Associate functions with address spaces

[dylanmckay]

Summary

I am popping this up on Phabricator for early feedback.

**NOTE*: I will submit this in several smaller patches once this is actually ready.

This adds support for letting targets specify which address
spaces their functions should reside in by default.

This is the first step towards placing functions into the correct
address space for Harvard architectures.

This requires address space to be specified when creating functions. In general, you should always be using DataLayout.getProgramAddressSpace() unless you have a reason not to.

[dylanmckay]

include/llvm/IR/DerivedTypes.h

106

I worry that other LLVM developers will see AddrSpace and naively enter 0, which would break all Harvard architectures.

One way around this could be make the ctor take a DataLayout instead, but you shouldn't really need one to construct this.

Any ideas are very welcome!

[dylanmckay]

I intend to add many more tests once I've had some feedback

[dylanmckay]

I meant to post that comment on this diff

[dylanmckay]

Place switch tables in the program memory address space

[pcc]

include/llvm/IR/DerivedTypes.h

106

I don't understand why this needs to be part of the function type. It seems to me that this ought to work in the same way as for global variables, i.e. function takes an address space at construction time which is used to create its pointer type; address space is queried by querying address space on the pointer type.

[theraven]

include/llvm/IR/DerivedTypes.h

106

Indeed. One of the big differences between the C and LLVM models is that C address spaces are properties of objects whereas LLVM address spaces are properties of pointers. The LLVM model is cleaner, but associating an address space with a function would be inconsistent.

[dylanmckay]

include/llvm/IR/DerivedTypes.h

106

I originally implemented this in the way you all are mentioning, but I had to backtrack when I saw these two lines

FunctionType *FT =
    FunctionType::get(RetType, ParamTypeList, isVarArg, AddrSpace);
  PointerType *PFT = PointerType::getUnqual(FT);

I just read up and realised that getUnqual will always use the generic address space, and so this is not relevant.

I will move the field to Function, similar to the way it is done for global variables.

[dylanmckay]

Abandoning this for now, will upload a new set of patches which places address space on Function and not FunctionType.

[dylanmckay]

Have raised

• Add program address space to data layout D37052
• Insert switch tables into the program memory address space D37053
• Require address space to be specified when creating functions D37054
• [clang] Require address space to be specified when creating functions D37057

docs/BitCodeFormat.rst

 The ``POINTER`` record (code 8) adds a pointer type to the type table. The
 operand fields are
 
 * *pointee type*: The type index of the pointed-to type
 
 * *address space*: If supplied, the target-specific numbered address space where
   the pointed-to object resides. Otherwise, the default address space is zero.
 
-TYPE_CODE_FUNCTION_OLD Record
+TYPE_CODE_FUNCTION_VERY_OLD Record
 ^^^^^^^^^^^^^^^^^^^^^^^^^^^^^
 
 .. note::
   This is a legacy encoding for functions, produced by LLVM versions 3.0 and
   earlier. It is guaranteed to be understood by the current LLVM version, as
   specified in the :ref:`IR backwards compatibility` policy.
 
-``[FUNCTION_OLD, vararg, ignored, retty, ...paramty... ]``
+``[FUNCTION_VERY_OLD, vararg, ignored, retty, ...paramty... ]``
 
-The ``FUNCTION_OLD`` record (code 9) adds a function type to the type table.
+The ``FUNCTION_VERY_OLD`` record (code 9) adds a function type to the type table.
 The operand fields are
 
 * *vararg*: Non-zero if the type represents a varargs function
 
 * *ignored*: This value field is present for backward compatibility only, and is
   ignored
 
 * *retty*: The type index of the function's return type
 
 * *paramty*: Zero or more type indices representing the parameter types of the
   function
 
+FIXME: Add docs for new record type
+
 TYPE_CODE_ARRAY Record
 ^^^^^^^^^^^^^^^^^^^^^^
 
 ``[ARRAY, numelts, eltty]``
 
 The ``ARRAY`` record (code 11) adds an array type to the type table.  The
 operand fields are
 

 type table, with a name defined by a previously encountered ``STRUCT_NAME``
 record. The operand fields are
 
 * *ispacked*: Non-zero if the type represents a packed structure
 
 * *eltty*: Zero or more type indices representing the element types of the
   structure
 
-TYPE_CODE_FUNCTION Record
+TYPE_CODE_FUNCTION_OLD Record
 ^^^^^^^^^^^^^^^^^^^^^^^^^
 
-``[FUNCTION, vararg, retty, ...paramty... ]``
+``[FUNCTION_OLD, vararg, retty, ...paramty... ]``
+
+FIXME: add a note about legacy
 
-The ``FUNCTION`` record (code 21) adds a function type to the type table. The
+The ``FUNCTION_OLD`` record (code 21) adds a function type to the type table. The
 operand fields are
 
 * *vararg*: Non-zero if the type represents a varargs function
 
 * *retty*: The type index of the function's return type
 
 * *paramty*: Zero or more type indices representing the parameter types of the
   function

docs/LangRef.rst

``e``
     location.
 ``S<size>``
     Specifies the natural alignment of the stack in bits. Alignment
     promotion of stack variables is limited to the natural stack
     alignment to avoid dynamic stack realignment. The stack alignment
     must be a multiple of 8-bits. If omitted, the natural stack
     alignment defaults to "unspecified", which does not prevent any
     alignment promotions.
+``P<address space>``
+    Specifies the address space that corresponds to program memory.
+    Harvard architectures can use this to specify what space LLVM
+    should place things such as functions or switch lookup tables
+    into. If omitted, the program memory space defaults to the
+    default address space of 0, which corresponds to a Von Neumann
+    architecture that has code and data in the same space.
 ``A<address space>``
-    Specifies the address space of  objects created by '``alloca``'.
+    Specifies the address space of objects created by '``alloca``'.
     Defaults to the default address space of 0.
 ``p[n]:<size>:<abi>:<pref>``
     This specifies the *size* of a pointer and its ``<abi>`` and
     ``<pref>``\erred alignments for address space ``n``. All sizes are in
     bits. The address space, ``n``, is optional, and if not specified,
     denotes the default address space 0. The value of ``n`` must be
     in the range [1,2^23).
 ``i<size>:<abi>:<pref>``

include/llvm/Bitcode/LLVMBitCodes.h

enum TypeCodes {
   TYPE_CODE_VOID = 2,    // VOID
   TYPE_CODE_FLOAT = 3,   // FLOAT
   TYPE_CODE_DOUBLE = 4,  // DOUBLE
   TYPE_CODE_LABEL = 5,   // LABEL
   TYPE_CODE_OPAQUE = 6,  // OPAQUE
   TYPE_CODE_INTEGER = 7, // INTEGER: [width]
   TYPE_CODE_POINTER = 8, // POINTER: [pointee type]
 
-  TYPE_CODE_FUNCTION_OLD = 9, // FUNCTION: [vararg, attrid, retty,
+  TYPE_CODE_FUNCTION_VERY_OLD = 9, // FUNCTION: [vararg, attrid, retty,
                                    //            paramty x N]
 
   TYPE_CODE_HALF = 10, // HALF
 
   TYPE_CODE_ARRAY = 11,  // ARRAY: [numelts, eltty]
   TYPE_CODE_VECTOR = 12, // VECTOR: [numelts, eltty]
 
   // These are not with the other floating point types because they're
   // a late addition, and putting them in the right place breaks
   // binary compatibility.
   TYPE_CODE_X86_FP80 = 13,  // X86 LONG DOUBLE
   TYPE_CODE_FP128 = 14,     // LONG DOUBLE (112 bit mantissa)
   TYPE_CODE_PPC_FP128 = 15, // PPC LONG DOUBLE (2 doubles)
 
   TYPE_CODE_METADATA = 16, // METADATA
 
   TYPE_CODE_X86_MMX = 17, // X86 MMX
 
   TYPE_CODE_STRUCT_ANON = 18,  // STRUCT_ANON: [ispacked, eltty x N]
   TYPE_CODE_STRUCT_NAME = 19,  // STRUCT_NAME: [strchr x N]
   TYPE_CODE_STRUCT_NAMED = 20, // STRUCT_NAMED: [ispacked, eltty x N]
 
-  TYPE_CODE_FUNCTION = 21, // FUNCTION: [vararg, retty, paramty x N]
+  TYPE_CODE_FUNCTION_OLD = 21, // FUNCTION: [vararg, retty, paramty x N]
 
-  TYPE_CODE_TOKEN = 22 // TOKEN
+  TYPE_CODE_TOKEN = 22, // TOKEN
+  TYPE_CODE_FUNCTION = 23 // FUNCTION: [vararg, addrspace, retty, paramty x N]
 };
 
 enum OperandBundleTagCode {
   OPERAND_BUNDLE_TAG = 1, // TAG: [strchr x N]
 };
 
 enum SyncScopeNameCode {
   SYNC_SCOPE_NAME = 1,

include/llvm/IR/DataLayout.h

 /// target being codegen'd to.
 class DataLayout {
 private:
   /// Defaults to false.
   bool BigEndian;
 
   unsigned AllocaAddrSpace;
   unsigned StackNaturalAlign;
+  unsigned ProgramAddrSpace;
 
   enum ManglingModeT {
     MM_None,
     MM_ELF,
     MM_MachO,
     MM_WinCOFF,
     MM_WinCOFFX86,
     MM_Mips
public:
   ~DataLayout(); // Not virtual, do not subclass this class
 
   DataLayout &operator=(const DataLayout &DL) {
     clear();
     StringRepresentation = DL.StringRepresentation;
     BigEndian = DL.isBigEndian();
     AllocaAddrSpace = DL.AllocaAddrSpace;
     StackNaturalAlign = DL.StackNaturalAlign;
+    ProgramAddrSpace = DL.ProgramAddrSpace;
     ManglingMode = DL.ManglingMode;
     LegalIntWidths = DL.LegalIntWidths;
     Alignments = DL.Alignments;
     Pointers = DL.Pointers;
     NonIntegralAddressSpaces = DL.NonIntegralAddressSpaces;
     return *this;
   }
 
public:
   /// Returns true if the given alignment exceeds the natural stack alignment.
   bool exceedsNaturalStackAlignment(unsigned Align) const {
     return (StackNaturalAlign != 0) && (Align > StackNaturalAlign);
   }
 
   unsigned getStackAlignment() const { return StackNaturalAlign; }
   unsigned getAllocaAddrSpace() const { return AllocaAddrSpace; }
 
+  unsigned getProgramAddressSpace() const { return ProgramAddrSpace; }
+
   bool hasMicrosoftFastStdCallMangling() const {
     return ManglingMode == MM_WinCOFFX86;
   }
 
   bool hasLinkerPrivateGlobalPrefix() const { return ManglingMode == MM_MachO; }
 
   StringRef getLinkerPrivateGlobalPrefix() const {
     if (ManglingMode == MM_MachO)

include/llvm/IR/DerivedTypes.h

protected:
   explicit IntegerType(LLVMContext &C, unsigned NumBits) : Type(C, IntegerTyID){
     setSubclassData(NumBits);
   }
 
 public:
   /// This enum is just used to hold constants we need for IntegerType.
   enum {
     MIN_INT_BITS = 1,        ///< Minimum number of bits that can be specified
-    MAX_INT_BITS = (1<<24)-1 ///< Maximum number of bits that can be specified
-      ///< Note that bit width is stored in the Type classes SubclassData field
-      ///< which has 24 bits. This yields a maximum bit width of 16,777,215
-      ///< bits.
+    /// Maximum number of bits that can be specified
+    /// Note that bit width is stored in the Type classes SubclassData field
+    /// which has 24 bits. This yields a maximum bit width of 16,777,215
+    /// bits.
+    MAX_INT_BITS = (1<<SUBCLASS_DATA_BITS)-1
   };
 
   /// This static method is the primary way of constructing an IntegerType.
   /// If an IntegerType with the same NumBits value was previously instantiated,
   /// that instance will be returned. Otherwise a new one will be created. Only
   /// one instance with a given NumBits value is ever created.
   /// @brief Get or create an IntegerType instance.
   static IntegerType *get(LLVMContext &C, unsigned NumBits);

 
 unsigned Type::getIntegerBitWidth() const {
   return cast<IntegerType>(this)->getBitWidth();
 }
 
 /// Class to represent function types
 ///
 class FunctionType : public Type {
-  FunctionType(Type *Result, ArrayRef<Type*> Params, bool IsVarArgs);
+  FunctionType(Type *Result, ArrayRef<Type*> Params, bool IsVarArgs,
+               unsigned AddrSpace);
 
 public:
   FunctionType(const FunctionType &) = delete;
   FunctionType &operator=(const FunctionType &) = delete;
 
   /// This static method is the primary way of constructing a FunctionType.
   static FunctionType *get(Type *Result,
-                           ArrayRef<Type*> Params, bool isVarArg);
+                           ArrayRef<Type*> Params, bool isVarArg,
+                           unsigned AddrSpace);
 
   /// Create a FunctionType taking no parameters.
-  static FunctionType *get(Type *Result, bool isVarArg);
+  static FunctionType *get(Type *Result, bool isVarArg, unsigned AddrSpace);
 
   /// Return true if the specified type is valid as a return type.
   static bool isValidReturnType(Type *RetTy);
 
   /// Return true if the specified type is valid as an argument type.
   static bool isValidArgumentType(Type *ArgTy);
 
-  bool isVarArg() const { return getSubclassData()!=0; }
+  bool isVarArg() const {
+    return (getSubclassData() & 1) != 0;
+  }
+
+  unsigned getAddressSpace() const {
+    unsigned Mask = ~1;
+    return (getSubclassData() & Mask) >> 1;
+  }
+
   Type *getReturnType() const { return ContainedTys[0]; }
 
   using param_iterator = Type::subtype_iterator;
 
   param_iterator param_begin() const { return ContainedTys + 1; }
   param_iterator param_end() const { return &ContainedTys[NumContainedTys]; }
   ArrayRef<Type *> params() const {
     return makeArrayRef(param_begin(), param_end());

include/llvm/IR/Function.h

public:
   /// getContext - Return a reference to the LLVMContext associated with this
   /// function.
   LLVMContext &getContext() const;
 
   /// isVarArg - Return true if this function takes a variable number of
   /// arguments.
   bool isVarArg() const { return getFunctionType()->isVarArg(); }
 
+  /// Gets the address space that the function resides in.
+  unsigned getAddressSpace() const { return getFunctionType()->getAddressSpace(); }
+
   bool isMaterializable() const {
     return getGlobalObjectSubClassData() & (1 << IsMaterializableBit);
   }
   void setIsMaterializable(bool V) {
     unsigned Mask = 1 << IsMaterializableBit;
     setGlobalObjectSubClassData((~Mask & getGlobalObjectSubClassData()) |
                                 (V ? Mask : 0u));
   }

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/IR/Module.h

/// @{
   /// function arguments, which makes it easier for clients to use.
   template<typename... ArgsTy>
   Constant *getOrInsertFunction(StringRef Name,
                                 AttributeList AttributeList,
                                 Type *RetTy, ArgsTy... Args)
   {
     SmallVector<Type*, sizeof...(ArgsTy)> ArgTys{Args...};
     return getOrInsertFunction(Name,
-                               FunctionType::get(RetTy, ArgTys, false),
+                               FunctionType::get(RetTy, ArgTys, false,
+                               DL.getProgramAddressSpace()),
                                AttributeList);
   }
 
   /// Same as above, but without the attributes.
   template<typename... ArgsTy>
   Constant *getOrInsertFunction(StringRef Name, Type *RetTy, ArgsTy... Args) {
     return getOrInsertFunction(Name, AttributeList{}, RetTy, Args...);
   }

include/llvm/IR/Type.h

 #include "llvm/Support/CBindingWrapping.h"
 #include "llvm/Support/Casting.h"
 #include "llvm/Support/Compiler.h"
 #include "llvm/Support/ErrorHandling.h"
 #include <cassert>
 #include <cstdint>
 #include <iterator>
 
+// The width of the integer field that type subclasses can
+// use for arbitrary information.
+#define SUBCLASS_DATA_BITS 24
+
 namespace llvm {
 
 template<class GraphType> struct GraphTraits;
 class IntegerType;
 class LLVMContext;
 class PointerType;
 class raw_ostream;
 class StringRef;
enum TypeID {
     PointerTyID,     ///< 15: Pointers
     VectorTyID       ///< 16: SIMD 'packed' format, or other vector type
   };
 
 private:
   /// This refers to the LLVMContext in which this type was uniqued.
   LLVMContext &Context;
 
-  TypeID   ID : 8;            // The current base type of this type.
-  unsigned SubclassData : 24; // Space for subclasses to store data.
-                              // Note that this should be synchronized with
-                              // MAX_INT_BITS value in IntegerType class.
+  // The current base type of this type.
+  TypeID   ID : 8;
+  // Space for subclasses to store data.
+  unsigned SubclassData : SUBCLASS_DATA_BITS;
 
 protected:
   friend class LLVMContextImpl;
 
   explicit Type(LLVMContext &C, TypeID tid)
     : Context(C), ID(tid), SubclassData(0) {}
   ~Type() = default;
 

include/llvm/IR/TypeBuilder.h

 
 #ifndef LLVM_IR_TYPEBUILDER_H
 #define LLVM_IR_TYPEBUILDER_H
 
 #include "llvm/IR/DerivedTypes.h"
 #include "llvm/IR/LLVMContext.h"
 #include <climits>
 
+// FIXME: we probably need to update this for func addr space
+
 namespace llvm {
 
 /// TypeBuilder - This provides a uniform API for looking up types
 /// known at compile time.  To support cross-compilation, we define a
 /// series of tag types in the llvm::types namespace, like i<N>,
 /// ieee_float, ppc_fp128, etc.  TypeBuilder<T, false> allows T to be
 /// any of these, a native C type (whose size may depend on the host
 /// compiler), or a pointer, function, or struct type built out of

 template<> class TypeBuilder<volatile void*, false>
   : public TypeBuilder<types::i<8>*, false> {};
 template<> class TypeBuilder<const volatile void*, false>
   : public TypeBuilder<types::i<8>*, false> {};
 
 template<typename R, bool cross> class TypeBuilder<R(), cross> {
 public:
   static FunctionType *get(LLVMContext &Context) {
-    return FunctionType::get(TypeBuilder<R, cross>::get(Context), false);
+    unsigned AddrSpace = 0; // FIXME: don't assume this
+    return FunctionType::get(TypeBuilder<R, cross>::get(Context), false,
+                             AddrSpace);
   }
 };
 template<typename R, typename A1, bool cross> class TypeBuilder<R(A1), cross> {
 public:
   static FunctionType *get(LLVMContext &Context) {
     Type *params[] = {
       TypeBuilder<A1, cross>::get(Context),
     };
+    unsigned AddrSpace = 0; // FIXME: don't assume this
     return FunctionType::get(TypeBuilder<R, cross>::get(Context),
-                             params, false);
+                             params, false, AddrSpace);
   }
 };
 template<typename R, typename A1, typename A2, bool cross>
 class TypeBuilder<R(A1, A2), cross> {
 public:
   static FunctionType *get(LLVMContext &Context) {
     Type *params[] = {
       TypeBuilder<A1, cross>::get(Context),
       TypeBuilder<A2, cross>::get(Context),
     };
+    unsigned AddrSpace = 0; // FIXME: don't assume this
     return FunctionType::get(TypeBuilder<R, cross>::get(Context),
-                             params, false);
+                             params, false, AddrSpace);
   }
 };
 template<typename R, typename A1, typename A2, typename A3, bool cross>
 class TypeBuilder<R(A1, A2, A3), cross> {
 public:
   static FunctionType *get(LLVMContext &Context) {
     Type *params[] = {
       TypeBuilder<A1, cross>::get(Context),
       TypeBuilder<A2, cross>::get(Context),
       TypeBuilder<A3, cross>::get(Context),
     };
+    unsigned AddrSpace = 0; // FIXME: don't assume this
     return FunctionType::get(TypeBuilder<R, cross>::get(Context),
-                             params, false);
+                             params, false, AddrSpace);
   }
 };
 
 template<typename R, typename A1, typename A2, typename A3, typename A4,
          bool cross>
 class TypeBuilder<R(A1, A2, A3, A4), cross> {
 public:
   static FunctionType *get(LLVMContext &Context) {
     Type *params[] = {
       TypeBuilder<A1, cross>::get(Context),
       TypeBuilder<A2, cross>::get(Context),
       TypeBuilder<A3, cross>::get(Context),
       TypeBuilder<A4, cross>::get(Context),
     };
+    unsigned AddrSpace = 0; // FIXME: don't assume this
     return FunctionType::get(TypeBuilder<R, cross>::get(Context),
-                             params, false);
+                             params, false, AddrSpace);
   }
 };
 
 template<typename R, typename A1, typename A2, typename A3, typename A4,
          typename A5, bool cross>
 class TypeBuilder<R(A1, A2, A3, A4, A5), cross> {
 public:
   static FunctionType *get(LLVMContext &Context) {
     Type *params[] = {
       TypeBuilder<A1, cross>::get(Context),
       TypeBuilder<A2, cross>::get(Context),
       TypeBuilder<A3, cross>::get(Context),
       TypeBuilder<A4, cross>::get(Context),
       TypeBuilder<A5, cross>::get(Context),
     };
+    unsigned AddrSpace = 0; // FIXME: don't assume this
     return FunctionType::get(TypeBuilder<R, cross>::get(Context),
-                             params, false);
+                             params, false, AddrSpace);
   }
 };
 
 template<typename R, bool cross> class TypeBuilder<R(...), cross> {
 public:
   static FunctionType *get(LLVMContext &Context) {
-    return FunctionType::get(TypeBuilder<R, cross>::get(Context), true);
+    unsigned AddrSpace = 0; // FIXME: don't assume this
+    return FunctionType::get(TypeBuilder<R, cross>::get(Context), true,
+                             AddrSpace);
   }
 };
 template<typename R, typename A1, bool cross>
 class TypeBuilder<R(A1, ...), cross> {
 public:
   static FunctionType *get(LLVMContext &Context) {
     Type *params[] = {
       TypeBuilder<A1, cross>::get(Context),
     };
-    return FunctionType::get(TypeBuilder<R, cross>::get(Context), params, true);
+    unsigned AddrSpace = 0; // FIXME: don't assume this
+    return FunctionType::get(TypeBuilder<R, cross>::get(Context), params, true, AddrSpace);
   }
 };
 template<typename R, typename A1, typename A2, bool cross>
 class TypeBuilder<R(A1, A2, ...), cross> {
 public:
   static FunctionType *get(LLVMContext &Context) {
     Type *params[] = {
       TypeBuilder<A1, cross>::get(Context),
       TypeBuilder<A2, cross>::get(Context),
     };
+    unsigned AddrSpace = 0; // FIXME: don't assume this
     return FunctionType::get(TypeBuilder<R, cross>::get(Context),
-                                   params, true);
+                                   params, true, AddrSpace);
   }
 };
 template<typename R, typename A1, typename A2, typename A3, bool cross>
 class TypeBuilder<R(A1, A2, A3, ...), cross> {
 public:
   static FunctionType *get(LLVMContext &Context) {
     Type *params[] = {
       TypeBuilder<A1, cross>::get(Context),
       TypeBuilder<A2, cross>::get(Context),
       TypeBuilder<A3, cross>::get(Context),
     };
+    unsigned AddrSpace = 0; // FIXME: don't assume this
     return FunctionType::get(TypeBuilder<R, cross>::get(Context),
-                                   params, true);
+                                   params, true, AddrSpace);
   }
 };
 
 template<typename R, typename A1, typename A2, typename A3, typename A4,
          bool cross>
 class TypeBuilder<R(A1, A2, A3, A4, ...), cross> {
 public:
   static FunctionType *get(LLVMContext &Context) {
     Type *params[] = {
       TypeBuilder<A1, cross>::get(Context),
       TypeBuilder<A2, cross>::get(Context),
       TypeBuilder<A3, cross>::get(Context),
       TypeBuilder<A4, cross>::get(Context),
     };
+    unsigned AddrSpace = 0; // FIXME: don't assume this
     return FunctionType::get(TypeBuilder<R, cross>::get(Context),
-                             params, true);
+                             params, true, AddrSpace);
   }
 };
 
 template<typename R, typename A1, typename A2, typename A3, typename A4,
          typename A5, bool cross>
 class TypeBuilder<R(A1, A2, A3, A4, A5, ...), cross> {
 public:
   static FunctionType *get(LLVMContext &Context) {
     Type *params[] = {
       TypeBuilder<A1, cross>::get(Context),
       TypeBuilder<A2, cross>::get(Context),
       TypeBuilder<A3, cross>::get(Context),
       TypeBuilder<A4, cross>::get(Context),
       TypeBuilder<A5, cross>::get(Context),
     };
+    unsigned AddrSpace = 0; // FIXME: don't assume this
     return FunctionType::get(TypeBuilder<R, cross>::get(Context),
-                                   params, true);
+                                   params, true, AddrSpace);
   }
 };
 
 }  // namespace llvm
 
 #endif

