1//===-- ClangFunctionCaller.cpp ---------------------------------*- C++ -*-===// 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 "ClangFunctionCaller.h" 10 11#include "ASTStructExtractor.h" 12#include "ClangExpressionParser.h" 13 14#include "clang/AST/ASTContext.h" 15#include "clang/AST/RecordLayout.h" 16#include "clang/CodeGen/CodeGenAction.h" 17#include "clang/CodeGen/ModuleBuilder.h" 18#include "clang/Frontend/CompilerInstance.h" 19#include "llvm/ADT/StringRef.h" 20#include "llvm/ADT/Triple.h" 21#include "llvm/ExecutionEngine/ExecutionEngine.h" 22#include "llvm/IR/Module.h" 23 24#include "lldb/Core/Module.h" 25#include "lldb/Core/ValueObject.h" 26#include "lldb/Core/ValueObjectList.h" 27#include "lldb/Expression/IRExecutionUnit.h" 28#include "lldb/Interpreter/CommandReturnObject.h" 29#include "lldb/Symbol/ClangASTContext.h" 30#include "lldb/Symbol/Function.h" 31#include "lldb/Symbol/Type.h" 32#include "lldb/Target/ExecutionContext.h" 33#include "lldb/Target/Process.h" 34#include "lldb/Target/RegisterContext.h" 35#include "lldb/Target/Target.h" 36#include "lldb/Target/Thread.h" 37#include "lldb/Target/ThreadPlan.h" 38#include "lldb/Target/ThreadPlanCallFunction.h" 39#include "lldb/Utility/DataExtractor.h" 40#include "lldb/Utility/Log.h" 41#include "lldb/Utility/State.h" 42 43using namespace lldb_private; 44 45char ClangFunctionCaller::ID; 46 47// ClangFunctionCaller constructor 48ClangFunctionCaller::ClangFunctionCaller(ExecutionContextScope &exe_scope, 49 const CompilerType &return_type, 50 const Address &functionAddress, 51 const ValueList &arg_value_list, 52 const char *name) 53 : FunctionCaller(exe_scope, return_type, functionAddress, arg_value_list, 54 name), 55 m_type_system_helper(*this) { 56 m_jit_process_wp = lldb::ProcessWP(exe_scope.CalculateProcess()); 57 // Can't make a ClangFunctionCaller without a process. 58 assert(m_jit_process_wp.lock()); 59} 60 61// Destructor 62ClangFunctionCaller::~ClangFunctionCaller() {} 63 64unsigned 65 66ClangFunctionCaller::CompileFunction(lldb::ThreadSP thread_to_use_sp, 67 DiagnosticManager &diagnostic_manager) { 68 if (m_compiled) 69 return 0; 70 71 // Compilation might call code, make sure to keep on the thread the caller 72 // indicated. 73 ThreadList::ExpressionExecutionThreadPusher execution_thread_pusher( 74 thread_to_use_sp); 75 76 // FIXME: How does clang tell us there's no return value? We need to handle 77 // that case. 78 unsigned num_errors = 0; 79 80 std::string return_type_str( 81 m_function_return_type.GetTypeName().AsCString("")); 82 83 // Cons up the function we're going to wrap our call in, then compile it... 84 // We declare the function "extern "C"" because the compiler might be in C++ 85 // mode which would mangle the name and then we couldn't find it again... 86 m_wrapper_function_text.clear(); 87 m_wrapper_function_text.append("extern \"C\" void "); 88 m_wrapper_function_text.append(m_wrapper_function_name); 89 m_wrapper_function_text.append(" (void *input)\n{\n struct "); 90 m_wrapper_function_text.append(m_wrapper_struct_name); 91 m_wrapper_function_text.append(" \n {\n"); 92 m_wrapper_function_text.append(" "); 93 m_wrapper_function_text.append(return_type_str); 94 m_wrapper_function_text.append(" (*fn_ptr) ("); 95 96 // Get the number of arguments. If we have a function type and it is 97 // prototyped, trust that, otherwise use the values we were given. 98 99 // FIXME: This will need to be extended to handle Variadic functions. We'll 100 // need 101 // to pull the defined arguments out of the function, then add the types from 102 // the arguments list for the variable arguments. 103 104 uint32_t num_args = UINT32_MAX; 105 bool trust_function = false; 106 // GetArgumentCount returns -1 for an unprototyped function. 107 CompilerType function_clang_type; 108 if (m_function_ptr) { 109 function_clang_type = m_function_ptr->GetCompilerType(); 110 if (function_clang_type) { 111 int num_func_args = function_clang_type.GetFunctionArgumentCount(); 112 if (num_func_args >= 0) { 113 trust_function = true; 114 num_args = num_func_args; 115 } 116 } 117 } 118 119 if (num_args == UINT32_MAX) 120 num_args = m_arg_values.GetSize(); 121 122 std::string args_buffer; // This one stores the definition of all the args in 123 // "struct caller". 124 std::string args_list_buffer; // This one stores the argument list called from 125 // the structure. 126 for (size_t i = 0; i < num_args; i++) { 127 std::string type_name; 128 129 if (trust_function) { 130 type_name = function_clang_type.GetFunctionArgumentTypeAtIndex(i) 131 .GetTypeName() 132 .AsCString(""); 133 } else { 134 CompilerType clang_qual_type = 135 m_arg_values.GetValueAtIndex(i)->GetCompilerType(); 136 if (clang_qual_type) { 137 type_name = clang_qual_type.GetTypeName().AsCString(""); 138 } else { 139 diagnostic_manager.Printf( 140 eDiagnosticSeverityError, 141 "Could not determine type of input value %" PRIu64 ".", 142 (uint64_t)i); 143 return 1; 144 } 145 } 146 147 m_wrapper_function_text.append(type_name); 148 if (i < num_args - 1) 149 m_wrapper_function_text.append(", "); 150 151 char arg_buf[32]; 152 args_buffer.append(" "); 153 args_buffer.append(type_name); 154 snprintf(arg_buf, 31, "arg_%" PRIu64, (uint64_t)i); 155 args_buffer.push_back(' '); 156 args_buffer.append(arg_buf); 157 args_buffer.append(";\n"); 158 159 args_list_buffer.append("__lldb_fn_data->"); 160 args_list_buffer.append(arg_buf); 161 if (i < num_args - 1) 162 args_list_buffer.append(", "); 163 } 164 m_wrapper_function_text.append( 165 ");\n"); // Close off the function calling prototype. 166 167 m_wrapper_function_text.append(args_buffer); 168 169 m_wrapper_function_text.append(" "); 170 m_wrapper_function_text.append(return_type_str); 171 m_wrapper_function_text.append(" return_value;"); 172 m_wrapper_function_text.append("\n };\n struct "); 173 m_wrapper_function_text.append(m_wrapper_struct_name); 174 m_wrapper_function_text.append("* __lldb_fn_data = (struct "); 175 m_wrapper_function_text.append(m_wrapper_struct_name); 176 m_wrapper_function_text.append(" *) input;\n"); 177 178 m_wrapper_function_text.append( 179 " __lldb_fn_data->return_value = __lldb_fn_data->fn_ptr ("); 180 m_wrapper_function_text.append(args_list_buffer); 181 m_wrapper_function_text.append(");\n}\n"); 182 183 Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS)); 184 LLDB_LOGF(log, "Expression: \n\n%s\n\n", m_wrapper_function_text.c_str()); 185 186 // Okay, now compile this expression 187 188 lldb::ProcessSP jit_process_sp(m_jit_process_wp.lock()); 189 if (jit_process_sp) { 190 const bool generate_debug_info = true; 191 auto *clang_parser = new ClangExpressionParser(jit_process_sp.get(), *this, 192 generate_debug_info); 193 num_errors = clang_parser->Parse(diagnostic_manager); 194 m_parser.reset(clang_parser); 195 } else { 196 diagnostic_manager.PutString(eDiagnosticSeverityError, 197 "no process - unable to inject function"); 198 num_errors = 1; 199 } 200 201 m_compiled = (num_errors == 0); 202 203 if (!m_compiled) 204 return num_errors; 205 206 return num_errors; 207} 208 209clang::ASTConsumer * 210ClangFunctionCaller::ClangFunctionCallerHelper::ASTTransformer( 211 clang::ASTConsumer *passthrough) { 212 m_struct_extractor.reset(new ASTStructExtractor( 213 passthrough, m_owner.GetWrapperStructName(), m_owner)); 214 215 return m_struct_extractor.get(); 216} 217