diff options
author | Reid Spencer <rspencer@reidspencer.com> | 2004-07-17 23:47:01 +0000 |
---|---|---|
committer | Reid Spencer <rspencer@reidspencer.com> | 2004-07-17 23:47:01 +0000 |
commit | 7970396014eacbe719eb171448ddc546c1ad2289 (patch) | |
tree | 986259afb363bd829d948f52a717608226f3c320 /lib/VMCore | |
parent | 31c0da448336754be34fcb7fe4ce4c08208bb03c (diff) | |
download | external_llvm-7970396014eacbe719eb171448ddc546c1ad2289.zip external_llvm-7970396014eacbe719eb171448ddc546c1ad2289.tar.gz external_llvm-7970396014eacbe719eb171448ddc546c1ad2289.tar.bz2 |
bug 122:
- 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@14927 91177308-0d34-0410-b5e6-96231b3b80d8
Diffstat (limited to 'lib/VMCore')
-rw-r--r-- | lib/VMCore/AsmWriter.cpp | 42 | ||||
-rw-r--r-- | lib/VMCore/ConstantFold.cpp | 43 |
2 files changed, 39 insertions, 46 deletions
diff --git a/lib/VMCore/AsmWriter.cpp b/lib/VMCore/AsmWriter.cpp index 0f76712..47b4cc8 100644 --- a/lib/VMCore/AsmWriter.cpp +++ b/lib/VMCore/AsmWriter.cpp @@ -381,6 +381,7 @@ std::ostream &llvm::WriteTypeSymbolic(std::ostream &Out, const Type *Ty, } } +/// @brief Internal constant writer. static void WriteConstantInt(std::ostream &Out, const Constant *CV, bool PrintName, std::map<const Type *, std::string> &TypeTable, @@ -493,9 +494,6 @@ static void WriteConstantInt(std::ostream &Out, const Constant *CV, } else if (isa<ConstantPointerNull>(CV)) { Out << "null"; - } else if (const ConstantPointerRef *PR = dyn_cast<ConstantPointerRef>(CV)) { - WriteAsOperandInternal(Out, PR->getValue(), true, TypeTable, Machine); - } else if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(CV)) { Out << CE->getOpcodeName() << " ("; @@ -527,12 +525,13 @@ static void WriteAsOperandInternal(std::ostream &Out, const Value *V, std::map<const Type*, std::string> &TypeTable, SlotMachine *Machine) { Out << ' '; - if (PrintName && V->hasName()) { + if ((PrintName || isa<GlobalValue>(V)) && V->hasName()) Out << getLLVMName(V->getName()); - } else { - if (const Constant *CV = dyn_cast<Constant>(V)) { + else { + const Constant *CV = dyn_cast<Constant>(V); + if (CV && !isa<GlobalValue>(CV)) WriteConstantInt(Out, CV, PrintName, TypeTable, Machine); - } else { + else { int Slot; if (Machine) { Slot = Machine->getSlot(V); @@ -764,8 +763,14 @@ void AssemblyWriter::printGlobal(const GlobalVariable *GV) { Out << (GV->isConstant() ? "constant " : "global "); printType(GV->getType()->getElementType()); - if (GV->hasInitializer()) - writeOperand(GV->getInitializer(), false, false); + if (GV->hasInitializer()) { + Constant* C = cast<Constant>(GV->getInitializer()); + assert(C && "GlobalVar initializer isn't constant?"); + if (isa<GlobalValue>(C)) + writeOperand(GV->getInitializer(), false, true); + else + writeOperand(GV->getInitializer(), false, false); + } printInfoComment(*GV); Out << "\n"; @@ -794,8 +799,9 @@ void AssemblyWriter::printSymbolTable(const SymbolTable &ST) { SymbolTable::value_const_iterator VE = ST.value_end(PI->first); for (; VI != VE; ++VI) { - const Value *V = VI->second; - if (const Constant *CPV = dyn_cast<Constant>(V)) { + const Value* V = VI->second; + const Constant *CPV = dyn_cast<Constant>(V) ; + if (CPV && !isa<GlobalValue>(V)) { printConstant(CPV); } } @@ -1162,12 +1168,6 @@ void Instruction::print(std::ostream &o, AssemblyAnnotationWriter *AAW) const { void Constant::print(std::ostream &o) const { if (this == 0) { o << "<null> constant value\n"; return; } - // Handle CPR's special, because they have context information... - if (const ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(this)) { - CPR->getValue()->print(o); // Print as a global value, with context info. - return; - } - o << ' ' << getType()->getDescription() << ' '; std::map<const Type *, std::string> TypeTable; @@ -1347,10 +1347,6 @@ int SlotMachine::getSlot(const Value *V) { // Check for uninitialized state and do lazy initialization this->initialize(); - // Do not number CPR's at all. They are an abomination - if ( const ConstantPointerRef* CPR = dyn_cast<ConstantPointerRef>(V) ) - V = CPR->getValue() ; - // Get the type of the value const Type* VTy = V->getType(); @@ -1593,8 +1589,8 @@ unsigned SlotMachine::insertValue(const Value *V ) { SC_DEBUG(" Inserting value [" << VTy << "] = " << V << " slot=" << DestSlot << " ["); // G = Global, C = Constant, T = Type, F = Function, o = other - SC_DEBUG((isa<GlobalVariable>(V) ? 'G' : (isa<Constant>(V) ? 'C' : - (isa<Function>(V) ? 'F' : 'o')))); + SC_DEBUG((isa<GlobalVariable>(V) ? 'G' : (isa<Function>(V) ? 'F' : + (isa<Constant>(V) ? 'C' : 'o')))); SC_DEBUG("]\n"); return DestSlot; } diff --git a/lib/VMCore/ConstantFold.cpp b/lib/VMCore/ConstantFold.cpp index e42de2a..2a96291 100644 --- a/lib/VMCore/ConstantFold.cpp +++ b/lib/VMCore/ConstantFold.cpp @@ -486,7 +486,7 @@ ConstRules &ConstRules::get(const Constant *V1, const Constant *V2) { static DirectFPRules <ConstantFP , double , &Type::DoubleTy> DoubleR; if (isa<ConstantExpr>(V1) || isa<ConstantExpr>(V2) || - isa<ConstantPointerRef>(V1) || isa<ConstantPointerRef>(V2)) + isa<GlobalValue>(V1) || isa<GlobalValue>(V2)) return EmptyR; switch (V1->getType()->getTypeID()) { @@ -525,12 +525,12 @@ Constant *llvm::ConstantFoldCastInstruction(const Constant *V, if (V->getType() == DestTy) return (Constant*)V; // Cast of a global address to boolean is always true. - if (const ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(V)) + if (const GlobalValue *GV = dyn_cast<GlobalValue>(V)) if (DestTy == Type::BoolTy) // FIXME: When we support 'external weak' references, we have to prevent // this transformation from happening. In the meantime we avoid folding // any cast of an external symbol. - if (!CPR->getValue()->isExternal()) + if (!GV->isExternal()) return ConstantBool::True; if (const ConstantExpr *CE = dyn_cast<ConstantExpr>(V)) @@ -624,15 +624,15 @@ static int IdxCompare(Constant *C1, Constant *C2) { /// evaluateRelation - This function determines if there is anything we can /// decide about the two constants provided. This doesn't need to handle simple -/// things like integer comparisons, but should instead handle ConstantExpr's -/// and ConstantPointerRef's. If we can determine that the two constants have a +/// things like integer comparisons, but should instead handle ConstantExprs +/// and GlobalValuess. If we can determine that the two constants have a /// particular relation to each other, we should return the corresponding SetCC /// code, otherwise return Instruction::BinaryOpsEnd. /// /// To simplify this code we canonicalize the relation so that the first /// operand is always the most "complex" of the two. We consider simple /// constants (like ConstantInt) to be the simplest, followed by -/// ConstantPointerRef's, followed by ConstantExpr's (the most complex). +/// GlobalValues, followed by ConstantExpr's (the most complex). /// static Instruction::BinaryOps evaluateRelation(const Constant *V1, const Constant *V2) { @@ -640,15 +640,15 @@ static Instruction::BinaryOps evaluateRelation(const Constant *V1, "Cannot compare different types of values!"); if (V1 == V2) return Instruction::SetEQ; - if (!isa<ConstantExpr>(V1) && !isa<ConstantPointerRef>(V1)) { + if (!isa<ConstantExpr>(V1) && !isa<GlobalValue>(V1)) { // If the first operand is simple, swap operands. - assert((isa<ConstantPointerRef>(V2) || isa<ConstantExpr>(V2)) && + assert((isa<GlobalValue>(V2) || isa<ConstantExpr>(V2)) && "Simple cases should have been handled by caller!"); Instruction::BinaryOps SwappedRelation = evaluateRelation(V2, V1); if (SwappedRelation != Instruction::BinaryOpsEnd) return SetCondInst::getSwappedCondition(SwappedRelation); - } else if (const ConstantPointerRef *CPR1 = dyn_cast<ConstantPointerRef>(V1)){ + } else if (const GlobalValue *CPR1 = dyn_cast<GlobalValue>(V1)){ if (isa<ConstantExpr>(V2)) { // Swap as necessary. Instruction::BinaryOps SwappedRelation = evaluateRelation(V2, V1); if (SwappedRelation != Instruction::BinaryOpsEnd) @@ -657,11 +657,11 @@ static Instruction::BinaryOps evaluateRelation(const Constant *V1, return Instruction::BinaryOpsEnd; } - // Now we know that the RHS is a ConstantPointerRef or simple constant, + // Now we know that the RHS is a GlobalValue or simple constant, // which (since the types must match) means that it's a ConstantPointerNull. - if (const ConstantPointerRef *CPR2 = dyn_cast<ConstantPointerRef>(V2)) { - assert(CPR1->getValue() != CPR2->getValue() && - "CPRs for the same value exist at different addresses??"); + if (const GlobalValue *CPR2 = dyn_cast<GlobalValue>(V2)) { + assert(CPR1 != CPR2 && + "GVs for the same value exist at different addresses??"); // FIXME: If both globals are external weak, they might both be null! return Instruction::SetNE; } else { @@ -693,7 +693,7 @@ static Instruction::BinaryOps evaluateRelation(const Constant *V1, if (isa<ConstantPointerNull>(V2)) { // If we are comparing a GEP to a null pointer, check to see if the base // of the GEP equals the null pointer. - if (isa<ConstantPointerRef>(CE1Op0)) { + if (isa<GlobalValue>(CE1Op0)) { // FIXME: this is not true when we have external weak references! // No offset can go from a global to a null pointer. return Instruction::SetGT; @@ -708,13 +708,11 @@ static Instruction::BinaryOps evaluateRelation(const Constant *V1, return Instruction::SetEQ; } // Otherwise, we can't really say if the first operand is null or not. - } else if (const ConstantPointerRef *CPR2 = - dyn_cast<ConstantPointerRef>(V2)) { + } else if (const GlobalValue *CPR2 = dyn_cast<GlobalValue>(V2)) { if (isa<ConstantPointerNull>(CE1Op0)) { // FIXME: This is not true with external weak references. return Instruction::SetLT; - } else if (const ConstantPointerRef *CPR1 = - dyn_cast<ConstantPointerRef>(CE1Op0)) { + } else if (const GlobalValue *CPR1 = dyn_cast<GlobalValue>(CE1Op0)) { if (CPR1 == CPR2) { // If this is a getelementptr of the same global, then it must be // different. Because the types must match, the getelementptr could @@ -741,8 +739,7 @@ static Instruction::BinaryOps evaluateRelation(const Constant *V1, case Instruction::GetElementPtr: // By far the most common case to handle is when the base pointers are // obviously to the same or different globals. - if (isa<ConstantPointerRef>(CE1Op0) && - isa<ConstantPointerRef>(CE2Op0)) { + if (isa<GlobalValue>(CE1Op0) && isa<GlobalValue>(CE2Op0)) { if (CE1Op0 != CE2Op0) // Don't know relative ordering, but not equal return Instruction::SetNE; // Ok, we know that both getelementptr instructions are based on the @@ -896,13 +893,13 @@ Constant *llvm::ConstantFoldBinaryInstruction(unsigned Opcode, return const_cast<Constant*>(V1); // X & -1 == X if (V2->isNullValue()) return const_cast<Constant*>(V2); // X & 0 == 0 if (CE1->getOpcode() == Instruction::Cast && - isa<ConstantPointerRef>(CE1->getOperand(0))) { - ConstantPointerRef *CPR =cast<ConstantPointerRef>(CE1->getOperand(0)); + isa<GlobalValue>(CE1->getOperand(0))) { + GlobalValue *CPR =cast<GlobalValue>(CE1->getOperand(0)); // Functions are at least 4-byte aligned. If and'ing the address of a // function with a constant < 4, fold it to zero. if (const ConstantInt *CI = dyn_cast<ConstantInt>(V2)) - if (CI->getRawValue() < 4 && isa<Function>(CPR->getValue())) + if (CI->getRawValue() < 4 && isa<Function>(CPR)) return Constant::getNullValue(CI->getType()); } break; |