?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
setupapi: Fix buffer overflow in SetupGetFileCompressionInfoW.
[wine.git] / dlls / ntdll / signal_powerpc.c
bloba457bdf3b449ab9ede076613acee6250f2af034c
1 /*
2 * PowerPC signal handling routines
3 *
4 * Copyright 2002 Marcus Meissner, SuSE Linux AG
5 *
6 * This library is free software; you can redistribute it and/or
7 * modify it under the terms of the GNU Lesser General Public
8 * License as published by the Free Software Foundation; either
9 * version 2.1 of the License, or (at your option) any later version.
10 *
11 * This library is distributed in the hope that it will be useful,
12 * but WITHOUT ANY WARRANTY; without even the implied warranty of
13 * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
14 * Lesser General Public License for more details.
15 *
16 * You should have received a copy of the GNU Lesser General Public
17 * License along with this library; if not, write to the Free Software
18 * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301, USA
19 */
20
21 #ifdef __powerpc__
22
23 #include "config.h"
24 #include "wine/port.h"
25
26 #include <assert.h>
27 #include <signal.h>
28 #include <stdlib.h>
29 #include <stdarg.h>
30 #include <stdio.h>
31 #ifdef HAVE_UNISTD_H
32 # include <unistd.h>
33 #endif
34
35 #ifdef HAVE_SYS_PARAM_H
36 # include <sys/param.h>
37 #endif
38 #ifdef HAVE_SYSCALL_H
39 # include <syscall.h>
40 #else
41 # ifdef HAVE_SYS_SYSCALL_H
42 # include <sys/syscall.h>
43 # endif
44 #endif
45
46 #ifdef HAVE_SYS_SIGNAL_H
47 # include <sys/signal.h>
48 #endif
49
50 #include "ntstatus.h"
51 #define WIN32_NO_STATUS
52 #include "windef.h"
53 #include "winternl.h"
54 #include "wine/library.h"
55 #include "wine/exception.h"
56 #include "ntdll_misc.h"
57 #include "wine/debug.h"
58
59 WINE_DEFAULT_DEBUG_CHANNEL(seh);
60
61 static pthread_key_t teb_key;
62
63 /***********************************************************************
64 * signal context platform-specific definitions
65 */
66 #ifdef linux
67
68 /* All Registers access - only for local access */
69 # define REG_sig(reg_name, context) ((context)->uc_mcontext.regs->reg_name)
70
71
72 /* Gpr Registers access */
73 # define GPR_sig(reg_num, context) REG_sig(gpr[reg_num], context)
74
75 # define IAR_sig(context) REG_sig(nip, context) /* Program counter */
76 # define MSR_sig(context) REG_sig(msr, context) /* Machine State Register (Supervisor) */
77 # define CTR_sig(context) REG_sig(ctr, context) /* Count register */
78
79 # define XER_sig(context) REG_sig(xer, context) /* User's integer exception register */
80 # define LR_sig(context) REG_sig(link, context) /* Link register */
81 # define CR_sig(context) REG_sig(ccr, context) /* Condition register */
82
83 /* Float Registers access */
84 # define FLOAT_sig(reg_num, context) (((double*)((char*)((context)->uc_mcontext.regs+48*4)))[reg_num])
85
86 # define FPSCR_sig(context) (*(int*)((char*)((context)->uc_mcontext.regs+(48+32*2)*4)))
87
88 /* Exception Registers access */
89 # define DAR_sig(context) REG_sig(dar, context)
90 # define DSISR_sig(context) REG_sig(dsisr, context)
91 # define TRAP_sig(context) REG_sig(trap, context)
92
93 #endif /* linux */
94
95 #ifdef __APPLE__
96
97 # include <sys/ucontext.h>
98 # include <sys/types.h>
99
100 /* All Registers access - only for local access */
101 # define REG_sig(reg_name, context) ((context)->uc_mcontext->ss.reg_name)
102 # define FLOATREG_sig(reg_name, context) ((context)->uc_mcontext->fs.reg_name)
103 # define EXCEPREG_sig(reg_name, context) ((context)->uc_mcontext->es.reg_name)
104 # define VECREG_sig(reg_name, context) ((context)->uc_mcontext->vs.reg_name)
105
106 /* Gpr Registers access */
107 # define GPR_sig(reg_num, context) REG_sig(r##reg_num, context)
108
109 # define IAR_sig(context) REG_sig(srr0, context) /* Program counter */
110 # define MSR_sig(context) REG_sig(srr1, context) /* Machine State Register (Supervisor) */
111 # define CTR_sig(context) REG_sig(ctr, context)
112
113 # define XER_sig(context) REG_sig(xer, context) /* Link register */
114 # define LR_sig(context) REG_sig(lr, context) /* User's integer exception register */
115 # define CR_sig(context) REG_sig(cr, context) /* Condition register */
116
117 /* Float Registers access */
118 # define FLOAT_sig(reg_num, context) FLOATREG_sig(fpregs[reg_num], context)
119
120 # define FPSCR_sig(context) FLOATREG_sig(fpscr, context)
121
122 /* Exception Registers access */
123 # define DAR_sig(context) EXCEPREG_sig(dar, context) /* Fault registers for coredump */
124 # define DSISR_sig(context) EXCEPREG_sig(dsisr, context)
125 # define TRAP_sig(context) EXCEPREG_sig(exception, context) /* number of powerpc exception taken */
126
127 /* Signal defs : Those are undefined on darwin
128 SIGBUS
129 #undef BUS_ADRERR
130 #undef BUS_OBJERR
131 SIGILL
132 #undef ILL_ILLOPN
133 #undef ILL_ILLTRP
134 #undef ILL_ILLADR
135 #undef ILL_COPROC
136 #undef ILL_PRVREG
137 #undef ILL_BADSTK
138 SIGTRAP
139 #undef TRAP_BRKPT
140 #undef TRAP_TRACE
141 SIGFPE
142 */
143
144 #endif /* __APPLE__ */
145
146
147
148 typedef int (*wine_signal_handler)(unsigned int sig);
149
150 static wine_signal_handler handlers[256];
151
152 /***********************************************************************
153 * dispatch_signal
154 */
155 static inline int dispatch_signal(unsigned int sig)
156 {
157 if (handlers[sig] == NULL) return 0;
158 return handlers[sig](sig);
159 }
160
161 /***********************************************************************
162 * save_context
163 *
164 * Set the register values from a sigcontext.
165 */
166 static void save_context( CONTEXT *context, const ucontext_t *sigcontext )
167 {
168
169 #define C(x) context->Gpr##x = GPR_sig(x,sigcontext)
170 /* Save Gpr registers */
171 C(0); C(1); C(2); C(3); C(4); C(5); C(6); C(7); C(8); C(9); C(10);
172 C(11); C(12); C(13); C(14); C(15); C(16); C(17); C(18); C(19); C(20);
173 C(21); C(22); C(23); C(24); C(25); C(26); C(27); C(28); C(29); C(30);
174 C(31);
175 #undef C
176
177 context->Iar = IAR_sig(sigcontext); /* Program Counter */
178 context->Msr = MSR_sig(sigcontext); /* Machine State Register (Supervisor) */
179 context->Ctr = CTR_sig(sigcontext);
180
181 context->Xer = XER_sig(sigcontext);
182 context->Lr = LR_sig(sigcontext);
183 context->Cr = CR_sig(sigcontext);
184
185 /* Saving Exception regs */
186 context->Dar = DAR_sig(sigcontext);
187 context->Dsisr = DSISR_sig(sigcontext);
188 context->Trap = TRAP_sig(sigcontext);
189 }
190
191
192 /***********************************************************************
193 * restore_context
194 *
195 * Build a sigcontext from the register values.
196 */
197 static void restore_context( const CONTEXT *context, ucontext_t *sigcontext )
198 {
199
200 #define C(x) GPR_sig(x,sigcontext) = context->Gpr##x
201 C(0); C(1); C(2); C(3); C(4); C(5); C(6); C(7); C(8); C(9); C(10);
202 C(11); C(12); C(13); C(14); C(15); C(16); C(17); C(18); C(19); C(20);
203 C(21); C(22); C(23); C(24); C(25); C(26); C(27); C(28); C(29); C(30);
204 C(31);
205 #undef C
206
207 IAR_sig(sigcontext) = context->Iar; /* Program Counter */
208 MSR_sig(sigcontext) = context->Msr; /* Machine State Register (Supervisor) */
209 CTR_sig(sigcontext) = context->Ctr;
210
211 XER_sig(sigcontext) = context->Xer;
212 LR_sig(sigcontext) = context->Lr;
213 CR_sig(sigcontext) = context->Cr;
214
215 /* Setting Exception regs */
216 DAR_sig(sigcontext) = context->Dar;
217 DSISR_sig(sigcontext) = context->Dsisr;
218 TRAP_sig(sigcontext) = context->Trap;
219 }
220
221
222 /***********************************************************************
223 * save_fpu
224 *
225 * Set the FPU context from a sigcontext.
226 */
227 static inline void save_fpu( CONTEXT *context, const ucontext_t *sigcontext )
228 {
229 #define C(x) context->Fpr##x = FLOAT_sig(x,sigcontext)
230 C(0); C(1); C(2); C(3); C(4); C(5); C(6); C(7); C(8); C(9); C(10);
231 C(11); C(12); C(13); C(14); C(15); C(16); C(17); C(18); C(19); C(20);
232 C(21); C(22); C(23); C(24); C(25); C(26); C(27); C(28); C(29); C(30);
233 C(31);
234 #undef C
235 context->Fpscr = FPSCR_sig(sigcontext);
236 }
237
238
239 /***********************************************************************
240 * restore_fpu
241 *
242 * Restore the FPU context to a sigcontext.
243 */
244 static inline void restore_fpu( CONTEXT *context, const ucontext_t *sigcontext )
245 {
246 #define C(x) FLOAT_sig(x,sigcontext) = context->Fpr##x
247 C(0); C(1); C(2); C(3); C(4); C(5); C(6); C(7); C(8); C(9); C(10);
248 C(11); C(12); C(13); C(14); C(15); C(16); C(17); C(18); C(19); C(20);
249 C(21); C(22); C(23); C(24); C(25); C(26); C(27); C(28); C(29); C(30);
250 C(31);
251 #undef C
252 FPSCR_sig(sigcontext) = context->Fpscr;
253 }
254
255
256 /***********************************************************************
257 * RtlCaptureContext (NTDLL.@)
258 */
259 void WINAPI RtlCaptureContext( CONTEXT *context )
260 {
261 FIXME("not implemented\n");
262 memset( context, 0, sizeof(*context) );
263 }
264
265
266 /***********************************************************************
267 * set_cpu_context
268 *
269 * Set the new CPU context.
270 */
271 void set_cpu_context( const CONTEXT *context )
272 {
273 FIXME("not implemented\n");
274 }
275
276
277 /***********************************************************************
278 * copy_context
279 *
280 * Copy a register context according to the flags.
281 */
282 void copy_context( CONTEXT *to, const CONTEXT *from, DWORD flags )
283 {
284 if (flags & CONTEXT_CONTROL)
285 {
286 to->Msr = from->Msr;
287 to->Ctr = from->Ctr;
288 to->Iar = from->Iar;
289 to->Lr = from->Lr;
290 to->Dar = from->Dar;
291 to->Dsisr = from->Dsisr;
292 to->Trap = from->Trap;
293 }
294 if (flags & CONTEXT_INTEGER)
295 {
296 to->Gpr0 = from->Gpr0;
297 to->Gpr1 = from->Gpr1;
298 to->Gpr2 = from->Gpr2;
299 to->Gpr3 = from->Gpr3;
300 to->Gpr4 = from->Gpr4;
301 to->Gpr5 = from->Gpr5;
302 to->Gpr6 = from->Gpr6;
303 to->Gpr7 = from->Gpr7;
304 to->Gpr8 = from->Gpr8;
305 to->Gpr9 = from->Gpr9;
306 to->Gpr10 = from->Gpr10;
307 to->Gpr11 = from->Gpr11;
308 to->Gpr12 = from->Gpr12;
309 to->Gpr13 = from->Gpr13;
310 to->Gpr14 = from->Gpr14;
311 to->Gpr15 = from->Gpr15;
312 to->Gpr16 = from->Gpr16;
313 to->Gpr17 = from->Gpr17;
314 to->Gpr18 = from->Gpr18;
315 to->Gpr19 = from->Gpr19;
316 to->Gpr20 = from->Gpr20;
317 to->Gpr21 = from->Gpr21;
318 to->Gpr22 = from->Gpr22;
319 to->Gpr23 = from->Gpr23;
320 to->Gpr24 = from->Gpr24;
321 to->Gpr25 = from->Gpr25;
322 to->Gpr26 = from->Gpr26;
323 to->Gpr27 = from->Gpr27;
324 to->Gpr28 = from->Gpr28;
325 to->Gpr29 = from->Gpr29;
326 to->Gpr30 = from->Gpr30;
327 to->Gpr31 = from->Gpr31;
328 to->Xer = from->Xer;
329 to->Cr = from->Cr;
330 }
331 if (flags & CONTEXT_FLOATING_POINT)
332 {
333 to->Fpr0 = from->Fpr0;
334 to->Fpr1 = from->Fpr1;
335 to->Fpr2 = from->Fpr2;
336 to->Fpr3 = from->Fpr3;
337 to->Fpr4 = from->Fpr4;
338 to->Fpr5 = from->Fpr5;
339 to->Fpr6 = from->Fpr6;
340 to->Fpr7 = from->Fpr7;
341 to->Fpr8 = from->Fpr8;
342 to->Fpr9 = from->Fpr9;
343 to->Fpr10 = from->Fpr10;
344 to->Fpr11 = from->Fpr11;
345 to->Fpr12 = from->Fpr12;
346 to->Fpr13 = from->Fpr13;
347 to->Fpr14 = from->Fpr14;
348 to->Fpr15 = from->Fpr15;
349 to->Fpr16 = from->Fpr16;
350 to->Fpr17 = from->Fpr17;
351 to->Fpr18 = from->Fpr18;
352 to->Fpr19 = from->Fpr19;
353 to->Fpr20 = from->Fpr20;
354 to->Fpr21 = from->Fpr21;
355 to->Fpr22 = from->Fpr22;
356 to->Fpr23 = from->Fpr23;
357 to->Fpr24 = from->Fpr24;
358 to->Fpr25 = from->Fpr25;
359 to->Fpr26 = from->Fpr26;
360 to->Fpr27 = from->Fpr27;
361 to->Fpr28 = from->Fpr28;
362 to->Fpr29 = from->Fpr29;
363 to->Fpr30 = from->Fpr30;
364 to->Fpr31 = from->Fpr31;
365 to->Fpscr = from->Fpscr;
366 }
367 }
368
369
370 /***********************************************************************
371 * context_to_server
372 *
373 * Convert a register context to the server format.
374 */
375 NTSTATUS context_to_server( context_t *to, const CONTEXT *from )
376 {
377 DWORD flags = from->ContextFlags; /* no CPU id? */
378
379 memset( to, 0, sizeof(*to) );
380 to->cpu = CPU_POWERPC;
381
382 if (flags & CONTEXT_CONTROL)
383 {
384 to->flags |= SERVER_CTX_CONTROL;
385 to->ctl.powerpc_regs.iar = from->Iar;
386 to->ctl.powerpc_regs.msr = from->Msr;
387 to->ctl.powerpc_regs.ctr = from->Ctr;
388 to->ctl.powerpc_regs.lr = from->Lr;
389 to->ctl.powerpc_regs.dar = from->Dar;
390 to->ctl.powerpc_regs.dsisr = from->Dsisr;
391 to->ctl.powerpc_regs.trap = from->Trap;
392 }
393 if (flags & CONTEXT_INTEGER)
394 {
395 to->flags |= SERVER_CTX_INTEGER;
396 to->integer.powerpc_regs.gpr[0] = from->Gpr0;
397 to->integer.powerpc_regs.gpr[1] = from->Gpr1;
398 to->integer.powerpc_regs.gpr[2] = from->Gpr2;
399 to->integer.powerpc_regs.gpr[3] = from->Gpr3;
400 to->integer.powerpc_regs.gpr[4] = from->Gpr4;
401 to->integer.powerpc_regs.gpr[5] = from->Gpr5;
402 to->integer.powerpc_regs.gpr[6] = from->Gpr6;
403 to->integer.powerpc_regs.gpr[7] = from->Gpr7;
404 to->integer.powerpc_regs.gpr[8] = from->Gpr8;
405 to->integer.powerpc_regs.gpr[9] = from->Gpr9;
406 to->integer.powerpc_regs.gpr[10] = from->Gpr10;
407 to->integer.powerpc_regs.gpr[11] = from->Gpr11;
408 to->integer.powerpc_regs.gpr[12] = from->Gpr12;
409 to->integer.powerpc_regs.gpr[13] = from->Gpr13;
410 to->integer.powerpc_regs.gpr[14] = from->Gpr14;
411 to->integer.powerpc_regs.gpr[15] = from->Gpr15;
412 to->integer.powerpc_regs.gpr[16] = from->Gpr16;
413 to->integer.powerpc_regs.gpr[17] = from->Gpr17;
414 to->integer.powerpc_regs.gpr[18] = from->Gpr18;
415 to->integer.powerpc_regs.gpr[19] = from->Gpr19;
416 to->integer.powerpc_regs.gpr[20] = from->Gpr20;
417 to->integer.powerpc_regs.gpr[21] = from->Gpr21;
418 to->integer.powerpc_regs.gpr[22] = from->Gpr22;
419 to->integer.powerpc_regs.gpr[23] = from->Gpr23;
420 to->integer.powerpc_regs.gpr[24] = from->Gpr24;
421 to->integer.powerpc_regs.gpr[25] = from->Gpr25;
422 to->integer.powerpc_regs.gpr[26] = from->Gpr26;
423 to->integer.powerpc_regs.gpr[27] = from->Gpr27;
424 to->integer.powerpc_regs.gpr[28] = from->Gpr28;
425 to->integer.powerpc_regs.gpr[29] = from->Gpr29;
426 to->integer.powerpc_regs.gpr[30] = from->Gpr30;
427 to->integer.powerpc_regs.gpr[31] = from->Gpr31;
428 to->integer.powerpc_regs.xer = from->Xer;
429 to->integer.powerpc_regs.cr = from->Cr;
430 }
431 if (flags & CONTEXT_FLOATING_POINT)
432 {
433 to->flags |= SERVER_CTX_FLOATING_POINT;
434 to->fp.powerpc_regs.fpr[0] = from->Fpr0;
435 to->fp.powerpc_regs.fpr[1] = from->Fpr1;
436 to->fp.powerpc_regs.fpr[2] = from->Fpr2;
437 to->fp.powerpc_regs.fpr[3] = from->Fpr3;
438 to->fp.powerpc_regs.fpr[4] = from->Fpr4;
439 to->fp.powerpc_regs.fpr[5] = from->Fpr5;
440 to->fp.powerpc_regs.fpr[6] = from->Fpr6;
441 to->fp.powerpc_regs.fpr[7] = from->Fpr7;
442 to->fp.powerpc_regs.fpr[8] = from->Fpr8;
443 to->fp.powerpc_regs.fpr[9] = from->Fpr9;
444 to->fp.powerpc_regs.fpr[10] = from->Fpr10;
445 to->fp.powerpc_regs.fpr[11] = from->Fpr11;
446 to->fp.powerpc_regs.fpr[12] = from->Fpr12;
447 to->fp.powerpc_regs.fpr[13] = from->Fpr13;
448 to->fp.powerpc_regs.fpr[14] = from->Fpr14;
449 to->fp.powerpc_regs.fpr[15] = from->Fpr15;
450 to->fp.powerpc_regs.fpr[16] = from->Fpr16;
451 to->fp.powerpc_regs.fpr[17] = from->Fpr17;
452 to->fp.powerpc_regs.fpr[18] = from->Fpr18;
453 to->fp.powerpc_regs.fpr[19] = from->Fpr19;
454 to->fp.powerpc_regs.fpr[20] = from->Fpr20;
455 to->fp.powerpc_regs.fpr[21] = from->Fpr21;
456 to->fp.powerpc_regs.fpr[22] = from->Fpr22;
457 to->fp.powerpc_regs.fpr[23] = from->Fpr23;
458 to->fp.powerpc_regs.fpr[24] = from->Fpr24;
459 to->fp.powerpc_regs.fpr[25] = from->Fpr25;
460 to->fp.powerpc_regs.fpr[26] = from->Fpr26;
461 to->fp.powerpc_regs.fpr[27] = from->Fpr27;
462 to->fp.powerpc_regs.fpr[28] = from->Fpr28;
463 to->fp.powerpc_regs.fpr[29] = from->Fpr29;
464 to->fp.powerpc_regs.fpr[30] = from->Fpr30;
465 to->fp.powerpc_regs.fpr[31] = from->Fpr31;
466 to->fp.powerpc_regs.fpscr = from->Fpscr;
467 }
468 return STATUS_SUCCESS;
469 }
470
471
472 /***********************************************************************
473 * context_from_server
474 *
475 * Convert a register context from the server format.
476 */
477 NTSTATUS context_from_server( CONTEXT *to, const context_t *from )
478 {
479 if (from->cpu != CPU_POWERPC) return STATUS_INVALID_PARAMETER;
480
481 to->ContextFlags = 0; /* no CPU id? */
482 if (from->flags & SERVER_CTX_CONTROL)
483 {
484 to->ContextFlags |= CONTEXT_CONTROL;
485 to->Msr = from->ctl.powerpc_regs.msr;
486 to->Ctr = from->ctl.powerpc_regs.ctr;
487 to->Iar = from->ctl.powerpc_regs.iar;
488 to->Lr = from->ctl.powerpc_regs.lr;
489 to->Dar = from->ctl.powerpc_regs.dar;
490 to->Dsisr = from->ctl.powerpc_regs.dsisr;
491 to->Trap = from->ctl.powerpc_regs.trap;
492 }
493 if (from->flags & SERVER_CTX_INTEGER)
494 {
495 to->ContextFlags |= CONTEXT_INTEGER;
496 to->Gpr0 = from->integer.powerpc_regs.gpr[0];
497 to->Gpr1 = from->integer.powerpc_regs.gpr[1];
498 to->Gpr2 = from->integer.powerpc_regs.gpr[2];
499 to->Gpr3 = from->integer.powerpc_regs.gpr[3];
500 to->Gpr4 = from->integer.powerpc_regs.gpr[4];
501 to->Gpr5 = from->integer.powerpc_regs.gpr[5];
502 to->Gpr6 = from->integer.powerpc_regs.gpr[6];
503 to->Gpr7 = from->integer.powerpc_regs.gpr[7];
504 to->Gpr8 = from->integer.powerpc_regs.gpr[8];
505 to->Gpr9 = from->integer.powerpc_regs.gpr[9];
506 to->Gpr10 = from->integer.powerpc_regs.gpr[10];
507 to->Gpr11 = from->integer.powerpc_regs.gpr[11];
508 to->Gpr12 = from->integer.powerpc_regs.gpr[12];
509 to->Gpr13 = from->integer.powerpc_regs.gpr[13];
510 to->Gpr14 = from->integer.powerpc_regs.gpr[14];
511 to->Gpr15 = from->integer.powerpc_regs.gpr[15];
512 to->Gpr16 = from->integer.powerpc_regs.gpr[16];
513 to->Gpr17 = from->integer.powerpc_regs.gpr[17];
514 to->Gpr18 = from->integer.powerpc_regs.gpr[18];
515 to->Gpr19 = from->integer.powerpc_regs.gpr[19];
516 to->Gpr20 = from->integer.powerpc_regs.gpr[20];
517 to->Gpr21 = from->integer.powerpc_regs.gpr[21];
518 to->Gpr22 = from->integer.powerpc_regs.gpr[22];
519 to->Gpr23 = from->integer.powerpc_regs.gpr[23];
520 to->Gpr24 = from->integer.powerpc_regs.gpr[24];
521 to->Gpr25 = from->integer.powerpc_regs.gpr[25];
522 to->Gpr26 = from->integer.powerpc_regs.gpr[26];
523 to->Gpr27 = from->integer.powerpc_regs.gpr[27];
524 to->Gpr28 = from->integer.powerpc_regs.gpr[28];
525 to->Gpr29 = from->integer.powerpc_regs.gpr[29];
526 to->Gpr30 = from->integer.powerpc_regs.gpr[30];
527 to->Gpr31 = from->integer.powerpc_regs.gpr[31];
528 to->Xer = from->integer.powerpc_regs.xer;
529 to->Cr = from->integer.powerpc_regs.cr;
530 }
531 if (from->flags & SERVER_CTX_FLOATING_POINT)
532 {
533 to->ContextFlags |= CONTEXT_FLOATING_POINT;
534 to->Fpr0 = from->fp.powerpc_regs.fpr[0];
535 to->Fpr1 = from->fp.powerpc_regs.fpr[1];
536 to->Fpr2 = from->fp.powerpc_regs.fpr[2];
537 to->Fpr3 = from->fp.powerpc_regs.fpr[3];
538 to->Fpr4 = from->fp.powerpc_regs.fpr[4];
539 to->Fpr5 = from->fp.powerpc_regs.fpr[5];
540 to->Fpr6 = from->fp.powerpc_regs.fpr[6];
541 to->Fpr7 = from->fp.powerpc_regs.fpr[7];
542 to->Fpr8 = from->fp.powerpc_regs.fpr[8];
543 to->Fpr9 = from->fp.powerpc_regs.fpr[9];
544 to->Fpr10 = from->fp.powerpc_regs.fpr[10];
545 to->Fpr11 = from->fp.powerpc_regs.fpr[11];
546 to->Fpr12 = from->fp.powerpc_regs.fpr[12];
547 to->Fpr13 = from->fp.powerpc_regs.fpr[13];
548 to->Fpr14 = from->fp.powerpc_regs.fpr[14];
549 to->Fpr15 = from->fp.powerpc_regs.fpr[15];
550 to->Fpr16 = from->fp.powerpc_regs.fpr[16];
551 to->Fpr17 = from->fp.powerpc_regs.fpr[17];
552 to->Fpr18 = from->fp.powerpc_regs.fpr[18];
553 to->Fpr19 = from->fp.powerpc_regs.fpr[19];
554 to->Fpr20 = from->fp.powerpc_regs.fpr[20];
555 to->Fpr21 = from->fp.powerpc_regs.fpr[21];
556 to->Fpr22 = from->fp.powerpc_regs.fpr[22];
557 to->Fpr23 = from->fp.powerpc_regs.fpr[23];
558 to->Fpr24 = from->fp.powerpc_regs.fpr[24];
559 to->Fpr25 = from->fp.powerpc_regs.fpr[25];
560 to->Fpr26 = from->fp.powerpc_regs.fpr[26];
561 to->Fpr27 = from->fp.powerpc_regs.fpr[27];
562 to->Fpr28 = from->fp.powerpc_regs.fpr[28];
563 to->Fpr29 = from->fp.powerpc_regs.fpr[29];
564 to->Fpr30 = from->fp.powerpc_regs.fpr[30];
565 to->Fpr31 = from->fp.powerpc_regs.fpr[31];
566 to->Fpscr = from->fp.powerpc_regs.fpscr;
567 }
568 return STATUS_SUCCESS;
569 }
570
571
572 /**********************************************************************
573 * call_stack_handlers
574 *
575 * Call the stack handlers chain.
576 */
577 static NTSTATUS call_stack_handlers( EXCEPTION_RECORD *rec, CONTEXT *context )
578 {
579 EXCEPTION_POINTERS ptrs;
580
581 FIXME( "not implemented on PowerPC\n" );
582
583 /* hack: call unhandled exception filter directly */
584 ptrs.ExceptionRecord = rec;
585 ptrs.ContextRecord = context;
586 unhandled_exception_filter( &ptrs );
587 return STATUS_UNHANDLED_EXCEPTION;
588 }
589
590
591 /*******************************************************************
592 * raise_exception
593 *
594 * Implementation of NtRaiseException.
595 */
596 static NTSTATUS raise_exception( EXCEPTION_RECORD *rec, CONTEXT *context, BOOL first_chance )
597 {
598 NTSTATUS status;
599
600 if (first_chance)
601 {
602 DWORD c;
603
604 TRACE( "code=%x flags=%x addr=%p ip=%x tid=%04x\n",
605 rec->ExceptionCode, rec->ExceptionFlags, rec->ExceptionAddress,
606 context->Iar, GetCurrentThreadId() );
607 for (c = 0; c < rec->NumberParameters; c++)
608 TRACE( " info[%d]=%08lx\n", c, rec->ExceptionInformation[c] );
609 if (rec->ExceptionCode == EXCEPTION_WINE_STUB)
610 {
611 if (rec->ExceptionInformation[1] >> 16)
612 MESSAGE( "wine: Call from %p to unimplemented function %s.%s, aborting\n",
613 rec->ExceptionAddress,
614 (char*)rec->ExceptionInformation[0], (char*)rec->ExceptionInformation[1] );
615 else
616 MESSAGE( "wine: Call from %p to unimplemented function %s.%ld, aborting\n",
617 rec->ExceptionAddress,
618 (char*)rec->ExceptionInformation[0], rec->ExceptionInformation[1] );
619 }
620 else
621 {
622 /* FIXME: dump context */
623 }
624
625 status = send_debug_event( rec, TRUE, context );
626 if (status == DBG_CONTINUE || status == DBG_EXCEPTION_HANDLED)
627 return STATUS_SUCCESS;
628
629 if (call_vectored_handlers( rec, context ) == EXCEPTION_CONTINUE_EXECUTION)
630 return STATUS_SUCCESS;
631
632 if ((status = call_stack_handlers( rec, context )) != STATUS_UNHANDLED_EXCEPTION)
633 return status;
634 }
635
636 /* last chance exception */
637
638 status = send_debug_event( rec, FALSE, context );
639 if (status != DBG_CONTINUE)
640 {
641 if (rec->ExceptionFlags & EH_STACK_INVALID)
642 ERR("Exception frame is not in stack limits => unable to dispatch exception.\n");
643 else if (rec->ExceptionCode == STATUS_NONCONTINUABLE_EXCEPTION)
644 ERR("Process attempted to continue execution after noncontinuable exception.\n");
645 else
646 ERR("Unhandled exception code %x flags %x addr %p\n",
647 rec->ExceptionCode, rec->ExceptionFlags, rec->ExceptionAddress );
648 NtTerminateProcess( NtCurrentProcess(), rec->ExceptionCode );
649 }
650 return STATUS_SUCCESS;
651 }
652
653
654 /**********************************************************************
655 * segv_handler
656 *
657 * Handler for SIGSEGV and related errors.
658 */
659 static void segv_handler( int signal, siginfo_t *siginfo, void *sigcontext )
660 {
661 EXCEPTION_RECORD rec;
662 CONTEXT context;
663 NTSTATUS status;
664
665 save_context( &context, sigcontext );
666
667 rec.ExceptionRecord = NULL;
668 rec.ExceptionFlags = EXCEPTION_CONTINUABLE;
669 rec.ExceptionAddress = (LPVOID)context.Iar;
670 rec.NumberParameters = 0;
671
672 switch (signal)
673 {
674 case SIGSEGV:
675 switch (siginfo->si_code & 0xffff)
676 {
677 case SEGV_MAPERR:
678 case SEGV_ACCERR:
679 rec.NumberParameters = 2;
680 rec.ExceptionInformation[0] = 0; /* FIXME ? */
681 rec.ExceptionInformation[1] = (ULONG_PTR)siginfo->si_addr;
682 if (!(rec.ExceptionCode = virtual_handle_fault(siginfo->si_addr, rec.ExceptionInformation[0])))
683 goto done;
684 break;
685 default:
686 FIXME("Unhandled SIGSEGV/%x\n",siginfo->si_code);
687 break;
688 }
689 break;
690 case SIGBUS:
691 switch (siginfo->si_code & 0xffff)
692 {
693 case BUS_ADRALN:
694 rec.ExceptionCode = EXCEPTION_DATATYPE_MISALIGNMENT;
695 break;
696 #ifdef BUS_ADRERR
697 case BUS_ADRERR:
698 #endif
699 #ifdef BUS_OBJERR
700 case BUS_OBJERR:
701 /* FIXME: correct for all cases ? */
702 rec.NumberParameters = 2;
703 rec.ExceptionInformation[0] = 0; /* FIXME ? */
704 rec.ExceptionInformation[1] = (ULONG_PTR)siginfo->si_addr;
705 if (!(rec.ExceptionCode = virtual_handle_fault(siginfo->si_addr, rec.ExceptionInformation[0])))
706 goto done;
707 break;
708 #endif
709 default:
710 FIXME("Unhandled SIGBUS/%x\n",siginfo->si_code);
711 break;
712 }
713 break;
714 case SIGILL:
715 switch (siginfo->si_code & 0xffff)
716 {
717 case ILL_ILLOPC: /* illegal opcode */
718 #ifdef ILL_ILLOPN
719 case ILL_ILLOPN: /* illegal operand */
720 #endif
721 #ifdef ILL_ILLADR
722 case ILL_ILLADR: /* illegal addressing mode */
723 #endif
724 #ifdef ILL_ILLTRP
725 case ILL_ILLTRP: /* illegal trap */
726 #endif
727 #ifdef ILL_COPROC
728 case ILL_COPROC: /* coprocessor error */
729 #endif
730 rec.ExceptionCode = EXCEPTION_ILLEGAL_INSTRUCTION;
731 break;
732 case ILL_PRVOPC: /* privileged opcode */
733 #ifdef ILL_PRVREG
734 case ILL_PRVREG: /* privileged register */
735 #endif
736 rec.ExceptionCode = EXCEPTION_PRIV_INSTRUCTION;
737 break;
738 #ifdef ILL_BADSTK
739 case ILL_BADSTK: /* internal stack error */
740 rec.ExceptionCode = EXCEPTION_STACK_OVERFLOW;
741 break;
742 #endif
743 default:
744 FIXME("Unhandled SIGILL/%x\n", siginfo->si_code);
745 break;
746 }
747 break;
748 }
749 status = raise_exception( &rec, &context, TRUE );
750 if (status) raise_status( status, &rec );
751 done:
752 restore_context( &context, sigcontext );
753 }
754
755 /**********************************************************************
756 * trap_handler
757 *
758 * Handler for SIGTRAP.
759 */
760 static void trap_handler( int signal, siginfo_t *siginfo, void *sigcontext )
761 {
762 EXCEPTION_RECORD rec;
763 CONTEXT context;
764 NTSTATUS status;
765
766 save_context( &context, sigcontext );
767
768 rec.ExceptionFlags = EXCEPTION_CONTINUABLE;
769 rec.ExceptionRecord = NULL;
770 rec.ExceptionAddress = (LPVOID)context.Iar;
771 rec.NumberParameters = 0;
772
773 /* FIXME: check if we might need to modify PC */
774 switch (siginfo->si_code & 0xffff)
775 {
776 #ifdef TRAP_BRKPT
777 case TRAP_BRKPT:
778 rec.ExceptionCode = EXCEPTION_BREAKPOINT;
779 break;
780 #endif
781 #ifdef TRAP_TRACE
782 case TRAP_TRACE:
783 rec.ExceptionCode = EXCEPTION_SINGLE_STEP;
784 break;
785 #endif
786 default:
787 FIXME("Unhandled SIGTRAP/%x\n", siginfo->si_code);
788 break;
789 }
790 status = raise_exception( &rec, &context, TRUE );
791 if (status) raise_status( status, &rec );
792 restore_context( &context, sigcontext );
793 }
794
795 /**********************************************************************
796 * fpe_handler
797 *
798 * Handler for SIGFPE.
799 */
800 static void fpe_handler( int signal, siginfo_t *siginfo, void *sigcontext )
801 {
802 EXCEPTION_RECORD rec;
803 CONTEXT context;
804 NTSTATUS status;
805
806 save_fpu( &context, sigcontext );
807 save_context( &context, sigcontext );
808
809 switch (siginfo->si_code & 0xffff )
810 {
811 #ifdef FPE_FLTSUB
812 case FPE_FLTSUB:
813 rec.ExceptionCode = EXCEPTION_ARRAY_BOUNDS_EXCEEDED;
814 break;
815 #endif
816 #ifdef FPE_INTDIV
817 case FPE_INTDIV:
818 rec.ExceptionCode = EXCEPTION_INT_DIVIDE_BY_ZERO;
819 break;
820 #endif
821 #ifdef FPE_INTOVF
822 case FPE_INTOVF:
823 rec.ExceptionCode = EXCEPTION_INT_OVERFLOW;
824 break;
825 #endif
826 #ifdef FPE_FLTDIV
827 case FPE_FLTDIV:
828 rec.ExceptionCode = EXCEPTION_FLT_DIVIDE_BY_ZERO;
829 break;
830 #endif
831 #ifdef FPE_FLTOVF
832 case FPE_FLTOVF:
833 rec.ExceptionCode = EXCEPTION_FLT_OVERFLOW;
834 break;
835 #endif
836 #ifdef FPE_FLTUND
837 case FPE_FLTUND:
838 rec.ExceptionCode = EXCEPTION_FLT_UNDERFLOW;
839 break;
840 #endif
841 #ifdef FPE_FLTRES
842 case FPE_FLTRES:
843 rec.ExceptionCode = EXCEPTION_FLT_INEXACT_RESULT;
844 break;
845 #endif
846 #ifdef FPE_FLTINV
847 case FPE_FLTINV:
848 #endif
849 default:
850 rec.ExceptionCode = EXCEPTION_FLT_INVALID_OPERATION;
851 break;
852 }
853 rec.ExceptionFlags = EXCEPTION_CONTINUABLE;
854 rec.ExceptionRecord = NULL;
855 rec.ExceptionAddress = (LPVOID)context.Iar;
856 rec.NumberParameters = 0;
857 status = raise_exception( &rec, &context, TRUE );
858 if (status) raise_status( status, &rec );
859
860 restore_context( &context, sigcontext );
861 restore_fpu( &context, sigcontext );
862 }
863
864 /**********************************************************************
865 * int_handler
866 *
867 * Handler for SIGINT.
868 */
869 static void int_handler( int signal, siginfo_t *siginfo, void *sigcontext )
870 {
871 if (!dispatch_signal(SIGINT))
872 {
873 EXCEPTION_RECORD rec;
874 CONTEXT context;
875 NTSTATUS status;
876
877 save_context( &context, sigcontext );
878 rec.ExceptionCode = CONTROL_C_EXIT;
879 rec.ExceptionFlags = EXCEPTION_CONTINUABLE;
880 rec.ExceptionRecord = NULL;
881 rec.ExceptionAddress = (LPVOID)context.Iar;
882 rec.NumberParameters = 0;
883 status = raise_exception( &rec, &context, TRUE );
884 if (status) raise_status( status, &rec );
885 restore_context( &context, sigcontext );
886 }
887 }
888
889
890 /**********************************************************************
891 * abrt_handler
892 *
893 * Handler for SIGABRT.
894 */
895 static void abrt_handler( int signal, siginfo_t *siginfo, void *sigcontext )
896 {
897 EXCEPTION_RECORD rec;
898 CONTEXT context;
899 NTSTATUS status;
900
901 save_context( &context, sigcontext );
902 rec.ExceptionCode = EXCEPTION_WINE_ASSERTION;
903 rec.ExceptionFlags = EH_NONCONTINUABLE;
904 rec.ExceptionRecord = NULL;
905 rec.ExceptionAddress = (LPVOID)context.Iar;
906 rec.NumberParameters = 0;
907 status = raise_exception( &rec, &context, TRUE );
908 if (status) raise_status( status, &rec );
909 restore_context( &context, sigcontext );
910 }
911
912
913 /**********************************************************************
914 * quit_handler
915 *
916 * Handler for SIGQUIT.
917 */
918 static void quit_handler( int signal, siginfo_t *siginfo, void *sigcontext )
919 {
920 abort_thread(0);
921 }
922
923
924 /**********************************************************************
925 * usr1_handler
926 *
927 * Handler for SIGUSR1, used to signal a thread that it got suspended.
928 */
929 static void usr1_handler( int signal, siginfo_t *siginfo, void *sigcontext )
930 {
931 CONTEXT context;
932
933 save_context( &context, sigcontext );
934 wait_suspend( &context );
935 restore_context( &context, sigcontext );
936 }
937
938
939 /***********************************************************************
940 * __wine_set_signal_handler (NTDLL.@)
941 */
942 int CDECL __wine_set_signal_handler(unsigned int sig, wine_signal_handler wsh)
943 {
944 if (sig > sizeof(handlers) / sizeof(handlers[0])) return -1;
945 if (handlers[sig] != NULL) return -2;
946 handlers[sig] = wsh;
947 return 0;
948 }
949
950
951 /**********************************************************************
952 * signal_alloc_thread
953 */
954 NTSTATUS signal_alloc_thread( TEB **teb )
955 {
956 static size_t sigstack_zero_bits;
957 SIZE_T size;
958 NTSTATUS status;
959
960 if (!sigstack_zero_bits)
961 {
962 size_t min_size = page_size; /* this is just for the TEB, we don't use a signal stack yet */
963 /* find the first power of two not smaller than min_size */
964 while ((1u << sigstack_zero_bits) < min_size) sigstack_zero_bits++;
965 assert( sizeof(TEB) <= min_size );
966 }
967
968 size = 1 << sigstack_zero_bits;
969 *teb = NULL;
970 if (!(status = NtAllocateVirtualMemory( NtCurrentProcess(), (void **)teb, sigstack_zero_bits,
971 &size, MEM_COMMIT | MEM_TOP_DOWN, PAGE_READWRITE )))
972 {
973 (*teb)->Tib.Self = &(*teb)->Tib;
974 (*teb)->Tib.ExceptionList = (void *)~0UL;
975 }
976 return status;
977 }
978
979
980 /**********************************************************************
981 * signal_free_thread
982 */
983 void signal_free_thread( TEB *teb )
984 {
985 SIZE_T size;
986
987 if (teb->DeallocationStack)
988 {
989 size = 0;
990 NtFreeVirtualMemory( GetCurrentProcess(), &teb->DeallocationStack, &size, MEM_RELEASE );
991 }
992 size = 0;
993 NtFreeVirtualMemory( NtCurrentProcess(), (void **)&teb, &size, MEM_RELEASE );
994 }
995
996
997 /**********************************************************************
998 * signal_init_thread
999 */
1000 void signal_init_thread( TEB *teb )
1001 {
1002 static BOOL init_done;
1003
1004 if (!init_done)
1005 {
1006 pthread_key_create( &teb_key, NULL );
1007 init_done = TRUE;
1008 }
1009 pthread_setspecific( teb_key, teb );
1010 }
1011
1012
1013 /**********************************************************************
1014 * signal_init_process
1015 */
1016 void signal_init_process(void)
1017 {
1018 struct sigaction sig_act;
1019
1020 sig_act.sa_mask = server_block_set;
1021 sig_act.sa_flags = SA_RESTART | SA_SIGINFO;
1022
1023 sig_act.sa_sigaction = int_handler;
1024 if (sigaction( SIGINT, &sig_act, NULL ) == -1) goto error;
1025 sig_act.sa_sigaction = fpe_handler;
1026 if (sigaction( SIGFPE, &sig_act, NULL ) == -1) goto error;
1027 sig_act.sa_sigaction = abrt_handler;
1028 if (sigaction( SIGABRT, &sig_act, NULL ) == -1) goto error;
1029 sig_act.sa_sigaction = quit_handler;
1030 if (sigaction( SIGQUIT, &sig_act, NULL ) == -1) goto error;
1031 sig_act.sa_sigaction = usr1_handler;
1032 if (sigaction( SIGUSR1, &sig_act, NULL ) == -1) goto error;
1033
1034 sig_act.sa_sigaction = segv_handler;
1035 if (sigaction( SIGSEGV, &sig_act, NULL ) == -1) goto error;
1036 if (sigaction( SIGILL, &sig_act, NULL ) == -1) goto error;
1037 #ifdef SIGBUS
1038 if (sigaction( SIGBUS, &sig_act, NULL ) == -1) goto error;
1039 #endif
1040
1041 #ifdef SIGTRAP
1042 sig_act.sa_sigaction = trap_handler;
1043 if (sigaction( SIGTRAP, &sig_act, NULL ) == -1) goto error;
1044 #endif
1045 return;
1046
1047 error:
1048 perror("sigaction");
1049 exit(1);
1050 }
1051
1052
1053 /**********************************************************************
1054 * __wine_enter_vm86 (NTDLL.@)
1055 */
1056 void __wine_enter_vm86( CONTEXT *context )
1057 {
1058 MESSAGE("vm86 mode not supported on this platform\n");
1059 }
1060
1061 /***********************************************************************
1062 * RtlUnwind (NTDLL.@)
1063 */
1064 void WINAPI RtlUnwind( PVOID pEndFrame, PVOID targetIp, PEXCEPTION_RECORD pRecord, PVOID retval )
1065 {
1066 FIXME( "Not implemented on PowerPC\n" );
1067 }
1068
1069 /*******************************************************************
1070 * NtRaiseException (NTDLL.@)
1071 */
1072 NTSTATUS WINAPI NtRaiseException( EXCEPTION_RECORD *rec, CONTEXT *context, BOOL first_chance )
1073 {
1074 NTSTATUS status = raise_exception( rec, context, first_chance );
1075 if (status == STATUS_SUCCESS) NtSetContextThread( GetCurrentThread(), context );
1076 return status;
1077 }
1078
1079 /***********************************************************************
1080 * RtlRaiseException (NTDLL.@)
1081 */
1082 void WINAPI RtlRaiseException( EXCEPTION_RECORD *rec )
1083 {
1084 CONTEXT context;
1085 NTSTATUS status;
1086
1087 RtlCaptureContext( &context );
1088 rec->ExceptionAddress = (void *)context.Iar;
1089 status = raise_exception( rec, &context, TRUE );
1090 if (status) raise_status( status, rec );
1091 }
1092
1093 /*************************************************************************
1094 * RtlCaptureStackBackTrace (NTDLL.@)
1095 */
1096 USHORT WINAPI RtlCaptureStackBackTrace( ULONG skip, ULONG count, PVOID *buffer, ULONG *hash )
1097 {
1098 FIXME( "(%d, %d, %p, %p) stub!\n", skip, count, buffer, hash );
1099 return 0;
1100 }
1101
1102 /***********************************************************************
1103 * call_thread_entry_point
1104 */
1105 void call_thread_entry_point( LPTHREAD_START_ROUTINE entry, void *arg )
1106 {
1107 __TRY
1108 {
1109 exit_thread( entry( arg ));
1110 }
1111 __EXCEPT(unhandled_exception_filter)
1112 {
1113 NtTerminateThread( GetCurrentThread(), GetExceptionCode() );
1114 }
1115 __ENDTRY
1116 abort(); /* should not be reached */
1117 }
1118
1119 /***********************************************************************
1120 * RtlExitUserThread (NTDLL.@)
1121 */
1122 void WINAPI RtlExitUserThread( ULONG status )
1123 {
1124 exit_thread( status );
1125 }
1126
1127 /***********************************************************************
1128 * abort_thread
1129 */
1130 void abort_thread( int status )
1131 {
1132 terminate_thread( status );
1133 }
1134
1135 /**********************************************************************
1136 * DbgBreakPoint (NTDLL.@)
1137 */
1138 void WINAPI DbgBreakPoint(void)
1139 {
1140 kill(getpid(), SIGTRAP);
1141 }
1142
1143 /**********************************************************************
1144 * DbgUserBreakPoint (NTDLL.@)
1145 */
1146 void WINAPI DbgUserBreakPoint(void)
1147 {
1148 kill(getpid(), SIGTRAP);
1149 }
1150
1151 /**********************************************************************
1152 * NtCurrentTeb (NTDLL.@)
1153 */
1154 TEB * WINAPI NtCurrentTeb(void)
1155 {
1156 return pthread_getspecific( teb_key );
1157 }
1158
1159 #endif /* __powerpc__ */
Windows API implementation