llvm/test/Transforms/SROA/preserve-metadata.ll

   1 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
   2 ; RUN: opt < %s -passes='sroa<preserve-cfg>' -S | FileCheck %s --check-prefixes=CHECK,CHECK-PRESERVE-CFG
   3 ; RUN: opt < %s -passes='sroa<modify-cfg>' -S | FileCheck %s --check-prefixes=CHECK,CHECK-MODIFY-CFG
   4 ;
   5 ; Make sure that SROA doesn't lose nonnull metadata
   6 ; on loads from allocas that get optimized out.
   7
   8 declare void @llvm.memcpy.p0.p0.i64(ptr nocapture writeonly, ptr nocapture readonly, i64, i1)
   9
  10 ; Check that we do basic propagation of nonnull when rewriting.
  11 define ptr @propagate_nonnull(ptr %v) {
  12 ; CHECK-LABEL: @propagate_nonnull(
  13 ; CHECK-NEXT:  entry:
  14 ; CHECK-NEXT:    [[A_SROA_1:%.*]] = alloca ptr, align 8
  15 ; CHECK-NEXT:    store ptr [[V:%.*]], ptr [[A_SROA_1]], align 8
  16 ; CHECK-NEXT:    [[A_SROA_1_0_A_SROA_1_8_LOAD:%.*]] = load volatile ptr, ptr [[A_SROA_1]], align 8, !nonnull !0
  17 ; CHECK-NEXT:    ret ptr [[A_SROA_1_0_A_SROA_1_8_LOAD]]
  18 ;
  19 entry:
  20   %a = alloca [2 x ptr]
  21   %a.gep1 = getelementptr [2 x ptr], ptr %a, i32 0, i32 1
  22   store ptr %v, ptr %a.gep1
  23   store ptr null, ptr %a
  24   %load = load volatile ptr, ptr %a.gep1, !nonnull !0
  25   ret ptr %load
  26 }
  27
  28 define i32 @propagate_range(i32 %v) {
  29 ; CHECK-LABEL: @propagate_range(
  30 ; CHECK-NEXT:  entry:
  31 ; CHECK-NEXT:    [[A_SROA_1:%.*]] = alloca i32, align 4
  32 ; CHECK-NEXT:    store i32 [[V:%.*]], ptr [[A_SROA_1]], align 4
  33 ; CHECK-NEXT:    [[A_SROA_1_0_A_SROA_1_4_LOAD:%.*]] = load volatile i32, ptr [[A_SROA_1]], align 4, !range [[RNG1:![0-9]+]]
  34 ; CHECK-NEXT:    ret i32 [[A_SROA_1_0_A_SROA_1_4_LOAD]]
  35 ;
  36 entry:
  37   %a = alloca [2 x i32]
  38   %a.gep1 = getelementptr [2 x i32], ptr %a, i32 0, i32 1
  39   store i32 %v, ptr %a.gep1
  40   store i32 0, ptr %a
  41   %load = load volatile i32, ptr %a.gep1, !range !{i32 0, i32 10}
  42   ret i32 %load
  43 }
  44
  45 define ptr @propagate_noundef(ptr %v) {
  46 ; CHECK-LABEL: @propagate_noundef(
  47 ; CHECK-NEXT:  entry:
  48 ; CHECK-NEXT:    [[A_SROA_1:%.*]] = alloca ptr, align 8
  49 ; CHECK-NEXT:    store ptr [[V:%.*]], ptr [[A_SROA_1]], align 8
  50 ; CHECK-NEXT:    [[A_SROA_1_0_A_SROA_1_8_LOAD:%.*]] = load volatile ptr, ptr [[A_SROA_1]], align 8, !noundef !0
  51 ; CHECK-NEXT:    ret ptr [[A_SROA_1_0_A_SROA_1_8_LOAD]]
  52 ;
  53 entry:
  54   %a = alloca [2 x ptr]
  55   %a.gep1 = getelementptr [2 x ptr], ptr %a, i32 0, i32 1
  56   store ptr %v, ptr %a.gep1
  57   store ptr null, ptr %a
  58   %load = load volatile ptr, ptr %a.gep1, !noundef !0
  59   ret ptr %load
  60 }
  61
  62 define ptr @turn_nonnull_noundef_into_assume(ptr %arg) {
  63 ; CHECK-LABEL: @turn_nonnull_noundef_into_assume(
  64 ; CHECK-NEXT:  entry:
  65 ; CHECK-NEXT:    [[BUF_0_COPYLOAD:%.*]] = load ptr, ptr [[ARG:%.*]], align 8
  66 ; CHECK-NEXT:    [[TMP0:%.*]] = icmp ne ptr [[BUF_0_COPYLOAD]], null
  67 ; CHECK-NEXT:    call void @llvm.assume(i1 [[TMP0]])
  68 ; CHECK-NEXT:    ret ptr [[BUF_0_COPYLOAD]]
  69 ;
  70 entry:
  71   %buf = alloca ptr
  72   call void @llvm.memcpy.p0.p0.i64(ptr align 8 %buf, ptr align 8 %arg, i64 8, i1 false)
  73   %ret = load ptr, ptr %buf, align 8, !nonnull !0, !noundef !0
  74   ret ptr %ret
  75 }
  76
  77 define ptr @dont_turn_nonnull_without_noundef_into_assume(ptr %arg) {
  78 ; CHECK-LABEL: @dont_turn_nonnull_without_noundef_into_assume(
  79 ; CHECK-NEXT:  entry:
  80 ; CHECK-NEXT:    [[BUF_0_COPYLOAD:%.*]] = load ptr, ptr [[ARG:%.*]], align 8
  81 ; CHECK-NEXT:    ret ptr [[BUF_0_COPYLOAD]]
  82 ;
  83 entry:
  84   %buf = alloca ptr
  85   call void @llvm.memcpy.p0.p0.i64(ptr align 8 %buf, ptr align 8 %arg, i64 8, i1 false)
  86   %ret = load ptr, ptr %buf, align 8, !nonnull !0
  87   ret ptr %ret
  88 }
  89
  90 ; Make sure we properly handle the !nonnull attribute when we convert
  91 ; a pointer load to an integer load.
  92 ; FIXME: While this doesn't do anythnig actively harmful today, it really
  93 ; should propagate the !nonnull metadata to range metadata. The irony is, it
  94 ; *does* initially, but then we lose that !range metadata before we finish
  95 ; SROA.
  96 define ptr @propagate_nonnull_to_int() {
  97 ; CHECK-LABEL: @propagate_nonnull_to_int(
  98 ; CHECK-NEXT:  entry:
  99 ; CHECK-NEXT:    [[A_SROA_1:%.*]] = alloca ptr, align 8
 100 ; CHECK-NEXT:    store ptr inttoptr (i64 42 to ptr), ptr [[A_SROA_1]], align 8
 101 ; CHECK-NEXT:    [[A_SROA_1_0_A_SROA_1_8_LOAD:%.*]] = load volatile ptr, ptr [[A_SROA_1]], align 8, !nonnull !0
 102 ; CHECK-NEXT:    ret ptr [[A_SROA_1_0_A_SROA_1_8_LOAD]]
 103 ;
 104 entry:
 105   %a = alloca [2 x ptr]
 106   %a.gep1 = getelementptr [2 x ptr], ptr %a, i32 0, i32 1
 107   store i64 42, ptr %a.gep1
 108   store i64 0, ptr %a
 109   %load = load volatile ptr, ptr %a.gep1, !nonnull !0
 110   ret ptr %load
 111 }
 112
 113 ; Make sure we properly handle the !nonnull attribute when we convert
 114 ; a pointer load to an integer load and immediately promote it to an SSA
 115 ; register. This can fail in interesting ways due to the rewrite iteration of
 116 ; SROA, resulting in PR32902.
 117 define ptr @propagate_nonnull_to_int_and_promote() {
 118 ; CHECK-LABEL: @propagate_nonnull_to_int_and_promote(
 119 ; CHECK-NEXT:  entry:
 120 ; CHECK-NEXT:    ret ptr inttoptr (i64 42 to ptr)
 121 ;
 122 entry:
 123   %a = alloca [2 x ptr], align 8
 124   %a.gep1 = getelementptr [2 x ptr], ptr %a, i32 0, i32 1
 125   store i64 42, ptr %a.gep1
 126   store i64 0, ptr %a
 127   %load = load ptr, ptr %a.gep1, align 8, !nonnull !0
 128   ret ptr %load
 129 }
 130
 131 define i128 @load_i128_to_load_ptr() {
 132 ; CHECK-LABEL: @load_i128_to_load_ptr(
 133 ; CHECK-NEXT:    [[TMP1:%.*]] = ptrtoint ptr null to i64
 134 ; CHECK-NEXT:    [[A_SROA_2_0_INSERT_EXT:%.*]] = zext i64 undef to i128
 135 ; CHECK-NEXT:    [[A_SROA_2_0_INSERT_SHIFT:%.*]] = shl i128 [[A_SROA_2_0_INSERT_EXT]], 64
 136 ; CHECK-NEXT:    [[A_SROA_2_0_INSERT_MASK:%.*]] = and i128 undef, 18446744073709551615
 137 ; CHECK-NEXT:    [[A_SROA_2_0_INSERT_INSERT:%.*]] = or i128 [[A_SROA_2_0_INSERT_MASK]], [[A_SROA_2_0_INSERT_SHIFT]]
 138 ; CHECK-NEXT:    [[A_SROA_0_0_INSERT_EXT:%.*]] = zext i64 [[TMP1]] to i128
 139 ; CHECK-NEXT:    [[A_SROA_0_0_INSERT_MASK:%.*]] = and i128 [[A_SROA_2_0_INSERT_INSERT]], -18446744073709551616
 140 ; CHECK-NEXT:    [[A_SROA_0_0_INSERT_INSERT:%.*]] = or i128 [[A_SROA_0_0_INSERT_MASK]], [[A_SROA_0_0_INSERT_EXT]]
 141 ; CHECK-NEXT:    ret i128 [[A_SROA_0_0_INSERT_INSERT]]
 142 ;
 143   %a = alloca i128
 144   store ptr null, ptr %a
 145   %v = load i128, ptr %a, !range !{i128 1, i128 0}
 146   ret i128 %v
 147 }
 148
 149 !0 = !{}
 150 ;; NOTE: These prefixes are unused and the list is autogenerated. Do not add tests below this line:
 151 ; CHECK-MODIFY-CFG: {{.*}}
 152 ; CHECK-PRESERVE-CFG: {{.*}}