Update AddrCast to match OG and address other nits

Author: RiverDave

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

@@ -13,7 +13,9 @@
 #ifndef CLANG_CIR_DIALECT_IR_CIRTYPES_H
 #define CLANG_CIR_DIALECT_IR_CIRTYPES_H
 
+#include "mlir/IR/Attributes.h"
 #include "mlir/IR/BuiltinAttributes.h"
+#include "mlir/IR/MLIRContext.h"
 #include "mlir/IR/Types.h"
 #include "mlir/Interfaces/DataLayoutInterfaces.h"
 #include "clang/Basic/AddressSpaces.h"
@@ -38,6 +40,15 @@ bool isValidFundamentalIntWidth(unsigned width);
 /// void, or abstract types.
 bool isSized(mlir::Type ty);
 
+//===----------------------------------------------------------------------===//
+// AddressSpace helpers
+//===----------------------------------------------------------------------===//
+cir::TargetAddressSpaceAttr toCIRTargetAddressSpace(mlir::MLIRContext &context,
+                                                    clang::LangAS langAS);
+
+bool isMatchingAddressSpace(cir::TargetAddressSpaceAttr cirAS,
+                            clang::LangAS as);
+
 } // namespace cir
 
 //===----------------------------------------------------------------------===//

clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp

@@ -12,7 +12,6 @@
 //===----------------------------------------------------------------------===//
 
 #include "CIRGenCall.h"
-#include "CIRGenConstantEmitter.h"
 #include "CIRGenFunction.h"
 #include "CIRGenModule.h"
 #include "CIRGenValue.h"
@@ -22,6 +21,7 @@
 #include "clang/AST/Expr.h"
 #include "clang/AST/GlobalDecl.h"
 #include "clang/Basic/Builtins.h"
+#include "clang/CIR/Dialect/IR/CIRTypes.h"
 #include "clang/CIR/MissingFeatures.h"
 #include "llvm/Support/ErrorHandling.h"
 
@@ -58,24 +58,6 @@ static RValue emitBuiltinBitOp(CIRGenFunction &cgf, const CallExpr *e,
   return RValue::get(result);
 }
 
-// Initialize the alloca with the given size and alignment according to the lang
-// opts. Supporting only the trivial non-initialization for now.
-static void initializeAlloca(CIRGenFunction &cgf,
-                             [[maybe_unused]] mlir::Value allocaAddr,
-                             [[maybe_unused]] mlir::Value size,
-                             [[maybe_unused]] CharUnits alignmentInBytes) {
-
-  switch (cgf.getLangOpts().getTrivialAutoVarInit()) {
-  case LangOptions::TrivialAutoVarInitKind::Uninitialized:
-    // Nothing to initialize.
-    return;
-  case LangOptions::TrivialAutoVarInitKind::Zero:
-  case LangOptions::TrivialAutoVarInitKind::Pattern:
-    cgf.cgm.errorNYI("trivial auto var init");
-    return;
-  }
-}
-
 RValue CIRGenFunction::emitRotate(const CallExpr *e, bool isRotateLeft) {
   mlir::Value input = emitScalarExpr(e->getArg(0));
   mlir::Value amount = emitScalarExpr(e->getArg(1));
@@ -190,28 +172,34 @@ RValue CIRGenFunction::emitBuiltinExpr(const GlobalDecl &gd, unsigned builtinID,
         builder.getUInt8Ty(), "bi_alloca", suitableAlignmentInBytes, size);
 
     // Initialize the allocated buffer if required.
-    if (builtinID != Builtin::BI__builtin_alloca_uninitialized)
-      initializeAlloca(*this, allocaAddr, size, suitableAlignmentInBytes);
+    if (builtinID != Builtin::BI__builtin_alloca_uninitialized) {
+
+      switch (getLangOpts().getTrivialAutoVarInit()) {
+      case LangOptions::TrivialAutoVarInitKind::Uninitialized:
+        // Nothing to initialize.
+        break;
+      case LangOptions::TrivialAutoVarInitKind::Zero:
+      case LangOptions::TrivialAutoVarInitKind::Pattern:
+        cgm.errorNYI("trivial auto var init");
+        break;
+      }
+    }
 
     // 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.
 
-    LangAS allocaAddrSpace = clang::LangAS::Default;
-    if (getCIRAllocaAddressSpace()) {
-      allocaAddrSpace = clang::getLangASFromTargetAS(
-          getCIRAllocaAddressSpace().getValue().getUInt());
-    }
-    LangAS exprAddrSpace = e->getType()->getPointeeType().getAddressSpace();
-    if (exprAddrSpace != allocaAddrSpace) {
+    if (!cir::isMatchingAddressSpace(
+            getCIRAllocaAddressSpace(),
+            e->getType()->getPointeeType().getAddressSpace())) {
       cgm.errorNYI(e->getSourceRange(), "Non-default address space for alloca");
     }
 
     // Bitcast the alloca to the expected type.
     return RValue::get(builder.createBitcast(
-        allocaAddr, builder.getVoidPtrTy(allocaAddrSpace)));
+        allocaAddr, builder.getVoidPtrTy(getCIRAllocaAddressSpace())));
   }
 
   case Builtin::BIcos:

