Changeset 16133


Ignore:
Timestamp:
Jul 23, 2014, 12:34:16 AM (7 years ago)
Author:
rme
Message:

Use the exception interface provided in mach/mach_exc.defs.

Unlike exc_server/catch_exception_raise/etc., which are in the system
library, to use the mach_exc_server/catch_mach_exception_raise/etc.
interface, we must run mig to generate the source files from the
interface definiton. So, update the Darwin makefiles to do that.

I didn't see any reason to keep using the -exported_symbols_list
linker option, so I removed that, too.

The main thing this gets us is 64-bit exception codes. (But we don't
take advantage of this yet.)

Location:
trunk/source/lisp-kernel
Files:
1 added
2 deleted
5 edited

Legend:

Unmodified
Added
Removed
  • trunk/source/lisp-kernel/darwinx8632

    • Property svn:ignore
      •  

        old new  
        11probes.h
         2mach_exc.h
         3mach_exc_server.c
  • trunk/source/lisp-kernel/darwinx8632/Makefile

    r16114 r16133  
    2525RM = /bin/rm
    2626LD = ld
    27 LDFLAGS =  -macosx_version_min $(OSVERSION) -arch i386 -dynamic  -o $@ -e start -pagezero_size 0x11000 -seg1addr 0x00011000 -sectalign __TEXT __text 0x1000 \
    28  -exported_symbols_list exports
     27LDFLAGS =  -macosx_version_min $(OSVERSION) -arch i386 -dynamic  -o $@ -e start -pagezero_size 0x11000 -seg1addr 0x00011000 -sectalign __TEXT __text 0x1000
    2928AS = as
    3029M4 = gm4
     
    5655
    5756DEBUGOBJ = lispdcmd.o plprint.o plsym.o x86_print.o xlbt.o
    58 KERNELOBJ= imports.o $(COBJ) x86-asmutils32.o
     57KERNELOBJ= imports.o $(COBJ) x86-asmutils32.o mach_exc_server.o
    5958
    6059SPINC = lisp.s m4macros.m4 x86-constants.s x86-macros.s errors.s x86-uuo.s x86-constants32.s lisp_globals.s
     
    10099thread_manager.o: thread_manager.c
    101100
     101mach_exc_server.o: mach_exc_server.c mach_exc.h
     102
     103mach_exc.h mach_exc_server.c: mach_exc.defs
     104        mig -arch i386 -header /dev/null -user /dev/null \
     105                -sheader mach_exc.h -server mach_exc_server.c \
     106                 $<
     107
    102108cclean:
    103109        $(RM) -f $(KERNELOBJ) $(DEBUGOBJ) ../../dx86cl
  • trunk/source/lisp-kernel/darwinx8664

    • Property svn:ignore
      •  

        old new  
        11probes.h
         2mach_exc.h
         3mach_exc_server.c
  • trunk/source/lisp-kernel/darwinx8664/Makefile

    r16114 r16133  
    3030### Gosh.  I always thought that it was.  Go know, right ?
    3131LDFLAGS = -macosx_version_min $(OSVERSION) -arch x86_64 -dynamic \
    32           -o $@ -e start -pagezero_size 0x11000 -seg1addr 0x00011000 \
    33           -exported_symbols_list exports
     32          -o $@ -e start -pagezero_size 0x11000 -seg1addr 0x00011000
    3433
    3534AS = as
     
    5554           -D_DARWIN_NO_64_BIT_INODE -DUSE_DTRACE
    5655CDEBUG = -g
    57 COPT = -O2
     56COPT = -O0
    5857# Once in a while, -Wformat says something useful.  The odds are against that,
    5958# however.
     
    7776
    7877DEBUGOBJ = lispdcmd.o plprint.o plsym.o xlbt.o x86_print.o
    79 KERNELOBJ= imports.o $(COBJ) x86-asmutils64.o
     78KERNELOBJ= imports.o $(COBJ) x86-asmutils64.o mach_exc_server.o
    8079
    8180SPINC = lisp.s m4macros.m4 x86-constants.s x86-macros.s errors.s x86-uuo.s \
     
    115114thread_manager.o: thread_manager.c
    116115
     116mach_exc_server.o: mach_exc_server.c mach_exc.h
     117
     118mach_exc.h mach_exc_server.c: mach_exc.defs
     119        mig -arch x86_64 -header /dev/null -user /dev/null \
     120                -sheader mach_exc.h -server mach_exc_server.c \
     121                 $<
     122
    117123cclean:
    118124        $(RM) -f $(KERNELOBJ) $(DEBUGOBJ) ../../dx86cl64
  • trunk/source/lisp-kernel/x86-exceptions.c

    r16115 r16133  
    33423342
    33433343kern_return_t
    3344 catch_exception_raise_state(mach_port_t exception_port,
    3345                             exception_type_t exception,
    3346                             exception_data_t code_vector,
    3347                             mach_msg_type_number_t code_count,
    3348                             int * flavor,
    3349                             thread_state_t in_state,
    3350                             mach_msg_type_number_t in_state_count,
    3351                             thread_state_t out_state,
    3352                             mach_msg_type_number_t * out_state_count)
    3353 {
    3354   int signum = 0, code = *code_vector;
     3344catch_mach_exception_raise(mach_port_t exception_port,
     3345                           mach_port_t thread,
     3346                           mach_port_t task,
     3347                           exception_type_t exception,
     3348                           mach_exception_data_t code,
     3349                           mach_msg_type_number_t code_count)
     3350{
     3351  abort();
     3352  return KERN_FAILURE;
     3353}
     3354
     3355kern_return_t
     3356catch_mach_exception_raise_state(mach_port_t exception_port,
     3357                                 exception_type_t exception,
     3358                                 mach_exception_data_t code,
     3359                                 mach_msg_type_number_t code_count,
     3360                                 int *flavor,
     3361                                 thread_state_t in_state,
     3362                                 mach_msg_type_number_t in_state_count,
     3363                                 thread_state_t out_state,
     3364                                 mach_msg_type_number_t *out_state_count)
     3365{
     3366  int64_t code0 = code[0];
     3367  int signum = 0;
    33553368  TCR *tcr = TCR_FROM_EXCEPTION_PORT(exception_port);
    33563369  mach_port_t thread = (mach_port_t)((natural)tcr->native_thread_id);
     
    33623375  mach_msg_type_number_t thread_state_count;
    33633376
    3364 
    3365 
    3366   if (1) {
    3367     if (tcr->flags & (1<<TCR_FLAG_BIT_PENDING_EXCEPTION)) {
    3368       CLR_TCR_FLAG(tcr,TCR_FLAG_BIT_PENDING_EXCEPTION);
    3369     }
    3370     if ((code == EXC_I386_GPFLT) &&
    3371         ((natural)(ts_pc(ts)) == (natural)pseudo_sigreturn)) {
    3372       kret = do_pseudo_sigreturn(thread, tcr, out_ts);
     3377  if (tcr->flags & (1<<TCR_FLAG_BIT_PENDING_EXCEPTION)) {
     3378    CLR_TCR_FLAG(tcr,TCR_FLAG_BIT_PENDING_EXCEPTION);
     3379  }
     3380  if ((code0 == EXC_I386_GPFLT) &&
     3381      ((natural)(ts_pc(ts)) == (natural)pseudo_sigreturn)) {
     3382    kret = do_pseudo_sigreturn(thread, tcr, out_ts);
    33733383#if 0
    3374       fprintf(dbgout, "Exception return in 0x%x\n",tcr);
    3375 #endif
    3376     } else if (tcr->flags & (1<<TCR_FLAG_BIT_PROPAGATE_EXCEPTION)) {
    3377       CLR_TCR_FLAG(tcr,TCR_FLAG_BIT_PROPAGATE_EXCEPTION);
     3384    fprintf(dbgout, "Exception return in 0x%x\n",tcr);
     3385#endif
     3386  } else if (tcr->flags & (1<<TCR_FLAG_BIT_PROPAGATE_EXCEPTION)) {
     3387    CLR_TCR_FLAG(tcr,TCR_FLAG_BIT_PROPAGATE_EXCEPTION);
     3388    kret = 17;
     3389  } else {
     3390    switch (exception) {
     3391    case EXC_BAD_ACCESS:
     3392      if (code0 == EXC_I386_GPFLT) {
     3393        signum = SIGSEGV;
     3394      } else {
     3395        signum = SIGBUS;
     3396      }
     3397      break;
     3398     
     3399    case EXC_BAD_INSTRUCTION:
     3400      if (code0 == EXC_I386_GPFLT) {
     3401        signum = SIGSEGV;
     3402      } else {
     3403        signum = SIGILL;
     3404      }
     3405      break;
     3406     
     3407    case EXC_SOFTWARE:
     3408      signum = SIGILL;
     3409      break;
     3410     
     3411    case EXC_ARITHMETIC:
     3412      signum = SIGFPE;
     3413      if (code0 == EXC_I386_DIV)
     3414        code0 = FPE_INTDIV;
     3415      break;
     3416     
     3417    default:
     3418      break;
     3419    }
     3420#if WORD_SIZE==64
     3421    if ((signum==SIGFPE) &&
     3422        (code0 != FPE_INTDIV) &&
     3423        (tcr->valence != TCR_STATE_LISP)) {
     3424      mach_msg_type_number_t thread_state_count = x86_FLOAT_STATE64_COUNT;
     3425      x86_float_state64_t fs;
     3426     
     3427      thread_get_state(thread,
     3428                       x86_FLOAT_STATE64,
     3429                       (thread_state_t)&fs,
     3430                       &thread_state_count);
     3431     
     3432      if (! (tcr->flags & (1<<TCR_FLAG_BIT_FOREIGN_FPE))) {
     3433        tcr->flags |= (1<<TCR_FLAG_BIT_FOREIGN_FPE);
     3434        tcr->lisp_mxcsr = (fs.__fpu_mxcsr & ~MXCSR_STATUS_MASK);
     3435      }
     3436      fs.__fpu_mxcsr &= ~MXCSR_STATUS_MASK;
     3437      fs.__fpu_mxcsr |= MXCSR_CONTROL_MASK;
     3438      thread_set_state(thread,
     3439                       x86_FLOAT_STATE64,
     3440                       (thread_state_t)&fs,
     3441                       x86_FLOAT_STATE64_COUNT);
     3442      *out_state_count = NATIVE_THREAD_STATE_COUNT;
     3443      *out_ts = *ts;
     3444      return KERN_SUCCESS;
     3445    }
     3446#endif
     3447    if (signum) {
     3448      kret = setup_signal_frame(thread,
     3449                                (void *)DARWIN_EXCEPTION_HANDLER,
     3450                                signum,
     3451                                code0,
     3452                                tcr,
     3453                                ts,
     3454                                out_ts);
     3455     
     3456    } else {
    33783457      kret = 17;
    3379     } else {
    3380       switch (exception) {
    3381       case EXC_BAD_ACCESS:
    3382         if (code == EXC_I386_GPFLT) {
    3383           signum = SIGSEGV;
    3384         } else {
    3385           signum = SIGBUS;
    3386         }
    3387         break;
    3388        
    3389       case EXC_BAD_INSTRUCTION:
    3390         if (code == EXC_I386_GPFLT) {
    3391           signum = SIGSEGV;
    3392         } else {
    3393           signum = SIGILL;
    3394         }
    3395         break;
    3396          
    3397       case EXC_SOFTWARE:
    3398         signum = SIGILL;
    3399         break;
    3400        
    3401       case EXC_ARITHMETIC:
    3402         signum = SIGFPE;
    3403         if (code == EXC_I386_DIV)
    3404           code = FPE_INTDIV;
    3405         break;
    3406        
    3407       default:
    3408         break;
    3409       }
    3410 #if WORD_SIZE==64
    3411       if ((signum==SIGFPE) &&
    3412           (code != FPE_INTDIV) &&
    3413           (tcr->valence != TCR_STATE_LISP)) {
    3414         mach_msg_type_number_t thread_state_count = x86_FLOAT_STATE64_COUNT;
    3415         x86_float_state64_t fs;
    3416 
    3417         thread_get_state(thread,
    3418                          x86_FLOAT_STATE64,
    3419                          (thread_state_t)&fs,
    3420                          &thread_state_count);
    3421        
    3422         if (! (tcr->flags & (1<<TCR_FLAG_BIT_FOREIGN_FPE))) {
    3423           tcr->flags |= (1<<TCR_FLAG_BIT_FOREIGN_FPE);
    3424           tcr->lisp_mxcsr = (fs.__fpu_mxcsr & ~MXCSR_STATUS_MASK);
    3425         }
    3426         fs.__fpu_mxcsr &= ~MXCSR_STATUS_MASK;
    3427         fs.__fpu_mxcsr |= MXCSR_CONTROL_MASK;
    3428         thread_set_state(thread,
    3429                          x86_FLOAT_STATE64,
    3430                          (thread_state_t)&fs,
    3431                          x86_FLOAT_STATE64_COUNT);
    3432         *out_state_count = NATIVE_THREAD_STATE_COUNT;
    3433         *out_ts = *ts;
    3434         return KERN_SUCCESS;
    3435       }
    3436 #endif
    3437       if (signum) {
    3438         kret = setup_signal_frame(thread,
    3439                                   (void *)DARWIN_EXCEPTION_HANDLER,
    3440                                   signum,
    3441                                   code,
    3442                                   tcr,
    3443                                   ts,
    3444                                   out_ts);
    3445        
    3446       } else {
    3447         kret = 17;
    3448       }
    3449     }
    3450   }
     3458    }
     3459  }
     3460 
    34513461  if (kret) {
    34523462    *out_state_count = 0;
     
    34583468}
    34593469
     3470kern_return_t
     3471catch_mach_exception_raise_state_identity(mach_port_t exception_port,
     3472                                          mach_port_t thread,
     3473                                          mach_port_t task,
     3474                                          exception_type_t exception,
     3475                                          mach_exception_data_t code,
     3476                                          mach_msg_type_number_t code_count,
     3477                                          int *flavor,
     3478                                          thread_state_t old_state,
     3479                                          mach_msg_type_number_t old_count,
     3480                                          thread_state_t new_state,
     3481                                          mach_msg_type_number_t *new_count)
     3482{
     3483  abort();
     3484  return KERN_FAILURE;
     3485}
     3486
     3487
    34603488
    34613489
     
    34713499exception_handler_proc(void *arg)
    34723500{
    3473   extern boolean_t exc_server();
     3501  extern boolean_t mach_exc_server();
    34743502  mach_port_t p = (mach_port_t)((natural)arg);
    34753503
    34763504  mach_exception_thread = pthread_mach_thread_np(pthread_self());
    3477   mach_msg_server(exc_server, 256, p, 0);
     3505  mach_msg_server(mach_exc_server, 256, p, 0);
    34783506  /* Should never return. */
    34793507  abort();
     
    35493577                                     LISP_EXCEPTIONS_HANDLED_MASK,
    35503578                                     lisp_port,
    3551                                      EXCEPTION_STATE,
     3579                                     MACH_EXCEPTION_CODES | EXCEPTION_STATE,
    35523580#if WORD_SIZE==64
    35533581                                     x86_THREAD_STATE64,
Note: See TracChangeset for help on using the changeset viewer.