1 // -*- C++ -*- Allocate exception objects. 2 // Copyright (C) 2001 Free Software Foundation, Inc. 3 // 4 // This file is part of GNU CC. 5 // 6 // GNU CC 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) 9 // any later version. 10 // 11 // GNU CC 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. 15 // 16 // You should have received a copy of the GNU General Public License 17 // along with GNU CC; see the file COPYING. If not, write to 18 // the Free Software Foundation, 59 Temple Place - Suite 330, 19 // Boston, MA 02111-1307, USA. 20 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. 29 30 // This is derived from the C++ ABI for IA-64. Where we diverge 31 // for cross-architecture compatibility are noted with "@@@". 32 33 #include <cstdlib> 34 #include <cstring> 35 #include <climits> 36 #include <exception> 37 #include "unwind-cxx.h" 38 #include "bits/c++config.h" 39 #include "bits/gthr.h" 40 41 using namespace __cxxabiv1; 42 43 44 // ??? How to control these parameters. 45 46 // Guess from the size of basic types how large a buffer is reasonable. 47 // Note that the basic c++ exception header has 13 pointers and 2 ints, 48 // so on a system with PSImode pointers we're talking about 56 bytes 49 // just for overhead. 50 51 #if INT_MAX == 32767 52 # define EMERGENCY_OBJ_SIZE 128 53 # define EMERGENCY_OBJ_COUNT 16 54 #elif LONG_MAX == 2147483647 55 # define EMERGENCY_OBJ_SIZE 512 56 # define EMERGENCY_OBJ_COUNT 32 57 #else 58 # define EMERGENCY_OBJ_SIZE 1024 59 # define EMERGENCY_OBJ_COUNT 64 60 #endif 61 62 #ifndef __GTHREADS 63 # undef EMERGENCY_OBJ_COUNT 64 # define EMERGENCY_OBJ_COUNT 4 65 #endif 66 67 #if INT_MAX == 32767 || EMERGENCY_OBJ_COUNT <= 32 68 typedef unsigned int bitmask_type; 69 #else 70 typedef unsigned long bitmask_type; 71 #endif 72 73 74 typedef char one_buffer[EMERGENCY_OBJ_SIZE] __attribute__((aligned)); 75 static one_buffer emergency_buffer[EMERGENCY_OBJ_COUNT]; 76 static bitmask_type emergency_used; 77 78 79 #ifdef __GTHREADS 80 #ifdef __GTHREAD_MUTEX_INIT 81 static __gthread_mutex_t emergency_mutex =__GTHREAD_MUTEX_INIT; 82 #else 83 static __gthread_mutex_t emergency_mutex; 84 #endif 85 86 #ifdef __GTHREAD_MUTEX_INIT_FUNCTION 87 static void 88 emergency_mutex_init () 89 { 90 __GTHREAD_MUTEX_INIT_FUNCTION (&emergency_mutex); 91 } 92 #endif 93 #endif 94 95 96 extern "C" void * 97 __cxa_allocate_exception(std::size_t thrown_size) 98 { 99 void *ret; 100 101 thrown_size += sizeof (__cxa_exception); 102 ret = std::malloc (thrown_size); 103 104 if (! ret) 105 { 106 #ifdef __GTHREADS 107 #ifdef __GTHREAD_MUTEX_INIT_FUNCTION 108 static __gthread_once_t once = __GTHREAD_ONCE_INIT; 109 __gthread_once (&once, emergency_mutex_init); 110 #endif 111 __gthread_mutex_lock (&emergency_mutex); 112 #endif 113 114 bitmask_type used = emergency_used; 115 unsigned int which = 0; 116 117 if (thrown_size > EMERGENCY_OBJ_SIZE) 118 goto failed; 119 while (used & 1) 120 { 121 used >>= 1; 122 if (++which >= EMERGENCY_OBJ_COUNT) 123 goto failed; 124 } 125 126 emergency_used |= (bitmask_type)1 << which; 127 ret = &emergency_buffer[which][0]; 128 129 failed:; 130 #ifdef __GTHREADS 131 __gthread_mutex_unlock (&emergency_mutex); 132 #endif 133 if (!ret) 134 std::terminate (); 135 } 136 137 std::memset (ret, 0, sizeof (__cxa_exception)); 138 139 return (void *)((char *)ret + sizeof (__cxa_exception)); 140 } 141 142 143 extern "C" void 144 __cxa_free_exception(void *vptr) 145 { 146 char *ptr = (char *) vptr; 147 if (ptr >= &emergency_buffer[0][0] 148 && ptr < &emergency_buffer[0][0] + sizeof (emergency_buffer)) 149 { 150 unsigned int which 151 = (unsigned)(ptr - &emergency_buffer[0][0]) / EMERGENCY_OBJ_SIZE; 152 153 #ifdef __GTHREADS 154 __gthread_mutex_lock (&emergency_mutex); 155 emergency_used &= ~((bitmask_type)1 << which); 156 __gthread_mutex_unlock (&emergency_mutex); 157 #else 158 emergency_used &= ~((bitmask_type)1 << which); 159 #endif 160 } 161 else 162 std::free (ptr - sizeof (__cxa_exception)); 163 } 164