[llvm-commits] CVS: llvm/lib/Transforms/IPO/ConstantMerge.cpp
Chris Lattner
lattner at cs.uiuc.edu
Mon Sep 23 18:01:00 PDT 2002
Changes in directory llvm/lib/Transforms/IPO:
ConstantMerge.cpp updated: 1.15 -> 1.16
---
Log message:
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.
---
Diffs of the changes:
Index: llvm/lib/Transforms/IPO/ConstantMerge.cpp
diff -u llvm/lib/Transforms/IPO/ConstantMerge.cpp:1.15 llvm/lib/Transforms/IPO/ConstantMerge.cpp:1.16
--- llvm/lib/Transforms/IPO/ConstantMerge.cpp:1.15 Fri Jul 26 16:12:33 2002
+++ llvm/lib/Transforms/IPO/ConstantMerge.cpp Mon Sep 23 18:00:46 2002
@@ -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 @@
//
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 @@
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 @@
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...
@@ -70,4 +63,99 @@
}
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();
}
More information about the llvm-commits
mailing list