Skip to content

Commit cc5961e

Browse files
orbirilanza
orbiri
authored and
lanza
committed
[CIR] Force cir.cmp to always return bool (#1110)
It was always the intention for `cir.cmp` operations to return bool result. Due to missing constraints, a bug in codegen has slipped in which created `cir.cmp` operations with result type that matches the original AST expression type. In C, as opposed to C++, boolean expression types are "int". This resulted with extra operations being codegened around boolean expressions and their usage. This commit both enforces `cir.cmp` in the op definition and fixes the mentioned bug.
1 parent 78e8ff8 commit cc5961e

File tree

18 files changed

+531
-588
lines changed

18 files changed

+531
-588
lines changed

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

+1-2
Original file line numberDiff line numberDiff line change
@@ -1268,8 +1268,7 @@ def CmpOp : CIR_Op<"cmp", [Pure, SameTypeOperands]> {
12681268
```
12691269
}];
12701270

1271-
// TODO: get more accurate than CIR_AnyType
1272-
let results = (outs CIR_AnyType:$result);
1271+
let results = (outs CIR_BoolType:$result);
12731272
let arguments = (ins Arg<CmpOpKind, "cmp kind">:$kind,
12741273
CIR_AnyType:$lhs, CIR_AnyType:$rhs);
12751274

‎clang/lib/CIR/CodeGen/CIRGenExprScalar.cpp

+5-8
Original file line numberDiff line numberDiff line change
@@ -947,12 +947,11 @@ class ScalarExprEmitter : public StmtVisitor<ScalarExprEmitter, mlir::Value> {
947947
// Other kinds of vectors. Element-wise comparison returning
948948
// a vector.
949949
cir::CmpOpKind Kind = ClangCmpToCIRCmp(E->getOpcode());
950-
return Builder.create<cir::VecCmpOp>(CGF.getLoc(BOInfo.Loc),
951-
CGF.getCIRType(BOInfo.FullType),
952-
Kind, BOInfo.LHS, BOInfo.RHS);
950+
Result = Builder.create<cir::VecCmpOp>(
951+
CGF.getLoc(BOInfo.Loc), CGF.getCIRType(BOInfo.FullType), Kind,
952+
BOInfo.LHS, BOInfo.RHS);
953953
}
954-
}
955-
if (BOInfo.isFixedPointOp()) {
954+
} else if (BOInfo.isFixedPointOp()) {
956955
assert(0 && "not implemented");
957956
} else {
958957
// FIXME(cir): handle another if above for CIR equivalent on
@@ -966,9 +965,7 @@ class ScalarExprEmitter : public StmtVisitor<ScalarExprEmitter, mlir::Value> {
966965
}
967966

968967
cir::CmpOpKind Kind = ClangCmpToCIRCmp(E->getOpcode());
969-
return Builder.create<cir::CmpOp>(CGF.getLoc(BOInfo.Loc),
970-
CGF.getCIRType(BOInfo.FullType), Kind,
971-
BOInfo.LHS, BOInfo.RHS);
968+
Result = Builder.createCompare(CGF.getLoc(BOInfo.Loc), Kind, LHS, RHS);
972969
}
973970
} else { // Complex Comparison: can only be an equality comparison.
974971
assert(0 && "not implemented");

‎clang/test/CIR/CodeGen/bf16-ops.c

+145-144
Large diffs are not rendered by default.

‎clang/test/CIR/CodeGen/float16-ops.c

+72-72
Large diffs are not rendered by default.

‎clang/test/CIR/CodeGen/fp16-ops.c

+36-36
Original file line numberDiff line numberDiff line change
@@ -228,145 +228,145 @@ void foo(void) {
228228
// CHECK-LLVM-NEXT: %{{.+}} = fsub half %{{.+}}, %[[#A]]
229229

230230
test = (h2 < h0);
231-
// CHECK: %[[#A:]] = cir.cmp(lt, %{{.+}}, %{{.+}}) : !cir.f16, !s32i
231+
// CHECK: %[[#A:]] = cir.cmp(lt, %{{.+}}, %{{.+}}) : !cir.f16, !cir.bool
232232
// CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#A]] : !s32i), !u32i
233233

234234
// CHECK-LLVM: %{{.+}} = fcmp olt half %{{.+}}, %{{.+}}
235235

236236
test = (h2 < (__fp16)42.0);
237237
// CHECK: %[[#A:]] = cir.const #cir.fp<4.200000e+01> : !cir.double
238238
// CHECK-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.double), !cir.f16
239-
// CHECK-NEXT: %[[#C:]] = cir.cmp(lt, %{{.+}}, %[[#B]]) : !cir.f16, !s32i
239+
// CHECK-NEXT: %[[#C:]] = cir.cmp(lt, %{{.+}}, %[[#B]]) : !cir.f16, !cir.bool
240240
// CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#C]] : !s32i), !u32i
241241

242242
// CHECK-LLVM: %{{.+}} = fcmp olt half %{{.+}}, 0xH5140
243243

244244
test = (h2 < f0);
245245
// CHECK: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
246-
// CHECK: %[[#B:]] = cir.cmp(lt, %[[#A]], %{{.+}}) : !cir.float, !s32i
246+
// CHECK: %[[#B:]] = cir.cmp(lt, %[[#A]], %{{.+}}) : !cir.float, !cir.bool
247247
// CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
248248

249249
// CHECK-LLVM: %[[#A:]] = fpext half %{{.+}} to float
250250
// CHECK-LLVM: %{{.+}} = fcmp olt float %[[#A]], %{{.+}}
251251

252252
test = (f2 < h0);
253253
// CHECK: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
254-
// CHECK-NEXT: %[[#B:]] = cir.cmp(lt, %{{.+}}, %[[#A]]) : !cir.float, !s32i
254+
// CHECK-NEXT: %[[#B:]] = cir.cmp(lt, %{{.+}}, %[[#A]]) : !cir.float, !cir.bool
255255
// CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
256256

257257
// CHECK-LLVM: %[[#A:]] = fpext half %{{.=}} to float
258258
// CHECK-LLVM-NEXT: %{{.+}} = fcmp olt float %{{.+}}, %[[#A]]
259259

260260
test = (i0 < h0);
261261
// CHECK: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
262-
// CHECK: %[[#B:]] = cir.cmp(lt, %[[#A]], %{{.+}}) : !cir.f16, !s32i
262+
// CHECK: %[[#B:]] = cir.cmp(lt, %[[#A]], %{{.+}}) : !cir.f16, !cir.bool
263263
// CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
264264

265265
// CHECK-LLVM: %[[#A:]] = sitofp i32 %{{.+}} to half
266266
// CHECK-LLVM: %{{.+}} = fcmp olt half %[[#A]], %{{.+}}
267267

268268
test = (h0 < i0);
269269
// CHECK: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
270-
// CHECK-NEXT: %[[#B:]] = cir.cmp(lt, %{{.+}}, %[[#A]]) : !cir.f16, !s32i
270+
// CHECK-NEXT: %[[#B:]] = cir.cmp(lt, %{{.+}}, %[[#A]]) : !cir.f16, !cir.bool
271271
// CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
272272

273273
// CHECK-LLVM: %[[#A:]] = sitofp i32 %{{.+}} to half
274274
// CHECK-LLVM-NEXT: %{{.+}} = fcmp olt half %{{.+}}, %[[#A]]
275275

276276
test = (h0 > h2);
277-
// CHECK: %[[#A:]] = cir.cmp(gt, %{{.+}}, %{{.+}}) : !cir.f16, !s32i
277+
// CHECK: %[[#A:]] = cir.cmp(gt, %{{.+}}, %{{.+}}) : !cir.f16, !cir.bool
278278
// CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#A]] : !s32i), !u32i
279279

280280
// CHECK-LLVM: %{{.+}} = fcmp ogt half %{{.+}}, %{{.+}}
281281

282282
test = ((__fp16)42.0 > h2);
283283
// CHECK: %[[#A:]] = cir.const #cir.fp<4.200000e+01> : !cir.double
284284
// CHECK-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.double), !cir.f16
285-
// CHECK: %[[#C:]] = cir.cmp(gt, %[[#B]], %{{.+}}) : !cir.f16, !s32i
285+
// CHECK: %[[#C:]] = cir.cmp(gt, %[[#B]], %{{.+}}) : !cir.f16, !cir.bool
286286
// CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#C]] : !s32i), !u32i
287287

288288
// CHECK-LLVM: %{{.+}} = fcmp ogt half 0xH5140, %{{.+}}
289289

290290
test = (h0 > f2);
291291
// CHECK: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
292-
// CHECK: %[[#B:]] = cir.cmp(gt, %[[#A]], %{{.+}}) : !cir.float, !s32i
292+
// CHECK: %[[#B:]] = cir.cmp(gt, %[[#A]], %{{.+}}) : !cir.float, !cir.bool
293293
// CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
294294

295295
// CHECK-LLVM: %[[#LHS:]] = fpext half %{{.=}} to float
296296
// CHECK-LLVM: %{{.+}} = fcmp ogt float %[[#LHS]], %{{.+}}
297297

298298
test = (f0 > h2);
299299
// CHECK: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
300-
// CHECK-NEXT: %[[#B:]] = cir.cmp(gt, %{{.+}}, %[[#A]]) : !cir.float, !s32i
300+
// CHECK-NEXT: %[[#B:]] = cir.cmp(gt, %{{.+}}, %[[#A]]) : !cir.float, !cir.bool
301301
// CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
302302

303303
// CHECK-LLVM: %[[#RHS:]] = fpext half %{{.+}} to float
304304
// CHECK-LLVM-NEXT: %{{.+}} = fcmp ogt float %{{.+}}, %[[#RHS]]
305305

306306
test = (i0 > h0);
307307
// CHECK: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
308-
// CHECK: %[[#B:]] = cir.cmp(gt, %[[#A]], %{{.+}}) : !cir.f16, !s32i
308+
// CHECK: %[[#B:]] = cir.cmp(gt, %[[#A]], %{{.+}}) : !cir.f16, !cir.bool
309309
// CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
310310

311311
// CHECK-LLVM: %[[#LHS:]] = sitofp i32 %{{.+}} to half
312312
// CHECK-LLVM: %{{.+}} = fcmp ogt half %[[#LHS]], %{{.+}}
313313

314314
test = (h0 > i0);
315315
// CHECK: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
316-
// CHECK-NEXT: %[[#B:]] = cir.cmp(gt, %{{.+}}, %[[#A]]) : !cir.f16, !s32i
316+
// CHECK-NEXT: %[[#B:]] = cir.cmp(gt, %{{.+}}, %[[#A]]) : !cir.f16, !cir.bool
317317
// CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
318318

319319
// CHECK-LLVM: %[[#RHS:]] = sitofp i32 %{{.+}} to half
320320
// CHECK-LLVM-NEXT: %{{.+}} = fcmp ogt half %{{.+}}, %[[#RHS]]
321321

322322
test = (h2 <= h0);
323-
// CHECK: %[[#A:]] = cir.cmp(le, %{{.+}}, %{{.+}}) : !cir.f16, !s32i
323+
// CHECK: %[[#A:]] = cir.cmp(le, %{{.+}}, %{{.+}}) : !cir.f16, !cir.bool
324324
// CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#A]] : !s32i), !u32i
325325

326326
// CHECK-LLVM: %{{.+}} = fcmp ole half %{{.+}}, %{{.+}}
327327

328328
test = (h2 <= (__fp16)42.0);
329329
// CHECK: %[[#A:]] = cir.const #cir.fp<4.200000e+01> : !cir.double
330330
// CHECK-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.double), !cir.f16
331-
// CHECK-NEXT: %[[#C:]] = cir.cmp(le, %{{.+}}, %[[#B]]) : !cir.f16, !s32i
331+
// CHECK-NEXT: %[[#C:]] = cir.cmp(le, %{{.+}}, %[[#B]]) : !cir.f16, !cir.bool
332332
// CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#C]] : !s32i), !u32i
333333

334334
// CHECK-LLVM: %{{.+}} = fcmp ole half %{{.+}}, 0xH5140
335335

336336
test = (h2 <= f0);
337337
// CHECK: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
338-
// CHECK: %[[#B:]] = cir.cmp(le, %[[#A]], %{{.+}}) : !cir.float, !s32i
338+
// CHECK: %[[#B:]] = cir.cmp(le, %[[#A]], %{{.+}}) : !cir.float, !cir.bool
339339
// CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
340340

341341
// CHECK-LLVM: %[[#LHS:]] = fpext half %{{.+}} to float
342342
// CHECK-LLVM: %{{.+}} = fcmp ole float %[[#LHS]], %{{.+}}
343343

344344
test = (f2 <= h0);
345345
// CHECK: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
346-
// CHECK-NEXT: %[[#B:]] = cir.cmp(le, %{{.+}}, %[[#A]]) : !cir.float, !s32i
346+
// CHECK-NEXT: %[[#B:]] = cir.cmp(le, %{{.+}}, %[[#A]]) : !cir.float, !cir.bool
347347
// CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
348348

349349
// CHECK-LLVM: %[[#RHS:]] = fpext half %{{.+}} to float
350350
// CHECK-LLVM-NEXT: %{{.+}} = fcmp ole float %{{.+}}, %[[#RHS]]
351351

352352
test = (i0 <= h0);
353353
// CHECK: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
354-
// CHECK: %[[#B:]] = cir.cmp(le, %[[#A]], %{{.+}}) : !cir.f16, !s32i
354+
// CHECK: %[[#B:]] = cir.cmp(le, %[[#A]], %{{.+}}) : !cir.f16, !cir.bool
355355
// CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
356356

357357
// CHECK-LLVM: %[[#LHS:]] = sitofp i32 %{{.+}} to half
358358
// CHECK-LLVM: %{{.+}} = fcmp ole half %[[#LHS]], %{{.+}}
359359

360360
test = (h0 <= i0);
361361
// CHECK: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
362-
// CHECK-NEXT: %[[#B:]] = cir.cmp(le, %{{.+}}, %[[#A]]) : !cir.f16, !s32i
362+
// CHECK-NEXT: %[[#B:]] = cir.cmp(le, %{{.+}}, %[[#A]]) : !cir.f16, !cir.bool
363363
// CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
364364

365365
// CHECK-LLVM: %[[#RHS:]] = sitofp i32 %{{.+}} to half
366366
// CHECK-LLVM-NEXT: %{{.+}} = fcmp ole half %{{.+}}, %[[#RHS]]
367367

368368
test = (h0 >= h2);
369-
// CHECK: %[[#A:]] = cir.cmp(ge, %{{.+}}, %{{.+}}) : !cir.f16, !s32i
369+
// CHECK: %[[#A:]] = cir.cmp(ge, %{{.+}}, %{{.+}}) : !cir.f16, !cir.bool
370370
// CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#A]] : !s32i), !u32i
371371

372372
// CHECK-LLVM: %{{.+}} = fcmp oge half %{{.+}}, %{{.+}}
@@ -375,130 +375,130 @@ void foo(void) {
375375
// CHECK: %[[#A:]] = cir.const #cir.fp<2.000000e+00> : !cir.double
376376
// CHECK-NEXT: %[[#B:]] = cir.unary(minus, %[[#A]]) : !cir.double, !cir.double
377377
// CHECK-NEXT: %[[#C:]] = cir.cast(floating, %[[#B]] : !cir.double), !cir.f16
378-
// CHECK-NEXT: %[[#D:]] = cir.cmp(ge, %{{.+}}, %[[#C]]) : !cir.f16, !s32i
378+
// CHECK-NEXT: %[[#D:]] = cir.cmp(ge, %{{.+}}, %[[#C]]) : !cir.f16, !cir.bool
379379
// CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#D]] : !s32i), !u32i
380380

381381
// CHECK-LLVM: %{{.+}} = fcmp oge half %{{.+}}, 0xHC000
382382

383383
test = (h0 >= f2);
384384
// CHECK: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
385-
// CHECK: %[[#B:]] = cir.cmp(ge, %[[#A]], %{{.+}}) : !cir.float, !s32i
385+
// CHECK: %[[#B:]] = cir.cmp(ge, %[[#A]], %{{.+}}) : !cir.float, !cir.bool
386386
// CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
387387

388388
// CHECK-LLVM: %[[#LHS:]] = fpext half %{{.+}} to float
389389
// CHECK-LLVM: %{{.+}} = fcmp oge float %[[#LHS]], %{{.+}}
390390

391391
test = (f0 >= h2);
392392
// CHECK: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
393-
// CHECK-NEXT: %[[#B:]] = cir.cmp(ge, %{{.+}}, %[[#A]]) : !cir.float, !s32i
393+
// CHECK-NEXT: %[[#B:]] = cir.cmp(ge, %{{.+}}, %[[#A]]) : !cir.float, !cir.bool
394394
// CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
395395

396396
// CHECK-LLVM: %[[#RHS:]] = fpext half %{{.+}} to float
397397
// CHECK-LLVM-NEXT: %{{.+}} = fcmp oge float %{{.+}}, %[[#RHS]]
398398

399399
test = (i0 >= h0);
400400
// CHECK: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
401-
// CHECK: %[[#B:]] = cir.cmp(ge, %[[#A]], %{{.+}}) : !cir.f16, !s32i
401+
// CHECK: %[[#B:]] = cir.cmp(ge, %[[#A]], %{{.+}}) : !cir.f16, !cir.bool
402402
// CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
403403

404404
// CHECK-LLVM: %[[#LHS:]] = sitofp i32 %{{.+}} to half
405405
// CHECK-LLVM: %{{.+}} = fcmp oge half %[[#LHS]], %{{.+}}
406406

407407
test = (h0 >= i0);
408408
// CHECK: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
409-
// CHECK-NEXT: %[[#B:]] = cir.cmp(ge, %{{.+}}, %[[#A]]) : !cir.f16, !s32i
409+
// CHECK-NEXT: %[[#B:]] = cir.cmp(ge, %{{.+}}, %[[#A]]) : !cir.f16, !cir.bool
410410
// CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
411411

412412
// CHECK-LLVM: %[[#RHS:]] = sitofp i32 %{{.+}} to half
413413
// CHECK-LLVM-NEXT: %{{.+}} = fcmp oge half %{{.+}}, %[[#RHS]]
414414

415415
test = (h1 == h2);
416-
// CHECK: %[[#A:]] = cir.cmp(eq, %{{.+}}, %{{.+}}) : !cir.f16, !s32i
416+
// CHECK: %[[#A:]] = cir.cmp(eq, %{{.+}}, %{{.+}}) : !cir.f16, !cir.bool
417417
// CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#A]] : !s32i), !u32i
418418

419419
// CHECK-LLVM: %{{.+}} = fcmp oeq half %{{.+}}, %{{.+}}
420420

421421
test = (h1 == (__fp16)1.0);
422422
// CHECK: %[[#A:]] = cir.const #cir.fp<1.000000e+00> : !cir.double
423423
// CHECK-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.double), !cir.f16
424-
// CHECK-NEXT: %[[#C:]] = cir.cmp(eq, %{{.+}}, %[[#B]]) : !cir.f16, !s32i
424+
// CHECK-NEXT: %[[#C:]] = cir.cmp(eq, %{{.+}}, %[[#B]]) : !cir.f16, !cir.bool
425425
// CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#C]] : !s32i), !u32i
426426

427427
// CHECK-LLVM: %{{.+}} = fcmp oeq half %{{.+}}, 0xH3C00
428428

429429
test = (h1 == f1);
430430
// CHECK: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
431-
// CHECK: %[[#B:]] = cir.cmp(eq, %[[#A]], %{{.+}}) : !cir.float, !s32i
431+
// CHECK: %[[#B:]] = cir.cmp(eq, %[[#A]], %{{.+}}) : !cir.float, !cir.bool
432432
// CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
433433

434434
// CHECK-LLVM: %[[#LHS:]] = fpext half %{{.+}} to float
435435
// CHECK-LLVM: %{{.+}} = fcmp oeq float %[[#LHS]], %{{.+}}
436436

437437
test = (f1 == h1);
438438
// CHECK: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
439-
// CHECK-NEXT: %[[#B:]] = cir.cmp(eq, %{{.+}}, %[[#A]]) : !cir.float, !s32i
439+
// CHECK-NEXT: %[[#B:]] = cir.cmp(eq, %{{.+}}, %[[#A]]) : !cir.float, !cir.bool
440440
// CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
441441

442442
// CHECK-LLVM: %[[#RHS:]] = fpext half %{{.+}} to float
443443
// CHECK-LLVM-NEXT: %{{.+}} = fcmp oeq float %{{.+}}, %[[#RHS]]
444444

445445
test = (i0 == h0);
446446
// CHECK: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
447-
// CHECK: %[[#B:]] = cir.cmp(eq, %[[#A]], %{{.+}}) : !cir.f16, !s32i
447+
// CHECK: %[[#B:]] = cir.cmp(eq, %[[#A]], %{{.+}}) : !cir.f16, !cir.bool
448448
// CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
449449

450450
// CHECK-LLVM: %[[#LHS:]] = sitofp i32 %{{.+}} to half
451451
// CHECK-LLVM: %{{.+}} = fcmp oeq half %[[#LHS]], %{{.+}}
452452

453453
test = (h0 == i0);
454454
// CHECK: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
455-
// CHECK-NEXT: %[[#B:]] = cir.cmp(eq, %{{.+}}, %[[#A]]) : !cir.f16, !s32i
455+
// CHECK-NEXT: %[[#B:]] = cir.cmp(eq, %{{.+}}, %[[#A]]) : !cir.f16, !cir.bool
456456
// CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
457457

458458
// CHECK-LLVM: %[[#RHS:]] = sitofp i32 %{{.+}} to half
459459
// CHECK-LLVM-NEXT: %{{.=}} = fcmp oeq half %{{.+}}, %[[#RHS]]
460460

461461
test = (h1 != h2);
462-
// CHECK: %[[#A:]] = cir.cmp(ne, %{{.+}}, %{{.+}}) : !cir.f16, !s32i
462+
// CHECK: %[[#A:]] = cir.cmp(ne, %{{.+}}, %{{.+}}) : !cir.f16, !cir.bool
463463
// CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#A]] : !s32i), !u32i
464464

465465
// CHECK-LLVM: %{{.+}} = fcmp une half %{{.+}}, %{{.+}}
466466

467467
test = (h1 != (__fp16)1.0);
468468
// CHECK: %[[#A:]] = cir.const #cir.fp<1.000000e+00> : !cir.double
469469
// CHECK-NEXT: %[[#B:]] = cir.cast(floating, %[[#A]] : !cir.double), !cir.f16
470-
// CHECK-NEXT: %[[#C:]] = cir.cmp(ne, %{{.+}}, %[[#B]]) : !cir.f16, !s32i
470+
// CHECK-NEXT: %[[#C:]] = cir.cmp(ne, %{{.+}}, %[[#B]]) : !cir.f16, !cir.bool
471471
// CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#C]] : !s32i), !u32i
472472

473473
// CHECK-LLVM: %{{.+}} = fcmp une half %{{.+}}, 0xH3C00
474474

475475
test = (h1 != f1);
476476
// CHECK: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
477-
// CHECK: %[[#B:]] = cir.cmp(ne, %[[#A]], %{{.+}}) : !cir.float, !s32i
477+
// CHECK: %[[#B:]] = cir.cmp(ne, %[[#A]], %{{.+}}) : !cir.float, !cir.bool
478478
// CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
479479

480480
// CHECK-LLVM: %[[#LHS:]] = fpext half %{{.=}} to float
481481
// CHECK-LLVM: %{{.+}} = fcmp une float %[[#LHS]], %{{.+}}
482482

483483
test = (f1 != h1);
484484
// CHECK: %[[#A:]] = cir.cast(floating, %{{.+}} : !cir.f16), !cir.float
485-
// CHECK-NEXT: %[[#B:]] = cir.cmp(ne, %{{.+}}, %[[#A]]) : !cir.float, !s32i
485+
// CHECK-NEXT: %[[#B:]] = cir.cmp(ne, %{{.+}}, %[[#A]]) : !cir.float, !cir.bool
486486
// CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
487487

488488
// CHECK-LLVM: %[[#A:]] = fpext half %{{.+}} to float
489489
// CHECK-LLVM-NEXT: %{{.+}} = fcmp une float %{{.+}}, %[[#A]]
490490

491491
test = (i0 != h0);
492492
// CHECK: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
493-
// CHECK: %[[#B:]] = cir.cmp(ne, %[[#A]], %{{.+}}) : !cir.f16, !s32i
493+
// CHECK: %[[#B:]] = cir.cmp(ne, %[[#A]], %{{.+}}) : !cir.f16, !cir.bool
494494
// CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
495495

496496
// CHECK-LLVM: %[[#LHS:]] = sitofp i32 %{{.+}} to half
497497
// CHECK-LLVM: %{{.+}} = fcmp une half %[[#LHS]], %{{.+}}
498498

499499
test = (h0 != i0);
500500
// CHECK: %[[#A:]] = cir.cast(int_to_float, %{{.+}} : !s32i), !cir.f16
501-
// CHECK-NEXT: %[[#B:]] = cir.cmp(ne, %{{.+}}, %[[#A]]) : !cir.f16, !s32i
501+
// CHECK-NEXT: %[[#B:]] = cir.cmp(ne, %{{.+}}, %[[#A]]) : !cir.f16, !cir.bool
502502
// CHECK-NEXT: %{{.+}} = cir.cast(integral, %[[#B]] : !s32i), !u32i
503503

504504
// CHECK-LLVM: %[[#RHS:]] = sitofp i32 %{{.+}} to half

‎clang/test/CIR/IR/invalid.cir

+10
Original file line numberDiff line numberDiff line change
@@ -1438,3 +1438,13 @@ cir.global external @f = #cir.fp<0x7FC00000 : !cir.float> : !cir.float
14381438
// expected-error @below {{unexpected decimal integer literal for a floating point value}}
14391439
// expected-note @below {{add a trailing dot to make the literal a float}}
14401440
cir.global external @f = #cir.fp<42> : !cir.float
1441+
1442+
// -----
1443+
1444+
// Verify
1445+
!s32i = !cir.int<s, 32>
1446+
cir.func @cast0(%arg0: !s32i, %arg1: !s32i) {
1447+
// expected-error @below {{custom op 'cir.cmp' invalid kind of Type specified}}
1448+
%1 = cir.cmp(eq, %arg0, %arg1): !s32i, !s32i
1449+
cir.return
1450+
}

0 commit comments

Comments
 (0)