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