Implement a lot of cast functionality (no FP or 64)

[oota-llvm.git] / lib / Target / X86 / X86InstrInfo.h

diff --git a/lib/Target/X86/X86InstrInfo.h b/lib/Target/X86/X86InstrInfo.h
index 415d81a05cfc60c754bdfa8d8bb2bcd8a1a121ed..9d2629120ef0424516fcd2861da5974fdb4c83fc 100644 (file)
--- a/lib/Target/X86/X86InstrInfo.h
+++ b/lib/Target/X86/X86InstrInfo.h
@@ -20,50 +20,77 @@ namespace X86II {
     // instructions.
     //
 
-    /// Other - An instruction gets this form if it doesn't fit any of the
-    /// catagories below.
-    OtherFrm       = 0,
-
     /// Raw - This form is for instructions that don't have any operands, so
     /// they are just a fixed opcode value, like 'leave'.
-    RawFrm         = 1,
+    RawFrm         = 0,
     
     /// AddRegFrm - This form is used for instructions like 'push r32' that have
     /// their one register operand added to their opcode.
-    AddRegFrm      = 2,
+    AddRegFrm      = 1,
 
     /// MRMDestReg - This form is used for instructions that use the Mod/RM byte
     /// to specify a destination, which in this case is a register.
     ///
-    MRMDestReg     = 3,
+    MRMDestReg     = 2,
 
     /// MRMDestMem - This form is used for instructions that use the Mod/RM byte
     /// to specify a destination, which in this case is memory.
     ///
-    MRMDestMem     = 4,
+    MRMDestMem     = 3,
 
     /// MRMSrcReg - This form is used for instructions that use the Mod/RM byte
     /// to specify a source, which in this case is a register.
     ///
-    MRMSrcReg      = 5,
+    MRMSrcReg      = 4,
 
     /// MRMSrcMem - This form is used for instructions that use the Mod/RM byte
     /// to specify a source, which in this case is memory.
     ///
-    MRMSrcMem      = 6,
+    MRMSrcMem      = 5,
   
-    /// TODO: Mod/RM that uses a fixed opcode extension, like /0
+    /// MRMS[0-7][rm] - These forms are used to represent instructions that use
+    /// a Mod/RM byte, and use the middle field to hold extended opcode
+    /// information.  In the intel manual these are represented as /0, /1, ...
+    ///
+
+    // First, instructions that operate on a register r/m operand...
+    MRMS0r = 16,  MRMS1r = 17,  MRMS2r = 18,  MRMS3r = 19, // Format /0 /1 /2 /3
+    MRMS4r = 20,  MRMS5r = 21,  MRMS6r = 22,  MRMS7r = 23, // Format /4 /5 /6 /7
+
+    // Next, instructions that operate on a memory r/m operand...
+    MRMS0m = 24,  MRMS1m = 25,  MRMS2m = 26,  MRMS3m = 27, // Format /0 /1 /2 /3
+    MRMS4m = 28,  MRMS5m = 29,  MRMS6m = 30,  MRMS7m = 31, // Format /4 /5 /6 /7
 
+    FormMask       = 31,
 
     //===------------------------------------------------------------------===//
     // Actual flags...
 
     /// Void - Set if this instruction produces no value
-    Void        = 1 << 3,
+    Void        = 1 << 5,
 
     // TB - TwoByte - Set if this instruction has a two byte opcode, which
     // starts with a 0x0F byte before the real opcode.
-    TB          = 1 << 4,
+    TB          = 1 << 6,
+
+    // FIXME: There are several more two byte opcode escapes: D8-DF
+    // Handle this.
+
+    // OpSize - Set if this instruction requires an operand size prefix (0x66),
+    // which most often indicates that the instruction operates on 16 bit data
+    // instead of 32 bit data.
+    OpSize      = 1 << 7,
+
+    // This three-bit field describes the size of a memory operand.
+    // I'm just being paranoid not using the zero value; there's 
+    // probably no reason you couldn't use it.
+    MemArg8     = 0x1 << 8,
+    MemArg16    = 0x2 << 8,
+    MemArg32    = 0x3 << 8,
+    MemArg64    = 0x4 << 8,
+    MemArg80    = 0x5 << 8,
+    MemArg128   = 0x6 << 8,
+    MemArgMask  = 0x7 << 8,
   };
 }
 
@@ -83,6 +110,12 @@ public:
   virtual void print(const MachineInstr *MI, std::ostream &O,
                      const TargetMachine &TM) const;
 
+  // getBaseOpcodeFor - This function returns the "base" X86 opcode for the
+  // specified opcode number.
+  //
+  unsigned char getBaseOpcodeFor(unsigned Opcode) const;
+
+
 
   //===--------------------------------------------------------------------===//
   //