maxjhandsome
/
llvm-project
forked from OSchip/llvm-project
1
0
Fork 0
Code Issues Pull Requests Packages Releases Wiki Activity

Separate const from non-const stuff during mergeing 

llvm-svn: 100642
This commit is contained in:
Anton Korobeynikov 2010-04-07 18:19:13 +00:00
parent 0453de0133
commit 10fc6e9650
1 changed files with 35 additions and 21 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

56
llvm/lib/Target/ARM/ARMGlobalMerge.cpp
View File

@ -30,8 +30,7 @@ namespace {
/// TLI - Keep a pointer of a TargetLowering to consult for determining /// TLI - Keep a pointer of a TargetLowering to consult for determining
/// target type sizes. /// target type sizes.
const TargetLowering *TLI; const TargetLowering *TLI;
bool doMerge(std::vector<GlobalVariable*> &Globals, Module &M, bool) const;
std::vector<GlobalVariable*> InternalGlobals;
public: public:
static char ID; // Pass identification, replacement for typeid. static char ID; // Pass identification, replacement for typeid.
@ -72,41 +71,30 @@ char ARMGlobalMerge::ID = 0;
#define MAX_OFFSET 4095 #define MAX_OFFSET 4095
bool ARMGlobalMerge::doInitialization(Module& M) { bool ARMGlobalMerge::doMerge(std::vector<GlobalVariable*> &Globals,
Module &M, bool isConst) const {
const TargetData *TD = TLI->getTargetData(); const TargetData *TD = TLI->getTargetData();
for (Module::global_iterator I = M.global_begin(),
E = M.global_end(); I != E; ++I) {
// FIXME: Can we just grab all 'local' vars here?
// Won't we break some semantics?
if (I->hasInternalLinkage() &&
TD->getTypeAllocSize(I->getType()) < MAX_OFFSET)
InternalGlobals.push_back(I);
}
// FIXME: Find better heuristics // FIXME: Find better heuristics
std::stable_sort(InternalGlobals.begin(), InternalGlobals.end(), std::stable_sort(Globals.begin(), Globals.end(), GlobalCmp(TD));
GlobalCmp(TD));
const Type *Int32Ty = Type::getInt32Ty(M.getContext()); const Type *Int32Ty = Type::getInt32Ty(M.getContext());
for (size_t i = 0, e = InternalGlobals.size(); i != e; ) { for (size_t i = 0, e = Globals.size(); i != e; ) {
size_t j = 0; size_t j = 0;
uint64_t MergedSize = 0; uint64_t MergedSize = 0;
std::vector<const Type*> Tys; std::vector<const Type*> Tys;
std::vector<Constant*> Inits; std::vector<Constant*> Inits;
for (j = i; MergedSize < MAX_OFFSET && j != e; ++j) { for (j = i; MergedSize < MAX_OFFSET && j != e; ++j) {
const Type* Ty = const Type* Ty = Globals[j]->getType()->getElementType();
cast<PointerType>(InternalGlobals[j]->getType())->getElementType();
Tys.push_back(Ty); Tys.push_back(Ty);
Inits.push_back(InternalGlobals[j]->getInitializer()); Inits.push_back(Globals[j]->getInitializer());
MergedSize += TD->getTypeAllocSize(Ty); MergedSize += TD->getTypeAllocSize(Ty);
} }
StructType* MergedTy = StructType::get(M.getContext(), Tys); StructType* MergedTy = StructType::get(M.getContext(), Tys);
Constant* MergedInit = ConstantStruct::get(MergedTy, Inits); Constant* MergedInit = ConstantStruct::get(MergedTy, Inits);
// FIXME: Should we handle constants and 'normal' globals separately? GlobalVariable* MergedGV = new GlobalVariable(M, MergedTy, isConst,
GlobalVariable* MergedGV = new GlobalVariable(M, MergedTy, false,
GlobalValue::InternalLinkage, GlobalValue::InternalLinkage,
MergedInit, "merged"); MergedInit, "merged");
for (size_t k = i; k < j; ++k) { for (size_t k = i; k < j; ++k) {
@ -118,7 +106,8 @@ bool ARMGlobalMerge::doInitialization(Module& M) {
ConstantExpr::getInBoundsGetElementPtr(MergedGV, ConstantExpr::getInBoundsGetElementPtr(MergedGV,
&Idx[0], Idx.size()); &Idx[0], Idx.size());
InternalGlobals[k]->replaceAllUsesWith(GEP); Globals[k]->replaceAllUsesWith(GEP);
Globals[k]->eraseFromParent();
} }
i = j; i = j;
} }
@ -126,6 +115,31 @@ bool ARMGlobalMerge::doInitialization(Module& M) {
return true; return true;
} }
bool ARMGlobalMerge::doInitialization(Module& M) {
std::vector<GlobalVariable*> Globals, ConstGlobals;
bool Changed = false;
const TargetData *TD = TLI->getTargetData();
// Grab all non-const globals.
for (Module::global_iterator I = M.global_begin(),
E = M.global_end(); I != E; ++I) {
// Ignore fancy-aligned globals for now.
if (I->hasLocalLinkage() && I->getAlignment() == 0 &&
TD->getTypeAllocSize(I->getType()) < MAX_OFFSET) {
if (I->isConstant())
ConstGlobals.push_back(I);
else
Globals.push_back(I);
}
}
Changed |= doMerge(Globals, M, false);
Changed |= doMerge(ConstGlobals, M, true);
return Changed;
}
bool ARMGlobalMerge::runOnFunction(Function& F) { bool ARMGlobalMerge::runOnFunction(Function& F) {
return false; return false;
} }