lib/AsmParser/LLParser.cpp

while (EatIfPresent(lltok::comma)) {
                            std::move(Name));
     }
   }
 
   return ParseToken(lltok::rparen, "expected ')' at end of argument list");
 }
 
 /// ParseFunctionType
-///  ::= Type ArgumentList OptionalAttrs
+///  ::= Type ArgumentList OptionalAddrSpace OptionalAttrs
 bool LLParser::ParseFunctionType(Type *&Result) {
   assert(Lex.getKind() == lltok::lparen);
 
+  const DataLayout &DL = M->getDataLayout();
+
   if (!FunctionType::isValidReturnType(Result))
     return TokError("invalid function return type");
 
   SmallVector<ArgInfo, 8> ArgList;
   bool isVarArg;
   if (ParseArgumentList(ArgList, isVarArg))
     return true;
 
+  unsigned AddrSpace = DL.getProgramAddressSpace();
+  if (ParseOptionalAddrSpace(AddrSpace))
+    return true;
+
   // Reject names on the arguments lists.
   for (unsigned i = 0, e = ArgList.size(); i != e; ++i) {
     if (!ArgList[i].Name.empty())
       return Error(ArgList[i].Loc, "argument name invalid in function type");
     if (ArgList[i].Attrs.hasAttributes())
       return Error(ArgList[i].Loc,
                    "argument attributes invalid in function type");
   }
 
   SmallVector<Type*, 16> ArgListTy;
   for (unsigned i = 0, e = ArgList.size(); i != e; ++i)
     ArgListTy.push_back(ArgList[i].Ty);
 
-  Result = FunctionType::get(Result, ArgListTy, isVarArg);
+  Result = FunctionType::get(Result, ArgListTy, isVarArg, AddrSpace);
   return false;
 }
 
 /// ParseAnonStructType - Parse an anonymous struct type, which is inlined into
 /// other structs.
 bool LLParser::ParseAnonStructType(Type *&Result, bool Packed) {
   SmallVector<Type*, 8> Elts;
   if (ParseStructBody(Elts)) return true;
bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) {
 
   unsigned Visibility;
   unsigned DLLStorageClass;
   AttrBuilder RetAttrs;
   unsigned CC;
   bool HasLinkage;
   Type *RetType = nullptr;
   LocTy RetTypeLoc = Lex.getLoc();
+
+  const DataLayout &DL = M->getDataLayout();
+
   if (ParseOptionalLinkage(Linkage, HasLinkage, Visibility, DLLStorageClass) ||
       ParseOptionalCallingConv(CC) || ParseOptionalReturnAttrs(RetAttrs) ||
       ParseType(RetType, RetTypeLoc, true /*void allowed*/))
     return true;
 
   // Verify that the linkage is ok.
   switch ((GlobalValue::LinkageTypes)Linkage) {
   case GlobalValue::ExternalLinkage:
bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) {
   AttrBuilder FuncAttrs;
   std::vector<unsigned> FwdRefAttrGrps;
   LocTy BuiltinLoc;
   std::string Section;
   unsigned Alignment;
   std::string GC;
   GlobalValue::UnnamedAddr UnnamedAddr = GlobalValue::UnnamedAddr::None;
   LocTy UnnamedAddrLoc;
+  unsigned AddrSpace = DL.getProgramAddressSpace();
   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)) ||
bool LLParser::ParseFunctionHeader(Function *&Fn, bool isDefine) {
   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);
