RPCS3/llvm
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm.git synced 2024-12-28 15:33:16 +00:00
Code Issues Actions Packages Projects Releases Wiki Activity

switch the inliner alignment enforcement stuff to use the

Browse Source 
getOrEnforceKnownAlignment function, which simplifies the code
and makes it stronger.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@122555 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Chris Lattner 2010-12-25 20:42:38 +00:00
parent 687140c818
commit 7569d79de1
1 changed files with 8 additions and 27 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

35
lib/Transforms/Utils/InlineFunction.cpp
View File

@ -24,6 +24,7 @@
#include "llvm/Analysis/DebugInfo.h"
#include "llvm/Analysis/InstructionSimplify.h"
#include "llvm/Target/TargetData.h"
#include "llvm/Transforms/Utils/Local.h"
#include "llvm/ADT/SmallVector.h"
#include "llvm/ADT/StringExtras.h"
#include "llvm/Support/CallSite.h"
@ -247,34 +248,14 @@ static Value *HandleByValArgument(Value *Arg, Instruction *TheCall,
if (ByValAlignment <= 1) // 0 = unspecified, 1 = no particular alignment.
return Arg;
// See if the argument is a (bitcasted) pointer to an alloca. If so, we can
// round up the alloca if needed.
if (AllocaInst *AI = dyn_cast<AllocaInst>(Arg->stripPointerCasts())) {
unsigned AIAlign = AI->getAlignment();
// If the alloca is known at least aligned as much as the byval, we can do
// this optimization.
if (AIAlign >= ByValAlignment)
return Arg;
// If the alloca has a specified alignment that is less than the byval,
// then we can safely bump it up.
if (AIAlign) {
AI->setAlignment(ByValAlignment);
return Arg;
}
// If the alignment has an unspecified alignment, then we can only modify
// it if we have TD information. Doing so without TD info could end up
// with us rounding the alignment *down* accidentally, which is badness.
if (IFI.TD) {
AIAlign = std::max(ByValAlignment, IFI.TD->getPrefTypeAlignment(AggTy));
AI->setAlignment(AIAlign);
return Arg;
}
}
// If the pointer is already known to be sufficiently aligned, or if we can
// round it up to a larger alignment, then we don't need a temporary.
if (getOrEnforceKnownAlignment(Arg, ByValAlignment,
IFI.TD) >= ByValAlignment)
return Arg;
// Otherwise, we have to make a memcpy to get a safe alignment, pretty lame.
// Otherwise, we have to make a memcpy to get a safe alignment. This is bad
// for code quality, but rarely happens and is required for correctness.
}
LLVMContext &Context = Arg->getContext();