OpenCores
URL https://opencores.org/ocsvn/openrisc/openrisc/trunk

Subversion Repositories openrisc

[/] [openrisc/] [trunk/] [gnu-dev/] [or1k-gcc/] [libgcc/] [generic-morestack.c] - Blame information for rev 772

Go to most recent revision | Details | Compare with Previous | View Log

Line No. Rev Author Line
1 734 jeremybenn
/* Library support for -fsplit-stack.  */
2
/* Copyright (C) 2009, 2010, 2011 Free Software Foundation, Inc.
3
   Contributed by Ian Lance Taylor <iant@google.com>.
4
 
5
This file is part of GCC.
6
 
7
GCC is free software; you can redistribute it and/or modify it under
8
the terms of the GNU General Public License as published by the Free
9
Software Foundation; either version 3, or (at your option) any later
10
version.
11
 
12
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
13
WARRANTY; without even the implied warranty of MERCHANTABILITY or
14
FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
15
for more details.
16
 
17
Under Section 7 of GPL version 3, you are granted additional
18
permissions described in the GCC Runtime Library Exception, version
19
3.1, as published by the Free Software Foundation.
20
 
21
You should have received a copy of the GNU General Public License and
22
a copy of the GCC Runtime Library Exception along with this program;
23
see the files COPYING3 and COPYING.RUNTIME respectively.  If not, see
24
<http://www.gnu.org/licenses/>.  */
25
 
26
#include "tconfig.h"
27
#include "tsystem.h"
28
#include "coretypes.h"
29
#include "tm.h"
30
#include "libgcc_tm.h"
31
 
32
/* If inhibit_libc is defined, we can not compile this file.  The
33
   effect is that people will not be able to use -fsplit-stack.  That
34
   is much better than failing the build particularly since people
35
   will want to define inhibit_libc while building a compiler which
36
   can build glibc.  */
37
 
38
#ifndef inhibit_libc
39
 
40
#include <assert.h>
41
#include <errno.h>
42
#include <signal.h>
43
#include <stdlib.h>
44
#include <string.h>
45
#include <unistd.h>
46
#include <sys/mman.h>
47
#include <sys/uio.h>
48
 
49
#include "generic-morestack.h"
50
 
51
typedef unsigned uintptr_type __attribute__ ((mode (pointer)));
52
 
53
/* This file contains subroutines that are used by code compiled with
54
   -fsplit-stack.  */
55
 
56
/* Declare functions to avoid warnings--there is no header file for
57
   these internal functions.  We give most of these functions the
58
   flatten attribute in order to minimize their stack usage--here we
59
   must minimize stack usage even at the cost of code size, and in
60
   general inlining everything will do that.  */
61
 
62
extern void
63
__generic_morestack_set_initial_sp (void *sp, size_t len)
64
  __attribute__ ((no_split_stack, flatten, visibility ("hidden")));
65
 
66
extern void *
67
__generic_morestack (size_t *frame_size, void *old_stack, size_t param_size)
68
  __attribute__ ((no_split_stack, flatten, visibility ("hidden")));
69
 
70
extern void *
71
__generic_releasestack (size_t *pavailable)
72
  __attribute__ ((no_split_stack, flatten, visibility ("hidden")));
73
 
74
extern void
75
__morestack_block_signals (void)
76
  __attribute__ ((no_split_stack, flatten, visibility ("hidden")));
77
 
78
extern void
79
__morestack_unblock_signals (void)
80
  __attribute__ ((no_split_stack, flatten, visibility ("hidden")));
81
 
82
extern size_t
83
__generic_findstack (void *stack)
84
  __attribute__ ((no_split_stack, flatten, visibility ("hidden")));
85
 
86
extern void
87
__morestack_load_mmap (void)
88
  __attribute__ ((no_split_stack, visibility ("hidden")));
89
 
90
extern void *
91
__morestack_allocate_stack_space (size_t size)
92
  __attribute__ ((visibility ("hidden")));
93
 
94
/* These are functions which -fsplit-stack code can call.  These are
95
   not called by the compiler, and are not hidden.  FIXME: These
96
   should be in some header file somewhere, somehow.  */
97
 
98
extern void *
99
__splitstack_find (void *, void *, size_t *, void **, void **, void **)
100
  __attribute__ ((visibility ("default")));
101
 
102
extern void
103
__splitstack_block_signals (int *, int *)
104
  __attribute__ ((visibility ("default")));
105
 
106
extern void
107
__splitstack_getcontext (void *context[10])
108
  __attribute__ ((no_split_stack, visibility ("default")));
109
 
110
extern void
111
__splitstack_setcontext (void *context[10])
112
  __attribute__ ((no_split_stack, visibility ("default")));
113
 
114
extern void *
115
__splitstack_makecontext (size_t, void *context[10], size_t *)
116
  __attribute__ ((visibility ("default")));
117
 
118
extern void *
119
__splitstack_resetcontext (void *context[10], size_t *)
120
  __attribute__ ((visibility ("default")));
121
 
122
extern void
123
__splitstack_releasecontext (void *context[10])
124
  __attribute__ ((visibility ("default")));
125
 
126
extern void
127
__splitstack_block_signals_context (void *context[10], int *, int *)
128
  __attribute__ ((visibility ("default")));
129
 
130
extern void *
131
__splitstack_find_context (void *context[10], size_t *, void **, void **,
132
                           void **)
133
  __attribute__ ((visibility ("default")));
134
 
135
/* These functions must be defined by the processor specific code.  */
136
 
137
extern void *__morestack_get_guard (void)
138
  __attribute__ ((no_split_stack, visibility ("hidden")));