+    FunctionType::get(RetType, ParamTypeList, isVarArg, AddrSpace);
   PointerType *PFT = PointerType::getUnqual(FT);
 
   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()) {
bool LLParser::ParseInvoke(Instruction *&Inst, PerFunctionState &PFS) {
   unsigned CC;
   Type *RetType = nullptr;
   LocTy RetTypeLoc;
   ValID CalleeID;
   SmallVector<ParamInfo, 16> ArgList;
   SmallVector<OperandBundleDef, 2> BundleList;
 
   BasicBlock *NormalBB, *UnwindBB;
+
+  const DataLayout &DL = M->getDataLayout();
+
   if (ParseOptionalCallingConv(CC) || ParseOptionalReturnAttrs(RetAttrs) ||
       ParseType(RetType, RetTypeLoc, true /*void allowed*/) ||
       ParseValID(CalleeID) || ParseParameterList(ArgList, PFS) ||
       ParseFnAttributeValuePairs(FnAttrs, FwdRefAttrGrps, false,
                                  NoBuiltinLoc) ||
       ParseOptionalOperandBundles(BundleList, PFS) ||
       ParseToken(lltok::kw_to, "expected 'to' in invoke") ||
       ParseTypeAndBasicBlock(NormalBB, PFS) ||
if (!Ty) {
     // Pull out the types of all of the arguments...
     std::vector<Type*> ParamTypes;
     for (unsigned i = 0, e = ArgList.size(); i != e; ++i)
       ParamTypes.push_back(ArgList[i].V->getType());
 
     if (!FunctionType::isValidReturnType(RetType))
       return Error(RetTypeLoc, "Invalid result type for LLVM function");
 
-    Ty = FunctionType::get(RetType, ParamTypes, false);
+    Ty = FunctionType::get(RetType, ParamTypes, false,
+                           DL.getProgramAddressSpace());
   }
 
   CalleeID.FTy = Ty;
 
   // Look up the callee.
   Value *Callee;
   if (ConvertValIDToValue(PointerType::getUnqual(Ty), CalleeID, Callee, &PFS))
     return true;
bool LLParser::ParseCall(Instruction *&Inst, PerFunctionState &PFS,
   unsigned CC;
   Type *RetType = nullptr;
   LocTy RetTypeLoc;
   ValID CalleeID;
   SmallVector<ParamInfo, 16> ArgList;
   SmallVector<OperandBundleDef, 2> BundleList;
   LocTy CallLoc = Lex.getLoc();
 
+  const DataLayout &DL = M->getDataLayout();
+
   if (TCK != CallInst::TCK_None &&
       ParseToken(lltok::kw_call,
                  "expected 'tail call', 'musttail call', or 'notail call'"))
     return true;
 
   FastMathFlags FMF = EatFastMathFlagsIfPresent();
 
   if (ParseOptionalCallingConv(CC) || ParseOptionalReturnAttrs(RetAttrs) ||
if (!Ty) {
     // Pull out the types of all of the arguments...
     std::vector<Type*> ParamTypes;
     for (unsigned i = 0, e = ArgList.size(); i != e; ++i)
       ParamTypes.push_back(ArgList[i].V->getType());
 
     if (!FunctionType::isValidReturnType(RetType))
       return Error(RetTypeLoc, "Invalid result type for LLVM function");
 
-    Ty = FunctionType::get(RetType, ParamTypes, false);
+    Ty = FunctionType::get(RetType, ParamTypes, false,
+                           DL.getProgramAddressSpace());
   }
 
   CalleeID.FTy = Ty;
 
   // Look up the callee.
   Value *Callee;
   if (ConvertValIDToValue(PointerType::getUnqual(Ty), CalleeID, Callee, &PFS))
     return true;

lib/Bitcode/Reader/BitcodeReader.cpp

case bitc::TYPE_CODE_POINTER: { // POINTER: [pointee type] or
         AddressSpace = Record[1];
       ResultTy = getTypeByID(Record[0]);
       if (!ResultTy ||
           !PointerType::isValidElementType(ResultTy))
         return error("Invalid type");
       ResultTy = PointerType::get(ResultTy, AddressSpace);
       break;
     }
-    case bitc::TYPE_CODE_FUNCTION_OLD: {
+    case bitc::TYPE_CODE_FUNCTION_VERY_OLD: {
       // FIXME: attrid is dead, remove it in LLVM 4.0
-      // FUNCTION: [vararg, attrid, retty, paramty x N]
+      // FUNCTION_VERY_OLD: [vararg, attrid, retty, paramty x N]
       if (Record.size() < 3)
         return error("Invalid record");
       SmallVector<Type*, 8> ArgTys;
       for (unsigned i = 3, e = Record.size(); i != e; ++i) {
         if (Type *T = getTypeByID(Record[i]))
           ArgTys.push_back(T);
         else
           break;
       }
 
       ResultTy = getTypeByID(Record[2]);
       if (!ResultTy || ArgTys.size() < Record.size()-3)
         return error("Invalid type");
 
-      ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]);
+      // We can assume that address space is zero here because no backend
+      // supported non-default address spaces on functions prior to release 5.0.
+      unsigned AddrSpace = 0;
+      ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0], AddrSpace);
       break;
     }
-    case bitc::TYPE_CODE_FUNCTION: {
-      // FUNCTION: [vararg, retty, paramty x N]
+    case bitc::TYPE_CODE_FUNCTION_OLD: {
+      // FUNCTION_OLD: [vararg, retty, paramty x N]
       if (Record.size() < 2)
         return error("Invalid record");
       SmallVector<Type*, 8> ArgTys;
       for (unsigned i = 2, e = Record.size(); i != e; ++i) {
         if (Type *T = getTypeByID(Record[i])) {
           if (!FunctionType::isValidArgumentType(T))
             return error("Invalid function argument type");
           ArgTys.push_back(T);
         }
         else
           break;
       }
 
       ResultTy = getTypeByID(Record[1]);
       if (!ResultTy || ArgTys.size() < Record.size()-2)
         return error("Invalid type");
 
-      ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0]);
+      // FIXME: I don't think we can add this in a backwards compatible way
+      // without some digusting hack.
+      unsigned AddrSpace = 0;
+      ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0], AddrSpace);
+      break;
+    }
+    case bitc::TYPE_CODE_FUNCTION: {
+      // FUNCTION: [vararg, addrspace, retty, paramty x N]
+      if (Record.size() < 3)
+        return error("Invalid record");
+      SmallVector<Type*, 8> ArgTys;
+      for (unsigned i = 3, e = Record.size(); i != e; ++i) {
+        if (Type *T = getTypeByID(Record[i])) {
+          if (!FunctionType::isValidArgumentType(T))
+            return error("Invalid function argument type");
+          ArgTys.push_back(T);
+        }
+        else
+          break;
+      }
+
+      ResultTy = getTypeByID(Record[2]);
+      if (!ResultTy || ArgTys.size() < Record.size()-3)
+        return error("Invalid type");
+
+      unsigned AddrSpace = Record[1];
+      ResultTy = FunctionType::get(ResultTy, ArgTys, Record[0], AddrSpace);
       break;
     }
     case bitc::TYPE_CODE_STRUCT_ANON: {  // STRUCT: [ispacked, eltty x N]
       if (Record.size() < 1)
         return error("Invalid record");
       SmallVector<Type*, 8> EltTys;
       for (unsigned i = 1, e = Record.size(); i != e; ++i) {
         if (Type *T = getTypeByID(Record[i]))

lib/Bitcode/Writer/BitcodeWriter.cpp

case Type::PointerTyID: {
       TypeVals.push_back(VE.getTypeID(PTy->getElementType()));
       unsigned AddressSpace = PTy->getAddressSpace();
       TypeVals.push_back(AddressSpace);
       if (AddressSpace == 0) AbbrevToUse = PtrAbbrev;
       break;
     }
     case Type::FunctionTyID: {
       FunctionType *FT = cast<FunctionType>(T);
-      // FUNCTION: [isvararg, retty, paramty x N]
+      // FUNCTION: [isvararg, addrspace, retty, paramty x N]
       Code = bitc::TYPE_CODE_FUNCTION;
       TypeVals.push_back(FT->isVarArg());
+      TypeVals.push_back(FT->getAddressSpace());
       TypeVals.push_back(VE.getTypeID(FT->getReturnType()));
       for (unsigned i = 0, e = FT->getNumParams(); i != e; ++i)
         TypeVals.push_back(VE.getTypeID(FT->getParamType(i)));
       AbbrevToUse = FunctionAbbrev;
       break;
     }
     case Type::StructTyID: {
       StructType *ST = cast<StructType>(T);

lib/CodeGen/AtomicExpandPass.cpp

if (CASExpected) {
     ResultTy = SizedIntTy;
   else
     ResultTy = Type::getVoidTy(Ctx);
 
   // Done with setting up arguments and return types, create the call:
   SmallVector<Type *, 6> ArgTys;
   for (Value *Arg : Args)
     ArgTys.push_back(Arg->getType());
-  FunctionType *FnType = FunctionType::get(ResultTy, ArgTys, false);
+  FunctionType *FnType = FunctionType::get(ResultTy, ArgTys, false,
+                                           DL.getProgramAddressSpace());
   Constant *LibcallFn =
       M->getOrInsertFunction(TLI->getLibcallName(RTLibType), FnType, Attr);
   CallInst *Call = Builder.CreateCall(LibcallFn, Args);
   Call->setAttributes(Attr);
   Value *Result = Call;
 
   // And then, extract the results...
   if (ValueOperand && !UseSizedLibcall)

lib/CodeGen/IntrinsicLowering.cpp

 #include "llvm/Support/ErrorHandling.h"
 #include "llvm/Support/raw_ostream.h"
 using namespace llvm;
 
 template <class ArgIt>
 static void EnsureFunctionExists(Module &M, const char *Name,
                                  ArgIt ArgBegin, ArgIt ArgEnd,
                                  Type *RetTy) {
+  const auto &DL = M.getDataLayout();
   // Insert a correctly-typed definition now.
   std::vector<Type *> ParamTys;
   for (ArgIt I = ArgBegin; I != ArgEnd; ++I)
     ParamTys.push_back(I->getType());
-  M.getOrInsertFunction(Name, FunctionType::get(RetTy, ParamTys, false));
+  M.getOrInsertFunction(Name, FunctionType::get(RetTy, ParamTys, false,
+                                                DL.getProgramAddressSpace()));
 }
 
 static void EnsureFPIntrinsicsExist(Module &M, Function &Fn,
                                     const char *FName,
                                     const char *DName, const char *LDName) {
   // Insert definitions for all the floating point types.
   switch((int)Fn.arg_begin()->getType()->getTypeID()) {
   case Type::FloatTyID:

 /// prototype doesn't match the arguments we expect to pass in.
 template <class ArgIt>
 static CallInst *ReplaceCallWith(const char *NewFn, CallInst *CI,
                                  ArgIt ArgBegin, ArgIt ArgEnd,
                                  Type *RetTy) {
   // If we haven't already looked up this function, check to see if the
   // program already contains a function with this name.
   Module *M = CI->getModule();
+  const auto &DL = M->getDataLayout();
   // Get or insert the definition now.
   std::vector<Type *> ParamTys;
   for (ArgIt I = ArgBegin; I != ArgEnd; ++I)
     ParamTys.push_back((*I)->getType());
   Constant* FCache = M->getOrInsertFunction(NewFn,
-                                  FunctionType::get(RetTy, ParamTys, false));
+                              FunctionType::get(RetTy, ParamTys, false,
+                                                DL.getProgramAddressSpace()));
 
   IRBuilder<> Builder(CI->getParent(), CI->getIterator());
   SmallVector<Value *, 8> Args(ArgBegin, ArgEnd);
   CallInst *NewCI = Builder.CreateCall(FCache, Args);
   NewCI->setName(CI->getName());
   if (!CI->use_empty())
     CI->replaceAllUsesWith(NewCI);
   return NewCI;

lib/CodeGen/MIRParser/MIRParser.cpp

bool MIRParserImpl::parseMachineFunctions(Module &M, MachineModuleInfo &MMI) {
 
   return false;
 }
 
 /// Create an empty function with the given name.
 static Function *createDummyFunction(StringRef Name, Module &M) {
   auto &Context = M.getContext();
   Function *F = cast<Function>(M.getOrInsertFunction(
-      Name, FunctionType::get(Type::getVoidTy(Context), false)));
+      Name, FunctionType::get(Type::getVoidTy(Context), false,
+                              M.getDataLayout().getProgramAddressSpace())));
   BasicBlock *BB = BasicBlock::Create(Context, "entry", F);
   new UnreachableInst(Context, BB);
   return F;
 }
 
 bool MIRParserImpl::parseMachineFunction(Module &M, MachineModuleInfo &MMI) {
   // Parse the yaml.
   yaml::MachineFunction YamlMF;

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;
+  unsigned AddrSpace = FT->getAddressSpace();
+  if (AddrSpace != 0)
+    Out << " addrspace(" << AddrSpace << ")";
   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

case 'a': {
     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);
+      FunctionType* fType = FunctionType::get(F->getReturnType(), args, false,
+                                              F->getAddressSpace());
       NewFn = Function::Create(fType, F->getLinkage(),
                                "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);
+      FunctionType* fType = FunctionType::get(F->getReturnType(), Tys, false, F->getAddressSpace());
       NewFn = Function::Create(fType, F->getLinkage(),
                                "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,

lib/IR/Core.cpp

 }
 
 /*--.. Operations on function types ........................................--*/
 
 LLVMTypeRef LLVMFunctionType(LLVMTypeRef ReturnType,
                              LLVMTypeRef *ParamTypes, unsigned ParamCount,
                              LLVMBool IsVarArg) {
   ArrayRef<Type*> Tys(unwrap(ParamTypes), ParamCount);
-  return wrap(FunctionType::get(unwrap(ReturnType), Tys, IsVarArg != 0));
+  unsigned AddrSpace = 0; // FIXME
+  return wrap(FunctionType::get(unwrap(ReturnType), Tys, IsVarArg != 0, AddrSpace));
 }
 
 LLVMBool LLVMIsFunctionVarArg(LLVMTypeRef FunctionTy) {
   return unwrap<FunctionType>(FunctionTy)->isVarArg();
 }
 
 LLVMTypeRef LLVMGetReturnType(LLVMTypeRef FunctionTy) {
   return wrap(unwrap<FunctionType>(FunctionTy)->getReturnType());

lib/IR/DataLayout.cpp

 
 void DataLayout::reset(StringRef Desc) {
   clear();
 
   LayoutMap = nullptr;
   BigEndian = false;
   AllocaAddrSpace = 0;
   StackNaturalAlign = 0;
+  ProgramAddrSpace = 0;
   ManglingMode = MM_None;
   NonIntegralAddressSpaces.clear();
 
   // Default alignments
   for (const LayoutAlignElem &E : DefaultAlignments) {
     setAlignment((AlignTypeEnum)E.AlignType, E.ABIAlign, E.PrefAlign,
                  E.TypeBitWidth);
   }

 
 /// Convert bits into bytes. Assert if not a byte width multiple.
 static unsigned inBytes(unsigned Bits) {
   if (Bits % 8)
     report_fatal_error("number of bits must be a byte width multiple");
   return Bits / 8;
 }
 
+/// Gets an unsigned address space integer, including error checks.
+static unsigned int getAddrSpace(StringRef R) {
+  unsigned AddrSpace = getInt(R);
+  if (!isUInt<24>(AddrSpace))
+    report_fatal_error("Invalid address space, must be a 24-bit integer");
+  return AddrSpace;
+}
+
 void DataLayout::parseSpecifier(StringRef Desc) {
   StringRepresentation = Desc;
   while (!Desc.empty()) {
     // Split at '-'.
     std::pair<StringRef, StringRef> Split = split(Desc, '-');
     Desc = Split.second;
 
     // Split at ':'.
case 'n':  // Native integer types.
           break;
         Split = split(Rest, ':');
       }
       break;
     case 'S': { // Stack natural alignment.
       StackNaturalAlign = inBytes(getInt(Tok));
       break;
     }
+    case 'P': { // Function address space.
+      ProgramAddrSpace = getAddrSpace(Tok);
+      break;
+    }
     case 'A': { // Default stack/alloca address space.
-      AllocaAddrSpace = getInt(Tok);
-      if (!isUInt<24>(AllocaAddrSpace))
-        report_fatal_error("Invalid address space, must be a 24bit integer");
+      AllocaAddrSpace = getAddrSpace(Tok);
       break;
     }
     case 'm':
       if (!Tok.empty())
         report_fatal_error("Unexpected trailing characters after mangling specifier in datalayout string");
       if (Rest.empty())
         report_fatal_error("Expected mangling specifier in datalayout string");
       if (Rest.size() > 1)

lib/IR/Function.cpp

FunctionType *Intrinsic::getType(LLVMContext &Context,
 
   ArrayRef<IITDescriptor> TableRef = Table;
   Type *ResultTy = DecodeFixedType(TableRef, Tys, Context);
 
   SmallVector<Type*, 8> ArgTys;
   while (!TableRef.empty())
     ArgTys.push_back(DecodeFixedType(TableRef, Tys, Context));
 
+  unsigned AddrSpace = 0; // FIXME: we should grab the progmem space from DL
+
   // DecodeFixedType returns Void for IITDescriptor::Void and IITDescriptor::VarArg
   // If we see void type as the type of the last argument, it is vararg intrinsic
   if (!ArgTys.empty() && ArgTys.back()->isVoidTy()) {
     ArgTys.pop_back();
-    return FunctionType::get(ResultTy, ArgTys, true);
+    return FunctionType::get(ResultTy, ArgTys, true, AddrSpace);
   }
-  return FunctionType::get(ResultTy, ArgTys, false);
+  return FunctionType::get(ResultTy, ArgTys, false, AddrSpace);
 }
 
 bool Intrinsic::isOverloaded(ID id) {
 #define GET_INTRINSIC_OVERLOAD_TABLE
 #include "llvm/IR/Intrinsics.gen"
 #undef GET_INTRINSIC_OVERLOAD_TABLE
 }
 

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/Type.cpp

APInt IntegerType::getMask() const {
   return APInt::getAllOnesValue(getBitWidth());
 }
 
 //===----------------------------------------------------------------------===//
 //                       FunctionType Implementation
 //===----------------------------------------------------------------------===//
 
 FunctionType::FunctionType(Type *Result, ArrayRef<Type*> Params,
-                           bool IsVarArgs)
+                           bool IsVarArgs, unsigned AddrSpace)
   : Type(Result->getContext(), FunctionTyID) {
   Type **SubTys = reinterpret_cast<Type**>(this+1);
   assert(isValidReturnType(Result) && "invalid return type for function");
-  setSubclassData(IsVarArgs);
+
+  unsigned SubclassData = (IsVarArgs & 1) | (AddrSpace << 1);
+  setSubclassData(SubclassData);
 
   SubTys[0] = Result;
 
   for (unsigned i = 0, e = Params.size(); i != e; ++i) {
     assert(isValidArgumentType(Params[i]) &&
            "Not a valid type for function argument!");
     SubTys[i+1] = Params[i];
   }
 
   ContainedTys = SubTys;
   NumContainedTys = Params.size() + 1; // + 1 for result type
 }
 
 // This is the factory function for the FunctionType class.
 FunctionType *FunctionType::get(Type *ReturnType,
-                                ArrayRef<Type*> Params, bool isVarArg) {
+                                ArrayRef<Type*> Params, bool isVarArg, unsigned AddrSpace) {
   LLVMContextImpl *pImpl = ReturnType->getContext().pImpl;
   FunctionTypeKeyInfo::KeyTy Key(ReturnType, Params, isVarArg);
   auto I = pImpl->FunctionTypes.find_as(Key);
   FunctionType *FT;
 
   if (I == pImpl->FunctionTypes.end()) {
     FT = (FunctionType *)pImpl->TypeAllocator.Allocate(
         sizeof(FunctionType) + sizeof(Type *) * (Params.size() + 1),
         alignof(FunctionType));
-    new (FT) FunctionType(ReturnType, Params, isVarArg);
+    new (FT) FunctionType(ReturnType, Params, isVarArg, AddrSpace);
     pImpl->FunctionTypes.insert(FT);
   } else {
     FT = *I;
   }
 
   return FT;
 }
 
-FunctionType *FunctionType::get(Type *Result, bool isVarArg) {
-  return get(Result, None, isVarArg);
+FunctionType *FunctionType::get(Type *Result, bool isVarArg, unsigned AddrSpace) {
+  return get(Result, None, isVarArg, AddrSpace);
 }
 
 bool FunctionType::isValidReturnType(Type *RetTy) {
   return !RetTy->isFunctionTy() && !RetTy->isLabelTy() &&
   !RetTy->isMetadataTy();
 }
 
 bool FunctionType::isValidArgumentType(Type *ArgTy) {

lib/IR/Verifier.cpp

if (GV.hasName() && (GV.getName() == "llvm.global_ctors" ||
                        GV.getName() == "llvm.global_dtors")) {
     Assert(!GV.hasInitializer() || GV.hasAppendingLinkage(),
            "invalid linkage for intrinsic global variable", &GV);
     // Don't worry about emitting an error for it not being an array,
     // visitGlobalValue will complain on appending non-array.
     if (ArrayType *ATy = dyn_cast<ArrayType>(GV.getValueType())) {
       StructType *STy = dyn_cast<StructType>(ATy->getElementType());
       PointerType *FuncPtrTy =
-          FunctionType::get(Type::getVoidTy(Context), false)->getPointerTo();
+          FunctionType::get(Type::getVoidTy(Context), false,
+          // FIXME: we might want to grab the AddrSpace from the DL
+                            /*AddrSpace=*/ 0)->getPointerTo();
       // FIXME: Reject the 2-field form in LLVM 4.0.
       Assert(STy &&
                  (STy->getNumElements() == 2 || STy->getNumElements() == 3) &&
                  STy->getTypeAtIndex(0u)->isIntegerTy(32) &&
                  STy->getTypeAtIndex(1) == FuncPtrTy,
              "wrong type for intrinsic global variable", &GV);
       if (STy->getNumElements() == 3) {
         Type *ETy = STy->getTypeAtIndex(2);

lib/Linker/IRMover.cpp

case Type::ArrayTyID:
     return *Entry = ArrayType::get(ElementTypes[0],
                                    cast<ArrayType>(Ty)->getNumElements());
   case Type::VectorTyID:
     return *Entry = VectorType::get(ElementTypes[0],
                                     cast<VectorType>(Ty)->getNumElements());
   case Type::PointerTyID:
     return *Entry = PointerType::get(ElementTypes[0],
                                      cast<PointerType>(Ty)->getAddressSpace());
-  case Type::FunctionTyID:
+  case Type::FunctionTyID: {
+    auto *FTy = cast<FunctionType>(Ty);
     return *Entry = FunctionType::get(ElementTypes[0],
                                       makeArrayRef(ElementTypes).slice(1),
-                                      cast<FunctionType>(Ty)->isVarArg());
+                                      FTy->isVarArg(),
+                                      FTy->getAddressSpace());
+  }
   case Type::StructTyID: {
     auto *STy = cast<StructType>(Ty);
     bool IsPacked = STy->isPacked();
     if (IsUniqued)
       return *Entry = StructType::get(Ty->getContext(), ElementTypes, IsPacked);
 
     // If the type is opaque, we can just use it directly.
     if (STy->isOpaque()) {

lib/Target/AMDGPU/AMDGPULibFunc.cpp

FunctionType* AMDGPULibFunc::getFunctionType(Module& M) const {
   std::vector<Type*> Args;
   ParamIterator I(Leads, manglingRules[FuncId]);
   Param P;
   while ((P=I.getNextParam()).ArgType != 0)
     Args.push_back(getIntrinsicParamType(C, P, true));
 
   return FunctionType::get(
     getIntrinsicParamType(C, getRetType(FuncId, Leads), true),
-    Args, false);
+    Args, false, M.getDataLayout().getProgramAddressSpace());
 }
 
 unsigned AMDGPULibFunc::getNumArgs() const {
   return manglingRules[FuncId].getNumArgs();
 }
 
 std::string AMDGPULibFunc::getName() const {
   SmallString<128> Buf;

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 NewFT = FunctionType::get(FT->getReturnType(), ArgTypes, false,
+                                   FT->getAddressSpace());
     auto NewF = Function::Create(NewFT, F->getLinkage(), 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()))) {

lib/Target/AMDGPU/AMDGPURewriteOutArguments.cpp

bool AMDGPURewriteOutArguments::runOnFunction(Function &F) {
   if (Replacements.empty())
     return false;
 
   LLVMContext &Ctx = F.getParent()->getContext();
   StructType *NewRetTy = StructType::create(Ctx, ReturnTypes, F.getName());
 
   FunctionType *NewFuncTy = FunctionType::get(NewRetTy,
                                               F.getFunctionType()->params(),
-                                              F.isVarArg());
+                                              F.isVarArg(),
+                                              F.getAddressSpace());
 
   DEBUG(dbgs() << "Computed new return type: " << *NewRetTy << '\n');
 
   Function *NewFunc = Function::Create(NewFuncTy, Function::PrivateLinkage,
                                        F.getName() + ".body");
   F.getParent()->getFunctionList().insert(F.getIterator(), NewFunc);
   NewFunc->copyAttributesFrom(&F);
   NewFunc->setComdat(F.getComdat());

lib/Target/AVR/AVRTargetMachine.cpp

 #include "llvm/Support/TargetRegistry.h"
 
 #include "AVR.h"
 #include "AVRTargetObjectFile.h"
 #include "MCTargetDesc/AVRMCTargetDesc.h"
 
 namespace llvm {
 
-static const char *AVRDataLayout = "e-p:16:16:16-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-n8";
+static const char *AVRDataLayout = "e-p:16:16:16-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-n8-P1";
 
 /// Processes a CPU name.
 static StringRef getCPU(StringRef CPU) {
   if (CPU.empty() || CPU == "generic") {
     return "avr2";
   }
 
   return CPU;

lib/Target/Mips/Mips16HardFloat.cpp

 
 } // end anonymous namespace
 
 static void EmitInlineAsm(LLVMContext &C, BasicBlock *BB, StringRef AsmText) {
   std::vector<Type *> AsmArgTypes;
   std::vector<Value *> AsmArgs;
 
   FunctionType *AsmFTy =
-      FunctionType::get(Type::getVoidTy(C), AsmArgTypes, false);
+      FunctionType::get(Type::getVoidTy(C), AsmArgTypes, false,
+                     BB->getModule()->getDataLayout().getProgramAddressSpace());
   InlineAsm *IA = InlineAsm::get(AsmFTy, AsmText, "", true,
                                  /* IsAlignStack */ false, InlineAsm::AD_ATT);
   CallInst::Create(IA, AsmArgs, "", BB);
 }
 
 char Mips16HardFloat::ID = 0;
 
 //

lib/Target/X86/X86WinEHState.cpp

bool WinEHStatePass::runOnFunction(Function &F) {
   if (!HasPads)
     return false;
 
   Type *Int8PtrType = Type::getInt8PtrTy(TheModule->getContext());
   SetJmp3 = TheModule->getOrInsertFunction(
       "_setjmp3", FunctionType::get(
                       Type::getInt32Ty(TheModule->getContext()),
                       {Int8PtrType, Type::getInt32Ty(TheModule->getContext())},
-                      /*isVarArg=*/true));
+                      /*isVarArg=*/true,
+                      TheModule->getDataLayout().getProgramAddressSpace()));
 
   // Disable frame pointer elimination in this function.
   // FIXME: Do the nested handlers need to keep the parent ebp in ebp, or can we
   // use an arbitrary register?
   F.addFnAttr("no-frame-pointer-elim", "true");
 
   emitExceptionRegistrationRecord(&F);
 
if (Personality == EHPersonality::MSVC_CXX) {
     insertStateNumberStore(&*Builder.GetInsertPoint(), ParentBaseState);
     // Handler = __ehhandler$F
     Function *Trampoline = generateLSDAInEAXThunk(F);
     Link = Builder.CreateStructGEP(RegNodeTy, RegNode, 1);
     linkExceptionRegistration(Builder, Trampoline);
 
     CxxLongjmpUnwind = TheModule->getOrInsertFunction(
         "__CxxLongjmpUnwind",
-        FunctionType::get(VoidTy, Int8PtrType, /*isVarArg=*/false));
+        FunctionType::get(VoidTy, Int8PtrType, /*isVarArg=*/false,
+                          TheModule->getDataLayout().getProgramAddressSpace()));
     cast<Function>(CxxLongjmpUnwind->stripPointerCasts())
         ->setCallingConv(CallingConv::X86_StdCall);
   } else if (Personality == EHPersonality::MSVC_X86SEH) {
     // If _except_handler4 is in use, some additional guard checks and prologue
     // stuff is required.
     StringRef PersonalityName = PersonalityFn->getName();
     UseStackGuard = (PersonalityName == "_except_handler4");
 

 /// PersonalityFn, forwarding the parameters passed to PEXCEPTION_ROUTINE:
 ///   typedef _EXCEPTION_DISPOSITION (*PEXCEPTION_ROUTINE)(
 ///       _EXCEPTION_RECORD *, void *, _CONTEXT *, void *);
 /// We essentially want this code:
 ///   movl $lsda, %eax
 ///   jmpl ___CxxFrameHandler3
 Function *WinEHStatePass::generateLSDAInEAXThunk(Function *ParentFunc) {
   LLVMContext &Context = ParentFunc->getContext();
+  const auto &DL = ParentFunc->getParent()->getDataLayout();
   Type *Int32Ty = Type::getInt32Ty(Context);
   Type *Int8PtrType = Type::getInt8PtrTy(Context);
   Type *ArgTys[5] = {Int8PtrType, Int8PtrType, Int8PtrType, Int8PtrType,
                      Int8PtrType};
   FunctionType *TrampolineTy =
       FunctionType::get(Int32Ty, makeArrayRef(&ArgTys[0], 4),
-                        /*isVarArg=*/false);
+                        /*isVarArg=*/false, DL.getProgramAddressSpace());
   FunctionType *TargetFuncTy =
       FunctionType::get(Int32Ty, makeArrayRef(&ArgTys[0], 5),
-                        /*isVarArg=*/false);
+                        /*isVarArg=*/false, DL.getProgramAddressSpace());
   Function *Trampoline =
       Function::Create(TrampolineTy, GlobalValue::InternalLinkage,
                        Twine("__ehhandler$") + GlobalValue::dropLLVMManglingEscape(
                                                    ParentFunc->getName()),
                        TheModule);
   BasicBlock *EntryBB = BasicBlock::Create(Context, "entry", Trampoline);
   IRBuilder<> Builder(EntryBB);
   Value *LSDA = emitEHLSDA(Builder, ParentFunc);

lib/Transforms/IPO/ArgumentPromotion.cpp

if (ByValArgsToTransform.count(&*I)) {
       else
         ++NumAggregatesPromoted;
     }
   }
 
   Type *RetTy = FTy->getReturnType();
 
   // Construct the new function type using the new arguments.
-  FunctionType *NFTy = FunctionType::get(RetTy, Params, FTy->isVarArg());
+  FunctionType *NFTy = FunctionType::get(RetTy, Params, FTy->isVarArg(),
+                                         FTy->getAddressSpace());
 
   // Create the new function body and insert it into the module.
   Function *NF = Function::Create(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);

lib/Transforms/IPO/DeadArgumentElimination.cpp

bool DeadArgumentEliminationPass::DeleteDeadVarargs(Function &Fn) {
   // remove the "..." and adjust all the calls.
 
   // Start by computing a new prototype for the function, which is the same as
   // the old function, but doesn't have isVarArg set.
   FunctionType *FTy = Fn.getFunctionType();
 
   std::vector<Type*> Params(FTy->param_begin(), FTy->param_end());
   FunctionType *NFTy = FunctionType::get(FTy->getReturnType(),
-                                                Params, false);
+                                         Params, false,
+                                         FTy->getAddressSpace());
   unsigned NumArgs = Params.size();
 
   // Create the new function body and insert it into the module...
   Function *NF = Function::Create(NFTy, Fn.getLinkage());
   NF->copyAttributesFrom(&Fn);
   NF->setComdat(Fn.getComdat());
   Fn.getParent()->getFunctionList().insert(Fn.getIterator(), NF);
   NF->takeName(&Fn);
bool DeadArgumentEliminationPass::RemoveDeadStuffFromFunction(Function *F) {
   AttributeSet RetAttrs = AttributeSet::get(F->getContext(), RAttrs);
 
   // Reconstruct the AttributesList based on the vector we constructed.
   assert(ArgAttrVec.size() == Params.size());
   AttributeList NewPAL = AttributeList::get(
       F->getContext(), PAL.getFnAttributes(), RetAttrs, ArgAttrVec);
 
   // Create the new function type based on the recomputed parameters.
-  FunctionType *NFTy = FunctionType::get(NRetTy, Params, FTy->isVarArg());
+  FunctionType *NFTy = FunctionType::get(NRetTy, Params, FTy->isVarArg(),
+                                         FTy->getAddressSpace());
 
   // 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());
   NF->copyAttributesFrom(F);

lib/Transforms/IPO/LowerTypeTests.cpp

public:
   }
   ArrayRef<MDNode *> types() const {
     return makeArrayRef(getTrailingObjects<MDNode *>(), NTypes);
   }
 };
 
 class LowerTypeTestsModule {
   Module &M;
+  const DataLayout &DL;
 
   ModuleSummaryIndex *ExportSummary;
   const ModuleSummaryIndex *ImportSummary;
 
   Triple::ArchType Arch;
   Triple::OSType OS;
   Triple::ObjectFormatType ObjectFormat;
 
else
     report_fatal_error("Unsupported architecture for jump tables");
 }
 
 void LowerTypeTestsModule::moveInitializerToModuleConstructor(
     GlobalVariable *GV) {
   if (WeakInitializerFn == nullptr) {
     WeakInitializerFn = Function::Create(
         FunctionType::get(Type::getVoidTy(M.getContext()),
-                          /* IsVarArg */ false),
+                          /* IsVarArg */ false, DL.getProgramAddressSpace()),
         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");
void LowerTypeTestsModule::createJumpTable(
   BasicBlock *BB = BasicBlock::Create(M.getContext(), "entry", F);
   IRBuilder<> IRB(BB);
 
   SmallVector<Type *, 16> ArgTypes;
   ArgTypes.reserve(AsmArgs.size());
   for (const auto &Arg : AsmArgs)
     ArgTypes.push_back(Arg->getType());
   InlineAsm *JumpTableAsm =
-      InlineAsm::get(FunctionType::get(IRB.getVoidTy(), ArgTypes, false),
+      InlineAsm::get(FunctionType::get(IRB.getVoidTy(), ArgTypes, false,
+                                       DL.getProgramAddressSpace()),
                      AsmOS.str(), ConstraintOS.str(),
                      /*hasSideEffects=*/true);
 
   IRB.CreateCall(JumpTableAsm, AsmArgs);
   IRB.CreateUnreachable();
 }
 
 /// Given a disjoint set of type identifiers and functions, build a jump table
void LowerTypeTestsModule::buildBitSetsFromFunctionsNative(
   // Build a simple layout based on the regular layout of jump tables.
   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),
+                                         /* IsVarArg */ false,
+                                         DL.getProgramAddressSpace()),
                        GlobalValue::PrivateLinkage, ".cfi.jumptable", &M);
   ArrayType *JumpTableType =
       ArrayType::get(getJumpTableEntryType(), Functions.size());
   auto JumpTable =
       ConstantExpr::getPointerCast(JumpTableFn, JumpTableType->getPointerTo(0));
 
   lowerTypeTestCalls(TypeIds, JumpTable, GlobalLayout);
 
if (Globals.empty() || isa<GlobalVariable>(Globals[0]->getGlobal())) {
     buildBitSetsFromFunctions(TypeIds, OrderedFns);
   }
 }
 
 /// Lower all type tests in this module.
 LowerTypeTestsModule::LowerTypeTestsModule(
     Module &M, ModuleSummaryIndex *ExportSummary,
     const ModuleSummaryIndex *ImportSummary)
-    : M(M), ExportSummary(ExportSummary), ImportSummary(ImportSummary) {
+    : M(M), DL(M.getDataLayout()), ExportSummary(ExportSummary),
+      ImportSummary(ImportSummary) {
   assert(!(ExportSummary && ImportSummary));
   Triple TargetTriple(M.getTargetTriple());
   Arch = TargetTriple.getArch();
   OS = TargetTriple.getOS();
   ObjectFormat = TargetTriple.getObjectFormat();
 }
 
 bool LowerTypeTestsModule::runForTesting(Module &M) {
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),
+              FunctionType::get(Type::getVoidTy(M.getContext()), false,
+                                DL.getProgramAddressSpace()),
               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()) {

lib/Transforms/IPO/ThinLTOBitcodeWriter.cpp

for (GlobalObject &GO : M.global_objects()) {
     }
   }
 }
 
 // Drop unused globals, and drop type information from function declarations.
 // FIXME: If we made functions typeless then there would be no need to do this.
 void simplifyExternals(Module &M) {
   FunctionType *EmptyFT =
-      FunctionType::get(Type::getVoidTy(M.getContext()), false);
+      FunctionType::get(Type::getVoidTy(M.getContext()), false,
+                        M.getDataLayout().getProgramAddressSpace());
 
   for (auto I = M.begin(), E = M.end(); I != E;) {
     Function &F = *I++;
     if (F.isDeclaration() && F.use_empty()) {
       F.eraseFromParent();
       continue;
     }
 

lib/Transforms/InstCombine/InstCombineCalls.cpp

if (NestTy) {
           ++ArgNo;
           ++I;
         } while (true);
       }
 
       // Replace the trampoline call with a direct call.  Let the generic
       // code sort out any function type mismatches.
       FunctionType *NewFTy = FunctionType::get(FTy->getReturnType(), NewTypes,
-                                                FTy->isVarArg());
+                                                FTy->isVarArg(),
+                                                FTy->getAddressSpace());
       Constant *NewCallee =
         NestF->getType() == PointerType::getUnqual(NewFTy) ?
         NestF : ConstantExpr::getBitCast(NestF,
                                          PointerType::getUnqual(NewFTy));
       AttributeList NewPAL =
           AttributeList::get(FTy->getContext(), Attrs.getFnAttributes(),
                              Attrs.getRetAttributes(), NewArgAttrs);
 

lib/Transforms/Instrumentation/AddressSanitizer.cpp

AddressSanitizerModule::CreateMetadataGlobal(Module &M, Constant *Initializer,
   GlobalVariable *Metadata = new GlobalVariable(
       M, Initializer->getType(), false, Linkage, Initializer,
       Twine("__asan_global_") + GlobalValue::dropLLVMManglingEscape(OriginalName));
   Metadata->setSection(getGlobalMetadataSection());
   return Metadata;
 }
 
 IRBuilder<> AddressSanitizerModule::CreateAsanModuleDtor(Module &M) {
+  unsigned AddrSpace = M.getDataLayout().getProgramAddressSpace();
+
   AsanDtorFunction =
-      Function::Create(FunctionType::get(Type::getVoidTy(*C), false),
+      Function::Create(FunctionType::get(Type::getVoidTy(*C), false, AddrSpace),
                        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,
if (AsanDtorFunction)
       appendToGlobalDtors(M, AsanDtorFunction, kAsanCtorAndDtorPriority);
   }
 
   return Changed;
 }
 
 void AddressSanitizer::initializeCallbacks(Module &M) {
   IRBuilder<> IRB(*C);
+
+  unsigned AddrSpace = M.getDataLayout().getProgramAddressSpace();
+
   // Create __asan_report* callbacks.
   // IsWrite, TypeSize and Exp are encoded in the function name.
   for (int Exp = 0; Exp < 2; Exp++) {
     for (size_t AccessIsWrite = 0; AccessIsWrite <= 1; AccessIsWrite++) {
       const std::string TypeStr = AccessIsWrite ? "store" : "load";
       const std::string ExpStr = Exp ? "exp_" : "";
       const std::string SuffixStr = CompileKernel ? "N" : "_n";
       const std::string EndingStr = Recover ? "_noabort" : "";
 
       SmallVector<Type *, 3> Args2 = {IntptrTy, IntptrTy};
       SmallVector<Type *, 2> Args1{1, IntptrTy};
       if (Exp) {
         Type *ExpType = Type::getInt32Ty(*C);
         Args2.push_back(ExpType);
         Args1.push_back(ExpType);
       }
       AsanErrorCallbackSized[AccessIsWrite][Exp] =
           checkSanitizerInterfaceFunction(M.getOrInsertFunction(
               kAsanReportErrorTemplate + ExpStr + TypeStr + SuffixStr +
                   EndingStr,
-              FunctionType::get(IRB.getVoidTy(), Args2, false)));
+              FunctionType::get(IRB.getVoidTy(), Args2, false, AddrSpace)));
 
       AsanMemoryAccessCallbackSized[AccessIsWrite][Exp] =
           checkSanitizerInterfaceFunction(M.getOrInsertFunction(
               ClMemoryAccessCallbackPrefix + ExpStr + TypeStr + "N" + EndingStr,
-              FunctionType::get(IRB.getVoidTy(), Args2, false)));
+              FunctionType::get(IRB.getVoidTy(), Args2, false, AddrSpace)));
 
       for (size_t AccessSizeIndex = 0; AccessSizeIndex < kNumberOfAccessSizes;
            AccessSizeIndex++) {
         const std::string Suffix = TypeStr + itostr(1ULL << AccessSizeIndex);
         AsanErrorCallback[AccessIsWrite][Exp][AccessSizeIndex] =
             checkSanitizerInterfaceFunction(M.getOrInsertFunction(
                 kAsanReportErrorTemplate + ExpStr + Suffix + EndingStr,
-                FunctionType::get(IRB.getVoidTy(), Args1, false)));
+                FunctionType::get(IRB.getVoidTy(), Args1, false, AddrSpace)));
 
         AsanMemoryAccessCallback[AccessIsWrite][Exp][AccessSizeIndex] =
             checkSanitizerInterfaceFunction(M.getOrInsertFunction(
                 ClMemoryAccessCallbackPrefix + ExpStr + Suffix + EndingStr,
-                FunctionType::get(IRB.getVoidTy(), Args1, false)));
+                FunctionType::get(IRB.getVoidTy(), Args1, false, AddrSpace)));
       }
     }
   }
 
   const std::string MemIntrinCallbackPrefix =
       CompileKernel ? std::string("") : ClMemoryAccessCallbackPrefix;
   AsanMemmove = checkSanitizerInterfaceFunction(M.getOrInsertFunction(
       MemIntrinCallbackPrefix + "memmove", IRB.getInt8PtrTy(),
       IRB.getInt8PtrTy(), IRB.getInt8PtrTy(), IntptrTy));
   AsanMemcpy = checkSanitizerInterfaceFunction(M.getOrInsertFunction(
       MemIntrinCallbackPrefix + "memcpy", IRB.getInt8PtrTy(),
       IRB.getInt8PtrTy(), IRB.getInt8PtrTy(), IntptrTy));
   AsanMemset = checkSanitizerInterfaceFunction(M.getOrInsertFunction(
       MemIntrinCallbackPrefix + "memset", IRB.getInt8PtrTy(),
       IRB.getInt8PtrTy(), IRB.getInt32Ty(), IntptrTy));
 
   AsanHandleNoReturnFunc = checkSanitizerInterfaceFunction(
       M.getOrInsertFunction(kAsanHandleNoReturnName, IRB.getVoidTy()));
 
   AsanPtrCmpFunction = checkSanitizerInterfaceFunction(M.getOrInsertFunction(
       kAsanPtrCmp, IRB.getVoidTy(), IntptrTy, IntptrTy));
   AsanPtrSubFunction = checkSanitizerInterfaceFunction(M.getOrInsertFunction(
       kAsanPtrSub, IRB.getVoidTy(), IntptrTy, IntptrTy));
   // We insert an empty inline asm after __asan_report* to avoid callback merge.
-  EmptyAsm = InlineAsm::get(FunctionType::get(IRB.getVoidTy(), false),
+  EmptyAsm = InlineAsm::get(FunctionType::get(IRB.getVoidTy(), false, AddrSpace),
                             StringRef(""), StringRef(""),
                             /*hasSideEffects=*/true);
 }
 
 // virtual
 bool AddressSanitizer::doInitialization(Module &M) {
   // Initialize the private fields. No one has accessed them before.
   GlobalsMD.init(M);

lib/Transforms/Instrumentation/DataFlowSanitizer.cpp

 FunctionType *DataFlowSanitizer::getArgsFunctionType(FunctionType *T) {
   llvm::SmallVector<Type *, 4> ArgTypes(T->param_begin(), T->param_end());
   ArgTypes.append(T->getNumParams(), ShadowTy);
   if (T->isVarArg())
     ArgTypes.push_back(ShadowPtrTy);
   Type *RetType = T->getReturnType();
   if (!RetType->isVoidTy())
     RetType = StructType::get(RetType, ShadowTy);
-  return FunctionType::get(RetType, ArgTypes, T->isVarArg());
+  return FunctionType::get(RetType, ArgTypes, T->isVarArg(),
+                           T->getAddressSpace());
 }
 
 FunctionType *DataFlowSanitizer::getTrampolineFunctionType(FunctionType *T) {
   assert(!T->isVarArg());
   llvm::SmallVector<Type *, 4> ArgTypes;
   ArgTypes.push_back(T->getPointerTo());
   ArgTypes.append(T->param_begin(), T->param_end());
   ArgTypes.append(T->getNumParams(), ShadowTy);
   Type *RetType = T->getReturnType();
   if (!RetType->isVoidTy())
     ArgTypes.push_back(ShadowPtrTy);
-  return FunctionType::get(T->getReturnType(), ArgTypes, false);
+  return FunctionType::get(T->getReturnType(), ArgTypes, false,
+                           T->getAddressSpace());
 }
 
 FunctionType *DataFlowSanitizer::getCustomFunctionType(FunctionType *T) {
   llvm::SmallVector<Type *, 4> ArgTypes;
   for (FunctionType::param_iterator i = T->param_begin(), e = T->param_end();
        i != e; ++i) {
     FunctionType *FT;
     if (isa<PointerType>(*i) && (FT = dyn_cast<FunctionType>(cast<PointerType>(
                                      *i)->getElementType()))) {
       ArgTypes.push_back(getTrampolineFunctionType(FT)->getPointerTo());
       ArgTypes.push_back(Type::getInt8PtrTy(*Ctx));
     } else {
       ArgTypes.push_back(*i);
     }
   }
   for (unsigned i = 0, e = T->getNumParams(); i != e; ++i)
     ArgTypes.push_back(ShadowTy);
   if (T->isVarArg())
     ArgTypes.push_back(ShadowPtrTy);
   Type *RetType = T->getReturnType();
   if (!RetType->isVoidTy())
     ArgTypes.push_back(ShadowPtrTy);
-  return FunctionType::get(T->getReturnType(), ArgTypes, T->isVarArg());
+  return FunctionType::get(T->getReturnType(), ArgTypes, T->isVarArg(),
+                           T->getAddressSpace());
 }
 
 bool DataFlowSanitizer::doInitialization(Module &M) {
   llvm::Triple TargetTriple(M.getTargetTriple());
   bool IsX86_64 = TargetTriple.getArch() == llvm::Triple::x86_64;
   bool IsMIPS64 = TargetTriple.getArch() == llvm::Triple::mips64 ||
                   TargetTriple.getArch() == llvm::Triple::mips64el;
   bool IsAArch64 = TargetTriple.getArch() == llvm::Triple::aarch64 ||
bool DataFlowSanitizer::doInitialization(Module &M) {
   // AArch64 supports multiple VMAs and the shadow mask is set at runtime.
   else if (IsAArch64)
     DFSanRuntimeShadowMask = true;
   else
     report_fatal_error("unsupported triple");
 
   Type *DFSanUnionArgs[2] = { ShadowTy, ShadowTy };
   DFSanUnionFnTy =
-      FunctionType::get(ShadowTy, DFSanUnionArgs, /*isVarArg=*/ false);
+      FunctionType::get(ShadowTy, DFSanUnionArgs, /*isVarArg=*/ false,
+                        DL.getProgramAddressSpace());
   Type *DFSanUnionLoadArgs[2] = { ShadowPtrTy, IntptrTy };
   DFSanUnionLoadFnTy =
-      FunctionType::get(ShadowTy, DFSanUnionLoadArgs, /*isVarArg=*/ false);
+      FunctionType::get(ShadowTy, DFSanUnionLoadArgs, /*isVarArg=*/ false,
+                        DL.getProgramAddressSpace());
   DFSanUnimplementedFnTy = FunctionType::get(
-      Type::getVoidTy(*Ctx), Type::getInt8PtrTy(*Ctx), /*isVarArg=*/false);
+      Type::getVoidTy(*Ctx), Type::getInt8PtrTy(*Ctx), /*isVarArg=*/false,
+      DL.getProgramAddressSpace());
   Type *DFSanSetLabelArgs[3] = { ShadowTy, Type::getInt8PtrTy(*Ctx), IntptrTy };
   DFSanSetLabelFnTy = FunctionType::get(Type::getVoidTy(*Ctx),
-                                        DFSanSetLabelArgs, /*isVarArg=*/false);
+                                        DFSanSetLabelArgs, /*isVarArg=*/false,
+                                        DL.getProgramAddressSpace());
   DFSanNonzeroLabelFnTy = FunctionType::get(
-      Type::getVoidTy(*Ctx), None, /*isVarArg=*/false);
+      Type::getVoidTy(*Ctx), None, /*isVarArg=*/false,
+      DL.getProgramAddressSpace());
   DFSanVarargWrapperFnTy = FunctionType::get(
-      Type::getVoidTy(*Ctx), Type::getInt8PtrTy(*Ctx), /*isVarArg=*/false);
+      Type::getVoidTy(*Ctx), Type::getInt8PtrTy(*Ctx), /*isVarArg=*/false,
+      DL.getProgramAddressSpace());
 
   if (GetArgTLSPtr) {
     Type *ArgTLSTy = ArrayType::get(ShadowTy, 64);
     ArgTLS = nullptr;
     GetArgTLS = ConstantExpr::getIntToPtr(
         ConstantInt::get(IntptrTy, uintptr_t(GetArgTLSPtr)),
         PointerType::getUnqual(
-            FunctionType::get(PointerType::getUnqual(ArgTLSTy), false)));
+            FunctionType::get(PointerType::getUnqual(ArgTLSTy), false,
+                              DL.getProgramAddressSpace())));
   }
   if (GetRetvalTLSPtr) {
     RetvalTLS = nullptr;
     GetRetvalTLS = ConstantExpr::getIntToPtr(
         ConstantInt::get(IntptrTy, uintptr_t(GetRetvalTLSPtr)),
         PointerType::getUnqual(
-            FunctionType::get(PointerType::getUnqual(ShadowTy), false)));
+            FunctionType::get(PointerType::getUnqual(ShadowTy), false,
+                              DL.getProgramAddressSpace())));
   }
 
   ColdCallWeights = MDBuilder(*Ctx).createBranchWeights(1, 1000);
   return true;
 }
 
 bool DataFlowSanitizer::isInstrumented(const Function *F) {
   return !ABIList.isIn(*F, "uninstrumented");

lib/Transforms/Instrumentation/EfficiencySanitizer.cpp

Constant *EfficiencySanitizer::createEsanInitToolInfoArg(Module &M,
   if (ToolInfoGV != nullptr)
     return ConstantExpr::getPointerCast(ToolInfoGV, Int8PtrTy);
 
   // Create the null pointer if no tool-specific variable created.
   return ConstantPointerNull::get(Int8PtrTy);
 }
 
 void EfficiencySanitizer::createDestructor(Module &M, Constant *ToolInfoArg) {
+  const auto &DL = M.getDataLayout();
+
   PointerType *Int8PtrTy = Type::getInt8PtrTy(*Ctx);
-  EsanDtorFunction = Function::Create(FunctionType::get(Type::getVoidTy(*Ctx),
-                                                        false),
-                                      GlobalValue::InternalLinkage,
+  auto *FTy = FunctionType::get(Type::getVoidTy(*Ctx), false,
+                                DL.getProgramAddressSpace());
+  EsanDtorFunction = Function::Create(FTy, GlobalValue::InternalLinkage,
                                       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});

lib/Transforms/Instrumentation/GCOVProfiling.cpp

private:
   GCOVOptions Options;
 
   // Reversed, NUL-terminated copy of Options.Version.
   char ReversedVersion[5];
   // Checksum, produced by hash of EdgeDestinations
   SmallVector<uint32_t, 4> FileChecksums;
 
   Module *M;
+  const DataLayout *DL;
   LLVMContext *Ctx;
   SmallVector<std::unique_ptr<GCOVFunction>, 16> Funcs;
 };
 
 class GCOVProfilerLegacyPass : public ModulePass {
 public:
   static char ID;
   GCOVProfilerLegacyPass()
std::string GCOVProfiler::mangleName(const DICompileUnit *CU,
   SmallString<128> CurPath;
   if (sys::fs::current_path(CurPath)) return FName;
   sys::path::append(CurPath, FName);
   return CurPath.str();
 }
 
 bool GCOVProfiler::runOnModule(Module &M) {
   this->M = &M;
-  Ctx = &M.getContext();
+  this->Ctx = &M.getContext();
+  this->DL = &M.getDataLayout();
 
   if (Options.EmitNotes) emitProfileNotes();
   if (Options.EmitData) return emitProfileArcs();
   return false;
 }
 
 PreservedAnalyses GCOVProfilerPass::run(Module &M,
                                         ModuleAnalysisManager &AM) {
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);
+    FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), false,
+                                          DL->getProgramAddressSpace());
     Function *F = Function::Create(FTy, GlobalValue::InternalLinkage,
                                    "__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);
 
-    FTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
+    FTy = FunctionType::get(Type::getVoidTy(*Ctx), false,
+                            DL->getProgramAddressSpace());
     Type *Params[] = {
       PointerType::get(FTy, 0),
       PointerType::get(FTy, 0)
     };
-    FTy = FunctionType::get(Builder.getVoidTy(), Params, false);
+    FTy = FunctionType::get(Builder.getVoidTy(), Params, false,
+                            DL->getProgramAddressSpace());
 
     // Initialize the environment and register the local writeout and flush
     // functions.
     Constant *GCOVInit = M->getOrInsertFunction("llvm_gcov_init", FTy);
     Builder.CreateCall(GCOVInit, {WriteoutF, FlushF});
     Builder.CreateRetVoid();
 
     appendToGlobalCtors(*M, F, 0);

 }
 
 Constant *GCOVProfiler::getStartFileFunc() {
   Type *Args[] = {
     Type::getInt8PtrTy(*Ctx),  // const char *orig_filename
     Type::getInt8PtrTy(*Ctx),  // const char version[4]
     Type::getInt32Ty(*Ctx),    // uint32_t checksum
   };
-  FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), Args, false);
+  FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), Args, false,
+                                        DL->getProgramAddressSpace());
   return M->getOrInsertFunction("llvm_gcda_start_file", FTy);
 }
 
 Constant *GCOVProfiler::getIncrementIndirectCounterFunc() {
   Type *Int32Ty = Type::getInt32Ty(*Ctx);
   Type *Int64Ty = Type::getInt64Ty(*Ctx);
   Type *Args[] = {
     Int32Ty->getPointerTo(),                // uint32_t *predecessor
     Int64Ty->getPointerTo()->getPointerTo() // uint64_t **counters
   };
-  FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), Args, false);
+  FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), Args, false,
+                                        DL->getProgramAddressSpace());
   return M->getOrInsertFunction("__llvm_gcov_indirect_counter_increment", FTy);
 }
 
 Constant *GCOVProfiler::getEmitFunctionFunc() {
   Type *Args[] = {
     Type::getInt32Ty(*Ctx),    // uint32_t ident
     Type::getInt8PtrTy(*Ctx),  // const char *function_name
     Type::getInt32Ty(*Ctx),    // uint32_t func_checksum
     Type::getInt8Ty(*Ctx),     // uint8_t use_extra_checksum
     Type::getInt32Ty(*Ctx),    // uint32_t cfg_checksum
   };
-  FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), Args, false);
+  FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), Args, false,
+                                        DL->getProgramAddressSpace());
   return M->getOrInsertFunction("llvm_gcda_emit_function", FTy);
 }
 
 Constant *GCOVProfiler::getEmitArcsFunc() {
   Type *Args[] = {
     Type::getInt32Ty(*Ctx),     // uint32_t num_counters
     Type::getInt64PtrTy(*Ctx),  // uint64_t *counters
   };
-  FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), Args, false);
+  FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), Args, false,
+                                        DL->getProgramAddressSpace());
   return M->getOrInsertFunction("llvm_gcda_emit_arcs", FTy);
 }
 
 Constant *GCOVProfiler::getSummaryInfoFunc() {
-  FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
+  FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), false,
+                                        DL->getProgramAddressSpace());
   return M->getOrInsertFunction("llvm_gcda_summary_info", FTy);
 }
 
 Constant *GCOVProfiler::getEndFileFunc() {
-  FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
+  FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), false,
+                                        DL->getProgramAddressSpace());
   return M->getOrInsertFunction("llvm_gcda_end_file", FTy);
 }
 
 GlobalVariable *GCOVProfiler::getEdgeStateValue() {
   GlobalVariable *GV = M->getGlobalVariable("__llvm_gcov_global_state_pred");
   if (!GV) {
     GV = new GlobalVariable(*M, Type::getInt32Ty(*Ctx), false,
                             GlobalValue::InternalLinkage,
                             ConstantInt::get(Type::getInt32Ty(*Ctx),
                                              0xffffffff),
                             "__llvm_gcov_global_state_pred");
     GV->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
   }
   return GV;
 }
 
 Function *GCOVProfiler::insertCounterWriteout(
     ArrayRef<std::pair<GlobalVariable *, MDNode *> > CountersBySP) {
-  FunctionType *WriteoutFTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
+  FunctionType *WriteoutFTy = FunctionType::get(Type::getVoidTy(*Ctx), false,
+                                                DL->getProgramAddressSpace());
   Function *WriteoutF = M->getFunction("__llvm_gcov_writeout");
   if (!WriteoutF)
     WriteoutF = Function::Create(WriteoutFTy, GlobalValue::InternalLinkage,
                                  "__llvm_gcov_writeout", M);
   WriteoutF->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
   WriteoutF->addFnAttr(Attribute::NoInline);
   if (Options.NoRedZone)
     WriteoutF->addFnAttr(Attribute::NoRedZone);
void GCOVProfiler::insertIndirectCounterIncrement() {
 
   // Fill in the exit block.
   Builder.SetInsertPoint(Exit);
   Builder.CreateRetVoid();
 }
 
 Function *GCOVProfiler::
 insertFlush(ArrayRef<std::pair<GlobalVariable*, MDNode*> > CountersBySP) {
-  FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), false);
+  FunctionType *FTy = FunctionType::get(Type::getVoidTy(*Ctx), false,
+                                        DL->getProgramAddressSpace());
   Function *FlushF = M->getFunction("__llvm_gcov_flush");
   if (!FlushF)
     FlushF = Function::Create(FTy, GlobalValue::InternalLinkage,
                               "__llvm_gcov_flush", M);
   else
     FlushF->setLinkage(GlobalValue::InternalLinkage);
   FlushF->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
   FlushF->addFnAttr(Attribute::NoInline);

