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 "stack.h"
18
19 #include "mirror/art_method-inl.h"
20 #include "mirror/class-inl.h"
21 #include "mirror/object.h"
22 #include "mirror/object-inl.h"
23 #include "mirror/object_array-inl.h"
24 #include "object_utils.h"
25 #include "thread_list.h"
26 #include "throw_location.h"
27 #include "vmap_table.h"
28
29 namespace art {
30
GetThisObject() const31 mirror::Object* ShadowFrame::GetThisObject() const {
32 mirror::ArtMethod* m = GetMethod();
33 if (m->IsStatic()) {
34 return NULL;
35 } else if (m->IsNative()) {
36 return GetVRegReference(0);
37 } else {
38 const DexFile::CodeItem* code_item = MethodHelper(m).GetCodeItem();
39 CHECK(code_item != NULL) << PrettyMethod(m);
40 uint16_t reg = code_item->registers_size_ - code_item->ins_size_;
41 return GetVRegReference(reg);
42 }
43 }
44
GetThisObject(uint16_t num_ins) const45 mirror::Object* ShadowFrame::GetThisObject(uint16_t num_ins) const {
46 mirror::ArtMethod* m = GetMethod();
47 if (m->IsStatic()) {
48 return NULL;
49 } else {
50 return GetVRegReference(NumberOfVRegs() - num_ins);
51 }
52 }
53
GetCurrentLocationForThrow() const54 ThrowLocation ShadowFrame::GetCurrentLocationForThrow() const {
55 return ThrowLocation(GetThisObject(), GetMethod(), GetDexPC());
56 }
57
NumJniShadowFrameReferences() const58 size_t ManagedStack::NumJniShadowFrameReferences() const {
59 size_t count = 0;
60 for (const ManagedStack* current_fragment = this; current_fragment != NULL;
61 current_fragment = current_fragment->GetLink()) {
62 for (ShadowFrame* current_frame = current_fragment->top_shadow_frame_; current_frame != NULL;
63 current_frame = current_frame->GetLink()) {
64 if (current_frame->GetMethod()->IsNative()) {
65 // The JNI ShadowFrame only contains references. (For indirect reference.)
66 count += current_frame->NumberOfVRegs();
67 }
68 }
69 }
70 return count;
71 }
72
ShadowFramesContain(mirror::Object ** shadow_frame_entry) const73 bool ManagedStack::ShadowFramesContain(mirror::Object** shadow_frame_entry) const {
74 for (const ManagedStack* current_fragment = this; current_fragment != NULL;
75 current_fragment = current_fragment->GetLink()) {
76 for (ShadowFrame* current_frame = current_fragment->top_shadow_frame_; current_frame != NULL;
77 current_frame = current_frame->GetLink()) {
78 if (current_frame->Contains(shadow_frame_entry)) {
79 return true;
80 }
81 }
82 }
83 return false;
84 }
85
StackVisitor(Thread * thread,Context * context)86 StackVisitor::StackVisitor(Thread* thread, Context* context)
87 : thread_(thread), cur_shadow_frame_(NULL),
88 cur_quick_frame_(NULL), cur_quick_frame_pc_(0), num_frames_(0), cur_depth_(0),
89 context_(context) {
90 DCHECK(thread == Thread::Current() || thread->IsSuspended()) << *thread;
91 }
92
GetDexPc() const93 uint32_t StackVisitor::GetDexPc() const {
94 if (cur_shadow_frame_ != NULL) {
95 return cur_shadow_frame_->GetDexPC();
96 } else if (cur_quick_frame_ != NULL) {
97 return GetMethod()->ToDexPc(cur_quick_frame_pc_);
98 } else {
99 return 0;
100 }
101 }
102
GetThisObject() const103 mirror::Object* StackVisitor::GetThisObject() const {
104 mirror::ArtMethod* m = GetMethod();
105 if (m->IsStatic()) {
106 return NULL;
107 } else if (m->IsNative()) {
108 if (cur_quick_frame_ != NULL) {
109 StackIndirectReferenceTable* sirt =
110 reinterpret_cast<StackIndirectReferenceTable*>(
111 reinterpret_cast<char*>(cur_quick_frame_) +
112 m->GetSirtOffsetInBytes());
113 return sirt->GetReference(0);
114 } else {
115 return cur_shadow_frame_->GetVRegReference(0);
116 }
117 } else {
118 const DexFile::CodeItem* code_item = MethodHelper(m).GetCodeItem();
119 if (code_item == NULL) {
120 UNIMPLEMENTED(ERROR) << "Failed to determine this object of abstract or proxy method"
121 << PrettyMethod(m);
122 return NULL;
123 } else {
124 uint16_t reg = code_item->registers_size_ - code_item->ins_size_;
125 return reinterpret_cast<mirror::Object*>(GetVReg(m, reg, kReferenceVReg));
126 }
127 }
128 }
129
GetNativePcOffset() const130 size_t StackVisitor::GetNativePcOffset() const {
131 DCHECK(!IsShadowFrame());
132 return GetMethod()->NativePcOffset(cur_quick_frame_pc_);
133 }
134
GetVReg(mirror::ArtMethod * m,uint16_t vreg,VRegKind kind) const135 uint32_t StackVisitor::GetVReg(mirror::ArtMethod* m, uint16_t vreg, VRegKind kind) const {
136 if (cur_quick_frame_ != NULL) {
137 DCHECK(context_ != NULL); // You can't reliably read registers without a context.
138 DCHECK(m == GetMethod());
139 const VmapTable vmap_table(m->GetVmapTable());
140 uint32_t vmap_offset;
141 // TODO: IsInContext stops before spotting floating point registers.
142 if (vmap_table.IsInContext(vreg, kind, &vmap_offset)) {
143 bool is_float = (kind == kFloatVReg) || (kind == kDoubleLoVReg) || (kind == kDoubleHiVReg);
144 uint32_t spill_mask = is_float ? m->GetFpSpillMask()
145 : m->GetCoreSpillMask();
146 return GetGPR(vmap_table.ComputeRegister(spill_mask, vmap_offset, kind));
147 } else {
148 const DexFile::CodeItem* code_item = MethodHelper(m).GetCodeItem();
149 DCHECK(code_item != NULL) << PrettyMethod(m); // Can't be NULL or how would we compile its instructions?
150 size_t frame_size = m->GetFrameSizeInBytes();
151 return GetVReg(cur_quick_frame_, code_item, m->GetCoreSpillMask(), m->GetFpSpillMask(),
152 frame_size, vreg);
153 }
154 } else {
155 return cur_shadow_frame_->GetVReg(vreg);
156 }
157 }
158
SetVReg(mirror::ArtMethod * m,uint16_t vreg,uint32_t new_value,VRegKind kind)159 void StackVisitor::SetVReg(mirror::ArtMethod* m, uint16_t vreg, uint32_t new_value,
160 VRegKind kind) {
161 if (cur_quick_frame_ != NULL) {
162 DCHECK(context_ != NULL); // You can't reliably write registers without a context.
163 DCHECK(m == GetMethod());
164 const VmapTable vmap_table(m->GetVmapTable());
165 uint32_t vmap_offset;
166 // TODO: IsInContext stops before spotting floating point registers.
167 if (vmap_table.IsInContext(vreg, kind, &vmap_offset)) {
168 bool is_float = (kind == kFloatVReg) || (kind == kDoubleLoVReg) || (kind == kDoubleHiVReg);
169 uint32_t spill_mask = is_float ? m->GetFpSpillMask() : m->GetCoreSpillMask();
170 const uint32_t reg = vmap_table.ComputeRegister(spill_mask, vmap_offset, kReferenceVReg);
171 SetGPR(reg, new_value);
172 } else {
173 const DexFile::CodeItem* code_item = MethodHelper(m).GetCodeItem();
174 DCHECK(code_item != NULL) << PrettyMethod(m); // Can't be NULL or how would we compile its instructions?
175 uint32_t core_spills = m->GetCoreSpillMask();
176 uint32_t fp_spills = m->GetFpSpillMask();
177 size_t frame_size = m->GetFrameSizeInBytes();
178 int offset = GetVRegOffset(code_item, core_spills, fp_spills, frame_size, vreg);
179 byte* vreg_addr = reinterpret_cast<byte*>(GetCurrentQuickFrame()) + offset;
180 *reinterpret_cast<uint32_t*>(vreg_addr) = new_value;
181 }
182 } else {
183 return cur_shadow_frame_->SetVReg(vreg, new_value);
184 }
185 }
186
GetGPR(uint32_t reg) const187 uintptr_t StackVisitor::GetGPR(uint32_t reg) const {
188 DCHECK(cur_quick_frame_ != NULL) << "This is a quick frame routine";
189 return context_->GetGPR(reg);
190 }
191
SetGPR(uint32_t reg,uintptr_t value)192 void StackVisitor::SetGPR(uint32_t reg, uintptr_t value) {
193 DCHECK(cur_quick_frame_ != NULL) << "This is a quick frame routine";
194 context_->SetGPR(reg, value);
195 }
196
GetReturnPc() const197 uintptr_t StackVisitor::GetReturnPc() const {
198 mirror::ArtMethod** sp = GetCurrentQuickFrame();
199 DCHECK(sp != NULL);
200 byte* pc_addr = reinterpret_cast<byte*>(sp) + GetMethod()->GetReturnPcOffsetInBytes();
201 return *reinterpret_cast<uintptr_t*>(pc_addr);
202 }
203
SetReturnPc(uintptr_t new_ret_pc)204 void StackVisitor::SetReturnPc(uintptr_t new_ret_pc) {
205 mirror::ArtMethod** sp = GetCurrentQuickFrame();
206 CHECK(sp != NULL);
207 byte* pc_addr = reinterpret_cast<byte*>(sp) + GetMethod()->GetReturnPcOffsetInBytes();
208 *reinterpret_cast<uintptr_t*>(pc_addr) = new_ret_pc;
209 }
210
ComputeNumFrames(Thread * thread)211 size_t StackVisitor::ComputeNumFrames(Thread* thread) {
212 struct NumFramesVisitor : public StackVisitor {
213 explicit NumFramesVisitor(Thread* thread)
214 : StackVisitor(thread, NULL), frames(0) {}
215
216 virtual bool VisitFrame() {
217 frames++;
218 return true;
219 }
220
221 size_t frames;
222 };
223 NumFramesVisitor visitor(thread);
224 visitor.WalkStack(true);
225 return visitor.frames;
226 }
227
DescribeStack(Thread * thread)228 void StackVisitor::DescribeStack(Thread* thread) {
229 struct DescribeStackVisitor : public StackVisitor {
230 explicit DescribeStackVisitor(Thread* thread)
231 : StackVisitor(thread, NULL) {}
232
233 virtual bool VisitFrame() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
234 LOG(INFO) << "Frame Id=" << GetFrameId() << " " << DescribeLocation();
235 return true;
236 }
237 };
238 DescribeStackVisitor visitor(thread);
239 visitor.WalkStack(true);
240 }
241
DescribeLocation() const242 std::string StackVisitor::DescribeLocation() const {
243 std::string result("Visiting method '");
244 mirror::ArtMethod* m = GetMethod();
245 if (m == NULL) {
246 return "upcall";
247 }
248 result += PrettyMethod(m);
249 result += StringPrintf("' at dex PC 0x%04zx", GetDexPc());
250 if (!IsShadowFrame()) {
251 result += StringPrintf(" (native PC %p)", reinterpret_cast<void*>(GetCurrentQuickFramePc()));
252 }
253 return result;
254 }
255
GetInstrumentationStackFrame(uint32_t depth) const256 instrumentation::InstrumentationStackFrame StackVisitor::GetInstrumentationStackFrame(uint32_t depth) const {
257 return thread_->GetInstrumentationStack()->at(depth);
258 }
259
SanityCheckFrame() const260 void StackVisitor::SanityCheckFrame() const {
261 #ifndef NDEBUG
262 mirror::ArtMethod* method = GetMethod();
263 CHECK(method->GetClass() == mirror::ArtMethod::GetJavaLangReflectArtMethod());
264 if (cur_quick_frame_ != NULL) {
265 method->AssertPcIsWithinCode(cur_quick_frame_pc_);
266 // Frame sanity.
267 size_t frame_size = method->GetFrameSizeInBytes();
268 CHECK_NE(frame_size, 0u);
269 // A rough guess at an upper size we expect to see for a frame. The 256 is
270 // a dex register limit. The 16 incorporates callee save spills and
271 // outgoing argument set up.
272 const size_t kMaxExpectedFrameSize = 256 * sizeof(word) + 16;
273 CHECK_LE(frame_size, kMaxExpectedFrameSize);
274 size_t return_pc_offset = method->GetReturnPcOffsetInBytes();
275 CHECK_LT(return_pc_offset, frame_size);
276 }
277 #endif
278 }
279
WalkStack(bool include_transitions)280 void StackVisitor::WalkStack(bool include_transitions) {
281 DCHECK(thread_ == Thread::Current() || thread_->IsSuspended());
282 CHECK_EQ(cur_depth_, 0U);
283 bool exit_stubs_installed = Runtime::Current()->GetInstrumentation()->AreExitStubsInstalled();
284 uint32_t instrumentation_stack_depth = 0;
285 for (const ManagedStack* current_fragment = thread_->GetManagedStack(); current_fragment != NULL;
286 current_fragment = current_fragment->GetLink()) {
287 cur_shadow_frame_ = current_fragment->GetTopShadowFrame();
288 cur_quick_frame_ = current_fragment->GetTopQuickFrame();
289 cur_quick_frame_pc_ = current_fragment->GetTopQuickFramePc();
290 if (cur_quick_frame_ != NULL) { // Handle quick stack frames.
291 // Can't be both a shadow and a quick fragment.
292 DCHECK(current_fragment->GetTopShadowFrame() == NULL);
293 mirror::ArtMethod* method = *cur_quick_frame_;
294 while (method != NULL) {
295 SanityCheckFrame();
296 bool should_continue = VisitFrame();
297 if (UNLIKELY(!should_continue)) {
298 return;
299 }
300 if (context_ != NULL) {
301 context_->FillCalleeSaves(*this);
302 }
303 size_t frame_size = method->GetFrameSizeInBytes();
304 // Compute PC for next stack frame from return PC.
305 size_t return_pc_offset = method->GetReturnPcOffsetInBytes();
306 byte* return_pc_addr = reinterpret_cast<byte*>(cur_quick_frame_) + return_pc_offset;
307 uintptr_t return_pc = *reinterpret_cast<uintptr_t*>(return_pc_addr);
308 if (UNLIKELY(exit_stubs_installed)) {
309 // While profiling, the return pc is restored from the side stack, except when walking
310 // the stack for an exception where the side stack will be unwound in VisitFrame.
311 if (GetQuickInstrumentationExitPc() == return_pc) {
312 instrumentation::InstrumentationStackFrame instrumentation_frame =
313 GetInstrumentationStackFrame(instrumentation_stack_depth);
314 instrumentation_stack_depth++;
315 if (GetMethod() == Runtime::Current()->GetCalleeSaveMethod(Runtime::kSaveAll)) {
316 // Skip runtime save all callee frames which are used to deliver exceptions.
317 } else if (instrumentation_frame.interpreter_entry_) {
318 mirror::ArtMethod* callee = Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsAndArgs);
319 CHECK_EQ(GetMethod(), callee) << "Expected: " << PrettyMethod(callee) << " Found: "
320 << PrettyMethod(GetMethod());
321 } else if (instrumentation_frame.method_ != GetMethod()) {
322 LOG(FATAL) << "Expected: " << PrettyMethod(instrumentation_frame.method_)
323 << " Found: " << PrettyMethod(GetMethod());
324 }
325 if (num_frames_ != 0) {
326 // Check agreement of frame Ids only if num_frames_ is computed to avoid infinite
327 // recursion.
328 CHECK(instrumentation_frame.frame_id_ == GetFrameId())
329 << "Expected: " << instrumentation_frame.frame_id_
330 << " Found: " << GetFrameId();
331 }
332 return_pc = instrumentation_frame.return_pc_;
333 }
334 }
335 cur_quick_frame_pc_ = return_pc;
336 byte* next_frame = reinterpret_cast<byte*>(cur_quick_frame_) + frame_size;
337 cur_quick_frame_ = reinterpret_cast<mirror::ArtMethod**>(next_frame);
338 cur_depth_++;
339 method = *cur_quick_frame_;
340 }
341 } else if (cur_shadow_frame_ != NULL) {
342 do {
343 SanityCheckFrame();
344 bool should_continue = VisitFrame();
345 if (UNLIKELY(!should_continue)) {
346 return;
347 }
348 cur_depth_++;
349 cur_shadow_frame_ = cur_shadow_frame_->GetLink();
350 } while (cur_shadow_frame_ != NULL);
351 }
352 if (include_transitions) {
353 bool should_continue = VisitFrame();
354 if (!should_continue) {
355 return;
356 }
357 }
358 cur_depth_++;
359 }
360 if (num_frames_ != 0) {
361 CHECK_EQ(cur_depth_, num_frames_);
362 }
363 }
364
365 } // namespace art
366