diff --git a/clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h b/clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h index a3df0ef0dcdc..110bedf5e456 100644 --- a/clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h +++ b/clang/include/clang/CIR/Dialect/Builder/CIRBaseBuilder.h @@ -328,8 +328,8 @@ class CIRBaseBuilderTy : public mlir::OpBuilder { } mlir::TypedAttr getConstPtrAttr(mlir::Type t, uint64_t v) { - assert(t.isa() && "expected cir.ptr"); - return mlir::cir::ConstPtrAttr::get(getContext(), t, v); + return mlir::cir::ConstPtrAttr::get(getContext(), + t.cast(), v); } // Creates constant nullptr for pointer type ty. diff --git a/clang/include/clang/CIR/Dialect/IR/CIRAttrs.td b/clang/include/clang/CIR/Dialect/IR/CIRAttrs.td index 2d53115e9917..c4e09abbf81d 100644 --- a/clang/include/clang/CIR/Dialect/IR/CIRAttrs.td +++ b/clang/include/clang/CIR/Dialect/IR/CIRAttrs.td @@ -248,20 +248,29 @@ def FPAttr : CIR_Attr<"FP", "fp", [TypedAttrInterface]> { def ConstPtrAttr : CIR_Attr<"ConstPtr", "ptr", [TypedAttrInterface]> { let summary = "Holds a constant pointer value"; - let parameters = (ins AttributeSelfTypeParameter<"">:$type, "uint64_t":$value); + let parameters = (ins + AttributeSelfTypeParameter<"", "::mlir::cir::PointerType">:$type, + "uint64_t":$value); let description = [{ A pointer attribute is a literal attribute that represents an integral value of a pointer type. }]; let builders = [ AttrBuilderWithInferredContext<(ins "Type":$type, "uint64_t":$value), [{ - return $_get(type.getContext(), type, value); + return $_get(type.getContext(), type.cast(), value); + }]>, + AttrBuilder<(ins "Type":$type, + "uint64_t":$value), [{ + return $_get($_ctxt, type.cast(), value); }]>, ]; let extraClassDeclaration = [{ bool isNullValue() const { return getValue() == 0; } }]; - let hasCustomAssemblyFormat = 1; + + let assemblyFormat = [{ + `<` custom($value) `>` + }]; } //===----------------------------------------------------------------------===// diff --git a/clang/include/clang/CIR/Dialect/IR/CIROps.td b/clang/include/clang/CIR/Dialect/IR/CIROps.td index f672e10e7597..1d29cf7863fa 100644 --- a/clang/include/clang/CIR/Dialect/IR/CIROps.td +++ b/clang/include/clang/CIR/Dialect/IR/CIROps.td @@ -264,7 +264,7 @@ def PtrStrideOp : CIR_Op<"ptr_stride", a stride (second operand). ```mlir - %3 = cir.const(0 : i32) : i32 + %3 = cir.const 0 : i32 %4 = cir.ptr_stride(%2 : !cir.ptr, %3 : i32), !cir.ptr ``` }]; @@ -293,7 +293,7 @@ def PtrStrideOp : CIR_Op<"ptr_stride", //===----------------------------------------------------------------------===// def ConstantOp : CIR_Op<"const", - [ConstantLike, Pure]> { + [ConstantLike, Pure, AllTypesMatch<["value", "res"]>]> { // FIXME: Use SameOperandsAndResultType or similar and prevent eye bleeding // type repetition in the assembly form. @@ -303,9 +303,9 @@ def ConstantOp : CIR_Op<"const", attached to the operation as an attribute. ```mlir - %0 = cir.const(42 : i32) : i32 - %1 = cir.const(4.2 : f32) : f32 - %2 = cir.const(nullptr : !cir.ptr) : !cir.ptr + %0 = cir.const 42 : i32 + %1 = cir.const 4.2 : f32 + %2 = cir.const nullptr : !cir.ptr ``` }]; @@ -315,9 +315,7 @@ def ConstantOp : CIR_Op<"const", // The constant operation returns a single value of CIR_AnyType. let results = (outs CIR_AnyType:$res); - let assemblyFormat = [{ - `(` custom($value) `)` attr-dict `:` type($res) - }]; + let assemblyFormat = "attr-dict $value"; let hasVerifier = 1; @@ -1111,13 +1109,13 @@ def BitClrsbOp : CIR_BitOp<"bit.clrsb", AnyTypeOf<[SInt32, SInt64]>> { !s32i = !cir.int // %0 = 0xDEADBEEF, 0b1101_1110_1010_1101_1011_1110_1110_1111 - %0 = cir.const(#cir.int<3735928559> : !s32i) : !s32i + %0 = cir.const #cir.int<3735928559> : !s32i // %1 will be 1 because there is 1 bit following the most significant bit // that is identical to it. %1 = cir.bit.clrsb(%0 : !s32i) : !s32i // %2 = 1, 0b0000_0000_0000_0000_0000_0000_0000_0001 - %2 = cir.const(#cir.int<1> : !s32i) : !s32i + %2 = cir.const #cir.int<1> : !s32i // %3 will be 30 %3 = cir.bit.clrsb(%2 : !s32i) : !s32i ``` @@ -1142,7 +1140,7 @@ def BitClzOp : CIR_BitOp<"bit.clz", AnyTypeOf<[UInt16, UInt32, UInt64]>> { !u32i = !cir.int // %0 = 0b0000_0000_0000_0000_0000_0000_0000_1000 - %0 = cir.const(#cir.int<8> : !u32i) : !u32i + %0 = cir.const #cir.int<8> : !u32i // %1 will be 28 %1 = cir.bit.clz(%0 : !u32i) : !s32i ``` @@ -1167,7 +1165,7 @@ def BitCtzOp : CIR_BitOp<"bit.ctz", AnyTypeOf<[UInt16, UInt32, UInt64]>> { !u32i = !cir.int // %0 = 0b1000 - %0 = cir.const(#cir.int<8> : !u32i) : !u32i + %0 = cir.const #cir.int<8> : !u32i // %1 will be 3 %1 = cir.bit.ctz(%0 : !u32i) : !s32i ``` @@ -1190,7 +1188,7 @@ def BitFfsOp : CIR_BitOp<"bit.ffs", AnyTypeOf<[SInt32, SInt64]>> { !s32i = !cir.int // %0 = 0x0010_1000 - %0 = cir.const(#cir.int<40> : !s32i) : !s32i + %0 = cir.const #cir.int<40> : !s32i // #1 will be 4 since the 4th least significant bit is 1. %1 = cir.bit.ffs(%0 : !s32i) : !s32i ``` @@ -1212,9 +1210,9 @@ def BitParityOp : CIR_BitOp<"bit.parity", AnyTypeOf<[UInt32, UInt64]>> { !u32i = !cir.int // %0 = 0x0110_1000 - %0 = cir.const(#cir.int<104> : !u32i) : !s32i + %0 = cir.const #cir.int<104> : !u32i // %1 will be 1 since there are 3 1-bits in %0 - %1 = cir.bit.parity(%0 : !u32i) : !s32i + %1 = cir.bit.parity(%0 : !u32i) : !u32i ``` }]; } @@ -1230,13 +1228,12 @@ def BitPopcountOp Example: ```mlir - !s32i = !cir.int !u32i = !cir.int // %0 = 0x0110_1000 - %0 = cir.const(#cir.int<104> : !u32i) : !s32i + %0 = cir.const #cir.int<104> : !u32i // %1 will be 3 since there are 3 1-bits in %0 - %1 = cir.bit.popcount(%0 : !u32i) : !s32i + %1 = cir.bit.popcount(%0 : !u32i) : !u32i ``` }]; } @@ -1260,7 +1257,7 @@ def ByteswapOp : CIR_Op<"bswap", [Pure, SameOperandsAndResultType]> { !u32i = !cir.int // %0 = 0x12345678 - %0 = cir.const(#cir.int<305419896> : !u32i) : !u32i + %0 = cir.const #cir.int<305419896> : !u32i // %1 should be 0x78563412 %1 = cir.bswap(%0 : !u32i) : !u32i @@ -1302,12 +1299,12 @@ def CmpThreeWayOp : CIR_Op<"cmp3way", [Pure, SameTypeOperands]> { #cmp3way_strong = #cmp3way_info #cmp3way_partial = #cmp3way_info - %0 = cir.const(#cir.int<0> : !s32i) : !s32i - %1 = cir.const(#cir.int<1> : !s32i) : !s32i + %0 = cir.const #cir.int<0> : !s32i + %1 = cir.const #cir.int<1> : !s32i %2 = cir.cmp3way(%0 : !s32i, %1, #cmp3way_strong) : !s8i - %3 = cir.const(#cir.fp<0.0> : !cir.float) : !cir.float - %4 = cir.const(#cir.fp<1.0> : !cir.float) : !cir.float + %3 = cir.const #cir.fp<0.0> : !cir.float + %4 = cir.const #cir.fp<1.0> : !cir.float %5 = cir.cmp3way(%3 : !cir.float, %4, #cmp3way_partial) : !s8i ``` }]; @@ -1961,7 +1958,7 @@ def SetBitfieldOp : CIR_Op<"set_bitfield"> { !struct_type = !cir.struct, !cir.int, !cir.int} #cir.record.decl.ast> #bfi_d = #cir.bitfield_info - %1 = cir.const(#cir.int<3> : !s32i) : !s32i + %1 = cir.const #cir.int<3> : !s32i %2 = cir.load %0 : !cir.ptr>, !cir.ptr %3 = cir.get_member %2[1] {name = "d"} : !cir.ptr -> !cir.ptr %4 = cir.set_bitfield(#bfi_d, %3 : !cir.ptr, %1 : !s32i) -> !s32i @@ -3045,7 +3042,7 @@ def MemCpyOp : CIR_Op<"libc.memcpy"> { ```mlir // Copying 2 bytes from one array to a struct: - %2 = cir.const(#cir.int<2> : !u32i) : !u32i + %2 = cir.const #cir.int<2> : !u32i cir.libc.memcpy %2 bytes from %arr to %struct : !cir.ptr -> !cir.ptr ``` }]; diff --git a/clang/lib/CIR/CodeGen/CIRGenExprAgg.cpp b/clang/lib/CIR/CodeGen/CIRGenExprAgg.cpp index 619ef026f410..aee7280881be 100644 --- a/clang/lib/CIR/CodeGen/CIRGenExprAgg.cpp +++ b/clang/lib/CIR/CodeGen/CIRGenExprAgg.cpp @@ -464,7 +464,7 @@ void AggExprEmitter::buildArrayInit(Address DestPtr, mlir::cir::ArrayType AType, mlir::Value element = begin; // Don't build the 'one' before the cycle to avoid - // emmiting the redundant cir.const(1) instrs. + // emmiting the redundant `cir.const 1` instrs. mlir::Value one; // Emit the explicit initializers. diff --git a/clang/lib/CIR/Dialect/IR/CIRAttrs.cpp b/clang/lib/CIR/Dialect/IR/CIRAttrs.cpp index 4e568137e1da..c75d9766b9fe 100644 --- a/clang/lib/CIR/Dialect/IR/CIRAttrs.cpp +++ b/clang/lib/CIR/Dialect/IR/CIRAttrs.cpp @@ -43,6 +43,11 @@ static mlir::ParseResult parseFloatLiteral(mlir::AsmParser &parser, mlir::FailureOr &value, mlir::Type ty); +static mlir::ParseResult parseConstPtr(mlir::AsmParser &parser, + uint64_t &value); + +static void printConstPtr(mlir::AsmPrinter &p, uint64_t value); + #define GET_ATTRDEF_CLASSES #include "clang/CIR/Dialect/IR/CIROpsAttributes.cpp.inc" @@ -212,37 +217,23 @@ void LangAttr::print(AsmPrinter &printer) const { // ConstPtrAttr definitions //===----------------------------------------------------------------------===// -Attribute ConstPtrAttr::parse(AsmParser &parser, Type odsType) { - uint64_t value; - - if (!odsType.isa()) - return {}; - - // Consume the '<' symbol. - if (parser.parseLess()) - return {}; +// TODO: Consider encoding the null value differently and use conditional +// assembly format instead of custom parsing/printing. +static ParseResult parseConstPtr(AsmParser &parser, uint64_t &value) { if (parser.parseOptionalKeyword("null").succeeded()) { value = 0; - } else { - if (parser.parseInteger(value)) - parser.emitError(parser.getCurrentLocation(), "expected integer value"); + return success(); } - // Consume the '>' symbol. - if (parser.parseGreater()) - return {}; - - return ConstPtrAttr::get(odsType, value); + return parser.parseInteger(value); } -void ConstPtrAttr::print(AsmPrinter &printer) const { - printer << '<'; - if (isNullValue()) - printer << "null"; +static void printConstPtr(AsmPrinter &p, uint64_t value) { + if (!value) + p << "null"; else - printer << getValue(); - printer << '>'; + p << value; } //===----------------------------------------------------------------------===// diff --git a/clang/lib/CIR/Dialect/IR/CIRDialect.cpp b/clang/lib/CIR/Dialect/IR/CIRDialect.cpp index bafcd48a7907..f5f6668dcba2 100644 --- a/clang/lib/CIR/Dialect/IR/CIRDialect.cpp +++ b/clang/lib/CIR/Dialect/IR/CIRDialect.cpp @@ -364,23 +364,6 @@ LogicalResult ConstantOp::verify() { return checkConstantTypes(getOperation(), getType(), getValue()); } -static ParseResult parseConstantValue(OpAsmParser &parser, - mlir::Attribute &valueAttr) { - NamedAttrList attr; - return parser.parseAttribute(valueAttr, "value", attr); -} - -// FIXME: create a CIRConstAttr and hide this away for both global -// initialization and cir.const operation. -static void printConstant(OpAsmPrinter &p, Attribute value) { - p.printAttribute(value); -} - -static void printConstantValue(OpAsmPrinter &p, cir::ConstantOp op, - Attribute value) { - printConstant(p, value); -} - OpFoldResult ConstantOp::fold(FoldAdaptor /*adaptor*/) { return getValue(); } //===----------------------------------------------------------------------===// @@ -1487,6 +1470,18 @@ ::llvm::SmallVector ForOp::getLoopRegions() { return {&getBody()}; } // GlobalOp //===----------------------------------------------------------------------===// +static ParseResult parseConstantValue(OpAsmParser &parser, + mlir::Attribute &valueAttr) { + NamedAttrList attr; + return parser.parseAttribute(valueAttr, "value", attr); +} + +// FIXME: create a CIRConstAttr and hide this away for both global +// initialization and cir.const operation. +static void printConstant(OpAsmPrinter &p, Attribute value) { + p.printAttribute(value); +} + static void printGlobalOpTypeAndInitialValue(OpAsmPrinter &p, GlobalOp op, TypeAttr type, Attribute initAttr, mlir::Region &ctorRegion, diff --git a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp index 638d68a776fb..6cc7fc75001c 100644 --- a/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp +++ b/clang/lib/CIR/Lowering/DirectToLLVM/LowerToLLVM.cpp @@ -3178,10 +3178,10 @@ static void buildCtorDtorList( // cir.func @foo(%arg0: !s32i) -> !s32i { // %4 = cir.cast(int_to_bool, %arg0 : !s32i), !cir.bool // cir.if %4 { -// %5 = cir.const(#cir.int<1> : !s32i) : !s32i +// %5 = cir.const #cir.int<1> : !s32i // cir.return %5 : !s32i // } else { -// %5 = cir.const(#cir.int<0> : !s32i) : !s32i +// %5 = cir.const #cir.int<0> : !s32i // cir.return %5 : !s32i // } // cir.return %arg0 : !s32i diff --git a/clang/test/CIR/CodeGen/OpenMP/parallel.cpp b/clang/test/CIR/CodeGen/OpenMP/parallel.cpp index a3c37da349b4..d2523d7b5396 100644 --- a/clang/test/CIR/CodeGen/OpenMP/parallel.cpp +++ b/clang/test/CIR/CodeGen/OpenMP/parallel.cpp @@ -18,10 +18,10 @@ void omp_parallel_2() { // CHECK: omp.parallel { // CHECK-NEXT: cir.scope { // CHECK-NEXT: %[[XVarDecl:.+]] = {{.*}} ["x", init] -// CHECK-NEXT: %[[C1:.+]] = cir.const(#cir.int<1> : !s32i) +// CHECK-NEXT: %[[C1:.+]] = cir.const #cir.int<1> : !s32i // CHECK-NEXT: cir.store %[[C1]], %[[XVarDecl]] // CHECK-NEXT: %[[XVal:.+]] = cir.load %[[XVarDecl]] -// CHECK-NEXT: %[[COne:.+]] = cir.const(#cir.int<1> : !s32i) +// CHECK-NEXT: %[[COne:.+]] = cir.const #cir.int<1> : !s32i // CHECK-NEXT: %[[BinOpVal:.+]] = cir.binop(add, %[[XVal]], %[[COne]]) // CHECK-NEXT: cir.store %[[BinOpVal]], %[[YVarDecl]] // CHECK-NEXT: } diff --git a/clang/test/CIR/CodeGen/String.cpp b/clang/test/CIR/CodeGen/String.cpp index fd87f3f287b1..c504c1d99d0c 100644 --- a/clang/test/CIR/CodeGen/String.cpp +++ b/clang/test/CIR/CodeGen/String.cpp @@ -22,10 +22,10 @@ void test() { // CHECK-NEXT: cir.store %arg0, %0 // CHECK-NEXT: %1 = cir.load %0 // CHECK-NEXT: %2 = cir.get_member %1[0] {name = "storage"} -// CHECK-NEXT: %3 = cir.const(#cir.ptr : !cir.ptr) : !cir.ptr +// CHECK-NEXT: %3 = cir.const #cir.ptr : !cir.ptr // CHECK-NEXT: cir.store %3, %2 : !cir.ptr, !cir.ptr> // CHECK-NEXT: %4 = cir.get_member %1[1] {name = "size"} : !cir.ptr -> !cir.ptr -// CHECK-NEXT: %5 = cir.const(#cir.int<0> : !s32i) : !s32i +// CHECK-NEXT: %5 = cir.const #cir.int<0> : !s32i // CHECK-NEXT: %6 = cir.cast(integral, %5 : !s32i), !s64i // CHECK-NEXT: cir.store %6, %4 : !s64i, !cir.ptr // CHECK-NEXT: cir.return @@ -37,7 +37,7 @@ void test() { // CHECK-NEXT: cir.store %arg1, %1 // CHECK-NEXT: %2 = cir.load %0 // CHECK-NEXT: %3 = cir.get_member %2[0] {name = "storage"} -// CHECK-NEXT: %4 = cir.const(#cir.ptr : !cir.ptr) +// CHECK-NEXT: %4 = cir.const #cir.ptr : !cir.ptr // CHECK-NEXT: cir.store %4, %3 // CHECK-NEXT: %5 = cir.get_member %2[1] {name = "size"} : !cir.ptr -> !cir.ptr // CHECK-NEXT: %6 = cir.load %1 : !cir.ptr, !s32i @@ -53,7 +53,7 @@ void test() { // CHECK-NEXT: cir.store %arg1, %1 : !cir.ptr, !cir.ptr> // CHECK-NEXT: %2 = cir.load %0 : !cir.ptr>, !cir.ptr // CHECK-NEXT: %3 = cir.get_member %2[0] {name = "storage"} : !cir.ptr -> !cir.ptr> -// CHECK-NEXT: %4 = cir.const(#cir.ptr : !cir.ptr) : !cir.ptr +// CHECK-NEXT: %4 = cir.const #cir.ptr : !cir.ptr // CHECK-NEXT: cir.store %4, %3 : !cir.ptr, !cir.ptr> // CHECK-NEXT: cir.return diff --git a/clang/test/CIR/CodeGen/agg-copy.c b/clang/test/CIR/CodeGen/agg-copy.c index 91e7d52c1d12..52d292d30b1a 100644 --- a/clang/test/CIR/CodeGen/agg-copy.c +++ b/clang/test/CIR/CodeGen/agg-copy.c @@ -15,10 +15,10 @@ typedef struct { // CHECK: cir.store %arg0, [[TMP0]] : !cir.ptr, !cir.ptr> // CHECK: cir.store %arg1, [[TMP1]] : !cir.ptr, !cir.ptr> // CHECK: [[TMP2:%.*]] = cir.load [[TMP0]] : !cir.ptr>, !cir.ptr -// CHECK: [[TMP3:%.*]] = cir.const(#cir.int<1> : !s32i) : !s32i +// CHECK: [[TMP3:%.*]] = cir.const #cir.int<1> : !s32i // CHECK: [[TMP4:%.*]] = cir.ptr_stride([[TMP2]] : !cir.ptr, [[TMP3]] : !s32i), !cir.ptr // CHECK: [[TMP5:%.*]] = cir.load [[TMP1]] : !cir.ptr>, !cir.ptr -// CHECK: [[TMP6:%.*]] = cir.const(#cir.int<1> : !s32i) : !s32i +// CHECK: [[TMP6:%.*]] = cir.const #cir.int<1> : !s32i // CHECK: [[TMP7:%.*]] = cir.ptr_stride([[TMP5]] : !cir.ptr, [[TMP6]] : !s32i), !cir.ptr // CHECK: cir.copy [[TMP7]] to [[TMP4]] : !cir.ptr void foo1(A* a1, A* a2) { @@ -68,7 +68,7 @@ A create() { A a; return a; } // CHECK: [[TMP1:%.*]] = cir.alloca !ty_22A22, !cir.ptr, ["tmp"] {alignment = 4 : i64} // CHECK: [[TMP2:%.*]] = cir.call @create() : () -> !ty_22A22 // CHECK: cir.store [[TMP2]], [[TMP1]] : !ty_22A22, !cir.ptr -// CHECK: cir.copy [[TMP1]] to [[TMP0]] : !cir.ptr +// CHECK: cir.copy [[TMP1]] to [[TMP0]] : !cir.ptr void foo5() { A a; a = create(); diff --git a/clang/test/CIR/CodeGen/agg-init.cpp b/clang/test/CIR/CodeGen/agg-init.cpp index 433574a4c418..5e3a6473b132 100644 --- a/clang/test/CIR/CodeGen/agg-init.cpp +++ b/clang/test/CIR/CodeGen/agg-init.cpp @@ -19,10 +19,10 @@ void use() { yop{}; } // CHECK: cir.func @_Z3usev() // CHECK: %0 = cir.alloca !ty_22yep_22, !cir.ptr, ["agg.tmp.ensured"] {alignment = 4 : i64} // CHECK: %1 = cir.get_member %0[0] {name = "Status"} : !cir.ptr -> !cir.ptr -// CHECK: %2 = cir.const(#cir.int<0> : !u32i) : !u32i +// CHECK: %2 = cir.const #cir.int<0> : !u32i // CHECK: cir.store %2, %1 : !u32i, !cir.ptr // CHECK: %3 = cir.get_member %0[1] {name = "HC"} : !cir.ptr -> !cir.ptr -// CHECK: %4 = cir.const(#cir.int<0> : !u32i) : !u32i +// CHECK: %4 = cir.const #cir.int<0> : !u32i // CHECK: cir.store %4, %3 : !u32i, !cir.ptr // CHECK: cir.return // CHECK: } @@ -49,14 +49,14 @@ void yo() { // CHECK: cir.func @_Z2yov() // CHECK: %0 = cir.alloca !ty_22Yo22, !cir.ptr, ["ext"] {alignment = 8 : i64} // CHECK: %1 = cir.alloca !ty_22Yo22, !cir.ptr, ["ext2", init] {alignment = 8 : i64} -// CHECK: %2 = cir.const(#cir.const_struct<{#cir.int<1000070000> : !u32i, #cir.ptr : !cir.ptr, #cir.int<0> : !u64i}> : !ty_22Yo22) : !ty_22Yo22 +// CHECK: %2 = cir.const #cir.const_struct<{#cir.int<1000070000> : !u32i, #cir.ptr : !cir.ptr, #cir.int<0> : !u64i}> : !ty_22Yo22 // CHECK: cir.store %2, %0 : !ty_22Yo22, !cir.ptr // CHECK: %3 = cir.get_member %1[0] {name = "type"} : !cir.ptr -> !cir.ptr -// CHECK: %4 = cir.const(#cir.int<1000066001> : !u32i) : !u32i +// CHECK: %4 = cir.const #cir.int<1000066001> : !u32i // CHECK: cir.store %4, %3 : !u32i, !cir.ptr // CHECK: %5 = cir.get_member %1[1] {name = "next"} : !cir.ptr -> !cir.ptr> // CHECK: %6 = cir.cast(bitcast, %0 : !cir.ptr), !cir.ptr // CHECK: cir.store %6, %5 : !cir.ptr, !cir.ptr> // CHECK: %7 = cir.get_member %1[2] {name = "createFlags"} : !cir.ptr -> !cir.ptr -// CHECK: %8 = cir.const(#cir.int<0> : !u64i) : !u64i +// CHECK: %8 = cir.const #cir.int<0> : !u64i // CHECK: cir.store %8, %7 : !u64i, !cir.ptr diff --git a/clang/test/CIR/CodeGen/array-init-destroy.cpp b/clang/test/CIR/CodeGen/array-init-destroy.cpp index 975c14635e16..2959e0085314 100644 --- a/clang/test/CIR/CodeGen/array-init-destroy.cpp +++ b/clang/test/CIR/CodeGen/array-init-destroy.cpp @@ -36,14 +36,14 @@ void x() { // AFTER: cir.func @_Z1xv() // AFTER: %[[ArrayAddr0:.*]] = cir.alloca !cir.array -// AFTER: %[[ConstTwo:.*]] = cir.const(#cir.int<2> : !u64i) : !u64i +// AFTER: %[[ConstTwo:.*]] = cir.const #cir.int<2> : !u64i // AFTER: %[[ArrayBegin:.*]] = cir.cast(array_to_ptrdecay, %[[ArrayAddr0]] : !cir.ptr>), !cir.ptr // AFTER: %[[ArrayPastEnd:.*]] = cir.ptr_stride(%[[ArrayBegin]] : !cir.ptr, %[[ConstTwo]] : !u64i), !cir.ptr // AFTER: %[[TmpIdx:.*]] = cir.alloca !cir.ptr, !cir.ptr>, ["__array_idx"] {alignment = 1 : i64} // AFTER: cir.store %[[ArrayBegin]], %[[TmpIdx]] : !cir.ptr, !cir.ptr> // AFTER: cir.do { // AFTER: %[[ArrayElt:.*]] = cir.load %[[TmpIdx]] : !cir.ptr>, !cir.ptr -// AFTER: %[[ConstOne:.*]] = cir.const(#cir.int<1> : !u64i) : !u64i +// AFTER: %[[ConstOne:.*]] = cir.const #cir.int<1> : !u64i // AFTER: cir.call @_ZN4xptoC1Ev(%[[ArrayElt]]) : (!cir.ptr) -> () // AFTER: %[[NextElt:.*]] = cir.ptr_stride(%[[ArrayElt]] : !cir.ptr, %[[ConstOne]] : !u64i), !cir.ptr // AFTER: cir.store %[[NextElt]], %[[TmpIdx]] : !cir.ptr, !cir.ptr> diff --git a/clang/test/CIR/CodeGen/array-init.c b/clang/test/CIR/CodeGen/array-init.c index 854cf377e2fc..d805d4ea1f4a 100644 --- a/clang/test/CIR/CodeGen/array-init.c +++ b/clang/test/CIR/CodeGen/array-init.c @@ -12,7 +12,7 @@ void buz(int x) { // CHECK-NEXT: [[X_ALLOCA:%.*]] = cir.alloca !s32i, !cir.ptr, ["x", init] {alignment = 4 : i64} // CHECK-NEXT: [[ARR:%.*]] = cir.alloca !cir.array, !cir.ptr>, ["arr", init] {alignment = 16 : i64} // CHECK-NEXT: cir.store %arg0, [[X_ALLOCA]] : !s32i, !cir.ptr -// CHECK-NEXT: [[ARR_INIT:%.*]] = cir.const(#cir.zero : !cir.array) : !cir.array +// CHECK-NEXT: [[ARR_INIT:%.*]] = cir.const #cir.zero : !cir.array // CHECK-NEXT: cir.store [[ARR_INIT]], [[ARR]] : !cir.array, !cir.ptr> // CHECK-NEXT: [[FI_EL:%.*]] = cir.cast(array_to_ptrdecay, [[ARR]] : !cir.ptr>), !cir.ptr // CHECK-NEXT: [[A_STORAGE0:%.*]] = cir.get_member [[FI_EL]][0] {name = "a"} : !cir.ptr -> !cir.ptr @@ -20,7 +20,7 @@ void buz(int x) { // CHECK-NEXT: [[X_VAL:%.*]] = cir.load [[X_ALLOCA]] : !cir.ptr, !s32i // CHECK-NEXT: [[X_CASTED:%.*]] = cir.cast(integral, [[X_VAL]] : !s32i), !s64i // CHECK-NEXT: cir.store [[X_CASTED]], [[B_STORAGE0]] : !s64i, !cir.ptr -// CHECK-NEXT: [[ONE:%.*]] = cir.const(#cir.int<1> : !s64i) : !s64i +// CHECK-NEXT: [[ONE:%.*]] = cir.const #cir.int<1> : !s64i // CHECK-NEXT: [[SE_EL:%.*]] = cir.ptr_stride([[FI_EL]] : !cir.ptr, [[ONE]] : !s64i), !cir.ptr // CHECK-NEXT: [[A_STORAGE1:%.*]] = cir.get_member [[SE_EL]][0] {name = "a"} : !cir.ptr -> !cir.ptr // CHECK-NEXT: [[B_STORAGE1:%.*]] = cir.get_member [[SE_EL]][1] {name = "b"} : !cir.ptr -> !cir.ptr @@ -31,7 +31,7 @@ void foo() { } // CHECK: %0 = cir.alloca !cir.array, !cir.ptr>, ["bar"] {alignment = 16 : i64} -// CHECK-NEXT: %1 = cir.const(#cir.const_array<[#cir.fp<9.000000e+00> : !cir.double, #cir.fp<8.000000e+00> : !cir.double, #cir.fp<7.000000e+00> : !cir.double]> : !cir.array) : !cir.array +// CHECK-NEXT: %1 = cir.const #cir.const_array<[#cir.fp<9.000000e+00> : !cir.double, #cir.fp<8.000000e+00> : !cir.double, #cir.fp<7.000000e+00> : !cir.double]> : !cir.array // CHECK-NEXT: cir.store %1, %0 : !cir.array, !cir.ptr> void bar(int a, int b, int c) { int arr[] = {a,b,c}; @@ -45,7 +45,7 @@ void bar(int a, int b, int c) { // CHECK-NEXT: [[FI_EL:%.*]] = cir.cast(array_to_ptrdecay, [[ARR]] : !cir.ptr>), !cir.ptr // CHECK-NEXT: [[LOAD_A:%.*]] = cir.load [[A]] : !cir.ptr, !s32i // CHECK-NEXT: cir.store [[LOAD_A]], [[FI_EL]] : !s32i, !cir.ptr -// CHECK-NEXT: [[ONE:%.*]] = cir.const(#cir.int<1> : !s64i) : !s64i +// CHECK-NEXT: [[ONE:%.*]] = cir.const #cir.int<1> : !s64i // CHECK-NEXT: [[SE_EL:%.*]] = cir.ptr_stride(%4 : !cir.ptr, [[ONE]] : !s64i), !cir.ptr // CHECK-NEXT: [[LOAD_B:%.*]] = cir.load [[B]] : !cir.ptr, !s32i // CHECK-NEXT: cir.store [[LOAD_B]], [[SE_EL]] : !s32i, !cir.ptr @@ -65,16 +65,16 @@ void zero_init(int x) { // CHECK: [[BEGIN:%.*]] = cir.cast(array_to_ptrdecay, %1 : !cir.ptr>), !cir.ptr // CHECK: [[VAR:%.*]] = cir.load [[VAR_ALLOC]] : !cir.ptr, !s32i // CHECK: cir.store [[VAR]], [[BEGIN]] : !s32i, !cir.ptr -// CHECK: [[ONE:%.*]] = cir.const(#cir.int<1> : !s64i) : !s64i +// CHECK: [[ONE:%.*]] = cir.const #cir.int<1> : !s64i // CHECK: [[ZERO_INIT_START:%.*]] = cir.ptr_stride([[BEGIN]] : !cir.ptr, [[ONE]] : !s64i), !cir.ptr // CHECK: cir.store [[ZERO_INIT_START]], [[TEMP]] : !cir.ptr, !cir.ptr> -// CHECK: [[SIZE:%.*]] = cir.const(#cir.int<3> : !s64i) : !s64i +// CHECK: [[SIZE:%.*]] = cir.const #cir.int<3> : !s64i // CHECK: [[END:%.*]] = cir.ptr_stride([[BEGIN]] : !cir.ptr, [[SIZE]] : !s64i), !cir.ptr // CHECK: cir.do { // CHECK: [[CUR:%.*]] = cir.load [[TEMP]] : !cir.ptr>, !cir.ptr -// CHECK: [[FILLER:%.*]] = cir.const(#cir.int<0> : !s32i) : !s32i +// CHECK: [[FILLER:%.*]] = cir.const #cir.int<0> : !s32i // CHECK: cir.store [[FILLER]], [[CUR]] : !s32i, !cir.ptr -// CHECK: [[ONE:%.*]] = cir.const(#cir.int<1> : !s64i) : !s64i +// CHECK: [[ONE:%.*]] = cir.const #cir.int<1> : !s64i // CHECK: [[NEXT:%.*]] = cir.ptr_stride([[CUR]] : !cir.ptr, [[ONE]] : !s64i), !cir.ptr // CHECK: cir.store [[NEXT]], [[TEMP]] : !cir.ptr, !cir.ptr> // CHECK: cir.yield diff --git a/clang/test/CIR/CodeGen/array.cpp b/clang/test/CIR/CodeGen/array.cpp index 20cbc48f387e..31649406fac1 100644 --- a/clang/test/CIR/CodeGen/array.cpp +++ b/clang/test/CIR/CodeGen/array.cpp @@ -15,8 +15,8 @@ void a1() { // CHECK: cir.func @_Z2a1v() // CHECK-NEXT: %0 = cir.alloca !cir.array, !cir.ptr>, ["a"] {alignment = 16 : i64} -// CHECK-NEXT: %1 = cir.const(#cir.int<1> : !s32i) : !s32i -// CHECK-NEXT: %2 = cir.const(#cir.int<0> : !s32i) : !s32i +// CHECK-NEXT: %1 = cir.const #cir.int<1> : !s32i +// CHECK-NEXT: %2 = cir.const #cir.int<0> : !s32i // CHECK-NEXT: %3 = cir.cast(array_to_ptrdecay, %0 : !cir.ptr>), !cir.ptr // CHECK-NEXT: %4 = cir.ptr_stride(%3 : !cir.ptr, %2 : !s32i), !cir.ptr // CHECK-NEXT: cir.store %1, %4 : !s32i, !cir.ptr @@ -29,7 +29,7 @@ int *a2() { // CHECK: cir.func @_Z2a2v() -> !cir.ptr // CHECK-NEXT: %0 = cir.alloca !cir.ptr, !cir.ptr>, ["__retval"] {alignment = 8 : i64} // CHECK-NEXT: %1 = cir.alloca !cir.array, !cir.ptr>, ["a"] {alignment = 16 : i64} -// CHECK-NEXT: %2 = cir.const(#cir.int<0> : !s32i) : !s32i +// CHECK-NEXT: %2 = cir.const #cir.int<0> : !s32i // CHECK-NEXT: %3 = cir.cast(array_to_ptrdecay, %1 : !cir.ptr>), !cir.ptr // CHECK-NEXT: %4 = cir.ptr_stride(%3 : !cir.ptr, %2 : !s32i), !cir.ptr // CHECK-NEXT: cir.store %4, %0 : !cir.ptr, !cir.ptr> @@ -76,7 +76,7 @@ void testPointerDecaySubscriptAccess(int arr[]) { // CHECK: cir.func @{{.+}}testPointerDecaySubscriptAccess arr[1]; // CHECK: %[[#BASE:]] = cir.load %{{.+}} : !cir.ptr>, !cir.ptr - // CHECK: %[[#DIM1:]] = cir.const(#cir.int<1> : !s32i) : !s32i + // CHECK: %[[#DIM1:]] = cir.const #cir.int<1> : !s32i // CHECK: cir.ptr_stride(%[[#BASE]] : !cir.ptr, %[[#DIM1]] : !s32i), !cir.ptr } @@ -84,9 +84,9 @@ void testPointerDecayedArrayMultiDimSubscriptAccess(int arr[][3]) { // CHECK: cir.func @{{.+}}testPointerDecayedArrayMultiDimSubscriptAccess arr[1][2]; // CHECK: %[[#V1:]] = cir.load %{{.+}} : !cir.ptr>>, !cir.ptr> - // CHECK: %[[#V2:]] = cir.const(#cir.int<1> : !s32i) : !s32i + // CHECK: %[[#V2:]] = cir.const #cir.int<1> : !s32i // CHECK: %[[#V3:]] = cir.ptr_stride(%[[#V1]] : !cir.ptr>, %[[#V2]] : !s32i), !cir.ptr> - // CHECK: %[[#V4:]] = cir.const(#cir.int<2> : !s32i) : !s32i + // CHECK: %[[#V4:]] = cir.const #cir.int<2> : !s32i // CHECK: %[[#V5:]] = cir.cast(array_to_ptrdecay, %[[#V3]] : !cir.ptr>), !cir.ptr // CHECK: cir.ptr_stride(%[[#V5]] : !cir.ptr, %[[#V4]] : !s32i), !cir.ptr } diff --git a/clang/test/CIR/CodeGen/atomic.cpp b/clang/test/CIR/CodeGen/atomic.cpp index 2103103fa40c..f7eba6b5b5f8 100644 --- a/clang/test/CIR/CodeGen/atomic.cpp +++ b/clang/test/CIR/CodeGen/atomic.cpp @@ -23,7 +23,7 @@ int basic_binop_fetch(int *i) { // CHECK: %[[ONE_ADDR:.*]] = cir.alloca !s32i, !cir.ptr, [".atomictmp"] {alignment = 4 : i64} // CHECK: cir.store %arg0, %[[ARGI]] : !cir.ptr, !cir.ptr> // CHECK: %[[I:.*]] = cir.load %[[ARGI]] : !cir.ptr>, !cir.ptr -// CHECK: %[[ONE:.*]] = cir.const(#cir.int<1> : !s32i) : !s32i +// CHECK: %[[ONE:.*]] = cir.const #cir.int<1> : !s32i // CHECK: cir.store %[[ONE]], %[[ONE_ADDR]] : !s32i, !cir.ptr // CHECK: %[[VAL:.*]] = cir.load %[[ONE_ADDR]] : !cir.ptr, !s32i // CHECK: cir.atomic.fetch(add, %[[I]] : !cir.ptr, %[[VAL]] : !s32i, seq_cst) : !s32i diff --git a/clang/test/CIR/CodeGen/basic.c b/clang/test/CIR/CodeGen/basic.c index be9db2ab8ec5..5ef5dbf21a6e 100644 --- a/clang/test/CIR/CodeGen/basic.c +++ b/clang/test/CIR/CodeGen/basic.c @@ -25,7 +25,7 @@ int f2(void) { return 3; } // CIR: cir.func @f2() -> !s32i // CIR-NEXT: %0 = cir.alloca !s32i, !cir.ptr, ["__retval"] {alignment = 4 : i64} -// CIR-NEXT: %1 = cir.const(#cir.int<3> : !s32i) : !s32i +// CIR-NEXT: %1 = cir.const #cir.int<3> : !s32i // CIR-NEXT: cir.store %1, %0 : !s32i, !cir.ptr // CIR-NEXT: %2 = cir.load %0 : !cir.ptr, !s32i // CIR-NEXT: cir.return %2 : !s32i @@ -46,7 +46,7 @@ int f3(void) { // CIR: cir.func @f3() -> !s32i // CIR-NEXT: %0 = cir.alloca !s32i, !cir.ptr, ["__retval"] {alignment = 4 : i64} // CIR-NEXT: %1 = cir.alloca !s32i, !cir.ptr, ["i", init] {alignment = 4 : i64} -// CIR-NEXT: %2 = cir.const(#cir.int<3> : !s32i) : !s32i +// CIR-NEXT: %2 = cir.const #cir.int<3> : !s32i // CIR-NEXT: cir.store %2, %1 : !s32i, !cir.ptr // CIR-NEXT: %3 = cir.load %1 : !cir.ptr, !s32i // CIR-NEXT: cir.store %3, %0 : !s32i, !cir.ptr diff --git a/clang/test/CIR/CodeGen/basic.cpp b/clang/test/CIR/CodeGen/basic.cpp index c1b60288e981..8817f97dca10 100644 --- a/clang/test/CIR/CodeGen/basic.cpp +++ b/clang/test/CIR/CodeGen/basic.cpp @@ -8,7 +8,7 @@ int *p0() { // CHECK: cir.func @_Z2p0v() -> !cir.ptr // CHECK: %1 = cir.alloca !cir.ptr, !cir.ptr>, ["p", init] -// CHECK: %2 = cir.const(#cir.ptr : !cir.ptr) : !cir.ptr +// CHECK: %2 = cir.const #cir.ptr : !cir.ptr // CHECK: cir.store %2, %1 : !cir.ptr, !cir.ptr> int *p1() { @@ -19,7 +19,7 @@ int *p1() { // CHECK: cir.func @_Z2p1v() -> !cir.ptr // CHECK: %1 = cir.alloca !cir.ptr, !cir.ptr>, ["p"] -// CHECK: %2 = cir.const(#cir.ptr : !cir.ptr) : !cir.ptr +// CHECK: %2 = cir.const #cir.ptr : !cir.ptr // CHECK: cir.store %2, %1 : !cir.ptr, !cir.ptr> int *p2() { @@ -36,18 +36,18 @@ int *p2() { // CHECK: cir.func @_Z2p2v() -> !cir.ptr // CHECK-NEXT: %0 = cir.alloca !cir.ptr, !cir.ptr>, ["__retval"] {alignment = 8 : i64} // CHECK-NEXT: %1 = cir.alloca !cir.ptr, !cir.ptr>, ["p", init] {alignment = 8 : i64} -// CHECK-NEXT: %2 = cir.const(#cir.ptr : !cir.ptr) : !cir.ptr +// CHECK-NEXT: %2 = cir.const #cir.ptr : !cir.ptr // CHECK-NEXT: cir.store %2, %1 : !cir.ptr, !cir.ptr> // CHECK-NEXT: cir.scope { // CHECK-NEXT: %7 = cir.alloca !s32i, !cir.ptr, ["x", init] {alignment = 4 : i64} -// CHECK-NEXT: %8 = cir.const(#cir.int<0> : !s32i) : !s32i +// CHECK-NEXT: %8 = cir.const #cir.int<0> : !s32i // CHECK-NEXT: cir.store %8, %7 : !s32i, !cir.ptr // CHECK-NEXT: cir.store %7, %1 : !cir.ptr, !cir.ptr> -// CHECK-NEXT: %9 = cir.const(#cir.int<42> : !s32i) : !s32i +// CHECK-NEXT: %9 = cir.const #cir.int<42> : !s32i // CHECK-NEXT: %10 = cir.load deref %1 : !cir.ptr>, !cir.ptr // CHECK-NEXT: cir.store %9, %10 : !s32i, !cir.ptr // CHECK-NEXT: } loc(#[[locScope:loc[0-9]+]]) -// CHECK-NEXT: %3 = cir.const(#cir.int<42> : !s32i) : !s32i +// CHECK-NEXT: %3 = cir.const #cir.int<42> : !s32i // CHECK-NEXT: %4 = cir.load deref %1 : !cir.ptr>, !cir.ptr // CHECK-NEXT: cir.store %3, %4 : !s32i, !cir.ptr // CHECK-NEXT: %5 = cir.load %1 : !cir.ptr>, !cir.ptr @@ -58,8 +58,8 @@ int *p2() { void b0() { bool x = true, y = false; } // CHECK: cir.func @_Z2b0v() -// CHECK: %2 = cir.const(#true) : !cir.bool -// CHECK: %3 = cir.const(#false) : !cir.bool +// CHECK: %2 = cir.const #true +// CHECK: %3 = cir.const #false void b1(int a) { bool b = a; } @@ -82,10 +82,10 @@ void if0(int a) { // CHECK: %3 = cir.load %0 : !cir.ptr, !s32i // CHECK: %4 = cir.cast(int_to_bool, %3 : !s32i), !cir.bool // CHECK-NEXT: cir.if %4 { -// CHECK-NEXT: %5 = cir.const(#cir.int<3> : !s32i) : !s32i +// CHECK-NEXT: %5 = cir.const #cir.int<3> : !s32i // CHECK-NEXT: cir.store %5, %1 : !s32i, !cir.ptr // CHECK-NEXT: } else { -// CHECK-NEXT: %5 = cir.const(#cir.int<4> : !s32i) : !s32i +// CHECK-NEXT: %5 = cir.const #cir.int<4> : !s32i // CHECK-NEXT: cir.store %5, %1 : !s32i, !cir.ptr // CHECK-NEXT: } // CHECK: } @@ -110,12 +110,12 @@ void if1(int a, bool b, bool c) { // CHECK: %5 = cir.load %0 : !cir.ptr, !s32i // CHECK: %6 = cir.cast(int_to_bool, %5 : !s32i), !cir.bool // CHECK: cir.if %6 { -// CHECK: %7 = cir.const(#cir.int<3> : !s32i) : !s32i +// CHECK: %7 = cir.const #cir.int<3> : !s32i // CHECK: cir.store %7, %3 : !s32i, !cir.ptr // CHECK: cir.scope { // CHECK: %8 = cir.load %1 : !cir.ptr, !cir.bool // CHECK-NEXT: cir.if %8 { -// CHECK-NEXT: %9 = cir.const(#cir.int<8> : !s32i) : !s32i +// CHECK-NEXT: %9 = cir.const #cir.int<8> : !s32i // CHECK-NEXT: cir.store %9, %3 : !s32i, !cir.ptr // CHECK-NEXT: } // CHECK: } @@ -123,11 +123,11 @@ void if1(int a, bool b, bool c) { // CHECK: cir.scope { // CHECK: %8 = cir.load %2 : !cir.ptr, !cir.bool // CHECK-NEXT: cir.if %8 { -// CHECK-NEXT: %9 = cir.const(#cir.int<14> : !s32i) : !s32i +// CHECK-NEXT: %9 = cir.const #cir.int<14> : !s32i // CHECK-NEXT: cir.store %9, %3 : !s32i, !cir.ptr // CHECK-NEXT: } // CHECK: } -// CHECK: %7 = cir.const(#cir.int<4> : !s32i) : !s32i +// CHECK: %7 = cir.const #cir.int<4> : !s32i // CHECK: cir.store %7, %3 : !s32i, !cir.ptr // CHECK: } // CHECK: } @@ -157,9 +157,9 @@ void x() { // CHECK: cir.func @_Z1xv() // CHECK: %0 = cir.alloca !cir.bool, !cir.ptr, ["b0", init] {alignment = 1 : i64} // CHECK: %1 = cir.alloca !cir.bool, !cir.ptr, ["b1", init] {alignment = 1 : i64} -// CHECK: %2 = cir.const(#true) : !cir.bool +// CHECK: %2 = cir.const #true // CHECK: cir.store %2, %0 : !cir.bool, !cir.ptr -// CHECK: %3 = cir.const(#false) : !cir.bool +// CHECK: %3 = cir.const #false // CHECK: cir.store %3, %1 : !cir.bool, !cir.ptr typedef unsigned long size_type; @@ -171,10 +171,10 @@ size_type max_size() { // CHECK: cir.func @_Z8max_sizev() // CHECK: %0 = cir.alloca !u64i, !cir.ptr, ["__retval"] {alignment = 8 : i64} -// CHECK: %1 = cir.const(#cir.int<0> : !s32i) : !s32i +// CHECK: %1 = cir.const #cir.int<0> : !s32i // CHECK: %2 = cir.unary(not, %1) : !s32i, !s32i // CHECK: %3 = cir.cast(integral, %2 : !s32i), !u64i -// CHECK: %4 = cir.const(#cir.int<8> : !u64i) : !u64i +// CHECK: %4 = cir.const #cir.int<8> : !u64i // CHECK: %5 = cir.binop(div, %3, %4) : !u64i // CHECK-DAG: #[[locScope]] = loc(fused[#[[locScopeA:loc[0-9]+]], #[[locScopeB:loc[0-9]+]]]) diff --git a/clang/test/CIR/CodeGen/binassign.cpp b/clang/test/CIR/CodeGen/binassign.cpp index 79cbc8baa96c..3e09281072e2 100644 --- a/clang/test/CIR/CodeGen/binassign.cpp +++ b/clang/test/CIR/CodeGen/binassign.cpp @@ -66,7 +66,7 @@ void exec() { // CHECK: %1 = cir.call @_Z5gettyv() : () -> !u32i // CHECK: cir.store %1, %0 : !u32i, !cir.ptr // CHECK: %2 = cir.cast(integral, %1 : !u32i), !s32i -// CHECK: %3 = cir.const(#cir.int<0> : !s32i) : !s32i +// CHECK: %3 = cir.const #cir.int<0> : !s32i // CHECK: %4 = cir.cmp(lt, %2, %3) : !s32i, !cir.bool // CHECK: cir.if %4 { diff --git a/clang/test/CIR/CodeGen/binop.cpp b/clang/test/CIR/CodeGen/binop.cpp index 0564e9c8e89f..30b54beab761 100644 --- a/clang/test/CIR/CodeGen/binop.cpp +++ b/clang/test/CIR/CodeGen/binop.cpp @@ -33,26 +33,26 @@ void b1(bool a, bool b) { // CHECK: cir.ternary(%3, true // CHECK-NEXT: %7 = cir.load %1 // CHECK-NEXT: cir.ternary(%7, true -// CHECK-NEXT: cir.const(#true) +// CHECK-NEXT: cir.const #true // CHECK-NEXT: cir.yield // CHECK-NEXT: false { -// CHECK-NEXT: cir.const(#false) +// CHECK-NEXT: cir.const #false // CHECK-NEXT: cir.yield // CHECK: cir.yield // CHECK-NEXT: false { -// CHECK-NEXT: cir.const(#false) +// CHECK-NEXT: cir.const #false // CHECK-NEXT: cir.yield // CHECK: cir.ternary(%5, true -// CHECK-NEXT: cir.const(#true) +// CHECK-NEXT: cir.const #true // CHECK-NEXT: cir.yield // CHECK-NEXT: false { // CHECK-NEXT: %7 = cir.load %1 // CHECK-NEXT: cir.ternary(%7, true -// CHECK-NEXT: cir.const(#true) +// CHECK-NEXT: cir.const #true // CHECK-NEXT: cir.yield // CHECK-NEXT: false { -// CHECK-NEXT: cir.const(#false) +// CHECK-NEXT: cir.const #false // CHECK-NEXT: cir.yield void b2(bool a) { @@ -64,13 +64,13 @@ void b2(bool a) { // CHECK: %0 = cir.alloca {{.*}} ["a", init] // CHECK: %1 = cir.alloca {{.*}} ["x", init] -// CHECK: %2 = cir.const(#false) +// CHECK: %2 = cir.const #false // CHECK-NEXT: cir.store %2, %1 // CHECK-NEXT: %3 = cir.load %0 // CHECK-NEXT: cir.store %3, %1 // CHECK-NEXT: %4 = cir.load %0 // CHECK-NEXT: cir.store %4, %1 -// CHECK-NEXT: %5 = cir.const(#true) +// CHECK-NEXT: %5 = cir.const #true // CHECK-NEXT: cir.store %5, %1 void b3(int a, int b, int c, int d) { diff --git a/clang/test/CIR/CodeGen/bitfields.c b/clang/test/CIR/CodeGen/bitfields.c index 1571a65650f8..ae4403af4e7c 100644 --- a/clang/test/CIR/CodeGen/bitfields.c +++ b/clang/test/CIR/CodeGen/bitfields.c @@ -27,30 +27,30 @@ typedef struct { int d : 2; int e : 15; unsigned f; // type other than int above, not a bitfield -} S; +} S; typedef struct { int a : 3; // one bitfield with size < 8 unsigned b; -} T; +} T; typedef struct { char a; char b; char c; - + // startOffset 24 bits, new storage from here - int d: 2; + int d: 2; int e: 2; int f: 4; int g: 25; int h: 3; - int i: 4; + int i: 4; int j: 3; int k: 8; int l: 14; // need to be a part of the new storage - // because (tail - startOffset) is 65 after 'l' field + // because (tail - startOffset) is 65 after 'l' field } U; // CHECK: !ty_22D22 = !cir.struct, !cir.int}> @@ -66,9 +66,9 @@ typedef struct { // CHECK: cir.func {{.*@store_field}} // CHECK: [[TMP0:%.*]] = cir.alloca !ty_22S22, !cir.ptr -// CHECK: [[TMP1:%.*]] = cir.const(#cir.int<3> : !s32i) : !s32i +// CHECK: [[TMP1:%.*]] = cir.const #cir.int<3> : !s32i // CHECK: [[TMP2:%.*]] = cir.get_member [[TMP0]][2] {name = "e"} : !cir.ptr -> !cir.ptr -// CHECK: cir.set_bitfield(#bfi_e, [[TMP2]] : !cir.ptr, [[TMP1]] : !s32i) +// CHECK: cir.set_bitfield(#bfi_e, [[TMP2]] : !cir.ptr, [[TMP1]] : !s32i) void store_field() { S s; s.e = 3; @@ -93,7 +93,7 @@ void unOp(S* s) { } // CHECK: cir.func {{.*@binOp}} -// CHECK: [[TMP0:%.*]] = cir.const(#cir.int<42> : !s32i) : !s32i +// CHECK: [[TMP0:%.*]] = cir.const #cir.int<42> : !s32i // CHECK: [[TMP1:%.*]] = cir.get_member {{.*}}[1] {name = "d"} : !cir.ptr -> !cir.ptr> // CHECK: [[TMP2:%.*]] = cir.get_bitfield(#bfi_d, [[TMP1]] : !cir.ptr>) -> !s32i // CHECK: [[TMP3:%.*]] = cir.binop(or, [[TMP2]], [[TMP0]]) : !s32i @@ -109,7 +109,7 @@ unsigned load_non_bitfield(S *s) { return s->f; } -// just create a usage of T type +// just create a usage of T type // CHECK: cir.func {{.*@load_one_bitfield}} int load_one_bitfield(T* t) { return t->a; @@ -124,7 +124,7 @@ void createU() { // CHECK: cir.func {{.*@createD}} // CHECK: %0 = cir.alloca !ty_22D22, !cir.ptr, ["d"] {alignment = 4 : i64} // CHECK: %1 = cir.cast(bitcast, %0 : !cir.ptr), !cir.ptr -// CHECK: %2 = cir.const(#cir.const_struct<{#cir.int<33> : !u8i, #cir.int<0> : !u8i, #cir.int<3> : !s32i}> : !ty_anon_struct) : !ty_anon_struct +// CHECK: %2 = cir.const #cir.const_struct<{#cir.int<33> : !u8i, #cir.int<0> : !u8i, #cir.int<3> : !s32i}> : !ty_anon_struct // CHECK: cir.store %2, %1 : !ty_anon_struct, !cir.ptr void createD() { D d = {1,2,3}; diff --git a/clang/test/CIR/CodeGen/bitfields.cpp b/clang/test/CIR/CodeGen/bitfields.cpp index 041ac482dd9b..f87b1e8e4acd 100644 --- a/clang/test/CIR/CodeGen/bitfields.cpp +++ b/clang/test/CIR/CodeGen/bitfields.cpp @@ -34,7 +34,7 @@ typedef struct { // CHECK: cir.func @_Z11store_field // CHECK: [[TMP0:%.*]] = cir.alloca !ty_22S22, !cir.ptr -// CHECK: [[TMP1:%.*]] = cir.const(#cir.int<3> : !s32i) : !s32i +// CHECK: [[TMP1:%.*]] = cir.const #cir.int<3> : !s32i // CHECK: [[TMP2:%.*]] = cir.cast(bitcast, [[TMP0]] : !cir.ptr), !cir.ptr // CHECK: cir.set_bitfield(#bfi_a, [[TMP2]] : !cir.ptr, [[TMP1]] : !s32i) void store_field() { @@ -57,7 +57,7 @@ unsigned load_non_bitfield(S& s) { return s.f; } -// just create a usage of T type +// just create a usage of T type // CHECK: cir.func @_Z17load_one_bitfield int load_one_bitfield(T& t) { return t.a; diff --git a/clang/test/CIR/CodeGen/bitint.cpp b/clang/test/CIR/CodeGen/bitint.cpp index 32bda23e663a..09c133d0e1be 100644 --- a/clang/test/CIR/CodeGen/bitint.cpp +++ b/clang/test/CIR/CodeGen/bitint.cpp @@ -26,7 +26,7 @@ i10 test_init() { } // CHECK: cir.func @_Z9test_initv() -> !cir.int -// CHECK: %[[#LITERAL:]] = cir.const(#cir.int<42> : !s32i) : !s32i +// CHECK: %[[#LITERAL:]] = cir.const #cir.int<42> : !s32i // CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#LITERAL]] : !s32i), !cir.int // CHECK: } @@ -35,7 +35,7 @@ void test_init_for_mem() { } // CHECK: cir.func @_Z17test_init_for_memv() -// CHECK: %[[#LITERAL:]] = cir.const(#cir.int<42> : !s32i) : !s32i +// CHECK: %[[#LITERAL:]] = cir.const #cir.int<42> : !s32i // CHECK-NEXT: %[[#INIT:]] = cir.cast(integral, %[[#LITERAL]] : !s32i), !cir.int // CHECK-NEXT: cir.store %[[#INIT]], %{{.+}} : !cir.int, !cir.ptr> // CHECK: } @@ -57,7 +57,7 @@ void Size1ExtIntParam(unsigned _BitInt(1) A) { // CHECK: cir.func @_Z16Size1ExtIntParamDU1_ // CHECK: %[[#A:]] = cir.load %{{.+}} : !cir.ptr>, !cir.int -// CHECK-NEXT: %[[#IDX:]] = cir.const(#cir.int<2> : !s32i) : !s32i +// CHECK-NEXT: %[[#IDX:]] = cir.const #cir.int<2> : !s32i // CHECK-NEXT: %[[#ARRAY:]] = cir.cast(array_to_ptrdecay, %1 : !cir.ptr x 5>>), !cir.ptr> // CHECK-NEXT: %[[#PTR:]] = cir.ptr_stride(%[[#ARRAY]] : !cir.ptr>, %[[#IDX]] : !s32i), !cir.ptr> // CHECK-NEXT: cir.store %[[#A]], %[[#PTR]] : !cir.int, !cir.ptr> @@ -76,9 +76,9 @@ void OffsetOfTest(void) { } // CHECK: cir.func @_Z12OffsetOfTestv() -// CHECK: %{{.+}} = cir.const(#cir.int<0> : !u64i) : !u64i -// CHECK: %{{.+}} = cir.const(#cir.int<4> : !u64i) : !u64i -// CHECK: %{{.+}} = cir.const(#cir.int<8> : !u64i) : !u64i +// CHECK: %{{.+}} = cir.const #cir.int<0> : !u64i +// CHECK: %{{.+}} = cir.const #cir.int<4> : !u64i +// CHECK: %{{.+}} = cir.const #cir.int<8> : !u64i // CHECK: } _BitInt(2) ParamPassing(_BitInt(15) a, _BitInt(31) b) {} diff --git a/clang/test/CIR/CodeGen/bool.c b/clang/test/CIR/CodeGen/bool.c index d3f4f2748672..038de348797b 100644 --- a/clang/test/CIR/CodeGen/bool.c +++ b/clang/test/CIR/CodeGen/bool.c @@ -3,13 +3,13 @@ #include -typedef struct { +typedef struct { bool x; } S; // CHECK: cir.func @init_bool // CHECK: [[ALLOC:%.*]] = cir.alloca !ty_22S22, !cir.ptr -// CHECK: [[ZERO:%.*]] = cir.const(#cir.zero : !ty_22S22) : !ty_22S22 +// CHECK: [[ZERO:%.*]] = cir.const #cir.zero : !ty_22S22 // CHECK: cir.store [[ZERO]], [[ALLOC]] : !ty_22S22, !cir.ptr void init_bool(void) { S s = {0}; @@ -17,23 +17,23 @@ void init_bool(void) { // CHECK: cir.func @store_bool // CHECK: [[TMP0:%.*]] = cir.alloca !cir.ptr, !cir.ptr> -// CHECK: cir.store %arg0, [[TMP0]] : !cir.ptr, !cir.ptr> -// CHECK: [[TMP1:%.*]] = cir.const(#cir.int<0> : !s32i) : !s32i -// CHECK: [[TMP2:%.*]] = cir.cast(int_to_bool, [[TMP1]] : !s32i), !cir.bool -// CHECK: [[TMP3:%.*]] = cir.load [[TMP0]] : !cir.ptr>, !cir.ptr -// CHECK: [[TMP4:%.*]] = cir.get_member [[TMP3]][0] {name = "x"} : !cir.ptr -> !cir.ptr -// CHECK: cir.store [[TMP2]], [[TMP4]] : !cir.bool, !cir.ptr +// CHECK: cir.store %arg0, [[TMP0]] : !cir.ptr, !cir.ptr> +// CHECK: [[TMP1:%.*]] = cir.const #cir.int<0> : !s32i +// CHECK: [[TMP2:%.*]] = cir.cast(int_to_bool, [[TMP1]] : !s32i), !cir.bool +// CHECK: [[TMP3:%.*]] = cir.load [[TMP0]] : !cir.ptr>, !cir.ptr +// CHECK: [[TMP4:%.*]] = cir.get_member [[TMP3]][0] {name = "x"} : !cir.ptr -> !cir.ptr +// CHECK: cir.store [[TMP2]], [[TMP4]] : !cir.bool, !cir.ptr void store_bool(S *s) { s->x = false; } // CHECK: cir.func @load_bool -// CHECK: [[TMP0:%.*]] = cir.alloca !cir.ptr, !cir.ptr>, ["s", init] {alignment = 8 : i64} -// CHECK: [[TMP1:%.*]] = cir.alloca !cir.bool, !cir.ptr, ["x", init] {alignment = 1 : i64} -// CHECK: cir.store %arg0, [[TMP0]] : !cir.ptr, !cir.ptr> -// CHECK: [[TMP2:%.*]] = cir.load [[TMP0]] : !cir.ptr>, !cir.ptr -// CHECK: [[TMP3:%.*]] = cir.get_member [[TMP2]][0] {name = "x"} : !cir.ptr -> !cir.ptr -// CHECK: [[TMP4:%.*]] = cir.load [[TMP3]] : !cir.ptr, !cir.bool +// CHECK: [[TMP0:%.*]] = cir.alloca !cir.ptr, !cir.ptr>, ["s", init] {alignment = 8 : i64} +// CHECK: [[TMP1:%.*]] = cir.alloca !cir.bool, !cir.ptr, ["x", init] {alignment = 1 : i64} +// CHECK: cir.store %arg0, [[TMP0]] : !cir.ptr, !cir.ptr> +// CHECK: [[TMP2:%.*]] = cir.load [[TMP0]] : !cir.ptr>, !cir.ptr +// CHECK: [[TMP3:%.*]] = cir.get_member [[TMP2]][0] {name = "x"} : !cir.ptr -> !cir.ptr +// CHECK: [[TMP4:%.*]] = cir.load [[TMP3]] : !cir.ptr, !cir.bool void load_bool(S *s) { bool x = s->x; } \ No newline at end of file diff --git a/clang/test/CIR/CodeGen/builtin-constant-evaluated.cpp b/clang/test/CIR/CodeGen/builtin-constant-evaluated.cpp index be633108597f..d09a60085f81 100644 --- a/clang/test/CIR/CodeGen/builtin-constant-evaluated.cpp +++ b/clang/test/CIR/CodeGen/builtin-constant-evaluated.cpp @@ -4,7 +4,7 @@ auto func() { return __builtin_strcmp("", ""); // CHECK: cir.func @_Z4funcv() // CHECK-NEXT: %0 = cir.alloca !s32i, !cir.ptr, ["__retval"] {alignment = 4 : i64} loc(#loc2) - // CHECK-NEXT: %1 = cir.const(#cir.int<0> : !s32i) : !s32i loc(#loc7) + // CHECK-NEXT: %1 = cir.const #cir.int<0> : !s32i loc(#loc7) // CHECK-NEXT: cir.store %1, %0 : !s32i, !cir.ptr loc(#loc8) // CHECK-NEXT: %2 = cir.load %0 : !cir.ptr, !s32i loc(#loc8) // CHECK-NEXT: cir.return %2 : !s32i loc(#loc8) diff --git a/clang/test/CIR/CodeGen/call.c b/clang/test/CIR/CodeGen/call.c index 1ed5e8ca57d3..8129288bbd68 100644 --- a/clang/test/CIR/CodeGen/call.c +++ b/clang/test/CIR/CodeGen/call.c @@ -46,8 +46,8 @@ void d(void) { // CHECK: } // CHECK: cir.func @d() // CHECK: call @a() : () -> () -// CHECK: %0 = cir.const(#cir.int<0> : !s32i) : !s32i -// CHECK: %1 = cir.const(#cir.int<1> : !s32i) : !s32i +// CHECK: %0 = cir.const #cir.int<0> : !s32i +// CHECK: %1 = cir.const #cir.int<1> : !s32i // CHECK: call @b(%0, %1) : (!s32i, !s32i) -> !s32i // CHECK: cir.return // CHECK: } @@ -84,8 +84,8 @@ void d(void) { // CXX-NEXT: } // CXX-NEXT: cir.func @_Z1dv() // CXX-NEXT: call @_Z1av() : () -> () -// CXX-NEXT: %0 = cir.const(#cir.int<0> : !s32i) : !s32i -// CXX-NEXT: %1 = cir.const(#cir.int<1> : !s32i) : !s32i +// CXX-NEXT: %0 = cir.const #cir.int<0> : !s32i +// CXX-NEXT: %1 = cir.const #cir.int<1> : !s32i // CXX-NEXT: call @_Z1bii(%0, %1) : (!s32i, !s32i) -> !s32i // CXX-NEXT: cir.return // CXX-NEXT: } diff --git a/clang/test/CIR/CodeGen/call.cpp b/clang/test/CIR/CodeGen/call.cpp index ac2ff489db69..26db637fdb1d 100644 --- a/clang/test/CIR/CodeGen/call.cpp +++ b/clang/test/CIR/CodeGen/call.cpp @@ -10,5 +10,5 @@ int f() { // CHECK: %0 = cir.alloca !s32i, !cir.ptr, ["__retval"] {alignment = 4 : i64} // CHECK: %1 = cir.call @_Z1pv() : () -> !cir.ptr // CHECK: %2 = cir.load %1 : !cir.ptr, !s32i -// CHECK: %3 = cir.const(#cir.int<22> : !s32i) : !s32i +// CHECK: %3 = cir.const #cir.int<22> : !s32i // CHECK: %4 = cir.binop(sub, %2, %3) nsw : !s32i diff --git a/clang/test/CIR/CodeGen/cast.cpp b/clang/test/CIR/CodeGen/cast.cpp index b5e15ba784ca..15991a8f1fd3 100644 --- a/clang/test/CIR/CodeGen/cast.cpp +++ b/clang/test/CIR/CodeGen/cast.cpp @@ -111,13 +111,13 @@ void call_cptr(void *d) { // CHECK: %3 = cir.unary(not, %2) : !cir.bool, !cir.bool // CHECK: cir.if %3 { -void lvalue_cast(int x) { +void lvalue_cast(int x) { *(int *)&x = 42; -} +} // CHECK: cir.func @_Z11lvalue_cast -// CHECK: %1 = cir.const(#cir.int<42> : !s32i) : !s32i -// CHECK: cir.store %1, %0 : !s32i, !cir.ptr +// CHECK: %1 = cir.const #cir.int<42> : !s32i +// CHECK: cir.store %1, %0 : !s32i, !cir.ptr struct A { int x; }; @@ -127,9 +127,9 @@ void null_cast(long ptr) { } // CHECK: cir.func @_Z9null_castl -// CHECK: %[[ADDR:[0-9]+]] = cir.const(#cir.ptr : !cir.ptr) : !cir.ptr +// CHECK: %[[ADDR:[0-9]+]] = cir.const #cir.ptr : !cir.ptr // CHECK: cir.store %{{[0-9]+}}, %[[ADDR]] : !s32i, !cir.ptr -// CHECK: %[[BASE:[0-9]+]] = cir.const(#cir.ptr : !cir.ptr) : !cir.ptr +// CHECK: %[[BASE:[0-9]+]] = cir.const #cir.ptr : !cir.ptr // CHECK: %[[FIELD:[0-9]+]] = cir.get_member %[[BASE]][0] {name = "x"} : !cir.ptr -> !cir.ptr // CHECK: cir.store %{{[0-9]+}}, %[[FIELD]] : !s32i, !cir.ptr diff --git a/clang/test/CIR/CodeGen/compound-literal.c b/clang/test/CIR/CodeGen/compound-literal.c index e8105288880a..2bca2c059f03 100644 --- a/clang/test/CIR/CodeGen/compound-literal.c +++ b/clang/test/CIR/CodeGen/compound-literal.c @@ -39,9 +39,9 @@ int foo() { // CIR: [[RET_MEM:%.*]] = cir.alloca !s32i, !cir.ptr, ["__retval"] {alignment = 4 : i64} // CIR: [[COMPLITERAL_MEM:%.*]] = cir.alloca !ty_22anon2E122, !cir.ptr, [".compoundliteral"] {alignment = 4 : i64} // CIR: [[FIELD:%.*]] = cir.get_member [[COMPLITERAL_MEM]][0] {name = "i"} : !cir.ptr -> !cir.ptr -// CIR: [[ONE:%.*]] = cir.const(#cir.int<1> : !s32i) : !s32i +// CIR: [[ONE:%.*]] = cir.const #cir.int<1> : !s32i // CIR: cir.store [[ONE]], [[FIELD]] : !s32i, !cir.ptr -// CIR: [[ONE:%.*]] = cir.const(#cir.int<1> : !s32i) : !s32i +// CIR: [[ONE:%.*]] = cir.const #cir.int<1> : !s32i // CIR: cir.store [[ONE]], [[RET_MEM]] : !s32i, !cir.ptr // CIR: [[RET:%.*]] = cir.load [[RET_MEM]] : !cir.ptr, !s32i // CIR: cir.return [[RET]] : !s32i diff --git a/clang/test/CIR/CodeGen/const-array.c b/clang/test/CIR/CodeGen/const-array.c index 7ae6f852d7ca..91a77d113daf 100644 --- a/clang/test/CIR/CodeGen/const-array.c +++ b/clang/test/CIR/CodeGen/const-array.c @@ -14,5 +14,5 @@ void foo() { // CHECK: cir.func {{.*@foo}} // CHECK: %0 = cir.alloca !cir.array, !cir.ptr>, ["a"] {alignment = 16 : i64} -// CHECK: %1 = cir.const(#cir.const_array<[#cir.int<1> : !s32i], trailing_zeros> : !cir.array) : !cir.array +// CHECK: %1 = cir.const #cir.const_array<[#cir.int<1> : !s32i], trailing_zeros> : !cir.array // CHECK: cir.store %1, %0 : !cir.array, !cir.ptr> diff --git a/clang/test/CIR/CodeGen/coro-task.cpp b/clang/test/CIR/CodeGen/coro-task.cpp index 7282ed8764cf..ae9f1f6064e7 100644 --- a/clang/test/CIR/CodeGen/coro-task.cpp +++ b/clang/test/CIR/CodeGen/coro-task.cpp @@ -158,8 +158,8 @@ VoidTask silly_task() { // Get coroutine id with __builtin_coro_id. -// CHECK: %[[#NullPtr:]] = cir.const(#cir.ptr : !cir.ptr) : !cir.ptr -// CHECK: %[[#Align:]] = cir.const(#cir.int<16> : !u32i) : !u32i +// CHECK: %[[#NullPtr:]] = cir.const #cir.ptr : !cir.ptr +// CHECK: %[[#Align:]] = cir.const #cir.int<16> : !u32i // CHECK: %[[#CoroId:]] = cir.call @__builtin_coro_id(%[[#Align]], %[[#NullPtr]], %[[#NullPtr]], %[[#NullPtr]]) // Perform allocation calling operator 'new' depending on __builtin_coro_alloc and @@ -261,8 +261,8 @@ VoidTask silly_task() { // Call builtin coro end and return -// CHECK-NEXT: %[[#CoroEndArg0:]] = cir.const(#cir.ptr : !cir.ptr) -// CHECK-NEXT: %[[#CoroEndArg1:]] = cir.const(#false) : !cir.bool +// CHECK-NEXT: %[[#CoroEndArg0:]] = cir.const #cir.ptr : !cir.ptr +// CHECK-NEXT: %[[#CoroEndArg1:]] = cir.const #false // CHECK-NEXT: = cir.call @__builtin_coro_end(%[[#CoroEndArg0]], %[[#CoroEndArg1]]) // CHECK: %[[#Tmp1:]] = cir.load %[[#VoidTaskAddr]] @@ -315,7 +315,7 @@ folly::coro::Task go1() { // The call to go(1) has its own scope due to full-expression rules. // CHECK: cir.scope { // CHECK: %[[#OneAddr:]] = cir.alloca !s32i, !cir.ptr, ["ref.tmp1", init] {alignment = 4 : i64} -// CHECK: %[[#One:]] = cir.const(#cir.int<1> : !s32i) : !s32i +// CHECK: %[[#One:]] = cir.const #cir.int<1> : !s32i // CHECK: cir.store %[[#One]], %[[#OneAddr]] : !s32i, !cir.ptr // CHECK: %[[#IntTaskTmp:]] = cir.call @_Z2goRKi(%[[#OneAddr]]) : (!cir.ptr) -> ![[IntTask]] // CHECK: cir.store %[[#IntTaskTmp]], %[[#IntTaskAddr]] : ![[IntTask]], !cir.ptr @@ -367,7 +367,7 @@ folly::coro::Task go4() { // CHECK: cir.scope { // CHECK: %17 = cir.alloca !s32i, !cir.ptr, ["ref.tmp2", init] {alignment = 4 : i64} // CHECK: %18 = cir.load %3 : !cir.ptr)>>>, !cir.ptr)>> -// CHECK: %19 = cir.const(#cir.int<3> : !s32i) : !s32i +// CHECK: %19 = cir.const #cir.int<3> : !s32i // CHECK: cir.store %19, %17 : !s32i, !cir.ptr // Call invoker, which calls operator() indirectly. diff --git a/clang/test/CIR/CodeGen/ctor-srcloc-fix.cpp b/clang/test/CIR/CodeGen/ctor-srcloc-fix.cpp index f70d1f8428d4..2f55a395c4b1 100644 --- a/clang/test/CIR/CodeGen/ctor-srcloc-fix.cpp +++ b/clang/test/CIR/CodeGen/ctor-srcloc-fix.cpp @@ -4,5 +4,5 @@ struct e { e(int); }; e *g = new e(0); -//CHECK: {{%.*}} = cir.const(#cir.int<1> : !u64i) : !u64i loc(#loc11) +//CHECK: {{%.*}} = cir.const #cir.int<1> : !u64i loc(#loc11) //CHECK: {{%.*}} = cir.call @_Znwm(%1) : (!u64i) -> !cir.ptr loc(#loc6) diff --git a/clang/test/CIR/CodeGen/delete.cpp b/clang/test/CIR/CodeGen/delete.cpp index 0f0ddcbc2c84..b02641ff87b0 100644 --- a/clang/test/CIR/CodeGen/delete.cpp +++ b/clang/test/CIR/CodeGen/delete.cpp @@ -10,6 +10,6 @@ namespace test1 { } // CHECK: cir.func @_ZN5test11aEPNS_1AE - // CHECK: %[[CONST:.*]] = cir.const(#cir.int<4> : !u64i) : !u64i + // CHECK: %[[CONST:.*]] = cir.const #cir.int<4> : !u64i // CHECK: cir.call @_ZN5test11AdlEPvm({{.*}}, %[[CONST]]) } \ No newline at end of file diff --git a/clang/test/CIR/CodeGen/derived-to-base.cpp b/clang/test/CIR/CodeGen/derived-to-base.cpp index afb7e7252d96..ac15185d1f22 100644 --- a/clang/test/CIR/CodeGen/derived-to-base.cpp +++ b/clang/test/CIR/CodeGen/derived-to-base.cpp @@ -87,7 +87,7 @@ void C3::Layer::Initialize() { // CHECK: %2 = cir.base_class_addr(%1 : !cir.ptr) -> !cir.ptr // CHECK: %3 = cir.get_member %2[1] {name = "m_C1"} : !cir.ptr -> !cir.ptr> // CHECK: %4 = cir.load %3 : !cir.ptr>, !cir.ptr -// CHECK: %5 = cir.const(#cir.ptr : !cir.ptr) : !cir.ptr +// CHECK: %5 = cir.const #cir.ptr : !cir.ptr // CHECK: %6 = cir.cmp(eq, %4, %5) : !cir.ptr, !cir.bool enumy C3::Initialize() { @@ -166,7 +166,7 @@ struct C : public A { }; // CHECK: cir.func @_Z8test_refv() -// CHECK: cir.get_member %2[1] {name = "ref"} +// CHECK: cir.get_member %2[1] {name = "ref"} int test_ref() { int x = 42; C c(x); diff --git a/clang/test/CIR/CodeGen/dtors.cpp b/clang/test/CIR/CodeGen/dtors.cpp index dc8d9027b431..05b614ad73c4 100644 --- a/clang/test/CIR/CodeGen/dtors.cpp +++ b/clang/test/CIR/CodeGen/dtors.cpp @@ -44,7 +44,7 @@ class B : public A // CHECK: cir.func @_Z4bluev() // CHECK: %0 = cir.alloca !ty_22PSEvent22, !cir.ptr, ["p", init] {alignment = 8 : i64} -// CHECK: %1 = cir.const(#cir.int<1> : !s32i) : !s32i +// CHECK: %1 = cir.const #cir.int<1> : !s32i // CHECK: %2 = cir.get_global @".str" : !cir.ptr> // CHECK: %3 = cir.cast(array_to_ptrdecay, %2 : !cir.ptr>), !cir.ptr // CHECK: cir.call @_ZN7PSEventC1E6EFModePKc(%0, %1, %3) : (!cir.ptr, !s32i, !cir.ptr) -> () diff --git a/clang/test/CIR/CodeGen/dynamic-cast.cpp b/clang/test/CIR/CodeGen/dynamic-cast.cpp index 0c74504a7faa..536fcf844845 100644 --- a/clang/test/CIR/CodeGen/dynamic-cast.cpp +++ b/clang/test/CIR/CodeGen/dynamic-cast.cpp @@ -22,13 +22,13 @@ Derived *ptr_cast(Base *b) { // AFTER: cir.func @_Z8ptr_castP4Base // AFTER: %[[#SRC_IS_NULL:]] = cir.cast(ptr_to_bool, %{{.+}} : !cir.ptr), !cir.bool // AFTER-NEXT: %{{.+}} = cir.ternary(%[[#SRC_IS_NULL]], true { -// AFTER-NEXT: %[[#NULL:]] = cir.const(#cir.ptr : !cir.ptr) : !cir.ptr +// AFTER-NEXT: %[[#NULL:]] = cir.const #cir.ptr : !cir.ptr // AFTER-NEXT: cir.yield %[[#NULL]] : !cir.ptr // AFTER-NEXT: }, false { // AFTER-NEXT: %[[#SRC_VOID_PTR:]] = cir.cast(bitcast, %2 : !cir.ptr), !cir.ptr -// AFTER-NEXT: %[[#SRC_RTTI:]] = cir.const(#cir.global_view<@_ZTI4Base> : !cir.ptr) : !cir.ptr -// AFTER-NEXT: %[[#DEST_RTTI:]] = cir.const(#cir.global_view<@_ZTI7Derived> : !cir.ptr) : !cir.ptr -// AFTER-NEXT: %[[#OFFSET_HINT:]] = cir.const(#cir.int<0> : !s64i) : !s64i +// AFTER-NEXT: %[[#SRC_RTTI:]] = cir.const #cir.global_view<@_ZTI4Base> : !cir.ptr +// AFTER-NEXT: %[[#DEST_RTTI:]] = cir.const #cir.global_view<@_ZTI7Derived> : !cir.ptr +// AFTER-NEXT: %[[#OFFSET_HINT:]] = cir.const #cir.int<0> : !s64i // AFTER-NEXT: %[[#CASTED_PTR:]] = cir.call @__dynamic_cast(%[[#SRC_VOID_PTR]], %[[#SRC_RTTI]], %[[#DEST_RTTI]], %[[#OFFSET_HINT]]) : (!cir.ptr, !cir.ptr, !cir.ptr, !s64i) -> !cir.ptr // AFTER-NEXT: %[[#RESULT:]] = cir.cast(bitcast, %[[#CASTED_PTR]] : !cir.ptr), !cir.ptr // AFTER-NEXT: cir.yield %[[#RESULT]] : !cir.ptr @@ -45,9 +45,9 @@ Derived &ref_cast(Base &b) { // AFTER: cir.func @_Z8ref_castR4Base // AFTER: %[[#SRC_VOID_PTR:]] = cir.cast(bitcast, %{{.+}} : !cir.ptr), !cir.ptr -// AFTER-NEXT: %[[#SRC_RTTI:]] = cir.const(#cir.global_view<@_ZTI4Base> : !cir.ptr) : !cir.ptr -// AFTER-NEXT: %[[#DEST_RTTI:]] = cir.const(#cir.global_view<@_ZTI7Derived> : !cir.ptr) : !cir.ptr -// AFTER-NEXT: %[[#OFFSET_HINT:]] = cir.const(#cir.int<0> : !s64i) : !s64i +// AFTER-NEXT: %[[#SRC_RTTI:]] = cir.const #cir.global_view<@_ZTI4Base> : !cir.ptr +// AFTER-NEXT: %[[#DEST_RTTI:]] = cir.const #cir.global_view<@_ZTI7Derived> : !cir.ptr +// AFTER-NEXT: %[[#OFFSET_HINT:]] = cir.const #cir.int<0> : !s64i // AFTER-NEXT: %[[#CASTED_PTR:]] = cir.call @__dynamic_cast(%[[#SRC_VOID_PTR]], %[[#SRC_RTTI]], %[[#DEST_RTTI]], %[[#OFFSET_HINT]]) : (!cir.ptr, !cir.ptr, !cir.ptr, !s64i) -> !cir.ptr // AFTER-NEXT: %[[#CASTED_PTR_IS_NOT_NULL:]] = cir.cast(ptr_to_bool, %[[#CASTED_PTR]] : !cir.ptr), !cir.bool // AFTER-NEXT: %[[#CASTED_PTR_IS_NULL:]] = cir.unary(not, %[[#CASTED_PTR_IS_NOT_NULL]]) : !cir.bool, !cir.bool @@ -67,7 +67,7 @@ void *ptr_cast_to_complete(Base *ptr) { // BEFORE-NEXT: %[[#V20:]] = cir.cast(ptr_to_bool, %[[#V19]] : !cir.ptr), !cir.bool // BEFORE-NEXT: %[[#V21:]] = cir.unary(not, %[[#V20]]) : !cir.bool, !cir.bool // BEFORE-NEXT: %{{.+}} = cir.ternary(%[[#V21]], true { -// BEFORE-NEXT: %[[#V22:]] = cir.const(#cir.ptr : !cir.ptr) : !cir.ptr +// BEFORE-NEXT: %[[#V22:]] = cir.const #cir.ptr : !cir.ptr // BEFORE-NEXT: cir.yield %[[#V22]] : !cir.ptr // BEFORE-NEXT: }, false { // BEFORE-NEXT: %[[#V23:]] = cir.cast(bitcast, %[[#V19]] : !cir.ptr), !cir.ptr> diff --git a/clang/test/CIR/CodeGen/evaluate-expr.c b/clang/test/CIR/CodeGen/evaluate-expr.c index 805fa5c01fd7..101f423c8e14 100644 --- a/clang/test/CIR/CodeGen/evaluate-expr.c +++ b/clang/test/CIR/CodeGen/evaluate-expr.c @@ -10,7 +10,7 @@ void foo() { } // CHECK: cir.func no_proto @foo() // CHECK: cir.scope { -// CHECK: [[ZERO:%.*]] = cir.const(#cir.int<0> : !s32i) : !s32i +// CHECK: [[ZERO:%.*]] = cir.const #cir.int<0> : !s32i // CHECK: [[FALSE:%.*]] = cir.cast(int_to_bool, [[ZERO:%.*]] : !s32i), !cir.bool // CHECK: cir.if [[FALSE]] { // CHECK: cir.return @@ -26,7 +26,7 @@ void bar() { // CHECK: cir.func no_proto @bar() // CHECK: [[ALLOC:%.*]] = cir.alloca !s32i, !cir.ptr, ["a", init] {alignment = 4 : i64} // CHECK: {{%.*}} = cir.get_global @s : !cir.ptr -// CHECK: [[CONST:%.*]] = cir.const(#cir.int<0> : !s32i) : !s32i +// CHECK: [[CONST:%.*]] = cir.const #cir.int<0> : !s32i // CHECK: cir.store [[CONST]], [[ALLOC]] : !s32i, !cir.ptr // CHECK: cir.return diff --git a/clang/test/CIR/CodeGen/expressions.cpp b/clang/test/CIR/CodeGen/expressions.cpp index 283acfca2d42..fb29394fbe2d 100644 --- a/clang/test/CIR/CodeGen/expressions.cpp +++ b/clang/test/CIR/CodeGen/expressions.cpp @@ -6,6 +6,6 @@ void test(int a) { // Should generate LValue parenthesis expression. (a) = 1; - // CHECK: %[[#C:]] = cir.const(#cir.int<1> : !s32i) : !s32i + // CHECK: %[[#C:]] = cir.const #cir.int<1> : !s32i // CHECK: cir.store %[[#C]], %{{.+}} : !s32i, !cir.ptr } diff --git a/clang/test/CIR/CodeGen/fullexpr.cpp b/clang/test/CIR/CodeGen/fullexpr.cpp index 2fd42b9b6db7..a83ce7d530cc 100644 --- a/clang/test/CIR/CodeGen/fullexpr.cpp +++ b/clang/test/CIR/CodeGen/fullexpr.cpp @@ -12,7 +12,7 @@ int go1() { // CHECK: %[[#XAddr:]] = cir.alloca !s32i, !cir.ptr, ["x", init] {alignment = 4 : i64} // CHECK: %[[#RVal:]] = cir.scope { // CHECK-NEXT: %[[#TmpAddr:]] = cir.alloca !s32i, !cir.ptr, ["ref.tmp0", init] {alignment = 4 : i64} -// CHECK-NEXT: %[[#One:]] = cir.const(#cir.int<1> : !s32i) : !s32i +// CHECK-NEXT: %[[#One:]] = cir.const #cir.int<1> : !s32i // CHECK-NEXT: cir.store %[[#One]], %[[#TmpAddr]] : !s32i, !cir.ptr // CHECK-NEXT: %[[#RValTmp:]] = cir.call @_Z2goRKi(%[[#TmpAddr]]) : (!cir.ptr) -> !s32i // CHECK-NEXT: cir.yield %[[#RValTmp]] : !s32i diff --git a/clang/test/CIR/CodeGen/fun-ptr.c b/clang/test/CIR/CodeGen/fun-ptr.c index ebbd0921fe76..5ae4b9780a9c 100644 --- a/clang/test/CIR/CodeGen/fun-ptr.c +++ b/clang/test/CIR/CodeGen/fun-ptr.c @@ -14,7 +14,7 @@ struct A; typedef int (*fun_typ)(struct A*); typedef struct A { - fun_typ fun; + fun_typ fun; } A; // CIR: !ty_22A22 = !cir.struct (!cir.ptr>)>>} #cir.record.decl.ast> @@ -29,7 +29,7 @@ int extract_a(Data* d) { // CIR: [[TMP1:%.*]] = cir.alloca !s32i, !cir.ptr, ["__retval"] // CIR: [[TMP2:%.*]] = cir.alloca !cir.ptr)>>, !cir.ptr)>>>, ["f", init] // CIR: cir.store %arg0, [[TMP0]] : !cir.ptr, !cir.ptr> -// CIR: [[TMP3:%.*]] = cir.const(#cir.ptr : !cir.ptr)>>) : !cir.ptr)>> +// CIR: [[TMP3:%.*]] = cir.const #cir.ptr : !cir.ptr)>> // CIR: cir.store [[TMP3]], [[TMP2]] : !cir.ptr)>>, !cir.ptr)>>> // CIR: [[TMP4:%.*]] = cir.get_global {{@.*extract_a.*}} : !cir.ptr)>> // CIR: cir.store [[TMP4]], [[TMP2]] : !cir.ptr)>>, !cir.ptr)>>> diff --git a/clang/test/CIR/CodeGen/globals.cpp b/clang/test/CIR/CodeGen/globals.cpp index da9f9397164f..cd2c235db672 100644 --- a/clang/test/CIR/CodeGen/globals.cpp +++ b/clang/test/CIR/CodeGen/globals.cpp @@ -67,7 +67,7 @@ int use_func() { return func(); } // CHECK-NEXT: %0 = cir.alloca !u8i, !cir.ptr, ["c", init] {alignment = 1 : i64} // CHECK-NEXT: %1 = cir.get_global @s2 : !cir.ptr> // CHECK-NEXT: %2 = cir.load %1 : !cir.ptr>, !cir.ptr -// CHECK-NEXT: %3 = cir.const(#cir.int<0> : !s32i) : !s32i +// CHECK-NEXT: %3 = cir.const #cir.int<0> : !s32i // CHECK-NEXT: %4 = cir.ptr_stride(%2 : !cir.ptr, %3 : !s32i), !cir.ptr // CHECK-NEXT: %5 = cir.load %4 : !cir.ptr, !s8i // CHECK-NEXT: %6 = cir.cast(integral, %5 : !s8i), !u8i @@ -76,7 +76,7 @@ int use_func() { return func(); } // CHECK: cir.func linkonce_odr @_Z4funcIiET_v() -> !s32i // CHECK-NEXT: %0 = cir.alloca !s32i, !cir.ptr, ["__retval"] {alignment = 4 : i64} -// CHECK-NEXT: %1 = cir.const(#cir.int<0> : !s32i) : !s32i +// CHECK-NEXT: %1 = cir.const #cir.int<0> : !s32i // CHECK-NEXT: cir.store %1, %0 : !s32i, !cir.ptr // CHECK-NEXT: %2 = cir.load %0 : !cir.ptr, !s32i // CHECK-NEXT: cir.return %2 : !s32i diff --git a/clang/test/CIR/CodeGen/gnu-extension.c b/clang/test/CIR/CodeGen/gnu-extension.c index 0eb7e750ddff..7386de78176f 100644 --- a/clang/test/CIR/CodeGen/gnu-extension.c +++ b/clang/test/CIR/CodeGen/gnu-extension.c @@ -5,7 +5,7 @@ int foo(void) { return __extension__ 0b101010; } //CHECK: cir.func @foo() //CHECK-NEXT: [[ADDR:%.*]] = cir.alloca !s32i, !cir.ptr, ["__retval"] {alignment = 4 : i64} -//CHECK-NEXT: [[VAL:%.*]] = cir.const(#cir.int<42> : !s32i) : !s32i +//CHECK-NEXT: [[VAL:%.*]] = cir.const #cir.int<42> : !s32i //CHECK-NEXT: cir.store [[VAL]], [[ADDR]] : !s32i, !cir.ptr //CHECK-NEXT: [[LOAD_VAL:%.*]] = cir.load [[ADDR]] : !cir.ptr, !s32i //CHECK-NEXT: cir.return [[LOAD_VAL]] : !s32i diff --git a/clang/test/CIR/CodeGen/goto.cpp b/clang/test/CIR/CodeGen/goto.cpp index fd21360e399d..204b00303fca 100644 --- a/clang/test/CIR/CodeGen/goto.cpp +++ b/clang/test/CIR/CodeGen/goto.cpp @@ -18,13 +18,13 @@ void g0(int a) { // CHECK-NEXT cir.br ^bb2 // CHECK-NEXT ^bb1: // no predecessors // CHECK-NEXT %3 = cir.load %1 : !cir.ptr, !s32i -// CHECK-NEXT %4 = cir.const(1 : !s32i) : !s32i +// CHECK-NEXT %4 = cir.const 1 : !s32i // CHECK-NEXT %5 = cir.binop(add, %3, %4) : !s32i // CHECK-NEXT cir.store %5, %1 : !s32i, !cir.ptr // CHECK-NEXT cir.br ^bb2 // CHECK-NEXT ^bb2: // 2 preds: ^bb0, ^bb1 // CHECK-NEXT %6 = cir.load %1 : !cir.ptr, !s32i -// CHECK-NEXT %7 = cir.const(2 : !s32i) : !s32i +// CHECK-NEXT %7 = cir.const 2 : !s32i // CHECK-NEXT %8 = cir.binop(add, %6, %7) : !s32i // CHECK-NEXT cir.store %8, %1 : !s32i, !cir.ptr // CHECK-NEXT cir.return diff --git a/clang/test/CIR/CodeGen/hello.c b/clang/test/CIR/CodeGen/hello.c index 07ba213419fd..8aa29c05a211 100644 --- a/clang/test/CIR/CodeGen/hello.c +++ b/clang/test/CIR/CodeGen/hello.c @@ -15,7 +15,7 @@ int main (void) { // CHECK: %2 = cir.get_global @".str" : !cir.ptr> // CHECK: %3 = cir.cast(array_to_ptrdecay, %2 : !cir.ptr>), !cir.ptr // CHECK: %4 = cir.call @printf(%3) : (!cir.ptr) -> !s32i -// CHECK: %5 = cir.const(#cir.int<0> : !s32i) : !s32i +// CHECK: %5 = cir.const #cir.int<0> : !s32i // CHECK: cir.store %5, %0 : !s32i, !cir.ptr // CHECK: %6 = cir.load %0 : !cir.ptr, !s32i // CHECK: cir.return %6 : !s32i diff --git a/clang/test/CIR/CodeGen/if-constexpr.cpp b/clang/test/CIR/CodeGen/if-constexpr.cpp index 18b09de54758..1e487389cc62 100644 --- a/clang/test/CIR/CodeGen/if-constexpr.cpp +++ b/clang/test/CIR/CodeGen/if-constexpr.cpp @@ -43,18 +43,18 @@ void if0() { // CHECK: cir.store %1, %0 : !s32i, !cir.ptr loc({{.*}}) // CHECK-NEXT: cir.scope { // CHECK-NEXT: %2 = cir.alloca !s32i, !cir.ptr, ["x", init] {{.*}} -// CHECK-NEXT: %3 = cir.const(#cir.int<2> : !s32i) : !s32i loc({{.*}}) +// CHECK-NEXT: %3 = cir.const #cir.int<2> : !s32i loc({{.*}}) // CHECK-NEXT: cir.store %3, %2 : !s32i, !cir.ptr loc({{.*}}) // CHECK-NEXT: } loc({{.*}}) // CHECK-NEXT: cir.scope { // CHECK-NEXT: %2 = cir.alloca !s32i, !cir.ptr, ["x", init] {{.*}} -// CHECK-NEXT: %3 = cir.const(#cir.int<5> : !s32i) : !s32i loc({{.*}}) +// CHECK-NEXT: %3 = cir.const #cir.int<5> : !s32i loc({{.*}}) // CHECK-NEXT: cir.store %3, %2 : !s32i, !cir.ptr loc({{.*}}) // CHECK-NEXT: } loc({{.*}}) // CHECK-NEXT: cir.scope { // CHECK-NEXT: %2 = cir.alloca !s32i, !cir.ptr, ["x", init] {{.*}} // CHECK-NEXT: %3 = cir.alloca !s32i, !cir.ptr, ["y", init] {{.*}} -// CHECK-NEXT: %4 = cir.const(#cir.int<7> : !s32i) : !s32i loc({{.*}}) +// CHECK-NEXT: %4 = cir.const #cir.int<7> : !s32i loc({{.*}}) // CHECK-NEXT: cir.store %4, %2 : !s32i, !cir.ptr loc({{.*}}) // CHECK-NEXT: %5 = cir.load %2 : !cir.ptr, !s32i loc({{.*}}) // CHECK-NEXT: cir.store %5, %3 : !s32i, !cir.ptr loc({{.*}}) @@ -62,16 +62,16 @@ void if0() { // CHECK-NEXT: cir.scope { // CHECK-NEXT: %2 = cir.alloca !s32i, !cir.ptr, ["x", init] {{.*}} // CHECK-NEXT: %3 = cir.alloca !s32i, !cir.ptr, ["y", init] {{.*}} -// CHECK-NEXT: %4 = cir.const(#cir.int<9> : !s32i) : !s32i loc({{.*}}) +// CHECK-NEXT: %4 = cir.const #cir.int<9> : !s32i loc({{.*}}) // CHECK-NEXT: cir.store %4, %2 : !s32i, !cir.ptr loc({{.*}}) -// CHECK-NEXT: %5 = cir.const(#cir.int<3> : !s32i) : !s32i loc({{.*}}) +// CHECK-NEXT: %5 = cir.const #cir.int<3> : !s32i loc({{.*}}) // CHECK-NEXT: %6 = cir.load %2 : !cir.ptr, !s32i loc({{.*}}) // CHECK-NEXT: %7 = cir.binop(mul, %5, %6) : !s32i loc({{.*}}) // CHECK-NEXT: cir.store %7, %3 : !s32i, !cir.ptr loc({{.*}}) // CHECK-NEXT: } loc({{.*}}) // CHECK-NEXT: cir.scope { // CHECK-NEXT: %2 = cir.alloca !s32i, !cir.ptr, ["x", init] {{.*}} -// CHECK-NEXT: %3 = cir.const(#cir.int<20> : !s32i) : !s32i loc({{.*}}) +// CHECK-NEXT: %3 = cir.const #cir.int<20> : !s32i loc({{.*}}) // CHECK-NEXT: cir.store %3, %2 : !s32i, !cir.ptr loc({{.*}}) // CHECK-NEXT: } loc({{.*}}) // CHECK-NEXT: cir.scope { @@ -80,16 +80,16 @@ void if0() { // CHECK-NEXT: cir.scope { // CHECK-NEXT: %2 = cir.alloca !s32i, !cir.ptr, ["x", init] {{.*}} // CHECK-NEXT: %3 = cir.alloca !s32i, !cir.ptr, ["y", init] {{.*}} -// CHECK-NEXT: %4 = cir.const(#cir.int<70> : !s32i) : !s32i loc({{.*}}) +// CHECK-NEXT: %4 = cir.const #cir.int<70> : !s32i loc({{.*}}) // CHECK-NEXT: cir.store %4, %2 : !s32i, !cir.ptr loc({{.*}}) -// CHECK-NEXT: %5 = cir.const(#cir.int<10> : !s32i) : !s32i loc({{.*}}) +// CHECK-NEXT: %5 = cir.const #cir.int<10> : !s32i loc({{.*}}) // CHECK-NEXT: %6 = cir.load %2 : !cir.ptr, !s32i loc({{.*}}) // CHECK-NEXT: %7 = cir.binop(mul, %5, %6) : !s32i loc({{.*}}) // CHECK-NEXT: cir.store %7, %3 : !s32i, !cir.ptr loc({{.*}}) // CHECK-NEXT: } loc({{.*}}) // CHECK-NEXT: cir.scope { // CHECK-NEXT: %2 = cir.alloca !s32i, !cir.ptr, ["x", init] {{.*}} -// CHECK-NEXT: %3 = cir.const(#cir.int<90> : !s32i) : !s32i loc({{.*}}) +// CHECK-NEXT: %3 = cir.const #cir.int<90> : !s32i loc({{.*}}) // CHECK-NEXT: cir.store %3, %2 : !s32i, !cir.ptr loc({{.*}}) // CHECK-NEXT: } loc({{.*}}) // CHECK-NEXT: cir.return loc({{.*}}) diff --git a/clang/test/CIR/CodeGen/if.cir b/clang/test/CIR/CodeGen/if.cir index b3104fd42d66..7ca069fe9399 100644 --- a/clang/test/CIR/CodeGen/if.cir +++ b/clang/test/CIR/CodeGen/if.cir @@ -6,10 +6,10 @@ module { cir.func @foo(%arg0: !s32i) -> !s32i { %4 = cir.cast(int_to_bool, %arg0 : !s32i), !cir.bool cir.if %4 { - %5 = cir.const(#cir.int<1> : !s32i) : !s32i + %5 = cir.const #cir.int<1> : !s32i cir.return %5 : !s32i } else { - %5 = cir.const(#cir.int<0> : !s32i) : !s32i + %5 = cir.const #cir.int<0> : !s32i cir.return %5 : !s32i } cir.return %arg0 : !s32i @@ -18,10 +18,10 @@ module { // CHECK-NEXT: %0 = cir.cast(int_to_bool, %arg0 : !s32i), !cir.bool // CHECK-NEXT: cir.brcond %0 ^bb2, ^bb1 // CHECK-NEXT: ^bb1: // pred: ^bb0 -// CHECK-NEXT: %1 = cir.const(#cir.int<0> : !s32i) : !s32i +// CHECK-NEXT: %1 = cir.const #cir.int<0> : !s32i // CHECK-NEXT: cir.return %1 : !s32i // CHECK-NEXT: ^bb2: // pred: ^bb0 -// CHECK-NEXT: %2 = cir.const(#cir.int<1> : !s32i) : !s32i +// CHECK-NEXT: %2 = cir.const #cir.int<1> : !s32i // CHECK-NEXT: cir.return %2 : !s32i // CHECK-NEXT: ^bb3: // no predecessors // CHECK-NEXT: cir.return %arg0 : !s32i @@ -30,7 +30,7 @@ module { cir.func @onlyIf(%arg0: !s32i) -> !s32i { %4 = cir.cast(int_to_bool, %arg0 : !s32i), !cir.bool cir.if %4 { - %5 = cir.const(#cir.int<1> : !s32i) : !s32i + %5 = cir.const #cir.int<1> : !s32i cir.return %5 : !s32i } cir.return %arg0 : !s32i @@ -39,7 +39,7 @@ module { // CHECK-NEXT: %0 = cir.cast(int_to_bool, %arg0 : !s32i), !cir.bool // CHECK-NEXT: cir.brcond %0 ^bb1, ^bb2 // CHECK-NEXT: ^bb1: // pred: ^bb0 -// CHECK-NEXT: %1 = cir.const(#cir.int<1> : !s32i) : !s32i +// CHECK-NEXT: %1 = cir.const #cir.int<1> : !s32i // CHECK-NEXT: cir.return %1 : !s32i // CHECK-NEXT: ^bb2: // pred: ^bb0 // CHECK-NEXT: cir.return %arg0 : !s32i diff --git a/clang/test/CIR/CodeGen/inc-bool.cpp b/clang/test/CIR/CodeGen/inc-bool.cpp index adeb39f73938..193d63314960 100644 --- a/clang/test/CIR/CodeGen/inc-bool.cpp +++ b/clang/test/CIR/CodeGen/inc-bool.cpp @@ -9,6 +9,6 @@ void foo(bool x) { // CHECK: [[ALLOC_X:%.*]] = cir.alloca !cir.bool, !cir.ptr, ["x", init] {alignment = 1 : i64} // CHECK: cir.store %arg0, [[ALLOC_X]] : !cir.bool, !cir.ptr // CHECK: {{.*}} = cir.load [[ALLOC_X]] : !cir.ptr, !cir.bool -// CHECK: [[TRUE:%.*]] = cir.const(#true) : !cir.bool +// CHECK: [[TRUE:%.*]] = cir.const #true // CHECK: cir.store [[TRUE]], [[ALLOC_X]] : !cir.bool, !cir.ptr // CHECK: cir.return diff --git a/clang/test/CIR/CodeGen/lalg.c b/clang/test/CIR/CodeGen/lalg.c index 5115f967d314..26b41591d7dd 100644 --- a/clang/test/CIR/CodeGen/lalg.c +++ b/clang/test/CIR/CodeGen/lalg.c @@ -10,9 +10,9 @@ double dot() { // CHECK: %1 = cir.alloca !cir.double, !cir.ptr, ["x", init] // CHECK-NEXT: %2 = cir.alloca !cir.double, !cir.ptr, ["y", init] // CHECK-NEXT: %3 = cir.alloca !cir.double, !cir.ptr, ["result", init] -// CHECK-NEXT: %4 = cir.const(#cir.fp<0.000000e+00> : !cir.double) : !cir.double +// CHECK-NEXT: %4 = cir.const #cir.fp<0.000000e+00> : !cir.double // CHECK-NEXT: cir.store %4, %1 : !cir.double, !cir.ptr -// CHECK-NEXT: %5 = cir.const(#cir.fp<0.000000e+00> : !cir.float) : !cir.float +// CHECK-NEXT: %5 = cir.const #cir.fp<0.000000e+00> : !cir.float // CHECK-NEXT: %6 = cir.cast(floating, %5 : !cir.float), !cir.double // CHECK-NEXT: cir.store %6, %2 : !cir.double, !cir.ptr // CHECK-NEXT: %7 = cir.load %1 : !cir.ptr, !cir.double diff --git a/clang/test/CIR/CodeGen/lambda.cpp b/clang/test/CIR/CodeGen/lambda.cpp index ea6d15a628e4..976b538a2129 100644 --- a/clang/test/CIR/CodeGen/lambda.cpp +++ b/clang/test/CIR/CodeGen/lambda.cpp @@ -29,7 +29,7 @@ void l0() { // CHECK: %2 = cir.get_member %1[0] {name = "i"} : !cir.ptr -> !cir.ptr> // CHECK: %3 = cir.load %2 : !cir.ptr>, !cir.ptr // CHECK: %4 = cir.load %3 : !cir.ptr, !s32i -// CHECK: %5 = cir.const(#cir.int<1> : !s32i) : !s32i +// CHECK: %5 = cir.const #cir.int<1> : !s32i // CHECK: %6 = cir.binop(add, %4, %5) : !s32i // CHECK: %7 = cir.get_member %1[0] {name = "i"} : !cir.ptr -> !cir.ptr> // CHECK: %8 = cir.load %7 : !cir.ptr>, !cir.ptr @@ -48,7 +48,7 @@ auto g() { // CHECK: cir.func @_Z1gv() -> !ty_22anon2E622 // CHECK: %0 = cir.alloca !ty_22anon2E622, !cir.ptr, ["__retval"] {alignment = 8 : i64} // CHECK: %1 = cir.alloca !s32i, !cir.ptr, ["i", init] {alignment = 4 : i64} -// CHECK: %2 = cir.const(#cir.int<12> : !s32i) : !s32i +// CHECK: %2 = cir.const #cir.int<12> : !s32i // CHECK: cir.store %2, %1 : !s32i, !cir.ptr // CHECK: %3 = cir.get_member %0[0] {name = "i"} : !cir.ptr -> !cir.ptr> // CHECK: cir.store %1, %3 : !cir.ptr, !cir.ptr> @@ -68,7 +68,7 @@ auto g2() { // CHECK: cir.func @_Z2g2v() -> !ty_22anon2E822 // CHECK-NEXT: %0 = cir.alloca !ty_22anon2E822, !cir.ptr, ["__retval", init] {alignment = 8 : i64} // CHECK-NEXT: %1 = cir.alloca !s32i, !cir.ptr, ["i", init] {alignment = 4 : i64} -// CHECK-NEXT: %2 = cir.const(#cir.int<12> : !s32i) : !s32i +// CHECK-NEXT: %2 = cir.const #cir.int<12> : !s32i // CHECK-NEXT: cir.store %2, %1 : !s32i, !cir.ptr // CHECK-NEXT: %3 = cir.get_member %0[0] {name = "i"} : !cir.ptr -> !cir.ptr> // CHECK-NEXT: cir.store %1, %3 : !cir.ptr, !cir.ptr> @@ -125,7 +125,7 @@ int g3() { // CHECK: %4 = cir.scope { // CHECK: %7 = cir.alloca !s32i, !cir.ptr, ["ref.tmp1", init] {alignment = 4 : i64} // CHECK: %8 = cir.load %1 : !cir.ptr)>>>, !cir.ptr)>> -// CHECK: %9 = cir.const(#cir.int<3> : !s32i) : !s32i +// CHECK: %9 = cir.const #cir.int<3> : !s32i // CHECK: cir.store %9, %7 : !s32i, !cir.ptr // 3. Call `__invoke()`, which effectively executes `operator()`. diff --git a/clang/test/CIR/CodeGen/literals.c b/clang/test/CIR/CodeGen/literals.c index 47665212c287..b8a33ad11559 100644 --- a/clang/test/CIR/CodeGen/literals.c +++ b/clang/test/CIR/CodeGen/literals.c @@ -2,7 +2,7 @@ int literals(void) { char a = 'a'; // char literals are int in C - // CHECK: %[[RES:[0-9]+]] = cir.const(#cir.int<97> : !s32i) : !s32i + // CHECK: %[[RES:[0-9]+]] = cir.const #cir.int<97> : !s32i // CHECK: %{{[0-9]+}} = cir.cast(integral, %[[RES]] : !s32i), !s8i return 0; diff --git a/clang/test/CIR/CodeGen/literals.cpp b/clang/test/CIR/CodeGen/literals.cpp index 537ebc8557e1..87290b888185 100644 --- a/clang/test/CIR/CodeGen/literals.cpp +++ b/clang/test/CIR/CodeGen/literals.cpp @@ -2,7 +2,7 @@ int literals() { char a = 'a'; // char literals have char type in C++ - // CHECK: %{{[0-9]+}} = cir.const(#cir.int<97> : !s8i) : !s8i + // CHECK: %{{[0-9]+}} = cir.const #cir.int<97> : !s8i return 0; } diff --git a/clang/test/CIR/CodeGen/loop-scope.cpp b/clang/test/CIR/CodeGen/loop-scope.cpp index 9f9e3058d1bf..fcc45a892e3d 100644 --- a/clang/test/CIR/CodeGen/loop-scope.cpp +++ b/clang/test/CIR/CodeGen/loop-scope.cpp @@ -13,14 +13,14 @@ void l0(void) { // CPPSCOPE-NEXT: cir.scope { // CPPSCOPE-NEXT: %0 = cir.alloca !s32i, !cir.ptr, ["i", init] {alignment = 4 : i64} // CPPSCOPE-NEXT: %1 = cir.alloca !s32i, !cir.ptr, ["j", init] {alignment = 4 : i64} -// CPPSCOPE-NEXT: %2 = cir.const(#cir.int<0> : !s32i) : !s32i +// CPPSCOPE-NEXT: %2 = cir.const #cir.int<0> : !s32i // CPPSCOPE-NEXT: cir.store %2, %0 : !s32i, !cir.ptr // CPPSCOPE-NEXT: cir.for : cond { // CSCOPE: cir.func @l0() // CSCOPE-NEXT: cir.scope { // CSCOPE-NEXT: %0 = cir.alloca !s32i, !cir.ptr, ["i", init] {alignment = 4 : i64} -// CSCOPE-NEXT: %1 = cir.const(#cir.int<0> : !s32i) : !s32i +// CSCOPE-NEXT: %1 = cir.const #cir.int<0> : !s32i // CSCOPE-NEXT: cir.store %1, %0 : !s32i, !cir.ptr // CSCOPE-NEXT: cir.for : cond { diff --git a/clang/test/CIR/CodeGen/loop.cpp b/clang/test/CIR/CodeGen/loop.cpp index 67ba64cbb6f2..4cda3fba3410 100644 --- a/clang/test/CIR/CodeGen/loop.cpp +++ b/clang/test/CIR/CodeGen/loop.cpp @@ -8,7 +8,7 @@ void l0() { // CHECK: cir.func @_Z2l0v // CHECK: cir.for : cond { -// CHECK: %[[#TRUE:]] = cir.const(#true) : !cir.bool +// CHECK: %[[#TRUE:]] = cir.const #true // CHECK: cir.condition(%[[#TRUE]]) void l1() { @@ -21,18 +21,18 @@ void l1() { // CHECK: cir.func @_Z2l1v // CHECK: cir.for : cond { // CHECK-NEXT: %4 = cir.load %2 : !cir.ptr, !s32i -// CHECK-NEXT: %5 = cir.const(#cir.int<10> : !s32i) : !s32i +// CHECK-NEXT: %5 = cir.const #cir.int<10> : !s32i // CHECK-NEXT: %6 = cir.cmp(lt, %4, %5) : !s32i, !cir.bool // CHECK-NEXT: cir.condition(%6) // CHECK-NEXT: } body { // CHECK-NEXT: %4 = cir.load %0 : !cir.ptr, !s32i -// CHECK-NEXT: %5 = cir.const(#cir.int<1> : !s32i) : !s32i +// CHECK-NEXT: %5 = cir.const #cir.int<1> : !s32i // CHECK-NEXT: %6 = cir.binop(add, %4, %5) : !s32i // CHECK-NEXT: cir.store %6, %0 : !s32i, !cir.ptr // CHECK-NEXT: cir.yield // CHECK-NEXT: } step { // CHECK-NEXT: %4 = cir.load %2 : !cir.ptr, !s32i -// CHECK-NEXT: %5 = cir.const(#cir.int<1> : !s32i) : !s32i +// CHECK-NEXT: %5 = cir.const #cir.int<1> : !s32i // CHECK-NEXT: %6 = cir.binop(add, %4, %5) : !s32i // CHECK-NEXT: cir.store %6, %2 : !s32i, !cir.ptr // CHECK-NEXT: cir.yield @@ -58,7 +58,7 @@ void l2(bool cond) { // CHECK-NEXT: cir.condition(%3) // CHECK-NEXT: } do { // CHECK-NEXT: %3 = cir.load %1 : !cir.ptr, !s32i -// CHECK-NEXT: %4 = cir.const(#cir.int<1> : !s32i) : !s32i +// CHECK-NEXT: %4 = cir.const #cir.int<1> : !s32i // CHECK-NEXT: %5 = cir.binop(add, %3, %4) : !s32i // CHECK-NEXT: cir.store %5, %1 : !s32i, !cir.ptr // CHECK-NEXT: cir.yield @@ -66,11 +66,11 @@ void l2(bool cond) { // CHECK-NEXT: } // CHECK-NEXT: cir.scope { // CHECK-NEXT: cir.while { -// CHECK-NEXT: %[[#TRUE:]] = cir.const(#true) : !cir.bool +// CHECK-NEXT: %[[#TRUE:]] = cir.const #true // CHECK-NEXT: cir.condition(%[[#TRUE]]) // CHECK-NEXT: } do { // CHECK-NEXT: %3 = cir.load %1 : !cir.ptr, !s32i -// CHECK-NEXT: %4 = cir.const(#cir.int<1> : !s32i) : !s32i +// CHECK-NEXT: %4 = cir.const #cir.int<1> : !s32i // CHECK-NEXT: %5 = cir.binop(add, %3, %4) : !s32i // CHECK-NEXT: cir.store %5, %1 : !s32i, !cir.ptr // CHECK-NEXT: cir.yield @@ -78,12 +78,12 @@ void l2(bool cond) { // CHECK-NEXT: } // CHECK-NEXT: cir.scope { // CHECK-NEXT: cir.while { -// CHECK-NEXT: %3 = cir.const(#cir.int<1> : !s32i) : !s32i +// CHECK-NEXT: %3 = cir.const #cir.int<1> : !s32i // CHECK-NEXT: %4 = cir.cast(int_to_bool, %3 : !s32i), !cir.bool // CHECK-NEXT: cir.condition(%4) // CHECK-NEXT: } do { // CHECK-NEXT: %3 = cir.load %1 : !cir.ptr, !s32i -// CHECK-NEXT: %4 = cir.const(#cir.int<1> : !s32i) : !s32i +// CHECK-NEXT: %4 = cir.const #cir.int<1> : !s32i // CHECK-NEXT: %5 = cir.binop(add, %3, %4) : !s32i // CHECK-NEXT: cir.store %5, %1 : !s32i, !cir.ptr // CHECK-NEXT: cir.yield @@ -107,7 +107,7 @@ void l3(bool cond) { // CHECK: cir.scope { // CHECK-NEXT: cir.do { // CHECK-NEXT: %3 = cir.load %1 : !cir.ptr, !s32i -// CHECK-NEXT: %4 = cir.const(#cir.int<1> : !s32i) : !s32i +// CHECK-NEXT: %4 = cir.const #cir.int<1> : !s32i // CHECK-NEXT: %5 = cir.binop(add, %3, %4) : !s32i // CHECK-NEXT: cir.store %5, %1 : !s32i, !cir.ptr // CHECK-NEXT: cir.yield @@ -119,24 +119,24 @@ void l3(bool cond) { // CHECK-NEXT: cir.scope { // CHECK-NEXT: cir.do { // CHECK-NEXT: %3 = cir.load %1 : !cir.ptr, !s32i -// CHECK-NEXT: %4 = cir.const(#cir.int<1> : !s32i) : !s32i +// CHECK-NEXT: %4 = cir.const #cir.int<1> : !s32i // CHECK-NEXT: %5 = cir.binop(add, %3, %4) : !s32i // CHECK-NEXT: cir.store %5, %1 : !s32i, !cir.ptr // CHECK-NEXT: cir.yield // CHECK-NEXT: } while { -// CHECK-NEXT: %[[#TRUE:]] = cir.const(#true) : !cir.bool +// CHECK-NEXT: %[[#TRUE:]] = cir.const #true // CHECK-NEXT: cir.condition(%[[#TRUE]]) // CHECK-NEXT: } // CHECK-NEXT: } // CHECK-NEXT: cir.scope { // CHECK-NEXT: cir.do { // CHECK-NEXT: %3 = cir.load %1 : !cir.ptr, !s32i -// CHECK-NEXT: %4 = cir.const(#cir.int<1> : !s32i) : !s32i +// CHECK-NEXT: %4 = cir.const #cir.int<1> : !s32i // CHECK-NEXT: %5 = cir.binop(add, %3, %4) : !s32i // CHECK-NEXT: cir.store %5, %1 : !s32i, !cir.ptr // CHECK-NEXT: cir.yield // CHECK-NEXT: } while { -// CHECK-NEXT: %3 = cir.const(#cir.int<1> : !s32i) : !s32i +// CHECK-NEXT: %3 = cir.const #cir.int<1> : !s32i // CHECK-NEXT: %4 = cir.cast(int_to_bool, %3 : !s32i), !cir.bool // CHECK-NEXT: cir.condition(%4) // CHECK-NEXT: } @@ -154,16 +154,16 @@ void l4() { // CHECK: cir.func @_Z2l4v // CHECK: cir.while { -// CHECK-NEXT: %[[#TRUE:]] = cir.const(#true) : !cir.bool +// CHECK-NEXT: %[[#TRUE:]] = cir.const #true // CHECK-NEXT: cir.condition(%[[#TRUE]]) // CHECK-NEXT: } do { // CHECK-NEXT: %4 = cir.load %0 : !cir.ptr, !s32i -// CHECK-NEXT: %5 = cir.const(#cir.int<1> : !s32i) : !s32i +// CHECK-NEXT: %5 = cir.const #cir.int<1> : !s32i // CHECK-NEXT: %6 = cir.binop(add, %4, %5) : !s32i // CHECK-NEXT: cir.store %6, %0 : !s32i, !cir.ptr // CHECK-NEXT: cir.scope { // CHECK-NEXT: %10 = cir.load %0 : !cir.ptr, !s32i -// CHECK-NEXT: %11 = cir.const(#cir.int<10> : !s32i) : !s32i +// CHECK-NEXT: %11 = cir.const #cir.int<10> : !s32i // CHECK-NEXT: %12 = cir.cmp(lt, %10, %11) : !s32i, !cir.bool // CHECK-NEXT: cir.if %12 { // CHECK-NEXT: cir.continue @@ -180,7 +180,7 @@ void l5() { // CHECK-NEXT: cir.do { // CHECK-NEXT: cir.yield // CHECK-NEXT: } while { -// CHECK-NEXT: %0 = cir.const(#cir.int<0> : !s32i) : !s32i +// CHECK-NEXT: %0 = cir.const #cir.int<0> : !s32i // CHECK-NEXT: %1 = cir.cast(int_to_bool, %0 : !s32i), !cir.bool // CHECK-NEXT: cir.condition(%1) // CHECK-NEXT: } @@ -197,7 +197,7 @@ void l6() { // CHECK: cir.func @_Z2l6v() // CHECK-NEXT: cir.scope { // CHECK-NEXT: cir.while { -// CHECK-NEXT: %[[#TRUE:]] = cir.const(#true) : !cir.bool +// CHECK-NEXT: %[[#TRUE:]] = cir.const #true // CHECK-NEXT: cir.condition(%[[#TRUE]]) // CHECK-NEXT: } do { // CHECK-NEXT: cir.return diff --git a/clang/test/CIR/CodeGen/new.cpp b/clang/test/CIR/CodeGen/new.cpp index cfb5d52d4daf..4f7226376ddd 100644 --- a/clang/test/CIR/CodeGen/new.cpp +++ b/clang/test/CIR/CodeGen/new.cpp @@ -18,7 +18,7 @@ void m(int a, int b) { // CHECK: cir.store %arg0, %0 : !cir.ptr, !cir.ptr> // CHECK: cir.store %arg1, %1 : !cir.ptr, !cir.ptr> // CHECK: cir.scope { -// CHECK: %4 = cir.const(#cir.int<1> : !u64i) : !u64i +// CHECK: %4 = cir.const #cir.int<1> : !u64i // CHECK: %5 = cir.call @_Znwm(%4) : (!u64i) -> !cir.ptr // CHECK: %6 = cir.cast(bitcast, %5 : !cir.ptr), !cir.ptr // CHECK: %7 = cir.load %0 : !cir.ptr>, !cir.ptr @@ -42,7 +42,7 @@ class B { // CHECK: cir.store %arg0, %0 : !cir.ptr, !cir.ptr> // CHECK: cir.store %arg1, %1 : !cir.ptr, !cir.ptr> // CHECK: %2 = cir.load %0 : !cir.ptr>, !cir.ptr -// CHECK: %3 = cir.const(#cir.int<1> : !u64i) : !u64i +// CHECK: %3 = cir.const #cir.int<1> : !u64i // CHECK: %4 = cir.load %1 : !cir.ptr>, !cir.ptr // CHECK: %5 = cir.cast(bitcast, %4 : !cir.ptr), !cir.ptr // CHECK: %6 = cir.cast(bitcast, %5 : !cir.ptr), !cir.ptr diff --git a/clang/test/CIR/CodeGen/nrvo.cpp b/clang/test/CIR/CodeGen/nrvo.cpp index f7734d075317..7006c3734ff3 100644 --- a/clang/test/CIR/CodeGen/nrvo.cpp +++ b/clang/test/CIR/CodeGen/nrvo.cpp @@ -14,7 +14,7 @@ std::vector test_nrvo() { // CHECK: cir.func @_Z9test_nrvov() -> ![[VEC]] // CHECK: %0 = cir.alloca ![[VEC]], !cir.ptr, ["__retval", init] {alignment = 8 : i64} // CHECK: %1 = cir.alloca !cir.bool, !cir.ptr, ["nrvo"] {alignment = 1 : i64} -// CHECK: %2 = cir.const(#false) : !cir.bool +// CHECK: %2 = cir.const #false // CHECK: cir.store %2, %1 : !cir.bool, !cir.ptr // CHECK: cir.call @_ZNSt6vectorIPKcEC1Ev(%0) : (!cir.ptr) -> () // CHECK: cir.scope { @@ -24,7 +24,7 @@ std::vector test_nrvo() { // CHECK: cir.store %7, %5 : !cir.ptr, !cir.ptr> // CHECK: cir.call @_ZNSt6vectorIPKcE9push_backEOS1_(%0, %5) : (!cir.ptr, !cir.ptr>) -> () // CHECK: } -// CHECK: %3 = cir.const(#true) : !cir.bool +// CHECK: %3 = cir.const #true // CHECK: cir.store %3, %1 : !cir.bool, !cir.ptr // CHECK: %4 = cir.load %0 : !cir.ptr, ![[VEC]] // CHECK: cir.return %4 : ![[VEC]] diff --git a/clang/test/CIR/CodeGen/offsetof.c b/clang/test/CIR/CodeGen/offsetof.c index 5259e14d4915..5cd0d76ff46c 100644 --- a/clang/test/CIR/CodeGen/offsetof.c +++ b/clang/test/CIR/CodeGen/offsetof.c @@ -13,7 +13,7 @@ void foo() { } // CHECK: cir.func no_proto @foo() -// CHECK: {{.*}} = cir.const(#cir.int<0> : !u64i) : !u64i -// CHECK: {{.*}} = cir.const(#cir.int<4> : !u64i) : !u64i +// CHECK: {{.*}} = cir.const #cir.int<0> : !u64i +// CHECK: {{.*}} = cir.const #cir.int<4> : !u64i // CHECK: cir.return diff --git a/clang/test/CIR/CodeGen/pointer-to-data-member.cpp b/clang/test/CIR/CodeGen/pointer-to-data-member.cpp index 7fb3ab8a784c..4bec78f52531 100644 --- a/clang/test/CIR/CodeGen/pointer-to-data-member.cpp +++ b/clang/test/CIR/CodeGen/pointer-to-data-member.cpp @@ -18,7 +18,7 @@ auto test1() -> int Point::* { return &Point::y; } // CHECK: cir.func @_Z5test1v() -> !cir.data_member -// CHECK: %{{.+}} = cir.const(#cir.data_member<1> : !cir.data_member) : !cir.data_member +// CHECK: %{{.+}} = cir.const #cir.data_member<1> : !cir.data_member // CHECK: } int test2(const Point &pt, int Point::*member) { @@ -51,12 +51,12 @@ auto test_null() -> int Point::* { return nullptr; } // CHECK: cir.func @_Z9test_nullv -// CHECK: %{{.+}} = cir.const(#cir.data_member : !cir.data_member) : !cir.data_member +// CHECK: %{{.+}} = cir.const #cir.data_member : !cir.data_member // CHECK: } auto test_null_incomplete() -> int Incomplete::* { return nullptr; } // CHECK: cir.func @_Z20test_null_incompletev -// CHECK: %{{.+}} = cir.const(#cir.data_member : !cir.data_member) : !cir.data_member +// CHECK: %{{.+}} = cir.const #cir.data_member : !cir.data_member // CHECK: } diff --git a/clang/test/CIR/CodeGen/pointers.cpp b/clang/test/CIR/CodeGen/pointers.cpp index 874e0984aad2..dfea22ebadd6 100644 --- a/clang/test/CIR/CodeGen/pointers.cpp +++ b/clang/test/CIR/CodeGen/pointers.cpp @@ -4,23 +4,23 @@ // Should generate basic pointer arithmetics. void foo(int *iptr, char *cptr, unsigned ustride) { iptr + 2; - // CHECK: %[[#STRIDE:]] = cir.const(#cir.int<2> : !s32i) : !s32i + // CHECK: %[[#STRIDE:]] = cir.const #cir.int<2> : !s32i // CHECK: cir.ptr_stride(%{{.+}} : !cir.ptr, %[[#STRIDE]] : !s32i), !cir.ptr cptr + 3; - // CHECK: %[[#STRIDE:]] = cir.const(#cir.int<3> : !s32i) : !s32i + // CHECK: %[[#STRIDE:]] = cir.const #cir.int<3> : !s32i // CHECK: cir.ptr_stride(%{{.+}} : !cir.ptr, %[[#STRIDE]] : !s32i), !cir.ptr iptr - 2; - // CHECK: %[[#STRIDE:]] = cir.const(#cir.int<2> : !s32i) : !s32i + // CHECK: %[[#STRIDE:]] = cir.const #cir.int<2> : !s32i // CHECK: %[[#NEGSTRIDE:]] = cir.unary(minus, %[[#STRIDE]]) : !s32i, !s32i // CHECK: cir.ptr_stride(%{{.+}} : !cir.ptr, %[[#NEGSTRIDE]] : !s32i), !cir.ptr cptr - 3; - // CHECK: %[[#STRIDE:]] = cir.const(#cir.int<3> : !s32i) : !s32i + // CHECK: %[[#STRIDE:]] = cir.const #cir.int<3> : !s32i // CHECK: %[[#NEGSTRIDE:]] = cir.unary(minus, %[[#STRIDE]]) : !s32i, !s32i // CHECK: cir.ptr_stride(%{{.+}} : !cir.ptr, %[[#NEGSTRIDE]] : !s32i), !cir.ptr iptr + ustride; // CHECK: %[[#STRIDE:]] = cir.load %{{.+}} : !cir.ptr, !u32i // CHECK: cir.ptr_stride(%{{.+}} : !cir.ptr, %[[#STRIDE]] : !u32i), !cir.ptr - + // Must convert unsigned stride to a signed one. iptr - ustride; // CHECK: %[[#STRIDE:]] = cir.load %{{.+}} : !cir.ptr, !u32i @@ -33,7 +33,7 @@ void testPointerSubscriptAccess(int *ptr) { // CHECK: testPointerSubscriptAccess ptr[1]; // CHECK: %[[#V1:]] = cir.load %{{.+}} : !cir.ptr>, !cir.ptr - // CHECK: %[[#V2:]] = cir.const(#cir.int<1> : !s32i) : !s32i + // CHECK: %[[#V2:]] = cir.const #cir.int<1> : !s32i // CHECK: cir.ptr_stride(%[[#V1]] : !cir.ptr, %[[#V2]] : !s32i), !cir.ptr } @@ -41,9 +41,9 @@ void testPointerMultiDimSubscriptAccess(int **ptr) { // CHECK: testPointerMultiDimSubscriptAccess ptr[1][2]; // CHECK: %[[#V1:]] = cir.load %{{.+}} : !cir.ptr>>, !cir.ptr> - // CHECK: %[[#V2:]] = cir.const(#cir.int<1> : !s32i) : !s32i + // CHECK: %[[#V2:]] = cir.const #cir.int<1> : !s32i // CHECK: %[[#V3:]] = cir.ptr_stride(%[[#V1]] : !cir.ptr>, %[[#V2]] : !s32i), !cir.ptr> // CHECK: %[[#V4:]] = cir.load %[[#V3]] : !cir.ptr>, !cir.ptr - // CHECK: %[[#V5:]] = cir.const(#cir.int<2> : !s32i) : !s32i + // CHECK: %[[#V5:]] = cir.const #cir.int<2> : !s32i // CHECK: cir.ptr_stride(%[[#V4]] : !cir.ptr, %[[#V5]] : !s32i), !cir.ptr } diff --git a/clang/test/CIR/CodeGen/predefined.cpp b/clang/test/CIR/CodeGen/predefined.cpp index 35bc4bff8e73..b5ec86d41aff 100644 --- a/clang/test/CIR/CodeGen/predefined.cpp +++ b/clang/test/CIR/CodeGen/predefined.cpp @@ -12,7 +12,7 @@ void m() { // CHECK: cir.func @_Z1mv() // CHECK: %0 = cir.get_global @".str" : !cir.ptr> // CHECK: %1 = cir.cast(array_to_ptrdecay, %0 : !cir.ptr>), !cir.ptr -// CHECK: %2 = cir.const(#cir.int<79> : !s32i) : !s32i +// CHECK: %2 = cir.const #cir.int<79> : !s32i // CHECK: %3 = cir.get_global @".str1" : !cir.ptr> // CHECK: %4 = cir.cast(array_to_ptrdecay, %3 : !cir.ptr>), !cir.ptr // CHECK: %5 = cir.get_global @".str2" : !cir.ptr> diff --git a/clang/test/CIR/CodeGen/ptrdiff.cpp b/clang/test/CIR/CodeGen/ptrdiff.cpp index 33149e2aee53..e322c9c6388a 100644 --- a/clang/test/CIR/CodeGen/ptrdiff.cpp +++ b/clang/test/CIR/CodeGen/ptrdiff.cpp @@ -18,7 +18,7 @@ long add(char *a, char *b) { // CHECK: cir.func @_Z3addPcS_(%arg0: !cir.ptr // %5 = cir.ptr_diff(%3, %4) : !cir.ptr -> !s64i -// %6 = cir.const(#cir.int<1> : !s32i) : !s32i +// %6 = cir.const #cir.int<1> : !s32i // %7 = cir.cast(integral, %6 : !s32i), !s64i // %8 = cir.binop(add, %5, %7) : !s64i diff --git a/clang/test/CIR/CodeGen/rangefor.cpp b/clang/test/CIR/CodeGen/rangefor.cpp index 7434ebc9ee43..35f8da89312c 100644 --- a/clang/test/CIR/CodeGen/rangefor.cpp +++ b/clang/test/CIR/CodeGen/rangefor.cpp @@ -52,10 +52,10 @@ void init(unsigned numImages) { // CHECK: cir.store %12, %7 : !cir.ptr, !cir.ptr> // CHECK: cir.scope { // CHECK: %13 = cir.alloca !ty_22triple22, !cir.ptr, ["ref.tmp0"] {alignment = 8 : i64} -// CHECK: %14 = cir.const(#cir.zero : !ty_22triple22) : !ty_22triple22 +// CHECK: %14 = cir.const #cir.zero : !ty_22triple22 // CHECK: cir.store %14, %13 : !ty_22triple22, !cir.ptr // CHECK: %15 = cir.get_member %13[0] {name = "type"} : !cir.ptr -> !cir.ptr -// CHECK: %16 = cir.const(#cir.int<1000024002> : !u32i) : !u32i +// CHECK: %16 = cir.const #cir.int<1000024002> : !u32i // CHECK: cir.store %16, %15 : !u32i, !cir.ptr // CHECK: %17 = cir.get_member %13[1] {name = "next"} : !cir.ptr -> !cir.ptr> // CHECK: %18 = cir.get_member %13[2] {name = "image"} : !cir.ptr -> !cir.ptr diff --git a/clang/test/CIR/CodeGen/scope.cir b/clang/test/CIR/CodeGen/scope.cir index 0c4a5df73fae..2d14784c33f8 100644 --- a/clang/test/CIR/CodeGen/scope.cir +++ b/clang/test/CIR/CodeGen/scope.cir @@ -6,7 +6,7 @@ module { cir.func @foo() { cir.scope { %0 = cir.alloca !u32i, !cir.ptr, ["a", init] {alignment = 4 : i64} - %1 = cir.const(#cir.int<4> : !u32i) : !u32i + %1 = cir.const #cir.int<4> : !u32i cir.store %1, %0 : !u32i, !cir.ptr } cir.return @@ -15,7 +15,7 @@ module { // CHECK: cir.br ^bb1 // CHECK: ^bb1: // pred: ^bb0 // CHECK: %0 = cir.alloca !u32i, !cir.ptr, ["a", init] {alignment = 4 : i64} -// CHECK: %1 = cir.const(#cir.int<4> : !u32i) : !u32i +// CHECK: %1 = cir.const #cir.int<4> : !u32i // CHECK: cir.store %1, %0 : !u32i, !cir.ptr // CHECK: cir.br ^bb2 // CHECK: ^bb2: // pred: ^bb1 @@ -35,7 +35,7 @@ module { cir.func @scope_with_return() -> !u32i { %0 = cir.alloca !u32i, !cir.ptr, ["__retval"] {alignment = 4 : i64} cir.scope { - %2 = cir.const(#cir.int<0> : !u32i) : !u32i + %2 = cir.const #cir.int<0> : !u32i cir.store %2, %0 : !u32i, !cir.ptr %3 = cir.load %0 : !cir.ptr, !u32i cir.return %3 : !u32i @@ -48,7 +48,7 @@ module { // CHECK: %0 = cir.alloca !u32i, !cir.ptr, ["__retval"] {alignment = 4 : i64} // CHECK: cir.br ^bb1 // CHECK: ^bb1: // pred: ^bb0 -// CHECK: %1 = cir.const(#cir.int<0> : !u32i) : !u32i +// CHECK: %1 = cir.const #cir.int<0> : !u32i // CHECK: cir.store %1, %0 : !u32i, !cir.ptr // CHECK: %2 = cir.load %0 : !cir.ptr, !u32i // CHECK: cir.return %2 : !u32i diff --git a/clang/test/CIR/CodeGen/sourcelocation.cpp b/clang/test/CIR/CodeGen/sourcelocation.cpp index b8122b3acb7f..cc456e6cf58b 100644 --- a/clang/test/CIR/CodeGen/sourcelocation.cpp +++ b/clang/test/CIR/CodeGen/sourcelocation.cpp @@ -32,13 +32,13 @@ int s0(int a, int b) { // CIR: cir.store %6, %3 : !s32i, !cir.ptr loc(#loc23) // CIR: cir.scope { // CIR: %9 = cir.load %3 : !cir.ptr, !s32i loc(#loc13) -// CIR: %10 = cir.const(#cir.int<0> : !s32i) : !s32i loc(#loc14) +// CIR: %10 = cir.const #cir.int<0> : !s32i loc(#loc14) // CIR: %11 = cir.cmp(gt, %9, %10) : !s32i, !cir.bool loc(#loc26) // CIR: cir.if %11 { -// CIR: %12 = cir.const(#cir.int<0> : !s32i) : !s32i loc(#loc16) +// CIR: %12 = cir.const #cir.int<0> : !s32i loc(#loc16) // CIR: cir.store %12, %3 : !s32i, !cir.ptr loc(#loc28) // CIR: } else { -// CIR: %12 = cir.const(#cir.int<1> : !s32i) : !s32i loc(#loc12) +// CIR: %12 = cir.const #cir.int<1> : !s32i loc(#loc12) // CIR: cir.store %12, %3 : !s32i, !cir.ptr loc(#loc29) // CIR: } loc(#loc27) // CIR: } loc(#loc25) diff --git a/clang/test/CIR/CodeGen/static.cpp b/clang/test/CIR/CodeGen/static.cpp index 390dd8fb456a..2d51cb1514d9 100644 --- a/clang/test/CIR/CodeGen/static.cpp +++ b/clang/test/CIR/CodeGen/static.cpp @@ -21,7 +21,7 @@ static Init __ioinit2(false); // BEFORE-NEXT: cir.func private @_ZN4InitD1Ev(!cir.ptr) // BEFORE-NEXT: cir.global "private" internal @_ZL8__ioinit = ctor : !ty_22Init22 { // BEFORE-NEXT: %0 = cir.get_global @_ZL8__ioinit : !cir.ptr -// BEFORE-NEXT: %1 = cir.const(#true) : !cir.bool +// BEFORE-NEXT: %1 = cir.const #true // BEFORE-NEXT: cir.call @_ZN4InitC1Eb(%0, %1) : (!cir.ptr, !cir.bool) -> () // BEFORE-NEXT: } dtor { // BEFORE-NEXT: %0 = cir.get_global @_ZL8__ioinit : !cir.ptr @@ -29,7 +29,7 @@ static Init __ioinit2(false); // BEFORE-NEXT: } {ast = #cir.var.decl.ast} // BEFORE: cir.global "private" internal @_ZL9__ioinit2 = ctor : !ty_22Init22 { // BEFORE-NEXT: %0 = cir.get_global @_ZL9__ioinit2 : !cir.ptr -// BEFORE-NEXT: %1 = cir.const(#false) : !cir.bool +// BEFORE-NEXT: %1 = cir.const #false // BEFORE-NEXT: cir.call @_ZN4InitC1Eb(%0, %1) : (!cir.ptr, !cir.bool) -> () // BEFORE-NEXT: } dtor { // BEFORE-NEXT: %0 = cir.get_global @_ZL9__ioinit2 : !cir.ptr @@ -46,7 +46,7 @@ static Init __ioinit2(false); // AFTER-NEXT: cir.global "private" internal @_ZL8__ioinit = #cir.zero : !ty_22Init22 {ast = #cir.var.decl.ast} // AFTER-NEXT: cir.func internal private @__cxx_global_var_init() // AFTER-NEXT: %0 = cir.get_global @_ZL8__ioinit : !cir.ptr -// AFTER-NEXT: %1 = cir.const(#true) : !cir.bool +// AFTER-NEXT: %1 = cir.const #true // AFTER-NEXT: cir.call @_ZN4InitC1Eb(%0, %1) : (!cir.ptr, !cir.bool) -> () // AFTER-NEXT: %2 = cir.get_global @_ZL8__ioinit : !cir.ptr // AFTER-NEXT: %3 = cir.get_global @_ZN4InitD1Ev : !cir.ptr)>> @@ -58,7 +58,7 @@ static Init __ioinit2(false); // AFTER: cir.global "private" internal @_ZL9__ioinit2 = #cir.zero : !ty_22Init22 {ast = #cir.var.decl.ast} // AFTER-NEXT: cir.func internal private @__cxx_global_var_init.1() // AFTER-NEXT: %0 = cir.get_global @_ZL9__ioinit2 : !cir.ptr -// AFTER-NEXT: %1 = cir.const(#false) : !cir.bool +// AFTER-NEXT: %1 = cir.const #false // AFTER-NEXT: cir.call @_ZN4InitC1Eb(%0, %1) : (!cir.ptr, !cir.bool) -> () // AFTER-NEXT: %2 = cir.get_global @_ZL9__ioinit2 : !cir.ptr // AFTER-NEXT: %3 = cir.get_global @_ZN4InitD1Ev : !cir.ptr)>> diff --git a/clang/test/CIR/CodeGen/std-array.cpp b/clang/test/CIR/CodeGen/std-array.cpp index ac4b119bdeb0..7b7fe1f86782 100644 --- a/clang/test/CIR/CodeGen/std-array.cpp +++ b/clang/test/CIR/CodeGen/std-array.cpp @@ -12,6 +12,6 @@ void t() { // CHECK: {{.*}} = cir.get_member // CHECK: {{.*}} = cir.cast(array_to_ptrdecay -// CHECK: {{.*}} = cir.const(#cir.int<9> : !u32i) : !u32i +// CHECK: {{.*}} = cir.const #cir.int<9> : !u32i // CHECK: cir.call @_ZNSt5arrayIhLj9EE3endEv \ No newline at end of file diff --git a/clang/test/CIR/CodeGen/store.c b/clang/test/CIR/CodeGen/store.c index 3e33641a2dd7..1bc215f75c3b 100644 --- a/clang/test/CIR/CodeGen/store.c +++ b/clang/test/CIR/CodeGen/store.c @@ -8,9 +8,9 @@ void foo(void) { // CHECK: cir.func @foo() // CHECK-NEXT: %0 = cir.alloca !s32i, !cir.ptr, ["a", init] {alignment = 4 : i64} -// CHECK-NEXT: %1 = cir.const(#cir.int<0> : !s32i) : !s32i +// CHECK-NEXT: %1 = cir.const #cir.int<0> : !s32i // CHECK-NEXT: cir.store %1, %0 : !s32i, !cir.ptr -// CHECK-NEXT: %2 = cir.const(#cir.int<1> : !s32i) : !s32i +// CHECK-NEXT: %2 = cir.const #cir.int<1> : !s32i // CHECK-NEXT: cir.store %2, %0 : !s32i, !cir.ptr // CHECK-NEXT: cir.return // CHECK-NEXT: } diff --git a/clang/test/CIR/CodeGen/struct.c b/clang/test/CIR/CodeGen/struct.c index 898719b1aee7..61e6fc5fd446 100644 --- a/clang/test/CIR/CodeGen/struct.c +++ b/clang/test/CIR/CodeGen/struct.c @@ -36,7 +36,7 @@ void shouldConstInitStructs(void) { // CHECK: cir.func @shouldConstInitStructs struct Foo f = {1, 2, {3, 4}}; // CHECK: %[[#V0:]] = cir.alloca !ty_22Foo22, !cir.ptr, ["f"] {alignment = 4 : i64} - // CHECK: %[[#V1:]] = cir.const(#cir.const_struct<{#cir.int<1> : !s32i, #cir.int<2> : !s8i, #cir.const_struct<{#cir.int<3> : !s32i, #cir.int<4> : !s8i}> : !ty_22Bar22}> : !ty_22Foo22) : !ty_22Foo22 + // CHECK: %[[#V1:]] = cir.const #cir.const_struct<{#cir.int<1> : !s32i, #cir.int<2> : !s8i, #cir.const_struct<{#cir.int<3> : !s32i, #cir.int<4> : !s8i}> : !ty_22Bar22}> : !ty_22Foo22 // CHECK: cir.store %[[#V1]], %[[#V0]] : !ty_22Foo22, !cir.ptr } @@ -80,13 +80,13 @@ struct Bar shouldGenerateAndAccessStructArrays(void) { return s[0]; } // CHECK-DAG: cir.func @shouldGenerateAndAccessStructArrays -// CHECK-DAG: %[[#STRIDE:]] = cir.const(#cir.int<0> : !s32i) : !s32i +// CHECK-DAG: %[[#STRIDE:]] = cir.const #cir.int<0> : !s32i // CHECK-DAG: %[[#DARR:]] = cir.cast(array_to_ptrdecay, %{{.+}} : !cir.ptr>), !cir.ptr // CHECK-DAG: %[[#ELT:]] = cir.ptr_stride(%[[#DARR]] : !cir.ptr, %[[#STRIDE]] : !s32i), !cir.ptr // CHECK-DAG: cir.copy %[[#ELT]] to %{{.+}} : !cir.ptr // CHECK-DAG: cir.func @local_decl -// CHECK-DAG: {{%.}} = cir.alloca !ty_22Local22, !cir.ptr, ["a"] +// CHECK-DAG: {{%.}} = cir.alloca !ty_22Local22, !cir.ptr, ["a"] void local_decl(void) { struct Local { int i; diff --git a/clang/test/CIR/CodeGen/struct.cpp b/clang/test/CIR/CodeGen/struct.cpp index 29f115536421..d57fd7ae49c3 100644 --- a/clang/test/CIR/CodeGen/struct.cpp +++ b/clang/test/CIR/CodeGen/struct.cpp @@ -68,9 +68,9 @@ void yoyo(incomplete *i) {} // CHECK-NEXT: %1 = cir.alloca !s32i, !cir.ptr, ["result", init] {alignment = 4 : i64} // CHECK-NEXT: %2 = cir.alloca !ty_22Foo22, !cir.ptr, ["f"] {alignment = 4 : i64} // CHECK-NEXT: cir.call @_ZN3Bar6methodEv(%0) : (!cir.ptr) -> () -// CHECK-NEXT: %3 = cir.const(#cir.int<4> : !s32i) : !s32i +// CHECK-NEXT: %3 = cir.const #cir.int<4> : !s32i // CHECK-NEXT: cir.call @_ZN3Bar7method2Ei(%0, %3) : (!cir.ptr, !s32i) -> () -// CHECK-NEXT: %4 = cir.const(#cir.int<4> : !s32i) : !s32i +// CHECK-NEXT: %4 = cir.const #cir.int<4> : !s32i // CHECK-NEXT: %5 = cir.call @_ZN3Bar7method3Ei(%0, %4) : (!cir.ptr, !s32i) -> !s32i // CHECK-NEXT: cir.store %5, %1 : !s32i, !cir.ptr // CHECK-NEXT: cir.return @@ -100,13 +100,13 @@ void m() { Adv C; } // CHECK: %1 = cir.load %0 : !cir.ptr>, !cir.ptr // CHECK: %2 = cir.get_member %1[0] {name = "x"} : !cir.ptr -> !cir.ptr // CHECK: %3 = cir.get_member %2[0] {name = "w"} : !cir.ptr -> !cir.ptr -// CHECK: %4 = cir.const(#cir.int<1000024001> : !u32i) : !u32i +// CHECK: %4 = cir.const #cir.int<1000024001> : !u32i // CHECK: cir.store %4, %3 : !u32i, !cir.ptr // CHECK: %5 = cir.get_member %2[1] {name = "n"} : !cir.ptr -> !cir.ptr> -// CHECK: %6 = cir.const(#cir.ptr : !cir.ptr) : !cir.ptr +// CHECK: %6 = cir.const #cir.ptr : !cir.ptr // CHECK: cir.store %6, %5 : !cir.ptr, !cir.ptr> // CHECK: %7 = cir.get_member %2[2] {name = "d"} : !cir.ptr -> !cir.ptr -// CHECK: %8 = cir.const(#cir.int<0> : !s32i) : !s32i +// CHECK: %8 = cir.const #cir.int<0> : !s32i // CHECK: cir.store %8, %7 : !s32i, !cir.ptr // CHECK: cir.return // CHECK: } diff --git a/clang/test/CIR/CodeGen/switch.cir b/clang/test/CIR/CodeGen/switch.cir index 39664bfa3957..1ea6dba49c98 100644 --- a/clang/test/CIR/CodeGen/switch.cir +++ b/clang/test/CIR/CodeGen/switch.cir @@ -33,7 +33,7 @@ module { case (equal, 1) { cir.break } - ] + ] cir.return } // CHECK: cir.func @shouldFlatSwitchWithoutDefault(%arg0: !s32i) { @@ -52,7 +52,7 @@ module { case (anyof, [1, 2] : !s64i) { cir.break } - ] + ] cir.return } // CHECK: cir.func @shouldFlatSwitchWithImplicitFallthrough(%arg0: !s64i) { @@ -72,11 +72,11 @@ module { cir.switch (%arg0 : !s64i) [ case (equal, 1 : !s64i) { // case 1 has its own region cir.yield // fallthrough to case 2 - }, + }, case (equal, 2 : !s64i) { cir.break - } - ] + } + ] cir.return } // CHECK: cir.func @shouldFlatSwitchWithExplicitFallthrough(%arg0: !s64i) { @@ -96,8 +96,8 @@ module { cir.switch (%arg0 : !s64i) [ case (equal, 1 : !s64i) { cir.yield // fallthrough to exit - } - ] + } + ] cir.return } // CHECK: cir.func @shouldFlatSwitchWithFallthroughToExit(%arg0: !s64i) { @@ -116,7 +116,7 @@ module { // CHECK-NOT: llvm.switch cir.return } -// CHECK: cir.func @shouldDropEmptySwitch(%arg0: !s64i) +// CHECK: cir.func @shouldDropEmptySwitch(%arg0: !s64i) // CHECK-NOT: cir.switch.flat @@ -131,7 +131,7 @@ module { ^bb1: // no predecessors cir.break } - ] + ] } cir.return } @@ -168,7 +168,7 @@ module { case (equal, 0) { cir.scope { %6 = cir.load %1 : !cir.ptr, !s32i - %7 = cir.const(#cir.int<0> : !s32i) : !s32i + %7 = cir.const #cir.int<0> : !s32i %8 = cir.cmp(ge, %6, %7) : !s32i, !s32i %9 = cir.cast(int_to_bool, %8 : !s32i), !cir.bool cir.if %9 { @@ -177,12 +177,12 @@ module { } cir.break } - ] - } - %3 = cir.const(#cir.int<3> : !s32i) : !s32i + ] + } + %3 = cir.const #cir.int<3> : !s32i cir.store %3, %2 : !s32i, !cir.ptr %4 = cir.load %2 : !cir.ptr, !s32i - cir.return %4 : !s32i + cir.return %4 : !s32i } // CHECK: cir.func @shouldFlatNestedBreak(%arg0: !s32i, %arg1: !s32i) -> !s32i { // CHECK: cir.switch.flat %3 : !s32i, ^bb7 [ @@ -200,7 +200,7 @@ module { // CHECK: cir.br ^bb7 // CHECK: ^bb7: // 3 preds: ^bb1, ^bb4, ^bb6 // CHECK: cir.br ^bb8 -// CHECK: ^bb8: // pred: ^bb7 +// CHECK: ^bb8: // pred: ^bb7 // CHECK: cir.return %9 : !s32i // CHECK: } diff --git a/clang/test/CIR/CodeGen/switch.cpp b/clang/test/CIR/CodeGen/switch.cpp index 7ba1185c660c..a19a55348ff6 100644 --- a/clang/test/CIR/CodeGen/switch.cpp +++ b/clang/test/CIR/CodeGen/switch.cpp @@ -19,7 +19,7 @@ void sw1(int a) { // CHECK: cir.switch (%3 : !s32i) [ // CHECK-NEXT: case (equal, 0) { // CHECK-NEXT: %4 = cir.load %1 : !cir.ptr, !s32i -// CHECK-NEXT: %5 = cir.const(#cir.int<1> : !s32i) : !s32i +// CHECK-NEXT: %5 = cir.const #cir.int<1> : !s32i // CHECK-NEXT: %6 = cir.binop(add, %4, %5) : !s32i // CHECK-NEXT: cir.store %6, %1 : !s32i, !cir.ptr // CHECK-NEXT: cir.break @@ -31,10 +31,10 @@ void sw1(int a) { // CHECK-NEXT: cir.scope { // CHECK-NEXT: %4 = cir.alloca !s32i, !cir.ptr, ["yolo", init] // CHECK-NEXT: %5 = cir.load %1 : !cir.ptr, !s32i -// CHECK-NEXT: %6 = cir.const(#cir.int<1> : !s32i) : !s32i +// CHECK-NEXT: %6 = cir.const #cir.int<1> : !s32i // CHECK-NEXT: %7 = cir.binop(add, %5, %6) : !s32i // CHECK-NEXT: cir.store %7, %1 : !s32i, !cir.ptr -// CHECK-NEXT: %8 = cir.const(#cir.int<100> : !s32i) : !s32i +// CHECK-NEXT: %8 = cir.const #cir.int<100> : !s32i // CHECK-NEXT: cir.store %8, %4 : !s32i, !cir.ptr // CHECK-NEXT: cir.break // CHECK-NEXT: } @@ -57,7 +57,7 @@ void sw2(int a) { // CHECK-NEXT: %2 = cir.alloca !s32i, !cir.ptr, ["fomo", init] // CHECK: cir.switch (%4 : !s32i) [ // CHECK-NEXT: case (equal, 3) { -// CHECK-NEXT: %5 = cir.const(#cir.int<0> : !s32i) : !s32i +// CHECK-NEXT: %5 = cir.const #cir.int<0> : !s32i // CHECK-NEXT: cir.store %5, %2 : !s32i, !cir.ptr void sw3(int a) { @@ -91,7 +91,7 @@ int sw4(int a) { // CHECK: cir.switch (%4 : !s32i) [ // CHECK-NEXT: case (equal, 42) { // CHECK-NEXT: cir.scope { -// CHECK-NEXT: %5 = cir.const(#cir.int<3> : !s32i) : !s32i +// CHECK-NEXT: %5 = cir.const #cir.int<3> : !s32i // CHECK-NEXT: cir.store %5, %1 : !s32i, !cir.ptr // CHECK-NEXT: %6 = cir.load %1 : !cir.ptr, !s32i // CHECK-NEXT: cir.return %6 : !s32i @@ -99,7 +99,7 @@ int sw4(int a) { // CHECK-NEXT: cir.yield // CHECK-NEXT: }, // CHECK-NEXT: case (default) { -// CHECK-NEXT: %5 = cir.const(#cir.int<2> : !s32i) : !s32i +// CHECK-NEXT: %5 = cir.const #cir.int<2> : !s32i // CHECK-NEXT: cir.store %5, %1 : !s32i, !cir.ptr // CHECK-NEXT: %6 = cir.load %1 : !cir.ptr, !s32i // CHECK-NEXT: cir.return %6 : !s32i @@ -180,13 +180,13 @@ void sw8(int a) { //CHECK-NEXT: } //CHECK-NEXT: case (default) { //CHECK-NEXT: cir.break -//CHECK-NEXT: } +//CHECK-NEXT: } void sw9(int a) { switch (a) { case 3: - break; + break; default: case 4: break; @@ -208,8 +208,8 @@ void sw10(int a) { switch (a) { case 3: - break; - case 4: + break; + case 4: default: case 5: break; @@ -234,9 +234,9 @@ void sw11(int a) { switch (a) { case 3: - break; + break; case 4: - case 5: + case 5: default: case 6: case 7: diff --git a/clang/test/CIR/CodeGen/ternary.cir b/clang/test/CIR/CodeGen/ternary.cir index 715061f15fb9..fedfbcbbc5ea 100644 --- a/clang/test/CIR/CodeGen/ternary.cir +++ b/clang/test/CIR/CodeGen/ternary.cir @@ -8,13 +8,13 @@ module { %1 = cir.alloca !s32i, !cir.ptr, ["__retval"] {alignment = 4 : i64} cir.store %arg0, %0 : !s32i, !cir.ptr %2 = cir.load %0 : !cir.ptr, !s32i - %3 = cir.const(#cir.int<0> : !s32i) : !s32i + %3 = cir.const #cir.int<0> : !s32i %4 = cir.cmp(gt, %2, %3) : !s32i, !cir.bool %5 = cir.ternary(%4, true { - %7 = cir.const(#cir.int<3> : !s32i) : !s32i + %7 = cir.const #cir.int<3> : !s32i cir.yield %7 : !s32i }, false { - %7 = cir.const(#cir.int<5> : !s32i) : !s32i + %7 = cir.const #cir.int<5> : !s32i cir.yield %7 : !s32i }) : (!cir.bool) -> !s32i cir.store %5, %1 : !s32i, !cir.ptr @@ -27,14 +27,14 @@ module { // CHECK: %1 = cir.alloca !s32i, !cir.ptr, ["__retval"] {alignment = 4 : i64} // CHECK: cir.store %arg0, %0 : !s32i, !cir.ptr // CHECK: %2 = cir.load %0 : !cir.ptr, !s32i -// CHECK: %3 = cir.const(#cir.int<0> : !s32i) : !s32i +// CHECK: %3 = cir.const #cir.int<0> : !s32i // CHECK: %4 = cir.cmp(gt, %2, %3) : !s32i, !cir.bool // CHECK: cir.brcond %4 ^bb1, ^bb2 // CHECK: ^bb1: // pred: ^bb0 -// CHECK: %5 = cir.const(#cir.int<3> : !s32i) : !s32i +// CHECK: %5 = cir.const #cir.int<3> : !s32i // CHECK: cir.br ^bb3(%5 : !s32i) // CHECK: ^bb2: // pred: ^bb0 -// CHECK: %6 = cir.const(#cir.int<5> : !s32i) : !s32i +// CHECK: %6 = cir.const #cir.int<5> : !s32i // CHECK: cir.br ^bb3(%6 : !s32i) // CHECK: ^bb3(%7: !s32i): // 2 preds: ^bb1, ^bb2 // CHECK: cir.br ^bb4 @@ -43,5 +43,5 @@ module { // CHECK: %8 = cir.load %1 : !cir.ptr, !s32i // CHECK: cir.return %8 : !s32i // CHECK: } - + } diff --git a/clang/test/CIR/CodeGen/ternary.cpp b/clang/test/CIR/CodeGen/ternary.cpp index 452745633d85..6475add8e2b4 100644 --- a/clang/test/CIR/CodeGen/ternary.cpp +++ b/clang/test/CIR/CodeGen/ternary.cpp @@ -10,13 +10,13 @@ int x(int y) { // CHECK: %1 = cir.alloca !s32i, !cir.ptr, ["__retval"] {alignment = 4 : i64} // CHECK: cir.store %arg0, %0 : !s32i, !cir.ptr // CHECK: %2 = cir.load %0 : !cir.ptr, !s32i -// CHECK: %3 = cir.const(#cir.int<0> : !s32i) : !s32i +// CHECK: %3 = cir.const #cir.int<0> : !s32i // CHECK: %4 = cir.cmp(gt, %2, %3) : !s32i, !cir.bool // CHECK: %5 = cir.ternary(%4, true { -// CHECK: %7 = cir.const(#cir.int<3> : !s32i) : !s32i +// CHECK: %7 = cir.const #cir.int<3> : !s32i // CHECK: cir.yield %7 : !s32i // CHECK: }, false { -// CHECK: %7 = cir.const(#cir.int<5> : !s32i) : !s32i +// CHECK: %7 = cir.const #cir.int<5> : !s32i // CHECK: cir.yield %7 : !s32i // CHECK: }) : (!cir.bool) -> !s32i // CHECK: cir.store %5, %1 : !s32i, !cir.ptr @@ -40,11 +40,11 @@ void m(APIType api) { // CHECK: cir.store %arg0, %0 : !u32i, !cir.ptr // CHECK: %1 = cir.load %0 : !cir.ptr, !u32i // CHECK: %2 = cir.cast(integral, %1 : !u32i), !s32i -// CHECK: %3 = cir.const(#cir.int<0> : !u32i) : !u32i +// CHECK: %3 = cir.const #cir.int<0> : !u32i // CHECK: %4 = cir.cast(integral, %3 : !u32i), !s32i // CHECK: %5 = cir.cmp(eq, %2, %4) : !s32i, !cir.bool // CHECK: cir.ternary(%5, true { -// CHECK: %6 = cir.const(#cir.int<0> : !s32i) : !s32i +// CHECK: %6 = cir.const #cir.int<0> : !s32i // CHECK: cir.yield // CHECK: }, false { // CHECK: %6 = cir.get_global @".str" : !cir.ptr> @@ -66,7 +66,7 @@ int foo(int a, int b) { // CHECK: [[B0:%.*]] = cir.load {{.*}} : !cir.ptr, !s32i // CHECK: [[CMP:%.*]] = cir.cmp(lt, [[A0]], [[B0]]) : !s32i, !cir.bool // CHECK: [[RES:%.*]] = cir.ternary([[CMP]], true { -// CHECK: [[ZERO:%.*]] = cir.const(#cir.int<0> : !s32i) : !s32i +// CHECK: [[ZERO:%.*]] = cir.const #cir.int<0> : !s32i // CHECK: cir.yield [[ZERO]] : !s32i // CHECK: }, false { // CHECK: [[A1:%.*]] = cir.load {{.*}} : !cir.ptr, !s32i diff --git a/clang/test/CIR/CodeGen/three-way-comparison.cpp b/clang/test/CIR/CodeGen/three-way-comparison.cpp index 4e1c2109a230..e511e6f9a3c0 100644 --- a/clang/test/CIR/CodeGen/three-way-comparison.cpp +++ b/clang/test/CIR/CodeGen/three-way-comparison.cpp @@ -30,24 +30,24 @@ auto three_way_strong(int x, int y) { // NONCANONICAL-AFTER: #cmp3way_info_strong_ltn1eq0gt1_ = #cir.cmp3way_info // NONCANONICAL-AFTER: cir.func @_Z16three_way_strongii // NONCANONICAL-AFTER: %[[#CMP3WAY_RESULT:]] = cir.cmp3way(%{{.+}} : !s32i, %{{.+}}, #cmp3way_info_strong_ltn1eq0gt1_) : !s8i -// NONCANONICAL-AFTER-NEXT: %[[#NEGONE:]] = cir.const(#cir.int<-1> : !s8i) : !s8i -// NONCANONICAL-AFTER-NEXT: %[[#ONE:]] = cir.const(#cir.int<1> : !s8i) : !s8i +// NONCANONICAL-AFTER-NEXT: %[[#NEGONE:]] = cir.const #cir.int<-1> : !s8i +// NONCANONICAL-AFTER-NEXT: %[[#ONE:]] = cir.const #cir.int<1> : !s8i // NONCANONICAL-AFTER-NEXT: %[[#CMP_TO_NEGONE:]] = cir.cmp(eq, %[[#CMP3WAY_RESULT]], %[[#NEGONE]]) : !s8i, !cir.bool // NONCANONICAL-AFTER-NEXT: %[[#A:]] = cir.ternary(%[[#CMP_TO_NEGONE]], true { // NONCANONICAL-AFTER-NEXT: cir.yield %[[#ONE]] : !s8i // NONCANONICAL-AFTER-NEXT: }, false { // NONCANONICAL-AFTER-NEXT: cir.yield %[[#CMP3WAY_RESULT]] : !s8i // NONCANONICAL-AFTER-NEXT: }) : (!cir.bool) -> !s8i -// NONCANONICAL-AFTER-NEXT: %[[#ZERO:]] = cir.const(#cir.int<0> : !s8i) : !s8i -// NONCANONICAL-AFTER-NEXT: %[[#TWO:]] = cir.const(#cir.int<2> : !s8i) : !s8i +// NONCANONICAL-AFTER-NEXT: %[[#ZERO:]] = cir.const #cir.int<0> : !s8i +// NONCANONICAL-AFTER-NEXT: %[[#TWO:]] = cir.const #cir.int<2> : !s8i // NONCANONICAL-AFTER-NEXT: %[[#CMP_TO_ZERO:]] = cir.cmp(eq, %[[#A]], %[[#ZERO]]) : !s8i, !cir.bool // NONCANONICAL-AFTER-NEXT: %[[#B:]] = cir.ternary(%[[#CMP_TO_ZERO]], true { // NONCANONICAL-AFTER-NEXT: cir.yield %[[#TWO]] : !s8i // NONCANONICAL-AFTER-NEXT: }, false { // NONCANONICAL-AFTER-NEXT: cir.yield %[[#A]] : !s8i // NONCANONICAL-AFTER-NEXT: }) : (!cir.bool) -> !s8i -// NONCANONICAL-AFTER-NEXT: %[[#ONE2:]] = cir.const(#cir.int<1> : !s8i) : !s8i -// NONCANONICAL-AFTER-NEXT: %[[#THREE:]] = cir.const(#cir.int<3> : !s8i) : !s8i +// NONCANONICAL-AFTER-NEXT: %[[#ONE2:]] = cir.const #cir.int<1> : !s8i +// NONCANONICAL-AFTER-NEXT: %[[#THREE:]] = cir.const #cir.int<3> : !s8i // NONCANONICAL-AFTER-NEXT: %[[#CMP_TO_ONE:]] = cir.cmp(eq, %[[#B]], %[[#ONE2]]) : !s8i, !cir.bool // NONCANONICAL-AFTER-NEXT: %{{.+}} = cir.ternary(%[[#CMP_TO_ONE]], true { // NONCANONICAL-AFTER-NEXT: cir.yield %[[#THREE]] : !s8i @@ -67,10 +67,10 @@ auto three_way_weak(float x, float y) { // AFTER: cir.func @_Z14three_way_weakff // AFTER: %[[#LHS:]] = cir.load %0 : !cir.ptr, !cir.float // AFTER-NEXT: %[[#RHS:]] = cir.load %1 : !cir.ptr, !cir.float -// AFTER-NEXT: %[[#LT:]] = cir.const(#cir.int<-1> : !s8i) : !s8i -// AFTER-NEXT: %[[#EQ:]] = cir.const(#cir.int<0> : !s8i) : !s8i -// AFTER-NEXT: %[[#GT:]] = cir.const(#cir.int<1> : !s8i) : !s8i -// AFTER-NEXT: %[[#UNORDERED:]] = cir.const(#cir.int<-127> : !s8i) : !s8i +// AFTER-NEXT: %[[#LT:]] = cir.const #cir.int<-1> : !s8i +// AFTER-NEXT: %[[#EQ:]] = cir.const #cir.int<0> : !s8i +// AFTER-NEXT: %[[#GT:]] = cir.const #cir.int<1> : !s8i +// AFTER-NEXT: %[[#UNORDERED:]] = cir.const #cir.int<-127> : !s8i // AFTER-NEXT: %[[#CMP_LT:]] = cir.cmp(lt, %[[#LHS]], %[[#RHS]]) : !cir.float, !cir.bool // AFTER-NEXT: %[[#CMP_EQ:]] = cir.cmp(eq, %[[#LHS]], %[[#RHS]]) : !cir.float, !cir.bool // AFTER-NEXT: %[[#CMP_GT:]] = cir.cmp(gt, %[[#LHS]], %[[#RHS]]) : !cir.float, !cir.bool diff --git a/clang/test/CIR/CodeGen/try-catch.cpp b/clang/test/CIR/CodeGen/try-catch.cpp index 99ee97d76719..46d6315e53a2 100644 --- a/clang/test/CIR/CodeGen/try-catch.cpp +++ b/clang/test/CIR/CodeGen/try-catch.cpp @@ -62,7 +62,7 @@ unsigned long long tc2() { } catch (...) { // CHECK: type (#cir.all) // CHECK: cir.catch_param - // CHECK: cir.const(#cir.int<100> : !s32i) : !s32i + // CHECK: cir.const #cir.int<100> : !s32i z = 100; } @@ -79,7 +79,7 @@ unsigned long long tc3() { } catch (...) { // CHECK: type (#cir.all) // CHECK: cir.catch_param - // CHECK: cir.const(#cir.int<100> : !s32i) : !s32i + // CHECK: cir.const #cir.int<100> : !s32i z = 100; } diff --git a/clang/test/CIR/CodeGen/types-nullptr.cpp b/clang/test/CIR/CodeGen/types-nullptr.cpp index 55f42be785fb..00250f438940 100644 --- a/clang/test/CIR/CodeGen/types-nullptr.cpp +++ b/clang/test/CIR/CodeGen/types-nullptr.cpp @@ -5,5 +5,5 @@ typedef decltype(nullptr) nullptr_t; void f() { nullptr_t t = nullptr; } // CHECK: %0 = cir.alloca !cir.ptr, !cir.ptr> -// CHECK: %1 = cir.const(#cir.ptr : !cir.ptr) : !cir.ptr +// CHECK: %1 = cir.const #cir.ptr : !cir.ptr // CHECK: cir.store %1, %0 : !cir.ptr, !cir.ptr> diff --git a/clang/test/CIR/CodeGen/unary.cpp b/clang/test/CIR/CodeGen/unary.cpp index f6d99af23b5a..5f6a451cee75 100644 --- a/clang/test/CIR/CodeGen/unary.cpp +++ b/clang/test/CIR/CodeGen/unary.cpp @@ -46,7 +46,7 @@ int inc0() { // CHECK: cir.func @_Z4inc0v() -> !s32i // CHECK: %[[#RET:]] = cir.alloca !s32i, !cir.ptr, ["__retval"] // CHECK: %[[#A:]] = cir.alloca !s32i, !cir.ptr, ["a", init] -// CHECK: %[[#ATMP:]] = cir.const(#cir.int<1> : !s32i) : !s32i +// CHECK: %[[#ATMP:]] = cir.const #cir.int<1> : !s32i // CHECK: cir.store %[[#ATMP]], %[[#A]] : !s32i // CHECK: %[[#INPUT:]] = cir.load %[[#A]] // CHECK: %[[#INCREMENTED:]] = cir.unary(inc, %[[#INPUT]]) @@ -65,7 +65,7 @@ int dec0() { // CHECK: cir.func @_Z4dec0v() -> !s32i // CHECK: %[[#RET:]] = cir.alloca !s32i, !cir.ptr, ["__retval"] // CHECK: %[[#A:]] = cir.alloca !s32i, !cir.ptr, ["a", init] -// CHECK: %[[#ATMP:]] = cir.const(#cir.int<1> : !s32i) : !s32i +// CHECK: %[[#ATMP:]] = cir.const #cir.int<1> : !s32i // CHECK: cir.store %[[#ATMP]], %[[#A]] : !s32i // CHECK: %[[#INPUT:]] = cir.load %[[#A]] // CHECK: %[[#INCREMENTED:]] = cir.unary(dec, %[[#INPUT]]) @@ -85,7 +85,7 @@ int inc1() { // CHECK: cir.func @_Z4inc1v() -> !s32i // CHECK: %[[#RET:]] = cir.alloca !s32i, !cir.ptr, ["__retval"] // CHECK: %[[#A:]] = cir.alloca !s32i, !cir.ptr, ["a", init] -// CHECK: %[[#ATMP:]] = cir.const(#cir.int<1> : !s32i) : !s32i +// CHECK: %[[#ATMP:]] = cir.const #cir.int<1> : !s32i // CHECK: cir.store %[[#ATMP]], %[[#A]] : !s32i // CHECK: %[[#INPUT:]] = cir.load %[[#A]] // CHECK: %[[#INCREMENTED:]] = cir.unary(inc, %[[#INPUT]]) @@ -104,7 +104,7 @@ int dec1() { // CHECK: cir.func @_Z4dec1v() -> !s32i // CHECK: %[[#RET:]] = cir.alloca !s32i, !cir.ptr, ["__retval"] // CHECK: %[[#A:]] = cir.alloca !s32i, !cir.ptr, ["a", init] -// CHECK: %[[#ATMP:]] = cir.const(#cir.int<1> : !s32i) : !s32i +// CHECK: %[[#ATMP:]] = cir.const #cir.int<1> : !s32i // CHECK: cir.store %[[#ATMP]], %[[#A]] : !s32i // CHECK: %[[#INPUT:]] = cir.load %[[#A]] // CHECK: %[[#INCREMENTED:]] = cir.unary(dec, %[[#INPUT]]) @@ -125,7 +125,7 @@ int inc2() { // CHECK: %[[#RET:]] = cir.alloca !s32i, !cir.ptr, ["__retval"] // CHECK: %[[#A:]] = cir.alloca !s32i, !cir.ptr, ["a", init] // CHECK: %[[#B:]] = cir.alloca !s32i, !cir.ptr, ["b", init] -// CHECK: %[[#ATMP:]] = cir.const(#cir.int<1> : !s32i) : !s32i +// CHECK: %[[#ATMP:]] = cir.const #cir.int<1> : !s32i // CHECK: cir.store %[[#ATMP]], %[[#A]] : !s32i // CHECK: %[[#ATOB:]] = cir.load %[[#A]] // CHECK: %[[#INCREMENTED:]] = cir.unary(inc, %[[#ATOB]]) @@ -146,11 +146,11 @@ int *inc_p(int *i) { // CHECK: %[[#i_addr:]] = cir.alloca !cir.ptr, !cir.ptr>, ["i", init] {alignment = 8 : i64} // CHECK: %[[#i_dec:]] = cir.load %[[#i_addr]] : !cir.ptr>, !cir.ptr -// CHECK: %[[#dec_const:]] = cir.const(#cir.int<-1> : !s32i) : !s32i +// CHECK: %[[#dec_const:]] = cir.const #cir.int<-1> : !s32i // CHECK: = cir.ptr_stride(%[[#i_dec]] : !cir.ptr, %[[#dec_const]] : !s32i), !cir.ptr // CHECK: %[[#i_inc:]] = cir.load %0 : !cir.ptr>, !cir.ptr -// CHECK: %[[#inc_const:]] = cir.const(#cir.int<1> : !s32i) : !s32i +// CHECK: %[[#inc_const:]] = cir.const #cir.int<1> : !s32i // CHECK: = cir.ptr_stride(%[[#i_inc]] : !cir.ptr, %[[#inc_const]] : !s32i), !cir.ptr void floats(float f) { @@ -189,19 +189,19 @@ void pointers(int *p) { // CHECK: cir.unary(plus, %{{.+}}) : !cir.ptr, !cir.ptr ++p; - // CHECK: %[[#INC:]] = cir.const(#cir.int<1> : !s32i) : !s32i + // CHECK: %[[#INC:]] = cir.const #cir.int<1> : !s32i // CHECK: %[[#RES:]] = cir.ptr_stride(%{{.+}} : !cir.ptr, %[[#INC]] : !s32i), !cir.ptr // CHECK: cir.store %[[#RES]], %[[#P]] : !cir.ptr, !cir.ptr> --p; - // CHECK: %[[#DEC:]] = cir.const(#cir.int<-1> : !s32i) : !s32i + // CHECK: %[[#DEC:]] = cir.const #cir.int<-1> : !s32i // CHECK: %[[#RES:]] = cir.ptr_stride(%{{.+}} : !cir.ptr, %[[#DEC]] : !s32i), !cir.ptr // CHECK: cir.store %[[#RES]], %[[#P]] : !cir.ptr, !cir.ptr> p++; - // CHECK: %[[#INC:]] = cir.const(#cir.int<1> : !s32i) : !s32i + // CHECK: %[[#INC:]] = cir.const #cir.int<1> : !s32i // CHECK: %[[#RES:]] = cir.ptr_stride(%{{.+}} : !cir.ptr, %[[#INC]] : !s32i), !cir.ptr // CHECK: cir.store %[[#RES]], %[[#P]] : !cir.ptr, !cir.ptr> p--; - // CHECK: %[[#DEC:]] = cir.const(#cir.int<-1> : !s32i) : !s32i + // CHECK: %[[#DEC:]] = cir.const #cir.int<-1> : !s32i // CHECK: %[[#RES:]] = cir.ptr_stride(%{{.+}} : !cir.ptr, %[[#DEC]] : !s32i), !cir.ptr // CHECK: cir.store %[[#RES]], %[[#P]] : !cir.ptr, !cir.ptr> diff --git a/clang/test/CIR/CodeGen/union-init.c b/clang/test/CIR/CodeGen/union-init.c index b041bc5533c7..9cf96adcaf48 100644 --- a/clang/test/CIR/CodeGen/union-init.c +++ b/clang/test/CIR/CodeGen/union-init.c @@ -22,21 +22,21 @@ void foo(int x) { // CHECK: [[TMP4:%.*]] = cir.load [[TMP0]] : !cir.ptr, !s32i // CHECK: [[TMP5:%.*]] = cir.cast(integral, [[TMP4]] : !s32i), !u32i // CHECK: [[TMP6:%.*]] = cir.load [[TMP3]] : !cir.ptr, !u32i -// CHECK: [[TMP7:%.*]] = cir.const(#cir.int<65535> : !u32i) : !u32i +// CHECK: [[TMP7:%.*]] = cir.const #cir.int<65535> : !u32i // CHECK: [[TMP8:%.*]] = cir.binop(and, [[TMP5]], [[TMP7]]) : !u32i -// CHECK: [[TMP9:%.*]] = cir.const(#cir.int<4294901760> : !u32i) : !u32i +// CHECK: [[TMP9:%.*]] = cir.const #cir.int<4294901760> : !u32i // CHECK: [[TMP10:%.*]] = cir.binop(and, [[TMP6]], [[TMP9]]) : !u32i // CHECK: [[TMP11:%.*]] = cir.binop(or, [[TMP10]], [[TMP8]]) : !u32i // CHECK: cir.store [[TMP11]], [[TMP3]] : !u32i, !cir.ptr // CHECK: [[TMP12:%.*]] = cir.cast(bitcast, [[TMP2]] : !cir.ptr), !cir.ptr -// CHECK: [[TMP13:%.*]] = cir.const(#cir.int<0> : !s32i) : !s32i +// CHECK: [[TMP13:%.*]] = cir.const #cir.int<0> : !s32i // CHECK: [[TMP14:%.*]] = cir.cast(integral, [[TMP13]] : !s32i), !u32i // CHECK: [[TMP15:%.*]] = cir.load [[TMP12]] : !cir.ptr, !u32i -// CHECK: [[TMP16:%.*]] = cir.const(#cir.int<65535> : !u32i) : !u32i +// CHECK: [[TMP16:%.*]] = cir.const #cir.int<65535> : !u32i // CHECK: [[TMP17:%.*]] = cir.binop(and, [[TMP14]], [[TMP16]]) : !u32i -// CHECK: [[TMP18:%.*]] = cir.const(#cir.int<16> : !u32i) : !u32i +// CHECK: [[TMP18:%.*]] = cir.const #cir.int<16> : !u32i // CHECK: [[TMP19:%.*]] = cir.shift(left, [[TMP17]] : !u32i, [[TMP18]] : !u32i) -> !u32i -// CHECK: [[TMP20:%.*]] = cir.const(#cir.int<65535> : !u32i) : !u32i +// CHECK: [[TMP20:%.*]] = cir.const #cir.int<65535> : !u32i // CHECK: [[TMP21:%.*]] = cir.binop(and, [[TMP15]], [[TMP20]]) : !u32i // CHECK: [[TMP22:%.*]] = cir.binop(or, [[TMP21]], [[TMP19]]) : !u32i // CHECK: cir.store [[TMP22]], [[TMP12]] : !u32i, !cir.ptr diff --git a/clang/test/CIR/CodeGen/union.cpp b/clang/test/CIR/CodeGen/union.cpp index 1ba5cff2a41d..8d32cf34eae5 100644 --- a/clang/test/CIR/CodeGen/union.cpp +++ b/clang/test/CIR/CodeGen/union.cpp @@ -81,11 +81,11 @@ typedef union { short a; int b; } A; - + void noCrushOnDifferentSizes() { A a = {0}; // CHECK: %[[#TMP0:]] = cir.alloca !ty_22A22, !cir.ptr, ["a"] {alignment = 4 : i64} // CHECK: %[[#TMP1:]] = cir.cast(bitcast, %[[#TMP0]] : !cir.ptr), !cir.ptr - // CHECK: %[[#TMP2:]] = cir.const(#cir.zero : !ty_anon_struct) : !ty_anon_struct + // CHECK: %[[#TMP2:]] = cir.const #cir.zero : !ty_anon_struct // CHECK: cir.store %[[#TMP2]], %[[#TMP1]] : !ty_anon_struct, !cir.ptr } \ No newline at end of file diff --git a/clang/test/CIR/CodeGen/vectype.cpp b/clang/test/CIR/CodeGen/vectype.cpp index 3d59f94c6d93..fa80ced0f1b9 100644 --- a/clang/test/CIR/CodeGen/vectype.cpp +++ b/clang/test/CIR/CodeGen/vectype.cpp @@ -18,13 +18,13 @@ void vector_int_test(int x) { // Incomplete vector initialization. vi4 bb = { x, x + 1 }; - // CHECK: %[[#zero:]] = cir.const(#cir.int<0> : !s32i) : !s32i + // CHECK: %[[#zero:]] = cir.const #cir.int<0> : !s32i // CHECK: %{{[0-9]+}} = cir.vec.create(%{{[0-9]+}}, %{{[0-9]+}}, %[[#zero]], %[[#zero]] : !s32i, !s32i, !s32i, !s32i) : !cir.vector // Scalar to vector conversion, a.k.a. vector splat. Only valid as an // operand of a binary operator, not as a regular conversion. bb = a + 7; - // CHECK: %[[#seven:]] = cir.const(#cir.int<7> : !s32i) : !s32i + // CHECK: %[[#seven:]] = cir.const #cir.int<7> : !s32i // CHECK: %{{[0-9]+}} = cir.vec.splat %[[#seven]] : !s32i, !cir.vector // Vector to vector conversion @@ -105,13 +105,13 @@ void vector_double_test(int x, double y) { // Incomplete vector initialization vd2 bb = { y }; - // CHECK: [[#dzero:]] = cir.const(#cir.fp<0.000000e+00> : !cir.double) : !cir.double + // CHECK: [[#dzero:]] = cir.const #cir.fp<0.000000e+00> : !cir.double // CHECK: %{{[0-9]+}} = cir.vec.create(%{{[0-9]+}}, %[[#dzero]] : !cir.double, !cir.double) : !cir.vector // Scalar to vector conversion, a.k.a. vector splat. Only valid as an // operand of a binary operator, not as a regular conversion. bb = a + 2.5; - // CHECK: %[[#twohalf:]] = cir.const(#cir.fp<2.500000e+00> : !cir.double) : !cir.double + // CHECK: %[[#twohalf:]] = cir.const #cir.fp<2.500000e+00> : !cir.double // CHECK: %{{[0-9]+}} = cir.vec.splat %[[#twohalf]] : !cir.double, !cir.vector // Extract element diff --git a/clang/test/CIR/CodeGen/vtable-rtti.cpp b/clang/test/CIR/CodeGen/vtable-rtti.cpp index 8dd4a73a0e12..425cbd0abbe5 100644 --- a/clang/test/CIR/CodeGen/vtable-rtti.cpp +++ b/clang/test/CIR/CodeGen/vtable-rtti.cpp @@ -55,7 +55,7 @@ class B : public A // CHECK: cir.func @_Z3foov() // CHECK: cir.scope { // CHECK: %0 = cir.alloca !ty_22B22, !cir.ptr, ["agg.tmp.ensured"] {alignment = 8 : i64} -// CHECK: %1 = cir.const(#cir.zero : ![[ClassB]]) : ![[ClassB]] +// CHECK: %1 = cir.const #cir.zero : ![[ClassB]] // CHECK: cir.store %1, %0 : ![[ClassB]], !cir.ptr // CHECK: cir.call @_ZN1BC2Ev(%0) : (!cir.ptr) -> () // CHECK: } diff --git a/clang/test/CIR/IR/bit.cir b/clang/test/CIR/IR/bit.cir index 974f22606cdc..7a6d4d2e4bdb 100644 --- a/clang/test/CIR/IR/bit.cir +++ b/clang/test/CIR/IR/bit.cir @@ -11,14 +11,14 @@ module { cir.func @test() { - %s8 = cir.const(#cir.int<1> : !s8i) : !s8i - %s16 = cir.const(#cir.int<1> : !s16i) : !s16i - %s32 = cir.const(#cir.int<1> : !s32i) : !s32i - %s64 = cir.const(#cir.int<1> : !s64i) : !s64i - %u8 = cir.const(#cir.int<1> : !u8i) : !u8i - %u16 = cir.const(#cir.int<1> : !u16i) : !u16i - %u32 = cir.const(#cir.int<1> : !u32i) : !u32i - %u64 = cir.const(#cir.int<1> : !u64i) : !u64i + %s8 = cir.const #cir.int<1> : !s8i + %s16 = cir.const #cir.int<1> : !s16i + %s32 = cir.const #cir.int<1> : !s32i + %s64 = cir.const #cir.int<1> : !s64i + %u8 = cir.const #cir.int<1> : !u8i + %u16 = cir.const #cir.int<1> : !u16i + %u32 = cir.const #cir.int<1> : !u32i + %u64 = cir.const #cir.int<1> : !u64i %2 = cir.bit.clrsb(%s32 : !s32i) : !s32i %3 = cir.bit.clrsb(%s64 : !s64i) : !s32i @@ -47,14 +47,14 @@ module { // CHECK: module { // CHECK-NEXT: cir.func @test() { -// CHECK-NEXT: %0 = cir.const(#cir.int<1> : !s8i) : !s8i -// CHECK-NEXT: %1 = cir.const(#cir.int<1> : !s16i) : !s16i -// CHECK-NEXT: %2 = cir.const(#cir.int<1> : !s32i) : !s32i -// CHECK-NEXT: %3 = cir.const(#cir.int<1> : !s64i) : !s64i -// CHECK-NEXT: %4 = cir.const(#cir.int<1> : !u8i) : !u8i -// CHECK-NEXT: %5 = cir.const(#cir.int<1> : !u16i) : !u16i -// CHECK-NEXT: %6 = cir.const(#cir.int<1> : !u32i) : !u32i -// CHECK-NEXT: %7 = cir.const(#cir.int<1> : !u64i) : !u64i +// CHECK-NEXT: %0 = cir.const #cir.int<1> : !s8i +// CHECK-NEXT: %1 = cir.const #cir.int<1> : !s16i +// CHECK-NEXT: %2 = cir.const #cir.int<1> : !s32i +// CHECK-NEXT: %3 = cir.const #cir.int<1> : !s64i +// CHECK-NEXT: %4 = cir.const #cir.int<1> : !u8i +// CHECK-NEXT: %5 = cir.const #cir.int<1> : !u16i +// CHECK-NEXT: %6 = cir.const #cir.int<1> : !u32i +// CHECK-NEXT: %7 = cir.const #cir.int<1> : !u64i // CHECK-NEXT: %8 = cir.bit.clrsb(%2 : !s32i) : !s32i // CHECK-NEXT: %9 = cir.bit.clrsb(%3 : !s64i) : !s32i // CHECK-NEXT: %10 = cir.bit.clz(%5 : !u16i) : !s32i diff --git a/clang/test/CIR/IR/cast.cir b/clang/test/CIR/IR/cast.cir index be4bffbe7fe1..986ed13a906e 100644 --- a/clang/test/CIR/IR/cast.cir +++ b/clang/test/CIR/IR/cast.cir @@ -7,7 +7,7 @@ module { %a = cir.cast (int_to_bool, %arg0 : !s32i), !cir.bool %3 = cir.cast(array_to_ptrdecay, %0 : !cir.ptr>), !cir.ptr - %4 = cir.const(#cir.int<0> : !s32i) : !s32i + %4 = cir.const #cir.int<0> : !s32i cir.return } diff --git a/clang/test/CIR/IR/cir-ops.cir b/clang/test/CIR/IR/cir-ops.cir index 24abc26e66d6..10fd9010cc1b 100644 --- a/clang/test/CIR/IR/cir-ops.cir +++ b/clang/test/CIR/IR/cir-ops.cir @@ -15,7 +15,7 @@ module { cir.func @f3() -> !s32i { %0 = cir.alloca !s32i, !cir.ptr, ["x", init] - %1 = cir.const(#cir.int<3> : !s32i) : !s32i + %1 = cir.const #cir.int<3> : !s32i cir.store %1, %0 : !s32i, !cir.ptr %2 = cir.load %0 : !cir.ptr, !s32i cir.return %2 : !s32i @@ -25,15 +25,15 @@ module { %0 = cir.alloca !s32i, !cir.ptr, ["x", init] {alignment = 4 : i64} %1 = cir.alloca !s32i, !cir.ptr, ["a", init] {alignment = 4 : i64} cir.store %arg0, %1 : !s32i, !cir.ptr - %2 = cir.const(#cir.int<0> : !s32i) : !s32i + %2 = cir.const #cir.int<0> : !s32i cir.store %2, %0 : !s32i, !cir.ptr %3 = cir.load %1 : !cir.ptr, !s32i %4 = cir.cast(int_to_bool, %3 : !s32i), !cir.bool cir.if %4 { - %6 = cir.const(#cir.int<3> : !s32i) : !s32i + %6 = cir.const #cir.int<3> : !s32i cir.store %6, %0 : !s32i, !cir.ptr } else { - %6 = cir.const(#cir.int<4> : !s32i) : !s32i + %6 = cir.const #cir.int<4> : !s32i cir.store %6, %0 : !s32i, !cir.ptr } %5 = cir.load %0 : !cir.ptr, !s32i @@ -68,7 +68,7 @@ module { // CHECK-NEXT: cir.func @f3() -> !s32i { // CHECK-NEXT: %0 = cir.alloca !s32i, !cir.ptr, ["x", init] -// CHECK-NEXT: %1 = cir.const(#cir.int<3> : !s32i) : !s32i +// CHECK-NEXT: %1 = cir.const #cir.int<3> : !s32i // CHECK-NEXT: cir.store %1, %0 : !s32i, !cir.ptr // CHECK-NEXT: %2 = cir.load %0 : !cir.ptr, !s32i // CHECK-NEXT: cir.return %2 : !s32i @@ -77,10 +77,10 @@ module { // CHECK: @if0(%arg0: !s32i) -> !s32i { // CHECK: %4 = cir.cast(int_to_bool, %3 : !s32i), !cir.bool // CHECK-NEXT: cir.if %4 { -// CHECK-NEXT: %6 = cir.const(#cir.int<3> : !s32i) : !s32i +// CHECK-NEXT: %6 = cir.const #cir.int<3> : !s32i // CHECK-NEXT: cir.store %6, %0 : !s32i, !cir.ptr // CHECK-NEXT: } else { -// CHECK-NEXT: %6 = cir.const(#cir.int<4> : !s32i) : !s32i +// CHECK-NEXT: %6 = cir.const #cir.int<4> : !s32i // CHECK-NEXT: cir.store %6, %0 : !s32i, !cir.ptr // CHECK-NEXT: } diff --git a/clang/test/CIR/IR/data-member-ptr.cir b/clang/test/CIR/IR/data-member-ptr.cir index 6370877291a4..d8332514c07b 100644 --- a/clang/test/CIR/IR/data-member-ptr.cir +++ b/clang/test/CIR/IR/data-member-ptr.cir @@ -7,18 +7,18 @@ module { cir.func @null_member() { - %0 = cir.const(#cir.data_member : !cir.data_member) : !cir.data_member + %0 = cir.const #cir.data_member : !cir.data_member cir.return } cir.func @get_runtime_member(%arg0: !cir.ptr) { - %0 = cir.const(#cir.data_member<0> : !cir.data_member) : !cir.data_member + %0 = cir.const #cir.data_member<0> : !cir.data_member %1 = cir.get_runtime_member %arg0[%0 : !cir.data_member] : !cir.ptr -> !cir.ptr cir.return } cir.func @get_global_member(%arg0: !cir.ptr) { - %0 = cir.const(#global_ptr) : !cir.data_member + %0 = cir.const #global_ptr %1 = cir.get_runtime_member %arg0[%0 : !cir.data_member] : !cir.ptr -> !cir.ptr cir.return } @@ -27,18 +27,18 @@ module { // CHECK: module { // CHECK-NEXT: cir.func @null_member() { -// CHECK-NEXT: %0 = cir.const(#cir.data_member : !cir.data_member) : !cir.data_member +// CHECK-NEXT: %0 = cir.const #cir.data_member : !cir.data_member // CHECK-NEXT: cir.return // CHECK-NEXT: } // CHECK-NEXT: cir.func @get_runtime_member(%arg0: !cir.ptr) { -// CHECK-NEXT: %0 = cir.const(#cir.data_member<0> : !cir.data_member) : !cir.data_member +// CHECK-NEXT: %0 = cir.const #cir.data_member<0> : !cir.data_member // CHECK-NEXT: %1 = cir.get_runtime_member %arg0[%0 : !cir.data_member] : !cir.ptr -> !cir.ptr // CHECK-NEXT: cir.return // CHECK-NEXT: } // CHECK-NEXT: cir.func @get_global_member(%arg0: !cir.ptr) { -// CHECK-NEXT: %0 = cir.const(#cir.data_member<0> : !cir.data_member) : !cir.data_member +// CHECK-NEXT: %0 = cir.const #cir.data_member<0> : !cir.data_member // CHECK-NEXT: %1 = cir.get_runtime_member %arg0[%0 : !cir.data_member] : !cir.ptr -> !cir.ptr // CHECK-NEXT: cir.return // CHECK-NEXT: } diff --git a/clang/test/CIR/IR/exceptions.cir b/clang/test/CIR/IR/exceptions.cir index f74a0a7ce1e4..c1a981d7a9f7 100644 --- a/clang/test/CIR/IR/exceptions.cir +++ b/clang/test/CIR/IR/exceptions.cir @@ -4,7 +4,7 @@ module { cir.func @div(%x : !s32i, %y : !s32i) -> !s32i { - %3 = cir.const(#cir.int<0> : !s32i) : !s32i + %3 = cir.const #cir.int<0> : !s32i cir.return %3 : !s32i } diff --git a/clang/test/CIR/IR/global.cir b/clang/test/CIR/IR/global.cir index 05fa0bca4a22..0db5f9f11b1a 100644 --- a/clang/test/CIR/IR/global.cir +++ b/clang/test/CIR/IR/global.cir @@ -36,7 +36,7 @@ module { cir.func private @_ZN4InitD1Ev(!cir.ptr) cir.global "private" internal @_ZL8__ioinit = ctor : !ty_22Init22 { %0 = cir.get_global @_ZL8__ioinit : !cir.ptr - %1 = cir.const(#cir.int<3> : !s8i) : !s8i + %1 = cir.const #cir.int<3> : !s8i cir.call @_ZN4InitC1Eb(%0, %1) : (!cir.ptr, !s8i) -> () } dtor { %0 = cir.get_global @_ZL8__ioinit : !cir.ptr @@ -85,7 +85,7 @@ module { // CHECK: cir.global "private" internal @_ZL8__ioinit = ctor : !ty_22Init22 { // CHECK-NEXT: %0 = cir.get_global @_ZL8__ioinit : !cir.ptr -// CHECK-NEXT: %1 = cir.const(#cir.int<3> : !s8i) : !s8i +// CHECK-NEXT: %1 = cir.const #cir.int<3> : !s8i // CHECK-NEXT: cir.call @_ZN4InitC1Eb(%0, %1) : (!cir.ptr, !s8i) -> () // CHECK-NEXT: } diff --git a/clang/test/CIR/IR/int.cir b/clang/test/CIR/IR/int.cir index 3acaacd011f7..af972da9340b 100644 --- a/clang/test/CIR/IR/int.cir +++ b/clang/test/CIR/IR/int.cir @@ -15,22 +15,22 @@ cir.func @validIntTypesAndAttributes() -> () { - %1 = cir.const(#cir.int<-128> : !cir.int) : !s8i - %2 = cir.const(#cir.int<127> : !cir.int) : !s8i - %3 = cir.const(#cir.int<255> : !cir.int) : !u8i + %1 = cir.const #cir.int<-128> : !cir.int + %2 = cir.const #cir.int<127> : !cir.int + %3 = cir.const #cir.int<255> : !cir.int - %4 = cir.const(#cir.int<-32768> : !cir.int) : !s16i - %5 = cir.const(#cir.int<32767> : !cir.int) : !s16i - %6 = cir.const(#cir.int<65535> : !cir.int) : !u16i + %4 = cir.const #cir.int<-32768> : !cir.int + %5 = cir.const #cir.int<32767> : !cir.int + %6 = cir.const #cir.int<65535> : !cir.int - %7 = cir.const(#cir.int<-2147483648> : !cir.int) : !s32i - %8 = cir.const(#cir.int<2147483647> : !cir.int) : !s32i - %9 = cir.const(#cir.int<4294967295> : !cir.int) : !u32i + %7 = cir.const #cir.int<-2147483648> : !cir.int + %8 = cir.const #cir.int<2147483647> : !cir.int + %9 = cir.const #cir.int<4294967295> : !cir.int // FIXME: MLIR is emitting a "too large" error for this one. Not sure why. - // %10 = cir.const(#cir.int<-9223372036854775808> : !cir.int) : !s64i - %11 = cir.const(#cir.int<9223372036854775807> : !cir.int) : !s64i - %12 = cir.const(#cir.int<18446744073709551615> : !cir.int) : !u64i + // %10 = cir.const #cir.int<-9223372036854775808> : !cir.int + %11 = cir.const #cir.int<9223372036854775807> : !cir.int + %12 = cir.const #cir.int<18446744073709551615> : !cir.int cir.return } diff --git a/clang/test/CIR/IR/invalid.cir b/clang/test/CIR/IR/invalid.cir index 2a78139200e6..6128fa42b824 100644 --- a/clang/test/CIR/IR/invalid.cir +++ b/clang/test/CIR/IR/invalid.cir @@ -3,20 +3,18 @@ !u32i = !cir.int -// expected-error@+2 {{'cir.const' op nullptr expects pointer type}} cir.func @p0() { - %1 = cir.const(#cir.ptr : !cir.ptr) : !u32i + // expected-error @below {{invalid kind of type specified}} + %1 = cir.const #cir.ptr : !u32i cir.return } // ----- -#false = #cir.bool : !cir.bool -#true = #cir.bool : !cir.bool !u32i = !cir.int -// expected-error@+2 {{op result type ('!cir.int') must be '!cir.bool' for '#cir.bool : !cir.bool'}} +// expected-error@+2 {{invalid kind of type specified}} cir.func @b0() { - %1 = cir.const(#true) : !u32i + %1 = cir.const #cir.bool : !u32i cir.return } @@ -26,10 +24,10 @@ cir.func @b0() { #true = #cir.bool : !cir.bool !u32i = !cir.int cir.func @if0() { - %0 = cir.const(#true) : !cir.bool + %0 = cir.const #true // expected-error@+1 {{'cir.if' op region control flow edge from Region #0 to parent results: source has 1 operands, but target successor needs 0}} cir.if %0 { - %6 = cir.const(#cir.int<3> : !u32i) : !u32i + %6 = cir.const #cir.int<3> : !u32i cir.yield %6 : !u32i } cir.return @@ -40,7 +38,7 @@ cir.func @if0() { #false = #cir.bool : !cir.bool #true = #cir.bool : !cir.bool cir.func @yield0() { - %0 = cir.const(#true) : !cir.bool + %0 = cir.const #true cir.if %0 { // expected-error {{custom op 'cir.if' multi-block region must not omit terminator}} cir.br ^a ^a: @@ -53,7 +51,7 @@ cir.func @yield0() { #false = #cir.bool : !cir.bool #true = #cir.bool : !cir.bool cir.func @yieldbreak() { - %0 = cir.const(#true) : !cir.bool + %0 = cir.const #true cir.if %0 { cir.break // expected-error {{op must be within a loop or switch}} } @@ -65,7 +63,7 @@ cir.func @yieldbreak() { #false = #cir.bool : !cir.bool #true = #cir.bool : !cir.bool cir.func @yieldcontinue() { - %0 = cir.const(#true) : !cir.bool + %0 = cir.const #true cir.if %0 { cir.continue // expected-error {{op must be within a loop}} } @@ -76,10 +74,10 @@ cir.func @yieldcontinue() { !s32i = !cir.int cir.func @s0() { - %1 = cir.const(#cir.int<2> : !s32i) : !s32i + %1 = cir.const #cir.int<2> : !s32i cir.switch (%1 : !s32i) [ case (equal, 5) { // expected-error {{custom op 'cir.switch' case regions must be explicitly terminated}} - %2 = cir.const(#cir.int<3> : !s32i) : !s32i + %2 = cir.const #cir.int<3> : !s32i } ] cir.return @@ -89,7 +87,7 @@ cir.func @s0() { !s32i = !cir.int cir.func @s1() { - %1 = cir.const(#cir.int<2> : !s32i) : !s32i + %1 = cir.const #cir.int<2> : !s32i cir.switch (%1 : !s32i) [ case (equal, 5) { } @@ -100,7 +98,7 @@ cir.func @s1() { // ----- cir.func @badstride(%x: !cir.ptr>) { - %idx = cir.const(#cir.int<2> : !cir.int) : !cir.int + %idx = cir.const #cir.int<2> : !cir.int %4 = cir.ptr_stride(%x : !cir.ptr>, %idx : !cir.int), !cir.ptr // expected-error {{requires the same type for first operand and result}} cir.return } @@ -365,7 +363,7 @@ module { !s32i = !cir.int cir.func @vec_op_size() { - %0 = cir.const(#cir.int<1> : !s32i) : !s32i + %0 = cir.const #cir.int<1> : !s32i %1 = cir.vec.create(%0 : !s32i) : !cir.vector // expected-error {{'cir.vec.create' op operand count of 1 doesn't match vector type '!cir.vector x 2>' element count of 2}} cir.return } @@ -375,8 +373,8 @@ cir.func @vec_op_size() { !s32i = !cir.int !u32i = !cir.int cir.func @vec_op_type() { - %0 = cir.const(#cir.int<1> : !s32i) : !s32i - %1 = cir.const(#cir.int<2> : !u32i) : !u32i + %0 = cir.const #cir.int<1> : !s32i + %1 = cir.const #cir.int<2> : !u32i %2 = cir.vec.create(%0, %1 : !s32i, !u32i) : !cir.vector // expected-error {{'cir.vec.create' op operand type '!cir.int' doesn't match vector element type '!cir.int'}} cir.return } @@ -385,8 +383,8 @@ cir.func @vec_op_type() { !s32i = !cir.int cir.func @vec_extract_non_int_idx() { - %0 = cir.const(1.5e+00 : f64) : f64 - %1 = cir.const(#cir.int<0> : !s32i) : !s32i + %0 = cir.const 1.5e+00 : f64 + %1 = cir.const #cir.int<0> : !s32i %2 = cir.vec.create(%1, %1 : !s32i, !s32i) : !cir.vector %3 = cir.vec.extract %2[%0 : f64] : !cir.vector // expected-error {{expected '<'}} cir.return @@ -398,7 +396,7 @@ cir.func @vec_extract_non_int_idx() { !u32i = !cir.int cir.func @vec_extract_bad_type() { %0 = cir.alloca !u32i, !cir.ptr, ["x", init] {alignment = 4 : i64} - %1 = cir.const(#cir.int<0> : !s32i) : !s32i + %1 = cir.const #cir.int<0> : !s32i %2 = cir.vec.create(%1, %1 : !s32i, !s32i) : !cir.vector %3 = cir.vec.extract %2[%1 : !s32i] : !cir.vector // expected-note {{prior use here}} cir.store %3, %0 : !u32i, !cir.ptr // expected-error {{use of value '%3' expects different type than prior uses: '!cir.int' vs '!cir.int'}} @@ -409,7 +407,7 @@ cir.func @vec_extract_bad_type() { !s32i = !cir.int cir.func @vec_extract_non_vector() { - %0 = cir.const(#cir.int<0> : !s32i) : !s32i + %0 = cir.const #cir.int<0> : !s32i %1 = cir.vec.extract %0[%0 : !s32i] : !s32i // expected-error {{custom op 'cir.vec.extract' 'vec' must be CIR vector type, but got '!cir.int'}} cir.return } @@ -419,9 +417,9 @@ cir.func @vec_extract_non_vector() { !s32i = !cir.int !u32i = !cir.int cir.func @vec_insert_bad_type() { - %0 = cir.const(#cir.int<0> : !s32i) : !s32i + %0 = cir.const #cir.int<0> : !s32i %1 = cir.vec.create(%0, %0 : !s32i, !s32i) : !cir.vector - %2 = cir.const(#cir.int<0> : !u32i) : !u32i // expected-note {{prior use here}} + %2 = cir.const #cir.int<0> : !u32i // expected-note {{prior use here}} %3 = cir.vec.insert %2, %1[%0 : !s32i] : !cir.vector // expected-error {{use of value '%2' expects different type than prior uses: '!cir.int' vs '!cir.int'}} cir.return } @@ -430,7 +428,7 @@ cir.func @vec_insert_bad_type() { !s32i = !cir.int cir.func @vec_insert_non_vector() { - %0 = cir.const(#cir.int<0> : !s32i) : !s32i + %0 = cir.const #cir.int<0> : !s32i %1 = cir.vec.insert %0, %0[%0 : !s32i] : !s32i // expected-error {{custom op 'cir.vec.insert' 'vec' must be CIR vector type, but got '!cir.int'}} cir.return } @@ -439,7 +437,7 @@ cir.func @vec_insert_non_vector() { !s32i = !cir.int cir.func @vec_ternary_non_vector1() { - %0 = cir.const(#cir.int<0> : !s32i) : !s32i + %0 = cir.const #cir.int<0> : !s32i %1 = cir.vec.create(%0, %0 : !s32i, !s32i) : !cir.vector %2 = cir.vec.ternary(%0, %1, %1) : !s32i, !cir.vector // expected-error {{'cir.vec.ternary' op operand #0 must be !cir.vector of !cir.int, but got '!cir.int'}} cir.return @@ -449,7 +447,7 @@ cir.func @vec_ternary_non_vector1() { !s32i = !cir.int cir.func @vec_ternary_non_vector2() { - %0 = cir.const(#cir.int<0> : !s32i) : !s32i + %0 = cir.const #cir.int<0> : !s32i %1 = cir.vec.create(%0, %0 : !s32i, !s32i) : !cir.vector %2 = cir.vec.ternary(%1, %0, %0) : !cir.vector, !s32i // expected-error {{'cir.vec.ternary' op operand #1 must be CIR vector type, but got '!cir.int'}} cir.return @@ -459,7 +457,7 @@ cir.func @vec_ternary_non_vector2() { !s32i = !cir.int cir.func @vec_ternary_different_size() { - %0 = cir.const(#cir.int<0> : !s32i) : !s32i + %0 = cir.const #cir.int<0> : !s32i %1 = cir.vec.create(%0, %0 : !s32i, !s32i) : !cir.vector %2 = cir.vec.create(%0, %0, %0, %0 : !s32i, !s32i, !s32i, !s32i) : !cir.vector %3 = cir.vec.ternary(%1, %2, %2) : !cir.vector, !cir.vector // expected-error {{'cir.vec.ternary' op : the number of elements in '!cir.vector x 2>' and '!cir.vector x 4>' don't match}} @@ -621,7 +619,7 @@ module { !s32i = !cir.int cir.func @test_br() -> !s32i { - %0 = cir.const(#cir.int<0>: !s32i) : !s32i + %0 = cir.const #cir.int<0>: !s32i // expected-error@below {{branch has 1 operands for successor #0, but target block has 0}} cir.br ^bb1(%0 : !s32i) ^bb1: @@ -829,16 +827,6 @@ module { // ----- -!s8i = !cir.int -!u8i = !cir.int -cir.func @const_type_mismatch() -> () { - // expected-error@+1 {{'cir.const' op result type ('!cir.int') does not match value type ('!cir.int')}} - %2 = cir.const(#cir.int<0> : !s8i) : !u8i - cir.return -} - -// ----- - !u16i = !cir.int // expected-error@+1 {{invalid kind of type specified}} @@ -1044,7 +1032,7 @@ cir.func @bad_fetch(%x: !cir.ptr, %y: !cir.float) -> () { cir.func @bad_operands_for_nowrap(%x: !cir.float, %y: !cir.float) { // expected-error@+1 {{only operations on integer values may have nsw/nuw flags}} - %0 = cir.binop(add, %x, %y) nsw : !cir.float + %0 = cir.binop(add, %x, %y) nsw : !cir.float } // ----- diff --git a/clang/test/CIR/IR/ptr_stride.cir b/clang/test/CIR/IR/ptr_stride.cir index 750e5764a72f..6791f830fd48 100644 --- a/clang/test/CIR/IR/ptr_stride.cir +++ b/clang/test/CIR/IR/ptr_stride.cir @@ -6,7 +6,7 @@ module { %0 = cir.alloca !cir.array, !cir.ptr>, ["x", init] %1 = cir.cast(int_to_bool, %arg0 : !s32i), !cir.bool %2 = cir.cast(array_to_ptrdecay, %0 : !cir.ptr>), !cir.ptr - %3 = cir.const(#cir.int<0> : !s32i) : !s32i + %3 = cir.const #cir.int<0> : !s32i %4 = cir.ptr_stride(%2 : !cir.ptr, %3 : !s32i), !cir.ptr cir.return } @@ -16,7 +16,7 @@ module { // CHECK-NEXT: %0 = cir.alloca !cir.array, !cir.ptr>, ["x", init] // CHECK-NEXT: %1 = cir.cast(int_to_bool, %arg0 : !s32i), !cir.bool // CHECK-NEXT: %2 = cir.cast(array_to_ptrdecay, %0 : !cir.ptr>), !cir.ptr -// CHECK-NEXT: %3 = cir.const(#cir.int<0> : !s32i) : !s32i +// CHECK-NEXT: %3 = cir.const #cir.int<0> : !s32i // CHECK-NEXT: %4 = cir.ptr_stride(%2 : !cir.ptr, %3 : !s32i), !cir.ptr // CHECK-NEXT: cir.return // CHECK-NEXT: } diff --git a/clang/test/CIR/IR/struct.cir b/clang/test/CIR/IR/struct.cir index b44b0d3eeee3..abaaf8766e4b 100644 --- a/clang/test/CIR/IR/struct.cir +++ b/clang/test/CIR/IR/struct.cir @@ -34,8 +34,8 @@ module { // CHECK: %1 = cir.alloca !cir.ptr, !cir.ptr>, ["i", init] cir.func @shouldSuccessfullyParseConstStructAttrs() { - %0 = cir.const(#cir.const_struct<{#cir.int<1> : !s32i, #cir.int<2> : !s32i}> : !ty_22S122) : !ty_22S122 - // CHECK: cir.const(#cir.const_struct<{#cir.int<1> : !s32i, #cir.int<2> : !s32i}> : !ty_22S122) : !ty_22S122 + %0 = cir.const #cir.const_struct<{#cir.int<1> : !s32i, #cir.int<2> : !s32i}> : !ty_22S122 + // CHECK: cir.const #cir.const_struct<{#cir.int<1> : !s32i, #cir.int<2> : !s32i}> : !ty_22S122 cir.return } } diff --git a/clang/test/CIR/IR/switch.cir b/clang/test/CIR/IR/switch.cir index db63a2928862..b5c0c9cafb6c 100644 --- a/clang/test/CIR/IR/switch.cir +++ b/clang/test/CIR/IR/switch.cir @@ -2,7 +2,7 @@ !s32i = !cir.int cir.func @s0() { - %1 = cir.const(#cir.int<2> : !s32i) : !s32i + %1 = cir.const #cir.int<2> : !s32i cir.switch (%1 : !s32i) [ case (default) { cir.return diff --git a/clang/test/CIR/IR/ternary.cir b/clang/test/CIR/IR/ternary.cir index 127d8ed8f2dc..3827dc77726d 100644 --- a/clang/test/CIR/IR/ternary.cir +++ b/clang/test/CIR/IR/ternary.cir @@ -4,10 +4,10 @@ module { cir.func @blue(%arg0: !cir.bool) -> !u32i { %0 = cir.ternary(%arg0, true { - %a = cir.const(#cir.int<0> : !u32i) : !u32i + %a = cir.const #cir.int<0> : !u32i cir.yield %a : !u32i }, false { - %b = cir.const(#cir.int<1> : !u32i) : !u32i + %b = cir.const #cir.int<1> : !u32i cir.yield %b : !u32i }) : (!cir.bool) -> !u32i cir.return %0 : !u32i @@ -18,10 +18,10 @@ module { // CHECK: cir.func @blue(%arg0: !cir.bool) -> !u32i { // CHECK: %0 = cir.ternary(%arg0, true { -// CHECK: %1 = cir.const(#cir.int<0> : !u32i) : !u32i +// CHECK: %1 = cir.const #cir.int<0> : !u32i // CHECK: cir.yield %1 : !u32i // CHECK: }, false { -// CHECK: %1 = cir.const(#cir.int<1> : !u32i) : !u32i +// CHECK: %1 = cir.const #cir.int<1> : !u32i // CHECK: cir.yield %1 : !u32i // CHECK: }) : (!cir.bool) -> !u32i // CHECK: cir.return %0 : !u32i diff --git a/clang/test/CIR/IR/try.cir b/clang/test/CIR/IR/try.cir index 2eb186e65f04..3bcb44e070bd 100644 --- a/clang/test/CIR/IR/try.cir +++ b/clang/test/CIR/IR/try.cir @@ -5,7 +5,7 @@ module { cir.func @div(%x : !s32i, %y : !s32i) -> !s32i { - %3 = cir.const(#cir.int<0> : !s32i) : !s32i + %3 = cir.const #cir.int<0> : !s32i cir.return %3 : !s32i } diff --git a/clang/test/CIR/Lowering/OpenMP/parallel.cir b/clang/test/CIR/Lowering/OpenMP/parallel.cir index 2457d929781f..da98868eddb1 100644 --- a/clang/test/CIR/Lowering/OpenMP/parallel.cir +++ b/clang/test/CIR/Lowering/OpenMP/parallel.cir @@ -4,15 +4,15 @@ module { cir.func @omp_parallel() { %0 = cir.alloca !s32i, !cir.ptr, ["y", init] {alignment = 4 : i64} - %1 = cir.const(#cir.int<0> : !s32i) : !s32i + %1 = cir.const #cir.int<0> : !s32i cir.store %1, %0 : !s32i, !cir.ptr omp.parallel { cir.scope { %2 = cir.alloca !s32i, !cir.ptr, ["x", init] {alignment = 4 : i64} - %3 = cir.const(#cir.int<1> : !s32i) : !s32i + %3 = cir.const #cir.int<1> : !s32i cir.store %3, %2 : !s32i, !cir.ptr %4 = cir.load %2 : !cir.ptr, !s32i - %5 = cir.const(#cir.int<1> : !s32i) : !s32i + %5 = cir.const #cir.int<1> : !s32i %6 = cir.binop(add, %4, %5) : !s32i cir.store %6, %0 : !s32i, !cir.ptr } diff --git a/clang/test/CIR/Lowering/ThroughMLIR/binop-unsigned-int.cir b/clang/test/CIR/Lowering/ThroughMLIR/binop-unsigned-int.cir index d9e3c36f80ef..eb5b747d8761 100644 --- a/clang/test/CIR/Lowering/ThroughMLIR/binop-unsigned-int.cir +++ b/clang/test/CIR/Lowering/ThroughMLIR/binop-unsigned-int.cir @@ -7,8 +7,8 @@ module { %0 = cir.alloca !u32i, !cir.ptr, ["a", init] {alignment = 4 : i64} %1 = cir.alloca !u32i, !cir.ptr, ["b", init] {alignment = 4 : i64} %2 = cir.alloca !u32i, !cir.ptr, ["x", init] {alignment = 4 : i64} - %3 = cir.const(#cir.int<2> : !u32i) : !u32i cir.store %3, %0 : !u32i, !cir.ptr - %4 = cir.const(#cir.int<1> : !u32i) : !u32i cir.store %4, %1 : !u32i, !cir.ptr + %3 = cir.const #cir.int<2> : !u32i cir.store %3, %0 : !u32i, !cir.ptr + %4 = cir.const #cir.int<1> : !u32i cir.store %4, %1 : !u32i, !cir.ptr %5 = cir.load %0 : !cir.ptr, !u32i %6 = cir.load %1 : !cir.ptr, !u32i %7 = cir.binop(mul, %5, %6) : !u32i diff --git a/clang/test/CIR/Lowering/ThroughMLIR/bool.cir b/clang/test/CIR/Lowering/ThroughMLIR/bool.cir index 1b41d8b1d0f7..408cac97ee41 100644 --- a/clang/test/CIR/Lowering/ThroughMLIR/bool.cir +++ b/clang/test/CIR/Lowering/ThroughMLIR/bool.cir @@ -6,7 +6,7 @@ module { cir.func @foo() { %0 = cir.alloca !cir.bool, !cir.ptr, ["a", init] {alignment = 1 : i64} - %1 = cir.const(#true) : !cir.bool + %1 = cir.const #true cir.store %1, %0 : !cir.bool, !cir.ptr cir.return } diff --git a/clang/test/CIR/Lowering/ThroughMLIR/branch.cir b/clang/test/CIR/Lowering/ThroughMLIR/branch.cir index 83c980838890..2b78484627d5 100644 --- a/clang/test/CIR/Lowering/ThroughMLIR/branch.cir +++ b/clang/test/CIR/Lowering/ThroughMLIR/branch.cir @@ -5,10 +5,10 @@ cir.func @foo(%arg0: !cir.bool) -> !s32i { cir.brcond %arg0 ^bb1, ^bb2 ^bb1: - %0 = cir.const(#cir.int<1>: !s32i) : !s32i + %0 = cir.const #cir.int<1>: !s32i cir.return %0 : !s32i ^bb2: - %1 = cir.const(#cir.int<0>: !s32i) : !s32i + %1 = cir.const #cir.int<0>: !s32i cir.return %1 : !s32i } diff --git a/clang/test/CIR/Lowering/ThroughMLIR/cos.cir b/clang/test/CIR/Lowering/ThroughMLIR/cos.cir index 0530d3cb19e8..93b102b7a854 100644 --- a/clang/test/CIR/Lowering/ThroughMLIR/cos.cir +++ b/clang/test/CIR/Lowering/ThroughMLIR/cos.cir @@ -3,10 +3,10 @@ module { cir.func @foo() { - %1 = cir.const(#cir.fp<1.0> : !cir.float) : !cir.float - %2 = cir.const(#cir.fp<1.0> : !cir.double) : !cir.double - %3 = cir.const(#cir.fp<1.0> : !cir.long_double) : !cir.long_double - %4 = cir.const(#cir.fp<1.0> : !cir.long_double) : !cir.long_double + %1 = cir.const #cir.fp<1.0> : !cir.float + %2 = cir.const #cir.fp<1.0> : !cir.double + %3 = cir.const #cir.fp<1.0> : !cir.long_double + %4 = cir.const #cir.fp<1.0> : !cir.long_double %5 = cir.cos %1 : !cir.float %6 = cir.cos %2 : !cir.double %7 = cir.cos %3 : !cir.long_double diff --git a/clang/test/CIR/Lowering/ThroughMLIR/dot.cir b/clang/test/CIR/Lowering/ThroughMLIR/dot.cir index ff73eca3667f..27ab0e9c33f6 100644 --- a/clang/test/CIR/Lowering/ThroughMLIR/dot.cir +++ b/clang/test/CIR/Lowering/ThroughMLIR/dot.cir @@ -11,7 +11,7 @@ module { cir.store %arg0, %0 : !cir.ptr, !cir.ptr> %3 = cir.load %0 : !cir.ptr>, !cir.ptr cir.store %3, %2 : !cir.ptr, !cir.ptr> - %4 = cir.const(#cir.int<0> : !s32i) : !s32i + %4 = cir.const #cir.int<0> : !s32i %5 = cir.load %1 : !cir.ptr, !s32i cir.return %5 : !s32i } diff --git a/clang/test/CIR/Lowering/ThroughMLIR/goto.cir b/clang/test/CIR/Lowering/ThroughMLIR/goto.cir index 170366d55af9..6c1d5c66fffa 100644 --- a/clang/test/CIR/Lowering/ThroughMLIR/goto.cir +++ b/clang/test/CIR/Lowering/ThroughMLIR/goto.cir @@ -5,18 +5,18 @@ module { cir.func @foo() { %0 = cir.alloca !u32i, !cir.ptr, ["b", init] {alignment = 4 : i64} - %1 = cir.const(#cir.int<1> : !u32i) : !u32i + %1 = cir.const #cir.int<1> : !u32i cir.store %1, %0 : !u32i, !cir.ptr cir.br ^bb2 ^bb1: // no predecessors %2 = cir.load %0 : !cir.ptr, !u32i - %3 = cir.const(#cir.int<1> : !u32i) : !u32i + %3 = cir.const #cir.int<1> : !u32i %4 = cir.binop(add, %2, %3) : !u32i cir.store %4, %0 : !u32i, !cir.ptr cir.br ^bb2 ^bb2: // 2 preds: ^bb0, ^bb1 %5 = cir.load %0 : !cir.ptr, !u32i - %6 = cir.const(#cir.int<2> : !u32i) : !u32i + %6 = cir.const #cir.int<2> : !u32i %7 = cir.binop(add, %5, %6) : !u32i cir.store %7, %0 : !u32i, !cir.ptr cir.return diff --git a/clang/test/CIR/Lowering/ThroughMLIR/memref.cir b/clang/test/CIR/Lowering/ThroughMLIR/memref.cir index 8aabe4cd0ffa..d51c4425d702 100644 --- a/clang/test/CIR/Lowering/ThroughMLIR/memref.cir +++ b/clang/test/CIR/Lowering/ThroughMLIR/memref.cir @@ -5,7 +5,7 @@ module { cir.func @foo() -> !u32i { %0 = cir.alloca !u32i, !cir.ptr, ["x", init] {alignment = 4 : i64} - %1 = cir.const(#cir.int<1> : !u32i) : !u32i + %1 = cir.const #cir.int<1> : !u32i cir.store %1, %0 : !u32i, !cir.ptr %2 = cir.load %0 : !cir.ptr, !u32i cir.return %2 : !u32i diff --git a/clang/test/CIR/Lowering/ThroughMLIR/scope.cir b/clang/test/CIR/Lowering/ThroughMLIR/scope.cir index 779363e21b2f..cf5effc02ce6 100644 --- a/clang/test/CIR/Lowering/ThroughMLIR/scope.cir +++ b/clang/test/CIR/Lowering/ThroughMLIR/scope.cir @@ -8,7 +8,7 @@ module { cir.func @foo() { cir.scope { %0 = cir.alloca !u32i, !cir.ptr, ["a", init] {alignment = 4 : i64} - %1 = cir.const(#cir.int<4> : !u32i) : !u32i + %1 = cir.const #cir.int<4> : !u32i cir.store %1, %0 : !u32i, !cir.ptr } cir.return diff --git a/clang/test/CIR/Lowering/ThroughMLIR/tenary.cir b/clang/test/CIR/Lowering/ThroughMLIR/tenary.cir index e1cae6aa9bd4..bcac62912fa9 100644 --- a/clang/test/CIR/Lowering/ThroughMLIR/tenary.cir +++ b/clang/test/CIR/Lowering/ThroughMLIR/tenary.cir @@ -10,13 +10,13 @@ cir.func @_Z1xi(%arg0: !s32i) -> !s32i { %1 = cir.alloca !s32i, !cir.ptr, ["__retval"] {alignment = 4 : i64} cir.store %arg0, %0 : !s32i, !cir.ptr %2 = cir.load %0 : !cir.ptr, !s32i - %3 = cir.const(#cir.int<0> : !s32i) : !s32i + %3 = cir.const #cir.int<0> : !s32i %4 = cir.cmp(gt, %2, %3) : !s32i, !cir.bool %5 = cir.ternary(%4, true { - %7 = cir.const(#cir.int<3> : !s32i) : !s32i + %7 = cir.const #cir.int<3> : !s32i cir.yield %7 : !s32i }, false { - %7 = cir.const(#cir.int<5> : !s32i) : !s32i + %7 = cir.const #cir.int<5> : !s32i cir.yield %7 : !s32i }) : (!cir.bool) -> !s32i cir.store %5, %1 : !s32i, !cir.ptr diff --git a/clang/test/CIR/Lowering/ThroughMLIR/unary-inc-dec.cir b/clang/test/CIR/Lowering/ThroughMLIR/unary-inc-dec.cir index 13fef83e435a..1db339fe34fc 100644 --- a/clang/test/CIR/Lowering/ThroughMLIR/unary-inc-dec.cir +++ b/clang/test/CIR/Lowering/ThroughMLIR/unary-inc-dec.cir @@ -6,7 +6,7 @@ module { cir.func @foo() { %0 = cir.alloca !s32i, !cir.ptr, ["a", init] {alignment = 4 : i64} %1 = cir.alloca !s32i, !cir.ptr, ["b", init] {alignment = 4 : i64} - %2 = cir.const(#cir.int<2> : !s32i) : !s32i + %2 = cir.const #cir.int<2> : !s32i cir.store %2, %0 : !s32i, !cir.ptr cir.store %2, %1 : !s32i, !cir.ptr diff --git a/clang/test/CIR/Lowering/ThroughMLIR/unary-plus-minus.cir b/clang/test/CIR/Lowering/ThroughMLIR/unary-plus-minus.cir index c013be35dfe7..ecb7e7ef6734 100644 --- a/clang/test/CIR/Lowering/ThroughMLIR/unary-plus-minus.cir +++ b/clang/test/CIR/Lowering/ThroughMLIR/unary-plus-minus.cir @@ -6,7 +6,7 @@ module { cir.func @foo() { %0 = cir.alloca !s32i, !cir.ptr, ["a", init] {alignment = 4 : i64} %1 = cir.alloca !s32i, !cir.ptr, ["b", init] {alignment = 4 : i64} - %2 = cir.const(#cir.int<2> : !s32i) : !s32i + %2 = cir.const #cir.int<2> : !s32i cir.store %2, %0 : !s32i, !cir.ptr cir.store %2, %1 : !s32i, !cir.ptr diff --git a/clang/test/CIR/Lowering/binop-signed-int.cir b/clang/test/CIR/Lowering/binop-signed-int.cir index 8ce730ad5234..5f028a6c901b 100644 --- a/clang/test/CIR/Lowering/binop-signed-int.cir +++ b/clang/test/CIR/Lowering/binop-signed-int.cir @@ -7,8 +7,8 @@ module { %0 = cir.alloca !s32i, !cir.ptr, ["a", init] {alignment = 4 : i64} %1 = cir.alloca !s32i, !cir.ptr, ["b", init] {alignment = 4 : i64} %2 = cir.alloca !s32i, !cir.ptr, ["x", init] {alignment = 4 : i64} - %3 = cir.const(#cir.int<2> : !s32i) : !s32i cir.store %3, %0 : !s32i, !cir.ptr - %4 = cir.const(#cir.int<1> : !s32i) : !s32i cir.store %4, %1 : !s32i, !cir.ptr + %3 = cir.const #cir.int<2> : !s32i cir.store %3, %0 : !s32i, !cir.ptr + %4 = cir.const #cir.int<1> : !s32i cir.store %4, %1 : !s32i, !cir.ptr %5 = cir.load %0 : !cir.ptr, !s32i %6 = cir.load %1 : !cir.ptr, !s32i %7 = cir.binop(mul, %5, %6) : !s32i diff --git a/clang/test/CIR/Lowering/binop-unsigned-int.cir b/clang/test/CIR/Lowering/binop-unsigned-int.cir index 53066225857a..9633a7f4d966 100644 --- a/clang/test/CIR/Lowering/binop-unsigned-int.cir +++ b/clang/test/CIR/Lowering/binop-unsigned-int.cir @@ -7,8 +7,8 @@ module { %0 = cir.alloca !u32i, !cir.ptr, ["a", init] {alignment = 4 : i64} %1 = cir.alloca !u32i, !cir.ptr, ["b", init] {alignment = 4 : i64} %2 = cir.alloca !u32i, !cir.ptr, ["x", init] {alignment = 4 : i64} - %3 = cir.const(#cir.int<2> : !u32i) : !u32i cir.store %3, %0 : !u32i, !cir.ptr - %4 = cir.const(#cir.int<1> : !u32i) : !u32i cir.store %4, %1 : !u32i, !cir.ptr + %3 = cir.const #cir.int<2> : !u32i cir.store %3, %0 : !u32i, !cir.ptr + %4 = cir.const #cir.int<1> : !u32i cir.store %4, %1 : !u32i, !cir.ptr %5 = cir.load %0 : !cir.ptr, !u32i %6 = cir.load %1 : !cir.ptr, !u32i %7 = cir.binop(mul, %5, %6) : !u32i diff --git a/clang/test/CIR/Lowering/bool-to-int.cir b/clang/test/CIR/Lowering/bool-to-int.cir index d7e2e45686cc..1b4bb73f80f9 100644 --- a/clang/test/CIR/Lowering/bool-to-int.cir +++ b/clang/test/CIR/Lowering/bool-to-int.cir @@ -6,12 +6,12 @@ module { cir.func @foo(%arg0: !s32i, %arg1: !s32i) -> !s32i { - %1 = cir.const(#true) : !cir.bool + %1 = cir.const #true %2 = cir.cast(bool_to_int, %1 : !cir.bool), !s32i cir.return %2 : !s32i } cir.func @bar(%arg0: !s32i, %arg1: !s32i) -> !s32i { - %1 = cir.const(#false) : !cir.bool + %1 = cir.const #false %2 = cir.cast(bool_to_int, %1 : !cir.bool), !s32i cir.return %2 : !s32i } diff --git a/clang/test/CIR/Lowering/bool.cir b/clang/test/CIR/Lowering/bool.cir index fb94f8135a4b..ee743e8376fa 100644 --- a/clang/test/CIR/Lowering/bool.cir +++ b/clang/test/CIR/Lowering/bool.cir @@ -10,7 +10,7 @@ module { // LLVM: @g_bl = global i8 0 cir.func @foo() { - %1 = cir.const(#true) : !cir.bool + %1 = cir.const #true %0 = cir.alloca !cir.bool, !cir.ptr, ["a", init] {alignment = 1 : i64} cir.store %1, %0 : !cir.bool, !cir.ptr cir.return diff --git a/clang/test/CIR/Lowering/branch.cir b/clang/test/CIR/Lowering/branch.cir index 90e143913d50..bbfb61e582a0 100644 --- a/clang/test/CIR/Lowering/branch.cir +++ b/clang/test/CIR/Lowering/branch.cir @@ -5,10 +5,10 @@ cir.func @foo(%arg0: !cir.bool) -> !s32i { cir.brcond %arg0 ^bb1, ^bb2 ^bb1: - %0 = cir.const(#cir.int<1>: !s32i) : !s32i + %0 = cir.const #cir.int<1>: !s32i cir.return %0 : !s32i ^bb2: - %1 = cir.const(#cir.int<0>: !s32i) : !s32i + %1 = cir.const #cir.int<0>: !s32i cir.return %1 : !s32i } diff --git a/clang/test/CIR/Lowering/cast.cir b/clang/test/CIR/Lowering/cast.cir index f6ec6a94be91..e100e0c2f07e 100644 --- a/clang/test/CIR/Lowering/cast.cir +++ b/clang/test/CIR/Lowering/cast.cir @@ -24,7 +24,7 @@ module { %8 = cir.alloca !cir.ptr, !cir.ptr>, ["e", init] {alignment = 8 : i64} cir.store %arg0, %0 : !u32i, !cir.ptr cir.store %arg1, %1 : !s32i, !cir.ptr - + // Integer casts. %9 = cir.load %0 : !cir.ptr, !u32i %10 = cir.cast(integral, %9 : !u32i), !s8i @@ -73,7 +73,7 @@ module { // CHECK: %{{.+}} = llvm.fptosi %{{.+}} : f32 to i32 %28 = cir.cast(float_to_int, %arg2 : !cir.float), !u32i // CHECK: %{{.+}} = llvm.fptoui %{{.+}} : f32 to i32 - %18 = cir.const(#cir.int<0> : !s32i) : !s32i + %18 = cir.const #cir.int<0> : !s32i // CHECK: %{{.+}} = llvm.fptrunc %{{.+}} : f64 to f32 %34 = cir.cast(floating, %arg3 : !cir.double), !cir.float diff --git a/clang/test/CIR/Lowering/class.cir b/clang/test/CIR/Lowering/class.cir index cc5046be57ac..75366182ad3c 100644 --- a/clang/test/CIR/Lowering/class.cir +++ b/clang/test/CIR/Lowering/class.cir @@ -24,7 +24,7 @@ module { cir.func @shouldConstInitLocalClassesWithConstStructAttr() { %0 = cir.alloca !ty_22S2A22, !cir.ptr, ["s"] {alignment = 4 : i64} - %1 = cir.const(#cir.const_struct<{#cir.int<1> : !s32i}> : !ty_22S2A22) : !ty_22S2A22 + %1 = cir.const #cir.const_struct<{#cir.int<1> : !s32i}> : !ty_22S2A22 cir.store %1, %0 : !ty_22S2A22, !cir.ptr cir.return } diff --git a/clang/test/CIR/Lowering/const.cir b/clang/test/CIR/Lowering/const.cir index 396006541a1c..7ac57b833fed 100644 --- a/clang/test/CIR/Lowering/const.cir +++ b/clang/test/CIR/Lowering/const.cir @@ -7,23 +7,23 @@ !ty_22anon2E122 = !cir.struct, !cir.int} #cir.record.decl.ast> module { cir.func @testConstArrInit() { - %0 = cir.const(#cir.const_array<"string\00" : !cir.array> : !cir.array) : !cir.array + %0 = cir.const #cir.const_array<"string\00" : !cir.array> : !cir.array // CHECK: llvm.mlir.constant(dense<[115, 116, 114, 105, 110, 103, 0]> : tensor<7xi8>) : !llvm.array<7 x i8> - %1 = cir.const(#cir.const_array<[#cir.int<1> : !s32i, #cir.int<2> : !s32i]> : !cir.array) : !cir.array + %1 = cir.const #cir.const_array<[#cir.int<1> : !s32i, #cir.int<2> : !s32i]> : !cir.array // CHECK: llvm.mlir.constant(dense<[1, 2]> : tensor<2xi32>) : !llvm.array<2 x i32> - %3 = cir.const(#cir.const_array<[#cir.fp<1.000000e+00> : !cir.float, #cir.fp<2.000000e+00> : !cir.float]> : !cir.array) : !cir.array + %3 = cir.const #cir.const_array<[#cir.fp<1.000000e+00> : !cir.float, #cir.fp<2.000000e+00> : !cir.float]> : !cir.array // CHECK: llvm.mlir.constant(dense<[1.000000e+00, 2.000000e+00]> : tensor<2xf32>) : !llvm.array<2 x f32> - %4 = cir.const(#cir.zero : !cir.array) : !cir.array + %4 = cir.const #cir.zero : !cir.array // CHECK: cir.llvmir.zeroinit : !llvm.array<3 x i32> cir.return } cir.func @testConvertConstArrayToDenseConst() { - %0 = cir.const(#cir.const_array<[#cir.const_array<[#cir.int<1> : !s32i]> : !cir.array, #cir.zero : !cir.array]> : !cir.array x 2>) : !cir.array x 2> - %1 = cir.const(#cir.const_array<[#cir.const_array<[#cir.int<1> : !s64i]> : !cir.array, #cir.zero : !cir.array]> : !cir.array x 2>) : !cir.array x 2> - %2 = cir.const(#cir.const_array<[#cir.const_array<[#cir.fp<1.000000e+00> : !cir.float]> : !cir.array, #cir.zero : !cir.array]> : !cir.array x 2>) : !cir.array x 2> - %3 = cir.const(#cir.const_array<[#cir.const_array<[#cir.fp<1.000000e+00> : !cir.double]> : !cir.array, #cir.zero : !cir.array]> : !cir.array x 2>) : !cir.array x 2> - %4 = cir.const(#cir.const_array<[#cir.const_array<[#cir.const_array<[#cir.int<1> : !s32i, #cir.int<1> : !s32i, #cir.int<1> : !s32i]> : !cir.array]> : !cir.array x 1>, #cir.zero : !cir.array x 1>]> : !cir.array x 1> x 2>) : !cir.array x 1> x 2> + %0 = cir.const #cir.const_array<[#cir.const_array<[#cir.int<1> : !s32i]> : !cir.array, #cir.zero : !cir.array]> : !cir.array x 2> + %1 = cir.const #cir.const_array<[#cir.const_array<[#cir.int<1> : !s64i]> : !cir.array, #cir.zero : !cir.array]> : !cir.array x 2> + %2 = cir.const #cir.const_array<[#cir.const_array<[#cir.fp<1.000000e+00> : !cir.float]> : !cir.array, #cir.zero : !cir.array]> : !cir.array x 2> + %3 = cir.const #cir.const_array<[#cir.const_array<[#cir.fp<1.000000e+00> : !cir.double]> : !cir.array, #cir.zero : !cir.array]> : !cir.array x 2> + %4 = cir.const #cir.const_array<[#cir.const_array<[#cir.const_array<[#cir.int<1> : !s32i, #cir.int<1> : !s32i, #cir.int<1> : !s32i]> : !cir.array]> : !cir.array x 1>, #cir.zero : !cir.array x 1>]> : !cir.array x 1> x 2> cir.return } @@ -37,7 +37,7 @@ module { cir.func @testConstArrayOfStructs() { %0 = cir.alloca !cir.array, !cir.ptr>, ["a"] {alignment = 4 : i64} - %1 = cir.const(#cir.const_array<[#cir.const_struct<{#cir.int<0> : !s32i, #cir.int<1> : !s32i}> : !ty_22anon2E122]> : !cir.array) : !cir.array + %1 = cir.const #cir.const_array<[#cir.const_struct<{#cir.int<0> : !s32i, #cir.int<1> : !s32i}> : !ty_22anon2E122]> : !cir.array cir.store %1, %0 : !cir.array, !cir.ptr> cir.return } @@ -56,7 +56,7 @@ module { cir.func @testArrWithTrailingZeros() { %0 = cir.alloca !cir.array, !cir.ptr>, ["a"] {alignment = 16 : i64} - %1 = cir.const(#cir.const_array<[#cir.int<1> : !s32i], trailing_zeros> : !cir.array) : !cir.array + %1 = cir.const #cir.const_array<[#cir.int<1> : !s32i], trailing_zeros> : !cir.array cir.store %1, %0 : !cir.array, !cir.ptr> cir.return } @@ -68,7 +68,7 @@ module { // CHECK: %4 = llvm.insertvalue %3, %2[0] : !llvm.array<10 x i32> cir.func @testInitArrWithBool() { - %1 = cir.const(#cir.const_array<[#cir.bool : !cir.bool]> : !cir.array) : !cir.array + %1 = cir.const #cir.const_array<[#cir.bool : !cir.bool]> : !cir.array cir.return } diff --git a/clang/test/CIR/Lowering/dot.cir b/clang/test/CIR/Lowering/dot.cir index 37958b0bfea3..d4823df783a7 100644 --- a/clang/test/CIR/Lowering/dot.cir +++ b/clang/test/CIR/Lowering/dot.cir @@ -12,11 +12,11 @@ module { cir.store %arg0, %0 : !cir.ptr, !cir.ptr> cir.store %arg1, %1 : !cir.ptr, !cir.ptr> cir.store %arg2, %2 : !s32i, !cir.ptr - %5 = cir.const(#cir.fp<0.000000e+00> : !cir.double) : !cir.double + %5 = cir.const #cir.fp<0.000000e+00> : !cir.double cir.store %5, %4 : !cir.double, !cir.ptr cir.scope { %8 = cir.alloca !s32i, !cir.ptr, ["i", init] {alignment = 4 : i64} - %9 = cir.const(#cir.int<0> : !s32i) : !s32i + %9 = cir.const #cir.int<0> : !s32i cir.store %9, %8 : !s32i, !cir.ptr cir.for : cond { %10 = cir.load %8 : !cir.ptr, !s32i diff --git a/clang/test/CIR/Lowering/expect.cir b/clang/test/CIR/Lowering/expect.cir index a221cca5f3dd..64c9c10e6277 100644 --- a/clang/test/CIR/Lowering/expect.cir +++ b/clang/test/CIR/Lowering/expect.cir @@ -4,7 +4,7 @@ !s64i = !cir.int module { cir.func @foo(%arg0: !s64i) { - %0 = cir.const(#cir.int<1> : !s64i) : !s64i + %0 = cir.const #cir.int<1> : !s64i %1 = cir.expect(%arg0, %0) : !s64i %2 = cir.cast(int_to_bool, %1 : !s64i), !cir.bool cir.if %2 { diff --git a/clang/test/CIR/Lowering/float.cir b/clang/test/CIR/Lowering/float.cir index 463768a35935..d4b66500b210 100644 --- a/clang/test/CIR/Lowering/float.cir +++ b/clang/test/CIR/Lowering/float.cir @@ -3,15 +3,15 @@ module { cir.func @test() { - // %0 = cir.const(1.0 : f16) : f16 + // %0 = cir.const 1.0 : f16 // DISABLED-CHECK: %{{.+}} = llvm.mlir.constant(1.000000e+00 : f16) : f16 - %1 = cir.const(#cir.fp<1.0> : !cir.float) : !cir.float + %1 = cir.const #cir.fp<1.0> : !cir.float // CHECK: %{{.+}} = llvm.mlir.constant(1.000000e+00 : f32) : f32 - %2 = cir.const(#cir.fp<1.0> : !cir.double) : !cir.double + %2 = cir.const #cir.fp<1.0> : !cir.double // CHECK: %{{.+}} = llvm.mlir.constant(1.000000e+00 : f64) : f64 - %3 = cir.const(#cir.fp<1.0> : !cir.long_double) : !cir.long_double + %3 = cir.const #cir.fp<1.0> : !cir.long_double // CHECK: %{{.+}} = llvm.mlir.constant(1.000000e+00 : f80) : f80 - // %5 = cir.const(1.0 : bf16) : bf16 + // %5 = cir.const 1.0 : bf16 // DISABLED-CHECK: %{{.+}} = llvm.mlir.constant(1.000000e+00 : bf16) : bf16 cir.return } diff --git a/clang/test/CIR/Lowering/globals.cir b/clang/test/CIR/Lowering/globals.cir index 3bfbd8b21846..e536f02eddda 100644 --- a/clang/test/CIR/Lowering/globals.cir +++ b/clang/test/CIR/Lowering/globals.cir @@ -54,7 +54,7 @@ module { %0 = cir.alloca !u8i, !cir.ptr, ["c", init] {alignment = 1 : i64} %1 = cir.get_global @s2 : !cir.ptr> %2 = cir.load %1 : !cir.ptr>, !cir.ptr - %3 = cir.const(#cir.int<0> : !s32i) : !s32i + %3 = cir.const #cir.int<0> : !s32i %4 = cir.ptr_stride(%2 : !cir.ptr, %3 : !s32i), !cir.ptr %5 = cir.load %4 : !cir.ptr, !s8i %6 = cir.cast(integral, %5 : !s8i), !u8i @@ -63,7 +63,7 @@ module { } cir.func linkonce_odr @_Z4funcIiET_v() -> !s32i { %0 = cir.alloca !s32i, !cir.ptr, ["__retval"] {alignment = 4 : i64} - %1 = cir.const(#cir.int<0> : !s32i) : !s32i + %1 = cir.const #cir.int<0> : !s32i cir.store %1, %0 : !s32i, !cir.ptr %2 = cir.load %0 : !cir.ptr, !s32i cir.return %2 : !s32i @@ -182,8 +182,8 @@ module { cir.global external @zero_array = #cir.zero : !cir.array cir.func @use_zero_array() { - %0 = cir.const(#cir.global_view<@zero_array> : !cir.ptr) : !cir.ptr - %1 = cir.const(#cir.int<0> : !s32i) : !s32i + %0 = cir.const #cir.global_view<@zero_array> : !cir.ptr + %1 = cir.const #cir.int<0> : !s32i %2 = cir.ptr_stride(%0 : !cir.ptr, %1 : !s32i), !cir.ptr %3 = cir.load %2 : !cir.ptr, !s32i cir.return diff --git a/clang/test/CIR/Lowering/goto.cir b/clang/test/CIR/Lowering/goto.cir index 784a8f473724..271666744d6c 100644 --- a/clang/test/CIR/Lowering/goto.cir +++ b/clang/test/CIR/Lowering/goto.cir @@ -6,18 +6,18 @@ module { cir.func @foo() { %0 = cir.alloca !u32i, !cir.ptr, ["b", init] {alignment = 4 : i64} - %1 = cir.const(#cir.int<1> : !u32i) : !u32i + %1 = cir.const #cir.int<1> : !u32i cir.store %1, %0 : !u32i, !cir.ptr cir.br ^bb2 ^bb1: // no predecessors %2 = cir.load %0 : !cir.ptr, !u32i - %3 = cir.const(#cir.int<1> : !u32i) : !u32i + %3 = cir.const #cir.int<1> : !u32i %4 = cir.binop(add, %2, %3) : !u32i cir.store %4, %0 : !u32i, !cir.ptr cir.br ^bb2 ^bb2: // 2 preds: ^bb0, ^bb1 %5 = cir.load %0 : !cir.ptr, !u32i - %6 = cir.const(#cir.int<2> : !u32i) : !u32i + %6 = cir.const #cir.int<2> : !u32i %7 = cir.binop(add, %5, %6) : !u32i cir.store %7, %0 : !u32i, !cir.ptr cir.return diff --git a/clang/test/CIR/Lowering/hello.cir b/clang/test/CIR/Lowering/hello.cir index 3db89230b785..94cc149388a1 100644 --- a/clang/test/CIR/Lowering/hello.cir +++ b/clang/test/CIR/Lowering/hello.cir @@ -12,7 +12,7 @@ module @"/tmp/test.raw" attributes {cir.lang = #cir.lang, cir.sob = #cir.sign %2 = cir.get_global @".str" : !cir.ptr> %3 = cir.cast(array_to_ptrdecay, %2 : !cir.ptr>), !cir.ptr %4 = cir.call @printf(%3) : (!cir.ptr) -> !s32i - %5 = cir.const(#cir.int<0> : !s32i) : !s32i + %5 = cir.const #cir.int<0> : !s32i cir.store %5, %0 : !s32i, !cir.ptr %6 = cir.load %0 : !cir.ptr, !s32i cir.return %6 : !s32i diff --git a/clang/test/CIR/Lowering/if.cir b/clang/test/CIR/Lowering/if.cir index eac0b5e4467e..cd42497983e4 100644 --- a/clang/test/CIR/Lowering/if.cir +++ b/clang/test/CIR/Lowering/if.cir @@ -6,10 +6,10 @@ module { cir.func @foo(%arg0: !s32i) -> !s32i { %4 = cir.cast(int_to_bool, %arg0 : !s32i), !cir.bool cir.if %4 { - %5 = cir.const(#cir.int<1> : !s32i) : !s32i + %5 = cir.const #cir.int<1> : !s32i cir.return %5 : !s32i } else { - %5 = cir.const(#cir.int<0> : !s32i) : !s32i + %5 = cir.const #cir.int<0> : !s32i cir.return %5 : !s32i } cir.return %arg0 : !s32i @@ -46,7 +46,7 @@ module { cir.func @onlyIf(%arg0: !s32i) -> !s32i { %4 = cir.cast(int_to_bool, %arg0 : !s32i), !cir.bool cir.if %4 { - %5 = cir.const(#cir.int<1> : !s32i) : !s32i + %5 = cir.const #cir.int<1> : !s32i cir.return %5 : !s32i } cir.return %arg0 : !s32i diff --git a/clang/test/CIR/Lowering/int-wrap.cir b/clang/test/CIR/Lowering/int-wrap.cir index ca4ee05b5354..b6b8bd385b89 100644 --- a/clang/test/CIR/Lowering/int-wrap.cir +++ b/clang/test/CIR/Lowering/int-wrap.cir @@ -7,7 +7,7 @@ module { %0 = cir.alloca !s32i, !cir.ptr, ["len", init] {alignment = 4 : i64} cir.store %arg0, %0 : !s32i, !cir.ptr %1 = cir.load %0 : !cir.ptr, !s32i - %2 = cir.const(#cir.int<42> : !s32i) : !s32i + %2 = cir.const #cir.int<42> : !s32i %3 = cir.binop(sub, %1, %2) nsw : !s32i %4 = cir.binop(sub, %1, %2) nuw : !s32i %5 = cir.binop(sub, %1, %2) : !s32i diff --git a/clang/test/CIR/Lowering/loadstorealloca.cir b/clang/test/CIR/Lowering/loadstorealloca.cir index e2fce2972385..f6d3a6eb521f 100644 --- a/clang/test/CIR/Lowering/loadstorealloca.cir +++ b/clang/test/CIR/Lowering/loadstorealloca.cir @@ -5,7 +5,7 @@ module { cir.func @foo() -> !u32i { %0 = cir.alloca !u32i, !cir.ptr, ["x", init] {alignment = 4 : i64} - %1 = cir.const(#cir.int<1> : !u32i) : !u32i + %1 = cir.const #cir.int<1> : !u32i cir.store %1, %0 : !u32i, !cir.ptr %2 = cir.load %0 : !cir.ptr, !u32i cir.return %2 : !u32i @@ -13,7 +13,7 @@ module { cir.func @test_volatile() -> !u32i { %0 = cir.alloca !u32i, !cir.ptr, ["x", init] {alignment = 4 : i64} - %1 = cir.const(#cir.int<1> : !u32i) : !u32i + %1 = cir.const #cir.int<1> : !u32i cir.store volatile %1, %0 : !u32i, !cir.ptr %2 = cir.load volatile %0 : !cir.ptr, !u32i cir.return %2 : !u32i diff --git a/clang/test/CIR/Lowering/loops-with-break.cir b/clang/test/CIR/Lowering/loops-with-break.cir index 02af716f703e..34b6bfd7618e 100644 --- a/clang/test/CIR/Lowering/loops-with-break.cir +++ b/clang/test/CIR/Lowering/loops-with-break.cir @@ -6,11 +6,11 @@ module { cir.func @testFor() { cir.scope { %0 = cir.alloca !s32i, !cir.ptr, ["i", init] {alignment = 4 : i64} - %1 = cir.const(#cir.int<1> : !s32i) : !s32i + %1 = cir.const #cir.int<1> : !s32i cir.store %1, %0 : !s32i, !cir.ptr cir.for : cond { %2 = cir.load %0 : !cir.ptr, !s32i - %3 = cir.const(#cir.int<10> : !s32i) : !s32i + %3 = cir.const #cir.int<10> : !s32i %4 = cir.cmp(lt, %2, %3) : !s32i, !s32i %5 = cir.cast(int_to_bool, %4 : !s32i), !cir.bool cir.condition(%5) @@ -18,7 +18,7 @@ module { cir.scope { cir.scope { %2 = cir.load %0 : !cir.ptr, !s32i - %3 = cir.const(#cir.int<5> : !s32i) : !s32i + %3 = cir.const #cir.int<5> : !s32i %4 = cir.cmp(eq, %2, %3) : !s32i, !s32i %5 = cir.cast(int_to_bool, %4 : !s32i), !cir.bool cir.if %5 { @@ -61,18 +61,18 @@ module { // CHECK: ^bb[[#STEP]]: // [...] // CHECK: llvm.br ^bb[[#COND:]] - // CHECK: ^bb[[#EXIT]]: + // CHECK: ^bb[[#EXIT]]: // [...] // CHECK: } cir.func @testForNested() { cir.scope { %0 = cir.alloca !s32i, !cir.ptr, ["i", init] {alignment = 4 : i64} - %1 = cir.const(#cir.int<1> : !s32i) : !s32i + %1 = cir.const #cir.int<1> : !s32i cir.store %1, %0 : !s32i, !cir.ptr cir.for : cond { %2 = cir.load %0 : !cir.ptr, !s32i - %3 = cir.const(#cir.int<10> : !s32i) : !s32i + %3 = cir.const #cir.int<10> : !s32i %4 = cir.cmp(lt, %2, %3) : !s32i, !s32i %5 = cir.cast(int_to_bool, %4 : !s32i), !cir.bool cir.condition(%5) @@ -80,11 +80,11 @@ module { cir.scope { cir.scope { %2 = cir.alloca !s32i, !cir.ptr, ["j", init] {alignment = 4 : i64} - %3 = cir.const(#cir.int<1> : !s32i) : !s32i + %3 = cir.const #cir.int<1> : !s32i cir.store %3, %2 : !s32i, !cir.ptr cir.for : cond { %4 = cir.load %2 : !cir.ptr, !s32i - %5 = cir.const(#cir.int<10> : !s32i) : !s32i + %5 = cir.const #cir.int<10> : !s32i %6 = cir.cmp(lt, %4, %5) : !s32i, !s32i %7 = cir.cast(int_to_bool, %6 : !s32i), !cir.bool cir.condition(%7) @@ -92,7 +92,7 @@ module { cir.scope { cir.scope { %4 = cir.load %2 : !cir.ptr, !s32i - %5 = cir.const(#cir.int<5> : !s32i) : !s32i + %5 = cir.const #cir.int<5> : !s32i %6 = cir.cmp(eq, %4, %5) : !s32i, !s32i %7 = cir.cast(int_to_bool, %6 : !s32i), !cir.bool cir.if %7 { @@ -120,60 +120,60 @@ module { cir.return } - // CHECK: llvm.func @testForNested() + // CHECK: llvm.func @testForNested() // [...] // CHECK: llvm.br ^bb[[#COND:]] // CHECK: ^bb[[#COND]]: // [...] // CHECK: llvm.cond_br %{{.+}}, ^bb[[#preNESTED1:]], ^bb[[#EXIT:]] - // CHECK: ^bb[[#preNESTED1]]: + // CHECK: ^bb[[#preNESTED1]]: // CHECK: llvm.br ^bb[[#preNESTED2:]] - // CHECK: ^bb[[#preNESTED2]]: + // CHECK: ^bb[[#preNESTED2]]: // CHECK: llvm.br ^bb[[#NESTED:]] - // CHECK: ^bb[[#NESTED]]: + // CHECK: ^bb[[#NESTED]]: // [...] // CHECK: llvm.br ^bb[[#COND_NESTED:]] // CHECK: ^bb[[#COND_NESTED]]: // [...] // CHECK: llvm.cond_br %{{.+}}, ^bb[[#preBREAK1:]], ^bb[[#EXIT_NESTED:]] - // CHECK: ^bb[[#preBREAK1]]: + // CHECK: ^bb[[#preBREAK1]]: // CHECK: llvm.br ^bb[[#preBREAK2:]] - // CHECK: ^bb[[#preBREAK2]]: + // CHECK: ^bb[[#preBREAK2]]: // CHECK: llvm.br ^bb[[#BREAK:]] - // CHECK: ^bb[[#BREAK]]: + // CHECK: ^bb[[#BREAK]]: // [...] // CHECK: llvm.cond_br %{{.+}}, ^bb[[#preEXIT2:]], ^bb[[#preBODY0:]] - // CHECK: ^bb[[#preEXIT2]]: + // CHECK: ^bb[[#preEXIT2]]: // CHECK: llvm.br ^bb[[#EXIT_NESTED:]] - // CHECK: ^bb[[#preBODY0]]: + // CHECK: ^bb[[#preBODY0]]: // CHECK: llvm.br ^bb[[#preBODY1:]] - // CHECK: ^bb[[#preBODY1]]: + // CHECK: ^bb[[#preBODY1]]: // CHECK: llvm.br ^bb[[#BODY_NESTED:]] - // CHECK: ^bb[[#BODY_NESTED]]: + // CHECK: ^bb[[#BODY_NESTED]]: // CHECK: llvm.br ^bb[[#STEP_NESTED:]] - // CHECK: ^bb[[#STEP_NESTED]]: + // CHECK: ^bb[[#STEP_NESTED]]: // [...] // CHECK: llvm.br ^bb[[#COND_NESTED:]] - // CHECK: ^bb[[#EXIT_NESTED]]: + // CHECK: ^bb[[#EXIT_NESTED]]: // [...] // CHECK: llvm.br ^bb[[#BODY:]] - // CHECK: ^bb[[#BODY]]: + // CHECK: ^bb[[#BODY]]: // CHECK: llvm.br ^bb[[#STEP:]] - // CHECK: ^bb[[#STEP]]: + // CHECK: ^bb[[#STEP]]: // [...] // CHECK: llvm.br ^bb[[#COND:]] - // CHECK: ^bb[[#EXIT]]: + // CHECK: ^bb[[#EXIT]]: // [...] // CHECK: } cir.func @testWhile() { %0 = cir.alloca !s32i, !cir.ptr, ["i", init] {alignment = 4 : i64} - %1 = cir.const(#cir.int<0> : !s32i) : !s32i + %1 = cir.const #cir.int<0> : !s32i cir.store %1, %0 : !s32i, !cir.ptr cir.scope { cir.while { %2 = cir.load %0 : !cir.ptr, !s32i - %3 = cir.const(#cir.int<10> : !s32i) : !s32i + %3 = cir.const #cir.int<10> : !s32i %4 = cir.cmp(lt, %2, %3) : !s32i, !s32i %5 = cir.cast(int_to_bool, %4 : !s32i), !cir.bool cir.condition(%5) @@ -183,7 +183,7 @@ module { cir.store %3, %0 : !s32i, !cir.ptr cir.scope { %4 = cir.load %0 : !cir.ptr, !s32i - %5 = cir.const(#cir.int<5> : !s32i) : !s32i + %5 = cir.const #cir.int<5> : !s32i %6 = cir.cmp(eq, %4, %5) : !s32i, !s32i %7 = cir.cast(int_to_bool, %6 : !s32i), !cir.bool cir.if %7 { @@ -203,27 +203,27 @@ module { // CHECK: ^bb[[#COND]]: // [...] // CHECK: llvm.cond_br %{{.+}}, ^bb[[#BODY:]], ^bb[[#EXIT:]] - // CHECK: ^bb[[#BODY]]: + // CHECK: ^bb[[#BODY]]: // [...] // CHECK: llvm.br ^bb[[#BREAK:]] - // CHECK: ^bb[[#BREAK]]: + // CHECK: ^bb[[#BREAK]]: // [...] // CHECK: llvm.cond_br %{{.+}}, ^bb[[#preEXIT1:]], ^bb[[#preCOND0:]] - // CHECK: ^bb[[#preEXIT1]]: + // CHECK: ^bb[[#preEXIT1]]: // CHECK: llvm.br ^bb[[#preEXIT2:]] - // CHECK: ^bb[[#preCOND0]]: + // CHECK: ^bb[[#preCOND0]]: // CHECK: llvm.br ^bb[[#preCOND1:]] - // CHECK: ^bb[[#preCOND1]]: + // CHECK: ^bb[[#preCOND1]]: // CHECK: llvm.br ^bb[[#COND:]] - // CHECK: ^bb[[#preEXIT2]]: + // CHECK: ^bb[[#preEXIT2]]: // CHECK: llvm.br ^bb[[#EXIT:]] - // CHECK: ^bb[[#EXIT]]: + // CHECK: ^bb[[#EXIT]]: // [...] // CHECK: } - + cir.func @testDoWhile() { %0 = cir.alloca !s32i, !cir.ptr, ["i", init] {alignment = 4 : i64} - %1 = cir.const(#cir.int<0> : !s32i) : !s32i + %1 = cir.const #cir.int<0> : !s32i cir.store %1, %0 : !s32i, !cir.ptr cir.scope { cir.do { @@ -232,7 +232,7 @@ cir.func @testDoWhile() { cir.store %3, %0 : !s32i, !cir.ptr cir.scope { %4 = cir.load %0 : !cir.ptr, !s32i - %5 = cir.const(#cir.int<5> : !s32i) : !s32i + %5 = cir.const #cir.int<5> : !s32i %6 = cir.cmp(eq, %4, %5) : !s32i, !s32i %7 = cir.cast(int_to_bool, %6 : !s32i), !cir.bool cir.if %7 { @@ -242,7 +242,7 @@ cir.func @testDoWhile() { cir.yield } while { %2 = cir.load %0 : !cir.ptr, !s32i - %3 = cir.const(#cir.int<10> : !s32i) : !s32i + %3 = cir.const #cir.int<10> : !s32i %4 = cir.cmp(lt, %2, %3) : !s32i, !s32i %5 = cir.cast(int_to_bool, %4 : !s32i), !cir.bool cir.condition(%5) @@ -257,21 +257,21 @@ cir.func @testDoWhile() { // CHECK: ^bb[[#COND]]: // [...] // CHECK: llvm.cond_br %{{.+}}, ^bb[[#BODY:]], ^bb[[#EXIT:]] - // CHECK: ^bb[[#BODY]]: + // CHECK: ^bb[[#BODY]]: // [...] // CHECK: llvm.br ^bb[[#BREAK:]] - // CHECK: ^bb[[#BREAK]]: + // CHECK: ^bb[[#BREAK]]: // [...] // CHECK: llvm.cond_br %{{.+}}, ^bb[[#preEXIT1:]], ^bb[[#preCOND0:]] - // CHECK: ^bb[[#preEXIT1]]: + // CHECK: ^bb[[#preEXIT1]]: // CHECK: llvm.br ^bb[[#preEXIT2:]] - // CHECK: ^bb[[#preCOND0]]: + // CHECK: ^bb[[#preCOND0]]: // CHECK: llvm.br ^bb[[#preCOND1:]] - // CHECK: ^bb[[#preCOND1]]: + // CHECK: ^bb[[#preCOND1]]: // CHECK: llvm.br ^bb[[#COND:]] - // CHECK: ^bb[[#preEXIT2]]: + // CHECK: ^bb[[#preEXIT2]]: // CHECK: llvm.br ^bb[[#EXIT:]] - // CHECK: ^bb[[#EXIT]]: + // CHECK: ^bb[[#EXIT]]: // [...] // CHECK: } diff --git a/clang/test/CIR/Lowering/loops-with-continue.cir b/clang/test/CIR/Lowering/loops-with-continue.cir index 13db11549099..0371d416b61d 100644 --- a/clang/test/CIR/Lowering/loops-with-continue.cir +++ b/clang/test/CIR/Lowering/loops-with-continue.cir @@ -6,11 +6,11 @@ module { cir.func @testFor() { cir.scope { %0 = cir.alloca !s32i, !cir.ptr, ["i", init] {alignment = 4 : i64} - %1 = cir.const(#cir.int<1> : !s32i) : !s32i + %1 = cir.const #cir.int<1> : !s32i cir.store %1, %0 : !s32i, !cir.ptr cir.for : cond { %2 = cir.load %0 : !cir.ptr, !s32i - %3 = cir.const(#cir.int<10> : !s32i) : !s32i + %3 = cir.const #cir.int<10> : !s32i %4 = cir.cmp(lt, %2, %3) : !s32i, !s32i %5 = cir.cast(int_to_bool, %4 : !s32i), !cir.bool cir.condition(%5) @@ -18,7 +18,7 @@ module { cir.scope { cir.scope { %2 = cir.load %0 : !cir.ptr, !s32i - %3 = cir.const(#cir.int<5> : !s32i) : !s32i + %3 = cir.const #cir.int<5> : !s32i %4 = cir.cmp(eq, %2, %3) : !s32i, !s32i %5 = cir.cast(int_to_bool, %4 : !s32i), !cir.bool cir.if %5 { @@ -43,25 +43,25 @@ module { // CHECK: ^bb[[#COND]]: // [...] // CHECK: llvm.cond_br %{{.+}}, ^bb[[#preCONTINUE1:]], ^bb[[#EXIT:]] - // CHECK: ^bb[[#preCONTINUE1]]: + // CHECK: ^bb[[#preCONTINUE1]]: // CHECK: llvm.br ^bb[[#preCONTINUE2:]] - // CHECK: ^bb[[#preCONTINUE2]]: + // CHECK: ^bb[[#preCONTINUE2]]: // CHECK: llvm.br ^bb[[#CONTINUE:]] - // CHECK: ^bb[[#CONTINUE]]: + // CHECK: ^bb[[#CONTINUE]]: // [...] // CHECK: llvm.cond_br %{{.+}}, ^bb[[#preSTEP:]], ^bb[[#preBODY0:]] - // CHECK: ^bb[[#preSTEP]]: + // CHECK: ^bb[[#preSTEP]]: // CHECK: llvm.br ^bb[[#STEP:]] - // CHECK: ^bb[[#preBODY0]]: + // CHECK: ^bb[[#preBODY0]]: // CHECK: llvm.br ^bb[[#preBODY1:]] - // CHECK: ^bb[[#preBODY1]]: + // CHECK: ^bb[[#preBODY1]]: // CHECK: llvm.br ^bb[[#BODY:]] - // CHECK: ^bb[[#BODY]]: + // CHECK: ^bb[[#BODY]]: // CHECK: llvm.br ^bb[[#STEP:]] - // CHECK: ^bb[[#STEP]]: + // CHECK: ^bb[[#STEP]]: // [...] // CHECK: llvm.br ^bb[[#COND:]] - // CHECK: ^bb[[#EXIT]]: + // CHECK: ^bb[[#EXIT]]: // [...] // CHECK: } @@ -69,11 +69,11 @@ module { cir.func @testForNested() { cir.scope { %0 = cir.alloca !s32i, !cir.ptr, ["i", init] {alignment = 4 : i64} - %1 = cir.const(#cir.int<1> : !s32i) : !s32i + %1 = cir.const #cir.int<1> : !s32i cir.store %1, %0 : !s32i, !cir.ptr cir.for : cond { %2 = cir.load %0 : !cir.ptr, !s32i - %3 = cir.const(#cir.int<10> : !s32i) : !s32i + %3 = cir.const #cir.int<10> : !s32i %4 = cir.cmp(lt, %2, %3) : !s32i, !s32i %5 = cir.cast(int_to_bool, %4 : !s32i), !cir.bool cir.condition(%5) @@ -81,11 +81,11 @@ module { cir.scope { cir.scope { %2 = cir.alloca !s32i, !cir.ptr, ["j", init] {alignment = 4 : i64} - %3 = cir.const(#cir.int<1> : !s32i) : !s32i + %3 = cir.const #cir.int<1> : !s32i cir.store %3, %2 : !s32i, !cir.ptr cir.for : cond { %4 = cir.load %2 : !cir.ptr, !s32i - %5 = cir.const(#cir.int<10> : !s32i) : !s32i + %5 = cir.const #cir.int<10> : !s32i %6 = cir.cmp(lt, %4, %5) : !s32i, !s32i %7 = cir.cast(int_to_bool, %6 : !s32i), !cir.bool cir.condition(%7) @@ -93,7 +93,7 @@ module { cir.scope { cir.scope { %4 = cir.load %2 : !cir.ptr, !s32i - %5 = cir.const(#cir.int<5> : !s32i) : !s32i + %5 = cir.const #cir.int<5> : !s32i %6 = cir.cmp(eq, %4, %5) : !s32i, !s32i %7 = cir.cast(int_to_bool, %6 : !s32i), !cir.bool cir.if %7 { @@ -127,53 +127,53 @@ module { // CHECK: ^bb[[#COND]]: // [...] // CHECK: llvm.cond_br %{{.+}}, ^bb[[#preNESTED1:]], ^bb[[#EXIT:]] - // CHECK: ^bb[[#preNESTED1]]: + // CHECK: ^bb[[#preNESTED1]]: // CHECK: llvm.br ^bb[[#preNESTED2:]] - // CHECK: ^bb[[#preNESTED2]]: + // CHECK: ^bb[[#preNESTED2]]: // CHECK: llvm.br ^bb[[#NESTED:]] - // CHECK: ^bb[[#NESTED]]: + // CHECK: ^bb[[#NESTED]]: // [...] // CHECK: llvm.br ^bb[[#COND_NESTED:]] // CHECK: ^bb[[#COND_NESTED]]: // [...] // CHECK: llvm.cond_br %{{.+}}, ^bb[[#preCONTINUE1:]], ^bb[[#EXIT_NESTED:]] - // CHECK: ^bb[[#preCONTINUE1]]: + // CHECK: ^bb[[#preCONTINUE1]]: // CHECK: llvm.br ^bb[[#preCONTINUE2:]] - // CHECK: ^bb[[#preCONTINUE2]]: + // CHECK: ^bb[[#preCONTINUE2]]: // CHECK: llvm.br ^bb[[#CONTINUE:]] - // CHECK: ^bb[[#CONTINUE]]: + // CHECK: ^bb[[#CONTINUE]]: // [...] // CHECK: llvm.cond_br %{{.+}}, ^bb[[#preSTEP0:]], ^bb[[#preBODY0:]] - // CHECK: ^bb[[#preSTEP0]]: + // CHECK: ^bb[[#preSTEP0]]: // CHECK: llvm.br ^bb[[#STEP_NESTED:]] - // CHECK: ^bb[[#preBODY0]]: + // CHECK: ^bb[[#preBODY0]]: // CHECK: llvm.br ^bb[[#preBODY1:]] - // CHECK: ^bb[[#preBODY1]]: + // CHECK: ^bb[[#preBODY1]]: // CHECK: llvm.br ^bb[[#BODY_NESTED:]] - // CHECK: ^bb[[#BODY_NESTED]]: + // CHECK: ^bb[[#BODY_NESTED]]: // CHECK: llvm.br ^bb[[#STEP_NESTED:]] - // CHECK: ^bb[[#STEP_NESTED]]: + // CHECK: ^bb[[#STEP_NESTED]]: // [...] // CHECK: llvm.br ^bb[[#COND_NESTED:]] - // CHECK: ^bb[[#EXIT_NESTED]]: + // CHECK: ^bb[[#EXIT_NESTED]]: // CHECK: llvm.br ^bb[[#BODY:]] - // CHECK: ^bb[[#BODY]]: + // CHECK: ^bb[[#BODY]]: // CHECK: llvm.br ^bb[[#STEP:]] - // CHECK: ^bb[[#STEP]]: + // CHECK: ^bb[[#STEP]]: // [...] // CHECK: llvm.br ^bb[[#COND:]] - // CHECK: ^bb[[#EXIT]]: + // CHECK: ^bb[[#EXIT]]: // [...] // CHECK: } cir.func @testWhile() { %0 = cir.alloca !s32i, !cir.ptr, ["i", init] {alignment = 4 : i64} - %1 = cir.const(#cir.int<0> : !s32i) : !s32i + %1 = cir.const #cir.int<0> : !s32i cir.store %1, %0 : !s32i, !cir.ptr cir.scope { cir.while { %2 = cir.load %0 : !cir.ptr, !s32i - %3 = cir.const(#cir.int<10> : !s32i) : !s32i + %3 = cir.const #cir.int<10> : !s32i %4 = cir.cmp(lt, %2, %3) : !s32i, !s32i %5 = cir.cast(int_to_bool, %4 : !s32i), !cir.bool cir.condition(%5) @@ -183,7 +183,7 @@ cir.func @testWhile() { cir.store %3, %0 : !s32i, !cir.ptr cir.scope { %4 = cir.load %0 : !cir.ptr, !s32i - %5 = cir.const(#cir.int<5> : !s32i) : !s32i + %5 = cir.const #cir.int<5> : !s32i %6 = cir.cmp(eq, %4, %5) : !s32i, !s32i %7 = cir.cast(int_to_bool, %6 : !s32i), !cir.bool cir.if %7 { @@ -202,25 +202,25 @@ cir.func @testWhile() { // CHECK: ^bb[[#COND]]: // [...] // CHECK: llvm.cond_br %{{.+}}, ^bb[[#BODY:]], ^bb[[#EXIT:]] - // CHECK: ^bb[[#BODY]]: + // CHECK: ^bb[[#BODY]]: // [...] // CHECK: llvm.br ^bb[[#CONTINUE:]] - // CHECK: ^bb[[#CONTINUE]]: + // CHECK: ^bb[[#CONTINUE]]: // [...] // CHECK: llvm.cond_br %{{.+}}, ^bb[[#preCOND0:]], ^bb[[#preCOND1:]] - // CHECK: ^bb[[#preCOND0]]: + // CHECK: ^bb[[#preCOND0]]: // CHECK: llvm.br ^bb[[#COND:]] - // CHECK: ^bb[[#preCOND1]]: + // CHECK: ^bb[[#preCOND1]]: // CHECK: llvm.br ^bb[[#preCOND2:]] - // CHECK: ^bb[[#preCOND2]]: + // CHECK: ^bb[[#preCOND2]]: // CHECK: llvm.br ^bb[[#COND:]] - // CHECK: ^bb[[#EXIT]]: + // CHECK: ^bb[[#EXIT]]: // [...] // CHECK: } cir.func @testDoWhile() { %0 = cir.alloca !s32i, !cir.ptr, ["i", init] {alignment = 4 : i64} - %1 = cir.const(#cir.int<0> : !s32i) : !s32i + %1 = cir.const #cir.int<0> : !s32i cir.store %1, %0 : !s32i, !cir.ptr cir.scope { cir.do { @@ -229,7 +229,7 @@ cir.func @testWhile() { cir.store %3, %0 : !s32i, !cir.ptr cir.scope { %4 = cir.load %0 : !cir.ptr, !s32i - %5 = cir.const(#cir.int<5> : !s32i) : !s32i + %5 = cir.const #cir.int<5> : !s32i %6 = cir.cmp(eq, %4, %5) : !s32i, !s32i %7 = cir.cast(int_to_bool, %6 : !s32i), !cir.bool cir.if %7 { @@ -239,7 +239,7 @@ cir.func @testWhile() { cir.yield } while { %2 = cir.load %0 : !cir.ptr, !s32i - %3 = cir.const(#cir.int<10> : !s32i) : !s32i + %3 = cir.const #cir.int<10> : !s32i %4 = cir.cmp(lt, %2, %3) : !s32i, !s32i %5 = cir.cast(int_to_bool, %4 : !s32i), !cir.bool cir.condition(%5) @@ -255,19 +255,19 @@ cir.func @testWhile() { // CHECK: ^bb[[#COND]]: // [...] // CHECK: llvm.cond_br %{{.+}}, ^bb[[#BODY:]], ^bb[[#EXIT:]] - // CHECK: ^bb[[#BODY]]: + // CHECK: ^bb[[#BODY]]: // [...] // CHECK: llvm.br ^bb[[#CONTINUE:]] - // CHECK: ^bb[[#CONTINUE]]: + // CHECK: ^bb[[#CONTINUE]]: // [...] // CHECK: llvm.cond_br %{{.+}}, ^bb[[#preCOND0:]], ^bb[[#preCOND1:]] - // CHECK: ^bb[[#preCOND0]]: + // CHECK: ^bb[[#preCOND0]]: // CHECK: llvm.br ^bb[[#COND:]] - // CHECK: ^bb[[#preCOND1]]: + // CHECK: ^bb[[#preCOND1]]: // CHECK: llvm.br ^bb[[#preCOND2:]] - // CHECK: ^bb[[#preCOND2]]: + // CHECK: ^bb[[#preCOND2]]: // CHECK: llvm.br ^bb[[#COND:]] - // CHECK: ^bb[[#EXIT]]: + // CHECK: ^bb[[#EXIT]]: // [...] // CHECK: } diff --git a/clang/test/CIR/Lowering/ptrstride.cir b/clang/test/CIR/Lowering/ptrstride.cir index 2516791d68a7..1616ede8934a 100644 --- a/clang/test/CIR/Lowering/ptrstride.cir +++ b/clang/test/CIR/Lowering/ptrstride.cir @@ -7,7 +7,7 @@ module { %0 = cir.alloca !cir.ptr, !cir.ptr>, ["a", init] {alignment = 8 : i64} cir.store %arg0, %0 : !cir.ptr, !cir.ptr> %1 = cir.load %0 : !cir.ptr>, !cir.ptr - %2 = cir.const(#cir.int<1> : !s32i) : !s32i + %2 = cir.const #cir.int<1> : !s32i %3 = cir.ptr_stride(%1 : !cir.ptr, %2 : !s32i), !cir.ptr %4 = cir.load %3 : !cir.ptr, !s32i cir.return diff --git a/clang/test/CIR/Lowering/scope.cir b/clang/test/CIR/Lowering/scope.cir index 1c99823b0584..9da4910499e4 100644 --- a/clang/test/CIR/Lowering/scope.cir +++ b/clang/test/CIR/Lowering/scope.cir @@ -7,7 +7,7 @@ module { cir.func @foo() { cir.scope { %0 = cir.alloca !u32i, !cir.ptr, ["a", init] {alignment = 4 : i64} - %1 = cir.const(#cir.int<4> : !u32i) : !u32i + %1 = cir.const #cir.int<4> : !u32i cir.store %1, %0 : !u32i, !cir.ptr } cir.return @@ -52,7 +52,7 @@ module { cir.func @scope_with_return() -> !u32i { %0 = cir.alloca !u32i, !cir.ptr, ["__retval"] {alignment = 4 : i64} cir.scope { - %2 = cir.const(#cir.int<0> : !u32i) : !u32i + %2 = cir.const #cir.int<0> : !u32i cir.store %2, %0 : !u32i, !cir.ptr %3 = cir.load %0 : !cir.ptr, !u32i cir.return %3 : !u32i diff --git a/clang/test/CIR/Lowering/struct.cir b/clang/test/CIR/Lowering/struct.cir index edf279755627..334ca781fd8e 100644 --- a/clang/test/CIR/Lowering/struct.cir +++ b/clang/test/CIR/Lowering/struct.cir @@ -24,7 +24,7 @@ module { cir.func @shouldConstInitLocalStructsWithConstStructAttr() { %0 = cir.alloca !ty_22S2A22, !cir.ptr, ["s"] {alignment = 4 : i64} - %1 = cir.const(#cir.const_struct<{#cir.int<1> : !s32i}> : !ty_22S2A22) : !ty_22S2A22 + %1 = cir.const #cir.const_struct<{#cir.int<1> : !s32i}> : !ty_22S2A22 cir.store %1, %0 : !ty_22S2A22, !cir.ptr cir.return } diff --git a/clang/test/CIR/Lowering/switch.cir b/clang/test/CIR/Lowering/switch.cir index 4737cba64b8b..dee8e98db858 100644 --- a/clang/test/CIR/Lowering/switch.cir +++ b/clang/test/CIR/Lowering/switch.cir @@ -117,7 +117,7 @@ module { ^bb1: // no predecessors cir.break } - ] + ] } cir.return } @@ -148,7 +148,7 @@ module { case (equal, 0) { cir.scope { %6 = cir.load %1 : !cir.ptr, !s32i - %7 = cir.const(#cir.int<0> : !s32i) : !s32i + %7 = cir.const #cir.int<0> : !s32i %8 = cir.cmp(ge, %6, %7) : !s32i, !s32i %9 = cir.cast(int_to_bool, %8 : !s32i), !cir.bool cir.if %9 { @@ -157,12 +157,12 @@ module { } cir.break } - ] - } - %3 = cir.const(#cir.int<3> : !s32i) : !s32i + ] + } + %3 = cir.const #cir.int<3> : !s32i cir.store %3, %2 : !s32i, !cir.ptr %4 = cir.load %2 : !cir.ptr, !s32i - cir.return %4 : !s32i + cir.return %4 : !s32i } // CHECK: llvm.func @shouldLowerNestedBreak // CHECK: llvm.switch %6 : i32, ^bb7 [ diff --git a/clang/test/CIR/Lowering/ternary.cir b/clang/test/CIR/Lowering/ternary.cir index 6ccd9c4ed323..9fccea8043f8 100644 --- a/clang/test/CIR/Lowering/ternary.cir +++ b/clang/test/CIR/Lowering/ternary.cir @@ -9,13 +9,13 @@ cir.func @_Z1xi(%arg0: !s32i) -> !s32i { %1 = cir.alloca !s32i, !cir.ptr, ["__retval"] {alignment = 4 : i64} cir.store %arg0, %0 : !s32i, !cir.ptr %2 = cir.load %0 : !cir.ptr, !s32i - %3 = cir.const(#cir.int<0> : !s32i) : !s32i + %3 = cir.const #cir.int<0> : !s32i %4 = cir.cmp(gt, %2, %3) : !s32i, !cir.bool %5 = cir.ternary(%4, true { - %7 = cir.const(#cir.int<3> : !s32i) : !s32i + %7 = cir.const #cir.int<3> : !s32i cir.yield %7 : !s32i }, false { - %7 = cir.const(#cir.int<5> : !s32i) : !s32i + %7 = cir.const #cir.int<5> : !s32i cir.yield %7 : !s32i }) : (!cir.bool) -> !s32i cir.store %5, %1 : !s32i, !cir.ptr diff --git a/clang/test/CIR/Lowering/types.cir b/clang/test/CIR/Lowering/types.cir index 12bb892bd4c4..5e5be9192e8a 100644 --- a/clang/test/CIR/Lowering/types.cir +++ b/clang/test/CIR/Lowering/types.cir @@ -5,9 +5,9 @@ module { cir.func @testTypeLowering() { // Should lower void pointers as opaque pointers. - %0 = cir.const(#cir.ptr : !cir.ptr) : !cir.ptr + %0 = cir.const #cir.ptr : !cir.ptr // CHECK: llvm.mlir.zero : !llvm.ptr - %1 = cir.const(#cir.ptr : !cir.ptr>) : !cir.ptr> + %1 = cir.const #cir.ptr : !cir.ptr> // CHECK: llvm.mlir.zero : !llvm.ptr cir.return } diff --git a/clang/test/CIR/Lowering/unary-inc-dec.cir b/clang/test/CIR/Lowering/unary-inc-dec.cir index 1be10c992c7b..9e8856428c84 100644 --- a/clang/test/CIR/Lowering/unary-inc-dec.cir +++ b/clang/test/CIR/Lowering/unary-inc-dec.cir @@ -5,7 +5,7 @@ module { cir.func @foo() { %0 = cir.alloca !s32i, !cir.ptr, ["a", init] {alignment = 4 : i64} %1 = cir.alloca !s32i, !cir.ptr, ["b", init] {alignment = 4 : i64} - %2 = cir.const(#cir.int<2> : !s32i) : !s32i + %2 = cir.const #cir.int<2> : !s32i cir.store %2, %0 : !s32i, !cir.ptr cir.store %2, %1 : !s32i, !cir.ptr diff --git a/clang/test/CIR/Lowering/unary-not.cir b/clang/test/CIR/Lowering/unary-not.cir index 773b57181de9..48e2705e756d 100644 --- a/clang/test/CIR/Lowering/unary-not.cir +++ b/clang/test/CIR/Lowering/unary-not.cir @@ -5,7 +5,7 @@ module { cir.func @foo() -> !s32i { %0 = cir.alloca !s32i, !cir.ptr, ["__retval"] {alignment = 4 : i64} %1 = cir.alloca !s32i, !cir.ptr, ["a", init] {alignment = 4 : i64} - %2 = cir.const(#cir.int<1> : !s32i) : !s32i + %2 = cir.const #cir.int<1> : !s32i cir.store %2, %1 : !s32i, !cir.ptr %3 = cir.load %1 : !cir.ptr, !s32i %4 = cir.unary(not, %3) : !s32i, !s32i diff --git a/clang/test/CIR/Lowering/unary-plus-minus.cir b/clang/test/CIR/Lowering/unary-plus-minus.cir index d998f494855e..6734845ad03d 100644 --- a/clang/test/CIR/Lowering/unary-plus-minus.cir +++ b/clang/test/CIR/Lowering/unary-plus-minus.cir @@ -6,7 +6,7 @@ module { cir.func @foo() { %0 = cir.alloca !s32i, !cir.ptr, ["a", init] {alignment = 4 : i64} %1 = cir.alloca !s32i, !cir.ptr, ["b", init] {alignment = 4 : i64} - %2 = cir.const(#cir.int<2> : !s32i) : !s32i + %2 = cir.const #cir.int<2> : !s32i cir.store %2, %0 : !s32i, !cir.ptr cir.store %2, %1 : !s32i, !cir.ptr diff --git a/clang/test/CIR/Lowering/unions.cir b/clang/test/CIR/Lowering/unions.cir index 92beda0ee4b8..694c3ae17465 100644 --- a/clang/test/CIR/Lowering/unions.cir +++ b/clang/test/CIR/Lowering/unions.cir @@ -22,7 +22,7 @@ module { cir.func @test(%arg0: !cir.ptr) { // Should store directly to the union's base address. - %5 = cir.const(#true) : !cir.bool + %5 = cir.const #true %6 = cir.get_member %arg0[0] {name = "b"} : !cir.ptr -> !cir.ptr cir.store %5, %6 : !cir.bool, !cir.ptr // CHECK: %[[#VAL:]] = llvm.mlir.constant(1 : i8) : i8 diff --git a/clang/test/CIR/Lowering/variadics.cir b/clang/test/CIR/Lowering/variadics.cir index 6e8c8f89233e..b4a5a30c5e82 100644 --- a/clang/test/CIR/Lowering/variadics.cir +++ b/clang/test/CIR/Lowering/variadics.cir @@ -32,7 +32,7 @@ module { // MLIR: %{{[0-9]+}} = llvm.getelementptr %{{[0-9]+}}[0] : (!llvm.ptr) -> !llvm.ptr, !llvm.struct<"struct.__va_list_tag", (i32, i32, ptr, ptr)> // MLIR-NEXT: %{{[0-9]+}} = llvm.bitcast %{{[0-9]+}} : !llvm.ptr to !llvm.ptr // MLIR-NEXT: llvm.intr.vaend %{{[0-9]+}} : !llvm.ptr - %8 = cir.const(#cir.int<0> : !s32i) : !s32i + %8 = cir.const #cir.int<0> : !s32i cir.store %8, %1 : !s32i, !cir.ptr %9 = cir.load %1 : !cir.ptr, !s32i cir.return %9 : !s32i diff --git a/clang/test/CIR/Transforms/lib-opt-find.cpp b/clang/test/CIR/Transforms/lib-opt-find.cpp index 14c464ff9448..c11daba10f28 100644 --- a/clang/test/CIR/Transforms/lib-opt-find.cpp +++ b/clang/test/CIR/Transforms/lib-opt-find.cpp @@ -19,11 +19,11 @@ int test1(unsigned char n = 3) // CHECK: %[[pattern:.*]] = cir.cast(integral, %[[load_pattern:.*]] : !u8i), !s32i // CHECK-NOT: {{.*}} cir.call @_ZSt4findIPhhET_S1_S1_RKT0_( - // CHECK: %[[array_size:.*]] = cir.const(#cir.int<9> : !u64i) : !u64i + // CHECK: %[[array_size:.*]] = cir.const #cir.int<9> : !u64i // CHECK: %[[result_cast:.*]] = cir.libc.memchr(%[[cast_to_void]], %[[pattern]], %[[array_size]]) // CHECK: %[[memchr_res:.*]] = cir.cast(bitcast, %[[result_cast]] : !cir.ptr), !cir.ptr - // CHECK: %[[nullptr:.*]] = cir.const(#cir.ptr : !cir.ptr) : !cir.ptr + // CHECK: %[[nullptr:.*]] = cir.const #cir.ptr : !cir.ptr // CHECK: %[[cmp_res:.*]] = cir.cmp(eq, %[[nullptr]], %[[memchr_res]]) : !cir.ptr, !cir.bool // CHECK: cir.ternary(%[[cmp_res]], true { // CHECK: cir.yield %[[last]] : !cir.ptr @@ -56,7 +56,7 @@ unsigned char* test2(unsigned char* first, unsigned char* last, unsigned char v) // CHECK: %[[result_cast:.*]] = cir.libc.memchr(%[[cast_to_void]], %[[pattern]], %[[array_size]]) // CHECK: %[[memchr_res:.*]] = cir.cast(bitcast, %[[result_cast]] : !cir.ptr), !cir.ptr - // CHECK: %[[nullptr:.*]] = cir.const(#cir.ptr : !cir.ptr) : !cir.ptr + // CHECK: %[[nullptr:.*]] = cir.const #cir.ptr : !cir.ptr // CHECK: %[[cmp_res:.*]] = cir.cmp(eq, %[[nullptr]], %[[memchr_res]]) : !cir.ptr, !cir.bool // CHECK: cir.ternary(%[[cmp_res]], true { // CHECK: cir.yield %[[last]] : !cir.ptr diff --git a/clang/test/CIR/Transforms/merge-cleanups.cir b/clang/test/CIR/Transforms/merge-cleanups.cir index 9306958f944e..5cb52d15c686 100644 --- a/clang/test/CIR/Transforms/merge-cleanups.cir +++ b/clang/test/CIR/Transforms/merge-cleanups.cir @@ -12,13 +12,13 @@ module { cir.store %arg1, %1 : !s32i, !cir.ptr cir.scope { %2 = cir.alloca !s32i, !cir.ptr, ["b", init] {alignment = 4 : i64} - %3 = cir.const(#cir.int<1> : !s32i) : !s32i + %3 = cir.const #cir.int<1> : !s32i cir.store %3, %2 : !s32i, !cir.ptr %4 = cir.load %0 : !cir.ptr, !s32i cir.switch (%4 : !s32i) [ case (equal, 0 : !s32i) { %5 = cir.load %2 : !cir.ptr, !s32i - %6 = cir.const(#cir.int<1> : !s32i) : !s32i + %6 = cir.const #cir.int<1> : !s32i %7 = cir.binop(add, %5, %6) : !s32i cir.store %7, %2 : !s32i, !cir.ptr cir.br ^bb1 @@ -29,7 +29,7 @@ module { cir.scope { cir.scope { %5 = cir.load %1 : !cir.ptr, !s32i - %6 = cir.const(#cir.int<3> : !s32i) : !s32i + %6 = cir.const #cir.int<3> : !s32i %7 = cir.cmp(eq, %5, %6) : !s32i, !cir.bool cir.if %7 { cir.br ^bb1 @@ -45,10 +45,10 @@ module { cir.scope { %5 = cir.alloca !s32i, !cir.ptr, ["yolo", init] {alignment = 4 : i64} %6 = cir.load %2 : !cir.ptr, !s32i - %7 = cir.const(#cir.int<1> : !s32i) : !s32i + %7 = cir.const #cir.int<1> : !s32i %8 = cir.binop(add, %6, %7) : !s32i cir.store %8, %2 : !s32i, !cir.ptr - %9 = cir.const(#cir.int<100> : !s32i) : !s32i + %9 = cir.const #cir.int<100> : !s32i cir.store %9, %5 : !s32i, !cir.ptr cir.br ^bb1 ^bb1: // pred: ^bb0 @@ -64,7 +64,7 @@ module { // CHECK: cir.switch (%4 : !s32i) [ // CHECK-NEXT: case (equal, 0) { // CHECK-NEXT: %5 = cir.load %2 : !cir.ptr, !s32i -// CHECK-NEXT: %6 = cir.const(#cir.int<1> : !s32i) : !s32i +// CHECK-NEXT: %6 = cir.const #cir.int<1> : !s32i // CHECK-NEXT: %7 = cir.binop(add, %5, %6) : !s32i // CHECK-NEXT: cir.store %7, %2 : !s32i, !cir.ptr // CHECK-NEXT: cir.return @@ -73,7 +73,7 @@ module { // CHECK-NEXT: cir.scope { // CHECK-NEXT: cir.scope { // CHECK-NEXT: %5 = cir.load %1 : !cir.ptr, !s32i -// CHECK-NEXT: %6 = cir.const(#cir.int<3> : !s32i) : !s32i +// CHECK-NEXT: %6 = cir.const #cir.int<3> : !s32i // CHECK-NEXT: %7 = cir.cmp(eq, %5, %6) : !s32i, !cir.bool // CHECK-NEXT: cir.if %7 { // CHECK-NEXT: cir.return @@ -87,10 +87,10 @@ module { // CHECK-NEXT: cir.scope { // CHECK-NEXT: %5 = cir.alloca !s32i, !cir.ptr, ["yolo", init] {alignment = 4 : i64} // CHECK-NEXT: %6 = cir.load %2 : !cir.ptr, !s32i -// CHECK-NEXT: %7 = cir.const(#cir.int<1> : !s32i) : !s32i +// CHECK-NEXT: %7 = cir.const #cir.int<1> : !s32i // CHECK-NEXT: %8 = cir.binop(add, %6, %7) : !s32i // CHECK-NEXT: cir.store %8, %2 : !s32i, !cir.ptr -// CHECK-NEXT: %9 = cir.const(#cir.int<100> : !s32i) : !s32i +// CHECK-NEXT: %9 = cir.const #cir.int<100> : !s32i // CHECK-NEXT: cir.store %9, %5 : !s32i, !cir.ptr // CHECK-NEXT: cir.return // CHECK-NEXT: }