AsmWriterEmitter.cpp revision ba8dc03935fadb05d4d68f9913543df22487f523
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" 162e1f51b8a583649d74cb666ca5e4cf680cc1ced9Chris Lattner#include "CodeGenTarget.h" 17175580c0f36b026daf9de0adabdb7ddcf7619db6Chris Lattner#include "Record.h" 186af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner#include "llvm/ADT/StringExtras.h" 19bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner#include "llvm/Support/Debug.h" 20bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner#include "llvm/Support/MathExtras.h" 21615ed993e115f8bc97ff0678aa861629fec93880Jeff Cohen#include <algorithm> 221a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar#include <iostream> 232e1f51b8a583649d74cb666ca5e4cf680cc1ced9Chris Lattnerusing namespace llvm; 242e1f51b8a583649d74cb666ca5e4cf680cc1ced9Chris Lattner 25076efa771aa634801202f7b8189e33ee79dfc4edChris Lattnerstatic bool isIdentChar(char C) { 26076efa771aa634801202f7b8189e33ee79dfc4edChris Lattner return (C >= 'a' && C <= 'z') || 27076efa771aa634801202f7b8189e33ee79dfc4edChris Lattner (C >= 'A' && C <= 'Z') || 28076efa771aa634801202f7b8189e33ee79dfc4edChris Lattner (C >= '0' && C <= '9') || 29076efa771aa634801202f7b8189e33ee79dfc4edChris Lattner C == '_'; 30076efa771aa634801202f7b8189e33ee79dfc4edChris Lattner} 31076efa771aa634801202f7b8189e33ee79dfc4edChris Lattner 32ad8c531e202adfc812aeabaaf87616ba27f02339Chris Lattner// This should be an anon namespace, this works around a GCC warning. 33ad8c531e202adfc812aeabaaf87616ba27f02339Chris Lattnernamespace llvm { 34b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner struct AsmWriterOperand { 353837b64f4152bd074013c19b024b94ff52157a65Evan Cheng enum { isLiteralTextOperand, isMachineInstrOperand } OperandType; 36b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner 37b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner /// Str - For isLiteralTextOperand, this IS the literal text. For 38b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner /// isMachineInstrOperand, this is the PrinterMethodName for the operand. 39b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner std::string Str; 40b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner 41b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner /// MiOpNo - For isMachineInstrOperand, this is the operand number of the 42b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner /// machine instruction. 43b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner unsigned MIOpNo; 4404cadb3684b14e4aad19f9f29e6c14539866bd56Chris Lattner 4504cadb3684b14e4aad19f9f29e6c14539866bd56Chris Lattner /// MiModifier - For isMachineInstrOperand, this is the modifier string for 4604cadb3684b14e4aad19f9f29e6c14539866bd56Chris Lattner /// an operand, specified with syntax like ${opname:modifier}. 4704cadb3684b14e4aad19f9f29e6c14539866bd56Chris Lattner std::string MiModifier; 48b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner 497caa2d0ffcbb6faa37e280924d3653912cd52301Cedric Venet // To make VS STL happy 503837b64f4152bd074013c19b024b94ff52157a65Evan Cheng AsmWriterOperand():OperandType(isLiteralTextOperand) {} 513bff2df61cbb5e88bc814240bb35c5502b1628d1Cedric Venet 523837b64f4152bd074013c19b024b94ff52157a65Evan Cheng explicit AsmWriterOperand(const std::string &LitStr) 533837b64f4152bd074013c19b024b94ff52157a65Evan Cheng : OperandType(isLiteralTextOperand), Str(LitStr) {} 54b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner 5504cadb3684b14e4aad19f9f29e6c14539866bd56Chris Lattner AsmWriterOperand(const std::string &Printer, unsigned OpNo, 563837b64f4152bd074013c19b024b94ff52157a65Evan Cheng const std::string &Modifier) 573837b64f4152bd074013c19b024b94ff52157a65Evan Cheng : OperandType(isMachineInstrOperand), Str(Printer), MIOpNo(OpNo), 5804cadb3684b14e4aad19f9f29e6c14539866bd56Chris Lattner MiModifier(Modifier) {} 59b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner 60870c016934bacf43995d89531b166ae095ee3675Chris Lattner bool operator!=(const AsmWriterOperand &Other) const { 61870c016934bacf43995d89531b166ae095ee3675Chris Lattner if (OperandType != Other.OperandType || Str != Other.Str) return true; 62870c016934bacf43995d89531b166ae095ee3675Chris Lattner if (OperandType == isMachineInstrOperand) 6304cadb3684b14e4aad19f9f29e6c14539866bd56Chris Lattner return MIOpNo != Other.MIOpNo || MiModifier != Other.MiModifier; 64870c016934bacf43995d89531b166ae095ee3675Chris Lattner return false; 65870c016934bacf43995d89531b166ae095ee3675Chris Lattner } 6638c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner bool operator==(const AsmWriterOperand &Other) const { 6738c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner return !operator!=(Other); 6838c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner } 69bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner 70bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner /// getCode - Return the code that prints this operand. 71bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner std::string getCode() const; 72b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner }; 73bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner} 74b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner 75bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattnernamespace llvm { 76d41b30def3181bce4bf87e8bde664d15663165d0Jeff Cohen class AsmWriterInst { 77d41b30def3181bce4bf87e8bde664d15663165d0Jeff Cohen public: 78b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner std::vector<AsmWriterOperand> Operands; 795765dba5ce9f493f063a7caf1106e7db9b6693b6Chris Lattner const CodeGenInstruction *CGI; 803da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman 815765dba5ce9f493f063a7caf1106e7db9b6693b6Chris Lattner AsmWriterInst(const CodeGenInstruction &CGI, unsigned Variant); 82870c016934bacf43995d89531b166ae095ee3675Chris Lattner 83f876668518097413a904537ce9d249953987508cChris Lattner /// MatchesAllButOneOp - If this instruction is exactly identical to the 84f876668518097413a904537ce9d249953987508cChris Lattner /// specified instruction except for one differing operand, return the 85f876668518097413a904537ce9d249953987508cChris Lattner /// differing operand number. Otherwise return ~0. 86f876668518097413a904537ce9d249953987508cChris Lattner unsigned MatchesAllButOneOp(const AsmWriterInst &Other) const; 87870c016934bacf43995d89531b166ae095ee3675Chris Lattner 88b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner private: 89b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner void AddLiteralString(const std::string &Str) { 90b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner // If the last operand was already a literal text string, append this to 91b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner // it, otherwise add a new operand. 92b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner if (!Operands.empty() && 93b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner Operands.back().OperandType == AsmWriterOperand::isLiteralTextOperand) 94b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner Operands.back().Str.append(Str); 95b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner else 96b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner Operands.push_back(AsmWriterOperand(Str)); 97b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner } 98b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner }; 99b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner} 100b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner 101b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner 102bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattnerstd::string AsmWriterOperand::getCode() const { 103b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner if (OperandType == isLiteralTextOperand) 104bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner return "O << \"" + Str + "\"; "; 105bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner 1061bf6361dfde21fcc0f433c8cf53d5c366225ee3fChris Lattner std::string Result = Str + "(MI"; 1071bf6361dfde21fcc0f433c8cf53d5c366225ee3fChris Lattner if (MIOpNo != ~0U) 1081bf6361dfde21fcc0f433c8cf53d5c366225ee3fChris Lattner Result += ", " + utostr(MIOpNo); 109bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner if (!MiModifier.empty()) 110bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner Result += ", \"" + MiModifier + '"'; 111bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner return Result + "); "; 112b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner} 113b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner 114b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner 115b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner/// ParseAsmString - Parse the specified Instruction's AsmString into this 116b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner/// AsmWriterInst. 117b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner/// 1183837b64f4152bd074013c19b024b94ff52157a65Evan ChengAsmWriterInst::AsmWriterInst(const CodeGenInstruction &CGI, unsigned Variant) { 1195765dba5ce9f493f063a7caf1106e7db9b6693b6Chris Lattner this->CGI = &CGI; 120b03b080a8208b25946bcb96c2a10661b53547ff6Chris Lattner unsigned CurVariant = ~0U; // ~0 if we are outside a {.|.|.} region, other #. 121b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner 1221cf9d961b2fc35c8ba67f20fd36c2b5fb51c9709Chris Lattner // NOTE: Any extensions to this code need to be mirrored in the 1231cf9d961b2fc35c8ba67f20fd36c2b5fb51c9709Chris Lattner // AsmPrinter::printInlineAsm code that executes as compile time (assuming 1241cf9d961b2fc35c8ba67f20fd36c2b5fb51c9709Chris Lattner // that inline asm strings should also get the new feature)! 125b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner const std::string &AsmString = CGI.AsmString; 126b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner std::string::size_type LastEmitted = 0; 127b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner while (LastEmitted != AsmString.size()) { 128b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner std::string::size_type DollarPos = 129817affccd5aa96e3063c0611c319b0da63fb4d07Nate Begeman AsmString.find_first_of("${|}\\", LastEmitted); 130b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner if (DollarPos == std::string::npos) DollarPos = AsmString.size(); 131b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner 132b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner // Emit a constant string fragment. 133b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner if (DollarPos != LastEmitted) { 1347f3b28a7867a35ec56a4ed80546e64995d69483eChris Lattner if (CurVariant == Variant || CurVariant == ~0U) { 1357f3b28a7867a35ec56a4ed80546e64995d69483eChris Lattner for (; LastEmitted != DollarPos; ++LastEmitted) 1367f3b28a7867a35ec56a4ed80546e64995d69483eChris Lattner switch (AsmString[LastEmitted]) { 1377f3b28a7867a35ec56a4ed80546e64995d69483eChris Lattner case '\n': AddLiteralString("\\n"); break; 1387f3b28a7867a35ec56a4ed80546e64995d69483eChris Lattner case '\t': AddLiteralString("\\t"); break; 1397f3b28a7867a35ec56a4ed80546e64995d69483eChris Lattner case '"': AddLiteralString("\\\""); break; 1407f3b28a7867a35ec56a4ed80546e64995d69483eChris Lattner case '\\': AddLiteralString("\\\\"); break; 1417f3b28a7867a35ec56a4ed80546e64995d69483eChris Lattner default: 1427f3b28a7867a35ec56a4ed80546e64995d69483eChris Lattner AddLiteralString(std::string(1, AsmString[LastEmitted])); 1437f3b28a7867a35ec56a4ed80546e64995d69483eChris Lattner break; 1447f3b28a7867a35ec56a4ed80546e64995d69483eChris Lattner } 1457f3b28a7867a35ec56a4ed80546e64995d69483eChris Lattner } else { 1467f3b28a7867a35ec56a4ed80546e64995d69483eChris Lattner LastEmitted = DollarPos; 1477f3b28a7867a35ec56a4ed80546e64995d69483eChris Lattner } 148817affccd5aa96e3063c0611c319b0da63fb4d07Nate Begeman } else if (AsmString[DollarPos] == '\\') { 149817affccd5aa96e3063c0611c319b0da63fb4d07Nate Begeman if (DollarPos+1 != AsmString.size() && 150817affccd5aa96e3063c0611c319b0da63fb4d07Nate Begeman (CurVariant == Variant || CurVariant == ~0U)) { 151817affccd5aa96e3063c0611c319b0da63fb4d07Nate Begeman if (AsmString[DollarPos+1] == 'n') { 152817affccd5aa96e3063c0611c319b0da63fb4d07Nate Begeman AddLiteralString("\\n"); 153817affccd5aa96e3063c0611c319b0da63fb4d07Nate Begeman } else if (AsmString[DollarPos+1] == 't') { 154817affccd5aa96e3063c0611c319b0da63fb4d07Nate Begeman AddLiteralString("\\t"); 155817affccd5aa96e3063c0611c319b0da63fb4d07Nate Begeman } else if (std::string("${|}\\").find(AsmString[DollarPos+1]) 156817affccd5aa96e3063c0611c319b0da63fb4d07Nate Begeman != std::string::npos) { 157817affccd5aa96e3063c0611c319b0da63fb4d07Nate Begeman AddLiteralString(std::string(1, AsmString[DollarPos+1])); 158817affccd5aa96e3063c0611c319b0da63fb4d07Nate Begeman } else { 159817affccd5aa96e3063c0611c319b0da63fb4d07Nate Begeman throw "Non-supported escaped character found in instruction '" + 160817affccd5aa96e3063c0611c319b0da63fb4d07Nate Begeman CGI.TheDef->getName() + "'!"; 161817affccd5aa96e3063c0611c319b0da63fb4d07Nate Begeman } 162817affccd5aa96e3063c0611c319b0da63fb4d07Nate Begeman LastEmitted = DollarPos+2; 163817affccd5aa96e3063c0611c319b0da63fb4d07Nate Begeman continue; 164817affccd5aa96e3063c0611c319b0da63fb4d07Nate Begeman } 165b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner } else if (AsmString[DollarPos] == '{') { 166b03b080a8208b25946bcb96c2a10661b53547ff6Chris Lattner if (CurVariant != ~0U) 16700b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen throw "Nested variants found for instruction '" + 1683e3def9c1955ab061575eb9a99aa4297a4de5299Chris Lattner CGI.TheDef->getName() + "'!"; 169b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner LastEmitted = DollarPos+1; 170b03b080a8208b25946bcb96c2a10661b53547ff6Chris Lattner CurVariant = 0; // We are now inside of the variant! 171b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner } else if (AsmString[DollarPos] == '|') { 172b03b080a8208b25946bcb96c2a10661b53547ff6Chris Lattner if (CurVariant == ~0U) 173b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner throw "'|' character found outside of a variant in instruction '" 1743e3def9c1955ab061575eb9a99aa4297a4de5299Chris Lattner + CGI.TheDef->getName() + "'!"; 175b03b080a8208b25946bcb96c2a10661b53547ff6Chris Lattner ++CurVariant; 176b03b080a8208b25946bcb96c2a10661b53547ff6Chris Lattner ++LastEmitted; 177b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner } else if (AsmString[DollarPos] == '}') { 178b03b080a8208b25946bcb96c2a10661b53547ff6Chris Lattner if (CurVariant == ~0U) 179b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner throw "'}' character found outside of a variant in instruction '" 1803e3def9c1955ab061575eb9a99aa4297a4de5299Chris Lattner + CGI.TheDef->getName() + "'!"; 181b03b080a8208b25946bcb96c2a10661b53547ff6Chris Lattner ++LastEmitted; 182b03b080a8208b25946bcb96c2a10661b53547ff6Chris Lattner CurVariant = ~0U; 183b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner } else if (DollarPos+1 != AsmString.size() && 184b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner AsmString[DollarPos+1] == '$') { 185b03b080a8208b25946bcb96c2a10661b53547ff6Chris Lattner if (CurVariant == Variant || CurVariant == ~0U) 186b03b080a8208b25946bcb96c2a10661b53547ff6Chris Lattner AddLiteralString("$"); // "$$" -> $ 187b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner LastEmitted = DollarPos+2; 188b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner } else { 189b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner // Get the name of the variable. 190b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner std::string::size_type VarEnd = DollarPos+1; 191afc545616a5a062e6872114f9f1c23070e5e753bNate Begeman 192afc545616a5a062e6872114f9f1c23070e5e753bNate Begeman // handle ${foo}bar as $foo by detecting whether the character following 193afc545616a5a062e6872114f9f1c23070e5e753bNate Begeman // the dollar sign is a curly brace. If so, advance VarEnd and DollarPos 194afc545616a5a062e6872114f9f1c23070e5e753bNate Begeman // so the variable name does not contain the leading curly brace. 195afc545616a5a062e6872114f9f1c23070e5e753bNate Begeman bool hasCurlyBraces = false; 196afc545616a5a062e6872114f9f1c23070e5e753bNate Begeman if (VarEnd < AsmString.size() && '{' == AsmString[VarEnd]) { 197afc545616a5a062e6872114f9f1c23070e5e753bNate Begeman hasCurlyBraces = true; 198afc545616a5a062e6872114f9f1c23070e5e753bNate Begeman ++DollarPos; 199afc545616a5a062e6872114f9f1c23070e5e753bNate Begeman ++VarEnd; 200afc545616a5a062e6872114f9f1c23070e5e753bNate Begeman } 201afc545616a5a062e6872114f9f1c23070e5e753bNate Begeman 202b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner while (VarEnd < AsmString.size() && isIdentChar(AsmString[VarEnd])) 203b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner ++VarEnd; 204b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner std::string VarName(AsmString.begin()+DollarPos+1, 205b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner AsmString.begin()+VarEnd); 206afc545616a5a062e6872114f9f1c23070e5e753bNate Begeman 20704cadb3684b14e4aad19f9f29e6c14539866bd56Chris Lattner // Modifier - Support ${foo:modifier} syntax, where "modifier" is passed 2081bf6361dfde21fcc0f433c8cf53d5c366225ee3fChris Lattner // into printOperand. Also support ${:feature}, which is passed into 20916f046a6cee08981084dc4339ceaf76b2e291b4cChris Lattner // PrintSpecial. 21004cadb3684b14e4aad19f9f29e6c14539866bd56Chris Lattner std::string Modifier; 21104cadb3684b14e4aad19f9f29e6c14539866bd56Chris Lattner 212afc545616a5a062e6872114f9f1c23070e5e753bNate Begeman // In order to avoid starting the next string at the terminating curly 213afc545616a5a062e6872114f9f1c23070e5e753bNate Begeman // brace, advance the end position past it if we found an opening curly 214afc545616a5a062e6872114f9f1c23070e5e753bNate Begeman // brace. 215afc545616a5a062e6872114f9f1c23070e5e753bNate Begeman if (hasCurlyBraces) { 216afc545616a5a062e6872114f9f1c23070e5e753bNate Begeman if (VarEnd >= AsmString.size()) 217afc545616a5a062e6872114f9f1c23070e5e753bNate Begeman throw "Reached end of string before terminating curly brace in '" 2183e3def9c1955ab061575eb9a99aa4297a4de5299Chris Lattner + CGI.TheDef->getName() + "'"; 21904cadb3684b14e4aad19f9f29e6c14539866bd56Chris Lattner 22004cadb3684b14e4aad19f9f29e6c14539866bd56Chris Lattner // Look for a modifier string. 22104cadb3684b14e4aad19f9f29e6c14539866bd56Chris Lattner if (AsmString[VarEnd] == ':') { 22204cadb3684b14e4aad19f9f29e6c14539866bd56Chris Lattner ++VarEnd; 22304cadb3684b14e4aad19f9f29e6c14539866bd56Chris Lattner if (VarEnd >= AsmString.size()) 22404cadb3684b14e4aad19f9f29e6c14539866bd56Chris Lattner throw "Reached end of string before terminating curly brace in '" 22504cadb3684b14e4aad19f9f29e6c14539866bd56Chris Lattner + CGI.TheDef->getName() + "'"; 22604cadb3684b14e4aad19f9f29e6c14539866bd56Chris Lattner 22704cadb3684b14e4aad19f9f29e6c14539866bd56Chris Lattner unsigned ModifierStart = VarEnd; 22804cadb3684b14e4aad19f9f29e6c14539866bd56Chris Lattner while (VarEnd < AsmString.size() && isIdentChar(AsmString[VarEnd])) 22904cadb3684b14e4aad19f9f29e6c14539866bd56Chris Lattner ++VarEnd; 23004cadb3684b14e4aad19f9f29e6c14539866bd56Chris Lattner Modifier = std::string(AsmString.begin()+ModifierStart, 23104cadb3684b14e4aad19f9f29e6c14539866bd56Chris Lattner AsmString.begin()+VarEnd); 23204cadb3684b14e4aad19f9f29e6c14539866bd56Chris Lattner if (Modifier.empty()) 23304cadb3684b14e4aad19f9f29e6c14539866bd56Chris Lattner throw "Bad operand modifier name in '"+ CGI.TheDef->getName() + "'"; 23404cadb3684b14e4aad19f9f29e6c14539866bd56Chris Lattner } 23504cadb3684b14e4aad19f9f29e6c14539866bd56Chris Lattner 236afc545616a5a062e6872114f9f1c23070e5e753bNate Begeman if (AsmString[VarEnd] != '}') 237b03b080a8208b25946bcb96c2a10661b53547ff6Chris Lattner throw "Variable name beginning with '{' did not end with '}' in '" 2383e3def9c1955ab061575eb9a99aa4297a4de5299Chris Lattner + CGI.TheDef->getName() + "'"; 239afc545616a5a062e6872114f9f1c23070e5e753bNate Begeman ++VarEnd; 240afc545616a5a062e6872114f9f1c23070e5e753bNate Begeman } 2411bf6361dfde21fcc0f433c8cf53d5c366225ee3fChris Lattner if (VarName.empty() && Modifier.empty()) 24200b16889ab461b7ecef1c91ade101186b7f1fce2Jeff Cohen throw "Stray '$' in '" + CGI.TheDef->getName() + 2433e3def9c1955ab061575eb9a99aa4297a4de5299Chris Lattner "' asm string, maybe you want $$?"; 244b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner 2451bf6361dfde21fcc0f433c8cf53d5c366225ee3fChris Lattner if (VarName.empty()) { 24616f046a6cee08981084dc4339ceaf76b2e291b4cChris Lattner // Just a modifier, pass this into PrintSpecial. 24716f046a6cee08981084dc4339ceaf76b2e291b4cChris Lattner Operands.push_back(AsmWriterOperand("PrintSpecial", ~0U, Modifier)); 2481bf6361dfde21fcc0f433c8cf53d5c366225ee3fChris Lattner } else { 2491bf6361dfde21fcc0f433c8cf53d5c366225ee3fChris Lattner // Otherwise, normal operand. 2501bf6361dfde21fcc0f433c8cf53d5c366225ee3fChris Lattner unsigned OpNo = CGI.getOperandNamed(VarName); 2511bf6361dfde21fcc0f433c8cf53d5c366225ee3fChris Lattner CodeGenInstruction::OperandInfo OpInfo = CGI.OperandList[OpNo]; 2521bf6361dfde21fcc0f433c8cf53d5c366225ee3fChris Lattner 253f64f9a4b75d07819866bfcf918b922a76d3e1600Chris Lattner if (CurVariant == Variant || CurVariant == ~0U) { 254f64f9a4b75d07819866bfcf918b922a76d3e1600Chris Lattner unsigned MIOp = OpInfo.MIOperandNo; 2551bf6361dfde21fcc0f433c8cf53d5c366225ee3fChris Lattner Operands.push_back(AsmWriterOperand(OpInfo.PrinterMethodName, MIOp, 2561bf6361dfde21fcc0f433c8cf53d5c366225ee3fChris Lattner Modifier)); 257f64f9a4b75d07819866bfcf918b922a76d3e1600Chris Lattner } 2581bf6361dfde21fcc0f433c8cf53d5c366225ee3fChris Lattner } 259b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner LastEmitted = VarEnd; 260b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner } 261b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner } 262ba8dc03935fadb05d4d68f9913543df22487f523Evan Cheng 263ba8dc03935fadb05d4d68f9913543df22487f523Evan Cheng AddLiteralString("\\n"); 264b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner} 265b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner 266f876668518097413a904537ce9d249953987508cChris Lattner/// MatchesAllButOneOp - If this instruction is exactly identical to the 267f876668518097413a904537ce9d249953987508cChris Lattner/// specified instruction except for one differing operand, return the differing 268f876668518097413a904537ce9d249953987508cChris Lattner/// operand number. If more than one operand mismatches, return ~1, otherwise 269f876668518097413a904537ce9d249953987508cChris Lattner/// if the instructions are identical return ~0. 270f876668518097413a904537ce9d249953987508cChris Lattnerunsigned AsmWriterInst::MatchesAllButOneOp(const AsmWriterInst &Other)const{ 271f876668518097413a904537ce9d249953987508cChris Lattner if (Operands.size() != Other.Operands.size()) return ~1; 272870c016934bacf43995d89531b166ae095ee3675Chris Lattner 273870c016934bacf43995d89531b166ae095ee3675Chris Lattner unsigned MismatchOperand = ~0U; 274870c016934bacf43995d89531b166ae095ee3675Chris Lattner for (unsigned i = 0, e = Operands.size(); i != e; ++i) { 275ae9f3a3b7c915f725aef5a7250e88eaeddda03c6Anton Korobeynikov if (Operands[i] != Other.Operands[i]) { 276f876668518097413a904537ce9d249953987508cChris Lattner if (MismatchOperand != ~0U) // Already have one mismatch? 277f876668518097413a904537ce9d249953987508cChris Lattner return ~1U; 2783da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman else 279870c016934bacf43995d89531b166ae095ee3675Chris Lattner MismatchOperand = i; 280ae9f3a3b7c915f725aef5a7250e88eaeddda03c6Anton Korobeynikov } 281870c016934bacf43995d89531b166ae095ee3675Chris Lattner } 282870c016934bacf43995d89531b166ae095ee3675Chris Lattner return MismatchOperand; 283870c016934bacf43995d89531b166ae095ee3675Chris Lattner} 284870c016934bacf43995d89531b166ae095ee3675Chris Lattner 28538c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattnerstatic void PrintCases(std::vector<std::pair<std::string, 2861a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar AsmWriterOperand> > &OpsToPrint, raw_ostream &O) { 28738c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner O << " case " << OpsToPrint.back().first << ": "; 28838c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner AsmWriterOperand TheOp = OpsToPrint.back().second; 28938c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner OpsToPrint.pop_back(); 29038c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner 29138c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner // Check to see if any other operands are identical in this list, and if so, 29238c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner // emit a case label for them. 29338c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner for (unsigned i = OpsToPrint.size(); i != 0; --i) 29438c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner if (OpsToPrint[i-1].second == TheOp) { 29538c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner O << "\n case " << OpsToPrint[i-1].first << ": "; 29638c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner OpsToPrint.erase(OpsToPrint.begin()+i-1); 29738c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner } 29838c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner 29938c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner // Finally, emit the code. 300bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner O << TheOp.getCode(); 30138c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner O << "break;\n"; 30238c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner} 30338c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner 304870c016934bacf43995d89531b166ae095ee3675Chris Lattner 305870c016934bacf43995d89531b166ae095ee3675Chris Lattner/// EmitInstructions - Emit the last instruction in the vector and any other 306870c016934bacf43995d89531b166ae095ee3675Chris Lattner/// instructions that are suitably similar to it. 307870c016934bacf43995d89531b166ae095ee3675Chris Lattnerstatic void EmitInstructions(std::vector<AsmWriterInst> &Insts, 3081a55180238dbcf11113f610aea010447e51f595bDaniel Dunbar raw_ostream &O) { 309870c016934bacf43995d89531b166ae095ee3675Chris Lattner AsmWriterInst FirstInst = Insts.back(); 310870c016934bacf43995d89531b166ae095ee3675Chris Lattner Insts.pop_back(); 311870c016934bacf43995d89531b166ae095ee3675Chris Lattner 312870c016934bacf43995d89531b166ae095ee3675Chris Lattner std::vector<AsmWriterInst> SimilarInsts; 313870c016934bacf43995d89531b166ae095ee3675Chris Lattner unsigned DifferingOperand = ~0; 314870c016934bacf43995d89531b166ae095ee3675Chris Lattner for (unsigned i = Insts.size(); i != 0; --i) { 315f876668518097413a904537ce9d249953987508cChris Lattner unsigned DiffOp = Insts[i-1].MatchesAllButOneOp(FirstInst); 316f876668518097413a904537ce9d249953987508cChris Lattner if (DiffOp != ~1U) { 317870c016934bacf43995d89531b166ae095ee3675Chris Lattner if (DifferingOperand == ~0U) // First match! 318870c016934bacf43995d89531b166ae095ee3675Chris Lattner DifferingOperand = DiffOp; 319870c016934bacf43995d89531b166ae095ee3675Chris Lattner 320870c016934bacf43995d89531b166ae095ee3675Chris Lattner // If this differs in the same operand as the rest of the instructions in 321870c016934bacf43995d89531b166ae095ee3675Chris Lattner // this class, move it to the SimilarInsts list. 322f876668518097413a904537ce9d249953987508cChris Lattner if (DifferingOperand == DiffOp || DiffOp == ~0U) { 323870c016934bacf43995d89531b166ae095ee3675Chris Lattner SimilarInsts.push_back(Insts[i-1]); 324870c016934bacf43995d89531b166ae095ee3675Chris Lattner Insts.erase(Insts.begin()+i-1); 325870c016934bacf43995d89531b166ae095ee3675Chris Lattner } 326870c016934bacf43995d89531b166ae095ee3675Chris Lattner } 327870c016934bacf43995d89531b166ae095ee3675Chris Lattner } 328870c016934bacf43995d89531b166ae095ee3675Chris Lattner 329a1e8a80b96d02c8667021049e7fba9050658f39bChris Lattner O << " case " << FirstInst.CGI->Namespace << "::" 330870c016934bacf43995d89531b166ae095ee3675Chris Lattner << FirstInst.CGI->TheDef->getName() << ":\n"; 331870c016934bacf43995d89531b166ae095ee3675Chris Lattner for (unsigned i = 0, e = SimilarInsts.size(); i != e; ++i) 332a1e8a80b96d02c8667021049e7fba9050658f39bChris Lattner O << " case " << SimilarInsts[i].CGI->Namespace << "::" 333870c016934bacf43995d89531b166ae095ee3675Chris Lattner << SimilarInsts[i].CGI->TheDef->getName() << ":\n"; 334870c016934bacf43995d89531b166ae095ee3675Chris Lattner for (unsigned i = 0, e = FirstInst.Operands.size(); i != e; ++i) { 335870c016934bacf43995d89531b166ae095ee3675Chris Lattner if (i != DifferingOperand) { 336870c016934bacf43995d89531b166ae095ee3675Chris Lattner // If the operand is the same for all instructions, just print it. 337bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner O << " " << FirstInst.Operands[i].getCode(); 338870c016934bacf43995d89531b166ae095ee3675Chris Lattner } else { 339870c016934bacf43995d89531b166ae095ee3675Chris Lattner // If this is the operand that varies between all of the instructions, 340870c016934bacf43995d89531b166ae095ee3675Chris Lattner // emit a switch for just this operand now. 341870c016934bacf43995d89531b166ae095ee3675Chris Lattner O << " switch (MI->getOpcode()) {\n"; 34238c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner std::vector<std::pair<std::string, AsmWriterOperand> > OpsToPrint; 343a1e8a80b96d02c8667021049e7fba9050658f39bChris Lattner OpsToPrint.push_back(std::make_pair(FirstInst.CGI->Namespace + "::" + 34438c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner FirstInst.CGI->TheDef->getName(), 34538c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner FirstInst.Operands[i])); 3463da94aec4d429b2ba0f65fa040c33650cade196bMisha Brukman 347870c016934bacf43995d89531b166ae095ee3675Chris Lattner for (unsigned si = 0, e = SimilarInsts.size(); si != e; ++si) { 34838c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner AsmWriterInst &AWI = SimilarInsts[si]; 349a1e8a80b96d02c8667021049e7fba9050658f39bChris Lattner OpsToPrint.push_back(std::make_pair(AWI.CGI->Namespace+"::"+ 35038c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner AWI.CGI->TheDef->getName(), 35138c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner AWI.Operands[i])); 352870c016934bacf43995d89531b166ae095ee3675Chris Lattner } 35338c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner std::reverse(OpsToPrint.begin(), OpsToPrint.end()); 35438c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner while (!OpsToPrint.empty()) 35538c0751a128c0387c04c0f96a2f092340aaa7545Chris Lattner PrintCases(OpsToPrint, O); 356870c016934bacf43995d89531b166ae095ee3675Chris Lattner O << " }"; 357870c016934bacf43995d89531b166ae095ee3675Chris Lattner } 358870c016934bacf43995d89531b166ae095ee3675Chris Lattner O << "\n"; 359870c016934bacf43995d89531b166ae095ee3675Chris Lattner } 360ba8dc03935fadb05d4d68f9913543df22487f523Evan Cheng 361870c016934bacf43995d89531b166ae095ee3675Chris Lattner O << " break;\n"; 362870c016934bacf43995d89531b166ae095ee3675Chris Lattner} 363b0b55e74a090454711b1bb17e4f872d62d6e6b65Chris Lattner 364bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattnervoid AsmWriterEmitter:: 365bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris LattnerFindUniqueOperandCommands(std::vector<std::string> &UniqueOperandCommands, 36696c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner std::vector<unsigned> &InstIdxs, 36796c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner std::vector<unsigned> &InstOpsUsed) const { 368195bb4a7b0de2bb76ae064a5ab8776094d4fccbbChris Lattner InstIdxs.assign(NumberedInstructions.size(), ~0U); 369bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner 370bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner // This vector parallels UniqueOperandCommands, keeping track of which 371bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner // instructions each case are used for. It is a comma separated string of 372bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner // enums. 373bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner std::vector<std::string> InstrsForCase; 374bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner InstrsForCase.resize(UniqueOperandCommands.size()); 37596c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner InstOpsUsed.assign(UniqueOperandCommands.size(), 0); 376bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner 377bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner for (unsigned i = 0, e = NumberedInstructions.size(); i != e; ++i) { 378bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner const AsmWriterInst *Inst = getAsmWriterInstByID(i); 3794406604047423576e36657c7ede266ca42e79642Dan Gohman if (Inst == 0) continue; // PHI, INLINEASM, DBG_LABEL, etc. 380bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner 381bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner std::string Command; 382b84628679ad7240a63d267fc6388efbc1e91f588Chris Lattner if (Inst->Operands.empty()) 383bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner continue; // Instruction already done. 384191dd1f1860661f2e0bb99432d10da9b2aff1fc7Chris Lattner 385b84628679ad7240a63d267fc6388efbc1e91f588Chris Lattner Command = " " + Inst->Operands[0].getCode() + "\n"; 386191dd1f1860661f2e0bb99432d10da9b2aff1fc7Chris Lattner 387191dd1f1860661f2e0bb99432d10da9b2aff1fc7Chris Lattner // If this is the last operand, emit a return. 388ba8dc03935fadb05d4d68f9913543df22487f523Evan Cheng if (Inst->Operands.size() == 1) 389191dd1f1860661f2e0bb99432d10da9b2aff1fc7Chris Lattner Command += " return true;\n"; 390bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner 391bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner // Check to see if we already have 'Command' in UniqueOperandCommands. 392bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner // If not, add it. 393bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner bool FoundIt = false; 394bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner for (unsigned idx = 0, e = UniqueOperandCommands.size(); idx != e; ++idx) 395bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner if (UniqueOperandCommands[idx] == Command) { 396bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner InstIdxs[i] = idx; 397bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner InstrsForCase[idx] += ", "; 398bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner InstrsForCase[idx] += Inst->CGI->TheDef->getName(); 399bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner FoundIt = true; 400bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner break; 401bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner } 402bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner if (!FoundIt) { 403bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner InstIdxs[i] = UniqueOperandCommands.size(); 404bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner UniqueOperandCommands.push_back(Command); 405bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner InstrsForCase.push_back(Inst->CGI->TheDef->getName()); 40696c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner 40796c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner // This command matches one operand so far. 40896c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner InstOpsUsed.push_back(1); 40996c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner } 41096c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner } 41196c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner 41296c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner // For each entry of UniqueOperandCommands, there is a set of instructions 41396c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner // that uses it. If the next command of all instructions in the set are 41496c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner // identical, fold it into the command. 41596c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner for (unsigned CommandIdx = 0, e = UniqueOperandCommands.size(); 41696c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner CommandIdx != e; ++CommandIdx) { 41796c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner 41896c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner for (unsigned Op = 1; ; ++Op) { 41996c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner // Scan for the first instruction in the set. 42096c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner std::vector<unsigned>::iterator NIT = 42196c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner std::find(InstIdxs.begin(), InstIdxs.end(), CommandIdx); 42296c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner if (NIT == InstIdxs.end()) break; // No commonality. 42396c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner 42496c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner // If this instruction has no more operands, we isn't anything to merge 42596c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner // into this command. 42696c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner const AsmWriterInst *FirstInst = 42796c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner getAsmWriterInstByID(NIT-InstIdxs.begin()); 42896c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner if (!FirstInst || FirstInst->Operands.size() == Op) 42996c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner break; 43096c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner 43196c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner // Otherwise, scan to see if all of the other instructions in this command 43296c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner // set share the operand. 43396c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner bool AllSame = true; 43496c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner 43596c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner for (NIT = std::find(NIT+1, InstIdxs.end(), CommandIdx); 43696c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner NIT != InstIdxs.end(); 43796c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner NIT = std::find(NIT+1, InstIdxs.end(), CommandIdx)) { 43896c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner // Okay, found another instruction in this command set. If the operand 43996c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner // matches, we're ok, otherwise bail out. 44096c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner const AsmWriterInst *OtherInst = 44196c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner getAsmWriterInstByID(NIT-InstIdxs.begin()); 44296c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner if (!OtherInst || OtherInst->Operands.size() == Op || 44396c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner OtherInst->Operands[Op] != FirstInst->Operands[Op]) { 44496c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner AllSame = false; 44596c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner break; 44696c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner } 44796c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner } 44896c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner if (!AllSame) break; 44996c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner 45096c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner // Okay, everything in this command set has the same next operand. Add it 45196c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner // to UniqueOperandCommands and remember that it was consumed. 45296c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner std::string Command = " " + FirstInst->Operands[Op].getCode() + "\n"; 45396c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner 45496c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner // If this is the last operand, emit a return after the code. 455ba8dc03935fadb05d4d68f9913543df22487f523Evan Cheng if (FirstInst->Operands.size() == Op+1) 45696c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner Command += " return true;\n"; 45796c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner 45896c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner UniqueOperandCommands[CommandIdx] += Command; 45996c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner InstOpsUsed[CommandIdx]++; 460bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner } 461bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner } 462bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner 463bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner // Prepend some of the instructions each case is used for onto the case val. 464bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner for (unsigned i = 0, e = InstrsForCase.size(); i != e; ++i) { 465bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner std::string Instrs = InstrsForCase[i]; 466bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner if (Instrs.size() > 70) { 467bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner Instrs.erase(Instrs.begin()+70, Instrs.end()); 468bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner Instrs += "..."; 469bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner } 470bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner 471bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner if (!Instrs.empty()) 472bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner UniqueOperandCommands[i] = " // " + Instrs + "\n" + 473bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner UniqueOperandCommands[i]; 474bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner } 475bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner} 476bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner 477bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner 478bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner 4791a55180238dbcf11113f610aea010447e51f595bDaniel Dunbarvoid AsmWriterEmitter::run(raw_ostream &O) { 4802e1f51b8a583649d74cb666ca5e4cf680cc1ced9Chris Lattner EmitSourceFileHeader("Assembly Writer Source Fragment", O); 4812e1f51b8a583649d74cb666ca5e4cf680cc1ced9Chris Lattner 4822e1f51b8a583649d74cb666ca5e4cf680cc1ced9Chris Lattner CodeGenTarget Target; 483175580c0f36b026daf9de0adabdb7ddcf7619db6Chris Lattner Record *AsmWriter = Target.getAsmWriter(); 484953c6fe11277c2511744440f5d8d90aca1354e18Chris Lattner std::string ClassName = AsmWriter->getValueAsString("AsmWriterClassName"); 485953c6fe11277c2511744440f5d8d90aca1354e18Chris Lattner unsigned Variant = AsmWriter->getValueAsInt("Variant"); 486175580c0f36b026daf9de0adabdb7ddcf7619db6Chris Lattner 4872e1f51b8a583649d74cb666ca5e4cf680cc1ced9Chris Lattner O << 4882e1f51b8a583649d74cb666ca5e4cf680cc1ced9Chris Lattner "/// printInstruction - This method is automatically generated by tablegen\n" 4892e1f51b8a583649d74cb666ca5e4cf680cc1ced9Chris Lattner "/// from the instruction set description. This method returns true if the\n" 4902e1f51b8a583649d74cb666ca5e4cf680cc1ced9Chris Lattner "/// machine instruction was sufficiently described to print it, otherwise\n" 4912e1f51b8a583649d74cb666ca5e4cf680cc1ced9Chris Lattner "/// it returns false.\n" 492953c6fe11277c2511744440f5d8d90aca1354e18Chris Lattner "bool " << Target.getName() << ClassName 493175580c0f36b026daf9de0adabdb7ddcf7619db6Chris Lattner << "::printInstruction(const MachineInstr *MI) {\n"; 4942e1f51b8a583649d74cb666ca5e4cf680cc1ced9Chris Lattner 4955765dba5ce9f493f063a7caf1106e7db9b6693b6Chris Lattner std::vector<AsmWriterInst> Instructions; 4965765dba5ce9f493f063a7caf1106e7db9b6693b6Chris Lattner 4972e1f51b8a583649d74cb666ca5e4cf680cc1ced9Chris Lattner for (CodeGenTarget::inst_iterator I = Target.inst_begin(), 4982e1f51b8a583649d74cb666ca5e4cf680cc1ced9Chris Lattner E = Target.inst_end(); I != E; ++I) 4995765dba5ce9f493f063a7caf1106e7db9b6693b6Chris Lattner if (!I->second.AsmString.empty()) 5005765dba5ce9f493f063a7caf1106e7db9b6693b6Chris Lattner Instructions.push_back(AsmWriterInst(I->second, Variant)); 5015765dba5ce9f493f063a7caf1106e7db9b6693b6Chris Lattner 502bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner // Get the instruction numbering. 5030cfcc1e8072af7f3d92bbcdba48da551cccd90beChris Lattner Target.getInstructionsByEnumValue(NumberedInstructions); 5040cfcc1e8072af7f3d92bbcdba48da551cccd90beChris Lattner 5056af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner // Compute the CodeGenInstruction -> AsmWriterInst mapping. Note that not 5066af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner // all machine instructions are necessarily being printed, so there may be 5076af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner // target instructions not in this map. 5086af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner for (unsigned i = 0, e = Instructions.size(); i != e; ++i) 5096af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner CGIAWIMap.insert(std::make_pair(Instructions[i].CGI, &Instructions[i])); 5106af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner 5116af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner // Build an aggregate string, and build a table of offsets into it. 5126af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner std::map<std::string, unsigned> StringOffset; 5136af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner std::string AggregateString; 514259bda48e2c6b886f707513781f1b76595d4ad0dChris Lattner AggregateString.push_back(0); // "\0" 515259bda48e2c6b886f707513781f1b76595d4ad0dChris Lattner AggregateString.push_back(0); // "\0" 5166af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner 517259bda48e2c6b886f707513781f1b76595d4ad0dChris Lattner /// OpcodeInfo - This encodes the index of the string to use for the first 5185561640043666174a1e4d828107702a8992e59f6Chris Lattner /// chunk of the output as well as indices used for operand printing. 5195561640043666174a1e4d828107702a8992e59f6Chris Lattner std::vector<unsigned> OpcodeInfo; 520bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner 5215561640043666174a1e4d828107702a8992e59f6Chris Lattner unsigned MaxStringIdx = 0; 5226af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner for (unsigned i = 0, e = NumberedInstructions.size(); i != e; ++i) { 5236af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner AsmWriterInst *AWI = CGIAWIMap[NumberedInstructions[i]]; 5246af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner unsigned Idx; 525a6dc9fb745962564fac3b18da28736b2e094c417Chris Lattner if (AWI == 0) { 5266af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner // Something not handled by the asmwriter printer. 5276af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner Idx = 0; 528a6dc9fb745962564fac3b18da28736b2e094c417Chris Lattner } else if (AWI->Operands[0].OperandType != 529a6dc9fb745962564fac3b18da28736b2e094c417Chris Lattner AsmWriterOperand::isLiteralTextOperand || 530a6dc9fb745962564fac3b18da28736b2e094c417Chris Lattner AWI->Operands[0].Str.empty()) { 531a6dc9fb745962564fac3b18da28736b2e094c417Chris Lattner // Something handled by the asmwriter printer, but with no leading string. 532a6dc9fb745962564fac3b18da28736b2e094c417Chris Lattner Idx = 1; 5336af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner } else { 5346af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner unsigned &Entry = StringOffset[AWI->Operands[0].Str]; 5356af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner if (Entry == 0) { 5366af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner // Add the string to the aggregate if this is the first time found. 5375561640043666174a1e4d828107702a8992e59f6Chris Lattner MaxStringIdx = Entry = AggregateString.size(); 5386af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner std::string Str = AWI->Operands[0].Str; 5396af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner UnescapeString(Str); 5406af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner AggregateString += Str; 5416af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner AggregateString += '\0'; 5426af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner } 5436af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner Idx = Entry; 5446af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner 5456af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner // Nuke the string from the operand list. It is now handled! 5466af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner AWI->Operands.erase(AWI->Operands.begin()); 5476af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner } 5485561640043666174a1e4d828107702a8992e59f6Chris Lattner OpcodeInfo.push_back(Idx); 549bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner } 550bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner 5515561640043666174a1e4d828107702a8992e59f6Chris Lattner // Figure out how many bits we used for the string index. 55259d28132bcd68f882c526b043380c359ffc465e6Nate Begeman unsigned AsmStrBits = Log2_32_Ceil(MaxStringIdx+1); 5535561640043666174a1e4d828107702a8992e59f6Chris Lattner 554bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner // To reduce code size, we compactify common instructions into a few bits 555bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner // in the opcode-indexed table. 556b51ecd4dd93b8eccf2cba3d541cff0f7cdbf7e1cChris Lattner unsigned BitsLeft = 32-AsmStrBits; 557bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner 558bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner std::vector<std::vector<std::string> > TableDrivenOperandPrinters; 559bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner 560b84628679ad7240a63d267fc6388efbc1e91f588Chris Lattner bool isFirst = true; 561b84628679ad7240a63d267fc6388efbc1e91f588Chris Lattner while (1) { 562bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner std::vector<std::string> UniqueOperandCommands; 563bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner 564a6dc9fb745962564fac3b18da28736b2e094c417Chris Lattner // For the first operand check, add a default value for instructions with 565a6dc9fb745962564fac3b18da28736b2e094c417Chris Lattner // just opcode strings to use. 566b84628679ad7240a63d267fc6388efbc1e91f588Chris Lattner if (isFirst) { 567ba8dc03935fadb05d4d68f9913543df22487f523Evan Cheng UniqueOperandCommands.push_back(" return true;\n"); 568b84628679ad7240a63d267fc6388efbc1e91f588Chris Lattner isFirst = false; 569b84628679ad7240a63d267fc6388efbc1e91f588Chris Lattner } 570ba8dc03935fadb05d4d68f9913543df22487f523Evan Cheng 571bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner std::vector<unsigned> InstIdxs; 57296c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner std::vector<unsigned> NumInstOpsHandled; 57396c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner FindUniqueOperandCommands(UniqueOperandCommands, InstIdxs, 57496c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner NumInstOpsHandled); 575bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner 576bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner // If we ran out of operands to print, we're done. 577bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner if (UniqueOperandCommands.empty()) break; 578bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner 579bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner // Compute the number of bits we need to represent these cases, this is 580bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner // ceil(log2(numentries)). 581bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner unsigned NumBits = Log2_32_Ceil(UniqueOperandCommands.size()); 582bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner 583bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner // If we don't have enough bits for this operand, don't include it. 584bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner if (NumBits > BitsLeft) { 585f5da13367f88f06e3b585dc2263ab6e9ca6c4bf8Bill Wendling DOUT << "Not enough bits to densely encode " << NumBits 586f5da13367f88f06e3b585dc2263ab6e9ca6c4bf8Bill Wendling << " more bits\n"; 587bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner break; 588bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner } 589bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner 590bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner // Otherwise, we can include this in the initial lookup table. Add it in. 591bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner BitsLeft -= NumBits; 592bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner for (unsigned i = 0, e = InstIdxs.size(); i != e; ++i) 593195bb4a7b0de2bb76ae064a5ab8776094d4fccbbChris Lattner if (InstIdxs[i] != ~0U) 594195bb4a7b0de2bb76ae064a5ab8776094d4fccbbChris Lattner OpcodeInfo[i] |= InstIdxs[i] << (BitsLeft+AsmStrBits); 595bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner 596b84628679ad7240a63d267fc6388efbc1e91f588Chris Lattner // Remove the info about this operand. 597b84628679ad7240a63d267fc6388efbc1e91f588Chris Lattner for (unsigned i = 0, e = NumberedInstructions.size(); i != e; ++i) { 598b84628679ad7240a63d267fc6388efbc1e91f588Chris Lattner if (AsmWriterInst *Inst = getAsmWriterInstByID(i)) 59996c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner if (!Inst->Operands.empty()) { 60096c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner unsigned NumOps = NumInstOpsHandled[InstIdxs[i]]; 6010a012128574c93d5b85adffd14eb4b07883fba4cChris Lattner assert(NumOps <= Inst->Operands.size() && 6020a012128574c93d5b85adffd14eb4b07883fba4cChris Lattner "Can't remove this many ops!"); 60396c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner Inst->Operands.erase(Inst->Operands.begin(), 60496c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner Inst->Operands.begin()+NumOps); 60596c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner } 606b84628679ad7240a63d267fc6388efbc1e91f588Chris Lattner } 607b84628679ad7240a63d267fc6388efbc1e91f588Chris Lattner 608b84628679ad7240a63d267fc6388efbc1e91f588Chris Lattner // Remember the handlers for this set of operands. 609bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner TableDrivenOperandPrinters.push_back(UniqueOperandCommands); 610bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner } 611bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner 612bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner 613bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner 6145561640043666174a1e4d828107702a8992e59f6Chris Lattner O<<" static const unsigned OpInfo[] = {\n"; 615bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner for (unsigned i = 0, e = NumberedInstructions.size(); i != e; ++i) { 616b51ecd4dd93b8eccf2cba3d541cff0f7cdbf7e1cChris Lattner O << " " << OpcodeInfo[i] << "U,\t// " 6175561640043666174a1e4d828107702a8992e59f6Chris Lattner << NumberedInstructions[i]->TheDef->getName() << "\n"; 6186af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner } 619bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner // Add a dummy entry so the array init doesn't end with a comma. 6205561640043666174a1e4d828107702a8992e59f6Chris Lattner O << " 0U\n"; 6216af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner O << " };\n\n"; 6226af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner 6236af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner // Emit the string itself. 6246af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner O << " const char *AsmStrs = \n \""; 6256af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner unsigned CharsPrinted = 0; 6266af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner EscapeString(AggregateString); 6276af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner for (unsigned i = 0, e = AggregateString.size(); i != e; ++i) { 6286af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner if (CharsPrinted > 70) { 6296af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner O << "\"\n \""; 6306af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner CharsPrinted = 0; 6316af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner } 6326af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner O << AggregateString[i]; 6336af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner ++CharsPrinted; 6346af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner 6356af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner // Print escape sequences all together. 6366af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner if (AggregateString[i] == '\\') { 6376af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner assert(i+1 < AggregateString.size() && "Incomplete escape sequence!"); 6386af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner if (isdigit(AggregateString[i+1])) { 6396af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner assert(isdigit(AggregateString[i+2]) && isdigit(AggregateString[i+3]) && 6406af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner "Expected 3 digit octal escape!"); 6416af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner O << AggregateString[++i]; 6426af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner O << AggregateString[++i]; 6436af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner O << AggregateString[++i]; 6446af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner CharsPrinted += 3; 645f876668518097413a904537ce9d249953987508cChris Lattner } else { 6466af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner O << AggregateString[++i]; 6476af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner ++CharsPrinted; 648f876668518097413a904537ce9d249953987508cChris Lattner } 649f876668518097413a904537ce9d249953987508cChris Lattner } 650f876668518097413a904537ce9d249953987508cChris Lattner } 6516af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner O << "\";\n\n"; 6526af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner 653cd76240f3d0f6c5f8c80e4762a8fe3a4de22e059Argyrios Kyrtzidis O << " processDebugLoc(MI->getDebugLoc());\n\n"; 654cb819f13d785ff6efcacfbd7d0fa9f3f67e5494dBill Wendling 6555b842c369097b22e0abca58bfc49e63919b28a58Chris Lattner O << "\n#ifndef NO_ASM_WRITER_BOILERPLATE\n"; 6565b842c369097b22e0abca58bfc49e63919b28a58Chris Lattner 657bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner O << " if (MI->getOpcode() == TargetInstrInfo::INLINEASM) {\n" 6584eecdeb3faf5df864790175da5d58301b751ec11Evan Cheng << " O << \"\\t\";\n" 659bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner << " printInlineAsm(MI);\n" 660bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner << " return true;\n" 6614406604047423576e36657c7ede266ca42e79642Dan Gohman << " } else if (MI->isLabel()) {\n" 662a683f9ba1356e92a5e7243d9f80fe8a8b6f737c8Jim Laskey << " printLabel(MI);\n" 663a683f9ba1356e92a5e7243d9f80fe8a8b6f737c8Jim Laskey << " return true;\n" 664a844bdeab31ef04221e7ef59a8467893584cc14dEvan Cheng << " } else if (MI->getOpcode() == TargetInstrInfo::DECLARE) {\n" 665a844bdeab31ef04221e7ef59a8467893584cc14dEvan Cheng << " printDeclare(MI);\n" 666a844bdeab31ef04221e7ef59a8467893584cc14dEvan Cheng << " return true;\n" 667da47e6e0d003c873da960361549e57ee4617c301Evan Cheng << " } else if (MI->getOpcode() == TargetInstrInfo::IMPLICIT_DEF) {\n" 668da47e6e0d003c873da960361549e57ee4617c301Evan Cheng << " printImplicitDef(MI);\n" 669da47e6e0d003c873da960361549e57ee4617c301Evan Cheng << " return true;\n" 670bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner << " }\n\n"; 6715b842c369097b22e0abca58bfc49e63919b28a58Chris Lattner 6725b842c369097b22e0abca58bfc49e63919b28a58Chris Lattner O << "\n#endif\n"; 6735b842c369097b22e0abca58bfc49e63919b28a58Chris Lattner 6744eecdeb3faf5df864790175da5d58301b751ec11Evan Cheng O << " O << \"\\t\";\n\n"; 6754eecdeb3faf5df864790175da5d58301b751ec11Evan Cheng 6766af022f255257bee7c6d6903ff4caa2217d51502Chris Lattner O << " // Emit the opcode for the instruction.\n" 6775561640043666174a1e4d828107702a8992e59f6Chris Lattner << " unsigned Bits = OpInfo[MI->getOpcode()];\n" 6783837b64f4152bd074013c19b024b94ff52157a65Evan Cheng << " if (Bits == 0) return false;\n" 6793837b64f4152bd074013c19b024b94ff52157a65Evan Cheng << " O << AsmStrs+(Bits & " << (1 << AsmStrBits)-1 << ");\n\n"; 680bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner 681bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner // Output the table driven operand information. 682b51ecd4dd93b8eccf2cba3d541cff0f7cdbf7e1cChris Lattner BitsLeft = 32-AsmStrBits; 683bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner for (unsigned i = 0, e = TableDrivenOperandPrinters.size(); i != e; ++i) { 684bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner std::vector<std::string> &Commands = TableDrivenOperandPrinters[i]; 685f876668518097413a904537ce9d249953987508cChris Lattner 686bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner // Compute the number of bits we need to represent these cases, this is 687bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner // ceil(log2(numentries)). 688bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner unsigned NumBits = Log2_32_Ceil(Commands.size()); 689bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner assert(NumBits <= BitsLeft && "consistency error"); 690bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner 691bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner // Emit code to extract this field from Bits. 692bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner BitsLeft -= NumBits; 693bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner 694bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner O << "\n // Fragment " << i << " encoded into " << NumBits 695e7a589df09ed4d1f0853fb586609b00357a34ac2Chris Lattner << " bits for " << Commands.size() << " unique commands.\n"; 696bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner 69796c1ade5c3927cb0e835af721cbf37f9605cc678Chris Lattner if (Commands.size() == 2) { 698e7a589df09ed4d1f0853fb586609b00357a34ac2Chris Lattner // Emit two possibilitys with if/else. 699e7a589df09ed4d1f0853fb586609b00357a34ac2Chris Lattner O << " if ((Bits >> " << (BitsLeft+AsmStrBits) << ") & " 700e7a589df09ed4d1f0853fb586609b00357a34ac2Chris Lattner << ((1 << NumBits)-1) << ") {\n" 701e7a589df09ed4d1f0853fb586609b00357a34ac2Chris Lattner << Commands[1] 702e7a589df09ed4d1f0853fb586609b00357a34ac2Chris Lattner << " } else {\n" 703e7a589df09ed4d1f0853fb586609b00357a34ac2Chris Lattner << Commands[0] 704e7a589df09ed4d1f0853fb586609b00357a34ac2Chris Lattner << " }\n\n"; 705e7a589df09ed4d1f0853fb586609b00357a34ac2Chris Lattner } else { 706e7a589df09ed4d1f0853fb586609b00357a34ac2Chris Lattner O << " switch ((Bits >> " << (BitsLeft+AsmStrBits) << ") & " 707e7a589df09ed4d1f0853fb586609b00357a34ac2Chris Lattner << ((1 << NumBits)-1) << ") {\n" 708e7a589df09ed4d1f0853fb586609b00357a34ac2Chris Lattner << " default: // unreachable.\n"; 709e7a589df09ed4d1f0853fb586609b00357a34ac2Chris Lattner 710e7a589df09ed4d1f0853fb586609b00357a34ac2Chris Lattner // Print out all the cases. 711e7a589df09ed4d1f0853fb586609b00357a34ac2Chris Lattner for (unsigned i = 0, e = Commands.size(); i != e; ++i) { 712e7a589df09ed4d1f0853fb586609b00357a34ac2Chris Lattner O << " case " << i << ":\n"; 713e7a589df09ed4d1f0853fb586609b00357a34ac2Chris Lattner O << Commands[i]; 714e7a589df09ed4d1f0853fb586609b00357a34ac2Chris Lattner O << " break;\n"; 715e7a589df09ed4d1f0853fb586609b00357a34ac2Chris Lattner } 716e7a589df09ed4d1f0853fb586609b00357a34ac2Chris Lattner O << " }\n\n"; 717bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner } 718bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner } 719bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner 720b84628679ad7240a63d267fc6388efbc1e91f588Chris Lattner // Okay, delete instructions with no operand info left. 721bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner for (unsigned i = 0, e = Instructions.size(); i != e; ++i) { 722bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner // Entire instruction has been emitted? 723bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner AsmWriterInst &Inst = Instructions[i]; 724b84628679ad7240a63d267fc6388efbc1e91f588Chris Lattner if (Inst.Operands.empty()) { 725bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner Instructions.erase(Instructions.begin()+i); 726b84628679ad7240a63d267fc6388efbc1e91f588Chris Lattner --i; --e; 727bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner } 728bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner } 729bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner 730bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner 731bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner // Because this is a vector, we want to emit from the end. Reverse all of the 732870c016934bacf43995d89531b166ae095ee3675Chris Lattner // elements in the vector. 733870c016934bacf43995d89531b166ae095ee3675Chris Lattner std::reverse(Instructions.begin(), Instructions.end()); 734bdff5f95b9cda9a6d24104201fa53204bd0c5a75Chris Lattner 735b51ecd4dd93b8eccf2cba3d541cff0f7cdbf7e1cChris Lattner if (!Instructions.empty()) { 736b51ecd4dd93b8eccf2cba3d541cff0f7cdbf7e1cChris Lattner // Find the opcode # of inline asm. 737b51ecd4dd93b8eccf2cba3d541cff0f7cdbf7e1cChris Lattner O << " switch (MI->getOpcode()) {\n"; 738b51ecd4dd93b8eccf2cba3d541cff0f7cdbf7e1cChris Lattner while (!Instructions.empty()) 739b51ecd4dd93b8eccf2cba3d541cff0f7cdbf7e1cChris Lattner EmitInstructions(Instructions, O); 740870c016934bacf43995d89531b166ae095ee3675Chris Lattner 741b51ecd4dd93b8eccf2cba3d541cff0f7cdbf7e1cChris Lattner O << " }\n"; 7423837b64f4152bd074013c19b024b94ff52157a65Evan Cheng O << " return true;\n"; 743b51ecd4dd93b8eccf2cba3d541cff0f7cdbf7e1cChris Lattner } 744b51ecd4dd93b8eccf2cba3d541cff0f7cdbf7e1cChris Lattner 7450a012128574c93d5b85adffd14eb4b07883fba4cChris Lattner O << "}\n"; 7462e1f51b8a583649d74cb666ca5e4cf680cc1ced9Chris Lattner} 747