139
 
140
extern void __morestack_set_guard (void *)
141
  __attribute__ ((no_split_stack, visibility ("hidden")));
142
 
143
extern void *__morestack_make_guard (void *, size_t)
144
  __attribute__ ((no_split_stack, visibility ("hidden")));
145
 
146
/* When we allocate a stack segment we put this header at the
147
   start.  */
148
 
149
struct stack_segment
150
{
151
  /* The previous stack segment--when a function running on this stack
152
     segment returns, it will run on the previous one.  */
153
  struct stack_segment *prev;
154
  /* The next stack segment, if it has been allocated--when a function
155
     is running on this stack segment, the next one is not being
156
     used.  */
157
  struct stack_segment *next;
158
  /* The total size of this stack segment.  */
159
  size_t size;
160
  /* The stack address when this stack was created.  This is used when
161
     popping the stack.  */
162
  void *old_stack;
163
  /* A list of memory blocks allocated by dynamic stack
164
     allocation.  */
165
  struct dynamic_allocation_blocks *dynamic_allocation;
166
  /* A list of dynamic memory blocks no longer needed.  */
167
  struct dynamic_allocation_blocks *free_dynamic_allocation;
168
  /* An extra pointer in case we need some more information some
169
     day.  */
170
  void *extra;
171
};
172
 
173
/* This structure holds the (approximate) initial stack pointer and
174
   size for the system supplied stack for a thread.  This is set when
175
   the thread is created.  We also store a sigset_t here to hold the
176
   signal mask while splitting the stack, since we don't want to store
177
   that on the stack.  */
178
 
179
struct initial_sp
180
{
181
  /* The initial stack pointer.  */
182
  void *sp;
183
  /* The stack length.  */
184
  size_t len;
185
  /* A signal mask, put here so that the thread can use it without
186
     needing stack space.  */
187
  sigset_t mask;
188
  /* Non-zero if we should not block signals.  This is a reversed flag
189
     so that the default zero value is the safe value.  The type is
190
     uintptr_type because it replaced one of the void * pointers in
191
     extra.  */
192
  uintptr_type dont_block_signals;
193
  /* Some extra space for later extensibility.  */
194
  void *extra[4];
195
};
196
 
197
/* A list of memory blocks allocated by dynamic stack allocation.
198
   This is used for code that calls alloca or uses variably sized
199
   arrays.  */
200
 
201
struct dynamic_allocation_blocks
202
{
203
  /* The next block in the list.  */
204
  struct dynamic_allocation_blocks *next;
205
  /* The size of the allocated memory.  */
206
  size_t size;
207
  /* The allocated memory.  */
208
  void *block;
209
};
210
 
211
/* These thread local global variables must be shared by all split
212
   stack code across shared library boundaries.  Therefore, they have
213
   default visibility.  They have extensibility fields if needed for
214
   new versions.  If more radical changes are needed, new code can be
215
   written using new variable names, while still using the existing
216
   variables in a backward compatible manner.  Symbol versioning is
217
   also used, although, since these variables are only referenced by
218
   code in this file and generic-morestack-thread.c, it is likely that
219
   simply using new names will suffice.  */
220
 
221
/* The first stack segment allocated for this thread.  */
222
 
223
__thread struct stack_segment *__morestack_segments
224
  __attribute__ ((visibility ("default")));
225
 
226
/* The stack segment that we think we are currently using.  This will
227
   be correct in normal usage, but will be incorrect if an exception
228
   unwinds into a different stack segment or if longjmp jumps to a
229
   different stack segment.  */
230
 
231
__thread struct stack_segment *__morestack_current_segment
232
  __attribute__ ((visibility ("default")));
233
 
234
/* The initial stack pointer and size for this thread.  */
235
 
236
__thread struct initial_sp __morestack_initial_sp
237
  __attribute__ ((visibility ("default")));
238
 
239
/* A static signal mask, to avoid taking up stack space.  */
240
 
241
static sigset_t __morestack_fullmask;
242
 
243
/* Convert an integer to a decimal string without using much stack
244
   space.  Return a pointer to the part of the buffer to use.  We this
245
   instead of sprintf because sprintf will require too much stack
246
   space.  */
247
 
248
static char *
249
print_int (int val, char *buf, int buflen, size_t *print_len)
250
{
251
  int is_negative;
252
  int i;
253
  unsigned int uval;
254
 
255
  uval = (unsigned int) val;
256
  if (val >= 0)
257
    is_negative = 0;
258
  else
259
    {
260
      is_negative = 1;
261
      uval = - uval;
262
    }
263
 
264
  i = buflen;
265
  do
266
    {
267
      --i;
268
      buf[i] = '0' + (uval % 10);
269
      uval /= 10;
270
    }
271
  while (uval != 0 && i > 0);
272
 
273
  if (is_negative)
274
    {
275
      if (i > 0)
276
        --i;
277
      buf[i] = '-';
278
    }
279
 
280
  *print_len = buflen - i;
281
  return buf + i;
282
}
283
 
284
/* Print the string MSG/LEN, the errno number ERR, and a newline on
285
   stderr.  Then crash.  */
286
 
287
void
288
__morestack_fail (const char *, size_t, int) __attribute__ ((noreturn));
289
 
