Commit bbaf33ed authored by Tom Stellard's avatar Tom Stellard
Browse files

Merging r344454, r344455, r344645: 

------------------------------------------------------------------------
r344454 | xbolva00 | 2018-10-13 08:21:55 -0700 (Sat, 13 Oct 2018) | 11 lines

[InstCombine] Fixed crash with aliased functions

Summary: Fixes PR39177

Reviewers: spatel, jbuening

Reviewed By: jbuening

Subscribers: jbuening, llvm-commits

Differential Revision: https://reviews.llvm.org/D53129
------------------------------------------------------------------------

------------------------------------------------------------------------
r344455 | xbolva00 | 2018-10-13 08:26:13 -0700 (Sat, 13 Oct 2018) | 2 lines

[NFC] Fixed duplicated test file

------------------------------------------------------------------------

------------------------------------------------------------------------
r344645 | xbolva00 | 2018-10-16 14:18:31 -0700 (Tue, 16 Oct 2018) | 9 lines

[InstCombine] Cleanup libfunc attribute inferring

Reviewers: efriedma

Reviewed By: efriedma

Subscribers: llvm-commits

Differential Revision: https://reviews.llvm.org/D53338
------------------------------------------------------------------------

llvm-svn: 345921
parent 74c32a11

llvm/include/llvm/Transforms/Utils/BuildLibCalls.h

