arch/all-mingw32/kernel/cpu_i386.h

   1 #ifdef __AROS__
   2
   3 #include <aros/i386/cpucontext.h>
   4
   5 /* This was taken from Mingw32's w32api/winnt.h */
   6
   7 /* Context flags */
   8 #define CONTEXT_i386               0x10000
   9 #define CONTEXT_i486               0x10000
  10 #define CONTEXT_CONTROL            (CONTEXT_i386|0x00000001L)
  11 #define CONTEXT_INTEGER            (CONTEXT_i386|0x00000002L)
  12 #define CONTEXT_SEGMENTS           (CONTEXT_i386|0x00000004L)
  13 #define CONTEXT_FLOATING_POINT     (CONTEXT_i386|0x00000008L)
  14 #define CONTEXT_DEBUG_REGISTERS    (CONTEXT_i386|0x00000010L)
  15 #define CONTEXT_EXTENDED_REGISTERS (CONTEXT_i386|0x00000020L)
  16 #define CONTEXT_FULL               (CONTEXT_CONTROL|CONTEXT_INTEGER|CONTEXT_SEGMENTS)
  17
  18 /* Some lengths */
  19 #define MAXIMUM_SUPPORTED_EXTENSION 512
  20
  21 typedef struct _FLOATING_SAVE_AREA
  22 {
  23         IPTR    ControlWord;
  24         IPTR    StatusWord;
  25         IPTR    TagWord;
  26         IPTR    ErrorOffset;
  27         IPTR    ErrorSelector;
  28         IPTR    DataOffset;
  29         IPTR    DataSelector;
  30         UBYTE   RegisterArea[80];
  31         IPTR    Cr0NpxState;
  32 } FLOATING_SAVE_AREA;
  33
  34 typedef struct _CONTEXT
  35 {
  36         IPTR    ContextFlags;
  37         IPTR    Dr0;
  38         IPTR    Dr1;
  39         IPTR    Dr2;
  40         IPTR    Dr3;
  41         IPTR    Dr6;
  42         IPTR    Dr7;
  43         FLOATING_SAVE_AREA FloatSave;
  44         IPTR    SegGs;
  45         IPTR    SegFs;
  46         IPTR    SegEs;
  47         IPTR    SegDs;
  48         IPTR    Edi;
  49         IPTR    Esi;
  50         IPTR    Ebx;
  51         IPTR    Edx;
  52         IPTR    Ecx;
  53         IPTR    Eax;
  54         IPTR    Ebp;
  55         IPTR    Eip;
  56         IPTR    SegCs;
  57         IPTR    EFlags;
  58         IPTR    Esp;
  59         IPTR    SegSs;
  60         BYTE    ExtendedRegisters[MAXIMUM_SUPPORTED_EXTENSION];
  61 } CONTEXT;
  62
  63 /* On AROS side we save also LastError code */
  64 struct AROSCPUContext
  65 {
  66     struct ExceptionContext regs; /* Public portion */
  67     ULONG LastError;              /* LastError code */
  68 };
  69
  70 /*
  71  * Common part of SAVEREGS and TRAP_SAVEREGS.
  72  * Saves CPU registers from CONTEXT in struct ExceptionContext.
  73  */
  74 #define SAVE_CPU(regs, ctx)                     \
  75     ctx.Flags = 0;                              \
  76     ctx.eax = regs->Eax;                        \
  77     ctx.ebx = regs->Ebx;                        \
  78     ctx.ecx = regs->Ecx;                        \
  79     ctx.edx = regs->Edx;                        \
  80     ctx.esi = regs->Esi;                        \
  81     ctx.edi = regs->Edi;                        \
  82     ctx.ebp = regs->Ebp;                        \
  83     ctx.eip = regs->Eip;                        \
  84     ctx.eflags = regs->EFlags;                  \
  85     ctx.esp = regs->Esp;                        \
  86     if (regs->ContextFlags & CONTEXT_SEGMENTS)  \
  87     {                                           \
  88         ctx.Flags |= ECF_SEGMENTS;              \
  89         ctx.ds = regs->SegDs;                   \
  90         ctx.es = regs->SegEs;                   \
  91         ctx.fs = regs->SegFs;                   \
  92         ctx.gs = regs->SegGs;                   \
  93         ctx.cs = regs->SegCs;                   \
  94         ctx.ss = regs->SegSs;                   \
  95     }
  96
  97 /*
  98  * Restore CPU registers.
  99  * Does not restore segment registers because they are of private use
 100  * by Windows. We can't modify them.
 101  */
 102 #define RESTORE_CPU(regs, ctx)                                  \
 103     regs->ContextFlags = CONTEXT_CONTROL|CONTEXT_INTEGER;       \
 104     regs->Eax = ctx.eax;                                        \
 105     regs->Ebx = ctx.ebx;                                        \
 106     regs->Ecx = ctx.ecx;                                        \
 107     regs->Edx = ctx.edx;                                        \
 108     regs->Esi = ctx.esi;                                        \
 109     regs->Edi = ctx.edi;                                        \
 110     regs->Ebp = ctx.ebp;                                        \
 111     regs->Eip = ctx.eip;                                        \
 112     regs->EFlags = ctx.eflags;                                  \
 113     regs->Esp = ctx.esp;
 114
 115 /* Provide legacy 8087 context together with SSE one */
 116 #define USE_LEGACY_8087
 117
 118 /* 8087 frame contains private portion (Cr0NpxState) */
 119 #define SIZEOF_8087_FRAME sizeof(FLOATING_SAVE_AREA)
 120
 121 /*
 122  * Save the whole set of registers in the allocated context space.
 123  * Also saves FPU and SSE, if available.
 124  */
 125 #define SAVEREGS(regs, ctx)                                                                     \
 126     SAVE_CPU(regs, ctx->regs);                                                                  \
 127     if (regs->ContextFlags & CONTEXT_FLOATING_POINT)                                            \
 128     {                                                                                           \
 129         ctx->regs.Flags |= ECF_FPU;                                                             \
 130         CopyMemQuick(&regs->FloatSave, ctx->regs.FPData, sizeof(FLOATING_SAVE_AREA));           \
 131     }                                                                                           \
 132     if (regs->ContextFlags & CONTEXT_EXTENDED_REGISTERS)                                        \
 133     {                                                                                           \
 134         ctx->regs.Flags |= ECF_FPX;                                                             \
 135         CopyMemQuick(regs->ExtendedRegisters, ctx->regs.FXData, MAXIMUM_SUPPORTED_EXTENSION);   \
 136     }
 137
 138 /*
 139  * Restore complete set of registers.
 140  * Restores FPU and SSE only if they present both in CONTEXT and in struct ExceptionContext.
 141  * This is done because a debugger may want to modify one of frames. In this case it will
 142  * reset flag of the second frame (which is still unmodified).
 143  */
 144 #define RESTOREREGS(regs, ctx)                                                                  \
 145 {                                                                                               \
 146     ULONG orig = regs->ContextFlags;                                                            \
 147     RESTORE_CPU(regs, ctx->regs);                                                               \
 148     if (ctx->regs.Flags & ECF_FPU)                                                              \
 149     {                                                                                           \
 150         regs->ContextFlags |= CONTEXT_FLOATING_POINT;                                           \
 151         CopyMemQuick(ctx->regs.FPData, &regs->FloatSave, sizeof(FLOATING_SAVE_AREA));           \
 152     }                                                                                           \
 153     if ((ctx->regs.Flags & ECF_FPX) && (orig & CONTEXT_EXTENDED_REGISTERS))                     \
 154     {                                                                                           \
 155         regs->ContextFlags |= CONTEXT_EXTENDED_REGISTERS;                                       \
 156         CopyMemQuick(ctx->regs.FXData, regs->ExtendedRegisters, MAXIMUM_SUPPORTED_EXTENSION);   \
 157     }                                                                                           \
 158 }
 159
 160 /*
 161  * Similar to SAVEREGS and RESTOREREGS, but actually copies only CPU part.
 162  * FPU and SSE are specified by references (frames format in host and AROS match).
 163  * This is for use within trap handling code.
 164  */
 165 #define TRAP_SAVEREGS(src, dest)                                        \
 166     SAVE_CPU(src, dest)                                                 \
 167     if (src->ContextFlags & CONTEXT_FLOATING_POINT)                     \
 168     {                                                                   \
 169         dest.Flags |= ECF_FPU;                                          \
 170         dest.FPData = (struct FPUContext *)&src->FloatSave;             \
 171     }                                                                   \
 172     if (src->ContextFlags & CONTEXT_EXTENDED_REGISTERS)                 \
 173     {                                                                   \
 174         dest.Flags |= ECF_FPX;                                          \
 175         dest.FXData = (struct FPXContext *)src->ExtendedRegisters;      \
 176     }
 177
 178 #define TRAP_RESTOREREGS(dest, src)                             \
 179     RESTORE_CPU(dest, src);                                     \
 180     if (src.Flags & ECF_FPU)                                    \
 181         dest->ContextFlags |= CONTEXT_FLOATING_POINT;           \
 182     if (src.Flags & ECF_FPX)                                    \
 183         dest->ContextFlags |= CONTEXT_EXTENDED_REGISTERS;
 184
 185 /*
 186  * Realign and copy FPU portion from src to dest. It is supposed
 187  * that common part is already copied.
 188  */
 189 #define COPY_FPU(src, dest)                                                             \
 190 {                                                                                       \
 191     IPTR fpdata = (IPTR)(dest) + sizeof(struct AROSCPUContext);                         \
 192     if ((src)->Flags & ECF_FPU)                                                         \
 193     {                                                                                   \
 194         (dest)->FPData = (struct FPUContext *)fpdata;                                   \
 195         fpdata += sizeof(FLOATING_SAVE_AREA);                                           \
 196         CopyMemQuick((src)->FPData, (dest)->FPData, sizeof(FLOATING_SAVE_AREA));        \
 197     }                                                                                   \
 198     else                                                                                \
 199         (dest)->FPData = NULL;                                                          \
 200     if ((src)->Flags & ECF_FPX)                                                         \
 201     {                                                                                   \
 202         fpdata = (fpdata + 15) & ~15;                                                   \
 203         (dest)->FXData = (struct FPXContext *)fpdata;                                   \
 204         CopyMemQuick((src)->FXData, (dest)->FXData, MAXIMUM_SUPPORTED_EXTENSION);       \
 205     }                                                                                   \
 206     else                                                                                \
 207         (dest)->FXData = NULL;                                                          \
 208 }
 209
 210 #define GET_SP(ctx) (void *)ctx->regs.esp
 211
 212 #define EXCEPTIONS_COUNT 18
 213
 214 #endif /* __AROS__ */
 215
 216 /* The following macros need to be visible on both Windows and AROS side */
 217
 218 #define PRINT_CPUCONTEXT(ctx) \
 219         bug ("    ContextFlags: 0x%08lX\n" \
 220                  "    ESP=%08lx  EBP=%08lx  EIP=%08lx\n" \
 221                  "    EAX=%08lx  EBX=%08lx  ECX=%08lx  EDX=%08lx\n" \
 222                  "    EDI=%08lx  ESI=%08lx  EFLAGS=%08lx\n" \
 223             , (ctx)->ContextFlags \
 224             , (ctx)->Esp \
 225             , (ctx)->Ebp \
 226             , (ctx)->Eip \
 227             , (ctx)->Eax \
 228             , (ctx)->Ebx \
 229             , (ctx)->Ecx \
 230             , (ctx)->Edx \
 231             , (ctx)->Edi \
 232             , (ctx)->Esi \
 233             , (ctx)->EFlags \
 234       );
 235
 236 #define CONTEXT_INIT_FLAGS(ctx) (ctx)->ContextFlags = CONTEXT_FULL|CONTEXT_FLOATING_POINT|CONTEXT_DEBUG_REGISTERS|CONTEXT_EXTENDED_REGISTERS
 237
 238 #define PC(regs) regs->Eip
 239 #define R0(regs) regs->Eax