X-Git-Url: https://git.saurik.com/apple/xnu.git/blobdiff_plain/91447636331957f3d9b5ca5b508f07c526b0074d..04b8595b18b1b41ac7a206e4b3d51a635f8413d7:/osfmk/mach/i386/thread_status.h diff --git a/osfmk/mach/i386/thread_status.h b/osfmk/mach/i386/thread_status.h index b41e6e7b7..9c682ee72 100644 --- a/osfmk/mach/i386/thread_status.h +++ b/osfmk/mach/i386/thread_status.h @@ -1,23 +1,29 @@ /* - * Copyright (c) 2000-2005 Apple Computer, Inc. All rights reserved. + * Copyright (c) 2000-2006 Apple Computer, Inc. All rights reserved. * - * @APPLE_LICENSE_HEADER_START@ + * @APPLE_OSREFERENCE_LICENSE_HEADER_START@ * - * The contents of this file constitute Original Code as defined in and - * are subject to the Apple Public Source License Version 1.1 (the - * "License"). You may not use this file except in compliance with the - * License. Please obtain a copy of the License at - * http://www.apple.com/publicsource and read it before using this file. + * This file contains Original Code and/or Modifications of Original Code + * as defined in and that are subject to the Apple Public Source License + * Version 2.0 (the 'License'). You may not use this file except in + * compliance with the License. The rights granted to you under the License + * may not be used to create, or enable the creation or redistribution of, + * unlawful or unlicensed copies of an Apple operating system, or to + * circumvent, violate, or enable the circumvention or violation of, any + * terms of an Apple operating system software license agreement. * - * This Original Code and all software distributed under the License are - * distributed on an "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, EITHER + * Please obtain a copy of the License at + * http://www.opensource.apple.com/apsl/ and read it before using this file. + * + * The Original Code and all software distributed under the License are + * distributed on an 'AS IS' basis, WITHOUT WARRANTY OF ANY KIND, EITHER * EXPRESS OR IMPLIED, AND APPLE HEREBY DISCLAIMS ALL SUCH WARRANTIES, * INCLUDING WITHOUT LIMITATION, ANY WARRANTIES OF MERCHANTABILITY, - * FITNESS FOR A PARTICULAR PURPOSE OR NON-INFRINGEMENT. Please see the - * License for the specific language governing rights and limitations - * under the License. + * FITNESS FOR A PARTICULAR PURPOSE, QUIET ENJOYMENT OR NON-INFRINGEMENT. + * Please see the License for the specific language governing rights and + * limitations under the License. * - * @APPLE_LICENSE_HEADER_END@ + * @APPLE_OSREFERENCE_LICENSE_HEADER_END@ */ /* * @OSF_COPYRIGHT@ @@ -61,334 +67,374 @@ #ifndef _MACH_I386_THREAD_STATUS_H_ #define _MACH_I386_THREAD_STATUS_H_ +#include #include #include #include -#include /* FIXME */ -#include /* FIXME */ +#include + /* - * i386_thread_state this is the structure that is exported - * to user threads for use in status/mutate - * calls. This structure should never - * change. - * - * i386_float_state exported to use threads for access to - * floating point registers. Try not to - * change this one, either. + * the i386_xxxx form is kept for legacy purposes since these types + * are externally known... eventually they should be deprecated. + * our internal implementation has moved to the following naming convention * - * i386_isa_port_map_state exported to user threads to allow - * selective in/out operations - * - * i386_v86_assist_state - * - * thread_syscall_state + * x86_xxxx32 names are used to deal with 32 bit states + * x86_xxxx64 names are used to deal with 64 bit states + * x86_xxxx names are used to deal with either 32 or 64 bit states + * via a self-describing mechanism */ -/* THREAD_STATE_FLAVOR_LIST 0 */ -#define i386_NEW_THREAD_STATE 1 /* used to be i386_THREAD_STATE */ -#define i386_FLOAT_STATE 2 -#define i386_ISA_PORT_MAP_STATE 3 -#define i386_V86_ASSIST_STATE 4 -#define i386_REGS_SEGS_STATE 5 -#define THREAD_SYSCALL_STATE 6 -#define THREAD_STATE_NONE 7 -#define i386_SAVED_STATE 8 +/* + * these are the legacy names which should be deprecated in the future + * they are externally known which is the only reason we don't just get + * rid of them + */ +#define i386_THREAD_STATE 1 +#define i386_FLOAT_STATE 2 +#define i386_EXCEPTION_STATE 3 + +/* + * THREAD_STATE_FLAVOR_LIST 0 + * these are the supported flavors + */ +#define x86_THREAD_STATE32 1 +#define x86_FLOAT_STATE32 2 +#define x86_EXCEPTION_STATE32 3 +#define x86_THREAD_STATE64 4 +#define x86_FLOAT_STATE64 5 +#define x86_EXCEPTION_STATE64 6 +#define x86_THREAD_STATE 7 +#define x86_FLOAT_STATE 8 +#define x86_EXCEPTION_STATE 9 +#define x86_DEBUG_STATE32 10 +#define x86_DEBUG_STATE64 11 +#define x86_DEBUG_STATE 12 +#define THREAD_STATE_NONE 13 +/* 14 and 15 are used for the internal x86_SAVED_STATE flavours */ +#define x86_AVX_STATE32 16 +#define x86_AVX_STATE64 17 +#define x86_AVX_STATE 18 +/* + * Largest state on this machine: + * (be sure mach/machine/thread_state.h matches!) + */ +#define THREAD_MACHINE_STATE_MAX THREAD_STATE_MAX + /* * VALID_THREAD_STATE_FLAVOR is a platform specific macro that when passed * an exception flavor will return if that is a defined flavor for that * platform. The macro must be manually updated to include all of the valid * exception flavors as defined above. */ -#define VALID_THREAD_STATE_FLAVOR(x) \ - ((x == i386_NEW_THREAD_STATE) || \ - (x == i386_FLOAT_STATE) || \ - (x == i386_ISA_PORT_MAP_STATE) || \ - (x == i386_V86_ASSIST_STATE) || \ - (x == i386_REGS_SEGS_STATE) || \ - (x == THREAD_SYSCALL_STATE) || \ - (x == THREAD_STATE_NONE) || \ - (x == i386_SAVED_STATE)) - -/* - * This structure is used for both - * i386_THREAD_STATE and i386_REGS_SEGS_STATE. - */ -struct i386_new_thread_state { - unsigned int gs; - unsigned int fs; - unsigned int es; - unsigned int ds; - unsigned int edi; - unsigned int esi; - unsigned int ebp; - unsigned int esp; - unsigned int ebx; - unsigned int edx; - unsigned int ecx; - unsigned int eax; - unsigned int eip; - unsigned int cs; - unsigned int efl; - unsigned int uesp; - unsigned int ss; +#define VALID_THREAD_STATE_FLAVOR(x) \ + ((x == x86_THREAD_STATE32) || \ + (x == x86_FLOAT_STATE32) || \ + (x == x86_EXCEPTION_STATE32) || \ + (x == x86_DEBUG_STATE32) || \ + (x == x86_THREAD_STATE64) || \ + (x == x86_FLOAT_STATE64) || \ + (x == x86_EXCEPTION_STATE64) || \ + (x == x86_DEBUG_STATE64) || \ + (x == x86_THREAD_STATE) || \ + (x == x86_FLOAT_STATE) || \ + (x == x86_EXCEPTION_STATE) || \ + (x == x86_DEBUG_STATE) || \ + (x == x86_AVX_STATE32) || \ + (x == x86_AVX_STATE64) || \ + (x == x86_AVX_STATE) || \ + (x == THREAD_STATE_NONE)) + +struct x86_state_hdr { + int flavor; + int count; }; -#define i386_NEW_THREAD_STATE_COUNT ((mach_msg_type_number_t) \ - (sizeof (struct i386_new_thread_state)/sizeof(unsigned int))) +typedef struct x86_state_hdr x86_state_hdr_t; /* - * Subset of saved state stored by processor on kernel-to-kernel - * trap. (Used by ddb to examine state guaranteed to be present - * on all traps into debugger.) + * Default segment register values. */ -struct i386_saved_state_from_kernel { - unsigned int gs; - unsigned int fs; - unsigned int es; - unsigned int ds; - unsigned int edi; - unsigned int esi; - unsigned int ebp; - unsigned int esp; /* kernel esp stored by pusha - - we save cr2 here later */ - unsigned int ebx; - unsigned int edx; - unsigned int ecx; - unsigned int eax; - unsigned int trapno; - unsigned int err; - unsigned int eip; - unsigned int cs; - unsigned int efl; -}; + +#define USER_CODE_SELECTOR 0x0017 +#define USER_DATA_SELECTOR 0x001f +#define KERN_CODE_SELECTOR 0x0008 +#define KERN_DATA_SELECTOR 0x0010 /* - * The format in which thread state is saved by Mach on this machine. This - * state flavor is most efficient for exception RPC's to kernel-loaded - * servers, because copying can be avoided: + * to be deprecated in the future */ -struct i386_saved_state { - unsigned int gs; - unsigned int fs; - unsigned int es; - unsigned int ds; - unsigned int edi; - unsigned int esi; - unsigned int ebp; - unsigned int esp; /* kernel esp stored by pusha - - we save cr2 here later */ - unsigned int ebx; - unsigned int edx; - unsigned int ecx; - unsigned int eax; - unsigned int trapno; - unsigned int err; - unsigned int eip; - unsigned int cs; - unsigned int efl; - unsigned int uesp; - unsigned int ss; - struct v86_segs { - unsigned int v86_es; /* virtual 8086 segment registers */ - unsigned int v86_ds; - unsigned int v86_fs; - unsigned int v86_gs; - } v86_segs; -#define i386_SAVED_ARGV_COUNT 7 - unsigned int argv_status; /* Boolean flag indicating whether or - * not Mach copied in the args */ - unsigned int argv[i386_SAVED_ARGV_COUNT]; - /* The return address, and the first several - * function call args from the stack, for - * efficient syscall exceptions */ -}; -#define i386_SAVED_STATE_COUNT ((mach_msg_type_number_t) \ - (sizeof (struct i386_saved_state)/sizeof(unsigned int))) -#define i386_REGS_SEGS_STATE_COUNT i386_SAVED_STATE_COUNT +typedef _STRUCT_X86_THREAD_STATE32 i386_thread_state_t; +#define i386_THREAD_STATE_COUNT ((mach_msg_type_number_t) \ + ( sizeof (i386_thread_state_t) / sizeof (int) )) + +typedef _STRUCT_X86_THREAD_STATE32 x86_thread_state32_t; +#define x86_THREAD_STATE32_COUNT ((mach_msg_type_number_t) \ + ( sizeof (x86_thread_state32_t) / sizeof (int) )) /* - * Machine-independent way for servers and Mach's exception mechanism to - * choose the most efficient state flavor for exception RPC's: + * to be deprecated in the future */ -#define MACHINE_THREAD_STATE i386_SAVED_STATE -#define MACHINE_THREAD_STATE_COUNT 144 +typedef _STRUCT_X86_FLOAT_STATE32 i386_float_state_t; +#define i386_FLOAT_STATE_COUNT ((mach_msg_type_number_t) \ + (sizeof(i386_float_state_t)/sizeof(unsigned int))) + +typedef _STRUCT_X86_FLOAT_STATE32 x86_float_state32_t; +#define x86_FLOAT_STATE32_COUNT ((mach_msg_type_number_t) \ + (sizeof(x86_float_state32_t)/sizeof(unsigned int))) + +typedef _STRUCT_X86_AVX_STATE32 x86_avx_state32_t; +#define x86_AVX_STATE32_COUNT ((mach_msg_type_number_t) \ + (sizeof(x86_avx_state32_t)/sizeof(unsigned int))) /* - * Largest state on this machine: - * (be sure mach/machine/thread_state.h matches!) + * to be deprecated in the future */ -#define THREAD_MACHINE_STATE_MAX THREAD_STATE_MAX +typedef _STRUCT_X86_EXCEPTION_STATE32 i386_exception_state_t; +#define i386_EXCEPTION_STATE_COUNT ((mach_msg_type_number_t) \ + ( sizeof (i386_exception_state_t) / sizeof (int) )) -/* - * Floating point state. - * - * fpkind tells in what way floating point operations are supported. - * See the values for fp_kind in . - * - * If the kind is FP_NO, then calls to set the state will fail, and - * thread_getstatus will return garbage for the rest of the state. - * If "initialized" is false, then the rest of the state is garbage. - * Clients can set "initialized" to false to force the coprocessor to - * be reset. - * "exc_status" is non-zero if the thread has noticed (but not - * proceeded from) a coprocessor exception. It contains the status - * word with the exception bits set. The status word in "fp_status" - * will have the exception bits turned off. If an exception bit in - * "fp_status" is turned on, then "exc_status" should be zero. This - * happens when the coprocessor exception is noticed after the system - * has context switched to some other thread. - * - * If kind is FP_387, then "state" is a i387_state. Other kinds might - * also use i387_state, but somebody will have to verify it (XXX). - * Note that the registers are ordered from top-of-stack down, not - * according to physical register number. - */ +typedef _STRUCT_X86_EXCEPTION_STATE32 x86_exception_state32_t; +#define x86_EXCEPTION_STATE32_COUNT ((mach_msg_type_number_t) \ + ( sizeof (x86_exception_state32_t) / sizeof (int) )) -#define FP_STATE_BYTES 512 +#define I386_EXCEPTION_STATE_COUNT i386_EXCEPTION_STATE_COUNT -struct i386_float_state { - int fpkind; /* FP_NO..FP_387 (readonly) */ - int initialized; - unsigned char hw_state[FP_STATE_BYTES]; /* actual "hardware" state */ - int exc_status; /* exception status (readonly) */ -}; -#define i386_FLOAT_STATE_COUNT ((mach_msg_type_number_t) \ - (sizeof(struct i386_float_state)/sizeof(unsigned int))) +typedef _STRUCT_X86_DEBUG_STATE32 x86_debug_state32_t; +#define x86_DEBUG_STATE32_COUNT ((mach_msg_type_number_t) \ + ( sizeof (x86_debug_state32_t) / sizeof (int) )) +#define X86_DEBUG_STATE32_COUNT x86_DEBUG_STATE32_COUNT -#define FP_old_STATE_BYTES ((mach_msg_type_number_t) \ - (sizeof (struct i386_fp_save) + sizeof (struct i386_fp_regs))) +typedef _STRUCT_X86_THREAD_STATE64 x86_thread_state64_t; +#define x86_THREAD_STATE64_COUNT ((mach_msg_type_number_t) \ + ( sizeof (x86_thread_state64_t) / sizeof (int) )) -struct i386_old_float_state { - int fpkind; /* FP_NO..FP_387 (readonly) */ - int initialized; - unsigned char hw_state[FP_old_STATE_BYTES]; /* actual "hardware" state */ - int exc_status; /* exception status (readonly) */ -}; -#define i386_old_FLOAT_STATE_COUNT ((mach_msg_type_number_t) \ - (sizeof(struct i386_old_float_state)/sizeof(unsigned int))) +typedef _STRUCT_X86_FLOAT_STATE64 x86_float_state64_t; +#define x86_FLOAT_STATE64_COUNT ((mach_msg_type_number_t) \ + (sizeof(x86_float_state64_t)/sizeof(unsigned int))) +typedef _STRUCT_X86_AVX_STATE64 x86_avx_state64_t; +#define x86_AVX_STATE64_COUNT ((mach_msg_type_number_t) \ + (sizeof(x86_avx_state64_t)/sizeof(unsigned int))) -#define PORT_MAP_BITS 0x400 -struct i386_isa_port_map_state { - unsigned char pm[PORT_MAP_BITS>>3]; -}; +typedef _STRUCT_X86_EXCEPTION_STATE64 x86_exception_state64_t; +#define x86_EXCEPTION_STATE64_COUNT ((mach_msg_type_number_t) \ + ( sizeof (x86_exception_state64_t) / sizeof (int) )) + +#define X86_EXCEPTION_STATE64_COUNT x86_EXCEPTION_STATE64_COUNT + +typedef _STRUCT_X86_DEBUG_STATE64 x86_debug_state64_t; +#define x86_DEBUG_STATE64_COUNT ((mach_msg_type_number_t) \ + ( sizeof (x86_debug_state64_t) / sizeof (int) )) -#define i386_ISA_PORT_MAP_STATE_COUNT ((mach_msg_type_number_t) \ - (sizeof(struct i386_isa_port_map_state)/sizeof(unsigned int))) +#define X86_DEBUG_STATE64_COUNT x86_DEBUG_STATE64_COUNT /* - * V8086 assist supplies a pointer to an interrupt - * descriptor table in task space. + * Combined thread, float and exception states */ -struct i386_v86_assist_state { - unsigned int int_table; /* interrupt table address */ - int int_count; /* interrupt table size */ +struct x86_thread_state { + x86_state_hdr_t tsh; + union { + x86_thread_state32_t ts32; + x86_thread_state64_t ts64; + } uts; }; -struct v86_interrupt_table { - unsigned int count; /* count of pending interrupts */ - unsigned short mask; /* ignore this interrupt if true */ - unsigned short vec; /* vector to take */ +struct x86_float_state { + x86_state_hdr_t fsh; + union { + x86_float_state32_t fs32; + x86_float_state64_t fs64; + } ufs; }; -#define i386_V86_ASSIST_STATE_COUNT ((mach_msg_type_number_t) \ - (sizeof(struct i386_v86_assist_state)/sizeof(unsigned int))) +struct x86_exception_state { + x86_state_hdr_t esh; + union { + x86_exception_state32_t es32; + x86_exception_state64_t es64; + } ues; +}; -struct thread_syscall_state { - unsigned eax; - unsigned edx; - unsigned efl; - unsigned eip; - unsigned esp; +struct x86_debug_state { + x86_state_hdr_t dsh; + union { + x86_debug_state32_t ds32; + x86_debug_state64_t ds64; + } uds; }; -#define i386_THREAD_SYSCALL_STATE_COUNT ((mach_msg_type_number_t) \ - (sizeof(struct thread_syscall_state) / sizeof(unsigned int))) +struct x86_avx_state { + x86_state_hdr_t ash; + union { + x86_avx_state32_t as32; + x86_avx_state64_t as64; + } ufs; +}; -/* - * Main thread state consists of - * general registers, segment registers, - * eip and eflags. - */ +typedef struct x86_thread_state x86_thread_state_t; +#define x86_THREAD_STATE_COUNT ((mach_msg_type_number_t) \ + ( sizeof (x86_thread_state_t) / sizeof (int) )) -#define i386_THREAD_STATE -1 +typedef struct x86_float_state x86_float_state_t; +#define x86_FLOAT_STATE_COUNT ((mach_msg_type_number_t) \ + (sizeof(x86_float_state_t)/sizeof(unsigned int))) -typedef struct { - unsigned int eax; - unsigned int ebx; - unsigned int ecx; - unsigned int edx; - unsigned int edi; - unsigned int esi; - unsigned int ebp; - unsigned int esp; - unsigned int ss; - unsigned int eflags; - unsigned int eip; - unsigned int cs; - unsigned int ds; - unsigned int es; - unsigned int fs; - unsigned int gs; -} i386_thread_state_t; +typedef struct x86_exception_state x86_exception_state_t; +#define x86_EXCEPTION_STATE_COUNT ((mach_msg_type_number_t) \ + (sizeof(x86_exception_state_t)/sizeof(unsigned int))) -#define i386_THREAD_STATE_COUNT ((mach_msg_type_number_t) \ - ( sizeof (i386_thread_state_t) / sizeof (int) )) +typedef struct x86_debug_state x86_debug_state_t; +#define x86_DEBUG_STATE_COUNT ((mach_msg_type_number_t) \ + (sizeof(x86_debug_state_t)/sizeof(unsigned int))) + +typedef struct x86_avx_state x86_avx_state_t; +#define x86_AVX_STATE_COUNT ((mach_msg_type_number_t) \ + (sizeof(x86_avx_state_t)/sizeof(unsigned int))) /* - * Default segment register values. + * Machine-independent way for servers and Mach's exception mechanism to + * choose the most efficient state flavor for exception RPC's: */ - -#define USER_CODE_SELECTOR 0x0017 -#define USER_DATA_SELECTOR 0x001f -#define KERN_CODE_SELECTOR 0x0008 -#define KERN_DATA_SELECTOR 0x0010 +#define MACHINE_THREAD_STATE x86_THREAD_STATE +#define MACHINE_THREAD_STATE_COUNT x86_THREAD_STATE_COUNT + +#ifdef XNU_KERNEL_PRIVATE + +#define x86_SAVED_STATE32 THREAD_STATE_NONE + 1 +#define x86_SAVED_STATE64 THREAD_STATE_NONE + 2 /* - * Thread floating point state - * includes FPU environment as - * well as the register stack. + * The format in which thread state is saved by Mach on this machine. This + * state flavor is most efficient for exception RPC's to kernel-loaded + * servers, because copying can be avoided: */ - -#define i386_THREAD_FPSTATE -2 +struct x86_saved_state32 { + uint32_t gs; + uint32_t fs; + uint32_t es; + uint32_t ds; + uint32_t edi; + uint32_t esi; + uint32_t ebp; + uint32_t cr2; /* kernel esp stored by pusha - we save cr2 here later */ + uint32_t ebx; + uint32_t edx; + uint32_t ecx; + uint32_t eax; + uint16_t trapno; + uint16_t cpu; + uint32_t err; + uint32_t eip; + uint32_t cs; + uint32_t efl; + uint32_t uesp; + uint32_t ss; +}; +typedef struct x86_saved_state32 x86_saved_state32_t; -typedef struct { - fp_env_t environ; - fp_stack_t stack; -} i386_thread_fpstate_t; +#define x86_SAVED_STATE32_COUNT ((mach_msg_type_number_t) \ + (sizeof (x86_saved_state32_t)/sizeof(unsigned int))) -#define i386_THREAD_FPSTATE_COUNT ((mach_msg_type_number_t) \ - ( sizeof (i386_thread_fpstate_t) / sizeof (int) )) +#pragma pack(4) /* - * Extra state that may be - * useful to exception handlers. + * This is the state pushed onto the 64-bit interrupt stack + * on any exception/trap/interrupt. */ +struct x86_64_intr_stack_frame { + uint16_t trapno; + uint16_t cpu; + uint32_t _pad; + uint64_t trapfn; + uint64_t err; + uint64_t rip; + uint64_t cs; + uint64_t rflags; + uint64_t rsp; + uint64_t ss; +}; +typedef struct x86_64_intr_stack_frame x86_64_intr_stack_frame_t; +/* Note: sizeof(x86_64_intr_stack_frame_t) must be a multiple of 16 bytes */ -#define i386_THREAD_EXCEPTSTATE -3 - -typedef struct { - unsigned int trapno; - err_code_t err; -} i386_thread_exceptstate_t; +/* + * thread state format for task running in 64bit long mode + * in long mode, the same hardware frame is always pushed regardless + * of whether there was a change in privlege level... therefore, there + * is no need for an x86_saved_state64_from_kernel variant + */ +struct x86_saved_state64 { + uint64_t rdi; /* arg0 for system call */ + uint64_t rsi; + uint64_t rdx; + uint64_t r10; /* R10 := RCX prior to syscall trap */ + uint64_t r8; + uint64_t r9; /* arg5 for system call */ + + uint64_t cr2; + uint64_t r15; + uint64_t r14; + uint64_t r13; + uint64_t r12; + uint64_t r11; + uint64_t rbp; + uint64_t rbx; + uint64_t rcx; + uint64_t rax; + + uint32_t gs; + uint32_t fs; + + uint64_t _pad; + + struct x86_64_intr_stack_frame isf; +}; +typedef struct x86_saved_state64 x86_saved_state64_t; +#define x86_SAVED_STATE64_COUNT ((mach_msg_type_number_t) \ + (sizeof (struct x86_saved_state64)/sizeof(unsigned int))) -#define i386_THREAD_EXCEPTSTATE_COUNT ((mach_msg_type_number_t) \ - ( sizeof (i386_thread_exceptstate_t) / sizeof (int) )) +extern uint32_t get_eflags_exportmask(void); /* - * Per-thread variable used - * to store 'self' id for cthreads. + * Unified, tagged saved state: */ - -#define i386_THREAD_CTHREADSTATE -4 - typedef struct { - unsigned int self; -} i386_thread_cthreadstate_t; - -#define i386_THREAD_CTHREADSTATE_COUNT ((mach_msg_type_number_t) \ - ( sizeof (i386_thread_cthreadstate_t) / sizeof (int) )) + uint32_t flavor; + uint32_t _pad_for_16byte_alignment[3]; + union { + x86_saved_state32_t ss_32; + x86_saved_state64_t ss_64; + } uss; +} x86_saved_state_t; +#define ss_32 uss.ss_32 +#define ss_64 uss.ss_64 +#pragma pack() + +static inline boolean_t +is_saved_state64(x86_saved_state_t *iss) +{ + return (iss->flavor == x86_SAVED_STATE64); +} + +static inline boolean_t +is_saved_state32(x86_saved_state_t *iss) +{ + return (iss->flavor == x86_SAVED_STATE32); +} + +static inline x86_saved_state32_t * +saved_state32(x86_saved_state_t *iss) +{ + return &iss->ss_32; +} + +static inline x86_saved_state64_t * +saved_state64(x86_saved_state_t *iss) +{ + return &iss->ss_64; +} + +#endif /* XNU_KERNEL_PRIVATE */ #endif /* _MACH_I386_THREAD_STATUS_H_ */