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

One real change - don't hoist something that's trivially rematerializable. It's

Browse Source 
possible for it to produce worse code than before.

The rest of this patch is code cleanup.


git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@50987 91177308-0d34-0410-b5e6-96231b3b80d8
This commit is contained in:
Bill Wendling 2008-05-12 19:38:32 +00:00
parent 6fd90ce2ee
commit e4fc1ccd4d
1 changed files with 19 additions and 18 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

37
lib/CodeGen/MachineLICM.cpp
View File

@ -34,16 +34,16 @@ namespace {
class VISIBILITY_HIDDEN MachineLICM : public MachineFunctionPass {
const TargetMachine *TM;
const TargetInstrInfo *TII;
MachineFunction *CurMF; // Current MachineFunction
MachineFunction *CurMF; // Current MachineFunction
// Various analyses that we use...
MachineLoopInfo *LI; // Current MachineLoopInfo
MachineDominatorTree *DT; // Machine dominator tree for the current Loop
MachineLoopInfo *LI; // Current MachineLoopInfo
MachineDominatorTree *DT; // Machine dominator tree for the cur loop
MachineRegisterInfo *RegInfo; // Machine register information
// State that is updated as we process loops
bool Changed; // True if a loop is changed.
MachineLoop *CurLoop; // The current loop we are working on.
bool Changed; // True if a loop is changed.
MachineLoop *CurLoop; // The current loop we are working on.
public:
static char ID; // Pass identification, replacement for typeid
MachineLICM() : MachineFunctionPass((intptr_t)&ID) {}
@ -233,15 +233,14 @@ bool MachineLICM::IsLoopInvariantInst(MachineInstr &I) {
return false;
if (TID.mayLoad()) {
// Okay, this instruction does a load. As a refinement, allow the target
// to decide whether the loaded value is actually a constant. If so, we
// can actually use it as a load.
if (!TII->isInvariantLoad(&I)) {
// Okay, this instruction does a load. As a refinement, we allow the target
// to decide whether the loaded value is actually a constant. If so, we can
// actually use it as a load.
if (!TII->isInvariantLoad(&I))
// FIXME: we should be able to sink loads with no other side effects if
// there is nothing that can change memory from here until the end of
// block. This is a trivial form of alias analysis.
// block. This is a trivial form of alias analysis.
return false;
}
}
DEBUG({
@ -263,12 +262,9 @@ bool MachineLICM::IsLoopInvariantInst(MachineInstr &I) {
*ImpDefs; ++ImpDefs)
DOUT << " -> " << TRI->getName(*ImpDefs) << "\n";
}
//if (TII->hasUnmodelledSideEffects(&I))
//DOUT << " * Instruction has side effects.\n";
});
// The instruction is loop invariant if all of its operands are loop-invariant
// The instruction is loop invariant if all of its operands are.
for (unsigned i = 0, e = I.getNumOperands(); i != e; ++i) {
const MachineOperand &MO = I.getOperand(i);
@ -282,7 +278,8 @@ bool MachineLICM::IsLoopInvariantInst(MachineInstr &I) {
if (TargetRegisterInfo::isPhysicalRegister(Reg))
return false;
assert(RegInfo->getVRegDef(Reg)&&"Machine instr not mapped for this vreg?");
assert(RegInfo->getVRegDef(Reg) &&
"Machine instr not mapped for this vreg?!");
// If the loop contains the definition of an operand, then the instruction
// isn't loop invariant.
@ -294,12 +291,16 @@ bool MachineLICM::IsLoopInvariantInst(MachineInstr &I) {
return true;
}
/// Hoist - When an instruction is found to only use loop invariant operands
/// that is safe to hoist, this instruction is called to do the dirty work.
/// Hoist - When an instruction is found to use only loop invariant operands
/// that are safe to hoist, this instruction is called to do the dirty work.
///
void MachineLICM::Hoist(MachineInstr &MI) {
if (!IsLoopInvariantInst(MI)) return;
// Hoisting things that are trivially rematerializable may result in worse
// code than before.
if (TII->isTriviallyReMaterializable(&MI)) return;
std::vector<MachineBasicBlock*> Preds;
// Non-back-edge predecessors.