Changeset 13303


Ignore:
Timestamp:
Dec 17, 2009, 2:58:25 PM (10 years ago)
Author:
gz
Message:

Mac/Windows?-only changes from trunk (r13206-r13209)

Location:
branches/working-0711/ccl
Files:
6 edited

Legend:

Unmodified
Added
Removed
  • branches/working-0711/ccl

  • branches/working-0711/ccl/level-1/linux-files.lisp

    r13192 r13303  
    20642064    (+ (pref tv :timeval.tv_sec) unix-to-universal-time)))
    20652065
     2066#+windows-target
     2067(defloadvar *windows-allocation-granularity*
     2068    (rlet ((info #>SYSTEM_INFO))
     2069      (#_GetSystemInfo info)
     2070      (pref info #>SYSTEM_INFO.dwAllocationGranularity)))
     2071
    20662072#-windows-target
    2067 (progn
     2073(defun %memory-map-fd (fd len bits-per-element)
     2074  (let* ((nbytes (+ *host-page-size*
     2075                    (logandc2 (+ len
     2076                                 (1- *host-page-size*))
     2077                              (1- *host-page-size*))))         
     2078         (ndata-elements
     2079          (ash len
     2080               (ecase bits-per-element
     2081                 (1 3)
     2082                 (8 0)
     2083                 (16 -1)
     2084                 (32 -2)
     2085                 (64 -3))))
     2086         (nalignment-elements
     2087          (ash target::nbits-in-word
     2088               (ecase bits-per-element
     2089                 (1 0)
     2090                 (8 -3)
     2091                 (16 -4)
     2092                 (32 -5)
     2093                 (64 -6)))))
     2094    (if (>= (+ ndata-elements nalignment-elements)
     2095            array-total-size-limit)
     2096      (progn
     2097        (fd-close fd)
     2098        (error "Can't make a vector with ~s elements in this implementation." (+ ndata-elements nalignment-elements)))
     2099      (let* ((addr (#_mmap (%null-ptr)
     2100                           nbytes
     2101                           #$PROT_NONE
     2102                           (logior #$MAP_ANON #$MAP_PRIVATE)
     2103                           -1
     2104                           0)))             
     2105        (if (eql addr (%int-to-ptr (1- (ash 1 target::nbits-in-word)))) ; #$MAP_FAILED
     2106          (let* ((errno (%get-errno)))
     2107            (fd-close fd)
     2108            (error "Can't map ~d bytes: ~a" nbytes (%strerror errno)))
     2109              ;;; Remap the first page so that we can put a vector header
     2110              ;;; there; use the first word on the first page to remember
     2111              ;;; the file descriptor.
     2112          (progn
     2113            (#_mmap addr
     2114                    *host-page-size*
     2115                    (logior #$PROT_READ #$PROT_WRITE)
     2116                    (logior #$MAP_ANON #$MAP_PRIVATE #$MAP_FIXED)
     2117                    -1
     2118                    0)
     2119            (setf (pref addr :int) fd)
     2120            (let* ((header-addr (%inc-ptr addr (- *host-page-size*
     2121                                                            (* 2 target::node-size)))))
     2122             
     2123              (when (> len 0)
     2124                (let* ((target-addr (%inc-ptr header-addr (* 2 target::node-size))))
     2125                  (unless (eql target-addr
     2126                               (#_mmap target-addr
     2127                                       len
     2128                                       #$PROT_READ
     2129                                       (logior #$MAP_PRIVATE #$MAP_FIXED)
     2130                                       fd
     2131                                       0))
     2132                    (let* ((errno (%get-errno)))
     2133                      (fd-close fd)
     2134                      (#_munmap addr nbytes)
     2135                      (error "Mapping failed: ~a" (%strerror errno))))))
     2136              (values header-addr ndata-elements nalignment-elements))))))))
     2137
     2138#+windows-target
     2139(defun %memory-map-fd (fd len bits-per-element)
     2140  (let* ((nbytes (+ *windows-allocation-granularity*
     2141                    (logandc2 (+ len
     2142                                 (1- *windows-allocation-granularity*))
     2143                              (1- *windows-allocation-granularity*))))         
     2144         (ndata-elements
     2145          (ash len
     2146               (ecase bits-per-element
     2147                 (1 3)
     2148                 (8 0)
     2149                 (16 -1)
     2150                 (32 -2)
     2151                 (64 -3))))
     2152         (nalignment-elements
     2153          (ash target::nbits-in-word
     2154               (ecase bits-per-element
     2155                 (1 0)
     2156                 (8 -3)
     2157                 (16 -4)
     2158                 (32 -5)
     2159                 (64 -6)))))
     2160    (if (>= (+ ndata-elements nalignment-elements)
     2161            array-total-size-limit)
     2162      (progn
     2163        (fd-close fd)
     2164        (error "Can't make a vector with ~s elements in this implementation." (+ ndata-elements nalignment-elements)))
     2165      (let* ((mapping (#_CreateFileMappingA (%int-to-ptr fd) (%null-ptr) #$PAGE_READONLY 0 0 (%null-ptr))))
     2166        (if (%null-ptr-p mapping)
     2167          (let* ((err (#_GetLastError)))
     2168            (fd-close fd)
     2169            (error "Couldn't create a file mapping - ~a." (%windows-error-string err)))
     2170          (loop
     2171            (let* ((base (#_VirtualAlloc (%null-ptr) nbytes #$MEM_RESERVE #$PAGE_NOACCESS)))
     2172              (if (%null-ptr-p base)
     2173                (let* ((err (#_GetLastError)))
     2174                  (#_CloseHandle mapping)
     2175                  (fd-close fd)
     2176                  (error "Couldn't reserve ~d bytes of address space for mapped file - ~a"
     2177                         nbytes (%windows-error-string err)))
     2178                ;; Now we have to free the memory and hope that we can reallocate it ...
     2179                (progn
     2180                  (#_VirtualFree base 0 #$MEM_RELEASE)
     2181                  (unless (%null-ptr-p (#_VirtualAlloc base *windows-allocation-granularity* #$MEM_RESERVE #$PAGE_NOACCESS))
     2182                    (let* ((fptr (%inc-ptr base *windows-allocation-granularity*)))
     2183                      (if (%null-ptr-p (#_MapViewOfFileEx mapping #$FILE_MAP_READ 0 0 0 fptr))
     2184                        (#_VirtualFree base 0 #$MEM_RELEASE)
     2185                        (let* ((prefix-page (%inc-ptr base (- *windows-allocation-granularity*
     2186                                                              *host-page-size*))))
     2187                          (#_VirtualAlloc prefix-page *host-page-size* #$MEM_COMMIT #$PAGE_READWRITE)
     2188                          (setf (paref prefix-page (:* :address) 0) mapping
     2189                                (paref prefix-page (:* :address) 1) (%int-to-ptr fd))
     2190                          (return (values
     2191                                   (%inc-ptr prefix-page (- *host-page-size*
     2192                                                            (* 2 target::node-size)))
     2193                                   ndata-elements
     2194                                   nalignment-elements)))))))))))))))
     2195                       
     2196
     2197
    20682198(defun map-file-to-ivector (pathname element-type)
    20692199  (let* ((upgraded-type (upgraded-array-element-type element-type))
     
    20802210          (if (< len 0)
    20812211            (signal-file-error fd pathname)
    2082             (let* ((nbytes (+ *host-page-size*
    2083                               (logandc2 (+ len
    2084                                            (1- *host-page-size*))
    2085                                         (1- *host-page-size*))))
    2086 
    2087                    (ndata-elements
    2088                     (ash len
    2089                          (ecase bits-per-element
    2090                            (1 3)
    2091                            (8 0)
    2092                            (16 -1)
    2093                            (32 -2)
    2094                            (64 -3))))
    2095                    (nalignment-elements
    2096                     (ash target::nbits-in-word
    2097                          (ecase bits-per-element
    2098                            (1 0)
    2099                            (8 -3)
    2100                            (16 -4)
    2101                            (32 -5)
    2102                            (64 -6)))))
    2103               (if (>= (+ ndata-elements nalignment-elements)
    2104                       array-total-size-limit)
    2105                 (progn
    2106                   (fd-close fd)
    2107                   (error "Can't make a vector with ~s elements in this implementation." (+ ndata-elements nalignment-elements)))
    2108                 (let* ((addr (#_mmap (%null-ptr)
    2109                                      nbytes
    2110                                      #$PROT_NONE
    2111                                      (logior #$MAP_ANON #$MAP_PRIVATE)
    2112                                      -1
    2113                                      0)))             
    2114                   (if (eql addr (%int-to-ptr (1- (ash 1 target::nbits-in-word)))) ; #$MAP_FAILED
    2115                     (let* ((errno (%get-errno)))
    2116                       (fd-close fd)
    2117                       (error "Can't map ~d bytes: ~a" nbytes (%strerror errno)))
    2118               ;;; Remap the first page so that we can put a vector header
    2119               ;;; there; use the first word on the first page to remember
    2120               ;;; the file descriptor.
    2121                     (progn
    2122                       (#_mmap addr
    2123                               *host-page-size*
    2124                               (logior #$PROT_READ #$PROT_WRITE)
    2125                               (logior #$MAP_ANON #$MAP_PRIVATE #$MAP_FIXED)
    2126                               -1
    2127                               0)
    2128                       (setf (pref addr :int) fd)
    2129                       (let* ((header-addr (%inc-ptr addr (- *host-page-size*
    2130                                                             (* 2 target::node-size)))))
    2131                         (setf (pref header-addr :unsigned-long)
    2132                               (logior (element-type-subtype upgraded-type)
    2133                                       (ash (+ ndata-elements nalignment-elements) target::num-subtag-bits)))
    2134                         (when (> len 0)
    2135                           (let* ((target-addr (%inc-ptr header-addr (* 2 target::node-size))))
    2136                             (unless (eql target-addr
    2137                                          (#_mmap target-addr
    2138                                                  len
    2139                                                  #$PROT_READ
    2140                                                  (logior #$MAP_PRIVATE #$MAP_FIXED)
    2141                                                  fd
    2142                                                  0))
    2143                               (let* ((errno (%get-errno)))
    2144                                 (fd-close fd)
    2145                                 (#_munmap addr nbytes)
    2146                                 (error "Mapping failed: ~a" (%strerror errno))))))
    2147                         (with-macptrs ((v (%inc-ptr header-addr target::fulltag-misc)))
     2212            (multiple-value-bind (header-address ndata-elements nalignment-elements)
     2213                (%memory-map-fd fd len bits-per-element)
     2214              (setf (%get-natural header-address 0)
     2215                    (logior (element-type-subtype upgraded-type)
     2216                            (ash (+ ndata-elements nalignment-elements) target::num-subtag-bits)))
     2217              (with-macptrs ((v (%inc-ptr header-address target::fulltag-misc)))
    21482218                          (let* ((vector (rlet ((p :address v)) (%get-object p 0))))
    21492219                            ;; Tell some parts of Clozure CL - notably the
     
    21572227                                        :displaced-to vector
    21582228                                        :adjustable t
    2159                                         :displaced-index-offset nalignment-elements)))))))))))))))
     2229                                        :displaced-index-offset nalignment-elements))))))))))
    21602230
    21612231(defun map-file-to-octet-vector (pathname)
     
    21782248                 target::node-size)))))
    21792249
    2180  
     2250
     2251#-windows-target
     2252(defun %unmap-file (data-address size-in-octets)
     2253  (let* ((base-address (%inc-ptr data-address (- *host-page-size*)))
     2254         (fd (pref base-address :int)))
     2255    (#_munmap base-address (+ *host-page-size* size-in-octets))
     2256    (fd-close fd)))
     2257
     2258#+windows-target
     2259(defun %unmap-file (data-address size-in-octets)
     2260  (declare (ignore size-in-octets))
     2261  (let* ((prefix-page (%inc-ptr data-address (- *host-page-size*)))
     2262         (prefix-allocation (%inc-ptr data-address (- *windows-allocation-granularity*)))
     2263         (mapping (paref prefix-page (:* :address) 0))
     2264         (fd (%ptr-to-int (paref prefix-page (:* :address) 1))))
     2265    (#_UnmapViewOfFile data-address)
     2266    (#_CloseHandle mapping)
     2267    (#_VirtualFree prefix-allocation 0 #$MEM_RELEASE)
     2268    (fd-close fd)))
     2269
     2270   
     2271
    21812272;;; Argument should be something returned by MAP-FILE-TO-IVECTOR;
    21822273;;; this should be called at most once for any such object.
     
    21842275  (multiple-value-bind (data-address size-in-octets)
    21852276      (mapped-vector-data-address-and-size displaced-vector)
    2186   (let* ((v (array-displacement displaced-vector))
    2187          (base-address (%inc-ptr data-address (- *host-page-size*)))
    2188          (fd (pref base-address :int)))
     2277  (let* ((v (array-displacement displaced-vector)))
    21892278      (let* ((element-type (array-element-type displaced-vector)))
    21902279        (adjust-array displaced-vector 0
     
    21942283      (with-lock-grabbed (*heap-ivector-lock*)
    21952284        (setq *heap-ivectors* (delete v *heap-ivectors*)))
    2196       (#_munmap base-address (+ size-in-octets *host-page-size*))     
    2197       (fd-close fd)
     2285      (%unmap-file data-address size-in-octets)
    21982286      t)))
    21992287
     
    22012289  (unmap-ivector v))
    22022290
     2291#-windows-target
     2292(progn
    22032293(defun lock-mapped-vector (v)
    22042294  (multiple-value-bind (address nbytes)
     
    22392329    (percentage-of-resident-pages address nbytes)))
    22402330)
     2331
    22412332
    22422333#+windows-target
  • branches/working-0711/ccl/lisp-kernel/lisptypes.h

    r13070 r13303  
    8383#include <sys/signal.h>
    8484#include <sys/ucontext.h>
     85#include <AvailabilityMacros.h>
    8586
    8687#ifdef PPC
     88#if MAC_OS_X_VERSION_MIN_REQUIRED <= MAC_OS_X_VERSION_10_4
     89#define __ss ss
     90#define __es es
     91#define __fs fs
     92
     93#define __srr0 srr0
     94#define __srr1 srr1
     95#define __r0 r0
     96#define __r1 r1
     97#define __r3 r3
     98#define __r4 r4
     99#define __r5 r5
     100#define __r6 r6
     101#define __r13 r13
     102#define __cr cr
     103#define __xer xer
     104#define __lr lr
     105#define __ctr ctr
     106
     107#define __dar dar
     108#define __dsisr dsisr
     109#define __exception exception
     110
     111#define __fpregs fpregs
     112#define __fpscr fpscr
     113#endif
     114
    87115#if WORD_SIZE == 64
    88116#ifdef _STRUCT_UCONTEXT64
     
    110138
    111139#ifdef X8664
    112 /* Broken <i386/ucontext.h> in xcode 2.4 */
    113 #ifndef _STRUCT_MCONTEXT64 /* A guess at what'll be defined when this is fixed */
     140#if MAC_OS_X_VERSION_MIN_REQUIRED <= MAC_OS_X_VERSION_10_4
     141/* Broken <i386/ucontext.h> in Mac OS 10.4u SDK */
    114142struct mcontext64 {
    115143        x86_exception_state64_t __es;
     
    125153#define __fpu_xmm0 fpu_xmm0
    126154#define __rsp rsp
     155#define __trapno trapno
    127156#define __faultvaddr faultvaddr
    128157#define __err err
     
    134163#define __r8 r8
    135164#define __rflags rflags
    136 #else
     165#else /* post-10.4 */
    137166typedef mcontext_t MCONTEXT_T;
    138167typedef ucontext_t ExceptionInformation;
    139168#define UC_MCONTEXT(UC) UC->uc_mcontext
    140 #endif /* _STRUCT_MCONTEXT64 */
    141 #endif /* X86_64 */
     169#endif
     170#endif
    142171
    143172#ifdef X8632
     
    151180   names (without leading __ prefixes.)  Confused yet ? */
    152181
    153 /* #if STILL_SUPPORT_TIGER */
     182#if MAC_OS_X_VERSION_MIN_REQUIRED <= MAC_OS_X_VERSION_10_4
    154183#define __ss ss
    155184#define __ds ds
     
    165194#define __fpu_mxcsr fpu_mxcsr
    166195#define __fpu_stmm0 fpu_stmm0
     196#define __trapno trapno
    167197#define __err err
    168198#define __faultvaddr faultvaddr
    169 /* #endif STILL_SUPPORT_TIGER */
     199#endif
    170200
    171201#define UC_MCONTEXT(UC) UC->uc_mcontext
  • branches/working-0711/ccl/lisp-kernel/ppc-exceptions.c

    r13070 r13303  
    24732473  kret = thread_set_state(thread,
    24742474                          PPC_FLOAT_STATE,
    2475                           (thread_state_t)&(mc->fs),
     2475                          (thread_state_t)&(mc->__fs),
    24762476                          PPC_FLOAT_STATE_COUNT);
    24772477
     
    24822482  kret = thread_set_state(thread,
    24832483                          PPC_THREAD_STATE64,
    2484                           (thread_state_t)&(mc->ss),
     2484                          (thread_state_t)&(mc->__ss),
    24852485                          PPC_THREAD_STATE64_COUNT);
    24862486#else
    24872487  kret = thread_set_state(thread,
    24882488                          MACHINE_THREAD_STATE,
    2489                           (thread_state_t)&(mc->ss),
     2489                          (thread_state_t)&(mc->__ss),
    24902490                          MACHINE_THREAD_STATE_COUNT);
    24912491#endif
     
    25592559    Bug(NULL, "Exception thread can't obtain thread state, Mach result = %d", result);
    25602560  }
    2561   stackp = ts.r1;
     2561  stackp = ts.__r1;
    25622562  backlink = stackp;
    25632563  stackp = TRUNC_DOWN(stackp, C_REDZONE_LEN, C_STK_ALIGN);
     
    25672567  stackp = TRUNC_DOWN(stackp, sizeof(*mc), C_STK_ALIGN);
    25682568  mc = (MCONTEXT_T) ptr_from_lispobj(stackp);
    2569   memmove(&(mc->ss),&ts,sizeof(ts));
     2569  memmove(&(mc->__ss),&ts,sizeof(ts));
    25702570
    25712571  thread_state_count = PPC_FLOAT_STATE_COUNT;
    25722572  thread_get_state(thread,
    25732573                   PPC_FLOAT_STATE,
    2574                    (thread_state_t)&(mc->fs),
     2574                   (thread_state_t)&(mc->__fs),
    25752575                   &thread_state_count);
    25762576
     
    25872587                   PPC_EXCEPTION_STATE,
    25882588#endif
    2589                    (thread_state_t)&(mc->es),
     2589                   (thread_state_t)&(mc->__es),
    25902590                   &thread_state_count);
    25912591
     
    26502650  */
    26512651
    2652   ts.srr0 = (natural) handler_address;
    2653   ts.srr1 = (int) xpMSR(pseudosigcontext) & ~MSR_FE0_FE1_MASK;
    2654   ts.r1 = stackp;
    2655   ts.r3 = signum;
    2656   ts.r4 = (natural)pseudosigcontext;
    2657   ts.r5 = (natural)tcr;
    2658   ts.r6 = (natural)old_valence;
    2659   ts.lr = (natural)pseudo_sigreturn;
     2652  ts.__srr0 = (natural) handler_address;
     2653  ts.__srr1 = (int) xpMSR(pseudosigcontext) & ~MSR_FE0_FE1_MASK;
     2654  ts.__r1 = stackp;
     2655  ts.__r3 = signum;
     2656  ts.__r4 = (natural)pseudosigcontext;
     2657  ts.__r5 = (natural)tcr;
     2658  ts.__r6 = (natural)old_valence;
     2659  ts.__lr = (natural)pseudo_sigreturn;
    26602660
    26612661
    26622662#ifdef PPC64
    2663   ts.r13 = xpGPR(pseudosigcontext,13);
     2663  ts.__r13 = xpGPR(pseudosigcontext,13);
    26642664  thread_set_state(thread,
    26652665                   PPC_THREAD_STATE64,
     
    27102710                   &thread_state_count);
    27112711  if (enabled) {
    2712     ts.srr1 |= MSR_FE0_FE1_MASK;
     2712    ts.__srr1 |= MSR_FE0_FE1_MASK;
    27132713  } else {
    2714     ts.srr1 &= ~MSR_FE0_FE1_MASK;
     2714    ts.__srr1 &= ~MSR_FE0_FE1_MASK;
    27152715  }
    27162716  /*
     
    27302730  */
    27312731  {
    2732     lisp_frame *tos = (lisp_frame *)ts.r1,
     2732    lisp_frame *tos = (lisp_frame *)ts.__r1,
    27332733      *next_frame = tos->backlink;
    27342734   
    27352735    if (tos == (next_frame -1)) {
    2736       ts.srr0 = tos->savelr;
    2737       ts.r1 = (LispObj) next_frame;
     2736      ts.__srr0 = tos->savelr;
     2737      ts.__r1 = (LispObj) next_frame;
    27382738    } else {
    2739       ts.srr0 += 4;
     2739      ts.__srr0 += 4;
    27402740    }
    27412741  }
  • branches/working-0711/ccl/lisp-kernel/ppc-exceptions.h

    r13070 r13303  
    7070
    7171#ifdef DARWIN
    72 #define xpGPRvector(x) (&(UC_MCONTEXT(x)->ss.r0))
     72#define xpGPRvector(x) (&(UC_MCONTEXT(x)->__ss.__r0))
    7373#define xpGPR(x,gprno) ((xpGPRvector(x))[gprno])
    7474#define set_xpGPR(x,gpr,new) xpGPR((x),(gpr)) = (UInt32)(new)
    75 #define xpPC(x) (*((pc*) &(UC_MCONTEXT(x)->ss.srr0)))
     75#define xpPC(x) (*((pc*) &(UC_MCONTEXT(x)->__ss.__srr0)))
    7676#define set_xpPC(x,new) (xpPC(x) = (pc)(new))
    77 #define xpLR(x) (*((pc*)(&(UC_MCONTEXT(x)->ss.lr))))
    78 #define xpCTR(x) (*(pc*)(&(UC_MCONTEXT(x)->ss.ctr)))
    79 #define xpXER(x) (UC_MCONTEXT(x)->ss.xer)
    80 #define xpCCR(x) (UC_MCONTEXT(x)->ss.cr)
    81 #define xpMSR(x) (UC_MCONTEXT(x)->ss.srr1)
    82 #define xpDSISR(x) (UC_MCONTEXT(x)->es.dsisr)
    83 #define xpDAR(x) (UC_MCONTEXT(x)->es.dar)
    84 #define xpTRAP(x) (UC_MCONTEXT(x)->es.exception)
    85 #define xpFPSCR(x) (UC_MCONTEXT(x)->fs.fpscr)
    86 #define xpFPRvector(x) (UC_MCONTEXT(x)->fs.fpregs)
     77#define xpLR(x) (*((pc*)(&(UC_MCONTEXT(x)->__ss.__lr))))
     78#define xpCTR(x) (*(pc*)(&(UC_MCONTEXT(x)->__ss.__ctr)))
     79#define xpXER(x) (UC_MCONTEXT(x)->__ss.__xer)
     80#define xpCCR(x) (UC_MCONTEXT(x)->__ss.__cr)
     81#define xpMSR(x) (UC_MCONTEXT(x)->__ss.__srr1)
     82#define xpDSISR(x) (UC_MCONTEXT(x)->__es.__dsisr)
     83#define xpDAR(x) (UC_MCONTEXT(x)->__es.__dar)
     84#define xpTRAP(x) (UC_MCONTEXT(x)->__es.__exception)
     85#define xpFPSCR(x) (UC_MCONTEXT(x)->__fs.__fpscr)
     86#define xpFPRvector(x) (UC_MCONTEXT(x)->__fs.__fpregs)
    8787#define xpFPR(x,fprno) (xpFPRvector(x)[fprno])
    8888/* There's a bug in some versions of Darwin on G5 processors: FP context
     
    128128#define DarwinSigReturn(x)
    129129#else
    130 #define DarwinSigReturn(x) (UC_MCONTEXT(x)->ss.xer)^=0x80
     130#define DarwinSigReturn(x) (UC_MCONTEXT(x)->__ss.__xer)^=0x80
    131131#endif
    132132#define SIGRETURN(context) DarwinSigReturn(context)
  • branches/working-0711/ccl/lisp-kernel/x86-exceptions.h

    r13070 r13303  
    187187#ifdef DARWIN
    188188#define SIGNUM_FOR_INTN_TRAP SIGSEGV /* Not really, but our Mach handler fakes that */
    189 #define IS_MAYBE_INT_TRAP(info,xp) ((UC_MCONTEXT(xp)->__es.trapno == 0xd) && (((UC_MCONTEXT(xp)->__es.err)&7)==2))
    190 #define IS_PAGE_FAULT(info,xp) (UC_MCONTEXT(xp)->__es.trapno == 0xe)
     189#define IS_MAYBE_INT_TRAP(info,xp) ((UC_MCONTEXT(xp)->__es.__trapno == 0xd) && (((UC_MCONTEXT(xp)->__es.__err)&7)==2))
     190#define IS_PAGE_FAULT(info,xp) (UC_MCONTEXT(xp)->__es.__trapno == 0xe)
    191191/* The x86 version of sigreturn just needs the context argument; the
    192192   hidden, magic "flavor" argument that sigtramp uses is ignored. */
Note: See TracChangeset for help on using the changeset viewer.