/[pcsx2_0.9.7]/trunk/common/include/x86emitter/x86types.h
ViewVC logotype

Diff of /trunk/common/include/x86emitter/x86types.h

Parent Directory Parent Directory | Revision Log Revision Log | View Patch Patch

revision 61 by william, Tue Sep 7 03:24:11 2010 UTC revision 62 by william, Tue Sep 7 11:08:22 2010 UTC
# Line 16  Line 16 
16  #pragma once  #pragma once
17    
18  // Register counts for x86/32 mode:  // Register counts for x86/32 mode:
19  static const int iREGCNT_XMM = 8;  static const uint iREGCNT_XMM = 8;
20  static const int iREGCNT_GPR = 8;  static const uint iREGCNT_GPR = 8;
21  static const int iREGCNT_MMX = 8;  static const uint iREGCNT_MMX = 8;
22    
23  enum XMMSSEType  enum XMMSSEType
24  {  {
# Line 80  extern const char* xGetRegName( int regi Line 80  extern const char* xGetRegName( int regi
80  //------------------------------------------------------------------  //------------------------------------------------------------------
81  // templated version of is_s8 is required, so that u16's get correct sign extension treatment.  // templated version of is_s8 is required, so that u16's get correct sign extension treatment.
82  template< typename T >  template< typename T >
83  static __forceinline bool is_s8( T imm ) { return (s8)imm == (s32)imm; }  static __fi bool is_s8( T imm ) { return (s8)imm == (s32)imm; }
84    
85  template< typename T > void xWrite( T val );  template< typename T > void xWrite( T val );
86    
# Line 114  template< typename T > void xWrite( T va Line 114  template< typename T > void xWrite( T va
114  //  //
115  // In the case of (Reg, Imm) forms, the inlining is up to the discreation of the compiler.  // In the case of (Reg, Imm) forms, the inlining is up to the discreation of the compiler.
116  //  //
117  // Note: I *intentionally* use __forceinline directly for most single-line class members,  // Note: I *intentionally* use __fi directly for most single-line class members,
118  // when needed.  There's no point in using __emitline in these cases since the debugger  // when needed.  There's no point in using __emitline in these cases since the debugger
119  // can't trace into single-line functions anyway.  // can't trace into single-line functions anyway.
120  //  //
121  #ifdef PCSX2_DEVBUILD  #ifdef PCSX2_DEVBUILD
122  #       define __emitinline  #       define __emitinline
123  #else  #else
124  #       define __emitinline __forceinline  #       define __emitinline __fi
125  #endif  #endif
126    
127          // ModRM 'mod' field enumeration.   Provided mostly for reference:          // ModRM 'mod' field enumeration.   Provided mostly for reference:
# Line 183  template< typename T > void xWrite( T va Line 183  template< typename T > void xWrite( T va
183          static const int ModRm_UseSib = 4;              // same index value as ESP (used in RM field)          static const int ModRm_UseSib = 4;              // same index value as ESP (used in RM field)
184          static const int ModRm_UseDisp32 = 5;   // same index value as EBP (used in Mod field)          static const int ModRm_UseDisp32 = 5;   // same index value as EBP (used in Mod field)
185    
         class xAddressInfo;  
         class ModSibBase;  
   
186          extern void xSetPtr( void* ptr );          extern void xSetPtr( void* ptr );
187          extern void xAlignPtr( uint bytes );          extern void xAlignPtr( uint bytes );
188          extern void xAdvancePtr( uint bytes );          extern void xAdvancePtr( uint bytes );
# Line 196  template< typename T > void xWrite( T va Line 193  template< typename T > void xWrite( T va
193    
194          extern JccComparisonType xInvertCond( JccComparisonType src );          extern JccComparisonType xInvertCond( JccComparisonType src );
195    
196            class xAddressVoid;
197    
198          // --------------------------------------------------------------------------------------          // --------------------------------------------------------------------------------------
199          //  OperandSizedObject          //  OperandSizedObject
200          // --------------------------------------------------------------------------------------          // --------------------------------------------------------------------------------------
# Line 356  template< typename T > void xWrite( T va Line 355  template< typename T > void xWrite( T va
355    
356          public:          public:
357                  xRegisterSSE(): _parent() {}                  xRegisterSSE(): _parent() {}
                 //xRegisterSSE( const xRegisterBase& src ) : _parent( src ) {}  
358                  explicit xRegisterSSE( int regId ) : _parent( regId ) {}                  explicit xRegisterSSE( int regId ) : _parent( regId ) {}
359    
360                  virtual uint GetOperandSize() const { return 16; }                  virtual uint GetOperandSize() const { return 16; }
# Line 375  template< typename T > void xWrite( T va Line 373  template< typename T > void xWrite( T va
373                          --Id &= (iREGCNT_XMM-1);                          --Id &= (iREGCNT_XMM-1);
374                          return *this;                          return *this;
375                  }                  }
376    
377                    static const inline xRegisterSSE& GetInstance(uint id);
378          };          };
379    
380          class xRegisterCL : public xRegister8          class xRegisterCL : public xRegister8
# Line 404  template< typename T > void xWrite( T va Line 404  template< typename T > void xWrite( T va
404                  // Returns true if the register is the stack pointer: ESP.                  // Returns true if the register is the stack pointer: ESP.
405                  bool IsStackPointer() const { return Id == 4; }                  bool IsStackPointer() const { return Id == 4; }
406    
407                  inline xAddressInfo operator+( const xAddressReg& right ) const;                  xAddressVoid operator+( const xAddressReg& right ) const;
408                  inline xAddressInfo operator+( const xAddressInfo& right ) const;                  xAddressVoid operator+( s32 right ) const;
409                  inline xAddressInfo operator+( s32 right ) const;                  xAddressVoid operator+( const void* right ) const;
410                  inline xAddressInfo operator+( const void* right ) const;                  xAddressVoid operator-( s32 right ) const;
411                    xAddressVoid operator-( const void* right ) const;
412                  inline xAddressInfo operator-( s32 right ) const;                  xAddressVoid operator*( u32 factor ) const;
413                  inline xAddressInfo operator-( const void* right ) const;                  xAddressVoid operator<<( u32 shift ) const;
   
                 inline xAddressInfo operator*( u32 factor ) const;  
                 inline xAddressInfo operator<<( u32 shift ) const;  
