/// InstAlias - This defines an alternate assembly syntax that is allowed to
/// match an instruction that has a different (more canonical) assembly
/// representation.
-class InstAlias<dag Outs, dag Ins, string Asm, dag Result> {
- dag OutOperandList = Outs; // An dag containing the MI def operand list.
- dag InOperandList = Ins; // An dag containing the MI use operand list.
+class InstAlias<string Asm, dag Result> {
string AsmString = Asm; // The .s format to match the instruction with.
dag ResultInst = Result; // The MCInst to generate.
//===----------------------------------------------------------------------===//
// movsx aliases
-def : InstAlias<(outs GR16:$dst), (ins GR8 :$src),
- "movsx $src, $dst",
+def : InstAlias<"movsx $src, $dst",
(MOVSX16rr8W GR16:$dst, GR8:$src)>;
-def : InstAlias<(outs GR16:$dst), (ins i8mem:$src),
- "movsx $src, $dst",
+def : InstAlias<"movsx $src, $dst",
(MOVSX16rm8W GR16:$dst, i8mem:$src)>;
-def : InstAlias<(outs GR32:$dst), (ins GR8 :$src),
- "movsx $src, $dst",
+def : InstAlias<"movsx $src, $dst",
(MOVSX32rr8 GR32:$dst, GR8:$src)>;
-def : InstAlias<(outs GR32:$dst), (ins GR16:$src),
- "movsx $src, $dst",
+def : InstAlias<"movsx $src, $dst",
(MOVSX32rr16 GR32:$dst, GR16:$src)>;
-def : InstAlias<(outs GR64:$dst), (ins GR8 :$src),
- "movsx $src, $dst",
+def : InstAlias<"movsx $src, $dst",
(MOVSX64rr8 GR64:$dst, GR8:$src)>;
-def : InstAlias<(outs GR64:$dst), (ins GR16:$src),
- "movsx $src, $dst",
+def : InstAlias<"movsx $src, $dst",
(MOVSX64rr16 GR64:$dst, GR16:$src)>;
-def : InstAlias<(outs GR64:$dst), (ins GR32:$src),
- "movsx $src, $dst",
+def : InstAlias<"movsx $src, $dst",
(MOVSX64rr32 GR64:$dst, GR32:$src)>;
// movzx aliases
-def : InstAlias<(outs GR16:$dst), (ins GR8 :$src),
- "movzx $src, $dst",
+def : InstAlias<"movzx $src, $dst",
(MOVZX16rr8W GR16:$dst, GR8:$src)>;
-def : InstAlias<(outs GR16:$dst), (ins i8mem:$src),
- "movzx $src, $dst",
+def : InstAlias<"movzx $src, $dst",
(MOVZX16rm8W GR16:$dst, i8mem:$src)>;
-def : InstAlias<(outs GR32:$dst), (ins GR8 :$src),
- "movzx $src, $dst",
+def : InstAlias<"movzx $src, $dst",
(MOVZX32rr8 GR32:$dst, GR8:$src)>;
-def : InstAlias<(outs GR32:$dst), (ins GR16:$src),
- "movzx $src, $dst",
+def : InstAlias<"movzx $src, $dst",
(MOVZX32rr16 GR32:$dst, GR16:$src)>;
-def : InstAlias<(outs GR64:$dst), (ins GR8 :$src),
- "movzx $src, $dst",
+def : InstAlias<"movzx $src, $dst",
(MOVZX64rr8_Q GR64:$dst, GR8:$src)>;
-def : InstAlias<(outs GR64:$dst), (ins GR16:$src),
- "movzx $src, $dst",
+def : InstAlias<"movzx $src, $dst",
(MOVZX64rr16_Q GR64:$dst, GR16:$src)>;
// Note: No GR32->GR64 movzx form.
/// DefRec - This is the definition that it came from.
PointerUnion<const CodeGenInstruction*, const CodeGenInstAlias*> DefRec;
- // FIXME: REMOVE.
- const CGIOperandList &TheOperandList;
-
+ const CodeGenInstruction *getResultInst() const {
+ if (DefRec.is<const CodeGenInstruction*>())
+ return DefRec.get<const CodeGenInstruction*>();
+ return DefRec.get<const CodeGenInstAlias*>()->ResultInst;
+ }
/// ResOperands - This is the operand list that should be built for the result
/// MCInst.
std::string ConversionFnKind;
MatchableInfo(const CodeGenInstruction &CGI)
- : TheDef(CGI.TheDef), DefRec(&CGI),
- TheOperandList(CGI.Operands), AsmString(CGI.AsmString) {
+ : TheDef(CGI.TheDef), DefRec(&CGI), AsmString(CGI.AsmString) {
}
MatchableInfo(const CodeGenInstAlias *Alias)
- : TheDef(Alias->TheDef), DefRec(Alias), TheOperandList(Alias->Operands),
- AsmString(Alias->AsmString) {
+ : TheDef(Alias->TheDef), DefRec(Alias), AsmString(Alias->AsmString) {
}
void Initialize(const AsmMatcherInfo &Info,
const CodeGenInstruction &CGI = *II->DefRec.get<const CodeGenInstruction*>();
const CGIOperandList &Operands = CGI.Operands;
- // Map this token to an operand. FIXME: Move elsewhere.
+ // Map this token to an operand.
unsigned Idx;
if (!Operands.hasOperandNamed(OperandName, Idx))
throw TGError(II->TheDef->getLoc(), "error: unable to find operand: '" +
// Set up the operand class.
for (unsigned i = 0, e = CGA.ResultOperands.size(); i != e; ++i)
if (CGA.ResultOperands[i].Name == OperandName) {
+ // It's safe to go with the first one we find, because CodeGenInstAlias
+ // validates that all operands with the same name have the same record.
Op.Class = getOperandClass(CGA.ResultInst->Operands[i]);
Op.SrcOpName = OperandName;
return;
}
void MatchableInfo::BuildResultOperands() {
- for (unsigned i = 0, e = TheOperandList.size(); i != e; ++i) {
- const CGIOperandList::OperandInfo &OpInfo = TheOperandList[i];
+ const CodeGenInstruction *ResultInst = getResultInst();
+
+ // Loop over all operands of the result instruction, determining how to
+ // populate them.
+ for (unsigned i = 0, e = ResultInst->Operands.size(); i != e; ++i) {
+ const CGIOperandList::OperandInfo &OpInfo = ResultInst->Operands[i];
// If this is a tied operand, just copy from the previously handled operand.
int TiedOp = OpInfo.getTiedRegister();
MatchableInfo &II = **it;
- const CodeGenInstruction *ResultInst;
- if (II.DefRec.is<const CodeGenInstruction*>())
- ResultInst = II.DefRec.get<const CodeGenInstruction*>();
- else
- ResultInst = II.DefRec.get<const CodeGenInstAlias*>()->ResultInst;
-
- OS << " { " << Target.getName() << "::" << ResultInst->TheDef->getName()
- << ", \"" << II.Mnemonic << "\""
- << ", " << II.ConversionFnKind << ", { ";
+ OS << " { " << Target.getName() << "::"
+ << II.getResultInst()->TheDef->getName() << ", \"" << II.Mnemonic << "\""
+ << ", " << II.ConversionFnKind << ", { ";
for (unsigned i = 0, e = II.AsmOperands.size(); i != e; ++i) {
MatchableInfo::AsmOperand &Op = II.AsmOperands[i];
/// CodeGenInstAlias Implementation
//===----------------------------------------------------------------------===//
-CodeGenInstAlias::CodeGenInstAlias(Record *R, CodeGenTarget &T)
- : TheDef(R), Operands(R) {
+CodeGenInstAlias::CodeGenInstAlias(Record *R, CodeGenTarget &T) : TheDef(R) {
AsmString = R->getValueAsString("AsmString");
-
Result = R->getValueAsDag("ResultInst");
// Verify that the root of the result is an instruction.
/// instruction.
std::string AsmString;
- /// Operands - This is information about the (ins) and (outs) list specified
- /// to the alias.
- CGIOperandList Operands;
-
/// Result - The result instruction.
DagInit *Result;