xref: /aosp_15_r20/art/runtime/common_throws.h (revision 795d594fd825385562da6b089ea9b2033f3abf5a) 
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)
45     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
46 
47 void ThrowAbstractMethodError(uint32_t method_idx, const DexFile& dex_file)
48     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
49 
50 // ArithmeticException
51 
52 EXPORT void ThrowArithmeticExceptionDivideByZero() REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
53 
54 // ArrayIndexOutOfBoundsException
55 
56 void ThrowArrayIndexOutOfBoundsException(int index, int length)
57     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
58 
59 // ArrayStoreException
60 
61 void ThrowArrayStoreException(ObjPtr<mirror::Class> element_class,
62                               ObjPtr<mirror::Class> array_class)
63     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
64 
65 // BootstrapMethodError
66 
67 void ThrowBootstrapMethodError(const char* fmt, ...)
68     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
69 
70 void ThrowWrappedBootstrapMethodError(const char* fmt, ...)
71     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
72 
73 // ClassCircularityError
74 
75 void ThrowClassCircularityError(ObjPtr<mirror::Class> c)
76     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
77 
78 void ThrowClassCircularityError(ObjPtr<mirror::Class> c, const char* fmt, ...)
79     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
80 
81 // ClassCastException
82 
83 EXPORT void ThrowClassCastException(ObjPtr<mirror::Class> dest_type, ObjPtr<mirror::Class> src_type)
84     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
85 
86 void ThrowClassCastException(const char* msg)
87     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
88 
89 // ClassFormatError
90 
91 EXPORT void ThrowClassFormatError(ObjPtr<mirror::Class> referrer, const char* fmt, ...)
92     __attribute__((__format__(__printf__, 2, 3))) REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
93 
94 // IllegalAccessError
95 
96 EXPORT void ThrowIllegalAccessErrorClass(ObjPtr<mirror::Class> referrer,
97                                          ObjPtr<mirror::Class> accessed)
98     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
99 
100 void ThrowIllegalAccessErrorClassForMethodDispatch(ObjPtr<mirror::Class> referrer,
101                                                    ObjPtr<mirror::Class> accessed,
102                                                    ArtMethod* called,
103                                                    InvokeType type)
104     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
105 
106 void ThrowIllegalAccessErrorMethod(ObjPtr<mirror::Class> referrer, ArtMethod* accessed)
107     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
108 
109 EXPORT void ThrowIllegalAccessErrorField(ObjPtr<mirror::Class> referrer, ArtField* accessed)
110     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
111 
112 EXPORT void ThrowIllegalAccessErrorFinalField(ArtMethod* referrer, ArtField* accessed)
113     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
114 
115 EXPORT void ThrowIllegalAccessError(ObjPtr<mirror::Class> referrer, const char* fmt, ...)
116     __attribute__((__format__(__printf__, 2, 3)))
117     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
118 
119 void ThrowIllegalAccessErrorForImplementingMethod(ObjPtr<mirror::Class> klass,
120                                                   ArtMethod* implementation_method,
121                                                   ArtMethod* interface_method)
122     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
123 
124 // IllegalAccessException
125 
126 void ThrowIllegalAccessException(const char* msg)
127     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
128 
129 // IllegalArgumentException
130 
131 void ThrowIllegalArgumentException(const char* msg)
132     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
133 
134 // IllegalAccessException
135 
136 EXPORT void ThrowIllegalStateException(const char* msg)
137     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
138 
139 // IncompatibleClassChangeError
140 
141 void ThrowIncompatibleClassChangeError(InvokeType expected_type,
142                                        InvokeType found_type,
143                                        ArtMethod* method,
144                                        ArtMethod* referrer)
145     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
146 
147 EXPORT void ThrowIncompatibleClassChangeErrorClassForInterfaceDispatch(
148     ArtMethod* interface_method, ObjPtr<mirror::Object> this_object, ArtMethod* referrer)
149     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
150 
151 EXPORT void ThrowIncompatibleClassChangeErrorField(
152     ArtField* resolved_field, bool is_static, ArtMethod* referrer)
153     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
154 
155 void ThrowIncompatibleClassChangeError(ObjPtr<mirror::Class> referrer, const char* fmt, ...)
156     __attribute__((__format__(__printf__, 2, 3)))
157     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
158 
159 void ThrowIncompatibleClassChangeErrorForMethodConflict(ArtMethod* method)
160     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
161 
162 // IndexOutOfBoundsException
163 
164 void ThrowIndexOutOfBoundsException(int index, int length)
165     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
166 
167 // InternalError
168 
169 void ThrowInternalError(const char* fmt, ...)
170     __attribute__((__format__(__printf__, 1, 2)))
171     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
172 
173 // IOException
174 
175 void ThrowIOException(const char* fmt, ...) __attribute__((__format__(__printf__, 1, 2)))
176     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
177 
178 void ThrowWrappedIOException(const char* fmt, ...) __attribute__((__format__(__printf__, 1, 2)))
179     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
180 
181 // LinkageError
182 
183 void ThrowLinkageError(ObjPtr<mirror::Class> referrer, const char* fmt, ...)
184     __attribute__((__format__(__printf__, 2, 3)))
185     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
186 
187 void ThrowWrappedLinkageError(ObjPtr<mirror::Class> referrer, const char* fmt, ...)
188     __attribute__((__format__(__printf__, 2, 3)))
189     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
190 
191 // NegativeArraySizeException
192 
193 EXPORT void ThrowNegativeArraySizeException(int size)
194     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
195 
196 void ThrowNegativeArraySizeException(const char* msg)
197     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
198 
199 
200 // NoSuchFieldError
201 
202 EXPORT void ThrowNoSuchFieldError(std::string_view scope,
203                                   ObjPtr<mirror::Class> c,
204                                   std::string_view type,
205                                   std::string_view name)
206     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
207 
208 void ThrowNoSuchFieldException(ObjPtr<mirror::Class> c, std::string_view name)
209     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
210 
211 // NoSuchMethodError
212 
213 void ThrowNoSuchMethodError(InvokeType type,
214                             ObjPtr<mirror::Class> c,
215                             std::string_view name,
216                             const Signature& signature)
217     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
218 
219 void ThrowNoSuchMethodError(ObjPtr<mirror::Class> c,
220                             std::string_view name,
221                             const Signature& signature)
222     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
223 
224 // NullPointerException
225 EXPORT
226 void ThrowNullPointerExceptionForFieldAccess(ArtField* field, ArtMethod* method, bool is_read)
227     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
228 
229 EXPORT void ThrowNullPointerExceptionForMethodAccess(uint32_t method_idx, InvokeType type)
230     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
231 
232 void ThrowNullPointerExceptionForMethodAccess(ArtMethod* method, InvokeType type)
233     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
234 
235 void ThrowNullPointerExceptionFromDexPC(bool check_address = false, uintptr_t addr = 0)
236     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
237 
238 EXPORT void ThrowNullPointerException(const char* msg)
239     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
240 
241 EXPORT void ThrowNullPointerException()
242     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
243 
244 // ReadOnlyBufferException
245 
246 void ThrowReadOnlyBufferException() REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
247 
248 // RuntimeException
249 
250 void ThrowRuntimeException(const char* fmt, ...)
251     __attribute__((__format__(__printf__, 1, 2)))
252     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
253 
254 // SecurityException
255 
256 void ThrowSecurityException(const char* fmt, ...)
257     __attribute__((__format__(__printf__, 1, 2)))
258     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
259 
260 // Stack overflow.
261 
262 template <StackType stack_type>
263 void ThrowStackOverflowError(Thread* self) REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
264 
265 // StringIndexOutOfBoundsException
266 
267 void ThrowStringIndexOutOfBoundsException(int index, int length)
268     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
269 
270 // UnsupportedOperationException
271 
272 void ThrowUnsupportedOperationException() REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
273 
274 // VerifyError
275 
276 void ThrowVerifyError(ObjPtr<mirror::Class> referrer, const char* fmt, ...)
277     __attribute__((__format__(__printf__, 2, 3)))
278     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
279 
280 // WrongMethodTypeException
281 
282 void ThrowWrongMethodTypeException(ObjPtr<mirror::MethodType> callee_type,
283                                    ObjPtr<mirror::MethodType> callsite_type)
284     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
285 
286 void ThrowWrongMethodTypeException(const std::string& expected_descriptor,
287                                    const std::string& actual_descriptor)
288     REQUIRES_SHARED(Locks::mutator_lock_) COLD_ATTR;
289 
290 }  // namespace art
291 
292 #endif  // ART_RUNTIME_COMMON_THROWS_H_
293