6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-11-01 00:11:00 +00:00
Code Issues Projects Releases Wiki Activity

Taken into account Duncan's comments for r149481 dated by 2nd Feb 2012:

Browse Source 
http://lists.cs.uiuc.edu/pipermail/llvm-commits/Week-of-Mon-20120130/136146.html

Implemented CaseIterator and it solves almost all described issues: we don't need to mix operand/case/successor indexing anymore. Base iterator class is implemented as a template since it may be initialized either from "const SwitchInst*" or from "SwitchInst*".

ConstCaseIt is just a read-only iterator.
CaseIt is read-write iterator; it allows to change case successor and case value.

Usage of iterator allows totally remove resolveXXXX methods. All indexing convertions done automatically inside the iterator's getters.

Main way of iterator usage looks like this:
SwitchInst *SI = ... // intialize it somehow

for (SwitchInst::CaseIt i = SI->caseBegin(), e = SI->caseEnd(); i != e; ++i) {
  BasicBlock *BB = i.getCaseSuccessor();
  ConstantInt *V = i.getCaseValue();
  // Do something.
}

If you want to convert case number to TerminatorInst successor index, just use getSuccessorIndex iterator's method.
If you want initialize iterator from TerminatorInst successor index, use CaseIt::fromSuccessorIndex(...) method.

There are also related changes in llvm-clients: klee and clang.



git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@152297 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Stepan Dyatkovskiy 2012-03-08 07:06:20 +00:00
parent 88d2fa438a
commit c10fa6c801
25 changed files with 302 additions and 211 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
include/llvm/Analysis/CFGPrinter.h
View File

@ -95,8 +95,9 @@ struct DOTGraphTraits<const Function*> : public DefaultDOTGraphTraits {
std::string Str;
raw_string_ostream OS(Str);
unsigned Case = SI->resolveCaseIndex(SuccNo);
OS << SI->getCaseValue(Case)->getValue();
SwitchInst::ConstCaseIt Case =
SwitchInst::ConstCaseIt::fromSuccessorIndex(SI, SuccNo);
OS << Case.getCaseValue()->getValue();
return OS.str();
}
return "";

235
include/llvm/Instructions.h
View File

