Skip to content

Commit 977d744

Browse files
kchibisovkchibisov
authored
[mlir][emitc] Set default dialect to emitc in ops with block (#123036)
This is a follow up to 68a3908 (func: Set default dialect to 'emitc'), but for other instructions with blocks to make it look consistent.
1 parent 57466db commit 977d744

File tree

6 files changed

+141
-99
lines changed

6 files changed

+141
-99
lines changed

‎mlir/include/mlir/Dialect/EmitC/IR/EmitC.td

+41-5
Original file line numberDiff line numberDiff line change
@@ -386,8 +386,8 @@ def EmitC_DivOp : EmitC_BinaryOp<"div", [CExpression]> {
386386
}
387387

388388
def EmitC_ExpressionOp : EmitC_Op<"expression",
389-
[HasOnlyGraphRegion, SingleBlockImplicitTerminator<"emitc::YieldOp">,
390-
NoRegionArguments]> {
389+
[HasOnlyGraphRegion, OpAsmOpInterface,
390+
SingleBlockImplicitTerminator<"emitc::YieldOp">, NoRegionArguments]> {
391391
let summary = "Expression operation";
392392
let description = [{
393393
The `emitc.expression` operation returns a single SSA value which is yielded by
@@ -453,12 +453,21 @@ def EmitC_ExpressionOp : EmitC_Op<"expression",
453453
return llvm::any_of(getRegion().front().without_terminator(), predicate);
454454
};
455455
Operation *getRootOp();
456+
457+
//===------------------------------------------------------------------===//
458+
// OpAsmOpInterface Methods
459+
//===------------------------------------------------------------------===//
460+
461+
/// EmitC ops in the body can omit their 'emitc.' prefix in the assembly.
462+
static ::llvm::StringRef getDefaultDialect() {
463+
return "emitc";
464+
}
456465
}];
457466
}
458467

459468
def EmitC_ForOp : EmitC_Op<"for",
460469
[AllTypesMatch<["lowerBound", "upperBound", "step"]>,
461-
SingleBlockImplicitTerminator<"emitc::YieldOp">,
470+
OpAsmOpInterface, SingleBlockImplicitTerminator<"emitc::YieldOp">,
462471
RecursiveMemoryEffects]> {
463472
let summary = "For operation";
464473
let description = [{
@@ -510,6 +519,15 @@ def EmitC_ForOp : EmitC_Op<"for",
510519
void setLowerBound(Value bound) { getOperation()->setOperand(0, bound); }
511520
void setUpperBound(Value bound) { getOperation()->setOperand(1, bound); }
512521
void setStep(Value step) { getOperation()->setOperand(2, step); }
522+
523+
//===------------------------------------------------------------------===//
524+
// OpAsmOpInterface Methods
525+
//===------------------------------------------------------------------===//
526+
527+
/// EmitC ops in the body can omit their 'emitc.' prefix in the assembly.
528+
static ::llvm::StringRef getDefaultDialect() {
529+
return "emitc";
530+
}
513531
}];
514532

515533
let hasCanonicalizer = 1;
@@ -1257,7 +1275,7 @@ def EmitC_YieldOp : EmitC_Op<"yield",
12571275
def EmitC_IfOp : EmitC_Op<"if",
12581276
[DeclareOpInterfaceMethods<RegionBranchOpInterface, [
12591277
"getNumRegionInvocations", "getRegionInvocationBounds",
1260-
"getEntrySuccessorRegions"]>, SingleBlock,
1278+
"getEntrySuccessorRegions"]>, OpAsmOpInterface, SingleBlock,
12611279
SingleBlockImplicitTerminator<"emitc::YieldOp">,
12621280
RecursiveMemoryEffects, NoRegionArguments]> {
12631281
let summary = "If-then-else operation";
@@ -1305,6 +1323,15 @@ def EmitC_IfOp : EmitC_Op<"if",
13051323
Block* body = getBody(1);
13061324
return OpBuilder::atBlockEnd(body, listener);
13071325
}
1326+
1327+
//===------------------------------------------------------------------===//
1328+
// OpAsmOpInterface Methods
1329+
//===------------------------------------------------------------------===//
1330+
1331+
/// EmitC ops in the body can omit their 'emitc.' prefix in the assembly.
1332+
static ::llvm::StringRef getDefaultDialect() {
1333+
return "emitc";
1334+
}
13081335
}];
13091336
let hasCustomAssemblyFormat = 1;
13101337
}
@@ -1360,7 +1387,7 @@ def EmitC_SubscriptOp : EmitC_Op<"subscript", []> {
13601387
}
13611388

