priv/guest-x86/gdefs.h

/*---------------------------------------------------------------*/
/*---                                                         ---*/
/*--- This file (guest-x86/gdefs.h) is                        ---*/
/*--- Copyright (c) 2004 OpenWorks LLP.  All rights reserved. ---*/
/*---                                                         ---*/
/*---------------------------------------------------------------*/

/*
   This file is part of LibVEX, a library for dynamic binary
   instrumentation and translation.

   Copyright (C) 2004 OpenWorks, LLP.

   This program is free software; you can redistribute it and/or modify
   it under the terms of the GNU General Public License as published by
   the Free Software Foundation; Version 2 dated June 1991 of the
   license.

   This program is distributed in the hope that it will be useful,
   but WITHOUT ANY WARRANTY; without even the implied warranty of
   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE, or liability
   for damages.  See the GNU General Public License for more details.

   Neither the names of the U.S. Department of Energy nor the
   University of California nor the names of its contributors may be
   used to endorse or promote products derived from this software
   without prior written permission.

   You should have received a copy of the GNU General Public License
   along with this program; if not, write to the Free Software
   Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
   USA.
*/

/* Only to be used within the guest-x86 directory. */

/* Some of this stuff is taken from QEMU, which is Copyright (c) 2003
   Fabrice Bellard, and licensed under the LGPL. */

#ifndef __LIBVEX_GUEST_X86_DEFS_H
#define __LIBVEX_GUEST_X86_DEFS_H


/*---------------------------------------------------------*/
/*--- x86 to IR conversion                              ---*/
/*---------------------------------------------------------*/

extern
IRBB* bbToIR_X86 ( UChar* x86code, 
                   Addr64 eip, 
                   Int*   guest_bytes_read, 
                   Bool   (*byte_accessible)(Addr64),
                   Bool   (*resteerOkFn)(Addr64),
                   Bool   host_bigendian );

/* Used by the optimiser to specialise calls to helpers. */
extern
IRExpr* guest_x86_spechelper ( Char* function_name,
                               IRExpr** args );

/* Describes to the optimser which part of the guest state require
   precise memory exceptions.  This is logically part of the guest
   state description. */
extern 
Bool guest_x86_state_requires_precise_mem_exns ( Int, Int );

extern
VexGuestLayout x86guest_layout;


/*---------------------------------------------------------*/
/*--- x86 guest helpers                                 ---*/
/*---------------------------------------------------------*/

/* --- CLEAN HELPERS --- */

extern UInt  x86g_calculate_eflags_all ( 
                UInt cc_op, UInt cc_dep1, UInt cc_dep2, UInt cc_ndep 
             );

extern UInt  x86g_calculate_eflags_c ( 
                UInt cc_op, UInt cc_dep1, UInt cc_dep2, UInt cc_ndep 
             );

extern UInt  x86g_calculate_condition ( 
                UInt/*X86Condcode*/ cond, 
                UInt cc_op, 
                UInt cc_dep1, UInt cc_dep2, UInt cc_ndep 
             );

extern UInt  x86g_calculate_FXAM ( UInt tag, ULong dbl );

extern ULong x86g_calculate_RCR  ( 
                UInt arg, UInt rot_amt, UInt eflags_in, UInt sz 
             );

extern ULong x86g_check_fldcw ( UInt fpucw );

extern UInt x86g_create_fpucw ( UInt fpround );

extern ULong x86g_check_ldmxcsr ( UInt mxcsr );

extern UInt x86g_create_mxcsr ( UInt sseround );

/* Translate a guest virtual_addr into a guest linear address by
   consulting the supplied LDT/GDT structures.  Their representation
   must be as specified in pub/libvex_guest_x86.h.  To indicate a
   translation failure, 1<<32 is returned.  On success, the lower 32
   bits of the returned result indicate the linear address.  
*/
extern 
ULong x86g_use_seg_selector ( HWord ldt, HWord gdt, 
                              UInt seg_selector, UInt virtual_addr );

/* --- Clean helpers for MMX --- */

extern ULong x86g_calculate_add64x1 ( ULong, ULong );
extern ULong x86g_calculate_add32x2 ( ULong, ULong );
extern ULong x86g_calculate_add16x4 ( ULong, ULong );
extern ULong x86g_calculate_add8x8  ( ULong, ULong );

extern ULong x86g_calculate_qadd16Sx4 ( ULong, ULong );
extern ULong x86g_calculate_qadd8Sx8  ( ULong, ULong );

extern ULong x86g_calculate_qadd16Ux4 ( ULong, ULong );
extern ULong x86g_calculate_qadd8Ux8  ( ULong, ULong );

extern ULong x86g_calculate_sub64x1 ( ULong, ULong );
extern ULong x86g_calculate_sub32x2 ( ULong, ULong );
extern ULong x86g_calculate_sub16x4 ( ULong, ULong );
extern ULong x86g_calculate_sub8x8  ( ULong, ULong );

