contrib/llvm/utils/TableGen/AsmWriterEmitter.cpp

   1 //===- AsmWriterEmitter.cpp - Generate an assembly writer -----------------===//
   2 //
   3 //                     The LLVM Compiler Infrastructure
   4 //
   5 // This file is distributed under the University of Illinois Open Source
   6 // License. See LICENSE.TXT for details.
   7 //
   8 //===----------------------------------------------------------------------===//
   9 //
  10 // This tablegen backend emits an assembly printer for the current target.
  11 // Note that this is currently fairly skeletal, but will grow over time.
  12 //
  13 //===----------------------------------------------------------------------===//
  14
  15 #include "AsmWriterInst.h"
  16 #include "CodeGenInstruction.h"
  17 #include "CodeGenRegisters.h"
  18 #include "CodeGenTarget.h"
  19 #include "SequenceToOffsetTable.h"
  20 #include "Types.h"
  21 #include "llvm/ADT/ArrayRef.h"
  22 #include "llvm/ADT/DenseMap.h"
  23 #include "llvm/ADT/SmallString.h"
  24 #include "llvm/ADT/SmallVector.h"
  25 #include "llvm/ADT/STLExtras.h"
  26 #include "llvm/ADT/StringExtras.h"
  27 #include "llvm/ADT/StringRef.h"
  28 #include "llvm/ADT/Twine.h"
  29 #include "llvm/Support/Casting.h"
  30 #include "llvm/Support/Debug.h"
  31 #include "llvm/Support/ErrorHandling.h"
  32 #include "llvm/Support/Format.h"
  33 #include "llvm/Support/MathExtras.h"
  34 #include "llvm/Support/raw_ostream.h"
  35 #include "llvm/TableGen/Error.h"
  36 #include "llvm/TableGen/Record.h"
  37 #include "llvm/TableGen/TableGenBackend.h"
  38 #include <algorithm>
  39 #include <cassert>
  40 #include <cstddef>
  41 #include <cstdint>
  42 #include <deque>
  43 #include <iterator>
  44 #include <map>
  45 #include <set>
  46 #include <string>
  47 #include <tuple>
  48 #include <utility>
  49 #include <vector>
  50
  51 using namespace llvm;
  52
  53 #define DEBUG_TYPE "asm-writer-emitter"
  54
  55 namespace {
  56
  57 class AsmWriterEmitter {
  58   RecordKeeper &Records;
  59   CodeGenTarget Target;
  60   ArrayRef<const CodeGenInstruction *> NumberedInstructions;
  61   std::vector<AsmWriterInst> Instructions;
  62
  63 public:
  64   AsmWriterEmitter(RecordKeeper &R);
  65
  66   void run(raw_ostream &o);
  67
  68 private:
  69   void EmitPrintInstruction(raw_ostream &o);
  70   void EmitGetRegisterName(raw_ostream &o);
  71   void EmitPrintAliasInstruction(raw_ostream &O);
  72
  73   void FindUniqueOperandCommands(std::vector<std::string> &UOC,
  74                                  std::vector<std::vector<unsigned>> &InstIdxs,
  75                                  std::vector<unsigned> &InstOpsUsed,
  76                                  bool PassSubtarget) const;
  77 };
  78
  79 } // end anonymous namespace
  80
  81 static void PrintCases(std::vector<std::pair<std::string,
  82                        AsmWriterOperand>> &OpsToPrint, raw_ostream &O,
  83                        bool PassSubtarget) {
  84   O << "    case " << OpsToPrint.back().first << ":";
  85   AsmWriterOperand TheOp = OpsToPrint.back().second;
  86   OpsToPrint.pop_back();
  87
  88   // Check to see if any other operands are identical in this list, and if so,
  89   // emit a case label for them.
  90   for (unsigned i = OpsToPrint.size(); i != 0; --i)
  91     if (OpsToPrint[i-1].second == TheOp) {
  92       O << "\n    case " << OpsToPrint[i-1].first << ":";
  93       OpsToPrint.erase(OpsToPrint.begin()+i-1);
  94     }
  95
  96   // Finally, emit the code.
  97   O << "\n      " << TheOp.getCode(PassSubtarget);
  98   O << "\n      break;\n";
  99 }
 100
 101 /// EmitInstructions - Emit the last instruction in the vector and any other
 102 /// instructions that are suitably similar to it.
 103 static void EmitInstructions(std::vector<AsmWriterInst> &Insts,
 104                              raw_ostream &O, bool PassSubtarget) {
 105   AsmWriterInst FirstInst = Insts.back();
 106   Insts.pop_back();
 107
 108   std::vector<AsmWriterInst> SimilarInsts;
 109   unsigned DifferingOperand = ~0;
 110   for (unsigned i = Insts.size(); i != 0; --i) {
 111     unsigned DiffOp = Insts[i-1].MatchesAllButOneOp(FirstInst);
 112     if (DiffOp != ~1U) {
 113       if (DifferingOperand == ~0U)  // First match!
 114         DifferingOperand = DiffOp;
 115
 116       // If this differs in the same operand as the rest of the instructions in
 117       // this class, move it to the SimilarInsts list.
 118       if (DifferingOperand == DiffOp || DiffOp == ~0U) {
 119         SimilarInsts.push_back(Insts[i-1]);
 120         Insts.erase(Insts.begin()+i-1);
 121       }
 122     }
 123   }
 124
 125   O << "  case " << FirstInst.CGI->Namespace << "::"
 126     << FirstInst.CGI->TheDef->getName() << ":\n";
 127   for (const AsmWriterInst &AWI : SimilarInsts)
 128     O << "  case " << AWI.CGI->Namespace << "::"
 129       << AWI.CGI->TheDef->getName() << ":\n";
 130   for (unsigned i = 0, e = FirstInst.Operands.size(); i != e; ++i) {
 131     if (i != DifferingOperand) {
 132       // If the operand is the same for all instructions, just print it.
 133       O << "    " << FirstInst.Operands[i].getCode(PassSubtarget);
 134     } else {
 135       // If this is the operand that varies between all of the instructions,
 136       // emit a switch for just this operand now.
 137       O << "    switch (MI->getOpcode()) {\n";
 138       O << "    default: llvm_unreachable(\"Unexpected opcode.\");\n";
 139       std::vector<std::pair<std::string, AsmWriterOperand>> OpsToPrint;
 140       OpsToPrint.push_back(std::make_pair(FirstInst.CGI->Namespace.str() + "::" +
 141                                           FirstInst.CGI->TheDef->getName().str(),
 142                                           FirstInst.Operands[i]));
 143
 144       for (const AsmWriterInst &AWI : SimilarInsts) {
 145         OpsToPrint.push_back(std::make_pair(AWI.CGI->Namespace.str()+"::" +
 146                                             AWI.CGI->TheDef->getName().str(),
 147                                             AWI.Operands[i]));
 148       }
 149       std::reverse(OpsToPrint.begin(), OpsToPrint.end());
 150       while (!OpsToPrint.empty())
 151         PrintCases(OpsToPrint, O, PassSubtarget);
 152       O << "    }";
 153     }
 154     O << "\n";
 155   }
 156   O << "    break;\n";
 157 }
 158
 159 void AsmWriterEmitter::
 160 FindUniqueOperandCommands(std::vector<std::string> &UniqueOperandCommands,
 161                           std::vector<std::vector<unsigned>> &InstIdxs,
 162                           std::vector<unsigned> &InstOpsUsed,
 163                           bool PassSubtarget) const {
 164   // This vector parallels UniqueOperandCommands, keeping track of which
 165   // instructions each case are used for.  It is a comma separated string of
 166   // enums.
 167   std::vector<std::string> InstrsForCase;
 168   InstrsForCase.resize(UniqueOperandCommands.size());
 169   InstOpsUsed.assign(UniqueOperandCommands.size(), 0);
 170
 171   for (size_t i = 0, e = Instructions.size(); i != e; ++i) {
 172     const AsmWriterInst &Inst = Instructions[i];
 173     if (Inst.Operands.empty())
 174       continue;   // Instruction already done.
 175
 176     std::string Command = "    "+Inst.Operands[0].getCode(PassSubtarget)+"\n";
 177
 178     // Check to see if we already have 'Command' in UniqueOperandCommands.
 179     // If not, add it.
 180     auto I = llvm::find(UniqueOperandCommands, Command);
 181     if (I != UniqueOperandCommands.end()) {
 182       size_t idx = I - UniqueOperandCommands.begin();
 183       InstrsForCase[idx] += ", ";
 184       InstrsForCase[idx] += Inst.CGI->TheDef->getName();
 185       InstIdxs[idx].push_back(i);
 186     } else {
 187       UniqueOperandCommands.push_back(std::move(Command));
 188       InstrsForCase.push_back(Inst.CGI->TheDef->getName());
 189       InstIdxs.emplace_back();
 190       InstIdxs.back().push_back(i);
 191
 192       // This command matches one operand so far.
 193       InstOpsUsed.push_back(1);
 194     }
 195   }
 196
 197   // For each entry of UniqueOperandCommands, there is a set of instructions
 198   // that uses it.  If the next command of all instructions in the set are
 199   // identical, fold it into the command.
 200   for (size_t CommandIdx = 0, e = UniqueOperandCommands.size();
 201        CommandIdx != e; ++CommandIdx) {
 202
 203     const auto &Idxs = InstIdxs[CommandIdx];
 204
 205     for (unsigned Op = 1; ; ++Op) {
 206       // Find the first instruction in the set.
 207       const AsmWriterInst &FirstInst = Instructions[Idxs.front()];
 208       // If this instruction has no more operands, we isn't anything to merge
 209       // into this command.
 210       if (FirstInst.Operands.size() == Op)
 211         break;
 212
 213       // Otherwise, scan to see if all of the other instructions in this command
 214       // set share the operand.
 215       if (std::any_of(Idxs.begin()+1, Idxs.end(),
 216                       [&](unsigned Idx) {
 217                         const AsmWriterInst &OtherInst = Instructions[Idx];
 218                         return OtherInst.Operands.size() == Op ||
 219                           OtherInst.Operands[Op] != FirstInst.Operands[Op];
 220                       }))
 221         break;
 222
 223       // Okay, everything in this command set has the same next operand.  Add it
 224       // to UniqueOperandCommands and remember that it was consumed.
 225       std::string Command = "    " +
 226         FirstInst.Operands[Op].getCode(PassSubtarget) + "\n";
 227
 228       UniqueOperandCommands[CommandIdx] += Command;
 229       InstOpsUsed[CommandIdx]++;
 230     }
 231   }
 232
 233   // Prepend some of the instructions each case is used for onto the case val.
 234   for (unsigned i = 0, e = InstrsForCase.size(); i != e; ++i) {
 235     std::string Instrs = InstrsForCase[i];
 236     if (Instrs.size() > 70) {
 237       Instrs.erase(Instrs.begin()+70, Instrs.end());
 238       Instrs += "...";
 239     }
 240
 241     if (!Instrs.empty())
 242       UniqueOperandCommands[i] = "    // " + Instrs + "\n" +
 243         UniqueOperandCommands[i];
 244   }
 245 }
 246
 247 static void UnescapeString(std::string &Str) {
 248   for (unsigned i = 0; i != Str.size(); ++i) {
 249     if (Str[i] == '\\' && i != Str.size()-1) {
 250       switch (Str[i+1]) {
 251       default: continue;  // Don't execute the code after the switch.
 252       case 'a': Str[i] = '\a'; break;
 253       case 'b': Str[i] = '\b'; break;
 254       case 'e': Str[i] = 27; break;
 255       case 'f': Str[i] = '\f'; break;
 256       case 'n': Str[i] = '\n'; break;
 257       case 'r': Str[i] = '\r'; break;
 258       case 't': Str[i] = '\t'; break;
 259       case 'v': Str[i] = '\v'; break;
 260       case '"': Str[i] = '\"'; break;
 261       case '\'': Str[i] = '\''; break;
 262       case '\\': Str[i] = '\\'; break;
 263       }
 264       // Nuke the second character.
 265       Str.erase(Str.begin()+i+1);
 266     }
 267   }
 268 }
 269
 270 /// EmitPrintInstruction - Generate the code for the "printInstruction" method
 271 /// implementation. Destroys all instances of AsmWriterInst information, by
 272 /// clearing the Instructions vector.
 273 void AsmWriterEmitter::EmitPrintInstruction(raw_ostream &O) {
 274   Record *AsmWriter = Target.getAsmWriter();
 275   StringRef ClassName = AsmWriter->getValueAsString("AsmWriterClassName");
 276   bool PassSubtarget = AsmWriter->getValueAsInt("PassSubtarget");
 277
 278   O <<
 279   "/// printInstruction - This method is automatically generated by tablegen\n"
 280   "/// from the instruction set description.\n"
 281     "void " << Target.getName() << ClassName
 282             << "::printInstruction(const MCInst *MI, "
 283             << (PassSubtarget ? "const MCSubtargetInfo &STI, " : "")
 284             << "raw_ostream &O) {\n";
 285
 286   // Build an aggregate string, and build a table of offsets into it.
 287   SequenceToOffsetTable<std::string> StringTable;
 288
 289   /// OpcodeInfo - This encodes the index of the string to use for the first
 290   /// chunk of the output as well as indices used for operand printing.
 291   std::vector<uint64_t> OpcodeInfo(NumberedInstructions.size());
 292   const unsigned OpcodeInfoBits = 64;
 293
 294   // Add all strings to the string table upfront so it can generate an optimized
 295   // representation.
 296   for (AsmWriterInst &AWI : Instructions) {
 297     if (AWI.Operands[0].OperandType ==
 298                  AsmWriterOperand::isLiteralTextOperand &&
 299         !AWI.Operands[0].Str.empty()) {
 300       std::string Str = AWI.Operands[0].Str;
 301       UnescapeString(Str);
 302       StringTable.add(Str);
 303     }
 304   }
 305
 306   StringTable.layout();
 307
 308   unsigned MaxStringIdx = 0;
 309   for (AsmWriterInst &AWI : Instructions) {
 310     unsigned Idx;
 311     if (AWI.Operands[0].OperandType != AsmWriterOperand::isLiteralTextOperand ||
 312         AWI.Operands[0].Str.empty()) {
 313       // Something handled by the asmwriter printer, but with no leading string.
 314       Idx = StringTable.get("");
 315     } else {
 316       std::string Str = AWI.Operands[0].Str;
 317       UnescapeString(Str);
 318       Idx = StringTable.get(Str);
 319       MaxStringIdx = std::max(MaxStringIdx, Idx);
 320
 321       // Nuke the string from the operand list.  It is now handled!
 322       AWI.Operands.erase(AWI.Operands.begin());
 323     }
 324
 325     // Bias offset by one since we want 0 as a sentinel.
 326     OpcodeInfo[AWI.CGIIndex] = Idx+1;
 327   }
 328
 329   // Figure out how many bits we used for the string index.
 330   unsigned AsmStrBits = Log2_32_Ceil(MaxStringIdx+2);
 331
 332   // To reduce code size, we compactify common instructions into a few bits
 333   // in the opcode-indexed table.
 334   unsigned BitsLeft = OpcodeInfoBits-AsmStrBits;
 335
 336   std::vector<std::vector<std::string>> TableDrivenOperandPrinters;
 337
 338   while (true) {
 339     std::vector<std::string> UniqueOperandCommands;
 340     std::vector<std::vector<unsigned>> InstIdxs;
 341     std::vector<unsigned> NumInstOpsHandled;
 342     FindUniqueOperandCommands(UniqueOperandCommands, InstIdxs,
 343                               NumInstOpsHandled, PassSubtarget);
 344
 345     // If we ran out of operands to print, we're done.
 346     if (UniqueOperandCommands.empty()) break;
 347
 348     // Compute the number of bits we need to represent these cases, this is
 349     // ceil(log2(numentries)).
 350     unsigned NumBits = Log2_32_Ceil(UniqueOperandCommands.size());
 351
 352     // If we don't have enough bits for this operand, don't include it.
 353     if (NumBits > BitsLeft) {
 354       LLVM_DEBUG(errs() << "Not enough bits to densely encode " << NumBits
 355                         << " more bits\n");
 356       break;
 357     }
 358
 359     // Otherwise, we can include this in the initial lookup table.  Add it in.
 360     for (size_t i = 0, e = InstIdxs.size(); i != e; ++i) {
 361       unsigned NumOps = NumInstOpsHandled[i];
 362       for (unsigned Idx : InstIdxs[i]) {
 363         OpcodeInfo[Instructions[Idx].CGIIndex] |=
 364           (uint64_t)i << (OpcodeInfoBits-BitsLeft);
 365         // Remove the info about this operand from the instruction.
 366         AsmWriterInst &Inst = Instructions[Idx];
 367         if (!Inst.Operands.empty()) {
 368           assert(NumOps <= Inst.Operands.size() &&
 369                  "Can't remove this many ops!");
 370           Inst.Operands.erase(Inst.Operands.begin(),
 371                               Inst.Operands.begin()+NumOps);
 372         }
 373       }
 374     }
 375     BitsLeft -= NumBits;
 376
 377     // Remember the handlers for this set of operands.
 378     TableDrivenOperandPrinters.push_back(std::move(UniqueOperandCommands));
 379   }
 380
 381   // Emit the string table itself.
 382   O << "  static const char AsmStrs[] = {\n";
 383   StringTable.emit(O, printChar);
 384   O << "  };\n\n";
 385
 386   // Emit the lookup tables in pieces to minimize wasted bytes.
 387   unsigned BytesNeeded = ((OpcodeInfoBits - BitsLeft) + 7) / 8;
 388   unsigned Table = 0, Shift = 0;
 389   SmallString<128> BitsString;
 390   raw_svector_ostream BitsOS(BitsString);
 391   // If the total bits is more than 32-bits we need to use a 64-bit type.
 392   BitsOS << "  uint" << ((BitsLeft < (OpcodeInfoBits - 32)) ? 64 : 32)
 393          << "_t Bits = 0;\n";
 394   while (BytesNeeded != 0) {
 395     // Figure out how big this table section needs to be, but no bigger than 4.
 396     unsigned TableSize = std::min(1 << Log2_32(BytesNeeded), 4);
 397     BytesNeeded -= TableSize;
 398     TableSize *= 8; // Convert to bits;
 399     uint64_t Mask = (1ULL << TableSize) - 1;
 400     O << "  static const uint" << TableSize << "_t OpInfo" << Table
 401       << "[] = {\n";
 402     for (unsigned i = 0, e = NumberedInstructions.size(); i != e; ++i) {
 403       O << "    " << ((OpcodeInfo[i] >> Shift) & Mask) << "U,\t// "
 404         << NumberedInstructions[i]->TheDef->getName() << "\n";
 405     }
 406     O << "  };\n\n";
 407     // Emit string to combine the individual table lookups.
 408     BitsOS << "  Bits |= ";
 409     // If the total bits is more than 32-bits we need to use a 64-bit type.
 410     if (BitsLeft < (OpcodeInfoBits - 32))
 411       BitsOS << "(uint64_t)";
 412     BitsOS << "OpInfo" << Table << "[MI->getOpcode()] << " << Shift << ";\n";
 413     // Prepare the shift for the next iteration and increment the table count.
 414     Shift += TableSize;
 415     ++Table;
 416   }
 417
 418   // Emit the initial tab character.
 419   O << "  O << \"\\t\";\n\n";
 420
 421   O << "  // Emit the opcode for the instruction.\n";
 422   O << BitsString;
 423
 424   // Emit the starting string.
 425   O << "  assert(Bits != 0 && \"Cannot print this instruction.\");\n"
 426     << "  O << AsmStrs+(Bits & " << (1 << AsmStrBits)-1 << ")-1;\n\n";
 427
 428   // Output the table driven operand information.
 429   BitsLeft = OpcodeInfoBits-AsmStrBits;
 430   for (unsigned i = 0, e = TableDrivenOperandPrinters.size(); i != e; ++i) {
 431     std::vector<std::string> &Commands = TableDrivenOperandPrinters[i];
 432
 433     // Compute the number of bits we need to represent these cases, this is
 434     // ceil(log2(numentries)).
 435     unsigned NumBits = Log2_32_Ceil(Commands.size());
 436     assert(NumBits <= BitsLeft && "consistency error");
 437
 438     // Emit code to extract this field from Bits.
 439     O << "\n  // Fragment " << i << " encoded into " << NumBits
 440       << " bits for " << Commands.size() << " unique commands.\n";
 441
 442     if (Commands.size() == 2) {
 443       // Emit two possibilitys with if/else.
 444       O << "  if ((Bits >> "
 445         << (OpcodeInfoBits-BitsLeft) << ") & "
 446         << ((1 << NumBits)-1) << ") {\n"
 447         << Commands[1]
 448         << "  } else {\n"
 449         << Commands[0]
 450         << "  }\n\n";
 451     } else if (Commands.size() == 1) {
 452       // Emit a single possibility.
 453       O << Commands[0] << "\n\n";
 454     } else {
 455       O << "  switch ((Bits >> "
 456         << (OpcodeInfoBits-BitsLeft) << ") & "
 457         << ((1 << NumBits)-1) << ") {\n"
 458         << "  default: llvm_unreachable(\"Invalid command number.\");\n";
 459
 460       // Print out all the cases.
 461       for (unsigned j = 0, e = Commands.size(); j != e; ++j) {
 462         O << "  case " << j << ":\n";
 463         O << Commands[j];
 464         O << "    break;\n";
 465       }
 466       O << "  }\n\n";
 467     }
 468     BitsLeft -= NumBits;
 469   }
 470
 471   // Okay, delete instructions with no operand info left.
 472   auto I = llvm::remove_if(Instructions,
 473                      [](AsmWriterInst &Inst) { return Inst.Operands.empty(); });
 474   Instructions.erase(I, Instructions.end());
 475
 476
 477   // Because this is a vector, we want to emit from the end.  Reverse all of the
 478   // elements in the vector.
 479   std::reverse(Instructions.begin(), Instructions.end());
 480
 481
 482   // Now that we've emitted all of the operand info that fit into 64 bits, emit
 483   // information for those instructions that are left.  This is a less dense
 484   // encoding, but we expect the main 64-bit table to handle the majority of
 485   // instructions.
 486   if (!Instructions.empty()) {
 487     // Find the opcode # of inline asm.
 488     O << "  switch (MI->getOpcode()) {\n";
 489     O << "  default: llvm_unreachable(\"Unexpected opcode.\");\n";
 490     while (!Instructions.empty())
 491       EmitInstructions(Instructions, O, PassSubtarget);
 492
 493     O << "  }\n";
 494   }
 495
 496   O << "}\n";
 497 }
 498
 499 static void
 500 emitRegisterNameString(raw_ostream &O, StringRef AltName,
 501                        const std::deque<CodeGenRegister> &Registers) {
 502   SequenceToOffsetTable<std::string> StringTable;
 503   SmallVector<std::string, 4> AsmNames(Registers.size());
 504   unsigned i = 0;
 505   for (const auto &Reg : Registers) {
 506     std::string &AsmName = AsmNames[i++];
 507
 508     // "NoRegAltName" is special. We don't need to do a lookup for that,
 509     // as it's just a reference to the default register name.
 510     if (AltName == "" || AltName == "NoRegAltName") {
 511       AsmName = Reg.TheDef->getValueAsString("AsmName");
 512       if (AsmName.empty())
 513         AsmName = Reg.getName();
 514     } else {
 515       // Make sure the register has an alternate name for this index.
 516       std::vector<Record*> AltNameList =
 517         Reg.TheDef->getValueAsListOfDefs("RegAltNameIndices");
 518       unsigned Idx = 0, e;
 519       for (e = AltNameList.size();
 520            Idx < e && (AltNameList[Idx]->getName() != AltName);
 521            ++Idx)
 522         ;
 523       // If the register has an alternate name for this index, use it.
 524       // Otherwise, leave it empty as an error flag.
 525       if (Idx < e) {
 526         std::vector<StringRef> AltNames =
 527           Reg.TheDef->getValueAsListOfStrings("AltNames");
 528         if (AltNames.size() <= Idx)
 529           PrintFatalError(Reg.TheDef->getLoc(),
 530                           "Register definition missing alt name for '" +
 531                           AltName + "'.");
 532         AsmName = AltNames[Idx];
 533       }
 534     }
 535     StringTable.add(AsmName);
 536   }
 537
 538   StringTable.layout();
 539   O << "  static const char AsmStrs" << AltName << "[] = {\n";
 540   StringTable.emit(O, printChar);
 541   O << "  };\n\n";
 542
 543   O << "  static const " << getMinimalTypeForRange(StringTable.size() - 1, 32)
 544     << " RegAsmOffset" << AltName << "[] = {";
 545   for (unsigned i = 0, e = Registers.size(); i != e; ++i) {
 546     if ((i % 14) == 0)
 547       O << "\n    ";
 548     O << StringTable.get(AsmNames[i]) << ", ";
 549   }
 550   O << "\n  };\n"
 551     << "\n";
 552 }
 553
 554 void AsmWriterEmitter::EmitGetRegisterName(raw_ostream &O) {
 555   Record *AsmWriter = Target.getAsmWriter();
 556   StringRef ClassName = AsmWriter->getValueAsString("AsmWriterClassName");
 557   const auto &Registers = Target.getRegBank().getRegisters();
 558   const std::vector<Record*> &AltNameIndices = Target.getRegAltNameIndices();
 559   bool hasAltNames = AltNameIndices.size() > 1;
 560   StringRef Namespace = Registers.front().TheDef->getValueAsString("Namespace");
 561
 562   O <<
 563   "\n\n/// getRegisterName - This method is automatically generated by tblgen\n"
 564   "/// from the register set description.  This returns the assembler name\n"
 565   "/// for the specified register.\n"
 566   "const char *" << Target.getName() << ClassName << "::";
 567   if (hasAltNames)
 568     O << "\ngetRegisterName(unsigned RegNo, unsigned AltIdx) {\n";
 569   else
 570     O << "getRegisterName(unsigned RegNo) {\n";
 571   O << "  assert(RegNo && RegNo < " << (Registers.size()+1)
 572     << " && \"Invalid register number!\");\n"
 573     << "\n";
 574
 575   if (hasAltNames) {
 576     for (const Record *R : AltNameIndices)
 577       emitRegisterNameString(O, R->getName(), Registers);
 578   } else
 579     emitRegisterNameString(O, "", Registers);
 580
 581   if (hasAltNames) {
 582     O << "  switch(AltIdx) {\n"
 583       << "  default: llvm_unreachable(\"Invalid register alt name index!\");\n";
 584     for (const Record *R : AltNameIndices) {
 585       StringRef AltName = R->getName();
 586       O << "  case ";
 587       if (!Namespace.empty())
 588         O << Namespace << "::";
 589       O << AltName << ":\n"
 590         << "    assert(*(AsmStrs" << AltName << "+RegAsmOffset" << AltName
 591         << "[RegNo-1]) &&\n"
 592         << "           \"Invalid alt name index for register!\");\n"
 593         << "    return AsmStrs" << AltName << "+RegAsmOffset" << AltName
 594         << "[RegNo-1];\n";
 595     }
 596     O << "  }\n";
 597   } else {
 598     O << "  assert (*(AsmStrs+RegAsmOffset[RegNo-1]) &&\n"
 599       << "          \"Invalid alt name index for register!\");\n"
 600       << "  return AsmStrs+RegAsmOffset[RegNo-1];\n";
 601   }
 602   O << "}\n";
 603 }
 604
 605 namespace {
 606
 607 // IAPrinter - Holds information about an InstAlias. Two InstAliases match if
 608 // they both have the same conditionals. In which case, we cannot print out the
 609 // alias for that pattern.
 610 class IAPrinter {
 611   std::vector<std::string> Conds;
 612   std::map<StringRef, std::pair<int, int>> OpMap;
 613
 614   std::string Result;
 615   std::string AsmString;
 616
 617 public:
 618   IAPrinter(std::string R, std::string AS)
 619       : Result(std::move(R)), AsmString(std::move(AS)) {}
 620
 621   void addCond(const std::string &C) { Conds.push_back(C); }
 622
 623   void addOperand(StringRef Op, int OpIdx, int PrintMethodIdx = -1) {
 624     assert(OpIdx >= 0 && OpIdx < 0xFE && "Idx out of range");
 625     assert(PrintMethodIdx >= -1 && PrintMethodIdx < 0xFF &&
 626            "Idx out of range");
 627     OpMap[Op] = std::make_pair(OpIdx, PrintMethodIdx);
 628   }
 629
 630   bool isOpMapped(StringRef Op) { return OpMap.find(Op) != OpMap.end(); }
 631   int getOpIndex(StringRef Op) { return OpMap[Op].first; }
 632   std::pair<int, int> &getOpData(StringRef Op) { return OpMap[Op]; }
 633
 634   std::pair<StringRef, StringRef::iterator> parseName(StringRef::iterator Start,
 635                                                       StringRef::iterator End) {
 636     StringRef::iterator I = Start;
 637     StringRef::iterator Next;
 638     if (*I == '{') {
 639       // ${some_name}
 640       Start = ++I;
 641       while (I != End && *I != '}')
 642         ++I;
 643       Next = I;
 644       // eat the final '}'
 645       if (Next != End)
 646         ++Next;
 647     } else {
 648       // $name, just eat the usual suspects.
 649       while (I != End &&
 650              ((*I >= 'a' && *I <= 'z') || (*I >= 'A' && *I <= 'Z') ||
 651               (*I >= '0' && *I <= '9') || *I == '_'))
 652         ++I;
 653       Next = I;
 654     }
 655
 656     return std::make_pair(StringRef(Start, I - Start), Next);
 657   }
 658
 659   void print(raw_ostream &O) {
 660     if (Conds.empty()) {
 661       O.indent(6) << "return true;\n";
 662       return;
 663     }
 664
 665     O << "if (";
 666
 667     for (std::vector<std::string>::iterator
 668            I = Conds.begin(), E = Conds.end(); I != E; ++I) {
 669       if (I != Conds.begin()) {
 670         O << " &&\n";
 671         O.indent(8);
 672       }
 673
 674       O << *I;
 675     }
 676
 677     O << ") {\n";
 678     O.indent(6) << "// " << Result << "\n";
 679
 680     // Directly mangle mapped operands into the string. Each operand is
 681     // identified by a '$' sign followed by a byte identifying the number of the
 682     // operand. We add one to the index to avoid zero bytes.
 683     StringRef ASM(AsmString);
 684     SmallString<128> OutString;
 685     raw_svector_ostream OS(OutString);
 686     for (StringRef::iterator I = ASM.begin(), E = ASM.end(); I != E;) {
 687       OS << *I;
 688       if (*I == '$') {
 689         StringRef Name;
 690         std::tie(Name, I) = parseName(++I, E);
 691         assert(isOpMapped(Name) && "Unmapped operand!");
 692
 693         int OpIndex, PrintIndex;
 694         std::tie(OpIndex, PrintIndex) = getOpData(Name);
 695         if (PrintIndex == -1) {
 696           // Can use the default printOperand route.
 697           OS << format("\\x%02X", (unsigned char)OpIndex + 1);
 698         } else
 699           // 3 bytes if a PrintMethod is needed: 0xFF, the MCInst operand
 700           // number, and which of our pre-detected Methods to call.
 701           OS << format("\\xFF\\x%02X\\x%02X", OpIndex + 1, PrintIndex + 1);
 702       } else {
 703         ++I;
 704       }
 705     }
 706
 707     // Emit the string.
 708     O.indent(6) << "AsmString = \"" << OutString << "\";\n";
 709
 710     O.indent(6) << "break;\n";
 711     O.indent(4) << '}';
 712   }
 713
 714   bool operator==(const IAPrinter &RHS) const {
 715     if (Conds.size() != RHS.Conds.size())
 716       return false;
 717
 718     unsigned Idx = 0;
 719     for (const auto &str : Conds)
 720       if (str != RHS.Conds[Idx++])
 721         return false;
 722
 723     return true;
 724   }
 725 };
 726
 727 } // end anonymous namespace
 728
 729 static unsigned CountNumOperands(StringRef AsmString, unsigned Variant) {
 730   return AsmString.count(' ') + AsmString.count('\t');
 731 }
 732
 733 namespace {
 734
 735 struct AliasPriorityComparator {
 736   typedef std::pair<CodeGenInstAlias, int> ValueType;
 737   bool operator()(const ValueType &LHS, const ValueType &RHS) const {
 738     if (LHS.second ==  RHS.second) {
 739       // We don't actually care about the order, but for consistency it
 740       // shouldn't depend on pointer comparisons.
 741       return LessRecordByID()(LHS.first.TheDef, RHS.first.TheDef);
 742     }
 743
 744     // Aliases with larger priorities should be considered first.
 745     return LHS.second > RHS.second;
 746   }
 747 };
 748
 749 } // end anonymous namespace
 750
 751 void AsmWriterEmitter::EmitPrintAliasInstruction(raw_ostream &O) {
 752   Record *AsmWriter = Target.getAsmWriter();
 753
 754   O << "\n#ifdef PRINT_ALIAS_INSTR\n";
 755   O << "#undef PRINT_ALIAS_INSTR\n\n";
 756
 757   //////////////////////////////
 758   // Gather information about aliases we need to print
 759   //////////////////////////////
 760
 761   // Emit the method that prints the alias instruction.
 762   StringRef ClassName = AsmWriter->getValueAsString("AsmWriterClassName");
 763   unsigned Variant = AsmWriter->getValueAsInt("Variant");
 764   bool PassSubtarget = AsmWriter->getValueAsInt("PassSubtarget");
 765
 766   std::vector<Record*> AllInstAliases =
 767     Records.getAllDerivedDefinitions("InstAlias");
 768
 769   // Create a map from the qualified name to a list of potential matches.
 770   typedef std::set<std::pair<CodeGenInstAlias, int>, AliasPriorityComparator>
 771       AliasWithPriority;
 772   std::map<std::string, AliasWithPriority> AliasMap;
 773   for (Record *R : AllInstAliases) {
 774     int Priority = R->getValueAsInt("EmitPriority");
 775     if (Priority < 1)
 776       continue; // Aliases with priority 0 are never emitted.
 777
 778     const DagInit *DI = R->getValueAsDag("ResultInst");
 779     const DefInit *Op = cast<DefInit>(DI->getOperator());
 780     AliasMap[getQualifiedName(Op->getDef())].insert(
 781         std::make_pair(CodeGenInstAlias(R, Target), Priority));
 782   }
 783
 784   // A map of which conditions need to be met for each instruction operand
 785   // before it can be matched to the mnemonic.
 786   std::map<std::string, std::vector<IAPrinter>> IAPrinterMap;
 787
 788   std::vector<std::string> PrintMethods;
 789
 790   // A list of MCOperandPredicates for all operands in use, and the reverse map
 791   std::vector<const Record*> MCOpPredicates;
 792   DenseMap<const Record*, unsigned> MCOpPredicateMap;
 793
 794   for (auto &Aliases : AliasMap) {
 795     for (auto &Alias : Aliases.second) {
 796       const CodeGenInstAlias &CGA = Alias.first;
 797       unsigned LastOpNo = CGA.ResultInstOperandIndex.size();
 798       std::string FlatInstAsmString =
 799          CodeGenInstruction::FlattenAsmStringVariants(CGA.ResultInst->AsmString,
 800                                                       Variant);
 801       unsigned NumResultOps = CountNumOperands(FlatInstAsmString, Variant);
 802
 803       std::string FlatAliasAsmString =
 804         CodeGenInstruction::FlattenAsmStringVariants(CGA.AsmString,
 805                                                       Variant);
 806
 807       // Don't emit the alias if it has more operands than what it's aliasing.
 808       if (NumResultOps < CountNumOperands(FlatAliasAsmString, Variant))
 809         continue;
 810
 811       IAPrinter IAP(CGA.Result->getAsString(), FlatAliasAsmString);
 812
 813       StringRef Namespace = Target.getName();
 814       std::vector<Record *> ReqFeatures;
 815       if (PassSubtarget) {
 816         // We only consider ReqFeatures predicates if PassSubtarget
 817         std::vector<Record *> RF =
 818             CGA.TheDef->getValueAsListOfDefs("Predicates");
 819         copy_if(RF, std::back_inserter(ReqFeatures), [](Record *R) {
 820           return R->getValueAsBit("AssemblerMatcherPredicate");
 821         });
 822       }
 823
 824       unsigned NumMIOps = 0;
 825       for (auto &ResultInstOpnd : CGA.ResultInst->Operands)
 826         NumMIOps += ResultInstOpnd.MINumOperands;
 827
 828       std::string Cond;
 829       Cond = std::string("MI->getNumOperands() == ") + utostr(NumMIOps);
 830       IAP.addCond(Cond);
 831
 832       bool CantHandle = false;
 833
 834       unsigned MIOpNum = 0;
 835       for (unsigned i = 0, e = LastOpNo; i != e; ++i) {
 836         // Skip over tied operands as they're not part of an alias declaration.
 837         auto &Operands = CGA.ResultInst->Operands;
 838         while (true) {
 839           unsigned OpNum = Operands.getSubOperandNumber(MIOpNum).first;
 840           if (Operands[OpNum].MINumOperands == 1 &&
 841               Operands[OpNum].getTiedRegister() != -1) {
 842             // Tied operands of different RegisterClass should be explicit within
 843             // an instruction's syntax and so cannot be skipped.
 844             int TiedOpNum = Operands[OpNum].getTiedRegister();
 845             if (Operands[OpNum].Rec->getName() ==
 846                 Operands[TiedOpNum].Rec->getName()) {
 847               ++MIOpNum;
 848               continue;
 849             }
 850           }
 851           break;
 852         }
 853
 854         std::string Op = "MI->getOperand(" + utostr(MIOpNum) + ")";
 855
 856         const CodeGenInstAlias::ResultOperand &RO = CGA.ResultOperands[i];
 857
 858         switch (RO.Kind) {
 859         case CodeGenInstAlias::ResultOperand::K_Record: {
 860           const Record *Rec = RO.getRecord();
 861           StringRef ROName = RO.getName();
 862           int PrintMethodIdx = -1;
 863
 864           // These two may have a PrintMethod, which we want to record (if it's
 865           // the first time we've seen it) and provide an index for the aliasing
 866           // code to use.
 867           if (Rec->isSubClassOf("RegisterOperand") ||
 868               Rec->isSubClassOf("Operand")) {
 869             StringRef PrintMethod = Rec->getValueAsString("PrintMethod");
 870             if (PrintMethod != "" && PrintMethod != "printOperand") {
 871               PrintMethodIdx =
 872                   llvm::find(PrintMethods, PrintMethod) - PrintMethods.begin();
 873               if (static_cast<unsigned>(PrintMethodIdx) == PrintMethods.size())
 874                 PrintMethods.push_back(PrintMethod);
 875             }
 876           }
 877
 878           if (Rec->isSubClassOf("RegisterOperand"))
 879             Rec = Rec->getValueAsDef("RegClass");
 880           if (Rec->isSubClassOf("RegisterClass")) {
 881             IAP.addCond(Op + ".isReg()");
 882
 883             if (!IAP.isOpMapped(ROName)) {
 884               IAP.addOperand(ROName, MIOpNum, PrintMethodIdx);
 885               Record *R = CGA.ResultOperands[i].getRecord();
 886               if (R->isSubClassOf("RegisterOperand"))
 887                 R = R->getValueAsDef("RegClass");
 888               Cond = std::string("MRI.getRegClass(") + Target.getName().str() +
 889                      "::" + R->getName().str() + "RegClassID).contains(" + Op +
 890                      ".getReg())";
 891             } else {
 892               Cond = Op + ".getReg() == MI->getOperand(" +
 893                      utostr(IAP.getOpIndex(ROName)) + ").getReg()";
 894             }
 895           } else {
 896             // Assume all printable operands are desired for now. This can be
 897             // overridden in the InstAlias instantiation if necessary.
 898             IAP.addOperand(ROName, MIOpNum, PrintMethodIdx);
 899
 900             // There might be an additional predicate on the MCOperand
 901             unsigned Entry = MCOpPredicateMap[Rec];
 902             if (!Entry) {
 903               if (!Rec->isValueUnset("MCOperandPredicate")) {
 904                 MCOpPredicates.push_back(Rec);
 905                 Entry = MCOpPredicates.size();
 906                 MCOpPredicateMap[Rec] = Entry;
 907               } else
 908                 break; // No conditions on this operand at all
 909             }
 910             Cond = (Target.getName() + ClassName + "ValidateMCOperand(" + Op +
 911                     ", STI, " + utostr(Entry) + ")")
 912                        .str();
 913           }
 914           // for all subcases of ResultOperand::K_Record:
 915           IAP.addCond(Cond);
 916           break;
 917         }
 918         case CodeGenInstAlias::ResultOperand::K_Imm: {
 919           // Just because the alias has an immediate result, doesn't mean the
 920           // MCInst will. An MCExpr could be present, for example.
 921           IAP.addCond(Op + ".isImm()");
 922
 923           Cond = Op + ".getImm() == " + itostr(CGA.ResultOperands[i].getImm());
 924           IAP.addCond(Cond);
 925           break;
 926         }
 927         case CodeGenInstAlias::ResultOperand::K_Reg:
 928           // If this is zero_reg, something's playing tricks we're not
 929           // equipped to handle.
 930           if (!CGA.ResultOperands[i].getRegister()) {
 931             CantHandle = true;
 932             break;
 933           }
 934
 935           Cond = Op + ".getReg() == " + Target.getName().str() + "::" +
 936                  CGA.ResultOperands[i].getRegister()->getName().str();
 937           IAP.addCond(Cond);
 938           break;
 939         }
 940
 941         MIOpNum += RO.getMINumOperands();
 942       }
 943
 944       if (CantHandle) continue;
 945
 946       for (auto I = ReqFeatures.cbegin(); I != ReqFeatures.cend(); I++) {
 947         Record *R = *I;
 948         StringRef AsmCondString = R->getValueAsString("AssemblerCondString");
 949
 950         // AsmCondString has syntax [!]F(,[!]F)*
 951         SmallVector<StringRef, 4> Ops;
 952         SplitString(AsmCondString, Ops, ",");
 953         assert(!Ops.empty() && "AssemblerCondString cannot be empty");
 954
 955         for (auto &Op : Ops) {
 956           assert(!Op.empty() && "Empty operator");
 957           if (Op[0] == '!')
 958             Cond = ("!STI.getFeatureBits()[" + Namespace + "::" + Op.substr(1) +
 959                     "]")
 960                        .str();
 961           else
 962             Cond =
 963                 ("STI.getFeatureBits()[" + Namespace + "::" + Op + "]").str();
 964           IAP.addCond(Cond);
 965         }
 966       }
 967
 968       IAPrinterMap[Aliases.first].push_back(std::move(IAP));
 969     }
 970   }
 971
 972   //////////////////////////////
 973   // Write out the printAliasInstr function
 974   //////////////////////////////
 975
 976   std::string Header;
 977   raw_string_ostream HeaderO(Header);
 978
 979   HeaderO << "bool " << Target.getName() << ClassName
 980           << "::printAliasInstr(const MCInst"
 981           << " *MI, " << (PassSubtarget ? "const MCSubtargetInfo &STI, " : "")
 982           << "raw_ostream &OS) {\n";
 983
 984   std::string Cases;
 985   raw_string_ostream CasesO(Cases);
 986
 987   for (auto &Entry : IAPrinterMap) {
 988     std::vector<IAPrinter> &IAPs = Entry.second;
 989     std::vector<IAPrinter*> UniqueIAPs;
 990
 991     for (auto &LHS : IAPs) {
 992       bool IsDup = false;
 993       for (const auto &RHS : IAPs) {
 994         if (&LHS != &RHS && LHS == RHS) {
 995           IsDup = true;
 996           break;
 997         }
 998       }
 999
1000       if (!IsDup)
1001         UniqueIAPs.push_back(&LHS);
1002     }
1003
1004     if (UniqueIAPs.empty()) continue;
1005
1006     CasesO.indent(2) << "case " << Entry.first << ":\n";
1007
1008     for (IAPrinter *IAP : UniqueIAPs) {
1009       CasesO.indent(4);
1010       IAP->print(CasesO);
1011       CasesO << '\n';
1012     }
1013
1014     CasesO.indent(4) << "return false;\n";
1015   }
1016
1017   if (CasesO.str().empty()) {
1018     O << HeaderO.str();
1019     O << "  return false;\n";
1020     O << "}\n\n";
1021     O << "#endif // PRINT_ALIAS_INSTR\n";
1022     return;
1023   }
1024
1025   if (!MCOpPredicates.empty())
1026     O << "static bool " << Target.getName() << ClassName
1027       << "ValidateMCOperand(const MCOperand &MCOp,\n"
1028       << "                  const MCSubtargetInfo &STI,\n"
1029       << "                  unsigned PredicateIndex);\n";
1030
1031   O << HeaderO.str();
1032   O.indent(2) << "const char *AsmString;\n";
1033   O.indent(2) << "switch (MI->getOpcode()) {\n";
1034   O.indent(2) << "default: return false;\n";
1035   O << CasesO.str();
1036   O.indent(2) << "}\n\n";
1037
1038   // Code that prints the alias, replacing the operands with the ones from the
1039   // MCInst.
1040   O << "  unsigned I = 0;\n";
1041   O << "  while (AsmString[I] != ' ' && AsmString[I] != '\\t' &&\n";
1042   O << "         AsmString[I] != '$' && AsmString[I] != '\\0')\n";
1043   O << "    ++I;\n";
1044   O << "  OS << '\\t' << StringRef(AsmString, I);\n";
1045
1046   O << "  if (AsmString[I] != '\\0') {\n";
1047   O << "    if (AsmString[I] == ' ' || AsmString[I] == '\\t') {\n";
1048   O << "      OS << '\\t';\n";
1049   O << "      ++I;\n";
1050   O << "    }\n";
1051   O << "    do {\n";
1052   O << "      if (AsmString[I] == '$') {\n";
1053   O << "        ++I;\n";
1054   O << "        if (AsmString[I] == (char)0xff) {\n";
1055   O << "          ++I;\n";
1056   O << "          int OpIdx = AsmString[I++] - 1;\n";
1057   O << "          int PrintMethodIdx = AsmString[I++] - 1;\n";
1058   O << "          printCustomAliasOperand(MI, OpIdx, PrintMethodIdx, ";
1059   O << (PassSubtarget ? "STI, " : "");
1060   O << "OS);\n";
1061   O << "        } else\n";
1062   O << "          printOperand(MI, unsigned(AsmString[I++]) - 1, ";
1063   O << (PassSubtarget ? "STI, " : "");
1064   O << "OS);\n";
1065   O << "      } else {\n";
1066   O << "        OS << AsmString[I++];\n";
1067   O << "      }\n";
1068   O << "    } while (AsmString[I] != '\\0');\n";
1069   O << "  }\n\n";
1070
1071   O << "  return true;\n";
1072   O << "}\n\n";
1073
1074   //////////////////////////////
1075   // Write out the printCustomAliasOperand function
1076   //////////////////////////////
1077
1078   O << "void " << Target.getName() << ClassName << "::"
1079     << "printCustomAliasOperand(\n"
1080     << "         const MCInst *MI, unsigned OpIdx,\n"
1081     << "         unsigned PrintMethodIdx,\n"
1082     << (PassSubtarget ? "         const MCSubtargetInfo &STI,\n" : "")
1083     << "         raw_ostream &OS) {\n";
1084   if (PrintMethods.empty())
1085     O << "  llvm_unreachable(\"Unknown PrintMethod kind\");\n";
1086   else {
1087     O << "  switch (PrintMethodIdx) {\n"
1088       << "  default:\n"
1089       << "    llvm_unreachable(\"Unknown PrintMethod kind\");\n"
1090       << "    break;\n";
1091
1092     for (unsigned i = 0; i < PrintMethods.size(); ++i) {
1093       O << "  case " << i << ":\n"
1094         << "    " << PrintMethods[i] << "(MI, OpIdx, "
1095         << (PassSubtarget ? "STI, " : "") << "OS);\n"
1096         << "    break;\n";
1097     }
1098     O << "  }\n";
1099   }
1100   O << "}\n\n";
1101
1102   if (!MCOpPredicates.empty()) {
1103     O << "static bool " << Target.getName() << ClassName
1104       << "ValidateMCOperand(const MCOperand &MCOp,\n"
1105       << "                  const MCSubtargetInfo &STI,\n"
1106       << "                  unsigned PredicateIndex) {\n"
1107       << "  switch (PredicateIndex) {\n"
1108       << "  default:\n"
1109       << "    llvm_unreachable(\"Unknown MCOperandPredicate kind\");\n"
1110       << "    break;\n";
1111
1112     for (unsigned i = 0; i < MCOpPredicates.size(); ++i) {
1113       Init *MCOpPred = MCOpPredicates[i]->getValueInit("MCOperandPredicate");
1114       if (CodeInit *SI = dyn_cast<CodeInit>(MCOpPred)) {
1115         O << "  case " << i + 1 << ": {\n"
1116           << SI->getValue() << "\n"
1117           << "    }\n";
1118       } else
1119         llvm_unreachable("Unexpected MCOperandPredicate field!");
1120     }
1121     O << "  }\n"
1122       << "}\n\n";
1123   }
1124
1125   O << "#endif // PRINT_ALIAS_INSTR\n";
1126 }
1127
1128 AsmWriterEmitter::AsmWriterEmitter(RecordKeeper &R) : Records(R), Target(R) {
1129   Record *AsmWriter = Target.getAsmWriter();
1130   unsigned Variant = AsmWriter->getValueAsInt("Variant");
1131
1132   // Get the instruction numbering.
1133   NumberedInstructions = Target.getInstructionsByEnumValue();
1134
1135   for (unsigned i = 0, e = NumberedInstructions.size(); i != e; ++i) {
1136     const CodeGenInstruction *I = NumberedInstructions[i];
1137     if (!I->AsmString.empty() && I->TheDef->getName() != "PHI")
1138       Instructions.emplace_back(*I, i, Variant);
1139   }
1140 }
1141
1142 void AsmWriterEmitter::run(raw_ostream &O) {
1143   EmitPrintInstruction(O);
1144   EmitGetRegisterName(O);
1145   EmitPrintAliasInstruction(O);
1146 }
1147
1148 namespace llvm {
1149
1150 void EmitAsmWriter(RecordKeeper &RK, raw_ostream &OS) {
1151   emitSourceFileHeader("Assembly Writer Source Fragment", OS);
1152   AsmWriterEmitter(RK).run(OS);
1153 }
1154
1155 } // end namespace llvm