Home | History | Annotate | Download | only in mirror 
      1 /*
      2  * Copyright (C) 2011 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 "throwable.h"
     18 
     19 #include "art_method-inl.h"
     20 #include "class-inl.h"
     21 #include "dex_file-inl.h"
     22 #include "gc/accounting/card_table-inl.h"
     23 #include "object-inl.h"
     24 #include "object_array.h"
     25 #include "object_array-inl.h"
     26 #include "stack_trace_element.h"
     27 #include "utils.h"
     28 #include "well_known_classes.h"
     29 
     30 namespace art {
     31 namespace mirror {
     32 
     33 GcRoot<Class> Throwable::java_lang_Throwable_;
     34 
     35 void Throwable::SetDetailMessage(String* new_detail_message) {
     36   if (Runtime::Current()->IsActiveTransaction()) {
     37     SetFieldObject<true>(OFFSET_OF_OBJECT_MEMBER(Throwable, detail_message_), new_detail_message);
     38   } else {
     39     SetFieldObject<false>(OFFSET_OF_OBJECT_MEMBER(Throwable, detail_message_),
     40                           new_detail_message);
     41   }
     42 }
     43 
     44 void Throwable::SetCause(Throwable* cause) {
     45   CHECK(cause != nullptr);
     46   CHECK(cause != this);
     47   Throwable* current_cause = GetFieldObject<Throwable>(OFFSET_OF_OBJECT_MEMBER(Throwable, cause_));
     48   CHECK(current_cause == NULL || current_cause == this);
     49   if (Runtime::Current()->IsActiveTransaction()) {
     50     SetFieldObject<true>(OFFSET_OF_OBJECT_MEMBER(Throwable, cause_), cause);
     51   } else {
     52     SetFieldObject<false>(OFFSET_OF_OBJECT_MEMBER(Throwable, cause_), cause);
     53   }
     54 }
     55 
     56 void Throwable::SetStackState(Object* state) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
     57   CHECK(state != nullptr);
     58   if (Runtime::Current()->IsActiveTransaction()) {
     59     SetFieldObjectVolatile<true>(OFFSET_OF_OBJECT_MEMBER(Throwable, stack_state_), state);
     60   } else {
     61     SetFieldObjectVolatile<false>(OFFSET_OF_OBJECT_MEMBER(Throwable, stack_state_), state);
     62   }
     63 }
     64 
     65 bool Throwable::IsCheckedException() {
     66   if (InstanceOf(WellKnownClasses::ToClass(WellKnownClasses::java_lang_Error))) {
     67     return false;
     68   }
     69   return !InstanceOf(WellKnownClasses::ToClass(WellKnownClasses::java_lang_RuntimeException));
     70 }
     71 
     72 std::string Throwable::Dump() {
     73   std::string result(PrettyTypeOf(this));
     74   result += ": ";
     75   String* msg = GetDetailMessage();
     76   if (msg != NULL) {
     77     result += msg->ToModifiedUtf8();
     78   }
     79   result += "\n";
     80   Object* stack_state = GetStackState();
     81   // check stack state isn't missing or corrupt
     82   if (stack_state != nullptr && stack_state->IsObjectArray()) {
     83     // Decode the internal stack trace into the depth and method trace
     84     ObjectArray<Object>* method_trace = down_cast<ObjectArray<Object>*>(stack_state);
     85     int32_t depth = method_trace->GetLength() - 1;
     86     IntArray* pc_trace = down_cast<IntArray*>(method_trace->Get(depth));
     87     if (depth == 0) {
     88       result += "(Throwable with empty stack trace)";
     89     } else {
     90       for (int32_t i = 0; i < depth; ++i) {
     91         mirror::ArtMethod* method = down_cast<ArtMethod*>(method_trace->Get(i));
     92         uint32_t dex_pc = pc_trace->Get(i);
     93         int32_t line_number = method->GetLineNumFromDexPC(dex_pc);
     94         const char* source_file = method->GetDeclaringClassSourceFile();
     95         result += StringPrintf("  at %s (%s:%d)\n", PrettyMethod(method, true).c_str(),
     96                                source_file, line_number);
     97       }
     98     }
     99   } else {
    100     Object* stack_trace = GetStackTrace();
    101     if (stack_trace != nullptr && stack_trace->IsObjectArray()) {
    102       CHECK_EQ(stack_trace->GetClass()->GetComponentType(),
    103                StackTraceElement::GetStackTraceElement());
    104       ObjectArray<StackTraceElement>* ste_array =
    105           down_cast<ObjectArray<StackTraceElement>*>(stack_trace);
    106       if (ste_array->GetLength() == 0) {
    107         result += "(Throwable with empty stack trace)";
    108       } else {
    109         for (int32_t i = 0; i < ste_array->GetLength(); ++i) {
    110           StackTraceElement* ste = ste_array->Get(i);
    111           result += StringPrintf("  at %s (%s:%d)\n",
    112                                  ste->GetMethodName()->ToModifiedUtf8().c_str(),
    113                                  ste->GetFileName()->ToModifiedUtf8().c_str(),
    114                                  ste->GetLineNumber());
    115         }
    116       }
    117     } else {
    118       result += "(Throwable with no stack trace)";
    119     }
    120   }
    121   Throwable* cause = GetFieldObject<Throwable>(OFFSET_OF_OBJECT_MEMBER(Throwable, cause_));
    122   if (cause != nullptr && cause != this) {  // Constructor makes cause == this by default.
    123     result += "Caused by: ";
    124     result += cause->Dump();
    125   }
    126   return result;
    127 }
    128 
    129 void Throwable::SetClass(Class* java_lang_Throwable) {
    130   CHECK(java_lang_Throwable_.IsNull());
    131   CHECK(java_lang_Throwable != NULL);
    132   java_lang_Throwable_ = GcRoot<Class>(java_lang_Throwable);
    133 }
    134 
    135 void Throwable::ResetClass() {
    136   CHECK(!java_lang_Throwable_.IsNull());
    137   java_lang_Throwable_ = GcRoot<Class>(nullptr);
    138 }
    139 
    140 void Throwable::VisitRoots(RootCallback* callback, void* arg) {
    141   if (!java_lang_Throwable_.IsNull()) {
    142     java_lang_Throwable_.VisitRoot(callback, arg, 0, kRootStickyClass);
    143   }
    144 }
    145 
    146 }  // namespace mirror
    147 }  // namespace art
    148