[cmucl-commit] [git] CMU Common Lisp branch master updated. snapshot-2011-12-34-gcba6f60

Raymond Toy rtoy at common-lisp.net
Sat Jan 7 03:29:20 UTC 2012


This is an automated email from the git hooks/post-receive script. It was
generated because a ref change was pushed to the repository containing
the project "CMU Common Lisp".

The branch, master has been updated
       via  cba6f60b2f9b38ed9d7beff3666a9b0a4afcca46 (commit)
      from  b57f6029c505b50eb9bfa97784627076ed4242f6 (commit)

Those revisions listed above that are new to this repository have
not appeared on any other notification email; so we list those
revisions in full, below.

- Log -----------------------------------------------------------------
commit cba6f60b2f9b38ed9d7beff3666a9b0a4afcca46
Author: Raymond Toy <toy.raymond at gmail.com>
Date:   Fri Jan 6 19:29:01 2012 -0800

    Fix some compiler warnings on sparc about sigcontexts.
    
    sunos-os.h:
    o Update HANDLER_ARGS to match definition used in sigaction.
    o Define os_context_t
    
    lisp.c:
    solaris-os.c:
    sparc-arch.c:
    o Use os_context_t as needed.

diff --git a/src/lisp/lisp.c b/src/lisp/lisp.c
index 2eb000f..c489cb0 100644
--- a/src/lisp/lisp.c
+++ b/src/lisp/lisp.c
@@ -51,9 +51,11 @@
 static void
 sigint_handler(HANDLER_ARGS)
 {
+    os_context_t *os_context = (os_context_t *) context;
+    
     SAVE_CONTEXT();
 
-    printf("\nSIGINT hit at 0x%08lX\n", (unsigned long) SC_PC(context));
+    printf("\nSIGINT hit at 0x%08lX\n", (unsigned long) SC_PC(os_context));
     ldb_monitor();
 }
 
diff --git a/src/lisp/solaris-os.c b/src/lisp/solaris-os.c
index fa1a45e..b0dfc4c 100644
--- a/src/lisp/solaris-os.c
+++ b/src/lisp/solaris-os.c
@@ -225,6 +225,8 @@ void real_segv_handler(HANDLER_ARGS)
 void
 segv_handler(HANDLER_ARGS)
 {
+    os_context_t *os_context = (os_context_t *) context;
+    
     caddr_t addr = code->si_addr;
 
     SAVE_CONTEXT();
@@ -275,7 +277,7 @@ segv_handler(HANDLER_ARGS)
     /* a *real* protection fault */
     fprintf(stderr, "segv_handler: Real protection violation: %p, PC = %p\n",
             addr,
-            context->uc_mcontext.gregs[1]);
+            os_context->uc_mcontext.gregs[1]);
     real_segv_handler(signal, code, context);
 }
 #else
