1; NOTE: Assertions have been autogenerated by utils/update_test_checks.py 2; RUN: opt < %s -passes=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: [[T4:%.*]] = icmp eq { i32, i32 }* [[X:%.*]], [[Y:%.*]] 150; CHECK-NEXT: ret i1 [[T4]] 151; 152 %t1 = getelementptr { i32, i32 }, { i32, i32 }* %x, i32 0, i32 1 153 %t3 = getelementptr { i32, i32 }, { i32, i32 }* %y, i32 0, i32 1 154 %t4 = icmp eq i32* %t1, %t3 155 ret i1 %t4 156} 157 158define i1 @test10_addrspacecast({ i32, i32 }* %x, { i32, i32 } addrspace(3)* %y) { 159; CHECK-LABEL: @test10_addrspacecast( 160; CHECK-NEXT: [[T1:%.*]] = getelementptr { i32, i32 }, { i32, i32 }* [[X:%.*]], i64 0, i32 1 161; CHECK-NEXT: [[T3:%.*]] = getelementptr { i32, i32 }, { i32, i32 } addrspace(3)* [[Y:%.*]], i64 0, i32 1 162; CHECK-NEXT: [[T3_C:%.*]] = addrspacecast i32 addrspace(3)* [[T3]] to i32* 163; CHECK-NEXT: [[T4:%.*]] = icmp eq i32* [[T1]], [[T3_C]] 164; CHECK-NEXT: ret i1 [[T4]] 165; 166 %t1 = getelementptr { i32, i32 }, { i32, i32 }* %x, i32 0, i32 1 167 %t3 = getelementptr { i32, i32 }, { i32, i32 } addrspace(3)* %y, i32 0, i32 1 168 %t3.c = addrspacecast i32 addrspace(3)* %t3 to i32* 169 %t4 = icmp eq i32* %t1, %t3.c 170 ret i1 %t4 171} 172 173define i1 @test11({ i32, i32 }* %X) { 174; CHECK-LABEL: @test11( 175; CHECK-NEXT: [[Q:%.*]] = icmp eq { i32, i32 }* [[X:%.*]], null 176; CHECK-NEXT: ret i1 [[Q]] 177; 178 %P = getelementptr { i32, i32 }, { i32, i32 }* %X, i32 0, i32 0 179 %Q = icmp eq i32* %P, null 180 ret i1 %Q 181} 182 183 184; PR4748 185define i32 @test12(%struct.A* %a) { 186; CHECK-LABEL: @test12( 187; CHECK-NEXT: entry: 188; CHECK-NEXT: [[G3:%.*]] = getelementptr [[STRUCT_A:%.*]], %struct.A* [[A:%.*]], i64 0, i32 1 189; CHECK-NEXT: store i32 10, i32* [[G3]], align 4 190; CHECK-NEXT: ret i32 10 191; 192entry: 193 %g3 = getelementptr %struct.A, %struct.A* %a, i32 0, i32 1 194 store i32 10, i32* %g3, align 4 195 196 %g4 = getelementptr %struct.A, %struct.A* %a, i32 0, i32 0 197 198 %new_a = bitcast %struct.B* %g4 to %struct.A* 199 200 %g5 = getelementptr %struct.A, %struct.A* %new_a, i32 0, i32 1 201 %a_a = load i32, i32* %g5, align 4 202 ret i32 %a_a 203} 204 205 206; PR2235 207%S = type { i32, [ 100 x i32] } 208define i1 @test13(i64 %X, %S* %P) { 209; CHECK-LABEL: @test13( 210; CHECK-NEXT: [[C:%.*]] = icmp eq i64 [[X:%.*]], -1 211; CHECK-NEXT: ret i1 [[C]] 212; 213 %A = getelementptr inbounds %S, %S* %P, i32 0, i32 1, i64 %X 214 %B = getelementptr inbounds %S, %S* %P, i32 0, i32 0 215 %C = icmp eq i32* %A, %B 216 ret i1 %C 217} 218 219define <2 x i1> @test13_vector(<2 x i64> %X, <2 x %S*> %P) nounwind { 220; CHECK-LABEL: @test13_vector( 221; CHECK-NEXT: [[C:%.*]] = icmp eq <2 x i64> [[X:%.*]], <i64 -1, i64 -1> 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>, <2 x 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 230define <2 x i1> @test13_vector2(i64 %X, <2 x %S*> %P) nounwind { 231; CHECK-LABEL: @test13_vector2( 232; CHECK-NEXT: [[DOTSPLATINSERT:%.*]] = insertelement <2 x i64> poison, i64 [[X:%.*]], i64 0 233; CHECK-NEXT: [[TMP1:%.*]] = shl <2 x i64> [[DOTSPLATINSERT]], <i64 2, i64 0> 234; CHECK-NEXT: [[TMP2:%.*]] = icmp eq <2 x i64> [[TMP1]], <i64 -4, i64 poison> 235; CHECK-NEXT: [[C:%.*]] = shufflevector <2 x i1> [[TMP2]], <2 x i1> poison, <2 x i32> zeroinitializer 236; CHECK-NEXT: ret <2 x i1> [[C]] 237; 238 %A = getelementptr inbounds %S, <2 x %S*> %P, <2 x i64> zeroinitializer, <2 x i32> <i32 1, i32 1>, i64 %X 239 %B = getelementptr inbounds %S, <2 x %S*> %P, <2 x i64> <i64 0, i64 0>, <2 x i32> <i32 0, i32 0> 240 %C = icmp eq <2 x i32*> %A, %B 241 ret <2 x i1> %C 242} 243 244; This is a test of icmp + shl nuw in disguise - 4611... is 0x3fff... 245define <2 x i1> @test13_vector3(i64 %X, <2 x %S*> %P) nounwind { 246; CHECK-LABEL: @test13_vector3( 247; CHECK-NEXT: [[DOTSPLATINSERT:%.*]] = insertelement <2 x i64> poison, i64 [[X:%.*]], i64 0 248; CHECK-NEXT: [[TMP1:%.*]] = shl <2 x i64> [[DOTSPLATINSERT]], <i64 2, i64 0> 249; CHECK-NEXT: [[TMP2:%.*]] = icmp eq <2 x i64> [[TMP1]], <i64 4, i64 poison> 250; CHECK-NEXT: [[C:%.*]] = shufflevector <2 x i1> [[TMP2]], <2 x i1> poison, <2 x i32> zeroinitializer 251; CHECK-NEXT: ret <2 x i1> [[C]] 252; 253 %A = getelementptr inbounds %S, <2 x %S*> %P, <2 x i64> zeroinitializer, <2 x i32> <i32 1, i32 1>, i64 %X 254 %B = getelementptr inbounds %S, <2 x %S*> %P, <2 x i64> <i64 0, i64 0>, <2 x i32> <i32 1, i32 1>, i64 1 255 %C = icmp eq <2 x i32*> %A, %B 256 ret <2 x i1> %C 257} 258 259define i1 @test13_as1(i16 %X, %S addrspace(1)* %P) { 260; CHECK-LABEL: @test13_as1( 261; CHECK-NEXT: [[C:%.*]] = icmp eq i16 [[X:%.*]], -1 262; CHECK-NEXT: ret i1 [[C]] 263; 264 %A = getelementptr inbounds %S, %S addrspace(1)* %P, i16 0, i32 1, i16 %X 265 %B = getelementptr inbounds %S, %S addrspace(1)* %P, i16 0, i32 0 266 %C = icmp eq i32 addrspace(1)* %A, %B 267 ret i1 %C 268} 269 270define <2 x i1> @test13_vector_as1(<2 x i16> %X, <2 x %S addrspace(1)*> %P) { 271; CHECK-LABEL: @test13_vector_as1( 272; CHECK-NEXT: [[C:%.*]] = icmp eq <2 x i16> [[X:%.*]], <i16 -1, i16 -1> 273; CHECK-NEXT: ret <2 x i1> [[C]] 274; 275 %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 276 %B = getelementptr inbounds %S, <2 x %S addrspace(1)*> %P, <2 x i16> <i16 0, i16 0>, <2 x i32> <i32 0, i32 0> 277 %C = icmp eq <2 x i32 addrspace(1)*> %A, %B 278 ret <2 x i1> %C 279} 280 281define i1 @test13_i32(i32 %X, %S* %P) { 282; CHECK-LABEL: @test13_i32( 283; CHECK-NEXT: [[C:%.*]] = icmp eq i32 [[X:%.*]], -1 284; CHECK-NEXT: ret i1 [[C]] 285; 286 %A = getelementptr inbounds %S, %S* %P, i32 0, i32 1, i32 %X 287 %B = getelementptr inbounds %S, %S* %P, i32 0, i32 0 288 %C = icmp eq i32* %A, %B 289 ret i1 %C 290} 291 292define i1 @test13_i16(i16 %X, %S* %P) { 293; CHECK-LABEL: @test13_i16( 294; CHECK-NEXT: [[C:%.*]] = icmp eq i16 [[X:%.*]], -1 295; CHECK-NEXT: ret i1 [[C]] 296; 297 %A = getelementptr inbounds %S, %S* %P, i16 0, i32 1, i16 %X 298 %B = getelementptr inbounds %S, %S* %P, i16 0, i32 0 299 %C = icmp eq i32* %A, %B 300 ret i1 %C 301} 302 303define i1 @test13_i128(i128 %X, %S* %P) { 304; CHECK-LABEL: @test13_i128( 305; CHECK-NEXT: [[TMP1:%.*]] = trunc i128 [[X:%.*]] to i64 306; CHECK-NEXT: [[C:%.*]] = icmp eq i64 [[TMP1]], -1 307; CHECK-NEXT: ret i1 [[C]] 308; 309 %A = getelementptr inbounds %S, %S* %P, i128 0, i32 1, i128 %X 310 %B = getelementptr inbounds %S, %S* %P, i128 0, i32 0 311 %C = icmp eq i32* %A, %B 312 ret i1 %C 313} 314 315 316@G = external global [3 x i8] 317define i8* @test14(i32 %idx) { 318; CHECK-LABEL: @test14( 319; CHECK-NEXT: [[ZEXT:%.*]] = zext i32 [[IDX:%.*]] to i64 320; CHECK-NEXT: [[T:%.*]] = getelementptr [3 x i8], [3 x i8]* @G, i64 0, i64 [[ZEXT]] 321; CHECK-NEXT: ret i8* [[T]] 322; 323 %zext = zext i32 %idx to i64 324 %t = getelementptr i8, i8* getelementptr ([3 x i8], [3 x i8]* @G, i32 0, i32 0), i64 %zext 325 ret i8* %t 326} 327 328 329; Test folding of constantexpr geps into normal geps. 330@Array = external global [40 x i32] 331define i32 *@test15(i64 %X) { 332; CHECK-LABEL: @test15( 333; CHECK-NEXT: [[A:%.*]] = getelementptr [40 x i32], [40 x i32]* @Array, i64 0, i64 [[X:%.*]] 334; CHECK-NEXT: ret i32* [[A]] 335; 336 %A = getelementptr i32, i32* getelementptr ([40 x i32], [40 x i32]* @Array, i64 0, i64 0), i64 %X 337 ret i32* %A 338} 339 340 341define i32* @test16(i32* %X, i32 %Idx) { 342; CHECK-LABEL: @test16( 343; CHECK-NEXT: [[TMP1:%.*]] = sext i32 [[IDX:%.*]] to i64 344; CHECK-NEXT: [[R:%.*]] = getelementptr i32, i32* [[X:%.*]], i64 [[TMP1]] 345; CHECK-NEXT: ret i32* [[R]] 346; 347 %R = getelementptr i32, i32* %X, i32 %Idx 348 ret i32* %R 349} 350 351 352define i1 @test17(i16* %P, i32 %I, i32 %J) { 353; CHECK-LABEL: @test17( 354; CHECK-NEXT: [[C:%.*]] = icmp slt i32 [[I:%.*]], [[J:%.*]] 355; CHECK-NEXT: ret i1 [[C]] 356; 357 %X = getelementptr inbounds i16, i16* %P, i32 %I 358 %Y = getelementptr inbounds i16, i16* %P, i32 %J 359 %C = icmp ult i16* %X, %Y 360 ret i1 %C 361} 362 363define i1 @test18(i16* %P, i32 %I) { 364; CHECK-LABEL: @test18( 365; CHECK-NEXT: [[C:%.*]] = icmp slt i32 [[I:%.*]], 0 366; CHECK-NEXT: ret i1 [[C]] 367; 368 %X = getelementptr inbounds i16, i16* %P, i32 %I 369 %C = icmp ult i16* %X, %P 370 ret i1 %C 371} 372 373; Larger than the pointer size for a non-zero address space 374define i1 @test18_as1(i16 addrspace(1)* %P, i32 %I) { 375; CHECK-LABEL: @test18_as1( 376; CHECK-NEXT: [[TMP1:%.*]] = and i32 [[I:%.*]], 32768 377; CHECK-NEXT: [[C:%.*]] = icmp ne i32 [[TMP1]], 0 378; CHECK-NEXT: ret i1 [[C]] 379; 380 %X = getelementptr inbounds i16, i16 addrspace(1)* %P, i32 %I 381 %C = icmp ult i16 addrspace(1)* %X, %P 382 ret i1 %C 383} 384 385; Smaller than the pointer size for a non-zero address space 386define i1 @test18_as1_i32(i16 addrspace(1)* %P, i32 %I) { 387; CHECK-LABEL: @test18_as1_i32( 388; CHECK-NEXT: [[TMP1:%.*]] = and i32 [[I:%.*]], 32768 389; CHECK-NEXT: [[C:%.*]] = icmp ne i32 [[TMP1]], 0 390; CHECK-NEXT: ret i1 [[C]] 391; 392 %X = getelementptr inbounds i16, i16 addrspace(1)* %P, i32 %I 393 %C = icmp ult i16 addrspace(1)* %X, %P 394 ret i1 %C 395} 396 397; Smaller than pointer size 398define i1 @test18_i16(i16* %P, i16 %I) { 399; CHECK-LABEL: @test18_i16( 400; CHECK-NEXT: [[C:%.*]] = icmp slt i16 [[I:%.*]], 0 401; CHECK-NEXT: ret i1 [[C]] 402; 403 %X = getelementptr inbounds i16, i16* %P, i16 %I 404 %C = icmp ult i16* %X, %P 405 ret i1 %C 406} 407 408; Same as pointer size 409define i1 @test18_i64(i16* %P, i64 %I) { 410; CHECK-LABEL: @test18_i64( 411; CHECK-NEXT: [[C:%.*]] = icmp slt i64 [[I:%.*]], 0 412; CHECK-NEXT: ret i1 [[C]] 413; 414 %X = getelementptr inbounds i16, i16* %P, i64 %I 415 %C = icmp ult i16* %X, %P 416 ret i1 %C 417} 418 419; Larger than the pointer size 420define i1 @test18_i128(i16* %P, i128 %I) { 421; CHECK-LABEL: @test18_i128( 422; CHECK-NEXT: [[TMP1:%.*]] = and i128 [[I:%.*]], 9223372036854775808 423; CHECK-NEXT: [[C:%.*]] = icmp ne i128 [[TMP1]], 0 424; CHECK-NEXT: ret i1 [[C]] 425; 426 %X = getelementptr inbounds i16, i16* %P, i128 %I 427 %C = icmp ult i16* %X, %P 428 ret i1 %C 429} 430 431define i32 @test19(i32* %P, i32 %A, i32 %B) { 432; CHECK-LABEL: @test19( 433; CHECK-NEXT: [[T10:%.*]] = icmp eq i32 [[A:%.*]], [[B:%.*]] 434; CHECK-NEXT: [[T11:%.*]] = zext i1 [[T10]] to i32 435; CHECK-NEXT: ret i32 [[T11]] 436; 437 %t4 = getelementptr inbounds i32, i32* %P, i32 %A 438 %t9 = getelementptr inbounds i32, i32* %P, i32 %B 439 %t10 = icmp eq i32* %t4, %t9 440 %t11 = zext i1 %t10 to i32 441 ret i32 %t11 442} 443 444define i32 @test20(i32* %P, i32 %A, i32 %B) { 445; CHECK-LABEL: @test20( 446; CHECK-NEXT: [[T6:%.*]] = icmp eq i32 [[A:%.*]], 0 447; CHECK-NEXT: [[T7:%.*]] = zext i1 [[T6]] to i32 448; CHECK-NEXT: ret i32 [[T7]] 449; 450 %t4 = getelementptr inbounds i32, i32* %P, i32 %A 451 %t6 = icmp eq i32* %t4, %P 452 %t7 = zext i1 %t6 to i32 453 ret i32 %t7 454} 455 456define i32 @test20_as1(i32 addrspace(1)* %P, i32 %A, i32 %B) { 457; CHECK-LABEL: @test20_as1( 458; CHECK-NEXT: [[TMP1:%.*]] = trunc i32 [[A:%.*]] to i16 459; CHECK-NEXT: [[T6:%.*]] = icmp eq i16 [[TMP1]], 0 460; CHECK-NEXT: [[T7:%.*]] = zext i1 [[T6]] to i32 461; CHECK-NEXT: ret i32 [[T7]] 462; 463 %t4 = getelementptr inbounds i32, i32 addrspace(1)* %P, i32 %A 464 %t6 = icmp eq i32 addrspace(1)* %t4, %P 465 %t7 = zext i1 %t6 to i32 466 ret i32 %t7 467} 468 469 470define i32 @test21() { 471; CHECK-LABEL: @test21( 472; CHECK-NEXT: [[PBOB1:%.*]] = alloca [[INTSTRUCT:%.*]], align 8 473; CHECK-NEXT: [[PBOBEL:%.*]] = getelementptr inbounds [[INTSTRUCT]], %intstruct* [[PBOB1]], i64 0, i32 0 474; CHECK-NEXT: [[RVAL:%.*]] = load i32, i32* [[PBOBEL]], align 8 475; CHECK-NEXT: ret i32 [[RVAL]] 476; 477 %pbob1 = alloca %intstruct 478 %pbob2 = getelementptr %intstruct, %intstruct* %pbob1 479 %pbobel = getelementptr %intstruct, %intstruct* %pbob2, i64 0, i32 0 480 %rval = load i32, i32* %pbobel 481 ret i32 %rval 482} 483 484 485@A = global i32 1 ; <i32*> [#uses=1] 486@B = global i32 2 ; <i32*> [#uses=1] 487 488define i1 @test22() { 489; CHECK-LABEL: @test22( 490; CHECK-NEXT: ret i1 icmp ult (i32* getelementptr inbounds (i32, i32* @A, i64 1), i32* getelementptr (i32, i32* @B, i64 2)) 491; 492 %C = icmp ult i32* getelementptr (i32, i32* @A, i64 1), 493 getelementptr (i32, i32* @B, i64 2) 494 ret i1 %C 495} 496 497 498%X = type { [10 x i32], float } 499 500define i1 @test23() { 501; CHECK-LABEL: @test23( 502; CHECK-NEXT: ret i1 false 503; 504 %A = getelementptr %X, %X* null, i64 0, i32 0, i64 0 ; <i32*> [#uses=1] 505 %B = icmp ne i32* %A, null ; <i1> [#uses=1] 506 ret i1 %B 507} 508 509define void @test25() { 510; CHECK-LABEL: @test25( 511; CHECK-NEXT: entry: 512; CHECK-NEXT: store i64 poison, i64* null, align 4294967296 513; CHECK-NEXT: tail call void @foo25(i32 0, i64 poison) 514; CHECK-NEXT: unreachable 515; 516entry: 517 %t = getelementptr { i64, i64, i64, i64 }, { i64, i64, i64, i64 }* null, i32 0, i32 3 518 %t.upgrd.1 = load i64, i64* %t 519 %t8.ui = load i64, i64* null 520 %t8 = bitcast i64 %t8.ui to i64 521 %t9 = and i64 %t8, %t.upgrd.1 522 %sext = trunc i64 %t9 to i32 523 %t27.i = sext i32 %sext to i64 524 tail call void @foo25( i32 0, i64 %t27.i ) 525 unreachable 526} 527 528declare void @foo25(i32, i64) 529 530 531; PR1637 532define i1 @test26(i8* %arr) { 533; CHECK-LABEL: @test26( 534; CHECK-NEXT: ret i1 true 535; 536 %X = getelementptr i8, i8* %arr, i32 1 537 %Y = getelementptr i8, i8* %arr, i32 1 538 %test = icmp uge i8* %X, %Y 539 ret i1 %test 540} 541 542 %struct.__large_struct = type { [100 x i64] } 543 %struct.compat_siginfo = type { i32, i32, i32, { [29 x i32] } } 544 %struct.siginfo_t = type { i32, i32, i32, { { i32, i32, [0 x i8], %struct.sigval_t, i32 }, [88 x i8] } } 545 %struct.sigval_t = type { i8* } 546 547define i32 @test27(%struct.compat_siginfo* %to, %struct.siginfo_t* %from) { 548; CHECK-LABEL: @test27( 549; CHECK-NEXT: entry: 550; CHECK-NEXT: [[FROM_ADDR:%.*]] = alloca %struct.siginfo_t*, align 8 551; CHECK-NEXT: [[T344:%.*]] = load %struct.siginfo_t*, %struct.siginfo_t** [[FROM_ADDR]], align 8 552; CHECK-NEXT: [[T349:%.*]] = getelementptr [[STRUCT_SIGINFO_T:%.*]], %struct.siginfo_t* [[T344]], i64 0, i32 3, i32 0, i32 3, i32 0 553; CHECK-NEXT: [[T349350:%.*]] = bitcast i8** [[T349]] to i32* 554; CHECK-NEXT: [[T351:%.*]] = load i32, i32* [[T349350]], align 8 555; CHECK-NEXT: [[T360:%.*]] = call i32 asm sideeffect "...", "=r,ir,*m,i,0,~{dirflag},~{fpsr},~{flags}"(i32 [[T351]], %struct.__large_struct* elementtype(%struct.__large_struct) null, i32 -14, i32 0) #[[ATTR0:[0-9]+]] 556; CHECK-NEXT: unreachable 557; 558entry: 559 %from_addr = alloca %struct.siginfo_t* 560 %t344 = load %struct.siginfo_t*, %struct.siginfo_t** %from_addr, align 8 561 %t345 = getelementptr %struct.siginfo_t, %struct.siginfo_t* %t344, i32 0, i32 3 562 %t346 = 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] }* %t345, i32 0, i32 0 563 %t346347 = bitcast { i32, i32, [0 x i8], %struct.sigval_t, i32 }* %t346 to { i32, i32, %struct.sigval_t }* 564 %t348 = getelementptr { i32, i32, %struct.sigval_t }, { i32, i32, %struct.sigval_t }* %t346347, i32 0, i32 2 565 %t349 = getelementptr %struct.sigval_t, %struct.sigval_t* %t348, i32 0, i32 0 566 %t349350 = bitcast i8** %t349 to i32* 567 %t351 = load i32, i32* %t349350, align 8 568 %t360 = call i32 asm sideeffect "...", 569 "=r,ir,*m,i,0,~{dirflag},~{fpsr},~{flags}"( i32 %t351, %struct.__large_struct* elementtype(%struct.__large_struct) null, i32 -14, i32 0 ) 570 unreachable 571} 572 573; PR1978 574 %struct.x = type <{ i8 }> 575@.str = internal constant [6 x i8] c"Main!\00" 576@.str1 = internal constant [12 x i8] c"destroy %p\0A\00" 577 578define i32 @test28() nounwind { 579; CHECK-LABEL: @test28( 580; CHECK-NEXT: entry: 581; CHECK-NEXT: [[ORIENTATIONS:%.*]] = alloca [1 x [1 x %struct.x]], align 8 582; CHECK-NEXT: [[T3:%.*]] = call i32 @puts(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([6 x i8], [6 x i8]* @.str, i64 0, i64 0)) #[[ATTR0]] 583; CHECK-NEXT: br label [[BB10:%.*]] 584; CHECK: bb10: 585; CHECK-NEXT: [[INDVAR:%.*]] = phi i32 [ 0, [[ENTRY:%.*]] ], [ [[INDVAR_NEXT:%.*]], [[BB10]] ] 586; CHECK-NEXT: [[T12_REC:%.*]] = xor i32 [[INDVAR]], -1 587; CHECK-NEXT: [[TMP0:%.*]] = sext i32 [[T12_REC]] to i64 588; CHECK-NEXT: [[T12:%.*]] = getelementptr inbounds [1 x [1 x %struct.x]], [1 x [1 x %struct.x]]* [[ORIENTATIONS]], i64 1, i64 0, i64 [[TMP0]] 589; CHECK-NEXT: [[T16:%.*]] = call i32 (i8*, ...) @printf(i8* noundef nonnull dereferenceable(1) getelementptr inbounds ([12 x i8], [12 x i8]* @.str1, i64 0, i64 0), %struct.x* nonnull [[T12]]) #[[ATTR0]] 590; CHECK-NEXT: [[T84:%.*]] = icmp eq i32 [[INDVAR]], 0 591; CHECK-NEXT: [[INDVAR_NEXT]] = add i32 [[INDVAR]], 1 592; CHECK-NEXT: br i1 [[T84]], label [[BB17:%.*]], label [[BB10]] 593; CHECK: bb17: 594; CHECK-NEXT: ret i32 0 595; 596entry: 597 %orientations = alloca [1 x [1 x %struct.x]] 598 %t3 = call i32 @puts( i8* getelementptr ([6 x i8], [6 x i8]* @.str, i32 0, i32 0) ) nounwind 599 %t45 = getelementptr inbounds [1 x [1 x %struct.x]], [1 x [1 x %struct.x]]* %orientations, i32 1, i32 0, i32 0 600 %orientations62 = getelementptr [1 x [1 x %struct.x]], [1 x [1 x %struct.x]]* %orientations, i32 0, i32 0, i32 0 601 br label %bb10 602 603bb10: 604 %indvar = phi i32 [ 0, %entry ], [ %indvar.next, %bb10 ] 605 %t.0.reg2mem.0.rec = mul i32 %indvar, -1 606 %t12.rec = add i32 %t.0.reg2mem.0.rec, -1 607 %t12 = getelementptr inbounds %struct.x, %struct.x* %t45, i32 %t12.rec 608 %t16 = call i32 (i8*, ...) @printf( i8* nonnull dereferenceable(1) getelementptr ([12 x i8], [12 x i8]* @.str1, i32 0, i32 0), %struct.x* %t12 ) nounwind 609 %t84 = icmp eq %struct.x* %t12, %orientations62 610 %indvar.next = add i32 %indvar, 1 611 br i1 %t84, label %bb17, label %bb10 612 613bb17: 614 ret i32 0 615} 616 617declare i32 @puts(i8*) 618 619declare i32 @printf(i8*, ...) 620 621 622 623 624; rdar://6762290 625 %T = type <{ i64, i64, i64 }> 626define i32 @test29(i8* %start, i32 %X) nounwind { 627; CHECK-LABEL: @test29( 628; CHECK-NEXT: entry: 629; CHECK-NEXT: store i64 poison, i64* null, align 4294967296 630; CHECK-NEXT: br i1 poison, label [[IF_THEN216:%.*]], label [[IF_END363:%.*]] 631; CHECK: if.then216: 632; CHECK-NEXT: ret i32 1 633; CHECK: if.end363: 634; CHECK-NEXT: ret i32 0 635; 636entry: 637 %t3 = load i64, i64* null 638 %add.ptr = getelementptr i8, i8* %start, i64 %t3 639 %t158 = load i32, i32* null 640 %add.ptr159 = getelementptr %T, %T* null, i32 %t158 641 %add.ptr209 = getelementptr i8, i8* %start, i64 0 642 %add.ptr212 = getelementptr i8, i8* %add.ptr209, i32 %X 643 %cmp214 = icmp ugt i8* %add.ptr212, %add.ptr 644 br i1 %cmp214, label %if.then216, label %if.end363 645 646if.then216: 647 ret i32 1 648 649if.end363: 650 ret i32 0 651} 652 653 654; PR3694 655define i32 @test30(i32 %m, i32 %n) nounwind { 656; CHECK-LABEL: @test30( 657; CHECK-NEXT: entry: 658; CHECK-NEXT: [[TMP0:%.*]] = zext i32 [[N:%.*]] to i64 659; CHECK-NEXT: [[TMP1:%.*]] = alloca i32, i64 [[TMP0]], align 4 660; CHECK-NEXT: call void @test30f(i32* nonnull [[TMP1]]) #[[ATTR0]] 661; CHECK-NEXT: [[TMP2:%.*]] = sext i32 [[M:%.*]] to i64 662; CHECK-NEXT: [[TMP3:%.*]] = getelementptr i32, i32* [[TMP1]], i64 [[TMP2]] 663; CHECK-NEXT: [[TMP4:%.*]] = load i32, i32* [[TMP3]], align 4 664; CHECK-NEXT: ret i32 [[TMP4]] 665; 666entry: 667 %0 = alloca i32, i32 %n, align 4 668 %1 = bitcast i32* %0 to [0 x i32]* 669 call void @test30f(i32* %0) nounwind 670 %2 = getelementptr [0 x i32], [0 x i32]* %1, i32 0, i32 %m 671 %3 = load i32, i32* %2, align 4 672 ret i32 %3 673} 674 675declare void @test30f(i32*) 676 677 678 679define i1 @test31(i32* %A) { 680; CHECK-LABEL: @test31( 681; CHECK-NEXT: ret i1 true 682; 683 %B = getelementptr i32, i32* %A, i32 1 684 %C = getelementptr i32, i32* %A, i64 1 685 %V = icmp eq i32* %B, %C 686 ret i1 %V 687} 688 689 690; PR1345 691define i8* @test32(i8* %v) { 692; CHECK-LABEL: @test32( 693; CHECK-NEXT: [[A:%.*]] = alloca [4 x i8*], align 16 694; CHECK-NEXT: [[B:%.*]] = getelementptr inbounds [4 x i8*], [4 x i8*]* [[A]], i64 0, i64 0 695; CHECK-NEXT: store i8* null, i8** [[B]], align 16 696; CHECK-NEXT: [[D:%.*]] = getelementptr inbounds [4 x i8*], [4 x i8*]* [[A]], i64 0, i64 1 697; CHECK-NEXT: store i8* [[V:%.*]], i8** [[D]], align 8 698; CHECK-NEXT: [[F:%.*]] = getelementptr inbounds [4 x i8*], [4 x i8*]* [[A]], i64 0, i64 2 699; CHECK-NEXT: [[G:%.*]] = load i8*, i8** [[F]], align 16 700; CHECK-NEXT: ret i8* [[G]] 701; 702 %A = alloca [4 x i8*], align 16 703 %B = getelementptr [4 x i8*], [4 x i8*]* %A, i32 0, i32 0 704 store i8* null, i8** %B 705 %C = bitcast [4 x i8*]* %A to { [16 x i8] }* 706 %D = getelementptr { [16 x i8] }, { [16 x i8] }* %C, i32 0, i32 0, i32 8 707 %E = bitcast i8* %D to i8** 708 store i8* %v, i8** %E 709 %F = getelementptr [4 x i8*], [4 x i8*]* %A, i32 0, i32 2 710 %G = load i8*, i8** %F 711 ret i8* %G 712} 713 714; PR3290 715%struct.Key = type { { i32, i32 } } 716%struct.anon = type <{ i8, [3 x i8], i32 }> 717 718define i32* @test33(%struct.Key* %A) { 719; CHECK-LABEL: @test33( 720; CHECK-NEXT: [[TMP1:%.*]] = getelementptr [[STRUCT_KEY:%.*]], %struct.Key* [[A:%.*]], i64 0, i32 0, i32 1 721; CHECK-NEXT: ret i32* [[TMP1]] 722; 723 %B = bitcast %struct.Key* %A to %struct.anon* 724 %C = getelementptr %struct.anon, %struct.anon* %B, i32 0, i32 2 725 ret i32* %C 726} 727 728define i32 addrspace(1)* @test33_as1(%struct.Key addrspace(1)* %A) { 729; CHECK-LABEL: @test33_as1( 730; CHECK-NEXT: [[TMP1:%.*]] = getelementptr [[STRUCT_KEY:%.*]], [[STRUCT_KEY]] addrspace(1)* [[A:%.*]], i16 0, i32 0, i32 1 731; CHECK-NEXT: ret i32 addrspace(1)* [[TMP1]] 732; 733 %B = bitcast %struct.Key addrspace(1)* %A to %struct.anon addrspace(1)* 734 %C = getelementptr %struct.anon, %struct.anon addrspace(1)* %B, i32 0, i32 2 735 ret i32 addrspace(1)* %C 736} 737 738define i32 addrspace(1)* @test33_array_as1([10 x i32] addrspace(1)* %A) { 739; CHECK-LABEL: @test33_array_as1( 740; CHECK-NEXT: [[C:%.*]] = getelementptr [10 x i32], [10 x i32] addrspace(1)* [[A:%.*]], i16 0, i16 2 741; CHECK-NEXT: ret i32 addrspace(1)* [[C]] 742; 743 %B = bitcast [10 x i32] addrspace(1)* %A to [5 x i32] addrspace(1)* 744 %C = getelementptr [5 x i32], [5 x i32] addrspace(1)* %B, i32 0, i32 2 745 ret i32 addrspace(1)* %C 746} 747 748; Make sure the GEP indices use the right pointer sized integer 749define i32 addrspace(1)* @test33_array_struct_as1([10 x %struct.Key] addrspace(1)* %A) { 750; CHECK-LABEL: @test33_array_struct_as1( 751; CHECK-NEXT: [[TMP1:%.*]] = getelementptr [10 x %struct.Key], [10 x %struct.Key] addrspace(1)* [[A:%.*]], i16 0, i16 1, i32 0, i32 0 752; CHECK-NEXT: ret i32 addrspace(1)* [[TMP1]] 753; 754 %B = bitcast [10 x %struct.Key] addrspace(1)* %A to [20 x i32] addrspace(1)* 755 %C = getelementptr [20 x i32], [20 x i32] addrspace(1)* %B, i32 0, i32 2 756 ret i32 addrspace(1)* %C 757} 758 759define i32 addrspace(1)* @test33_addrspacecast(%struct.Key* %A) { 760; CHECK-LABEL: @test33_addrspacecast( 761; CHECK-NEXT: [[C:%.*]] = getelementptr [[STRUCT_KEY:%.*]], %struct.Key* [[A:%.*]], i64 0, i32 0, i32 1 762; CHECK-NEXT: [[TMP1:%.*]] = addrspacecast i32* [[C]] to i32 addrspace(1)* 763; CHECK-NEXT: ret i32 addrspace(1)* [[TMP1]] 764; 765 %B = addrspacecast %struct.Key* %A to %struct.anon addrspace(1)* 766 %C = getelementptr %struct.anon, %struct.anon addrspace(1)* %B, i32 0, i32 2 767 ret i32 addrspace(1)* %C 768} 769 770 %T2 = type { i8*, i8 } 771define i8* @test34(i8* %Val, i64 %V) nounwind { 772; CHECK-LABEL: @test34( 773; CHECK-NEXT: entry: 774; CHECK-NEXT: [[C_CAST:%.*]] = inttoptr i64 [[V:%.*]] to i8* 775; CHECK-NEXT: ret i8* [[C_CAST]] 776; 777entry: 778 %A = alloca %T2, align 8 779 %mrv_gep = bitcast %T2* %A to i64* 780 %B = getelementptr %T2, %T2* %A, i64 0, i32 0 781 782 store i64 %V, i64* %mrv_gep 783 %C = load i8*, i8** %B, align 8 784 ret i8* %C 785} 786 787%t0 = type { i8*, [19 x i8] } 788%t1 = type { i8*, [0 x i8] } 789 790@array = external global [11 x i8] 791 792@s = external global %t0 793@"\01LC8" = external constant [17 x i8] 794 795; Instcombine should be able to fold this getelementptr. 796 797define i32 @test35() nounwind { 798; CHECK-LABEL: @test35( 799; CHECK-NEXT: [[TMP1:%.*]] = call i32 (i8*, ...) @printf(i8* noundef 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]] 800; CHECK-NEXT: ret i32 0 801; 802 call i32 (i8*, ...) @printf(i8* getelementptr ([17 x i8], [17 x i8]* @"\01LC8", i32 0, i32 0), 803 i8* getelementptr (%t1, %t1* bitcast (%t0* @s to %t1*), i32 0, i32 1, i32 0)) nounwind 804 ret i32 0 805} 806 807; Don't treat signed offsets as unsigned. 808define i8* @test36() nounwind { 809; CHECK-LABEL: @test36( 810; CHECK-NEXT: ret i8* getelementptr ([11 x i8], [11 x i8]* @array, i64 -1, i64 10) 811; 812 ret i8* getelementptr ([11 x i8], [11 x i8]* @array, i32 0, i64 -1) 813} 814 815; Instcombine shouldn't assume that gep(A,0,1) != gep(A,1,0). 816@A37 = external constant [1 x i8] 817define i1 @test37() nounwind { 818; CHECK-LABEL: @test37( 819; CHECK-NEXT: ret i1 true 820; 821 %t = icmp eq i8* getelementptr ([1 x i8], [1 x i8]* @A37, i64 0, i64 1), 822 getelementptr ([1 x i8], [1 x i8]* @A37, i64 1, i64 0) 823 ret i1 %t 824} 825 826; Test index promotion 827define i32* @test38(i32* %I, i32 %n) { 828; CHECK-LABEL: @test38( 829; CHECK-NEXT: [[TMP1:%.*]] = sext i32 [[N:%.*]] to i64 830; CHECK-NEXT: [[A:%.*]] = getelementptr i32, i32* [[I:%.*]], i64 [[TMP1]] 831; CHECK-NEXT: ret i32* [[A]] 832; 833 %A = getelementptr i32, i32* %I, i32 %n 834 ret i32* %A 835} 836 837; Test that we don't duplicate work when the second gep is a "bitcast". 838%pr10322_t = type { i8* } 839declare void @pr10322_f2(%pr10322_t*) 840declare void @pr10322_f3(i8**) 841define void @pr10322_f1(%pr10322_t* %foo) { 842; CHECK-LABEL: @pr10322_f1( 843; CHECK-NEXT: entry: 844; CHECK-NEXT: [[ARRAYIDX8:%.*]] = getelementptr inbounds [[PR10322_T:%.*]], %pr10322_t* [[FOO:%.*]], i64 2 845; CHECK-NEXT: call void @pr10322_f2(%pr10322_t* nonnull [[ARRAYIDX8]]) #[[ATTR0]] 846; CHECK-NEXT: [[T2:%.*]] = getelementptr inbounds [[PR10322_T]], %pr10322_t* [[ARRAYIDX8]], i64 0, i32 0 847; CHECK-NEXT: call void @pr10322_f3(i8** nonnull [[T2]]) #[[ATTR0]] 848; CHECK-NEXT: ret void 849; 850entry: 851 %arrayidx8 = getelementptr inbounds %pr10322_t, %pr10322_t* %foo, i64 2 852 call void @pr10322_f2(%pr10322_t* %arrayidx8) nounwind 853 %t2 = getelementptr inbounds %pr10322_t, %pr10322_t* %arrayidx8, i64 0, i32 0 854 call void @pr10322_f3(i8** %t2) nounwind 855 ret void 856 857} 858 859; Test that we combine the last two geps in this sequence, before we 860; would wait for gep1 and gep2 to be combined and never combine 2 and 3. 861%three_gep_t = type {i32} 862%three_gep_t2 = type {%three_gep_t} 863 864define void @three_gep_f(%three_gep_t2* %x) { 865; CHECK-LABEL: @three_gep_f( 866; CHECK-NEXT: [[GEP1:%.*]] = getelementptr [[THREE_GEP_T2:%.*]], %three_gep_t2* [[X:%.*]], i64 2 867; CHECK-NEXT: call void @three_gep_h(%three_gep_t2* [[GEP1]]) 868; CHECK-NEXT: [[GEP3:%.*]] = getelementptr [[THREE_GEP_T2]], %three_gep_t2* [[GEP1]], i64 0, i32 0, i32 0 869; CHECK-NEXT: call void @three_gep_g(i32* [[GEP3]]) 870; CHECK-NEXT: ret void 871; 872 %gep1 = getelementptr %three_gep_t2, %three_gep_t2* %x, i64 2 873 call void @three_gep_h(%three_gep_t2* %gep1) 874 %gep2 = getelementptr %three_gep_t2, %three_gep_t2* %gep1, i64 0, i32 0 875 %gep3 = getelementptr %three_gep_t, %three_gep_t* %gep2, i64 0, i32 0 876 call void @three_gep_g(i32* %gep3) 877 878 ret void 879} 880 881declare void @three_gep_g(i32*) 882declare void @three_gep_h(%three_gep_t2*) 883 884%struct.ham = type { i32, %struct.zot*, %struct.zot*, %struct.zot* } 885%struct.zot = type { i64, i8 } 886 887define void @test39(%struct.ham* %arg, i8 %arg1) nounwind { 888; CHECK-LABEL: @test39( 889; CHECK-NEXT: [[T:%.*]] = getelementptr inbounds [[STRUCT_HAM:%.*]], %struct.ham* [[ARG:%.*]], i64 0, i32 2 890; CHECK-NEXT: [[TMP1:%.*]] = bitcast %struct.zot** [[T]] to i8** 891; CHECK-NEXT: [[T21:%.*]] = load i8*, i8** [[TMP1]], align 8 892; CHECK-NEXT: [[T4:%.*]] = getelementptr inbounds i8, i8* [[T21]], i64 -8 893; CHECK-NEXT: store i8 [[ARG1:%.*]], i8* [[T4]], align 8 894; CHECK-NEXT: ret void 895; 896 %t = getelementptr inbounds %struct.ham, %struct.ham* %arg, i64 0, i32 2 897 %t2 = load %struct.zot*, %struct.zot** %t, align 8 898 %t3 = bitcast %struct.zot* %t2 to i8* 899 %t4 = getelementptr inbounds i8, i8* %t3, i64 -8 900 store i8 %arg1, i8* %t4, align 8 901 ret void 902 903} 904 905define i1 @pr16483([1 x i8]* %a, [1 x i8]* %b) { 906; CHECK-LABEL: @pr16483( 907; CHECK-NEXT: [[CMP:%.*]] = icmp ult [1 x i8]* [[A:%.*]], [[B:%.*]] 908; CHECK-NEXT: ret i1 [[CMP]] 909; 910 %c = getelementptr [1 x i8], [1 x i8]* %a, i32 0, i32 0 911 %d = getelementptr [1 x i8], [1 x i8]* %b, i32 0, i32 0 912 %cmp = icmp ult i8* %c, %d 913 ret i1 %cmp 914 915} 916 917define i8 @test_gep_bitcast_as1(i32 addrspace(1)* %arr, i16 %N) { 918; CHECK-LABEL: @test_gep_bitcast_as1( 919; CHECK-NEXT: [[T1:%.*]] = getelementptr i32, i32 addrspace(1)* [[ARR:%.*]], i16 [[N:%.*]] 920; CHECK-NEXT: [[T:%.*]] = bitcast i32 addrspace(1)* [[T1]] to i8 addrspace(1)* 921; CHECK-NEXT: [[X:%.*]] = load i8, i8 addrspace(1)* [[T]], align 1 922; CHECK-NEXT: ret i8 [[X]] 923; 924 %cast = bitcast i32 addrspace(1)* %arr to i8 addrspace(1)* 925 %V = mul i16 %N, 4 926 %t = getelementptr i8, i8 addrspace(1)* %cast, i16 %V 927 %x = load i8, i8 addrspace(1)* %t 928 ret i8 %x 929} 930 931; The element size of the array matches the element size of the pointer 932define i64 @test_gep_bitcast_array_same_size_element([100 x double]* %arr, i64 %N) { 933; CHECK-LABEL: @test_gep_bitcast_array_same_size_element( 934; CHECK-NEXT: [[V:%.*]] = shl i64 [[N:%.*]], 3 935; CHECK-NEXT: [[T1:%.*]] = getelementptr [100 x double], [100 x double]* [[ARR:%.*]], i64 0, i64 [[V]] 936; CHECK-NEXT: [[T:%.*]] = bitcast double* [[T1]] to i64* 937; CHECK-NEXT: [[X:%.*]] = load i64, i64* [[T]], align 4 938; CHECK-NEXT: ret i64 [[X]] 939; 940 %cast = bitcast [100 x double]* %arr to i64* 941 %V = mul i64 %N, 8 942 %t = getelementptr i64, i64* %cast, i64 %V 943 %x = load i64, i64* %t 944 ret i64 %x 945} 946 947; gep should be done in the original address space. 948define i64 @test_gep_bitcast_array_same_size_element_addrspacecast([100 x double]* %arr, i64 %N) { 949; CHECK-LABEL: @test_gep_bitcast_array_same_size_element_addrspacecast( 950; CHECK-NEXT: [[V:%.*]] = shl i64 [[N:%.*]], 3 951; CHECK-NEXT: [[T1:%.*]] = getelementptr [100 x double], [100 x double]* [[ARR:%.*]], i64 0, i64 [[V]] 952; CHECK-NEXT: [[TMP1:%.*]] = bitcast double* [[T1]] to i64* 953; CHECK-NEXT: [[T:%.*]] = addrspacecast i64* [[TMP1]] to i64 addrspace(3)* 954; CHECK-NEXT: [[X:%.*]] = load i64, i64 addrspace(3)* [[T]], align 4 955; CHECK-NEXT: ret i64 [[X]] 956; 957 %cast = addrspacecast [100 x double]* %arr to i64 addrspace(3)* 958 %V = mul i64 %N, 8 959 %t = getelementptr i64, i64 addrspace(3)* %cast, i64 %V 960 %x = load i64, i64 addrspace(3)* %t 961 ret i64 %x 962} 963 964; The element size of the array is different the element size of the pointer 965define i8 @test_gep_bitcast_array_different_size_element([100 x double]* %arr, i64 %N) { 966; CHECK-LABEL: @test_gep_bitcast_array_different_size_element( 967; CHECK-NEXT: [[T1:%.*]] = getelementptr [100 x double], [100 x double]* [[ARR:%.*]], i64 0, i64 [[N:%.*]] 968; CHECK-NEXT: [[T:%.*]] = bitcast double* [[T1]] to i8* 969; CHECK-NEXT: [[X:%.*]] = load i8, i8* [[T]], align 1 970; CHECK-NEXT: ret i8 [[X]] 971; 972 %cast = bitcast [100 x double]* %arr to i8* 973 %V = mul i64 %N, 8 974 %t = getelementptr i8, i8* %cast, i64 %V 975 %x = load i8, i8* %t 976 ret i8 %x 977} 978 979define i64 @test_gep_bitcast_array_same_size_element_as1([100 x double] addrspace(1)* %arr, i16 %N) { 980; CHECK-LABEL: @test_gep_bitcast_array_same_size_element_as1( 981; CHECK-NEXT: [[V:%.*]] = shl i16 [[N:%.*]], 3 982; CHECK-NEXT: [[T1:%.*]] = getelementptr [100 x double], [100 x double] addrspace(1)* [[ARR:%.*]], i16 0, i16 [[V]] 983; CHECK-NEXT: [[T:%.*]] = bitcast double addrspace(1)* [[T1]] to i64 addrspace(1)* 984; CHECK-NEXT: [[X:%.*]] = load i64, i64 addrspace(1)* [[T]], align 4 985; CHECK-NEXT: ret i64 [[X]] 986; 987 %cast = bitcast [100 x double] addrspace(1)* %arr to i64 addrspace(1)* 988 %V = mul i16 %N, 8 989 %t = getelementptr i64, i64 addrspace(1)* %cast, i16 %V 990 %x = load i64, i64 addrspace(1)* %t 991 ret i64 %x 992} 993 994define i8 @test_gep_bitcast_array_different_size_element_as1([100 x double] addrspace(1)* %arr, i16 %N) { 995; CHECK-LABEL: @test_gep_bitcast_array_different_size_element_as1( 996; CHECK-NEXT: [[T1:%.*]] = getelementptr [100 x double], [100 x double] addrspace(1)* [[ARR:%.*]], i16 0, i16 [[N:%.*]] 997; CHECK-NEXT: [[T:%.*]] = bitcast double addrspace(1)* [[T1]] to i8 addrspace(1)* 998; CHECK-NEXT: [[X:%.*]] = load i8, i8 addrspace(1)* [[T]], align 1 999; CHECK-NEXT: ret i8 [[X]] 1000; 1001 %cast = bitcast [100 x double] addrspace(1)* %arr to i8 addrspace(1)* 1002 %V = mul i16 %N, 8 1003 %t = getelementptr i8, i8 addrspace(1)* %cast, i16 %V 1004 %x = load i8, i8 addrspace(1)* %t 1005 ret i8 %x 1006} 1007 1008define i64 @test40() { 1009; CHECK-LABEL: @test40( 1010; CHECK-NEXT: ret i64 8 1011; 1012 %array = alloca [3 x i32], align 4 1013 %gep = getelementptr inbounds [3 x i32], [3 x i32]* %array, i64 0, i64 2 1014 %gepi8 = bitcast i32* %gep to i8* 1015 %p = ptrtoint [3 x i32]* %array to i64 1016 %np = sub i64 0, %p 1017 %gep2 = getelementptr i8, i8* %gepi8, i64 %np 1018 %ret = ptrtoint i8* %gep2 to i64 1019 ret i64 %ret 1020 1021} 1022 1023define i16 @test41([3 x i32] addrspace(1)* %array) { 1024; CHECK-LABEL: @test41( 1025; CHECK-NEXT: ret i16 8 1026; 1027 %gep = getelementptr inbounds [3 x i32], [3 x i32] addrspace(1)* %array, i16 0, i16 2 1028 %gepi8 = bitcast i32 addrspace(1)* %gep to i8 addrspace(1)* 1029 %p = ptrtoint [3 x i32] addrspace(1)* %array to i16 1030 %np = sub i16 0, %p 1031 %gep2 = getelementptr i8, i8 addrspace(1)* %gepi8, i16 %np 1032 %ret = ptrtoint i8 addrspace(1)* %gep2 to i16 1033 ret i16 %ret 1034 1035} 1036 1037define i8* @test42i(i8* %c1, i8* %c2) { 1038; CHECK-LABEL: @test42i( 1039; CHECK-NEXT: [[PTRTOINT:%.*]] = ptrtoint i8* [[C1:%.*]] to i64 1040; CHECK-NEXT: [[SUB:%.*]] = sub i64 0, [[PTRTOINT]] 1041; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds i8, i8* [[C2:%.*]], i64 [[SUB]] 1042; CHECK-NEXT: ret i8* [[GEP]] 1043; 1044 %ptrtoint = ptrtoint i8* %c1 to i64 1045 %sub = sub i64 0, %ptrtoint 1046 %gep = getelementptr inbounds i8, i8* %c2, i64 %sub 1047 ret i8* %gep 1048 1049} 1050 1051define i8* @test42(i8* %c1, i8* %c2) { 1052; CHECK-LABEL: @test42( 1053; CHECK-NEXT: [[PTRTOINT:%.*]] = ptrtoint i8* [[C1:%.*]] to i64 1054; CHECK-NEXT: [[SUB:%.*]] = sub i64 0, [[PTRTOINT]] 1055; CHECK-NEXT: [[GEP:%.*]] = getelementptr i8, i8* [[C2:%.*]], i64 [[SUB]] 1056; CHECK-NEXT: ret i8* [[GEP]] 1057; 1058 %ptrtoint = ptrtoint i8* %c1 to i64 1059 %sub = sub i64 0, %ptrtoint 1060 %gep = getelementptr i8, i8* %c2, i64 %sub 1061 ret i8* %gep 1062 1063} 1064 1065define i16* @test43i(i16* %c1, i16* %c2) { 1066; CHECK-LABEL: @test43i( 1067; CHECK-NEXT: [[PTRTOINT:%.*]] = ptrtoint i16* [[C1:%.*]] to i64 1068; CHECK-NEXT: [[SUB:%.*]] = sub i64 0, [[PTRTOINT]] 1069; CHECK-NEXT: [[SHR:%.*]] = ashr i64 [[SUB]], 1 1070; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds i16, i16* [[C2:%.*]], i64 [[SHR]] 1071; CHECK-NEXT: ret i16* [[GEP]] 1072; 1073 %ptrtoint = ptrtoint i16* %c1 to i64 1074 %sub = sub i64 0, %ptrtoint 1075 %shr = ashr i64 %sub, 1 1076 %gep = getelementptr inbounds i16, i16* %c2, i64 %shr 1077 ret i16* %gep 1078 1079} 1080 1081define %struct.C* @test44i(%struct.C* %c1, %struct.C* %c2) { 1082; CHECK-LABEL: @test44i( 1083; CHECK-NEXT: [[PTRTOINT:%.*]] = ptrtoint %struct.C* [[C1:%.*]] to i64 1084; CHECK-NEXT: [[SUB:%.*]] = sub i64 0, [[PTRTOINT]] 1085; CHECK-NEXT: [[SHR:%.*]] = sdiv i64 [[SUB]], 7 1086; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds [[STRUCT_C:%.*]], %struct.C* [[C2:%.*]], i64 [[SHR]] 1087; CHECK-NEXT: ret %struct.C* [[GEP]] 1088; 1089 %ptrtoint = ptrtoint %struct.C* %c1 to i64 1090 %sub = sub i64 0, %ptrtoint 1091 %shr = sdiv i64 %sub, 7 1092 %gep = getelementptr inbounds %struct.C, %struct.C* %c2, i64 %shr 1093 ret %struct.C* %gep 1094 1095} 1096 1097define %struct.C* @test45(%struct.C* %c1, %struct.C** %c2) { 1098; CHECK-LABEL: @test45( 1099; CHECK-NEXT: [[PTRTOINT1:%.*]] = ptrtoint %struct.C* [[C1:%.*]] to i64 1100; CHECK-NEXT: [[PTRTOINT2:%.*]] = ptrtoint %struct.C** [[C2:%.*]] to i64 1101; CHECK-NEXT: [[SUB:%.*]] = sub i64 [[PTRTOINT2]], [[PTRTOINT1]] 1102; CHECK-NEXT: [[SHR:%.*]] = sdiv i64 [[SUB]], 7 1103; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds [[STRUCT_C:%.*]], %struct.C* [[C1]], i64 [[SHR]] 1104; CHECK-NEXT: ret %struct.C* [[GEP]] 1105; 1106 %ptrtoint1 = ptrtoint %struct.C* %c1 to i64 1107 %ptrtoint2 = ptrtoint %struct.C** %c2 to i64 1108 %sub = sub i64 %ptrtoint2, %ptrtoint1 ; C2 - C1 1109 %shr = sdiv i64 %sub, 7 1110 %gep = getelementptr inbounds %struct.C, %struct.C* %c1, i64 %shr ; C1 + (C2 - C1) 1111 ret %struct.C* %gep 1112} 1113 1114define %struct.C* @test46(%struct.C* %c1, %struct.C* %c2, i64 %N) { 1115; CHECK-LABEL: @test46( 1116; CHECK-NEXT: [[PTRTOINT:%.*]] = ptrtoint %struct.C* [[C1:%.*]] to i64 1117; CHECK-NEXT: [[SUB:%.*]] = sub i64 0, [[PTRTOINT]] 1118; CHECK-NEXT: [[SDIV:%.*]] = sdiv i64 [[SUB]], [[N:%.*]] 1119; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds [[STRUCT_C:%.*]], %struct.C* [[C2:%.*]], i64 [[SDIV]] 1120; CHECK-NEXT: ret %struct.C* [[GEP]] 1121; 1122 %ptrtoint = ptrtoint %struct.C* %c1 to i64 1123 %sub = sub i64 0, %ptrtoint 1124 %sdiv = sdiv i64 %sub, %N 1125 %gep = getelementptr inbounds %struct.C, %struct.C* %c2, i64 %sdiv 1126 ret %struct.C* %gep 1127 1128} 1129 1130define i32* @test47(i32* %I, i64 %C, i64 %D) { 1131; CHECK-LABEL: @test47( 1132; CHECK-NEXT: [[B:%.*]] = getelementptr i32, i32* [[I:%.*]], i64 [[D:%.*]] 1133; CHECK-NEXT: ret i32* [[B]] 1134; 1135 %sub = sub i64 %D, %C 1136 %A = getelementptr i32, i32* %I, i64 %C 1137 %B = getelementptr i32, i32* %A, i64 %sub 1138 ret i32* %B 1139} 1140 1141define i32* @test48(i32* %I, i64 %C, i64 %D) { 1142; CHECK-LABEL: @test48( 1143; CHECK-NEXT: [[B:%.*]] = getelementptr i32, i32* [[I:%.*]], i64 [[D:%.*]] 1144; CHECK-NEXT: ret i32* [[B]] 1145; 1146 %sub = sub i64 %D, %C 1147 %A = getelementptr i32, i32* %I, i64 %sub 1148 %B = getelementptr i32, i32* %A, i64 %C 1149 ret i32* %B 1150} 1151 1152define i32* @test49(i32* %I, i64 %C) { 1153; CHECK-LABEL: @test49( 1154; CHECK-NEXT: [[B:%.*]] = getelementptr i32, i32* [[I:%.*]], i64 -1 1155; CHECK-NEXT: ret i32* [[B]] 1156; 1157 %notC = xor i64 -1, %C 1158 %A = getelementptr i32, i32* %I, i64 %C 1159 %B = getelementptr i32, i32* %A, i64 %notC 1160 ret i32* %B 1161} 1162 1163define i32 addrspace(1)* @ascast_0_gep(i32* %p) nounwind { 1164; CHECK-LABEL: @ascast_0_gep( 1165; CHECK-NEXT: [[X:%.*]] = addrspacecast i32* [[P:%.*]] to i32 addrspace(1)* 1166; CHECK-NEXT: ret i32 addrspace(1)* [[X]] 1167; 1168 %gep = getelementptr i32, i32* %p, i32 0 1169 %x = addrspacecast i32* %gep to i32 addrspace(1)* 1170 ret i32 addrspace(1)* %x 1171} 1172 1173; Do not merge the GEP and the addrspacecast, because it would undo the 1174; addrspacecast canonicalization. 1175define i32 addrspace(1)* @ascast_0_0_gep([128 x i32]* %p) nounwind { 1176; CHECK-LABEL: @ascast_0_0_gep( 1177; CHECK-NEXT: [[GEP:%.*]] = getelementptr [128 x i32], [128 x i32]* [[P:%.*]], i64 0, i64 0 1178; CHECK-NEXT: [[X:%.*]] = addrspacecast i32* [[GEP]] to i32 addrspace(1)* 1179; CHECK-NEXT: ret i32 addrspace(1)* [[X]] 1180; 1181 %gep = getelementptr [128 x i32], [128 x i32]* %p, i32 0, i32 0 1182 %x = addrspacecast i32* %gep to i32 addrspace(1)* 1183 ret i32 addrspace(1)* %x 1184} 1185 1186define <2 x i32*> @PR32414(i32** %ptr) { 1187; CHECK-LABEL: @PR32414( 1188; CHECK-NEXT: [[T0:%.*]] = bitcast i32** [[PTR:%.*]] to i32* 1189; CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds i32, i32* [[T0]], <2 x i64> <i64 0, i64 1> 1190; CHECK-NEXT: ret <2 x i32*> [[T1]] 1191; 1192 %t0 = bitcast i32** %ptr to i32* 1193 %t1 = getelementptr inbounds i32, i32* %t0, <2 x i64> <i64 0, i64 1> 1194 ret <2 x i32*> %t1 1195} 1196 1197define i32* @test_bitcast_nzgep([1 x i32]* %base, i64 %idx) { 1198; CHECK-LABEL: @test_bitcast_nzgep( 1199; CHECK-NEXT: [[PTR:%.*]] = getelementptr inbounds [1 x i32], [1 x i32]* [[BASE:%.*]], i64 0, i64 [[IDX:%.*]] 1200; CHECK-NEXT: ret i32* [[PTR]] 1201; 1202 %base2 = bitcast [1 x i32]* %base to i32* 1203 %ptr = getelementptr inbounds i32, i32* %base2, i64 %idx 1204 ret i32* %ptr 1205} 1206 1207define i32* @test_zgep_nzgep([1 x i32]* %base, i64 %idx) { 1208; CHECK-LABEL: @test_zgep_nzgep( 1209; CHECK-NEXT: [[PTR:%.*]] = getelementptr inbounds [1 x i32], [1 x i32]* [[BASE:%.*]], i64 0, i64 [[IDX:%.*]] 1210; CHECK-NEXT: ret i32* [[PTR]] 1211; 1212 %base2 = getelementptr [1 x i32], [1 x i32]* %base, i64 0, i64 0 1213 %ptr = getelementptr inbounds i32, i32* %base2, i64 %idx 1214 ret i32* %ptr 1215} 1216 1217define i32* @test_nzgep_zgep([1 x i32]* %base, i64 %idx) { 1218; CHECK-LABEL: @test_nzgep_zgep( 1219; CHECK-NEXT: [[PTR:%.*]] = getelementptr inbounds [1 x i32], [1 x i32]* [[BASE:%.*]], i64 [[IDX:%.*]], i64 0 1220; CHECK-NEXT: ret i32* [[PTR]] 1221; 1222 %base2 = getelementptr inbounds [1 x i32], [1 x i32]* %base, i64 %idx 1223 %ptr = getelementptr [1 x i32], [1 x i32]* %base2, i64 0, i64 0 1224 ret i32* %ptr 1225} 1226 1227define i32* @test_gep_inbounds_of_gep(i32* %base) { 1228; CHECK-LABEL: @test_gep_inbounds_of_gep( 1229; CHECK-NEXT: [[PTR2:%.*]] = getelementptr i32, i32* [[BASE:%.*]], i64 8 1230; CHECK-NEXT: ret i32* [[PTR2]] 1231; 1232 %ptr1 = getelementptr i32, i32* %base, i64 4 1233 %ptr2 = getelementptr inbounds i32, i32* %ptr1, i64 4 1234 ret i32* %ptr2 1235} 1236 1237%struct.f = type { i32 } 1238 1239@g0 = internal unnamed_addr constant %struct.f zeroinitializer, align 4 1240@g1 = internal unnamed_addr constant %struct.f { i32 -1 }, align 4 1241 1242define i32* @PR45084(i1 %cond) { 1243; CHECK-LABEL: @PR45084( 1244; 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 [[PROF0:![0-9]+]] 1245; CHECK-NEXT: ret i32* [[GEP]] 1246; 1247 %sel = select i1 %cond, %struct.f* @g0, %struct.f* @g1, !prof !0 1248 %gep = getelementptr inbounds %struct.f, %struct.f* %sel, i64 0, i32 0 1249 ret i32* %gep 1250} 1251 1252define i32* @PR45084_extra_use(i1 %cond, %struct.f** %p) { 1253; CHECK-LABEL: @PR45084_extra_use( 1254; CHECK-NEXT: [[SEL:%.*]] = select i1 [[COND:%.*]], %struct.f* @g0, %struct.f* @g1 1255; CHECK-NEXT: store %struct.f* [[SEL]], %struct.f** [[P:%.*]], align 8 1256; 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) 1257; CHECK-NEXT: ret i32* [[GEP]] 1258; 1259 %sel = select i1 %cond, %struct.f* @g0, %struct.f* @g1 1260 store %struct.f* %sel, %struct.f** %p 1261 %gep = getelementptr %struct.f, %struct.f* %sel, i64 0, i32 0 1262 ret i32* %gep 1263} 1264 1265define i8* @gep_null_inbounds(i64 %idx) { 1266; CHECK-LABEL: @gep_null_inbounds( 1267; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds i8, i8* null, i64 [[IDX:%.*]] 1268; CHECK-NEXT: ret i8* [[GEP]] 1269; 1270 %gep = getelementptr inbounds i8, i8* null, i64 %idx 1271 ret i8* %gep 1272} 1273 1274define i8* @gep_null_not_inbounds(i64 %idx) { 1275; CHECK-LABEL: @gep_null_not_inbounds( 1276; CHECK-NEXT: [[GEP:%.*]] = getelementptr i8, i8* null, i64 [[IDX:%.*]] 1277; CHECK-NEXT: ret i8* [[GEP]] 1278; 1279 %gep = getelementptr i8, i8* null, i64 %idx 1280 ret i8* %gep 1281} 1282 1283define i8* @gep_null_defined(i64 %idx) null_pointer_is_valid { 1284; CHECK-LABEL: @gep_null_defined( 1285; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds i8, i8* null, i64 [[IDX:%.*]] 1286; CHECK-NEXT: ret i8* [[GEP]] 1287; 1288 %gep = getelementptr inbounds i8, i8* null, i64 %idx 1289 ret i8* %gep 1290} 1291 1292define i8* @gep_null_inbounds_different_type(i64 %idx1, i64 %idx2) { 1293; CHECK-LABEL: @gep_null_inbounds_different_type( 1294; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds [0 x i8], [0 x i8]* null, i64 0, i64 [[IDX2:%.*]] 1295; CHECK-NEXT: ret i8* [[GEP]] 1296; 1297 %gep = getelementptr inbounds [0 x i8], [0 x i8]* null, i64 %idx1, i64 %idx2 1298 ret i8* %gep 1299} 1300 1301define i8* @D98588(i8* %c1, i64 %offset) { 1302; CHECK-LABEL: @D98588( 1303; CHECK-NEXT: [[C2_NEXT_IDX:%.*]] = shl nsw i64 [[OFFSET:%.*]], 3 1304; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds i8, i8* [[C1:%.*]], i64 [[C2_NEXT_IDX]] 1305; CHECK-NEXT: ret i8* [[GEP]] 1306; 1307 %c2 = bitcast i8* %c1 to i64* 1308 %c2_next = getelementptr inbounds i64, i64* %c2, i64 %offset 1309 %ptrtoint1 = ptrtoint i8* %c1 to i64 1310 %ptrtoint2 = ptrtoint i64* %c2_next to i64 1311 %sub = sub i64 %ptrtoint2, %ptrtoint1 ; C2 - C1 1312 %gep = getelementptr inbounds i8, i8* %c1, i64 %sub ; C1 + (C2 - C1) 1313 ret i8* %gep 1314} 1315 1316declare noalias i8* @malloc(i64) nounwind allockind("alloc,uninitialized") allocsize(0) 1317 1318define i32 @test_gep_bitcast_malloc(%struct.A* %a) { 1319; CHECK-LABEL: @test_gep_bitcast_malloc( 1320; CHECK-NEXT: entry: 1321; CHECK-NEXT: [[CALL:%.*]] = call noalias dereferenceable_or_null(16) i8* @malloc(i64 16) 1322; CHECK-NEXT: [[B:%.*]] = bitcast i8* [[CALL]] to %struct.A* 1323; CHECK-NEXT: [[G3:%.*]] = getelementptr [[STRUCT_A:%.*]], %struct.A* [[B]], i64 0, i32 2 1324; CHECK-NEXT: [[A_C:%.*]] = load i32, i32* [[G3]], align 4 1325; CHECK-NEXT: ret i32 [[A_C]] 1326; 1327entry: 1328 %call = call noalias i8* @malloc(i64 16) #2 1329 %B = bitcast i8* %call to %struct.A* 1330 %g3 = getelementptr %struct.A, %struct.A* %B, i32 0, i32 2 1331 %a_c = load i32, i32* %g3, align 4 1332 ret i32 %a_c 1333} 1334 1335!0 = !{!"branch_weights", i32 2, i32 10} 1336