RPCS3/archived-llvm
1
0
Fork 0
mirror of https://github.com/RPCS3/llvm.git synced 2026-01-31 01:25:19 +01:00
Code Issues Packages Projects Releases Wiki Activity

[Alignment][NFC] Convert LoadInst to MaybeAlign

Browse Source 
Summary:
This is patch is part of a series to introduce an Alignment type.
See this thread for context: http://lists.llvm.org/pipermail/llvm-dev/2019-July/133851.html
See this patch for the introduction of the type: https://reviews.llvm.org/D64790

Reviewers: courbet

Subscribers: hiraditya, jfb, llvm-commits

Tags: #llvm

Differential Revision: https://reviews.llvm.org/D69302

git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@375498 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Guillaume Chatelet
2019-10-22 12:35:55 +00:00
parent 4a0e8977ca
commit 8b6d26ec66
10 changed files with 37 additions and 38 deletions
Download Patch File Download Diff File Expand all files Collapse all files

16
include/llvm/IR/Instructions.h
View File

@@ -184,15 +184,15 @@ public:
LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
BasicBlock *InsertAtEnd);
LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
unsigned Align, Instruction *InsertBefore = nullptr);
MaybeAlign Align, Instruction *InsertBefore = nullptr);
LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
unsigned Align, BasicBlock *InsertAtEnd);
MaybeAlign Align, BasicBlock *InsertAtEnd);
LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
unsigned Align, AtomicOrdering Order,
MaybeAlign Align, AtomicOrdering Order,
SyncScope::ID SSID = SyncScope::System,
Instruction *InsertBefore = nullptr);
LoadInst(Type *Ty, Value *Ptr, const Twine &NameStr, bool isVolatile,
unsigned Align, AtomicOrdering Order, SyncScope::ID SSID,
MaybeAlign Align, AtomicOrdering Order, SyncScope::ID SSID,
BasicBlock *InsertAtEnd);
// Deprecated [opaque pointer types]
@@ -211,20 +211,20 @@ public:
BasicBlock *InsertAtEnd)
: LoadInst(Ptr->getType()->getPointerElementType(), Ptr, NameStr,
isVolatile, InsertAtEnd) {}
LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile, unsigned Align,
LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile, MaybeAlign Align,
Instruction *InsertBefore = nullptr)
: LoadInst(Ptr->getType()->getPointerElementType(), Ptr, NameStr,
isVolatile, Align, InsertBefore) {}
LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile, unsigned Align,
LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile, MaybeAlign Align,
BasicBlock *InsertAtEnd)
: LoadInst(Ptr->getType()->getPointerElementType(), Ptr, NameStr,
isVolatile, Align, InsertAtEnd) {}
LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile, unsigned Align,
LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile, MaybeAlign Align,
AtomicOrdering Order, SyncScope::ID SSID = SyncScope::System,
Instruction *InsertBefore = nullptr)
: LoadInst(Ptr->getType()->getPointerElementType(), Ptr, NameStr,
isVolatile, Align, Order, SSID, InsertBefore) {}
LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile, unsigned Align,
LoadInst(Value *Ptr, const Twine &NameStr, bool isVolatile, MaybeAlign Align,
AtomicOrdering Order, SyncScope::ID SSID, BasicBlock *InsertAtEnd)
: LoadInst(Ptr->getType()->getPointerElementType(), Ptr, NameStr,
isVolatile, Align, Order, SSID, InsertAtEnd) {}

3
lib/AsmParser/LLParser.cpp
View File

@@ -6969,8 +6969,7 @@ int LLParser::ParseLoad(Instruction *&Inst, PerFunctionState &PFS) {
return Error(ExplicitTypeLoc,
"explicit pointee type doesn't match operand's pointee type");
Inst = new LoadInst(Ty, Val, "", isVolatile,
Alignment ? Alignment->value() : 0, Ordering, SSID);
Inst = new LoadInst(Ty, Val, "", isVolatile, Alignment, Ordering, SSID);
return AteExtraComma ? InstExtraComma : InstNormal;
}

6
lib/Bitcode/Reader/BitcodeReader.cpp
View File

@@ -4792,8 +4792,7 @@ Error BitcodeReader::parseFunctionBody(Function *F) {
MaybeAlign Align;
if (Error Err = parseAlignmentValue(Record[OpNum], Align))
return Err;
I = new LoadInst(Ty, Op, "", Record[OpNum + 1],
Align ? Align->value() : 0);
I = new LoadInst(Ty, Op, "", Record[OpNum + 1], Align);
InstructionList.push_back(I);
break;
}
@@ -4830,8 +4829,7 @@ Error BitcodeReader::parseFunctionBody(Function *F) {
MaybeAlign Align;
if (Error Err = parseAlignmentValue(Record[OpNum], Align))
return Err;
I = new LoadInst(Ty, Op, "", Record[OpNum + 1],
Align ? Align->value() : 0, Ordering, SSID);
I = new LoadInst(Ty, Op, "", Record[OpNum + 1], Align, Ordering, SSID);
InstructionList.push_back(I);
break;
}

