Apply 2nd round of suggestions

Author: RiverDave

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

@@ -607,9 +607,14 @@ def CIR_VTableAttr : CIR_Attr<"VTable", "vtable", [TypedAttrInterface]> {
 
 def CIR_TargetAddressSpaceAttr : CIR_Attr< "TargetAddressSpace",
                                          "target_address_space"> {
-  let summary = "Attribute representing a target-specific numeric address space";
+  let summary = "Represents a target-specific numeric address space";
   let description = [{
-    Represents a target-specific numeric address space for pointer types.
+    The TargetAddressSpaceAttr represents a target-specific numeric address space,
+    corresponding to the LLVM IR `addressspace` qualifier and the clang
+     `address_space` attribute.
+    
+    A value of zero represents the default address space. The semantics of non-zero
+    address spaces are target-specific.
 
     Example:
     ```mlir

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

@@ -38,13 +38,6 @@ bool isValidFundamentalIntWidth(unsigned width);
 /// void, or abstract types.
 bool isSized(mlir::Type ty);
 
-//===----------------------------------------------------------------------===//
-// AddressSpace helpers
-//===----------------------------------------------------------------------===//
-
-/// Returns the integer value of a CIR address space for LLVM.
-unsigned getTargetAddrSpaceFromAttr(cir::TargetAddressSpaceAttr attr);
-
 } // namespace cir
 
 //===----------------------------------------------------------------------===//

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

@@ -238,10 +238,6 @@ def CIR_PointerType : CIR_Type<"Pointer", "ptr", [
     records, arrays, vectors, functions, and other pointers. It can also point
     to incomplete types, such as incomplete records.
 
-    Note: Data-member pointers and method pointers are represented by
-    `!cir.data_member` and `!cir.method` types, respectively not by
-    `!cir.ptr` type.
-
     Examples:
 
     ```mlir
@@ -256,8 +252,7 @@ def CIR_PointerType : CIR_Type<"Pointer", "ptr", [
   let parameters = (ins
     "mlir::Type":$pointee,
     OptionalParameter<
-    "cir::TargetAddressSpaceAttr"
-    >:$addrSpace
+        "cir::TargetAddressSpaceAttr">:$addrSpace
   );
 
   let skipDefaultBuilders = 1;

clang/lib/CIR/CodeGen/CIRGenExpr.cpp

@@ -2053,7 +2053,7 @@ mlir::Value CIRGenFunction::emitAlloca(StringRef name, mlir::Type ty,
   // layout like original CodeGen. The data layout awareness should be done in
   // the lowering pass instead.
   cir::PointerType localVarPtrTy =
-      builder.getPointerTo(ty, getASTAllocaAddressSpace());
+      builder.getPointerTo(ty, getCIRAllocaAddressSpace());
   mlir::IntegerAttr alignIntAttr = cgm.getSize(alignment);
 
   mlir::Value addr;

clang/lib/CIR/CodeGen/CIRGenModule.cpp

@@ -76,7 +76,7 @@ CIRGenModule::CIRGenModule(mlir::MLIRContext &mlirContext,
   SInt128Ty = cir::IntType::get(&getMLIRContext(), 128, /*isSigned=*/true);
   UInt8Ty = cir::IntType::get(&getMLIRContext(), 8, /*isSigned=*/false);
   UInt8PtrTy = cir::PointerType::get(UInt8Ty);
-  ASTAllocaAddressSpace = getTargetCIRGenInfo().getASTAllocaAddressSpace();
+  cirAllocaAddressSpace = getTargetCIRGenInfo().getCIRAllocaAddressSpace();
   UInt16Ty = cir::IntType::get(&getMLIRContext(), 16, /*isSigned=*/false);
   UInt32Ty = cir::IntType::get(&getMLIRContext(), 32, /*isSigned=*/false);
   UInt64Ty = cir::IntType::get(&getMLIRContext(), 64, /*isSigned=*/false);

clang/lib/CIR/CodeGen/CIRGenTypeCache.h

@@ -74,7 +74,7 @@ struct CIRGenTypeCache {
   /// The alignment of size_t.
   unsigned char SizeAlignInBytes;
 
-  LangAS ASTAllocaAddressSpace;
+  cir::TargetAddressSpaceAttr cirAllocaAddressSpace;
 
   clang::CharUnits getSizeAlign() const {
     return clang::CharUnits::fromQuantity(SizeAlignInBytes);
@@ -84,7 +84,9 @@ struct CIRGenTypeCache {
     return clang::CharUnits::fromQuantity(PointerAlignInBytes);
   }
 
-  LangAS getASTAllocaAddressSpace() const { return ASTAllocaAddressSpace; }
+  cir::TargetAddressSpaceAttr getCIRAllocaAddressSpace() const {
+    return cirAllocaAddressSpace;
+  }
 };
 
 } // namespace clang::CIRGen

clang/lib/CIR/CodeGen/TargetInfo.h

@@ -44,8 +44,10 @@ class TargetCIRGenInfo {
   /// Returns ABI info helper for the target.
   const ABIInfo &getABIInfo() const { return *info; }
 
-  /// Get the AST address space for alloca.
-  virtual LangAS getASTAllocaAddressSpace() const { return LangAS::Default; }
+  /// Get the address space for alloca.
+  virtual cir::TargetAddressSpaceAttr getCIRAllocaAddressSpace() const {
+    return nullptr;
+  }
 
   /// Determine whether a call to an unprototyped functions under
   /// the given calling convention should use the variadic

clang/lib/CIR/Dialect/IR/CIRTypes.cpp

@@ -805,13 +805,6 @@ mlir::LogicalResult cir::VectorType::verify(
 // TargetAddressSpace definitions
 //===----------------------------------------------------------------------===//
 
-// Convert from TargetAddressSpaceAttr to the actual integer address space.
-unsigned cir::getTargetAddrSpaceFromAttr(cir::TargetAddressSpaceAttr attr) {
-  if (!attr)
-    return 0; // Default address space is 0 in LLVM.
-  return attr.getValue().getUInt();
-}
-
 mlir::ParseResult parseTargetAddressSpace(mlir::AsmParser &p,
                                           cir::TargetAddressSpaceAttr &attr) {
   if (failed(p.parseKeyword("target_address_space")))
@@ -820,7 +813,7 @@ mlir::ParseResult parseTargetAddressSpace(mlir::AsmParser &p,
   if (failed(p.parseLParen()))
     return mlir::failure();
 
-  int64_t targetValue;
+  int32_t targetValue;
   if (failed(p.parseInteger(targetValue)))
     return p.emitError(p.getCurrentLocation(),
                        "expected integer address space value");
@@ -830,9 +823,8 @@ mlir::ParseResult parseTargetAddressSpace(mlir::AsmParser &p,
                        "expected ')' after address space value");
 
   mlir::MLIRContext *context = p.getBuilder().getContext();
-  auto intTy = mlir::IntegerType::get(context, 32);
   attr = cir::TargetAddressSpaceAttr::get(
-      context, mlir::IntegerAttr::get(intTy, targetValue));
+      context, p.getBuilder().getUI32IntegerAttr(targetValue));
   return mlir::success();
 }
 

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

@@ -2309,7 +2309,8 @@ mlir::LogicalResult CIRToLLVMSelectOpLowering::matchAndRewrite(
 static void prepareTypeConverter(mlir::LLVMTypeConverter &converter,
                                  mlir::DataLayout &dataLayout) {
   converter.addConversion([&](cir::PointerType type) -> mlir::Type {
-    unsigned addrSpace = cir::getTargetAddrSpaceFromAttr(type.getAddrSpace());
+    unsigned addrSpace =
+        type.getAddrSpace() ? type.getAddrSpace().getValue().getUInt() : 0;
     return mlir::LLVM::LLVMPointerType::get(type.getContext(), addrSpace);
   });
   converter.addConversion([&](cir::VPtrType type) -> mlir::Type {

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

@@ -27,4 +27,4 @@ void bar(int __attribute__((address_space(0))) *arg) {
 // OGCG: define dso_local void @baz(ptr noundef %arg)
 void baz(int *arg) {
   return;
-}
+}