6502/llvm-6502
1
0
Fork 0
mirror of https://github.com/c64scene-ar/llvm-6502.git synced 2024-08-17 21:29:20 +00:00
Code Issues Projects Releases Wiki Activity

bug 122:

Browse Source 
- Replace ConstantPointerRef usage with GlobalValue usage
- Minimize redundant isa<GlobalValue> usage
- Correct isa<Constant> for GlobalValue subclass


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@14942 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Reid Spencer 2004-07-18 00:18:30 +00:00
parent e0125b6785
commit e840434755
10 changed files with 48 additions and 78 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

18
lib/Analysis/BasicAliasAnalysis.cpp
View File

@ -143,8 +143,8 @@ static const Value *getUnderlyingObject(const Value *V) {
if (CE->getOpcode() == Instruction::Cast ||
CE->getOpcode() == Instruction::GetElementPtr)
return getUnderlyingObject(CE->getOperand(0));
} else if (const ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(V)) {
return CPR->getValue();
} else if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
return GV;
}
return 0;
}
@ -166,7 +166,7 @@ static const Value *GetGEPOperands(const Value *V, std::vector<Value*> &GEPOps){
V = cast<User>(V)->getOperand(0);
while (const User *G = isGEP(V)) {
if (!isa<Constant>(GEPOps[0]) ||
if (!isa<Constant>(GEPOps[0]) || isa<GlobalValue>(GEPOps[0]) ||
!cast<Constant>(GEPOps[0])->isNullValue())
break; // Don't handle folding arbitrary pointer offsets yet...
GEPOps.erase(GEPOps.begin()); // Drop the zero index
@ -217,7 +217,7 @@ static bool AddressMightEscape(const Value *V) {
//
AliasAnalysis::ModRefResult
BasicAliasAnalysis::getModRefInfo(CallSite CS, Value *P, unsigned Size) {
if (!isa<Constant>(P) && !isa<GlobalValue>(P))
if (!isa<Constant>(P))
if (const AllocationInst *AI =
dyn_cast_or_null<AllocationInst>(getUnderlyingObject(P))) {
// Okay, the pointer is to a stack allocated object. If we can prove that
@ -246,12 +246,6 @@ BasicAliasAnalysis::alias(const Value *V1, unsigned V1Size,
if (CE->getOpcode() == Instruction::Cast)
V2 = CE->getOperand(0);
// Strip off constant pointer refs if they exist
if (const ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(V1))
V1 = CPR->getValue();
if (const ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(V2))
V2 = CPR->getValue();
// Are we checking for alias of the same value?
if (V1 == V2) return MustAlias;
@ -380,7 +374,7 @@ BasicAliasAnalysis::alias(const Value *V1, unsigned V1Size,
// the arguments provided, except substitute 0's for any variable
// indexes we find...
for (unsigned i = 0; i != GEPOperands.size(); ++i)
if (!isa<Constant>(GEPOperands[i]) ||
if (!isa<Constant>(GEPOperands[i]) || isa<GlobalValue>(GEPOperands[i]) ||
isa<ConstantExpr>(GEPOperands[i]))
GEPOperands[i] =Constant::getNullValue(GEPOperands[i]->getType());
int64_t Offset = getTargetData().getIndexedOffset(BasePtr->getType(),
@ -453,7 +447,7 @@ CheckGEPInstructions(const Type* BasePtr1Ty, std::vector<Value*> &GEP1Ops,
bool AllAreZeros = true;
for (unsigned i = UnequalOper; i != MaxOperands; ++i)
if (!isa<Constant>(GEP1Ops[i]) ||
if (!isa<Constant>(GEP1Ops[i]) ||
!cast<Constant>(GEP1Ops[i])->isNullValue()) {
AllAreZeros = false;
break;

2
lib/Analysis/DataStructure/DataStructureStats.cpp
View File

@ -102,7 +102,7 @@ void DSGraphStats::countCallees(const Function& F) {
DSNode *DSGraphStats::getNodeForValue(Value *V) {
const DSGraph *G = TDGraph;
if (isa<GlobalValue>(V) || isa<Constant>(V))
if (isa<Constant>(V))
G = TDGraph->getGlobalsGraph();
const DSGraph::ScalarMapTy &ScalarMap = G->getScalarMap();

21
lib/Analysis/DataStructure/Local.cpp
View File

@ -220,10 +220,13 @@ DSNodeHandle GraphBuilder::getValueDest(Value &Val) {
// Otherwise we need to create a new node to point to.
// Check first for constant expressions that must be traversed to
// extract the actual value.
if (Constant *C = dyn_cast<Constant>(V))
if (ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(C)) {
return NH = getValueDest(*CPR->getValue());
} else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) {
DSNode* N;
if (GlobalValue* GV = dyn_cast<GlobalValue>(V)) {
// Create a new global node for this global variable...
N = createNode(GV->getType()->getElementType());
N->addGlobal(GV);
} else if (Constant *C = dyn_cast<Constant>(V)) {
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) {
if (CE->getOpcode() == Instruction::Cast)
NH = getValueDest(*CE->getOperand(0));
else if (CE->getOpcode() == Instruction::GetElementPtr) {
@ -247,13 +250,7 @@ DSNodeHandle GraphBuilder::getValueDest(Value &Val) {
} else {
assert(0 && "Unknown constant type!");
}
// Otherwise we need to create a new node to point to...
DSNode *N;
if (GlobalValue *GV = dyn_cast<GlobalValue>(V)) {
// Create a new global node for this global variable...
N = createNode(GV->getType()->getElementType());
N->addGlobal(GV);
N = createNode(); // just create a shadow node
} else {
// Otherwise just create a shadow node
N = createNode();
@ -491,8 +488,6 @@ void GraphBuilder::visitInvokeInst(InvokeInst &II) {
void GraphBuilder::visitCallSite(CallSite CS) {
Value *Callee = CS.getCalledValue();
if (ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(Callee))
Callee = CPR->getValue();
// Special case handling of certain libc allocation functions here.
if (Function *F = dyn_cast<Function>(Callee))

2
lib/Analysis/DataStructure/Printer.cpp
View File

@ -138,7 +138,7 @@ struct DOTGraphTraits<const DSGraph*> : public DefaultDOTGraphTraits {
// Add scalar nodes to the graph...
const DSGraph::ScalarMapTy &VM = G->getScalarMap();
for (DSGraph::ScalarMapTy::const_iterator I = VM.begin(); I != VM.end();++I)
if (!isa<GlobalValue>(I->first) && !isa<ConstantPointerRef>(I->first)) {
if (!isa<GlobalValue>(I->first)) {
std::stringstream OS;
WriteAsOperand(OS, I->first, false, true, CurMod);
GW.emitSimpleNode(I->first, "", OS.str());

8
lib/Analysis/IPA/Andersens.cpp
View File

@ -479,8 +479,8 @@ Andersens::Node *Andersens::getNodeForConstantPointer(Constant *C) {
if (isa<ConstantPointerNull>(C))
return &GraphNodes[NullPtr];
else if (ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(C))
return getNode(CPR->getValue());
else if (GlobalValue *GV = dyn_cast<GlobalValue>(C))
return getNode(GV);
else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) {
switch (CE->getOpcode()) {
case Instruction::GetElementPtr:
@ -507,8 +507,8 @@ Andersens::Node *Andersens::getNodeForConstantPointerTarget(Constant *C) {
if (isa<ConstantPointerNull>(C))
return &GraphNodes[NullObject];
else if (ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(C))
return getObject(CPR->getValue());
else if (GlobalValue *GV = dyn_cast<GlobalValue>(C))
return getObject(GV);
else if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) {
switch (CE->getOpcode()) {
case Instruction::GetElementPtr:

6
lib/Analysis/IPA/CallGraph.cpp
View File

@ -73,10 +73,8 @@ void CallGraph::addToCallGraph(Function *F) {
getNodeFor(Inst->getParent()->getParent())->addCalledFunction(Node);
else
isUsedExternally = true;
} else if (ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(*I)) {
// THIS IS A DISGUSTING HACK. Brought to you by the power of
// ConstantPointerRefs!
for (Value::use_iterator I = CPR->use_begin(), E = CPR->use_end();
} else if (GlobalValue *GV = dyn_cast<GlobalValue>(*I)) {
for (Value::use_iterator I = GV->use_begin(), E = GV->use_end();
I != E; ++I)
if (Instruction *Inst = dyn_cast<Instruction>(*I)) {
if (isOnlyADirectCall(F, CallSite::get(Inst)))

7
lib/Analysis/IPA/FindUsedTypes.cpp
View File

@ -48,9 +48,10 @@ void FindUsedTypes::IncorporateValue(const Value *V) {
// If this is a constant, it could be using other types...
if (const Constant *C = dyn_cast<Constant>(V)) {
for (User::const_op_iterator OI = C->op_begin(), OE = C->op_end();
OI != OE; ++OI)
IncorporateValue(*OI);
if (!isa<GlobalValue>(C))
for (User::const_op_iterator OI = C->op_begin(), OE = C->op_end();
OI != OE; ++OI)
IncorporateValue(*OI);
}
}

6
lib/Analysis/IPA/GlobalsModRef.cpp
View File

@ -165,8 +165,8 @@ bool GlobalsModRef::AnalyzeUsesOfGlobal(Value *V,
} else {
return true;
}
} else if (ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(*UI)) {
if (AnalyzeUsesOfGlobal(CPR, Readers, Writers)) return true;
} else if (GlobalValue *GV = dyn_cast<GlobalValue>(*UI)) {
if (AnalyzeUsesOfGlobal(GV, Readers, Writers)) return true;
} else {
return true;
}
@ -257,8 +257,6 @@ static const GlobalValue *getUnderlyingObject(const Value *V) {
if (CE->getOpcode() == Instruction::Cast ||
CE->getOpcode() == Instruction::GetElementPtr)
return getUnderlyingObject(CE->getOperand(0));
} else if (const ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(V)) {
return CPR->getValue();
}
return 0;
}

10
lib/Analysis/ScalarEvolution.cpp
View File

@ -1498,9 +1498,9 @@ static Constant *ConstantFold(const Instruction *I,
case Instruction::Select:
return ConstantExpr::getSelect(Operands[0], Operands[1], Operands[2]);
case Instruction::Call:
if (ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(Operands[0])) {
if (Function *GV = dyn_cast<Function>(Operands[0])) {
Operands.erase(Operands.begin());
return ConstantFoldCall(cast<Function>(CPR->getValue()), Operands);
return ConstantFoldCall(cast<Function>(GV), Operands);
}
return 0;
@ -1560,9 +1560,9 @@ static PHINode *getConstantEvolvingPHI(Value *V, const Loop *L) {
/// reason, return null.
static Constant *EvaluateExpression(Value *V, Constant *PHIVal) {
if (isa<PHINode>(V)) return PHIVal;
if (Constant *C = dyn_cast<Constant>(V)) return C;
if (GlobalValue *GV = dyn_cast<GlobalValue>(V))
return ConstantPointerRef::get(GV);
return GV;
if (Constant *C = dyn_cast<Constant>(V)) return C;
Instruction *I = cast<Instruction>(V);
std::vector<Constant*> Operands;
@ -1718,8 +1718,6 @@ SCEVHandle ScalarEvolutionsImpl::getSCEVAtScope(SCEV *V, const Loop *L) {
Value *Op = I->getOperand(i);
if (Constant *C = dyn_cast<Constant>(Op)) {
Operands.push_back(C);
} else if (GlobalValue *GV = dyn_cast<GlobalValue>(Op)) {
Operands.push_back(ConstantPointerRef::get(GV));
} else {
SCEVHandle OpV = getSCEVAtScope(getSCEV(Op), L);
if (SCEVConstant *SC = dyn_cast<SCEVConstant>(OpV))

46
lib/Bytecode/Writer/SlotCalculator.cpp
View File

@ -77,8 +77,6 @@ SlotCalculator::SlotCalculator(const Function *M ) {
unsigned SlotCalculator::getGlobalSlot(const Value *V) const {
assert(!CompactionTable.empty() &&
"This method can only be used when compaction is enabled!");
if (const ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(V))
V = CPR->getValue();
std::map<const Value*, unsigned>::const_iterator I = NodeMap.find(V);
assert(I != NodeMap.end() && "Didn't find global slot entry!");
return I->second;
@ -169,17 +167,14 @@ void SlotCalculator::processModule() {
}
}
// If we are emitting a bytecode file, scan all of the functions for their
// constants, which allows us to emit more compact modules. This is optional,
// and is just used to compactify the constants used by different functions
// together.
//
// This functionality is completely optional for the bytecode writer, but
// tends to produce smaller bytecode files. This should not be used in the
// future by clients that want to, for example, build and emit functions on
// the fly. For now, however, it is unconditionally enabled when building
// bytecode information.
// Scan all of the functions for their constants, which allows us to emit
// more compact modules. This is optional, and is just used to compactify
// the constants used by different functions together.
//
// This functionality tends to produce smaller bytecode files. This should
// not be used in the future by clients that want to, for example, build and
// emit functions on the fly. For now, however, it is unconditionally
// enabled.
ModuleContainsAllFunctionConstants = true;
SC_DEBUG("Inserting function constants:\n");
@ -187,7 +182,8 @@ void SlotCalculator::processModule() {
F != E; ++F) {
for (const_inst_iterator I = inst_begin(F), E = inst_end(F); I != E; ++I){
for (unsigned op = 0, e = I->getNumOperands(); op != e; ++op)
if (isa<Constant>(I->getOperand(op)))
if (isa<Constant>(I->getOperand(op)) &&
!isa<GlobalValue>(I->getOperand(op)))
getOrCreateSlot(I->getOperand(op));
getOrCreateSlot(I->getType());
if (const VANextInst *VAN = dyn_cast<VANextInst>(&*I))
@ -265,7 +261,8 @@ void SlotCalculator::processSymbolTableConstants(const SymbolTable *ST) {
PE = ST->plane_end(); PI != PE; ++PI)
for (SymbolTable::value_const_iterator VI = PI->second.begin(),
VE = PI->second.end(); VI != VE; ++VI)
if (isa<Constant>(VI->second))
if (isa<Constant>(VI->second) &&
!isa<GlobalValue>(VI->second))
getOrCreateSlot(VI->second);
}
@ -397,8 +394,6 @@ static inline bool hasNullValue(unsigned TyID) {
/// getOrCreateCompactionTableSlot - This method is used to build up the initial
/// approximation of the compaction table.
unsigned SlotCalculator::getOrCreateCompactionTableSlot(const Value *V) {
if (const ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(V))
V = CPR->getValue();
std::map<const Value*, unsigned>::iterator I =
CompactionNodeMap.lower_bound(V);
if (I != CompactionNodeMap.end() && I->first == V)
@ -473,8 +468,7 @@ void SlotCalculator::buildCompactionTable(const Function *F) {
for (const_inst_iterator I = inst_begin(F), E = inst_end(F); I != E; ++I) {
getOrCreateCompactionTableSlot(I->getType());
for (unsigned op = 0, e = I->getNumOperands(); op != e; ++op)
if (isa<Constant>(I->getOperand(op)) ||
isa<GlobalValue>(I->getOperand(op)))
if (isa<Constant>(I->getOperand(op)))
getOrCreateCompactionTableSlot(I->getOperand(op));
if (const VANextInst *VAN = dyn_cast<VANextInst>(&*I))
getOrCreateCompactionTableSlot(VAN->getArgType());
@ -491,7 +485,7 @@ void SlotCalculator::buildCompactionTable(const Function *F) {
PE = ST.plane_end(); PI != PE; ++PI)
for (SymbolTable::value_const_iterator VI = PI->second.begin(),
VE = PI->second.end(); VI != VE; ++VI)
if (isa<Constant>(VI->second) || isa<GlobalValue>(VI->second))
if (isa<Constant>(VI->second) && !isa<GlobalValue>(VI->second))
getOrCreateCompactionTableSlot(VI->second);
// Now that we have all of the values in the table, and know what types are
@ -643,10 +637,6 @@ int SlotCalculator::getSlot(const Value *V) const {
if (I != NodeMap.end())
return (int)I->second;
// Do not number ConstantPointerRef's at all. They are an abomination.
if (const ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(V))
return getSlot(CPR->getValue());
return -1;
}
@ -674,10 +664,6 @@ int SlotCalculator::getOrCreateSlot(const Value *V) {
int SlotNo = getSlot(V); // Check to see if it's already in!
if (SlotNo != -1) return SlotNo;
// Do not number ConstantPointerRef's at all. They are an abomination.
if (const ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(V))
return getOrCreateSlot(CPR->getValue());
if (!isa<GlobalValue>(V)) // Initializers for globals are handled explicitly
if (const Constant *C = dyn_cast<Constant>(V)) {
assert(CompactionNodeMap.empty() &&
@ -720,8 +706,8 @@ int SlotCalculator::insertValue(const Value *D, bool dontIgnore) {
// insert the value into the compaction map, not into the global map.
if (!CompactionNodeMap.empty()) {
if (D->getType() == Type::VoidTy) return -1; // Do not insert void values
assert(!isa<Constant>(D) && !isa<GlobalValue>(D) &&
"Types, constants, and globals should be in global SymTab!");
assert(!isa<Constant>(D) &&
"Types, constants, and globals should be in global table!");
int Plane = getSlot(D->getType());
assert(Plane != -1 && CompactionTable.size() > (unsigned)Plane &&
@ -774,7 +760,7 @@ int SlotCalculator::insertType(const Type *Ty, bool dontIgnore) {
if (getSlot(SubTy) == -1) {
SC_DEBUG(" Inserting subtype: " << SubTy->getDescription() << "\n");
doInsertType(SubTy);
SC_DEBUG(" Inserted subtype: " << SubTy->getDescription());
SC_DEBUG(" Inserted subtype: " << SubTy->getDescription() << "\n");
}
}
}