test/Transforms/InferFunctionAttrs/annotate.ll

   1 ; RUN: opt < %s -mtriple=x86_64-- -inferattrs -S | FileCheck -check-prefix=CHECK-UNKNOWN %s
   2 ; RUN: opt < %s -mtriple=x86_64-- -passes=inferattrs -S | FileCheck -check-prefix=CHECK-UNKNOWN %s
   3 ; RUN: opt < %s -mtriple=x86_64-apple-macosx10.8.0 -inferattrs -S | FileCheck -check-prefix=CHECK -check-prefix=CHECK-DARWIN %s
   4 ; RUN: opt < %s -mtriple=x86_64-unknown-linux-gnu -inferattrs -S | FileCheck -check-prefix=CHECK -check-prefix=CHECK-LINUX %s
   5 ; RUN: opt < %s -mtriple=nvptx -inferattrs -S | FileCheck -check-prefix=CHECK-NVPTX %s
   6
   7 ; operator new routines
   8 declare i8* @_Znwj(i64 )
   9 ; CHECK: declare noalias nonnull i8* @_Znwj(i64) [[G0:#[0-9]+]]
  10 declare i8* @_Znwm(i64)
  11 ; CHECK: declare noalias nonnull i8* @_Znwm(i64) [[G0]]
  12
  13 declare i32 @__nvvm_reflect(i8*)
  14 ; CHECK-NVPTX: declare i32 @__nvvm_reflect(i8*) [[G0:#[0-9]+]]
  15 ; CHECK-NVPTX: attributes [[G0]] = { nofree nounwind readnone }
  16
  17
  18 ; Check all the libc functions (thereby also exercising the prototype check).
  19 ; Note that it's OK to modify these as attributes might be missing. These checks
  20 ; reflect the currently inferred attributes.
  21
  22 ; Use an opaque pointer type for all the (possibly opaque) structs.
  23 %opaque = type opaque
  24
  25 ; CHECK: declare double @__acos_finite(double)
  26 declare double @__acos_finite(double)
  27
  28 ; CHECK: declare float @__acosf_finite(float)
  29 declare float @__acosf_finite(float)
  30
  31 ; CHECK: declare double @__acosh_finite(double)
  32 declare double @__acosh_finite(double)
  33
  34 ; CHECK: declare float @__acoshf_finite(float)
  35 declare float @__acoshf_finite(float)
  36
  37 ; CHECK: declare x86_fp80 @__acoshl_finite(x86_fp80)
  38 declare x86_fp80 @__acoshl_finite(x86_fp80)
  39
  40 ; CHECK: declare x86_fp80 @__acosl_finite(x86_fp80)
  41 declare x86_fp80 @__acosl_finite(x86_fp80)
  42
  43 ; CHECK: declare double @__asin_finite(double)
  44 declare double @__asin_finite(double)
  45
  46 ; CHECK: declare float @__asinf_finite(float)
  47 declare float @__asinf_finite(float)
  48
  49 ; CHECK: declare x86_fp80 @__asinl_finite(x86_fp80)
  50 declare x86_fp80 @__asinl_finite(x86_fp80)
  51
  52 ; CHECK: declare double @__atan2_finite(double, double)
  53 declare double @__atan2_finite(double, double)
  54
  55 ; CHECK: declare float @__atan2f_finite(float, float)
  56 declare float @__atan2f_finite(float, float)
  57
  58 ; CHECK: declare x86_fp80 @__atan2l_finite(x86_fp80, x86_fp80)
  59 declare x86_fp80 @__atan2l_finite(x86_fp80, x86_fp80)
  60
  61 ; CHECK: declare double @__atanh_finite(double)
  62 declare double @__atanh_finite(double)
  63
  64 ; CHECK: declare float @__atanhf_finite(float)
  65 declare float @__atanhf_finite(float)
  66
  67 ; CHECK: declare x86_fp80 @__atanhl_finite(x86_fp80)
  68 declare x86_fp80 @__atanhl_finite(x86_fp80)
  69
  70 ; CHECK: declare double @__cosh_finite(double)
  71 declare double @__cosh_finite(double)
  72
  73 ; CHECK: declare float @__coshf_finite(float)
  74 declare float @__coshf_finite(float)
  75
  76 ; CHECK: declare x86_fp80 @__coshl_finite(x86_fp80)
  77 declare x86_fp80 @__coshl_finite(x86_fp80)
  78
  79 ; CHECK: declare double @__cospi(double)
  80 declare double @__cospi(double)
  81
  82 ; CHECK: declare float @__cospif(float)
  83 declare float @__cospif(float)
  84
  85 ; CHECK: declare double @__exp10_finite(double)
  86 declare double @__exp10_finite(double)
  87
  88 ; CHECK: declare float @__exp10f_finite(float)
  89 declare float @__exp10f_finite(float)
  90
  91 ; CHECK: declare x86_fp80 @__exp10l_finite(x86_fp80)
  92 declare x86_fp80 @__exp10l_finite(x86_fp80)
  93
  94 ; CHECK: declare double @__exp2_finite(double)
  95 declare double @__exp2_finite(double)
  96
  97 ; CHECK: declare float @__exp2f_finite(float)
  98 declare float @__exp2f_finite(float)
  99
 100 ; CHECK: declare x86_fp80 @__exp2l_finite(x86_fp80)
 101 declare x86_fp80 @__exp2l_finite(x86_fp80)
 102
 103 ; CHECK: declare double @__exp_finite(double)
 104 declare double @__exp_finite(double)
 105
 106 ; CHECK: declare float @__expf_finite(float)
 107 declare float @__expf_finite(float)
 108
 109 ; CHECK: declare x86_fp80 @__expl_finite(x86_fp80)
 110 declare x86_fp80 @__expl_finite(x86_fp80)
 111
 112 ; CHECK: declare double @__log10_finite(double)
 113 declare double @__log10_finite(double)
 114
 115 ; CHECK: declare float @__log10f_finite(float)
 116 declare float @__log10f_finite(float)
 117
 118 ; CHECK: declare x86_fp80 @__log10l_finite(x86_fp80)
 119 declare x86_fp80 @__log10l_finite(x86_fp80)
 120
 121 ; CHECK: declare double @__log2_finite(double)
 122 declare double @__log2_finite(double)
 123
 124 ; CHECK: declare float @__log2f_finite(float)
 125 declare float @__log2f_finite(float)
 126
 127 ; CHECK: declare x86_fp80 @__log2l_finite(x86_fp80)
 128 declare x86_fp80 @__log2l_finite(x86_fp80)
 129
 130 ; CHECK: declare double @__log_finite(double)
 131 declare double @__log_finite(double)
 132
 133 ; CHECK: declare float @__logf_finite(float)
 134 declare float @__logf_finite(float)
 135
 136 ; CHECK: declare x86_fp80 @__logl_finite(x86_fp80)
 137 declare x86_fp80 @__logl_finite(x86_fp80)
 138
 139 ; CHECK: declare double @__pow_finite(double, double)
 140 declare double @__pow_finite(double, double)
 141
 142 ; CHECK: declare float @__powf_finite(float, float)
 143 declare float @__powf_finite(float, float)
 144
 145 ; CHECK: declare x86_fp80 @__powl_finite(x86_fp80, x86_fp80)
 146 declare x86_fp80 @__powl_finite(x86_fp80, x86_fp80)
 147
 148 ; CHECK: declare double @__sinh_finite(double)
 149 declare double @__sinh_finite(double)
 150
 151 ; CHECK: declare float @__sinhf_finite(float)
 152 declare float @__sinhf_finite(float)
 153
 154 ; CHECK: declare x86_fp80 @__sinhl_finite(x86_fp80)
 155 declare x86_fp80 @__sinhl_finite(x86_fp80)
 156
 157 ; CHECK: declare double @__sinpi(double)
 158 declare double @__sinpi(double)
 159
 160 ; CHECK: declare float @__sinpif(float)
 161 declare float @__sinpif(float)
 162
 163 ; CHECK: declare i32 @abs(i32) [[G0]]
 164 declare i32 @abs(i32)
 165
 166 ; CHECK: declare i32 @access(i8* nocapture readonly, i32) [[G1:#[0-9]+]]
 167 declare i32 @access(i8*, i32)
 168
 169 ; CHECK: declare double @acos(double) [[G0]]
 170 declare double @acos(double)
 171
 172 ; CHECK: declare float @acosf(float) [[G0]]
 173 declare float @acosf(float)
 174
 175 ; CHECK: declare double @acosh(double) [[G0]]
 176 declare double @acosh(double)
 177
 178 ; CHECK: declare float @acoshf(float) [[G0]]
 179 declare float @acoshf(float)
 180
 181 ; CHECK: declare x86_fp80 @acoshl(x86_fp80) [[G0]]
 182 declare x86_fp80 @acoshl(x86_fp80)
 183
 184 ; CHECK: declare x86_fp80 @acosl(x86_fp80) [[G0]]
 185 declare x86_fp80 @acosl(x86_fp80)
 186
 187 ; CHECK: declare double @asin(double) [[G0]]
 188 declare double @asin(double)
 189
 190 ; CHECK: declare float @asinf(float) [[G0]]
 191 declare float @asinf(float)
 192
 193 ; CHECK: declare double @asinh(double) [[G0]]
 194 declare double @asinh(double)
 195
 196 ; CHECK: declare float @asinhf(float) [[G0]]
 197 declare float @asinhf(float)
 198
 199 ; CHECK: declare x86_fp80 @asinhl(x86_fp80) [[G0]]
 200 declare x86_fp80 @asinhl(x86_fp80)
 201
 202 ; CHECK: declare x86_fp80 @asinl(x86_fp80) [[G0]]
 203 declare x86_fp80 @asinl(x86_fp80)
 204
 205 ; CHECK: declare double @atan(double) [[G0]]
 206 declare double @atan(double)
 207
 208 ; CHECK: declare double @atan2(double, double) [[G0]]
 209 declare double @atan2(double, double)
 210
 211 ; CHECK: declare float @atan2f(float, float) [[G0]]
 212 declare float @atan2f(float, float)
 213
 214 ; CHECK: declare x86_fp80 @atan2l(x86_fp80, x86_fp80) [[G0]]
 215 declare x86_fp80 @atan2l(x86_fp80, x86_fp80)
 216
 217 ; CHECK: declare float @atanf(float) [[G0]]
 218 declare float @atanf(float)
 219
 220 ; CHECK: declare double @atanh(double) [[G0]]
 221 declare double @atanh(double)
 222
 223 ; CHECK: declare float @atanhf(float) [[G0]]
 224 declare float @atanhf(float)
 225
 226 ; CHECK: declare x86_fp80 @atanhl(x86_fp80) [[G0]]
 227 declare x86_fp80 @atanhl(x86_fp80)
 228
 229 ; CHECK: declare x86_fp80 @atanl(x86_fp80) [[G0]]
 230 declare x86_fp80 @atanl(x86_fp80)
 231
 232 ; CHECK: declare double @atof(i8* nocapture) [[G2:#[0-9]+]]
 233 declare double @atof(i8*)
 234
 235 ; CHECK: declare i32 @atoi(i8* nocapture) [[G2]]
 236 declare i32 @atoi(i8*)
 237
 238 ; CHECK: declare i64 @atol(i8* nocapture) [[G2]]
 239 declare i64 @atol(i8*)
 240
 241 ; CHECK: declare i64 @atoll(i8* nocapture) [[G2]]
 242 declare i64 @atoll(i8*)
 243
 244 ; CHECK-LINUX: declare i32 @bcmp(i8* nocapture, i8* nocapture, i64) [[G2]]
 245 ; CHECK-DARWIN-NOT: declare i32 @bcmp(i8* nocapture, i8* nocapture, i64) [[G2]]
 246 ; CHECK-UNKNOWN-NOT: declare i32 @bcmp(i8* nocapture, i8* nocapture, i64) [[G2]]
 247 ; CHECK-NVPTX-NOT: declare i32 @bcmp(i8* nocapture, i8* nocapture, i64) [[G2]]
 248 declare i32 @bcmp(i8*, i8*, i64)
 249
 250 ; CHECK: declare void @bcopy(i8* nocapture readonly, i8* nocapture, i64) [[G1]]
 251 declare void @bcopy(i8*, i8*, i64)
 252
 253 ; CHECK: declare void @bzero(i8* nocapture, i64) [[G1]]
 254 declare void @bzero(i8*, i64)
 255
 256 ; CHECK: declare noalias i8* @calloc(i64, i64) [[G1]]
 257 declare i8* @calloc(i64, i64)
 258
 259 ; CHECK: declare double @cbrt(double) [[G0]]
 260 declare double @cbrt(double)
 261
 262 ; CHECK: declare float @cbrtf(float) [[G0]]
 263 declare float @cbrtf(float)
 264
 265 ; CHECK: declare x86_fp80 @cbrtl(x86_fp80) [[G0]]
 266 declare x86_fp80 @cbrtl(x86_fp80)
 267
 268 ; CHECK: declare double @ceil(double) [[G0]]
 269 declare double @ceil(double)
 270
 271 ; CHECK: declare float @ceilf(float) [[G0]]
 272 declare float @ceilf(float)
 273
 274 ; CHECK: declare x86_fp80 @ceill(x86_fp80) [[G0]]
 275 declare x86_fp80 @ceill(x86_fp80)
 276
 277 ; CHECK: declare i32 @chmod(i8* nocapture readonly, i16 zeroext) [[G1]]
 278 declare i32 @chmod(i8*, i16 zeroext)
 279
 280 ; CHECK: declare i32 @chown(i8* nocapture readonly, i32, i32) [[G1]]
 281 declare i32 @chown(i8*, i32, i32)
 282
 283 ; CHECK: declare void @clearerr(%opaque* nocapture) [[G1]]
 284 declare void @clearerr(%opaque*)
 285
 286 ; CHECK: declare i32 @closedir(%opaque* nocapture) [[G1]]
 287 declare i32 @closedir(%opaque*)
 288
 289 ; CHECK: declare double @copysign(double, double) [[G0]]
 290 declare double @copysign(double, double)
 291
 292 ; CHECK: declare float @copysignf(float, float) [[G0]]
 293 declare float @copysignf(float, float)
 294
 295 ; CHECK: declare x86_fp80 @copysignl(x86_fp80, x86_fp80) [[G0]]
 296 declare x86_fp80 @copysignl(x86_fp80, x86_fp80)
 297
 298 ; CHECK: declare double @cos(double) [[G0]]
 299 declare double @cos(double)
 300
 301 ; CHECK: declare float @cosf(float) [[G0]]
 302 declare float @cosf(float)
 303
 304 ; CHECK: declare double @cosh(double) [[G0]]
 305 declare double @cosh(double)
 306
 307 ; CHECK: declare float @coshf(float) [[G0]]
 308 declare float @coshf(float)
 309
 310 ; CHECK: declare x86_fp80 @coshl(x86_fp80) [[G0]]
 311 declare x86_fp80 @coshl(x86_fp80)
 312
 313 ; CHECK: declare x86_fp80 @cosl(x86_fp80) [[G0]]
 314 declare x86_fp80 @cosl(x86_fp80)
 315
 316 ; CHECK: declare i8* @ctermid(i8* nocapture) [[G1]]
 317 declare i8* @ctermid(i8*)
 318
 319 ; CHECK: declare double @exp(double) [[G0]]
 320 declare double @exp(double)
 321
 322 ; CHECK: declare double @exp2(double) [[G0]]
 323 declare double @exp2(double)
 324
 325 ; CHECK: declare float @exp2f(float) [[G0]]
 326 declare float @exp2f(float)
 327
 328 ; CHECK: declare x86_fp80 @exp2l(x86_fp80) [[G0]]
 329 declare x86_fp80 @exp2l(x86_fp80)
 330
 331 ; CHECK: declare float @expf(float) [[G0]]
 332 declare float @expf(float)
 333
 334 ; CHECK: declare x86_fp80 @expl(x86_fp80) [[G0]]
 335 declare x86_fp80 @expl(x86_fp80)
 336
 337 ; CHECK: declare double @expm1(double) [[G0]]
 338 declare double @expm1(double)
 339
 340 ; CHECK: declare float @expm1f(float) [[G0]]
 341 declare float @expm1f(float)
 342
 343 ; CHECK: declare x86_fp80 @expm1l(x86_fp80) [[G0]]
 344 declare x86_fp80 @expm1l(x86_fp80)
 345
 346 ; CHECK: declare double @fabs(double) [[G0]]
 347 declare double @fabs(double)
 348
 349 ; CHECK: declare float @fabsf(float) [[G0]]
 350 declare float @fabsf(float)
 351
 352 ; CHECK: declare x86_fp80 @fabsl(x86_fp80) [[G0]]
 353 declare x86_fp80 @fabsl(x86_fp80)
 354
 355 ; CHECK: declare i32 @fclose(%opaque* nocapture) [[G1]]
 356 declare i32 @fclose(%opaque*)
 357
 358 ; CHECK: declare noalias %opaque* @fdopen(i32, i8* nocapture readonly) [[G1]]
 359 declare %opaque* @fdopen(i32, i8*)
 360
 361 ; CHECK: declare i32 @feof(%opaque* nocapture) [[G1]]
 362 declare i32 @feof(%opaque*)
 363
 364 ; CHECK: declare i32 @ferror(%opaque* nocapture) [[G2]]
 365 declare i32 @ferror(%opaque*)
 366
 367 ; CHECK: declare i32 @fflush(%opaque* nocapture) [[G1]]
 368 declare i32 @fflush(%opaque*)
 369
 370 ; CHECK: declare i32 @ffs(i32) [[G0]]
 371 declare i32 @ffs(i32)
 372
 373 ; CHECK: declare i32 @ffsl(i64) [[G0]]
 374 declare i32 @ffsl(i64)
 375
 376 ; CHECK: declare i32 @ffsll(i64) [[G0]]
 377 declare i32 @ffsll(i64)
 378
 379 ; CHECK: declare i32 @fgetc(%opaque* nocapture) [[G1]]
 380 declare i32 @fgetc(%opaque*)
 381
 382 ; CHECK: declare i32 @fgetpos(%opaque* nocapture, i64* nocapture) [[G1]]
 383 declare i32 @fgetpos(%opaque*, i64*)
 384
 385 ; CHECK: declare i8* @fgets(i8*, i32, %opaque* nocapture) [[G1]]
 386 declare i8* @fgets(i8*, i32, %opaque*)
 387
 388 ; CHECK: declare i32 @fileno(%opaque* nocapture) [[G1]]
 389 declare i32 @fileno(%opaque*)
 390
 391 ; CHECK: declare void @flockfile(%opaque* nocapture) [[G1]]
 392 declare void @flockfile(%opaque*)
 393
 394 ; CHECK: declare double @floor(double) [[G0]]
 395 declare double @floor(double)
 396
 397 ; CHECK: declare float @floorf(float) [[G0]]
 398 declare float @floorf(float)
 399
 400 ; CHECK: declare x86_fp80 @floorl(x86_fp80) [[G0]]
 401 declare x86_fp80 @floorl(x86_fp80)
 402
 403 ; CHECK: declare i32 @fls(i32)
 404 declare i32 @fls(i32)
 405
 406 ; CHECK: declare i32 @flsl(i64)
 407 declare i32 @flsl(i64)
 408
 409 ; CHECK: declare i32 @flsll(i64)
 410 declare i32 @flsll(i64)
 411
 412 ; CHECK: declare double @fmax(double, double) [[G0]]
 413 declare double @fmax(double, double)
 414
 415 ; CHECK: declare float @fmaxf(float, float) [[G0]]
 416 declare float @fmaxf(float, float)
 417
 418 ; CHECK: declare x86_fp80 @fmaxl(x86_fp80, x86_fp80) [[G0]]
 419 declare x86_fp80 @fmaxl(x86_fp80, x86_fp80)
 420
 421 ; CHECK: declare double @fmin(double, double) [[G0]]
 422 declare double @fmin(double, double)
 423
 424 ; CHECK: declare float @fminf(float, float) [[G0]]
 425 declare float @fminf(float, float)
 426
 427 ; CHECK: declare x86_fp80 @fminl(x86_fp80, x86_fp80) [[G0]]
 428 declare x86_fp80 @fminl(x86_fp80, x86_fp80)
 429
 430 ; CHECK: declare double @fmod(double, double) [[G0]]
 431 declare double @fmod(double, double)
 432
 433 ; CHECK: declare float @fmodf(float, float) [[G0]]
 434 declare float @fmodf(float, float)
 435
 436 ; CHECK: declare x86_fp80 @fmodl(x86_fp80, x86_fp80) [[G0]]
 437 declare x86_fp80 @fmodl(x86_fp80, x86_fp80)
 438
 439 ; CHECK: declare noalias %opaque* @fopen(i8* nocapture readonly, i8* nocapture readonly) [[G1]]
 440 declare %opaque* @fopen(i8*, i8*)
 441
 442 ; CHECK: declare i32 @fprintf(%opaque* nocapture, i8* nocapture readonly, ...) [[G1]]
 443 declare i32 @fprintf(%opaque*, i8*, ...)
 444
 445 ; CHECK: declare i32 @fputc(i32, %opaque* nocapture) [[G1]]
 446 declare i32 @fputc(i32, %opaque*)
 447
 448 ; CHECK: declare i32 @fputs(i8* nocapture readonly, %opaque* nocapture) [[G1]]
 449 declare i32 @fputs(i8*, %opaque*)
 450
 451 ; CHECK: declare i64 @fread(i8* nocapture, i64, i64, %opaque* nocapture) [[G1]]
 452 declare i64 @fread(i8*, i64, i64, %opaque*)
 453
 454 ; CHECK: declare void @free(i8* nocapture) [[G3:#[0-9]+]]
 455 declare void @free(i8*)
 456
 457 ; CHECK: declare double @frexp(double, i32* nocapture) [[G1]]
 458 declare double @frexp(double, i32*)
 459
 460 ; CHECK: declare float @frexpf(float, i32* nocapture) [[G1]]
 461 declare float @frexpf(float, i32*)
 462
 463 ; CHECK: declare x86_fp80 @frexpl(x86_fp80, i32* nocapture) [[G1]]
 464 declare x86_fp80 @frexpl(x86_fp80, i32*)
 465
 466 ; CHECK: declare i32 @fscanf(%opaque* nocapture, i8* nocapture readonly, ...) [[G1]]
 467 declare i32 @fscanf(%opaque*, i8*, ...)
 468
 469 ; CHECK: declare i32 @fseek(%opaque* nocapture, i64, i32) [[G1]]
 470 declare i32 @fseek(%opaque*, i64, i32)
 471
 472 ; CHECK: declare i32 @fseeko(%opaque* nocapture, i64, i32) [[G1]]
 473 declare i32 @fseeko(%opaque*, i64, i32)
 474
 475 ; CHECK-LINUX: declare i32 @fseeko64(%opaque* nocapture, i64, i32) [[G1]]
 476 declare i32 @fseeko64(%opaque*, i64, i32)
 477
 478 ; CHECK: declare i32 @fsetpos(%opaque* nocapture, i64*) [[G1]]
 479 declare i32 @fsetpos(%opaque*, i64*)
 480
 481 ; CHECK: declare i32 @fstat(i32, %opaque* nocapture) [[G1]]
 482 declare i32 @fstat(i32, %opaque*)
 483
 484 ; CHECK-LINUX: declare i32 @fstat64(i32, %opaque* nocapture) [[G1]]
 485 declare i32 @fstat64(i32, %opaque*)
 486
 487 ; CHECK: declare i32 @fstatvfs(i32, %opaque* nocapture) [[G1]]
 488 declare i32 @fstatvfs(i32, %opaque*)
 489
 490 ; CHECK-LINUX: declare i32 @fstatvfs64(i32, %opaque* nocapture) [[G1]]
 491 declare i32 @fstatvfs64(i32, %opaque*)
 492
 493 ; CHECK: declare i64 @ftell(%opaque* nocapture) [[G1]]
 494 declare i64 @ftell(%opaque*)
 495
 496 ; CHECK: declare i64 @ftello(%opaque* nocapture) [[G1]]
 497 declare i64 @ftello(%opaque*)
 498
 499 ; CHECK-LINUX: declare i64 @ftello64(%opaque* nocapture) [[G1]]
 500 declare i64 @ftello64(%opaque*)
 501
 502 ; CHECK: declare i32 @ftrylockfile(%opaque* nocapture) [[G1]]
 503 declare i32 @ftrylockfile(%opaque*)
 504
 505 ; CHECK: declare void @funlockfile(%opaque* nocapture) [[G1]]
 506 declare void @funlockfile(%opaque*)
 507
 508 ; CHECK: declare i64 @fwrite(i8* nocapture, i64, i64, %opaque* nocapture) [[G1]]
 509 declare i64 @fwrite(i8*, i64, i64, %opaque*)
 510
 511 ; CHECK: declare i32 @getc(%opaque* nocapture) [[G1]]
 512 declare i32 @getc(%opaque*)
 513
 514 ; CHECK: declare i32 @getc_unlocked(%opaque* nocapture) [[G1]]
 515 declare i32 @getc_unlocked(%opaque*)
 516
 517 ; CHECK: declare i32 @getchar() [[G1]]
 518 declare i32 @getchar()
 519
 520 ; CHECK: declare i32 @getchar_unlocked() [[G1]]
 521 declare i32 @getchar_unlocked()
 522
 523 ; CHECK: declare i8* @getenv(i8* nocapture) [[G2]]
 524 declare i8* @getenv(i8*)
 525
 526 ; CHECK: declare i32 @getitimer(i32, %opaque* nocapture) [[G1]]
 527 declare i32 @getitimer(i32, %opaque*)
 528
 529 ; CHECK: declare i32 @getlogin_r(i8* nocapture, i64) [[G1]]
 530 declare i32 @getlogin_r(i8*, i64)
 531
 532 ; CHECK: declare %opaque* @getpwnam(i8* nocapture readonly) [[G1]]
 533 declare %opaque* @getpwnam(i8*)
 534
 535 ; CHECK: declare i8* @gets(i8*) [[G1]]
 536 declare i8* @gets(i8*)
 537
 538 ; CHECK: declare i32 @gettimeofday(%opaque* nocapture, i8* nocapture) [[G1]]
 539 declare i32 @gettimeofday(%opaque*, i8*)
 540
 541 ; CHECK: declare i32 @isascii(i32) [[G0]]
 542 declare i32 @isascii(i32)
 543
 544 ; CHECK: declare i32 @isdigit(i32) [[G0]]
 545 declare i32 @isdigit(i32)
 546
 547 ; CHECK: declare i64 @labs(i64) [[G0]]
 548 declare i64 @labs(i64)
 549
 550 ; CHECK: declare i32 @lchown(i8* nocapture readonly, i32, i32) [[G1]]
 551 declare i32 @lchown(i8*, i32, i32)
 552
 553 ; CHECK: declare double @ldexp(double, i32) [[G0]]
 554 declare double @ldexp(double, i32)
 555
 556 ; CHECK: declare float @ldexpf(float, i32) [[G0]]
 557 declare float @ldexpf(float, i32)
 558
 559 ; CHECK: declare x86_fp80 @ldexpl(x86_fp80, i32) [[G0]]
 560 declare x86_fp80 @ldexpl(x86_fp80, i32)
 561
 562 ; CHECK: declare i64 @llabs(i64) [[G0]]
 563 declare i64 @llabs(i64)
 564
 565 ; CHECK: declare double @log(double) [[G0]]
 566 declare double @log(double)
 567
 568 ; CHECK: declare double @log10(double) [[G0]]
 569 declare double @log10(double)
 570
 571 ; CHECK: declare float @log10f(float) [[G0]]
 572 declare float @log10f(float)
 573
 574 ; CHECK: declare x86_fp80 @log10l(x86_fp80) [[G0]]
 575 declare x86_fp80 @log10l(x86_fp80)
 576
 577 ; CHECK: declare double @log1p(double) [[G0]]
 578 declare double @log1p(double)
 579
 580 ; CHECK: declare float @log1pf(float) [[G0]]
 581 declare float @log1pf(float)
 582
 583 ; CHECK: declare x86_fp80 @log1pl(x86_fp80) [[G0]]
 584 declare x86_fp80 @log1pl(x86_fp80)
 585
 586 ; CHECK: declare double @log2(double) [[G0]]
 587 declare double @log2(double)
 588
 589 ; CHECK: declare float @log2f(float) [[G0]]
 590 declare float @log2f(float)
 591
 592 ; CHECK: declare x86_fp80 @log2l(x86_fp80) [[G0]]
 593 declare x86_fp80 @log2l(x86_fp80)
 594
 595 ; CHECK: declare double @logb(double) [[G0]]
 596 declare double @logb(double)
 597
 598 ; CHECK: declare float @logbf(float) [[G0]]
 599 declare float @logbf(float)
 600
 601 ; CHECK: declare x86_fp80 @logbl(x86_fp80) [[G0]]
 602 declare x86_fp80 @logbl(x86_fp80)
 603
 604 ; CHECK: declare float @logf(float) [[G0]]
 605 declare float @logf(float)
 606
 607 ; CHECK: declare x86_fp80 @logl(x86_fp80) [[G0]]
 608 declare x86_fp80 @logl(x86_fp80)
 609
 610 ; CHECK: declare i32 @lstat(i8* nocapture readonly, %opaque* nocapture) [[G1]]
 611 declare i32 @lstat(i8*, %opaque*)
 612
 613 ; CHECK-LINUX: declare i32 @lstat64(i8* nocapture readonly, %opaque* nocapture) [[G1]]
 614 declare i32 @lstat64(i8*, %opaque*)
 615
 616 ; CHECK: declare noalias i8* @malloc(i64) [[G1]]
 617 declare i8* @malloc(i64)
 618
 619 ; CHECK-LINUX: declare noalias i8* @memalign(i64, i64) [[G0]]
 620 declare i8* @memalign(i64, i64)
 621
 622 ; CHECK: declare i8* @memccpy(i8* noalias, i8* noalias nocapture readonly, i32, i64) [[G1]]
 623 declare i8* @memccpy(i8*, i8*, i32, i64)
 624
 625 ; CHECK: declare i8* @memchr(i8*, i32, i64) [[G2]]
 626 declare i8* @memchr(i8*, i32, i64)
 627
 628 ; CHECK: declare i32 @memcmp(i8* nocapture, i8* nocapture, i64) [[G2]]
 629 declare i32 @memcmp(i8*, i8*, i64)
 630
 631 ; CHECK: declare i8* @memcpy(i8* noalias returned, i8* noalias nocapture readonly, i64) [[G1]]
 632 declare i8* @memcpy(i8*, i8*, i64)
 633
 634 ; CHECK: declare i8* @mempcpy(i8* noalias, i8* noalias nocapture readonly, i64) [[G1]]
 635 declare i8* @mempcpy(i8*, i8*, i64)
 636
 637 ; CHECK: declare i8* @memmove(i8* returned, i8* nocapture readonly, i64) [[G1]]
 638 declare i8* @memmove(i8*, i8*, i64)
 639
 640 ; CHECK: declare i8* @memset(i8*, i32, i64) [[G0]]
 641 declare i8* @memset(i8*, i32, i64)
 642
 643 ; CHECK: declare i32 @mkdir(i8* nocapture readonly, i16 zeroext) [[G1]]
 644 declare i32 @mkdir(i8*, i16 zeroext)
 645
 646 ; CHECK: declare i64 @mktime(%opaque* nocapture) [[G1]]
 647 declare i64 @mktime(%opaque*)
 648
 649 ; CHECK: declare double @modf(double, double* nocapture) [[G1]]
 650 declare double @modf(double, double*)
 651
 652 ; CHECK: declare float @modff(float, float* nocapture) [[G1]]
 653 declare float @modff(float, float*)
 654
 655 ; CHECK: declare x86_fp80 @modfl(x86_fp80, x86_fp80* nocapture) [[G1]]
 656 declare x86_fp80 @modfl(x86_fp80, x86_fp80*)
 657
 658 ; CHECK: declare double @nearbyint(double) [[G0]]
 659 declare double @nearbyint(double)
 660
 661 ; CHECK: declare float @nearbyintf(float) [[G0]]
 662 declare float @nearbyintf(float)
 663
 664 ; CHECK: declare x86_fp80 @nearbyintl(x86_fp80) [[G0]]
 665 declare x86_fp80 @nearbyintl(x86_fp80)
 666
 667 ; CHECK: declare i32 @open(i8* nocapture readonly, i32, ...) [[G0]]
 668 declare i32 @open(i8*, i32, ...)
 669
 670 ; CHECK-LINUX: declare i32 @open64(i8* nocapture readonly, i32, ...) [[G0]]
 671 declare i32 @open64(i8*, i32, ...)
 672
 673 ; CHECK: declare noalias %opaque* @opendir(i8* nocapture readonly) [[G1]]
 674 declare %opaque* @opendir(i8*)
 675
 676 ; CHECK: declare i32 @pclose(%opaque* nocapture) [[G1]]
 677 declare i32 @pclose(%opaque*)
 678
 679 ; CHECK: declare void @perror(i8* nocapture readonly) [[G1]]
 680 declare void @perror(i8*)
 681
 682 ; CHECK: declare noalias %opaque* @popen(i8* nocapture readonly, i8* nocapture readonly) [[G1]]
 683 declare %opaque* @popen(i8*, i8*)
 684
 685 ; CHECK: declare i32 @posix_memalign(i8**, i64, i64) [[G0]]
 686 declare i32 @posix_memalign(i8**, i64, i64)
 687
 688 ; CHECK: declare double @pow(double, double) [[G0]]
 689 declare double @pow(double, double)
 690
 691 ; CHECK: declare float @powf(float, float) [[G0]]
 692 declare float @powf(float, float)
 693
 694 ; CHECK: declare x86_fp80 @powl(x86_fp80, x86_fp80) [[G0]]
 695 declare x86_fp80 @powl(x86_fp80, x86_fp80)
 696
 697 ; CHECK: declare i64 @pread(i32, i8* nocapture, i64, i64) [[G0]]
 698 declare i64 @pread(i32, i8*, i64, i64)
 699
 700 ; CHECK: declare i32 @printf(i8* nocapture readonly, ...) [[G1]]
 701 declare i32 @printf(i8*, ...)
 702
 703 ; CHECK: declare i32 @putc(i32, %opaque* nocapture) [[G1]]
 704 declare i32 @putc(i32, %opaque*)
 705
 706 ; CHECK: declare i32 @putchar(i32) [[G1]]
 707 declare i32 @putchar(i32)
 708
 709 ; CHECK: declare i32 @putchar_unlocked(i32) [[G1]]
 710 declare i32 @putchar_unlocked(i32)
 711
 712 ; CHECK: declare i32 @puts(i8* nocapture readonly) [[G1]]
 713 declare i32 @puts(i8*)
 714
 715 ; CHECK: declare i64 @pwrite(i32, i8* nocapture readonly, i64, i64) [[G0]]
 716 declare i64 @pwrite(i32, i8*, i64, i64)
 717
 718 ; CHECK: declare void @qsort(i8*, i64, i64, i32 (i8*, i8*)* nocapture) [[G0]]
 719 declare void @qsort(i8*, i64, i64, i32 (i8*, i8*)*)
 720
 721 ; CHECK: declare i64 @read(i32, i8* nocapture, i64) [[G0]]
 722 declare i64 @read(i32, i8*, i64)
 723
 724 ; CHECK: declare i64 @readlink(i8* nocapture readonly, i8* nocapture, i64) [[G1]]
 725 declare i64 @readlink(i8*, i8*, i64)
 726
 727 ; CHECK: declare noalias i8* @realloc(i8* nocapture, i64) [[G3]]
 728 declare i8* @realloc(i8*, i64)
 729
 730 ; CHECK: declare i8* @reallocf(i8*, i64)
 731 declare i8* @reallocf(i8*, i64)
 732
 733 ; CHECK: declare i8* @realpath(i8* nocapture readonly, i8*) [[G1]]
 734 declare i8* @realpath(i8*, i8*)
 735
 736 ; CHECK: declare i32 @remove(i8* nocapture readonly) [[G1]]
 737 declare i32 @remove(i8*)
 738
 739 ; CHECK: declare i32 @rename(i8* nocapture readonly, i8* nocapture readonly) [[G1]]
 740 declare i32 @rename(i8*, i8*)
 741
 742 ; CHECK: declare void @rewind(%opaque* nocapture) [[G1]]
 743 declare void @rewind(%opaque*)
 744
 745 ; CHECK: declare double @rint(double) [[G0]]
 746 declare double @rint(double)
 747
 748 ; CHECK: declare float @rintf(float) [[G0]]
 749 declare float @rintf(float)
 750
 751 ; CHECK: declare x86_fp80 @rintl(x86_fp80) [[G0]]
 752 declare x86_fp80 @rintl(x86_fp80)
 753
 754 ; CHECK: declare i32 @rmdir(i8* nocapture readonly) [[G1]]
 755 declare i32 @rmdir(i8*)
 756
 757 ; CHECK: declare double @round(double) [[G0]]
 758 declare double @round(double)
 759
 760 ; CHECK: declare float @roundf(float) [[G0]]
 761 declare float @roundf(float)
 762
 763 ; CHECK: declare x86_fp80 @roundl(x86_fp80) [[G0]]
 764 declare x86_fp80 @roundl(x86_fp80)
 765
 766 ; CHECK: declare i32 @scanf(i8* nocapture readonly, ...) [[G1]]
 767 declare i32 @scanf(i8*, ...)
 768
 769 ; CHECK: declare void @setbuf(%opaque* nocapture, i8*) [[G1]]
 770 declare void @setbuf(%opaque*, i8*)
 771
 772 ; CHECK: declare i32 @setitimer(i32, %opaque* nocapture readonly, %opaque* nocapture) [[G1]]
 773 declare i32 @setitimer(i32, %opaque*, %opaque*)
 774
 775 ; CHECK: declare i32 @setvbuf(%opaque* nocapture, i8*, i32, i64) [[G1]]
 776 declare i32 @setvbuf(%opaque*, i8*, i32, i64)
 777
 778 ; CHECK: declare double @sin(double) [[G0]]
 779 declare double @sin(double)
 780
 781 ; CHECK: declare float @sinf(float) [[G0]]
 782 declare float @sinf(float)
 783
 784 ; CHECK: declare double @sinh(double) [[G0]]
 785 declare double @sinh(double)
 786
 787 ; CHECK: declare float @sinhf(float) [[G0]]
 788 declare float @sinhf(float)
 789
 790 ; CHECK: declare x86_fp80 @sinhl(x86_fp80) [[G0]]
 791 declare x86_fp80 @sinhl(x86_fp80)
 792
 793 ; CHECK: declare x86_fp80 @sinl(x86_fp80) [[G0]]
 794 declare x86_fp80 @sinl(x86_fp80)
 795
 796 ; CHECK: declare i32 @snprintf(i8* noalias nocapture, i64, i8* nocapture readonly, ...) [[G1]]
 797 declare i32 @snprintf(i8*, i64, i8*, ...)
 798
 799 ; CHECK: declare i32 @sprintf(i8* noalias nocapture, i8* nocapture readonly, ...) [[G1]]
 800 declare i32 @sprintf(i8*, i8*, ...)
 801
 802 ; CHECK: declare double @sqrt(double) [[G0]]
 803 declare double @sqrt(double)
 804
 805 ; CHECK: declare float @sqrtf(float) [[G0]]
 806 declare float @sqrtf(float)
 807
 808 ; CHECK: declare x86_fp80 @sqrtl(x86_fp80) [[G0]]
 809 declare x86_fp80 @sqrtl(x86_fp80)
 810
 811 ; CHECK: declare i32 @sscanf(i8* nocapture readonly, i8* nocapture readonly, ...) [[G1]]
 812 declare i32 @sscanf(i8*, i8*, ...)
 813
 814 ; CHECK: declare i32 @stat(i8* nocapture readonly, %opaque* nocapture) [[G1]]
 815 declare i32 @stat(i8*, %opaque*)
 816
 817 ; CHECK-LINUX: declare i32 @stat64(i8* nocapture readonly, %opaque* nocapture) [[G1]]
 818 declare i32 @stat64(i8*, %opaque*)
 819
 820 ; CHECK: declare i32 @statvfs(i8* nocapture readonly, %opaque* nocapture) [[G1]]
 821 declare i32 @statvfs(i8*, %opaque*)
 822
 823 ; CHECK-LINUX: declare i32 @statvfs64(i8* nocapture readonly, %opaque* nocapture) [[G1]]
 824 declare i32 @statvfs64(i8*, %opaque*)
 825
 826 ; CHECK: declare i8* @stpcpy(i8*, i8* nocapture readonly) [[G1]]
 827 declare i8* @stpcpy(i8*, i8*)
 828
 829 ; CHECK: declare i8* @stpncpy(i8*, i8* nocapture readonly, i64) [[G1]]
 830 declare i8* @stpncpy(i8*, i8*, i64)
 831
 832 ; CHECK: declare i32 @strcasecmp(i8* nocapture, i8* nocapture) [[G2]]
 833 declare i32 @strcasecmp(i8*, i8*)
 834
 835 ; CHECK: declare i8* @strcat(i8* returned, i8* nocapture readonly) [[G1]]
 836 declare i8* @strcat(i8*, i8*)
 837
 838 ; CHECK: declare i8* @strchr(i8*, i32) [[G2]]
 839 declare i8* @strchr(i8*, i32)
 840
 841 ; CHECK: declare i32 @strcmp(i8* nocapture, i8* nocapture) [[G2]]
 842 declare i32 @strcmp(i8*, i8*)
 843
 844 ; CHECK: declare i32 @strcoll(i8* nocapture, i8* nocapture) [[G2]]
 845 declare i32 @strcoll(i8*, i8*)
 846
 847 ; CHECK: declare i8* @strcpy(i8* noalias returned, i8* noalias nocapture readonly) [[G1]]
 848 declare i8* @strcpy(i8*, i8*)
 849
 850 ; CHECK: declare i64 @strcspn(i8* nocapture, i8* nocapture) [[G2]]
 851 declare i64 @strcspn(i8*, i8*)
 852
 853 ; CHECK: declare noalias i8* @strdup(i8* nocapture readonly) [[G1]]
 854 declare i8* @strdup(i8*)
 855
 856 ; CHECK: declare i64 @strlen(i8* nocapture) [[G4:#[0-9]+]]
 857 declare i64 @strlen(i8*)
 858
 859 ; CHECK: declare i32 @strncasecmp(i8* nocapture, i8* nocapture, i64) [[G2]]
 860 declare i32 @strncasecmp(i8*, i8*, i64)
 861
 862 ; CHECK: declare i8* @strncat(i8* returned, i8* nocapture readonly, i64) [[G1]]
 863 declare i8* @strncat(i8*, i8*, i64)
 864
 865 ; CHECK: declare i32 @strncmp(i8* nocapture, i8* nocapture, i64) [[G2]]
 866 declare i32 @strncmp(i8*, i8*, i64)
 867
 868 ; CHECK: declare i8* @strncpy(i8* noalias returned, i8* noalias nocapture readonly, i64) [[G1]]
 869 declare i8* @strncpy(i8*, i8*, i64)
 870
 871 ; CHECK: declare noalias i8* @strndup(i8* nocapture readonly, i64) [[G1]]
 872 declare i8* @strndup(i8*, i64)
 873
 874 ; CHECK: declare i64 @strnlen(i8*, i64) [[G0]]
 875 declare i64 @strnlen(i8*, i64)
 876
 877 ; CHECK: declare i8* @strpbrk(i8*, i8* nocapture) [[G2]]
 878 declare i8* @strpbrk(i8*, i8*)
 879
 880 ; CHECK: declare i8* @strrchr(i8*, i32) [[G2]]
 881 declare i8* @strrchr(i8*, i32)
 882
 883 ; CHECK: declare i64 @strspn(i8* nocapture, i8* nocapture) [[G2]]
 884 declare i64 @strspn(i8*, i8*)
 885
 886 ; CHECK: declare i8* @strstr(i8*, i8* nocapture) [[G2]]
 887 declare i8* @strstr(i8*, i8*)
 888
 889 ; CHECK: declare double @strtod(i8* readonly, i8** nocapture) [[G1]]
 890 declare double @strtod(i8*, i8**)
 891
 892 ; CHECK: declare float @strtof(i8* readonly, i8** nocapture) [[G1]]
 893 declare float @strtof(i8*, i8**)
 894
 895 ; CHECK: declare i8* @strtok(i8*, i8* nocapture readonly) [[G1]]
 896 declare i8* @strtok(i8*, i8*)
 897
 898 ; CHECK: declare i8* @strtok_r(i8*, i8* nocapture readonly, i8**) [[G1]]
 899 declare i8* @strtok_r(i8*, i8*, i8**)
 900
 901 ; CHECK: declare i64 @strtol(i8* readonly, i8** nocapture, i32) [[G1]]
 902 declare i64 @strtol(i8*, i8**, i32)
 903
 904 ; CHECK: declare x86_fp80 @strtold(i8* readonly, i8** nocapture) [[G1]]
 905 declare x86_fp80 @strtold(i8*, i8**)
 906
 907 ; CHECK: declare i64 @strtoll(i8* readonly, i8** nocapture, i32) [[G1]]
 908 declare i64 @strtoll(i8*, i8**, i32)
 909
 910 ; CHECK: declare i64 @strtoul(i8* readonly, i8** nocapture, i32) [[G1]]
 911 declare i64 @strtoul(i8*, i8**, i32)
 912
 913 ; CHECK: declare i64 @strtoull(i8* readonly, i8** nocapture, i32) [[G1]]
 914 declare i64 @strtoull(i8*, i8**, i32)
 915
 916 ; CHECK: declare i64 @strxfrm(i8* nocapture, i8* nocapture readonly, i64) [[G1]]
 917 declare i64 @strxfrm(i8*, i8*, i64)
 918
 919 ; CHECK: declare i32 @system(i8* nocapture readonly) [[G0]]
 920 declare i32 @system(i8*)
 921
 922 ; CHECK: declare double @tan(double) [[G0]]
 923 declare double @tan(double)
 924
 925 ; CHECK: declare float @tanf(float) [[G0]]
 926 declare float @tanf(float)
 927
 928 ; CHECK: declare double @tanh(double) [[G0]]
 929 declare double @tanh(double)
 930
 931 ; CHECK: declare float @tanhf(float) [[G0]]
 932 declare float @tanhf(float)
 933
 934 ; CHECK: declare x86_fp80 @tanhl(x86_fp80) [[G0]]
 935 declare x86_fp80 @tanhl(x86_fp80)
 936
 937 ; CHECK: declare x86_fp80 @tanl(x86_fp80) [[G0]]
 938 declare x86_fp80 @tanl(x86_fp80)
 939
 940 ; CHECK: declare i64 @times(%opaque* nocapture) [[G1]]
 941 declare i64 @times(%opaque*)
 942
 943 ; CHECK: declare noalias %opaque* @tmpfile() [[G1]]
 944 declare %opaque* @tmpfile()
 945
 946 ; CHECK-LINUX: declare noalias %opaque* @tmpfile64() [[G1]]
 947 declare %opaque* @tmpfile64()
 948
 949 ; CHECK: declare i32 @toascii(i32) [[G0]]
 950 declare i32 @toascii(i32)
 951
 952 ; CHECK: declare double @trunc(double) [[G0]]
 953 declare double @trunc(double)
 954
 955 ; CHECK: declare float @truncf(float) [[G0]]
 956 declare float @truncf(float)
 957
 958 ; CHECK: declare x86_fp80 @truncl(x86_fp80) [[G0]]
 959 declare x86_fp80 @truncl(x86_fp80)
 960
 961 ; CHECK: declare i32 @uname(%opaque* nocapture) [[G1]]
 962 declare i32 @uname(%opaque*)
 963
 964 ; CHECK: declare i32 @ungetc(i32, %opaque* nocapture) [[G1]]
 965 declare i32 @ungetc(i32, %opaque*)
 966
 967 ; CHECK: declare i32 @unlink(i8* nocapture readonly) [[G1]]
 968 declare i32 @unlink(i8*)
 969
 970 ; CHECK: declare i32 @unsetenv(i8* nocapture readonly) [[G1]]
 971 declare i32 @unsetenv(i8*)
 972
 973 ; CHECK: declare i32 @utime(i8* nocapture readonly, %opaque* nocapture readonly) [[G1]]
 974 declare i32 @utime(i8*, %opaque*)
 975
 976 ; CHECK: declare i32 @utimes(i8* nocapture readonly, %opaque* nocapture readonly) [[G1]]
 977 declare i32 @utimes(i8*, %opaque*)
 978
 979 ; CHECK: declare noalias i8* @valloc(i64) [[G1]]
 980 declare i8* @valloc(i64)
 981
 982 ; CHECK: declare i32 @vfprintf(%opaque* nocapture, i8* nocapture readonly, %opaque*) [[G1]]
 983 declare i32 @vfprintf(%opaque*, i8*, %opaque*)
 984
 985 ; CHECK: declare i32 @vfscanf(%opaque* nocapture, i8* nocapture readonly, %opaque*) [[G1]]
 986 declare i32 @vfscanf(%opaque*, i8*, %opaque*)
 987
 988 ; CHECK: declare i32 @vprintf(i8* nocapture readonly, %opaque*) [[G1]]
 989 declare i32 @vprintf(i8*, %opaque*)
 990
 991 ; CHECK: declare i32 @vscanf(i8* nocapture readonly, %opaque*) [[G1]]
 992 declare i32 @vscanf(i8*, %opaque*)
 993
 994 ; CHECK: declare i32 @vsnprintf(i8* nocapture, i64, i8* nocapture readonly, %opaque*) [[G1]]
 995 declare i32 @vsnprintf(i8*, i64, i8*, %opaque*)
 996
 997 ; CHECK: declare i32 @vsprintf(i8* nocapture, i8* nocapture readonly, %opaque*) [[G1]]
 998 declare i32 @vsprintf(i8*, i8*, %opaque*)
 999
1000 ; CHECK: declare i32 @vsscanf(i8* nocapture readonly, i8* nocapture readonly, %opaque*) [[G1]]
1001 declare i32 @vsscanf(i8*, i8*, %opaque*)
1002
1003 ; CHECK: declare i64 @write(i32, i8* nocapture readonly, i64) [[G0]]
1004 declare i64 @write(i32, i8*, i64)
1005
1006
1007 ; memset_pattern16 isn't available everywhere.
1008 ; CHECK-DARWIN: declare void @memset_pattern16(i8* nocapture, i8* nocapture readonly, i64) [[G5:#[0-9]+]]
1009 declare void @memset_pattern16(i8*, i8*, i64)
1010
1011 ; CHECK: attributes [[G0]] = { nofree }
1012 ; CHECK: attributes [[G1]] = { nofree nounwind }
1013 ; CHECK: attributes [[G2]] = { nofree nounwind readonly }
1014 ; CHECK: attributes [[G3]] = { nounwind }
1015 ; CHECK: attributes [[G4]] = { argmemonly nofree nounwind readonly }
1016 ; CHECK-DARWIN: attributes [[G5]] = { argmemonly nofree }