From aa96ed2c3a137c91d1dc5b093c216dab9098f684 Mon Sep 17 00:00:00 2001
From: Raymond Toy <rtoy@google.com>
Date: Wed, 4 Jan 2012 09:19:58 -0800
Subject: [PATCH] Get rid of more compiler warnings on Linux by making
 HANDLER_ARGS match the sa_sigaction argument types.  Adjust code
 appropriately to use os_context_t appropriately too.

---
 src/lisp/Linux-os.c  | 15 ++++++++-------
 src/lisp/Linux-os.h  |  2 +-
 src/lisp/interrupt.c | 10 +++++-----
 src/lisp/x86-arch.c  | 46 ++++++++++++++++++++++----------------------
 4 files changed, 37 insertions(+), 36 deletions(-)

diff --git a/src/lisp/Linux-os.c b/src/lisp/Linux-os.c
index 20731e25d..6c8f10f16 100644
--- a/src/lisp/Linux-os.c
+++ b/src/lisp/Linux-os.c
@@ -406,18 +406,19 @@ sigsegv_handler_tramp(void)
 void
 sigsegv_handler(HANDLER_ARGS)
 {
-    int fault_addr = context->uc_mcontext.cr2;
+    os_context_t *os_context = (os_context_t *) context;
+    int fault_addr = os_context->uc_mcontext.cr2;
 
 #ifdef RED_ZONE_HIT
-    if (os_control_stack_overflow((void *) fault_addr, context))
+    if (os_control_stack_overflow((void *) fault_addr, os_context))
 	return;
 #endif
     if (gc_write_barrier(code->si_addr))
 	return;
 #if defined(__x86_64)
-    DPRINTF(0, (stderr, "sigsegv: rip: %p\n", context->uc_mcontext.gregs[REG_RIP]));
+    DPRINTF(0, (stderr, "sigsegv: rip: %p\n", os_context->uc_mcontext.gregs[REG_RIP]));
 #else
-    DPRINTF(0, (stderr, "sigsegv: eip: %x\n", context->uc_mcontext.gregs[REG_EIP]));
+    DPRINTF(0, (stderr, "sigsegv: eip: %x\n", os_context->uc_mcontext.gregs[REG_EIP]));
 #endif
 
 #ifdef RED_ZONE_HIT
@@ -427,13 +428,13 @@ sigsegv_handler(HANDLER_ARGS)
 	   to the other stack. */
 	tramp_signal = signal;
 	tramp_code = *code;
-	tramp_context = *context;
-	SC_PC(context) = (unsigned long) sigsegv_handler_tramp;
+	tramp_context = *os_context;
+	SC_PC(os_context) = (unsigned long) sigsegv_handler_tramp;
 	return;
     }
 #endif
 
-    sigsegv_handle_now(signal, code, context);
+    sigsegv_handle_now(signal, code, os_context);
 }
 #else
 static void
diff --git a/src/lisp/Linux-os.h b/src/lisp/Linux-os.h
index 06acf3b8b..b00e454c1 100644
--- a/src/lisp/Linux-os.h
+++ b/src/lisp/Linux-os.h
@@ -44,7 +44,7 @@ typedef int os_vm_prot_t;	/* like hpux */
 
 void restore_fpu(ucontext_t *);
 
-#define HANDLER_ARGS int signal, siginfo_t *code, ucontext_t *context
+#define HANDLER_ARGS int signal, siginfo_t *code, void *context
 #define CODE(code) ((code) ? code->si_code : 0)
 #define RESTORE_FPU(context) restore_fpu(context)
 
