2004-08-01 13:59:33 +08:00
|
|
|
//===- AsmWriterEmitter.cpp - Generate an assembly writer -----------------===//
|
2005-04-22 08:00:37 +08:00
|
|
|
//
|
2004-08-01 13:59:33 +08:00
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-30 04:37:13 +08:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2005-04-22 08:00:37 +08:00
|
|
|
//
|
2004-08-01 13:59:33 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This tablegen backend is emits an assembly printer for the current target.
|
|
|
|
// Note that this is currently fairly skeletal, but will grow over time.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "AsmWriterEmitter.h"
|
|
|
|
#include "CodeGenTarget.h"
|
2004-08-15 06:50:53 +08:00
|
|
|
#include "Record.h"
|
2006-07-15 06:59:11 +08:00
|
|
|
#include "llvm/ADT/StringExtras.h"
|
2006-07-19 01:18:03 +08:00
|
|
|
#include "llvm/Support/Debug.h"
|
|
|
|
#include "llvm/Support/MathExtras.h"
|
2005-01-23 02:50:10 +08:00
|
|
|
#include <algorithm>
|
2009-07-30 04:10:24 +08:00
|
|
|
#include <sstream>
|
2009-07-03 08:10:29 +08:00
|
|
|
#include <iostream>
|
2004-08-01 13:59:33 +08:00
|
|
|
using namespace llvm;
|
|
|
|
|
2004-08-01 15:43:02 +08:00
|
|
|
static bool isIdentChar(char C) {
|
|
|
|
return (C >= 'a' && C <= 'z') ||
|
|
|
|
(C >= 'A' && C <= 'Z') ||
|
|
|
|
(C >= '0' && C <= '9') ||
|
|
|
|
C == '_';
|
|
|
|
}
|
|
|
|
|
2007-07-18 12:51:57 +08:00
|
|
|
// This should be an anon namespace, this works around a GCC warning.
|
|
|
|
namespace llvm {
|
2005-01-23 01:32:42 +08:00
|
|
|
struct AsmWriterOperand {
|
2009-07-30 04:10:24 +08:00
|
|
|
enum OpType {
|
2009-08-01 05:57:10 +08:00
|
|
|
// Output this text surrounded by quotes to the asm.
|
2009-07-30 04:10:24 +08:00
|
|
|
isLiteralTextOperand,
|
2009-08-01 05:57:10 +08:00
|
|
|
// This is the name of a routine to call to print the operand.
|
2009-07-30 04:10:24 +08:00
|
|
|
isMachineInstrOperand,
|
2009-08-01 05:57:10 +08:00
|
|
|
// Output this text verbatim to the asm writer. It is code that
|
|
|
|
// will output some text to the asm.
|
2009-07-30 04:10:24 +08:00
|
|
|
isLiteralStatementOperand
|
|
|
|
} OperandType;
|
2005-01-23 01:32:42 +08:00
|
|
|
|
|
|
|
/// Str - For isLiteralTextOperand, this IS the literal text. For
|
2009-08-01 05:57:10 +08:00
|
|
|
/// isMachineInstrOperand, this is the PrinterMethodName for the operand..
|
|
|
|
/// For isLiteralStatementOperand, this is the code to insert verbatim
|
|
|
|
/// into the asm writer.
|
2005-01-23 01:32:42 +08:00
|
|
|
std::string Str;
|
|
|
|
|
|
|
|
/// MiOpNo - For isMachineInstrOperand, this is the operand number of the
|
|
|
|
/// machine instruction.
|
|
|
|
unsigned MIOpNo;
|
2006-02-07 07:40:48 +08:00
|
|
|
|
|
|
|
/// MiModifier - For isMachineInstrOperand, this is the modifier string for
|
|
|
|
/// an operand, specified with syntax like ${opname:modifier}.
|
|
|
|
std::string MiModifier;
|
2005-01-23 01:32:42 +08:00
|
|
|
|
2008-10-28 03:21:35 +08:00
|
|
|
// To make VS STL happy
|
2009-07-30 04:10:24 +08:00
|
|
|
AsmWriterOperand(OpType op = isLiteralTextOperand):OperandType(op) {}
|
2008-10-26 23:40:44 +08:00
|
|
|
|
2009-07-30 04:10:24 +08:00
|
|
|
AsmWriterOperand(const std::string &LitStr,
|
|
|
|
OpType op = isLiteralTextOperand)
|
|
|
|
: OperandType(op), Str(LitStr) {}
|
2005-01-23 01:32:42 +08:00
|
|
|
|
2006-02-07 07:40:48 +08:00
|
|
|
AsmWriterOperand(const std::string &Printer, unsigned OpNo,
|
2009-07-30 04:10:24 +08:00
|
|
|
const std::string &Modifier,
|
|
|
|
OpType op = isMachineInstrOperand)
|
|
|
|
: OperandType(op), Str(Printer), MIOpNo(OpNo),
|
2006-02-07 07:40:48 +08:00
|
|
|
MiModifier(Modifier) {}
|
2005-01-23 01:32:42 +08:00
|
|
|
|
Implement factoring of instruction pattern strings. In particular, instead of
emitting code like this:
case PPC::ADD: O << "add "; printOperand(MI, 0, MVT::i64); O << ", "; prin
tOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '\n
'; break;
case PPC::ADDC: O << "addc "; printOperand(MI, 0, MVT::i64); O << ", "; pr
intOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '
\n'; break;
case PPC::ADDE: O << "adde "; printOperand(MI, 0, MVT::i64); O << ", "; pr
intOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '
\n'; break;
...
Emit code like this:
case PPC::ADD:
case PPC::ADDC:
case PPC::ADDE:
...
switch (MI->getOpcode()) {
case PPC::ADD: O << "add "; break;
case PPC::ADDC: O << "addc "; break;
case PPC::ADDE: O << "adde "; break;
...
}
printOperand(MI, 0, MVT::i64);
O << ", ";
printOperand(MI, 1, MVT::i64);
O << ", ";
printOperand(MI, 2, MVT::i64);
O << "\n";
break;
This shrinks the PPC asm writer from 24785->15205 bytes (even though the new
asmwriter has much more whitespace than the old one), and the X86 printers shrink
quite a bit too. The important implication of this is that GCC no longer hits swap
when building the PPC backend in optimized mode. Thus this fixes PR448.
-Chris
llvm-svn: 19755
2005-01-23 02:38:13 +08:00
|
|
|
bool operator!=(const AsmWriterOperand &Other) const {
|
|
|
|
if (OperandType != Other.OperandType || Str != Other.Str) return true;
|
|
|
|
if (OperandType == isMachineInstrOperand)
|
2006-02-07 07:40:48 +08:00
|
|
|
return MIOpNo != Other.MIOpNo || MiModifier != Other.MiModifier;
|
Implement factoring of instruction pattern strings. In particular, instead of
emitting code like this:
case PPC::ADD: O << "add "; printOperand(MI, 0, MVT::i64); O << ", "; prin
tOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '\n
'; break;
case PPC::ADDC: O << "addc "; printOperand(MI, 0, MVT::i64); O << ", "; pr
intOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '
\n'; break;
case PPC::ADDE: O << "adde "; printOperand(MI, 0, MVT::i64); O << ", "; pr
intOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '
\n'; break;
...
Emit code like this:
case PPC::ADD:
case PPC::ADDC:
case PPC::ADDE:
...
switch (MI->getOpcode()) {
case PPC::ADD: O << "add "; break;
case PPC::ADDC: O << "addc "; break;
case PPC::ADDE: O << "adde "; break;
...
}
printOperand(MI, 0, MVT::i64);
O << ", ";
printOperand(MI, 1, MVT::i64);
O << ", ";
printOperand(MI, 2, MVT::i64);
O << "\n";
break;
This shrinks the PPC asm writer from 24785->15205 bytes (even though the new
asmwriter has much more whitespace than the old one), and the X86 printers shrink
quite a bit too. The important implication of this is that GCC no longer hits swap
when building the PPC backend in optimized mode. Thus this fixes PR448.
-Chris
llvm-svn: 19755
2005-01-23 02:38:13 +08:00
|
|
|
return false;
|
|
|
|
}
|
This is the final big of factoring. This shares cases in suboperand
differences, which means that identical instructions (after stripping off
the first literal string) do not run any different code at all. On the X86,
this turns this code:
switch (MI->getOpcode()) {
case X86::ADC32mi: printOperand(MI, 4, MVT::i32); break;
case X86::ADC32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::ADC32mr: printOperand(MI, 4, MVT::i32); break;
case X86::ADD32mi: printOperand(MI, 4, MVT::i32); break;
case X86::ADD32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::ADD32mr: printOperand(MI, 4, MVT::i32); break;
case X86::AND32mi: printOperand(MI, 4, MVT::i32); break;
case X86::AND32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::AND32mr: printOperand(MI, 4, MVT::i32); break;
case X86::CMP32mi: printOperand(MI, 4, MVT::i32); break;
case X86::CMP32mr: printOperand(MI, 4, MVT::i32); break;
case X86::MOV32mi: printOperand(MI, 4, MVT::i32); break;
case X86::MOV32mr: printOperand(MI, 4, MVT::i32); break;
case X86::OR32mi: printOperand(MI, 4, MVT::i32); break;
case X86::OR32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::OR32mr: printOperand(MI, 4, MVT::i32); break;
case X86::ROL32mi: printOperand(MI, 4, MVT::i8); break;
case X86::ROR32mi: printOperand(MI, 4, MVT::i8); break;
case X86::SAR32mi: printOperand(MI, 4, MVT::i8); break;
case X86::SBB32mi: printOperand(MI, 4, MVT::i32); break;
case X86::SBB32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::SBB32mr: printOperand(MI, 4, MVT::i32); break;
case X86::SHL32mi: printOperand(MI, 4, MVT::i8); break;
case X86::SHLD32mrCL: printOperand(MI, 4, MVT::i32); break;
case X86::SHR32mi: printOperand(MI, 4, MVT::i8); break;
case X86::SHRD32mrCL: printOperand(MI, 4, MVT::i32); break;
case X86::SUB32mi: printOperand(MI, 4, MVT::i32); break;
case X86::SUB32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::SUB32mr: printOperand(MI, 4, MVT::i32); break;
case X86::TEST32mi: printOperand(MI, 4, MVT::i32); break;
case X86::TEST32mr: printOperand(MI, 4, MVT::i32); break;
case X86::TEST8mi: printOperand(MI, 4, MVT::i8); break;
case X86::XCHG32mr: printOperand(MI, 4, MVT::i32); break;
case X86::XOR32mi: printOperand(MI, 4, MVT::i32); break;
case X86::XOR32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::XOR32mr: printOperand(MI, 4, MVT::i32); break;
}
into this:
switch (MI->getOpcode()) {
case X86::ADC32mi:
case X86::ADC32mr:
case X86::ADD32mi:
case X86::ADD32mr:
case X86::AND32mi:
case X86::AND32mr:
case X86::CMP32mi:
case X86::CMP32mr:
case X86::MOV32mi:
case X86::MOV32mr:
case X86::OR32mi:
case X86::OR32mr:
case X86::SBB32mi:
case X86::SBB32mr:
case X86::SHLD32mrCL:
case X86::SHRD32mrCL:
case X86::SUB32mi:
case X86::SUB32mr:
case X86::TEST32mi:
case X86::TEST32mr:
case X86::XCHG32mr:
case X86::XOR32mi:
case X86::XOR32mr: printOperand(MI, 4, MVT::i32); break;
case X86::ADC32mi8:
case X86::ADD32mi8:
case X86::AND32mi8:
case X86::OR32mi8:
case X86::ROL32mi:
case X86::ROR32mi:
case X86::SAR32mi:
case X86::SBB32mi8:
case X86::SHL32mi:
case X86::SHR32mi:
case X86::SUB32mi8:
case X86::TEST8mi:
case X86::XOR32mi8: printOperand(MI, 4, MVT::i8); break;
}
After this, the generated asmwriters look pretty much as though they were
generated by hand. This shrinks the X86 asmwriter.inc files from 55101->39669
and 55429->39551 bytes each, and PPC from 16766->12859 bytes.
llvm-svn: 19760
2005-01-23 04:31:17 +08:00
|
|
|
bool operator==(const AsmWriterOperand &Other) const {
|
|
|
|
return !operator!=(Other);
|
|
|
|
}
|
2006-07-19 01:18:03 +08:00
|
|
|
|
|
|
|
/// getCode - Return the code that prints this operand.
|
|
|
|
std::string getCode() const;
|
2005-01-23 01:32:42 +08:00
|
|
|
};
|
2006-07-19 01:18:03 +08:00
|
|
|
}
|
2005-01-23 01:32:42 +08:00
|
|
|
|
2006-07-19 01:18:03 +08:00
|
|
|
namespace llvm {
|
2006-11-06 03:31:28 +08:00
|
|
|
class AsmWriterInst {
|
|
|
|
public:
|
2005-01-23 01:32:42 +08:00
|
|
|
std::vector<AsmWriterOperand> Operands;
|
2005-01-23 01:40:38 +08:00
|
|
|
const CodeGenInstruction *CGI;
|
2005-04-22 08:00:37 +08:00
|
|
|
|
2009-08-08 07:13:38 +08:00
|
|
|
AsmWriterInst(const CodeGenInstruction &CGI, Record *AsmWriter);
|
Implement factoring of instruction pattern strings. In particular, instead of
emitting code like this:
case PPC::ADD: O << "add "; printOperand(MI, 0, MVT::i64); O << ", "; prin
tOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '\n
'; break;
case PPC::ADDC: O << "addc "; printOperand(MI, 0, MVT::i64); O << ", "; pr
intOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '
\n'; break;
case PPC::ADDE: O << "adde "; printOperand(MI, 0, MVT::i64); O << ", "; pr
intOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '
\n'; break;
...
Emit code like this:
case PPC::ADD:
case PPC::ADDC:
case PPC::ADDE:
...
switch (MI->getOpcode()) {
case PPC::ADD: O << "add "; break;
case PPC::ADDC: O << "addc "; break;
case PPC::ADDE: O << "adde "; break;
...
}
printOperand(MI, 0, MVT::i64);
O << ", ";
printOperand(MI, 1, MVT::i64);
O << ", ";
printOperand(MI, 2, MVT::i64);
O << "\n";
break;
This shrinks the PPC asm writer from 24785->15205 bytes (even though the new
asmwriter has much more whitespace than the old one), and the X86 printers shrink
quite a bit too. The important implication of this is that GCC no longer hits swap
when building the PPC backend in optimized mode. Thus this fixes PR448.
-Chris
llvm-svn: 19755
2005-01-23 02:38:13 +08:00
|
|
|
|
2005-01-23 03:22:23 +08:00
|
|
|
/// MatchesAllButOneOp - If this instruction is exactly identical to the
|
|
|
|
/// specified instruction except for one differing operand, return the
|
|
|
|
/// differing operand number. Otherwise return ~0.
|
|
|
|
unsigned MatchesAllButOneOp(const AsmWriterInst &Other) const;
|
Implement factoring of instruction pattern strings. In particular, instead of
emitting code like this:
case PPC::ADD: O << "add "; printOperand(MI, 0, MVT::i64); O << ", "; prin
tOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '\n
'; break;
case PPC::ADDC: O << "addc "; printOperand(MI, 0, MVT::i64); O << ", "; pr
intOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '
\n'; break;
case PPC::ADDE: O << "adde "; printOperand(MI, 0, MVT::i64); O << ", "; pr
intOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '
\n'; break;
...
Emit code like this:
case PPC::ADD:
case PPC::ADDC:
case PPC::ADDE:
...
switch (MI->getOpcode()) {
case PPC::ADD: O << "add "; break;
case PPC::ADDC: O << "addc "; break;
case PPC::ADDE: O << "adde "; break;
...
}
printOperand(MI, 0, MVT::i64);
O << ", ";
printOperand(MI, 1, MVT::i64);
O << ", ";
printOperand(MI, 2, MVT::i64);
O << "\n";
break;
This shrinks the PPC asm writer from 24785->15205 bytes (even though the new
asmwriter has much more whitespace than the old one), and the X86 printers shrink
quite a bit too. The important implication of this is that GCC no longer hits swap
when building the PPC backend in optimized mode. Thus this fixes PR448.
-Chris
llvm-svn: 19755
2005-01-23 02:38:13 +08:00
|
|
|
|
2005-01-23 01:32:42 +08:00
|
|
|
private:
|
|
|
|
void AddLiteralString(const std::string &Str) {
|
|
|
|
// If the last operand was already a literal text string, append this to
|
|
|
|
// it, otherwise add a new operand.
|
|
|
|
if (!Operands.empty() &&
|
|
|
|
Operands.back().OperandType == AsmWriterOperand::isLiteralTextOperand)
|
|
|
|
Operands.back().Str.append(Str);
|
|
|
|
else
|
|
|
|
Operands.push_back(AsmWriterOperand(Str));
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
|
|
|
|
2006-07-19 01:18:03 +08:00
|
|
|
std::string AsmWriterOperand::getCode() const {
|
2009-08-08 08:05:42 +08:00
|
|
|
if (OperandType == isLiteralTextOperand) {
|
|
|
|
if (Str.size() == 1)
|
|
|
|
return "O << '" + Str + "'; ";
|
2006-07-19 01:18:03 +08:00
|
|
|
return "O << \"" + Str + "\"; ";
|
2009-08-08 08:05:42 +08:00
|
|
|
}
|
2006-07-19 01:18:03 +08:00
|
|
|
|
2009-08-08 08:05:42 +08:00
|
|
|
if (OperandType == isLiteralStatementOperand)
|
2009-07-30 04:10:24 +08:00
|
|
|
return Str;
|
|
|
|
|
2006-09-27 07:45:08 +08:00
|
|
|
std::string Result = Str + "(MI";
|
|
|
|
if (MIOpNo != ~0U)
|
|
|
|
Result += ", " + utostr(MIOpNo);
|
2006-07-19 01:18:03 +08:00
|
|
|
if (!MiModifier.empty())
|
|
|
|
Result += ", \"" + MiModifier + '"';
|
|
|
|
return Result + "); ";
|
2005-01-23 01:32:42 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
/// ParseAsmString - Parse the specified Instruction's AsmString into this
|
|
|
|
/// AsmWriterInst.
|
|
|
|
///
|
2009-08-08 07:13:38 +08:00
|
|
|
AsmWriterInst::AsmWriterInst(const CodeGenInstruction &CGI, Record *AsmWriter) {
|
2005-01-23 01:40:38 +08:00
|
|
|
this->CGI = &CGI;
|
2009-08-08 07:13:38 +08:00
|
|
|
|
|
|
|
unsigned Variant = AsmWriter->getValueAsInt("Variant");
|
|
|
|
int FirstOperandColumn = AsmWriter->getValueAsInt("FirstOperandColumn");
|
|
|
|
int OperandSpacing = AsmWriter->getValueAsInt("OperandSpacing");
|
|
|
|
|
2006-02-07 06:43:28 +08:00
|
|
|
unsigned CurVariant = ~0U; // ~0 if we are outside a {.|.|.} region, other #.
|
2005-01-23 01:32:42 +08:00
|
|
|
|
2009-08-08 07:13:38 +08:00
|
|
|
// This is the number of tabs we've seen if we're doing columnar layout.
|
|
|
|
unsigned CurColumn = 0;
|
|
|
|
|
|
|
|
|
2006-02-02 03:12:23 +08:00
|
|
|
// NOTE: Any extensions to this code need to be mirrored in the
|
|
|
|
// AsmPrinter::printInlineAsm code that executes as compile time (assuming
|
|
|
|
// that inline asm strings should also get the new feature)!
|
2005-01-23 01:32:42 +08:00
|
|
|
const std::string &AsmString = CGI.AsmString;
|
|
|
|
std::string::size_type LastEmitted = 0;
|
|
|
|
while (LastEmitted != AsmString.size()) {
|
|
|
|
std::string::size_type DollarPos =
|
2008-03-17 15:26:14 +08:00
|
|
|
AsmString.find_first_of("${|}\\", LastEmitted);
|
2005-01-23 01:32:42 +08:00
|
|
|
if (DollarPos == std::string::npos) DollarPos = AsmString.size();
|
|
|
|
|
|
|
|
// Emit a constant string fragment.
|
2009-07-30 04:10:24 +08:00
|
|
|
|
2005-01-23 01:32:42 +08:00
|
|
|
if (DollarPos != LastEmitted) {
|
2009-03-14 05:33:17 +08:00
|
|
|
if (CurVariant == Variant || CurVariant == ~0U) {
|
|
|
|
for (; LastEmitted != DollarPos; ++LastEmitted)
|
|
|
|
switch (AsmString[LastEmitted]) {
|
2009-07-30 04:10:24 +08:00
|
|
|
case '\n':
|
|
|
|
AddLiteralString("\\n");
|
|
|
|
break;
|
2009-08-08 07:13:38 +08:00
|
|
|
case '\t':
|
|
|
|
// If the asm writer is not using a columnar layout, \t is not
|
|
|
|
// magic.
|
|
|
|
if (FirstOperandColumn == -1 || OperandSpacing == -1) {
|
|
|
|
AddLiteralString("\\t");
|
2009-08-08 07:37:47 +08:00
|
|
|
} else {
|
|
|
|
// We recognize a tab as an operand delimeter.
|
|
|
|
unsigned DestColumn = FirstOperandColumn +
|
|
|
|
CurColumn++ * OperandSpacing;
|
|
|
|
Operands.push_back(
|
|
|
|
AsmWriterOperand("O.PadToColumn(" +
|
2009-08-17 23:48:08 +08:00
|
|
|
utostr(DestColumn) + ");\n",
|
2009-08-08 07:37:47 +08:00
|
|
|
AsmWriterOperand::isLiteralStatementOperand));
|
2009-08-08 07:13:38 +08:00
|
|
|
}
|
2009-07-30 04:10:24 +08:00
|
|
|
break;
|
|
|
|
case '"':
|
|
|
|
AddLiteralString("\\\"");
|
|
|
|
break;
|
|
|
|
case '\\':
|
|
|
|
AddLiteralString("\\\\");
|
|
|
|
break;
|
2009-03-14 05:33:17 +08:00
|
|
|
default:
|
|
|
|
AddLiteralString(std::string(1, AsmString[LastEmitted]));
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
} else {
|
|
|
|
LastEmitted = DollarPos;
|
|
|
|
}
|
2008-03-17 15:26:14 +08:00
|
|
|
} else if (AsmString[DollarPos] == '\\') {
|
|
|
|
if (DollarPos+1 != AsmString.size() &&
|
|
|
|
(CurVariant == Variant || CurVariant == ~0U)) {
|
|
|
|
if (AsmString[DollarPos+1] == 'n') {
|
|
|
|
AddLiteralString("\\n");
|
|
|
|
} else if (AsmString[DollarPos+1] == 't') {
|
2009-08-08 07:13:38 +08:00
|
|
|
// If the asm writer is not using a columnar layout, \t is not
|
|
|
|
// magic.
|
|
|
|
if (FirstOperandColumn == -1 || OperandSpacing == -1) {
|
|
|
|
AddLiteralString("\\t");
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// We recognize a tab as an operand delimeter.
|
|
|
|
unsigned DestColumn = FirstOperandColumn +
|
|
|
|
CurColumn++ * OperandSpacing;
|
2009-08-01 05:57:10 +08:00
|
|
|
Operands.push_back(
|
2009-08-17 23:48:08 +08:00
|
|
|
AsmWriterOperand("O.PadToColumn(" + utostr(DestColumn) + ");\n",
|
2009-08-01 05:57:10 +08:00
|
|
|
AsmWriterOperand::isLiteralStatementOperand));
|
2009-08-08 07:13:38 +08:00
|
|
|
break;
|
2008-03-17 15:26:14 +08:00
|
|
|
} else if (std::string("${|}\\").find(AsmString[DollarPos+1])
|
|
|
|
!= std::string::npos) {
|
|
|
|
AddLiteralString(std::string(1, AsmString[DollarPos+1]));
|
|
|
|
} else {
|
|
|
|
throw "Non-supported escaped character found in instruction '" +
|
|
|
|
CGI.TheDef->getName() + "'!";
|
|
|
|
}
|
|
|
|
LastEmitted = DollarPos+2;
|
|
|
|
continue;
|
|
|
|
}
|
2005-01-23 01:32:42 +08:00
|
|
|
} else if (AsmString[DollarPos] == '{') {
|
2006-02-07 06:43:28 +08:00
|
|
|
if (CurVariant != ~0U)
|
2005-07-27 14:12:32 +08:00
|
|
|
throw "Nested variants found for instruction '" +
|
2005-07-16 06:43:04 +08:00
|
|
|
CGI.TheDef->getName() + "'!";
|
2005-01-23 01:32:42 +08:00
|
|
|
LastEmitted = DollarPos+1;
|
2006-02-07 06:43:28 +08:00
|
|
|
CurVariant = 0; // We are now inside of the variant!
|
2005-01-23 01:32:42 +08:00
|
|
|
} else if (AsmString[DollarPos] == '|') {
|
2006-02-07 06:43:28 +08:00
|
|
|
if (CurVariant == ~0U)
|
2005-01-23 01:32:42 +08:00
|
|
|
throw "'|' character found outside of a variant in instruction '"
|
2005-07-16 06:43:04 +08:00
|
|
|
+ CGI.TheDef->getName() + "'!";
|
2006-02-07 06:43:28 +08:00
|
|
|
++CurVariant;
|
|
|
|
++LastEmitted;
|
2005-01-23 01:32:42 +08:00
|
|
|
} else if (AsmString[DollarPos] == '}') {
|
2006-02-07 06:43:28 +08:00
|
|
|
if (CurVariant == ~0U)
|
2005-01-23 01:32:42 +08:00
|
|
|
throw "'}' character found outside of a variant in instruction '"
|
2005-07-16 06:43:04 +08:00
|
|
|
+ CGI.TheDef->getName() + "'!";
|
2006-02-07 06:43:28 +08:00
|
|
|
++LastEmitted;
|
|
|
|
CurVariant = ~0U;
|
2005-01-23 01:32:42 +08:00
|
|
|
} else if (DollarPos+1 != AsmString.size() &&
|
|
|
|
AsmString[DollarPos+1] == '$') {
|
2009-07-30 04:10:24 +08:00
|
|
|
if (CurVariant == Variant || CurVariant == ~0U) {
|
2006-02-07 06:43:28 +08:00
|
|
|
AddLiteralString("$"); // "$$" -> $
|
2009-07-30 04:10:24 +08:00
|
|
|
}
|
2005-01-23 01:32:42 +08:00
|
|
|
LastEmitted = DollarPos+2;
|
|
|
|
} else {
|
|
|
|
// Get the name of the variable.
|
|
|
|
std::string::size_type VarEnd = DollarPos+1;
|
2009-07-30 04:10:24 +08:00
|
|
|
|
2005-07-15 06:50:30 +08:00
|
|
|
// handle ${foo}bar as $foo by detecting whether the character following
|
|
|
|
// the dollar sign is a curly brace. If so, advance VarEnd and DollarPos
|
|
|
|
// so the variable name does not contain the leading curly brace.
|
|
|
|
bool hasCurlyBraces = false;
|
|
|
|
if (VarEnd < AsmString.size() && '{' == AsmString[VarEnd]) {
|
|
|
|
hasCurlyBraces = true;
|
|
|
|
++DollarPos;
|
|
|
|
++VarEnd;
|
|
|
|
}
|
|
|
|
|
2005-01-23 01:32:42 +08:00
|
|
|
while (VarEnd < AsmString.size() && isIdentChar(AsmString[VarEnd]))
|
|
|
|
++VarEnd;
|
|
|
|
std::string VarName(AsmString.begin()+DollarPos+1,
|
|
|
|
AsmString.begin()+VarEnd);
|
2005-07-15 06:50:30 +08:00
|
|
|
|
2006-02-07 07:40:48 +08:00
|
|
|
// Modifier - Support ${foo:modifier} syntax, where "modifier" is passed
|
2006-09-27 07:45:08 +08:00
|
|
|
// into printOperand. Also support ${:feature}, which is passed into
|
2006-09-27 07:47:10 +08:00
|
|
|
// PrintSpecial.
|
2006-02-07 07:40:48 +08:00
|
|
|
std::string Modifier;
|
|
|
|
|
2005-07-15 06:50:30 +08:00
|
|
|
// In order to avoid starting the next string at the terminating curly
|
|
|
|
// brace, advance the end position past it if we found an opening curly
|
|
|
|
// brace.
|
|
|
|
if (hasCurlyBraces) {
|
|
|
|
if (VarEnd >= AsmString.size())
|
|
|
|
throw "Reached end of string before terminating curly brace in '"
|
2005-07-16 06:43:04 +08:00
|
|
|
+ CGI.TheDef->getName() + "'";
|
2006-02-07 07:40:48 +08:00
|
|
|
|
|
|
|
// Look for a modifier string.
|
|
|
|
if (AsmString[VarEnd] == ':') {
|
|
|
|
++VarEnd;
|
|
|
|
if (VarEnd >= AsmString.size())
|
|
|
|
throw "Reached end of string before terminating curly brace in '"
|
|
|
|
+ CGI.TheDef->getName() + "'";
|
|
|
|
|
|
|
|
unsigned ModifierStart = VarEnd;
|
|
|
|
while (VarEnd < AsmString.size() && isIdentChar(AsmString[VarEnd]))
|
|
|
|
++VarEnd;
|
|
|
|
Modifier = std::string(AsmString.begin()+ModifierStart,
|
|
|
|
AsmString.begin()+VarEnd);
|
|
|
|
if (Modifier.empty())
|
|
|
|
throw "Bad operand modifier name in '"+ CGI.TheDef->getName() + "'";
|
|
|
|
}
|
|
|
|
|
2005-07-15 06:50:30 +08:00
|
|
|
if (AsmString[VarEnd] != '}')
|
2006-02-07 06:43:28 +08:00
|
|
|
throw "Variable name beginning with '{' did not end with '}' in '"
|
2005-07-16 06:43:04 +08:00
|
|
|
+ CGI.TheDef->getName() + "'";
|
2005-07-15 06:50:30 +08:00
|
|
|
++VarEnd;
|
|
|
|
}
|
2006-09-27 07:45:08 +08:00
|
|
|
if (VarName.empty() && Modifier.empty())
|
2005-07-27 14:12:32 +08:00
|
|
|
throw "Stray '$' in '" + CGI.TheDef->getName() +
|
2005-07-16 06:43:04 +08:00
|
|
|
"' asm string, maybe you want $$?";
|
2005-01-23 01:32:42 +08:00
|
|
|
|
2006-09-27 07:45:08 +08:00
|
|
|
if (VarName.empty()) {
|
2006-09-27 07:47:10 +08:00
|
|
|
// Just a modifier, pass this into PrintSpecial.
|
|
|
|
Operands.push_back(AsmWriterOperand("PrintSpecial", ~0U, Modifier));
|
2006-09-27 07:45:08 +08:00
|
|
|
} else {
|
|
|
|
// Otherwise, normal operand.
|
|
|
|
unsigned OpNo = CGI.getOperandNamed(VarName);
|
|
|
|
CodeGenInstruction::OperandInfo OpInfo = CGI.OperandList[OpNo];
|
|
|
|
|
2006-11-16 07:23:02 +08:00
|
|
|
if (CurVariant == Variant || CurVariant == ~0U) {
|
|
|
|
unsigned MIOp = OpInfo.MIOperandNo;
|
2006-09-27 07:45:08 +08:00
|
|
|
Operands.push_back(AsmWriterOperand(OpInfo.PrinterMethodName, MIOp,
|
|
|
|
Modifier));
|
2006-11-16 07:23:02 +08:00
|
|
|
}
|
2006-09-27 07:45:08 +08:00
|
|
|
}
|
2005-01-23 01:32:42 +08:00
|
|
|
LastEmitted = VarEnd;
|
|
|
|
}
|
|
|
|
}
|
2009-07-20 14:10:07 +08:00
|
|
|
|
2009-07-30 04:10:24 +08:00
|
|
|
Operands.push_back(
|
|
|
|
AsmWriterOperand("EmitComments(*MI);\n",
|
|
|
|
AsmWriterOperand::isLiteralStatementOperand));
|
2009-07-20 14:10:07 +08:00
|
|
|
AddLiteralString("\\n");
|
2005-01-23 01:32:42 +08:00
|
|
|
}
|
|
|
|
|
2005-01-23 03:22:23 +08:00
|
|
|
/// MatchesAllButOneOp - If this instruction is exactly identical to the
|
|
|
|
/// specified instruction except for one differing operand, return the differing
|
|
|
|
/// operand number. If more than one operand mismatches, return ~1, otherwise
|
|
|
|
/// if the instructions are identical return ~0.
|
|
|
|
unsigned AsmWriterInst::MatchesAllButOneOp(const AsmWriterInst &Other)const{
|
|
|
|
if (Operands.size() != Other.Operands.size()) return ~1;
|
Implement factoring of instruction pattern strings. In particular, instead of
emitting code like this:
case PPC::ADD: O << "add "; printOperand(MI, 0, MVT::i64); O << ", "; prin
tOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '\n
'; break;
case PPC::ADDC: O << "addc "; printOperand(MI, 0, MVT::i64); O << ", "; pr
intOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '
\n'; break;
case PPC::ADDE: O << "adde "; printOperand(MI, 0, MVT::i64); O << ", "; pr
intOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '
\n'; break;
...
Emit code like this:
case PPC::ADD:
case PPC::ADDC:
case PPC::ADDE:
...
switch (MI->getOpcode()) {
case PPC::ADD: O << "add "; break;
case PPC::ADDC: O << "addc "; break;
case PPC::ADDE: O << "adde "; break;
...
}
printOperand(MI, 0, MVT::i64);
O << ", ";
printOperand(MI, 1, MVT::i64);
O << ", ";
printOperand(MI, 2, MVT::i64);
O << "\n";
break;
This shrinks the PPC asm writer from 24785->15205 bytes (even though the new
asmwriter has much more whitespace than the old one), and the X86 printers shrink
quite a bit too. The important implication of this is that GCC no longer hits swap
when building the PPC backend in optimized mode. Thus this fixes PR448.
-Chris
llvm-svn: 19755
2005-01-23 02:38:13 +08:00
|
|
|
|
|
|
|
unsigned MismatchOperand = ~0U;
|
|
|
|
for (unsigned i = 0, e = Operands.size(); i != e; ++i) {
|
2008-02-20 19:08:44 +08:00
|
|
|
if (Operands[i] != Other.Operands[i]) {
|
2005-01-23 03:22:23 +08:00
|
|
|
if (MismatchOperand != ~0U) // Already have one mismatch?
|
|
|
|
return ~1U;
|
2005-04-22 08:00:37 +08:00
|
|
|
else
|
Implement factoring of instruction pattern strings. In particular, instead of
emitting code like this:
case PPC::ADD: O << "add "; printOperand(MI, 0, MVT::i64); O << ", "; prin
tOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '\n
'; break;
case PPC::ADDC: O << "addc "; printOperand(MI, 0, MVT::i64); O << ", "; pr
intOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '
\n'; break;
case PPC::ADDE: O << "adde "; printOperand(MI, 0, MVT::i64); O << ", "; pr
intOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '
\n'; break;
...
Emit code like this:
case PPC::ADD:
case PPC::ADDC:
case PPC::ADDE:
...
switch (MI->getOpcode()) {
case PPC::ADD: O << "add "; break;
case PPC::ADDC: O << "addc "; break;
case PPC::ADDE: O << "adde "; break;
...
}
printOperand(MI, 0, MVT::i64);
O << ", ";
printOperand(MI, 1, MVT::i64);
O << ", ";
printOperand(MI, 2, MVT::i64);
O << "\n";
break;
This shrinks the PPC asm writer from 24785->15205 bytes (even though the new
asmwriter has much more whitespace than the old one), and the X86 printers shrink
quite a bit too. The important implication of this is that GCC no longer hits swap
when building the PPC backend in optimized mode. Thus this fixes PR448.
-Chris
llvm-svn: 19755
2005-01-23 02:38:13 +08:00
|
|
|
MismatchOperand = i;
|
2008-02-20 19:08:44 +08:00
|
|
|
}
|
Implement factoring of instruction pattern strings. In particular, instead of
emitting code like this:
case PPC::ADD: O << "add "; printOperand(MI, 0, MVT::i64); O << ", "; prin
tOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '\n
'; break;
case PPC::ADDC: O << "addc "; printOperand(MI, 0, MVT::i64); O << ", "; pr
intOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '
\n'; break;
case PPC::ADDE: O << "adde "; printOperand(MI, 0, MVT::i64); O << ", "; pr
intOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '
\n'; break;
...
Emit code like this:
case PPC::ADD:
case PPC::ADDC:
case PPC::ADDE:
...
switch (MI->getOpcode()) {
case PPC::ADD: O << "add "; break;
case PPC::ADDC: O << "addc "; break;
case PPC::ADDE: O << "adde "; break;
...
}
printOperand(MI, 0, MVT::i64);
O << ", ";
printOperand(MI, 1, MVT::i64);
O << ", ";
printOperand(MI, 2, MVT::i64);
O << "\n";
break;
This shrinks the PPC asm writer from 24785->15205 bytes (even though the new
asmwriter has much more whitespace than the old one), and the X86 printers shrink
quite a bit too. The important implication of this is that GCC no longer hits swap
when building the PPC backend in optimized mode. Thus this fixes PR448.
-Chris
llvm-svn: 19755
2005-01-23 02:38:13 +08:00
|
|
|
}
|
|
|
|
return MismatchOperand;
|
|
|
|
}
|
|
|
|
|
This is the final big of factoring. This shares cases in suboperand
differences, which means that identical instructions (after stripping off
the first literal string) do not run any different code at all. On the X86,
this turns this code:
switch (MI->getOpcode()) {
case X86::ADC32mi: printOperand(MI, 4, MVT::i32); break;
case X86::ADC32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::ADC32mr: printOperand(MI, 4, MVT::i32); break;
case X86::ADD32mi: printOperand(MI, 4, MVT::i32); break;
case X86::ADD32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::ADD32mr: printOperand(MI, 4, MVT::i32); break;
case X86::AND32mi: printOperand(MI, 4, MVT::i32); break;
case X86::AND32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::AND32mr: printOperand(MI, 4, MVT::i32); break;
case X86::CMP32mi: printOperand(MI, 4, MVT::i32); break;
case X86::CMP32mr: printOperand(MI, 4, MVT::i32); break;
case X86::MOV32mi: printOperand(MI, 4, MVT::i32); break;
case X86::MOV32mr: printOperand(MI, 4, MVT::i32); break;
case X86::OR32mi: printOperand(MI, 4, MVT::i32); break;
case X86::OR32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::OR32mr: printOperand(MI, 4, MVT::i32); break;
case X86::ROL32mi: printOperand(MI, 4, MVT::i8); break;
case X86::ROR32mi: printOperand(MI, 4, MVT::i8); break;
case X86::SAR32mi: printOperand(MI, 4, MVT::i8); break;
case X86::SBB32mi: printOperand(MI, 4, MVT::i32); break;
case X86::SBB32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::SBB32mr: printOperand(MI, 4, MVT::i32); break;
case X86::SHL32mi: printOperand(MI, 4, MVT::i8); break;
case X86::SHLD32mrCL: printOperand(MI, 4, MVT::i32); break;
case X86::SHR32mi: printOperand(MI, 4, MVT::i8); break;
case X86::SHRD32mrCL: printOperand(MI, 4, MVT::i32); break;
case X86::SUB32mi: printOperand(MI, 4, MVT::i32); break;
case X86::SUB32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::SUB32mr: printOperand(MI, 4, MVT::i32); break;
case X86::TEST32mi: printOperand(MI, 4, MVT::i32); break;
case X86::TEST32mr: printOperand(MI, 4, MVT::i32); break;
case X86::TEST8mi: printOperand(MI, 4, MVT::i8); break;
case X86::XCHG32mr: printOperand(MI, 4, MVT::i32); break;
case X86::XOR32mi: printOperand(MI, 4, MVT::i32); break;
case X86::XOR32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::XOR32mr: printOperand(MI, 4, MVT::i32); break;
}
into this:
switch (MI->getOpcode()) {
case X86::ADC32mi:
case X86::ADC32mr:
case X86::ADD32mi:
case X86::ADD32mr:
case X86::AND32mi:
case X86::AND32mr:
case X86::CMP32mi:
case X86::CMP32mr:
case X86::MOV32mi:
case X86::MOV32mr:
case X86::OR32mi:
case X86::OR32mr:
case X86::SBB32mi:
case X86::SBB32mr:
case X86::SHLD32mrCL:
case X86::SHRD32mrCL:
case X86::SUB32mi:
case X86::SUB32mr:
case X86::TEST32mi:
case X86::TEST32mr:
case X86::XCHG32mr:
case X86::XOR32mi:
case X86::XOR32mr: printOperand(MI, 4, MVT::i32); break;
case X86::ADC32mi8:
case X86::ADD32mi8:
case X86::AND32mi8:
case X86::OR32mi8:
case X86::ROL32mi:
case X86::ROR32mi:
case X86::SAR32mi:
case X86::SBB32mi8:
case X86::SHL32mi:
case X86::SHR32mi:
case X86::SUB32mi8:
case X86::TEST8mi:
case X86::XOR32mi8: printOperand(MI, 4, MVT::i8); break;
}
After this, the generated asmwriters look pretty much as though they were
generated by hand. This shrinks the X86 asmwriter.inc files from 55101->39669
and 55429->39551 bytes each, and PPC from 16766->12859 bytes.
llvm-svn: 19760
2005-01-23 04:31:17 +08:00
|
|
|
static void PrintCases(std::vector<std::pair<std::string,
|
2009-07-03 08:10:29 +08:00
|
|
|
AsmWriterOperand> > &OpsToPrint, raw_ostream &O) {
|
This is the final big of factoring. This shares cases in suboperand
differences, which means that identical instructions (after stripping off
the first literal string) do not run any different code at all. On the X86,
this turns this code:
switch (MI->getOpcode()) {
case X86::ADC32mi: printOperand(MI, 4, MVT::i32); break;
case X86::ADC32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::ADC32mr: printOperand(MI, 4, MVT::i32); break;
case X86::ADD32mi: printOperand(MI, 4, MVT::i32); break;
case X86::ADD32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::ADD32mr: printOperand(MI, 4, MVT::i32); break;
case X86::AND32mi: printOperand(MI, 4, MVT::i32); break;
case X86::AND32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::AND32mr: printOperand(MI, 4, MVT::i32); break;
case X86::CMP32mi: printOperand(MI, 4, MVT::i32); break;
case X86::CMP32mr: printOperand(MI, 4, MVT::i32); break;
case X86::MOV32mi: printOperand(MI, 4, MVT::i32); break;
case X86::MOV32mr: printOperand(MI, 4, MVT::i32); break;
case X86::OR32mi: printOperand(MI, 4, MVT::i32); break;
case X86::OR32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::OR32mr: printOperand(MI, 4, MVT::i32); break;
case X86::ROL32mi: printOperand(MI, 4, MVT::i8); break;
case X86::ROR32mi: printOperand(MI, 4, MVT::i8); break;
case X86::SAR32mi: printOperand(MI, 4, MVT::i8); break;
case X86::SBB32mi: printOperand(MI, 4, MVT::i32); break;
case X86::SBB32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::SBB32mr: printOperand(MI, 4, MVT::i32); break;
case X86::SHL32mi: printOperand(MI, 4, MVT::i8); break;
case X86::SHLD32mrCL: printOperand(MI, 4, MVT::i32); break;
case X86::SHR32mi: printOperand(MI, 4, MVT::i8); break;
case X86::SHRD32mrCL: printOperand(MI, 4, MVT::i32); break;
case X86::SUB32mi: printOperand(MI, 4, MVT::i32); break;
case X86::SUB32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::SUB32mr: printOperand(MI, 4, MVT::i32); break;
case X86::TEST32mi: printOperand(MI, 4, MVT::i32); break;
case X86::TEST32mr: printOperand(MI, 4, MVT::i32); break;
case X86::TEST8mi: printOperand(MI, 4, MVT::i8); break;
case X86::XCHG32mr: printOperand(MI, 4, MVT::i32); break;
case X86::XOR32mi: printOperand(MI, 4, MVT::i32); break;
case X86::XOR32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::XOR32mr: printOperand(MI, 4, MVT::i32); break;
}
into this:
switch (MI->getOpcode()) {
case X86::ADC32mi:
case X86::ADC32mr:
case X86::ADD32mi:
case X86::ADD32mr:
case X86::AND32mi:
case X86::AND32mr:
case X86::CMP32mi:
case X86::CMP32mr:
case X86::MOV32mi:
case X86::MOV32mr:
case X86::OR32mi:
case X86::OR32mr:
case X86::SBB32mi:
case X86::SBB32mr:
case X86::SHLD32mrCL:
case X86::SHRD32mrCL:
case X86::SUB32mi:
case X86::SUB32mr:
case X86::TEST32mi:
case X86::TEST32mr:
case X86::XCHG32mr:
case X86::XOR32mi:
case X86::XOR32mr: printOperand(MI, 4, MVT::i32); break;
case X86::ADC32mi8:
case X86::ADD32mi8:
case X86::AND32mi8:
case X86::OR32mi8:
case X86::ROL32mi:
case X86::ROR32mi:
case X86::SAR32mi:
case X86::SBB32mi8:
case X86::SHL32mi:
case X86::SHR32mi:
case X86::SUB32mi8:
case X86::TEST8mi:
case X86::XOR32mi8: printOperand(MI, 4, MVT::i8); break;
}
After this, the generated asmwriters look pretty much as though they were
generated by hand. This shrinks the X86 asmwriter.inc files from 55101->39669
and 55429->39551 bytes each, and PPC from 16766->12859 bytes.
llvm-svn: 19760
2005-01-23 04:31:17 +08:00
|
|
|
O << " case " << OpsToPrint.back().first << ": ";
|
|
|
|
AsmWriterOperand TheOp = OpsToPrint.back().second;
|
|
|
|
OpsToPrint.pop_back();
|
|
|
|
|
|
|
|
// Check to see if any other operands are identical in this list, and if so,
|
|
|
|
// emit a case label for them.
|
|
|
|
for (unsigned i = OpsToPrint.size(); i != 0; --i)
|
|
|
|
if (OpsToPrint[i-1].second == TheOp) {
|
|
|
|
O << "\n case " << OpsToPrint[i-1].first << ": ";
|
|
|
|
OpsToPrint.erase(OpsToPrint.begin()+i-1);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Finally, emit the code.
|
2006-07-19 01:18:03 +08:00
|
|
|
O << TheOp.getCode();
|
This is the final big of factoring. This shares cases in suboperand
differences, which means that identical instructions (after stripping off
the first literal string) do not run any different code at all. On the X86,
this turns this code:
switch (MI->getOpcode()) {
case X86::ADC32mi: printOperand(MI, 4, MVT::i32); break;
case X86::ADC32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::ADC32mr: printOperand(MI, 4, MVT::i32); break;
case X86::ADD32mi: printOperand(MI, 4, MVT::i32); break;
case X86::ADD32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::ADD32mr: printOperand(MI, 4, MVT::i32); break;
case X86::AND32mi: printOperand(MI, 4, MVT::i32); break;
case X86::AND32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::AND32mr: printOperand(MI, 4, MVT::i32); break;
case X86::CMP32mi: printOperand(MI, 4, MVT::i32); break;
case X86::CMP32mr: printOperand(MI, 4, MVT::i32); break;
case X86::MOV32mi: printOperand(MI, 4, MVT::i32); break;
case X86::MOV32mr: printOperand(MI, 4, MVT::i32); break;
case X86::OR32mi: printOperand(MI, 4, MVT::i32); break;
case X86::OR32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::OR32mr: printOperand(MI, 4, MVT::i32); break;
case X86::ROL32mi: printOperand(MI, 4, MVT::i8); break;
case X86::ROR32mi: printOperand(MI, 4, MVT::i8); break;
case X86::SAR32mi: printOperand(MI, 4, MVT::i8); break;
case X86::SBB32mi: printOperand(MI, 4, MVT::i32); break;
case X86::SBB32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::SBB32mr: printOperand(MI, 4, MVT::i32); break;
case X86::SHL32mi: printOperand(MI, 4, MVT::i8); break;
case X86::SHLD32mrCL: printOperand(MI, 4, MVT::i32); break;
case X86::SHR32mi: printOperand(MI, 4, MVT::i8); break;
case X86::SHRD32mrCL: printOperand(MI, 4, MVT::i32); break;
case X86::SUB32mi: printOperand(MI, 4, MVT::i32); break;
case X86::SUB32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::SUB32mr: printOperand(MI, 4, MVT::i32); break;
case X86::TEST32mi: printOperand(MI, 4, MVT::i32); break;
case X86::TEST32mr: printOperand(MI, 4, MVT::i32); break;
case X86::TEST8mi: printOperand(MI, 4, MVT::i8); break;
case X86::XCHG32mr: printOperand(MI, 4, MVT::i32); break;
case X86::XOR32mi: printOperand(MI, 4, MVT::i32); break;
case X86::XOR32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::XOR32mr: printOperand(MI, 4, MVT::i32); break;
}
into this:
switch (MI->getOpcode()) {
case X86::ADC32mi:
case X86::ADC32mr:
case X86::ADD32mi:
case X86::ADD32mr:
case X86::AND32mi:
case X86::AND32mr:
case X86::CMP32mi:
case X86::CMP32mr:
case X86::MOV32mi:
case X86::MOV32mr:
case X86::OR32mi:
case X86::OR32mr:
case X86::SBB32mi:
case X86::SBB32mr:
case X86::SHLD32mrCL:
case X86::SHRD32mrCL:
case X86::SUB32mi:
case X86::SUB32mr:
case X86::TEST32mi:
case X86::TEST32mr:
case X86::XCHG32mr:
case X86::XOR32mi:
case X86::XOR32mr: printOperand(MI, 4, MVT::i32); break;
case X86::ADC32mi8:
case X86::ADD32mi8:
case X86::AND32mi8:
case X86::OR32mi8:
case X86::ROL32mi:
case X86::ROR32mi:
case X86::SAR32mi:
case X86::SBB32mi8:
case X86::SHL32mi:
case X86::SHR32mi:
case X86::SUB32mi8:
case X86::TEST8mi:
case X86::XOR32mi8: printOperand(MI, 4, MVT::i8); break;
}
After this, the generated asmwriters look pretty much as though they were
generated by hand. This shrinks the X86 asmwriter.inc files from 55101->39669
and 55429->39551 bytes each, and PPC from 16766->12859 bytes.
llvm-svn: 19760
2005-01-23 04:31:17 +08:00
|
|
|
O << "break;\n";
|
|
|
|
}
|
|
|
|
|
Implement factoring of instruction pattern strings. In particular, instead of
emitting code like this:
case PPC::ADD: O << "add "; printOperand(MI, 0, MVT::i64); O << ", "; prin
tOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '\n
'; break;
case PPC::ADDC: O << "addc "; printOperand(MI, 0, MVT::i64); O << ", "; pr
intOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '
\n'; break;
case PPC::ADDE: O << "adde "; printOperand(MI, 0, MVT::i64); O << ", "; pr
intOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '
\n'; break;
...
Emit code like this:
case PPC::ADD:
case PPC::ADDC:
case PPC::ADDE:
...
switch (MI->getOpcode()) {
case PPC::ADD: O << "add "; break;
case PPC::ADDC: O << "addc "; break;
case PPC::ADDE: O << "adde "; break;
...
}
printOperand(MI, 0, MVT::i64);
O << ", ";
printOperand(MI, 1, MVT::i64);
O << ", ";
printOperand(MI, 2, MVT::i64);
O << "\n";
break;
This shrinks the PPC asm writer from 24785->15205 bytes (even though the new
asmwriter has much more whitespace than the old one), and the X86 printers shrink
quite a bit too. The important implication of this is that GCC no longer hits swap
when building the PPC backend in optimized mode. Thus this fixes PR448.
-Chris
llvm-svn: 19755
2005-01-23 02:38:13 +08:00
|
|
|
|
|
|
|
/// EmitInstructions - Emit the last instruction in the vector and any other
|
|
|
|
/// instructions that are suitably similar to it.
|
|
|
|
static void EmitInstructions(std::vector<AsmWriterInst> &Insts,
|
2009-07-03 08:10:29 +08:00
|
|
|
raw_ostream &O) {
|
Implement factoring of instruction pattern strings. In particular, instead of
emitting code like this:
case PPC::ADD: O << "add "; printOperand(MI, 0, MVT::i64); O << ", "; prin
tOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '\n
'; break;
case PPC::ADDC: O << "addc "; printOperand(MI, 0, MVT::i64); O << ", "; pr
intOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '
\n'; break;
case PPC::ADDE: O << "adde "; printOperand(MI, 0, MVT::i64); O << ", "; pr
intOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '
\n'; break;
...
Emit code like this:
case PPC::ADD:
case PPC::ADDC:
case PPC::ADDE:
...
switch (MI->getOpcode()) {
case PPC::ADD: O << "add "; break;
case PPC::ADDC: O << "addc "; break;
case PPC::ADDE: O << "adde "; break;
...
}
printOperand(MI, 0, MVT::i64);
O << ", ";
printOperand(MI, 1, MVT::i64);
O << ", ";
printOperand(MI, 2, MVT::i64);
O << "\n";
break;
This shrinks the PPC asm writer from 24785->15205 bytes (even though the new
asmwriter has much more whitespace than the old one), and the X86 printers shrink
quite a bit too. The important implication of this is that GCC no longer hits swap
when building the PPC backend in optimized mode. Thus this fixes PR448.
-Chris
llvm-svn: 19755
2005-01-23 02:38:13 +08:00
|
|
|
AsmWriterInst FirstInst = Insts.back();
|
|
|
|
Insts.pop_back();
|
|
|
|
|
|
|
|
std::vector<AsmWriterInst> SimilarInsts;
|
|
|
|
unsigned DifferingOperand = ~0;
|
|
|
|
for (unsigned i = Insts.size(); i != 0; --i) {
|
2005-01-23 03:22:23 +08:00
|
|
|
unsigned DiffOp = Insts[i-1].MatchesAllButOneOp(FirstInst);
|
|
|
|
if (DiffOp != ~1U) {
|
Implement factoring of instruction pattern strings. In particular, instead of
emitting code like this:
case PPC::ADD: O << "add "; printOperand(MI, 0, MVT::i64); O << ", "; prin
tOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '\n
'; break;
case PPC::ADDC: O << "addc "; printOperand(MI, 0, MVT::i64); O << ", "; pr
intOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '
\n'; break;
case PPC::ADDE: O << "adde "; printOperand(MI, 0, MVT::i64); O << ", "; pr
intOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '
\n'; break;
...
Emit code like this:
case PPC::ADD:
case PPC::ADDC:
case PPC::ADDE:
...
switch (MI->getOpcode()) {
case PPC::ADD: O << "add "; break;
case PPC::ADDC: O << "addc "; break;
case PPC::ADDE: O << "adde "; break;
...
}
printOperand(MI, 0, MVT::i64);
O << ", ";
printOperand(MI, 1, MVT::i64);
O << ", ";
printOperand(MI, 2, MVT::i64);
O << "\n";
break;
This shrinks the PPC asm writer from 24785->15205 bytes (even though the new
asmwriter has much more whitespace than the old one), and the X86 printers shrink
quite a bit too. The important implication of this is that GCC no longer hits swap
when building the PPC backend in optimized mode. Thus this fixes PR448.
-Chris
llvm-svn: 19755
2005-01-23 02:38:13 +08:00
|
|
|
if (DifferingOperand == ~0U) // First match!
|
|
|
|
DifferingOperand = DiffOp;
|
|
|
|
|
|
|
|
// If this differs in the same operand as the rest of the instructions in
|
|
|
|
// this class, move it to the SimilarInsts list.
|
2005-01-23 03:22:23 +08:00
|
|
|
if (DifferingOperand == DiffOp || DiffOp == ~0U) {
|
Implement factoring of instruction pattern strings. In particular, instead of
emitting code like this:
case PPC::ADD: O << "add "; printOperand(MI, 0, MVT::i64); O << ", "; prin
tOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '\n
'; break;
case PPC::ADDC: O << "addc "; printOperand(MI, 0, MVT::i64); O << ", "; pr
intOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '
\n'; break;
case PPC::ADDE: O << "adde "; printOperand(MI, 0, MVT::i64); O << ", "; pr
intOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '
\n'; break;
...
Emit code like this:
case PPC::ADD:
case PPC::ADDC:
case PPC::ADDE:
...
switch (MI->getOpcode()) {
case PPC::ADD: O << "add "; break;
case PPC::ADDC: O << "addc "; break;
case PPC::ADDE: O << "adde "; break;
...
}
printOperand(MI, 0, MVT::i64);
O << ", ";
printOperand(MI, 1, MVT::i64);
O << ", ";
printOperand(MI, 2, MVT::i64);
O << "\n";
break;
This shrinks the PPC asm writer from 24785->15205 bytes (even though the new
asmwriter has much more whitespace than the old one), and the X86 printers shrink
quite a bit too. The important implication of this is that GCC no longer hits swap
when building the PPC backend in optimized mode. Thus this fixes PR448.
-Chris
llvm-svn: 19755
2005-01-23 02:38:13 +08:00
|
|
|
SimilarInsts.push_back(Insts[i-1]);
|
|
|
|
Insts.erase(Insts.begin()+i-1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-05-02 01:01:17 +08:00
|
|
|
O << " case " << FirstInst.CGI->Namespace << "::"
|
Implement factoring of instruction pattern strings. In particular, instead of
emitting code like this:
case PPC::ADD: O << "add "; printOperand(MI, 0, MVT::i64); O << ", "; prin
tOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '\n
'; break;
case PPC::ADDC: O << "addc "; printOperand(MI, 0, MVT::i64); O << ", "; pr
intOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '
\n'; break;
case PPC::ADDE: O << "adde "; printOperand(MI, 0, MVT::i64); O << ", "; pr
intOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '
\n'; break;
...
Emit code like this:
case PPC::ADD:
case PPC::ADDC:
case PPC::ADDE:
...
switch (MI->getOpcode()) {
case PPC::ADD: O << "add "; break;
case PPC::ADDC: O << "addc "; break;
case PPC::ADDE: O << "adde "; break;
...
}
printOperand(MI, 0, MVT::i64);
O << ", ";
printOperand(MI, 1, MVT::i64);
O << ", ";
printOperand(MI, 2, MVT::i64);
O << "\n";
break;
This shrinks the PPC asm writer from 24785->15205 bytes (even though the new
asmwriter has much more whitespace than the old one), and the X86 printers shrink
quite a bit too. The important implication of this is that GCC no longer hits swap
when building the PPC backend in optimized mode. Thus this fixes PR448.
-Chris
llvm-svn: 19755
2005-01-23 02:38:13 +08:00
|
|
|
<< FirstInst.CGI->TheDef->getName() << ":\n";
|
|
|
|
for (unsigned i = 0, e = SimilarInsts.size(); i != e; ++i)
|
2006-05-02 01:01:17 +08:00
|
|
|
O << " case " << SimilarInsts[i].CGI->Namespace << "::"
|
Implement factoring of instruction pattern strings. In particular, instead of
emitting code like this:
case PPC::ADD: O << "add "; printOperand(MI, 0, MVT::i64); O << ", "; prin
tOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '\n
'; break;
case PPC::ADDC: O << "addc "; printOperand(MI, 0, MVT::i64); O << ", "; pr
intOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '
\n'; break;
case PPC::ADDE: O << "adde "; printOperand(MI, 0, MVT::i64); O << ", "; pr
intOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '
\n'; break;
...
Emit code like this:
case PPC::ADD:
case PPC::ADDC:
case PPC::ADDE:
...
switch (MI->getOpcode()) {
case PPC::ADD: O << "add "; break;
case PPC::ADDC: O << "addc "; break;
case PPC::ADDE: O << "adde "; break;
...
}
printOperand(MI, 0, MVT::i64);
O << ", ";
printOperand(MI, 1, MVT::i64);
O << ", ";
printOperand(MI, 2, MVT::i64);
O << "\n";
break;
This shrinks the PPC asm writer from 24785->15205 bytes (even though the new
asmwriter has much more whitespace than the old one), and the X86 printers shrink
quite a bit too. The important implication of this is that GCC no longer hits swap
when building the PPC backend in optimized mode. Thus this fixes PR448.
-Chris
llvm-svn: 19755
2005-01-23 02:38:13 +08:00
|
|
|
<< SimilarInsts[i].CGI->TheDef->getName() << ":\n";
|
|
|
|
for (unsigned i = 0, e = FirstInst.Operands.size(); i != e; ++i) {
|
|
|
|
if (i != DifferingOperand) {
|
|
|
|
// If the operand is the same for all instructions, just print it.
|
2006-07-19 01:18:03 +08:00
|
|
|
O << " " << FirstInst.Operands[i].getCode();
|
Implement factoring of instruction pattern strings. In particular, instead of
emitting code like this:
case PPC::ADD: O << "add "; printOperand(MI, 0, MVT::i64); O << ", "; prin
tOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '\n
'; break;
case PPC::ADDC: O << "addc "; printOperand(MI, 0, MVT::i64); O << ", "; pr
intOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '
\n'; break;
case PPC::ADDE: O << "adde "; printOperand(MI, 0, MVT::i64); O << ", "; pr
intOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '
\n'; break;
...
Emit code like this:
case PPC::ADD:
case PPC::ADDC:
case PPC::ADDE:
...
switch (MI->getOpcode()) {
case PPC::ADD: O << "add "; break;
case PPC::ADDC: O << "addc "; break;
case PPC::ADDE: O << "adde "; break;
...
}
printOperand(MI, 0, MVT::i64);
O << ", ";
printOperand(MI, 1, MVT::i64);
O << ", ";
printOperand(MI, 2, MVT::i64);
O << "\n";
break;
This shrinks the PPC asm writer from 24785->15205 bytes (even though the new
asmwriter has much more whitespace than the old one), and the X86 printers shrink
quite a bit too. The important implication of this is that GCC no longer hits swap
when building the PPC backend in optimized mode. Thus this fixes PR448.
-Chris
llvm-svn: 19755
2005-01-23 02:38:13 +08:00
|
|
|
} else {
|
|
|
|
// If this is the operand that varies between all of the instructions,
|
|
|
|
// emit a switch for just this operand now.
|
|
|
|
O << " switch (MI->getOpcode()) {\n";
|
This is the final big of factoring. This shares cases in suboperand
differences, which means that identical instructions (after stripping off
the first literal string) do not run any different code at all. On the X86,
this turns this code:
switch (MI->getOpcode()) {
case X86::ADC32mi: printOperand(MI, 4, MVT::i32); break;
case X86::ADC32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::ADC32mr: printOperand(MI, 4, MVT::i32); break;
case X86::ADD32mi: printOperand(MI, 4, MVT::i32); break;
case X86::ADD32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::ADD32mr: printOperand(MI, 4, MVT::i32); break;
case X86::AND32mi: printOperand(MI, 4, MVT::i32); break;
case X86::AND32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::AND32mr: printOperand(MI, 4, MVT::i32); break;
case X86::CMP32mi: printOperand(MI, 4, MVT::i32); break;
case X86::CMP32mr: printOperand(MI, 4, MVT::i32); break;
case X86::MOV32mi: printOperand(MI, 4, MVT::i32); break;
case X86::MOV32mr: printOperand(MI, 4, MVT::i32); break;
case X86::OR32mi: printOperand(MI, 4, MVT::i32); break;
case X86::OR32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::OR32mr: printOperand(MI, 4, MVT::i32); break;
case X86::ROL32mi: printOperand(MI, 4, MVT::i8); break;
case X86::ROR32mi: printOperand(MI, 4, MVT::i8); break;
case X86::SAR32mi: printOperand(MI, 4, MVT::i8); break;
case X86::SBB32mi: printOperand(MI, 4, MVT::i32); break;
case X86::SBB32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::SBB32mr: printOperand(MI, 4, MVT::i32); break;
case X86::SHL32mi: printOperand(MI, 4, MVT::i8); break;
case X86::SHLD32mrCL: printOperand(MI, 4, MVT::i32); break;
case X86::SHR32mi: printOperand(MI, 4, MVT::i8); break;
case X86::SHRD32mrCL: printOperand(MI, 4, MVT::i32); break;
case X86::SUB32mi: printOperand(MI, 4, MVT::i32); break;
case X86::SUB32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::SUB32mr: printOperand(MI, 4, MVT::i32); break;
case X86::TEST32mi: printOperand(MI, 4, MVT::i32); break;
case X86::TEST32mr: printOperand(MI, 4, MVT::i32); break;
case X86::TEST8mi: printOperand(MI, 4, MVT::i8); break;
case X86::XCHG32mr: printOperand(MI, 4, MVT::i32); break;
case X86::XOR32mi: printOperand(MI, 4, MVT::i32); break;
case X86::XOR32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::XOR32mr: printOperand(MI, 4, MVT::i32); break;
}
into this:
switch (MI->getOpcode()) {
case X86::ADC32mi:
case X86::ADC32mr:
case X86::ADD32mi:
case X86::ADD32mr:
case X86::AND32mi:
case X86::AND32mr:
case X86::CMP32mi:
case X86::CMP32mr:
case X86::MOV32mi:
case X86::MOV32mr:
case X86::OR32mi:
case X86::OR32mr:
case X86::SBB32mi:
case X86::SBB32mr:
case X86::SHLD32mrCL:
case X86::SHRD32mrCL:
case X86::SUB32mi:
case X86::SUB32mr:
case X86::TEST32mi:
case X86::TEST32mr:
case X86::XCHG32mr:
case X86::XOR32mi:
case X86::XOR32mr: printOperand(MI, 4, MVT::i32); break;
case X86::ADC32mi8:
case X86::ADD32mi8:
case X86::AND32mi8:
case X86::OR32mi8:
case X86::ROL32mi:
case X86::ROR32mi:
case X86::SAR32mi:
case X86::SBB32mi8:
case X86::SHL32mi:
case X86::SHR32mi:
case X86::SUB32mi8:
case X86::TEST8mi:
case X86::XOR32mi8: printOperand(MI, 4, MVT::i8); break;
}
After this, the generated asmwriters look pretty much as though they were
generated by hand. This shrinks the X86 asmwriter.inc files from 55101->39669
and 55429->39551 bytes each, and PPC from 16766->12859 bytes.
llvm-svn: 19760
2005-01-23 04:31:17 +08:00
|
|
|
std::vector<std::pair<std::string, AsmWriterOperand> > OpsToPrint;
|
2006-05-02 01:01:17 +08:00
|
|
|
OpsToPrint.push_back(std::make_pair(FirstInst.CGI->Namespace + "::" +
|
This is the final big of factoring. This shares cases in suboperand
differences, which means that identical instructions (after stripping off
the first literal string) do not run any different code at all. On the X86,
this turns this code:
switch (MI->getOpcode()) {
case X86::ADC32mi: printOperand(MI, 4, MVT::i32); break;
case X86::ADC32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::ADC32mr: printOperand(MI, 4, MVT::i32); break;
case X86::ADD32mi: printOperand(MI, 4, MVT::i32); break;
case X86::ADD32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::ADD32mr: printOperand(MI, 4, MVT::i32); break;
case X86::AND32mi: printOperand(MI, 4, MVT::i32); break;
case X86::AND32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::AND32mr: printOperand(MI, 4, MVT::i32); break;
case X86::CMP32mi: printOperand(MI, 4, MVT::i32); break;
case X86::CMP32mr: printOperand(MI, 4, MVT::i32); break;
case X86::MOV32mi: printOperand(MI, 4, MVT::i32); break;
case X86::MOV32mr: printOperand(MI, 4, MVT::i32); break;
case X86::OR32mi: printOperand(MI, 4, MVT::i32); break;
case X86::OR32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::OR32mr: printOperand(MI, 4, MVT::i32); break;
case X86::ROL32mi: printOperand(MI, 4, MVT::i8); break;
case X86::ROR32mi: printOperand(MI, 4, MVT::i8); break;
case X86::SAR32mi: printOperand(MI, 4, MVT::i8); break;
case X86::SBB32mi: printOperand(MI, 4, MVT::i32); break;
case X86::SBB32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::SBB32mr: printOperand(MI, 4, MVT::i32); break;
case X86::SHL32mi: printOperand(MI, 4, MVT::i8); break;
case X86::SHLD32mrCL: printOperand(MI, 4, MVT::i32); break;
case X86::SHR32mi: printOperand(MI, 4, MVT::i8); break;
case X86::SHRD32mrCL: printOperand(MI, 4, MVT::i32); break;
case X86::SUB32mi: printOperand(MI, 4, MVT::i32); break;
case X86::SUB32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::SUB32mr: printOperand(MI, 4, MVT::i32); break;
case X86::TEST32mi: printOperand(MI, 4, MVT::i32); break;
case X86::TEST32mr: printOperand(MI, 4, MVT::i32); break;
case X86::TEST8mi: printOperand(MI, 4, MVT::i8); break;
case X86::XCHG32mr: printOperand(MI, 4, MVT::i32); break;
case X86::XOR32mi: printOperand(MI, 4, MVT::i32); break;
case X86::XOR32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::XOR32mr: printOperand(MI, 4, MVT::i32); break;
}
into this:
switch (MI->getOpcode()) {
case X86::ADC32mi:
case X86::ADC32mr:
case X86::ADD32mi:
case X86::ADD32mr:
case X86::AND32mi:
case X86::AND32mr:
case X86::CMP32mi:
case X86::CMP32mr:
case X86::MOV32mi:
case X86::MOV32mr:
case X86::OR32mi:
case X86::OR32mr:
case X86::SBB32mi:
case X86::SBB32mr:
case X86::SHLD32mrCL:
case X86::SHRD32mrCL:
case X86::SUB32mi:
case X86::SUB32mr:
case X86::TEST32mi:
case X86::TEST32mr:
case X86::XCHG32mr:
case X86::XOR32mi:
case X86::XOR32mr: printOperand(MI, 4, MVT::i32); break;
case X86::ADC32mi8:
case X86::ADD32mi8:
case X86::AND32mi8:
case X86::OR32mi8:
case X86::ROL32mi:
case X86::ROR32mi:
case X86::SAR32mi:
case X86::SBB32mi8:
case X86::SHL32mi:
case X86::SHR32mi:
case X86::SUB32mi8:
case X86::TEST8mi:
case X86::XOR32mi8: printOperand(MI, 4, MVT::i8); break;
}
After this, the generated asmwriters look pretty much as though they were
generated by hand. This shrinks the X86 asmwriter.inc files from 55101->39669
and 55429->39551 bytes each, and PPC from 16766->12859 bytes.
llvm-svn: 19760
2005-01-23 04:31:17 +08:00
|
|
|
FirstInst.CGI->TheDef->getName(),
|
|
|
|
FirstInst.Operands[i]));
|
2005-04-22 08:00:37 +08:00
|
|
|
|
Implement factoring of instruction pattern strings. In particular, instead of
emitting code like this:
case PPC::ADD: O << "add "; printOperand(MI, 0, MVT::i64); O << ", "; prin
tOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '\n
'; break;
case PPC::ADDC: O << "addc "; printOperand(MI, 0, MVT::i64); O << ", "; pr
intOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '
\n'; break;
case PPC::ADDE: O << "adde "; printOperand(MI, 0, MVT::i64); O << ", "; pr
intOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '
\n'; break;
...
Emit code like this:
case PPC::ADD:
case PPC::ADDC:
case PPC::ADDE:
...
switch (MI->getOpcode()) {
case PPC::ADD: O << "add "; break;
case PPC::ADDC: O << "addc "; break;
case PPC::ADDE: O << "adde "; break;
...
}
printOperand(MI, 0, MVT::i64);
O << ", ";
printOperand(MI, 1, MVT::i64);
O << ", ";
printOperand(MI, 2, MVT::i64);
O << "\n";
break;
This shrinks the PPC asm writer from 24785->15205 bytes (even though the new
asmwriter has much more whitespace than the old one), and the X86 printers shrink
quite a bit too. The important implication of this is that GCC no longer hits swap
when building the PPC backend in optimized mode. Thus this fixes PR448.
-Chris
llvm-svn: 19755
2005-01-23 02:38:13 +08:00
|
|
|
for (unsigned si = 0, e = SimilarInsts.size(); si != e; ++si) {
|
This is the final big of factoring. This shares cases in suboperand
differences, which means that identical instructions (after stripping off
the first literal string) do not run any different code at all. On the X86,
this turns this code:
switch (MI->getOpcode()) {
case X86::ADC32mi: printOperand(MI, 4, MVT::i32); break;
case X86::ADC32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::ADC32mr: printOperand(MI, 4, MVT::i32); break;
case X86::ADD32mi: printOperand(MI, 4, MVT::i32); break;
case X86::ADD32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::ADD32mr: printOperand(MI, 4, MVT::i32); break;
case X86::AND32mi: printOperand(MI, 4, MVT::i32); break;
case X86::AND32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::AND32mr: printOperand(MI, 4, MVT::i32); break;
case X86::CMP32mi: printOperand(MI, 4, MVT::i32); break;
case X86::CMP32mr: printOperand(MI, 4, MVT::i32); break;
case X86::MOV32mi: printOperand(MI, 4, MVT::i32); break;
case X86::MOV32mr: printOperand(MI, 4, MVT::i32); break;
case X86::OR32mi: printOperand(MI, 4, MVT::i32); break;
case X86::OR32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::OR32mr: printOperand(MI, 4, MVT::i32); break;
case X86::ROL32mi: printOperand(MI, 4, MVT::i8); break;
case X86::ROR32mi: printOperand(MI, 4, MVT::i8); break;
case X86::SAR32mi: printOperand(MI, 4, MVT::i8); break;
case X86::SBB32mi: printOperand(MI, 4, MVT::i32); break;
case X86::SBB32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::SBB32mr: printOperand(MI, 4, MVT::i32); break;
case X86::SHL32mi: printOperand(MI, 4, MVT::i8); break;
case X86::SHLD32mrCL: printOperand(MI, 4, MVT::i32); break;
case X86::SHR32mi: printOperand(MI, 4, MVT::i8); break;
case X86::SHRD32mrCL: printOperand(MI, 4, MVT::i32); break;
case X86::SUB32mi: printOperand(MI, 4, MVT::i32); break;
case X86::SUB32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::SUB32mr: printOperand(MI, 4, MVT::i32); break;
case X86::TEST32mi: printOperand(MI, 4, MVT::i32); break;
case X86::TEST32mr: printOperand(MI, 4, MVT::i32); break;
case X86::TEST8mi: printOperand(MI, 4, MVT::i8); break;
case X86::XCHG32mr: printOperand(MI, 4, MVT::i32); break;
case X86::XOR32mi: printOperand(MI, 4, MVT::i32); break;
case X86::XOR32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::XOR32mr: printOperand(MI, 4, MVT::i32); break;
}
into this:
switch (MI->getOpcode()) {
case X86::ADC32mi:
case X86::ADC32mr:
case X86::ADD32mi:
case X86::ADD32mr:
case X86::AND32mi:
case X86::AND32mr:
case X86::CMP32mi:
case X86::CMP32mr:
case X86::MOV32mi:
case X86::MOV32mr:
case X86::OR32mi:
case X86::OR32mr:
case X86::SBB32mi:
case X86::SBB32mr:
case X86::SHLD32mrCL:
case X86::SHRD32mrCL:
case X86::SUB32mi:
case X86::SUB32mr:
case X86::TEST32mi:
case X86::TEST32mr:
case X86::XCHG32mr:
case X86::XOR32mi:
case X86::XOR32mr: printOperand(MI, 4, MVT::i32); break;
case X86::ADC32mi8:
case X86::ADD32mi8:
case X86::AND32mi8:
case X86::OR32mi8:
case X86::ROL32mi:
case X86::ROR32mi:
case X86::SAR32mi:
case X86::SBB32mi8:
case X86::SHL32mi:
case X86::SHR32mi:
case X86::SUB32mi8:
case X86::TEST8mi:
case X86::XOR32mi8: printOperand(MI, 4, MVT::i8); break;
}
After this, the generated asmwriters look pretty much as though they were
generated by hand. This shrinks the X86 asmwriter.inc files from 55101->39669
and 55429->39551 bytes each, and PPC from 16766->12859 bytes.
llvm-svn: 19760
2005-01-23 04:31:17 +08:00
|
|
|
AsmWriterInst &AWI = SimilarInsts[si];
|
2006-05-02 01:01:17 +08:00
|
|
|
OpsToPrint.push_back(std::make_pair(AWI.CGI->Namespace+"::"+
|
This is the final big of factoring. This shares cases in suboperand
differences, which means that identical instructions (after stripping off
the first literal string) do not run any different code at all. On the X86,
this turns this code:
switch (MI->getOpcode()) {
case X86::ADC32mi: printOperand(MI, 4, MVT::i32); break;
case X86::ADC32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::ADC32mr: printOperand(MI, 4, MVT::i32); break;
case X86::ADD32mi: printOperand(MI, 4, MVT::i32); break;
case X86::ADD32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::ADD32mr: printOperand(MI, 4, MVT::i32); break;
case X86::AND32mi: printOperand(MI, 4, MVT::i32); break;
case X86::AND32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::AND32mr: printOperand(MI, 4, MVT::i32); break;
case X86::CMP32mi: printOperand(MI, 4, MVT::i32); break;
case X86::CMP32mr: printOperand(MI, 4, MVT::i32); break;
case X86::MOV32mi: printOperand(MI, 4, MVT::i32); break;
case X86::MOV32mr: printOperand(MI, 4, MVT::i32); break;
case X86::OR32mi: printOperand(MI, 4, MVT::i32); break;
case X86::OR32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::OR32mr: printOperand(MI, 4, MVT::i32); break;
case X86::ROL32mi: printOperand(MI, 4, MVT::i8); break;
case X86::ROR32mi: printOperand(MI, 4, MVT::i8); break;
case X86::SAR32mi: printOperand(MI, 4, MVT::i8); break;
case X86::SBB32mi: printOperand(MI, 4, MVT::i32); break;
case X86::SBB32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::SBB32mr: printOperand(MI, 4, MVT::i32); break;
case X86::SHL32mi: printOperand(MI, 4, MVT::i8); break;
case X86::SHLD32mrCL: printOperand(MI, 4, MVT::i32); break;
case X86::SHR32mi: printOperand(MI, 4, MVT::i8); break;
case X86::SHRD32mrCL: printOperand(MI, 4, MVT::i32); break;
case X86::SUB32mi: printOperand(MI, 4, MVT::i32); break;
case X86::SUB32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::SUB32mr: printOperand(MI, 4, MVT::i32); break;
case X86::TEST32mi: printOperand(MI, 4, MVT::i32); break;
case X86::TEST32mr: printOperand(MI, 4, MVT::i32); break;
case X86::TEST8mi: printOperand(MI, 4, MVT::i8); break;
case X86::XCHG32mr: printOperand(MI, 4, MVT::i32); break;
case X86::XOR32mi: printOperand(MI, 4, MVT::i32); break;
case X86::XOR32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::XOR32mr: printOperand(MI, 4, MVT::i32); break;
}
into this:
switch (MI->getOpcode()) {
case X86::ADC32mi:
case X86::ADC32mr:
case X86::ADD32mi:
case X86::ADD32mr:
case X86::AND32mi:
case X86::AND32mr:
case X86::CMP32mi:
case X86::CMP32mr:
case X86::MOV32mi:
case X86::MOV32mr:
case X86::OR32mi:
case X86::OR32mr:
case X86::SBB32mi:
case X86::SBB32mr:
case X86::SHLD32mrCL:
case X86::SHRD32mrCL:
case X86::SUB32mi:
case X86::SUB32mr:
case X86::TEST32mi:
case X86::TEST32mr:
case X86::XCHG32mr:
case X86::XOR32mi:
case X86::XOR32mr: printOperand(MI, 4, MVT::i32); break;
case X86::ADC32mi8:
case X86::ADD32mi8:
case X86::AND32mi8:
case X86::OR32mi8:
case X86::ROL32mi:
case X86::ROR32mi:
case X86::SAR32mi:
case X86::SBB32mi8:
case X86::SHL32mi:
case X86::SHR32mi:
case X86::SUB32mi8:
case X86::TEST8mi:
case X86::XOR32mi8: printOperand(MI, 4, MVT::i8); break;
}
After this, the generated asmwriters look pretty much as though they were
generated by hand. This shrinks the X86 asmwriter.inc files from 55101->39669
and 55429->39551 bytes each, and PPC from 16766->12859 bytes.
llvm-svn: 19760
2005-01-23 04:31:17 +08:00
|
|
|
AWI.CGI->TheDef->getName(),
|
|
|
|
AWI.Operands[i]));
|
Implement factoring of instruction pattern strings. In particular, instead of
emitting code like this:
case PPC::ADD: O << "add "; printOperand(MI, 0, MVT::i64); O << ", "; prin
tOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '\n
'; break;
case PPC::ADDC: O << "addc "; printOperand(MI, 0, MVT::i64); O << ", "; pr
intOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '
\n'; break;
case PPC::ADDE: O << "adde "; printOperand(MI, 0, MVT::i64); O << ", "; pr
intOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '
\n'; break;
...
Emit code like this:
case PPC::ADD:
case PPC::ADDC:
case PPC::ADDE:
...
switch (MI->getOpcode()) {
case PPC::ADD: O << "add "; break;
case PPC::ADDC: O << "addc "; break;
case PPC::ADDE: O << "adde "; break;
...
}
printOperand(MI, 0, MVT::i64);
O << ", ";
printOperand(MI, 1, MVT::i64);
O << ", ";
printOperand(MI, 2, MVT::i64);
O << "\n";
break;
This shrinks the PPC asm writer from 24785->15205 bytes (even though the new
asmwriter has much more whitespace than the old one), and the X86 printers shrink
quite a bit too. The important implication of this is that GCC no longer hits swap
when building the PPC backend in optimized mode. Thus this fixes PR448.
-Chris
llvm-svn: 19755
2005-01-23 02:38:13 +08:00
|
|
|
}
|
This is the final big of factoring. This shares cases in suboperand
differences, which means that identical instructions (after stripping off
the first literal string) do not run any different code at all. On the X86,
this turns this code:
switch (MI->getOpcode()) {
case X86::ADC32mi: printOperand(MI, 4, MVT::i32); break;
case X86::ADC32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::ADC32mr: printOperand(MI, 4, MVT::i32); break;
case X86::ADD32mi: printOperand(MI, 4, MVT::i32); break;
case X86::ADD32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::ADD32mr: printOperand(MI, 4, MVT::i32); break;
case X86::AND32mi: printOperand(MI, 4, MVT::i32); break;
case X86::AND32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::AND32mr: printOperand(MI, 4, MVT::i32); break;
case X86::CMP32mi: printOperand(MI, 4, MVT::i32); break;
case X86::CMP32mr: printOperand(MI, 4, MVT::i32); break;
case X86::MOV32mi: printOperand(MI, 4, MVT::i32); break;
case X86::MOV32mr: printOperand(MI, 4, MVT::i32); break;
case X86::OR32mi: printOperand(MI, 4, MVT::i32); break;
case X86::OR32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::OR32mr: printOperand(MI, 4, MVT::i32); break;
case X86::ROL32mi: printOperand(MI, 4, MVT::i8); break;
case X86::ROR32mi: printOperand(MI, 4, MVT::i8); break;
case X86::SAR32mi: printOperand(MI, 4, MVT::i8); break;
case X86::SBB32mi: printOperand(MI, 4, MVT::i32); break;
case X86::SBB32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::SBB32mr: printOperand(MI, 4, MVT::i32); break;
case X86::SHL32mi: printOperand(MI, 4, MVT::i8); break;
case X86::SHLD32mrCL: printOperand(MI, 4, MVT::i32); break;
case X86::SHR32mi: printOperand(MI, 4, MVT::i8); break;
case X86::SHRD32mrCL: printOperand(MI, 4, MVT::i32); break;
case X86::SUB32mi: printOperand(MI, 4, MVT::i32); break;
case X86::SUB32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::SUB32mr: printOperand(MI, 4, MVT::i32); break;
case X86::TEST32mi: printOperand(MI, 4, MVT::i32); break;
case X86::TEST32mr: printOperand(MI, 4, MVT::i32); break;
case X86::TEST8mi: printOperand(MI, 4, MVT::i8); break;
case X86::XCHG32mr: printOperand(MI, 4, MVT::i32); break;
case X86::XOR32mi: printOperand(MI, 4, MVT::i32); break;
case X86::XOR32mi8: printOperand(MI, 4, MVT::i8); break;
case X86::XOR32mr: printOperand(MI, 4, MVT::i32); break;
}
into this:
switch (MI->getOpcode()) {
case X86::ADC32mi:
case X86::ADC32mr:
case X86::ADD32mi:
case X86::ADD32mr:
case X86::AND32mi:
case X86::AND32mr:
case X86::CMP32mi:
case X86::CMP32mr:
case X86::MOV32mi:
case X86::MOV32mr:
case X86::OR32mi:
case X86::OR32mr:
case X86::SBB32mi:
case X86::SBB32mr:
case X86::SHLD32mrCL:
case X86::SHRD32mrCL:
case X86::SUB32mi:
case X86::SUB32mr:
case X86::TEST32mi:
case X86::TEST32mr:
case X86::XCHG32mr:
case X86::XOR32mi:
case X86::XOR32mr: printOperand(MI, 4, MVT::i32); break;
case X86::ADC32mi8:
case X86::ADD32mi8:
case X86::AND32mi8:
case X86::OR32mi8:
case X86::ROL32mi:
case X86::ROR32mi:
case X86::SAR32mi:
case X86::SBB32mi8:
case X86::SHL32mi:
case X86::SHR32mi:
case X86::SUB32mi8:
case X86::TEST8mi:
case X86::XOR32mi8: printOperand(MI, 4, MVT::i8); break;
}
After this, the generated asmwriters look pretty much as though they were
generated by hand. This shrinks the X86 asmwriter.inc files from 55101->39669
and 55429->39551 bytes each, and PPC from 16766->12859 bytes.
llvm-svn: 19760
2005-01-23 04:31:17 +08:00
|
|
|
std::reverse(OpsToPrint.begin(), OpsToPrint.end());
|
|
|
|
while (!OpsToPrint.empty())
|
|
|
|
PrintCases(OpsToPrint, O);
|
Implement factoring of instruction pattern strings. In particular, instead of
emitting code like this:
case PPC::ADD: O << "add "; printOperand(MI, 0, MVT::i64); O << ", "; prin
tOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '\n
'; break;
case PPC::ADDC: O << "addc "; printOperand(MI, 0, MVT::i64); O << ", "; pr
intOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '
\n'; break;
case PPC::ADDE: O << "adde "; printOperand(MI, 0, MVT::i64); O << ", "; pr
intOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '
\n'; break;
...
Emit code like this:
case PPC::ADD:
case PPC::ADDC:
case PPC::ADDE:
...
switch (MI->getOpcode()) {
case PPC::ADD: O << "add "; break;
case PPC::ADDC: O << "addc "; break;
case PPC::ADDE: O << "adde "; break;
...
}
printOperand(MI, 0, MVT::i64);
O << ", ";
printOperand(MI, 1, MVT::i64);
O << ", ";
printOperand(MI, 2, MVT::i64);
O << "\n";
break;
This shrinks the PPC asm writer from 24785->15205 bytes (even though the new
asmwriter has much more whitespace than the old one), and the X86 printers shrink
quite a bit too. The important implication of this is that GCC no longer hits swap
when building the PPC backend in optimized mode. Thus this fixes PR448.
-Chris
llvm-svn: 19755
2005-01-23 02:38:13 +08:00
|
|
|
O << " }";
|
|
|
|
}
|
|
|
|
O << "\n";
|
|
|
|
}
|
|
|
|
O << " break;\n";
|
|
|
|
}
|
2005-01-23 01:32:42 +08:00
|
|
|
|
2006-07-19 01:18:03 +08:00
|
|
|
void AsmWriterEmitter::
|
|
|
|
FindUniqueOperandCommands(std::vector<std::string> &UniqueOperandCommands,
|
2006-07-19 02:28:27 +08:00
|
|
|
std::vector<unsigned> &InstIdxs,
|
|
|
|
std::vector<unsigned> &InstOpsUsed) const {
|
2006-07-19 03:27:30 +08:00
|
|
|
InstIdxs.assign(NumberedInstructions.size(), ~0U);
|
2006-07-19 01:18:03 +08:00
|
|
|
|
|
|
|
// This vector parallels UniqueOperandCommands, keeping track of which
|
|
|
|
// instructions each case are used for. It is a comma separated string of
|
|
|
|
// enums.
|
|
|
|
std::vector<std::string> InstrsForCase;
|
|
|
|
InstrsForCase.resize(UniqueOperandCommands.size());
|
2006-07-19 02:28:27 +08:00
|
|
|
InstOpsUsed.assign(UniqueOperandCommands.size(), 0);
|
2006-07-19 01:18:03 +08:00
|
|
|
|
|
|
|
for (unsigned i = 0, e = NumberedInstructions.size(); i != e; ++i) {
|
|
|
|
const AsmWriterInst *Inst = getAsmWriterInstByID(i);
|
2008-07-01 08:05:16 +08:00
|
|
|
if (Inst == 0) continue; // PHI, INLINEASM, DBG_LABEL, etc.
|
2006-07-19 01:18:03 +08:00
|
|
|
|
|
|
|
std::string Command;
|
2006-07-19 01:56:07 +08:00
|
|
|
if (Inst->Operands.empty())
|
2006-07-19 01:18:03 +08:00
|
|
|
continue; // Instruction already done.
|
2006-07-19 01:50:22 +08:00
|
|
|
|
2006-07-19 01:56:07 +08:00
|
|
|
Command = " " + Inst->Operands[0].getCode() + "\n";
|
2006-07-19 01:50:22 +08:00
|
|
|
|
|
|
|
// If this is the last operand, emit a return.
|
2009-08-08 08:05:42 +08:00
|
|
|
if (Inst->Operands.size() == 1)
|
2009-08-08 09:32:19 +08:00
|
|
|
Command += " return;\n";
|
2006-07-19 01:18:03 +08:00
|
|
|
|
|
|
|
// Check to see if we already have 'Command' in UniqueOperandCommands.
|
|
|
|
// If not, add it.
|
|
|
|
bool FoundIt = false;
|
|
|
|
for (unsigned idx = 0, e = UniqueOperandCommands.size(); idx != e; ++idx)
|
|
|
|
if (UniqueOperandCommands[idx] == Command) {
|
|
|
|
InstIdxs[i] = idx;
|
|
|
|
InstrsForCase[idx] += ", ";
|
|
|
|
InstrsForCase[idx] += Inst->CGI->TheDef->getName();
|
|
|
|
FoundIt = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
if (!FoundIt) {
|
|
|
|
InstIdxs[i] = UniqueOperandCommands.size();
|
|
|
|
UniqueOperandCommands.push_back(Command);
|
|
|
|
InstrsForCase.push_back(Inst->CGI->TheDef->getName());
|
2006-07-19 02:28:27 +08:00
|
|
|
|
|
|
|
// This command matches one operand so far.
|
|
|
|
InstOpsUsed.push_back(1);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// For each entry of UniqueOperandCommands, there is a set of instructions
|
|
|
|
// that uses it. If the next command of all instructions in the set are
|
|
|
|
// identical, fold it into the command.
|
|
|
|
for (unsigned CommandIdx = 0, e = UniqueOperandCommands.size();
|
|
|
|
CommandIdx != e; ++CommandIdx) {
|
|
|
|
|
|
|
|
for (unsigned Op = 1; ; ++Op) {
|
|
|
|
// Scan for the first instruction in the set.
|
|
|
|
std::vector<unsigned>::iterator NIT =
|
|
|
|
std::find(InstIdxs.begin(), InstIdxs.end(), CommandIdx);
|
|
|
|
if (NIT == InstIdxs.end()) break; // No commonality.
|
|
|
|
|
|
|
|
// If this instruction has no more operands, we isn't anything to merge
|
|
|
|
// into this command.
|
|
|
|
const AsmWriterInst *FirstInst =
|
|
|
|
getAsmWriterInstByID(NIT-InstIdxs.begin());
|
|
|
|
if (!FirstInst || FirstInst->Operands.size() == Op)
|
|
|
|
break;
|
|
|
|
|
|
|
|
// Otherwise, scan to see if all of the other instructions in this command
|
|
|
|
// set share the operand.
|
|
|
|
bool AllSame = true;
|
2009-07-30 04:10:24 +08:00
|
|
|
// Keep track of the maximum, number of operands or any
|
|
|
|
// instruction we see in the group.
|
|
|
|
size_t MaxSize = FirstInst->Operands.size();
|
|
|
|
|
2006-07-19 02:28:27 +08:00
|
|
|
for (NIT = std::find(NIT+1, InstIdxs.end(), CommandIdx);
|
|
|
|
NIT != InstIdxs.end();
|
|
|
|
NIT = std::find(NIT+1, InstIdxs.end(), CommandIdx)) {
|
|
|
|
// Okay, found another instruction in this command set. If the operand
|
|
|
|
// matches, we're ok, otherwise bail out.
|
|
|
|
const AsmWriterInst *OtherInst =
|
|
|
|
getAsmWriterInstByID(NIT-InstIdxs.begin());
|
2009-07-30 04:10:24 +08:00
|
|
|
|
|
|
|
if (OtherInst &&
|
|
|
|
OtherInst->Operands.size() > FirstInst->Operands.size())
|
|
|
|
MaxSize = std::max(MaxSize, OtherInst->Operands.size());
|
|
|
|
|
2006-07-19 02:28:27 +08:00
|
|
|
if (!OtherInst || OtherInst->Operands.size() == Op ||
|
|
|
|
OtherInst->Operands[Op] != FirstInst->Operands[Op]) {
|
|
|
|
AllSame = false;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (!AllSame) break;
|
|
|
|
|
|
|
|
// Okay, everything in this command set has the same next operand. Add it
|
|
|
|
// to UniqueOperandCommands and remember that it was consumed.
|
|
|
|
std::string Command = " " + FirstInst->Operands[Op].getCode() + "\n";
|
|
|
|
|
|
|
|
// If this is the last operand, emit a return after the code.
|
2009-07-30 04:10:24 +08:00
|
|
|
if (FirstInst->Operands.size() == Op+1 &&
|
|
|
|
// Don't early-out too soon. Other instructions in this
|
|
|
|
// group may have more operands.
|
|
|
|
FirstInst->Operands.size() == MaxSize) {
|
2009-08-08 09:32:19 +08:00
|
|
|
Command += " return;\n";
|
2009-07-30 04:10:24 +08:00
|
|
|
}
|
2006-07-19 02:28:27 +08:00
|
|
|
|
|
|
|
UniqueOperandCommands[CommandIdx] += Command;
|
|
|
|
InstOpsUsed[CommandIdx]++;
|
2006-07-19 01:18:03 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Prepend some of the instructions each case is used for onto the case val.
|
|
|
|
for (unsigned i = 0, e = InstrsForCase.size(); i != e; ++i) {
|
|
|
|
std::string Instrs = InstrsForCase[i];
|
|
|
|
if (Instrs.size() > 70) {
|
|
|
|
Instrs.erase(Instrs.begin()+70, Instrs.end());
|
|
|
|
Instrs += "...";
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!Instrs.empty())
|
|
|
|
UniqueOperandCommands[i] = " // " + Instrs + "\n" +
|
|
|
|
UniqueOperandCommands[i];
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2009-07-03 08:10:29 +08:00
|
|
|
void AsmWriterEmitter::run(raw_ostream &O) {
|
2004-08-01 13:59:33 +08:00
|
|
|
EmitSourceFileHeader("Assembly Writer Source Fragment", O);
|
|
|
|
|
|
|
|
CodeGenTarget Target;
|
2004-08-15 06:50:53 +08:00
|
|
|
Record *AsmWriter = Target.getAsmWriter();
|
2004-10-04 04:19:02 +08:00
|
|
|
std::string ClassName = AsmWriter->getValueAsString("AsmWriterClassName");
|
2004-08-15 06:50:53 +08:00
|
|
|
|
2004-08-01 13:59:33 +08:00
|
|
|
O <<
|
|
|
|
"/// printInstruction - This method is automatically generated by tablegen\n"
|
|
|
|
"/// from the instruction set description. This method returns true if the\n"
|
|
|
|
"/// machine instruction was sufficiently described to print it, otherwise\n"
|
|
|
|
"/// it returns false.\n"
|
2009-08-08 09:32:19 +08:00
|
|
|
"void " << Target.getName() << ClassName
|
2004-08-15 06:50:53 +08:00
|
|
|
<< "::printInstruction(const MachineInstr *MI) {\n";
|
2004-08-01 13:59:33 +08:00
|
|
|
|
2005-01-23 01:40:38 +08:00
|
|
|
std::vector<AsmWriterInst> Instructions;
|
|
|
|
|
2004-08-01 13:59:33 +08:00
|
|
|
for (CodeGenTarget::inst_iterator I = Target.inst_begin(),
|
|
|
|
E = Target.inst_end(); I != E; ++I)
|
2005-01-23 01:40:38 +08:00
|
|
|
if (!I->second.AsmString.empty())
|
2009-08-08 07:13:38 +08:00
|
|
|
Instructions.push_back(AsmWriterInst(I->second, AsmWriter));
|
2005-01-23 01:40:38 +08:00
|
|
|
|
2006-07-19 01:18:03 +08:00
|
|
|
// Get the instruction numbering.
|
2006-01-27 10:10:50 +08:00
|
|
|
Target.getInstructionsByEnumValue(NumberedInstructions);
|
|
|
|
|
2006-07-15 06:59:11 +08:00
|
|
|
// Compute the CodeGenInstruction -> AsmWriterInst mapping. Note that not
|
|
|
|
// all machine instructions are necessarily being printed, so there may be
|
|
|
|
// target instructions not in this map.
|
|
|
|
for (unsigned i = 0, e = Instructions.size(); i != e; ++i)
|
|
|
|
CGIAWIMap.insert(std::make_pair(Instructions[i].CGI, &Instructions[i]));
|
|
|
|
|
|
|
|
// Build an aggregate string, and build a table of offsets into it.
|
|
|
|
std::map<std::string, unsigned> StringOffset;
|
|
|
|
std::string AggregateString;
|
2006-09-28 00:44:09 +08:00
|
|
|
AggregateString.push_back(0); // "\0"
|
|
|
|
AggregateString.push_back(0); // "\0"
|
2006-07-15 06:59:11 +08:00
|
|
|
|
2006-09-28 00:44:09 +08:00
|
|
|
/// OpcodeInfo - This encodes the index of the string to use for the first
|
2006-07-19 01:32:27 +08:00
|
|
|
/// chunk of the output as well as indices used for operand printing.
|
|
|
|
std::vector<unsigned> OpcodeInfo;
|
2006-07-19 01:18:03 +08:00
|
|
|
|
2006-07-19 01:32:27 +08:00
|
|
|
unsigned MaxStringIdx = 0;
|
2006-07-15 06:59:11 +08:00
|
|
|
for (unsigned i = 0, e = NumberedInstructions.size(); i != e; ++i) {
|
|
|
|
AsmWriterInst *AWI = CGIAWIMap[NumberedInstructions[i]];
|
|
|
|
unsigned Idx;
|
2006-07-19 09:39:06 +08:00
|
|
|
if (AWI == 0) {
|
2006-07-15 06:59:11 +08:00
|
|
|
// Something not handled by the asmwriter printer.
|
|
|
|
Idx = 0;
|
2006-07-19 09:39:06 +08:00
|
|
|
} else if (AWI->Operands[0].OperandType !=
|
|
|
|
AsmWriterOperand::isLiteralTextOperand ||
|
|
|
|
AWI->Operands[0].Str.empty()) {
|
|
|
|
// Something handled by the asmwriter printer, but with no leading string.
|
|
|
|
Idx = 1;
|
2006-07-15 06:59:11 +08:00
|
|
|
} else {
|
|
|
|
unsigned &Entry = StringOffset[AWI->Operands[0].Str];
|
|
|
|
if (Entry == 0) {
|
|
|
|
// Add the string to the aggregate if this is the first time found.
|
2006-07-19 01:32:27 +08:00
|
|
|
MaxStringIdx = Entry = AggregateString.size();
|
2006-07-15 06:59:11 +08:00
|
|
|
std::string Str = AWI->Operands[0].Str;
|
|
|
|
UnescapeString(Str);
|
|
|
|
AggregateString += Str;
|
|
|
|
AggregateString += '\0';
|
|
|
|
}
|
|
|
|
Idx = Entry;
|
|
|
|
|
|
|
|
// Nuke the string from the operand list. It is now handled!
|
|
|
|
AWI->Operands.erase(AWI->Operands.begin());
|
|
|
|
}
|
2006-07-19 01:32:27 +08:00
|
|
|
OpcodeInfo.push_back(Idx);
|
2006-07-19 01:18:03 +08:00
|
|
|
}
|
|
|
|
|
2006-07-19 01:32:27 +08:00
|
|
|
// Figure out how many bits we used for the string index.
|
2008-04-10 00:24:11 +08:00
|
|
|
unsigned AsmStrBits = Log2_32_Ceil(MaxStringIdx+1);
|
2006-07-19 01:32:27 +08:00
|
|
|
|
2006-07-19 01:18:03 +08:00
|
|
|
// To reduce code size, we compactify common instructions into a few bits
|
|
|
|
// in the opcode-indexed table.
|
2006-07-19 01:38:46 +08:00
|
|
|
unsigned BitsLeft = 32-AsmStrBits;
|
2006-07-19 01:18:03 +08:00
|
|
|
|
|
|
|
std::vector<std::vector<std::string> > TableDrivenOperandPrinters;
|
|
|
|
|
2006-07-19 01:56:07 +08:00
|
|
|
bool isFirst = true;
|
|
|
|
while (1) {
|
2006-07-19 01:18:03 +08:00
|
|
|
std::vector<std::string> UniqueOperandCommands;
|
|
|
|
|
2006-07-19 09:39:06 +08:00
|
|
|
// For the first operand check, add a default value for instructions with
|
|
|
|
// just opcode strings to use.
|
2006-07-19 01:56:07 +08:00
|
|
|
if (isFirst) {
|
2009-08-08 09:32:19 +08:00
|
|
|
UniqueOperandCommands.push_back(" return;\n");
|
2006-07-19 01:56:07 +08:00
|
|
|
isFirst = false;
|
|
|
|
}
|
2009-07-30 04:10:24 +08:00
|
|
|
|
2006-07-19 01:18:03 +08:00
|
|
|
std::vector<unsigned> InstIdxs;
|
2006-07-19 02:28:27 +08:00
|
|
|
std::vector<unsigned> NumInstOpsHandled;
|
|
|
|
FindUniqueOperandCommands(UniqueOperandCommands, InstIdxs,
|
|
|
|
NumInstOpsHandled);
|
2006-07-19 01:18:03 +08:00
|
|
|
|
|
|
|
// If we ran out of operands to print, we're done.
|
|
|
|
if (UniqueOperandCommands.empty()) break;
|
|
|
|
|
|
|
|
// Compute the number of bits we need to represent these cases, this is
|
|
|
|
// ceil(log2(numentries)).
|
|
|
|
unsigned NumBits = Log2_32_Ceil(UniqueOperandCommands.size());
|
|
|
|
|
|
|
|
// If we don't have enough bits for this operand, don't include it.
|
|
|
|
if (NumBits > BitsLeft) {
|
2006-12-08 06:21:48 +08:00
|
|
|
DOUT << "Not enough bits to densely encode " << NumBits
|
|
|
|
<< " more bits\n";
|
2006-07-19 01:18:03 +08:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Otherwise, we can include this in the initial lookup table. Add it in.
|
|
|
|
BitsLeft -= NumBits;
|
|
|
|
for (unsigned i = 0, e = InstIdxs.size(); i != e; ++i)
|
2006-07-19 03:27:30 +08:00
|
|
|
if (InstIdxs[i] != ~0U)
|
|
|
|
OpcodeInfo[i] |= InstIdxs[i] << (BitsLeft+AsmStrBits);
|
2006-07-19 01:18:03 +08:00
|
|
|
|
2006-07-19 01:56:07 +08:00
|
|
|
// Remove the info about this operand.
|
|
|
|
for (unsigned i = 0, e = NumberedInstructions.size(); i != e; ++i) {
|
|
|
|
if (AsmWriterInst *Inst = getAsmWriterInstByID(i))
|
2006-07-19 02:28:27 +08:00
|
|
|
if (!Inst->Operands.empty()) {
|
|
|
|
unsigned NumOps = NumInstOpsHandled[InstIdxs[i]];
|
2006-07-19 03:06:01 +08:00
|
|
|
assert(NumOps <= Inst->Operands.size() &&
|
|
|
|
"Can't remove this many ops!");
|
2006-07-19 02:28:27 +08:00
|
|
|
Inst->Operands.erase(Inst->Operands.begin(),
|
|
|
|
Inst->Operands.begin()+NumOps);
|
|
|
|
}
|
2006-07-19 01:56:07 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
// Remember the handlers for this set of operands.
|
2006-07-19 01:18:03 +08:00
|
|
|
TableDrivenOperandPrinters.push_back(UniqueOperandCommands);
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
|
2006-07-19 01:32:27 +08:00
|
|
|
O<<" static const unsigned OpInfo[] = {\n";
|
2006-07-19 01:18:03 +08:00
|
|
|
for (unsigned i = 0, e = NumberedInstructions.size(); i != e; ++i) {
|
2006-07-19 01:38:46 +08:00
|
|
|
O << " " << OpcodeInfo[i] << "U,\t// "
|
2006-07-19 01:32:27 +08:00
|
|
|
<< NumberedInstructions[i]->TheDef->getName() << "\n";
|
2006-07-15 06:59:11 +08:00
|
|
|
}
|
2006-07-19 01:18:03 +08:00
|
|
|
// Add a dummy entry so the array init doesn't end with a comma.
|
2006-07-19 01:32:27 +08:00
|
|
|
O << " 0U\n";
|
2006-07-15 06:59:11 +08:00
|
|
|
O << " };\n\n";
|
|
|
|
|
|
|
|
// Emit the string itself.
|
|
|
|
O << " const char *AsmStrs = \n \"";
|
|
|
|
unsigned CharsPrinted = 0;
|
|
|
|
EscapeString(AggregateString);
|
|
|
|
for (unsigned i = 0, e = AggregateString.size(); i != e; ++i) {
|
|
|
|
if (CharsPrinted > 70) {
|
|
|
|
O << "\"\n \"";
|
|
|
|
CharsPrinted = 0;
|
|
|
|
}
|
|
|
|
O << AggregateString[i];
|
|
|
|
++CharsPrinted;
|
|
|
|
|
|
|
|
// Print escape sequences all together.
|
|
|
|
if (AggregateString[i] == '\\') {
|
|
|
|
assert(i+1 < AggregateString.size() && "Incomplete escape sequence!");
|
|
|
|
if (isdigit(AggregateString[i+1])) {
|
|
|
|
assert(isdigit(AggregateString[i+2]) && isdigit(AggregateString[i+3]) &&
|
|
|
|
"Expected 3 digit octal escape!");
|
|
|
|
O << AggregateString[++i];
|
|
|
|
O << AggregateString[++i];
|
|
|
|
O << AggregateString[++i];
|
|
|
|
CharsPrinted += 3;
|
2005-01-23 03:22:23 +08:00
|
|
|
} else {
|
2006-07-15 06:59:11 +08:00
|
|
|
O << AggregateString[++i];
|
|
|
|
++CharsPrinted;
|
2005-01-23 03:22:23 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
2006-07-15 06:59:11 +08:00
|
|
|
O << "\";\n\n";
|
|
|
|
|
2009-05-07 21:55:51 +08:00
|
|
|
O << " processDebugLoc(MI->getDebugLoc());\n\n";
|
2009-02-19 07:12:06 +08:00
|
|
|
|
2009-06-20 07:57:53 +08:00
|
|
|
O << "\n#ifndef NO_ASM_WRITER_BOILERPLATE\n";
|
|
|
|
|
2006-07-19 01:18:03 +08:00
|
|
|
O << " if (MI->getOpcode() == TargetInstrInfo::INLINEASM) {\n"
|
2008-02-02 16:39:46 +08:00
|
|
|
<< " O << \"\\t\";\n"
|
2006-07-19 01:18:03 +08:00
|
|
|
<< " printInlineAsm(MI);\n"
|
2009-08-08 09:32:19 +08:00
|
|
|
<< " return;\n"
|
2008-07-01 08:05:16 +08:00
|
|
|
<< " } else if (MI->isLabel()) {\n"
|
2007-01-27 01:29:20 +08:00
|
|
|
<< " printLabel(MI);\n"
|
2009-08-08 09:32:19 +08:00
|
|
|
<< " return;\n"
|
2008-03-15 08:03:38 +08:00
|
|
|
<< " } else if (MI->getOpcode() == TargetInstrInfo::IMPLICIT_DEF) {\n"
|
|
|
|
<< " printImplicitDef(MI);\n"
|
2009-08-08 09:32:19 +08:00
|
|
|
<< " return;\n"
|
2006-07-19 01:18:03 +08:00
|
|
|
<< " }\n\n";
|
2009-06-20 07:57:53 +08:00
|
|
|
|
|
|
|
O << "\n#endif\n";
|
|
|
|
|
2008-02-02 16:39:46 +08:00
|
|
|
O << " O << \"\\t\";\n\n";
|
|
|
|
|
2006-07-15 06:59:11 +08:00
|
|
|
O << " // Emit the opcode for the instruction.\n"
|
2006-07-19 01:32:27 +08:00
|
|
|
<< " unsigned Bits = OpInfo[MI->getOpcode()];\n"
|
2009-08-08 09:32:19 +08:00
|
|
|
<< " assert(Bits != 0 && \"Cannot print this instruction.\");\n"
|
2009-08-06 05:00:52 +08:00
|
|
|
<< " O << AsmStrs+(Bits & " << (1 << AsmStrBits)-1 << ");\n\n";
|
|
|
|
|
2006-07-19 01:18:03 +08:00
|
|
|
// Output the table driven operand information.
|
2006-07-19 01:38:46 +08:00
|
|
|
BitsLeft = 32-AsmStrBits;
|
2006-07-19 01:18:03 +08:00
|
|
|
for (unsigned i = 0, e = TableDrivenOperandPrinters.size(); i != e; ++i) {
|
|
|
|
std::vector<std::string> &Commands = TableDrivenOperandPrinters[i];
|
2005-01-23 03:22:23 +08:00
|
|
|
|
2006-07-19 01:18:03 +08:00
|
|
|
// Compute the number of bits we need to represent these cases, this is
|
|
|
|
// ceil(log2(numentries)).
|
|
|
|
unsigned NumBits = Log2_32_Ceil(Commands.size());
|
|
|
|
assert(NumBits <= BitsLeft && "consistency error");
|
|
|
|
|
|
|
|
// Emit code to extract this field from Bits.
|
|
|
|
BitsLeft -= NumBits;
|
|
|
|
|
|
|
|
O << "\n // Fragment " << i << " encoded into " << NumBits
|
2006-07-19 01:43:54 +08:00
|
|
|
<< " bits for " << Commands.size() << " unique commands.\n";
|
2006-07-19 01:18:03 +08:00
|
|
|
|
2006-07-19 02:28:27 +08:00
|
|
|
if (Commands.size() == 2) {
|
2006-07-19 01:43:54 +08:00
|
|
|
// Emit two possibilitys with if/else.
|
|
|
|
O << " if ((Bits >> " << (BitsLeft+AsmStrBits) << ") & "
|
|
|
|
<< ((1 << NumBits)-1) << ") {\n"
|
|
|
|
<< Commands[1]
|
|
|
|
<< " } else {\n"
|
|
|
|
<< Commands[0]
|
|
|
|
<< " }\n\n";
|
|
|
|
} else {
|
|
|
|
O << " switch ((Bits >> " << (BitsLeft+AsmStrBits) << ") & "
|
|
|
|
<< ((1 << NumBits)-1) << ") {\n"
|
|
|
|
<< " default: // unreachable.\n";
|
|
|
|
|
|
|
|
// Print out all the cases.
|
|
|
|
for (unsigned i = 0, e = Commands.size(); i != e; ++i) {
|
|
|
|
O << " case " << i << ":\n";
|
|
|
|
O << Commands[i];
|
|
|
|
O << " break;\n";
|
|
|
|
}
|
|
|
|
O << " }\n\n";
|
2006-07-19 01:18:03 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-07-19 01:56:07 +08:00
|
|
|
// Okay, delete instructions with no operand info left.
|
2006-07-19 01:18:03 +08:00
|
|
|
for (unsigned i = 0, e = Instructions.size(); i != e; ++i) {
|
|
|
|
// Entire instruction has been emitted?
|
|
|
|
AsmWriterInst &Inst = Instructions[i];
|
2006-07-19 01:56:07 +08:00
|
|
|
if (Inst.Operands.empty()) {
|
2006-07-19 01:18:03 +08:00
|
|
|
Instructions.erase(Instructions.begin()+i);
|
2006-07-19 01:56:07 +08:00
|
|
|
--i; --e;
|
2006-07-19 01:18:03 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
|
|
|
|
// Because this is a vector, we want to emit from the end. Reverse all of the
|
Implement factoring of instruction pattern strings. In particular, instead of
emitting code like this:
case PPC::ADD: O << "add "; printOperand(MI, 0, MVT::i64); O << ", "; prin
tOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '\n
'; break;
case PPC::ADDC: O << "addc "; printOperand(MI, 0, MVT::i64); O << ", "; pr
intOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '
\n'; break;
case PPC::ADDE: O << "adde "; printOperand(MI, 0, MVT::i64); O << ", "; pr
intOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '
\n'; break;
...
Emit code like this:
case PPC::ADD:
case PPC::ADDC:
case PPC::ADDE:
...
switch (MI->getOpcode()) {
case PPC::ADD: O << "add "; break;
case PPC::ADDC: O << "addc "; break;
case PPC::ADDE: O << "adde "; break;
...
}
printOperand(MI, 0, MVT::i64);
O << ", ";
printOperand(MI, 1, MVT::i64);
O << ", ";
printOperand(MI, 2, MVT::i64);
O << "\n";
break;
This shrinks the PPC asm writer from 24785->15205 bytes (even though the new
asmwriter has much more whitespace than the old one), and the X86 printers shrink
quite a bit too. The important implication of this is that GCC no longer hits swap
when building the PPC backend in optimized mode. Thus this fixes PR448.
-Chris
llvm-svn: 19755
2005-01-23 02:38:13 +08:00
|
|
|
// elements in the vector.
|
|
|
|
std::reverse(Instructions.begin(), Instructions.end());
|
2006-07-19 01:18:03 +08:00
|
|
|
|
2006-07-19 01:38:46 +08:00
|
|
|
if (!Instructions.empty()) {
|
|
|
|
// Find the opcode # of inline asm.
|
|
|
|
O << " switch (MI->getOpcode()) {\n";
|
|
|
|
while (!Instructions.empty())
|
|
|
|
EmitInstructions(Instructions, O);
|
Implement factoring of instruction pattern strings. In particular, instead of
emitting code like this:
case PPC::ADD: O << "add "; printOperand(MI, 0, MVT::i64); O << ", "; prin
tOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '\n
'; break;
case PPC::ADDC: O << "addc "; printOperand(MI, 0, MVT::i64); O << ", "; pr
intOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '
\n'; break;
case PPC::ADDE: O << "adde "; printOperand(MI, 0, MVT::i64); O << ", "; pr
intOperand(MI, 1, MVT::i64); O << ", "; printOperand(MI, 2, MVT::i64); O << '
\n'; break;
...
Emit code like this:
case PPC::ADD:
case PPC::ADDC:
case PPC::ADDE:
...
switch (MI->getOpcode()) {
case PPC::ADD: O << "add "; break;
case PPC::ADDC: O << "addc "; break;
case PPC::ADDE: O << "adde "; break;
...
}
printOperand(MI, 0, MVT::i64);
O << ", ";
printOperand(MI, 1, MVT::i64);
O << ", ";
printOperand(MI, 2, MVT::i64);
O << "\n";
break;
This shrinks the PPC asm writer from 24785->15205 bytes (even though the new
asmwriter has much more whitespace than the old one), and the X86 printers shrink
quite a bit too. The important implication of this is that GCC no longer hits swap
when building the PPC backend in optimized mode. Thus this fixes PR448.
-Chris
llvm-svn: 19755
2005-01-23 02:38:13 +08:00
|
|
|
|
2006-07-19 01:38:46 +08:00
|
|
|
O << " }\n";
|
2009-08-08 09:32:19 +08:00
|
|
|
O << " return;\n";
|
2006-07-19 01:38:46 +08:00
|
|
|
}
|
2009-07-30 04:10:24 +08:00
|
|
|
|
2009-08-08 09:32:19 +08:00
|
|
|
O << " return;\n";
|
2006-07-19 03:06:01 +08:00
|
|
|
O << "}\n";
|
2004-08-01 13:59:33 +08:00
|
|
|
}
|