19
lib/IR/Instructions.cpp
View File

@@ -1296,25 +1296,25 @@ LoadInst::LoadInst(Type *Ty, Value *Ptr, const Twine &Name,
LoadInst::LoadInst(Type *Ty, Value *Ptr, const Twine &Name, bool isVolatile,
Instruction *InsertBef)
: LoadInst(Ty, Ptr, Name, isVolatile, /*Align=*/0, InsertBef) {}
: LoadInst(Ty, Ptr, Name, isVolatile, /*Align=*/None, InsertBef) {}
LoadInst::LoadInst(Type *Ty, Value *Ptr, const Twine &Name, bool isVolatile,
BasicBlock *InsertAE)
: LoadInst(Ty, Ptr, Name, isVolatile, /*Align=*/0, InsertAE) {}
: LoadInst(Ty, Ptr, Name, isVolatile, /*Align=*/None, InsertAE) {}
LoadInst::LoadInst(Type *Ty, Value *Ptr, const Twine &Name, bool isVolatile,
unsigned Align, Instruction *InsertBef)
MaybeAlign Align, Instruction *InsertBef)
: LoadInst(Ty, Ptr, Name, isVolatile, Align, AtomicOrdering::NotAtomic,
SyncScope::System, InsertBef) {}
LoadInst::LoadInst(Type *Ty, Value *Ptr, const Twine &Name, bool isVolatile,
unsigned Align, BasicBlock *InsertAE)
MaybeAlign Align, BasicBlock *InsertAE)
: LoadInst(Ty, Ptr, Name, isVolatile, Align, AtomicOrdering::NotAtomic,
SyncScope::System, InsertAE) {}
LoadInst::LoadInst(Type *Ty, Value *Ptr, const Twine &Name, bool isVolatile,
unsigned Align, AtomicOrdering Order,
SyncScope::ID SSID, Instruction *InsertBef)
MaybeAlign Align, AtomicOrdering Order, SyncScope::ID SSID,
Instruction *InsertBef)
: UnaryInstruction(Ty, Load, Ptr, InsertBef) {
assert(Ty == cast<PointerType>(Ptr->getType())->getElementType());
setVolatile(isVolatile);
@@ -1325,12 +1325,12 @@ LoadInst::LoadInst(Type *Ty, Value *Ptr, const Twine &Name, bool isVolatile,
}
LoadInst::LoadInst(Type *Ty, Value *Ptr, const Twine &Name, bool isVolatile,
unsigned Align, AtomicOrdering Order, SyncScope::ID SSID,
MaybeAlign Align, AtomicOrdering Order, SyncScope::ID SSID,
BasicBlock *InsertAE)
: UnaryInstruction(Ty, Load, Ptr, InsertAE) {
assert(Ty == cast<PointerType>(Ptr->getType())->getElementType());
setVolatile(isVolatile);
setAlignment(MaybeAlign(Align));
setAlignment(Align);
setAtomic(Order, SSID);
AssertOK();
setName(Name);
@@ -4140,7 +4140,8 @@ AllocaInst *AllocaInst::cloneImpl() const {
LoadInst *LoadInst::cloneImpl() const {
return new LoadInst(getType(), getOperand(0), Twine(), isVolatile(),
getAlignment(), getOrdering(), getSyncScopeID());
MaybeAlign(getAlignment()), getOrdering(),
getSyncScopeID());
}
StoreInst *StoreInst::cloneImpl() const {

10
lib/Transforms/IPO/GlobalOpt.cpp
View File

@@ -909,7 +909,7 @@ OptimizeGlobalAddressOfMalloc(GlobalVariable *GV, CallInst *CI, Type *AllocTy,
// Replace the cmp X, 0 with a use of the bool value.
// Sink the load to where the compare was, if atomic rules allow us to.
Value *LV = new LoadInst(InitBool->getValueType(), InitBool,
InitBool->getName() + ".val", false, 0,
InitBool->getName() + ".val", false, None,
LI->getOrdering(), LI->getSyncScopeID(),
LI->isUnordered() ? (Instruction *)ICI : LI);
InitBoolUsed = true;
@@ -1716,7 +1716,7 @@ static bool TryToShrinkGlobalToBoolean(GlobalVariable *GV, Constant *OtherVal) {
assert(LI->getOperand(0) == GV && "Not a copy!");
// Insert a new load, to preserve the saved value.
StoreVal = new LoadInst(NewGV->getValueType(), NewGV,
LI->getName() + ".b", false, 0,
LI->getName() + ".b", false, None,
LI->getOrdering(), LI->getSyncScopeID(), LI);
} else {
assert((isa<CastInst>(StoredVal) || isa<SelectInst>(StoredVal)) &&
@@ -1732,9 +1732,9 @@ static bool TryToShrinkGlobalToBoolean(GlobalVariable *GV, Constant *OtherVal) {
} else {
// Change the load into a load of bool then a select.
LoadInst *LI = cast<LoadInst>(UI);
LoadInst *NLI =
new LoadInst(NewGV->getValueType(), NewGV, LI->getName() + ".b",
false, 0, LI->getOrdering(), LI->getSyncScopeID(), LI);
LoadInst *NLI = new LoadInst(NewGV->getValueType(), NewGV,
LI->getName() + ".b", false, None,
LI->getOrdering(), LI->getSyncScopeID(), LI);
Instruction *NSI;
if (IsOneZero)
NSI = new ZExtInst(NLI, LI->getType(), "", LI);

2
lib/Transforms/InstCombine/InstCombineCalls.cpp
View File

@@ -2342,7 +2342,7 @@ Instruction *InstCombiner::visitCallInst(CallInst &CI) {
// Turn PPC VSX loads into normal loads.
Value *Ptr = Builder.CreateBitCast(II->getArgOperand(0),
PointerType::getUnqual(II->getType()));
return new LoadInst(II->getType(), Ptr, Twine(""), false, 1);
return new LoadInst(II->getType(), Ptr, Twine(""), false, Align::None());
}
case Intrinsic::ppc_altivec_stvx:
case Intrinsic::ppc_altivec_stvxl:

6
lib/Transforms/InstCombine/InstCombinePHI.cpp
View File

@@ -542,7 +542,7 @@ Instruction *InstCombiner::FoldPHIArgLoadIntoPHI(PHINode &PN) {
// visitLoadInst will propagate an alignment onto the load when TD is around,
// and if TD isn't around, we can't handle the mixed case.
bool isVolatile = FirstLI->isVolatile();
unsigned LoadAlignment = FirstLI->getAlignment();
MaybeAlign LoadAlignment(FirstLI->getAlignment());
unsigned LoadAddrSpace = FirstLI->getPointerAddressSpace();
// We can't sink the load if the loaded value could be modified between the
@@ -574,10 +574,10 @@ Instruction *InstCombiner::FoldPHIArgLoadIntoPHI(PHINode &PN) {
// If some of the loads have an alignment specified but not all of them,
// we can't do the transformation.
if ((LoadAlignment != 0) != (LI->getAlignment() != 0))
if ((LoadAlignment.hasValue()) != (LI->getAlignment() != 0))
return nullptr;
LoadAlignment = std::min(LoadAlignment, LI->getAlignment());
LoadAlignment = std::min(LoadAlignment, MaybeAlign(LI->getAlignment()));
// If the PHI is of volatile loads and the load block has multiple
// successors, sinking it would remove a load of the volatile value from

8
lib/Transforms/Scalar/GVN.cpp
View File

@@ -1241,10 +1241,10 @@ bool GVN::PerformLoadPRE(LoadInst *LI, AvailValInBlkVect &ValuesPerBlock,
BasicBlock *UnavailablePred = PredLoad.first;
Value *LoadPtr = PredLoad.second;
auto *NewLoad =
new LoadInst(LI->getType(), LoadPtr, LI->getName() + ".pre",
LI->isVolatile(), LI->getAlignment(), LI->getOrdering(),
LI->getSyncScopeID(), UnavailablePred->getTerminator());
auto *NewLoad = new LoadInst(
LI->getType(), LoadPtr, LI->getName() + ".pre", LI->isVolatile(),
MaybeAlign(LI->getAlignment()), LI->getOrdering(), LI->getSyncScopeID(),
UnavailablePred->getTerminator());
NewLoad->setDebugLoc(LI->getDebugLoc());
// Transfer the old load's AA tags to the new load.

2
lib/Transforms/Scalar/JumpThreading.cpp
View File

@@ -1471,7 +1471,7 @@ bool JumpThreadingPass::SimplifyPartiallyRedundantLoad(LoadInst *LoadI) {
"Can't handle critical edge here!");
LoadInst *NewVal = new LoadInst(
LoadI->getType(), LoadedPtr->DoPHITranslation(LoadBB, UnavailablePred),
LoadI->getName() + ".pr", false, LoadI->getAlignment(),
LoadI->getName() + ".pr", false, MaybeAlign(LoadI->getAlignment()),
LoadI->getOrdering(), LoadI->getSyncScopeID(),
UnavailablePred->getTerminator());
NewVal->setDebugLoc(LoadI->getDebugLoc());

3
lib/Transforms/Scalar/LoopLoadElimination.cpp
View File

@@ -435,7 +435,8 @@ public:
PH->getTerminator());
Value *Initial = new LoadInst(
Cand.Load->getType(), InitialPtr, "load_initial",
/* isVolatile */ false, Cand.Load->getAlignment(), PH->getTerminator());
/* isVolatile */ false, MaybeAlign(Cand.Load->getAlignment()),
PH->getTerminator());
PHINode *PHI = PHINode::Create(Initial->getType(), 2, "store_forwarded",
&L->getHeader()->front());