Chris Lattner | c9670ef | 2003-07-31 04:43:49 +0000 | [diff] [blame] | 1 | //===- CodeEmitterGen.cpp - Code Emitter Generator ------------------------===// |
Misha Brukman | 3da94ae | 2005-04-22 00:00:37 +0000 | [diff] [blame] | 2 | // |
John Criswell | 01d4582 | 2003-10-20 20:20:30 +0000 | [diff] [blame] | 3 | // The LLVM Compiler Infrastructure |
| 4 | // |
Chris Lattner | 3060910 | 2007-12-29 20:37:13 +0000 | [diff] [blame] | 5 | // This file is distributed under the University of Illinois Open Source |
| 6 | // License. See LICENSE.TXT for details. |
Misha Brukman | 3da94ae | 2005-04-22 00:00:37 +0000 | [diff] [blame] | 7 | // |
John Criswell | 01d4582 | 2003-10-20 20:20:30 +0000 | [diff] [blame] | 8 | //===----------------------------------------------------------------------===// |
Chris Lattner | c9670ef | 2003-07-31 04:43:49 +0000 | [diff] [blame] | 9 | // |
Misha Brukman | 4e4f863 | 2004-08-04 22:07:54 +0000 | [diff] [blame] | 10 | // 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 Lattner | c9670ef | 2003-07-31 04:43:49 +0000 | [diff] [blame] | 13 | // |
| 14 | //===----------------------------------------------------------------------===// |
| 15 | |
Misha Brukman | 9fff7e1 | 2003-05-24 00:15:53 +0000 | [diff] [blame] | 16 | #include "CodeEmitterGen.h" |
Misha Brukman | d7a5b28 | 2004-08-09 19:10:43 +0000 | [diff] [blame] | 17 | #include "CodeGenTarget.h" |
Chris Lattner | c9670ef | 2003-07-31 04:43:49 +0000 | [diff] [blame] | 18 | #include "Record.h" |
Jim Laskey | f1b05bf | 2006-07-13 21:02:53 +0000 | [diff] [blame] | 19 | #include "llvm/ADT/StringExtras.h" |
Reid Spencer | 551ccae | 2004-09-01 22:55:40 +0000 | [diff] [blame] | 20 | #include "llvm/Support/Debug.h" |
Chris Lattner | 2082ebe | 2004-08-01 03:55:39 +0000 | [diff] [blame] | 21 | using namespace llvm; |
Brian Gaeke | d0fde30 | 2003-11-11 22:41:34 +0000 | [diff] [blame] | 22 | |
Jim Laskey | f1b05bf | 2006-07-13 21:02:53 +0000 | [diff] [blame] | 23 | void CodeEmitterGen::reverseBits(std::vector<Record*> &Insts) { |
| 24 | for (std::vector<Record*>::iterator I = Insts.begin(), E = Insts.end(); |
| 25 | I != E; ++I) { |
| 26 | Record *R = *I; |
Jim Laskey | a683f9b | 2007-01-26 17:29:20 +0000 | [diff] [blame] | 27 | if (R->getName() == "PHI" || |
| 28 | R->getName() == "INLINEASM" || |
Dan Gohman | 4406604 | 2008-07-01 00:05:16 +0000 | [diff] [blame] | 29 | R->getName() == "DBG_LABEL" || |
| 30 | R->getName() == "EH_LABEL" || |
| 31 | R->getName() == "GC_LABEL" || |
Evan Cheng | a844bde | 2008-02-02 04:07:54 +0000 | [diff] [blame] | 32 | R->getName() == "DECLARE" || |
Christopher Lamb | 08d5207 | 2007-07-26 07:48:21 +0000 | [diff] [blame] | 33 | R->getName() == "EXTRACT_SUBREG" || |
Evan Cheng | da47e6e | 2008-03-15 00:03:38 +0000 | [diff] [blame] | 34 | R->getName() == "INSERT_SUBREG" || |
Christopher Lamb | c929823 | 2008-03-16 03:12:01 +0000 | [diff] [blame] | 35 | R->getName() == "IMPLICIT_DEF" || |
Dan Gohman | f8c7394 | 2009-04-13 15:38:05 +0000 | [diff] [blame] | 36 | R->getName() == "SUBREG_TO_REG" || |
Dan Gohman | 88c7af0 | 2009-04-13 21:06:25 +0000 | [diff] [blame] | 37 | R->getName() == "COPY_TO_REGCLASS") continue; |
Dan Gohman | f8c7394 | 2009-04-13 15:38:05 +0000 | [diff] [blame] | 38 | |
Jim Laskey | f1b05bf | 2006-07-13 21:02:53 +0000 | [diff] [blame] | 39 | BitsInit *BI = R->getValueAsBitsInit("Inst"); |
Misha Brukman | 28eefa5 | 2004-10-14 05:53:01 +0000 | [diff] [blame] | 40 | |
Jim Laskey | f1b05bf | 2006-07-13 21:02:53 +0000 | [diff] [blame] | 41 | unsigned numBits = BI->getNumBits(); |
| 42 | BitsInit *NewBI = new BitsInit(numBits); |
| 43 | for (unsigned bit = 0, end = numBits / 2; bit != end; ++bit) { |
| 44 | unsigned bitSwapIdx = numBits - bit - 1; |
| 45 | Init *OrigBit = BI->getBit(bit); |
| 46 | Init *BitSwap = BI->getBit(bitSwapIdx); |
| 47 | NewBI->setBit(bit, BitSwap); |
| 48 | NewBI->setBit(bitSwapIdx, OrigBit); |
Misha Brukman | 28eefa5 | 2004-10-14 05:53:01 +0000 | [diff] [blame] | 49 | } |
Jim Laskey | f1b05bf | 2006-07-13 21:02:53 +0000 | [diff] [blame] | 50 | if (numBits % 2) { |
| 51 | unsigned middle = (numBits + 1) / 2; |
| 52 | NewBI->setBit(middle, BI->getBit(middle)); |
| 53 | } |
| 54 | |
| 55 | // Update the bits in reversed order so that emitInstrOpBits will get the |
| 56 | // correct endianness. |
| 57 | R->getValue("Inst")->setValue(NewBI); |
Misha Brukman | 28eefa5 | 2004-10-14 05:53:01 +0000 | [diff] [blame] | 58 | } |
| 59 | } |
| 60 | |
| 61 | |
Jim Laskey | cb12903 | 2006-07-13 22:17:08 +0000 | [diff] [blame] | 62 | // If the VarBitInit at position 'bit' matches the specified variable then |
| 63 | // return the variable bit position. Otherwise return -1. |
| 64 | int CodeEmitterGen::getVariableBit(const std::string &VarName, |
| 65 | BitsInit *BI, int bit) { |
Jim Laskey | f1b05bf | 2006-07-13 21:02:53 +0000 | [diff] [blame] | 66 | if (VarBitInit *VBI = dynamic_cast<VarBitInit*>(BI->getBit(bit))) { |
| 67 | TypedInit *TI = VBI->getVariable(); |
| 68 | |
| 69 | if (VarInit *VI = dynamic_cast<VarInit*>(TI)) { |
| 70 | if (VI->getName() == VarName) return VBI->getBitNum(); |
| 71 | } |
| 72 | } |
| 73 | |
| 74 | return -1; |
| 75 | } |
| 76 | |
| 77 | |
Daniel Dunbar | 1a55180 | 2009-07-03 00:10:29 +0000 | [diff] [blame] | 78 | void CodeEmitterGen::run(raw_ostream &o) { |
Misha Brukman | e2ba778 | 2004-08-10 18:31:01 +0000 | [diff] [blame] | 79 | CodeGenTarget Target; |
Chris Lattner | 048c00d | 2003-08-01 04:38:18 +0000 | [diff] [blame] | 80 | std::vector<Record*> Insts = Records.getAllDerivedDefinitions("Instruction"); |
Jim Laskey | f1b05bf | 2006-07-13 21:02:53 +0000 | [diff] [blame] | 81 | |
| 82 | // For little-endian instruction bit encodings, reverse the bit order |
| 83 | if (Target.isLittleEndianEncoding()) reverseBits(Insts); |
Misha Brukman | 9fff7e1 | 2003-05-24 00:15:53 +0000 | [diff] [blame] | 84 | |
Chris Lattner | 0e5e49e | 2003-08-06 04:36:35 +0000 | [diff] [blame] | 85 | EmitSourceFileHeader("Machine Code Emitter", o); |
Misha Brukman | e2ba778 | 2004-08-10 18:31:01 +0000 | [diff] [blame] | 86 | std::string Namespace = Insts[0]->getValueAsString("Namespace") + "::"; |
Jim Laskey | ed39343 | 2006-07-12 19:15:43 +0000 | [diff] [blame] | 87 | |
| 88 | std::vector<const CodeGenInstruction*> NumberedInstructions; |
| 89 | Target.getInstructionsByEnumValue(NumberedInstructions); |
Misha Brukman | 9fff7e1 | 2003-05-24 00:15:53 +0000 | [diff] [blame] | 90 | |
Misha Brukman | ad346ad | 2004-08-10 20:54:58 +0000 | [diff] [blame] | 91 | // Emit function declaration |
Misha Brukman | e2ba778 | 2004-08-10 18:31:01 +0000 | [diff] [blame] | 92 | o << "unsigned " << Target.getName() << "CodeEmitter::" |
Evan Cheng | acff339 | 2008-09-02 06:51:36 +0000 | [diff] [blame] | 93 | << "getBinaryCodeForInstr(const MachineInstr &MI) {\n"; |
Misha Brukman | ad346ad | 2004-08-10 20:54:58 +0000 | [diff] [blame] | 94 | |
Jim Laskey | ed39343 | 2006-07-12 19:15:43 +0000 | [diff] [blame] | 95 | // Emit instruction base values |
| 96 | o << " static const unsigned InstBits[] = {\n"; |
| 97 | for (std::vector<const CodeGenInstruction*>::iterator |
| 98 | IN = NumberedInstructions.begin(), |
| 99 | EN = NumberedInstructions.end(); |
| 100 | IN != EN; ++IN) { |
| 101 | const CodeGenInstruction *CGI = *IN; |
| 102 | Record *R = CGI->TheDef; |
Chris Lattner | 188454a | 2006-01-27 01:39:38 +0000 | [diff] [blame] | 103 | |
Jim Laskey | a683f9b | 2007-01-26 17:29:20 +0000 | [diff] [blame] | 104 | if (R->getName() == "PHI" || |
| 105 | R->getName() == "INLINEASM" || |
Dan Gohman | 4406604 | 2008-07-01 00:05:16 +0000 | [diff] [blame] | 106 | R->getName() == "DBG_LABEL" || |
| 107 | R->getName() == "EH_LABEL" || |
| 108 | R->getName() == "GC_LABEL" || |
Evan Cheng | a844bde | 2008-02-02 04:07:54 +0000 | [diff] [blame] | 109 | R->getName() == "DECLARE" || |
Christopher Lamb | 08d5207 | 2007-07-26 07:48:21 +0000 | [diff] [blame] | 110 | R->getName() == "EXTRACT_SUBREG" || |
Evan Cheng | da47e6e | 2008-03-15 00:03:38 +0000 | [diff] [blame] | 111 | R->getName() == "INSERT_SUBREG" || |
Christopher Lamb | c929823 | 2008-03-16 03:12:01 +0000 | [diff] [blame] | 112 | R->getName() == "IMPLICIT_DEF" || |
Dan Gohman | f8c7394 | 2009-04-13 15:38:05 +0000 | [diff] [blame] | 113 | R->getName() == "SUBREG_TO_REG" || |
Dan Gohman | 88c7af0 | 2009-04-13 21:06:25 +0000 | [diff] [blame] | 114 | R->getName() == "COPY_TO_REGCLASS") { |
Evan Cheng | bc95b23 | 2008-09-17 06:29:52 +0000 | [diff] [blame] | 115 | o << " 0U,\n"; |
Jim Laskey | ed39343 | 2006-07-12 19:15:43 +0000 | [diff] [blame] | 116 | continue; |
| 117 | } |
| 118 | |
Chris Lattner | 6f334ad | 2003-08-01 04:46:24 +0000 | [diff] [blame] | 119 | BitsInit *BI = R->getValueAsBitsInit("Inst"); |
Misha Brukman | 9fff7e1 | 2003-05-24 00:15:53 +0000 | [diff] [blame] | 120 | |
Misha Brukman | 9fff7e1 | 2003-05-24 00:15:53 +0000 | [diff] [blame] | 121 | // Start by filling in fixed values... |
Reid Spencer | fa3e3b9 | 2006-11-03 01:48:30 +0000 | [diff] [blame] | 122 | unsigned Value = 0; |
Misha Brukman | cbfde0a | 2003-05-27 22:19:58 +0000 | [diff] [blame] | 123 | for (unsigned i = 0, e = BI->getNumBits(); i != e; ++i) { |
| 124 | if (BitInit *B = dynamic_cast<BitInit*>(BI->getBit(e-i-1))) { |
| 125 | Value |= B->getValue() << (e-i-1); |
Misha Brukman | cbfde0a | 2003-05-27 22:19:58 +0000 | [diff] [blame] | 126 | } |
| 127 | } |
Evan Cheng | bc95b23 | 2008-09-17 06:29:52 +0000 | [diff] [blame] | 128 | o << " " << Value << "U," << '\t' << "// " << R->getName() << "\n"; |
Jim Laskey | ed39343 | 2006-07-12 19:15:43 +0000 | [diff] [blame] | 129 | } |
Evan Cheng | bc95b23 | 2008-09-17 06:29:52 +0000 | [diff] [blame] | 130 | o << " 0U\n };\n"; |
Jim Laskey | f1b05bf | 2006-07-13 21:02:53 +0000 | [diff] [blame] | 131 | |
| 132 | // Map to accumulate all the cases. |
| 133 | std::map<std::string, std::vector<std::string> > CaseMap; |
| 134 | |
| 135 | // Construct all cases statement for each opcode |
| 136 | for (std::vector<Record*>::iterator IC = Insts.begin(), EC = Insts.end(); |
| 137 | IC != EC; ++IC) { |
| 138 | Record *R = *IC; |
| 139 | const std::string &InstName = R->getName(); |
| 140 | std::string Case(""); |
Jim Laskey | ed39343 | 2006-07-12 19:15:43 +0000 | [diff] [blame] | 141 | |
Jim Laskey | a683f9b | 2007-01-26 17:29:20 +0000 | [diff] [blame] | 142 | if (InstName == "PHI" || |
| 143 | InstName == "INLINEASM" || |
Dan Gohman | 4406604 | 2008-07-01 00:05:16 +0000 | [diff] [blame] | 144 | InstName == "DBG_LABEL"|| |
| 145 | InstName == "EH_LABEL"|| |
| 146 | InstName == "GC_LABEL"|| |
Evan Cheng | a844bde | 2008-02-02 04:07:54 +0000 | [diff] [blame] | 147 | InstName == "DECLARE"|| |
Christopher Lamb | 08d5207 | 2007-07-26 07:48:21 +0000 | [diff] [blame] | 148 | InstName == "EXTRACT_SUBREG" || |
Evan Cheng | da47e6e | 2008-03-15 00:03:38 +0000 | [diff] [blame] | 149 | InstName == "INSERT_SUBREG" || |
Christopher Lamb | c929823 | 2008-03-16 03:12:01 +0000 | [diff] [blame] | 150 | InstName == "IMPLICIT_DEF" || |
Dan Gohman | f8c7394 | 2009-04-13 15:38:05 +0000 | [diff] [blame] | 151 | InstName == "SUBREG_TO_REG" || |
Dan Gohman | 88c7af0 | 2009-04-13 21:06:25 +0000 | [diff] [blame] | 152 | InstName == "COPY_TO_REGCLASS") continue; |
Dan Gohman | f8c7394 | 2009-04-13 15:38:05 +0000 | [diff] [blame] | 153 | |
Jim Laskey | ed39343 | 2006-07-12 19:15:43 +0000 | [diff] [blame] | 154 | BitsInit *BI = R->getValueAsBitsInit("Inst"); |
| 155 | const std::vector<RecordVal> &Vals = R->getValues(); |
Chris Lattner | f64f9a4 | 2006-11-15 23:23:02 +0000 | [diff] [blame] | 156 | CodeGenInstruction &CGI = Target.getInstruction(InstName); |
| 157 | |
Misha Brukman | 28eefa5 | 2004-10-14 05:53:01 +0000 | [diff] [blame] | 158 | // Loop over all of the fields in the instruction, determining which are the |
Misha Brukman | 3da94ae | 2005-04-22 00:00:37 +0000 | [diff] [blame] | 159 | // operands to the instruction. |
Misha Brukman | cbfde0a | 2003-05-27 22:19:58 +0000 | [diff] [blame] | 160 | unsigned op = 0; |
Misha Brukman | 9fff7e1 | 2003-05-24 00:15:53 +0000 | [diff] [blame] | 161 | for (unsigned i = 0, e = Vals.size(); i != e; ++i) { |
Misha Brukman | 28eefa5 | 2004-10-14 05:53:01 +0000 | [diff] [blame] | 162 | if (!Vals[i].getPrefix() && !Vals[i].getValue()->isComplete()) { |
Misha Brukman | 7eac476 | 2003-07-15 21:00:32 +0000 | [diff] [blame] | 163 | // Is the operand continuous? If so, we can just mask and OR it in |
Misha Brukman | 3da94ae | 2005-04-22 00:00:37 +0000 | [diff] [blame] | 164 | // instead of doing it bit-by-bit, saving a lot in runtime cost. |
Jim Laskey | f1b05bf | 2006-07-13 21:02:53 +0000 | [diff] [blame] | 165 | const std::string &VarName = Vals[i].getName(); |
| 166 | bool gotOp = false; |
| 167 | |
| 168 | for (int bit = BI->getNumBits()-1; bit >= 0; ) { |
| 169 | int varBit = getVariableBit(VarName, BI, bit); |
| 170 | |
| 171 | if (varBit == -1) { |
| 172 | --bit; |
| 173 | } else { |
| 174 | int beginInstBit = bit; |
| 175 | int beginVarBit = varBit; |
| 176 | int N = 1; |
| 177 | |
| 178 | for (--bit; bit >= 0;) { |
| 179 | varBit = getVariableBit(VarName, BI, bit); |
| 180 | if (varBit == -1 || varBit != (beginVarBit - N)) break; |
| 181 | ++N; |
| 182 | --bit; |
Chris Lattner | d7efef9 | 2003-08-05 03:53:04 +0000 | [diff] [blame] | 183 | } |
Misha Brukman | 3da94ae | 2005-04-22 00:00:37 +0000 | [diff] [blame] | 184 | |
Jim Laskey | f1b05bf | 2006-07-13 21:02:53 +0000 | [diff] [blame] | 185 | if (!gotOp) { |
Chris Lattner | f64f9a4 | 2006-11-15 23:23:02 +0000 | [diff] [blame] | 186 | /// If this operand is not supposed to be emitted by the generated |
| 187 | /// emitter, skip it. |
| 188 | while (CGI.isFlatOperandNotEmitted(op)) |
| 189 | ++op; |
| 190 | |
Jim Laskey | f1b05bf | 2006-07-13 21:02:53 +0000 | [diff] [blame] | 191 | Case += " // op: " + VarName + "\n" |
| 192 | + " op = getMachineOpValue(MI, MI.getOperand(" |
Chris Lattner | f64f9a4 | 2006-11-15 23:23:02 +0000 | [diff] [blame] | 193 | + utostr(op++) + "));\n"; |
Jim Laskey | f1b05bf | 2006-07-13 21:02:53 +0000 | [diff] [blame] | 194 | gotOp = true; |
| 195 | } |
| 196 | |
Chris Lattner | 1cfa077 | 2008-10-05 18:31:58 +0000 | [diff] [blame] | 197 | unsigned opMask = ~0U >> (32-N); |
Jim Laskey | f1b05bf | 2006-07-13 21:02:53 +0000 | [diff] [blame] | 198 | int opShift = beginVarBit - N + 1; |
| 199 | opMask <<= opShift; |
| 200 | opShift = beginInstBit - beginVarBit; |
| 201 | |
| 202 | if (opShift > 0) { |
| 203 | Case += " Value |= (op & " + utostr(opMask) + "U) << " |
| 204 | + itostr(opShift) + ";\n"; |
| 205 | } else if (opShift < 0) { |
| 206 | Case += " Value |= (op & " + utostr(opMask) + "U) >> " |
| 207 | + itostr(-opShift) + ";\n"; |
| 208 | } else { |
| 209 | Case += " Value |= op & " + utostr(opMask) + "U;\n"; |
| 210 | } |
Chris Lattner | d7efef9 | 2003-08-05 03:53:04 +0000 | [diff] [blame] | 211 | } |
Misha Brukman | 7eac476 | 2003-07-15 21:00:32 +0000 | [diff] [blame] | 212 | } |
Misha Brukman | 9fff7e1 | 2003-05-24 00:15:53 +0000 | [diff] [blame] | 213 | } |
| 214 | } |
| 215 | |
Chris Lattner | f64f9a4 | 2006-11-15 23:23:02 +0000 | [diff] [blame] | 216 | std::vector<std::string> &InstList = CaseMap[Case]; |
Jim Laskey | f1b05bf | 2006-07-13 21:02:53 +0000 | [diff] [blame] | 217 | InstList.push_back(InstName); |
| 218 | } |
Misha Brukman | 9fff7e1 | 2003-05-24 00:15:53 +0000 | [diff] [blame] | 219 | |
Jim Laskey | f1b05bf | 2006-07-13 21:02:53 +0000 | [diff] [blame] | 220 | |
| 221 | // Emit initial function code |
| 222 | o << " const unsigned opcode = MI.getOpcode();\n" |
| 223 | << " unsigned Value = InstBits[opcode];\n" |
Evan Cheng | e3e3626 | 2008-09-07 09:00:57 +0000 | [diff] [blame] | 224 | << " unsigned op = 0;\n" |
Evan Cheng | acff339 | 2008-09-02 06:51:36 +0000 | [diff] [blame] | 225 | << " op = op; // suppress warning\n" |
Jim Laskey | f1b05bf | 2006-07-13 21:02:53 +0000 | [diff] [blame] | 226 | << " switch (opcode) {\n"; |
| 227 | |
| 228 | // Emit each case statement |
| 229 | std::map<std::string, std::vector<std::string> >::iterator IE, EE; |
| 230 | for (IE = CaseMap.begin(), EE = CaseMap.end(); IE != EE; ++IE) { |
| 231 | const std::string &Case = IE->first; |
| 232 | std::vector<std::string> &InstList = IE->second; |
| 233 | |
| 234 | for (int i = 0, N = InstList.size(); i < N; i++) { |
| 235 | if (i) o << "\n"; |
| 236 | o << " case " << Namespace << InstList[i] << ":"; |
| 237 | } |
| 238 | o << " {\n"; |
| 239 | o << Case; |
Misha Brukman | 9fff7e1 | 2003-05-24 00:15:53 +0000 | [diff] [blame] | 240 | o << " break;\n" |
| 241 | << " }\n"; |
| 242 | } |
Misha Brukman | 7eac476 | 2003-07-15 21:00:32 +0000 | [diff] [blame] | 243 | |
Misha Brukman | 28eefa5 | 2004-10-14 05:53:01 +0000 | [diff] [blame] | 244 | // Default case: unhandled opcode |
Misha Brukman | cbfde0a | 2003-05-27 22:19:58 +0000 | [diff] [blame] | 245 | o << " default:\n" |
Torok Edwin | 804e0fe | 2009-07-08 19:04:27 +0000 | [diff] [blame] | 246 | << " std::string msg;\n" |
| 247 | << " raw_string_ostream Msg(msg);\n" |
| 248 | << " Msg << \"Not supported instr: \" << MI;\n" |
| 249 | << " llvm_report_error(Msg.str());\n" |
Misha Brukman | cbfde0a | 2003-05-27 22:19:58 +0000 | [diff] [blame] | 250 | << " }\n" |
Misha Brukman | 9fff7e1 | 2003-05-24 00:15:53 +0000 | [diff] [blame] | 251 | << " return Value;\n" |
Misha Brukman | 28eefa5 | 2004-10-14 05:53:01 +0000 | [diff] [blame] | 252 | << "}\n\n"; |
Misha Brukman | 9fff7e1 | 2003-05-24 00:15:53 +0000 | [diff] [blame] | 253 | } |