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 is 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 "AsmWriterEmitter.h"
  16 #include "CodeGenTarget.h"
  17 #include "Record.h"
  18 #include "llvm/ADT/StringExtras.h"
  19 #include "llvm/Support/Debug.h"
  20 #include "llvm/Support/MathExtras.h"
  21 #include <algorithm>
  22 using namespace llvm;
  23
  24 static bool isIdentChar(char C) {
  25   return (C >= 'a' && C <= 'z') ||
  26          (C >= 'A' && C <= 'Z') ||
  27          (C >= '0' && C <= '9') ||
  28          C == '_';
  29 }
  30
  31 // This should be an anon namespace, this works around a GCC warning.
  32 namespace llvm {
  33   struct AsmWriterOperand {
  34     enum { isLiteralTextOperand, isMachineInstrOperand } OperandType;
  35
  36     /// Str - For isLiteralTextOperand, this IS the literal text.  For
  37     /// isMachineInstrOperand, this is the PrinterMethodName for the operand.
  38     std::string Str;
  39
  40     /// MiOpNo - For isMachineInstrOperand, this is the operand number of the
  41     /// machine instruction.
  42     unsigned MIOpNo;
  43
  44     /// MiModifier - For isMachineInstrOperand, this is the modifier string for
  45     /// an operand, specified with syntax like ${opname:modifier}.
  46     std::string MiModifier;
  47
  48     // To make VS STL happy
  49     AsmWriterOperand():OperandType(isLiteralTextOperand) {}
  50
  51     explicit AsmWriterOperand(const std::string &LitStr)
  52       : OperandType(isLiteralTextOperand), Str(LitStr) {}
  53
  54     AsmWriterOperand(const std::string &Printer, unsigned OpNo,
  55                      const std::string &Modifier)
  56       : OperandType(isMachineInstrOperand), Str(Printer), MIOpNo(OpNo),
  57       MiModifier(Modifier) {}
  58
  59     bool operator!=(const AsmWriterOperand &Other) const {
  60       if (OperandType != Other.OperandType || Str != Other.Str) return true;
  61       if (OperandType == isMachineInstrOperand)
  62         return MIOpNo != Other.MIOpNo || MiModifier != Other.MiModifier;
  63       return false;
  64     }
  65     bool operator==(const AsmWriterOperand &Other) const {
  66       return !operator!=(Other);
  67     }
  68
  69     /// getCode - Return the code that prints this operand.
  70     std::string getCode() const;
  71   };
  72 }
  73
  74 namespace llvm {
  75   class AsmWriterInst {
  76   public:
  77     std::vector<AsmWriterOperand> Operands;
  78     const CodeGenInstruction *CGI;
  79
  80     AsmWriterInst(const CodeGenInstruction &CGI, unsigned Variant);
  81
  82     /// MatchesAllButOneOp - If this instruction is exactly identical to the
  83     /// specified instruction except for one differing operand, return the
  84     /// differing operand number.  Otherwise return ~0.
  85     unsigned MatchesAllButOneOp(const AsmWriterInst &Other) const;
  86
  87   private:
  88     void AddLiteralString(const std::string &Str) {
  89       // If the last operand was already a literal text string, append this to
  90       // it, otherwise add a new operand.
  91       if (!Operands.empty() &&
  92           Operands.back().OperandType == AsmWriterOperand::isLiteralTextOperand)
  93         Operands.back().Str.append(Str);
  94       else
  95         Operands.push_back(AsmWriterOperand(Str));
  96     }
  97   };
  98 }
  99
 100
 101 std::string AsmWriterOperand::getCode() const {
 102   if (OperandType == isLiteralTextOperand)
 103     return "O << \"" + Str + "\"; ";
 104
 105   std::string Result = Str + "(MI";
 106   if (MIOpNo != ~0U)
 107     Result += ", " + utostr(MIOpNo);
 108   if (!MiModifier.empty())
 109     Result += ", \"" + MiModifier + '"';
 110   return Result + "); ";
 111 }
 112
 113
 114 /// ParseAsmString - Parse the specified Instruction's AsmString into this
 115 /// AsmWriterInst.
 116 ///
 117 AsmWriterInst::AsmWriterInst(const CodeGenInstruction &CGI, unsigned Variant) {
 118   this->CGI = &CGI;
 119   unsigned CurVariant = ~0U;  // ~0 if we are outside a {.|.|.} region, other #.
 120
 121   // NOTE: Any extensions to this code need to be mirrored in the
 122   // AsmPrinter::printInlineAsm code that executes as compile time (assuming
 123   // that inline asm strings should also get the new feature)!
 124   const std::string &AsmString = CGI.AsmString;
 125   std::string::size_type LastEmitted = 0;
 126   while (LastEmitted != AsmString.size()) {
 127     std::string::size_type DollarPos =
 128       AsmString.find_first_of("${|}\\", LastEmitted);
 129     if (DollarPos == std::string::npos) DollarPos = AsmString.size();
 130
 131     // Emit a constant string fragment.
 132     if (DollarPos != LastEmitted) {
 133       // TODO: this should eventually handle escaping.
 134       if (CurVariant == Variant || CurVariant == ~0U)
 135         AddLiteralString(std::string(AsmString.begin()+LastEmitted,
 136                                      AsmString.begin()+DollarPos));
 137       LastEmitted = DollarPos;
 138     } else if (AsmString[DollarPos] == '\\') {
 139       if (DollarPos+1 != AsmString.size() &&
 140           (CurVariant == Variant || CurVariant == ~0U)) {
 141         if (AsmString[DollarPos+1] == 'n') {
 142           AddLiteralString("\\n");
 143         } else if (AsmString[DollarPos+1] == 't') {
 144           AddLiteralString("\\t");
 145         } else if (std::string("${|}\\").find(AsmString[DollarPos+1])
 146                    != std::string::npos) {
 147           AddLiteralString(std::string(1, AsmString[DollarPos+1]));
 148         } else {
 149           throw "Non-supported escaped character found in instruction '" +
 150             CGI.TheDef->getName() + "'!";
 151         }
 152         LastEmitted = DollarPos+2;
 153         continue;
 154       }
 155     } else if (AsmString[DollarPos] == '{') {
 156       if (CurVariant != ~0U)
 157         throw "Nested variants found for instruction '" +
 158               CGI.TheDef->getName() + "'!";
 159       LastEmitted = DollarPos+1;
 160       CurVariant = 0;   // We are now inside of the variant!
 161     } else if (AsmString[DollarPos] == '|') {
 162       if (CurVariant == ~0U)
 163         throw "'|' character found outside of a variant in instruction '"
 164           + CGI.TheDef->getName() + "'!";
 165       ++CurVariant;
 166       ++LastEmitted;
 167     } else if (AsmString[DollarPos] == '}') {
 168       if (CurVariant == ~0U)
 169         throw "'}' character found outside of a variant in instruction '"
 170           + CGI.TheDef->getName() + "'!";
 171       ++LastEmitted;
 172       CurVariant = ~0U;
 173     } else if (DollarPos+1 != AsmString.size() &&
 174                AsmString[DollarPos+1] == '$') {
 175       if (CurVariant == Variant || CurVariant == ~0U)
 176         AddLiteralString("$");  // "$$" -> $
 177       LastEmitted = DollarPos+2;
 178     } else {
 179       // Get the name of the variable.
 180       std::string::size_type VarEnd = DollarPos+1;
 181
 182       // handle ${foo}bar as $foo by detecting whether the character following
 183       // the dollar sign is a curly brace.  If so, advance VarEnd and DollarPos
 184       // so the variable name does not contain the leading curly brace.
 185       bool hasCurlyBraces = false;
 186       if (VarEnd < AsmString.size() && '{' == AsmString[VarEnd]) {
 187         hasCurlyBraces = true;
 188         ++DollarPos;
 189         ++VarEnd;
 190       }
 191
 192       while (VarEnd < AsmString.size() && isIdentChar(AsmString[VarEnd]))
 193         ++VarEnd;
 194       std::string VarName(AsmString.begin()+DollarPos+1,
 195                           AsmString.begin()+VarEnd);
 196
 197       // Modifier - Support ${foo:modifier} syntax, where "modifier" is passed
 198       // into printOperand.  Also support ${:feature}, which is passed into
 199       // PrintSpecial.
 200       std::string Modifier;
 201
 202       // In order to avoid starting the next string at the terminating curly
 203       // brace, advance the end position past it if we found an opening curly
 204       // brace.
 205       if (hasCurlyBraces) {
 206         if (VarEnd >= AsmString.size())
 207           throw "Reached end of string before terminating curly brace in '"
 208                 + CGI.TheDef->getName() + "'";
 209
 210         // Look for a modifier string.
 211         if (AsmString[VarEnd] == ':') {
 212           ++VarEnd;
 213           if (VarEnd >= AsmString.size())
 214             throw "Reached end of string before terminating curly brace in '"
 215               + CGI.TheDef->getName() + "'";
 216
 217           unsigned ModifierStart = VarEnd;
 218           while (VarEnd < AsmString.size() && isIdentChar(AsmString[VarEnd]))
 219             ++VarEnd;
 220           Modifier = std::string(AsmString.begin()+ModifierStart,
 221                                  AsmString.begin()+VarEnd);
 222           if (Modifier.empty())
 223             throw "Bad operand modifier name in '"+ CGI.TheDef->getName() + "'";
 224         }
 225
 226         if (AsmString[VarEnd] != '}')
 227           throw "Variable name beginning with '{' did not end with '}' in '"
 228                 + CGI.TheDef->getName() + "'";
 229         ++VarEnd;
 230       }
 231       if (VarName.empty() && Modifier.empty())
 232         throw "Stray '$' in '" + CGI.TheDef->getName() +
 233               "' asm string, maybe you want $$?";
 234
 235       if (VarName.empty()) {
 236         // Just a modifier, pass this into PrintSpecial.
 237         Operands.push_back(AsmWriterOperand("PrintSpecial", ~0U, Modifier));
 238       } else {
 239         // Otherwise, normal operand.
 240         unsigned OpNo = CGI.getOperandNamed(VarName);
 241         CodeGenInstruction::OperandInfo OpInfo = CGI.OperandList[OpNo];
 242
 243         if (CurVariant == Variant || CurVariant == ~0U) {
 244           unsigned MIOp = OpInfo.MIOperandNo;
 245           Operands.push_back(AsmWriterOperand(OpInfo.PrinterMethodName, MIOp,
 246                                               Modifier));
 247         }
 248       }
 249       LastEmitted = VarEnd;
 250     }
 251   }
 252
 253   AddLiteralString("\\n");
 254 }
 255
 256 /// MatchesAllButOneOp - If this instruction is exactly identical to the
 257 /// specified instruction except for one differing operand, return the differing
 258 /// operand number.  If more than one operand mismatches, return ~1, otherwise
 259 /// if the instructions are identical return ~0.
 260 unsigned AsmWriterInst::MatchesAllButOneOp(const AsmWriterInst &Other)const{
 261   if (Operands.size() != Other.Operands.size()) return ~1;
 262
 263   unsigned MismatchOperand = ~0U;
 264   for (unsigned i = 0, e = Operands.size(); i != e; ++i) {
 265     if (Operands[i] != Other.Operands[i]) {
 266       if (MismatchOperand != ~0U)  // Already have one mismatch?
 267         return ~1U;
 268       else
 269         MismatchOperand = i;
 270     }
 271   }
 272   return MismatchOperand;
 273 }
 274
 275 static void PrintCases(std::vector<std::pair<std::string,
 276                        AsmWriterOperand> > &OpsToPrint, std::ostream &O) {
 277   O << "    case " << OpsToPrint.back().first << ": ";
 278   AsmWriterOperand TheOp = OpsToPrint.back().second;
 279   OpsToPrint.pop_back();
 280
 281   // Check to see if any other operands are identical in this list, and if so,
 282   // emit a case label for them.
 283   for (unsigned i = OpsToPrint.size(); i != 0; --i)
 284     if (OpsToPrint[i-1].second == TheOp) {
 285       O << "\n    case " << OpsToPrint[i-1].first << ": ";
 286       OpsToPrint.erase(OpsToPrint.begin()+i-1);
 287     }
 288
 289   // Finally, emit the code.
 290   O << TheOp.getCode();
 291   O << "break;\n";
 292 }
 293
 294
 295 /// EmitInstructions - Emit the last instruction in the vector and any other
 296 /// instructions that are suitably similar to it.
 297 static void EmitInstructions(std::vector<AsmWriterInst> &Insts,
 298                              std::ostream &O) {
 299   AsmWriterInst FirstInst = Insts.back();
 300   Insts.pop_back();
 301
 302   std::vector<AsmWriterInst> SimilarInsts;
 303   unsigned DifferingOperand = ~0;
 304   for (unsigned i = Insts.size(); i != 0; --i) {
 305     unsigned DiffOp = Insts[i-1].MatchesAllButOneOp(FirstInst);
 306     if (DiffOp != ~1U) {
 307       if (DifferingOperand == ~0U)  // First match!
 308         DifferingOperand = DiffOp;
 309
 310       // If this differs in the same operand as the rest of the instructions in
 311       // this class, move it to the SimilarInsts list.
 312       if (DifferingOperand == DiffOp || DiffOp == ~0U) {
 313         SimilarInsts.push_back(Insts[i-1]);
 314         Insts.erase(Insts.begin()+i-1);
 315       }
 316     }
 317   }
 318
 319   O << "  case " << FirstInst.CGI->Namespace << "::"
 320     << FirstInst.CGI->TheDef->getName() << ":\n";
 321   for (unsigned i = 0, e = SimilarInsts.size(); i != e; ++i)
 322     O << "  case " << SimilarInsts[i].CGI->Namespace << "::"
 323       << SimilarInsts[i].CGI->TheDef->getName() << ":\n";
 324   for (unsigned i = 0, e = FirstInst.Operands.size(); i != e; ++i) {
 325     if (i != DifferingOperand) {
 326       // If the operand is the same for all instructions, just print it.
 327       O << "    " << FirstInst.Operands[i].getCode();
 328     } else {
 329       // If this is the operand that varies between all of the instructions,
 330       // emit a switch for just this operand now.
 331       O << "    switch (MI->getOpcode()) {\n";
 332       std::vector<std::pair<std::string, AsmWriterOperand> > OpsToPrint;
 333       OpsToPrint.push_back(std::make_pair(FirstInst.CGI->Namespace + "::" +
 334                                           FirstInst.CGI->TheDef->getName(),
 335                                           FirstInst.Operands[i]));
 336
 337       for (unsigned si = 0, e = SimilarInsts.size(); si != e; ++si) {
 338         AsmWriterInst &AWI = SimilarInsts[si];
 339         OpsToPrint.push_back(std::make_pair(AWI.CGI->Namespace+"::"+
 340                                             AWI.CGI->TheDef->getName(),
 341                                             AWI.Operands[i]));
 342       }
 343       std::reverse(OpsToPrint.begin(), OpsToPrint.end());
 344       while (!OpsToPrint.empty())
 345         PrintCases(OpsToPrint, O);
 346       O << "    }";
 347     }
 348     O << "\n";
 349   }
 350
 351   O << "    break;\n";
 352 }
 353
 354 void AsmWriterEmitter::
 355 FindUniqueOperandCommands(std::vector<std::string> &UniqueOperandCommands,
 356                           std::vector<unsigned> &InstIdxs,
 357                           std::vector<unsigned> &InstOpsUsed) const {
 358   InstIdxs.assign(NumberedInstructions.size(), ~0U);
 359
 360   // This vector parallels UniqueOperandCommands, keeping track of which
 361   // instructions each case are used for.  It is a comma separated string of
 362   // enums.
 363   std::vector<std::string> InstrsForCase;
 364   InstrsForCase.resize(UniqueOperandCommands.size());
 365   InstOpsUsed.assign(UniqueOperandCommands.size(), 0);
 366
 367   for (unsigned i = 0, e = NumberedInstructions.size(); i != e; ++i) {
 368     const AsmWriterInst *Inst = getAsmWriterInstByID(i);
 369     if (Inst == 0) continue;  // PHI, INLINEASM, DBG_LABEL, etc.
 370
 371     std::string Command;
 372     if (Inst->Operands.empty())
 373       continue;   // Instruction already done.
 374
 375     Command = "    " + Inst->Operands[0].getCode() + "\n";
 376
 377     // If this is the last operand, emit a return.
 378     if (Inst->Operands.size() == 1)
 379       Command += "    return true;\n";
 380
 381     // Check to see if we already have 'Command' in UniqueOperandCommands.
 382     // If not, add it.
 383     bool FoundIt = false;
 384     for (unsigned idx = 0, e = UniqueOperandCommands.size(); idx != e; ++idx)
 385       if (UniqueOperandCommands[idx] == Command) {
 386         InstIdxs[i] = idx;
 387         InstrsForCase[idx] += ", ";
 388         InstrsForCase[idx] += Inst->CGI->TheDef->getName();
 389         FoundIt = true;
 390         break;
 391       }
 392     if (!FoundIt) {
 393       InstIdxs[i] = UniqueOperandCommands.size();
 394       UniqueOperandCommands.push_back(Command);
 395       InstrsForCase.push_back(Inst->CGI->TheDef->getName());
 396
 397       // This command matches one operand so far.
 398       InstOpsUsed.push_back(1);
 399     }
 400   }
 401
 402   // For each entry of UniqueOperandCommands, there is a set of instructions
 403   // that uses it.  If the next command of all instructions in the set are
 404   // identical, fold it into the command.
 405   for (unsigned CommandIdx = 0, e = UniqueOperandCommands.size();
 406        CommandIdx != e; ++CommandIdx) {
 407
 408     for (unsigned Op = 1; ; ++Op) {
 409       // Scan for the first instruction in the set.
 410       std::vector<unsigned>::iterator NIT =
 411         std::find(InstIdxs.begin(), InstIdxs.end(), CommandIdx);
 412       if (NIT == InstIdxs.end()) break;  // No commonality.
 413
 414       // If this instruction has no more operands, we isn't anything to merge
 415       // into this command.
 416       const AsmWriterInst *FirstInst =
 417         getAsmWriterInstByID(NIT-InstIdxs.begin());
 418       if (!FirstInst || FirstInst->Operands.size() == Op)
 419         break;
 420
 421       // Otherwise, scan to see if all of the other instructions in this command
 422       // set share the operand.
 423       bool AllSame = true;
 424
 425       for (NIT = std::find(NIT+1, InstIdxs.end(), CommandIdx);
 426            NIT != InstIdxs.end();
 427            NIT = std::find(NIT+1, InstIdxs.end(), CommandIdx)) {
 428         // Okay, found another instruction in this command set.  If the operand
 429         // matches, we're ok, otherwise bail out.
 430         const AsmWriterInst *OtherInst =
 431           getAsmWriterInstByID(NIT-InstIdxs.begin());
 432         if (!OtherInst || OtherInst->Operands.size() == Op ||
 433             OtherInst->Operands[Op] != FirstInst->Operands[Op]) {
 434           AllSame = false;
 435           break;
 436         }
 437       }
 438       if (!AllSame) break;
 439
 440       // Okay, everything in this command set has the same next operand.  Add it
 441       // to UniqueOperandCommands and remember that it was consumed.
 442       std::string Command = "    " + FirstInst->Operands[Op].getCode() + "\n";
 443
 444       // If this is the last operand, emit a return after the code.
 445       if (FirstInst->Operands.size() == Op+1)
 446         Command += "    return true;\n";
 447
 448       UniqueOperandCommands[CommandIdx] += Command;
 449       InstOpsUsed[CommandIdx]++;
 450     }
 451   }
 452
 453   // Prepend some of the instructions each case is used for onto the case val.
 454   for (unsigned i = 0, e = InstrsForCase.size(); i != e; ++i) {
 455     std::string Instrs = InstrsForCase[i];
 456     if (Instrs.size() > 70) {
 457       Instrs.erase(Instrs.begin()+70, Instrs.end());
 458       Instrs += "...";
 459     }
 460
 461     if (!Instrs.empty())
 462       UniqueOperandCommands[i] = "    // " + Instrs + "\n" +
 463         UniqueOperandCommands[i];
 464   }
 465 }
 466
 467
 468
 469 void AsmWriterEmitter::run(std::ostream &O) {
 470   EmitSourceFileHeader("Assembly Writer Source Fragment", O);
 471
 472   CodeGenTarget Target;
 473   Record *AsmWriter = Target.getAsmWriter();
 474   std::string ClassName = AsmWriter->getValueAsString("AsmWriterClassName");
 475   unsigned Variant = AsmWriter->getValueAsInt("Variant");
 476
 477   O <<
 478   "/// printInstruction - This method is automatically generated by tablegen\n"
 479   "/// from the instruction set description.  This method returns true if the\n"
 480   "/// machine instruction was sufficiently described to print it, otherwise\n"
 481   "/// it returns false.\n"
 482     "bool " << Target.getName() << ClassName
 483             << "::printInstruction(const MachineInstr *MI) {\n";
 484
 485   std::vector<AsmWriterInst> Instructions;
 486
 487   for (CodeGenTarget::inst_iterator I = Target.inst_begin(),
 488          E = Target.inst_end(); I != E; ++I)
 489     if (!I->second.AsmString.empty())
 490       Instructions.push_back(AsmWriterInst(I->second, Variant));
 491
 492   // Get the instruction numbering.
 493   Target.getInstructionsByEnumValue(NumberedInstructions);
 494
 495   // Compute the CodeGenInstruction -> AsmWriterInst mapping.  Note that not
 496   // all machine instructions are necessarily being printed, so there may be
 497   // target instructions not in this map.
 498   for (unsigned i = 0, e = Instructions.size(); i != e; ++i)
 499     CGIAWIMap.insert(std::make_pair(Instructions[i].CGI, &Instructions[i]));
 500
 501   // Build an aggregate string, and build a table of offsets into it.
 502   std::map<std::string, unsigned> StringOffset;
 503   std::string AggregateString;
 504   AggregateString.push_back(0);  // "\0"
 505   AggregateString.push_back(0);  // "\0"
 506
 507   /// OpcodeInfo - This encodes the index of the string to use for the first
 508   /// chunk of the output as well as indices used for operand printing.
 509   std::vector<unsigned> OpcodeInfo;
 510
 511   unsigned MaxStringIdx = 0;
 512   for (unsigned i = 0, e = NumberedInstructions.size(); i != e; ++i) {
 513     AsmWriterInst *AWI = CGIAWIMap[NumberedInstructions[i]];
 514     unsigned Idx;
 515     if (AWI == 0) {
 516       // Something not handled by the asmwriter printer.
 517       Idx = 0;
 518     } else if (AWI->Operands[0].OperandType !=
 519                         AsmWriterOperand::isLiteralTextOperand ||
 520                AWI->Operands[0].Str.empty()) {
 521       // Something handled by the asmwriter printer, but with no leading string.
 522       Idx = 1;
 523     } else {
 524       unsigned &Entry = StringOffset[AWI->Operands[0].Str];
 525       if (Entry == 0) {
 526         // Add the string to the aggregate if this is the first time found.
 527         MaxStringIdx = Entry = AggregateString.size();
 528         std::string Str = AWI->Operands[0].Str;
 529         UnescapeString(Str);
 530         AggregateString += Str;
 531         AggregateString += '\0';
 532       }
 533       Idx = Entry;
 534
 535       // Nuke the string from the operand list.  It is now handled!
 536       AWI->Operands.erase(AWI->Operands.begin());
 537     }
 538     OpcodeInfo.push_back(Idx);
 539   }
 540
 541   // Figure out how many bits we used for the string index.
 542   unsigned AsmStrBits = Log2_32_Ceil(MaxStringIdx+1);
 543
 544   // To reduce code size, we compactify common instructions into a few bits
 545   // in the opcode-indexed table.
 546   unsigned BitsLeft = 32-AsmStrBits;
 547
 548   std::vector<std::vector<std::string> > TableDrivenOperandPrinters;
 549
 550   bool isFirst = true;
 551   while (1) {
 552     std::vector<std::string> UniqueOperandCommands;
 553
 554     // For the first operand check, add a default value for instructions with
 555     // just opcode strings to use.
 556     if (isFirst) {
 557       UniqueOperandCommands.push_back("    return true;\n");
 558       isFirst = false;
 559     }
 560
 561     std::vector<unsigned> InstIdxs;
 562     std::vector<unsigned> NumInstOpsHandled;
 563     FindUniqueOperandCommands(UniqueOperandCommands, InstIdxs,
 564                               NumInstOpsHandled);
 565
 566     // If we ran out of operands to print, we're done.
 567     if (UniqueOperandCommands.empty()) break;
 568
 569     // Compute the number of bits we need to represent these cases, this is
 570     // ceil(log2(numentries)).
 571     unsigned NumBits = Log2_32_Ceil(UniqueOperandCommands.size());
 572
 573     // If we don't have enough bits for this operand, don't include it.
 574     if (NumBits > BitsLeft) {
 575       DOUT << "Not enough bits to densely encode " << NumBits
 576            << " more bits\n";
 577       break;
 578     }
 579
 580     // Otherwise, we can include this in the initial lookup table.  Add it in.
 581     BitsLeft -= NumBits;
 582     for (unsigned i = 0, e = InstIdxs.size(); i != e; ++i)
 583       if (InstIdxs[i] != ~0U)
 584         OpcodeInfo[i] |= InstIdxs[i] << (BitsLeft+AsmStrBits);
 585
 586     // Remove the info about this operand.
 587     for (unsigned i = 0, e = NumberedInstructions.size(); i != e; ++i) {
 588       if (AsmWriterInst *Inst = getAsmWriterInstByID(i))
 589         if (!Inst->Operands.empty()) {
 590           unsigned NumOps = NumInstOpsHandled[InstIdxs[i]];
 591           assert(NumOps <= Inst->Operands.size() &&
 592                  "Can't remove this many ops!");
 593           Inst->Operands.erase(Inst->Operands.begin(),
 594                                Inst->Operands.begin()+NumOps);
 595         }
 596     }
 597
 598     // Remember the handlers for this set of operands.
 599     TableDrivenOperandPrinters.push_back(UniqueOperandCommands);
 600   }
 601
 602
 603
 604   O<<"  static const unsigned OpInfo[] = {\n";
 605   for (unsigned i = 0, e = NumberedInstructions.size(); i != e; ++i) {
 606     O << "    " << OpcodeInfo[i] << "U,\t// "
 607       << NumberedInstructions[i]->TheDef->getName() << "\n";
 608   }
 609   // Add a dummy entry so the array init doesn't end with a comma.
 610   O << "    0U\n";
 611   O << "  };\n\n";
 612
 613   // Emit the string itself.
 614   O << "  const char *AsmStrs = \n    \"";
 615   unsigned CharsPrinted = 0;
 616   EscapeString(AggregateString);
 617   for (unsigned i = 0, e = AggregateString.size(); i != e; ++i) {
 618     if (CharsPrinted > 70) {
 619       O << "\"\n    \"";
 620       CharsPrinted = 0;
 621     }
 622     O << AggregateString[i];
 623     ++CharsPrinted;
 624
 625     // Print escape sequences all together.
 626     if (AggregateString[i] == '\\') {
 627       assert(i+1 < AggregateString.size() && "Incomplete escape sequence!");
 628       if (isdigit(AggregateString[i+1])) {
 629         assert(isdigit(AggregateString[i+2]) && isdigit(AggregateString[i+3]) &&
 630                "Expected 3 digit octal escape!");
 631         O << AggregateString[++i];
 632         O << AggregateString[++i];
 633         O << AggregateString[++i];
 634         CharsPrinted += 3;
 635       } else {
 636         O << AggregateString[++i];
 637         ++CharsPrinted;
 638       }
 639     }
 640   }
 641   O << "\";\n\n";
 642
 643   O << "  if (TAI->doesSupportDebugInformation() &&\n"
 644     << "      DW->ShouldEmitDwarfDebug() && !Fast) {\n"
 645     << "    DebugLoc CurDL = MI->getDebugLoc();\n\n"
 646     << "    if (!CurDL.isUnknown()) {\n"
 647     << "      static DebugLocTuple PrevDLT(~0U, ~0U, ~0U);\n"
 648     << "      DebugLocTuple CurDLT = MF->getDebugLocTuple(CurDL);\n\n"
 649     << "      if (PrevDLT.Src != ~0U && PrevDLT != CurDLT)\n"
 650     << "        printLabel(DW->RecordSourceLine(CurDLT.Line, CurDLT.Col,\n"
 651     << "                                        CurDLT.Src));\n\n"
 652     << "      PrevDLT = CurDLT;\n"
 653     << "    }\n"
 654     << "  }\n\n";
 655
 656   O << "  if (MI->getOpcode() == TargetInstrInfo::INLINEASM) {\n"
 657     << "    O << \"\\t\";\n"
 658     << "    printInlineAsm(MI);\n"
 659     << "    return true;\n"
 660     << "  } else if (MI->isLabel()) {\n"
 661     << "    printLabel(MI);\n"
 662     << "    return true;\n"
 663     << "  } else if (MI->getOpcode() == TargetInstrInfo::DECLARE) {\n"
 664     << "    printDeclare(MI);\n"
 665     << "    return true;\n"
 666     << "  } else if (MI->getOpcode() == TargetInstrInfo::IMPLICIT_DEF) {\n"
 667     << "    printImplicitDef(MI);\n"
 668     << "    return true;\n"
 669     << "  }\n\n";
 670
 671   O << "  O << \"\\t\";\n\n";
 672
 673   O << "  // Emit the opcode for the instruction.\n"
 674     << "  unsigned Bits = OpInfo[MI->getOpcode()];\n"
 675     << "  if (Bits == 0) return false;\n"
 676     << "  O << AsmStrs+(Bits & " << (1 << AsmStrBits)-1 << ");\n\n";
 677
 678   // Output the table driven operand information.
 679   BitsLeft = 32-AsmStrBits;
 680   for (unsigned i = 0, e = TableDrivenOperandPrinters.size(); i != e; ++i) {
 681     std::vector<std::string> &Commands = TableDrivenOperandPrinters[i];
 682
 683     // Compute the number of bits we need to represent these cases, this is
 684     // ceil(log2(numentries)).
 685     unsigned NumBits = Log2_32_Ceil(Commands.size());
 686     assert(NumBits <= BitsLeft && "consistency error");
 687
 688     // Emit code to extract this field from Bits.
 689     BitsLeft -= NumBits;
 690
 691     O << "\n  // Fragment " << i << " encoded into " << NumBits
 692       << " bits for " << Commands.size() << " unique commands.\n";
 693
 694     if (Commands.size() == 2) {
 695       // Emit two possibilitys with if/else.
 696       O << "  if ((Bits >> " << (BitsLeft+AsmStrBits) << ") & "
 697         << ((1 << NumBits)-1) << ") {\n"
 698         << Commands[1]
 699         << "  } else {\n"
 700         << Commands[0]
 701         << "  }\n\n";
 702     } else {
 703       O << "  switch ((Bits >> " << (BitsLeft+AsmStrBits) << ") & "
 704         << ((1 << NumBits)-1) << ") {\n"
 705         << "  default:   // unreachable.\n";
 706
 707       // Print out all the cases.
 708       for (unsigned i = 0, e = Commands.size(); i != e; ++i) {
 709         O << "  case " << i << ":\n";
 710         O << Commands[i];
 711         O << "    break;\n";
 712       }
 713       O << "  }\n\n";
 714     }
 715   }
 716
 717   // Okay, delete instructions with no operand info left.
 718   for (unsigned i = 0, e = Instructions.size(); i != e; ++i) {
 719     // Entire instruction has been emitted?
 720     AsmWriterInst &Inst = Instructions[i];
 721     if (Inst.Operands.empty()) {
 722       Instructions.erase(Instructions.begin()+i);
 723       --i; --e;
 724     }
 725   }
 726
 727
 728   // Because this is a vector, we want to emit from the end.  Reverse all of the
 729   // elements in the vector.
 730   std::reverse(Instructions.begin(), Instructions.end());
 731
 732   if (!Instructions.empty()) {
 733     // Find the opcode # of inline asm.
 734     O << "  switch (MI->getOpcode()) {\n";
 735     while (!Instructions.empty())
 736       EmitInstructions(Instructions, O);
 737
 738     O << "  }\n";
 739     O << "  return true;\n";
 740   }
 741
 742   O << "}\n";
 743 }