Add a FunctionImporter helper to perform summary-based cross-module function importing

[mehdi_amini]

Summary

This is a helper to perform cross-module import for ThinLTO. Right now
it is importing naively every possible called functions.

[tejohnson]

Hi Mehdi,

Didn't realize you were working on this, I was readying a slightly different version. We can work from your version though. Some initial comments below.

There are a couple of pieces missing. One thing that is missing here is to import for calls from imported functions, noted below. Another thing is that there potentially needs to be static promotion/renaming in the current module being compiled. I have a clang FE patch to handle that part, since it should be done early.

lib/Transforms/IPO/FunctionImport.cpp

51

I was not planning to keep all the modules being imported from in memory, to minimize the memory overhead. That does require reparsing the initial part of the bitcode, but that is quite fast in practice.

The metadata importing patch handles this by not parsing/materializing metadata until a separate metadata parse/link step. Note that even if we are to save the modules as in this approach we would need to delay the metadata parsing/linking until the end of all importing to reduce memory overhead, so much of that patch is still needed.

82

I think this should save the called function pointers in a set, rather than the name. You also don't need the DefinedFunctions set. Just check here if the called function is a declaration, and don't add to the called function set if not.

96

Not needed as noted above.

106

We should always have the function info populated, even if we are doing lazy parsing of summaries. The case where we decided not to include a function in the index (because we decided earlier that it was not eligible for or profitable to import) should be handled by the above check on the returned iterator.

112

With my comdat importing patch we probably shouldn't even hit this situation as I made a change to import referenced comdat groups. Fine to pick the first entry here for now though, we can reevaluate later.

120

Add a note that we should eventually check if we are doing lazy parsing of summaries, in which case we import lazily at this point.

145

Need to get the function for the alias base object. Here's the code from my version of the importer, you can probably just drop this in and modify the variable names:

GlobalValue *SGV = SrcM->getNamedValue(FunctionName);
Function *SF = dyn_cast<Function>(SGV);
if (!SF && isa<GlobalAlias>(SGV)) {
  auto *SGA = dyn_cast<GlobalAlias>(SGV);
  SF = dyn_cast<Function>(SGA->getBaseObject());
}

160

After this, we need to walk the imported function copy in the destination and find new callsites that need to be imported. For now if you want to add a FIXME comment to that effect it is fine and I can add that along with profitability heuristics. Otherwise you will end up importing all functions in the call tree below functions in this module...

[tejohnson]

In D14914#295006, @tejohnson wrote:

[...] Another thing is that there potentially needs to be static promotion/renaming in the current module being compiled. I have a clang FE patch to handle that part, since it should be done early.

I guess you won't be doing this through clang since you are planning to invoke from ld64, but remember to do this part there for each module being compiled. Will need to do from 'opt' as well for testing. My clang patch also includes support for an option to trigger the pass and pass down the index file path via a CodeGenOption, with corresponding support in llvm to invoke the pass. I can add that part after this goes in.

[mehdi_amini]

Hi Teresa,

Thanks for the review, I should have added in the description that I was mostly interested to share some high level design and APIs as I am working on ld64 integration. I know you're also working on the same functionality, I just wrote this one to be able to test cross-module importing without heuristic (i.e. import one level of the call graph unconditionally).

So I don't mind at all dropping this patch if you already have a replacement (I'll continue to use this code for my prototype till you're ready), or if this patch is close enough to what you're working on we can integrate this and work iteratively to improve it. As you prefer :)

Good point that the renaming is still missing, this is not gonna be trivial in the plugin I think as we will need to communicate the renaming and the new edges between file to the linker. Doing it in the FE would be nice, but I guess it won't be possible as it requires to have the index.
This is why I'm glad I posted this as it already exposes some interface with the linker I'm missing at that time.

Thanks,

Mehdi

lib/Transforms/IPO/FunctionImport.cpp

51

Note that these are only the "Lazy" modules used for importing. They should consume less memory since they don't initialize the bodies.
That said, I agree that some measurements need to be done to explore the cost tradeoff.

82

Thanks good point.

106

IIUC the answer is "yes we could assert here", right?

160

Yes I didn't want to import the full call-graph, so I limited arbitrarily to one level.
I guess we'll need to move to a worklist pattern for this loop and enqueue imported function?

[tejohnson]

In D14914#295184, @joker.eph wrote:

Hi Teresa,