extern ULong x86g_calculate_qsub16Sx4 ( ULong, ULong );
extern ULong x86g_calculate_qsub8Sx8  ( ULong, ULong );

extern ULong x86g_calculate_qsub16Ux4 ( ULong, ULong );
extern ULong x86g_calculate_qsub8Ux8  ( ULong, ULong );

extern ULong x86g_calculate_mulhi16x4 ( ULong, ULong );
extern ULong x86g_calculate_mullo16x4 ( ULong, ULong );

extern ULong x86g_calculate_pmaddwd ( ULong, ULong );

extern ULong x86g_calculate_cmpeq32x2  ( ULong, ULong );
extern ULong x86g_calculate_cmpeq16x4  ( ULong, ULong );
extern ULong x86g_calculate_cmpeq8x8   ( ULong, ULong );
extern ULong x86g_calculate_cmpge32Sx2 ( ULong, ULong );
extern ULong x86g_calculate_cmpge16Sx4 ( ULong, ULong );
extern ULong x86g_calculate_cmpge8Sx8  ( ULong, ULong );

extern ULong x86g_calculate_packssdw ( ULong, ULong );
extern ULong x86g_calculate_packsswb ( ULong, ULong );
extern ULong x86g_calculate_packuswb ( ULong, ULong );

extern ULong x86g_calculate_punpckhbw ( ULong, ULong );
extern ULong x86g_calculate_punpcklbw ( ULong, ULong );
extern ULong x86g_calculate_punpckhwd ( ULong, ULong );
extern ULong x86g_calculate_punpcklwd ( ULong, ULong );
extern ULong x86g_calculate_punpckhdq ( ULong, ULong );
extern ULong x86g_calculate_punpckldq ( ULong, ULong );

extern ULong x86g_calculate_shl16x4 ( ULong, ULong );
extern ULong x86g_calculate_shl32x2 ( ULong, ULong );
extern ULong x86g_calculate_shl64x1 ( ULong, ULong );

extern ULong x86g_calculate_shr16Ux4 ( ULong, ULong );
extern ULong x86g_calculate_shr32Ux2 ( ULong, ULong );
extern ULong x86g_calculate_shr64Ux1 ( ULong, ULong );

extern ULong x86g_calculate_shr16Sx4 ( ULong, ULong );
extern ULong x86g_calculate_shr32Sx2 ( ULong, ULong );

extern ULong x86g_calculate_avg8Ux8  ( ULong, ULong );
extern ULong x86g_calculate_avg16Ux4 ( ULong, ULong );

extern ULong x86g_calculate_max16Sx4 ( ULong, ULong );
extern ULong x86g_calculate_max8Ux8  ( ULong, ULong );
extern ULong x86g_calculate_min16Sx4 ( ULong, ULong );
extern ULong x86g_calculate_min8Ux8  ( ULong, ULong );

extern UInt  x86g_calculate_pmovmskb ( ULong xx );
extern ULong x86g_calculate_psadbw ( ULong, ULong );

extern ULong x86g_calculate_mull16uHIx4 ( ULong, ULong );

extern UInt  x86g_calculate_sse_pmovmskb ( ULong w64hi, ULong w64lo );

/* --- DIRTY HELPERS --- */

extern ULong x86g_loadF80le  ( UInt );

extern void  x86g_storeF80le ( UInt, ULong );

extern void  x86g_dirtyhelper_CPUID ( VexGuestX86State* );

extern void  x86g_dirtyhelper_FSAVE ( VexGuestX86State*, HWord );

extern VexEmWarn
            x86g_dirtyhelper_FRSTOR ( VexGuestX86State*, HWord );

extern void x86g_dirtyhelper_FSTENV ( VexGuestX86State*, HWord );

extern VexEmWarn 
            x86g_dirtyhelper_FLDENV ( VexGuestX86State*, HWord );


/*---------------------------------------------------------*/
/*--- Condition code stuff                              ---*/
/*---------------------------------------------------------*/

/* eflags masks */
#define X86G_CC_SHIFT_O   11
#define X86G_CC_SHIFT_S   7
#define X86G_CC_SHIFT_Z   6
#define X86G_CC_SHIFT_A   4
#define X86G_CC_SHIFT_C   0
#define X86G_CC_SHIFT_P   2

#define X86G_CC_MASK_O    (1 << X86G_CC_SHIFT_O)
#define X86G_CC_MASK_S    (1 << X86G_CC_SHIFT_S)
#define X86G_CC_MASK_Z    (1 << X86G_CC_SHIFT_Z)
#define X86G_CC_MASK_A    (1 << X86G_CC_SHIFT_A)
#define X86G_CC_MASK_C    (1 << X86G_CC_SHIFT_C)
#define X86G_CC_MASK_P    (1 << X86G_CC_SHIFT_P)

