[CIR][CIRGen] Enable address space flags and re-categorize / fix usages

clang/include/clang/CIR/Dialect/IR/CIRTypes.td

@@ -194,9 +194,22 @@ def CIR_PointerType : CIR_Type<"Pointer", "ptr",
     `CIR.ptr` is a type returned by any op generating a pointer in C++.
   }];
 
-  let parameters = (ins "mlir::Type":$pointee);
+  let parameters = (ins "mlir::Type":$pointee, DefaultValuedParameter<"unsigned", "0">:$addrSpace);
 
-  let assemblyFormat = "`<` $pointee `>`";
+  let builders = [
+    TypeBuilderWithInferredContext<(ins "mlir::Type":$pointee, CArg<"unsigned", "0">:$addrSpace), [{
+      return Base::get(pointee.getContext(), pointee, addrSpace);
+    }]>,
+    TypeBuilder<(ins "mlir::Type":$pointee, CArg<"unsigned", "0">:$addrSpace), [{
+      return Base::get($_ctxt, pointee, addrSpace);
+    }]>,
+  ];
+
+  let assemblyFormat = [{
+    `<` $pointee ( `,` `addrspace` `(` $addrSpace^ `)` )? `>`
+  }];
+
+  let skipDefaultBuilders = 1;
 
   let extraClassDeclaration = [{
     bool isVoidPtr() const {

clang/lib/CIR/CodeGen/CIRGenBuilder.h

@@ -643,9 +643,8 @@ class CIRGenBuilderTy : public CIRBaseBuilderTy {
 
   mlir::Value createDynCastToVoid(mlir::Location loc, mlir::Value src,
                                   bool vtableUseRelativeLayout) {
-    // TODO(cir): consider address space here.
-    assert(!UnimplementedFeature::addressSpace());
-    auto destTy = getVoidPtrTy();
+    auto srcTy = src.getType().cast<mlir::cir::PointerType>();
+    auto destTy = getVoidPtrTy(srcTy.getAddrSpace());
     return create<mlir::cir::DynamicCastOp>(
         loc, destTy, mlir::cir::DynamicCastKind::ptr, src,
         mlir::cir::DynamicCastInfoAttr{}, vtableUseRelativeLayout);
@@ -875,11 +874,11 @@ class CIRGenBuilderTy : public CIRBaseBuilderTy {
   mlir::cir::GetRuntimeMemberOp createGetIndirectMember(mlir::Location loc,
                                                         mlir::Value objectPtr,
                                                         mlir::Value memberPtr) {
+    auto objectPtrTy = objectPtr.getType().cast<mlir::cir::PointerType>();
     auto memberPtrTy = memberPtr.getType().cast<mlir::cir::DataMemberType>();
 
-    // TODO(cir): consider address space.
-    assert(!UnimplementedFeature::addressSpace());
-    auto resultTy = getPointerTo(memberPtrTy.getMemberTy());
+    auto resultTy =
+        getPointerTo(memberPtrTy.getMemberTy(), objectPtrTy.getAddrSpace());
 
     return create<mlir::cir::GetRuntimeMemberOp>(loc, resultTy, objectPtr,
                                                  memberPtr);

clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp

@@ -842,8 +842,11 @@ RValue CIRGenFunction::buildBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
     // FIXME(cir): It may make sense to allow AllocaOp of type `u8` to return a
     // pointer of type `void *`. This will require a change to the allocaOp
     // verifier.
+
+    LangAS AAS = getASTAllocaAddressSpace();
+    auto TargetAAS = CGM.getASTContext().getTargetAddressSpace(AAS);
     auto AllocaAddr = builder.createAlloca(
-        getLoc(E->getSourceRange()), builder.getUInt8PtrTy(),
+        getLoc(E->getSourceRange()), builder.getUInt8PtrTy(TargetAAS),
         builder.getUInt8Ty(), "bi_alloca", SuitableAlignmentInBytes, Size);
 
     // Initialize the allocated buffer if required.
@@ -855,16 +858,16 @@ RValue CIRGenFunction::buildBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
     // default (e.g. in C / C++ auto vars are in the generic address space). At
     // the AST level this is handled within CreateTempAlloca et al., but for the
     // builtin / dynamic alloca we have to handle it here.
-    assert(!UnimplementedFeature::addressSpace());
-    LangAS AAS = getASTAllocaAddressSpace();
     LangAS EAS = E->getType()->getPointeeType().getAddressSpace();
     if (EAS != AAS) {
-      assert(false && "Non-default address space for alloca NYI");
+      // TODO(cir): perform a address space casting from AAS to EAS
+      assert(!UnimplementedFeature::addressSpaceCasting());
+      llvm_unreachable("Non-default address space for alloca NYI");
     }
 
     // Bitcast the alloca to the expected type.
     return RValue::get(
-        builder.createBitcast(AllocaAddr, builder.getVoidPtrTy()));
+        builder.createBitcast(AllocaAddr, builder.getVoidPtrTy(TargetAAS)));
   }
 
   case Builtin::BI__builtin_add_overflow:

clang/lib/CIR/CodeGen/CIRGenClass.cpp

@@ -694,8 +694,8 @@ void CIRGenFunction::initializeVTablePointer(mlir::Location loc,
   // Finally, store the address point. Use the same CIR types as the field.
   //
   // vtable field is derived from `this` pointer, therefore they should be in
-  // the same addr space.
-  assert(!UnimplementedFeature::addressSpace());
+  // the same addr space. while vtable APs should use addr space for globals,
+  // which we should ensure when creating these ops in CXX ABI.
   VTableField = builder.createElementBitCast(loc, VTableField,
                                              VTableAddressPoint.getType());
   builder.createStore(loc, VTableAddressPoint, VTableField);
@@ -1384,7 +1384,7 @@ CIRGenFunction::getAddressOfBaseClass(Address Value,
 
   // Get the base pointer type.
   auto BaseValueTy = convertType((PathEnd[-1])->getType());
-  assert(!UnimplementedFeature::addressSpace());
+  // TODO(cir): specify addr space in base ptr ty
   // auto BasePtrTy = builder.getPointerTo(BaseValueTy);
   // QualType DerivedTy = getContext().getRecordType(Derived);
   // CharUnits DerivedAlign = CGM.getClassPointerAlignment(Derived);

clang/lib/CIR/CodeGen/CIRGenDecl.cpp

@@ -464,7 +464,7 @@ CIRGenModule::getOrCreateStaticVarDecl(const VarDecl &D,
     Name = getStaticDeclName(*this, D);
 
   mlir::Type LTy = getTypes().convertTypeForMem(Ty);
-  assert(!UnimplementedFeature::addressSpace());
+  assert(!UnimplementedFeature::addressSpaceInGlobalVar());
 
   // OpenCL variables in local address space and CUDA shared
   // variables cannot have an initializer.
@@ -491,7 +491,7 @@ CIRGenModule::getOrCreateStaticVarDecl(const VarDecl &D,
   setGVProperties(GV, &D);
 
   // Make sure the result is of the correct type.
-  assert(!UnimplementedFeature::addressSpace());
+  assert(!UnimplementedFeature::addressSpaceCasting());
 
   // Ensure that the static local gets initialized by making sure the parent
   // function gets emitted eventually.

clang/lib/CIR/CodeGen/CIRGenDeclCXX.cpp

@@ -70,7 +70,7 @@ void CIRGenModule::buildGlobalVarDeclInit(const VarDecl *D,
     // For example, in the above CUDA code, the static local variable s has a
     // "shared" address space qualifier, but the constructor of StructWithCtor
     // expects "this" in the "generic" address space.
-    assert(!UnimplementedFeature::addressSpace());
+    assert(!UnimplementedFeature::addressSpaceCasting());
 
     if (!T->isReferenceType()) {
       bool NeedsDtor =

clang/lib/CIR/CodeGen/CIRGenException.cpp

@@ -439,7 +439,7 @@ static void buildCatchDispatchBlock(CIRGenFunction &CGF,
     assert(typeValue && "fell into catch-all case!");
     // Check for address space mismatch: if (typeValue->getType() !=
     // argTy)
-    assert(!UnimplementedFeature::addressSpace());
+    assert(!UnimplementedFeature::addressSpaceCasting());
 
     bool nextIsEnd = false;
     // If this is the last handler, we're at the end, and the next

clang/lib/CIR/CodeGen/CIRGenExpr.cpp

@@ -173,7 +173,7 @@ static Address buildPointerWithAlignment(const Expr *E,
         Addr = CGF.getBuilder().createElementBitCast(
             CGF.getLoc(E->getSourceRange()), Addr, ElemTy);
         if (CE->getCastKind() == CK_AddressSpaceConversion) {
-          assert(!UnimplementedFeature::addressSpace());
+          assert(!UnimplementedFeature::addressSpaceCasting());
           llvm_unreachable("NYI");
         }
         return Addr;
@@ -1206,23 +1206,21 @@ RValue CIRGenFunction::buildCall(clang::QualType CalleeType,
   //   some trivial cases].
   // That is, in the general case, we should assume that a call through an
   // unprototyped function type works like a *non-variadic* call. The way we
-  // make this work is to cast to the exxact type fo the promoted arguments.
+  // make this work is to cast to the exact type fo the promoted arguments.
   //
-  // Chain calls use the same code path to add the inviisble chain parameter to
+  // Chain calls use the same code path to add the invisible chain parameter to
   // the function type.
   if (isa<FunctionNoProtoType>(FnType) || Chain) {
     assert(!UnimplementedFeature::chainCalls());
-    assert(!UnimplementedFeature::addressSpace());
     auto CalleeTy = getTypes().GetFunctionType(FnInfo);
     // get non-variadic function type
     CalleeTy = mlir::cir::FuncType::get(CalleeTy.getInputs(),
                                         CalleeTy.getReturnType(), false);
-    auto CalleePtrTy =
-        mlir::cir::PointerType::get(builder.getContext(), CalleeTy);
 
     auto *Fn = Callee.getFunctionPointer();
     mlir::Value Addr;
     if (auto funcOp = llvm::dyn_cast<mlir::cir::FuncOp>(Fn)) {
+      assert(!UnimplementedFeature::addressSpaceInGlobalVar());
       Addr = builder.create<mlir::cir::GetGlobalOp>(
           getLoc(E->getSourceRange()),
           mlir::cir::PointerType::get(builder.getContext(),
@@ -1232,6 +1230,12 @@ RValue CIRGenFunction::buildCall(clang::QualType CalleeType,
       Addr = Fn->getResult(0);
     }
 
+    // Use the same addr space as Addr
+    auto CalleePtrAS =
+        Addr.getType().cast<mlir::cir::PointerType>().getAddrSpace();
+    auto CalleePtrTy = mlir::cir::PointerType::get(builder.getContext(),
+                                                   CalleeTy, CalleePtrAS);
+
     Fn = builder.createBitcast(Addr, CalleePtrTy).getDefiningOp();
     Callee.setFunctionPointer(Fn);
   }

clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp

@@ -1414,9 +1414,15 @@ mlir::Value ScalarExprEmitter::VisitCastExpr(CastExpr *CE) {
   case CK_AnyPointerToBlockPointerCast:
   case CK_BitCast: {
     auto Src = Visit(const_cast<Expr *>(E));
+    mlir::Type SrcTy = Src.getType();
     mlir::Type DstTy = CGF.convertType(DestTy);
 
-    assert(!UnimplementedFeature::addressSpace());
+    if (SrcTy.isa<mlir::cir::PointerType>() &&
+        DstTy.isa<mlir::cir::PointerType>()) {
+      assert((SrcTy.cast<mlir::cir::PointerType>().getAddrSpace() ==
+              DstTy.cast<mlir::cir::PointerType>().getAddrSpace()) &&
+             "Address-space cast must be used to convert address spaces");
+    }
     if (CGF.SanOpts.has(SanitizerKind::CFIUnrelatedCast)) {
       llvm_unreachable("NYI");
     }
@@ -1449,8 +1455,10 @@ mlir::Value ScalarExprEmitter::VisitCastExpr(CastExpr *CE) {
     return CGF.getBuilder().createBitcast(CGF.getLoc(E->getSourceRange()), Src,
                                           DstTy);
   }
-  case CK_AddressSpaceConversion:
+  case CK_AddressSpaceConversion: {
+    assert(!UnimplementedFeature::addressSpaceCasting());
     llvm_unreachable("NYI");
+  }
   case CK_AtomicToNonAtomic:
     llvm_unreachable("NYI");
   case CK_NonAtomicToAtomic:

clang/lib/CIR/CodeGen/CIRGenModule.cpp

@@ -721,7 +721,8 @@ CIRGenModule::getOrCreateCIRGlobal(StringRef MangledName, mlir::Type Ty,
       return Entry;
   }
 
-  // TODO(cir): auto DAddrSpace = GetGlobalVarAddressSpace(D);
+  // TODO(cir): auto DAddrSpace = getGlobalVarAddressSpace(D);
+  assert(!UnimplementedFeature::addressSpaceInGlobalVar());
   // TODO(cir): do we need to strip pointer casts for Entry?
 
   auto loc = getLoc(D->getSourceRange());
@@ -809,6 +810,7 @@ CIRGenModule::getOrCreateCIRGlobal(StringRef MangledName, mlir::Type Ty,
   }
 
   // TODO(cir): address space cast when needed for DAddrSpace.
+  assert(!UnimplementedFeature::addressSpaceCasting());
   return GV;
 }
 
@@ -2378,8 +2380,8 @@ mlir::cir::FuncOp CIRGenModule::GetOrCreateCIRFunction(
     return F;
   }
 
-  // TODO(cir): Might need bitcast to different address space.
-  assert(!UnimplementedFeature::addressSpace());
+  // TODO(cir): Might need address-space cast to different address space.
+  assert(!UnimplementedFeature::addressSpaceCasting());
   return F;
 }
 
@@ -2803,9 +2805,10 @@ mlir::cir::GlobalOp CIRGenModule::getOrInsertGlobal(
   // If the variable exists but has the wrong type, return a bitcast to the
   // right type.
   auto GVTy = GV.getSymType();
-  assert(!UnimplementedFeature::addressSpace());
+  assert(!UnimplementedFeature::addressSpaceInGlobalVar());
   auto PTy = builder.getPointerTo(Ty);
 
+  assert(!UnimplementedFeature::addressSpaceCasting());
   if (GVTy != PTy)
     llvm_unreachable("NYI");
 

clang/lib/CIR/CodeGen/CIRGenTypeCache.h

@@ -128,7 +128,6 @@ struct CIRGenTypeCache {
     // Address spaces are not yet fully supported, but the usage of the default
     // alloca address space can be used for now only for comparison with the
     // default address space.
-    assert(!UnimplementedFeature::addressSpace());
     assert(ASTAllocaAddressSpace == clang::LangAS::Default);
     return ASTAllocaAddressSpace;
   }

clang/lib/CIR/CodeGen/CIRGenTypes.cpp

@@ -598,9 +598,9 @@ mlir::Type CIRGenTypes::ConvertType(QualType T) {
     const ReferenceType *RTy = cast<ReferenceType>(Ty);
     QualType ETy = RTy->getPointeeType();
     auto PointeeType = convertTypeForMem(ETy);
-    // TODO(cir): use Context.getTargetAddressSpace(ETy) on pointer
-    ResultType =
-        ::mlir::cir::PointerType::get(Builder.getContext(), PointeeType);
+    ResultType = ::mlir::cir::PointerType::get(
+        Builder.getContext(), PointeeType,
+        Context.getTargetAddressSpace(ETy.getAddressSpace()));
     assert(ResultType && "Cannot get pointer type?");
     break;
   }
@@ -615,9 +615,9 @@ mlir::Type CIRGenTypes::ConvertType(QualType T) {
     // if (PointeeType->isVoidTy())
     //  PointeeType = Builder.getI8Type();
 
-    // FIXME: add address specifier to cir::PointerType?
-    ResultType =
-        ::mlir::cir::PointerType::get(Builder.getContext(), PointeeType);
+    ResultType = ::mlir::cir::PointerType::get(
+        Builder.getContext(), PointeeType,
+        Context.getTargetAddressSpace(ETy.getAddressSpace()));
     assert(ResultType && "Cannot get pointer type?");
     break;
   }

clang/lib/CIR/CodeGen/UnimplementedFeatureGuarding.h

@@ -29,8 +29,9 @@ struct UnimplementedFeature {
   static bool vectorConstants() { return false; }
 
   // Address space related
-  static bool addressSpace() { return false; }
+  static bool addressSpace() { return true; }
   static bool addressSpaceInGlobalVar() { return false; }
+  static bool addressSpaceCasting() { return false; }
 
   // Clang codegen options
   static bool strictVTablePointers() { return false; }

clang/lib/CIR/Dialect/IR/MissingFeatures.h

@@ -23,7 +23,8 @@ struct MissingFeatures {
   static bool setCallingConv() { return false; }
 
   // Address space related
-  static bool addressSpace() { return false; }
+  static bool addressSpace() { return true; }
+  static bool addressSpaceCasting() { return false; }
 
   // Sanitizers
   static bool buildTypeCheck() { return false; }

clang/lib/CIR/Dialect/Transforms/LoweringPrepareItaniumCXXABI.cpp

@@ -55,7 +55,7 @@ static mlir::Value buildDynamicCastAfterNullCheck(CIRBaseBuilderTy &builder,
   auto castInfo = op.getInfo().value();
 
   // TODO(cir): consider address space
-  assert(!MissingFeatures::addressSpace());
+  assert(!MissingFeatures::addressSpaceCasting());
 
   auto srcPtr = builder.createBitcast(srcValue, builder.getVoidPtrTy());
   auto srcRtti = builder.getConstant(loc, castInfo.getSrcRtti());
@@ -100,7 +100,7 @@ buildDynamicCastToVoidAfterNullCheck(CIRBaseBuilderTy &builder,
   bool vtableUsesRelativeLayout = op.getRelativeLayout();
 
   // TODO(cir): consider address space in this function.
-  assert(!MissingFeatures::addressSpace());
+  assert(!MissingFeatures::addressSpaceCasting());
 
   mlir::Type vtableElemTy;
   uint64_t vtableElemAlign;

clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp

@@ -3178,7 +3178,8 @@ void prepareTypeConverter(mlir::LLVMTypeConverter &converter,
                           mlir::DataLayout &dataLayout) {
   converter.addConversion([&](mlir::cir::PointerType type) -> mlir::Type {
     // Drop pointee type since LLVM dialect only allows opaque pointers.
-    return mlir::LLVM::LLVMPointerType::get(type.getContext());
+    return mlir::LLVM::LLVMPointerType::get(type.getContext(),
+                                            type.getAddrSpace());
   });
   converter.addConversion([&](mlir::cir::ArrayType type) -> mlir::Type {
     auto ty = converter.convertType(type.getEltType());

clang/test/CIR/CodeGen/address-space.c

@@ -0,0 +1,12 @@
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-cir %s -o %t.cir
+// RUN: FileCheck --input-file=%t.cir %s
+
+// CHECK: cir.func {{@.*foo.*}}(%arg0: !cir.ptr<!s32i>
+void foo(int __attribute__((address_space(0))) *arg) {
+  return;
+}
+
+// CHECK: cir.func {{@.*bar.*}}(%arg0: !cir.ptr<!s32i, addrspace(1)>
+void bar(int __attribute__((address_space(1))) *arg) {
+  return;
+}

clang/test/CIR/Lowering/address-space.cir

@@ -0,0 +1,20 @@
+// RUN: cir-translate %s -cir-to-llvmir -o %t.ll
+// RUN: FileCheck --input-file=%t.ll %s -check-prefix=LLVM
+
+!s32i = !cir.int<s, 32>
+
+module  {
+  // LLVM: define void @foo(ptr %0)
+  cir.func @foo(%arg0: !cir.ptr<!s32i>) {
+    // LLVM-NEXT: alloca ptr,
+    %0 = cir.alloca !cir.ptr<!s32i>, !cir.ptr<!cir.ptr<!s32i>>, ["arg", init] {alignment = 8 : i64}
+    cir.return
+  }
+
+  // LLVM: define void @bar(ptr addrspace(1) %0)
+  cir.func @bar(%arg0: !cir.ptr<!s32i, addrspace(1)>) {
+    // LLVM-NEXT: alloca ptr addrspace(1)
+    %0 = cir.alloca !cir.ptr<!s32i, addrspace(1)>, !cir.ptr<!cir.ptr<!s32i, addrspace(1)>>, ["arg", init] {alignment = 8 : i64}
+    cir.return
+  }
+}