Thanks for the review, I should have added in the description that I was mostly interested to share some high level design and APIs as I am working on ld64 integration. I know you're also working on the same functionality, I just wrote this one to be able to test cross-module importing without heuristic (i.e. import one level of the call graph unconditionally).

So I don't mind at all dropping this patch if you already have a replacement (I'll continue to use this code for my prototype till you're ready), or if this patch is close enough to what you're working on we can integrate this and work iteratively to improve it. As you prefer :)

No problem, this is only a piece of the stuff I was working on (have the clang part as well), and is a bit simpler since I was trying to incorporate some initial profitability checking and iteratively handling the imported calls. I am thinking it is good to get this one in with the current functionality to serve as the general framework and I can add that part shortly. That way we can start iterating and refining this more quickly.

Good point that the renaming is still missing, this is not gonna be trivial in the plugin I think as we will need to communicate the renaming and the new edges between file to the linker. Doing it in the FE would be nice, but I guess it won't be possible as it requires to have the index.

I am passing in the index to clang but this is to support distributed builds where we are invoking the backend piece as a separate job, so that won't help your use case. I will need to do something similar to what you are dealing with in the gold-plugin for supporting single machine ThinLTO builds too. 

This is why I'm glad I posted this as it already exposes some interface with the linker I'm missing at that time.

Thanks,

Mehdi

lib/Transforms/IPO/FunctionImport.cpp

106

Yep, sorry, I meant you can assert here.

160

Yep, I think that is what is going to be needed (e.g. some kind of priority queue), but go ahead and leave as-is for now, that can be added when the functionality for adding imported callsites is added.

[tejohnson]

lib/Transforms/IPO/FunctionImport.cpp

185

Remove and replace call with new llvm:getFunctionIndexForFile routine just added in r253903.

[mehdi_amini]

Update taking comment in to account (hopefully all...)

[tejohnson]

LGTM with one issue

lib/Transforms/IPO/FunctionImport.cpp

91

I just hit an issue with the earlier version of this patch I had downloaded and modified to store a worklist of Function pointers instead, and a slightly modified test case. The module linker may replace the dest module Function (erasing it from the parent) if it creates a new GV while linking global value protos. It might do this for other declarations it finds in the import module besides the import function. I had forgotten about this, I was dealing with it in my version of the import pass by passing in the structure to update with the new Function. But that is probably overkill. So unfortunately I think we may need to go back to tracking the names of function decls instead of the Function pointers.

[mehdi_amini]

lib/Transforms/IPO/FunctionImport.cpp

51

About caching the Module, the question is also if I have a call to foo() and bar() in module Y, both function being defined in module Y, this allows to transparently load Y only once when importing into Y.

91

Do you mean that while importing function foo() into module A, the Linker can change a declaration for function bar(), invalidating the Function pointer to bar() that may be in the worklist?

[tejohnson]

lib/Transforms/IPO/FunctionImport.cpp

51

Sorry, is Y the module we are importing from or to in your example? If we are importing into it, we only load it once. If we are importing foo() and bar() from it, then yes, without caching the modules in between imports Y needs to be loaded twice, but only one function is parsed/materialized on each load. It is a time vs memory tradeoff that we'll have to evaluate.

Let me know if I didn't understand your scenario though.

91

Yes. For example, in ModuleLinker::shouldLinkFromSource we will link from source (creating a new GV in the process with potentially new linkage type) when the dest is a declaration. We will even do this in certain cases when the source is only a declaration (weak linkage). So for example we create a new GV and delete the old dest GV for weakalias in your test case, which is an alias but is imported as a function decl since we aren't importing its aliasee. With the test case as-is I think we get lucky, but when I modified it I hit a seg fault somewhere because the Function in the work list is used after freed (apparently just luck that the memory was not yet overwritten).

[mehdi_amini]

Back to a string set

[mehdi_amini]

lib/Transforms/IPO/FunctionImport.cpp

51

I think we're on the same page here :)

[tejohnson]

LGTM. Thanks.

[mehdi_amini]

r253954

include/llvm/InitializePasses.h

 void initializePlaceSafepointsPass(PassRegistry&);
 void initializeDwarfEHPreparePass(PassRegistry&);
 void initializeFloat2IntPass(PassRegistry&);
 void initializeLoopDistributePass(PassRegistry&);
 void initializeSjLjEHPreparePass(PassRegistry&);
 void initializeDemandedBitsPass(PassRegistry&);
 void initializeFuncletLayoutPass(PassRegistry &);
 void initializeLoopLoadEliminationPass(PassRegistry&);
