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-2011 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 VEX_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
