1; NOTE: Assertions have been autogenerated by utils/update_test_checks.py 2; RUN: opt < %s -instcombine -S | FileCheck %s 3 4target datalayout = "e-p:64:64-p1:16:16-p2:32:32:32-p3:64:64:64" 5 6%intstruct = type { i32 } 7%pair = type { i32, i32 } 8%struct.B = type { double } 9%struct.A = type { %struct.B, i32, i32 } 10%struct.C = type { [7 x i8] } 11 12 13@Global = external global [10 x i8] 14@Global_as1 = external addrspace(1) global [10 x i8] 15 16; Test noop elimination 17define i32* @test1(i32* %I) { 18; CHECK-LABEL: @test1( 19; CHECK-NEXT: ret i32* [[I:%.*]] 20; 21 %A = getelementptr i32, i32* %I, i64 0 22 ret i32* %A 23} 24 25define i32 addrspace(1)* @test1_as1(i32 addrspace(1)* %I) { 26; CHECK-LABEL: @test1_as1( 27; CHECK-NEXT: ret i32 addrspace(1)* [[I:%.*]] 28; 29 %A = getelementptr i32, i32 addrspace(1)* %I, i64 0 30 ret i32 addrspace(1)* %A 31} 32 33; Test noop elimination 34define i32* @test2(i32* %I) { 35; CHECK-LABEL: @test2( 36; CHECK-NEXT: ret i32* [[I:%.*]] 37; 38 %A = getelementptr i32, i32* %I 39 ret i32* %A 40} 41 42; Test that two array indexing geps fold 43define i32* @test3(i32* %I) { 44; CHECK-LABEL: @test3( 45; CHECK-NEXT: [[B:%.*]] = getelementptr i32, i32* [[I:%.*]], i64 21 46; CHECK-NEXT: ret i32* [[B]] 47; 48 %A = getelementptr i32, i32* %I, i64 17 49 %B = getelementptr i32, i32* %A, i64 4 50 ret i32* %B 51} 52 53; Test that two getelementptr insts fold 54define i32* @test4({ i32 }* %I) { 55; CHECK-LABEL: @test4( 56; CHECK-NEXT: [[B:%.*]] = getelementptr { i32 }, { i32 }* [[I:%.*]], i64 1, i32 0 57; CHECK-NEXT: ret i32* [[B]] 58; 59 %A = getelementptr { i32 }, { i32 }* %I, i64 1 60 %B = getelementptr { i32 }, { i32 }* %A, i64 0, i32 0 61 ret i32* %B 62} 63 64define void @test5(i8 %B) { 65 ; This should be turned into a constexpr instead of being an instruction 66; CHECK-LABEL: @test5( 67; CHECK-NEXT: store i8 [[B:%.*]], i8* getelementptr inbounds ([10 x i8], [10 x i8]* @Global, i64 0, i64 4), align 1 68; CHECK-NEXT: ret void 69; 70 %A = getelementptr [10 x i8], [10 x i8]* @Global, i64 0, i64 4 71 store i8 %B, i8* %A 72 ret void 73} 74 75define void @test5_as1(i8 %B) { 76 ; This should be turned into a constexpr instead of being an instruction 77; CHECK-LABEL: @test5_as1( 78; CHECK-NEXT: store i8 [[B:%.*]], i8 addrspace(1)* getelementptr inbounds ([10 x i8], [10 x i8] addrspace(1)* @Global_as1, i16 0, i16 4), align 1 79; CHECK-NEXT: ret void 80; 81 %A = getelementptr [10 x i8], [10 x i8] addrspace(1)* @Global_as1, i16 0, i16 4 82 store i8 %B, i8 addrspace(1)* %A 83 ret void 84} 85 86%as1_ptr_struct = type { i32 addrspace(1)* } 87%as2_ptr_struct = type { i32 addrspace(2)* } 88 89@global_as2 = addrspace(2) global i32 zeroinitializer 90@global_as1_as2_ptr = addrspace(1) global %as2_ptr_struct { i32 addrspace(2)* @global_as2 } 91 92; This should be turned into a constexpr instead of being an instruction 93define void @test_evaluate_gep_nested_as_ptrs(i32 addrspace(2)* %B) { 94; CHECK-LABEL: @test_evaluate_gep_nested_as_ptrs( 95; CHECK-NEXT: store i32 addrspace(2)* [[B:%.*]], i32 addrspace(2)* addrspace(1)* getelementptr inbounds (%as2_ptr_struct, [[AS2_PTR_STRUCT:%.*]] addrspace(1)* @global_as1_as2_ptr, i16 0, i32 0), align 8 96; CHECK-NEXT: ret void 97; 98 %A = getelementptr %as2_ptr_struct, %as2_ptr_struct addrspace(1)* @global_as1_as2_ptr, i16 0, i32 0 99 store i32 addrspace(2)* %B, i32 addrspace(2)* addrspace(1)* %A 100 ret void 101} 102 103@arst = addrspace(1) global [4 x i8 addrspace(2)*] zeroinitializer 104 105define void @test_evaluate_gep_as_ptrs_array(i8 addrspace(2)* %B) { 106; CHECK-LABEL: @test_evaluate_gep_as_ptrs_array( 107; CHECK-NEXT: store i8 addrspace(2)* [[B:%.*]], i8 addrspace(2)* addrspace(1)* getelementptr inbounds ([4 x i8 addrspace(2)*], [4 x i8 addrspace(2)*] addrspace(1)* @arst, i16 0, i16 2), align 4 108; CHECK-NEXT: ret void 109; 110 111 %A = getelementptr [4 x i8 addrspace(2)*], [4 x i8 addrspace(2)*] addrspace(1)* @arst, i16 0, i16 2 112 store i8 addrspace(2)* %B, i8 addrspace(2)* addrspace(1)* %A 113 ret void 114} 115 116define i32* @test7(i32* %I, i64 %C, i64 %D) { 117; CHECK-LABEL: @test7( 118; CHECK-NEXT: [[A:%.*]] = getelementptr i32, i32* [[I:%.*]], i64 [[C:%.*]] 119; CHECK-NEXT: [[B:%.*]] = getelementptr i32, i32* [[A]], i64 [[D:%.*]] 120; CHECK-NEXT: ret i32* [[B]] 121; 122 %A = getelementptr i32, i32* %I, i64 %C 123 %B = getelementptr i32, i32* %A, i64 %D 124 ret i32* %B 125} 126 127define i8* @test8([10 x i32]* %X) { 128 ;; Fold into the cast. 129; CHECK-LABEL: @test8( 130; CHECK-NEXT: [[B:%.*]] = bitcast [10 x i32]* [[X:%.*]] to i8* 131; CHECK-NEXT: ret i8* [[B]] 132; 133 %A = getelementptr [10 x i32], [10 x i32]* %X, i64 0, i64 0 134 %B = bitcast i32* %A to i8* 135 ret i8* %B 136} 137 138define i32 @test9() { 139; CHECK-LABEL: @test9( 140; CHECK-NEXT: ret i32 8 141; 142 %A = getelementptr { i32, double }, { i32, double }* null, i32 0, i32 1 143 %B = ptrtoint double* %A to i32 144 ret i32 %B 145} 146 147define i1 @test10({ i32, i32 }* %x, { i32, i32 }* %y) { 148; CHECK-LABEL: @test10( 149; CHECK-NEXT: [[TMP_4:%.*]] = icmp eq { i32, i32 }* [[X:%.*]], [[Y:%.*]] 150; CHECK-NEXT: ret i1 [[TMP_4]] 151; 152 %tmp.1 = getelementptr { i32, i32 }, { i32, i32 }* %x, i32 0, i32 1 153 %tmp.3 = getelementptr { i32, i32 }, { i32, i32 }* %y, i32 0, i32 1 154 ;; seteq x, y 155 %tmp.4 = icmp eq i32* %tmp.1, %tmp.3 156 ret i1 %tmp.4 157} 158 159define i1 @test11({ i32, i32 }* %X) { 160; CHECK-LABEL: @test11( 161; CHECK-NEXT: [[Q:%.*]] = icmp eq { i32, i32 }* [[X:%.*]], null 162; CHECK-NEXT: ret i1 [[Q]] 163; 164 %P = getelementptr { i32, i32 }, { i32, i32 }* %X, i32 0, i32 0 165 %Q = icmp eq i32* %P, null 166 ret i1 %Q 167} 168 169 170; PR4748 171define i32 @test12(%struct.A* %a) { 172; CHECK-LABEL: @test12( 173; CHECK-NEXT: entry: 174; CHECK-NEXT: [[G3:%.*]] = getelementptr [[STRUCT_A:%.*]], %struct.A* [[A:%.*]], i64 0, i32 1 175; CHECK-NEXT: store i32 10, i32* [[G3]], align 4 176; CHECK-NEXT: ret i32 10 177; 178entry: 179 %g3 = getelementptr %struct.A, %struct.A* %a, i32 0, i32 1 180 store i32 10, i32* %g3, align 4 181 182 %g4 = getelementptr %struct.A, %struct.A* %a, i32 0, i32 0 183 184 %new_a = bitcast %struct.B* %g4 to %struct.A* 185 186 %g5 = getelementptr %struct.A, %struct.A* %new_a, i32 0, i32 1 187 %a_a = load i32, i32* %g5, align 4 188 ret i32 %a_a 189} 190 191 192; PR2235 193%S = type { i32, [ 100 x i32] } 194define i1 @test13(i64 %X, %S* %P) { 195; CHECK-LABEL: @test13( 196; CHECK-NEXT: [[C:%.*]] = icmp eq i64 [[X:%.*]], -1 197; CHECK-NEXT: ret i1 [[C]] 198; 199 %A = getelementptr inbounds %S, %S* %P, i32 0, i32 1, i64 %X 200 %B = getelementptr inbounds %S, %S* %P, i32 0, i32 0 201 %C = icmp eq i32* %A, %B 202 ret i1 %C 203} 204 205define <2 x i1> @test13_vector(<2 x i64> %X, <2 x %S*> %P) nounwind { 206; CHECK-LABEL: @test13_vector( 207; CHECK-NEXT: [[C:%.*]] = icmp eq <2 x i64> [[X:%.*]], <i64 -1, i64 -1> 208; CHECK-NEXT: ret <2 x i1> [[C]] 209; 210 %A = getelementptr inbounds %S, <2 x %S*> %P, <2 x i64> zeroinitializer, <2 x i32> <i32 1, i32 1>, <2 x i64> %X 211 %B = getelementptr inbounds %S, <2 x %S*> %P, <2 x i64> <i64 0, i64 0>, <2 x i32> <i32 0, i32 0> 212 %C = icmp eq <2 x i32*> %A, %B 213 ret <2 x i1> %C 214} 215 216define <2 x i1> @test13_vector2(i64 %X, <2 x %S*> %P) nounwind { 217; CHECK-LABEL: @test13_vector2( 218; CHECK-NEXT: [[DOTSPLATINSERT:%.*]] = insertelement <2 x i64> undef, i64 [[X:%.*]], i32 0 219; CHECK-NEXT: [[TMP1:%.*]] = shl <2 x i64> [[DOTSPLATINSERT]], <i64 2, i64 0> 220; CHECK-NEXT: [[TMP2:%.*]] = icmp eq <2 x i64> [[TMP1]], <i64 -4, i64 undef> 221; CHECK-NEXT: [[C:%.*]] = shufflevector <2 x i1> [[TMP2]], <2 x i1> undef, <2 x i32> zeroinitializer 222; CHECK-NEXT: ret <2 x i1> [[C]] 223; 224 %A = getelementptr inbounds %S, <2 x %S*> %P, <2 x i64> zeroinitializer, <2 x i32> <i32 1, i32 1>, i64 %X 225 %B = getelementptr inbounds %S, <2 x %S*> %P, <2 x i64> <i64 0, i64 0>, <2 x i32> <i32 0, i32 0> 226 %C = icmp eq <2 x i32*> %A, %B 227 ret <2 x i1> %C 228} 229 230; This is a test of icmp + shl nuw in disguise - 4611... is 0x3fff... 231define <2 x i1> @test13_vector3(i64 %X, <2 x %S*> %P) nounwind { 232; CHECK-LABEL: @test13_vector3( 233; CHECK-NEXT: [[DOTSPLATINSERT:%.*]] = insertelement <2 x i64> undef, i64 [[X:%.*]], i32 0 234; CHECK-NEXT: [[TMP1:%.*]] = shl <2 x i64> [[DOTSPLATINSERT]], <i64 2, i64 0> 235; CHECK-NEXT: [[TMP2:%.*]] = icmp eq <2 x i64> [[TMP1]], <i64 4, i64 undef> 236; CHECK-NEXT: [[C:%.*]] = shufflevector <2 x i1> [[TMP2]], <2 x i1> undef, <2 x i32> zeroinitializer 237; CHECK-NEXT: ret <2 x i1> [[C]] 238; 239 %A = getelementptr inbounds %S, <2 x %S*> %P, <2 x i64> zeroinitializer, <2 x i32> <i32 1, i32 1>, i64 %X 240 %B = getelementptr inbounds %S, <2 x %S*> %P, <2 x i64> <i64 0, i64 0>, <2 x i32> <i32 1, i32 1>, i64 1 241 %C = icmp eq <2 x i32*> %A, %B 242 ret <2 x i1> %C 243} 244 245define i1 @test13_as1(i16 %X, %S addrspace(1)* %P) { 246; CHECK-LABEL: @test13_as1( 247; CHECK-NEXT: [[C:%.*]] = icmp eq i16 [[X:%.*]], -1 248; CHECK-NEXT: ret i1 [[C]] 249; 250 %A = getelementptr inbounds %S, %S addrspace(1)* %P, i16 0, i32 1, i16 %X 251 %B = getelementptr inbounds %S, %S addrspace(1)* %P, i16 0, i32 0 252 %C = icmp eq i32 addrspace(1)* %A, %B 253 ret i1 %C 254} 255 256define <2 x i1> @test13_vector_as1(<2 x i16> %X, <2 x %S addrspace(1)*> %P) { 257; CHECK-LABEL: @test13_vector_as1( 258; CHECK-NEXT: [[C:%.*]] = icmp eq <2 x i16> [[X:%.*]], <i16 -1, i16 -1> 259; CHECK-NEXT: ret <2 x i1> [[C]] 260; 261 %A = getelementptr inbounds %S, <2 x %S addrspace(1)*> %P, <2 x i16> <i16 0, i16 0>, <2 x i32> <i32 1, i32 1>, <2 x i16> %X 262 %B = getelementptr inbounds %S, <2 x %S addrspace(1)*> %P, <2 x i16> <i16 0, i16 0>, <2 x i32> <i32 0, i32 0> 263 %C = icmp eq <2 x i32 addrspace(1)*> %A, %B 264 ret <2 x i1> %C 265} 266 267define i1 @test13_i32(i32 %X, %S* %P) { 268; CHECK-LABEL: @test13_i32( 269; CHECK-NEXT: [[C:%.*]] = icmp eq i32 [[X:%.*]], -1 270; CHECK-NEXT: ret i1 [[C]] 271; 272 %A = getelementptr inbounds %S, %S* %P, i32 0, i32 1, i32 %X 273 %B = getelementptr inbounds %S, %S* %P, i32 0, i32 0 274 %C = icmp eq i32* %A, %B 275 ret i1 %C 276} 277 278define i1 @test13_i16(i16 %X, %S* %P) { 279; CHECK-LABEL: @test13_i16( 280; CHECK-NEXT: [[C:%.*]] = icmp eq i16 [[X:%.*]], -1 281; CHECK-NEXT: ret i1 [[C]] 282; 283 %A = getelementptr inbounds %S, %S* %P, i16 0, i32 1, i16 %X 284 %B = getelementptr inbounds %S, %S* %P, i16 0, i32 0 285 %C = icmp eq i32* %A, %B 286 ret i1 %C 287} 288 289define i1 @test13_i128(i128 %X, %S* %P) { 290; CHECK-LABEL: @test13_i128( 291; CHECK-NEXT: [[TMP1:%.*]] = trunc i128 [[X:%.*]] to i64 292; CHECK-NEXT: [[C:%.*]] = icmp eq i64 [[TMP1]], -1 293; CHECK-NEXT: ret i1 [[C]] 294; 295 %A = getelementptr inbounds %S, %S* %P, i128 0, i32 1, i128 %X 296 %B = getelementptr inbounds %S, %S* %P, i128 0, i32 0 297 %C = icmp eq i32* %A, %B 298 ret i1 %C 299} 300 301 302@G = external global [3 x i8] 303define i8* @test14(i32 %idx) { 304; CHECK-LABEL: @test14( 305; CHECK-NEXT: [[ZEXT:%.*]] = zext i32 [[IDX:%.*]] to i64 306; CHECK-NEXT: [[TMP:%.*]] = getelementptr [3 x i8], [3 x i8]* @G, i64 0, i64 [[ZEXT]] 307; CHECK-NEXT: ret i8* [[TMP]] 308; 309 %zext = zext i32 %idx to i64 310 %tmp = getelementptr i8, i8* getelementptr ([3 x i8], [3 x i8]* @G, i32 0, i32 0), i64 %zext 311 ret i8* %tmp 312} 313 314 315; Test folding of constantexpr geps into normal geps. 316@Array = external global [40 x i32] 317define i32 *@test15(i64 %X) { 318; CHECK-LABEL: @test15( 319; CHECK-NEXT: [[A:%.*]] = getelementptr [40 x i32], [40 x i32]* @Array, i64 0, i64 [[X:%.*]] 320; CHECK-NEXT: ret i32* [[A]] 321; 322 %A = getelementptr i32, i32* getelementptr ([40 x i32], [40 x i32]* @Array, i64 0, i64 0), i64 %X 323 ret i32* %A 324} 325 326 327define i32* @test16(i32* %X, i32 %Idx) { 328; CHECK-LABEL: @test16( 329; CHECK-NEXT: [[TMP1:%.*]] = sext i32 [[IDX:%.*]] to i64 330; CHECK-NEXT: [[R:%.*]] = getelementptr i32, i32* [[X:%.*]], i64 [[TMP1]] 331; CHECK-NEXT: ret i32* [[R]] 332; 333 %R = getelementptr i32, i32* %X, i32 %Idx 334 ret i32* %R 335} 336 337 338define i1 @test17(i16* %P, i32 %I, i32 %J) { 339; CHECK-LABEL: @test17( 340; CHECK-NEXT: [[C:%.*]] = icmp slt i32 [[I:%.*]], [[J:%.*]] 341; CHECK-NEXT: ret i1 [[C]] 342; 343 %X = getelementptr inbounds i16, i16* %P, i32 %I 344 %Y = getelementptr inbounds i16, i16* %P, i32 %J 345 %C = icmp ult i16* %X, %Y 346 ret i1 %C 347} 348 349define i1 @test18(i16* %P, i32 %I) { 350; CHECK-LABEL: @test18( 351; CHECK-NEXT: [[C:%.*]] = icmp slt i32 [[I:%.*]], 0 352; CHECK-NEXT: ret i1 [[C]] 353; 354 %X = getelementptr inbounds i16, i16* %P, i32 %I 355 %C = icmp ult i16* %X, %P 356 ret i1 %C 357} 358 359; Larger than the pointer size for a non-zero address space 360define i1 @test18_as1(i16 addrspace(1)* %P, i32 %I) { 361; CHECK-LABEL: @test18_as1( 362; CHECK-NEXT: [[TMP1:%.*]] = trunc i32 [[I:%.*]] to i16 363; CHECK-NEXT: [[C:%.*]] = icmp slt i16 [[TMP1]], 0 364; CHECK-NEXT: ret i1 [[C]] 365; 366 %X = getelementptr inbounds i16, i16 addrspace(1)* %P, i32 %I 367 %C = icmp ult i16 addrspace(1)* %X, %P 368 ret i1 %C 369} 370 371; Smaller than the pointer size for a non-zero address space 372define i1 @test18_as1_i32(i16 addrspace(1)* %P, i32 %I) { 373; CHECK-LABEL: @test18_as1_i32( 374; CHECK-NEXT: [[TMP1:%.*]] = trunc i32 [[I:%.*]] to i16 375; CHECK-NEXT: [[C:%.*]] = icmp slt i16 [[TMP1]], 0 376; CHECK-NEXT: ret i1 [[C]] 377; 378 %X = getelementptr inbounds i16, i16 addrspace(1)* %P, i32 %I 379 %C = icmp ult i16 addrspace(1)* %X, %P 380 ret i1 %C 381} 382 383; Smaller than pointer size 384define i1 @test18_i16(i16* %P, i16 %I) { 385; CHECK-LABEL: @test18_i16( 386; CHECK-NEXT: [[C:%.*]] = icmp slt i16 [[I:%.*]], 0 387; CHECK-NEXT: ret i1 [[C]] 388; 389 %X = getelementptr inbounds i16, i16* %P, i16 %I 390 %C = icmp ult i16* %X, %P 391 ret i1 %C 392} 393 394; Same as pointer size 395define i1 @test18_i64(i16* %P, i64 %I) { 396; CHECK-LABEL: @test18_i64( 397; CHECK-NEXT: [[C:%.*]] = icmp slt i64 [[I:%.*]], 0 398; CHECK-NEXT: ret i1 [[C]] 399; 400 %X = getelementptr inbounds i16, i16* %P, i64 %I 401 %C = icmp ult i16* %X, %P 402 ret i1 %C 403} 404 405; Larger than the pointer size 406define i1 @test18_i128(i16* %P, i128 %I) { 407; CHECK-LABEL: @test18_i128( 408; CHECK-NEXT: [[TMP1:%.*]] = trunc i128 [[I:%.*]] to i64 409; CHECK-NEXT: [[C:%.*]] = icmp slt i64 [[TMP1]], 0 410; CHECK-NEXT: ret i1 [[C]] 411; 412 %X = getelementptr inbounds i16, i16* %P, i128 %I 413 %C = icmp ult i16* %X, %P 414 ret i1 %C 415} 416 417define i32 @test19(i32* %P, i32 %A, i32 %B) { 418; CHECK-LABEL: @test19( 419; CHECK-NEXT: [[TMP_10:%.*]] = icmp eq i32 [[A:%.*]], [[B:%.*]] 420; CHECK-NEXT: [[TMP_11:%.*]] = zext i1 [[TMP_10]] to i32 421; CHECK-NEXT: ret i32 [[TMP_11]] 422; 423 %tmp.4 = getelementptr inbounds i32, i32* %P, i32 %A 424 %tmp.9 = getelementptr inbounds i32, i32* %P, i32 %B 425 %tmp.10 = icmp eq i32* %tmp.4, %tmp.9 426 %tmp.11 = zext i1 %tmp.10 to i32 427 ret i32 %tmp.11 428} 429 430define i32 @test20(i32* %P, i32 %A, i32 %B) { 431; CHECK-LABEL: @test20( 432; CHECK-NEXT: [[TMP_6:%.*]] = icmp eq i32 [[A:%.*]], 0 433; CHECK-NEXT: [[TMP_7:%.*]] = zext i1 [[TMP_6]] to i32 434; CHECK-NEXT: ret i32 [[TMP_7]] 435; 436 %tmp.4 = getelementptr inbounds i32, i32* %P, i32 %A 437 %tmp.6 = icmp eq i32* %tmp.4, %P 438 %tmp.7 = zext i1 %tmp.6 to i32 439 ret i32 %tmp.7 440} 441 442define i32 @test20_as1(i32 addrspace(1)* %P, i32 %A, i32 %B) { 443; CHECK-LABEL: @test20_as1( 444; CHECK-NEXT: [[TMP1:%.*]] = trunc i32 [[A:%.*]] to i16 445; CHECK-NEXT: [[TMP_6:%.*]] = icmp eq i16 [[TMP1]], 0 446; CHECK-NEXT: [[TMP_7:%.*]] = zext i1 [[TMP_6]] to i32 447; CHECK-NEXT: ret i32 [[TMP_7]] 448; 449 %tmp.4 = getelementptr inbounds i32, i32 addrspace(1)* %P, i32 %A 450 %tmp.6 = icmp eq i32 addrspace(1)* %tmp.4, %P 451 %tmp.7 = zext i1 %tmp.6 to i32 452 ret i32 %tmp.7 453} 454 455 456define i32 @test21() { 457; CHECK-LABEL: @test21( 458; CHECK-NEXT: [[PBOB1:%.*]] = alloca [[INTSTRUCT:%.*]], align 8 459; CHECK-NEXT: [[PBOBEL:%.*]] = getelementptr inbounds [[INTSTRUCT]], %intstruct* [[PBOB1]], i64 0, i32 0 460; CHECK-NEXT: [[RVAL:%.*]] = load i32, i32* [[PBOBEL]], align 8 461; CHECK-NEXT: ret i32 [[RVAL]] 462; 463 %pbob1 = alloca %intstruct 464 %pbob2 = getelementptr %intstruct, %intstruct* %pbob1 465 %pbobel = getelementptr %intstruct, %intstruct* %pbob2, i64 0, i32 0 466 %rval = load i32, i32* %pbobel 467 ret i32 %rval 468} 469 470 471@A = global i32 1 ; <i32*> [#uses=1] 472@B = global i32 2 ; <i32*> [#uses=1] 473 474define i1 @test22() { 475; CHECK-LABEL: @test22( 476; CHECK-NEXT: ret i1 icmp ult (i32* getelementptr inbounds (i32, i32* @A, i64 1), i32* getelementptr (i32, i32* @B, i64 2)) 477; 478 %C = icmp ult i32* getelementptr (i32, i32* @A, i64 1), 479 getelementptr (i32, i32* @B, i64 2) 480 ret i1 %C 481} 482 483 484%X = type { [10 x i32], float } 485 486define i1 @test23() { 487; CHECK-LABEL: @test23( 488; CHECK-NEXT: ret i1 false 489; 490 %A = getelementptr %X, %X* null, i64 0, i32 0, i64 0 ; <i32*> [#uses=1] 491 %B = icmp ne i32* %A, null ; <i1> [#uses=1] 492 ret i1 %B 493} 494 495define void @test25() { 496; CHECK-LABEL: @test25( 497; CHECK-NEXT: entry: 498; CHECK-NEXT: store i64 undef, i64* null, align 536870912 499; CHECK-NEXT: tail call void @foo25(i32 0, i64 0) 500; CHECK-NEXT: unreachable 501; 502entry: 503 %tmp = getelementptr { i64, i64, i64, i64 }, { i64, i64, i64, i64 }* null, i32 0, i32 3 ; <i64*> [#uses=1] 504 %tmp.upgrd.1 = load i64, i64* %tmp ; <i64> [#uses=1] 505 %tmp8.ui = load i64, i64* null ; <i64> [#uses=1] 506 %tmp8 = bitcast i64 %tmp8.ui to i64 ; <i64> [#uses=1] 507 %tmp9 = and i64 %tmp8, %tmp.upgrd.1 ; <i64> [#uses=1] 508 %sext = trunc i64 %tmp9 to i32 ; <i32> [#uses=1] 509 %tmp27.i = sext i32 %sext to i64 ; <i64> [#uses=1] 510 tail call void @foo25( i32 0, i64 %tmp27.i ) 511 unreachable 512} 513 514declare void @foo25(i32, i64) 515 516 517; PR1637 518define i1 @test26(i8* %arr) { 519; CHECK-LABEL: @test26( 520; CHECK-NEXT: ret i1 true 521; 522 %X = getelementptr i8, i8* %arr, i32 1 523 %Y = getelementptr i8, i8* %arr, i32 1 524 %test = icmp uge i8* %X, %Y 525 ret i1 %test 526} 527 528 %struct.__large_struct = type { [100 x i64] } 529 %struct.compat_siginfo = type { i32, i32, i32, { [29 x i32] } } 530 %struct.siginfo_t = type { i32, i32, i32, { { i32, i32, [0 x i8], %struct.sigval_t, i32 }, [88 x i8] } } 531 %struct.sigval_t = type { i8* } 532 533define i32 @test27(%struct.compat_siginfo* %to, %struct.siginfo_t* %from) { 534; CHECK-LABEL: @test27( 535; CHECK-NEXT: entry: 536; CHECK-NEXT: [[FROM_ADDR:%.*]] = alloca %struct.siginfo_t*, align 8 537; CHECK-NEXT: [[TMP344:%.*]] = load %struct.siginfo_t*, %struct.siginfo_t** [[FROM_ADDR]], align 8 538; CHECK-NEXT: [[TMP349:%.*]] = getelementptr [[STRUCT_SIGINFO_T:%.*]], %struct.siginfo_t* [[TMP344]], i64 0, i32 3, i32 0, i32 3, i32 0 539; CHECK-NEXT: [[TMP349350:%.*]] = bitcast i8** [[TMP349]] to i32* 540; CHECK-NEXT: [[TMP351:%.*]] = load i32, i32* [[TMP349350]], align 8 541; CHECK-NEXT: [[TMP360:%.*]] = call i32 asm sideeffect "...", "=r,ir,*m,i,0,~{dirflag},~{fpsr},~{flags}"(i32 [[TMP351]], %struct.__large_struct* null, i32 -14, i32 0) [[ATTR0:#.*]] 542; CHECK-NEXT: unreachable 543; 544entry: 545 %from_addr = alloca %struct.siginfo_t* 546 %tmp344 = load %struct.siginfo_t*, %struct.siginfo_t** %from_addr, align 8 547 %tmp345 = getelementptr %struct.siginfo_t, %struct.siginfo_t* %tmp344, i32 0, i32 3 548 %tmp346 = getelementptr { { i32, i32, [0 x i8], %struct.sigval_t, i32 }, [88 x i8] }, { { i32, i32, [0 x i8], %struct.sigval_t, i32 }, [88 x i8] }* %tmp345, i32 0, i32 0 549 %tmp346347 = bitcast { i32, i32, [0 x i8], %struct.sigval_t, i32 }* %tmp346 to { i32, i32, %struct.sigval_t }* 550 %tmp348 = getelementptr { i32, i32, %struct.sigval_t }, { i32, i32, %struct.sigval_t }* %tmp346347, i32 0, i32 2 551 %tmp349 = getelementptr %struct.sigval_t, %struct.sigval_t* %tmp348, i32 0, i32 0 552 %tmp349350 = bitcast i8** %tmp349 to i32* 553 %tmp351 = load i32, i32* %tmp349350, align 8 554 %tmp360 = call i32 asm sideeffect "...", 555 "=r,ir,*m,i,0,~{dirflag},~{fpsr},~{flags}"( i32 %tmp351, 556 %struct.__large_struct* null, i32 -14, i32 0 ) 557 unreachable 558} 559 560; PR1978 561 %struct.x = type <{ i8 }> 562@.str = internal constant [6 x i8] c"Main!\00" 563@.str1 = internal constant [12 x i8] c"destroy %p\0A\00" 564 565define i32 @test28() nounwind { 566; CHECK-LABEL: @test28( 567; CHECK-NEXT: entry: 568; CHECK-NEXT: [[ORIENTATIONS:%.*]] = alloca [1 x [1 x %struct.x]], align 8 569; CHECK-NEXT: [[TMP3:%.*]] = call i32 @puts(i8* nonnull dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0)) [[ATTR0]] 570; CHECK-NEXT: br label [[BB10:%.*]] 571; CHECK: bb10: 572; CHECK-NEXT: [[INDVAR:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[INDVAR_NEXT:%.*]], [[BB10]] ] 573; CHECK-NEXT: [[TMP12_REC:%.*]] = xor i32 [[INDVAR]], -1 574; CHECK-NEXT: [[TMP0:%.*]] = sext i32 [[TMP12_REC]] to i64 575; CHECK-NEXT: [[TMP12:%.*]] = getelementptr inbounds [1 x [1 x %struct.x]], [1 x [1 x %struct.x]]* [[ORIENTATIONS]], i64 1, i64 0, i64 [[TMP0]] 576; CHECK-NEXT: [[TMP16:%.*]] = call i32 (i8*, ...) @printf(i8* nonnull dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @.str1, i64 0, i64 0), %struct.x* nonnull [[TMP12]]) [[ATTR0]] 577; CHECK-NEXT: [[TMP84:%.*]] = icmp eq i32 [[INDVAR]], 0 578; CHECK-NEXT: [[INDVAR_NEXT]] = add i32 [[INDVAR]], 1 579; CHECK-NEXT: br i1 [[TMP84]], label [[BB17:%.*]], label [[BB10]] 580; CHECK: bb17: 581; CHECK-NEXT: ret i32 0 582; 583entry: 584 %orientations = alloca [1 x [1 x %struct.x]] 585 %tmp3 = call i32 @puts( i8* getelementptr ([6 x i8], [6 x i8]* @.str, i32 0, i32 0) ) nounwind 586 %tmp45 = getelementptr inbounds [1 x [1 x %struct.x]], [1 x [1 x %struct.x]]* %orientations, i32 1, i32 0, i32 0 587 %orientations62 = getelementptr [1 x [1 x %struct.x]], [1 x [1 x %struct.x]]* %orientations, i32 0, i32 0, i32 0 588 br label %bb10 589 590bb10: 591 %indvar = phi i32 [ 0, %entry ], [ %indvar.next, %bb10 ] 592 %tmp.0.reg2mem.0.rec = mul i32 %indvar, -1 593 %tmp12.rec = add i32 %tmp.0.reg2mem.0.rec, -1 594 %tmp12 = getelementptr inbounds %struct.x, %struct.x* %tmp45, i32 %tmp12.rec 595 %tmp16 = call i32 (i8*, ...) @printf( i8* nonnull dereferenceable(1) getelementptr ([12 x i8], [12 x i8]* @.str1, i32 0, i32 0), %struct.x* %tmp12 ) nounwind 596 %tmp84 = icmp eq %struct.x* %tmp12, %orientations62 597 %indvar.next = add i32 %indvar, 1 598 br i1 %tmp84, label %bb17, label %bb10 599 600bb17: 601 ret i32 0 602} 603 604declare i32 @puts(i8*) 605 606declare i32 @printf(i8*, ...) 607 608 609 610 611; rdar://6762290 612 %T = type <{ i64, i64, i64 }> 613define i32 @test29(i8* %start, i32 %X) nounwind { 614; CHECK-LABEL: @test29( 615; CHECK-NEXT: entry: 616; CHECK-NEXT: store i64 undef, i64* null, align 536870912 617; CHECK-NEXT: [[ADD_PTR:%.*]] = getelementptr i8, i8* [[START:%.*]], i64 undef 618; CHECK-NEXT: [[TMP0:%.*]] = sext i32 [[X:%.*]] to i64 619; CHECK-NEXT: [[ADD_PTR212:%.*]] = getelementptr i8, i8* [[START]], i64 [[TMP0]] 620; CHECK-NEXT: [[CMP214:%.*]] = icmp ugt i8* [[ADD_PTR212]], [[ADD_PTR]] 621; CHECK-NEXT: br i1 [[CMP214]], label [[IF_THEN216:%.*]], label [[IF_END363:%.*]] 622; CHECK: if.then216: 623; CHECK-NEXT: ret i32 1 624; CHECK: if.end363: 625; CHECK-NEXT: ret i32 0 626; 627entry: 628 %tmp3 = load i64, i64* null 629 %add.ptr = getelementptr i8, i8* %start, i64 %tmp3 630 %tmp158 = load i32, i32* null 631 %add.ptr159 = getelementptr %T, %T* null, i32 %tmp158 632 %add.ptr209 = getelementptr i8, i8* %start, i64 0 633 %add.ptr212 = getelementptr i8, i8* %add.ptr209, i32 %X 634 %cmp214 = icmp ugt i8* %add.ptr212, %add.ptr 635 br i1 %cmp214, label %if.then216, label %if.end363 636 637if.then216: 638 ret i32 1 639 640if.end363: 641 ret i32 0 642} 643 644 645; PR3694 646define i32 @test30(i32 %m, i32 %n) nounwind { 647; CHECK-LABEL: @test30( 648; CHECK-NEXT: entry: 649; CHECK-NEXT: [[TMP0:%.*]] = zext i32 [[N:%.*]] to i64 650; CHECK-NEXT: [[TMP1:%.*]] = alloca i32, i64 [[TMP0]], align 4 651; CHECK-NEXT: call void @test30f(i32* nonnull [[TMP1]]) [[ATTR0]] 652; CHECK-NEXT: [[TMP2:%.*]] = sext i32 [[M:%.*]] to i64 653; CHECK-NEXT: [[TMP3:%.*]] = getelementptr i32, i32* [[TMP1]], i64 [[TMP2]] 654; CHECK-NEXT: [[TMP4:%.*]] = load i32, i32* [[TMP3]], align 4 655; CHECK-NEXT: ret i32 [[TMP4]] 656; 657entry: 658 %0 = alloca i32, i32 %n, align 4 659 %1 = bitcast i32* %0 to [0 x i32]* 660 call void @test30f(i32* %0) nounwind 661 %2 = getelementptr [0 x i32], [0 x i32]* %1, i32 0, i32 %m 662 %3 = load i32, i32* %2, align 4 663 ret i32 %3 664} 665 666declare void @test30f(i32*) 667 668 669 670define i1 @test31(i32* %A) { 671; CHECK-LABEL: @test31( 672; CHECK-NEXT: ret i1 true 673; 674 %B = getelementptr i32, i32* %A, i32 1 675 %C = getelementptr i32, i32* %A, i64 1 676 %V = icmp eq i32* %B, %C 677 ret i1 %V 678} 679 680 681; PR1345 682define i8* @test32(i8* %v) { 683; CHECK-LABEL: @test32( 684; CHECK-NEXT: [[A:%.*]] = alloca [4 x i8*], align 16 685; CHECK-NEXT: [[B:%.*]] = getelementptr inbounds [4 x i8*], [4 x i8*]* [[A]], i64 0, i64 0 686; CHECK-NEXT: store i8* null, i8** [[B]], align 16 687; CHECK-NEXT: [[D:%.*]] = getelementptr inbounds [4 x i8*], [4 x i8*]* [[A]], i64 0, i64 1 688; CHECK-NEXT: store i8* [[V:%.*]], i8** [[D]], align 8 689; CHECK-NEXT: [[F:%.*]] = getelementptr inbounds [4 x i8*], [4 x i8*]* [[A]], i64 0, i64 2 690; CHECK-NEXT: [[G:%.*]] = load i8*, i8** [[F]], align 16 691; CHECK-NEXT: ret i8* [[G]] 692; 693 %A = alloca [4 x i8*], align 16 694 %B = getelementptr [4 x i8*], [4 x i8*]* %A, i32 0, i32 0 695 store i8* null, i8** %B 696 %C = bitcast [4 x i8*]* %A to { [16 x i8] }* 697 %D = getelementptr { [16 x i8] }, { [16 x i8] }* %C, i32 0, i32 0, i32 8 698 %E = bitcast i8* %D to i8** 699 store i8* %v, i8** %E 700 %F = getelementptr [4 x i8*], [4 x i8*]* %A, i32 0, i32 2 701 %G = load i8*, i8** %F 702 ret i8* %G 703} 704 705; PR3290 706%struct.Key = type { { i32, i32 } } 707%struct.anon = type <{ i8, [3 x i8], i32 }> 708 709define i32* @test33(%struct.Key* %A) { 710; CHECK-LABEL: @test33( 711; CHECK-NEXT: [[TMP1:%.*]] = getelementptr [[STRUCT_KEY:%.*]], %struct.Key* [[A:%.*]], i64 0, i32 0, i32 1 712; CHECK-NEXT: ret i32* [[TMP1]] 713; 714 %B = bitcast %struct.Key* %A to %struct.anon* 715 %C = getelementptr %struct.anon, %struct.anon* %B, i32 0, i32 2 716 ret i32* %C 717} 718 719define i32 addrspace(1)* @test33_as1(%struct.Key addrspace(1)* %A) { 720; CHECK-LABEL: @test33_as1( 721; CHECK-NEXT: [[TMP1:%.*]] = getelementptr [[STRUCT_KEY:%.*]], [[STRUCT_KEY]] addrspace(1)* [[A:%.*]], i16 0, i32 0, i32 1 722; CHECK-NEXT: ret i32 addrspace(1)* [[TMP1]] 723; 724 %B = bitcast %struct.Key addrspace(1)* %A to %struct.anon addrspace(1)* 725 %C = getelementptr %struct.anon, %struct.anon addrspace(1)* %B, i32 0, i32 2 726 ret i32 addrspace(1)* %C 727} 728 729define i32 addrspace(1)* @test33_array_as1([10 x i32] addrspace(1)* %A) { 730; CHECK-LABEL: @test33_array_as1( 731; CHECK-NEXT: [[C:%.*]] = getelementptr [10 x i32], [10 x i32] addrspace(1)* [[A:%.*]], i16 0, i16 2 732; CHECK-NEXT: ret i32 addrspace(1)* [[C]] 733; 734 %B = bitcast [10 x i32] addrspace(1)* %A to [5 x i32] addrspace(1)* 735 %C = getelementptr [5 x i32], [5 x i32] addrspace(1)* %B, i32 0, i32 2 736 ret i32 addrspace(1)* %C 737} 738 739; Make sure the GEP indices use the right pointer sized integer 740define i32 addrspace(1)* @test33_array_struct_as1([10 x %struct.Key] addrspace(1)* %A) { 741; CHECK-LABEL: @test33_array_struct_as1( 742; CHECK-NEXT: [[TMP1:%.*]] = getelementptr [10 x %struct.Key], [10 x %struct.Key] addrspace(1)* [[A:%.*]], i16 0, i16 1, i32 0, i32 0 743; CHECK-NEXT: ret i32 addrspace(1)* [[TMP1]] 744; 745 %B = bitcast [10 x %struct.Key] addrspace(1)* %A to [20 x i32] addrspace(1)* 746 %C = getelementptr [20 x i32], [20 x i32] addrspace(1)* %B, i32 0, i32 2 747 ret i32 addrspace(1)* %C 748} 749 750define i32 addrspace(1)* @test33_addrspacecast(%struct.Key* %A) { 751; CHECK-LABEL: @test33_addrspacecast( 752; CHECK-NEXT: [[C:%.*]] = getelementptr [[STRUCT_KEY:%.*]], %struct.Key* [[A:%.*]], i64 0, i32 0, i32 1 753; CHECK-NEXT: [[TMP1:%.*]] = addrspacecast i32* [[C]] to i32 addrspace(1)* 754; CHECK-NEXT: ret i32 addrspace(1)* [[TMP1]] 755; 756 %B = addrspacecast %struct.Key* %A to %struct.anon addrspace(1)* 757 %C = getelementptr %struct.anon, %struct.anon addrspace(1)* %B, i32 0, i32 2 758 ret i32 addrspace(1)* %C 759} 760 761 %T2 = type { i8*, i8 } 762define i8* @test34(i8* %Val, i64 %V) nounwind { 763; CHECK-LABEL: @test34( 764; CHECK-NEXT: entry: 765; CHECK-NEXT: [[C_CAST:%.*]] = inttoptr i64 [[V:%.*]] to i8* 766; CHECK-NEXT: ret i8* [[C_CAST]] 767; 768entry: 769 %A = alloca %T2, align 8 770 %mrv_gep = bitcast %T2* %A to i64* 771 %B = getelementptr %T2, %T2* %A, i64 0, i32 0 772 773 store i64 %V, i64* %mrv_gep 774 %C = load i8*, i8** %B, align 8 775 ret i8* %C 776} 777 778%t0 = type { i8*, [19 x i8] } 779%t1 = type { i8*, [0 x i8] } 780 781@array = external global [11 x i8] 782 783@s = external global %t0 784@"\01LC8" = external constant [17 x i8] 785 786; Instcombine should be able to fold this getelementptr. 787 788define i32 @test35() nounwind { 789; CHECK-LABEL: @test35( 790; CHECK-NEXT: [[TMP1:%.*]] = call i32 (i8*, ...) @printf(i8* nonnull dereferenceable(1) getelementptr inbounds ([17 x i8], [17 x i8]* @"\01LC8", i64 0, i64 0), i8* getelementptr inbounds (%t0, %t0* @s, i64 0, i32 1, i64 0)) [[ATTR0]] 791; CHECK-NEXT: ret i32 0 792; 793 call i32 (i8*, ...) @printf(i8* getelementptr ([17 x i8], [17 x i8]* @"\01LC8", i32 0, i32 0), 794 i8* getelementptr (%t1, %t1* bitcast (%t0* @s to %t1*), i32 0, i32 1, i32 0)) nounwind 795 ret i32 0 796} 797 798; Don't treat signed offsets as unsigned. 799define i8* @test36() nounwind { 800; CHECK-LABEL: @test36( 801; CHECK-NEXT: ret i8* getelementptr ([11 x i8], [11 x i8]* @array, i64 0, i64 -1) 802; 803 ret i8* getelementptr ([11 x i8], [11 x i8]* @array, i32 0, i64 -1) 804} 805 806; Instcombine shouldn't assume that gep(A,0,1) != gep(A,1,0). 807@A37 = external constant [1 x i8] 808define i1 @test37() nounwind { 809; CHECK-LABEL: @test37( 810; CHECK-NEXT: ret i1 true 811; 812 %t = icmp eq i8* getelementptr ([1 x i8], [1 x i8]* @A37, i64 0, i64 1), 813 getelementptr ([1 x i8], [1 x i8]* @A37, i64 1, i64 0) 814 ret i1 %t 815} 816 817; Test index promotion 818define i32* @test38(i32* %I, i32 %n) { 819; CHECK-LABEL: @test38( 820; CHECK-NEXT: [[TMP1:%.*]] = sext i32 [[N:%.*]] to i64 821; CHECK-NEXT: [[A:%.*]] = getelementptr i32, i32* [[I:%.*]], i64 [[TMP1]] 822; CHECK-NEXT: ret i32* [[A]] 823; 824 %A = getelementptr i32, i32* %I, i32 %n 825 ret i32* %A 826} 827 828; Test that we don't duplicate work when the second gep is a "bitcast". 829%pr10322_t = type { i8* } 830declare void @pr10322_f2(%pr10322_t*) 831declare void @pr10322_f3(i8**) 832define void @pr10322_f1(%pr10322_t* %foo) { 833; CHECK-LABEL: @pr10322_f1( 834; CHECK-NEXT: entry: 835; CHECK-NEXT: [[ARRAYIDX8:%.*]] = getelementptr inbounds [[PR10322_T:%.*]], %pr10322_t* [[FOO:%.*]], i64 2 836; CHECK-NEXT: call void @pr10322_f2(%pr10322_t* nonnull [[ARRAYIDX8]]) [[ATTR0]] 837; CHECK-NEXT: [[TMP2:%.*]] = getelementptr inbounds [[PR10322_T]], %pr10322_t* [[ARRAYIDX8]], i64 0, i32 0 838; CHECK-NEXT: call void @pr10322_f3(i8** nonnull [[TMP2]]) [[ATTR0]] 839; CHECK-NEXT: ret void 840; 841entry: 842 %arrayidx8 = getelementptr inbounds %pr10322_t, %pr10322_t* %foo, i64 2 843 call void @pr10322_f2(%pr10322_t* %arrayidx8) nounwind 844 %tmp2 = getelementptr inbounds %pr10322_t, %pr10322_t* %arrayidx8, i64 0, i32 0 845 call void @pr10322_f3(i8** %tmp2) nounwind 846 ret void 847 848} 849 850; Test that we combine the last two geps in this sequence, before we 851; would wait for gep1 and gep2 to be combined and never combine 2 and 3. 852%three_gep_t = type {i32} 853%three_gep_t2 = type {%three_gep_t} 854 855define void @three_gep_f(%three_gep_t2* %x) { 856; CHECK-LABEL: @three_gep_f( 857; CHECK-NEXT: [[GEP1:%.*]] = getelementptr [[THREE_GEP_T2:%.*]], %three_gep_t2* [[X:%.*]], i64 2 858; CHECK-NEXT: call void @three_gep_h(%three_gep_t2* [[GEP1]]) 859; CHECK-NEXT: [[GEP3:%.*]] = getelementptr [[THREE_GEP_T2]], %three_gep_t2* [[GEP1]], i64 0, i32 0, i32 0 860; CHECK-NEXT: call void @three_gep_g(i32* [[GEP3]]) 861; CHECK-NEXT: ret void 862; 863 %gep1 = getelementptr %three_gep_t2, %three_gep_t2* %x, i64 2 864 call void @three_gep_h(%three_gep_t2* %gep1) 865 %gep2 = getelementptr %three_gep_t2, %three_gep_t2* %gep1, i64 0, i32 0 866 %gep3 = getelementptr %three_gep_t, %three_gep_t* %gep2, i64 0, i32 0 867 call void @three_gep_g(i32* %gep3) 868 869 ret void 870} 871 872declare void @three_gep_g(i32*) 873declare void @three_gep_h(%three_gep_t2*) 874 875%struct.ham = type { i32, %struct.zot*, %struct.zot*, %struct.zot* } 876%struct.zot = type { i64, i8 } 877 878define void @test39(%struct.ham* %arg, i8 %arg1) nounwind { 879; CHECK-LABEL: @test39( 880; CHECK-NEXT: [[TMP:%.*]] = getelementptr inbounds [[STRUCT_HAM:%.*]], %struct.ham* [[ARG:%.*]], i64 0, i32 2 881; CHECK-NEXT: [[TMP1:%.*]] = bitcast %struct.zot** [[TMP]] to i8** 882; CHECK-NEXT: [[TMP21:%.*]] = load i8*, i8** [[TMP1]], align 8 883; CHECK-NEXT: [[TMP4:%.*]] = getelementptr inbounds i8, i8* [[TMP21]], i64 -8 884; CHECK-NEXT: store i8 [[ARG1:%.*]], i8* [[TMP4]], align 8 885; CHECK-NEXT: ret void 886; 887 %tmp = getelementptr inbounds %struct.ham, %struct.ham* %arg, i64 0, i32 2 888 %tmp2 = load %struct.zot*, %struct.zot** %tmp, align 8 889 %tmp3 = bitcast %struct.zot* %tmp2 to i8* 890 %tmp4 = getelementptr inbounds i8, i8* %tmp3, i64 -8 891 store i8 %arg1, i8* %tmp4, align 8 892 ret void 893 894} 895 896define i1 @pr16483([1 x i8]* %a, [1 x i8]* %b) { 897; CHECK-LABEL: @pr16483( 898; CHECK-NEXT: [[CMP:%.*]] = icmp ult [1 x i8]* [[A:%.*]], [[B:%.*]] 899; CHECK-NEXT: ret i1 [[CMP]] 900; 901 %c = getelementptr [1 x i8], [1 x i8]* %a, i32 0, i32 0 902 %d = getelementptr [1 x i8], [1 x i8]* %b, i32 0, i32 0 903 %cmp = icmp ult i8* %c, %d 904 ret i1 %cmp 905 906} 907 908define i8 @test_gep_bitcast_as1(i32 addrspace(1)* %arr, i16 %N) { 909; CHECK-LABEL: @test_gep_bitcast_as1( 910; CHECK-NEXT: [[T1:%.*]] = getelementptr i32, i32 addrspace(1)* [[ARR:%.*]], i16 [[N:%.*]] 911; CHECK-NEXT: [[T:%.*]] = bitcast i32 addrspace(1)* [[T1]] to i8 addrspace(1)* 912; CHECK-NEXT: [[X:%.*]] = load i8, i8 addrspace(1)* [[T]], align 1 913; CHECK-NEXT: ret i8 [[X]] 914; 915 %cast = bitcast i32 addrspace(1)* %arr to i8 addrspace(1)* 916 %V = mul i16 %N, 4 917 %t = getelementptr i8, i8 addrspace(1)* %cast, i16 %V 918 %x = load i8, i8 addrspace(1)* %t 919 ret i8 %x 920} 921 922; The element size of the array matches the element size of the pointer 923define i64 @test_gep_bitcast_array_same_size_element([100 x double]* %arr, i64 %N) { 924; CHECK-LABEL: @test_gep_bitcast_array_same_size_element( 925; CHECK-NEXT: [[V:%.*]] = shl i64 [[N:%.*]], 3 926; CHECK-NEXT: [[T1:%.*]] = getelementptr [100 x double], [100 x double]* [[ARR:%.*]], i64 0, i64 [[V]] 927; CHECK-NEXT: [[T:%.*]] = bitcast double* [[T1]] to i64* 928; CHECK-NEXT: [[X:%.*]] = load i64, i64* [[T]], align 4 929; CHECK-NEXT: ret i64 [[X]] 930; 931 %cast = bitcast [100 x double]* %arr to i64* 932 %V = mul i64 %N, 8 933 %t = getelementptr i64, i64* %cast, i64 %V 934 %x = load i64, i64* %t 935 ret i64 %x 936} 937 938; gep should be done in the original address space. 939define i64 @test_gep_bitcast_array_same_size_element_addrspacecast([100 x double]* %arr, i64 %N) { 940; CHECK-LABEL: @test_gep_bitcast_array_same_size_element_addrspacecast( 941; CHECK-NEXT: [[V:%.*]] = shl i64 [[N:%.*]], 3 942; CHECK-NEXT: [[T1:%.*]] = getelementptr [100 x double], [100 x double]* [[ARR:%.*]], i64 0, i64 [[V]] 943; CHECK-NEXT: [[TMP1:%.*]] = bitcast double* [[T1]] to i64* 944; CHECK-NEXT: [[T:%.*]] = addrspacecast i64* [[TMP1]] to i64 addrspace(3)* 945; CHECK-NEXT: [[X:%.*]] = load i64, i64 addrspace(3)* [[T]], align 4 946; CHECK-NEXT: ret i64 [[X]] 947; 948 %cast = addrspacecast [100 x double]* %arr to i64 addrspace(3)* 949 %V = mul i64 %N, 8 950 %t = getelementptr i64, i64 addrspace(3)* %cast, i64 %V 951 %x = load i64, i64 addrspace(3)* %t 952 ret i64 %x 953} 954 955; The element size of the array is different the element size of the pointer 956define i8 @test_gep_bitcast_array_different_size_element([100 x double]* %arr, i64 %N) { 957; CHECK-LABEL: @test_gep_bitcast_array_different_size_element( 958; CHECK-NEXT: [[T1:%.*]] = getelementptr [100 x double], [100 x double]* [[ARR:%.*]], i64 0, i64 [[N:%.*]] 959; CHECK-NEXT: [[T:%.*]] = bitcast double* [[T1]] to i8* 960; CHECK-NEXT: [[X:%.*]] = load i8, i8* [[T]], align 1 961; CHECK-NEXT: ret i8 [[X]] 962; 963 %cast = bitcast [100 x double]* %arr to i8* 964 %V = mul i64 %N, 8 965 %t = getelementptr i8, i8* %cast, i64 %V 966 %x = load i8, i8* %t 967 ret i8 %x 968} 969 970define i64 @test_gep_bitcast_array_same_size_element_as1([100 x double] addrspace(1)* %arr, i16 %N) { 971; CHECK-LABEL: @test_gep_bitcast_array_same_size_element_as1( 972; CHECK-NEXT: [[V:%.*]] = shl i16 [[N:%.*]], 3 973; CHECK-NEXT: [[T1:%.*]] = getelementptr [100 x double], [100 x double] addrspace(1)* [[ARR:%.*]], i16 0, i16 [[V]] 974; CHECK-NEXT: [[T:%.*]] = bitcast double addrspace(1)* [[T1]] to i64 addrspace(1)* 975; CHECK-NEXT: [[X:%.*]] = load i64, i64 addrspace(1)* [[T]], align 4 976; CHECK-NEXT: ret i64 [[X]] 977; 978 %cast = bitcast [100 x double] addrspace(1)* %arr to i64 addrspace(1)* 979 %V = mul i16 %N, 8 980 %t = getelementptr i64, i64 addrspace(1)* %cast, i16 %V 981 %x = load i64, i64 addrspace(1)* %t 982 ret i64 %x 983} 984 985define i8 @test_gep_bitcast_array_different_size_element_as1([100 x double] addrspace(1)* %arr, i16 %N) { 986; CHECK-LABEL: @test_gep_bitcast_array_different_size_element_as1( 987; CHECK-NEXT: [[T1:%.*]] = getelementptr [100 x double], [100 x double] addrspace(1)* [[ARR:%.*]], i16 0, i16 [[N:%.*]] 988; CHECK-NEXT: [[T:%.*]] = bitcast double addrspace(1)* [[T1]] to i8 addrspace(1)* 989; CHECK-NEXT: [[X:%.*]] = load i8, i8 addrspace(1)* [[T]], align 1 990; CHECK-NEXT: ret i8 [[X]] 991; 992 %cast = bitcast [100 x double] addrspace(1)* %arr to i8 addrspace(1)* 993 %V = mul i16 %N, 8 994 %t = getelementptr i8, i8 addrspace(1)* %cast, i16 %V 995 %x = load i8, i8 addrspace(1)* %t 996 ret i8 %x 997} 998 999define i64 @test40() { 1000; CHECK-LABEL: @test40( 1001; CHECK-NEXT: ret i64 8 1002; 1003 %array = alloca [3 x i32], align 4 1004 %gep = getelementptr inbounds [3 x i32], [3 x i32]* %array, i64 0, i64 2 1005 %gepi8 = bitcast i32* %gep to i8* 1006 %p = ptrtoint [3 x i32]* %array to i64 1007 %np = sub i64 0, %p 1008 %gep2 = getelementptr i8, i8* %gepi8, i64 %np 1009 %ret = ptrtoint i8* %gep2 to i64 1010 ret i64 %ret 1011 1012} 1013 1014define i16 @test41([3 x i32] addrspace(1)* %array) { 1015; CHECK-LABEL: @test41( 1016; CHECK-NEXT: ret i16 8 1017; 1018 %gep = getelementptr inbounds [3 x i32], [3 x i32] addrspace(1)* %array, i16 0, i16 2 1019 %gepi8 = bitcast i32 addrspace(1)* %gep to i8 addrspace(1)* 1020 %p = ptrtoint [3 x i32] addrspace(1)* %array to i16 1021 %np = sub i16 0, %p 1022 %gep2 = getelementptr i8, i8 addrspace(1)* %gepi8, i16 %np 1023 %ret = ptrtoint i8 addrspace(1)* %gep2 to i16 1024 ret i16 %ret 1025 1026} 1027 1028define i8* @test42(i8* %c1, i8* %c2) { 1029; CHECK-LABEL: @test42( 1030; CHECK-NEXT: [[PTRTOINT:%.*]] = ptrtoint i8* [[C1:%.*]] to i64 1031; CHECK-NEXT: [[TMP1:%.*]] = ptrtoint i8* [[C2:%.*]] to i64 1032; CHECK-NEXT: [[TMP2:%.*]] = sub i64 [[TMP1]], [[PTRTOINT]] 1033; CHECK-NEXT: [[GEP:%.*]] = inttoptr i64 [[TMP2]] to i8* 1034; CHECK-NEXT: ret i8* [[GEP]] 1035; 1036 %ptrtoint = ptrtoint i8* %c1 to i64 1037 %sub = sub i64 0, %ptrtoint 1038 %gep = getelementptr inbounds i8, i8* %c2, i64 %sub 1039 ret i8* %gep 1040 1041} 1042 1043define i16* @test43(i16* %c1, i16* %c2) { 1044; CHECK-LABEL: @test43( 1045; CHECK-NEXT: [[PTRTOINT:%.*]] = ptrtoint i16* [[C1:%.*]] to i64 1046; CHECK-NEXT: [[TMP1:%.*]] = ptrtoint i16* [[C2:%.*]] to i64 1047; CHECK-NEXT: [[TMP2:%.*]] = sub i64 [[TMP1]], [[PTRTOINT]] 1048; CHECK-NEXT: [[GEP:%.*]] = inttoptr i64 [[TMP2]] to i16* 1049; CHECK-NEXT: ret i16* [[GEP]] 1050; 1051 %ptrtoint = ptrtoint i16* %c1 to i64 1052 %sub = sub i64 0, %ptrtoint 1053 %shr = ashr i64 %sub, 1 1054 %gep = getelementptr inbounds i16, i16* %c2, i64 %shr 1055 ret i16* %gep 1056 1057} 1058 1059define %struct.C* @test44(%struct.C* %c1, %struct.C* %c2) { 1060; CHECK-LABEL: @test44( 1061; CHECK-NEXT: [[PTRTOINT:%.*]] = ptrtoint %struct.C* [[C1:%.*]] to i64 1062; CHECK-NEXT: [[TMP1:%.*]] = ptrtoint %struct.C* [[C2:%.*]] to i64 1063; CHECK-NEXT: [[TMP2:%.*]] = sub i64 [[TMP1]], [[PTRTOINT]] 1064; CHECK-NEXT: [[GEP:%.*]] = inttoptr i64 [[TMP2]] to %struct.C* 1065; CHECK-NEXT: ret %struct.C* [[GEP]] 1066; 1067 %ptrtoint = ptrtoint %struct.C* %c1 to i64 1068 %sub = sub i64 0, %ptrtoint 1069 %shr = sdiv i64 %sub, 7 1070 %gep = getelementptr inbounds %struct.C, %struct.C* %c2, i64 %shr 1071 ret %struct.C* %gep 1072 1073} 1074 1075define %struct.C* @test45(%struct.C* %c1, %struct.C** %c2) { 1076; CHECK-LABEL: @test45( 1077; CHECK-NEXT: [[GEP:%.*]] = bitcast %struct.C** [[C2:%.*]] to %struct.C* 1078; CHECK-NEXT: ret %struct.C* [[GEP]] 1079; 1080 %ptrtoint1 = ptrtoint %struct.C* %c1 to i64 1081 %ptrtoint2 = ptrtoint %struct.C** %c2 to i64 1082 %sub = sub i64 %ptrtoint2, %ptrtoint1 ; C2 - C1 1083 %shr = sdiv i64 %sub, 7 1084 %gep = getelementptr inbounds %struct.C, %struct.C* %c1, i64 %shr ; C1 + (C2 - C1) 1085 ret %struct.C* %gep 1086 1087} 1088 1089define %struct.C* @test46(%struct.C* %c1, %struct.C* %c2, i64 %N) { 1090; CHECK-LABEL: @test46( 1091; CHECK-NEXT: [[PTRTOINT:%.*]] = ptrtoint %struct.C* [[C1:%.*]] to i64 1092; CHECK-NEXT: [[SUB:%.*]] = sub i64 0, [[PTRTOINT]] 1093; CHECK-NEXT: [[SDIV:%.*]] = sdiv i64 [[SUB]], [[N:%.*]] 1094; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds [[STRUCT_C:%.*]], %struct.C* [[C2:%.*]], i64 [[SDIV]] 1095; CHECK-NEXT: ret %struct.C* [[GEP]] 1096; 1097 %ptrtoint = ptrtoint %struct.C* %c1 to i64 1098 %sub = sub i64 0, %ptrtoint 1099 %sdiv = sdiv i64 %sub, %N 1100 %gep = getelementptr inbounds %struct.C, %struct.C* %c2, i64 %sdiv 1101 ret %struct.C* %gep 1102 1103} 1104 1105define i32* @test47(i32* %I, i64 %C, i64 %D) { 1106; CHECK-LABEL: @test47( 1107; CHECK-NEXT: [[B:%.*]] = getelementptr i32, i32* [[I:%.*]], i64 [[D:%.*]] 1108; CHECK-NEXT: ret i32* [[B]] 1109; 1110 %sub = sub i64 %D, %C 1111 %A = getelementptr i32, i32* %I, i64 %C 1112 %B = getelementptr i32, i32* %A, i64 %sub 1113 ret i32* %B 1114} 1115 1116define i32* @test48(i32* %I, i64 %C, i64 %D) { 1117; CHECK-LABEL: @test48( 1118; CHECK-NEXT: [[B:%.*]] = getelementptr i32, i32* [[I:%.*]], i64 [[D:%.*]] 1119; CHECK-NEXT: ret i32* [[B]] 1120; 1121 %sub = sub i64 %D, %C 1122 %A = getelementptr i32, i32* %I, i64 %sub 1123 %B = getelementptr i32, i32* %A, i64 %C 1124 ret i32* %B 1125} 1126 1127define i32* @test49(i32* %I, i64 %C) { 1128; CHECK-LABEL: @test49( 1129; CHECK-NEXT: [[B:%.*]] = getelementptr i32, i32* [[I:%.*]], i64 -1 1130; CHECK-NEXT: ret i32* [[B]] 1131; 1132 %notC = xor i64 -1, %C 1133 %A = getelementptr i32, i32* %I, i64 %C 1134 %B = getelementptr i32, i32* %A, i64 %notC 1135 ret i32* %B 1136} 1137 1138define i32 addrspace(1)* @ascast_0_gep(i32* %p) nounwind { 1139; CHECK-LABEL: @ascast_0_gep( 1140; CHECK-NEXT: [[X:%.*]] = addrspacecast i32* [[P:%.*]] to i32 addrspace(1)* 1141; CHECK-NEXT: ret i32 addrspace(1)* [[X]] 1142; 1143 %gep = getelementptr i32, i32* %p, i32 0 1144 %x = addrspacecast i32* %gep to i32 addrspace(1)* 1145 ret i32 addrspace(1)* %x 1146} 1147 1148; Do not merge the GEP and the addrspacecast, because it would undo the 1149; addrspacecast canonicalization. 1150define i32 addrspace(1)* @ascast_0_0_gep([128 x i32]* %p) nounwind { 1151; CHECK-LABEL: @ascast_0_0_gep( 1152; CHECK-NEXT: [[GEP:%.*]] = getelementptr [128 x i32], [128 x i32]* [[P:%.*]], i64 0, i64 0 1153; CHECK-NEXT: [[X:%.*]] = addrspacecast i32* [[GEP]] to i32 addrspace(1)* 1154; CHECK-NEXT: ret i32 addrspace(1)* [[X]] 1155; 1156 %gep = getelementptr [128 x i32], [128 x i32]* %p, i32 0, i32 0 1157 %x = addrspacecast i32* %gep to i32 addrspace(1)* 1158 ret i32 addrspace(1)* %x 1159} 1160 1161define <2 x i32*> @PR32414(i32** %ptr) { 1162; CHECK-LABEL: @PR32414( 1163; CHECK-NEXT: [[TMP0:%.*]] = bitcast i32** [[PTR:%.*]] to i32* 1164; CHECK-NEXT: [[TMP1:%.*]] = getelementptr inbounds i32, i32* [[TMP0]], <2 x i64> <i64 0, i64 1> 1165; CHECK-NEXT: ret <2 x i32*> [[TMP1]] 1166; 1167 %tmp0 = bitcast i32** %ptr to i32* 1168 %tmp1 = getelementptr inbounds i32, i32* %tmp0, <2 x i64> <i64 0, i64 1> 1169 ret <2 x i32*> %tmp1 1170} 1171 1172define i32* @test_bitcast_nzgep([1 x i32]* %base, i64 %idx) { 1173; CHECK-LABEL: @test_bitcast_nzgep( 1174; CHECK-NEXT: [[PTR:%.*]] = getelementptr inbounds [1 x i32], [1 x i32]* [[BASE:%.*]], i64 0, i64 [[IDX:%.*]] 1175; CHECK-NEXT: ret i32* [[PTR]] 1176; 1177 %base2 = bitcast [1 x i32]* %base to i32* 1178 %ptr = getelementptr inbounds i32, i32* %base2, i64 %idx 1179 ret i32* %ptr 1180} 1181 1182define i32* @test_zgep_nzgep([1 x i32]* %base, i64 %idx) { 1183; CHECK-LABEL: @test_zgep_nzgep( 1184; CHECK-NEXT: [[PTR:%.*]] = getelementptr inbounds [1 x i32], [1 x i32]* [[BASE:%.*]], i64 0, i64 [[IDX:%.*]] 1185; CHECK-NEXT: ret i32* [[PTR]] 1186; 1187 %base2 = getelementptr [1 x i32], [1 x i32]* %base, i64 0, i64 0 1188 %ptr = getelementptr inbounds i32, i32* %base2, i64 %idx 1189 ret i32* %ptr 1190} 1191 1192define i32* @test_nzgep_zgep([1 x i32]* %base, i64 %idx) { 1193; CHECK-LABEL: @test_nzgep_zgep( 1194; CHECK-NEXT: [[PTR:%.*]] = getelementptr inbounds [1 x i32], [1 x i32]* [[BASE:%.*]], i64 [[IDX:%.*]], i64 0 1195; CHECK-NEXT: ret i32* [[PTR]] 1196; 1197 %base2 = getelementptr inbounds [1 x i32], [1 x i32]* %base, i64 %idx 1198 %ptr = getelementptr [1 x i32], [1 x i32]* %base2, i64 0, i64 0 1199 ret i32* %ptr 1200} 1201 1202define i32* @test_gep_inbounds_of_gep(i32* %base) { 1203; CHECK-LABEL: @test_gep_inbounds_of_gep( 1204; CHECK-NEXT: [[PTR2:%.*]] = getelementptr i32, i32* [[BASE:%.*]], i64 8 1205; CHECK-NEXT: ret i32* [[PTR2]] 1206; 1207 %ptr1 = getelementptr i32, i32* %base, i64 4 1208 %ptr2 = getelementptr inbounds i32, i32* %ptr1, i64 4 1209 ret i32* %ptr2 1210} 1211 1212%struct.f = type { i32 } 1213 1214@g0 = internal unnamed_addr constant %struct.f zeroinitializer, align 4 1215@g1 = internal unnamed_addr constant %struct.f { i32 -1 }, align 4 1216 1217define i32* @PR45084(i1 %cond) { 1218; CHECK-LABEL: @PR45084( 1219; CHECK-NEXT: [[GEP:%.*]] = select i1 [[COND:%.*]], i32* getelementptr inbounds (%struct.f, %struct.f* @g0, i64 0, i32 0), i32* getelementptr inbounds (%struct.f, %struct.f* @g1, i64 0, i32 0), !prof !0 1220; CHECK-NEXT: ret i32* [[GEP]] 1221; 1222 %sel = select i1 %cond, %struct.f* @g0, %struct.f* @g1, !prof !0 1223 %gep = getelementptr inbounds %struct.f, %struct.f* %sel, i64 0, i32 0 1224 ret i32* %gep 1225} 1226 1227define i32* @PR45084_extra_use(i1 %cond, %struct.f** %p) { 1228; CHECK-LABEL: @PR45084_extra_use( 1229; CHECK-NEXT: [[SEL:%.*]] = select i1 [[COND:%.*]], %struct.f* @g0, %struct.f* @g1 1230; CHECK-NEXT: store %struct.f* [[SEL]], %struct.f** [[P:%.*]], align 8 1231; CHECK-NEXT: [[GEP:%.*]] = select i1 [[COND]], i32* getelementptr inbounds (%struct.f, %struct.f* @g0, i64 0, i32 0), i32* getelementptr inbounds (%struct.f, %struct.f* @g1, i64 0, i32 0) 1232; CHECK-NEXT: ret i32* [[GEP]] 1233; 1234 %sel = select i1 %cond, %struct.f* @g0, %struct.f* @g1 1235 store %struct.f* %sel, %struct.f** %p 1236 %gep = getelementptr %struct.f, %struct.f* %sel, i64 0, i32 0 1237 ret i32* %gep 1238} 1239 1240!0 = !{!"branch_weights", i32 2, i32 10} 1241