[lldb] Optimize expressions

[teemperor]

Summary

At the moment we codegen or interpret the IR in exactly the way as it is generated by Clang.
This patch runs the default O2 optimizations over the generated LLVM module before we
interpret or JIT it.

The motivation for this patch is twofold. First, LLDB contains an LLVM IR interpreter that
supports a very limited subset of LLVM instructions for the sake of maintainability. The
IR interpreter is intended as a fast first path to run the code provided by the user (fast in
comparison to JITing and injecting the code). It also is the only way LLDB can evaluate
expressions for targets where we cant JIT&inject code. Because the LLVM IR interpreter
only supports a limited set of instructions, most non-trivial Clang expression can't be
interpreted which is really limiting the expression evaluator functionality when we can't
JIT code. By running running the default -O2 passes over the IR before interpreting it,
LLVM will give us usually a much more concise IR that the IR interpreter can more often
than not handle.

Second, sometimes users want to run expressions that are simple but might process quite
a bit of data. An example for that would be any algorithm that users can now invoke via
the std C++ module. Calling std::count_if with a relatively simple predicate on a large
vector currently takes far too long to be considered usable.

To give some stats on the first claim:

• Currently we run about 7700 expressions in a test suit run (the actual number of expressions is fluctuating a bit....)
• Around 5800 of these expressions are simple enough that the IR interpreter can interpret them right now (most of them just print simple variables)
• This leaves us with around 1900 expressions that we currently can't interpret in the test suite.
• After applying this patch the number of expressions we can't interpret drops to around 1300 (-33%).
• The average expression evaluation time when running on my local machine doesn't change with this patch (around 50ms before and after).

The patch consists of two parts:

• The generic (new) pass manager setup and run code.
• Some new code that injects a function call at the end of our expressions.

The injected function call just exists to prevent the optimizer from removing the store to our
result variable. Right now we capture l-values by having a pointer that points to alloca'd memory.
The optimizer thinks this is a dead store (which it actually is but we read the memory after the
call has finished) and removes it. By injecting a call to an undefined function that just takes the
address of the result we can prevent any of these optimizations. The call is alter on removed
after the pass manager is done so that we can actually interpret/JIT the module again.

[teemperor]

lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.cpp

2026

I do wish we had a better way to do the iterate-while-erase algorithm on IR nodes but apparently there is no such thing :(

[vsk]

lldb/source/Plugins/ExpressionParser/Clang/ASTResultSynthesizer.cpp

409

Why is it safe for lldb to take the address of "c"? After evaluation completes, is the state of the stack preserved?

409

Would marking __lldb_expr_result_ptr volatile make the call to __lldb_use_expr_result redundant?

[teemperor]

lldb/source/Plugins/ExpressionParser/Clang/ASTResultSynthesizer.cpp

409

That's actually a good point and I am actually writing up an RFC about the current behaviour to lldb-dev. The current behaviour of LLDB is that we end the function call, we call all the destructors and so on and then we read the results from memory. So the memory we read is just the leftovers after the function call has returned. That's why a unique_ptr local variable in LLDB always looks like it owns no memory because we read it after it got already destroyed. I'm actually thinking whether/how we should fix that behaviour as seems rather fragile (but that's for the RFC).

So unless I'm missing something, we currently already rely on the stack being preserved to even get the correct results. The function call is just there to make sure the optimizer doesn't realize what we're up to.

Not sure about the volatile and if it would help. The __lldb_expr_result variable gets transformed by IRForTarget until it ends up being just a part of our argument struct IIRC, so I need to look into that before I know where we could sneak in a volatile.

lldb/source/Plugins/ExpressionParser/Clang/ASTResultSynthesizer.cpp

 //===-- ASTResultSynthesizer.cpp ------------------------------------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #include "ASTResultSynthesizer.h"
 
 #include "ClangASTImporter.h"
+#include "ClangExpressionSourceCode.h"
 #include "ClangPersistentVariables.h"
 
 #include "Plugins/TypeSystem/Clang/TypeSystemClang.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/LLDBAssert.h"
 #include "lldb/Utility/Log.h"
 #include "stdlib.h"
 #include "clang/AST/ASTContext.h"