290
void
291
__morestack_fail (const char *msg, size_t len, int err)
292
{
293
  char buf[24];
294
  static const char nl[] = "\n";
295
  struct iovec iov[3];
296
  union { char *p; const char *cp; } const_cast;
297
 
298
  const_cast.cp = msg;
299
  iov[0].iov_base = const_cast.p;
300
  iov[0].iov_len = len;
301
  /* We can't call strerror, because it may try to translate the error
302
     message, and that would use too much stack space.  */
303
  iov[1].iov_base = print_int (err, buf, sizeof buf, &iov[1].iov_len);
304
  const_cast.cp = &nl[0];
305
  iov[2].iov_base = const_cast.p;
306
  iov[2].iov_len = sizeof nl - 1;
307
  /* FIXME: On systems without writev we need to issue three write
308
     calls, or punt on printing errno.  For now this is irrelevant
309
     since stack splitting only works on GNU/Linux anyhow.  */
310
  writev (2, iov, 3);
311
  abort ();
312
}
313
 
314
/* Allocate a new stack segment.  FRAME_SIZE is the required frame
315
   size.  */
316
 
317
static struct stack_segment *
318
allocate_segment (size_t frame_size)
319
{
320
  static unsigned int static_pagesize;
321
  static int use_guard_page;
322
  unsigned int pagesize;
323
  unsigned int overhead;
324
  unsigned int allocate;
325
  void *space;
326
  struct stack_segment *pss;
327
 
328
  pagesize = static_pagesize;
329
  if (pagesize == 0)
330
    {
331
      unsigned int p;
332
 
333
      pagesize = getpagesize ();
334
 
335
#ifdef __GCC_HAVE_SYNC_COMPARE_AND_SWAP_4
336
      p = __sync_val_compare_and_swap (&static_pagesize, 0, pagesize);
337
#else
338
      /* Just hope this assignment is atomic.  */
339
      static_pagesize = pagesize;
340
      p = 0;
341
#endif
342
 
343
      use_guard_page = getenv ("SPLIT_STACK_GUARD") != 0;
344
 
345
      /* FIXME: I'm not sure this assert should be in the released
346
         code.  */
347
      assert (p == 0 || p == pagesize);
348
    }
349
 
350
  overhead = sizeof (struct stack_segment);
351
 
352
  allocate = pagesize;
353
  if (allocate < MINSIGSTKSZ)
354
    allocate = ((MINSIGSTKSZ + overhead + pagesize - 1)
355
                & ~ (pagesize - 1));
356
  if (allocate < frame_size)
357
    allocate = ((frame_size + overhead + pagesize - 1)
358
                & ~ (pagesize - 1));
359
 
360
  if (use_guard_page)
361
    allocate += pagesize;
362
 
363
  /* FIXME: If this binary requires an executable stack, then we need
364
     to set PROT_EXEC.  Unfortunately figuring that out is complicated
365
     and target dependent.  We would need to use dl_iterate_phdr to
366
     see if there is any object which does not have a PT_GNU_STACK
367
     phdr, though only for architectures which use that mechanism.  */
368
  space = mmap (NULL, allocate, PROT_READ | PROT_WRITE,
369
                MAP_ANONYMOUS | MAP_PRIVATE, -1, 0);
370
  if (space == MAP_FAILED)
371
    {
372
      static const char msg[] =
373
        "unable to allocate additional stack space: errno ";
374
      __morestack_fail (msg, sizeof msg - 1, errno);
375
    }
376
 
377
  if (use_guard_page)
378
    {
379
      void *guard;
380
 
381
#ifdef STACK_GROWS_DOWNWARD
382
      guard = space;
383
      space = (char *) space + pagesize;
384
#else
385
      guard = space + allocate - pagesize;
386
#endif
387
 
388
      mprotect (guard, pagesize, PROT_NONE);
389
      allocate -= pagesize;
390
    }
391
 
392
  pss = (struct stack_segment *) space;
393
 
394
  pss->prev = NULL;
395
  pss->next = NULL;
396
  pss->size = allocate - overhead;
397
  pss->dynamic_allocation = NULL;
398
  pss->free_dynamic_allocation = NULL;
399
  pss->extra = NULL;
400
 
401
  return pss;
402
}
403
 
404
/* Free a list of dynamic blocks.  */
405
 
406
static void
407
free_dynamic_blocks (struct dynamic_allocation_blocks *p)
408
{
409
  while (p != NULL)
410
    {
411
      struct dynamic_allocation_blocks *next;
412
 
413
      next = p->next;
414
      free (p->block);
415
      free (p);
416
      p = next;
417
    }
418
}
419
 
420
/* Merge two lists of dynamic blocks.  */
421
 
422
static struct dynamic_allocation_blocks *
423
merge_dynamic_blocks (struct dynamic_allocation_blocks *a,
424
                      struct dynamic_allocation_blocks *b)
425
{
426
  struct dynamic_allocation_blocks **pp;
427
 
428
  if (a == NULL)
429
    return b;
430
  if (b == NULL)
431
    return a;
432
  for (pp = &a->next; *pp != NULL; pp = &(*pp)->next)
433
    ;
434
  *pp = b;
435
  return a;
436
}
437
 
438
/* Release stack segments.  If FREE_DYNAMIC is non-zero, we also free
439
   any dynamic blocks.  Otherwise we return them.  */
440
 