diff --git a/src/lisp/interrupt.c b/src/lisp/interrupt.c
index 39a2d87ff..de17cee10 100644
--- a/src/lisp/interrupt.c
+++ b/src/lisp/interrupt.c
@@ -406,7 +406,7 @@ interrupt_install_low_level_handler(int signal, void handler(HANDLER_ARGS))
 {
     struct sigaction sa;
 
-    sa.sa_sigaction = handler;
+    sa.sa_sigaction = (void (*)(HANDLER_ARGS)) handler;
     sigemptyset(&sa.sa_mask);
     FILLBLOCKSET(&sa.sa_mask);
     sa.sa_flags = SA_RESTART | SA_SIGINFO;
@@ -461,12 +461,12 @@ install_handler(int signal, void handler(HANDLER_ARGS))
     if (interrupt_low_level_handlers[signal] == 0) {
 	if (handler == (void (*)(HANDLER_ARGS)) SIG_DFL
 	    || handler == (void (*)(HANDLER_ARGS)) SIG_IGN)
-	    sa.sa_sigaction = handler;
+            sa.sa_sigaction = (void (*)(HANDLER_ARGS)) handler;
 	else if (sigismember(&new, signal))
-	    sa.sa_sigaction = maybe_now_maybe_later;
+	    sa.sa_sigaction = (void (*)(HANDLER_ARGS)) maybe_now_maybe_later;
 	else
-	    sa.sa_sigaction = interrupt_handle_now_handler;
-
+	    sa.sa_sigaction = (void (*)(HANDLER_ARGS)) interrupt_handle_now_handler;
+        
 	sigemptyset(&sa.sa_mask);
 	FILLBLOCKSET(&sa.sa_mask);
 	sa.sa_flags = SA_SIGINFO | SA_RESTART;
diff --git a/src/lisp/x86-arch.c b/src/lisp/x86-arch.c
index 474fb875b..2932b135f 100644
--- a/src/lisp/x86-arch.c
+++ b/src/lisp/x86-arch.c
@@ -278,11 +278,11 @@ void
 sigtrap_handler(HANDLER_ARGS)
 {
     unsigned int trap;
-
+    os_context_t* os_context = (os_context_t *) context;
 #if 0
     fprintf(stderr, "x86sigtrap: %8x %x\n",
-            SC_PC(context), *(unsigned char *) (SC_PC(context) - 1));
-    fprintf(stderr, "sigtrap(%d %d %x)\n", signal, CODE(code), context);
+            SC_PC(os_os_context), *(unsigned char *) (SC_PC(os_context) - 1));
+    fprintf(stderr, "sigtrap(%d %d %x)\n", signal, CODE(code), os_context);
 #endif
 
     if (single_stepping && (signal == SIGTRAP)) {
@@ -292,7 +292,7 @@ sigtrap_handler(HANDLER_ARGS)
 
 #ifdef SC_EFLAGS
 	/* Disable single-stepping */
-	SC_EFLAGS(context) ^= 0x100;
+	SC_EFLAGS(os_context) ^= 0x100;
 #else
 	/* Un-install single step helper instructions. */
 	*(single_stepping - 3) = single_step_save1;
@@ -304,7 +304,7 @@ sigtrap_handler(HANDLER_ARGS)
 	/*
 	 * Re-install the breakpoint if possible.
 	 */
-	if ((int) SC_PC(context) == (int) single_stepping + 1)
+	if ((int) SC_PC(os_context) == (int) single_stepping + 1)
 	    fprintf(stderr, "* Breakpoint not re-install\n");
 	else {
 	    char *ptr = (char *) single_stepping;
@@ -318,9 +318,9 @@ sigtrap_handler(HANDLER_ARGS)
     }
 
     /* This is just for info in case monitor wants to print an approx */
-    current_control_stack_pointer = (unsigned long *) SC_SP(context);
+    current_control_stack_pointer = (unsigned long *) SC_SP(os_context);
 
-    RESTORE_FPU(context);
+    RESTORE_FPU(os_context);
 
     /*
      * On entry %eip points just after the INT3 byte and aims at the
@@ -329,13 +329,13 @@ sigtrap_handler(HANDLER_ARGS)
      * arguments to follow.
      */
 
-    trap = *(unsigned char *) SC_PC(context);
+    trap = *(unsigned char *) SC_PC(os_context);
 
     switch (trap) {
       case trap_PendingInterrupt:
 	  DPRINTF(0, (stderr, "<trap Pending Interrupt.>\n"));
-	  arch_skip_instruction(context);
-	  interrupt_handle_pending(context);
+	  arch_skip_instruction(os_context);
+	  interrupt_handle_pending(os_context);
 	  break;
 
       case trap_Halt:
@@ -345,59 +345,59 @@ sigtrap_handler(HANDLER_ARGS)
 
 	      fpu_save(fpu_state);
 #endif
-	      fake_foreign_function_call(context);
+	      fake_foreign_function_call(os_context);
 	      lose("%%primitive halt called; the party is over.\n");
-	      undo_fake_foreign_function_call(context);
+	      undo_fake_foreign_function_call(os_context);
 #ifndef __linux__
 	      fpu_restore(fpu_state);
 #endif
-	      arch_skip_instruction(context);
+	      arch_skip_instruction(os_context);
 	      break;
 	  }
 
       case trap_Error:
       case trap_Cerror:
 	  DPRINTF(0, (stderr, "<trap Error %x>\n", CODE(code)));
-	  interrupt_internal_error(signal, code, context, CODE(code) == trap_Cerror);
+	  interrupt_internal_error(signal, code, os_context, CODE(code) == trap_Cerror);
 	  break;
 
       case trap_Breakpoint:
 #if 0
 	  fprintf(stderr, "*C break\n");
 #endif
-	  SC_PC(context) -= 1;
+	  SC_PC(os_context) -= 1;
 
-	  handle_breakpoint(signal, CODE(code), context);
+	  handle_breakpoint(signal, CODE(code), os_context);
 #if 0
 	  fprintf(stderr, "*C break return\n");
 #endif
 	  break;
 
       case trap_FunctionEndBreakpoint:
-	  SC_PC(context) -= 1;
-	  SC_PC(context) =
-	      (int) handle_function_end_breakpoint(signal, CODE(code), context);
+	  SC_PC(os_context) -= 1;
+	  SC_PC(os_context) =
+	      (int) handle_function_end_breakpoint(signal, CODE(code), os_context);
 	  break;
 
 #ifdef trap_DynamicSpaceOverflowWarning
       case trap_DynamicSpaceOverflowWarning:
 	  interrupt_handle_space_overflow(SymbolFunction
 					  (DYNAMIC_SPACE_OVERFLOW_WARNING_HIT),
-					  context);
+					  os_context);
 	  break;
 #endif
 #ifdef trap_DynamicSpaceOverflowError
       case trap_DynamicSpaceOverflowError:
 	  interrupt_handle_space_overflow(SymbolFunction
 					  (DYNAMIC_SPACE_OVERFLOW_ERROR_HIT),
-					  context);
+					  os_context);
 	  break;
 #endif
       default:
 	  DPRINTF(0,
 		  (stderr, "[C--trap default %d %d %p]\n", signal, CODE(code),
-		   context));
-	  interrupt_handle_now(signal, code, context);
+		   os_context));
+	  interrupt_handle_now(signal, code, os_context);
 	  break;
     }
 }
-- 
GitLab