Fix bug with function resolution when using IR Interpreter

[ted]

Summary

Recent changes to the expression parser broke function name resolution when using the IR interpreter instead of JIT. This patch changes the IRMemoryMap ivar in InterpreterStackFrame to an IRExecutionUnitSP (which is a subclass), allowing InterpreterStackFrame::ResolveConstantValue() to call FindSymbol() on the name of the Value when it's a FunctionVal. It also changes IRExecutionUnit::FindInSymbols() to call GetFileAddress() on the symball if ResolveCallableAddress() fails and there is no valid Process.

[spyffe]

Aside from one minor object ownership issue this is good to go. Change the IRExecutionUnitSP to an IRExecutionUnit& and you have my blessing!

source/Expression/IRInterpreter.cpp

106

As noted below, this can just be an IRExecutionUnit&.

689

Given that the caller of Interpret has an execution_unit_sp, and Interpret does not create any objects that live longer than the Interpret invocation (specifically, the InterpreterStackFrame is stack-allocated) I believe we should not need to take the shared pointer. An IRExecutionUnit& should suffice.

[ted]

Updated to address Sean's comments

include/lldb/Expression/IRInterpreter.h

CanInterpret (llvm::Module &module,
                   llvm::Function &function,
                   lldb_private::Error &error,
                   const bool support_function_calls);
     
     static bool
     Interpret (llvm::Module &module,
                llvm::Function &function,
                llvm::ArrayRef<lldb::addr_t> args,
-               lldb_private::IRMemoryMap &memory_map,
+               lldb_private::IRExecutionUnit &execution_unit,
                lldb_private::Error &error,
                lldb::addr_t stack_frame_bottom,
                lldb::addr_t stack_frame_top,
                lldb_private::ExecutionContext &exe_ctx);
     
 private:   
     static bool
     supportsFunction (llvm::Function &llvm_function,
                       lldb_private::Error &err);
 };
 
 #endif

source/Expression/IRExecutionUnit.cpp

for (const SearchSpec &spec : specs)
                 sc_list.GetContextAtIndex(si, candidate_sc);
 
                 const bool is_external = (candidate_sc.function) ||
                                          (candidate_sc.symbol && candidate_sc.symbol->IsExternal());
 
                 load_address = candidate_sc.symbol->ResolveCallableAddress(*target);
 
                 if (load_address == LLDB_INVALID_ADDRESS)
+                    if (target->GetProcessSP())
                         load_address = candidate_sc.symbol->GetAddress().GetLoadAddress(target);
