Home | History | Annotate | Download | only in priv
      1 
      2 /*---------------------------------------------------------------*/
      3 /*--- begin                                  guest_x86_defs.h ---*/
      4 /*---------------------------------------------------------------*/
      5 
      6 /*
      7    This file is part of Valgrind, a dynamic binary instrumentation
      8    framework.
      9 
     10    Copyright (C) 2004-2010 OpenWorks LLP
     11       info (at) open-works.net
     12 
     13    This program is free software; you can redistribute it and/or
     14    modify it under the terms of the GNU General Public License as
     15    published by the Free Software Foundation; either version 2 of the
     16    License, or (at your option) any later version.
     17 
     18    This program is distributed in the hope that it will be useful, but
     19    WITHOUT ANY WARRANTY; without even the implied warranty of
     20    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
     21    General Public License for more details.
     22 
     23    You should have received a copy of the GNU General Public License
     24    along with this program; if not, write to the Free Software
     25    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
     26    02110-1301, USA.
     27 
     28    The GNU General Public License is contained in the file COPYING.
     29 
     30    Neither the names of the U.S. Department of Energy nor the
     31    University of California nor the names of its contributors may be
     32    used to endorse or promote products derived from this software
     33    without prior written permission.
     34 */
     35 
     36 /* Only to be used within the guest-x86 directory. */
     37 
     38 #ifndef __VEX_GUEST_X86_DEFS_H
     39 #define __VEX_GUEST_X86_DEFS_H
     40 
     41 
     42 /*---------------------------------------------------------*/
     43 /*--- x86 to IR conversion                              ---*/
     44 /*---------------------------------------------------------*/
     45 
     46 /* Convert one x86 insn to IR.  See the type DisOneInstrFn in
     47    bb_to_IR.h. */
     48 extern
     49 DisResult disInstr_X86 ( IRSB*        irbb,
     50                          Bool         put_IP,
     51                          Bool         (*resteerOkFn) ( void*, Addr64 ),
     52                          Bool         resteerCisOk,
     53                          void*        callback_opaque,
     54                          UChar*       guest_code,
     55                          Long         delta,
     56                          Addr64       guest_IP,
     57                          VexArch      guest_arch,
     58                          VexArchInfo* archinfo,
     59                          VexAbiInfo*  abiinfo,
     60                          Bool         host_bigendian );
     61 
     62 /* Used by the optimiser to specialise calls to helpers. */
     63 extern
     64 IRExpr* guest_x86_spechelper ( HChar*   function_name,
     65                                IRExpr** args,
     66                                IRStmt** precedingStmts,
     67                                Int      n_precedingStmts );
     68 
     69 /* Describes to the optimiser which part of the guest state require
     70    precise memory exceptions.  This is logically part of the guest
     71    state description. */
     72 extern
     73 Bool guest_x86_state_requires_precise_mem_exns ( Int, Int );
     74 
     75 extern
     76 VexGuestLayout x86guest_layout;
     77 
     78 
     79 /*---------------------------------------------------------*/
     80 /*--- x86 guest helpers                                 ---*/
     81 /*---------------------------------------------------------*/
     82 
     83 /* --- CLEAN HELPERS --- */
     84 
     85 extern UInt  x86g_calculate_eflags_all (
     86                 UInt cc_op, UInt cc_dep1, UInt cc_dep2, UInt cc_ndep
     87              );
     88 
     89 __attribute((regparm(3)))
     90 extern UInt  x86g_calculate_eflags_c (
     91                 UInt cc_op, UInt cc_dep1, UInt cc_dep2, UInt cc_ndep
     92              );
     93 
     94 extern UInt  x86g_calculate_condition (
     95                 UInt/*X86Condcode*/ cond,
     96                 UInt cc_op,
     97                 UInt cc_dep1, UInt cc_dep2, UInt cc_ndep
     98              );
     99 
    100 extern UInt  x86g_calculate_FXAM ( UInt tag, ULong dbl );
    101 
    102 extern ULong x86g_calculate_RCR (
    103                 UInt arg, UInt rot_amt, UInt eflags_in, UInt sz
    104              );
    105 extern ULong x86g_calculate_RCL (
    106                 UInt arg, UInt rot_amt, UInt eflags_in, UInt sz
    107              );
    108 
    109 extern UInt x86g_calculate_daa_das_aaa_aas ( UInt AX_and_flags, UInt opcode );
    110 
    111 extern UInt x86g_calculate_aad_aam ( UInt AX_and_flags, UInt opcode );
    112 
    113 extern ULong x86g_check_fldcw ( UInt fpucw );
    114 
    115 extern UInt  x86g_create_fpucw ( UInt fpround );
    116 
    117 extern ULong x86g_check_ldmxcsr ( UInt mxcsr );
    118 
    119 extern UInt  x86g_create_mxcsr ( UInt sseround );
    120 
    121 
    122 /* Translate a guest virtual_addr into a guest linear address by
    123    consulting the supplied LDT/GDT structures.  Their representation
    124    must be as specified in pub/libvex_guest_x86.h.  To indicate a
    125    translation failure, 1<<32 is returned.  On success, the lower 32
    126    bits of the returned result indicate the linear address.
    127 */
    128 extern
    129 ULong x86g_use_seg_selector ( HWord ldt, HWord gdt,
    130                               UInt seg_selector, UInt virtual_addr );
    131 
    132 extern ULong x86g_calculate_mmx_pmaddwd  ( ULong, ULong );
    133 extern ULong x86g_calculate_mmx_psadbw   ( ULong, ULong );
    134 extern UInt  x86g_calculate_mmx_pmovmskb ( ULong );
    135 extern UInt  x86g_calculate_sse_pmovmskb ( ULong w64hi, ULong w64lo );
    136 
    137 
    138 /* --- DIRTY HELPERS --- */
    139 
    140 extern ULong x86g_dirtyhelper_loadF80le  ( UInt );
    141 
    142 extern void  x86g_dirtyhelper_storeF80le ( UInt, ULong );
    143 
    144 extern void  x86g_dirtyhelper_CPUID_sse0 ( VexGuestX86State* );
    145 extern void  x86g_dirtyhelper_CPUID_sse1 ( VexGuestX86State* );
    146 extern void  x86g_dirtyhelper_CPUID_sse2 ( VexGuestX86State* );
    147 
    148 extern void  x86g_dirtyhelper_FINIT ( VexGuestX86State* );
    149 
    150 extern void  x86g_dirtyhelper_FXSAVE ( VexGuestX86State*, HWord );
    151 extern void  x86g_dirtyhelper_FSAVE  ( VexGuestX86State*, HWord );
    152 extern void  x86g_dirtyhelper_FSTENV ( VexGuestX86State*, HWord );
    153 
    154 extern ULong x86g_dirtyhelper_RDTSC ( void );
    155 
    156 extern UInt x86g_dirtyhelper_IN  ( UInt portno, UInt sz/*1,2 or 4*/ );
    157 extern void x86g_dirtyhelper_OUT ( UInt portno, UInt data,
    158                                    UInt sz/*1,2 or 4*/ );
    159 
    160 extern void x86g_dirtyhelper_SxDT ( void* address,
    161                                     UInt op /* 0 or 1 */ );
    162 
    163 extern VexEmWarn
    164             x86g_dirtyhelper_FXRSTOR ( VexGuestX86State*, HWord );
    165 
    166 extern VexEmWarn
    167             x86g_dirtyhelper_FRSTOR ( VexGuestX86State*, HWord );
    168 
    169 extern VexEmWarn
    170             x86g_dirtyhelper_FLDENV ( VexGuestX86State*, HWord );
    171 
    172 
    173 /*---------------------------------------------------------*/
    174 /*--- Condition code stuff                              ---*/
    175 /*---------------------------------------------------------*/
    176 
    177 /* eflags masks */
    178 #define X86G_CC_SHIFT_O   11
    179 #define X86G_CC_SHIFT_S   7
    180 #define X86G_CC_SHIFT_Z   6
    181 #define X86G_CC_SHIFT_A   4
    182 #define X86G_CC_SHIFT_C   0
    183 #define X86G_CC_SHIFT_P   2
    184 
    185 #define X86G_CC_MASK_O    (1 << X86G_CC_SHIFT_O)
    186 #define X86G_CC_MASK_S    (1 << X86G_CC_SHIFT_S)
    187 #define X86G_CC_MASK_Z    (1 << X86G_CC_SHIFT_Z)
    188 #define X86G_CC_MASK_A    (1 << X86G_CC_SHIFT_A)
    189 #define X86G_CC_MASK_C    (1 << X86G_CC_SHIFT_C)
    190 #define X86G_CC_MASK_P    (1 << X86G_CC_SHIFT_P)
    191 
    192 /* FPU flag masks */
    193 #define X86G_FC_SHIFT_C3   14
    194 #define X86G_FC_SHIFT_C2   10
    195 #define X86G_FC_SHIFT_C1   9
    196 #define X86G_FC_SHIFT_C0   8
    197 
    198 #define X86G_FC_MASK_C3    (1 << X86G_FC_SHIFT_C3)
    199 #define X86G_FC_MASK_C2    (1 << X86G_FC_SHIFT_C2)
    200 #define X86G_FC_MASK_C1    (1 << X86G_FC_SHIFT_C1)
    201 #define X86G_FC_MASK_C0    (1 << X86G_FC_SHIFT_C0)
    202 
    203 
    204 /* %EFLAGS thunk descriptors.  A four-word thunk is used to record
    205    details of the most recent flag-setting operation, so the flags can
    206    be computed later if needed.  It is possible to do this a little
    207    more efficiently using a 3-word thunk, but that makes it impossible
    208    to describe the flag data dependencies sufficiently accurately for
    209    Memcheck.  Hence 4 words are used, with minimal loss of efficiency.
    210 
    211    The four words are:
    212 
    213       CC_OP, which describes the operation.
    214 
    215       CC_DEP1 and CC_DEP2.  These are arguments to the operation.
    216          We want Memcheck to believe that the resulting flags are
    217          data-dependent on both CC_DEP1 and CC_DEP2, hence the
    218          name DEP.
    219 
    220       CC_NDEP.  This is a 3rd argument to the operation which is
    221          sometimes needed.  We arrange things so that Memcheck does
    222          not believe the resulting flags are data-dependent on CC_NDEP
    223          ("not dependent").
    224 
    225    To make Memcheck believe that (the definedness of) the encoded
    226    flags depends only on (the definedness of) CC_DEP1 and CC_DEP2
    227    requires two things:
    228 
    229    (1) In the guest state layout info (x86guest_layout), CC_OP and
    230        CC_NDEP are marked as always defined.
    231 
    232    (2) When passing the thunk components to an evaluation function
    233        (calculate_condition, calculate_eflags, calculate_eflags_c) the
    234        IRCallee's mcx_mask must be set so as to exclude from
    235        consideration all passed args except CC_DEP1 and CC_DEP2.
    236 
    237    Strictly speaking only (2) is necessary for correctness.  However,
    238    (1) helps efficiency in that since (2) means we never ask about the
    239    definedness of CC_OP or CC_NDEP, we may as well not even bother to
    240    track their definedness.
    241 
    242    When building the thunk, it is always necessary to write words into
    243    CC_DEP1 and CC_DEP2, even if those args are not used given the
    244    CC_OP field (eg, CC_DEP2 is not used if CC_OP is CC_LOGIC1/2/4).
    245    This is important because otherwise Memcheck could give false
    246    positives as it does not understand the relationship between the
    247    CC_OP field and CC_DEP1 and CC_DEP2, and so believes that the
    248    definedness of the stored flags always depends on both CC_DEP1 and
    249    CC_DEP2.
    250 
    251    However, it is only necessary to set CC_NDEP when the CC_OP value
    252    requires it, because Memcheck ignores CC_NDEP, and the evaluation
    253    functions do understand the CC_OP fields and will only examine
    254    CC_NDEP for suitable values of CC_OP.
    255 
    256    A summary of the field usages is:
    257 
    258    Operation          DEP1               DEP2               NDEP
    259    ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~~
    260 
    261    add/sub/mul        first arg          second arg         unused
    262 
    263    adc/sbb            first arg          (second arg)
    264                                          XOR old_carry      old_carry
    265 
    266    and/or/xor         result             zero               unused
    267 
    268    inc/dec            result             zero               old_carry
    269 
    270    shl/shr/sar        result             subshifted-        unused
    271                                          result
    272 
    273    rol/ror            result             zero               old_flags
    274 
    275    copy               old_flags          zero               unused.
    276 
    277 
    278    Therefore Memcheck will believe the following:
    279 
    280    * add/sub/mul -- definedness of result flags depends on definedness
    281      of both args.
    282 
    283    * adc/sbb -- definedness of result flags depends on definedness of
    284      both args and definedness of the old C flag.  Because only two
    285      DEP fields are available, the old C flag is XOR'd into the second
    286      arg so that Memcheck sees the data dependency on it.  That means
    287      the NDEP field must contain a second copy of the old C flag
    288      so that the evaluation functions can correctly recover the second
    289      arg.
    290 
    291    * and/or/xor are straightforward -- definedness of result flags
    292      depends on definedness of result value.
    293 
    294    * inc/dec -- definedness of result flags depends only on
    295      definedness of result.  This isn't really true -- it also depends
    296      on the old C flag.  However, we don't want Memcheck to see that,
    297      and so the old C flag must be passed in NDEP and not in DEP2.
    298      It's inconceivable that a compiler would generate code that puts
    299      the C flag in an undefined state, then does an inc/dec, which
    300      leaves C unchanged, and then makes a conditional jump/move based
    301      on C.  So our fiction seems a good approximation.
    302 
    303    * shl/shr/sar -- straightforward, again, definedness of result
    304      flags depends on definedness of result value.  The subshifted
    305      value (value shifted one less) is also needed, but its
    306      definedness is the same as the definedness of the shifted value.
    307 
    308    * rol/ror -- these only set O and C, and leave A Z C P alone.
    309      However it seems prudent (as per inc/dec) to say the definedness
    310      of all resulting flags depends on the definedness of the result,
    311      hence the old flags must go in as NDEP and not DEP2.
    312 
    313    * rcl/rcr are too difficult to do in-line, and so are done by a
    314      helper function.  They are not part of this scheme.  The helper
    315      function takes the value to be rotated, the rotate amount and the
    316      old flags, and returns the new flags and the rotated value.
    317      Since the helper's mcx_mask does not have any set bits, Memcheck
    318      will lazily propagate undefinedness from any of the 3 args into
    319      both results (flags and actual value).
    320 */
    321 enum {
    322     X86G_CC_OP_COPY=0,  /* DEP1 = current flags, DEP2 = 0, NDEP = unused */
    323                         /* just copy DEP1 to output */
    324 
    325     X86G_CC_OP_ADDB,    /* 1 */
    326     X86G_CC_OP_ADDW,    /* 2 DEP1 = argL, DEP2 = argR, NDEP = unused */
    327     X86G_CC_OP_ADDL,    /* 3 */
    328 
    329     X86G_CC_OP_SUBB,    /* 4 */
    330     X86G_CC_OP_SUBW,    /* 5 DEP1 = argL, DEP2 = argR, NDEP = unused */
    331     X86G_CC_OP_SUBL,    /* 6 */
    332 
    333     X86G_CC_OP_ADCB,    /* 7 */
    334     X86G_CC_OP_ADCW,    /* 8 DEP1 = argL, DEP2 = argR ^ oldCarry, NDEP = oldCarry */
    335     X86G_CC_OP_ADCL,    /* 9 */
    336 
    337     X86G_CC_OP_SBBB,    /* 10 */
    338     X86G_CC_OP_SBBW,    /* 11 DEP1 = argL, DEP2 = argR ^ oldCarry, NDEP = oldCarry */
    339     X86G_CC_OP_SBBL,    /* 12 */
    340 
    341     X86G_CC_OP_LOGICB,  /* 13 */
    342     X86G_CC_OP_LOGICW,  /* 14 DEP1 = result, DEP2 = 0, NDEP = unused */
    343     X86G_CC_OP_LOGICL,  /* 15 */
    344 
    345     X86G_CC_OP_INCB,    /* 16 */
    346     X86G_CC_OP_INCW,    /* 17 DEP1 = result, DEP2 = 0, NDEP = oldCarry (0 or 1) */
    347     X86G_CC_OP_INCL,    /* 18 */
    348 
    349     X86G_CC_OP_DECB,    /* 19 */
    350     X86G_CC_OP_DECW,    /* 20 DEP1 = result, DEP2 = 0, NDEP = oldCarry (0 or 1) */
    351     X86G_CC_OP_DECL,    /* 21 */
    352 
    353     X86G_CC_OP_SHLB,    /* 22 DEP1 = res, DEP2 = res', NDEP = unused */
    354     X86G_CC_OP_SHLW,    /* 23 where res' is like res but shifted one bit less */
    355     X86G_CC_OP_SHLL,    /* 24 */
    356 
    357     X86G_CC_OP_SHRB,    /* 25 DEP1 = res, DEP2 = res', NDEP = unused */
    358     X86G_CC_OP_SHRW,    /* 26 where res' is like res but shifted one bit less */
    359     X86G_CC_OP_SHRL,    /* 27 */
    360 
    361     X86G_CC_OP_ROLB,    /* 28 */
    362     X86G_CC_OP_ROLW,    /* 29 DEP1 = res, DEP2 = 0, NDEP = old flags */
    363     X86G_CC_OP_ROLL,    /* 30 */
    364 
    365     X86G_CC_OP_RORB,    /* 31 */
    366     X86G_CC_OP_RORW,    /* 32 DEP1 = res, DEP2 = 0, NDEP = old flags */
    367     X86G_CC_OP_RORL,    /* 33 */
    368 
    369     X86G_CC_OP_UMULB,   /* 34 */
    370     X86G_CC_OP_UMULW,   /* 35 DEP1 = argL, DEP2 = argR, NDEP = unused */
    371     X86G_CC_OP_UMULL,   /* 36 */
    372 
    373     X86G_CC_OP_SMULB,   /* 37 */
    374     X86G_CC_OP_SMULW,   /* 38 DEP1 = argL, DEP2 = argR, NDEP = unused */
    375     X86G_CC_OP_SMULL,   /* 39 */
    376 
    377     X86G_CC_OP_NUMBER
    378 };
    379 
    380 typedef
    381    enum {
    382       X86CondO      = 0,  /* overflow           */
    383       X86CondNO     = 1,  /* no overflow        */
    384 
    385       X86CondB      = 2,  /* below              */
    386       X86CondNB     = 3,  /* not below          */
    387 
    388       X86CondZ      = 4,  /* zero               */
    389       X86CondNZ     = 5,  /* not zero           */
    390 
    391       X86CondBE     = 6,  /* below or equal     */
    392       X86CondNBE    = 7,  /* not below or equal */
    393 
    394       X86CondS      = 8,  /* negative           */
    395       X86CondNS     = 9,  /* not negative       */
    396 
    397       X86CondP      = 10, /* parity even        */
    398       X86CondNP     = 11, /* not parity even    */
    399 
    400       X86CondL      = 12, /* jump less          */
    401       X86CondNL     = 13, /* not less           */
    402 
    403       X86CondLE     = 14, /* less or equal      */
    404       X86CondNLE    = 15, /* not less or equal  */
    405 
    406       X86CondAlways = 16  /* HACK */
    407    }
    408    X86Condcode;
    409 
    410 #endif /* ndef __VEX_GUEST_X86_DEFS_H */
    411 
    412 /*---------------------------------------------------------------*/
    413 /*--- end                                    guest_x86_defs.h ---*/
    414 /*---------------------------------------------------------------*/
    415