src/runtime/x86-arch.c

   1 /*
   2  * This software is part of the SBCL system. See the README file for
   3  * more information.
   4  *
   5  * This software is derived from the CMU CL system, which was
   6  * written at Carnegie Mellon University and released into the
   7  * public domain. The software is in the public domain and is
   8  * provided with absolutely no warranty. See the COPYING and CREDITS
   9  * files for more information.
  10  */
  11
  12 #include <stdio.h>
  13
  14 #include "sbcl.h"
  15 #include "runtime.h"
  16 #include "globals.h"
  17 #include "validate.h"
  18 #include "os.h"
  19 #include "arch.h"
  20 #include "lispregs.h"
  21 #include "signal.h"
  22 #include "alloc.h"
  23 #include "interrupt.h"
  24 #include "interr.h"
  25 #include "breakpoint.h"
  26 #include "thread.h"
  27 #include "pseudo-atomic.h"
  28
  29 #include "genesis/static-symbols.h"
  30 #include "genesis/symbol.h"
  31
  32 #define BREAKPOINT_INST 0xcc    /* INT3 */
  33 #define UD2_INST 0x0b0f         /* UD2 */
  34
  35 #ifndef LISP_FEATURE_UD2_BREAKPOINTS
  36 #define BREAKPOINT_WIDTH 1
  37 #else
  38 #define BREAKPOINT_WIDTH 2
  39 #endif
  40
  41 unsigned long fast_random_state = 1;
  42
  43 void arch_init(void)
  44 {}
  45
  46 #ifndef LISP_FEATURE_WIN32
  47 os_vm_address_t
  48 arch_get_bad_addr(int sig, siginfo_t *code, os_context_t *context)
  49 {
  50     return (os_vm_address_t)code->si_addr;
  51 }
  52 #endif
  53
  54 \f
  55 /*
  56  * hacking signal contexts
  57  *
  58  * (This depends both on architecture, which determines what we might
  59  * want to get to, and on OS, which determines how we get to it.)
  60  */
  61
  62 int *
  63 context_eflags_addr(os_context_t *context)
  64 {
  65 #if defined __linux__ || defined __sun
  66     /* KLUDGE: As of kernel 2.2.14 on Red Hat 6.2, there's code in the
  67      * <sys/ucontext.h> file to define symbolic names for offsets into
  68      * gregs[], but it's conditional on __USE_GNU and not defined, so
  69      * we need to do this nasty absolute index magic number thing
  70      * instead. */
  71     return &context->uc_mcontext.gregs[16];
  72 #elif defined __FreeBSD__
  73     return &context->uc_mcontext.mc_eflags;
  74 #elif defined __OpenBSD__
  75     return &context->sc_eflags;
  76 #elif defined LISP_FEATURE_DARWIN
  77     return (int *)(&context->uc_mcontext->SS.EFLAGS);
  78 #elif defined __NetBSD__
  79     return &(context->uc_mcontext.__gregs[_REG_EFL]);
  80 #elif defined LISP_FEATURE_WIN32
  81     return (int *)&context->EFlags;
  82 #else
  83 #error unsupported OS
  84 #endif
  85 }
  86 \f
  87 void arch_skip_instruction(os_context_t *context)
  88 {
  89     /* Assuming we get here via an INT3 xxx instruction, the PC now
  90      * points to the interrupt code (a Lisp value) so we just move
  91      * past it. Skip the code; after that, if the code is an
  92      * error-trap or cerror-trap then skip the data bytes that follow. */
  93
  94     int vlen;
  95     int code;
  96
  97
  98     /* Get and skip the Lisp interrupt code. */
  99     code = *(char*)(*os_context_pc_addr(context))++;
 100     switch (code)
 101         {
 102         case trap_Error:
 103         case trap_Cerror:
 104             /* Lisp error arg vector length */
 105             vlen = *(char*)(*os_context_pc_addr(context))++;
 106             /* Skip Lisp error arg data bytes. */
 107             while (vlen-- > 0) {
 108                 ++*os_context_pc_addr(context);
 109             }
 110             break;
 111
 112         case trap_Breakpoint:           /* not tested */
 113         case trap_FunEndBreakpoint: /* not tested */
 114             break;
 115
 116         case trap_PendingInterrupt:
 117         case trap_Halt:
 118         case trap_SingleStepAround:
 119         case trap_SingleStepBefore:
 120             /* only needed to skip the Code */
 121             break;
 122
 123         default:
 124             fprintf(stderr,"[arch_skip_inst invalid code %d\n]\n",code);
 125             break;
 126         }
 127
 128     FSHOW((stderr,
 129            "/[arch_skip_inst resuming at %x]\n",
 130            *os_context_pc_addr(context)));
 131 }
 132
 133 unsigned char *
 134 arch_internal_error_arguments(os_context_t *context)
 135 {
 136     return 1 + (unsigned char *)(*os_context_pc_addr(context));
 137 }
 138
 139 boolean
 140 arch_pseudo_atomic_atomic(os_context_t *context)
 141 {
 142     return get_pseudo_atomic_atomic(arch_os_get_current_thread());
 143 }
 144
 145 void
 146 arch_set_pseudo_atomic_interrupted(os_context_t *context)
 147 {
 148     struct thread *thread = arch_os_get_current_thread();
 149     set_pseudo_atomic_interrupted(thread);
 150 }
 151
 152 void
 153 arch_clear_pseudo_atomic_interrupted(os_context_t *context)
 154 {
 155     struct thread *thread = arch_os_get_current_thread();
 156     clear_pseudo_atomic_interrupted(thread);
 157 }
 158 \f
 159 /*
 160  * This stuff seems to get called for TRACE and debug activity.
 161  */
 162
 163 unsigned int
 164 arch_install_breakpoint(void *pc)
 165 {
 166     unsigned int result = *(unsigned int*)pc;
 167
 168 #ifndef LISP_FEATURE_UD2_BREAKPOINTS
 169     *(char*)pc = BREAKPOINT_INST;               /* x86 INT3       */
 170     *((char*)pc+1) = trap_Breakpoint;           /* Lisp trap code */
 171 #else
 172     *(char*)pc = UD2_INST & 0xff;
 173     *((char*)pc+1) = UD2_INST >> 8;
 174     *((char*)pc+2) = trap_Breakpoint;
 175 #endif
 176
 177     return result;
 178 }
 179
 180 void
 181 arch_remove_breakpoint(void *pc, unsigned int orig_inst)
 182 {
 183     *((char *)pc) = orig_inst & 0xff;
 184     *((char *)pc + 1) = (orig_inst & 0xff00) >> 8;
 185 #if BREAKPOINT_WIDTH > 1
 186     *((char *)pc + 2) = (orig_inst & 0xff0000) >> 16;
 187 #endif
 188 }
 189 \f
 190 /* When single stepping, single_stepping holds the original instruction
 191  * PC location. */
 192 unsigned int *single_stepping = NULL;
 193 #ifdef CANNOT_GET_TO_SINGLE_STEP_FLAG
 194 unsigned int  single_step_save1;
 195 unsigned int  single_step_save2;
 196 unsigned int  single_step_save3;
 197 #endif
 198
 199 void
 200 arch_do_displaced_inst(os_context_t *context, unsigned int orig_inst)
 201 {
 202     unsigned int *pc = (unsigned int*)(*os_context_pc_addr(context));
 203
 204     /* Put the original instruction back. */
 205     arch_remove_breakpoint(pc, orig_inst);
 206
 207 #ifdef CANNOT_GET_TO_SINGLE_STEP_FLAG
 208     /* Install helper instructions for the single step:
 209      * pushf; or [esp],0x100; popf. */
 210     single_step_save1 = *(pc-3);
 211     single_step_save2 = *(pc-2);
 212     single_step_save3 = *(pc-1);
 213     *(pc-3) = 0x9c909090;
 214     *(pc-2) = 0x00240c81;
 215     *(pc-1) = 0x9d000001;
 216 #else
 217     *context_eflags_addr(context) |= 0x100;
 218 #endif
 219
 220     single_stepping = pc;
 221
 222 #ifdef CANNOT_GET_TO_SINGLE_STEP_FLAG
 223     *os_context_pc_addr(context) = (os_context_register_t)((char *)pc - 9);
 224 #endif
 225 }
 226 \f
 227 void
 228 restore_breakpoint_from_single_step(os_context_t * context)
 229 {
 230     /* fprintf(stderr,"* single step trap %x\n", single_stepping); */
 231 #ifdef CANNOT_GET_TO_SINGLE_STEP_FLAG
 232     /* Un-install single step helper instructions. */
 233     *(single_stepping-3) = single_step_save1;
 234     *(single_stepping-2) = single_step_save2;
 235     *(single_stepping-1) = single_step_save3;
 236 #else
 237     *context_eflags_addr(context) &= ~0x100;
 238 #endif
 239     /* Re-install the breakpoint if possible. */
 240     if (((char *)*os_context_pc_addr(context) >
 241          (char *)single_stepping) &&
 242         ((char *)*os_context_pc_addr(context) <=
 243          (char *)single_stepping + BREAKPOINT_WIDTH)) {
 244         fprintf(stderr, "warning: couldn't reinstall breakpoint\n");
 245     } else {
 246         arch_install_breakpoint(single_stepping);
 247     }
 248
 249     single_stepping = NULL;
 250     return;
 251 }
 252
 253 void
 254 arch_handle_breakpoint(os_context_t *context)
 255 {
 256     *os_context_pc_addr(context) -= BREAKPOINT_WIDTH;
 257     handle_breakpoint(context);
 258 }
 259
 260 void
 261 arch_handle_fun_end_breakpoint(os_context_t *context)
 262 {
 263     *os_context_pc_addr(context) -= BREAKPOINT_WIDTH;
 264     *os_context_pc_addr(context) =
 265         (int)handle_fun_end_breakpoint(context);
 266 }
 267
 268 void
 269 arch_handle_single_step_trap(os_context_t *context, int trap)
 270 {
 271     arch_skip_instruction(context);
 272     /* On x86 the fdefn / function is always in EAX, so we pass 0
 273      * as the register_offset. */
 274     handle_single_step_trap(context, trap, 0);
 275 }
 276
 277 #ifndef LISP_FEATURE_WIN32
 278 void
 279 sigtrap_handler(int signal, siginfo_t *info, os_context_t *context)
 280 {
 281     unsigned int trap;
 282
 283     if (single_stepping) {
 284         restore_breakpoint_from_single_step(context);
 285         return;
 286     }
 287
 288     /* This is just for info in case the monitor wants to print an
 289      * approximation. */
 290     access_control_stack_pointer(arch_os_get_current_thread()) =
 291         (lispobj *)*os_context_sp_addr(context);
 292
 293 #ifdef LISP_FEATURE_SUNOS
 294     /* For some reason the breakpoints that :ENCAPSULATE NIL tracing sets up
 295      * cause a trace trap (i.e. processor single-stepping trap) on the following
 296      * instruction on Solaris 10/x86. -- JES, 2006-04-07
 297      */
 298     if (info->si_code == TRAP_TRACE) {
 299         lose("foo");
 300         return;
 301     }
 302 #endif
 303
 304     /* On entry %eip points just after the INT3 byte and aims at the
 305      * 'kind' value (eg trap_Cerror). For error-trap and Cerror-trap a
 306      * number of bytes will follow, the first is the length of the byte
 307      * arguments to follow. */
 308     trap = *(unsigned char *)(*os_context_pc_addr(context));
 309     handle_trap(context, trap);
 310 }
 311
 312 void
 313 sigill_handler(int signal, siginfo_t *siginfo, os_context_t *context) {
 314     /* Triggering SIGTRAP using int3 is unreliable on OS X/x86, so
 315      * we need to use illegal instructions for traps.
 316      */
 317 #if defined(LISP_FEATURE_UD2_BREAKPOINTS) && !defined(LISP_FEATURE_MACH_EXCEPTION_HANDLER)
 318     if (*((unsigned short *)*os_context_pc_addr(context)) == UD2_INST) {
 319         *os_context_pc_addr(context) += 2;
 320         return sigtrap_handler(signal, siginfo, context);
 321     }
 322 #endif
 323     fake_foreign_function_call(context);
 324     lose("Unhandled SIGILL");
 325 }
 326 #endif /* not LISP_FEATURE_WIN32 */
 327
 328 void
 329 arch_install_interrupt_handlers()
 330 {
 331     SHOW("entering arch_install_interrupt_handlers()");
 332
 333     /* Note: The old CMU CL code here used sigtrap_handler() to handle
 334      * SIGILL as well as SIGTRAP. I couldn't see any reason to do
 335      * things that way. So, I changed to separate handlers when
 336      * debugging a problem on OpenBSD, where SBCL wasn't catching
 337      * SIGILL properly, but was instead letting the process be
 338      * terminated with an "Illegal instruction" output. If this change
 339      * turns out to break something (maybe breakpoint handling on some
 340      * OS I haven't tested on?) and we have to go back to the old CMU
 341      * CL way, I hope there will at least be a comment to explain
 342      * why.. -- WHN 2001-06-07 */
 343 #if !defined(LISP_FEATURE_WIN32) && !defined(LISP_FEATURE_MACH_EXCEPTION_HANDLER)
 344     undoably_install_low_level_interrupt_handler(SIGILL , sigill_handler);
 345     undoably_install_low_level_interrupt_handler(SIGTRAP, sigtrap_handler);
 346 #endif
 347     SHOW("returning from arch_install_interrupt_handlers()");
 348 }
 349 \f
 350 #ifdef LISP_FEATURE_LINKAGE_TABLE
 351 /* FIXME: It might be cleaner to generate these from the lisp side of
 352  * things.
 353  */
 354
 355 void
 356 arch_write_linkage_table_jmp(char * reloc, void * fun)
 357 {
 358     /* Make JMP to function entry. JMP offset is calculated from next
 359      * instruction.
 360      */
 361     long offset = (char *)fun - (reloc + 5);
 362     int i;
 363
 364     *reloc++ = 0xe9;            /* opcode for JMP rel32 */
 365     for (i = 0; i < 4; i++) {
 366         *reloc++ = offset & 0xff;
 367         offset >>= 8;
 368     }
 369
 370     /* write a nop for good measure. */
 371     *reloc = 0x90;
 372 }
 373
 374 void
 375 arch_write_linkage_table_ref(void * reloc, void * data)
 376 {
 377     *(unsigned long *)reloc = (unsigned long)data;
 378 }
 379
 380 #endif