Chris Lattner | c9670ef | 2003-07-31 04:43:49 +0000 | [diff] [blame] | 1 | //===- CodeEmitterGen.cpp - Code Emitter Generator ------------------------===// |
| 2 | // |
| 3 | // FIXME: Document. |
| 4 | // |
| 5 | //===----------------------------------------------------------------------===// |
| 6 | |
Misha Brukman | 9fff7e1 | 2003-05-24 00:15:53 +0000 | [diff] [blame] | 7 | #include "CodeEmitterGen.h" |
Chris Lattner | c9670ef | 2003-07-31 04:43:49 +0000 | [diff] [blame] | 8 | #include "Record.h" |
Chris Lattner | c648dab | 2003-08-01 22:13:59 +0000 | [diff] [blame] | 9 | #include "Support/Debug.h" |
Misha Brukman | 9fff7e1 | 2003-05-24 00:15:53 +0000 | [diff] [blame] | 10 | |
Chris Lattner | 048c00d | 2003-08-01 04:38:18 +0000 | [diff] [blame] | 11 | void CodeEmitterGen::run(std::ostream &o) { |
| 12 | std::vector<Record*> Insts = Records.getAllDerivedDefinitions("Instruction"); |
Misha Brukman | 9fff7e1 | 2003-05-24 00:15:53 +0000 | [diff] [blame] | 13 | |
Chris Lattner | 0e5e49e | 2003-08-06 04:36:35 +0000 | [diff] [blame^] | 14 | EmitSourceFileHeader("Machine Code Emitter", o); |
| 15 | |
Misha Brukman | 9fff7e1 | 2003-05-24 00:15:53 +0000 | [diff] [blame] | 16 | std::string Namespace = "V9::"; |
| 17 | std::string ClassName = "SparcV9CodeEmitter::"; |
| 18 | |
| 19 | //const std::string &Namespace = Inst->getValue("Namespace")->getName(); |
Misha Brukman | b9dd815 | 2003-05-27 22:29:02 +0000 | [diff] [blame] | 20 | o << "unsigned " << ClassName |
Misha Brukman | 9fff7e1 | 2003-05-24 00:15:53 +0000 | [diff] [blame] | 21 | << "getBinaryCodeForInstr(MachineInstr &MI) {\n" |
| 22 | << " unsigned Value = 0;\n" |
Misha Brukman | f4ef4c8 | 2003-06-06 00:27:02 +0000 | [diff] [blame] | 23 | << " DEBUG(std::cerr << MI);\n" |
Misha Brukman | 9fff7e1 | 2003-05-24 00:15:53 +0000 | [diff] [blame] | 24 | << " switch (MI.getOpcode()) {\n"; |
| 25 | for (std::vector<Record*>::iterator I = Insts.begin(), E = Insts.end(); |
Chris Lattner | cf1b585 | 2003-08-01 04:15:25 +0000 | [diff] [blame] | 26 | I != E; ++I) { |
Misha Brukman | 9fff7e1 | 2003-05-24 00:15:53 +0000 | [diff] [blame] | 27 | Record *R = *I; |
Misha Brukman | ecc7fd3 | 2003-05-28 18:29:10 +0000 | [diff] [blame] | 28 | o << " case " << Namespace << R->getName() << ": {\n" |
Misha Brukman | f4ef4c8 | 2003-06-06 00:27:02 +0000 | [diff] [blame] | 29 | << " DEBUG(std::cerr << \"Emitting " << R->getName() << "\\n\");\n"; |
Misha Brukman | 9fff7e1 | 2003-05-24 00:15:53 +0000 | [diff] [blame] | 30 | |
Chris Lattner | 6f334ad | 2003-08-01 04:46:24 +0000 | [diff] [blame] | 31 | BitsInit *BI = R->getValueAsBitsInit("Inst"); |
Misha Brukman | 9fff7e1 | 2003-05-24 00:15:53 +0000 | [diff] [blame] | 32 | |
| 33 | unsigned Value = 0; |
| 34 | const std::vector<RecordVal> &Vals = R->getValues(); |
| 35 | |
Misha Brukman | f6e5217 | 2003-07-15 21:26:09 +0000 | [diff] [blame] | 36 | DEBUG(o << " // prefilling: "); |
Misha Brukman | 9fff7e1 | 2003-05-24 00:15:53 +0000 | [diff] [blame] | 37 | // Start by filling in fixed values... |
Misha Brukman | cbfde0a | 2003-05-27 22:19:58 +0000 | [diff] [blame] | 38 | for (unsigned i = 0, e = BI->getNumBits(); i != e; ++i) { |
| 39 | if (BitInit *B = dynamic_cast<BitInit*>(BI->getBit(e-i-1))) { |
| 40 | Value |= B->getValue() << (e-i-1); |
Misha Brukman | f6e5217 | 2003-07-15 21:26:09 +0000 | [diff] [blame] | 41 | DEBUG(o << B->getValue()); |
Misha Brukman | cbfde0a | 2003-05-27 22:19:58 +0000 | [diff] [blame] | 42 | } else { |
Misha Brukman | f6e5217 | 2003-07-15 21:26:09 +0000 | [diff] [blame] | 43 | DEBUG(o << "0"); |
Misha Brukman | cbfde0a | 2003-05-27 22:19:58 +0000 | [diff] [blame] | 44 | } |
| 45 | } |
Misha Brukman | f6e5217 | 2003-07-15 21:26:09 +0000 | [diff] [blame] | 46 | DEBUG(o << "\n"); |
Misha Brukman | 9fff7e1 | 2003-05-24 00:15:53 +0000 | [diff] [blame] | 47 | |
Chris Lattner | 6f334ad | 2003-08-01 04:46:24 +0000 | [diff] [blame] | 48 | DEBUG(o << " // " << *R->getValue("Inst") << "\n"); |
Misha Brukman | cbfde0a | 2003-05-27 22:19:58 +0000 | [diff] [blame] | 49 | o << " Value = " << Value << "U;\n\n"; |
Misha Brukman | 9fff7e1 | 2003-05-24 00:15:53 +0000 | [diff] [blame] | 50 | |
Chris Lattner | d7efef9 | 2003-08-05 03:53:04 +0000 | [diff] [blame] | 51 | // Loop over all of the fields in the instruction determining which are the |
| 52 | // operands to the instruction. |
Misha Brukman | 9fff7e1 | 2003-05-24 00:15:53 +0000 | [diff] [blame] | 53 | // |
Misha Brukman | cbfde0a | 2003-05-27 22:19:58 +0000 | [diff] [blame] | 54 | unsigned op = 0; |
Chris Lattner | d7efef9 | 2003-08-05 03:53:04 +0000 | [diff] [blame] | 55 | std::map<std::string, unsigned> OpOrder; |
| 56 | std::map<std::string, bool> OpContinuous; |
Misha Brukman | 9fff7e1 | 2003-05-24 00:15:53 +0000 | [diff] [blame] | 57 | for (unsigned i = 0, e = Vals.size(); i != e; ++i) { |
Misha Brukman | d88ba5a | 2003-08-05 14:35:35 +0000 | [diff] [blame] | 58 | if (!Vals[i].getPrefix() && !Vals[i].getValue()->isComplete()) { |
Misha Brukman | 7eac476 | 2003-07-15 21:00:32 +0000 | [diff] [blame] | 59 | // Is the operand continuous? If so, we can just mask and OR it in |
| 60 | // instead of doing it bit-by-bit, saving a lot in runtime cost. |
| 61 | const BitsInit *InstInit = BI; |
Chris Lattner | d7efef9 | 2003-08-05 03:53:04 +0000 | [diff] [blame] | 62 | int beginBitInVar = -1, endBitInVar = -1; |
| 63 | int beginBitInInst = -1, endBitInInst = -1; |
Misha Brukman | 7eac476 | 2003-07-15 21:00:32 +0000 | [diff] [blame] | 64 | bool continuous = true; |
| 65 | |
| 66 | for (int bit = InstInit->getNumBits()-1; bit >= 0; --bit) { |
| 67 | if (VarBitInit *VBI = |
| 68 | dynamic_cast<VarBitInit*>(InstInit->getBit(bit))) { |
| 69 | TypedInit *TI = VBI->getVariable(); |
| 70 | if (VarInit *VI = dynamic_cast<VarInit*>(TI)) { |
| 71 | // only process the current variable |
| 72 | if (VI->getName() != Vals[i].getName()) |
| 73 | continue; |
| 74 | |
| 75 | if (beginBitInVar == -1) |
| 76 | beginBitInVar = VBI->getBitNum(); |
| 77 | |
| 78 | if (endBitInVar == -1) |
| 79 | endBitInVar = VBI->getBitNum(); |
| 80 | else { |
| 81 | if (endBitInVar == (int)VBI->getBitNum() + 1) |
| 82 | endBitInVar = VBI->getBitNum(); |
| 83 | else { |
| 84 | continuous = false; |
| 85 | break; |
| 86 | } |
| 87 | } |
| 88 | |
| 89 | if (beginBitInInst == -1) |
| 90 | beginBitInInst = bit; |
| 91 | if (endBitInInst == -1) |
| 92 | endBitInInst = bit; |
| 93 | else { |
| 94 | if (endBitInInst == bit + 1) |
| 95 | endBitInInst = bit; |
| 96 | else { |
| 97 | continuous = false; |
| 98 | break; |
| 99 | } |
| 100 | } |
| 101 | |
| 102 | // maintain same distance between bits in field and bits in |
| 103 | // instruction. if the relative distances stay the same |
| 104 | // throughout, |
Chris Lattner | d7efef9 | 2003-08-05 03:53:04 +0000 | [diff] [blame] | 105 | if (beginBitInVar - (int)VBI->getBitNum() != |
| 106 | beginBitInInst - bit) { |
Misha Brukman | 7eac476 | 2003-07-15 21:00:32 +0000 | [diff] [blame] | 107 | continuous = false; |
| 108 | break; |
| 109 | } |
| 110 | } |
| 111 | } |
| 112 | } |
| 113 | |
Chris Lattner | ffaee37 | 2003-08-05 03:59:01 +0000 | [diff] [blame] | 114 | // If we have found no bit in "Inst" which comes from this field, then |
| 115 | // this is not an operand!! |
Chris Lattner | d7efef9 | 2003-08-05 03:53:04 +0000 | [diff] [blame] | 116 | if (beginBitInInst != -1) { |
| 117 | o << " // op" << op << ": " << Vals[i].getName() << "\n" |
| 118 | << " int64_t op" << op |
| 119 | <<" = getMachineOpValue(MI, MI.getOperand("<<op<<"));\n"; |
| 120 | //<< " MachineOperand &op" << op <<" = MI.getOperand("<<op<<");\n"; |
| 121 | OpOrder[Vals[i].getName()] = op++; |
Misha Brukman | 7eac476 | 2003-07-15 21:00:32 +0000 | [diff] [blame] | 122 | |
Chris Lattner | d7efef9 | 2003-08-05 03:53:04 +0000 | [diff] [blame] | 123 | DEBUG(o << " // Var: begin = " << beginBitInVar |
| 124 | << ", end = " << endBitInVar |
| 125 | << "; Inst: begin = " << beginBitInInst |
| 126 | << ", end = " << endBitInInst << "\n"); |
| 127 | |
| 128 | if (continuous) { |
| 129 | DEBUG(o << " // continuous: op" << OpOrder[Vals[i].getName()] |
| 130 | << "\n"); |
| 131 | |
| 132 | // Mask off the right bits |
| 133 | // Low mask (ie. shift, if necessary) |
| 134 | if (endBitInVar != 0) { |
| 135 | o << " op" << OpOrder[Vals[i].getName()] |
| 136 | << " >>= " << endBitInVar << ";\n"; |
| 137 | beginBitInVar -= endBitInVar; |
| 138 | endBitInVar = 0; |
| 139 | } |
| 140 | |
| 141 | // High mask |
Misha Brukman | 7eac476 | 2003-07-15 21:00:32 +0000 | [diff] [blame] | 142 | o << " op" << OpOrder[Vals[i].getName()] |
Chris Lattner | d7efef9 | 2003-08-05 03:53:04 +0000 | [diff] [blame] | 143 | << " &= (1<<" << beginBitInVar+1 << ") - 1;\n"; |
| 144 | |
| 145 | // Shift the value to the correct place (according to place in inst) |
| 146 | if (endBitInInst != 0) |
| 147 | o << " op" << OpOrder[Vals[i].getName()] |
Misha Brukman | 7eac476 | 2003-07-15 21:00:32 +0000 | [diff] [blame] | 148 | << " <<= " << endBitInInst << ";\n"; |
Chris Lattner | d7efef9 | 2003-08-05 03:53:04 +0000 | [diff] [blame] | 149 | |
| 150 | // Just OR in the result |
| 151 | o << " Value |= op" << OpOrder[Vals[i].getName()] << ";\n"; |
| 152 | } |
| 153 | |
| 154 | // otherwise, will be taken care of in the loop below using this |
| 155 | // value: |
| 156 | OpContinuous[Vals[i].getName()] = continuous; |
Misha Brukman | 7eac476 | 2003-07-15 21:00:32 +0000 | [diff] [blame] | 157 | } |
Misha Brukman | 9fff7e1 | 2003-05-24 00:15:53 +0000 | [diff] [blame] | 158 | } |
| 159 | } |
| 160 | |
Misha Brukman | 48aa824 | 2003-07-07 22:30:44 +0000 | [diff] [blame] | 161 | for (unsigned f = 0, e = Vals.size(); f != e; ++f) { |
Misha Brukman | 9fff7e1 | 2003-05-24 00:15:53 +0000 | [diff] [blame] | 162 | if (Vals[f].getPrefix()) { |
| 163 | BitsInit *FieldInitializer = (BitsInit*)Vals[f].getValue(); |
| 164 | |
| 165 | // Scan through the field looking for bit initializers of the current |
| 166 | // variable... |
| 167 | for (int i = FieldInitializer->getNumBits()-1; i >= 0; --i) { |
Chris Lattner | ffaee37 | 2003-08-05 03:59:01 +0000 | [diff] [blame] | 168 | if (BitInit *BI = dynamic_cast<BitInit*>(FieldInitializer->getBit(i))) |
Misha Brukman | 7eac476 | 2003-07-15 21:00:32 +0000 | [diff] [blame] | 169 | { |
Misha Brukman | f6e5217 | 2003-07-15 21:26:09 +0000 | [diff] [blame] | 170 | DEBUG(o << " // bit init: f: " << f << ", i: " << i << "\n"); |
Misha Brukman | 7eac476 | 2003-07-15 21:00:32 +0000 | [diff] [blame] | 171 | } else if (UnsetInit *UI = |
Misha Brukman | 9fff7e1 | 2003-05-24 00:15:53 +0000 | [diff] [blame] | 172 | dynamic_cast<UnsetInit*>(FieldInitializer->getBit(i))) { |
Misha Brukman | f6e5217 | 2003-07-15 21:26:09 +0000 | [diff] [blame] | 173 | DEBUG(o << " // unset init: f: " << f << ", i: " << i << "\n"); |
Misha Brukman | 9fff7e1 | 2003-05-24 00:15:53 +0000 | [diff] [blame] | 174 | } else if (VarBitInit *VBI = |
| 175 | dynamic_cast<VarBitInit*>(FieldInitializer->getBit(i))) { |
| 176 | TypedInit *TI = VBI->getVariable(); |
| 177 | if (VarInit *VI = dynamic_cast<VarInit*>(TI)) { |
Misha Brukman | 7eac476 | 2003-07-15 21:00:32 +0000 | [diff] [blame] | 178 | // If the bits of the field are laid out consecutively in the |
| 179 | // instruction, then instead of separately ORing in bits, just |
| 180 | // mask and shift the entire field for efficiency. |
| 181 | if (OpContinuous[VI->getName()]) { |
| 182 | // already taken care of in the loop above, thus there is no |
| 183 | // need to individually OR in the bits |
| 184 | |
| 185 | // for debugging, output the regular version anyway, commented |
Misha Brukman | f6e5217 | 2003-07-15 21:26:09 +0000 | [diff] [blame] | 186 | DEBUG(o << " // Value |= getValueBit(op" |
| 187 | << OpOrder[VI->getName()] << ", " << VBI->getBitNum() |
| 188 | << ")" << " << " << i << ";\n"); |
Misha Brukman | 7eac476 | 2003-07-15 21:00:32 +0000 | [diff] [blame] | 189 | } else { |
| 190 | o << " Value |= getValueBit(op" << OpOrder[VI->getName()] |
| 191 | << ", " << VBI->getBitNum() |
| 192 | << ")" << " << " << i << ";\n"; |
| 193 | } |
Misha Brukman | 9fff7e1 | 2003-05-24 00:15:53 +0000 | [diff] [blame] | 194 | } else if (FieldInit *FI = dynamic_cast<FieldInit*>(TI)) { |
| 195 | // FIXME: implement this! |
| 196 | o << "FIELD INIT not implemented yet!\n"; |
| 197 | } else { |
Misha Brukman | cbfde0a | 2003-05-27 22:19:58 +0000 | [diff] [blame] | 198 | o << "Error: UNIMPLEMENTED\n"; |
Misha Brukman | 9fff7e1 | 2003-05-24 00:15:53 +0000 | [diff] [blame] | 199 | } |
| 200 | } |
Misha Brukman | 7eac476 | 2003-07-15 21:00:32 +0000 | [diff] [blame] | 201 | } |
Misha Brukman | 9fff7e1 | 2003-05-24 00:15:53 +0000 | [diff] [blame] | 202 | } |
| 203 | } |
| 204 | |
| 205 | o << " break;\n" |
| 206 | << " }\n"; |
| 207 | } |
Misha Brukman | 7eac476 | 2003-07-15 21:00:32 +0000 | [diff] [blame] | 208 | |
Misha Brukman | cbfde0a | 2003-05-27 22:19:58 +0000 | [diff] [blame] | 209 | o << " default:\n" |
Misha Brukman | f4ef4c8 | 2003-06-06 00:27:02 +0000 | [diff] [blame] | 210 | << " DEBUG(std::cerr << \"Not supported instr: \" << MI << \"\\n\");\n" |
Misha Brukman | cbfde0a | 2003-05-27 22:19:58 +0000 | [diff] [blame] | 211 | << " abort();\n" |
| 212 | << " }\n" |
Misha Brukman | 9fff7e1 | 2003-05-24 00:15:53 +0000 | [diff] [blame] | 213 | << " return Value;\n" |
| 214 | << "}\n"; |
Misha Brukman | 9fff7e1 | 2003-05-24 00:15:53 +0000 | [diff] [blame] | 215 | } |