Expression evaluation, a new ThreadPlanCallFunctionNoJIT for executing a function call on target via register manipulation

[EwanCrawford]

Summary

For Hexagon we want to be able to call functions during debugging, however currently lldb only supports this when there is JIT support. Although emulation using IR interpretation is an alternative, it is currently limited in that it can't make function calls.

In this patch we have extended the IR interpreter so that it can execute a function call on the target using register manipulation. Which is the same method GDB uses for calling a function. To do this we need to handle the Call IR instruction, passing arguments to a new thread plan and collecting any return values to pass back into the IR interpreter. The new thread plan is needed to call an alternative ABI interface of "ABI::PerpareTrivialCall()", allowing more detailed information about arguments and return values.

Currently the expression evaluator checks if an expression can be interpreted and if it can it uses the IR interpreter, if it can't then it tries to JIT the expression and run it on target. It seems however that for targets that can JIT, it would be better to use that when executing a function call since its presumably much more robust. Perhaps this should be used exclusively for targets that cannot JIT?

I'd appreciate any feedback since this change touches a few important files.

[spyffe]

From the perspective of the IR interpreter, this is a great step forward. After some minor cleanup this should be a good addition.
I would prefer if the API eventually could take arbitrary arguments with LLVM types, but I realize that we're not at that point yet. We can make those improvements in-tree.
I will defer to Jim on the merits of ThreadPlanCallFunctionNoJIT.

source/Expression/IRInterpreter.cpp

1586 ↗