414    
415                  /*xAddressReg& operator=( const xRegister32& src )                  /*xAddressReg& operator=( const xRegister32& src )
416                  {                  {
# Line 472  template< typename T > void xWrite( T va Line 469  template< typename T > void xWrite( T va
469    
470          extern const xRegisterEmpty xEmptyReg;          extern const xRegisterEmpty xEmptyReg;
471    
472            extern const xRegisterSSE
473                    xmm0, xmm1, xmm2, xmm3,
474                    xmm4, xmm5, xmm6, xmm7;
475    
476            extern const xRegisterMMX
477                    mm0, mm1, mm2, mm3,
478                    mm4, mm5, mm6, mm7;
479    
480            extern const xAddressReg
481                    eax, ebx, ecx, edx,
482                    esi, edi, ebp, esp;
483    
484            extern const xRegister16
485                    ax, bx, cx, dx,
486                    si, di, bp, sp;
487    
488            extern const xRegister8
489                    al, dl, bl,
490                    ah, ch, dh, bh;
491    
492            extern const xRegisterCL cl;            // I'm special!
493    
494            const xRegisterSSE& xRegisterSSE::GetInstance(uint id)
495            {
496                    static const xRegisterSSE *const m_tbl_xmmRegs[iREGCNT_XMM] =
497                    {
498                            &xmm0, &xmm1,
499                            &xmm2, &xmm3,
500                            &xmm4, &xmm5,
501                            &xmm6, &xmm7
502                    };
503    
504                    pxAssume(id < iREGCNT_XMM);
505                    return *m_tbl_xmmRegs[id];
506            }
507    
508          // --------------------------------------------------------------------------------------          // --------------------------------------------------------------------------------------
509          //  xAddressInfo          //  xAddressVoid
510          // --------------------------------------------------------------------------------------          // --------------------------------------------------------------------------------------
511          class xAddressInfo          class xAddressVoid
512          {          {
513          public:          public:
514                  xAddressReg     Base;                   // base register (no scale)                  xAddressReg     Base;                   // base register (no scale)
# Line 484  template< typename T > void xWrite( T va Line 517  template< typename T > void xWrite( T va
517                  s32                     Displacement;   // address displacement                  s32                     Displacement;   // address displacement
518    
519          public:          public:
520                  __forceinline xAddressInfo( const xAddressReg& base, const xAddressReg& index, int factor=1, s32 displacement=0 )                  xAddressVoid( const xAddressReg& base, const xAddressReg& index, int factor=1, s32 displacement=0 );
                 {  
                         Base            = base;  
                         Index           = index;  
                         Factor          = factor;  
                         Displacement= displacement;  
   
                         pxAssertMsg( base.Id != xRegId_Invalid, "Uninitialized x86 register." );  
                         pxAssertMsg( index.Id != xRegId_Invalid, "Uninitialized x86 register." );  
                 }  
521    
522                  __forceinline explicit xAddressInfo( const xAddressReg& index, int displacement=0 )                  xAddressVoid( const xAddressReg& index, int displacement=0 );
523                  {                  explicit xAddressVoid( const void* displacement );
524                          Base            = xEmptyReg;                  explicit xAddressVoid( s32 displacement=0 );
                         Index           = index;  
                         Factor          = 0;  
                         Displacement= displacement;  
525    
526                          pxAssertMsg( index.Id != xRegId_Invalid, "Uninitialized x86 register." );          public:
527                  }                  bool IsByteSizeDisp() const { return is_s8( Displacement ); }
528    
529                  __forceinline explicit xAddressInfo( s32 displacement=0 )                  xAddressVoid& Add( s32 imm )
530                  {                  {
531                          Base            = xEmptyReg;                          Displacement += imm;
532                          Index           = xEmptyReg;                          return *this;
                         Factor          = 0;  
                         Displacement= displacement;  
533                  }                  }
534    
535                  static xAddressInfo FromIndexReg( const xAddressReg& index, int scale=0, s32 displacement=0 );                  xAddressVoid& Add( const xAddressReg& src );
536                    xAddressVoid& Add( const xAddressVoid& src );
537    
538                    __fi xAddressVoid operator+( const xAddressReg& right ) const   { return xAddressVoid( *this ).Add( right ); }
539                    __fi xAddressVoid operator+( const xAddressVoid& right ) const  { return xAddressVoid( *this ).Add( right ); }
540                    __fi xAddressVoid operator+( s32 imm ) const                                    { return xAddressVoid( *this ).Add( imm ); }
541                    __fi xAddressVoid operator-( s32 imm ) const                                    { return xAddressVoid( *this ).Add( -imm ); }
542                    __fi xAddressVoid operator+( const void* addr ) const                   { return xAddressVoid( *this ).Add( (uptr)addr ); }
543    
544                    __fi void operator+=( const xAddressReg& right ) { Add( right ); }
545                    __fi void operator+=( s32 imm ) { Add( imm ); }
546                    __fi void operator-=( s32 imm ) { Add( -imm ); }
547            };
548    
549            // --------------------------------------------------------------------------------------
550            //  xAddressInfo
551            // --------------------------------------------------------------------------------------
552            template< typename BaseType >
553            class xAddressInfo : public xAddressVoid
554            {
555                    typedef xAddressVoid _parent;
556    
557            public:
558                    xAddressInfo( const xAddressReg& base, const xAddressReg& index, int factor=1, s32 displacement=0 )
559                            : _parent( base, index, factor, displacement ) {}
560    
561                    /*xAddressInfo( const xAddressVoid& src )
562                            : _parent( src ) {}*/
563                    
564                    explicit xAddressInfo( const xAddressReg& index, int displacement=0 )
565                            : _parent( index, displacement ) {}
566    
567                    explicit xAddressInfo( s32 displacement=0 )
568                            : _parent( displacement ) {}
569    
570                    static xAddressInfo<BaseType> FromIndexReg( const xAddressReg& index, int scale=0, s32 displacement=0 );
571    
572          public:          public:
573                    using _parent::operator+=;
574                    using _parent::operator-=;
575    
576                  bool IsByteSizeDisp() const { return is_s8( Displacement ); }                  bool IsByteSizeDisp() const { return is_s8( Displacement ); }
577    
578                  __forceinline xAddressInfo& Add( s32 imm )                  xAddressInfo<BaseType>& Add( s32 imm )
579                  {                  {
580                          Displacement += imm;                          Displacement += imm;
581                          return *this;                          return *this;
582                  }                  }
583    
584                  xAddressInfo& Add( const xAddressReg& src );                  xAddressInfo<BaseType>& Add( const xAddressReg& src )                           { _parent::Add(src); return *this; }
585                  xAddressInfo& Add( const xAddressInfo& src );                  xAddressInfo<BaseType>& Add( const xAddressInfo<BaseType>& src )        { _parent::Add(src); return *this; }
586    
587                  __forceinline xAddressInfo operator+( const xAddressReg& right ) const  { return xAddressInfo( *this ).Add( right ); }                  __fi xAddressInfo<BaseType> operator+( const xAddressReg& right ) const { return xAddressInfo( *this ).Add( right ); }
588                  __forceinline xAddressInfo operator+( const xAddressInfo& right ) const { return xAddressInfo( *this ).Add( right ); }                  __fi xAddressInfo<BaseType> operator+( const xAddressInfo<BaseType>& right ) const      { return xAddressInfo( *this ).Add( right ); }
589                  __forceinline xAddressInfo operator+( s32 imm ) const                                   { return xAddressInfo( *this ).Add( imm ); }                  __fi xAddressInfo<BaseType> operator+( s32 imm ) const                                  { return xAddressInfo( *this ).Add( imm ); }
590                  __forceinline xAddressInfo operator-( s32 imm ) const                                   { return xAddressInfo( *this ).Add( -imm ); }                  __fi xAddressInfo<BaseType> operator-( s32 imm ) const                                  { return xAddressInfo( *this ).Add( -imm ); }
591                  __forceinline xAddressInfo operator+( const void* addr ) const                  { return xAddressInfo( *this ).Add( (uptr)addr ); }                  __fi xAddressInfo<BaseType> operator+( const void* addr ) const                 { return xAddressInfo( *this ).Add( (uptr)addr ); }
   
                 __forceinline void operator+=( const xAddressReg& right )       { Add( right ); }  
                 __forceinline void operator+=( const xAddressInfo& right )      { Add( right ); }  
                 __forceinline void operator+=( s32 imm ) { Add( imm ); }  
                 __forceinline void operator-=( s32 imm ) { Add( -imm ); }  
         };  
