MFC r258884: Update LLDB to upstream r196259 snapshot

Sponsored by:	DARPA, AFRL

1 files changed, 45 insertions, 113 deletions

diff --git a/contrib/llvm/tools/lldb/source/Expression/ClangFunction.cpp b/contrib/llvm/tools/lldb/source/Expression/ClangFunction.cpp
index b37044d..e707c60 100644
--- a/contrib/llvm/tools/lldb/source/Expression/ClangFunction.cpp
+++ b/contrib/llvm/tools/lldb/source/Expression/ClangFunction.cpp
@@ -394,14 +394,9 @@ ClangFunction::InsertFunction (ExecutionContext &exe_ctx, lldb::addr_t &args_add
 
 ThreadPlan *
 ClangFunction::GetThreadPlanToCallFunction (ExecutionContext &exe_ctx, 
-                                            lldb::addr_t func_addr, 
-                                            lldb::addr_t &args_addr, 
-                                            Stream &errors, 
-                                            bool stop_others, 
-                                            bool unwind_on_error,
-                                            bool ignore_breakpoints,
-                                            lldb::addr_t *this_arg,
-                                            lldb::addr_t *cmd_arg)
+                                            lldb::addr_t args_addr,
+                                            const EvaluateExpressionOptions &options,
+                                            Stream &errors)
 {
     Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_EXPRESSIONS | LIBLLDB_LOG_STEP));
     
@@ -418,16 +413,15 @@ ClangFunction::GetThreadPlanToCallFunction (ExecutionContext &exe_ctx,
 
     // Okay, now run the function:
 
-    Address wrapper_address (func_addr);
+    Address wrapper_address (m_jit_start_addr);
+    
+    lldb::addr_t args = { args_addr };
+    
     ThreadPlan *new_plan = new ThreadPlanCallFunction (*thread, 
                                                        wrapper_address,
                                                        ClangASTType(),
-                                                       args_addr,
-                                                       stop_others, 
-                                                       unwind_on_error,
-                                                       ignore_breakpoints,
-                                                       this_arg,
-                                                       cmd_arg);
+                                                       args,
+                                                       options);
     new_plan->SetIsMasterPlan(true);
     new_plan->SetOkayToDiscard (false);
     return new_plan;
@@ -479,63 +473,48 @@ ClangFunction::DeallocateFunctionResults (ExecutionContext &exe_ctx, lldb::addr_
 }
 
 ExecutionResults
-ClangFunction::ExecuteFunction(ExecutionContext &exe_ctx, Stream &errors, Value &results)
-{
-    return ExecuteFunction (exe_ctx, errors, 1000, true, results);
-}
-
-ExecutionResults
-ClangFunction::ExecuteFunction(ExecutionContext &exe_ctx, Stream &errors, bool stop_others, Value &results)
-{
-    const bool try_all_threads = false;
-    const bool unwind_on_error = true;
-    const bool ignore_breakpoints = true;
-    return ExecuteFunction (exe_ctx, NULL, errors, stop_others, 0UL, try_all_threads,
-                            unwind_on_error, ignore_breakpoints, results);
-}
-
-ExecutionResults
 ClangFunction::ExecuteFunction(
         ExecutionContext &exe_ctx, 
+        lldb::addr_t *args_addr_ptr,
+        const EvaluateExpressionOptions &options,
         Stream &errors, 
-        uint32_t timeout_usec, 
-        bool try_all_threads, 
         Value &results)
 {
-    const bool stop_others = true;
-    const bool unwind_on_error = true;
-    const bool ignore_breakpoints = true;
-    return ExecuteFunction (exe_ctx, NULL, errors, stop_others, timeout_usec,
-                            try_all_threads, unwind_on_error, ignore_breakpoints, results);
-}
+    using namespace clang;
+    ExecutionResults return_value = eExecutionSetupError;
+    
+    // ClangFunction::ExecuteFunction execution is always just to get the result.  Do make sure we ignore
+    // breakpoints, unwind on error, and don't try to debug it.
+    EvaluateExpressionOptions real_options = options;
+    real_options.SetDebug(false);
+    real_options.SetUnwindOnError(true);
+    real_options.SetIgnoreBreakpoints(true);
+    
+    lldb::addr_t args_addr;
+    
+    if (args_addr_ptr != NULL)
+        args_addr = *args_addr_ptr;
+    else
+        args_addr = LLDB_INVALID_ADDRESS;
+        
+    if (CompileFunction(errors) != 0)
+        return eExecutionSetupError;
+    
+    if (args_addr == LLDB_INVALID_ADDRESS)
+    {
+        if (!InsertFunction(exe_ctx, args_addr, errors))
+            return eExecutionSetupError;
+    }
 
