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