blob: 33444f829c146d81437fa2ad4f860fb3ff8f3441 [file] [log] [blame]
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001/*
2 * Copyright (C) 2008 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/*
18 * Dalvik-specific side of debugger support. (The JDWP code is intended to
19 * be relatively generic.)
20 */
Brian Carlstromfc0e3212013-07-17 14:40:12 -070021#ifndef ART_RUNTIME_DEBUGGER_H_
22#define ART_RUNTIME_DEBUGGER_H_
Elliott Hughes872d4ec2011-10-21 17:07:15 -070023
24#include <pthread.h>
25
Sebastien Hertz61b7f1b2013-11-15 15:59:30 +010026#include <set>
Elliott Hughes3bb81562011-10-21 18:52:59 -070027#include <string>
Sebastien Hertz4d25df32014-03-21 17:44:46 +010028#include <vector>
Elliott Hughes3bb81562011-10-21 18:52:59 -070029
Alex Light8c2b9292017-11-09 13:21:01 -080030#include "base/array_ref.h"
Andreas Gampe0f01b582017-01-18 15:22:37 -080031#include "class_linker.h"
Andreas Gampe8cf9cb32017-07-19 09:28:38 -070032#include "gc_root.h"
Andreas Gampe0f01b582017-01-18 15:22:37 -080033#include "handle.h"
Elliott Hughes872d4ec2011-10-21 17:07:15 -070034#include "jdwp/jdwp.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080035#include "jni.h"
36#include "jvalue.h"
Mathieu Chartier3398c782016-09-30 10:27:43 -070037#include "obj_ptr.h"
Alex Light21611932017-09-26 13:07:39 -070038#include "runtime_callbacks.h"
Mingyao Yang99170c62015-07-06 11:10:37 -070039#include "thread.h"
Jeff Hao920af3e2013-08-28 15:46:38 -070040#include "thread_state.h"
Elliott Hughes872d4ec2011-10-21 17:07:15 -070041
42namespace art {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080043namespace mirror {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080044class Class;
45class Object;
46class Throwable;
47} // namespace mirror
Mathieu Chartierc7853442015-03-27 14:35:38 -070048class ArtField;
Mathieu Chartiere401d142015-04-22 13:56:20 -070049class ArtMethod;
Sebastien Hertz6995c602014-09-09 12:10:13 +020050class ObjectRegistry;
Sebastien Hertzcbc50642015-06-01 17:33:12 +020051class ScopedObjectAccess;
Sebastien Hertz6995c602014-09-09 12:10:13 +020052class ScopedObjectAccessUnchecked;
Sebastien Hertz8009f392014-09-01 17:07:11 +020053class StackVisitor;
Ian Rogers1b09b092012-08-20 15:35:52 -070054class Thread;
Elliott Hughes872d4ec2011-10-21 17:07:15 -070055
Alex Light40320712017-12-14 11:52:04 -080056struct DebuggerActiveMethodInspectionCallback : public MethodInspectionCallback {
Roland Levillainbbc6e7e2018-08-24 16:58:47 +010057 bool IsMethodBeingInspected(ArtMethod* method) override REQUIRES_SHARED(Locks::mutator_lock_);
58 bool IsMethodSafeToJit(ArtMethod* method) override REQUIRES_SHARED(Locks::mutator_lock_);
59 bool MethodNeedsDebugVersion(ArtMethod* method) override REQUIRES_SHARED(Locks::mutator_lock_);
Alex Light40320712017-12-14 11:52:04 -080060};
61
Alex Light8c2b9292017-11-09 13:21:01 -080062struct DebuggerDdmCallback : public DdmCallback {
63 void DdmPublishChunk(uint32_t type, const ArrayRef<const uint8_t>& data)
Roland Levillainbbc6e7e2018-08-24 16:58:47 +010064 override REQUIRES_SHARED(Locks::mutator_lock_);
Alex Light8c2b9292017-11-09 13:21:01 -080065};
66
Alex Light40320712017-12-14 11:52:04 -080067struct InternalDebuggerControlCallback : public DebuggerControlCallback {
Roland Levillainbbc6e7e2018-08-24 16:58:47 +010068 void StartDebugger() override;
69 void StopDebugger() override;
70 bool IsDebuggerConfigured() override;
Alex Light21611932017-09-26 13:07:39 -070071};
72
Elliott Hughes872d4ec2011-10-21 17:07:15 -070073/*
74 * Invoke-during-breakpoint support.
75 */
76struct DebugInvokeReq {
Sebastien Hertzcbc50642015-06-01 17:33:12 +020077 DebugInvokeReq(uint32_t invoke_request_id, JDWP::ObjectId invoke_thread_id,
78 mirror::Object* invoke_receiver, mirror::Class* invoke_class,
Mathieu Chartiere401d142015-04-22 13:56:20 -070079 ArtMethod* invoke_method, uint32_t invoke_options,
Sebastien Hertzcbc50642015-06-01 17:33:12 +020080 uint64_t args[], uint32_t args_count)
81 : request_id(invoke_request_id), thread_id(invoke_thread_id), receiver(invoke_receiver),
82 klass(invoke_class), method(invoke_method), arg_count(args_count), arg_values(args),
83 options(invoke_options), reply(JDWP::expandBufAlloc()) {
Elliott Hughes475fc232011-10-25 15:00:35 -070084 }
85
Sebastien Hertzcbc50642015-06-01 17:33:12 +020086 ~DebugInvokeReq() {
87 JDWP::expandBufFree(reply);
88 }
89
90 // Request
91 const uint32_t request_id;
92 const JDWP::ObjectId thread_id;
93 GcRoot<mirror::Object> receiver; // not used for ClassType.InvokeMethod.
Sebastien Hertz1558b572015-02-25 15:05:59 +010094 GcRoot<mirror::Class> klass;
Sebastien Hertzcbc50642015-06-01 17:33:12 +020095 ArtMethod* const method;
Sebastien Hertz1558b572015-02-25 15:05:59 +010096 const uint32_t arg_count;
Sebastien Hertzcbc50642015-06-01 17:33:12 +020097 std::unique_ptr<uint64_t[]> arg_values; // will be null if arg_count_ == 0. We take ownership
98 // of this array so we must delete it upon destruction.
Sebastien Hertz1558b572015-02-25 15:05:59 +010099 const uint32_t options;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700100
Sebastien Hertzcbc50642015-06-01 17:33:12 +0200101 // Reply
102 JDWP::ExpandBuf* const reply;
Sebastien Hertz61b7f1b2013-11-15 15:59:30 +0100103
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -0700104 void VisitRoots(RootVisitor* visitor, const RootInfo& root_info)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700105 REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartier3b05e9b2014-03-25 09:29:43 -0700106
Sebastien Hertz61b7f1b2013-11-15 15:59:30 +0100107 private:
108 DISALLOW_COPY_AND_ASSIGN(DebugInvokeReq);
109};
110
111// Thread local data-structure that holds fields for controlling single-stepping.
Sebastien Hertz597c4f02015-01-26 17:37:14 +0100112class SingleStepControl {
113 public:
114 SingleStepControl(JDWP::JdwpStepSize step_size, JDWP::JdwpStepDepth step_depth,
Mathieu Chartiere401d142015-04-22 13:56:20 -0700115 int stack_depth, ArtMethod* method)
Sebastien Hertz597c4f02015-01-26 17:37:14 +0100116 : step_size_(step_size), step_depth_(step_depth),
117 stack_depth_(stack_depth), method_(method) {
Sebastien Hertz61b7f1b2013-11-15 15:59:30 +0100118 }
119
Sebastien Hertz597c4f02015-01-26 17:37:14 +0100120 JDWP::JdwpStepSize GetStepSize() const {
121 return step_size_;
122 }
Sebastien Hertz61b7f1b2013-11-15 15:59:30 +0100123
Sebastien Hertz597c4f02015-01-26 17:37:14 +0100124 JDWP::JdwpStepDepth GetStepDepth() const {
125 return step_depth_;
126 }
127
128 int GetStackDepth() const {
129 return stack_depth_;
130 }
131
Mathieu Chartiere401d142015-04-22 13:56:20 -0700132 ArtMethod* GetMethod() const {
133 return method_;
Sebastien Hertz597c4f02015-01-26 17:37:14 +0100134 }
135
136 const std::set<uint32_t>& GetDexPcs() const {
137 return dex_pcs_;
138 }
139
Sebastien Hertz597c4f02015-01-26 17:37:14 +0100140 void AddDexPc(uint32_t dex_pc);
141
142 bool ContainsDexPc(uint32_t dex_pc) const;
143
144 private:
Sebastien Hertz61b7f1b2013-11-15 15:59:30 +0100145 // See JdwpStepSize and JdwpStepDepth for details.
Sebastien Hertz597c4f02015-01-26 17:37:14 +0100146 const JDWP::JdwpStepSize step_size_;
147 const JDWP::JdwpStepDepth step_depth_;
148
149 // The stack depth when this single-step was initiated. This is used to support SD_OVER and SD_OUT
150 // single-step depth.
151 const int stack_depth_;
Sebastien Hertz61b7f1b2013-11-15 15:59:30 +0100152
153 // The location this single-step was initiated from.
154 // A single-step is initiated in a suspended thread. We save here the current method and the
155 // set of DEX pcs associated to the source line number where the suspension occurred.
156 // This is used to support SD_INTO and SD_OVER single-step depths so we detect when a single-step
157 // causes the execution of an instruction in a different method or at a different line number.
Mathieu Chartiere401d142015-04-22 13:56:20 -0700158 ArtMethod* method_;
159
Sebastien Hertz597c4f02015-01-26 17:37:14 +0100160 std::set<uint32_t> dex_pcs_;
Sebastien Hertz61b7f1b2013-11-15 15:59:30 +0100161
Sebastien Hertz61b7f1b2013-11-15 15:59:30 +0100162 DISALLOW_COPY_AND_ASSIGN(SingleStepControl);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700163};
164
Sebastien Hertz42cd43f2014-05-13 14:15:41 +0200165// TODO rename to InstrumentationRequest.
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -0700166class DeoptimizationRequest {
167 public:
Sebastien Hertz4d25df32014-03-21 17:44:46 +0100168 enum Kind {
169 kNothing, // no action.
Sebastien Hertz42cd43f2014-05-13 14:15:41 +0200170 kRegisterForEvent, // start listening for instrumentation event.
171 kUnregisterForEvent, // stop listening for instrumentation event.
Sebastien Hertz4d25df32014-03-21 17:44:46 +0100172 kFullDeoptimization, // deoptimize everything.
173 kFullUndeoptimization, // undeoptimize everything.
174 kSelectiveDeoptimization, // deoptimize one method.
175 kSelectiveUndeoptimization // undeoptimize one method.
176 };
177
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -0700178 DeoptimizationRequest() : kind_(kNothing), instrumentation_event_(0), method_(nullptr) {}
Sebastien Hertz4d25df32014-03-21 17:44:46 +0100179
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -0700180 DeoptimizationRequest(const DeoptimizationRequest& other)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700181 REQUIRES_SHARED(Locks::mutator_lock_)
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -0700182 : kind_(other.kind_), instrumentation_event_(other.instrumentation_event_) {
183 // Create a new JNI global reference for the method.
184 SetMethod(other.Method());
185 }
Sebastien Hertz4d25df32014-03-21 17:44:46 +0100186
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700187 ArtMethod* Method() const REQUIRES_SHARED(Locks::mutator_lock_);
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -0700188
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700189 void SetMethod(ArtMethod* m) REQUIRES_SHARED(Locks::mutator_lock_);
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -0700190
191 // Name 'Kind()' would collide with the above enum name.
192 Kind GetKind() const {
193 return kind_;
194 }
195
196 void SetKind(Kind kind) {
197 kind_ = kind;
198 }
199
200 uint32_t InstrumentationEvent() const {
201 return instrumentation_event_;
202 }
203
204 void SetInstrumentationEvent(uint32_t instrumentation_event) {
205 instrumentation_event_ = instrumentation_event;
206 }
207
208 private:
209 Kind kind_;
Sebastien Hertz4d25df32014-03-21 17:44:46 +0100210
Sebastien Hertz42cd43f2014-05-13 14:15:41 +0200211 // TODO we could use a union to hold the instrumentation_event and the method since they
212 // respectively have sense only for kRegisterForEvent/kUnregisterForEvent and
213 // kSelectiveDeoptimization/kSelectiveUndeoptimization.
214
215 // Event to start or stop listening to. Only for kRegisterForEvent and kUnregisterForEvent.
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -0700216 uint32_t instrumentation_event_;
Sebastien Hertz42cd43f2014-05-13 14:15:41 +0200217
Sebastien Hertz4d25df32014-03-21 17:44:46 +0100218 // Method for selective deoptimization.
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -0700219 jmethodID method_;
Sebastien Hertz4d25df32014-03-21 17:44:46 +0100220};
Ian Rogers6a3c1fc2014-10-31 00:33:20 -0700221std::ostream& operator<<(std::ostream& os, const DeoptimizationRequest::Kind& rhs);
Sebastien Hertz4d25df32014-03-21 17:44:46 +0100222
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700223class Dbg {
Elliott Hughesff17f1f2012-01-24 18:12:29 -0800224 public:
Elliott Hughes4ffd3132011-10-24 12:06:42 -0700225 static void SetJdwpAllowed(bool allowed);
Leonard Mosescueb842212016-10-06 17:26:36 -0700226 static bool IsJdwpAllowed();
Elliott Hughes4ffd3132011-10-24 12:06:42 -0700227
Sebastien Hertzb3b173b2015-02-06 09:16:32 +0100228 static void StartJdwp();
Elliott Hughesd1cc8362011-10-24 16:58:50 -0700229 static void StopJdwp();
230
Elliott Hughes767a1472011-10-26 18:49:02 -0700231 // Invoked by the GC in case we need to keep DDMS informed.
Mathieu Chartier90443472015-07-16 20:32:27 -0700232 static void GcDidFinish() REQUIRES(!Locks::mutator_lock_);
Elliott Hughes767a1472011-10-26 18:49:02 -0700233
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700234 // Return the DebugInvokeReq for the current thread.
235 static DebugInvokeReq* GetInvokeReq();
236
Elliott Hughes475fc232011-10-25 15:00:35 -0700237 static Thread* GetDebugThread();
238 static void ClearWaitForEventThread();
239
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700240 /*
241 * Enable/disable breakpoints and step modes. Used to provide a heads-up
242 * when the debugger attaches.
243 */
244 static void Connected();
Sebastien Hertz138dbfc2013-12-04 18:15:25 +0100245 static void GoActive()
Mathieu Chartier90443472015-07-16 20:32:27 -0700246 REQUIRES(!Locks::breakpoint_lock_, !Locks::deoptimization_lock_, !Locks::mutator_lock_);
247 static void Disconnected() REQUIRES(!Locks::deoptimization_lock_, !Locks::mutator_lock_);
Sebastien Hertz4e5b2082015-03-24 19:03:40 +0100248 static void Dispose() {
249 gDisposed = true;
250 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700251
Elliott Hughesc0f09332012-03-26 13:27:06 -0700252 // Returns true if we're actually debugging with a real debugger, false if it's
253 // just DDMS (or nothing at all).
Daniel Mihalyieb076692014-08-22 17:33:31 +0200254 static bool IsDebuggerActive() {
255 return gDebuggerActive;
256 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700257
Sebastien Hertzb3b173b2015-02-06 09:16:32 +0100258 // Configures JDWP with parsed command-line options.
Alex Light40320712017-12-14 11:52:04 -0800259 static void ConfigureJdwp(const JDWP::JdwpOptions& jdwp_options)
260 REQUIRES_SHARED(Locks::mutator_lock_);
Sebastien Hertzb3b173b2015-02-06 09:16:32 +0100261
Elliott Hughesc0f09332012-03-26 13:27:06 -0700262 // Returns true if we had -Xrunjdwp or -agentlib:jdwp= on the command line.
263 static bool IsJdwpConfigured();
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700264
Mathieu Chartierd8565452015-03-26 09:41:50 -0700265 // Returns true if a method has any breakpoints.
Mathieu Chartiere401d142015-04-22 13:56:20 -0700266 static bool MethodHasAnyBreakpoints(ArtMethod* method)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700267 REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Locks::breakpoint_lock_);
Mathieu Chartierd8565452015-03-26 09:41:50 -0700268
Sebastien Hertz4e5b2082015-03-24 19:03:40 +0100269 static bool IsDisposed() {
270 return gDisposed;
271 }
Elliott Hughes86964332012-02-15 19:37:42 -0800272
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700273 /*
274 * Time, in milliseconds, since the last debugger activity. Does not
275 * include DDMS activity. Returns -1 if there has been no activity.
276 * Returns 0 if we're in the middle of handling a debugger request.
277 */
278 static int64_t LastDebuggerActivity();
279
Sebastien Hertz253fa552014-10-14 17:27:15 +0200280 static void UndoDebuggerSuspensions()
Mathieu Chartier90443472015-07-16 20:32:27 -0700281 REQUIRES(!Locks::thread_list_lock_, !Locks::thread_suspend_count_lock_);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700282
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700283 /*
284 * Class, Object, Array
285 */
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700286 static std::string GetClassName(JDWP::RefTypeId id)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700287 REQUIRES_SHARED(Locks::mutator_lock_);
Sebastien Hertz6995c602014-09-09 12:10:13 +0200288 static std::string GetClassName(mirror::Class* klass)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700289 REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogersc0542af2014-09-03 16:16:56 -0700290 static JDWP::JdwpError GetClassObject(JDWP::RefTypeId id, JDWP::ObjectId* class_object_id)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700291 REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogersc0542af2014-09-03 16:16:56 -0700292 static JDWP::JdwpError GetSuperclass(JDWP::RefTypeId id, JDWP::RefTypeId* superclass_id)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700293 REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700294 static JDWP::JdwpError GetClassLoader(JDWP::RefTypeId id, JDWP::ExpandBuf* pReply)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700295 REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700296 static JDWP::JdwpError GetModifiers(JDWP::RefTypeId id, JDWP::ExpandBuf* pReply)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700297 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes88d63092013-01-09 09:55:54 -0800298 static JDWP::JdwpError GetReflectedType(JDWP::RefTypeId class_id, JDWP::ExpandBuf* pReply)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700299 REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogersc0542af2014-09-03 16:16:56 -0700300 static void GetClassList(std::vector<JDWP::RefTypeId>* classes)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700301 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes88d63092013-01-09 09:55:54 -0800302 static JDWP::JdwpError GetClassInfo(JDWP::RefTypeId class_id, JDWP::JdwpTypeTag* pTypeTag,
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700303 uint32_t* pStatus, std::string* pDescriptor)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700304 REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogersc0542af2014-09-03 16:16:56 -0700305 static void FindLoadedClassBySignature(const char* descriptor, std::vector<JDWP::RefTypeId>* ids)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700306 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes64f574f2013-02-20 14:57:12 -0800307 static JDWP::JdwpError GetReferenceType(JDWP::ObjectId object_id, JDWP::ExpandBuf* pReply)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700308 REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogersfc0e94b2013-09-23 23:51:32 -0700309 static JDWP::JdwpError GetSignature(JDWP::RefTypeId ref_type_id, std::string* signature)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700310 REQUIRES_SHARED(Locks::mutator_lock_);
Orion Hodson77d8a1c2017-04-24 14:53:19 +0100311 static JDWP::JdwpError GetSourceDebugExtension(JDWP::RefTypeId ref_type_id,
312 std::string* extension_data)
313 REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogersc0542af2014-09-03 16:16:56 -0700314 static JDWP::JdwpError GetSourceFile(JDWP::RefTypeId ref_type_id, std::string* source_file)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700315 REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogersc0542af2014-09-03 16:16:56 -0700316 static JDWP::JdwpError GetObjectTag(JDWP::ObjectId object_id, uint8_t* tag)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700317 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughesaed4be92011-12-02 16:16:23 -0800318 static size_t GetTagWidth(JDWP::JdwpTag tag);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700319
Ian Rogersc0542af2014-09-03 16:16:56 -0700320 static JDWP::JdwpError GetArrayLength(JDWP::ObjectId array_id, int32_t* length)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700321 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes88d63092013-01-09 09:55:54 -0800322 static JDWP::JdwpError OutputArray(JDWP::ObjectId array_id, int offset, int count,
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700323 JDWP::ExpandBuf* pReply)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700324 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes88d63092013-01-09 09:55:54 -0800325 static JDWP::JdwpError SetArrayElements(JDWP::ObjectId array_id, int offset, int count,
Ian Rogersc0542af2014-09-03 16:16:56 -0700326 JDWP::Request* request)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700327 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700328
Sebastien Hertz2c3e77a2015-04-02 16:26:48 +0200329 static JDWP::JdwpError CreateString(const std::string& str, JDWP::ObjectId* new_string_id)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700330 REQUIRES_SHARED(Locks::mutator_lock_);
Sebastien Hertz2c3e77a2015-04-02 16:26:48 +0200331 static JDWP::JdwpError CreateObject(JDWP::RefTypeId class_id, JDWP::ObjectId* new_object_id)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700332 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes88d63092013-01-09 09:55:54 -0800333 static JDWP::JdwpError CreateArrayObject(JDWP::RefTypeId array_class_id, uint32_t length,
Sebastien Hertz2c3e77a2015-04-02 16:26:48 +0200334 JDWP::ObjectId* new_array_id)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700335 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700336
Sebastien Hertz6995c602014-09-09 12:10:13 +0200337 //
338 // Event filtering.
339 //
340 static bool MatchThread(JDWP::ObjectId expected_thread_id, Thread* event_thread)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700341 REQUIRES_SHARED(Locks::mutator_lock_);
Sebastien Hertz6995c602014-09-09 12:10:13 +0200342
343 static bool MatchLocation(const JDWP::JdwpLocation& expected_location,
344 const JDWP::EventLocation& event_location)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700345 REQUIRES_SHARED(Locks::mutator_lock_);
Sebastien Hertz6995c602014-09-09 12:10:13 +0200346
Mathieu Chartier3398c782016-09-30 10:27:43 -0700347 static bool MatchType(ObjPtr<mirror::Class> event_class, JDWP::RefTypeId class_id)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700348 REQUIRES_SHARED(Locks::mutator_lock_);
Sebastien Hertz6995c602014-09-09 12:10:13 +0200349
350 static bool MatchField(JDWP::RefTypeId expected_type_id, JDWP::FieldId expected_field_id,
Mathieu Chartierc7853442015-03-27 14:35:38 -0700351 ArtField* event_field)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700352 REQUIRES_SHARED(Locks::mutator_lock_);
Sebastien Hertz6995c602014-09-09 12:10:13 +0200353
354 static bool MatchInstance(JDWP::ObjectId expected_instance_id, mirror::Object* event_instance)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700355 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700356
Elliott Hughesec0f83d2013-01-15 16:54:08 -0800357 //
358 // Monitors.
359 //
360 static JDWP::JdwpError GetMonitorInfo(JDWP::ObjectId object_id, JDWP::ExpandBuf* reply)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700361 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughesec0f83d2013-01-15 16:54:08 -0800362 static JDWP::JdwpError GetOwnedMonitors(JDWP::ObjectId thread_id,
Ian Rogersc0542af2014-09-03 16:16:56 -0700363 std::vector<JDWP::ObjectId>* monitors,
364 std::vector<uint32_t>* stack_depths)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700365 REQUIRES(!Locks::thread_list_lock_) REQUIRES_SHARED(Locks::mutator_lock_);
Sebastien Hertz52d131d2014-03-13 16:17:40 +0100366 static JDWP::JdwpError GetContendedMonitor(JDWP::ObjectId thread_id,
Ian Rogersc0542af2014-09-03 16:16:56 -0700367 JDWP::ObjectId* contended_monitor)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700368 REQUIRES(!Locks::thread_list_lock_) REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughesec0f83d2013-01-15 16:54:08 -0800369
370 //
371 // Heap.
372 //
373 static JDWP::JdwpError GetInstanceCounts(const std::vector<JDWP::RefTypeId>& class_ids,
Ian Rogersc0542af2014-09-03 16:16:56 -0700374 std::vector<uint64_t>* counts)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700375 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes3b78c942013-01-15 17:35:41 -0800376 static JDWP::JdwpError GetInstances(JDWP::RefTypeId class_id, int32_t max_count,
Ian Rogersc0542af2014-09-03 16:16:56 -0700377 std::vector<JDWP::ObjectId>* instances)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700378 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes0cbaff52013-01-16 15:28:01 -0800379 static JDWP::JdwpError GetReferringObjects(JDWP::ObjectId object_id, int32_t max_count,
Ian Rogersc0542af2014-09-03 16:16:56 -0700380 std::vector<JDWP::ObjectId>* referring_objects)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700381 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes64f574f2013-02-20 14:57:12 -0800382 static JDWP::JdwpError DisableCollection(JDWP::ObjectId object_id)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700383 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes64f574f2013-02-20 14:57:12 -0800384 static JDWP::JdwpError EnableCollection(JDWP::ObjectId object_id)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700385 REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogersc0542af2014-09-03 16:16:56 -0700386 static JDWP::JdwpError IsCollected(JDWP::ObjectId object_id, bool* is_collected)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700387 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes64f574f2013-02-20 14:57:12 -0800388 static void DisposeObject(JDWP::ObjectId object_id, uint32_t reference_count)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700389 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughesec0f83d2013-01-15 16:54:08 -0800390
Elliott Hughes9777ba22013-01-17 09:04:19 -0800391 //
392 // Methods and fields.
393 //
Elliott Hughesa96836a2013-01-17 12:27:49 -0800394 static std::string GetMethodName(JDWP::MethodId method_id)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700395 REQUIRES_SHARED(Locks::mutator_lock_);
Alex Light73376312017-04-06 10:10:51 -0700396 static bool IsMethodObsolete(JDWP::MethodId method_id)
397 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes88d63092013-01-09 09:55:54 -0800398 static JDWP::JdwpError OutputDeclaredFields(JDWP::RefTypeId ref_type_id, bool with_generic,
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700399 JDWP::ExpandBuf* pReply)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700400 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes88d63092013-01-09 09:55:54 -0800401 static JDWP::JdwpError OutputDeclaredMethods(JDWP::RefTypeId ref_type_id, bool with_generic,
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700402 JDWP::ExpandBuf* pReply)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700403 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes88d63092013-01-09 09:55:54 -0800404 static JDWP::JdwpError OutputDeclaredInterfaces(JDWP::RefTypeId ref_type_id,
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700405 JDWP::ExpandBuf* pReply)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700406 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes88d63092013-01-09 09:55:54 -0800407 static void OutputLineTable(JDWP::RefTypeId ref_type_id, JDWP::MethodId method_id,
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700408 JDWP::ExpandBuf* pReply)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700409 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes88d63092013-01-09 09:55:54 -0800410 static void OutputVariableTable(JDWP::RefTypeId ref_type_id, JDWP::MethodId id, bool with_generic,
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700411 JDWP::ExpandBuf* pReply)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700412 REQUIRES_SHARED(Locks::mutator_lock_);
Jeff Hao579b0242013-11-18 13:16:49 -0800413 static void OutputMethodReturnValue(JDWP::MethodId method_id, const JValue* return_value,
414 JDWP::ExpandBuf* pReply)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700415 REQUIRES_SHARED(Locks::mutator_lock_);
Sebastien Hertz3f52eaf2014-04-04 17:50:18 +0200416 static void OutputFieldValue(JDWP::FieldId field_id, const JValue* field_value,
417 JDWP::ExpandBuf* pReply)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700418 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes9777ba22013-01-17 09:04:19 -0800419 static JDWP::JdwpError GetBytecodes(JDWP::RefTypeId class_id, JDWP::MethodId method_id,
Ian Rogersc0542af2014-09-03 16:16:56 -0700420 std::vector<uint8_t>* bytecodes)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700421 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700422
Elliott Hughesa96836a2013-01-17 12:27:49 -0800423 static std::string GetFieldName(JDWP::FieldId field_id)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700424 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes88d63092013-01-09 09:55:54 -0800425 static JDWP::JdwpTag GetFieldBasicTag(JDWP::FieldId field_id)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700426 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes88d63092013-01-09 09:55:54 -0800427 static JDWP::JdwpTag GetStaticFieldBasicTag(JDWP::FieldId field_id)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700428 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes88d63092013-01-09 09:55:54 -0800429 static JDWP::JdwpError GetFieldValue(JDWP::ObjectId object_id, JDWP::FieldId field_id,
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700430 JDWP::ExpandBuf* pReply)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700431 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes88d63092013-01-09 09:55:54 -0800432 static JDWP::JdwpError SetFieldValue(JDWP::ObjectId object_id, JDWP::FieldId field_id,
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700433 uint64_t value, int width)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700434 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes88d63092013-01-09 09:55:54 -0800435 static JDWP::JdwpError GetStaticFieldValue(JDWP::RefTypeId ref_type_id, JDWP::FieldId field_id,
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700436 JDWP::ExpandBuf* pReply)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700437 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes88d63092013-01-09 09:55:54 -0800438 static JDWP::JdwpError SetStaticFieldValue(JDWP::FieldId field_id, uint64_t value, int width)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700439 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700440
Sebastien Hertzb0b0b492014-09-15 11:27:27 +0200441 static JDWP::JdwpError StringToUtf8(JDWP::ObjectId string_id, std::string* str)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700442 REQUIRES_SHARED(Locks::mutator_lock_);
Jeff Hao579b0242013-11-18 13:16:49 -0800443 static void OutputJValue(JDWP::JdwpTag tag, const JValue* return_value, JDWP::ExpandBuf* pReply)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700444 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700445
446 /*
447 * Thread, ThreadGroup, Frame
448 */
Ian Rogersc0542af2014-09-03 16:16:56 -0700449 static JDWP::JdwpError GetThreadName(JDWP::ObjectId thread_id, std::string* name)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700450 REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Locks::thread_list_lock_);
Sebastien Hertz52d131d2014-03-13 16:17:40 +0100451 static JDWP::JdwpError GetThreadGroup(JDWP::ObjectId thread_id, JDWP::ExpandBuf* pReply)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700452 REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(!Locks::thread_list_lock_);
Sebastien Hertza06430c2014-09-15 19:21:30 +0200453 static JDWP::JdwpError GetThreadGroupName(JDWP::ObjectId thread_group_id,
454 JDWP::ExpandBuf* pReply)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700455 REQUIRES_SHARED(Locks::mutator_lock_);
Sebastien Hertza06430c2014-09-15 19:21:30 +0200456 static JDWP::JdwpError GetThreadGroupParent(JDWP::ObjectId thread_group_id,
457 JDWP::ExpandBuf* pReply)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700458 REQUIRES_SHARED(Locks::mutator_lock_);
Sebastien Hertza06430c2014-09-15 19:21:30 +0200459 static JDWP::JdwpError GetThreadGroupChildren(JDWP::ObjectId thread_group_id,
460 JDWP::ExpandBuf* pReply)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700461 REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700462 static JDWP::ObjectId GetSystemThreadGroupId()
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700463 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700464
Jeff Hao920af3e2013-08-28 15:46:38 -0700465 static JDWP::JdwpThreadStatus ToJdwpThreadStatus(ThreadState state);
Sebastien Hertz52d131d2014-03-13 16:17:40 +0100466 static JDWP::JdwpError GetThreadStatus(JDWP::ObjectId thread_id,
467 JDWP::JdwpThreadStatus* pThreadStatus,
468 JDWP::JdwpSuspendStatus* pSuspendStatus)
Mathieu Chartier90443472015-07-16 20:32:27 -0700469 REQUIRES(!Locks::thread_list_lock_);
Sebastien Hertz52d131d2014-03-13 16:17:40 +0100470 static JDWP::JdwpError GetThreadDebugSuspendCount(JDWP::ObjectId thread_id,
471 JDWP::ExpandBuf* pReply)
Mathieu Chartier90443472015-07-16 20:32:27 -0700472 REQUIRES(!Locks::thread_list_lock_, !Locks::thread_suspend_count_lock_);
Brian Carlstrom7934ac22013-07-26 10:54:15 -0700473 // static void WaitForSuspend(JDWP::ObjectId thread_id);
Elliott Hughescaf76542012-06-28 16:08:22 -0700474
Elliott Hughes026b1462012-06-28 20:43:49 -0700475 // Fills 'thread_ids' with the threads in the given thread group. If thread_group_id == 0,
Elliott Hughescaf76542012-06-28 16:08:22 -0700476 // returns all threads.
Sebastien Hertza06430c2014-09-15 19:21:30 +0200477 static void GetThreads(mirror::Object* thread_group, std::vector<JDWP::ObjectId>* thread_ids)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700478 REQUIRES(!Locks::thread_list_lock_) REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughescaf76542012-06-28 16:08:22 -0700479
Ian Rogersc0542af2014-09-03 16:16:56 -0700480 static JDWP::JdwpError GetThreadFrameCount(JDWP::ObjectId thread_id, size_t* result)
Mathieu Chartier90443472015-07-16 20:32:27 -0700481 REQUIRES(!Locks::thread_list_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700482 static JDWP::JdwpError GetThreadFrames(JDWP::ObjectId thread_id, size_t start_frame,
483 size_t frame_count, JDWP::ExpandBuf* buf)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700484 REQUIRES(!Locks::thread_list_lock_) REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700485
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700486 static JDWP::ObjectId GetThreadSelfId() REQUIRES_SHARED(Locks::mutator_lock_);
487 static JDWP::ObjectId GetThreadId(Thread* thread) REQUIRES_SHARED(Locks::mutator_lock_);
Sebastien Hertz6995c602014-09-09 12:10:13 +0200488
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700489 static void SuspendVM()
Mathieu Chartier90443472015-07-16 20:32:27 -0700490 REQUIRES(!Locks::thread_list_lock_, !Locks::thread_suspend_count_lock_);
Sebastien Hertz253fa552014-10-14 17:27:15 +0200491 static void ResumeVM()
Mathieu Chartier90443472015-07-16 20:32:27 -0700492 REQUIRES(!Locks::thread_list_lock_, !Locks::thread_suspend_count_lock_);
Elliott Hughes88d63092013-01-09 09:55:54 -0800493 static JDWP::JdwpError SuspendThread(JDWP::ObjectId thread_id, bool request_suspension = true)
Mathieu Chartier90443472015-07-16 20:32:27 -0700494 REQUIRES(!Locks::mutator_lock_, !Locks::thread_list_lock_,
495 !Locks::thread_suspend_count_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700496
Elliott Hughes88d63092013-01-09 09:55:54 -0800497 static void ResumeThread(JDWP::ObjectId thread_id)
Mathieu Chartier90443472015-07-16 20:32:27 -0700498 REQUIRES(!Locks::thread_list_lock_, !Locks::thread_suspend_count_lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700499 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700500 static void SuspendSelf();
501
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700502 static JDWP::JdwpError GetThisObject(JDWP::ObjectId thread_id, JDWP::FrameId frame_id,
503 JDWP::ObjectId* result)
Mathieu Chartier90443472015-07-16 20:32:27 -0700504 REQUIRES(!Locks::thread_list_lock_, !Locks::thread_suspend_count_lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700505 REQUIRES_SHARED(Locks::mutator_lock_);
Sebastien Hertz8009f392014-09-01 17:07:11 +0200506 static JDWP::JdwpError GetLocalValues(JDWP::Request* request, JDWP::ExpandBuf* pReply)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700507 REQUIRES(!Locks::thread_list_lock_) REQUIRES_SHARED(Locks::mutator_lock_);
Sebastien Hertz8009f392014-09-01 17:07:11 +0200508 static JDWP::JdwpError SetLocalValues(JDWP::Request* request)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700509 REQUIRES(!Locks::thread_list_lock_) REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700510
Sebastien Hertz52d131d2014-03-13 16:17:40 +0100511 static JDWP::JdwpError Interrupt(JDWP::ObjectId thread_id)
Mathieu Chartier90443472015-07-16 20:32:27 -0700512 REQUIRES(!Locks::thread_list_lock_);
Elliott Hughesf9501702013-01-11 11:22:27 -0800513
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700514 /*
515 * Debugger notification
516 */
Ian Rogers6a3c1fc2014-10-31 00:33:20 -0700517 enum EventFlag {
Elliott Hughes86964332012-02-15 19:37:42 -0800518 kBreakpoint = 0x01,
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700519 kSingleStep = 0x02,
520 kMethodEntry = 0x04,
521 kMethodExit = 0x08,
522 };
Mathieu Chartiere401d142015-04-22 13:56:20 -0700523 static void PostFieldAccessEvent(ArtMethod* m, int dex_pc, mirror::Object* this_object,
Mathieu Chartierc7853442015-03-27 14:35:38 -0700524 ArtField* f)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700525 REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartiere401d142015-04-22 13:56:20 -0700526 static void PostFieldModificationEvent(ArtMethod* m, int dex_pc,
Mathieu Chartierc7853442015-03-27 14:35:38 -0700527 mirror::Object* this_object, ArtField* f,
Sebastien Hertz3f52eaf2014-04-04 17:50:18 +0200528 const JValue* field_value)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700529 REQUIRES_SHARED(Locks::mutator_lock_);
Nicolas Geoffray14691c52015-03-05 10:40:17 +0000530 static void PostException(mirror::Throwable* exception)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700531 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700532
Ian Rogers62d6c772013-02-27 08:32:07 -0800533 static void UpdateDebugger(Thread* thread, mirror::Object* this_object,
Mathieu Chartiere401d142015-04-22 13:56:20 -0700534 ArtMethod* method, uint32_t new_dex_pc,
Sebastien Hertz8379b222014-02-24 17:38:15 +0100535 int event_flags, const JValue* return_value)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700536 REQUIRES(!Locks::breakpoint_lock_) REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes91bf6cd2012-02-14 17:27:48 -0800537
Sebastien Hertzf3928792014-11-17 19:00:37 +0100538 // Indicates whether we need deoptimization for debugging.
539 static bool RequiresDeoptimization();
540
Sebastien Hertz4d25df32014-03-21 17:44:46 +0100541 // Records deoptimization request in the queue.
542 static void RequestDeoptimization(const DeoptimizationRequest& req)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700543 REQUIRES(!Locks::deoptimization_lock_) REQUIRES_SHARED(Locks::mutator_lock_);
Sebastien Hertz138dbfc2013-12-04 18:15:25 +0100544
Sebastien Hertz4d25df32014-03-21 17:44:46 +0100545 // Manage deoptimization after updating JDWP events list. Suspends all threads, processes each
546 // request and finally resumes all threads.
Sebastien Hertz138dbfc2013-12-04 18:15:25 +0100547 static void ManageDeoptimization()
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700548 REQUIRES(!Locks::deoptimization_lock_) REQUIRES_SHARED(Locks::mutator_lock_);
Sebastien Hertz138dbfc2013-12-04 18:15:25 +0100549
550 // Breakpoints.
Sebastien Hertz4d25df32014-03-21 17:44:46 +0100551 static void WatchLocation(const JDWP::JdwpLocation* pLoc, DeoptimizationRequest* req)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700552 REQUIRES(!Locks::breakpoint_lock_) REQUIRES_SHARED(Locks::mutator_lock_);
Sebastien Hertz4d25df32014-03-21 17:44:46 +0100553 static void UnwatchLocation(const JDWP::JdwpLocation* pLoc, DeoptimizationRequest* req)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700554 REQUIRES(!Locks::breakpoint_lock_) REQUIRES_SHARED(Locks::mutator_lock_);
Sebastien Hertz138dbfc2013-12-04 18:15:25 +0100555
Daniel Mihalyieb076692014-08-22 17:33:31 +0200556 /*
557 * Forced interpreter checkers for single-step and continue support.
558 */
559
560 // Indicates whether we need to force the use of interpreter to invoke a method.
561 // This allows to single-step or continue into the called method.
Mathieu Chartiere401d142015-04-22 13:56:20 -0700562 static bool IsForcedInterpreterNeededForCalling(Thread* thread, ArtMethod* m)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700563 REQUIRES_SHARED(Locks::mutator_lock_) {
Daniel Mihalyieb076692014-08-22 17:33:31 +0200564 if (!IsDebuggerActive()) {
565 return false;
566 }
567 return IsForcedInterpreterNeededForCallingImpl(thread, m);
568 }
569
570 // Indicates whether we need to force the use of interpreter entrypoint when calling a
571 // method through the resolution trampoline. This allows to single-step or continue into
572 // the called method.
Mathieu Chartiere401d142015-04-22 13:56:20 -0700573 static bool IsForcedInterpreterNeededForResolution(Thread* thread, ArtMethod* m)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700574 REQUIRES_SHARED(Locks::mutator_lock_) {
Daniel Mihalyieb076692014-08-22 17:33:31 +0200575 if (!IsDebuggerActive()) {
576 return false;
577 }
578 return IsForcedInterpreterNeededForResolutionImpl(thread, m);
579 }
580
581 // Indicates whether we need to force the use of instrumentation entrypoint when calling
582 // a method through the resolution trampoline. This allows to deoptimize the stack for
583 // debugging when we returned from the called method.
Mathieu Chartiere401d142015-04-22 13:56:20 -0700584 static bool IsForcedInstrumentationNeededForResolution(Thread* thread, ArtMethod* m)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700585 REQUIRES_SHARED(Locks::mutator_lock_) {
Daniel Mihalyieb076692014-08-22 17:33:31 +0200586 if (!IsDebuggerActive()) {
587 return false;
588 }
589 return IsForcedInstrumentationNeededForResolutionImpl(thread, m);
590 }
591
592 // Indicates whether we need to force the use of interpreter when returning from the
593 // interpreter into the runtime. This allows to deoptimize the stack and continue
594 // execution with interpreter for debugging.
Mathieu Chartiere401d142015-04-22 13:56:20 -0700595 static bool IsForcedInterpreterNeededForUpcall(Thread* thread, ArtMethod* m)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700596 REQUIRES_SHARED(Locks::mutator_lock_) {
Mingyao Yang99170c62015-07-06 11:10:37 -0700597 if (!IsDebuggerActive() && !thread->HasDebuggerShadowFrames()) {
Daniel Mihalyieb076692014-08-22 17:33:31 +0200598 return false;
599 }
600 return IsForcedInterpreterNeededForUpcallImpl(thread, m);
601 }
602
Sebastien Hertz520633b2015-09-08 17:03:36 +0200603 // Indicates whether we need to force the use of interpreter when handling an
604 // exception. This allows to deoptimize the stack and continue execution with
605 // the interpreter.
606 // Note: the interpreter will start by handling the exception when executing
607 // the deoptimized frames.
608 static bool IsForcedInterpreterNeededForException(Thread* thread)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700609 REQUIRES_SHARED(Locks::mutator_lock_) {
Mingyao Yang99170c62015-07-06 11:10:37 -0700610 if (!IsDebuggerActive() && !thread->HasDebuggerShadowFrames()) {
Sebastien Hertz520633b2015-09-08 17:03:36 +0200611 return false;
612 }
613 return IsForcedInterpreterNeededForExceptionImpl(thread);
614 }
615
Sebastien Hertz138dbfc2013-12-04 18:15:25 +0100616 // Single-stepping.
Elliott Hughes88d63092013-01-09 09:55:54 -0800617 static JDWP::JdwpError ConfigureStep(JDWP::ObjectId thread_id, JDWP::JdwpStepSize size,
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700618 JDWP::JdwpStepDepth depth)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700619 REQUIRES_SHARED(Locks::mutator_lock_);
Sebastien Hertz61b7f1b2013-11-15 15:59:30 +0100620 static void UnconfigureStep(JDWP::ObjectId thread_id)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700621 REQUIRES(!Locks::thread_list_lock_) REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700622
Sebastien Hertzcbc50642015-06-01 17:33:12 +0200623 /*
624 * Invoke support
625 */
626
627 // Called by the JDWP thread to prepare invocation in the event thread (suspended on an event).
628 // If the information sent by the debugger is incorrect, it will send a reply with the
629 // appropriate error code. Otherwise, it will attach a DebugInvokeReq object to the event thread
630 // and resume it (and possibly other threads depending on the invoke options).
631 // Unlike other commands, the JDWP thread will not send the reply to the debugger (see
632 // JdwpState::ProcessRequest). The reply will be sent by the event thread itself after method
633 // invocation completes (see FinishInvokeMethod). This is required to allow the JDWP thread to
634 // process incoming commands from the debugger while the invocation is still in progress in the
635 // event thread, especially if it gets suspended by a debug event occurring in another thread.
636 static JDWP::JdwpError PrepareInvokeMethod(uint32_t request_id, JDWP::ObjectId thread_id,
637 JDWP::ObjectId object_id, JDWP::RefTypeId class_id,
638 JDWP::MethodId method_id, uint32_t arg_count,
639 uint64_t arg_values[], JDWP::JdwpTag* arg_types,
640 uint32_t options)
Mathieu Chartier90443472015-07-16 20:32:27 -0700641 REQUIRES(!Locks::thread_list_lock_, !Locks::thread_suspend_count_lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700642 REQUIRES_SHARED(Locks::mutator_lock_);
Sebastien Hertzcbc50642015-06-01 17:33:12 +0200643
644 // Called by the event thread to execute a method prepared by the JDWP thread in the given
645 // DebugInvokeReq object. Once the invocation completes, the event thread attaches a reply
646 // to that DebugInvokeReq object so it can be sent to the debugger only when the event thread
647 // is ready to suspend (see FinishInvokeMethod).
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700648 static void ExecuteMethod(DebugInvokeReq* pReq);
649
Sebastien Hertzcbc50642015-06-01 17:33:12 +0200650 // Called by the event thread to send the reply of the invoke (created in ExecuteMethod)
651 // before suspending itself. This is to ensure the thread is ready to suspend before the
652 // debugger receives the reply.
653 static void FinishInvokeMethod(DebugInvokeReq* pReq);
654
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700655 /*
656 * DDM support.
657 */
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700658 static void DdmSendThreadNotification(Thread* t, uint32_t type)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700659 REQUIRES_SHARED(Locks::mutator_lock_);
Sebastien Hertz52d131d2014-03-13 16:17:40 +0100660 static void DdmSetThreadNotification(bool enable)
Mathieu Chartier90443472015-07-16 20:32:27 -0700661 REQUIRES(!Locks::thread_list_lock_);
Alex Light8c2b9292017-11-09 13:21:01 -0800662 static bool DdmHandleChunk(
663 JNIEnv* env,
664 uint32_t type,
665 const ArrayRef<const jbyte>& data,
666 /*out*/uint32_t* out_type,
667 /*out*/std::vector<uint8_t>* out_data);
Ian Rogersc0542af2014-09-03 16:16:56 -0700668 static bool DdmHandlePacket(JDWP::Request* request, uint8_t** pReplyBuf, int* pReplyLen);
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700669 static void DdmConnected() REQUIRES_SHARED(Locks::mutator_lock_);
670 static void DdmDisconnected() REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes767a1472011-10-26 18:49:02 -0700671
Mathieu Chartiera6b1ead2015-10-06 10:32:38 -0700672 // Visit breakpoint roots, used to prevent unloading of methods with breakpoints.
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -0700673 static void VisitRoots(RootVisitor* visitor)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700674 REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartier3b05e9b2014-03-25 09:29:43 -0700675
Elliott Hughes545a0642011-11-08 19:10:03 -0800676 /*
Man Cao8c2ff642015-05-27 17:25:30 -0700677 * Allocation tracking support.
Elliott Hughes545a0642011-11-08 19:10:03 -0800678 */
Mathieu Chartier90443472015-07-16 20:32:27 -0700679 static void SetAllocTrackingEnabled(bool enabled) REQUIRES(!Locks::alloc_tracker_lock_);
Sebastien Hertz52d131d2014-03-13 16:17:40 +0100680 static jbyteArray GetRecentAllocations()
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700681 REQUIRES(!Locks::alloc_tracker_lock_) REQUIRES_SHARED(Locks::mutator_lock_);
Mathieu Chartier90443472015-07-16 20:32:27 -0700682 static void DumpRecentAllocations() REQUIRES(!Locks::alloc_tracker_lock_);
Elliott Hughes545a0642011-11-08 19:10:03 -0800683
Elliott Hughes767a1472011-10-26 18:49:02 -0700684 enum HpifWhen {
685 HPIF_WHEN_NEVER = 0,
686 HPIF_WHEN_NOW = 1,
687 HPIF_WHEN_NEXT_GC = 2,
688 HPIF_WHEN_EVERY_GC = 3
689 };
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700690 static int DdmHandleHpifChunk(HpifWhen when)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700691 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes767a1472011-10-26 18:49:02 -0700692
693 enum HpsgWhen {
694 HPSG_WHEN_NEVER = 0,
695 HPSG_WHEN_EVERY_GC = 1,
696 };
697 enum HpsgWhat {
698 HPSG_WHAT_MERGED_OBJECTS = 0,
699 HPSG_WHAT_DISTINCT_OBJECTS = 1,
700 };
701 static bool DdmHandleHpsgNhsgChunk(HpsgWhen when, HpsgWhat what, bool native);
702
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700703 static void DdmSendHeapInfo(HpifWhen reason)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700704 REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700705 static void DdmSendHeapSegments(bool native)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700706 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughes545a0642011-11-08 19:10:03 -0800707
Sebastien Hertz6995c602014-09-09 12:10:13 +0200708 static ObjectRegistry* GetObjectRegistry() {
709 return gRegistry;
710 }
711
712 static JDWP::JdwpTag TagFromObject(const ScopedObjectAccessUnchecked& soa, mirror::Object* o)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700713 REQUIRES_SHARED(Locks::mutator_lock_);
Sebastien Hertz6995c602014-09-09 12:10:13 +0200714
Mathieu Chartier3398c782016-09-30 10:27:43 -0700715 static JDWP::JdwpTypeTag GetTypeTag(ObjPtr<mirror::Class> klass)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700716 REQUIRES_SHARED(Locks::mutator_lock_);
Sebastien Hertz6995c602014-09-09 12:10:13 +0200717
Mathieu Chartierc7853442015-03-27 14:35:38 -0700718 static JDWP::FieldId ToFieldId(const ArtField* f)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700719 REQUIRES_SHARED(Locks::mutator_lock_);
Sebastien Hertz6995c602014-09-09 12:10:13 +0200720
Mathieu Chartiere401d142015-04-22 13:56:20 -0700721 static void SetJdwpLocation(JDWP::JdwpLocation* location, ArtMethod* m, uint32_t dex_pc)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700722 REQUIRES_SHARED(Locks::mutator_lock_)
Mathieu Chartier90443472015-07-16 20:32:27 -0700723 REQUIRES(!Locks::thread_list_lock_, !Locks::thread_suspend_count_lock_);
Sebastien Hertz6995c602014-09-09 12:10:13 +0200724
Mathieu Chartierad466ad2015-01-08 16:28:08 -0800725 static JDWP::JdwpState* GetJdwpState();
726
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700727 static uint32_t GetInstrumentationEvents() REQUIRES_SHARED(Locks::mutator_lock_) {
Sebastien Hertz9d6bf692015-04-10 12:12:33 +0200728 return instrumentation_events_;
729 }
730
Andreas Gampe04bbb5b2017-01-19 17:49:03 +0000731 static ThreadLifecycleCallback* GetThreadLifecycleCallback() {
732 return &thread_lifecycle_callback_;
733 }
Andreas Gampe0f01b582017-01-18 15:22:37 -0800734 static ClassLoadCallback* GetClassLoadCallback() {
735 return &class_load_callback_;
736 }
Andreas Gampe04bbb5b2017-01-19 17:49:03 +0000737
Elliott Hughes545a0642011-11-08 19:10:03 -0800738 private:
Sebastien Hertzcbc50642015-06-01 17:33:12 +0200739 static void ExecuteMethodWithoutPendingException(ScopedObjectAccess& soa, DebugInvokeReq* pReq)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700740 REQUIRES_SHARED(Locks::mutator_lock_);
Sebastien Hertzcbc50642015-06-01 17:33:12 +0200741
742 static void BuildInvokeReply(JDWP::ExpandBuf* pReply, uint32_t request_id,
743 JDWP::JdwpTag result_tag, uint64_t result_value,
744 JDWP::ObjectId exception)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700745 REQUIRES_SHARED(Locks::mutator_lock_);
Sebastien Hertzcbc50642015-06-01 17:33:12 +0200746
Sebastien Hertz8009f392014-09-01 17:07:11 +0200747 static JDWP::JdwpError GetLocalValue(const StackVisitor& visitor,
748 ScopedObjectAccessUnchecked& soa, int slot,
749 JDWP::JdwpTag tag, uint8_t* buf, size_t width)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700750 REQUIRES(!Locks::thread_list_lock_) REQUIRES_SHARED(Locks::mutator_lock_);
Mingyao Yang99170c62015-07-06 11:10:37 -0700751 static JDWP::JdwpError SetLocalValue(Thread* thread, StackVisitor& visitor, int slot,
752 JDWP::JdwpTag tag, uint64_t value, size_t width)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700753 REQUIRES(!Locks::thread_list_lock_) REQUIRES_SHARED(Locks::mutator_lock_);
Sebastien Hertz8009f392014-09-01 17:07:11 +0200754
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700755 static void DdmBroadcast(bool connect) REQUIRES_SHARED(Locks::mutator_lock_);
Andreas Gampe04bbb5b2017-01-19 17:49:03 +0000756
757 static void PostThreadStart(Thread* t)
758 REQUIRES_SHARED(Locks::mutator_lock_);
759 static void PostThreadDeath(Thread* t)
760 REQUIRES_SHARED(Locks::mutator_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700761 static void PostThreadStartOrStop(Thread*, uint32_t)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700762 REQUIRES_SHARED(Locks::mutator_lock_);
Elliott Hughesa2155262011-11-16 16:26:58 -0800763
Andreas Gampe0f01b582017-01-18 15:22:37 -0800764 static void PostClassPrepare(mirror::Class* c)
765 REQUIRES_SHARED(Locks::mutator_lock_);
766
Mathieu Chartiere401d142015-04-22 13:56:20 -0700767 static void PostLocationEvent(ArtMethod* method, int pcOffset,
Sebastien Hertz8379b222014-02-24 17:38:15 +0100768 mirror::Object* thisPtr, int eventFlags,
769 const JValue* return_value)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700770 REQUIRES_SHARED(Locks::mutator_lock_);
Sebastien Hertz8379b222014-02-24 17:38:15 +0100771
Sebastien Hertz4d25df32014-03-21 17:44:46 +0100772 static void ProcessDeoptimizationRequest(const DeoptimizationRequest& request)
Mathieu Chartieraa516822015-10-02 15:53:37 -0700773 REQUIRES(Locks::mutator_lock_, Roles::uninterruptible_);
Sebastien Hertz4d25df32014-03-21 17:44:46 +0100774
Sebastien Hertz7ec2f1c2014-03-27 20:06:47 +0100775 static void RequestDeoptimizationLocked(const DeoptimizationRequest& req)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700776 REQUIRES(Locks::deoptimization_lock_) REQUIRES_SHARED(Locks::mutator_lock_);
Sebastien Hertz7ec2f1c2014-03-27 20:06:47 +0100777
Mathieu Chartiere401d142015-04-22 13:56:20 -0700778 static bool IsForcedInterpreterNeededForCallingImpl(Thread* thread, ArtMethod* m)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700779 REQUIRES_SHARED(Locks::mutator_lock_);
Daniel Mihalyieb076692014-08-22 17:33:31 +0200780
Mathieu Chartiere401d142015-04-22 13:56:20 -0700781 static bool IsForcedInterpreterNeededForResolutionImpl(Thread* thread, ArtMethod* m)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700782 REQUIRES_SHARED(Locks::mutator_lock_);
Daniel Mihalyieb076692014-08-22 17:33:31 +0200783
Mathieu Chartiere401d142015-04-22 13:56:20 -0700784 static bool IsForcedInstrumentationNeededForResolutionImpl(Thread* thread, ArtMethod* m)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700785 REQUIRES_SHARED(Locks::mutator_lock_);
Daniel Mihalyieb076692014-08-22 17:33:31 +0200786
Mathieu Chartiere401d142015-04-22 13:56:20 -0700787 static bool IsForcedInterpreterNeededForUpcallImpl(Thread* thread, ArtMethod* m)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700788 REQUIRES_SHARED(Locks::mutator_lock_);
Daniel Mihalyieb076692014-08-22 17:33:31 +0200789
Sebastien Hertz520633b2015-09-08 17:03:36 +0200790 static bool IsForcedInterpreterNeededForExceptionImpl(Thread* thread)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700791 REQUIRES_SHARED(Locks::mutator_lock_);
Sebastien Hertz520633b2015-09-08 17:03:36 +0200792
Daniel Mihalyieb076692014-08-22 17:33:31 +0200793 // Indicates whether the debugger is making requests.
794 static bool gDebuggerActive;
795
Alex Light21611932017-09-26 13:07:39 -0700796 static DebuggerActiveMethodInspectionCallback gDebugActiveCallback;
Alex Light8c2b9292017-11-09 13:21:01 -0800797 static DebuggerDdmCallback gDebugDdmCallback;
Alex Light40320712017-12-14 11:52:04 -0800798 static InternalDebuggerControlCallback gDebuggerControlCallback;
Alex Light21611932017-09-26 13:07:39 -0700799
Sebastien Hertz4e5b2082015-03-24 19:03:40 +0100800 // Indicates whether we should drop the JDWP connection because the runtime stops or the
801 // debugger called VirtualMachine.Dispose.
802 static bool gDisposed;
803
Daniel Mihalyieb076692014-08-22 17:33:31 +0200804 // The registry mapping objects to JDWP ids.
Sebastien Hertz6995c602014-09-09 12:10:13 +0200805 static ObjectRegistry* gRegistry;
806
Sebastien Hertz4d25df32014-03-21 17:44:46 +0100807 // Deoptimization requests to be processed each time the event list is updated. This is used when
808 // registering and unregistering events so we do not deoptimize while holding the event list
809 // lock.
Sebastien Hertz42cd43f2014-05-13 14:15:41 +0200810 // TODO rename to instrumentation_requests.
Brian Carlstrom306db812014-09-05 13:01:41 -0700811 static std::vector<DeoptimizationRequest> deoptimization_requests_ GUARDED_BY(Locks::deoptimization_lock_);
Sebastien Hertz4d25df32014-03-21 17:44:46 +0100812
813 // Count the number of events requiring full deoptimization. When the counter is > 0, everything
814 // is deoptimized, otherwise everything is undeoptimized.
815 // Note: we fully deoptimize on the first event only (when the counter is set to 1). We fully
816 // undeoptimize when the last event is unregistered (when the counter is set to 0).
Brian Carlstrom306db812014-09-05 13:01:41 -0700817 static size_t full_deoptimization_event_count_ GUARDED_BY(Locks::deoptimization_lock_);
Sebastien Hertz4d25df32014-03-21 17:44:46 +0100818
Sebastien Hertz42cd43f2014-05-13 14:15:41 +0200819 static size_t* GetReferenceCounterForEvent(uint32_t instrumentation_event);
820
821 // Instrumentation event reference counters.
822 // TODO we could use an array instead of having all these dedicated counters. Instrumentation
823 // events are bits of a mask so we could convert them to array index.
Brian Carlstrom306db812014-09-05 13:01:41 -0700824 static size_t dex_pc_change_event_ref_count_ GUARDED_BY(Locks::deoptimization_lock_);
825 static size_t method_enter_event_ref_count_ GUARDED_BY(Locks::deoptimization_lock_);
826 static size_t method_exit_event_ref_count_ GUARDED_BY(Locks::deoptimization_lock_);
827 static size_t field_read_event_ref_count_ GUARDED_BY(Locks::deoptimization_lock_);
828 static size_t field_write_event_ref_count_ GUARDED_BY(Locks::deoptimization_lock_);
829 static size_t exception_catch_event_ref_count_ GUARDED_BY(Locks::deoptimization_lock_);
Sebastien Hertz42cd43f2014-05-13 14:15:41 +0200830 static uint32_t instrumentation_events_ GUARDED_BY(Locks::mutator_lock_);
831
Andreas Gampe04bbb5b2017-01-19 17:49:03 +0000832 class DbgThreadLifecycleCallback : public ThreadLifecycleCallback {
833 public:
Roland Levillainbbc6e7e2018-08-24 16:58:47 +0100834 void ThreadStart(Thread* self) override REQUIRES_SHARED(Locks::mutator_lock_);
835 void ThreadDeath(Thread* self) override REQUIRES_SHARED(Locks::mutator_lock_);
Andreas Gampe04bbb5b2017-01-19 17:49:03 +0000836 };
837
Andreas Gampe0f01b582017-01-18 15:22:37 -0800838 class DbgClassLoadCallback : public ClassLoadCallback {
839 public:
Roland Levillainbbc6e7e2018-08-24 16:58:47 +0100840 void ClassLoad(Handle<mirror::Class> klass) override REQUIRES_SHARED(Locks::mutator_lock_);
Andreas Gampe0f01b582017-01-18 15:22:37 -0800841 void ClassPrepare(Handle<mirror::Class> temp_klass,
Roland Levillainbbc6e7e2018-08-24 16:58:47 +0100842 Handle<mirror::Class> klass) override REQUIRES_SHARED(Locks::mutator_lock_);
Andreas Gampe0f01b582017-01-18 15:22:37 -0800843 };
844
Andreas Gampe04bbb5b2017-01-19 17:49:03 +0000845 static DbgThreadLifecycleCallback thread_lifecycle_callback_;
Andreas Gampe0f01b582017-01-18 15:22:37 -0800846 static DbgClassLoadCallback class_load_callback_;
Andreas Gampe04bbb5b2017-01-19 17:49:03 +0000847
Ian Rogers719d1a32014-03-06 12:13:39 -0800848 DISALLOW_COPY_AND_ASSIGN(Dbg);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700849};
850
851#define CHUNK_TYPE(_name) \
Elliott Hughes82188472011-11-07 18:11:48 -0800852 static_cast<uint32_t>((_name)[0] << 24 | (_name)[1] << 16 | (_name)[2] << 8 | (_name)[3])
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700853
854} // namespace art
855
Brian Carlstromfc0e3212013-07-17 14:40:12 -0700856#endif // ART_RUNTIME_DEBUGGER_H_