#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.
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();
}
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);
}
-
// If there are no indices, return the current pointer.
// Else extract the pointer from the GEP and fold the indices.
- return (gepNode)? GetGEPInstArgs(gepNode, idxVec, allConstantIndices)
- : ptrVal;
+ return gepNode ? GetGEPInstArgs(gepNode, idxVec, allConstantIndices)
+ : ptrVal;
}
MachineOperand::MachineOperandType
}
+
//---------------------------------------------------------------------------
// Function: FixConstantOperandsForInstr
//
MachineInstr* minstr,
TargetMachine& target)
{
- vector<MachineInstr*> loadConstVec;
+ vector<MachineInstr*> MVec;
MachineOpCode opCode = minstr->getOpCode();
const TargetInstrInfo& instrInfo = target.getInstrInfo();
if (mop.getType() == MachineOperand::MO_VirtualRegister)
{
assert(mop.getVRegValue() != NULL);
- opValue = mop.getVRegValue();
- if (Constant *opConst = dyn_cast<Constant>(opValue))
- {
- opType = ChooseRegOrImmed(opConst, opCode, target,
- (immedPos == (int)op), machineRegNum, immedValue);
- if (opType == MachineOperand::MO_VirtualRegister)
- constantThatMustBeLoaded = true;
- }
+ if (Constant *opConst = dyn_cast<Constant>(mop.getVRegValue())) {
+ opType = ChooseRegOrImmed(opConst, opCode, target,
+ (immedPos == (int)op), machineRegNum,
+ immedValue);
+ if (opType == MachineOperand::MO_VirtualRegister)
+ constantThatMustBeLoaded = true;
+ }
}
else
{
- assert(mop.getType() == MachineOperand::MO_SignExtendedImmed ||
- mop.getType() == MachineOperand::MO_UnextendedImmed);
-
- bool isSigned = (mop.getType() ==
- MachineOperand::MO_SignExtendedImmed);
+ assert(mop.isImmediate());
+ bool isSigned = mop.getType() == MachineOperand::MO_SignExtendedImmed;
// Bit-selection flags indicate an instruction that is extracting
// bits from its operand so ignore this even if it is a big constant.
{ // opValue is a constant that must be explicitly loaded into a reg
assert(opValue);
TmpInstruction* tmpReg = InsertCodeToLoadConstant(F, opValue, vmInstr,
- loadConstVec, target);
+ MVec, target);
minstr->SetMachineOperandVal(op, MachineOperand::MO_VirtualRegister,
tmpReg);
}
{
Value* oldVal = minstr->getImplicitRef(i);
TmpInstruction* tmpReg =
- InsertCodeToLoadConstant(F, oldVal, vmInstr, loadConstVec, target);
+ InsertCodeToLoadConstant(F, oldVal, vmInstr, MVec, target);
minstr->setImplicitRef(i, tmpReg);
if (isCall)
}
}
- return loadConstVec;
+ return MVec;
}
-
-
#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.
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();
}
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);
}
-
// If there are no indices, return the current pointer.
// Else extract the pointer from the GEP and fold the indices.
- return (gepNode)? GetGEPInstArgs(gepNode, idxVec, allConstantIndices)
- : ptrVal;
+ return gepNode ? GetGEPInstArgs(gepNode, idxVec, allConstantIndices)
+ : ptrVal;
}
MachineOperand::MachineOperandType
}
+
//---------------------------------------------------------------------------
// Function: FixConstantOperandsForInstr
//
MachineInstr* minstr,
TargetMachine& target)
{
- vector<MachineInstr*> loadConstVec;
+ vector<MachineInstr*> MVec;
MachineOpCode opCode = minstr->getOpCode();
const TargetInstrInfo& instrInfo = target.getInstrInfo();
if (mop.getType() == MachineOperand::MO_VirtualRegister)
{
assert(mop.getVRegValue() != NULL);
- opValue = mop.getVRegValue();
- if (Constant *opConst = dyn_cast<Constant>(opValue))
- {
- opType = ChooseRegOrImmed(opConst, opCode, target,
- (immedPos == (int)op), machineRegNum, immedValue);
- if (opType == MachineOperand::MO_VirtualRegister)
- constantThatMustBeLoaded = true;
- }
+ if (Constant *opConst = dyn_cast<Constant>(mop.getVRegValue())) {
+ opType = ChooseRegOrImmed(opConst, opCode, target,
+ (immedPos == (int)op), machineRegNum,
+ immedValue);
+ if (opType == MachineOperand::MO_VirtualRegister)
+ constantThatMustBeLoaded = true;
+ }
}
else
{
- assert(mop.getType() == MachineOperand::MO_SignExtendedImmed ||
- mop.getType() == MachineOperand::MO_UnextendedImmed);
-
- bool isSigned = (mop.getType() ==
- MachineOperand::MO_SignExtendedImmed);
+ assert(mop.isImmediate());
+ bool isSigned = mop.getType() == MachineOperand::MO_SignExtendedImmed;
// Bit-selection flags indicate an instruction that is extracting
// bits from its operand so ignore this even if it is a big constant.
{ // opValue is a constant that must be explicitly loaded into a reg
assert(opValue);
TmpInstruction* tmpReg = InsertCodeToLoadConstant(F, opValue, vmInstr,
- loadConstVec, target);
+ MVec, target);
minstr->SetMachineOperandVal(op, MachineOperand::MO_VirtualRegister,
tmpReg);
}
{
Value* oldVal = minstr->getImplicitRef(i);
TmpInstruction* tmpReg =
- InsertCodeToLoadConstant(F, oldVal, vmInstr, loadConstVec, target);
+ InsertCodeToLoadConstant(F, oldVal, vmInstr, MVec, target);
minstr->setImplicitRef(i, tmpReg);
if (isCall)
}
}
- return loadConstVec;
+ return MVec;
}
-
-