Require address space to be specified when creating functions (2/3)

[dylanmckay]

Summary

This makes it necessary to specify address spaces when creating new
functions.

Most users won't have to worry about this as all of the
'getOrInsertFunction' functions on Module will default to the program
address space.

An overload has been added to Function::Create to abstract away the
details for most callers.

Full patchset

• Add program address space to data layout D37052
• Require address space to be specified when creating functions D37054
• [clang] Require address space to be specified when creating functions D37057

[dylanmckay]

Fix a bug where we would attempt to bitcast all AVR function pointers

[dylanmckay]

Don't check address space when looking up global values by name

If we are just looking up @foobar, we shouldn't have to specify the address space.

[dylanmckay]

I believe I also need to update the docs to mention the new bitcode field

[dylanmckay]

• Remove the switch table stuff for a later patch
• Rebased on top of trunk

[dylanmckay]

Move GlobalValue::getAddressSpace() from previous patch into here

[bjope]

I've applied your patches to my downstream repo, trying to figure out how much of our own patches for having different address space for functions that can be removed and still getting existing test cases to work when only having your patches.
Lots of new things happens now when there are addrspace on all function definitions. Our old implementation kind of added the addrspace information when fetching function pointers from the symbol table instead of adding addrspace when creating the functions. So I still have a couple of issues to analyse. I think that I at least tracked down one problem with calls to a function given a local function pointer variable (see my inline comment in LLParser.cpp).

There are no testcases included here with ll-files including calls/bitcasts etc with non-zero addrspace, so it is a little bit tricky to understand how far I'm supposed to get by only using your set of patches.
Are you testing this with some other out-of-tree target?

lib/AsmParser/LLParser.cpp

2691

I think we need the same patch as in GetGlobalVal here (line 1228).
I have a test case with function pointers that did not work otherwise. Here is an extract of the IR:

define void @f2(i16 %n, void (i16) addrspace(40)* %f) addrspace(40) #0 !dbg !16 {
entry:
  %n.addr = alloca i16, align 1
  %f.addr = alloca void (i16) addrspace(40)*, align 1
  %gap = alloca i16, align 1
  store i16 %n, i16* %n.addr, align 1, !tbaa !9
  store void (i16) addrspace(40)* %f, void (i16) addrspace(40)** %f.addr, align 1, !tbaa !17
  %0 = bitcast i16* %gap to i8*, !dbg !19
  call void @llvm.lifetime.start.p0i8(i64 1, i8* %0) #3, !dbg !19
  %1 = load i16, i16* %n.addr, align 1, !dbg !20, !tbaa !9
  %div = sdiv i16 %1, 2, !dbg !21
  store i16 %div, i16* %gap, align 1, !dbg !22, !tbaa !9
  br label %for.cond, !dbg !23

for.cond:                                         ; preds = %for.inc, %entry
  %2 = load i16, i16* %gap, align 1, !dbg !24, !tbaa !9
  %cmp = icmp sgt i16 %2, 0, !dbg !25
  br i1 %cmp, label %for.body, label %for.end, !dbg !26

for.body:                                         ; preds = %for.cond
  %3 = load void (i16) addrspace(40)*, void (i16) addrspace(40)** %f.addr, align 1, !dbg !27, !tbaa !17
  call void %3(i16 8), !dbg !28
  br label %for.inc, !dbg !29

And I got this error (unless I added the same patch as in GetGlobalVal):

opt: ./func_ptr.ll:43:13: error: '%3' defined with type 'void (i16) addrspace(40)*'
  call void %3(i16 8), !dbg !28
            ^

[bjope]

In D37054#956959, @bjope wrote:

I've applied your patches to my downstream repo, trying to figure out how much of our own patches for having different address space for functions that can be removed and still getting existing test cases to work when only having your patches.
Lots of new things happens now when there are addrspace on all function definitions. Our old implementation kind of added the addrspace information when fetching function pointers from the symbol table instead of adding addrspace when creating the functions. So I still have a couple of issues to analyse. I think that I at least tracked down one problem with calls to a function given a local function pointer variable (see my inline comment in LLParser.cpp).

There are no testcases included here with ll-files including calls/bitcasts etc with non-zero addrspace, so it is a little bit tricky to understand how far I'm supposed to get by only using your set of patches.
Are you testing this with some other out-of-tree target?

ping!

[bjope]

In D37054#1001762, @bjope wrote:

In D37054#956959, @bjope wrote:

I've applied your patches to my downstream repo, trying to figure out how much of our own patches for having different address space for functions that can be removed and still getting existing test cases to work when only having your patches.
Lots of new things happens now when there are addrspace on all function definitions. Our old implementation kind of added the addrspace information when fetching function pointers from the symbol table instead of adding addrspace when creating the functions. So I still have a couple of issues to analyse. I think that I at least tracked down one problem with calls to a function given a local function pointer variable (see my inline comment in LLParser.cpp).

There are no testcases included here with ll-files including calls/bitcasts etc with non-zero addrspace, so it is a little bit tricky to understand how far I'm supposed to get by only using your set of patches.
Are you testing this with some other out-of-tree target?

ping!

I see that part 1/3 has been landed now. As I mentioned above this second part at least breaks things for our out-of-tree target.
I've not analysed this any more since I discovered the problems in LLParser in December. I'm still kind of waiting for some response to understand more about the status of this patch (is it tested? is it supposed to work? do you have some test cases?).

[arichardson]

Looks good once the IR parser accepts calls to non-AS0 pointers.

lib/AsmParser/LLParser.cpp

1254

I believe loading a global in a different address space should still be an error, only calling is fine.

2691

Yes, we run into the same issue with CHERI and in our fork I added a hack to simply accept any pointer in AS200.

However, I believe this should only be okay for call instructions since we really don't want any implicit conversions from AS200 to AS0 pointers.

[arichardson]

@bjope does D43645 fix the LLParser issues for you?

[bjope]

In D37054#1016555, @arichardson wrote:

@bjope does D43645 fix the LLParser issues for you?

Thanks for the feedback @arichardson.
The D43645 solves some problems. I will do some more analysis of the problems I see in our local test suite (and hopefully I can create similar patches).

One problem I've seen is related to globals with forward reference of a function pointer (although I've not tested it with a clean top-of-tree yet):

%fun1 = type i16 (i16)
%funptr1 = type %fun1 addrspace(40)*

@fun_ptr = global %funptr1 @fun

define i16 @fun(i16 %arg) addrspace(40) {
  ret i16 %arg
}

I think that we should replace

PointerType *PFT = PointerType::getUnqual(FT);

by

PointerType *PFT = PointerType::get(FT, AddrSpace);

in LLParser::ParseFunctionHeader. That seems to solve the above problem at least.

Another problem I have is related to the declare construct. The test case is doing something like this:

define %int4 @fn1 () addrspace(40) {
...
%_tmp13 = call %int4 (%ptr6, %int4) bitcast ( %int4 (...)addrspace(40)* @fn2 to %int4 (%ptr6, %int4)addrspace(40)*)(%ptr6 %_tmp9, %int4 %_tmp12)
...
}

declare %int4 @fn2 (...);

and I get

error: constant expression type mismatch
%_tmp13 = call %int4 (%ptr6, %int4) bitcast ( %int4 (...)addrspace(40)* @fn2 to %int4 (%ptr6, %int4)addrspace(40)*)(%ptr6 %_tmp9, %int4 %_tmp12)
                                    ^

Maybe there should be an addrspace attribute on the declare statement? At the moment it does not help, because LLParser does not parse it.

[arichardson]

Thanks for working on this, it will make life a lot easier for us when it lands.

lib/AsmParser/LLParser.cpp

5051

As @bjope says this should use PointerType::get(FT, AddrSpace)

In our fork (https://github.com/CTSRD-CHERI/llvm / https://github.com/CTSRD-CHERI/clang) I have removed all uses of PointerType::getUnqual() from clang and most of them from LLVM since they almost always cause issues for us.

[dylanmckay]

There are no testcases included here with ll-files including calls/bitcasts etc with non-zero addrspace, so it is a little bit tricky to understand how far I'm supposed to get by only using your set of patches.

I've not analysed this any more since I discovered the problems in LLParser in December. I'm still kind of waiting for some response to understand more about the status of this patch (is it tested? is it supposed to work? do you have some test cases?).

I will work on adding some more test cases @bjope, sorry for being so slow with this!

@arichardson

Thanks a lot for looking into and submitting D43645! I will happily review it

@bjope

One problem I've seen is related to globals with forward reference of a function pointer (although I've not tested it with a clean top-of-tree yet)
..
Maybe there should be an addrspace attribute on the declare statement? At the moment it does not help, because LLParser does not parse it.

Your writeup and suggested change SGTM, I will fix the patch up and resubmit

[dylanmckay]

Gentle rebase

[arichardson]

docs/LangRef.rst

772

Just wondering if it would be better to put functions without an explicit address space in the program address space?
I think this may be more consistent since creating a new FunctionType without an address space will put it in the program address space and not address space zero.
I am not sure if there are any backwards compatibility constraints here since IR generated by an older version will never have the program address space in the datalayout string so they should also end up in address space zero.

Putting everything in the program address space should make it easier for us to keep the existing IR testcases once we expect all functions to be in address space 200.

[bjope]

docs/LangRef.rst

772

That sounds interesting. I'll probably try to do that for our out-of-tree target. Because we currently have two different frontends (one based on clang). With this commit the clang frontend will start to add explicit address spaces on functions, but it will take some time for me to adapt the other frontend to do the same in all situations.

The result would be quite similar to what we have out-of-tree today. We have patched both frontends to set a non-zero program address space in the DataLayout. But we do not set the address space explicitly on function declarations.

Without having the AS explicit when parsing the LL file we need to parse the DataLayout string first, to know about the targets default program address space when parsing the functions declarations. I think that is one problem those explicit address space annotations was supposed to help out with. So I'm not sure if it is feasible for the upstream LLVM trunk. However, normally the DataLayout is in the beginning of the .ll-file (no idea about .bc).

[dylanmckay]

Rebase and remove cherry-picked function now in trunk

[arichardson]

LGTM but I guess someone else should approve

lib/AsmParser/LLParser.cpp

1244

This line can be removed since isValidVariableType() does that check too

[bjope]

Another problem I have is related to the declare construct. The test case is doing something like this:

define %int4 @fn1 () addrspace(40) {
...
%_tmp13 = call %int4 (%ptr6, %int4) bitcast ( %int4 (...)addrspace(40)* @fn2 to %int4 (%ptr6, %int4)addrspace(40)*)(%ptr6 %_tmp9, %int4 %_tmp12)
...
}

declare %int4 @fn2 (...);

and I get

error: constant expression type mismatch
%_tmp13 = call %int4 (%ptr6, %int4) bitcast ( %int4 (...)addrspace(40)* @fn2 to %int4 (%ptr6, %int4)addrspace(40)*)(%ptr6 %_tmp9, %int4 %_tmp12)
                                    ^

Maybe there should be an addrspace attribute on the declare statement? At the moment it does not help, because LLParser does not parse it.

What about this? How is it supposed to work? Is it supposed to work? Or is it a question for the future?
(for me it will be a question for the present, because I think our out-of-tree tests starts to fail if I merge this patch...)

I still think there are lots of test cases that should be added to verify scenarios involving functions with non-zero address space.
The only new test case, test/Bitcode/function-nonzero-address-spaces.ll, verifies that it is possible to have a function declaration with the address space attribute.
Maybe that is all that is expected to work with this patch, or should I expect that I can have a more complete test case where I also call that function, or saves the function pointer in a variable, etc?

[arichardson]

test/Bitcode/function-nonzero-address-spaces.ll

6

Could you extend this test to also check that declare void @foo() addrspace(3) works?

[arichardson]

I've extracted a patch without the Module* -> Module& changes in D47541. It would be really good if something like this could land soon since I just ran into the problem that always_inline wasn't working at -O0 for us due to functions being in AS0 but the calls in AS200 and the alwaysInliner only handles direct calls without an addressspacecast.

[dylanmckay]

lib/AsmParser/LLParser.cpp

5051

It looks like there are quite a few getUnqual calls around the codebase which are likely to lose information.

A quick grep shows <~80

I wonder if it's worth refactoring the getUnqual method to make it harder to misuse.

[dylanmckay]

Ignore the review-related comments, they were leftover draft messages from a while back.

docs/LangRef.rst

 optional :ref:`linkage type <linkage>`, an optional :ref:`runtime preemption
 specifier <runtime_preemption_model>`,  an optional :ref:`visibility
 style <visibility>`, an optional :ref:`DLL storage class <dllstorageclass>`,
 an optional :ref:`calling convention <callingconv>`,
 an optional ``unnamed_addr`` attribute, a return type, an optional
 :ref:`parameter attribute <paramattrs>` for the return type, a function
 name, a (possibly empty) argument list (each with optional :ref:`parameter
 attributes <paramattrs>`), optional :ref:`function attributes <fnattrs>`,
-an optional section, an optional alignment,
+an optional address space, an optional section, an optional alignment,
 an optional :ref:`comdat <langref_comdats>`,
 an optional :ref:`garbage collector name <gc>`, an optional :ref:`prefix <prefixdata>`,
 an optional :ref:`prologue <prologuedata>`,
 an optional :ref:`personality <personalityfn>`,
 an optional list of attached :ref:`metadata <metadata>`,
 an opening curly brace, a list of basic blocks, and a closing curly brace.
 
 LLVM function declarations consist of the "``declare``" keyword, an
 optional :ref:`linkage type <linkage>`, an optional :ref:`visibility style
 <visibility>`, an optional :ref:`DLL storage class <dllstorageclass>`, an
 optional :ref:`calling convention <callingconv>`, an optional ``unnamed_addr``