/* FPU flag masks */
#define X86G_FC_MASK_C3   (1 << 14)
#define X86G_FC_MASK_C2   (1 << 10)
#define X86G_FC_MASK_C1   (1 << 9)
#define X86G_FC_MASK_C0   (1 << 8)

/* %EFLAGS thunk descriptors.  A four-word thunk is used to record
   details of the most recent flag-setting operation, so the flags can
   be computed later if needed.  It is possible to do this a little
   more efficiently using a 3-word thunk, but that makes it impossible
   to describe the flag data dependencies sufficiently accurately for
   Memcheck.  Hence 4 words are used, with minimal loss of efficiency.

   The four words are:

      CC_OP, which describes the operation.

      CC_DEP1 and CC_DEP2.  These are arguments to the operation.
         We want Memcheck to believe that the resulting flags are
         data-dependent on both CC_DEP1 and CC_DEP2, hence the 
         name DEP.

      CC_NDEP.  This is a 3rd argument to the operation which is
         sometimes needed.  We arrange things so that Memcheck does
         not believe the resulting flags are data-dependent on CC_NDEP
         ("not dependent").

   To make Memcheck believe that (the definedness of) the encoded
   flags depends only on (the definedness of) CC_DEP1 and CC_DEP2
   requires two things:

   (1) In the guest state layout info (x86guest_layout), CC_OP and
       CC_NDEP are marked as always defined.

   (2) When passing the thunk components to an evaluation function
       (calculate_condition, calculate_eflags, calculate_eflags_c) the
       IRCallee's mcx_mask must be set so as to exclude from
       consideration all passed args except CC_DEP1 and CC_DEP2.

   Strictly speaking only (2) is necessary for correctness.  However,
   (1) helps efficiency in that since (2) means we never ask about the
   definedness of CC_OP or CC_NDEP, we may as well not even bother to
   track their definedness.

   When building the thunk, it is always necessary to write words into
   CC_DEP1 and CC_DEP2, even if those args are not used given the
   CC_OP field (eg, CC_DEP2 is not used if CC_OP is CC_LOGIC1/2/4).
   This is important because otherwise Memcheck could give false
   positives as it does not understand the relationship between the
   CC_OP field and CC_DEP1 and CC_DEP2, and so believes that the 
   definedness of the stored flags always depends on both CC_DEP1 and
   CC_DEP2.

   However, it is only necessary to set CC_NDEP when the CC_OP value
   requires it, because Memcheck ignores CC_NDEP, and the evaluation
   functions do understand the CC_OP fields and will only examine
   CC_NDEP for suitable values of CC_OP.

   A summary of the field usages is:

   Operation          DEP1               DEP2               NDEP
   ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~

   add/sub/mul        first arg          second arg         unused

   adc/sbb            first arg          (second arg)
                                         XOR old_carry      old_carry

   and/or/xor         result             zero               unused

   inc/dec            result             zero               old_carry

   shl/shr/sar        result             subshifted-        unused
                                         result

   rol/ror            result             zero               old_flags

   copy               old_flags          zero               unused.


   Therefore Memcheck will believe the following:

   * add/sub/mul -- definedness of result flags depends on definedness
     of both args.

   * adc/sbb -- definedness of result flags depends on definedness of
     both args and definedness of the old C flag.  Because only two
     DEP fields are available, the old C flag is XOR'd into the second
     arg so that Memcheck sees the data dependency on it.  That means
     the NDEP field must contain a second copy of the old C flag
     so that the evaluation functions can correctly recover the second
     arg.

   * and/or/xor are straightforward -- definedness of result flags
     depends on definedness of result value.

   * inc/dec -- definedness of result flags depends only on
     definedness of result.  This isn't really true -- it also depends
     on the old C flag.  However, we don't want Memcheck to see that,
     and so the old C flag must be passed in NDEP and not in DEP2.
     It's inconceivable that a compiler would generate code that puts
     the C flag in an undefined state, then does an inc/dec, which
     leaves C unchanged, and then makes a conditional jump/move based
     on C.  So our fiction seems a good approximation.

   * shl/shr/sar -- straightforward, again, definedness of result
     flags depends on definedness of result value.  The subshifted
     value (value shifted one less) is also needed, but its
     definedness is the same as the definedness of the shifted value.

   * rol/ror -- these only set O and C, and leave A Z C P alone.
     However it seems prudent (as per inc/dec) to say the definedness
     of all resulting flags depends on the definedness of the result,
     hence the old flags must go in as NDEP and not DEP2.

   * rcl/rcr are too difficult to do in-line, and so are done by a
     helper function.  They are not part of this scheme.  The helper
     function takes the value to be rotated, the rotate amount and the
     old flags, and returns the new flags and the rotated value.
     Since the helper's mcx_mask does not have any set bits, Memcheck
     will lazily propagate undefinedness from any of the 3 args into 
     both results (flags and actual value).
*/
enum {
    X86G_CC_OP_COPY,    /* DEP1 = current flags, DEP2 = 0, NDEP = unused */
                        /* just copy DEP1 to output */