592    
593          extern const xRegisterSSE                  __fi void operator+=( const xAddressInfo<BaseType>& right )     { Add( right ); }
594                  xmm0, xmm1, xmm2, xmm3,          };
                 xmm4, xmm5, xmm6, xmm7;  
595    
596          extern const xRegisterMMX          typedef xAddressInfo<u128>      xAddress128;
597                  mm0, mm1, mm2, mm3,          typedef xAddressInfo<u64>       xAddress64;
598                  mm4, mm5, mm6, mm7;          typedef xAddressInfo<u32>       xAddress32;
599            typedef xAddressInfo<u16>       xAddress16;
600            typedef xAddressInfo<u8>        xAddress8;
601    
602          extern const xAddressReg          static __fi xAddressVoid operator+( const void* addr, const xAddressVoid& right )
603                  eax, ebx, ecx, edx,          {
604                  esi, edi, ebp, esp;                  return right + addr;
605            }
606    
607          extern const xRegister16          static __fi xAddressVoid operator+( s32 addr, const xAddressVoid& right )
608                  ax, bx, cx, dx,          {
609                  si, di, bp, sp;                  return right + addr;
610            }
611    
612          extern const xRegister8          template< typename OperandType >
613                  al, dl, bl,          static __fi xAddressInfo<OperandType> operator+( const void* addr, const xAddressInfo<OperandType>& right )
614                  ah, ch, dh, bh;          {
615                    //return xAddressInfo<OperandType>( (sptr)addr ).Add( reg );
616                    return right + addr;
617            }
618    
619          extern const xRegisterCL cl;            // I'm special!          template< typename OperandType >
620            static __fi xAddressInfo<OperandType> operator+( s32 addr, const xAddressInfo<OperandType>& right )
621            {
622                    return right + addr;
623            }
624    
625          // --------------------------------------------------------------------------------------          // --------------------------------------------------------------------------------------
626          //  xImmReg< typename xRegType >          //  xImmReg< typename xRegType >
# Line 596  template< typename T > void xWrite( T va Line 657  template< typename T > void xWrite( T va
657          };          };
658    
659          // --------------------------------------------------------------------------------------          // --------------------------------------------------------------------------------------
660          //  ModSib - Internal low-level representation of the ModRM/SIB information.          //  xIndirectVoid - Internal low-level representation of the ModRM/SIB information.
661          // --------------------------------------------------------------------------------------          // --------------------------------------------------------------------------------------
662          // This class serves two purposes:  It houses 'reduced' ModRM/SIB info only, which means          // This class serves two purposes:  It houses 'reduced' ModRM/SIB info only, which means
663          // that the Base, Index, Scale, and Displacement values are all in the correct arrange-          // that the Base, Index, Scale, and Displacement values are all in the correct arrange-
# Line 607  template< typename T > void xWrite( T va Line 668  template< typename T > void xWrite( T va
668          //          //
669          // End users should always use xAddressInfo instead.          // End users should always use xAddressInfo instead.
670          //          //
671          class ModSibBase : public OperandSizedObject          class xIndirectVoid : public OperandSizedObject
672          {          {
673          public:          public:
674                  xAddressReg             Base;                   // base register (no scale)                  xAddressReg             Base;                   // base register (no scale)
# Line 616  template< typename T > void xWrite( T va Line 677  template< typename T > void xWrite( T va
677                  s32                             Displacement;   // offset applied to the Base/Index registers.                  s32                             Displacement;   // offset applied to the Base/Index registers.
678    
679          public:          public:
680                  explicit ModSibBase( const xAddressInfo& src )                  explicit xIndirectVoid( s32 disp );
681                  {                  explicit xIndirectVoid( const xAddressVoid& src );
682                          Base            = src.Base;                  xIndirectVoid( xAddressReg base, xAddressReg index, int scale=0, s32 displacement=0 );
                         Index           = src.Index;  
                         Scale           = src.Factor;  
                         Displacement= src.Displacement;  
683    
684                          Reduce();                  virtual uint GetOperandSize() const;
685                  }                  xIndirectVoid& Add( s32 imm );
   
                 ModSibBase( xAddressReg base, xAddressReg index, int scale=0, s32 displacement=0 )  
                 {  
                         Base            = base;  
                         Index           = index;  
                         Scale           = scale;  
                         Displacement= displacement;  
686    
687                          Reduce();                  bool IsByteSizeDisp() const { return is_s8( Displacement ); }
                 }  
688    
689                  explicit ModSibBase( s32 disp )                  operator xAddressVoid()
690                  {                  {
691                          Base            = xEmptyReg;                          return xAddressVoid( Base, Index, Scale, Displacement );
                         Index           = xEmptyReg;  
                         Scale           = 0;  
                         Displacement= disp;  
   
                         // no reduction necessary :D  
692                  }                  }
693    
694                  ModSibBase( const void* target )                  __fi xIndirectVoid operator+( const s32 imm ) const { return xIndirectVoid( *this ).Add( imm ); }
695                  {                  __fi xIndirectVoid operator-( const s32 imm ) const { return xIndirectVoid( *this ).Add( -imm ); }
                         Base            = xEmptyReg;  
                         Index           = xEmptyReg;  
                         Scale           = 0;  
                         Displacement= (s32)target;  
696    
697                          // no reduction necessary :D          protected:
698                  }                  void Reduce();
699            };
700            
701            template< typename OperandType >        
702            class xIndirect : public xIndirectVoid
703            {
704                    typedef xIndirectVoid _parent;
705    
706                  virtual uint GetOperandSize() const { pxFail( "Invalid operation on ModSibBase" ); return 0; }          public:
707                  bool IsByteSizeDisp() const { return is_s8( Displacement ); }                  explicit xIndirect( s32 disp ) : _parent( disp ) {}
708                    explicit xIndirect( const xAddressInfo<OperandType>& src ) : _parent( src ) {}
709                    xIndirect( xAddressReg base, xAddressReg index, int scale=0, s32 displacement=0 )
710                            : _parent( base, index, scale, displacement ) {}
711    
712                  ModSibBase& Add( s32 imm )                  virtual uint GetOperandSize() const { return sizeof(OperandType); }
713    
714                    xIndirect<OperandType>& Add( s32 imm )
715                  {                  {
716                          Displacement += imm;                          Displacement += imm;
717                          return *this;                          return *this;
718                  }                  }
719    
720                  __forceinline ModSibBase operator+( const s32 imm ) const { return ModSibBase( *this ).Add( imm ); }                  __fi xIndirect<OperandType> operator+( const s32 imm ) const { return xIndirect( *this ).Add( imm ); }
721                  __forceinline ModSibBase operator-( const s32 imm ) const { return ModSibBase( *this ).Add( -imm ); }                  __fi xIndirect<OperandType> operator-( const s32 imm ) const { return xIndirect( *this ).Add( -imm ); }
722    
723                    bool operator==( const xIndirect<OperandType>& src ) const
724                    {
725                            return
726                                    ( Base == src.Base ) && ( Index == src.Index ) &&
727                                    ( Scale == src.Scale ) && ( Displacement == src.Displacement );
728                    }
729    
730                    bool operator!=( const xIndirect<OperandType>& src ) const
731                    {
732                            return !operator==( src );
733                    }
734    
735          protected:          protected:
736                  void Reduce();                  void Reduce();
737          };          };
738    
739            typedef xIndirect<u128> xIndirect128;
740            typedef xIndirect<u64> xIndirect64;
741            typedef xIndirect<u32> xIndirect32;
742            typedef xIndirect<u16> xIndirect16;
743            typedef xIndirect<u8> xIndirect8;
744    
745          // --------------------------------------------------------------------------------------          // --------------------------------------------------------------------------------------
746          //  ModSib32rrLass  -  base class 32, 16, and 8 bit operand types          //  xIndirect32orLass  -  base class 32, 16, and 8 bit operand types
747          // --------------------------------------------------------------------------------------          // --------------------------------------------------------------------------------------
748          class ModSib32orLess : public ModSibBase          class xIndirect32orLess : public xIndirectVoid
749          {          {
750                  typedef ModSibBase _parent;                  typedef xIndirectVoid _parent;
751    
752          protected:          protected:
753                  explicit ModSib32orLess( const xAddressInfo& src ) : _parent( src ) {}                  uint    m_OpSize;
                 explicit ModSib32orLess( s32 disp ) : _parent( disp ) {}  
                 ModSib32orLess( const void* target ) : _parent( target ) {}  
                 ModSib32orLess( xAddressReg base, xAddressReg index, int scale=0, s32 displacement=0 ) :  
                         _parent( base, index, scale, displacement ) {}  
         };  
754    
755          // --------------------------------------------------------------------------------------          public:
756          //  ModSib8/16/32/64/128                  xIndirect32orLess( const xIndirect8& src ) : _parent( src ) { m_OpSize = src.GetOperandSize(); }
757          // --------------------------------------------------------------------------------------                  xIndirect32orLess( const xIndirect16& src ) : _parent( src ) { m_OpSize = src.GetOperandSize(); }
758          // Strictly-typed version of ModSibBase, which is used to apply operand size information                  xIndirect32orLess( const xIndirect32& src ) : _parent( src ) { m_OpSize = src.GetOperandSize(); }
759          // to operations that do not involve an implicit operand size via register (such as  
760          // imm,mem or mem,imm)                  uint GetOperandSize() const { return m_OpSize; }
761          //  
762  #define DECLARE_CLASS_ModSibBits( bits, baseClass ) \          protected:
763          class ModSib##bits : public baseClass \                  //xIndirect32orLess( const xAddressVoid& src ) : _parent( src ) {}
         { \  
                 typedef baseClass _parent; \  
         public: \  
                 explicit ModSib##bits( const xAddressInfo& src ) : _parent( src ) {} \  
                 explicit ModSib##bits( s32 disp ) : _parent( disp ) {} \  
                 ModSib##bits( const u##bits* target ) : _parent( target ) {} \  
                 ModSib##bits( xAddressReg base, xAddressReg index, int scale=0, s32 displacement=0 ) : \  
                         _parent( base, index, scale, displacement ) {} \  
  \  
                 virtual uint GetOperandSize() const { return bits / 8; } \  
  \  
                 __forceinline ModSib##bits& Add( s32 imm ) \  
                 { \  
                         Displacement += imm; \  
                         return *this; \  
                 } \  
  \  
                 __forceinline ModSib##bits operator+( const s32 imm ) const { return ModSib##bits( *this ).Add( imm ); } \  
                 __forceinline ModSib##bits operator-( const s32 imm ) const { return ModSib##bits( *this ).Add( -imm ); } \  
  \  
                 bool operator==( const ModSib##bits& src ) const \  
                 { \  
                         return \  
                                 ( Base == src.Base ) && ( Index == src.Index ) && \  
                                 ( Scale == src.Scale ) && ( Displacement == src.Displacement ); \  
                 } \  
  \  
                 bool operator!=( const ModSib##bits& src ) const \  
                 { \  
                         return !operator==( src ); \  
                 } \  
         }  
764    
765          DECLARE_CLASS_ModSibBits( 8, ModSib32orLess );                  explicit xIndirect32orLess( s32 disp ) : _parent( disp ) {}
766          DECLARE_CLASS_ModSibBits( 16, ModSib32orLess );                  xIndirect32orLess( xAddressReg base, xAddressReg index, int scale=0, s32 displacement=0 ) :
767          DECLARE_CLASS_ModSibBits( 32, ModSib32orLess );                          _parent( base, index, scale, displacement ) {}
768          DECLARE_CLASS_ModSibBits( 64, ModSibBase );          };
         DECLARE_CLASS_ModSibBits( 128, ModSibBase );  
769    
770          // --------------------------------------------------------------------------------------          // --------------------------------------------------------------------------------------
771          //  xAddressIndexer          //  xAddressIndexer
772          // --------------------------------------------------------------------------------------          // --------------------------------------------------------------------------------------
773          // This is a type-translation "interface class" which provisions our ptr[] syntax.          // This is a type-translation "interface class" which provisions our ptr[] syntax.
774          // xAddressReg types go in, and ModSibBase derived types come out.          // xAddressReg types go in, and xIndirectVoid derived types come out.
775          //          //
776          template< typename xModSibType >          template< typename xModSibType >
777          struct xAddressIndexer          class xAddressIndexer
778          {          {
779            public:
780                  // passthrough instruction, allows ModSib to pass silently through ptr translation                  // passthrough instruction, allows ModSib to pass silently through ptr translation
781                  // without doing anything and without compiler error.                  // without doing anything and without compiler error.
782                  const xModSibType& operator[]( const xModSibType& src ) const { return src; }                  const xModSibType& operator[]( const xModSibType& src ) const { return src; }
783    
784                  xModSibType operator[]( xAddressReg src ) const                  xModSibType operator[]( const xAddressReg& src ) const
785                  {                  {
786                          return xModSibType( src, xEmptyReg );                          return xModSibType( src, xEmptyReg );
787                  }                  }
788    
789                  xModSibType operator[]( const xAddressInfo& src ) const                  xModSibType operator[]( const xAddressVoid& src ) const
                 {  
                         return xModSibType( src );  
                 }  
   
                 xModSibType operator[]( uptr src ) const  
790                  {                  {
791                          return xModSibType( src );                          return xModSibType( src.Base, src.Index, src.Factor, src.Displacement );
792                  }                  }
793    
794                  xModSibType operator[]( const void* src ) const                  xModSibType operator[]( const void* src ) const
# Line 771  template< typename T > void xWrite( T va Line 799  template< typename T > void xWrite( T va
799    
800          // ptr[] - use this form for instructions which can resolve the address operand size from          // ptr[] - use this form for instructions which can resolve the address operand size from
801          // the other register operand sizes.          // the other register operand sizes.
802          extern const xAddressIndexer<ModSibBase>        ptr;          extern const xAddressIndexer<xIndirectVoid>             ptr;
803          extern const xAddressIndexer<ModSib128>         ptr128;          extern const xAddressIndexer<xIndirect128>              ptr128;
804          extern const xAddressIndexer<ModSib64>          ptr64;          extern const xAddressIndexer<xIndirect64>               ptr64;
805          extern const xAddressIndexer<ModSib32>          ptr32;          extern const xAddressIndexer<xIndirect32>               ptr32;
806          extern const xAddressIndexer<ModSib16>          ptr16;          extern const xAddressIndexer<xIndirect16>               ptr16;
807          extern const xAddressIndexer<ModSib8>           ptr8;          extern const xAddressIndexer<xIndirect8>                ptr8;
808    
809          // --------------------------------------------------------------------------------------          // --------------------------------------------------------------------------------------
810          //  xDirectOrIndirect          //  xDirectOrIndirect
# Line 823  template< typename T > void xWrite( T va Line 851  template< typename T > void xWrite( T va
851                  bool operator!=( const xRegType& src ) const    { return (m_RegDirect != src); }                  bool operator!=( const xRegType& src ) const    { return (m_RegDirect != src); }
852          };          };
853    
854          typedef xDirectOrIndirect<xRegister8,ModSib8>           xDirectOrIndirect8;          typedef xDirectOrIndirect<xRegister8,xIndirect8>                xDirectOrIndirect8;
855          typedef xDirectOrIndirect<xRegister16,ModSib16>         xDirectOrIndirect16;          typedef xDirectOrIndirect<xRegister16,xIndirect16>              xDirectOrIndirect16;
856          typedef xDirectOrIndirect<xRegister32,ModSib32>         xDirectOrIndirect32;          typedef xDirectOrIndirect<xRegister32,xIndirect32>              xDirectOrIndirect32;
857          typedef xDirectOrIndirect<xRegisterMMX,ModSib64>        xDirectOrIndirect64;          typedef xDirectOrIndirect<xRegisterMMX,xIndirect64>     xDirectOrIndirect64;
858          typedef xDirectOrIndirect<xRegisterSSE,ModSib128>       xDirectOrIndirect128;          typedef xDirectOrIndirect<xRegisterSSE,xIndirect128>    xDirectOrIndirect128;
859  #endif  #endif
860    
861          // --------------------------------------------------------------------------------------          // --------------------------------------------------------------------------------------
# Line 935  template< typename T > void xWrite( T va Line 963  template< typename T > void xWrite( T va
963                  }                  }
964          };          };
965    
966          static __forceinline xAddressInfo operator+( const void* addr, const xAddressReg& reg )          static __fi xAddressVoid operator+( const void* addr, const xAddressReg& reg )
         {  
                 return xAddressInfo( reg, (sptr)addr );  
         }  
   
         static __forceinline xAddressInfo operator+( const void* addr, const xAddressInfo& reg )  
         {  
                 return xAddressInfo( (sptr)addr ).Add( reg );  
         }  
   
         static __forceinline xAddressInfo operator+( s32 addr, const xAddressReg& reg )  
967          {          {
968                  return xAddressInfo( reg, (sptr)addr );                  return reg + (sptr)addr;
969          }          }
970    
971          static __forceinline xAddressInfo operator+( s32 addr, const xAddressInfo& reg )          static __fi xAddressVoid operator+( s32 addr, const xAddressReg& reg )
972          {          {
973                  return xAddressInfo( (sptr)addr ).Add( reg );                  return reg + (sptr)addr;
974          }          }
975  }  }
976    

Legend:
Removed from v.61  
changed lines
  Added in v.62

  ViewVC Help
Powered by ViewVC 1.1.22