clang/lib/CIR/CodeGen/CIRGenExpr.cpp

@@ -24,7 +24,9 @@
 #include "clang/AST/ExprCXX.h"
 #include "clang/Basic/AddressSpaces.h"
 #include "clang/Basic/TargetInfo.h"
+#include "clang/CIR/Dialect/IR/CIRAttrs.h"
 #include "clang/CIR/Dialect/IR/CIRDialect.h"
+#include "clang/CIR/Dialect/IR/CIRTypes.h"
 #include "clang/CIR/MissingFeatures.h"
 #include <optional>
 
@@ -1199,16 +1201,6 @@ LValue CIRGenFunction::emitCastLValue(const CastExpr *e) {
   case CK_AtomicToNonAtomic:
   case CK_ToUnion:
   case CK_BaseToDerived:
-  case CK_AddressSpaceConversion: {
-    LValue lv = emitLValue(e->getSubExpr());
-    QualType destTy = getContext().getPointerType(e->getType());
-    mlir::Value v = getTargetHooks().performAddrSpaceCast(
-        *this, lv.getPointer(), convertType(destTy));
-
-    return makeAddrLValue(Address(v, convertTypeForMem(e->getType()),
-                                  lv.getAddress().getAlignment()),
-                          e->getType(), lv.getBaseInfo());
-  }
   case CK_ObjCObjectLValueCast:
   case CK_VectorSplat:
   case CK_ConstructorConversion:
@@ -1222,7 +1214,23 @@ LValue CIRGenFunction::emitCastLValue(const CastExpr *e) {
 
     return {};
   }
+  case CK_AddressSpaceConversion: {
+    LValue lv = emitLValue(e->getSubExpr());
+    QualType destTy = getContext().getPointerType(e->getType());
+
+    clang::LangAS srcLangAS = e->getSubExpr()->getType().getAddressSpace();
+    cir::TargetAddressSpaceAttr srcAS;
+    if (clang::isTargetAddressSpace(srcLangAS)) {
+      srcAS = cir::toCIRTargetAddressSpace(getMLIRContext(), srcLangAS);
+    }
+
+    mlir::Value v = getTargetHooks().performAddrSpaceCast(
+        *this, lv.getPointer(), srcAS, convertType(destTy));
 
+    return makeAddrLValue(Address(v, convertTypeForMem(e->getType()),
+                                  lv.getAddress().getAlignment()),
+                          e->getType(), lv.getBaseInfo());
+  }
   case CK_LValueBitCast: {
     // This must be a reinterpret_cast (or c-style equivalent).
     const auto *ce = cast<ExplicitCastExpr>(e);
@@ -2311,7 +2319,7 @@ Address CIRGenFunction::createTempAlloca(mlir::Type ty, CharUnits align,
   }
 
   if (dstTyAS != allocaAS) {
-    getTargetHooks().performAddrSpaceCast(*this, v,
+    getTargetHooks().performAddrSpaceCast(*this, v, getCIRAllocaAddressSpace(),
                                           builder.getPointerTo(ty, dstTyAS));
   }
   return Address(v, ty, align);

clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp

@@ -15,6 +15,7 @@
 
 #include "clang/AST/Expr.h"
 #include "clang/AST/StmtVisitor.h"
+#include "clang/CIR/Dialect/IR/CIRTypes.h"
 #include "clang/CIR/MissingFeatures.h"
 
 #include "mlir/IR/Location.h"
@@ -1884,10 +1885,16 @@ mlir::Value ScalarExprEmitter::VisitCastExpr(CastExpr *ce) {
       return cgf.cgm.emitNullConstant(destTy,
                                       cgf.getLoc(subExpr->getExprLoc()));
     }
+
+    clang::LangAS srcLangAS = subExpr->getType().getAddressSpace();
+    cir::TargetAddressSpaceAttr subExprAS;
+    if (clang::isTargetAddressSpace(srcLangAS)) {
+      subExprAS = cir::toCIRTargetAddressSpace(cgf.getMLIRContext(), srcLangAS);
+    }
     // Since target may map different address spaces in AST to the same address
     // space, an address space conversion may end up as a bitcast.
     return cgf.cgm.getTargetCIRGenInfo().performAddrSpaceCast(
-        cgf, Visit(subExpr), convertType(destTy));
+        cgf, Visit(subExpr), subExprAS, convertType(destTy));
   }
 
   case CK_AtomicToNonAtomic: {

clang/lib/CIR/CodeGen/TargetInfo.cpp

@@ -1,6 +1,7 @@
 #include "TargetInfo.h"
 #include "ABIInfo.h"
 #include "CIRGenFunction.h"
+#include "clang/CIR/Dialect/IR/CIRAttrs.h"
 #include "clang/CIR/Dialect/IR/CIRDialect.h"
 
 using namespace clang;
@@ -71,10 +72,9 @@ bool TargetCIRGenInfo::isNoProtoCallVariadic(
   return false;
 }
 
-mlir::Value TargetCIRGenInfo::performAddrSpaceCast(CIRGenFunction &cgf,
-                                                   mlir::Value v,
-                                                   mlir::Type destTy,
-                                                   bool isNonNull) const {
+mlir::Value TargetCIRGenInfo::performAddrSpaceCast(
+    CIRGenFunction &cgf, mlir::Value v, cir::TargetAddressSpaceAttr srcAddr,
+    mlir::Type destTy, bool isNonNull) const {
   // Since target may map different address spaces in AST to the same address
   // space, an address space conversion may end up as a bitcast.
   if (cir::GlobalOp globalOp = v.getDefiningOp<cir::GlobalOp>())

clang/lib/CIR/CodeGen/TargetInfo.h

@@ -17,6 +17,7 @@
 #include "ABIInfo.h"
 #include "CIRGenTypes.h"
 #include "clang/Basic/AddressSpaces.h"
+#include "clang/CIR/Dialect/IR/CIRAttrs.h"
 
 #include <memory>
 #include <utility>
@@ -53,8 +54,10 @@ class TargetCIRGenInfo {
   /// Perform address space cast of an expression of pointer type.
   /// \param V is the value to be casted to another address space.
   /// \param DestTy is the destination pointer type.
+  /// \param srcAS is theaddress space of \p V.
   /// \param IsNonNull is the flag indicating \p V is known to be non null.
   virtual mlir::Value performAddrSpaceCast(CIRGenFunction &cgf, mlir::Value v,
+                                           cir::TargetAddressSpaceAttr srcAddr,
                                            mlir::Type destTy,
                                            bool isNonNull = false) const;
 

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

@@ -12,11 +12,16 @@
 
 #include "clang/CIR/Dialect/IR/CIRTypes.h"
 
+#include "mlir/IR/BuiltinAttributes.h"
 #include "mlir/IR/DialectImplementation.h"
+#include "mlir/IR/MLIRContext.h"
+#include "clang/Basic/AddressSpaces.h"
 #include "clang/CIR/Dialect/IR/CIRAttrs.h"
 #include "clang/CIR/Dialect/IR/CIRDialect.h"
 #include "clang/CIR/Dialect/IR/CIRTypesDetails.h"
 #include "clang/CIR/MissingFeatures.h"
+#include "llvm/ADT/APInt.h"
+#include "llvm/ADT/APSInt.h"
 #include "llvm/ADT/TypeSwitch.h"
 
 //===----------------------------------------------------------------------===//
@@ -807,6 +812,27 @@ mlir::LogicalResult cir::VectorType::verify(
 // TargetAddressSpace definitions
 //===----------------------------------------------------------------------===//
 
+cir::TargetAddressSpaceAttr
+cir::toCIRTargetAddressSpace(mlir::MLIRContext &context, clang::LangAS langAS) {
+  return cir::TargetAddressSpaceAttr::get(
+      &context,
+      IntegerAttr::get(&context,
+                       llvm::APSInt(clang::toTargetAddressSpace(langAS))));
+}
+
+bool cir::isMatchingAddressSpace(cir::TargetAddressSpaceAttr cirAS,
+                                 clang::LangAS as) {
+  // If there is no CIR target attr, consider it "default" and only match
+  // when the AST address space is LangAS::Default.
+  if (!cirAS)
+    return as == clang::LangAS::Default;
+
+  if (!isTargetAddressSpace(as))
+    return false;
+
+  return cirAS.getValue().getUInt() == toTargetAddressSpace(as);
+}
+
 mlir::ParseResult parseTargetAddressSpace(mlir::AsmParser &p,
                                           cir::TargetAddressSpaceAttr &attr) {
   if (failed(p.parseKeyword("target_address_space")))