blob: 9d4dc5c4607a6ea6c6d409558911062ae4a6bad6 [file] [log] [blame]
Chris Lattnerc9670ef2003-07-31 04:43:49 +00001//===- CodeEmitterGen.cpp - Code Emitter Generator ------------------------===//
Misha Brukman3da94ae2005-04-22 00:00:37 +00002//
John Criswell01d45822003-10-20 20:20:30 +00003// The LLVM Compiler Infrastructure
4//
Chris Lattner30609102007-12-29 20:37:13 +00005// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
Misha Brukman3da94ae2005-04-22 00:00:37 +00007//
John Criswell01d45822003-10-20 20:20:30 +00008//===----------------------------------------------------------------------===//
Chris Lattnerc9670ef2003-07-31 04:43:49 +00009//
Misha Brukman4e4f8632004-08-04 22:07:54 +000010// CodeEmitterGen uses the descriptions of instructions and their fields to
11// construct an automated code emitter: a function that, given a MachineInstr,
12// returns the (currently, 32-bit unsigned) value of the instruction.
Chris Lattnerc9670ef2003-07-31 04:43:49 +000013//
14//===----------------------------------------------------------------------===//
15
Misha Brukman9fff7e12003-05-24 00:15:53 +000016#include "CodeEmitterGen.h"
Misha Brukmand7a5b282004-08-09 19:10:43 +000017#include "CodeGenTarget.h"
Chris Lattnerc9670ef2003-07-31 04:43:49 +000018#include "Record.h"
Jim Laskeyf1b05bf2006-07-13 21:02:53 +000019#include "llvm/ADT/StringExtras.h"
Jim Grosbachab3d00e2010-11-02 17:35:25 +000020#include "llvm/Support/CommandLine.h"
Reid Spencer551ccae2004-09-01 22:55:40 +000021#include "llvm/Support/Debug.h"
Bill Wendlingeac8f352010-12-13 01:05:54 +000022#include <map>
Chris Lattner2082ebe2004-08-01 03:55:39 +000023using namespace llvm;
Brian Gaeked0fde302003-11-11 22:41:34 +000024
Jim Grosbach60aaa762010-11-03 23:38:14 +000025// FIXME: Somewhat hackish to use a command line option for this. There should
26// be a CodeEmitter class in the Target.td that controls this sort of thing
27// instead.
Jim Grosbachab3d00e2010-11-02 17:35:25 +000028static cl::opt<bool>
Jim Grosbach60aaa762010-11-03 23:38:14 +000029MCEmitter("mc-emitter",
Jim Grosbachab3d00e2010-11-02 17:35:25 +000030 cl::desc("Generate CodeEmitter for use with the MC library."),
31 cl::init(false));
32
Jim Laskeyf1b05bf2006-07-13 21:02:53 +000033void CodeEmitterGen::reverseBits(std::vector<Record*> &Insts) {
34 for (std::vector<Record*>::iterator I = Insts.begin(), E = Insts.end();
35 I != E; ++I) {
36 Record *R = *I;
Jakob Stoklund Olesen65766ce2010-07-02 21:44:22 +000037 if (R->getValueAsString("Namespace") == "TargetOpcode")
38 continue;
Dan Gohmanf8c73942009-04-13 15:38:05 +000039
Jim Laskeyf1b05bf2006-07-13 21:02:53 +000040 BitsInit *BI = R->getValueAsBitsInit("Inst");
Misha Brukman28eefa52004-10-14 05:53:01 +000041
Jim Laskeyf1b05bf2006-07-13 21:02:53 +000042 unsigned numBits = BI->getNumBits();
43 BitsInit *NewBI = new BitsInit(numBits);
44 for (unsigned bit = 0, end = numBits / 2; bit != end; ++bit) {
45 unsigned bitSwapIdx = numBits - bit - 1;
46 Init *OrigBit = BI->getBit(bit);
47 Init *BitSwap = BI->getBit(bitSwapIdx);
48 NewBI->setBit(bit, BitSwap);
49 NewBI->setBit(bitSwapIdx, OrigBit);
Misha Brukman28eefa52004-10-14 05:53:01 +000050 }
Jim Laskeyf1b05bf2006-07-13 21:02:53 +000051 if (numBits % 2) {
52 unsigned middle = (numBits + 1) / 2;
53 NewBI->setBit(middle, BI->getBit(middle));
54 }
Jim Grosbach8b892ae2010-10-07 16:56:28 +000055
Jim Laskeyf1b05bf2006-07-13 21:02:53 +000056 // Update the bits in reversed order so that emitInstrOpBits will get the
57 // correct endianness.
58 R->getValue("Inst")->setValue(NewBI);
Misha Brukman28eefa52004-10-14 05:53:01 +000059 }
60}
61
Jim Laskeycb129032006-07-13 22:17:08 +000062// If the VarBitInit at position 'bit' matches the specified variable then
63// return the variable bit position. Otherwise return -1.
Dan Gohman9b03da62009-12-15 20:21:44 +000064int CodeEmitterGen::getVariableBit(const std::string &VarName,
Chris Lattner16201172010-11-15 06:59:17 +000065 BitsInit *BI, int bit) {
Owen Anderson4cdcb472011-04-28 17:51:45 +000066 if (VarBitInit *VBI = dynamic_cast<VarBitInit*>(BI->getBit(bit))) {
Chris Lattner98e969a2010-11-15 06:42:13 +000067 if (VarInit *VI = dynamic_cast<VarInit*>(VBI->getVariable()))
68 if (VI->getName() == VarName)
69 return VBI->getBitNum();
Owen Anderson4cdcb472011-04-28 17:51:45 +000070 } else if (VarInit *VI = dynamic_cast<VarInit*>(BI->getBit(bit))) {
71 if (VI->getName() == VarName)
72 return 0;
73 }
Jim Grosbach8b892ae2010-10-07 16:56:28 +000074
Jim Laskeyf1b05bf2006-07-13 21:02:53 +000075 return -1;
Jim Grosbach8b892ae2010-10-07 16:56:28 +000076}
Jim Laskeyf1b05bf2006-07-13 21:02:53 +000077
Chris Lattner16201172010-11-15 06:59:17 +000078void CodeEmitterGen::
79AddCodeToMergeInOperand(Record *R, BitsInit *BI, const std::string &VarName,
80 unsigned &NumberedOp,
81 std::string &Case, CodeGenTarget &Target) {
Chris Lattner16201172010-11-15 06:59:17 +000082 CodeGenInstruction &CGI = Target.getInstruction(R);
83
Chris Lattner8ae082b2010-11-15 07:09:28 +000084 // Determine if VarName actually contributes to the Inst encoding.
85 int bit = BI->getNumBits()-1;
86
87 // Scan for a bit that this contributed to.
88 for (; bit >= 0; ) {
89 if (getVariableBit(VarName, BI, bit) != -1)
90 break;
91
92 --bit;
93 }
94
95 // If we found no bits, ignore this value, otherwise emit the call to get the
96 // operand encoding.
97 if (bit < 0) return;
98
99 // If the operand matches by name, reference according to that
100 // operand number. Non-matching operands are assumed to be in
101 // order.
102 unsigned OpIdx;
103 if (CGI.Operands.hasOperandNamed(VarName, OpIdx)) {
104 // Get the machine operand number for the indicated operand.
105 OpIdx = CGI.Operands[OpIdx].MIOperandNo;
106 assert(!CGI.Operands.isFlatOperandNotEmitted(OpIdx) &&
107 "Explicitly used operand also marked as not emitted!");
108 } else {
109 /// If this operand is not supposed to be emitted by the
110 /// generated emitter, skip it.
111 while (CGI.Operands.isFlatOperandNotEmitted(NumberedOp))
112 ++NumberedOp;
113 OpIdx = NumberedOp++;
114 }
115
116 std::pair<unsigned, unsigned> SO = CGI.Operands.getSubOperandNumber(OpIdx);
117 std::string &EncoderMethodName = CGI.Operands[SO.first].EncoderMethodName;
118
119 // If the source operand has a custom encoder, use it. This will
120 // get the encoding for all of the suboperands.
121 if (!EncoderMethodName.empty()) {
122 // A custom encoder has all of the information for the
123 // sub-operands, if there are more than one, so only
124 // query the encoder once per source operand.
125 if (SO.second == 0) {
126 Case += " // op: " + VarName + "\n" +
127 " op = " + EncoderMethodName + "(MI, " + utostr(OpIdx);
128 if (MCEmitter)
129 Case += ", Fixups";
130 Case += ");\n";
131 }
132 } else {
133 Case += " // op: " + VarName + "\n" +
134 " op = getMachineOpValue(MI, MI.getOperand(" + utostr(OpIdx) + ")";
135 if (MCEmitter)
136 Case += ", Fixups";
137 Case += ");\n";
138 }
139
140 for (; bit >= 0; ) {
Chris Lattner16201172010-11-15 06:59:17 +0000141 int varBit = getVariableBit(VarName, BI, bit);
142
143 // If this bit isn't from a variable, skip it.
144 if (varBit == -1) {
145 --bit;
146 continue;
147 }
148
Bob Wilson9b8c3532011-01-27 23:08:52 +0000149 // Figure out the consecutive range of bits covered by this operand, in
Chris Lattner16201172010-11-15 06:59:17 +0000150 // order to generate better encoding code.
151 int beginInstBit = bit;
152 int beginVarBit = varBit;
153 int N = 1;
154 for (--bit; bit >= 0;) {
155 varBit = getVariableBit(VarName, BI, bit);
156 if (varBit == -1 || varBit != (beginVarBit - N)) break;
157 ++N;
158 --bit;
159 }
Chris Lattner8ae082b2010-11-15 07:09:28 +0000160
Chris Lattner16201172010-11-15 06:59:17 +0000161 unsigned opMask = ~0U >> (32-N);
162 int opShift = beginVarBit - N + 1;
163 opMask <<= opShift;
164 opShift = beginInstBit - beginVarBit;
165
166 if (opShift > 0) {
167 Case += " Value |= (op & " + utostr(opMask) + "U) << " +
168 itostr(opShift) + ";\n";
169 } else if (opShift < 0) {
170 Case += " Value |= (op & " + utostr(opMask) + "U) >> " +
171 itostr(-opShift) + ";\n";
172 } else {
173 Case += " Value |= op & " + utostr(opMask) + "U;\n";
174 }
175 }
176}
177
178
179std::string CodeEmitterGen::getInstructionCase(Record *R,
180 CodeGenTarget &Target) {
181 std::string Case;
182
183 BitsInit *BI = R->getValueAsBitsInit("Inst");
184 const std::vector<RecordVal> &Vals = R->getValues();
185 unsigned NumberedOp = 0;
186
187 // Loop over all of the fields in the instruction, determining which are the
188 // operands to the instruction.
189 for (unsigned i = 0, e = Vals.size(); i != e; ++i) {
190 // Ignore fixed fields in the record, we're looking for values like:
191 // bits<5> RST = { ?, ?, ?, ?, ? };
192 if (Vals[i].getPrefix() || Vals[i].getValue()->isComplete())
193 continue;
194
195 AddCodeToMergeInOperand(R, BI, Vals[i].getName(), NumberedOp, Case, Target);
196 }
197
198 std::string PostEmitter = R->getValueAsString("PostEncoderMethod");
199 if (!PostEmitter.empty())
200 Case += " Value = " + PostEmitter + "(MI, Value);\n";
201
202 return Case;
203}
204
Daniel Dunbar1a551802009-07-03 00:10:29 +0000205void CodeEmitterGen::run(raw_ostream &o) {
Chris Lattner67db8832010-12-13 00:23:57 +0000206 CodeGenTarget Target(Records);
Chris Lattner048c00d2003-08-01 04:38:18 +0000207 std::vector<Record*> Insts = Records.getAllDerivedDefinitions("Instruction");
Jim Grosbach8b892ae2010-10-07 16:56:28 +0000208
Jim Laskeyf1b05bf2006-07-13 21:02:53 +0000209 // For little-endian instruction bit encodings, reverse the bit order
210 if (Target.isLittleEndianEncoding()) reverseBits(Insts);
Misha Brukman9fff7e12003-05-24 00:15:53 +0000211
Chris Lattner0e5e49e2003-08-06 04:36:35 +0000212 EmitSourceFileHeader("Machine Code Emitter", o);
Jim Grosbach8b892ae2010-10-07 16:56:28 +0000213
Chris Lattnerf6502782010-03-19 00:34:35 +0000214 const std::vector<const CodeGenInstruction*> &NumberedInstructions =
215 Target.getInstructionsByEnumValue();
Misha Brukman9fff7e12003-05-24 00:15:53 +0000216
Misha Brukmanad346ad2004-08-10 20:54:58 +0000217 // Emit function declaration
Jim Grosbach60aaa762010-11-03 23:38:14 +0000218 o << "unsigned " << Target.getName();
219 if (MCEmitter)
220 o << "MCCodeEmitter::getBinaryCodeForInstr(const MCInst &MI,\n"
221 << " SmallVectorImpl<MCFixup> &Fixups) const {\n";
222 else
223 o << "CodeEmitter::getBinaryCodeForInstr(const MachineInstr &MI) const {\n";
Misha Brukmanad346ad2004-08-10 20:54:58 +0000224
Jim Laskeyed393432006-07-12 19:15:43 +0000225 // Emit instruction base values
226 o << " static const unsigned InstBits[] = {\n";
Chris Lattnerf6502782010-03-19 00:34:35 +0000227 for (std::vector<const CodeGenInstruction*>::const_iterator
Jim Laskeyed393432006-07-12 19:15:43 +0000228 IN = NumberedInstructions.begin(),
229 EN = NumberedInstructions.end();
230 IN != EN; ++IN) {
231 const CodeGenInstruction *CGI = *IN;
232 Record *R = CGI->TheDef;
Jim Grosbach8b892ae2010-10-07 16:56:28 +0000233
Jakob Stoklund Olesen65766ce2010-07-02 21:44:22 +0000234 if (R->getValueAsString("Namespace") == "TargetOpcode") {
Evan Chengbc95b232008-09-17 06:29:52 +0000235 o << " 0U,\n";
Jim Laskeyed393432006-07-12 19:15:43 +0000236 continue;
237 }
Jim Grosbach8b892ae2010-10-07 16:56:28 +0000238
Chris Lattner6f334ad2003-08-01 04:46:24 +0000239 BitsInit *BI = R->getValueAsBitsInit("Inst");
Misha Brukman9fff7e12003-05-24 00:15:53 +0000240
Chris Lattner16201172010-11-15 06:59:17 +0000241 // Start by filling in fixed values.
Reid Spencerfa3e3b92006-11-03 01:48:30 +0000242 unsigned Value = 0;
Misha Brukmancbfde0a2003-05-27 22:19:58 +0000243 for (unsigned i = 0, e = BI->getNumBits(); i != e; ++i) {
Chris Lattner16201172010-11-15 06:59:17 +0000244 if (BitInit *B = dynamic_cast<BitInit*>(BI->getBit(e-i-1)))
Misha Brukmancbfde0a2003-05-27 22:19:58 +0000245 Value |= B->getValue() << (e-i-1);
Misha Brukmancbfde0a2003-05-27 22:19:58 +0000246 }
Evan Chengbc95b232008-09-17 06:29:52 +0000247 o << " " << Value << "U," << '\t' << "// " << R->getName() << "\n";
Jim Laskeyed393432006-07-12 19:15:43 +0000248 }
Evan Chengbc95b232008-09-17 06:29:52 +0000249 o << " 0U\n };\n";
Jim Grosbach8b892ae2010-10-07 16:56:28 +0000250
Jim Laskeyf1b05bf2006-07-13 21:02:53 +0000251 // Map to accumulate all the cases.
252 std::map<std::string, std::vector<std::string> > CaseMap;
Jim Grosbach8b892ae2010-10-07 16:56:28 +0000253
Jim Laskeyf1b05bf2006-07-13 21:02:53 +0000254 // Construct all cases statement for each opcode
255 for (std::vector<Record*>::iterator IC = Insts.begin(), EC = Insts.end();
256 IC != EC; ++IC) {
257 Record *R = *IC;
Jakob Stoklund Olesen65766ce2010-07-02 21:44:22 +0000258 if (R->getValueAsString("Namespace") == "TargetOpcode")
259 continue;
Jim Grosbach0ed92f22011-02-03 23:26:36 +0000260 const std::string &InstName = R->getValueAsString("Namespace") + "::"
261 + R->getName();
Chris Lattner16201172010-11-15 06:59:17 +0000262 std::string Case = getInstructionCase(R, Target);
Dan Gohmanf8c73942009-04-13 15:38:05 +0000263
Chris Lattner16201172010-11-15 06:59:17 +0000264 CaseMap[Case].push_back(InstName);
Jim Laskeyf1b05bf2006-07-13 21:02:53 +0000265 }
Misha Brukman9fff7e12003-05-24 00:15:53 +0000266
Jim Laskeyf1b05bf2006-07-13 21:02:53 +0000267 // Emit initial function code
268 o << " const unsigned opcode = MI.getOpcode();\n"
269 << " unsigned Value = InstBits[opcode];\n"
Evan Chenge3e36262008-09-07 09:00:57 +0000270 << " unsigned op = 0;\n"
Jeffrey Yasskin8e68c382010-12-23 00:58:24 +0000271 << " (void)op; // suppress warning\n"
Jim Laskeyf1b05bf2006-07-13 21:02:53 +0000272 << " switch (opcode) {\n";
273
274 // Emit each case statement
275 std::map<std::string, std::vector<std::string> >::iterator IE, EE;
276 for (IE = CaseMap.begin(), EE = CaseMap.end(); IE != EE; ++IE) {
277 const std::string &Case = IE->first;
278 std::vector<std::string> &InstList = IE->second;
279
280 for (int i = 0, N = InstList.size(); i < N; i++) {
281 if (i) o << "\n";
Jim Grosbach0ed92f22011-02-03 23:26:36 +0000282 o << " case " << InstList[i] << ":";
Jim Laskeyf1b05bf2006-07-13 21:02:53 +0000283 }
284 o << " {\n";
285 o << Case;
Misha Brukman9fff7e12003-05-24 00:15:53 +0000286 o << " break;\n"
287 << " }\n";
288 }
Misha Brukman7eac4762003-07-15 21:00:32 +0000289
Misha Brukman28eefa52004-10-14 05:53:01 +0000290 // Default case: unhandled opcode
Misha Brukmancbfde0a2003-05-27 22:19:58 +0000291 o << " default:\n"
Torok Edwin804e0fe2009-07-08 19:04:27 +0000292 << " std::string msg;\n"
293 << " raw_string_ostream Msg(msg);\n"
294 << " Msg << \"Not supported instr: \" << MI;\n"
Chris Lattner75361b62010-04-07 22:58:41 +0000295 << " report_fatal_error(Msg.str());\n"
Misha Brukmancbfde0a2003-05-27 22:19:58 +0000296 << " }\n"
Misha Brukman9fff7e12003-05-24 00:15:53 +0000297 << " return Value;\n"
Misha Brukman28eefa52004-10-14 05:53:01 +0000298 << "}\n\n";
Misha Brukman9fff7e12003-05-24 00:15:53 +0000299}