blob: d5405fbdf0cd42c5516e33c8b1d6ff9ff00fc41b [file] [log] [blame]
Elliott Hughes68e76522011-10-05 13:22:16 -07001/*
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
Dave Allisonf9439142014-03-27 15:10:22 -070019#include "base/hex_dump.h"
Brian Carlstromea46f952013-07-30 01:26:50 -070020#include "mirror/art_method-inl.h"
Ian Rogers4f6ad8a2013-03-18 15:27:28 -070021#include "mirror/class-inl.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080022#include "mirror/object.h"
23#include "mirror/object-inl.h"
24#include "mirror/object_array-inl.h"
Ian Rogers6d4d9fc2011-11-30 16:24:48 -080025#include "object_utils.h"
Vladimir Marko7624d252014-05-02 14:40:15 +010026#include "quick/quick_method_frame_info.h"
Mathieu Chartier590fee92013-09-13 13:46:47 -070027#include "runtime.h"
Dave Allisonf9439142014-03-27 15:10:22 -070028#include "thread.h"
Elliott Hughesbfe487b2011-10-26 15:48:55 -070029#include "thread_list.h"
Ian Rogers62d6c772013-02-27 08:32:07 -080030#include "throw_location.h"
Mathieu Chartier4e305412014-02-19 10:54:44 -080031#include "verify_object-inl.h"
Ian Rogers1809a722013-08-09 22:05:32 -070032#include "vmap_table.h"
Elliott Hughes68e76522011-10-05 13:22:16 -070033
Elliott Hughes11d1b0c2012-01-23 16:57:47 -080034namespace art {
35
Ian Rogers62d6c772013-02-27 08:32:07 -080036mirror::Object* ShadowFrame::GetThisObject() const {
Brian Carlstromea46f952013-07-30 01:26:50 -070037 mirror::ArtMethod* m = GetMethod();
Ian Rogers62d6c772013-02-27 08:32:07 -080038 if (m->IsStatic()) {
39 return NULL;
40 } else if (m->IsNative()) {
41 return GetVRegReference(0);
42 } else {
Mathieu Chartierbfd9a432014-05-21 17:43:44 -070043 const DexFile::CodeItem* code_item = m->GetCodeItem();
Ian Rogers62d6c772013-02-27 08:32:07 -080044 CHECK(code_item != NULL) << PrettyMethod(m);
45 uint16_t reg = code_item->registers_size_ - code_item->ins_size_;
46 return GetVRegReference(reg);
47 }
48}
49
Jeff Haoe701f482013-05-24 11:50:49 -070050mirror::Object* ShadowFrame::GetThisObject(uint16_t num_ins) const {
Brian Carlstromea46f952013-07-30 01:26:50 -070051 mirror::ArtMethod* m = GetMethod();
Jeff Haoe701f482013-05-24 11:50:49 -070052 if (m->IsStatic()) {
53 return NULL;
54 } else {
Jeff Hao8d448852013-06-03 17:26:19 -070055 return GetVRegReference(NumberOfVRegs() - num_ins);
Jeff Haoe701f482013-05-24 11:50:49 -070056 }
57}
58
Ian Rogers62d6c772013-02-27 08:32:07 -080059ThrowLocation ShadowFrame::GetCurrentLocationForThrow() const {
60 return ThrowLocation(GetThisObject(), GetMethod(), GetDexPC());
61}
62
TDYa127ce4cc0d2012-11-18 16:59:53 -080063size_t ManagedStack::NumJniShadowFrameReferences() const {
Ian Rogers0399dde2012-06-06 17:09:28 -070064 size_t count = 0;
65 for (const ManagedStack* current_fragment = this; current_fragment != NULL;
66 current_fragment = current_fragment->GetLink()) {
67 for (ShadowFrame* current_frame = current_fragment->top_shadow_frame_; current_frame != NULL;
68 current_frame = current_frame->GetLink()) {
TDYa127ce4cc0d2012-11-18 16:59:53 -080069 if (current_frame->GetMethod()->IsNative()) {
70 // The JNI ShadowFrame only contains references. (For indirect reference.)
71 count += current_frame->NumberOfVRegs();
72 }
Ian Rogers0399dde2012-06-06 17:09:28 -070073 }
74 }
75 return count;
76}
77
Ian Rogersef7d42f2014-01-06 12:55:46 -080078bool ManagedStack::ShadowFramesContain(StackReference<mirror::Object>* shadow_frame_entry) const {
Ian Rogers0399dde2012-06-06 17:09:28 -070079 for (const ManagedStack* current_fragment = this; current_fragment != NULL;
80 current_fragment = current_fragment->GetLink()) {
81 for (ShadowFrame* current_frame = current_fragment->top_shadow_frame_; current_frame != NULL;
82 current_frame = current_frame->GetLink()) {
83 if (current_frame->Contains(shadow_frame_entry)) {
84 return true;
85 }
86 }
87 }
88 return false;
89}
90
Ian Rogers7a22fa62013-01-23 12:16:16 -080091StackVisitor::StackVisitor(Thread* thread, Context* context)
92 : thread_(thread), cur_shadow_frame_(NULL),
93 cur_quick_frame_(NULL), cur_quick_frame_pc_(0), num_frames_(0), cur_depth_(0),
94 context_(context) {
Ian Rogers62d6c772013-02-27 08:32:07 -080095 DCHECK(thread == Thread::Current() || thread->IsSuspended()) << *thread;
Ian Rogers7a22fa62013-01-23 12:16:16 -080096}
97
Ian Rogers5cf98192014-05-29 21:31:50 -070098StackVisitor::StackVisitor(Thread* thread, Context* context, size_t num_frames)
99 : thread_(thread), cur_shadow_frame_(NULL),
100 cur_quick_frame_(NULL), cur_quick_frame_pc_(0), num_frames_(num_frames), cur_depth_(0),
101 context_(context) {
102 DCHECK(thread == Thread::Current() || thread->IsSuspended()) << *thread;
103}
104
Dave Allisonb373e092014-02-20 16:06:36 -0800105uint32_t StackVisitor::GetDexPc(bool abort_on_failure) const {
Ian Rogers0399dde2012-06-06 17:09:28 -0700106 if (cur_shadow_frame_ != NULL) {
107 return cur_shadow_frame_->GetDexPC();
108 } else if (cur_quick_frame_ != NULL) {
Dave Allisonb373e092014-02-20 16:06:36 -0800109 return GetMethod()->ToDexPc(cur_quick_frame_pc_, abort_on_failure);
Ian Rogers0399dde2012-06-06 17:09:28 -0700110 } else {
111 return 0;
112 }
113}
114
Ian Rogers62d6c772013-02-27 08:32:07 -0800115mirror::Object* StackVisitor::GetThisObject() const {
Brian Carlstromea46f952013-07-30 01:26:50 -0700116 mirror::ArtMethod* m = GetMethod();
Ian Rogers62d6c772013-02-27 08:32:07 -0800117 if (m->IsStatic()) {
118 return NULL;
119 } else if (m->IsNative()) {
120 if (cur_quick_frame_ != NULL) {
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700121 HandleScope* hs = reinterpret_cast<HandleScope*>(
122 reinterpret_cast<char*>(cur_quick_frame_) + m->GetHandleScopeOffsetInBytes());
123 return hs->GetReference(0);
Ian Rogers62d6c772013-02-27 08:32:07 -0800124 } else {
125 return cur_shadow_frame_->GetVRegReference(0);
126 }
127 } else {
Mathieu Chartierbfd9a432014-05-21 17:43:44 -0700128 const DexFile::CodeItem* code_item = m->GetCodeItem();
Ian Rogers62d6c772013-02-27 08:32:07 -0800129 if (code_item == NULL) {
Ian Rogerse0dcd462014-03-08 15:21:04 -0800130 UNIMPLEMENTED(ERROR) << "Failed to determine this object of abstract or proxy method: "
Ian Rogers62d6c772013-02-27 08:32:07 -0800131 << PrettyMethod(m);
Ian Rogerse0dcd462014-03-08 15:21:04 -0800132 return nullptr;
Ian Rogers62d6c772013-02-27 08:32:07 -0800133 } else {
134 uint16_t reg = code_item->registers_size_ - code_item->ins_size_;
135 return reinterpret_cast<mirror::Object*>(GetVReg(m, reg, kReferenceVReg));
136 }
137 }
138}
139
Ian Rogers0c7abda2012-09-19 13:33:42 -0700140size_t StackVisitor::GetNativePcOffset() const {
141 DCHECK(!IsShadowFrame());
142 return GetMethod()->NativePcOffset(cur_quick_frame_pc_);
143}
144
Sebastien Hertz0bcb2902014-06-17 15:52:45 +0200145bool StackVisitor::GetVReg(mirror::ArtMethod* m, uint16_t vreg, VRegKind kind,
146 uint32_t* val) const {
Ian Rogers0ec569a2012-07-01 16:43:46 -0700147 if (cur_quick_frame_ != NULL) {
Brian Carlstrom7934ac22013-07-26 10:54:15 -0700148 DCHECK(context_ != NULL); // You can't reliably read registers without a context.
Ian Rogers2bcb4a42012-11-08 10:39:18 -0800149 DCHECK(m == GetMethod());
Vladimir Marko4c1c5102014-05-14 16:51:16 +0100150 const void* code_pointer = m->GetQuickOatCodePointer();
151 DCHECK(code_pointer != nullptr);
152 const VmapTable vmap_table(m->GetVmapTable(code_pointer));
153 QuickMethodFrameInfo frame_info = m->GetQuickFrameInfo(code_pointer);
Ian Rogers0ec569a2012-07-01 16:43:46 -0700154 uint32_t vmap_offset;
155 // TODO: IsInContext stops before spotting floating point registers.
Ian Rogers1809a722013-08-09 22:05:32 -0700156 if (vmap_table.IsInContext(vreg, kind, &vmap_offset)) {
Ian Rogers2bcb4a42012-11-08 10:39:18 -0800157 bool is_float = (kind == kFloatVReg) || (kind == kDoubleLoVReg) || (kind == kDoubleHiVReg);
Vladimir Marko7624d252014-05-02 14:40:15 +0100158 uint32_t spill_mask = is_float ? frame_info.FpSpillMask() : frame_info.CoreSpillMask();
Sebastien Hertz0bcb2902014-06-17 15:52:45 +0200159 uint32_t reg = vmap_table.ComputeRegister(spill_mask, vmap_offset, kind);
160 uintptr_t ptr_val;
161 bool success = false;
buzbeeb5860fb2014-06-21 15:31:01 -0700162 bool target64 = (kRuntimeISA == kArm64) || (kRuntimeISA == kX86_64);
Sebastien Hertz0bcb2902014-06-17 15:52:45 +0200163 if (is_float) {
164 success = GetFPR(reg, &ptr_val);
165 } else {
166 success = GetGPR(reg, &ptr_val);
167 }
buzbeeb5860fb2014-06-21 15:31:01 -0700168 if (success && target64) {
169 bool wide_lo = (kind == kLongLoVReg) || (kind == kDoubleLoVReg);
170 bool wide_hi = (kind == kLongHiVReg) || (kind == kDoubleHiVReg);
171 int64_t value_long = static_cast<int64_t>(ptr_val);
172 if (wide_lo) {
173 ptr_val = static_cast<uintptr_t>(value_long & 0xFFFFFFFF);
174 } else if (wide_hi) {
175 ptr_val = static_cast<uintptr_t>(value_long >> 32);
176 }
177 }
Sebastien Hertz0bcb2902014-06-17 15:52:45 +0200178 *val = ptr_val;
179 return success;
Ian Rogers0ec569a2012-07-01 16:43:46 -0700180 } else {
Mathieu Chartierbfd9a432014-05-21 17:43:44 -0700181 const DexFile::CodeItem* code_item = m->GetCodeItem();
Brian Carlstrom7934ac22013-07-26 10:54:15 -0700182 DCHECK(code_item != NULL) << PrettyMethod(m); // Can't be NULL or how would we compile its instructions?
Sebastien Hertz0bcb2902014-06-17 15:52:45 +0200183 *val = *GetVRegAddr(cur_quick_frame_, code_item, frame_info.CoreSpillMask(),
Vladimir Marko7624d252014-05-02 14:40:15 +0100184 frame_info.FpSpillMask(), frame_info.FrameSizeInBytes(), vreg);
Sebastien Hertz0bcb2902014-06-17 15:52:45 +0200185 return true;
Ian Rogers0399dde2012-06-06 17:09:28 -0700186 }
Ian Rogers0399dde2012-06-06 17:09:28 -0700187 } else {
Sebastien Hertz0bcb2902014-06-17 15:52:45 +0200188 *val = cur_shadow_frame_->GetVReg(vreg);
189 return true;
Ian Rogers0399dde2012-06-06 17:09:28 -0700190 }
191}
192
Sebastien Hertz0bcb2902014-06-17 15:52:45 +0200193bool StackVisitor::SetVReg(mirror::ArtMethod* m, uint16_t vreg, uint32_t new_value,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800194 VRegKind kind) {
Ian Rogers0ec569a2012-07-01 16:43:46 -0700195 if (cur_quick_frame_ != NULL) {
Brian Carlstrom7934ac22013-07-26 10:54:15 -0700196 DCHECK(context_ != NULL); // You can't reliably write registers without a context.
Ian Rogers0ec569a2012-07-01 16:43:46 -0700197 DCHECK(m == GetMethod());
Vladimir Marko4c1c5102014-05-14 16:51:16 +0100198 const void* code_pointer = m->GetQuickOatCodePointer();
199 DCHECK(code_pointer != nullptr);
200 const VmapTable vmap_table(m->GetVmapTable(code_pointer));
201 QuickMethodFrameInfo frame_info = m->GetQuickFrameInfo(code_pointer);
Ian Rogers0ec569a2012-07-01 16:43:46 -0700202 uint32_t vmap_offset;
203 // TODO: IsInContext stops before spotting floating point registers.
Ian Rogers1809a722013-08-09 22:05:32 -0700204 if (vmap_table.IsInContext(vreg, kind, &vmap_offset)) {
Mathieu Chartier67022432012-11-29 18:04:50 -0800205 bool is_float = (kind == kFloatVReg) || (kind == kDoubleLoVReg) || (kind == kDoubleHiVReg);
Vladimir Marko7624d252014-05-02 14:40:15 +0100206 uint32_t spill_mask = is_float ? frame_info.FpSpillMask() : frame_info.CoreSpillMask();
Sebastien Hertz0bcb2902014-06-17 15:52:45 +0200207 const uint32_t reg = vmap_table.ComputeRegister(spill_mask, vmap_offset, kind);
buzbeeb5860fb2014-06-21 15:31:01 -0700208 bool target64 = (kRuntimeISA == kArm64) || (kRuntimeISA == kX86_64);
209 // Deal with 32 or 64-bit wide registers in a way that builds on all targets.
210 if (target64) {
211 bool wide_lo = (kind == kLongLoVReg) || (kind == kDoubleLoVReg);
212 bool wide_hi = (kind == kLongHiVReg) || (kind == kDoubleHiVReg);
213 if (wide_lo || wide_hi) {
214 uintptr_t old_reg_val;
215 bool success = is_float ? GetFPR(reg, &old_reg_val) : GetGPR(reg, &old_reg_val);
216 if (!success) {
217 return false;
218 }
219 uint64_t new_vreg_portion = static_cast<uint64_t>(new_value);
220 uint64_t old_reg_val_as_wide = static_cast<uint64_t>(old_reg_val);
221 uint64_t mask = 0xffffffff;
222 if (wide_lo) {
223 mask = mask << 32;
224 } else {
225 new_vreg_portion = new_vreg_portion << 32;
226 }
227 new_value = static_cast<uintptr_t>((old_reg_val_as_wide & mask) | new_vreg_portion);
228 }
229 }
Sebastien Hertz0bcb2902014-06-17 15:52:45 +0200230 if (is_float) {
231 return SetFPR(reg, new_value);
232 } else {
233 return SetGPR(reg, new_value);
234 }
Mathieu Chartier67022432012-11-29 18:04:50 -0800235 } else {
Mathieu Chartierbfd9a432014-05-21 17:43:44 -0700236 const DexFile::CodeItem* code_item = m->GetCodeItem();
Brian Carlstrom7934ac22013-07-26 10:54:15 -0700237 DCHECK(code_item != NULL) << PrettyMethod(m); // Can't be NULL or how would we compile its instructions?
Vladimir Marko7624d252014-05-02 14:40:15 +0100238 int offset = GetVRegOffset(code_item, frame_info.CoreSpillMask(), frame_info.FpSpillMask(),
239 frame_info.FrameSizeInBytes(), vreg, kRuntimeISA);
Mathieu Chartier67022432012-11-29 18:04:50 -0800240 byte* vreg_addr = reinterpret_cast<byte*>(GetCurrentQuickFrame()) + offset;
241 *reinterpret_cast<uint32_t*>(vreg_addr) = new_value;
Sebastien Hertz0bcb2902014-06-17 15:52:45 +0200242 return true;
Ian Rogers0ec569a2012-07-01 16:43:46 -0700243 }
Ian Rogers0ec569a2012-07-01 16:43:46 -0700244 } else {
Sebastien Hertz0bcb2902014-06-17 15:52:45 +0200245 cur_shadow_frame_->SetVReg(vreg, new_value);
246 return true;
Ian Rogers0399dde2012-06-06 17:09:28 -0700247 }
Ian Rogers0399dde2012-06-06 17:09:28 -0700248}
249
Mathieu Chartier815873e2014-02-13 18:02:13 -0800250uintptr_t* StackVisitor::GetGPRAddress(uint32_t reg) const {
251 DCHECK(cur_quick_frame_ != NULL) << "This is a quick frame routine";
252 return context_->GetGPRAddress(reg);
253}
254
Sebastien Hertz0bcb2902014-06-17 15:52:45 +0200255bool StackVisitor::GetGPR(uint32_t reg, uintptr_t* val) const {
Brian Carlstromdf629502013-07-17 22:39:56 -0700256 DCHECK(cur_quick_frame_ != NULL) << "This is a quick frame routine";
Sebastien Hertz0bcb2902014-06-17 15:52:45 +0200257 return context_->GetGPR(reg, val);
Ian Rogers0399dde2012-06-06 17:09:28 -0700258}
259
Sebastien Hertz0bcb2902014-06-17 15:52:45 +0200260bool StackVisitor::SetGPR(uint32_t reg, uintptr_t value) {
Brian Carlstromdf629502013-07-17 22:39:56 -0700261 DCHECK(cur_quick_frame_ != NULL) << "This is a quick frame routine";
Sebastien Hertz0bcb2902014-06-17 15:52:45 +0200262 return context_->SetGPR(reg, value);
263}
264
265bool StackVisitor::GetFPR(uint32_t reg, uintptr_t* val) const {
266 DCHECK(cur_quick_frame_ != NULL) << "This is a quick frame routine";
267 return context_->GetFPR(reg, val);
268}
269
270bool StackVisitor::SetFPR(uint32_t reg, uintptr_t value) {
271 DCHECK(cur_quick_frame_ != NULL) << "This is a quick frame routine";
272 return context_->SetFPR(reg, value);
Mathieu Chartier67022432012-11-29 18:04:50 -0800273}
274
Ian Rogers0399dde2012-06-06 17:09:28 -0700275uintptr_t StackVisitor::GetReturnPc() const {
Andreas Gampecf4035a2014-05-28 22:43:01 -0700276 byte* sp = reinterpret_cast<byte*>(GetCurrentQuickFrame());
Ian Rogers2bcb4a42012-11-08 10:39:18 -0800277 DCHECK(sp != NULL);
Andreas Gampecf4035a2014-05-28 22:43:01 -0700278 byte* pc_addr = sp + GetMethod()->GetReturnPcOffsetInBytes();
Ian Rogers0399dde2012-06-06 17:09:28 -0700279 return *reinterpret_cast<uintptr_t*>(pc_addr);
280}
281
282void StackVisitor::SetReturnPc(uintptr_t new_ret_pc) {
Andreas Gampecf4035a2014-05-28 22:43:01 -0700283 byte* sp = reinterpret_cast<byte*>(GetCurrentQuickFrame());
Ian Rogers0399dde2012-06-06 17:09:28 -0700284 CHECK(sp != NULL);
Andreas Gampecf4035a2014-05-28 22:43:01 -0700285 byte* pc_addr = sp + GetMethod()->GetReturnPcOffsetInBytes();
Ian Rogers0399dde2012-06-06 17:09:28 -0700286 *reinterpret_cast<uintptr_t*>(pc_addr) = new_ret_pc;
287}
288
Ian Rogers7a22fa62013-01-23 12:16:16 -0800289size_t StackVisitor::ComputeNumFrames(Thread* thread) {
Ian Rogers0399dde2012-06-06 17:09:28 -0700290 struct NumFramesVisitor : public StackVisitor {
Ian Rogers7a22fa62013-01-23 12:16:16 -0800291 explicit NumFramesVisitor(Thread* thread)
292 : StackVisitor(thread, NULL), frames(0) {}
Ian Rogers0399dde2012-06-06 17:09:28 -0700293
Ian Rogers5cf98192014-05-29 21:31:50 -0700294 bool VisitFrame() OVERRIDE {
Ian Rogers0399dde2012-06-06 17:09:28 -0700295 frames++;
296 return true;
297 }
Elliott Hughes08fc03a2012-06-26 17:34:00 -0700298
Ian Rogers0399dde2012-06-06 17:09:28 -0700299 size_t frames;
300 };
Ian Rogers7a22fa62013-01-23 12:16:16 -0800301 NumFramesVisitor visitor(thread);
Ian Rogers0399dde2012-06-06 17:09:28 -0700302 visitor.WalkStack(true);
303 return visitor.frames;
304}
305
Ian Rogers5cf98192014-05-29 21:31:50 -0700306bool StackVisitor::GetNextMethodAndDexPc(mirror::ArtMethod** next_method, uint32_t* next_dex_pc) {
307 struct HasMoreFramesVisitor : public StackVisitor {
308 explicit HasMoreFramesVisitor(Thread* thread, size_t num_frames, size_t frame_height)
309 : StackVisitor(thread, nullptr, num_frames), frame_height_(frame_height),
310 found_frame_(false), has_more_frames_(false), next_method_(nullptr), next_dex_pc_(0) {
311 }
312
313 bool VisitFrame() OVERRIDE SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
314 if (found_frame_) {
315 mirror::ArtMethod* method = GetMethod();
316 if (method != nullptr && !method->IsRuntimeMethod()) {
317 has_more_frames_ = true;
318 next_method_ = method;
319 next_dex_pc_ = GetDexPc();
320 return false; // End stack walk once next method is found.
321 }
322 } else if (GetFrameHeight() == frame_height_) {
323 found_frame_ = true;
324 }
325 return true;
326 }
327
328 size_t frame_height_;
329 bool found_frame_;
330 bool has_more_frames_;
331 mirror::ArtMethod* next_method_;
332 uint32_t next_dex_pc_;
333 };
334 HasMoreFramesVisitor visitor(thread_, GetNumFrames(), GetFrameHeight());
335 visitor.WalkStack(true);
336 *next_method = visitor.next_method_;
337 *next_dex_pc = visitor.next_dex_pc_;
338 return visitor.has_more_frames_;
339}
340
Ian Rogers7a22fa62013-01-23 12:16:16 -0800341void StackVisitor::DescribeStack(Thread* thread) {
Ian Rogers306057f2012-11-26 12:45:53 -0800342 struct DescribeStackVisitor : public StackVisitor {
Ian Rogers7a22fa62013-01-23 12:16:16 -0800343 explicit DescribeStackVisitor(Thread* thread)
344 : StackVisitor(thread, NULL) {}
Ian Rogers306057f2012-11-26 12:45:53 -0800345
Ian Rogers5cf98192014-05-29 21:31:50 -0700346 bool VisitFrame() OVERRIDE SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers306057f2012-11-26 12:45:53 -0800347 LOG(INFO) << "Frame Id=" << GetFrameId() << " " << DescribeLocation();
348 return true;
349 }
350 };
Ian Rogers7a22fa62013-01-23 12:16:16 -0800351 DescribeStackVisitor visitor(thread);
Ian Rogers306057f2012-11-26 12:45:53 -0800352 visitor.WalkStack(true);
353}
354
Ian Rogers40e3bac2012-11-20 00:09:14 -0800355std::string StackVisitor::DescribeLocation() const {
356 std::string result("Visiting method '");
Brian Carlstromea46f952013-07-30 01:26:50 -0700357 mirror::ArtMethod* m = GetMethod();
Ian Rogers306057f2012-11-26 12:45:53 -0800358 if (m == NULL) {
359 return "upcall";
360 }
361 result += PrettyMethod(m);
Ian Rogersef7d42f2014-01-06 12:55:46 -0800362 result += StringPrintf("' at dex PC 0x%04x", GetDexPc());
Ian Rogers40e3bac2012-11-20 00:09:14 -0800363 if (!IsShadowFrame()) {
364 result += StringPrintf(" (native PC %p)", reinterpret_cast<void*>(GetCurrentQuickFramePc()));
365 }
366 return result;
367}
368
Sebastien Hertz74e256b2013-10-04 10:40:37 +0200369instrumentation::InstrumentationStackFrame& StackVisitor::GetInstrumentationStackFrame(uint32_t depth) const {
Sebastien Hertz123756a2013-11-27 15:49:42 +0100370 CHECK_LT(depth, thread_->GetInstrumentationStack()->size());
Ian Rogers7a22fa62013-01-23 12:16:16 -0800371 return thread_->GetInstrumentationStack()->at(depth);
372}
373
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700374void StackVisitor::SanityCheckFrame() const {
Ian Rogersef7d42f2014-01-06 12:55:46 -0800375 if (kIsDebugBuild) {
376 mirror::ArtMethod* method = GetMethod();
Mathieu Chartier119c6bd2014-05-09 14:11:47 -0700377 CHECK_EQ(method->GetClass(), mirror::ArtMethod::GetJavaLangReflectArtMethod());
Ian Rogersef7d42f2014-01-06 12:55:46 -0800378 if (cur_quick_frame_ != nullptr) {
379 method->AssertPcIsWithinQuickCode(cur_quick_frame_pc_);
380 // Frame sanity.
381 size_t frame_size = method->GetFrameSizeInBytes();
382 CHECK_NE(frame_size, 0u);
Andreas Gampe5b417b92014-03-10 14:18:35 -0700383 // A rough guess at an upper size we expect to see for a frame.
384 // 256 registers
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700385 // 2 words HandleScope overhead
Andreas Gampe5b417b92014-03-10 14:18:35 -0700386 // 3+3 register spills
387 // TODO: this seems architecture specific for the case of JNI frames.
Brian Carlstromed08bd42014-03-19 18:34:17 -0700388 // TODO: 083-compiler-regressions ManyFloatArgs shows this estimate is wrong.
389 // const size_t kMaxExpectedFrameSize = (256 + 2 + 3 + 3) * sizeof(word);
390 const size_t kMaxExpectedFrameSize = 2 * KB;
Ian Rogersef7d42f2014-01-06 12:55:46 -0800391 CHECK_LE(frame_size, kMaxExpectedFrameSize);
392 size_t return_pc_offset = method->GetReturnPcOffsetInBytes();
393 CHECK_LT(return_pc_offset, frame_size);
394 }
Ian Rogers0399dde2012-06-06 17:09:28 -0700395 }
Ian Rogers0399dde2012-06-06 17:09:28 -0700396}
397
398void StackVisitor::WalkStack(bool include_transitions) {
Ian Rogers7a22fa62013-01-23 12:16:16 -0800399 DCHECK(thread_ == Thread::Current() || thread_->IsSuspended());
Ian Rogers62d6c772013-02-27 08:32:07 -0800400 CHECK_EQ(cur_depth_, 0U);
401 bool exit_stubs_installed = Runtime::Current()->GetInstrumentation()->AreExitStubsInstalled();
jeffhao725a9572012-11-13 18:20:12 -0800402 uint32_t instrumentation_stack_depth = 0;
Dave Allisonf9439142014-03-27 15:10:22 -0700403
Ian Rogers7a22fa62013-01-23 12:16:16 -0800404 for (const ManagedStack* current_fragment = thread_->GetManagedStack(); current_fragment != NULL;
Ian Rogers0399dde2012-06-06 17:09:28 -0700405 current_fragment = current_fragment->GetLink()) {
406 cur_shadow_frame_ = current_fragment->GetTopShadowFrame();
407 cur_quick_frame_ = current_fragment->GetTopQuickFrame();
408 cur_quick_frame_pc_ = current_fragment->GetTopQuickFramePc();
Dave Allisonf9439142014-03-27 15:10:22 -0700409
Ian Rogers0399dde2012-06-06 17:09:28 -0700410 if (cur_quick_frame_ != NULL) { // Handle quick stack frames.
411 // Can't be both a shadow and a quick fragment.
412 DCHECK(current_fragment->GetTopShadowFrame() == NULL);
Andreas Gampecf4035a2014-05-28 22:43:01 -0700413 mirror::ArtMethod* method = cur_quick_frame_->AsMirrorPtr();
jeffhao6641ea12013-01-02 18:13:42 -0800414 while (method != NULL) {
Dave Allison5cd33752014-04-15 15:57:58 -0700415 SanityCheckFrame();
416 bool should_continue = VisitFrame();
417 if (UNLIKELY(!should_continue)) {
418 return;
Ian Rogers0399dde2012-06-06 17:09:28 -0700419 }
Dave Allison5cd33752014-04-15 15:57:58 -0700420
Ian Rogers0399dde2012-06-06 17:09:28 -0700421 if (context_ != NULL) {
422 context_->FillCalleeSaves(*this);
423 }
424 size_t frame_size = method->GetFrameSizeInBytes();
425 // Compute PC for next stack frame from return PC.
Vladimir Marko4c1c5102014-05-14 16:51:16 +0100426 size_t return_pc_offset = method->GetReturnPcOffsetInBytes(frame_size);
Ian Rogers0399dde2012-06-06 17:09:28 -0700427 byte* return_pc_addr = reinterpret_cast<byte*>(cur_quick_frame_) + return_pc_offset;
428 uintptr_t return_pc = *reinterpret_cast<uintptr_t*>(return_pc_addr);
Ian Rogers62d6c772013-02-27 08:32:07 -0800429 if (UNLIKELY(exit_stubs_installed)) {
Ian Rogers0399dde2012-06-06 17:09:28 -0700430 // While profiling, the return pc is restored from the side stack, except when walking
431 // the stack for an exception where the side stack will be unwound in VisitFrame.
Ian Rogers848871b2013-08-05 10:56:33 -0700432 if (GetQuickInstrumentationExitPc() == return_pc) {
Sebastien Hertz74e256b2013-10-04 10:40:37 +0200433 const instrumentation::InstrumentationStackFrame& instrumentation_frame =
Ian Rogers62d6c772013-02-27 08:32:07 -0800434 GetInstrumentationStackFrame(instrumentation_stack_depth);
jeffhao725a9572012-11-13 18:20:12 -0800435 instrumentation_stack_depth++;
Jeff Haofb2802d2013-07-24 13:53:05 -0700436 if (GetMethod() == Runtime::Current()->GetCalleeSaveMethod(Runtime::kSaveAll)) {
437 // Skip runtime save all callee frames which are used to deliver exceptions.
438 } else if (instrumentation_frame.interpreter_entry_) {
Brian Carlstromea46f952013-07-30 01:26:50 -0700439 mirror::ArtMethod* callee = Runtime::Current()->GetCalleeSaveMethod(Runtime::kRefsAndArgs);
Jeff Haofb2802d2013-07-24 13:53:05 -0700440 CHECK_EQ(GetMethod(), callee) << "Expected: " << PrettyMethod(callee) << " Found: "
Sebastien Hertz138dbfc2013-12-04 18:15:25 +0100441 << PrettyMethod(GetMethod());
Jeff Hao9a916d32013-06-27 18:45:37 -0700442 } else if (instrumentation_frame.method_ != GetMethod()) {
Ian Rogers62d6c772013-02-27 08:32:07 -0800443 LOG(FATAL) << "Expected: " << PrettyMethod(instrumentation_frame.method_)
Sebastien Hertz138dbfc2013-12-04 18:15:25 +0100444 << " Found: " << PrettyMethod(GetMethod());
Ian Rogers62d6c772013-02-27 08:32:07 -0800445 }
446 if (num_frames_ != 0) {
447 // Check agreement of frame Ids only if num_frames_ is computed to avoid infinite
448 // recursion.
449 CHECK(instrumentation_frame.frame_id_ == GetFrameId())
450 << "Expected: " << instrumentation_frame.frame_id_
451 << " Found: " << GetFrameId();
452 }
jeffhao725a9572012-11-13 18:20:12 -0800453 return_pc = instrumentation_frame.return_pc_;
Ian Rogers0399dde2012-06-06 17:09:28 -0700454 }
455 }
456 cur_quick_frame_pc_ = return_pc;
457 byte* next_frame = reinterpret_cast<byte*>(cur_quick_frame_) + frame_size;
Andreas Gampecf4035a2014-05-28 22:43:01 -0700458 cur_quick_frame_ = reinterpret_cast<StackReference<mirror::ArtMethod>*>(next_frame);
Ian Rogers0399dde2012-06-06 17:09:28 -0700459 cur_depth_++;
Andreas Gampecf4035a2014-05-28 22:43:01 -0700460 method = cur_quick_frame_->AsMirrorPtr();
jeffhao6641ea12013-01-02 18:13:42 -0800461 }
Ian Rogers0399dde2012-06-06 17:09:28 -0700462 } else if (cur_shadow_frame_ != NULL) {
463 do {
464 SanityCheckFrame();
465 bool should_continue = VisitFrame();
466 if (UNLIKELY(!should_continue)) {
467 return;
468 }
469 cur_depth_++;
470 cur_shadow_frame_ = cur_shadow_frame_->GetLink();
Brian Carlstromdf629502013-07-17 22:39:56 -0700471 } while (cur_shadow_frame_ != NULL);
Ian Rogers0399dde2012-06-06 17:09:28 -0700472 }
Ian Rogers0399dde2012-06-06 17:09:28 -0700473 if (include_transitions) {
474 bool should_continue = VisitFrame();
475 if (!should_continue) {
476 return;
477 }
478 }
Ian Rogers62d6c772013-02-27 08:32:07 -0800479 cur_depth_++;
480 }
481 if (num_frames_ != 0) {
482 CHECK_EQ(cur_depth_, num_frames_);
Ian Rogers0399dde2012-06-06 17:09:28 -0700483 }
484}
485
Elliott Hughes68e76522011-10-05 13:22:16 -0700486} // namespace art