(On Diff #24742)

This is not 64-bit clean. Usually lldb::addr_t is the right container for a raw pointer from the inferior.

1591 ↗

(On Diff #24742)

At first glance this doesn't look too tricky to solve. Either CallArgument needs to be extended to be able to own data, or (if that is not the right way to do it) you could introduce a piece of storage (a vector of OwningPointers?) with the same lifespan as rawArgs.

1614 ↗

(On Diff #24742)

This code is not 64-bit clean.

[spyffe]

I'd definitely want a testcase when this gets submitted so that we verify we've caught all the Hexagon-specific aspects of this code.
We'd probably need to add a setting that prevents expressions from using the JIT to enable such a testcase.

[jingham]

I'd prefer if we could come up with a name that says what this DOES, not what it doesn't do which isn't all that helpful. Maybe ThreadPlanCallFunctionUsingABI? Other than that, this seems fine. Note there are some platforms (the Mach kernel for one) that don't support function calling of any sort. I think this patch is okay in that regard, but you do need to be careful you don't try this method just because JIT'ing isn't possible on such platforms.

Jim

[EwanCrawford]

Thanks for taking the time to review the patch.

In regards to adding a test case I agree it would be valuable but seems awkward to create right now. Since currently just Hexagon implements the necessary ABI functions. So before we could test any other arch we need to implement the alternative ABI::PrepareTrivialCall(), and ABI::GetReturnValueObject() signatures. However AFAIK if interpreting is available then it is chosen over JIT, therefore we wouldn't need a setting to disable JIT.

I could add a test case only working on Hexagon now, to expand on later, but that wouldn't help catch any Hexagon-specific assumptions.

[spyffe]

Adding a Hexagon-specific test case sounds like the right thing to do for now. Then whoever enables the necessary ABI support for x86_64 can just enable the testcase.

Sean

[ted]

The problem with a Hexagon-specific testcase is it would need to use the Hexagon simulator, which is not currently publicly available. We expect it to be available later this year.

Sean, would an XFAIL'd testcase with a binary, to be turned on when the simulator is publicly available, be acceptable?

[spyffe]

Ted,

I thought about this a bit. The test case just boils down to testing that you can call a function, right? On x86_64 we should just magically get the IR interpreter handling certain expressions with simple function calls.

So it should be simple enough to make a test case that calls a function with a few integer or pointer arguments. Right now you’d be able to see that testcase work on your simulator, and it would work fine on x86_64 by virtue of running on the JIT. Then, when the necessary ABI support gets into x86_64, we’ll be able to verify it using the same testcase.

Sean

[EwanCrawford]

Thanks for the feedback guys.

I added a test case calling some functions using expression evaluation. As mentioned this will only test the JIT on x86 for now, but would pass using the IR Interpreter on Hexagon.
If you had something else in mind for the test, or any other comments, let me know.

[EwanCrawford]

If there are no objections can I go ahead and commit?

[EwanCrawford]

Friendly ping.

[EwanCrawford]

Hi everyone, I'm still quite keen to get this patch through so I'd appreciate any more feedback you have.

Also If I'm adding new files, how do I go about updating the xcode project file?

[jingham]

Do you have a MacOS X system? If so I can explain how to add files in Xcode. If you don't, when you get around to checking this in just ping us and tell us what files you added, and one of us will add them to the project file.

Jim

[EwanCrawford]

Hiya Jim, I do have access to an OSX system with Xcode. It would be good to know how to add files for future reference.

[jingham]

Great. I am assuming these files are lldb_private, the instructions are slightly different for SB API files.

Open the lldb.xcworkspace in the top-level lldb directory. Select the Project Navigator from the Navigators on the LHS of the Xcode window, and figure out where in the project hierarchy your new files should go. For instance, if they relate to targets & live processes, they go in Source->Target, if expressions in the Source->Expressions folder, etc. Note, even if the headers & source files are separated into source & include on disk, we put them into the same Group in the project hierarchy.

Anyway, once you've determined what group you want them to go into, select that group in the Project Navigator and do File->Add Files. In the file picker, first select all the .cpp files, and add them. In the dialog that comes up, add the files to the lldb-core Target. Also make sure the files are "relative to Group" but that's the default value so you shouldn't have to change that setting.

Then do it again for the include files, but in that case DON'T add them to any target. The reason for this is that Xcode has some trickery to allow you to access headers as if they were in a directory with an explicit -I, without providing the path relative to include, but then those files wouldn't build with cmake. If you don't add them to the project, then this won't happen...

Note, you can check your work in the Utilities viewer - which you can open by clicking the right-most control on the toolbar - whose tooltip is "Hide or Show Utilities". That will show target ownership, etc.

Then clean & build to make sure everything worked.

Jim

[emaste]

Is it worth documenting the XCode steps in the www docs? I had the same question some time ago and had someone on the IRC channel walk me through it.

[EwanCrawford]

Thanks for the instructions Jim, I agree it would be good to get them documented somewhere.

[deepak2427]

Adding Greg for review.

[EwanCrawford]

Could we please get a final answer on this? Cheers.

[jingham]

I didn't look at the IRInterpreter part of this closely at first, but now looking over this a bit I am concerned about passing the ExecutionContext to CanInterpret, what information is that really providing? Do we expect some threads could interpret but not others? This just makes it confusing. It looks like in fact you only need the architecture, so maybe passing that - or getting it from something you already have your hands on - might be cleaner.

Also a trivial thing, but you do a whole bunch of work in the branch that handles the Call instruction, and then check that the execution context has a process in it, and bail otherwise. It would be cleaner to check that up front.

Finally, I didn't look at this too closely, but for some purposes it is important to ensure that you don't try to run the target at all. We should make sure we weren't accidentally using the fact that Interpret didn't run the target, as part of our strategy for implementing this...

[clayborg]

I will defer to Jim Ingham on this one. If he is OK with what you have done, I am good.

[EwanCrawford]

Thanks for taking the time to have a closer look Jim. Could you expand on your last point about situations where we don't want to run the target at all, it didn't quite click.

[EwanCrawford]

To address that final point of not doing any code execution at all for certain targets. I used the CanJIT() idea to create a similar CanInterpretFunctionCalls() member function of Process.
This means that we can just pass the value of the m_can_interpret_function_calls variable to CanInterpret() instead of the Arch or execution context.

Since interpreting function calls is a special case for hexagon right now the value defaults to false, and is only set to true by the hexagon dynamic loader.

In the future though when more targets support this feature, CanInterpretFunctionCalls() would be enabled by default and then specifically disabled by targets.
Using the example of the OSX kernel, which can't do any code execution, the patch explicitly sets jitting and interpreting function calls to false in the dynamic loader using an added CanRunCode() function.

[jingham]

For my part that looks great.

Jim

lldb/trunk/include/lldb/Expression/IRInterpreter.h

 /// in the target.  The IRInterpreter attempts to do this.
 //----------------------------------------------------------------------
 class IRInterpreter
 {
 public:
     static bool
     CanInterpret (llvm::Module &module,
                   llvm::Function &function,
-                  lldb_private::Error &error);
+                  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::Error &error,
                lldb::addr_t stack_frame_bottom,
-               lldb::addr_t stack_frame_top);
+               lldb::addr_t stack_frame_top,
+               lldb_private::ExecutionContext &exe_ctx);
     
 private:   
     static bool
     supportsFunction (llvm::Function &llvm_function,
                       lldb_private::Error &err);
 };
 
 #endif

lldb/trunk/include/lldb/Expression/IRMemoryMap.h

public:
     void Free (lldb::addr_t process_address, Error &error);
     
     void WriteMemory (lldb::addr_t process_address, const uint8_t *bytes, size_t size, Error &error);
     void WriteScalarToMemory (lldb::addr_t process_address, Scalar &scalar, size_t size, Error &error);
     void WritePointerToMemory (lldb::addr_t process_address, lldb::addr_t address, Error &error);
     void ReadMemory (uint8_t *bytes, lldb::addr_t process_address, size_t size, Error &error);
     void ReadScalarFromMemory (Scalar &scalar, lldb::addr_t process_address, size_t size, Error &error);
     void ReadPointerFromMemory (lldb::addr_t *address, lldb::addr_t process_address, Error &error);
-    
+    bool GetAllocSize(lldb::addr_t address, size_t &size);
     void GetMemoryData (DataExtractor &extractor, lldb::addr_t process_address, size_t size, Error &error);
     
     lldb::ByteOrder GetByteOrder();
     uint32_t GetAddressByteSize();
     
     // This function can return NULL.
     ExecutionContextScope *GetBestExecutionContextScope() const;
 

lldb/trunk/include/lldb/Target/ABI.h

public:
     {
         enum eType
         {
             HostPointer = 0,        /* pointer to host data */
             TargetValue ,           /* value is on the target or literal */
         };
         eType  type;                /* value of eType */
         size_t size;                /* size in bytes of this argument */
-        union {
-            lldb::addr_t  value;    /* literal value */
-            uint8_t      *data;     /* host data pointer */
-        };
+
+        lldb::addr_t  value;                    /* literal value */
+        std::unique_ptr<uint8_t[]> data_ap;     /* host data pointer */
     };
 
     virtual
     ~ABI();
 
     virtual size_t
     GetRedZoneSize () const = 0;
     
     virtual bool
     PrepareTrivialCall ( lldb_private::Thread &thread, 
                          lldb::addr_t sp,
                          lldb::addr_t functionAddress,
                          lldb::addr_t returnAddress, 
                          llvm::ArrayRef<lldb::addr_t> args) const = 0;
 
-    // Prepare trivial call used from ThreadPlanFunctionCallGDB
+    // Prepare trivial call used from ThreadPlanFunctionCallUsingABI
     // AD:
     //  . Because i don't want to change other ABI's this is not declared pure virtual.
     //    The dummy implementation will simply fail.  Only HexagonABI will currently
     //    use this method.
     //  . Two PrepareTrivialCall's is not good design so perhaps this should be combined.
     //
     virtual bool
     PrepareTrivialCall ( lldb_private::Thread &thread, 

lldb/trunk/include/lldb/Target/Process.h

public:
     //------------------------------------------------------------------
     /// Sets whether executing JIT-compiled code in this process 
     /// is possible.
     ///
     /// @param[in] can_jit
     ///     True if execution of JIT code is possible; false otherwise.
     //------------------------------------------------------------------
     void SetCanJIT (bool can_jit);
-    
     //------------------------------------------------------------------
+    /// Determines whether executing function calls using the interpreter
+    /// is possible for this process.
+    ///
+    /// @return
+    ///     True if possible; false otherwise.
+    //------------------------------------------------------------------
+    bool CanInterpretFunctionCalls ()
+    {
+        return m_can_interpret_function_calls;
+    }
+    
+    //------------------------------------------------------------------
+    /// Sets whether executing function calls using the interpreter
+    /// is possible for this process.
+    ///
+    /// @param[in] can_interpret_function_calls
+    ///     True if possible; false otherwise.
+    //------------------------------------------------------------------
+    void SetCanInterpretFunctionCalls (bool can_interpret_function_calls)
+    {
+        m_can_interpret_function_calls = can_interpret_function_calls;
+    }
+
+    //------------------------------------------------------------------
+    /// Sets whether executing code in this process is possible.
+    /// This could be either through JIT or interpreting.
+    ///
+    /// @param[in] can_run_code
+    ///     True if execution of code is possible; false otherwise.
+    //------------------------------------------------------------------
+    void SetCanRunCode (bool can_run_code);
+
+    //------------------------------------------------------------------
     /// Actually deallocate memory in the process.
     ///
     /// This function will deallocate memory in the process's address
     /// space that was allocated with AllocateMemory.
     ///
     /// @param[in] ptr
     ///     A return value from AllocateMemory, pointing to the memory you
     ///     want to deallocate.
protected:
     bool                        m_resume_requested;         // If m_currently_handling_event or m_currently_handling_do_on_removals are true, Resume will only request a resume, using this flag to check.
     bool                        m_finalizing; // This is set at the beginning of Process::Finalize() to stop functions from looking up or creating things during a finalize call
     bool                        m_finalize_called; // This is set at the end of Process::Finalize()
     bool                        m_clear_thread_plans_on_stop;
     bool                        m_force_next_event_delivery;
     lldb::StateType             m_last_broadcast_state;   /// This helps with the Public event coalescing in ShouldBroadcastEvent.
     std::map<lldb::addr_t,lldb::addr_t> m_resolved_indirect_addresses;
     bool m_destroy_in_process;
+    bool m_can_interpret_function_calls; // Some targets, e.g the OSX kernel, don't support the ability to modify the stack.
     
     enum {
         eCanJITDontKnow= 0,
         eCanJITYes,
         eCanJITNo
     } m_can_jit;
 
     size_t

lldb/trunk/include/lldb/Target/ThreadPlanCallFunction.h

class ThreadPlanCallFunction : public ThreadPlan
     // return type, otherwise just pass in an invalid ClangASTType.
 public:
     ThreadPlanCallFunction (Thread &thread,
                             const Address &function,
                             const ClangASTType &return_type,
                             llvm::ArrayRef<lldb::addr_t> args,
                             const EvaluateExpressionOptions &options);
 
+    ThreadPlanCallFunction(Thread &thread,
+                           const Address &function,
+                           const EvaluateExpressionOptions &options);
+
     virtual
     ~ThreadPlanCallFunction ();
 
     virtual void
     GetDescription (Stream *s, lldb::DescriptionLevel level);
 
     virtual bool
     ValidatePlan (Stream *error);
public:
     SetStopOthers (bool new_value);
     
 protected:
     void ReportRegisterState (const char *message);
 
     virtual bool
     DoPlanExplainsStop (Event *event_ptr);
 
-private:
+    virtual void
+    SetReturnValue();
 
     bool
     ConstructorSetup (Thread &thread,
                       ABI *& abi,
                       lldb::addr_t &start_load_addr,
                       lldb::addr_t &function_load_addr);
 
     void
     DoTakedown (bool success);
     
     void
     SetBreakpoints ();
     
     void
     ClearBreakpoints ();
     
     bool
     BreakpointsExplainStop ();
-    
     bool                                            m_valid;
     bool                                            m_stop_other_threads;
     bool                                            m_unwind_on_error;
     bool                                            m_ignore_breakpoints;
     bool                                            m_debug_execution;
     bool                                            m_trap_exceptions;
     Address                                         m_function_addr;
     Address                                         m_start_addr;
     lldb::addr_t                                    m_function_sp;
     lldb::ThreadPlanSP                              m_subplan_sp;
     LanguageRuntime                                *m_cxx_language_runtime;
     LanguageRuntime                                *m_objc_language_runtime;
     Thread::ThreadStateCheckpoint                   m_stored_thread_state;
     lldb::StopInfoSP                                m_real_stop_info_sp; // In general we want to hide call function
                                                                          // thread plans, but for reporting purposes,
                                                                          // it's nice to know the real stop reason.
                                                                          // This gets set in DoTakedown.
     StreamString                                    m_constructor_errors;
-    ClangASTType                                    m_return_type;
     lldb::ValueObjectSP                             m_return_valobj_sp;  // If this contains a valid pointer, use the ABI to extract values when complete
     bool                                            m_takedown_done;    // We want to ensure we only do the takedown once.  This ensures that.
     bool                                            m_should_clear_objc_exception_bp;
     bool                                            m_should_clear_cxx_exception_bp;
     lldb::addr_t                                    m_stop_address;     // This is the address we stopped at.  Also set in DoTakedown;
 
+private:
+    ClangASTType                                    m_return_type;
     DISALLOW_COPY_AND_ASSIGN (ThreadPlanCallFunction);
 };
 
 } // namespace lldb_private
 
 #endif  // liblldb_ThreadPlanCallFunction_h_

