6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2025-01-05 12:31:33 +00:00
Code Issues Projects Releases Wiki Activity

convert more operand loops to iterator formulation

Browse Source 
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@51663 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Gabor Greif 2008-05-29 01:59:18 +00:00
parent bd0879d7d9
commit 5e46321d66
2 changed files with 29 additions and 23 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

5
lib/Transforms/IPO/ArgumentPromotion.cpp
View File

@ -262,8 +262,9 @@ bool ArgPromotion::isSafeToPromoteArgument(Argument *Arg, bool isByVal) const {
} }
// Ensure that all of the indices are constants. // Ensure that all of the indices are constants.
SmallVector<ConstantInt*, 8> Operands; SmallVector<ConstantInt*, 8> Operands;
for (unsigned i = 1, e = GEP->getNumOperands(); i != e; ++i) for (User::op_iterator i = GEP->op_begin() + 1, e = GEP->op_end();
if (ConstantInt *C = dyn_cast<ConstantInt>(GEP->getOperand(i))) i != e; ++i)
if (ConstantInt *C = dyn_cast<ConstantInt>(*i))
Operands.push_back(C); Operands.push_back(C);
else else
return false; // Not a constant operand GEP! return false; // Not a constant operand GEP!

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

@ -704,8 +704,9 @@ static bool OptimizeAwayTrappingUsesOfValue(Value *V, Constant *NewV) {
// Should handle GEP here. // Should handle GEP here.
SmallVector<Constant*, 8> Idxs; SmallVector<Constant*, 8> Idxs;
Idxs.reserve(GEPI->getNumOperands()-1); Idxs.reserve(GEPI->getNumOperands()-1);
for (unsigned i = 1, e = GEPI->getNumOperands(); i != e; ++i) for (User::op_iterator i = GEPI->op_begin() + 1, e = GEPI->op_end();
if (Constant *C = dyn_cast<Constant>(GEPI->getOperand(i))) i != e; ++i)
if (Constant *C = dyn_cast<Constant>(*i))
Idxs.push_back(C); Idxs.push_back(C);
else else
break; break;
@ -984,8 +985,8 @@ static bool GlobalLoadUsesSimpleEnoughForHeapSRA(GlobalVariable *GV,
if (LoadInst *LI = dyn_cast<LoadInst>(*UI)) { if (LoadInst *LI = dyn_cast<LoadInst>(*UI)) {
// We permit two users of the load: setcc comparing against the null // We permit two users of the load: setcc comparing against the null
// pointer, and a getelementptr of a specific form. // pointer, and a getelementptr of a specific form.
for (Value::use_iterator UI = LI->use_begin(), E = LI->use_end(); UI != E; for (Value::use_iterator UI = LI->use_begin(), E = LI->use_end();
++UI) { UI != E; ++UI) {
// Comparison against null is ok. // Comparison against null is ok.
if (ICmpInst *ICI = dyn_cast<ICmpInst>(*UI)) { if (ICmpInst *ICI = dyn_cast<ICmpInst>(*UI)) {
if (!isa<ConstantPointerNull>(ICI->getOperand(1))) if (!isa<ConstantPointerNull>(ICI->getOperand(1)))
@ -1279,9 +1280,10 @@ static bool OptimizeOnceStoredGlobal(GlobalVariable *GV, Value *StoredOnceVal,
else if (GetElementPtrInst *GEPI =dyn_cast<GetElementPtrInst>(StoredOnceVal)){ else if (GetElementPtrInst *GEPI =dyn_cast<GetElementPtrInst>(StoredOnceVal)){
// "getelementptr Ptr, 0, 0, 0" is really just a cast. // "getelementptr Ptr, 0, 0, 0" is really just a cast.
bool IsJustACast = true; bool IsJustACast = true;
for (unsigned i = 1, e = GEPI->getNumOperands(); i != e; ++i) for (User::op_iterator i = GEPI->op_begin() + 1, e = GEPI->op_end();
if (!isa<Constant>(GEPI->getOperand(i)) || i != e; ++i)
!cast<Constant>(GEPI->getOperand(i))->isNullValue()) { if (!isa<Constant>(*i) ||
!cast<Constant>(*i)->isNullValue()) {
IsJustACast = false; IsJustACast = false;
break; break;
} }
@ -1606,8 +1608,9 @@ static bool OnlyCalledDirectly(Function *F) {
if (!isa<CallInst>(User) && !isa<InvokeInst>(User)) return false; if (!isa<CallInst>(User) && !isa<InvokeInst>(User)) return false;
// See if the function address is passed as an argument. // See if the function address is passed as an argument.
for (unsigned i = 1, e = User->getNumOperands(); i != e; ++i) for (User::op_iterator i = User->op_begin() + 1, e = User->op_end();
if (User->getOperand(i) == F) return false; i != e; ++i)
if (*i == F) return false;
} }
return true; return true;
} }
@ -1712,8 +1715,8 @@ GlobalVariable *GlobalOpt::FindGlobalCtors(Module &M) {
if (!I->hasInitializer()) return 0; if (!I->hasInitializer()) return 0;
ConstantArray *CA = dyn_cast<ConstantArray>(I->getInitializer()); ConstantArray *CA = dyn_cast<ConstantArray>(I->getInitializer());
if (!CA) return 0; if (!CA) return 0;
for (unsigned i = 0, e = CA->getNumOperands(); i != e; ++i) for (User::op_iterator i = CA->op_begin(), e = CA->op_end(); i != e; ++i)
if (ConstantStruct *CS = dyn_cast<ConstantStruct>(CA->getOperand(i))) { if (ConstantStruct *CS = dyn_cast<ConstantStruct>(*i)) {
if (isa<ConstantPointerNull>(CS->getOperand(1))) if (isa<ConstantPointerNull>(CS->getOperand(1)))
continue; continue;
@ -1740,8 +1743,8 @@ static std::vector<Function*> ParseGlobalCtors(GlobalVariable *GV) {
ConstantArray *CA = cast<ConstantArray>(GV->getInitializer()); ConstantArray *CA = cast<ConstantArray>(GV->getInitializer());
std::vector<Function*> Result; std::vector<Function*> Result;
Result.reserve(CA->getNumOperands()); Result.reserve(CA->getNumOperands());
for (unsigned i = 0, e = CA->getNumOperands(); i != e; ++i) { for (User::op_iterator i = CA->op_begin(), e = CA->op_end(); i != e; ++i) {
ConstantStruct *CS = cast<ConstantStruct>(CA->getOperand(i)); ConstantStruct *CS = cast<ConstantStruct>(*i);
Result.push_back(dyn_cast<Function>(CS->getOperand(1))); Result.push_back(dyn_cast<Function>(CS->getOperand(1)));
} }
return Result; return Result;
@ -1854,8 +1857,8 @@ static Constant *EvaluateStoreInto(Constant *Init, Constant *Val,
// Break up the constant into its elements. // Break up the constant into its elements.
if (ConstantStruct *CS = dyn_cast<ConstantStruct>(Init)) { if (ConstantStruct *CS = dyn_cast<ConstantStruct>(Init)) {
for (unsigned i = 0, e = CS->getNumOperands(); i != e; ++i) for (User::op_iterator i = CS->op_begin(), e = CS->op_end(); i != e; ++i)
Elts.push_back(CS->getOperand(i)); Elts.push_back(cast<Constant>(*i));
} else if (isa<ConstantAggregateZero>(Init)) { } else if (isa<ConstantAggregateZero>(Init)) {
for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i) for (unsigned i = 0, e = STy->getNumElements(); i != e; ++i)
Elts.push_back(Constant::getNullValue(STy->getElementType(i))); Elts.push_back(Constant::getNullValue(STy->getElementType(i)));
@ -1882,8 +1885,8 @@ static Constant *EvaluateStoreInto(Constant *Init, Constant *Val,
// Break up the array into elements. // Break up the array into elements.
std::vector<Constant*> Elts; std::vector<Constant*> Elts;
if (ConstantArray *CA = dyn_cast<ConstantArray>(Init)) { if (ConstantArray *CA = dyn_cast<ConstantArray>(Init)) {
for (unsigned i = 0, e = CA->getNumOperands(); i != e; ++i) for (User::op_iterator i = CA->op_begin(), e = CA->op_end(); i != e; ++i)
Elts.push_back(CA->getOperand(i)); Elts.push_back(cast<Constant>(*i));
} else if (isa<ConstantAggregateZero>(Init)) { } else if (isa<ConstantAggregateZero>(Init)) {
Constant *Elt = Constant::getNullValue(ATy->getElementType()); Constant *Elt = Constant::getNullValue(ATy->getElementType());
Elts.assign(ATy->getNumElements(), Elt); Elts.assign(ATy->getNumElements(), Elt);
@ -2011,8 +2014,9 @@ static bool EvaluateFunction(Function *F, Constant *&RetVal,
} else if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(CurInst)) { } else if (GetElementPtrInst *GEP = dyn_cast<GetElementPtrInst>(CurInst)) {
Constant *P = getVal(Values, GEP->getOperand(0)); Constant *P = getVal(Values, GEP->getOperand(0));
SmallVector<Constant*, 8> GEPOps; SmallVector<Constant*, 8> GEPOps;
for (unsigned i = 1, e = GEP->getNumOperands(); i != e; ++i) for (User::op_iterator i = GEP->op_begin() + 1, e = GEP->op_end();
GEPOps.push_back(getVal(Values, GEP->getOperand(i))); i != e; ++i)
GEPOps.push_back(getVal(Values, *i));
InstResult = ConstantExpr::getGetElementPtr(P, &GEPOps[0], GEPOps.size()); InstResult = ConstantExpr::getGetElementPtr(P, &GEPOps[0], GEPOps.size());
} else if (LoadInst *LI = dyn_cast<LoadInst>(CurInst)) { } else if (LoadInst *LI = dyn_cast<LoadInst>(CurInst)) {
if (LI->isVolatile()) return false; // no volatile accesses. if (LI->isVolatile()) return false; // no volatile accesses.
@ -2036,8 +2040,9 @@ static bool EvaluateFunction(Function *F, Constant *&RetVal,
if (!Callee) return false; // Cannot resolve. if (!Callee) return false; // Cannot resolve.
std::vector<Constant*> Formals; std::vector<Constant*> Formals;
for (unsigned i = 1, e = CI->getNumOperands(); i != e; ++i) for (User::op_iterator i = CI->op_begin() + 1, e = CI->op_end();
Formals.push_back(getVal(Values, CI->getOperand(i))); i != e; ++i)
Formals.push_back(getVal(Values, *i));
if (Callee->isDeclaration()) { if (Callee->isDeclaration()) {
// If this is a function we can constant fold, do it. // If this is a function we can constant fold, do it.