• Home
  • History
  • Annotate
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
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  
23  namespace 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
OperandTypeAsmWriterOperand57      AsmWriterOperand(OpType op = isLiteralTextOperand):OperandType(op) {}
58  
59      AsmWriterOperand(const std::string &LitStr,
60                       OpType op = isLiteralTextOperand)
OperandTypeAsmWriterOperand61      : 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)
OperandTypeAsmWriterOperand68      : 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:
AddLiteralString(const std::string & Str)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