Chameleon

Chameleon Svn Source Tree

Root/branches/ErmaC/Trunk/i386/modules/uClibcxx/include/unwind-cxx.h

1// -*- C++ -*- Exception handling and frame unwind runtime interface routines.
2// Copyright (C) 2001 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, 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#ifndef _UNWIND_CXX_H
34#define _UNWIND_CXX_H 1
35
36// Level 2: C++ ABI
37
38#include <typeinfo>
39#include <exception>
40#include <cstddef>
41//#include <unwind.h>
42
43namespace __cxxabiv1
44{
45
46#ifdef __UCLIBCXX_EXCEPTION_SUPPORT__
47
48// A C++ exception object consists of a header, which is a wrapper around
49// an unwind object header with additional C++ specific information,
50// followed by the exception object itself.
51
52struct __cxa_exception
53{
54 // Manage the exception object itself.
55 std::type_info *exceptionType;
56 void (*exceptionDestructor)(void *);
57
58 // The C++ standard has entertaining rules wrt calling set_terminate
59 // and set_unexpected in the middle of the exception cleanup process.
60 std::unexpected_handler unexpectedHandler;
61 std::terminate_handler terminateHandler;
62
63 // The caught exception stack threads through here.
64 __cxa_exception *nextException;
65
66 // How many nested handlers have caught this exception. A negated
67 // value is a signal that this object has been rethrown.
68 int handlerCount;
69
70 // Cache parsed handler data from the personality routine Phase 1
71 // for Phase 2 and __cxa_call_unexpected.
72 int handlerSwitchValue;
73 const unsigned char *actionRecord;
74 const unsigned char *languageSpecificData;
75 _Unwind_Ptr catchTemp;
76 void *adjustedPtr;
77
78 // The generic exception header. Must be last.
79 _Unwind_Exception unwindHeader;
80};
81
82// Each thread in a C++ program has access to a __cxa_eh_globals object.
83struct __cxa_eh_globals
84{
85 __cxa_exception *caughtExceptions;
86 unsigned int uncaughtExceptions;
87};
88
89
90// The __cxa_eh_globals for the current thread can be obtained by using
91// either of the following functions. The "fast" version assumes at least
92// one prior call of __cxa_get_globals has been made from the current
93// thread, so no initialization is necessary.
94extern "C" __cxa_eh_globals *__cxa_get_globals () throw();
95extern "C" __cxa_eh_globals *__cxa_get_globals_fast () throw();
96#endif
97
98#ifdef __UCLIBCXX_EXCEPTION_SUPPORT__
99// Allocate memory for the exception plus the thown object.
100extern "C" void *__cxa_allocate_exception(std::size_t thrown_size) throw();
101
102// Free the space allocated for the exception.
103extern "C" void __cxa_free_exception(void *thrown_exception) throw();
104
105// Throw the exception.
106extern "C" void __cxa_throw (void *thrown_exception,
107 std::type_info *tinfo,
108 void (*dest) (void *))
109 __attribute__((noreturn));
110
111// Used to implement exception handlers.
112extern "C" void *__cxa_begin_catch (void *) throw();
113extern "C" void __cxa_end_catch ();
114extern "C" void __cxa_rethrow () __attribute__((noreturn));
115#endif
116
117// These facilitate code generation for recurring situations.
118extern "C" void __cxa_bad_cast ();
119extern "C" void __cxa_bad_typeid ();
120
121// @@@ These are not directly specified by the IA-64 C++ ABI.
122
123// Handles re-checking the exception specification if unexpectedHandler
124// throws, and if bad_exception needs to be thrown. Called from the
125// compiler.
126extern "C" void __cxa_call_unexpected (void *) __attribute__((noreturn));
127
128// Invokes given handler, dying appropriately if the user handler was
129// so inconsiderate as to return.
130extern void __terminate(std::terminate_handler) __attribute__((noreturn));
131extern void __unexpected(std::unexpected_handler) __attribute__((noreturn));
132
133// The current installed user handlers.
134extern std::terminate_handler __terminate_handler;
135extern std::unexpected_handler __unexpected_handler;
136
137#ifdef __UCLIBCXX_EXCEPTION_SUPPORT__
138// Acquire the C++ exception header from the C++ object.
139static inline __cxa_exception *
140__get_exception_header_from_obj (void *ptr)
141{
142 return reinterpret_cast<__cxa_exception *>(ptr) - 1;
143}
144
145// Acquire the C++ exception header from the generic exception header.
146static inline __cxa_exception *
147__get_exception_header_from_ue (_Unwind_Exception *exc)
148{
149 return reinterpret_cast<__cxa_exception *>(exc + 1) - 1;
150}
151#endif
152} /* namespace __cxxabiv1 */
153
154#endif // _UNWIND_CXX_H
155

Archive Download this file

Revision: 2111