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: [[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 ;; seteq x, y 155 %t4 = icmp eq i32* %t1, %t3 156 ret i1 %t4 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> poison, 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 poison> 221; CHECK-NEXT: [[C:%.*]] = shufflevector <2 x i1> [[TMP2]], <2 x i1> poison, <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> poison, 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 poison> 236; CHECK-NEXT: [[C:%.*]] = shufflevector <2 x i1> [[TMP2]], <2 x i1> poison, <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: [[T:%.*]] = getelementptr [3 x i8], [3 x i8]* @G, i64 0, i64 [[ZEXT]] 307; CHECK-NEXT: ret i8* [[T]] 308; 309 %zext = zext i32 %idx to i64 310 %t = getelementptr i8, i8* getelementptr ([3 x i8], [3 x i8]* @G, i32 0, i32 0), i64 %zext 311 ret i8* %t 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: [[T10:%.*]] = icmp eq i32 [[A:%.*]], [[B:%.*]] 420; CHECK-NEXT: [[T11:%.*]] = zext i1 [[T10]] to i32 421; CHECK-NEXT: ret i32 [[T11]] 422; 423 %t4 = getelementptr inbounds i32, i32* %P, i32 %A 424 %t9 = getelementptr inbounds i32, i32* %P, i32 %B 425 %t10 = icmp eq i32* %t4, %t9 426 %t11 = zext i1 %t10 to i32 427 ret i32 %t11 428} 429 430define i32 @test20(i32* %P, i32 %A, i32 %B) { 431; CHECK-LABEL: @test20( 432; CHECK-NEXT: [[T6:%.*]] = icmp eq i32 [[A:%.*]], 0 433; CHECK-NEXT: [[T7:%.*]] = zext i1 [[T6]] to i32 434; CHECK-NEXT: ret i32 [[T7]] 435; 436 %t4 = getelementptr inbounds i32, i32* %P, i32 %A 437 %t6 = icmp eq i32* %t4, %P 438 %t7 = zext i1 %t6 to i32 439 ret i32 %t7 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: [[T6:%.*]] = icmp eq i16 [[TMP1]], 0 446; CHECK-NEXT: [[T7:%.*]] = zext i1 [[T6]] to i32 447; CHECK-NEXT: ret i32 [[T7]] 448; 449 %t4 = getelementptr inbounds i32, i32 addrspace(1)* %P, i32 %A 450 %t6 = icmp eq i32 addrspace(1)* %t4, %P 451 %t7 = zext i1 %t6 to i32 452 ret i32 %t7 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 poison, i64* null, align 4294967296 499; CHECK-NEXT: tail call void @foo25(i32 0, i64 poison) 500; CHECK-NEXT: unreachable 501; 502entry: 503 %t = getelementptr { i64, i64, i64, i64 }, { i64, i64, i64, i64 }* null, i32 0, i32 3 504 %t.upgrd.1 = load i64, i64* %t 505 %t8.ui = load i64, i64* null 506 %t8 = bitcast i64 %t8.ui to i64 507 %t9 = and i64 %t8, %t.upgrd.1 508 %sext = trunc i64 %t9 to i32 509 %t27.i = sext i32 %sext to i64 510 tail call void @foo25( i32 0, i64 %t27.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: [[T344:%.*]] = load %struct.siginfo_t*, %struct.siginfo_t** [[FROM_ADDR]], align 8 538; CHECK-NEXT: [[T349:%.*]] = getelementptr [[STRUCT_SIGINFO_T:%.*]], %struct.siginfo_t* [[T344]], i64 0, i32 3, i32 0, i32 3, i32 0 539; CHECK-NEXT: [[T349350:%.*]] = bitcast i8** [[T349]] to i32* 540; CHECK-NEXT: [[T351:%.*]] = load i32, i32* [[T349350]], align 8 541; CHECK-NEXT: [[T360:%.*]] = call i32 asm sideeffect "...", "=r,ir,*m,i,0,~{dirflag},~{fpsr},~{flags}"(i32 [[T351]], %struct.__large_struct* null, i32 -14, i32 0) #[[ATTR0:[0-9]+]] 542; CHECK-NEXT: unreachable 543; 544entry: 545 %from_addr = alloca %struct.siginfo_t* 546 %t344 = load %struct.siginfo_t*, %struct.siginfo_t** %from_addr, align 8 547 %t345 = getelementptr %struct.siginfo_t, %struct.siginfo_t* %t344, i32 0, i32 3 548 %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 549 %t346347 = bitcast { i32, i32, [0 x i8], %struct.sigval_t, i32 }* %t346 to { i32, i32, %struct.sigval_t }* 550 %t348 = getelementptr { i32, i32, %struct.sigval_t }, { i32, i32, %struct.sigval_t }* %t346347, i32 0, i32 2 551 %t349 = getelementptr %struct.sigval_t, %struct.sigval_t* %t348, i32 0, i32 0 552 %t349350 = bitcast i8** %t349 to i32* 553 %t351 = load i32, i32* %t349350, align 8 554 %t360 = call i32 asm sideeffect "...", 555 "=r,ir,*m,i,0,~{dirflag},~{fpsr},~{flags}"( i32 %t351, 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: [[T3:%.*]] = call i32 @puts(i8* noundef 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: [[T12_REC:%.*]] = xor i32 [[INDVAR]], -1 574; CHECK-NEXT: [[TMP0:%.*]] = sext i32 [[T12_REC]] to i64 575; CHECK-NEXT: [[T12:%.*]] = getelementptr inbounds [1 x [1 x %struct.x]], [1 x [1 x %struct.x]]* [[ORIENTATIONS]], i64 1, i64 0, i64 [[TMP0]] 576; 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]] 577; CHECK-NEXT: [[T84:%.*]] = icmp eq i32 [[INDVAR]], 0 578; CHECK-NEXT: [[INDVAR_NEXT]] = add i32 [[INDVAR]], 1 579; CHECK-NEXT: br i1 [[T84]], 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 %t3 = call i32 @puts( i8* getelementptr ([6 x i8], [6 x i8]* @.str, i32 0, i32 0) ) nounwind 586 %t45 = 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 %t.0.reg2mem.0.rec = mul i32 %indvar, -1 593 %t12.rec = add i32 %t.0.reg2mem.0.rec, -1 594 %t12 = getelementptr inbounds %struct.x, %struct.x* %t45, i32 %t12.rec 595 %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 596 %t84 = icmp eq %struct.x* %t12, %orientations62 597 %indvar.next = add i32 %indvar, 1 598 br i1 %t84, 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 poison, i64* null, align 4294967296 617; CHECK-NEXT: br i1 poison, label [[IF_THEN216:%.*]], label [[IF_END363:%.*]] 618; CHECK: if.then216: 619; CHECK-NEXT: ret i32 1 620; CHECK: if.end363: 621; CHECK-NEXT: ret i32 0 622; 623entry: 624 %t3 = load i64, i64* null 625 %add.ptr = getelementptr i8, i8* %start, i64 %t3 626 %t158 = load i32, i32* null 627 %add.ptr159 = getelementptr %T, %T* null, i32 %t158 628 %add.ptr209 = getelementptr i8, i8* %start, i64 0 629 %add.ptr212 = getelementptr i8, i8* %add.ptr209, i32 %X 630 %cmp214 = icmp ugt i8* %add.ptr212, %add.ptr 631 br i1 %cmp214, label %if.then216, label %if.end363 632 633if.then216: 634 ret i32 1 635 636if.end363: 637 ret i32 0 638} 639 640 641; PR3694 642define i32 @test30(i32 %m, i32 %n) nounwind { 643; CHECK-LABEL: @test30( 644; CHECK-NEXT: entry: 645; CHECK-NEXT: [[TMP0:%.*]] = zext i32 [[N:%.*]] to i64 646; CHECK-NEXT: [[TMP1:%.*]] = alloca i32, i64 [[TMP0]], align 4 647; CHECK-NEXT: call void @test30f(i32* nonnull [[TMP1]]) #[[ATTR0]] 648; CHECK-NEXT: [[TMP2:%.*]] = sext i32 [[M:%.*]] to i64 649; CHECK-NEXT: [[TMP3:%.*]] = getelementptr i32, i32* [[TMP1]], i64 [[TMP2]] 650; CHECK-NEXT: [[TMP4:%.*]] = load i32, i32* [[TMP3]], align 4 651; CHECK-NEXT: ret i32 [[TMP4]] 652; 653entry: 654 %0 = alloca i32, i32 %n, align 4 655 %1 = bitcast i32* %0 to [0 x i32]* 656 call void @test30f(i32* %0) nounwind 657 %2 = getelementptr [0 x i32], [0 x i32]* %1, i32 0, i32 %m 658 %3 = load i32, i32* %2, align 4 659 ret i32 %3 660} 661 662declare void @test30f(i32*) 663 664 665 666define i1 @test31(i32* %A) { 667; CHECK-LABEL: @test31( 668; CHECK-NEXT: ret i1 true 669; 670 %B = getelementptr i32, i32* %A, i32 1 671 %C = getelementptr i32, i32* %A, i64 1 672 %V = icmp eq i32* %B, %C 673 ret i1 %V 674} 675 676 677; PR1345 678define i8* @test32(i8* %v) { 679; CHECK-LABEL: @test32( 680; CHECK-NEXT: [[A:%.*]] = alloca [4 x i8*], align 16 681; CHECK-NEXT: [[B:%.*]] = getelementptr inbounds [4 x i8*], [4 x i8*]* [[A]], i64 0, i64 0 682; CHECK-NEXT: store i8* null, i8** [[B]], align 16 683; CHECK-NEXT: [[D:%.*]] = getelementptr inbounds [4 x i8*], [4 x i8*]* [[A]], i64 0, i64 1 684; CHECK-NEXT: store i8* [[V:%.*]], i8** [[D]], align 8 685; CHECK-NEXT: [[F:%.*]] = getelementptr inbounds [4 x i8*], [4 x i8*]* [[A]], i64 0, i64 2 686; CHECK-NEXT: [[G:%.*]] = load i8*, i8** [[F]], align 16 687; CHECK-NEXT: ret i8* [[G]] 688; 689 %A = alloca [4 x i8*], align 16 690 %B = getelementptr [4 x i8*], [4 x i8*]* %A, i32 0, i32 0 691 store i8* null, i8** %B 692 %C = bitcast [4 x i8*]* %A to { [16 x i8] }* 693 %D = getelementptr { [16 x i8] }, { [16 x i8] }* %C, i32 0, i32 0, i32 8 694 %E = bitcast i8* %D to i8** 695 store i8* %v, i8** %E 696 %F = getelementptr [4 x i8*], [4 x i8*]* %A, i32 0, i32 2 697 %G = load i8*, i8** %F 698 ret i8* %G 699} 700 701; PR3290 702%struct.Key = type { { i32, i32 } } 703%struct.anon = type <{ i8, [3 x i8], i32 }> 704 705define i32* @test33(%struct.Key* %A) { 706; CHECK-LABEL: @test33( 707; CHECK-NEXT: [[TMP1:%.*]] = getelementptr [[STRUCT_KEY:%.*]], %struct.Key* [[A:%.*]], i64 0, i32 0, i32 1 708; CHECK-NEXT: ret i32* [[TMP1]] 709; 710 %B = bitcast %struct.Key* %A to %struct.anon* 711 %C = getelementptr %struct.anon, %struct.anon* %B, i32 0, i32 2 712 ret i32* %C 713} 714 715define i32 addrspace(1)* @test33_as1(%struct.Key addrspace(1)* %A) { 716; CHECK-LABEL: @test33_as1( 717; CHECK-NEXT: [[TMP1:%.*]] = getelementptr [[STRUCT_KEY:%.*]], [[STRUCT_KEY]] addrspace(1)* [[A:%.*]], i16 0, i32 0, i32 1 718; CHECK-NEXT: ret i32 addrspace(1)* [[TMP1]] 719; 720 %B = bitcast %struct.Key addrspace(1)* %A to %struct.anon addrspace(1)* 721 %C = getelementptr %struct.anon, %struct.anon addrspace(1)* %B, i32 0, i32 2 722 ret i32 addrspace(1)* %C 723} 724 725define i32 addrspace(1)* @test33_array_as1([10 x i32] addrspace(1)* %A) { 726; CHECK-LABEL: @test33_array_as1( 727; CHECK-NEXT: [[C:%.*]] = getelementptr [10 x i32], [10 x i32] addrspace(1)* [[A:%.*]], i16 0, i16 2 728; CHECK-NEXT: ret i32 addrspace(1)* [[C]] 729; 730 %B = bitcast [10 x i32] addrspace(1)* %A to [5 x i32] addrspace(1)* 731 %C = getelementptr [5 x i32], [5 x i32] addrspace(1)* %B, i32 0, i32 2 732 ret i32 addrspace(1)* %C 733} 734 735; Make sure the GEP indices use the right pointer sized integer 736define i32 addrspace(1)* @test33_array_struct_as1([10 x %struct.Key] addrspace(1)* %A) { 737; CHECK-LABEL: @test33_array_struct_as1( 738; CHECK-NEXT: [[TMP1:%.*]] = getelementptr [10 x %struct.Key], [10 x %struct.Key] addrspace(1)* [[A:%.*]], i16 0, i16 1, i32 0, i32 0 739; CHECK-NEXT: ret i32 addrspace(1)* [[TMP1]] 740; 741 %B = bitcast [10 x %struct.Key] addrspace(1)* %A to [20 x i32] addrspace(1)* 742 %C = getelementptr [20 x i32], [20 x i32] addrspace(1)* %B, i32 0, i32 2 743 ret i32 addrspace(1)* %C 744} 745 746define i32 addrspace(1)* @test33_addrspacecast(%struct.Key* %A) { 747; CHECK-LABEL: @test33_addrspacecast( 748; CHECK-NEXT: [[C:%.*]] = getelementptr [[STRUCT_KEY:%.*]], %struct.Key* [[A:%.*]], i64 0, i32 0, i32 1 749; CHECK-NEXT: [[TMP1:%.*]] = addrspacecast i32* [[C]] to i32 addrspace(1)* 750; CHECK-NEXT: ret i32 addrspace(1)* [[TMP1]] 751; 752 %B = addrspacecast %struct.Key* %A to %struct.anon addrspace(1)* 753 %C = getelementptr %struct.anon, %struct.anon addrspace(1)* %B, i32 0, i32 2 754 ret i32 addrspace(1)* %C 755} 756 757 %T2 = type { i8*, i8 } 758define i8* @test34(i8* %Val, i64 %V) nounwind { 759; CHECK-LABEL: @test34( 760; CHECK-NEXT: entry: 761; CHECK-NEXT: [[C_CAST:%.*]] = inttoptr i64 [[V:%.*]] to i8* 762; CHECK-NEXT: ret i8* [[C_CAST]] 763; 764entry: 765 %A = alloca %T2, align 8 766 %mrv_gep = bitcast %T2* %A to i64* 767 %B = getelementptr %T2, %T2* %A, i64 0, i32 0 768 769 store i64 %V, i64* %mrv_gep 770 %C = load i8*, i8** %B, align 8 771 ret i8* %C 772} 773 774%t0 = type { i8*, [19 x i8] } 775%t1 = type { i8*, [0 x i8] } 776 777@array = external global [11 x i8] 778 779@s = external global %t0 780@"\01LC8" = external constant [17 x i8] 781 782; Instcombine should be able to fold this getelementptr. 783 784define i32 @test35() nounwind { 785; CHECK-LABEL: @test35( 786; 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]] 787; CHECK-NEXT: ret i32 0 788; 789 call i32 (i8*, ...) @printf(i8* getelementptr ([17 x i8], [17 x i8]* @"\01LC8", i32 0, i32 0), 790 i8* getelementptr (%t1, %t1* bitcast (%t0* @s to %t1*), i32 0, i32 1, i32 0)) nounwind 791 ret i32 0 792} 793 794; Don't treat signed offsets as unsigned. 795define i8* @test36() nounwind { 796; CHECK-LABEL: @test36( 797; CHECK-NEXT: ret i8* getelementptr ([11 x i8], [11 x i8]* @array, i64 -1, i64 10) 798; 799 ret i8* getelementptr ([11 x i8], [11 x i8]* @array, i32 0, i64 -1) 800} 801 802; Instcombine shouldn't assume that gep(A,0,1) != gep(A,1,0). 803@A37 = external constant [1 x i8] 804define i1 @test37() nounwind { 805; CHECK-LABEL: @test37( 806; CHECK-NEXT: ret i1 true 807; 808 %t = icmp eq i8* getelementptr ([1 x i8], [1 x i8]* @A37, i64 0, i64 1), 809 getelementptr ([1 x i8], [1 x i8]* @A37, i64 1, i64 0) 810 ret i1 %t 811} 812 813; Test index promotion 814define i32* @test38(i32* %I, i32 %n) { 815; CHECK-LABEL: @test38( 816; CHECK-NEXT: [[TMP1:%.*]] = sext i32 [[N:%.*]] to i64 817; CHECK-NEXT: [[A:%.*]] = getelementptr i32, i32* [[I:%.*]], i64 [[TMP1]] 818; CHECK-NEXT: ret i32* [[A]] 819; 820 %A = getelementptr i32, i32* %I, i32 %n 821 ret i32* %A 822} 823 824; Test that we don't duplicate work when the second gep is a "bitcast". 825%pr10322_t = type { i8* } 826declare void @pr10322_f2(%pr10322_t*) 827declare void @pr10322_f3(i8**) 828define void @pr10322_f1(%pr10322_t* %foo) { 829; CHECK-LABEL: @pr10322_f1( 830; CHECK-NEXT: entry: 831; CHECK-NEXT: [[ARRAYIDX8:%.*]] = getelementptr inbounds [[PR10322_T:%.*]], %pr10322_t* [[FOO:%.*]], i64 2 832; CHECK-NEXT: call void @pr10322_f2(%pr10322_t* nonnull [[ARRAYIDX8]]) #[[ATTR0]] 833; CHECK-NEXT: [[T2:%.*]] = getelementptr inbounds [[PR10322_T]], %pr10322_t* [[ARRAYIDX8]], i64 0, i32 0 834; CHECK-NEXT: call void @pr10322_f3(i8** nonnull [[T2]]) #[[ATTR0]] 835; CHECK-NEXT: ret void 836; 837entry: 838 %arrayidx8 = getelementptr inbounds %pr10322_t, %pr10322_t* %foo, i64 2 839 call void @pr10322_f2(%pr10322_t* %arrayidx8) nounwind 840 %t2 = getelementptr inbounds %pr10322_t, %pr10322_t* %arrayidx8, i64 0, i32 0 841 call void @pr10322_f3(i8** %t2) nounwind 842 ret void 843 844} 845 846; Test that we combine the last two geps in this sequence, before we 847; would wait for gep1 and gep2 to be combined and never combine 2 and 3. 848%three_gep_t = type {i32} 849%three_gep_t2 = type {%three_gep_t} 850 851define void @three_gep_f(%three_gep_t2* %x) { 852; CHECK-LABEL: @three_gep_f( 853; CHECK-NEXT: [[GEP1:%.*]] = getelementptr [[THREE_GEP_T2:%.*]], %three_gep_t2* [[X:%.*]], i64 2 854; CHECK-NEXT: call void @three_gep_h(%three_gep_t2* [[GEP1]]) 855; CHECK-NEXT: [[GEP3:%.*]] = getelementptr [[THREE_GEP_T2]], %three_gep_t2* [[GEP1]], i64 0, i32 0, i32 0 856; CHECK-NEXT: call void @three_gep_g(i32* [[GEP3]]) 857; CHECK-NEXT: ret void 858; 859 %gep1 = getelementptr %three_gep_t2, %three_gep_t2* %x, i64 2 860 call void @three_gep_h(%three_gep_t2* %gep1) 861 %gep2 = getelementptr %three_gep_t2, %three_gep_t2* %gep1, i64 0, i32 0 862 %gep3 = getelementptr %three_gep_t, %three_gep_t* %gep2, i64 0, i32 0 863 call void @three_gep_g(i32* %gep3) 864 865 ret void 866} 867 868declare void @three_gep_g(i32*) 869declare void @three_gep_h(%three_gep_t2*) 870 871%struct.ham = type { i32, %struct.zot*, %struct.zot*, %struct.zot* } 872%struct.zot = type { i64, i8 } 873 874define void @test39(%struct.ham* %arg, i8 %arg1) nounwind { 875; CHECK-LABEL: @test39( 876; CHECK-NEXT: [[T:%.*]] = getelementptr inbounds [[STRUCT_HAM:%.*]], %struct.ham* [[ARG:%.*]], i64 0, i32 2 877; CHECK-NEXT: [[TMP1:%.*]] = bitcast %struct.zot** [[T]] to i8** 878; CHECK-NEXT: [[T21:%.*]] = load i8*, i8** [[TMP1]], align 8 879; CHECK-NEXT: [[T4:%.*]] = getelementptr inbounds i8, i8* [[T21]], i64 -8 880; CHECK-NEXT: store i8 [[ARG1:%.*]], i8* [[T4]], align 8 881; CHECK-NEXT: ret void 882; 883 %t = getelementptr inbounds %struct.ham, %struct.ham* %arg, i64 0, i32 2 884 %t2 = load %struct.zot*, %struct.zot** %t, align 8 885 %t3 = bitcast %struct.zot* %t2 to i8* 886 %t4 = getelementptr inbounds i8, i8* %t3, i64 -8 887 store i8 %arg1, i8* %t4, align 8 888 ret void 889 890} 891 892define i1 @pr16483([1 x i8]* %a, [1 x i8]* %b) { 893; CHECK-LABEL: @pr16483( 894; CHECK-NEXT: [[CMP:%.*]] = icmp ult [1 x i8]* [[A:%.*]], [[B:%.*]] 895; CHECK-NEXT: ret i1 [[CMP]] 896; 897 %c = getelementptr [1 x i8], [1 x i8]* %a, i32 0, i32 0 898 %d = getelementptr [1 x i8], [1 x i8]* %b, i32 0, i32 0 899 %cmp = icmp ult i8* %c, %d 900 ret i1 %cmp 901 902} 903 904define i8 @test_gep_bitcast_as1(i32 addrspace(1)* %arr, i16 %N) { 905; CHECK-LABEL: @test_gep_bitcast_as1( 906; CHECK-NEXT: [[T1:%.*]] = getelementptr i32, i32 addrspace(1)* [[ARR:%.*]], i16 [[N:%.*]] 907; CHECK-NEXT: [[T:%.*]] = bitcast i32 addrspace(1)* [[T1]] to i8 addrspace(1)* 908; CHECK-NEXT: [[X:%.*]] = load i8, i8 addrspace(1)* [[T]], align 1 909; CHECK-NEXT: ret i8 [[X]] 910; 911 %cast = bitcast i32 addrspace(1)* %arr to i8 addrspace(1)* 912 %V = mul i16 %N, 4 913 %t = getelementptr i8, i8 addrspace(1)* %cast, i16 %V 914 %x = load i8, i8 addrspace(1)* %t 915 ret i8 %x 916} 917 918; The element size of the array matches the element size of the pointer 919define i64 @test_gep_bitcast_array_same_size_element([100 x double]* %arr, i64 %N) { 920; CHECK-LABEL: @test_gep_bitcast_array_same_size_element( 921; CHECK-NEXT: [[V:%.*]] = shl i64 [[N:%.*]], 3 922; CHECK-NEXT: [[T1:%.*]] = getelementptr [100 x double], [100 x double]* [[ARR:%.*]], i64 0, i64 [[V]] 923; CHECK-NEXT: [[T:%.*]] = bitcast double* [[T1]] to i64* 924; CHECK-NEXT: [[X:%.*]] = load i64, i64* [[T]], align 4 925; CHECK-NEXT: ret i64 [[X]] 926; 927 %cast = bitcast [100 x double]* %arr to i64* 928 %V = mul i64 %N, 8 929 %t = getelementptr i64, i64* %cast, i64 %V 930 %x = load i64, i64* %t 931 ret i64 %x 932} 933 934; gep should be done in the original address space. 935define i64 @test_gep_bitcast_array_same_size_element_addrspacecast([100 x double]* %arr, i64 %N) { 936; CHECK-LABEL: @test_gep_bitcast_array_same_size_element_addrspacecast( 937; CHECK-NEXT: [[V:%.*]] = shl i64 [[N:%.*]], 3 938; CHECK-NEXT: [[T1:%.*]] = getelementptr [100 x double], [100 x double]* [[ARR:%.*]], i64 0, i64 [[V]] 939; CHECK-NEXT: [[TMP1:%.*]] = bitcast double* [[T1]] to i64* 940; CHECK-NEXT: [[T:%.*]] = addrspacecast i64* [[TMP1]] to i64 addrspace(3)* 941; CHECK-NEXT: [[X:%.*]] = load i64, i64 addrspace(3)* [[T]], align 4 942; CHECK-NEXT: ret i64 [[X]] 943; 944 %cast = addrspacecast [100 x double]* %arr to i64 addrspace(3)* 945 %V = mul i64 %N, 8 946 %t = getelementptr i64, i64 addrspace(3)* %cast, i64 %V 947 %x = load i64, i64 addrspace(3)* %t 948 ret i64 %x 949} 950 951; The element size of the array is different the element size of the pointer 952define i8 @test_gep_bitcast_array_different_size_element([100 x double]* %arr, i64 %N) { 953; CHECK-LABEL: @test_gep_bitcast_array_different_size_element( 954; CHECK-NEXT: [[T1:%.*]] = getelementptr [100 x double], [100 x double]* [[ARR:%.*]], i64 0, i64 [[N:%.*]] 955; CHECK-NEXT: [[T:%.*]] = bitcast double* [[T1]] to i8* 956; CHECK-NEXT: [[X:%.*]] = load i8, i8* [[T]], align 1 957; CHECK-NEXT: ret i8 [[X]] 958; 959 %cast = bitcast [100 x double]* %arr to i8* 960 %V = mul i64 %N, 8 961 %t = getelementptr i8, i8* %cast, i64 %V 962 %x = load i8, i8* %t 963 ret i8 %x 964} 965 966define i64 @test_gep_bitcast_array_same_size_element_as1([100 x double] addrspace(1)* %arr, i16 %N) { 967; CHECK-LABEL: @test_gep_bitcast_array_same_size_element_as1( 968; CHECK-NEXT: [[V:%.*]] = shl i16 [[N:%.*]], 3 969; CHECK-NEXT: [[T1:%.*]] = getelementptr [100 x double], [100 x double] addrspace(1)* [[ARR:%.*]], i16 0, i16 [[V]] 970; CHECK-NEXT: [[T:%.*]] = bitcast double addrspace(1)* [[T1]] to i64 addrspace(1)* 971; CHECK-NEXT: [[X:%.*]] = load i64, i64 addrspace(1)* [[T]], align 4 972; CHECK-NEXT: ret i64 [[X]] 973; 974 %cast = bitcast [100 x double] addrspace(1)* %arr to i64 addrspace(1)* 975 %V = mul i16 %N, 8 976 %t = getelementptr i64, i64 addrspace(1)* %cast, i16 %V 977 %x = load i64, i64 addrspace(1)* %t 978 ret i64 %x 979} 980 981define i8 @test_gep_bitcast_array_different_size_element_as1([100 x double] addrspace(1)* %arr, i16 %N) { 982; CHECK-LABEL: @test_gep_bitcast_array_different_size_element_as1( 983; CHECK-NEXT: [[T1:%.*]] = getelementptr [100 x double], [100 x double] addrspace(1)* [[ARR:%.*]], i16 0, i16 [[N:%.*]] 984; CHECK-NEXT: [[T:%.*]] = bitcast double addrspace(1)* [[T1]] to i8 addrspace(1)* 985; CHECK-NEXT: [[X:%.*]] = load i8, i8 addrspace(1)* [[T]], align 1 986; CHECK-NEXT: ret i8 [[X]] 987; 988 %cast = bitcast [100 x double] addrspace(1)* %arr to i8 addrspace(1)* 989 %V = mul i16 %N, 8 990 %t = getelementptr i8, i8 addrspace(1)* %cast, i16 %V 991 %x = load i8, i8 addrspace(1)* %t 992 ret i8 %x 993} 994 995define i64 @test40() { 996; CHECK-LABEL: @test40( 997; CHECK-NEXT: ret i64 8 998; 999 %array = alloca [3 x i32], align 4 1000 %gep = getelementptr inbounds [3 x i32], [3 x i32]* %array, i64 0, i64 2 1001 %gepi8 = bitcast i32* %gep to i8* 1002 %p = ptrtoint [3 x i32]* %array to i64 1003 %np = sub i64 0, %p 1004 %gep2 = getelementptr i8, i8* %gepi8, i64 %np 1005 %ret = ptrtoint i8* %gep2 to i64 1006 ret i64 %ret 1007 1008} 1009 1010define i16 @test41([3 x i32] addrspace(1)* %array) { 1011; CHECK-LABEL: @test41( 1012; CHECK-NEXT: ret i16 8 1013; 1014 %gep = getelementptr inbounds [3 x i32], [3 x i32] addrspace(1)* %array, i16 0, i16 2 1015 %gepi8 = bitcast i32 addrspace(1)* %gep to i8 addrspace(1)* 1016 %p = ptrtoint [3 x i32] addrspace(1)* %array to i16 1017 %np = sub i16 0, %p 1018 %gep2 = getelementptr i8, i8 addrspace(1)* %gepi8, i16 %np 1019 %ret = ptrtoint i8 addrspace(1)* %gep2 to i16 1020 ret i16 %ret 1021 1022} 1023 1024define i8* @test42i(i8* %c1, i8* %c2) { 1025; CHECK-LABEL: @test42i( 1026; CHECK-NEXT: [[PTRTOINT:%.*]] = ptrtoint i8* [[C1:%.*]] to i64 1027; CHECK-NEXT: [[SUB:%.*]] = sub i64 0, [[PTRTOINT]] 1028; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds i8, i8* [[C2:%.*]], i64 [[SUB]] 1029; CHECK-NEXT: ret i8* [[GEP]] 1030; 1031 %ptrtoint = ptrtoint i8* %c1 to i64 1032 %sub = sub i64 0, %ptrtoint 1033 %gep = getelementptr inbounds i8, i8* %c2, i64 %sub 1034 ret i8* %gep 1035 1036} 1037 1038define i8* @test42(i8* %c1, i8* %c2) { 1039; CHECK-LABEL: @test42( 1040; CHECK-NEXT: [[PTRTOINT:%.*]] = ptrtoint i8* [[C1:%.*]] to i64 1041; CHECK-NEXT: [[SUB:%.*]] = sub i64 0, [[PTRTOINT]] 1042; CHECK-NEXT: [[GEP:%.*]] = getelementptr i8, i8* [[C2:%.*]], i64 [[SUB]] 1043; CHECK-NEXT: ret i8* [[GEP]] 1044; 1045 %ptrtoint = ptrtoint i8* %c1 to i64 1046 %sub = sub i64 0, %ptrtoint 1047 %gep = getelementptr i8, i8* %c2, i64 %sub 1048 ret i8* %gep 1049 1050} 1051 1052define i16* @test43i(i16* %c1, i16* %c2) { 1053; CHECK-LABEL: @test43i( 1054; CHECK-NEXT: [[PTRTOINT:%.*]] = ptrtoint i16* [[C1:%.*]] to i64 1055; CHECK-NEXT: [[SUB:%.*]] = sub i64 0, [[PTRTOINT]] 1056; CHECK-NEXT: [[SHR:%.*]] = ashr i64 [[SUB]], 1 1057; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds i16, i16* [[C2:%.*]], i64 [[SHR]] 1058; CHECK-NEXT: ret i16* [[GEP]] 1059; 1060 %ptrtoint = ptrtoint i16* %c1 to i64 1061 %sub = sub i64 0, %ptrtoint 1062 %shr = ashr i64 %sub, 1 1063 %gep = getelementptr inbounds i16, i16* %c2, i64 %shr 1064 ret i16* %gep 1065 1066} 1067 1068define %struct.C* @test44i(%struct.C* %c1, %struct.C* %c2) { 1069; CHECK-LABEL: @test44i( 1070; CHECK-NEXT: [[PTRTOINT:%.*]] = ptrtoint %struct.C* [[C1:%.*]] to i64 1071; CHECK-NEXT: [[SUB:%.*]] = sub i64 0, [[PTRTOINT]] 1072; CHECK-NEXT: [[SHR:%.*]] = sdiv i64 [[SUB]], 7 1073; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds [[STRUCT_C:%.*]], %struct.C* [[C2:%.*]], i64 [[SHR]] 1074; CHECK-NEXT: ret %struct.C* [[GEP]] 1075; 1076 %ptrtoint = ptrtoint %struct.C* %c1 to i64 1077 %sub = sub i64 0, %ptrtoint 1078 %shr = sdiv i64 %sub, 7 1079 %gep = getelementptr inbounds %struct.C, %struct.C* %c2, i64 %shr 1080 ret %struct.C* %gep 1081 1082} 1083 1084define %struct.C* @test45(%struct.C* %c1, %struct.C** %c2) { 1085; CHECK-LABEL: @test45( 1086; CHECK-NEXT: [[PTRTOINT1:%.*]] = ptrtoint %struct.C* [[C1:%.*]] to i64 1087; CHECK-NEXT: [[PTRTOINT2:%.*]] = ptrtoint %struct.C** [[C2:%.*]] to i64 1088; CHECK-NEXT: [[SUB:%.*]] = sub i64 [[PTRTOINT2]], [[PTRTOINT1]] 1089; CHECK-NEXT: [[SHR:%.*]] = sdiv i64 [[SUB]], 7 1090; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds [[STRUCT_C:%.*]], %struct.C* [[C1]], i64 [[SHR]] 1091; CHECK-NEXT: ret %struct.C* [[GEP]] 1092; 1093 %ptrtoint1 = ptrtoint %struct.C* %c1 to i64 1094 %ptrtoint2 = ptrtoint %struct.C** %c2 to i64 1095 %sub = sub i64 %ptrtoint2, %ptrtoint1 ; C2 - C1 1096 %shr = sdiv i64 %sub, 7 1097 %gep = getelementptr inbounds %struct.C, %struct.C* %c1, i64 %shr ; C1 + (C2 - C1) 1098 ret %struct.C* %gep 1099} 1100 1101define %struct.C* @test46(%struct.C* %c1, %struct.C* %c2, i64 %N) { 1102; CHECK-LABEL: @test46( 1103; CHECK-NEXT: [[PTRTOINT:%.*]] = ptrtoint %struct.C* [[C1:%.*]] to i64 1104; CHECK-NEXT: [[SUB:%.*]] = sub i64 0, [[PTRTOINT]] 1105; CHECK-NEXT: [[SDIV:%.*]] = sdiv i64 [[SUB]], [[N:%.*]] 1106; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds [[STRUCT_C:%.*]], %struct.C* [[C2:%.*]], i64 [[SDIV]] 1107; CHECK-NEXT: ret %struct.C* [[GEP]] 1108; 1109 %ptrtoint = ptrtoint %struct.C* %c1 to i64 1110 %sub = sub i64 0, %ptrtoint 1111 %sdiv = sdiv i64 %sub, %N 1112 %gep = getelementptr inbounds %struct.C, %struct.C* %c2, i64 %sdiv 1113 ret %struct.C* %gep 1114 1115} 1116 1117define i32* @test47(i32* %I, i64 %C, i64 %D) { 1118; CHECK-LABEL: @test47( 1119; CHECK-NEXT: [[B:%.*]] = getelementptr i32, i32* [[I:%.*]], i64 [[D:%.*]] 1120; CHECK-NEXT: ret i32* [[B]] 1121; 1122 %sub = sub i64 %D, %C 1123 %A = getelementptr i32, i32* %I, i64 %C 1124 %B = getelementptr i32, i32* %A, i64 %sub 1125 ret i32* %B 1126} 1127 1128define i32* @test48(i32* %I, i64 %C, i64 %D) { 1129; CHECK-LABEL: @test48( 1130; CHECK-NEXT: [[B:%.*]] = getelementptr i32, i32* [[I:%.*]], i64 [[D:%.*]] 1131; CHECK-NEXT: ret i32* [[B]] 1132; 1133 %sub = sub i64 %D, %C 1134 %A = getelementptr i32, i32* %I, i64 %sub 1135 %B = getelementptr i32, i32* %A, i64 %C 1136 ret i32* %B 1137} 1138 1139define i32* @test49(i32* %I, i64 %C) { 1140; CHECK-LABEL: @test49( 1141; CHECK-NEXT: [[B:%.*]] = getelementptr i32, i32* [[I:%.*]], i64 -1 1142; CHECK-NEXT: ret i32* [[B]] 1143; 1144 %notC = xor i64 -1, %C 1145 %A = getelementptr i32, i32* %I, i64 %C 1146 %B = getelementptr i32, i32* %A, i64 %notC 1147 ret i32* %B 1148} 1149 1150define i32 addrspace(1)* @ascast_0_gep(i32* %p) nounwind { 1151; CHECK-LABEL: @ascast_0_gep( 1152; CHECK-NEXT: [[X:%.*]] = addrspacecast i32* [[P:%.*]] to i32 addrspace(1)* 1153; CHECK-NEXT: ret i32 addrspace(1)* [[X]] 1154; 1155 %gep = getelementptr i32, i32* %p, i32 0 1156 %x = addrspacecast i32* %gep to i32 addrspace(1)* 1157 ret i32 addrspace(1)* %x 1158} 1159 1160; Do not merge the GEP and the addrspacecast, because it would undo the 1161; addrspacecast canonicalization. 1162define i32 addrspace(1)* @ascast_0_0_gep([128 x i32]* %p) nounwind { 1163; CHECK-LABEL: @ascast_0_0_gep( 1164; CHECK-NEXT: [[GEP:%.*]] = getelementptr [128 x i32], [128 x i32]* [[P:%.*]], i64 0, i64 0 1165; CHECK-NEXT: [[X:%.*]] = addrspacecast i32* [[GEP]] to i32 addrspace(1)* 1166; CHECK-NEXT: ret i32 addrspace(1)* [[X]] 1167; 1168 %gep = getelementptr [128 x i32], [128 x i32]* %p, i32 0, i32 0 1169 %x = addrspacecast i32* %gep to i32 addrspace(1)* 1170 ret i32 addrspace(1)* %x 1171} 1172 1173define <2 x i32*> @PR32414(i32** %ptr) { 1174; CHECK-LABEL: @PR32414( 1175; CHECK-NEXT: [[T0:%.*]] = bitcast i32** [[PTR:%.*]] to i32* 1176; CHECK-NEXT: [[T1:%.*]] = getelementptr inbounds i32, i32* [[T0]], <2 x i64> <i64 0, i64 1> 1177; CHECK-NEXT: ret <2 x i32*> [[T1]] 1178; 1179 %t0 = bitcast i32** %ptr to i32* 1180 %t1 = getelementptr inbounds i32, i32* %t0, <2 x i64> <i64 0, i64 1> 1181 ret <2 x i32*> %t1 1182} 1183 1184define i32* @test_bitcast_nzgep([1 x i32]* %base, i64 %idx) { 1185; CHECK-LABEL: @test_bitcast_nzgep( 1186; CHECK-NEXT: [[PTR:%.*]] = getelementptr inbounds [1 x i32], [1 x i32]* [[BASE:%.*]], i64 0, i64 [[IDX:%.*]] 1187; CHECK-NEXT: ret i32* [[PTR]] 1188; 1189 %base2 = bitcast [1 x i32]* %base to i32* 1190 %ptr = getelementptr inbounds i32, i32* %base2, i64 %idx 1191 ret i32* %ptr 1192} 1193 1194define i32* @test_zgep_nzgep([1 x i32]* %base, i64 %idx) { 1195; CHECK-LABEL: @test_zgep_nzgep( 1196; CHECK-NEXT: [[PTR:%.*]] = getelementptr inbounds [1 x i32], [1 x i32]* [[BASE:%.*]], i64 0, i64 [[IDX:%.*]] 1197; CHECK-NEXT: ret i32* [[PTR]] 1198; 1199 %base2 = getelementptr [1 x i32], [1 x i32]* %base, i64 0, i64 0 1200 %ptr = getelementptr inbounds i32, i32* %base2, i64 %idx 1201 ret i32* %ptr 1202} 1203 1204define i32* @test_nzgep_zgep([1 x i32]* %base, i64 %idx) { 1205; CHECK-LABEL: @test_nzgep_zgep( 1206; CHECK-NEXT: [[PTR:%.*]] = getelementptr inbounds [1 x i32], [1 x i32]* [[BASE:%.*]], i64 [[IDX:%.*]], i64 0 1207; CHECK-NEXT: ret i32* [[PTR]] 1208; 1209 %base2 = getelementptr inbounds [1 x i32], [1 x i32]* %base, i64 %idx 1210 %ptr = getelementptr [1 x i32], [1 x i32]* %base2, i64 0, i64 0 1211 ret i32* %ptr 1212} 1213 1214define i32* @test_gep_inbounds_of_gep(i32* %base) { 1215; CHECK-LABEL: @test_gep_inbounds_of_gep( 1216; CHECK-NEXT: [[PTR2:%.*]] = getelementptr i32, i32* [[BASE:%.*]], i64 8 1217; CHECK-NEXT: ret i32* [[PTR2]] 1218; 1219 %ptr1 = getelementptr i32, i32* %base, i64 4 1220 %ptr2 = getelementptr inbounds i32, i32* %ptr1, i64 4 1221 ret i32* %ptr2 1222} 1223 1224%struct.f = type { i32 } 1225 1226@g0 = internal unnamed_addr constant %struct.f zeroinitializer, align 4 1227@g1 = internal unnamed_addr constant %struct.f { i32 -1 }, align 4 1228 1229define i32* @PR45084(i1 %cond) { 1230; CHECK-LABEL: @PR45084( 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), !prof [[PROF0:![0-9]+]] 1232; CHECK-NEXT: ret i32* [[GEP]] 1233; 1234 %sel = select i1 %cond, %struct.f* @g0, %struct.f* @g1, !prof !0 1235 %gep = getelementptr inbounds %struct.f, %struct.f* %sel, i64 0, i32 0 1236 ret i32* %gep 1237} 1238 1239define i32* @PR45084_extra_use(i1 %cond, %struct.f** %p) { 1240; CHECK-LABEL: @PR45084_extra_use( 1241; CHECK-NEXT: [[SEL:%.*]] = select i1 [[COND:%.*]], %struct.f* @g0, %struct.f* @g1 1242; CHECK-NEXT: store %struct.f* [[SEL]], %struct.f** [[P:%.*]], align 8 1243; 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) 1244; CHECK-NEXT: ret i32* [[GEP]] 1245; 1246 %sel = select i1 %cond, %struct.f* @g0, %struct.f* @g1 1247 store %struct.f* %sel, %struct.f** %p 1248 %gep = getelementptr %struct.f, %struct.f* %sel, i64 0, i32 0 1249 ret i32* %gep 1250} 1251 1252define i8* @gep_null_inbounds(i64 %idx) { 1253; CHECK-LABEL: @gep_null_inbounds( 1254; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds i8, i8* null, i64 [[IDX:%.*]] 1255; CHECK-NEXT: ret i8* [[GEP]] 1256; 1257 %gep = getelementptr inbounds i8, i8* null, i64 %idx 1258 ret i8* %gep 1259} 1260 1261define i8* @gep_null_not_inbounds(i64 %idx) { 1262; CHECK-LABEL: @gep_null_not_inbounds( 1263; CHECK-NEXT: [[GEP:%.*]] = getelementptr i8, i8* null, i64 [[IDX:%.*]] 1264; CHECK-NEXT: ret i8* [[GEP]] 1265; 1266 %gep = getelementptr i8, i8* null, i64 %idx 1267 ret i8* %gep 1268} 1269 1270define i8* @gep_null_defined(i64 %idx) null_pointer_is_valid { 1271; CHECK-LABEL: @gep_null_defined( 1272; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds i8, i8* null, i64 [[IDX:%.*]] 1273; CHECK-NEXT: ret i8* [[GEP]] 1274; 1275 %gep = getelementptr inbounds i8, i8* null, i64 %idx 1276 ret i8* %gep 1277} 1278 1279define i8* @gep_null_inbounds_different_type(i64 %idx1, i64 %idx2) { 1280; CHECK-LABEL: @gep_null_inbounds_different_type( 1281; CHECK-NEXT: [[GEP:%.*]] = getelementptr inbounds [0 x i8], [0 x i8]* null, i64 0, i64 [[IDX2:%.*]] 1282; CHECK-NEXT: ret i8* [[GEP]] 1283; 1284 %gep = getelementptr inbounds [0 x i8], [0 x i8]* null, i64 %idx1, i64 %idx2 1285 ret i8* %gep 1286} 1287 1288define i8* @D98588(i8* %c1, i64 %offset) { 1289; CHECK-LABEL: @D98588( 1290; CHECK-NEXT: [[C2:%.*]] = bitcast i8* [[C1:%.*]] to i64* 1291; CHECK-NEXT: [[C2_NEXT:%.*]] = getelementptr inbounds i64, i64* [[C2]], i64 [[OFFSET:%.*]] 1292; CHECK-NEXT: [[GEP:%.*]] = bitcast i64* [[C2_NEXT]] to i8* 1293; CHECK-NEXT: ret i8* [[GEP]] 1294; 1295 %c2 = bitcast i8* %c1 to i64* 1296 %c2_next = getelementptr inbounds i64, i64* %c2, i64 %offset 1297 %ptrtoint1 = ptrtoint i8* %c1 to i64 1298 %ptrtoint2 = ptrtoint i64* %c2_next to i64 1299 %sub = sub i64 %ptrtoint2, %ptrtoint1 ; C2 - C1 1300 %gep = getelementptr inbounds i8, i8* %c1, i64 %sub ; C1 + (C2 - C1) 1301 ret i8* %gep 1302} 1303 1304declare noalias i8* @malloc(i64) nounwind 1305 1306define i32 @test_gep_bitcast_malloc(%struct.A* %a) { 1307; CHECK-LABEL: @test_gep_bitcast_malloc( 1308; CHECK-NEXT: entry: 1309; CHECK-NEXT: [[CALL:%.*]] = call noalias dereferenceable_or_null(16) i8* @malloc(i64 16) 1310; CHECK-NEXT: [[B:%.*]] = bitcast i8* [[CALL]] to %struct.A* 1311; CHECK-NEXT: [[G3:%.*]] = getelementptr [[STRUCT_A:%.*]], %struct.A* [[B]], i64 0, i32 2 1312; CHECK-NEXT: [[A_C:%.*]] = load i32, i32* [[G3]], align 4 1313; CHECK-NEXT: ret i32 [[A_C]] 1314; 1315entry: 1316 %call = call noalias i8* @malloc(i64 16) #2 1317 %B = bitcast i8* %call to %struct.A* 1318 %g3 = getelementptr %struct.A, %struct.A* %B, i32 0, i32 2 1319 %a_c = load i32, i32* %g3, align 4 1320 ret i32 %a_c 1321} 1322 1323!0 = !{!"branch_weights", i32 2, i32 10} 1324