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