follow direct ASTAllocaAddressSpace

Author: seven-mile

clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp

@@ -993,21 +993,24 @@ RValue CIRGenFunction::buildBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
     if (BuiltinID != Builtin::BI__builtin_alloca_uninitialized)
       initializeAlloca(*this, AllocaAddr, Size, SuitableAlignmentInBytes);
 
+    // Bitcast the alloca to the expected type.
+    auto resAddr = builder.createBitcast(
+        AllocaAddr, builder.getVoidPtrTy(CGM.AllocaInt8PtrTy.getAddrSpace()));
+
     // An alloca will always return a pointer to the alloca (stack) address
     // space. This address space need not be the same as the AST / Language
     // 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(!MissingFeatures::addressSpace());
     LangAS AAS = getASTAllocaAddressSpace();
     LangAS EAS = E->getType()->getPointeeType().getAddressSpace();
-    if (EAS != AAS) {
-      assert(false && "Non-default address space for alloca NYI");
+    if (AAS != EAS) {
+      mlir::Type Ty = CGM.getTypes().ConvertType(E->getType());
+      return RValue::get(
+          getTargetHooks().performAddrSpaceCast(*this, resAddr, AAS, EAS, Ty));
     }
 
-    // Bitcast the alloca to the expected type.
-    return RValue::get(
-        builder.createBitcast(AllocaAddr, builder.getVoidPtrTy()));
+    return RValue::get(resAddr);
   }
 
   case Builtin::BI__sync_fetch_and_add:

clang/lib/CIR/CodeGen/CIRGenExpr.cpp

@@ -2945,7 +2945,10 @@ Address CIRGenFunction::CreateTempAlloca(mlir::Type Ty, CharUnits Align,
   // in C++ the auto variables are in the default address space. Therefore
   // cast alloca to the default address space when necessary.
   if (getASTAllocaAddressSpace() != LangAS::Default) {
-    llvm_unreachable("Requires address space cast which is NYI");
+    auto DestAddrSpace = getContext().getTargetAddressSpace(LangAS::Default);
+    V = getTargetHooks().performAddrSpaceCast(
+        *this, V, getASTAllocaAddressSpace(), LangAS::Default,
+        builder.getPointerTo(Ty, DestAddrSpace), /*non-null*/ true);
   }
   return Address(V, Ty, Align);
 }

clang/lib/CIR/CodeGen/CIRGenTypeCache.h

@@ -128,7 +128,6 @@ struct CIRGenTypeCache {
     // alloca address space can be used for now only for comparison with the
     // default address space.
     assert(!MissingFeatures::addressSpace());
-    assert(ASTAllocaAddressSpace == clang::LangAS::Default);
     return ASTAllocaAddressSpace;
   }
 };

clang/lib/CIR/CodeGen/TargetInfo.cpp

@@ -257,6 +257,11 @@ class CommonSPIRTargetCIRGenInfo : public TargetCIRGenInfo {
   CommonSPIRTargetCIRGenInfo(std::unique_ptr<ABIInfo> ABIInfo)
       : TargetCIRGenInfo(std::move(ABIInfo)) {}
 
+  LangAS getASTAllocaAddressSpace() const override {
+    return getLangASFromTargetAS(
+        getABIInfo().CGT.getModule().getDataLayout().getAllocaMemorySpace());
+  }
+
   unsigned getOpenCLKernelCallingConv() const override {
     return llvm::CallingConv::SPIR_KERNEL;
   }

clang/test/CIR/CodeGen/OpenCL/addrspace-alloca.cl

@@ -3,9 +3,9 @@
 // RUN: %clang_cc1 -cl-std=CL3.0 -O0 -fclangir -S -emit-llvm -triple spirv64-unknown-unknown %s -o %t.ll
 // RUN: FileCheck --input-file=%t.ll %s --check-prefix=LLVM
 
-// CIR: cir.func @func(%arg0: !cir.ptr<!s32i, addrspace(3)>
-// LLVM: @func(ptr addrspace(3)
-kernel void func(local int *p) {
+// CIR: cir.func @foo(%arg0: !cir.ptr<!s32i, addrspace(3)>
+// LLVM: @foo(ptr addrspace(3)
+kernel void foo(local int *p) {
   // CIR-NEXT: %[[#ALLOCA_P:]] = cir.alloca !cir.ptr<!s32i, addrspace(3)>, !cir.ptr<!cir.ptr<!s32i, addrspace(3)>>, ["p", init] {alignment = 8 : i64}
   // LLVM-NEXT: %[[#ALLOCA_P:]] = alloca ptr addrspace(3), i64 1, align 8
 
@@ -23,3 +23,18 @@ kernel void func(local int *p) {
 
   return;
 }
+
+// CIR: cir.func @bar(
+// LLVM: @bar(
+kernel void bar() {
+  void * arr = __builtin_alloca(2 * sizeof(int));
+  // CIR:      %[[#ALLOCA:]] = cir.alloca !u8i, !cir.ptr<!u8i>, %{{[0-9]+}} : !u64i, ["bi_alloca"] {alignment = 8 : i64}
+  // CIR-NEXT: %[[#PRIVATE_VOID_PTR:]] = cir.cast(bitcast, %[[#ALLOCA]] : !cir.ptr<!u8i>), !cir.ptr<!void>
+  // CIR-NEXT: %[[#GENERIC_VOID_PTR:]] = cir.cast(address_space, %[[#PRIVATE_VOID_PTR:]] : !cir.ptr<!void>), !cir.ptr<!void, addrspace(4)>
+  // CIR-NEXT: cir.store %[[#GENERIC_VOID_PTR]], %{{[0-9]+}} : !cir.ptr<!void, addrspace(4)>, !cir.ptr<!cir.ptr<!void, addrspace(4)>>
+
+  // LLVM:      %[[#ALLOCA:]] = alloca i8, i64 8, align 8
+  // LLVM-NEXT: %[[#GENERIC_VOID_PTR:]] = addrspacecast ptr %[[#ALLOCA]] to ptr addrspace(4)
+  // LLVM-NEXT: store ptr addrspace(4) %[[#GENERIC_VOID_PTR]], ptr %{{[0-9]+}}, align 8
+
+}