441
struct dynamic_allocation_blocks *
442
__morestack_release_segments (struct stack_segment **pp, int free_dynamic)
443
{
444
  struct dynamic_allocation_blocks *ret;
445
  struct stack_segment *pss;
446
 
447
  ret = NULL;
448
  pss = *pp;
449
  while (pss != NULL)
450
    {
451
      struct stack_segment *next;
452
      unsigned int allocate;
453
 
454
      next = pss->next;
455
 
456
      if (pss->dynamic_allocation != NULL
457
          || pss->free_dynamic_allocation != NULL)
458
        {
459
          if (free_dynamic)
460
            {
461
              free_dynamic_blocks (pss->dynamic_allocation);
462
              free_dynamic_blocks (pss->free_dynamic_allocation);
463
            }
464
          else
465
            {
466
              ret = merge_dynamic_blocks (pss->dynamic_allocation, ret);
467
              ret = merge_dynamic_blocks (pss->free_dynamic_allocation, ret);
468
            }
469
        }
470
 
471
      allocate = pss->size + sizeof (struct stack_segment);
472
      if (munmap (pss, allocate) < 0)
473
        {
474
          static const char msg[] = "munmap of stack space failed: errno ";
475
          __morestack_fail (msg, sizeof msg - 1, errno);
476
        }
477
 
478
      pss = next;
479
    }
480
  *pp = NULL;
481
 
482
  return ret;
483
}
484
 
485
/* This function is called by a processor specific function to set the
486
   initial stack pointer for a thread.  The operating system will
487
   always create a stack for a thread.  Here we record a stack pointer
488
   near the base of that stack.  The size argument lets the processor
489
   specific code estimate how much stack space is available on this
490
   initial stack.  */
491
 
492
void
493
__generic_morestack_set_initial_sp (void *sp, size_t len)
494
{
495
  /* The stack pointer most likely starts on a page boundary.  Adjust
496
     to the nearest 512 byte boundary.  It's not essential that we be
497
     precise here; getting it wrong will just leave some stack space
498
     unused.  */
499
#ifdef STACK_GROWS_DOWNWARD
500
  sp = (void *) ((((__UINTPTR_TYPE__) sp + 511U) / 512U) * 512U);
501
#else
502
  sp = (void *) ((((__UINTPTR_TYPE__) sp - 511U) / 512U) * 512U);
503
#endif
504
 
505
  __morestack_initial_sp.sp = sp;
506
  __morestack_initial_sp.len = len;
507
  sigemptyset (&__morestack_initial_sp.mask);
508
 
509
  sigfillset (&__morestack_fullmask);
510
#if defined(__GLIBC__) && defined(__linux__)
511
  /* In glibc, the first two real time signals are used by the NPTL
512
     threading library.  By taking them out of the set of signals, we
513
     avoiding copying the signal mask in pthread_sigmask.  More
514
     importantly, pthread_sigmask uses less stack space on x86_64.  */
515
  sigdelset (&__morestack_fullmask, __SIGRTMIN);
516
  sigdelset (&__morestack_fullmask, __SIGRTMIN + 1);
517
#endif
518
}
519
 
520
/* This function is called by a processor specific function which is
521
   run in the prologue when more stack is needed.  The processor
522
   specific function handles the details of saving registers and
523
   frobbing the actual stack pointer.  This function is responsible
524
   for allocating a new stack segment and for copying a parameter
525
   block from the old stack to the new one.  On function entry
526
   *PFRAME_SIZE is the size of the required stack frame--the returned
527
   stack must be at least this large.  On function exit *PFRAME_SIZE
528
   is the amount of space remaining on the allocated stack.  OLD_STACK
529
   points at the parameters the old stack (really the current one
530
   while this function is running).  OLD_STACK is saved so that it can
531
   be returned by a later call to __generic_releasestack.  PARAM_SIZE
532
   is the size in bytes of parameters to copy to the new stack.  This
533
   function returns a pointer to the new stack segment, pointing to
534
   the memory after the parameters have been copied.  The returned
535
   value minus the returned *PFRAME_SIZE (or plus if the stack grows
536
   upward) is the first address on the stack which should not be used.
537
 
538
   This function is running on the old stack and has only a limited
539
   amount of stack space available.  */
540
 
541
void *
542
__generic_morestack (size_t *pframe_size, void *old_stack, size_t param_size)
543
{
544
  size_t frame_size = *pframe_size;
545
  struct stack_segment *current;
546
  struct stack_segment **pp;
547
  struct dynamic_allocation_blocks *dynamic;
548
  char *from;
549
  char *to;
550
  void *ret;
551
  size_t i;
552
 
553
  current = __morestack_current_segment;
554
 
555
  pp = current != NULL ? &current->next : &__morestack_segments;
556
  if (*pp != NULL && (*pp)->size < frame_size)
557
    dynamic = __morestack_release_segments (pp, 0);
558
  else
559
    dynamic = NULL;
560
  current = *pp;
561
 
562
  if (current == NULL)
563
    {
564
      current = allocate_segment (frame_size + param_size);
565
      current->prev = __morestack_current_segment;
566
      *pp = current;
567
    }
568
 
569
  current->old_stack = old_stack;
570
 
571
  __morestack_current_segment = current;
572
 
573
  if (dynamic != NULL)
574
    {
575
      /* Move the free blocks onto our list.  We don't want to call
576
         free here, as we are short on stack space.  */
577
      current->free_dynamic_allocation =
578
        merge_dynamic_blocks (dynamic, current->free_dynamic_allocation);
579
    }
580
 
581
  *pframe_size = current->size - param_size;
582
 
583
#ifdef STACK_GROWS_DOWNWARD
584
  {
585
    char *bottom = (char *) (current + 1) + current->size;
586
    to = bottom - param_size;
587
    ret = bottom - param_size;
588
  }
589
#else
590
  to = current + 1;
591
  ret = (char *) (current + 1) + param_size;
592
#endif
593
 
594
  /* We don't call memcpy to avoid worrying about the dynamic linker
595
     trying to resolve it.  */
596
  from = (char *) old_stack;
597
  for (i = 0; i < param_size; i++)
598
    *to++ = *from++;
599
 
600
  return ret;
601
}
602
 
