-//===- InstrSelection.cpp - Machine Independant Inst Selection Driver -----===//
+//===- InstrSelection.cpp - Machine Independent Inst Selection Driver -----===//
+//
+// The LLVM Compiler Infrastructure
+//
+// This file was developed by the LLVM research group and is distributed under
+// the University of Illinois Open Source License. See LICENSE.TXT for details.
+//
+//===----------------------------------------------------------------------===//
//
// Machine-independent driver file for instruction selection. This file
// constructs a forest of BURG instruction trees and then uses the
#include "llvm/CodeGen/InstrForest.h"
#include "llvm/CodeGen/MachineCodeForInstruction.h"
#include "llvm/CodeGen/MachineFunction.h"
-#include "llvm/Target/MachineRegInfo.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.
}
bool runOnFunction(Function &F);
+ virtual const char *getPassName() const { return "Instruction Selection"; }
};
}
-// Register the pass...
-static RegisterLLC<InstructionSelection>
-X("instselect", "Instruction Selection", createInstructionSelectionPass);
+TmpInstruction::TmpInstruction(MachineCodeForInstruction& mcfi,
+ Value *s1, Value *s2, const std::string &name)
+ : Instruction(s1->getType(), Instruction::UserOp1, name)
+{
+ mcfi.addTemp(this);
-TmpInstruction::TmpInstruction(Value *s1, Value *s2, const std::string &name)
- : Instruction(s1->getType(), Instruction::UserOp1, name) {
- Operands.push_back(Use(s1, this)); // s1 must be nonnull
+ Operands.push_back(Use(s1, this)); // s1 must be non-null
if (s2) {
Operands.push_back(Use(s2, this));
}
// Constructor that requires the type of the temporary to be specified.
// Both S1 and S2 may be NULL.(
-TmpInstruction::TmpInstruction(const Type *Ty, Value *s1, Value* s2,
+TmpInstruction::TmpInstruction(MachineCodeForInstruction& mcfi,
+ const Type *Ty, Value *s1, Value* s2,
const std::string &name)
- : Instruction(Ty, Instruction::UserOp1, name) {
+ : Instruction(Ty, Instruction::UserOp1, name)
+{
+ mcfi.addTemp(this);
+
if (s1) { Operands.push_back(Use(s1, this)); }
if (s2) { Operands.push_back(Use(s2, this)); }
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);
}
if (SelectDebugLevel >= Select_PrintMachineCode)
{
- cerr << "\n*** Machine instructions after INSTRUCTION SELECTION\n";
+ std::cerr << "\n*** Machine instructions after INSTRUCTION SELECTION\n";
MachineFunction::get(&F).dump();
}
//
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) {
+ for (BasicBlock::const_iterator IIt = BB->getBasicBlock()->begin();
+ const PHINode *PN = dyn_cast<PHINode>(IIt); ++IIt) {
// FIXME: This is probably wrong...
Value *PhiCpRes = new PHINode(PN->getType(), "PhiCp:");
for (vector<MachineInstr*>::iterator MI=mvec.begin();
MI != mvec.end(); ++MI) {
vector<MachineInstr*> CpVec2 =
- FixConstantOperandsForInstr(PN, *MI, Target);
+ FixConstantOperandsForInstr(const_cast<PHINode*>(PN), *MI, Target);
CpVec2.push_back(*MI);
CpVec.insert(CpVec.end(), CpVec2.begin(), CpVec2.end());
}
}
vector<MachineInstr*> mvec;
- Target.getRegInfo().cpValue2Value(PhiCpRes, PN, mvec);
+ Target.getRegInfo().cpValue2Value(PhiCpRes, const_cast<PHINode*>(PN),
+ mvec);
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);
assert (FirstMIOfTerm && "No Machine Instrs for terminator");
MachineFunction &MF = MachineFunction::get(BB->getParent());
- MachineBasicBlock *MBB;
// FIXME: if PHI instructions existed in the machine code, this would be
- // unnecesary.
+ // unnecessary.
+ MachineBasicBlock *MBB = 0;
for (MachineFunction::iterator I = MF.begin(), E = MF.end(); I != E; ++I)
if (I->getBasicBlock() == BB) {
MBB = I;
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();
}
}
}
- // Finally, do any postprocessing on this node after its children
+ // Finally, do any post-processing on this node after its children
// have been translated
//
if (treeRoot->opLabel != VRegListOp)
// createInstructionSelectionPass - Public entrypoint for instruction selection
// and this file as a whole...
//
-Pass *createInstructionSelectionPass(TargetMachine &T) {
+FunctionPass *createInstructionSelectionPass(TargetMachine &T) {
return new InstructionSelection(T);
}
-