* Do not allow nodes which produce chain results (e.g. loads) to be folded if

[oota-llvm.git] / utils / TableGen / CodeGenInstruction.h

diff --git a/utils/TableGen/CodeGenInstruction.h b/utils/TableGen/CodeGenInstruction.h
index 5269cc76e2b9d9de0724fdbaa493c4afbdc442dd..cee55d2856524a17b497674b7a0249b61d2711ec 100644 (file)
--- a/utils/TableGen/CodeGenInstruction.h
+++ b/utils/TableGen/CodeGenInstruction.h
@@ -1,10 +1,10 @@
 //===- CodeGenInstruction.h - Instruction Class Wrapper ---------*- C++ -*-===//
-// 
+//
 //                     The LLVM Compiler Infrastructure
 //
 // This file was developed by the LLVM research group and is distributed under
 // the University of Illinois Open Source License. See LICENSE.TXT for details.
-// 
+//
 //===----------------------------------------------------------------------===//
 //
 // This file defines a wrapper class for the 'Instruction' TableGen class.
@@ -21,6 +21,7 @@
 
 namespace llvm {
   class Record;
+  class DagInit;
 
   struct CodeGenInstruction {
     Record *TheDef;            // The actual record defining this instruction.
@@ -31,17 +32,40 @@ namespace llvm {
     /// instruction.
     std::string AsmString;
 
-    /// OperandInfo - For each operand declared in the OperandList of the
-    /// instruction, keep track of its record (which specifies the class of the
-    /// operand), its type, and the name given to the operand, if any.
+    /// OperandInfo - The information we keep track of for each operand in the
+    /// operand list for a tablegen instruction.
     struct OperandInfo {
+      /// Rec - The definition this operand is declared as.
+      ///
       Record *Rec;
-      MVT::ValueType Ty;
+
+      /// Name - If this operand was assigned a symbolic name, this is it,
+      /// otherwise, it's empty.
       std::string Name;
-      OperandInfo(Record *R, MVT::ValueType T, const std::string &N)
-        : Rec(R), Ty(T), Name(N) {}
+
+      /// PrinterMethodName - The method used to print operands of this type in
+      /// the asmprinter.
+      std::string PrinterMethodName;
+
+      /// MIOperandNo - Currently (this is meant to be phased out), some logical
+      /// operands correspond to multiple MachineInstr operands.  In the X86
+      /// target for example, one address operand is represented as 4
+      /// MachineOperands.  Because of this, the operand number in the
+      /// OperandList may not match the MachineInstr operand num.  Until it
+      /// does, this contains the MI operand index of this operand.
+      unsigned MIOperandNo;
+      unsigned MINumOperands;   // The number of operands.
+
+      /// MIOperandInfo - Default MI operand type. Note an operand may be made
+      /// up of multiple MI operands.
+      DagInit *MIOperandInfo;
+
+      OperandInfo(Record *R, const std::string &N, const std::string &PMN, 
+                  unsigned MION, unsigned MINO, DagInit *MIOI)
+        : Rec(R), Name(N), PrinterMethodName(PMN), MIOperandNo(MION),
+          MINumOperands(MINO), MIOperandInfo(MIOI) {}
     };
-    
+
     /// OperandList - The list of declared operands, along with their declared
     /// type (which is a record).
     std::vector<OperandInfo> OperandList;
@@ -51,10 +75,18 @@ namespace llvm {
     bool isBranch;
     bool isBarrier;
     bool isCall;
+    bool isLoad;
+    bool isStore;
     bool isTwoAddress;
+    bool isConvertibleToThreeAddress;
+    bool isCommutable;
     bool isTerminator;
+    bool hasDelaySlot;
+    bool usesCustomDAGSchedInserter;
+    bool hasVariableNumberOfOperands;
+    bool hasCtrlDep;
 
-    CodeGenInstruction(Record *R);
+    CodeGenInstruction(Record *R, const std::string &AsmStr);
 
     /// getOperandNamed - Return the index of the operand with the specified
     /// non-empty name.  If the instruction does not have an operand with the