1 //===-- OptionArgParser.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/OptionArgParser.h"
10 #include "lldb/DataFormatters/FormatManager.h"
11 #include "lldb/Target/ABI.h"
12 #include "lldb/Target/Target.h"
13 #include "lldb/Utility/Status.h"
14 #include "lldb/Utility/StreamString.h"
15 
16 using namespace lldb_private;
17 using namespace lldb;
18 
19 bool OptionArgParser::ToBoolean(llvm::StringRef ref, bool fail_value,
20                                 bool *success_ptr) {
21   if (success_ptr)
22     *success_ptr = true;
23   ref = ref.trim();
24   if (ref.equals_insensitive("false") || ref.equals_insensitive("off") ||
25       ref.equals_insensitive("no") || ref.equals_insensitive("0")) {
26     return false;
27   } else if (ref.equals_insensitive("true") || ref.equals_insensitive("on") ||
28              ref.equals_insensitive("yes") || ref.equals_insensitive("1")) {
29     return true;
30   }
31   if (success_ptr)
32     *success_ptr = false;
33   return fail_value;
34 }
35 
36 char OptionArgParser::ToChar(llvm::StringRef s, char fail_value,
37                              bool *success_ptr) {
38   if (success_ptr)
39     *success_ptr = false;
40   if (s.size() != 1)
41     return fail_value;
42 
43   if (success_ptr)
44     *success_ptr = true;
45   return s[0];
46 }
47 
48 int64_t OptionArgParser::ToOptionEnum(llvm::StringRef s,
49                                       const OptionEnumValues &enum_values,
50                                       int32_t fail_value, Status &error) {
51   error.Clear();
52   if (enum_values.empty()) {
53     error.SetErrorString("invalid enumeration argument");
54     return fail_value;
55   }
56 
57   if (s.empty()) {
58     error.SetErrorString("empty enumeration string");
59     return fail_value;
60   }
61 
62   for (const auto &enum_value : enum_values) {
63     llvm::StringRef this_enum(enum_value.string_value);
64     if (this_enum.startswith(s))
65       return enum_value.value;
66   }
67 
68   StreamString strm;
69   strm.PutCString("invalid enumeration value, valid values are: ");
70   bool is_first = true;
71   for (const auto &enum_value : enum_values) {
72     strm.Printf("%s\"%s\"",
73         is_first ? is_first = false,"" : ", ", enum_value.string_value);
74   }
75   error.SetErrorString(strm.GetString());
76   return fail_value;
77 }
78 
79 Status OptionArgParser::ToFormat(const char *s, lldb::Format &format,
80                                  size_t *byte_size_ptr) {
81   format = eFormatInvalid;
82   Status error;
83 
84   if (s && s[0]) {
85     if (byte_size_ptr) {
86       if (isdigit(s[0])) {
87         char *format_char = nullptr;
88         unsigned long byte_size = ::strtoul(s, &format_char, 0);
89         if (byte_size != ULONG_MAX)
90           *byte_size_ptr = byte_size;
91         s = format_char;
92       } else
93         *byte_size_ptr = 0;
94     }
95 
96     const bool partial_match_ok = true;
97     if (!FormatManager::GetFormatFromCString(s, partial_match_ok, format)) {
98       StreamString error_strm;
99       error_strm.Printf(
100           "Invalid format character or name '%s'. Valid values are:\n", s);
101       for (Format f = eFormatDefault; f < kNumFormats; f = Format(f + 1)) {
102         char format_char = FormatManager::GetFormatAsFormatChar(f);
103         if (format_char)
104           error_strm.Printf("'%c' or ", format_char);
105 
106         error_strm.Printf("\"%s\"", FormatManager::GetFormatAsCString(f));
107         error_strm.EOL();
108       }
109 
110       if (byte_size_ptr)
111         error_strm.PutCString(
112             "An optional byte size can precede the format character.\n");
113       error.SetErrorString(error_strm.GetString());
114     }
115 
116     if (error.Fail())
117       return error;
118   } else {
119     error.SetErrorStringWithFormat("%s option string", s ? "empty" : "invalid");
120   }
121   return error;
122 }
123 
124 lldb::ScriptLanguage OptionArgParser::ToScriptLanguage(
125     llvm::StringRef s, lldb::ScriptLanguage fail_value, bool *success_ptr) {
126   if (success_ptr)
127     *success_ptr = true;
128 
129   if (s.equals_insensitive("python"))
130     return eScriptLanguagePython;
131   if (s.equals_insensitive("lua"))
132     return eScriptLanguageLua;
133   if (s.equals_insensitive("default"))
134     return eScriptLanguageDefault;
135   if (s.equals_insensitive("none"))
136     return eScriptLanguageNone;
137 
138   if (success_ptr)
139     *success_ptr = false;
140   return fail_value;
141 }
142 
143 lldb::addr_t OptionArgParser::ToRawAddress(const ExecutionContext *exe_ctx,
144                                            llvm::StringRef s,
145                                            lldb::addr_t fail_value,
146                                            Status *error_ptr) {
147   std::optional<lldb::addr_t> maybe_addr = DoToAddress(exe_ctx, s, error_ptr);
148   return maybe_addr ? *maybe_addr : fail_value;
149 }
150 
151 lldb::addr_t OptionArgParser::ToAddress(const ExecutionContext *exe_ctx,
152                                         llvm::StringRef s,
153                                         lldb::addr_t fail_value,
154                                         Status *error_ptr) {
155   std::optional<lldb::addr_t> maybe_addr = DoToAddress(exe_ctx, s, error_ptr);
156   if (!maybe_addr)
157     return fail_value;
158 
159   lldb::addr_t addr = *maybe_addr;
160 
161   if (Process *process = exe_ctx->GetProcessPtr())
162     if (ABISP abi_sp = process->GetABI())
163       addr = abi_sp->FixCodeAddress(addr);
164 
165   return addr;
166 }
167 
168 std::optional<lldb::addr_t>
169 OptionArgParser::DoToAddress(const ExecutionContext *exe_ctx, llvm::StringRef s,
170                              Status *error_ptr) {
171   bool error_set = false;
172   if (s.empty()) {
173     if (error_ptr)
174       error_ptr->SetErrorStringWithFormat("invalid address expression \"%s\"",
175                                           s.str().c_str());
176     return {};
177   }
178 
179   llvm::StringRef sref = s;
180 
181   lldb::addr_t addr = LLDB_INVALID_ADDRESS;
182   if (!s.getAsInteger(0, addr)) {
183     if (error_ptr)
184       error_ptr->Clear();
185 
186     return addr;
187   }
188 
189   // Try base 16 with no prefix...
190   if (!s.getAsInteger(16, addr)) {
191     if (error_ptr)
192       error_ptr->Clear();
193     return addr;
194   }
195 
196   Target *target = nullptr;
197   if (!exe_ctx || !(target = exe_ctx->GetTargetPtr())) {
198     if (error_ptr)
199       error_ptr->SetErrorStringWithFormat("invalid address expression \"%s\"",
200                                           s.str().c_str());
201     return {};
202   }
203 
204   lldb::ValueObjectSP valobj_sp;
205   EvaluateExpressionOptions options;
206   options.SetCoerceToId(false);
207   options.SetUnwindOnError(true);
208   options.SetKeepInMemory(false);
209   options.SetTryAllThreads(true);
210 
211   ExpressionResults expr_result =
212       target->EvaluateExpression(s, exe_ctx->GetFramePtr(), valobj_sp, options);
213 
214   bool success = false;
215   if (expr_result == eExpressionCompleted) {
216     if (valobj_sp)
217       valobj_sp = valobj_sp->GetQualifiedRepresentationIfAvailable(
218           valobj_sp->GetDynamicValueType(), true);
219     // Get the address to watch.
220     if (valobj_sp)
221       addr = valobj_sp->GetValueAsUnsigned(0, &success);
222     if (success) {
223       if (error_ptr)
224         error_ptr->Clear();
225       return addr;
226     } else {
227       if (error_ptr) {
228         error_set = true;
229         error_ptr->SetErrorStringWithFormat(
230             "address expression \"%s\" resulted in a value whose type "
231             "can't be converted to an address: %s",
232             s.str().c_str(), valobj_sp->GetTypeName().GetCString());
233       }
234     }
235 
236   } else {
237     // Since the compiler can't handle things like "main + 12" we should try to
238     // do this for now. The compiler doesn't like adding offsets to function
239     // pointer types.
240     static RegularExpression g_symbol_plus_offset_regex(
241         "^(.*)([-\\+])[[:space:]]*(0x[0-9A-Fa-f]+|[0-9]+)[[:space:]]*$");
242 
243     llvm::SmallVector<llvm::StringRef, 4> matches;
244     if (g_symbol_plus_offset_regex.Execute(sref, &matches)) {
245       uint64_t offset = 0;
246       std::string name = matches[1].str();
247       std::string sign = matches[2].str();
248       std::string str_offset = matches[3].str();
249       if (!llvm::StringRef(str_offset).getAsInteger(0, offset)) {
250         Status error;
251         addr = ToAddress(exe_ctx, name.c_str(), LLDB_INVALID_ADDRESS, &error);
252         if (addr != LLDB_INVALID_ADDRESS) {
253           if (sign[0] == '+')
254             return addr + offset;
255           else
256             return addr - offset;
257         }
258       }
259     }
260 
261     if (error_ptr) {
262       error_set = true;
263       error_ptr->SetErrorStringWithFormat(
264           "address expression \"%s\" evaluation failed", s.str().c_str());
265     }
266   }
267 
268   if (error_ptr) {
269     if (!error_set)
270       error_ptr->SetErrorStringWithFormat("invalid address expression \"%s\"",
271                                           s.str().c_str());
272   }
273   return {};
274 }
275