Skip to content

Commit c85f28b

Browse files
schweitzpgischweitzpgi
committed
Fix tests.
Signed-off-by: Eric Schweitz <eschweitz@nvidia.com>
1 parent 72930cc commit c85f28b

File tree

13 files changed

+348
-398
lines changed

13 files changed

+348
-398
lines changed

‎python/cudaq/kernel/kernel_builder.py‎

Lines changed: 12 additions & 8 deletions
Original file line numberDiff line numberDiff line change
@@ -1122,10 +1122,12 @@ def mx(self, target, regName=None):
11221122
if quake.VeqType.isinstance(target.mlirValue.type):
11231123
retTy = stdvecTy
11241124
measTy = cc.StdvecType.get(self.ctx, measTy)
1125-
res = quake.MxOp(
1126-
measTy, [], [target.mlirValue],
1127-
registerName=StringAttr.get(regName, context=self.ctx)
1128-
if regName is not None else '')
1125+
if regName is not None:
1126+
res = quake.MxOp(measTy, [], [target.mlirValue],
1127+
registerName=StringAttr.get(regName,
1128+
context=self.ctx))
1129+
else:
1130+
res = quake.MxOp(measTy, [], [target.mlirValue])
11291131
disc = quake.DiscriminateOp(retTy, res)
11301132
return self.__createQuakeValue(disc.result)
11311133

@@ -1167,10 +1169,12 @@ def my(self, target, regName=None):
11671169
if quake.VeqType.isinstance(target.mlirValue.type):
11681170
retTy = stdvecTy
11691171
measTy = cc.StdvecType.get(self.ctx, measTy)
1170-
res = quake.MyOp(
1171-
measTy, [], [target.mlirValue],
1172-
registerName=StringAttr.get(regName, context=self.ctx)
1173-
if regName is not None else '')
1172+
if regName is not None:
1173+
res = quake.MyOp(measTy, [], [target.mlirValue],
1174+
registerName=StringAttr.get(regName,
1175+
context=self.ctx))
1176+
else:
1177+
res = quake.MyOp(measTy, [], [target.mlirValue])
11741178
disc = quake.DiscriminateOp(retTy, res)
11751179
return self.__createQuakeValue(disc.result)
11761180

‎python/tests/mlir/adjoint.py‎

Lines changed: 2 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -241,7 +241,7 @@ def test_sample_adjoint_qubit():
241241
# CHECK: quake.x %[[VAL_0]] : (!quake.ref) -> ()
242242
# CHECK: call @__nvqpp__mlirgen____nvqppBuilderKernel_{{.*}}(%[[VAL_0]]) : (!quake.ref) -> ()
243243
# CHECK: quake.apply<adj> @__nvqpp__mlirgen____nvqppBuilderKernel_{{.*}} %[[VAL_0]] : (!quake.ref) -> ()
244-
# CHECK: %[[VAL_1:.*]] = quake.mz %[[VAL_0]] name "" : (!quake.ref) -> !quake.measure
244+
# CHECK: %[[VAL_1:.*]] = quake.mz %[[VAL_0]] : (!quake.ref) -> !quake.measure
245245
# CHECK: return
246246
# CHECK: }
247247

@@ -302,7 +302,7 @@ def test_sample_adjoint_qreg():
302302
# CHECK: } {invariant}
303303
# CHECK: call @__nvqpp__mlirgen____nvqppBuilderKernel_{{.*}}(%[[VAL_3]]) : (!quake.veq<?>) -> ()
304304
# CHECK: quake.apply<adj> @__nvqpp__mlirgen____nvqppBuilderKernel_{{.*}} %[[VAL_3]] : (!quake.veq<?>) -> ()
305-
# CHECK: %[[VAL_13:.*]] = quake.mz %0 name "" : (!quake.veq<?>) -> !cc.stdvec<!quake.measure>
305+
# CHECK: %[[VAL_13:.*]] = quake.mz %0 : (!quake.veq<?>) -> !cc.stdvec<!quake.measure>
306306
# CHECK: return
307307
# CHECK: }
308308

‎python/tests/mlir/ast_elif.py‎

Lines changed: 67 additions & 45 deletions
Original file line numberDiff line numberDiff line change
@@ -30,58 +30,80 @@ def cost(thetas: np.ndarray): # can pass 1D ndarray or list
3030

3131

