277 lines · plain
1; RUN: mlir-translate -import-llvm -split-input-file %s | FileCheck %s2 3; CHECK-LABEL: @int_constants4define void @int_constants(i16 %arg0, i32 %arg1, i1 %arg2) {5 ; CHECK: %[[C0:.+]] = llvm.mlir.constant(42 : i16) : i166 ; CHECK: %[[C1:.+]] = llvm.mlir.constant(7 : i32) : i327 ; CHECK: %[[C2:.+]] = llvm.mlir.constant(true) : i18 9 ; CHECK: llvm.add %[[C0]], %{{.*}} : i1610 %1 = add i16 42, %arg011 ; CHECK: llvm.add %[[C1]], %{{.*}} : i3212 %2 = add i32 7, %arg113 ; CHECK: llvm.or %[[C2]], %{{.*}} : i114 %3 = or i1 1, %arg215 ret void16}17 18; // -----19 20; CHECK-LABEL: @float_constants21define void @float_constants(half %arg0, bfloat %arg1, fp128 %arg2, x86_fp80 %arg3) {22 ; CHECK: %[[C0:.+]] = llvm.mlir.constant(1.000000e+00 : f16) : f1623 ; CHECK: %[[C1:.+]] = llvm.mlir.constant(1.000000e+00 : bf16) : bf1624 ; CHECK: %[[C2:.+]] = llvm.mlir.constant(0.000000e+00 : f128) : f12825 ; CHECK: %[[C3:.+]] = llvm.mlir.constant(7.000000e+00 : f80) : f8026 27 ; CHECK: llvm.fadd %[[C0]], %{{.*}} : f1628 %1 = fadd half 1.0, %arg029 ; CHECK: llvm.fadd %[[C1]], %{{.*}} : bf1630 %2 = fadd bfloat 1.0, %arg131 ; CHECK: llvm.fadd %[[C2]], %{{.*}} : f12832 %3 = fadd fp128 0xL00000000000000000000000000000000, %arg233 ; CHECK: llvm.fadd %[[C3]], %{{.*}} : f8034 %4 = fadd x86_fp80 0xK4001E000000000000000, %arg335 ret void36}37 38; // -----39 40; CHECK-LABEL: @undef_constant41define void @undef_constant(i32 %arg0) {42 ; CHECK: %[[UNDEF:.+]] = llvm.mlir.undef : i3243 ; CHECK: llvm.add %[[UNDEF]], %{{.*}} : i3244 %1 = add i32 undef, %arg045 ret void46}47 48; // -----49 50; CHECK-LABEL: @poison_constant51define void @poison_constant(double %arg0) {52 ; CHECK: %[[POISON:.+]] = llvm.mlir.poison : f6453 ; CHECK: llvm.fadd %[[POISON]], %{{.*}} : f6454 %1 = fadd double poison, %arg055 ret void56}57 58; // -----59 60; CHECK-LABEL: @null_constant61define ptr @null_constant() {62 ; CHECK: %[[NULL:[0-9]+]] = llvm.mlir.zero : !llvm.ptr63 ; CHECK: llvm.return %[[NULL]] : !llvm.ptr64 ret ptr null65}66 67; // -----68 69@global = external global i32, align 870 71; CHECK-LABEL: @gep_const_expr72define ptr @gep_const_expr() {73 ; CHECK-DAG: %[[ADDR:[0-9]+]] = llvm.mlir.addressof @global : !llvm.ptr74 ; CHECK-DAG: %[[IDX:[0-9]+]] = llvm.mlir.constant(2 : i32) : i3275 ; CHECK-DAG: %[[GEP:[0-9]+]] = llvm.getelementptr %[[ADDR]][%[[IDX]]] : (!llvm.ptr, i32) -> !llvm.ptr76 ; CHECK-DAG: llvm.return %[[GEP]] : !llvm.ptr77 ret ptr getelementptr (i32, ptr @global, i32 2)78}79 80; // -----81 82@global = external global i32, align 883 84; CHECK-LABEL: @const_expr_with_duplicate85define i64 @const_expr_with_duplicate() {86 ; CHECK-DAG: %[[ADDR:[0-9]+]] = llvm.mlir.addressof @global : !llvm.ptr87 ; CHECK-DAG: %[[IDX:[0-9]+]] = llvm.mlir.constant(7 : i32) : i3288 ; CHECK-DAG: %[[GEP:[0-9]+]] = llvm.getelementptr %[[ADDR]][%[[IDX]]] : (!llvm.ptr, i32) -> !llvm.ptr89 ; CHECK-DAG: %[[DUP:[0-9]+]] = llvm.ptrtoint %[[GEP]] : !llvm.ptr to i6490 91 ; Verify the duplicate sub expression is converted only once.92 ; CHECK-DAG: %[[SUM:[0-9]+]] = llvm.add %[[DUP]], %[[DUP]] : i6493 ; CHECK-DAG: llvm.return %[[SUM]] : i6494 ret i64 add (i64 ptrtoint (ptr getelementptr (i32, ptr @global, i32 7) to i64),95 i64 ptrtoint (ptr getelementptr (i32, ptr @global, i32 7) to i64))96}97 98; // -----99 100@global = external global i32, align 8101 102; CHECK-LABEL: @const_expr_with_aggregate()103define i64 @const_expr_with_aggregate() {104 ; Compute the vector elements.105 ; CHECK-DAG: %[[VAL1:[0-9]+]] = llvm.mlir.constant(33 : i64) : i64106 ; CHECK-DAG: %[[ADDR:[0-9]+]] = llvm.mlir.addressof @global : !llvm.ptr107 ; CHECK-DAG: %[[IDX1:[0-9]+]] = llvm.mlir.constant(7 : i32) : i32108 ; CHECK-DAG: %[[GEP1:[0-9]+]] = llvm.getelementptr %[[ADDR]][%[[IDX1]]] : (!llvm.ptr, i32) -> !llvm.ptr109 ; CHECK-DAG: %[[VAL2:[0-9]+]] = llvm.ptrtoint %[[GEP1]] : !llvm.ptr to i64110 111 ; Fill the vector.112 ; CHECK-DAG: %[[VEC1:[0-9]+]] = llvm.mlir.undef : vector<2xi64>113 ; CHECK-DAG: %[[IDX2:[0-9]+]] = llvm.mlir.constant(0 : i32) : i32114 ; CHECK-DAG: %[[VEC2:[0-9]+]] = llvm.insertelement %[[VAL1]], %[[VEC1]][%[[IDX2]] : i32] : vector<2xi64>115 ; CHECK-DAG: %[[IDX3:[0-9]+]] = llvm.mlir.constant(1 : i32) : i32116 ; CHECK-DAG: %[[VEC3:[0-9]+]] = llvm.insertelement %[[VAL2]], %[[VEC2]][%[[IDX3]] : i32] : vector<2xi64>117 ; CHECK-DAG: %[[IDX4:[0-9]+]] = llvm.mlir.constant(42 : i32) : i32118 119 ; Compute the extract index.120 ; CHECK-DAG: %[[GEP2:[0-9]+]] = llvm.getelementptr %[[ADDR]][%[[IDX4]]] : (!llvm.ptr, i32) -> !llvm.ptr121 ; CHECK-DAG: %[[IDX5:[0-9]+]] = llvm.ptrtoint %[[GEP2]] : !llvm.ptr to i64122 123 ; Extract the vector element.124 ; CHECK-DAG: %[[ELEM:[0-9]+]] = llvm.extractelement %[[VEC3]][%[[IDX5]] : i64] : vector<2xi64>125 ; CHECK-DAG: llvm.return %[[ELEM]] : i64126 ret i64 extractelement (127 <2 x i64> <i64 33, i64 ptrtoint (ptr getelementptr (i32, ptr @global, i32 7) to i64)>,128 i64 ptrtoint (ptr getelementptr (i32, ptr @global, i32 42) to i64))129}130 131; // -----132 133; Verify the function constant import.134 135; Calling a function that has not been defined yet.136; CHECK-LABEL: @function_address_before_def137define i32 @function_address_before_def() {138 %1 = alloca ptr139 ; CHECK: %[[FUN:.*]] = llvm.mlir.addressof @callee : !llvm.ptr140 ; CHECK: llvm.store %[[FUN]], %[[PTR:.*]] : !llvm.ptr, !llvm.ptr141 store ptr @callee, ptr %1142 ; CHECK: %[[INDIR:.*]] = llvm.load %[[PTR]] : !llvm.ptr -> !llvm.ptr143 %2 = load ptr, ptr %1144 ; CHECK: llvm.call %[[INDIR]]() : !llvm.ptr, () -> i32145 %3 = call i32 %2()146 ret i32 %3147}148 149define i32 @callee() {150 ret i32 42151}152 153; Calling a function that has been defined.154; CHECK-LABEL: @function_address_after_def155define i32 @function_address_after_def() {156 %1 = alloca ptr157 ; CHECK: %[[FUN:.*]] = llvm.mlir.addressof @callee : !llvm.ptr158 ; CHECK: llvm.store %[[FUN]], %[[PTR:.*]] : !llvm.ptr, !llvm.ptr159 store ptr @callee, ptr %1160 ; CHECK: %[[INDIR:.*]] = llvm.load %[[PTR]] : !llvm.ptr -> !llvm.ptr161 %2 = load ptr, ptr %1162 ; CHECK: llvm.call %[[INDIR]]() : !llvm.ptr, () -> i32163 %3 = call i32 %2()164 ret i32 %3165}166 167; // -----168 169; Verify the aggregate constant import.170 171; CHECK-DAG: %[[C0:.+]] = llvm.mlir.constant(9 : i32) : i32172; CHECK-DAG: %[[C1:.+]] = llvm.mlir.constant(4 : i8) : i8173; CHECK-DAG: %[[C2:.+]] = llvm.mlir.constant(8 : i16) : i16174; CHECK-DAG: %[[C3:.+]] = llvm.mlir.constant(7 : i32) : i32175; CHECK-DAG: %[[ROOT:.+]] = llvm.mlir.undef : !llvm.struct<"simple_agg_type", (i32, i8, i16, i32)>176; CHECK-DAG: %[[CHAIN0:.+]] = llvm.insertvalue %[[C0]], %[[ROOT]][0]177; CHECK-DAG: %[[CHAIN1:.+]] = llvm.insertvalue %[[C1]], %[[CHAIN0]][1]178; CHECK-DAG: %[[CHAIN2:.+]] = llvm.insertvalue %[[C2]], %[[CHAIN1]][2]179; CHECK-DAG: %[[CHAIN3:.+]] = llvm.insertvalue %[[C3]], %[[CHAIN2]][3]180; CHECK-DAG: llvm.return %[[CHAIN3]]181%simple_agg_type = type {i32, i8, i16, i32}182@simple_agg = global %simple_agg_type {i32 9, i8 4, i16 8, i32 7}183 184; CHECK-DAG: %[[C1:.+]] = llvm.mlir.constant(1 : i32) : i32185; CHECK-DAG: %[[C2:.+]] = llvm.mlir.constant(2 : i8) : i8186; CHECK-DAG: %[[C3:.+]] = llvm.mlir.constant(3 : i16) : i16187; CHECK-DAG: %[[C4:.+]] = llvm.mlir.constant(4 : i32) : i32188; CHECK-DAG: %[[NESTED:.+]] = llvm.mlir.undef : !llvm.struct<"simple_agg_type", (i32, i8, i16, i32)>189; CHECK-DAG: %[[CHAIN0:.+]] = llvm.insertvalue %[[C1]], %[[NESTED]][0]190; CHECK-DAG: %[[CHAIN1:.+]] = llvm.insertvalue %[[C2]], %[[CHAIN0]][1]191; CHECK-DAG: %[[CHAIN2:.+]] = llvm.insertvalue %[[C3]], %[[CHAIN1]][2]192; CHECK-DAG: %[[CHAIN3:.+]] = llvm.insertvalue %[[C4]], %[[CHAIN2]][3]193; CHECK-DAG: %[[NULL:.+]] = llvm.mlir.zero : !llvm.ptr194; CHECK-DAG: %[[ROOT:.+]] = llvm.mlir.undef : !llvm.struct<"nested_agg_type", (struct<"simple_agg_type", (i32, i8, i16, i32)>, ptr)>195; CHECK-DAG: %[[CHAIN4:.+]] = llvm.insertvalue %[[CHAIN3]], %[[ROOT]][0]196; CHECK-DAG: %[[CHAIN5:.+]] = llvm.insertvalue %[[NULL]], %[[CHAIN4]][1]197; CHECK-DAG: llvm.return %[[CHAIN5]]198%nested_agg_type = type {%simple_agg_type, ptr}199@nested_agg = global %nested_agg_type { %simple_agg_type{i32 1, i8 2, i16 3, i32 4}, ptr null }200 201; CHECK-DAG: %[[NULL:.+]] = llvm.mlir.zero : !llvm.ptr202; CHECK-DAG: %[[ROOT:.+]] = llvm.mlir.undef : vector<2x!llvm.ptr>203; CHECK-DAG: %[[P0:.+]] = llvm.mlir.constant(0 : i32) : i32204; CHECK-DAG: %[[CHAIN0:.+]] = llvm.insertelement %[[NULL]], %[[ROOT]][%[[P0]] : i32] : vector<2x!llvm.ptr>205; CHECK-DAG: %[[P1:.+]] = llvm.mlir.constant(1 : i32) : i32206; CHECK-DAG: %[[CHAIN1:.+]] = llvm.insertelement %[[NULL]], %[[CHAIN0]][%[[P1]] : i32] : vector<2x!llvm.ptr>207; CHECK-DAG: llvm.return %[[CHAIN1]] : vector<2x!llvm.ptr>208@vector_agg = global <2 x ptr> <ptr null, ptr null>209 210; // -----211 212; Verfiy the import of subsequent constant expressions with duplicates.213 214@global = external global i32, align 8215 216; CHECK-LABEL: @const_exprs_with_duplicate217define i64 @const_exprs_with_duplicate() {218 ; CHECK: %[[ADDR:.+]] = llvm.mlir.addressof @global : !llvm.ptr219 ; CHECK: llvm.getelementptr %[[ADDR]][%{{.*}}] : (!llvm.ptr, i32) -> !llvm.ptr220 %1 = add i64 1, ptrtoint (ptr getelementptr (i32, ptr @global, i32 7) to i64)221 222 ; Verify the address value is reused.223 ; CHECK: llvm.getelementptr %[[ADDR]][%{{.*}}] : (!llvm.ptr, i32) -> !llvm.ptr224 %2 = add i64 %1, ptrtoint (ptr getelementptr (i32, ptr @global, i32 42) to i64)225 ret i64 %2226}227 228; // -----229 230; Verify the import of constant expressions with cyclic dependencies.231 232@cyclic = internal constant i64 add (i64 ptrtoint (ptr @cyclic to i64), i64 ptrtoint (ptr @cyclic to i64))233 234; CHECK-LABEL: @cyclic235; CHECK: %[[ADDR:.+]] = llvm.mlir.addressof @cyclic236; CHECK: %[[VAL0:.+]] = llvm.ptrtoint %[[ADDR]]237; CHECK: %[[VAL1:.+]] = llvm.add %[[VAL0]], %[[VAL0]]238; CHECK: llvm.return %[[VAL1]]239 240; // -----241 242declare void @extern_func()243@const = dso_local constant i32 trunc (i64 sub (i64 ptrtoint (ptr dso_local_equivalent @extern_func to i64), i64 ptrtoint (ptr @const to i64)) to i32)244 245; CHECK: llvm.mlir.global external constant @const()246; CHECK: %[[ADDR:.+]] = llvm.mlir.addressof @const : !llvm.ptr247; CHECK: llvm.ptrtoint %[[ADDR]] : !llvm.ptr to i64248; CHECK: llvm.dso_local_equivalent @extern_func : !llvm.ptr249 250; // -----251 252declare i32 @extern_func()253 254define void @call_extern_func() {255 call noundef i32 dso_local_equivalent @extern_func()256 ret void257}258 259; CHECK-LABEL: @call_extern_func()260; CHECK: %[[DSO_EQ:.+]] = llvm.dso_local_equivalent @extern_func : !llvm.ptr261; CHECK: llvm.call %[[DSO_EQ]]() : !llvm.ptr, () -> (i32 {llvm.noundef})262 263; // -----264 265define void @aliasee_func() {266 ret void267}268 269@alias_func = alias void (), ptr @aliasee_func270define void @call_alias_func() {271 call void dso_local_equivalent @alias_func()272 ret void273}274 275; CHECK-LABEL: @call_alias_func()276; CHECK: llvm.dso_local_equivalent @alias_func : !llvm.ptr277