blob: fabdd4f46a6fe299677b31394ab3d643325b0324 [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
Brian Carlstromfc0e3212013-07-17 14:40:12 -070017#ifndef ART_RUNTIME_STACK_H_
18#define ART_RUNTIME_STACK_H_
Elliott Hughes68e76522011-10-05 13:22:16 -070019
Ian Rogers6d4d9fc2011-11-30 16:24:48 -080020#include "dex_file.h"
jeffhao725a9572012-11-13 18:20:12 -080021#include "instrumentation.h"
Nicolas Geoffray42fcd982014-04-22 11:03:52 +000022#include "arch/context.h"
Ian Rogersef7d42f2014-01-06 12:55:46 -080023#include "base/casts.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080024#include "base/macros.h"
Nicolas Geoffray42fcd982014-04-22 11:03:52 +000025#include "instruction_set.h"
Mathieu Chartier4e305412014-02-19 10:54:44 -080026#include "mirror/object.h"
Ian Rogersef7d42f2014-01-06 12:55:46 -080027#include "mirror/object_reference.h"
Vladimir Marko81949632014-05-02 11:53:22 +010028#include "utils.h"
Mathieu Chartier4e305412014-02-19 10:54:44 -080029#include "verify_object.h"
Elliott Hughes68e76522011-10-05 13:22:16 -070030
31#include <stdint.h>
Ian Rogers40e3bac2012-11-20 00:09:14 -080032#include <string>
Elliott Hughes68e76522011-10-05 13:22:16 -070033
34namespace art {
35
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080036namespace mirror {
Brian Carlstromea46f952013-07-30 01:26:50 -070037 class ArtMethod;
38 class Object;
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080039} // namespace mirror
40
41class Context;
Ian Rogers0399dde2012-06-06 17:09:28 -070042class ShadowFrame;
Mathieu Chartiereb8167a2014-05-07 15:43:14 -070043class HandleScope;
Ian Rogers00f7d0e2012-07-19 15:28:27 -070044class ScopedObjectAccess;
Elliott Hughes68e76522011-10-05 13:22:16 -070045class Thread;
46
Ian Rogers2bcb4a42012-11-08 10:39:18 -080047// The kind of vreg being accessed in calls to Set/GetVReg.
48enum VRegKind {
49 kReferenceVReg,
50 kIntVReg,
51 kFloatVReg,
52 kLongLoVReg,
53 kLongHiVReg,
54 kDoubleLoVReg,
55 kDoubleHiVReg,
56 kConstant,
57 kImpreciseConstant,
58 kUndefined,
59};
60
Razvan A Lupusoruda7a69b2014-01-08 15:09:50 -080061/**
62 * @brief Represents the virtual register numbers that denote special meaning.
63 * @details This is used to make some virtual register numbers to have specific
64 * semantic meaning. This is done so that the compiler can treat all virtual
65 * registers the same way and only special case when needed. For example,
66 * calculating SSA does not care whether a virtual register is a normal one or
67 * a compiler temporary, so it can deal with them in a consistent manner. But,
68 * for example if backend cares about temporaries because it has custom spill
69 * location, then it can special case them only then.
70 */
71enum VRegBaseRegNum : int {
72 /**
73 * @brief Virtual registers originating from dex have number >= 0.
74 */
75 kVRegBaseReg = 0,
76
77 /**
78 * @brief Invalid virtual register number.
79 */
80 kVRegInvalid = -1,
81
82 /**
83 * @brief Used to denote the base register for compiler temporaries.
84 * @details Compiler temporaries are virtual registers not originating
85 * from dex but that are created by compiler. All virtual register numbers
86 * that are <= kVRegTempBaseReg are categorized as compiler temporaries.
87 */
88 kVRegTempBaseReg = -2,
89
90 /**
91 * @brief Base register of temporary that holds the method pointer.
92 * @details This is a special compiler temporary because it has a specific
93 * location on stack.
94 */
95 kVRegMethodPtrBaseReg = kVRegTempBaseReg,
96
97 /**
98 * @brief Base register of non-special compiler temporary.
99 * @details A non-special compiler temporary is one whose spill location
100 * is flexible.
101 */
102 kVRegNonSpecialTempBaseReg = -3,
103};
104
Ian Rogersef7d42f2014-01-06 12:55:46 -0800105// A reference from the shadow stack to a MirrorType object within the Java heap.
106template<class MirrorType>
107class MANAGED StackReference : public mirror::ObjectReference<false, MirrorType> {
108 public:
109 StackReference<MirrorType>() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
110 : mirror::ObjectReference<false, MirrorType>(nullptr) {}
111
112 static StackReference<MirrorType> FromMirrorPtr(MirrorType* p)
113 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
114 return StackReference<MirrorType>(p);
115 }
116
117 private:
118 StackReference<MirrorType>(MirrorType* p) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
119 : mirror::ObjectReference<false, MirrorType>(p) {}
120};
121
Mathieu Chartier67022432012-11-29 18:04:50 -0800122// ShadowFrame has 3 possible layouts:
123// - portable - a unified array of VRegs and references. Precise references need GC maps.
124// - interpreter - separate VRegs and reference arrays. References are in the reference array.
125// - JNI - just VRegs, but where every VReg holds a reference.
Ian Rogers0399dde2012-06-06 17:09:28 -0700126class ShadowFrame {
Elliott Hughes68e76522011-10-05 13:22:16 -0700127 public:
Ian Rogersef7d42f2014-01-06 12:55:46 -0800128 // Compute size of ShadowFrame in bytes assuming it has a reference array.
Jeff Hao66135192013-05-14 11:02:41 -0700129 static size_t ComputeSize(uint32_t num_vregs) {
130 return sizeof(ShadowFrame) + (sizeof(uint32_t) * num_vregs) +
Ian Rogersef7d42f2014-01-06 12:55:46 -0800131 (sizeof(StackReference<mirror::Object>) * num_vregs);
Jeff Hao66135192013-05-14 11:02:41 -0700132 }
133
134 // Create ShadowFrame in heap for deoptimization.
TDYa127ce4cc0d2012-11-18 16:59:53 -0800135 static ShadowFrame* Create(uint32_t num_vregs, ShadowFrame* link,
Brian Carlstromea46f952013-07-30 01:26:50 -0700136 mirror::ArtMethod* method, uint32_t dex_pc) {
Jeff Hao66135192013-05-14 11:02:41 -0700137 uint8_t* memory = new uint8_t[ComputeSize(num_vregs)];
Sebastien Hertzc61124b2013-09-10 11:44:19 +0200138 return Create(num_vregs, link, method, dex_pc, memory);
Jeff Hao66135192013-05-14 11:02:41 -0700139 }
140
141 // Create ShadowFrame for interpreter using provided memory.
142 static ShadowFrame* Create(uint32_t num_vregs, ShadowFrame* link,
Brian Carlstromea46f952013-07-30 01:26:50 -0700143 mirror::ArtMethod* method, uint32_t dex_pc, void* memory) {
TDYa127ce4cc0d2012-11-18 16:59:53 -0800144 ShadowFrame* sf = new (memory) ShadowFrame(num_vregs, link, method, dex_pc, true);
145 return sf;
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700146 }
147 ~ShadowFrame() {}
148
TDYa127ce4cc0d2012-11-18 16:59:53 -0800149 bool HasReferenceArray() const {
Ian Rogers8a01a3a2013-05-06 13:25:44 -0700150#if defined(ART_USE_PORTABLE_COMPILER)
TDYa127ce4cc0d2012-11-18 16:59:53 -0800151 return (number_of_vregs_ & kHasReferenceArray) != 0;
Ian Rogers8a01a3a2013-05-06 13:25:44 -0700152#else
153 return true;
154#endif
Ian Rogers0399dde2012-06-06 17:09:28 -0700155 }
Elliott Hughes68e76522011-10-05 13:22:16 -0700156
TDYa127ce4cc0d2012-11-18 16:59:53 -0800157 uint32_t NumberOfVRegs() const {
Ian Rogers8a01a3a2013-05-06 13:25:44 -0700158#if defined(ART_USE_PORTABLE_COMPILER)
TDYa127ce4cc0d2012-11-18 16:59:53 -0800159 return number_of_vregs_ & ~kHasReferenceArray;
Ian Rogers8a01a3a2013-05-06 13:25:44 -0700160#else
161 return number_of_vregs_;
162#endif
Ian Rogers0399dde2012-06-06 17:09:28 -0700163 }
164
TDYa127ce4cc0d2012-11-18 16:59:53 -0800165 void SetNumberOfVRegs(uint32_t number_of_vregs) {
Ian Rogers8a01a3a2013-05-06 13:25:44 -0700166#if defined(ART_USE_PORTABLE_COMPILER)
TDYa127ce4cc0d2012-11-18 16:59:53 -0800167 number_of_vregs_ = number_of_vregs | (number_of_vregs_ & kHasReferenceArray);
Ian Rogers8a01a3a2013-05-06 13:25:44 -0700168#else
169 UNUSED(number_of_vregs);
170 UNIMPLEMENTED(FATAL) << "Should only be called when portable is enabled";
171#endif
Ian Rogers5438ad82012-10-15 17:22:44 -0700172 }
173
Ian Rogers0399dde2012-06-06 17:09:28 -0700174 uint32_t GetDexPC() const {
175 return dex_pc_;
176 }
177
178 void SetDexPC(uint32_t dex_pc) {
179 dex_pc_ = dex_pc;
180 }
181
Ian Rogers0399dde2012-06-06 17:09:28 -0700182 ShadowFrame* GetLink() const {
183 return link_;
184 }
185
186 void SetLink(ShadowFrame* frame) {
187 DCHECK_NE(this, frame);
188 link_ = frame;
189 }
190
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700191 int32_t GetVReg(size_t i) const {
TDYa127ce4cc0d2012-11-18 16:59:53 -0800192 DCHECK_LT(i, NumberOfVRegs());
193 const uint32_t* vreg = &vregs_[i];
194 return *reinterpret_cast<const int32_t*>(vreg);
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700195 }
196
197 float GetVRegFloat(size_t i) const {
TDYa127ce4cc0d2012-11-18 16:59:53 -0800198 DCHECK_LT(i, NumberOfVRegs());
199 // NOTE: Strict-aliasing?
200 const uint32_t* vreg = &vregs_[i];
201 return *reinterpret_cast<const float*>(vreg);
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700202 }
203
204 int64_t GetVRegLong(size_t i) const {
Sebastien Hertz807a2562013-04-15 09:33:39 +0200205 DCHECK_LT(i, NumberOfVRegs());
TDYa127ce4cc0d2012-11-18 16:59:53 -0800206 const uint32_t* vreg = &vregs_[i];
Jeff Haoe47637c2013-09-19 15:13:16 -0700207 // Alignment attribute required for GCC 4.8
208 typedef const int64_t unaligned_int64 __attribute__ ((aligned (4)));
209 return *reinterpret_cast<unaligned_int64*>(vreg);
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700210 }
211
212 double GetVRegDouble(size_t i) const {
Sebastien Hertz807a2562013-04-15 09:33:39 +0200213 DCHECK_LT(i, NumberOfVRegs());
TDYa127ce4cc0d2012-11-18 16:59:53 -0800214 const uint32_t* vreg = &vregs_[i];
Jeff Haoe47637c2013-09-19 15:13:16 -0700215 // Alignment attribute required for GCC 4.8
216 typedef const double unaligned_double __attribute__ ((aligned (4)));
217 return *reinterpret_cast<unaligned_double*>(vreg);
TDYa127ce4cc0d2012-11-18 16:59:53 -0800218 }
219
Mathieu Chartier4e305412014-02-19 10:54:44 -0800220 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
Ian Rogersef7d42f2014-01-06 12:55:46 -0800221 mirror::Object* GetVRegReference(size_t i) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
TDYa127ce4cc0d2012-11-18 16:59:53 -0800222 DCHECK_LT(i, NumberOfVRegs());
Mathieu Chartier4e305412014-02-19 10:54:44 -0800223 mirror::Object* ref;
TDYa127ce4cc0d2012-11-18 16:59:53 -0800224 if (HasReferenceArray()) {
Mathieu Chartier4e305412014-02-19 10:54:44 -0800225 ref = References()[i].AsMirrorPtr();
TDYa127ce4cc0d2012-11-18 16:59:53 -0800226 } else {
Ian Rogersef7d42f2014-01-06 12:55:46 -0800227 const uint32_t* vreg_ptr = &vregs_[i];
Mathieu Chartier4e305412014-02-19 10:54:44 -0800228 ref = reinterpret_cast<const StackReference<mirror::Object>*>(vreg_ptr)->AsMirrorPtr();
TDYa127ce4cc0d2012-11-18 16:59:53 -0800229 }
Mathieu Chartier4e305412014-02-19 10:54:44 -0800230 if (kVerifyFlags & kVerifyReads) {
231 VerifyObject(ref);
232 }
233 return ref;
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700234 }
235
Jeff Hao16743632013-05-08 10:59:04 -0700236 // Get view of vregs as range of consecutive arguments starting at i.
237 uint32_t* GetVRegArgs(size_t i) {
238 return &vregs_[i];
239 }
240
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700241 void SetVReg(size_t i, int32_t val) {
TDYa127ce4cc0d2012-11-18 16:59:53 -0800242 DCHECK_LT(i, NumberOfVRegs());
243 uint32_t* vreg = &vregs_[i];
244 *reinterpret_cast<int32_t*>(vreg) = val;
Mathieu Chartier590fee92013-09-13 13:46:47 -0700245 // This is needed for moving collectors since these can update the vreg references if they
246 // happen to agree with references in the reference array.
247 if (kMovingCollector && HasReferenceArray()) {
Ian Rogersef7d42f2014-01-06 12:55:46 -0800248 References()[i].Clear();
Mathieu Chartier590fee92013-09-13 13:46:47 -0700249 }
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700250 }
251
252 void SetVRegFloat(size_t i, float val) {
TDYa127ce4cc0d2012-11-18 16:59:53 -0800253 DCHECK_LT(i, NumberOfVRegs());
254 uint32_t* vreg = &vregs_[i];
255 *reinterpret_cast<float*>(vreg) = val;
Mathieu Chartier590fee92013-09-13 13:46:47 -0700256 // This is needed for moving collectors since these can update the vreg references if they
257 // happen to agree with references in the reference array.
258 if (kMovingCollector && HasReferenceArray()) {
Ian Rogersef7d42f2014-01-06 12:55:46 -0800259 References()[i].Clear();
Mathieu Chartier590fee92013-09-13 13:46:47 -0700260 }
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700261 }
262
263 void SetVRegLong(size_t i, int64_t val) {
Sebastien Hertz807a2562013-04-15 09:33:39 +0200264 DCHECK_LT(i, NumberOfVRegs());
TDYa127ce4cc0d2012-11-18 16:59:53 -0800265 uint32_t* vreg = &vregs_[i];
Jeff Haoe47637c2013-09-19 15:13:16 -0700266 // Alignment attribute required for GCC 4.8
267 typedef int64_t unaligned_int64 __attribute__ ((aligned (4)));
268 *reinterpret_cast<unaligned_int64*>(vreg) = val;
Mathieu Chartier590fee92013-09-13 13:46:47 -0700269 // This is needed for moving collectors since these can update the vreg references if they
270 // happen to agree with references in the reference array.
271 if (kMovingCollector && HasReferenceArray()) {
Ian Rogersef7d42f2014-01-06 12:55:46 -0800272 References()[i].Clear();
273 References()[i + 1].Clear();
Mathieu Chartier590fee92013-09-13 13:46:47 -0700274 }
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700275 }
276
277 void SetVRegDouble(size_t i, double val) {
Sebastien Hertz807a2562013-04-15 09:33:39 +0200278 DCHECK_LT(i, NumberOfVRegs());
TDYa127ce4cc0d2012-11-18 16:59:53 -0800279 uint32_t* vreg = &vregs_[i];
Jeff Haoe47637c2013-09-19 15:13:16 -0700280 // Alignment attribute required for GCC 4.8
281 typedef double unaligned_double __attribute__ ((aligned (4)));
282 *reinterpret_cast<unaligned_double*>(vreg) = val;
Mathieu Chartier590fee92013-09-13 13:46:47 -0700283 // This is needed for moving collectors since these can update the vreg references if they
284 // happen to agree with references in the reference array.
285 if (kMovingCollector && HasReferenceArray()) {
Ian Rogersef7d42f2014-01-06 12:55:46 -0800286 References()[i].Clear();
287 References()[i + 1].Clear();
Mathieu Chartier590fee92013-09-13 13:46:47 -0700288 }
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700289 }
290
Mathieu Chartier4e305412014-02-19 10:54:44 -0800291 template<VerifyObjectFlags kVerifyFlags = kDefaultVerifyFlags>
Ian Rogersef7d42f2014-01-06 12:55:46 -0800292 void SetVRegReference(size_t i, mirror::Object* val) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
TDYa127ce4cc0d2012-11-18 16:59:53 -0800293 DCHECK_LT(i, NumberOfVRegs());
Mathieu Chartier4e305412014-02-19 10:54:44 -0800294 if (kVerifyFlags & kVerifyWrites) {
295 VerifyObject(val);
296 }
TDYa127ce4cc0d2012-11-18 16:59:53 -0800297 uint32_t* vreg = &vregs_[i];
Ian Rogersef7d42f2014-01-06 12:55:46 -0800298 reinterpret_cast<StackReference<mirror::Object>*>(vreg)->Assign(val);
TDYa127ce4cc0d2012-11-18 16:59:53 -0800299 if (HasReferenceArray()) {
Ian Rogersef7d42f2014-01-06 12:55:46 -0800300 References()[i].Assign(val);
TDYa127ce4cc0d2012-11-18 16:59:53 -0800301 }
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700302 }
303
Ian Rogersef7d42f2014-01-06 12:55:46 -0800304 mirror::ArtMethod* GetMethod() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
305 DCHECK(method_ != nullptr);
Ian Rogers0399dde2012-06-06 17:09:28 -0700306 return method_;
Elliott Hughes68e76522011-10-05 13:22:16 -0700307 }
308
Hiroshi Yamauchi92d1a662014-05-15 21:43:59 -0700309 mirror::ArtMethod** GetMethodAddress() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
310 DCHECK(method_ != nullptr);
311 return &method_;
312 }
313
Ian Rogers62d6c772013-02-27 08:32:07 -0800314 mirror::Object* GetThisObject() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
315
Jeff Haoe701f482013-05-24 11:50:49 -0700316 mirror::Object* GetThisObject(uint16_t num_ins) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
317
Ian Rogers62d6c772013-02-27 08:32:07 -0800318 ThrowLocation GetCurrentLocationForThrow() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
319
Brian Carlstromea46f952013-07-30 01:26:50 -0700320 void SetMethod(mirror::ArtMethod* method) {
Ian Rogers8a01a3a2013-05-06 13:25:44 -0700321#if defined(ART_USE_PORTABLE_COMPILER)
Ian Rogersef7d42f2014-01-06 12:55:46 -0800322 DCHECK(method != nullptr);
Ian Rogers0399dde2012-06-06 17:09:28 -0700323 method_ = method;
Ian Rogers8a01a3a2013-05-06 13:25:44 -0700324#else
325 UNUSED(method);
326 UNIMPLEMENTED(FATAL) << "Should only be called when portable is enabled";
327#endif
Elliott Hughes68e76522011-10-05 13:22:16 -0700328 }
329
Ian Rogersef7d42f2014-01-06 12:55:46 -0800330 bool Contains(StackReference<mirror::Object>* shadow_frame_entry_obj) const {
TDYa127ce4cc0d2012-11-18 16:59:53 -0800331 if (HasReferenceArray()) {
332 return ((&References()[0] <= shadow_frame_entry_obj) &&
333 (shadow_frame_entry_obj <= (&References()[NumberOfVRegs() - 1])));
334 } else {
335 uint32_t* shadow_frame_entry = reinterpret_cast<uint32_t*>(shadow_frame_entry_obj);
336 return ((&vregs_[0] <= shadow_frame_entry) &&
337 (shadow_frame_entry <= (&vregs_[NumberOfVRegs() - 1])));
Ian Rogers0399dde2012-06-06 17:09:28 -0700338 }
Elliott Hughes68e76522011-10-05 13:22:16 -0700339 }
340
Ian Rogers0399dde2012-06-06 17:09:28 -0700341 static size_t LinkOffset() {
342 return OFFSETOF_MEMBER(ShadowFrame, link_);
343 }
344
Ian Rogers0399dde2012-06-06 17:09:28 -0700345 static size_t MethodOffset() {
346 return OFFSETOF_MEMBER(ShadowFrame, method_);
347 }
348
Ian Rogers0399dde2012-06-06 17:09:28 -0700349 static size_t DexPCOffset() {
350 return OFFSETOF_MEMBER(ShadowFrame, dex_pc_);
351 }
352
Ian Rogers5438ad82012-10-15 17:22:44 -0700353 static size_t NumberOfVRegsOffset() {
354 return OFFSETOF_MEMBER(ShadowFrame, number_of_vregs_);
355 }
356
TDYa127ce4cc0d2012-11-18 16:59:53 -0800357 static size_t VRegsOffset() {
358 return OFFSETOF_MEMBER(ShadowFrame, vregs_);
Ian Rogers5438ad82012-10-15 17:22:44 -0700359 }
360
Elliott Hughes68e76522011-10-05 13:22:16 -0700361 private:
Brian Carlstromea46f952013-07-30 01:26:50 -0700362 ShadowFrame(uint32_t num_vregs, ShadowFrame* link, mirror::ArtMethod* method,
Ian Rogers2dd0e2c2013-01-24 12:42:14 -0800363 uint32_t dex_pc, bool has_reference_array)
TDYa127ce4cc0d2012-11-18 16:59:53 -0800364 : number_of_vregs_(num_vregs), link_(link), method_(method), dex_pc_(dex_pc) {
365 if (has_reference_array) {
Ian Rogers8a01a3a2013-05-06 13:25:44 -0700366#if defined(ART_USE_PORTABLE_COMPILER)
367 CHECK_LT(num_vregs, static_cast<uint32_t>(kHasReferenceArray));
TDYa127ce4cc0d2012-11-18 16:59:53 -0800368 number_of_vregs_ |= kHasReferenceArray;
Ian Rogers8a01a3a2013-05-06 13:25:44 -0700369#endif
Ian Rogersef7d42f2014-01-06 12:55:46 -0800370 memset(vregs_, 0, num_vregs * (sizeof(uint32_t) + sizeof(StackReference<mirror::Object>)));
Mathieu Chartier67022432012-11-29 18:04:50 -0800371 } else {
Jeff Haoe701f482013-05-24 11:50:49 -0700372 memset(vregs_, 0, num_vregs * sizeof(uint32_t));
Ian Rogers2fa6b2e2012-10-17 00:10:17 -0700373 }
374 }
Elliott Hughes68e76522011-10-05 13:22:16 -0700375
Ian Rogersef7d42f2014-01-06 12:55:46 -0800376 const StackReference<mirror::Object>* References() const {
Mathieu Chartier67022432012-11-29 18:04:50 -0800377 DCHECK(HasReferenceArray());
TDYa127ce4cc0d2012-11-18 16:59:53 -0800378 const uint32_t* vreg_end = &vregs_[NumberOfVRegs()];
Ian Rogersef7d42f2014-01-06 12:55:46 -0800379 return reinterpret_cast<const StackReference<mirror::Object>*>(vreg_end);
TDYa127ce4cc0d2012-11-18 16:59:53 -0800380 }
381
Ian Rogersef7d42f2014-01-06 12:55:46 -0800382 StackReference<mirror::Object>* References() {
383 return const_cast<StackReference<mirror::Object>*>(const_cast<const ShadowFrame*>(this)->References());
TDYa127ce4cc0d2012-11-18 16:59:53 -0800384 }
385
Ian Rogers8a01a3a2013-05-06 13:25:44 -0700386#if defined(ART_USE_PORTABLE_COMPILER)
TDYa127ce4cc0d2012-11-18 16:59:53 -0800387 enum ShadowFrameFlag {
388 kHasReferenceArray = 1ul << 31
389 };
Ian Rogers8a01a3a2013-05-06 13:25:44 -0700390 // TODO: make const in the portable case.
TDYa127ce4cc0d2012-11-18 16:59:53 -0800391 uint32_t number_of_vregs_;
Ian Rogers8a01a3a2013-05-06 13:25:44 -0700392#else
393 const uint32_t number_of_vregs_;
394#endif
Ian Rogers5438ad82012-10-15 17:22:44 -0700395 // Link to previous shadow frame or NULL.
Ian Rogers0399dde2012-06-06 17:09:28 -0700396 ShadowFrame* link_;
Brian Carlstromea46f952013-07-30 01:26:50 -0700397 mirror::ArtMethod* method_;
Ian Rogers0399dde2012-06-06 17:09:28 -0700398 uint32_t dex_pc_;
TDYa127ce4cc0d2012-11-18 16:59:53 -0800399 uint32_t vregs_[0];
Elliott Hughes68e76522011-10-05 13:22:16 -0700400
Ian Rogers0399dde2012-06-06 17:09:28 -0700401 DISALLOW_IMPLICIT_CONSTRUCTORS(ShadowFrame);
Elliott Hughes68e76522011-10-05 13:22:16 -0700402};
403
Ian Rogers0399dde2012-06-06 17:09:28 -0700404// The managed stack is used to record fragments of managed code stacks. Managed code stacks
405// may either be shadow frames or lists of frames using fixed frame sizes. Transition records are
406// necessary for transitions between code using different frame layouts and transitions into native
407// code.
Ian Rogersdf1ce912012-11-27 17:07:11 -0800408class PACKED(4) ManagedStack {
Ian Rogers0399dde2012-06-06 17:09:28 -0700409 public:
Ian Rogersca190662012-06-26 15:45:57 -0700410 ManagedStack()
411 : link_(NULL), top_shadow_frame_(NULL), top_quick_frame_(NULL), top_quick_frame_pc_(0) {}
Ian Rogers81d425b2012-09-27 16:03:43 -0700412
413 void PushManagedStackFragment(ManagedStack* fragment) {
414 // Copy this top fragment into given fragment.
415 memcpy(fragment, this, sizeof(ManagedStack));
416 // Clear this fragment, which has become the top.
417 memset(this, 0, sizeof(ManagedStack));
418 // Link our top fragment onto the given fragment.
419 link_ = fragment;
420 }
421
422 void PopManagedStackFragment(const ManagedStack& fragment) {
423 DCHECK(&fragment == link_);
424 // Copy this given fragment back to the top.
425 memcpy(this, &fragment, sizeof(ManagedStack));
426 }
Ian Rogers0399dde2012-06-06 17:09:28 -0700427
428 ManagedStack* GetLink() const {
429 return link_;
430 }
431
Andreas Gampecf4035a2014-05-28 22:43:01 -0700432 StackReference<mirror::ArtMethod>* GetTopQuickFrame() const {
Ian Rogers0399dde2012-06-06 17:09:28 -0700433 return top_quick_frame_;
434 }
435
Andreas Gampecf4035a2014-05-28 22:43:01 -0700436 void SetTopQuickFrame(StackReference<mirror::ArtMethod>* top) {
Sebastien Hertza7b0c422013-04-05 16:19:39 +0200437 DCHECK(top_shadow_frame_ == NULL);
Ian Rogers0399dde2012-06-06 17:09:28 -0700438 top_quick_frame_ = top;
439 }
440
441 uintptr_t GetTopQuickFramePc() const {
442 return top_quick_frame_pc_;
443 }
444
445 void SetTopQuickFramePc(uintptr_t pc) {
Sebastien Hertza7b0c422013-04-05 16:19:39 +0200446 DCHECK(top_shadow_frame_ == NULL);
Ian Rogers0399dde2012-06-06 17:09:28 -0700447 top_quick_frame_pc_ = pc;
448 }
449
450 static size_t TopQuickFrameOffset() {
451 return OFFSETOF_MEMBER(ManagedStack, top_quick_frame_);
452 }
453
454 static size_t TopQuickFramePcOffset() {
455 return OFFSETOF_MEMBER(ManagedStack, top_quick_frame_pc_);
456 }
457
458 ShadowFrame* PushShadowFrame(ShadowFrame* new_top_frame) {
Sebastien Hertza7b0c422013-04-05 16:19:39 +0200459 DCHECK(top_quick_frame_ == NULL);
Ian Rogers0399dde2012-06-06 17:09:28 -0700460 ShadowFrame* old_frame = top_shadow_frame_;
461 top_shadow_frame_ = new_top_frame;
462 new_top_frame->SetLink(old_frame);
463 return old_frame;
464 }
465
466 ShadowFrame* PopShadowFrame() {
Sebastien Hertza7b0c422013-04-05 16:19:39 +0200467 DCHECK(top_quick_frame_ == NULL);
Ian Rogers0399dde2012-06-06 17:09:28 -0700468 CHECK(top_shadow_frame_ != NULL);
469 ShadowFrame* frame = top_shadow_frame_;
470 top_shadow_frame_ = frame->GetLink();
471 return frame;
472 }
473
474 ShadowFrame* GetTopShadowFrame() const {
475 return top_shadow_frame_;
476 }
477
Jeff Hao11ffc2d2013-02-01 11:52:17 -0800478 void SetTopShadowFrame(ShadowFrame* top) {
Sebastien Hertza7b0c422013-04-05 16:19:39 +0200479 DCHECK(top_quick_frame_ == NULL);
Jeff Hao11ffc2d2013-02-01 11:52:17 -0800480 top_shadow_frame_ = top;
481 }
482
Ian Rogers0399dde2012-06-06 17:09:28 -0700483 static size_t TopShadowFrameOffset() {
484 return OFFSETOF_MEMBER(ManagedStack, top_shadow_frame_);
485 }
486
Ian Rogersef7d42f2014-01-06 12:55:46 -0800487 size_t NumJniShadowFrameReferences() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers0399dde2012-06-06 17:09:28 -0700488
Ian Rogersef7d42f2014-01-06 12:55:46 -0800489 bool ShadowFramesContain(StackReference<mirror::Object>* shadow_frame_entry) const;
Ian Rogers0399dde2012-06-06 17:09:28 -0700490
491 private:
492 ManagedStack* link_;
493 ShadowFrame* top_shadow_frame_;
Andreas Gampecf4035a2014-05-28 22:43:01 -0700494 StackReference<mirror::ArtMethod>* top_quick_frame_;
Ian Rogers0399dde2012-06-06 17:09:28 -0700495 uintptr_t top_quick_frame_pc_;
496};
497
498class StackVisitor {
499 protected:
Ian Rogers7a22fa62013-01-23 12:16:16 -0800500 StackVisitor(Thread* thread, Context* context) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers0399dde2012-06-06 17:09:28 -0700501
502 public:
503 virtual ~StackVisitor() {}
504
505 // Return 'true' if we should continue to visit more frames, 'false' to stop.
Ian Rogersb726dcb2012-09-05 08:57:23 -0700506 virtual bool VisitFrame() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) = 0;
Ian Rogers0399dde2012-06-06 17:09:28 -0700507
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700508 void WalkStack(bool include_transitions = false)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700509 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers0399dde2012-06-06 17:09:28 -0700510
Ian Rogersef7d42f2014-01-06 12:55:46 -0800511 mirror::ArtMethod* GetMethod() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
512 if (cur_shadow_frame_ != nullptr) {
Ian Rogers0399dde2012-06-06 17:09:28 -0700513 return cur_shadow_frame_->GetMethod();
Ian Rogersef7d42f2014-01-06 12:55:46 -0800514 } else if (cur_quick_frame_ != nullptr) {
Andreas Gampecf4035a2014-05-28 22:43:01 -0700515 return cur_quick_frame_->AsMirrorPtr();
Hiroshi Yamauchi92d1a662014-05-15 21:43:59 -0700516 } else {
517 return nullptr;
518 }
519 }
520
Ian Rogers0399dde2012-06-06 17:09:28 -0700521 bool IsShadowFrame() const {
Ian Rogersef7d42f2014-01-06 12:55:46 -0800522 return cur_shadow_frame_ != nullptr;
Ian Rogers0399dde2012-06-06 17:09:28 -0700523 }
524
Dave Allisonb373e092014-02-20 16:06:36 -0800525 uint32_t GetDexPc(bool abort_on_failure = true) const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers0c7abda2012-09-19 13:33:42 -0700526
Ian Rogers62d6c772013-02-27 08:32:07 -0800527 mirror::Object* GetThisObject() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
528
Ian Rogers0c7abda2012-09-19 13:33:42 -0700529 size_t GetNativePcOffset() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
530
Ian Rogersef7d42f2014-01-06 12:55:46 -0800531 uintptr_t* CalleeSaveAddress(int num, size_t frame_size) const
532 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers0399dde2012-06-06 17:09:28 -0700533 // Callee saves are held at the top of the frame
Ian Rogersef7d42f2014-01-06 12:55:46 -0800534 DCHECK(GetMethod() != nullptr);
Ian Rogers0399dde2012-06-06 17:09:28 -0700535 byte* save_addr =
536 reinterpret_cast<byte*>(cur_quick_frame_) + frame_size - ((num + 1) * kPointerSize);
Andreas Gampebf6b92a2014-03-05 16:11:04 -0800537#if defined(__i386__) || defined(__x86_64__)
Ian Rogers0399dde2012-06-06 17:09:28 -0700538 save_addr -= kPointerSize; // account for return address
539#endif
Mathieu Chartier67022432012-11-29 18:04:50 -0800540 return reinterpret_cast<uintptr_t*>(save_addr);
Ian Rogers0399dde2012-06-06 17:09:28 -0700541 }
542
Elliott Hughes08fc03a2012-06-26 17:34:00 -0700543 // Returns the height of the stack in the managed stack frames, including transitions.
Ian Rogersb726dcb2012-09-05 08:57:23 -0700544 size_t GetFrameHeight() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers62d6c772013-02-27 08:32:07 -0800545 return GetNumFrames() - cur_depth_ - 1;
Ian Rogers0399dde2012-06-06 17:09:28 -0700546 }
547
Elliott Hughes08fc03a2012-06-26 17:34:00 -0700548 // Returns a frame ID for JDWP use, starting from 1.
Ian Rogersb726dcb2012-09-05 08:57:23 -0700549 size_t GetFrameId() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers0399dde2012-06-06 17:09:28 -0700550 return GetFrameHeight() + 1;
551 }
552
Ian Rogersb726dcb2012-09-05 08:57:23 -0700553 size_t GetNumFrames() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers0399dde2012-06-06 17:09:28 -0700554 if (num_frames_ == 0) {
Ian Rogers7a22fa62013-01-23 12:16:16 -0800555 num_frames_ = ComputeNumFrames(thread_);
Ian Rogers0399dde2012-06-06 17:09:28 -0700556 }
557 return num_frames_;
558 }
559
Ian Rogers5cf98192014-05-29 21:31:50 -0700560 // Get the method and dex pc immediately after the one that's currently being visited.
561 bool GetNextMethodAndDexPc(mirror::ArtMethod** next_method, uint32_t* next_dex_pc)
562 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
563
Brian Carlstromea46f952013-07-30 01:26:50 -0700564 uint32_t GetVReg(mirror::ArtMethod* m, uint16_t vreg, VRegKind kind) const
Ian Rogers2bcb4a42012-11-08 10:39:18 -0800565 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers0399dde2012-06-06 17:09:28 -0700566
Brian Carlstromea46f952013-07-30 01:26:50 -0700567 void SetVReg(mirror::ArtMethod* m, uint16_t vreg, uint32_t new_value, VRegKind kind)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700568 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers0399dde2012-06-06 17:09:28 -0700569
Mathieu Chartier815873e2014-02-13 18:02:13 -0800570 uintptr_t* GetGPRAddress(uint32_t reg) const;
Ian Rogers0399dde2012-06-06 17:09:28 -0700571 uintptr_t GetGPR(uint32_t reg) const;
Mathieu Chartier67022432012-11-29 18:04:50 -0800572 void SetGPR(uint32_t reg, uintptr_t value);
Ian Rogers0399dde2012-06-06 17:09:28 -0700573
Mathieu Chartier423d2a32013-09-12 17:33:56 -0700574 // This is a fast-path for getting/setting values in a quick frame.
Andreas Gampecf4035a2014-05-28 22:43:01 -0700575 uint32_t* GetVRegAddr(StackReference<mirror::ArtMethod>* cur_quick_frame,
576 const DexFile::CodeItem* code_item,
Ian Rogersef7d42f2014-01-06 12:55:46 -0800577 uint32_t core_spills, uint32_t fp_spills, size_t frame_size,
578 uint16_t vreg) const {
Nicolas Geoffray42fcd982014-04-22 11:03:52 +0000579 int offset = GetVRegOffset(code_item, core_spills, fp_spills, frame_size, vreg, kRuntimeISA);
Ian Rogers0ec569a2012-07-01 16:43:46 -0700580 DCHECK_EQ(cur_quick_frame, GetCurrentQuickFrame());
581 byte* vreg_addr = reinterpret_cast<byte*>(cur_quick_frame) + offset;
Mathieu Chartier423d2a32013-09-12 17:33:56 -0700582 return reinterpret_cast<uint32_t*>(vreg_addr);
Ian Rogers0399dde2012-06-06 17:09:28 -0700583 }
584
Ian Rogersef7d42f2014-01-06 12:55:46 -0800585 uintptr_t GetReturnPc() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers0399dde2012-06-06 17:09:28 -0700586
Ian Rogersef7d42f2014-01-06 12:55:46 -0800587 void SetReturnPc(uintptr_t new_ret_pc) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers0399dde2012-06-06 17:09:28 -0700588
589 /*
590 * Return sp-relative offset for a Dalvik virtual register, compiler
591 * spill or Method* in bytes using Method*.
Razvan A Lupusoruda7a69b2014-01-08 15:09:50 -0800592 * Note that (reg >= 0) refers to a Dalvik register, (reg == -1)
593 * denotes an invalid Dalvik register, (reg == -2) denotes Method*
594 * and (reg <= -3) denotes a compiler temporary. A compiler temporary
595 * can be thought of as a virtual register that does not exist in the
596 * dex but holds intermediate values to help optimizations and code
597 * generation. A special compiler temporary is one whose location
598 * in frame is well known while non-special ones do not have a requirement
599 * on location in frame as long as code generator itself knows how
600 * to access them.
Ian Rogers0399dde2012-06-06 17:09:28 -0700601 *
602 * +------------------------+
603 * | IN[ins-1] | {Note: resides in caller's frame}
604 * | . |
605 * | IN[0] |
606 * | caller's Method* |
607 * +========================+ {Note: start of callee's frame}
608 * | core callee-save spill | {variable sized}
609 * +------------------------+
610 * | fp callee-save spill |
611 * +------------------------+
612 * | filler word | {For compatibility, if V[locals-1] used as wide
613 * +------------------------+
614 * | V[locals-1] |
615 * | V[locals-2] |
616 * | . |
617 * | . | ... (reg == 2)
618 * | V[1] | ... (reg == 1)
619 * | V[0] | ... (reg == 0) <---- "locals_start"
620 * +------------------------+
Razvan A Lupusoruda7a69b2014-01-08 15:09:50 -0800621 * | Compiler temp region | ... (reg <= -3)
622 * | |
623 * | |
Ian Rogers0399dde2012-06-06 17:09:28 -0700624 * +------------------------+
625 * | stack alignment padding| {0 to (kStackAlignWords-1) of padding}
626 * +------------------------+
627 * | OUT[outs-1] |
628 * | OUT[outs-2] |
629 * | . |
630 * | OUT[0] |
Razvan A Lupusoruda7a69b2014-01-08 15:09:50 -0800631 * | curMethod* | ... (reg == -2) <<== sp, 16-byte aligned
Ian Rogers0399dde2012-06-06 17:09:28 -0700632 * +========================+
633 */
634 static int GetVRegOffset(const DexFile::CodeItem* code_item,
Ian Rogersb23a7722012-10-09 16:54:26 -0700635 uint32_t core_spills, uint32_t fp_spills,
Nicolas Geoffray42fcd982014-04-22 11:03:52 +0000636 size_t frame_size, int reg, InstructionSet isa) {
Ian Rogers0399dde2012-06-06 17:09:28 -0700637 DCHECK_EQ(frame_size & (kStackAlignment - 1), 0U);
Razvan A Lupusoruda7a69b2014-01-08 15:09:50 -0800638 DCHECK_NE(reg, static_cast<int>(kVRegInvalid));
Vladimir Marko81949632014-05-02 11:53:22 +0100639 int spill_size = POPCOUNT(core_spills) * GetBytesPerGprSpillLocation(isa)
640 + POPCOUNT(fp_spills) * GetBytesPerFprSpillLocation(isa)
Nicolas Geoffray42fcd982014-04-22 11:03:52 +0000641 + sizeof(uint32_t); // Filler.
Ian Rogers0399dde2012-06-06 17:09:28 -0700642 int num_ins = code_item->ins_size_;
643 int num_regs = code_item->registers_size_ - num_ins;
Nicolas Geoffray42fcd982014-04-22 11:03:52 +0000644 int locals_start = frame_size - spill_size - num_regs * sizeof(uint32_t);
Razvan A Lupusoruda7a69b2014-01-08 15:09:50 -0800645 if (reg == static_cast<int>(kVRegMethodPtrBaseReg)) {
646 // The current method pointer corresponds to special location on stack.
647 return 0;
648 } else if (reg <= static_cast<int>(kVRegNonSpecialTempBaseReg)) {
649 /*
650 * Special temporaries may have custom locations and the logic above deals with that.
651 * However, non-special temporaries are placed relative to the locals. Since the
652 * virtual register numbers for temporaries "grow" in negative direction, reg number
653 * will always be <= to the temp base reg. Thus, the logic ensures that the first
654 * temp is at offset -4 bytes from locals, the second is at -8 bytes from locals,
655 * and so on.
656 */
Nicolas Geoffray42fcd982014-04-22 11:03:52 +0000657 int relative_offset =
658 (reg + std::abs(static_cast<int>(kVRegNonSpecialTempBaseReg)) - 1) * sizeof(uint32_t);
Razvan A Lupusoruda7a69b2014-01-08 15:09:50 -0800659 return locals_start + relative_offset;
660 } else if (reg < num_regs) {
661 return locals_start + (reg * sizeof(uint32_t));
Ian Rogers0399dde2012-06-06 17:09:28 -0700662 } else {
Razvan A Lupusoru3bc01742014-02-06 13:18:43 -0800663 // Handle ins.
Nicolas Geoffray42fcd982014-04-22 11:03:52 +0000664 return frame_size + ((reg - num_regs) * sizeof(uint32_t)) + GetBytesPerGprSpillLocation(isa);
Ian Rogers0399dde2012-06-06 17:09:28 -0700665 }
666 }
667
Nicolas Geoffray42fcd982014-04-22 11:03:52 +0000668 static int GetOutVROffset(uint16_t out_num, InstructionSet isa) {
Razvan A Lupusoru3bc01742014-02-06 13:18:43 -0800669 // According to stack model, the first out is above the Method ptr.
Nicolas Geoffray42fcd982014-04-22 11:03:52 +0000670 return GetBytesPerGprSpillLocation(isa) + (out_num * sizeof(uint32_t));
Razvan A Lupusoru3bc01742014-02-06 13:18:43 -0800671 }
672
Ian Rogers0399dde2012-06-06 17:09:28 -0700673 uintptr_t GetCurrentQuickFramePc() const {
674 return cur_quick_frame_pc_;
675 }
676
Andreas Gampecf4035a2014-05-28 22:43:01 -0700677 StackReference<mirror::ArtMethod>* GetCurrentQuickFrame() const {
Ian Rogers0399dde2012-06-06 17:09:28 -0700678 return cur_quick_frame_;
679 }
680
681 ShadowFrame* GetCurrentShadowFrame() const {
682 return cur_shadow_frame_;
683 }
684
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700685 HandleScope* GetCurrentHandleScope() const {
Andreas Gampecf4035a2014-05-28 22:43:01 -0700686 StackReference<mirror::ArtMethod>* sp = GetCurrentQuickFrame();
Mathieu Chartiereb8167a2014-05-07 15:43:14 -0700687 ++sp; // Skip Method*; handle scope comes next;
688 return reinterpret_cast<HandleScope*>(sp);
Elliott Hughes08fc03a2012-06-26 17:34:00 -0700689 }
690
Ian Rogers40e3bac2012-11-20 00:09:14 -0800691 std::string DescribeLocation() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
692
Ian Rogers7a22fa62013-01-23 12:16:16 -0800693 static size_t ComputeNumFrames(Thread* thread) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers306057f2012-11-26 12:45:53 -0800694
Ian Rogers7a22fa62013-01-23 12:16:16 -0800695 static void DescribeStack(Thread* thread) SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers306057f2012-11-26 12:45:53 -0800696
Ian Rogers0399dde2012-06-06 17:09:28 -0700697 private:
Ian Rogers5cf98192014-05-29 21:31:50 -0700698 // Private constructor known in the case that num_frames_ has already been computed.
699 StackVisitor(Thread* thread, Context* context, size_t num_frames)
700 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
701
Sebastien Hertz74e256b2013-10-04 10:40:37 +0200702 instrumentation::InstrumentationStackFrame& GetInstrumentationStackFrame(uint32_t depth) const;
Ian Rogers0399dde2012-06-06 17:09:28 -0700703
Ian Rogersb726dcb2012-09-05 08:57:23 -0700704 void SanityCheckFrame() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_);
Ian Rogers0399dde2012-06-06 17:09:28 -0700705
Ian Rogers7a22fa62013-01-23 12:16:16 -0800706 Thread* const thread_;
Ian Rogers0399dde2012-06-06 17:09:28 -0700707 ShadowFrame* cur_shadow_frame_;
Andreas Gampecf4035a2014-05-28 22:43:01 -0700708 StackReference<mirror::ArtMethod>* cur_quick_frame_;
Ian Rogers0399dde2012-06-06 17:09:28 -0700709 uintptr_t cur_quick_frame_pc_;
710 // Lazily computed, number of frames in the stack.
711 size_t num_frames_;
712 // Depth of the frame we're currently at.
713 size_t cur_depth_;
Brian Carlstrom0cd7ec22013-07-17 23:40:20 -0700714
Ian Rogers0399dde2012-06-06 17:09:28 -0700715 protected:
716 Context* const context_;
717};
718
Elliott Hughes68e76522011-10-05 13:22:16 -0700719} // namespace art
720
Brian Carlstromfc0e3212013-07-17 14:40:12 -0700721#endif // ART_RUNTIME_STACK_H_