lldb/trunk/include/lldb/Target/ThreadPlanCallFunctionUsingABI.h

+//===-- ThreadPlanCallFunctionUsingABI.h --------------------------------*- C++ -*-===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef liblldb_ThreadPlanCallFunctionUsingABI_h_
+#define liblldb_ThreadPlanCallFunctionUsingABI_h_
+
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+// Project includes
+#include "lldb/lldb-private.h"
+#include "lldb/Target/ABI.h"
+#include "lldb/Target/Thread.h"
+#include "lldb/Target/ThreadPlanCallFunction.h"
+
+#include "llvm/ADT/ArrayRef.h"
+#include "llvm/IR/Type.h"
+
+namespace lldb_private {
+
+class ThreadPlanCallFunctionUsingABI : public ThreadPlanCallFunction
+{
+    // Create a thread plan to call a function at the address passed in the "function"
+    // argument, this function is executed using register manipulation instead of JIT.
+    // Class derives from ThreadPlanCallFunction and differs by calling a alternative
+    // ABI interface ABI::PrepareTrivialCall() which provides more detailed information.
+public:
+    ThreadPlanCallFunctionUsingABI (Thread &thread,
+                                 const Address &function_address,
+                                 llvm::Type &function_prototype,
+                                 llvm::Type &return_type,
+                                 llvm::ArrayRef<ABI::CallArgument> args,
+                                 const EvaluateExpressionOptions &options);
+
+    ~ThreadPlanCallFunctionUsingABI ();
+
+    void
+    GetDescription (Stream *s, lldb::DescriptionLevel level) override;
+
+protected:
+    void
+    SetReturnValue () override;
+
+
+private:
+    llvm::Type                                     &m_return_type;
+    DISALLOW_COPY_AND_ASSIGN (ThreadPlanCallFunctionUsingABI);
+};
+
+} // namespace lldb_private
+
+#endif  // liblldb_ThreadPlanCallFunctionUsingABI_h_

