contrib/llvm/tools/lldb/source/Interpreter/OptionGroupFormat.cpp

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