    X86G_CC_OP_ADDB,    /* 1 */
    X86G_CC_OP_ADDW,    /* 2 DEP1 = argL, DEP2 = argR, NDEP = unused */
    X86G_CC_OP_ADDL,    /* 3 */

    X86G_CC_OP_SUBB,    /* 4 */
    X86G_CC_OP_SUBW,    /* 5 DEP1 = argL, DEP2 = argR, NDEP = unused */
    X86G_CC_OP_SUBL,    /* 6 */

    X86G_CC_OP_ADCB,    /* 7 */
    X86G_CC_OP_ADCW,    /* 8 DEP1 = argL, DEP2 = argR ^ oldCarry, NDEP = oldCarry */
    X86G_CC_OP_ADCL,    /* 9 */

    X86G_CC_OP_SBBB,    /* 10 */
    X86G_CC_OP_SBBW,    /* 11 DEP1 = argL, DEP2 = argR ^ oldCarry, NDEP = oldCarry */
    X86G_CC_OP_SBBL,    /* 12 */

    X86G_CC_OP_LOGICB,  /* 13 */
    X86G_CC_OP_LOGICW,  /* 14 DEP1 = result, DEP2 = 0, NDEP = unused */
    X86G_CC_OP_LOGICL,  /* 15 */

    X86G_CC_OP_INCB,    /* 16 */
    X86G_CC_OP_INCW,    /* 17 DEP1 = result, DEP2 = 0, NDEP = oldCarry (0 or 1) */
    X86G_CC_OP_INCL,    /* 18 */

    X86G_CC_OP_DECB,    /* 19 */
    X86G_CC_OP_DECW,    /* 20 DEP1 = result, DEP2 = 0, NDEP = oldCarry (0 or 1) */
    X86G_CC_OP_DECL,    /* 21 */

    X86G_CC_OP_SHLB,    /* 22 DEP1 = res, DEP2 = res', NDEP = unused */
    X86G_CC_OP_SHLW,    /* 23 where res' is like res but shifted one bit less */
    X86G_CC_OP_SHLL,    /* 24 */

    X86G_CC_OP_SHRB,    /* 25 DEP1 = res, DEP2 = res', NDEP = unused */
    X86G_CC_OP_SHRW,    /* 26 where res' is like res but shifted one bit less */
    X86G_CC_OP_SHRL,    /* 27 */

    X86G_CC_OP_ROLB,    /* 28 */
    X86G_CC_OP_ROLW,    /* 29 DEP1 = res, DEP2 = 0, NDEP = old flags */
    X86G_CC_OP_ROLL,    /* 30 */

    X86G_CC_OP_RORB,    /* 31 */
    X86G_CC_OP_RORW,    /* 32 DEP1 = res, DEP2 = 0, NDEP = old flags */
    X86G_CC_OP_RORL,    /* 33 */

    X86G_CC_OP_UMULB,   /* 34 */
    X86G_CC_OP_UMULW,   /* 35 DEP1 = argL, DEP2 = argR, NDEP = unused */
    X86G_CC_OP_UMULL,   /* 36 */

    X86G_CC_OP_SMULB,   /* 37 */
    X86G_CC_OP_SMULW,   /* 38 DEP1 = argL, DEP2 = argR, NDEP = unused */
    X86G_CC_OP_SMULL,   /* 39 */

    X86G_CC_OP_NUMBER
};

typedef
   enum {
      X86CondO      = 0,  /* overflow           */
      X86CondNO     = 1,  /* no overflow        */

      X86CondB      = 2,  /* below              */
      X86CondNB     = 3,  /* not below          */

      X86CondZ      = 4,  /* zero               */
      X86CondNZ     = 5,  /* not zero           */

      X86CondBE     = 6,  /* below or equal     */
      X86CondNBE    = 7,  /* not below or equal */

      X86CondS      = 8,  /* negative           */
      X86CondNS     = 9,  /* not negative       */

      X86CondP      = 10, /* parity even        */
      X86CondNP     = 11, /* not parity even    */

      X86CondL      = 12, /* jump less          */
      X86CondNL     = 13, /* not less           */

      X86CondLE     = 14, /* less or equal      */
      X86CondNLE    = 15, /* not less or equal  */

      X86CondAlways = 16  /* HACK */
   }
   X86Condcode;

#endif /* ndef __LIBVEX_GUEST_X86_DEFS_H */

/*---------------------------------------------------------------*/
/*--- end                                   guest-x86/gdefs.h ---*/
/*---------------------------------------------------------------*/