bool ASTResultSynthesizer::SynthesizeBodyResult(CompoundStmt *Body,
 
   if (!Body)
     return false;
 
   if (Body->body_empty())
     return false;
 
   Stmt **last_stmt_ptr = Body->body_end() - 1;
+  // The last statement in the expression is our injected call to
+  // __lldb_use_expr_result. The expression before is the actual user expression
+  // so skip the injected function call.
+  CallExpr *use_call = cast<CallExpr>(*last_stmt_ptr);
+  assert(cast<FunctionDecl>(use_call->getCalleeDecl())->getName() ==
+         ClangExpressionSourceCode::GetUseExprResultFunctionName());
+  --last_stmt_ptr;
+
   Stmt *last_stmt = *last_stmt_ptr;
 
   while (dyn_cast<NullStmt>(last_stmt)) {
     if (last_stmt_ptr != Body->body_begin()) {
       last_stmt_ptr--;
       last_stmt = *last_stmt_ptr;
     } else {
       return false;
StmtResult result_initialization_stmt_result(m_sema->ActOnDeclStmt(
       result_decl_group_ptr, SourceLocation(), SourceLocation()));
 
   ////////////////////////////////////////////////
   // replace the old statement with the new one
   //
 
   *last_stmt_ptr = static_cast<Stmt *>(result_initialization_stmt_result.get());
 
+  // At this point we created the result variable that stores the result of
+  // the last expression. However, in a situation where we finish on a local
+  // variable, the expression result is just a pointer to something on the stack
+  // and LLVM will optimize that away. E.g., `MyClass c; c` becomes:
+  //
+  //       MyClass c;
+  //       static MyClass *__lldb_expr_result_ptr = &c; // Points to stack.
+  //     } // End of expression function.
+  //
+  // The optimizer will just remove this store. So we add a trailing call to
+  // the undefined function `__lldb_use_expr_result` which will take an address
+  // of `__lldb_expr_result_ptr`. We will manually remove that call later,
+  // but until we remove that function the optimizer can no longer remove
+  // the store to our result variable:
+  //
+  //       MyClass c;
+  //       static MyClass *__lldb_expr_result_ptr = &c; // Points to stack.
+  //       __lldb_expr_result_ptr(__lldb_expr_result_ptr);
+  //     } // End of expression function.
+  //
+  // We already have a call at the end in the form:
+  //     __lldb_expr_result_ptr(nullptr);
+  // which we injected into the wrapping source code. We just need to change
+  // the placeholder `nullptr` argument to the result variable we created above
+  // and do any casting.
+  Expr *ref_result = DeclRefExpr::Create(
+      Ctx, NestedNameSpecifierLoc(), SourceLocation(), result_decl,
+      /*RefersToEnclosingVariableOrCapture=*/false, SourceLocation(),
+      result_decl->getType(), ExprValueKind::VK_LValue);
+  QualType ref_type = ref_result->getType();
+  // __lldb_expr_result isn't a pointer for non-lvalues, so inject an &:
+  // __lldb_expr_result_ptr(&__lldb_expression_result)
+  if (!ref_type->isPointerType())
+    ref_result = UnaryOperator::Create(
+        Ctx, ref_result, UnaryOperator::Opcode::UO_AddrOf,
+        Ctx.getPointerType(ref_type), ExprValueKind::VK_RValue,
+        ExprObjectKind::OK_Ordinary, SourceLocation(), /*CanOverflow=*/false,
+        FPOptionsOverride());
+  // Cast the pointer type we have to void so that the type system is not
+  // complaining.
+  ImplicitCastExpr *c = ImplicitCastExpr::Create(
+      Ctx, Ctx.VoidPtrTy, CastKind::CK_BitCast, ref_result, nullptr,
+      ExprValueKind::VK_RValue, FPOptionsOverride());
+  // Overwrite the placeholder argument.
+  use_call->getArgs()[0] = c;
+
   return true;
 }
 
 void ASTResultSynthesizer::HandleTranslationUnit(ASTContext &Ctx) {
   if (m_passthrough)
     m_passthrough->HandleTranslationUnit(Ctx);
 }
 

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionParser.cpp

 #include "llvm/ExecutionEngine/ExecutionEngine.h"
 #include "llvm/Support/CrashRecoveryContext.h"
 #include "llvm/Support/Debug.h"
 #include "llvm/Support/FileSystem.h"
 #include "llvm/Support/TargetSelect.h"
 
 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/Module.h"
+#include "llvm/Passes/PassBuilder.h"
 #include "llvm/Support/DynamicLibrary.h"
 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/Host.h"
 #include "llvm/Support/MemoryBuffer.h"
 #include "llvm/Support/Signals.h"
+#include "llvm/Transforms/IPO/PassManagerBuilder.h"
 
 #include "ClangDiagnostic.h"
 #include "ClangExpressionParser.h"
 #include "ClangUserExpression.h"
 
 #include "ASTUtils.h"
 #include "ClangASTSource.h"
 #include "ClangDiagnostic.h"
ClangExpressionParser::ClangExpressionParser(
 
   // Set CodeGen options
   m_compiler->getCodeGenOpts().EmitDeclMetadata = true;
   m_compiler->getCodeGenOpts().InstrumentFunctions = false;
   m_compiler->getCodeGenOpts().setFramePointer(
                                     CodeGenOptions::FramePointerKind::All);
   if (generate_debug_info)
     m_compiler->getCodeGenOpts().setDebugInfo(codegenoptions::FullDebugInfo);
-  else
+  else {
     m_compiler->getCodeGenOpts().setDebugInfo(codegenoptions::NoDebugInfo);
+    // If the user doesn't want to debug the expression we can optimize it.
+    // This makes it run a bit faster in case it's a long-running expression
+    // and it makes the life of the IRInterpreter easier as all the verbose
+    // IR nodes generated by Clang are simplified.
+    // The level set here gets propagated to the pass manager.
+    m_compiler->getCodeGenOpts().OptimizationLevel = 2;
+    // LLVM's lifetime markers aren't supported by the IRInterpreter so avoid
+    // generating them.
+    m_compiler->getCodeGenOpts().DisableLifetimeMarkers = true;
+  }
 
   // Disable some warnings.
   SetupDefaultClangDiagnostics(*m_compiler);
 
   // Inform the target of the language options
   //
   // FIXME: We shouldn't need to do this, the target should be immutable once
   // created. This complexity should be lifted elsewhere.
for (const auto &func : module->getFunctionList()) {
     if (name.find(orig_name) != StringRef::npos) {
       mangled_name.SetString(name);
       return true;
     }
   }
 
   return false;
 }
 
+static void RunOptimizationPipeline(llvm::Module &module,
+                                      clang::CodeGenOptions &opts) {
+  // Build a fitting target machine for our triple.
+  llvm::Triple triple(module.getTargetTriple());
+  std::unique_ptr<llvm::TargetMachine> target_machine;
+  llvm::SmallVector<std::string, 0> mAttrs;
+  target_machine.reset(llvm::EngineBuilder().selectTarget(triple,
+                                                          /*MArch=*/"",
+                                                          /*MCPU=*/"", mAttrs));
+
+  // Build the default analysis managers.
+  LoopAnalysisManager LAM;
+  FunctionAnalysisManager FAM;
+  CGSCCAnalysisManager CGAM;
+  ModuleAnalysisManager MAM;
+
+  PassInstrumentationCallbacks PIC;
+  Optional<PGOOptions> P;
+  PipelineTuningOptions PTO;
+  PassBuilder PB(target_machine.get(), PTO, P, &PIC);
+
+  // Register all passes.
+  PB.registerModuleAnalyses(MAM);
+  PB.registerCGSCCAnalyses(CGAM);
+  PB.registerFunctionAnalyses(FAM);
+  PB.registerLoopAnalyses(LAM);
+  PB.crossRegisterProxies(LAM, FAM, CGAM, MAM);
+
+  ModulePassManager MPM;
+  // Pick a pipeline that fits to our CodeGenOpts optimization level and add
+  // the respective passes.
+  std::string pipelineString =
+      "default<O" + std::to_string(opts.OptimizationLevel) + ">";
+  if (auto Err = PB.parsePassPipeline(MPM, pipelineString))
+    llvm_unreachable("Failed to parse pipeline");
+
+  MPM.run(module, MAM);
+}
+
 lldb_private::Status ClangExpressionParser::PrepareForExecution(
     lldb::addr_t &func_addr, lldb::addr_t &func_end,
     lldb::IRExecutionUnitSP &execution_unit_sp, ExecutionContext &exe_ctx,
     bool &can_interpret, ExecutionPolicy execution_policy) {
   func_addr = LLDB_INVALID_ADDRESS;
   func_end = LLDB_INVALID_ADDRESS;
   Log *log(lldb_private::GetLogIfAllCategoriesSet(LIBLLDB_LOG_EXPRESSIONS));
 
IRForTarget ir_for_target(decl_map, m_expr.NeedsVariableResolution(),
                               *execution_unit_sp, error_stream,
                               function_name.AsCString());
 
     if (!ir_for_target.runOnModule(*execution_unit_sp->GetModule())) {
       err.SetErrorString(error_stream.GetString());
       return err;
     }
 
+    // Run the default LLVM optimization passes over the generated module unless
+    // this is an expression that the user wants to debug (in which case the
+    // optimizations would degrade the debug experience).
+    if (!GetGenerateDebugInfo())
+      RunOptimizationPipeline(*execution_unit_sp->GetModule(),
+                                m_compiler->getCodeGenOpts());
+    // Remove the injected function call that prevents the optimizer from
+    // removing the seemingly dead store of the expression result.
+    ir_for_target.RemoveAllCallsToFunction(
+        ClangExpressionSourceCode::GetUseExprResultFunctionName());
+
     Process *process = exe_ctx.GetProcessPtr();
 
     if (execution_policy != eExecutionPolicyAlways &&
         execution_policy != eExecutionPolicyTopLevel) {
       lldb_private::Status interpret_error;
 
       bool interpret_function_calls =
           !process ? false : process->CanInterpretFunctionCalls();

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionSourceCode.h

 //===-- ClangExpressionSourceCode.h -----------------------------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGEXPRESSIONSOURCECODE_H
 #define LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_CLANGEXPRESSIONSOURCECODE_H
 
 #include "lldb/Expression/Expression.h"
 #include "lldb/Expression/ExpressionSourceCode.h"
 #include "lldb/lldb-enumerations.h"
 #include "llvm/ADT/ArrayRef.h"
 #include "llvm/ADT/StringRef.h"
 
 #include <string>
 
 namespace lldb_private {
bool GetText(std::string &text, ExecutionContext &exe_ctx, bool add_locals,
                llvm::ArrayRef<std::string> modules) const;
 
   // Given a string returned by GetText, find the beginning and end of the body
   // passed to CreateWrapped. Return true if the bounds could be found.  This
   // will also work on text with FixItHints applied.
   bool GetOriginalBodyBounds(std::string transformed_text,
                              size_t &start_loc, size_t &end_loc);
 
+  /// Returns the name of the function that is injected in the source code
+  /// to make sure the expression result is considered used by the optimizer.
+  static llvm::StringRef GetUseExprResultFunctionName();
+
 protected:
   ClangExpressionSourceCode(llvm::StringRef filename, llvm::StringRef name,
                             llvm::StringRef prefix, llvm::StringRef body,
                             Wrapping wrap, WrapKind wrap_kind);
 
 private:
   void AddLocalVariableDecls(const lldb::VariableListSP &var_list_sp,
                              StreamString &stream,

lldb/source/Plugins/ExpressionParser/Clang/ClangExpressionSourceCode.cpp

 #include "lldb/Target/StackFrame.h"
 #include "lldb/Target/Target.h"
 #include "lldb/Utility/StreamString.h"
 
 using namespace lldb_private;
 
 #define PREFIX_NAME "<lldb wrapper prefix>"
 #define SUFFIX_NAME "<lldb wrapper suffix>"
+/// \see ClangExpressionSourceCode::GetUseExprResultFunctionName
+#define LLDB_USE_EXPR_RESULT "__lldb_use_expr_result"
 
 const llvm::StringRef ClangExpressionSourceCode::g_prefix_file_name = PREFIX_NAME;
 
 const char *ClangExpressionSourceCode::g_expression_prefix =
 "#line 1 \"" PREFIX_NAME R"("
 #ifndef offsetof
 #define offsetof(t, d) __builtin_offsetof(t, d)
 #endif
 #ifndef NULL
 #define NULL (__null)
 #endif
 #ifndef Nil
 #define Nil (__null)

 typedef __INTPTR_TYPE__ intptr_t;
 typedef __UINTPTR_TYPE__ uintptr_t;
 typedef __SIZE_TYPE__ size_t;
 typedef __PTRDIFF_TYPE__ ptrdiff_t;
 typedef unsigned short unichar;
 extern "C"
 {
     int printf(const char * __restrict, ...);
+    void )" LLDB_USE_EXPR_RESULT R"((void *);
 }
 )";
 
 const char *ClangExpressionSourceCode::g_expression_suffix =
     "\n;\n#line 1 \"" SUFFIX_NAME "\"\n";
 
 namespace {
 
if (m_wrap) {
     switch (m_wrap_kind) {
     case WrapKind::Function:
       wrap_stream.Printf("%s"
                          "void                           \n"
                          "%s(void *$__lldb_arg)          \n"
                          "{                              \n"
                          "    %s;                        \n"
                          "%s"
+                         "    " LLDB_USE_EXPR_RESULT "(0);\n"
                          "}                              \n",
                          module_imports.c_str(), m_name.c_str(),
                          lldb_local_var_decls.GetData(), tagged_body.c_str());
       break;
     case WrapKind::CppStaticMemberFunction:
     case WrapKind::CppMemberFunction:
       wrap_stream.Printf("%s"
                          "void                                   \n"
                          "$__lldb_class::%s(void *$__lldb_arg)   \n"
                          "{                                      \n"
                          "    %s;                                \n"
                          "%s"
+                         "    " LLDB_USE_EXPR_RESULT "(nullptr); \n"
                          "}                                      \n",
                          module_imports.c_str(), m_name.c_str(),
                          lldb_local_var_decls.GetData(), tagged_body.c_str());
       break;
     case WrapKind::ObjCInstanceMethod:
       wrap_stream.Printf(
           "%s"
           "@interface $__lldb_objc_class ($__lldb_category)       \n"
           "-(void)%s:(void *)$__lldb_arg;                         \n"
           "@end                                                   \n"
           "@implementation $__lldb_objc_class ($__lldb_category)  \n"
           "-(void)%s:(void *)$__lldb_arg                          \n"
           "{                                                      \n"
           "    %s;                                                \n"
           "%s"
+          "    " LLDB_USE_EXPR_RESULT "(0);                       \n"
           "}                                                      \n"
           "@end                                                   \n",
           module_imports.c_str(), m_name.c_str(), m_name.c_str(),
           lldb_local_var_decls.GetData(), tagged_body.c_str());
       break;
 
     case WrapKind::ObjCStaticMethod:
       wrap_stream.Printf(
           "%s"
           "@interface $__lldb_objc_class ($__lldb_category)        \n"
           "+(void)%s:(void *)$__lldb_arg;                          \n"
           "@end                                                    \n"
           "@implementation $__lldb_objc_class ($__lldb_category)   \n"
           "+(void)%s:(void *)$__lldb_arg                           \n"
           "{                                                       \n"
           "    %s;                                                 \n"
           "%s"
+          "    " LLDB_USE_EXPR_RESULT "(0);                        \n"
           "}                                                       \n"
           "@end                                                    \n",
           module_imports.c_str(), m_name.c_str(), m_name.c_str(),
           lldb_local_var_decls.GetData(), tagged_body.c_str());
       break;
     }
 
     text = std::string(wrap_stream.GetString());
   } else {
     text.append(m_body);
   }
 
   return true;
 }
 
 bool ClangExpressionSourceCode::GetOriginalBodyBounds(
     std::string transformed_text, size_t &start_loc, size_t &end_loc) {
   start_loc = transformed_text.find(m_start_marker);
   if (start_loc == std::string::npos)
     return false;
   start_loc += m_start_marker.size();
   end_loc = transformed_text.find(m_end_marker);
   return end_loc != std::string::npos;
 }
+
+llvm::StringRef ClangExpressionSourceCode::GetUseExprResultFunctionName() {
+  return LLDB_USE_EXPR_RESULT;
+}

lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.h

 //===-- IRForTarget.h ---------------------------------------------*- C++
 //-*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_IRFORTARGET_H
 #define LLDB_SOURCE_PLUGINS_EXPRESSIONPARSER_CLANG_IRFORTARGET_H
 
 #include "lldb/Symbol/TaggedASTType.h"
 #include "lldb/Utility/ConstString.h"
 #include "lldb/Utility/Status.h"
 #include "lldb/Utility/Stream.h"
 #include "lldb/Utility/StreamString.h"
 #include "lldb/lldb-public.h"
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/Pass.h"
 
public:
   ///     The module to run on.  This module is searched for the function
   ///     $__lldb_expr, and that function is passed to the passes one by
   ///     one.
   ///
   /// \return
   ///     True on success; false otherwise
   bool runOnModule(llvm::Module &llvm_module) override;
 
+  /// Removes all calls to the function with the given name in the module.
+  ///
+  /// All calls found by this function must be safe to remove.
+  void RemoveAllCallsToFunction(llvm::StringRef function_name);
+
   /// Interface stub
   ///
   /// Implementation of the llvm::ModulePass::assignPassManager() function.
   void assignPassManager(llvm::PMStack &pass_mgr_stack,
                          llvm::PassManagerType pass_mgr_type =
                              llvm::PMT_ModulePassManager) override;
 
   /// Returns PMT_ModulePassManager

lldb/source/Plugins/ExpressionParser/Clang/IRForTarget.cpp

bool IRForTarget::CreateResultVariable(llvm::Function &llvm_function) {
   MDNode *persistent_global_md = MDNode::get(m_module->getContext(), value_ref);
   NamedMDNode *named_metadata =
       m_module->getNamedMetadata("clang.global.decl.ptrs");
   named_metadata->addOperand(persistent_global_md);
 
   LLDB_LOG(log, "Replacing \"{0}\" with \"{1}\"", PrintValue(result_global),
            PrintValue(new_result_global));
 
-  if (result_global->use_empty()) {
+  // If the old global had an initializer, create a store that initializes
+  // the new global with the same value.
+  if (result_global->hasInitializer()) {
     // We need to synthesize a store for this variable, because otherwise
     // there's nothing to put into its equivalent persistent variable.
 
     BasicBlock &entry_block(llvm_function.getEntryBlock());
     Instruction *first_entry_instruction(entry_block.getFirstNonPHIOrDbg());
 
     if (!first_entry_instruction)
       return false;
 
-    if (!result_global->hasInitializer()) {
-      LLDB_LOG(log, "Couldn't find initializer for unused variable");
-
-      m_error_stream.Format("Internal error [IRForTarget]: Result variable "
-                            "({0}) has no writes and no initializer\n",
-                            result_name);
-
-      return false;
-    }
-
     Constant *initializer = result_global->getInitializer();
 
     StoreInst *synthesized_store =
         new StoreInst(initializer, new_result_global, first_entry_instruction);
 
     LLDB_LOG(log, "Synthesized result store \"{0}\"\n",
              PrintValue(synthesized_store));
-  } else {
-    result_global->replaceAllUsesWith(new_result_global);
   }
+  // About to remove the old result global, so RAUW the new global.
+  result_global->replaceAllUsesWith(new_result_global);
 
   if (!m_decl_map->AddPersistentVariable(
           result_decl, m_result_name, m_result_type, true, m_result_is_pointer))
     return false;
 
   result_global->eraseFromParent();
 
   return true;
if (log && log->GetVerbose()) {
     oss.flush();
 
     LLDB_LOG(log, "Module after preparing for execution: \n\"{0}\"", s);
   }
 
   return true;
 }
 
+void IRForTarget::RemoveAllCallsToFunction(llvm::StringRef function_name) {
+  for (llvm::Function &function : *m_module) {
+    for (BasicBlock &bb : function) {
+      for (BasicBlock::iterator i = bb.begin(), end = bb.end(); i != end;) {
+        if (CallInst *call = dyn_cast<CallInst>(&(*i))) {
+          if (llvm::Function *func = call->getCalledFunction()) {
+            if (func->getName() == function_name) {
+              i = call->eraseFromParent();
+              continue;
+            }
+          }
+        }
+        ++i;
+      }
+    }
+  }
+}
+
 void IRForTarget::assignPassManager(PMStack &pass_mgr_stack,
                                     PassManagerType pass_mgr_type) {}
 
 PassManagerType IRForTarget::getPotentialPassManagerType() const {
   return PMT_ModulePassManager;
 }