Merge branch 'llvm:main' into convertCIRTargetTriple

Author: felixdaas

clang/include/clang/Basic/LangStandard.h

@@ -26,8 +26,8 @@ enum class Language : uint8_t {
   /// Assembly: we accept this only so that we can preprocess it.
   Asm,
 
-  /// LLVM IR: we accept this so that we can run the optimizer on it,
-  /// and compile it to assembly or object code.
+  /// LLVM IR & CIR: we accept these so that we can run the optimizer on them,
+  /// and compile them to assembly or object code (or LLVM for CIR).
   CIR,
   LLVM_IR,
 

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

@@ -1237,9 +1237,13 @@ def ShiftOp : CIR_Op<"shift", [Pure]> {
     ```
   }];
 
-  let results = (outs CIR_AnyIntOrVecOfInt:$result);
-  let arguments = (ins CIR_AnyIntOrVecOfInt:$value, CIR_AnyIntOrVecOfInt:$amount,
-                       UnitAttr:$isShiftleft);
+  let arguments = (ins
+    CIR_AnyIntOrVecOfIntType:$value,
+    CIR_AnyIntOrVecOfIntType:$amount,
+    UnitAttr:$isShiftleft
+  );
+
+  let results = (outs CIR_AnyIntOrVecOfIntType:$result);
 
   let assemblyFormat = [{
     `(`
@@ -3125,7 +3129,7 @@ def VecInsertOp : CIR_Op<"vec.insert", [Pure,
 
   let arguments = (ins
     CIR_VectorType:$vec,
-    AnyType:$value,
+    CIR_VectorElementType:$value,
     CIR_AnyFundamentalIntType:$index
   );
 
@@ -3158,13 +3162,14 @@ def VecExtractOp : CIR_Op<"vec.extract", [Pure,
     CIR_AnyFundamentalIntType:$index
   );
 
-  let results = (outs CIR_AnyType:$result);
+  let results = (outs CIR_VectorElementType:$result);
 
   let assemblyFormat = [{
     $vec `[` $index `:` type($index) `]` attr-dict `:` qualified(type($vec))
   }];
 
   let llvmOp = "ExtractElementOp";
+  let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//
@@ -3180,7 +3185,7 @@ def VecCreateOp : CIR_Op<"vec.create", [Pure]> {
     in the vector type.
   }];
 
-  let arguments = (ins Variadic<CIR_AnyType>:$elements);
+  let arguments = (ins Variadic<CIR_VectorElementType>:$elements);
   let results = (outs CIR_VectorType:$result);
 
   let assemblyFormat = [{
@@ -3210,7 +3215,7 @@ def VecSplatOp : CIR_Op<"vec.splat", [Pure,
     All elements of the vector have the same value, that of the given scalar.
   }];
 
-  let arguments = (ins CIR_AnyType:$value);
+  let arguments = (ins CIR_VectorElementType:$value);
   let results = (outs CIR_VectorType:$result);
 
   let assemblyFormat = [{
@@ -3263,8 +3268,13 @@ def VecTernaryOp : CIR_Op<"vec.ternary",
     The result is a vector of the same type as the second and third arguments.
     Each element of the result is `(bool)a[n] ? b[n] : c[n]`.
   }];
-  let arguments = (ins IntegerVector:$cond, CIR_VectorType:$vec1,
-		       CIR_VectorType:$vec2);
+
+  let arguments = (ins
+    CIR_VectorOfIntType:$cond,
+    CIR_VectorType:$vec1,
+		CIR_VectorType:$vec2
+  );
+
   let results = (outs CIR_VectorType:$result);
   let assemblyFormat = [{
     `(` $cond `,` $vec1 `,` $vec2 `)` `:` qualified(type($cond)) `,`
@@ -3327,7 +3337,7 @@ def VecShuffleDynamicOp : CIR_Op<"vec.shuffle.dynamic",
     result vector is constructed by taking the elements from the first input
     vector from the indices indicated by the elements of the second vector.
   }];
-  let arguments = (ins CIR_VectorType:$vec, IntegerVector:$indices);
+  let arguments = (ins CIR_VectorType:$vec, CIR_VectorOfIntType:$indices);
   let results = (outs CIR_VectorType:$result);
   let assemblyFormat = [{
     $vec `:` qualified(type($vec)) `,` $indices `:` qualified(type($indices))
@@ -4711,8 +4721,8 @@ def LLrintOp : UnaryFPToIntBuiltinOp<"llrint", "LlrintOp">;
 
 class UnaryFPToFPBuiltinOp<string mnemonic, string llvmOpName>
     : CIR_Op<mnemonic, [Pure, SameOperandsAndResultType]> {
-  let arguments = (ins CIR_AnyFloatOrVecOfFloat:$src);
-  let results = (outs CIR_AnyFloatOrVecOfFloat:$result);
+  let arguments = (ins CIR_AnyFloatOrVecOfFloatType:$src);
+  let results = (outs CIR_AnyFloatOrVecOfFloatType:$result);
   let summary = "libc builtin equivalent ignoring "
                 "floating point exceptions and errno";
   let assemblyFormat = "$src `:` type($src) attr-dict";
@@ -4742,8 +4752,6 @@ def TanOp : UnaryFPToFPBuiltinOp<"tan", "TanOp">;
 def TruncOp : UnaryFPToFPBuiltinOp<"trunc", "FTruncOp">;
 
 def AbsOp : CIR_Op<"abs", [Pure, SameOperandsAndResultType]> {
-  let arguments = (ins CIR_AnySignedIntOrVecOfSignedInt:$src, UnitAttr:$poison);
-  let results = (outs CIR_AnySignedIntOrVecOfSignedInt:$result);
   let summary = [{
     libc builtin equivalent abs, labs, llabs
 
@@ -4759,6 +4767,14 @@ def AbsOp : CIR_Op<"abs", [Pure, SameOperandsAndResultType]> {
       %2 = cir.abs %3 : !cir.vector<!s32i x 4>
     ```
   }];
+
+  let arguments = (ins
+    CIR_AnySIntOrVecOfSIntType:$src,
+    UnitAttr:$poison
+  );
+
+  let results = (outs CIR_AnySIntOrVecOfSIntType:$result);
+
   let assemblyFormat = "$src ( `poison` $poison^ )? `:` type($src) attr-dict";
 }
 