603
/* This function is called by a processor specific function when it is
604
   ready to release a stack segment.  We don't actually release the
605
   stack segment, we just move back to the previous one.  The current
606
   stack segment will still be available if we need it in
607
   __generic_morestack.  This returns a pointer to the new stack
608
   segment to use, which is the one saved by a previous call to
609
   __generic_morestack.  The processor specific function is then
610
   responsible for actually updating the stack pointer.  This sets
611
   *PAVAILABLE to the amount of stack space now available.  */
612
 
613
void *
614
__generic_releasestack (size_t *pavailable)
615
{
616
  struct stack_segment *current;
617
  void *old_stack;
618
 
619
  current = __morestack_current_segment;
620
  old_stack = current->old_stack;
621
  current = current->prev;
622
  __morestack_current_segment = current;
623
 
624
  if (current != NULL)
625
    {
626
#ifdef STACK_GROWS_DOWNWARD
627
      *pavailable = (char *) old_stack - (char *) (current + 1);
628
#else
629
      *pavailable = (char *) (current + 1) + current->size - (char *) old_stack;
630
#endif
631
    }
632
  else
633
    {
634
      size_t used;
635
 
636
      /* We have popped back to the original stack.  */
637
#ifdef STACK_GROWS_DOWNWARD
638
      if ((char *) old_stack >= (char *) __morestack_initial_sp.sp)
639
        used = 0;
640
      else
641
        used = (char *) __morestack_initial_sp.sp - (char *) old_stack;
642
#else
643
      if ((char *) old_stack <= (char *) __morestack_initial_sp.sp)
644
        used = 0;
645
      else
646
        used = (char *) old_stack - (char *) __morestack_initial_sp.sp;
647
#endif
648
 
649
      if (used > __morestack_initial_sp.len)
650
        *pavailable = 0;
651
      else
652
        *pavailable = __morestack_initial_sp.len - used;
653
    }
654
 
655
  return old_stack;
656
}
657
 
658
/* Block signals while splitting the stack.  This avoids trouble if we
659
   try to invoke a signal handler which itself wants to split the
660
   stack.  */
661
 
662
extern int pthread_sigmask (int, const sigset_t *, sigset_t *)
663
  __attribute__ ((weak));
664
 
665
void
666
__morestack_block_signals (void)
667
{
668
  if (__morestack_initial_sp.dont_block_signals)
669
    ;
670
  else if (pthread_sigmask)
671
    pthread_sigmask (SIG_BLOCK, &__morestack_fullmask,
672
                     &__morestack_initial_sp.mask);
673
  else
674
    sigprocmask (SIG_BLOCK, &__morestack_fullmask,
675
                 &__morestack_initial_sp.mask);
676
}
677
 
678
/* Unblock signals while splitting the stack.  */
679
 
680
void
681
__morestack_unblock_signals (void)
682
{
683
  if (__morestack_initial_sp.dont_block_signals)
684
    ;
685
  else if (pthread_sigmask)
686
    pthread_sigmask (SIG_SETMASK, &__morestack_initial_sp.mask, NULL);
687
  else
688
    sigprocmask (SIG_SETMASK, &__morestack_initial_sp.mask, NULL);
689
}
690
 
691
/* This function is called to allocate dynamic stack space, for alloca
692
   or a variably sized array.  This is a regular function with
693
   sufficient stack space, so we just use malloc to allocate the
694
   space.  We attach the allocated blocks to the current stack
695
   segment, so that they will eventually be reused or freed.  */
696
 
697
void *
698
__morestack_allocate_stack_space (size_t size)
699
{
700
  struct stack_segment *seg, *current;
701
  struct dynamic_allocation_blocks *p;
702
 
703
  /* We have to block signals to avoid getting confused if we get
704
     interrupted by a signal whose handler itself uses alloca or a
705
     variably sized array.  */
706
  __morestack_block_signals ();
707
 
708
  /* Since we don't want to call free while we are low on stack space,
709
     we may have a list of already allocated blocks waiting to be
710
     freed.  Release them all, unless we find one that is large
711
     enough.  We don't look at every block to see if one is large
712
     enough, just the first one, because we aren't trying to build a
713
     memory allocator here, we're just trying to speed up common
714
     cases.  */
715
 
716
  current = __morestack_current_segment;
717
  p = NULL;
718
  for (seg = __morestack_segments; seg != NULL; seg = seg->next)
719
    {
720
      p = seg->free_dynamic_allocation;
721
      if (p != NULL)
722
        {
723
          if (p->size >= size)
724
            {
725
              seg->free_dynamic_allocation = p->next;
726
              break;
727
            }
728
 
729
          free_dynamic_blocks (p);
730
          seg->free_dynamic_allocation = NULL;
731
          p = NULL;
732
        }
733
    }
734
 
735
  if (p == NULL)
736
    {
737
      /* We need to allocate additional memory.  */
738
      p = malloc (sizeof (*p));
739
      if (p == NULL)
740
        abort ();
741
      p->size = size;
742
      p->block = malloc (size);
743
      if (p->block == NULL)
744
        abort ();
745
    }
746
 
747
  /* If we are still on the initial stack, then we have a space leak.
748
     FIXME.  */
749
  if (current != NULL)
750
    {
751
      p->next = current->dynamic_allocation;
752
      current->dynamic_allocation = p;
753
    }
754
 
755
  __morestack_unblock_signals ();
756
 
757
  return p->block;
758
}
759
 
