1//===- AsmWriterInst.h - Classes encapsulating a printable inst -*- C++ -*-===//
2//
3//                     The LLVM Compiler Infrastructure
4//
5// This file is distributed under the University of Illinois Open Source
6// License. See LICENSE.TXT for details.
7//
8//===----------------------------------------------------------------------===//
9//
10// These classes implement a parser for assembly strings.  The parser splits
11// the string into operands, which can be literal strings (the constant bits of
12// the string), actual operands (i.e., operands from the MachineInstr), and
13// dynamically-generated text, specified by raw C++ code.
14//
15//===----------------------------------------------------------------------===//
16
17#ifndef ASMWRITER_INST_H
18#define ASMWRITER_INST_H
19
20#include <string>
21#include <vector>
22
23namespace llvm {
24  class CodeGenInstruction;
25  class Record;
26
27  struct AsmWriterOperand {
28    enum OpType {
29      // Output this text surrounded by quotes to the asm.
30      isLiteralTextOperand,
31      // This is the name of a routine to call to print the operand.
32      isMachineInstrOperand,
33      // Output this text verbatim to the asm writer.  It is code that
34      // will output some text to the asm.
35      isLiteralStatementOperand
36    } OperandType;
37
38    /// Str - For isLiteralTextOperand, this IS the literal text.  For
39    /// isMachineInstrOperand, this is the PrinterMethodName for the operand..
40    /// For isLiteralStatementOperand, this is the code to insert verbatim
41    /// into the asm writer.
42    std::string Str;
43
44    /// CGIOpNo - For isMachineInstrOperand, this is the index of the operand in
45    /// the CodeGenInstruction.
46    unsigned CGIOpNo;
47
48    /// MiOpNo - For isMachineInstrOperand, this is the operand number of the
49    /// machine instruction.
50    unsigned MIOpNo;
51
52    /// MiModifier - For isMachineInstrOperand, this is the modifier string for
53    /// an operand, specified with syntax like ${opname:modifier}.
54    std::string MiModifier;
55
56    // To make VS STL happy
57    AsmWriterOperand(OpType op = isLiteralTextOperand):OperandType(op) {}
58
59    AsmWriterOperand(const std::string &LitStr,
60                     OpType op = isLiteralTextOperand)
61    : OperandType(op), Str(LitStr) {}
62
63    AsmWriterOperand(const std::string &Printer,
64                     unsigned _CGIOpNo,
65                     unsigned _MIOpNo,
66                     const std::string &Modifier,
67                     OpType op = isMachineInstrOperand)
68    : OperandType(op), Str(Printer), CGIOpNo(_CGIOpNo), MIOpNo(_MIOpNo),
69    MiModifier(Modifier) {}
70
71    bool operator!=(const AsmWriterOperand &Other) const {
72      if (OperandType != Other.OperandType || Str != Other.Str) return true;
73      if (OperandType == isMachineInstrOperand)
74        return MIOpNo != Other.MIOpNo || MiModifier != Other.MiModifier;
75      return false;
76    }
77    bool operator==(const AsmWriterOperand &Other) const {
78      return !operator!=(Other);
79    }
80
81    /// getCode - Return the code that prints this operand.
82    std::string getCode() const;
83  };
84
85  class AsmWriterInst {
86  public:
87    std::vector<AsmWriterOperand> Operands;
88    const CodeGenInstruction *CGI;
89
90    AsmWriterInst(const CodeGenInstruction &CGI,
91                  unsigned Variant,
92                  int FirstOperandColumn,
93                  int OperandSpacing);
94
95    /// MatchesAllButOneOp - If this instruction is exactly identical to the
96    /// specified instruction except for one differing operand, return the
97    /// differing operand number.  Otherwise return ~0.
98    unsigned MatchesAllButOneOp(const AsmWriterInst &Other) const;
99
100  private:
101    void AddLiteralString(const std::string &Str) {
102      // If the last operand was already a literal text string, append this to
103      // it, otherwise add a new operand.
104      if (!Operands.empty() &&
105          Operands.back().OperandType == AsmWriterOperand::isLiteralTextOperand)
106        Operands.back().Str.append(Str);
107      else
108        Operands.push_back(AsmWriterOperand(Str));
109    }
110  };
111}
112
113#endif
114