Skip to content

Commit 4e37469

Browse files
mrguenthermrguenther
authored
Add more thorough support for float folding. (#2853)
Add float support to several folder patterns.
1 parent 20b8ee5 commit 4e37469

File tree

2 files changed

+408
-63
lines changed

2 files changed

+408
-63
lines changed

‎stablehlo/tests/transforms/stablehlo_aggressive_folder.mlir‎

Lines changed: 267 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -150,8 +150,8 @@ func.func @clamp_fold(%arg0: tensor<3xi32>) -> tensor<3xi32> {
150150
////////
151151
// CompareOp
152152

153-
// CHECK-LABEL: func.func @compare_folds
154-
func.func @compare_folds()
153+
// CHECK-LABEL: func.func @compare_fold_int
154+
func.func @compare_fold_int()
155155
-> (tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>) {
156156
%cn1 = stablehlo.constant dense<-1> : tensor<i32>
157157
%c0 = stablehlo.constant dense<0> : tensor<i32>
@@ -176,6 +176,270 @@ func.func @compare_folds()
176176
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>
177177
}
178178

179+
// -----
180+
181+
// CHECK-LABEL: func.func @compare_fold_float
182+
func.func @compare_fold_float()
183+
-> (tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>) {
184+
%c0 = stablehlo.constant dense<0.0> : tensor<f32>
185+
%c1 = stablehlo.constant dense<0.01> : tensor<f32>
186+
%c2 = stablehlo.constant dense<-0.01> : tensor<f32>
187+
%c3 = stablehlo.constant dense<42.1> : tensor<f32>
188+
%c4 = stablehlo.constant dense<-50.0> : tensor<f32>
189+
190+
%0 = stablehlo.compare EQ, %c0, %c0, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
191+
%1 = stablehlo.compare EQ, %c1, %c2, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
192+
%2 = stablehlo.compare NE, %c0, %c0, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
193+
%3 = stablehlo.compare NE, %c1, %c2, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
194+
%4 = stablehlo.compare GT, %c3, %c3, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
195+
%5 = stablehlo.compare GT, %c3, %c4, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
196+
%6 = stablehlo.compare GE, %c3, %c3, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
197+
%7 = stablehlo.compare GE, %c3, %c4, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
198+
%8 = stablehlo.compare LT, %c2, %c2, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
199+
%9 = stablehlo.compare LT, %c2, %c4, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
200+
%10 = stablehlo.compare LE, %c2, %c2, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
201+
%11 = stablehlo.compare LE, %c2, %c4, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
202+
203+
// CHECK-DAG: [[FALSE:%.+]] = stablehlo.constant dense<false> : tensor<i1>
204+
// CHECK-DAG: [[TRUE:%.+]] = stablehlo.constant dense<true> : tensor<i1>
205+
206+
// CHECK-NEXT: return [[TRUE]], [[FALSE]], [[FALSE]], [[TRUE]], [[FALSE]], [[TRUE]], [[TRUE]], [[TRUE]], [[FALSE]], [[FALSE]], [[TRUE]], [[FALSE]]
207+
return %0, %1, %2, %3, %4, %5, %6, %7, %8, %9, %10, %11 :
208+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>
209+
}
210+
211+
// -----
212+
213+
// CHECK-LABEL: func.func @compare_fold_float_edge_cases
214+
func.func @compare_fold_float_edge_cases()
215+
-> (tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>,
216+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>,
217+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>,
218+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>,
219+
220+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>,
221+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>,
222+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>,
223+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>,
224+
225+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>,
226+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>,
227+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>,
228+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>,
229+
230+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>,
231+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>,
232+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>,
233+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>,
234+
235+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>,
236+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>,
237+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>,
238+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>,
239+
240+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>,
241+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>,
242+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>,
243+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>) {
244+
%zero = stablehlo.constant dense<0.0> : tensor<f32>
245+
%pos_inf = stablehlo.constant dense<0x7F800000> : tensor<f32>
246+
%neg_inf = stablehlo.constant dense<0xFF800000> : tensor<f32>
247+
%nan = stablehlo.constant dense<0x7FC00000> : tensor<f32>
248+
249+
// CHECK-DAG: [[FALSE:%.+]] = stablehlo.constant dense<false> : tensor<i1>
250+
// CHECK-DAG: [[TRUE:%.+]] = stablehlo.constant dense<true> : tensor<i1>
251+
252+
%0 = stablehlo.compare EQ, %zero, %zero, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
253+
%1 = stablehlo.compare EQ, %zero, %pos_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
254+
%2 = stablehlo.compare EQ, %zero, %neg_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
255+
%3 = stablehlo.compare EQ, %zero, %nan, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
256+
%4 = stablehlo.compare EQ, %pos_inf, %zero, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
257+
%5 = stablehlo.compare EQ, %pos_inf, %pos_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
258+
%6 = stablehlo.compare EQ, %pos_inf, %neg_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
259+
%7 = stablehlo.compare EQ, %pos_inf, %nan, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
260+
%8 = stablehlo.compare EQ, %neg_inf, %zero, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
261+
%9 = stablehlo.compare EQ, %neg_inf, %pos_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
262+
%10 = stablehlo.compare EQ, %neg_inf, %neg_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
263+
%11 = stablehlo.compare EQ, %neg_inf, %nan, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
264+
%12 = stablehlo.compare EQ, %nan, %zero, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
265+
%13 = stablehlo.compare EQ, %nan, %pos_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
266+
%14 = stablehlo.compare EQ, %nan, %neg_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
267+
%15 = stablehlo.compare EQ, %nan, %nan, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
268+
269+
%16 = stablehlo.compare NE, %zero, %zero, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
270+
%17 = stablehlo.compare NE, %zero, %pos_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
271+
%18 = stablehlo.compare NE, %zero, %neg_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
272+
%19 = stablehlo.compare NE, %zero, %nan, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
273+
%20 = stablehlo.compare NE, %pos_inf, %zero, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
274+
%21 = stablehlo.compare NE, %pos_inf, %pos_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
275+
%22 = stablehlo.compare NE, %pos_inf, %neg_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
276+
%23 = stablehlo.compare NE, %pos_inf, %nan, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
277+
%24 = stablehlo.compare NE, %neg_inf, %zero, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
278+
%25 = stablehlo.compare NE, %neg_inf, %pos_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
279+
%26 = stablehlo.compare NE, %neg_inf, %neg_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
280+
%27 = stablehlo.compare NE, %neg_inf, %nan, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
281+
%28 = stablehlo.compare NE, %nan, %zero, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
282+
%29 = stablehlo.compare NE, %nan, %pos_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
283+
%30 = stablehlo.compare NE, %nan, %neg_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
284+
%31 = stablehlo.compare NE, %nan, %nan, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
285+
286+
%32 = stablehlo.compare GT, %zero, %zero, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
287+
%33 = stablehlo.compare GT, %zero, %pos_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
288+
%34 = stablehlo.compare GT, %zero, %neg_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
289+
%35 = stablehlo.compare GT, %zero, %nan, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
290+
%36 = stablehlo.compare GT, %pos_inf, %zero, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
291+
%37 = stablehlo.compare GT, %pos_inf, %pos_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
292+
%38 = stablehlo.compare GT, %pos_inf, %neg_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
293+
%39 = stablehlo.compare GT, %pos_inf, %nan, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
294+
%40 = stablehlo.compare GT, %neg_inf, %zero, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
295+
%41 = stablehlo.compare GT, %neg_inf, %pos_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
296+
%42 = stablehlo.compare GT, %neg_inf, %neg_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
297+
%43 = stablehlo.compare GT, %neg_inf, %nan, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
298+
%44 = stablehlo.compare GT, %nan, %zero, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
299+
%45 = stablehlo.compare GT, %nan, %pos_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
300+
%46 = stablehlo.compare GT, %nan, %neg_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
301+
%47 = stablehlo.compare GT, %nan, %nan, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
302+
303+
%48 = stablehlo.compare GE, %zero, %zero, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
304+
%49 = stablehlo.compare GE, %zero, %pos_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
305+
%50 = stablehlo.compare GE, %zero, %neg_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
306+
%51 = stablehlo.compare GE, %zero, %nan, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
307+
%52 = stablehlo.compare GE, %pos_inf, %zero, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
308+
%53 = stablehlo.compare GE, %pos_inf, %pos_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
309+
%54 = stablehlo.compare GE, %pos_inf, %neg_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
310+
%55 = stablehlo.compare GE, %pos_inf, %nan, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
311+
%56 = stablehlo.compare GE, %neg_inf, %zero, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
312+
%57 = stablehlo.compare GE, %neg_inf, %pos_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
313+
%58 = stablehlo.compare GE, %neg_inf, %neg_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
314+
%59 = stablehlo.compare GE, %neg_inf, %nan, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
315+
%60 = stablehlo.compare GE, %nan, %zero, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
316+
%61 = stablehlo.compare GE, %nan, %pos_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
317+
%62 = stablehlo.compare GE, %nan, %neg_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
318+
%63 = stablehlo.compare GE, %nan, %nan, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
319+
320+
%64 = stablehlo.compare LT, %zero, %zero, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
321+
%65 = stablehlo.compare LT, %zero, %pos_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
322+
%66 = stablehlo.compare LT, %zero, %neg_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
323+
%67 = stablehlo.compare LT, %zero, %nan, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
324+
%68 = stablehlo.compare LT, %pos_inf, %zero, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
325+
%69 = stablehlo.compare LT, %pos_inf, %pos_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
326+
%70 = stablehlo.compare LT, %pos_inf, %neg_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
327+
%71 = stablehlo.compare LT, %pos_inf, %nan, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
328+
%72 = stablehlo.compare LT, %neg_inf, %zero, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
329+
%73 = stablehlo.compare LT, %neg_inf, %pos_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
330+
%74 = stablehlo.compare LT, %neg_inf, %neg_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
331+
%75 = stablehlo.compare LT, %neg_inf, %nan, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
332+
%76 = stablehlo.compare LT, %nan, %zero, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
333+
%77 = stablehlo.compare LT, %nan, %pos_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
334+
%78 = stablehlo.compare LT, %nan, %neg_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
335+
%79 = stablehlo.compare LT, %nan, %nan, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
336+
337+
%80 = stablehlo.compare LE, %zero, %zero, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
338+
%81 = stablehlo.compare LE, %zero, %pos_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
339+
%82 = stablehlo.compare LE, %zero, %neg_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
340+
%83 = stablehlo.compare LE, %zero, %nan, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
341+
%84 = stablehlo.compare LE, %pos_inf, %zero, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
342+
%85 = stablehlo.compare LE, %pos_inf, %pos_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
343+
%86 = stablehlo.compare LE, %pos_inf, %neg_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
344+
%87 = stablehlo.compare LE, %pos_inf, %nan, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
345+
%88 = stablehlo.compare LE, %neg_inf, %zero, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
346+
%89 = stablehlo.compare LE, %neg_inf, %pos_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
347+
%90 = stablehlo.compare LE, %neg_inf, %neg_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
348+
%91 = stablehlo.compare LE, %neg_inf, %nan, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
349+
%92 = stablehlo.compare LE, %nan, %zero, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
350+
%93 = stablehlo.compare LE, %nan, %pos_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
351+
%94 = stablehlo.compare LE, %nan, %neg_inf, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
352+
%95 = stablehlo.compare LE, %nan, %nan, FLOAT : (tensor<f32>, tensor<f32>) -> tensor<i1>
353+
354+
// CHECK: return [[TRUE]], [[FALSE]], [[FALSE]], [[FALSE]],
355+
// CHECK-SAME: [[FALSE]], [[TRUE]], [[FALSE]], [[FALSE]],
356+
// CHECK-SAME: [[FALSE]], [[FALSE]], [[TRUE]], [[FALSE]],
357+
// CHECK-SAME: [[FALSE]], [[FALSE]], [[FALSE]], [[FALSE]],
358+
359+
// CHECK-SAME: [[FALSE]], [[TRUE]], [[TRUE]], [[TRUE]],
360+
// CHECK-SAME: [[TRUE]], [[FALSE]], [[TRUE]], [[TRUE]],
361+
// CHECK-SAME: [[TRUE]], [[TRUE]], [[FALSE]], [[TRUE]],
362+
// CHECK-SAME: [[TRUE]], [[TRUE]], [[TRUE]], [[TRUE]],
363+
364+
// CHECK-SAME: [[FALSE]], [[FALSE]], [[TRUE]], [[FALSE]],
365+
// CHECK-SAME: [[TRUE]], [[FALSE]], [[TRUE]], [[FALSE]],
366+
// CHECK-SAME: [[FALSE]], [[FALSE]], [[FALSE]], [[FALSE]],
367+
// CHECK-SAME: [[FALSE]], [[FALSE]], [[FALSE]], [[FALSE]],
368+
369+
// CHECK-SAME: [[TRUE]], [[FALSE]], [[TRUE]], [[FALSE]],
370+
// CHECK-SAME: [[TRUE]], [[TRUE]], [[TRUE]], [[FALSE]],
371+
// CHECK-SAME: [[FALSE]], [[FALSE]], [[TRUE]], [[FALSE]],
372+
// CHECK-SAME: [[FALSE]], [[FALSE]], [[FALSE]], [[FALSE]],
373+
374+
// CHECK-SAME: [[FALSE]], [[TRUE]], [[FALSE]], [[FALSE]],
375+
// CHECK-SAME: [[FALSE]], [[FALSE]], [[FALSE]], [[FALSE]],
376+
// CHECK-SAME: [[TRUE]], [[TRUE]], [[FALSE]], [[FALSE]],
377+
// CHECK-SAME: [[FALSE]], [[FALSE]], [[FALSE]], [[FALSE]],
378+
379+
// CHECK-SAME: [[TRUE]], [[TRUE]], [[FALSE]], [[FALSE]],
380+
// CHECK-SAME: [[FALSE]], [[TRUE]], [[FALSE]], [[FALSE]],
381+
// CHECK-SAME: [[TRUE]], [[TRUE]], [[TRUE]], [[FALSE]],
382+
// CHECK-SAME: [[FALSE]], [[FALSE]], [[FALSE]], [[FALSE]]
383+
384+
return %0, %1, %2, %3,
385+
%4, %5, %6, %7,
386+
%8, %9, %10, %11,
387+
%12, %13, %14, %15,
388+
389+
%16, %17, %18, %19,
390+
%20, %21, %22, %23,
391+
%24, %25, %26, %27,
392+
%28, %29, %30, %31,
393+
394+
%32, %33, %34, %35,
395+
%36, %37, %38, %39,
396+
%40, %41, %42, %43,
397+
%44, %45, %46, %47,
398+
399+
%48, %49, %50, %51,
400+
%52, %53, %54, %55,
401+
%56, %57, %58, %59,
402+
%60, %61, %62, %63,
403+
404+
%64, %65, %66, %67,
405+
%68, %69, %70, %71,
406+
%72, %73, %74, %75,
407+
%76, %77, %78, %79,
408+
409+
%80, %81, %82, %83,
410+
%84, %85, %86, %87,
411+
%88, %89, %90, %91,
412+
%92, %93, %94, %95 :
413+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>,
414+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>,
415+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>,
416+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>,
417+
418+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>,
419+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>,
420+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>,
421+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>,
422+
423+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>,
424+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>,
425+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>,
426+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>,
427+
428+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>,
429+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>,
430+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>,
431+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>,
432+
433+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>,
434+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>,
435+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>,
436+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>,
437+
438+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>,
439+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>,
440+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>,
441+
tensor<i1>, tensor<i1>, tensor<i1>, tensor<i1>
442+
}
179443

180444
// -----
181445

@@ -218,8 +482,7 @@ func.func @div_fold_cst() -> (tensor<i32>, tensor<ui32>, tensor<f32>) {
218482
%cst_2 = stablehlo.constant dense<2.0> : tensor<f32>
219483
// CHECK: stablehlo.constant dense<1> : tensor<i32>
220484
// CHECK: stablehlo.constant dense<1> : tensor<ui32>
221-
// CHECK: stablehlo.divide{{.*}} : tensor<f32>
222-
// DISABLED-CHECK: stablehlo.constant dense<1.0{{.*}}> : tensor<f32>
485+
// CHECK: stablehlo.constant dense<1.0{{.*}}> : tensor<f32>
223486
%0 = stablehlo.divide %cst, %cst : tensor<i32>
224487
%1 = stablehlo.divide %cst_1, %cst_1 : tensor<ui32>
225488
%2 = stablehlo.divide %cst_2, %cst_2 : tensor<f32>

0 commit comments

Comments
 (0)