1044 lines · plain
1// Test the FIR operations2 3// RUN: fir-opt %s | fir-opt | FileCheck %s4 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.func private @it1() -> !fir.int<4>10func.func private @box1() -> !fir.boxchar<2>11func.func private @box2() -> !fir.boxproc<(i32, i32) -> i64>12func.func private @box3() -> !fir.box<!fir.type<derived3{f:f32}>>13 14// Fortran SUBROUTINE and FUNCTION15// 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.func private @print_index3(index, index, index)19func.func private @user_i64(i64)20func.func private @user_tdesc(!fir.tdesc<!fir.type<x>>)21 22// expect the void return to be omitted23// 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.func private @store_tuple(tuple<!fir.type<qq1{f1:i32}>>) -> ()27func.func private @get_method_box() -> !fir.box<!fir.type<derived3{f:f32}>>28func.func 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.func private @nop()33func.func private @get_func() -> (() -> ())34 35// CHECK-LABEL: func @instructions() {36func.func @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 i3240// CHECK: [[VAL_3:%.*]] = arith.constant 22 : i3241 %0 = fir.alloca !fir.array<10xi32>42 %1 = fir.load %0 : !fir.ref<!fir.array<10xi32>>43 %2 = fir.alloca i3244 %3 = arith.constant 22 : i3245 46// CHECK: fir.store [[VAL_3]] to [[VAL_2]] : !fir.ref<i32>47// CHECK: [[VAL_4:%.*]] = fir.undefined i3248// 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 i3252 %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 %7 = fir.box_addr %6 : (!fir.box<!fir.array<100xf32>>) -> !fir.ref<!fir.array<100xf32>>57// CHECK: %[[WAL_2:.*]] = fir.undefined !fir.boxproc<() -> ()>58 %ba1 = fir.undefined !fir.boxproc<() -> ()>59// CHECK: %{{.*}} = fir.box_addr %[[WAL_2]] : (!fir.boxproc<() -> ()>) -> (() -> ())60 %ba2 = fir.box_addr %ba1 : (!fir.boxproc<() -> ()>) -> (() -> ())61 %ba3 = fir.undefined !fir.boxchar<1>62// CHECK: %{{.*}} = fir.box_addr %{{.*}} : (!fir.boxchar<1>) -> !fir.ref<!fir.char<1>>63 %ba4 = fir.box_addr %ba3 : (!fir.boxchar<1>) -> !fir.ref<!fir.char<1>>64 %c0 = arith.constant 0 : index65 %d1:3 = fir.box_dims %6, %c0 : (!fir.box<!fir.array<100xf32>>, index) -> (index, index, index)66// CHECK: [[VAL_8:%.*]] = arith.constant 0 : index67// CHECK: [[VAL_9:%.*]]:3 = fir.box_dims [[VAL_6]], [[VAL_8]] : (!fir.box<!fir.array<100xf32>>, index) -> (index, index, index)68// CHECK: fir.call @print_index3([[VAL_9]]#0, [[VAL_9]]#1, [[VAL_9]]#2) : (index, index, index) -> ()69// CHECK: [[VAL_10:%.*]] = fir.call @it1() : () -> !fir.int<4>70 fir.call @print_index3(%d1#0, %d1#1, %d1#2) : (index, index, index) -> ()71 %8 = fir.call @it1() : () -> !fir.int<4>72 73// CHECK: [[VAL_11:%.*]] = fir.box_elesize [[VAL_6]] : (!fir.box<!fir.array<100xf32>>) -> i6474// CHECK: [[VAL_12:%.*]] = fir.box_isalloc [[VAL_6]] : (!fir.box<!fir.array<100xf32>>) -> i175// CHECK: [[VAL_13:%.*]] = fir.box_isarray [[VAL_6]] : (!fir.box<!fir.array<100xf32>>) -> i176// CHECK: [[VAL_14:%.*]] = fir.box_isptr [[VAL_6]] : (!fir.box<!fir.array<100xf32>>) -> i177// CHECK: [[VAL_15:%.*]] = fir.box_rank [[VAL_6]] : (!fir.box<!fir.array<100xf32>>) -> i6478 %9 = fir.box_elesize %6 : (!fir.box<!fir.array<100xf32>>) -> i6479 %10 = fir.box_isalloc %6 : (!fir.box<!fir.array<100xf32>>) -> i180 %11 = fir.box_isarray %6 : (!fir.box<!fir.array<100xf32>>) -> i181 %12 = fir.box_isptr %6 : (!fir.box<!fir.array<100xf32>>) -> i182 %13 = fir.box_rank %6 : (!fir.box<!fir.array<100xf32>>) -> i6483 84// CHECK: [[VAL_16:%.*]] = fir.box_tdesc [[VAL_6]] : (!fir.box<!fir.array<100xf32>>) -> !fir.tdesc<!fir.array<100xf32>>85// CHECK: [[VAL_17:%.*]] = fir.call @box1() : () -> !fir.boxchar<2>86// CHECK: [[VAL_18:%.*]] = fir.boxchar_len [[VAL_17]] : (!fir.boxchar<2>) -> i3287// CHECK: [[VAL_19:%.*]] = fir.call @box2() : () -> !fir.boxproc<(i32, i32) -> i64>88// CHECK: [[VAL_20:%.*]] = fir.boxproc_host [[VAL_19]] : (!fir.boxproc<(i32, i32) -> i64>) -> !fir.ref<i32>89 %14 = fir.box_tdesc %6 : (!fir.box<!fir.array<100xf32>>) -> !fir.tdesc<!fir.array<100xf32>>90 %15 = fir.call @box1() : () -> !fir.boxchar<2>91 %16 = fir.boxchar_len %15 : (!fir.boxchar<2>) -> i3292 %17 = fir.call @box2() : () -> !fir.boxproc<(i32, i32) -> i64>93 %18 = fir.boxproc_host %17 : (!fir.boxproc<(i32, i32) -> i64>) -> !fir.ref<i32>94 95// CHECK: [[VAL_21:%.*]] = arith.constant 10 : i3296// CHECK: [[VAL_22:%.*]] = fir.coordinate_of [[VAL_5]], [[VAL_21]] : (!fir.heap<!fir.array<100xf32>>, i32) -> !fir.ref<f32>97// CHECK: [[VAL_23:%.*]] = fir.field_index f, !fir.type<derived{f:f32}>98// CHECK: [[VAL_24:%.*]] = fir.undefined !fir.type<derived{f:f32}>99// CHECK: [[VAL_25:%.*]] = fir.extract_value [[VAL_24]], ["f", !fir.type<derived{f:f32}>] : (!fir.type<derived{f:f32}>) -> f32100 %19 = arith.constant 10 : i32101 %20 = fir.coordinate_of %5, %19 : (!fir.heap<!fir.array<100xf32>>, i32) -> !fir.ref<f32>102 %21 = fir.field_index f, !fir.type<derived{f:f32}>103 %22 = fir.undefined !fir.type<derived{f:f32}>104 %23 = fir.extract_value %22, ["f", !fir.type<derived{f:f32}>] : (!fir.type<derived{f:f32}>) -> f32105 106// CHECK: [[VAL_26:%.*]] = arith.constant 1 : i32107// CHECK: [[VAL_27:%.*]] = fir.shape [[VAL_21]] : (i32) -> !fir.shape<1>108// CHECK: [[VAL_28:%.*]] = arith.constant 1.0109// CHECK: [[VAL_29:%.*]] = fir.insert_value [[VAL_24]], [[VAL_28]], ["f", !fir.type<derived{f:f32}>] : (!fir.type<derived{f:f32}>, f32) -> !fir.type<derived{f:f32}>110// CHECK: [[VAL_30:%.*]] = fir.len_param_index f, !fir.type<derived3{f:f32}>111 %c1 = arith.constant 1 : i32112 %24 = fir.shape %19 : (i32) -> !fir.shape<1>113 %cf1 = arith.constant 1.0 : f32114 %25 = fir.insert_value %22, %cf1, ["f", !fir.type<derived{f:f32}>] : (!fir.type<derived{f:f32}>, f32) -> !fir.type<derived{f:f32}>115 %26 = fir.len_param_index f, !fir.type<derived3{f:f32}>116 117// CHECK: [[VAL_31:%.*]] = fir.call @box3() : () -> !fir.class<!fir.type<derived3{f:f32}>>118// CHECK: [[VAL_32:%.*]] = fir.dispatch "method"([[VAL_31]] : !fir.class<!fir.type<derived3{f:f32}>>) -> i32119// CHECK: [[VAL_33:%.*]] = fir.convert [[VAL_32]] : (i32) -> i64120// CHECK: [[VAL_34:%.*]] = fir.type_desc !fir.type<x>121// CHECK: fir.call @user_tdesc([[VAL_34]]) : (!fir.tdesc<!fir.type<x>>) -> ()122// CHECK: [[VAL_35:%.*]] = fir.no_reassoc [[VAL_33]] : i64123 %27 = fir.call @box3() : () -> !fir.class<!fir.type<derived3{f:f32}>>124 %28 = fir.dispatch "method"(%27 : !fir.class<!fir.type<derived3{f:f32}>>) -> i32125 %29 = fir.convert %28 : (i32) -> i64126 %30 = fir.type_desc !fir.type<x>127 fir.call @user_tdesc(%30) : (!fir.tdesc<!fir.type<x>>) -> ()128 %31 = fir.no_reassoc %29 : i64129 130// CHECK: fir.call @user_i64([[VAL_35]]) : (i64) -> ()131// CHECK: fir.freemem [[VAL_5]] : !fir.heap<!fir.array<100xf32>>132// CHECK: [[VAL_36:%.*]] = fir.call @get_func() : () -> (() -> ())133// CHECK: fir.call [[VAL_36]]() : () -> ()134// CHECK: [[VAL_37:%.*]] = fir.address_of(@it1) : !fir.ref<() -> !fir.int<4>>135// CHECK: return136// CHECK: }137 fir.call @user_i64(%31) : (i64) -> ()138 fir.freemem %5 : !fir.heap<!fir.array<100xf32>>139 %32 = fir.call @get_func() : () -> (() -> ())140 fir.call %32() : () -> ()141 %33 = fir.address_of (@it1) : !fir.ref<() -> !fir.int<4>>142 return143}144 145// CHECK-LABEL: func @boxing_match() {146func.func @boxing_match() {147// CHECK: [[VAL_38:%.*]] = fir.alloca i32148// CHECK: [[VAL_39:%.*]] = fir.alloca !fir.type<qq2{f1:i32,f2:f64}>149// CHECK: [[VAL_40:%.*]] = fir.alloca !fir.char<1>150// CHECK: [[VAL_41:%.*]] = fir.alloca tuple<i32, f64>151// CHECK: [[VAL_42:%.*]] = fir.embox [[VAL_38]] : (!fir.ref<i32>) -> !fir.box<i32>152// CHECK: [[VAL_44:%.*]] = arith.constant 8 : i32153// CHECK: [[VAL_45:%.*]] = fir.undefined !fir.char<1>154// CHECK: [[VAL_46:%.*]] = fir.emboxchar [[VAL_40]], [[VAL_44]] : (!fir.ref<!fir.char<1>>, i32) -> !fir.boxchar<1>155// CHECK: [[VAL_47:%.*]]:2 = fir.unboxchar [[VAL_46]] : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1>>, i32)156// CHECK: [[VAL_48:%.*]] = fir.undefined !fir.type<qq2{f1:i32,f2:f64}>157// CHECK: [[VAL_49:%.*]] = arith.constant 0 : i32158// CHECK: [[VAL_50:%.*]] = arith.constant 12 : i32159// CHECK: [[VAL_51:%.*]] = fir.insert_value [[VAL_48]], [[VAL_50]], [0 : i32] : (!fir.type<qq2{f1:i32,f2:f64}>, i32) -> !fir.type<qq2{f1:i32,f2:f64}>160// CHECK: [[VAL_52:%.*]] = arith.constant 1 : i32161// CHECK: [[VAL_53:%.*]] = arith.constant 4.213000e+01 : f64162// CHECK: [[VAL_54:%.*]] = fir.insert_value [[VAL_48]], [[VAL_53]], [1 : i32] : (!fir.type<qq2{f1:i32,f2:f64}>, f64) -> !fir.type<qq2{f1:i32,f2:f64}>163// CHECK: fir.store [[VAL_54]] to [[VAL_39]] : !fir.ref<!fir.type<qq2{f1:i32,f2:f64}>>164// CHECK: %[[WAL_1:.*]] = fir.address_of(@method_impl)165// CHECK: [[VAL_55:%.*]] = fir.emboxproc %[[WAL_1]], [[VAL_41]] : ((!fir.box<!fir.type<derived3{f:f32}>>) -> (), !fir.ref<tuple<i32, f64>>) -> !fir.boxproc<(!fir.box<!fir.type<derived3{f:f32}>>) -> ()>166// 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}>>>)167// CHECK: [[VAL_58:%.*]] = fir.call @box2() : () -> !fir.boxproc<(i32, i32) -> i64>168// 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}>>>)169// CHECK: [[VAL_61:%.*]] = fir.load [[VAL_60]] : !fir.ref<tuple<!fir.type<qq1{f1:i32}>>>170// CHECK: fir.call @store_tuple([[VAL_61]]) : (tuple<!fir.type<qq1{f1:i32}>>) -> ()171// CHECK: return172// CHECK: }173 %0 = fir.alloca i32174 %d6 = fir.alloca !fir.type<qq2{f1:i32,f2:f64}>175 %d3 = fir.alloca !fir.char<1>176 %e6 = fir.alloca tuple<i32,f64>177 %1 = fir.embox %0 : (!fir.ref<i32>) -> !fir.box<i32>178 %c8 = arith.constant 8 : i32179 %3 = fir.undefined !fir.char<1>180 %4 = fir.emboxchar %d3, %c8 : (!fir.ref<!fir.char<1>>, i32) -> !fir.boxchar<1>181 %5:2 = fir.unboxchar %4 : (!fir.boxchar<1>) -> (!fir.ref<!fir.char<1>>, i32)182 %6 = fir.undefined !fir.type<qq2{f1:i32,f2:f64}>183 %z = arith.constant 0 : i32184 %c12 = arith.constant 12 : i32185 %a2 = fir.insert_value %6, %c12, [0 : i32] : (!fir.type<qq2{f1:i32,f2:f64}>, i32) -> !fir.type<qq2{f1:i32,f2:f64}>186 %z1 = arith.constant 1 : i32187 %c42 = arith.constant 42.13 : f64188 %a3 = fir.insert_value %6, %c42, [1 : i32] : (!fir.type<qq2{f1:i32,f2:f64}>, f64) -> !fir.type<qq2{f1:i32,f2:f64}>189 fir.store %a3 to %d6 : !fir.ref<!fir.type<qq2{f1:i32,f2:f64}>>190 %mi = fir.address_of(@method_impl) : (!fir.box<!fir.type<derived3{f:f32}>>) -> ()191 %7 = fir.emboxproc %mi, %e6 : ((!fir.box<!fir.type<derived3{f:f32}>>) -> (), !fir.ref<tuple<i32,f64>>) -> !fir.boxproc<(!fir.box<!fir.type<derived3{f:f32}>>) -> ()>192 %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}>>>)193 %9 = fir.call @box2() : () -> !fir.boxproc<(i32, i32) -> i64>194 %10:2 = fir.unboxproc %9 : (!fir.boxproc<(i32, i32) -> i64>) -> ((i32, i32) -> i64, !fir.ref<tuple<!fir.type<qq1{f1:i32}>>>)195 %11 = fir.load %10#1 : !fir.ref<tuple<!fir.type<qq1{f1:i32}>>>196 fir.call @store_tuple(%11) : (tuple<!fir.type<qq1{f1:i32}>>) -> ()197 return198}199 200// CHECK-LABEL: func @loop() {201func.func @loop() {202// CHECK: [[VAL_62:%.*]] = arith.constant 1 : index203// CHECK: [[VAL_63:%.*]] = arith.constant 10 : index204// CHECK: [[VAL_64:%.*]] = arith.constant true205 %c1 = arith.constant 1 : index206 %c10 = arith.constant 10 : index207 %ct = arith.constant true208 209// CHECK: fir.do_loop [[VAL_65:%.*]] = [[VAL_62]] to [[VAL_63]] step [[VAL_62]] {210// CHECK: fir.if [[VAL_64]] {211// CHECK: fir.call @nop() : () -> ()212// CHECK: } else {213// CHECK: fir.call @nop() : () -> ()214// CHECK: }215// CHECK: }216// CHECK: fir.unreachable217// CHECK: }218 fir.do_loop %i = %c1 to %c10 step %c1 {219 fir.if %ct {220 fir.call @nop() : () -> ()221 } else {222 fir.call @nop() : () -> ()223 }224 }225 fir.unreachable226}227 228// CHECK: func @bar_select([[VAL_66:%.*]]: i32, [[VAL_67:%.*]]: i32) -> i32 {229func.func @bar_select(%arg : i32, %arg2 : i32) -> i32 {230// CHECK: [[VAL_68:%.*]] = arith.constant 1 : i32231// CHECK: [[VAL_69:%.*]] = arith.constant 2 : i32232// CHECK: [[VAL_70:%.*]] = arith.constant 3 : i32233// CHECK: [[VAL_71:%.*]] = arith.constant 4 : i32234 %0 = arith.constant 1 : i32235 %1 = arith.constant 2 : i32236 %2 = arith.constant 3 : i32237 %3 = arith.constant 4 : i32238 239// 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]240// CHECK: ^bb1([[VAL_72:%.*]]: i32):241// CHECK: return [[VAL_72]] : i32242// CHECK: ^bb2([[VAL_73:%.*]]: i32, [[VAL_74:%.*]]: i32, [[VAL_75:%.*]]: i32):243// CHECK: [[VAL_76:%.*]] = arith.addi [[VAL_73]], [[VAL_74]] : i32244// CHECK: [[VAL_77:%.*]] = arith.addi [[VAL_76]], [[VAL_75]] : i32245// CHECK: return [[VAL_77]] : i32246// CHECK: ^bb3([[VAL_78:%.*]]: i32, [[VAL_79:%.*]]: i32):247// CHECK: [[VAL_80:%.*]] = arith.addi [[VAL_78]], [[VAL_79]] : i32248// CHECK: return [[VAL_80]] : i32249// CHECK: ^bb4([[VAL_81:%.*]]: i32):250// CHECK: return [[VAL_81]] : i32251// CHECK: ^bb5:252// CHECK: [[VAL_82:%.*]] = arith.constant 0 : i32253// CHECK: return [[VAL_82]] : i32254// CHECK: }255 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 ]256^bb1(%a : i32) :257 return %a : i32258^bb2(%b : i32, %b2 : i32, %b3:i32) :259 %4 = arith.addi %b, %b2 : i32260 %5 = arith.addi %4, %b3 : i32261 return %5 : i32262^bb3(%c:i32, %c2:i32) :263 %6 = arith.addi %c, %c2 : i32264 return %6 : i32265^bb4(%d : i32) :266 return %d : i32267^bb5 :268 %zero = arith.constant 0 : i32269 return %zero : i32270}271 272// CHECK-LABEL: func @bar_select_rank(273// CHECK-SAME: [[VAL_83:%.*]]: i32, [[VAL_84:%.*]]: i32) -> i32 {274func.func @bar_select_rank(%arg : i32, %arg2 : i32) -> i32 {275// CHECK: [[VAL_85:%.*]] = arith.constant 1 : i32276// CHECK: [[VAL_86:%.*]] = arith.constant 2 : i32277// CHECK: [[VAL_87:%.*]] = arith.constant 3 : i32278// CHECK: [[VAL_88:%.*]] = arith.constant 4 : i32279 %0 = arith.constant 1 : i32280 %1 = arith.constant 2 : i32281 %2 = arith.constant 3 : i32282 %3 = arith.constant 4 : i32283 284// 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]285// CHECK: ^bb1([[VAL_89:%.*]]: i32):286// CHECK: return [[VAL_89]] : i32287// CHECK: ^bb2([[VAL_90:%.*]]: i32, [[VAL_91:%.*]]: i32, [[VAL_92:%.*]]: i32):288// CHECK: [[VAL_93:%.*]] = arith.addi [[VAL_90]], [[VAL_91]] : i32289// CHECK: [[VAL_94:%.*]] = arith.addi [[VAL_93]], [[VAL_92]] : i32290// CHECK: return [[VAL_94]] : i32291 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 ]292^bb1(%a : i32) :293 return %a : i32294^bb2(%b : i32, %b2 : i32, %b3:i32) :295 %4 = arith.addi %b, %b2 : i32296 %5 = arith.addi %4, %b3 : i32297 return %5 : i32298 299// CHECK: ^bb3([[VAL_95:%.*]]: i32, [[VAL_96:%.*]]: i32):300// CHECK: [[VAL_97:%.*]] = arith.addi [[VAL_95]], [[VAL_96]] : i32301// CHECK: return [[VAL_97]] : i32302// CHECK: ^bb4([[VAL_98:%.*]]: i32):303// CHECK: return [[VAL_98]] : i32304^bb3(%c:i32, %c2:i32) :305 %6 = arith.addi %c, %c2 : i32306 return %6 : i32307^bb4(%d : i32) :308 return %d : i32309 310// CHECK: ^bb5:311// CHECK: [[VAL_99:%.*]] = arith.constant 0 : i32312// CHECK: [[VAL_100:%.*]] = fir.call @get_method_box() : () -> !fir.class<!fir.type<derived3{f:f32}>>313// CHECK: fir.dispatch "method"([[VAL_100]] : !fir.class<!fir.type<derived3{f:f32}>>)314^bb5 :315 %zero = arith.constant 0 : i32316 %7 = fir.call @get_method_box() : () -> !fir.class<!fir.type<derived3{f:f32}>>317 fir.dispatch "method"(%7 : !fir.class<!fir.type<derived3{f:f32}>>)318 319// CHECK: return [[VAL_99]] : i32320// CHECK: }321 return %zero : i32322}323 324// CHECK-LABEL: func @bar_select_type(325// CHECK-SAME: [[VAL_101:%.*]]: !fir.class<!fir.type<name(param1:i32){fld:!fir.char<1>}>>) -> i32 {326func.func @bar_select_type(%arg : !fir.class<!fir.type<name(param1:i32){fld:!fir.char<1>}>>) -> i32 {327 328// CHECK: [[VAL_102:%.*]] = arith.constant 1 : i32329// CHECK: [[VAL_103:%.*]] = arith.constant 2 : i32330// CHECK: [[VAL_104:%.*]] = arith.constant 3 : i32331// CHECK: [[VAL_105:%.*]] = arith.constant 4 : i32332 %0 = arith.constant 1 : i32333 %1 = arith.constant 2 : i32334 %2 = arith.constant 3 : i32335 %3 = arith.constant 4 : i32336 337// CHECK: fir.select_type [[VAL_101]] : !fir.class<!fir.type<name(param1:i32){fld:!fir.char<1>}>> [#fir.type_is<!fir.int<4>>, ^bb1([[VAL_102]] : i32), #fir.type_is<!fir.int<8>>, ^bb2([[VAL_104]] : i32), #fir.class_is<!fir.int<2>>, ^bb3([[VAL_104]] : i32), #fir.type_is<!fir.int<1>>, ^bb4([[VAL_103]] : i32), unit, ^bb5]338 fir.select_type %arg : !fir.class<!fir.type<name(param1:i32){fld:!fir.char<1>}>> [ #fir.type_is<!fir.int<4>>,^bb1(%0:i32), #fir.type_is<!fir.int<8>>,^bb2(%2:i32), #fir.class_is<!fir.int<2>>,^bb3(%2:i32), #fir.type_is<!fir.int<1>>,^bb4(%1:i32), unit,^bb5 ]339 340// CHECK: ^bb1([[VAL_106:%.*]]: i32):341// CHECK: return [[VAL_106]] : i32342// CHECK: ^bb2([[VAL_107:%.*]]: i32):343// CHECK: return [[VAL_107]] : i32344// CHECK: ^bb3([[VAL_108:%.*]]: i32):345// CHECK: return [[VAL_108]] : i32346// CHECK: ^bb4([[VAL_109:%.*]]: i32):347// CHECK: return [[VAL_109]] : i32348^bb1(%a : i32) :349 return %a : i32350^bb2(%b : i32) :351 return %b : i32352^bb3(%c : i32) :353 return %c : i32354^bb4(%d : i32) :355 return %d : i32356 357// CHECK: ^bb5:358// CHECK: [[VAL_110:%.*]] = arith.constant 0 : i32359// CHECK: return [[VAL_110]] : i32360// CHECK: }361^bb5 :362 %zero = arith.constant 0 : i32363 return %zero : i32364}365 366// CHECK-LABEL: func @bar_select_case(367// CHECK-SAME: [[VAL_111:%.*]]: i32, [[VAL_112:%.*]]: i32) -> i32 {368// CHECK: [[VAL_113:%.*]] = arith.constant 1 : i32369// CHECK: [[VAL_114:%.*]] = arith.constant 2 : i32370// CHECK: [[VAL_115:%.*]] = arith.constant 3 : i32371// CHECK: [[VAL_116:%.*]] = arith.constant 4 : i32372func.func @bar_select_case(%arg : i32, %arg2 : i32) -> i32 {373 %0 = arith.constant 1 : i32374 %1 = arith.constant 2 : i32375 %2 = arith.constant 3 : i32376 %3 = arith.constant 4 : i32377 378// 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]379 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]380 381// CHECK: ^bb1([[VAL_117:%.*]]: i32):382// CHECK: return [[VAL_117]] : i32383// CHECK: ^bb2([[VAL_118:%.*]]: i32, [[VAL_119:%.*]]: i32, [[VAL_120:%.*]]: i32, [[VAL_121:%.*]]: i32):384// CHECK: [[VAL_122:%.*]] = arith.addi [[VAL_118]], [[VAL_119]] : i32385// CHECK: [[VAL_123:%.*]] = arith.muli [[VAL_122]], [[VAL_120]] : i32386// CHECK: [[VAL_124:%.*]] = arith.addi [[VAL_123]], [[VAL_121]] : i32387// CHECK: return [[VAL_124]] : i32388// CHECK: ^bb3([[VAL_125:%.*]]: i32, [[VAL_126:%.*]]: i32):389// CHECK: [[VAL_127:%.*]] = arith.addi [[VAL_125]], [[VAL_126]] : i32390// CHECK: return [[VAL_127]] : i32391// CHECK: ^bb4([[VAL_128:%.*]]: i32):392// CHECK: return [[VAL_128]] : i32393^bb1(%a : i32) :394 return %a : i32395^bb2(%b : i32, %b2:i32, %b3:i32, %b4:i32) :396 %4 = arith.addi %b, %b2 : i32397 %5 = arith.muli %4, %b3 : i32398 %6 = arith.addi %5, %b4 : i32399 return %6 : i32400^bb3(%c : i32, %c2 : i32) :401 %7 = arith.addi %c, %c2 : i32402 return %7 : i32403^bb4(%d : i32) :404 return %d : i32405 406// CHECK: ^bb5:407// CHECK: [[VAL_129:%.*]] = arith.constant 0 : i32408// CHECK: return [[VAL_129]] : i32409// CHECK: }410^bb5 :411 %zero = arith.constant 0 : i32412 return %zero : i32413}414 415// CHECK-LABEL: fir.global @global_var : i32 {416// CHECK: [[VAL_130:%.*]] = arith.constant 1 : i32417// CHECK: fir.has_value [[VAL_130]] : i32418// CHECK: }419fir.global @global_var : i32 {420 %0 = arith.constant 1 : i32421 fir.has_value %0 : i32422}423 424// CHECK-LABEL: fir.global @global_constant constant : i32 {425// CHECK: [[VAL_131:%.*]] = arith.constant 934 : i32426// CHECK: fir.has_value [[VAL_131]] : i32427// CHECK: }428fir.global @global_constant constant : i32 {429 %0 = arith.constant 934 : i32430 fir.has_value %0 : i32431}432 433// CHECK-LABEL: fir.global @global_derived : !fir.type<minez(f:i32)> {434// CHECK: fir.global_len "f", 1 : i32435// CHECK: [[VAL_132:%.*]] = fir.undefined !fir.type<minez(f:i32)>436// CHECK: fir.has_value [[VAL_132]] : !fir.type<minez(f:i32)>437// CHECK: }438fir.global @global_derived : !fir.type<minez(f:i32)> {439 fir.global_len f, 1 : i32440 %0 = fir.undefined !fir.type<minez>441 fir.has_value %0 : !fir.type<minez>442}443 444// CHECK-LABEL: fir.global linkonce_odr @global_linkonce_odr : i32 {445// CHECK: [[VAL_130:%.*]] = arith.constant 1 : i32446// CHECK: fir.has_value [[VAL_130]] : i32447// CHECK: }448fir.global linkonce_odr @global_linkonce_odr : i32 {449 %0 = arith.constant 1 : i32450 fir.has_value %0 : i32451}452 453// CHECK-LABEL: fir.type_info @dispatch_tbl : !fir.type<dispatch_tbl{i:i32}> dispatch_table {454// CHECK: fir.dt_entry "method", @method_impl455// CHECK: }456fir.type_info @dispatch_tbl : !fir.type<dispatch_tbl{i:i32}> dispatch_table {457 fir.dt_entry "method", @method_impl458}459 460// CHECK-LABEL: fir.type_info @test_type_info noinit nodestroy nofinal extends !fir.type<parent{i:i32}> : !fir.type<test_type_info{i:i32,j:f32}>461fir.type_info @test_type_info noinit nodestroy nofinal extends !fir.type<parent{i:i32}> : !fir.type<test_type_info{i:i32,j:f32}>462 463// CHECK-LABEL: fir.type_info @cpinfo : !fir.type<cpinfo{comp_i:!fir.array<10x20xi32>}> component_info {464// CHECK: fir.dt_component "component_info" lbs [2, 3]465// CHECK: }466fir.type_info @cpinfo : !fir.type<cpinfo{comp_i:!fir.array<10x20xi32>}> component_info {467 fir.dt_component "component_info" lbs [2, 3]468}469 470// CHECK-LABEL: func @compare_complex(471// CHECK-SAME: [[VAL_151:%.*]]: complex<f128>, [[VAL_152:%.*]]: complex<f128>) {472func.func @compare_complex(%a : complex<f128>, %b : complex<f128>) {473 474// CHECK: [[VAL_153:%.*]] = fir.cmpc "false", [[VAL_151]], [[VAL_152]] {fastmath = {{.*}}} : complex<f128>475// CHECK: [[VAL_154:%.*]] = fir.cmpc "oeq", [[VAL_151]], [[VAL_152]] {fastmath = {{.*}}} : complex<f128>476// CHECK: [[VAL_155:%.*]] = fir.cmpc "ogt", [[VAL_151]], [[VAL_152]] {fastmath = {{.*}}} : complex<f128>477// CHECK: [[VAL_156:%.*]] = fir.cmpc "oge", [[VAL_151]], [[VAL_152]] {fastmath = {{.*}}} : complex<f128>478 %d0 = fir.cmpc "false", %a, %b : complex<f128>479 %d1 = fir.cmpc "oeq", %a, %b : complex<f128>480 %d2 = fir.cmpc "ogt", %a, %b : complex<f128>481 %d3 = fir.cmpc "oge", %a, %b : complex<f128>482 483// CHECK: [[VAL_157:%.*]] = fir.cmpc "olt", [[VAL_151]], [[VAL_152]] {fastmath = {{.*}}} : complex<f128>484// CHECK: [[VAL_158:%.*]] = fir.cmpc "ole", [[VAL_151]], [[VAL_152]] {fastmath = {{.*}}} : complex<f128>485// CHECK: [[VAL_159:%.*]] = fir.cmpc "one", [[VAL_151]], [[VAL_152]] {fastmath = {{.*}}} : complex<f128>486// CHECK: [[VAL_160:%.*]] = fir.cmpc "ord", [[VAL_151]], [[VAL_152]] {fastmath = {{.*}}} : complex<f128>487 %a0 = fir.cmpc "olt", %a, %b : complex<f128>488 %a1 = fir.cmpc "ole", %a, %b : complex<f128>489 %a2 = fir.cmpc "one", %a, %b : complex<f128>490 %a3 = fir.cmpc "ord", %a, %b : complex<f128>491 492// CHECK: [[VAL_161:%.*]] = fir.cmpc "ueq", [[VAL_151]], [[VAL_152]] {fastmath = {{.*}}} : complex<f128>493// CHECK: [[VAL_162:%.*]] = fir.cmpc "ugt", [[VAL_151]], [[VAL_152]] {fastmath = {{.*}}} : complex<f128>494// CHECK: [[VAL_163:%.*]] = fir.cmpc "uge", [[VAL_151]], [[VAL_152]] {fastmath = {{.*}}} : complex<f128>495// CHECK: [[VAL_164:%.*]] = fir.cmpc "ult", [[VAL_151]], [[VAL_152]] {fastmath = {{.*}}} : complex<f128>496 %b0 = fir.cmpc "ueq", %a, %b : complex<f128>497 %b1 = fir.cmpc "ugt", %a, %b : complex<f128>498 %b2 = fir.cmpc "uge", %a, %b : complex<f128>499 %b3 = fir.cmpc "ult", %a, %b : complex<f128>500 501// CHECK: [[VAL_165:%.*]] = fir.cmpc "ule", [[VAL_151]], [[VAL_152]] {fastmath = {{.*}}} : complex<f128>502// CHECK: [[VAL_166:%.*]] = fir.cmpc "une", [[VAL_151]], [[VAL_152]] {fastmath = {{.*}}} : complex<f128>503// CHECK: [[VAL_167:%.*]] = fir.cmpc "uno", [[VAL_151]], [[VAL_152]] {fastmath = {{.*}}} : complex<f128>504// CHECK: [[VAL_168:%.*]] = fir.cmpc "true", [[VAL_151]], [[VAL_152]] {fastmath = {{.*}}} : complex<f128>505 %c0 = fir.cmpc "ule", %a, %b : complex<f128>506 %c1 = fir.cmpc "une", %a, %b : complex<f128>507 %c2 = fir.cmpc "uno", %a, %b : complex<f128>508 %c3 = fir.cmpc "true", %a, %b : complex<f128>509// CHECK: return510// CHECK: }511 return512}513 514// CHECK-LABEL: func @arith_real(515// CHECK-SAME: [[VAL_169:%.*]]: f128, [[VAL_170:%.*]]: f128) -> f128 {516func.func @arith_real(%a : f128, %b : f128) -> f128 {517 518// CHECK: [[VAL_171:%.*]] = arith.constant 1.0519// CHECK: [[VAL_172:%.*]] = fir.convert [[VAL_171]] : (f32) -> f128520// CHECK: [[VAL_173:%.*]] = arith.negf [[VAL_169]] : f128521// CHECK: [[VAL_174:%.*]] = arith.addf [[VAL_172]], [[VAL_173]] : f128522// CHECK: [[VAL_175:%.*]] = arith.subf [[VAL_174]], [[VAL_170]] : f128523// CHECK: [[VAL_176:%.*]] = arith.mulf [[VAL_173]], [[VAL_175]] : f128524// CHECK: [[VAL_177:%.*]] = arith.divf [[VAL_176]], [[VAL_169]] : f128525 %c1 = arith.constant 1.0 : f32526 %0 = fir.convert %c1 : (f32) -> f128527 %1 = arith.negf %a : f128528 %2 = arith.addf %0, %1 : f128529 %3 = arith.subf %2, %b : f128530 %4 = arith.mulf %1, %3 : f128531 %5 = arith.divf %4, %a : f128532// CHECK: return [[VAL_177]] : f128533// CHECK: }534 return %5 : f128535}536 537// CHECK-LABEL: func @arith_complex(538// CHECK-SAME: [[VAL_179:%.*]]: complex<f128>, [[VAL_180:%.*]]: complex<f128>) -> complex<f128> {539func.func @arith_complex(%a : complex<f128>, %b : complex<f128>) -> complex<f128> {540// CHECK: [[VAL_181:%.*]] = fir.negc [[VAL_179]] : complex<f128>541// CHECK: [[VAL_182:%.*]] = fir.addc [[VAL_180]], [[VAL_181]] : complex<f128>542// CHECK: [[VAL_183:%.*]] = fir.subc [[VAL_182]], [[VAL_180]] : complex<f128>543// CHECK: [[VAL_184:%.*]] = fir.mulc [[VAL_181]], [[VAL_183]] : complex<f128>544// CHECK: [[VAL_185:%.*]] = fir.divc [[VAL_184]], [[VAL_179]] : complex<f128>545 %1 = fir.negc %a : complex<f128>546 %2 = fir.addc %b, %1 : complex<f128>547 %3 = fir.subc %2, %b : complex<f128>548 %4 = fir.mulc %1, %3 : complex<f128>549 %5 = fir.divc %4, %a : complex<f128>550// CHECK: return [[VAL_185]] : complex<f128>551// CHECK: }552 return %5 : complex<f128>553}554 555// CHECK-LABEL: func @character_literal() -> !fir.char<1,13> {556func.func @character_literal() -> !fir.char<1,13> {557// CHECK: [[VAL_186:%.*]] = fir.string_lit "Hello, World!"(13) : !fir.char<1,13>558 %0 = fir.string_lit "Hello, World!"(13) : !fir.char<1,13>559// CHECK: return [[VAL_186]] : !fir.char<1,13>560 return %0 : !fir.char<1,13>561// CHECK: }562}563 564// CHECK-LABEL: func private @earlyexit2(i32) -> i1565func.func private @earlyexit2(%a : i32) -> i1566 567// CHECK-LABEL: func @early_exit(568// CHECK-SAME: [[VAL_187:%.*]]: i1, [[VAL_188:%.*]]: i32) -> i1 {569func.func @early_exit(%ok : i1, %k : i32) -> i1 {570// CHECK: [[VAL_189:%.*]] = arith.constant 1 : index571// CHECK: [[VAL_190:%.*]] = arith.constant 100 : index572 %c1 = arith.constant 1 : index573 %c100 = arith.constant 100 : index574 575// 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) {576// CHECK: [[VAL_195:%.*]] = func.call @earlyexit2([[VAL_194]]) : (i32) -> i1577// CHECK: fir.result [[VAL_195]], [[VAL_194]] : i1, i32578// CHECK: }579 %newOk:2 = fir.iterate_while (%i = %c1 to %c100 step %c1) and (%ok_ = %ok) iter_args(%v = %k) -> (i32) {580 %stop = func.call @earlyexit2(%v) : (i32) -> i1581 fir.result %stop, %v : i1, i32582 }583// CHECK: return %[[VAL_191]]#0 : i1584// CHECK: }585 return %newOk#0 : i1586}587 588// CHECK-LABEL: @array_access589func.func @array_access(%arr : !fir.ref<!fir.array<?x?xf32>>) {590 // CHECK-DAG: %[[c1:.*]] = arith.constant 100591 // CHECK-DAG: %[[c2:.*]] = arith.constant 50592 %c100 = arith.constant 100 : index593 %c50 = arith.constant 50 : index594 // CHECK: %[[sh:.*]] = fir.shape %[[c1]], %[[c2]] : {{.*}} -> !fir.shape<2>595 %shape = fir.shape %c100, %c50 : (index, index) -> !fir.shape<2>596 %c47 = arith.constant 47 : index597 %c78 = arith.constant 78 : index598 %c3 = arith.constant 3 : index599 %c18 = arith.constant 18 : index600 %c36 = arith.constant 36 : index601 %c4 = arith.constant 4 : index602 // CHECK: %[[sl:.*]] = fir.slice {{.*}} -> !fir.slice<2>603 %slice = fir.slice %c47, %c78, %c3, %c18, %c36, %c4 : (index,index,index,index,index,index) -> !fir.slice<2>604 %c0 = arith.constant 0 : index605 %c99 = arith.constant 99 : index606 %c1 = arith.constant 1 : index607 fir.do_loop %i = %c0 to %c99 step %c1 {608 %c49 = arith.constant 49 : index609 fir.do_loop %j = %c0 to %c49 step %c1 {610 // CHECK: fir.array_coor %{{.*}}(%[[sh]]) [%[[sl]]] %{{.*}}, %{{.*}} :611 %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>612 %x = arith.constant 42.0 : f32613 fir.store %x to %p : !fir.ref<f32>614 }615 }616 return617}618 619// CHECK-LABEL: @test_is_present620func.func @test_is_present(%arg0: !fir.box<!fir.array<?xf32>>) -> i1 {621 // CHECK: fir.is_present %{{.*}} : (!fir.box<!fir.array<?xf32>>) -> i1622 %0 = fir.is_present %arg0 : (!fir.box<!fir.array<?xf32>>) -> i1623 return %0 : i1624}625// CHECK-LABEL: @test_absent626func.func @test_absent() -> i1 {627 // CHECK: fir.absent !fir.box<!fir.array<?xf32>>628 %0 = fir.absent !fir.box<!fir.array<?xf32>>629 %1 = fir.call @_QPfoo(%0) : (!fir.box<!fir.array<?xf32>>) -> i1630 return %1 : i1631}632 633// CHECK-LABEL: @test_misc_ops(634// CHECK-SAME: [[ARR1:%.*]]: !fir.ref<!fir.array<?x?xf32>>, [[INDXM:%.*]]: index, [[INDXN:%.*]]: index, [[INDXO:%.*]]: index, [[INDXP:%.*]]: index)635func.func @test_misc_ops(%arr1 : !fir.ref<!fir.array<?x?xf32>>, %m : index, %n : index, %o : index, %p : index) {636 // CHECK: [[I10:%.*]] = arith.constant 10 : index637 // CHECK: [[J20:%.*]] = arith.constant 20 : index638 // CHECK: [[C2:%.*]] = arith.constant 2 : index639 // CHECK: [[C9:%.*]] = arith.constant 9 : index640 // CHECK: [[C1_I32:%.*]] = arith.constant 9 : i32641 %i10 = arith.constant 10 : index642 %j20 = arith.constant 20 : index643 %c2 = arith.constant 2 : index644 %c9 = arith.constant 9 : index645 %c1_i32 = arith.constant 9 : i32646 647 // CHECK: [[ARR2:%.*]] = fir.zero_bits !fir.array<10xi32>648 // CHECK: [[ARR3:%.*]] = fir.insert_on_range [[ARR2]], [[C1_I32]] from (2) to (9) : (!fir.array<10xi32>, i32) -> !fir.array<10xi32>649 // CHECK: fir.call @noret1([[ARR3]]) : (!fir.array<10xi32>) -> ()650 %arr2 = fir.zero_bits !fir.array<10xi32>651 %arr3 = fir.insert_on_range %arr2, %c1_i32 from (2) to (9) : (!fir.array<10xi32>, i32) -> !fir.array<10xi32>652 fir.call @noret1(%arr3) : (!fir.array<10xi32>) -> ()653 654 // CHECK: [[SHAPE:%.*]] = fir.shape_shift [[INDXM:%.*]], [[INDXN:%.*]], [[INDXO:%.*]], [[INDXP:%.*]] : (index, index, index, index) -> !fir.shapeshift<2>655 // CHECK: [[AV1:%.*]] = fir.array_load [[ARR1]]([[SHAPE]]) : (!fir.ref<!fir.array<?x?xf32>>, !fir.shapeshift<2>) -> !fir.array<?x?xf32>656 // CHECK: [[FVAL:%.*]] = fir.array_fetch [[AV1]], [[I10]], [[J20]] : (!fir.array<?x?xf32>, index, index) -> f32657 // CHECK: [[AV2:%.*]] = fir.array_update [[AV1]], [[FVAL]], [[I10]], [[J20]] : (!fir.array<?x?xf32>, f32, index, index) -> !fir.array<?x?xf32>658 // CHECK: fir.array_merge_store [[AV1]], [[AV2]] to [[ARR1]] : !fir.array<?x?xf32>, !fir.array<?x?xf32>, !fir.ref<!fir.array<?x?xf32>>659 %s = fir.shape_shift %m, %n, %o, %p : (index, index, index, index) -> !fir.shapeshift<2>660 %av1 = fir.array_load %arr1(%s) : (!fir.ref<!fir.array<?x?xf32>>, !fir.shapeshift<2>) -> !fir.array<?x?xf32>661 %f = fir.array_fetch %av1, %i10, %j20 : (!fir.array<?x?xf32>, index, index) -> f32662 %av2 = fir.array_update %av1, %f, %i10, %j20 : (!fir.array<?x?xf32>, f32, index, index) -> !fir.array<?x?xf32>663 fir.array_merge_store %av1, %av2 to %arr1 : !fir.array<?x?xf32>, !fir.array<?x?xf32>, !fir.ref<!fir.array<?x?xf32>>664 665 // CHECK: [[AV3:%.*]] = fir.array_load [[ARR1]]([[SHAPE]]) : (!fir.ref<!fir.array<?x?xf32>>, !fir.shapeshift<2>) -> !fir.array<?x?xf32>666 // CHECK: [[FVAL2:%.*]] = fir.array_fetch [[AV3]], [[I10]], [[J20]] : (!fir.array<?x?xf32>, index, index) -> f32667 // CHECK: [[AV4:%.*]]:2 = fir.array_modify [[AV3]], [[I10]], [[J20]] : (!fir.array<?x?xf32>, index, index) -> (!fir.ref<f32>, !fir.array<?x?xf32>)668 // CHECK: fir.store [[FVAL2]] to [[AV4]]#0 : !fir.ref<f32>669 // CHECK: fir.array_merge_store [[AV3]], [[AV4]]#1 to [[ARR1]] : !fir.array<?x?xf32>, !fir.array<?x?xf32>, !fir.ref<!fir.array<?x?xf32>>670 %av3 = fir.array_load %arr1(%s) : (!fir.ref<!fir.array<?x?xf32>>, !fir.shapeshift<2>) -> !fir.array<?x?xf32>671 %f2 = fir.array_fetch %av3, %i10, %j20 : (!fir.array<?x?xf32>, index, index) -> f32672 %addr, %av4 = fir.array_modify %av3, %i10, %j20 : (!fir.array<?x?xf32>, index, index) -> (!fir.ref<f32>, !fir.array<?x?xf32>)673 fir.store %f2 to %addr : !fir.ref<f32>674 fir.array_merge_store %av3, %av4 to %arr1 : !fir.array<?x?xf32>, !fir.array<?x?xf32>, !fir.ref<!fir.array<?x?xf32>>675 return676}677 678// CHECK-LABEL: @insert_on_range_multi_dim679// CHECK-SAME: %[[ARR:.*]]: !fir.array<10x20xi32>, %[[CST:.*]]: i32680func.func @insert_on_range_multi_dim(%arr : !fir.array<10x20xi32>, %cst : i32) {681 // CHECK: fir.insert_on_range %[[ARR]], %[[CST]] from (2, 3) to (5, 6) : (!fir.array<10x20xi32>, i32) -> !fir.array<10x20xi32>682 %arr3 = fir.insert_on_range %arr, %cst from (2, 3) to (5, 6) : (!fir.array<10x20xi32>, i32) -> !fir.array<10x20xi32>683 return684}685 686// CHECK-LABEL: @test_shift687func.func @test_shift(%arg0: !fir.box<!fir.array<?xf32>>) -> !fir.ref<f32> {688 %c4 = arith.constant 4 : index689 %c100 = arith.constant 100 : index690 // CHECK: fir.shift %{{.*}} : (index) -> !fir.shift<1>691 %0 = fir.shift %c4 : (index) -> !fir.shift<1>692 %1 = fir.array_coor %arg0(%0) %c100 : (!fir.box<!fir.array<?xf32>>, !fir.shift<1>, index) -> !fir.ref<f32>693 return %1 : !fir.ref<f32>694} 695 696func.func private @bar_rebox_test(!fir.box<!fir.array<?x?xf32>>)697// CHECK-LABEL: @test_rebox(698func.func @test_rebox(%arg0: !fir.box<!fir.array<?xf32>>) {699 %c0 = arith.constant 0 : index700 %c1 = arith.constant 1 : index701 %c2 = arith.constant 2 : index702 %c3 = arith.constant 3 : index703 %c4 = arith.constant 4 : index704 %c10 = arith.constant 10 : index705 %c33 = arith.constant 33 : index706 %0 = fir.slice %c10, %c33, %c2 : (index, index, index) -> !fir.slice<1>707 %1 = fir.shift %c0 : (index) -> !fir.shift<1>708 // CHECK: fir.rebox %{{.*}}(%{{.*}}) [%{{.*}}] : (!fir.box<!fir.array<?xf32>>, !fir.shift<1>, !fir.slice<1>) -> !fir.box<!fir.array<?xf32>>709 %2 = fir.rebox %arg0(%1) [%0] : (!fir.box<!fir.array<?xf32>>, !fir.shift<1>, !fir.slice<1>) -> !fir.box<!fir.array<?xf32>>710 %3 = fir.shape %c3, %c4 : (index, index) -> !fir.shape<2>711 // CHECK: fir.rebox %{{.*}}(%{{.*}}) : (!fir.box<!fir.array<?xf32>>, !fir.shape<2>) -> !fir.box<!fir.array<?x?xf32>>712 %4 = fir.rebox %2(%3) : (!fir.box<!fir.array<?xf32>>, !fir.shape<2>) -> !fir.box<!fir.array<?x?xf32>>713 fir.call @bar_rebox_test(%4) : (!fir.box<!fir.array<?x?xf32>>) -> ()714 return715}716 717func.func private @bar_rebox_test_char(!fir.box<!fir.array<?x!fir.char<1,?>>>)718// CHECK-LABEL: @test_rebox_char(719func.func @test_rebox_char(%arg0: !fir.box<!fir.array<?x!fir.char<1,20>>>) {720 %c7_i64 = arith.constant 7 : i64721 %c1_i64 = arith.constant 1 : i64722 %c0 = arith.constant 0 : index723 %c1 = arith.constant 1 : index724 %0:3 = fir.box_dims %arg0, %c0 : (!fir.box<!fir.array<?x!fir.char<1,20>>>, index) -> (index, index, index)725 %1 = fir.slice %c1, %0#1, %c1_i64 substr %c1_i64, %c7_i64 : (index, index, i64, i64, i64) -> !fir.slice<1>726 // CHECK: fir.rebox %{{.*}} [%{{.*}}] : (!fir.box<!fir.array<?x!fir.char<1,20>>>, !fir.slice<1>) -> !fir.box<!fir.array<?x!fir.char<1,?>>>727 %2 = fir.rebox %arg0 [%1] : (!fir.box<!fir.array<?x!fir.char<1,20>>>, !fir.slice<1>) -> !fir.box<!fir.array<?x!fir.char<1,?>>>728 fir.call @bar_rebox_test_char(%2) : (!fir.box<!fir.array<?x!fir.char<1,?>>>) -> ()729 return730}731 732 733func.func private @array_func() -> !fir.array<?x!fir.char<1,?>>734// CHECK-LABEL: @test_save_result(735func.func @test_save_result(%buffer: !fir.ref<!fir.array<?x!fir.char<1,?>>>) {736 %c100 = arith.constant 100 : index737 %c50 = arith.constant 50 : index738 %shape = fir.shape %c100 : (index) -> !fir.shape<1>739 %res = fir.call @array_func() : () -> !fir.array<?x!fir.char<1,?>>740 // CHECK: fir.save_result %{{.*}} to %{{.*}}(%{{.*}}) typeparams %{{.*}} : !fir.array<?x!fir.char<1,?>>, !fir.ref<!fir.array<?x!fir.char<1,?>>>, !fir.shape<1>, index741 fir.save_result %res to %buffer(%shape) typeparams %c50 : !fir.array<?x!fir.char<1,?>>, !fir.ref<!fir.array<?x!fir.char<1,?>>>, !fir.shape<1>, index742 return743}744 745func.func @char_convert() {746 %1 = fir.undefined i32747 %2 = fir.undefined !fir.ref<!fir.char<1>>748 %3 = fir.undefined !fir.ref<!fir.array<?x!fir.char<2,?>>>749 // CHECK: fir.char_convert %{{.*}} for %{{.*}} to %{{.*}} : !fir.ref<!fir.char<1>>, i32, !fir.ref<!fir.array<?x!fir.char<2,?>>>750 fir.char_convert %2 for %1 to %3 : !fir.ref<!fir.char<1>>, i32, !fir.ref<!fir.array<?x!fir.char<2,?>>>751 return752}753 754func.func @slice_substr() {755 %lb = arith.constant 0 : index756 %ub = arith.constant 42 : index757 %c1 = arith.constant 1 : index758 %offset = arith.constant 10 : index759 %0 = fir.slice %lb, %ub, %c1 substr %offset, %c1 : (index, index, index, index, index) -> !fir.slice<1>760 // CHECK: fir.slice %{{.*}}, %{{.*}}, %{{.*}} substr %{{.*}}, %{{.*}} : (index, index, index, index, index) -> !fir.slice<1>761 return762}763 764// Test load, store, coordinate_of with llvmptr type765// CHECK-LABEL: llvm_ptr_load_store_coordinate766// CHECK-SAME: (%[[ARG0:.*]]: !fir.ref<tuple<!fir.ref<!fir.box<!fir.ptr<f32>>>, !fir.ref<!fir.box<!fir.heap<f32>>>>>, %[[ARG1:.*]]: !fir.ref<!fir.box<!fir.ptr<f32>>>)767func.func @llvm_ptr_load_store_coordinate(%arg0: !fir.ref<tuple<!fir.ref<!fir.box<!fir.ptr<f32>>>, !fir.ref<!fir.box<!fir.heap<f32>>>>>, %arg1: !fir.ref<!fir.box<!fir.ptr<f32>>>) -> !fir.ref<!fir.box<!fir.ptr<f32>>> {768 // CHECK-NEXT: %[[C0:.*]] = arith.constant 0 : i32769 %c0_i32 = arith.constant 0 : i32770 // CHECK-NEXT: %[[LLVMPTR:.*]] = fir.coordinate_of %[[ARG0]], %[[C0]] : (!fir.ref<tuple<!fir.ref<!fir.box<!fir.ptr<f32>>>, !fir.ref<!fir.box<!fir.heap<f32>>>>>, i32) -> !fir.llvm_ptr<!fir.ref<!fir.box<!fir.ptr<f32>>>>771 %0 = fir.coordinate_of %arg0, %c0_i32 : (!fir.ref<tuple<!fir.ref<!fir.box<!fir.ptr<f32>>>, !fir.ref<!fir.box<!fir.heap<f32>>>>>, i32) -> !fir.llvm_ptr<!fir.ref<!fir.box<!fir.ptr<f32>>>>772 // CHECK-NEXT: fir.store %[[ARG1]] to %[[LLVMPTR]] : !fir.llvm_ptr<!fir.ref<!fir.box<!fir.ptr<f32>>>>773 fir.store %arg1 to %0 : !fir.llvm_ptr<!fir.ref<!fir.box<!fir.ptr<f32>>>>774 // CHECK-NEXT: fir.load %[[LLVMPTR]] : !fir.llvm_ptr<!fir.ref<!fir.box<!fir.ptr<f32>>>>775 %1 = fir.load %0 : !fir.llvm_ptr<!fir.ref<!fir.box<!fir.ptr<f32>>>>776 return %1 : !fir.ref<!fir.box<!fir.ptr<f32>>>777}778 779func.func @array_access_ops(%a : !fir.ref<!fir.array<?x?xf32>>) {780 %c1 = arith.constant 1 : index781 %n = arith.constant 0 : index782 %m = arith.constant 50 : index783 %s = fir.shape %n, %m : (index, index) -> !fir.shape<2>784 %v = fir.array_load %a(%s) : (!fir.ref<!fir.array<?x?xf32>>, !fir.shape<2>) -> !fir.array<?x?xf32>785 %p = fir.array_access %v, %c1, %c1 : (!fir.array<?x?xf32>, index, index) -> !fir.ref<f32>786 // CHECK: %{{.*}} = fir.array_access %{{.*}}, %{{.*}}, %{{.*}} : (!fir.array<?x?xf32>, index, index) -> !fir.ref<f32>787 return788}789 790func.func @array_amend_ops(%a : !fir.ref<!fir.array<?x?xf32>>) {791 %c1 = arith.constant 1 : index792 %n = arith.constant 0 : index793 %m = arith.constant 50 : index794 %s = fir.shape %n, %m : (index, index) -> !fir.shape<2>795 %v = fir.array_load %a(%s) : (!fir.ref<!fir.array<?x?xf32>>, !fir.shape<2>) -> !fir.array<?x?xf32>796 %p = fir.array_access %v, %c1, %c1 : (!fir.array<?x?xf32>, index, index) -> !fir.ref<f32>797 %res = fir.array_amend %v, %p : (!fir.array<?x?xf32>, !fir.ref<f32>) -> !fir.array<?x?xf32>798 // CHECK: %{{.*}} = fir.array_amend %{{.*}}, %{{.*}} : (!fir.array<?x?xf32>, !fir.ref<f32>) -> !fir.array<?x?xf32>799 return800}801 802func.func private @dispatch(%arg0: !fir.class<!fir.type<dispatch_derived1{a:i32,b:i32}>>, %arg1: i32) -> () {803 // CHECK-LABEL: func.func private @dispatch(804 // CHECK-SAME: %[[CLASS:.*]]: !fir.class<!fir.type<dispatch_derived1{a:i32,b:i32}>>, %[[INTARG:.*]]: i32)805 fir.dispatch "proc1"(%arg0 : !fir.class<!fir.type<dispatch_derived1{a:i32,b:i32}>>) (%arg0 : !fir.class<!fir.type<dispatch_derived1{a:i32,b:i32}>>) {pass_arg_pos = 0 : i32}806 // CHECK: fir.dispatch "proc1"(%[[CLASS]] : !fir.class<!fir.type<dispatch_derived1{a:i32,b:i32}>>) (%[[CLASS]] : !fir.class<!fir.type<dispatch_derived1{a:i32,b:i32}>>) {pass_arg_pos = 0 : i32}807 808 fir.dispatch "proc2"(%arg0 : !fir.class<!fir.type<dispatch_derived1{a:i32,b:i32}>>) proc_attrs<pure>809 // CHECK: fir.dispatch "proc2"(%[[CLASS]] : !fir.class<!fir.type<dispatch_derived1{a:i32,b:i32}>>) proc_attrs <pure>810 811 fir.dispatch "proc3"(%arg0 : !fir.class<!fir.type<dispatch_derived1{a:i32,b:i32}>>) (%arg1, %arg0 : i32, !fir.class<!fir.type<dispatch_derived1{a:i32,b:i32}>>) {pass_arg_pos = 1 : i32}812 // CHECK: fir.dispatch "proc3"(%[[CLASS]] : !fir.class<!fir.type<dispatch_derived1{a:i32,b:i32}>>) (%[[INTARG]], %[[CLASS]] : i32, !fir.class<!fir.type<dispatch_derived1{a:i32,b:i32}>>) {pass_arg_pos = 1 : i32}813 return814}815 816 817// CHECK-LABEL: func.func @embox_tdesc(818// CHECK-SAME: %[[ARG0:.*]]: !fir.class<!fir.array<10x!fir.type<derived_poly{a:i32,b:i32}>>>819func.func @embox_tdesc(%arg0: !fir.class<!fir.array<10x!fir.type<derived_poly{a:i32,b:i32}>>>) {820 %0 = fir.alloca i32821 %c1_i32 = arith.constant 1 : i32822 %1 = fir.convert %c1_i32 : (i32) -> index823 %c10_i32 = arith.constant 10 : i32824 %2 = fir.convert %c10_i32 : (i32) -> index825 %c1 = arith.constant 1 : index826 %3 = fir.convert %1 : (index) -> i32827 %4:2 = fir.do_loop %arg2 = %1 to %2 step %c1 iter_args(%arg3 = %3) -> (index, i32) {828 fir.store %arg3 to %0 : !fir.ref<i32>829 %9 = fir.load %0 : !fir.ref<i32>830 %10 = fir.convert %9 : (i32) -> i64831 %c1_i64 = arith.constant 1 : i64832 %11 = arith.subi %10, %c1_i64 : i64833 %12 = fir.coordinate_of %arg0, %11 : (!fir.class<!fir.array<10x!fir.type<derived_poly{a:i32,b:i32}>>>, i64) -> !fir.ref<!fir.type<derived_poly{a:i32,b:i32}>>834 %13 = fir.embox %12 source_box %arg0 : (!fir.ref<!fir.type<derived_poly{a:i32,b:i32}>>, !fir.class<!fir.array<10x!fir.type<derived_poly{a:i32,b:i32}>>>) -> !fir.class<!fir.type<derived_poly{a:i32,b:i32}>>835 // CHECK: %{{.*}} = fir.embox %{{.*}} source_box %[[ARG0]] : (!fir.ref<!fir.type<derived_poly{a:i32,b:i32}>>, !fir.class<!fir.array<10x!fir.type<derived_poly{a:i32,b:i32}>>>) -> !fir.class<!fir.type<derived_poly{a:i32,b:i32}>>836 %14 = arith.addi %arg2, %c1 : index837 %15 = fir.convert %c1 : (index) -> i32838 %16 = fir.load %0 : !fir.ref<i32>839 %17 = arith.addi %16, %15 : i32840 fir.result %14, %17 : index, i32841 }842 fir.store %4#1 to %0 : !fir.ref<i32>843 return844}845 846// CHECK-LABEL: func.func @embox_with_source_box(847// CHECK-SAME: %[[ARG0:.*]]: !fir.heap<!fir.array<?xnone>>,848// CHECK-SAME: %[[ARG1:.*]]: !fir.shape<1>,849// CHECK-SAME: %[[ARG2:.*]]: !fir.box<!fir.array<?xnone>>) -> !fir.class<!fir.heap<!fir.array<?xnone>>> {850func.func @embox_with_source_box(%arg0: !fir.heap<!fir.array<?xnone>>, %arg1: !fir.shape<1>, %arg2: !fir.box<!fir.array<?xnone>>) -> !fir.class<!fir.heap<!fir.array<?xnone>>> {851// CHECK: %[[VAL_0:.*]] = fir.embox %[[ARG0]](%[[ARG1]]) source_box %[[ARG2]] : (!fir.heap<!fir.array<?xnone>>, !fir.shape<1>, !fir.box<!fir.array<?xnone>>) -> !fir.class<!fir.heap<!fir.array<?xnone>>>852 %0 = fir.embox %arg0(%arg1) source_box %arg2 : (!fir.heap<!fir.array<?xnone>>, !fir.shape<1>, !fir.box<!fir.array<?xnone>>) -> !fir.class<!fir.heap<!fir.array<?xnone>>>853 return %0 : !fir.class<!fir.heap<!fir.array<?xnone>>>854}855 856func.func @test_fortran_var_attrs() {857 %0 = fir.alloca !fir.heap<f32> {fortran_attrs = #fir.var_attrs<allocatable>}858 %1 = fir.alloca f32 {fortran_attrs = #fir.var_attrs<asynchronous>}859 %2 = fir.alloca f32 {fortran_attrs = #fir.var_attrs<bind_c>}860 %3 = fir.alloca f32 {fortran_attrs = #fir.var_attrs<contiguous>}861 %4 = fir.alloca f32 {fortran_attrs = #fir.var_attrs<intent_in>}862 %5 = fir.alloca f32 {fortran_attrs = #fir.var_attrs<intent_inout>}863 %6 = fir.alloca f32 {fortran_attrs = #fir.var_attrs<intent_out>}864 %7 = fir.alloca f32 {fortran_attrs = #fir.var_attrs<optional>}865 %8 = fir.alloca f32 {fortran_attrs = #fir.var_attrs<parameter>}866 %9 = fir.alloca !fir.ptr<f32> {fortran_attrs = #fir.var_attrs<pointer>}867 %10 = fir.alloca f32 {fortran_attrs = #fir.var_attrs<target>}868 %11 = fir.alloca f32 {fortran_attrs = #fir.var_attrs<value>}869 %12 = fir.alloca f32 {fortran_attrs = #fir.var_attrs<volatile>}870 %13 = fir.alloca !fir.box<!fir.ptr<!fir.array<?xf32>>> {fortran_attrs = #fir.var_attrs<pointer, contiguous, volatile>}871 return872 // CHECK: fir.alloca !fir.heap<f32> {fortran_attrs = #fir.var_attrs<allocatable>}873 // CHECK: fir.alloca f32 {fortran_attrs = #fir.var_attrs<asynchronous>}874 // CHECK: fir.alloca f32 {fortran_attrs = #fir.var_attrs<bind_c>}875 // CHECK: fir.alloca f32 {fortran_attrs = #fir.var_attrs<contiguous>}876 // CHECK: fir.alloca f32 {fortran_attrs = #fir.var_attrs<intent_in>}877 // CHECK: fir.alloca f32 {fortran_attrs = #fir.var_attrs<intent_inout>}878 // CHECK: fir.alloca f32 {fortran_attrs = #fir.var_attrs<intent_out>}879 // CHECK: fir.alloca f32 {fortran_attrs = #fir.var_attrs<optional>}880 // CHECK: fir.alloca f32 {fortran_attrs = #fir.var_attrs<parameter>}881 // CHECK: fir.alloca !fir.ptr<f32> {fortran_attrs = #fir.var_attrs<pointer>}882 // CHECK: fir.alloca f32 {fortran_attrs = #fir.var_attrs<target>}883 // CHECK: fir.alloca f32 {fortran_attrs = #fir.var_attrs<value>}884 // CHECK: fir.alloca f32 {fortran_attrs = #fir.var_attrs<volatile>}885 // CHECK: fir.alloca !fir.box<!fir.ptr<!fir.array<?xf32>>> {fortran_attrs = #fir.var_attrs<contiguous, pointer, volatile>}886}887 888func.func @test_box_typecode(%a: !fir.class<none>) {889 %0 = fir.box_typecode %a : (!fir.class<none>) -> i32890 return891}892 893// CHECK-LABEL: func.func @test_box_typecode(894// CHECK-SAME: %[[A:.*]]: !fir.class<none>)895// CHECK: %{{.*}} = fir.box_typecode %[[A]] : (!fir.class<none>) -> i32896 897fir.global @t1 {keep_my_attr = "data"} : i32 {898 %1 = arith.constant 0 : i32899 fir.has_value %1 : i32900}901 902// CHECK-LABEL: fir.global @t1 {keep_my_attr = "data"} : i32903 904func.func @test_rebox_assumed_rank(%arg0: !fir.box<!fir.array<*:f32>> ) {905 %1 = fir.rebox_assumed_rank %arg0 lbs ones : (!fir.box<!fir.array<*:f32>>) -> !fir.box<!fir.array<*:f32>>906 %2 = fir.rebox_assumed_rank %arg0 lbs zeroes : (!fir.box<!fir.array<*:f32>>) -> !fir.box<!fir.array<*:f32>>907 %3 = fir.rebox_assumed_rank %arg0 lbs preserve : (!fir.box<!fir.array<*:f32>>) -> !fir.box<!fir.array<*:f32>>908 return909}910// CHECK-LABEL: func.func @test_rebox_assumed_rank(911// CHECK-SAME: %[[A:.*]]: !fir.box<!fir.array<*:f32>>)912 // CHECK: fir.rebox_assumed_rank %[[A]] lbs ones : (!fir.box<!fir.array<*:f32>>) -> !fir.box<!fir.array<*:f32>>913 // CHECK: fir.rebox_assumed_rank %[[A]] lbs zeroes : (!fir.box<!fir.array<*:f32>>) -> !fir.box<!fir.array<*:f32>>914 // CHECK: fir.rebox_assumed_rank %[[A]] lbs preserve : (!fir.box<!fir.array<*:f32>>) -> !fir.box<!fir.array<*:f32>>915 916func.func @test_is_assumed_size(%arg0: !fir.class<!fir.array<*:none>>, %arg1 : !fir.box<!fir.array<?xf32>>) {917 %1 = fir.is_assumed_size %arg0 : (!fir.class<!fir.array<*:none>>) -> i1918 %2 = fir.is_assumed_size %arg1 : (!fir.box<!fir.array<?xf32>>) -> i1919 return920}921// CHECK-LABEL: func.func @test_is_assumed_size(922// CHECK-SAME: %[[A:.*]]: !fir.class<!fir.array<*:none>>,923// CHECK-SAME: %[[B:.*]]: !fir.box<!fir.array<?xf32>>)924 // CHECK: fir.is_assumed_size %[[A]] : (!fir.class<!fir.array<*:none>>) -> i1925 // CHECK: fir.is_assumed_size %[[B]] : (!fir.box<!fir.array<?xf32>>) -> i1926 927func.func private @somefunc(i32, !fir.ref<i64>)928 929// CHECK-LABEL: @test_call_arg_attrs_direct930// CHECK-SAME: %[[VAL_0:.*]]: i32,931// CHECK-SAME: %[[VAL_1:.*]]: !fir.ref<i64>) {932func.func @test_call_arg_attrs_direct(%arg0: i32, %arg1: !fir.ref<i64>) {933 // CHECK: fir.call @somefunc(%[[VAL_0]], %[[VAL_1]]) : (i32, !fir.ref<i64> {llvm.byval = i64}) -> ()934 fir.call @somefunc(%arg0, %arg1) : (i32, !fir.ref<i64> {llvm.byval = i64}) -> ()935 return936}937 938// CHECK-LABEL: @test_call_arg_attrs_indirect939// CHECK-SAME: %[[VAL_0:.*]]: i16,940// CHECK-SAME: %[[VAL_1:.*]]: (i16) -> i16) -> i16 {941func.func @test_call_arg_attrs_indirect(%arg0: i16, %arg1: (i16)-> i16) -> i16 {942 // CHECK: fir.call %[[VAL_1]](%[[VAL_0]]) : (i16 {llvm.noundef, llvm.signext}) -> (i16 {llvm.signext})943 %0 = fir.call %arg1(%arg0) : (i16 {llvm.noundef, llvm.signext}) -> (i16 {llvm.signext})944 return %0 : i16945}946 947// CHECK-LABEL: @test_copy(948// CHECK-SAME: %[[VAL_0:.*]]: !fir.ref<!fir.type<sometype{i:i32}>>,949// CHECK-SAME: %[[VAL_1:.*]]: !fir.ptr<!fir.type<sometype{i:i32}>>950func.func @test_copy(%arg0: !fir.ref<!fir.type<sometype{i:i32}>>, %arg1: !fir.ptr<!fir.type<sometype{i:i32}>>) {951 // CHECK: fir.copy %[[VAL_0]] to %[[VAL_1]] no_overlap : !fir.ref<!fir.type<sometype{i:i32}>>, !fir.ptr<!fir.type<sometype{i:i32}>>952 fir.copy %arg0 to %arg1 no_overlap : !fir.ref<!fir.type<sometype{i:i32}>>, !fir.ptr<!fir.type<sometype{i:i32}>>953 return954}955 956// CHECK-LABEL: func.func @test_pack_unpack_array(957// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.ref<!fir.box<none>>,958// CHECK-SAME: %[[VAL_1:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.box<!fir.array<?xi32>>) {959func.func @test_pack_unpack_array(%arg0: !fir.ref<!fir.box<none>>, %arg1: !fir.box<!fir.array<?xi32>>) {960// CHECK: %[[VAL_2:.*]] = fir.pack_array %[[VAL_1]] heap whole : (!fir.box<!fir.array<?xi32>>) -> !fir.box<!fir.array<?xi32>>961 %0 = fir.pack_array %arg1 heap whole : (!fir.box<!fir.array<?xi32>>) -> !fir.box<!fir.array<?xi32>>962 %1 = fir.convert %0 : (!fir.box<!fir.array<?xi32>>) -> !fir.box<none>963 fir.store %1 to %arg0 : !fir.ref<!fir.box<none>>964// CHECK: %[[VAL_4:.*]] = fir.pack_array %[[VAL_1]] stack whole : (!fir.box<!fir.array<?xi32>>) -> !fir.box<!fir.array<?xi32>>965 %2 = fir.pack_array %arg1 stack whole : (!fir.box<!fir.array<?xi32>>) -> !fir.box<!fir.array<?xi32>>966 %3 = fir.convert %2 : (!fir.box<!fir.array<?xi32>>) -> !fir.box<none>967 fir.store %3 to %arg0 : !fir.ref<!fir.box<none>>968// CHECK: %[[VAL_6:.*]] = fir.pack_array %[[VAL_1]] heap whole no_copy : (!fir.box<!fir.array<?xi32>>) -> !fir.box<!fir.array<?xi32>>969 %4 = fir.pack_array %arg1 heap whole no_copy constraints {} heuristics <none> : (!fir.box<!fir.array<?xi32>>) -> !fir.box<!fir.array<?xi32>>970 %5 = fir.convert %4 : (!fir.box<!fir.array<?xi32>>) -> !fir.box<none>971 fir.store %5 to %arg0 : !fir.ref<!fir.box<none>>972// CHECK: %[[VAL_8:.*]] = fir.pack_array %[[VAL_1]] stack whole constraints {max_size = 100 : ui64, max_element_size = 1 : ui64, min_stride = 10 : ui64} heuristics <loop_only> : (!fir.box<!fir.array<?xi32>>) -> !fir.box<!fir.array<?xi32>>973 %6 = fir.pack_array %arg1 stack whole constraints {max_size = 100 : ui64, max_element_size = 1 : ui64, min_stride = 10 : ui64} heuristics <loop_only> : (!fir.box<!fir.array<?xi32>>) -> !fir.box<!fir.array<?xi32>>974 %7 = fir.convert %6 : (!fir.box<!fir.array<?xi32>>) -> !fir.box<none>975 fir.store %7 to %arg0 : !fir.ref<!fir.box<none>>976// CHECK: fir.unpack_array %[[VAL_8]] to %[[VAL_1]] stack no_copy : !fir.box<!fir.array<?xi32>>977 fir.unpack_array %6 to %arg1 stack no_copy : !fir.box<!fir.array<?xi32>>978 return979}980 981// Test assumed-length character array packing.982// CHECK-LABEL: func.func @test_pack_array_character(983// CHECK-SAME: %[[VAL_0:[0-9]+|[a-zA-Z$._-][a-zA-Z0-9$._-]*]]: !fir.box<!fir.array<?x!fir.char<1,?>>>) {984func.func @test_pack_array_character(%arg0: !fir.box<!fir.array<?x!fir.char<1,?>>>) {985// CHECK: %[[VAL_1:.*]] = fir.pack_array %[[VAL_0]] heap whole : (!fir.box<!fir.array<?x!fir.char<1,?>>>) -> !fir.box<!fir.array<?x!fir.char<1,?>>>986 %0 = fir.pack_array %arg0 heap whole : (!fir.box<!fir.array<?x!fir.char<1,?>>>) -> !fir.box<!fir.array<?x!fir.char<1,?>>>987// CHECK: fir.unpack_array %[[VAL_1]] to %[[VAL_0]] heap no_copy : !fir.box<!fir.array<?x!fir.char<1,?>>>988 fir.unpack_array %0 to %arg0 heap no_copy : !fir.box<!fir.array<?x!fir.char<1,?>>>989 return990}991 992// CHECK-LABEL: func.func @test_is_contiguous_box(993func.func @test_is_contiguous_box(%arg0: !fir.class<!fir.type<sometype{i:i32}>>, %arg1: !fir.box<!fir.array<?x?xf32>>, %arg2: !fir.box<i32>) -> i1 {994// CHECK: fir.is_contiguous_box %{{.*}} innermost : (!fir.class<!fir.type<sometype{i:i32}>>) -> i1995 %0 = fir.is_contiguous_box %arg0 innermost : (!fir.class<!fir.type<sometype{i:i32}>>) -> i1996// CHECK: fir.is_contiguous_box %{{.*}} whole : (!fir.class<!fir.type<sometype{i:i32}>>) -> i1997 %1 = fir.is_contiguous_box %arg0 whole : (!fir.class<!fir.type<sometype{i:i32}>>) -> i1998// CHECK: fir.is_contiguous_box %{{.*}} innermost : (!fir.box<!fir.array<?x?xf32>>) -> i1999 %2 = fir.is_contiguous_box %arg1 innermost : (!fir.box<!fir.array<?x?xf32>>) -> i11000// CHECK: fir.is_contiguous_box %{{.*}} whole : (!fir.box<!fir.array<?x?xf32>>) -> i11001 %3 = fir.is_contiguous_box %arg1 whole : (!fir.box<!fir.array<?x?xf32>>) -> i11002// CHECK: fir.is_contiguous_box %{{.*}} innermost : (!fir.box<i32>) -> i11003 %4 = fir.is_contiguous_box %arg2 innermost : (!fir.box<i32>) -> i11004// CHECK: fir.is_contiguous_box %{{.*}} whole : (!fir.box<i32>) -> i11005 %5 = fir.is_contiguous_box %arg2 whole : (!fir.box<i32>) -> i11006 %6 = arith.andi %0, %1 : i11007 %7 = arith.andi %2, %3 : i11008 %8 = arith.andi %4, %5 : i11009 %9 = arith.andi %6, %7 : i11010 %10 = arith.andi %8, %9 : i11011 return %10 : i11012}1013 1014// CHECK-LABEL: func.func @test_box_total_elements(1015func.func @test_box_total_elements(%arg0: !fir.class<!fir.type<sometype{i:i32}>>, %arg1: !fir.box<!fir.array<?x?xf32>>, %arg2: !fir.box<i32>) -> index {1016// CHECK: fir.box_total_elements %{{.*}} : (!fir.class<!fir.type<sometype{i:i32}>>) -> i161017 %0 = fir.box_total_elements %arg0 : (!fir.class<!fir.type<sometype{i:i32}>>) -> i161018// CHECK: fir.box_total_elements %{{.*}} : (!fir.box<!fir.array<?x?xf32>>) -> i321019 %1 = fir.box_total_elements %arg1 : (!fir.box<!fir.array<?x?xf32>>) -> i321020// CHECK: fir.box_total_elements %{{.*}} : (!fir.box<i32>) -> index1021 %2 = fir.box_total_elements %arg2 : (!fir.box<i32>) -> index1022 %3 = fir.convert %0 : (i16) -> index1023 %4 = fir.convert %1 : (i32) -> index1024 %5 = arith.addi %3, %4 : index1025 %6 = arith.addi %2, %5 : index1026 return %6 : index1027}1028 1029// CHECK-LABEL: func.func @test_if_weights(1030// CHECK-SAME: %[[ARG0:.*]]: i1) {1031func.func @test_if_weights(%cond: i1) {1032// CHECK: fir.if %[[ARG0]] weights([99, 1]) {1033// CHECK: }1034 fir.if %cond weights([99, 1]) {1035 }1036// CHECK: fir.if %[[ARG0]] weights([99, 1]) {1037// CHECK: } else {1038// CHECK: }1039 fir.if %cond weights ([99,1]) {1040 } else {1041 }1042 return1043}1044