AsmWriterEmitter.cpp revision 68ae5b4beab17542b15817815e802475ad1a841f
12e1f51b8a583649d74cb666ca5e4cf680cc1ced9Chris Lattner//===- AsmWriterEmitter.cpp - Generate an assembly writer -----------------===//
23da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman//
32e1f51b8a583649d74cb666ca5e4cf680cc1ced9Chris Lattner//                     The LLVM Compiler Infrastructure
42e1f51b8a583649d74cb666ca5e4cf680cc1ced9Chris Lattner//
53060910e290949a9ac5eda8726d030790c4d60ffChris Lattner// This file is distributed under the University of Illinois Open Source
63060910e290949a9ac5eda8726d030790c4d60ffChris Lattner// License. See LICENSE.TXT for details.
73da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman//
82e1f51b8a583649d74cb666ca5e4cf680cc1ced9Chris Lattner//===----------------------------------------------------------------------===//
92e1f51b8a583649d74cb666ca5e4cf680cc1ced9Chris Lattner//
102e1f51b8a583649d74cb666ca5e4cf680cc1ced9Chris Lattner// This tablegen backend is emits an assembly printer for the current target.
112e1f51b8a583649d74cb666ca5e4cf680cc1ced9Chris Lattner// Note that this is currently fairly skeletal, but will grow over time.
122e1f51b8a583649d74cb666ca5e4cf680cc1ced9Chris Lattner//
132e1f51b8a583649d74cb666ca5e4cf680cc1ced9Chris Lattner//===----------------------------------------------------------------------===//
142e1f51b8a583649d74cb666ca5e4cf680cc1ced9Chris Lattner
152e1f51b8a583649d74cb666ca5e4cf680cc1ced9Chris Lattner#include "AsmWriterEmitter.h"
16d32c02f3145c8d5114c9bd367e9ff15f4aed2e15Sean Callanan#include "AsmWriterInst.h"
170b6a44afb92fed0365b6709c1f46b0c5e49e1a72Jim Grosbach#include "Error.h"
182e1f51b8a583649d74cb666ca5e4cf680cc1ced9Chris Lattner#include "CodeGenTarget.h"
19175580c0f36b026daf9de0adabdb7ddcf7619db6Chris Lattner#include "Record.h"
2044da5fbf97e31d5cf8ca6ebf99c613d116f51445Chris Lattner#include "StringToOffsetTable.h"
21bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson#include "llvm/ADT/Twine.h"
22bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner#include "llvm/Support/Debug.h"
23bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner#include "llvm/Support/MathExtras.h"
24615ed993e115f8bc97ff0678aa861629fec93880Jeff Cohen#include <algorithm>
252e1f51b8a583649d74cb666ca5e4cf680cc1ced9Chris Lattnerusing namespace llvm;
262e1f51b8a583649d74cb666ca5e4cf680cc1ced9Chris Lattner
2738c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattnerstatic void PrintCases(std::vector<std::pair<std::string,
281a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar                       AsmWriterOperand> > &OpsToPrint, raw_ostream &O) {
2938c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner  O << "    case " << OpsToPrint.back().first << ": ";
3038c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner  AsmWriterOperand TheOp = OpsToPrint.back().second;
3138c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner  OpsToPrint.pop_back();
3238c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner
3338c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner  // Check to see if any other operands are identical in this list, and if so,
3438c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner  // emit a case label for them.
3538c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner  for (unsigned i = OpsToPrint.size(); i != 0; --i)
3638c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner    if (OpsToPrint[i-1].second == TheOp) {
3738c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner      O << "\n    case " << OpsToPrint[i-1].first << ": ";
3838c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner      OpsToPrint.erase(OpsToPrint.begin()+i-1);
3938c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner    }
4038c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner
4138c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner  // Finally, emit the code.
42bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner  O << TheOp.getCode();
4338c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner  O << "break;\n";
4438c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner}
4538c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner
46870c016934bacf43995d89531b166ae095ee3675Chris Lattner
47870c016934bacf43995d89531b166ae095ee3675Chris Lattner/// EmitInstructions - Emit the last instruction in the vector and any other
48870c016934bacf43995d89531b166ae095ee3675Chris Lattner/// instructions that are suitably similar to it.
49870c016934bacf43995d89531b166ae095ee3675Chris Lattnerstatic void EmitInstructions(std::vector<AsmWriterInst> &Insts,
501a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar                             raw_ostream &O) {
51870c016934bacf43995d89531b166ae095ee3675Chris Lattner  AsmWriterInst FirstInst = Insts.back();
52870c016934bacf43995d89531b166ae095ee3675Chris Lattner  Insts.pop_back();
53870c016934bacf43995d89531b166ae095ee3675Chris Lattner
54870c016934bacf43995d89531b166ae095ee3675Chris Lattner  std::vector<AsmWriterInst> SimilarInsts;
55870c016934bacf43995d89531b166ae095ee3675Chris Lattner  unsigned DifferingOperand = ~0;
56870c016934bacf43995d89531b166ae095ee3675Chris Lattner  for (unsigned i = Insts.size(); i != 0; --i) {
57f876668518097413a904537ce9d249953987508cChris Lattner    unsigned DiffOp = Insts[i-1].MatchesAllButOneOp(FirstInst);
58f876668518097413a904537ce9d249953987508cChris Lattner    if (DiffOp != ~1U) {
59870c016934bacf43995d89531b166ae095ee3675Chris Lattner      if (DifferingOperand == ~0U)  // First match!
60870c016934bacf43995d89531b166ae095ee3675Chris Lattner        DifferingOperand = DiffOp;
61870c016934bacf43995d89531b166ae095ee3675Chris Lattner
62870c016934bacf43995d89531b166ae095ee3675Chris Lattner      // If this differs in the same operand as the rest of the instructions in
63870c016934bacf43995d89531b166ae095ee3675Chris Lattner      // this class, move it to the SimilarInsts list.
64f876668518097413a904537ce9d249953987508cChris Lattner      if (DifferingOperand == DiffOp || DiffOp == ~0U) {
65870c016934bacf43995d89531b166ae095ee3675Chris Lattner        SimilarInsts.push_back(Insts[i-1]);
66870c016934bacf43995d89531b166ae095ee3675Chris Lattner        Insts.erase(Insts.begin()+i-1);
67870c016934bacf43995d89531b166ae095ee3675Chris Lattner      }
68870c016934bacf43995d89531b166ae095ee3675Chris Lattner    }
69870c016934bacf43995d89531b166ae095ee3675Chris Lattner  }
70870c016934bacf43995d89531b166ae095ee3675Chris Lattner
71a1e8a80b96d02c8667021049e7fba9050658f39bChris Lattner  O << "  case " << FirstInst.CGI->Namespace << "::"
72870c016934bacf43995d89531b166ae095ee3675Chris Lattner    << FirstInst.CGI->TheDef->getName() << ":\n";
73870c016934bacf43995d89531b166ae095ee3675Chris Lattner  for (unsigned i = 0, e = SimilarInsts.size(); i != e; ++i)
74a1e8a80b96d02c8667021049e7fba9050658f39bChris Lattner    O << "  case " << SimilarInsts[i].CGI->Namespace << "::"
75870c016934bacf43995d89531b166ae095ee3675Chris Lattner      << SimilarInsts[i].CGI->TheDef->getName() << ":\n";
76870c016934bacf43995d89531b166ae095ee3675Chris Lattner  for (unsigned i = 0, e = FirstInst.Operands.size(); i != e; ++i) {
77870c016934bacf43995d89531b166ae095ee3675Chris Lattner    if (i != DifferingOperand) {
78870c016934bacf43995d89531b166ae095ee3675Chris Lattner      // If the operand is the same for all instructions, just print it.
79bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner      O << "    " << FirstInst.Operands[i].getCode();
80870c016934bacf43995d89531b166ae095ee3675Chris Lattner    } else {
81870c016934bacf43995d89531b166ae095ee3675Chris Lattner      // If this is the operand that varies between all of the instructions,
82870c016934bacf43995d89531b166ae095ee3675Chris Lattner      // emit a switch for just this operand now.
83870c016934bacf43995d89531b166ae095ee3675Chris Lattner      O << "    switch (MI->getOpcode()) {\n";
8438c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner      std::vector<std::pair<std::string, AsmWriterOperand> > OpsToPrint;
85a1e8a80b96d02c8667021049e7fba9050658f39bChris Lattner      OpsToPrint.push_back(std::make_pair(FirstInst.CGI->Namespace + "::" +
8638c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner                                          FirstInst.CGI->TheDef->getName(),
8738c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner                                          FirstInst.Operands[i]));
883da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman
89870c016934bacf43995d89531b166ae095ee3675Chris Lattner      for (unsigned si = 0, e = SimilarInsts.size(); si != e; ++si) {
9038c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner        AsmWriterInst &AWI = SimilarInsts[si];
91a1e8a80b96d02c8667021049e7fba9050658f39bChris Lattner        OpsToPrint.push_back(std::make_pair(AWI.CGI->Namespace+"::"+
9238c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner                                            AWI.CGI->TheDef->getName(),
9338c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner                                            AWI.Operands[i]));
94870c016934bacf43995d89531b166ae095ee3675Chris Lattner      }
9538c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner      std::reverse(OpsToPrint.begin(), OpsToPrint.end());
9638c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner      while (!OpsToPrint.empty())
9738c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner        PrintCases(OpsToPrint, O);
98870c016934bacf43995d89531b166ae095ee3675Chris Lattner      O << "    }";
99870c016934bacf43995d89531b166ae095ee3675Chris Lattner    }
100870c016934bacf43995d89531b166ae095ee3675Chris Lattner    O << "\n";
101870c016934bacf43995d89531b166ae095ee3675Chris Lattner  }
102870c016934bacf43995d89531b166ae095ee3675Chris Lattner  O << "    break;\n";
103870c016934bacf43995d89531b166ae095ee3675Chris Lattner}
104b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner
105bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattnervoid AsmWriterEmitter::
1069255b8d349768a02b2d139a43984c9b544098122Jim GrosbachFindUniqueOperandCommands(std::vector<std::string> &UniqueOperandCommands,
10796c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner                          std::vector<unsigned> &InstIdxs,
10896c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner                          std::vector<unsigned> &InstOpsUsed) const {
109195bb4a7b0de2bb76ae064a5ab8776094d4fccbbChris Lattner  InstIdxs.assign(NumberedInstructions.size(), ~0U);
1109255b8d349768a02b2d139a43984c9b544098122Jim Grosbach
111bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner  // This vector parallels UniqueOperandCommands, keeping track of which
112bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner  // instructions each case are used for.  It is a comma separated string of
113bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner  // enums.
114bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner  std::vector<std::string> InstrsForCase;
115bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner  InstrsForCase.resize(UniqueOperandCommands.size());
11696c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner  InstOpsUsed.assign(UniqueOperandCommands.size(), 0);
1179255b8d349768a02b2d139a43984c9b544098122Jim Grosbach
118bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner  for (unsigned i = 0, e = NumberedInstructions.size(); i != e; ++i) {
119bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner    const AsmWriterInst *Inst = getAsmWriterInstByID(i);
120b9449d663921fc27d503d048028937c5a19b6f8bBill Wendling    if (Inst == 0) continue;  // PHI, INLINEASM, PROLOG_LABEL, etc.
1219255b8d349768a02b2d139a43984c9b544098122Jim Grosbach
122bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner    std::string Command;
123b84628679ad7240a63d267fc6388efbc1e91f588Chris Lattner    if (Inst->Operands.empty())
124bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner      continue;   // Instruction already done.
125191dd1f1860661f2e0bb99432d10da9b2aff1fc7Chris Lattner
126b84628679ad7240a63d267fc6388efbc1e91f588Chris Lattner    Command = "    " + Inst->Operands[0].getCode() + "\n";
127191dd1f1860661f2e0bb99432d10da9b2aff1fc7Chris Lattner
128bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner    // Check to see if we already have 'Command' in UniqueOperandCommands.
129bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner    // If not, add it.
130bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner    bool FoundIt = false;
131bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner    for (unsigned idx = 0, e = UniqueOperandCommands.size(); idx != e; ++idx)
132bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner      if (UniqueOperandCommands[idx] == Command) {
133bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner        InstIdxs[i] = idx;
134bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner        InstrsForCase[idx] += ", ";
135bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner        InstrsForCase[idx] += Inst->CGI->TheDef->getName();
136bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner        FoundIt = true;
137bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner        break;
138bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner      }
139bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner    if (!FoundIt) {
140bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner      InstIdxs[i] = UniqueOperandCommands.size();
141bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner      UniqueOperandCommands.push_back(Command);
142bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner      InstrsForCase.push_back(Inst->CGI->TheDef->getName());
14396c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner
14496c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner      // This command matches one operand so far.
14596c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner      InstOpsUsed.push_back(1);
14696c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner    }
14796c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner  }
1489255b8d349768a02b2d139a43984c9b544098122Jim Grosbach
14996c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner  // For each entry of UniqueOperandCommands, there is a set of instructions
15096c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner  // that uses it.  If the next command of all instructions in the set are
15196c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner  // identical, fold it into the command.
15296c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner  for (unsigned CommandIdx = 0, e = UniqueOperandCommands.size();
15396c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner       CommandIdx != e; ++CommandIdx) {
1549255b8d349768a02b2d139a43984c9b544098122Jim Grosbach
15596c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner    for (unsigned Op = 1; ; ++Op) {
15696c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner      // Scan for the first instruction in the set.
15796c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner      std::vector<unsigned>::iterator NIT =
15896c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner        std::find(InstIdxs.begin(), InstIdxs.end(), CommandIdx);
15996c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner      if (NIT == InstIdxs.end()) break;  // No commonality.
16096c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner
16196c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner      // If this instruction has no more operands, we isn't anything to merge
16296c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner      // into this command.
1639255b8d349768a02b2d139a43984c9b544098122Jim Grosbach      const AsmWriterInst *FirstInst =
16496c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner        getAsmWriterInstByID(NIT-InstIdxs.begin());
16596c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner      if (!FirstInst || FirstInst->Operands.size() == Op)
16696c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner        break;
16796c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner
16896c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner      // Otherwise, scan to see if all of the other instructions in this command
16996c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner      // set share the operand.
17096c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner      bool AllSame = true;
171c8d060503619d32012167d2427891a85e116f3d2David Greene      // Keep track of the maximum, number of operands or any
172c8d060503619d32012167d2427891a85e116f3d2David Greene      // instruction we see in the group.
173c8d060503619d32012167d2427891a85e116f3d2David Greene      size_t MaxSize = FirstInst->Operands.size();
174c8d060503619d32012167d2427891a85e116f3d2David Greene
17596c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner      for (NIT = std::find(NIT+1, InstIdxs.end(), CommandIdx);
17696c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner           NIT != InstIdxs.end();
17796c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner           NIT = std::find(NIT+1, InstIdxs.end(), CommandIdx)) {
17896c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner        // Okay, found another instruction in this command set.  If the operand
17996c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner        // matches, we're ok, otherwise bail out.
1809255b8d349768a02b2d139a43984c9b544098122Jim Grosbach        const AsmWriterInst *OtherInst =
18196c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner          getAsmWriterInstByID(NIT-InstIdxs.begin());
182c8d060503619d32012167d2427891a85e116f3d2David Greene
183c8d060503619d32012167d2427891a85e116f3d2David Greene        if (OtherInst &&
184c8d060503619d32012167d2427891a85e116f3d2David Greene            OtherInst->Operands.size() > FirstInst->Operands.size())
185c8d060503619d32012167d2427891a85e116f3d2David Greene          MaxSize = std::max(MaxSize, OtherInst->Operands.size());
186c8d060503619d32012167d2427891a85e116f3d2David Greene
18796c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner        if (!OtherInst || OtherInst->Operands.size() == Op ||
18896c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner            OtherInst->Operands[Op] != FirstInst->Operands[Op]) {
18996c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner          AllSame = false;
19096c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner          break;
19196c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner        }
19296c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner      }
19396c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner      if (!AllSame) break;
1949255b8d349768a02b2d139a43984c9b544098122Jim Grosbach
19596c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner      // Okay, everything in this command set has the same next operand.  Add it
19696c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner      // to UniqueOperandCommands and remember that it was consumed.
19796c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner      std::string Command = "    " + FirstInst->Operands[Op].getCode() + "\n";
1989255b8d349768a02b2d139a43984c9b544098122Jim Grosbach
19996c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner      UniqueOperandCommands[CommandIdx] += Command;
20096c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner      InstOpsUsed[CommandIdx]++;
201bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner    }
202bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner  }
2039255b8d349768a02b2d139a43984c9b544098122Jim Grosbach
204bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner  // Prepend some of the instructions each case is used for onto the case val.
205bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner  for (unsigned i = 0, e = InstrsForCase.size(); i != e; ++i) {
206bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner    std::string Instrs = InstrsForCase[i];
207bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner    if (Instrs.size() > 70) {
208bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner      Instrs.erase(Instrs.begin()+70, Instrs.end());
209bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner      Instrs += "...";
210bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner    }
2119255b8d349768a02b2d139a43984c9b544098122Jim Grosbach
212bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner    if (!Instrs.empty())
2139255b8d349768a02b2d139a43984c9b544098122Jim Grosbach      UniqueOperandCommands[i] = "    // " + Instrs + "\n" +
214bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner        UniqueOperandCommands[i];
215bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner  }
216bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner}
217bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner
218bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner
2199bd34602fbe945cc2ed81f8f8ac7de59f4679038Daniel Dunbarstatic void UnescapeString(std::string &Str) {
2209bd34602fbe945cc2ed81f8f8ac7de59f4679038Daniel Dunbar  for (unsigned i = 0; i != Str.size(); ++i) {
2219bd34602fbe945cc2ed81f8f8ac7de59f4679038Daniel Dunbar    if (Str[i] == '\\' && i != Str.size()-1) {
2229bd34602fbe945cc2ed81f8f8ac7de59f4679038Daniel Dunbar      switch (Str[i+1]) {
2239bd34602fbe945cc2ed81f8f8ac7de59f4679038Daniel Dunbar      default: continue;  // Don't execute the code after the switch.
2249bd34602fbe945cc2ed81f8f8ac7de59f4679038Daniel Dunbar      case 'a': Str[i] = '\a'; break;
2259bd34602fbe945cc2ed81f8f8ac7de59f4679038Daniel Dunbar      case 'b': Str[i] = '\b'; break;
2269bd34602fbe945cc2ed81f8f8ac7de59f4679038Daniel Dunbar      case 'e': Str[i] = 27; break;
2279bd34602fbe945cc2ed81f8f8ac7de59f4679038Daniel Dunbar      case 'f': Str[i] = '\f'; break;
2289bd34602fbe945cc2ed81f8f8ac7de59f4679038Daniel Dunbar      case 'n': Str[i] = '\n'; break;
2299bd34602fbe945cc2ed81f8f8ac7de59f4679038Daniel Dunbar      case 'r': Str[i] = '\r'; break;
2309bd34602fbe945cc2ed81f8f8ac7de59f4679038Daniel Dunbar      case 't': Str[i] = '\t'; break;
2319bd34602fbe945cc2ed81f8f8ac7de59f4679038Daniel Dunbar      case 'v': Str[i] = '\v'; break;
2329bd34602fbe945cc2ed81f8f8ac7de59f4679038Daniel Dunbar      case '"': Str[i] = '\"'; break;
2339bd34602fbe945cc2ed81f8f8ac7de59f4679038Daniel Dunbar      case '\'': Str[i] = '\''; break;
2349bd34602fbe945cc2ed81f8f8ac7de59f4679038Daniel Dunbar      case '\\': Str[i] = '\\'; break;
2359bd34602fbe945cc2ed81f8f8ac7de59f4679038Daniel Dunbar      }
2369bd34602fbe945cc2ed81f8f8ac7de59f4679038Daniel Dunbar      // Nuke the second character.
2379bd34602fbe945cc2ed81f8f8ac7de59f4679038Daniel Dunbar      Str.erase(Str.begin()+i+1);
2389bd34602fbe945cc2ed81f8f8ac7de59f4679038Daniel Dunbar    }
2399bd34602fbe945cc2ed81f8f8ac7de59f4679038Daniel Dunbar  }
2409bd34602fbe945cc2ed81f8f8ac7de59f4679038Daniel Dunbar}
2419bd34602fbe945cc2ed81f8f8ac7de59f4679038Daniel Dunbar
24205af2616d0df19638e799d3e7afadea26d96a4baChris Lattner/// EmitPrintInstruction - Generate the code for the "printInstruction" method
24305af2616d0df19638e799d3e7afadea26d96a4baChris Lattner/// implementation.
24405af2616d0df19638e799d3e7afadea26d96a4baChris Lattnervoid AsmWriterEmitter::EmitPrintInstruction(raw_ostream &O) {
24567db883487fca3472fdde51e931657e22d4d0495Chris Lattner  CodeGenTarget Target(Records);
246175580c0f36b026daf9de0adabdb7ddcf7619db6Chris Lattner  Record *AsmWriter = Target.getAsmWriter();
247953c6fe11277c2511744440f5d8d90aca1354e18Chris Lattner  std::string ClassName = AsmWriter->getValueAsString("AsmWriterClassName");
248ca96a861655d3fcfc5ff047e249703930c8330bcJim Grosbach  bool isMC = AsmWriter->getValueAsBit("isMCAsmWriter");
249ca96a861655d3fcfc5ff047e249703930c8330bcJim Grosbach  const char *MachineInstrClassName = isMC ? "MCInst" : "MachineInstr";
2509255b8d349768a02b2d139a43984c9b544098122Jim Grosbach
2512e1f51b8a583649d74cb666ca5e4cf680cc1ced9Chris Lattner  O <<
2522e1f51b8a583649d74cb666ca5e4cf680cc1ced9Chris Lattner  "/// printInstruction - This method is automatically generated by tablegen\n"
25305af2616d0df19638e799d3e7afadea26d96a4baChris Lattner  "/// from the instruction set description.\n"
25441aefdcdd1c1631041834d53ffada106a5cfaf02Chris Lattner    "void " << Target.getName() << ClassName
255ca96a861655d3fcfc5ff047e249703930c8330bcJim Grosbach            << "::printInstruction(const " << MachineInstrClassName
256ca96a861655d3fcfc5ff047e249703930c8330bcJim Grosbach            << " *MI, raw_ostream &O) {\n";
2572e1f51b8a583649d74cb666ca5e4cf680cc1ced9Chris Lattner
2585765dba5ce9f493f063a7caf1106e7db9b6693b6Chris Lattner  std::vector<AsmWriterInst> Instructions;
2595765dba5ce9f493f063a7caf1106e7db9b6693b6Chris Lattner
2602e1f51b8a583649d74cb666ca5e4cf680cc1ced9Chris Lattner  for (CodeGenTarget::inst_iterator I = Target.inst_begin(),
2612e1f51b8a583649d74cb666ca5e4cf680cc1ced9Chris Lattner         E = Target.inst_end(); I != E; ++I)
2626a91b18e5777f39e52e93221453abfa4553b6f93Chris Lattner    if (!(*I)->AsmString.empty() &&
2636a91b18e5777f39e52e93221453abfa4553b6f93Chris Lattner        (*I)->TheDef->getName() != "PHI")
264d0bc7f060ece77c670794ef60f7052e2ff1847c9Sean Callanan      Instructions.push_back(
2659255b8d349768a02b2d139a43984c9b544098122Jim Grosbach        AsmWriterInst(**I,
266d0bc7f060ece77c670794ef60f7052e2ff1847c9Sean Callanan                      AsmWriter->getValueAsInt("Variant"),
267d0bc7f060ece77c670794ef60f7052e2ff1847c9Sean Callanan                      AsmWriter->getValueAsInt("FirstOperandColumn"),
268d0bc7f060ece77c670794ef60f7052e2ff1847c9Sean Callanan                      AsmWriter->getValueAsInt("OperandSpacing")));
2695765dba5ce9f493f063a7caf1106e7db9b6693b6Chris Lattner
270bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner  // Get the instruction numbering.
271f65027842e82027dd6e8020586a299aaa548e355Chris Lattner  NumberedInstructions = Target.getInstructionsByEnumValue();
2729255b8d349768a02b2d139a43984c9b544098122Jim Grosbach
2736af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner  // Compute the CodeGenInstruction -> AsmWriterInst mapping.  Note that not
2746af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner  // all machine instructions are necessarily being printed, so there may be
2756af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner  // target instructions not in this map.
2766af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner  for (unsigned i = 0, e = Instructions.size(); i != e; ++i)
2776af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner    CGIAWIMap.insert(std::make_pair(Instructions[i].CGI, &Instructions[i]));
2786af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner
2796af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner  // Build an aggregate string, and build a table of offsets into it.
2803200fc9badda8964fac571995bd74a3954977ddcChris Lattner  StringToOffsetTable StringTable;
2819255b8d349768a02b2d139a43984c9b544098122Jim Grosbach
282259bda48e2c6b886f707513781f1b76595d4ad0dChris Lattner  /// OpcodeInfo - This encodes the index of the string to use for the first
2835561640043666174a1e4d828107702a8992e59f6Chris Lattner  /// chunk of the output as well as indices used for operand printing.
2845561640043666174a1e4d828107702a8992e59f6Chris Lattner  std::vector<unsigned> OpcodeInfo;
2859255b8d349768a02b2d139a43984c9b544098122Jim Grosbach
2865561640043666174a1e4d828107702a8992e59f6Chris Lattner  unsigned MaxStringIdx = 0;
2876af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner  for (unsigned i = 0, e = NumberedInstructions.size(); i != e; ++i) {
2886af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner    AsmWriterInst *AWI = CGIAWIMap[NumberedInstructions[i]];
2896af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner    unsigned Idx;
290a6dc9fb745962564fac3b18da28736b2e094c417Chris Lattner    if (AWI == 0) {
2916af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner      // Something not handled by the asmwriter printer.
2923200fc9badda8964fac571995bd74a3954977ddcChris Lattner      Idx = ~0U;
2939255b8d349768a02b2d139a43984c9b544098122Jim Grosbach    } else if (AWI->Operands[0].OperandType !=
294a6dc9fb745962564fac3b18da28736b2e094c417Chris Lattner                        AsmWriterOperand::isLiteralTextOperand ||
295a6dc9fb745962564fac3b18da28736b2e094c417Chris Lattner               AWI->Operands[0].Str.empty()) {
296a6dc9fb745962564fac3b18da28736b2e094c417Chris Lattner      // Something handled by the asmwriter printer, but with no leading string.
2973200fc9badda8964fac571995bd74a3954977ddcChris Lattner      Idx = StringTable.GetOrAddStringOffset("");
2986af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner    } else {
2993200fc9badda8964fac571995bd74a3954977ddcChris Lattner      std::string Str = AWI->Operands[0].Str;
3003200fc9badda8964fac571995bd74a3954977ddcChris Lattner      UnescapeString(Str);
3013200fc9badda8964fac571995bd74a3954977ddcChris Lattner      Idx = StringTable.GetOrAddStringOffset(Str);
3023200fc9badda8964fac571995bd74a3954977ddcChris Lattner      MaxStringIdx = std::max(MaxStringIdx, Idx);
3039255b8d349768a02b2d139a43984c9b544098122Jim Grosbach
3046af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner      // Nuke the string from the operand list.  It is now handled!
3056af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner      AWI->Operands.erase(AWI->Operands.begin());
3066af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner    }
3079255b8d349768a02b2d139a43984c9b544098122Jim Grosbach
3083200fc9badda8964fac571995bd74a3954977ddcChris Lattner    // Bias offset by one since we want 0 as a sentinel.
3093200fc9badda8964fac571995bd74a3954977ddcChris Lattner    OpcodeInfo.push_back(Idx+1);
310bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner  }
3119255b8d349768a02b2d139a43984c9b544098122Jim Grosbach
3125561640043666174a1e4d828107702a8992e59f6Chris Lattner  // Figure out how many bits we used for the string index.
3133200fc9badda8964fac571995bd74a3954977ddcChris Lattner  unsigned AsmStrBits = Log2_32_Ceil(MaxStringIdx+2);
3149255b8d349768a02b2d139a43984c9b544098122Jim Grosbach
315bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner  // To reduce code size, we compactify common instructions into a few bits
316bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner  // in the opcode-indexed table.
317b51ecd4dd93b8eccf2cba3d541cff0f7cdbf7e1cChris Lattner  unsigned BitsLeft = 32-AsmStrBits;
318bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner
319bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner  std::vector<std::vector<std::string> > TableDrivenOperandPrinters;
3209255b8d349768a02b2d139a43984c9b544098122Jim Grosbach
321b84628679ad7240a63d267fc6388efbc1e91f588Chris Lattner  while (1) {
322bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner    std::vector<std::string> UniqueOperandCommands;
323bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner    std::vector<unsigned> InstIdxs;
32496c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner    std::vector<unsigned> NumInstOpsHandled;
32596c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner    FindUniqueOperandCommands(UniqueOperandCommands, InstIdxs,
32696c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner                              NumInstOpsHandled);
3279255b8d349768a02b2d139a43984c9b544098122Jim Grosbach
328bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner    // If we ran out of operands to print, we're done.
329bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner    if (UniqueOperandCommands.empty()) break;
3309255b8d349768a02b2d139a43984c9b544098122Jim Grosbach
331bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner    // Compute the number of bits we need to represent these cases, this is
332bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner    // ceil(log2(numentries)).
333bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner    unsigned NumBits = Log2_32_Ceil(UniqueOperandCommands.size());
3349255b8d349768a02b2d139a43984c9b544098122Jim Grosbach
335bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner    // If we don't have enough bits for this operand, don't include it.
336bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner    if (NumBits > BitsLeft) {
337569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner      DEBUG(errs() << "Not enough bits to densely encode " << NumBits
338569f121f4ecc53f8ab505c4ccb6e1e77c78e188dChris Lattner                   << " more bits\n");
339bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner      break;
340bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner    }
3419255b8d349768a02b2d139a43984c9b544098122Jim Grosbach
342bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner    // Otherwise, we can include this in the initial lookup table.  Add it in.
343bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner    BitsLeft -= NumBits;
344bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner    for (unsigned i = 0, e = InstIdxs.size(); i != e; ++i)
345195bb4a7b0de2bb76ae064a5ab8776094d4fccbbChris Lattner      if (InstIdxs[i] != ~0U)
346195bb4a7b0de2bb76ae064a5ab8776094d4fccbbChris Lattner        OpcodeInfo[i] |= InstIdxs[i] << (BitsLeft+AsmStrBits);
3479255b8d349768a02b2d139a43984c9b544098122Jim Grosbach
348b84628679ad7240a63d267fc6388efbc1e91f588Chris Lattner    // Remove the info about this operand.
349b84628679ad7240a63d267fc6388efbc1e91f588Chris Lattner    for (unsigned i = 0, e = NumberedInstructions.size(); i != e; ++i) {
350b84628679ad7240a63d267fc6388efbc1e91f588Chris Lattner      if (AsmWriterInst *Inst = getAsmWriterInstByID(i))
35196c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner        if (!Inst->Operands.empty()) {
35296c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner          unsigned NumOps = NumInstOpsHandled[InstIdxs[i]];
3530a012128574c93d5b85adffd14eb4b07883fba4cChris Lattner          assert(NumOps <= Inst->Operands.size() &&
3540a012128574c93d5b85adffd14eb4b07883fba4cChris Lattner                 "Can't remove this many ops!");
35596c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner          Inst->Operands.erase(Inst->Operands.begin(),
35696c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner                               Inst->Operands.begin()+NumOps);
35796c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner        }
358b84628679ad7240a63d267fc6388efbc1e91f588Chris Lattner    }
3599255b8d349768a02b2d139a43984c9b544098122Jim Grosbach
360b84628679ad7240a63d267fc6388efbc1e91f588Chris Lattner    // Remember the handlers for this set of operands.
361bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner    TableDrivenOperandPrinters.push_back(UniqueOperandCommands);
362bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner  }
3639255b8d349768a02b2d139a43984c9b544098122Jim Grosbach
3649255b8d349768a02b2d139a43984c9b544098122Jim Grosbach
3659255b8d349768a02b2d139a43984c9b544098122Jim Grosbach
3665561640043666174a1e4d828107702a8992e59f6Chris Lattner  O<<"  static const unsigned OpInfo[] = {\n";
367bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner  for (unsigned i = 0, e = NumberedInstructions.size(); i != e; ++i) {
368b51ecd4dd93b8eccf2cba3d541cff0f7cdbf7e1cChris Lattner    O << "    " << OpcodeInfo[i] << "U,\t// "
3695561640043666174a1e4d828107702a8992e59f6Chris Lattner      << NumberedInstructions[i]->TheDef->getName() << "\n";
3706af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner  }
371bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner  // Add a dummy entry so the array init doesn't end with a comma.
3725561640043666174a1e4d828107702a8992e59f6Chris Lattner  O << "    0U\n";
3736af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner  O << "  };\n\n";
3749255b8d349768a02b2d139a43984c9b544098122Jim Grosbach
3756af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner  // Emit the string itself.
3763200fc9badda8964fac571995bd74a3954977ddcChris Lattner  O << "  const char *AsmStrs = \n";
3773200fc9badda8964fac571995bd74a3954977ddcChris Lattner  StringTable.EmitString(O);
3783200fc9badda8964fac571995bd74a3954977ddcChris Lattner  O << ";\n\n";
3796af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner
3804eecdeb3faf5df864790175da5d58301b751ec11Evan Cheng  O << "  O << \"\\t\";\n\n";
3814eecdeb3faf5df864790175da5d58301b751ec11Evan Cheng
3826af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner  O << "  // Emit the opcode for the instruction.\n"
3835561640043666174a1e4d828107702a8992e59f6Chris Lattner    << "  unsigned Bits = OpInfo[MI->getOpcode()];\n"
38441aefdcdd1c1631041834d53ffada106a5cfaf02Chris Lattner    << "  assert(Bits != 0 && \"Cannot print this instruction.\");\n"
3853200fc9badda8964fac571995bd74a3954977ddcChris Lattner    << "  O << AsmStrs+(Bits & " << (1 << AsmStrBits)-1 << ")-1;\n\n";
386a5bb59f85613e8ce481351803e7388f5ab466e72David Greene
387bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner  // Output the table driven operand information.
388b51ecd4dd93b8eccf2cba3d541cff0f7cdbf7e1cChris Lattner  BitsLeft = 32-AsmStrBits;
389bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner  for (unsigned i = 0, e = TableDrivenOperandPrinters.size(); i != e; ++i) {
390bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner    std::vector<std::string> &Commands = TableDrivenOperandPrinters[i];
391f876668518097413a904537ce9d249953987508cChris Lattner
392bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner    // Compute the number of bits we need to represent these cases, this is
393bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner    // ceil(log2(numentries)).
394bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner    unsigned NumBits = Log2_32_Ceil(Commands.size());
395bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner    assert(NumBits <= BitsLeft && "consistency error");
3969255b8d349768a02b2d139a43984c9b544098122Jim Grosbach
397bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner    // Emit code to extract this field from Bits.
398bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner    BitsLeft -= NumBits;
3999255b8d349768a02b2d139a43984c9b544098122Jim Grosbach
400bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner    O << "\n  // Fragment " << i << " encoded into " << NumBits
401e7a589df09ed4d1f0853fb586609b00357a34ac2Chris Lattner      << " bits for " << Commands.size() << " unique commands.\n";
4029255b8d349768a02b2d139a43984c9b544098122Jim Grosbach
40396c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner    if (Commands.size() == 2) {
404e7a589df09ed4d1f0853fb586609b00357a34ac2Chris Lattner      // Emit two possibilitys with if/else.
405e7a589df09ed4d1f0853fb586609b00357a34ac2Chris Lattner      O << "  if ((Bits >> " << (BitsLeft+AsmStrBits) << ") & "
406e7a589df09ed4d1f0853fb586609b00357a34ac2Chris Lattner        << ((1 << NumBits)-1) << ") {\n"
407e7a589df09ed4d1f0853fb586609b00357a34ac2Chris Lattner        << Commands[1]
408e7a589df09ed4d1f0853fb586609b00357a34ac2Chris Lattner        << "  } else {\n"
409e7a589df09ed4d1f0853fb586609b00357a34ac2Chris Lattner        << Commands[0]
410e7a589df09ed4d1f0853fb586609b00357a34ac2Chris Lattner        << "  }\n\n";
411168705049c55feec88aec65af0aef07fc1376ce6Eric Christopher    } else if (Commands.size() == 1) {
412168705049c55feec88aec65af0aef07fc1376ce6Eric Christopher      // Emit a single possibility.
413168705049c55feec88aec65af0aef07fc1376ce6Eric Christopher      O << Commands[0] << "\n\n";
414e7a589df09ed4d1f0853fb586609b00357a34ac2Chris Lattner    } else {
415e7a589df09ed4d1f0853fb586609b00357a34ac2Chris Lattner      O << "  switch ((Bits >> " << (BitsLeft+AsmStrBits) << ") & "
416e7a589df09ed4d1f0853fb586609b00357a34ac2Chris Lattner        << ((1 << NumBits)-1) << ") {\n"
417e7a589df09ed4d1f0853fb586609b00357a34ac2Chris Lattner        << "  default:   // unreachable.\n";
4189255b8d349768a02b2d139a43984c9b544098122Jim Grosbach
419e7a589df09ed4d1f0853fb586609b00357a34ac2Chris Lattner      // Print out all the cases.
420e7a589df09ed4d1f0853fb586609b00357a34ac2Chris Lattner      for (unsigned i = 0, e = Commands.size(); i != e; ++i) {
421e7a589df09ed4d1f0853fb586609b00357a34ac2Chris Lattner        O << "  case " << i << ":\n";
422e7a589df09ed4d1f0853fb586609b00357a34ac2Chris Lattner        O << Commands[i];
423e7a589df09ed4d1f0853fb586609b00357a34ac2Chris Lattner        O << "    break;\n";
424e7a589df09ed4d1f0853fb586609b00357a34ac2Chris Lattner      }
425e7a589df09ed4d1f0853fb586609b00357a34ac2Chris Lattner      O << "  }\n\n";
426bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner    }
427bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner  }
4289255b8d349768a02b2d139a43984c9b544098122Jim Grosbach
429b84628679ad7240a63d267fc6388efbc1e91f588Chris Lattner  // Okay, delete instructions with no operand info left.
430bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner  for (unsigned i = 0, e = Instructions.size(); i != e; ++i) {
431bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner    // Entire instruction has been emitted?
432bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner    AsmWriterInst &Inst = Instructions[i];
433b84628679ad7240a63d267fc6388efbc1e91f588Chris Lattner    if (Inst.Operands.empty()) {
434bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner      Instructions.erase(Instructions.begin()+i);
435b84628679ad7240a63d267fc6388efbc1e91f588Chris Lattner      --i; --e;
436bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner    }
437bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner  }
438bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner
4399255b8d349768a02b2d139a43984c9b544098122Jim Grosbach
440bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner  // Because this is a vector, we want to emit from the end.  Reverse all of the
441870c016934bacf43995d89531b166ae095ee3675Chris Lattner  // elements in the vector.
442870c016934bacf43995d89531b166ae095ee3675Chris Lattner  std::reverse(Instructions.begin(), Instructions.end());
4439255b8d349768a02b2d139a43984c9b544098122Jim Grosbach
4449255b8d349768a02b2d139a43984c9b544098122Jim Grosbach
445700676087f338ff8eae3b90d34095df88a7b6c46Chris Lattner  // Now that we've emitted all of the operand info that fit into 32 bits, emit
446700676087f338ff8eae3b90d34095df88a7b6c46Chris Lattner  // information for those instructions that are left.  This is a less dense
447700676087f338ff8eae3b90d34095df88a7b6c46Chris Lattner  // encoding, but we expect the main 32-bit table to handle the majority of
448700676087f338ff8eae3b90d34095df88a7b6c46Chris Lattner  // instructions.
449b51ecd4dd93b8eccf2cba3d541cff0f7cdbf7e1cChris Lattner  if (!Instructions.empty()) {
450b51ecd4dd93b8eccf2cba3d541cff0f7cdbf7e1cChris Lattner    // Find the opcode # of inline asm.
451b51ecd4dd93b8eccf2cba3d541cff0f7cdbf7e1cChris Lattner    O << "  switch (MI->getOpcode()) {\n";
452b51ecd4dd93b8eccf2cba3d541cff0f7cdbf7e1cChris Lattner    while (!Instructions.empty())
453b51ecd4dd93b8eccf2cba3d541cff0f7cdbf7e1cChris Lattner      EmitInstructions(Instructions, O);
454870c016934bacf43995d89531b166ae095ee3675Chris Lattner
455b51ecd4dd93b8eccf2cba3d541cff0f7cdbf7e1cChris Lattner    O << "  }\n";
45641aefdcdd1c1631041834d53ffada106a5cfaf02Chris Lattner    O << "  return;\n";
457b51ecd4dd93b8eccf2cba3d541cff0f7cdbf7e1cChris Lattner  }
458c8d060503619d32012167d2427891a85e116f3d2David Greene
4590a012128574c93d5b85adffd14eb4b07883fba4cChris Lattner  O << "}\n";
4602e1f51b8a583649d74cb666ca5e4cf680cc1ced9Chris Lattner}
46105af2616d0df19638e799d3e7afadea26d96a4baChris Lattner
462bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Andersonstatic void
463bea6f615eefae279e53bbb63a31d2c3c67274c45Owen AndersonemitRegisterNameString(raw_ostream &O, StringRef AltName,
464bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson  const std::vector<CodeGenRegister*> &Registers) {
465bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson  StringToOffsetTable StringTable;
466bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson  O << "  static const unsigned RegAsmOffset" << AltName << "[] = {\n    ";
467bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson  for (unsigned i = 0, e = Registers.size(); i != e; ++i) {
468bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson    const CodeGenRegister &Reg = *Registers[i];
469bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson
4702e10b0874447c8627a86d551f28f88620e0958c7Francois Pichet    std::string AsmName;
471bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson    // "NoRegAltName" is special. We don't need to do a lookup for that,
472bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson    // as it's just a reference to the default register name.
473bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson    if (AltName == "" || AltName == "NoRegAltName") {
474bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson      AsmName = Reg.TheDef->getValueAsString("AsmName");
475bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson      if (AsmName.empty())
476bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson        AsmName = Reg.getName();
477bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson    } else {
478bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson      // Make sure the register has an alternate name for this index.
479bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson      std::vector<Record*> AltNameList =
480bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson        Reg.TheDef->getValueAsListOfDefs("RegAltNameIndices");
481bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson      unsigned Idx = 0, e;
482bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson      for (e = AltNameList.size();
483bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson           Idx < e && (AltNameList[Idx]->getName() != AltName);
484bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson           ++Idx)
485bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson        ;
486bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson      // If the register has an alternate name for this index, use it.
487bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson      // Otherwise, leave it empty as an error flag.
488bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson      if (Idx < e) {
489bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson        std::vector<std::string> AltNames =
490bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson          Reg.TheDef->getValueAsListOfStrings("AltNames");
491bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson        if (AltNames.size() <= Idx)
492bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson          throw TGError(Reg.TheDef->getLoc(),
493bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson                        (Twine("Register definition missing alt name for '") +
494bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson                        AltName + "'.").str());
495bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson        AsmName = AltNames[Idx];
496bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson      }
497bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson    }
498bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson
499bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson    O << StringTable.GetOrAddStringOffset(AsmName);
500bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson    if (((i + 1) % 14) == 0)
501bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson      O << ",\n    ";
502bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson    else
503bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson      O << ", ";
504bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson
505bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson  }
506bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson  O << "0\n"
507bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson    << "  };\n"
508bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson    << "\n";
509bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson
510bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson  O << "  const char *AsmStrs" << AltName << " =\n";
511bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson  StringTable.EmitString(O);
512bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson  O << ";\n";
513bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson}
51405af2616d0df19638e799d3e7afadea26d96a4baChris Lattner
51505af2616d0df19638e799d3e7afadea26d96a4baChris Lattnervoid AsmWriterEmitter::EmitGetRegisterName(raw_ostream &O) {
51667db883487fca3472fdde51e931657e22d4d0495Chris Lattner  CodeGenTarget Target(Records);
51705af2616d0df19638e799d3e7afadea26d96a4baChris Lattner  Record *AsmWriter = Target.getAsmWriter();
51805af2616d0df19638e799d3e7afadea26d96a4baChris Lattner  std::string ClassName = AsmWriter->getValueAsString("AsmWriterClassName");
519abdbc84b4ed4276ed3def50f554e3ba156325717Jakob Stoklund Olesen  const std::vector<CodeGenRegister*> &Registers =
520abdbc84b4ed4276ed3def50f554e3ba156325717Jakob Stoklund Olesen    Target.getRegBank().getRegisters();
521bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson  std::vector<Record*> AltNameIndices = Target.getRegAltNameIndices();
522bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson  bool hasAltNames = AltNameIndices.size() > 1;
5239255b8d349768a02b2d139a43984c9b544098122Jim Grosbach
52405af2616d0df19638e799d3e7afadea26d96a4baChris Lattner  O <<
52505af2616d0df19638e799d3e7afadea26d96a4baChris Lattner  "\n\n/// getRegisterName - This method is automatically generated by tblgen\n"
52605af2616d0df19638e799d3e7afadea26d96a4baChris Lattner  "/// from the register set description.  This returns the assembler name\n"
52705af2616d0df19638e799d3e7afadea26d96a4baChris Lattner  "/// for the specified register.\n"
528bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson  "const char *" << Target.getName() << ClassName << "::";
529bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson  if (hasAltNames)
530bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson    O << "\ngetRegisterName(unsigned RegNo, unsigned AltIdx) {\n";
531bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson  else
532bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson    O << "getRegisterName(unsigned RegNo) {\n";
533bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson  O << "  assert(RegNo && RegNo < " << (Registers.size()+1)
534bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson    << " && \"Invalid register number!\");\n"
535f6761be50d9fe4beee1a8a9eeedb33e529011f9fChris Lattner    << "\n";
5369255b8d349768a02b2d139a43984c9b544098122Jim Grosbach
537bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson  if (hasAltNames) {
538bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson    for (unsigned i = 0, e = AltNameIndices.size(); i < e; ++i)
539bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson      emitRegisterNameString(O, AltNameIndices[i]->getName(), Registers);
540bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson  } else
541bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson    emitRegisterNameString(O, "", Registers);
542bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson
543bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson  if (hasAltNames) {
544bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson    O << "  const unsigned *RegAsmOffset;\n"
545bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson      << "  const char *AsmStrs;\n"
546bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson      << "  switch(AltIdx) {\n"
547bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson      << "  default: assert(0 && \"Invalid register alt name index!\");\n";
548bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson    for (unsigned i = 0, e = AltNameIndices.size(); i < e; ++i) {
549bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson      StringRef Namespace = AltNameIndices[1]->getValueAsString("Namespace");
550bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson      StringRef AltName(AltNameIndices[i]->getName());
551bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson      O << "  case " << Namespace << "::" << AltName
552bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson        << ":\n"
553bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson        << "    AsmStrs = AsmStrs" << AltName  << ";\n"
554bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson        << "    RegAsmOffset = RegAsmOffset" << AltName << ";\n"
555bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson        << "    break;\n";
556bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson    }
557bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson    O << "}\n";
558bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson  }
5599255b8d349768a02b2d139a43984c9b544098122Jim Grosbach
560bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson  O << "  assert (*(AsmStrs+RegAsmOffset[RegNo-1]) &&\n"
561bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson    << "          \"Invalid alt name index for register!\");\n"
562bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson    << "  return AsmStrs+RegAsmOffset[RegNo-1];\n"
56305af2616d0df19638e799d3e7afadea26d96a4baChris Lattner    << "}\n";
56405af2616d0df19638e799d3e7afadea26d96a4baChris Lattner}
56505af2616d0df19638e799d3e7afadea26d96a4baChris Lattner
5660d7b0aa76036abc3118d148fbf02ad287bc7be6cChris Lattnervoid AsmWriterEmitter::EmitGetInstructionName(raw_ostream &O) {
56767db883487fca3472fdde51e931657e22d4d0495Chris Lattner  CodeGenTarget Target(Records);
5680d7b0aa76036abc3118d148fbf02ad287bc7be6cChris Lattner  Record *AsmWriter = Target.getAsmWriter();
5690d7b0aa76036abc3118d148fbf02ad287bc7be6cChris Lattner  std::string ClassName = AsmWriter->getValueAsString("AsmWriterClassName");
5700d7b0aa76036abc3118d148fbf02ad287bc7be6cChris Lattner
571f65027842e82027dd6e8020586a299aaa548e355Chris Lattner  const std::vector<const CodeGenInstruction*> &NumberedInstructions =
572f65027842e82027dd6e8020586a299aaa548e355Chris Lattner    Target.getInstructionsByEnumValue();
5739255b8d349768a02b2d139a43984c9b544098122Jim Grosbach
5740d7b0aa76036abc3118d148fbf02ad287bc7be6cChris Lattner  StringToOffsetTable StringTable;
5750d7b0aa76036abc3118d148fbf02ad287bc7be6cChris Lattner  O <<
5760d7b0aa76036abc3118d148fbf02ad287bc7be6cChris Lattner"\n\n#ifdef GET_INSTRUCTION_NAME\n"
5770d7b0aa76036abc3118d148fbf02ad287bc7be6cChris Lattner"#undef GET_INSTRUCTION_NAME\n\n"
5780d7b0aa76036abc3118d148fbf02ad287bc7be6cChris Lattner"/// getInstructionName: This method is automatically generated by tblgen\n"
5790d7b0aa76036abc3118d148fbf02ad287bc7be6cChris Lattner"/// from the instruction set description.  This returns the enum name of the\n"
5800d7b0aa76036abc3118d148fbf02ad287bc7be6cChris Lattner"/// specified instruction.\n"
5810d7b0aa76036abc3118d148fbf02ad287bc7be6cChris Lattner  "const char *" << Target.getName() << ClassName
5820d7b0aa76036abc3118d148fbf02ad287bc7be6cChris Lattner  << "::getInstructionName(unsigned Opcode) {\n"
5830d7b0aa76036abc3118d148fbf02ad287bc7be6cChris Lattner  << "  assert(Opcode < " << NumberedInstructions.size()
5840d7b0aa76036abc3118d148fbf02ad287bc7be6cChris Lattner  << " && \"Invalid instruction number!\");\n"
5850d7b0aa76036abc3118d148fbf02ad287bc7be6cChris Lattner  << "\n"
5860d7b0aa76036abc3118d148fbf02ad287bc7be6cChris Lattner  << "  static const unsigned InstAsmOffset[] = {";
5870d7b0aa76036abc3118d148fbf02ad287bc7be6cChris Lattner  for (unsigned i = 0, e = NumberedInstructions.size(); i != e; ++i) {
5880d7b0aa76036abc3118d148fbf02ad287bc7be6cChris Lattner    const CodeGenInstruction &Inst = *NumberedInstructions[i];
5899255b8d349768a02b2d139a43984c9b544098122Jim Grosbach
5900d7b0aa76036abc3118d148fbf02ad287bc7be6cChris Lattner    std::string AsmName = Inst.TheDef->getName();
5910d7b0aa76036abc3118d148fbf02ad287bc7be6cChris Lattner    if ((i % 14) == 0)
5920d7b0aa76036abc3118d148fbf02ad287bc7be6cChris Lattner      O << "\n    ";
5939255b8d349768a02b2d139a43984c9b544098122Jim Grosbach
5940d7b0aa76036abc3118d148fbf02ad287bc7be6cChris Lattner    O << StringTable.GetOrAddStringOffset(AsmName) << ", ";
5950d7b0aa76036abc3118d148fbf02ad287bc7be6cChris Lattner  }
5960d7b0aa76036abc3118d148fbf02ad287bc7be6cChris Lattner  O << "0\n"
5970d7b0aa76036abc3118d148fbf02ad287bc7be6cChris Lattner  << "  };\n"
5980d7b0aa76036abc3118d148fbf02ad287bc7be6cChris Lattner  << "\n";
5999255b8d349768a02b2d139a43984c9b544098122Jim Grosbach
6000d7b0aa76036abc3118d148fbf02ad287bc7be6cChris Lattner  O << "  const char *Strs =\n";
6010d7b0aa76036abc3118d148fbf02ad287bc7be6cChris Lattner  StringTable.EmitString(O);
6020d7b0aa76036abc3118d148fbf02ad287bc7be6cChris Lattner  O << ";\n";
6039255b8d349768a02b2d139a43984c9b544098122Jim Grosbach
6040d7b0aa76036abc3118d148fbf02ad287bc7be6cChris Lattner  O << "  return Strs+InstAsmOffset[Opcode];\n"
6050d7b0aa76036abc3118d148fbf02ad287bc7be6cChris Lattner  << "}\n\n#endif\n";
6060d7b0aa76036abc3118d148fbf02ad287bc7be6cChris Lattner}
6070d7b0aa76036abc3118d148fbf02ad287bc7be6cChris Lattner
6082cf6fc6857a3544e56f1e701e826114906b1cc57Bill Wendlingnamespace {
6094962e6143186f6168f5d0ee979bf047651a13124Bill Wendling// IAPrinter - Holds information about an InstAlias. Two InstAliases match if
6104962e6143186f6168f5d0ee979bf047651a13124Bill Wendling// they both have the same conditionals. In which case, we cannot print out the
6114962e6143186f6168f5d0ee979bf047651a13124Bill Wendling// alias for that pattern.
6124962e6143186f6168f5d0ee979bf047651a13124Bill Wendlingclass IAPrinter {
6134962e6143186f6168f5d0ee979bf047651a13124Bill Wendling  std::vector<std::string> Conds;
6144962e6143186f6168f5d0ee979bf047651a13124Bill Wendling  std::map<StringRef, unsigned> OpMap;
6154962e6143186f6168f5d0ee979bf047651a13124Bill Wendling  std::string Result;
6164962e6143186f6168f5d0ee979bf047651a13124Bill Wendling  std::string AsmString;
6174962e6143186f6168f5d0ee979bf047651a13124Bill Wendling  std::vector<Record*> ReqFeatures;
6184962e6143186f6168f5d0ee979bf047651a13124Bill Wendlingpublic:
61968ae5b4beab17542b15817815e802475ad1a841fEvan Cheng  IAPrinter(std::string R, std::string AS)
62068ae5b4beab17542b15817815e802475ad1a841fEvan Cheng    : Result(R), AsmString(AS) {}
6214962e6143186f6168f5d0ee979bf047651a13124Bill Wendling
6224962e6143186f6168f5d0ee979bf047651a13124Bill Wendling  void addCond(const std::string &C) { Conds.push_back(C); }
6234962e6143186f6168f5d0ee979bf047651a13124Bill Wendling
6244962e6143186f6168f5d0ee979bf047651a13124Bill Wendling  void addOperand(StringRef Op, unsigned Idx) { OpMap[Op] = Idx; }
6254962e6143186f6168f5d0ee979bf047651a13124Bill Wendling  unsigned getOpIndex(StringRef Op) { return OpMap[Op]; }
6264962e6143186f6168f5d0ee979bf047651a13124Bill Wendling  bool isOpMapped(StringRef Op) { return OpMap.find(Op) != OpMap.end(); }
6274962e6143186f6168f5d0ee979bf047651a13124Bill Wendling
62868ae5b4beab17542b15817815e802475ad1a841fEvan Cheng  void print(raw_ostream &O) {
62944dcfd36253570ccd5f00189eb918604473135e0Bill Wendling    if (Conds.empty() && ReqFeatures.empty()) {
63044dcfd36253570ccd5f00189eb918604473135e0Bill Wendling      O.indent(6) << "return true;\n";
63168ae5b4beab17542b15817815e802475ad1a841fEvan Cheng      return;
63244dcfd36253570ccd5f00189eb918604473135e0Bill Wendling    }
6333ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling
63444dcfd36253570ccd5f00189eb918604473135e0Bill Wendling    O << "if (";
6354962e6143186f6168f5d0ee979bf047651a13124Bill Wendling
6364962e6143186f6168f5d0ee979bf047651a13124Bill Wendling    for (std::vector<std::string>::iterator
6374962e6143186f6168f5d0ee979bf047651a13124Bill Wendling           I = Conds.begin(), E = Conds.end(); I != E; ++I) {
6384962e6143186f6168f5d0ee979bf047651a13124Bill Wendling      if (I != Conds.begin()) {
6394962e6143186f6168f5d0ee979bf047651a13124Bill Wendling        O << " &&\n";
64044dcfd36253570ccd5f00189eb918604473135e0Bill Wendling        O.indent(8);
6414962e6143186f6168f5d0ee979bf047651a13124Bill Wendling      }
6423ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling
6434962e6143186f6168f5d0ee979bf047651a13124Bill Wendling      O << *I;
6444962e6143186f6168f5d0ee979bf047651a13124Bill Wendling    }
6454962e6143186f6168f5d0ee979bf047651a13124Bill Wendling
64644dcfd36253570ccd5f00189eb918604473135e0Bill Wendling    O << ") {\n";
64744dcfd36253570ccd5f00189eb918604473135e0Bill Wendling    O.indent(6) << "// " << Result << "\n";
64844dcfd36253570ccd5f00189eb918604473135e0Bill Wendling    O.indent(6) << "AsmString = \"" << AsmString << "\";\n";
6494962e6143186f6168f5d0ee979bf047651a13124Bill Wendling
6504962e6143186f6168f5d0ee979bf047651a13124Bill Wendling    for (std::map<StringRef, unsigned>::iterator
6514962e6143186f6168f5d0ee979bf047651a13124Bill Wendling           I = OpMap.begin(), E = OpMap.end(); I != E; ++I)
652f415d8b64687d4db7e1986b74e9da6cae72c0fd1Bill Wendling      O.indent(6) << "OpMap.push_back(std::make_pair(\"" << I->first << "\", "
653f415d8b64687d4db7e1986b74e9da6cae72c0fd1Bill Wendling                  << I->second << "));\n";
6544962e6143186f6168f5d0ee979bf047651a13124Bill Wendling
65544dcfd36253570ccd5f00189eb918604473135e0Bill Wendling    O.indent(6) << "break;\n";
65644dcfd36253570ccd5f00189eb918604473135e0Bill Wendling    O.indent(4) << '}';
6574962e6143186f6168f5d0ee979bf047651a13124Bill Wendling  }
6584962e6143186f6168f5d0ee979bf047651a13124Bill Wendling
6594962e6143186f6168f5d0ee979bf047651a13124Bill Wendling  bool operator==(const IAPrinter &RHS) {
6604962e6143186f6168f5d0ee979bf047651a13124Bill Wendling    if (Conds.size() != RHS.Conds.size())
6614962e6143186f6168f5d0ee979bf047651a13124Bill Wendling      return false;
6624962e6143186f6168f5d0ee979bf047651a13124Bill Wendling
6634962e6143186f6168f5d0ee979bf047651a13124Bill Wendling    unsigned Idx = 0;
6644962e6143186f6168f5d0ee979bf047651a13124Bill Wendling    for (std::vector<std::string>::iterator
6654962e6143186f6168f5d0ee979bf047651a13124Bill Wendling           I = Conds.begin(), E = Conds.end(); I != E; ++I)
6664962e6143186f6168f5d0ee979bf047651a13124Bill Wendling      if (*I != RHS.Conds[Idx++])
6674962e6143186f6168f5d0ee979bf047651a13124Bill Wendling        return false;
6684962e6143186f6168f5d0ee979bf047651a13124Bill Wendling
6694962e6143186f6168f5d0ee979bf047651a13124Bill Wendling    return true;
6704962e6143186f6168f5d0ee979bf047651a13124Bill Wendling  }
6714962e6143186f6168f5d0ee979bf047651a13124Bill Wendling
6724962e6143186f6168f5d0ee979bf047651a13124Bill Wendling  bool operator()(const IAPrinter &RHS) {
6734962e6143186f6168f5d0ee979bf047651a13124Bill Wendling    if (Conds.size() < RHS.Conds.size())
6744962e6143186f6168f5d0ee979bf047651a13124Bill Wendling      return true;
6754962e6143186f6168f5d0ee979bf047651a13124Bill Wendling
6764962e6143186f6168f5d0ee979bf047651a13124Bill Wendling    unsigned Idx = 0;
6774962e6143186f6168f5d0ee979bf047651a13124Bill Wendling    for (std::vector<std::string>::iterator
6784962e6143186f6168f5d0ee979bf047651a13124Bill Wendling           I = Conds.begin(), E = Conds.end(); I != E; ++I)
6794962e6143186f6168f5d0ee979bf047651a13124Bill Wendling      if (*I != RHS.Conds[Idx++])
6804962e6143186f6168f5d0ee979bf047651a13124Bill Wendling        return *I < RHS.Conds[Idx++];
6814962e6143186f6168f5d0ee979bf047651a13124Bill Wendling
6824962e6143186f6168f5d0ee979bf047651a13124Bill Wendling    return false;
6834962e6143186f6168f5d0ee979bf047651a13124Bill Wendling  }
6844962e6143186f6168f5d0ee979bf047651a13124Bill Wendling};
6854962e6143186f6168f5d0ee979bf047651a13124Bill Wendling
6862cf6fc6857a3544e56f1e701e826114906b1cc57Bill Wendling} // end anonymous namespace
6872cf6fc6857a3544e56f1e701e826114906b1cc57Bill Wendling
688f415d8b64687d4db7e1986b74e9da6cae72c0fd1Bill Wendlingstatic void EmitGetMapOperandNumber(raw_ostream &O) {
689f415d8b64687d4db7e1986b74e9da6cae72c0fd1Bill Wendling  O << "static unsigned getMapOperandNumber("
690f415d8b64687d4db7e1986b74e9da6cae72c0fd1Bill Wendling    << "const SmallVectorImpl<std::pair<StringRef, unsigned> > &OpMap,\n";
691f415d8b64687d4db7e1986b74e9da6cae72c0fd1Bill Wendling  O << "                                    StringRef Name) {\n";
692f415d8b64687d4db7e1986b74e9da6cae72c0fd1Bill Wendling  O << "  for (SmallVectorImpl<std::pair<StringRef, unsigned> >::"
693f415d8b64687d4db7e1986b74e9da6cae72c0fd1Bill Wendling    << "const_iterator\n";
694f415d8b64687d4db7e1986b74e9da6cae72c0fd1Bill Wendling  O << "         I = OpMap.begin(), E = OpMap.end(); I != E; ++I)\n";
695f415d8b64687d4db7e1986b74e9da6cae72c0fd1Bill Wendling  O << "    if (I->first == Name)\n";
696f415d8b64687d4db7e1986b74e9da6cae72c0fd1Bill Wendling  O << "      return I->second;\n";
697f415d8b64687d4db7e1986b74e9da6cae72c0fd1Bill Wendling  O << "  assert(false && \"Operand not in map!\");\n";
698f415d8b64687d4db7e1986b74e9da6cae72c0fd1Bill Wendling  O << "  return 0;\n";
699f415d8b64687d4db7e1986b74e9da6cae72c0fd1Bill Wendling  O << "}\n\n";
700f415d8b64687d4db7e1986b74e9da6cae72c0fd1Bill Wendling}
701f415d8b64687d4db7e1986b74e9da6cae72c0fd1Bill Wendling
7022cf6fc6857a3544e56f1e701e826114906b1cc57Bill Wendlingvoid AsmWriterEmitter::EmitRegIsInRegClass(raw_ostream &O) {
7032cf6fc6857a3544e56f1e701e826114906b1cc57Bill Wendling  CodeGenTarget Target(Records);
7047520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling
7057520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  // Enumerate the register classes.
7067520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  const std::vector<CodeGenRegisterClass> &RegisterClasses =
7077520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling    Target.getRegisterClasses();
7087520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling
7097520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  O << "namespace { // Register classes\n";
7107520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  O << "  enum RegClass {\n";
7117520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling
7127520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  // Emit the register enum value for each RegisterClass.
7137520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  for (unsigned I = 0, E = RegisterClasses.size(); I != E; ++I) {
7147520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling    if (I != 0) O << ",\n";
7157520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling    O << "    RC_" << RegisterClasses[I].TheDef->getName();
7167520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  }
7177520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling
7187520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  O << "\n  };\n";
7197520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  O << "} // end anonymous namespace\n\n";
7207520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling
7217520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  // Emit a function that returns 'true' if a regsiter is part of a particular
7227520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  // register class. I.e., RAX is part of GR64 on X86.
7237520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  O << "static bool regIsInRegisterClass"
7247520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling    << "(unsigned RegClass, unsigned Reg) {\n";
7257520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling
7267520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  // Emit the switch that checks if a register belongs to a particular register
7277520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  // class.
7287520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  O << "  switch (RegClass) {\n";
7297520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  O << "  default: break;\n";
7307520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling
7317520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  for (unsigned I = 0, E = RegisterClasses.size(); I != E; ++I) {
7327520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling    const CodeGenRegisterClass &RC = RegisterClasses[I];
7337520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling
7347520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling    // Give the register class a legal C name if it's anonymous.
7357520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling    std::string Name = RC.TheDef->getName();
7367520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling    O << "  case RC_" << Name << ":\n";
7377520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling
7387520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling    // Emit the register list now.
739ae1920b1efa72c1789d562df4746110d0c2e10bdJakob Stoklund Olesen    unsigned IE = RC.getOrder().size();
7407520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling    if (IE == 1) {
741ae1920b1efa72c1789d562df4746110d0c2e10bdJakob Stoklund Olesen      O << "    if (Reg == " << getQualifiedName(RC.getOrder()[0]) << ")\n";
7427520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling      O << "      return true;\n";
7437520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling    } else {
7447520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling      O << "    switch (Reg) {\n";
7457520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling      O << "    default: break;\n";
7467520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling
7477520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling      for (unsigned II = 0; II != IE; ++II) {
748ae1920b1efa72c1789d562df4746110d0c2e10bdJakob Stoklund Olesen        Record *Reg = RC.getOrder()[II];
7497520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling        O << "    case " << getQualifiedName(Reg) << ":\n";
7507520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling      }
7517520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling
7527520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling      O << "      return true;\n";
7537520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling      O << "    }\n";
7547520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling    }
7557520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling
7567520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling    O << "    break;\n";
7577520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  }
7587520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling
7597520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  O << "  }\n\n";
7607520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  O << "  return false;\n";
7617520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  O << "}\n\n";
7622cf6fc6857a3544e56f1e701e826114906b1cc57Bill Wendling}
7632cf6fc6857a3544e56f1e701e826114906b1cc57Bill Wendling
764740e5b3586a474f1cea371cf6f652850e5420b90Bill Wendlingstatic unsigned CountNumOperands(StringRef AsmString) {
765740e5b3586a474f1cea371cf6f652850e5420b90Bill Wendling  unsigned NumOps = 0;
766740e5b3586a474f1cea371cf6f652850e5420b90Bill Wendling  std::pair<StringRef, StringRef> ASM = AsmString.split(' ');
767740e5b3586a474f1cea371cf6f652850e5420b90Bill Wendling
768740e5b3586a474f1cea371cf6f652850e5420b90Bill Wendling  while (!ASM.second.empty()) {
769740e5b3586a474f1cea371cf6f652850e5420b90Bill Wendling    ++NumOps;
770740e5b3586a474f1cea371cf6f652850e5420b90Bill Wendling    ASM = ASM.second.split(' ');
771740e5b3586a474f1cea371cf6f652850e5420b90Bill Wendling  }
772740e5b3586a474f1cea371cf6f652850e5420b90Bill Wendling
773740e5b3586a474f1cea371cf6f652850e5420b90Bill Wendling  return NumOps;
774740e5b3586a474f1cea371cf6f652850e5420b90Bill Wendling}
775740e5b3586a474f1cea371cf6f652850e5420b90Bill Wendling
776393c4047c05b6d7b5851d339e51bb2cc35f630c2Bill Wendlingstatic unsigned CountResultNumOperands(StringRef AsmString) {
777393c4047c05b6d7b5851d339e51bb2cc35f630c2Bill Wendling  unsigned NumOps = 0;
778393c4047c05b6d7b5851d339e51bb2cc35f630c2Bill Wendling  std::pair<StringRef, StringRef> ASM = AsmString.split('\t');
779393c4047c05b6d7b5851d339e51bb2cc35f630c2Bill Wendling
780393c4047c05b6d7b5851d339e51bb2cc35f630c2Bill Wendling  if (!ASM.second.empty()) {
781393c4047c05b6d7b5851d339e51bb2cc35f630c2Bill Wendling    size_t I = ASM.second.find('{');
782393c4047c05b6d7b5851d339e51bb2cc35f630c2Bill Wendling    StringRef Str = ASM.second;
783393c4047c05b6d7b5851d339e51bb2cc35f630c2Bill Wendling    if (I != StringRef::npos)
784393c4047c05b6d7b5851d339e51bb2cc35f630c2Bill Wendling      Str = ASM.second.substr(I, ASM.second.find('|', I));
785393c4047c05b6d7b5851d339e51bb2cc35f630c2Bill Wendling
786393c4047c05b6d7b5851d339e51bb2cc35f630c2Bill Wendling    ASM = Str.split(' ');
787393c4047c05b6d7b5851d339e51bb2cc35f630c2Bill Wendling
788393c4047c05b6d7b5851d339e51bb2cc35f630c2Bill Wendling    do {
789393c4047c05b6d7b5851d339e51bb2cc35f630c2Bill Wendling      ++NumOps;
790393c4047c05b6d7b5851d339e51bb2cc35f630c2Bill Wendling      ASM = ASM.second.split(' ');
791393c4047c05b6d7b5851d339e51bb2cc35f630c2Bill Wendling    } while (!ASM.second.empty());
792393c4047c05b6d7b5851d339e51bb2cc35f630c2Bill Wendling  }
793393c4047c05b6d7b5851d339e51bb2cc35f630c2Bill Wendling
794393c4047c05b6d7b5851d339e51bb2cc35f630c2Bill Wendling  return NumOps;
795393c4047c05b6d7b5851d339e51bb2cc35f630c2Bill Wendling}
796740e5b3586a474f1cea371cf6f652850e5420b90Bill Wendling
7972cf6fc6857a3544e56f1e701e826114906b1cc57Bill Wendlingvoid AsmWriterEmitter::EmitPrintAliasInstruction(raw_ostream &O) {
7982cf6fc6857a3544e56f1e701e826114906b1cc57Bill Wendling  CodeGenTarget Target(Records);
7992cf6fc6857a3544e56f1e701e826114906b1cc57Bill Wendling  Record *AsmWriter = Target.getAsmWriter();
8002cf6fc6857a3544e56f1e701e826114906b1cc57Bill Wendling
801740e5b3586a474f1cea371cf6f652850e5420b90Bill Wendling  if (!AsmWriter->getValueAsBit("isMCAsmWriter"))
802740e5b3586a474f1cea371cf6f652850e5420b90Bill Wendling    return;
803740e5b3586a474f1cea371cf6f652850e5420b90Bill Wendling
8042cf6fc6857a3544e56f1e701e826114906b1cc57Bill Wendling  O << "\n#ifdef PRINT_ALIAS_INSTR\n";
8052cf6fc6857a3544e56f1e701e826114906b1cc57Bill Wendling  O << "#undef PRINT_ALIAS_INSTR\n\n";
8062cf6fc6857a3544e56f1e701e826114906b1cc57Bill Wendling
8072cf6fc6857a3544e56f1e701e826114906b1cc57Bill Wendling  EmitRegIsInRegClass(O);
8087520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling
8097520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  // Emit the method that prints the alias instruction.
8107520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  std::string ClassName = AsmWriter->getValueAsString("AsmWriterClassName");
8110d7b0aa76036abc3118d148fbf02ad287bc7be6cChris Lattner
8127520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  std::vector<Record*> AllInstAliases =
8137520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling    Records.getAllDerivedDefinitions("InstAlias");
8147520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling
8157520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  // Create a map from the qualified name to a list of potential matches.
8167520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  std::map<std::string, std::vector<CodeGenInstAlias*> > AliasMap;
8177520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  for (std::vector<Record*>::iterator
8187520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling         I = AllInstAliases.begin(), E = AllInstAliases.end(); I != E; ++I) {
8197520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling    CodeGenInstAlias *Alias = new CodeGenInstAlias(*I, Target);
8207520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling    const Record *R = *I;
821eef965f04bab483a7d2fd46a7d51559197eda5cfBill Wendling    if (!R->getValueAsBit("EmitAlias"))
822eef965f04bab483a7d2fd46a7d51559197eda5cfBill Wendling      continue; // We were told not to emit the alias, but to emit the aliasee.
8237520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling    const DagInit *DI = R->getValueAsDag("ResultInst");
8247520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling    const DefInit *Op = dynamic_cast<const DefInit*>(DI->getOperator());
8257520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling    AliasMap[getQualifiedName(Op->getDef())].push_back(Alias);
8267520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  }
8277520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling
8283ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling  // A map of which conditions need to be met for each instruction operand
8293ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling  // before it can be matched to the mnemonic.
8303ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling  std::map<std::string, std::vector<IAPrinter*> > IAPrinterMap;
8313ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling
8323ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling  for (std::map<std::string, std::vector<CodeGenInstAlias*> >::iterator
8333ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling         I = AliasMap.begin(), E = AliasMap.end(); I != E; ++I) {
8343ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling    std::vector<CodeGenInstAlias*> &Aliases = I->second;
8353ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling
8363ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling    for (std::vector<CodeGenInstAlias*>::iterator
8373ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling           II = Aliases.begin(), IE = Aliases.end(); II != IE; ++II) {
8383ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling      const CodeGenInstAlias *CGA = *II;
839740e5b3586a474f1cea371cf6f652850e5420b90Bill Wendling      unsigned LastOpNo = CGA->ResultInstOperandIndex.size();
840393c4047c05b6d7b5851d339e51bb2cc35f630c2Bill Wendling      unsigned NumResultOps =
841393c4047c05b6d7b5851d339e51bb2cc35f630c2Bill Wendling        CountResultNumOperands(CGA->ResultInst->AsmString);
842740e5b3586a474f1cea371cf6f652850e5420b90Bill Wendling
843740e5b3586a474f1cea371cf6f652850e5420b90Bill Wendling      // Don't emit the alias if it has more operands than what it's aliasing.
844393c4047c05b6d7b5851d339e51bb2cc35f630c2Bill Wendling      if (NumResultOps < CountNumOperands(CGA->AsmString))
845740e5b3586a474f1cea371cf6f652850e5420b90Bill Wendling        continue;
846740e5b3586a474f1cea371cf6f652850e5420b90Bill Wendling
84768ae5b4beab17542b15817815e802475ad1a841fEvan Cheng      IAPrinter *IAP = new IAPrinter(CGA->Result->getAsString(),
8483ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling                                     CGA->AsmString);
8493ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling
8503ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling      std::string Cond;
8513ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling      Cond = std::string("MI->getNumOperands() == ") + llvm::utostr(LastOpNo);
8523ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling      IAP->addCond(Cond);
8533ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling
8543ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling      std::map<StringRef, unsigned> OpMap;
8553ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling      bool CantHandle = false;
8563ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling
8573ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling      for (unsigned i = 0, e = LastOpNo; i != e; ++i) {
8583ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling        const CodeGenInstAlias::ResultOperand &RO = CGA->ResultOperands[i];
8593ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling
8603ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling        switch (RO.Kind) {
8613ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling        default: assert(0 && "unexpected InstAlias operand kind");
8623ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling        case CodeGenInstAlias::ResultOperand::K_Record: {
8633ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling          const Record *Rec = RO.getRecord();
8643ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling          StringRef ROName = RO.getName();
8653ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling
866bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson
867bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson          if (Rec->isSubClassOf("RegisterOperand"))
868bea6f615eefae279e53bbb63a31d2c3c67274c45Owen Anderson            Rec = Rec->getValueAsDef("RegClass");
8693ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling          if (Rec->isSubClassOf("RegisterClass")) {
8703ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling            Cond = std::string("MI->getOperand(")+llvm::utostr(i)+").isReg()";
8713ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling            IAP->addCond(Cond);
8723ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling
8733ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling            if (!IAP->isOpMapped(ROName)) {
8743ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling              IAP->addOperand(ROName, i);
8753ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling              Cond = std::string("regIsInRegisterClass(RC_") +
8763ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling                CGA->ResultOperands[i].getRecord()->getName() +
8773ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling                ", MI->getOperand(" + llvm::utostr(i) + ").getReg())";
8783ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling              IAP->addCond(Cond);
8793ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling            } else {
8803ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling              Cond = std::string("MI->getOperand(") +
8813ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling                llvm::utostr(i) + ").getReg() == MI->getOperand(" +
8823ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling                llvm::utostr(IAP->getOpIndex(ROName)) + ").getReg()";
8833ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling              IAP->addCond(Cond);
8843ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling            }
8853ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling          } else {
8863ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling            assert(Rec->isSubClassOf("Operand") && "Unexpected operand!");
887740e5b3586a474f1cea371cf6f652850e5420b90Bill Wendling            // FIXME: We may need to handle these situations.
8883ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling            delete IAP;
8893ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling            IAP = 0;
8903ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling            CantHandle = true;
8913ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling            break;
8923ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling          }
8933ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling
8943ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling          break;
8953ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling        }
8963ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling        case CodeGenInstAlias::ResultOperand::K_Imm:
8973ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling          Cond = std::string("MI->getOperand(") +
8983ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling            llvm::utostr(i) + ").getImm() == " +
8993ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling            llvm::utostr(CGA->ResultOperands[i].getImm());
9003ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling          IAP->addCond(Cond);
9013ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling          break;
9023ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling        case CodeGenInstAlias::ResultOperand::K_Reg:
9033ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling          Cond = std::string("MI->getOperand(") +
9043ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling            llvm::utostr(i) + ").getReg() == " + Target.getName() +
9053ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling            "::" + CGA->ResultOperands[i].getRegister()->getName();
9063ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling          IAP->addCond(Cond);
9073ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling          break;
9083ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling        }
9093ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling
9103ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling        if (!IAP) break;
9113ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling      }
9123ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling
9133ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling      if (CantHandle) continue;
9143ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling      IAPrinterMap[I->first].push_back(IAP);
9153ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling    }
9163ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling  }
9173ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling
918f415d8b64687d4db7e1986b74e9da6cae72c0fd1Bill Wendling  std::string Header;
919f415d8b64687d4db7e1986b74e9da6cae72c0fd1Bill Wendling  raw_string_ostream HeaderO(Header);
920f415d8b64687d4db7e1986b74e9da6cae72c0fd1Bill Wendling
921f415d8b64687d4db7e1986b74e9da6cae72c0fd1Bill Wendling  HeaderO << "bool " << Target.getName() << ClassName
922740e5b3586a474f1cea371cf6f652850e5420b90Bill Wendling          << "::printAliasInstr(const MCInst"
923f415d8b64687d4db7e1986b74e9da6cae72c0fd1Bill Wendling          << " *MI, raw_ostream &OS) {\n";
9243ce1b7d514d2898516106c8b2b843ae9386607ceBill Wendling
92544dcfd36253570ccd5f00189eb918604473135e0Bill Wendling  std::string Cases;
92644dcfd36253570ccd5f00189eb918604473135e0Bill Wendling  raw_string_ostream CasesO(Cases);
92744dcfd36253570ccd5f00189eb918604473135e0Bill Wendling
92844dcfd36253570ccd5f00189eb918604473135e0Bill Wendling  for (std::map<std::string, std::vector<IAPrinter*> >::iterator
92944dcfd36253570ccd5f00189eb918604473135e0Bill Wendling         I = IAPrinterMap.begin(), E = IAPrinterMap.end(); I != E; ++I) {
93044dcfd36253570ccd5f00189eb918604473135e0Bill Wendling    std::vector<IAPrinter*> &IAPs = I->second;
93144dcfd36253570ccd5f00189eb918604473135e0Bill Wendling    std::vector<IAPrinter*> UniqueIAPs;
93244dcfd36253570ccd5f00189eb918604473135e0Bill Wendling
93344dcfd36253570ccd5f00189eb918604473135e0Bill Wendling    for (std::vector<IAPrinter*>::iterator
93444dcfd36253570ccd5f00189eb918604473135e0Bill Wendling           II = IAPs.begin(), IE = IAPs.end(); II != IE; ++II) {
93544dcfd36253570ccd5f00189eb918604473135e0Bill Wendling      IAPrinter *LHS = *II;
93644dcfd36253570ccd5f00189eb918604473135e0Bill Wendling      bool IsDup = false;
93744dcfd36253570ccd5f00189eb918604473135e0Bill Wendling      for (std::vector<IAPrinter*>::iterator
93844dcfd36253570ccd5f00189eb918604473135e0Bill Wendling             III = IAPs.begin(), IIE = IAPs.end(); III != IIE; ++III) {
93944dcfd36253570ccd5f00189eb918604473135e0Bill Wendling        IAPrinter *RHS = *III;
94044dcfd36253570ccd5f00189eb918604473135e0Bill Wendling        if (LHS != RHS && *LHS == *RHS) {
94144dcfd36253570ccd5f00189eb918604473135e0Bill Wendling          IsDup = true;
9427520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling          break;
9437520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling        }
9447520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling      }
9457520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling
94644dcfd36253570ccd5f00189eb918604473135e0Bill Wendling      if (!IsDup) UniqueIAPs.push_back(LHS);
94744dcfd36253570ccd5f00189eb918604473135e0Bill Wendling    }
9487520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling
94944dcfd36253570ccd5f00189eb918604473135e0Bill Wendling    if (UniqueIAPs.empty()) continue;
9507520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling
95144dcfd36253570ccd5f00189eb918604473135e0Bill Wendling    CasesO.indent(2) << "case " << I->first << ":\n";
9527520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling
95344dcfd36253570ccd5f00189eb918604473135e0Bill Wendling    for (std::vector<IAPrinter*>::iterator
95444dcfd36253570ccd5f00189eb918604473135e0Bill Wendling           II = UniqueIAPs.begin(), IE = UniqueIAPs.end(); II != IE; ++II) {
95544dcfd36253570ccd5f00189eb918604473135e0Bill Wendling      IAPrinter *IAP = *II;
95644dcfd36253570ccd5f00189eb918604473135e0Bill Wendling      CasesO.indent(4);
95768ae5b4beab17542b15817815e802475ad1a841fEvan Cheng      IAP->print(CasesO);
95844dcfd36253570ccd5f00189eb918604473135e0Bill Wendling      CasesO << '\n';
9597520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling    }
9607520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling
961721ef66d17978a7474bc2bde5a0ce2996615a7ceEric Christopher    CasesO.indent(4) << "return false;\n";
96244dcfd36253570ccd5f00189eb918604473135e0Bill Wendling  }
9637520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling
964740e5b3586a474f1cea371cf6f652850e5420b90Bill Wendling  if (CasesO.str().empty()) {
965f415d8b64687d4db7e1986b74e9da6cae72c0fd1Bill Wendling    O << HeaderO.str();
966721ef66d17978a7474bc2bde5a0ce2996615a7ceEric Christopher    O << "  return false;\n";
96744dcfd36253570ccd5f00189eb918604473135e0Bill Wendling    O << "}\n\n";
96844dcfd36253570ccd5f00189eb918604473135e0Bill Wendling    O << "#endif // PRINT_ALIAS_INSTR\n";
96944dcfd36253570ccd5f00189eb918604473135e0Bill Wendling    return;
9707520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  }
9717520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling
972f415d8b64687d4db7e1986b74e9da6cae72c0fd1Bill Wendling  EmitGetMapOperandNumber(O);
973f415d8b64687d4db7e1986b74e9da6cae72c0fd1Bill Wendling
974f415d8b64687d4db7e1986b74e9da6cae72c0fd1Bill Wendling  O << HeaderO.str();
97544dcfd36253570ccd5f00189eb918604473135e0Bill Wendling  O.indent(2) << "StringRef AsmString;\n";
976f415d8b64687d4db7e1986b74e9da6cae72c0fd1Bill Wendling  O.indent(2) << "SmallVector<std::pair<StringRef, unsigned>, 4> OpMap;\n";
97744dcfd36253570ccd5f00189eb918604473135e0Bill Wendling  O.indent(2) << "switch (MI->getOpcode()) {\n";
978721ef66d17978a7474bc2bde5a0ce2996615a7ceEric Christopher  O.indent(2) << "default: return false;\n";
97944dcfd36253570ccd5f00189eb918604473135e0Bill Wendling  O << CasesO.str();
98044dcfd36253570ccd5f00189eb918604473135e0Bill Wendling  O.indent(2) << "}\n\n";
9817520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling
9827520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  // Code that prints the alias, replacing the operands with the ones from the
9837520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  // MCInst.
9847520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  O << "  std::pair<StringRef, StringRef> ASM = AsmString.split(' ');\n";
9857520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  O << "  OS << '\\t' << ASM.first;\n";
9867520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling
9877520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  O << "  if (!ASM.second.empty()) {\n";
9887520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  O << "    OS << '\\t';\n";
9897520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  O << "    for (StringRef::iterator\n";
9907520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  O << "         I = ASM.second.begin(), E = ASM.second.end(); I != E; ) {\n";
9917520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  O << "      if (*I == '$') {\n";
9927520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  O << "        StringRef::iterator Start = ++I;\n";
9937520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  O << "        while (I != E &&\n";
9947520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  O << "               ((*I >= 'a' && *I <= 'z') ||\n";
9957520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  O << "                (*I >= 'A' && *I <= 'Z') ||\n";
9967520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  O << "                (*I >= '0' && *I <= '9') ||\n";
9977520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  O << "                *I == '_'))\n";
9987520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  O << "          ++I;\n";
9997520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  O << "        StringRef Name(Start, I - Start);\n";
1000f415d8b64687d4db7e1986b74e9da6cae72c0fd1Bill Wendling  O << "        printOperand(MI, getMapOperandNumber(OpMap, Name), OS);\n";
10017520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  O << "      } else {\n";
10027520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  O << "        OS << *I++;\n";
10037520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  O << "      }\n";
10047520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  O << "    }\n";
10057520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  O << "  }\n\n";
10067520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling
1007721ef66d17978a7474bc2bde5a0ce2996615a7ceEric Christopher  O << "  return true;\n";
10087520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  O << "}\n\n";
10097520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling
10107520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  O << "#endif // PRINT_ALIAS_INSTR\n";
10117520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling}
101205af2616d0df19638e799d3e7afadea26d96a4baChris Lattner
101305af2616d0df19638e799d3e7afadea26d96a4baChris Lattnervoid AsmWriterEmitter::run(raw_ostream &O) {
101405af2616d0df19638e799d3e7afadea26d96a4baChris Lattner  EmitSourceFileHeader("Assembly Writer Source Fragment", O);
10159255b8d349768a02b2d139a43984c9b544098122Jim Grosbach
101605af2616d0df19638e799d3e7afadea26d96a4baChris Lattner  EmitPrintInstruction(O);
101705af2616d0df19638e799d3e7afadea26d96a4baChris Lattner  EmitGetRegisterName(O);
10180d7b0aa76036abc3118d148fbf02ad287bc7be6cChris Lattner  EmitGetInstructionName(O);
10197520e3a2b54aee466b458675542db692a7f31ac1Bill Wendling  EmitPrintAliasInstruction(O);
102005af2616d0df19638e799d3e7afadea26d96a4baChris Lattner}
102105af2616d0df19638e799d3e7afadea26d96a4baChris Lattner
1022