lib/Transforms/Instrumentation/InstrProfiling.cpp

bool InstrProfiling::run(Module &M, const TargetLibraryInfo &TLI) {
   emitInitialization();
   return true;
 }
 
 static Constant *getOrInsertValueProfilingCall(Module &M,
                                                const TargetLibraryInfo &TLI,
                                                bool IsRange = false) {
   LLVMContext &Ctx = M.getContext();
+  const auto &DL = M.getDataLayout();
   auto *ReturnTy = Type::getVoidTy(M.getContext());
 
   Constant *Res;
   if (!IsRange) {
     Type *ParamTypes[] = {
 #define VALUE_PROF_FUNC_PARAM(ParamType, ParamName, ParamLLVMType) ParamLLVMType
 #include "llvm/ProfileData/InstrProfData.inc"
     };
     auto *ValueProfilingCallTy =
-        FunctionType::get(ReturnTy, makeArrayRef(ParamTypes), false);
+        FunctionType::get(ReturnTy, makeArrayRef(ParamTypes), false,
+                          DL.getProgramAddressSpace());
     Res = M.getOrInsertFunction(getInstrProfValueProfFuncName(),
                                 ValueProfilingCallTy);
   } else {
     Type *RangeParamTypes[] = {
 #define VALUE_RANGE_PROF 1
 #define VALUE_PROF_FUNC_PARAM(ParamType, ParamName, ParamLLVMType) ParamLLVMType
 #include "llvm/ProfileData/InstrProfData.inc"
 #undef VALUE_RANGE_PROF
     };
     auto *ValueRangeProfilingCallTy =
-        FunctionType::get(ReturnTy, makeArrayRef(RangeParamTypes), false);
+        FunctionType::get(ReturnTy, makeArrayRef(RangeParamTypes), false,
+                          DL.getProgramAddressSpace());
     Res = M.getOrInsertFunction(getInstrProfValueRangeProfFuncName(),
                                 ValueRangeProfilingCallTy);
   }
 
   if (Function *FunRes = dyn_cast<Function>(Res)) {
     if (auto AK = TLI.getExtAttrForI32Param(false))
       FunRes->addParamAttr(2, AK);
   }
NamesVar->setSection(
       getInstrProfSectionName(IPSK_name, TT.getObjectFormat()));
   UsedVars.push_back(NamesVar);
 
   for (auto *NamePtr : ReferencedNames)
     NamePtr->eraseFromParent();
 }
 
 void InstrProfiling::emitRegistration() {
+  const auto &DL = M->getDataLayout();
+
   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 *RegisterFTy = FunctionType::get(VoidTy, false,
+                                        DL.getProgramAddressSpace());
   auto *RegisterF = Function::Create(RegisterFTy, GlobalValue::InternalLinkage,
                                      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);
 
   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);
