test/Transforms/FunctionAttrs/arg_returned.ll

   1 ; RUN: opt -functionattrs -S < %s | FileCheck %s --check-prefix=FNATTR
   2 ; RUN: opt -attributor -attributor-manifest-internal -attributor-disable=false -attributor-max-iterations-verify -attributor-max-iterations=6 -S < %s | FileCheck %s --check-prefix=ATTRIBUTOR
   3 ; RUN: opt -attributor -attributor-manifest-internal -attributor-disable=false -functionattrs -S < %s | FileCheck %s --check-prefix=BOTH
   4 ;
   5 ; Test cases specifically designed for the "returned" argument attribute.
   6 ; We use FIXME's to indicate problems and missing attributes.
   7 ;
   8
   9 ; TEST SCC test returning an integer value argument
  10 ;
  11 ; BOTH: Function Attrs: nofree noinline norecurse nosync nounwind readnone uwtable
  12 ; BOTH-NEXT: define i32 @sink_r0(i32 returned %r)
  13 ; BOTH: Function Attrs: nofree noinline nosync nounwind readnone uwtable
  14 ; BOTH-NEXT: define i32 @scc_r1(i32 %a, i32 returned %r, i32 %b)
  15 ; BOTH: Function Attrs: nofree noinline nosync nounwind readnone uwtable
  16 ; BOTH-NEXT: define i32 @scc_r2(i32 %a, i32 %b, i32 returned %r)
  17 ; BOTH: Function Attrs: nofree noinline nosync nounwind readnone uwtable
  18 ; BOTH-NEXT: define i32 @scc_rX(i32 %a, i32 %b, i32 %r)
  19 ;
  20 ; FNATTR: define i32 @sink_r0(i32 returned %r)
  21 ; FNATTR: define i32 @scc_r1(i32 %a, i32 %r, i32 %b)
  22 ; FNATTR: define i32 @scc_r2(i32 %a, i32 %b, i32 %r)
  23 ; FNATTR: define i32 @scc_rX(i32 %a, i32 %b, i32 %r)
  24 ;
  25 ; ATTRIBUTOR: define i32 @sink_r0(i32 returned %r)
  26 ; ATTRIBUTOR: define i32 @scc_r1(i32 %a, i32 returned %r, i32 %b)
  27 ; ATTRIBUTOR: define i32 @scc_r2(i32 %a, i32 %b, i32 returned %r)
  28 ; ATTRIBUTOR: define i32 @scc_rX(i32 %a, i32 %b, i32 %r)
  29 ;
  30 ; int scc_r1(int a, int b, int r);
  31 ; int scc_r2(int a, int b, int r);
  32 ;
  33 ; __attribute__((noinline)) int sink_r0(int r) {
  34 ;   return r;
  35 ; }
  36 ;
  37 ; __attribute__((noinline)) int scc_r1(int a, int r, int b) {
  38 ;   return scc_r2(r, a, sink_r0(r));
  39 ; }
  40 ;
  41 ; __attribute__((noinline)) int scc_r2(int a, int b, int r) {
  42 ;   if (a > b)
  43 ;     return scc_r2(b, a, sink_r0(r));
  44 ;   if (a < b)
  45 ;     return scc_r1(sink_r0(b), scc_r2(scc_r1(a, b, r), scc_r1(a, scc_r2(r, r, r), r), scc_r2(a, b, r)), scc_r1(a, b, r));
  46 ;   return a == b ? r : scc_r2(a, b, r);
  47 ; }
  48 ; __attribute__((noinline)) int scc_rX(int a, int b, int r) {
  49 ;   if (a > b)
  50 ;     return scc_r2(b, a, sink_r0(r));
  51 ;   if (a < b)                                                                         // V Diff to scc_r2
  52 ;     return scc_r1(sink_r0(b), scc_r2(scc_r1(a, b, r), scc_r1(a, scc_r2(r, r, r), r), scc_r1(a, b, r)), scc_r1(a, b, r));
  53 ;   return a == b ? r : scc_r2(a, b, r);
  54 ; }
  55 target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
  56
  57 define i32 @sink_r0(i32 %r) #0 {
  58 entry:
  59   ret i32 %r
  60 }
  61
  62 define i32 @scc_r1(i32 %a, i32 %r, i32 %b) #0 {
  63 entry:
  64   %call = call i32 @sink_r0(i32 %r)
  65   %call1 = call i32 @scc_r2(i32 %r, i32 %a, i32 %call)
  66   ret i32 %call1
  67 }
  68
  69 define i32 @scc_r2(i32 %a, i32 %b, i32 %r) #0 {
  70 entry:
  71   %cmp = icmp sgt i32 %a, %b
  72   br i1 %cmp, label %if.then, label %if.end
  73
  74 if.then:                                          ; preds = %entry
  75   %call = call i32 @sink_r0(i32 %r)
  76   %call1 = call i32 @scc_r2(i32 %b, i32 %a, i32 %call)
  77   br label %return
  78
  79 if.end:                                           ; preds = %entry
  80   %cmp2 = icmp slt i32 %a, %b
  81   br i1 %cmp2, label %if.then3, label %if.end12
  82
  83 if.then3:                                         ; preds = %if.end
  84   %call4 = call i32 @sink_r0(i32 %b)
  85   %call5 = call i32 @scc_r1(i32 %a, i32 %b, i32 %r)
  86   %call6 = call i32 @scc_r2(i32 %r, i32 %r, i32 %r)
  87   %call7 = call i32 @scc_r1(i32 %a, i32 %call6, i32 %r)
  88   %call8 = call i32 @scc_r2(i32 %a, i32 %b, i32 %r)
  89   %call9 = call i32 @scc_r2(i32 %call5, i32 %call7, i32 %call8)
  90   %call10 = call i32 @scc_r1(i32 %a, i32 %b, i32 %r)
  91   %call11 = call i32 @scc_r1(i32 %call4, i32 %call9, i32 %call10)
  92   br label %return
  93
  94 if.end12:                                         ; preds = %if.end
  95   %cmp13 = icmp eq i32 %a, %b
  96   br i1 %cmp13, label %cond.true, label %cond.false
  97
  98 cond.true:                                        ; preds = %if.end12
  99   br label %cond.end
 100
 101 cond.false:                                       ; preds = %if.end12
 102   %call14 = call i32 @scc_r2(i32 %a, i32 %b, i32 %r)
 103   br label %cond.end
 104
 105 cond.end:                                         ; preds = %cond.false, %cond.true
 106   %cond = phi i32 [ %r, %cond.true ], [ %call14, %cond.false ]
 107   br label %return
 108
 109 return:                                           ; preds = %cond.end, %if.then3, %if.then
 110   %retval.0 = phi i32 [ %call1, %if.then ], [ %call11, %if.then3 ], [ %cond, %cond.end ]
 111   ret i32 %retval.0
 112 }
 113
 114 define i32 @scc_rX(i32 %a, i32 %b, i32 %r) #0 {
 115 entry:
 116   %cmp = icmp sgt i32 %a, %b
 117   br i1 %cmp, label %if.then, label %if.end
 118
 119 if.then:                                          ; preds = %entry
 120   %call = call i32 @sink_r0(i32 %r)
 121   %call1 = call i32 @scc_r2(i32 %b, i32 %a, i32 %call)
 122   br label %return
 123
 124 if.end:                                           ; preds = %entry
 125   %cmp2 = icmp slt i32 %a, %b
 126   br i1 %cmp2, label %if.then3, label %if.end12
 127
 128 if.then3:                                         ; preds = %if.end
 129   %call4 = call i32 @sink_r0(i32 %b)
 130   %call5 = call i32 @scc_r1(i32 %a, i32 %b, i32 %r)
 131   %call6 = call i32 @scc_r2(i32 %r, i32 %r, i32 %r)
 132   %call7 = call i32 @scc_r1(i32 %a, i32 %call6, i32 %r)
 133   %call8 = call i32 @scc_r1(i32 %a, i32 %b, i32 %r)
 134   %call9 = call i32 @scc_r2(i32 %call5, i32 %call7, i32 %call8)
 135   %call10 = call i32 @scc_r1(i32 %a, i32 %b, i32 %r)
 136   %call11 = call i32 @scc_r1(i32 %call4, i32 %call9, i32 %call10)
 137   br label %return
 138
 139 if.end12:                                         ; preds = %if.end
 140   %cmp13 = icmp eq i32 %a, %b
 141   br i1 %cmp13, label %cond.true, label %cond.false
 142
 143 cond.true:                                        ; preds = %if.end12
 144   br label %cond.end
 145
 146 cond.false:                                       ; preds = %if.end12
 147   %call14 = call i32 @scc_r2(i32 %a, i32 %b, i32 %r)
 148   br label %cond.end
 149
 150 cond.end:                                         ; preds = %cond.false, %cond.true
 151   %cond = phi i32 [ %r, %cond.true ], [ %call14, %cond.false ]
 152   br label %return
 153
 154 return:                                           ; preds = %cond.end, %if.then3, %if.then
 155   %retval.0 = phi i32 [ %call1, %if.then ], [ %call11, %if.then3 ], [ %cond, %cond.end ]
 156   ret i32 %retval.0
 157 }
 158
 159
 160 ; TEST SCC test returning a pointer value argument
 161 ;
 162 ; BOTH: Function Attrs: nofree noinline norecurse nosync nounwind readnone uwtable
 163 ; BOTH-NEXT: define double* @ptr_sink_r0(double* readnone returned "no-capture-maybe-returned" %r)
 164 ; BOTH: Function Attrs: nofree noinline nosync nounwind readnone uwtable
 165 ; BOTH-NEXT: define double* @ptr_scc_r1(double* %a, double* readnone returned %r, double* nocapture readnone %b)
 166 ; BOTH: Function Attrs: nofree noinline nosync nounwind readnone uwtable
 167 ; BOTH-NEXT: define double* @ptr_scc_r2(double* readnone %a, double* readnone %b, double* readnone returned %r)
 168 ;
 169 ; FNATTR: define double* @ptr_sink_r0(double* readnone returned %r)
 170 ; FNATTR: define double* @ptr_scc_r1(double* %a, double* readnone %r, double* nocapture readnone %b)
 171 ; FNATTR: define double* @ptr_scc_r2(double* readnone %a, double* readnone %b, double* readnone %r)
 172 ;
 173 ; ATTRIBUTOR: Function Attrs: nofree noinline nosync nounwind uwtable
 174 ; ATTRIBUTOR-NEXT: define double* @ptr_sink_r0(double* returned "no-capture-maybe-returned" %r)
 175 ; ATTRIBUTOR: Function Attrs: nofree noinline nosync nounwind uwtable
 176 ; ATTRIBUTOR-NEXT: define double* @ptr_scc_r1(double* %a, double* returned %r, double* nocapture %b)
 177 ; ATTRIBUTOR: Function Attrs: nofree noinline nosync nounwind uwtable
 178 ; ATTRIBUTOR-NEXT: define double* @ptr_scc_r2(double* %a, double* %b, double* returned %r)
 179 ;
 180 ; double* ptr_scc_r1(double* a, double* b, double* r);
 181 ; double* ptr_scc_r2(double* a, double* b, double* r);
 182 ;
 183 ; __attribute__((noinline)) double* ptr_sink_r0(double* r) {
 184 ;   return r;
 185 ; }
 186 ;
 187 ; __attribute__((noinline)) double* ptr_scc_r1(double* a, double* r, double* b) {
 188 ;   return ptr_scc_r2(r, a, ptr_sink_r0(r));
 189 ; }
 190 ;
 191 ; __attribute__((noinline)) double* ptr_scc_r2(double* a, double* b, double* r) {
 192 ;   if (a > b)
 193 ;     return ptr_scc_r2(b, a, ptr_sink_r0(r));
 194 ;   if (a < b)
 195 ;     return ptr_scc_r1(ptr_sink_r0(b), ptr_scc_r2(ptr_scc_r1(a, b, r), ptr_scc_r1(a, ptr_scc_r2(r, r, r), r), ptr_scc_r2(a, b, r)), ptr_scc_r1(a, b, r));
 196 ;   return a == b ? r : ptr_scc_r2(a, b, r);
 197 ; }
 198 define double* @ptr_sink_r0(double* %r) #0 {
 199 entry:
 200   ret double* %r
 201 }
 202
 203 define double* @ptr_scc_r1(double* %a, double* %r, double* %b) #0 {
 204 entry:
 205   %call = call double* @ptr_sink_r0(double* %r)
 206   %call1 = call double* @ptr_scc_r2(double* %r, double* %a, double* %call)
 207   ret double* %call1
 208 }
 209
 210 define double* @ptr_scc_r2(double* %a, double* %b, double* %r) #0 {
 211 entry:
 212   %cmp = icmp ugt double* %a, %b
 213   br i1 %cmp, label %if.then, label %if.end
 214
 215 if.then:                                          ; preds = %entry
 216   %call = call double* @ptr_sink_r0(double* %r)
 217   %call1 = call double* @ptr_scc_r2(double* %b, double* %a, double* %call)
 218   br label %return
 219
 220 if.end:                                           ; preds = %entry
 221   %cmp2 = icmp ult double* %a, %b
 222   br i1 %cmp2, label %if.then3, label %if.end12
 223
 224 if.then3:                                         ; preds = %if.end
 225   %call4 = call double* @ptr_sink_r0(double* %b)
 226   %call5 = call double* @ptr_scc_r1(double* %a, double* %b, double* %r)
 227   %call6 = call double* @ptr_scc_r2(double* %r, double* %r, double* %r)
 228   %call7 = call double* @ptr_scc_r1(double* %a, double* %call6, double* %r)
 229   %call8 = call double* @ptr_scc_r2(double* %a, double* %b, double* %r)
 230   %call9 = call double* @ptr_scc_r2(double* %call5, double* %call7, double* %call8)
 231   %call10 = call double* @ptr_scc_r1(double* %a, double* %b, double* %r)
 232   %call11 = call double* @ptr_scc_r1(double* %call4, double* %call9, double* %call10)
 233   br label %return
 234
 235 if.end12:                                         ; preds = %if.end
 236   %cmp13 = icmp eq double* %a, %b
 237   br i1 %cmp13, label %cond.true, label %cond.false
 238
 239 cond.true:                                        ; preds = %if.end12
 240   br label %cond.end
 241
 242 cond.false:                                       ; preds = %if.end12
 243   %call14 = call double* @ptr_scc_r2(double* %a, double* %b, double* %r)
 244   br label %cond.end
 245
 246 cond.end:                                         ; preds = %cond.false, %cond.true
 247   %cond = phi double* [ %r, %cond.true ], [ %call14, %cond.false ]
 248   br label %return
 249
 250 return:                                           ; preds = %cond.end, %if.then3, %if.then
 251   %retval.0 = phi double* [ %call1, %if.then ], [ %call11, %if.then3 ], [ %cond, %cond.end ]
 252   ret double* %retval.0
 253 }
 254
 255
 256 ; TEST a no-return singleton SCC
 257 ;
 258 ; int* rt0(int *a) {
 259 ;   return *a ? a : rt0(a);
 260 ; }
 261 ;
 262 ; FNATTR:  define i32* @rt0(i32* readonly %a)
 263 ; BOTH: Function Attrs: nofree noinline noreturn nosync nounwind readonly uwtable
 264 ; BOTH-NEXT:    define noalias nonnull align 536870912 dereferenceable(4294967295) i32* @rt0(i32* nocapture readonly %a)
 265 define i32* @rt0(i32* %a) #0 {
 266 entry:
 267   %v = load i32, i32* %a, align 4
 268   %tobool = icmp ne i32 %v, 0
 269   %call = call i32* @rt0(i32* %a)
 270   %sel = select i1 %tobool, i32* %a, i32* %call
 271   ret i32* %sel
 272 }
 273
 274 ; TEST a no-return singleton SCC
 275 ;
 276 ; int* rt1(int *a) {
 277 ;   return *a ? undef : rt1(a);
 278 ; }
 279 ;
 280 ; FNATTR:  define noalias i32* @rt1(i32* nocapture readonly %a)
 281 ; BOTH: Function Attrs: nofree noinline noreturn nosync nounwind readonly uwtable
 282 ; BOTH-NEXT:    define noalias nonnull align 536870912 dereferenceable(4294967295) i32* @rt1(i32* nocapture readonly %a)
 283 define i32* @rt1(i32* %a) #0 {
 284 entry:
 285   %v = load i32, i32* %a, align 4
 286   %tobool = icmp ne i32 %v, 0
 287   %call = call i32* @rt1(i32* %a)
 288   %sel = select i1 %tobool, i32* undef, i32* %call
 289   ret i32* %sel
 290 }
 291
 292 ; TEST another SCC test
 293 ;
 294 ; FNATTR:  define i32* @rt2_helper(i32* %a)
 295 ; FNATTR:  define i32* @rt2(i32* readnone %a, i32* readnone %b)
 296 ; BOTH:    define i32* @rt2_helper(i32* returned %a)
 297 ; BOTH:    define i32* @rt2(i32* readnone %a, i32* readnone "no-capture-maybe-returned" %b)
 298 define i32* @rt2_helper(i32* %a) #0 {
 299 entry:
 300   %call = call i32* @rt2(i32* %a, i32* %a)
 301   ret i32* %call
 302 }
 303
 304 define i32* @rt2(i32* %a, i32 *%b) #0 {
 305 entry:
 306   %cmp = icmp eq i32* %a, null
 307   br i1 %cmp, label %if.then, label %if.end
 308
 309 if.then:
 310   %call = call i32* @rt2_helper(i32* %a)
 311   br label %if.end
 312
 313 if.end:
 314   %sel = phi i32* [ %b, %entry], [%call, %if.then]
 315   ret i32* %sel
 316 }
 317
 318 ; TEST another SCC test
 319 ;
 320 ; FNATTR:  define i32* @rt3_helper(i32* %a, i32* %b)
 321 ; FNATTR:  define i32* @rt3(i32* readnone %a, i32* readnone %b)
 322 ; BOTH:    define i32* @rt3_helper(i32* %a, i32* returned "no-capture-maybe-returned" %b)
 323 ; BOTH:    define i32* @rt3(i32* readnone %a, i32* readnone returned "no-capture-maybe-returned" %b)
 324 define i32* @rt3_helper(i32* %a, i32* %b) #0 {
 325 entry:
 326   %call = call i32* @rt3(i32* %a, i32* %b)
 327   ret i32* %call
 328 }
 329
 330 define i32* @rt3(i32* %a, i32 *%b) #0 {
 331 entry:
 332   %cmp = icmp eq i32* %a, null
 333   br i1 %cmp, label %if.then, label %if.end
 334
 335 if.then:
 336   %call = call i32* @rt3_helper(i32* %a, i32* %b)
 337   br label %if.end
 338
 339 if.end:
 340   %sel = phi i32* [ %b, %entry], [%call, %if.then]
 341   ret i32* %sel
 342 }
 343
 344 ; TEST address taken function with call to an external functions
 345 ;
 346 ;  void unknown_fn(void *);
 347 ;
 348 ;  int* calls_unknown_fn(int *r) {
 349 ;    unknown_fn(&calls_unknown_fn);
 350 ;    return r;
 351 ;  }
 352 ;
 353 ; BOTH: declare void @unknown_fn(i32* (i32*)*)
 354 ;
 355 ; BOTH:       Function Attrs: noinline nounwind uwtable
 356 ; BOTH-NEXT:  define i32* @calls_unknown_fn(i32* readnone returned "no-capture-maybe-returned" %r)
 357 ; FNATTR:     define i32* @calls_unknown_fn(i32* readnone returned %r)
 358 ; ATTRIBUTOR: define i32* @calls_unknown_fn(i32* returned "no-capture-maybe-returned" %r)
 359 declare void @unknown_fn(i32* (i32*)*) #0
 360
 361 define i32* @calls_unknown_fn(i32* %r) #0 {
 362   tail call void @unknown_fn(i32* (i32*)* nonnull @calls_unknown_fn)
 363   ret i32* %r
 364 }
 365
 366
 367 ; TEST call to a function that might be redifined at link time
 368 ;
 369 ;  int *maybe_redefined_fn(int *r) {
 370 ;    return r;
 371 ;  }
 372 ;
 373 ;  int *calls_maybe_redefined_fn(int *r) {
 374 ;    maybe_redefined_fn(r);
 375 ;    return r;
 376 ;  }
 377 ;
 378 ; Verify the maybe-redefined function is not annotated:
 379 ;
 380 ; CHECK: Function Attrs: noinline nounwind uwtable
 381 ; CHECK: define linkonce_odr i32* @maybe_redefined_fn(i32* %r)
 382 ;
 383 ; CHECK: Function Attrs: noinline nounwind uwtable
 384 ; CHECK: define i32* @calls_maybe_redefined_fn(i32* returned %r)
 385 ;
 386 ; BOTH: Function Attrs: noinline nounwind uwtable
 387 ; BOTH-NEXT: define linkonce_odr i32* @maybe_redefined_fn(i32* %r)
 388 ;
 389 ; BOTH: Function Attrs: noinline nounwind uwtable
 390 ; BOTH-NEXT: define i32* @calls_maybe_redefined_fn(i32* returned %r)
 391 define linkonce_odr i32* @maybe_redefined_fn(i32* %r) #0 {
 392 entry:
 393   ret i32* %r
 394 }
 395
 396 define i32* @calls_maybe_redefined_fn(i32* %r) #0 {
 397 entry:
 398   %call = call i32* @maybe_redefined_fn(i32* %r)
 399   ret i32* %r
 400 }
 401
 402 ; TEST return call to a function that might be redifined at link time
 403 ;
 404 ;  int *maybe_redefined_fn2(int *r) {
 405 ;    return r;
 406 ;  }
 407 ;
 408 ;  int *calls_maybe_redefined_fn2(int *r) {
 409 ;    return maybe_redefined_fn2(r);
 410 ;  }
 411 ;
 412 ; Verify the maybe-redefined function is not annotated:
 413 ;
 414 ; BOTH: Function Attrs: noinline nounwind uwtable
 415 ; BOTH-NEXT: define linkonce_odr i32* @maybe_redefined_fn2(i32* %r)
 416 ; BOTH: Function Attrs: noinline nounwind uwtable
 417 ; BOTH-NEXT: define i32* @calls_maybe_redefined_fn2(i32* %r)
 418 ;
 419 ; FNATTR:     define i32* @calls_maybe_redefined_fn2(i32* %r)
 420 ; ATTRIBUTOR: define i32* @calls_maybe_redefined_fn2(i32* %r)
 421 define linkonce_odr i32* @maybe_redefined_fn2(i32* %r) #0 {
 422 entry:
 423   ret i32* %r
 424 }
 425
 426 define i32* @calls_maybe_redefined_fn2(i32* %r) #0 {
 427 entry:
 428   %call = call i32* @maybe_redefined_fn2(i32* %r)
 429   ret i32* %call
 430 }
 431
 432
 433 ; TEST returned argument goes through select and phi
 434 ;
 435 ; double select_and_phi(double b) {
 436 ;   double x = b;
 437 ;   if (b > 0)
 438 ;     x = b;
 439 ;   return b == 0? b : x;
 440 ; }
 441 ;
 442 ; BOTH: Function Attrs: nofree noinline norecurse nosync nounwind readnone uwtable
 443 ; BOTH-NEXT: define double @select_and_phi(double returned %b)
 444 ;
 445 ; FNATTR:     define double @select_and_phi(double %b)
 446 ; ATTRIBUTOR: Function Attrs: nofree noinline nosync nounwind uwtable
 447 ; ATTRIBUTOR-NEXT: define double @select_and_phi(double returned %b)
 448 define double @select_and_phi(double %b) #0 {
 449 entry:
 450   %cmp = fcmp ogt double %b, 0.000000e+00
 451   br i1 %cmp, label %if.then, label %if.end
 452
 453 if.then:                                          ; preds = %entry
 454   br label %if.end
 455
 456 if.end:                                           ; preds = %if.then, %entry
 457   %phi = phi double [ %b, %if.then ], [ %b, %entry ]
 458   %cmp1 = fcmp oeq double %b, 0.000000e+00
 459   %sel = select i1 %cmp1, double %b, double %phi
 460   ret double %sel
 461 }
 462
 463
 464 ; TEST returned argument goes through recursion, select, and phi
 465 ;
 466 ; double recursion_select_and_phi(int a, double b) {
 467 ;   double x = b;
 468 ;   if (a-- > 0)
 469 ;     x = recursion_select_and_phi(a, b);
 470 ;   return b == 0? b : x;
 471 ; }
 472 ;
 473 ; BOTH: Function Attrs: nofree noinline nosync nounwind readnone uwtable
 474 ; BOTH-NEXT: define double @recursion_select_and_phi(i32 %a, double returned %b)
 475 ;
 476 ; FNATTR:     define double @recursion_select_and_phi(i32 %a, double %b)
 477 ;
 478 ; ATTRIBUTOR: Function Attrs: nofree noinline nosync nounwind uwtable
 479 ; ATTRIBUTOR-NEXT: define double @recursion_select_and_phi(i32 %a, double returned %b)
 480 define double @recursion_select_and_phi(i32 %a, double %b) #0 {
 481 entry:
 482   %dec = add nsw i32 %a, -1
 483   %cmp = icmp sgt i32 %a, 0
 484   br i1 %cmp, label %if.then, label %if.end
 485
 486 if.then:                                          ; preds = %entry
 487   %call = call double @recursion_select_and_phi(i32 %dec, double %b)
 488   br label %if.end
 489
 490 if.end:                                           ; preds = %if.then, %entry
 491   %phi = phi double [ %call, %if.then ], [ %b, %entry ]
 492   %cmp1 = fcmp oeq double %b, 0.000000e+00
 493   %sel = select i1 %cmp1, double %b, double %phi
 494   ret double %sel
 495 }
 496
 497
 498 ; TEST returned argument goes through bitcasts
 499 ;
 500 ; double* bitcast(int* b) {
 501 ;   return (double*)b;
 502 ; }
 503 ;
 504 ; BOTH: Function Attrs: nofree noinline norecurse nosync nounwind readnone uwtable
 505 ; BOTH-NEXT:  define double* @bitcast(i32* readnone returned "no-capture-maybe-returned" %b)
 506 ;
 507 ; FNATTR:     define double* @bitcast(i32* readnone %b)
 508 ;
 509 ; ATTRIBUTOR: Function Attrs: nofree noinline nosync nounwind uwtable
 510 ; ATTRIBUTOR-NEXT: define double* @bitcast(i32* returned "no-capture-maybe-returned" %b)
 511 define double* @bitcast(i32* %b) #0 {
 512 entry:
 513   %bc0 = bitcast i32* %b to double*
 514   ret double* %bc0
 515 }
 516
 517
 518 ; TEST returned argument goes through select and phi interleaved with bitcasts
 519 ;
 520 ; double* bitcasts_select_and_phi(int* b) {
 521 ;   double* x = b;
 522 ;   if (b == 0)
 523 ;     x = b;
 524 ;   return b != 0 ? b : x;
 525 ; }
 526 ;
 527 ; BOTH: Function Attrs: nofree noinline norecurse nosync nounwind readnone uwtable
 528 ; BOTH-NEXT: define double* @bitcasts_select_and_phi(i32* readnone returned %b)
 529 ;
 530 ; FNATTR:     define double* @bitcasts_select_and_phi(i32* readnone %b)
 531 ;
 532 ; ATTRIBUTOR: Function Attrs: nofree noinline nosync nounwind uwtable
 533 ; ATTRIBUTOR-NEXT: define double* @bitcasts_select_and_phi(i32* returned %b)
 534 define double* @bitcasts_select_and_phi(i32* %b) #0 {
 535 entry:
 536   %bc0 = bitcast i32* %b to double*
 537   %cmp = icmp eq double* %bc0, null
 538   br i1 %cmp, label %if.then, label %if.end
 539
 540 if.then:                                          ; preds = %entry
 541   %bc1 = bitcast i32* %b to double*
 542   br label %if.end
 543
 544 if.end:                                           ; preds = %if.then, %entry
 545   %phi = phi double* [ %bc1, %if.then ], [ %bc0, %entry ]
 546   %bc2 = bitcast double* %phi to i8*
 547   %bc3 = bitcast i32* %b to i8*
 548   %cmp2 = icmp ne double* %bc0, null
 549   %sel = select i1 %cmp2, i8* %bc2, i8* %bc3
 550   %bc4 = bitcast i8* %sel to double*
 551   ret double* %bc4
 552 }
 553
 554
 555 ; TEST return argument or argument or undef
 556 ;
 557 ; double* ret_arg_arg_undef(int* b) {
 558 ;   if (b == 0)
 559 ;     return (double*)b;
 560 ;   if (b == 0)
 561 ;     return (double*)b;
 562 ;   /* return undef */
 563 ; }
 564 ;
 565 ; BOTH: Function Attrs: nofree noinline norecurse nosync nounwind readnone uwtable
 566 ; BOTH-NEXT:  define double* @ret_arg_arg_undef(i32* readnone returned %b)
 567 ;
 568 ; FNATTR:     define double* @ret_arg_arg_undef(i32* readnone %b)
 569 ;
 570 ; ATTRIBUTOR: Function Attrs: nofree noinline nosync nounwind uwtable
 571 ; ATTRIBUTOR-NEXT: define double* @ret_arg_arg_undef(i32* returned %b)
 572 define double* @ret_arg_arg_undef(i32* %b) #0 {
 573 entry:
 574   %bc0 = bitcast i32* %b to double*
 575   %cmp = icmp eq double* %bc0, null
 576   br i1 %cmp, label %ret_arg0, label %if.end
 577
 578 ret_arg0:
 579   %bc1 = bitcast i32* %b to double*
 580   ret double* %bc1
 581
 582 if.end:
 583   br i1 %cmp, label %ret_arg1, label %ret_undef
 584
 585 ret_arg1:
 586   ret double* %bc0
 587
 588 ret_undef:
 589   ret double *undef
 590 }
 591
 592
 593 ; TEST return undef or argument or argument
 594 ;
 595 ; double* ret_undef_arg_arg(int* b) {
 596 ;   if (b == 0)
 597 ;     return (double*)b;
 598 ;   if (b == 0)
 599 ;     return (double*)b;
 600 ;   /* return undef */
 601 ; }
 602 ;
 603 ; BOTH: Function Attrs: nofree noinline norecurse nosync nounwind readnone uwtable
 604 ; BOTH-NEXT:  define double* @ret_undef_arg_arg(i32* readnone returned %b)
 605 ;
 606 ; FNATTR:     define double* @ret_undef_arg_arg(i32* readnone %b)
 607 ;
 608 ; ATTRIBUTOR: Function Attrs: nofree noinline nosync nounwind uwtable
 609 ; ATTRIBUTOR-NEXT: define double* @ret_undef_arg_arg(i32* returned %b)
 610 define double* @ret_undef_arg_arg(i32* %b) #0 {
 611 entry:
 612   %bc0 = bitcast i32* %b to double*
 613   %cmp = icmp eq double* %bc0, null
 614   br i1 %cmp, label %ret_undef, label %if.end
 615
 616 ret_undef:
 617   ret double *undef
 618
 619 if.end:
 620   br i1 %cmp, label %ret_arg0, label %ret_arg1
 621
 622 ret_arg0:
 623   ret double* %bc0
 624
 625 ret_arg1:
 626   %bc1 = bitcast i32* %b to double*
 627   ret double* %bc1
 628 }
 629
 630
 631 ; TEST return undef or argument or undef
 632 ;
 633 ; double* ret_undef_arg_undef(int* b) {
 634 ;   if (b == 0)
 635 ;     /* return undef */
 636 ;   if (b == 0)
 637 ;     return (double*)b;
 638 ;   /* return undef */
 639 ; }
 640 ;
 641 ; BOTH: Function Attrs: nofree noinline norecurse nosync nounwind readnone uwtable
 642 ; BOTH-NEXT:  define double* @ret_undef_arg_undef(i32* readnone returned %b)
 643 ;
 644 ; FNATTR:     define double* @ret_undef_arg_undef(i32* readnone %b)
 645 ; ATTRIBUTOR: define double* @ret_undef_arg_undef(i32* returned %b)
 646 define double* @ret_undef_arg_undef(i32* %b) #0 {
 647 entry:
 648   %bc0 = bitcast i32* %b to double*
 649   %cmp = icmp eq double* %bc0, null
 650   br i1 %cmp, label %ret_undef0, label %if.end
 651
 652 ret_undef0:
 653   ret double *undef
 654
 655 if.end:
 656   br i1 %cmp, label %ret_arg, label %ret_undef1
 657
 658 ret_arg:
 659   ret double* %bc0
 660
 661 ret_undef1:
 662   ret double *undef
 663 }
 664
 665 ; TEST return argument or unknown call result
 666 ;
 667 ; int* ret_arg_or_unknown(int* b) {
 668 ;   if (b == 0)
 669 ;     return b;
 670 ;   return unknown();
 671 ; }
 672 ;
 673 ; Verify we do not assume b is returned
 674 ;
 675 ; FNATTR:     define i32* @ret_arg_or_unknown(i32* %b)
 676 ; FNATTR:     define i32* @ret_arg_or_unknown_through_phi(i32* %b)
 677 ; ATTRIBUTOR: define i32* @ret_arg_or_unknown(i32* %b)
 678 ; ATTRIBUTOR: define i32* @ret_arg_or_unknown_through_phi(i32* %b)
 679 ; BOTH:       define i32* @ret_arg_or_unknown(i32* %b)
 680 ; BOTH:       define i32* @ret_arg_or_unknown_through_phi(i32* %b)
 681 declare i32* @unknown(i32*)
 682
 683 define i32* @ret_arg_or_unknown(i32* %b) #0 {
 684 entry:
 685   %cmp = icmp eq i32* %b, null
 686   br i1 %cmp, label %ret_arg, label %ret_unknown
 687
 688 ret_arg:
 689   ret i32* %b
 690
 691 ret_unknown:
 692   %call = call i32* @unknown(i32* %b)
 693   ret i32* %call
 694 }
 695
 696 define i32* @ret_arg_or_unknown_through_phi(i32* %b) #0 {
 697 entry:
 698   %cmp = icmp eq i32* %b, null
 699   br i1 %cmp, label %ret_arg, label %ret_unknown
 700
 701 ret_arg:
 702   br label %r
 703
 704 ret_unknown:
 705   %call = call i32* @unknown(i32* %b)
 706   br label %r
 707
 708 r:
 709   %phi = phi i32* [ %b, %ret_arg ], [ %call, %ret_unknown ]
 710   ret i32* %phi
 711 }
 712
 713 ; TEST inconsistent IR in dead code.
 714 ;
 715 ; FNATTR:     define i32 @deadblockcall1(i32 %A)
 716 ; FNATTR:     define i32 @deadblockcall2(i32 %A)
 717 ; FNATTR:     define i32 @deadblockphi1(i32 %A)
 718 ; FNATTR:     define i32 @deadblockphi2(i32 %A)
 719 ; ATTRIBUTOR: define i32 @deadblockcall1(i32 returned %A)
 720 ; ATTRIBUTOR: define i32 @deadblockcall2(i32 returned %A)
 721 ; ATTRIBUTOR: define i32 @deadblockphi1(i32 returned %A)
 722 ; ATTRIBUTOR: define i32 @deadblockphi2(i32 returned %A)
 723 ; BOTH:       define i32 @deadblockcall1(i32 returned %A)
 724 ; BOTH:       define i32 @deadblockcall2(i32 returned %A)
 725 ; BOTH:       define i32 @deadblockphi1(i32 returned %A)
 726 ; BOTH:       define i32 @deadblockphi2(i32 returned %A)
 727 define i32 @deadblockcall1(i32 %A) #0 {
 728 entry:
 729   ret i32 %A
 730 unreachableblock:
 731   %B = call i32 @deadblockcall1(i32 %B)
 732   ret i32 %B
 733 }
 734
 735 declare i32 @deadblockcall_helper(i32 returned %A);
 736
 737 define i32 @deadblockcall2(i32 %A) #0 {
 738 entry:
 739   ret i32 %A
 740 unreachableblock1:
 741   %B = call i32 @deadblockcall_helper(i32 %B)
 742   ret i32 %B
 743 unreachableblock2:
 744   %C = call i32 @deadblockcall1(i32 %C)
 745   ret i32 %C
 746 }
 747
 748 define i32 @deadblockphi1(i32 %A) #0 {
 749 entry:
 750   br label %r
 751 unreachableblock1:
 752   %B = call i32 @deadblockcall_helper(i32 %B)
 753   ret i32 %B
 754 unreachableblock2:
 755   %C = call i32 @deadblockcall1(i32 %C)
 756   br label %r
 757 r:
 758   %PHI = phi i32 [%A, %entry], [%C, %unreachableblock2]
 759   ret i32 %PHI
 760 }
 761
 762 define i32 @deadblockphi2(i32 %A) #0 {
 763 entry:
 764   br label %r
 765 unreachableblock1:
 766   %B = call i32 @deadblockcall_helper(i32 %B)
 767   br label %unreachableblock3
 768 unreachableblock2:
 769   %C = call i32 @deadblockcall1(i32 %C)
 770   br label %unreachableblock3
 771 unreachableblock3:
 772   %PHI1 = phi i32 [%B, %unreachableblock1], [%C, %unreachableblock2]
 773   br label %r
 774 r:
 775   %PHI2 = phi i32 [%A, %entry], [%PHI1, %unreachableblock3]
 776   ret i32 %PHI2
 777 }
 778
 779 declare void @noreturn() noreturn;
 780
 781 define i32 @deadblockphi3(i32 %A, i1 %c) #0 {
 782 entry:
 783   br i1 %c, label %r, label %unreachablecall
 784 unreachablecall:
 785   call void @noreturn();
 786   %B = call i32 @deadblockcall_helper(i32 0)
 787   br label %unreachableblock3
 788 unreachableblock2:
 789   %C = call i32 @deadblockcall1(i32 %C)
 790   br label %unreachableblock3
 791 unreachableblock3:
 792   %PHI1 = phi i32 [%B, %unreachablecall], [%C, %unreachableblock2]
 793   br label %r
 794 r:
 795   %PHI2 = phi i32 [%A, %entry], [%PHI1, %unreachableblock3]
 796   ret i32 %PHI2
 797 }
 798
 799 define weak_odr i32 @non_exact_0() {
 800   ret i32 0
 801 }
 802 define weak_odr i32 @non_exact_1(i32 %a) {
 803   ret i32 %a
 804 }
 805 define weak_odr i32 @non_exact_2(i32 returned %a) {
 806   ret i32 %a
 807 }
 808 define weak_odr i32* @non_exact_3(i32* align 32 returned %a) {
 809   ret i32* %a
 810 }
 811 define i32 @exact(i32* %a) {
 812   %c0 = call i32 @non_exact_0()
 813   %c1 = call i32 @non_exact_1(i32 1)
 814   %c2 = call i32 @non_exact_2(i32 2)
 815   %c3 = call i32* @non_exact_3(i32* %a)
 816 ; We can use the information of the weak function non_exact_3 because it was
 817 ; given to us and not derived (the alignment of the returned argument).
 818 ; CHECK:  %c4 = load i32, i32* %c3, align 32
 819   %c4 = load i32, i32* %c3
 820 ; FIXME: %c2 and %c3 should be replaced but not %c0 or %c1!
 821 ; CHECK:  %add1 = add i32 %c0, %c1
 822 ; CHECK:  %add2 = add i32 %add1, %c2
 823 ; CHECK:  %add3 = add i32 %add2, %c3
 824   %add1 = add i32 %c0, %c1
 825   %add2 = add i32 %add1, %c2
 826   %add3 = add i32 %add2, %c4
 827   ret i32 %add3
 828 }
 829
 830 @G = external global i8
 831 define i32* @ret_const() #0 {
 832   %bc = bitcast i8* @G to i32*
 833   ret i32* %bc
 834 }
 835 define i32* @use_const() #0 {
 836   %c = call i32* @ret_const()
 837   ; CHECK: ret i32* bitcast (i8* @G to i32*)
 838   ret i32* %c
 839 }
 840
 841 attributes #0 = { noinline nounwind uwtable }
 842
 843 ; BOTH-NOT: attributes #
 844 ; BOTH-DAG: attributes #{{[0-9]*}} = { nofree noinline norecurse nosync nounwind readnone uwtable willreturn }
 845 ; BOTH-DAG: attributes #{{[0-9]*}} = { nofree noinline nosync nounwind readnone uwtable }
 846 ; BOTH-DAG: attributes #{{[0-9]*}} = { nofree noinline noreturn nosync nounwind readonly uwtable }
 847 ; BOTH-DAG: attributes #{{[0-9]*}} = { noinline nounwind uwtable }
 848 ; BOTH-DAG: attributes #{{[0-9]*}} = { noreturn }
 849 ; BOTH-DAG: attributes #{{[0-9]*}} = { nofree nosync willreturn }
 850 ; BOTH-DAG: attributes #{{[0-9]*}} = { nofree nosync }
 851 ; BOTH-DAG: attributes #{{[0-9]*}} = { nofree noreturn nosync }
 852 ; BOTH-NOT: attributes #