1 // -*- C++ -*- Allocate exception objects.
2 // Copyright (C) 2001, 2004, 2005 Free Software Foundation, Inc.
4 // This file is part of GCC.
6 // GCC is free software; you can redistribute it and/or modify
7 // it under the terms of the GNU General Public License as published by
8 // the Free Software Foundation; either version 2, or (at your option)
11 // GCC 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
14 // GNU General Public License for more details.
16 // You should have received a copy of the GNU General Public License
17 // along with GCC; see the file COPYING. If not, write to
18 // the Free Software Foundation, 51 Franklin Street, Fifth Floor,
19 // Boston, MA 02110-1301, USA.
21 // As a special exception, you may use this file as part of a free software
22 // library without restriction. Specifically, if other files instantiate
23 // templates or use macros or inline functions from this file, or you compile
24 // this file and link it with other files to produce an executable, this
25 // file does not by itself cause the resulting executable to be covered by
26 // the GNU General Public License. This exception does not however
27 // invalidate any other reasons why the executable file might be covered by
28 // the GNU General Public License.
30 // This is derived from the C++ ABI for IA-64. Where we diverge
31 // for cross-architecture compatibility are noted with "@@@".
33 #include <bits/c++config.h>
40 #include "unwind-cxx.h"
41 #include "bits/gthr.h"
48 // In a freestanding environment, these functions may not be available
49 // -- but for now, we assume that they are.
50 extern "C" void *malloc (std::size_t);
51 extern "C" void free(void *);
52 extern "C" int memset (void *, int, std::size_t);
55 using namespace __cxxabiv1
;
57 // ??? How to control these parameters.
59 // Guess from the size of basic types how large a buffer is reasonable.
60 // Note that the basic c++ exception header has 13 pointers and 2 ints,
61 // so on a system with PSImode pointers we're talking about 56 bytes
65 # define EMERGENCY_OBJ_SIZE 128
66 # define EMERGENCY_OBJ_COUNT 16
67 #elif LONG_MAX == 2147483647
68 # define EMERGENCY_OBJ_SIZE 512
69 # define EMERGENCY_OBJ_COUNT 32
71 # define EMERGENCY_OBJ_SIZE 1024
72 # define EMERGENCY_OBJ_COUNT 64
76 # undef EMERGENCY_OBJ_COUNT
77 # define EMERGENCY_OBJ_COUNT 4
80 #if INT_MAX == 32767 || EMERGENCY_OBJ_COUNT <= 32
81 typedef unsigned int bitmask_type
;
83 typedef unsigned long bitmask_type
;
87 typedef char one_buffer
[EMERGENCY_OBJ_SIZE
] __attribute__((aligned
));
88 static one_buffer emergency_buffer
[EMERGENCY_OBJ_COUNT
];
89 static bitmask_type emergency_used
;
93 #ifdef __GTHREAD_MUTEX_INIT
94 static __gthread_mutex_t emergency_mutex
=__GTHREAD_MUTEX_INIT
;
96 static __gthread_mutex_t emergency_mutex
;
99 #ifdef __GTHREAD_MUTEX_INIT_FUNCTION
101 emergency_mutex_init ()
103 __GTHREAD_MUTEX_INIT_FUNCTION (&emergency_mutex
);
110 __cxxabiv1::__cxa_allocate_exception(std::size_t thrown_size
) throw()
114 thrown_size
+= sizeof (__cxa_exception
);
115 ret
= malloc (thrown_size
);
120 #ifdef __GTHREAD_MUTEX_INIT_FUNCTION
121 static __gthread_once_t once
= __GTHREAD_ONCE_INIT
;
122 __gthread_once (&once
, emergency_mutex_init
);
124 __gthread_mutex_lock (&emergency_mutex
);
127 bitmask_type used
= emergency_used
;
128 unsigned int which
= 0;
130 if (thrown_size
> EMERGENCY_OBJ_SIZE
)
135 if (++which
>= EMERGENCY_OBJ_COUNT
)
139 emergency_used
|= (bitmask_type
)1 << which
;
140 ret
= &emergency_buffer
[which
][0];
144 __gthread_mutex_unlock (&emergency_mutex
);
150 // We have an uncaught exception as soon as we allocate memory. This
151 // yields uncaught_exception() true during the copy-constructor that
152 // initializes the exception object. See Issue 475.
153 __cxa_eh_globals
*globals
= __cxa_get_globals ();
154 globals
->uncaughtExceptions
+= 1;
156 memset (ret
, 0, sizeof (__cxa_exception
));
158 return (void *)((char *)ret
+ sizeof (__cxa_exception
));
163 __cxxabiv1::__cxa_free_exception(void *vptr
) throw()
165 char *ptr
= (char *) vptr
;
166 if (ptr
>= &emergency_buffer
[0][0]
167 && ptr
< &emergency_buffer
[0][0] + sizeof (emergency_buffer
))
170 = (unsigned)(ptr
- &emergency_buffer
[0][0]) / EMERGENCY_OBJ_SIZE
;
173 __gthread_mutex_lock (&emergency_mutex
);
174 emergency_used
&= ~((bitmask_type
)1 << which
);
175 __gthread_mutex_unlock (&emergency_mutex
);
177 emergency_used
&= ~((bitmask_type
)1 << which
);
181 free (ptr
- sizeof (__cxa_exception
));