+        FunctionType::get(VoidTy, makeArrayRef(ParamTypes), false,
+                          DL.getProgramAddressSpace());
     auto *NamesRegisterF =
         Function::Create(NamesRegisterTy, GlobalVariable::ExternalLinkage,
                          getInstrProfNamesRegFuncName(), M);
     IRB.CreateCall(NamesRegisterF, {IRB.CreateBitCast(NamesVar, VoidPtrTy),
                                     IRB.getInt64(NamesSize)});
   }
 
   IRB.CreateRetVoid();
 }
 
 void InstrProfiling::emitRuntimeHook() {
+  const auto &DL = M->getDataLayout();
+
   // We expect the linker to be invoked with -u<hook_var> flag for linux,
   // for which case there is no need to emit the user function.
   if (Triple(M->getTargetTriple()).isOSLinux())
     return;
 
   // If the module's provided its own runtime, we don't need to do anything.
   if (M->getGlobalVariable(getInstrProfRuntimeHookVarName()))
     return;
 
   // Declare an external variable that will pull in the runtime initialization.
   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),
+  auto *User = Function::Create(FunctionType::get(Int32Ty, false,
+                                                  DL.getProgramAddressSpace()),
                                 GlobalValue::LinkOnceODRLinkage,
                                 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));
   auto *Load = IRB.CreateLoad(Var);
   IRB.CreateRet(Load);
 
   // Mark the user variable as used so that it isn't stripped out.
   UsedVars.push_back(User);
 }
 
 void InstrProfiling::emitUses() {
   if (!UsedVars.empty())
     appendToUsed(*M, UsedVars);
 }
 
 void InstrProfiling::emitInitialization() {
+  const auto &DL = M->getDataLayout();
   StringRef InstrProfileOutput = Options.InstrProfileOutput;
 
   if (!InstrProfileOutput.empty()) {
     // Create variable for profile name.
     Constant *ProfileNameConst =
         ConstantDataArray::getString(M->getContext(), InstrProfileOutput, true);
     GlobalVariable *ProfileNameVar = new GlobalVariable(
         *M, ProfileNameConst->getType(), true, GlobalValue::WeakAnyLinkage,
         ProfileNameConst, INSTR_PROF_QUOTE(INSTR_PROF_PROFILE_NAME_VAR));
     if (TT.supportsCOMDAT()) {
       ProfileNameVar->setLinkage(GlobalValue::ExternalLinkage);
       ProfileNameVar->setComdat(M->getOrInsertComdat(
           StringRef(INSTR_PROF_QUOTE(INSTR_PROF_PROFILE_NAME_VAR))));
     }
   }
 
   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),
+  auto *F = Function::Create(FunctionType::get(VoidTy, false,
+                                               DL.getProgramAddressSpace()),
                              GlobalValue::InternalLinkage,
                              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/Instrumentation/MemorySanitizer.cpp

static GlobalVariable *createPrivateNonConstGlobalForString(Module &M,
                                                             StringRef Str) {
   Constant *StrConst = ConstantDataArray::getString(M.getContext(), Str);
   return new GlobalVariable(M, StrConst->getType(), /*isConstant=*/false,
                             GlobalValue::PrivateLinkage, StrConst, "");
 }
 
 /// \brief Insert extern declaration of runtime-provided functions and globals.
 void MemorySanitizer::initializeCallbacks(Module &M) {
+  const auto &DL = M.getDataLayout();
+
   // Only do this once.
   if (WarningFn)
     return;
 
   IRBuilder<> IRB(*C);
   // Create the callback.
   // FIXME: this function should have "Cold" calling conv,
   // which is not yet implemented.
VAArgOverflowSizeTLS = new GlobalVariable(
     M, IRB.getInt64Ty(), false, GlobalVariable::ExternalLinkage, nullptr,
     "__msan_va_arg_overflow_size_tls", nullptr,
     GlobalVariable::InitialExecTLSModel);
   OriginTLS = new GlobalVariable(
     M, IRB.getInt32Ty(), false, GlobalVariable::ExternalLinkage, nullptr,
     "__msan_origin_tls", nullptr, GlobalVariable::InitialExecTLSModel);
 
   // We insert an empty inline asm after __msan_report* to avoid callback merge.
-  EmptyAsm = InlineAsm::get(FunctionType::get(IRB.getVoidTy(), false),
+  EmptyAsm = InlineAsm::get(FunctionType::get(IRB.getVoidTy(), false,
+                                              DL.getProgramAddressSpace()),
                             StringRef(""), StringRef(""),
                             /*hasSideEffects=*/true);
 }
 
 /// \brief Module-level initialization.
 ///
 /// inserts a call to __msan_init to the module's constructor list.
 bool MemorySanitizer::doInitialization(Module &M) {
-  auto &DL = M.getDataLayout();
+  const auto &DL = M.getDataLayout();
 
   Triple TargetTriple(M.getTargetTriple());
   switch (TargetTriple.getOS()) {
     case Triple::FreeBSD:
       switch (TargetTriple.getArch()) {
         case Triple::x86_64:
           MapParams = FreeBSD_X86_MemoryMapParams.bits64;
           break;

lib/Transforms/Instrumentation/SanitizerCoverage.cpp

for (int i = 0; i < 3; i++) {
       SanCovTraceConstCmpFunction[i]->addParamAttr(0, Attribute::ZExt);
       SanCovTraceConstCmpFunction[i]->addParamAttr(1, Attribute::ZExt);
     }
     SanCovTraceDivFunction[0]->addParamAttr(0, Attribute::ZExt);
   }
 
 
   // We insert an empty inline asm after cov callbacks to avoid callback merge.
-  EmptyAsm = InlineAsm::get(FunctionType::get(IRB.getVoidTy(), false),
+  EmptyAsm = InlineAsm::get(FunctionType::get(IRB.getVoidTy(), false,
+                                              DL->getProgramAddressSpace()),
                             StringRef(""), StringRef(""),
                             /*hasSideEffects=*/true);
 
   SanCovTracePC = checkSanitizerInterfaceFunction(
       M.getOrInsertFunction(SanCovTracePCName, VoidTy));
   SanCovTracePCGuard = checkSanitizerInterfaceFunction(M.getOrInsertFunction(
       SanCovTracePCGuardName, VoidTy, Int32PtrTy));
 

lib/Transforms/ObjCARC/ARCRuntimeEntryPoints.h

private:
   /// Declaration for objc_retainAutoreleaseReturnValue().
   Constant *RetainAutoreleaseRV;
 
   Constant *getVoidRetI8XEntryPoint(Constant *&Decl, StringRef Name) {
     if (Decl)
       return Decl;
 
     LLVMContext &C = TheModule->getContext();
+    const auto &DL = TheModule->getDataLayout();
     Type *Params[] = { PointerType::getUnqual(Type::getInt8Ty(C)) };
     AttributeList Attr = AttributeList().addAttribute(
         C, AttributeList::FunctionIndex, Attribute::NoUnwind);
     FunctionType *Fty = FunctionType::get(Type::getVoidTy(C), Params,
-                                          /*isVarArg=*/false);
+                                          /*isVarArg=*/false,
+                                          DL.getProgramAddressSpace());
     return Decl = TheModule->getOrInsertFunction(Name, Fty, Attr);
   }
 
   Constant *getI8XRetI8XEntryPoint(Constant *&Decl, StringRef Name,
                                    bool NoUnwind = false) {
     if (Decl)
       return Decl;
 
     LLVMContext &C = TheModule->getContext();
+    const auto &DL = TheModule->getDataLayout();
     Type *I8X = PointerType::getUnqual(Type::getInt8Ty(C));
     Type *Params[] = { I8X };
-    FunctionType *Fty = FunctionType::get(I8X, Params, /*isVarArg=*/false);
+    FunctionType *Fty = FunctionType::get(I8X, Params, /*isVarArg=*/false,
+                                          DL.getProgramAddressSpace());
     AttributeList Attr = AttributeList();
 
     if (NoUnwind)
       Attr = Attr.addAttribute(C, AttributeList::FunctionIndex,
                                Attribute::NoUnwind);
 
     return Decl = TheModule->getOrInsertFunction(Name, Fty, Attr);
   }
 
   Constant *getI8XRetI8XXI8XEntryPoint(Constant *&Decl, StringRef Name) {
     if (Decl)
       return Decl;
 
     LLVMContext &C = TheModule->getContext();
+    const auto &DL = TheModule->getDataLayout();
     Type *I8X = PointerType::getUnqual(Type::getInt8Ty(C));
     Type *I8XX = PointerType::getUnqual(I8X);
     Type *Params[] = { I8XX, I8X };
 
     AttributeList Attr = AttributeList().addAttribute(
         C, AttributeList::FunctionIndex, Attribute::NoUnwind);
     Attr = Attr.addParamAttribute(C, 0, Attribute::NoCapture);
 
     FunctionType *Fty = FunctionType::get(Type::getVoidTy(C), Params,
-                                          /*isVarArg=*/false);
+                                          /*isVarArg=*/false,
+                                          DL.getProgramAddressSpace());
 
     return Decl = TheModule->getOrInsertFunction(Name, Fty, Attr);
   }
 
 }; // class ARCRuntimeEntryPoints
 
 } // namespace objcarc
 } // namespace llvm
 
 #endif

