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 "lldb/lldb-python.h"
11
12 #include "CommandObjectExpression.h"
13
14 // C Includes
15 // C++ Includes
16 // Other libraries and framework includes
17 // Project includes
18 #include "lldb/Interpreter/Args.h"
19 #include "lldb/Core/Value.h"
20 #include "lldb/Core/InputReader.h"
21 #include "lldb/Core/ValueObjectVariable.h"
22 #include "lldb/Expression/ClangExpressionVariable.h"
23 #include "lldb/Expression/ClangUserExpression.h"
24 #include "lldb/Expression/ClangFunction.h"
25 #include "lldb/Expression/DWARFExpression.h"
26 #include "lldb/Host/Host.h"
27 #include "lldb/Core/Debugger.h"
28 #include "lldb/Interpreter/CommandInterpreter.h"
29 #include "lldb/Interpreter/CommandReturnObject.h"
30 #include "lldb/Target/ObjCLanguageRuntime.h"
31 #include "lldb/Symbol/ObjectFile.h"
32 #include "lldb/Symbol/Variable.h"
33 #include "lldb/Target/Process.h"
34 #include "lldb/Target/StackFrame.h"
35 #include "lldb/Target/Target.h"
36 #include "lldb/Target/Thread.h"
37 #include "llvm/ADT/StringRef.h"
38
39 using namespace lldb;
40 using namespace lldb_private;
41
CommandOptions()42 CommandObjectExpression::CommandOptions::CommandOptions () :
43 OptionGroup()
44 {
45 }
46
47
~CommandOptions()48 CommandObjectExpression::CommandOptions::~CommandOptions ()
49 {
50 }
51
52 OptionDefinition
53 CommandObjectExpression::CommandOptions::g_option_table[] =
54 {
55 { LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "all-threads", 'a', required_argument, NULL, 0, eArgTypeBoolean, "Should we run all threads if the execution doesn't complete on one thread."},
56 { LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "ignore-breakpoints", 'i', required_argument, NULL, 0, eArgTypeBoolean, "Ignore breakpoint hits while running expressions"},
57 { LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "timeout", 't', required_argument, NULL, 0, eArgTypeUnsignedInteger, "Timeout value (in microseconds) for running the expression."},
58 { LLDB_OPT_SET_1 | LLDB_OPT_SET_2, false, "unwind-on-error", 'u', required_argument, NULL, 0, eArgTypeBoolean, "Clean up program state if the expression causes a crash, or raises a signal. Note, unlike gdb hitting a breakpoint is controlled by another option (-i)."},
59 };
60
61
62 uint32_t
GetNumDefinitions()63 CommandObjectExpression::CommandOptions::GetNumDefinitions ()
64 {
65 return sizeof(g_option_table)/sizeof(OptionDefinition);
66 }
67
68 Error
SetOptionValue(CommandInterpreter & interpreter,uint32_t option_idx,const char * option_arg)69 CommandObjectExpression::CommandOptions::SetOptionValue (CommandInterpreter &interpreter,
70 uint32_t option_idx,
71 const char *option_arg)
72 {
73 Error error;
74
75 const int short_option = g_option_table[option_idx].short_option;
76
77 switch (short_option)
78 {
79 //case 'l':
80 //if (language.SetLanguageFromCString (option_arg) == false)
81 //{
82 // error.SetErrorStringWithFormat("invalid language option argument '%s'", option_arg);
83 //}
84 //break;
85
86 case 'a':
87 {
88 bool success;
89 bool result;
90 result = Args::StringToBoolean(option_arg, true, &success);
91 if (!success)
92 error.SetErrorStringWithFormat("invalid all-threads value setting: \"%s\"", option_arg);
93 else
94 try_all_threads = result;
95 }
96 break;
97
98 case 'i':
99 {
100 bool success;
101 bool tmp_value = Args::StringToBoolean(option_arg, true, &success);
102 if (success)
103 ignore_breakpoints = tmp_value;
104 else
105 error.SetErrorStringWithFormat("could not convert \"%s\" to a boolean value.", option_arg);
106 break;
107 }
108 case 't':
109 {
110 bool success;
111 uint32_t result;
112 result = Args::StringToUInt32(option_arg, 0, 0, &success);
113 if (success)
114 timeout = result;
115 else
116 error.SetErrorStringWithFormat ("invalid timeout setting \"%s\"", option_arg);
117 }
118 break;
119
120 case 'u':
121 {
122 bool success;
123 bool tmp_value = Args::StringToBoolean(option_arg, true, &success);
124 if (success)
125 unwind_on_error = tmp_value;
126 else
127 error.SetErrorStringWithFormat("could not convert \"%s\" to a boolean value.", option_arg);
128 break;
129 }
130 default:
131 error.SetErrorStringWithFormat("invalid short option character '%c'", short_option);
132 break;
133 }
134
135 return error;
136 }
137
138 void
OptionParsingStarting(CommandInterpreter & interpreter)139 CommandObjectExpression::CommandOptions::OptionParsingStarting (CommandInterpreter &interpreter)
140 {
141 Process *process = interpreter.GetExecutionContext().GetProcessPtr();
142 if (process != NULL)
143 {
144 ignore_breakpoints = process->GetIgnoreBreakpointsInExpressions();
145 unwind_on_error = process->GetUnwindOnErrorInExpressions();
146 }
147 else
148 {
149 ignore_breakpoints = false;
150 unwind_on_error = true;
151 }
152
153 show_summary = true;
154 try_all_threads = true;
155 timeout = 0;
156 }
157
158 const OptionDefinition*
GetDefinitions()159 CommandObjectExpression::CommandOptions::GetDefinitions ()
160 {
161 return g_option_table;
162 }
163
CommandObjectExpression(CommandInterpreter & interpreter)164 CommandObjectExpression::CommandObjectExpression (CommandInterpreter &interpreter) :
165 CommandObjectRaw (interpreter,
166 "expression",
167 "Evaluate a C/ObjC/C++ expression in the current program context, using user defined variables and variables currently in scope.",
168 NULL,
169 eFlagProcessMustBePaused | eFlagTryTargetAPILock),
170 m_option_group (interpreter),
171 m_format_options (eFormatDefault),
172 m_command_options (),
173 m_expr_line_count (0),
174 m_expr_lines ()
175 {
176 SetHelpLong(
177 "Timeouts:\n\
178 If the expression can be evaluated statically (without runnning code) then it will be.\n\
179 Otherwise, by default the expression will run on the current thread with a short timeout:\n\
180 currently .25 seconds. If it doesn't return in that time, the evaluation will be interrupted\n\
181 and resumed with all threads running. You can use the -a option to disable retrying on all\n\
182 threads. You can use the -t option to set a shorter timeout.\n\
183 \n\
184 User defined variables:\n\
185 You can define your own variables for convenience or to be used in subsequent expressions.\n\
186 You define them the same way you would define variables in C. If the first character of \n\
187 your user defined variable is a $, then the variable's value will be available in future\n\
188 expressions, otherwise it will just be available in the current expression.\n\
189 \n\
190 Examples: \n\
191 \n\
192 expr my_struct->a = my_array[3] \n\
193 expr -f bin -- (index * 8) + 5 \n\
194 expr unsigned int $foo = 5\n\
195 expr char c[] = \"foo\"; c[0]\n");
196
197 CommandArgumentEntry arg;
198 CommandArgumentData expression_arg;
199
200 // Define the first (and only) variant of this arg.
201 expression_arg.arg_type = eArgTypeExpression;
202 expression_arg.arg_repetition = eArgRepeatPlain;
203
204 // There is only one variant this argument could be; put it into the argument entry.
205 arg.push_back (expression_arg);
206
207 // Push the data for the first argument into the m_arguments vector.
208 m_arguments.push_back (arg);
209
210 // Add the "--format" and "--gdb-format"
211 m_option_group.Append (&m_format_options, OptionGroupFormat::OPTION_GROUP_FORMAT | OptionGroupFormat::OPTION_GROUP_GDB_FMT, LLDB_OPT_SET_1);
212 m_option_group.Append (&m_command_options);
213 m_option_group.Append (&m_varobj_options, LLDB_OPT_SET_ALL, LLDB_OPT_SET_1 | LLDB_OPT_SET_2);
214 m_option_group.Finalize();
215 }
216
~CommandObjectExpression()217 CommandObjectExpression::~CommandObjectExpression ()
218 {
219 }
220
221 Options *
GetOptions()222 CommandObjectExpression::GetOptions ()
223 {
224 return &m_option_group;
225 }
226
227 size_t
MultiLineExpressionCallback(void * baton,InputReader & reader,lldb::InputReaderAction notification,const char * bytes,size_t bytes_len)228 CommandObjectExpression::MultiLineExpressionCallback
229 (
230 void *baton,
231 InputReader &reader,
232 lldb::InputReaderAction notification,
233 const char *bytes,
234 size_t bytes_len
235 )
236 {
237 CommandObjectExpression *cmd_object_expr = (CommandObjectExpression *) baton;
238 bool batch_mode = reader.GetDebugger().GetCommandInterpreter().GetBatchCommandMode();
239
240 switch (notification)
241 {
242 case eInputReaderActivate:
243 if (!batch_mode)
244 {
245 StreamSP async_strm_sp(reader.GetDebugger().GetAsyncOutputStream());
246 if (async_strm_sp)
247 {
248 async_strm_sp->PutCString("Enter expressions, then terminate with an empty line to evaluate:\n");
249 async_strm_sp->Flush();
250 }
251 }
252 // Fall through
253 case eInputReaderReactivate:
254 break;
255
256 case eInputReaderDeactivate:
257 break;
258
259 case eInputReaderAsynchronousOutputWritten:
260 break;
261
262 case eInputReaderGotToken:
263 ++cmd_object_expr->m_expr_line_count;
264 if (bytes && bytes_len)
265 {
266 cmd_object_expr->m_expr_lines.append (bytes, bytes_len + 1);
267 }
268
269 if (bytes_len == 0)
270 reader.SetIsDone(true);
271 break;
272
273 case eInputReaderInterrupt:
274 cmd_object_expr->m_expr_lines.clear();
275 reader.SetIsDone (true);
276 if (!batch_mode)
277 {
278 StreamSP async_strm_sp (reader.GetDebugger().GetAsyncOutputStream());
279 if (async_strm_sp)
280 {
281 async_strm_sp->PutCString("Expression evaluation cancelled.\n");
282 async_strm_sp->Flush();
283 }
284 }
285 break;
286
287 case eInputReaderEndOfFile:
288 reader.SetIsDone (true);
289 break;
290
291 case eInputReaderDone:
292 if (cmd_object_expr->m_expr_lines.size() > 0)
293 {
294 StreamSP output_stream = reader.GetDebugger().GetAsyncOutputStream();
295 StreamSP error_stream = reader.GetDebugger().GetAsyncErrorStream();
296 cmd_object_expr->EvaluateExpression (cmd_object_expr->m_expr_lines.c_str(),
297 output_stream.get(),
298 error_stream.get());
299 output_stream->Flush();
300 error_stream->Flush();
301 }
302 break;
303 }
304
305 return bytes_len;
306 }
307
308 bool
EvaluateExpression(const char * expr,Stream * output_stream,Stream * error_stream,CommandReturnObject * result)309 CommandObjectExpression::EvaluateExpression
310 (
311 const char *expr,
312 Stream *output_stream,
313 Stream *error_stream,
314 CommandReturnObject *result
315 )
316 {
317 // Don't use m_exe_ctx as this might be called asynchronously
318 // after the command object DoExecute has finished when doing
319 // multi-line expression that use an input reader...
320 ExecutionContext exe_ctx (m_interpreter.GetExecutionContext());
321
322 Target *target = exe_ctx.GetTargetPtr();
323
324 if (!target)
325 target = Host::GetDummyTarget(m_interpreter.GetDebugger()).get();
326
327 if (target)
328 {
329 lldb::ValueObjectSP result_valobj_sp;
330
331 ExecutionResults exe_results;
332
333 bool keep_in_memory = true;
334
335 EvaluateExpressionOptions options;
336 options.SetCoerceToId(m_varobj_options.use_objc)
337 .SetUnwindOnError(m_command_options.unwind_on_error)
338 .SetIgnoreBreakpoints (m_command_options.ignore_breakpoints)
339 .SetKeepInMemory(keep_in_memory)
340 .SetUseDynamic(m_varobj_options.use_dynamic)
341 .SetRunOthers(m_command_options.try_all_threads)
342 .SetTimeoutUsec(m_command_options.timeout);
343
344 exe_results = target->EvaluateExpression (expr,
345 exe_ctx.GetFramePtr(),
346 result_valobj_sp,
347 options);
348
349 if (result_valobj_sp)
350 {
351 Format format = m_format_options.GetFormat();
352
353 if (result_valobj_sp->GetError().Success())
354 {
355 if (format != eFormatVoid)
356 {
357 if (format != eFormatDefault)
358 result_valobj_sp->SetFormat (format);
359
360 ValueObject::DumpValueObjectOptions options(m_varobj_options.GetAsDumpOptions(true,format));
361
362 ValueObject::DumpValueObject (*(output_stream),
363 result_valobj_sp.get(), // Variable object to dump
364 options);
365 if (result)
366 result->SetStatus (eReturnStatusSuccessFinishResult);
367 }
368 }
369 else
370 {
371 if (result_valobj_sp->GetError().GetError() == ClangUserExpression::kNoResult)
372 {
373 if (format != eFormatVoid && m_interpreter.GetDebugger().GetNotifyVoid())
374 {
375 error_stream->PutCString("(void)\n");
376 }
377
378 if (result)
379 result->SetStatus (eReturnStatusSuccessFinishResult);
380 }
381 else
382 {
383 const char *error_cstr = result_valobj_sp->GetError().AsCString();
384 if (error_cstr && error_cstr[0])
385 {
386 const size_t error_cstr_len = strlen (error_cstr);
387 const bool ends_with_newline = error_cstr[error_cstr_len - 1] == '\n';
388 if (strstr(error_cstr, "error:") != error_cstr)
389 error_stream->PutCString ("error: ");
390 error_stream->Write(error_cstr, error_cstr_len);
391 if (!ends_with_newline)
392 error_stream->EOL();
393 }
394 else
395 {
396 error_stream->PutCString ("error: unknown error\n");
397 }
398
399 if (result)
400 result->SetStatus (eReturnStatusFailed);
401 }
402 }
403 }
404 }
405 else
406 {
407 error_stream->Printf ("error: invalid execution context for expression\n");
408 return false;
409 }
410
411 return true;
412 }
413
414 bool
DoExecute(const char * command,CommandReturnObject & result)415 CommandObjectExpression::DoExecute
416 (
417 const char *command,
418 CommandReturnObject &result
419 )
420 {
421 m_option_group.NotifyOptionParsingStarting();
422
423 const char * expr = NULL;
424
425 if (command[0] == '\0')
426 {
427 m_expr_lines.clear();
428 m_expr_line_count = 0;
429
430 InputReaderSP reader_sp (new InputReader(m_interpreter.GetDebugger()));
431 if (reader_sp)
432 {
433 Error err (reader_sp->Initialize (CommandObjectExpression::MultiLineExpressionCallback,
434 this, // baton
435 eInputReaderGranularityLine, // token size, to pass to callback function
436 NULL, // end token
437 NULL, // prompt
438 true)); // echo input
439 if (err.Success())
440 {
441 m_interpreter.GetDebugger().PushInputReader (reader_sp);
442 result.SetStatus (eReturnStatusSuccessFinishNoResult);
443 }
444 else
445 {
446 result.AppendError (err.AsCString());
447 result.SetStatus (eReturnStatusFailed);
448 }
449 }
450 else
451 {
452 result.AppendError("out of memory");
453 result.SetStatus (eReturnStatusFailed);
454 }
455 return result.Succeeded();
456 }
457
458 if (command[0] == '-')
459 {
460 // We have some options and these options MUST end with --.
461 const char *end_options = NULL;
462 const char *s = command;
463 while (s && s[0])
464 {
465 end_options = ::strstr (s, "--");
466 if (end_options)
467 {
468 end_options += 2; // Get past the "--"
469 if (::isspace (end_options[0]))
470 {
471 expr = end_options;
472 while (::isspace (*expr))
473 ++expr;
474 break;
475 }
476 }
477 s = end_options;
478 }
479
480 if (end_options)
481 {
482 Args args (command, end_options - command);
483 if (!ParseOptions (args, result))
484 return false;
485
486 Error error (m_option_group.NotifyOptionParsingFinished());
487 if (error.Fail())
488 {
489 result.AppendError (error.AsCString());
490 result.SetStatus (eReturnStatusFailed);
491 return false;
492 }
493 }
494 }
495
496 if (expr == NULL)
497 expr = command;
498
499 if (EvaluateExpression (expr, &(result.GetOutputStream()), &(result.GetErrorStream()), &result))
500 return true;
501
502 result.SetStatus (eReturnStatusFailed);
503 return false;
504 }
505
506