+void initializeFunctionImportPassPass(PassRegistry&);
 }
 
 #endif

include/llvm/Transforms/IPO/FunctionImport.h

+//===- llvm/Transforms/IPO/FunctionImport.h - ThinLTO importing -*- C++ -*-===//
+//
+//                      The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_FUNCTIONIMPORT_H
+#define LLVM_FUNCTIONIMPORT_H
+
+#include "llvm/IR/DiagnosticInfo.h"
+#include "llvm/ADT/StringMap.h"
+
+namespace llvm {
+class LLVMContext;
+class Module;
+class FunctionInfoIndex;
+
+/// The function importer is automatically importing function from other modules
+/// based on the provided summary informations.
+class FunctionImporter {
+
+  /// Cache of lazily loaded module for import.
+  StringMap<std::unique_ptr<Module>> ModuleMap;
+
+  /// The context that will be used for importing.
+  LLVMContext &Context;
+
+  /// The summaries index used to trigger importing.
+  const FunctionInfoIndex &Index;
+
+  /// Diagnostic will be sent to this handler.
+  DiagnosticHandlerFunction DiagnosticHandler;
+
+  /// Retrieve a Module from the cache or lazily load it on demand.
+  Module &getOrLoadModule(StringRef FileName);
+
+public:
+  /// Create a Function Importer.
+  FunctionImporter(LLVMContext &Context, const FunctionInfoIndex &Index,
+                   DiagnosticHandlerFunction DiagnosticHandler)
+      : Context(Context), Index(Index), DiagnosticHandler(DiagnosticHandler) {}
+
+  /// Import functions in Module \p M based on the summary informations.
+  bool importFunctions(Module &M);
+};
+}
+
+#endif // LLVM_FUNCTIONIMPORT_H

