bool ClangUserExpression::PrepareForParsing(
DiagnosticManager &diagnostic_manager, ExecutionContext &exe_ctx) {
InstallContext(exe_ctx);
if (!SetupPersistentState(diagnostic_manager, exe_ctx))
return false;
Status err;
ScanContext(exe_ctx, err);
if (!err.Success()) {
diagnostic_manager.PutString(eDiagnosticSeverityWarning, err.AsCString());
}
////////////////////////////////////
// Generate the expression
//
ApplyObjcCastHack(m_expr_text);
SetupDeclVendor(exe_ctx, m_target);
UpdateLanguageForExpr(diagnostic_manager, exe_ctx);
return true;
}
lldb::ThreadPlanSP FunctionCaller::GetThreadPlanToCallFunction(
ExecutionContext &exe_ctx, lldb::addr_t args_addr,
const EvaluateExpressionOptions &options,
DiagnosticManager &diagnostic_manager) {
Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_EXPRESSIONS |
LIBLLDB_LOG_STEP));
if (log)
log->Printf("-- [FunctionCaller::GetThreadPlanToCallFunction] Creating "
"thread plan to call function \"%s\" --",
m_name.c_str());
// FIXME: Use the errors Stream for better error reporting.
Thread *thread = exe_ctx.GetThreadPtr();
if (thread == NULL) {
diagnostic_manager.PutString(
eDiagnosticSeverityError,
"Can't call a function without a valid thread.");
return NULL;
}
// Okay, now run the function:
Address wrapper_address(m_jit_start_addr);
lldb::addr_t args = {args_addr};
lldb::ThreadPlanSP new_plan_sp(new ThreadPlanCallFunction(
*thread, wrapper_address, CompilerType(), args, options));
new_plan_sp->SetIsMasterPlan(true);
new_plan_sp->SetOkayToDiscard(false);
return new_plan_sp;
}
bool ClangUserExpression::SetupPersistentState(DiagnosticManager &diagnostic_manager,
ExecutionContext &exe_ctx) {
if (Target *target = exe_ctx.GetTargetPtr()) {
if (PersistentExpressionState *persistent_state =
target->GetPersistentExpressionStateForLanguage(
lldb::eLanguageTypeC)) {
m_result_delegate.RegisterPersistentState(persistent_state);
} else {
diagnostic_manager.PutString(
eDiagnosticSeverityError,
"couldn't start parsing (no persistent data)");
return false;
}
} else {
diagnostic_manager.PutString(eDiagnosticSeverityError,
"error: couldn't start parsing (no target)");
return false;
}
return true;
}
void ClangUserExpression::UpdateLanguageForExpr(
DiagnosticManager &diagnostic_manager, ExecutionContext &exe_ctx) {
m_expr_lang = lldb::LanguageType::eLanguageTypeUnknown;
std::string prefix = m_expr_prefix;
if (m_options.GetExecutionPolicy() == eExecutionPolicyTopLevel) {
m_transformed_text = m_expr_text;
} else {
std::unique_ptr<ExpressionSourceCode> source_code(
ExpressionSourceCode::CreateWrapped(prefix.c_str(),
m_expr_text.c_str()));
if (m_in_cplusplus_method)
m_expr_lang = lldb::eLanguageTypeC_plus_plus;
else if (m_in_objectivec_method)
m_expr_lang = lldb::eLanguageTypeObjC;
else
m_expr_lang = lldb::eLanguageTypeC;
if (!source_code->GetText(m_transformed_text, m_expr_lang,
m_in_static_method, exe_ctx)) {
diagnostic_manager.PutString(eDiagnosticSeverityError,
"couldn't construct expression body");
return;
}
// Find and store the start position of the original code inside the
// transformed code. We need this later for the code completion.
std::size_t original_start;
std::size_t original_end;
bool found_bounds = source_code->GetOriginalBodyBounds(
m_transformed_text, m_expr_lang, original_start, original_end);
if (found_bounds) {
m_user_expression_start_pos = original_start;
}
}
}
unsigned
ClangFunctionCaller::CompileFunction(lldb::ThreadSP thread_to_use_sp,
DiagnosticManager &diagnostic_manager) {
if (m_compiled)
return 0;
// Compilation might call code, make sure to keep on the thread the caller
// indicated.
ThreadList::ExpressionExecutionThreadPusher execution_thread_pusher(
thread_to_use_sp);
// FIXME: How does clang tell us there's no return value? We need to handle
// that case.
unsigned num_errors = 0;
std::string return_type_str(
m_function_return_type.GetTypeName().AsCString(""));
// Cons up the function we're going to wrap our call in, then compile it...
// We declare the function "extern "C"" because the compiler might be in C++
// mode which would mangle the name and then we couldn't find it again...
m_wrapper_function_text.clear();
m_wrapper_function_text.append("extern \"C\" void ");
m_wrapper_function_text.append(m_wrapper_function_name);
m_wrapper_function_text.append(" (void *input)\n{\n struct ");
m_wrapper_function_text.append(m_wrapper_struct_name);
m_wrapper_function_text.append(" \n {\n");
m_wrapper_function_text.append(" ");
m_wrapper_function_text.append(return_type_str);
m_wrapper_function_text.append(" (*fn_ptr) (");
// Get the number of arguments. If we have a function type and it is
// prototyped,
// trust that, otherwise use the values we were given.
// FIXME: This will need to be extended to handle Variadic functions. We'll
// need
// to pull the defined arguments out of the function, then add the types from
// the
// arguments list for the variable arguments.
uint32_t num_args = UINT32_MAX;
bool trust_function = false;
// GetArgumentCount returns -1 for an unprototyped function.
CompilerType function_clang_type;
if (m_function_ptr) {
function_clang_type = m_function_ptr->GetCompilerType();
if (function_clang_type) {
int num_func_args = function_clang_type.GetFunctionArgumentCount();
if (num_func_args >= 0) {
trust_function = true;
num_args = num_func_args;
}
}
}
if (num_args == UINT32_MAX)
num_args = m_arg_values.GetSize();
std::string args_buffer; // This one stores the definition of all the args in
// "struct caller".
std::string args_list_buffer; // This one stores the argument list called from
// the structure.
for (size_t i = 0; i < num_args; i++) {
std::string type_name;
if (trust_function) {
type_name = function_clang_type.GetFunctionArgumentTypeAtIndex(i)
.GetTypeName()
.AsCString("");
} else {
CompilerType clang_qual_type =
m_arg_values.GetValueAtIndex(i)->GetCompilerType();
if (clang_qual_type) {
type_name = clang_qual_type.GetTypeName().AsCString("");
} else {
diagnostic_manager.Printf(
eDiagnosticSeverityError,
"Could not determine type of input value %" PRIu64 ".",
(uint64_t)i);
return 1;
}
}
m_wrapper_function_text.append(type_name);
if (i < num_args - 1)
m_wrapper_function_text.append(", ");
char arg_buf[32];
args_buffer.append(" ");
args_buffer.append(type_name);
snprintf(arg_buf, 31, "arg_%" PRIu64, (uint64_t)i);
args_buffer.push_back(' ');
args_buffer.append(arg_buf);
args_buffer.append(";\n");
args_list_buffer.append("__lldb_fn_data->");
args_list_buffer.append(arg_buf);
if (i < num_args - 1)
args_list_buffer.append(", ");
}
m_wrapper_function_text.append(
");\n"); // Close off the function calling prototype.
m_wrapper_function_text.append(args_buffer);
m_wrapper_function_text.append(" ");
m_wrapper_function_text.append(return_type_str);
m_wrapper_function_text.append(" return_value;");
m_wrapper_function_text.append("\n };\n struct ");
m_wrapper_function_text.append(m_wrapper_struct_name);
m_wrapper_function_text.append("* __lldb_fn_data = (struct ");
m_wrapper_function_text.append(m_wrapper_struct_name);
m_wrapper_function_text.append(" *) input;\n");
m_wrapper_function_text.append(
" __lldb_fn_data->return_value = __lldb_fn_data->fn_ptr (");
m_wrapper_function_text.append(args_list_buffer);
m_wrapper_function_text.append(");\n}\n");
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
if (log)
log->Printf("Expression: \n\n%s\n\n", m_wrapper_function_text.c_str());
// Okay, now compile this expression
lldb::ProcessSP jit_process_sp(m_jit_process_wp.lock());
if (jit_process_sp) {
const bool generate_debug_info = true;
m_parser.reset(new ClangExpressionParser(jit_process_sp.get(), *this,
generate_debug_info));
num_errors = m_parser->Parse(diagnostic_manager);
} else {
diagnostic_manager.PutString(eDiagnosticSeverityError,
"no process - unable to inject function");
num_errors = 1;
}
m_compiled = (num_errors == 0);
if (!m_compiled)
return num_errors;
return num_errors;
}
lldb::ExpressionResults
LLVMUserExpression::DoExecute(DiagnosticManager &diagnostic_manager,
ExecutionContext &exe_ctx,
const EvaluateExpressionOptions &options,
lldb::UserExpressionSP &shared_ptr_to_me,
lldb::ExpressionVariableSP &result) {
// The expression log is quite verbose, and if you're just tracking the
// execution of the
// expression, it's quite convenient to have these logs come out with the STEP
// log as well.
Log *log(lldb_private::GetLogIfAnyCategoriesSet(LIBLLDB_LOG_EXPRESSIONS |
LIBLLDB_LOG_STEP));
if (m_jit_start_addr != LLDB_INVALID_ADDRESS || m_can_interpret) {
lldb::addr_t struct_address = LLDB_INVALID_ADDRESS;
if (!PrepareToExecuteJITExpression(diagnostic_manager, exe_ctx,
struct_address)) {
diagnostic_manager.Printf(
eDiagnosticSeverityError,
"errored out in %s, couldn't PrepareToExecuteJITExpression",
__FUNCTION__);
return lldb::eExpressionSetupError;
}
lldb::addr_t function_stack_bottom = LLDB_INVALID_ADDRESS;
lldb::addr_t function_stack_top = LLDB_INVALID_ADDRESS;
if (m_can_interpret) {
llvm::Module *module = m_execution_unit_sp->GetModule();
llvm::Function *function = m_execution_unit_sp->GetFunction();
if (!module || !function) {
diagnostic_manager.PutString(
eDiagnosticSeverityError,
"supposed to interpret, but nothing is there");
return lldb::eExpressionSetupError;
}
Error interpreter_error;
std::vector<lldb::addr_t> args;
if (!AddArguments(exe_ctx, args, struct_address, diagnostic_manager)) {
diagnostic_manager.Printf(eDiagnosticSeverityError,
"errored out in %s, couldn't AddArguments",
__FUNCTION__);
return lldb::eExpressionSetupError;
}
function_stack_bottom = m_stack_frame_bottom;
function_stack_top = m_stack_frame_top;
IRInterpreter::Interpret(*module, *function, args,
*m_execution_unit_sp.get(), interpreter_error,
function_stack_bottom, function_stack_top,
exe_ctx);
if (!interpreter_error.Success()) {
diagnostic_manager.Printf(eDiagnosticSeverityError,
"supposed to interpret, but failed: %s",
interpreter_error.AsCString());
return lldb::eExpressionDiscarded;
}
} else {
if (!exe_ctx.HasThreadScope()) {
diagnostic_manager.Printf(eDiagnosticSeverityError,
"%s called with no thread selected",
__FUNCTION__);
return lldb::eExpressionSetupError;
}
Address wrapper_address(m_jit_start_addr);
std::vector<lldb::addr_t> args;
if (!AddArguments(exe_ctx, args, struct_address, diagnostic_manager)) {
diagnostic_manager.Printf(eDiagnosticSeverityError,
"errored out in %s, couldn't AddArguments",
__FUNCTION__);
return lldb::eExpressionSetupError;
}
lldb::ThreadPlanSP call_plan_sp(new ThreadPlanCallUserExpression(
exe_ctx.GetThreadRef(), wrapper_address, args, options,
shared_ptr_to_me));
StreamString ss;
if (!call_plan_sp || !call_plan_sp->ValidatePlan(&ss)) {
diagnostic_manager.PutString(eDiagnosticSeverityError, ss.GetString());
return lldb::eExpressionSetupError;
}
ThreadPlanCallUserExpression *user_expression_plan =
static_cast<ThreadPlanCallUserExpression *>(call_plan_sp.get());
lldb::addr_t function_stack_pointer =
user_expression_plan->GetFunctionStackPointer();
function_stack_bottom = function_stack_pointer - HostInfo::GetPageSize();
function_stack_top = function_stack_pointer;
if (log)
log->Printf(
"-- [UserExpression::Execute] Execution of expression begins --");
if (exe_ctx.GetProcessPtr())
exe_ctx.GetProcessPtr()->SetRunningUserExpression(true);
lldb::ExpressionResults execution_result =
exe_ctx.GetProcessRef().RunThreadPlan(exe_ctx, call_plan_sp, options,
diagnostic_manager);
if (exe_ctx.GetProcessPtr())
exe_ctx.GetProcessPtr()->SetRunningUserExpression(false);
if (log)
log->Printf("-- [UserExpression::Execute] Execution of expression "
"completed --");
if (execution_result == lldb::eExpressionInterrupted ||
execution_result == lldb::eExpressionHitBreakpoint) {
const char *error_desc = NULL;
if (call_plan_sp) {
lldb::StopInfoSP real_stop_info_sp = call_plan_sp->GetRealStopInfo();
if (real_stop_info_sp)
error_desc = real_stop_info_sp->GetDescription();
}
if (error_desc)
diagnostic_manager.Printf(eDiagnosticSeverityError,
"Execution was interrupted, reason: %s.",
error_desc);
else
diagnostic_manager.PutString(eDiagnosticSeverityError,
"Execution was interrupted.");
if ((execution_result == lldb::eExpressionInterrupted &&
options.DoesUnwindOnError()) ||
(execution_result == lldb::eExpressionHitBreakpoint &&
options.DoesIgnoreBreakpoints()))
diagnostic_manager.AppendMessageToDiagnostic(
"The process has been returned to the state before expression "
"evaluation.");
else {
if (execution_result == lldb::eExpressionHitBreakpoint)
user_expression_plan->TransferExpressionOwnership();
diagnostic_manager.AppendMessageToDiagnostic(
"The process has been left at the point where it was "
"interrupted, "
"use \"thread return -x\" to return to the state before "
"expression evaluation.");
}
return execution_result;
} else if (execution_result == lldb::eExpressionStoppedForDebug) {
diagnostic_manager.PutString(
eDiagnosticSeverityRemark,
"Execution was halted at the first instruction of the expression "
"function because \"debug\" was requested.\n"
"Use \"thread return -x\" to return to the state before expression "
"evaluation.");
return execution_result;
} else if (execution_result != lldb::eExpressionCompleted) {
diagnostic_manager.Printf(
eDiagnosticSeverityError,
"Couldn't execute function; result was %s",
Process::ExecutionResultAsCString(execution_result));
return execution_result;
}
}
if (FinalizeJITExecution(diagnostic_manager, exe_ctx, result,
function_stack_bottom, function_stack_top)) {
return lldb::eExpressionCompleted;
} else {
return lldb::eExpressionResultUnavailable;
}
} else {
diagnostic_manager.PutString(
eDiagnosticSeverityError,
"Expression can't be run, because there is no JIT compiled function");
return lldb::eExpressionSetupError;
}
}
bool LLVMUserExpression::PrepareToExecuteJITExpression(
DiagnosticManager &diagnostic_manager, ExecutionContext &exe_ctx,
lldb::addr_t &struct_address) {
lldb::TargetSP target;
lldb::ProcessSP process;
lldb::StackFrameSP frame;
if (!LockAndCheckContext(exe_ctx, target, process, frame)) {
diagnostic_manager.PutString(
eDiagnosticSeverityError,
"The context has changed before we could JIT the expression!");
return false;
}
if (m_jit_start_addr != LLDB_INVALID_ADDRESS || m_can_interpret) {
if (m_materialized_address == LLDB_INVALID_ADDRESS) {
Error alloc_error;
IRMemoryMap::AllocationPolicy policy =
m_can_interpret ? IRMemoryMap::eAllocationPolicyHostOnly
: IRMemoryMap::eAllocationPolicyMirror;
const bool zero_memory = false;
m_materialized_address = m_execution_unit_sp->Malloc(
m_materializer_ap->GetStructByteSize(),
m_materializer_ap->GetStructAlignment(),
lldb::ePermissionsReadable | lldb::ePermissionsWritable, policy,
zero_memory, alloc_error);
if (!alloc_error.Success()) {
diagnostic_manager.Printf(
eDiagnosticSeverityError,
"Couldn't allocate space for materialized struct: %s",
alloc_error.AsCString());
return false;
}
}
struct_address = m_materialized_address;
if (m_can_interpret && m_stack_frame_bottom == LLDB_INVALID_ADDRESS) {
Error alloc_error;
const size_t stack_frame_size = 512 * 1024;
const bool zero_memory = false;
m_stack_frame_bottom = m_execution_unit_sp->Malloc(
stack_frame_size, 8,
lldb::ePermissionsReadable | lldb::ePermissionsWritable,
IRMemoryMap::eAllocationPolicyHostOnly, zero_memory, alloc_error);
m_stack_frame_top = m_stack_frame_bottom + stack_frame_size;
if (!alloc_error.Success()) {
diagnostic_manager.Printf(
eDiagnosticSeverityError,
"Couldn't allocate space for the stack frame: %s",
alloc_error.AsCString());
return false;
}
}
Error materialize_error;
m_dematerializer_sp = m_materializer_ap->Materialize(
frame, *m_execution_unit_sp, struct_address, materialize_error);
if (!materialize_error.Success()) {
diagnostic_manager.Printf(eDiagnosticSeverityError,
"Couldn't materialize: %s",
materialize_error.AsCString());
return false;
}
}
return true;
}
unsigned
ClangExpressionParser::ParseInternal(DiagnosticManager &diagnostic_manager,
CodeCompleteConsumer *completion_consumer,
unsigned completion_line,
unsigned completion_column) {
ClangDiagnosticManagerAdapter *adapter =
static_cast<ClangDiagnosticManagerAdapter *>(
m_compiler->getDiagnostics().getClient());
clang::TextDiagnosticBuffer *diag_buf = adapter->GetPassthrough();
diag_buf->FlushDiagnostics(m_compiler->getDiagnostics());
adapter->ResetManager(&diagnostic_manager);
const char *expr_text = m_expr.Text();
clang::SourceManager &source_mgr = m_compiler->getSourceManager();
bool created_main_file = false;
// Clang wants to do completion on a real file known by Clang's file manager,
// so we have to create one to make this work.
// TODO: We probably could also simulate to Clang's file manager that there
// is a real file that contains our code.
bool should_create_file = completion_consumer != nullptr;
// We also want a real file on disk if we generate full debug info.
should_create_file |= m_compiler->getCodeGenOpts().getDebugInfo() ==
codegenoptions::FullDebugInfo;
if (should_create_file) {
int temp_fd = -1;
llvm::SmallString<128> result_path;
if (FileSpec tmpdir_file_spec = HostInfo::GetProcessTempDir()) {
tmpdir_file_spec.AppendPathComponent("lldb-%%%%%%.expr");
std::string temp_source_path = tmpdir_file_spec.GetPath();
llvm::sys::fs::createUniqueFile(temp_source_path, temp_fd, result_path);
} else {
llvm::sys::fs::createTemporaryFile("lldb", "expr", temp_fd, result_path);
}
if (temp_fd != -1) {
lldb_private::File file(temp_fd, true);
const size_t expr_text_len = strlen(expr_text);
size_t bytes_written = expr_text_len;
if (file.Write(expr_text, bytes_written).Success()) {
if (bytes_written == expr_text_len) {
file.Close();
source_mgr.setMainFileID(
source_mgr.createFileID(m_file_manager->getFile(result_path),
SourceLocation(), SrcMgr::C_User));
created_main_file = true;
}
}
}
}
if (!created_main_file) {
std::unique_ptr<MemoryBuffer> memory_buffer =
MemoryBuffer::getMemBufferCopy(expr_text, __FUNCTION__);
source_mgr.setMainFileID(source_mgr.createFileID(std::move(memory_buffer)));
}
diag_buf->BeginSourceFile(m_compiler->getLangOpts(),
&m_compiler->getPreprocessor());
ClangExpressionHelper *type_system_helper =
dyn_cast<ClangExpressionHelper>(m_expr.GetTypeSystemHelper());
ASTConsumer *ast_transformer =
type_system_helper->ASTTransformer(m_code_generator.get());
if (ClangExpressionDeclMap *decl_map = type_system_helper->DeclMap())
decl_map->InstallCodeGenerator(m_code_generator.get());
// If we want to parse for code completion, we need to attach our code
// completion consumer to the Sema and specify a completion position.
// While parsing the Sema will call this consumer with the provided
// completion suggestions.
if (completion_consumer) {
auto main_file = source_mgr.getFileEntryForID(source_mgr.getMainFileID());
auto &PP = m_compiler->getPreprocessor();
// Lines and columns start at 1 in Clang, but code completion positions are
// indexed from 0, so we need to add 1 to the line and column here.
++completion_line;
++completion_column;
PP.SetCodeCompletionPoint(main_file, completion_line, completion_column);
}
if (ast_transformer) {
ast_transformer->Initialize(m_compiler->getASTContext());
ParseAST(m_compiler->getPreprocessor(), ast_transformer,
m_compiler->getASTContext(), false, TU_Complete,
completion_consumer);
} else {
m_code_generator->Initialize(m_compiler->getASTContext());
ParseAST(m_compiler->getPreprocessor(), m_code_generator.get(),
m_compiler->getASTContext(), false, TU_Complete,
completion_consumer);
}
diag_buf->EndSourceFile();
unsigned num_errors = diag_buf->getNumErrors();
if (m_pp_callbacks && m_pp_callbacks->hasErrors()) {
num_errors++;
diagnostic_manager.PutString(eDiagnosticSeverityError,
"while importing modules:");
diagnostic_manager.AppendMessageToDiagnostic(
m_pp_callbacks->getErrorString());
}
if (!num_errors) {
if (type_system_helper->DeclMap() &&
!type_system_helper->DeclMap()->ResolveUnknownTypes()) {
diagnostic_manager.Printf(eDiagnosticSeverityError,
"Couldn't infer the type of a variable");
num_errors++;
}
}
if (!num_errors) {
type_system_helper->CommitPersistentDecls();
}
adapter->ResetManager();
return num_errors;
}
bool FunctionCaller::WriteFunctionArguments(
ExecutionContext &exe_ctx, lldb::addr_t &args_addr_ref,
ValueList &arg_values, DiagnosticManager &diagnostic_manager) {
// All the information to reconstruct the struct is provided by the
// StructExtractor.
if (!m_struct_valid) {
diagnostic_manager.PutString(eDiagnosticSeverityError,
"Argument information was not correctly "
"parsed, so the function cannot be called.");
return false;
}
Status error;
lldb::ExpressionResults return_value = lldb::eExpressionSetupError;
Process *process = exe_ctx.GetProcessPtr();
if (process == NULL)
return return_value;
lldb::ProcessSP jit_process_sp(m_jit_process_wp.lock());
if (process != jit_process_sp.get())
return false;
if (args_addr_ref == LLDB_INVALID_ADDRESS) {
args_addr_ref = process->AllocateMemory(
m_struct_size, lldb::ePermissionsReadable | lldb::ePermissionsWritable,
error);
if (args_addr_ref == LLDB_INVALID_ADDRESS)
return false;
m_wrapper_args_addrs.push_back(args_addr_ref);
} else {
// Make sure this is an address that we've already handed out.
if (find(m_wrapper_args_addrs.begin(), m_wrapper_args_addrs.end(),
args_addr_ref) == m_wrapper_args_addrs.end()) {
return false;
}
}
// TODO: verify fun_addr needs to be a callable address
Scalar fun_addr(
m_function_addr.GetCallableLoadAddress(exe_ctx.GetTargetPtr()));
uint64_t first_offset = m_member_offsets[0];
process->WriteScalarToMemory(args_addr_ref + first_offset, fun_addr,
process->GetAddressByteSize(), error);
// FIXME: We will need to extend this for Variadic functions.
Status value_error;
size_t num_args = arg_values.GetSize();
if (num_args != m_arg_values.GetSize()) {
diagnostic_manager.Printf(
eDiagnosticSeverityError,
"Wrong number of arguments - was: %" PRIu64 " should be: %" PRIu64 "",
(uint64_t)num_args, (uint64_t)m_arg_values.GetSize());
return false;
}
for (size_t i = 0; i < num_args; i++) {
// FIXME: We should sanity check sizes.
uint64_t offset = m_member_offsets[i + 1]; // Clang sizes are in bytes.
Value *arg_value = arg_values.GetValueAtIndex(i);
// FIXME: For now just do scalars:
// Special case: if it's a pointer, don't do anything (the ABI supports
// passing cstrings)
if (arg_value->GetValueType() == Value::eValueTypeHostAddress &&
arg_value->GetContextType() == Value::eContextTypeInvalid &&
arg_value->GetCompilerType().IsPointerType())
continue;
const Scalar &arg_scalar = arg_value->ResolveValue(&exe_ctx);
if (!process->WriteScalarToMemory(args_addr_ref + offset, arg_scalar,
arg_scalar.GetByteSize(), error))
return false;
}
return true;
}
bool ClangUserExpression::AddArguments(ExecutionContext &exe_ctx,
std::vector<lldb::addr_t> &args,
lldb::addr_t struct_address,
DiagnosticManager &diagnostic_manager) {
lldb::addr_t object_ptr = LLDB_INVALID_ADDRESS;
lldb::addr_t cmd_ptr = LLDB_INVALID_ADDRESS;
if (m_needs_object_ptr) {
lldb::StackFrameSP frame_sp = exe_ctx.GetFrameSP();
if (!frame_sp)
return true;
ConstString object_name;
if (m_in_cplusplus_method) {
object_name.SetCString("this");
} else if (m_in_objectivec_method) {
object_name.SetCString("self");
} else {
diagnostic_manager.PutString(
eDiagnosticSeverityError,
"need object pointer but don't know the language");
return false;
}
Status object_ptr_error;
object_ptr = GetObjectPointer(frame_sp, object_name, object_ptr_error);
if (!object_ptr_error.Success()) {
exe_ctx.GetTargetRef().GetDebugger().GetAsyncOutputStream()->Printf(
"warning: `%s' is not accessible (substituting 0)\n",
object_name.AsCString());
object_ptr = 0;
}
if (m_in_objectivec_method) {
ConstString cmd_name("_cmd");
cmd_ptr = GetObjectPointer(frame_sp, cmd_name, object_ptr_error);
if (!object_ptr_error.Success()) {
diagnostic_manager.Printf(
eDiagnosticSeverityWarning,
"couldn't get cmd pointer (substituting NULL): %s",
object_ptr_error.AsCString());
cmd_ptr = 0;
}
}
args.push_back(object_ptr);
if (m_in_objectivec_method)
args.push_back(cmd_ptr);
args.push_back(struct_address);
} else {
args.push_back(struct_address);
}
return true;
}
bool ClangUserExpression::Parse(DiagnosticManager &diagnostic_manager,
ExecutionContext &exe_ctx,
lldb_private::ExecutionPolicy execution_policy,
bool keep_result_in_memory,
bool generate_debug_info) {
Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
if (!PrepareForParsing(diagnostic_manager, exe_ctx))
return false;
if (log)
log->Printf("Parsing the following code:\n%s", m_transformed_text.c_str());
////////////////////////////////////
// Set up the target and compiler
//
Target *target = exe_ctx.GetTargetPtr();
if (!target) {
diagnostic_manager.PutString(eDiagnosticSeverityError, "invalid target");
return false;
}
//////////////////////////
// Parse the expression
//
m_materializer_ap.reset(new Materializer());
ResetDeclMap(exe_ctx, m_result_delegate, keep_result_in_memory);
OnExit on_exit([this]() { ResetDeclMap(); });
if (!DeclMap()->WillParse(exe_ctx, m_materializer_ap.get())) {
diagnostic_manager.PutString(
eDiagnosticSeverityError,
"current process state is unsuitable for expression parsing");
return false;
}
if (m_options.GetExecutionPolicy() == eExecutionPolicyTopLevel) {
DeclMap()->SetLookupsEnabled(true);
}
Process *process = exe_ctx.GetProcessPtr();
ExecutionContextScope *exe_scope = process;
if (!exe_scope)
exe_scope = exe_ctx.GetTargetPtr();
// We use a shared pointer here so we can use the original parser - if it
// succeeds or the rewrite parser we might make if it fails. But the
// parser_sp will never be empty.
ClangExpressionParser parser(exe_scope, *this, generate_debug_info);
unsigned num_errors = parser.Parse(diagnostic_manager);
// Check here for FixItHints. If there are any try to apply the fixits and
// set the fixed text in m_fixed_text before returning an error.
if (num_errors) {
if (diagnostic_manager.HasFixIts()) {
if (parser.RewriteExpression(diagnostic_manager)) {
size_t fixed_start;
size_t fixed_end;
const std::string &fixed_expression =
diagnostic_manager.GetFixedExpression();
if (ExpressionSourceCode::GetOriginalBodyBounds(
fixed_expression, m_expr_lang, fixed_start, fixed_end))
m_fixed_text =
fixed_expression.substr(fixed_start, fixed_end - fixed_start);
}
}
return false;
}
//////////////////////////////////////////////////////////////////////////////////////////
// Prepare the output of the parser for execution, evaluating it statically
// if possible
//
{
Status jit_error = parser.PrepareForExecution(
m_jit_start_addr, m_jit_end_addr, m_execution_unit_sp, exe_ctx,
m_can_interpret, execution_policy);
if (!jit_error.Success()) {
const char *error_cstr = jit_error.AsCString();
if (error_cstr && error_cstr[0])
diagnostic_manager.PutString(eDiagnosticSeverityError, error_cstr);
else
diagnostic_manager.PutString(eDiagnosticSeverityError,
"expression can't be interpreted or run");
return false;
}
}
if (exe_ctx.GetProcessPtr() && execution_policy == eExecutionPolicyTopLevel) {
Status static_init_error =
parser.RunStaticInitializers(m_execution_unit_sp, exe_ctx);
if (!static_init_error.Success()) {
const char *error_cstr = static_init_error.AsCString();
if (error_cstr && error_cstr[0])
diagnostic_manager.Printf(eDiagnosticSeverityError,
"couldn't run static initializers: %s\n",
error_cstr);
else
diagnostic_manager.PutString(eDiagnosticSeverityError,
"couldn't run static initializers\n");
return false;
}
}
if (m_execution_unit_sp) {
bool register_execution_unit = false;
if (m_options.GetExecutionPolicy() == eExecutionPolicyTopLevel) {
register_execution_unit = true;
}
// If there is more than one external function in the execution unit, it
// needs to keep living even if it's not top level, because the result
// could refer to that function.
if (m_execution_unit_sp->GetJittedFunctions().size() > 1) {
register_execution_unit = true;
}
if (register_execution_unit) {
llvm::cast<PersistentExpressionState>(
exe_ctx.GetTargetPtr()->GetPersistentExpressionStateForLanguage(
m_language))
->RegisterExecutionUnit(m_execution_unit_sp);
}
}
if (generate_debug_info) {
lldb::ModuleSP jit_module_sp(m_execution_unit_sp->GetJITModule());
if (jit_module_sp) {
ConstString const_func_name(FunctionName());
FileSpec jit_file;
jit_file.GetFilename() = const_func_name;
jit_module_sp->SetFileSpecAndObjectName(jit_file, ConstString());
m_jit_module_wp = jit_module_sp;
target->GetImages().Append(jit_module_sp);
}
}
if (process && m_jit_start_addr != LLDB_INVALID_ADDRESS)
m_jit_process_wp = lldb::ProcessWP(process->shared_from_this());
return true;
}