1; RUN: llvm-reduce --abort-on-invalid-reduction --delta-passes=opcodes --test FileCheck --test-arg --check-prefix=ALL --test-arg %s --test-arg --input-file %s -o %t 2; RUN: FileCheck -check-prefixes=RESULT,ALL %s < %t 3 4target datalayout = "A5" 5 6declare token @llvm.return.token() 7declare void @llvm.uses.token(token) 8 9; ALL-LABEL: @call_token( 10; RESULT-NEXT: %token = call token @llvm.return.token() 11; RESULT-NEXT: call void @llvm.uses.token(token %token) 12; RESULT-NEXT: ret void 13define void @call_token() { 14 %token = call token @llvm.return.token() 15 call void @llvm.uses.token(token %token) 16 ret void 17} 18 19; ALL-LABEL: @call_void_0_size_arg( 20; RESULT-NEXT: store volatile {} %arg, ptr addrspace(5) null, align 1 21; RESULT-NEXT: ret void 22define void @call_void_0_size_arg({} %arg) { 23 call void @void_0_size_arg({} %arg) 24 ret void 25} 26 27; ALL-LABEL: @call_return_0_size( 28; RESULT-NEXT: %op = load volatile {}, ptr %ptr, align 1 29; RESULT-NEXT: ret {} %op 30define {} @call_return_0_size(ptr %ptr) { 31 %op = call {} @return_0_size(ptr %ptr) 32 ret {} %op 33} 34 35; ALL-LABEL: define void @call_void_no_args( 36; RESULT-NEXT: store volatile i32 0, ptr addrspace(5) null, align 4 37; RESULT-NEXT: ret void 38define void @call_void_no_args() { 39 call void @void_no_args() 40 ret void 41} 42 43; ALL-LABEL: @call_store_like_i16( 44; RESULT-NEXT: store volatile i16 %val, ptr addrspace(1) %ptr, align 2 45; RESULT-NEXT: ret void 46define void @call_store_like_i16(i16 %val, ptr addrspace(1) %ptr) { 47 call void @store_like_i16(i16 %val, ptr addrspace(1) %ptr) 48 ret void 49} 50 51; ALL-LABEL: @keep_call_store_like_i16( 52; ALL-NEXT: call void @store_like_i16(i16 %val, ptr addrspace(1) %ptr) 53; ALL-NEXT: ret void 54define void @keep_call_store_like_i16(i16 %val, ptr addrspace(1) %ptr) { 55 call void @store_like_i16(i16 %val, ptr addrspace(1) %ptr) 56 ret void 57} 58 59; ALL-LABEL: @call_store_like_i16_swap( 60; RESULT-NEXT: store volatile i16 %val, ptr addrspace(1) %ptr 61; RESULT-NEXT: ret void 62define void @call_store_like_i16_swap(ptr addrspace(1) %ptr, i16 %val) { 63 call void @store_like_i16_swap(ptr addrspace(1) %ptr, i16 %val) 64 ret void 65} 66 67; ALL-LABEL: @call_store_like_i16_extra_arg( 68; RESULT-NEXT: call void @store_like_i16_extra_arg(i16 %val, ptr addrspace(1) %ptr, i32 %extra) 69; RESULT-NEXT: ret void 70define void @call_store_like_i16_extra_arg(i16 %val, ptr addrspace(1) %ptr, i32 %extra) { 71 call void @store_like_i16_extra_arg(i16 %val, ptr addrspace(1) %ptr, i32 %extra) 72 ret void 73} 74 75; ALL-LABEL: @call_store_like_i16_extra_ptr_arg( 76; RESULT-NEXT: call void @store_like_i16_extra_ptr_arg(i16 %val, ptr addrspace(1) %ptr, ptr addrspace(1) %extra) 77; RESULT-NEXT: ret void 78define void @call_store_like_i16_extra_ptr_arg(i16 %val, ptr addrspace(1) %ptr, ptr addrspace(1) %extra) { 79 call void @store_like_i16_extra_ptr_arg(i16 %val, ptr addrspace(1) %ptr, ptr addrspace(1) %extra) 80 ret void 81} 82 83; ALL-LABEL: @call_store_like_ptr_store( 84; RESULT-NEXT: store volatile ptr addrspace(1) %ptr, ptr addrspace(3) %ptr.val, align 8 85; RESULT-NEXT: ret void 86define void @call_store_like_ptr_store(ptr addrspace(3) %ptr.val, ptr addrspace(1) %ptr) { 87 call void @store_like_ptr_store(ptr addrspace(3) %ptr.val, ptr addrspace(1) %ptr) 88 ret void 89} 90 91; ALL-LABEL: @call_store_like_ptr_store_swap( 92; RESULT-NEXT: store volatile ptr addrspace(3) %ptr.val, ptr addrspace(1) %ptr, align 8 93; RESULT-NEXT: ret void 94define void @call_store_like_ptr_store_swap(ptr addrspace(1) %ptr, ptr addrspace(3) %ptr.val) { 95 call void @store_like_ptr_store_swap(ptr addrspace(1) %ptr, ptr addrspace(3) %ptr.val) 96 ret void 97} 98 99; ALL-LABEL: @call_store_like_ptr_store_different_element_type( 100; RESULT-NEXT: store volatile ptr addrspace(1) %ptr, ptr addrspace(3) %ptr.val, align 8 101; RESULT-NEXT: ret void 102define void @call_store_like_ptr_store_different_element_type(ptr addrspace(3) %ptr.val, ptr addrspace(1) %ptr) { 103 call void @store_like_ptr_store_different_element_type(ptr addrspace(3) %ptr.val, ptr addrspace(1) %ptr) 104 ret void 105} 106 107; ALL-LABEL: @call_store_like_ptr_store_different_element_type_swap( 108; RESULT-NEXT: store volatile ptr addrspace(3) %ptr.val, ptr addrspace(1) %ptr, align 8 109; RESULT-NEXT: ret void 110define void @call_store_like_ptr_store_different_element_type_swap(ptr addrspace(1) %ptr, ptr addrspace(3) %ptr.val) { 111 call void @store_like_ptr_store_different_element_type_swap(ptr addrspace(1) %ptr, ptr addrspace(3) %ptr.val) 112 ret void 113} 114 115; ALL-LABEL: @call_load_like_i32( 116; RESULT-NEXT: %op = load volatile i32, ptr addrspace(1) %ptr, align 4 117; RESULT-NEXT: ret i32 %op 118define i32 @call_load_like_i32(ptr addrspace(1) %ptr) { 119 %op = call i32 @load_like_i32(ptr addrspace(1) %ptr) 120 ret i32 %op 121} 122 123; ALL-LABEL: @keep_call_load_like_i32( 124; ALL-NEXT: %op = call i32 @load_like_i32(ptr addrspace(1) %ptr) 125; ALL-NEXT: ret i32 %op 126define i32 @keep_call_load_like_i32(ptr addrspace(1) %ptr) { 127 %op = call i32 @load_like_i32(ptr addrspace(1) %ptr) 128 ret i32 %op 129} 130 131; ALL-LABEL: @call_load_like_i32_extra_arg( 132; RESULT-NEXT: %op = call i32 @load_like_i32_extra_arg(ptr addrspace(1) %ptr, i32 %extra) 133; RESULT-NEXT: ret i32 %op 134define i32 @call_load_like_i32_extra_arg(ptr addrspace(1) %ptr, i32 %extra) { 135 %op = call i32 @load_like_i32_extra_arg(ptr addrspace(1) %ptr, i32 %extra) 136 ret i32 %op 137} 138 139; ALL-LABEL: @call_load_like_ptr_mismatch( 140; RESULT-NEXT: %op = load volatile i32, ptr addrspace(1) %ptr, align 4 141; RESULT-NEXT: ret i32 %op 142define i32 @call_load_like_ptr_mismatch(ptr addrspace(1) %ptr) { 143 %op = call i32 @load_like_ptr_mismatch(ptr addrspace(1) %ptr) 144 ret i32 %op 145} 146 147; ALL-LABEL: @call_load_like_skip_arg( 148; RESULT-NEXT: %op = load volatile i32, ptr addrspace(1) %ptr, align 4 149; RESULT-NEXT: ret i32 %op 150define i32 @call_load_like_skip_arg(float, ptr addrspace(1) %ptr) { 151 %op = call i32 @load_like_skip_arg(float poison, ptr addrspace(1) %ptr) 152 ret i32 %op 153} 154 155; ALL-LABEL: @call_fp_scalar_noargs( 156; RESULT-NEXT: %op = load volatile float, ptr addrspace(5) null, align 4 157; RESULT-NEXT: ret float %op 158define float @call_fp_scalar_noargs() { 159 %op = call nsz float @fp_scalar_noargs() 160 ret float %op 161} 162 163; ALL-LABEL: @call_fp_vector_noargs( 164; RESULT-NEXT: %op = load volatile <2 x half>, ptr addrspace(5) null, align 4 165; RESULT-NEXT: ret <2 x half> %op 166define <2 x half> @call_fp_vector_noargs() { 167 %op = call nsz <2 x half> @fp_vector_noargs() 168 ret <2 x half> %op 169} 170 171; ALL-LABEL: @call_unary_fp_scalar( 172; RESULT-NEXT: %op = fneg nsz float %a 173; RESULT-NEXT: ret float %op 174define float @call_unary_fp_scalar(float %a) { 175 %op = call nsz float @unary_fp_scalar(float %a) 176 ret float %op 177} 178 179; ALL-LABEL: @call_unary_fp_vector( 180; RESULT-NEXT: %op = fneg nsz <2 x half> %a 181; RESULT-NEXT: ret <2 x half> %op 182define <2 x half> @call_unary_fp_vector(<2 x half> %a) { 183 %op = call nsz <2 x half> @unary_fp_vector(<2 x half> %a) 184 ret <2 x half> %op 185} 186 187; ALL-LABEL: @ignore_undef_args_unary_fp( 188; RESULT-NEXT: %op = fneg nnan float %a 189; RESULT-NEXT: ret float %op 190define float @ignore_undef_args_unary_fp(float %a) { 191 %op = call nnan float @func_i32_f32_i32(i32 poison, float %a, i32 poison) 192 ret float %op 193} 194 195; ALL-LABEL: @call_binary_fp_scalar( 196; RESULT: %op = fmul afn float %a, %b 197; RESULT-NEXT: ret float %op 198define float @call_binary_fp_scalar(float %a, float %b) { 199 %op = call afn float @binary_fp_scalar(float %a, float %b) 200 ret float %op 201} 202 203; ALL-LABEL: @call_binary_fp_vector( 204; RESULT-NEXT: %op = fmul afn <2 x half> %a, %b 205; RESULT-NEXT: ret <2 x half> %op 206define <2 x half> @call_binary_fp_vector(<2 x half> %a, <2 x half> %b) { 207 %op = call afn <2 x half> @binary_fp_vector(<2 x half> %a, <2 x half> %b) 208 ret <2 x half> %op 209} 210 211; ALL-LABEL: @call_ternary_fp_scalar( 212; RESULT-NEXT: %op = call afn float @llvm.fma.f32(float %a, float %b, float %c) 213; RESULT-NEXT: ret float %op 214define float @call_ternary_fp_scalar(float %a, float %b, float %c) { 215 %op = call afn float @ternary_fp_scalar(float %a, float %b, float %c) 216 ret float %op 217} 218 219; ALL-LABEL: @call_ternary_fp_vector( 220; RESULT-NEXT: %op = call afn <2 x half> @llvm.fma.v2f16(<2 x half> %a, <2 x half> %b, <2 x half> %c) 221; RESULT-NEXT: ret <2 x half> %op 222define <2 x half> @call_ternary_fp_vector(<2 x half> %a, <2 x half> %b, <2 x half> %c) { 223 %op = call afn <2 x half> @ternary_fp_vector(<2 x half> %a, <2 x half> %b, <2 x half> %c) 224 ret <2 x half> %op 225} 226 227; ALL-LABEL: @call_unary_int_scalar( 228; RESULT-NEXT: %op = call i32 @llvm.bswap.i32(i32 %a) 229; RESULT-NEXT: ret i32 %op 230define i32 @call_unary_int_scalar(i32 %a) { 231 %op = call i32 @unary_int_scalar(i32 %a) 232 ret i32 %op 233} 234 235; ALL-LABEL: @call_unary_int_vector( 236; RESULT-NEXT: %op = call <2 x i16> @llvm.bswap.v2i16(<2 x i16> %a) 237; RESULT-NEXT: ret <2 x i16> %op 238define <2 x i16> @call_unary_int_vector(<2 x i16> %a) { 239 %op = call <2 x i16> @unary_int_vector(<2 x i16> %a) 240 ret <2 x i16> %op 241} 242 243; ALL-LABEL: @call_binary_int_scalar( 244; RESULT-NEXT: %op = and i32 %a, %b 245; RESULT-NEXT: ret i32 %op 246define i32 @call_binary_int_scalar(i32 %a, i32 %b) { 247 %op = call i32 @binary_int_scalar(i32 %a, i32 %b) 248 ret i32 %op 249} 250 251; ALL-LABEL: @call_binary_int_vector( 252; RESULT-NEXT: %op = and <2 x i16> %a, %b 253; RESULT-NEXT: ret <2 x i16> %op 254define <2 x i16> @call_binary_int_vector(<2 x i16> %a, <2 x i16> %b) { 255 %op = call <2 x i16> @binary_int_vector(<2 x i16> %a, <2 x i16> %b) 256 ret <2 x i16> %op 257} 258 259; ALL-LABEL: @call_ternary_int_scalar( 260; RESULT-NEXT: %op = call i32 @llvm.fshl.i32(i32 %a, i32 %b, i32 %c) 261; RESULT-NEXT: ret i32 %op 262define i32 @call_ternary_int_scalar(i32 %a, i32 %b, i32 %c) { 263 %op = call i32 @ternary_int_scalar(i32 %a, i32 %b, i32 %c) 264 ret i32 %op 265} 266 267; ALL-LABEL: @call_ternary_int_vector( 268; RESULT-NEXT: %op = call <2 x i16> @llvm.fshl.v2i16(<2 x i16> %a, <2 x i16> %b, <2 x i16> %c) 269; RESULT-NEXT: ret <2 x i16> %op 270define <2 x i16> @call_ternary_int_vector(<2 x i16> %a, <2 x i16> %b, <2 x i16> %c) { 271 %op = call <2 x i16> @ternary_int_vector(<2 x i16> %a, <2 x i16> %b, <2 x i16> %c) 272 ret <2 x i16> %op 273} 274 275; ALL-LABEL: @call_quaternary_int_scalar( 276; RESULT-NEXT: %op = call i32 @quaternary_int_scalar(i32 %a, i32 %b, i32 %c, i32 %d) 277; RESULT-NEXT: ret i32 %op 278define i32 @call_quaternary_int_scalar(i32 %a, i32 %b, i32 %c, i32 %d) { 279 %op = call i32 @quaternary_int_scalar(i32 %a, i32 %b, i32 %c, i32 %d) 280 ret i32 %op 281} 282 283; ALL-LABEL: @call_quaternary_int_vector( 284; RESULT-NEXT: %op = call <2 x i16> @quaternary_int_vector(<2 x i16> %a, <2 x i16> %b, <2 x i16> %c, <2 x i16> %d) 285; RESULT-NEXT: ret <2 x i16> %op 286define <2 x i16> @call_quaternary_int_vector(<2 x i16> %a, <2 x i16> %b, <2 x i16> %c, <2 x i16> %d) { 287 %op = call <2 x i16> @quaternary_int_vector(<2 x i16> %a, <2 x i16> %b, <2 x i16> %c, <2 x i16> %d) 288 ret <2 x i16> %op 289} 290 291declare void @void_0_size_arg({}) 292declare {} @return_0_size(ptr) 293declare void @void_no_args() 294declare void @store_like_i16(i16, ptr addrspace(1)) 295declare void @store_like_i16_swap(ptr addrspace(1), i16) 296declare void @store_like_i16_extra_arg(i16, ptr addrspace(1), i32) 297declare void @store_like_i16_extra_ptr_arg(i16, ptr addrspace(1), ptr addrspace(1)) 298declare void @store_like_ptr_store(ptr addrspace(3), ptr addrspace(1)) 299declare void @store_like_ptr_store_swap(ptr addrspace(1), ptr addrspace(3)) 300declare void @store_like_ptr_store_different_element_type(ptr addrspace(3), ptr addrspace(1)) 301declare void @store_like_ptr_store_different_element_type_swap(ptr addrspace(1), ptr addrspace(3)) 302declare i32 @load_like_i32(ptr addrspace(1)) 303 304declare i32 @load_like_i32_extra_arg(ptr addrspace(1), i32) 305 306declare i32 @load_like_ptr_mismatch(ptr addrspace(1)) 307declare i32 @load_like_skip_arg(float, ptr addrspace(1)) 308 309declare float @fp_scalar_noargs() 310declare i32 @int_scalar_noargs() 311 312declare <2 x half> @fp_vector_noargs() 313declare <2 x i16> @int_vector_noargs() 314 315declare float @unary_fp_scalar(float) 316declare <2 x half> @unary_fp_vector(<2 x half>) 317declare float @func_i32_f32_i32(i32, float, i32) 318 319declare float @binary_fp_scalar(float, float) 320declare <2 x half> @binary_fp_vector(<2 x half>, <2 x half>) 321 322declare float @ternary_fp_scalar(float, float, float) 323declare <2 x half> @ternary_fp_vector(<2 x half>, <2 x half>, <2 x half>) 324 325declare float @quaternary_fp_scalar(float, float, float, float) 326declare <2 x half> @quaternary_fp_vector(<2 x half>, <2 x half>, <2 x half>, <2 x half>) 327 328declare i32 @unary_int_scalar(i32) 329declare <2 x i16> @unary_int_vector(<2 x i16>) 330declare i32 @binary_int_scalar(i32, i32) 331declare <2 x i16> @binary_int_vector(<2 x i16>, <2 x i16>) 332declare i32 @ternary_int_scalar(i32, i32, i32) 333declare <2 x i16> @ternary_int_vector(<2 x i16>, <2 x i16>, <2 x i16>) 334declare i32 @quaternary_int_scalar(i32, i32, i32, i32) 335declare <2 x i16> @quaternary_int_vector(<2 x i16>, <2 x i16>, <2 x i16>, <2 x i16>) 336