llvm-project/llvm/lib/CodeGen/MachineInstr.cpp

173 lines
4.6 KiB
C++
Raw Normal View History

// $Id$
//***************************************************************************
// File:
// MachineInstr.cpp
//
// Purpose:
//
//
// Strategy:
//
// History:
// 7/2/01 - Vikram Adve - Created
//**************************************************************************/
#include "llvm/CodeGen/MachineInstr.h"
#include "llvm/Value.h"
#include <iostream>
using std::cerr;
//************************ Class Implementations **************************/
// Constructor for instructions with fixed #operands (nearly all)
MachineInstr::MachineInstr(MachineOpCode _opCode,
OpCodeMask _opCodeMask)
: opCode(_opCode),
opCodeMask(_opCodeMask),
operands(TargetInstrDescriptors[_opCode].numOperands)
{
assert(TargetInstrDescriptors[_opCode].numOperands >= 0);
}
// Constructor for instructions with variable #operands
MachineInstr::MachineInstr(MachineOpCode _opCode,
unsigned numOperands,
OpCodeMask _opCodeMask)
: opCode(_opCode),
opCodeMask(_opCodeMask),
operands(numOperands)
{
}
void
MachineInstr::SetMachineOperandVal(unsigned int i,
MachineOperand::MachineOperandType operandType,
Value* _val, bool isdef=false)
{
assert(i < operands.size());
operands[i].Initialize(operandType, _val);
operands[i].isDef = isdef ||
2001-09-18 20:56:28 +08:00
TargetInstrDescriptors[opCode].resultPos == (int) i;
}
void
MachineInstr::SetMachineOperandConst(unsigned int i,
MachineOperand::MachineOperandType operandType,
int64_t intValue)
{
assert(i < operands.size());
assert(TargetInstrDescriptors[opCode].resultPos != (int) i &&
"immed. constant cannot be defined");
operands[i].InitializeConst(operandType, intValue);
operands[i].isDef = false;
}
void
MachineInstr::SetMachineOperandReg(unsigned int i,
int regNum,
bool isdef=false,
bool isCCReg=false)
{
assert(i < operands.size());
operands[i].InitializeReg(regNum, isCCReg);
operands[i].isDef = isdef ||
2001-09-18 20:56:28 +08:00
TargetInstrDescriptors[opCode].resultPos == (int) i;
}
void
MachineInstr::dump(unsigned int indent) const
{
for (unsigned i=0; i < indent; i++)
cerr << " ";
cerr << *this;
}
static inline std::ostream &OutputValue(std::ostream &os,
const Value* val)
{
os << "(val ";
if (val && val->hasName())
return os << val->getName();
else
return os << (void*) val; // print address only
os << ")";
}
std::ostream &operator<<(std::ostream& os, const MachineInstr& minstr)
{
os << TargetInstrDescriptors[minstr.opCode].opCodeString;
for (unsigned i=0, N=minstr.getNumOperands(); i < N; i++) {
os << "\t" << minstr.getOperand(i);
if( minstr.getOperand(i).opIsDef() )
os << "*";
}
// code for printing implict references
unsigned NumOfImpRefs = minstr.getNumImplicitRefs();
if( NumOfImpRefs > 0 ) {
os << "\tImplicit: ";
for(unsigned z=0; z < NumOfImpRefs; z++) {
OutputValue(os, minstr.getImplicitRef(z));
if( minstr.implicitRefIsDefined(z)) os << "*";
os << "\t";
}
}
return os << "\n";
}
static inline std::ostream &OutputOperand(std::ostream &os,
const MachineOperand &mop)
2001-09-18 20:56:28 +08:00
{
Value* val;
2001-09-18 20:56:28 +08:00
switch (mop.getOperandType())
{
case MachineOperand::MO_CCRegister:
case MachineOperand::MO_VirtualRegister:
return OutputValue(os, mop.getVRegValue());
2001-09-18 20:56:28 +08:00
case MachineOperand::MO_MachineRegister:
return os << "(" << mop.getMachineRegNum() << ")";
2001-09-18 20:56:28 +08:00
default:
assert(0 && "Unknown operand type");
return os;
}
}
std::ostream &operator<<(std::ostream &os, const MachineOperand &mop)
2001-09-18 20:56:28 +08:00
{
switch(mop.opType)
{
case MachineOperand::MO_VirtualRegister:
case MachineOperand::MO_MachineRegister:
os << "%reg";
return OutputOperand(os, mop);
case MachineOperand::MO_CCRegister:
os << "%ccreg";
return OutputOperand(os, mop);
case MachineOperand::MO_SignExtendedImmed:
return os << (long)mop.immedVal;
2001-09-18 20:56:28 +08:00
case MachineOperand::MO_UnextendedImmed:
return os << (long)mop.immedVal;
2001-09-18 20:56:28 +08:00
case MachineOperand::MO_PCRelativeDisp:
{
const Value* opVal = mop.getVRegValue();
2002-04-09 06:01:15 +08:00
bool isLabel = isa<Function>(opVal) || isa<BasicBlock>(opVal);
os << "%disp(" << (isLabel? "label " : "addr-of-val ");
if (opVal->hasName())
os << opVal->getName();
else
os << opVal;
return os << ")";
}
2001-09-18 20:56:28 +08:00
default:
assert(0 && "Unrecognized operand type");
break;
}
return os;
}