src/runtime/x86-win32-os.c

   1 /*
   2  * The x86 Win32 incarnation of arch-dependent OS-dependent routines.
   3  * See also "win32-os.c".
   4  */
   5
   6 /*
   7  * This software is part of the SBCL system. See the README file for
   8  * more information.
   9  *
  10  * This software is derived from the CMU CL system, which was
  11  * written at Carnegie Mellon University and released into the
  12  * public domain. The software is in the public domain and is
  13  * provided with absolutely no warranty. See the COPYING and CREDITS
  14  * files for more information.
  15  */
  16
  17 #include <stdio.h>
  18 #include <stddef.h>
  19 #include <sys/param.h>
  20 #include <sys/file.h>
  21 #include <sys/types.h>
  22 #include <unistd.h>
  23 #include <errno.h>
  24
  25 #include "os.h"
  26 #include "arch.h"
  27 #include "globals.h"
  28 #include "interrupt.h"
  29 #include "interr.h"
  30 #include "lispregs.h"
  31 #include "genesis/sbcl.h"
  32
  33 #include <sys/types.h>
  34 #include "runtime.h"
  35 #include <sys/time.h>
  36 #include <sys/stat.h>
  37 #include <unistd.h>
  38 #include "thread.h"             /* dynamic_values_bytes */
  39 #include "align.h"              /* PTR_ALIGN... */
  40
  41 #include "validate.h"
  42
  43 int arch_os_thread_init(struct thread *thread)
  44 {
  45     {
  46         void *top_exception_frame;
  47         void *cur_stack_end;
  48         void *cur_stack_start;
  49         MEMORY_BASIC_INFORMATION stack_memory;
  50
  51         asm volatile ("movl %%fs:0,%0": "=r" (top_exception_frame));
  52         asm volatile ("movl %%fs:4,%0": "=r" (cur_stack_end));
  53
  54         /* Can't pull stack start from fs:4 or fs:8 or whatever,
  55          * because that's only what currently has memory behind
  56          * it from being used, so do a quick VirtualQuery() and
  57          * grab the AllocationBase. -AB 2006/11/25
  58          */
  59
  60         if (!VirtualQuery(&stack_memory, &stack_memory, sizeof(stack_memory))) {
  61             fprintf(stderr, "VirtualQuery: 0x%lx.\n", GetLastError());
  62             lose("Could not query stack memory information.");
  63         }
  64
  65         cur_stack_start = stack_memory.AllocationBase;
  66
  67         /* We use top_exception_frame rather than cur_stack_end to
  68          * elide the last few (boring) stack entries at the bottom of
  69          * the backtrace.
  70          */
  71         thread->control_stack_start = cur_stack_start;
  72         thread->control_stack_end = top_exception_frame;
  73     }
  74
  75     TlsSetValue(OUR_TLS_INDEX,thread);
  76
  77     extern void win32_set_stack_guarantee(void);
  78     win32_set_stack_guarantee();
  79
  80     return 1;
  81 }
  82
  83 /* free any arch/os-specific resources used by thread, which is now
  84  * defunct.  Not called on live threads
  85  */
  86
  87 int arch_os_thread_cleanup(struct thread *thread) {
  88     return 0;
  89 }
  90
  91 sigset_t *os_context_sigmask_addr(os_context_t *context)
  92 {
  93   return &context->sigmask;
  94 }
  95
  96 os_context_register_t *
  97 os_context_register_addr(os_context_t *context, int offset)
  98 {
  99     static const size_t offsets[8] = {
 100         offsetof(CONTEXT,Eax),
 101         offsetof(CONTEXT,Ecx),
 102         offsetof(CONTEXT,Edx),
 103         offsetof(CONTEXT,Ebx),
 104         offsetof(CONTEXT,Esp),
 105         offsetof(CONTEXT,Ebp),
 106         offsetof(CONTEXT,Esi),
 107         offsetof(CONTEXT,Edi),
 108     };
 109     return
 110         (offset >= 0 && offset < 16) ?
 111         ((void*)(context->win32_context)) + offsets[offset>>1]  : 0;
 112 }
 113
 114 os_context_register_t *
 115 os_context_sp_addr(os_context_t *context)
 116 {
 117     return (void*)&context->win32_context->Esp; /* REG_UESP */
 118 }
 119
 120 os_context_register_t *
 121 os_context_fp_addr(os_context_t *context)
 122 {
 123     return (void*)&context->win32_context->Ebp; /* REG_EBP */
 124 }
 125
 126 unsigned long
 127 os_context_fp_control(os_context_t *context)
 128 {
 129     return ((((context->win32_context->FloatSave.ControlWord) & 0xffff) ^ 0x3f) |
 130             (((context->win32_context->FloatSave.StatusWord) & 0xffff) << 16));
 131 }
 132
 133 void
 134 os_restore_fp_control(os_context_t *context)
 135 {
 136     asm ("fldcw %0" : : "m" (context->win32_context->FloatSave.ControlWord));
 137 }
 138
 139 os_context_register_t *
 140 os_context_float_register_addr(os_context_t *context, int offset)
 141 {
 142     return (os_context_register_t*)&context->win32_context->FloatSave.RegisterArea[offset];
 143 }
 144 void
 145 os_flush_icache(os_vm_address_t address, os_vm_size_t length)
 146 {
 147 }
 148
 149 /*
 150  * The stubs below are replacements for the windows versions,
 151  * which can -fail- when used in our memory spaces because they
 152  * validate the memory spaces they are passed in a way that
 153  * denies our exception handler a chance to run.
 154  */
 155
 156 void *memmove(void *dest, const void *src, size_t n)
 157 {
 158     if (dest < src) {
 159         size_t i;
 160         for (i = 0; i < n; i++) *(((char *)dest)+i) = *(((char *)src)+i);
 161     } else {
 162         while (n--) *(((char *)dest)+n) = *(((char *)src)+n);
 163     }
 164     return dest;
 165 }
 166
 167 void *memcpy(void *dest, const void *src, size_t n)
 168 {
 169     while (n--) *(((char *)dest)+n) = *(((char *)src)+n);
 170     return dest;
 171 }