lldb/trunk/lldb.xcodeproj/project.pbxproj

     E7723D421AC4A7FB002BA082 /* RegisterContextPOSIXCore_arm64.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = RegisterContextPOSIXCore_arm64.cpp; sourceTree = "<group>"; };
     E7723D431AC4A7FB002BA082 /* RegisterContextPOSIXCore_arm64.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = RegisterContextPOSIXCore_arm64.h; sourceTree = "<group>"; };
     E7723D461AC4A8C8002BA082 /* RegisterContextFreeBSD_arm64.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = RegisterContextFreeBSD_arm64.cpp; path = Utility/RegisterContextFreeBSD_arm64.cpp; sourceTree = "<group>"; };
     E7723D471AC4A8C8002BA082 /* RegisterContextFreeBSD_arm64.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = RegisterContextFreeBSD_arm64.h; path = Utility/RegisterContextFreeBSD_arm64.h; sourceTree = "<group>"; };
     E7723D4A1AC4A944002BA082 /* RegisterContextPOSIX_arm64.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = RegisterContextPOSIX_arm64.cpp; path = Utility/RegisterContextPOSIX_arm64.cpp; sourceTree = "<group>"; };
     E7723D4B1AC4A944002BA082 /* RegisterContextPOSIX_arm64.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = RegisterContextPOSIX_arm64.h; path = Utility/RegisterContextPOSIX_arm64.h; sourceTree = "<group>"; };
     E778E99F1B062D1700247609 /* EmulateInstructionMIPS.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = EmulateInstructionMIPS.cpp; sourceTree = "<group>"; };
     E778E9A01B062D1700247609 /* EmulateInstructionMIPS.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = EmulateInstructionMIPS.h; sourceTree = "<group>"; };
+    EBDD01241B39B62F00E04792 /* ThreadPlanCallFunctionUsingABI.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = ThreadPlanCallFunctionUsingABI.cpp; path = source/Target/ThreadPlanCallFunctionUsingABI.cpp; sourceTree = "<group>"; };
+    EBDD01261B39B66700E04792 /* ThreadPlanCallFunctionUsingABI.h */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.c.h; name = ThreadPlanCallFunctionUsingABI.h; path = include/lldb/Target/ThreadPlanCallFunctionUsingABI.h; sourceTree = "<group>"; };
     ED88244F15114CA200BC98B9 /* main.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = main.mm; sourceTree = "<group>"; };
     ED88245215114CFC00BC98B9 /* LauncherRootXPCService.mm */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.objcpp; path = LauncherRootXPCService.mm; sourceTree = "<group>"; };
     EDB919B214F6EC85008FF64B /* LauncherXPCService.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = LauncherXPCService.h; sourceTree = "<group>"; };
     EDB919B414F6F10D008FF64B /* Security.framework */ = {isa = PBXFileReference; lastKnownFileType = wrapper.framework; name = Security.framework; path = /System/Library/Frameworks/Security.framework; sourceTree = "<absolute>"; };
     EDC6D49214E5C15C001B75F8 /* LauncherXPCService-Info.plist */ = {isa = PBXFileReference; explicitFileType = sourcecode.c.h; path = "LauncherXPCService-Info.plist"; sourceTree = "<group>"; };
     EDC6D49314E5C15C001B75F8 /* LauncherXPCService.entitlements */ = {isa = PBXFileReference; lastKnownFileType = text.xml; path = LauncherXPCService.entitlements; sourceTree = "<group>"; };
     EDC6D49414E5C15C001B75F8 /* LauncherXPCService.mm */ = {isa = PBXFileReference; lastKnownFileType = sourcecode.cpp.objcpp; path = LauncherXPCService.mm; sourceTree = "<group>"; };
     EDC6D49914E5C19B001B75F8 /* com.apple.lldb.launcherXPCService.xpc */ = {isa = PBXFileReference; explicitFileType = wrapper.cfbundle; includeInIndex = 0; path = com.apple.lldb.launcherXPCService.xpc; sourceTree = BUILT_PRODUCTS_DIR; };
26BC7DDF10F1B7E200F91463 /* Interpreter */ = {
         26BC7F0C10F1B8DD00F91463 /* ScriptInterpreterPython.cpp */,
       );
       name = Interpreter;
       sourceTree = "<group>";
     };
     26BC7DEF10F1B80200F91463 /* Target */ = {
       isa = PBXGroup;
       children = (
+        EBDD01261B39B66700E04792 /* ThreadPlanCallFunctionUsingABI.h */,
+        EBDD01241B39B62F00E04792 /* ThreadPlanCallFunctionUsingABI.cpp */,
         8CF02AE019DCBF3B00B14BE0 /* InstrumentationRuntime.h */,
         8CF02ADF19DCBF3B00B14BE0 /* InstrumentationRuntime.cpp */,
         8CF02AEE19DD15CF00B14BE0 /* InstrumentationRuntimeStopInfo.h */,
         8CF02AED19DD15CF00B14BE0 /* InstrumentationRuntimeStopInfo.cpp */,
         3FDFD6C3199C396E009756A7 /* FileAction.h */,
         3FDFDDBC199C3A06009756A7 /* FileAction.cpp */,
         23EDE3311926843600F6A132 /* NativeRegisterContext.h */,
         23EDE3301926839700F6A132 /* NativeRegisterContext.cpp */,
2689FFC613353D7A00698AC0 /* Sources */ = {
         26BC17AB18C7F4CB00D2196D /* ProcessElfCore.cpp in Sources */,
         AF1F7B07189C904B0087DB9C /* AppleGetPendingItemsHandler.cpp in Sources */,
         26B1FCC21338115F002886E2 /* Host.mm in Sources */,
         E778E9A21B062D1700247609 /* EmulateInstructionMIPS.cpp in Sources */,
         3FDFDDC6199D37ED009756A7 /* FileSystem.cpp in Sources */,
         26744EF11338317700EF765A /* GDBRemoteCommunicationClient.cpp in Sources */,
         26744EF31338317700EF765A /* GDBRemoteCommunicationServer.cpp in Sources */,
         264A97BF133918BC0017F0BE /* PlatformRemoteGDBServer.cpp in Sources */,
+        EBDD01251B39B62F00E04792 /* ThreadPlanCallFunctionUsingABI.cpp in Sources */,
         2697A54D133A6305004E4240 /* PlatformDarwin.cpp in Sources */,
         26651A18133BF9E0005B64B7 /* Opcode.cpp in Sources */,
         3FDFED0B19B7C8DE009756A7 /* HostThreadMacOSX.mm in Sources */,
         266603CA1345B5A8004DA8B6 /* ConnectionSharedMemory.cpp in Sources */,
         2671A0D013482601003A87BB /* ConnectionMachPort.cpp in Sources */,
         4CABA9E0134A8BCD00539BDD /* ValueObjectMemory.cpp in Sources */,
         4CD0BD0F134BFADF00CB44D4 /* ValueObjectDynamicValue.cpp in Sources */,
         946216C21A97C080006E19CC /* OptionValueLanguage.cpp in Sources */,

lldb/trunk/source/Expression/ClangExpressionParser.cpp

if (decl_map)
                                   m_expr.NeedsVariableResolution(),
                                   *execution_unit_sp,
                                   error_stream,
                                   function_name.AsCString());
 
         bool ir_can_run = ir_for_target.runOnModule(*execution_unit_sp->GetModule());
 
         Error interpret_error;
+        Process *process = exe_ctx.GetProcessPtr();
 
-        can_interpret = IRInterpreter::CanInterpret(*execution_unit_sp->GetModule(), *execution_unit_sp->GetFunction(), interpret_error);
+        bool interpret_function_calls = !process ? false : process->CanInterpretFunctionCalls();
+        can_interpret = IRInterpreter::CanInterpret(*execution_unit_sp->GetModule(), *execution_unit_sp->GetFunction(), interpret_error, interpret_function_calls);
 
-        Process *process = exe_ctx.GetProcessPtr();
 
         if (!ir_can_run)
         {
             err.SetErrorString("The expression could not be prepared to run in the target");
             return err;
         }
 
         if (!can_interpret && execution_policy == eExecutionPolicyNever)

lldb/trunk/source/Expression/ClangUserExpression.cpp

if (m_jit_start_addr != LLDB_INVALID_ADDRESS || m_can_interpret)
             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);
+                                      function_stack_top,
+                                      exe_ctx);
 
             if (!interpreter_error.Success())
             {
                 error_stream.Printf("Supposed to interpret, but failed: %s", interpreter_error.AsCString());
                 return lldb::eExpressionDiscarded;
             }
         }
         else

lldb/trunk/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/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/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"
+#include "lldb/Target/ThreadPlan.h"
+#include "lldb/Target/ThreadPlanCallFunctionUsingABI.h"
+
 #include "llvm/IR/Constants.h"
 #include "llvm/IR/DataLayout.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/Instructions.h"
 #include "llvm/IR/Intrinsics.h"