-// This is the static function
-ExecutionResults 
-ClangFunction::ExecuteFunction (
-        ExecutionContext &exe_ctx, 
-        lldb::addr_t function_address, 
-        lldb::addr_t &void_arg,
-        bool stop_others,
-        bool try_all_threads,
-        bool unwind_on_error,
-        bool ignore_breakpoints,
-        uint32_t timeout_usec,
-        Stream &errors,
-        lldb::addr_t *this_arg)
-{
     Log *log(lldb_private::GetLogIfAnyCategoriesSet (LIBLLDB_LOG_EXPRESSIONS | LIBLLDB_LOG_STEP));
 
     if (log)
         log->Printf("== [ClangFunction::ExecuteFunction] Executing function ==");
     
-    lldb::ThreadPlanSP call_plan_sp (ClangFunction::GetThreadPlanToCallFunction (exe_ctx,
-                                                                                 function_address, 
-                                                                                 void_arg, 
-                                                                                 errors, 
-                                                                                 stop_others, 
-                                                                                 unwind_on_error,
-                                                                                 ignore_breakpoints,
-                                                                                 this_arg));
+    lldb::ThreadPlanSP call_plan_sp (GetThreadPlanToCallFunction (exe_ctx,
+                                                                  args_addr,
+                                                                  real_options,
+                                                                  errors));
     if (!call_plan_sp)
         return eExecutionSetupError;
         
@@ -544,17 +523,14 @@ ClangFunction::ExecuteFunction (
     if (exe_ctx.GetProcessPtr())
         exe_ctx.GetProcessPtr()->SetRunningUserExpression(true);
     
-    ExecutionResults results = exe_ctx.GetProcessRef().RunThreadPlan (exe_ctx, call_plan_sp,
-                                                                      stop_others, 
-                                                                      try_all_threads, 
-                                                                      unwind_on_error,
-                                                                      ignore_breakpoints,
-                                                                      timeout_usec,
-                                                                      errors);
+    return_value = exe_ctx.GetProcessRef().RunThreadPlan (exe_ctx,
+                                                          call_plan_sp,
+                                                          real_options,
+                                                          errors);
     
     if (log)
     {
-        if (results != eExecutionCompleted)
+        if (return_value != eExecutionCompleted)
         {
             log->Printf("== [ClangFunction::ExecuteFunction] Execution completed abnormally ==");
         }
@@ -567,50 +543,6 @@ ClangFunction::ExecuteFunction (
     if (exe_ctx.GetProcessPtr())
         exe_ctx.GetProcessPtr()->SetRunningUserExpression(false);
     
-    return results;
-}
-
-ExecutionResults
-ClangFunction::ExecuteFunction(
-        ExecutionContext &exe_ctx, 
-        lldb::addr_t *args_addr_ptr, 
-        Stream &errors, 
-        bool stop_others, 
-        uint32_t timeout_usec, 
-        bool try_all_threads,
-        bool unwind_on_error,
-        bool ignore_breakpoints,
-        Value &results)
-{
-    using namespace clang;
-    ExecutionResults return_value = eExecutionSetupError;
-    
-    lldb::addr_t args_addr;
-    
-    if (args_addr_ptr != NULL)
-        args_addr = *args_addr_ptr;
-    else
-        args_addr = LLDB_INVALID_ADDRESS;
-        
-    if (CompileFunction(errors) != 0)
-        return eExecutionSetupError;
-    
-    if (args_addr == LLDB_INVALID_ADDRESS)
-    {
-        if (!InsertFunction(exe_ctx, args_addr, errors))
-            return eExecutionSetupError;
-    }
-    
-    return_value = ClangFunction::ExecuteFunction (exe_ctx, 
-                                                   m_jit_start_addr, 
-                                                   args_addr, 
-                                                   stop_others, 
-                                                   try_all_threads, 
-                                                   unwind_on_error,
-                                                   ignore_breakpoints,
-                                                   timeout_usec, 
-                                                   errors);
-
     if (args_addr_ptr != NULL)
         *args_addr_ptr = args_addr;