Merge remote-tracking branch 'origin/main' into std-vector-op

Author: bruteforceboy

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

@@ -1310,18 +1310,27 @@ def CIR_CXXDtorAttr : CIR_Attr<"CXXDtor", "cxx_dtor"> {
   let description = [{
     Functions with this attribute are CXX destructors
   }];
+<<<<<<< HEAD
   let parameters = (ins "mlir::Type":$type,
     OptionalParameter<"std::optional<const clang::CXXRecordDecl *>">:$recordDecl);
+=======
+  let parameters = (ins "mlir::Type":$type);
+>>>>>>> origin/main
 
   let assemblyFormat = [{
     `<` $type `>`
   }];
 
   let builders = [
+<<<<<<< HEAD
     AttrBuilderWithInferredContext<(ins "mlir::Type":$type,
         CArg<"std::optional<const clang::CXXRecordDecl *>",
              "std::nullopt">:$recordDecl), [{
       return $_get(type.getContext(), type, recordDecl);
+=======
+    AttrBuilderWithInferredContext<(ins "mlir::Type":$type), [{
+      return $_get(type.getContext(), type);
+>>>>>>> origin/main
     }]>
   ];
 }

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

@@ -459,6 +459,21 @@ def CIR_ConstantOp : CIR_Op<"const",[
        return ptrAttr.isNullValue();
       return false;
      }
+
+     template <typename T>
+     T getValueAttr() { return mlir::dyn_cast<T>(getValue()); }
+
+     llvm::APInt getIntValue() {
+       if (const auto intAttr = getValueAttr<cir::IntAttr>())
+         return intAttr.getValue();
+       llvm_unreachable("Expected an IntAttr in ConstantOp");
+     }
+
+     bool getBoolValue() {
+       if (const auto boolAttr = getValueAttr<cir::BoolAttr>())
+         return boolAttr.getValue();
+       llvm_unreachable("Expected a BoolAttr in ConstantOp");
+     }
   }];
 
   let hasFolder = 1;
@@ -3132,6 +3147,58 @@ def CIR_GetMethodOp : CIR_Op<"get_method"> {
   let hasVerifier = 1;
 }
 
+//===----------------------------------------------------------------------===//
+// GetElementOp
+//===----------------------------------------------------------------------===//
+
+def CIR_GetElementOp : CIR_Op<"get_element"> {
+  let summary = "Get the address of an array element";
+  let description = [{
+    The `cir.get_element` operation gets the address of a particular element
+    from the `base` array.
+
+    It expects a pointer to the `base` array and the `index` of the element.
+
+    Example:
+    ```mlir
+    // Suppose we have a array.
+    !s32i = !cir.int<s, 32>
+    !arr_ty = !cir.array<!s32i x 4>
+
+    // Get the address of the element at index 1.
+    %elem_1 = cir.get_element %0[1] : (!cir.ptr<!array_ty>, !s32i) -> !cir.ptr<!s32i>
+
+    // Get the address of the element at index %i.
+    %i = ...
+    %elem_i = cir.get_element %0[%i] : (!cir.ptr<!array_ty>, !s32i) -> !cir.ptr<!s32i>
+    ```
+  }];
+
+  let arguments = (ins
+    Arg<CIR_PtrToArray, "the base address of the array ">:$base,
+    Arg<CIR_AnyFundamentalIntType, "the index of the element">:$index
+  );
+
+  let results = (outs CIR_PointerType:$result);
+
+  let assemblyFormat = [{
+    $base `[` $index `]` `:` `(` qualified(type($base)) `,` qualified(type($index)) `)`
+    `->` qualified(type($result)) attr-dict
+  }];
+
+  let extraClassDeclaration = [{
+    // Get the type of the element.
+    mlir::Type getElementType() {
+      return getType().getPointee();
+    }
+    cir::PointerType getBaseType() {
+      return mlir::cast<cir::PointerType>(getBase().getType());
+    }
+  }];
+
+  let hasVerifier = 1;
+}
+
 //===----------------------------------------------------------------------===//
 // VecInsertOp
 //===----------------------------------------------------------------------===//

clang/lib/CIR/CodeGen/Address.h

@@ -179,6 +179,10 @@ class Address {
       return nullptr;
     return getPointer().getDefiningOp();
   }
+
+  template <typename T> T getDefiningOp() const {
+    return mlir::dyn_cast_or_null<T>(getDefiningOp());
+  }
 };
 
 } // namespace clang::CIRGen

clang/lib/CIR/CodeGen/CIRGenAtomic.cpp

@@ -330,40 +330,41 @@ Address AtomicInfo::CreateTempAlloca() const {
   return TempAlloca;
 }
 