-or ``local_unnamed_addr`` attribute, a return type, an optional :ref:`parameter
-attribute <paramattrs>` for the return type, a function name, a possibly
+or ``local_unnamed_addr`` attribute, an optional address space, a return type,
+an optional :ref:`parameter attribute <paramattrs>` for the return type, a function name, a possibly
 empty list of arguments, an optional alignment, an optional :ref:`garbage
 collector name <gc>`, an optional :ref:`prefix <prefixdata>`, and an optional
 :ref:`prologue <prologuedata>`.
 
 A function definition contains a list of basic blocks, forming the CFG (Control
 Flow Graph) for the function. Each basic block may optionally start with a label
 (giving the basic block a symbol table entry), contains a list of instructions,
 and ends with a :ref:`terminator <terminators>` instruction (such as a branch or

 alignment. All alignments must be a power of 2.
 
 If the ``unnamed_addr`` attribute is given, the address is known to not
 be significant and two identical functions can be merged.
 
 If the ``local_unnamed_addr`` attribute is given, the address is known to
 not be significant within the module.
 
+If an explicit address space is not given, it will default to zero.
+
 Syntax::
 
     define [linkage] [PreemptionSpecifier] [visibility] [DLLStorageClass]
            [cconv] [ret attrs]
            <ResultType> @<FunctionName> ([argument list])
-           [(unnamed_addr|local_unnamed_addr)] [fn Attrs] [section "name"]
-           [comdat [($name)]] [align N] [gc] [prefix Constant]
+           [(unnamed_addr|local_unnamed_addr)] [AddrSpace] [fn Attrs]
+           [section "name"] [comdat [($name)]] [align N] [gc] [prefix Constant]
            [prologue Constant] [personality Constant] (!name !N)* { ... }
 
 The argument list is a comma separated sequence of arguments where each
 argument is of the following form:
 
 Syntax::
 
    <type> [parameter Attrs] [name]

include/llvm/ExecutionEngine/Orc/CompileOnDemandLayer.h

auto Materializer = createLambdaMaterializer([&LD, &LMId,
         return ClonedF;
       }
 
       if (auto *A = dyn_cast<GlobalAlias>(V)) {
         auto *Ty = A->getValueType();
         if (Ty->isFunctionTy())
           return Function::Create(cast<FunctionType>(Ty),
                                   GlobalValue::ExternalLinkage, A->getName(),
-                                  M.get());
+                                  *M.get());
 
         return new GlobalVariable(*M, Ty, false, GlobalValue::ExternalLinkage,
                                   nullptr, A->getName(), nullptr,
                                   GlobalValue::NotThreadLocal,
                                   A->getType()->getAddressSpace());
       }
 
       return nullptr;

include/llvm/IR/Function.h

private:
   void BuildLazyArguments() const;
 
   void clearArguments();
 
   /// Function ctor - If the (optional) Module argument is specified, the
   /// function is automatically inserted into the end of the function list for
   /// the module.
   ///
-  Function(FunctionType *Ty, LinkageTypes Linkage,
+  Function(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace,
            const Twine &N = "", Module *M = nullptr);
 
 public:
   Function(const Function&) = delete;
   void operator=(const Function&) = delete;
   ~Function();
 
   // This is here to help easily convert from FunctionT * (Function * or
   // MachineFunction *) in BlockFrequencyInfoImpl to Function * by calling
   // FunctionT->getFunction().
   const Function &getFunction() const { return *this; }
 
   static Function *Create(FunctionType *Ty, LinkageTypes Linkage,
-                          const Twine &N = "", Module *M = nullptr) {
-    return new Function(Ty, Linkage, N, M);
+                          unsigned AddrSpace, const Twine &N = "",
+                          Module *M = nullptr) {
+    return new Function(Ty, Linkage, AddrSpace, N, M);
   }
 
+  /// Creates a new function and attaches it to a module.
+  ///
+  /// Places the function in the program address space as specified
+  /// by the module's data layout.
+  static Function *Create(FunctionType *Ty, LinkageTypes Linkage,
+                          const Twine &N, Module &M);
+
+  static Function *CreateBefore(Function &InsertBefore, FunctionType *Ty,
+                                LinkageTypes Linkage, const Twine &N = "");
+
   // Provide fast operand accessors.
   DECLARE_TRANSPARENT_OPERAND_ACCESSORS(Value);
 
   /// Returns the FunctionType for me.
   FunctionType *getFunctionType() const {
     return cast<FunctionType>(getValueType());
   }
 

include/llvm/IR/GlobalValue.h

enum ThreadLocalMode {
     LocalDynamicTLSModel,
     InitialExecTLSModel,
     LocalExecTLSModel
   };
 
   GlobalValue(const GlobalValue &) = delete;
 
   unsigned getAlignment() const;
+  unsigned getAddressSpace() const;
 
   enum class UnnamedAddr {
     None,
     Local,
     Global,
   };
 
   bool hasGlobalUnnamedAddr() const {

include/llvm/LinkAllPasses.h

ForcePassLinking() {
       (void) llvm::createStraightLineStrengthReducePass();
       (void) llvm::createMemDerefPrinter();
       (void) llvm::createFloat2IntPass();
       (void) llvm::createEliminateAvailableExternallyPass();
       (void) llvm::createScalarizeMaskedMemIntrinPass();
 
       (void)new llvm::IntervalPartition();
       (void)new llvm::ScalarEvolutionWrapperPass();
-      llvm::Function::Create(nullptr, llvm::GlobalValue::ExternalLinkage)->viewCFGOnly();
+      llvm::Function::Create(nullptr, llvm::GlobalValue::ExternalLinkage, 0)->viewCFGOnly();
       llvm::RGPassManager RGM;
       llvm::TargetLibraryInfoImpl TLII;
       llvm::TargetLibraryInfo TLI(TLII);
       llvm::AliasAnalysis AA(TLI);
       llvm::AliasSetTracker X(AA);
       X.add(nullptr, 0, llvm::AAMDNodes()); // for -print-alias-sets
       (void) llvm::AreStatisticsEnabled();
       (void) llvm::sys::RunningOnValgrind();
     }
   } ForcePassLinking; // Force link by creating a global definition.
 }
 
 #endif

lib/AsmParser/LLParser.cpp

 
 //===----------------------------------------------------------------------===//
 // GlobalValue Reference/Resolution Routines.
 //===----------------------------------------------------------------------===//
 
 static inline GlobalValue *createGlobalFwdRef(Module *M, PointerType *PTy,
                                               const std::string &Name) {
   if (auto *FT = dyn_cast<FunctionType>(PTy->getElementType()))
-    return Function::Create(FT, GlobalValue::ExternalWeakLinkage, Name, M);
+    return Function::Create(FT, GlobalValue::ExternalWeakLinkage,
+                            PTy->getAddressSpace(), Name, M);
   else
     return new GlobalVariable(*M, PTy->getElementType(), false,
                               GlobalValue::ExternalWeakLinkage, nullptr, Name,
                               nullptr, GlobalVariable::NotThreadLocal,
                               PTy->getAddressSpace());
 }
 
+static bool isValidVariableType(Module *M, Type *Ty, Value *Val, bool IsCall) {
+  if (Val->getType() == Ty)
+    return true;
+  // For calls we also accept variables in the program address space
+  if (IsCall && isa<PointerType>(Ty)) {
+    Type *TyInProgAS = cast<PointerType>(Ty)->getElementType()->getPointerTo(
+        M->getDataLayout().getProgramAddressSpace());
+    if (Val->getType() == TyInProgAS)
+      return true;
+  }
+  return false;
+}
+
 /// GetGlobalVal - Get a value with the specified name or ID, creating a
 /// forward reference record if needed.  This can return null if the value
 /// exists but does not have the right type.
 GlobalValue *LLParser::GetGlobalVal(const std::string &Name, Type *Ty,
                                     LocTy Loc) {
   PointerType *PTy = dyn_cast<PointerType>(Ty);
   if (!PTy) {
     Error(Loc, "global variable reference must have pointer type");
GlobalValue *LLParser::GetGlobalVal(const std::string &Name, Type *Ty,
   if (!Val) {
     auto I = ForwardRefVals.find(Name);
     if (I != ForwardRefVals.end())
       Val = I->second.first;
   }
 
   // If we have the value in the symbol table or fwd-ref table, return it.
   if (Val) {
     if (Val->getType() == Ty) return Val;
+    if (isValidVariableType(M, Ty, Val, /*IsCall=*/true)) return Val;
+
     Error(Loc, "'@" + Name + "' defined with type '" +
           getTypeString(Val->getType()) + "'");
     return nullptr;
   }
 
   // Otherwise, create a new forward reference for this value and remember it.
   GlobalValue *FwdVal = createGlobalFwdRef(M, PTy, Name);
   ForwardRefVals[Name] = std::make_pair(FwdVal, Loc);
   return FwdVal;
 }
 
 GlobalValue *LLParser::GetGlobalVal(unsigned ID, Type *Ty, LocTy Loc) {
   PointerType *PTy = dyn_cast<PointerType>(Ty);
   if (!PTy) {
     Error(Loc, "global variable reference must have pointer type");
     return nullptr;
return P.Error(ForwardRefVals.begin()->second.second,
                    "'");
   if (!ForwardRefValIDs.empty())
     return P.Error(ForwardRefValIDs.begin()->second.second,
                    "use of undefined value '%" +
                    Twine(ForwardRefValIDs.begin()->first) + "'");
   return false;
 }
 
-static bool isValidVariableType(Module *M, Type *Ty, Value *Val, bool IsCall) {
-  if (Val->getType() == Ty)
-    return true;
-  // For calls we also accept variables in the program address space
-  if (IsCall && isa<PointerType>(Ty)) {
-    Type *TyInProgAS = cast<PointerType>(Ty)->getElementType()->getPointerTo(
-        M->getDataLayout().getProgramAddressSpace());
-    if (Val->getType() == TyInProgAS)
-      return true;
-  }
-  return false;
-}
-
 /// GetVal - Get a value with the specified name or ID, creating a
 /// forward reference record if needed.  This can return null if the value
 /// exists but does not have the right type.
 Value *LLParser::PerFunctionState::GetVal(const std::string &Name, Type *Ty,
                                           LocTy Loc, bool IsCall) {
   // Look this name up in the normal function symbol table.
   Value *Val = F.getValueSymbolTable()->lookup(Name);
 
Value *LLParser::PerFunctionState::GetVal(unsigned ID, Type *Ty, LocTy Loc,
   // forward ref record.
   if (!Val) {
     auto I = ForwardRefValIDs.find(ID);
     if (I != ForwardRefValIDs.end())
       Val = I->second.first;
   }
 
   // If we have the value in the symbol table or fwd-ref table, return it.
   if (Val) {
     if (isValidVariableType(P.M, Ty, Val, IsCall))
       return Val;
     if (Ty->isLabelTy())
       P.Error(Loc, "'%" + Twine(ID) + "' is not a basic block");
     else
       P.Error(Loc, "'%" + Twine(ID) + "' defined with type '" +
               getTypeString(Val->getType()) + "'");
     return nullptr;
bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) {
   bool isVarArg;
   AttrBuilder FuncAttrs;
   std::vector<unsigned> FwdRefAttrGrps;
   LocTy BuiltinLoc;
   std::string Section;
   unsigned Alignment;
   std::string GC;
   GlobalValue::UnnamedAddr UnnamedAddr = GlobalValue::UnnamedAddr::None;
+  unsigned AddrSpace = 0;
   Constant *Prefix = nullptr;
   Constant *Prologue = nullptr;
   Constant *PersonalityFn = nullptr;
   Comdat *C;
 
   if (ParseArgumentList(ArgList, isVarArg) ||
       ParseOptionalUnnamedAddr(UnnamedAddr) ||
+      ParseOptionalAddrSpace(AddrSpace) ||
       ParseFnAttributeValuePairs(FuncAttrs, FwdRefAttrGrps, false,
                                  BuiltinLoc) ||
       (EatIfPresent(lltok::kw_section) &&
        ParseStringConstant(Section)) ||
       parseOptionalComdat(FunctionName, C) ||
       ParseOptionalAlignment(Alignment) ||
       (EatIfPresent(lltok::kw_gc) &&
        ParseStringConstant(GC)) ||
AttributeList PAL =
       AttributeList::get(Context, AttributeSet::get(Context, FuncAttrs),
                          AttributeSet::get(Context, RetAttrs), Attrs);
 
   if (PAL.hasAttribute(1, Attribute::StructRet) && !RetType->isVoidTy())
     return Error(RetTypeLoc, "functions with 'sret' argument must return void");
 
   FunctionType *FT =
     FunctionType::get(RetType, ParamTypeList, isVarArg);
-  PointerType *PFT = PointerType::getUnqual(FT);
+  PointerType *PFT = PointerType::get(FT, AddrSpace);
 
   Fn = nullptr;
   if (!FunctionName.empty()) {
     // If this was a definition of a forward reference, remove the definition
     // from the forward reference table and fill in the forward ref.
     auto FRVI = ForwardRefVals.find(FunctionName);
     if (FRVI != ForwardRefVals.end()) {
       Fn = M->getFunction(FunctionName);
if (I != ForwardRefValIDs.end()) {
       if (Fn->getType() != PFT)
         return Error(NameLoc, "type of definition and forward reference of '@" +
                      Twine(NumberedVals.size()) + "' disagree");
       ForwardRefValIDs.erase(I);
     }
   }
 
   if (!Fn)
-    Fn = Function::Create(FT, GlobalValue::ExternalLinkage, FunctionName, M);
+    Fn = Function::Create(FT, GlobalValue::ExternalLinkage, AddrSpace,
+                          FunctionName, M);
   else // Move the forward-reference to the correct spot in the module.
     M->getFunctionList().splice(M->end(), M->getFunctionList(), Fn);
 
   if (FunctionName.empty())
     NumberedVals.push_back(Fn);
 
   Fn->setLinkage((GlobalValue::LinkageTypes)Linkage);
   maybeSetDSOLocal(DSOLocal, *Fn);

lib/Bitcode/Reader/BitcodeReader.cpp

Error BitcodeReader::parseGlobalVarRecord(ArrayRef<uint64_t> Record) {
   }
 
   return Error::success();
 }
 
 Error BitcodeReader::parseFunctionRecord(ArrayRef<uint64_t> Record) {
   // v1: [type, callingconv, isproto, linkage, paramattr, alignment, section,
   // visibility, gc, unnamed_addr, prologuedata, dllstorageclass, comdat,
-  // prefixdata,  personalityfn, preemption specifier] (name in VST)
+  // prefixdata,  personalityfn, preemption specifier, addrspace] (name in VST)
   // v2: [strtab_offset, strtab_size, v1]
   StringRef Name;
   std::tie(Name, Record) = readNameFromStrtab(Record);
 
   if (Record.size() < 8)
     return error("Invalid record");
   Type *Ty = getTypeByID(Record[0]);
   if (!Ty)
     return error("Invalid record");
   if (auto *PTy = dyn_cast<PointerType>(Ty))
     Ty = PTy->getElementType();
   auto *FTy = dyn_cast<FunctionType>(Ty);
   if (!FTy)
     return error("Invalid type for value");
   auto CC = static_cast<CallingConv::ID>(Record[1]);
   if (CC & ~CallingConv::MaxID)
     return error("Invalid calling convention ID");
 
+  unsigned AddrSpace = TheModule->getDataLayout().getProgramAddressSpace();
+  if (Record.size() > 16)
+    AddrSpace = Record[16];
+
   Function *Func =
-      Function::Create(FTy, GlobalValue::ExternalLinkage, Name, TheModule);
+      Function::Create(FTy, GlobalValue::ExternalLinkage, AddrSpace, Name,
+                       TheModule);
 
   Func->setCallingConv(CC);
   bool isProto = Record[2];
   uint64_t RawLinkage = Record[3];
   Func->setLinkage(getDecodedLinkage(RawLinkage));
   Func->setAttributes(getAttributes(Record[4]));
 
   unsigned Alignment;

lib/Bitcode/Writer/BitcodeWriter.cpp

for (const GlobalVariable &GV : M.globals()) {
     Vals.clear();
   }
 
   // Emit the function proto information.
   for (const Function &F : M) {
     // FUNCTION:  [strtab offset, strtab size, type, callingconv, isproto,
     //             linkage, paramattrs, alignment, section, visibility, gc,
     //             unnamed_addr, prologuedata, dllstorageclass, comdat,
-    //             prefixdata, personalityfn, DSO_Local]
+    //             prefixdata, personalityfn, DSO_Local, addrspace]
     Vals.push_back(addToStrtab(F.getName()));
     Vals.push_back(F.getName().size());
     Vals.push_back(VE.getTypeID(F.getFunctionType()));
     Vals.push_back(F.getCallingConv());
     Vals.push_back(F.isDeclaration());
     Vals.push_back(getEncodedLinkage(F));
     Vals.push_back(VE.getAttributeListID(F.getAttributes()));
     Vals.push_back(Log2_32(F.getAlignment())+1);
     Vals.push_back(F.hasSection() ? SectionMap[F.getSection()] : 0);
     Vals.push_back(getEncodedVisibility(F));
     Vals.push_back(F.hasGC() ? GCMap[F.getGC()] : 0);
     Vals.push_back(getEncodedUnnamedAddr(F));
     Vals.push_back(F.hasPrologueData() ? (VE.getValueID(F.getPrologueData()) + 1)
                                        : 0);
     Vals.push_back(getEncodedDLLStorageClass(F));
     Vals.push_back(F.hasComdat() ? VE.getComdatID(F.getComdat()) : 0);
     Vals.push_back(F.hasPrefixData() ? (VE.getValueID(F.getPrefixData()) + 1)
                                      : 0);
     Vals.push_back(
         F.hasPersonalityFn() ? (VE.getValueID(F.getPersonalityFn()) + 1) : 0);
 
     Vals.push_back(F.isDSOLocal());
+    Vals.push_back(F.getAddressSpace());
+
     unsigned AbbrevToUse = 0;
     Stream.EmitRecord(bitc::MODULE_CODE_FUNCTION, Vals, AbbrevToUse);
     Vals.clear();
   }
 
   // Emit the alias information.
   for (const GlobalAlias &A : M.aliases()) {
     // ALIAS: [strtab offset, strtab size, alias type, aliasee val#, linkage,

lib/ExecutionEngine/Orc/IndirectionUtils.cpp

for (auto &A : M.aliases())
     raiseVisibilityOnValue(A, Renamer);
 }
 
 Function* cloneFunctionDecl(Module &Dst, const Function &F,
                             ValueToValueMapTy *VMap) {
   assert(F.getParent() != &Dst && "Can't copy decl over existing function.");
   Function *NewF =
     Function::Create(cast<FunctionType>(F.getValueType()),
-                     F.getLinkage(), F.getName(), &Dst);
+                     F.getLinkage(), F.getName(), Dst);
   NewF->copyAttributesFrom(&F);
 
   if (VMap) {
     (*VMap)[&F] = NewF;
     auto NewArgI = NewF->arg_begin();
     for (auto ArgI = F.arg_begin(), ArgE = F.arg_end(); ArgI != ArgE;
          ++ArgI, ++NewArgI)
       (*VMap)[&*ArgI] = &*NewArgI;

lib/FuzzMutate/IRMutator.cpp

 
 using namespace llvm;
 
 static void createEmptyFunction(Module &M) {
   // TODO: Some arguments and a return value would probably be more interesting.
   LLVMContext &Context = M.getContext();
   Function *F = Function::Create(FunctionType::get(Type::getVoidTy(Context), {},
                                                    /*isVarArg=*/false),
-                                 GlobalValue::ExternalLinkage, "f", &M);
+                                 GlobalValue::ExternalLinkage, "f", M);
   BasicBlock *BB = BasicBlock::Create(Context, "BB", F);
   ReturnInst::Create(Context, BB);
 }
 
 void IRMutationStrategy::mutate(Module &M, RandomIRBuilder &IB) {
   if (M.empty())
     createEmptyFunction(M);
 

lib/IR/AsmWriter.cpp

void AssemblyWriter::printFunction(const Function *F) {
   if (FT->isVarArg()) {
     if (FT->getNumParams()) Out << ", ";
     Out << "...";  // Output varargs portion of signature!
   }
   Out << ')';
   StringRef UA = getUnnamedAddrEncoding(F->getUnnamedAddr());
   if (!UA.empty())
     Out << ' ' << UA;
+  if (F->getAddressSpace() != 0)
+    Out << " addrspace(" << F->getAddressSpace() << ")";
   if (Attrs.hasAttributes(AttributeList::FunctionIndex))
     Out << " #" << Machine.getAttributeGroupSlot(Attrs.getFnAttributes());
   if (F->hasSection()) {
     Out << " section \"";
     PrintEscapedString(F->getSection(), Out);
     Out << '"';
   }
   maybePrintComdat(Out, *F);

lib/IR/AutoUpgrade.cpp

if (Name.startswith("arm.neon.vclz")) {
       Type* args[2] = {
         F->arg_begin()->getType(),
         Type::getInt1Ty(F->getContext())
       };
       // Can't use Intrinsic::getDeclaration here as it adds a ".i1" to
       // the end of the name. Change name from llvm.arm.neon.vclz.* to
       //  llvm.ctlz.*
       FunctionType* fType = FunctionType::get(F->getReturnType(), args, false);
-      NewFn = Function::Create(fType, F->getLinkage(),
+      NewFn = Function::Create(fType, F->getLinkage(), F->getAddressSpace(),
                                "llvm.ctlz." + Name.substr(14), F->getParent());
       return true;
     }
     if (Name.startswith("arm.neon.vcnt")) {
       NewFn = Intrinsic::getDeclaration(F->getParent(), Intrinsic::ctpop,
                                         F->arg_begin()->getType());
       return true;
     }
     Regex vldRegex("^arm\\.neon\\.vld([1234]|[234]lane)\\.v[a-z0-9]*$");
     if (vldRegex.match(Name)) {
       auto fArgs = F->getFunctionType()->params();
       SmallVector<Type *, 4> Tys(fArgs.begin(), fArgs.end());
       // Can't use Intrinsic::getDeclaration here as the return types might
       // then only be structurally equal.
       FunctionType* fType = FunctionType::get(F->getReturnType(), Tys, false);
-      NewFn = Function::Create(fType, F->getLinkage(),
+      NewFn = Function::Create(fType, F->getLinkage(), F->getAddressSpace(),
                                "llvm." + Name + ".p0i8", F->getParent());
       return true;
     }
     Regex vstRegex("^arm\\.neon\\.vst([1234]|[234]lane)\\.v[a-z0-9]*$");
     if (vstRegex.match(Name)) {
       static const Intrinsic::ID StoreInts[] = {Intrinsic::arm_neon_vst1,
                                                 Intrinsic::arm_neon_vst2,
                                                 Intrinsic::arm_neon_vst3,

lib/IR/Core.cpp

return wrap(GlobalAlias::create(PTy->getElementType(), PTy->getAddressSpace(),
                                   GlobalValue::ExternalLinkage, Name,
                                   unwrap<Constant>(Aliasee), unwrap(M)));
 }
 
 /*--.. Operations on functions .............................................--*/
 
 LLVMValueRef LLVMAddFunction(LLVMModuleRef M, const char *Name,
                              LLVMTypeRef FunctionTy) {
+  auto &Mod = *unwrap(M);
   return wrap(Function::Create(unwrap<FunctionType>(FunctionTy),
-                               GlobalValue::ExternalLinkage, Name, unwrap(M)));
+                               GlobalValue::ExternalLinkage, Name, Mod));
 }
 
 LLVMValueRef LLVMGetNamedFunction(LLVMModuleRef M, const char *Name) {
   return wrap(unwrap(M)->getFunction(Name));
 }
 
 LLVMValueRef LLVMGetFirstFunction(LLVMModuleRef M) {
   Module *Mod = unwrap(M);

lib/IR/Function.cpp

 //===----------------------------------------------------------------------===//
 // Helper Methods in Function
 //===----------------------------------------------------------------------===//
 
 LLVMContext &Function::getContext() const {
   return getType()->getContext();
 }
 
+Function *Function::Create(FunctionType *Ty, LinkageTypes Linkage,
+                           const Twine &N, Module &M) {
+  return Create(Ty, Linkage, M.getDataLayout().getProgramAddressSpace(),
+                N, &M);
+}
+
+Function *Function::CreateBefore(Function &InsertBefore, FunctionType *Ty,
+                                 LinkageTypes Linkage, const Twine &N) {
+  auto &M = *InsertBefore.getParent();
+  unsigned AddrSpace = M.getDataLayout().getProgramAddressSpace();
+  Function *F = Create(Ty, Linkage, AddrSpace, N);
+
+  M.getFunctionList().insert(InsertBefore.getIterator(), F);
+  return F;
+}
+
 void Function::removeFromParent() {
   getParent()->getFunctionList().remove(getIterator());
 }
 
 void Function::eraseFromParent() {
   getParent()->getFunctionList().erase(getIterator());
 }
 
 //===----------------------------------------------------------------------===//
 // Function Implementation
 //===----------------------------------------------------------------------===//
 
-Function::Function(FunctionType *Ty, LinkageTypes Linkage, const Twine &name,
-                   Module *ParentModule)
+Function::Function(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace,
+                   const Twine &name, Module *ParentModule)
     : GlobalObject(Ty, Value::FunctionVal,
-                   OperandTraits<Function>::op_begin(this), 0, Linkage, name),
+                   OperandTraits<Function>::op_begin(this), 0, Linkage, name,
+                   AddrSpace),
       NumArgs(Ty->getNumParams()) {
   assert(FunctionType::isValidReturnType(getReturnType()) &&
          "invalid return type");
   setGlobalObjectSubClassData(0);
 
   // We only need a symbol table for a function if the context keeps value names
   if (!getContext().shouldDiscardValueNames())
     SymTab = make_unique<ValueSymbolTable>();

lib/IR/Globals.cpp

if (auto *GA = dyn_cast<GlobalAlias>(this)) {
     // FIXME: we should also be able to handle:
     // Alias = Global + Offset
     // Alias = Absolute
     return 0;
   }
   return cast<GlobalObject>(this)->getAlignment();
 }
 
+unsigned GlobalValue::getAddressSpace() const {
+  PointerType *PtrTy = getType();
+  return PtrTy->getAddressSpace();
+}
+
 void GlobalObject::setAlignment(unsigned Align) {
   assert((Align & (Align-1)) == 0 && "Alignment is not a power of 2!");
   assert(Align <= MaximumAlignment &&
          "Alignment is greater than MaximumAlignment!");
   unsigned AlignmentData = Log2_32(Align) + 1;
   unsigned OldData = getGlobalValueSubClassData();
   setGlobalValueSubClassData((OldData & ~AlignmentMask) | AlignmentData);
   assert(getAlignment() == Align && "Alignment representation error!");

lib/IR/Module.cpp

 // the symbol table directly for this common task.
 //
 Constant *Module::getOrInsertFunction(StringRef Name, FunctionType *Ty,
                                       AttributeList AttributeList) {
   // See if we have a definition for the specified function already.
   GlobalValue *F = getNamedValue(Name);
   if (!F) {
     // Nope, add it
-    Function *New = Function::Create(Ty, GlobalVariable::ExternalLinkage, Name);
+    Function *New = Function::Create(Ty, GlobalVariable::ExternalLinkage,
+                                     DL.getProgramAddressSpace(), Name);
     if (!New->isIntrinsic())       // Intrinsics get attrs set on construction
       New->setAttributes(AttributeList);
     FunctionList.push_back(New);
     return New;                    // Return the new prototype.
   }
 
   // If the function exists but has the wrong type, return a bitcast to the
   // right type.
-  if (F->getType() != PointerType::getUnqual(Ty))
-    return ConstantExpr::getBitCast(F, PointerType::getUnqual(Ty));
+  auto *PTy = PointerType::get(Ty, F->getAddressSpace());
+  if (F->getType() != PTy)
+    return ConstantExpr::getBitCast(F, PTy);
 
   // Otherwise, we just found the existing function or a prototype.
   return F;
 }
 
 Constant *Module::getOrInsertFunction(StringRef Name,
                                       FunctionType *Ty) {
   return getOrInsertFunction(Name, Ty, AttributeList());

lib/Linker/IRMover.cpp

 
 /// Link the function in the source module into the destination module if
 /// needed, setting up mapping information.
 Function *IRLinker::copyFunctionProto(const Function *SF) {
   // If there is no linkage to be performed or we are linking from the source,
   // bring SF over.
   auto *F =
       Function::Create(TypeMap.get(SF->getFunctionType()),
-                       GlobalValue::ExternalLinkage, SF->getName(), &DstM);
+                       GlobalValue::ExternalLinkage, SF->getName(), DstM);
   F->copyAttributesFrom(SF);
   return F;
 }
 
 /// Set up prototypes for any aliases that come over from the source module.
 GlobalValue *IRLinker::copyGlobalAliasProto(const GlobalAlias *SGA) {
   // If there is no linkage to be performed or we're linking from the source,
   // bring over SGA.
GlobalValue *IRLinker::copyGlobalValueProto(const GlobalValue *SGV,
   } else if (auto *SF = dyn_cast<Function>(SGV)) {
     NewGV = copyFunctionProto(SF);
   } else {
     if (ForDefinition)
       NewGV = copyGlobalAliasProto(cast<GlobalAlias>(SGV));
     else if (SGV->getValueType()->isFunctionTy())
       NewGV =
           Function::Create(cast<FunctionType>(TypeMap.get(SGV->getValueType())),
-                           GlobalValue::ExternalLinkage, SGV->getName(), &DstM);
+                           GlobalValue::ExternalLinkage, SGV->getName(), DstM);
     else
       NewGV = new GlobalVariable(
           DstM, TypeMap.get(SGV->getValueType()),
           /*isConstant*/ false, GlobalValue::ExternalLinkage,
           /*init*/ nullptr, SGV->getName(),
           /*insertbefore*/ nullptr, SGV->getThreadLocalMode(),
           SGV->getType()->getAddressSpace());
   }

lib/Linker/LinkModules.cpp

void ModuleLinker::dropReplacedComdat(
   } else if (auto *Var = dyn_cast<GlobalVariable>(&GV)) {
     Var->setInitializer(nullptr);
   } else {
     auto &Alias = cast<GlobalAlias>(GV);
     Module &M = *Alias.getParent();
     PointerType &Ty = *cast<PointerType>(Alias.getType());
     GlobalValue *Declaration;
     if (auto *FTy = dyn_cast<FunctionType>(Alias.getValueType())) {
-      Declaration = Function::Create(FTy, GlobalValue::ExternalLinkage, "", &M);
+      Declaration = Function::Create(FTy, GlobalValue::ExternalLinkage, "", M);
     } else {
       Declaration =
           new GlobalVariable(M, Ty.getElementType(), /*isConstant*/ false,
                              GlobalValue::ExternalLinkage,
                              /*Initializer*/ nullptr);
     }
     Declaration->takeName(&Alias);
     Alias.replaceAllUsesWith(Declaration);

lib/Target/AMDGPU/AMDGPUOpenCLImageTypeLoweringPass.cpp

for (unsigned i = 0; i < FT->getNumParams(); ++i) {
       Modified = true;
     }
     if (!Modified) {
       return std::make_tuple(nullptr, nullptr);
     }
 
     // Create function with new signature and clone the old body into it.
     auto NewFT = FunctionType::get(FT->getReturnType(), ArgTypes, false);
-    auto NewF = Function::Create(NewFT, F->getLinkage(), F->getName());
+    auto NewF = Function::Create(NewFT, F->getLinkage(), F->getAddressSpace(),
+                                 F->getName());
     ValueToValueMapTy VMap;
     auto NewFArgIt = NewF->arg_begin();
     for (auto &Arg: F->args()) {
       auto ArgName = Arg.getName();
       NewFArgIt->setName(ArgName);
       VMap[&Arg] = &(*NewFArgIt++);
       if (IsImageType(ArgTypeFromMD(KernelMDNode, Arg.getArgNo()))) {
         (NewFArgIt++)->setName(Twine("__size_") + ArgName);

lib/Target/AMDGPU/AMDGPURewriteOutArguments.cpp

bool AMDGPURewriteOutArguments::runOnFunction(Function &F) {
   StructType *NewRetTy = StructType::create(Ctx, ReturnTypes, F.getName());
 
   FunctionType *NewFuncTy = FunctionType::get(NewRetTy,
                                               F.getFunctionType()->params(),
                                               F.isVarArg());
 
   DEBUG(dbgs() << "Computed new return type: " << *NewRetTy << '\n');
 
-  Function *NewFunc = Function::Create(NewFuncTy, Function::PrivateLinkage,
+  Function *NewFunc = Function::CreateBefore(F, NewFuncTy,
+                                             Function::PrivateLinkage,
                                              F.getName() + ".body");
-  F.getParent()->getFunctionList().insert(F.getIterator(), NewFunc);
   NewFunc->copyAttributesFrom(&F);
   NewFunc->setComdat(F.getComdat());
 
   // We want to preserve the function and param attributes, but need to strip
   // off any return attributes, e.g. zeroext doesn't make sense with a struct.
   NewFunc->stealArgumentListFrom(F);
 
   AttrBuilder RetAttrs;

lib/Target/Mips/Mips16HardFloat.cpp

static void assureFPCallStub(Function &F, Module *M,
   std::string SectionName = ".mips16.call.fp." + Name;
   std::string StubName = "__call_stub_fp_" + Name;
   //
   // see if we already have the stub
   //
   Function *FStub = M->getFunction(StubName);
   if (FStub && !FStub->isDeclaration()) return;
   FStub = Function::Create(F.getFunctionType(),
-                           Function::InternalLinkage, StubName, M);
+                           Function::InternalLinkage, StubName, *M);
   FStub->addFnAttr("mips16_fp_stub");
   FStub->addFnAttr(Attribute::Naked);
   FStub->addFnAttr(Attribute::NoInline);
   FStub->addFnAttr(Attribute::NoUnwind);
   FStub->addFnAttr("nomips16");
   FStub->setSection(SectionName);
   BasicBlock *BB = BasicBlock::Create(Context, "entry", FStub);
   FPReturnVariant RV = whichFPReturnVariant(FStub->getReturnType());
static void createFPFnStub(Function *F, Module *M, FPParamVariant PV,
   bool LE = TM.isLittleEndian();
   LLVMContext &Context = M->getContext();
   std::string Name = F->getName();
   std::string SectionName = ".mips16.fn." + Name;
   std::string StubName = "__fn_stub_" + Name;
   std::string LocalName = "$$__fn_local_" + Name;
   Function *FStub = Function::Create
     (F->getFunctionType(),
-     Function::InternalLinkage, StubName, M);
+     Function::InternalLinkage, StubName, *M);
   FStub->addFnAttr("mips16_fp_stub");
   FStub->addFnAttr(Attribute::Naked);
   FStub->addFnAttr(Attribute::NoUnwind);
   FStub->addFnAttr(Attribute::NoInline);
   FStub->addFnAttr("nomips16");
   FStub->setSection(SectionName);
   BasicBlock *BB = BasicBlock::Create(Context, "entry", FStub);
 

lib/Target/X86/X86RetpolineThunks.cpp

 
 void X86RetpolineThunks::createThunkFunction(Module &M, StringRef Name) {
   assert(Name.startswith(ThunkNamePrefix) &&
          "Created a thunk with an unexpected prefix!");
 
   LLVMContext &Ctx = M.getContext();
   auto Type = FunctionType::get(Type::getVoidTy(Ctx), false);
   Function *F =
-      Function::Create(Type, GlobalValue::LinkOnceODRLinkage, Name, &M);
+      Function::Create(Type, GlobalValue::LinkOnceODRLinkage, Name, M);
   F->setVisibility(GlobalValue::HiddenVisibility);
   F->setComdat(M.getOrInsertComdat(Name));
 
   // Add Attributes so that we don't create a frame, unwind information, or
   // inline.
   AttrBuilder B;
   B.addAttribute(llvm::Attribute::NoUnwind);
   B.addAttribute(llvm::Attribute::Naked);

lib/Target/X86/X86WinEHState.cpp

FunctionType *TrampolineTy =
                         /*isVarArg=*/false);
   FunctionType *TargetFuncTy =
       FunctionType::get(Int32Ty, makeArrayRef(&ArgTys[0], 5),
                         /*isVarArg=*/false);
   Function *Trampoline =
       Function::Create(TrampolineTy, GlobalValue::InternalLinkage,
                        Twine("__ehhandler$") + GlobalValue::dropLLVMManglingEscape(
                                                    ParentFunc->getName()),
-                       TheModule);
+                       *TheModule);
   if (auto *C = ParentFunc->getComdat())
     Trampoline->setComdat(C);
+
   BasicBlock *EntryBB = BasicBlock::Create(Context, "entry", Trampoline);
   IRBuilder<> Builder(EntryBB);
   Value *LSDA = emitEHLSDA(Builder, ParentFunc);
   Value *CastPersonality =
       Builder.CreateBitCast(PersonalityFn, TargetFuncTy->getPointerTo());
   auto AI = Trampoline->arg_begin();
   Value *Args[5] = {LSDA, &*AI++, &*AI++, &*AI++, &*AI++};
   CallInst *Call = Builder.CreateCall(CastPersonality, Args);

lib/Transforms/Coroutines/CoroSplit.cpp

static Function *createClone(Function &F, Twine Suffix, coro::Shape &Shape,
                              BasicBlock *ResumeEntry, int8_t FnIndex) {
   Module *M = F.getParent();
   auto *FrameTy = Shape.FrameTy;
   auto *FnPtrTy = cast<PointerType>(FrameTy->getElementType(0));
   auto *FnTy = cast<FunctionType>(FnPtrTy->getElementType());
 
   Function *NewF =
       Function::Create(FnTy, GlobalValue::LinkageTypes::InternalLinkage,
-                       F.getName() + Suffix, M);
+                       F.getName() + Suffix, *M);
   NewF->addParamAttr(0, Attribute::NonNull);
   NewF->addParamAttr(0, Attribute::NoAlias);
 
   ValueToValueMapTy VMap;
   // Replace all args with undefs. The buildCoroutineFrame algorithm already
   // rewritten access to the args that occurs after suspend points with loads
   // and stores to/from the coroutine frame.
   for (Argument &A : F.args())
static void createDevirtTriggerFunc(CallGraph &CG, CallGraphSCC &SCC) {
   if (M.getFunction(CORO_DEVIRT_TRIGGER_FN))
     return;
 
   LLVMContext &C = M.getContext();
   auto *FnTy = FunctionType::get(Type::getVoidTy(C), Type::getInt8PtrTy(C),
                                  /*IsVarArgs=*/false);
   Function *DevirtFn =
       Function::Create(FnTy, GlobalValue::LinkageTypes::PrivateLinkage,
-                       CORO_DEVIRT_TRIGGER_FN, &M);
+                       CORO_DEVIRT_TRIGGER_FN, M);
   DevirtFn->addFnAttr(Attribute::AlwaysInline);
   auto *Entry = BasicBlock::Create(C, "entry", DevirtFn);
   ReturnInst::Create(C, Entry);
 
   auto *Node = CG.getOrInsertFunction(DevirtFn);
 
   SmallVector<CallGraphNode *, 8> Nodes(SCC.begin(), SCC.end());
   Nodes.push_back(Node);

lib/Transforms/IPO/ArgumentPromotion.cpp

doPromotion(Function *F, SmallPtrSetImpl<Argument *> &ArgsToPromote,
   }
 
   Type *RetTy = FTy->getReturnType();
 
   // Construct the new function type using the new arguments.
   FunctionType *NFTy = FunctionType::get(RetTy, Params, FTy->isVarArg());
 
   // Create the new function body and insert it into the module.
-  Function *NF = Function::Create(NFTy, F->getLinkage(), F->getName());
+  Function *NF = Function::CreateBefore(*F, NFTy, F->getLinkage(),
+                                        F->getName());
   NF->copyAttributesFrom(F);
 
   // Patch the pointer to LLVM function in debug info descriptor.
   NF->setSubprogram(F->getSubprogram());
   F->setSubprogram(nullptr);
 
   DEBUG(dbgs() << "ARG PROMOTION:  Promoting to:" << *NF << "\n"
                << "From: " << *F);
 
   // Recompute the parameter attributes list based on the new arguments for
   // the function.
   NF->setAttributes(AttributeList::get(F->getContext(), PAL.getFnAttributes(),
                                        PAL.getRetAttributes(), ArgAttrVec));
   ArgAttrVec.clear();
 
-  F->getParent()->getFunctionList().insert(F->getIterator(), NF);
   NF->takeName(F);
 
   // Loop over all of the callers of the function, transforming the call sites
   // to pass in the loaded pointers.
   //
   SmallVector<Value *, 16> Args;
   while (!F->use_empty()) {
     CallSite CS(F->user_back());

lib/Transforms/IPO/DeadArgumentElimination.cpp

bool DeadArgumentEliminationPass::DeleteDeadVarargs(Function &Fn) {
   FunctionType *FTy = Fn.getFunctionType();
 
   std::vector<Type *> Params(FTy->param_begin(), FTy->param_end());
   FunctionType *NFTy = FunctionType::get(FTy->getReturnType(),
                                                 Params, false);
   unsigned NumArgs = Params.size();
 
   // Create the new function body and insert it into the module...
-  Function *NF = Function::Create(NFTy, Fn.getLinkage());
+  Function *NF = Function::CreateBefore(Fn, NFTy, Fn.getLinkage());
   NF->copyAttributesFrom(&Fn);
   NF->setComdat(Fn.getComdat());
-  Fn.getParent()->getFunctionList().insert(Fn.getIterator(), NF);
   NF->takeName(&Fn);
 
   // Loop over all of the callers of the function, transforming the call sites
   // to pass in a smaller number of arguments into the new function.
   //
   std::vector<Value *> Args;
   for (Value::user_iterator I = Fn.user_begin(), E = Fn.user_end(); I != E; ) {
     CallSite CS(*I++);
bool DeadArgumentEliminationPass::RemoveDeadStuffFromFunction(Function *F) {
 
   // Create the new function type based on the recomputed parameters.
   FunctionType *NFTy = FunctionType::get(NRetTy, Params, FTy->isVarArg());
 
   // No change?
   if (NFTy == FTy)
     return false;
 
-  // Create the new function body and insert it into the module...
-  Function *NF = Function::Create(NFTy, F->getLinkage());
+  // Create the new function body.
+  // Insert the new function before the old function, so we won't be processing
+  // it again.
+  Function *NF = Function::CreateBefore(*F, NFTy, F->getLinkage());
   NF->copyAttributesFrom(F);
   NF->setComdat(F->getComdat());
   NF->setAttributes(NewPAL);
-  // Insert the new function before the old function, so we won't be processing
-  // it again.
-  F->getParent()->getFunctionList().insert(F->getIterator(), NF);
   NF->takeName(F);
 
   // Patch the pointer to LLVM function in debug info descriptor.
   NF->setSubprogram(F->getSubprogram());
 
   // Loop over all of the callers of the function, transforming the call sites
   // to pass in a smaller number of arguments into the new function.
   std::vector<Value*> Args;

lib/Transforms/IPO/ExtractGV.cpp

bool runOnModule(Module &M) override {
 
         if (Delete) {
           Type *Ty =  CurI->getValueType();
 
           CurI->removeFromParent();
           llvm::Value *Declaration;
           if (FunctionType *FTy = dyn_cast<FunctionType>(Ty)) {
             Declaration = Function::Create(FTy, GlobalValue::ExternalLinkage,
-                                           CurI->getName(), &M);
+                                           CurI->getName(), M);
 
           } else {
             Declaration =
               new GlobalVariable(M, Ty, false, GlobalValue::ExternalLinkage,
                                  nullptr, CurI->getName());
 
           }
           CurI->replaceAllUsesWith(Declaration);

lib/Transforms/IPO/FunctionImport.cpp

if (Function *F = dyn_cast<Function>(&GV)) {
     V->setLinkage(GlobalValue::ExternalLinkage);
     V->clearMetadata();
     V->setComdat(nullptr);
   } else {
     GlobalValue *NewGV;
     if (GV.getValueType()->isFunctionTy())
       NewGV =
           Function::Create(cast<FunctionType>(GV.getValueType()),
-                           GlobalValue::ExternalLinkage, "", GV.getParent());
+                           GlobalValue::ExternalLinkage, "", *GV.getParent());
     else
       NewGV =
           new GlobalVariable(*GV.getParent(), GV.getValueType(),
                              /*isConstant*/ false, GlobalValue::ExternalLinkage,
                              /*init*/ nullptr, "",
                              /*insertbefore*/ nullptr, GV.getThreadLocalMode(),
                              GV.getType()->getAddressSpace());
     NewGV->takeName(&GV);

lib/Transforms/IPO/LowerTypeTests.cpp

void LowerTypeTestsModule::importFunction(Function *F, bool isDefinition) {
 
   GlobalValue::VisibilityTypes Visibility = F->getVisibility();
   std::string Name = F->getName();
   Function *FDecl;
 
   if (F->isDeclarationForLinker() && !isDefinition) {
     // Declaration of an external function.
     FDecl = Function::Create(F->getFunctionType(), GlobalValue::ExternalLinkage,
-                             Name + ".cfi_jt", &M);
+                             Name + ".cfi_jt", M);
     FDecl->setVisibility(GlobalValue::HiddenVisibility);
   } else if (isDefinition) {
     F->setName(Name + ".cfi");
     F->setLinkage(GlobalValue::ExternalLinkage);
     F->setVisibility(GlobalValue::HiddenVisibility);
     FDecl = Function::Create(F->getFunctionType(), GlobalValue::ExternalLinkage,
-                             Name, &M);
+                             Name, M);
     FDecl->setVisibility(Visibility);
 
     // Delete aliases pointing to this function, they'll be re-created in the
     // merged output
     SmallVector<GlobalAlias*, 4> ToErase;
     for (auto &U : F->uses()) {
       if (auto *A = dyn_cast<GlobalAlias>(U.getUser())) {
         Function *AliasDecl = Function::Create(
-            F->getFunctionType(), GlobalValue::ExternalLinkage, "", &M);
+            F->getFunctionType(), GlobalValue::ExternalLinkage, "", M);
         AliasDecl->takeName(A);
         A->replaceAllUsesWith(AliasDecl);
         ToErase.push_back(A);
       }
     }
     for (auto *A : ToErase)
       A->eraseFromParent();
   } else {

 }
 
 void LowerTypeTestsModule::moveInitializerToModuleConstructor(
     GlobalVariable *GV) {
   if (WeakInitializerFn == nullptr) {
     WeakInitializerFn = Function::Create(
         FunctionType::get(Type::getVoidTy(M.getContext()),
                           /* IsVarArg */ false),
-        GlobalValue::InternalLinkage, "__cfi_global_var_init", &M);
+        GlobalValue::InternalLinkage, "__cfi_global_var_init", M);
     BasicBlock *BB =
         BasicBlock::Create(M.getContext(), "entry", WeakInitializerFn);
     ReturnInst::Create(M.getContext(), BB);
     WeakInitializerFn->setSection(
         ObjectFormat == Triple::MachO
             ? "__TEXT,__StaticInit,regular,pure_instructions"
             : ".text.startup");
     // This code is equivalent to relocation application, and should run at the
void LowerTypeTestsModule::replaceWeakDeclarationWithJumpTablePtr(
   findGlobalVariableUsersOf(F, GlobalVarUsers);
   for (auto GV : GlobalVarUsers)
     moveInitializerToModuleConstructor(GV);
 
   // Can not RAUW F with an expression that uses F. Replace with a temporary
   // placeholder first.
   Function *PlaceholderFn =
       Function::Create(cast<FunctionType>(F->getValueType()),
-                       GlobalValue::ExternalWeakLinkage, "", &M);
+                       GlobalValue::ExternalWeakLinkage, "", M);
   F->replaceAllUsesWith(PlaceholderFn);
 
   Constant *Target = ConstantExpr::getSelect(
       ConstantExpr::getICmp(CmpInst::ICMP_NE, F,
                             Constant::getNullValue(F->getType())),
       JT, Constant::getNullValue(F->getType()));
   PlaceholderFn->replaceAllUsesWith(Target);
   PlaceholderFn->eraseFromParent();
void LowerTypeTestsModule::buildBitSetsFromFunctionsNative(
   DenseMap<GlobalTypeMember *, uint64_t> GlobalLayout;
   unsigned EntrySize = getJumpTableEntrySize();
   for (unsigned I = 0; I != Functions.size(); ++I)
     GlobalLayout[Functions[I]] = I * EntrySize;
 
   Function *JumpTableFn =
       Function::Create(FunctionType::get(Type::getVoidTy(M.getContext()),
                                          /* IsVarArg */ false),
-                       GlobalValue::PrivateLinkage, ".cfi.jumptable", &M);
+                       GlobalValue::PrivateLinkage, ".cfi.jumptable", M);
   ArrayType *JumpTableType =
       ArrayType::get(getJumpTableEntryType(), Functions.size());
   auto JumpTable =
       ConstantExpr::getPointerCast(JumpTableFn, JumpTableType->getPointerTo(0));
 
   lowerTypeTestCalls(TypeIds, JumpTable, GlobalLayout);
 
   // Build aliases pointing to offsets into the jump table, and replace
if (CfiFunctionsMD) {
       for (const auto &P : ExportedFunctions) {
         StringRef FunctionName = P.first;
         CfiFunctionLinkage Linkage = P.second.Linkage;
         MDNode *FuncMD = P.second.FuncMD;
         Function *F = M.getFunction(FunctionName);
         if (!F)
           F = Function::Create(
               FunctionType::get(Type::getVoidTy(M.getContext()), false),
-              GlobalVariable::ExternalLinkage, FunctionName, &M);
+              GlobalVariable::ExternalLinkage, FunctionName, M);
 
         // If the function is available_externally, remove its definition so
         // that it is handled the same way as a declaration. Later we will try
         // to create an alias using this function's linkage, which will fail if
         // the linkage is available_externally. This will also result in us
         // following the code path below to replace the type metadata.
         if (F->hasAvailableExternallyLinkage()) {
           F->setLinkage(GlobalValue::ExternalLinkage);

lib/Transforms/IPO/MergeFunctions.cpp

if (MergeFunctionsPDI) {
     DEBUG(dbgs() << "writeThunk: (MergeFunctionsPDI) filter parameter related "
                     "debug info for "
                  << G->getName() << "() {\n");
     filterInstsUnrelatedToPDI(GEntryBlock, PDIUnrelatedWL);
     GEntryBlock->getTerminator()->eraseFromParent();
     BB = GEntryBlock;
   } else {
     NewG = Function::Create(G->getFunctionType(), G->getLinkage(), "",
-                            G->getParent());
+                            *G->getParent());
     BB = BasicBlock::Create(F->getContext(), "", NewG);
   }
 
   IRBuilder<> Builder(BB);
   Function *H = MergeFunctionsPDI ? G : NewG;
   SmallVector<Value *, 16> Args;
   unsigned i = 0;
   FunctionType *FFTy = F->getFunctionType();

 
 // Merge two equivalent functions. Upon completion, Function G is deleted.
 void MergeFunctions::mergeTwoFunctions(Function *F, Function *G) {
   if (F->isInterposable()) {
     assert(G->isInterposable());
 
     // Make them both thunks to the same internal function.
     Function *H = Function::Create(F->getFunctionType(), F->getLinkage(), "",
-                                   F->getParent());
+                                   *F->getParent());
     H->copyAttributesFrom(F);
     H->takeName(F);
     removeUsers(F);
     F->replaceAllUsesWith(H);
 
     unsigned MaxAlignment = std::max(G->getAlignment(), H->getAlignment());
 
     writeThunk(F, G);

lib/Transforms/IPO/ThinLTOBitcodeWriter.cpp

for (auto I = M.begin(), E = M.end(); I != E;) {
     }
 
     if (!F.isDeclaration() || F.getFunctionType() == EmptyFT ||
         // Changing the type of an intrinsic may invalidate the IR.
         F.getName().startswith("llvm."))
       continue;
 
     Function *NewF =
-        Function::Create(EmptyFT, GlobalValue::ExternalLinkage, "", &M);
+        Function::Create(EmptyFT, GlobalValue::ExternalLinkage, "", M);
     NewF->setVisibility(F.getVisibility());
     NewF->takeName(&F);
     F.replaceAllUsesWith(ConstantExpr::getBitCast(NewF, F.getType()));
     F.eraseFromParent();
   }
 
   for (auto I = M.global_begin(), E = M.global_end(); I != E;) {
     GlobalVariable &GV = *I++;

lib/Transforms/Instrumentation/AddressSanitizer.cpp

GlobalVariable *Metadata = new GlobalVariable(
       Twine("__asan_global_") + GlobalValue::dropLLVMManglingEscape(OriginalName));
   Metadata->setSection(getGlobalMetadataSection());
   return Metadata;
 }
 
 IRBuilder<> AddressSanitizerModule::CreateAsanModuleDtor(Module &M) {
   AsanDtorFunction =
       Function::Create(FunctionType::get(Type::getVoidTy(*C), false),
-                       GlobalValue::InternalLinkage, kAsanModuleDtorName, &M);
+                       GlobalValue::InternalLinkage, kAsanModuleDtorName, M);
   BasicBlock *AsanDtorBB = BasicBlock::Create(*C, "", AsanDtorFunction);
 
   return IRBuilder<>(ReturnInst::Create(*C, AsanDtorBB));
 }
 
 void AddressSanitizerModule::InstrumentGlobalsCOFF(
     IRBuilder<> &IRB, Module &M, ArrayRef<GlobalVariable *> ExtendedGlobals,
     ArrayRef<Constant *> MetadataInitializers) {

lib/Transforms/Instrumentation/DataFlowSanitizer.cpp

void DataFlowSanitizer::addGlobalNamePrefix(GlobalValue *GV) {
   }
 }
 
 Function *
 DataFlowSanitizer::buildWrapperFunction(Function *F, StringRef NewFName,
                                         GlobalValue::LinkageTypes NewFLink,
                                         FunctionType *NewFT) {
   FunctionType *FT = F->getFunctionType();
-  Function *NewF = Function::Create(NewFT, NewFLink, NewFName,
-                                    F->getParent());
+  Function *NewF = Function::Create(NewFT, NewFLink, F->getAddressSpace(),
+                                    NewFName, F->getParent());
   NewF->copyAttributesFrom(F);
   NewF->removeAttributes(
       AttributeList::ReturnIndex,
       AttributeFuncs::typeIncompatible(NewFT->getReturnType()));
 
   BasicBlock *BB = BasicBlock::Create(*Ctx, "entry", NewF);
   if (F->isVarArg()) {
     NewF->removeAttributes(AttributeList::FunctionIndex,
for (std::vector<Function *>::iterator i = FnsToInstrument.begin(),
     bool IsZeroArgsVoidRet = (FT->getNumParams() == 0 && !FT->isVarArg() &&
                               FT->getReturnType()->isVoidTy());
 
     if (isInstrumented(&F)) {
       // Instrumented functions get a 'dfs$' prefix.  This allows us to more
       // easily identify cases of mismatching ABIs.
       if (getInstrumentedABI() == IA_Args && !IsZeroArgsVoidRet) {
         FunctionType *NewFT = getArgsFunctionType(FT);
-        Function *NewF = Function::Create(NewFT, F.getLinkage(), "", &M);
+        Function *NewF = Function::Create(NewFT, F.getLinkage(),
+                                          F.getAddressSpace(), "", &M);
         NewF->copyAttributesFrom(&F);
         NewF->removeAttributes(
             AttributeList::ReturnIndex,
             AttributeFuncs::typeIncompatible(NewFT->getReturnType()));
         for (Function::arg_iterator FArg = F.arg_begin(),
                                     NewFArg = NewF->arg_begin(),
                                     FArgEnd = F.arg_end();
              FArg != FArgEnd; ++FArg, ++NewFArg) {

lib/Transforms/Instrumentation/EfficiencySanitizer.cpp

Constant *EfficiencySanitizer::createEsanInitToolInfoArg(Module &M,
   return ConstantPointerNull::get(Int8PtrTy);
 }
 
 void EfficiencySanitizer::createDestructor(Module &M, Constant *ToolInfoArg) {
   PointerType *Int8PtrTy = Type::getInt8PtrTy(*Ctx);
   EsanDtorFunction = Function::Create(FunctionType::get(Type::getVoidTy(*Ctx),
                                                         false),
                                       GlobalValue::InternalLinkage,
-                                      EsanModuleDtorName, &M);
+                                      EsanModuleDtorName, M);
   ReturnInst::Create(*Ctx, BasicBlock::Create(*Ctx, "", EsanDtorFunction));
   IRBuilder<> IRB_Dtor(EsanDtorFunction->getEntryBlock().getTerminator());
   Function *EsanExit = checkSanitizerInterfaceFunction(
       M.getOrInsertFunction(EsanExitName, IRB_Dtor.getVoidTy(),
                             Int8PtrTy));
   EsanExit->setLinkage(Function::ExternalLinkage);
   IRB_Dtor.CreateCall(EsanExit, {ToolInfoArg});
   appendToGlobalDtors(M, EsanDtorFunction, EsanCtorAndDtorPriority);

lib/Transforms/Instrumentation/GCOVProfiling.cpp

for (unsigned i = 0, e = CU_Nodes->getNumOperands(); i != e; ++i) {
     Function *WriteoutF = insertCounterWriteout(CountersBySP);
     Function *FlushF = insertFlush(CountersBySP);
 
     // Create a small bit of code that registers the "__llvm_gcov_writeout" to
     // be executed at exit and the "__llvm_gcov_flush" function to be executed
     // when "__gcov_flush" is called.
     FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
     Function *F = Function::Create(FTy, GlobalValue::InternalLinkage,
-                                   "__llvm_gcov_init", M);
+                                   "__llvm_gcov_init", *M);
     F->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
     F->setLinkage(GlobalValue::InternalLinkage);
     F->addFnAttr(Attribute::NoInline);
     if (Options.NoRedZone)
       F->addFnAttr(Attribute::NoRedZone);
 
     BasicBlock *BB = BasicBlock::Create(*Ctx, "entry", F);
     IRBuilder<> Builder(BB);

 }
 
 Function *GCOVProfiler::insertCounterWriteout(
     ArrayRef<std::pair<GlobalVariable *, MDNode *> > CountersBySP) {
   FunctionType *WriteoutFTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
   Function *WriteoutF = M->getFunction("__llvm_gcov_writeout");
   if (!WriteoutF)
     WriteoutF = Function::Create(WriteoutFTy, GlobalValue::InternalLinkage,
-                                 "__llvm_gcov_writeout", M);
+                                 "__llvm_gcov_writeout", *M);
   WriteoutF->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
   WriteoutF->addFnAttr(Attribute::NoInline);
   if (Options.NoRedZone)
     WriteoutF->addFnAttr(Attribute::NoRedZone);
 
   BasicBlock *BB = BasicBlock::Create(*Ctx, "entry", WriteoutF);
   IRBuilder<> Builder(BB);
 

 }
 
 Function *GCOVProfiler::
 insertFlush(ArrayRef<std::pair<GlobalVariable*, MDNode*> > CountersBySP) {
   FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
   Function *FlushF = M->getFunction("__llvm_gcov_flush");
   if (!FlushF)
     FlushF = Function::Create(FTy, GlobalValue::InternalLinkage,
-                              "__llvm_gcov_flush", M);
+                              "__llvm_gcov_flush", *M);
   else
     FlushF->setLinkage(GlobalValue::InternalLinkage);
   FlushF->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
   FlushF->addFnAttr(Attribute::NoInline);
   if (Options.NoRedZone)
     FlushF->addFnAttr(Attribute::NoRedZone);
 
   BasicBlock *Entry = BasicBlock::Create(*Ctx, "entry", FlushF);

lib/Transforms/Instrumentation/InstrProfiling.cpp

if (!needsRuntimeRegistrationOfSectionRange(*M))
     return;
 
   // Construct the function.
   auto *VoidTy = Type::getVoidTy(M->getContext());
   auto *VoidPtrTy = Type::getInt8PtrTy(M->getContext());
   auto *Int64Ty = Type::getInt64Ty(M->getContext());
   auto *RegisterFTy = FunctionType::get(VoidTy, false);
   auto *RegisterF = Function::Create(RegisterFTy, GlobalValue::InternalLinkage,
-                                     getInstrProfRegFuncsName(), M);
+                                     getInstrProfRegFuncsName(), *M);
   RegisterF->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
   if (Options.NoRedZone)
     RegisterF->addFnAttr(Attribute::NoRedZone);
 
   auto *RuntimeRegisterTy = FunctionType::get(VoidTy, VoidPtrTy, false);
   auto *RuntimeRegisterF =
       Function::Create(RuntimeRegisterTy, GlobalVariable::ExternalLinkage,
-                       getInstrProfRegFuncName(), M);
+                       getInstrProfRegFuncName(), *M);
 
   IRBuilder<> IRB(BasicBlock::Create(M->getContext(), "", RegisterF));
   for (Value *Data : UsedVars)
     if (Data != NamesVar)
       IRB.CreateCall(RuntimeRegisterF, IRB.CreateBitCast(Data, VoidPtrTy));
 
   if (NamesVar) {
     Type *ParamTypes[] = {VoidPtrTy, Int64Ty};
     auto *NamesRegisterTy =
         FunctionType::get(VoidTy, makeArrayRef(ParamTypes), false);
     auto *NamesRegisterF =
         Function::Create(NamesRegisterTy, GlobalVariable::ExternalLinkage,
-                         getInstrProfNamesRegFuncName(), M);
+                         getInstrProfNamesRegFuncName(), *M);
     IRB.CreateCall(NamesRegisterF, {IRB.CreateBitCast(NamesVar, VoidPtrTy),
                                     IRB.getInt64(NamesSize)});
   }
 
   IRB.CreateRetVoid();
 }
 
 bool InstrProfiling::emitRuntimeHook() {
bool InstrProfiling::emitRuntimeHook() {
   auto *Int32Ty = Type::getInt32Ty(M->getContext());
   auto *Var =
       new GlobalVariable(*M, Int32Ty, false, GlobalValue::ExternalLinkage,
                          nullptr, getInstrProfRuntimeHookVarName());
 
   // Make a function that uses it.
   auto *User = Function::Create(FunctionType::get(Int32Ty, false),
                                 GlobalValue::LinkOnceODRLinkage,
-                                getInstrProfRuntimeHookVarUseFuncName(), M);
+                                getInstrProfRuntimeHookVarUseFuncName(), *M);
   User->addFnAttr(Attribute::NoInline);
   if (Options.NoRedZone)
     User->addFnAttr(Attribute::NoRedZone);
   User->setVisibility(GlobalValue::HiddenVisibility);
   if (Triple(M->getTargetTriple()).supportsCOMDAT())
     User->setComdat(M->getOrInsertComdat(User->getName()));
 
   IRBuilder<> IRB(BasicBlock::Create(M->getContext(), "", User));
void InstrProfiling::emitInitialization() {
   Constant *RegisterF = M->getFunction(getInstrProfRegFuncsName());
   if (!RegisterF)
     return;
 
   // Create the initialization function.
   auto *VoidTy = Type::getVoidTy(M->getContext());
   auto *F = Function::Create(FunctionType::get(VoidTy, false),
                              GlobalValue::InternalLinkage,
-                             getInstrProfInitFuncName(), M);
+                             getInstrProfInitFuncName(), *M);
   F->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
   F->addFnAttr(Attribute::NoInline);
   if (Options.NoRedZone)
     F->addFnAttr(Attribute::NoRedZone);
 
   // Add the basic block and the necessary calls.
   IRBuilder<> IRB(BasicBlock::Create(M->getContext(), "", F));
   if (RegisterF)
     IRB.CreateCall(RegisterF, {});
   IRB.CreateRetVoid();
 
   appendToGlobalCtors(*M, F, 0);
 }

lib/Transforms/Utils/CloneFunction.cpp

if (VMap.count(&I) == 0) // Haven't mapped the argument to anything yet?
       ArgTypes.push_back(I.getType());
 
   // Create a new function type...
   FunctionType *FTy = FunctionType::get(F->getFunctionType()->getReturnType(),
                                     ArgTypes, F->getFunctionType()->isVarArg());
 
   // Create the new function...
   Function *NewF =
-      Function::Create(FTy, F->getLinkage(), F->getName(), F->getParent());
+      Function::Create(FTy, F->getLinkage(), F->getAddressSpace(),
+                       F->getName(), F->getParent());
 
   // Loop over the arguments, copying the names of the mapped arguments over...
   Function::arg_iterator DestI = NewF->arg_begin();
   for (const Argument & I : F->args())
     if (VMap.count(&I) == 0) {     // Is this argument preserved?
       DestI->setName(I.getName()); // Copy the name over...
       VMap[&I] = &*DestI++;        // Add mapping to VMap
     }

lib/Transforms/Utils/CloneModule.cpp

GlobalVariable *GV = new GlobalVariable(*New,
                                             I->getType()->getAddressSpace());
     GV->copyAttributesFrom(&*I);
     VMap[&*I] = GV;
   }
 
   // Loop over the functions in the module, making external functions as before
   for (const Function &I : M) {
     Function *NF = Function::Create(cast<FunctionType>(I.getValueType()),
-                                    I.getLinkage(), I.getName(), New.get());
+                                    I.getLinkage(), I.getAddressSpace(),
+                                    I.getName(), New.get());
     NF->copyAttributesFrom(&I);
     VMap[&I] = NF;
   }
 
   // Loop over the aliases in the module
   for (Module::const_alias_iterator I = M.alias_begin(), E = M.alias_end();
        I != E; ++I) {
     if (!ShouldCloneDefinition(&*I)) {
       // An alias cannot act as an external reference, so we need to create
       // either a function or a global variable depending on the value type.
       // FIXME: Once pointee types are gone we can probably pick one or the
       // other.
       GlobalValue *GV;
       if (I->getValueType()->isFunctionTy())
         GV = Function::Create(cast<FunctionType>(I->getValueType()),
-                              GlobalValue::ExternalLinkage, I->getName(),
+                              GlobalValue::ExternalLinkage,
+                              I->getAddressSpace(), I->getName(),
                               New.get());
       else
         GV = new GlobalVariable(
             *New, I->getValueType(), false, GlobalValue::ExternalLinkage,
             nullptr, I->getName(), nullptr,
             I->getThreadLocalMode(), I->getType()->getAddressSpace());
       VMap[&*I] = GV;
       // We do not copy attributes (mainly because copying between different

lib/Transforms/Utils/CodeExtractor.cpp

Function *CodeExtractor::constructFunction(const ValueSet &inputs,
   }
   FunctionType *funcType =
                   FunctionType::get(RetTy, paramTy,
                                     AllowVarArgs && oldFunction->isVarArg());
 
   // Create the new function
   Function *newFunction = Function::Create(funcType,
                                            GlobalValue::InternalLinkage,
+                                           oldFunction->getAddressSpace(),
                                            oldFunction->getName() + "_" +
                                            header->getName(), M);
   // If the old function is no-throw, so is the new one.
   if (oldFunction->doesNotThrow())
     newFunction->setDoesNotThrow();
 
   // Inherit the uwtable attribute if we need to.
   if (oldFunction->hasUWTable())

lib/Transforms/Utils/ModuleUtils.cpp

std::pair<Function *, Function *> llvm::createSanitizerCtorAndInitFunctions(
     StringRef VersionCheckName) {
   assert(!InitName.empty() && "Expected init function name");
   assert(InitArgs.size() == InitArgTypes.size() &&
          "Sanitizer's init function expects different number of arguments");
   Function *InitFunction =
       declareSanitizerInitFunction(M, InitName, InitArgTypes);
   Function *Ctor = Function::Create(
       FunctionType::get(Type::getVoidTy(M.getContext()), false),
-      GlobalValue::InternalLinkage, CtorName, &M);
+                        GlobalValue::InternalLinkage,
+                        CtorName, M);
   BasicBlock *CtorBB = BasicBlock::Create(M.getContext(), "", Ctor);
   IRBuilder<> IRB(ReturnInst::Create(M.getContext(), CtorBB));
   IRB.CreateCall(InitFunction, InitArgs);
   if (!VersionCheckName.empty()) {
     Function *VersionCheckFunction =
         checkSanitizerInterfaceFunction(M.getOrInsertFunction(
             VersionCheckName, FunctionType::get(IRB.getVoidTy(), {}, false),
             AttributeList()));

lib/Transforms/Utils/SanitizerStats.cpp

auto NewModuleStatsGV = new GlobalVariable(
            ConstantInt::get(Int32Ty, Inits.size()),
            ConstantArray::get(makeModuleStatsArrayTy(), Inits)}));
   ModuleStatsGV->replaceAllUsesWith(
       ConstantExpr::getBitCast(NewModuleStatsGV, ModuleStatsGV->getType()));
   ModuleStatsGV->eraseFromParent();
 
   // Create a global constructor to register NewModuleStatsGV.
   auto F = Function::Create(FunctionType::get(VoidTy, false),
-                            GlobalValue::InternalLinkage, "", M);
+                            GlobalValue::InternalLinkage, "", *M);
   auto BB = BasicBlock::Create(M->getContext(), "", F);
   IRBuilder<> B(BB);
 
   FunctionType *StatInitTy = FunctionType::get(VoidTy, Int8PtrTy, false);
   Constant *StatInit = M->getOrInsertFunction(
       "__sanitizer_stat_init", StatInitTy);
 
   B.CreateCall(StatInit, ConstantExpr::getBitCast(NewModuleStatsGV, Int8PtrTy));
   B.CreateRetVoid();
 
   appendToGlobalCtors(*M, F, 0);
 }

lib/Transforms/Vectorize/LoopVectorize.cpp

for (unsigned Part = 0; Part < UF; ++Part) {
         // Use vector version of the library call.
         StringRef VFnName = TLI->getVectorizedFunction(FnName, VF);
         assert(!VFnName.empty() && "Vector function name is empty.");
         VectorF = M->getFunction(VFnName);
         if (!VectorF) {
           // Generate a declaration
           FunctionType *FTy = FunctionType::get(RetTy, Tys, false);
           VectorF =
-              Function::Create(FTy, Function::ExternalLinkage, VFnName, M);
+              Function::Create(FTy, Function::ExternalLinkage, VFnName, *M);
           VectorF->copyAttributesFrom(F);
         }
       }
       assert(VectorF && "Can't create vector function.");
 
       SmallVector<OperandBundleDef, 1> OpBundles;
       CI->getOperandBundlesAsDefs(OpBundles);
       CallInst *V = Builder.CreateCall(VectorF, Args, OpBundles);

test/Bitcode/function-nonzero-address-spaces.ll

+; RUN: llvm-as < %s | llvm-dis | FileCheck %s
+
+; CHECK: define void @main() addrspace(3)
+define void @main() addrspace(3) {
+  ret void
+}
+

tools/bugpoint/Miscompilation.cpp

static void CleanupAndPrepareModules(BugDriver &BD,
   // which just calls the old one.
   if (Function *oldMain = Safe->getFunction("main"))
     if (!oldMain->isDeclaration()) {
       // Rename it
       oldMain->setName("llvm_bugpoint_old_main");
       // Create a NEW `main' function with same type in the test module.
       Function *newMain =
           Function::Create(oldMain->getFunctionType(),
-                           GlobalValue::ExternalLinkage, "main", Test.get());
+                           GlobalValue::ExternalLinkage, "main", *Test.get());
       // Create an `oldmain' prototype in the test module, which will
       // corresponds to the real main function in the same module.
       Function *oldMainProto = Function::Create(oldMain->getFunctionType(),
                                                 GlobalValue::ExternalLinkage,
-                                                oldMain->getName(), Test.get());
+                                                oldMain->getName(), *Test.get());
       // Set up and remember the argument list for the main function.
       std::vector<Value *> args;
       for (Function::arg_iterator I = newMain->arg_begin(),
                                   E = newMain->arg_end(),
                                   OI = oldMain->arg_begin();
            I != E; ++I, ++OI) {
         I->setName(OI->getName()); // Copy argument names from oldMain
         args.push_back(&*I);
if (F->isDeclaration() && !F->use_empty() && &*F != resolverFunc &&
           GlobalVariable *Cache = new GlobalVariable(
               *F->getParent(), F->getType(), false,
               GlobalValue::InternalLinkage, NullPtr, F->getName() + ".fpcache");
 
           // Construct a new stub function that will re-route calls to F
           FunctionType *FuncTy = F->getFunctionType();
           Function *FuncWrapper =
               Function::Create(FuncTy, GlobalValue::InternalLinkage,
-                               F->getName() + "_wrapper", F->getParent());
+                               F->getName() + "_wrapper", *F->getParent());
           BasicBlock *EntryBB =
               BasicBlock::Create(F->getContext(), "entry", FuncWrapper);
           BasicBlock *DoCallBB =
               BasicBlock::Create(F->getContext(), "usecache", FuncWrapper);
           BasicBlock *LookupBB =
               BasicBlock::Create(F->getContext(), "lookupfp", FuncWrapper);
 
           // Check to see if we already looked up the value.

tools/lli/lli.cpp

static void addCygMingExtraModule(ExecutionEngine &EE, LLVMContext &Context,
   std::unique_ptr<Module> M = make_unique<Module>("CygMingHelper", Context);
   M->setTargetTriple(TargetTripleStr);
 
   // Create an empty function named "__main".
   Function *Result;
   if (TargetTriple.isArch64Bit()) {
     Result = Function::Create(
       TypeBuilder<int64_t(void), false>::get(Context),
-      GlobalValue::ExternalLinkage, "__main", M.get());
+      GlobalValue::ExternalLinkage, "__main", *M.get());
   } else {
     Result = Function::Create(
       TypeBuilder<int32_t(void), false>::get(Context),
-      GlobalValue::ExternalLinkage, "__main", M.get());
+      GlobalValue::ExternalLinkage, "__main", *M.get());
   }
   BasicBlock *BB = BasicBlock::Create(Context, "__main", Result);
   Builder.SetInsertPoint(BB);
   Value *ReturnVal;
   if (TargetTriple.isArch64Bit())
     ReturnVal = ConstantInt::get(Context, APInt(64, 0));
   else
     ReturnVal = ConstantInt::get(Context, APInt(32, 0));

tools/llvm-stress/llvm-stress.cpp

Type* ArgsTy[] = {
     Type::getInt32Ty(Context),
     Type::getInt64Ty(Context),
     Type::getInt8Ty(Context)
   };
 
   auto *FuncTy = FunctionType::get(Type::getVoidTy(Context), ArgsTy, false);
   // Pick a unique name to describe the input parameters
   Twine Name = "autogen_SD" + Twine{SeedCL};
-  auto *Func = Function::Create(FuncTy, GlobalValue::ExternalLinkage, Name, M);
+  auto *Func = Function::Create(FuncTy, GlobalValue::ExternalLinkage, Name, *M);
   Func->setCallingConv(CallingConv::C);
   return Func;
 }
 
 /// A base class, implementing utilities needed for
 /// modifying and adding new random instructions.
 struct Modifier {
   /// Used to store the randomly generated values.

unittests/Analysis/LazyCallGraphTest.cpp

TEST(LazyCallGraphTest, ReplaceNodeFunction) {
   EXPECT_EQ(&C2, CG.lookupSCC(BN));
   EXPECT_EQ(&RC1, CG.lookupRefSCC(DN));
   EXPECT_EQ(&RC1, CG.lookupRefSCC(CN));
   EXPECT_EQ(&RC1, CG.lookupRefSCC(BN));
   EXPECT_EQ(&RC2, CG.lookupRefSCC(AN));
 
   // Now we need to build a new function 'e' with the same signature as 'd'.
   Function &D = DN.getFunction();
-  Function &E = *Function::Create(D.getFunctionType(), D.getLinkage(), "e");
-  D.getParent()->getFunctionList().insert(D.getIterator(), &E);
+  Function &E = *Function::CreateBefore(D, D.getFunctionType(), D.getLinkage(), "e");
 
   // Change each use of 'd' to use 'e'. This is particularly easy as they have
   // the same type.
   D.replaceAllUsesWith(&E);
 
   // Splice the body of the old function into the new one.
   E.getBasicBlockList().splice(E.begin(), D.getBasicBlockList());
   // And fix up the one argument.

unittests/Analysis/MemoryBuiltinsTest.cpp

 // bytes exist at the pointer handed back by the function.
 TEST(AllocSize, AllocationBuiltinsTest) {
   LLVMContext Context;
   Module M("", Context);
   IntegerType *ArgTy = Type::getInt32Ty(Context);
 
   Function *AllocSizeFn = Function::Create(
       FunctionType::get(Type::getInt8PtrTy(Context), {ArgTy}, false),
-      GlobalValue::ExternalLinkage, "F", &M);
+      GlobalValue::ExternalLinkage, "F", M);
 
   AllocSizeFn->addFnAttr(Attribute::getWithAllocSizeArgs(Context, 1, None));
 
   // 100 is arbitrary.
   std::unique_ptr<CallInst> Caller(
       CallInst::Create(AllocSizeFn, {ConstantInt::get(ArgTy, 100)}));
 
   const TargetLibraryInfo *TLI = nullptr;

unittests/Analysis/MemorySSA.cpp

 };
 
 TEST_F(MemorySSATest, CreateALoad) {
   // We create a diamond where there is a store on one side, and then after
   // building MemorySSA, create a load after the merge point, and use it to test
   // updating by creating an access for the load.
   F = Function::Create(
       FunctionType::get(B.getVoidTy(), {B.getInt8PtrTy()}, false),
-      GlobalValue::ExternalLinkage, "F", &M);
+      GlobalValue::ExternalLinkage, "F", M);
   BasicBlock *Entry(BasicBlock::Create(C, "", F));
   BasicBlock *Left(BasicBlock::Create(C, "", F));
   BasicBlock *Right(BasicBlock::Create(C, "", F));
   BasicBlock *Merge(BasicBlock::Create(C, "", F));
   B.SetInsertPoint(Entry);
   B.CreateCondBr(B.getTrue(), Left, Right);
   B.SetInsertPoint(Left);
   Argument *PointerArg = &*F->arg_begin();

 }
 TEST_F(MemorySSATest, CreateLoadsAndStoreUpdater) {
   // We create a diamond, then build memoryssa with no memory accesses, and
   // incrementally update it by inserting a store in the, entry, a load in the
   // merge point, then a store in the branch, another load in the merge point,
   // and then a store in the entry.
   F = Function::Create(
       FunctionType::get(B.getVoidTy(), {B.getInt8PtrTy()}, false),
-      GlobalValue::ExternalLinkage, "F", &M);
+      GlobalValue::ExternalLinkage, "F", M);
   BasicBlock *Entry(BasicBlock::Create(C, "", F));
   BasicBlock *Left(BasicBlock::Create(C, "", F));
   BasicBlock *Right(BasicBlock::Create(C, "", F));
   BasicBlock *Merge(BasicBlock::Create(C, "", F));
   B.SetInsertPoint(Entry);
   B.CreateCondBr(B.getTrue(), Left, Right);
   B.SetInsertPoint(Left, Left->begin());
   Argument *PointerArg = &*F->arg_begin();

 }
 
 TEST_F(MemorySSATest, CreateALoadUpdater) {
   // We create a diamond, then build memoryssa with no memory accesses, and
   // incrementally update it by inserting a store in one of the branches, and a
   // load in the merge point
   F = Function::Create(
       FunctionType::get(B.getVoidTy(), {B.getInt8PtrTy()}, false),
-      GlobalValue::ExternalLinkage, "F", &M);
+      GlobalValue::ExternalLinkage, "F", M);
   BasicBlock *Entry(BasicBlock::Create(C, "", F));
   BasicBlock *Left(BasicBlock::Create(C, "", F));
   BasicBlock *Right(BasicBlock::Create(C, "", F));
   BasicBlock *Merge(BasicBlock::Create(C, "", F));
   B.SetInsertPoint(Entry);
   B.CreateCondBr(B.getTrue(), Left, Right);
   B.SetInsertPoint(Left, Left->begin());
   Argument *PointerArg = &*F->arg_begin();
TEST_F(MemorySSATest, CreateALoadUpdater) {
   MemoryAccess *DefiningAccess = LoadAccess->getDefiningAccess();
   EXPECT_TRUE(isa<MemoryPhi>(DefiningAccess));
   MSSA.verifyMemorySSA();
 }
 
 TEST_F(MemorySSATest, SinkLoad) {
   F = Function::Create(
       FunctionType::get(B.getVoidTy(), {B.getInt8PtrTy()}, false),
-      GlobalValue::ExternalLinkage, "F", &M);
+      GlobalValue::ExternalLinkage, "F", M);
   BasicBlock *Entry(BasicBlock::Create(C, "", F));
   BasicBlock *Left(BasicBlock::Create(C, "", F));
   BasicBlock *Right(BasicBlock::Create(C, "", F));
   BasicBlock *Merge(BasicBlock::Create(C, "", F));
   B.SetInsertPoint(Entry);
   B.CreateCondBr(B.getTrue(), Left, Right);
   B.SetInsertPoint(Left, Left->begin());
   Argument *PointerArg = &*F->arg_begin();

 
 TEST_F(MemorySSATest, MoveAStore) {
   // We create a diamond where there is a in the entry, a store on one side, and
   // a load at the end.  After building MemorySSA, we test updating by moving
   // the store from the side block to the entry block. This destroys the old
   // access.
   F = Function::Create(
       FunctionType::get(B.getVoidTy(), {B.getInt8PtrTy()}, false),
-      GlobalValue::ExternalLinkage, "F", &M);
+      GlobalValue::ExternalLinkage, "F", M);
   BasicBlock *Entry(BasicBlock::Create(C, "", F));
   BasicBlock *Left(BasicBlock::Create(C, "", F));
   BasicBlock *Right(BasicBlock::Create(C, "", F));
   BasicBlock *Merge(BasicBlock::Create(C, "", F));
   B.SetInsertPoint(Entry);
   Argument *PointerArg = &*F->arg_begin();
   StoreInst *EntryStore = B.CreateStore(B.getInt8(16), PointerArg);
   B.CreateCondBr(B.getTrue(), Left, Right);

 
 TEST_F(MemorySSATest, MoveAStoreUpdater) {
   // We create a diamond where there is a in the entry, a store on one side, and
   // a load at the end.  After building MemorySSA, we test updating by moving
   // the store from the side block to the entry block.  This destroys the old
   // access.
   F = Function::Create(
       FunctionType::get(B.getVoidTy(), {B.getInt8PtrTy()}, false),
-      GlobalValue::ExternalLinkage, "F", &M);
+      GlobalValue::ExternalLinkage, "F", M);
   BasicBlock *Entry(BasicBlock::Create(C, "", F));
   BasicBlock *Left(BasicBlock::Create(C, "", F));
   BasicBlock *Right(BasicBlock::Create(C, "", F));
   BasicBlock *Merge(BasicBlock::Create(C, "", F));
   B.SetInsertPoint(Entry);
   Argument *PointerArg = &*F->arg_begin();
   StoreInst *EntryStore = B.CreateStore(B.getInt8(16), PointerArg);
   B.CreateCondBr(B.getTrue(), Left, Right);

 
 TEST_F(MemorySSATest, MoveAStoreUpdaterMove) {
   // We create a diamond where there is a in the entry, a store on one side, and
   // a load at the end.  After building MemorySSA, we test updating by moving
   // the store from the side block to the entry block.  This does not destroy
   // the old access.
   F = Function::Create(
       FunctionType::get(B.getVoidTy(), {B.getInt8PtrTy()}, false),
-      GlobalValue::ExternalLinkage, "F", &M);
+      GlobalValue::ExternalLinkage, "F", M);
   BasicBlock *Entry(BasicBlock::Create(C, "", F));
   BasicBlock *Left(BasicBlock::Create(C, "", F));
   BasicBlock *Right(BasicBlock::Create(C, "", F));
   BasicBlock *Merge(BasicBlock::Create(C, "", F));
   B.SetInsertPoint(Entry);
   Argument *PointerArg = &*F->arg_begin();
   StoreInst *EntryStore = B.CreateStore(B.getInt8(16), PointerArg);
   B.CreateCondBr(B.getTrue(), Left, Right);

 
 TEST_F(MemorySSATest, MoveAStoreAllAround) {
   // We create a diamond where there is a in the entry, a store on one side, and
   // a load at the end.  After building MemorySSA, we test updating by moving
   // the store from the side block to the entry block, then to the other side
   // block, then to before the load.  This does not destroy the old access.
   F = Function::Create(
       FunctionType::get(B.getVoidTy(), {B.getInt8PtrTy()}, false),
-      GlobalValue::ExternalLinkage, "F", &M);
+      GlobalValue::ExternalLinkage, "F", M);
   BasicBlock *Entry(BasicBlock::Create(C, "", F));
   BasicBlock *Left(BasicBlock::Create(C, "", F));
   BasicBlock *Right(BasicBlock::Create(C, "", F));
   BasicBlock *Merge(BasicBlock::Create(C, "", F));
   B.SetInsertPoint(Entry);
   Argument *PointerArg = &*F->arg_begin();
   StoreInst *EntryStore = B.CreateStore(B.getInt8(16), PointerArg);
   B.CreateCondBr(B.getTrue(), Left, Right);

 }
 
 TEST_F(MemorySSATest, RemoveAPhi) {
   // We create a diamond where there is a store on one side, and then a load
   // after the merge point.  This enables us to test a bunch of different
   // removal cases.
   F = Function::Create(
       FunctionType::get(B.getVoidTy(), {B.getInt8PtrTy()}, false),
-      GlobalValue::ExternalLinkage, "F", &M);
+      GlobalValue::ExternalLinkage, "F", M);
   BasicBlock *Entry(BasicBlock::Create(C, "", F));
   BasicBlock *Left(BasicBlock::Create(C, "", F));
   BasicBlock *Right(BasicBlock::Create(C, "", F));
   BasicBlock *Merge(BasicBlock::Create(C, "", F));
   B.SetInsertPoint(Entry);
   B.CreateCondBr(B.getTrue(), Left, Right);
   B.SetInsertPoint(Left);
   Argument *PointerArg = &*F->arg_begin();

 }
 
 TEST_F(MemorySSATest, RemoveMemoryAccess) {
   // We create a diamond where there is a store on one side, and then a load
   // after the merge point.  This enables us to test a bunch of different
   // removal cases.
   F = Function::Create(
       FunctionType::get(B.getVoidTy(), {B.getInt8PtrTy()}, false),
-      GlobalValue::ExternalLinkage, "F", &M);
+      GlobalValue::ExternalLinkage, "F", M);
   BasicBlock *Entry(BasicBlock::Create(C, "", F));
   BasicBlock *Left(BasicBlock::Create(C, "", F));
   BasicBlock *Right(BasicBlock::Create(C, "", F));
   BasicBlock *Merge(BasicBlock::Create(C, "", F));
   B.SetInsertPoint(Entry);
   B.CreateCondBr(B.getTrue(), Left, Right);
   B.SetInsertPoint(Left);
   Argument *PointerArg = &*F->arg_begin();

 //   store i8 0, i8* %A
 // ; 2 = MemoryDef(1)
 //   store i8 1, i8* %A
 // ; 3 = MemoryDef(2)
 //   store i8 2, i8* %A
 // }
 TEST_F(MemorySSATest, TestTripleStore) {
   F = Function::Create(FunctionType::get(B.getVoidTy(), {}, false),
-                       GlobalValue::ExternalLinkage, "F", &M);
+                       GlobalValue::ExternalLinkage, "F", M);
   B.SetInsertPoint(BasicBlock::Create(C, "", F));
   Type *Int8 = Type::getInt8Ty(C);
   Value *Alloca = B.CreateAlloca(Int8, ConstantInt::get(Int8, 1), "A");
   StoreInst *S1 = B.CreateStore(ConstantInt::get(Int8, 0), Alloca);
   StoreInst *S2 = B.CreateStore(ConstantInt::get(Int8, 1), Alloca);
   StoreInst *S3 = B.CreateStore(ConstantInt::get(Int8, 2), Alloca);
 
   setupAnalyses();

 }
 
 // ...And fixing the above bug made it obvious that, when walking, MemorySSA's
 // walker was caching the initial node it walked. This was fine (albeit
 // mostly redundant) unless the initial node being walked is a clobber for the
 // query. In that case, we'd cache that the node clobbered itself.
 TEST_F(MemorySSATest, TestStoreAndLoad) {
   F = Function::Create(FunctionType::get(B.getVoidTy(), {}, false),
-                       GlobalValue::ExternalLinkage, "F", &M);
+                       GlobalValue::ExternalLinkage, "F", M);
   B.SetInsertPoint(BasicBlock::Create(C, "", F));
   Type *Int8 = Type::getInt8Ty(C);
   Value *Alloca = B.CreateAlloca(Int8, ConstantInt::get(Int8, 1), "A");
   Instruction *SI = B.CreateStore(ConstantInt::get(Int8, 0), Alloca);
   Instruction *LI = B.CreateLoad(Alloca);
 
   setupAnalyses();
   MemorySSA &MSSA = *Analyses->MSSA;

 // hand back the store (correctly). A later call to
 // getClobberingMemoryAccess(const Instruction*) would also hand back the store
 // (incorrectly; it should return liveOnEntry).
 //
 // This test checks that repeated calls to either function returns what they're
 // meant to.
 TEST_F(MemorySSATest, TestStoreDoubleQuery) {
   F = Function::Create(FunctionType::get(B.getVoidTy(), {}, false),
-                       GlobalValue::ExternalLinkage, "F", &M);
+                       GlobalValue::ExternalLinkage, "F", M);
   B.SetInsertPoint(BasicBlock::Create(C, "", F));
   Type *Int8 = Type::getInt8Ty(C);
   Value *Alloca = B.CreateAlloca(Int8, ConstantInt::get(Int8, 1), "A");
   StoreInst *SI = B.CreateStore(ConstantInt::get(Int8, 0), Alloca);
 
   setupAnalyses();
   MemorySSA &MSSA = *Analyses->MSSA;
   MemorySSAWalker *Walker = Analyses->Walker;

 //   \ /
 //    C
 //
 // Where, when we try to optimize a thing in 'C', a blocker is found in 'B'.
 // The walk must determine that the blocker exists by using cache entries *while
 // walking* 'B'.
 TEST_F(MemorySSATest, PartialWalkerCacheWithPhis) {
   F = Function::Create(FunctionType::get(B.getVoidTy(), {}, false),
-                       GlobalValue::ExternalLinkage, "F", &M);
+                       GlobalValue::ExternalLinkage, "F", M);
   B.SetInsertPoint(BasicBlock::Create(C, "A", F));
   Type *Int8 = Type::getInt8Ty(C);
   Constant *One = ConstantInt::get(Int8, 1);
   Constant *Zero = ConstantInt::get(Int8, 0);
   Value *AllocA = B.CreateAlloca(Int8, One, "a");
   Value *AllocB = B.CreateAlloca(Int8, One, "b");
   BasicBlock *IfThen = BasicBlock::Create(C, "B", F);
   BasicBlock *IfEnd = BasicBlock::Create(C, "C", F);

 
 // Test that our walker properly handles loads with the invariant group
 // attribute. It's a bit hacky, since we add the invariant attribute *after*
 // building MSSA. Otherwise, the use optimizer will optimize it for us, which
 // isn't what we want.
 // FIXME: It may be easier/cleaner to just add an 'optimize uses?' flag to MSSA.
 TEST_F(MemorySSATest, WalkerInvariantLoadOpt) {
   F = Function::Create(FunctionType::get(B.getVoidTy(), {}, false),
-                       GlobalValue::ExternalLinkage, "F", &M);
+                       GlobalValue::ExternalLinkage, "F", M);
   B.SetInsertPoint(BasicBlock::Create(C, "", F));
   Type *Int8 = Type::getInt8Ty(C);
   Constant *One = ConstantInt::get(Int8, 1);
   Value *AllocA = B.CreateAlloca(Int8, One, "");
 
   Instruction *Store = B.CreateStore(One, AllocA);
   Instruction *Load = B.CreateLoad(AllocA);
 
TEST_F(MemorySSATest, WalkerInvariantLoadOpt) {
 
   MemoryAccess *LoadClobber = Walker->getClobberingMemoryAccess(LoadMA);
   EXPECT_EQ(LoadClobber, MSSA.getLiveOnEntryDef());
 }
 
 // Test loads get reoptimized properly by the walker.
 TEST_F(MemorySSATest, WalkerReopt) {
   F = Function::Create(FunctionType::get(B.getVoidTy(), {}, false),
-                       GlobalValue::ExternalLinkage, "F", &M);
+                       GlobalValue::ExternalLinkage, "F", M);
   B.SetInsertPoint(BasicBlock::Create(C, "", F));
   Type *Int8 = Type::getInt8Ty(C);
   Value *AllocaA = B.CreateAlloca(Int8, ConstantInt::get(Int8, 1), "A");
   Instruction *SIA = B.CreateStore(ConstantInt::get(Int8, 0), AllocaA);
   Value *AllocaB = B.CreateAlloca(Int8, ConstantInt::get(Int8, 1), "B");
   Instruction *SIB = B.CreateStore(ConstantInt::get(Int8, 0), AllocaB);
   Instruction *LIA = B.CreateLoad(AllocaA);
 
TEST_F(MemorySSATest, WalkerReopt) {
   // This should it cause it to be optimized
   EXPECT_EQ(Walker->getClobberingMemoryAccess(NewLoadAccess), LoadClobber);
   EXPECT_EQ(NewLoadAccess->getDefiningAccess(), LoadClobber);
 }
 
 // Test out MemorySSAUpdater::moveBefore
 TEST_F(MemorySSATest, MoveAboveMemoryDef) {
   F = Function::Create(FunctionType::get(B.getVoidTy(), {}, false),
-                       GlobalValue::ExternalLinkage, "F", &M);
+                       GlobalValue::ExternalLinkage, "F", M);
   B.SetInsertPoint(BasicBlock::Create(C, "", F));
 
   Type *Int8 = Type::getInt8Ty(C);
   Value *A = B.CreateAlloca(Int8, ConstantInt::get(Int8, 1), "A");
   Value *B_ = B.CreateAlloca(Int8, ConstantInt::get(Int8, 1), "B");
   Value *C = B.CreateAlloca(Int8, ConstantInt::get(Int8, 1), "C");
 
   StoreInst *StoreA0 = B.CreateStore(ConstantInt::get(Int8, 0), A);
TEST_F(MemorySSATest, Irreducible) {
   // second_loop_entry:
   // }
   // use(x)
 
   SmallVector<PHINode *, 8> Inserted;
   IRBuilder<> B(C);
   F = Function::Create(
       FunctionType::get(B.getVoidTy(), {B.getInt8PtrTy()}, false),
-      GlobalValue::ExternalLinkage, "F", &M);
+      GlobalValue::ExternalLinkage, "F", M);
 
   // Make blocks
   BasicBlock *IfBB = BasicBlock::Create(C, "if", F);
   BasicBlock *LoopStartBB = BasicBlock::Create(C, "loopstart", F);
   BasicBlock *LoopMainBB = BasicBlock::Create(C, "loopmain", F);
   BasicBlock *AfterLoopBB = BasicBlock::Create(C, "afterloop", F);
   B.SetInsertPoint(IfBB);
   B.CreateCondBr(B.getTrue(), LoopMainBB, LoopStartBB);

unittests/Analysis/SparsePropagation.cpp

 /// }
 ///
 /// For this test, we initially mark "f" executable, and the solver discovers
 /// "g" because of the call in "f". The mutually recursive call in "g" also
 /// tests that we don't add a block to the basic block work list if it is
 /// already executable. Doing so would put the solver into an infinite loop.
 TEST_F(SparsePropagationTest, MarkBlockExecutable) {
   Function *F = Function::Create(FunctionType::get(Builder.getVoidTy(), false),
-                                 GlobalValue::InternalLinkage, "f", &M);
+                                 GlobalValue::InternalLinkage, "f", M);
   Function *G = Function::Create(FunctionType::get(Builder.getVoidTy(), false),
-                                 GlobalValue::InternalLinkage, "g", &M);
+                                 GlobalValue::InternalLinkage, "g", M);
   BasicBlock *FEntry = BasicBlock::Create(Context, "", F);
   BasicBlock *GEntry = BasicBlock::Create(Context, "", G);
   Builder.SetInsertPoint(FEntry);
   Builder.CreateCall(G);
   Builder.CreateRetVoid();
   Builder.SetInsertPoint(GEntry);
   Builder.CreateCall(F);
   Builder.CreateRetVoid();

 ///   store i64 1, i64* @gv
 ///   ret void
 /// }
 ///
 /// For this test, we initially mark both "f" and "g" executable, and the
 /// solver computes the lattice state of the global variable as constant.
 TEST_F(SparsePropagationTest, GlobalVariableConstant) {
   Function *F = Function::Create(FunctionType::get(Builder.getVoidTy(), false),
-                                 GlobalValue::InternalLinkage, "f", &M);
+                                 GlobalValue::InternalLinkage, "f", M);
   Function *G = Function::Create(FunctionType::get(Builder.getVoidTy(), false),
-                                 GlobalValue::InternalLinkage, "g", &M);
+                                 GlobalValue::InternalLinkage, "g", M);
   GlobalVariable *GV =
       new GlobalVariable(M, Builder.getInt64Ty(), false,
                          GlobalValue::InternalLinkage, nullptr, "gv");
   BasicBlock *FEntry = BasicBlock::Create(Context, "", F);
   BasicBlock *GEntry = BasicBlock::Create(Context, "", G);
   Builder.SetInsertPoint(FEntry);
   Builder.CreateStore(Builder.getInt64(1), GV);
   Builder.CreateRetVoid();

 ///   store i64 1, i64* @gv
 ///   ret void
 /// }
 ///
 /// For this test, we initially mark both "f" and "g" executable, and the
 /// solver computes the lattice state of the global variable as overdefined.
 TEST_F(SparsePropagationTest, GlobalVariableOverDefined) {
   Function *F = Function::Create(FunctionType::get(Builder.getVoidTy(), false),
-                                 GlobalValue::InternalLinkage, "f", &M);
+                                 GlobalValue::InternalLinkage, "f", M);
   Function *G = Function::Create(FunctionType::get(Builder.getVoidTy(), false),
-                                 GlobalValue::InternalLinkage, "g", &M);
+                                 GlobalValue::InternalLinkage, "g", M);
   GlobalVariable *GV =
       new GlobalVariable(M, Builder.getInt64Ty(), false,
                          GlobalValue::InternalLinkage, nullptr, "gv");
   BasicBlock *FEntry = BasicBlock::Create(Context, "", F);
   BasicBlock *GEntry = BasicBlock::Create(Context, "", G);
   Builder.SetInsertPoint(FEntry);
   Builder.CreateStore(Builder.getInt64(0), GV);
   Builder.CreateRetVoid();

 /// }
 ///
 /// For this test, we initially mark "f" executable, and the solver computes
 /// the return value of the function as constant.
 TEST_F(SparsePropagationTest, FunctionDefined) {
   Function *F =
       Function::Create(FunctionType::get(Builder.getInt64Ty(),
                                          {Type::getInt1PtrTy(Context)}, false),
-                       GlobalValue::InternalLinkage, "f", &M);
+                       GlobalValue::InternalLinkage, "f", M);
   BasicBlock *If = BasicBlock::Create(Context, "if", F);
   BasicBlock *Then = BasicBlock::Create(Context, "then", F);
   BasicBlock *Else = BasicBlock::Create(Context, "else", F);
   F->arg_begin()->setName("cond");
   Builder.SetInsertPoint(If);
   LoadInst *Cond = Builder.CreateLoad(F->arg_begin());
   Builder.CreateCondBr(Cond, Then, Else);
   Builder.SetInsertPoint(Then);

 /// }
 ///
 /// For this test, we initially mark "f" executable, and the solver computes
 /// the return value of the function as overdefined.
 TEST_F(SparsePropagationTest, FunctionOverDefined) {
   Function *F =
       Function::Create(FunctionType::get(Builder.getInt64Ty(),
                                          {Type::getInt1PtrTy(Context)}, false),
-                       GlobalValue::InternalLinkage, "f", &M);
+                       GlobalValue::InternalLinkage, "f", M);
   BasicBlock *If = BasicBlock::Create(Context, "if", F);
   BasicBlock *Then = BasicBlock::Create(Context, "then", F);
   BasicBlock *Else = BasicBlock::Create(Context, "else", F);
   F->arg_begin()->setName("cond");
   Builder.SetInsertPoint(If);
   LoadInst *Cond = Builder.CreateLoad(F->arg_begin());
   Builder.CreateCondBr(Cond, Then, Else);
   Builder.SetInsertPoint(Then);

 /// "a" as overdefined and the state of "b" as constant.
 ///
 /// In addition, this test demonstrates that ComputeInstructionState can alter
 /// the state of multiple lattice values, in addition to the one associated
 /// with the instruction definition. Each call instruction in this test updates
 /// the state of arguments "a" and "b".
 TEST_F(SparsePropagationTest, ComputeInstructionState) {
   Function *F = Function::Create(FunctionType::get(Builder.getVoidTy(), false),
-                                 GlobalValue::InternalLinkage, "f", &M);
+                                 GlobalValue::InternalLinkage, "f", M);
   Function *G = Function::Create(
       FunctionType::get(Builder.getVoidTy(),
                         {Builder.getInt64Ty(), Builder.getInt64Ty()}, false),
-      GlobalValue::InternalLinkage, "g", &M);
+      GlobalValue::InternalLinkage, "g", M);
   Argument *A = G->arg_begin();
   Argument *B = std::next(G->arg_begin());
   A->setName("a");
   B->setName("b");
   BasicBlock *FEntry = BasicBlock::Create(Context, "", F);
   BasicBlock *GEntry = BasicBlock::Create(Context, "", G);
   Builder.SetInsertPoint(FEntry);
   Builder.CreateCall(G, {Builder.getInt64(0), Builder.getInt64(1)});

 /// exit:
 ///   ret void
 /// }
 ///
 /// For this test, we initially mark the entry block executable. The solver
 /// then discovers the rest of the blocks in the function are executable.
 TEST_F(SparsePropagationTest, ExceptionalTerminatorInsts) {
   Function *P = Function::Create(FunctionType::get(Builder.getVoidTy(), false),
-                                 GlobalValue::InternalLinkage, "p", &M);
+                                 GlobalValue::InternalLinkage, "p", M);
   Function *G = Function::Create(FunctionType::get(Builder.getVoidTy(), false),
-                                 GlobalValue::InternalLinkage, "g", &M);
+                                 GlobalValue::InternalLinkage, "g", M);
   Function *F = Function::Create(FunctionType::get(Builder.getVoidTy(), false),
-                                 GlobalValue::InternalLinkage, "f", &M);
+                                 GlobalValue::InternalLinkage, "f", M);
   Constant *C =
       ConstantExpr::getCast(Instruction::BitCast, P, Builder.getInt8PtrTy());
   F->setPersonalityFn(C);
   BasicBlock *Entry = BasicBlock::Create(Context, "entry", F);
   BasicBlock *Pad = BasicBlock::Create(Context, "catch.pad", F);
   BasicBlock *Body = BasicBlock::Create(Context, "catch.body", F);
   BasicBlock *Exit = BasicBlock::Create(Context, "exit", F);
   Builder.SetInsertPoint(Entry);

unittests/CodeGen/MachineInstrTest.cpp

 std::unique_ptr<BogusTargetMachine> createTargetMachine() {
   return llvm::make_unique<BogusTargetMachine>();
 }
 
 std::unique_ptr<MachineFunction> createMachineFunction() {
   LLVMContext Ctx;
   Module M("Module", Ctx);
   auto Type = FunctionType::get(Type::getVoidTy(Ctx), false);
-  auto F = Function::Create(Type, GlobalValue::ExternalLinkage, "Test", &M);
+  auto F = Function::Create(Type, GlobalValue::ExternalLinkage, "Test", M);
 
   auto TM = createTargetMachine();
   unsigned FunctionNum = 42;
   MachineModuleInfo MMI(TM.get());
   const TargetSubtargetInfo &STI = *TM->getSubtargetImpl(*F);
 
   return llvm::make_unique<MachineFunction>(*F, *TM, STI, FunctionNum, MMI);
 }

unittests/ExecutionEngine/MCJIT/MCJITTestBase.h

Module *createEmptyModule(StringRef Name = StringRef()) {
     M->setTargetTriple(Triple::normalize(BuilderTriple));
     return M;
   }
 
   template<typename FuncType>
   Function *startFunction(Module *M, StringRef Name) {
     Function *Result = Function::Create(
       TypeBuilder<FuncType, false>::get(Context),
-      GlobalValue::ExternalLinkage, Name, M);
+      GlobalValue::ExternalLinkage, Name, *M);
 
     BasicBlock *BB = BasicBlock::Create(Context, Name, Result);
     Builder.SetInsertPoint(BB);
 
     return Result;
   }
 
   void endFunctionWithRet(Function *Func, Value *RetValue) {
Function *insertAddFunction(Module *M, StringRef Name = "add") {
     return Result;
   }
 
   // Inserts a declaration to a function defined elsewhere
   template <typename FuncType>
   Function *insertExternalReferenceToFunction(Module *M, StringRef Name) {
     Function *Result = Function::Create(
                          TypeBuilder<FuncType, false>::get(Context),
-                         GlobalValue::ExternalLinkage, Name, M);
+                         GlobalValue::ExternalLinkage, Name, *M);
     return Result;
   }
 
   // Inserts an declaration to a function defined elsewhere
   Function *insertExternalReferenceToFunction(Module *M, StringRef Name,
                                               FunctionType *FuncTy) {
     Function *Result = Function::Create(FuncTy,
                                         GlobalValue::ExternalLinkage,
-                                        Name, M);
+                                        Name, *M);
     return Result;
   }
 
   // Inserts an declaration to a function defined elsewhere
   Function *insertExternalReferenceToFunction(Module *M, Function *Func) {
     Function *Result = Function::Create(Func->getFunctionType(),
                                         GlobalValue::ExternalLinkage,
-                                        Func->getName(), M);
+                                        Func->getName(), *M);
     return Result;
   }
 
   // Inserts a global variable of type int32
   // FIXME: make this a template function to support any type
   GlobalVariable *insertGlobalInt32(Module *M,
                                     StringRef name,
                                     int32_t InitialValue) {

unittests/ExecutionEngine/Orc/OrcTestCommon.h

 public:
   ModuleBuilder(LLVMContext &Context, StringRef Triple,
                 StringRef Name);
 
   template <typename FuncType>
   Function* createFunctionDecl(StringRef Name) {
     return Function::Create(
              TypeBuilder<FuncType, false>::get(M->getContext()),
-             GlobalValue::ExternalLinkage, Name, M.get());
+             GlobalValue::ExternalLinkage, Name, *M.get());
   }
 
   Module* getModule() { return M.get(); }
   const Module* getModule() const { return M.get(); }
   std::unique_ptr<Module> takeModule() { return std::move(M); }
 
 private:
   std::unique_ptr<Module> M;

unittests/FuzzMutate/OperationsTest.cpp

 }
 
 TEST(OperationsTest, SplitBlock) {
   LLVMContext Ctx;
 
   Module M("M", Ctx);
   Function *F = Function::Create(FunctionType::get(Type::getVoidTy(Ctx), {},
                                                    /*isVarArg=*/false),
-                                 GlobalValue::ExternalLinkage, "f", &M);
+                                 GlobalValue::ExternalLinkage, "f", M);
   auto SBOp = fuzzerop::splitBlockDescriptor(1);
 
   // Create a block with only a return and split it on the return.
   auto *BB = BasicBlock::Create(Ctx, "BB", F);
   auto *RI = ReturnInst::Create(Ctx, BB);
   SBOp.BuilderFunc({UndefValue::get(Type::getInt1Ty(Ctx))}, RI);
 
   // We should end up with an unconditional branch from BB to BB1, and the

 TEST(OperationsTest, SplitBlockWithPhis) {
   LLVMContext Ctx;
 
   Type *Int8Ty = Type::getInt8Ty(Ctx);
 
   Module M("M", Ctx);
   Function *F = Function::Create(FunctionType::get(Type::getVoidTy(Ctx), {},
                                                    /*isVarArg=*/false),
-                                 GlobalValue::ExternalLinkage, "f", &M);
+                                 GlobalValue::ExternalLinkage, "f", M);
   auto SBOp = fuzzerop::splitBlockDescriptor(1);
 
   // Create 3 blocks with an if-then branch.
   auto *BB1 = BasicBlock::Create(Ctx, "BB1", F);
   auto *BB2 = BasicBlock::Create(Ctx, "BB2", F);
   auto *BB3 = BasicBlock::Create(Ctx, "BB3", F);
   BranchInst::Create(BB2, BB3, ConstantInt::getFalse(Ctx), BB1);
   BranchInst::Create(BB3, BB2);
TEST(OperationsTest, GEP) {
   LLVMContext Ctx;
 
   Type *Int8PtrTy = Type::getInt8PtrTy(Ctx);
   Type *Int32Ty = Type::getInt32Ty(Ctx);
 
   Module M("M", Ctx);
   Function *F = Function::Create(FunctionType::get(Type::getVoidTy(Ctx), {},
                                                    /*isVarArg=*/false),
-                                 GlobalValue::ExternalLinkage, "f", &M);
+                                 GlobalValue::ExternalLinkage, "f", M);
   auto *BB = BasicBlock::Create(Ctx, "BB", F);
   auto *RI = ReturnInst::Create(Ctx, BB);
 
   auto GEPOp = fuzzerop::gepDescriptor(1);
   EXPECT_TRUE(GEPOp.SourcePreds[0].matches({}, UndefValue::get(Int8PtrTy)));
   EXPECT_TRUE(GEPOp.SourcePreds[1].matches({UndefValue::get(Int8PtrTy)},
                                            ConstantInt::get(Int32Ty, 0)));
 

unittests/IR/FunctionTest.cpp

 TEST(FunctionTest, hasLazyArguments) {
   LLVMContext C;
 
   Type *ArgTypes[] = {Type::getInt8Ty(C), Type::getInt32Ty(C)};
   FunctionType *FTy = FunctionType::get(Type::getVoidTy(C), ArgTypes, false);
 
   // Functions start out with lazy arguments.
   std::unique_ptr<Function> F(
-      Function::Create(FTy, GlobalValue::ExternalLinkage, "F"));
+     Function::Create(FTy, GlobalValue::ExternalLinkage, /*AddrSpace=*/0, "F"));
   EXPECT_TRUE(F->hasLazyArguments());
 
   // Checking for empty or size shouldn't force arguments to be instantiated.
   EXPECT_FALSE(F->arg_empty());
   EXPECT_TRUE(F->hasLazyArguments());
   EXPECT_EQ(2u, F->arg_size());
   EXPECT_TRUE(F->hasLazyArguments());
 
   // The argument list should be populated at first access.
   (void)F->arg_begin();
   EXPECT_FALSE(F->hasLazyArguments());
 }
 
 TEST(FunctionTest, stealArgumentListFrom) {
   LLVMContext C;
 
   Type *ArgTypes[] = {Type::getInt8Ty(C), Type::getInt32Ty(C)};
   FunctionType *FTy = FunctionType::get(Type::getVoidTy(C), ArgTypes, false);
   std::unique_ptr<Function> F1(
-      Function::Create(FTy, GlobalValue::ExternalLinkage, "F1"));
+    Function::Create(FTy, GlobalValue::ExternalLinkage, /*AddrSpace=*/0, "F1"));
   std::unique_ptr<Function> F2(
-      Function::Create(FTy, GlobalValue::ExternalLinkage, "F1"));
+    Function::Create(FTy, GlobalValue::ExternalLinkage, /*AddrSpace=*/0, "F1"));
   EXPECT_TRUE(F1->hasLazyArguments());
   EXPECT_TRUE(F2->hasLazyArguments());
 
   // Steal arguments before they've been accessed.  Nothing should change; both
   // functions should still have lazy arguments.
   //
   //   steal(empty); drop (empty)
   F1->stealArgumentListFrom(*F2);

 
 // Test setting and removing section information
 TEST(FunctionTest, setSection) {
   LLVMContext C;
   Module M("test", C);
 
   llvm::Function *F =
       Function::Create(llvm::FunctionType::get(llvm::Type::getVoidTy(C), false),
-                       llvm::GlobalValue::ExternalLinkage, "F", &M);
+                       llvm::GlobalValue::ExternalLinkage, "F", M);
 
   F->setSection(".text.test");
   EXPECT_TRUE(F->getSection() == ".text.test");
   EXPECT_TRUE(F->hasSection());
   F->setSection("");
   EXPECT_FALSE(F->hasSection());
   F->setSection(".text.test");
   F->setSection(".text.test2");
   EXPECT_TRUE(F->getSection() == ".text.test2");
   EXPECT_TRUE(F->hasSection());
 }
 
 } // end namespace

