MachineInstr.cpp revision 9aba1d3307a3ce4a30fa95a08b6b68c445a49b8a 
1// $Id$
2//***************************************************************************
3// File:
4//	MachineInstr.cpp
5//
6// Purpose:
7//
8//
9// Strategy:
10//
11// History:
12//	7/2/01	 -  Vikram Adve  -  Created
13//**************************************************************************/
14
15
16#include "llvm/CodeGen/MachineInstr.h"
17#include "llvm/Target/MachineRegInfo.h"
18#include "llvm/Method.h"
19#include "llvm/Instruction.h"
20
21
22//************************ Class Implementations **************************/
23
24// Constructor for instructions with fixed #operands (nearly all)
25MachineInstr::MachineInstr(MachineOpCode _opCode,
26			   OpCodeMask    _opCodeMask)
27  : opCode(_opCode),
28    opCodeMask(_opCodeMask),
29    operands(TargetInstrDescriptors[_opCode].numOperands)
30{
31  assert(TargetInstrDescriptors[_opCode].numOperands >= 0);
32}
33
34// Constructor for instructions with variable #operands
35MachineInstr::MachineInstr(MachineOpCode _opCode,
36			   unsigned	 numOperands,
37			   OpCodeMask    _opCodeMask)
38  : opCode(_opCode),
39    opCodeMask(_opCodeMask),
40    operands(numOperands)
41{
42}
43
44void
45MachineInstr::SetMachineOperand(unsigned int i,
46				MachineOperand::MachineOperandType operandType,
47				Value* _val, bool isdef=false)
48{
49  assert(i < operands.size());
50  operands[i].Initialize(operandType, _val);
51  operands[i].isDef = isdef ||
52    TargetInstrDescriptors[opCode].resultPos == (int) i;
53}
54
55void
56MachineInstr::SetMachineOperand(unsigned int i,
57				MachineOperand::MachineOperandType operandType,
58				int64_t intValue, bool isdef=false)
59{
60  assert(i < operands.size());
61  operands[i].InitializeConst(operandType, intValue);
62  operands[i].isDef = isdef ||
63    TargetInstrDescriptors[opCode].resultPos == (int) i;
64}
65
66void
67MachineInstr::SetMachineOperand(unsigned int i,
68				unsigned int regNum, bool isdef=false)
69{
70  assert(i < operands.size());
71  operands[i].InitializeReg(regNum);
72  operands[i].isDef = isdef ||
73    TargetInstrDescriptors[opCode].resultPos == (int) i;
74}
75
76void
77MachineInstr::dump(unsigned int indent) const
78{
79  for (unsigned i=0; i < indent; i++)
80    cout << "    ";
81
82  cout << *this;
83}
84
85ostream&
86operator<< (ostream& os, const MachineInstr& minstr)
87{
88  os << TargetInstrDescriptors[minstr.opCode].opCodeString;
89
90  for (unsigned i=0, N=minstr.getNumOperands(); i < N; i++)
91    os << "\t" << minstr.getOperand(i);
92
93#undef DEBUG_VAL_OP_ITERATOR
94#ifdef DEBUG_VAL_OP_ITERATOR
95  os << endl << "\tValue operands are: ";
96  for (MachineInstr::val_op_const_iterator vo(&minstr); ! vo.done(); ++vo)
97    {
98      const Value* val = *vo;
99      os << val << (vo.isDef()? "(def), " : ", ");
100    }
101  os << endl;
102#endif
103
104  return os;
105}
106
107static inline ostream&
108OutputOperand(ostream &os, const MachineOperand &mop)
109{
110  switch (mop.getOperandType())
111    {
112    case MachineOperand::MO_CCRegister:
113    case MachineOperand::MO_VirtualRegister:
114      return os << "(val " << mop.getVRegValue() << ")";
115    case MachineOperand::MO_MachineRegister:
116      return os << "("     << mop.getMachineRegNum() << ")";
117    default:
118      assert(0 && "Unknown operand type");
119      return os;
120    }
121}
122
123
124ostream&
125operator<<(ostream &os, const MachineOperand &mop)
126{
127  switch(mop.opType)
128    {
129    case MachineOperand::MO_VirtualRegister:
130    case MachineOperand::MO_MachineRegister:
131      os << "%reg";
132      return OutputOperand(os, mop);
133    case MachineOperand::MO_CCRegister:
134      os << "%ccreg";
135      return OutputOperand(os, mop);
136    case MachineOperand::MO_SignExtendedImmed:
137      return os << mop.immedVal;
138    case MachineOperand::MO_UnextendedImmed:
139      return os << mop.immedVal;
140    case MachineOperand::MO_PCRelativeDisp:
141      {
142        const Value* opVal = mop.getVRegValue();
143        bool isLabel = isa<Method>(opVal) || isa<BasicBlock>(opVal);
144        return os << "%disp("
145                  << (isLabel? "label " : "addr-of-val ")
146                  << opVal << ")";
147      }
148    default:
149      assert(0 && "Unrecognized operand type");
150      break;
151    }
152
153  return os;
154}
155
156
157void
158PrintMachineInstructions(const Method *const method)
159{
160  cout << "\n" << method->getReturnType()
161       << " \"" << method->getName() << "\"" << endl;
162
163  for (Method::const_iterator BI = method->begin(); BI != method->end(); ++BI)
164    {
165      BasicBlock* bb = *BI;
166      cout << "\n"
167	   << (bb->hasName()? bb->getName() : "Label")
168	   << " (" << bb << ")" << ":"
169	   << endl;
170
171      MachineCodeForBasicBlock& mvec = bb->getMachineInstrVec();
172      for (unsigned i=0; i < mvec.size(); i++)
173	cout << "\t" << *mvec[i] << endl;
174    }
175  cout << endl << "End method \"" << method->getName() << "\""
176       << endl << endl;
177}
178