-// If the value comes from a ConstOp + IntAttr, retrieve and skip a series
-// of casts if necessary.
-//
-// FIXME(cir): figure out warning issue and move this to CIRBaseBuilder.h
-static cir::IntAttr getConstOpIntAttr(mlir::Value v) {
-  mlir::Operation *op = v.getDefiningOp();
-  cir::IntAttr constVal;
-  while (auto c = dyn_cast<cir::CastOp>(op))
-    op = c.getOperand().getDefiningOp();
-  if (auto c = dyn_cast<cir::ConstantOp>(op)) {
-    if (mlir::isa<cir::IntType>(c.getType()))
-      constVal = mlir::cast<cir::IntAttr>(c.getValue());
-  }
-  return constVal;
+static mlir::Value stripCasts(mlir::Value value) {
+  while (auto castOp = value.getDefiningOp<cir::CastOp>())
+    value = castOp.getOperand();
+  return value;
+}
+
+static cir::ConstantOp extractConstant(mlir::Value v) {
+  return stripCasts(v).getDefiningOp<cir::ConstantOp>();
+}
+
+// If the value comes from a ConstOp + IntAttr, retrieve and skip a series of
+// casts if necessary.
+static cir::IntAttr extractIntAttr(mlir::Value v) {
+  if (auto c = extractConstant(v))
+    return c.getValueAttr<cir::IntAttr>();
+  return {};
 }
 
 // Inspect a value that is the strong/weak flag for a compare-exchange.  If it
 // is a constant of intergral or boolean type, set `val` to the constant's
 // boolean value and return true.  Otherwise leave `val` unchanged and return
 // false.
 static bool isCstWeak(mlir::Value weakVal, bool &val) {
-  mlir::Operation *op = weakVal.getDefiningOp();
-  while (auto c = dyn_cast<cir::CastOp>(op)) {
-    op = c.getOperand().getDefiningOp();
-  }
-  if (auto c = dyn_cast<cir::ConstantOp>(op)) {
-    if (mlir::isa<cir::IntType>(c.getType())) {
-      val = mlir::cast<cir::IntAttr>(c.getValue()).getUInt() != 0;
+  if (auto c = extractConstant(weakVal)) {
+    if (auto attr = c.getValueAttr<cir::IntAttr>()) {
+      val = attr.getUInt() != 0;
       return true;
-    } else if (mlir::isa<cir::BoolType>(c.getType())) {
-      val = mlir::cast<cir::BoolAttr>(c.getValue()).getValue();
+    }
+
+    if (auto attr = c.getValueAttr<cir::BoolAttr>()) {
+      val = attr.getValue();
       return true;
     }
   }
+
   return false;
 }
 
@@ -456,7 +457,7 @@ static void emitAtomicCmpXchgFailureSet(
     cir::MemOrder SuccessOrder, cir::MemScopeKind Scope) {
 
   cir::MemOrder FailureOrder;
-  if (auto ordAttr = getConstOpIntAttr(FailureOrderVal)) {
+  if (auto ordAttr = extractIntAttr(FailureOrderVal)) {
     // We should not ever get to a case where the ordering isn't a valid CABI
     // value, but it's hard to enforce that in general.
     auto ord = ordAttr.getUInt();
@@ -805,7 +806,7 @@ static void emitAtomicOp(CIRGenFunction &CGF, AtomicExpr *Expr, Address Dest,
   }
 
   // Handle constant scope.
-  if (getConstOpIntAttr(Scope)) {
+  if (extractIntAttr(Scope)) {
     assert(!cir::MissingFeatures::syncScopeID());
     llvm_unreachable("NYI");
     return;
@@ -1208,7 +1209,7 @@ RValue CIRGenFunction::emitAtomicExpr(AtomicExpr *E) {
                 E->getOp() == AtomicExpr::AO__scoped_atomic_load ||
                 E->getOp() == AtomicExpr::AO__scoped_atomic_load_n;
 
-  if (auto ordAttr = getConstOpIntAttr(Order)) {
+  if (auto ordAttr = extractIntAttr(Order)) {
     // We should not ever get to a case where the ordering isn't a valid CABI
     // value, but it's hard to enforce that in general.
     auto ord = ordAttr.getUInt();

clang/lib/CIR/CodeGen/CIRGenBuilder.cpp

@@ -28,11 +28,48 @@ mlir::Value CIRGenBuilderTy::maybeBuildArrayDecay(mlir::Location loc,
   return arrayPtr;
 }
 
-mlir::Value CIRGenBuilderTy::getArrayElement(mlir::Location arrayLocBegin,
+mlir::Value CIRGenBuilderTy::promoteArrayIndex(const clang::TargetInfo &ti,
+                                               mlir::Location loc,
+                                               mlir::Value index) {
+  // Get the array index type.
+  auto arrayIndexWidth = ti.getTypeWidth(clang::TargetInfo::IntType::SignedInt);
+  mlir::Type arrayIndexType = getSIntNTy(arrayIndexWidth);
+
+  // If this is a boolean, zero-extend it to the array index type.
+  if (auto boolTy = mlir::dyn_cast<cir::BoolType>(index.getType()))
+    return create<cir::CastOp>(loc, arrayIndexType, cir::CastKind::bool_to_int,
+                               index);
+
+  // If this an integer, ensure that it is at least as width as the array index
+  // type.
+  if (auto intTy = mlir::dyn_cast<cir::IntType>(index.getType())) {
+    if (intTy.getWidth() < arrayIndexWidth)
+      return create<cir::CastOp>(loc, arrayIndexType, cir::CastKind::integral,
+                                 index);
+  }
+
+  return index;
+}
+
+mlir::Value CIRGenBuilderTy::getArrayElement(const clang::TargetInfo &ti,
+                                             mlir::Location arrayLocBegin,
                                              mlir::Location arrayLocEnd,
                                              mlir::Value arrayPtr,
                                              mlir::Type eltTy, mlir::Value idx,
                                              bool shouldDecay) {
+  auto arrayPtrTy = mlir::dyn_cast<cir::PointerType>(arrayPtr.getType());
+  assert(arrayPtrTy && "expected pointer type");
+
+  // If the array pointer is not decayed, emit a GetElementOp.
+  auto arrayTy = mlir::dyn_cast<cir::ArrayType>(arrayPtrTy.getPointee());
+  if (shouldDecay && arrayTy && arrayTy == eltTy) {
+    auto eltPtrTy =
+        getPointerTo(arrayTy.getElementType(), arrayPtrTy.getAddrSpace());
+    return create<cir::GetElementOp>(arrayLocEnd, eltPtrTy, arrayPtr,
+                                     promoteArrayIndex(ti, arrayLocBegin, idx));
+  }
+
+  // If we don't have sufficient type information, emit a PtrStrideOp.
   mlir::Value basePtr = arrayPtr;
   if (shouldDecay)
     basePtr = maybeBuildArrayDecay(arrayLocBegin, arrayPtr, eltTy);

clang/lib/CIR/CodeGen/CIRGenBuilder.h

@@ -16,6 +16,7 @@
 
 #include "clang/AST/Decl.h"
 #include "clang/AST/Type.h"
+#include "clang/Basic/TargetInfo.h"
 #include "clang/CIR/Dialect/Builder/CIRBaseBuilder.h"
 #include "clang/CIR/Dialect/IR/CIRAttrs.h"
 #include "clang/CIR/Dialect/IR/CIRDataLayout.h"
@@ -1030,10 +1031,15 @@ class CIRGenBuilderTy : public cir::CIRBaseBuilderTy {
     return create<cir::GetRuntimeMemberOp>(loc, resultTy, objectPtr, memberPtr);
   }
 
+  /// Promote a value for use as an array index.
+  mlir::Value promoteArrayIndex(const clang::TargetInfo &TargetInfo,
+                                mlir::Location loc, mlir::Value index);
+
   /// Create a cir.ptr_stride operation to get access to an array element.
   /// idx is the index of the element to access, shouldDecay is true if the
   /// result should decay to a pointer to the element type.
-  mlir::Value getArrayElement(mlir::Location arrayLocBegin,
+  mlir::Value getArrayElement(const clang::TargetInfo &targetInfo,
+                              mlir::Location arrayLocBegin,
                               mlir::Location arrayLocEnd, mlir::Value arrayPtr,
                               mlir::Type eltTy, mlir::Value idx,
                               bool shouldDecay);

clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp

@@ -382,14 +382,11 @@ static mlir::Value makeAtomicFenceValue(CIRGenFunction &cgf,
   auto &builder = cgf.getBuilder();
   mlir::Value orderingVal = cgf.emitScalarExpr(expr->getArg(0));
 
-  auto constOrdering =
-      mlir::dyn_cast<cir::ConstantOp>(orderingVal.getDefiningOp());
+  auto constOrdering = orderingVal.getDefiningOp<cir::ConstantOp>();
   if (!constOrdering)
     llvm_unreachable("NYI: variable ordering not supported");
 
-  auto constOrderingAttr =
-      mlir::dyn_cast<cir::IntAttr>(constOrdering.getValue());
-  if (constOrderingAttr) {
+  if (auto constOrderingAttr = constOrdering.getValueAttr<cir::IntAttr>()) {
     cir::MemOrder ordering =
         static_cast<cir::MemOrder>(constOrderingAttr.getUInt());
 

clang/lib/CIR/CodeGen/CIRGenBuiltinAArch64.cpp

@@ -2123,10 +2123,7 @@ castVecOfFPTypeToVecOfIntWithSameWidth(CIRGenBuilderTy &builder,
 
 /// Get integer from a mlir::Value that is an int constant or a constant op.
 static int64_t getIntValueFromConstOp(mlir::Value val) {
-  auto constOp = mlir::cast<cir::ConstantOp>(val.getDefiningOp());
-  return (mlir::cast<cir::IntAttr>(constOp.getValue()))
-      .getValue()
-      .getSExtValue();
+  return val.getDefiningOp<cir::ConstantOp>().getIntValue().getSExtValue();
 }
 
 static mlir::Value emitNeonSplat(CIRGenBuilderTy &builder, mlir::Location loc,

clang/lib/CIR/CodeGen/CIRGenBuiltinX86.cpp

@@ -68,10 +68,7 @@ translateX86ToMsvcIntrin(unsigned BuiltinID) {
 
 /// Get integer from a mlir::Value that is an int constant or a constant op.
 static int64_t getIntValueFromConstOp(mlir::Value val) {
-  auto constOp = mlir::cast<cir::ConstantOp>(val.getDefiningOp());
-  return (mlir::cast<cir::IntAttr>(constOp.getValue()))
-      .getValue()
-      .getSExtValue();
+  return val.getDefiningOp<cir::ConstantOp>().getIntValue().getSExtValue();
 }
 
 // Convert the mask from an integer type to a vector of i1.
@@ -274,9 +271,8 @@ mlir::Value CIRGenFunction::emitX86BuiltinExpr(unsigned BuiltinID,
   case X86::BI__builtin_ia32_vec_ext_v4di: {
     unsigned NumElts = cast<cir::VectorType>(Ops[0].getType()).getSize();
 
-    auto constOp = cast<cir::ConstantOp>(Ops[1].getDefiningOp());
-    auto intAttr = cast<cir::IntAttr>(constOp.getValue());
-    uint64_t index = intAttr.getValue().getZExtValue();
+    uint64_t index =
+        Ops[1].getDefiningOp<cir::ConstantOp>().getIntValue().getZExtValue();
 
     index &= NumElts - 1;
 
@@ -301,9 +297,8 @@ mlir::Value CIRGenFunction::emitX86BuiltinExpr(unsigned BuiltinID,
   case X86::BI__builtin_ia32_vec_set_v4di: {
     unsigned NumElts = cast<cir::VectorType>(Ops[0].getType()).getSize();
 
-    auto constOp = cast<cir::ConstantOp>(Ops[2].getDefiningOp());
-    auto intAttr = cast<cir::IntAttr>(constOp.getValue());
-    uint64_t index = intAttr.getValue().getZExtValue();
+    uint64_t index =
+        Ops[2].getDefiningOp<cir::ConstantOp>().getIntValue().getZExtValue();
 
     index &= NumElts - 1;
 
@@ -568,7 +563,10 @@ mlir::Value CIRGenFunction::emitX86BuiltinExpr(unsigned BuiltinID,
   case X86::BI__builtin_ia32_movdqa64store512_mask:
   case X86::BI__builtin_ia32_storeaps512_mask:
   case X86::BI__builtin_ia32_storeapd512_mask:
-    llvm_unreachable("vfmaddsubph256_round_mask3 NYI");
+    return emitX86MaskedStore(
+        *this, Ops,
+        getContext().getTypeAlignInChars(E->getArg(1)->getType()).getAsAlign(),
+        getLoc(E->getExprLoc()));
 
   case X86::BI__builtin_ia32_loadups128_mask:
   case X86::BI__builtin_ia32_loadups256_mask:

clang/lib/CIR/CodeGen/CIRGenCall.h

@@ -54,7 +54,7 @@ class CIRGenCallee {
   enum class SpecialKind : uintptr_t {
     Invalid,
     Builtin,
-    PsuedoDestructor,
+    PseudoDestructor,
     Virtual,
 
     Last = Virtual
@@ -128,8 +128,20 @@ class CIRGenCallee {
     return result;
   }
 
-  bool isPsuedoDestructor() const {
-    return KindOrFunctionPointer == SpecialKind::PsuedoDestructor;
+  static CIRGenCallee
+  forPseudoDestructor(const clang::CXXPseudoDestructorExpr *expr) {
+    CIRGenCallee result(SpecialKind::PseudoDestructor);
+    result.PseudoDestructorInfo.Expr = expr;
+    return result;
+  }
+
+  bool isPseudoDestructor() const {
+    return KindOrFunctionPointer == SpecialKind::PseudoDestructor;
+  }
+
+  const CXXPseudoDestructorExpr *getPseudoDestructorExpr() const {
+    assert(isPseudoDestructor());
+    return PseudoDestructorInfo.Expr;
   }
 
   bool isOrdinary() const {