unittests/IR/IRBuilderTest.cpp

 namespace {
 
 class IRBuilderTest : public testing::Test {
 protected:
   void SetUp() override {
     M.reset(new Module("MyModule", Ctx));
     FunctionType *FTy = FunctionType::get(Type::getVoidTy(Ctx),
                                           /*isVarArg=*/false);
-    F = Function::Create(FTy, Function::ExternalLinkage, "", M.get());
+    F = Function::Create(FTy, Function::ExternalLinkage, "", *M.get());
     BB = BasicBlock::Create(Ctx, "", F);
     GV = new GlobalVariable(*M, Type::getFloatTy(Ctx), true,
                             GlobalValue::ExternalLinkage, nullptr);
   }
 
   void TearDown() override {
     BB = nullptr;
     M.reset();
TEST_F(IRBuilderTest, FastMathFlags) {
   EXPECT_TRUE(FAdd->hasApproxFunc());
   EXPECT_TRUE(FAdd->hasAllowContract());
   EXPECT_TRUE(FAdd->hasAllowReassoc());
 
   // Test a call with FMF.
   auto CalleeTy = FunctionType::get(Type::getFloatTy(Ctx),
                                     /*isVarArg=*/false);
   auto Callee =
-      Function::Create(CalleeTy, Function::ExternalLinkage, "", M.get());
+      Function::Create(CalleeTy, Function::ExternalLinkage, "", *M.get());
 
   FCall = Builder.CreateCall(Callee, None);
   EXPECT_FALSE(FCall->hasNoNaNs());
 
   Value *V = 
-      Function::Create(CalleeTy, Function::ExternalLinkage, "", M.get());
+      Function::Create(CalleeTy, Function::ExternalLinkage, "", *M.get());
   FCall = Builder.CreateCall(V, None);
   EXPECT_FALSE(FCall->hasNoNaNs());
 
   FMF.clear();
   FMF.setNoNaNs();
   Builder.setFastMathFlags(FMF);
 
   FCall = Builder.CreateCall(Callee, None);
TEST_F(IRBuilderTest, CreateGlobalStringPtr) {
   EXPECT_TRUE(String2->getType()->getPointerAddressSpace() == 1);
   EXPECT_TRUE(String3->getType()->getPointerAddressSpace() == 2);
 }
 
 TEST_F(IRBuilderTest, DebugLoc) {
   auto CalleeTy = FunctionType::get(Type::getVoidTy(Ctx),
                                     /*isVarArg=*/false);
   auto Callee =
-      Function::Create(CalleeTy, Function::ExternalLinkage, "", M.get());
+      Function::Create(CalleeTy, Function::ExternalLinkage, "", *M.get());
 
   DIBuilder DIB(*M);
   auto File = DIB.createFile("tmp.cpp", "/");
   auto CU = DIB.createCompileUnit(dwarf::DW_LANG_C_plus_plus_11,
                                   DIB.createFile("tmp.cpp", "/"), "", true, "",
                                   0);
   auto SPType = DIB.createSubroutineType(DIB.getOrCreateTypeArray(None));
   auto SP =

unittests/IR/InstructionsTest.cpp

 class ModuleWithFunctionTest : public testing::Test {
 protected:
   ModuleWithFunctionTest() : M(new Module("MyModule", Ctx)) {
     FArgTypes.push_back(Type::getInt8Ty(Ctx));
     FArgTypes.push_back(Type::getInt32Ty(Ctx));
     FArgTypes.push_back(Type::getInt64Ty(Ctx));
     FunctionType *FTy =
         FunctionType::get(Type::getVoidTy(Ctx), FArgTypes, false);
-    F = Function::Create(FTy, Function::ExternalLinkage, "", M.get());
+    F = Function::Create(FTy, Function::ExternalLinkage, "", *M.get());
   }
 
   LLVMContext Ctx;
   std::unique_ptr<Module> M;
   SmallVector<Type *, 3> FArgTypes;
   Function *F;
 };
 

unittests/IR/LegacyPassManagerTest.cpp

Module *makeLLVMModule(LLVMContext &Context) {
           /*Params=*/FuncTy_2_args,
           /*isVarArg=*/false);
 
       // Function Declarations
 
       Function* func_test1 = Function::Create(
         /*Type=*/FuncTy_0,
         /*Linkage=*/GlobalValue::ExternalLinkage,
-        /*Name=*/"test1", mod);
+        /*Name=*/"test1", *mod);
       func_test1->setCallingConv(CallingConv::C);
       AttributeList func_test1_PAL;
       func_test1->setAttributes(func_test1_PAL);
 
       Function* func_test2 = Function::Create(
         /*Type=*/FuncTy_0,
         /*Linkage=*/GlobalValue::ExternalLinkage,
-        /*Name=*/"test2", mod);
+        /*Name=*/"test2", *mod);
       func_test2->setCallingConv(CallingConv::C);
       AttributeList func_test2_PAL;
       func_test2->setAttributes(func_test2_PAL);
 
       Function* func_test3 = Function::Create(
         /*Type=*/FuncTy_0,
         /*Linkage=*/GlobalValue::ExternalLinkage,
-        /*Name=*/"test3", mod);
+        /*Name=*/"test3", *mod);
       func_test3->setCallingConv(CallingConv::C);
       AttributeList func_test3_PAL;
       func_test3->setAttributes(func_test3_PAL);
 
       Function* func_test4 = Function::Create(
         /*Type=*/FuncTy_2,
         /*Linkage=*/GlobalValue::ExternalLinkage,
-        /*Name=*/"test4", mod);
+        /*Name=*/"test4", *mod);
       func_test4->setCallingConv(CallingConv::C);
       AttributeList func_test4_PAL;
       func_test4->setAttributes(func_test4_PAL);
 
       // Global Variable Declarations
 
 
       // Constant Definitions

unittests/IR/MetadataTest.cpp

TEST_F(MDNodeTest, PrintFromModule) {
   }
 
   EXPECT_PRINTER_EQ(Expected, N->print(OS, &M));
 }
 
 TEST_F(MDNodeTest, PrintFromFunction) {
   Module M("test", Context);
   auto *FTy = FunctionType::get(Type::getVoidTy(Context), false);
-  auto *F0 = Function::Create(FTy, GlobalValue::ExternalLinkage, "F0", &M);
-  auto *F1 = Function::Create(FTy, GlobalValue::ExternalLinkage, "F1", &M);
+  auto *F0 = Function::Create(FTy, GlobalValue::ExternalLinkage, "F0", M);
+  auto *F1 = Function::Create(FTy, GlobalValue::ExternalLinkage, "F1", M);
   auto *BB0 = BasicBlock::Create(Context, "entry", F0);
   auto *BB1 = BasicBlock::Create(Context, "entry", F1);
   auto *R0 = ReturnInst::Create(Context, BB0);
   auto *R1 = ReturnInst::Create(Context, BB1);
   auto *N0 = MDNode::getDistinct(Context, None);
   auto *N1 = MDNode::getDistinct(Context, None);
   R0->setMetadata("md", N0);
   R1->setMetadata("md", N1);
 
   EXPECT_PRINTER_EQ("!0 = distinct !{}", N0->print(OS, &M));
   EXPECT_PRINTER_EQ("!1 = distinct !{}", N1->print(OS, &M));
 
   ModuleSlotTracker MST(&M);
   EXPECT_PRINTER_EQ("!0 = distinct !{}", N0->print(OS, MST));
   EXPECT_PRINTER_EQ("!1 = distinct !{}", N1->print(OS, MST));
 }
 
 TEST_F(MDNodeTest, PrintFromMetadataAsValue) {
   Module M("test", Context);
 
   auto *Intrinsic =
       Function::Create(FunctionType::get(Type::getVoidTy(Context),
                                          Type::getMetadataTy(Context), false),
-                       GlobalValue::ExternalLinkage, "llvm.intrinsic", &M);
+                       GlobalValue::ExternalLinkage, "llvm.intrinsic", M);
 
   auto *FTy = FunctionType::get(Type::getVoidTy(Context), false);
