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
SetDetailMessage(String * new_detail_message)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
SetCause(Throwable * cause)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
SetStackState(Object * state)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
IsCheckedException()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
Dump()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
SetClass(Class * java_lang_Throwable)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
ResetClass()135 void Throwable::ResetClass() {
136 CHECK(!java_lang_Throwable_.IsNull());
137 java_lang_Throwable_ = GcRoot<Class>(nullptr);
138 }
139
VisitRoots(RootCallback * callback,void * arg)140 void Throwable::VisitRoots(RootCallback* callback, void* arg) {
141 java_lang_Throwable_.VisitRootIfNonNull(callback, arg, RootInfo(kRootStickyClass));
142 }
143
144 } // namespace mirror
145 } // namespace art
146