1 //===------------------------ stdexcept.cpp -------------------------------===//
2 //
3 //                     The LLVM Compiler Infrastructure
4 //
5 // This file is dual licensed under the MIT and the University of Illinois Open
6 // Source Licenses. See LICENSE.TXT for details.
7 //
8 //===----------------------------------------------------------------------===//
9 
10 #include "stdexcept"
11 #include "new"
12 #include "string"
13 #include <cstdlib>
14 #include <cstring>
15 #include <cstdint>
16 #include <cstddef>
17 #include "system_error"
18 
19 #ifndef __has_include
20 #define __has_include(inc) 0
21 #endif
22 
23 #ifdef __APPLE__
24 #include <cxxabi.h>
25 #elif defined(LIBCXXRT) || __has_include(<cxxabi.h>)
26 #include <cxxabi.h>
27 #endif
28 
29 // Note:  optimize for size
30 
31 #if ! defined(_LIBCPP_MSVC)
32 #pragma GCC visibility push(hidden)
33 #endif
34 
35 namespace
36 {
37 
38 class __libcpp_nmstr
39 {
40 private:
41     const char* str_;
42 
43     typedef std::size_t unused_t;
44     typedef std::ptrdiff_t count_t;
45 
46     static const std::ptrdiff_t offset = static_cast<std::ptrdiff_t>(2*sizeof(unused_t) +
47                                                                        sizeof(count_t));
48 
49     count_t& count() const _NOEXCEPT {return *const_cast<count_t *>(reinterpret_cast<const count_t *>(str_ - sizeof(count_t)));}
50 public:
51     explicit __libcpp_nmstr(const char* msg);
52     __libcpp_nmstr(const __libcpp_nmstr& s) _NOEXCEPT;
53     __libcpp_nmstr& operator=(const __libcpp_nmstr& s) _NOEXCEPT;
54     ~__libcpp_nmstr();
55     const char* c_str() const _NOEXCEPT {return str_;}
56 };
57 
58 __libcpp_nmstr::__libcpp_nmstr(const char* msg)
59 {
60     std::size_t len = strlen(msg);
61     str_ = new char[len + 1 + offset];
62     unused_t* c = reinterpret_cast<unused_t*>(const_cast<char *>(str_));
63     c[0] = c[1] = len;
64     str_ += offset;
65     count() = 0;
66     std::memcpy(const_cast<char*>(c_str()), msg, len + 1);
67 }
68 
69 inline
70 __libcpp_nmstr::__libcpp_nmstr(const __libcpp_nmstr& s) _NOEXCEPT
71     : str_(s.str_)
72 {
73     __sync_add_and_fetch(&count(), 1);
74 }
75 
76 __libcpp_nmstr&
77 __libcpp_nmstr::operator=(const __libcpp_nmstr& s) _NOEXCEPT
78 {
79     const char* p = str_;
80     str_ = s.str_;
81     __sync_add_and_fetch(&count(), 1);
82     if (__sync_add_and_fetch(reinterpret_cast<count_t*>(const_cast<char*>(p)-sizeof(count_t)), count_t(-1)) < 0)
83         delete [] (p-offset);
84     return *this;
85 }
86 
87 inline
88 __libcpp_nmstr::~__libcpp_nmstr()
89 {
90     if (__sync_add_and_fetch(&count(), count_t(-1)) < 0)
91         delete [] (str_ - offset);
92 }
93 
94 }
95 
96 #if ! defined(_LIBCPP_MSVC)
97 #pragma GCC visibility pop
98 #endif
99 
100 namespace std  // purposefully not using versioning namespace
101 {
102 
103 logic_error::logic_error(const string& msg)
104 {
105     __libcpp_nmstr *s = reinterpret_cast<__libcpp_nmstr *>(&__imp_);
106     ::new(s) __libcpp_nmstr(msg.c_str());
107 }
108 
109 logic_error::logic_error(const char* msg)
110 {
111     __libcpp_nmstr *s = reinterpret_cast<__libcpp_nmstr *>(&__imp_);
112     ::new(s) __libcpp_nmstr(msg);
113 }
114 
115 logic_error::logic_error(const logic_error& le) _NOEXCEPT
116 {
117     __libcpp_nmstr *s = reinterpret_cast<__libcpp_nmstr *>(&__imp_);
118     const __libcpp_nmstr *s2 = reinterpret_cast<const __libcpp_nmstr *>(&le.__imp_);
119     ::new(s) __libcpp_nmstr(*s2);
120 }
121 
122 logic_error&
123 logic_error::operator=(const logic_error& le) _NOEXCEPT
124 {
125     __libcpp_nmstr *s1 = reinterpret_cast<__libcpp_nmstr *>(&__imp_);
126     const __libcpp_nmstr *s2 = reinterpret_cast<const __libcpp_nmstr *>(&le.__imp_);
127     *s1 = *s2;
128     return *this;
129 }
130 
131 #if !defined(_LIBCPPABI_VERSION) && !defined(LIBSTDCXX)
132 
133 logic_error::~logic_error() _NOEXCEPT
134 {
135     __libcpp_nmstr *s = reinterpret_cast<__libcpp_nmstr *>(&__imp_);
136     s->~__libcpp_nmstr();
137 }
138 
139 const char*
140 logic_error::what() const _NOEXCEPT
141 {
142     const __libcpp_nmstr *s = reinterpret_cast<const __libcpp_nmstr *>(&__imp_);
143     return s->c_str();
144 }
145 
146 #endif
147 
148 runtime_error::runtime_error(const string& msg)
149 {
150     __libcpp_nmstr *s = reinterpret_cast<__libcpp_nmstr *>(&__imp_);
151     ::new(s) __libcpp_nmstr(msg.c_str());
152 }
153 
154 runtime_error::runtime_error(const char* msg)
155 {
156     __libcpp_nmstr *s = reinterpret_cast<__libcpp_nmstr *>(&__imp_);
157     ::new(s) __libcpp_nmstr(msg);
158 }
159 
160 runtime_error::runtime_error(const runtime_error& le) _NOEXCEPT
161 {
162     __libcpp_nmstr *s = reinterpret_cast<__libcpp_nmstr *>(&__imp_);
163     const __libcpp_nmstr *s2 = reinterpret_cast<const __libcpp_nmstr *>(&le.__imp_);
164     ::new(s) __libcpp_nmstr(*s2);
165 }
166 
167 runtime_error&
168 runtime_error::operator=(const runtime_error& le) _NOEXCEPT
169 {
170     __libcpp_nmstr *s1 = reinterpret_cast<__libcpp_nmstr *>(&__imp_);
171     const __libcpp_nmstr *s2 = reinterpret_cast<const __libcpp_nmstr *>(&le.__imp_);
172     *s1 = *s2;
173     return *this;
174 }
175 
176 #if !defined(_LIBCPPABI_VERSION) && !defined(LIBSTDCXX)
177 
178 runtime_error::~runtime_error() _NOEXCEPT
179 {
180     __libcpp_nmstr *s = reinterpret_cast<__libcpp_nmstr *>(&__imp_);
181     s->~__libcpp_nmstr();
182 }
183 
184 const char*
185 runtime_error::what() const _NOEXCEPT
186 {
187     const __libcpp_nmstr *s = reinterpret_cast<const __libcpp_nmstr *>(&__imp_);
188     return s->c_str();
189 }
190 
191 domain_error::~domain_error() _NOEXCEPT {}
192 invalid_argument::~invalid_argument() _NOEXCEPT {}
193 length_error::~length_error() _NOEXCEPT {}
194 out_of_range::~out_of_range() _NOEXCEPT {}
195 
196 range_error::~range_error() _NOEXCEPT {}
197 overflow_error::~overflow_error() _NOEXCEPT {}
198 underflow_error::~underflow_error() _NOEXCEPT {}
199 
200 #endif
201 
202 }  // std
203