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 "android-base/stringprintf.h"
20
21 #include "art_method-inl.h"
22 #include "base/enums.h"
23 #include "class-inl.h"
24 #include "dex_file-inl.h"
25 #include "gc/accounting/card_table-inl.h"
26 #include "object-inl.h"
27 #include "object_array.h"
28 #include "object_array-inl.h"
29 #include "stack_trace_element.h"
30 #include "string.h"
31 #include "utils.h"
32 #include "well_known_classes.h"
33
34 namespace art {
35 namespace mirror {
36
37 using android::base::StringPrintf;
38
39 GcRoot<Class> Throwable::java_lang_Throwable_;
40
SetDetailMessage(ObjPtr<String> new_detail_message)41 void Throwable::SetDetailMessage(ObjPtr<String> new_detail_message) {
42 if (Runtime::Current()->IsActiveTransaction()) {
43 SetFieldObject<true>(OFFSET_OF_OBJECT_MEMBER(Throwable, detail_message_), new_detail_message);
44 } else {
45 SetFieldObject<false>(OFFSET_OF_OBJECT_MEMBER(Throwable, detail_message_),
46 new_detail_message);
47 }
48 }
49
SetCause(ObjPtr<Throwable> cause)50 void Throwable::SetCause(ObjPtr<Throwable> cause) {
51 CHECK(cause != nullptr);
52 CHECK(cause != this);
53 Throwable* current_cause = GetFieldObject<Throwable>(OFFSET_OF_OBJECT_MEMBER(Throwable, cause_));
54 CHECK(current_cause == nullptr || current_cause == this);
55 if (Runtime::Current()->IsActiveTransaction()) {
56 SetFieldObject<true>(OFFSET_OF_OBJECT_MEMBER(Throwable, cause_), cause);
57 } else {
58 SetFieldObject<false>(OFFSET_OF_OBJECT_MEMBER(Throwable, cause_), cause);
59 }
60 }
61
SetStackState(ObjPtr<Object> state)62 void Throwable::SetStackState(ObjPtr<Object> state) REQUIRES_SHARED(Locks::mutator_lock_) {
63 CHECK(state != nullptr);
64 if (Runtime::Current()->IsActiveTransaction()) {
65 SetFieldObjectVolatile<true>(OFFSET_OF_OBJECT_MEMBER(Throwable, backtrace_), state);
66 } else {
67 SetFieldObjectVolatile<false>(OFFSET_OF_OBJECT_MEMBER(Throwable, backtrace_), state);
68 }
69 }
70
IsCheckedException()71 bool Throwable::IsCheckedException() {
72 if (InstanceOf(WellKnownClasses::ToClass(WellKnownClasses::java_lang_Error))) {
73 return false;
74 }
75 return !InstanceOf(WellKnownClasses::ToClass(WellKnownClasses::java_lang_RuntimeException));
76 }
77
GetStackDepth()78 int32_t Throwable::GetStackDepth() {
79 ObjPtr<Object> stack_state = GetStackState();
80 if (stack_state == nullptr || !stack_state->IsObjectArray()) {
81 return -1;
82 }
83 ObjPtr<mirror::ObjectArray<Object>> const trace = stack_state->AsObjectArray<Object>();
84 const int32_t array_len = trace->GetLength();
85 DCHECK_GT(array_len, 0);
86 // See method BuildInternalStackTraceVisitor::Init for the format.
87 return array_len - 1;
88 }
89
Dump()90 std::string Throwable::Dump() {
91 std::string result(PrettyTypeOf());
92 result += ": ";
93 ObjPtr<String> msg = GetDetailMessage();
94 if (msg != nullptr) {
95 result += msg->ToModifiedUtf8();
96 }
97 result += "\n";
98 ObjPtr<Object> stack_state = GetStackState();
99 // check stack state isn't missing or corrupt
100 if (stack_state != nullptr && stack_state->IsObjectArray()) {
101 ObjPtr<ObjectArray<Object>> object_array = stack_state->AsObjectArray<Object>();
102 // Decode the internal stack trace into the depth and method trace
103 // See method BuildInternalStackTraceVisitor::Init for the format.
104 DCHECK_GT(object_array->GetLength(), 0);
105 ObjPtr<Object> methods_and_dex_pcs = object_array->Get(0);
106 DCHECK(methods_and_dex_pcs->IsIntArray() || methods_and_dex_pcs->IsLongArray());
107 ObjPtr<PointerArray> method_trace = ObjPtr<PointerArray>::DownCast(methods_and_dex_pcs);
108 const int32_t array_len = method_trace->GetLength();
109 CHECK_EQ(array_len % 2, 0);
110 const auto depth = array_len / 2;
111 if (depth == 0) {
112 result += "(Throwable with empty stack trace)\n";
113 } else {
114 const PointerSize ptr_size = Runtime::Current()->GetClassLinker()->GetImagePointerSize();
115 for (int32_t i = 0; i < depth; ++i) {
116 ArtMethod* method = method_trace->GetElementPtrSize<ArtMethod*>(i, ptr_size);
117 uintptr_t dex_pc = method_trace->GetElementPtrSize<uintptr_t>(i + depth, ptr_size);
118 int32_t line_number = method->GetLineNumFromDexPC(dex_pc);
119 const char* source_file = method->GetDeclaringClassSourceFile();
120 result += StringPrintf(" at %s (%s:%d)\n", method->PrettyMethod(true).c_str(),
121 source_file, line_number);
122 }
123 }
124 } else {
125 ObjPtr<Object> stack_trace = GetStackTrace();
126 if (stack_trace != nullptr && stack_trace->IsObjectArray()) {
127 CHECK_EQ(stack_trace->GetClass()->GetComponentType(),
128 StackTraceElement::GetStackTraceElement());
129 ObjPtr<ObjectArray<StackTraceElement>> ste_array =
130 ObjPtr<ObjectArray<StackTraceElement>>::DownCast(stack_trace);
131 if (ste_array->GetLength() == 0) {
132 result += "(Throwable with empty stack trace)\n";
133 } else {
134 for (int32_t i = 0; i < ste_array->GetLength(); ++i) {
135 StackTraceElement* ste = ste_array->Get(i);
136 DCHECK(ste != nullptr);
137 auto* method_name = ste->GetMethodName();
138 auto* file_name = ste->GetFileName();
139 result += StringPrintf(
140 " at %s (%s:%d)\n",
141 method_name != nullptr ? method_name->ToModifiedUtf8().c_str() : "<unknown method>",
142 file_name != nullptr ? file_name->ToModifiedUtf8().c_str() : "(Unknown Source)",
143 ste->GetLineNumber());
144 }
145 }
146 } else {
147 result += "(Throwable with no stack trace)\n";
148 }
149 }
150 ObjPtr<Throwable> cause = GetFieldObject<Throwable>(OFFSET_OF_OBJECT_MEMBER(Throwable, cause_));
151 if (cause != nullptr && cause != this) { // Constructor makes cause == this by default.
152 result += "Caused by: ";
153 result += cause->Dump();
154 }
155 return result;
156 }
157
SetClass(ObjPtr<Class> java_lang_Throwable)158 void Throwable::SetClass(ObjPtr<Class> java_lang_Throwable) {
159 CHECK(java_lang_Throwable_.IsNull());
160 CHECK(java_lang_Throwable != nullptr);
161 java_lang_Throwable_ = GcRoot<Class>(java_lang_Throwable);
162 }
163
ResetClass()164 void Throwable::ResetClass() {
165 CHECK(!java_lang_Throwable_.IsNull());
166 java_lang_Throwable_ = GcRoot<Class>(nullptr);
167 }
168
VisitRoots(RootVisitor * visitor)169 void Throwable::VisitRoots(RootVisitor* visitor) {
170 java_lang_Throwable_.VisitRootIfNonNull(visitor, RootInfo(kRootStickyClass));
171 }
172
GetStackState()173 Object* Throwable::GetStackState() {
174 return GetFieldObjectVolatile<Object>(OFFSET_OF_OBJECT_MEMBER(Throwable, backtrace_));
175 }
176
GetStackTrace()177 Object* Throwable::GetStackTrace() {
178 return GetFieldObjectVolatile<Object>(OFFSET_OF_OBJECT_MEMBER(Throwable, backtrace_));
179 }
180
GetDetailMessage()181 String* Throwable::GetDetailMessage() {
182 return GetFieldObject<String>(OFFSET_OF_OBJECT_MEMBER(Throwable, detail_message_));
183 }
184
185 } // namespace mirror
186 } // namespace art
187