@ -24,7 +24,6 @@
#include "llvm/ADT/SmallVector.h"
#include "llvm/Support/ErrorHandling.h"
#include <iterator>
#include <limits.h>
namespace llvm {
@ -2468,8 +2467,119 @@ class SwitchInst : public TerminatorInst {
protected:
virtual SwitchInst *clone_impl() const;
public:
static const unsigned DefaultPseudoIndex = ~0L-1; // -2
template <class SwitchInstTy, class ConstantIntTy, class BasicBlockTy>
class CaseIteratorT {
protected:
SwitchInstTy *SI;
unsigned Index;
public:
typedef CaseIteratorT<SwitchInstTy, ConstantIntTy, BasicBlockTy> Self;
/// Initializes case iterator for given SwitchInst and for given
/// case number.
CaseIteratorT(SwitchInstTy *SI, unsigned CaseNum) {
this->SI = SI;
Index = CaseNum;
}
/// Initializes case iterator for given SwitchInst and for given
/// TerminatorInst's successor index.
static Self fromSuccessorIndex(SwitchInstTy *SI, unsigned SuccessorIndex) {
assert(SuccessorIndex < SI->getNumSuccessors() &&
"Successor index # out of range!");
return SuccessorIndex != 0 ?
Self(SI, SuccessorIndex - 1) :
Self(SI, DefaultPseudoIndex);
}
/// Resolves case value for current case.
ConstantIntTy *getCaseValue() {
assert(Index < SI->getNumCases() && "Index out the number of cases.");
return reinterpret_cast<ConstantIntTy*>(SI->getOperand(2 + Index*2));
}
/// Resolves successor for current case.
BasicBlockTy *getCaseSuccessor() {
assert((Index < SI->getNumCases() || DefaultPseudoIndex) &&
"Index out the number of cases.");
return SI->getSuccessor(getSuccessorIndex());
}
/// Returns number of current case.
unsigned getCaseIndex() const { return Index; }
/// Returns TerminatorInst's successor index for current case successor.
unsigned getSuccessorIndex() const {
assert((Index == DefaultPseudoIndex || Index < SI->getNumCases()) &&
"Index out the number of cases.");
return Index != DefaultPseudoIndex ? Index + 1 : 0;
}
Self operator++() {
// Check index correctness after increment.
// Note: Index == getNumCases() means end().
assert(Index+1 <= SI->getNumCases() && "Index out the number of cases.");
++Index;
return *this;
}
Self operator++(int) {
Self tmp = *this;
++(*this);
return tmp;
}
Self operator--() {
// Check index correctness after decrement.
// Note: Index == getNumCases() means end().
// Also allow "-1" iterator here. That will became valid after ++.
assert((Index == 0 || Index-1 <= SI->getNumCases()) &&
"Index out the number of cases.");
--Index;
return *this;
}
Self operator--(int) {
Self tmp = *this;
--(*this);
return tmp;
}
bool operator==(const Self& RHS) const {
assert(RHS.SI == SI && "Incompatible operators.");
return RHS.Index == Index;
}
bool operator!=(const Self& RHS) const {
assert(RHS.SI == SI && "Incompatible operators.");
return RHS.Index != Index;
}
};
typedef CaseIteratorT<const SwitchInst, const ConstantInt, const BasicBlock>
ConstCaseIt;
enum { ErrorIndex = UINT_MAX };
class CaseIt : public CaseIteratorT<SwitchInst, ConstantInt, BasicBlock> {
typedef CaseIteratorT<SwitchInst, ConstantInt, BasicBlock> ParentTy;
public:
CaseIt(const ParentTy& Src) : ParentTy(Src) {}
CaseIt(SwitchInst *SI, unsigned CaseNum) : ParentTy(SI, CaseNum) {}
/// Sets the new value for current case.
void setValue(ConstantInt *V) {
assert(Index < SI->getNumCases() && "Index out the number of cases.");
SI->setOperand(2 + Index*2, reinterpret_cast<Value*>(V));
}
/// Sets the new successor for current case.
void setSuccessor(BasicBlock *S) {
SI->setSuccessor(getSuccessorIndex(), S);
}
};
static SwitchInst *Create(Value *Value, BasicBlock *Default,
unsigned NumCases, Instruction *InsertBefore = 0) {
@ -2479,6 +2589,7 @@ public:
unsigned NumCases, BasicBlock *InsertAtEnd) {
return new SwitchInst(Value, Default, NumCases, InsertAtEnd);
}
~SwitchInst();
/// Provide fast operand accessors
@ -2502,64 +2613,64 @@ public:
return getNumOperands()/2 - 1;
}
/// getCaseValue - Return the specified case value. Note that case #0, means
/// first case, not a default case.
ConstantInt *getCaseValue(unsigned i) {
assert(i < getNumCases() && "Illegal case value to get!");
return reinterpret_cast<ConstantInt*>(getOperand(2 + i*2));
/// Returns a read/write iterator that points to the first
/// case in SwitchInst.
CaseIt caseBegin() {
return CaseIt(this, 0);
}
/// getCaseValue - Return the specified case value. Note that case #0, means
/// first case, not a default case.
const ConstantInt *getCaseValue(unsigned i) const {
assert(i < getNumCases() && "Illegal case value to get!");
return reinterpret_cast<const ConstantInt*>(getOperand(2 + i*2));
/// Returns a read-only iterator that points to the first
/// case in the SwitchInst.
ConstCaseIt caseBegin() const {
return ConstCaseIt(this, 0);
}
// setSuccessorValue - Updates the value associated with the specified
// case.
void setCaseValue(unsigned i, ConstantInt *CaseValue) {
assert(i < getNumCases() && "Case index # out of range!");
setOperand(2 + i*2, reinterpret_cast<Value*>(CaseValue));
/// Returns a read/write iterator that points one past the last
/// in the SwitchInst.
CaseIt caseEnd() {
return CaseIt(this, getNumCases());
}
/// Returns a read-only iterator that points one past the last
/// in the SwitchInst.
ConstCaseIt caseEnd() const {
return ConstCaseIt(this, getNumCases());
}
/// Returns an iterator that points to default case.
/// Note: this iterator allows to resolve successor only. Attempt
/// to resolve case value causes an assertion.
CaseIt caseDefault() {
return CaseIt(this, DefaultPseudoIndex);
}
ConstCaseIt caseDefault() const {
return ConstCaseIt(this, DefaultPseudoIndex);
}
/// findCaseValue - Search all of the case values for the specified constant.
/// If it is explicitly handled, return the case number of it, otherwise
/// return ErrorIndex to indicate that it is handled by the default handler.
unsigned findCaseValue(const ConstantInt *C) const {
for (unsigned i = 0, e = getNumCases(); i != e; ++i)
if (getCaseValue(i) == C)
/// If it is explicitly handled, return the case iterator of it, otherwise
/// return default case iterator to indicate
/// that it is handled by the default handler.
CaseIt findCaseValue(const ConstantInt *C) {
for (CaseIt i = caseBegin(), e = caseEnd(); i != e; ++i)
if (i.getCaseValue() == C)
return i;
return ErrorIndex;
return caseDefault();
}
ConstCaseIt findCaseValue(const ConstantInt *C) const {
for (ConstCaseIt i = caseBegin(), e = caseEnd(); i != e; ++i)
if (i.getCaseValue() == C)
return i;
return caseDefault();
}
/// resolveSuccessorIndex - Converts case index to index of its successor
/// index in TerminatorInst successors collection.
/// If CaseIndex == ErrorIndex, "default" successor will returned then.
unsigned resolveSuccessorIndex(unsigned CaseIndex) const {
assert((CaseIndex == ErrorIndex || CaseIndex < getNumCases()) &&
"Case index # out of range!");
return CaseIndex != ErrorIndex ? CaseIndex + 1 : 0;
}
/// resolveCaseIndex - Converts index of successor in TerminatorInst
/// collection to index of case that corresponds to this successor.
unsigned resolveCaseIndex(unsigned SuccessorIndex) const {
assert(SuccessorIndex < getNumSuccessors() &&
"Successor index # out of range!");
return SuccessorIndex != 0 ? SuccessorIndex - 1 : ErrorIndex;
}
/// findCaseDest - Finds the unique case value for a given successor. Returns
/// null if the successor is not found, not unique, or is the default case.
ConstantInt *findCaseDest(BasicBlock *BB) {
if (BB == getDefaultDest()) return NULL;
ConstantInt *CI = NULL;
for (unsigned i = 0, e = getNumCases(); i != e; ++i) {
if (getSuccessor(i + 1) == BB) {
for (CaseIt i = caseBegin(), e = caseEnd(); i != e; ++i) {
if (i.getCaseSuccessor() == BB) {
if (CI) return NULL; // Multiple cases lead to BB.
else CI = getCaseValue(i);
else CI = i.getCaseValue();
}
}
return CI;
@ -2573,7 +2684,7 @@ public:
/// from the switch instruction. Note that this operation may reorder the
/// remaining cases at index idx and above.
///
void removeCase(unsigned idx);
void removeCase(CaseIt i);
unsigned getNumSuccessors() const { return getNumOperands()/2; }
BasicBlock *getSuccessor(unsigned idx) const {
@ -2585,36 +2696,6 @@ public:
setOperand(idx*2+1, (Value*)NewSucc);
}
/// Resolves successor for idx-th case.
/// Use getCaseSuccessor instead of TerminatorInst::getSuccessor,
/// since internal SwitchInst organization of operands/successors is
/// hidden and may be changed in any moment.
BasicBlock *getCaseSuccessor(unsigned idx) const {
return getSuccessor(resolveSuccessorIndex(idx));
}
/// Set new successor for idx-th case.
/// Use setCaseSuccessor instead of TerminatorInst::setSuccessor,
/// since internal SwitchInst organization of operands/successors is
/// hidden and may be changed in any moment.
void setCaseSuccessor(unsigned idx, BasicBlock *NewSucc) {
setSuccessor(resolveSuccessorIndex(idx), NewSucc);
}
// getSuccessorValue - Return the value associated with the specified
// successor.
ConstantInt *getSuccessorValue(unsigned idx) const {
assert(idx < getNumSuccessors() && "Successor # out of range!");
return reinterpret_cast<ConstantInt*>(getOperand(idx*2));
}
// setSuccessorValue - Updates the value associated with the specified
// successor.
void setSuccessorValue(unsigned idx, ConstantInt* SuccessorValue) {
assert(idx < getNumSuccessors() && "Successor # out of range!");
setOperand(idx*2, reinterpret_cast<Value*>(SuccessorValue));
}
// Methods for support type inquiry through isa, cast, and dyn_cast:
static inline bool classof(const SwitchInst *) { return true; }
static inline bool classof(const Instruction *I) {

7
lib/Analysis/LazyValueInfo.cpp
View File

@ -866,10 +866,11 @@ bool LazyValueInfoCache::getEdgeValue(Value *Val, BasicBlock *BBFrom,
// BBFrom to BBTo.
unsigned NumEdges = 0;
ConstantInt *EdgeVal = 0;
for (unsigned i = 0, e = SI->getNumCases(); i != e; ++i) {
if (SI->getCaseSuccessor(i) != BBTo) continue;
for (SwitchInst::CaseIt i = SI->caseBegin(), e = SI->caseEnd();
i != e; ++i) {
if (i.getCaseSuccessor() != BBTo) continue;
if (NumEdges++) break;
EdgeVal = SI->getCaseValue(i);
EdgeVal = i.getCaseValue();
}
assert(EdgeVal && "Missing successor?");
if (NumEdges == 1) {

5
lib/Analysis/SparsePropagation.cpp
View File

@ -194,9 +194,8 @@ void SparseSolver::getFeasibleSuccessors(TerminatorInst &TI,
Succs.assign(TI.getNumSuccessors(), true);
return;
}
unsigned CCase = SI.findCaseValue(cast<ConstantInt>(C));
Succs[SI.resolveSuccessorIndex(CCase)] = true;
SwitchInst::CaseIt Case = SI.findCaseValue(cast<ConstantInt>(C));
Succs[Case.getSuccessorIndex()] = true;
}

7
lib/Bitcode/Writer/BitcodeWriter.cpp
View File

@ -1142,9 +1142,10 @@ static void WriteInstruction(const Instruction &I, unsigned InstID,
Vals.push_back(VE.getTypeID(SI.getCondition()->getType()));
Vals.push_back(VE.getValueID(SI.getCondition()));
Vals.push_back(VE.getValueID(SI.getDefaultDest()));
for (unsigned i = 0, e = SI.getNumCases(); i != e; ++i) {
Vals.push_back(VE.getValueID(SI.getCaseValue(i)));
Vals.push_back(VE.getValueID(SI.getCaseSuccessor(i)));
for (SwitchInst::CaseIt i = SI.caseBegin(), e = SI.caseEnd();
i != e; ++i) {
Vals.push_back(VE.getValueID(i.getCaseValue()));
Vals.push_back(VE.getValueID(i.getCaseSuccessor()));
}
}
break;

8
lib/CodeGen/SelectionDAG/SelectionDAGBuilder.cpp
View File

@ -2411,14 +2411,14 @@ size_t SelectionDAGBuilder::Clusterify(CaseVector& Cases,
BranchProbabilityInfo *BPI = FuncInfo.BPI;
// Start with "simple" cases
for (size_t i = 0; i < SI.getNumCases(); ++i) {
BasicBlock *SuccBB = SI.getCaseSuccessor(i);
for (SwitchInst::ConstCaseIt i = SI.caseBegin(), e = SI.caseEnd();
i != e; ++i) {
const BasicBlock *SuccBB = i.getCaseSuccessor();
MachineBasicBlock *SMBB = FuncInfo.MBBMap[SuccBB];
uint32_t ExtraWeight = BPI ? BPI->getEdgeWeight(SI.getParent(), SuccBB) : 0;
Cases.push_back(Case(SI.getCaseValue(i),
SI.getCaseValue(i),
Cases.push_back(Case(i.getCaseValue(), i.getCaseValue(),
SMBB, ExtraWeight));
}
std::sort(Cases.begin(), Cases.end(), CaseCmp());

8
lib/ExecutionEngine/Interpreter/Execution.cpp
View File

@ -650,12 +650,10 @@ void Interpreter::visitSwitchInst(SwitchInst &I) {
// Check to see if any of the cases match...
BasicBlock *Dest = 0;
unsigned NumCases = I.getNumCases();
// Skip the first item since that's the default case.
for (unsigned i = 0; i < NumCases; ++i) {
GenericValue CaseVal = getOperandValue(I.getCaseValue(i), SF);
for (SwitchInst::CaseIt i = I.caseBegin(), e = I.caseEnd(); i != e; ++i) {
GenericValue CaseVal = getOperandValue(i.getCaseValue(), SF);
if (executeICMP_EQ(CondVal, CaseVal, ElTy).IntVal != 0) {
Dest = cast<BasicBlock>(I.getCaseSuccessor(i));
Dest = cast<BasicBlock>(i.getCaseSuccessor());
break;
}
}

10
lib/Target/CBackend/CBackend.cpp
View File

@ -2392,17 +2392,17 @@ void CWriter::visitSwitchInst(SwitchInst &SI) {
printBranchToBlock(SI.getParent(), SI.getDefaultDest(), 2);
Out << ";\n";
unsigned NumCases = SI.getNumCases();
// Skip the first item since that's the default case.
for (unsigned i = 0; i < NumCases; ++i) {
ConstantInt* CaseVal = SI.getCaseValue(i);
BasicBlock* Succ = SI.getCaseSuccessor(i);
for (SwitchInst::CaseIt i = SI.caseBegin(), e = SI.caseEnd(); i != e; ++i) {
ConstantInt* CaseVal = i.getCaseValue();
BasicBlock* Succ = i.getCaseSuccessor();
Out << " case ";
writeOperand(CaseVal);
Out << ":\n";
printPHICopiesForSuccessor (SI.getParent(), Succ, 2);
printBranchToBlock(SI.getParent(), Succ, 2);
if (Function::iterator(Succ) == llvm::next(Function::iterator(SI.getParent())))
if (Function::iterator(Succ) ==
llvm::next(Function::iterator(SI.getParent())))
Out << " break;\n";
}

8
lib/Target/CppBackend/CPPBackend.cpp
View File

@ -1090,10 +1090,10 @@ void CppWriter::printInstruction(const Instruction *I,
<< getOpName(SI->getDefaultDest()) << ", "
<< SI->getNumCases() << ", " << bbname << ");";
nl(Out);
unsigned NumCases = SI->getNumCases();
for (unsigned i = 0; i < NumCases; ++i) {
const ConstantInt* CaseVal = SI->getCaseValue(i);
const BasicBlock *BB = SI->getCaseSuccessor(i);
for (SwitchInst::ConstCaseIt i = SI->caseBegin(), e = SI->caseEnd();
i != e; ++i) {
const ConstantInt* CaseVal = i.getCaseValue();
const BasicBlock *BB = i.getCaseSuccessor();
Out << iName << "->addCase("
<< getOpName(CaseVal) << ", "
<< getOpName(BB) << ");";

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

@ -2582,8 +2582,7 @@ bool Evaluator::EvaluateBlock(BasicBlock::iterator CurInst,
ConstantInt *Val =
dyn_cast<ConstantInt>(getVal(SI->getCondition()));
if (!Val) return false; // Cannot determine.
unsigned ValTISucc = SI->resolveSuccessorIndex(SI->findCaseValue(Val));
NextBB = SI->getSuccessor(ValTISucc);
NextBB = SI->findCaseValue(Val).getCaseSuccessor();
} else if (IndirectBrInst *IBI = dyn_cast<IndirectBrInst>(CurInst)) {
Value *Val = getVal(IBI->getAddress())->stripPointerCasts();
if (BlockAddress *BA = dyn_cast<BlockAddress>(Val))

15
lib/Transforms/InstCombine/InstructionCombining.cpp
View File

@ -1245,15 +1245,15 @@ Instruction *InstCombiner::visitSwitchInst(SwitchInst &SI) {
if (I->getOpcode() == Instruction::Add)
if (ConstantInt *AddRHS = dyn_cast<ConstantInt>(I->getOperand(1))) {
// change 'switch (X+4) case 1:' into 'switch (X) case -3'
unsigned NumCases = SI.getNumCases();
// Skip the first item since that's the default case.
for (unsigned i = 0; i < NumCases; ++i) {
ConstantInt* CaseVal = SI.getCaseValue(i);
for (SwitchInst::CaseIt i = SI.caseBegin(), e = SI.caseEnd();
i != e; ++i) {
ConstantInt* CaseVal = i.getCaseValue();
Constant* NewCaseVal = ConstantExpr::getSub(cast<Constant>(CaseVal),
AddRHS);
assert(isa<ConstantInt>(NewCaseVal) &&
"Result of expression should be constant");
SI.setCaseValue(i, cast<ConstantInt>(NewCaseVal));
i.setValue(cast<ConstantInt>(NewCaseVal));
}
SI.setCondition(I->getOperand(0));
Worklist.Add(I);
@ -1873,9 +1873,10 @@ static bool AddReachableCodeToWorklist(BasicBlock *BB,
} else if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) {
if (ConstantInt *Cond = dyn_cast<ConstantInt>(SI->getCondition())) {
// See if this is an explicit destination.
for (unsigned i = 0, e = SI->getNumCases(); i != e; ++i)
if (SI->getCaseValue(i) == Cond) {
BasicBlock *ReachableBB = SI->getCaseSuccessor(i);
for (SwitchInst::CaseIt i = SI->caseBegin(), e = SI->caseEnd();
i != e; ++i)
if (i.getCaseValue() == Cond) {
BasicBlock *ReachableBB = i.getCaseSuccessor();
Worklist.push_back(ReachableBB);
continue;
}

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

@ -2158,10 +2158,11 @@ bool GVN::processInstruction(Instruction *I) {
Value *SwitchCond = SI->getCondition();
BasicBlock *Parent = SI->getParent();
bool Changed = false;
for (unsigned i = 0, e = SI->getNumCases(); i != e; ++i) {
BasicBlock *Dst = SI->getCaseSuccessor(i);
for (SwitchInst::CaseIt i = SI->caseBegin(), e = SI->caseEnd();
i != e; ++i) {
BasicBlock *Dst = i.getCaseSuccessor();
if (isOnlyReachableViaThisEdge(Parent, Dst, DT))
Changed |= propagateEquality(SwitchCond, SI->getCaseValue(i), Dst);
Changed |= propagateEquality(SwitchCond, i.getCaseValue(), Dst);
}
return Changed;
}

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

@ -1087,8 +1087,7 @@ bool JumpThreading::ProcessThreadableEdges(Value *Cond, BasicBlock *BB,
else if (BranchInst *BI = dyn_cast<BranchInst>(BB->getTerminator()))
DestBB = BI->getSuccessor(cast<ConstantInt>(Val)->isZero());
else if (SwitchInst *SI = dyn_cast<SwitchInst>(BB->getTerminator())) {
unsigned ValCase = SI->findCaseValue(cast<ConstantInt>(Val));
DestBB = SI->getSuccessor(SI->resolveSuccessorIndex(ValCase));
DestBB = SI->findCaseValue(cast<ConstantInt>(Val)).getCaseSuccessor();
} else {
assert(isa<IndirectBrInst>(BB->getTerminator())
&& "Unexpected terminator");

20
lib/Transforms/Scalar/LoopUnswitch.cpp
View File

@ -445,8 +445,9 @@ bool LoopUnswitch::processCurrentLoop() {
// Do not process same value again and again.
// At this point we have some cases already unswitched and
// some not yet unswitched. Let's find the first not yet unswitched one.
for (unsigned i = 0; i < NumCases; ++i) {
Constant* UnswitchValCandidate = SI->getCaseValue(i);
for (SwitchInst::CaseIt i = SI->caseBegin(), e = SI->caseEnd();
i != e; ++i) {
Constant* UnswitchValCandidate = i.getCaseValue();
if (!BranchesInfo.isUnswitched(SI, UnswitchValCandidate)) {
UnswitchVal = UnswitchValCandidate;
break;
@ -574,12 +575,13 @@ bool LoopUnswitch::IsTrivialUnswitchCondition(Value *Cond, Constant **Val,
// this.
// Note that we can't trivially unswitch on the default case or
// on already unswitched cases.
for (unsigned i = 0, e = SI->getNumCases(); i != e; ++i) {
for (SwitchInst::CaseIt i = SI->caseBegin(), e = SI->caseEnd();
i != e; ++i) {
BasicBlock* LoopExitCandidate;
if ((LoopExitCandidate = isTrivialLoopExitBlock(currentLoop,
SI->getCaseSuccessor(i)))) {
i.getCaseSuccessor()))) {
// Okay, we found a trivial case, remember the value that is trivial.
ConstantInt* CaseVal = SI->getCaseValue(i);
ConstantInt* CaseVal = i.getCaseValue();
// Check that it was not unswitched before, since already unswitched
// trivial vals are looks trivial too.
@ -1117,16 +1119,16 @@ void LoopUnswitch::RewriteLoopBodyWithConditionConstant(Loop *L, Value *LIC,
SwitchInst *SI = dyn_cast<SwitchInst>(U);
if (SI == 0 || !isa<ConstantInt>(Val)) continue;
unsigned DeadCase = SI->findCaseValue(cast<ConstantInt>(Val));
SwitchInst::CaseIt DeadCase = SI->findCaseValue(cast<ConstantInt>(Val));
// Default case is live for multiple values.
if (DeadCase == SwitchInst::ErrorIndex) continue;
if (DeadCase == SI->caseDefault()) continue;
// Found a dead case value. Don't remove PHI nodes in the
// successor if they become single-entry, those PHI nodes may
// be in the Users list.
BasicBlock *Switch = SI->getParent();
BasicBlock *SISucc = SI->getCaseSuccessor(DeadCase);
BasicBlock *SISucc = DeadCase.getCaseSuccessor();
BasicBlock *Latch = L->getLoopLatch();
BranchesInfo.setUnswitched(SI, Val);
@ -1146,7 +1148,7 @@ void LoopUnswitch::RewriteLoopBodyWithConditionConstant(Loop *L, Value *LIC,
// Compute the successors instead of relying on the return value
// of SplitEdge, since it may have split the switch successor
// after PHI nodes.
BasicBlock *NewSISucc = SI->getCaseSuccessor(DeadCase);
BasicBlock *NewSISucc = DeadCase.getCaseSuccessor();
BasicBlock *OldSISucc = *succ_begin(NewSISucc);
// Create an "unreachable" destination.
BasicBlock *Abort = BasicBlock::Create(Context, "us-unreachable",

17
lib/Transforms/Scalar/SCCP.cpp
View File

@ -564,7 +564,7 @@ void SCCPSolver::getFeasibleSuccessors(TerminatorInst &TI,
return;
}
Succs[SI->resolveSuccessorIndex(SI->findCaseValue(CI))] = true;
Succs[SI->findCaseValue(CI).getSuccessorIndex()] = true;
return;
}
@ -623,14 +623,7 @@ bool SCCPSolver::isEdgeFeasible(BasicBlock *From, BasicBlock *To) {
if (CI == 0)
return !SCValue.isUndefined();
// Make sure to skip the "default value" which isn't a value
for (unsigned i = 0, E = SI->getNumCases(); i != E; ++i)
if (SI->getCaseValue(i) == CI) // Found the taken branch.
return SI->getCaseSuccessor(i) == To;
// If the constant value is not equal to any of the branches, we must
// execute default branch.
return SI->getDefaultDest() == To;
return SI->findCaseValue(CI).getCaseSuccessor() == To;
}
// Just mark all destinations executable!
@ -1495,12 +1488,12 @@ bool SCCPSolver::ResolvedUndefsIn(Function &F) {
// If the input to SCCP is actually switch on undef, fix the undef to
// the first constant.
if (isa<UndefValue>(SI->getCondition())) {
SI->setCondition(SI->getCaseValue(0));
markEdgeExecutable(BB, SI->getCaseSuccessor(0));
SI->setCondition(SI->caseBegin().getCaseValue());
markEdgeExecutable(BB, SI->caseBegin().getCaseSuccessor());
return true;
}
markForcedConstant(SI->getCondition(), SI->getCaseValue(0));
markForcedConstant(SI->getCondition(), SI->caseBegin().getCaseValue());
return true;
}
}

4
lib/Transforms/Utils/CloneFunction.cpp
View File

@ -313,8 +313,8 @@ void PruningFunctionCloner::CloneBlock(const BasicBlock *BB,
Cond = dyn_cast_or_null<ConstantInt>(V);
}
if (Cond) { // Constant fold to uncond branch!
unsigned CaseIndex = SI->findCaseValue(Cond);
BasicBlock *Dest = SI->getSuccessor(SI->resolveSuccessorIndex(CaseIndex));
SwitchInst::ConstCaseIt Case = SI->findCaseValue(Cond);
BasicBlock *Dest = const_cast<BasicBlock*>(Case.getCaseSuccessor());
VMap[OldTI] = BranchInst::Create(Dest, NewBB);
ToClone.push_back(Dest);
TerminatorDone = true;

3
lib/Transforms/Utils/CodeExtractor.cpp
View File

@ -617,7 +617,8 @@ emitCallAndSwitchStatement(Function *newFunction, BasicBlock *codeReplacer,
// of the other successors.
TheSwitch->setCondition(call);
TheSwitch->setDefaultDest(TheSwitch->getSuccessor(NumExitBlocks));
TheSwitch->removeCase(NumExitBlocks-1); // Remove redundant case
// Remove redundant case
TheSwitch->removeCase(SwitchInst::CaseIt(TheSwitch, NumExitBlocks-1));
break;
}
}

21
lib/Transforms/Utils/Local.cpp
View File

@ -106,31 +106,32 @@ bool llvm::ConstantFoldTerminator(BasicBlock *BB, bool DeleteDeadConditions) {
// If we are switching on a constant, we can convert the switch into a
// single branch instruction!
ConstantInt *CI = dyn_cast<ConstantInt>(SI->getCondition());
BasicBlock *TheOnlyDest = SI->getDefaultDest(); // The default dest
BasicBlock *TheOnlyDest = SI->getDefaultDest();
BasicBlock *DefaultDest = TheOnlyDest;
// Figure out which case it goes to.
for (unsigned i = 0, e = SI->getNumCases(); i != e; ++i) {
for (SwitchInst::CaseIt i = SI->caseBegin(), e = SI->caseEnd();
i != e; ++i) {
// Found case matching a constant operand?
if (SI->getCaseValue(i) == CI) {
TheOnlyDest = SI->getCaseSuccessor(i);
if (i.getCaseValue() == CI) {
TheOnlyDest = i.getCaseSuccessor();
break;
}
// Check to see if this branch is going to the same place as the default
// dest. If so, eliminate it as an explicit compare.
if (SI->getCaseSuccessor(i) == DefaultDest) {
if (i.getCaseSuccessor() == DefaultDest) {
// Remove this entry.
DefaultDest->removePredecessor(SI->getParent());
SI->removeCase(i);
--i; --e; // Don't skip an entry...
--i; --e;
continue;
}
// Otherwise, check to see if the switch only branches to one destination.
// We do this by reseting "TheOnlyDest" to null when we find two non-equal
// destinations.
if (SI->getCaseSuccessor(i) != TheOnlyDest) TheOnlyDest = 0;
if (i.getCaseSuccessor() != TheOnlyDest) TheOnlyDest = 0;
}
if (CI && !TheOnlyDest) {
@ -167,11 +168,13 @@ bool llvm::ConstantFoldTerminator(BasicBlock *BB, bool DeleteDeadConditions) {
if (SI->getNumCases() == 1) {
// Otherwise, we can fold this switch into a conditional branch
// instruction if it has only one non-default destination.
SwitchInst::CaseIt FirstCase = SI->caseBegin();
Value *Cond = Builder.CreateICmpEQ(SI->getCondition(),
SI->getCaseValue(0), "cond");
FirstCase.getCaseValue(), "cond");
// Insert the new branch.
Builder.CreateCondBr(Cond, SI->getCaseSuccessor(0), SI->getDefaultDest());
Builder.CreateCondBr(Cond, FirstCase.getCaseSuccessor(),
SI->getDefaultDest());
// Delete the old switch.
SI->eraseFromParent();

6
lib/Transforms/Utils/LowerExpectIntrinsic.cpp
View File

@ -73,16 +73,16 @@ bool LowerExpectIntrinsic::HandleSwitchExpect(SwitchInst *SI) {
LLVMContext &Context = CI->getContext();
Type *Int32Ty = Type::getInt32Ty(Context);
unsigned caseNo = SI->findCaseValue(ExpectedValue);
SwitchInst::CaseIt Case = SI->findCaseValue(ExpectedValue);
std::vector<Value *> Vec;
unsigned n = SI->getNumCases();
Vec.resize(n + 1 + 1); // +1 for MDString and +1 for default case
Vec[0] = MDString::get(Context, "branch_weights");
Vec[1] = ConstantInt::get(Int32Ty, SwitchInst::ErrorIndex == caseNo ?
Vec[1] = ConstantInt::get(Int32Ty, Case == SI->caseDefault() ?
LikelyBranchWeight : UnlikelyBranchWeight);
for (unsigned i = 0; i < n; ++i) {
Vec[i + 1 + 1] = ConstantInt::get(Int32Ty, i == caseNo ?
Vec[i + 1 + 1] = ConstantInt::get(Int32Ty, i == Case.getCaseIndex() ?
LikelyBranchWeight : UnlikelyBranchWeight);
}

8
lib/Transforms/Utils/LowerSwitch.cpp
View File

@ -237,10 +237,10 @@ unsigned LowerSwitch::Clusterify(CaseVector& Cases, SwitchInst *SI) {
unsigned numCmps = 0;
// Start with "simple" cases
for (unsigned i = 0; i < SI->getNumCases(); ++i)
Cases.push_back(CaseRange(SI->getCaseValue(i),
SI->getCaseValue(i),
SI->getCaseSuccessor(i)));
for (SwitchInst::CaseIt i = SI->caseBegin(), e = SI->caseEnd(); i != e; ++i)
Cases.push_back(CaseRange(i.getCaseValue(), i.getCaseValue(),
i.getCaseSuccessor()));
std::sort(Cases.begin(), Cases.end(), CaseCmp());
// Merge case into clusters

74
lib/Transforms/Utils/SimplifyCFG.cpp
View File

@ -480,9 +480,9 @@ GetValueEqualityComparisonCases(TerminatorInst *TI,
BasicBlock*> > &Cases) {
if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) {
Cases.reserve(SI->getNumCases());
for (unsigned i = 0, e = SI->getNumCases(); i != e; ++i)
Cases.push_back(std::make_pair(SI->getCaseValue(i),
SI->getCaseSuccessor(i)));
for (SwitchInst::CaseIt i = SI->caseBegin(), e = SI->caseEnd(); i != e; ++i)
Cases.push_back(std::make_pair(i.getCaseValue(),
i.getCaseSuccessor()));
return SI->getDefaultDest();
}
@ -605,10 +605,10 @@ SimplifyEqualityComparisonWithOnlyPredecessor(TerminatorInst *TI,
DEBUG(dbgs() << "Threading pred instr: " << *Pred->getTerminator()
<< "Through successor TI: " << *TI);
for (unsigned i = SI->getNumCases(); i != 0;) {
for (SwitchInst::CaseIt i = SI->caseEnd(), e = SI->caseBegin(); i != e;) {
--i;
if (DeadCases.count(SI->getCaseValue(i))) {
SI->getCaseSuccessor(i)->removePredecessor(TI->getParent());
if (DeadCases.count(i.getCaseValue())) {
i.getCaseSuccessor()->removePredecessor(TI->getParent());
SI->removeCase(i);
}
}
@ -2009,10 +2009,8 @@ static bool SimplifySwitchOnSelect(SwitchInst *SI, SelectInst *Select) {
// Find the relevant condition and destinations.
Value *Condition = Select->getCondition();
unsigned TrueCase = SI->findCaseValue(TrueVal);
unsigned FalseCase = SI->findCaseValue(FalseVal);
BasicBlock *TrueBB = SI->getSuccessor(SI->resolveSuccessorIndex(TrueCase));
BasicBlock *FalseBB = SI->getSuccessor(SI->resolveSuccessorIndex(FalseCase));
BasicBlock *TrueBB = SI->findCaseValue(TrueVal).getCaseSuccessor();
BasicBlock *FalseBB = SI->findCaseValue(FalseVal).getCaseSuccessor();
// Perform the actual simplification.
return SimplifyTerminatorOnSelect(SI, Condition, TrueBB, FalseBB);
@ -2096,7 +2094,7 @@ static bool TryToSimplifyUncondBranchWithICmpInIt(ICmpInst *ICI,
// Ok, the block is reachable from the default dest. If the constant we're
// comparing exists in one of the other edges, then we can constant fold ICI
// and zap it.
if (SI->findCaseValue(Cst) != SwitchInst::ErrorIndex) {
if (SI->findCaseValue(Cst) != SI->caseDefault()) {
Value *V;
if (ICI->getPredicate() == ICmpInst::ICMP_EQ)
V = ConstantInt::getFalse(BB->getContext());
@ -2423,8 +2421,9 @@ bool SimplifyCFGOpt::SimplifyUnreachable(UnreachableInst *UI) {
}
}
} else if (SwitchInst *SI = dyn_cast<SwitchInst>(TI)) {
for (unsigned i = 0, e = SI->getNumCases(); i != e; ++i)
if (SI->getCaseSuccessor(i) == BB) {
for (SwitchInst::CaseIt i = SI->caseBegin(), e = SI->caseEnd();
i != e; ++i)
if (i.getCaseSuccessor() == BB) {
BB->removePredecessor(SI->getParent());
SI->removeCase(i);
--i; --e;
@ -2434,12 +2433,13 @@ bool SimplifyCFGOpt::SimplifyUnreachable(UnreachableInst *UI) {
// destination and make it the default.
if (SI->getDefaultDest() == BB) {
std::map<BasicBlock*, std::pair<unsigned, unsigned> > Popularity;
for (unsigned i = 0, e = SI->getNumCases(); i != e; ++i) {
for (SwitchInst::CaseIt i = SI->caseBegin(), e = SI->caseEnd();
i != e; ++i) {
std::pair<unsigned, unsigned> &entry =
Popularity[SI->getCaseSuccessor(i)];
Popularity[i.getCaseSuccessor()];
if (entry.first == 0) {
entry.first = 1;
entry.second = i;
entry.second = i.getCaseIndex();
} else {
entry.first++;
}
@ -2470,8 +2470,9 @@ bool SimplifyCFGOpt::SimplifyUnreachable(UnreachableInst *UI) {
for (unsigned i = 0; i != MaxPop-1; ++i)
MaxBlock->removePredecessor(SI->getParent());
for (unsigned i = 0, e = SI->getNumCases(); i != e; ++i)
if (SI->getCaseSuccessor(i) == MaxBlock) {
for (SwitchInst::CaseIt i = SI->caseBegin(), e = SI->caseEnd();
i != e; ++i)
if (i.getCaseSuccessor() == MaxBlock) {
SI->removeCase(i);
--i; --e;
}
@ -2517,11 +2518,13 @@ static bool TurnSwitchRangeIntoICmp(SwitchInst *SI, IRBuilder<> &Builder) {
// Make sure all cases point to the same destination and gather the values.
SmallVector<ConstantInt *, 16> Cases;
Cases.push_back(SI->getCaseValue(0));
for (unsigned I = 1, E = SI->getNumCases(); I != E; ++I) {
if (SI->getCaseSuccessor(I-1) != SI->getCaseSuccessor(I))
SwitchInst::CaseIt I = SI->caseBegin();
Cases.push_back(I.getCaseValue());
SwitchInst::CaseIt PrevI = I++;
for (SwitchInst::CaseIt E = SI->caseEnd(); I != E; PrevI = I++) {
if (PrevI.getCaseSuccessor() != I.getCaseSuccessor())
return false;
Cases.push_back(SI->getCaseValue(I));
Cases.push_back(I.getCaseValue());
}
assert(Cases.size() == SI->getNumCases() && "Not all cases gathered");
@ -2539,10 +2542,11 @@ static bool TurnSwitchRangeIntoICmp(SwitchInst *SI, IRBuilder<> &Builder) {
if (!Offset->isNullValue())
Sub = Builder.CreateAdd(Sub, Offset, Sub->getName()+".off");
Value *Cmp = Builder.CreateICmpULT(Sub, NumCases, "switch");
Builder.CreateCondBr(Cmp, SI->getCaseSuccessor(0), SI->getDefaultDest());
Builder.CreateCondBr(
Cmp, SI->caseBegin().getCaseSuccessor(), SI->getDefaultDest());
// Prune obsolete incoming values off the successor's PHI nodes.
for (BasicBlock::iterator BBI = SI->getCaseSuccessor(0)->begin();
for (BasicBlock::iterator BBI = SI->caseBegin().getCaseSuccessor()->begin();
isa<PHINode>(BBI); ++BBI) {
for (unsigned I = 0, E = SI->getNumCases()-1; I != E; ++I)
cast<PHINode>(BBI)->removeIncomingValue(SI->getParent());
@ -2562,22 +2566,22 @@ static bool EliminateDeadSwitchCases(SwitchInst *SI) {
// Gather dead cases.
SmallVector<ConstantInt*, 8> DeadCases;
for (unsigned I = 0, E = SI->getNumCases(); I != E; ++I) {
if ((SI->getCaseValue(I)->getValue() & KnownZero) != 0 ||
(SI->getCaseValue(I)->getValue() & KnownOne) != KnownOne) {
DeadCases.push_back(SI->getCaseValue(I));
for (SwitchInst::CaseIt I = SI->caseBegin(), E = SI->caseEnd(); I != E; ++I) {
if ((I.getCaseValue()->getValue() & KnownZero) != 0 ||
(I.getCaseValue()->getValue() & KnownOne) != KnownOne) {
DeadCases.push_back(I.getCaseValue());
DEBUG(dbgs() << "SimplifyCFG: switch case '"
<< SI->getCaseValue(I)->getValue() << "' is dead.\n");
<< I.getCaseValue() << "' is dead.\n");
}
}
// Remove dead cases from the switch.
for (unsigned I = 0, E = DeadCases.size(); I != E; ++I) {
unsigned Case = SI->findCaseValue(DeadCases[I]);
assert(Case != SwitchInst::ErrorIndex &&
SwitchInst::CaseIt Case = SI->findCaseValue(DeadCases[I]);
assert(Case != SI->caseDefault() &&
"Case was not found. Probably mistake in DeadCases forming.");
// Prune unused values from PHI nodes.
SI->getCaseSuccessor(Case)->removePredecessor(SI->getParent());
Case.getCaseSuccessor()->removePredecessor(SI->getParent());
SI->removeCase(Case);
}
@ -2626,9 +2630,9 @@ static bool ForwardSwitchConditionToPHI(SwitchInst *SI) {
typedef DenseMap<PHINode*, SmallVector<int,4> > ForwardingNodesMap;
ForwardingNodesMap ForwardingNodes;
for (unsigned I = 0; I < SI->getNumCases(); ++I) { // 0 is the default case.
ConstantInt *CaseValue = SI->getCaseValue(I);
BasicBlock *CaseDest = SI->getCaseSuccessor(I);
for (SwitchInst::CaseIt I = SI->caseBegin(), E = SI->caseEnd(); I != E; ++I) {
ConstantInt *CaseValue = I.getCaseValue();
BasicBlock *CaseDest = I.getCaseSuccessor();
int PhiIndex;
PHINode *PHI = FindPHIForConditionForwarding(CaseValue, CaseDest,

8
lib/VMCore/AsmWriter.cpp
View File

@ -1731,12 +1731,12 @@ void AssemblyWriter::printInstruction(const Instruction &I) {
Out << ", ";
writeOperand(SI.getDefaultDest(), true);
Out << " [";
unsigned NumCases = SI.getNumCases();
for (unsigned i = 0; i < NumCases; ++i) {
for (SwitchInst::CaseIt i = SI.caseBegin(), e = SI.caseEnd();
i != e; ++i) {
Out << "\n ";
writeOperand(SI.getCaseValue(i), true);
writeOperand(i.getCaseValue(), true);
Out << ", ";
writeOperand(SI.getCaseSuccessor(i), true);
writeOperand(i.getCaseSuccessor(), true);
}
Out << "\n ]";
} else if (isa<IndirectBrInst>(I)) {

9
lib/VMCore/Instructions.cpp
View File

@ -3159,13 +3159,16 @@ void SwitchInst::addCase(ConstantInt *OnVal, BasicBlock *Dest) {
// Initialize some new operands.
assert(OpNo+1 < ReservedSpace && "Growing didn't work!");
NumOperands = OpNo+2;
setCaseValue(NewCaseIdx, OnVal);
setCaseSuccessor(NewCaseIdx, Dest);
CaseIt Case(this, NewCaseIdx);
Case.setValue(OnVal);
Case.setSuccessor(Dest);
}
/// removeCase - This method removes the specified case and its successor
/// from the switch instruction.
void SwitchInst::removeCase(unsigned idx) {
void SwitchInst::removeCase(CaseIt i) {
unsigned idx = i.getCaseIndex();
assert(2 + idx*2 < getNumOperands() && "Case index out of range!!!");
unsigned NumOps = getNumOperands();

8
lib/VMCore/Verifier.cpp
View File

@ -813,11 +813,11 @@ void Verifier::visitSwitchInst(SwitchInst &SI) {
// have the same type as the switched-on value.
Type *SwitchTy = SI.getCondition()->getType();
SmallPtrSet<ConstantInt*, 32> Constants;
for (unsigned i = 0, e = SI.getNumCases(); i != e; ++i) {
Assert1(SI.getCaseValue(i)->getType() == SwitchTy,
for (SwitchInst::CaseIt i = SI.caseBegin(), e = SI.caseEnd(); i != e; ++i) {
Assert1(i.getCaseValue()->getType() == SwitchTy,
"Switch constants must all be same type as switch value!", &SI);
Assert2(Constants.insert(SI.getCaseValue(i)),
"Duplicate integer as switch case", &SI, SI.getCaseValue(i));
Assert2(Constants.insert(i.getCaseValue()),
"Duplicate integer as switch case", &SI, i.getCaseValue());
}
visitTerminatorInst(SI);

14
tools/llvm-diff/DifferenceEngine.cpp
View File

@ -319,13 +319,17 @@ class FunctionDifferenceEngine {
bool Difference = false;
DenseMap<ConstantInt*,BasicBlock*> LCases;
for (unsigned I = 0, E = LI->getNumCases(); I != E; ++I)
LCases[LI->getCaseValue(I)] = LI->getCaseSuccessor(I);
for (unsigned I = 0, E = RI->getNumCases(); I != E; ++I) {
ConstantInt *CaseValue = RI->getCaseValue(I);
for (SwitchInst::CaseIt I = LI->caseBegin(), E = LI->caseEnd();
I != E; ++I)
LCases[I.getCaseValue()] = I.getCaseSuccessor();
for (SwitchInst::CaseIt I = RI->caseBegin(), E = RI->caseEnd();
I != E; ++I) {
ConstantInt *CaseValue = I.getCaseValue();
BasicBlock *LCase = LCases[CaseValue];
if (LCase) {
if (TryUnify) tryUnify(LCase, RI->getCaseSuccessor(I));
if (TryUnify) tryUnify(LCase, I.getCaseSuccessor());
LCases.erase(CaseValue);
} else if (Complain || !Difference) {
if (Complain)