3232
# CHECK-LABEL: func.func @__nvqpp__mlirgen__cost(
33-
# CHECK-SAME: %[[VAL_0:.*]]: !cc.stdvec<f64>) attributes {"cudaq-entrypoint", "cudaq-kernel"} {
34-
# CHECK-DAG: %[[VAL_1:.*]] = arith.constant 2 : i64
35-
# CHECK-DAG: %[[VAL_2:.*]] = arith.constant 1 : i64
36-
# CHECK-DAG: %[[VAL_3:.*]] = arith.constant 0 : i64
37-
# CHECK-DAG: %[[VAL_4:.*]] = arith.constant 4 : i64
38-
# CHECK: %[[VAL_5:.*]] = quake.alloca !quake.veq<4>
39-
# CHECK: %[[VAL_6:.*]] = cc.stdvec_size %[[VAL_0]] : (!cc.stdvec<f64>) -> i64
40-
# CHECK: %[[VAL_7:.*]] = cc.alloca !cc.struct<{i64, f64}>{{\[}}%[[VAL_6]] : i64]
41-
# CHECK: %[[VAL_8:.*]] = cc.loop while ((%[[VAL_9:.*]] = %[[VAL_3]]) -> (i64)) {
42-
# CHECK: %[[VAL_10:.*]] = arith.cmpi slt, %[[VAL_9]], %[[VAL_6]] : i64
43-
# CHECK: cc.condition %[[VAL_10]](%[[VAL_9]] : i64)
33+
# CHECK-SAME: %[[VAL_0:.*]]: !cc.stdvec<f64>) attributes {"cudaq-entrypoint", "cudaq-kernel"} {
34+
# CHECK: %[[VAL_1:.*]] = arith.constant 4 : i64
35+
# CHECK: %[[VAL_2:.*]] = quake.alloca !quake.veq<?>{{\[}}%[[VAL_1]] : i64]
36+
# CHECK: %[[VAL_3:.*]] = cc.stdvec_size %[[VAL_0]] : (!cc.stdvec<f64>) -> i64
37+
# CHECK: %[[VAL_4:.*]] = arith.constant 0 : i64
38+
# CHECK: %[[VAL_5:.*]] = arith.constant 1 : i64
39+
# CHECK: %[[VAL_6:.*]] = cc.loop while ((%[[VAL_7:.*]] = %[[VAL_4]]) -> (i64)) {
40+
# CHECK: %[[VAL_8:.*]] = arith.cmpi slt, %[[VAL_7]], %[[VAL_3]] : i64
41+
# CHECK: cc.condition %[[VAL_8]](%[[VAL_7]] : i64)
4442
# CHECK: } do {
45-
# CHECK: ^bb0(%[[VAL_11:.*]]: i64):
46-
# CHECK: %[[VAL_12:.*]] = cc.undef !cc.struct<{i64, f64}>
47-
# CHECK: %[[VAL_13:.*]] = cc.stdvec_data %[[VAL_0]] : (!cc.stdvec<f64>) -> !cc.ptr<!cc.array<f64 x ?>>
48-
# CHECK: %[[VAL_14:.*]] = cc.compute_ptr %[[VAL_13]][%[[VAL_11]]] : (!cc.ptr<!cc.array<f64 x ?>>, i64) -> !cc.ptr<f64>
49-
# CHECK: %[[VAL_15:.*]] = cc.load %[[VAL_14]] : !cc.ptr<f64>
50-
# CHECK: %[[VAL_16:.*]] = cc.compute_ptr %[[VAL_7]]{{\[}}%[[VAL_11]]] : (!cc.ptr<!cc.array<!cc.struct<{i64, f64}> x ?>>, i64) -> !cc.ptr<!cc.struct<{i64, f64}>>
51-
# CHECK: %[[VAL_17:.*]] = cc.insert_value %[[VAL_12]][0], %[[VAL_11]] : (!cc.struct<{i64, f64}>, i64) -> !cc.struct<{i64, f64}>
52-
# CHECK: %[[VAL_18:.*]] = cc.insert_value %[[VAL_17]][1], %[[VAL_15]] : (!cc.struct<{i64, f64}>, f64) -> !cc.struct<{i64, f64}>
53-
# CHECK: cc.store %[[VAL_18]], %[[VAL_16]] : !cc.ptr<!cc.struct<{i64, f64}>>
54-
# CHECK: cc.continue %[[VAL_11]] : i64
43+
# CHECK: ^bb0(%[[VAL_9:.*]]: i64):
44+
# CHECK: %[[VAL_10:.*]] = cc.stdvec_data %[[VAL_0]] : (!cc.stdvec<f64>) -> !cc.ptr<!cc.array<f64 x ?>>
45+
# CHECK: %[[VAL_11:.*]] = cc.compute_ptr %[[VAL_10]]{{\[}}%[[VAL_9]]] : (!cc.ptr<!cc.array<f64 x ?>>, i64) -> !cc.ptr<f64>
46+
# CHECK: %[[VAL_12:.*]] = arith.constant 2.000000e+00 : f64
47+
# CHECK: %[[VAL_13:.*]] = arith.fptosi %[[VAL_12]] : f64 to i64
48+
# CHECK: %[[VAL_14:.*]] = arith.remui %[[VAL_9]], %[[VAL_13]] : i64
49+
# CHECK: %[[VAL_15:.*]] = arith.constant 0 : i64
50+
# CHECK: %[[VAL_16:.*]] = arith.cmpi ne, %[[VAL_14]], %[[VAL_15]] : i64
51+
# CHECK: cc.if(%[[VAL_16]]) {
52+
# CHECK: %[[VAL_17:.*]] = cc.load %[[VAL_11]] : !cc.ptr<f64>
53+
# CHECK: %[[VAL_18:.*]] = arith.constant 4 : i64
54+
# CHECK: %[[VAL_19:.*]] = arith.remui %[[VAL_9]], %[[VAL_18]] : i64
55+
# CHECK: %[[VAL_20:.*]] = quake.extract_ref %[[VAL_2]]{{\[}}%[[VAL_19]]] : (!quake.veq<?>, i64) -> !quake.ref
56+
# CHECK: quake.ry (%[[VAL_17]]) %[[VAL_20]] : (f64, !quake.ref) -> ()
57+
# CHECK: } else {
58+
# CHECK: %[[VAL_21:.*]] = cc.load %[[VAL_11]] : !cc.ptr<f64>
59+
# CHECK: %[[VAL_22:.*]] = arith.constant 4 : i64
60+
# CHECK: %[[VAL_23:.*]] = arith.remui %[[VAL_9]], %[[VAL_22]] : i64
61+
# CHECK: %[[VAL_24:.*]] = quake.extract_ref %[[VAL_2]]{{\[}}%[[VAL_23]]] : (!quake.veq<?>, i64) -> !quake.ref
62+
# CHECK: quake.rx (%[[VAL_21]]) %[[VAL_24]] : (f64, !quake.ref) -> ()
63+
# CHECK: }
64+
# CHECK: cc.continue %[[VAL_9]] : i64
5565
# CHECK: } step {
56-
# CHECK: ^bb0(%[[VAL_19:.*]]: i64):
57-
# CHECK: %[[VAL_20:.*]] = arith.addi %[[VAL_19]], %[[VAL_2]] : i64
58-
# CHECK: cc.continue %[[VAL_20]] : i64
66+
# CHECK: ^bb0(%[[VAL_25:.*]]: i64):
67+
# CHECK: %[[VAL_26:.*]] = arith.addi %[[VAL_25]], %[[VAL_5]] : i64
68+
# CHECK: cc.continue %[[VAL_26]] : i64
5969
# CHECK: } {invariant}
60-
# CHECK: %[[VAL_21:.*]] = cc.loop while ((%[[VAL_22:.*]] = %[[VAL_3]]) -> (i64)) {
61-
# CHECK: %[[VAL_23:.*]] = arith.cmpi slt, %[[VAL_22]], %[[VAL_6]] : i64
62-
# CHECK: cc.condition %[[VAL_23]](%[[VAL_22]] : i64)
70+
# CHECK: return
71+
# CHECK: }
72+
73+
# CHECK-LABEL: func.func @__nvqpp__mlirgen__cost(
74+
# CHECK-SAME: %[[VAL_0:.*]]: !cc.stdvec<f64>) attributes {"cudaq-entrypoint", "cudaq-kernel"} {
75+
# CHECK-DAG: %[[VAL_1:.*]] = arith.constant 2 : i64
76+
# CHECK-DAG: %[[VAL_2:.*]] = arith.constant 1 : i64
77+
# CHECK-DAG: %[[VAL_3:.*]] = arith.constant 0 : i64
78+
# CHECK-DAG: %[[VAL_4:.*]] = arith.constant 4 : i64
79+
# CHECK-DAG: %[[VAL_5:.*]] = quake.alloca !quake.veq<4>
80+
# CHECK: %[[VAL_6:.*]] = cc.stdvec_size %[[VAL_0]] : (!cc.stdvec<f64>) -> i64
81+
# CHECK: %[[VAL_7:.*]] = cc.loop while ((%[[VAL_8:.*]] = %[[VAL_3]]) -> (i64)) {
82+
# CHECK: %[[VAL_9:.*]] = arith.cmpi slt, %[[VAL_8]], %[[VAL_6]] : i64
83+
# CHECK: cc.condition %[[VAL_9]](%[[VAL_8]] : i64)
6384
# CHECK: } do {
64-
# CHECK: ^bb0(%[[VAL_24:.*]]: i64):
65-
# CHECK: %[[VAL_25:.*]] = cc.compute_ptr %[[VAL_7]]{{\[}}%[[VAL_24]]] : (!cc.ptr<!cc.array<!cc.struct<{i64, f64}> x ?>>, i64) -> !cc.ptr<!cc.struct<{i64, f64}>>
66-
# CHECK: %[[VAL_26:.*]] = cc.load %[[VAL_25]] : !cc.ptr<!cc.struct<{i64, f64}>>
67-
# CHECK: %[[VAL_27:.*]] = cc.extract_value %[[VAL_26]][0] : (!cc.struct<{i64, f64}>) -> i64
68-
# CHECK: %[[VAL_28:.*]] = cc.extract_value %[[VAL_26]][1] : (!cc.struct<{i64, f64}>) -> f64
69-
# CHECK: %[[VAL_29:.*]] = arith.remui %[[VAL_27]], %[[VAL_1]] : i64
70-
# CHECK: %[[VAL_30:.*]] = arith.cmpi ne, %[[VAL_29]], %[[VAL_3]] : i64
71-
# CHECK: cc.if(%[[VAL_30]]) {
72-
# CHECK: %[[VAL_31:.*]] = arith.remui %[[VAL_27]], %[[VAL_4]] : i64
73-
# CHECK: %[[VAL_32:.*]] = quake.extract_ref %[[VAL_5]]{{\[}}%[[VAL_31]]] : (!quake.veq<4>, i64) -> !quake.ref
74-
# CHECK: quake.ry (%[[VAL_28]]) %[[VAL_32]] : (f64, !quake.ref) -> ()
85+
# CHECK: ^bb0(%[[VAL_10:.*]]: i64):
86+
# CHECK: %[[VAL_11:.*]] = cc.stdvec_data %[[VAL_0]] : (!cc.stdvec<f64>) -> !cc.ptr<!cc.array<f64 x ?>>
87+
# CHECK: %[[VAL_12:.*]] = cc.compute_ptr %[[VAL_11]]{{\[}}%[[VAL_10]]] : (!cc.ptr<!cc.array<f64 x ?>>, i64) -> !cc.ptr<f64>
88+
# CHECK: %[[VAL_13:.*]] = arith.remui %[[VAL_10]], %[[VAL_1]] : i64
89+
# CHECK: %[[VAL_14:.*]] = arith.cmpi ne, %[[VAL_13]], %[[VAL_3]] : i64
90+
# CHECK: cc.if(%[[VAL_14]]) {
91+
# CHECK: %[[VAL_15:.*]] = cc.load %[[VAL_12]] : !cc.ptr<f64>
92+
# CHECK: %[[VAL_16:.*]] = arith.remui %[[VAL_10]], %[[VAL_4]] : i64
93+
# CHECK: %[[VAL_17:.*]] = quake.extract_ref %[[VAL_5]]{{\[}}%[[VAL_16]]] : (!quake.veq<4>, i64) -> !quake.ref
94+
# CHECK: quake.ry (%[[VAL_15]]) %[[VAL_17]] : (f64, !quake.ref) -> ()
7595
# CHECK: } else {
76-
# CHECK: %[[VAL_33:.*]] = arith.remui %[[VAL_27]], %[[VAL_4]] : i64
77-
# CHECK: %[[VAL_34:.*]] = quake.extract_ref %[[VAL_5]]{{\[}}%[[VAL_33]]] : (!quake.veq<4>, i64) -> !quake.ref
78-
# CHECK: quake.rx (%[[VAL_28]]) %[[VAL_34]] : (f64, !quake.ref) -> ()
96+
# CHECK: %[[VAL_18:.*]] = cc.load %[[VAL_12]] : !cc.ptr<f64>
97+
# CHECK: %[[VAL_19:.*]] = arith.remui %[[VAL_10]], %[[VAL_4]] : i64
98+
# CHECK: %[[VAL_20:.*]] = quake.extract_ref %[[VAL_5]]{{\[}}%[[VAL_19]]] : (!quake.veq<4>, i64) -> !quake.ref
99+
# CHECK: quake.rx (%[[VAL_18]]) %[[VAL_20]] : (f64, !quake.ref) -> ()
79100
# CHECK: }
80-
# CHECK: cc.continue %[[VAL_24]] : i64
101+
# CHECK: cc.continue %[[VAL_10]] : i64
81102
# CHECK: } step {
82-
# CHECK: ^bb0(%[[VAL_35:.*]]: i64):
83-
# CHECK: %[[VAL_36:.*]] = arith.addi %[[VAL_35]], %[[VAL_2]] : i64
84-
# CHECK: cc.continue %[[VAL_36]] : i64
103+
# CHECK: ^bb0(%[[VAL_21:.*]]: i64):
104+
# CHECK: %[[VAL_22:.*]] = arith.addi %[[VAL_21]], %[[VAL_2]] : i64
105+
# CHECK: cc.continue %[[VAL_22]] : i64
85106
# CHECK: } {invariant}
86107
# CHECK: return
87108
# CHECK: }
109+