+#include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/raw_ostream.h"
 
 #include <map>
 
 using namespace llvm;
 
 static std::string

 static const char *memory_write_error               = "Interpreter couldn't write to memory";
 static const char *memory_read_error                = "Interpreter couldn't read from memory";
 static const char *infinite_loop_error              = "Interpreter ran for too many cycles";
 //static const char *bad_result_error                 = "Result of expression is in bad memory";
 
 bool
 IRInterpreter::CanInterpret (llvm::Module &module,
                              llvm::Function &function,
-                             lldb_private::Error &error)
+                             lldb_private::Error &error,
+                             const bool support_function_calls)
 {
     lldb_private::Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS));
 
     bool saw_function_with_body = false;
 
     for (Module::iterator fi = module.begin(), fe = module.end();
          fi != fe;
          ++fi)
for (Function::iterator bbi = function.begin(), bbe = function.end();
 
                     if (!call_inst)
                     {
                         error.SetErrorToGenericError();
                         error.SetErrorString(interpreter_internal_error);
                         return false;
                     }
 
-                    if (!CanIgnoreCall(call_inst))
+                    if (!CanIgnoreCall(call_inst) && !support_function_calls)
                     {
                         if (log)
                             log->Printf("Unsupported instruction: %s", PrintValue(ii).c_str());
                         error.SetErrorToGenericError();
                         error.SetErrorString(unsupported_opcode_error);
                         return false;
                     }
                 }

 
 bool
 IRInterpreter::Interpret (llvm::Module &module,
                           llvm::Function &function,
                           llvm::ArrayRef<lldb::addr_t> args,
                           lldb_private::IRMemoryMap &memory_map,
                           lldb_private::Error &error,
                           lldb::addr_t stack_frame_bottom,
-                          lldb::addr_t stack_frame_top)
+                          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);
 
while (frame.m_ii != frame.m_ie && (++num_insts < 4096))
 
         if (log)
             log->Printf("Interpreting %s", PrintValue(inst).c_str());
 
         switch (inst->getOpcode())
         {
             default:
                 break;
-            case Instruction::Call:
-            {
-                const CallInst *call_inst = dyn_cast<CallInst>(inst);
-
-                if (!call_inst)
-                {
-                    if (log)
-                        log->Printf("getOpcode() returns %s, but instruction is not a CallInst", inst->getOpcodeName());
-                    error.SetErrorToGenericError();
-                    error.SetErrorString(interpreter_internal_error);
-                    return false;
-                }
 
-                if (!CanIgnoreCall(call_inst))
-                {
-                    if (log)
-                        log->Printf("The interpreter shouldn't have accepted %s", PrintValue(call_inst).c_str());
-                    error.SetErrorToGenericError();
-                    error.SetErrorString(interpreter_internal_error);
-                    return false;
-                }
-            }
-                break;
             case Instruction::Add:
             case Instruction::Sub:
             case Instruction::Mul:
             case Instruction::SDiv:
             case Instruction::UDiv:
             case Instruction::SRem:
             case Instruction::URem:
             case Instruction::Shl:
while (frame.m_ii != frame.m_ie && (++num_insts < 4096))
                 {
                     log->Printf("Interpreted a StoreInst");
                     log->Printf("  D : 0x%" PRIx64, D);
                     log->Printf("  P : 0x%" PRIx64, P);
                     log->Printf("  R : 0x%" PRIx64, R);
                 }
             }
                 break;
