1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
|
/* Thread library support for -fsplit-stack. */
/* Copyright (C) 2009-2013 Free Software Foundation, Inc.
Contributed by Ian Lance Taylor <iant@google.com>.
This file is part of GCC.
GCC is free software; you can redistribute it and/or modify it under
the terms of the GNU General Public License as published by the Free
Software Foundation; either version 3, or (at your option) any later
version.
GCC is distributed in the hope that it will be useful, but WITHOUT ANY
WARRANTY; without even the implied warranty of MERCHANTABILITY or
FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
for more details.
Under Section 7 of GPL version 3, you are granted additional
permissions described in the GCC Runtime Library Exception, version
3.1, as published by the Free Software Foundation.
You should have received a copy of the GNU General Public License and
a copy of the GCC Runtime Library Exception along with this program;
see the files COPYING3 and COPYING.RUNTIME respectively. If not, see
<http://www.gnu.org/licenses/>. */
#include "tconfig.h"
#include "tsystem.h"
#include "coretypes.h"
#include "tm.h"
#include "libgcc_tm.h"
/* If inhibit_libc is defined, we can not compile this file. The
effect is that people will not be able to use -fsplit-stack. That
is much better than failing the build particularly since people
will want to define inhibit_libc while building a compiler which
can build glibc. */
#ifndef inhibit_libc
#include <errno.h>
#include <pthread.h>
#include "generic-morestack.h"
/* We declare the pthread functions we need as weak, so that
libgcc_s.so does not need to be linked against -lpthread. */
extern int pthread_once (pthread_once_t *, void (*) (void))
__attribute__ ((weak));
extern int pthread_key_create (pthread_key_t *, void (*) (void *))
__attribute__ ((weak));
extern int pthread_setspecific (pthread_key_t, const void *)
__attribute__ ((weak));
/* The key for the list of stack segments to free when the thread
exits. This is created by pthread_key_create. */
static pthread_key_t segment_list_key;
/* Used to only run create_key once. */
static pthread_once_t create_key_once = PTHREAD_ONCE_INIT;
/* Release all the segments for a thread. This is the destructor
function used by pthread_key_create, and is called when a thread
exits. */
static void
free_segments (void* arg)
{
__morestack_release_segments ((struct stack_segment **) arg, 1);
}
/* Set up the key for the list of segments. This is called via
pthread_once. */
static void
create_key (void)
{
int err;
err = pthread_key_create (&segment_list_key, free_segments);
if (err != 0)
{
static const char msg[] = "pthread_key_create failed: errno ";
__morestack_fail (msg, sizeof msg - 1, err);
}
}
/* Pass information from the pthread_create wrapper to
stack_split_initialize_thread. */
struct pthread_create_args
{
void *(*start_routine) (void *);
void *arg;
};
/* Initialize a thread. This is called via pthread_create. It calls
a target dependent function to set up any required stack guard. */
static void* stack_split_initialize_thread (void *)
__attribute__ ((no_split_stack));
static void *
stack_split_initialize_thread (void *varg)
{
struct pthread_create_args *args = (struct pthread_create_args *) varg;
int err;
void *(*start_routine) (void *);
void *arg;
__stack_split_initialize ();
err = pthread_setspecific (segment_list_key, (void *) &__morestack_segments);
if (err != 0)
{
static const char msg[] = "pthread_setspecific failed: errno ";
__morestack_fail (msg, sizeof msg - 1, err);
}
start_routine = args->start_routine;
arg = args->arg;
free (args);
return (*start_routine) (arg);
}
/* This function wraps calls to pthread_create to make sure that the
stack guard is initialized for new threads. FIXME: This hack will
not be necessary if glibc supports -fsplit-stack directly. */
int __wrap_pthread_create (pthread_t *, const pthread_attr_t *,
void *(*start_routine) (void *), void *)
__attribute__ ((visibility ("hidden")));
extern int __real_pthread_create (pthread_t *, const pthread_attr_t *,
void *(*start_routine) (void *), void *)
__attribute__ ((weak));
int
__wrap_pthread_create (pthread_t *tid, const pthread_attr_t *attr,
void *(*start_routine) (void *), void *arg)
{
int err;
struct pthread_create_args* args;
err = pthread_once (&create_key_once, create_key);
if (err != 0)
{
static const char msg[] = "pthread_once failed: errno ";
__morestack_fail (msg, sizeof msg - 1, err);
}
args = malloc (sizeof (struct pthread_create_args));
if (args == NULL)
return EAGAIN;
args->start_routine = start_routine;
args->arg = arg;
return __real_pthread_create (tid, attr, stack_split_initialize_thread, args);
}
#endif /* !defined (inhibit_libc) */
|
