1// Test the FIR operations 2 3// RUN: fir-opt %s | fir-opt | FileCheck %s 4 5// CHECK-LABEL: func private @it1() -> !fir.int<4> 6// CHECK: func private @box1() -> !fir.boxchar<2> 7// CHECK: func private @box2() -> !fir.boxproc<(i32, i32) -> i64> 8// CHECK: func private @box3() -> !fir.box<!fir.type<derived3{f:f32}>> 9func private @it1() -> !fir.int<4> 10func private @box1() -> !fir.boxchar<2> 11func private @box2() -> !fir.boxproc<(i32, i32) -> i64> 12func private @box3() -> !fir.box<!fir.type<derived3{f:f32}>> 13 14// Fortran SUBROUTINE and FUNCTION 15// CHECK-LABEL: func private @print_index3(index, index, index) 16// CHECK: func private @user_i64(i64) 17// CHECK: func private @user_tdesc(!fir.tdesc<!fir.type<x>>) 18func private @print_index3(index, index, index) 19func private @user_i64(i64) 20func private @user_tdesc(!fir.tdesc<!fir.type<x>>) 21 22// expect the void return to be omitted 23// CHECK-LABEL: func private @store_tuple(tuple<!fir.type<qq1{f1:i32}>>) 24// CHECK: func private @get_method_box() -> !fir.box<!fir.type<derived3{f:f32}>> 25// CHECK: func private @method_impl(!fir.box<!fir.type<derived3{f:f32}>>) 26func private @store_tuple(tuple<!fir.type<qq1{f1:i32}>>) -> () 27func private @get_method_box() -> !fir.box<!fir.type<derived3{f:f32}>> 28func private @method_impl(!fir.box<!fir.type<derived3{f:f32}>>) 29 30// CHECK-LABEL: func private @nop() 31// CHECK-LABEL: func private @get_func() -> (() -> ()) 32func private @nop() 33func private @get_func() -> (() -> ()) 34 35// CHECK-LABEL: func @instructions() { 36func @instructions() { 37// CHECK: [[VAL_0:%.*]] = fir.alloca !fir.array<10xi32> 38// CHECK: [[VAL_1:%.*]] = fir.load [[VAL_0]] : !fir.ref<!fir.array<10xi32>> 39// CHECK: [[VAL_2:%.*]] = fir.alloca i32 40// CHECK: [[VAL_3:%.*]] = constant 22 : i32 41 %0 = fir.alloca !fir.array<10xi32> 42 %1 = fir.load %0 : !fir.ref<!fir.array<10xi32>> 43 %2 = fir.alloca i32 44 %3 = constant 22 : i32 45 46// CHECK: fir.store [[VAL_3]] to [[VAL_2]] : !fir.ref<i32> 47// CHECK: [[VAL_4:%.*]] = fir.undefined i32 48// CHECK: [[VAL_5:%.*]] = fir.allocmem !fir.array<100xf32> 49// CHECK: [[VAL_6:%.*]] = fir.embox [[VAL_5]] : (!fir.heap<!fir.array<100xf32>>) -> !fir.box<!fir.array<100xf32>> 50 fir.store %3 to %2 : !fir.ref<i32> 51 %4 = fir.undefined i32 52 %5 = fir.allocmem !fir.array<100xf32> 53 %6 = fir.embox %5 : (!fir.heap<!fir.array<100xf32>>) -> !fir.box<!fir.array<100xf32>> 54 55// CHECK: [[VAL_7:%.*]] = fir.box_addr [[VAL_6]] : (!fir.box<!fir.array<100xf32>>) -> !fir.ref<!fir.array<100xf32>> 56// CHECK: [[VAL_8:%.*]] = constant 0 : index 57// CHECK: [[VAL_9:%.*]]:3 = fir.box_dims [[VAL_6]], [[VAL_8]] : (!fir.box<!fir.array<100xf32>>, index) -> (index, index, index) 58// CHECK: fir.call @print_index3([[VAL_9]]#0, [[VAL_9]]#1, [[VAL_9]]#2) : (index, index, index) -> () 59// CHECK: [[VAL_10:%.*]] = fir.call @it1() : () -> !fir.int<4> 60 %7 = fir.box_addr %6 : (!fir.box<!fir.array<100xf32>>) -> !fir.ref<!fir.array<100xf32>> 61 %c0 = constant 0 : index 62 %d1:3 = fir.box_dims %6, %c0 : (!fir.box<!fir.array<100xf32>>, index) -> (index, index, index) 63 fir.call @print_index3(%d1#0, %d1#1, %d1#2) : (index, index, index) -> () 64 %8 = fir.call @it1() : () -> !fir.int<4> 65 66// CHECK: [[VAL_11:%.*]] = fir.box_elesize [[VAL_6]] : (!fir.box<!fir.array<100xf32>>) -> i64 67// CHECK: [[VAL_12:%.*]] = fir.box_isalloc [[VAL_6]] : (!fir.box<!fir.array<100xf32>>) -> i1 68// CHECK: [[VAL_13:%.*]] = fir.box_isarray [[VAL_6]] : (!fir.box<!fir.array<100xf32>>) -> i1 69// CHECK: [[VAL_14:%.*]] = fir.box_isptr [[VAL_6]] : (!fir.box<!fir.array<100xf32>>) -> i1 70// CHECK: [[VAL_15:%.*]] = fir.box_rank [[VAL_6]] : (!fir.box<!fir.array<100xf32>>) -> i64 71 %9 = fir.box_elesize %6 : (!fir.box<!fir.array<100xf32>>) -> i64 72 %10 = fir.box_isalloc %6 : (!fir.box<!fir.array<100xf32>>) -> i1 73 %11 = fir.box_isarray %6 : (!fir.box<!fir.array<100xf32>>) -> i1 74 %12 = fir.box_isptr %6 : (!fir.box<!fir.array<100xf32>>) -> i1 75 %13 = fir.box_rank %6 : (!fir.box<!fir.array<100xf32>>) -> i64 76 77// CHECK: [[VAL_16:%.*]] = fir.box_tdesc [[VAL_6]] : (!fir.box<!fir.array<100xf32>>) -> !fir.tdesc<!fir.array<100xf32>> 78// CHECK: [[VAL_17:%.*]] = fir.call @box1() : () -> !fir.boxchar<2> 79// CHECK: [[VAL_18:%.*]] = fir.boxchar_len [[VAL_17]] : (!fir.boxchar<2>) -> i32 80// CHECK: [[VAL_19:%.*]] = fir.call @box2() : () -> !fir.boxproc<(i32, i32) -> i64> 81// CHECK: [[VAL_20:%.*]] = fir.boxproc_host [[VAL_19]] : (!fir.boxproc<(i32, i32) -> i64>) -> !fir.ref<i32> 82 %14 = fir.box_tdesc %6 : (!fir.box<!fir.array<100xf32>>) -> !fir.tdesc<!fir.array<100xf32>> 83 %15 = fir.call @box1() : () -> !fir.boxchar<2> 84 %16 = fir.boxchar_len %15 : (!fir.boxchar<2>) -> i32 85 %17 = fir.call @box2() : () -> !fir.boxproc<(i32, i32) -> i64> 86 %18 = fir.boxproc_host %17 : (!fir.boxproc<(i32, i32) -> i64>) -> !fir.ref<i32> 87 88// CHECK: [[VAL_21:%.*]] = constant 10 : i32 89// CHECK: [[VAL_22:%.*]] = fir.coordinate_of [[VAL_5]], [[VAL_21]] : (!fir.heap<!fir.array<100xf32>>, i32) -> !fir.ref<f32> 90// CHECK: [[VAL_23:%.*]] = fir.field_index f, !fir.type<derived{f:f32}> 91// CHECK: [[VAL_24:%.*]] = fir.undefined !fir.type<derived{f:f32}> 92// CHECK: [[VAL_25:%.*]] = fir.extract_value [[VAL_24]], [[VAL_23]] : (!fir.type<derived{f:f32}>, !fir.field) -> f32 93 %19 = constant 10 : i32 94 %20 = fir.coordinate_of %5, %19 : (!fir.heap<!fir.array<100xf32>>, i32) -> !fir.ref<f32> 95 %21 = fir.field_index f, !fir.type<derived{f:f32}> 96 %22 = fir.undefined !fir.type<derived{f:f32}> 97 %23 = fir.extract_value %22, %21 : (!fir.type<derived{f:f32}>, !fir.field) -> f32 98 99// CHECK: [[VAL_26:%.*]] = constant 1 : i32 100// CHECK: [[VAL_27:%.*]] = fir.shape [[VAL_21]] : (i32) -> !fir.shape<1> 101// CHECK: [[VAL_28:%.*]] = constant 1.0 102// CHECK: [[VAL_29:%.*]] = fir.insert_value [[VAL_24]], [[VAL_28]], [[VAL_23]] : (!fir.type<derived{f:f32}>, f32, !fir.field) -> !fir.type<derived{f:f32}> 103// CHECK: [[VAL_30:%.*]] = fir.len_param_index f, !fir.type<derived3{f:f32}> 104 %c1 = constant 1 : i32 105 %24 = fir.shape %19 : (i32) -> !fir.shape<1> 106 %cf1 = constant 1.0 : f32 107 %25 = fir.insert_value %22, %cf1, %21 : (!fir.type<derived{f:f32}>, f32, !fir.field) -> !fir.type<derived{f:f32}> 108 %26 = fir.len_param_index f, !fir.type<derived3{f:f32}> 109 110// CHECK: [[VAL_31:%.*]] = fir.call @box3() : () -> !fir.box<!fir.type<derived3{f:f32}>> 111// CHECK: [[VAL_32:%.*]] = fir.dispatch "method"([[VAL_31]]) : (!fir.box<!fir.type<derived3{f:f32}>>) -> i32 112// CHECK: [[VAL_33:%.*]] = fir.convert [[VAL_32]] : (i32) -> i64 113// CHECK: [[VAL_34:%.*]] = fir.gentypedesc !fir.type<x> 114// CHECK: fir.call @user_tdesc([[VAL_34]]) : (!fir.tdesc<!fir.type<x>>) -> () 115// CHECK: [[VAL_35:%.*]] = fir.no_reassoc [[VAL_33]] : i64 116 %27 = fir.call @box3() : () -> !fir.box<!fir.type<derived3{f:f32}>> 117 %28 = fir.dispatch "method"(%27) : (!fir.box<!fir.type<derived3{f:f32}>>) -> i32 118 %29 = fir.convert %28 : (i32) -> i64 119 %30 = fir.gentypedesc !fir.type<x> 120 fir.call @user_tdesc(%30) : (!fir.tdesc<!fir.type<x>>) -> () 121 %31 = fir.no_reassoc %29 : i64 122 123// CHECK: fir.call @user_i64([[VAL_35]]) : (i64) -> () 124// CHECK: fir.freemem [[VAL_5]] : !fir.heap<!fir.array<100xf32>> 125// CHECK: [[VAL_36:%.*]] = fir.call @get_func() : () -> (() -> ()) 126// CHECK: fir.call [[VAL_36]]() : () -> () 127// CHECK: [[VAL_37:%.*]] = fir.address_of(@it1) : !fir.ref<() -> !fir.int<4>> 128// CHECK: return 129// CHECK: } 130 fir.call @user_i64(%31) : (i64) -> () 131 fir.freemem %5 : !fir.heap<!fir.array<100xf32>> 132 %32 = fir.call @get_func() : () -> (() -> ()) 133 fir.call %32() : () -> () 134 %33 = fir.address_of (@it1) : !fir.ref<() -> !fir.int<4>> 135 return 136} 137 138// CHECK-LABEL: func @boxing_match() { 139func @boxing_match() { 140// CHECK: [[VAL_38:%.*]] = fir.alloca i32 141// CHECK: [[VAL_39:%.*]] = fir.alloca !fir.type<qq2{f1:i32,f2:f64}> 142// CHECK: [[VAL_40:%.*]] = fir.alloca !fir.char<1> 143// CHECK: [[VAL_41:%.*]] = fir.alloca tuple<i32, f64> 144// CHECK: [[VAL_42:%.*]] = fir.embox [[VAL_38]] : (!fir.ref<i32>) -> !fir.box<i32> 145// CHECK: [[VAL_43:%.*]]:6 = fir.unbox [[VAL_42]] : (!fir.box<i32>) -> (!fir.ref<i32>, i32, i32, !fir.tdesc<i32>, i32, !fir.array<3x?xindex>) 146// CHECK: [[VAL_44:%.*]] = constant 8 : i32 147// CHECK: [[VAL_45:%.*]] = fir.undefined !fir.char<1> 148// CHECK: [[VAL_46:%.*]] = fir.emboxchar [[VAL_40]], [[VAL_44]] : (!fir.ref<!fir.char<1>>, i32) -> !fir.boxchar<1> 149// CHECK: [[VAL_47:%.*]]:2 = fir.unboxchar [[VAL_46]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1>>, i32) 150// CHECK: [[VAL_48:%.*]] = fir.undefined !fir.type<qq2{f1:i32,f2:f64}> 151// CHECK: [[VAL_49:%.*]] = constant 0 : i32 152// CHECK: [[VAL_50:%.*]] = constant 12 : i32 153// CHECK: [[VAL_51:%.*]] = fir.insert_value [[VAL_48]], [[VAL_50]], [[VAL_49]] : (!fir.type<qq2{f1:i32,f2:f64}>, i32, i32) -> !fir.type<qq2{f1:i32,f2:f64}> 154// CHECK: [[VAL_52:%.*]] = constant 1 : i32 155// CHECK: [[VAL_53:%.*]] = constant 4.213000e+01 : f64 156// CHECK: [[VAL_54:%.*]] = fir.insert_value [[VAL_48]], [[VAL_53]], [[VAL_52]] : (!fir.type<qq2{f1:i32,f2:f64}>, f64, i32) -> !fir.type<qq2{f1:i32,f2:f64}> 157// CHECK: fir.store [[VAL_54]] to [[VAL_39]] : !fir.ref<!fir.type<qq2{f1:i32,f2:f64}>> 158// CHECK: [[VAL_55:%.*]] = fir.emboxproc @method_impl, [[VAL_41]] : ((!fir.box<!fir.type<derived3{f:f32}>>) -> (), !fir.ref<tuple<i32, f64>>) -> !fir.boxproc<(!fir.box<!fir.type<derived3{f:f32}>>) -> ()> 159// CHECK: [[VAL_56:%.*]], [[VAL_57:%.*]] = fir.unboxproc [[VAL_55]] : (!fir.boxproc<(!fir.box<!fir.type<derived3{f:f32}>>) -> ()>) -> ((!fir.box<!fir.type<derived3{f:f32}>>) -> (), !fir.ref<tuple<!fir.type<qq2{f1:i32,f2:f64}>>>) 160// CHECK: [[VAL_58:%.*]] = fir.call @box2() : () -> !fir.boxproc<(i32, i32) -> i64> 161// CHECK: [[VAL_59:%.*]], [[VAL_60:%.*]] = fir.unboxproc [[VAL_58]] : (!fir.boxproc<(i32, i32) -> i64>) -> ((i32, i32) -> i64, !fir.ref<tuple<!fir.type<qq1{f1:i32}>>>) 162// CHECK: [[VAL_61:%.*]] = fir.load [[VAL_60]] : !fir.ref<tuple<!fir.type<qq1{f1:i32}>>> 163// CHECK: fir.call @store_tuple([[VAL_61]]) : (tuple<!fir.type<qq1{f1:i32}>>) -> () 164// CHECK: return 165// CHECK: } 166 %0 = fir.alloca i32 167 %d6 = fir.alloca !fir.type<qq2{f1:i32,f2:f64}> 168 %d3 = fir.alloca !fir.char<1> 169 %e6 = fir.alloca tuple<i32,f64> 170 %1 = fir.embox %0 : (!fir.ref<i32>) -> !fir.box<i32> 171 %2:6 = fir.unbox %1 : (!fir.box<i32>) -> (!fir.ref<i32>,i32,i32,!fir.tdesc<i32>,i32,!fir.array<3x?xindex>) 172 %c8 = constant 8 : i32 173 %3 = fir.undefined !fir.char<1> 174 %4 = fir.emboxchar %d3, %c8 : (!fir.ref<!fir.char<1>>, i32) -> !fir.boxchar<1> 175 %5:2 = fir.unboxchar %4 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1>>, i32) 176 %6 = fir.undefined !fir.type<qq2{f1:i32,f2:f64}> 177 %z = constant 0 : i32 178 %c12 = constant 12 : i32 179 %a2 = fir.insert_value %6, %c12, %z : (!fir.type<qq2{f1:i32,f2:f64}>, i32, i32) -> !fir.type<qq2{f1:i32,f2:f64}> 180 %z1 = constant 1 : i32 181 %c42 = constant 42.13 : f64 182 %a3 = fir.insert_value %6, %c42, %z1 : (!fir.type<qq2{f1:i32,f2:f64}>, f64, i32) -> !fir.type<qq2{f1:i32,f2:f64}> 183 fir.store %a3 to %d6 : !fir.ref<!fir.type<qq2{f1:i32,f2:f64}>> 184 %7 = fir.emboxproc @method_impl, %e6 : ((!fir.box<!fir.type<derived3{f:f32}>>) -> (), !fir.ref<tuple<i32,f64>>) -> !fir.boxproc<(!fir.box<!fir.type<derived3{f:f32}>>) -> ()> 185 %8:2 = fir.unboxproc %7 : (!fir.boxproc<(!fir.box<!fir.type<derived3{f:f32}>>) -> ()>) -> ((!fir.box<!fir.type<derived3{f:f32}>>) -> (), !fir.ref<tuple<!fir.type<qq2{f1:i32,f2:f64}>>>) 186 %9 = fir.call @box2() : () -> !fir.boxproc<(i32, i32) -> i64> 187 %10:2 = fir.unboxproc %9 : (!fir.boxproc<(i32, i32) -> i64>) -> ((i32, i32) -> i64, !fir.ref<tuple<!fir.type<qq1{f1:i32}>>>) 188 %11 = fir.load %10#1 : !fir.ref<tuple<!fir.type<qq1{f1:i32}>>> 189 fir.call @store_tuple(%11) : (tuple<!fir.type<qq1{f1:i32}>>) -> () 190 return 191} 192 193// CHECK-LABEL: func @loop() { 194func @loop() { 195// CHECK: [[VAL_62:%.*]] = constant 1 : index 196// CHECK: [[VAL_63:%.*]] = constant 10 : index 197// CHECK: [[VAL_64:%.*]] = constant true 198 %c1 = constant 1 : index 199 %c10 = constant 10 : index 200 %ct = constant true 201 202// CHECK: fir.do_loop [[VAL_65:%.*]] = [[VAL_62]] to [[VAL_63]] step [[VAL_62]] { 203// CHECK: fir.if [[VAL_64]] { 204// CHECK: fir.call @nop() : () -> () 205// CHECK: } else { 206// CHECK: fir.call @nop() : () -> () 207// CHECK: } 208// CHECK: } 209// CHECK: fir.unreachable 210// CHECK: } 211 fir.do_loop %i = %c1 to %c10 step %c1 { 212 fir.if %ct { 213 fir.call @nop() : () -> () 214 } else { 215 fir.call @nop() : () -> () 216 } 217 } 218 fir.unreachable 219} 220 221// CHECK: func @bar_select([[VAL_66:%.*]]: i32, [[VAL_67:%.*]]: i32) -> i32 { 222func @bar_select(%arg : i32, %arg2 : i32) -> i32 { 223// CHECK: [[VAL_68:%.*]] = constant 1 : i32 224// CHECK: [[VAL_69:%.*]] = constant 2 : i32 225// CHECK: [[VAL_70:%.*]] = constant 3 : i32 226// CHECK: [[VAL_71:%.*]] = constant 4 : i32 227 %0 = constant 1 : i32 228 %1 = constant 2 : i32 229 %2 = constant 3 : i32 230 %3 = constant 4 : i32 231 232// CHECK: fir.select [[VAL_66]] : i32 [1, ^bb1([[VAL_68]] : i32), 2, ^bb2([[VAL_70]], [[VAL_66]], [[VAL_67]] : i32, i32, i32), -3, ^bb3([[VAL_67]], [[VAL_70]] : i32, i32), 4, ^bb4([[VAL_69]] : i32), unit, ^bb5] 233// CHECK: ^bb1([[VAL_72:%.*]]: i32): 234// CHECK: return [[VAL_72]] : i32 235// CHECK: ^bb2([[VAL_73:%.*]]: i32, [[VAL_74:%.*]]: i32, [[VAL_75:%.*]]: i32): 236// CHECK: [[VAL_76:%.*]] = addi [[VAL_73]], [[VAL_74]] : i32 237// CHECK: [[VAL_77:%.*]] = addi [[VAL_76]], [[VAL_75]] : i32 238// CHECK: return [[VAL_77]] : i32 239// CHECK: ^bb3([[VAL_78:%.*]]: i32, [[VAL_79:%.*]]: i32): 240// CHECK: [[VAL_80:%.*]] = addi [[VAL_78]], [[VAL_79]] : i32 241// CHECK: return [[VAL_80]] : i32 242// CHECK: ^bb4([[VAL_81:%.*]]: i32): 243// CHECK: return [[VAL_81]] : i32 244// CHECK: ^bb5: 245// CHECK: [[VAL_82:%.*]] = constant 0 : i32 246// CHECK: return [[VAL_82]] : i32 247// CHECK: } 248 fir.select %arg:i32 [ 1,^bb1(%0:i32), 2,^bb2(%2,%arg,%arg2:i32,i32,i32), -3,^bb3(%arg2,%2:i32,i32), 4,^bb4(%1:i32), unit,^bb5 ] 249^bb1(%a : i32) : 250 return %a : i32 251^bb2(%b : i32, %b2 : i32, %b3:i32) : 252 %4 = addi %b, %b2 : i32 253 %5 = addi %4, %b3 : i32 254 return %5 : i32 255^bb3(%c:i32, %c2:i32) : 256 %6 = addi %c, %c2 : i32 257 return %6 : i32 258^bb4(%d : i32) : 259 return %d : i32 260^bb5 : 261 %zero = constant 0 : i32 262 return %zero : i32 263} 264 265// CHECK-LABEL: func @bar_select_rank( 266// CHECK-SAME: [[VAL_83:%.*]]: i32, [[VAL_84:%.*]]: i32) -> i32 { 267func @bar_select_rank(%arg : i32, %arg2 : i32) -> i32 { 268// CHECK: [[VAL_85:%.*]] = constant 1 : i32 269// CHECK: [[VAL_86:%.*]] = constant 2 : i32 270// CHECK: [[VAL_87:%.*]] = constant 3 : i32 271// CHECK: [[VAL_88:%.*]] = constant 4 : i32 272 %0 = constant 1 : i32 273 %1 = constant 2 : i32 274 %2 = constant 3 : i32 275 %3 = constant 4 : i32 276 277// CHECK: fir.select_rank [[VAL_83]] : i32 [1, ^bb1([[VAL_85]] : i32), 2, ^bb2([[VAL_87]], [[VAL_83]], [[VAL_84]] : i32, i32, i32), 3, ^bb3([[VAL_84]], [[VAL_87]] : i32, i32), -1, ^bb4([[VAL_86]] : i32), unit, ^bb5] 278// CHECK: ^bb1([[VAL_89:%.*]]: i32): 279// CHECK: return [[VAL_89]] : i32 280// CHECK: ^bb2([[VAL_90:%.*]]: i32, [[VAL_91:%.*]]: i32, [[VAL_92:%.*]]: i32): 281// CHECK: [[VAL_93:%.*]] = addi [[VAL_90]], [[VAL_91]] : i32 282// CHECK: [[VAL_94:%.*]] = addi [[VAL_93]], [[VAL_92]] : i32 283// CHECK: return [[VAL_94]] : i32 284 fir.select_rank %arg:i32 [ 1,^bb1(%0:i32), 2,^bb2(%2,%arg,%arg2:i32,i32,i32), 3,^bb3(%arg2,%2:i32,i32), -1,^bb4(%1:i32), unit,^bb5 ] 285^bb1(%a : i32) : 286 return %a : i32 287^bb2(%b : i32, %b2 : i32, %b3:i32) : 288 %4 = addi %b, %b2 : i32 289 %5 = addi %4, %b3 : i32 290 return %5 : i32 291 292// CHECK: ^bb3([[VAL_95:%.*]]: i32, [[VAL_96:%.*]]: i32): 293// CHECK: [[VAL_97:%.*]] = addi [[VAL_95]], [[VAL_96]] : i32 294// CHECK: return [[VAL_97]] : i32 295// CHECK: ^bb4([[VAL_98:%.*]]: i32): 296// CHECK: return [[VAL_98]] : i32 297^bb3(%c:i32, %c2:i32) : 298 %6 = addi %c, %c2 : i32 299 return %6 : i32 300^bb4(%d : i32) : 301 return %d : i32 302 303// CHECK: ^bb5: 304// CHECK: [[VAL_99:%.*]] = constant 0 : i32 305// CHECK: [[VAL_100:%.*]] = fir.call @get_method_box() : () -> !fir.box<!fir.type<derived3{f:f32}>> 306// CHECK: fir.dispatch "method"([[VAL_100]]) : (!fir.box<!fir.type<derived3{f:f32}>>) -> () 307^bb5 : 308 %zero = constant 0 : i32 309 %7 = fir.call @get_method_box() : () -> !fir.box<!fir.type<derived3{f:f32}>> 310 fir.dispatch method(%7) : (!fir.box<!fir.type<derived3{f:f32}>>) -> () 311 312// CHECK: return [[VAL_99]] : i32 313// CHECK: } 314 return %zero : i32 315} 316 317// CHECK-LABEL: func @bar_select_type( 318// CHECK-SAME: [[VAL_101:%.*]]: !fir.box<!fir.type<name(param1:i32){fld:!fir.char<1>}>>) -> i32 { 319func @bar_select_type(%arg : !fir.box<!fir.type<name(param1:i32){fld:!fir.char<1>}>>) -> i32 { 320 321// CHECK: [[VAL_102:%.*]] = constant 1 : i32 322// CHECK: [[VAL_103:%.*]] = constant 2 : i32 323// CHECK: [[VAL_104:%.*]] = constant 3 : i32 324// CHECK: [[VAL_105:%.*]] = constant 4 : i32 325 %0 = constant 1 : i32 326 %1 = constant 2 : i32 327 %2 = constant 3 : i32 328 %3 = constant 4 : i32 329 330// CHECK: fir.select_type [[VAL_101]] : !fir.box<!fir.type<name(param1:i32){fld:!fir.char<1>}>> [#fir.instance<!fir.int<4>>, ^bb1([[VAL_102]] : i32), #fir.instance<!fir.int<8>>, ^bb2([[VAL_104]] : i32), #fir.subsumed<!fir.int<2>>, ^bb3([[VAL_104]] : i32), #fir.instance<!fir.int<1>>, ^bb4([[VAL_103]] : i32), unit, ^bb5] 331 fir.select_type %arg : !fir.box<!fir.type<name(param1:i32){fld:!fir.char<1>}>> [ #fir.instance<!fir.int<4>>,^bb1(%0:i32), #fir.instance<!fir.int<8>>,^bb2(%2:i32), #fir.subsumed<!fir.int<2>>,^bb3(%2:i32), #fir.instance<!fir.int<1>>,^bb4(%1:i32), unit,^bb5 ] 332 333// CHECK: ^bb1([[VAL_106:%.*]]: i32): 334// CHECK: return [[VAL_106]] : i32 335// CHECK: ^bb2([[VAL_107:%.*]]: i32): 336// CHECK: return [[VAL_107]] : i32 337// CHECK: ^bb3([[VAL_108:%.*]]: i32): 338// CHECK: return [[VAL_108]] : i32 339// CHECK: ^bb4([[VAL_109:%.*]]: i32): 340// CHECK: return [[VAL_109]] : i32 341^bb1(%a : i32) : 342 return %a : i32 343^bb2(%b : i32) : 344 return %b : i32 345^bb3(%c : i32) : 346 return %c : i32 347^bb4(%d : i32) : 348 return %d : i32 349 350// CHECK: ^bb5: 351// CHECK: [[VAL_110:%.*]] = constant 0 : i32 352// CHECK: return [[VAL_110]] : i32 353// CHECK: } 354^bb5 : 355 %zero = constant 0 : i32 356 return %zero : i32 357} 358 359// CHECK-LABEL: func @bar_select_case( 360// CHECK-SAME: [[VAL_111:%.*]]: i32, [[VAL_112:%.*]]: i32) -> i32 { 361// CHECK: [[VAL_113:%.*]] = constant 1 : i32 362// CHECK: [[VAL_114:%.*]] = constant 2 : i32 363// CHECK: [[VAL_115:%.*]] = constant 3 : i32 364// CHECK: [[VAL_116:%.*]] = constant 4 : i32 365func @bar_select_case(%arg : i32, %arg2 : i32) -> i32 { 366 %0 = constant 1 : i32 367 %1 = constant 2 : i32 368 %2 = constant 3 : i32 369 %3 = constant 4 : i32 370 371// CHECK: fir.select_case [[VAL_111]] : i32 [#fir.point, [[VAL_113]], ^bb1([[VAL_113]] : i32), #fir.lower, [[VAL_114]], ^bb2([[VAL_115]], [[VAL_111]], [[VAL_112]], [[VAL_114]] : i32, i32, i32, i32), #fir.interval, [[VAL_115]], [[VAL_116]], ^bb3([[VAL_115]], [[VAL_112]] : i32, i32), #fir.upper, [[VAL_111]], ^bb4([[VAL_114]] : i32), unit, ^bb5] 372 fir.select_case %arg : i32 [#fir.point, %0, ^bb1(%0:i32), #fir.lower, %1, ^bb2(%2,%arg,%arg2,%1:i32,i32,i32,i32), #fir.interval, %2, %3, ^bb3(%2,%arg2:i32,i32), #fir.upper, %arg, ^bb4(%1:i32), unit, ^bb5] 373 374// CHECK: ^bb1([[VAL_117:%.*]]: i32): 375// CHECK: return [[VAL_117]] : i32 376// CHECK: ^bb2([[VAL_118:%.*]]: i32, [[VAL_119:%.*]]: i32, [[VAL_120:%.*]]: i32, [[VAL_121:%.*]]: i32): 377// CHECK: [[VAL_122:%.*]] = addi [[VAL_118]], [[VAL_119]] : i32 378// CHECK: [[VAL_123:%.*]] = muli [[VAL_122]], [[VAL_120]] : i32 379// CHECK: [[VAL_124:%.*]] = addi [[VAL_123]], [[VAL_121]] : i32 380// CHECK: return [[VAL_124]] : i32 381// CHECK: ^bb3([[VAL_125:%.*]]: i32, [[VAL_126:%.*]]: i32): 382// CHECK: [[VAL_127:%.*]] = addi [[VAL_125]], [[VAL_126]] : i32 383// CHECK: return [[VAL_127]] : i32 384// CHECK: ^bb4([[VAL_128:%.*]]: i32): 385// CHECK: return [[VAL_128]] : i32 386^bb1(%a : i32) : 387 return %a : i32 388^bb2(%b : i32, %b2:i32, %b3:i32, %b4:i32) : 389 %4 = addi %b, %b2 : i32 390 %5 = muli %4, %b3 : i32 391 %6 = addi %5, %b4 : i32 392 return %6 : i32 393^bb3(%c : i32, %c2 : i32) : 394 %7 = addi %c, %c2 : i32 395 return %7 : i32 396^bb4(%d : i32) : 397 return %d : i32 398 399// CHECK: ^bb5: 400// CHECK: [[VAL_129:%.*]] = constant 0 : i32 401// CHECK: return [[VAL_129]] : i32 402// CHECK: } 403^bb5 : 404 %zero = constant 0 : i32 405 return %zero : i32 406} 407 408// CHECK-LABEL: fir.global @global_var : i32 { 409// CHECK: [[VAL_130:%.*]] = constant 1 : i32 410// CHECK: fir.has_value [[VAL_130]] : i32 411// CHECK: } 412fir.global @global_var : i32 { 413 %0 = constant 1 : i32 414 fir.has_value %0 : i32 415} 416 417// CHECK-LABEL: fir.global @global_constant constant : i32 { 418// CHECK: [[VAL_131:%.*]] = constant 934 : i32 419// CHECK: fir.has_value [[VAL_131]] : i32 420// CHECK: } 421fir.global @global_constant constant : i32 { 422 %0 = constant 934 : i32 423 fir.has_value %0 : i32 424} 425 426// CHECK-LABEL: fir.global @global_derived : !fir.type<minez(f:i32)> { 427// CHECK: fir.global_len "f", 1 : i32 428// CHECK: [[VAL_132:%.*]] = fir.undefined !fir.type<minez(f:i32)> 429// CHECK: fir.has_value [[VAL_132]] : !fir.type<minez(f:i32)> 430// CHECK: } 431fir.global @global_derived : !fir.type<minez(f:i32)> { 432 fir.global_len f, 1 : i32 433 %0 = fir.undefined !fir.type<minez> 434 fir.has_value %0 : !fir.type<minez> 435} 436 437// CHECK-LABEL: fir.dispatch_table @dispatch_tbl { 438// CHECK: fir.dt_entry "method", @method_impl 439// CHECK: } 440fir.dispatch_table @dispatch_tbl { 441 fir.dt_entry "method", @method_impl 442} 443 444// CHECK-LABEL: func @compare_real( 445// CHECK-SAME: [[VAL_133:%.*]]: f128, [[VAL_134:%.*]]: f128) { 446func @compare_real(%a : f128, %b : f128) { 447 448// CHECK: [[VAL_135:%.*]] = fir.cmpf "false", [[VAL_133]], [[VAL_134]] : f128 449// CHECK: [[VAL_136:%.*]] = fir.cmpf "oeq", [[VAL_133]], [[VAL_134]] : f128 450// CHECK: [[VAL_137:%.*]] = fir.cmpf "ogt", [[VAL_133]], [[VAL_134]] : f128 451// CHECK: [[VAL_138:%.*]] = fir.cmpf "oge", [[VAL_133]], [[VAL_134]] : f128 452 %d0 = fir.cmpf "false", %a, %b : f128 453 %d1 = fir.cmpf "oeq", %a, %b : f128 454 %d2 = fir.cmpf "ogt", %a, %b : f128 455 %d3 = fir.cmpf "oge", %a, %b : f128 456 457// CHECK: [[VAL_139:%.*]] = fir.cmpf "olt", [[VAL_133]], [[VAL_134]] : f128 458// CHECK: [[VAL_140:%.*]] = fir.cmpf "ole", [[VAL_133]], [[VAL_134]] : f128 459// CHECK: [[VAL_141:%.*]] = fir.cmpf "one", [[VAL_133]], [[VAL_134]] : f128 460// CHECK: [[VAL_142:%.*]] = fir.cmpf "ord", [[VAL_133]], [[VAL_134]] : f128 461 %a0 = fir.cmpf "olt", %a, %b : f128 462 %a1 = fir.cmpf "ole", %a, %b : f128 463 %a2 = fir.cmpf "one", %a, %b : f128 464 %a3 = fir.cmpf "ord", %a, %b : f128 465 466// CHECK: [[VAL_143:%.*]] = fir.cmpf "ueq", [[VAL_133]], [[VAL_134]] : f128 467// CHECK: [[VAL_144:%.*]] = fir.cmpf "ugt", [[VAL_133]], [[VAL_134]] : f128 468// CHECK: [[VAL_145:%.*]] = fir.cmpf "uge", [[VAL_133]], [[VAL_134]] : f128 469// CHECK: [[VAL_146:%.*]] = fir.cmpf "ult", [[VAL_133]], [[VAL_134]] : f128 470 %b0 = fir.cmpf "ueq", %a, %b : f128 471 %b1 = fir.cmpf "ugt", %a, %b : f128 472 %b2 = fir.cmpf "uge", %a, %b : f128 473 %b3 = fir.cmpf "ult", %a, %b : f128 474 475// CHECK: [[VAL_147:%.*]] = fir.cmpf "ule", [[VAL_133]], [[VAL_134]] : f128 476// CHECK: [[VAL_148:%.*]] = fir.cmpf "une", [[VAL_133]], [[VAL_134]] : f128 477// CHECK: [[VAL_149:%.*]] = fir.cmpf "uno", [[VAL_133]], [[VAL_134]] : f128 478// CHECK: [[VAL_150:%.*]] = fir.cmpf "true", [[VAL_133]], [[VAL_134]] : f128 479 %c0 = fir.cmpf "ule", %a, %b : f128 480 %c1 = fir.cmpf "une", %a, %b : f128 481 %c2 = fir.cmpf "uno", %a, %b : f128 482 %c3 = fir.cmpf "true", %a, %b : f128 483 484// CHECK: return 485// CHECK: } 486 return 487} 488 489// CHECK-LABEL: func @compare_complex( 490// CHECK-SAME: [[VAL_151:%.*]]: !fir.complex<16>, [[VAL_152:%.*]]: !fir.complex<16>) { 491func @compare_complex(%a : !fir.complex<16>, %b : !fir.complex<16>) { 492 493// CHECK: [[VAL_153:%.*]] = fir.cmpc "false", [[VAL_151]], [[VAL_152]] : !fir.complex<16> 494// CHECK: [[VAL_154:%.*]] = fir.cmpc "oeq", [[VAL_151]], [[VAL_152]] : !fir.complex<16> 495// CHECK: [[VAL_155:%.*]] = fir.cmpc "ogt", [[VAL_151]], [[VAL_152]] : !fir.complex<16> 496// CHECK: [[VAL_156:%.*]] = fir.cmpc "oge", [[VAL_151]], [[VAL_152]] : !fir.complex<16> 497 %d0 = fir.cmpc "false", %a, %b : !fir.complex<16> 498 %d1 = fir.cmpc "oeq", %a, %b : !fir.complex<16> 499 %d2 = fir.cmpc "ogt", %a, %b : !fir.complex<16> 500 %d3 = fir.cmpc "oge", %a, %b : !fir.complex<16> 501 502// CHECK: [[VAL_157:%.*]] = fir.cmpc "olt", [[VAL_151]], [[VAL_152]] : !fir.complex<16> 503// CHECK: [[VAL_158:%.*]] = fir.cmpc "ole", [[VAL_151]], [[VAL_152]] : !fir.complex<16> 504// CHECK: [[VAL_159:%.*]] = fir.cmpc "one", [[VAL_151]], [[VAL_152]] : !fir.complex<16> 505// CHECK: [[VAL_160:%.*]] = fir.cmpc "ord", [[VAL_151]], [[VAL_152]] : !fir.complex<16> 506 %a0 = fir.cmpc "olt", %a, %b : !fir.complex<16> 507 %a1 = fir.cmpc "ole", %a, %b : !fir.complex<16> 508 %a2 = fir.cmpc "one", %a, %b : !fir.complex<16> 509 %a3 = fir.cmpc "ord", %a, %b : !fir.complex<16> 510 511// CHECK: [[VAL_161:%.*]] = fir.cmpc "ueq", [[VAL_151]], [[VAL_152]] : !fir.complex<16> 512// CHECK: [[VAL_162:%.*]] = fir.cmpc "ugt", [[VAL_151]], [[VAL_152]] : !fir.complex<16> 513// CHECK: [[VAL_163:%.*]] = fir.cmpc "uge", [[VAL_151]], [[VAL_152]] : !fir.complex<16> 514// CHECK: [[VAL_164:%.*]] = fir.cmpc "ult", [[VAL_151]], [[VAL_152]] : !fir.complex<16> 515 %b0 = fir.cmpc "ueq", %a, %b : !fir.complex<16> 516 %b1 = fir.cmpc "ugt", %a, %b : !fir.complex<16> 517 %b2 = fir.cmpc "uge", %a, %b : !fir.complex<16> 518 %b3 = fir.cmpc "ult", %a, %b : !fir.complex<16> 519 520// CHECK: [[VAL_165:%.*]] = fir.cmpc "ule", [[VAL_151]], [[VAL_152]] : !fir.complex<16> 521// CHECK: [[VAL_166:%.*]] = fir.cmpc "une", [[VAL_151]], [[VAL_152]] : !fir.complex<16> 522// CHECK: [[VAL_167:%.*]] = fir.cmpc "uno", [[VAL_151]], [[VAL_152]] : !fir.complex<16> 523// CHECK: [[VAL_168:%.*]] = fir.cmpc "true", [[VAL_151]], [[VAL_152]] : !fir.complex<16> 524 %c0 = fir.cmpc "ule", %a, %b : !fir.complex<16> 525 %c1 = fir.cmpc "une", %a, %b : !fir.complex<16> 526 %c2 = fir.cmpc "uno", %a, %b : !fir.complex<16> 527 %c3 = fir.cmpc "true", %a, %b : !fir.complex<16> 528// CHECK: return 529// CHECK: } 530 return 531} 532 533// CHECK-LABEL: func @arith_real( 534// CHECK-SAME: [[VAL_169:%.*]]: f128, [[VAL_170:%.*]]: f128) -> f128 { 535func @arith_real(%a : f128, %b : f128) -> f128 { 536 537// CHECK: [[VAL_171:%.*]] = constant 1.0 538// CHECK: [[VAL_172:%.*]] = fir.convert [[VAL_171]] : (f32) -> f128 539// CHECK: [[VAL_173:%.*]] = fir.negf [[VAL_169]] : f128 540// CHECK: [[VAL_174:%.*]] = addf [[VAL_172]], [[VAL_173]] : f128 541// CHECK: [[VAL_175:%.*]] = subf [[VAL_174]], [[VAL_170]] : f128 542// CHECK: [[VAL_176:%.*]] = mulf [[VAL_173]], [[VAL_175]] : f128 543// CHECK: [[VAL_177:%.*]] = divf [[VAL_176]], [[VAL_169]] : f128 544// CHECK: [[VAL_178:%.*]] = fir.modf [[VAL_177]], [[VAL_170]] : f128 545 %c1 = constant 1.0 : f32 546 %0 = fir.convert %c1 : (f32) -> f128 547 %1 = fir.negf %a : f128 548 %2 = addf %0, %1 : f128 549 %3 = subf %2, %b : f128 550 %4 = mulf %1, %3 : f128 551 %5 = divf %4, %a : f128 552 %6 = fir.modf %5, %b : f128 553// CHECK: return [[VAL_178]] : f128 554// CHECK: } 555 return %6 : f128 556} 557 558// CHECK-LABEL: func @arith_complex( 559// CHECK-SAME: [[VAL_179:%.*]]: !fir.complex<16>, [[VAL_180:%.*]]: !fir.complex<16>) -> !fir.complex<16> { 560func @arith_complex(%a : !fir.complex<16>, %b : !fir.complex<16>) -> !fir.complex<16> { 561// CHECK: [[VAL_181:%.*]] = fir.negc [[VAL_179]] : !fir.complex<16> 562// CHECK: [[VAL_182:%.*]] = fir.addc [[VAL_180]], [[VAL_181]] : !fir.complex<16> 563// CHECK: [[VAL_183:%.*]] = fir.subc [[VAL_182]], [[VAL_180]] : !fir.complex<16> 564// CHECK: [[VAL_184:%.*]] = fir.mulc [[VAL_181]], [[VAL_183]] : !fir.complex<16> 565// CHECK: [[VAL_185:%.*]] = fir.divc [[VAL_184]], [[VAL_179]] : !fir.complex<16> 566 %1 = fir.negc %a : !fir.complex<16> 567 %2 = fir.addc %b, %1 : !fir.complex<16> 568 %3 = fir.subc %2, %b : !fir.complex<16> 569 %4 = fir.mulc %1, %3 : !fir.complex<16> 570 %5 = fir.divc %4, %a : !fir.complex<16> 571// CHECK: return [[VAL_185]] : !fir.complex<16> 572// CHECK: } 573 return %5 : !fir.complex<16> 574} 575 576// CHECK-LABEL: func @character_literal() -> !fir.char<1,13> { 577func @character_literal() -> !fir.char<1,13> { 578// CHECK: [[VAL_186:%.*]] = fir.string_lit "Hello, World!"(13) : !fir.char<1,13> 579 %0 = fir.string_lit "Hello, World!"(13) : !fir.char<1,13> 580// CHECK: return [[VAL_186]] : !fir.char<1,13> 581 return %0 : !fir.char<1,13> 582// CHECK: } 583} 584 585// CHECK-LABEL: func private @earlyexit2(i32) -> i1 586func private @earlyexit2(%a : i32) -> i1 587 588// CHECK-LABEL: func @early_exit( 589// CHECK-SAME: [[VAL_187:%.*]]: i1, [[VAL_188:%.*]]: i32) -> i1 { 590func @early_exit(%ok : i1, %k : i32) -> i1 { 591// CHECK: [[VAL_189:%.*]] = constant 1 : index 592// CHECK: [[VAL_190:%.*]] = constant 100 : index 593 %c1 = constant 1 : index 594 %c100 = constant 100 : index 595 596// CHECK: %[[VAL_191:.*]]:2 = fir.iterate_while ([[VAL_192:%.*]] = [[VAL_189]] to [[VAL_190]] step [[VAL_189]]) and ([[VAL_193:%.*]] = [[VAL_187]]) iter_args([[VAL_194:%.*]] = [[VAL_188]]) -> (i32) { 597// CHECK: [[VAL_195:%.*]] = call @earlyexit2([[VAL_194]]) : (i32) -> i1 598// CHECK: fir.result [[VAL_195]], [[VAL_194]] : i1, i32 599// CHECK: } 600 %newOk:2 = fir.iterate_while (%i = %c1 to %c100 step %c1) and (%ok_ = %ok) iter_args(%v = %k) -> (i32) { 601 %stop = call @earlyexit2(%v) : (i32) -> i1 602 fir.result %stop, %v : i1, i32 603 } 604// CHECK: return %[[VAL_191]]#0 : i1 605// CHECK: } 606 return %newOk#0 : i1 607} 608 609// CHECK-LABEL: @array_access 610func @array_access(%arr : !fir.ref<!fir.array<?x?xf32>>) { 611 // CHECK-DAG: %[[c1:.*]] = constant 100 612 // CHECK-DAG: %[[c2:.*]] = constant 50 613 %c100 = constant 100 : index 614 %c50 = constant 50 : index 615 // CHECK: %[[sh:.*]] = fir.shape %[[c1]], %[[c2]] : {{.*}} -> !fir.shape<2> 616 %shape = fir.shape %c100, %c50 : (index, index) -> !fir.shape<2> 617 %c47 = constant 47 : index 618 %c78 = constant 78 : index 619 %c3 = constant 3 : index 620 %c18 = constant 18 : index 621 %c36 = constant 36 : index 622 %c4 = constant 4 : index 623 // CHECK: %[[sl:.*]] = fir.slice {{.*}} -> !fir.slice<2> 624 %slice = fir.slice %c47, %c78, %c3, %c18, %c36, %c4 : (index,index,index,index,index,index) -> !fir.slice<2> 625 %c0 = constant 0 : index 626 %c99 = constant 99 : index 627 %c1 = constant 1 : index 628 fir.do_loop %i = %c0 to %c99 step %c1 { 629 %c49 = constant 49 : index 630 fir.do_loop %j = %c0 to %c49 step %c1 { 631 // CHECK: fir.array_coor %{{.*}}(%[[sh]]) [%[[sl]]] %{{.*}}, %{{.*}} : 632 %p = fir.array_coor %arr(%shape)[%slice] %i, %j : (!fir.ref<!fir.array<?x?xf32>>, !fir.shape<2>, !fir.slice<2>, index, index) -> !fir.ref<f32> 633 %x = constant 42.0 : f32 634 fir.store %x to %p : !fir.ref<f32> 635 } 636 } 637 return 638} 639 640// CHECK-LABEL: @test_is_present 641func @test_is_present(%arg0: !fir.box<!fir.array<?xf32>>) -> i1 { 642 // CHECK: fir.is_present %{{.*}} : (!fir.box<!fir.array<?xf32>>) -> i1 643 %0 = fir.is_present %arg0 : (!fir.box<!fir.array<?xf32>>) -> i1 644 return %0 : i1 645} 646// CHECK-LABEL: @test_absent 647func @test_absent() -> i1 { 648 // CHECK: fir.absent !fir.box<!fir.array<?xf32>> 649 %0 = fir.absent !fir.box<!fir.array<?xf32>> 650 %1 = fir.call @_QPfoo(%0) : (!fir.box<!fir.array<?xf32>>) -> i1 651 return %1 : i1 652} 653 654// CHECK-LABEL: @test_misc_ops( 655// CHECK-SAME: [[ARR1:%.*]]: !fir.ref<!fir.array<?x?xf32>>, [[INDXM:%.*]]: index, [[INDXN:%.*]]: index, [[INDXO:%.*]]: index, [[INDXP:%.*]]: index) 656func @test_misc_ops(%arr1 : !fir.ref<!fir.array<?x?xf32>>, %m : index, %n : index, %o : index, %p : index) { 657 // CHECK: [[I10:%.*]] = constant 10 : index 658 // CHECK: [[J20:%.*]] = constant 20 : index 659 // CHECK: [[C2:%.*]] = constant 2 : index 660 // CHECK: [[C9:%.*]] = constant 9 : index 661 // CHECK: [[C1_I32:%.*]] = constant 9 : i32 662 %i10 = constant 10 : index 663 %j20 = constant 20 : index 664 %c2 = constant 2 : index 665 %c9 = constant 9 : index 666 %c1_i32 = constant 9 : i32 667 668 // CHECK: [[ARR2:%.*]] = fir.zero_bits !fir.array<10xi32> 669 // CHECK: [[ARR3:%.*]] = fir.insert_on_range [[ARR2]], [[C1_I32]], [[C2]], [[C9]] : (!fir.array<10xi32>, i32, index, index) -> !fir.array<10xi32> 670 // CHECK: fir.call @noret1([[ARR3]]) : (!fir.array<10xi32>) -> () 671 %arr2 = fir.zero_bits !fir.array<10xi32> 672 %arr3 = fir.insert_on_range %arr2, %c1_i32, %c2, %c9 : (!fir.array<10xi32>, i32, index, index) -> !fir.array<10xi32> 673 fir.call @noret1(%arr3) : (!fir.array<10xi32>) -> () 674 675 // CHECK: [[SHAPE:%.*]] = fir.shape_shift [[INDXM:%.*]], [[INDXN:%.*]], [[INDXO:%.*]], [[INDXP:%.*]] : (index, index, index, index) -> !fir.shapeshift<2> 676 // CHECK: [[AV1:%.*]] = fir.array_load [[ARR1]]([[SHAPE]]) : (!fir.ref<!fir.array<?x?xf32>>, !fir.shapeshift<2>) -> !fir.array<?x?xf32> 677 // CHECK: [[FVAL:%.*]] = fir.array_fetch [[AV1]], [[I10]], [[J20]] : (!fir.array<?x?xf32>, index, index) -> f32 678 // CHECK: [[AV2:%.*]] = fir.array_update [[AV1]], [[FVAL]], [[I10]], [[J20]] : (!fir.array<?x?xf32>, f32, index, index) -> !fir.array<?x?xf32> 679 // CHECK: fir.array_merge_store [[AV1]], [[AV2]] to [[ARR1]] : !fir.ref<!fir.array<?x?xf32>> 680 %s = fir.shape_shift %m, %n, %o, %p : (index, index, index, index) -> !fir.shapeshift<2> 681 %av1 = fir.array_load %arr1(%s) : (!fir.ref<!fir.array<?x?xf32>>, !fir.shapeshift<2>) -> !fir.array<?x?xf32> 682 %f = fir.array_fetch %av1, %i10, %j20 : (!fir.array<?x?xf32>, index, index) -> f32 683 %av2 = fir.array_update %av1, %f, %i10, %j20 : (!fir.array<?x?xf32>, f32, index, index) -> !fir.array<?x?xf32> 684 fir.array_merge_store %av1, %av2 to %arr1 : !fir.ref<!fir.array<?x?xf32>> 685 686 return 687} 688 689// CHECK-LABEL: @test_shift 690func @test_shift(%arg0: !fir.box<!fir.array<?xf32>>) -> !fir.ref<f32> { 691 %c4 = constant 4 : index 692 %c100 = constant 100 : index 693 // CHECK: fir.shift %{{.*}} : (index) -> !fir.shift<1> 694 %0 = fir.shift %c4 : (index) -> !fir.shift<1> 695 %1 = fir.array_coor %arg0(%0) %c100 : (!fir.box<!fir.array<?xf32>>, !fir.shift<1>, index) -> !fir.ref<f32> 696 return %1 : !fir.ref<f32> 697} 698 699func private @bar_rebox_test(!fir.box<!fir.array<?x?xf32>>) 700// CHECK-LABEL: @test_rebox( 701func @test_rebox(%arg0: !fir.box<!fir.array<?xf32>>) { 702 %c0 = constant 0 : index 703 %c1 = constant 1 : index 704 %c2 = constant 2 : index 705 %c3 = constant 3 : index 706 %c4 = constant 4 : index 707 %c10 = constant 10 : index 708 %c33 = constant 33 : index 709 %0 = fir.slice %c10, %c33, %c2 : (index, index, index) -> !fir.slice<1> 710 %1 = fir.shift %c0 : (index) -> !fir.shift<1> 711 // CHECK: fir.rebox %{{.*}}(%{{.*}}) [%{{.*}}] : (!fir.box<!fir.array<?xf32>>, !fir.shift<1>, !fir.slice<1>) -> !fir.box<!fir.array<?xf32>> 712 %2 = fir.rebox %arg0(%1) [%0] : (!fir.box<!fir.array<?xf32>>, !fir.shift<1>, !fir.slice<1>) -> !fir.box<!fir.array<?xf32>> 713 %3 = fir.shape %c3, %c4 : (index, index) -> !fir.shape<2> 714 // CHECK: fir.rebox %{{.*}}(%{{.*}}) : (!fir.box<!fir.array<?xf32>>, !fir.shape<2>) -> !fir.box<!fir.array<?x?xf32>> 715 %4 = fir.rebox %2(%3) : (!fir.box<!fir.array<?xf32>>, !fir.shape<2>) -> !fir.box<!fir.array<?x?xf32>> 716 fir.call @bar_rebox_test(%4) : (!fir.box<!fir.array<?x?xf32>>) -> () 717 return 718} 719