760
/* Find the stack segment for STACK and return the amount of space
761
   available.  This is used when unwinding the stack because of an
762
   exception, in order to reset the stack guard correctly.  */
763
 
764
size_t
765
__generic_findstack (void *stack)
766
{
767
  struct stack_segment *pss;
768
  size_t used;
769
 
770
  for (pss = __morestack_current_segment; pss != NULL; pss = pss->prev)
771
    {
772
      if ((char *) pss < (char *) stack
773
          && (char *) pss + pss->size > (char *) stack)
774
        {
775
          __morestack_current_segment = pss;
776
#ifdef STACK_GROWS_DOWNWARD
777
          return (char *) stack - (char *) (pss + 1);
778
#else
779
          return (char *) (pss + 1) + pss->size - (char *) stack;
780
#endif
781
        }
782
    }
783
 
784
  /* We have popped back to the original stack.  */
785
 
786
  if (__morestack_initial_sp.sp == NULL)
787
    return 0;
788
 
789
#ifdef STACK_GROWS_DOWNWARD
790
  if ((char *) stack >= (char *) __morestack_initial_sp.sp)
791
    used = 0;
792
  else
793
    used = (char *) __morestack_initial_sp.sp - (char *) stack;
794
#else
795
  if ((char *) stack <= (char *) __morestack_initial_sp.sp)
796
    used = 0;
797
  else
798
    used = (char *) stack - (char *) __morestack_initial_sp.sp;
799
#endif
800
 
801
  if (used > __morestack_initial_sp.len)
802
    return 0;
803
  else
804
    return __morestack_initial_sp.len - used;
805
}
806
 
807
/* This function is called at program startup time to make sure that
808
   mmap, munmap, and getpagesize are resolved if linking dynamically.
809
   We want to resolve them while we have enough stack for them, rather
810
   than calling into the dynamic linker while low on stack space.  */
811
 
812
void
813
__morestack_load_mmap (void)
814
{
815
  /* Call with bogus values to run faster.  We don't care if the call
816
     fails.  Pass __MORESTACK_CURRENT_SEGMENT to make sure that any
817
     TLS accessor function is resolved.  */
818
  mmap (__morestack_current_segment, 0, PROT_READ, MAP_ANONYMOUS, -1, 0);
819
  mprotect (NULL, 0, 0);
820
  munmap (0, getpagesize ());
821
}
822
 
823
/* This function may be used to iterate over the stack segments.
824
   This can be called like this.
825
     void *next_segment = NULL;
826
     void *next_sp = NULL;
827
     void *initial_sp = NULL;
828
     void *stack;
829
     size_t stack_size;
830
     while ((stack = __splitstack_find (next_segment, next_sp, &stack_size,
831
                                        &next_segment, &next_sp,
832
                                        &initial_sp)) != NULL)
833
       {
834
         // Stack segment starts at stack and is stack_size bytes long.
835
       }
836
 
837
   There is no way to iterate over the stack segments of a different
838
   thread.  However, what is permitted is for one thread to call this
839
   with the first two values NULL, to pass next_segment, next_sp, and
840
   initial_sp to a different thread, and then to suspend one way or
841
   another.  A different thread may run the subsequent
842
   __morestack_find iterations.  Of course, this will only work if the
843
   first thread is suspended during the __morestack_find iterations.
844
   If not, the second thread will be looking at the stack while it is
845
   changing, and anything could happen.
846
 
847
   FIXME: This should be declared in some header file, but where?  */
848
 
849
void *
850
__splitstack_find (void *segment_arg, void *sp, size_t *len,
851
                   void **next_segment, void **next_sp,
852
                   void **initial_sp)
853
{
854
  struct stack_segment *segment;
855
  void *ret;
856
  char *nsp;
857
 
858
  if (segment_arg == (void *) (uintptr_type) 1)
859
    {
860
      char *isp = (char *) *initial_sp;
861
 
862
      if (isp == NULL)
863
        return NULL;
864
 
865
      *next_segment = (void *) (uintptr_type) 2;
866
      *next_sp = NULL;
867
#ifdef STACK_GROWS_DOWNWARD
868
      if ((char *) sp >= isp)
869
        return NULL;
870
      *len = (char *) isp - (char *) sp;
871
      return sp;
872
#else
873
      if ((char *) sp <= (char *) isp)
874
        return NULL;
875
      *len = (char *) sp - (char *) isp;
876
      return (void *) isp;
877
#endif
878
    }
879
  else if (segment_arg == (void *) (uintptr_type) 2)
880
    return NULL;
881
  else if (segment_arg != NULL)
882
    segment = (struct stack_segment *) segment_arg;
883
  else
884
    {
885
      *initial_sp = __morestack_initial_sp.sp;
886
      segment = __morestack_current_segment;
887
      sp = (void *) &segment;
888
      while (1)
889
        {
890
          if (segment == NULL)
891
            return __splitstack_find ((void *) (uintptr_type) 1, sp, len,
892
                                      next_segment, next_sp, initial_sp);
893
          if ((char *) sp >= (char *) (segment + 1)
894
              && (char *) sp <= (char *) (segment + 1) + segment->size)
895
            break;
896
          segment = segment->prev;
897
        }
898
    }
899
 
900
  if (segment->prev == NULL)
901
    *next_segment = (void *) (uintptr_type) 1;
902
  else
903
    *next_segment = segment->prev;
904
 
905
  /* The old_stack value is the address of the function parameters of
906
     the function which called __morestack.  So if f1 called f2 which
907
     called __morestack, the stack looks like this:
908
 
909
         parameters       <- old_stack
910
         return in f1
911
         return in f2
912
         registers pushed by __morestack
913
 
914
     The registers pushed by __morestack may not be visible on any
915
     other stack, if we are being called by a signal handler
916
     immediately after the call to __morestack_unblock_signals.  We
917
     want to adjust our return value to include those registers.  This
918
     is target dependent.  */
919
 
920
  nsp = (char *) segment->old_stack;
921
 
922
  if (nsp == NULL)
923
    {
924
      /* We've reached the top of the stack.  */
925
      *next_segment = (void *) (uintptr_type) 2;
926
    }
927
  else
928
    {
929
#if defined (__x86_64__)
930
      nsp -= 12 * sizeof (void *);
931
#elif defined (__i386__)
932
      nsp -= 6 * sizeof (void *);
933
#else
934
#error "unrecognized target"
935
#endif
936
 
937
      *next_sp = (void *) nsp;
938
    }
939
 
940
#ifdef STACK_GROWS_DOWNWARD
941
  *len = (char *) (segment + 1) + segment->size - (char *) sp;
942
  ret = (void *) sp;
943
#else
944
  *len = (char *) sp - (char *) (segment + 1);
945
  ret = (void *) (segment + 1);
946
#endif
947
 
948
  return ret;
949
}
950
 