lib/Transforms/IPO/CMakeLists.txt

 add_llvm_library(LLVMipo
   ArgumentPromotion.cpp
   BarrierNoopPass.cpp
   ConstantMerge.cpp
   DeadArgumentElimination.cpp
   ElimAvailExtern.cpp
   ExtractGV.cpp
   FunctionAttrs.cpp
+  FunctionImport.cpp
   GlobalDCE.cpp
   GlobalOpt.cpp
   IPConstantPropagation.cpp
   IPO.cpp
   InlineAlways.cpp
   InlineSimple.cpp
   Inliner.cpp
   Internalize.cpp

lib/Transforms/IPO/FunctionImport.cpp

+//===- FunctionImport.cpp - ThinLTO Summary-based Function Import ---------===//
+//
+//                     The LLVM Compiler Infrastructure
+//
+// This file is distributed under the University of Illinois Open Source
+// License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
+//
+// This file implements Function import based on summaries.
+//
+//===----------------------------------------------------------------------===//
+
+#include "llvm/Transforms/IPO/FunctionImport.h"
+
+#include "llvm/ADT/StringSet.h"
+#include "llvm/IR/AutoUpgrade.h"
+#include "llvm/IR/DiagnosticPrinter.h"
+#include "llvm/IR/IntrinsicInst.h"
+#include "llvm/IR/Module.h"
+#include "llvm/IRReader/IRReader.h"
+#include "llvm/Linker/Linker.h"
+#include "llvm/Object/FunctionIndexObjectFile.h"
+#include "llvm/Support/CommandLine.h"
+#include "llvm/Support/Debug.h"
+#include "llvm/Support/SourceMgr.h"
+using namespace llvm;
+
+#define DEBUG_TYPE "function-import"
+
+// Load lazily a module from \p FileName in \p Context.
+static std::unique_ptr<Module> loadFile(const std::string &FileName,
+                                        LLVMContext &Context) {
+  SMDiagnostic Err;
+  DEBUG(dbgs() << "Loading '" << FileName << "'\n");
+  std::unique_ptr<Module> Result = getLazyIRFileModule(FileName, Err, Context);
+  if (!Result) {
+    Err.print("function-import", errs());
+    return nullptr;
+  }
+
+  Result->materializeMetadata();
+  UpgradeDebugInfo(*Result);
+
+  return Result;
+}
+
+// Get a Module for \p FileName from the cache, or load it lazily.
+Module &FunctionImporter::getOrLoadModule(StringRef FileName) {
+  auto &Module = ModuleMap[FileName];
+  if (!Module)
+    Module = loadFile(FileName, Context);
+  return *Module;
+}
+
+// Automatically import functions in Module \p M based on the summaries index.
+//
+// The current implementation imports every called functions that exists in the
+// summaries index.
+bool FunctionImporter::importFunctions(Module &M) {
+  assert(&Context == &M.getContext());
+
+  bool Changed = false;
+
+  /// First step is collecting the called functions and the one defined in this
+  /// module.
+  SmallPtrSet<Function *, 64> CalledFunctions; // FIXME tune size
+  for (auto &F : M) {
+    if (F.isDeclaration() || F.hasFnAttribute(Attribute::OptimizeNone))
+      continue;
+    for (auto &BB : F) {
+      for (auto &I : BB) {
+        if (isa<CallInst>(I)) {
+          DEBUG(dbgs() << "Found a call: '" << I << "'\n");
+          if (cast<CallInst>(I).getCalledFunction() &&
+              cast<CallInst>(I).getCalledFunction()->hasName() &&
+              cast<CallInst>(I).getCalledFunction()->isDeclaration())
+            CalledFunctions.insert(cast<CallInst>(I).getCalledFunction());
+        }
+      }
+    }
+  }
+
+  /// Second step: for every call to an external function, try to import it.
+
+  // Linker that will be used for importing function
+  Linker L(&M, DiagnosticHandler);
+
+  /// Insert initial called function set in a worklist, so that we can add
+  /// transively called functions when importing.
+  SmallVector<Function *, 64> Worklist(CalledFunctions.begin(),
+                                       CalledFunctions.end());
+  errs() << "Worklistsize: " << Worklist.size() << " " << CalledFunctions.size() <<  "\n";
+  while (!Worklist.empty()) {
+    auto CalledFunctionName = Worklist.pop_back_val()->getName();
+    DEBUG(dbgs() << "Process import for " << CalledFunctionName << "\n");
+    // Try to get a summary for this function call.
+    auto InfoList = Index.findFunctionInfoList(CalledFunctionName);
+    if (InfoList == Index.end()) {
+      DEBUG(dbgs() << "No summary for " << CalledFunctionName
+                   << " Ignoring.\n");
+      continue;
+    }
+    assert(!InfoList->second.empty() && "No summary, error at import?");
+
+    // Comdat can have multiple entries, FIXME: what do we do with them?
+    auto &Info = InfoList->second[0];
+    assert(Info && "Nullptr in list, error importing summaries?\n");
+
+    auto *Summary = Info->functionSummary();
+    if (!Summary) {
+      // FIXME: in case we are lazyloading summaries, we can do it now.
+      dbgs() << "Missing summary for  " << CalledFunctionName
+             << ", error at import?\n";
+      llvm_unreachable("Missing summary");
+    }
+
+    //
+    // No profitability notion right now, just import all the time...
+    //
+
+    // Get the module path from the summary.
+    auto FileName = Summary->modulePath();
+    DEBUG(dbgs() << "Importing " << CalledFunctionName << " from " << FileName
+                 << "\n");
+
+    // Get the module for the import (potentially from the cache).
+    auto &Module = getOrLoadModule(FileName);
+
+    // The function that we will import!
+    GlobalValue *SGV = Module.getNamedValue(CalledFunctionName);
+    Function *F = dyn_cast<Function>(SGV);
+    if (!F && isa<GlobalAlias>(SGV)) {
+      auto *SGA = dyn_cast<GlobalAlias>(SGV);
+      F = dyn_cast<Function>(SGA->getBaseObject());
+    }
+    if (!F) {
+      errs() << "Can't load function '" << CalledFunctionName << "' in Module '"
+             << FileName << "', error in the summary?\n";
+      llvm_unreachable("Can't load function in Module");
+    }
+
+    // We cannot import weak_any functions without possibly affecting the
+    // order they are seen and selected by the linker, changing program
+    // semantics.
+    if (F->hasWeakAnyLinkage()) {
+      DEBUG(dbgs() << "Ignoring import request for weak-any function "
+                   << CalledFunctionName << " from " << FileName << "\n");
+      continue;
+    }
+
+    // Link in the specified function.
+    if (L.linkInModule(&Module, Linker::Flags::None, &Index, F))
+      report_fatal_error("Function Import: link error");
+
+    // TODO: Process the newly imported function and add callees to the
+    // worklist.
+
+    Changed = true;
+  }
+  return Changed;
+}
+
+
+/// Summary file to use for function importing when using -function-import from
+/// the command line.
+static cl::opt<std::string>
+    SummaryFile("summary-file",
+                cl::desc("The summary file to use for function importing."));
+
+static void diagnosticHandler(const DiagnosticInfo &DI) {
+  raw_ostream &OS = errs();
+  DiagnosticPrinterRawOStream DP(OS);
+  DI.print(DP);
+  OS << '\n';
+}
+
+/// Parse the function index out of an IR file and return the function
+/// index object if found, or nullptr if not.
+static std::unique_ptr<FunctionInfoIndex>
+getFunctionIndexForFile(StringRef Path, std::string &Error,
+                        DiagnosticHandlerFunction DiagnosticHandler) {
+  std::unique_ptr<MemoryBuffer> Buffer;
+  ErrorOr<std::unique_ptr<MemoryBuffer>> BufferOrErr =
+      MemoryBuffer::getFile(Path);
+  if (std::error_code EC = BufferOrErr.getError()) {
+    Error = EC.message();
+    return nullptr;
+  }
+  Buffer = std::move(BufferOrErr.get());
+  ErrorOr<std::unique_ptr<object::FunctionIndexObjectFile>> ObjOrErr =
+      object::FunctionIndexObjectFile::create(Buffer->getMemBufferRef(),
+                                              DiagnosticHandler);
+  if (std::error_code EC = ObjOrErr.getError()) {
+    Error = EC.message();
+    return nullptr;
+  }
+  return (*ObjOrErr)->takeIndex();
+}
+
+
+/// Pass that performs cross-module function import provided a summary file.
+class FunctionImportPass : public ModulePass {
+
+public:
+  /// Pass identification, replacement for typeid
+  static char ID;
+
+  explicit FunctionImportPass() : ModulePass(ID) {}
+
+  bool runOnModule(Module &M) override {
+    if (SummaryFile.empty()) {
+      report_fatal_error("error: -function-import requires -summary-file\n");
+    }
+    std::string Error;
+    std::unique_ptr<FunctionInfoIndex> Index =
+        getFunctionIndexForFile(SummaryFile, Error, diagnosticHandler);
+    if (!Index) {
+      errs() << "Error loading file '" << SummaryFile << "': " << Error
+                   << "\n";
+      return false;
+    }
+
+    // Perform the import now.
+    FunctionImporter Importer(M.getContext(), *Index, diagnosticHandler);
+    return Importer.importFunctions(M);
+
+    return false;
+  }
+};
+
+char FunctionImportPass::ID = 0;
+INITIALIZE_PASS_BEGIN(FunctionImportPass, "function-import",
+                      "Summary Based Function Import", false, false)
+INITIALIZE_PASS_END(FunctionImportPass, "function-import",
+                    "Summary Based Function Import", false, false)
+
+namespace llvm {
+Pass *createFunctionImportPass() { return new FunctionImportPass(); }
+}

lib/Transforms/IPO/IPO.cpp

void llvm::initializeIPO(PassRegistry &Registry) {
   initializeStripDeadPrototypesLegacyPassPass(Registry);
   initializeStripSymbolsPass(Registry);
   initializeStripDebugDeclarePass(Registry);
   initializeStripDeadDebugInfoPass(Registry);
   initializeStripNonDebugSymbolsPass(Registry);
   initializeBarrierNoopPass(Registry);
   initializeEliminateAvailableExternallyPass(Registry);
   initializeSampleProfileLoaderPass(Registry);
+  initializeFunctionImportPassPass(Registry);
 }
 
 void LLVMInitializeIPO(LLVMPassRegistryRef R) {
   initializeIPO(*unwrap(R));
 }
 
 void LLVMAddArgumentPromotionPass(LLVMPassManagerRef PM) {
   unwrap(PM)->add(createArgumentPromotionPass());

lib/Transforms/IPO/LLVMBuild.txt

 ;
 ;===------------------------------------------------------------------------===;
 
 [component_0]
 type = Library
 name = IPO
 parent = Transforms
 library_name = ipo
-required_libraries = Analysis Core InstCombine ProfileData Scalar Support TransformUtils Vectorize
+required_libraries = Analysis Core InstCombine Linker ProfileData Scalar Support TransformUtils Vectorize

test/Transforms/FunctionImport/Inputs/funcimport.ll

+@globalvar = global i32 1, align 4
+@staticvar = internal global i32 1, align 4
+@staticconstvar = internal unnamed_addr constant [2 x i32] [i32 10, i32 20], align 4
+@commonvar = common global i32 0, align 4
+@P = internal global void ()* null, align 8
+
+@weakalias = weak alias void (...), bitcast (void ()* @globalfunc1 to void (...)*)
+@analias = alias void (...), bitcast (void ()* @globalfunc2 to void (...)*)
+@linkoncealias = alias void (...), bitcast (void ()* @linkoncefunc to void (...)*)
+
+define void @globalfunc1() #0 {
+entry:
+  ret void
+}
+
+define void @globalfunc2() #0 {
+entry:
+  ret void
+}
+
+define linkonce_odr void @linkoncefunc() #0 {
+entry:
+  ret void
+}
+
+define i32 @referencestatics(i32 %i) #0 {
+entry:
+  %i.addr = alloca i32, align 4
+  store i32 %i, i32* %i.addr, align 4
+  %call = call i32 @staticfunc()
+  %0 = load i32, i32* @staticvar, align 4
+  %add = add nsw i32 %call, %0
+  %1 = load i32, i32* %i.addr, align 4
+  %idxprom = sext i32 %1 to i64
+  %arrayidx = getelementptr inbounds [2 x i32], [2 x i32]* @staticconstvar, i64 0, i64 %idxprom
+  %2 = load i32, i32* %arrayidx, align 4
+  %add1 = add nsw i32 %add, %2
+  ret i32 %add1
+}
+
+define i32 @referenceglobals(i32 %i) #0 {
+entry:
+  %i.addr = alloca i32, align 4
+  store i32 %i, i32* %i.addr, align 4
+  call void @globalfunc1()
+  %0 = load i32, i32* @globalvar, align 4
+  ret i32 %0
+}
+
+define i32 @referencecommon(i32 %i) #0 {
+entry:
+  %i.addr = alloca i32, align 4
+  store i32 %i, i32* %i.addr, align 4
+  %0 = load i32, i32* @commonvar, align 4
+  ret i32 %0
+}
+
+define void @setfuncptr() #0 {
+entry:
+  store void ()* @staticfunc2, void ()** @P, align 8
+  ret void
+}
+
+define void @callfuncptr() #0 {
+entry:
+  %0 = load void ()*, void ()** @P, align 8
+  call void %0()
+  ret void
+}
+
+@weakvar = weak global i32 1, align 4
+define weak void @weakfunc() #0 {
+entry:
+  ret void
+}
+
+define void @callweakfunc() #0 {
+entry:
+  call void @weakfunc()
+  ret void
+}
+
+define internal i32 @staticfunc() #0 {
+entry:
+  ret i32 1
+}
+
+define internal void @staticfunc2() #0 {
+entry:
+  ret void
+}
+
+