@@ -4768,9 +4784,12 @@ class BinaryFPToFPBuiltinOp<string mnemonic, string llvmOpName>
     libc builtin equivalent ignoring floating-point exceptions and errno.
   }];
 
-  let arguments = (ins  CIR_AnyFloatOrVecOfFloat:$lhs,
-                         CIR_AnyFloatOrVecOfFloat:$rhs);
-  let results = (outs  CIR_AnyFloatOrVecOfFloat:$result);
+  let arguments = (ins
+    CIR_AnyFloatOrVecOfFloatType:$lhs,
+    CIR_AnyFloatOrVecOfFloatType:$rhs
+  );
+
+  let results = (outs  CIR_AnyFloatOrVecOfFloatType:$result);
 
   let assemblyFormat = [{
     $lhs `,` $rhs `:` qualified(type($lhs)) attr-dict

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

@@ -43,6 +43,12 @@ class CIR_TypeSummaries<list<Type> types> {
     string value = !if(!eq(!size(types), 1), joined, "any of " # joined);
 }
 
+//===----------------------------------------------------------------------===//
+// Bool Type predicates
+//===----------------------------------------------------------------------===//
+
+def CIR_AnyBoolType : CIR_TypeBase<"::cir::BoolType", "boolean type">;
+
 //===----------------------------------------------------------------------===//
 // IntType predicates
 //===----------------------------------------------------------------------===//
@@ -250,4 +256,78 @@ def CIR_PtrToExceptionInfoType
       BuildableType<"$_builder.getType<" # cppType # ">("
         "cir::ExceptionInfoType::get($_builder.getContext())))">;
 
+//===----------------------------------------------------------------------===//
+// Data member type predicates
+//===----------------------------------------------------------------------===//
+
+def CIR_AnyDataMemberType : CIR_TypeBase<"::cir::DataMemberType",
+    "data member type">;
+
+//===----------------------------------------------------------------------===//
+// Scalar Type predicates
+//===----------------------------------------------------------------------===//
+
+defvar CIR_ScalarTypes = [
+    CIR_AnyBoolType, CIR_AnyIntType, CIR_AnyFloatType, CIR_AnyPtrType,
+    CIR_AnyDataMemberType
+];
+
+def CIR_AnyScalarType : AnyTypeOf<CIR_ScalarTypes, "cir scalar type"> {
+  let cppFunctionName = "isScalarType";
+}
+
+//===----------------------------------------------------------------------===//
+// Vector Type predicates
+//===----------------------------------------------------------------------===//
+
+def CIR_AnyVectorType : CIR_TypeBase<"::cir::VectorType", "vector type">;
+
+def CIR_VectorElementType : AnyTypeOf<[CIR_AnyIntOrFloatType, CIR_AnyPtrType],
+    "any cir integer, floating point or pointer type"
+> {
+    let cppFunctionName = "isValidVectorTypeElementType";
+}
+
+// Element type constraint bases
+class CIR_ElementTypePred<Pred pred> : SubstLeaves<"$_self",
+    "::mlir::cast<::cir::VectorType>($_self).getElementType()", pred>;
+
+class CIR_VectorTypeOf<list<Type> types, string summary = "">
+    : CIR_ConfinedType<CIR_AnyVectorType,
+        [Or<!foreach(type, types, CIR_ElementTypePred<type.predicate>)>],
+        !if(!empty(summary),
+            "vector of " # CIR_TypeSummaries<types>.value,
+            summary)>;
+
+// Vector of type constraints
+def CIR_VectorOfIntType : CIR_VectorTypeOf<[CIR_AnyIntType]>;
+def CIR_VectorOfUIntType : CIR_VectorTypeOf<[CIR_AnyUIntType]>;
+def CIR_VectorOfSIntType : CIR_VectorTypeOf<[CIR_AnySIntType]>;
+def CIR_VectorOfFloatType : CIR_VectorTypeOf<[CIR_AnyFloatType]>;
+
+// Vector or Scalar type constraints
+def CIR_AnyIntOrVecOfIntType
+    : AnyTypeOf<[CIR_AnyIntType, CIR_VectorOfIntType],
+        "integer or vector of integer type"> {
+    let cppFunctionName = "isIntOrVectorOfIntType";
+}
+
+def CIR_AnySIntOrVecOfSIntType
+    : AnyTypeOf<[CIR_AnySIntType, CIR_VectorOfSIntType],
+        "signed integer or vector of signed integer type"> {
+    let cppFunctionName = "isSIntOrVectorOfSIntType";
+}
+
+def CIR_AnyUIntOrVecOfUIntType
+    : AnyTypeOf<[CIR_AnyUIntType, CIR_VectorOfUIntType],
+        "unsigned integer or vector of unsigned integer type"> {
+    let cppFunctionName = "isUIntOrVectorOfUIntType";
+}
+
+def CIR_AnyFloatOrVecOfFloatType
+    : AnyTypeOf<[CIR_AnyFloatType, CIR_VectorOfFloatType],
+        "floating point or vector of floating point type"> {
+    let cppFunctionName = "isFPOrVectorOfFPType";
+}
+
 #endif // CLANG_CIR_DIALECT_IR_CIRTYPECONSTRAINTS_TD

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

@@ -27,9 +27,6 @@ struct RecordTypeStorage;
 
 bool isValidFundamentalIntWidth(unsigned width);
 
-bool isScalarType(mlir::Type t);
-bool isFPOrFPVectorTy(mlir::Type);
-bool isIntOrIntVectorTy(mlir::Type);
 } // namespace cir
 
 mlir::ParseResult parseAddrSpaceAttribute(mlir::AsmParser &p,

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

@@ -262,15 +262,15 @@ def CIR_PointerType : CIR_Type<"Pointer", "ptr",
 }
 
 //===----------------------------------------------------------------------===//
-// DataMemberType
+// CIR_DataMemberType
 //===----------------------------------------------------------------------===//
 
 def CIR_DataMemberType : CIR_Type<"DataMember", "data_member",
     [DeclareTypeInterfaceMethods<DataLayoutTypeInterface>]> {
 
   let summary = "CIR type that represents pointer-to-data-member type in C++";
   let description = [{
-    `cir.member_ptr` models the pointer-to-data-member type in C++. Values of
+    `cir.data_member` models the pointer-to-data-member type in C++. Values of
     this type are essentially offsets of the pointed-to member within one of
     its containing record.
   }];
@@ -345,11 +345,31 @@ def CIR_VectorType : CIR_Type<"Vector", "vector",
 
   let summary = "CIR vector type";
   let description = [{
-    `cir.vector' represents fixed-size vector types.  The parameters are the
-    element type and the number of elements.
+    The `!cir.vector` type represents a fixed-size, one-dimensional vector.
+    It takes two parameters: the element type and the number of elements.
+
+    Syntax:
+
+    ```mlir
+    vector-type ::= !cir.vector<element-type x size>
+    element-type ::= float-type | integer-type | pointer-type
+    ```
+
+    The `element-type` must be a scalar CIR type. Zero-sized vectors are not
+    allowed. The `size` must be a positive integer.
+
+    Examples:
+
+    ```mlir
+    !cir.vector<!cir.int<u, 8> x 4>
+    !cir.vector<!cir.float x 2>
+    ```
   }];
 
-  let parameters = (ins "mlir::Type":$elementType, "uint64_t":$size);
+  let parameters = (ins
+    CIR_VectorElementType:$elementType,
+    "uint64_t":$size
+  );
 
   let builders = [
     TypeBuilderWithInferredContext<(ins
@@ -503,50 +523,6 @@ def CIR_VoidType : CIR_Type<"Void", "void"> {
   }];
 }
 
-// Constraints
-
-// Vector of integral type
-def IntegerVector : Type<
-    And<[
-      CPred<"::mlir::isa<::cir::VectorType>($_self)">,
-      CPred<"::mlir::isa<::cir::IntType>("
-            "::mlir::cast<::cir::VectorType>($_self).getElementType())">,
-      CPred<"::mlir::cast<::cir::IntType>("
-            "::mlir::cast<::cir::VectorType>($_self).getElementType())"
-            ".isFundamental()">
-    ]>, "!cir.vector of !cir.int"> {
-}
-
-// Vector of signed integral type
-def SignedIntegerVector : Type<
-    And<[
-      CPred<"::mlir::isa<::cir::VectorType>($_self)">,
-      CPred<"::mlir::isa<::cir::IntType>("
-            "::mlir::cast<::cir::VectorType>($_self).getElementType())">,
-      CPred<"::mlir::cast<::cir::IntType>("
-            "::mlir::cast<::cir::VectorType>($_self).getElementType())"
-            ".isSignedFundamental()">
-    ]>, "!cir.vector of !cir.int"> {
-}
-
-// Vector of Float type
-def FPVector : Type<
-    And<[
-      CPred<"::mlir::isa<::cir::VectorType>($_self)">,
-      CPred<"::mlir::isa<::cir::SingleType, ::cir::DoubleType>("
-            "::mlir::cast<::cir::VectorType>($_self).getElementType())">,
-    ]>, "!cir.vector of !cir.fp"> {
-}
-
-// Constraints
-def CIR_AnyIntOrVecOfInt: AnyTypeOf<[CIR_IntType, IntegerVector]>;
-
-def CIR_AnySignedIntOrVecOfSignedInt: AnyTypeOf<[
-  CIR_AnyFundamentalSIntType, SignedIntegerVector
-]>;
-
-def CIR_AnyFloatOrVecOfFloat: AnyTypeOf<[CIR_AnyFloatType, FPVector]>;
-
 //===----------------------------------------------------------------------===//
 // RecordType
 //

clang/include/clang/Driver/Types.def

@@ -100,6 +100,7 @@ TYPE("lto-ir",                   LTO_IR,       INVALID,         "s",      phases
 TYPE("lto-bc",                   LTO_BC,       INVALID,         "o",      phases::Compile, phases::Backend, phases::Assemble, phases::Link)
 
 TYPE("mlir",                     MLIR,         INVALID,         "mlir",   phases::Compile, phases::Backend, phases::Assemble, phases::Link)
+TYPE("cir",                      CIR,          INVALID,         "cir",    phases::Compile, phases::Backend, phases::Assemble, phases::Link)
 
 // Misc.
 TYPE("ast",                      AST,          INVALID,         "ast",    phases::Compile, phases::Backend, phases::Assemble, phases::Link)

clang/lib/CIR/CodeGen/CIRGenBuiltin.cpp

@@ -1482,7 +1482,7 @@ RValue CIRGenFunction::emitBuiltinExpr(const GlobalDecl GD, unsigned BuiltinID,
 
   case Builtin::BI__builtin_elementwise_abs: {
     mlir::Type cirTy = convertType(E->getArg(0)->getType());
-    bool isIntTy = cir::isIntOrIntVectorTy(cirTy);
+    bool isIntTy = cir::isIntOrVectorOfIntType(cirTy);
     if (!isIntTy) {
       return emitUnaryFPBuiltin<cir::FAbsOp>(*this, *E);
     }

clang/lib/CIR/CodeGen/CIRGenBuiltinAArch64.cpp

@@ -4015,7 +4015,7 @@ CIRGenFunction::emitAArch64BuiltinExpr(unsigned BuiltinID, const CallExpr *E,
     mlir::Location loc = getLoc(E->getExprLoc());
     Ops[0] = builder.createBitcast(Ops[0], ty);
     Ops[1] = builder.createBitcast(Ops[1], ty);
-    if (cir::isFPOrFPVectorTy(ty)) {
+    if (cir::isFPOrVectorOfFPType(ty)) {
       return builder.create<cir::FMaximumOp>(loc, Ops[0], Ops[1]);
     }
     return builder.create<cir::BinOp>(loc, cir::BinOpKind::Max, Ops[0], Ops[1]);
@@ -4026,7 +4026,7 @@ CIRGenFunction::emitAArch64BuiltinExpr(unsigned BuiltinID, const CallExpr *E,
   case NEON::BI__builtin_neon_vmin_v:
   case NEON::BI__builtin_neon_vminq_v: {
     llvm::StringRef name = usgn ? "aarch64.neon.umin" : "aarch64.neon.smin";
-    if (cir::isFPOrFPVectorTy(ty))
+    if (cir::isFPOrVectorOfFPType(ty))
       name = "aarch64.neon.fmin";
     return emitNeonCall(builder, {ty, ty}, Ops, name, ty,
                         getLoc(E->getExprLoc()));
@@ -4037,7 +4037,7 @@ CIRGenFunction::emitAArch64BuiltinExpr(unsigned BuiltinID, const CallExpr *E,
   case NEON::BI__builtin_neon_vabd_v:
   case NEON::BI__builtin_neon_vabdq_v: {
     llvm::StringRef name = usgn ? "aarch64.neon.uabd" : "aarch64.neon.sabd";
-    if (cir::isFPOrFPVectorTy(ty))
+    if (cir::isFPOrVectorOfFPType(ty))
       name = "aarch64.neon.fabd";
     return emitNeonCall(builder, {ty, ty}, Ops, name, ty,
                         getLoc(E->getExprLoc()));