diff --git a/clang/include/clang/CIR/Dialect/IR/CIRTypes.td b/clang/include/clang/CIR/Dialect/IR/CIRTypes.td index ee8b266ed962..9f77fd7d5ca0 100644 --- a/clang/include/clang/CIR/Dialect/IR/CIRTypes.td +++ b/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 { diff --git a/clang/lib/CIR/CodeGen/CIRGenBuilder.h b/clang/lib/CIR/CodeGen/CIRGenBuilder.h index 652cadb9ffcb..ffc64edfd489 100644 --- a/clang/lib/CIR/CodeGen/CIRGenBuilder.h +++ b/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(); + auto destTy = getVoidPtrTy(srcTy.getAddrSpace()); return create( 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(); auto memberPtrTy = memberPtr.getType().cast(); - // TODO(cir): consider address space. - assert(!UnimplementedFeature::addressSpace()); - auto resultTy = getPointerTo(memberPtrTy.getMemberTy()); + auto resultTy = + getPointerTo(memberPtrTy.getMemberTy(), objectPtrTy.getAddrSpace()); return create(loc, resultTy, objectPtr, memberPtr); diff --git a/clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp b/clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp index 82a7bfcbc573..39bedcdc2d04 100644 --- a/clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp +++ b/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: diff --git a/clang/lib/CIR/CodeGen/CIRGenClass.cpp b/clang/lib/CIR/CodeGen/CIRGenClass.cpp index a209e4e8866c..e842ea083758 100644 --- a/clang/lib/CIR/CodeGen/CIRGenClass.cpp +++ b/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); diff --git a/clang/lib/CIR/CodeGen/CIRGenDecl.cpp b/clang/lib/CIR/CodeGen/CIRGenDecl.cpp index d1abfeeeb8c5..219b50fb0cae 100644 --- a/clang/lib/CIR/CodeGen/CIRGenDecl.cpp +++ b/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. diff --git a/clang/lib/CIR/CodeGen/CIRGenDeclCXX.cpp b/clang/lib/CIR/CodeGen/CIRGenDeclCXX.cpp index 3d8c72dd7f5e..3ff29923c093 100644 --- a/clang/lib/CIR/CodeGen/CIRGenDeclCXX.cpp +++ b/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 = diff --git a/clang/lib/CIR/CodeGen/CIRGenException.cpp b/clang/lib/CIR/CodeGen/CIRGenException.cpp index 1c0b686154f4..2a9717aea60e 100644 --- a/clang/lib/CIR/CodeGen/CIRGenException.cpp +++ b/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 diff --git a/clang/lib/CIR/CodeGen/CIRGenExpr.cpp b/clang/lib/CIR/CodeGen/CIRGenExpr.cpp index 26e31484faef..ea6d1e80057c 100644 --- a/clang/lib/CIR/CodeGen/CIRGenExpr.cpp +++ b/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(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(Fn)) { + assert(!UnimplementedFeature::addressSpaceInGlobalVar()); Addr = builder.create( 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().getAddrSpace(); + auto CalleePtrTy = mlir::cir::PointerType::get(builder.getContext(), + CalleeTy, CalleePtrAS); + Fn = builder.createBitcast(Addr, CalleePtrTy).getDefiningOp(); Callee.setFunctionPointer(Fn); } diff --git a/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp b/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp index b3b42abc026e..5a8785eaec05 100644 --- a/clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp +++ b/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(E)); + mlir::Type SrcTy = Src.getType(); mlir::Type DstTy = CGF.convertType(DestTy); - assert(!UnimplementedFeature::addressSpace()); + if (SrcTy.isa() && + DstTy.isa()) { + assert((SrcTy.cast().getAddrSpace() == + DstTy.cast().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: diff --git a/clang/lib/CIR/CodeGen/CIRGenModule.cpp b/clang/lib/CIR/CodeGen/CIRGenModule.cpp index 5c22c18dc551..2bdac03b6bda 100644 --- a/clang/lib/CIR/CodeGen/CIRGenModule.cpp +++ b/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"); diff --git a/clang/lib/CIR/CodeGen/CIRGenTypeCache.h b/clang/lib/CIR/CodeGen/CIRGenTypeCache.h index 96d3ed851e8a..111643b4ebbd 100644 --- a/clang/lib/CIR/CodeGen/CIRGenTypeCache.h +++ b/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; } diff --git a/clang/lib/CIR/CodeGen/CIRGenTypes.cpp b/clang/lib/CIR/CodeGen/CIRGenTypes.cpp index 157d68435571..53787563eb94 100644 --- a/clang/lib/CIR/CodeGen/CIRGenTypes.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenTypes.cpp @@ -598,9 +598,9 @@ mlir::Type CIRGenTypes::ConvertType(QualType T) { const ReferenceType *RTy = cast(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; } diff --git a/clang/lib/CIR/CodeGen/UnimplementedFeatureGuarding.h b/clang/lib/CIR/CodeGen/UnimplementedFeatureGuarding.h index e2e9f0a4d91f..86b93290f334 100644 --- a/clang/lib/CIR/CodeGen/UnimplementedFeatureGuarding.h +++ b/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; } diff --git a/clang/lib/CIR/Dialect/IR/MissingFeatures.h b/clang/lib/CIR/Dialect/IR/MissingFeatures.h index e21fc0e0b191..fbbad73c0383 100644 --- a/clang/lib/CIR/Dialect/IR/MissingFeatures.h +++ b/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; } diff --git a/clang/lib/CIR/Dialect/Transforms/LoweringPrepareItaniumCXXABI.cpp b/clang/lib/CIR/Dialect/Transforms/LoweringPrepareItaniumCXXABI.cpp index dc997e604a96..900fe3219e27 100644 --- a/clang/lib/CIR/Dialect/Transforms/LoweringPrepareItaniumCXXABI.cpp +++ b/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; diff --git a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp index a1c2f73794af..dc04663d69b4 100644 --- a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp +++ b/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()); diff --git a/clang/test/CIR/CodeGen/address-space.c b/clang/test/CIR/CodeGen/address-space.c new file mode 100644 index 000000000000..2f29a8b7ca29 --- /dev/null +++ b/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 +void foo(int __attribute__((address_space(0))) *arg) { + return; +} + +// CHECK: cir.func {{@.*bar.*}}(%arg0: !cir.ptr +void bar(int __attribute__((address_space(1))) *arg) { + return; +} diff --git a/clang/test/CIR/Lowering/address-space.cir b/clang/test/CIR/Lowering/address-space.cir new file mode 100644 index 000000000000..c7d5a84829c4 --- /dev/null +++ b/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 + +module { + // LLVM: define void @foo(ptr %0) + cir.func @foo(%arg0: !cir.ptr) { + // LLVM-NEXT: alloca ptr, + %0 = cir.alloca !cir.ptr, !cir.ptr>, ["arg", init] {alignment = 8 : i64} + cir.return + } + + // LLVM: define void @bar(ptr addrspace(1) %0) + cir.func @bar(%arg0: !cir.ptr) { + // LLVM-NEXT: alloca ptr addrspace(1) + %0 = cir.alloca !cir.ptr, !cir.ptr>, ["arg", init] {alignment = 8 : i64} + cir.return + } +}