target-i386/cpu.h

   1 /*
   2  * i386 virtual CPU header
   3  *
   4  *  Copyright (c) 2003 Fabrice Bellard
   5  *
   6  * This library is free software; you can redistribute it and/or
   7  * modify it under the terms of the GNU Lesser General Public
   8  * License as published by the Free Software Foundation; either
   9  * version 2 of the License, or (at your option) any later version.
  10  *
  11  * This library is distributed in the hope that it will be useful,
  12  * but WITHOUT ANY WARRANTY; without even the implied warranty of
  13  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  14  * Lesser General Public License for more details.
  15  *
  16  * You should have received a copy of the GNU Lesser General Public
  17  * License along with this library; if not, see <http://www.gnu.org/licenses/>.
  18  */
  19
  20 #ifndef I386_CPU_H
  21 #define I386_CPU_H
  22
  23 #include "qemu-common.h"
  24 #include "cpu-qom.h"
  25 #include "standard-headers/asm-x86/hyperv.h"
  26
  27 #ifdef TARGET_X86_64
  28 #define TARGET_LONG_BITS 64
  29 #else
  30 #define TARGET_LONG_BITS 32
  31 #endif
  32
  33 /* Maximum instruction code size */
  34 #define TARGET_MAX_INSN_SIZE 16
  35
  36 /* support for self modifying code even if the modified instruction is
  37    close to the modifying instruction */
  38 #define TARGET_HAS_PRECISE_SMC
  39
  40 #ifdef TARGET_X86_64
  41 #define I386_ELF_MACHINE  EM_X86_64
  42 #define ELF_MACHINE_UNAME "x86_64"
  43 #else
  44 #define I386_ELF_MACHINE  EM_386
  45 #define ELF_MACHINE_UNAME "i686"
  46 #endif
  47
  48 #define CPUArchState struct CPUX86State
  49
  50 #include "exec/cpu-defs.h"
  51
  52 #include "fpu/softfloat.h"
  53
  54 #define R_EAX 0
  55 #define R_ECX 1
  56 #define R_EDX 2
  57 #define R_EBX 3
  58 #define R_ESP 4
  59 #define R_EBP 5
  60 #define R_ESI 6
  61 #define R_EDI 7
  62
  63 #define R_AL 0
  64 #define R_CL 1
  65 #define R_DL 2
  66 #define R_BL 3
  67 #define R_AH 4
  68 #define R_CH 5
  69 #define R_DH 6
  70 #define R_BH 7
  71
  72 #define R_ES 0
  73 #define R_CS 1
  74 #define R_SS 2
  75 #define R_DS 3
  76 #define R_FS 4
  77 #define R_GS 5
  78
  79 /* segment descriptor fields */
  80 #define DESC_G_MASK     (1 << 23)
  81 #define DESC_B_SHIFT    22
  82 #define DESC_B_MASK     (1 << DESC_B_SHIFT)
  83 #define DESC_L_SHIFT    21 /* x86_64 only : 64 bit code segment */
  84 #define DESC_L_MASK     (1 << DESC_L_SHIFT)
  85 #define DESC_AVL_MASK   (1 << 20)
  86 #define DESC_P_MASK     (1 << 15)
  87 #define DESC_DPL_SHIFT  13
  88 #define DESC_DPL_MASK   (3 << DESC_DPL_SHIFT)
  89 #define DESC_S_MASK     (1 << 12)
  90 #define DESC_TYPE_SHIFT 8
  91 #define DESC_TYPE_MASK  (15 << DESC_TYPE_SHIFT)
  92 #define DESC_A_MASK     (1 << 8)
  93
  94 #define DESC_CS_MASK    (1 << 11) /* 1=code segment 0=data segment */
  95 #define DESC_C_MASK     (1 << 10) /* code: conforming */
  96 #define DESC_R_MASK     (1 << 9)  /* code: readable */
  97
  98 #define DESC_E_MASK     (1 << 10) /* data: expansion direction */
  99 #define DESC_W_MASK     (1 << 9)  /* data: writable */
 100
 101 #define DESC_TSS_BUSY_MASK (1 << 9)
 102
 103 /* eflags masks */
 104 #define CC_C    0x0001
 105 #define CC_P    0x0004
 106 #define CC_A    0x0010
 107 #define CC_Z    0x0040
 108 #define CC_S    0x0080
 109 #define CC_O    0x0800
 110
 111 #define TF_SHIFT   8
 112 #define IOPL_SHIFT 12
 113 #define VM_SHIFT   17
 114
 115 #define TF_MASK                 0x00000100
 116 #define IF_MASK                 0x00000200
 117 #define DF_MASK                 0x00000400
 118 #define IOPL_MASK               0x00003000
 119 #define NT_MASK                 0x00004000
 120 #define RF_MASK                 0x00010000
 121 #define VM_MASK                 0x00020000
 122 #define AC_MASK                 0x00040000
 123 #define VIF_MASK                0x00080000
 124 #define VIP_MASK                0x00100000
 125 #define ID_MASK                 0x00200000
 126
 127 /* hidden flags - used internally by qemu to represent additional cpu
 128    states. Only the INHIBIT_IRQ, SMM and SVMI are not redundant. We
 129    avoid using the IOPL_MASK, TF_MASK, VM_MASK and AC_MASK bit
 130    positions to ease oring with eflags. */
 131 /* current cpl */
 132 #define HF_CPL_SHIFT         0
 133 /* true if hardware interrupts must be disabled for next instruction */
 134 #define HF_INHIBIT_IRQ_SHIFT 3
 135 /* 16 or 32 segments */
 136 #define HF_CS32_SHIFT        4
 137 #define HF_SS32_SHIFT        5
 138 /* zero base for DS, ES and SS : can be '0' only in 32 bit CS segment */
 139 #define HF_ADDSEG_SHIFT      6
 140 /* copy of CR0.PE (protected mode) */
 141 #define HF_PE_SHIFT          7
 142 #define HF_TF_SHIFT          8 /* must be same as eflags */
 143 #define HF_MP_SHIFT          9 /* the order must be MP, EM, TS */
 144 #define HF_EM_SHIFT         10
 145 #define HF_TS_SHIFT         11
 146 #define HF_IOPL_SHIFT       12 /* must be same as eflags */
 147 #define HF_LMA_SHIFT        14 /* only used on x86_64: long mode active */
 148 #define HF_CS64_SHIFT       15 /* only used on x86_64: 64 bit code segment  */
 149 #define HF_RF_SHIFT         16 /* must be same as eflags */
 150 #define HF_VM_SHIFT         17 /* must be same as eflags */
 151 #define HF_AC_SHIFT         18 /* must be same as eflags */
 152 #define HF_SMM_SHIFT        19 /* CPU in SMM mode */
 153 #define HF_SVME_SHIFT       20 /* SVME enabled (copy of EFER.SVME) */
 154 #define HF_SVMI_SHIFT       21 /* SVM intercepts are active */
 155 #define HF_OSFXSR_SHIFT     22 /* CR4.OSFXSR */
 156 #define HF_SMAP_SHIFT       23 /* CR4.SMAP */
 157 #define HF_IOBPT_SHIFT      24 /* an io breakpoint enabled */
 158 #define HF_MPX_EN_SHIFT     25 /* MPX Enabled (CR4+XCR0+BNDCFGx) */
 159 #define HF_MPX_IU_SHIFT     26 /* BND registers in-use */
 160
 161 #define HF_CPL_MASK          (3 << HF_CPL_SHIFT)
 162 #define HF_INHIBIT_IRQ_MASK  (1 << HF_INHIBIT_IRQ_SHIFT)
 163 #define HF_CS32_MASK         (1 << HF_CS32_SHIFT)
 164 #define HF_SS32_MASK         (1 << HF_SS32_SHIFT)
 165 #define HF_ADDSEG_MASK       (1 << HF_ADDSEG_SHIFT)
 166 #define HF_PE_MASK           (1 << HF_PE_SHIFT)
 167 #define HF_TF_MASK           (1 << HF_TF_SHIFT)
 168 #define HF_MP_MASK           (1 << HF_MP_SHIFT)
 169 #define HF_EM_MASK           (1 << HF_EM_SHIFT)
 170 #define HF_TS_MASK           (1 << HF_TS_SHIFT)
 171 #define HF_IOPL_MASK         (3 << HF_IOPL_SHIFT)
 172 #define HF_LMA_MASK          (1 << HF_LMA_SHIFT)
 173 #define HF_CS64_MASK         (1 << HF_CS64_SHIFT)
 174 #define HF_RF_MASK           (1 << HF_RF_SHIFT)
 175 #define HF_VM_MASK           (1 << HF_VM_SHIFT)
 176 #define HF_AC_MASK           (1 << HF_AC_SHIFT)
 177 #define HF_SMM_MASK          (1 << HF_SMM_SHIFT)
 178 #define HF_SVME_MASK         (1 << HF_SVME_SHIFT)
 179 #define HF_SVMI_MASK         (1 << HF_SVMI_SHIFT)
 180 #define HF_OSFXSR_MASK       (1 << HF_OSFXSR_SHIFT)
 181 #define HF_SMAP_MASK         (1 << HF_SMAP_SHIFT)
 182 #define HF_IOBPT_MASK        (1 << HF_IOBPT_SHIFT)
 183 #define HF_MPX_EN_MASK       (1 << HF_MPX_EN_SHIFT)
 184 #define HF_MPX_IU_MASK       (1 << HF_MPX_IU_SHIFT)
 185
 186 /* hflags2 */
 187
 188 #define HF2_GIF_SHIFT            0 /* if set CPU takes interrupts */
 189 #define HF2_HIF_SHIFT            1 /* value of IF_MASK when entering SVM */
 190 #define HF2_NMI_SHIFT            2 /* CPU serving NMI */
 191 #define HF2_VINTR_SHIFT          3 /* value of V_INTR_MASKING bit */
 192 #define HF2_SMM_INSIDE_NMI_SHIFT 4 /* CPU serving SMI nested inside NMI */
 193 #define HF2_MPX_PR_SHIFT         5 /* BNDCFGx.BNDPRESERVE */
 194
 195 #define HF2_GIF_MASK            (1 << HF2_GIF_SHIFT)
 196 #define HF2_HIF_MASK            (1 << HF2_HIF_SHIFT)
 197 #define HF2_NMI_MASK            (1 << HF2_NMI_SHIFT)
 198 #define HF2_VINTR_MASK          (1 << HF2_VINTR_SHIFT)
 199 #define HF2_SMM_INSIDE_NMI_MASK (1 << HF2_SMM_INSIDE_NMI_SHIFT)
 200 #define HF2_MPX_PR_MASK         (1 << HF2_MPX_PR_SHIFT)
 201
 202 #define CR0_PE_SHIFT 0
 203 #define CR0_MP_SHIFT 1
 204
 205 #define CR0_PE_MASK  (1U << 0)
 206 #define CR0_MP_MASK  (1U << 1)
 207 #define CR0_EM_MASK  (1U << 2)
 208 #define CR0_TS_MASK  (1U << 3)
 209 #define CR0_ET_MASK  (1U << 4)
 210 #define CR0_NE_MASK  (1U << 5)
 211 #define CR0_WP_MASK  (1U << 16)
 212 #define CR0_AM_MASK  (1U << 18)
 213 #define CR0_PG_MASK  (1U << 31)
 214
 215 #define CR4_VME_MASK  (1U << 0)
 216 #define CR4_PVI_MASK  (1U << 1)
 217 #define CR4_TSD_MASK  (1U << 2)
 218 #define CR4_DE_MASK   (1U << 3)
 219 #define CR4_PSE_MASK  (1U << 4)
 220 #define CR4_PAE_MASK  (1U << 5)
 221 #define CR4_MCE_MASK  (1U << 6)
 222 #define CR4_PGE_MASK  (1U << 7)
 223 #define CR4_PCE_MASK  (1U << 8)
 224 #define CR4_OSFXSR_SHIFT 9
 225 #define CR4_OSFXSR_MASK (1U << CR4_OSFXSR_SHIFT)
 226 #define CR4_OSXMMEXCPT_MASK  (1U << 10)
 227 #define CR4_VMXE_MASK   (1U << 13)
 228 #define CR4_SMXE_MASK   (1U << 14)
 229 #define CR4_FSGSBASE_MASK (1U << 16)
 230 #define CR4_PCIDE_MASK  (1U << 17)
 231 #define CR4_OSXSAVE_MASK (1U << 18)
 232 #define CR4_SMEP_MASK   (1U << 20)
 233 #define CR4_SMAP_MASK   (1U << 21)
 234 #define CR4_PKE_MASK   (1U << 22)
 235
 236 #define DR6_BD          (1 << 13)
 237 #define DR6_BS          (1 << 14)
 238 #define DR6_BT          (1 << 15)
 239 #define DR6_FIXED_1     0xffff0ff0
 240
 241 #define DR7_GD          (1 << 13)
 242 #define DR7_TYPE_SHIFT  16
 243 #define DR7_LEN_SHIFT   18
 244 #define DR7_FIXED_1     0x00000400
 245 #define DR7_GLOBAL_BP_MASK   0xaa
 246 #define DR7_LOCAL_BP_MASK    0x55
 247 #define DR7_MAX_BP           4
 248 #define DR7_TYPE_BP_INST     0x0
 249 #define DR7_TYPE_DATA_WR     0x1
 250 #define DR7_TYPE_IO_RW       0x2
 251 #define DR7_TYPE_DATA_RW     0x3
 252
 253 #define PG_PRESENT_BIT  0
 254 #define PG_RW_BIT       1
 255 #define PG_USER_BIT     2
 256 #define PG_PWT_BIT      3
 257 #define PG_PCD_BIT      4
 258 #define PG_ACCESSED_BIT 5
 259 #define PG_DIRTY_BIT    6
 260 #define PG_PSE_BIT      7
 261 #define PG_GLOBAL_BIT   8
 262 #define PG_PSE_PAT_BIT  12
 263 #define PG_PKRU_BIT     59
 264 #define PG_NX_BIT       63
 265
 266 #define PG_PRESENT_MASK  (1 << PG_PRESENT_BIT)
 267 #define PG_RW_MASK       (1 << PG_RW_BIT)
 268 #define PG_USER_MASK     (1 << PG_USER_BIT)
 269 #define PG_PWT_MASK      (1 << PG_PWT_BIT)
 270 #define PG_PCD_MASK      (1 << PG_PCD_BIT)
 271 #define PG_ACCESSED_MASK (1 << PG_ACCESSED_BIT)
 272 #define PG_DIRTY_MASK    (1 << PG_DIRTY_BIT)
 273 #define PG_PSE_MASK      (1 << PG_PSE_BIT)
 274 #define PG_GLOBAL_MASK   (1 << PG_GLOBAL_BIT)
 275 #define PG_PSE_PAT_MASK  (1 << PG_PSE_PAT_BIT)
 276 #define PG_ADDRESS_MASK  0x000ffffffffff000LL
 277 #define PG_HI_RSVD_MASK  (PG_ADDRESS_MASK & ~PHYS_ADDR_MASK)
 278 #define PG_HI_USER_MASK  0x7ff0000000000000LL
 279 #define PG_PKRU_MASK     (15ULL << PG_PKRU_BIT)
 280 #define PG_NX_MASK       (1ULL << PG_NX_BIT)
 281
 282 #define PG_ERROR_W_BIT     1
 283
 284 #define PG_ERROR_P_MASK    0x01
 285 #define PG_ERROR_W_MASK    (1 << PG_ERROR_W_BIT)
 286 #define PG_ERROR_U_MASK    0x04
 287 #define PG_ERROR_RSVD_MASK 0x08
 288 #define PG_ERROR_I_D_MASK  0x10
 289 #define PG_ERROR_PK_MASK   0x20
 290
 291 #define MCG_CTL_P       (1ULL<<8)   /* MCG_CAP register available */
 292 #define MCG_SER_P       (1ULL<<24) /* MCA recovery/new status bits */
 293 #define MCG_LMCE_P      (1ULL<<27) /* Local Machine Check Supported */
 294
 295 #define MCE_CAP_DEF     (MCG_CTL_P|MCG_SER_P)
 296 #define MCE_BANKS_DEF   10
 297
 298 #define MCG_CAP_BANKS_MASK 0xff
 299
 300 #define MCG_STATUS_RIPV (1ULL<<0)   /* restart ip valid */
 301 #define MCG_STATUS_EIPV (1ULL<<1)   /* ip points to correct instruction */
 302 #define MCG_STATUS_MCIP (1ULL<<2)   /* machine check in progress */
 303 #define MCG_STATUS_LMCE (1ULL<<3)   /* Local MCE signaled */
 304
 305 #define MCG_EXT_CTL_LMCE_EN (1ULL<<0) /* Local MCE enabled */
 306
 307 #define MCI_STATUS_VAL   (1ULL<<63)  /* valid error */
 308 #define MCI_STATUS_OVER  (1ULL<<62)  /* previous errors lost */
 309 #define MCI_STATUS_UC    (1ULL<<61)  /* uncorrected error */
 310 #define MCI_STATUS_EN    (1ULL<<60)  /* error enabled */
 311 #define MCI_STATUS_MISCV (1ULL<<59)  /* misc error reg. valid */
 312 #define MCI_STATUS_ADDRV (1ULL<<58)  /* addr reg. valid */
 313 #define MCI_STATUS_PCC   (1ULL<<57)  /* processor context corrupt */
 314 #define MCI_STATUS_S     (1ULL<<56)  /* Signaled machine check */
 315 #define MCI_STATUS_AR    (1ULL<<55)  /* Action required */
 316
 317 /* MISC register defines */
 318 #define MCM_ADDR_SEGOFF  0      /* segment offset */
 319 #define MCM_ADDR_LINEAR  1      /* linear address */
 320 #define MCM_ADDR_PHYS    2      /* physical address */
 321 #define MCM_ADDR_MEM     3      /* memory address */
 322 #define MCM_ADDR_GENERIC 7      /* generic */
 323
 324 #define MSR_IA32_TSC                    0x10
 325 #define MSR_IA32_APICBASE               0x1b
 326 #define MSR_IA32_APICBASE_BSP           (1<<8)
 327 #define MSR_IA32_APICBASE_ENABLE        (1<<11)
 328 #define MSR_IA32_APICBASE_BASE          (0xfffffU<<12)
 329 #define MSR_IA32_FEATURE_CONTROL        0x0000003a
 330 #define MSR_TSC_ADJUST                  0x0000003b
 331 #define MSR_IA32_TSCDEADLINE            0x6e0
 332
 333 #define FEATURE_CONTROL_LOCKED                    (1<<0)
 334 #define FEATURE_CONTROL_VMXON_ENABLED_OUTSIDE_SMX (1<<2)
 335 #define FEATURE_CONTROL_LMCE                      (1<<20)
 336
 337 #define MSR_P6_PERFCTR0                 0xc1
 338
 339 #define MSR_IA32_SMBASE                 0x9e
 340 #define MSR_MTRRcap                     0xfe
 341 #define MSR_MTRRcap_VCNT                8
 342 #define MSR_MTRRcap_FIXRANGE_SUPPORT    (1 << 8)
 343 #define MSR_MTRRcap_WC_SUPPORTED        (1 << 10)
 344
 345 #define MSR_IA32_SYSENTER_CS            0x174
 346 #define MSR_IA32_SYSENTER_ESP           0x175
 347 #define MSR_IA32_SYSENTER_EIP           0x176
 348
 349 #define MSR_MCG_CAP                     0x179
 350 #define MSR_MCG_STATUS                  0x17a
 351 #define MSR_MCG_CTL                     0x17b
 352 #define MSR_MCG_EXT_CTL                 0x4d0
 353
 354 #define MSR_P6_EVNTSEL0                 0x186
 355
 356 #define MSR_IA32_PERF_STATUS            0x198
 357
 358 #define MSR_IA32_MISC_ENABLE            0x1a0
 359 /* Indicates good rep/movs microcode on some processors: */
 360 #define MSR_IA32_MISC_ENABLE_DEFAULT    1
 361
 362 #define MSR_MTRRphysBase(reg)           (0x200 + 2 * (reg))
 363 #define MSR_MTRRphysMask(reg)           (0x200 + 2 * (reg) + 1)
 364
 365 #define MSR_MTRRphysIndex(addr)         ((((addr) & ~1u) - 0x200) / 2)
 366
 367 #define MSR_MTRRfix64K_00000            0x250
 368 #define MSR_MTRRfix16K_80000            0x258
 369 #define MSR_MTRRfix16K_A0000            0x259
 370 #define MSR_MTRRfix4K_C0000             0x268
 371 #define MSR_MTRRfix4K_C8000             0x269
 372 #define MSR_MTRRfix4K_D0000             0x26a
 373 #define MSR_MTRRfix4K_D8000             0x26b
 374 #define MSR_MTRRfix4K_E0000             0x26c
 375 #define MSR_MTRRfix4K_E8000             0x26d
 376 #define MSR_MTRRfix4K_F0000             0x26e
 377 #define MSR_MTRRfix4K_F8000             0x26f
 378
 379 #define MSR_PAT                         0x277
 380
 381 #define MSR_MTRRdefType                 0x2ff
 382
 383 #define MSR_CORE_PERF_FIXED_CTR0        0x309
 384 #define MSR_CORE_PERF_FIXED_CTR1        0x30a
 385 #define MSR_CORE_PERF_FIXED_CTR2        0x30b
 386 #define MSR_CORE_PERF_FIXED_CTR_CTRL    0x38d
 387 #define MSR_CORE_PERF_GLOBAL_STATUS     0x38e
 388 #define MSR_CORE_PERF_GLOBAL_CTRL       0x38f
 389 #define MSR_CORE_PERF_GLOBAL_OVF_CTRL   0x390
 390
 391 #define MSR_MC0_CTL                     0x400
 392 #define MSR_MC0_STATUS                  0x401
 393 #define MSR_MC0_ADDR                    0x402
 394 #define MSR_MC0_MISC                    0x403
 395
 396 #define MSR_EFER                        0xc0000080
 397
 398 #define MSR_EFER_SCE   (1 << 0)
 399 #define MSR_EFER_LME   (1 << 8)
 400 #define MSR_EFER_LMA   (1 << 10)
 401 #define MSR_EFER_NXE   (1 << 11)
 402 #define MSR_EFER_SVME  (1 << 12)
 403 #define MSR_EFER_FFXSR (1 << 14)
 404
 405 #define MSR_STAR                        0xc0000081
 406 #define MSR_LSTAR                       0xc0000082
 407 #define MSR_CSTAR                       0xc0000083
 408 #define MSR_FMASK                       0xc0000084
 409 #define MSR_FSBASE                      0xc0000100
 410 #define MSR_GSBASE                      0xc0000101
 411 #define MSR_KERNELGSBASE                0xc0000102
 412 #define MSR_TSC_AUX                     0xc0000103
 413
 414 #define MSR_VM_HSAVE_PA                 0xc0010117
 415
 416 #define MSR_IA32_BNDCFGS                0x00000d90
 417 #define MSR_IA32_XSS                    0x00000da0
 418
 419 #define XSTATE_FP_BIT                   0
 420 #define XSTATE_SSE_BIT                  1
 421 #define XSTATE_YMM_BIT                  2
 422 #define XSTATE_BNDREGS_BIT              3
 423 #define XSTATE_BNDCSR_BIT               4
 424 #define XSTATE_OPMASK_BIT               5
 425 #define XSTATE_ZMM_Hi256_BIT            6
 426 #define XSTATE_Hi16_ZMM_BIT             7
 427 #define XSTATE_PKRU_BIT                 9
 428
 429 #define XSTATE_FP_MASK                  (1ULL << XSTATE_FP_BIT)
 430 #define XSTATE_SSE_MASK                 (1ULL << XSTATE_SSE_BIT)
 431 #define XSTATE_YMM_MASK                 (1ULL << XSTATE_YMM_BIT)
 432 #define XSTATE_BNDREGS_MASK             (1ULL << XSTATE_BNDREGS_BIT)
 433 #define XSTATE_BNDCSR_MASK              (1ULL << XSTATE_BNDCSR_BIT)
 434 #define XSTATE_OPMASK_MASK              (1ULL << XSTATE_OPMASK_BIT)
 435 #define XSTATE_ZMM_Hi256_MASK           (1ULL << XSTATE_ZMM_Hi256_BIT)
 436 #define XSTATE_Hi16_ZMM_MASK            (1ULL << XSTATE_Hi16_ZMM_BIT)
 437 #define XSTATE_PKRU_MASK                (1ULL << XSTATE_PKRU_BIT)
 438
 439 /* CPUID feature words */
 440 typedef enum FeatureWord {
 441     FEAT_1_EDX,         /* CPUID[1].EDX */
 442     FEAT_1_ECX,         /* CPUID[1].ECX */
 443     FEAT_7_0_EBX,       /* CPUID[EAX=7,ECX=0].EBX */
 444     FEAT_7_0_ECX,       /* CPUID[EAX=7,ECX=0].ECX */
 445     FEAT_8000_0001_EDX, /* CPUID[8000_0001].EDX */
 446     FEAT_8000_0001_ECX, /* CPUID[8000_0001].ECX */
 447     FEAT_8000_0007_EDX, /* CPUID[8000_0007].EDX */
 448     FEAT_C000_0001_EDX, /* CPUID[C000_0001].EDX */
 449     FEAT_KVM,           /* CPUID[4000_0001].EAX (KVM_CPUID_FEATURES) */
 450     FEAT_HYPERV_EAX,    /* CPUID[4000_0003].EAX */
 451     FEAT_HYPERV_EBX,    /* CPUID[4000_0003].EBX */
 452     FEAT_HYPERV_EDX,    /* CPUID[4000_0003].EDX */
 453     FEAT_SVM,           /* CPUID[8000_000A].EDX */
 454     FEAT_XSAVE,         /* CPUID[EAX=0xd,ECX=1].EAX */
 455     FEAT_6_EAX,         /* CPUID[6].EAX */
 456     FEATURE_WORDS,
 457 } FeatureWord;
 458
 459 typedef uint32_t FeatureWordArray[FEATURE_WORDS];
 460
 461 /* cpuid_features bits */
 462 #define CPUID_FP87 (1U << 0)
 463 #define CPUID_VME  (1U << 1)
 464 #define CPUID_DE   (1U << 2)
 465 #define CPUID_PSE  (1U << 3)
 466 #define CPUID_TSC  (1U << 4)
 467 #define CPUID_MSR  (1U << 5)
 468 #define CPUID_PAE  (1U << 6)
 469 #define CPUID_MCE  (1U << 7)
 470 #define CPUID_CX8  (1U << 8)
 471 #define CPUID_APIC (1U << 9)
 472 #define CPUID_SEP  (1U << 11) /* sysenter/sysexit */
 473 #define CPUID_MTRR (1U << 12)
 474 #define CPUID_PGE  (1U << 13)
 475 #define CPUID_MCA  (1U << 14)
 476 #define CPUID_CMOV (1U << 15)
 477 #define CPUID_PAT  (1U << 16)
 478 #define CPUID_PSE36   (1U << 17)
 479 #define CPUID_PN   (1U << 18)
 480 #define CPUID_CLFLUSH (1U << 19)
 481 #define CPUID_DTS (1U << 21)
 482 #define CPUID_ACPI (1U << 22)
 483 #define CPUID_MMX  (1U << 23)
 484 #define CPUID_FXSR (1U << 24)
 485 #define CPUID_SSE  (1U << 25)
 486 #define CPUID_SSE2 (1U << 26)
 487 #define CPUID_SS (1U << 27)
 488 #define CPUID_HT (1U << 28)
 489 #define CPUID_TM (1U << 29)
 490 #define CPUID_IA64 (1U << 30)
 491 #define CPUID_PBE (1U << 31)
 492
 493 #define CPUID_EXT_SSE3     (1U << 0)
 494 #define CPUID_EXT_PCLMULQDQ (1U << 1)
 495 #define CPUID_EXT_DTES64   (1U << 2)
 496 #define CPUID_EXT_MONITOR  (1U << 3)
 497 #define CPUID_EXT_DSCPL    (1U << 4)
 498 #define CPUID_EXT_VMX      (1U << 5)
 499 #define CPUID_EXT_SMX      (1U << 6)
 500 #define CPUID_EXT_EST      (1U << 7)
 501 #define CPUID_EXT_TM2      (1U << 8)
 502 #define CPUID_EXT_SSSE3    (1U << 9)
 503 #define CPUID_EXT_CID      (1U << 10)
 504 #define CPUID_EXT_FMA      (1U << 12)
 505 #define CPUID_EXT_CX16     (1U << 13)
 506 #define CPUID_EXT_XTPR     (1U << 14)
 507 #define CPUID_EXT_PDCM     (1U << 15)
 508 #define CPUID_EXT_PCID     (1U << 17)
 509 #define CPUID_EXT_DCA      (1U << 18)
 510 #define CPUID_EXT_SSE41    (1U << 19)
 511 #define CPUID_EXT_SSE42    (1U << 20)
 512 #define CPUID_EXT_X2APIC   (1U << 21)
 513 #define CPUID_EXT_MOVBE    (1U << 22)
 514 #define CPUID_EXT_POPCNT   (1U << 23)
 515 #define CPUID_EXT_TSC_DEADLINE_TIMER (1U << 24)
 516 #define CPUID_EXT_AES      (1U << 25)
 517 #define CPUID_EXT_XSAVE    (1U << 26)
 518 #define CPUID_EXT_OSXSAVE  (1U << 27)
 519 #define CPUID_EXT_AVX      (1U << 28)
 520 #define CPUID_EXT_F16C     (1U << 29)
 521 #define CPUID_EXT_RDRAND   (1U << 30)
 522 #define CPUID_EXT_HYPERVISOR  (1U << 31)
 523
 524 #define CPUID_EXT2_FPU     (1U << 0)
 525 #define CPUID_EXT2_VME     (1U << 1)
 526 #define CPUID_EXT2_DE      (1U << 2)
 527 #define CPUID_EXT2_PSE     (1U << 3)
 528 #define CPUID_EXT2_TSC     (1U << 4)
 529 #define CPUID_EXT2_MSR     (1U << 5)
 530 #define CPUID_EXT2_PAE     (1U << 6)
 531 #define CPUID_EXT2_MCE     (1U << 7)
 532 #define CPUID_EXT2_CX8     (1U << 8)
 533 #define CPUID_EXT2_APIC    (1U << 9)
 534 #define CPUID_EXT2_SYSCALL (1U << 11)
 535 #define CPUID_EXT2_MTRR    (1U << 12)
 536 #define CPUID_EXT2_PGE     (1U << 13)
 537 #define CPUID_EXT2_MCA     (1U << 14)
 538 #define CPUID_EXT2_CMOV    (1U << 15)
 539 #define CPUID_EXT2_PAT     (1U << 16)
 540 #define CPUID_EXT2_PSE36   (1U << 17)
 541 #define CPUID_EXT2_MP      (1U << 19)
 542 #define CPUID_EXT2_NX      (1U << 20)
 543 #define CPUID_EXT2_MMXEXT  (1U << 22)
 544 #define CPUID_EXT2_MMX     (1U << 23)
 545 #define CPUID_EXT2_FXSR    (1U << 24)
 546 #define CPUID_EXT2_FFXSR   (1U << 25)
 547 #define CPUID_EXT2_PDPE1GB (1U << 26)
 548 #define CPUID_EXT2_RDTSCP  (1U << 27)
 549 #define CPUID_EXT2_LM      (1U << 29)
 550 #define CPUID_EXT2_3DNOWEXT (1U << 30)
 551 #define CPUID_EXT2_3DNOW   (1U << 31)
 552
 553 /* CPUID[8000_0001].EDX bits that are aliase of CPUID[1].EDX bits on AMD CPUs */
 554 #define CPUID_EXT2_AMD_ALIASES (CPUID_EXT2_FPU | CPUID_EXT2_VME | \
 555                                 CPUID_EXT2_DE | CPUID_EXT2_PSE | \
 556                                 CPUID_EXT2_TSC | CPUID_EXT2_MSR | \
 557                                 CPUID_EXT2_PAE | CPUID_EXT2_MCE | \
 558                                 CPUID_EXT2_CX8 | CPUID_EXT2_APIC | \
 559                                 CPUID_EXT2_MTRR | CPUID_EXT2_PGE | \
 560                                 CPUID_EXT2_MCA | CPUID_EXT2_CMOV | \
 561                                 CPUID_EXT2_PAT | CPUID_EXT2_PSE36 | \
 562                                 CPUID_EXT2_MMX | CPUID_EXT2_FXSR)
 563
 564 #define CPUID_EXT3_LAHF_LM (1U << 0)
 565 #define CPUID_EXT3_CMP_LEG (1U << 1)
 566 #define CPUID_EXT3_SVM     (1U << 2)
 567 #define CPUID_EXT3_EXTAPIC (1U << 3)
 568 #define CPUID_EXT3_CR8LEG  (1U << 4)
 569 #define CPUID_EXT3_ABM     (1U << 5)
 570 #define CPUID_EXT3_SSE4A   (1U << 6)
 571 #define CPUID_EXT3_MISALIGNSSE (1U << 7)
 572 #define CPUID_EXT3_3DNOWPREFETCH (1U << 8)
 573 #define CPUID_EXT3_OSVW    (1U << 9)
 574 #define CPUID_EXT3_IBS     (1U << 10)
 575 #define CPUID_EXT3_XOP     (1U << 11)
 576 #define CPUID_EXT3_SKINIT  (1U << 12)
 577 #define CPUID_EXT3_WDT     (1U << 13)
 578 #define CPUID_EXT3_LWP     (1U << 15)
 579 #define CPUID_EXT3_FMA4    (1U << 16)
 580 #define CPUID_EXT3_TCE     (1U << 17)
 581 #define CPUID_EXT3_NODEID  (1U << 19)
 582 #define CPUID_EXT3_TBM     (1U << 21)
 583 #define CPUID_EXT3_TOPOEXT (1U << 22)
 584 #define CPUID_EXT3_PERFCORE (1U << 23)
 585 #define CPUID_EXT3_PERFNB  (1U << 24)
 586
 587 #define CPUID_SVM_NPT          (1U << 0)
 588 #define CPUID_SVM_LBRV         (1U << 1)
 589 #define CPUID_SVM_SVMLOCK      (1U << 2)
 590 #define CPUID_SVM_NRIPSAVE     (1U << 3)
 591 #define CPUID_SVM_TSCSCALE     (1U << 4)
 592 #define CPUID_SVM_VMCBCLEAN    (1U << 5)
 593 #define CPUID_SVM_FLUSHASID    (1U << 6)
 594 #define CPUID_SVM_DECODEASSIST (1U << 7)
 595 #define CPUID_SVM_PAUSEFILTER  (1U << 10)
 596 #define CPUID_SVM_PFTHRESHOLD  (1U << 12)
 597
 598 #define CPUID_7_0_EBX_FSGSBASE (1U << 0)
 599 #define CPUID_7_0_EBX_BMI1     (1U << 3)
 600 #define CPUID_7_0_EBX_HLE      (1U << 4)
 601 #define CPUID_7_0_EBX_AVX2     (1U << 5)
 602 #define CPUID_7_0_EBX_SMEP     (1U << 7)
 603 #define CPUID_7_0_EBX_BMI2     (1U << 8)
 604 #define CPUID_7_0_EBX_ERMS     (1U << 9)
 605 #define CPUID_7_0_EBX_INVPCID  (1U << 10)
 606 #define CPUID_7_0_EBX_RTM      (1U << 11)
 607 #define CPUID_7_0_EBX_MPX      (1U << 14)
 608 #define CPUID_7_0_EBX_AVX512F  (1U << 16) /* AVX-512 Foundation */
 609 #define CPUID_7_0_EBX_RDSEED   (1U << 18)
 610 #define CPUID_7_0_EBX_ADX      (1U << 19)
 611 #define CPUID_7_0_EBX_SMAP     (1U << 20)
 612 #define CPUID_7_0_EBX_PCOMMIT  (1U << 22) /* Persistent Commit */
 613 #define CPUID_7_0_EBX_CLFLUSHOPT (1U << 23) /* Flush a Cache Line Optimized */
 614 #define CPUID_7_0_EBX_CLWB     (1U << 24) /* Cache Line Write Back */
 615 #define CPUID_7_0_EBX_AVX512PF (1U << 26) /* AVX-512 Prefetch */
 616 #define CPUID_7_0_EBX_AVX512ER (1U << 27) /* AVX-512 Exponential and Reciprocal */
 617 #define CPUID_7_0_EBX_AVX512CD (1U << 28) /* AVX-512 Conflict Detection */
 618
 619 #define CPUID_7_0_ECX_PKU      (1U << 3)
 620 #define CPUID_7_0_ECX_OSPKE    (1U << 4)
 621
 622 #define CPUID_XSAVE_XSAVEOPT   (1U << 0)
 623 #define CPUID_XSAVE_XSAVEC     (1U << 1)
 624 #define CPUID_XSAVE_XGETBV1    (1U << 2)
 625 #define CPUID_XSAVE_XSAVES     (1U << 3)
 626
 627 #define CPUID_6_EAX_ARAT       (1U << 2)
 628
 629 /* CPUID[0x80000007].EDX flags: */
 630 #define CPUID_APM_INVTSC       (1U << 8)
 631
 632 #define CPUID_VENDOR_SZ      12
 633
 634 #define CPUID_VENDOR_INTEL_1 0x756e6547 /* "Genu" */
 635 #define CPUID_VENDOR_INTEL_2 0x49656e69 /* "ineI" */
 636 #define CPUID_VENDOR_INTEL_3 0x6c65746e /* "ntel" */
 637 #define CPUID_VENDOR_INTEL "GenuineIntel"
 638
 639 #define CPUID_VENDOR_AMD_1   0x68747541 /* "Auth" */
 640 #define CPUID_VENDOR_AMD_2   0x69746e65 /* "enti" */
 641 #define CPUID_VENDOR_AMD_3   0x444d4163 /* "cAMD" */
 642 #define CPUID_VENDOR_AMD   "AuthenticAMD"
 643
 644 #define CPUID_VENDOR_VIA   "CentaurHauls"
 645
 646 #define CPUID_MWAIT_IBE     (1U << 1) /* Interrupts can exit capability */
 647 #define CPUID_MWAIT_EMX     (1U << 0) /* enumeration supported */
 648
 649 /* CPUID[0xB].ECX level types */
 650 #define CPUID_TOPOLOGY_LEVEL_INVALID  (0U << 8)
 651 #define CPUID_TOPOLOGY_LEVEL_SMT      (1U << 8)
 652 #define CPUID_TOPOLOGY_LEVEL_CORE     (2U << 8)
 653
 654 #ifndef HYPERV_SPINLOCK_NEVER_RETRY
 655 #define HYPERV_SPINLOCK_NEVER_RETRY             0xFFFFFFFF
 656 #endif
 657
 658 #define EXCP00_DIVZ     0
 659 #define EXCP01_DB       1
 660 #define EXCP02_NMI      2
 661 #define EXCP03_INT3     3
 662 #define EXCP04_INTO     4
 663 #define EXCP05_BOUND    5
 664 #define EXCP06_ILLOP    6
 665 #define EXCP07_PREX     7
 666 #define EXCP08_DBLE     8
 667 #define EXCP09_XERR     9
 668 #define EXCP0A_TSS      10
 669 #define EXCP0B_NOSEG    11
 670 #define EXCP0C_STACK    12
 671 #define EXCP0D_GPF      13
 672 #define EXCP0E_PAGE     14
 673 #define EXCP10_COPR     16
 674 #define EXCP11_ALGN     17
 675 #define EXCP12_MCHK     18
 676
 677 #define EXCP_SYSCALL    0x100 /* only happens in user only emulation
 678                                  for syscall instruction */
 679
 680 /* i386-specific interrupt pending bits.  */
 681 #define CPU_INTERRUPT_POLL      CPU_INTERRUPT_TGT_EXT_1
 682 #define CPU_INTERRUPT_SMI       CPU_INTERRUPT_TGT_EXT_2
 683 #define CPU_INTERRUPT_NMI       CPU_INTERRUPT_TGT_EXT_3
 684 #define CPU_INTERRUPT_MCE       CPU_INTERRUPT_TGT_EXT_4
 685 #define CPU_INTERRUPT_VIRQ      CPU_INTERRUPT_TGT_INT_0
 686 #define CPU_INTERRUPT_SIPI      CPU_INTERRUPT_TGT_INT_1
 687 #define CPU_INTERRUPT_TPR       CPU_INTERRUPT_TGT_INT_2
 688
 689 /* Use a clearer name for this.  */
 690 #define CPU_INTERRUPT_INIT      CPU_INTERRUPT_RESET
 691
 692 typedef enum {
 693     CC_OP_DYNAMIC, /* must use dynamic code to get cc_op */
 694     CC_OP_EFLAGS,  /* all cc are explicitly computed, CC_SRC = flags */
 695
 696     CC_OP_MULB, /* modify all flags, C, O = (CC_SRC != 0) */
 697     CC_OP_MULW,
 698     CC_OP_MULL,
 699     CC_OP_MULQ,
 700
 701     CC_OP_ADDB, /* modify all flags, CC_DST = res, CC_SRC = src1 */
 702     CC_OP_ADDW,
 703     CC_OP_ADDL,
 704     CC_OP_ADDQ,
 705
 706     CC_OP_ADCB, /* modify all flags, CC_DST = res, CC_SRC = src1 */
 707     CC_OP_ADCW,
 708     CC_OP_ADCL,
 709     CC_OP_ADCQ,
 710
 711     CC_OP_SUBB, /* modify all flags, CC_DST = res, CC_SRC = src1 */
 712     CC_OP_SUBW,
 713     CC_OP_SUBL,
 714     CC_OP_SUBQ,
 715
 716     CC_OP_SBBB, /* modify all flags, CC_DST = res, CC_SRC = src1 */
 717     CC_OP_SBBW,
 718     CC_OP_SBBL,
 719     CC_OP_SBBQ,
 720
 721     CC_OP_LOGICB, /* modify all flags, CC_DST = res */
 722     CC_OP_LOGICW,
 723     CC_OP_LOGICL,
 724     CC_OP_LOGICQ,
 725
 726     CC_OP_INCB, /* modify all flags except, CC_DST = res, CC_SRC = C */
 727     CC_OP_INCW,
 728     CC_OP_INCL,
 729     CC_OP_INCQ,
 730
 731     CC_OP_DECB, /* modify all flags except, CC_DST = res, CC_SRC = C  */
 732     CC_OP_DECW,
 733     CC_OP_DECL,
 734     CC_OP_DECQ,
 735
 736     CC_OP_SHLB, /* modify all flags, CC_DST = res, CC_SRC.msb = C */
 737     CC_OP_SHLW,
 738     CC_OP_SHLL,
 739     CC_OP_SHLQ,
 740
 741     CC_OP_SARB, /* modify all flags, CC_DST = res, CC_SRC.lsb = C */
 742     CC_OP_SARW,
 743     CC_OP_SARL,
 744     CC_OP_SARQ,
 745
 746     CC_OP_BMILGB, /* Z,S via CC_DST, C = SRC==0; O=0; P,A undefined */
 747     CC_OP_BMILGW,
 748     CC_OP_BMILGL,
 749     CC_OP_BMILGQ,
 750
 751     CC_OP_ADCX, /* CC_DST = C, CC_SRC = rest.  */
 752     CC_OP_ADOX, /* CC_DST = O, CC_SRC = rest.  */
 753     CC_OP_ADCOX, /* CC_DST = C, CC_SRC2 = O, CC_SRC = rest.  */
 754
 755     CC_OP_CLR, /* Z set, all other flags clear.  */
 756
 757     CC_OP_NB,
 758 } CCOp;
 759
 760 typedef struct SegmentCache {
 761     uint32_t selector;
 762     target_ulong base;
 763     uint32_t limit;
 764     uint32_t flags;
 765 } SegmentCache;
 766
 767 #define MMREG_UNION(n, bits)        \
 768     union n {                       \
 769         uint8_t  _b_##n[(bits)/8];  \
 770         uint16_t _w_##n[(bits)/16]; \
 771         uint32_t _l_##n[(bits)/32]; \
 772         uint64_t _q_##n[(bits)/64]; \
 773         float32  _s_##n[(bits)/32]; \
 774         float64  _d_##n[(bits)/64]; \
 775     }
 776
 777 typedef MMREG_UNION(ZMMReg, 512) ZMMReg;
 778 typedef MMREG_UNION(MMXReg, 64)  MMXReg;
 779
 780 typedef struct BNDReg {
 781     uint64_t lb;
 782     uint64_t ub;
 783 } BNDReg;
 784
 785 typedef struct BNDCSReg {
 786     uint64_t cfgu;
 787     uint64_t sts;
 788 } BNDCSReg;
 789
 790 #define BNDCFG_ENABLE       1ULL
 791 #define BNDCFG_BNDPRESERVE  2ULL
 792 #define BNDCFG_BDIR_MASK    TARGET_PAGE_MASK
 793
 794 #ifdef HOST_WORDS_BIGENDIAN
 795 #define ZMM_B(n) _b_ZMMReg[63 - (n)]
 796 #define ZMM_W(n) _w_ZMMReg[31 - (n)]
 797 #define ZMM_L(n) _l_ZMMReg[15 - (n)]
 798 #define ZMM_S(n) _s_ZMMReg[15 - (n)]
 799 #define ZMM_Q(n) _q_ZMMReg[7 - (n)]
 800 #define ZMM_D(n) _d_ZMMReg[7 - (n)]
 801
 802 #define MMX_B(n) _b_MMXReg[7 - (n)]
 803 #define MMX_W(n) _w_MMXReg[3 - (n)]
 804 #define MMX_L(n) _l_MMXReg[1 - (n)]
 805 #define MMX_S(n) _s_MMXReg[1 - (n)]
 806 #else
 807 #define ZMM_B(n) _b_ZMMReg[n]
 808 #define ZMM_W(n) _w_ZMMReg[n]
 809 #define ZMM_L(n) _l_ZMMReg[n]
 810 #define ZMM_S(n) _s_ZMMReg[n]
 811 #define ZMM_Q(n) _q_ZMMReg[n]
 812 #define ZMM_D(n) _d_ZMMReg[n]
 813
 814 #define MMX_B(n) _b_MMXReg[n]
 815 #define MMX_W(n) _w_MMXReg[n]
 816 #define MMX_L(n) _l_MMXReg[n]
 817 #define MMX_S(n) _s_MMXReg[n]
 818 #endif
 819 #define MMX_Q(n) _q_MMXReg[n]
 820
 821 typedef union {
 822     floatx80 d __attribute__((aligned(16)));
 823     MMXReg mmx;
 824 } FPReg;
 825
 826 typedef struct {
 827     uint64_t base;
 828     uint64_t mask;
 829 } MTRRVar;
 830
 831 #define CPU_NB_REGS64 16
 832 #define CPU_NB_REGS32 8
 833
 834 #ifdef TARGET_X86_64
 835 #define CPU_NB_REGS CPU_NB_REGS64
 836 #else
 837 #define CPU_NB_REGS CPU_NB_REGS32
 838 #endif
 839
 840 #define MAX_FIXED_COUNTERS 3
 841 #define MAX_GP_COUNTERS    (MSR_IA32_PERF_STATUS - MSR_P6_EVNTSEL0)
 842
 843 #define NB_MMU_MODES 3
 844 #define TARGET_INSN_START_EXTRA_WORDS 1
 845
 846 #define NB_OPMASK_REGS 8
 847
 848 typedef union X86LegacyXSaveArea {
 849     struct {
 850         uint16_t fcw;
 851         uint16_t fsw;
 852         uint8_t ftw;
 853         uint8_t reserved;
 854         uint16_t fpop;
 855         uint64_t fpip;
 856         uint64_t fpdp;
 857         uint32_t mxcsr;
 858         uint32_t mxcsr_mask;
 859         FPReg fpregs[8];
 860         uint8_t xmm_regs[16][16];
 861     };
 862     uint8_t data[512];
 863 } X86LegacyXSaveArea;
 864
 865 typedef struct X86XSaveHeader {
 866     uint64_t xstate_bv;
 867     uint64_t xcomp_bv;
 868     uint8_t reserved[48];
 869 } X86XSaveHeader;
 870
 871 /* Ext. save area 2: AVX State */
 872 typedef struct XSaveAVX {
 873     uint8_t ymmh[16][16];
 874 } XSaveAVX;
 875
 876 /* Ext. save area 3: BNDREG */
 877 typedef struct XSaveBNDREG {
 878     BNDReg bnd_regs[4];
 879 } XSaveBNDREG;
 880
 881 /* Ext. save area 4: BNDCSR */
 882 typedef union XSaveBNDCSR {
 883     BNDCSReg bndcsr;
 884     uint8_t data[64];
 885 } XSaveBNDCSR;
 886
 887 /* Ext. save area 5: Opmask */
 888 typedef struct XSaveOpmask {
 889     uint64_t opmask_regs[NB_OPMASK_REGS];
 890 } XSaveOpmask;
 891
 892 /* Ext. save area 6: ZMM_Hi256 */
 893 typedef struct XSaveZMM_Hi256 {
 894     uint8_t zmm_hi256[16][32];
 895 } XSaveZMM_Hi256;
 896
 897 /* Ext. save area 7: Hi16_ZMM */
 898 typedef struct XSaveHi16_ZMM {
 899     uint8_t hi16_zmm[16][64];
 900 } XSaveHi16_ZMM;
 901
 902 /* Ext. save area 9: PKRU state */
 903 typedef struct XSavePKRU {
 904     uint32_t pkru;
 905     uint32_t padding;
 906 } XSavePKRU;
 907
 908 typedef struct X86XSaveArea {
 909     X86LegacyXSaveArea legacy;
 910     X86XSaveHeader header;
 911
 912     /* Extended save areas: */
 913
 914     /* AVX State: */
 915     XSaveAVX avx_state;
 916     uint8_t padding[960 - 576 - sizeof(XSaveAVX)];
 917     /* MPX State: */
 918     XSaveBNDREG bndreg_state;
 919     XSaveBNDCSR bndcsr_state;
 920     /* AVX-512 State: */
 921     XSaveOpmask opmask_state;
 922     XSaveZMM_Hi256 zmm_hi256_state;
 923     XSaveHi16_ZMM hi16_zmm_state;
 924     /* PKRU State: */
 925     XSavePKRU pkru_state;
 926 } X86XSaveArea;
 927
 928 QEMU_BUILD_BUG_ON(offsetof(X86XSaveArea, avx_state) != 0x240);
 929 QEMU_BUILD_BUG_ON(sizeof(XSaveAVX) != 0x100);
 930 QEMU_BUILD_BUG_ON(offsetof(X86XSaveArea, bndreg_state) != 0x3c0);
 931 QEMU_BUILD_BUG_ON(sizeof(XSaveBNDREG) != 0x40);
 932 QEMU_BUILD_BUG_ON(offsetof(X86XSaveArea, bndcsr_state) != 0x400);
 933 QEMU_BUILD_BUG_ON(sizeof(XSaveBNDCSR) != 0x40);
 934 QEMU_BUILD_BUG_ON(offsetof(X86XSaveArea, opmask_state) != 0x440);
 935 QEMU_BUILD_BUG_ON(sizeof(XSaveOpmask) != 0x40);
 936 QEMU_BUILD_BUG_ON(offsetof(X86XSaveArea, zmm_hi256_state) != 0x480);
 937 QEMU_BUILD_BUG_ON(sizeof(XSaveZMM_Hi256) != 0x200);
 938 QEMU_BUILD_BUG_ON(offsetof(X86XSaveArea, hi16_zmm_state) != 0x680);
 939 QEMU_BUILD_BUG_ON(sizeof(XSaveHi16_ZMM) != 0x400);
 940 QEMU_BUILD_BUG_ON(offsetof(X86XSaveArea, pkru_state) != 0xA80);
 941 QEMU_BUILD_BUG_ON(sizeof(XSavePKRU) != 0x8);
 942
 943 typedef enum TPRAccess {
 944     TPR_ACCESS_READ,
 945     TPR_ACCESS_WRITE,
 946 } TPRAccess;
 947
 948 typedef struct CPUX86State {
 949     /* standard registers */
 950     target_ulong regs[CPU_NB_REGS];
 951     target_ulong eip;
 952     target_ulong eflags; /* eflags register. During CPU emulation, CC
 953                         flags and DF are set to zero because they are
 954                         stored elsewhere */
 955
 956     /* emulator internal eflags handling */
 957     target_ulong cc_dst;
 958     target_ulong cc_src;
 959     target_ulong cc_src2;
 960     uint32_t cc_op;
 961     int32_t df; /* D flag : 1 if D = 0, -1 if D = 1 */
 962     uint32_t hflags; /* TB flags, see HF_xxx constants. These flags
 963                         are known at translation time. */
 964     uint32_t hflags2; /* various other flags, see HF2_xxx constants. */
 965
 966     /* segments */
 967     SegmentCache segs[6]; /* selector values */
 968     SegmentCache ldt;
 969     SegmentCache tr;
 970     SegmentCache gdt; /* only base and limit are used */
 971     SegmentCache idt; /* only base and limit are used */
 972
 973     target_ulong cr[5]; /* NOTE: cr1 is unused */
 974     int32_t a20_mask;
 975
 976     BNDReg bnd_regs[4];
 977     BNDCSReg bndcs_regs;
 978     uint64_t msr_bndcfgs;
 979     uint64_t efer;
 980
 981     /* Beginning of state preserved by INIT (dummy marker).  */
 982     struct {} start_init_save;
 983
 984     /* FPU state */
 985     unsigned int fpstt; /* top of stack index */
 986     uint16_t fpus;
 987     uint16_t fpuc;
 988     uint8_t fptags[8];   /* 0 = valid, 1 = empty */
 989     FPReg fpregs[8];
 990     /* KVM-only so far */
 991     uint16_t fpop;
 992     uint64_t fpip;
 993     uint64_t fpdp;
 994
 995     /* emulator internal variables */
 996     float_status fp_status;
 997     floatx80 ft0;
 998
 999     float_status mmx_status; /* for 3DNow! float ops */
1000     float_status sse_status;
1001     uint32_t mxcsr;
1002     ZMMReg xmm_regs[CPU_NB_REGS == 8 ? 8 : 32];
1003     ZMMReg xmm_t0;
1004     MMXReg mmx_t0;
1005
1006     uint64_t opmask_regs[NB_OPMASK_REGS];
1007
1008     /* sysenter registers */
1009     uint32_t sysenter_cs;
1010     target_ulong sysenter_esp;
1011     target_ulong sysenter_eip;
1012     uint64_t star;
1013
1014     uint64_t vm_hsave;
1015
1016 #ifdef TARGET_X86_64
1017     target_ulong lstar;
1018     target_ulong cstar;
1019     target_ulong fmask;
1020     target_ulong kernelgsbase;
1021 #endif
1022
1023     uint64_t tsc;
1024     uint64_t tsc_adjust;
1025     uint64_t tsc_deadline;
1026
1027     uint64_t mcg_status;
1028     uint64_t msr_ia32_misc_enable;
1029     uint64_t msr_ia32_feature_control;
1030
1031     uint64_t msr_fixed_ctr_ctrl;
1032     uint64_t msr_global_ctrl;
1033     uint64_t msr_global_status;
1034     uint64_t msr_global_ovf_ctrl;
1035     uint64_t msr_fixed_counters[MAX_FIXED_COUNTERS];
1036     uint64_t msr_gp_counters[MAX_GP_COUNTERS];
1037     uint64_t msr_gp_evtsel[MAX_GP_COUNTERS];
1038
1039     uint64_t pat;
1040     uint32_t smbase;
1041
1042     /* End of state preserved by INIT (dummy marker).  */
1043     struct {} end_init_save;
1044
1045     uint64_t system_time_msr;
1046     uint64_t wall_clock_msr;
1047     uint64_t steal_time_msr;
1048     uint64_t async_pf_en_msr;
1049     uint64_t pv_eoi_en_msr;
1050
1051     uint64_t msr_hv_hypercall;
1052     uint64_t msr_hv_guest_os_id;
1053     uint64_t msr_hv_vapic;
1054     uint64_t msr_hv_tsc;
1055     uint64_t msr_hv_crash_params[HV_X64_MSR_CRASH_PARAMS];
1056     uint64_t msr_hv_runtime;
1057     uint64_t msr_hv_synic_control;
1058     uint64_t msr_hv_synic_version;
1059     uint64_t msr_hv_synic_evt_page;
1060     uint64_t msr_hv_synic_msg_page;
1061     uint64_t msr_hv_synic_sint[HV_SYNIC_SINT_COUNT];
1062     uint64_t msr_hv_stimer_config[HV_SYNIC_STIMER_COUNT];
1063     uint64_t msr_hv_stimer_count[HV_SYNIC_STIMER_COUNT];
1064
1065     /* exception/interrupt handling */
1066     int error_code;
1067     int exception_is_int;
1068     target_ulong exception_next_eip;
1069     target_ulong dr[8]; /* debug registers; note dr4 and dr5 are unused */
1070     union {
1071         struct CPUBreakpoint *cpu_breakpoint[4];
1072         struct CPUWatchpoint *cpu_watchpoint[4];
1073     }; /* break/watchpoints for dr[0..3] */
1074     int old_exception;  /* exception in flight */
1075
1076     uint64_t vm_vmcb;
1077     uint64_t tsc_offset;
1078     uint64_t intercept;
1079     uint16_t intercept_cr_read;
1080     uint16_t intercept_cr_write;
1081     uint16_t intercept_dr_read;
1082     uint16_t intercept_dr_write;
1083     uint32_t intercept_exceptions;
1084     uint8_t v_tpr;
1085
1086     /* KVM states, automatically cleared on reset */
1087     uint8_t nmi_injected;
1088     uint8_t nmi_pending;
1089
1090     CPU_COMMON
1091
1092     /* Fields from here on are preserved across CPU reset. */
1093
1094     /* processor features (e.g. for CPUID insn) */
1095     uint32_t cpuid_level;
1096     uint32_t cpuid_xlevel;
1097     uint32_t cpuid_xlevel2;
1098     uint32_t cpuid_vendor1;
1099     uint32_t cpuid_vendor2;
1100     uint32_t cpuid_vendor3;
1101     uint32_t cpuid_version;
1102     FeatureWordArray features;
1103     uint32_t cpuid_model[12];
1104
1105     /* MTRRs */
1106     uint64_t mtrr_fixed[11];
1107     uint64_t mtrr_deftype;
1108     MTRRVar mtrr_var[MSR_MTRRcap_VCNT];
1109
1110     /* For KVM */
1111     uint32_t mp_state;
1112     int32_t exception_injected;
1113     int32_t interrupt_injected;
1114     uint8_t soft_interrupt;
1115     uint8_t has_error_code;
1116     uint32_t sipi_vector;
1117     bool tsc_valid;
1118     int64_t tsc_khz;
1119     int64_t user_tsc_khz; /* for sanity check only */
1120     void *kvm_xsave_buf;
1121
1122     uint64_t mcg_cap;
1123     uint64_t mcg_ctl;
1124     uint64_t mcg_ext_ctl;
1125     uint64_t mce_banks[MCE_BANKS_DEF*4];
1126
1127     uint64_t tsc_aux;
1128
1129     /* vmstate */
1130     uint16_t fpus_vmstate;
1131     uint16_t fptag_vmstate;
1132     uint16_t fpregs_format_vmstate;
1133     uint64_t xstate_bv;
1134
1135     uint64_t xcr0;
1136     uint64_t xss;
1137
1138     uint32_t pkru;
1139
1140     TPRAccess tpr_access_type;
1141 } CPUX86State;
1142
1143 struct kvm_msrs;
1144
1145 /**
1146  * X86CPU:
1147  * @env: #CPUX86State
1148  * @migratable: If set, only migratable flags will be accepted when "enforce"
1149  * mode is used, and only migratable flags will be included in the "host"
1150  * CPU model.
1151  *
1152  * An x86 CPU.
1153  */
1154 struct X86CPU {
1155     /*< private >*/
1156     CPUState parent_obj;
1157     /*< public >*/
1158
1159     CPUX86State env;
1160
1161     bool hyperv_vapic;
1162     bool hyperv_relaxed_timing;
1163     int hyperv_spinlock_attempts;
1164     char *hyperv_vendor_id;
1165     bool hyperv_time;
1166     bool hyperv_crash;
1167     bool hyperv_reset;
1168     bool hyperv_vpindex;
1169     bool hyperv_runtime;
1170     bool hyperv_synic;
1171     bool hyperv_stimer;
1172     bool check_cpuid;
1173     bool enforce_cpuid;
1174     bool expose_kvm;
1175     bool migratable;
1176     bool host_features;
1177     int64_t apic_id;
1178
1179     /* if true the CPUID code directly forward host cache leaves to the guest */
1180     bool cache_info_passthrough;
1181
1182     /* Features that were filtered out because of missing host capabilities */
1183     uint32_t filtered_features[FEATURE_WORDS];
1184
1185     /* Enable PMU CPUID bits. This can't be enabled by default yet because
1186      * it doesn't have ABI stability guarantees, as it passes all PMU CPUID
1187      * bits returned by GET_SUPPORTED_CPUID (that depend on host CPU and kernel
1188      * capabilities) directly to the guest.
1189      */
1190     bool enable_pmu;
1191
1192     /* LMCE support can be enabled/disabled via cpu option 'lmce=on/off'. It is
1193      * disabled by default to avoid breaking migration between QEMU with
1194      * different LMCE configurations.
1195      */
1196     bool enable_lmce;
1197
1198     /* Compatibility bits for old machine types: */
1199     bool enable_cpuid_0xb;
1200
1201     /* in order to simplify APIC support, we leave this pointer to the
1202        user */
1203     struct DeviceState *apic_state;
1204     struct MemoryRegion *cpu_as_root, *cpu_as_mem, *smram;
1205     Notifier machine_done;
1206
1207     struct kvm_msrs *kvm_msr_buf;
1208 };
1209
1210 static inline X86CPU *x86_env_get_cpu(CPUX86State *env)
1211 {
1212     return container_of(env, X86CPU, env);
1213 }
1214
1215 #define ENV_GET_CPU(e) CPU(x86_env_get_cpu(e))
1216
1217 #define ENV_OFFSET offsetof(X86CPU, env)
1218
1219 #ifndef CONFIG_USER_ONLY
1220 extern struct VMStateDescription vmstate_x86_cpu;
1221 #endif
1222
1223 /**
1224  * x86_cpu_do_interrupt:
1225  * @cpu: vCPU the interrupt is to be handled by.
1226  */
1227 void x86_cpu_do_interrupt(CPUState *cpu);
1228 bool x86_cpu_exec_interrupt(CPUState *cpu, int int_req);
1229
1230 int x86_cpu_write_elf64_note(WriteCoreDumpFunction f, CPUState *cpu,
1231                              int cpuid, void *opaque);
1232 int x86_cpu_write_elf32_note(WriteCoreDumpFunction f, CPUState *cpu,
1233                              int cpuid, void *opaque);
1234 int x86_cpu_write_elf64_qemunote(WriteCoreDumpFunction f, CPUState *cpu,
1235                                  void *opaque);
1236 int x86_cpu_write_elf32_qemunote(WriteCoreDumpFunction f, CPUState *cpu,
1237                                  void *opaque);
1238
1239 void x86_cpu_get_memory_mapping(CPUState *cpu, MemoryMappingList *list,
1240                                 Error **errp);
1241
1242 void x86_cpu_dump_state(CPUState *cs, FILE *f, fprintf_function cpu_fprintf,
1243                         int flags);
1244
1245 hwaddr x86_cpu_get_phys_page_debug(CPUState *cpu, vaddr addr);
1246
1247 int x86_cpu_gdb_read_register(CPUState *cpu, uint8_t *buf, int reg);
1248 int x86_cpu_gdb_write_register(CPUState *cpu, uint8_t *buf, int reg);
1249
1250 void x86_cpu_exec_enter(CPUState *cpu);
1251 void x86_cpu_exec_exit(CPUState *cpu);
1252
1253 X86CPU *cpu_x86_init(const char *cpu_model);
1254 void x86_cpu_list(FILE *f, fprintf_function cpu_fprintf);
1255 int cpu_x86_support_mca_broadcast(CPUX86State *env);
1256
1257 int cpu_get_pic_interrupt(CPUX86State *s);
1258 /* MSDOS compatibility mode FPU exception support */
1259 void cpu_set_ferr(CPUX86State *s);
1260
1261 /* this function must always be used to load data in the segment
1262    cache: it synchronizes the hflags with the segment cache values */
1263 static inline void cpu_x86_load_seg_cache(CPUX86State *env,
1264                                           int seg_reg, unsigned int selector,
1265                                           target_ulong base,
1266                                           unsigned int limit,
1267                                           unsigned int flags)
1268 {
1269     SegmentCache *sc;
1270     unsigned int new_hflags;
1271
1272     sc = &env->segs[seg_reg];
1273     sc->selector = selector;
1274     sc->base = base;
1275     sc->limit = limit;
1276     sc->flags = flags;
1277
1278     /* update the hidden flags */
1279     {
1280         if (seg_reg == R_CS) {
1281 #ifdef TARGET_X86_64
1282             if ((env->hflags & HF_LMA_MASK) && (flags & DESC_L_MASK)) {
1283                 /* long mode */
1284                 env->hflags |= HF_CS32_MASK | HF_SS32_MASK | HF_CS64_MASK;
1285                 env->hflags &= ~(HF_ADDSEG_MASK);
1286             } else
1287 #endif
1288             {
1289                 /* legacy / compatibility case */
1290                 new_hflags = (env->segs[R_CS].flags & DESC_B_MASK)
1291                     >> (DESC_B_SHIFT - HF_CS32_SHIFT);
1292                 env->hflags = (env->hflags & ~(HF_CS32_MASK | HF_CS64_MASK)) |
1293                     new_hflags;
1294             }
1295         }
1296         if (seg_reg == R_SS) {
1297             int cpl = (flags >> DESC_DPL_SHIFT) & 3;
1298 #if HF_CPL_MASK != 3
1299 #error HF_CPL_MASK is hardcoded
1300 #endif
1301             env->hflags = (env->hflags & ~HF_CPL_MASK) | cpl;
1302         }
1303         new_hflags = (env->segs[R_SS].flags & DESC_B_MASK)
1304             >> (DESC_B_SHIFT - HF_SS32_SHIFT);
1305         if (env->hflags & HF_CS64_MASK) {
1306             /* zero base assumed for DS, ES and SS in long mode */
1307         } else if (!(env->cr[0] & CR0_PE_MASK) ||
1308                    (env->eflags & VM_MASK) ||
1309                    !(env->hflags & HF_CS32_MASK)) {
1310             /* XXX: try to avoid this test. The problem comes from the
1311                fact that is real mode or vm86 mode we only modify the
1312                'base' and 'selector' fields of the segment cache to go
1313                faster. A solution may be to force addseg to one in
1314                translate-i386.c. */
1315             new_hflags |= HF_ADDSEG_MASK;
1316         } else {
1317             new_hflags |= ((env->segs[R_DS].base |
1318                             env->segs[R_ES].base |
1319                             env->segs[R_SS].base) != 0) <<
1320                 HF_ADDSEG_SHIFT;
1321         }
1322         env->hflags = (env->hflags &
1323                        ~(HF_SS32_MASK | HF_ADDSEG_MASK)) | new_hflags;
1324     }
1325 }
1326
1327 static inline void cpu_x86_load_seg_cache_sipi(X86CPU *cpu,
1328                                                uint8_t sipi_vector)
1329 {
1330     CPUState *cs = CPU(cpu);
1331     CPUX86State *env = &cpu->env;
1332
1333     env->eip = 0;
1334     cpu_x86_load_seg_cache(env, R_CS, sipi_vector << 8,
1335                            sipi_vector << 12,
1336                            env->segs[R_CS].limit,
1337                            env->segs[R_CS].flags);
1338     cs->halted = 0;
1339 }
1340
1341 int cpu_x86_get_descr_debug(CPUX86State *env, unsigned int selector,
1342                             target_ulong *base, unsigned int *limit,
1343                             unsigned int *flags);
1344
1345 /* op_helper.c */
1346 /* used for debug or cpu save/restore */
1347 void cpu_get_fp80(uint64_t *pmant, uint16_t *pexp, floatx80 f);
1348 floatx80 cpu_set_fp80(uint64_t mant, uint16_t upper);
1349
1350 /* cpu-exec.c */
1351 /* the following helpers are only usable in user mode simulation as
1352    they can trigger unexpected exceptions */
1353 void cpu_x86_load_seg(CPUX86State *s, int seg_reg, int selector);
1354 void cpu_x86_fsave(CPUX86State *s, target_ulong ptr, int data32);
1355 void cpu_x86_frstor(CPUX86State *s, target_ulong ptr, int data32);
1356
1357 /* you can call this signal handler from your SIGBUS and SIGSEGV
1358    signal handlers to inform the virtual CPU of exceptions. non zero
1359    is returned if the signal was handled by the virtual CPU.  */
1360 int cpu_x86_signal_handler(int host_signum, void *pinfo,
1361                            void *puc);
1362
1363 /* cpu.c */
1364 typedef struct ExtSaveArea {
1365     uint32_t feature, bits;
1366     uint32_t offset, size;
1367 } ExtSaveArea;
1368
1369 extern const ExtSaveArea x86_ext_save_areas[];
1370
1371 void cpu_x86_cpuid(CPUX86State *env, uint32_t index, uint32_t count,
1372                    uint32_t *eax, uint32_t *ebx,
1373                    uint32_t *ecx, uint32_t *edx);
1374 void cpu_clear_apic_feature(CPUX86State *env);
1375 void host_cpuid(uint32_t function, uint32_t count,
1376                 uint32_t *eax, uint32_t *ebx, uint32_t *ecx, uint32_t *edx);
1377
1378 /* helper.c */
1379 int x86_cpu_handle_mmu_fault(CPUState *cpu, vaddr addr,
1380                              int is_write, int mmu_idx);
1381 void x86_cpu_set_a20(X86CPU *cpu, int a20_state);
1382
1383 #ifndef CONFIG_USER_ONLY
1384 uint8_t x86_ldub_phys(CPUState *cs, hwaddr addr);
1385 uint32_t x86_lduw_phys(CPUState *cs, hwaddr addr);
1386 uint32_t x86_ldl_phys(CPUState *cs, hwaddr addr);
1387 uint64_t x86_ldq_phys(CPUState *cs, hwaddr addr);
1388 void x86_stb_phys(CPUState *cs, hwaddr addr, uint8_t val);
1389 void x86_stl_phys_notdirty(CPUState *cs, hwaddr addr, uint32_t val);
1390 void x86_stw_phys(CPUState *cs, hwaddr addr, uint32_t val);
1391 void x86_stl_phys(CPUState *cs, hwaddr addr, uint32_t val);
1392 void x86_stq_phys(CPUState *cs, hwaddr addr, uint64_t val);
1393 #endif
1394
1395 void breakpoint_handler(CPUState *cs);
1396
1397 /* will be suppressed */
1398 void cpu_x86_update_cr0(CPUX86State *env, uint32_t new_cr0);
1399 void cpu_x86_update_cr3(CPUX86State *env, target_ulong new_cr3);
1400 void cpu_x86_update_cr4(CPUX86State *env, uint32_t new_cr4);
1401 void cpu_x86_update_dr7(CPUX86State *env, uint32_t new_dr7);
1402
1403 /* hw/pc.c */
1404 uint64_t cpu_get_tsc(CPUX86State *env);
1405
1406 #define TARGET_PAGE_BITS 12
1407
1408 #ifdef TARGET_X86_64
1409 #define TARGET_PHYS_ADDR_SPACE_BITS 52
1410 /* ??? This is really 48 bits, sign-extended, but the only thing
1411    accessible to userland with bit 48 set is the VSYSCALL, and that
1412    is handled via other mechanisms.  */
1413 #define TARGET_VIRT_ADDR_SPACE_BITS 47
1414 #else
1415 #define TARGET_PHYS_ADDR_SPACE_BITS 36
1416 #define TARGET_VIRT_ADDR_SPACE_BITS 32
1417 #endif
1418
1419 /* XXX: This value should match the one returned by CPUID
1420  * and in exec.c */
1421 # if defined(TARGET_X86_64)
1422 # define PHYS_ADDR_MASK 0xffffffffffLL
1423 # else
1424 # define PHYS_ADDR_MASK 0xfffffffffLL
1425 # endif
1426
1427 #define cpu_init(cpu_model) CPU(cpu_x86_init(cpu_model))
1428
1429 #define cpu_signal_handler cpu_x86_signal_handler
1430 #define cpu_list x86_cpu_list
1431
1432 /* MMU modes definitions */
1433 #define MMU_MODE0_SUFFIX _ksmap
1434 #define MMU_MODE1_SUFFIX _user
1435 #define MMU_MODE2_SUFFIX _knosmap /* SMAP disabled or CPL<3 && AC=1 */
1436 #define MMU_KSMAP_IDX   0
1437 #define MMU_USER_IDX    1
1438 #define MMU_KNOSMAP_IDX 2
1439 static inline int cpu_mmu_index(CPUX86State *env, bool ifetch)
1440 {
1441     return (env->hflags & HF_CPL_MASK) == 3 ? MMU_USER_IDX :
1442         (!(env->hflags & HF_SMAP_MASK) || (env->eflags & AC_MASK))
1443         ? MMU_KNOSMAP_IDX : MMU_KSMAP_IDX;
1444 }
1445
1446 static inline int cpu_mmu_index_kernel(CPUX86State *env)
1447 {
1448     return !(env->hflags & HF_SMAP_MASK) ? MMU_KNOSMAP_IDX :
1449         ((env->hflags & HF_CPL_MASK) < 3 && (env->eflags & AC_MASK))
1450         ? MMU_KNOSMAP_IDX : MMU_KSMAP_IDX;
1451 }
1452
1453 #define CC_DST  (env->cc_dst)
1454 #define CC_SRC  (env->cc_src)
1455 #define CC_SRC2 (env->cc_src2)
1456 #define CC_OP   (env->cc_op)
1457
1458 /* n must be a constant to be efficient */
1459 static inline target_long lshift(target_long x, int n)
1460 {
1461     if (n >= 0) {
1462         return x << n;
1463     } else {
1464         return x >> (-n);
1465     }
1466 }
1467
1468 /* float macros */
1469 #define FT0    (env->ft0)
1470 #define ST0    (env->fpregs[env->fpstt].d)
1471 #define ST(n)  (env->fpregs[(env->fpstt + (n)) & 7].d)
1472 #define ST1    ST(1)
1473
1474 /* translate.c */
1475 void tcg_x86_init(void);
1476
1477 #include "exec/cpu-all.h"
1478 #include "svm.h"
1479
1480 #if !defined(CONFIG_USER_ONLY)
1481 #include "hw/i386/apic.h"
1482 #endif
1483
1484 static inline void cpu_get_tb_cpu_state(CPUX86State *env, target_ulong *pc,
1485                                         target_ulong *cs_base, uint32_t *flags)
1486 {
1487     *cs_base = env->segs[R_CS].base;
1488     *pc = *cs_base + env->eip;
1489     *flags = env->hflags |
1490         (env->eflags & (IOPL_MASK | TF_MASK | RF_MASK | VM_MASK | AC_MASK));
1491 }
1492
1493 void do_cpu_init(X86CPU *cpu);
1494 void do_cpu_sipi(X86CPU *cpu);
1495
1496 #define MCE_INJECT_BROADCAST    1
1497 #define MCE_INJECT_UNCOND_AO    2
1498
1499 void cpu_x86_inject_mce(Monitor *mon, X86CPU *cpu, int bank,
1500                         uint64_t status, uint64_t mcg_status, uint64_t addr,
1501                         uint64_t misc, int flags);
1502
1503 /* excp_helper.c */
1504 void QEMU_NORETURN raise_exception(CPUX86State *env, int exception_index);
1505 void QEMU_NORETURN raise_exception_ra(CPUX86State *env, int exception_index,
1506                                       uintptr_t retaddr);
1507 void QEMU_NORETURN raise_exception_err(CPUX86State *env, int exception_index,
1508                                        int error_code);
1509 void QEMU_NORETURN raise_exception_err_ra(CPUX86State *env, int exception_index,
1510                                           int error_code, uintptr_t retaddr);
1511 void QEMU_NORETURN raise_interrupt(CPUX86State *nenv, int intno, int is_int,
1512                                    int error_code, int next_eip_addend);
1513
1514 /* cc_helper.c */
1515 extern const uint8_t parity_table[256];
1516 uint32_t cpu_cc_compute_all(CPUX86State *env1, int op);
1517 void update_fp_status(CPUX86State *env);
1518
1519 static inline uint32_t cpu_compute_eflags(CPUX86State *env)
1520 {
1521     return env->eflags | cpu_cc_compute_all(env, CC_OP) | (env->df & DF_MASK);
1522 }
1523
1524 /* NOTE: the translator must set DisasContext.cc_op to CC_OP_EFLAGS
1525  * after generating a call to a helper that uses this.
1526  */
1527 static inline void cpu_load_eflags(CPUX86State *env, int eflags,
1528                                    int update_mask)
1529 {
1530     CC_SRC = eflags & (CC_O | CC_S | CC_Z | CC_A | CC_P | CC_C);
1531     CC_OP = CC_OP_EFLAGS;
1532     env->df = 1 - (2 * ((eflags >> 10) & 1));
1533     env->eflags = (env->eflags & ~update_mask) |
1534         (eflags & update_mask) | 0x2;
1535 }
1536
1537 /* load efer and update the corresponding hflags. XXX: do consistency
1538    checks with cpuid bits? */
1539 static inline void cpu_load_efer(CPUX86State *env, uint64_t val)
1540 {
1541     env->efer = val;
1542     env->hflags &= ~(HF_LMA_MASK | HF_SVME_MASK);
1543     if (env->efer & MSR_EFER_LMA) {
1544         env->hflags |= HF_LMA_MASK;
1545     }
1546     if (env->efer & MSR_EFER_SVME) {
1547         env->hflags |= HF_SVME_MASK;
1548     }
1549 }
1550
1551 static inline MemTxAttrs cpu_get_mem_attrs(CPUX86State *env)
1552 {
1553     return ((MemTxAttrs) { .secure = (env->hflags & HF_SMM_MASK) != 0 });
1554 }
1555
1556 /* fpu_helper.c */
1557 void cpu_set_mxcsr(CPUX86State *env, uint32_t val);
1558 void cpu_set_fpuc(CPUX86State *env, uint16_t val);
1559
1560 /* mem_helper.c */
1561 void helper_lock_init(void);
1562
1563 /* svm_helper.c */
1564 void cpu_svm_check_intercept_param(CPUX86State *env1, uint32_t type,
1565                                    uint64_t param);
1566 void cpu_vmexit(CPUX86State *nenv, uint32_t exit_code, uint64_t exit_info_1);
1567
1568 /* seg_helper.c */
1569 void do_interrupt_x86_hardirq(CPUX86State *env, int intno, int is_hw);
1570
1571 /* smm_helper.c */
1572 void do_smm_enter(X86CPU *cpu);
1573 void cpu_smm_update(X86CPU *cpu);
1574
1575 /* apic.c */
1576 void cpu_report_tpr_access(CPUX86State *env, TPRAccess access);
1577 void apic_handle_tpr_access_report(DeviceState *d, target_ulong ip,
1578                                    TPRAccess access);
1579
1580
1581 /* Change the value of a KVM-specific default
1582  *
1583  * If value is NULL, no default will be set and the original
1584  * value from the CPU model table will be kept.
1585  *
1586  * It is valid to call this function only for properties that
1587  * are already present in the kvm_default_props table.
1588  */
1589 void x86_cpu_change_kvm_default(const char *prop, const char *value);
1590
1591 /* mpx_helper.c */
1592 void cpu_sync_bndcs_hflags(CPUX86State *env);
1593
1594 /* Return name of 32-bit register, from a R_* constant */
1595 const char *get_register_name_32(unsigned int reg);
1596
1597 void enable_compat_apic_id_mode(void);
1598
1599 #define APIC_DEFAULT_ADDRESS 0xfee00000
1600 #define APIC_SPACE_SIZE      0x100000
1601
1602 void x86_cpu_dump_local_apic_state(CPUState *cs, FILE *f,
1603                                    fprintf_function cpu_fprintf, int flags);
1604
1605 /* cpu.c */
1606 bool cpu_is_bsp(X86CPU *cpu);
1607
1608 #endif /* I386_CPU_H */