From d10a03dac43d5a7c71eedd9459b41f31efe750d4 Mon Sep 17 00:00:00 2001 From: Owen Anderson Date: Thu, 5 Dec 2024 15:08:42 +1300 Subject: [PATCH 1/4] SimplifyLibCalls: Use default globals address space when building new global strings. Writing a test for this transitively exposed a number of places in BuildLibCalls where we were failing to propagate address spaces properly, which are additionally fixed. --- .../llvm/Transforms/Utils/BuildLibCalls.h | 17 +-- llvm/lib/Transforms/Utils/BuildLibCalls.cpp | 113 ++++++++++-------- .../lib/Transforms/Utils/SimplifyLibCalls.cpp | 88 +++++++++----- .../InstCombine/printf-addrspace.ll | 42 +++++++ 4 files changed, 173 insertions(+), 87 deletions(-) create mode 100644 llvm/test/Transforms/InstCombine/printf-addrspace.ll diff --git a/llvm/include/llvm/Transforms/Utils/BuildLibCalls.h b/llvm/include/llvm/Transforms/Utils/BuildLibCalls.h index a8fb38e726004..3766c755baf4f 100644 --- a/llvm/include/llvm/Transforms/Utils/BuildLibCalls.h +++ b/llvm/include/llvm/Transforms/Utils/BuildLibCalls.h @@ -247,7 +247,7 @@ namespace llvm { /// Emit a call to the malloc function. Value *emitMalloc(Value *Num, IRBuilderBase &B, const DataLayout &DL, - const TargetLibraryInfo *TLI); + const TargetLibraryInfo *TLI, unsigned AddrSpace); /// Emit a call to the calloc function. Value *emitCalloc(Value *Num, Value *Size, IRBuilderBase &B, @@ -256,24 +256,27 @@ namespace llvm { /// Emit a call to the hot/cold operator new function. Value *emitHotColdNew(Value *Num, IRBuilderBase &B, const TargetLibraryInfo *TLI, LibFunc NewFunc, - uint8_t HotCold); + uint8_t HotCold, unsigned AddrSpace); Value *emitHotColdNewNoThrow(Value *Num, Value *NoThrow, IRBuilderBase &B, const TargetLibraryInfo *TLI, LibFunc NewFunc, - uint8_t HotCold); + uint8_t HotCold, unsigned AddrSpace); Value *emitHotColdNewAligned(Value *Num, Value *Align, IRBuilderBase &B, const TargetLibraryInfo *TLI, LibFunc NewFunc, - uint8_t HotCold); + uint8_t HotCold, unsigned AddrSpace); Value *emitHotColdNewAlignedNoThrow(Value *Num, Value *Align, Value *NoThrow, IRBuilderBase &B, const TargetLibraryInfo *TLI, - LibFunc NewFunc, uint8_t HotCold); + LibFunc NewFunc, uint8_t HotCold, + unsigned AddrSpace); Value *emitHotColdSizeReturningNew(Value *Num, IRBuilderBase &B, const TargetLibraryInfo *TLI, - LibFunc NewFunc, uint8_t HotCold); + LibFunc NewFunc, uint8_t HotCold, + unsigned AddrSpace); Value *emitHotColdSizeReturningNewAligned(Value *Num, Value *Align, IRBuilderBase &B, const TargetLibraryInfo *TLI, - LibFunc NewFunc, uint8_t HotCold); + LibFunc NewFunc, uint8_t HotCold, + unsigned AddrSpace); } #endif diff --git a/llvm/lib/Transforms/Utils/BuildLibCalls.cpp b/llvm/lib/Transforms/Utils/BuildLibCalls.cpp index e4f4052e5e481..c7aec524eedfd 100644 --- a/llvm/lib/Transforms/Utils/BuildLibCalls.cpp +++ b/llvm/lib/Transforms/Utils/BuildLibCalls.cpp @@ -1545,20 +1545,20 @@ static Value *emitLibCall(LibFunc TheLibFunc, Type *ReturnType, Value *llvm::emitStrLen(Value *Ptr, IRBuilderBase &B, const DataLayout &DL, const TargetLibraryInfo *TLI) { - Type *CharPtrTy = B.getPtrTy(); + Type *CharPtrTy = Ptr->getType(); Type *SizeTTy = getSizeTTy(B, TLI); return emitLibCall(LibFunc_strlen, SizeTTy, CharPtrTy, Ptr, B, TLI); } Value *llvm::emitStrDup(Value *Ptr, IRBuilderBase &B, const TargetLibraryInfo *TLI) { - Type *CharPtrTy = B.getPtrTy(); + Type *CharPtrTy = Ptr->getType(); return emitLibCall(LibFunc_strdup, CharPtrTy, CharPtrTy, Ptr, B, TLI); } Value *llvm::emitStrChr(Value *Ptr, char C, IRBuilderBase &B, const TargetLibraryInfo *TLI) { - Type *CharPtrTy = B.getPtrTy(); + Type *CharPtrTy = Ptr->getType(); Type *IntTy = getIntTy(B, TLI); return emitLibCall(LibFunc_strchr, CharPtrTy, {CharPtrTy, IntTy}, {Ptr, ConstantInt::get(IntTy, C)}, B, TLI); @@ -1566,7 +1566,8 @@ Value *llvm::emitStrChr(Value *Ptr, char C, IRBuilderBase &B, Value *llvm::emitStrNCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B, const DataLayout &DL, const TargetLibraryInfo *TLI) { - Type *CharPtrTy = B.getPtrTy(); + Type *CharPtrTy = Ptr1->getType(); + assert(CharPtrTy == Ptr2->getType()); Type *IntTy = getIntTy(B, TLI); Type *SizeTTy = getSizeTTy(B, TLI); return emitLibCall( @@ -1578,20 +1579,23 @@ Value *llvm::emitStrNCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B, Value *llvm::emitStrCpy(Value *Dst, Value *Src, IRBuilderBase &B, const TargetLibraryInfo *TLI) { Type *CharPtrTy = Dst->getType(); + assert(CharPtrTy == Src->getType()); return emitLibCall(LibFunc_strcpy, CharPtrTy, {CharPtrTy, CharPtrTy}, {Dst, Src}, B, TLI); } Value *llvm::emitStpCpy(Value *Dst, Value *Src, IRBuilderBase &B, const TargetLibraryInfo *TLI) { - Type *CharPtrTy = B.getPtrTy(); + Type *CharPtrTy = Dst->getType(); + assert(CharPtrTy == Src->getType()); return emitLibCall(LibFunc_stpcpy, CharPtrTy, {CharPtrTy, CharPtrTy}, {Dst, Src}, B, TLI); } Value *llvm::emitStrNCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B, const TargetLibraryInfo *TLI) { - Type *CharPtrTy = B.getPtrTy(); + Type *CharPtrTy = Dst->getType(); + assert(CharPtrTy == Src->getType()); Type *SizeTTy = getSizeTTy(B, TLI); return emitLibCall(LibFunc_strncpy, CharPtrTy, {CharPtrTy, CharPtrTy, SizeTTy}, {Dst, Src, Len}, B, TLI); @@ -1599,7 +1603,8 @@ Value *llvm::emitStrNCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B, Value *llvm::emitStpNCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B, const TargetLibraryInfo *TLI) { - Type *CharPtrTy = B.getPtrTy(); + Type *CharPtrTy = Dst->getType(); + assert(CharPtrTy == Src->getType()); Type *SizeTTy = getSizeTTy(B, TLI); return emitLibCall(LibFunc_stpncpy, CharPtrTy, {CharPtrTy, CharPtrTy, SizeTTy}, {Dst, Src, Len}, B, TLI); @@ -1615,7 +1620,8 @@ Value *llvm::emitMemCpyChk(Value *Dst, Value *Src, Value *Len, Value *ObjSize, AttributeList AS; AS = AttributeList::get(M->getContext(), AttributeList::FunctionIndex, Attribute::NoUnwind); - Type *VoidPtrTy = B.getPtrTy(); + Type *VoidPtrTy = Dst->getType(); + assert(VoidPtrTy == Src->getType()); Type *SizeTTy = getSizeTTy(B, TLI); FunctionCallee MemCpy = getOrInsertLibFunc(M, *TLI, LibFunc_memcpy_chk, AttributeList::get(M->getContext(), AS), VoidPtrTy, @@ -1629,7 +1635,8 @@ Value *llvm::emitMemCpyChk(Value *Dst, Value *Src, Value *Len, Value *ObjSize, Value *llvm::emitMemPCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B, const DataLayout &DL, const TargetLibraryInfo *TLI) { - Type *VoidPtrTy = B.getPtrTy(); + Type *VoidPtrTy = Dst->getType(); + assert(VoidPtrTy == Src->getType()); Type *SizeTTy = getSizeTTy(B, TLI); return emitLibCall(LibFunc_mempcpy, VoidPtrTy, {VoidPtrTy, VoidPtrTy, SizeTTy}, @@ -1638,7 +1645,7 @@ Value *llvm::emitMemPCpy(Value *Dst, Value *Src, Value *Len, IRBuilderBase &B, Value *llvm::emitMemChr(Value *Ptr, Value *Val, Value *Len, IRBuilderBase &B, const DataLayout &DL, const TargetLibraryInfo *TLI) { - Type *VoidPtrTy = B.getPtrTy(); + Type *VoidPtrTy = Ptr->getType(); Type *IntTy = getIntTy(B, TLI); Type *SizeTTy = getSizeTTy(B, TLI); return emitLibCall(LibFunc_memchr, VoidPtrTy, @@ -1648,7 +1655,7 @@ Value *llvm::emitMemChr(Value *Ptr, Value *Val, Value *Len, IRBuilderBase &B, Value *llvm::emitMemRChr(Value *Ptr, Value *Val, Value *Len, IRBuilderBase &B, const DataLayout &DL, const TargetLibraryInfo *TLI) { - Type *VoidPtrTy = B.getPtrTy(); + Type *VoidPtrTy = Ptr->getType(); Type *IntTy = getIntTy(B, TLI); Type *SizeTTy = getSizeTTy(B, TLI); return emitLibCall(LibFunc_memrchr, VoidPtrTy, @@ -1658,7 +1665,8 @@ Value *llvm::emitMemRChr(Value *Ptr, Value *Val, Value *Len, IRBuilderBase &B, Value *llvm::emitMemCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B, const DataLayout &DL, const TargetLibraryInfo *TLI) { - Type *VoidPtrTy = B.getPtrTy(); + Type *VoidPtrTy = Ptr1->getType(); + assert(VoidPtrTy == Ptr2->getType()); Type *IntTy = getIntTy(B, TLI); Type *SizeTTy = getSizeTTy(B, TLI); return emitLibCall(LibFunc_memcmp, IntTy, @@ -1668,7 +1676,8 @@ Value *llvm::emitMemCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B, Value *llvm::emitBCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B, const DataLayout &DL, const TargetLibraryInfo *TLI) { - Type *VoidPtrTy = B.getPtrTy(); + Type *VoidPtrTy = Ptr1->getType(); + assert(VoidPtrTy == Ptr2->getType()); Type *IntTy = getIntTy(B, TLI); Type *SizeTTy = getSizeTTy(B, TLI); return emitLibCall(LibFunc_bcmp, IntTy, @@ -1678,7 +1687,8 @@ Value *llvm::emitBCmp(Value *Ptr1, Value *Ptr2, Value *Len, IRBuilderBase &B, Value *llvm::emitMemCCpy(Value *Ptr1, Value *Ptr2, Value *Val, Value *Len, IRBuilderBase &B, const TargetLibraryInfo *TLI) { - Type *VoidPtrTy = B.getPtrTy(); + Type *VoidPtrTy = Ptr1->getType(); + assert(VoidPtrTy == Ptr2->getType()); Type *IntTy = getIntTy(B, TLI); Type *SizeTTy = getSizeTTy(B, TLI); return emitLibCall(LibFunc_memccpy, VoidPtrTy, @@ -1689,7 +1699,8 @@ Value *llvm::emitMemCCpy(Value *Ptr1, Value *Ptr2, Value *Val, Value *Len, Value *llvm::emitSNPrintf(Value *Dest, Value *Size, Value *Fmt, ArrayRef VariadicArgs, IRBuilderBase &B, const TargetLibraryInfo *TLI) { - Type *CharPtrTy = B.getPtrTy(); + Type *CharPtrTy = Dest->getType(); + assert(CharPtrTy == Fmt->getType()); Type *IntTy = getIntTy(B, TLI); Type *SizeTTy = getSizeTTy(B, TLI); SmallVector Args{Dest, Size, Fmt}; @@ -1702,7 +1713,7 @@ Value *llvm::emitSNPrintf(Value *Dest, Value *Size, Value *Fmt, Value *llvm::emitSPrintf(Value *Dest, Value *Fmt, ArrayRef VariadicArgs, IRBuilderBase &B, const TargetLibraryInfo *TLI) { - Type *CharPtrTy = B.getPtrTy(); + Type *CharPtrTy = Dest->getType(); Type *IntTy = getIntTy(B, TLI); SmallVector Args{Dest, Fmt}; llvm::append_range(Args, VariadicArgs); @@ -1713,7 +1724,8 @@ Value *llvm::emitSPrintf(Value *Dest, Value *Fmt, Value *llvm::emitStrCat(Value *Dest, Value *Src, IRBuilderBase &B, const TargetLibraryInfo *TLI) { - Type *CharPtrTy = B.getPtrTy(); + Type *CharPtrTy = Dest->getType(); + assert(CharPtrTy == Src->getType()); return emitLibCall(LibFunc_strcat, CharPtrTy, {CharPtrTy, CharPtrTy}, {Dest, Src}, B, TLI); @@ -1721,7 +1733,8 @@ Value *llvm::emitStrCat(Value *Dest, Value *Src, IRBuilderBase &B, Value *llvm::emitStrLCpy(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B, const TargetLibraryInfo *TLI) { - Type *CharPtrTy = B.getPtrTy(); + Type *CharPtrTy = Dest->getType(); + assert(CharPtrTy == Src->getType()); Type *SizeTTy = getSizeTTy(B, TLI); return emitLibCall(LibFunc_strlcpy, SizeTTy, {CharPtrTy, CharPtrTy, SizeTTy}, @@ -1730,7 +1743,8 @@ Value *llvm::emitStrLCpy(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B, Value *llvm::emitStrLCat(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B, const TargetLibraryInfo *TLI) { - Type *CharPtrTy = B.getPtrTy(); + Type *CharPtrTy = Dest->getType(); + assert(CharPtrTy == Src->getType()); Type *SizeTTy = getSizeTTy(B, TLI); return emitLibCall(LibFunc_strlcat, SizeTTy, {CharPtrTy, CharPtrTy, SizeTTy}, @@ -1739,7 +1753,8 @@ Value *llvm::emitStrLCat(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B, Value *llvm::emitStrNCat(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B, const TargetLibraryInfo *TLI) { - Type *CharPtrTy = B.getPtrTy(); + Type *CharPtrTy = Dest->getType(); + assert(CharPtrTy == Src->getType()); Type *SizeTTy = getSizeTTy(B, TLI); return emitLibCall(LibFunc_strncat, CharPtrTy, {CharPtrTy, CharPtrTy, SizeTTy}, @@ -1748,7 +1763,8 @@ Value *llvm::emitStrNCat(Value *Dest, Value *Src, Value *Size, IRBuilderBase &B, Value *llvm::emitVSNPrintf(Value *Dest, Value *Size, Value *Fmt, Value *VAList, IRBuilderBase &B, const TargetLibraryInfo *TLI) { - Type *CharPtrTy = B.getPtrTy(); + Type *CharPtrTy = Dest->getType(); + assert(CharPtrTy == Fmt->getType()); Type *IntTy = getIntTy(B, TLI); Type *SizeTTy = getSizeTTy(B, TLI); return emitLibCall( @@ -1759,7 +1775,8 @@ Value *llvm::emitVSNPrintf(Value *Dest, Value *Size, Value *Fmt, Value *VAList, Value *llvm::emitVSPrintf(Value *Dest, Value *Fmt, Value *VAList, IRBuilderBase &B, const TargetLibraryInfo *TLI) { - Type *CharPtrTy = B.getPtrTy(); + Type *CharPtrTy = Dest->getType(); + assert(CharPtrTy == Fmt->getType()); Type *IntTy = getIntTy(B, TLI); return emitLibCall(LibFunc_vsprintf, IntTy, {CharPtrTy, CharPtrTy, VAList->getType()}, @@ -1912,8 +1929,8 @@ Value *llvm::emitPutS(Value *Str, IRBuilderBase &B, Type *IntTy = getIntTy(B, TLI); StringRef PutsName = TLI->getName(LibFunc_puts); - FunctionCallee PutS = getOrInsertLibFunc(M, *TLI, LibFunc_puts, IntTy, - B.getPtrTy()); + FunctionCallee PutS = + getOrInsertLibFunc(M, *TLI, LibFunc_puts, IntTy, Str->getType()); inferNonMandatoryLibFuncAttrs(M, PutsName, *TLI); CallInst *CI = B.CreateCall(PutS, Str, PutsName); if (const Function *F = @@ -1951,7 +1968,7 @@ Value *llvm::emitFPutS(Value *Str, Value *File, IRBuilderBase &B, Type *IntTy = getIntTy(B, TLI); StringRef FPutsName = TLI->getName(LibFunc_fputs); FunctionCallee F = getOrInsertLibFunc(M, *TLI, LibFunc_fputs, IntTy, - B.getPtrTy(), File->getType()); + Str->getType(), File->getType()); if (File->getType()->isPointerTy()) inferNonMandatoryLibFuncAttrs(M, FPutsName, *TLI); CallInst *CI = B.CreateCall(F, {Str, File}, FPutsName); @@ -1970,9 +1987,9 @@ Value *llvm::emitFWrite(Value *Ptr, Value *Size, Value *File, IRBuilderBase &B, Type *SizeTTy = getSizeTTy(B, TLI); StringRef FWriteName = TLI->getName(LibFunc_fwrite); - FunctionCallee F = getOrInsertLibFunc(M, *TLI, LibFunc_fwrite, - SizeTTy, B.getPtrTy(), SizeTTy, - SizeTTy, File->getType()); + FunctionCallee F = + getOrInsertLibFunc(M, *TLI, LibFunc_fwrite, SizeTTy, Ptr->getType(), + SizeTTy, SizeTTy, File->getType()); if (File->getType()->isPointerTy()) inferNonMandatoryLibFuncAttrs(M, FWriteName, *TLI); @@ -1987,7 +2004,7 @@ Value *llvm::emitFWrite(Value *Ptr, Value *Size, Value *File, IRBuilderBase &B, } Value *llvm::emitMalloc(Value *Num, IRBuilderBase &B, const DataLayout &DL, - const TargetLibraryInfo *TLI) { + const TargetLibraryInfo *TLI, unsigned AddrSpace) { Module *M = B.GetInsertBlock()->getModule(); if (!isLibFuncEmittable(M, TLI, LibFunc_malloc)) return nullptr; @@ -1995,7 +2012,7 @@ Value *llvm::emitMalloc(Value *Num, IRBuilderBase &B, const DataLayout &DL, StringRef MallocName = TLI->getName(LibFunc_malloc); Type *SizeTTy = getSizeTTy(B, TLI); FunctionCallee Malloc = getOrInsertLibFunc(M, *TLI, LibFunc_malloc, - B.getPtrTy(), SizeTTy); + B.getPtrTy(AddrSpace), SizeTTy); inferNonMandatoryLibFuncAttrs(M, MallocName, *TLI); CallInst *CI = B.CreateCall(Malloc, Num, MallocName); @@ -2029,7 +2046,7 @@ Value *llvm::emitCalloc(Value *Num, Value *Size, IRBuilderBase &B, Value *llvm::emitHotColdSizeReturningNew(Value *Num, IRBuilderBase &B, const TargetLibraryInfo *TLI, LibFunc SizeFeedbackNewFunc, - uint8_t HotCold) { + uint8_t HotCold, unsigned AddrSpace) { Module *M = B.GetInsertBlock()->getModule(); if (!isLibFuncEmittable(M, TLI, SizeFeedbackNewFunc)) return nullptr; @@ -2038,7 +2055,7 @@ Value *llvm::emitHotColdSizeReturningNew(Value *Num, IRBuilderBase &B, // __sized_ptr_t struct return type { void*, size_t } StructType *SizedPtrT = - StructType::get(M->getContext(), {B.getPtrTy(), Num->getType()}); + StructType::get(M->getContext(), {B.getPtrTy(AddrSpace), Num->getType()}); FunctionCallee Func = M->getOrInsertFunction(Name, SizedPtrT, Num->getType(), B.getInt8Ty()); inferNonMandatoryLibFuncAttrs(M, Name, *TLI); @@ -2050,11 +2067,9 @@ Value *llvm::emitHotColdSizeReturningNew(Value *Num, IRBuilderBase &B, return CI; } -Value *llvm::emitHotColdSizeReturningNewAligned(Value *Num, Value *Align, - IRBuilderBase &B, - const TargetLibraryInfo *TLI, - LibFunc SizeFeedbackNewFunc, - uint8_t HotCold) { +Value *llvm::emitHotColdSizeReturningNewAligned( + Value *Num, Value *Align, IRBuilderBase &B, const TargetLibraryInfo *TLI, + LibFunc SizeFeedbackNewFunc, uint8_t HotCold, unsigned AddrSpace) { Module *M = B.GetInsertBlock()->getModule(); if (!isLibFuncEmittable(M, TLI, SizeFeedbackNewFunc)) return nullptr; @@ -2063,7 +2078,7 @@ Value *llvm::emitHotColdSizeReturningNewAligned(Value *Num, Value *Align, // __sized_ptr_t struct return type { void*, size_t } StructType *SizedPtrT = - StructType::get(M->getContext(), {B.getPtrTy(), Num->getType()}); + StructType::get(M->getContext(), {B.getPtrTy(AddrSpace), Num->getType()}); FunctionCallee Func = M->getOrInsertFunction(Name, SizedPtrT, Num->getType(), Align->getType(), B.getInt8Ty()); inferNonMandatoryLibFuncAttrs(M, Name, *TLI); @@ -2078,13 +2093,13 @@ Value *llvm::emitHotColdSizeReturningNewAligned(Value *Num, Value *Align, Value *llvm::emitHotColdNew(Value *Num, IRBuilderBase &B, const TargetLibraryInfo *TLI, LibFunc NewFunc, - uint8_t HotCold) { + uint8_t HotCold, unsigned AddrSpace) { Module *M = B.GetInsertBlock()->getModule(); if (!isLibFuncEmittable(M, TLI, NewFunc)) return nullptr; StringRef Name = TLI->getName(NewFunc); - FunctionCallee Func = M->getOrInsertFunction(Name, B.getPtrTy(), + FunctionCallee Func = M->getOrInsertFunction(Name, B.getPtrTy(AddrSpace), Num->getType(), B.getInt8Ty()); inferNonMandatoryLibFuncAttrs(M, Name, *TLI); CallInst *CI = B.CreateCall(Func, {Num, B.getInt8(HotCold)}, Name); @@ -2098,14 +2113,15 @@ Value *llvm::emitHotColdNew(Value *Num, IRBuilderBase &B, Value *llvm::emitHotColdNewNoThrow(Value *Num, Value *NoThrow, IRBuilderBase &B, const TargetLibraryInfo *TLI, - LibFunc NewFunc, uint8_t HotCold) { + LibFunc NewFunc, uint8_t HotCold, + unsigned AddrSpace) { Module *M = B.GetInsertBlock()->getModule(); if (!isLibFuncEmittable(M, TLI, NewFunc)) return nullptr; StringRef Name = TLI->getName(NewFunc); FunctionCallee Func = - M->getOrInsertFunction(Name, B.getPtrTy(), Num->getType(), + M->getOrInsertFunction(Name, B.getPtrTy(AddrSpace), Num->getType(), NoThrow->getType(), B.getInt8Ty()); inferNonMandatoryLibFuncAttrs(M, Name, *TLI); CallInst *CI = B.CreateCall(Func, {Num, NoThrow, B.getInt8(HotCold)}, Name); @@ -2119,14 +2135,16 @@ Value *llvm::emitHotColdNewNoThrow(Value *Num, Value *NoThrow, IRBuilderBase &B, Value *llvm::emitHotColdNewAligned(Value *Num, Value *Align, IRBuilderBase &B, const TargetLibraryInfo *TLI, - LibFunc NewFunc, uint8_t HotCold) { + LibFunc NewFunc, uint8_t HotCold, + unsigned AddrSpace) { Module *M = B.GetInsertBlock()->getModule(); if (!isLibFuncEmittable(M, TLI, NewFunc)) return nullptr; StringRef Name = TLI->getName(NewFunc); - FunctionCallee Func = M->getOrInsertFunction( - Name, B.getPtrTy(), Num->getType(), Align->getType(), B.getInt8Ty()); + FunctionCallee Func = + M->getOrInsertFunction(Name, B.getPtrTy(AddrSpace), Num->getType(), + Align->getType(), B.getInt8Ty()); inferNonMandatoryLibFuncAttrs(M, Name, *TLI); CallInst *CI = B.CreateCall(Func, {Num, Align, B.getInt8(HotCold)}, Name); @@ -2140,14 +2158,15 @@ Value *llvm::emitHotColdNewAligned(Value *Num, Value *Align, IRBuilderBase &B, Value *llvm::emitHotColdNewAlignedNoThrow(Value *Num, Value *Align, Value *NoThrow, IRBuilderBase &B, const TargetLibraryInfo *TLI, - LibFunc NewFunc, uint8_t HotCold) { + LibFunc NewFunc, uint8_t HotCold, + unsigned AddrSpace) { Module *M = B.GetInsertBlock()->getModule(); if (!isLibFuncEmittable(M, TLI, NewFunc)) return nullptr; StringRef Name = TLI->getName(NewFunc); FunctionCallee Func = M->getOrInsertFunction( - Name, B.getPtrTy(), Num->getType(), Align->getType(), + Name, B.getPtrTy(AddrSpace), Num->getType(), Align->getType(), NoThrow->getType(), B.getInt8Ty()); inferNonMandatoryLibFuncAttrs(M, Name, *TLI); CallInst *CI = diff --git a/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp b/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp index d85e0d9946602..b5d6c74b439ac 100644 --- a/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp +++ b/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp @@ -917,8 +917,9 @@ Value *LibCallSimplifier::optimizeStringNCpy(CallInst *CI, bool RetEnd, // Create a bigger, nul-padded array with the same length, SrcLen, // as the original string. SrcStr.resize(N, '\0'); - Src = B.CreateGlobalString(SrcStr, "str", /*AddressSpace=*/0, - /*M=*/nullptr, /*AddNull=*/false); + Src = B.CreateGlobalString( + SrcStr, "str", /*AddressSpace=*/DL.getDefaultGlobalsAddressSpace(), + /*M=*/nullptr, /*AddNull=*/false); } Type *PT = Callee->getFunctionType()->getParamType(0); @@ -1723,7 +1724,10 @@ Value *LibCallSimplifier::optimizeMemSet(CallInst *CI, IRBuilderBase &B) { Value *LibCallSimplifier::optimizeRealloc(CallInst *CI, IRBuilderBase &B) { if (isa(CI->getArgOperand(0))) - return copyFlags(*CI, emitMalloc(CI->getArgOperand(1), B, DL, TLI)); + return copyFlags( + *CI, + emitMalloc(CI->getArgOperand(1), B, DL, TLI, + CI->getArgOperand(0)->getType()->getPointerAddressSpace())); return nullptr; } @@ -1759,122 +1763,138 @@ Value *LibCallSimplifier::optimizeNew(CallInst *CI, IRBuilderBase &B, case LibFunc_Znwm12__hot_cold_t: if (OptimizeExistingHotColdNew) return emitHotColdNew(CI->getArgOperand(0), B, TLI, - LibFunc_Znwm12__hot_cold_t, HotCold); + LibFunc_Znwm12__hot_cold_t, HotCold, + CI->getType()->getPointerAddressSpace()); break; case LibFunc_Znwm: if (HotCold != NotColdNewHintValue) return emitHotColdNew(CI->getArgOperand(0), B, TLI, - LibFunc_Znwm12__hot_cold_t, HotCold); + LibFunc_Znwm12__hot_cold_t, HotCold, + CI->getType()->getPointerAddressSpace()); break; case LibFunc_Znam12__hot_cold_t: if (OptimizeExistingHotColdNew) return emitHotColdNew(CI->getArgOperand(0), B, TLI, - LibFunc_Znam12__hot_cold_t, HotCold); + LibFunc_Znam12__hot_cold_t, HotCold, + CI->getType()->getPointerAddressSpace()); break; case LibFunc_Znam: if (HotCold != NotColdNewHintValue) return emitHotColdNew(CI->getArgOperand(0), B, TLI, - LibFunc_Znam12__hot_cold_t, HotCold); + LibFunc_Znam12__hot_cold_t, HotCold, + CI->getType()->getPointerAddressSpace()); break; case LibFunc_ZnwmRKSt9nothrow_t12__hot_cold_t: if (OptimizeExistingHotColdNew) return emitHotColdNewNoThrow( CI->getArgOperand(0), CI->getArgOperand(1), B, TLI, - LibFunc_ZnwmRKSt9nothrow_t12__hot_cold_t, HotCold); + LibFunc_ZnwmRKSt9nothrow_t12__hot_cold_t, HotCold, + CI->getType()->getPointerAddressSpace()); break; case LibFunc_ZnwmRKSt9nothrow_t: if (HotCold != NotColdNewHintValue) return emitHotColdNewNoThrow( CI->getArgOperand(0), CI->getArgOperand(1), B, TLI, - LibFunc_ZnwmRKSt9nothrow_t12__hot_cold_t, HotCold); + LibFunc_ZnwmRKSt9nothrow_t12__hot_cold_t, HotCold, + CI->getType()->getPointerAddressSpace()); break; case LibFunc_ZnamRKSt9nothrow_t12__hot_cold_t: if (OptimizeExistingHotColdNew) return emitHotColdNewNoThrow( CI->getArgOperand(0), CI->getArgOperand(1), B, TLI, - LibFunc_ZnamRKSt9nothrow_t12__hot_cold_t, HotCold); + LibFunc_ZnamRKSt9nothrow_t12__hot_cold_t, HotCold, + CI->getType()->getPointerAddressSpace()); break; case LibFunc_ZnamRKSt9nothrow_t: if (HotCold != NotColdNewHintValue) return emitHotColdNewNoThrow( CI->getArgOperand(0), CI->getArgOperand(1), B, TLI, - LibFunc_ZnamRKSt9nothrow_t12__hot_cold_t, HotCold); + LibFunc_ZnamRKSt9nothrow_t12__hot_cold_t, HotCold, + CI->getType()->getPointerAddressSpace()); break; case LibFunc_ZnwmSt11align_val_t12__hot_cold_t: if (OptimizeExistingHotColdNew) return emitHotColdNewAligned( CI->getArgOperand(0), CI->getArgOperand(1), B, TLI, - LibFunc_ZnwmSt11align_val_t12__hot_cold_t, HotCold); + LibFunc_ZnwmSt11align_val_t12__hot_cold_t, HotCold, + CI->getType()->getPointerAddressSpace()); break; case LibFunc_ZnwmSt11align_val_t: if (HotCold != NotColdNewHintValue) return emitHotColdNewAligned( CI->getArgOperand(0), CI->getArgOperand(1), B, TLI, - LibFunc_ZnwmSt11align_val_t12__hot_cold_t, HotCold); + LibFunc_ZnwmSt11align_val_t12__hot_cold_t, HotCold, + CI->getType()->getPointerAddressSpace()); break; case LibFunc_ZnamSt11align_val_t12__hot_cold_t: if (OptimizeExistingHotColdNew) return emitHotColdNewAligned( CI->getArgOperand(0), CI->getArgOperand(1), B, TLI, - LibFunc_ZnamSt11align_val_t12__hot_cold_t, HotCold); + LibFunc_ZnamSt11align_val_t12__hot_cold_t, HotCold, + CI->getType()->getPointerAddressSpace()); break; case LibFunc_ZnamSt11align_val_t: if (HotCold != NotColdNewHintValue) return emitHotColdNewAligned( CI->getArgOperand(0), CI->getArgOperand(1), B, TLI, - LibFunc_ZnamSt11align_val_t12__hot_cold_t, HotCold); + LibFunc_ZnamSt11align_val_t12__hot_cold_t, HotCold, + CI->getType()->getPointerAddressSpace()); break; case LibFunc_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t: if (OptimizeExistingHotColdNew) return emitHotColdNewAlignedNoThrow( CI->getArgOperand(0), CI->getArgOperand(1), CI->getArgOperand(2), B, - TLI, LibFunc_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t, - HotCold); + TLI, LibFunc_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t, HotCold, + CI->getType()->getPointerAddressSpace()); break; case LibFunc_ZnwmSt11align_val_tRKSt9nothrow_t: if (HotCold != NotColdNewHintValue) return emitHotColdNewAlignedNoThrow( CI->getArgOperand(0), CI->getArgOperand(1), CI->getArgOperand(2), B, - TLI, LibFunc_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t, - HotCold); + TLI, LibFunc_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t, HotCold, + CI->getType()->getPointerAddressSpace()); break; case LibFunc_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t: if (OptimizeExistingHotColdNew) return emitHotColdNewAlignedNoThrow( CI->getArgOperand(0), CI->getArgOperand(1), CI->getArgOperand(2), B, - TLI, LibFunc_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t, - HotCold); + TLI, LibFunc_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t, HotCold, + CI->getType()->getPointerAddressSpace()); break; case LibFunc_ZnamSt11align_val_tRKSt9nothrow_t: if (HotCold != NotColdNewHintValue) return emitHotColdNewAlignedNoThrow( CI->getArgOperand(0), CI->getArgOperand(1), CI->getArgOperand(2), B, - TLI, LibFunc_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t, - HotCold); + TLI, LibFunc_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t, HotCold, + CI->getType()->getPointerAddressSpace()); break; case LibFunc_size_returning_new: if (HotCold != NotColdNewHintValue) - return emitHotColdSizeReturningNew(CI->getArgOperand(0), B, TLI, - LibFunc_size_returning_new_hot_cold, - HotCold); + return emitHotColdSizeReturningNew( + CI->getArgOperand(0), B, TLI, LibFunc_size_returning_new_hot_cold, + HotCold, + CI->getType()->getStructElementType(0)->getPointerAddressSpace()); break; case LibFunc_size_returning_new_hot_cold: if (OptimizeExistingHotColdNew) - return emitHotColdSizeReturningNew(CI->getArgOperand(0), B, TLI, - LibFunc_size_returning_new_hot_cold, - HotCold); + return emitHotColdSizeReturningNew( + CI->getArgOperand(0), B, TLI, LibFunc_size_returning_new_hot_cold, + HotCold, + CI->getType()->getStructElementType(0)->getPointerAddressSpace()); break; case LibFunc_size_returning_new_aligned: if (HotCold != NotColdNewHintValue) return emitHotColdSizeReturningNewAligned( CI->getArgOperand(0), CI->getArgOperand(1), B, TLI, - LibFunc_size_returning_new_aligned_hot_cold, HotCold); + LibFunc_size_returning_new_aligned_hot_cold, HotCold, + CI->getType()->getStructElementType(0)->getPointerAddressSpace()); break; case LibFunc_size_returning_new_aligned_hot_cold: if (OptimizeExistingHotColdNew) return emitHotColdSizeReturningNewAligned( CI->getArgOperand(0), CI->getArgOperand(1), B, TLI, - LibFunc_size_returning_new_aligned_hot_cold, HotCold); + LibFunc_size_returning_new_aligned_hot_cold, HotCold, + CI->getType()->getStructElementType(0)->getPointerAddressSpace()); break; default: return nullptr; @@ -3345,7 +3365,8 @@ Value *LibCallSimplifier::optimizePrintFString(CallInst *CI, IRBuilderBase &B) { // printf("%s", str"\n") --> puts(str) if (OperandStr.back() == '\n') { OperandStr = OperandStr.drop_back(); - Value *GV = B.CreateGlobalString(OperandStr, "str"); + Value *GV = B.CreateGlobalString(OperandStr, "str", + DL.getDefaultGlobalsAddressSpace()); return copyFlags(*CI, emitPutS(GV, B, TLI)); } return nullptr; @@ -3357,7 +3378,8 @@ Value *LibCallSimplifier::optimizePrintFString(CallInst *CI, IRBuilderBase &B) { // Create a string literal with no \n on it. We expect the constant merge // pass to be run after this pass, to merge duplicate strings. FormatStr = FormatStr.drop_back(); - Value *GV = B.CreateGlobalString(FormatStr, "str"); + Value *GV = B.CreateGlobalString(FormatStr, "str", + DL.getDefaultGlobalsAddressSpace()); return copyFlags(*CI, emitPutS(GV, B, TLI)); } diff --git a/llvm/test/Transforms/InstCombine/printf-addrspace.ll b/llvm/test/Transforms/InstCombine/printf-addrspace.ll new file mode 100644 index 0000000000000..1ce25bc0ad84d --- /dev/null +++ b/llvm/test/Transforms/InstCombine/printf-addrspace.ll @@ -0,0 +1,42 @@ +; NOTE: Assertions have been autogenerated by utils/update_test_checks.py +; Test that the printf library call simplifier works correctly. +; +; RUN: opt < %s -passes=instcombine -S | FileCheck %s + +target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128-G200" + +@hello_world = addrspace(200) constant [13 x i8] c"hello world\0A\00" +@h = addrspace(200) constant [2 x i8] c"h\00" +@h2 = addrspace(200) constant [3 x i8] c"%%\00" +@percent = addrspace(200) constant [2 x i8] c"%\00" +@percent_c = addrspace(200) constant [3 x i8] c"%c\00" +@percent_d = addrspace(200) constant [3 x i8] c"%d\00" +@percent_f = addrspace(200) constant [3 x i8] c"%f\00" +@percent_s = addrspace(200) constant [4 x i8] c"%s\0A\00" +@empty = addrspace(200) constant [1 x i8] c"\00" + +declare i32 @printf(ptr addrspace(200) , ...) +declare i32 @puts(ptr addrspace(200)) + +; Check printf("foo\n") -> puts("foo"). + +define void @test_simplify1() { +; CHECK-LABEL: @test_simplify1( +; CHECK-NEXT: [[PUTS:%.*]] = call i32 @puts(ptr addrspace(200) @str) +; CHECK-NEXT: ret void +; + call i32 (ptr addrspace(200) , ...) @printf(ptr addrspace(200) @hello_world) + ret void +} + + +; Check printf("%s\n", str) -> puts(str). + +define void @test_simplify2() { +; CHECK-LABEL: @test_simplify2( +; CHECK-NEXT: [[PUTS:%.*]] = call i32 @puts(ptr addrspace(200) @hello_world) +; CHECK-NEXT: ret void +; + call i32 (ptr addrspace(200) , ...) @printf(ptr addrspace(200) @percent_s, ptr addrspace(200) @hello_world) + ret void +} From c38738c5e676c9cf59338037b6c84500d1349ea4 Mon Sep 17 00:00:00 2001 From: Owen Anderson Date: Thu, 5 Dec 2024 22:38:28 +1300 Subject: [PATCH 2/4] Replace explicit address space arguments with Type* --- .../llvm/Transforms/Utils/BuildLibCalls.h | 43 ++++--- .../Scalar/DeadStoreElimination.cpp | 5 +- llvm/lib/Transforms/Utils/BuildLibCalls.cpp | 74 ++++++------ .../lib/Transforms/Utils/SimplifyLibCalls.cpp | 110 ++++++++---------- 4 files changed, 105 insertions(+), 127 deletions(-) diff --git a/llvm/include/llvm/Transforms/Utils/BuildLibCalls.h b/llvm/include/llvm/Transforms/Utils/BuildLibCalls.h index 3766c755baf4f..0508f92dfd2ff 100644 --- a/llvm/include/llvm/Transforms/Utils/BuildLibCalls.h +++ b/llvm/include/llvm/Transforms/Utils/BuildLibCalls.h @@ -246,37 +246,34 @@ namespace llvm { const DataLayout &DL, const TargetLibraryInfo *TLI); /// Emit a call to the malloc function. - Value *emitMalloc(Value *Num, IRBuilderBase &B, const DataLayout &DL, - const TargetLibraryInfo *TLI, unsigned AddrSpace); + Value *emitMalloc(Type *RetTy, Value *Num, IRBuilderBase &B, + const DataLayout &DL, const TargetLibraryInfo *TLI); /// Emit a call to the calloc function. - Value *emitCalloc(Value *Num, Value *Size, IRBuilderBase &B, - const TargetLibraryInfo &TLI, unsigned AddrSpace); + Value *emitCalloc(Type *RetTy, Value *Num, Value *Size, IRBuilderBase &B, + const TargetLibraryInfo &TLI); /// Emit a call to the hot/cold operator new function. - Value *emitHotColdNew(Value *Num, IRBuilderBase &B, + Value *emitHotColdNew(Type *RetTy, Value *Num, IRBuilderBase &B, const TargetLibraryInfo *TLI, LibFunc NewFunc, - uint8_t HotCold, unsigned AddrSpace); - Value *emitHotColdNewNoThrow(Value *Num, Value *NoThrow, IRBuilderBase &B, - const TargetLibraryInfo *TLI, LibFunc NewFunc, - uint8_t HotCold, unsigned AddrSpace); - Value *emitHotColdNewAligned(Value *Num, Value *Align, IRBuilderBase &B, - const TargetLibraryInfo *TLI, LibFunc NewFunc, - uint8_t HotCold, unsigned AddrSpace); - Value *emitHotColdNewAlignedNoThrow(Value *Num, Value *Align, Value *NoThrow, - IRBuilderBase &B, + uint8_t HotCold); + Value *emitHotColdNewNoThrow(Type *RetTy, Value *Num, Value *NoThrow, + IRBuilderBase &B, const TargetLibraryInfo *TLI, + LibFunc NewFunc, uint8_t HotCold); + Value *emitHotColdNewAligned(Type *RetTy, Value *Num, Value *Align, + IRBuilderBase &B, const TargetLibraryInfo *TLI, + LibFunc NewFunc, uint8_t HotCold); + Value *emitHotColdNewAlignedNoThrow(Type *RetTy, Value *Num, Value *Align, + Value *NoThrow, IRBuilderBase &B, const TargetLibraryInfo *TLI, - LibFunc NewFunc, uint8_t HotCold, - unsigned AddrSpace); - Value *emitHotColdSizeReturningNew(Value *Num, IRBuilderBase &B, + LibFunc NewFunc, uint8_t HotCold); + Value *emitHotColdSizeReturningNew(Type *RetTy, Value *Num, IRBuilderBase &B, const TargetLibraryInfo *TLI, - LibFunc NewFunc, uint8_t HotCold, - unsigned AddrSpace); - Value *emitHotColdSizeReturningNewAligned(Value *Num, Value *Align, - IRBuilderBase &B, + LibFunc NewFunc, uint8_t HotCold); + Value *emitHotColdSizeReturningNewAligned(Type *RetTy, Value *Num, + Value *Align, IRBuilderBase &B, const TargetLibraryInfo *TLI, - LibFunc NewFunc, uint8_t HotCold, - unsigned AddrSpace); + LibFunc NewFunc, uint8_t HotCold); } #endif diff --git a/llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp b/llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp index 5555b5e29cc74..09e8301b772d9 100644 --- a/llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp +++ b/llvm/lib/Transforms/Scalar/DeadStoreElimination.cpp @@ -2014,9 +2014,8 @@ struct DSEState { return false; IRBuilder<> IRB(Malloc); Type *SizeTTy = Malloc->getArgOperand(0)->getType(); - auto *Calloc = - emitCalloc(ConstantInt::get(SizeTTy, 1), Malloc->getArgOperand(0), IRB, - TLI, Malloc->getType()->getPointerAddressSpace()); + auto *Calloc = emitCalloc(Malloc->getType(), ConstantInt::get(SizeTTy, 1), + Malloc->getArgOperand(0), IRB, TLI); if (!Calloc) return false; diff --git a/llvm/lib/Transforms/Utils/BuildLibCalls.cpp b/llvm/lib/Transforms/Utils/BuildLibCalls.cpp index c7aec524eedfd..b6a06f88b2e82 100644 --- a/llvm/lib/Transforms/Utils/BuildLibCalls.cpp +++ b/llvm/lib/Transforms/Utils/BuildLibCalls.cpp @@ -2003,16 +2003,16 @@ Value *llvm::emitFWrite(Value *Ptr, Value *Size, Value *File, IRBuilderBase &B, return CI; } -Value *llvm::emitMalloc(Value *Num, IRBuilderBase &B, const DataLayout &DL, - const TargetLibraryInfo *TLI, unsigned AddrSpace) { +Value *llvm::emitMalloc(Type *RetTy, Value *Num, IRBuilderBase &B, + const DataLayout &DL, const TargetLibraryInfo *TLI) { Module *M = B.GetInsertBlock()->getModule(); if (!isLibFuncEmittable(M, TLI, LibFunc_malloc)) return nullptr; StringRef MallocName = TLI->getName(LibFunc_malloc); Type *SizeTTy = getSizeTTy(B, TLI); - FunctionCallee Malloc = getOrInsertLibFunc(M, *TLI, LibFunc_malloc, - B.getPtrTy(AddrSpace), SizeTTy); + FunctionCallee Malloc = + getOrInsertLibFunc(M, *TLI, LibFunc_malloc, RetTy, SizeTTy); inferNonMandatoryLibFuncAttrs(M, MallocName, *TLI); CallInst *CI = B.CreateCall(Malloc, Num, MallocName); @@ -2023,16 +2023,16 @@ Value *llvm::emitMalloc(Value *Num, IRBuilderBase &B, const DataLayout &DL, return CI; } -Value *llvm::emitCalloc(Value *Num, Value *Size, IRBuilderBase &B, - const TargetLibraryInfo &TLI, unsigned AddrSpace) { +Value *llvm::emitCalloc(Type *RetTy, Value *Num, Value *Size, IRBuilderBase &B, + const TargetLibraryInfo &TLI) { Module *M = B.GetInsertBlock()->getModule(); if (!isLibFuncEmittable(M, &TLI, LibFunc_calloc)) return nullptr; StringRef CallocName = TLI.getName(LibFunc_calloc); Type *SizeTTy = getSizeTTy(B, &TLI); - FunctionCallee Calloc = getOrInsertLibFunc( - M, TLI, LibFunc_calloc, B.getPtrTy(AddrSpace), SizeTTy, SizeTTy); + FunctionCallee Calloc = + getOrInsertLibFunc(M, TLI, LibFunc_calloc, RetTy, SizeTTy, SizeTTy); inferNonMandatoryLibFuncAttrs(M, CallocName, TLI); CallInst *CI = B.CreateCall(Calloc, {Num, Size}, CallocName); @@ -2043,10 +2043,11 @@ Value *llvm::emitCalloc(Value *Num, Value *Size, IRBuilderBase &B, return CI; } -Value *llvm::emitHotColdSizeReturningNew(Value *Num, IRBuilderBase &B, +Value *llvm::emitHotColdSizeReturningNew(Type *RetTy, Value *Num, + IRBuilderBase &B, const TargetLibraryInfo *TLI, LibFunc SizeFeedbackNewFunc, - uint8_t HotCold, unsigned AddrSpace) { + uint8_t HotCold) { Module *M = B.GetInsertBlock()->getModule(); if (!isLibFuncEmittable(M, TLI, SizeFeedbackNewFunc)) return nullptr; @@ -2055,7 +2056,7 @@ Value *llvm::emitHotColdSizeReturningNew(Value *Num, IRBuilderBase &B, // __sized_ptr_t struct return type { void*, size_t } StructType *SizedPtrT = - StructType::get(M->getContext(), {B.getPtrTy(AddrSpace), Num->getType()}); + StructType::get(M->getContext(), {RetTy, Num->getType()}); FunctionCallee Func = M->getOrInsertFunction(Name, SizedPtrT, Num->getType(), B.getInt8Ty()); inferNonMandatoryLibFuncAttrs(M, Name, *TLI); @@ -2067,9 +2068,11 @@ Value *llvm::emitHotColdSizeReturningNew(Value *Num, IRBuilderBase &B, return CI; } -Value *llvm::emitHotColdSizeReturningNewAligned( - Value *Num, Value *Align, IRBuilderBase &B, const TargetLibraryInfo *TLI, - LibFunc SizeFeedbackNewFunc, uint8_t HotCold, unsigned AddrSpace) { +Value *llvm::emitHotColdSizeReturningNewAligned(Type *RetTy, Value *Num, + Value *Align, IRBuilderBase &B, + const TargetLibraryInfo *TLI, + LibFunc SizeFeedbackNewFunc, + uint8_t HotCold) { Module *M = B.GetInsertBlock()->getModule(); if (!isLibFuncEmittable(M, TLI, SizeFeedbackNewFunc)) return nullptr; @@ -2078,7 +2081,7 @@ Value *llvm::emitHotColdSizeReturningNewAligned( // __sized_ptr_t struct return type { void*, size_t } StructType *SizedPtrT = - StructType::get(M->getContext(), {B.getPtrTy(AddrSpace), Num->getType()}); + StructType::get(M->getContext(), {RetTy, Num->getType()}); FunctionCallee Func = M->getOrInsertFunction(Name, SizedPtrT, Num->getType(), Align->getType(), B.getInt8Ty()); inferNonMandatoryLibFuncAttrs(M, Name, *TLI); @@ -2091,16 +2094,16 @@ Value *llvm::emitHotColdSizeReturningNewAligned( return CI; } -Value *llvm::emitHotColdNew(Value *Num, IRBuilderBase &B, +Value *llvm::emitHotColdNew(Type *RetTy, Value *Num, IRBuilderBase &B, const TargetLibraryInfo *TLI, LibFunc NewFunc, - uint8_t HotCold, unsigned AddrSpace) { + uint8_t HotCold) { Module *M = B.GetInsertBlock()->getModule(); if (!isLibFuncEmittable(M, TLI, NewFunc)) return nullptr; StringRef Name = TLI->getName(NewFunc); - FunctionCallee Func = M->getOrInsertFunction(Name, B.getPtrTy(AddrSpace), - Num->getType(), B.getInt8Ty()); + FunctionCallee Func = + M->getOrInsertFunction(Name, RetTy, Num->getType(), B.getInt8Ty()); inferNonMandatoryLibFuncAttrs(M, Name, *TLI); CallInst *CI = B.CreateCall(Func, {Num, B.getInt8(HotCold)}, Name); @@ -2111,18 +2114,17 @@ Value *llvm::emitHotColdNew(Value *Num, IRBuilderBase &B, return CI; } -Value *llvm::emitHotColdNewNoThrow(Value *Num, Value *NoThrow, IRBuilderBase &B, +Value *llvm::emitHotColdNewNoThrow(Type *RetTy, Value *Num, Value *NoThrow, + IRBuilderBase &B, const TargetLibraryInfo *TLI, - LibFunc NewFunc, uint8_t HotCold, - unsigned AddrSpace) { + LibFunc NewFunc, uint8_t HotCold) { Module *M = B.GetInsertBlock()->getModule(); if (!isLibFuncEmittable(M, TLI, NewFunc)) return nullptr; StringRef Name = TLI->getName(NewFunc); - FunctionCallee Func = - M->getOrInsertFunction(Name, B.getPtrTy(AddrSpace), Num->getType(), - NoThrow->getType(), B.getInt8Ty()); + FunctionCallee Func = M->getOrInsertFunction( + Name, RetTy, Num->getType(), NoThrow->getType(), B.getInt8Ty()); inferNonMandatoryLibFuncAttrs(M, Name, *TLI); CallInst *CI = B.CreateCall(Func, {Num, NoThrow, B.getInt8(HotCold)}, Name); @@ -2133,18 +2135,17 @@ Value *llvm::emitHotColdNewNoThrow(Value *Num, Value *NoThrow, IRBuilderBase &B, return CI; } -Value *llvm::emitHotColdNewAligned(Value *Num, Value *Align, IRBuilderBase &B, +Value *llvm::emitHotColdNewAligned(Type *RetTy, Value *Num, Value *Align, + IRBuilderBase &B, const TargetLibraryInfo *TLI, - LibFunc NewFunc, uint8_t HotCold, - unsigned AddrSpace) { + LibFunc NewFunc, uint8_t HotCold) { Module *M = B.GetInsertBlock()->getModule(); if (!isLibFuncEmittable(M, TLI, NewFunc)) return nullptr; StringRef Name = TLI->getName(NewFunc); - FunctionCallee Func = - M->getOrInsertFunction(Name, B.getPtrTy(AddrSpace), Num->getType(), - Align->getType(), B.getInt8Ty()); + FunctionCallee Func = M->getOrInsertFunction(Name, RetTy, Num->getType(), + Align->getType(), B.getInt8Ty()); inferNonMandatoryLibFuncAttrs(M, Name, *TLI); CallInst *CI = B.CreateCall(Func, {Num, Align, B.getInt8(HotCold)}, Name); @@ -2155,19 +2156,18 @@ Value *llvm::emitHotColdNewAligned(Value *Num, Value *Align, IRBuilderBase &B, return CI; } -Value *llvm::emitHotColdNewAlignedNoThrow(Value *Num, Value *Align, +Value *llvm::emitHotColdNewAlignedNoThrow(Type *RetTy, Value *Num, Value *Align, Value *NoThrow, IRBuilderBase &B, const TargetLibraryInfo *TLI, - LibFunc NewFunc, uint8_t HotCold, - unsigned AddrSpace) { + LibFunc NewFunc, uint8_t HotCold) { Module *M = B.GetInsertBlock()->getModule(); if (!isLibFuncEmittable(M, TLI, NewFunc)) return nullptr; StringRef Name = TLI->getName(NewFunc); - FunctionCallee Func = M->getOrInsertFunction( - Name, B.getPtrTy(AddrSpace), Num->getType(), Align->getType(), - NoThrow->getType(), B.getInt8Ty()); + FunctionCallee Func = + M->getOrInsertFunction(Name, RetTy, Num->getType(), Align->getType(), + NoThrow->getType(), B.getInt8Ty()); inferNonMandatoryLibFuncAttrs(M, Name, *TLI); CallInst *CI = B.CreateCall(Func, {Num, Align, NoThrow, B.getInt8(HotCold)}, Name); diff --git a/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp b/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp index b5d6c74b439ac..65e6fa49dc6bd 100644 --- a/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp +++ b/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp @@ -1724,10 +1724,8 @@ Value *LibCallSimplifier::optimizeMemSet(CallInst *CI, IRBuilderBase &B) { Value *LibCallSimplifier::optimizeRealloc(CallInst *CI, IRBuilderBase &B) { if (isa(CI->getArgOperand(0))) - return copyFlags( - *CI, - emitMalloc(CI->getArgOperand(1), B, DL, TLI, - CI->getArgOperand(0)->getType()->getPointerAddressSpace())); + return copyFlags(*CI, emitMalloc(CI->getArgOperand(0)->getType(), + CI->getArgOperand(1), B, DL, TLI)); return nullptr; } @@ -1762,139 +1760,123 @@ Value *LibCallSimplifier::optimizeNew(CallInst *CI, IRBuilderBase &B, switch (Func) { case LibFunc_Znwm12__hot_cold_t: if (OptimizeExistingHotColdNew) - return emitHotColdNew(CI->getArgOperand(0), B, TLI, - LibFunc_Znwm12__hot_cold_t, HotCold, - CI->getType()->getPointerAddressSpace()); + return emitHotColdNew(CI->getType(), CI->getArgOperand(0), B, TLI, + LibFunc_Znwm12__hot_cold_t, HotCold); break; case LibFunc_Znwm: if (HotCold != NotColdNewHintValue) - return emitHotColdNew(CI->getArgOperand(0), B, TLI, - LibFunc_Znwm12__hot_cold_t, HotCold, - CI->getType()->getPointerAddressSpace()); + return emitHotColdNew(CI->getType(), CI->getArgOperand(0), B, TLI, + LibFunc_Znwm12__hot_cold_t, HotCold); break; case LibFunc_Znam12__hot_cold_t: if (OptimizeExistingHotColdNew) - return emitHotColdNew(CI->getArgOperand(0), B, TLI, - LibFunc_Znam12__hot_cold_t, HotCold, - CI->getType()->getPointerAddressSpace()); + return emitHotColdNew(CI->getType(), CI->getArgOperand(0), B, TLI, + LibFunc_Znam12__hot_cold_t, HotCold); break; case LibFunc_Znam: if (HotCold != NotColdNewHintValue) - return emitHotColdNew(CI->getArgOperand(0), B, TLI, - LibFunc_Znam12__hot_cold_t, HotCold, - CI->getType()->getPointerAddressSpace()); + return emitHotColdNew(CI->getType(), CI->getArgOperand(0), B, TLI, + LibFunc_Znam12__hot_cold_t, HotCold); break; case LibFunc_ZnwmRKSt9nothrow_t12__hot_cold_t: if (OptimizeExistingHotColdNew) return emitHotColdNewNoThrow( - CI->getArgOperand(0), CI->getArgOperand(1), B, TLI, - LibFunc_ZnwmRKSt9nothrow_t12__hot_cold_t, HotCold, - CI->getType()->getPointerAddressSpace()); + CI->getType(), CI->getArgOperand(0), CI->getArgOperand(1), B, TLI, + LibFunc_ZnwmRKSt9nothrow_t12__hot_cold_t, HotCold); break; case LibFunc_ZnwmRKSt9nothrow_t: if (HotCold != NotColdNewHintValue) return emitHotColdNewNoThrow( - CI->getArgOperand(0), CI->getArgOperand(1), B, TLI, - LibFunc_ZnwmRKSt9nothrow_t12__hot_cold_t, HotCold, - CI->getType()->getPointerAddressSpace()); + CI->getType(), CI->getArgOperand(0), CI->getArgOperand(1), B, TLI, + LibFunc_ZnwmRKSt9nothrow_t12__hot_cold_t, HotCold); break; case LibFunc_ZnamRKSt9nothrow_t12__hot_cold_t: if (OptimizeExistingHotColdNew) return emitHotColdNewNoThrow( - CI->getArgOperand(0), CI->getArgOperand(1), B, TLI, - LibFunc_ZnamRKSt9nothrow_t12__hot_cold_t, HotCold, - CI->getType()->getPointerAddressSpace()); + CI->getType(), CI->getArgOperand(0), CI->getArgOperand(1), B, TLI, + LibFunc_ZnamRKSt9nothrow_t12__hot_cold_t, HotCold); break; case LibFunc_ZnamRKSt9nothrow_t: if (HotCold != NotColdNewHintValue) return emitHotColdNewNoThrow( - CI->getArgOperand(0), CI->getArgOperand(1), B, TLI, - LibFunc_ZnamRKSt9nothrow_t12__hot_cold_t, HotCold, - CI->getType()->getPointerAddressSpace()); + CI->getType(), CI->getArgOperand(0), CI->getArgOperand(1), B, TLI, + LibFunc_ZnamRKSt9nothrow_t12__hot_cold_t, HotCold); break; case LibFunc_ZnwmSt11align_val_t12__hot_cold_t: if (OptimizeExistingHotColdNew) return emitHotColdNewAligned( - CI->getArgOperand(0), CI->getArgOperand(1), B, TLI, - LibFunc_ZnwmSt11align_val_t12__hot_cold_t, HotCold, - CI->getType()->getPointerAddressSpace()); + CI->getType(), CI->getArgOperand(0), CI->getArgOperand(1), B, TLI, + LibFunc_ZnwmSt11align_val_t12__hot_cold_t, HotCold); break; case LibFunc_ZnwmSt11align_val_t: if (HotCold != NotColdNewHintValue) return emitHotColdNewAligned( - CI->getArgOperand(0), CI->getArgOperand(1), B, TLI, - LibFunc_ZnwmSt11align_val_t12__hot_cold_t, HotCold, - CI->getType()->getPointerAddressSpace()); + CI->getType(), CI->getArgOperand(0), CI->getArgOperand(1), B, TLI, + LibFunc_ZnwmSt11align_val_t12__hot_cold_t, HotCold); break; case LibFunc_ZnamSt11align_val_t12__hot_cold_t: if (OptimizeExistingHotColdNew) return emitHotColdNewAligned( - CI->getArgOperand(0), CI->getArgOperand(1), B, TLI, - LibFunc_ZnamSt11align_val_t12__hot_cold_t, HotCold, - CI->getType()->getPointerAddressSpace()); + CI->getType(), CI->getArgOperand(0), CI->getArgOperand(1), B, TLI, + LibFunc_ZnamSt11align_val_t12__hot_cold_t, HotCold); break; case LibFunc_ZnamSt11align_val_t: if (HotCold != NotColdNewHintValue) return emitHotColdNewAligned( - CI->getArgOperand(0), CI->getArgOperand(1), B, TLI, - LibFunc_ZnamSt11align_val_t12__hot_cold_t, HotCold, - CI->getType()->getPointerAddressSpace()); + CI->getType(), CI->getArgOperand(0), CI->getArgOperand(1), B, TLI, + LibFunc_ZnamSt11align_val_t12__hot_cold_t, HotCold); break; case LibFunc_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t: if (OptimizeExistingHotColdNew) return emitHotColdNewAlignedNoThrow( - CI->getArgOperand(0), CI->getArgOperand(1), CI->getArgOperand(2), B, - TLI, LibFunc_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t, HotCold, - CI->getType()->getPointerAddressSpace()); + CI->getType(), CI->getArgOperand(0), CI->getArgOperand(1), + CI->getArgOperand(2), B, TLI, + LibFunc_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t, HotCold); break; case LibFunc_ZnwmSt11align_val_tRKSt9nothrow_t: if (HotCold != NotColdNewHintValue) return emitHotColdNewAlignedNoThrow( - CI->getArgOperand(0), CI->getArgOperand(1), CI->getArgOperand(2), B, - TLI, LibFunc_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t, HotCold, - CI->getType()->getPointerAddressSpace()); + CI->getType(), CI->getArgOperand(0), CI->getArgOperand(1), + CI->getArgOperand(2), B, TLI, + LibFunc_ZnwmSt11align_val_tRKSt9nothrow_t12__hot_cold_t, HotCold); break; case LibFunc_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t: if (OptimizeExistingHotColdNew) return emitHotColdNewAlignedNoThrow( - CI->getArgOperand(0), CI->getArgOperand(1), CI->getArgOperand(2), B, - TLI, LibFunc_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t, HotCold, - CI->getType()->getPointerAddressSpace()); + CI->getType(), CI->getArgOperand(0), CI->getArgOperand(1), + CI->getArgOperand(2), B, TLI, + LibFunc_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t, HotCold); break; case LibFunc_ZnamSt11align_val_tRKSt9nothrow_t: if (HotCold != NotColdNewHintValue) return emitHotColdNewAlignedNoThrow( - CI->getArgOperand(0), CI->getArgOperand(1), CI->getArgOperand(2), B, - TLI, LibFunc_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t, HotCold, - CI->getType()->getPointerAddressSpace()); + CI->getType(), CI->getArgOperand(0), CI->getArgOperand(1), + CI->getArgOperand(2), B, TLI, + LibFunc_ZnamSt11align_val_tRKSt9nothrow_t12__hot_cold_t, HotCold); break; case LibFunc_size_returning_new: if (HotCold != NotColdNewHintValue) return emitHotColdSizeReturningNew( - CI->getArgOperand(0), B, TLI, LibFunc_size_returning_new_hot_cold, - HotCold, - CI->getType()->getStructElementType(0)->getPointerAddressSpace()); + CI->getType(), CI->getArgOperand(0), B, TLI, + LibFunc_size_returning_new_hot_cold, HotCold); break; case LibFunc_size_returning_new_hot_cold: if (OptimizeExistingHotColdNew) return emitHotColdSizeReturningNew( - CI->getArgOperand(0), B, TLI, LibFunc_size_returning_new_hot_cold, - HotCold, - CI->getType()->getStructElementType(0)->getPointerAddressSpace()); + CI->getType(), CI->getArgOperand(0), B, TLI, + LibFunc_size_returning_new_hot_cold, HotCold); break; case LibFunc_size_returning_new_aligned: if (HotCold != NotColdNewHintValue) return emitHotColdSizeReturningNewAligned( - CI->getArgOperand(0), CI->getArgOperand(1), B, TLI, - LibFunc_size_returning_new_aligned_hot_cold, HotCold, - CI->getType()->getStructElementType(0)->getPointerAddressSpace()); + CI->getType(), CI->getArgOperand(0), CI->getArgOperand(1), B, TLI, + LibFunc_size_returning_new_aligned_hot_cold, HotCold); break; case LibFunc_size_returning_new_aligned_hot_cold: if (OptimizeExistingHotColdNew) return emitHotColdSizeReturningNewAligned( - CI->getArgOperand(0), CI->getArgOperand(1), B, TLI, - LibFunc_size_returning_new_aligned_hot_cold, HotCold, - CI->getType()->getStructElementType(0)->getPointerAddressSpace()); + CI->getType(), CI->getArgOperand(0), CI->getArgOperand(1), B, TLI, + LibFunc_size_returning_new_aligned_hot_cold, HotCold); break; default: return nullptr; From 458f1ddd3688d77069c35bfddca88c8e1a5f7eb9 Mon Sep 17 00:00:00 2001 From: Owen Anderson Date: Thu, 5 Dec 2024 23:22:27 +1300 Subject: [PATCH 3/4] Fix assertion failure --- llvm/lib/Transforms/Utils/BuildLibCalls.cpp | 8 ++++---- llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp | 10 ++++++---- 2 files changed, 10 insertions(+), 8 deletions(-) diff --git a/llvm/lib/Transforms/Utils/BuildLibCalls.cpp b/llvm/lib/Transforms/Utils/BuildLibCalls.cpp index b6a06f88b2e82..287538179af8f 100644 --- a/llvm/lib/Transforms/Utils/BuildLibCalls.cpp +++ b/llvm/lib/Transforms/Utils/BuildLibCalls.cpp @@ -2043,7 +2043,7 @@ Value *llvm::emitCalloc(Type *RetTy, Value *Num, Value *Size, IRBuilderBase &B, return CI; } -Value *llvm::emitHotColdSizeReturningNew(Type *RetTy, Value *Num, +Value *llvm::emitHotColdSizeReturningNew(Type *RetPtrTy, Value *Num, IRBuilderBase &B, const TargetLibraryInfo *TLI, LibFunc SizeFeedbackNewFunc, @@ -2056,7 +2056,7 @@ Value *llvm::emitHotColdSizeReturningNew(Type *RetTy, Value *Num, // __sized_ptr_t struct return type { void*, size_t } StructType *SizedPtrT = - StructType::get(M->getContext(), {RetTy, Num->getType()}); + StructType::get(M->getContext(), {RetPtrTy, Num->getType()}); FunctionCallee Func = M->getOrInsertFunction(Name, SizedPtrT, Num->getType(), B.getInt8Ty()); inferNonMandatoryLibFuncAttrs(M, Name, *TLI); @@ -2068,7 +2068,7 @@ Value *llvm::emitHotColdSizeReturningNew(Type *RetTy, Value *Num, return CI; } -Value *llvm::emitHotColdSizeReturningNewAligned(Type *RetTy, Value *Num, +Value *llvm::emitHotColdSizeReturningNewAligned(Type *RetPtrTy, Value *Num, Value *Align, IRBuilderBase &B, const TargetLibraryInfo *TLI, LibFunc SizeFeedbackNewFunc, @@ -2081,7 +2081,7 @@ Value *llvm::emitHotColdSizeReturningNewAligned(Type *RetTy, Value *Num, // __sized_ptr_t struct return type { void*, size_t } StructType *SizedPtrT = - StructType::get(M->getContext(), {RetTy, Num->getType()}); + StructType::get(M->getContext(), {RetPtrTy, Num->getType()}); FunctionCallee Func = M->getOrInsertFunction(Name, SizedPtrT, Num->getType(), Align->getType(), B.getInt8Ty()); inferNonMandatoryLibFuncAttrs(M, Name, *TLI); diff --git a/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp b/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp index 65e6fa49dc6bd..0438ccf36aeaf 100644 --- a/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp +++ b/llvm/lib/Transforms/Utils/SimplifyLibCalls.cpp @@ -1857,25 +1857,27 @@ Value *LibCallSimplifier::optimizeNew(CallInst *CI, IRBuilderBase &B, case LibFunc_size_returning_new: if (HotCold != NotColdNewHintValue) return emitHotColdSizeReturningNew( - CI->getType(), CI->getArgOperand(0), B, TLI, + CI->getType()->getStructElementType(0), CI->getArgOperand(0), B, TLI, LibFunc_size_returning_new_hot_cold, HotCold); break; case LibFunc_size_returning_new_hot_cold: if (OptimizeExistingHotColdNew) return emitHotColdSizeReturningNew( - CI->getType(), CI->getArgOperand(0), B, TLI, + CI->getType()->getStructElementType(0), CI->getArgOperand(0), B, TLI, LibFunc_size_returning_new_hot_cold, HotCold); break; case LibFunc_size_returning_new_aligned: if (HotCold != NotColdNewHintValue) return emitHotColdSizeReturningNewAligned( - CI->getType(), CI->getArgOperand(0), CI->getArgOperand(1), B, TLI, + CI->getType()->getStructElementType(0), CI->getArgOperand(0), + CI->getArgOperand(1), B, TLI, LibFunc_size_returning_new_aligned_hot_cold, HotCold); break; case LibFunc_size_returning_new_aligned_hot_cold: if (OptimizeExistingHotColdNew) return emitHotColdSizeReturningNewAligned( - CI->getType(), CI->getArgOperand(0), CI->getArgOperand(1), B, TLI, + CI->getType()->getStructElementType(0), CI->getArgOperand(0), + CI->getArgOperand(1), B, TLI, LibFunc_size_returning_new_aligned_hot_cold, HotCold); break; default: From 606ccc997a76e5a09092a2866917323482e69a30 Mon Sep 17 00:00:00 2001 From: Owen Anderson Date: Fri, 6 Dec 2024 10:33:07 +1300 Subject: [PATCH 4/4] Prune unneeded globals from test --- llvm/test/Transforms/InstCombine/printf-addrspace.ll | 7 ------- 1 file changed, 7 deletions(-) diff --git a/llvm/test/Transforms/InstCombine/printf-addrspace.ll b/llvm/test/Transforms/InstCombine/printf-addrspace.ll index 1ce25bc0ad84d..3cb28ce3460bf 100644 --- a/llvm/test/Transforms/InstCombine/printf-addrspace.ll +++ b/llvm/test/Transforms/InstCombine/printf-addrspace.ll @@ -6,14 +6,7 @@ target datalayout = "e-p:32:32:32-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-f32:32:32-f64:32:64-v64:64:64-v128:128:128-a0:0:64-f80:128:128-G200" @hello_world = addrspace(200) constant [13 x i8] c"hello world\0A\00" -@h = addrspace(200) constant [2 x i8] c"h\00" -@h2 = addrspace(200) constant [3 x i8] c"%%\00" -@percent = addrspace(200) constant [2 x i8] c"%\00" -@percent_c = addrspace(200) constant [3 x i8] c"%c\00" -@percent_d = addrspace(200) constant [3 x i8] c"%d\00" -@percent_f = addrspace(200) constant [3 x i8] c"%f\00" @percent_s = addrspace(200) constant [4 x i8] c"%s\0A\00" -@empty = addrspace(200) constant [1 x i8] c"\00" declare i32 @printf(ptr addrspace(200) , ...) declare i32 @puts(ptr addrspace(200))