diff --git a/src/lisp/sparc-arch.c b/src/lisp/sparc-arch.c
index 0d98599..5027179 100644
--- a/src/lisp/sparc-arch.c
+++ b/src/lisp/sparc-arch.c
@@ -38,19 +38,20 @@ arch_get_bad_addr(HANDLER_ARGS)
 {
     unsigned int badinst;
     int rs1;
-
+    os_context_t *os_context = (os_context_t *) context;
+    
     /* On the sparc, we have to decode the instruction. */
 
     /* Make sure it's not the pc thats bogus, and that it was lisp code */
     /* that caused the fault. */
-    if ((SC_PC(context) & 3) != 0 ||
-	((SC_PC(context) < READ_ONLY_SPACE_START ||
-	  SC_PC(context) >= READ_ONLY_SPACE_START + read_only_space_size) &&
-	 ((lispobj *) SC_PC(context) < current_dynamic_space &&
-	  (lispobj *) SC_PC(context) >=
+    if ((SC_PC(os_context) & 3) != 0 ||
+	((SC_PC(os_context) < READ_ONLY_SPACE_START ||
+	  SC_PC(os_context) >= READ_ONLY_SPACE_START + read_only_space_size) &&
+	 ((lispobj *) SC_PC(os_context) < current_dynamic_space &&
+	  (lispobj *) SC_PC(os_context) >=
 	  current_dynamic_space + dynamic_space_size))) return 0;
 
-    badinst = *(unsigned int *) SC_PC(context);
+    badinst = *(unsigned int *) SC_PC(os_context);
 
     if ((badinst >> 30) != 3)
 	/* All load/store instructions have op = 11 (binary) */
@@ -65,19 +66,18 @@ arch_get_bad_addr(HANDLER_ARGS)
 	if (simm13 & (1 << 12))
 	    simm13 |= -1 << 13;
 
-	return (os_vm_address_t) (SC_REG(context, rs1) + simm13);
+	return (os_vm_address_t) (SC_REG(os_context, rs1) + simm13);
     } else {
 	/* r[rs1] + r[rs2] */
 	int rs2 = badinst & 0x1f;
 
-	return (os_vm_address_t) (SC_REG(context, rs1) + SC_REG(context, rs2));
+	return (os_vm_address_t) (SC_REG(os_context, rs1) + SC_REG(os_context, rs2));
     }
 
 }
 
 void
-arch_skip_instruction(context)
-     struct sigcontext *context;
+arch_skip_instruction(os_context_t *context)
 {
     /* Skip the offending instruction */
     SC_PC(context) = SC_NPC(context);
@@ -425,6 +425,8 @@ handle_allocation_trap(struct sigcontext *context)
 static void
 sigill_handler(HANDLER_ARGS)
 {
+    os_context_t *os_context = (os_context_t *) context;
+    
     SAVE_CONTEXT();
 
     /*
@@ -441,13 +443,13 @@ sigill_handler(HANDLER_ARGS)
      * a bad idea to have interrupts enabled here.)
      */
 #if 0
-    sigprocmask(SIG_SETMASK, &context->uc_sigmask, 0);
+    sigprocmask(SIG_SETMASK, &os_context->uc_sigmask, 0);
 #endif
 
     if (CODE(code) == ILLTRAP_INST) {
 	int illtrap_code;
 	unsigned int inst;
-	unsigned int *pc = (unsigned int *) (SC_PC(context));
+	unsigned int *pc = (unsigned int *) (SC_PC(os_context));
 
 	inst = *pc;
 
@@ -455,88 +457,88 @@ sigill_handler(HANDLER_ARGS)
 
 	switch (illtrap_code) {
 	  case trap_PendingInterrupt:
-	      arch_skip_instruction(context);
-	      interrupt_handle_pending(context);
+	      arch_skip_instruction(os_context);
+	      interrupt_handle_pending(os_context);
 	      break;
 
 	  case trap_Halt:
-	      fake_foreign_function_call(context);
+	      fake_foreign_function_call(os_context);
 	      lose("%%primitive halt called; the party is over.\n");
 
 	  case trap_Error:
 	  case trap_Cerror:
-	      interrupt_internal_error(signal, code, context,
+	      interrupt_internal_error(signal, code, os_context,
 				       illtrap_code == trap_Cerror);
 	      break;
 
 	  case trap_Breakpoint:
 	      enable_some_signals();
-	      handle_breakpoint(signal, CODE(code), context);
+	      handle_breakpoint(signal, CODE(code), os_context);
 	      break;
 
 	  case trap_FunctionEndBreakpoint:
 	      enable_some_signals();
-	      SC_PC(context) =
+	      SC_PC(os_context) =
 		  (long) handle_function_end_breakpoint(signal, CODE(code),
-							context);
-	      SC_NPC(context) = SC_PC(context) + 4;
+							os_context);
+	      SC_NPC(os_context) = SC_PC(os_context) + 4;
 	      break;
 
 	  case trap_AfterBreakpoint:
 	      *skipped_break_addr = trap_Breakpoint;
 	      skipped_break_addr = NULL;
-	      *(unsigned long *) SC_PC(context) = displaced_after_inst;
-	      context->uc_sigmask = orig_sigmask;
-	      os_flush_icache((os_vm_address_t) SC_PC(context),
+	      *(unsigned long *) SC_PC(os_context) = displaced_after_inst;
+	      os_context->uc_sigmask = orig_sigmask;
+	      os_flush_icache((os_vm_address_t) SC_PC(os_context),
 
 			      sizeof(unsigned long));
 	      break;
 
 #ifdef trap_DynamicSpaceOverflowWarning
 	  case trap_DynamicSpaceOverflowWarning:
-	      arch_skip_instruction(context);
+	      arch_skip_instruction(os_context);
 	      enable_some_signals();
 	      interrupt_handle_space_overflow(SymbolFunction
 					      (DYNAMIC_SPACE_OVERFLOW_WARNING_HIT),
-					      context);
+					      os_context);
 	      break;
 #endif
 #ifdef trap_DynamicSpaceOverflowError
 	  case trap_DynamicSpaceOverflowError:
-	      arch_skip_instruction(context);
+	      arch_skip_instruction(os_context);
 	      enable_some_signals();
 	      interrupt_handle_space_overflow(SymbolFunction
 					      (DYNAMIC_SPACE_OVERFLOW_ERROR_HIT),
-					      context);
+					      os_context);
 	      break;
 #endif
 	  default:
-	      interrupt_handle_now(signal, code, context);
+	      interrupt_handle_now(signal, code, os_context);
 	      break;
 	}
     } else if (TRAP_INST(code)) {
-	if (pseudo_atomic_trap_p(context)) {
+	if (pseudo_atomic_trap_p(os_context)) {
 	    /* A trap instruction from a pseudo-atomic.  We just need
 	       to fixup up alloc-tn to remove the interrupted flag,
 	       skip over the trap instruction, and then handle the
 	       pending interrupt(s). */
-	    SC_REG(context, reg_ALLOC) &= ~lowtag_Mask;
-	    arch_skip_instruction(context);
-	    interrupt_handle_pending(context);
+	    SC_REG(os_context, reg_ALLOC) &= ~lowtag_Mask;
+	    arch_skip_instruction(os_context);
+	    interrupt_handle_pending(os_context);
 	}
 #ifdef GENCGC
-	else if (allocation_trap_p(context)) {
+	else if (allocation_trap_p(os_context)) {
 	    /* An allocation trap. Call the trap handler and then skip
 	       this instruction */
-	    handle_allocation_trap(context);
-	    arch_skip_instruction(context);
+	    handle_allocation_trap(os_context);
+	    arch_skip_instruction(os_context);
 	}
 #endif
 	else {
-	    interrupt_internal_error(signal, code, context, FALSE);
+	    interrupt_internal_error(signal, code, os_context, FALSE);
 	}
     } else {
-	interrupt_handle_now(signal, code, context);
+	interrupt_handle_now(signal, code, os_context);
     }
 }
 
diff --git a/src/lisp/sunos-os.h b/src/lisp/sunos-os.h
index 3e06777..4f59a1a 100644
--- a/src/lisp/sunos-os.h
+++ b/src/lisp/sunos-os.h
@@ -50,8 +50,10 @@ typedef int os_vm_prot_t;
 
 #ifdef SOLARIS
 #include <ucontext.h>
-#define HANDLER_ARGS int signal, siginfo_t *code, struct ucontext *context
+#define HANDLER_ARGS int signal, siginfo_t *code, void *context
 #define CODE(code)  ((code) ? code->si_code : 0)
+typedef struct ucontext os_context_t__;
+#define os_context_t os_context_t__
 #ifndef i386
 #define SAVE_CONTEXT() save_context()
 #endif

-----------------------------------------------------------------------

Summary of changes:
 src/lisp/lisp.c       |    4 ++-
 src/lisp/solaris-os.c |    4 ++-
 src/lisp/sparc-arch.c |   78 +++++++++++++++++++++++++------------------------
 src/lisp/sunos-os.h   |    4 ++-
 4 files changed, 49 insertions(+), 41 deletions(-)


hooks/post-receive
-- 
CMU Common Lisp


More information about the cmucl-commit mailing list