+            case Instruction::Call:
+            {
+                const CallInst *call_inst = dyn_cast<CallInst>(inst);
+
+                if (!call_inst)
+                {
+                    if (log)
+                       log->Printf("getOpcode() returns %s, but instruction is not a CallInst", inst->getOpcodeName());
+                    error.SetErrorToGenericError();
+                    error.SetErrorString(interpreter_internal_error);
+                    return false;
+                }
+
+                if (CanIgnoreCall(call_inst))
+                    break;
+
+                // Get the return type
+                llvm::Type *returnType = call_inst->getType();
+                if (returnType == nullptr)
+                {
+                    error.SetErrorToGenericError();
+                    error.SetErrorString("unable to access return type");
+                    return false;
+                }
+
+                // Work with void, integer and pointer return types
+                if (!returnType->isVoidTy() &&
+                    !returnType->isIntegerTy() &&
+                    !returnType->isPointerTy())
+                {
+                    error.SetErrorToGenericError();
+                    error.SetErrorString("return type is not supported");
+                    return false;
+                }
+
+                // Check we can actually get a thread
+                if (exe_ctx.GetThreadPtr() == nullptr)
+                {
+                    error.SetErrorToGenericError();
+                    error.SetErrorStringWithFormat("unable to acquire thread");
+                    return false;
+                }
+
+                // Make sure we have a valid process
+                if (!exe_ctx.GetProcessPtr())
+                {
+                    error.SetErrorToGenericError();
+                    error.SetErrorStringWithFormat("unable to get the process");
+                    return false;
+                }
+
+                // Find the address of the callee function
+                lldb_private::Scalar I;
+                const llvm::Value *val = call_inst->getCalledValue();
+
+                if (!frame.EvaluateValue(I, val, module))
+                {
+                    error.SetErrorToGenericError();
+                    error.SetErrorString("unable to get address of function");
+                    return false;
+                }
+                lldb_private::Address funcAddr(I.ULongLong(LLDB_INVALID_ADDRESS));
+
+                lldb_private::StreamString error_stream;
+                lldb_private::EvaluateExpressionOptions options;
+
+                // We generally receive a function pointer which we must dereference
+                llvm::Type* prototype = val->getType();
+                if (!prototype->isPointerTy())
+                {
+                    error.SetErrorToGenericError();
+                    error.SetErrorString("call need function pointer");
+                    return false;
+                }
+
+                // Dereference the function pointer
+                prototype = prototype->getPointerElementType();
+                if (!(prototype->isFunctionTy() || prototype->isFunctionVarArg()))
+                {
+                    error.SetErrorToGenericError();
+                    error.SetErrorString("call need function pointer");
+                    return false;
+                }
+
+                // Find number of arguments
+                const int numArgs = call_inst->getNumArgOperands();
+
+                // We work with a fixed array of 16 arguments which is our upper limit
+                static lldb_private::ABI::CallArgument rawArgs[16];
+                if (numArgs >= 16)
+                {
+                    error.SetErrorToGenericError();
+                    error.SetErrorStringWithFormat("function takes too many arguments");
+                    return false;
+                }
+
+                // Push all function arguments to the argument list that will
+                // be passed to the call function thread plan
+                for (int i = 0; i < numArgs; i++)
+                {
+                    // Get details of this argument
+                    llvm::Value *arg_op = call_inst->getArgOperand(i);
+                    llvm::Type  *arg_ty = arg_op->getType();
+
+                    // Ensure that this argument is an supported type
+                    if (!arg_ty->isIntegerTy() && !arg_ty->isPointerTy())
+                    {
+                         error.SetErrorToGenericError();
+                         error.SetErrorStringWithFormat("argument %d must be integer type", i);
+                         return false;
+                    }
+
+                    // Extract the arguments value
+                    lldb_private::Scalar tmp_op = 0;
+                    if (!frame.EvaluateValue(tmp_op, arg_op, module))
+                    {
+                         error.SetErrorToGenericError();
+                         error.SetErrorStringWithFormat("unable to evaluate argument %d", i);
+                         return false;
+                    }
+
+                    // Check if this is a string literal or constant string pointer
+                    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))
+                        {
+                            // 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);
+                            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;
+                        }
+                        else
+                        {
+                            assert(!"unable to locate host data for transfer to device");
+                            return false;
+                        }
+                    }
+                    else /* if ( arg_ty->isPointerTy() ) */
+                    {
+                        rawArgs[i].type = lldb_private::ABI::CallArgument::TargetValue;
+                        // Get argument size in bytes
+                        rawArgs[i].size = arg_ty->getIntegerBitWidth() / 8;
+                        // Push value into argument list for thread plan
+                        rawArgs[i].value = tmp_op.ULongLong();
+                    }
+
+                }
+
+                // Pack the arguments into an llvm::array
+                llvm::ArrayRef<lldb_private::ABI::CallArgument> args(rawArgs, numArgs);
+
+                // Setup a thread plan to call the target function
+                lldb::ThreadPlanSP call_plan_sp
+                (
+                    new lldb_private::ThreadPlanCallFunctionUsingABI
+                    (
+                        exe_ctx.GetThreadRef(),
+                        funcAddr,
+                        *prototype,
+                        *returnType,
+                        args,
+                        options
+                    )
+                );
+
+                // Check if the plan is valid
+                if (!call_plan_sp || !call_plan_sp->ValidatePlan(&error_stream))
+                {
+                    error.SetErrorToGenericError();
+                    error.SetErrorStringWithFormat("unable to make ThreadPlanCallFunctionUsingABI for 0x%llx", I.ULongLong());
+                    return false;
+                }
+
+                exe_ctx.GetProcessPtr()->SetRunningUserExpression(true);
+
+                // Execute the actual function call thread plan
+                lldb::ExpressionResults res = exe_ctx.GetProcessRef().RunThreadPlan(exe_ctx, call_plan_sp, options, error_stream);
+
+                // Check that the thread plan completed successfully
+                if (res != lldb::ExpressionResults::eExpressionCompleted)
+                {
+                    error.SetErrorToGenericError();
+                    error.SetErrorStringWithFormat("ThreadPlanCallFunctionUsingABI failed");
+                    return false;
+                }
+
+                exe_ctx.GetProcessPtr()->SetRunningUserExpression(false);
+
+                // Void return type
+                if (returnType->isVoidTy())
+                {
+                    // Cant assign to void types, so we leave the frame untouched
+                }
+                else
+                    // Integer or pointer return type
+                    if (returnType->isIntegerTy() || returnType->isPointerTy())
+                    {
+                        // Get the encapsulated return value
+                        lldb::ValueObjectSP retVal = call_plan_sp.get()->GetReturnValueObject();
+
+                        lldb_private::Scalar returnVal = -1;
+                        lldb_private::ValueObject *vobj = retVal.get();
+
+                        // Check if the return value is valid
+                        if (vobj == nullptr || retVal.empty())
+                        {
+                            error.SetErrorToGenericError();
+                            error.SetErrorStringWithFormat("unable to get the return value");
+                            return false;
+                        }
+
+                        // Extract the return value as a integer
+                        lldb_private::Value & value = vobj->GetValue();
+                        returnVal = value.GetScalar();
+
+                        // Push the return value as the result
+                        frame.AssignValue(inst, returnVal, module);
+                    }
+            }
+                break;
         }
 
         ++frame.m_ii;
     }
 
     if (num_insts >= 4096)
     {
         error.SetErrorToGenericError();
         error.SetErrorString(infinite_loop_error);
         return false;
     }
 
     return false;
 }

lldb/trunk/source/Expression/IRMemoryMap.cpp

if (lldb_private::Log *log = lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_EXPRESSIONS))
                     (uint64_t)process_address,
                     iter->second.m_process_start,
                     iter->second.m_process_start + iter->second.m_size);
     }
 
     m_allocations.erase(iter);
 }
 
+bool
+IRMemoryMap::GetAllocSize(lldb::addr_t address, size_t &size)
+{
+    AllocationMap::iterator iter = FindAllocation(address, size);
+    if (iter == m_allocations.end())
+        return false;
+
+    Allocation &al = iter->second;
+
+    if (address > (al.m_process_start + al.m_size))
+    {
+        size = 0;
+        return false;
+    }
+
+    if (address > al.m_process_start)
+    {
+        int dif = address - al.m_process_start;
+        size = al.m_size - dif;
+        return true;
+    }
+
+    size = al.m_size;
+    return true;
+}
+
 void
 IRMemoryMap::WriteMemory (lldb::addr_t process_address, const uint8_t *bytes, size_t size, Error &error)
 {
     error.Clear();
 
     AllocationMap::iterator iter = FindAllocation(process_address, size);
 
     if (iter == m_allocations.end())

lldb/trunk/source/Plugins/ABI/SysV-hexagon/ABISysV_hexagon.cpp

for ( size_t i = 0; i < args.size( ); i++ )
             continue;
         // round up to 8 byte multiple
         size_t argSize = ( arg.size | 0x7 ) + 1;
 
         // create space on the stack for this data
         sp -= argSize;
 
         // write this argument onto the stack of the host process
-        proc.get( )->WriteMemory( sp, arg.data, arg.size, error );
+        proc.get( )->WriteMemory( sp, arg.data_ap.get(), arg.size, error );
         if ( error.Fail( ) )
             return false;
 
         // update the argument with the target pointer
         //XXX: This is a gross hack for getting around the const
         *const_cast<lldb::addr_t*>(&arg.value) = sp;
     }
 

lldb/trunk/source/Plugins/DynamicLoader/Darwin-Kernel/DynamicLoaderDarwinKernel.cpp

