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 = Status::FromErrorString("--count option is disabled");
  85     } else {
  86       error = m_count.SetValueFromString(option_arg);
  87       if (m_count.GetCurrentValue() == 0)
  88         error = Status::FromErrorStringWithFormat(
  89             "invalid --count option value '%s'", option_arg.str().c_str());
  90     }
  91     break;
  92
  93   case 's':
  94     if (m_byte_size.GetDefaultValue() == 0) {
  95       error = Status::FromErrorString("--size option is disabled");
  96     } else {
  97       error = m_byte_size.SetValueFromString(option_arg);
  98       if (m_byte_size.GetCurrentValue() == 0)
  99         error = Status::FromErrorStringWithFormat(
 100             "invalid --size option value '%s'", 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 = Status::FromErrorStringWithFormat(
 126           "invalid gdb format string '%s'", 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 = Status::FromErrorString(
 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 = Status::FromErrorString(
 162             "this command doesn't support specifying a count");
 163         return error;
 164       }
 165     }
 166
 167     m_format.SetCurrentValue(format);
 168     m_format.SetOptionWasSet();
 169     if (byte_size_enabled) {
 170       m_byte_size.SetCurrentValue(byte_size);
 171       m_byte_size.SetOptionWasSet();
 172     }
 173     if (count_enabled) {
 174       m_count.SetCurrentValue(count);
 175       m_count.SetOptionWasSet();
 176     }
 177   } break;
 178
 179   default:
 180     llvm_unreachable("Unimplemented option");
 181   }
 182
 183   return error;
 184 }
 185
 186 bool OptionGroupFormat::ParserGDBFormatLetter(
 187     ExecutionContext *execution_context, char format_letter, Format &format,
 188     uint32_t &byte_size) {
 189   m_has_gdb_format = true;
 190   switch (format_letter) {
 191   case 'o':
 192     format = eFormatOctal;
 193     m_prev_gdb_format = format_letter;
 194     return true;
 195   case 'x':
 196     format = eFormatHex;
 197     m_prev_gdb_format = format_letter;
 198     return true;
 199   case 'd':
 200     format = eFormatDecimal;
 201     m_prev_gdb_format = format_letter;
 202     return true;
 203   case 'u':
 204     format = eFormatUnsigned;
 205     m_prev_gdb_format = format_letter;
 206     return true;
 207   case 't':
 208     format = eFormatBinary;
 209     m_prev_gdb_format = format_letter;
 210     return true;
 211   case 'f':
 212     format = eFormatFloat;
 213     m_prev_gdb_format = format_letter;
 214     return true;
 215   case 'a':
 216     format = eFormatAddressInfo;
 217     {
 218       TargetSP target_sp =
 219           execution_context ? execution_context->GetTargetSP() : TargetSP();
 220       if (target_sp)
 221         byte_size = target_sp->GetArchitecture().GetAddressByteSize();
 222       m_prev_gdb_format = format_letter;
 223       return true;
 224     }
 225   case 'i':
 226     format = eFormatInstruction;
 227     m_prev_gdb_format = format_letter;
 228     return true;
 229   case 'c':
 230     format = eFormatChar;
 231     m_prev_gdb_format = format_letter;
 232     return true;
 233   case 's':
 234     format = eFormatCString;
 235     m_prev_gdb_format = format_letter;
 236     return true;
 237   case 'T':
 238     format = eFormatOSType;
 239     m_prev_gdb_format = format_letter;
 240     return true;
 241   case 'A':
 242     format = eFormatHexFloat;
 243     m_prev_gdb_format = format_letter;
 244     return true;
 245
 246   case 'b':
 247   case 'h':
 248   case 'w':
 249   case 'g':
 250     {
 251       // Size isn't used for printing instructions, so if a size is specified,
 252       // and the previous format was 'i', then we should reset it to the
 253       // default ('x').  Otherwise we'll continue to print as instructions,
 254       // which isn't expected.
 255       if (format_letter == 'b')
 256           byte_size = 1;
 257       else if (format_letter == 'h')
 258           byte_size = 2;
 259       else if (format_letter == 'w')
 260           byte_size = 4;
 261       else if (format_letter == 'g')
 262           byte_size = 8;
 263
 264         m_prev_gdb_size = format_letter;
 265         if (m_prev_gdb_format == 'i')
 266           m_prev_gdb_format = 'x';
 267         return true;
 268     }
 269     break;
 270   default:
 271     break;
 272   }
 273
 274
 275   return false;
 276 }
 277
 278 void OptionGroupFormat::OptionParsingStarting(
 279     ExecutionContext *execution_context) {
 280   m_format.Clear();
 281   m_byte_size.Clear();
 282   m_count.Clear();
 283   m_has_gdb_format = false;
 284 }