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 #include "common_throws.h"
18 
19 #include <sstream>
20 
21 #include "ScopedLocalRef.h"
22 
23 #include "art_field-inl.h"
24 #include "art_method-inl.h"
25 #include "base/logging.h"
26 #include "class_linker-inl.h"
27 #include "dex_file-inl.h"
28 #include "dex_instruction-inl.h"
29 #include "invoke_type.h"
30 #include "mirror/class-inl.h"
31 #include "mirror/object-inl.h"
32 #include "mirror/object_array-inl.h"
33 #include "thread.h"
34 #include "verifier/method_verifier.h"
35 
36 namespace art {
37 
AddReferrerLocation(std::ostream & os,mirror::Class * referrer)38 static void AddReferrerLocation(std::ostream& os, mirror::Class* referrer)
39     SHARED_REQUIRES(Locks::mutator_lock_) {
40   if (referrer != nullptr) {
41     std::string location(referrer->GetLocation());
42     if (!location.empty()) {
43       os << " (declaration of '" << PrettyDescriptor(referrer)
44             << "' appears in " << location << ")";
45     }
46   }
47 }
48 
ThrowException(const char * exception_descriptor,mirror::Class * referrer,const char * fmt,va_list * args=nullptr)49 static void ThrowException(const char* exception_descriptor,
50                            mirror::Class* referrer, const char* fmt, va_list* args = nullptr)
51     SHARED_REQUIRES(Locks::mutator_lock_) {
52   std::ostringstream msg;
53   if (args != nullptr) {
54     std::string vmsg;
55     StringAppendV(&vmsg, fmt, *args);
56     msg << vmsg;
57   } else {
58     msg << fmt;
59   }
60   AddReferrerLocation(msg, referrer);
61   Thread* self = Thread::Current();
62   self->ThrowNewException(exception_descriptor, msg.str().c_str());
63 }
64 
ThrowWrappedException(const char * exception_descriptor,mirror::Class * referrer,const char * fmt,va_list * args=nullptr)65 static void ThrowWrappedException(const char* exception_descriptor,
66                                   mirror::Class* referrer, const char* fmt, va_list* args = nullptr)
67     SHARED_REQUIRES(Locks::mutator_lock_) {
68   std::ostringstream msg;
69   if (args != nullptr) {
70     std::string vmsg;
71     StringAppendV(&vmsg, fmt, *args);
72     msg << vmsg;
73   } else {
74     msg << fmt;
75   }
76   AddReferrerLocation(msg, referrer);
77   Thread* self = Thread::Current();
78   self->ThrowNewWrappedException(exception_descriptor, msg.str().c_str());
79 }
80 
81 // AbstractMethodError
82 
ThrowAbstractMethodError(ArtMethod * method)83 void ThrowAbstractMethodError(ArtMethod* method) {
84   ThrowException("Ljava/lang/AbstractMethodError;", nullptr,
85                  StringPrintf("abstract method \"%s\"",
86                               PrettyMethod(method).c_str()).c_str());
87 }
88 
ThrowAbstractMethodError(uint32_t method_idx,const DexFile & dex_file)89 void ThrowAbstractMethodError(uint32_t method_idx, const DexFile& dex_file) {
90   ThrowException("Ljava/lang/AbstractMethodError;", /* referrer */ nullptr,
91                  StringPrintf("abstract method \"%s\"",
92                               PrettyMethod(method_idx,
93                                            dex_file,
94                                            /* with_signature */ true).c_str()).c_str());
95 }
96 
97 // ArithmeticException
98 
ThrowArithmeticExceptionDivideByZero()99 void ThrowArithmeticExceptionDivideByZero() {
100   ThrowException("Ljava/lang/ArithmeticException;", nullptr, "divide by zero");
101 }
102 
103 // ArrayIndexOutOfBoundsException
104 
ThrowArrayIndexOutOfBoundsException(int index,int length)105 void ThrowArrayIndexOutOfBoundsException(int index, int length) {
106   ThrowException("Ljava/lang/ArrayIndexOutOfBoundsException;", nullptr,
107                  StringPrintf("length=%d; index=%d", length, index).c_str());
108 }
109 
110 // ArrayStoreException
111 
ThrowArrayStoreException(mirror::Class * element_class,mirror::Class * array_class)112 void ThrowArrayStoreException(mirror::Class* element_class, mirror::Class* array_class) {
113   ThrowException("Ljava/lang/ArrayStoreException;", nullptr,
114                  StringPrintf("%s cannot be stored in an array of type %s",
115                               PrettyDescriptor(element_class).c_str(),
116                               PrettyDescriptor(array_class).c_str()).c_str());
117 }
118 
119 // ClassCastException
120 
ThrowClassCastException(mirror::Class * dest_type,mirror::Class * src_type)121 void ThrowClassCastException(mirror::Class* dest_type, mirror::Class* src_type) {
122   ThrowException("Ljava/lang/ClassCastException;", nullptr,
123                  StringPrintf("%s cannot be cast to %s",
124                               PrettyDescriptor(src_type).c_str(),
125                               PrettyDescriptor(dest_type).c_str()).c_str());
126 }
127 
ThrowClassCastException(const char * msg)128 void ThrowClassCastException(const char* msg) {
129   ThrowException("Ljava/lang/ClassCastException;", nullptr, msg);
130 }
131 
132 // ClassCircularityError
133 
ThrowClassCircularityError(mirror::Class * c)134 void ThrowClassCircularityError(mirror::Class* c) {
135   std::ostringstream msg;
136   msg << PrettyDescriptor(c);
137   ThrowException("Ljava/lang/ClassCircularityError;", c, msg.str().c_str());
138 }
139 
ThrowClassCircularityError(mirror::Class * c,const char * fmt,...)140 void ThrowClassCircularityError(mirror::Class* c, const char* fmt, ...) {
141   va_list args;
142   va_start(args, fmt);
143   ThrowException("Ljava/lang/ClassCircularityError;", c, fmt, &args);
144   va_end(args);
145 }
146 
147 // ClassFormatError
148 
ThrowClassFormatError(mirror::Class * referrer,const char * fmt,...)149 void ThrowClassFormatError(mirror::Class* referrer, const char* fmt, ...) {
150   va_list args;
151   va_start(args, fmt);
152   ThrowException("Ljava/lang/ClassFormatError;", referrer, fmt, &args);
153   va_end(args);}
154 
155 // IllegalAccessError
156 
ThrowIllegalAccessErrorClass(mirror::Class * referrer,mirror::Class * accessed)157 void ThrowIllegalAccessErrorClass(mirror::Class* referrer, mirror::Class* accessed) {
158   std::ostringstream msg;
159   msg << "Illegal class access: '" << PrettyDescriptor(referrer) << "' attempting to access '"
160       << PrettyDescriptor(accessed) << "'";
161   ThrowException("Ljava/lang/IllegalAccessError;", referrer, msg.str().c_str());
162 }
163 
ThrowIllegalAccessErrorClassForMethodDispatch(mirror::Class * referrer,mirror::Class * accessed,ArtMethod * called,InvokeType type)164 void ThrowIllegalAccessErrorClassForMethodDispatch(mirror::Class* referrer, mirror::Class* accessed,
165                                                    ArtMethod* called,
166                                                    InvokeType type) {
167   std::ostringstream msg;
168   msg << "Illegal class access ('" << PrettyDescriptor(referrer) << "' attempting to access '"
169       << PrettyDescriptor(accessed) << "') in attempt to invoke " << type
170       << " method " << PrettyMethod(called).c_str();
171   ThrowException("Ljava/lang/IllegalAccessError;", referrer, msg.str().c_str());
172 }
173 
ThrowIllegalAccessErrorMethod(mirror::Class * referrer,ArtMethod * accessed)174 void ThrowIllegalAccessErrorMethod(mirror::Class* referrer, ArtMethod* accessed) {
175   std::ostringstream msg;
176   msg << "Method '" << PrettyMethod(accessed) << "' is inaccessible to class '"
177       << PrettyDescriptor(referrer) << "'";
178   ThrowException("Ljava/lang/IllegalAccessError;", referrer, msg.str().c_str());
179 }
180 
ThrowIllegalAccessErrorField(mirror::Class * referrer,ArtField * accessed)181 void ThrowIllegalAccessErrorField(mirror::Class* referrer, ArtField* accessed) {
182   std::ostringstream msg;
183   msg << "Field '" << PrettyField(accessed, false) << "' is inaccessible to class '"
184       << PrettyDescriptor(referrer) << "'";
185   ThrowException("Ljava/lang/IllegalAccessError;", referrer, msg.str().c_str());
186 }
187 
ThrowIllegalAccessErrorFinalField(ArtMethod * referrer,ArtField * accessed)188 void ThrowIllegalAccessErrorFinalField(ArtMethod* referrer, ArtField* accessed) {
189   std::ostringstream msg;
190   msg << "Final field '" << PrettyField(accessed, false) << "' cannot be written to by method '"
191       << PrettyMethod(referrer) << "'";
192   ThrowException("Ljava/lang/IllegalAccessError;",
193                  referrer != nullptr ? referrer->GetDeclaringClass() : nullptr,
194                  msg.str().c_str());
195 }
196 
ThrowIllegalAccessError(mirror::Class * referrer,const char * fmt,...)197 void ThrowIllegalAccessError(mirror::Class* referrer, const char* fmt, ...) {
198   va_list args;
199   va_start(args, fmt);
200   ThrowException("Ljava/lang/IllegalAccessError;", referrer, fmt, &args);
201   va_end(args);
202 }
203 
204 // IllegalAccessException
205 
ThrowIllegalAccessException(const char * msg)206 void ThrowIllegalAccessException(const char* msg) {
207   ThrowException("Ljava/lang/IllegalAccessException;", nullptr, msg);
208 }
209 
210 // IllegalArgumentException
211 
ThrowIllegalArgumentException(const char * msg)212 void ThrowIllegalArgumentException(const char* msg) {
213   ThrowException("Ljava/lang/IllegalArgumentException;", nullptr, msg);
214 }
215 
216 
217 // IncompatibleClassChangeError
218 
ThrowIncompatibleClassChangeError(InvokeType expected_type,InvokeType found_type,ArtMethod * method,ArtMethod * referrer)219 void ThrowIncompatibleClassChangeError(InvokeType expected_type, InvokeType found_type,
220                                        ArtMethod* method, ArtMethod* referrer) {
221   std::ostringstream msg;
222   msg << "The method '" << PrettyMethod(method) << "' was expected to be of type "
223       << expected_type << " but instead was found to be of type " << found_type;
224   ThrowException("Ljava/lang/IncompatibleClassChangeError;",
225                  referrer != nullptr ? referrer->GetDeclaringClass() : nullptr,
226                  msg.str().c_str());
227 }
228 
ThrowIncompatibleClassChangeErrorClassForInterfaceSuper(ArtMethod * method,mirror::Class * target_class,mirror::Object * this_object,ArtMethod * referrer)229 void ThrowIncompatibleClassChangeErrorClassForInterfaceSuper(ArtMethod* method,
230                                                              mirror::Class* target_class,
231                                                              mirror::Object* this_object,
232                                                              ArtMethod* referrer) {
233   // Referrer is calling interface_method on this_object, however, the interface_method isn't
234   // implemented by this_object.
235   CHECK(this_object != nullptr);
236   std::ostringstream msg;
237   msg << "Class '" << PrettyDescriptor(this_object->GetClass())
238       << "' does not implement interface '" << PrettyDescriptor(target_class) << "' in call to '"
239       << PrettyMethod(method) << "'";
240   ThrowException("Ljava/lang/IncompatibleClassChangeError;",
241                  referrer != nullptr ? referrer->GetDeclaringClass() : nullptr,
242                  msg.str().c_str());
243 }
244 
ThrowIncompatibleClassChangeErrorClassForInterfaceDispatch(ArtMethod * interface_method,mirror::Object * this_object,ArtMethod * referrer)245 void ThrowIncompatibleClassChangeErrorClassForInterfaceDispatch(ArtMethod* interface_method,
246                                                                 mirror::Object* this_object,
247                                                                 ArtMethod* referrer) {
248   // Referrer is calling interface_method on this_object, however, the interface_method isn't
249   // implemented by this_object.
250   CHECK(this_object != nullptr);
251   std::ostringstream msg;
252   msg << "Class '" << PrettyDescriptor(this_object->GetClass())
253       << "' does not implement interface '"
254       << PrettyDescriptor(interface_method->GetDeclaringClass())
255       << "' in call to '" << PrettyMethod(interface_method) << "'";
256   ThrowException("Ljava/lang/IncompatibleClassChangeError;",
257                  referrer != nullptr ? referrer->GetDeclaringClass() : nullptr,
258                  msg.str().c_str());
259 }
260 
ThrowIncompatibleClassChangeErrorField(ArtField * resolved_field,bool is_static,ArtMethod * referrer)261 void ThrowIncompatibleClassChangeErrorField(ArtField* resolved_field, bool is_static,
262                                             ArtMethod* referrer) {
263   std::ostringstream msg;
264   msg << "Expected '" << PrettyField(resolved_field) << "' to be a "
265       << (is_static ? "static" : "instance") << " field" << " rather than a "
266       << (is_static ? "instance" : "static") << " field";
267   ThrowException("Ljava/lang/IncompatibleClassChangeError;", referrer->GetDeclaringClass(),
268                  msg.str().c_str());
269 }
270 
ThrowIncompatibleClassChangeError(mirror::Class * referrer,const char * fmt,...)271 void ThrowIncompatibleClassChangeError(mirror::Class* referrer, const char* fmt, ...) {
272   va_list args;
273   va_start(args, fmt);
274   ThrowException("Ljava/lang/IncompatibleClassChangeError;", referrer, fmt, &args);
275   va_end(args);
276 }
277 
ThrowIncompatibleClassChangeErrorForMethodConflict(ArtMethod * method)278 void ThrowIncompatibleClassChangeErrorForMethodConflict(ArtMethod* method) {
279   DCHECK(method != nullptr);
280   ThrowException("Ljava/lang/IncompatibleClassChangeError;",
281                  /*referrer*/nullptr,
282                  StringPrintf("Conflicting default method implementations %s",
283                               PrettyMethod(method).c_str()).c_str());
284 }
285 
286 
287 // IOException
288 
ThrowIOException(const char * fmt,...)289 void ThrowIOException(const char* fmt, ...) {
290   va_list args;
291   va_start(args, fmt);
292   ThrowException("Ljava/io/IOException;", nullptr, fmt, &args);
293   va_end(args);
294 }
295 
ThrowWrappedIOException(const char * fmt,...)296 void ThrowWrappedIOException(const char* fmt, ...) {
297   va_list args;
298   va_start(args, fmt);
299   ThrowWrappedException("Ljava/io/IOException;", nullptr, fmt, &args);
300   va_end(args);
301 }
302 
303 // LinkageError
304 
ThrowLinkageError(mirror::Class * referrer,const char * fmt,...)305 void ThrowLinkageError(mirror::Class* referrer, const char* fmt, ...) {
306   va_list args;
307   va_start(args, fmt);
308   ThrowException("Ljava/lang/LinkageError;", referrer, fmt, &args);
309   va_end(args);
310 }
311 
ThrowWrappedLinkageError(mirror::Class * referrer,const char * fmt,...)312 void ThrowWrappedLinkageError(mirror::Class* referrer, const char* fmt, ...) {
313   va_list args;
314   va_start(args, fmt);
315   ThrowWrappedException("Ljava/lang/LinkageError;", referrer, fmt, &args);
316   va_end(args);
317 }
318 
319 // NegativeArraySizeException
320 
ThrowNegativeArraySizeException(int size)321 void ThrowNegativeArraySizeException(int size) {
322   ThrowException("Ljava/lang/NegativeArraySizeException;", nullptr,
323                  StringPrintf("%d", size).c_str());
324 }
325 
ThrowNegativeArraySizeException(const char * msg)326 void ThrowNegativeArraySizeException(const char* msg) {
327   ThrowException("Ljava/lang/NegativeArraySizeException;", nullptr, msg);
328 }
329 
330 // NoSuchFieldError
331 
ThrowNoSuchFieldError(const StringPiece & scope,mirror::Class * c,const StringPiece & type,const StringPiece & name)332 void ThrowNoSuchFieldError(const StringPiece& scope, mirror::Class* c,
333                            const StringPiece& type, const StringPiece& name) {
334   std::ostringstream msg;
335   std::string temp;
336   msg << "No " << scope << "field " << name << " of type " << type
337       << " in class " << c->GetDescriptor(&temp) << " or its superclasses";
338   ThrowException("Ljava/lang/NoSuchFieldError;", c, msg.str().c_str());
339 }
340 
ThrowNoSuchFieldException(mirror::Class * c,const StringPiece & name)341 void ThrowNoSuchFieldException(mirror::Class* c, const StringPiece& name) {
342   std::ostringstream msg;
343   std::string temp;
344   msg << "No field " << name << " in class " << c->GetDescriptor(&temp);
345   ThrowException("Ljava/lang/NoSuchFieldException;", c, msg.str().c_str());
346 }
347 
348 // NoSuchMethodError
349 
ThrowNoSuchMethodError(InvokeType type,mirror::Class * c,const StringPiece & name,const Signature & signature)350 void ThrowNoSuchMethodError(InvokeType type, mirror::Class* c, const StringPiece& name,
351                             const Signature& signature) {
352   std::ostringstream msg;
353   std::string temp;
354   msg << "No " << type << " method " << name << signature
355       << " in class " << c->GetDescriptor(&temp) << " or its super classes";
356   ThrowException("Ljava/lang/NoSuchMethodError;", c, msg.str().c_str());
357 }
358 
ThrowNoSuchMethodError(uint32_t method_idx)359 void ThrowNoSuchMethodError(uint32_t method_idx) {
360   ArtMethod* method = Thread::Current()->GetCurrentMethod(nullptr);
361   mirror::DexCache* dex_cache = method->GetDeclaringClass()->GetDexCache();
362   const DexFile& dex_file = *dex_cache->GetDexFile();
363   std::ostringstream msg;
364   msg << "No method '" << PrettyMethod(method_idx, dex_file, true) << "'";
365   ThrowException("Ljava/lang/NoSuchMethodError;",
366                  method->GetDeclaringClass(), msg.str().c_str());
367 }
368 
369 // NullPointerException
370 
ThrowNullPointerExceptionForFieldAccess(ArtField * field,bool is_read)371 void ThrowNullPointerExceptionForFieldAccess(ArtField* field, bool is_read) {
372   std::ostringstream msg;
373   msg << "Attempt to " << (is_read ? "read from" : "write to")
374       << " field '" << PrettyField(field, true) << "' on a null object reference";
375   ThrowException("Ljava/lang/NullPointerException;", nullptr, msg.str().c_str());
376 }
377 
ThrowNullPointerExceptionForMethodAccessImpl(uint32_t method_idx,const DexFile & dex_file,InvokeType type)378 static void ThrowNullPointerExceptionForMethodAccessImpl(uint32_t method_idx,
379                                                          const DexFile& dex_file,
380                                                          InvokeType type)
381     SHARED_REQUIRES(Locks::mutator_lock_) {
382   std::ostringstream msg;
383   msg << "Attempt to invoke " << type << " method '"
384       << PrettyMethod(method_idx, dex_file, true) << "' on a null object reference";
385   ThrowException("Ljava/lang/NullPointerException;", nullptr, msg.str().c_str());
386 }
387 
ThrowNullPointerExceptionForMethodAccess(uint32_t method_idx,InvokeType type)388 void ThrowNullPointerExceptionForMethodAccess(uint32_t method_idx,
389                                               InvokeType type) {
390   mirror::DexCache* dex_cache =
391       Thread::Current()->GetCurrentMethod(nullptr)->GetDeclaringClass()->GetDexCache();
392   const DexFile& dex_file = *dex_cache->GetDexFile();
393   ThrowNullPointerExceptionForMethodAccessImpl(method_idx, dex_file, type);
394 }
395 
ThrowNullPointerExceptionForMethodAccess(ArtMethod * method,InvokeType type)396 void ThrowNullPointerExceptionForMethodAccess(ArtMethod* method,
397                                               InvokeType type) {
398   mirror::DexCache* dex_cache = method->GetDeclaringClass()->GetDexCache();
399   const DexFile& dex_file = *dex_cache->GetDexFile();
400   ThrowNullPointerExceptionForMethodAccessImpl(method->GetDexMethodIndex(),
401                                                dex_file, type);
402 }
403 
ThrowNullPointerExceptionFromDexPC()404 void ThrowNullPointerExceptionFromDexPC() {
405   uint32_t throw_dex_pc;
406   ArtMethod* method = Thread::Current()->GetCurrentMethod(&throw_dex_pc);
407   const DexFile::CodeItem* code = method->GetCodeItem();
408   CHECK_LT(throw_dex_pc, code->insns_size_in_code_units_);
409   const Instruction* instr = Instruction::At(&code->insns_[throw_dex_pc]);
410   switch (instr->Opcode()) {
411     case Instruction::INVOKE_DIRECT:
412       ThrowNullPointerExceptionForMethodAccess(instr->VRegB_35c(), kDirect);
413       break;
414     case Instruction::INVOKE_DIRECT_RANGE:
415       ThrowNullPointerExceptionForMethodAccess(instr->VRegB_3rc(), kDirect);
416       break;
417     case Instruction::INVOKE_VIRTUAL:
418       ThrowNullPointerExceptionForMethodAccess(instr->VRegB_35c(), kVirtual);
419       break;
420     case Instruction::INVOKE_VIRTUAL_RANGE:
421       ThrowNullPointerExceptionForMethodAccess(instr->VRegB_3rc(), kVirtual);
422       break;
423     case Instruction::INVOKE_INTERFACE:
424       ThrowNullPointerExceptionForMethodAccess(instr->VRegB_35c(), kInterface);
425       break;
426     case Instruction::INVOKE_INTERFACE_RANGE:
427       ThrowNullPointerExceptionForMethodAccess(instr->VRegB_3rc(), kInterface);
428       break;
429     case Instruction::INVOKE_VIRTUAL_QUICK:
430     case Instruction::INVOKE_VIRTUAL_RANGE_QUICK: {
431       // Since we replaced the method index, we ask the verifier to tell us which
432       // method is invoked at this location.
433       ArtMethod* invoked_method =
434           verifier::MethodVerifier::FindInvokedMethodAtDexPc(method, throw_dex_pc);
435       if (invoked_method != nullptr) {
436         // NPE with precise message.
437         ThrowNullPointerExceptionForMethodAccess(invoked_method, kVirtual);
438       } else {
439         // NPE with imprecise message.
440         ThrowNullPointerException("Attempt to invoke a virtual method on a null object reference");
441       }
442       break;
443     }
444     case Instruction::IGET:
445     case Instruction::IGET_WIDE:
446     case Instruction::IGET_OBJECT:
447     case Instruction::IGET_BOOLEAN:
448     case Instruction::IGET_BYTE:
449     case Instruction::IGET_CHAR:
450     case Instruction::IGET_SHORT: {
451       ArtField* field =
452           Runtime::Current()->GetClassLinker()->ResolveField(instr->VRegC_22c(), method, false);
453       ThrowNullPointerExceptionForFieldAccess(field, true /* read */);
454       break;
455     }
456     case Instruction::IGET_QUICK:
457     case Instruction::IGET_BOOLEAN_QUICK:
458     case Instruction::IGET_BYTE_QUICK:
459     case Instruction::IGET_CHAR_QUICK:
460     case Instruction::IGET_SHORT_QUICK:
461     case Instruction::IGET_WIDE_QUICK:
462     case Instruction::IGET_OBJECT_QUICK: {
463       // Since we replaced the field index, we ask the verifier to tell us which
464       // field is accessed at this location.
465       ArtField* field =
466           verifier::MethodVerifier::FindAccessedFieldAtDexPc(method, throw_dex_pc);
467       if (field != nullptr) {
468         // NPE with precise message.
469         ThrowNullPointerExceptionForFieldAccess(field, true /* read */);
470       } else {
471         // NPE with imprecise message.
472         ThrowNullPointerException("Attempt to read from a field on a null object reference");
473       }
474       break;
475     }
476     case Instruction::IPUT:
477     case Instruction::IPUT_WIDE:
478     case Instruction::IPUT_OBJECT:
479     case Instruction::IPUT_BOOLEAN:
480     case Instruction::IPUT_BYTE:
481     case Instruction::IPUT_CHAR:
482     case Instruction::IPUT_SHORT: {
483       ArtField* field =
484           Runtime::Current()->GetClassLinker()->ResolveField(instr->VRegC_22c(), method, false);
485       ThrowNullPointerExceptionForFieldAccess(field, false /* write */);
486       break;
487     }
488     case Instruction::IPUT_QUICK:
489     case Instruction::IPUT_BOOLEAN_QUICK:
490     case Instruction::IPUT_BYTE_QUICK:
491     case Instruction::IPUT_CHAR_QUICK:
492     case Instruction::IPUT_SHORT_QUICK:
493     case Instruction::IPUT_WIDE_QUICK:
494     case Instruction::IPUT_OBJECT_QUICK: {
495       // Since we replaced the field index, we ask the verifier to tell us which
496       // field is accessed at this location.
497       ArtField* field =
498           verifier::MethodVerifier::FindAccessedFieldAtDexPc(method, throw_dex_pc);
499       if (field != nullptr) {
500         // NPE with precise message.
501         ThrowNullPointerExceptionForFieldAccess(field, false /* write */);
502       } else {
503         // NPE with imprecise message.
504         ThrowNullPointerException("Attempt to write to a field on a null object reference");
505       }
506       break;
507     }
508     case Instruction::AGET:
509     case Instruction::AGET_WIDE:
510     case Instruction::AGET_OBJECT:
511     case Instruction::AGET_BOOLEAN:
512     case Instruction::AGET_BYTE:
513     case Instruction::AGET_CHAR:
514     case Instruction::AGET_SHORT:
515       ThrowException("Ljava/lang/NullPointerException;", nullptr,
516                      "Attempt to read from null array");
517       break;
518     case Instruction::APUT:
519     case Instruction::APUT_WIDE:
520     case Instruction::APUT_OBJECT:
521     case Instruction::APUT_BOOLEAN:
522     case Instruction::APUT_BYTE:
523     case Instruction::APUT_CHAR:
524     case Instruction::APUT_SHORT:
525       ThrowException("Ljava/lang/NullPointerException;", nullptr,
526                      "Attempt to write to null array");
527       break;
528     case Instruction::ARRAY_LENGTH:
529       ThrowException("Ljava/lang/NullPointerException;", nullptr,
530                      "Attempt to get length of null array");
531       break;
532     default: {
533       // TODO: We should have covered all the cases where we expect a NPE above, this
534       //       message/logging is so we can improve any cases we've missed in the future.
535       const DexFile* dex_file =
536           method->GetDeclaringClass()->GetDexCache()->GetDexFile();
537       ThrowException("Ljava/lang/NullPointerException;", nullptr,
538                      StringPrintf("Null pointer exception during instruction '%s'",
539                                   instr->DumpString(dex_file).c_str()).c_str());
540       break;
541     }
542   }
543 }
544 
ThrowNullPointerException(const char * msg)545 void ThrowNullPointerException(const char* msg) {
546   ThrowException("Ljava/lang/NullPointerException;", nullptr, msg);
547 }
548 
549 // RuntimeException
550 
ThrowRuntimeException(const char * fmt,...)551 void ThrowRuntimeException(const char* fmt, ...) {
552   va_list args;
553   va_start(args, fmt);
554   ThrowException("Ljava/lang/RuntimeException;", nullptr, fmt, &args);
555   va_end(args);
556 }
557 
558 // Stack overflow.
559 
ThrowStackOverflowError(Thread * self)560 void ThrowStackOverflowError(Thread* self) {
561   if (self->IsHandlingStackOverflow()) {
562     LOG(ERROR) << "Recursive stack overflow.";
563     // We don't fail here because SetStackEndForStackOverflow will print better diagnostics.
564   }
565 
566   self->SetStackEndForStackOverflow();  // Allow space on the stack for constructor to execute.
567   JNIEnvExt* env = self->GetJniEnv();
568   std::string msg("stack size ");
569   msg += PrettySize(self->GetStackSize());
570 
571   // Avoid running Java code for exception initialization.
572   // TODO: Checks to make this a bit less brittle.
573 
574   std::string error_msg;
575 
576   // Allocate an uninitialized object.
577   ScopedLocalRef<jobject> exc(env,
578                               env->AllocObject(WellKnownClasses::java_lang_StackOverflowError));
579   if (exc.get() != nullptr) {
580     // "Initialize".
581     // StackOverflowError -> VirtualMachineError -> Error -> Throwable -> Object.
582     // Only Throwable has "custom" fields:
583     //   String detailMessage.
584     //   Throwable cause (= this).
585     //   List<Throwable> suppressedExceptions (= Collections.emptyList()).
586     //   Object stackState;
587     //   StackTraceElement[] stackTrace;
588     // Only Throwable has a non-empty constructor:
589     //   this.stackTrace = EmptyArray.STACK_TRACE_ELEMENT;
590     //   fillInStackTrace();
591 
592     // detailMessage.
593     // TODO: Use String::FromModifiedUTF...?
594     ScopedLocalRef<jstring> s(env, env->NewStringUTF(msg.c_str()));
595     if (s.get() != nullptr) {
596       env->SetObjectField(exc.get(), WellKnownClasses::java_lang_Throwable_detailMessage, s.get());
597 
598       // cause.
599       env->SetObjectField(exc.get(), WellKnownClasses::java_lang_Throwable_cause, exc.get());
600 
601       // suppressedExceptions.
602       ScopedLocalRef<jobject> emptylist(env, env->GetStaticObjectField(
603           WellKnownClasses::java_util_Collections,
604           WellKnownClasses::java_util_Collections_EMPTY_LIST));
605       CHECK(emptylist.get() != nullptr);
606       env->SetObjectField(exc.get(),
607                           WellKnownClasses::java_lang_Throwable_suppressedExceptions,
608                           emptylist.get());
609 
610       // stackState is set as result of fillInStackTrace. fillInStackTrace calls
611       // nativeFillInStackTrace.
612       ScopedLocalRef<jobject> stack_state_val(env, nullptr);
613       {
614         ScopedObjectAccessUnchecked soa(env);
615         stack_state_val.reset(soa.Self()->CreateInternalStackTrace<false>(soa));
616       }
617       if (stack_state_val.get() != nullptr) {
618         env->SetObjectField(exc.get(),
619                             WellKnownClasses::java_lang_Throwable_stackState,
620                             stack_state_val.get());
621 
622         // stackTrace.
623         ScopedLocalRef<jobject> stack_trace_elem(env, env->GetStaticObjectField(
624             WellKnownClasses::libcore_util_EmptyArray,
625             WellKnownClasses::libcore_util_EmptyArray_STACK_TRACE_ELEMENT));
626         env->SetObjectField(exc.get(),
627                             WellKnownClasses::java_lang_Throwable_stackTrace,
628                             stack_trace_elem.get());
629       } else {
630         error_msg = "Could not create stack trace.";
631       }
632       // Throw the exception.
633       self->SetException(reinterpret_cast<mirror::Throwable*>(self->DecodeJObject(exc.get())));
634     } else {
635       // Could not allocate a string object.
636       error_msg = "Couldn't throw new StackOverflowError because JNI NewStringUTF failed.";
637     }
638   } else {
639     error_msg = "Could not allocate StackOverflowError object.";
640   }
641 
642   if (!error_msg.empty()) {
643     LOG(WARNING) << error_msg;
644     CHECK(self->IsExceptionPending());
645   }
646 
647   bool explicit_overflow_check = Runtime::Current()->ExplicitStackOverflowChecks();
648   self->ResetDefaultStackEnd();  // Return to default stack size.
649 
650   // And restore protection if implicit checks are on.
651   if (!explicit_overflow_check) {
652     self->ProtectStack();
653   }
654 }
655 
656 // VerifyError
657 
ThrowVerifyError(mirror::Class * referrer,const char * fmt,...)658 void ThrowVerifyError(mirror::Class* referrer, const char* fmt, ...) {
659   va_list args;
660   va_start(args, fmt);
661   ThrowException("Ljava/lang/VerifyError;", referrer, fmt, &args);
662   va_end(args);
663 }
664 
665 }  // namespace art
666