test/Transforms/FunctionImport/funcimport.ll

+; Do setup work for all below tests: generate bitcode and combined index
+; RUN: llvm-as -function-summary %s -o %t.bc
+; RUN: llvm-as -function-summary %p/Inputs/funcimport.ll -o %t2.bc
+; RUN: llvm-lto -thinlto -o %t3 %t.bc %t2.bc
+
+; Do the import now
+; RUN: opt -function-import -summary-file %t3.thinlto.bc %s -S | FileCheck %s
+
+define i32 @main() #0 {
+entry:
+  call void (...) @weakalias()
+  call void (...) @analias()
+  %call = call i32 (...) @referencestatics()
+  %call1 = call i32 (...) @referenceglobals()
+  %call2 = call i32 (...) @referencecommon()
+  call void (...) @setfuncptr()
+  call void (...) @callfuncptr()
+  call void (...) @callweakfunc()
+  ret i32 0
+}
+
+; Won't import alias
+declare void @weakalias(...) #1
+declare void @analias(...) #1
+
+; CHECK-DAG: define available_externally i32 @referencestatics(i32 %i)
+declare i32 @referencestatics(...) #1
+
+; CHECK-DAG: define available_externally i32 @referenceglobals(i32 %i)
+declare i32 @referenceglobals(...) #1
+
+; CHECK-DAG: define available_externally i32 @referencecommon(i32 %i)
+declare i32 @referencecommon(...) #1
+
+; CHECK-DAG: define available_externally void @setfuncptr()
+declare void @setfuncptr(...) #1
+
+; CHECK-DAG: define available_externally void @callfuncptr()
+declare void @callfuncptr(...) #1
+
+; Won't import weak func
+declare void @callweakfunc(...) #1