Add support for multiple program address spaces

[pmatos]

Summary

Allows for multiple program address spaces to be defined through
multiple Px-Py... in the data layout.
If none is specified, the default program address space is 0.

Unless data layout is modified with multiple Px, this patch shouldn't
have any effect on current code.

[pmatos]

This is WIP - there a still a few test failures but I am happy to start getting comments on this.

This is in preparation for implementation of reference types for the WebAssembly backend that requires functions to be able to live in multiple address spaces.

[tlively]

I think this is a good direction overall, and I'm glad the code doesn't become any messier with this change. I do think it would be good to also email llvm-dev about this change to get general feedback and make sure it doesn't require a full RFC.

llvm/lib/AsmParser/LLParser.cpp

1470–1471

Or maybe this comment can be removed since it is subsumed by the comment you added just below.

1491

It would be good to add a test for this error message (if one doesn't already exist). It's not obvious to me that the expected type in the error message will always have a correct program address space.

llvm/lib/IR/DataLayout.cpp

476

It would be good to check for repeats here. As it is, hasNonZeroProgramAddressSpace() would return true for "P0-P0" .

[pmatos]

Ensure the program address spaces vector doesn't contain duplicates.

[pmatos]

Fix type check.

[jdoerfert]

I'll be on the lookout for the RFC. There, and in an updated commit message, you have to provide more details.

http://lists.llvm.org/pipermail/llvm-dev/2020-July/143808.html is related as well.

[arsenm]

While the IR definitely should support mixing functions with different address spaces, I don't see the point of encoding multiple of these in the datalayout

llvm/include/llvm/IR/DataLayout.h

125–130

I don't see why we need a list of program address spaces. The datalayout only needs to know the one to use for situations when generic code needs to synthesize a function out of thin air. Anything beyond that would need target information in the specific pass.

[tlively]

@arsenm, Are you suggesting that we just relax the verification rules to allow calling function pointers to arbitrary address spaces without needing any changes to the data layout string? That seems fine to me, but the data layout string solution does allow targets to opt in to more precise validation.

[pmatos]

The RFC has now been sent to the mailing list: http://lists.llvm.org/pipermail/llvm-dev/2020-November/146723.html

[arichardson]

I don't see why you would need multiple program address spaces to support calls to other address spaces. You can already do the following:

define i32 @foo(i32) addrspace(1) {
    %ret = add i32 %0, 1
    ret i32 %ret
}

define i32 @bar() addrspace(0) {
    %call = call addrspace(1) i32 @foo(i32 1)
    ret i32 %call
}

Isn't that sufficient for your WebAssembly changes?

[arichardson]

The change to rename getProgramAddressSpace getDefaultProgramAddressSpace seems fine to me since it matches the GlobalsAddressSpace.

By the way, your test already seems to work (if you add an explicit call addrspace(1) void %ref() for llc: https://godbolt.org/z/arj9M9

[jrtc27]

Currently P0-P1 is valid and results in the program address space being 1, but this patch changes the semantics of that. How sure are you that nothing will break? I do not like the idea of reusing existing valid syntax to mean something else; if you want to introduce some notion of secondary program address spaces then the syntax should be different.

However, I don't understand why this is needed; can you not just change your call void %ref() to call addrspace(1) void %ref()? That gets parsed and type-checked just fine for me, i.e. this is not adding anything significant to LLVM other than letting you be lazy and drop the address space for calls through function pointers to a non-default address space?

[pmatos]

Thanks, @arichardson and @jrtc27 for your comments.
I am definitely surprised to find that if you explicitly mark the call with the address space, this patch is not required. At first look, this RFC is not required any more but I need sometime to investigate further. If no changes are necessary, this is indeed good news.

[pmatos]

In D91428#2413292, @pmatos wrote:

Thanks, @arichardson and @jrtc27 for your comments.
I am definitely surprised to find that if you explicitly mark the call with the address space, this patch is not required. At first look, this RFC is not required any more but I need sometime to investigate further. If no changes are necessary, this is indeed good news.

Thank you for your comments - I am dropping this patch and the RFC as it is indeed not required by my use case.

clang/lib/CodeGen/CGException.cpp

static llvm::FunctionCallee getPersonalityFn(CodeGenModule &CGM,
   return CGM.CreateRuntimeFunction(llvm::FunctionType::get(CGM.Int32Ty, true),
                                    Personality.PersonalityFn,
                                    llvm::AttributeList(), /*Local=*/true);
 }
 
 static llvm::Constant *getOpaquePersonalityFn(CodeGenModule &CGM,
                                         const EHPersonality &Personality) {
   llvm::FunctionCallee Fn = getPersonalityFn(CGM, Personality);
-  llvm::PointerType* Int8PtrTy = llvm::PointerType::get(
+  llvm::PointerType *Int8PtrTy = llvm::PointerType::get(
       llvm::Type::getInt8Ty(CGM.getLLVMContext()),
-      CGM.getDataLayout().getProgramAddressSpace());
+      CGM.getDataLayout().getDefaultProgramAddressSpace());
 
   return llvm::ConstantExpr::getBitCast(cast<llvm::Constant>(Fn.getCallee()),
                                         Int8PtrTy);
 }
 
 /// Check whether a landingpad instruction only uses C++ features.
 static bool LandingPadHasOnlyCXXUses(llvm::LandingPadInst *LPI) {
   for (unsigned I = 0, E = LPI->getNumClauses(); I != E; ++I) {

clang/lib/CodeGen/CodeGenModule.cpp

void CodeGenModule::AddGlobalDtor(llvm::Function *Dtor, int Priority) {
   GlobalDtors.push_back(Structor(Priority, Dtor, nullptr));
 }
 
 void CodeGenModule::EmitCtorList(CtorList &Fns, const char *GlobalName) {
   if (Fns.empty()) return;
 
   // Ctor function type is void()*.
   llvm::FunctionType* CtorFTy = llvm::FunctionType::get(VoidTy, false);
-  llvm::Type *CtorPFTy = llvm::PointerType::get(CtorFTy,
-      TheModule.getDataLayout().getProgramAddressSpace());
+  llvm::Type *CtorPFTy = llvm::PointerType::get(
+      CtorFTy, TheModule.getDataLayout().getDefaultProgramAddressSpace());
 
   // Get the type of a ctor entry, { i32, void ()*, i8* }.
   llvm::StructType *CtorStructTy = llvm::StructType::get(
       Int32Ty, CtorPFTy, VoidPtrTy);
 
   // Construct the constructor and destructor arrays.
   ConstantInitBuilder builder(*this);
   auto ctors = builder.beginArray(CtorStructTy);

clang/lib/CodeGen/CodeGenTypes.cpp

#include "clang/AST/BuiltinTypes.def"
   case Type::Pointer: {
     const PointerType *PTy = cast<PointerType>(Ty);
     QualType ETy = PTy->getPointeeType();
     llvm::Type *PointeeType = ConvertTypeForMem(ETy);
     if (PointeeType->isVoidTy())
       PointeeType = llvm::Type::getInt8Ty(getLLVMContext());
 
     unsigned AS = PointeeType->isFunctionTy()
-                      ? getDataLayout().getProgramAddressSpace()
+                      ? getDataLayout().getDefaultProgramAddressSpace()
                       : Context.getTargetAddressSpace(ETy);
 
     ResultType = llvm::PointerType::get(PointeeType, AS);
     break;
   }
 
   case Type::VariableArray: {
     const VariableArrayType *A = cast<VariableArrayType>(Ty);

llvm/docs/LangRef.rst

 ``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.
+    Specifies an address space that corresponds to program memory.
     Harvard architectures can use this to specify what space LLVM
     should place things such as functions 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``'.
     Defaults to the default address space of 0.

llvm/include/llvm/CodeGen/TargetLowering.h

public:
   /// the alloca address space specified through the data layout.
   MVT getFrameIndexTy(const DataLayout &DL) const {
     return getPointerTy(DL, DL.getAllocaAddrSpace());
   }
 
   /// Return the type for code pointers, which is determined by the program
   /// address space specified through the data layout.
   MVT getProgramPointerTy(const DataLayout &DL) const {
-    return getPointerTy(DL, DL.getProgramAddressSpace());
+    return getPointerTy(DL, DL.getDefaultProgramAddressSpace());
   }
 
   /// Return the type for operands of fence.
   /// TODO: Let fence operands be of i32 type and remove this.
   virtual MVT getFenceOperandTy(const DataLayout &DL) const {
     return getPointerTy(DL);
   }
 

llvm/include/llvm/IR/DataLayout.h

enum class FunctionPtrAlignType {
     MultipleOfFunctionAlign,
   };
 private:
   /// Defaults to false.
   bool BigEndian;
 
   unsigned AllocaAddrSpace;
   MaybeAlign StackNaturalAlign;
-  unsigned ProgramAddrSpace;
+  /// Vector of address spaces that can contain code
+  /// Always non-empty, contains the default address space by default.
+  /// Harvard architectures can specify a different address space.
+  /// WebAssembly might specify more than one address space.
+  SmallVector<unsigned, 8> ProgramAddrSpaces;
 
   MaybeAlign FunctionPtrAlign;
   FunctionPtrAlignType TheFunctionPtrAlignType;
 
   enum ManglingModeT {
     MM_None,
     MM_ELF,
     MM_MachO,
     MM_WinCOFF,
public:
   DataLayout &operator=(const DataLayout &DL) {
     clear();
     StringRepresentation = DL.StringRepresentation;
     BigEndian = DL.isBigEndian();
     AllocaAddrSpace = DL.AllocaAddrSpace;
     StackNaturalAlign = DL.StackNaturalAlign;
     FunctionPtrAlign = DL.FunctionPtrAlign;
     TheFunctionPtrAlignType = DL.TheFunctionPtrAlignType;
-    ProgramAddrSpace = DL.ProgramAddrSpace;
+    ProgramAddrSpaces = DL.ProgramAddrSpaces;
     ManglingMode = DL.ManglingMode;
     LegalIntWidths = DL.LegalIntWidths;
     Alignments = DL.Alignments;
     Pointers = DL.Pointers;
     NonIntegralAddressSpaces = DL.NonIntegralAddressSpaces;
     return *this;
   }
 
public:
   MaybeAlign getFunctionPtrAlign() const { return FunctionPtrAlign; }
 
   /// Return the type of function pointer alignment.
   /// \see getFunctionPtrAlign
   FunctionPtrAlignType getFunctionPtrAlignType() const {
     return TheFunctionPtrAlignType;
   }
 
-  unsigned getProgramAddressSpace() const { return ProgramAddrSpace; }
+  ArrayRef<unsigned> getProgramAddressSpaces() const {
+    assert(!ProgramAddrSpaces.empty());
+    return ProgramAddrSpaces;
+  }
+
+  unsigned getDefaultProgramAddressSpace() const {
+    assert(!ProgramAddrSpaces.empty());
+    return ProgramAddrSpaces[0];
+  }
+
+  bool isProgramAddressSpace(unsigned AddrSpace) const {
+    ArrayRef<unsigned> ProgramAddressSpaces = getProgramAddressSpaces();
+    return find(ProgramAddressSpaces, AddrSpace) != ProgramAddressSpaces.end();
+  }
+
+  bool isPointerTypeInProgramAddressSpace(PointerType *PT) const {
+    return isProgramAddressSpace(PT->getAddressSpace());
+  }
+
+  bool isPointerTypeInProgramAddressSpace(Type *Ty) const {
+    auto *PTy = dyn_cast<PointerType>(Ty);
+    return PTy && isPointerTypeInProgramAddressSpace(PTy);
+  }
+
+  bool hasNonZeroProgramAddressSpace() const {
+    return ProgramAddrSpaces.size() > 1 || ProgramAddrSpaces[0] != 0;
+  }
 
   bool hasMicrosoftFastStdCallMangling() const {
     return ManglingMode == MM_WinCOFFX86;
   }
 
   /// Returns true if symbols with leading question marks should not receive IR
   /// mangling. True for Windows mangling modes.
   bool doNotMangleLeadingQuestionMark() const {

llvm/include/llvm/Target/TargetMachine.h

unsigned getPointerSize(unsigned AS) const {
     return DL.getPointerSize(AS);
   }
 
   unsigned getPointerSizeInBits(unsigned AS) const {
     return DL.getPointerSizeInBits(AS);
   }
 
   unsigned getProgramPointerSize() const {
-    return DL.getPointerSize(DL.getProgramAddressSpace());
+    return DL.getPointerSize(DL.getDefaultProgramAddressSpace());
   }
 
   unsigned getAllocaPointerSize() const {
     return DL.getPointerSize(DL.getAllocaAddrSpace());
   }
 
   /// Reset the target options based on the function's attributes.
   // FIXME: Remove TargetOptions that affect per-function code generation

llvm/lib/AsmParser/LLParser.h

private:
     bool parseStringAttribute(AttrBuilder &B);
 
     bool parseTLSModel(GlobalVariable::ThreadLocalMode &TLM);
     bool parseOptionalThreadLocal(GlobalVariable::ThreadLocalMode &TLM);
     bool parseOptionalUnnamedAddr(GlobalVariable::UnnamedAddr &UnnamedAddr);
     bool parseOptionalAddrSpace(unsigned &AddrSpace, unsigned DefaultAS = 0);
     bool parseOptionalProgramAddrSpace(unsigned &AddrSpace) {
       return parseOptionalAddrSpace(
-          AddrSpace, M->getDataLayout().getProgramAddressSpace());
+          AddrSpace, M->getDataLayout().getDefaultProgramAddressSpace());
     };
     bool parseOptionalParamAttrs(AttrBuilder &B);
     bool parseOptionalReturnAttrs(AttrBuilder &B);
     bool parseOptionalLinkage(unsigned &Res, bool &HasLinkage,
                               unsigned &Visibility, unsigned &DLLStorageClass,
                               bool &DSOLocal);
     void parseOptionalDSOLocal(bool &DSOLocal);
     void parseOptionalVisibility(unsigned &Res);

llvm/lib/AsmParser/LLParser.cpp

return new GlobalVariable(*M, PTy->getElementType(), false,
                               nullptr, GlobalVariable::NotThreadLocal,
                               PTy->getAddressSpace());
 }
 
 Value *LLParser::checkValidVariableType(LocTy Loc, const Twine &Name, Type *Ty,
                                         Value *Val, bool IsCall) {
   if (Val->getType() == Ty)
     return Val;
+
   // For calls we also accept variables in the program address space.
-  Type *SuggestedTy = Ty;
   if (IsCall && isa<PointerType>(Ty)) {
+    // Call through a function pointer
+    // The type can live in any of the program address spaces
+
+    // We check if the address space of the pointer type of Val is one
+    // of the defined program address spaces and if with that AS, Ty matches
+    // Val's type.
+    if (M->getDataLayout().isPointerTypeInProgramAddressSpace(Ty)) {
       Type *TyInProgAS = cast<PointerType>(Ty)->getElementType()->getPointerTo(
-        M->getDataLayout().getProgramAddressSpace());
-    SuggestedTy = TyInProgAS;
+          cast<PointerType>(Val->getType())->getAddressSpace());
+
       if (Val->getType() == TyInProgAS)
         return Val;
     }
+  }
   if (Ty->isLabelTy())
     error(Loc, "'" + Name + "' is not a basic block");
   else
     error(Loc, "'" + Name + "' defined with type '" +
                    getTypeString(Val->getType()) + "' but expected '" +
-                   getTypeString(SuggestedTy) + "'");
+                   getTypeString(Ty) + "'");
   return nullptr;
 }
 
 /// getGlobalVal - Get a value with the specified name or ID, creating a
 /// forward reference record if needed.  This can return null if the value
 /// exists but does not have the right type.
 GlobalValue *LLParser::getGlobalVal(const std::string &Name, Type *Ty,
                                     LocTy Loc, bool IsCall) {

llvm/lib/Bitcode/Reader/BitcodeReader.cpp

if (isa<PointerType>(FTy))
     std::tie(FullFTy, FTy) = getPointerElementTypes(FullFTy);
 
   if (!isa<FunctionType>(FTy))
     return error("Invalid type for value");
   auto CC = static_cast<CallingConv::ID>(Record[1]);
   if (CC & ~CallingConv::MaxID)
     return error("Invalid calling convention ID");
 
-  unsigned AddrSpace = TheModule->getDataLayout().getProgramAddressSpace();
+  unsigned AddrSpace =
+      TheModule->getDataLayout().getDefaultProgramAddressSpace();
   if (Record.size() > 16)
     AddrSpace = Record[16];
 
   Function *Func =
       Function::Create(cast<FunctionType>(FTy), GlobalValue::ExternalLinkage,
                        AddrSpace, Name, TheModule);
 
   assert(Func->getFunctionType() == flattenPointerTypes(FullFTy) &&

llvm/lib/IR/AsmWriter.cpp

void AssemblyWriter::printFunction(const Function *F) {
   StringRef UA = getUnnamedAddrEncoding(F->getUnnamedAddr());
   if (!UA.empty())
     Out << ' ' << UA;
   // We print the function address space if it is non-zero or if we are writing
   // a module with a non-zero program address space or if there is no valid
   // Module* so that the file can be parsed without the datalayout string.
   const Module *Mod = F->getParent();
   if (F->getAddressSpace() != 0 || !Mod ||
-      Mod->getDataLayout().getProgramAddressSpace() != 0)
+      Mod->getDataLayout().hasNonZeroProgramAddressSpace())
     Out << " addrspace(" << F->getAddressSpace() << ")";
   if (Attrs.hasAttributes(AttributeList::FunctionIndex))
     Out << " #" << Machine.getAttributeGroupSlot(Attrs.getFnAttributes());
   if (F->hasSection()) {
     Out << " section \"";
     printEscapedString(F->getSection(), Out);
     Out << '"';
   }
static void maybePrintCallAddrSpace(const Value *Operand, const Instruction *I,
   // We print the address space of the call if it is non-zero.
   unsigned CallAddrSpace = Operand->getType()->getPointerAddressSpace();
   bool PrintAddrSpace = CallAddrSpace != 0;
   if (!PrintAddrSpace) {
     const Module *Mod = getModuleFromVal(I);
     // We also print it if it is zero but not equal to the program address space
     // or if we can't find a valid Module* to make it possible to parse
     // the resulting file even without a datalayout string.
-    if (!Mod || Mod->getDataLayout().getProgramAddressSpace() != 0)
+    if (!Mod || Mod->getDataLayout().hasNonZeroProgramAddressSpace())
       PrintAddrSpace = true;
   }
   if (PrintAddrSpace)
     Out << " addrspace(" << CallAddrSpace << ")";
 }
 
 // This member is called for each Instruction in a function..
 void AssemblyWriter::printInstruction(const Instruction &I) {

llvm/lib/IR/DataLayout.cpp

 
 void DataLayout::reset(StringRef Desc) {
   clear();
 
   LayoutMap = nullptr;
   BigEndian = false;
   AllocaAddrSpace = 0;
   StackNaturalAlign.reset();
-  ProgramAddrSpace = 0;
+  ProgramAddrSpaces.clear();
   FunctionPtrAlign.reset();
   TheFunctionPtrAlignType = FunctionPtrAlignType::Independent;
   ManglingMode = MM_None;
   NonIntegralAddressSpaces.clear();
 
   // Default alignments
   for (const LayoutAlignElem &E : DefaultAlignments) {
     if (Error Err = setAlignment((AlignTypeEnum)E.AlignType, E.ABIAlign,
case 'F': {
       if (Error Err = getIntInBytes(Tok, Alignment))
         return Err;
       if (Alignment != 0 && !llvm::isPowerOf2_64(Alignment))
         return reportError("Alignment is neither 0 nor a power of 2");
       FunctionPtrAlign = MaybeAlign(Alignment);
       break;
     }
     case 'P': { // Function address space.
-      if (Error Err = getAddrSpace(Tok, ProgramAddrSpace))
+      unsigned pa;
+      if (Error Err = getAddrSpace(Tok, pa))
         return Err;
+
+      // Only add if not already defined
+      bool found = false;
+      for (size_t i = 0; i < ProgramAddrSpaces.size(); i++) {
+        if (ProgramAddrSpaces[i] == pa) {
+          found = true;
+          break;
+        }
+      }
+      if (!found)
+        ProgramAddrSpaces.push_back(pa);
       break;
     }
     case 'A': { // Default stack/alloca address space.
       if (Error Err = getAddrSpace(Tok, AllocaAddrSpace))
         return Err;
       break;
     }
     case 'm':
case 'm':
       }
       break;
     default:
       return reportError("Unknown specifier in datalayout string");
       break;
     }
   }
 
+  // If Program address spaces is empty, add the default address space (0)
+  if (ProgramAddrSpaces.empty())
+    ProgramAddrSpaces.push_back(0);
+
   return Error::success();
 }
 
 DataLayout::DataLayout(const Module *M) {
   init(M);
 }
 
 void DataLayout::init(const Module *M) { *this = M->getDataLayout(); }
 
 bool DataLayout::operator==(const DataLayout &Other) const {
   bool Ret = BigEndian == Other.BigEndian &&
              AllocaAddrSpace == Other.AllocaAddrSpace &&
              StackNaturalAlign == Other.StackNaturalAlign &&
-             ProgramAddrSpace == Other.ProgramAddrSpace &&
+             ProgramAddrSpaces == Other.ProgramAddrSpaces &&
              FunctionPtrAlign == Other.FunctionPtrAlign &&
              TheFunctionPtrAlignType == Other.TheFunctionPtrAlignType &&
              ManglingMode == Other.ManglingMode &&
              LegalIntWidths == Other.LegalIntWidths &&
              Alignments == Other.Alignments && Pointers == Other.Pointers;
   // Note: getStringRepresentation() might differs, it is not canonicalized
   return Ret;
 }

llvm/lib/IR/Function.cpp

unsigned Function::getInstructionCount() const {
   for (const BasicBlock &BB : BasicBlocks)
     NumInstrs += std::distance(BB.instructionsWithoutDebug().begin(),
                                BB.instructionsWithoutDebug().end());
   return NumInstrs;
 }
 
 Function *Function::Create(FunctionType *Ty, LinkageTypes Linkage,
                            const Twine &N, Module &M) {
-  return Create(Ty, Linkage, M.getDataLayout().getProgramAddressSpace(), N, &M);
+  return Create(Ty, Linkage, M.getDataLayout().getDefaultProgramAddressSpace(),
+                N, &M);
 }
 
 void Function::removeFromParent() {
   getParent()->getFunctionList().remove(getIterator());
 }
 
 void Function::eraseFromParent() {
   getParent()->getFunctionList().erase(getIterator());
 }
 
 //===----------------------------------------------------------------------===//
 // Function Implementation
 //===----------------------------------------------------------------------===//
 
 static unsigned computeAddrSpace(unsigned AddrSpace, Module *M) {
   // If AS == -1 and we are passed a valid module pointer we place the function
   // in the program address space. Otherwise we default to AS0.
   if (AddrSpace == static_cast<unsigned>(-1))
-    return M ? M->getDataLayout().getProgramAddressSpace() : 0;
+    return M ? M->getDataLayout().getDefaultProgramAddressSpace() : 0;
   return AddrSpace;
 }
 
 Function::Function(FunctionType *Ty, LinkageTypes Linkage, unsigned AddrSpace,
                    const Twine &name, Module *ParentModule)
     : GlobalObject(Ty, Value::FunctionVal,
                    OperandTraits<Function>::op_begin(this), 0, Linkage, name,
                    computeAddrSpace(AddrSpace, ParentModule)),

llvm/lib/IR/Module.cpp

 //
 FunctionCallee Module::getOrInsertFunction(StringRef Name, FunctionType *Ty,
                                            AttributeList AttributeList) {
   // See if we have a definition for the specified function already.
   GlobalValue *F = getNamedValue(Name);
   if (!F) {
     // Nope, add it
     Function *New = Function::Create(Ty, GlobalVariable::ExternalLinkage,
-                                     DL.getProgramAddressSpace(), Name);
+                                     DL.getDefaultProgramAddressSpace(), Name);
     if (!New->isIntrinsic())       // Intrinsics get attrs set on construction
       New->setAttributes(AttributeList);
     FunctionList.push_back(New);
     return {Ty, New}; // Return the new prototype.
   }
 
   // If the function exists but has the wrong type, return a bitcast to the
   // right type.

llvm/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(DL.getProgramAddressSpace());
+          FunctionType::get(Type::getVoidTy(Context), false)
+              ->getPointerTo(DL.getDefaultProgramAddressSpace());
       Assert(STy &&
                  (STy->getNumElements() == 2 || STy->getNumElements() == 3) &&
                  STy->getTypeAtIndex(0u)->isIntegerTy(32) &&
                  STy->getTypeAtIndex(1) == FuncPtrTy,
              "wrong type for intrinsic global variable", &GV);
       Assert(STy->getNumElements() == 3,
              "the third field of the element type is mandatory, "
              "specify i8* null to migrate from the obsoleted 2-field form");

llvm/lib/Transforms/IPO/LowerTypeTests.cpp

else if (Arch == Triple::wasm32 || Arch == Triple::wasm64)
     buildBitSetsFromFunctionsWASM(TypeIds, Functions);
   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()),
+    WeakInitializerFn =
+        Function::Create(FunctionType::get(Type::getVoidTy(M.getContext()),
                                            /* IsVarArg */ false),
                          GlobalValue::InternalLinkage,
-        M.getDataLayout().getProgramAddressSpace(),
+                         M.getDataLayout().getDefaultProgramAddressSpace(),
                          "__cfi_global_var_init", &M);
     BasicBlock *BB =
         BasicBlock::Create(M.getContext(), "entry", WeakInitializerFn);
     ReturnInst::Create(M.getContext(), BB);
     WeakInitializerFn->setSection(
         ObjectFormat == Triple::MachO
             ? "__TEXT,__StaticInit,regular,pure_instructions"
             : ".text.startup");
     // This code is equivalent to relocation application, and should run at the
void LowerTypeTestsModule::buildBitSetsFromFunctionsNative(
   assert(!Functions.empty());
 
   // 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),
-                       GlobalValue::PrivateLinkage,
-                       M.getDataLayout().getProgramAddressSpace(),
-                       ".cfi.jumptable", &M);
+  Function *JumpTableFn = Function::Create(
+      FunctionType::get(Type::getVoidTy(M.getContext()),
+      M.getDataLayout().getDefaultProgramAddressSpace(), ".cfi.jumptable", &M);
   ArrayType *JumpTableType =
       ArrayType::get(getJumpTableEntryType(), Functions.size());
   auto JumpTable =
       ConstantExpr::getPointerCast(JumpTableFn, JumpTableType->getPointerTo(0));
 
   lowerTypeTestCalls(TypeIds, JumpTable, GlobalLayout);
 
   {
if (CfiFunctionsMD) {
           F->setName(F->getName() + ".1");
           F = nullptr;
         }
 
         if (!F)
           F = Function::Create(
               FunctionType::get(Type::getVoidTy(M.getContext()), false),
               GlobalVariable::ExternalLinkage,
-              M.getDataLayout().getProgramAddressSpace(), FunctionName, &M);
+              M.getDataLayout().getDefaultProgramAddressSpace(), FunctionName,
+              &M);
 
         // If the function is available_externally, remove its definition so
         // that it is handled the same way as a declaration. Later we will try
         // to create an alias using this function's linkage, which will fail if
         // the linkage is available_externally. This will also result in us
         // following the code path below to replace the type metadata.
         if (F->hasAvailableExternallyLinkage()) {
           F->setLinkage(GlobalValue::ExternalLinkage);

llvm/lib/Transforms/IPO/WholeProgramDevirt.cpp

void DevirtModule::tryICallBranchFunnel(
   if (!HasNonDevirt)
     return;
 
   FunctionType *FT =
       FunctionType::get(Type::getVoidTy(M.getContext()), {Int8PtrTy}, true);
   Function *JT;
   if (isa<MDString>(Slot.TypeID)) {
     JT = Function::Create(FT, Function::ExternalLinkage,
-                          M.getDataLayout().getProgramAddressSpace(),
+                          M.getDataLayout().getDefaultProgramAddressSpace(),
                           getGlobalName(Slot, {}, "branch_funnel"), &M);
     JT->setVisibility(GlobalValue::HiddenVisibility);
   } else {
     JT = Function::Create(FT, Function::InternalLinkage,
-                          M.getDataLayout().getProgramAddressSpace(),
+                          M.getDataLayout().getDefaultProgramAddressSpace(),
                           "branch_funnel", &M);
   }
   JT->addAttribute(1, Attribute::Nest);
 
   std::vector<Value *> JTArgs;
   JTArgs.push_back(JT->arg_begin());
   for (auto &T : TargetsForSlot) {
     JTArgs.push_back(getMemberAddr(T.TM));

llvm/test/Assembler/function-address_spaces.ll

+; RUN: llvm-as < %s | llvm-dis | FileCheck  %s
+
+; specifying explicitly P:0 (although it's the default)
+; P:1 specifies an extra address space for code where funcrefs live
+target datalayout = "e-m:e-p:32:32-i64:64-n32:64-S128-ni:1-P0-P1"
+
+; square and double_square are in addrspace(0)
+define i32 @square(i32 %0) {
+; CHECK: define i32 @square(i32 %0) addrspace(0) {
+       %2 = mul nsw i32 %0, %0
+       ret i32 %2
+}
+
+define i32 @double_square(i32 %0) {
+; CHECK: define i32 @double_square(i32 %0) addrspace(0) {
+       %2 = shl i32 %0, 1
+       %3 = mul i32 %2, %0
+       ret i32 %3
+}
+
+; funcref is a pointer to a function in addrspace(1)
+; called in call_funcref
+%func = type void ()
+%funcref = type %func addrspace(1)*
+
+define void @call_funcref(%funcref %ref) {
+; CHECK: define void @call_funcref(void () addrspace(1)* %ref) addrspace(0) {
+       call void %ref()
+       ret void
+}