• Home
  • Line#
  • Scopes#
  • Navigate#
  • Raw
  • Download
1 /*
2  * Copyright (C) 2012 The Android Open Source Project
3  *
4  * Licensed under the Apache License, Version 2.0 (the "License");
5  * you may not use this file except in compliance with the License.
6  * You may obtain a copy of the License at
7  *
8  *      http://www.apache.org/licenses/LICENSE-2.0
9  *
10  * Unless required by applicable law or agreed to in writing, software
11  * distributed under the License is distributed on an "AS IS" BASIS,
12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
13  * See the License for the specific language governing permissions and
14  * limitations under the License.
15  */
16 
17 #ifndef ART_RUNTIME_COMMON_THROWS_H_
18 #define ART_RUNTIME_COMMON_THROWS_H_
19 
20 #include <string_view>
21 
22 #include "base/locks.h"
23 #include "base/macros.h"
24 #include "obj_ptr.h"
25 
26 namespace art HIDDEN {
27 namespace mirror {
28 class Class;
29 class Object;
30 class MethodType;
31 }  // namespace mirror
32 class ArtField;
33 class ArtMethod;
34 class DexFile;
35 enum InvokeType : uint32_t;
36 class Signature;
37 enum class StackType;
38 
39 // The descriptor of the transaction abort exception.
40 constexpr const char kTransactionAbortErrorDescriptor[] = "Ldalvik/system/TransactionAbortError;";
41 
42 // AbstractMethodError
43 
44 void ThrowAbstractMethodError(ArtMethod* method, ObjPtr<mirror::Object> receiver)
45     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
46 
47 void ThrowAbstractMethodError(uint32_t method_idx,
48                               const DexFile& dex_file,
49                               ObjPtr<mirror::Object> receiver)
50     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
51 
52 // ArithmeticException
53 
54 EXPORT void ThrowArithmeticExceptionDivideByZero() REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
55 
56 // ArrayIndexOutOfBoundsException
57 
58 void ThrowArrayIndexOutOfBoundsException(int index, int length)
59     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
60 
61 // ArrayStoreException
62 
63 void ThrowArrayStoreException(ObjPtr<mirror::Class> element_class,
64                               ObjPtr<mirror::Class> array_class)
65     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
66 
67 // BootstrapMethodError
68 
69 void ThrowBootstrapMethodError(const char* fmt, ...)
70     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
71 
72 void ThrowWrappedBootstrapMethodError(const char* fmt, ...)
73     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
74 
75 // ClassCircularityError
76 
77 void ThrowClassCircularityError(ObjPtr<mirror::Class> c)
78     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
79 
80 void ThrowClassCircularityError(ObjPtr<mirror::Class> c, const char* fmt, ...)
81     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
82 
83 // ClassCastException
84 
85 EXPORT void ThrowClassCastException(ObjPtr<mirror::Class> dest_type, ObjPtr<mirror::Class> src_type)
86     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
87 
88 void ThrowClassCastException(const char* msg)
89     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
90 
91 // ClassFormatError
92 
93 EXPORT void ThrowClassFormatError(ObjPtr<mirror::Class> referrer, const char* fmt, ...)
94     __attribute__((__format__(__printf__, 2, 3))) REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
95 
96 // IllegalAccessError
97 
98 EXPORT void ThrowIllegalAccessErrorClass(ObjPtr<mirror::Class> referrer,
99                                          ObjPtr<mirror::Class> accessed)
100     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
101 
102 void ThrowIllegalAccessErrorClassForMethodDispatch(ObjPtr<mirror::Class> referrer,
103                                                    ObjPtr<mirror::Class> accessed,
104                                                    ArtMethod* called,
105                                                    InvokeType type)
106     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
107 
108 void ThrowIllegalAccessErrorMethod(ObjPtr<mirror::Class> referrer, ArtMethod* accessed)
109     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
110 
111 EXPORT void ThrowIllegalAccessErrorField(ObjPtr<mirror::Class> referrer, ArtField* accessed)
112     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
113 
114 EXPORT void ThrowIllegalAccessErrorFinalField(ArtMethod* referrer, ArtField* accessed)
115     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
116 
117 EXPORT void ThrowIllegalAccessError(ObjPtr<mirror::Class> referrer, const char* fmt, ...)
118     __attribute__((__format__(__printf__, 2, 3)))
119     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
120 
121 void ThrowIllegalAccessErrorForImplementingMethod(ObjPtr<mirror::Class> klass,
122                                                   ArtMethod* implementation_method,
123                                                   ArtMethod* interface_method)
124     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
125 
126 // IllegalAccessException
127 
128 void ThrowIllegalAccessException(const char* msg)
129     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
130 
131 // IllegalArgumentException
132 
133 void ThrowIllegalArgumentException(const char* msg)
134     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
135 
136 // IllegalAccessException
137 
138 EXPORT void ThrowIllegalStateException(const char* msg)
139     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
140 
141 // IncompatibleClassChangeError
142 
143 void ThrowIncompatibleClassChangeError(InvokeType expected_type,
144                                        InvokeType found_type,
145                                        ArtMethod* method,
146                                        ArtMethod* referrer)
147     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
148 
149 EXPORT void ThrowIncompatibleClassChangeErrorClassForInterfaceDispatch(
150     ArtMethod* interface_method, ObjPtr<mirror::Object> this_object, ArtMethod* referrer)
151     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
152 
153 EXPORT void ThrowIncompatibleClassChangeErrorField(
154     ArtField* resolved_field, bool is_static, ArtMethod* referrer)
155     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
156 
157 void ThrowIncompatibleClassChangeError(ObjPtr<mirror::Class> referrer, const char* fmt, ...)
158     __attribute__((__format__(__printf__, 2, 3)))
159     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
160 
161 void ThrowIncompatibleClassChangeErrorForMethodConflict(ArtMethod* method)
162     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
163 
164 // IndexOutOfBoundsException
165 
166 void ThrowIndexOutOfBoundsException(int index, int length)
167     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
168 
169 // InternalError
170 
171 void ThrowInternalError(const char* fmt, ...)
172     __attribute__((__format__(__printf__, 1, 2)))
173     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
174 
175 // IOException
176 
177 void ThrowIOException(const char* fmt, ...) __attribute__((__format__(__printf__, 1, 2)))
178     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
179 
180 void ThrowWrappedIOException(const char* fmt, ...) __attribute__((__format__(__printf__, 1, 2)))
181     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
182 
183 // LinkageError
184 
185 void ThrowLinkageError(ObjPtr<mirror::Class> referrer, const char* fmt, ...)
186     __attribute__((__format__(__printf__, 2, 3)))
187     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
188 
189 void ThrowWrappedLinkageError(ObjPtr<mirror::Class> referrer, const char* fmt, ...)
190     __attribute__((__format__(__printf__, 2, 3)))
191     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
192 
193 // NegativeArraySizeException
194 
195 EXPORT void ThrowNegativeArraySizeException(int size)
196     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
197 
198 void ThrowNegativeArraySizeException(const char* msg)
199     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
200 
201 
202 // NoSuchFieldError
203 
204 EXPORT void ThrowNoSuchFieldError(std::string_view scope,
205                                   ObjPtr<mirror::Class> c,
206                                   std::string_view type,
207                                   std::string_view name)
208     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
209 
210 void ThrowNoSuchFieldException(ObjPtr<mirror::Class> c, std::string_view name)
211     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
212 
213 // NoSuchMethodError
214 
215 void ThrowNoSuchMethodError(InvokeType type,
216                             ObjPtr<mirror::Class> c,
217                             std::string_view name,
218                             const Signature& signature)
219     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
220 
221 void ThrowNoSuchMethodError(ObjPtr<mirror::Class> c,
222                             std::string_view name,
223                             const Signature& signature)
224     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
225 
226 // NullPointerException
227 EXPORT
228 void ThrowNullPointerExceptionForFieldAccess(ArtField* field, ArtMethod* method, bool is_read)
229     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
230 
231 EXPORT void ThrowNullPointerExceptionForMethodAccess(uint32_t method_idx, InvokeType type)
232     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
233 
234 void ThrowNullPointerExceptionForMethodAccess(ArtMethod* method, InvokeType type)
235     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
236 
237 void ThrowNullPointerExceptionFromDexPC(bool check_address = false, uintptr_t addr = 0)
238     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
239 
240 EXPORT void ThrowNullPointerException(const char* msg)
241     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
242 
243 EXPORT void ThrowNullPointerException()
244     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
245 
246 // ReadOnlyBufferException
247 
248 void ThrowReadOnlyBufferException() REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
249 
250 // RuntimeException
251 
252 void ThrowRuntimeException(const char* fmt, ...)
253     __attribute__((__format__(__printf__, 1, 2)))
254     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
255 
256 // SecurityException
257 
258 void ThrowSecurityException(const char* fmt, ...)
259     __attribute__((__format__(__printf__, 1, 2)))
260     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
261 
262 // Stack overflow.
263 
264 template <StackType stack_type>
265 void ThrowStackOverflowError(Thread* self) REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
266 
267 // StringIndexOutOfBoundsException
268 
269 void ThrowStringIndexOutOfBoundsException(int index, int length)
270     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
271 
272 // UnsupportedOperationException
273 
274 void ThrowUnsupportedOperationException() REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
275 
276 // VerifyError
277 
278 void ThrowVerifyError(ObjPtr<mirror::Class> referrer, const char* fmt, ...)
279     __attribute__((__format__(__printf__, 2, 3)))
280     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
281 
282 // WrongMethodTypeException
283 
284 void ThrowWrongMethodTypeException(ObjPtr<mirror::MethodType> callee_type,
285                                    ObjPtr<mirror::MethodType> callsite_type)
286     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
287 
288 void ThrowWrongMethodTypeException(const std::string& expected_descriptor,
289                                    const std::string& actual_descriptor)
290     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
291 
292 }  // namespace art
293 
294 #endif  // ART_RUNTIME_COMMON_THROWS_H_
295