lib/Transforms/ObjCARC/ObjCARCContract.cpp

if (Load->use_empty())
     Load->eraseFromParent();
 }
 
 bool ObjCARCContract::tryToPeepholeInstruction(
   Function &F, Instruction *Inst, inst_iterator &Iter,
   SmallPtrSetImpl<Instruction *> &DependingInsts,
   SmallPtrSetImpl<const BasicBlock *> &Visited,
   bool &TailOkForStoreStrongs) {
-    // Only these library routines return their argument. In particular,
-    // objc_retainBlock does not necessarily return its argument.
+  const auto &DL = F.getParent()->getDataLayout();
+
   ARCInstKind Class = GetBasicARCInstKind(Inst);
     switch (Class) {
     case ARCInstKind::FusedRetainAutorelease:
     case ARCInstKind::FusedRetainAutoreleaseRV:
       return false;
     case ARCInstKind::Autorelease:
     case ARCInstKind::AutoreleaseRV:
       return contractAutorelease(F, Inst, Class, DependingInsts, Visited);
case ARCInstKind::ClaimRV: {
       } while (IsNoopInstruction(&*BBI));
 
       if (&*BBI == GetArgRCIdentityRoot(Inst)) {
         DEBUG(dbgs() << "Adding inline asm marker for the return value "
                         "optimization.\n");
         Changed = true;
         InlineAsm *IA = InlineAsm::get(
             FunctionType::get(Type::getVoidTy(Inst->getContext()),
-                              /*isVarArg=*/false),
+                              /*isVarArg=*/false, DL.getProgramAddressSpace()),
             RVInstMarker->getString(),
             /*Constraints=*/"", /*hasSideEffects=*/true);
         CallInst::Create(IA, "", Inst);
       }
     decline_rv_optimization:
       return false;
     }
     case ARCInstKind::InitWeak: {

lib/Transforms/Scalar/PlaceSafepoints.cpp

 static void
 InsertSafepointPoll(Instruction *InsertBefore,
                     std::vector<CallSite> &ParsePointsNeeded /*rval*/,
                     const TargetLibraryInfo &TLI) {
   BasicBlock *OrigBB = InsertBefore->getParent();
   Module *M = InsertBefore->getModule();
   assert(M && "must be part of a module");
 
+  const auto &DL = M->getDataLayout();
+
   // Inline the safepoint poll implementation - this will get all the branch,
   // control flow, etc..  Most importantly, it will introduce the actual slow
   // path call - where we need to insert a safepoint (parsepoint).
 
   auto *F = M->getFunction(GCSafepointPollName);
   assert(F && "gc.safepoint_poll function is missing");
   assert(F->getValueType() ==
-         FunctionType::get(Type::getVoidTy(M->getContext()), false) &&
+         FunctionType::get(Type::getVoidTy(M->getContext()), false,
+                           DL.getProgramAddressSpace()) &&
          "gc.safepoint_poll declared with wrong type");
   assert(!F->empty() && "gc.safepoint_poll must be a non-empty function");
   CallInst *PollCall = CallInst::Create(F, "", InsertBefore);
 
   // Record some information about the call site we're replacing
   BasicBlock::iterator Before(PollCall), After(PollCall);
   bool IsBegin = false;
   if (Before == OrigBB->begin())

lib/Transforms/Scalar/RewriteStatepointsForGC.cpp

makeStatepointExplicitImpl(const CallSite CS, /* to replace */
                            std::vector<DeferredReplacement> &Replacements) {
   assert(BasePtrs.size() == LiveVariables.size());
 
   // Then go ahead and use the builder do actually do the inserts.  We insert
   // immediately before the previous instruction under the assumption that all
   // arguments will be available here.  We can't insert afterwards since we may
   // be replacing a terminator.
   Instruction *InsertBefore = CS.getInstruction();
+  const auto &DL = InsertBefore->getModule()->getDataLayout();
   IRBuilder<> Builder(InsertBefore);
 
   ArrayRef<Value *> GCArgs(LiveVariables);
   uint64_t StatepointID = StatepointDirectives::DefaultStatepointID;
   uint32_t NumPatchBytes = 0;
   uint32_t Flags = uint32_t(StatepointFlags::None);
 
   ArrayRef<Use> CallArgs(CS.arg_begin(), CS.arg_end());
if (F->getIntrinsicID() == Intrinsic::experimental_deoptimize) {
       // Calls to llvm.experimental.deoptimize are lowered to calls to the
       // __llvm_deoptimize symbol.  We want to resolve this now, since the
       // verifier does not allow taking the address of an intrinsic function.
 
       SmallVector<Type *, 8> DomainTy;
       for (Value *Arg : CallArgs)
         DomainTy.push_back(Arg->getType());
       auto *FTy = FunctionType::get(Type::getVoidTy(F->getContext()), DomainTy,
-                                    /* isVarArg = */ false);
+                                    /* isVarArg = */ false,
+                                    DL.getProgramAddressSpace());
 
       // Note: CallTarget can be a bitcast instruction of a symbol if there are
       // calls to @llvm.experimental.deoptimize with different argument types in
       // the same module.  This is fine -- we assume the frontend knew what it
       // was doing when generating this kind of IR.
       CallTarget =
           F->getParent()->getOrInsertFunction("__llvm_deoptimize", FTy);
 

 /// lifetime of the call.
 static void insertUseHolderAfter(CallSite &CS, const ArrayRef<Value *> Values,
                                  SmallVectorImpl<CallInst *> &Holders) {
   if (Values.empty())
     // No values to hold live, might as well not insert the empty holder
     return;
 
   Module *M = CS.getInstruction()->getModule();
+  const auto &DL = M->getDataLayout();
   // Use a dummy vararg function to actually hold the values live
   Function *Func = cast<Function>(M->getOrInsertFunction(
-      "__tmp_use", FunctionType::get(Type::getVoidTy(M->getContext()), true)));
+      "__tmp_use", FunctionType::get(Type::getVoidTy(M->getContext()), true,
+                                     DL.getProgramAddressSpace())));
   if (CS.isCall()) {
     // For call safepoints insert dummy calls right after safepoint
     Holders.push_back(CallInst::Create(Func, Values, "",
                                        &*++CS.getInstruction()->getIterator()));
     return;
   }
   // For invoke safepooints insert dummy calls both in normal and
   // exceptional destination blocks

lib/Transforms/Utils/CloneFunction.cpp

Function *llvm::CloneFunction(Function *F, ValueToValueMapTy &VMap,
   // the VMap.  If so, we need to not add the arguments to the arg ty vector
   //
   for (const Argument &I : F->args())
     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());
+                                    ArgTypes, F->getFunctionType()->isVarArg(),
+                                    F->getFunctionType()->getAddressSpace());
 
   // Create the new function...
   Function *NewF =
       Function::Create(FTy, F->getLinkage(), 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())

lib/Transforms/Utils/CodeExtractor.cpp

Function *CodeExtractor::constructFunction(const ValueSet &inputs,
 
   StructType *StructTy;
   if (AggregateArgs && (inputs.size() + outputs.size() > 0)) {
     StructTy = StructType::get(M->getContext(), paramTy);
     paramTy.clear();
     paramTy.push_back(PointerType::getUnqual(StructTy));
   }
   FunctionType *funcType =
-                  FunctionType::get(RetTy, paramTy, false);
+                  FunctionType::get(RetTy, paramTy, false,
+                                    oldFunction->getAddressSpace());
 
   // Create the new function
   Function *newFunction = Function::Create(funcType,
                                            GlobalValue::InternalLinkage,
                                            oldFunction->getName() + "_" +
                                            header->getName(), M);
   // If the old function is no-throw, so is the new one.
   if (oldFunction->doesNotThrow())

lib/Transforms/Utils/EscapeEnumerator.cpp

 #include "llvm/Analysis/EHPersonalities.h"
 #include "llvm/IR/CallSite.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Transforms/Utils/Local.h"
 using namespace llvm;
 
 static Constant *getDefaultPersonalityFn(Module *M) {
   LLVMContext &C = M->getContext();
+  const DataLayout &DL = M->getDataLayout();
   Triple T(M->getTargetTriple());
   EHPersonality Pers = getDefaultEHPersonality(T);
+
   return M->getOrInsertFunction(getEHPersonalityName(Pers),
-                                FunctionType::get(Type::getInt32Ty(C), true));
+                                FunctionType::get(Type::getInt32Ty(C), true,
+                                                  DL.getProgramAddressSpace()));
 }
 
 IRBuilder<> *EscapeEnumerator::Next() {
   if (Done)
     return nullptr;
 
   // Find all 'return', 'resume', and 'unwind' instructions.
   while (StateBB != StateE) {

lib/Transforms/Utils/ModuleUtils.cpp

 #include "llvm/IR/IRBuilder.h"
 #include "llvm/IR/Module.h"
 #include "llvm/Support/raw_ostream.h"
 
 using namespace llvm;
 
 static void appendToGlobalArray(const char *Array, Module &M, Function *F,
                                 int Priority, Constant *Data) {
+  const DataLayout &DL = M.getDataLayout();
   IRBuilder<> IRB(M.getContext());
-  FunctionType *FnTy = FunctionType::get(IRB.getVoidTy(), false);
+  FunctionType *FnTy = FunctionType::get(IRB.getVoidTy(), false,
+                                         DL.getProgramAddressSpace());
 
   // Get the current set of static global constructors and add the new ctor
   // to the list.
   SmallVector<Constant *, 16> CurrentCtors;
   StructType *EltTy;
   if (GlobalVariable *GVCtor = M.getNamedGlobal(Array)) {
     ArrayType *ATy = cast<ArrayType>(GVCtor->getValueType());
     StructType *OldEltTy = cast<StructType>(ATy->getElementType());
Function *llvm::checkSanitizerInterfaceFunction(Constant *FuncOrBitcast) {
   raw_string_ostream Stream(Err);
   Stream << "Sanitizer interface function redefined: " << *FuncOrBitcast;
   report_fatal_error(Err);
 }
 
 Function *llvm::declareSanitizerInitFunction(Module &M, StringRef InitName,
                                              ArrayRef<Type *> InitArgTypes) {
   assert(!InitName.empty() && "Expected init function name");
+  const DataLayout &DL = M.getDataLayout();
   Function *F = checkSanitizerInterfaceFunction(M.getOrInsertFunction(
       InitName,
-      FunctionType::get(Type::getVoidTy(M.getContext()), InitArgTypes, false),
+      FunctionType::get(Type::getVoidTy(M.getContext()), InitArgTypes, false,
+                        DL.getProgramAddressSpace()),
       AttributeList()));
   F->setLinkage(Function::ExternalLinkage);
   return F;
 }
 
 std::pair<Function *, Function *> llvm::createSanitizerCtorAndInitFunctions(
     Module &M, StringRef CtorName, StringRef InitName,
     ArrayRef<Type *> InitArgTypes, ArrayRef<Value *> InitArgs,
     StringRef VersionCheckName) {
+  const DataLayout &DL = M.getDataLayout();
   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),
+      FunctionType::get(Type::getVoidTy(M.getContext()), false,
+                        DL.getProgramAddressSpace()),
       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),

lib/Transforms/Utils/SanitizerStats.cpp

 }
 
 void SanitizerStatReport::finish() {
   if (Inits.empty()) {
     ModuleStatsGV->eraseFromParent();
     return;
   }
 
+  const DataLayout &DL = M->getDataLayout();
+
   PointerType *Int8PtrTy = Type::getInt8PtrTy(M->getContext());
   IntegerType *Int32Ty = Type::getInt32Ty(M->getContext());
   Type *VoidTy = Type::getVoidTy(M->getContext());
 
   // Create a new ModuleStatsGV to replace the old one. We can't just set the
   // old one's initializer because its type is different.
   auto NewModuleStatsGV = new GlobalVariable(
       *M, makeModuleStatsTy(), false, GlobalValue::InternalLinkage,
       ConstantStruct::getAnon(
           {Constant::getNullValue(Int8PtrTy),
            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),
+  auto F = Function::Create(FunctionType::get(VoidTy, false,
+                            DL.getProgramAddressSpace()),
                             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/Utils/SimplifyCFG.cpp

SwitchLookupTable::SwitchLookupTable(
   }
 
   // Store the table in an array.
   ArrayType *ArrayTy = ArrayType::get(ValueType, TableSize);
   Constant *Initializer = ConstantArray::get(ArrayTy, TableContents);
 
   Array = new GlobalVariable(M, ArrayTy, /*constant=*/true,
                              GlobalVariable::PrivateLinkage, Initializer,
-                             "switch.table." + FuncName);
+                             "switch.table." + FuncName,
+                             /*InsertBefore=*/nullptr,
+                             GlobalValue::NotThreadLocal,
+                             DL.getProgramAddressSpace());
   Array->setUnnamedAddr(GlobalValue::UnnamedAddr::Global);
   Kind = ArrayKind;
 }
 
 Value *SwitchLookupTable::BuildLookup(Value *Index, IRBuilder<> &Builder) {
   switch (Kind) {
   case SingleValueKind:
     return SingleValue;

lib/Transforms/Utils/ValueMapper.cpp

void Mapper::remapInstruction(Instruction *I) {
   // If the instruction's type is being remapped, do so now.
   if (auto CS = CallSite(I)) {
     SmallVector<Type *, 3> Tys;
     FunctionType *FTy = CS.getFunctionType();
     Tys.reserve(FTy->getNumParams());
     for (Type *Ty : FTy->params())
       Tys.push_back(TypeMapper->remapType(Ty));
     CS.mutateFunctionType(FunctionType::get(
-        TypeMapper->remapType(I->getType()), Tys, FTy->isVarArg()));
+        TypeMapper->remapType(I->getType()), Tys, FTy->isVarArg(),
+        FTy->getAddressSpace()));
     return;
   }
   if (auto *AI = dyn_cast<AllocaInst>(I))
     AI->setAllocatedType(TypeMapper->remapType(AI->getAllocatedType()));
   if (auto *GEP = dyn_cast<GetElementPtrInst>(I)) {
     GEP->setSourceElementType(
         TypeMapper->remapType(GEP->getSourceElementType()));
     GEP->setResultElementType(

lib/Transforms/Vectorize/LoopVectorize.cpp

void InnerLoopVectorizer::widenInstruction(Instruction &I) {
 
   case Instruction::Call: {
     // Ignore dbg intrinsics.
     if (isa<DbgInfoIntrinsic>(I))
       break;
     setDebugLocFromInst(Builder, &I);
 
     Module *M = I.getParent()->getParent()->getParent();
+    const auto &DL = M->getDataLayout();
     auto *CI = cast<CallInst>(&I);
 
     StringRef FnName = CI->getCalledFunction()->getName();
     Function *F = CI->getCalledFunction();
     Type *RetTy = ToVectorTy(CI->getType(), VF);
     SmallVector<Type *, 4> Tys;
     for (Value *ArgOperand : CI->arg_operands())
       Tys.push_back(ToVectorTy(ArgOperand->getType(), VF));
for (unsigned Part = 0; Part < UF; ++Part) {
         VectorF = Intrinsic::getDeclaration(M, ID, TysForDecl);
       } else {
         // 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);
+          FunctionType *FTy = FunctionType::get(RetTy, Tys, false,
+                                                DL.getProgramAddressSpace());
           VectorF =
               Function::Create(FTy, Function::ExternalLinkage, VFnName, M);
           VectorF->copyAttributesFrom(F);
         }
       }
       assert(VectorF && "Can't create vector function.");
 
       SmallVector<OperandBundleDef, 1> 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
+}

test/CodeGen/AVR/switch-lookup-table-in-progmem-space.ll

+; RUN: opt -S -mtriple=avr -latesimplifycfg < %s | FileCheck %s
+
+target datalayout = "e-p:16:16:16-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-n8-P1"
+
+; Switch lookup tables should be placed in program memory (address space 1).
+
+%MyType = type { i8, [0 x i8], [0 x i8] }
+
+define i8 @foo(i8 %arg) {
+start:
+  %_0 = alloca %MyType
+
+; CHECK: @switch.table.foo = {{.*}}addrspace(1) constant {{.*}}
+  switch i8 %arg, label %bb7 [
+    i8 0, label %bb1
+    i8 1, label %bb2
+    i8 2, label %bb3
+    i8 3, label %bb4
+    i8 4, label %bb5
+    i8 14, label %bb6
+  ]
+
+bb1:                                              ; preds = %start
+  %tmp = getelementptr inbounds %MyType, %MyType* %_0, i32 0, i32 0
+  store i8 1, i8* %tmp
+  br label %bb8
+
+bb2:                                              ; preds = %start
+  %tmp1 = getelementptr inbounds %MyType, %MyType* %_0, i32 0, i32 0
+  store i8 1, i8* %tmp1
+  br label %bb8
+
+bb3:                                              ; preds = %start
+  %tmp2 = getelementptr inbounds %MyType, %MyType* %_0, i32 0, i32 0
+  store i8 1, i8* %tmp2
+  br label %bb8
+
+bb4:                                              ; preds = %start
+  %tmp3 = getelementptr inbounds %MyType, %MyType* %_0, i32 0, i32 0
+  store i8 1, i8* %tmp3
+  br label %bb8
+
+bb5:                                              ; preds = %start
+  %tmp4 = getelementptr inbounds %MyType, %MyType* %_0, i32 0, i32 0
+  store i8 1, i8* %tmp4
+  br label %bb8
+
+bb6:                                              ; preds = %start
+  %tmp5 = getelementptr inbounds %MyType, %MyType* %_0, i32 0, i32 0
+  store i8 1, i8* %tmp5
+  br label %bb8
+
+bb7:                                              ; preds = %start
+  %tmp6 = getelementptr inbounds %MyType, %MyType* %_0, i32 0, i32 0
+  store i8 0, i8* %tmp6
+  br label %bb8
+
+bb8:                                              ; preds = %bb7, %bb6, %bb5, %bb4, %bb3, %bb2, %bb1
+  %tmp7 = bitcast %MyType* %_0 to i8*
+  %tmp8 = load i8, i8* %tmp7, align 1
+  ret i8 %tmp8
+}

tools/llvm-stress/llvm-stress.cpp

Type* ArgsTy[] = {
     Type::getInt8PtrTy(Context),
     Type::getInt32PtrTy(Context),
     Type::getInt64PtrTy(Context),
     Type::getInt32Ty(Context),
     Type::getInt64Ty(Context),
     Type::getInt8Ty(Context)
   };
 
-  auto *FuncTy = FunctionType::get(Type::getVoidTy(Context), ArgsTy, false);
+  auto *FuncTy = FunctionType::get(Type::getVoidTy(Context), ArgsTy, false,
+                                   M->getDataLayout().getProgramAddressSpace());
   // Pick a unique name to describe the input parameters
   Twine Name = "autogen_SD" + Twine{SeedCL};
   auto *Func = Function::Create(FuncTy, GlobalValue::ExternalLinkage, Name, M);
   Func->setCallingConv(CallingConv::C);
   return Func;
 }
 
 /// A base class, implementing utilities needed for

unittests/Analysis/AliasAnalysisTest.cpp

AAResults &getAAResults(Function &F) {
 
     return *AAR;
   }
 };
 
 TEST_F(AliasAnalysisTest, getModRefInfo) {
   // Setup function.
   FunctionType *FTy =
-      FunctionType::get(Type::getVoidTy(C), std::vector<Type *>(), false);
+      FunctionType::get(Type::getVoidTy(C), std::vector<Type *>(), false, 0);
   auto *F = cast<Function>(M.getOrInsertFunction("f", FTy));
   auto *BB = BasicBlock::Create(C, "entry", F);
   auto IntType = Type::getInt32Ty(C);
   auto PtrType = Type::getInt32PtrTy(C);
   auto *Value = ConstantInt::get(IntType, 42);
   auto *Addr = ConstantPointerNull::get(PtrType);
 
   auto *Store1 = new StoreInst(Value, Addr, BB);

unittests/Analysis/ScalarEvolutionTest.cpp

void runWithSE(
     ASSERT_NE(F, nullptr) << "Could not find " << FuncName;
     ScalarEvolution SE = buildSE(*F);
     Test(*F, *LI, SE);
   }
 };
 
 TEST_F(ScalarEvolutionsTest, SCEVUnknownRAUW) {
   FunctionType *FTy = FunctionType::get(Type::getVoidTy(Context),
-                                              std::vector<Type *>(), false);
+                                              std::vector<Type *>(), false, 0);
   Function *F = cast<Function>(M.getOrInsertFunction("f", FTy));
   BasicBlock *BB = BasicBlock::Create(Context, "entry", F);
   ReturnInst::Create(Context, nullptr, BB);
 
   Type *Ty = Type::getInt1Ty(Context);
   Constant *Init = Constant::getNullValue(Ty);
   Value *V0 = new GlobalVariable(M, Ty, false, GlobalValue::ExternalLinkage, Init, "V0");
   Value *V1 = new GlobalVariable(M, Ty, false, GlobalValue::ExternalLinkage, Init, "V1");
TEST_F(ScalarEvolutionsTest, SCEVUnknownRAUW) {
   EXPECT_EQ(cast<SCEVUnknown>(M1->getOperand(1))->getValue(), V0);
   EXPECT_EQ(cast<SCEVUnknown>(M2->getOperand(1))->getValue(), V0);
 }
 
 TEST_F(ScalarEvolutionsTest, SCEVMultiplyAddRecs) {
   Type *Ty = Type::getInt32Ty(Context);
   SmallVector<Type *, 10> Types;
   Types.append(10, Ty);
-  FunctionType *FTy = FunctionType::get(Type::getVoidTy(Context), Types, false);
+  FunctionType *FTy =
+          FunctionType::get(Type::getVoidTy(Context), Types, false, 0);
   Function *F = cast<Function>(M.getOrInsertFunction("f", FTy));
   BasicBlock *BB = BasicBlock::Create(Context, "entry", F);
   ReturnInst::Create(Context, nullptr, BB);
 
   ScalarEvolution SE = buildSE(*F);
 
   // It's possible to produce an empty loop through the default constructor,
   // but you can't add any blocks to it without a LoopInfo pass.

 #endif
 
   Sum.push_back(SE.getMulExpr(SE.getConstant(Ty, 70), A[4], B[4]));
   EXPECT_EQ(Product->getOperand(8), SE.getAddExpr(Sum));
 }
 
 TEST_F(ScalarEvolutionsTest, SimplifiedPHI) {
   FunctionType *FTy = FunctionType::get(Type::getVoidTy(Context),
-                                              std::vector<Type *>(), false);
+                                        std::vector<Type *>(), false, 0);
   Function *F = cast<Function>(M.getOrInsertFunction("f", FTy));
   BasicBlock *EntryBB = BasicBlock::Create(Context, "entry", F);
   BasicBlock *LoopBB = BasicBlock::Create(Context, "loop", F);
   BasicBlock *ExitBB = BasicBlock::Create(Context, "exit", F);
   BranchInst::Create(LoopBB, EntryBB);
   BranchInst::Create(LoopBB, ExitBB, UndefValue::get(Type::getInt1Ty(Context)),
                      LoopBB);
   ReturnInst::Create(Context, nullptr, ExitBB);

 TEST_F(ScalarEvolutionsTest, ExpandPtrTypeSCEV) {
   // It is to test the fix for PR30213. It exercises the branch in scev
   // expansion when the value in ValueOffsetPair is a ptr and the offset
   // is not divisible by the elem type size of value.
   auto *I8Ty = Type::getInt8Ty(Context);
   auto *I8PtrTy = Type::getInt8PtrTy(Context);
   auto *I32Ty = Type::getInt32Ty(Context);
   auto *I32PtrTy = Type::getInt32PtrTy(Context);
-  FunctionType *FTy =
-      FunctionType::get(Type::getVoidTy(Context), std::vector<Type *>(), false);
+  FunctionType *FTy = FunctionType::get(Type::getVoidTy(Context),
+                                        std::vector<Type *>(), false, 0);
   Function *F = cast<Function>(M.getOrInsertFunction("f", FTy));
   BasicBlock *EntryBB = BasicBlock::Create(Context, "entry", F);
   BasicBlock *LoopBB = BasicBlock::Create(Context, "loop", F);
   BasicBlock *ExitBB = BasicBlock::Create(Context, "exit", F);
   BranchInst::Create(LoopBB, EntryBB);
   ReturnInst::Create(Context, nullptr, ExitBB);
 
   // loop:                            ; preds = %loop, %entry
runWithSE(
         *M, FuncName, [&](Function &F, LoopInfo &LI, ScalarEvolution &SE) {
           CheckCommutativeMulExprs(SE, SE.getSCEV(getInstructionByName(F, "x")),
                                    SE.getSCEV(getInstructionByName(F, "y")),
                                    SE.getSCEV(getInstructionByName(F, "z")));
         });
 }
 
 TEST_F(ScalarEvolutionsTest, CompareSCEVComplexity) {
-  FunctionType *FTy =
-      FunctionType::get(Type::getVoidTy(Context), std::vector<Type *>(), false);
+  FunctionType *FTy = FunctionType::get(Type::getVoidTy(Context),
+                                        std::vector<Type *>(), false, 0);
   Function *F = cast<Function>(M.getOrInsertFunction("f", FTy));
   BasicBlock *EntryBB = BasicBlock::Create(Context, "entry", F);
   BasicBlock *LoopBB = BasicBlock::Create(Context, "bb1", F);
   BranchInst::Create(LoopBB, EntryBB);
 
   auto *Ty = Type::getInt32Ty(Context);
   SmallVector<Instruction*, 8> Muls(8), Acc(8), NextAcc(8);
 
TEST_F(ScalarEvolutionsTest, CompareSCEVComplexity) {
 
   EXPECT_NE(nullptr, SE.getSCEV(Acc[0]));
 }
 
 TEST_F(ScalarEvolutionsTest, CompareValueComplexity) {
   IntegerType *IntPtrTy = M.getDataLayout().getIntPtrType(Context);
   PointerType *IntPtrPtrTy = IntPtrTy->getPointerTo();
 
-  FunctionType *FTy =
-      FunctionType::get(Type::getVoidTy(Context), {IntPtrTy, IntPtrTy}, false);
+  FunctionType *FTy = FunctionType::get(Type::getVoidTy(Context),
+                                        {IntPtrTy, IntPtrTy}, false, 0);
   Function *F = cast<Function>(M.getOrInsertFunction("f", FTy));
   BasicBlock *EntryBB = BasicBlock::Create(Context, "entry", F);
 
   Value *X = &*F->arg_begin();
   Value *Y = &*std::next(F->arg_begin());
 
   const int ValueDepth = 10;
   for (int i = 0; i < ValueDepth; i++) {
TEST_F(ScalarEvolutionsTest, CompareValueComplexity) {
   EXPECT_NE(A, B);
 }
 
 TEST_F(ScalarEvolutionsTest, SCEVAddExpr) {
   Type *Ty32 = Type::getInt32Ty(Context);
   Type *ArgTys[] = {Type::getInt64Ty(Context), Ty32};
 
   FunctionType *FTy =
-      FunctionType::get(Type::getVoidTy(Context), ArgTys, false);
+      FunctionType::get(Type::getVoidTy(Context), ArgTys, false, 0);
   Function *F = cast<Function>(M.getOrInsertFunction("f", FTy));
 
   Argument *A1 = &*F->arg_begin();
   Argument *A2 = &*(std::next(F->arg_begin()));
   BasicBlock *EntryBB = BasicBlock::Create(Context, "entry", F);
 
   Instruction *Trunc = CastInst::CreateTruncOrBitCast(A1, Ty32, "", EntryBB);
   Instruction *Mul1 = BinaryOperator::CreateMul(Trunc, A2, "", EntryBB);
TEST_F(ScalarEvolutionsTest, SCEVZeroExtendExpr) {
   //
   // for.end:
   //   %gep = getelementptr i8, i8* null, i64 %dec
   //   %gep6 = getelementptr i8, i8* %gep, i64 %dec5
   //   ......
   //   %gep95 = getelementptr i8, i8* %gep91, i64 %dec94
   //   ret void
   // }
-  FunctionType *FTy = FunctionType::get(Type::getVoidTy(Context), {}, false);
+  FunctionType *FTy = FunctionType::get(Type::getVoidTy(Context), {}, false, 0);
   Function *F = cast<Function>(M.getOrInsertFunction("foo", FTy));
 
   BasicBlock *EntryBB = BasicBlock::Create(Context, "entry", F);
   BasicBlock *CondBB = BasicBlock::Create(Context, "for.cond", F);
   BasicBlock *EndBB = BasicBlock::Create(Context, "for.end", F);
   BranchInst::Create(CondBB, EntryBB);
   BasicBlock *PrevBB = EntryBB;
 
TEST_F(ScalarEvolutionsTest, SCEVZeroExtendExprNonIntegral) {
   DataLayout += "ni:10";
   NIM.setDataLayout(DataLayout);
 
   Type *T_int1 = Type::getInt1Ty(Context);
   Type *T_int64 = Type::getInt64Ty(Context);
   Type *T_pint64 = T_int64->getPointerTo(10);
 
   FunctionType *FTy =
-      FunctionType::get(Type::getVoidTy(Context), {T_pint64}, false);
+      FunctionType::get(Type::getVoidTy(Context), {T_pint64}, false, 0);
   Function *F = cast<Function>(NIM.getOrInsertFunction("foo", FTy));
 
   Argument *Arg = &*F->arg_begin();
 
   BasicBlock *Top = BasicBlock::Create(Context, "top", F);
   BasicBlock *LPh = BasicBlock::Create(Context, "L.ph", F);
   BasicBlock *L = BasicBlock::Create(Context, "L", F);
   BasicBlock *Post = BasicBlock::Create(Context, "post", F);
if (!DataLayout.empty())
     DataLayout += "-";
   DataLayout += "ni:10";
   NIM.setDataLayout(DataLayout);
 
   Type *T_int64 = Type::getInt64Ty(Context);
   Type *T_pint64 = T_int64->getPointerTo(10);
 
   FunctionType *FTy =
-      FunctionType::get(Type::getVoidTy(Context), {T_pint64}, false);
+      FunctionType::get(Type::getVoidTy(Context), {T_pint64}, false, 0);
   Function *F = cast<Function>(NIM.getOrInsertFunction("foo", FTy));
 
   BasicBlock *Top = BasicBlock::Create(Context, "top", F);
   BasicBlock *LPh = BasicBlock::Create(Context, "L.ph", F);
   BasicBlock *L = BasicBlock::Create(Context, "L", F);
   BasicBlock *Post = BasicBlock::Create(Context, "post", F);
 
   IRBuilder<> Builder(Top);
if (!DataLayout.empty())
     DataLayout += "-";
   DataLayout += "ni:10";
   NIM.setDataLayout(DataLayout);
 
   Type *T_int64 = Type::getInt64Ty(Context);
   Type *T_pint64 = T_int64->getPointerTo(10);
 
   FunctionType *FTy =
-      FunctionType::get(Type::getVoidTy(Context), {T_pint64}, false);
+      FunctionType::get(Type::getVoidTy(Context), {T_pint64}, false, 0);
   Function *F = cast<Function>(NIM.getOrInsertFunction("foo", FTy));
 
   Argument *Arg = &*F->arg_begin();
 
   BasicBlock *Top = BasicBlock::Create(Context, "top", F);
   BasicBlock *LPh = BasicBlock::Create(Context, "L.ph", F);
   BasicBlock *L = BasicBlock::Create(Context, "L", F);
   BasicBlock *Post = BasicBlock::Create(Context, "post", F);

unittests/Analysis/TBAATest.cpp

protected:
 
   LLVMContext C;
   Module M;
   MDBuilder MD;
 };
 
 static StoreInst *getFunctionWithSingleStore(Module *M, StringRef Name) {
   auto &C = M->getContext();
-  FunctionType *FTy = FunctionType::get(Type::getVoidTy(C), {});
+  FunctionType *FTy = FunctionType::get(Type::getVoidTy(C), {}, 0);
   auto *F = cast<Function>(M->getOrInsertFunction(Name, FTy));
   auto *BB = BasicBlock::Create(C, "entry", F);
   auto *IntType = Type::getInt32Ty(C);
   auto *PtrType = Type::getInt32PtrTy(C);
   auto *SI = new StoreInst(ConstantInt::get(IntType, 42),
                            ConstantPointerNull::get(PtrType), BB);
   ReturnInst::Create(C, nullptr, BB);
 

unittests/Analysis/TargetLibraryInfoTest.cpp

 
 } // end anonymous namespace
 
 // Check that we don't accept egregiously incorrect prototypes.
 TEST_F(TargetLibraryInfoTest, InvalidProto) {
   parseAssembly("%foo = type { %foo }\n");
 
   auto *StructTy = M->getTypeByName("foo");
-  auto *InvalidFTy = FunctionType::get(StructTy, /*isVarArg=*/false);
+  auto *InvalidFTy = FunctionType::get(StructTy, /*isVarArg=*/false,
+                                       /*AddrSpace=*/0);
 
   for (unsigned FI = 0; FI != LibFunc::NumLibFuncs; ++FI) {
     LibFunc LF = (LibFunc)FI;
     auto *F = cast<Function>(
         M->getOrInsertFunction(TLI.getName(LF), InvalidFTy));
     EXPECT_FALSE(isLibFunc(F, LF));
   }
 }

unittests/IR/FunctionTest.cpp

 using namespace llvm;
 
 namespace {
 
 TEST(FunctionTest, hasLazyArguments) {
   LLVMContext C;
 
   Type *ArgTypes[] = {Type::getInt8Ty(C), Type::getInt32Ty(C)};
-  FunctionType *FTy = FunctionType::get(Type::getVoidTy(C), ArgTypes, false);
+  FunctionType *FTy = FunctionType::get(Type::getVoidTy(C), ArgTypes, false, 0);
 
   // Functions start out with lazy arguments.
   std::unique_ptr<Function> F(
       Function::Create(FTy, GlobalValue::ExternalLinkage, "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);
+  FunctionType *FTy = FunctionType::get(Type::getVoidTy(C), ArgTypes, false, 0);
   std::unique_ptr<Function> F1(
       Function::Create(FTy, GlobalValue::ExternalLinkage, "F1"));
   std::unique_ptr<Function> F2(
       Function::Create(FTy, GlobalValue::ExternalLinkage, "F1"));
   EXPECT_TRUE(F1->hasLazyArguments());
   EXPECT_TRUE(F2->hasLazyArguments());
 
   // Steal arguments before they've been accessed.  Nothing should change; both

 }
 
 // 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),
+      Function::Create(llvm::FunctionType::get(llvm::Type::getVoidTy(C), false, 0),
                        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());
 }
 
+// Test setting and retrieving fields stored in subclass data bitfield
+// through the associated FunctionType
+TEST(FunctionTest, subclassData) {
+  LLVMContext C;
+  Module M("test", C);
+
+  llvm::Function *F =
+      Function::Create(llvm::FunctionType::get(llvm::Type::getVoidTy(C), true,
+                       180), GlobalValue::ExternalLinkage);
+
+  EXPECT_EQ(false, F->isVarArg());
+  EXPECT_EQ(180u, F->getAddressSpace());
+}
+
 } // 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);
+                                          /*isVarArg=*/false, /*AddrSpace=*/0);
     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;
TEST_F(IRBuilderTest, FastMathFlags) {
   ASSERT_TRUE(isa<Instruction>(FC));
   FAdd = cast<Instruction>(FC);
   EXPECT_TRUE(FAdd->hasAllowContract());
 
   Builder.clearFastMathFlags();
 
   // Test a call with FMF.
   auto CalleeTy = FunctionType::get(Type::getFloatTy(Ctx),
-                                    /*isVarArg=*/false);
+                                    /*isVarArg=*/false, /*AddrSpace=*/0);
   auto Callee =
       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());
TEST_F(IRBuilderTest, CreateGlobalStringPtr) {
   EXPECT_TRUE(String1a->getType()->getPointerAddressSpace() == 0);
   EXPECT_TRUE(String1b->getType()->getPointerAddressSpace() == 0);
   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);
+                                    /*isVarArg=*/false, /*AddrSpace=*/0);
   auto Callee =
       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);

unittests/IR/InstructionsTest.cpp

 // for tests that need to refer to the function in some way.
 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);
+        FunctionType::get(Type::getVoidTy(Ctx), FArgTypes, false, 0);
     F = Function::Create(FTy, Function::ExternalLinkage, "", M.get());
   }
 
   LLVMContext Ctx;
   std::unique_ptr<Module> M;
   SmallVector<Type *, 3> FArgTypes;
   Function *F;
 };
EXPECT_EQ(CastInst::isEliminableCastPair(CastInst::IntToPtr,
             CastInst::IntToPtr);
 
 }
 
 TEST(InstructionsTest, CloneCall) {
   LLVMContext C;
   Type *Int32Ty = Type::getInt32Ty(C);
   Type *ArgTys[] = {Int32Ty, Int32Ty, Int32Ty};
-  Type *FnTy = FunctionType::get(Int32Ty, ArgTys, /*isVarArg=*/false);
+  Type *FnTy = FunctionType::get(Int32Ty, ArgTys, /*isVarArg=*/false, 0);
   Value *Callee = Constant::getNullValue(FnTy->getPointerTo());
   Value *Args[] = {
     ConstantInt::get(Int32Ty, 1),
     ConstantInt::get(Int32Ty, 2),
     ConstantInt::get(Int32Ty, 3)
   };
   std::unique_ptr<CallInst> Call(CallInst::Create(Callee, Args, "result"));
 
// Test cloning an attribute.
     std::unique_ptr<CallInst> Clone(cast<CallInst>(Call->clone()));
     EXPECT_TRUE(Clone->onlyReadsMemory());
   }
 }
 
 TEST(InstructionsTest, AlterCallBundles) {
   LLVMContext C;
   Type *Int32Ty = Type::getInt32Ty(C);
-  Type *FnTy = FunctionType::get(Int32Ty, Int32Ty, /*isVarArg=*/false);
+  Type *FnTy = FunctionType::get(Int32Ty, Int32Ty, /*isVarArg=*/false, 0);
   Value *Callee = Constant::getNullValue(FnTy->getPointerTo());
   Value *Args[] = {ConstantInt::get(Int32Ty, 42)};
   OperandBundleDef OldBundle("before", UndefValue::get(Int32Ty));
   std::unique_ptr<CallInst> Call(
       CallInst::Create(Callee, Args, OldBundle, "result"));
   Call->setTailCallKind(CallInst::TailCallKind::TCK_NoTail);
   AttrBuilder AB;
   AB.addAttribute(Attribute::Cold);
TEST(InstructionsTest, AlterCallBundles) {
   EXPECT_EQ(Call->getDebugLoc(), Clone->getDebugLoc());
   EXPECT_EQ(Clone->getNumOperandBundles(), 1U);
   EXPECT_TRUE(Clone->getOperandBundle("after").hasValue());
 }
 
 TEST(InstructionsTest, AlterInvokeBundles) {
   LLVMContext C;
   Type *Int32Ty = Type::getInt32Ty(C);
-  Type *FnTy = FunctionType::get(Int32Ty, Int32Ty, /*isVarArg=*/false);
+  Type *FnTy = FunctionType::get(Int32Ty, Int32Ty, /*isVarArg=*/false, 0);
   Value *Callee = Constant::getNullValue(FnTy->getPointerTo());
   Value *Args[] = {ConstantInt::get(Int32Ty, 42)};
   std::unique_ptr<BasicBlock> NormalDest(BasicBlock::Create(C));
   std::unique_ptr<BasicBlock> UnwindDest(BasicBlock::Create(C));
   OperandBundleDef OldBundle("before", UndefValue::get(Int32Ty));
   std::unique_ptr<InvokeInst> Invoke(InvokeInst::Create(
       Callee, NormalDest.get(), UnwindDest.get(), Args, OldBundle, "result"));
   AttrBuilder AB;

unittests/IR/LegacyPassManagerTest.cpp

Module *makeLLVMModule(LLVMContext &Context) {
                          "a:0:64-s:64:64-f80:128:128");
       mod->setTargetTriple("x86_64-unknown-linux-gnu");
 
       // Type Definitions
       std::vector<Type*>FuncTy_0_args;
       FunctionType *FuncTy_0 = FunctionType::get(
           /*Result=*/IntegerType::get(Context, 32),
           /*Params=*/FuncTy_0_args,
-          /*isVarArg=*/false);
+          /*isVarArg=*/false,
+          /*AddrSpace=*/0);
 
       std::vector<Type*>FuncTy_2_args;
       FuncTy_2_args.push_back(IntegerType::get(Context, 1));
       FunctionType *FuncTy_2 = FunctionType::get(
           /*Result=*/Type::getVoidTy(Context),
           /*Params=*/FuncTy_2_args,
-          /*isVarArg=*/false);
+          /*isVarArg=*/false,
+          /*AddrSpace=*/0);
 
       // Function Declarations
 
       Function* func_test1 = Function::Create(
         /*Type=*/FuncTy_0,
         /*Linkage=*/GlobalValue::ExternalLinkage,
         /*Name=*/"test1", mod);
       func_test1->setCallingConv(CallingConv::C);

unittests/IR/MetadataTest.cpp

protected:
   }
   DIType *getCompositeType() {
     return DICompositeType::getDistinct(
         Context, dwarf::DW_TAG_structure_type, "", nullptr, 0, nullptr, nullptr,
         32, 32, 0, DINode::FlagZero, nullptr, 0, nullptr, nullptr, "");
   }
   Function *getFunction(StringRef Name) {
     return cast<Function>(M.getOrInsertFunction(
-        Name, FunctionType::get(Type::getVoidTy(Context), None, false)));
+        Name, FunctionType::get(Type::getVoidTy(Context), None, false, 0)));
   }
 };
 typedef MetadataTest MDStringTest;
 
 // Test that construction of MDString with different value produces different
 // MDString objects, even with the same string pointer and nulls in the string.
 TEST_F(MDStringTest, CreateDifferent) {
   char x[3] = { 'f', 0, 'A' };
std::string Expected;
     OS << ", null, !1, !2, !3}";
   }
 
   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 *FTy = FunctionType::get(Type::getVoidTy(Context), false, 0);
   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),
