add CXXCtorDtor attribute

Author: bruteforceboy

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

@@ -1138,9 +1138,9 @@ def ASTCallExprAttr : AST<"CallExpr", "call.expr",
 //===----------------------------------------------------------------------===//
 
 def CIR_VisibilityKind : CIR_I32EnumAttr<"VisibilityKind", "C/C++ visibility", [
- I32EnumAttrCase<"Default", 1, "default">,
- I32EnumAttrCase<"Hidden", 2, "hidden">,
- I32EnumAttrCase<"Protected", 3, "protected">
+ I32EnumAttrCase<"Default", 0, "default">,
+ I32EnumAttrCase<"Hidden", 1, "hidden">,
+ I32EnumAttrCase<"Protected", 2, "protected">
 ]> {
  let genSpecializedAttr = 0;
 }
@@ -1155,7 +1155,8 @@ def CIR_VisibilityAttr : CIR_EnumAttr<CIR_VisibilityKind, "visibility"> {
 
  let skipDefaultBuilders = 1;
  let builders = [
- AttrBuilder<(ins CArg<"VisibilityKind", "cir::VisibilityKind::Default">:$value), [{
+ AttrBuilder<(ins CArg<"VisibilityKind",
+ "cir::VisibilityKind::Default">:$value), [{
  return $_get($_ctxt, value);
  }]>
  ];
@@ -1300,6 +1301,59 @@ def GlobalDtorAttr : CIR_GlobalCtorDtor<"Dtor", "dtor",
  "A function with this attribute excutes before module unloading"
 >;
 
+class CIR_CXXSpecialMember<string name, string attrMnemonic, string sum,
+ string desc> : CIR_Attr<name, attrMnemonic> {
+ let summary = sum;
+ let description = desc;
+ let skipDefaultBuilders = 1;
+}
+
+def CXXCtorAttr
+ : CIR_CXXSpecialMember<
+ "CXXCtor", "cxx_ctor", "Marks a function as a CXX constructor",
+ "Functions with this attribute are CXX constructors"> {
+ let parameters = (ins "mlir::Type":$type,
+ "bool":$is_default_constructor,
+ "bool":$is_copy_constructor);
+ let assemblyFormat = [{
+ `<`
+ $type `,` $is_default_constructor `,` $is_copy_constructor
+ `>`
+ }];
+ let builders =
+ [AttrBuilder<(ins "mlir::Type":$type,
+ "bool":$is_default_constructor,
+ "bool":$is_copy_constructor), [{
+ return $_get($_ctxt, type, is_default_constructor,
+ is_copy_constructor);
+ }]>,
+ AttrBuilderWithInferredContext<(ins "mlir::Type":$type,
+ "bool":$is_default_constructor,
+ "bool":$is_copy_constructor), [{
+ return $_get(type.getContext(), type,
+ is_default_constructor, is_copy_constructor);
+ }]>];
+}
+
+def CXXDtorAttr
+ : CIR_CXXSpecialMember<
+ "CXXDtor", "cxx_dtor", "Marks a function as a CXX destructor",
+ "Functions with this attribute are CXX destructors"> {
+ let parameters = (ins "mlir::Type":$type);
+ let assemblyFormat = [{
+ `<`
+ $type
+ `>`
+ }];
+ let builders =
+ [AttrBuilder<(ins "mlir::Type":$type), [{
+ return $_get($_ctxt, type);
+ }]>,
+ AttrBuilderWithInferredContext<(ins "mlir::Type":$type), [{
+ return $_get(type.getContext(), type);
+ }]>];
+}
+
 def BitfieldInfoAttr : CIR_Attr<"BitfieldInfo", "bitfield_info"> {
  let summary = "Represents a bit field info";
  let description = [{

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

@@ -87,32 +87,78 @@ class CIR_Op<string mnemonic, list<Trait> traits = []> :
 //===----------------------------------------------------------------------===//
 
 def CIR_CastKind : CIR_I32EnumAttr<"CastKind", "cast kind", [
- // The enumaration value isn't in sync with clang.
- I32EnumAttrCase<"int_to_bool", 0>,
- I32EnumAttrCase<"array_to_ptrdecay", 1>,
- I32EnumAttrCase<"integral", 2>,
- I32EnumAttrCase<"bitcast", 3>,
- I32EnumAttrCase<"floating", 4>,
- I32EnumAttrCase<"ptr_to_bool", 5>,
- I32EnumAttrCase<"float_to_int", 6>,
- I32EnumAttrCase<"int_to_ptr", 7>,
- I32EnumAttrCase<"ptr_to_int", 8>,
- I32EnumAttrCase<"float_to_bool", 9>,
- I32EnumAttrCase<"bool_to_int", 10>,
- I32EnumAttrCase<"int_to_float", 11>,
- I32EnumAttrCase<"bool_to_float", 12>,
- I32EnumAttrCase<"address_space", 13>,
- I32EnumAttrCase<"float_to_complex", 14>,
- I32EnumAttrCase<"int_to_complex", 15>,
- I32EnumAttrCase<"float_complex_to_real", 16>,
- I32EnumAttrCase<"int_complex_to_real", 17>,
- I32EnumAttrCase<"float_complex_to_bool", 18>,
- I32EnumAttrCase<"int_complex_to_bool", 19>,
- I32EnumAttrCase<"float_complex", 20>,
- I32EnumAttrCase<"float_complex_to_int_complex", 21>,
- I32EnumAttrCase<"int_complex", 22>,
- I32EnumAttrCase<"int_complex_to_float_complex", 23>,
- I32EnumAttrCase<"member_ptr_to_bool", 24>
+ I32EnumAttrCase<"bitcast", 1>,
+ // CK_LValueBitCast
+ // CK_LValueToRValueBitCast
+ // CK_LValueToRValue
+ // CK_NoOp
+ // CK_BaseToDerived
+ // CK_DerivedToBase
+ // CK_UncheckedDerivedToBase
+ // CK_Dynamic
+ // CK_ToUnion
+ I32EnumAttrCase<"array_to_ptrdecay", 11>,
+ // CK_FunctionToPointerDecay
+ // CK_NullToPointer
+ // CK_NullToMemberPointer
+ // CK_BaseToDerivedMemberPointer
+ // CK_DerivedToBaseMemberPointer
+ I32EnumAttrCase<"member_ptr_to_bool", 17>,
+ // CK_ReinterpretMemberPointer
+ // CK_UserDefinedConversion
+ // CK_ConstructorConversion
+ I32EnumAttrCase<"int_to_ptr", 21>,
+ I32EnumAttrCase<"ptr_to_int", 22>,
+ I32EnumAttrCase<"ptr_to_bool", 23>,
+ // CK_ToVoid
+ // CK_MatrixCast
+ // CK_VectorSplat
+ I32EnumAttrCase<"integral", 27>,
+ I32EnumAttrCase<"int_to_bool", 28>,
+ I32EnumAttrCase<"int_to_float", 29>,
+ // CK_FloatingToFixedPoint
+ // CK_FixedPointToFloating
+ // CK_FixedPointCast
+ // CK_FixedPointToIntegral
+ // CK_IntegralToFixedPoint
+ // CK_FixedPointToBoolean
+ I32EnumAttrCase<"float_to_int", 36>,
+ I32EnumAttrCase<"float_to_bool", 37>,
+ I32EnumAttrCase<"bool_to_int", 38>,
+ I32EnumAttrCase<"floating", 39>,
+ // CK_CPointerToObjCPointerCast
+ // CK_BlockPointerToObjCPointerCast
+ // CK_AnyPointerToBlockPointerCast
+ // CK_ObjCObjectLValueCast
+ I32EnumAttrCase<"float_to_complex", 44>,
+ I32EnumAttrCase<"float_complex_to_real", 45>,
+ I32EnumAttrCase<"float_complex_to_bool", 46>,
+ I32EnumAttrCase<"float_complex", 47>,
+ I32EnumAttrCase<"float_complex_to_int_complex", 48>,
+ I32EnumAttrCase<"int_to_complex", 49>,
+ I32EnumAttrCase<"int_complex_to_real", 50>,
+ I32EnumAttrCase<"int_complex_to_bool", 51>,
+ I32EnumAttrCase<"int_complex", 52>,
+ I32EnumAttrCase<"int_complex_to_float_complex", 53>,
+ // CK_ARCProduceObject
+ // CK_ARCConsumeObject
+ // CK_ARCReclaimReturnedObject
+ // CK_ARCExtendBlockObject
+ // CK_AtomicToNonAtomic
+ // CK_NonAtomicToAtomic
+ // CK_CopyAndAutoreleaseBlockObject
+ // CK_BuiltinFnToFnPtr
+ // CK_ZeroToOCLOpaqueType
+ I32EnumAttrCase<"address_space", 63>,
+ // CK_IntToOCLSampler
+ // CK_HLSLVectorTruncation
+ // CK_HLSLArrayRValue
+ // CK_HLSLElementwiseCast
+ // CK_HLSLAggregateSplatCast
+
+ // Enums below are specific to CIR and don't have a correspondence to classic
+ // codegen:
+ I32EnumAttrCase<"bool_to_float", 1000>,
 ]>;
 
 def CastOp : CIR_Op<"cast",
@@ -121,39 +167,48 @@ def CastOp : CIR_Op<"cast",
  // FIXME: not all conversions are free of side effects.
  let summary = "Conversion between values of different types";
  let description = [{
- Apply C/C++ usual conversions rules between values. Currently supported kinds:
+ Apply the usual C/C++ conversion rules between values. This operation models
+ a subset of conversions as defined in Clang's `OperationKinds.def`
+ (`llvm-project/clang/include/clang/AST/OperationKinds.def`).
+
+ Note: not all conversions are implemented using `cir.cast`. For instance,
+ lvalue-to-rvalue conversion is modeled as a `cir.load` instead. Currently
+ supported kinds:
 
- - `array_to_ptrdecay`
  - `bitcast`
+ - `array_to_ptrdecay`
+ - `member_ptr_to_bool
+ - `int_to_ptr`
+ - `ptr_to_int`
+ - `ptr_to_bool`
  - `integral`
  - `int_to_bool`
  - `int_to_float`
- - `floating`
  - `float_to_int`
  - `float_to_bool`
- - `ptr_to_int`
- - `ptr_to_bool`
  - `bool_to_int`
- - `bool_to_float`
- - `address_space`
+ - `floating`
  - `float_to_complex`
- - `int_to_complex`
  - `float_complex_to_real`
- - `int_complex_to_real`
  - `float_complex_to_bool`
- - `int_complex_to_bool`
  - `float_complex`
  - `float_complex_to_int_complex`
+ - `int_to_complex`
+ - `int_complex_to_real`
+ - `int_complex_to_bool`
  - `int_complex`
  - `int_complex_to_float_complex`
+ - `address_space`
+
+ CIR also supports some additional conversions that are not part of the classic
+ Clang codegen:
+
+ - `bool_to_float`
 
- This is effectively a subset of the rules from
- `llvm-project/clang/include/clang/AST/OperationKinds.def`; but note that some
- of the conversions aren't implemented in terms of `cir.cast`, `lvalue-to-rvalue`
- for instance is modeled as a regular `cir.load`.
+ Example:
 
  ```mlir
- %4 = cir.cast (int_to_bool, %3 : i32), !cir.bool
+ %4 = cir.cast(int_to_bool, %3 : i32), !cir.bool
  ...
  %x = cir.cast(array_to_ptrdecay, %0 : !cir.ptr<!cir.array<i32 x 10>>), !cir.ptr<i32>
  ```
@@ -1846,10 +1901,10 @@ def CmpThreeWayOp : CIR_Op<"cmp3way", [Pure, SameTypeOperands]> {
 //===----------------------------------------------------------------------===//
 
 def CIR_CaseOpKind : CIR_I32EnumAttr<"CaseOpKind", "case kind", [
- I32EnumAttrCase<"Default", 1, "default">,
- I32EnumAttrCase<"Equal", 2, "equal">,
- I32EnumAttrCase<"Anyof", 3, "anyof">,
- I32EnumAttrCase<"Range", 4, "range">
+ I32EnumAttrCase<"Default", 0, "default">,
+ I32EnumAttrCase<"Equal", 1, "equal">,
+ I32EnumAttrCase<"Anyof", 2, "anyof">,
+ I32EnumAttrCase<"Range", 3, "range">
 ]>;
 
 def CaseOp : CIR_Op<"case", [
@@ -3107,6 +3162,7 @@ def VecCreateOp : CIR_Op<"vec.create", [Pure]> {
  }];
 
  let hasVerifier = 1;
+ let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//
@@ -3169,7 +3225,7 @@ def VecCmpOp : CIR_Op<"vec.cmp", [Pure, SameTypeOperands]> {
 //===----------------------------------------------------------------------===//
 
 def VecTernaryOp : CIR_Op<"vec.ternary",
- [Pure, AllTypesMatch<["result", "vec1", "vec2"]>]> {
+ [Pure, AllTypesMatch<["result", "lhs", "rhs"]>]> {
  let summary = "The `cond ? a : b` ternary operator for vector types";
  let description = [{
  The `cir.vec.ternary` operation represents the C/C++ ternary operator,
@@ -3188,16 +3244,18 @@ def VecTernaryOp : CIR_Op<"vec.ternary",
 
  let arguments = (ins
  CIR_VectorOfIntType:$cond,
- CIR_VectorType:$vec1,
-CIR_VectorType:$vec2
+ CIR_VectorType:$lhs,
+ CIR_VectorType:$rhs
  );
 
  let results = (outs CIR_VectorType:$result);
  let assemblyFormat = [{
- `(` $cond `,` $vec1 `,` $vec2 `)` `:` qualified(type($cond)) `,`
- qualified(type($vec1)) attr-dict
+ `(` $cond `,` $lhs `,` $rhs `)` `:` qualified(type($cond)) `,`
+ qualified(type($lhs)) attr-dict
  }];
+
  let hasVerifier = 1;
+ let hasFolder = 1;
 }
 
 //===----------------------------------------------------------------------===//
@@ -3595,7 +3653,9 @@ def FuncOp : CIR_Op<"func", [
  OptionalAttr<GlobalCtorAttr>:$global_ctor,
  OptionalAttr<GlobalDtorAttr>:$global_dtor,
  OptionalAttr<ArrayAttr>:$annotations,
- OptionalAttr<AnyASTFunctionDeclAttr>:$ast
+ OptionalAttr<AnyASTFunctionDeclAttr>:$ast,
+ OptionalAttr<CXXCtorAttr>:$cxx_ctor,
+ OptionalAttr<CXXDtorAttr>:$cxx_dtor
  );
 
  let regions = (region AnyRegion:$body);
@@ -3765,11 +3825,11 @@ def DeleteArrayOp : CIR_Op<"delete.array">,
 //===----------------------------------------------------------------------===//
 
 def CIR_SideEffect : CIR_I32EnumAttr<
- "SideEffect", "allowed side effects of a function",[
- I32EnumAttrCase<"All", 1, "all">,
- I32EnumAttrCase<"Pure", 2, "pure">,
- I32EnumAttrCase<"Const", 3, "const">
- ]> {
+ "SideEffect", "allowed side effects of a function", [
+ I32EnumAttrCase<"All", 0, "all">,
+ I32EnumAttrCase<"Pure", 1, "pure">,
+ I32EnumAttrCase<"Const", 2, "const">
+]> {
  let description = [{
  The side effect attribute specifies the possible side effects of the callee
  of a call operation. This is an enumeration attribute and all possible

clang/lib/CIR/CodeGen/CIRGenBuiltinX86.cpp

@@ -145,19 +145,46 @@ mlir::Value CIRGenFunction::emitX86BuiltinExpr(unsigned BuiltinID,
  .getResult();
  }
  case X86::BI__builtin_ia32_rdtscp: {
- llvm_unreachable("__rdtscp NYI");
+ // For rdtscp, we need to create a proper struct type to hold {i64, i32}
+ cir::RecordType resTy = builder.getAnonRecordTy(
+ {builder.getUInt64Ty(), builder.getUInt32Ty()}, false, false);
+
+ auto call = builder
+ .create<cir::LLVMIntrinsicCallOp>(
+ getLoc(E->getExprLoc()),
+ builder.getStringAttr("x86.rdtscp"), resTy)
+ .getResult();
+
+ // Store processor ID in address param
+ mlir::Value pID = builder.create<cir::ExtractMemberOp>(
+ getLoc(E->getExprLoc()), builder.getUInt32Ty(), call, 1);
+ builder.create<cir::StoreOp>(getLoc(E->getExprLoc()), pID, Ops[0]);
+
+ // Return the timestamp at index 0
+ return builder.create<cir::ExtractMemberOp>(getLoc(E->getExprLoc()),
+ builder.getUInt64Ty(), call, 0);
  }
  case X86::BI__builtin_ia32_lzcnt_u16:
  case X86::BI__builtin_ia32_lzcnt_u32:
  case X86::BI__builtin_ia32_lzcnt_u64: {
  mlir::Value V = builder.create<cir::ConstantOp>(
  getLoc(E->getExprLoc()), cir::BoolAttr::get(&getMLIRContext(), false));
-
  return builder
  .create<cir::LLVMIntrinsicCallOp>(
  getLoc(E->getExprLoc()), builder.getStringAttr("ctlz"),
  Ops[0].getType(), mlir::ValueRange{Ops[0], V})
  .getResult();
  }
+ case X86::BI__builtin_ia32_tzcnt_u16:
+ case X86::BI__builtin_ia32_tzcnt_u32:
+ case X86::BI__builtin_ia32_tzcnt_u64: {
+ mlir::Value V = builder.create<cir::ConstantOp>(
+ getLoc(E->getExprLoc()), cir::BoolAttr::get(&getMLIRContext(), false));
+ return builder
+ .create<cir::LLVMIntrinsicCallOp>(
+ getLoc(E->getExprLoc()), builder.getStringAttr("cttz"),
+ Ops[0].getType(), mlir::ValueRange{Ops[0], V})
+ .getResult();
+ }
  }
 }

clang/lib/CIR/CodeGen/CIRGenExprComplex.cpp

@@ -313,7 +313,10 @@ class ComplexExprEmitter : public StmtVisitor<ComplexExprEmitter, mlir::Value> {
  VisitAbstractConditionalOperator(const AbstractConditionalOperator *CO) {
  llvm_unreachable("NYI");
  }
- mlir::Value VisitChooseExpr(ChooseExpr *CE) { llvm_unreachable("NYI"); }
+
+ mlir::Value VisitChooseExpr(ChooseExpr *CE) {
+ return Visit(CE->getChosenSubExpr());
+ }
 
  mlir::Value VisitInitListExpr(InitListExpr *E);