#include "llvm/CodeGen/InstrSelectionSupport.h"
#include "llvm/CodeGen/InstrForest.h"
#include "llvm/CodeGen/MachineCodeForInstruction.h"
-#include "llvm/CodeGen/MachineCodeForBasicBlock.h"
-#include "llvm/CodeGen/MachineCodeForMethod.h"
-#include "llvm/Target/MachineRegInfo.h"
+#include "llvm/CodeGen/MachineFunction.h"
+#include "llvm/Target/TargetRegInfo.h"
#include "llvm/Target/TargetMachine.h"
#include "llvm/Function.h"
#include "llvm/iPHINode.h"
#include "llvm/Pass.h"
#include "Support/CommandLine.h"
#include "Support/LeakDetector.h"
-using std::cerr;
using std::vector;
+std::vector<MachineInstr*>
+FixConstantOperandsForInstr(Instruction* vmInstr, MachineInstr* minstr,
+ TargetMachine& target);
+
namespace {
//===--------------------------------------------------------------------===//
// SelectDebugLevel - Allow command line control over debugging.
int ruleForNode, short* nts);
public:
InstructionSelection(TargetMachine &T) : Target(T) {}
+
+ virtual void getAnalysisUsage(AnalysisUsage &AU) const {
+ AU.setPreservesCFG();
+ }
bool runOnFunction(Function &F);
};
if (SelectDebugLevel >= Select_DebugInstTrees)
{
- cerr << "\n\n*** Input to instruction selection for function "
- << F.getName() << "\n\n" << F
- << "\n\n*** Instruction trees for function "
- << F.getName() << "\n\n";
+ std::cerr << "\n\n*** Input to instruction selection for function "
+ << F.getName() << "\n\n" << F
+ << "\n\n*** Instruction trees for function "
+ << F.getName() << "\n\n";
instrForest.dump();
}
if (SelectDebugLevel >= Select_DebugBurgTrees)
{
printcover(basicNode, 1, 0);
- cerr << "\nCover cost == " << treecost(basicNode, 1, 0) << "\n\n";
+ std::cerr << "\nCover cost == " << treecost(basicNode, 1, 0) <<"\n\n";
printMatches(basicNode);
}
}
//
- // Record instructions in the vector for each basic block
+ // Create the MachineBasicBlock records and add all of the MachineInstrs
+ // defined in the MachineCodeForInstruction objects to also live in the
+ // MachineBasicBlock objects.
//
- for (Function::iterator BI = F.begin(), BE = F.end(); BI != BE; ++BI)
+ MachineFunction &MF = MachineFunction::get(&F);
+ for (Function::iterator BI = F.begin(), BE = F.end(); BI != BE; ++BI) {
+ MachineBasicBlock *MCBB = new MachineBasicBlock(BI);
+ MF.getBasicBlockList().push_back(MCBB);
+
for (BasicBlock::iterator II = BI->begin(); II != BI->end(); ++II) {
MachineCodeForInstruction &mvec = MachineCodeForInstruction::get(II);
- MachineCodeForBasicBlock &MCBB = MachineCodeForBasicBlock::get(BI);
- MCBB.insert(MCBB.end(), mvec.begin(), mvec.end());
+ MCBB->insert(MCBB->end(), mvec.begin(), mvec.end());
}
+ }
// Insert phi elimination code
InsertCodeForPhis(F);
if (SelectDebugLevel >= Select_PrintMachineCode)
{
- cerr << "\n*** Machine instructions after INSTRUCTION SELECTION\n";
- MachineCodeForMethod::get(&F).dump();
+ std::cerr << "\n*** Machine instructions after INSTRUCTION SELECTION\n";
+ MachineFunction::get(&F).dump();
}
return true;
{
// for all basic blocks in function
//
- for (Function::iterator BB = F.begin(); BB != F.end(); ++BB) {
- BasicBlock::InstListType &InstList = BB->getInstList();
- for (BasicBlock::iterator IIt = InstList.begin();
- PHINode *PN = dyn_cast<PHINode>(&*IIt); ++IIt) {
+ MachineFunction &MF = MachineFunction::get(&F);
+ for (MachineFunction::iterator BB = MF.begin(); BB != MF.end(); ++BB) {
+ for (BasicBlock::iterator IIt = BB->getBasicBlock()->begin();
+ PHINode *PN = dyn_cast<PHINode>(IIt); ++IIt) {
// FIXME: This is probably wrong...
Value *PhiCpRes = new PHINode(PN->getType(), "PhiCp:");
-
+
+ // The leak detector shouldn't track these nodes. They are not garbage,
+ // even though their parent field is never filled in.
+ //
+ LeakDetector::removeGarbageObject(PhiCpRes);
+
// for each incoming value of the phi, insert phi elimination
//
for (unsigned i = 0; i < PN->getNumIncomingValues(); ++i) {
vector<MachineInstr*> mvec;
Target.getRegInfo().cpValue2Value(PhiCpRes, PN, mvec);
-
- // get an iterator to machine instructions in the BB
- MachineCodeForBasicBlock& bbMvec = MachineCodeForBasicBlock::get(BB);
-
- bbMvec.insert(bbMvec.begin(), mvec.begin(), mvec.end());
+ BB->insert(BB->begin(), mvec.begin(), mvec.end());
} // for each Phi Instr in BB
} // for all BBs in function
}
void
InstructionSelection::InsertPhiElimInstructions(BasicBlock *BB,
- const vector<MachineInstr*>& CpVec)
+ const vector<MachineInstr*>& CpVec)
{
Instruction *TermInst = (Instruction*)BB->getTerminator();
MachineCodeForInstruction &MC4Term = MachineCodeForInstruction::get(TermInst);
MachineInstr *FirstMIOfTerm = MC4Term.front();
-
assert (FirstMIOfTerm && "No Machine Instrs for terminator");
-
- MachineCodeForBasicBlock &bbMvec = MachineCodeForBasicBlock::get(BB);
+
+ MachineFunction &MF = MachineFunction::get(BB->getParent());
+
+ // FIXME: if PHI instructions existed in the machine code, this would be
+ // unnecesary.
+ MachineBasicBlock *MBB = 0;
+ for (MachineFunction::iterator I = MF.begin(), E = MF.end(); I != E; ++I)
+ if (I->getBasicBlock() == BB) {
+ MBB = I;
+ break;
+ }
// find the position of first machine instruction generated by the
// terminator of this BB
- MachineCodeForBasicBlock::iterator MCIt =
- std::find(bbMvec.begin(), bbMvec.end(), FirstMIOfTerm);
+ MachineBasicBlock::iterator MCIt =
+ std::find(MBB->begin(), MBB->end(), FirstMIOfTerm);
- assert( MCIt != bbMvec.end() && "Start inst of terminator not found");
+ assert(MCIt != MBB->end() && "Start inst of terminator not found");
// insert the copy instructions just before the first machine instruction
// generated for the terminator
- bbMvec.insert(MCIt, CpVec.begin(), CpVec.end());
+ MBB->insert(MCIt, CpVec.begin(), CpVec.end());
}
int ruleForNode = burm_rule(treeRoot->state, goalnt);
if (ruleForNode == 0) {
- cerr << "Could not match instruction tree for instr selection\n";
+ std::cerr << "Could not match instruction tree for instr selection\n";
abort();
}
Pass *createInstructionSelectionPass(TargetMachine &T) {
return new InstructionSelection(T);
}
-
projects / oota-llvm.git / blobdiff