• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 //===- CodeGenInstruction.h - Instruction Class Wrapper ---------*- 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 // This file defines a wrapper class for the 'Instruction' TableGen class.
11 //
12 //===----------------------------------------------------------------------===//
13 
14 #ifndef LLVM_UTILS_TABLEGEN_CODEGENINSTRUCTION_H
15 #define LLVM_UTILS_TABLEGEN_CODEGENINSTRUCTION_H
16 
17 #include "llvm/ADT/StringRef.h"
18 #include "llvm/CodeGen/MachineValueType.h"
19 #include "llvm/Support/SMLoc.h"
20 #include <string>
21 #include <utility>
22 #include <vector>
23 
24 namespace llvm {
25 template <typename T> class ArrayRef;
26   class Record;
27   class DagInit;
28   class CodeGenTarget;
29 
30   class CGIOperandList {
31   public:
32     class ConstraintInfo {
33       enum { None, EarlyClobber, Tied } Kind;
34       unsigned OtherTiedOperand;
35     public:
ConstraintInfo()36       ConstraintInfo() : Kind(None) {}
37 
getEarlyClobber()38       static ConstraintInfo getEarlyClobber() {
39         ConstraintInfo I;
40         I.Kind = EarlyClobber;
41         I.OtherTiedOperand = 0;
42         return I;
43       }
44 
getTied(unsigned Op)45       static ConstraintInfo getTied(unsigned Op) {
46         ConstraintInfo I;
47         I.Kind = Tied;
48         I.OtherTiedOperand = Op;
49         return I;
50       }
51 
isNone()52       bool isNone() const { return Kind == None; }
isEarlyClobber()53       bool isEarlyClobber() const { return Kind == EarlyClobber; }
isTied()54       bool isTied() const { return Kind == Tied; }
55 
getTiedOperand()56       unsigned getTiedOperand() const {
57         assert(isTied());
58         return OtherTiedOperand;
59       }
60     };
61 
62     /// OperandInfo - The information we keep track of for each operand in the
63     /// operand list for a tablegen instruction.
64     struct OperandInfo {
65       /// Rec - The definition this operand is declared as.
66       ///
67       Record *Rec;
68 
69       /// Name - If this operand was assigned a symbolic name, this is it,
70       /// otherwise, it's empty.
71       std::string Name;
72 
73       /// PrinterMethodName - The method used to print operands of this type in
74       /// the asmprinter.
75       std::string PrinterMethodName;
76 
77       /// EncoderMethodName - The method used to get the machine operand value
78       /// for binary encoding. "getMachineOpValue" by default.
79       std::string EncoderMethodName;
80 
81       /// OperandType - A value from MCOI::OperandType representing the type of
82       /// the operand.
83       std::string OperandType;
84 
85       /// MIOperandNo - Currently (this is meant to be phased out), some logical
86       /// operands correspond to multiple MachineInstr operands.  In the X86
87       /// target for example, one address operand is represented as 4
88       /// MachineOperands.  Because of this, the operand number in the
89       /// OperandList may not match the MachineInstr operand num.  Until it
90       /// does, this contains the MI operand index of this operand.
91       unsigned MIOperandNo;
92       unsigned MINumOperands;   // The number of operands.
93 
94       /// DoNotEncode - Bools are set to true in this vector for each operand in
95       /// the DisableEncoding list.  These should not be emitted by the code
96       /// emitter.
97       std::vector<bool> DoNotEncode;
98 
99       /// MIOperandInfo - Default MI operand type. Note an operand may be made
100       /// up of multiple MI operands.
101       DagInit *MIOperandInfo;
102 
103       /// Constraint info for this operand.  This operand can have pieces, so we
104       /// track constraint info for each.
105       std::vector<ConstraintInfo> Constraints;
106 
OperandInfoOperandInfo107       OperandInfo(Record *R, const std::string &N, const std::string &PMN,
108                   const std::string &EMN, const std::string &OT, unsigned MION,
109                   unsigned MINO, DagInit *MIOI)
110       : Rec(R), Name(N), PrinterMethodName(PMN), EncoderMethodName(EMN),
111         OperandType(OT), MIOperandNo(MION), MINumOperands(MINO),
112         MIOperandInfo(MIOI) {}
113 
114 
115       /// getTiedOperand - If this operand is tied to another one, return the
116       /// other operand number.  Otherwise, return -1.
getTiedRegisterOperandInfo117       int getTiedRegister() const {
118         for (unsigned j = 0, e = Constraints.size(); j != e; ++j) {
119           const CGIOperandList::ConstraintInfo &CI = Constraints[j];
120           if (CI.isTied()) return CI.getTiedOperand();
121         }
122         return -1;
123       }
124     };
125 
126     CGIOperandList(Record *D);
127 
128     Record *TheDef;            // The actual record containing this OperandList.
129 
130     /// NumDefs - Number of def operands declared, this is the number of
131     /// elements in the instruction's (outs) list.
132     ///
133     unsigned NumDefs;
134 
135     /// OperandList - The list of declared operands, along with their declared
136     /// type (which is a record).
137     std::vector<OperandInfo> OperandList;
138 
139     // Information gleaned from the operand list.
140     bool isPredicable;
141     bool hasOptionalDef;
142     bool isVariadic;
143 
144     // Provide transparent accessors to the operand list.
empty()145     bool empty() const { return OperandList.empty(); }
size()146     unsigned size() const { return OperandList.size(); }
147     const OperandInfo &operator[](unsigned i) const { return OperandList[i]; }
148     OperandInfo &operator[](unsigned i) { return OperandList[i]; }
back()149     OperandInfo &back() { return OperandList.back(); }
back()150     const OperandInfo &back() const { return OperandList.back(); }
151 
152     typedef std::vector<OperandInfo>::iterator iterator;
153     typedef std::vector<OperandInfo>::const_iterator const_iterator;
begin()154     iterator begin() { return OperandList.begin(); }
begin()155     const_iterator begin() const { return OperandList.begin(); }
end()156     iterator end() { return OperandList.end(); }
end()157     const_iterator end() const { return OperandList.end(); }
158 
159     /// getOperandNamed - Return the index of the operand with the specified
160     /// non-empty name.  If the instruction does not have an operand with the
161     /// specified name, abort.
162     unsigned getOperandNamed(StringRef Name) const;
163 
164     /// hasOperandNamed - Query whether the instruction has an operand of the
165     /// given name. If so, return true and set OpIdx to the index of the
166     /// operand. Otherwise, return false.
167     bool hasOperandNamed(StringRef Name, unsigned &OpIdx) const;
168 
169     /// ParseOperandName - Parse an operand name like "$foo" or "$foo.bar",
170     /// where $foo is a whole operand and $foo.bar refers to a suboperand.
171     /// This aborts if the name is invalid.  If AllowWholeOp is true, references
172     /// to operands with suboperands are allowed, otherwise not.
173     std::pair<unsigned,unsigned> ParseOperandName(const std::string &Op,
174                                                   bool AllowWholeOp = true);
175 
176     /// getFlattenedOperandNumber - Flatten a operand/suboperand pair into a
177     /// flat machineinstr operand #.
getFlattenedOperandNumber(std::pair<unsigned,unsigned> Op)178     unsigned getFlattenedOperandNumber(std::pair<unsigned,unsigned> Op) const {
179       return OperandList[Op.first].MIOperandNo + Op.second;
180     }
181 
182     /// getSubOperandNumber - Unflatten a operand number into an
183     /// operand/suboperand pair.
getSubOperandNumber(unsigned Op)184     std::pair<unsigned,unsigned> getSubOperandNumber(unsigned Op) const {
185       for (unsigned i = 0; ; ++i) {
186         assert(i < OperandList.size() && "Invalid flat operand #");
187         if (OperandList[i].MIOperandNo+OperandList[i].MINumOperands > Op)
188           return std::make_pair(i, Op-OperandList[i].MIOperandNo);
189       }
190     }
191 
192 
193     /// isFlatOperandNotEmitted - Return true if the specified flat operand #
194     /// should not be emitted with the code emitter.
isFlatOperandNotEmitted(unsigned FlatOpNo)195     bool isFlatOperandNotEmitted(unsigned FlatOpNo) const {
196       std::pair<unsigned,unsigned> Op = getSubOperandNumber(FlatOpNo);
197       if (OperandList[Op.first].DoNotEncode.size() > Op.second)
198         return OperandList[Op.first].DoNotEncode[Op.second];
199       return false;
200     }
201 
202     void ProcessDisableEncoding(std::string Value);
203   };
204 
205 
206   class CodeGenInstruction {
207   public:
208     Record *TheDef;            // The actual record defining this instruction.
209     std::string Namespace;     // The namespace the instruction is in.
210 
211     /// AsmString - The format string used to emit a .s file for the
212     /// instruction.
213     std::string AsmString;
214 
215     /// Operands - This is information about the (ins) and (outs) list specified
216     /// to the instruction.
217     CGIOperandList Operands;
218 
219     /// ImplicitDefs/ImplicitUses - These are lists of registers that are
220     /// implicitly defined and used by the instruction.
221     std::vector<Record*> ImplicitDefs, ImplicitUses;
222 
223     // Various boolean values we track for the instruction.
224     bool isReturn : 1;
225     bool isBranch : 1;
226     bool isIndirectBranch : 1;
227     bool isCompare : 1;
228     bool isMoveImm : 1;
229     bool isBitcast : 1;
230     bool isSelect : 1;
231     bool isBarrier : 1;
232     bool isCall : 1;
233     bool canFoldAsLoad : 1;
234     bool mayLoad : 1;
235     bool mayLoad_Unset : 1;
236     bool mayStore : 1;
237     bool mayStore_Unset : 1;
238     bool isPredicable : 1;
239     bool isConvertibleToThreeAddress : 1;
240     bool isCommutable : 1;
241     bool isTerminator : 1;
242     bool isReMaterializable : 1;
243     bool hasDelaySlot : 1;
244     bool usesCustomInserter : 1;
245     bool hasPostISelHook : 1;
246     bool hasCtrlDep : 1;
247     bool isNotDuplicable : 1;
248     bool hasSideEffects : 1;
249     bool hasSideEffects_Unset : 1;
250     bool isAsCheapAsAMove : 1;
251     bool hasExtraSrcRegAllocReq : 1;
252     bool hasExtraDefRegAllocReq : 1;
253     bool isCodeGenOnly : 1;
254     bool isPseudo : 1;
255     bool isRegSequence : 1;
256     bool isExtractSubreg : 1;
257     bool isInsertSubreg : 1;
258     bool isConvergent : 1;
259     bool hasNoSchedulingInfo : 1;
260 
261     std::string DeprecatedReason;
262     bool HasComplexDeprecationPredicate;
263 
264     /// Are there any undefined flags?
hasUndefFlags()265     bool hasUndefFlags() const {
266       return mayLoad_Unset || mayStore_Unset || hasSideEffects_Unset;
267     }
268 
269     // The record used to infer instruction flags, or NULL if no flag values
270     // have been inferred.
271     Record *InferredFrom;
272 
273     CodeGenInstruction(Record *R);
274 
275     /// HasOneImplicitDefWithKnownVT - If the instruction has at least one
276     /// implicit def and it has a known VT, return the VT, otherwise return
277     /// MVT::Other.
278     MVT::SimpleValueType
279       HasOneImplicitDefWithKnownVT(const CodeGenTarget &TargetInfo) const;
280 
281 
282     /// FlattenAsmStringVariants - Flatten the specified AsmString to only
283     /// include text from the specified variant, returning the new string.
284     static std::string FlattenAsmStringVariants(StringRef AsmString,
285                                                 unsigned Variant);
286   };
287 
288 
289   /// CodeGenInstAlias - This represents an InstAlias definition.
290   class CodeGenInstAlias {
291   public:
292     Record *TheDef;            // The actual record defining this InstAlias.
293 
294     /// AsmString - The format string used to emit a .s file for the
295     /// instruction.
296     std::string AsmString;
297 
298     /// Result - The result instruction.
299     DagInit *Result;
300 
301     /// ResultInst - The instruction generated by the alias (decoded from
302     /// Result).
303     CodeGenInstruction *ResultInst;
304 
305 
306     struct ResultOperand {
307     private:
308       std::string Name;
309       Record *R;
310 
311       int64_t Imm;
312     public:
313       enum {
314         K_Record,
315         K_Imm,
316         K_Reg
317       } Kind;
318 
ResultOperandResultOperand319       ResultOperand(std::string N, Record *r)
320           : Name(std::move(N)), R(r), Kind(K_Record) {}
ResultOperandResultOperand321       ResultOperand(int64_t I) : Imm(I), Kind(K_Imm) {}
ResultOperandResultOperand322       ResultOperand(Record *r) : R(r), Kind(K_Reg) {}
323 
isRecordResultOperand324       bool isRecord() const { return Kind == K_Record; }
isImmResultOperand325       bool isImm() const { return Kind == K_Imm; }
isRegResultOperand326       bool isReg() const { return Kind == K_Reg; }
327 
getNameResultOperand328       StringRef getName() const { assert(isRecord()); return Name; }
getRecordResultOperand329       Record *getRecord() const { assert(isRecord()); return R; }
getImmResultOperand330       int64_t getImm() const { assert(isImm()); return Imm; }
getRegisterResultOperand331       Record *getRegister() const { assert(isReg()); return R; }
332 
333       unsigned getMINumOperands() const;
334     };
335 
336     /// ResultOperands - The decoded operands for the result instruction.
337     std::vector<ResultOperand> ResultOperands;
338 
339     /// ResultInstOperandIndex - For each operand, this vector holds a pair of
340     /// indices to identify the corresponding operand in the result
341     /// instruction.  The first index specifies the operand and the second
342     /// index specifies the suboperand.  If there are no suboperands or if all
343     /// of them are matched by the operand, the second value should be -1.
344     std::vector<std::pair<unsigned, int> > ResultInstOperandIndex;
345 
346     CodeGenInstAlias(Record *R, unsigned Variant, CodeGenTarget &T);
347 
348     bool tryAliasOpMatch(DagInit *Result, unsigned AliasOpNo,
349                          Record *InstOpRec, bool hasSubOps, ArrayRef<SMLoc> Loc,
350                          CodeGenTarget &T, ResultOperand &ResOp);
351   };
352 }
353 
354 #endif
355