69
65
# if defined(SPARC) || defined(IA64)
70
66
/* Value returned from register flushing routine; either sp (SPARC) */
71
67
/* or ar.bsp (IA64) */
72
word GC_save_regs_ret_val;
68
ptr_t GC_save_regs_ret_val;
75
71
/* Routine to mark from registers that are preserved by the C compiler. */
76
/* This must be ported to every new architecture. There is a generic */
77
/* version at the end, that is likely, but not guaranteed to work */
78
/* on your architecture. Run the test_setjmp program to see whether */
79
/* there is any chance it will work. */
72
/* This must be ported to every new architecture. It is noe optional, */
73
/* and should not be used on platforms that are either UNIX-like, or */
74
/* require thread support. */
81
#if !defined(USE_GENERIC_PUSH_REGS) && !defined(USE_ASM_PUSH_REGS)
82
76
#undef HAVE_PUSH_REGS
78
#if defined(USE_ASM_PUSH_REGS)
79
# define HAVE_PUSH_REGS
80
#else /* No asm implementation */
83
81
void GC_push_regs()
86
register long TMP_SP; /* must be bound to r11 */
90
/* VAX - generic code below does not work under 4.2 */
91
/* r1 through r5 are caller save, and therefore */
92
/* on the stack or dead. */
93
asm("pushl r11"); asm("calls $1,_GC_push_one");
94
asm("pushl r10"); asm("calls $1,_GC_push_one");
95
asm("pushl r9"); asm("calls $1,_GC_push_one");
96
asm("pushl r8"); asm("calls $1,_GC_push_one");
97
asm("pushl r7"); asm("calls $1,_GC_push_one");
98
asm("pushl r6"); asm("calls $1,_GC_push_one");
99
# define HAVE_PUSH_REGS
101
# if defined(M68K) && (defined(SUNOS4) || defined(NEXT))
102
/* M68K SUNOS - could be replaced by generic code */
103
/* a0, a1 and d1 are caller save */
104
/* and therefore are on stack or dead. */
106
asm("subqw #0x4,sp"); /* allocate word on top of stack */
108
asm("movl a2,sp@"); asm("jbsr _GC_push_one");
109
asm("movl a3,sp@"); asm("jbsr _GC_push_one");
110
asm("movl a4,sp@"); asm("jbsr _GC_push_one");
111
asm("movl a5,sp@"); asm("jbsr _GC_push_one");
112
/* Skip frame pointer and stack pointer */
113
asm("movl d1,sp@"); asm("jbsr _GC_push_one");
114
asm("movl d2,sp@"); asm("jbsr _GC_push_one");
115
asm("movl d3,sp@"); asm("jbsr _GC_push_one");
116
asm("movl d4,sp@"); asm("jbsr _GC_push_one");
117
asm("movl d5,sp@"); asm("jbsr _GC_push_one");
118
asm("movl d6,sp@"); asm("jbsr _GC_push_one");
119
asm("movl d7,sp@"); asm("jbsr _GC_push_one");
121
asm("addqw #0x4,sp"); /* put stack back where it was */
122
# define HAVE_PUSH_REGS
125
# if defined(M68K) && defined(HP)
126
/* M68K HP - could be replaced by generic code */
127
/* a0, a1 and d1 are caller save. */
129
asm("subq.w &0x4,%sp"); /* allocate word on top of stack */
131
asm("mov.l %a2,(%sp)"); asm("jsr _GC_push_one");
132
asm("mov.l %a3,(%sp)"); asm("jsr _GC_push_one");
133
asm("mov.l %a4,(%sp)"); asm("jsr _GC_push_one");
134
asm("mov.l %a5,(%sp)"); asm("jsr _GC_push_one");
135
/* Skip frame pointer and stack pointer */
136
asm("mov.l %d1,(%sp)"); asm("jsr _GC_push_one");
137
asm("mov.l %d2,(%sp)"); asm("jsr _GC_push_one");
138
asm("mov.l %d3,(%sp)"); asm("jsr _GC_push_one");
139
asm("mov.l %d4,(%sp)"); asm("jsr _GC_push_one");
140
asm("mov.l %d5,(%sp)"); asm("jsr _GC_push_one");
141
asm("mov.l %d6,(%sp)"); asm("jsr _GC_push_one");
142
asm("mov.l %d7,(%sp)"); asm("jsr _GC_push_one");
144
asm("addq.w &0x4,%sp"); /* put stack back where it was */
145
# define HAVE_PUSH_REGS
146
# endif /* M68K HP */
148
83
# if defined(M68K) && defined(AMIGA)
149
84
/* AMIGA - could be replaced by generic code */
150
85
/* a0, a1, d0 and d1 are caller save */
214
149
# define HAVE_PUSH_REGS
215
150
# endif /* __MWERKS__ */
216
151
# endif /* MACOS */
218
# if defined(I386) &&!defined(OS2) &&!defined(SVR4) \
219
&& (defined(__MINGW32__) || !defined(MSWIN32)) \
220
&& !defined(SCO) && !defined(SCO_ELF) \
221
&& !(defined(LINUX) && defined(__ELF__)) \
222
&& !(defined(FREEBSD) && defined(__ELF__)) \
223
&& !(defined(NETBSD) && defined(__ELF__)) \
224
&& !(defined(OPENBSD) && defined(__ELF__)) \
225
&& !(defined(BEOS) && defined(__ELF__)) \
226
&& !defined(DOS4GW) && !defined(HURD)
227
/* I386 code, generic code does not appear to work */
228
/* It does appear to work under OS2, and asms dont */
229
/* This is used for some 38g UNIX variants and for CYGWIN32 */
230
asm("pushl %eax"); asm("call _GC_push_one"); asm("addl $4,%esp");
231
asm("pushl %ecx"); asm("call _GC_push_one"); asm("addl $4,%esp");
232
asm("pushl %edx"); asm("call _GC_push_one"); asm("addl $4,%esp");
233
asm("pushl %ebp"); asm("call _GC_push_one"); asm("addl $4,%esp");
234
asm("pushl %esi"); asm("call _GC_push_one"); asm("addl $4,%esp");
235
asm("pushl %edi"); asm("call _GC_push_one"); asm("addl $4,%esp");
236
asm("pushl %ebx"); asm("call _GC_push_one"); asm("addl $4,%esp");
237
# define HAVE_PUSH_REGS
240
# if ( defined(I386) && defined(LINUX) && defined(__ELF__) ) \
241
|| ( defined(I386) && defined(FREEBSD) && defined(__ELF__) ) \
242
|| ( defined(I386) && defined(NETBSD) && defined(__ELF__) ) \
243
|| ( defined(I386) && defined(OPENBSD) && defined(__ELF__) ) \
244
|| ( defined(I386) && defined(HURD) && defined(__ELF__) ) \
245
|| ( defined(I386) && defined(DGUX) )
247
/* This is modified for Linux with ELF (Note: _ELF_ only) */
248
/* This section handles FreeBSD with ELF. */
249
/* Eax is caller-save and dead here. Other caller-save */
250
/* registers could also be skipped. We assume there are no */
251
/* pointers in MMX registers, etc. */
252
/* We combine instructions in a single asm to prevent gcc from */
253
/* inserting code in the middle. */
254
asm("pushl %ecx; call GC_push_one; addl $4,%esp");
255
asm("pushl %edx; call GC_push_one; addl $4,%esp");
256
asm("pushl %ebp; call GC_push_one; addl $4,%esp");
257
asm("pushl %esi; call GC_push_one; addl $4,%esp");
258
asm("pushl %edi; call GC_push_one; addl $4,%esp");
259
asm("pushl %ebx; call GC_push_one; addl $4,%esp");
260
# define HAVE_PUSH_REGS
263
# if ( defined(I386) && defined(BEOS) && defined(__ELF__) )
264
/* As far as I can understand from */
265
/* http://www.beunited.org/articles/jbq/nasm.shtml, */
266
/* only ebp, esi, edi and ebx are not scratch. How MMX */
267
/* etc. registers should be treated, I have no idea. */
268
asm("pushl %ebp; call GC_push_one; addl $4,%esp");
269
asm("pushl %esi; call GC_push_one; addl $4,%esp");
270
asm("pushl %edi; call GC_push_one; addl $4,%esp");
271
asm("pushl %ebx; call GC_push_one; addl $4,%esp");
272
# define HAVE_PUSH_REGS
275
# if defined(I386) && defined(MSWIN32) && !defined(__MINGW32__) \
276
&& !defined(USE_GENERIC)
277
/* I386 code, Microsoft variant */
279
__asm call GC_push_one
282
__asm call GC_push_one
285
__asm call GC_push_one
288
__asm call GC_push_one
291
__asm call GC_push_one
294
__asm call GC_push_one
297
__asm call GC_push_one
299
# define HAVE_PUSH_REGS
302
# if defined(I386) && (defined(SVR4) || defined(SCO) || defined(SCO_ELF))
303
/* I386 code, SVR4 variant, generic code does not appear to work */
304
asm("pushl %eax"); asm("call GC_push_one"); asm("addl $4,%esp");
305
asm("pushl %ebx"); asm("call GC_push_one"); asm("addl $4,%esp");
306
asm("pushl %ecx"); asm("call GC_push_one"); asm("addl $4,%esp");
307
asm("pushl %edx"); asm("call GC_push_one"); asm("addl $4,%esp");
308
asm("pushl %ebp"); asm("call GC_push_one"); asm("addl $4,%esp");
309
asm("pushl %esi"); asm("call GC_push_one"); asm("addl $4,%esp");
310
asm("pushl %edi"); asm("call GC_push_one"); asm("addl $4,%esp");
311
# define HAVE_PUSH_REGS
315
asm ("movd r3, tos"); asm ("bsr ?_GC_push_one"); asm ("adjspb $-4");
316
asm ("movd r4, tos"); asm ("bsr ?_GC_push_one"); asm ("adjspb $-4");
317
asm ("movd r5, tos"); asm ("bsr ?_GC_push_one"); asm ("adjspb $-4");
318
asm ("movd r6, tos"); asm ("bsr ?_GC_push_one"); asm ("adjspb $-4");
319
asm ("movd r7, tos"); asm ("bsr ?_GC_push_one"); asm ("adjspb $-4");
320
# define HAVE_PUSH_REGS
324
GC_save_regs_ret_val = GC_save_regs_in_stack();
325
# define HAVE_PUSH_REGS
329
GC_push_one(TMP_SP); /* GC_push_one from r11 */
331
asm("cas r11, r6, r0"); GC_push_one(TMP_SP); /* r6 */
332
asm("cas r11, r7, r0"); GC_push_one(TMP_SP); /* through */
333
asm("cas r11, r8, r0"); GC_push_one(TMP_SP); /* r10 */
334
asm("cas r11, r9, r0"); GC_push_one(TMP_SP);
335
asm("cas r11, r10, r0"); GC_push_one(TMP_SP);
337
asm("cas r11, r12, r0"); GC_push_one(TMP_SP); /* r12 */
338
asm("cas r11, r13, r0"); GC_push_one(TMP_SP); /* through */
339
asm("cas r11, r14, r0"); GC_push_one(TMP_SP); /* r15 */
340
asm("cas r11, r15, r0"); GC_push_one(TMP_SP);
341
# define HAVE_PUSH_REGS
344
# if defined(M68K) && defined(SYSV)
345
/* Once again similar to SUN and HP, though setjmp appears to work.
349
asm("subqw #0x4,%sp"); /* allocate word on top of stack */
351
asm("movl %a2,%sp@"); asm("jbsr GC_push_one");
352
asm("movl %a3,%sp@"); asm("jbsr GC_push_one");
353
asm("movl %a4,%sp@"); asm("jbsr GC_push_one");
354
asm("movl %a5,%sp@"); asm("jbsr GC_push_one");
355
/* Skip frame pointer and stack pointer */
356
asm("movl %d1,%sp@"); asm("jbsr GC_push_one");
357
asm("movl %d2,%sp@"); asm("jbsr GC_push_one");
358
asm("movl %d3,%sp@"); asm("jbsr GC_push_one");
359
asm("movl %d4,%sp@"); asm("jbsr GC_push_one");
360
asm("movl %d5,%sp@"); asm("jbsr GC_push_one");
361
asm("movl %d6,%sp@"); asm("jbsr GC_push_one");
362
asm("movl %d7,%sp@"); asm("jbsr GC_push_one");
364
asm("addqw #0x4,%sp"); /* put stack back where it was */
365
# define HAVE_PUSH_REGS
366
# else /* !__GNUC__*/
367
asm("subq.w &0x4,%sp"); /* allocate word on top of stack */
369
asm("mov.l %a2,(%sp)"); asm("jsr GC_push_one");
370
asm("mov.l %a3,(%sp)"); asm("jsr GC_push_one");
371
asm("mov.l %a4,(%sp)"); asm("jsr GC_push_one");
372
asm("mov.l %a5,(%sp)"); asm("jsr GC_push_one");
373
/* Skip frame pointer and stack pointer */
374
asm("mov.l %d1,(%sp)"); asm("jsr GC_push_one");
375
asm("mov.l %d2,(%sp)"); asm("jsr GC_push_one");
376
asm("mov.l %d3,(%sp)"); asm("jsr GC_push_one");
377
asm("mov.l %d4,(%sp)"); asm("jsr GC_push_one");
378
asm("mov.l %d5,(%sp)"); asm("jsr GC_push_one");
379
asm("mov.l %d6,(%sp)"); asm("jsr GC_push_one");
380
asm("mov.l %d7,(%sp)"); asm("jsr GC_push_one");
382
asm("addq.w &0x4,%sp"); /* put stack back where it was */
383
# define HAVE_PUSH_REGS
384
# endif /* !__GNUC__ */
385
# endif /* M68K/SYSV */
389
register int * sp asm ("optop");
390
extern int *__libc_stack_end;
392
GC_push_all_stack (sp, __libc_stack_end);
393
# define HAVE_PUSH_REGS
394
/* Isn't this redundant with the code to push the stack? */
153
#endif /* !USE_ASM_PUSH_REGS */
155
#if defined(HAVE_PUSH_REGS) && defined(THREADS)
156
# error GC_push_regs cannot be used with threads
157
/* Would fail for GC_do_blocking. There are probably other safety */
159
# undef HAVE_PUSH_REGS
162
#if !defined(HAVE_PUSH_REGS) && defined(UNIX_LIKE)
163
# include <ucontext.h>
166
/* Ensure that either registers are pushed, or callee-save registers */
167
/* are somewhere on the stack, and then call fn(arg, ctxt). */
168
/* ctxt is either a pointer to a ucontext_t we generated, or NULL. */
169
void GC_with_callee_saves_pushed(void (*fn)(ptr_t, void *),
175
# if defined(HAVE_PUSH_REGS)
177
# elif defined(UNIX_LIKE) && !defined(DARWIN) && !defined(ARM32) && \
178
!defined(HURD) && !defined(AVR32)
179
/* Older versions of Darwin seem to lack getcontext(). */
180
/* ARM Linux often doesn't support a real getcontext(). */
182
if (getcontext(&ctxt) < 0)
183
ABORT ("Getcontext failed: Use another register retrieval method?");
185
# if defined(SPARC) || defined(IA64)
186
/* On a register window machine, we need to save register */
187
/* contents on the stack for this to work. This may already be */
188
/* subsumed by the getcontext() call. */
190
GC_save_regs_ret_val = GC_save_regs_in_stack();
398
/* other machines... */
399
# if !defined(HAVE_PUSH_REGS)
400
--> We just generated an empty GC_push_regs, which
401
--> is almost certainly broken. Try defining
402
--> USE_GENERIC_PUSH_REGS instead.
405
#endif /* !USE_GENERIC_PUSH_REGS && !USE_ASM_PUSH_REGS */
407
void GC_with_callee_saves_pushed(fn, arg)
413
# if defined(USE_GENERIC_PUSH_REGS)
414
# ifdef HAVE_BUILTIN_UNWIND_INIT
415
/* This was suggested by Richard Henderson as the way to */
416
/* force callee-save registers and register windows onto */
418
__builtin_unwind_init();
419
# else /* !HAVE_BUILTIN_UNWIND_INIT */
420
# if defined(RS6000) || defined(POWERPC)
421
/* FIXME: RS6000 means AIX. */
422
/* This should probably be used in all Posix/non-gcc */
423
/* settings. We defer that change to minimize risk. */
192
# endif /* register windows. */
193
# elif defined(HAVE_BUILTIN_UNWIND_INIT)
194
/* This was suggested by Richard Henderson as the way to */
195
/* force callee-save registers and register windows onto */
197
__builtin_unwind_init();
198
# else /* !HAVE_BUILTIN_UNWIND_INIT && !UNIX_LIKE */
199
/* && !HAVE_PUSH_REGS */
427
200
/* Generic code */
428
201
/* The idea is due to Parag Patel at HP. */
429
202
/* We're not sure whether he would like */
441
214
|| defined(UTS4) || defined(LINUX) || defined(EWS4800)
442
215
(void) setjmp(regs);
444
(void) _setjmp(regs);
217
(void) _setjmp(regs);
445
218
/* We don't want to mess with signals. According to */
446
219
/* SUSV3, setjmp() may or may not save signal mask. */
447
220
/* _setjmp won't, but is less portable. */
449
# endif /* !AIX ... */
450
# endif /* !HAVE_BUILTIN_UNWIND_INIT */
452
# if defined(PTHREADS) && !defined(MSWIN32) /* !USE_GENERIC_PUSH_REGS */
453
/* We may still need this to save thread contexts. */
456
# else /* Shouldn't be needed */
457
ABORT("Unexpected call to GC_with_callee_saves_pushed");
460
# if (defined(SPARC) && !defined(HAVE_BUILTIN_UNWIND_INIT)) \
462
/* On a register window machine, we need to save register */
463
/* contents on the stack for this to work. The setjmp */
464
/* is probably not needed on SPARC, since pointers are */
465
/* only stored in windowed or scratch registers. It is */
466
/* needed on IA64, since some non-windowed registers are */
469
GC_save_regs_ret_val = GC_save_regs_in_stack();
470
/* On IA64 gcc, could use __builtin_ia64_flushrs() and */
471
/* __builtin_ia64_flushrs(). The latter will be done */
472
/* implicitly by __builtin_unwind_init() for gcc3.0.1 */
222
# endif /* !HAVE_PUSH_REGS ... */
223
/* FIXME: context here is sometimes just zero. At the moment the callees */
224
/* don't really need it. */
477
226
/* Strongly discourage the compiler from treating the above */
478
227
/* as a tail-call, since that would pop the register */
479
228
/* contents before we get a chance to look at them. */
480
229
GC_noop1((word)(&dummy));
483
#if defined(USE_GENERIC_PUSH_REGS)
484
void GC_generic_push_regs(cold_gc_frame)
232
void GC_push_regs_and_stack(ptr_t cold_gc_frame)
487
234
GC_with_callee_saves_pushed(GC_push_current_stack, cold_gc_frame);
489
#endif /* USE_GENERIC_PUSH_REGS */
491
/* On register window machines, we need a way to force registers into */
492
/* the stack. Return sp. */
494
asm(" .seg \"text\"");
495
# if defined(SVR4) || defined(NETBSD) || defined(FREEBSD)
496
asm(" .globl GC_save_regs_in_stack");
497
asm("GC_save_regs_in_stack:");
498
asm(" .type GC_save_regs_in_stack,#function");
500
asm(" .globl _GC_save_regs_in_stack");
501
asm("_GC_save_regs_in_stack:");
503
# if defined(__arch64__) || defined(__sparcv9)
504
asm(" save %sp,-128,%sp");
507
asm(" restore %sp,2047+128,%o0");
509
asm(" ta 0x3 ! ST_FLUSH_WINDOWS");
514
asm(" .GC_save_regs_in_stack_end:");
515
asm(" .size GC_save_regs_in_stack,.GC_save_regs_in_stack_end-GC_save_regs_in_stack");
518
word GC_save_regs_in_stack() { return(0 /* sp really */);}
522
/* On IA64, we also need to flush register windows. But they end */
523
/* up on the other side of the stack segment. */
524
/* Returns the backing store pointer for the register stack. */
525
/* We now implement this as a separate assembly file, since inline */
526
/* assembly code here doesn't work with either the Intel or HP */
537
asm(" .global GC_save_regs_in_stack");
538
asm(" .proc GC_save_regs_in_stack");
539
asm("GC_save_regs_in_stack:");
543
asm(" mov r8=ar.bsp");
544
asm(" br.ret.sptk.few rp");
545
asm(" .endp GC_save_regs_in_stack");
547
# if 0 /* Other alternatives that don't work on HP/UX */
548
word GC_save_regs_in_stack() {
550
__builtin_ia64_flushrs();
551
return __builtin_ia64_bsp();
556
_asm(" mov r8=ar.bsp");
557
_asm(" br.ret.sptk.few rp");
561
asm(" mov r8=ar.bsp");
562
asm(" br.ret.sptk.few rp");
569
/* GC_clear_stack_inner(arg, limit) clears stack area up to limit and */
570
/* returns arg. Stack clearing is crucial on SPARC, so we supply */
571
/* an assembly version that's more careful. Assumes limit is hotter */
572
/* than sp, and limit is 8 byte aligned. */
573
237
#if defined(ASM_CLEAR_CODE)
578
asm(".globl _GC_clear_stack_inner");
579
asm("_GC_clear_stack_inner:");
581
asm(".globl GC_clear_stack_inner");
582
asm("GC_clear_stack_inner:");
583
asm(".type GC_save_regs_in_stack,#function");
585
#if defined(__arch64__) || defined(__sparcv9)
586
asm("mov %sp,%o2"); /* Save sp */
587
asm("add %sp,2047-8,%o3"); /* p = sp+bias-8 */
588
asm("add %o1,-2047-192,%sp"); /* Move sp out of the way, */
589
/* so that traps still work. */
590
/* Includes some extra words */
591
/* so we can be sloppy below. */
593
asm("stx %g0,[%o3]"); /* *(long *)p = 0 */
595
asm("bgu,pt %xcc, loop"); /* if (p > limit) goto loop */
596
asm("add %o3,-8,%o3"); /* p -= 8 (delay slot) */
598
asm("mov %o2,%sp"); /* Restore sp., delay slot */
600
asm("mov %sp,%o2"); /* Save sp */
601
asm("add %sp,-8,%o3"); /* p = sp-8 */
602
asm("clr %g1"); /* [g0,g1] = 0 */
603
asm("add %o1,-0x60,%sp"); /* Move sp out of the way, */
604
/* so that traps still work. */
605
/* Includes some extra words */
606
/* so we can be sloppy below. */
608
asm("std %g0,[%o3]"); /* *(long long *)p = 0 */
610
asm("bgu loop "); /* if (p > limit) goto loop */
611
asm("add %o3,-8,%o3"); /* p -= 8 (delay slot) */
613
asm("mov %o2,%sp"); /* Restore sp., delay slot */
614
#endif /* old SPARC */
615
/* First argument = %o0 = return value */
617
asm(" .GC_clear_stack_inner_end:");
618
asm(" .size GC_clear_stack_inner,.GC_clear_stack_inner_end-GC_clear_stack_inner");
623
240
ptr_t GC_clear_stack_inner(arg, limit)
624
241
ptr_t arg; word limit;
243
/* The real version is in a .S file */
245
#endif /* ASM_CLEAR_CODE */
added
removed
mach_dep.c
