llvm/test/Analysis/BasicAA/libfuncs.ll

   1 ; RUN: opt -mtriple=x86_64-pc-linux-gnu -aa-pipeline=basic-aa -passes=inferattrs,aa-eval -print-all-alias-modref-info -disable-output 2>&1 %s | FileCheck %s
   2
   3 ; CHECK-LABEL: Function: test_memcmp_const_size
   4 ; CHECK:      Just Ref:  Ptr: i8* %a    <->  %res = tail call i32 @memcmp(ptr %a, ptr %b, i64 4)
   5 ; CHECK-NEXT: Just Ref:  Ptr: i8* %b    <->  %res = tail call i32 @memcmp(ptr %a, ptr %b, i64 4)
   6 ; CHECK-NEXT: Just Ref:  Ptr: i8* %a.gep.1      <->  %res = tail call i32 @memcmp(ptr %a, ptr %b, i64 4)
   7 ; CHECK-NEXT: NoModRef:  Ptr: i8* %a.gep.5      <->  %res = tail call i32 @memcmp(ptr %a, ptr %b, i64 4)
   8 ; CHECK-NEXT: Just Ref:  Ptr: i8* %b.gep.1      <->  %res = tail call i32 @memcmp(ptr %a, ptr %b, i64 4)
   9 ; CHECK-NEXT: NoModRef:  Ptr: i8* %b.gep.5      <->  %res = tail call i32 @memcmp(ptr %a, ptr %b, i64 4)
  10 define i32 @test_memcmp_const_size(ptr noalias %a, ptr noalias %b) {
  11 entry:
  12   load i8, ptr %a
  13   load i8, ptr %b
  14   %res = tail call i32 @memcmp(ptr %a, ptr %b, i64 4)
  15   %a.gep.1 = getelementptr i8, ptr %a, i32 1
  16   store i8 0, ptr %a.gep.1
  17   %a.gep.5 = getelementptr i8, ptr %a, i32 5
  18   store i8 1, ptr %a.gep.5
  19   %b.gep.1 = getelementptr i8, ptr %b, i32 1
  20   store i8 2, ptr %b.gep.1
  21   %b.gep.5 = getelementptr i8, ptr %b, i32 5
  22   store i8 3, ptr %b.gep.5
  23   ret i32 %res
  24 }
  25
  26 ; CHECK-LABEL: Function: test_memcmp_variable_size
  27 ; CHECK:      Just Ref:  Ptr: i8* %a    <->  %res = tail call i32 @memcmp(ptr %a, ptr %b, i64 %n)
  28 ; CHECK-NEXT: Just Ref:  Ptr: i8* %b    <->  %res = tail call i32 @memcmp(ptr %a, ptr %b, i64 %n)
  29 ; CHECK-NEXT: Just Ref:  Ptr: i8* %a.gep.1      <->  %res = tail call i32 @memcmp(ptr %a, ptr %b, i64 %n)
  30 ; CHECK-NEXT: Just Ref:  Ptr: i8* %a.gep.5      <->  %res = tail call i32 @memcmp(ptr %a, ptr %b, i64 %n)
  31 ; CHECK-NEXT: Just Ref:  Ptr: i8* %b.gep.1      <->  %res = tail call i32 @memcmp(ptr %a, ptr %b, i64 %n)
  32 ; CHECK-NEXT: Just Ref:  Ptr: i8* %b.gep.5      <->  %res = tail call i32 @memcmp(ptr %a, ptr %b, i64 %n)
  33 define i32 @test_memcmp_variable_size(ptr noalias %a, ptr noalias %b, i64 %n) {
  34 entry:
  35   load i8, ptr %a
  36   load i8, ptr %b
  37   %res = tail call i32 @memcmp(ptr %a, ptr %b, i64 %n)
  38   %a.gep.1 = getelementptr i8, ptr %a, i32 1
  39   store i8 0, ptr %a.gep.1
  40   %a.gep.5 = getelementptr i8, ptr %a, i32 5
  41   store i8 1, ptr %a.gep.5
  42   %b.gep.1 = getelementptr i8, ptr %b, i32 1
  43   store i8 2, ptr %b.gep.1
  44   %b.gep.5 = getelementptr i8, ptr %b, i32 5
  45   store i8 3, ptr %b.gep.5
  46   ret i32 %res
  47 }
  48
  49 declare i32 @memcmp(ptr, ptr, i64)
  50 declare i32 @bcmp(ptr, ptr, i64)
  51
  52 ; CHECK-LABEL: Function: test_bcmp_const_size
  53 ; CHECK:      Just Ref:  Ptr: i8* %a    <->  %res = tail call i32 @bcmp(ptr %a, ptr %b, i64 4)
  54 ; CHECK-NEXT: Just Ref:  Ptr: i8* %b    <->  %res = tail call i32 @bcmp(ptr %a, ptr %b, i64 4)
  55 ; CHECK-NEXT: Just Ref:  Ptr: i8* %a.gep.1      <->  %res = tail call i32 @bcmp(ptr %a, ptr %b, i64 4)
  56 ; CHECK-NEXT: NoModRef:  Ptr: i8* %a.gep.5      <->  %res = tail call i32 @bcmp(ptr %a, ptr %b, i64 4)
  57 ; CHECK-NEXT: Just Ref:  Ptr: i8* %b.gep.1      <->  %res = tail call i32 @bcmp(ptr %a, ptr %b, i64 4)
  58 ; CHECK-NEXT: NoModRef:  Ptr: i8* %b.gep.5      <->  %res = tail call i32 @bcmp(ptr %a, ptr %b, i64 4)
  59 define i32 @test_bcmp_const_size(ptr noalias %a, ptr noalias %b) {
  60 entry:
  61   load i8, ptr %a
  62   load i8, ptr %b
  63   %res = tail call i32 @bcmp(ptr %a, ptr %b, i64 4)
  64   %a.gep.1 = getelementptr i8, ptr %a, i32 1
  65   store i8 0, ptr %a.gep.1
  66   %a.gep.5 = getelementptr i8, ptr %a, i32 5
  67   store i8 1, ptr %a.gep.5
  68   %b.gep.1 = getelementptr i8, ptr %b, i32 1
  69   store i8 2, ptr %b.gep.1
  70   %b.gep.5 = getelementptr i8, ptr %b, i32 5
  71   store i8 3, ptr %b.gep.5
  72   ret i32 %res
  73 }
  74
  75 ; CHECK-LABEL: Function: test_bcmp_variable_size
  76 ; CHECK:      Just Ref:  Ptr: i8* %a    <->  %res = tail call i32 @bcmp(ptr %a, ptr %b, i64 %n)
  77 ; CHECK-NEXT: Just Ref:  Ptr: i8* %b    <->  %res = tail call i32 @bcmp(ptr %a, ptr %b, i64 %n)
  78 ; CHECK-NEXT: Just Ref:  Ptr: i8* %a.gep.1      <->  %res = tail call i32 @bcmp(ptr %a, ptr %b, i64 %n)
  79 ; CHECK-NEXT: Just Ref:  Ptr: i8* %a.gep.5      <->  %res = tail call i32 @bcmp(ptr %a, ptr %b, i64 %n)
  80 ; CHECK-NEXT: Just Ref:  Ptr: i8* %b.gep.1      <->  %res = tail call i32 @bcmp(ptr %a, ptr %b, i64 %n)
  81 ; CHECK-NEXT: Just Ref:  Ptr: i8* %b.gep.5      <->  %res = tail call i32 @bcmp(ptr %a, ptr %b, i64 %n)
  82 define i32 @test_bcmp_variable_size(ptr noalias %a, ptr noalias %b, i64 %n) {
  83 entry:
  84   load i8, ptr %a
  85   load i8, ptr %b
  86   %res = tail call i32 @bcmp(ptr %a, ptr %b, i64 %n)
  87   %a.gep.1 = getelementptr i8, ptr %a, i32 1
  88   store i8 0, ptr %a.gep.1
  89   %a.gep.5 = getelementptr i8, ptr %a, i32 5
  90   store i8 1, ptr %a.gep.5
  91   %b.gep.1 = getelementptr i8, ptr %b, i32 1
  92   store i8 2, ptr %b.gep.1
  93   %b.gep.5 = getelementptr i8, ptr %b, i32 5
  94   store i8 3, ptr %b.gep.5
  95   ret i32 %res
  96 }
  97
  98 declare ptr @memchr(ptr, i32, i64)
  99
 100 ; CHECK-LABEL: Function: test_memchr_const_size
 101 ; CHECK: Just Ref:  Ptr: i8* %res      <->  %res = call ptr @memchr(ptr %a, i32 42, i64 4)
 102 ; CHECK-NEXT: Just Ref:  Ptr: i8* %a.gep.1  <->  %res = call ptr @memchr(ptr %a, i32 42, i64 4)
 103 ; CHECK-NEXT: NoModRef:  Ptr: i8* %a.gep.5  <->  %res = call ptr @memchr(ptr %a, i32 42, i64 4)
 104 define ptr @test_memchr_const_size(ptr noalias %a) {
 105 entry:
 106   %res = call ptr @memchr(ptr %a, i32 42, i64 4)
 107   load i8, ptr %res
 108   %a.gep.1 = getelementptr i8, ptr %a, i32 1
 109   store i8 0, ptr %a.gep.1
 110   %a.gep.5 = getelementptr i8, ptr %a, i32 5
 111   store i8 1, ptr %a.gep.5
 112   ret ptr %res
 113 }
 114
 115 declare ptr @memccpy(ptr, ptr, i32, i64)
 116
 117 ; CHECK-LABEL: Function: test_memccpy_const_size
 118 ; CHECK:      Just Mod:  Ptr: i8* %a        <->  %res = call ptr @memccpy(ptr %a, ptr %b, i32 42, i64 4)
 119 ; CHECK-NEXT: Just Ref:  Ptr: i8* %b        <->  %res = call ptr @memccpy(ptr %a, ptr %b, i32 42, i64 4)
 120 ; CHECK-NEXT: Just Mod:  Ptr: i8* %res      <->  %res = call ptr @memccpy(ptr %a, ptr %b, i32 42, i64 4)
 121 ; CHECK-NEXT: Just Mod:  Ptr: i8* %a.gep.1  <->  %res = call ptr @memccpy(ptr %a, ptr %b, i32 42, i64 4)
 122 ; CHECK-NEXT: NoModRef:  Ptr: i8* %a.gep.5  <->  %res = call ptr @memccpy(ptr %a, ptr %b, i32 42, i64 4)
 123 ; CHECK-NEXT: Just Ref:  Ptr: i8* %b.gep.1  <->  %res = call ptr @memccpy(ptr %a, ptr %b, i32 42, i64 4)
 124 ; CHECK-NEXT: NoModRef:  Ptr: i8* %b.gep.5  <->  %res = call ptr @memccpy(ptr %a, ptr %b, i32 42, i64 4)
 125
 126 define ptr @test_memccpy_const_size(ptr noalias %a, ptr noalias %b) {
 127 entry:
 128   load i8, ptr %a
 129   load i8, ptr %b
 130   %res = call ptr @memccpy(ptr %a, ptr %b, i32 42, i64 4)
 131   load i8, ptr %res
 132   %a.gep.1 = getelementptr i8, ptr %a, i32 1
 133   store i8 0, ptr %a.gep.1
 134   %a.gep.5 = getelementptr i8, ptr %a, i32 5
 135   store i8 1, ptr %a.gep.5
 136   %b.gep.1 = getelementptr i8, ptr %b, i32 1
 137   store i8 2, ptr %b.gep.1
 138   %b.gep.5 = getelementptr i8, ptr %b, i32 5
 139   store i8 3, ptr %b.gep.5
 140   ret ptr %res
 141 }
 142
 143 declare ptr @strcat(ptr, ptr)
 144
 145 define ptr @test_strcat_read_write_after(ptr noalias %a, ptr noalias %b) {
 146 ; CHECK-LABEL: Function: test_strcat_read_write_after
 147 ; CHECK:       NoModRef:  Ptr: i8* %a   <->  %res = tail call ptr @strcat(ptr %a.gep.1, ptr %b.gep.1)
 148 ; CHECK-NEXT:  NoModRef:  Ptr: i8* %b   <->  %res = tail call ptr @strcat(ptr %a.gep.1, ptr %b.gep.1)
 149 ; CHECK-NEXT:  Both ModRef:  Ptr: i8* %a.gep.1  <->  %res = tail call ptr @strcat(ptr %a.gep.1, ptr %b.gep.1)
 150 ; CHECK-NEXT:  Just Ref:  Ptr: i8* %b.gep.1     <->  %res = tail call ptr @strcat(ptr %a.gep.1, ptr %b.gep.1)
 151 ; CHECK-NEXT:  Both ModRef:  Ptr: i8* %res      <->  %res = tail call ptr @strcat(ptr %a.gep.1, ptr %b.gep.1)
 152 ; CHECK-NEXT:  Both ModRef:  Ptr: i8* %a.gep.5  <->  %res = tail call ptr @strcat(ptr %a.gep.1, ptr %b.gep.1)
 153 ; CHECK-NEXT:  Just Ref:  Ptr: i8* %b.gep.5     <->  %res = tail call ptr @strcat(ptr %a.gep.1, ptr %b.gep.1)
 154 ;
 155 entry:
 156   store i8 0, ptr %a
 157   store i8 2, ptr %b
 158   %a.gep.1 = getelementptr i8, ptr %a, i32 1
 159   load i8, ptr %a.gep.1
 160   %b.gep.1 = getelementptr i8, ptr %b, i32 1
 161   load i8, ptr %b.gep.1
 162   %res = tail call ptr @strcat(ptr %a.gep.1, ptr %b.gep.1)
 163   load i8, ptr %res
 164   %a.gep.5 = getelementptr i8, ptr %a, i32 5
 165   store i8 1, ptr %a.gep.5
 166   %b.gep.5 = getelementptr i8, ptr %b, i32 5
 167   store i8 3, ptr %b.gep.5
 168   ret ptr %res
 169 }
 170
 171 declare ptr @strncat(ptr, ptr, i64)
 172
 173 define ptr @test_strncat_read_write_after(ptr noalias %a, ptr noalias %b, i64 %n) {
 174 ; CHECK-LABEL: Function: test_strncat_read_write_after
 175 ; CHECK:       NoModRef:  Ptr: i8* %a   <->  %res = tail call ptr @strncat(ptr %a.gep.1, ptr %b.gep.1, i64 %n)
 176 ; CHECK-NEXT:  NoModRef:  Ptr: i8* %b   <->  %res = tail call ptr @strncat(ptr %a.gep.1, ptr %b.gep.1, i64 %n)
 177 ; CHECK-NEXT:  Both ModRef:  Ptr: i8* %a.gep.1  <->  %res = tail call ptr @strncat(ptr %a.gep.1, ptr %b.gep.1, i64 %n)
 178 ; CHECK-NEXT:  Just Ref:  Ptr: i8* %b.gep.1     <->  %res = tail call ptr @strncat(ptr %a.gep.1, ptr %b.gep.1, i64 %n)
 179 ; CHECK-NEXT:  Both ModRef:  Ptr: i8* %res      <->  %res = tail call ptr @strncat(ptr %a.gep.1, ptr %b.gep.1, i64 %n)
 180 ; CHECK-NEXT:  Both ModRef:  Ptr: i8* %a.gep.5  <->  %res = tail call ptr @strncat(ptr %a.gep.1, ptr %b.gep.1, i64 %n)
 181 ; CHECK-NEXT:  Just Ref:  Ptr: i8* %b.gep.5     <->  %res = tail call ptr @strncat(ptr %a.gep.1, ptr %b.gep.1, i64 %n)
 182 ;
 183 entry:
 184   store i8 0, ptr %a
 185   store i8 2, ptr %b
 186   %a.gep.1 = getelementptr i8, ptr %a, i32 1
 187   load i8, ptr %a.gep.1
 188   %b.gep.1 = getelementptr i8, ptr %b, i32 1
 189   load i8, ptr %b.gep.1
 190   %res = tail call ptr @strncat(ptr %a.gep.1, ptr %b.gep.1, i64 %n)
 191   load i8, ptr %res
 192   %a.gep.5 = getelementptr i8, ptr %a, i32 5
 193   store i8 1, ptr %a.gep.5
 194   %b.gep.5 = getelementptr i8, ptr %b, i32 5
 195   store i8 3, ptr %b.gep.5
 196   ret ptr %res
 197 }
 198
 199 declare ptr @strcpy(ptr, ptr)
 200
 201 define ptr @test_strcpy_read_write_after(ptr noalias %a, ptr noalias %b) {
 202 ; CHECK-LABEL: Function: test_strcpy_read_write_after
 203 ; CHECK:       NoModRef:  Ptr: i8* %a   <->  %res = tail call ptr @strcpy(ptr %a.gep.1, ptr %b.gep.1)
 204 ; CHECK-NEXT:  NoModRef:  Ptr: i8* %b   <->  %res = tail call ptr @strcpy(ptr %a.gep.1, ptr %b.gep.1)
 205 ; CHECK-NEXT:  Just Mod:  Ptr: i8* %a.gep.1     <->  %res = tail call ptr @strcpy(ptr %a.gep.1, ptr %b.gep.1)
 206 ; CHECK-NEXT:  Just Ref:  Ptr: i8* %b.gep.1     <->  %res = tail call ptr @strcpy(ptr %a.gep.1, ptr %b.gep.1)
 207 ; CHECK-NEXT:  Just Mod:  Ptr: i8* %res <->  %res = tail call ptr @strcpy(ptr %a.gep.1, ptr %b.gep.1)
 208 ; CHECK-NEXT:  Just Mod:  Ptr: i8* %a.gep.5     <->  %res = tail call ptr @strcpy(ptr %a.gep.1, ptr %b.gep.1)
 209 ; CHECK-NEXT:  Just Ref:  Ptr: i8* %b.gep.5     <->  %res = tail call ptr @strcpy(ptr %a.gep.1, ptr %b.gep.1)
 210 ;
 211 entry:
 212   store i8 0, ptr %a
 213   store i8 2, ptr %b
 214   %a.gep.1 = getelementptr i8, ptr %a, i32 1
 215   load i8, ptr %a.gep.1
 216   %b.gep.1 = getelementptr i8, ptr %b, i32 1
 217   load i8, ptr %b.gep.1
 218   %res = tail call ptr @strcpy(ptr %a.gep.1, ptr %b.gep.1)
 219   load i8, ptr %res
 220   %a.gep.5 = getelementptr i8, ptr %a, i32 5
 221   store i8 1, ptr %a.gep.5
 222   %b.gep.5 = getelementptr i8, ptr %b, i32 5
 223   store i8 3, ptr %b.gep.5
 224   ret ptr %res
 225 }
 226
 227 declare ptr @strncpy(ptr, ptr, i64)
 228
 229 define ptr @test_strncpy_const_size(ptr noalias %a, ptr noalias %b) {
 230 ; CHECK-LABEL: Function: test_strncpy_const_size
 231 ; CHECK:       Just Mod:  Ptr: i8* %a   <->  %res = tail call ptr @strncpy(ptr %a, ptr %b, i64 4)
 232 ; CHECK-NEXT:  Just Ref:  Ptr: i8* %b   <->  %res = tail call ptr @strncpy(ptr %a, ptr %b, i64 4)
 233 ; CHECK-NEXT:  Just Mod:  Ptr: i8* %res <->  %res = tail call ptr @strncpy(ptr %a, ptr %b, i64 4)
 234 ; CHECK-NEXT:  Just Mod:  Ptr: i8* %a.gep.1     <->  %res = tail call ptr @strncpy(ptr %a, ptr %b, i64 4)
 235 ; CHECK-NEXT:  NoModRef:  Ptr: i8* %a.gep.5     <->  %res = tail call ptr @strncpy(ptr %a, ptr %b, i64 4)
 236 ; CHECK-NEXT:  Just Ref:  Ptr: i8* %b.gep.1     <->  %res = tail call ptr @strncpy(ptr %a, ptr %b, i64 4)
 237 ; CHECK-NEXT:  NoModRef:  Ptr: i8* %b.gep.5     <->  %res = tail call ptr @strncpy(ptr %a, ptr %b, i64 4)
 238 ;
 239 entry:
 240   load i8, ptr %a
 241   load i8, ptr %b
 242   %res = tail call ptr @strncpy(ptr %a, ptr %b, i64 4)
 243   load i8, ptr %res
 244   %a.gep.1 = getelementptr i8, ptr %a, i32 1
 245   store i8 0, ptr %a.gep.1
 246   %a.gep.5 = getelementptr i8, ptr %a, i32 5
 247   store i8 1, ptr %a.gep.5
 248   %b.gep.1 = getelementptr i8, ptr %b, i32 1
 249   store i8 2, ptr %b.gep.1
 250   %b.gep.5 = getelementptr i8, ptr %b, i32 5
 251   store i8 3, ptr %b.gep.5
 252   ret ptr %res
 253 }
 254
 255 define ptr @test_strncpy_variable_size(ptr noalias %a, ptr noalias %b, i64 %n) {
 256 ; CHECK-LABEL: Function: test_strncpy_variable_size
 257 ; CHECK:       Just Mod:  Ptr: i8* %a   <->  %res = tail call ptr @strncpy(ptr %a, ptr %b, i64 %n)
 258 ; CHECK-NEXT:  Just Ref:  Ptr: i8* %b   <->  %res = tail call ptr @strncpy(ptr %a, ptr %b, i64 %n)
 259 ; CHECK-NEXT:  Just Mod:  Ptr: i8* %res <->  %res = tail call ptr @strncpy(ptr %a, ptr %b, i64 %n)
 260 ; CHECK-NEXT:  Just Mod:  Ptr: i8* %a.gep.1     <->  %res = tail call ptr @strncpy(ptr %a, ptr %b, i64 %n)
 261 ; CHECK-NEXT:  Just Mod:  Ptr: i8* %a.gep.5     <->  %res = tail call ptr @strncpy(ptr %a, ptr %b, i64 %n)
 262 ; CHECK-NEXT:  Just Ref:  Ptr: i8* %b.gep.1     <->  %res = tail call ptr @strncpy(ptr %a, ptr %b, i64 %n)
 263 ; CHECK-NEXT:  Just Ref:  Ptr: i8* %b.gep.5     <->  %res = tail call ptr @strncpy(ptr %a, ptr %b, i64 %n)
 264 ;
 265 entry:
 266   load i8, ptr %a
 267   load i8, ptr %b
 268   %res = tail call ptr @strncpy(ptr %a, ptr %b, i64 %n)
 269   load i8, ptr %res
 270   %a.gep.1 = getelementptr i8, ptr %a, i32 1
 271   store i8 0, ptr %a.gep.1
 272   %a.gep.5 = getelementptr i8, ptr %a, i32 5
 273   store i8 1, ptr %a.gep.5
 274   %b.gep.1 = getelementptr i8, ptr %b, i32 1
 275   store i8 2, ptr %b.gep.1
 276   %b.gep.5 = getelementptr i8, ptr %b, i32 5
 277   store i8 3, ptr %b.gep.5
 278   ret ptr %res
 279 }
 280
 281 declare ptr @__memset_chk(ptr writeonly, i32, i64, i64)
 282
 283 ; CHECK-LABEL: Function: test_memset_chk_const_size
 284 define ptr @test_memset_chk_const_size(ptr noalias %a, i64 %n) {
 285 ; CHECK:       Just Mod:  Ptr: i8* %a   <->  %res = tail call ptr @__memset_chk(ptr %a, i32 0, i64 4, i64 %n)
 286 ; CHECK-NEXT:  Just Mod:  Ptr: i8* %res <->  %res = tail call ptr @__memset_chk(ptr %a, i32 0, i64 4, i64 %n)
 287 ; CHECK-NEXT:  Just Mod:  Ptr: i8* %a.gep.1     <->  %res = tail call ptr @__memset_chk(ptr %a, i32 0, i64 4, i64 %n)
 288 ; CHECK-NEXT:  NoModRef:  Ptr: i8* %a.gep.5     <->  %res = tail call ptr @__memset_chk(ptr %a, i32 0, i64 4, i64 %n)
 289 ;
 290 entry:
 291   load i8, ptr %a
 292   %res = tail call ptr @__memset_chk(ptr %a, i32 0, i64 4, i64 %n)
 293   load i8, ptr %res
 294   %a.gep.1 = getelementptr i8, ptr %a, i32 1
 295   store i8 0, ptr %a.gep.1
 296   %a.gep.5 = getelementptr i8, ptr %a, i32 5
 297   store i8 1, ptr %a.gep.5
 298   ret ptr %res
 299 }
 300
 301 define ptr @test_memset_chk_variable_size(ptr noalias %a, i64 %n.1, i64 %n.2) {
 302 ; CHECK-LABEL: Function: test_memset_chk_variable_size
 303 ; CHECK:       Just Mod:  Ptr: i8* %a   <->  %res = tail call ptr @__memset_chk(ptr %a, i32 0, i64 %n.1, i64 %n.2)
 304 ; CHECK-NEXT:  Just Mod:  Ptr: i8* %res <->  %res = tail call ptr @__memset_chk(ptr %a, i32 0, i64 %n.1, i64 %n.2)
 305 ; CHECK-NEXT:  Just Mod:  Ptr: i8* %a.gep.1     <->  %res = tail call ptr @__memset_chk(ptr %a, i32 0, i64 %n.1, i64 %n.2)
 306 ; CHECK-NEXT:  Just Mod:  Ptr: i8* %a.gep.5     <->  %res = tail call ptr @__memset_chk(ptr %a, i32 0, i64 %n.1, i64 %n.2)
 307 ;
 308 entry:
 309   load i8, ptr %a
 310   %res = tail call ptr @__memset_chk(ptr %a, i32 0, i64 %n.1, i64 %n.2)
 311   load i8, ptr %res
 312   %a.gep.1 = getelementptr i8, ptr %a, i32 1
 313   store i8 0, ptr %a.gep.1
 314   %a.gep.5 = getelementptr i8, ptr %a, i32 5
 315   store i8 1, ptr %a.gep.5
 316   ret ptr %res
 317 }
 318
 319 declare ptr @__memcpy_chk(ptr writeonly, ptr readonly, i64, i64)
 320
 321 define ptr @test_memcpy_chk_const_size(ptr noalias %a, ptr noalias %b, i64 %n) {
 322 ; CHECK-LABEL: Function: test_memcpy_chk_const_size
 323 ; CHECK:       Just Mod:  Ptr: i8* %a   <->  %res = tail call ptr @__memcpy_chk(ptr %a, ptr %b, i64 4, i64 %n)
 324 ; CHECK-NEXT:  Just Mod:  Ptr: i8* %res <->  %res = tail call ptr @__memcpy_chk(ptr %a, ptr %b, i64 4, i64 %n)
 325 ; CHECK-NEXT:  Just Mod:  Ptr: i8* %a.gep.1     <->  %res = tail call ptr @__memcpy_chk(ptr %a, ptr %b, i64 4, i64 %n)
 326 ; CHECK-NEXT:  NoModRef:  Ptr: i8* %a.gep.5     <->  %res = tail call ptr @__memcpy_chk(ptr %a, ptr %b, i64 4, i64 %n)
 327 ; CHECK-NEXT:  Just Ref:  Ptr: i8* %b.gep.1     <->  %res = tail call ptr @__memcpy_chk(ptr %a, ptr %b, i64 4, i64 %n)
 328 ; CHECK-NEXT:  NoModRef:  Ptr: i8* %b.gep.5     <->  %res = tail call ptr @__memcpy_chk(ptr %a, ptr %b, i64 4, i64 %n)
 329 ;
 330 entry:
 331   load i8, ptr %a
 332   %res = tail call ptr @__memcpy_chk(ptr %a, ptr %b, i64 4, i64 %n)
 333   load i8, ptr %res
 334   %a.gep.1 = getelementptr i8, ptr %a, i32 1
 335   store i8 0, ptr %a.gep.1
 336   %a.gep.5 = getelementptr i8, ptr %a, i32 5
 337   store i8 1, ptr %a.gep.5
 338   %b.gep.1 = getelementptr i8, ptr %b, i32 1
 339   store i8 0, ptr %b.gep.1
 340   %b.gep.5 = getelementptr i8, ptr %b, i32 5
 341   store i8 1, ptr %b.gep.5
 342   ret ptr %res
 343 }
 344
 345 define ptr @test_memcpy_chk_variable_size(ptr noalias %a, ptr noalias %b, i64 %n.1, i64 %n.2) {
 346 ; CHECK-LABEL: Function: test_memcpy_chk_variable_size
 347 ; CHECK:       Just Mod:  Ptr: i8* %a   <->  %res = tail call ptr @__memcpy_chk(ptr %a, ptr %b, i64 %n.1, i64 %n.2)
 348 ; CHECK-NEXT:  Just Mod:  Ptr: i8* %res <->  %res = tail call ptr @__memcpy_chk(ptr %a, ptr %b, i64 %n.1, i64 %n.2)
 349 ; CHECK-NEXT:  Just Mod:  Ptr: i8* %a.gep.1     <->  %res = tail call ptr @__memcpy_chk(ptr %a, ptr %b, i64 %n.1, i64 %n.2)
 350 ; CHECK-NEXT:  Just Mod:  Ptr: i8* %a.gep.5     <->  %res = tail call ptr @__memcpy_chk(ptr %a, ptr %b, i64 %n.1, i64 %n.2)
 351 ; CHECK-NEXT:  Just Ref:  Ptr: i8* %b.gep.1     <->  %res = tail call ptr @__memcpy_chk(ptr %a, ptr %b, i64 %n.1, i64 %n.2)
 352 ; CHECK-NEXT:  Just Ref:  Ptr: i8* %b.gep.5     <->  %res = tail call ptr @__memcpy_chk(ptr %a, ptr %b, i64 %n.1, i64 %n.2)
 353 ;
 354 entry:
 355   load i8, ptr %a
 356   %res = tail call ptr @__memcpy_chk(ptr %a, ptr %b, i64 %n.1, i64 %n.2)
 357   load i8, ptr %res
 358   %a.gep.1 = getelementptr i8, ptr %a, i32 1
 359   store i8 0, ptr %a.gep.1
 360   %a.gep.5 = getelementptr i8, ptr %a, i32 5
 361   store i8 1, ptr %a.gep.5
 362   %b.gep.1 = getelementptr i8, ptr %b, i32 1
 363   store i8 0, ptr %b.gep.1
 364   %b.gep.5 = getelementptr i8, ptr %b, i32 5
 365   store i8 1, ptr %b.gep.5
 366   ret ptr %res
 367 }