-  auto *F0 = Function::Create(FTy, GlobalValue::ExternalLinkage, "F0", &M);
-  auto *F1 = Function::Create(FTy, GlobalValue::ExternalLinkage, "F1", &M);
+  auto *F0 = Function::Create(FTy, GlobalValue::ExternalLinkage, "F0", M);
+  auto *F1 = Function::Create(FTy, GlobalValue::ExternalLinkage, "F1", M);
   auto *BB0 = BasicBlock::Create(Context, "entry", F0);
   auto *BB1 = BasicBlock::Create(Context, "entry", F1);
   auto *N0 = MDNode::getDistinct(Context, None);
   auto *N1 = MDNode::getDistinct(Context, None);
   auto *MAV0 = MetadataAsValue::get(Context, N0);
   auto *MAV1 = MetadataAsValue::get(Context, N1);
   CallInst::Create(Intrinsic, MAV0, "", BB0);
   CallInst::Create(Intrinsic, MAV1, "", BB1);

unittests/IR/PatternMatch.cpp

struct PatternMatchTest : ::testing::Test {
   Function *F;
   BasicBlock *BB;
   IRBuilder<NoFolder> IRB;
 
   PatternMatchTest()
       : M(new Module("PatternMatchTestModule", Ctx)),
         F(Function::Create(
             FunctionType::get(Type::getVoidTy(Ctx), /* IsVarArg */ false),
-            Function::ExternalLinkage, "f", M.get())),
+            Function::ExternalLinkage, "f", *M.get())),
         BB(BasicBlock::Create(Ctx, "entry", F)), IRB(BB) {}
 };
 
 TEST_F(PatternMatchTest, OneUse) {
   // Build up a little tree of values:
   //
   //   One  = (1 + 2) + 42
   //   Two  = One + 42

unittests/IR/UserTest.cpp

TEST(UserTest, ValueOpIteration) {
   EXPECT_EQ(IP->value_op_end(), (CI - 2) + 8);
 }
 
 TEST(UserTest, PersonalityUser) {
   LLVMContext Context;
   Module M("", Context);
   FunctionType *RetVoidTy = FunctionType::get(Type::getVoidTy(Context), false);
   Function *PersonalityF = Function::Create(
-      RetVoidTy, GlobalValue::ExternalLinkage, "PersonalityFn", &M);
+      RetVoidTy, GlobalValue::ExternalLinkage, "PersonalityFn", M);
   Function *TestF =
-      Function::Create(RetVoidTy, GlobalValue::ExternalLinkage, "TestFn", &M);
+      Function::Create(RetVoidTy, GlobalValue::ExternalLinkage, "TestFn", M);
 
   // Set up the personality function
   TestF->setPersonalityFn(PersonalityF);
   auto PersonalityUsers = PersonalityF->user_begin();
 
   // One user and that user is the Test function
   EXPECT_EQ(*PersonalityUsers, TestF);
   EXPECT_EQ(++PersonalityUsers, PersonalityF->user_end());

unittests/IR/VerifierTest.cpp

EXPECT_TRUE(
                                           "have external or weak linkage!"));
 }
 
 TEST(VerifierTest, InvalidFunctionLinkage) {
   LLVMContext C;
   Module M("M", C);
 
   FunctionType *FTy = FunctionType::get(Type::getVoidTy(C), /*isVarArg=*/false);
-  Function::Create(FTy, GlobalValue::LinkOnceODRLinkage, "foo", &M);
+  Function::Create(FTy, GlobalValue::LinkOnceODRLinkage, "foo", M);
   std::string Error;
   raw_string_ostream ErrorOS(Error);
   EXPECT_TRUE(verifyModule(M, &ErrorOS));
   EXPECT_TRUE(
       StringRef(ErrorOS.str()).startswith("Global is external, but doesn't "
                                           "have external or weak linkage!"));
 }
 