+                                         Type::getMetadataTy(Context), false,
+                                         0),
                        GlobalValue::ExternalLinkage, "llvm.intrinsic", &M);
 
-  auto *FTy = FunctionType::get(Type::getVoidTy(Context), false);
+  auto *FTy = FunctionType::get(Type::getVoidTy(Context), false, 0);
   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);

unittests/IR/PatternMatch.cpp

struct PatternMatchTest : ::testing::Test {
   std::unique_ptr<Module> M;
   Function *F;
   BasicBlock *BB;
   IRBuilder<NoFolder> IRB;
 
   PatternMatchTest()
       : M(new Module("PatternMatchTestModule", Ctx)),
         F(Function::Create(
-            FunctionType::get(Type::getVoidTy(Ctx), /* IsVarArg */ false),
+            FunctionType::get(Type::getVoidTy(Ctx), /*IsVarArg=*/false,
+                              /*AddrSpace=*/0),
             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

unittests/IR/TypeBuilderTest.cpp

TEST(TypeBuilderTest, Derived) {
   EXPECT_EQ(Type::getInt8PtrTy(Context),
             (TypeBuilder<const volatile int8_t *const volatile, false>::get(
                 Context)));
 }
 
 TEST(TypeBuilderTest, Functions) {
   LLVMContext Context;
   std::vector<Type*> params;
-  EXPECT_EQ(FunctionType::get(Type::getVoidTy(Context), params, false),
+  EXPECT_EQ(FunctionType::get(Type::getVoidTy(Context), params, false, 0),
             (TypeBuilder<void(), true>::get(Context)));
-  EXPECT_EQ(FunctionType::get(Type::getInt8Ty(Context), params, true),
+  EXPECT_EQ(FunctionType::get(Type::getInt8Ty(Context), params, true, 0),
             (TypeBuilder<int8_t(...), false>::get(Context)));
   params.push_back(TypeBuilder<int32_t *, false>::get(Context));
-  EXPECT_EQ(FunctionType::get(Type::getInt8Ty(Context), params, false),
+  EXPECT_EQ(FunctionType::get(Type::getInt8Ty(Context), params, false, 0),
             (TypeBuilder<int8_t(const int32_t *), false>::get(Context)));
-  EXPECT_EQ(FunctionType::get(Type::getInt8Ty(Context), params, true),
+  EXPECT_EQ(FunctionType::get(Type::getInt8Ty(Context), params, true, 0),
             (TypeBuilder<int8_t(const int32_t *, ...), false>::get(Context)));
   params.push_back(TypeBuilder<char *, false>::get(Context));
-  EXPECT_EQ(FunctionType::get(Type::getInt8Ty(Context), params, false),
+  EXPECT_EQ(FunctionType::get(Type::getInt8Ty(Context), params, false, 0),
             (TypeBuilder<int8_t(int32_t *, void *), false>::get(Context)));
-  EXPECT_EQ(FunctionType::get(Type::getInt8Ty(Context), params, true),
+  EXPECT_EQ(FunctionType::get(Type::getInt8Ty(Context), params, true, 0),
             (TypeBuilder<int8_t(int32_t *, char *, ...), false>::get(Context)));
   params.push_back(TypeBuilder<char, false>::get(Context));
   EXPECT_EQ(
-      FunctionType::get(Type::getInt8Ty(Context), params, false),
+      FunctionType::get(Type::getInt8Ty(Context), params, false, 0),
       (TypeBuilder<int8_t(int32_t *, void *, char), false>::get(Context)));
   EXPECT_EQ(
-      FunctionType::get(Type::getInt8Ty(Context), params, true),
+      FunctionType::get(Type::getInt8Ty(Context), params, true, 0),
       (TypeBuilder<int8_t(int32_t *, char *, char, ...), false>::get(Context)));
   params.push_back(TypeBuilder<char, false>::get(Context));
-  EXPECT_EQ(FunctionType::get(Type::getInt8Ty(Context), params, false),
+  EXPECT_EQ(FunctionType::get(Type::getInt8Ty(Context), params, false, 0),
             (TypeBuilder<int8_t(int32_t *, void *, char, char), false>::get(
                 Context)));
   EXPECT_EQ(
-      FunctionType::get(Type::getInt8Ty(Context), params, true),
+      FunctionType::get(Type::getInt8Ty(Context), params, true, 0),
       (TypeBuilder<int8_t(int32_t *, char *, char, char, ...), false>::get(
           Context)));
   params.push_back(TypeBuilder<char, false>::get(Context));
   EXPECT_EQ(
-      FunctionType::get(Type::getInt8Ty(Context), params, false),
+      FunctionType::get(Type::getInt8Ty(Context), params, false, 0),
       (TypeBuilder<int8_t(int32_t *, void *, char, char, char), false>::get(
           Context)));
-  EXPECT_EQ(FunctionType::get(Type::getInt8Ty(Context), params, true),
+  EXPECT_EQ(FunctionType::get(Type::getInt8Ty(Context), params, true, 0),
             (TypeBuilder<int8_t(int32_t *, char *, char, char, char, ...),
                          false>::get(Context)));
 }
 
 TEST(TypeBuilderTest, Context) {
   // We used to cache TypeBuilder results in static local variables.  This
   // produced the same type for different contexts, which of course broke
   // things.

unittests/IR/UserTest.cpp

TEST(UserTest, ValueOpIteration) {
   CI++;
   EXPECT_EQ(IP->getOperand(6), CI[2]);
   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);
+  FunctionType *RetVoidTy = FunctionType::get(Type::getVoidTy(Context), false, 0);
   Function *PersonalityF = Function::Create(
       RetVoidTy, GlobalValue::ExternalLinkage, "PersonalityFn", &M);
   Function *TestF =
       Function::Create(RetVoidTy, GlobalValue::ExternalLinkage, "TestFn", &M);
 
   // Set up the personality function
   TestF->setPersonalityFn(PersonalityF);
   auto PersonalityUsers = PersonalityF->user_begin();

unittests/IR/VerifierTest.cpp

 #include "gtest/gtest.h"
 
 namespace llvm {
 namespace {
 
 TEST(VerifierTest, Branch_i1) {
   LLVMContext C;
   Module M("M", C);
-  FunctionType *FTy = FunctionType::get(Type::getVoidTy(C), /*isVarArg=*/false);
+  FunctionType *FTy = FunctionType::get(Type::getVoidTy(C), /*isVarArg=*/false,
+                                        /*AddrSpace=*/0);
   Function *F = cast<Function>(M.getOrInsertFunction("foo", FTy));
   BasicBlock *Entry = BasicBlock::Create(C, "entry", F);
   BasicBlock *Exit = BasicBlock::Create(C, "exit", F);
   ReturnInst::Create(C, Exit);
 
   // To avoid triggering an assertion in BranchInst::Create, we first create
   // a branch with an 'i1' condition ...
 
   Constant *False = ConstantInt::getFalse(C);
   BranchInst *BI = BranchInst::Create(Exit, Exit, False, Entry);
 
   // ... then use setOperand to redirect it to a value of different type.
 
   Constant *Zero32 = ConstantInt::get(IntegerType::get(C, 32), 0);
   BI->setOperand(0, Zero32);
 
   EXPECT_TRUE(verifyFunction(*F));
 }
 
 TEST(VerifierTest, InvalidRetAttribute) {
   LLVMContext C;
   Module M("M", C);
-  FunctionType *FTy = FunctionType::get(Type::getInt32Ty(C), /*isVarArg=*/false);
+  FunctionType *FTy = FunctionType::get(Type::getInt32Ty(C), /*isVarArg=*/false,
+                                        /*AddrSpace=*/0);
   Function *F = cast<Function>(M.getOrInsertFunction("foo", FTy));
   AttributeList AS = F->getAttributes();
   F->setAttributes(
       AS.addAttribute(C, AttributeList::ReturnIndex, Attribute::UWTable));
 
   std::string Error;
   raw_string_ostream ErrorOS(Error);
   EXPECT_TRUE(verifyModule(M, &ErrorOS));
   EXPECT_TRUE(StringRef(ErrorOS.str()).startswith(
       "Attribute 'uwtable' only applies to functions!"));
 }
 
 TEST(VerifierTest, CrossModuleRef) {
   LLVMContext C;
   Module M1("M1", C);
   Module M2("M2", C);
   Module M3("M3", C);
-  FunctionType *FTy = FunctionType::get(Type::getInt32Ty(C), /*isVarArg=*/false);
+  FunctionType *FTy = FunctionType::get(Type::getInt32Ty(C), /*isVarArg=*/false,
+                                        /*AddrSpace=*/0);
   Function *F1 = cast<Function>(M1.getOrInsertFunction("foo1", FTy));
   Function *F2 = cast<Function>(M2.getOrInsertFunction("foo2", FTy));
   Function *F3 = cast<Function>(M3.getOrInsertFunction("foo3", FTy));
 
   BasicBlock *Entry1 = BasicBlock::Create(C, "entry", F1);
   BasicBlock *Entry3 = BasicBlock::Create(C, "entry", F3);
 
   // BAD: Referencing function in another module
EXPECT_TRUE(
       StringRef(ErrorOS.str()).startswith("Global is external, but doesn't "
                                           "have external or weak linkage!"));
 }
 
 TEST(VerifierTest, InvalidFunctionLinkage) {
   LLVMContext C;
   Module M("M", C);
 
-  FunctionType *FTy = FunctionType::get(Type::getVoidTy(C), /*isVarArg=*/false);
+  FunctionType *FTy = FunctionType::get(Type::getVoidTy(C), /*isVarArg=*/false,
+                                        /*AddrSpace=*/0);
   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!"));
 }
TEST(VerifierTest, StripInvalidDebugInfo) {
     DIBuilder DIB(M);
     auto *CU = DIB.createCompileUnit(dwarf::DW_LANG_C89,
                                      DIB.createFile("broken.c", "/"),
                                      "unittest", false, "", 0);
     new GlobalVariable(M, Type::getInt8Ty(C), false,
                        GlobalValue::ExternalLinkage, nullptr, "g");
 
     auto *F = cast<Function>(M.getOrInsertFunction(
-        "f", FunctionType::get(Type::getVoidTy(C), false)));
+        "f", FunctionType::get(Type::getVoidTy(C), false, 0)));
     IRBuilder<> Builder(BasicBlock::Create(C, "", F));
     Builder.CreateUnreachable();
     F->setSubprogram(DIB.createFunction(CU, "f", "f",
                                         DIB.createFile("broken.c", "/"), 1,
                                         nullptr, true, true, 1));
     DIB.finalize();
     EXPECT_FALSE(verifyModule(M));
 

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);
+  FunctionType *FT = FunctionType::get(Type::getVoidTy(Context), true, 0);
   std::unique_ptr<Function> F(
       Function::Create(FT, GlobalValue::ExternalLinkage));
   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)

unittests/ProfileData/InstrProfTest.cpp

TEST_P(MaybeSparseInstrProfTest, annotate_vp_data) {
   auto Profile = Writer.writeBuffer();
   readProfile(std::move(Profile));
   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);
+                                        /*isVarArg=*/false, /*AddrSpace=*/0);
   Function *F =
       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);
 
TEST_P(MaybeSparseInstrProfTest, instr_prof_bogus_symtab_empty_func_name) {
   EXPECT_TRUE(ErrorEquals(instrprof_error::malformed, Symtab.addFuncName("")));
 }
 
 // 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);
+                                        /*isVarArg=*/false, /*AddrSpace=*/0);
   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());

unittests/Transforms/Utils/Cloning.cpp

TEST_F(CloneInstruction, Exact) {
   EXPECT_FALSE(this->clone(SDiv)->isExact());
 
   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);
+  FunctionType *FT1 =  FunctionType::get(Type::getVoidTy(context), ArgTy1, false, 0);
 
   Function *F1 = Function::Create(FT1, Function::ExternalLinkage);
   BasicBlock *BB = BasicBlock::Create(context, "", F1);
   IRBuilder<> Builder(BB);
   Builder.CreateRetVoid();
 
   Function *F2 = Function::Create(FT1, Function::ExternalLinkage);
 
   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);
+  FunctionType *FT1 =  FunctionType::get(Type::getVoidTy(context), ArgTy1, false, 0);
 
   Function *F1 = Function::Create(FT1, Function::ExternalLinkage);
   F1->setCallingConv(CallingConv::Cold);
   BasicBlock *BB = BasicBlock::Create(context, "", F1);
   IRBuilder<> Builder(BB);
   Builder.CreateRetVoid();
 
   Function *F2 = Function::Create(FT1, Function::ExternalLinkage);
 
   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);
+  FunctionType *FT = FunctionType::get(Type::getVoidTy(context), ArgTy1, false, 0);
   V = new Argument(Type::getInt32Ty(context));
 
   Function *F = Function::Create(FT, Function::ExternalLinkage);
 
   BasicBlock *BB1 = BasicBlock::Create(context, "", F);
   IRBuilder<> Builder1(BB1);
 
   BasicBlock *BB2 = BasicBlock::Create(context, "", F);
protected:
 
   void TearDown() override { delete Finder; }
 
   void SetupModule() {
     M = new Module("", C);
   }
 
   void CreateOldFunc() {
-    FunctionType* FuncType = FunctionType::get(Type::getVoidTy(C), false);
+    FunctionType* FuncType = FunctionType::get(Type::getVoidTy(C), false, 0);
     OldFunc = Function::Create(FuncType, GlobalValue::PrivateLinkage, "f", M);
     CreateOldFunctionBodyAndDI();
   }
 
   void CreateOldFunctionBodyAndDI() {
     DIBuilder DBuilder(*M);
     IRBuilder<> IBuilder(C);
 
auto GV = new GlobalVariable(
         *OldM, Type::getInt32Ty(C), false, GlobalValue::ExternalLinkage,
         ConstantInt::get(Type::getInt32Ty(C), 1), "gv");
     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 *FuncType = FunctionType::get(Type::getVoidTy(C), false, 0);
     auto *PersFn = Function::Create(FuncType, GlobalValue::ExternalLinkage,
                                     "persfn", OldM);
     auto *F =
         Function::Create(FuncType, GlobalValue::PrivateLinkage, "f", OldM);
     F->setPersonalityFn(PersFn);
     F->setComdat(CD);
 
     // Create debug info

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),
+                                                   ArgTys, false, 0),
                                  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++;

 
 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),
+                                                   ArgTys, false, 0),
                                  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++;

 
 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),
+                                                   ArgTys, false, 0),
                                  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++;

 
 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),
+                                                   ArgTys, false, 0),
                                  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++;

 
 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),
+                                                   ArgTys, false, 0),
                                  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++;

 
 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),
+                                                   ArgTys, false, 0),
                                  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++;

 
 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),
+                                                   ArgTys, false, 0),
                                  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++;

 
 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),
+                                                   ArgTys, false, 0),
                                  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++;

unittests/Transforms/Utils/Local.cpp

TEST(Local, RecursivelyDeleteDeadPHINodes) {
   delete bb1;
 }
 
 TEST(Local, RemoveDuplicatePHINodes) {
   LLVMContext C;
   IRBuilder<> B(C);
 
   std::unique_ptr<Function> F(
-      Function::Create(FunctionType::get(B.getVoidTy(), false),
+      Function::Create(FunctionType::get(B.getVoidTy(), false, 0),
                        GlobalValue::ExternalLinkage, "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);