951
/* Tell the split stack code whether it has to block signals while
952
   manipulating the stack.  This is for programs in which some threads
953
   block all signals.  If a thread already blocks signals, there is no
954
   need for the split stack code to block them as well.  If NEW is not
955
   NULL, then if *NEW is non-zero signals will be blocked while
956
   splitting the stack, otherwise they will not.  If OLD is not NULL,
957
   *OLD will be set to the old value.  */
958
 
959
void
960
__splitstack_block_signals (int *new, int *old)
961
{
962
  if (old != NULL)
963
    *old = __morestack_initial_sp.dont_block_signals ? 0 : 1;
964
  if (new != NULL)
965
    __morestack_initial_sp.dont_block_signals = *new ? 0 : 1;
966
}
967
 
968
/* The offsets into the arrays used by __splitstack_getcontext and
969
   __splitstack_setcontext.  */
970
 
971
enum __splitstack_context_offsets
972
{
973
  MORESTACK_SEGMENTS = 0,
974
  CURRENT_SEGMENT = 1,
975
  CURRENT_STACK = 2,
976
  STACK_GUARD = 3,
977
  INITIAL_SP = 4,
978
  INITIAL_SP_LEN = 5,
979
  BLOCK_SIGNALS = 6,
980
 
981
  NUMBER_OFFSETS = 10
982
};
983
 
984
/* Get the current split stack context.  This may be used for
985
   coroutine switching, similar to getcontext.  The argument should
986
   have at least 10 void *pointers for extensibility, although we
987
   don't currently use all of them.  This would normally be called
988
   immediately before a call to getcontext or swapcontext or
989
   setjmp.  */
990
 
991
void
992
__splitstack_getcontext (void *context[NUMBER_OFFSETS])
993
{
994
  memset (context, 0, NUMBER_OFFSETS * sizeof (void *));
995
  context[MORESTACK_SEGMENTS] = (void *) __morestack_segments;
996
  context[CURRENT_SEGMENT] = (void *) __morestack_current_segment;
997
  context[CURRENT_STACK] = (void *) &context;
998
  context[STACK_GUARD] = __morestack_get_guard ();
999
  context[INITIAL_SP] = (void *) __morestack_initial_sp.sp;
1000
  context[INITIAL_SP_LEN] = (void *) (uintptr_type) __morestack_initial_sp.len;
1001
  context[BLOCK_SIGNALS] = (void *) __morestack_initial_sp.dont_block_signals;
1002
}
1003
 
1004
/* Set the current split stack context.  The argument should be a
1005
   context previously passed to __splitstack_getcontext.  This would
1006
   normally be called immediately after a call to getcontext or
1007
   swapcontext or setjmp if something jumped to it.  */
1008
 
1009
void
1010
__splitstack_setcontext (void *context[NUMBER_OFFSETS])
1011
{
1012
  __morestack_segments = (struct stack_segment *) context[MORESTACK_SEGMENTS];
1013
  __morestack_current_segment =
1014
    (struct stack_segment *) context[CURRENT_SEGMENT];
1015
  __morestack_set_guard (context[STACK_GUARD]);
1016
  __morestack_initial_sp.sp = context[INITIAL_SP];
1017
  __morestack_initial_sp.len = (size_t) context[INITIAL_SP_LEN];
1018
  __morestack_initial_sp.dont_block_signals =
1019
    (uintptr_type) context[BLOCK_SIGNALS];
1020
}
1021
 
1022
/* Create a new split stack context.  This will allocate a new stack
1023
   segment which may be used by a coroutine.  STACK_SIZE is the
1024
   minimum size of the new stack.  The caller is responsible for
1025
   actually setting the stack pointer.  This would normally be called
1026
   before a call to makecontext, and the returned stack pointer and
1027
   size would be used to set the uc_stack field.  A function called
1028
   via makecontext on a stack created by __splitstack_makecontext may
1029
   not return.  Note that the returned pointer points to the lowest
1030
   address in the stack space, and thus may not be the value to which
1031
   to set the stack pointer.  */
1032
 
1033
void *
1034
__splitstack_makecontext (size_t stack_size, void *context[NUMBER_OFFSETS],
1035
                          size_t *size)