unittests/IR/WaymarkTest.cpp

TEST(WaymarkTest, NativeArray) {
   LLVMContext Context;
   static uint8_t tail[22] = "s02s33s30y2y0s1x0syxS";
   Value * values[22];
   std::transform(tail, tail + 22, values, [&](char c) {
     return ConstantInt::get(Type::getInt8Ty(Context), c);
   });
   FunctionType *FT = FunctionType::get(Type::getVoidTy(Context), true);
   std::unique_ptr<Function> F(
-      Function::Create(FT, GlobalValue::ExternalLinkage));
+      Function::Create(FT, GlobalValue::ExternalLinkage, /*AddrSpace=*/0));
   const CallInst *A = CallInst::Create(F.get(), makeArrayRef(values));
   ASSERT_NE(A, (const CallInst*)nullptr);
   ASSERT_EQ(1U + 22, A->getNumOperands());
   const Use *U = &A->getOperandUse(0);
   const Use *Ue = &A->getOperandUse(22);
   for (; U != Ue; ++U)
   {
     EXPECT_EQ(A, U->getUser());

unittests/Linker/LinkModulesTest.cpp

 namespace {
 
 class LinkModuleTest : public testing::Test {
 protected:
   void SetUp() override {
     M.reset(new Module("MyModule", Ctx));
     FunctionType *FTy = FunctionType::get(
         Type::getInt8PtrTy(Ctx), Type::getInt32Ty(Ctx), false /*=isVarArg*/);
-    F = Function::Create(FTy, Function::ExternalLinkage, "ba_func", M.get());
+    F = Function::Create(FTy, Function::ExternalLinkage, "ba_func", *M.get());
     F->setCallingConv(CallingConv::C);
 
     EntryBB = BasicBlock::Create(Ctx, "entry", F);
     SwitchCase1BB = BasicBlock::Create(Ctx, "switch.case.1", F);
     SwitchCase2BB = BasicBlock::Create(Ctx, "switch.case.2", F);
     ExitBB = BasicBlock::Create(Ctx, "exit", F);
 
     AT = ArrayType::get(Type::getInt8PtrTy(Ctx), 3);

 
 static Module *getExternal(LLVMContext &Ctx, StringRef FuncName) {
   // Create a module with an empty externally-linked function
   Module *M = new Module("ExternalModule", Ctx);
   FunctionType *FTy = FunctionType::get(
       Type::getVoidTy(Ctx), Type::getInt8PtrTy(Ctx), false /*=isVarArgs*/);
 
   Function *F =
-      Function::Create(FTy, Function::ExternalLinkage, FuncName, M);
+      Function::Create(FTy, Function::ExternalLinkage, FuncName, *M);
   F->setCallingConv(CallingConv::C);
 
   BasicBlock *BB = BasicBlock::Create(Ctx, "", F);
   IRBuilder<> Builder(BB);
   Builder.CreateRetVoid();
   return M;
 }
 
 static Module *getInternal(LLVMContext &Ctx) {
   Module *InternalM = new Module("InternalModule", Ctx);
   FunctionType *FTy = FunctionType::get(
       Type::getVoidTy(Ctx), Type::getInt8PtrTy(Ctx), false /*=isVarArgs*/);
 
   Function *F =
-      Function::Create(FTy, Function::InternalLinkage, "bar", InternalM);
+      Function::Create(FTy, Function::InternalLinkage, "bar", *InternalM);
   F->setCallingConv(CallingConv::C);
 
   BasicBlock *BB = BasicBlock::Create(Ctx, "", F);
   IRBuilder<> Builder(BB);
   Builder.CreateRetVoid();
 
   StructType *STy = StructType::create(Ctx, PointerType::get(FTy, 0));
 

unittests/ProfileData/InstrProfTest.cpp

TEST_P(MaybeSparseInstrProfTest, annotate_vp_data) {
   Expected<InstrProfRecord> R = Reader->getInstrProfRecord("caller", 0x1234);
   EXPECT_THAT_ERROR(R.takeError(), Succeeded());
 
   LLVMContext Ctx;
   std::unique_ptr<Module> M(new Module("MyModule", Ctx));
   FunctionType *FTy = FunctionType::get(Type::getVoidTy(Ctx),
                                         /*isVarArg=*/false);
   Function *F =
-      Function::Create(FTy, Function::ExternalLinkage, "caller", M.get());
+      Function::Create(FTy, Function::ExternalLinkage, "caller", *M.get());
   BasicBlock *BB = BasicBlock::Create(Ctx, "", F);
 
   IRBuilder<> Builder(BB);
   BasicBlock *TBB = BasicBlock::Create(Ctx, "", F);
   BasicBlock *FBB = BasicBlock::Create(Ctx, "", F);
 
   // Use branch instruction to annotate with value profile data for simplicity
   Instruction *Inst = Builder.CreateCondBr(Builder.getTrue(), TBB, FBB);

 }
 
 // Testing symtab creator interface used by value profile transformer.
 TEST_P(MaybeSparseInstrProfTest, instr_prof_symtab_module_test) {
   LLVMContext Ctx;
   std::unique_ptr<Module> M = llvm::make_unique<Module>("MyModule.cpp", Ctx);
   FunctionType *FTy = FunctionType::get(Type::getVoidTy(Ctx),
                                         /*isVarArg=*/false);
-  Function::Create(FTy, Function::ExternalLinkage, "Gfoo", M.get());
-  Function::Create(FTy, Function::ExternalLinkage, "Gblah", M.get());
-  Function::Create(FTy, Function::ExternalLinkage, "Gbar", M.get());
-  Function::Create(FTy, Function::InternalLinkage, "Ifoo", M.get());
-  Function::Create(FTy, Function::InternalLinkage, "Iblah", M.get());
-  Function::Create(FTy, Function::InternalLinkage, "Ibar", M.get());
-  Function::Create(FTy, Function::PrivateLinkage, "Pfoo", M.get());
-  Function::Create(FTy, Function::PrivateLinkage, "Pblah", M.get());
-  Function::Create(FTy, Function::PrivateLinkage, "Pbar", M.get());
-  Function::Create(FTy, Function::WeakODRLinkage, "Wfoo", M.get());
-  Function::Create(FTy, Function::WeakODRLinkage, "Wblah", M.get());
-  Function::Create(FTy, Function::WeakODRLinkage, "Wbar", M.get());
+  Function::Create(FTy, Function::ExternalLinkage, "Gfoo", *M.get());
+  Function::Create(FTy, Function::ExternalLinkage, "Gblah", *M.get());
+  Function::Create(FTy, Function::ExternalLinkage, "Gbar", *M.get());
+  Function::Create(FTy, Function::InternalLinkage, "Ifoo", *M.get());
+  Function::Create(FTy, Function::InternalLinkage, "Iblah", *M.get());
+  Function::Create(FTy, Function::InternalLinkage, "Ibar", *M.get());
+  Function::Create(FTy, Function::PrivateLinkage, "Pfoo", *M.get());
+  Function::Create(FTy, Function::PrivateLinkage, "Pblah", *M.get());
+  Function::Create(FTy, Function::PrivateLinkage, "Pbar", *M.get());
+  Function::Create(FTy, Function::WeakODRLinkage, "Wfoo", *M.get());
+  Function::Create(FTy, Function::WeakODRLinkage, "Wblah", *M.get());
+  Function::Create(FTy, Function::WeakODRLinkage, "Wbar", *M.get());
 
   InstrProfSymtab ProfSymtab;
   EXPECT_THAT_ERROR(ProfSymtab.create(*M), Succeeded());
 
   StringRef Funcs[] = {"Gfoo", "Gblah", "Gbar", "Ifoo", "Iblah", "Ibar",
                        "Pfoo", "Pblah", "Pbar", "Wfoo", "Wblah", "Wbar"};
 
   for (unsigned I = 0; I < sizeof(Funcs) / sizeof(*Funcs); I++) {

unittests/Transforms/Utils/Cloning.cpp

TEST_F(CloneInstruction, Exact) {
   SDiv->setIsExact(true);
   EXPECT_TRUE(this->clone(SDiv)->isExact());
 }
 
 TEST_F(CloneInstruction, Attributes) {
   Type *ArgTy1[] = { Type::getInt32PtrTy(context) };
   FunctionType *FT1 =  FunctionType::get(Type::getVoidTy(context), ArgTy1, false);
 
-  Function *F1 = Function::Create(FT1, Function::ExternalLinkage);
+  Function *F1 = Function::Create(FT1, Function::ExternalLinkage,
+                                  /*AddrSpace=*/0);
   BasicBlock *BB = BasicBlock::Create(context, "", F1);
   IRBuilder<> Builder(BB);
   Builder.CreateRetVoid();
 
-  Function *F2 = Function::Create(FT1, Function::ExternalLinkage);
+  Function *F2 = Function::Create(FT1, Function::ExternalLinkage,
+                                  /*AddrSpace=*/0);
 
   Argument *A = &*F1->arg_begin();
   A->addAttr(Attribute::NoCapture);
 
   SmallVector<ReturnInst*, 4> Returns;
   ValueToValueMapTy VMap;
   VMap[A] = UndefValue::get(A->getType());
 
   CloneFunctionInto(F2, F1, VMap, false, Returns);
   EXPECT_FALSE(F2->arg_begin()->hasNoCaptureAttr());
 
   delete F1;
   delete F2;
 }
 
 TEST_F(CloneInstruction, CallingConvention) {
   Type *ArgTy1[] = { Type::getInt32PtrTy(context) };
   FunctionType *FT1 =  FunctionType::get(Type::getVoidTy(context), ArgTy1, false);
 
-  Function *F1 = Function::Create(FT1, Function::ExternalLinkage);
+  Function *F1 = Function::Create(FT1, Function::ExternalLinkage,
+                                  /*AddrSpace=*/0);
   F1->setCallingConv(CallingConv::Cold);
   BasicBlock *BB = BasicBlock::Create(context, "", F1);
   IRBuilder<> Builder(BB);
   Builder.CreateRetVoid();
 
-  Function *F2 = Function::Create(FT1, Function::ExternalLinkage);
+  Function *F2 = Function::Create(FT1, Function::ExternalLinkage,
+                                  /*AddrSpace=*/0);
 
   SmallVector<ReturnInst*, 4> Returns;
   ValueToValueMapTy VMap;
   VMap[&*F1->arg_begin()] = &*F2->arg_begin();
 
   CloneFunctionInto(F2, F1, VMap, false, Returns);
   EXPECT_EQ(CallingConv::Cold, F2->getCallingConv());
 
   delete F1;
   delete F2;
 }
 
 TEST_F(CloneInstruction, DuplicateInstructionsToSplit) {
   Type *ArgTy1[] = {Type::getInt32PtrTy(context)};
   FunctionType *FT = FunctionType::get(Type::getVoidTy(context), ArgTy1, false);
   V = new Argument(Type::getInt32Ty(context));
 
-  Function *F = Function::Create(FT, Function::ExternalLinkage);
+  Function *F = Function::Create(FT, Function::ExternalLinkage,
+                                 /*AddrSpace=*/0);
 
   BasicBlock *BB1 = BasicBlock::Create(context, "", F);
   IRBuilder<> Builder1(BB1);
 
   BasicBlock *BB2 = BasicBlock::Create(context, "", F);
   IRBuilder<> Builder2(BB2);
 
   Builder1.CreateBr(BB2);
protected:
   void TearDown() override { delete Finder; }
 
   void SetupModule() {
     M = new Module("", C);
   }
 
   void CreateOldFunc() {
     FunctionType* FuncType = FunctionType::get(Type::getVoidTy(C), false);
-    OldFunc = Function::Create(FuncType, GlobalValue::PrivateLinkage, "f", M);
+    OldFunc = Function::Create(FuncType, GlobalValue::PrivateLinkage, "f", *M);
     CreateOldFunctionBodyAndDI();
   }
 
   void CreateOldFunctionBodyAndDI() {
     DIBuilder DBuilder(*M);
     IRBuilder<> IBuilder(C);
 
     // Function DI
void CreateOldModule() {
     GV->addMetadata(LLVMContext::MD_type, *MDNode::get(C, {}));
     GV->setComdat(CD);
 
     DIBuilder DBuilder(*OldM);
     IRBuilder<> IBuilder(C);
 
     auto *FuncType = FunctionType::get(Type::getVoidTy(C), false);
     auto *PersFn = Function::Create(FuncType, GlobalValue::ExternalLinkage,
-                                    "persfn", OldM);
+                                    "persfn", *OldM);
     auto *F =
-        Function::Create(FuncType, GlobalValue::PrivateLinkage, "f", OldM);
+        Function::Create(FuncType, GlobalValue::PrivateLinkage, "f", *OldM);
     F->setPersonalityFn(PersFn);
     F->setComdat(CD);
 
     // Create debug info
     auto *File = DBuilder.createFile("filename.c", "/file/dir/");
     DITypeRefArray ParamTypes = DBuilder.getOrCreateTypeArray(None);
     DISubroutineType *DFuncType = DBuilder.createSubroutineType(ParamTypes);
     auto *CU = DBuilder.createCompileUnit(dwarf::DW_LANG_C99,

unittests/Transforms/Utils/FunctionComparator.cpp

struct TestFunction {
   Constant *C;
   Instruction *I;
   Type *T;
 
   TestFunction(LLVMContext &Ctx, Module &M, int addVal) {
     IRBuilder<> B(Ctx);
     T = B.getInt8Ty();
     F = Function::Create(FunctionType::get(T, {B.getInt8PtrTy()}, false),
-                         GlobalValue::ExternalLinkage, "F", &M);
+                         GlobalValue::ExternalLinkage, "F", M);
     BB = BasicBlock::Create(Ctx, "", F);
     B.SetInsertPoint(BB);
     Argument *PointerArg = &*F->arg_begin();
     LoadInst *LoadInst = B.CreateLoad(PointerArg);
     C = B.getInt8(addVal);
     I = cast<Instruction>(B.CreateAdd(LoadInst, C));
     B.CreateRet(I);
   }

unittests/Transforms/Utils/IntegerDivision.cpp

 TEST(IntegerDivision, SDiv) {
   LLVMContext C;
   Module M("test division", C);
   IRBuilder<> Builder(C);
 
   SmallVector<Type*, 2> ArgTys(2, Builder.getInt32Ty());
   Function *F = Function::Create(FunctionType::get(Builder.getInt32Ty(),
                                                    ArgTys, false),
-                                 GlobalValue::ExternalLinkage, "F", &M);
+                                 GlobalValue::ExternalLinkage, "F", M);
   assert(F->arg_size() == 2);
 
   BasicBlock *BB = BasicBlock::Create(C, "", F);
   Builder.SetInsertPoint(BB);
 
   Function::arg_iterator AI = F->arg_begin();
   Value *A = &*AI++;
   Value *B = &*AI++;

 TEST(IntegerDivision, UDiv) {
   LLVMContext C;
   Module M("test division", C);
   IRBuilder<> Builder(C);
 
   SmallVector<Type*, 2> ArgTys(2, Builder.getInt32Ty());
   Function *F = Function::Create(FunctionType::get(Builder.getInt32Ty(),
                                                    ArgTys, false),
-                                 GlobalValue::ExternalLinkage, "F", &M);
+                                 GlobalValue::ExternalLinkage, "F", M);
   assert(F->arg_size() == 2);
 
   BasicBlock *BB = BasicBlock::Create(C, "", F);
   Builder.SetInsertPoint(BB);
 
   Function::arg_iterator AI = F->arg_begin();
   Value *A = &*AI++;
   Value *B = &*AI++;

 TEST(IntegerDivision, SRem) {
   LLVMContext C;
   Module M("test remainder", C);
   IRBuilder<> Builder(C);
 
   SmallVector<Type*, 2> ArgTys(2, Builder.getInt32Ty());
   Function *F = Function::Create(FunctionType::get(Builder.getInt32Ty(),
                                                    ArgTys, false),
-                                 GlobalValue::ExternalLinkage, "F", &M);
+                                 GlobalValue::ExternalLinkage, "F", M);
   assert(F->arg_size() == 2);
 
   BasicBlock *BB = BasicBlock::Create(C, "", F);
   Builder.SetInsertPoint(BB);
 
   Function::arg_iterator AI = F->arg_begin();
   Value *A = &*AI++;
   Value *B = &*AI++;

 TEST(IntegerDivision, URem) {
   LLVMContext C;
   Module M("test remainder", C);
   IRBuilder<> Builder(C);
 
   SmallVector<Type*, 2> ArgTys(2, Builder.getInt32Ty());
   Function *F = Function::Create(FunctionType::get(Builder.getInt32Ty(),
                                                    ArgTys, false),
-                                 GlobalValue::ExternalLinkage, "F", &M);
+                                 GlobalValue::ExternalLinkage, "F", M);
   assert(F->arg_size() == 2);
 
   BasicBlock *BB = BasicBlock::Create(C, "", F);
   Builder.SetInsertPoint(BB);
 
   Function::arg_iterator AI = F->arg_begin();
   Value *A = &*AI++;
   Value *B = &*AI++;

 TEST(IntegerDivision, SDiv64) {
   LLVMContext C;
   Module M("test division", C);
   IRBuilder<> Builder(C);
 
   SmallVector<Type*, 2> ArgTys(2, Builder.getInt64Ty());
   Function *F = Function::Create(FunctionType::get(Builder.getInt64Ty(),
                                                    ArgTys, false),
-                                 GlobalValue::ExternalLinkage, "F", &M);
+                                 GlobalValue::ExternalLinkage, "F", M);
   assert(F->arg_size() == 2);
 
   BasicBlock *BB = BasicBlock::Create(C, "", F);
   Builder.SetInsertPoint(BB);
 
   Function::arg_iterator AI = F->arg_begin();
   Value *A = &*AI++;
   Value *B = &*AI++;

 TEST(IntegerDivision, UDiv64) {
   LLVMContext C;
   Module M("test division", C);
   IRBuilder<> Builder(C);
 
   SmallVector<Type*, 2> ArgTys(2, Builder.getInt64Ty());
   Function *F = Function::Create(FunctionType::get(Builder.getInt64Ty(),
                                                    ArgTys, false),
-                                 GlobalValue::ExternalLinkage, "F", &M);
+                                 GlobalValue::ExternalLinkage, "F", M);
   assert(F->arg_size() == 2);
 
   BasicBlock *BB = BasicBlock::Create(C, "", F);
   Builder.SetInsertPoint(BB);
 
   Function::arg_iterator AI = F->arg_begin();
   Value *A = &*AI++;
   Value *B = &*AI++;

 TEST(IntegerDivision, SRem64) {
   LLVMContext C;
   Module M("test remainder", C);
   IRBuilder<> Builder(C);
 
   SmallVector<Type*, 2> ArgTys(2, Builder.getInt64Ty());
   Function *F = Function::Create(FunctionType::get(Builder.getInt64Ty(),
                                                    ArgTys, false),
-                                 GlobalValue::ExternalLinkage, "F", &M);
+                                 GlobalValue::ExternalLinkage, "F", M);
   assert(F->arg_size() == 2);
 
   BasicBlock *BB = BasicBlock::Create(C, "", F);
   Builder.SetInsertPoint(BB);
 
   Function::arg_iterator AI = F->arg_begin();
   Value *A = &*AI++;
   Value *B = &*AI++;

 TEST(IntegerDivision, URem64) {
   LLVMContext C;
   Module M("test remainder", C);
   IRBuilder<> Builder(C);
 
   SmallVector<Type*, 2> ArgTys(2, Builder.getInt64Ty());
   Function *F = Function::Create(FunctionType::get(Builder.getInt64Ty(),
                                                    ArgTys, false),
-                                 GlobalValue::ExternalLinkage, "F", &M);
+                                 GlobalValue::ExternalLinkage, "F", M);
   assert(F->arg_size() == 2);
 
   BasicBlock *BB = BasicBlock::Create(C, "", F);
   Builder.SetInsertPoint(BB);
 
   Function::arg_iterator AI = F->arg_begin();
   Value *A = &*AI++;
   Value *B = &*AI++;

unittests/Transforms/Utils/Local.cpp

 }
 
 TEST(Local, RemoveDuplicatePHINodes) {
   LLVMContext C;
   IRBuilder<> B(C);
 
   std::unique_ptr<Function> F(
       Function::Create(FunctionType::get(B.getVoidTy(), false),
-                       GlobalValue::ExternalLinkage, "F"));
+                       GlobalValue::ExternalLinkage, /*AddrSpace=*/0, "F"));
   BasicBlock *Entry(BasicBlock::Create(C, "", F.get()));
   BasicBlock *BB(BasicBlock::Create(C, "", F.get()));
   BranchInst::Create(BB, Entry);
 
   B.SetInsertPoint(BB);
 
   AssertingVH<PHINode> P1 = B.CreatePHI(Type::getInt32Ty(C), 2);
   P1->addIncoming(B.getInt32(42), Entry);

unittests/Transforms/Utils/ValueMapperTest.cpp

TEST(ValueMapperTest, mapMDNodeSeededWithNull) {
   EXPECT_EQ(nullptr, ValueMapper(VM).mapMDNode(*D));
 }
 
 TEST(ValueMapperTest, mapMetadataNullMapGlobalWithIgnoreMissingLocals) {
   LLVMContext C;
   FunctionType *FTy =
       FunctionType::get(Type::getVoidTy(C), Type::getInt8Ty(C), false);
   std::unique_ptr<Function> F(
-      Function::Create(FTy, GlobalValue::ExternalLinkage, "F"));
+      Function::Create(FTy, GlobalValue::ExternalLinkage, /*AddrSpace=*/0,
+                       "F"));
 
   ValueToValueMapTy VM;
   RemapFlags Flags = RF_IgnoreMissingLocals | RF_NullMapMissingGlobalValues;
   EXPECT_EQ(nullptr, ValueMapper(VM, Flags).mapValue(*F));
 }
 
 TEST(ValueMapperTest, mapMetadataMDString) {
   LLVMContext C;
TEST(ValueMapperTest, mapMetadataNoModuleLevelChanges) {
   EXPECT_EQ(None, VM.getMappedMD(N1));
 }
 
 TEST(ValueMapperTest, mapMetadataConstantAsMetadata) {
   LLVMContext C;
   FunctionType *FTy =
       FunctionType::get(Type::getVoidTy(C), Type::getInt8Ty(C), false);
   std::unique_ptr<Function> F(
-      Function::Create(FTy, GlobalValue::ExternalLinkage, "F"));
+      Function::Create(FTy, GlobalValue::ExternalLinkage, /*AddrSpace=*/0,
+                       "F"));
 
   auto *CAM = ConstantAsMetadata::get(F.get());
   {
     // ConstantAsMetadata shouldn't be memoized.
     ValueToValueMapTy VM;
     EXPECT_EQ(CAM, ValueMapper(VM).mapMetadata(*CAM));
     EXPECT_FALSE(VM.MD().count(CAM));
     EXPECT_EQ(CAM, ValueMapper(VM, RF_IgnoreMissingLocals).mapMetadata(*CAM));
     EXPECT_FALSE(VM.MD().count(CAM));
 
     // But it should respect a mapping that gets seeded.
     auto *N = MDTuple::get(C, None);
     VM.MD()[CAM].reset(N);
     EXPECT_EQ(N, ValueMapper(VM).mapMetadata(*CAM));
     EXPECT_EQ(N, ValueMapper(VM, RF_IgnoreMissingLocals).mapMetadata(*CAM));
   }
 
   std::unique_ptr<Function> F2(
-      Function::Create(FTy, GlobalValue::ExternalLinkage, "F2"));
+      Function::Create(FTy, GlobalValue::ExternalLinkage, /*AddrSpace=*/0,
+                       "F2"));
   ValueToValueMapTy VM;
   VM[F.get()] = F2.get();
   auto *F2MD = ValueMapper(VM).mapMetadata(*CAM);
   EXPECT_FALSE(VM.MD().count(CAM));
   EXPECT_TRUE(F2MD);
   EXPECT_EQ(F2.get(), cast<ConstantAsMetadata>(F2MD)->getValue());
 }
 
 #ifdef GTEST_HAS_DEATH_TEST
 #ifndef NDEBUG
 TEST(ValueMapperTest, mapMetadataLocalAsMetadata) {
   LLVMContext C;
   FunctionType *FTy =
       FunctionType::get(Type::getVoidTy(C), Type::getInt8Ty(C), false);
   std::unique_ptr<Function> F(
-      Function::Create(FTy, GlobalValue::ExternalLinkage, "F"));
+      Function::Create(FTy, GlobalValue::ExternalLinkage, /*AddrSpace=*/0,
+                       "F"));
   Argument &A = *F->arg_begin();
 
   // mapMetadata doesn't support LocalAsMetadata.  The only valid container for
   // LocalAsMetadata is a MetadataAsValue instance, so use it directly.
   auto *LAM = LocalAsMetadata::get(&A);
   ValueToValueMapTy VM;
   EXPECT_DEATH(ValueMapper(VM).mapMetadata(*LAM), "Unexpected local metadata");
   EXPECT_DEATH(ValueMapper(VM, RF_IgnoreMissingLocals).mapMetadata(*LAM),
                "Unexpected local metadata");
 }
 #endif
 #endif
 
 TEST(ValueMapperTest, mapValueLocalAsMetadata) {
   LLVMContext C;
   FunctionType *FTy =
       FunctionType::get(Type::getVoidTy(C), Type::getInt8Ty(C), false);
   std::unique_ptr<Function> F(
-      Function::Create(FTy, GlobalValue::ExternalLinkage, "F"));
+      Function::Create(FTy, GlobalValue::ExternalLinkage, /*AddrSpace=*/0,
+                       "F"));
   Argument &A = *F->arg_begin();
 
   auto *LAM = LocalAsMetadata::get(&A);
   auto *MAV = MetadataAsValue::get(C, LAM);
 
   // The principled answer to a LocalAsMetadata of an unmapped SSA value would
   // be to return nullptr (regardless of RF_IgnoreMissingLocals).
   //
TEST(ValueMapperTest, mapValueLocalAsMetadata) {
   EXPECT_FALSE(VM.count(&A));
 }
 
 TEST(ValueMapperTest, mapValueLocalAsMetadataToConstant) {
   LLVMContext Context;
   auto *Int8 = Type::getInt8Ty(Context);
   FunctionType *FTy = FunctionType::get(Type::getVoidTy(Context), Int8, false);
   std::unique_ptr<Function> F(
-      Function::Create(FTy, GlobalValue::ExternalLinkage, "F"));
+      Function::Create(FTy, GlobalValue::ExternalLinkage, /*AddrSpace=*/0,
+                       "F"));
 
   // Map a local value to a constant.
   Argument &A = *F->arg_begin();
   Constant &C = *ConstantInt::get(Int8, 42);
   ValueToValueMapTy VM;
   VM[&A] = &C;
 
   // Look up the metadata-as-value wrapper.  Don't crash.