DynamicLoaderDarwinKernel::CreateInstance (Process* process, bool force)
     }
 
     // At this point if there is an ExecutableModule, it is a kernel and the Target is some variant of an Apple system.  
     // If the Process hasn't provided the kernel load address, we need to look around in memory to find it.
 
     addr_t kernel_load_address = SearchForDarwinKernel (process);
     if (kernel_load_address != LLDB_INVALID_ADDRESS)
     {
-        process->SetCanJIT(false);
+        process->SetCanRunCode(false);
         return new DynamicLoaderDarwinKernel (process, kernel_load_address);
     }
     return NULL;
 }
 
 lldb::addr_t
 DynamicLoaderDarwinKernel::SearchForDarwinKernel (Process *process)
 {

lldb/trunk/source/Plugins/DynamicLoader/Hexagon-DYLD/DynamicLoaderHexagonDYLD.cpp

DynamicLoaderHexagonDYLD::DidAttach()
 
     // Check that there is a valid executable
     if ( executable.get( ) == nullptr )
         return;
         
     // Disable JIT for hexagon targets because its not supported
     m_process->SetCanJIT(false);
 
+    // Enable Interpreting of function call expressions
+    m_process->SetCanInterpretFunctionCalls(true);
+
     // Add the current executable to the module list
     ModuleList module_list;
     module_list.Append(executable);
 
     // Map the loaded sections of this executable
     if ( load_offset != LLDB_INVALID_ADDRESS )
         UpdateLoadedSections(executable, LLDB_INVALID_ADDRESS, load_offset);
 

lldb/trunk/source/Target/CMakeLists.txt

add_lldb_library(lldbTarget
   Target.cpp
   TargetList.cpp
   Thread.cpp
   ThreadCollection.cpp
   ThreadList.cpp
   ThreadPlan.cpp
   ThreadPlanBase.cpp
   ThreadPlanCallFunction.cpp
+  ThreadPlanCallFunctionUsingABI.cpp
   ThreadPlanCallUserExpression.cpp
   ThreadPlanPython.cpp
   ThreadPlanRunToAddress.cpp
   ThreadPlanShouldStopHere.cpp
   ThreadPlanStepInRange.cpp
   ThreadPlanStepInstruction.cpp
   ThreadPlanStepOut.cpp
   ThreadPlanStepOverBreakpoint.cpp

lldb/trunk/source/Target/Process.cpp

Process::Process(Target &target, Listener &listener, const UnixSignalsSP &unix_signals_sp) :
     m_currently_handling_event(false),
     m_stop_info_override_callback (NULL),
     m_finalizing (false),
     m_finalize_called (false),
     m_clear_thread_plans_on_stop (false),
     m_force_next_event_delivery (false),
     m_last_broadcast_state (eStateInvalid),
     m_destroy_in_process (false),
+    m_can_interpret_function_calls(false),
     m_can_jit(eCanJITDontKnow)
 {
     CheckInWithManager ();
 
     Log *log(lldb_private::GetLogIfAllCategoriesSet (LIBLLDB_LOG_OBJECT));
     if (log)
         log->Printf ("%p Process::Process()", static_cast<void*>(this));
 

 }
 
 void
 Process::SetCanJIT (bool can_jit)
 {
     m_can_jit = (can_jit ? eCanJITYes : eCanJITNo);
 }
 
+void
+Process::SetCanRunCode (bool can_run_code)
+{
+    SetCanJIT(can_run_code);
+    m_can_interpret_function_calls = can_run_code;
+}
+
 Error
 Process::DeallocateMemory (addr_t ptr)
 {
     Error error;
 #if defined (USE_ALLOCATE_MEMORY_CACHE)
     if (!m_allocated_memory_cache.DeallocateMemory(ptr))
     {
         error.SetErrorStringWithFormat ("deallocation of memory at 0x%" PRIx64 " failed.", (uint64_t)ptr);

lldb/trunk/source/Target/ThreadPlanCallFunction.cpp

ThreadPlanCallFunction::ThreadPlanCallFunction (Thread &thread,
     m_valid (false),
     m_stop_other_threads (options.GetStopOthers()),
     m_unwind_on_error (options.DoesUnwindOnError()),
     m_ignore_breakpoints (options.DoesIgnoreBreakpoints()),
     m_debug_execution (options.GetDebug()),
     m_trap_exceptions (options.GetTrapExceptions()),
     m_function_addr (function),
     m_function_sp (0),
-    m_return_type (return_type),
     m_takedown_done (false),
     m_should_clear_objc_exception_bp(false),
     m_should_clear_cxx_exception_bp (false),
-    m_stop_address (LLDB_INVALID_ADDRESS)
+    m_stop_address (LLDB_INVALID_ADDRESS),
+    m_return_type (return_type)
 {
-    lldb::addr_t start_load_addr;
-    ABI *abi;
-    lldb::addr_t function_load_addr;
+    lldb::addr_t start_load_addr = LLDB_INVALID_ADDRESS;
+    lldb::addr_t function_load_addr = LLDB_INVALID_ADDRESS;
+    ABI *abi = nullptr;
+
     if (!ConstructorSetup (thread, abi, start_load_addr, function_load_addr))
         return;
 
     if (!abi->PrepareTrivialCall(thread,
                                  m_function_sp,
                                  function_load_addr,
                                  start_load_addr,
                                  args))
         return;
 
     ReportRegisterState ("Function call was set up.  Register state was:");
 
     m_valid = true;    
 }
 
+ThreadPlanCallFunction::ThreadPlanCallFunction(Thread &thread,
+                                               const Address &function,
+                                               const EvaluateExpressionOptions &options) :
+    ThreadPlan(ThreadPlan::eKindCallFunction, "Call function plan", thread, eVoteNoOpinion, eVoteNoOpinion),
+    m_valid(false),
+    m_stop_other_threads(options.GetStopOthers()),
+    m_unwind_on_error(options.DoesUnwindOnError()),
+    m_ignore_breakpoints(options.DoesIgnoreBreakpoints()),
+    m_debug_execution(options.GetDebug()),
+    m_trap_exceptions(options.GetTrapExceptions()),
+    m_function_addr(function),
+    m_function_sp(0),
+    m_takedown_done(false),
+    m_should_clear_objc_exception_bp(false),
+    m_should_clear_cxx_exception_bp(false),
+    m_stop_address(LLDB_INVALID_ADDRESS),
+    m_return_type(ClangASTType())
+{
+
+}
+
 ThreadPlanCallFunction::~ThreadPlanCallFunction ()
 {
     DoTakedown(PlanSucceeded());
 }
 
 void
 ThreadPlanCallFunction::ReportRegisterState (const char *message)
 {
if (!m_valid)
                          static_cast<void*>(this));
         return;
     }
 
     if (!m_takedown_done)
     {
         if (success)
         {
-            ProcessSP process_sp (m_thread.GetProcess());
-            const ABI *abi = process_sp ? process_sp->GetABI().get() : NULL;
-            if (abi && m_return_type.IsValid())
-            {
-                const bool persistent = false;
-                m_return_valobj_sp = abi->GetReturnValueObject (m_thread, m_return_type, persistent);
-            }
+            SetReturnValue();
         }
         if (log)
             log->Printf ("ThreadPlanCallFunction(%p): DoTakedown called for thread 0x%4.4" PRIx64 ", m_valid: %d complete: %d.\n",
                          static_cast<void*>(this), m_thread.GetID(), m_valid,
                          IsPlanComplete());
         m_takedown_done = true;
         m_stop_address = m_thread.GetStackFrameAtIndex(0)->GetRegisterContext()->GetPC();
         m_real_stop_info_sp = GetPrivateStopInfo ();

 
 
 bool
 ThreadPlanCallFunction::RestoreThreadState()
 {
     return GetThread().RestoreThreadStateFromCheckpoint(m_stored_thread_state);
 }
 
+
+void
+ThreadPlanCallFunction::SetReturnValue()
+{
+    ProcessSP process_sp(m_thread.GetProcess());
+    const ABI *abi = process_sp ? process_sp->GetABI().get() : NULL;
+    if (abi && m_return_type.IsValid())
+    {
+        const bool persistent = false;
+        m_return_valobj_sp = abi->GetReturnValueObject(m_thread, m_return_type, persistent);
+    }
+}

lldb/trunk/source/Target/ThreadPlanCallFunctionUsingABI.cpp

+//===-- ThreadPlanCallFunctionUsingABI.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/Target/ThreadPlanCallFunctionUsingABI.h"
+
+// C Includes
+// C++ Includes
+// Other libraries and framework includes
+
+// Project includes
+#include "lldb/Core/Address.h"
+#include "lldb/Core/Log.h"
+#include "lldb/Core/Stream.h"
+#include "lldb/Target/Process.h"
+#include "lldb/Target/RegisterContext.h"
+#include "lldb/Target/Target.h"
+#include "lldb/Target/Thread.h"
+
+using namespace lldb;
+using namespace lldb_private;
+
+//--------------------------------------------------------------------------------------------
+// ThreadPlanCallFunctionUsingABI: Plan to call a single function using the ABI instead of JIT
+//-------------------------------------------------------------------------------------------
+ThreadPlanCallFunctionUsingABI::ThreadPlanCallFunctionUsingABI (Thread &thread,
+                                                          const Address &function,
+                                                          llvm::Type &prototype,
+                                                          llvm::Type &return_type,
+                                                          llvm::ArrayRef<ABI::CallArgument> args,
+                                                          const EvaluateExpressionOptions &options) :
+     ThreadPlanCallFunction(thread,function,options),
+     m_return_type(return_type)
+{
+    lldb::addr_t start_load_addr = LLDB_INVALID_ADDRESS;
+    lldb::addr_t function_load_addr = LLDB_INVALID_ADDRESS;
+    ABI *abi = nullptr;
+
+    if (!ConstructorSetup(thread, abi, start_load_addr, function_load_addr))
+        return;
+
+    if (!abi->PrepareTrivialCall(thread,
+        m_function_sp,
+        function_load_addr,
+        start_load_addr,
+        prototype,
+        args))
+        return;
+
+    ReportRegisterState("ABI Function call was set up.  Register state was:");
+
+    m_valid = true;
+}
+
+ThreadPlanCallFunctionUsingABI::~ThreadPlanCallFunctionUsingABI()
+{
+
+}
+
+void
+ThreadPlanCallFunctionUsingABI::GetDescription(Stream *s, DescriptionLevel level)
+{
+    if (level == eDescriptionLevelBrief)
+    {
+        s->Printf("Function call thread plan using ABI instead of JIT");
+    }
+    else
+    {
+        TargetSP target_sp(m_thread.CalculateTarget());
+        s->Printf("Thread plan to call 0x%" PRIx64" using ABI instead of JIT", m_function_addr.GetLoadAddress(target_sp.get()));
+    }
+}
+
+void
+ThreadPlanCallFunctionUsingABI::SetReturnValue()
+{
+    ProcessSP process_sp(m_thread.GetProcess());
+    const ABI *abi = process_sp ? process_sp->GetABI().get() : NULL;
+
+    // Ask the abi for the return value
+    if (abi)
+    {
+        const bool persistent = false;
+        m_return_valobj_sp = abi->GetReturnValueObject(m_thread, m_return_type, persistent);
+    }
+}

lldb/trunk/test/expression_command/call-function/TestCallUserDefinedFunction.py

+"""
+Test calling user defined functions using expression evaluation.
+
+Note:
+  LLDBs current first choice of evaluating functions is using the IR interpreter,
+  which is only supported on Hexagon. Otherwise JIT is used for the evaluation.
+
+"""
+
+import unittest2
+import lldb
+import lldbutil
+from lldbtest import *
+
+class ExprCommandCallUserDefinedFunction(TestBase):
+
+    mydir = TestBase.compute_mydir(__file__)
+
+    def setUp(self):
+        # Call super's setUp().
+        TestBase.setUp(self)
+        # Find the line number to break for main.c.
+        self.line = line_number('main.cpp',
+                                '// Please test these expressions while stopped at this line:')
+    @skipUnlessDarwin
+    @dsym_test
+    @expectedFailureDarwin("llvm.org/pr20274") # intermittent failure on MacOSX
+    def test_with_dsym(self):
+        """Test return values of user defined function calls."""
+        self.buildDsym()
+        self.call_function()
+
+    @dwarf_test
+    @expectedFailureFreeBSD("llvm.org/pr20274") # intermittent failure
+    def test_with_dwarf(self):
+        """Test return values of user defined function calls."""
+        self.buildDwarf()
+        self.call_functions()
+
+    def call_functions(self):
+        """Test return values of user defined function calls."""
+
+        # Set breakpoint in main and run exe
+        self.runCmd("file a.out", CURRENT_EXECUTABLE_SET)
+        lldbutil.run_break_set_by_file_and_line (self, "main.cpp", self.line, num_expected_locations=-1, loc_exact=True)
+
+        self.runCmd("run", RUN_SUCCEEDED)
+
+        # Test recursive function call.
+        self.expect("expr fib(5)", substrs = ['$0 = 5'])
+
+        # Test function with more than one paramter
+        self.expect("expr add(4,8)", substrs = ['$1 = 12'])
+
+        # Test nesting function calls in function paramters
+        self.expect("expr add(add(5,2),add(3,4))", substrs = ['$2 = 14'])
+        self.expect("expr add(add(5,2),fib(5))", substrs = ['$3 = 12'])
+
+        # Test function with pointer paramter
+        self.expect("exp stringCompare((const char*) \"Hello world\")", substrs = ['$4 = true'])
+        self.expect("exp stringCompare((const char*) \"Hellworld\")", substrs = ['$5 = false'])
+
+
+if __name__ == '__main__':
+    import atexit
+    lldb.SBDebugger.Initialize()
+    atexit.register(lambda: lldb.SBDebugger.Terminate())
+    unittest2.main()

lldb/trunk/test/expression_command/call-function/main.cpp

 #include <iostream>
 #include <string>
+#include <cstring>
 
 struct Five
 {
     int number;
     const char *name;
 };
 
 Five
 returnsFive()
 {
     Five my_five = { 5, "five" };
     return my_five;
 }
 
+unsigned int
+fib(unsigned int n)
+{
+    if (n < 2)
+        return n;
+    else
+        return fib(n - 1) + fib(n - 2);
+}
+
+int
+add(int a, int b)
+{
+    return a + b;
+}
+
+bool
+stringCompare(const char *str)
+{
+    if (strcmp( str, "Hello world" ) == 0)
+        return true;
+    else
+        return false;
+}
+
 int main (int argc, char const *argv[])
 {
     std::string str = "Hello world";
     std::cout << str << std::endl;
     std::cout << str.c_str() << std::endl;
     Five main_five = returnsFive();
 #if 0
     print str
     print str.c_str()
 #endif
     return 0; // Please test these expressions while stopped at this line:
 }