+                    else
+                        load_address = candidate_sc.symbol->GetAddress().GetFileAddress();
 
                 if (load_address != LLDB_INVALID_ADDRESS)
                 {
                     if (is_external)
                     {
                         return true;
                     }
                     else if (best_internal_load_address == LLDB_INVALID_ADDRESS)

source/Expression/IRInterpreter.cpp

 //===-- IRInterpreter.cpp ---------------------------------------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 
+#include "lldb/Core/ConstString.h"
 #include "lldb/Core/DataExtractor.h"
 #include "lldb/Core/Error.h"
 #include "lldb/Core/Log.h"
 #include "lldb/Core/ModuleSpec.h"
 #include "lldb/Core/Module.h"
 #include "lldb/Core/Scalar.h"
 #include "lldb/Core/StreamString.h"
 #include "lldb/Core/ValueObject.h"
+#include "lldb/Expression/IRExecutionUnit.h"
 #include "lldb/Expression/IRMemoryMap.h"
 #include "lldb/Expression/IRInterpreter.h"
 #include "lldb/Host/Endian.h"
 
 #include "lldb/Target/ABI.h"
 #include "lldb/Target/ExecutionContext.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Target/Thread.h"

 
 class InterpreterStackFrame
 {
 public:
     typedef std::map <const Value*, lldb::addr_t> ValueMap;
 
     ValueMap                                m_values;
     DataLayout                             &m_target_data;
-    lldb_private::IRMemoryMap              &m_memory_map;
+    lldb_private::IRExecutionUnit          &m_execution_unit;
     const BasicBlock                       *m_bb;
     BasicBlock::const_iterator              m_ii;
     BasicBlock::const_iterator              m_ie;
 
     lldb::addr_t                            m_frame_process_address;
     size_t                                  m_frame_size;
     lldb::addr_t                            m_stack_pointer;
 
     lldb::ByteOrder                         m_byte_order;
     size_t                                  m_addr_byte_size;
 
     InterpreterStackFrame (DataLayout &target_data,
-                           lldb_private::IRMemoryMap &memory_map,
+                           lldb_private::IRExecutionUnit &execution_unit,
                            lldb::addr_t stack_frame_bottom,
                            lldb::addr_t stack_frame_top) :
         m_target_data (target_data),
-        m_memory_map (memory_map)
+        m_execution_unit (execution_unit)
     {
         m_byte_order = (target_data.isLittleEndian() ? lldb::eByteOrderLittle : lldb::eByteOrderBig);
         m_addr_byte_size = (target_data.getPointerSize(0));
 
         m_frame_process_address = stack_frame_bottom;
         m_frame_size = stack_frame_top - stack_frame_bottom;
         m_stack_pointer = stack_frame_top;
     }
bool EvaluateValue (lldb_private::Scalar &scalar, const Value *value, Module &module)
         else
         {
             lldb::addr_t process_address = ResolveValue(value, module);
             size_t value_size = m_target_data.getTypeStoreSize(value->getType());
 
             lldb_private::DataExtractor value_extractor;
             lldb_private::Error extract_error;
 
-            m_memory_map.GetMemoryData(value_extractor, process_address, value_size, extract_error);
+            m_execution_unit.GetMemoryData(value_extractor, process_address, value_size, extract_error);
 
             if (!extract_error.Success())
                 return false;
 
             lldb::offset_t offset = 0;
             if (value_size == 1 || value_size == 2 || value_size == 4 || value_size == 8)
             {
                 uint64_t u64value = value_extractor.GetMaxU64(&offset, value_size);
bool AssignValue (const Value *value, lldb_private::Scalar &scalar, Module &module)
 
         lldb_private::Error get_data_error;
 
         if (!cast_scalar.GetAsMemoryData(buf.GetBytes(), buf.GetByteSize(), m_byte_order, get_data_error))
             return false;
 
         lldb_private::Error write_error;
 
-        m_memory_map.WriteMemory(process_address, buf.GetBytes(), buf.GetByteSize(), write_error);
+        m_execution_unit.WriteMemory(process_address, buf.GetBytes(), buf.GetByteSize(), write_error);
 
         return write_error.Success();
     }
 
     bool ResolveConstantValue (APInt &value, const Constant *constant)
     {
         switch (constant->getValueID())
         {
         default:
             break;
+        case Value::FunctionVal:
+            if (const Function *constant_func = dyn_cast<Function>(constant))
+            {
+                lldb_private::ConstString name(constant_func->getName());
+                lldb::addr_t addr = m_execution_unit.FindSymbol(name);
+                if (addr == LLDB_INVALID_ADDRESS)
+                    return false;
+                value = APInt(m_target_data.getPointerSizeInBits(), addr);
+                return true;
+            }
+            break;
         case Value::ConstantIntVal:
             if (const ConstantInt *constant_int = dyn_cast<ConstantInt>(constant))
             {
                 value = constant_int->getValue();
                 return true;
             }
             break;
         case Value::ConstantFPVal:
public:
     {
         lldb::addr_t data_address = Malloc(value->getType());
 
         if (data_address == LLDB_INVALID_ADDRESS)
             return false;
 
         lldb_private::Error write_error;
 
-        m_memory_map.WritePointerToMemory(data_address, address, write_error);
+        m_execution_unit.WritePointerToMemory(data_address, address, write_error);
 
         if (!write_error.Success())
         {
             lldb_private::Error free_error;
-            m_memory_map.Free(data_address, free_error);
+            m_execution_unit.Free(data_address, free_error);
             return false;
         }
 
         m_values[value] = data_address;
 
         lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
 
         if (log)
public:
     bool ResolveConstant (lldb::addr_t process_address, const Constant *constant)
     {
         APInt resolved_value;
 
         if (!ResolveConstantValue(resolved_value, constant))
             return false;
 
         lldb_private::StreamString buffer (lldb_private::Stream::eBinary,
-                                           m_memory_map.GetAddressByteSize(),
-                                           m_memory_map.GetByteOrder());
+                                           m_execution_unit.GetAddressByteSize(),
+                                           m_execution_unit.GetByteOrder());
 
         size_t constant_size = m_target_data.getTypeStoreSize(constant->getType());
 
         const uint64_t *raw_data = resolved_value.getRawData();
 
         buffer.PutRawBytes(raw_data, constant_size, lldb_private::endian::InlHostByteOrder());
 
         lldb_private::Error write_error;
 
-        m_memory_map.WriteMemory(process_address, (const uint8_t*)buffer.GetData(), constant_size, write_error);
+        m_execution_unit.WriteMemory(process_address, (const uint8_t*)buffer.GetData(), constant_size, write_error);
 
         return write_error.Success();
     }
 
     lldb::addr_t Malloc (size_t size, uint8_t byte_alignment)
     {
         lldb::addr_t ret = m_stack_pointer;
 
public:
     std::string PrintData (lldb::addr_t addr, llvm::Type *type)
     {
         size_t length = m_target_data.getTypeStoreSize(type);
 
         lldb_private::DataBufferHeap buf(length, 0);
 
         lldb_private::Error read_error;
 
-        m_memory_map.ReadMemory(buf.GetBytes(), addr, length, read_error);
+        m_execution_unit.ReadMemory(buf.GetBytes(), addr, length, read_error);
 
         if (!read_error.Success())
             return std::string("<couldn't read data>");
 
         lldb_private::StreamString ss;
 
         for (size_t i = 0; i < length; i++)
         {
lldb::addr_t ResolveValue (const Value *value, Module &module)
 
         lldb::addr_t data_address = Malloc(value->getType());
 
         if (const Constant *constant = dyn_cast<Constant>(value))
         {
             if (!ResolveConstant (data_address, constant))
             {
                 lldb_private::Error free_error;
-                m_memory_map.Free(data_address, free_error);
+                m_execution_unit.Free(data_address, free_error);
                 return LLDB_INVALID_ADDRESS;
             }
         }
 
         m_values[value] = data_address;
         return data_address;
     }
 };

 CanResolveConstant (llvm::Constant *constant)
 {
     switch (constant->getValueID())
     {
     default:
         return false;
     case Value::ConstantIntVal:
     case Value::ConstantFPVal:
+    case Value::FunctionVal:
         return true;
     case Value::ConstantExprVal:
         if (const ConstantExpr *constant_expr = dyn_cast<ConstantExpr>(constant))
         {
             switch (constant_expr->getOpcode())
             {
                 default:
                     return false;
IRInterpreter::CanInterpret (llvm::Module &module,
     }
 
     return true;}
 
 bool
 IRInterpreter::Interpret (llvm::Module &module,
                           llvm::Function &function,
                           llvm::ArrayRef<lldb::addr_t> args,
-                          lldb_private::IRMemoryMap &memory_map,
+                          lldb_private::IRExecutionUnit &execution_unit,
                           lldb_private::Error &error,
                           lldb::addr_t stack_frame_bottom,
                           lldb::addr_t stack_frame_top,
                           lldb_private::ExecutionContext &exe_ctx)
 {
     lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
 
     if (log)
     {
         std::string s;
         raw_string_ostream oss(s);
 
         module.print(oss, NULL);
 
         oss.flush();
 
         log->Printf("Module as passed in to IRInterpreter::Interpret: \n\"%s\"", s.c_str());
     }
 
     DataLayout data_layout(&module);
 
-    InterpreterStackFrame frame(data_layout, memory_map, stack_frame_bottom, stack_frame_top);
+    InterpreterStackFrame frame(data_layout, execution_unit, stack_frame_bottom, stack_frame_top);
 
     if (frame.m_frame_process_address == LLDB_INVALID_ADDRESS)
     {
         error.SetErrorString("Couldn't allocate stack frame");
     }
 
     int arg_index = 0;
 
while (frame.m_ii != frame.m_ie && (++num_insts < 4096))
                         log->Printf("Couldn't allocate the result pointer for an AllocaInst");
                     error.SetErrorToGenericError();
                     error.SetErrorString(memory_allocation_error);
                     return false;
                 }
 
                 lldb_private::Error write_error;
 
-                memory_map.WritePointerToMemory(P, R, write_error);
+                execution_unit.WritePointerToMemory(P, R, write_error);
 
                 if (!write_error.Success())
                 {
                     if (log)
                         log->Printf("Couldn't write the result pointer for an AllocaInst");
                     error.SetErrorToGenericError();
                     error.SetErrorString(memory_write_error);
                     lldb_private::Error free_error;
-                    memory_map.Free(P, free_error);
-                    memory_map.Free(R, free_error);
+                    execution_unit.Free(P, free_error);
+                    execution_unit.Free(R, free_error);
                     return false;
                 }
 
                 frame.m_values[alloca_inst] = P;
 
                 if (log)
                 {
                     log->Printf("Interpreted an AllocaInst");
while (frame.m_ii != frame.m_ie && (++num_insts < 4096))
                         log->Printf("LoadInst's pointer doesn't resolve to anything");
                     error.SetErrorToGenericError();
                     error.SetErrorString(bad_value_error);
                     return false;
                 }
 
                 lldb::addr_t R;
                 lldb_private::Error read_error;
-                memory_map.ReadPointerFromMemory(&R, P, read_error);
+                execution_unit.ReadPointerFromMemory(&R, P, read_error);
 
                 if (!read_error.Success())
                 {
                     if (log)
                         log->Printf("Couldn't read the address to be loaded for a LoadInst");
                     error.SetErrorToGenericError();
                     error.SetErrorString(memory_read_error);
                     return false;
                 }
 
                 size_t target_size = data_layout.getTypeStoreSize(target_ty);
                 lldb_private::DataBufferHeap buffer(target_size, 0);
 
                 read_error.Clear();
-                memory_map.ReadMemory(buffer.GetBytes(), R, buffer.GetByteSize(), read_error);
+                execution_unit.ReadMemory(buffer.GetBytes(), R, buffer.GetByteSize(), read_error);
                 if (!read_error.Success())
                 {
                     if (log)
                         log->Printf("Couldn't read from a region on behalf of a LoadInst");
                     error.SetErrorToGenericError();
                     error.SetErrorString(memory_read_error);
                     return false;
                 }
 
                 lldb_private::Error write_error;
-                memory_map.WriteMemory(D, buffer.GetBytes(), buffer.GetByteSize(), write_error);
+                execution_unit.WriteMemory(D, buffer.GetBytes(), buffer.GetByteSize(), write_error);
                 if (!write_error.Success())
                 {
                     if (log)
                         log->Printf("Couldn't write to a region on behalf of a LoadInst");
                     error.SetErrorToGenericError();
                     error.SetErrorString(memory_read_error);
                     return false;
                 }
while (frame.m_ii != frame.m_ie && (++num_insts < 4096))
                         log->Printf("StoreInst's pointer doesn't resolve to anything");
                     error.SetErrorToGenericError();
                     error.SetErrorString(bad_value_error);
                     return false;
                 }
 
                 lldb::addr_t R;
                 lldb_private::Error read_error;
-                memory_map.ReadPointerFromMemory(&R, P, read_error);
+                execution_unit.ReadPointerFromMemory(&R, P, read_error);
 
                 if (!read_error.Success())
                 {
                     if (log)
                         log->Printf("Couldn't read the address to be loaded for a LoadInst");
                     error.SetErrorToGenericError();
                     error.SetErrorString(memory_read_error);
                     return false;
                 }
 
                 size_t target_size = data_layout.getTypeStoreSize(target_ty);
                 lldb_private::DataBufferHeap buffer(target_size, 0);
 
                 read_error.Clear();
-                memory_map.ReadMemory(buffer.GetBytes(), D, buffer.GetByteSize(), read_error);
+                execution_unit.ReadMemory(buffer.GetBytes(), D, buffer.GetByteSize(), read_error);
                 if (!read_error.Success())
                 {
                     if (log)
                         log->Printf("Couldn't read from a region on behalf of a StoreInst");
                     error.SetErrorToGenericError();
                     error.SetErrorString(memory_read_error);
                     return false;
                 }
 
                 lldb_private::Error write_error;
-                memory_map.WriteMemory(R, buffer.GetBytes(), buffer.GetByteSize(), write_error);
+                execution_unit.WriteMemory(R, buffer.GetBytes(), buffer.GetByteSize(), write_error);
                 if (!write_error.Success())
                 {
                     if (log)
                         log->Printf("Couldn't write to a region on behalf of a StoreInst");
                     error.SetErrorToGenericError();
                     error.SetErrorString(memory_write_error);
                     return false;
                 }
while (frame.m_ii != frame.m_ie && (++num_insts < 4096))
                     if (arg_ty->isPointerTy())
                     {
                         // Pointer to just one type
                         assert(arg_ty->getNumContainedTypes() == 1);
 
                         lldb::addr_t addr = tmp_op.ULongLong();
                         size_t dataSize = 0;
 
-                        if (memory_map.GetAllocSize(addr, dataSize))
+                        if (execution_unit.GetAllocSize(addr, dataSize))
                         {
                             // Create the required buffer
                             rawArgs[i].size = dataSize;
                             rawArgs[i].data_ap.reset(new uint8_t[dataSize + 1]);
 
                             // Read string from host memory
-                            memory_map.ReadMemory(rawArgs[i].data_ap.get(), addr, dataSize, error);
+                            execution_unit.ReadMemory(rawArgs[i].data_ap.get(), addr, dataSize, error);
                             if (error.Fail())
                             {
                                 assert(!"we have failed to read the string from memory");
                                 return false;
                             }
                             // Add null terminator
                             rawArgs[i].data_ap[dataSize] = '\0';
                             rawArgs[i].type = lldb_private::ABI::CallArgument::HostPointer;

source/Expression/LLVMUserExpression.cpp

if (m_jit_start_addr != LLDB_INVALID_ADDRESS || m_can_interpret)
                 error_stream.Printf("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 (m_materialized_address != LLDB_INVALID_ADDRESS)
                 if (exe_ctx.GetProcessPtr())
                     exe_ctx.GetProcessPtr()->DeallocateMemory(m_materialized_address);
             if (m_stack_frame_bottom != LLDB_INVALID_ADDRESS)
                 if (exe_ctx.GetProcessPtr())
               exe_ctx.GetProcessPtr()->DeallocateMemory(m_stack_frame_bottom);