lldb/source/Interpreter/OptionGroupFormat.cpp

   1 //===-- OptionGroupFormat.cpp ---------------------------------------------===//
   2 //
   3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
   4 // See https://llvm.org/LICENSE.txt for license information.
   5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
   6 //
   7 //===----------------------------------------------------------------------===//
   8
   9 #include "lldb/Interpreter/OptionGroupFormat.h"
  10
  11 #include "lldb/Host/OptionParser.h"
  12 #include "lldb/Interpreter/CommandInterpreter.h"
  13 #include "lldb/Target/ExecutionContext.h"
  14 #include "lldb/Target/Target.h"
  15
  16 using namespace lldb;
  17 using namespace lldb_private;
  18
  19 static constexpr OptionDefinition g_default_option_definitions[] = {
  20     {LLDB_OPT_SET_1, false, "format", 'f', OptionParser::eRequiredArgument,
  21      nullptr, {}, 0, eArgTypeFormat,
  22      "Specify a format to be used for display."},
  23     {LLDB_OPT_SET_2, false, "gdb-format", 'G', OptionParser::eRequiredArgument,
  24      nullptr, {}, 0, eArgTypeGDBFormat,
  25      "Specify a format using a GDB format specifier string."},
  26     {LLDB_OPT_SET_3, false, "size", 's', OptionParser::eRequiredArgument,
  27      nullptr, {}, 0, eArgTypeByteSize,
  28      "The size in bytes to use when displaying with the selected format."},
  29     {LLDB_OPT_SET_4, false, "count", 'c', OptionParser::eRequiredArgument,
  30      nullptr, {}, 0, eArgTypeCount,
  31      "The number of total items to display."},
  32 };
  33
  34 OptionGroupFormat::OptionGroupFormat(
  35     lldb::Format default_format, uint64_t default_byte_size,
  36     uint64_t default_count, OptionGroupFormatUsageTextVector usage_text_vector)
  37     : m_format(default_format, default_format),
  38       m_byte_size(default_byte_size, default_byte_size),
  39       m_count(default_count, default_count), m_prev_gdb_format('x'),
  40       m_prev_gdb_size('w'), m_has_gdb_format(false) {
  41   // Copy the default option definitions.
  42   std::copy(std::begin(g_default_option_definitions),
  43             std::end(g_default_option_definitions),
  44             std::begin(m_option_definitions));
  45
  46   for (auto usage_text_tuple : usage_text_vector) {
  47     switch (std::get<0>(usage_text_tuple)) {
  48     case eArgTypeFormat:
  49       m_option_definitions[0].usage_text = std::get<1>(usage_text_tuple);
  50       break;
  51     case eArgTypeByteSize:
  52       m_option_definitions[2].usage_text = std::get<1>(usage_text_tuple);
  53       break;
  54     default:
  55       llvm_unreachable("Unimplemented option");
  56     }
  57   }
  58 }
  59
  60 llvm::ArrayRef<OptionDefinition> OptionGroupFormat::GetDefinitions() {
  61   auto result = llvm::ArrayRef(m_option_definitions);
  62   if (m_byte_size.GetDefaultValue() < UINT64_MAX) {
  63     if (m_count.GetDefaultValue() < UINT64_MAX)
  64       return result;
  65     else
  66       return result.take_front(3);
  67   }
  68   return result.take_front(2);
  69 }
  70
  71 Status OptionGroupFormat::SetOptionValue(uint32_t option_idx,
  72                                          llvm::StringRef option_arg,
  73                                          ExecutionContext *execution_context) {
  74   Status error;
  75   const int short_option = m_option_definitions[option_idx].short_option;
  76
  77   switch (short_option) {
  78   case 'f':
  79     error = m_format.SetValueFromString(option_arg);
  80     break;
  81
  82   case 'c':
  83     if (m_count.GetDefaultValue() == 0) {
  84       error.SetErrorString("--count option is disabled");
  85     } else {
  86       error = m_count.SetValueFromString(option_arg);
  87       if (m_count.GetCurrentValue() == 0)
  88         error.SetErrorStringWithFormat("invalid --count option value '%s'",
  89                                        option_arg.str().c_str());
  90     }
  91     break;
  92
  93   case 's':
  94     if (m_byte_size.GetDefaultValue() == 0) {
  95       error.SetErrorString("--size option is disabled");
  96     } else {
  97       error = m_byte_size.SetValueFromString(option_arg);
  98       if (m_byte_size.GetCurrentValue() == 0)
  99         error.SetErrorStringWithFormat("invalid --size option value '%s'",
 100                                        option_arg.str().c_str());
 101     }
 102     break;
 103
 104   case 'G': {
 105     uint64_t count = 0;
 106     llvm::StringRef gdb_format_str = option_arg;
 107     gdb_format_str.consumeInteger(0, count);
 108
 109     Format format = eFormatDefault;
 110     uint32_t byte_size = 0;
 111
 112     while (!gdb_format_str.empty() &&
 113            ParserGDBFormatLetter(execution_context, gdb_format_str[0], format,
 114                                  byte_size)) {
 115       gdb_format_str = gdb_format_str.drop_front();
 116     }
 117
 118     // We the first character of the "gdb_format_str" is not the
 119     // NULL terminator, we didn't consume the entire string and
 120     // something is wrong. Also, if none of the format, size or count was
 121     // specified correctly, then abort.
 122     if (!gdb_format_str.empty() ||
 123         (format == eFormatInvalid && byte_size == 0 && count == 0)) {
 124       // Nothing got set correctly
 125       error.SetErrorStringWithFormat("invalid gdb format string '%s'",
 126                                      option_arg.str().c_str());
 127       return error;
 128     }
 129
 130     // At least one of the format, size or count was set correctly. Anything
 131     // that wasn't set correctly should be set to the previous default
 132     if (format == eFormatInvalid)
 133       ParserGDBFormatLetter(execution_context, m_prev_gdb_format, format,
 134                             byte_size);
 135
 136     const bool byte_size_enabled = m_byte_size.GetDefaultValue() < UINT64_MAX;
 137     const bool count_enabled = m_count.GetDefaultValue() < UINT64_MAX;
 138     if (byte_size_enabled) {
 139       // Byte size is enabled
 140       if (byte_size == 0)
 141         ParserGDBFormatLetter(execution_context, m_prev_gdb_size, format,
 142                               byte_size);
 143     } else {
 144       // Byte size is disabled, make sure it wasn't specified but if this is an
 145       // address, it's actually necessary to specify one so don't error out
 146       if (byte_size > 0 && format != lldb::eFormatAddressInfo) {
 147         error.SetErrorString(
 148             "this command doesn't support specifying a byte size");
 149         return error;
 150       }
 151     }
 152
 153     if (count_enabled) {
 154       // Count is enabled and was not set, set it to the default for gdb format
 155       // statements (which is 1).
 156       if (count == 0)
 157         count = 1;
 158     } else {
 159       // Count is disabled, make sure it wasn't specified
 160       if (count > 0) {
 161         error.SetErrorString("this command doesn't support specifying a count");
 162         return error;
 163       }
 164     }
 165
 166     m_format.SetCurrentValue(format);
 167     m_format.SetOptionWasSet();
 168     if (byte_size_enabled) {
 169       m_byte_size.SetCurrentValue(byte_size);
 170       m_byte_size.SetOptionWasSet();
 171     }
 172     if (count_enabled) {
 173       m_count.SetCurrentValue(count);
 174       m_count.SetOptionWasSet();
 175     }
 176   } break;
 177
 178   default:
 179     llvm_unreachable("Unimplemented option");
 180   }
 181
 182   return error;
 183 }
 184
 185 bool OptionGroupFormat::ParserGDBFormatLetter(
 186     ExecutionContext *execution_context, char format_letter, Format &format,
 187     uint32_t &byte_size) {
 188   m_has_gdb_format = true;
 189   switch (format_letter) {
 190   case 'o':
 191     format = eFormatOctal;
 192     m_prev_gdb_format = format_letter;
 193     return true;
 194   case 'x':
 195     format = eFormatHex;
 196     m_prev_gdb_format = format_letter;
 197     return true;
 198   case 'd':
 199     format = eFormatDecimal;
 200     m_prev_gdb_format = format_letter;
 201     return true;
 202   case 'u':
 203     format = eFormatUnsigned;
 204     m_prev_gdb_format = format_letter;
 205     return true;
 206   case 't':
 207     format = eFormatBinary;
 208     m_prev_gdb_format = format_letter;
 209     return true;
 210   case 'f':
 211     format = eFormatFloat;
 212     m_prev_gdb_format = format_letter;
 213     return true;
 214   case 'a':
 215     format = eFormatAddressInfo;
 216     {
 217       TargetSP target_sp =
 218           execution_context ? execution_context->GetTargetSP() : TargetSP();
 219       if (target_sp)
 220         byte_size = target_sp->GetArchitecture().GetAddressByteSize();
 221       m_prev_gdb_format = format_letter;
 222       return true;
 223     }
 224   case 'i':
 225     format = eFormatInstruction;
 226     m_prev_gdb_format = format_letter;
 227     return true;
 228   case 'c':
 229     format = eFormatChar;
 230     m_prev_gdb_format = format_letter;
 231     return true;
 232   case 's':
 233     format = eFormatCString;
 234     m_prev_gdb_format = format_letter;
 235     return true;
 236   case 'T':
 237     format = eFormatOSType;
 238     m_prev_gdb_format = format_letter;
 239     return true;
 240   case 'A':
 241     format = eFormatHexFloat;
 242     m_prev_gdb_format = format_letter;
 243     return true;
 244
 245   case 'b':
 246   case 'h':
 247   case 'w':
 248   case 'g':
 249     {
 250       // Size isn't used for printing instructions, so if a size is specified,
 251       // and the previous format was 'i', then we should reset it to the
 252       // default ('x').  Otherwise we'll continue to print as instructions,
 253       // which isn't expected.
 254       if (format_letter == 'b')
 255           byte_size = 1;
 256       else if (format_letter == 'h')
 257           byte_size = 2;
 258       else if (format_letter == 'w')
 259           byte_size = 4;
 260       else if (format_letter == 'g')
 261           byte_size = 8;
 262
 263         m_prev_gdb_size = format_letter;
 264         if (m_prev_gdb_format == 'i')
 265           m_prev_gdb_format = 'x';
 266         return true;
 267     }
 268     break;
 269   default:
 270     break;
 271   }
 272
 273
 274   return false;
 275 }
 276
 277 void OptionGroupFormat::OptionParsingStarting(
 278     ExecutionContext *execution_context) {
 279   m_format.Clear();
 280   m_byte_size.Clear();
 281   m_count.Clear();
 282   m_has_gdb_format = false;
 283 }