‎python/tests/mlir/ast_list_init.py‎

Lines changed: 24 additions & 44 deletions
Original file line numberDiff line numberDiff line change
@@ -34,56 +34,36 @@ def kernel():
3434
# CHECK-DAG: %[[VAL_6:.*]] = arith.constant 1.000000e+00 : f64
3535
# CHECK-DAG: %[[VAL_7:.*]] = quake.alloca !quake.veq<6>
3636
# CHECK-DAG: %[[VAL_8:.*]] = cc.alloca !cc.array<f64 x 4>
37-
# CHECK: %[[VAL_91:.*]] = cc.cast %[[VAL_8]] : (!cc.ptr<!cc.array<f64 x 4>>) -> !cc.ptr<!cc.array<f64 x ?>>
38-
# CHECK: %[[VAL_9:.*]] = cc.cast %[[VAL_8]] : (!cc.ptr<!cc.array<f64 x 4>>) -> !cc.ptr<f64>
39-
# CHECK: cc.store %[[VAL_6]], %[[VAL_9]] : !cc.ptr<f64>
40-
# CHECK: %[[VAL_10:.*]] = cc.compute_ptr %[[VAL_8]][1] : (!cc.ptr<!cc.array<f64 x 4>>) -> !cc.ptr<f64>
41-
# CHECK: cc.store %[[VAL_5]], %[[VAL_10]] : !cc.ptr<f64>
42-
# CHECK: %[[VAL_11:.*]] = cc.compute_ptr %[[VAL_8]][2] : (!cc.ptr<!cc.array<f64 x 4>>) -> !cc.ptr<f64>
43-
# CHECK: cc.store %[[VAL_4]], %[[VAL_11]] : !cc.ptr<f64>
44-
# CHECK: %[[VAL_12:.*]] = cc.compute_ptr %[[VAL_8]][3] : (!cc.ptr<!cc.array<f64 x 4>>) -> !cc.ptr<f64>
45-
# CHECK: cc.store %[[VAL_3]], %[[VAL_12]] : !cc.ptr<f64>
46-
# CHECK: %[[VAL_13:.*]] = cc.stdvec_init %[[VAL_91]], %[[VAL_2]] : (!cc.ptr<!cc.array<f64 x ?>>, i64) -> !cc.stdvec<f64>
47-
# CHECK: %[[VAL_14:.*]] = cc.alloca !cc.stdvec<f64>
48-
# CHECK: cc.store %[[VAL_13]], %[[VAL_14]] : !cc.ptr<!cc.stdvec<f64>>
49-
# CHECK: %[[VAL_15:.*]] = cc.load %[[VAL_14]] : !cc.ptr<!cc.stdvec<f64>>
50-
# CHECK: %[[VAL_16:.*]] = cc.stdvec_size %[[VAL_15]] : (!cc.stdvec<f64>) -> i64
51-
# CHECK: %[[VAL_17:.*]] = cc.alloca !cc.struct<{i64, f64}>[%[[VAL_16]] : i64]
37+
# CHECK: %[[VAL_9:.*]] = cc.cast %[[VAL_8]] : (!cc.ptr<!cc.array<f64 x 4>>) -> !cc.ptr<!cc.array<f64 x ?>>
38+
# CHECK: %[[VAL_10:.*]] = cc.cast %[[VAL_8]] : (!cc.ptr<!cc.array<f64 x 4>>) -> !cc.ptr<f64>
39+
# CHECK: cc.store %[[VAL_6]], %[[VAL_10]] : !cc.ptr<f64>
40+
# CHECK: %[[VAL_11:.*]] = cc.compute_ptr %[[VAL_8]][1] : (!cc.ptr<!cc.array<f64 x 4>>) -> !cc.ptr<f64>
41+
# CHECK: cc.store %[[VAL_5]], %[[VAL_11]] : !cc.ptr<f64>
42+
# CHECK: %[[VAL_12:.*]] = cc.compute_ptr %[[VAL_8]][2] : (!cc.ptr<!cc.array<f64 x 4>>) -> !cc.ptr<f64>
43+
# CHECK: cc.store %[[VAL_4]], %[[VAL_12]] : !cc.ptr<f64>
44+
# CHECK: %[[VAL_13:.*]] = cc.compute_ptr %[[VAL_8]][3] : (!cc.ptr<!cc.array<f64 x 4>>) -> !cc.ptr<f64>
45+
# CHECK: cc.store %[[VAL_3]], %[[VAL_13]] : !cc.ptr<f64>
46+
# CHECK: %[[VAL_14:.*]] = cc.stdvec_init %[[VAL_9]], %[[VAL_2]] : (!cc.ptr<!cc.array<f64 x ?>>, i64) -> !cc.stdvec<f64>
47+
# CHECK: %[[VAL_15:.*]] = cc.alloca !cc.stdvec<f64>
48+
# CHECK: cc.store %[[VAL_14]], %[[VAL_15]] : !cc.ptr<!cc.stdvec<f64>>
49+
# CHECK: %[[VAL_16:.*]] = cc.load %[[VAL_15]] : !cc.ptr<!cc.stdvec<f64>>
50+
# CHECK: %[[VAL_17:.*]] = cc.stdvec_size %[[VAL_16]] : (!cc.stdvec<f64>) -> i64
5251
# CHECK: %[[VAL_18:.*]] = cc.loop while ((%[[VAL_19:.*]] = %[[VAL_1]]) -> (i64)) {
53-
# CHECK: %[[VAL_20:.*]] = arith.cmpi slt, %[[VAL_19]], %[[VAL_16]] : i64
52+
# CHECK: %[[VAL_20:.*]] = arith.cmpi slt, %[[VAL_19]], %[[VAL_17]] : i64
5453
# CHECK: cc.condition %[[VAL_20]](%[[VAL_19]] : i64)
5554
# CHECK: } do {
5655
# CHECK: ^bb0(%[[VAL_21:.*]]: i64):
57-
# CHECK: %[[VAL_22:.*]] = cc.undef !cc.struct<{i64, f64}>
58-
# CHECK: %[[VAL_23:.*]] = cc.stdvec_data %[[VAL_15]] : (!cc.stdvec<f64>) -> !cc.ptr<!cc.array<f64 x ?>>
59-
# CHECK: %[[VAL_24:.*]] = cc.compute_ptr %[[VAL_23]][%[[VAL_21]]] : (!cc.ptr<!cc.array<f64 x ?>>, i64) -> !cc.ptr<f64>
60-
# CHECK: %[[VAL_25:.*]] = cc.load %[[VAL_24]] : !cc.ptr<f64>
61-
# CHECK: %[[VAL_26:.*]] = cc.compute_ptr %[[VAL_17]][%[[VAL_21]]] : (!cc.ptr<!cc.array<!cc.struct<{i64, f64}> x ?>>, i64) -> !cc.ptr<!cc.struct<{i64, f64}>>
62-
# CHECK: %[[VAL_27:.*]] = cc.insert_value %[[VAL_22]][0], %[[VAL_21]] : (!cc.struct<{i64, f64}>, i64) -> !cc.struct<{i64, f64}>
63-
# CHECK: %[[VAL_28:.*]] = cc.insert_value %[[VAL_27]][1], %[[VAL_25]] : (!cc.struct<{i64, f64}>, f64) -> !cc.struct<{i64, f64}>
64-
# CHECK: cc.store %[[VAL_28]], %[[VAL_26]] : !cc.ptr<!cc.struct<{i64, f64}>>
56+
# CHECK: %[[VAL_22:.*]] = cc.stdvec_data %[[VAL_16]] : (!cc.stdvec<f64>) -> !cc.ptr<!cc.array<f64 x ?>>
57+
# CHECK: %[[VAL_23:.*]] = cc.compute_ptr %[[VAL_22]]{{\[}}%[[VAL_21]]] : (!cc.ptr<!cc.array<f64 x ?>>, i64) -> !cc.ptr<f64>
58+
# CHECK: %[[VAL_24:.*]] = cc.load %[[VAL_23]] : !cc.ptr<f64>
59+
# CHECK: %[[VAL_25:.*]] = quake.extract_ref %[[VAL_7]]{{\[}}%[[VAL_21]]] : (!quake.veq<6>, i64) -> !quake.ref
60+
# CHECK: quake.ry (%[[VAL_24]]) %[[VAL_25]] : (f64, !quake.ref) -> ()
6561
# CHECK: cc.continue %[[VAL_21]] : i64
6662
# CHECK: } step {
67-
# CHECK: ^bb0(%[[VAL_29:.*]]: i64):
68-
# CHECK: %[[VAL_30:.*]] = arith.addi %[[VAL_29]], %[[VAL_0]] : i64
69-
# CHECK: cc.continue %[[VAL_30]] : i64
70-
# CHECK: } {invariant}
71-
# CHECK: %[[VAL_31:.*]] = cc.loop while ((%[[VAL_32:.*]] = %[[VAL_1]]) -> (i64)) {
72-
# CHECK: %[[VAL_33:.*]] = arith.cmpi slt, %[[VAL_32]], %[[VAL_16]] : i64
73-
# CHECK: cc.condition %[[VAL_33]](%[[VAL_32]] : i64)
74-
# CHECK: } do {
75-
# CHECK: ^bb0(%[[VAL_34:.*]]: i64):
76-
# CHECK: %[[VAL_35:.*]] = cc.compute_ptr %[[VAL_17]]{{\[}}%[[VAL_34]]] : (!cc.ptr<!cc.array<!cc.struct<{i64, f64}> x ?>>, i64) -> !cc.ptr<!cc.struct<{i64, f64}>>
77-
# CHECK: %[[VAL_36:.*]] = cc.load %[[VAL_35]] : !cc.ptr<!cc.struct<{i64, f64}>>
78-
# CHECK: %[[VAL_37:.*]] = cc.extract_value %[[VAL_36]][0] : (!cc.struct<{i64, f64}>) -> i64
79-
# CHECK: %[[VAL_38:.*]] = cc.extract_value %[[VAL_36]][1] : (!cc.struct<{i64, f64}>) -> f64
80-
# CHECK: %[[VAL_39:.*]] = quake.extract_ref %[[VAL_7]]{{\[}}%[[VAL_37]]] : (!quake.veq<6>, i64) -> !quake.ref
81-
# CHECK: quake.ry (%[[VAL_38]]) %[[VAL_39]] : (f64, !quake.ref) -> ()
82-
# CHECK: cc.continue %[[VAL_34]] : i64
83-
# CHECK: } step {
84-
# CHECK: ^bb0(%[[VAL_40:.*]]: i64):
85-
# CHECK: %[[VAL_41:.*]] = arith.addi %[[VAL_40]], %[[VAL_0]] : i64
86-
# CHECK: cc.continue %[[VAL_41]] : i64
63+
# CHECK: ^bb0(%[[VAL_26:.*]]: i64):
64+
# CHECK: %[[VAL_27:.*]] = arith.addi %[[VAL_26]], %[[VAL_0]] : i64
65+
# CHECK: cc.continue %[[VAL_27]] : i64
8766
# CHECK: } {invariant}
8867
# CHECK: return
8968
# CHECK: }
69+

0 commit comments

Comments
 (0)