* libsupc++/eh_arm.cc (__cxa_type_match): Handle foreign
[people/dverkamp/gcc.git] / libstdc++-v3 / libsupc++ / eh_arm.cc
1 // -*- C++ -*- ARM specific Exception handling support routines.
2 // Copyright (C) 2004, 2005 Free Software Foundation, Inc.
3 //
4 // This file is part of GCC.
5 //
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)
9 // any later version.
10 //
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.
15 //
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.
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 #include <cxxabi.h>
31 #include "unwind-cxx.h"
32
33 #ifdef __ARM_EABI_UNWINDER__
34
35 using namespace __cxxabiv1;
36
37
38 // Given the thrown type THROW_TYPE, pointer to a variable containing a
39 // pointer to the exception object THROWN_PTR_P and a type CATCH_TYPE to
40 // compare against, return whether or not there is a match and if so,
41 // update *THROWN_PTR_P.
42
43 extern "C" __cxa_type_match_result
44 __cxa_type_match(_Unwind_Exception* ue_header,
45                  const std::type_info* catch_type,
46                  bool is_reference __attribute__((__unused__)),
47                  void** thrown_ptr_p)
48 {
49   bool foreign_exception = !__is_gxx_exception_class(ue_header->exception_class);
50   __cxa_exception* xh = __get_exception_header_from_ue(ue_header);
51   const std::type_info* throw_type;
52
53   // XXX What to do with forced unwind?
54   if (foreign_exception)
55     throw_type = &typeid(abi::__foreign_exception);
56   else
57     throw_type = xh->exceptionType;
58
59   void* thrown_ptr = *thrown_ptr_p;
60
61   // Pointer types need to adjust the actual pointer, not
62   // the pointer to pointer that is the exception object.
63   // This also has the effect of passing pointer types
64   // "by value" through the __cxa_begin_catch return value.
65   if (throw_type->__is_pointer_p())
66     thrown_ptr = *(void**) thrown_ptr;
67
68   if (catch_type->__do_catch(throw_type, &thrown_ptr, 1))
69     {
70       *thrown_ptr_p = thrown_ptr;
71
72       if (typeid(*catch_type) == typeid (typeid(void*)))
73         {
74           const __pointer_type_info *catch_pointer_type =
75             static_cast<const __pointer_type_info *> (catch_type);
76           const __pointer_type_info *throw_pointer_type =
77             static_cast<const __pointer_type_info *> (throw_type);
78
79           if (typeid (*catch_pointer_type->__pointee) != typeid (void)
80               && (*catch_pointer_type->__pointee != 
81                   *throw_pointer_type->__pointee))
82             return ctm_succeeded_with_ptr_to_base;
83         }
84
85       return ctm_succeeded;
86     }
87
88   return ctm_failed;
89 }
90
91 // ABI defined routine called at the start of a cleanup handler.
92 extern "C" bool
93 __cxa_begin_cleanup(_Unwind_Exception* ue_header)
94 {
95   __cxa_eh_globals *globals = __cxa_get_globals();
96   __cxa_exception *header = __get_exception_header_from_ue(ue_header);
97   bool native = __is_gxx_exception_class(header->unwindHeader.exception_class);
98
99
100   if (native)
101     {
102       header->propagationCount++;
103       // Add it to the chain if this is the first time we've seen this
104       // exception.
105       if (header->propagationCount == 1)
106         {
107           header->nextPropagatingException = globals->propagatingExceptions;
108           globals->propagatingExceptions = header;
109         }
110     }
111   else
112     {
113       // Remember the exception object, so end_cleanup can return it.
114       // These cannot be stacked, so we must abort if we already have
115       // a propagating exception.
116       if (globals->propagatingExceptions)
117         std::terminate ();
118       globals->propagatingExceptions = header;
119     }
120
121   return true;
122 }
123
124 // Do the work for __cxa_end_cleanup.  Returns the currently propagating
125 // exception object.
126 extern "C" _Unwind_Exception *
127 __gnu_end_cleanup(void)
128 {
129   __cxa_exception *header;
130   __cxa_eh_globals *globals = __cxa_get_globals();
131
132   header = globals->propagatingExceptions;
133
134   // Check something hasn't gone horribly wrong.
135   if (!header)
136     std::terminate();
137
138   if (__is_gxx_exception_class(header->unwindHeader.exception_class))
139     {
140       header->propagationCount--;
141       if (header->propagationCount == 0)
142         {
143           // Remove exception from chain.
144           globals->propagatingExceptions = header->nextPropagatingException;
145           header->nextPropagatingException = NULL;
146         }
147     }
148   else
149     globals->propagatingExceptions = NULL;
150
151   return &header->unwindHeader;
152 }
153
154 // Assembly wrapper to call __gnu_end_cleanup without clobbering r1-r3.
155 // Also push r4 to preserve stack alignment.
156 #ifdef __thumb__
157 asm (".global __cxa_end_cleanup\n"
158 "       .type __cxa_end_cleanup, \"function\"\n"
159 "       .thumb_func\n"
160 "__cxa_end_cleanup:\n"
161 "       push\t{r1, r2, r3, r4}\n"
162 "       bl\t__gnu_end_cleanup\n"
163 "       pop\t{r1, r2, r3, r4}\n"
164 "       bl\t_Unwind_Resume @ Never returns\n");
165 #else
166 asm (".global __cxa_end_cleanup\n"
167 "       .type __cxa_end_cleanup, \"function\"\n"
168 "__cxa_end_cleanup:\n"
169 "       stmfd\tsp!, {r1, r2, r3, r4}\n"
170 "       bl\t__gnu_end_cleanup\n"
171 "       ldmfd\tsp!, {r1, r2, r3, r4}\n"
172 "       bl\t_Unwind_Resume @ Never returns\n");
173 #endif
174
175 #endif