13621389
def EmitC_SwitchOp : EmitC_Op<"switch", [RecursiveMemoryEffects,
1363-
SingleBlockImplicitTerminator<"emitc::YieldOp">,
1390+
OpAsmOpInterface, SingleBlockImplicitTerminator<"emitc::YieldOp">,
13641391
DeclareOpInterfaceMethods<RegionBranchOpInterface,
13651392
["getRegionInvocationBounds",
13661393
"getEntrySuccessorRegions"]>]> {
@@ -1438,6 +1465,15 @@ def EmitC_SwitchOp : EmitC_Op<"switch", [RecursiveMemoryEffects,
14381465

14391466
/// Get the body of a case region.
14401467
Block &getCaseBlock(unsigned idx);
1468+
1469+
//===------------------------------------------------------------------===//
1470+
// OpAsmOpInterface Methods
1471+
//===------------------------------------------------------------------===//
1472+
1473+
/// EmitC ops in the body can omit their 'emitc.' prefix in the assembly.
1474+
static ::llvm::StringRef getDefaultDialect() {
1475+
return "emitc";
1476+
}
14411477
}];
14421478

14431479
let hasVerifier = 1;

‎mlir/test/Conversion/ArithToEmitC/arith-to-emitc.mlir

+33-27
Original file line numberDiff line numberDiff line change
@@ -152,11 +152,12 @@ func.func @arith_shift_left(%arg0: i32, %arg1: i32) {
152152
// CHECK-DAG: %[[SizeConstant:[^ ]*]] = "emitc.constant"{{.*}}value = 32
153153
// CHECK-DAG: %[[CmpNoExcess:[^ ]*]] = emitc.cmp lt, %[[C2]], %[[SizeConstant]] : (ui32, ui32) -> i1
154154
// CHECK-DAG: %[[Zero:[^ ]*]] = "emitc.constant"{{.*}}value = 0
155-
// CHECK: %[[ShiftRes:[^ ]*]] = emitc.expression : ui32
156-
// CHECK: %[[SHL:[^ ]*]] = emitc.bitwise_left_shift %[[C1]], %[[C2]] : (ui32, ui32) -> ui32
157-
// CHECK: %[[Ternary:[^ ]*]] = emitc.conditional %[[CmpNoExcess]], %[[SHL]], %[[Zero]] : ui32
158-
// CHECK: emitc.yield %[[Ternary]] : ui32
159-
// CHECK: emitc.cast %[[ShiftRes]] : ui32 to i32
155+
// CHECK: %[[ShiftRes:[^ ]*]] = emitc.expression : ui32 {
156+
// CHECK-NEXT: %[[SHL:[^ ]*]] = bitwise_left_shift %[[C1]], %[[C2]] : (ui32, ui32) -> ui32
157+
// CHECK-NEXT: %[[Ternary:[^ ]*]] = conditional %[[CmpNoExcess]], %[[SHL]], %[[Zero]] : ui32
158+
// CHECK-NEXT: yield %[[Ternary]] : ui32
159+
// CHECK-NEXT: }
160+
// CHECK-NEXT: emitc.cast %[[ShiftRes]] : ui32 to i32
160161
%1 = arith.shli %arg0, %arg1 : i32
161162
return
162163
}
@@ -171,21 +172,23 @@ func.func @arith_shift_right(%arg0: i32, %arg1: i32) {
171172
// CHECK-DAG: %[[SizeConstant:[^ ]*]] = "emitc.constant"{{.*}}value = 32{{.*}}ui32
172173
// CHECK-DAG: %[[CmpNoExcess:[^ ]*]] = emitc.cmp lt, %[[C2]], %[[SizeConstant]] : (ui32, ui32) -> i1
173174
// CHECK-DAG: %[[Zero:[^ ]*]] = "emitc.constant"{{.*}}value = 0{{.*}}ui32
174-
// CHECK: %[[ShiftRes:[^ ]*]] = emitc.expression : ui32
175-
// CHECK: %[[SHR:[^ ]*]] = emitc.bitwise_right_shift %[[C1]], %[[C2]] : (ui32, ui32) -> ui32
176-
// CHECK: %[[Ternary:[^ ]*]] = emitc.conditional %[[CmpNoExcess]], %[[SHR]], %[[Zero]] : ui32
177-
// CHECK: emitc.yield %[[Ternary]] : ui32
178-
// CHECK: emitc.cast %[[ShiftRes]] : ui32 to i32
175+
// CHECK: %[[ShiftRes:[^ ]*]] = emitc.expression : ui32 {
176+
// CHECK-NEXT: %[[SHR:[^ ]*]] = bitwise_right_shift %[[C1]], %[[C2]] : (ui32, ui32) -> ui32
177+
// CHECK-NEXT: %[[Ternary:[^ ]*]] = conditional %[[CmpNoExcess]], %[[SHR]], %[[Zero]] : ui32
178+
// CHECK-NEXT: yield %[[Ternary]] : ui32
179+
// CHECK-NEXT: }
180+
// CHECK-NEXT: emitc.cast %[[ShiftRes]] : ui32 to i32
179181
%2 = arith.shrui %arg0, %arg1 : i32
180182

181183
// CHECK-DAG: %[[SC2:[^ ]*]] = emitc.cast %[[ARG1]] : i32 to ui32
182184
// CHECK-DAG: %[[SSizeConstant:[^ ]*]] = "emitc.constant"{{.*}}value = 32{{.*}}ui32
183185
// CHECK-DAG: %[[SCmpNoExcess:[^ ]*]] = emitc.cmp lt, %[[SC2]], %[[SSizeConstant]] : (ui32, ui32) -> i1
184186
// CHECK-DAG: %[[SZero:[^ ]*]] = "emitc.constant"{{.*}}value = 0{{.*}}i32
185-
// CHECK: %[[SShiftRes:[^ ]*]] = emitc.expression : i32
186-
// CHECK: %[[SHRSI:[^ ]*]] = emitc.bitwise_right_shift %[[ARG0]], %[[SC2]] : (i32, ui32) -> i32
187-
// CHECK: %[[STernary:[^ ]*]] = emitc.conditional %[[SCmpNoExcess]], %[[SHRSI]], %[[SZero]] : i32
188-
// CHECK: emitc.yield %[[STernary]] : i32
187+
// CHECK: %[[SShiftRes:[^ ]*]] = emitc.expression : i32 {
188+
// CHECK-NEXT: %[[SHRSI:[^ ]*]] = bitwise_right_shift %[[ARG0]], %[[SC2]] : (i32, ui32) -> i32
189+
// CHECK-NEXT: %[[STernary:[^ ]*]] = conditional %[[SCmpNoExcess]], %[[SHRSI]], %[[SZero]] : i32
190+
// CHECK-NEXT: yield %[[STernary]] : i32
191+
// CHECK-NEXT: }
189192
%3 = arith.shrsi %arg0, %arg1 : i32
190193

191194
return
@@ -206,10 +209,11 @@ func.func @arith_shift_left_index(%amount: i32) {
206209
// CHECK-DAG: %[[SizeConstant:[^ ]*]] = emitc.mul %[[Byte]], %[[SizeOf]] : (!emitc.size_t, !emitc.size_t) -> !emitc.size_t
207210
// CHECK-DAG: %[[CmpNoExcess:[^ ]*]] = emitc.cmp lt, %[[AmountIdx]], %[[SizeConstant]] : (!emitc.size_t, !emitc.size_t) -> i1
208211
// CHECK-DAG: %[[Zero:[^ ]*]] = "emitc.constant"{{.*}}value = 0
209-
// CHECK: %[[ShiftRes:[^ ]*]] = emitc.expression : !emitc.size_t
210-
// CHECK: %[[SHL:[^ ]*]] = emitc.bitwise_left_shift %[[C1]], %[[AmountIdx]] : (!emitc.size_t, !emitc.size_t) -> !emitc.size_t
211-
// CHECK: %[[Ternary:[^ ]*]] = emitc.conditional %[[CmpNoExcess]], %[[SHL]], %[[Zero]] : !emitc.size_t
212-
// CHECK: emitc.yield %[[Ternary]] : !emitc.size_t
212+
// CHECK: %[[ShiftRes:[^ ]*]] = emitc.expression : !emitc.size_t {
213+
// CHECK-NEXT: %[[SHL:[^ ]*]] = bitwise_left_shift %[[C1]], %[[AmountIdx]] : (!emitc.size_t, !emitc.size_t) -> !emitc.size_t
214+
// CHECK-NEXT: %[[Ternary:[^ ]*]] = conditional %[[CmpNoExcess]], %[[SHL]], %[[Zero]] : !emitc.size_t
215+
// CHECK-NEXT: yield %[[Ternary]] : !emitc.size_t
216+
// CHECK-NEXT: }
213217
%1 = arith.shli %cst0, %cast1 : index
214218
return
215219
}
@@ -230,10 +234,11 @@ func.func @arith_shift_right_index(%amount: i32) {
230234
// CHECK-DAG: %[[SizeConstant:[^ ]*]] = emitc.mul %[[Byte]], %[[SizeOf]] : (!emitc.size_t, !emitc.size_t) -> !emitc.size_t
231235
// CHECK-DAG: %[[CmpNoExcess:[^ ]*]] = emitc.cmp lt, %[[AmountIdx]], %[[SizeConstant]] : (!emitc.size_t, !emitc.size_t) -> i1
232236
// CHECK-DAG: %[[Zero:[^ ]*]] = "emitc.constant"{{.*}}value = 0{{.*}}!emitc.size_t
233-
// CHECK: %[[ShiftRes:[^ ]*]] = emitc.expression : !emitc.size_t
234-
// CHECK: %[[SHR:[^ ]*]] = emitc.bitwise_right_shift %[[C1]], %[[AmountIdx]] : (!emitc.size_t, !emitc.size_t) -> !emitc.size_t
235-
// CHECK: %[[Ternary:[^ ]*]] = emitc.conditional %[[CmpNoExcess]], %[[SHR]], %[[Zero]] : !emitc.size_t
236-
// CHECK: emitc.yield %[[Ternary]] : !emitc.size_t
237+
// CHECK: %[[ShiftRes:[^ ]*]] = emitc.expression : !emitc.size_t {
238+
// CHECK-NEXT: %[[SHR:[^ ]*]] = bitwise_right_shift %[[C1]], %[[AmountIdx]] : (!emitc.size_t, !emitc.size_t) -> !emitc.size_t
239+
// CHECK-NEXT: %[[Ternary:[^ ]*]] = conditional %[[CmpNoExcess]], %[[SHR]], %[[Zero]] : !emitc.size_t
240+
// CHECK-NEXT: yield %[[Ternary]] : !emitc.size_t
241+
// CHECK-NEXT: }
237242
%2 = arith.shrui %arg0, %arg1 : index
238243

239244
// CHECK-DAG: %[[SC1:[^ ]*]] = emitc.cast %[[C1]] : !emitc.size_t to !emitc.ptrdiff_t
@@ -242,11 +247,12 @@ func.func @arith_shift_right_index(%amount: i32) {
242247
// CHECK-DAG: %[[SSizeConstant:[^ ]*]] = emitc.mul %[[SByte]], %[[SSizeOf]] : (!emitc.size_t, !emitc.size_t) -> !emitc.size_t
243248
// CHECK-DAG: %[[SCmpNoExcess:[^ ]*]] = emitc.cmp lt, %[[AmountIdx]], %[[SSizeConstant]] : (!emitc.size_t, !emitc.size_t) -> i1
244249
// CHECK-DAG: %[[SZero:[^ ]*]] = "emitc.constant"{{.*}}value = 0{{.*}}!emitc.ptrdiff_t
245-
// CHECK: %[[SShiftRes:[^ ]*]] = emitc.expression : !emitc.ptrdiff_t
246-
// CHECK: %[[SHRSI:[^ ]*]] = emitc.bitwise_right_shift %[[SC1]], %[[AmountIdx]] : (!emitc.ptrdiff_t, !emitc.size_t) -> !emitc.ptrdiff_t
247-
// CHECK: %[[STernary:[^ ]*]] = emitc.conditional %[[SCmpNoExcess]], %[[SHRSI]], %[[SZero]] : !emitc.ptrdiff_t
248-
// CHECK: emitc.yield %[[STernary]] : !emitc.ptrdiff_t
249-
// CHECK: emitc.cast %[[SShiftRes]] : !emitc.ptrdiff_t to !emitc.size_t
250+
// CHECK: %[[SShiftRes:[^ ]*]] = emitc.expression : !emitc.ptrdiff_t {
251+
// CHECK-NEXT: %[[SHRSI:[^ ]*]] = bitwise_right_shift %[[SC1]], %[[AmountIdx]] : (!emitc.ptrdiff_t, !emitc.size_t) -> !emitc.ptrdiff_t
252+
// CHECK-NEXT: %[[STernary:[^ ]*]] = conditional %[[SCmpNoExcess]], %[[SHRSI]], %[[SZero]] : !emitc.ptrdiff_t
253+
// CHECK-NEXT: yield %[[STernary]] : !emitc.ptrdiff_t
254+
// CHECK-NEXT: }
255+
// CHECK-NEXT: emitc.cast %[[SShiftRes]] : !emitc.ptrdiff_t to !emitc.size_t
250256
%3 = arith.shrsi %arg0, %arg1 : index
251257

252258
return

‎mlir/test/Conversion/SCFToEmitC/for.mlir

+16-16
Original file line numberDiff line numberDiff line change
@@ -33,7 +33,7 @@ func.func @simple_std_2_for_loops(%arg0 : index, %arg1 : index, %arg2 : index) {
3333
// CHECK-NEXT: %[[VAL_0:.*]] = builtin.unrealized_conversion_cast %[[ARG_0]] : index to !emitc.size_t
3434
// CHECK-NEXT: emitc.for %[[VAL_3:.*]] = %[[VAL_0]] to %[[VAL_1]] step %[[VAL_2]] : !emitc.size_t {
3535
// CHECK-NEXT: %[[VAL_4:.*]] = arith.constant 1 : index
36-
// CHECK-NEXT: emitc.for %[[VAL_5:.*]] = %[[VAL_0]] to %[[VAL_1]] step %[[VAL_2]] : !emitc.size_t {
36+
// CHECK-NEXT: for %[[VAL_5:.*]] = %[[VAL_0]] to %[[VAL_1]] step %[[VAL_2]] : !emitc.size_t {
3737
// CHECK-NEXT: %[[VAL_6:.*]] = arith.constant 1 : index
3838
// CHECK-NEXT: }
3939
// CHECK-NEXT: }
@@ -61,11 +61,11 @@ func.func @for_yield(%arg0 : index, %arg1 : index, %arg2 : index) -> (f32, f32)
6161
// CHECK-NEXT: emitc.assign %[[VAL_3]] : f32 to %[[VAL_5]] : <f32>
6262
// CHECK-NEXT: emitc.assign %[[VAL_4]] : f32 to %[[VAL_6]] : <f32>
6363
// CHECK-NEXT: emitc.for %[[VAL_7:.*]] = %[[VAL_0]] to %[[VAL_1]] step %[[VAL_2]] : !emitc.size_t {
64-
// CHECK-NEXT: %[[VAL_8:.*]] = emitc.load %[[VAL_5]] : <f32>
65-
// CHECK-NEXT: %[[VAL_9:.*]] = emitc.load %[[VAL_6]] : <f32>
64+
// CHECK-NEXT: %[[VAL_8:.*]] = load %[[VAL_5]] : <f32>
65+
// CHECK-NEXT: %[[VAL_9:.*]] = load %[[VAL_6]] : <f32>
6666
// CHECK-NEXT: %[[VAL_10:.*]] = arith.addf %[[VAL_8]], %[[VAL_9]] : f32
67-
// CHECK-NEXT: emitc.assign %[[VAL_10]] : f32 to %[[VAL_5]] : <f32>
68-
// CHECK-NEXT: emitc.assign %[[VAL_10]] : f32 to %[[VAL_6]] : <f32>
67+
// CHECK-NEXT: assign %[[VAL_10]] : f32 to %[[VAL_5]] : <f32>
68+
// CHECK-NEXT: assign %[[VAL_10]] : f32 to %[[VAL_6]] : <f32>
6969
// CHECK-NEXT: }
7070
// CHECK-NEXT: %[[VAL_11:.*]] = emitc.load %[[VAL_5]] : <f32>
7171
// CHECK-NEXT: %[[VAL_12:.*]] = emitc.load %[[VAL_6]] : <f32>
@@ -92,16 +92,16 @@ func.func @nested_for_yield(%arg0 : index, %arg1 : index, %arg2 : index) -> f32
9292
// CHECK-NEXT: %[[VAL_4:.*]] = "emitc.variable"() <{value = #emitc.opaque<"">}> : () -> !emitc.lvalue<f32>
9393
// CHECK-NEXT: emitc.assign %[[VAL_3]] : f32 to %[[VAL_4]] : <f32>
9494
// CHECK-NEXT: emitc.for %[[VAL_5:.*]] = %[[VAL_0]] to %[[VAL_1]] step %[[VAL_2]] : !emitc.size_t {
95-
// CHECK-NEXT: %[[VAL_6:.*]] = emitc.load %[[VAL_4]] : <f32>
95+
// CHECK-NEXT: %[[VAL_6:.*]] = load %[[VAL_4]] : <f32>
9696
// CHECK-NEXT: %[[VAL_7:.*]] = "emitc.variable"() <{value = #emitc.opaque<"">}> : () -> !emitc.lvalue<f32>
97-
// CHECK-NEXT: emitc.assign %[[VAL_6]] : f32 to %[[VAL_7]] : <f32>
98-
// CHECK-NEXT: emitc.for %[[VAL_8:.*]] = %[[VAL_0]] to %[[VAL_1]] step %[[VAL_2]] : !emitc.size_t {
99-
// CHECK-NEXT: %[[VAL_9:.*]] = emitc.load %[[VAL_7]] : <f32>
97+
// CHECK-NEXT: assign %[[VAL_6]] : f32 to %[[VAL_7]] : <f32>
98+
// CHECK-NEXT: for %[[VAL_8:.*]] = %[[VAL_0]] to %[[VAL_1]] step %[[VAL_2]] : !emitc.size_t {
99+
// CHECK-NEXT: %[[VAL_9:.*]] = load %[[VAL_7]] : <f32>
100100
// CHECK-NEXT: %[[VAL_10:.*]] = arith.addf %[[VAL_9]], %[[VAL_9]] : f32
101-
// CHECK-NEXT: emitc.assign %[[VAL_10]] : f32 to %[[VAL_7]] : <f32>
101+
// CHECK-NEXT: assign %[[VAL_10]] : f32 to %[[VAL_7]] : <f32>
102102
// CHECK-NEXT: }
103-
// CHECK-NEXT: %[[VAL_11:.*]] = emitc.load %[[VAL_7]] : <f32>
104-
// CHECK-NEXT: emitc.assign %[[VAL_11]] : f32 to %[[VAL_4]] : <f32>
103+
// CHECK-NEXT: %[[VAL_11:.*]] = load %[[VAL_7]] : <f32>
104+
// CHECK-NEXT: assign %[[VAL_11]] : f32 to %[[VAL_4]] : <f32>
105105
// CHECK-NEXT: }
106106
// CHECK-NEXT: %[[VAL_12:.*]] = emitc.load %[[VAL_4]] : <f32>
107107
// CHECK-NEXT: return %[[VAL_12]] : f32
@@ -125,8 +125,8 @@ func.func @for_yield_index(%arg0 : index, %arg1 : index, %arg2 : index) -> index
125125
// CHECK: %[[VAL_4:.*]] = "emitc.variable"() <{value = #emitc.opaque<"">}> : () -> !emitc.lvalue<!emitc.size_t>
126126
// CHECK: emitc.assign %[[VAL_3]] : !emitc.size_t to %[[VAL_4]] : <!emitc.size_t>
127127
// CHECK: emitc.for %[[VAL_5:.*]] = %[[VAL_2]] to %[[VAL_1]] step %[[VAL_0]] : !emitc.size_t {
128-
// CHECK: %[[V:.*]] = emitc.load %[[VAL_4]] : <!emitc.size_t>
129-
// CHECK: emitc.assign %[[V]] : !emitc.size_t to %[[VAL_4]] : <!emitc.size_t>
128+
// CHECK: %[[V:.*]] = load %[[VAL_4]] : <!emitc.size_t>
129+
// CHECK: assign %[[V]] : !emitc.size_t to %[[VAL_4]] : <!emitc.size_t>
130130
// CHECK: }
131131
// CHECK: %[[V2:.*]] = emitc.load %[[VAL_4]] : <!emitc.size_t>
132132
// CHECK: %[[VAL_8:.*]] = builtin.unrealized_conversion_cast %[[V2]] : !emitc.size_t to index
@@ -153,11 +153,11 @@ func.func @for_yield_update_loop_carried_var(%arg0 : index, %arg1 : index, %arg2
153153
// CHECK: %[[VAL_4:.*]] = "emitc.variable"() <{value = #emitc.opaque<"">}> : () -> !emitc.lvalue<!emitc.size_t>
154154
// CHECK: emitc.assign %[[VAL_3]] : !emitc.size_t to %[[VAL_4]] : <!emitc.size_t>
155155
// CHECK: emitc.for %[[ARG_3:.*]] = %[[VAL_2]] to %[[VAL_1]] step %[[VAL_0]] : !emitc.size_t {
156-
// CHECK: %[[V:.*]] = emitc.load %[[VAL_4]] : <!emitc.size_t>
156+
// CHECK: %[[V:.*]] = load %[[VAL_4]] : <!emitc.size_t>
157157
// CHECK: %[[VAL_5:.*]] = builtin.unrealized_conversion_cast %[[V]] : !emitc.size_t to index
158158
// CHECK: %[[VAL_6:.*]] = arith.addi %[[VAL_5]], %[[VAL_5]] : index
159159
// CHECK: %[[VAL_8:.*]] = builtin.unrealized_conversion_cast %[[VAL_6]] : index to !emitc.size_t
160-
// CHECK: emitc.assign %[[VAL_8]] : !emitc.size_t to %[[VAL_4]] : <!emitc.size_t>
160+
// CHECK: assign %[[VAL_8]] : !emitc.size_t to %[[VAL_4]] : <!emitc.size_t>
161161
// CHECK: }
162162
// CHECK: %[[V2:.*]] = emitc.load %[[VAL_4]] : <!emitc.size_t>
163163
// CHECK: %[[VAL_9:.*]] = builtin.unrealized_conversion_cast %[[V2]] : !emitc.size_t to index

‎mlir/test/Conversion/SCFToEmitC/if.mlir

+11-11
Original file line numberDiff line numberDiff line change
@@ -10,7 +10,7 @@ func.func @test_if(%arg0: i1, %arg1: f32) {
1010
// CHECK-SAME: %[[VAL_0:.*]]: i1,
1111
// CHECK-SAME: %[[VAL_1:.*]]: f32) {
1212
// CHECK-NEXT: emitc.if %[[VAL_0]] {
13-
// CHECK-NEXT: %[[VAL_2:.*]] = emitc.call_opaque "func_const"(%[[VAL_1]]) : (f32) -> i32
13+
// CHECK-NEXT: %[[VAL_2:.*]] = call_opaque "func_const"(%[[VAL_1]]) : (f32) -> i32
1414
// CHECK-NEXT: }
1515
// CHECK-NEXT: return
1616
// CHECK-NEXT: }
@@ -28,9 +28,9 @@ func.func @test_if_else(%arg0: i1, %arg1: f32) {
2828
// CHECK-SAME: %[[VAL_0:.*]]: i1,
2929
// CHECK-SAME: %[[VAL_1:.*]]: f32) {
3030
// CHECK-NEXT: emitc.if %[[VAL_0]] {
31-
// CHECK-NEXT: %[[VAL_2:.*]] = emitc.call_opaque "func_true"(%[[VAL_1]]) : (f32) -> i32
31+
// CHECK-NEXT: %[[VAL_2:.*]] = call_opaque "func_true"(%[[VAL_1]]) : (f32) -> i32
3232
// CHECK-NEXT: } else {
33-
// CHECK-NEXT: %[[VAL_3:.*]] = emitc.call_opaque "func_false"(%[[VAL_1]]) : (f32) -> i32
33+
// CHECK-NEXT: %[[VAL_3:.*]] = call_opaque "func_false"(%[[VAL_1]]) : (f32) -> i32
3434
// CHECK-NEXT: }
3535
// CHECK-NEXT: return
3636
// CHECK-NEXT: }
@@ -56,15 +56,15 @@ func.func @test_if_yield(%arg0: i1, %arg1: f32) -> (i32, f64) {
5656
// CHECK-NEXT: %[[VAL_3:.*]] = "emitc.variable"() <{value = #emitc.opaque<"">}> : () -> !emitc.lvalue<i32>
5757
// CHECK-NEXT: %[[VAL_4:.*]] = "emitc.variable"() <{value = #emitc.opaque<"">}> : () -> !emitc.lvalue<f64>
5858
// CHECK-NEXT: emitc.if %[[VAL_0]] {
59-
// CHECK-NEXT: %[[VAL_5:.*]] = emitc.call_opaque "func_true_1"(%[[VAL_1]]) : (f32) -> i32
60-
// CHECK-NEXT: %[[VAL_6:.*]] = emitc.call_opaque "func_true_2"(%[[VAL_1]]) : (f32) -> f64
61-
// CHECK-NEXT: emitc.assign %[[VAL_5]] : i32 to %[[VAL_3]] : <i32>
62-
// CHECK-NEXT: emitc.assign %[[VAL_6]] : f64 to %[[VAL_4]] : <f64>
59+
// CHECK-NEXT: %[[VAL_5:.*]] = call_opaque "func_true_1"(%[[VAL_1]]) : (f32) -> i32
60+
// CHECK-NEXT: %[[VAL_6:.*]] = call_opaque "func_true_2"(%[[VAL_1]]) : (f32) -> f64
61+
// CHECK-NEXT: assign %[[VAL_5]] : i32 to %[[VAL_3]] : <i32>
62+
// CHECK-NEXT: assign %[[VAL_6]] : f64 to %[[VAL_4]] : <f64>
6363
// CHECK-NEXT: } else {
64-
// CHECK-NEXT: %[[VAL_7:.*]] = emitc.call_opaque "func_false_1"(%[[VAL_1]]) : (f32) -> i32
65-
// CHECK-NEXT: %[[VAL_8:.*]] = emitc.call_opaque "func_false_2"(%[[VAL_1]]) : (f32) -> f64
66-
// CHECK-NEXT: emitc.assign %[[VAL_7]] : i32 to %[[VAL_3]] : <i32>
67-
// CHECK-NEXT: emitc.assign %[[VAL_8]] : f64 to %[[VAL_4]] : <f64>
64+
// CHECK-NEXT: %[[VAL_7:.*]] = call_opaque "func_false_1"(%[[VAL_1]]) : (f32) -> i32
65+
// CHECK-NEXT: %[[VAL_8:.*]] = call_opaque "func_false_2"(%[[VAL_1]]) : (f32) -> f64
66+
// CHECK-NEXT: assign %[[VAL_7]] : i32 to %[[VAL_3]] : <i32>
67+
// CHECK-NEXT: assign %[[VAL_8]] : f64 to %[[VAL_4]] : <f64>
6868
// CHECK-NEXT: }
6969
// CHECK-NEXT: %[[VAL_9:.*]] = emitc.load %[[VAL_3]] : <i32>
7070
// CHECK-NEXT: %[[VAL_10:.*]] = emitc.load %[[VAL_4]] : <f64>

0 commit comments

Comments
 (0)