1 //===-- CommandObjectExpression.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 "CommandObjectExpression.h" 11 12 // C Includes 13 // C++ Includes 14 // Other libraries and framework includes 15 // Project includes 16 #include "lldb/Interpreter/Args.h" 17 #include "lldb/Core/Value.h" 18 #include "lldb/Core/InputReader.h" 19 #include "lldb/Core/ValueObjectVariable.h" 20 #include "lldb/Expression/ClangExpressionVariable.h" 21 #include "lldb/Expression/ClangUserExpression.h" 22 #include "lldb/Expression/ClangFunction.h" 23 #include "lldb/Expression/DWARFExpression.h" 24 #include "lldb/Host/Host.h" 25 #include "lldb/Core/Debugger.h" 26 #include "lldb/Interpreter/CommandInterpreter.h" 27 #include "lldb/Interpreter/CommandReturnObject.h" 28 #include "lldb/Target/ObjCLanguageRuntime.h" 29 #include "lldb/Symbol/ObjectFile.h" 30 #include "lldb/Symbol/Variable.h" 31 #include "lldb/Target/Process.h" 32 #include "lldb/Target/StackFrame.h" 33 #include "lldb/Target/Target.h" 34 #include "llvm/ADT/StringRef.h" 35 36 using namespace lldb; 37 using namespace lldb_private; 38 39 CommandObjectExpression::CommandOptions::CommandOptions () : 40 Options() 41 { 42 // Keep only one place to reset the values to their defaults 43 ResetOptionValues(); 44 } 45 46 47 CommandObjectExpression::CommandOptions::~CommandOptions () 48 { 49 } 50 51 Error 52 CommandObjectExpression::CommandOptions::SetOptionValue (int option_idx, const char *option_arg) 53 { 54 Error error; 55 56 char short_option = (char) m_getopt_table[option_idx].val; 57 58 switch (short_option) 59 { 60 //case 'l': 61 //if (language.SetLanguageFromCString (option_arg) == false) 62 //{ 63 // error.SetErrorStringWithFormat("Invalid language option argument '%s'.\n", option_arg); 64 //} 65 //break; 66 67 case 'g': 68 debug = true; 69 break; 70 71 case 'f': 72 error = Args::StringToFormat(option_arg, format); 73 break; 74 75 case 'o': 76 print_object = true; 77 break; 78 79 default: 80 error.SetErrorStringWithFormat("Invalid short option character '%c'.\n", short_option); 81 break; 82 } 83 84 return error; 85 } 86 87 void 88 CommandObjectExpression::CommandOptions::ResetOptionValues () 89 { 90 Options::ResetOptionValues(); 91 //language.Clear(); 92 debug = false; 93 format = eFormatDefault; 94 print_object = false; 95 show_types = true; 96 show_summary = true; 97 } 98 99 const lldb::OptionDefinition* 100 CommandObjectExpression::CommandOptions::GetDefinitions () 101 { 102 return g_option_table; 103 } 104 105 CommandObjectExpression::CommandObjectExpression (CommandInterpreter &interpreter) : 106 CommandObject (interpreter, 107 "expression", 108 "Evaluate a C/ObjC/C++ expression in the current program context, using variables currently in scope.", 109 NULL), 110 m_expr_line_count (0), 111 m_expr_lines () 112 { 113 SetHelpLong( 114 "Examples: \n\ 115 \n\ 116 expr my_struct->a = my_array[3] \n\ 117 expr -f bin -- (index * 8) + 5 \n\ 118 expr char c[] = \"foo\"; c[0]\n"); 119 120 CommandArgumentEntry arg; 121 CommandArgumentData expression_arg; 122 123 // Define the first (and only) variant of this arg. 124 expression_arg.arg_type = eArgTypeExpression; 125 expression_arg.arg_repetition = eArgRepeatPlain; 126 127 // There is only one variant this argument could be; put it into the argument entry. 128 arg.push_back (expression_arg); 129 130 // Push the data for the first argument into the m_arguments vector. 131 m_arguments.push_back (arg); 132 } 133 134 CommandObjectExpression::~CommandObjectExpression () 135 { 136 } 137 138 Options * 139 CommandObjectExpression::GetOptions () 140 { 141 return &m_options; 142 } 143 144 145 bool 146 CommandObjectExpression::Execute 147 ( 148 Args& command, 149 CommandReturnObject &result 150 ) 151 { 152 return false; 153 } 154 155 156 size_t 157 CommandObjectExpression::MultiLineExpressionCallback 158 ( 159 void *baton, 160 InputReader &reader, 161 lldb::InputReaderAction notification, 162 const char *bytes, 163 size_t bytes_len 164 ) 165 { 166 CommandObjectExpression *cmd_object_expr = (CommandObjectExpression *) baton; 167 168 switch (notification) 169 { 170 case eInputReaderActivate: 171 reader.GetDebugger().GetOutputStream().Printf("%s\n", "Enter expressions, then terminate with an empty line to evaluate:"); 172 // Fall through 173 case eInputReaderReactivate: 174 //if (out_fh) 175 // reader.GetDebugger().GetOutputStream().Printf ("%3u: ", cmd_object_expr->m_expr_line_count); 176 break; 177 178 case eInputReaderDeactivate: 179 break; 180 181 case eInputReaderGotToken: 182 ++cmd_object_expr->m_expr_line_count; 183 if (bytes && bytes_len) 184 { 185 cmd_object_expr->m_expr_lines.append (bytes, bytes_len + 1); 186 } 187 188 if (bytes_len == 0) 189 reader.SetIsDone(true); 190 //else if (out_fh && !reader->IsDone()) 191 // ::fprintf (out_fh, "%3u: ", cmd_object_expr->m_expr_line_count); 192 break; 193 194 case eInputReaderDone: 195 { 196 bool bare = false; 197 cmd_object_expr->EvaluateExpression (cmd_object_expr->m_expr_lines.c_str(), 198 bare, 199 reader.GetDebugger().GetOutputStream(), 200 reader.GetDebugger().GetErrorStream()); 201 } 202 break; 203 } 204 205 return bytes_len; 206 } 207 208 bool 209 CommandObjectExpression::EvaluateExpression 210 ( 211 const char *expr, 212 bool bare, 213 Stream &output_stream, 214 Stream &error_stream, 215 CommandReturnObject *result 216 ) 217 { 218 if (!m_exe_ctx.process) 219 { 220 error_stream.Printf ("Execution context doesn't contain a process\n"); 221 return false; 222 } 223 224 if (!m_exe_ctx.process->GetDynamicCheckers()) 225 { 226 DynamicCheckerFunctions *dynamic_checkers = new DynamicCheckerFunctions(); 227 228 StreamString install_errors; 229 230 if (!dynamic_checkers->Install(install_errors, m_exe_ctx)) 231 { 232 error_stream.Printf("Couldn't install dynamic checkers into the execution context: %s\n", install_errors.GetData()); 233 return false; 234 } 235 236 m_exe_ctx.process->SetDynamicCheckers(dynamic_checkers); 237 } 238 239 ClangUserExpression user_expression (expr); 240 241 if (!user_expression.Parse (error_stream, m_exe_ctx)) 242 { 243 error_stream.Printf ("Couldn't parse the expresssion\n"); 244 return false; 245 } 246 247 ClangExpressionVariable *expr_result = NULL; 248 249 if (!user_expression.Execute (error_stream, m_exe_ctx, expr_result)) 250 { 251 error_stream.Printf ("Couldn't execute the expresssion\n"); 252 return false; 253 } 254 255 if (expr_result) 256 { 257 // TODO: seems weird to get a pointer to a result object back from 258 // a function. Do we own it? Feels like we do, but from looking at the 259 // code we don't. Might be best to make this a reference and state 260 // explicitly that we don't own it when we get a reference back from 261 // the execute? 262 lldb::ValueObjectSP valobj_sp (expr_result->GetExpressionResult (&m_exe_ctx)); 263 if (valobj_sp) 264 { 265 ValueObject::DumpValueObject (output_stream, 266 m_exe_ctx.GetBestExecutionContextScope(), 267 valobj_sp.get(), // Variable object to dump 268 expr_result->m_name.c_str(),// Root object name 269 0, // Pointer depth to traverse (zero means stop at pointers) 270 0, // Current depth, this is the top most, so zero... 271 UINT32_MAX, // Max depth to go when dumping concrete types, dump everything... 272 m_options.show_types, // Show types when dumping? 273 false, // Show locations of variables, no since this is a host address which we don't care to see 274 m_options.print_object, // Print the objective C object? 275 true); // Scope is already checked. Const results are always in scope. 276 output_stream.EOL(); 277 } 278 else 279 { 280 error_stream.PutCString ("Couldn't extract expression result"); 281 } 282 if (result) 283 result->SetStatus (eReturnStatusSuccessFinishResult); 284 } 285 else 286 { 287 if (result) 288 result->SetStatus (eReturnStatusSuccessFinishNoResult); 289 } 290 291 return true; 292 } 293 294 bool 295 CommandObjectExpression::ExecuteRawCommandString 296 ( 297 const char *command, 298 CommandReturnObject &result 299 ) 300 { 301 m_exe_ctx = m_interpreter.GetDebugger().GetExecutionContext(); 302 303 m_options.ResetOptionValues(); 304 305 const char * expr = NULL; 306 307 if (command[0] == '\0') 308 { 309 m_expr_lines.clear(); 310 m_expr_line_count = 0; 311 312 InputReaderSP reader_sp (new InputReader(m_interpreter.GetDebugger())); 313 if (reader_sp) 314 { 315 Error err (reader_sp->Initialize (CommandObjectExpression::MultiLineExpressionCallback, 316 this, // baton 317 eInputReaderGranularityLine, // token size, to pass to callback function 318 NULL, // end token 319 NULL, // prompt 320 true)); // echo input 321 if (err.Success()) 322 { 323 m_interpreter.GetDebugger().PushInputReader (reader_sp); 324 result.SetStatus (eReturnStatusSuccessFinishNoResult); 325 } 326 else 327 { 328 result.AppendError (err.AsCString()); 329 result.SetStatus (eReturnStatusFailed); 330 } 331 } 332 else 333 { 334 result.AppendError("out of memory"); 335 result.SetStatus (eReturnStatusFailed); 336 } 337 return result.Succeeded(); 338 } 339 340 if (command[0] == '-') 341 { 342 // We have some options and these options MUST end with --. 343 const char *end_options = NULL; 344 const char *s = command; 345 while (s && s[0]) 346 { 347 end_options = ::strstr (s, "--"); 348 if (end_options) 349 { 350 end_options += 2; // Get past the "--" 351 if (::isspace (end_options[0])) 352 { 353 expr = end_options; 354 while (::isspace (*expr)) 355 ++expr; 356 break; 357 } 358 } 359 s = end_options; 360 } 361 362 if (end_options) 363 { 364 Args args (command, end_options - command); 365 if (!ParseOptions (args, result)) 366 return false; 367 } 368 } 369 370 if (expr == NULL) 371 expr = command; 372 373 if (EvaluateExpression (expr, false, result.GetOutputStream(), result.GetErrorStream(), &result)) 374 return true; 375 376 result.SetStatus (eReturnStatusFailed); 377 return false; 378 } 379 380 lldb::OptionDefinition 381 CommandObjectExpression::CommandOptions::g_option_table[] = 382 { 383 //{ LLDB_OPT_SET_ALL, false, "language", 'l', required_argument, NULL, 0, "[c|c++|objc|objc++]", "Sets the language to use when parsing the expression."}, 384 //{ LLDB_OPT_SET_1, false, "format", 'f', required_argument, NULL, 0, "[ [bool|b] | [bin] | [char|c] | [oct|o] | [dec|i|d|u] | [hex|x] | [float|f] | [cstr|s] ]", "Specify the format that the expression output should use."}, 385 { LLDB_OPT_SET_1, false, "format", 'f', required_argument, NULL, 0, eArgTypeExprFormat, "Specify the format that the expression output should use."}, 386 { LLDB_OPT_SET_2, false, "object-description", 'o', no_argument, NULL, 0, eArgTypeNone, "Print the object description of the value resulting from the expression"}, 387 { LLDB_OPT_SET_ALL, false, "debug", 'g', no_argument, NULL, 0, eArgTypeNone, "Enable verbose debug logging of the expression parsing and evaluation."}, 388 { LLDB_OPT_SET_ALL, false, "use-ir", 'i', no_argument, NULL, 0, eArgTypeNone, "[Temporary] Instructs the expression evaluator to use IR instead of ASTs."}, 389 { 0, false, NULL, 0, 0, NULL, NULL, eArgTypeNone, NULL } 390 }; 391 392