diff --git a/llvm/lib/Transforms/IPO/ElimAvailExtern.cpp b/llvm/lib/Transforms/IPO/ElimAvailExtern.cpp
--- a/llvm/lib/Transforms/IPO/ElimAvailExtern.cpp
+++ b/llvm/lib/Transforms/IPO/ElimAvailExtern.cpp
@@ -12,22 +12,71 @@
 //===----------------------------------------------------------------------===//
 
 #include "llvm/Transforms/IPO/ElimAvailExtern.h"
+#include "llvm/ADT/STLExtras.h"
 #include "llvm/ADT/Statistic.h"
 #include "llvm/IR/Constant.h"
+#include "llvm/IR/DebugInfoMetadata.h"
 #include "llvm/IR/Function.h"
 #include "llvm/IR/GlobalValue.h"
 #include "llvm/IR/GlobalVariable.h"
+#include "llvm/IR/MDBuilder.h"
 #include "llvm/IR/Module.h"
+#include "llvm/Support/CommandLine.h"
 #include "llvm/Transforms/IPO.h"
 #include "llvm/Transforms/Utils/GlobalStatus.h"
+#include "llvm/Transforms/Utils/ModuleUtils.h"
 
 using namespace llvm;
 
 #define DEBUG_TYPE "elim-avail-extern"
 
+cl::opt<bool> ConvertToLocal(
+    "avail-extern-to-local", cl::Hidden,
+    cl::desc("Convert available_externally into locals, renaming them "
+             "to avoid link-time clashes."));
+
 STATISTIC(NumFunctions, "Number of functions removed");
 STATISTIC(NumVariables, "Number of global variables removed");
 
+static void handleThinltoCopy(Function &F) {
+  assert(F.hasAvailableExternallyLinkage());
+  assert(!F.isDeclaration());
+  // If we can't find a single use that's a call, just delete the function.
+  if (F.uses().end() == llvm::find_if(F.uses(), [&](Use &U) {
+        return isa<CallBase>(U.getUser());
+      })) {
+    F.deleteBody();
+    return;
+  }
+
+  auto OrigName = F.getName().str();
+  auto *M = F.getParent();
+  assert(M);
+  // Build a new name. We still need the old name (see below).
+  // We could just rely on internal linking allowing 2 modules have internal
+  // functions with the same name, but that just creates more trouble than
+  // necessary e.g. distinguishing profiles or debugging. Instead, we append the
+  // module identifier.
+  auto NewName = OrigName + ".__clone__" + getUniqueModuleId(M);
+  F.setName(NewName);
+  if (auto *SP = F.getSubprogram()) {
+    SP->replaceLinkageName(MDString::get(F.getParent()->getContext(), NewName));
+  }
+  // Making the function
+  F.setLinkage(GlobalValue::InternalLinkage);
+  // Now make a declaration for the old name. We'll use it if there are non-call
+  // uses. For those, it would be incorrect to replace them with the local copy:
+  // for example, one such use could be taking the address of the function and
+  // passing it to an external function, which, in turn, might compare the
+  // function pointer to the original (non-local) function pointer, e.g. as part
+  // of indirect call promotion.
+  auto *Decl =
+      Function::Create(F.getFunctionType(), GlobalValue::ExternalLinkage,
+                       F.getAddressSpace(), OrigName, F.getParent());
+  F.replaceUsesWithIf(Decl,
+                      [&](Use &U) { return !isa<CallBase>(U.getUser()); });
+}
+
 static bool eliminateAvailableExternally(Module &M) {
   bool Changed = false;
 
@@ -48,12 +97,17 @@
   }
 
   // Drop the bodies of available externally functions.
-  for (Function &F : M) {
-    if (!F.hasAvailableExternallyLinkage())
+  for (Function &F : llvm::make_early_inc_range(M)) {
+    if (F.isDeclaration() || !F.hasAvailableExternallyLinkage())
       continue;
-    if (!F.isDeclaration())
+
+    if (ConvertToLocal) {
+      handleThinltoCopy(F);
+    } else {
       // This will set the linkage to external
       F.deleteBody();
+    }
+
     F.removeDeadConstantUsers();
     NumFunctions++;
     Changed = true;
diff --git a/llvm/test/Transforms/EliminateAvailableExternally/transform-to-local.ll b/llvm/test/Transforms/EliminateAvailableExternally/transform-to-local.ll
new file mode 100644
--- /dev/null
+++ b/llvm/test/Transforms/EliminateAvailableExternally/transform-to-local.ll
@@ -0,0 +1,25 @@
+; RUN: opt -passes=elim-avail-extern -avail-extern-to-local -S < %s | FileCheck %s
+
+
+declare void @call_out(ptr %fct)
+
+define available_externally hidden void @f() {
+  ret void
+}
+
+define available_externally hidden void @g() {
+  ret void
+}
+
+define void @hello(ptr %g) {
+  call void @f()
+  %f = load ptr, ptr @f
+  call void @call_out(ptr %f)
+  ret void
+}
+
+; CHECK: define internal void @f.__clone__.{{[0-9|a-f]*}}()
+; CHECK: declare hidden void @g()
+; CHECK: call void @f.__clone__.{{[0-9|a-f]*}}()
+; CHECK-NEXT: load ptr, ptr @f
+; CHECK-NEXT: call void @call_out(ptr %f)