From 7c7760da7ea03c154bb4f7fb4c50b1d947e4efdb Mon Sep 17 00:00:00 2001 From: David Bolvansky Date: Tue, 16 Oct 2018 21:18:31 +0000 Subject: [PATCH] [InstCombine] Cleanup libfunc attribute inferring Reviewers: efriedma Reviewed By: efriedma Subscribers: llvm-commits Differential Revision: https://reviews.llvm.org/D53338 llvm-svn: 344645 --- llvm/include/llvm/Transforms/Utils/BuildLibCalls.h | 3 +- llvm/lib/Transforms/IPO/InferFunctionAttrs.cpp | 2 +- llvm/lib/Transforms/Scalar/LoopIdiomRecognize.cpp | 5 +- llvm/lib/Transforms/Utils/BuildLibCalls.cpp | 121 ++++++++++++--------- llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp | 2 +- llvm/test/Transforms/InstCombine/pr39177.ll | 13 ++- 6 files changed, 88 insertions(+), 58 deletions(-) diff --git a/llvm/include/llvm/Transforms/Utils/BuildLibCalls.h b/llvm/include/llvm/Transforms/Utils/BuildLibCalls.h index ab7d22c..eafe07f 100644 --- a/llvm/include/llvm/Transforms/Utils/BuildLibCalls.h +++ b/llvm/include/llvm/Transforms/Utils/BuildLibCalls.h @@ -28,7 +28,8 @@ namespace llvm { /// If the library function is unavailable, this doesn't modify it. /// /// Returns true if any attributes were set and false otherwise. - bool inferLibFuncAttributes(Function *Func, const TargetLibraryInfo &TLI); + 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. diff --git a/llvm/lib/Transforms/IPO/InferFunctionAttrs.cpp b/llvm/lib/Transforms/IPO/InferFunctionAttrs.cpp index c53a9b5..470f97b 100644 --- a/llvm/lib/Transforms/IPO/InferFunctionAttrs.cpp +++ b/llvm/lib/Transforms/IPO/InferFunctionAttrs.cpp @@ -27,7 +27,7 @@ static bool inferAllPrototypeAttributes(Module &M, // We only infer things using the prototype and the name; we don't need // definitions. if (F.isDeclaration() && !F.hasFnAttribute((Attribute::OptimizeNone))) - Changed |= inferLibFuncAttributes(&F, TLI); + Changed |= inferLibFuncAttributes(F, TLI); return Changed; } diff --git a/llvm/lib/Transforms/Scalar/LoopIdiomRecognize.cpp b/llvm/lib/Transforms/Scalar/LoopIdiomRecognize.cpp index 4b37595..241dbed 100644 --- a/llvm/lib/Transforms/Scalar/LoopIdiomRecognize.cpp +++ b/llvm/lib/Transforms/Scalar/LoopIdiomRecognize.cpp @@ -928,10 +928,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. diff --git a/llvm/lib/Transforms/Utils/BuildLibCalls.cpp b/llvm/lib/Transforms/Utils/BuildLibCalls.cpp index 234449b..06d197b 100644 --- a/llvm/lib/Transforms/Utils/BuildLibCalls.cpp +++ b/llvm/lib/Transforms/Utils/BuildLibCalls.cpp @@ -121,11 +121,15 @@ static bool setNonLazyBind(Function &F) { return true; } -bool llvm::inferLibFuncAttributes(Function *Func, +bool llvm::inferLibFuncAttributes(Module *M, StringRef Name, const TargetLibraryInfo &TLI) { - if (!Func) + Function *F = M->getFunction(Name); + if (!F) return false; - Function &F = *Func; + return inferLibFuncAttributes(*F, TLI); +} + +bool llvm::inferLibFuncAttributes(Function &F, const TargetLibraryInfo &TLI) { LibFunc TheLibFunc; if (!(TLI.getLibFunc(F, TheLibFunc) && TLI.has(TheLibFunc))) return false; @@ -774,11 +778,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(StrLen->stripPointerCasts())) CI->setCallingConv(F->getCallingConv()); @@ -791,13 +796,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(StrChr->stripPointerCasts())) CI->setCallingConv(F->getCallingConv()); return CI; @@ -809,13 +815,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(StrNCmp->stripPointerCasts())) CI->setCallingConv(F->getCallingConv()); @@ -831,7 +838,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(StrCpy->stripPointerCasts())) @@ -848,9 +855,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(StrNCpy->stripPointerCasts())) CI->setCallingConv(F->getCallingConv()); return CI; @@ -885,12 +892,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(MemChr->stripPointerCasts())) CI->setCallingConv(F->getCallingConv()); @@ -904,13 +912,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(MemCmp->stripPointerCasts())) CI->setCallingConv(F->getCallingConv()); @@ -977,14 +986,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(PutChar->stripPointerCasts())) CI->setCallingConv(F->getCallingConv()); @@ -997,10 +1007,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(PutS->stripPointerCasts())) CI->setCallingConv(F->getCallingConv()); return CI; @@ -1012,13 +1023,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(F->stripPointerCasts())) CI->setCallingConv(Fn->getCallingConv()); @@ -1031,12 +1043,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(F->stripPointerCasts())) CI->setCallingConv(Fn->getCallingConv()); @@ -1053,8 +1066,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(F->stripPointerCasts())) CI->setCallingConv(Fn->getCallingConv()); @@ -1071,8 +1084,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(F->stripPointerCasts())) CI->setCallingConv(Fn->getCallingConv()); @@ -1092,7 +1105,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}); @@ -1108,11 +1121,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(Malloc->stripPointerCasts())) CI->setCallingConv(F->getCallingConv()); @@ -1126,12 +1140,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(Calloc->stripPointerCasts())) CI->setCallingConv(F->getCallingConv()); @@ -1153,7 +1168,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(F->stripPointerCasts())) @@ -1167,11 +1182,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(F->stripPointerCasts())) CI->setCallingConv(Fn->getCallingConv()); @@ -1184,12 +1200,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(F->stripPointerCasts())) CI->setCallingConv(Fn->getCallingConv()); @@ -1210,7 +1227,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(F->stripPointerCasts())) diff --git a/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp b/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp index 6f24dc1..41a495a 100644 --- a/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp +++ b/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp @@ -145,7 +145,7 @@ static bool isLocallyOpenedFile(Value *File, CallInst *CI, IRBuilder<> &B, Func != LibFunc_fopen) return false; - inferLibFuncAttributes(CI->getCalledFunction(), *TLI); + inferLibFuncAttributes(*CI->getCalledFunction(), *TLI); if (PointerMayBeCaptured(File, true, true)) return false; diff --git a/llvm/test/Transforms/InstCombine/pr39177.ll b/llvm/test/Transforms/InstCombine/pr39177.ll index a047a07..35c5ce0 100644 --- a/llvm/test/Transforms/InstCombine/pr39177.ll +++ b/llvm/test/Transforms/InstCombine/pr39177.ll @@ -1,4 +1,5 @@ -; RUN: opt < %s -instcombine -S +; 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 } @@ -9,6 +10,10 @@ @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 @@ -22,6 +27,12 @@ entry: } 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 -- 2.7.4