forked from OSchip/llvm-project
Fix: ConstantMerge/2002-09-23-CPR-Update.ll
Basically, this bug boiled down to calling replaceUsesOfWith on a constant, which changed it's shape in an illegal way. This pass now goes through all of the trouble neccesary to do the replacement on constants. llvm-svn: 3895
This commit is contained in:
parent
be4521f333
commit
28d103548d
|
@ -3,19 +3,16 @@
|
|||
// This file defines the interface to a pass that merges duplicate global
|
||||
// constants together into a single constant that is shared. This is useful
|
||||
// because some passes (ie TraceValues) insert a lot of string constants into
|
||||
// the program, regardless of whether or not they duplicate an existing string.
|
||||
// the program, regardless of whether or not an existing string is available.
|
||||
//
|
||||
// Algorithm: ConstantMerge is designed to build up a map of available constants
|
||||
// and elminate duplicates when it is initialized.
|
||||
//
|
||||
// The DynamicConstantMerge method is a superset of the ConstantMerge algorithm
|
||||
// that checks for each function to see if constants have been added to the
|
||||
// constant pool since it was last run... if so, it processes them.
|
||||
// and eliminate duplicates when it is initialized.
|
||||
//
|
||||
//===----------------------------------------------------------------------===//
|
||||
|
||||
#include "llvm/Transforms/IPO.h"
|
||||
#include "llvm/Module.h"
|
||||
#include "llvm/Constants.h"
|
||||
#include "llvm/Pass.h"
|
||||
#include "Support/StatisticReporter.h"
|
||||
|
||||
|
@ -26,9 +23,9 @@ namespace {
|
|||
//
|
||||
bool run(Module &M);
|
||||
|
||||
virtual void getAnalysisUsage(AnalysisUsage &AU) const {
|
||||
AU.preservesCFG();
|
||||
}
|
||||
private:
|
||||
void replaceUsesOfWith(GlobalVariable *Old, GlobalVariable *New);
|
||||
void replaceConstantWith(Constant *Old, Constant *New);
|
||||
};
|
||||
|
||||
Statistic<> NumMerged("constmerge\t\t- Number of global constants merged");
|
||||
|
@ -38,10 +35,6 @@ namespace {
|
|||
Pass *createConstantMergePass() { return new ConstantMerge(); }
|
||||
|
||||
|
||||
// ConstantMerge::run - Workhorse for the pass. This eliminates duplicate
|
||||
// constants, starting at global ConstantNo, and adds vars to the map if they
|
||||
// are new and unique.
|
||||
//
|
||||
bool ConstantMerge::run(Module &M) {
|
||||
std::map<Constant*, GlobalVariable*> CMap;
|
||||
bool MadeChanges = false;
|
||||
|
@ -58,7 +51,7 @@ bool ConstantMerge::run(Module &M) {
|
|||
CMap.insert(I, std::make_pair(Init, GV));
|
||||
} else { // Yup, this is a duplicate!
|
||||
// Make all uses of the duplicate constant use the cannonical version...
|
||||
GV->replaceAllUsesWith(I->second);
|
||||
replaceUsesOfWith(GV, I->second);
|
||||
|
||||
// Delete the global value from the module... and back up iterator to
|
||||
// not skip the next global...
|
||||
|
@ -71,3 +64,98 @@ bool ConstantMerge::run(Module &M) {
|
|||
|
||||
return MadeChanges;
|
||||
}
|
||||
|
||||
/// replaceUsesOfWith - Replace all uses of Old with New. For instructions,
|
||||
/// this is a really simple matter of replacing the reference to Old with a
|
||||
/// reference to New. For constants references, however, we must carefully
|
||||
/// build replacement constants to substitute in.
|
||||
///
|
||||
void ConstantMerge::replaceUsesOfWith(GlobalVariable *Old, GlobalVariable *New){
|
||||
while (!Old->use_empty()) {
|
||||
User *U = Old->use_back();
|
||||
if (ConstantPointerRef *CPR = dyn_cast<ConstantPointerRef>(U))
|
||||
replaceConstantWith(CPR, ConstantPointerRef::get(New));
|
||||
else
|
||||
U->replaceUsesOfWith(Old, New);
|
||||
}
|
||||
}
|
||||
|
||||
/// replaceWith - Ok, so we have a constant 'Old' and we want to replace it with
|
||||
/// 'New'. To do this, we have to recursively go through the uses of Old,
|
||||
/// replacing them with new things. The problem is that if a constant uses Old,
|
||||
/// then we need to replace the uses of the constant with uses of the equivalent
|
||||
/// constant that uses New instead.
|
||||
///
|
||||
void ConstantMerge::replaceConstantWith(Constant *Old, Constant *New) {
|
||||
while (!Old->use_empty()) {
|
||||
User *U = Old->use_back();
|
||||
|
||||
if (Constant *C = dyn_cast<Constant>(U)) {
|
||||
Constant *Replacement = 0;
|
||||
|
||||
// Depending on the type of constant, build a suitable replacement...
|
||||
if (ConstantExpr *CE = dyn_cast<ConstantExpr>(C)) {
|
||||
if (CE->getOpcode() == Instruction::GetElementPtr) {
|
||||
std::vector<Constant*> Indices;
|
||||
Constant *Pointer = cast<Constant>(CE->getOperand(0));
|
||||
Indices.reserve(CE->getNumOperands()-1);
|
||||
if (Pointer == Old) Pointer = New;
|
||||
|
||||
for (unsigned i = 1, e = CE->getNumOperands(); i != e; ++i) {
|
||||
Constant *Val = cast<Constant>(CE->getOperand(i));
|
||||
if (Val == Old) Val = New;
|
||||
Indices.push_back(Val);
|
||||
}
|
||||
Replacement = ConstantExpr::getGetElementPtr(Pointer, Indices);
|
||||
} else if (CE->getOpcode() == Instruction::Cast) {
|
||||
assert(CE->getOperand(0) == Old && "Cast only has one use!");
|
||||
Replacement = ConstantExpr::getCast(New, CE->getType());
|
||||
} else if (CE->getNumOperands() == 2) {
|
||||
Constant *C1 = cast<Constant>(CE->getOperand(0));
|
||||
Constant *C2 = cast<Constant>(CE->getOperand(1));
|
||||
if (C1 == Old) C1 = New;
|
||||
if (C2 == Old) C2 = New;
|
||||
Replacement = ConstantExpr::get(CE->getOpcode(), C1, C2);
|
||||
} else {
|
||||
assert(0 && "Unknown ConstantExpr type!");
|
||||
}
|
||||
|
||||
|
||||
} else if (ConstantArray *CA = dyn_cast<ConstantArray>(C)) {
|
||||
std::vector<Constant*> Values;
|
||||
Values.reserve(CA->getValues().size());
|
||||
for (unsigned i = 0, e = CA->getValues().size(); i != e; ++i) {
|
||||
Constant *Val = cast<Constant>(CA->getValues()[i]);
|
||||
if (Val == Old) Val = New;
|
||||
Values.push_back(Val);
|
||||
}
|
||||
|
||||
Replacement = ConstantArray::get(CA->getType(), Values);
|
||||
} else if (ConstantStruct *CS = dyn_cast<ConstantStruct>(C)) {
|
||||
std::vector<Constant*> Values;
|
||||
Values.reserve(CS->getValues().size());
|
||||
|
||||
for (unsigned i = 0, e = CS->getValues().size(); i != e; ++i) {
|
||||
Constant *Val = cast<Constant>(CS->getValues()[i]);
|
||||
if (Val == Old) Val = New;
|
||||
Values.push_back(Val);
|
||||
}
|
||||
|
||||
Replacement = ConstantStruct::get(CS->getType(), Values);
|
||||
} else {
|
||||
assert(0 && "Unexpected/unknown constant type!");
|
||||
}
|
||||
|
||||
// Now that we have a suitable replacement, recursively eliminate C.
|
||||
replaceConstantWith(C, Replacement);
|
||||
|
||||
} else {
|
||||
// If it is not a constant, we can simply replace uses of Old with New.
|
||||
U->replaceUsesOfWith(Old, New);
|
||||
}
|
||||
|
||||
}
|
||||
|
||||
// No-one refers to this old dead constant now, destroy it!
|
||||
Old->destroyConstant();
|
||||
}
|
||||
|
|
Loading…
Reference in New Issue