1036
{
1037
  struct stack_segment *segment;
1038
  void *initial_sp;
1039
 
1040
  memset (context, 0, NUMBER_OFFSETS * sizeof (void *));
1041
  segment = allocate_segment (stack_size);
1042
  context[MORESTACK_SEGMENTS] = segment;
1043
  context[CURRENT_SEGMENT] = segment;
1044
#ifdef STACK_GROWS_DOWNWARD
1045
  initial_sp = (void *) ((char *) (segment + 1) + segment->size);
1046
#else
1047
  initial_sp = (void *) (segment + 1);
1048
#endif
1049
  context[STACK_GUARD] = __morestack_make_guard (initial_sp, segment->size);
1050
  context[INITIAL_SP] = NULL;
1051
  context[INITIAL_SP_LEN] = 0;
1052
  *size = segment->size;
1053
  return (void *) (segment + 1);
1054
}
1055
 
1056
/* Given an existing split stack context, reset it back to the start
1057
   of the stack.  Return the stack pointer and size, appropriate for
1058
   use with makecontext.  This may be used if a coroutine exits, in
1059
   order to reuse the stack segments for a new coroutine.  */
1060
 
1061
void *
1062
__splitstack_resetcontext (void *context[10], size_t *size)
1063
{
1064
  struct stack_segment *segment;
1065
  void *initial_sp;
1066
  size_t initial_size;
1067
  void *ret;
1068
 
1069
  /* Reset the context assuming that MORESTACK_SEGMENTS, INITIAL_SP
1070
     and INITIAL_SP_LEN are correct.  */
1071
 
1072
  segment = context[MORESTACK_SEGMENTS];
1073
  context[CURRENT_SEGMENT] = segment;
1074
  context[CURRENT_STACK] = NULL;
1075
  if (segment == NULL)
1076
    {
1077
      initial_sp = context[INITIAL_SP];
1078
      initial_size = (uintptr_type) context[INITIAL_SP_LEN];
1079
      ret = initial_sp;
1080
#ifdef STACK_GROWS_DOWNWARD
1081
      ret = (void *) ((char *) ret - initial_size);
1082
#endif
1083
    }
1084
  else
1085
    {
1086
#ifdef STACK_GROWS_DOWNWARD
1087
      initial_sp = (void *) ((char *) (segment + 1) + segment->size);
1088
#else
1089
      initial_sp = (void *) (segment + 1);
1090
#endif
1091
      initial_size = segment->size;
1092
      ret = (void *) (segment + 1);
1093
    }
1094
  context[STACK_GUARD] = __morestack_make_guard (initial_sp, initial_size);
1095
  context[BLOCK_SIGNALS] = NULL;
1096
  *size = initial_size;
1097
  return ret;
1098
}
1099
 
1100
/* Release all the memory associated with a splitstack context.  This
1101
   may be used if a coroutine exits and the associated stack should be
1102
   freed.  */
1103
 
1104
void
1105
__splitstack_releasecontext (void *context[10])
1106
{
1107
  __morestack_release_segments (((struct stack_segment **)
1108
                                 &context[MORESTACK_SEGMENTS]),
1109
                                1);
1110
}
1111
 
1112
/* Like __splitstack_block_signals, but operating on CONTEXT, rather
1113
   than on the current state.  */
1114
 
1115
void
1116
__splitstack_block_signals_context (void *context[NUMBER_OFFSETS], int *new,
1117
                                    int *old)
1118
{
1119
  if (old != NULL)
1120
    *old = ((uintptr_type) context[BLOCK_SIGNALS]) != 0 ? 0 : 1;
1121
  if (new != NULL)
1122
    context[BLOCK_SIGNALS] = (void *) (uintptr_type) (*new ? 0 : 1);
1123
}
1124
 
1125
/* Find the stack segments associated with a split stack context.
1126
   This will return the address of the first stack segment and set
1127
   *STACK_SIZE to its size.  It will set next_segment, next_sp, and
1128
   initial_sp which may be passed to __splitstack_find to find the
1129
   remaining segments.  */
1130
 
1131
void *
1132
__splitstack_find_context (void *context[NUMBER_OFFSETS], size_t *stack_size,
1133
                           void **next_segment, void **next_sp,
1134
                           void **initial_sp)
1135
{
1136
  void *sp;
1137
  struct stack_segment *segment;
1138
 
1139
  *initial_sp = context[INITIAL_SP];
1140
 
1141
  sp = context[CURRENT_STACK];
1142
  if (sp == NULL)
1143
    {
1144
      /* Most likely this context was created but was never used.  The
1145
         value 2 is a code used by __splitstack_find to mean that we
1146
         have reached the end of the list of stacks.  */
1147
      *next_segment = (void *) (uintptr_type) 2;
1148
      *next_sp = NULL;
1149
      *initial_sp = NULL;
1150
      return NULL;
1151
    }
1152
 
1153
  segment = context[CURRENT_SEGMENT];
1154
  if (segment == NULL)
1155
    {
1156
      /* Most likely this context was saved by a thread which was not
1157
         created using __splistack_makecontext and which has never
1158
         split the stack.  The value 1 is a code used by
1159
         __splitstack_find to look at the initial stack.  */
1160
      segment = (struct stack_segment *) (uintptr_type) 1;
1161
    }
1162
 
1163
  return __splitstack_find (segment, sp, stack_size, next_segment, next_sp,
1164
                            initial_sp);
1165
}
1166
 
1167
#endif /* !defined (inhibit_libc) */

powered by: WebSVN 2.1.0

© copyright 1999-2024 OpenCores.org, equivalent to Oliscience, all rights reserved. OpenCores®, registered trademark.