+1 −0
Original line number Diff line number Diff line
@@ -29,6 +29,7 @@ namespace llvm { 
  ///

  /// Returns true if any attributes were set and false otherwise.

  bool inferLibFuncAttributes(Function &F, const TargetLibraryInfo &TLI);

  bool inferLibFuncAttributes(Module *M, StringRef Name, const TargetLibraryInfo &TLI);



  /// Check whether the overloaded unary floating point function

  /// corresponding to \a Ty is available.

llvm/lib/Transforms/Scalar/LoopIdiomRecognize.cpp

+3 −2
Original line number Diff line number Diff line
@@ -921,10 +921,11 @@ bool LoopIdiomRecognize::processLoopStridedStore( 
    Type *Int8PtrTy = DestInt8PtrTy;



    Module *M = TheStore->getModule();

    StringRef FuncName = "memset_pattern16";

    Value *MSP =

        M->getOrInsertFunction("memset_pattern16", Builder.getVoidTy(),

        M->getOrInsertFunction(FuncName, Builder.getVoidTy(),

                               Int8PtrTy, Int8PtrTy, IntPtr);

    inferLibFuncAttributes(*M->getFunction("memset_pattern16"), *TLI);

    inferLibFuncAttributes(M, FuncName, *TLI);



    // Otherwise we should form a memset_pattern16.  PatternValue is known to be

    // an constant array of 16-bytes.  Plop the value into a mergable global.

llvm/lib/Transforms/Utils/BuildLibCalls.cpp

+70 −49
Original line number Diff line number Diff line
@@ -112,6 +112,14 @@ static bool setNonLazyBind(Function &F) { 
  return true;

}



bool llvm::inferLibFuncAttributes(Module *M, StringRef Name,

                                  const TargetLibraryInfo &TLI) {

  Function *F = M->getFunction(Name);

  if (!F)

    return false;

  return inferLibFuncAttributes(*F, TLI);

}



bool llvm::inferLibFuncAttributes(Function &F, const TargetLibraryInfo &TLI) {

  LibFunc TheLibFunc;

  if (!(TLI.getLibFunc(F, TheLibFunc) && TLI.has(TheLibFunc)))
@@ -755,11 +763,12 @@ Value *llvm::emitStrLen(Value *Ptr, IRBuilder<> &B, const DataLayout &DL, 
    return nullptr;



  Module *M = B.GetInsertBlock()->getModule();

  StringRef StrlenName = TLI->getName(LibFunc_strlen);

  LLVMContext &Context = B.GetInsertBlock()->getContext();

  Constant *StrLen = M->getOrInsertFunction("strlen", DL.getIntPtrType(Context),

  Constant *StrLen = M->getOrInsertFunction(StrlenName, DL.getIntPtrType(Context),

                                            B.getInt8PtrTy());

  inferLibFuncAttributes(*M->getFunction("strlen"), *TLI);

  CallInst *CI = B.CreateCall(StrLen, castToCStr(Ptr, B), "strlen");

  inferLibFuncAttributes(M, StrlenName, *TLI);

  CallInst *CI = B.CreateCall(StrLen, castToCStr(Ptr, B), StrlenName);

  if (const Function *F = dyn_cast<Function>(StrLen->stripPointerCasts()))

    CI->setCallingConv(F->getCallingConv());
@@ -772,13 +781,14 @@ Value *llvm::emitStrChr(Value *Ptr, char C, IRBuilder<> &B, 
    return nullptr;



  Module *M = B.GetInsertBlock()->getModule();

  StringRef StrChrName = TLI->getName(LibFunc_strchr);

  Type *I8Ptr = B.getInt8PtrTy();

  Type *I32Ty = B.getInt32Ty();

  Constant *StrChr =

      M->getOrInsertFunction("strchr", I8Ptr, I8Ptr, I32Ty);

  inferLibFuncAttributes(*M->getFunction("strchr"), *TLI);

      M->getOrInsertFunction(StrChrName, I8Ptr, I8Ptr, I32Ty);

  inferLibFuncAttributes(M, StrChrName, *TLI);

  CallInst *CI = B.CreateCall(

      StrChr, {castToCStr(Ptr, B), ConstantInt::get(I32Ty, C)}, "strchr");

      StrChr, {castToCStr(Ptr, B), ConstantInt::get(I32Ty, C)}, StrChrName);

  if (const Function *F = dyn_cast<Function>(StrChr->stripPointerCasts()))

    CI->setCallingConv(F->getCallingConv());

  return CI;
@@ -790,13 +800,14 @@ Value *llvm::emitStrNCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilder<> &B, 
    return nullptr;



  Module *M = B.GetInsertBlock()->getModule();

  StringRef StrNCmpName = TLI->getName(LibFunc_strncmp);

  LLVMContext &Context = B.GetInsertBlock()->getContext();

  Value *StrNCmp = M->getOrInsertFunction("strncmp", B.getInt32Ty(),

  Value *StrNCmp = M->getOrInsertFunction(StrNCmpName, B.getInt32Ty(),

                                          B.getInt8PtrTy(), B.getInt8PtrTy(),

                                          DL.getIntPtrType(Context));

  inferLibFuncAttributes(*M->getFunction("strncmp"), *TLI);

  inferLibFuncAttributes(M, StrNCmpName, *TLI);

  CallInst *CI = B.CreateCall(

      StrNCmp, {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, "strncmp");

      StrNCmp, {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, StrNCmpName);



  if (const Function *F = dyn_cast<Function>(StrNCmp->stripPointerCasts()))

    CI->setCallingConv(F->getCallingConv());
@@ -812,7 +823,7 @@ Value *llvm::emitStrCpy(Value *Dst, Value *Src, IRBuilder<> &B, 
  Module *M = B.GetInsertBlock()->getModule();

  Type *I8Ptr = B.getInt8PtrTy();

  Value *StrCpy = M->getOrInsertFunction(Name, I8Ptr, I8Ptr, I8Ptr);

  inferLibFuncAttributes(*M->getFunction(Name), *TLI);

  inferLibFuncAttributes(M, Name, *TLI);

  CallInst *CI =

      B.CreateCall(StrCpy, {castToCStr(Dst, B), castToCStr(Src, B)}, Name);

  if (const Function *F = dyn_cast<Function>(StrCpy->stripPointerCasts()))
@@ -829,9 +840,9 @@ Value *llvm::emitStrNCpy(Value *Dst, Value *Src, Value *Len, IRBuilder<> &B, 
  Type *I8Ptr = B.getInt8PtrTy();

  Value *StrNCpy = M->getOrInsertFunction(Name, I8Ptr, I8Ptr, I8Ptr,

                                          Len->getType());

  inferLibFuncAttributes(*M->getFunction(Name), *TLI);

  inferLibFuncAttributes(M, Name, *TLI);

  CallInst *CI = B.CreateCall(

      StrNCpy, {castToCStr(Dst, B), castToCStr(Src, B), Len}, "strncpy");

      StrNCpy, {castToCStr(Dst, B), castToCStr(Src, B), Len}, Name);

  if (const Function *F = dyn_cast<Function>(StrNCpy->stripPointerCasts()))

    CI->setCallingConv(F->getCallingConv());

  return CI;
@@ -866,12 +877,13 @@ Value *llvm::emitMemChr(Value *Ptr, Value *Val, Value *Len, IRBuilder<> &B, 
    return nullptr;



  Module *M = B.GetInsertBlock()->getModule();

  StringRef MemChrName = TLI->getName(LibFunc_memchr);

  LLVMContext &Context = B.GetInsertBlock()->getContext();

  Value *MemChr = M->getOrInsertFunction("memchr", B.getInt8PtrTy(),

  Value *MemChr = M->getOrInsertFunction(MemChrName, B.getInt8PtrTy(),

                                         B.getInt8PtrTy(), B.getInt32Ty(),

                                         DL.getIntPtrType(Context));

  inferLibFuncAttributes(*M->getFunction("memchr"), *TLI);

  CallInst *CI = B.CreateCall(MemChr, {castToCStr(Ptr, B), Val, Len}, "memchr");

  inferLibFuncAttributes(M, MemChrName, *TLI);

  CallInst *CI = B.CreateCall(MemChr, {castToCStr(Ptr, B), Val, Len}, MemChrName);



  if (const Function *F = dyn_cast<Function>(MemChr->stripPointerCasts()))

    CI->setCallingConv(F->getCallingConv());
@@ -885,13 +897,14 @@ Value *llvm::emitMemCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilder<> &B, 
    return nullptr;



  Module *M = B.GetInsertBlock()->getModule();

  StringRef MemCmpName = TLI->getName(LibFunc_memcmp);

  LLVMContext &Context = B.GetInsertBlock()->getContext();

  Value *MemCmp = M->getOrInsertFunction("memcmp", B.getInt32Ty(),

  Value *MemCmp = M->getOrInsertFunction(MemCmpName, B.getInt32Ty(),

                                         B.getInt8PtrTy(), B.getInt8PtrTy(),

                                         DL.getIntPtrType(Context));

  inferLibFuncAttributes(*M->getFunction("memcmp"), *TLI);

  inferLibFuncAttributes(M, MemCmpName, *TLI);

  CallInst *CI = B.CreateCall(

      MemCmp, {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, "memcmp");

      MemCmp, {castToCStr(Ptr1, B), castToCStr(Ptr2, B), Len}, MemCmpName);



  if (const Function *F = dyn_cast<Function>(MemCmp->stripPointerCasts()))

    CI->setCallingConv(F->getCallingConv());
@@ -958,14 +971,15 @@ Value *llvm::emitPutChar(Value *Char, IRBuilder<> &B, 
    return nullptr;



  Module *M = B.GetInsertBlock()->getModule();

  Value *PutChar = M->getOrInsertFunction("putchar", B.getInt32Ty(), B.getInt32Ty());

  inferLibFuncAttributes(*M->getFunction("putchar"), *TLI);

  StringRef PutCharName = TLI->getName(LibFunc_putchar);

  Value *PutChar = M->getOrInsertFunction(PutCharName, B.getInt32Ty(), B.getInt32Ty());

  inferLibFuncAttributes(M, PutCharName, *TLI);

  CallInst *CI = B.CreateCall(PutChar,

                              B.CreateIntCast(Char,

                              B.getInt32Ty(),

                              /*isSigned*/true,

                              "chari"),

                              "putchar");

                              PutCharName);



  if (const Function *F = dyn_cast<Function>(PutChar->stripPointerCasts()))

    CI->setCallingConv(F->getCallingConv());
@@ -978,10 +992,11 @@ Value *llvm::emitPutS(Value *Str, IRBuilder<> &B, 
    return nullptr;



  Module *M = B.GetInsertBlock()->getModule();

  StringRef PutsName = TLI->getName(LibFunc_puts);

  Value *PutS =

      M->getOrInsertFunction("puts", B.getInt32Ty(), B.getInt8PtrTy());

  inferLibFuncAttributes(*M->getFunction("puts"), *TLI);

  CallInst *CI = B.CreateCall(PutS, castToCStr(Str, B), "puts");

      M->getOrInsertFunction(PutsName, B.getInt32Ty(), B.getInt8PtrTy());

  inferLibFuncAttributes(M, PutsName, *TLI);

  CallInst *CI = B.CreateCall(PutS, castToCStr(Str, B), PutsName);

  if (const Function *F = dyn_cast<Function>(PutS->stripPointerCasts()))

    CI->setCallingConv(F->getCallingConv());

  return CI;
@@ -993,13 +1008,14 @@ Value *llvm::emitFPutC(Value *Char, Value *File, IRBuilder<> &B, 
    return nullptr;



  Module *M = B.GetInsertBlock()->getModule();

  Constant *F = M->getOrInsertFunction("fputc", B.getInt32Ty(), B.getInt32Ty(),

  StringRef FPutcName = TLI->getName(LibFunc_fputc);

  Constant *F = M->getOrInsertFunction(FPutcName, B.getInt32Ty(), B.getInt32Ty(),

                                       File->getType());

  if (File->getType()->isPointerTy())

    inferLibFuncAttributes(*M->getFunction("fputc"), *TLI);

    inferLibFuncAttributes(M, FPutcName, *TLI);

  Char = B.CreateIntCast(Char, B.getInt32Ty(), /*isSigned*/true,

                         "chari");

  CallInst *CI = B.CreateCall(F, {Char, File}, "fputc");

  CallInst *CI = B.CreateCall(F, {Char, File}, FPutcName);



  if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))

    CI->setCallingConv(Fn->getCallingConv());
@@ -1012,12 +1028,13 @@ Value *llvm::emitFPutCUnlocked(Value *Char, Value *File, IRBuilder<> &B, 
    return nullptr;



  Module *M = B.GetInsertBlock()->getModule();

  Constant *F = M->getOrInsertFunction("fputc_unlocked", B.getInt32Ty(),

  StringRef FPutcUnlockedName = TLI->getName(LibFunc_fputc_unlocked);

  Constant *F = M->getOrInsertFunction(FPutcUnlockedName, B.getInt32Ty(),

                                       B.getInt32Ty(), File->getType());

  if (File->getType()->isPointerTy())

    inferLibFuncAttributes(*M->getFunction("fputc_unlocked"), *TLI);

    inferLibFuncAttributes(M, FPutcUnlockedName, *TLI);

  Char = B.CreateIntCast(Char, B.getInt32Ty(), /*isSigned*/ true, "chari");

  CallInst *CI = B.CreateCall(F, {Char, File}, "fputc_unlocked");

  CallInst *CI = B.CreateCall(F, {Char, File}, FPutcUnlockedName);



  if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))

    CI->setCallingConv(Fn->getCallingConv());
@@ -1034,8 +1051,8 @@ Value *llvm::emitFPutS(Value *Str, Value *File, IRBuilder<> &B, 
  Constant *F = M->getOrInsertFunction(

      FPutsName, B.getInt32Ty(), B.getInt8PtrTy(), File->getType());

  if (File->getType()->isPointerTy())

    inferLibFuncAttributes(*M->getFunction(FPutsName), *TLI);

  CallInst *CI = B.CreateCall(F, {castToCStr(Str, B), File}, "fputs");

    inferLibFuncAttributes(M, FPutsName, *TLI);

  CallInst *CI = B.CreateCall(F, {castToCStr(Str, B), File}, FPutsName);



  if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))

    CI->setCallingConv(Fn->getCallingConv());
@@ -1052,8 +1069,8 @@ Value *llvm::emitFPutSUnlocked(Value *Str, Value *File, IRBuilder<> &B, 
  Constant *F = M->getOrInsertFunction(FPutsUnlockedName, B.getInt32Ty(),

                                       B.getInt8PtrTy(), File->getType());

  if (File->getType()->isPointerTy())

    inferLibFuncAttributes(*M->getFunction(FPutsUnlockedName), *TLI);

  CallInst *CI = B.CreateCall(F, {castToCStr(Str, B), File}, "fputs_unlocked");

    inferLibFuncAttributes(M, FPutsUnlockedName, *TLI);

  CallInst *CI = B.CreateCall(F, {castToCStr(Str, B), File}, FPutsUnlockedName);



  if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))

    CI->setCallingConv(Fn->getCallingConv());
@@ -1073,7 +1090,7 @@ Value *llvm::emitFWrite(Value *Ptr, Value *Size, Value *File, IRBuilder<> &B, 
      DL.getIntPtrType(Context), DL.getIntPtrType(Context), File->getType());



  if (File->getType()->isPointerTy())

    inferLibFuncAttributes(*M->getFunction(FWriteName), *TLI);

    inferLibFuncAttributes(M, FWriteName, *TLI);

  CallInst *CI =

      B.CreateCall(F, {castToCStr(Ptr, B), Size,

                       ConstantInt::get(DL.getIntPtrType(Context), 1), File});
@@ -1089,11 +1106,12 @@ Value *llvm::emitMalloc(Value *Num, IRBuilder<> &B, const DataLayout &DL, 
    return nullptr;



  Module *M = B.GetInsertBlock()->getModule();

  StringRef MallocName = TLI->getName(LibFunc_malloc);

  LLVMContext &Context = B.GetInsertBlock()->getContext();

  Value *Malloc = M->getOrInsertFunction("malloc", B.getInt8PtrTy(),

  Value *Malloc = M->getOrInsertFunction(MallocName, B.getInt8PtrTy(),

                                         DL.getIntPtrType(Context));

  inferLibFuncAttributes(*M->getFunction("malloc"), *TLI);

  CallInst *CI = B.CreateCall(Malloc, Num, "malloc");

  inferLibFuncAttributes(M, MallocName, *TLI);

  CallInst *CI = B.CreateCall(Malloc, Num, MallocName);



  if (const Function *F = dyn_cast<Function>(Malloc->stripPointerCasts()))

    CI->setCallingConv(F->getCallingConv());
@@ -1107,12 +1125,13 @@ Value *llvm::emitCalloc(Value *Num, Value *Size, const AttributeList &Attrs, 
    return nullptr;



  Module *M = B.GetInsertBlock()->getModule();

  StringRef CallocName = TLI.getName(LibFunc_calloc);

  const DataLayout &DL = M->getDataLayout();

  IntegerType *PtrType = DL.getIntPtrType((B.GetInsertBlock()->getContext()));

  Value *Calloc = M->getOrInsertFunction("calloc", Attrs, B.getInt8PtrTy(),

  Value *Calloc = M->getOrInsertFunction(CallocName, Attrs, B.getInt8PtrTy(),

                                         PtrType, PtrType);

  inferLibFuncAttributes(*M->getFunction("calloc"), TLI);

  CallInst *CI = B.CreateCall(Calloc, {Num, Size}, "calloc");

  inferLibFuncAttributes(M, CallocName, TLI);

  CallInst *CI = B.CreateCall(Calloc, {Num, Size}, CallocName);



  if (const auto *F = dyn_cast<Function>(Calloc->stripPointerCasts()))

    CI->setCallingConv(F->getCallingConv());
@@ -1134,7 +1153,7 @@ Value *llvm::emitFWriteUnlocked(Value *Ptr, Value *Size, Value *N, Value *File, 
      DL.getIntPtrType(Context), DL.getIntPtrType(Context), File->getType());



  if (File->getType()->isPointerTy())

    inferLibFuncAttributes(*M->getFunction(FWriteUnlockedName), *TLI);

    inferLibFuncAttributes(M, FWriteUnlockedName, *TLI);

  CallInst *CI = B.CreateCall(F, {castToCStr(Ptr, B), Size, N, File});



  if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))
@@ -1148,11 +1167,12 @@ Value *llvm::emitFGetCUnlocked(Value *File, IRBuilder<> &B, 
    return nullptr;



  Module *M = B.GetInsertBlock()->getModule();

  StringRef FGetCUnlockedName = TLI->getName(LibFunc_fgetc_unlocked);

  Constant *F =

      M->getOrInsertFunction("fgetc_unlocked", B.getInt32Ty(), File->getType());

      M->getOrInsertFunction(FGetCUnlockedName, B.getInt32Ty(), File->getType());

  if (File->getType()->isPointerTy())

    inferLibFuncAttributes(*M->getFunction("fgetc_unlocked"), *TLI);

  CallInst *CI = B.CreateCall(F, File, "fgetc_unlocked");

    inferLibFuncAttributes(M, FGetCUnlockedName, *TLI);

  CallInst *CI = B.CreateCall(F, File, FGetCUnlockedName);



  if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))

    CI->setCallingConv(Fn->getCallingConv());
@@ -1165,12 +1185,13 @@ Value *llvm::emitFGetSUnlocked(Value *Str, Value *Size, Value *File, 
    return nullptr;



  Module *M = B.GetInsertBlock()->getModule();

  StringRef FGetSUnlockedName = TLI->getName(LibFunc_fgets_unlocked);

  Constant *F =

      M->getOrInsertFunction("fgets_unlocked", B.getInt8PtrTy(),

      M->getOrInsertFunction(FGetSUnlockedName, B.getInt8PtrTy(),

                             B.getInt8PtrTy(), B.getInt32Ty(), File->getType());

  inferLibFuncAttributes(*M->getFunction("fgets_unlocked"), *TLI);

  inferLibFuncAttributes(M, FGetSUnlockedName, *TLI);

  CallInst *CI =

      B.CreateCall(F, {castToCStr(Str, B), Size, File}, "fgets_unlocked");

      B.CreateCall(F, {castToCStr(Str, B), Size, File}, FGetSUnlockedName);



  if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))

    CI->setCallingConv(Fn->getCallingConv());
@@ -1191,7 +1212,7 @@ Value *llvm::emitFReadUnlocked(Value *Ptr, Value *Size, Value *N, Value *File, 
      DL.getIntPtrType(Context), DL.getIntPtrType(Context), File->getType());



  if (File->getType()->isPointerTy())

    inferLibFuncAttributes(*M->getFunction(FReadUnlockedName), *TLI);

    inferLibFuncAttributes(M, FReadUnlockedName, *TLI);

  CallInst *CI = B.CreateCall(F, {castToCStr(Ptr, B), Size, N, File});



  if (const Function *Fn = dyn_cast<Function>(F->stripPointerCasts()))

llvm/test/Transforms/InstCombine/pr39177.ll

0 → 100644
+44 −0
Original line number Diff line number Diff line 
; NOTE: Assertions have been autogenerated by utils/update_test_checks.py

; RUN: opt < %s -instcombine -S | FileCheck %s



%struct._IO_FILE = type { i32, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, i8*, %struct._IO_marker*, %struct._IO_FILE*, i32, i32, i64, i16, i8, [1 x i8], i8*, i64, i8*, i8*, i8*, i8*, i64, i32, [20 x i8] }

%struct._IO_marker = type { %struct._IO_marker*, %struct._IO_FILE*, i32 }



@stderr = external global %struct._IO_FILE*, align 8

@.str = private constant [8 x i8] c"crash!\0A\00", align 1



@fwrite = alias i64 (i8*, i64, i64, %struct._IO_FILE*), i64 (i8*, i64, i64, %struct._IO_FILE*)* @__fwrite_alias



define i64 @__fwrite_alias(i8* %ptr, i64 %size, i64 %n, %struct._IO_FILE* %s) {

; CHECK-LABEL: @__fwrite_alias(

; CHECK-NEXT:  entry:

; CHECK-NEXT:    ret i64 0

;

entry:

  %ptr.addr = alloca i8*, align 8

  %size.addr = alloca i64, align 8

  %n.addr = alloca i64, align 8

  %s.addr = alloca %struct._IO_FILE*, align 8

  store i8* %ptr, i8** %ptr.addr, align 8

  store i64 %size, i64* %size.addr, align 8

  store i64 %n, i64* %n.addr, align 8

  store %struct._IO_FILE* %s, %struct._IO_FILE** %s.addr, align 8

  ret i64 0

}



define void @foo() {

; CHECK-LABEL: @foo(

; CHECK-NEXT:  entry:

; CHECK-NEXT:    [[TMP0:%.*]] = load %struct._IO_FILE*, %struct._IO_FILE** @stderr, align 8

; CHECK-NEXT:    [[TMP1:%.*]] = call i64 @__fwrite_alias(i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i64 0, i64 0), i64 7, i64 1, %struct._IO_FILE* [[TMP0]])

; CHECK-NEXT:    ret void

;

entry:

  %retval = alloca i32, align 4

  store i32 0, i32* %retval, align 4

  %0 = load %struct._IO_FILE*, %struct._IO_FILE** @stderr, align 8

  %call = call i32 (%struct._IO_FILE*, i8*, ...) @fprintf(%struct._IO_FILE* %0, i8* getelementptr inbounds ([8 x i8], [8 x i8]* @.str, i32 0, i32 0))

  ret void

}



declare i32 @fprintf(%struct._IO_FILE*, i8*, ...)