blob: df4413d52ca85ba124bb92c5637c55b17a8b33b8 [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#include "debugger.h"
18
Elliott Hughes3bb81562011-10-21 18:52:59 -070019#include <sys/uio.h>
20
Elliott Hughes545a0642011-11-08 19:10:03 -080021#include <set>
22
Andreas Gampe46ee31b2016-12-14 10:11:49 -080023#include "android-base/stringprintf.h"
24
Ian Rogers166db042013-07-26 12:05:57 -070025#include "arch/context.h"
Mathieu Chartierc7853442015-03-27 14:35:38 -070026#include "art_field-inl.h"
Mathieu Chartiere401d142015-04-22 13:56:20 -070027#include "art_method-inl.h"
Andreas Gampe542451c2016-07-26 09:02:02 -070028#include "base/enums.h"
Vladimir Marko80afd022015-05-19 18:08:00 +010029#include "base/time_utils.h"
Elliott Hughes545a0642011-11-08 19:10:03 -080030#include "class_linker.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080031#include "class_linker-inl.h"
Ian Rogers4f6ad8a2013-03-18 15:27:28 -070032#include "dex_file-inl.h"
David Sehr9323e6e2016-09-13 08:58:35 -070033#include "dex_file_annotations.h"
Ian Rogers776ac1f2012-04-13 23:36:36 -070034#include "dex_instruction.h"
Mingyao Yang6ea1a0e2016-01-29 12:12:49 -080035#include "entrypoints/runtime_asm_entrypoints.h"
Ian Rogers1d54e732013-05-02 21:10:01 -070036#include "gc/accounting/card_table-inl.h"
Man Cao8c2ff642015-05-27 17:25:30 -070037#include "gc/allocation_record.h"
Mathieu Chartieraa516822015-10-02 15:53:37 -070038#include "gc/scoped_gc_critical_section.h"
Ian Rogers1d54e732013-05-02 21:10:01 -070039#include "gc/space/large_object_space.h"
40#include "gc/space/space-inl.h"
Mathieu Chartiereb8167a2014-05-07 15:43:14 -070041#include "handle_scope.h"
Sebastien Hertzcbc50642015-06-01 17:33:12 +020042#include "jdwp/jdwp_priv.h"
Elliott Hughes64f574f2013-02-20 14:57:12 -080043#include "jdwp/object_registry.h"
Andreas Gampe13b27842016-11-07 16:48:23 -080044#include "jni_internal.h"
Mathieu Chartier28bd2e42016-10-04 13:54:57 -070045#include "jvalue-inl.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080046#include "mirror/class.h"
47#include "mirror/class-inl.h"
48#include "mirror/class_loader.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080049#include "mirror/object-inl.h"
50#include "mirror/object_array-inl.h"
Ian Rogersb0fa5dc2014-04-28 16:47:08 -070051#include "mirror/string-inl.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080052#include "mirror/throwable.h"
Mathieu Chartier3398c782016-09-30 10:27:43 -070053#include "obj_ptr-inl.h"
Ian Rogers53b8b092014-03-13 23:45:53 -070054#include "reflection.h"
Elliott Hughesa0e18062012-04-13 15:59:59 -070055#include "safe_map.h"
Mathieu Chartier0795f232016-09-27 18:43:30 -070056#include "scoped_thread_state_change-inl.h"
Elliott Hughes6a5bd492011-10-28 14:33:57 -070057#include "ScopedLocalRef.h"
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -070058#include "ScopedPrimitiveArray.h"
Mathieu Chartiereb8167a2014-05-07 15:43:14 -070059#include "handle_scope-inl.h"
Elliott Hughes475fc232011-10-25 15:00:35 -070060#include "thread_list.h"
Ian Rogers2dd0e2c2013-01-24 12:42:14 -080061#include "utf.h"
Elliott Hugheseac76672012-05-24 21:56:51 -070062#include "well_known_classes.h"
Elliott Hughes475fc232011-10-25 15:00:35 -070063
Elliott Hughes872d4ec2011-10-21 17:07:15 -070064namespace art {
65
Andreas Gampe46ee31b2016-12-14 10:11:49 -080066using android::base::StringPrintf;
67
Sebastien Hertz0462c4c2015-04-01 16:34:17 +020068// The key identifying the debugger to update instrumentation.
69static constexpr const char* kDbgInstrumentationKey = "Debugger";
70
Man Cao8c2ff642015-05-27 17:25:30 -070071// Limit alloc_record_count to the 2BE value (64k-1) that is the limit of the current protocol.
Brian Carlstrom306db812014-09-05 13:01:41 -070072static uint16_t CappedAllocRecordCount(size_t alloc_record_count) {
Man Cao1ed11b92015-06-11 22:47:35 -070073 const size_t cap = 0xffff;
Man Cao8c2ff642015-05-27 17:25:30 -070074 if (alloc_record_count > cap) {
75 return cap;
Brian Carlstrom306db812014-09-05 13:01:41 -070076 }
77 return alloc_record_count;
78}
Elliott Hughes475fc232011-10-25 15:00:35 -070079
Alex Light6c8467f2015-11-20 15:03:26 -080080// Takes a method and returns a 'canonical' one if the method is default (and therefore potentially
81// copied from some other class). This ensures that the debugger does not get confused as to which
82// method we are in.
83static ArtMethod* GetCanonicalMethod(ArtMethod* m)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -070084 REQUIRES_SHARED(Locks::mutator_lock_) {
Alex Light6c8467f2015-11-20 15:03:26 -080085 if (LIKELY(!m->IsDefault())) {
86 return m;
87 } else {
88 mirror::Class* declaring_class = m->GetDeclaringClass();
89 return declaring_class->FindDeclaredVirtualMethod(declaring_class->GetDexCache(),
90 m->GetDexMethodIndex(),
Andreas Gampe542451c2016-07-26 09:02:02 -070091 kRuntimePointerSize);
Alex Light6c8467f2015-11-20 15:03:26 -080092 }
93}
94
Mathieu Chartier41af5e52015-10-28 11:10:46 -070095class Breakpoint : public ValueObject {
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -070096 public:
Mathieu Chartier41af5e52015-10-28 11:10:46 -070097 Breakpoint(ArtMethod* method, uint32_t dex_pc, DeoptimizationRequest::Kind deoptimization_kind)
Alex Light6c8467f2015-11-20 15:03:26 -080098 : method_(GetCanonicalMethod(method)),
Mathieu Chartier41af5e52015-10-28 11:10:46 -070099 dex_pc_(dex_pc),
100 deoptimization_kind_(deoptimization_kind) {
Sebastien Hertzf3928792014-11-17 19:00:37 +0100101 CHECK(deoptimization_kind_ == DeoptimizationRequest::kNothing ||
102 deoptimization_kind_ == DeoptimizationRequest::kSelectiveDeoptimization ||
103 deoptimization_kind_ == DeoptimizationRequest::kFullDeoptimization);
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -0700104 }
105
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700106 Breakpoint(const Breakpoint& other) REQUIRES_SHARED(Locks::mutator_lock_)
Mathieu Chartier41af5e52015-10-28 11:10:46 -0700107 : method_(other.method_),
108 dex_pc_(other.dex_pc_),
109 deoptimization_kind_(other.deoptimization_kind_) {}
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -0700110
Mathieu Chartier41af5e52015-10-28 11:10:46 -0700111 // Method() is called from root visiting, do not use ScopedObjectAccess here or it can cause
112 // GC to deadlock if another thread tries to call SuspendAll while the GC is in a runnable state.
113 ArtMethod* Method() const {
114 return method_;
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -0700115 }
116
117 uint32_t DexPc() const {
118 return dex_pc_;
119 }
120
Sebastien Hertzf3928792014-11-17 19:00:37 +0100121 DeoptimizationRequest::Kind GetDeoptimizationKind() const {
122 return deoptimization_kind_;
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -0700123 }
124
Alex Light6c8467f2015-11-20 15:03:26 -0800125 // Returns true if the method of this breakpoint and the passed in method should be considered the
126 // same. That is, they are either the same method or they are copied from the same method.
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700127 bool IsInMethod(ArtMethod* m) const REQUIRES_SHARED(Locks::mutator_lock_) {
Alex Light6c8467f2015-11-20 15:03:26 -0800128 return method_ == GetCanonicalMethod(m);
129 }
130
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -0700131 private:
Sebastien Hertza76a6d42014-03-20 16:40:17 +0100132 // The location of this breakpoint.
Mathieu Chartier41af5e52015-10-28 11:10:46 -0700133 ArtMethod* method_;
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -0700134 uint32_t dex_pc_;
Sebastien Hertza76a6d42014-03-20 16:40:17 +0100135
136 // Indicates whether breakpoint needs full deoptimization or selective deoptimization.
Sebastien Hertzf3928792014-11-17 19:00:37 +0100137 DeoptimizationRequest::Kind deoptimization_kind_;
Elliott Hughes86964332012-02-15 19:37:42 -0800138};
139
Sebastien Hertzed2be172014-08-19 15:33:43 +0200140static std::ostream& operator<<(std::ostream& os, const Breakpoint& rhs)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700141 REQUIRES_SHARED(Locks::mutator_lock_) {
David Sehr709b0702016-10-13 09:12:37 -0700142 os << StringPrintf("Breakpoint[%s @%#x]", ArtMethod::PrettyMethod(rhs.Method()).c_str(),
143 rhs.DexPc());
Elliott Hughes86964332012-02-15 19:37:42 -0800144 return os;
145}
146
Sebastien Hertz3f52eaf2014-04-04 17:50:18 +0200147class DebugInstrumentationListener FINAL : public instrumentation::InstrumentationListener {
Ian Rogers62d6c772013-02-27 08:32:07 -0800148 public:
149 DebugInstrumentationListener() {}
150 virtual ~DebugInstrumentationListener() {}
151
Mathieu Chartiere401d142015-04-22 13:56:20 -0700152 void MethodEntered(Thread* thread, mirror::Object* this_object, ArtMethod* method,
Sebastien Hertz9d6bf692015-04-10 12:12:33 +0200153 uint32_t dex_pc)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700154 OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) {
Ian Rogers62d6c772013-02-27 08:32:07 -0800155 if (method->IsNative()) {
156 // TODO: post location events is a suspension point and native method entry stubs aren't.
157 return;
158 }
Sebastien Hertz9d6bf692015-04-10 12:12:33 +0200159 if (IsListeningToDexPcMoved()) {
160 // We also listen to kDexPcMoved instrumentation event so we know the DexPcMoved method is
161 // going to be called right after us. To avoid sending JDWP events twice for this location,
162 // we report the event in DexPcMoved. However, we must remind this is method entry so we
163 // send the METHOD_ENTRY event. And we can also group it with other events for this location
164 // like BREAKPOINT or SINGLE_STEP (or even METHOD_EXIT if this is a RETURN instruction).
165 thread->SetDebugMethodEntry();
166 } else if (IsListeningToMethodExit() && IsReturn(method, dex_pc)) {
167 // We also listen to kMethodExited instrumentation event and the current instruction is a
168 // RETURN so we know the MethodExited method is going to be called right after us. To avoid
169 // sending JDWP events twice for this location, we report the event(s) in MethodExited.
170 // However, we must remind this is method entry so we send the METHOD_ENTRY event. And we can
171 // also group it with other events for this location like BREAKPOINT or SINGLE_STEP.
172 thread->SetDebugMethodEntry();
173 } else {
174 Dbg::UpdateDebugger(thread, this_object, method, 0, Dbg::kMethodEntry, nullptr);
175 }
Ian Rogers62d6c772013-02-27 08:32:07 -0800176 }
177
Mathieu Chartiere401d142015-04-22 13:56:20 -0700178 void MethodExited(Thread* thread, mirror::Object* this_object, ArtMethod* method,
Sebastien Hertz3f52eaf2014-04-04 17:50:18 +0200179 uint32_t dex_pc, const JValue& return_value)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700180 OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) {
Ian Rogers62d6c772013-02-27 08:32:07 -0800181 if (method->IsNative()) {
182 // TODO: post location events is a suspension point and native method entry stubs aren't.
183 return;
184 }
Sebastien Hertz9d6bf692015-04-10 12:12:33 +0200185 uint32_t events = Dbg::kMethodExit;
186 if (thread->IsDebugMethodEntry()) {
187 // It is also the method entry.
188 DCHECK(IsReturn(method, dex_pc));
189 events |= Dbg::kMethodEntry;
190 thread->ClearDebugMethodEntry();
191 }
192 Dbg::UpdateDebugger(thread, this_object, method, dex_pc, events, &return_value);
Ian Rogers62d6c772013-02-27 08:32:07 -0800193 }
194
Sebastien Hertz9d6bf692015-04-10 12:12:33 +0200195 void MethodUnwind(Thread* thread ATTRIBUTE_UNUSED, mirror::Object* this_object ATTRIBUTE_UNUSED,
Mathieu Chartiere401d142015-04-22 13:56:20 -0700196 ArtMethod* method, uint32_t dex_pc)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700197 OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) {
Ian Rogers62d6c772013-02-27 08:32:07 -0800198 // We're not recorded to listen to this kind of event, so complain.
David Sehr709b0702016-10-13 09:12:37 -0700199 LOG(ERROR) << "Unexpected method unwind event in debugger " << ArtMethod::PrettyMethod(method)
Sebastien Hertz51db44a2013-11-19 10:00:29 +0100200 << " " << dex_pc;
Ian Rogers62d6c772013-02-27 08:32:07 -0800201 }
202
Mathieu Chartiere401d142015-04-22 13:56:20 -0700203 void DexPcMoved(Thread* thread, mirror::Object* this_object, ArtMethod* method,
Sebastien Hertz3f52eaf2014-04-04 17:50:18 +0200204 uint32_t new_dex_pc)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700205 OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) {
Sebastien Hertz9d6bf692015-04-10 12:12:33 +0200206 if (IsListeningToMethodExit() && IsReturn(method, new_dex_pc)) {
207 // We also listen to kMethodExited instrumentation event and the current instruction is a
208 // RETURN so we know the MethodExited method is going to be called right after us. Like in
209 // MethodEntered, we delegate event reporting to MethodExited.
210 // Besides, if this RETURN instruction is the only one in the method, we can send multiple
211 // JDWP events in the same packet: METHOD_ENTRY, METHOD_EXIT, BREAKPOINT and/or SINGLE_STEP.
212 // Therefore, we must not clear the debug method entry flag here.
213 } else {
214 uint32_t events = 0;
215 if (thread->IsDebugMethodEntry()) {
216 // It is also the method entry.
217 events = Dbg::kMethodEntry;
218 thread->ClearDebugMethodEntry();
219 }
220 Dbg::UpdateDebugger(thread, this_object, method, new_dex_pc, events, nullptr);
221 }
Ian Rogers62d6c772013-02-27 08:32:07 -0800222 }
223
Sebastien Hertz9d6bf692015-04-10 12:12:33 +0200224 void FieldRead(Thread* thread ATTRIBUTE_UNUSED, mirror::Object* this_object,
Mathieu Chartiere401d142015-04-22 13:56:20 -0700225 ArtMethod* method, uint32_t dex_pc, ArtField* field)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700226 OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) {
Sebastien Hertz3f52eaf2014-04-04 17:50:18 +0200227 Dbg::PostFieldAccessEvent(method, dex_pc, this_object, field);
Ian Rogers62d6c772013-02-27 08:32:07 -0800228 }
Sebastien Hertz3f52eaf2014-04-04 17:50:18 +0200229
Ian Rogers6a3c1fc2014-10-31 00:33:20 -0700230 void FieldWritten(Thread* thread ATTRIBUTE_UNUSED, mirror::Object* this_object,
Mathieu Chartiere401d142015-04-22 13:56:20 -0700231 ArtMethod* method, uint32_t dex_pc, ArtField* field,
Ian Rogers6a3c1fc2014-10-31 00:33:20 -0700232 const JValue& field_value)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700233 OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) {
Sebastien Hertz3f52eaf2014-04-04 17:50:18 +0200234 Dbg::PostFieldModificationEvent(method, dex_pc, this_object, field, &field_value);
235 }
236
Nicolas Geoffray14691c52015-03-05 10:40:17 +0000237 void ExceptionCaught(Thread* thread ATTRIBUTE_UNUSED, mirror::Throwable* exception_object)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700238 OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) {
Nicolas Geoffray14691c52015-03-05 10:40:17 +0000239 Dbg::PostException(exception_object);
Sebastien Hertz3f52eaf2014-04-04 17:50:18 +0200240 }
241
Nicolas Geoffray81f0f952016-01-20 16:25:19 +0000242 // We only care about branches in the Jit.
243 void Branch(Thread* /*thread*/, ArtMethod* method, uint32_t dex_pc, int32_t dex_pc_offset)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700244 OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) {
David Sehr709b0702016-10-13 09:12:37 -0700245 LOG(ERROR) << "Unexpected branch event in debugger " << ArtMethod::PrettyMethod(method)
Nicolas Geoffray81f0f952016-01-20 16:25:19 +0000246 << " " << dex_pc << ", " << dex_pc_offset;
Mathieu Chartiere5f13e52015-02-24 09:37:21 -0800247 }
248
Nicolas Geoffray5550ca82015-08-21 18:38:30 +0100249 // We only care about invokes in the Jit.
250 void InvokeVirtualOrInterface(Thread* thread ATTRIBUTE_UNUSED,
251 mirror::Object*,
252 ArtMethod* method,
253 uint32_t dex_pc,
254 ArtMethod*)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700255 OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) {
David Sehr709b0702016-10-13 09:12:37 -0700256 LOG(ERROR) << "Unexpected invoke event in debugger " << ArtMethod::PrettyMethod(method)
Nicolas Geoffray5550ca82015-08-21 18:38:30 +0100257 << " " << dex_pc;
258 }
259
Sebastien Hertz3f52eaf2014-04-04 17:50:18 +0200260 private:
Mathieu Chartiere401d142015-04-22 13:56:20 -0700261 static bool IsReturn(ArtMethod* method, uint32_t dex_pc)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700262 REQUIRES_SHARED(Locks::mutator_lock_) {
Sebastien Hertz9d6bf692015-04-10 12:12:33 +0200263 const DexFile::CodeItem* code_item = method->GetCodeItem();
264 const Instruction* instruction = Instruction::At(&code_item->insns_[dex_pc]);
265 return instruction->IsReturn();
266 }
267
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700268 static bool IsListeningToDexPcMoved() REQUIRES_SHARED(Locks::mutator_lock_) {
Sebastien Hertz9d6bf692015-04-10 12:12:33 +0200269 return IsListeningTo(instrumentation::Instrumentation::kDexPcMoved);
270 }
271
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700272 static bool IsListeningToMethodExit() REQUIRES_SHARED(Locks::mutator_lock_) {
Sebastien Hertz9d6bf692015-04-10 12:12:33 +0200273 return IsListeningTo(instrumentation::Instrumentation::kMethodExited);
274 }
275
276 static bool IsListeningTo(instrumentation::Instrumentation::InstrumentationEvent event)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700277 REQUIRES_SHARED(Locks::mutator_lock_) {
Sebastien Hertz9d6bf692015-04-10 12:12:33 +0200278 return (Dbg::GetInstrumentationEvents() & event) != 0;
279 }
280
Sebastien Hertz3f52eaf2014-04-04 17:50:18 +0200281 DISALLOW_COPY_AND_ASSIGN(DebugInstrumentationListener);
Ian Rogers62d6c772013-02-27 08:32:07 -0800282} gDebugInstrumentationListener;
283
Elliott Hughes4ffd3132011-10-24 12:06:42 -0700284// JDWP is allowed unless the Zygote forbids it.
285static bool gJdwpAllowed = true;
286
Elliott Hughesc0f09332012-03-26 13:27:06 -0700287// Was there a -Xrunjdwp or -agentlib:jdwp= argument on the command line?
Elliott Hughes3bb81562011-10-21 18:52:59 -0700288static bool gJdwpConfigured = false;
289
Sebastien Hertzb3b173b2015-02-06 09:16:32 +0100290// JDWP options for debugging. Only valid if IsJdwpConfigured() is true.
291static JDWP::JdwpOptions gJdwpOptions;
292
Elliott Hughes3bb81562011-10-21 18:52:59 -0700293// Runtime JDWP state.
Ian Rogersc0542af2014-09-03 16:16:56 -0700294static JDWP::JdwpState* gJdwpState = nullptr;
Elliott Hughes3bb81562011-10-21 18:52:59 -0700295static bool gDebuggerConnected; // debugger or DDMS is connected.
Elliott Hughes3bb81562011-10-21 18:52:59 -0700296
Elliott Hughes47fce012011-10-25 18:37:19 -0700297static bool gDdmThreadNotification = false;
298
Elliott Hughes767a1472011-10-26 18:49:02 -0700299// DDMS GC-related settings.
300static Dbg::HpifWhen gDdmHpifWhen = Dbg::HPIF_WHEN_NEVER;
301static Dbg::HpsgWhen gDdmHpsgWhen = Dbg::HPSG_WHEN_NEVER;
302static Dbg::HpsgWhat gDdmHpsgWhat;
303static Dbg::HpsgWhen gDdmNhsgWhen = Dbg::HPSG_WHEN_NEVER;
304static Dbg::HpsgWhat gDdmNhsgWhat;
305
Daniel Mihalyieb076692014-08-22 17:33:31 +0200306bool Dbg::gDebuggerActive = false;
Sebastien Hertz4e5b2082015-03-24 19:03:40 +0100307bool Dbg::gDisposed = false;
Sebastien Hertz6995c602014-09-09 12:10:13 +0200308ObjectRegistry* Dbg::gRegistry = nullptr;
Elliott Hughes475fc232011-10-25 15:00:35 -0700309
Sebastien Hertz138dbfc2013-12-04 18:15:25 +0100310// Deoptimization support.
Sebastien Hertz4d25df32014-03-21 17:44:46 +0100311std::vector<DeoptimizationRequest> Dbg::deoptimization_requests_;
312size_t Dbg::full_deoptimization_event_count_ = 0;
Sebastien Hertz138dbfc2013-12-04 18:15:25 +0100313
Sebastien Hertz42cd43f2014-05-13 14:15:41 +0200314// Instrumentation event reference counters.
315size_t Dbg::dex_pc_change_event_ref_count_ = 0;
316size_t Dbg::method_enter_event_ref_count_ = 0;
317size_t Dbg::method_exit_event_ref_count_ = 0;
318size_t Dbg::field_read_event_ref_count_ = 0;
319size_t Dbg::field_write_event_ref_count_ = 0;
320size_t Dbg::exception_catch_event_ref_count_ = 0;
321uint32_t Dbg::instrumentation_events_ = 0;
322
Sebastien Hertz138dbfc2013-12-04 18:15:25 +0100323// Breakpoints.
jeffhao09bfc6a2012-12-11 18:11:43 -0800324static std::vector<Breakpoint> gBreakpoints GUARDED_BY(Locks::breakpoint_lock_);
Elliott Hughes86964332012-02-15 19:37:42 -0800325
Mathieu Chartierbb87e0f2015-04-03 11:21:55 -0700326void DebugInvokeReq::VisitRoots(RootVisitor* visitor, const RootInfo& root_info) {
327 receiver.VisitRootIfNonNull(visitor, root_info); // null for static method call.
328 klass.VisitRoot(visitor, root_info);
Mathieu Chartier3b05e9b2014-03-25 09:29:43 -0700329}
330
Sebastien Hertz597c4f02015-01-26 17:37:14 +0100331void SingleStepControl::AddDexPc(uint32_t dex_pc) {
332 dex_pcs_.insert(dex_pc);
Sebastien Hertzbb43b432014-04-14 11:59:08 +0200333}
334
Sebastien Hertz597c4f02015-01-26 17:37:14 +0100335bool SingleStepControl::ContainsDexPc(uint32_t dex_pc) const {
336 return dex_pcs_.find(dex_pc) == dex_pcs_.end();
Sebastien Hertzbb43b432014-04-14 11:59:08 +0200337}
338
Alex Light6c8467f2015-11-20 15:03:26 -0800339static bool IsBreakpoint(ArtMethod* m, uint32_t dex_pc)
Mathieu Chartier90443472015-07-16 20:32:27 -0700340 REQUIRES(!Locks::breakpoint_lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700341 REQUIRES_SHARED(Locks::mutator_lock_) {
Sebastien Hertzed2be172014-08-19 15:33:43 +0200342 ReaderMutexLock mu(Thread::Current(), *Locks::breakpoint_lock_);
Sebastien Hertz138dbfc2013-12-04 18:15:25 +0100343 for (size_t i = 0, e = gBreakpoints.size(); i < e; ++i) {
Alex Light6c8467f2015-11-20 15:03:26 -0800344 if (gBreakpoints[i].DexPc() == dex_pc && gBreakpoints[i].IsInMethod(m)) {
Elliott Hughes86964332012-02-15 19:37:42 -0800345 VLOG(jdwp) << "Hit breakpoint #" << i << ": " << gBreakpoints[i];
346 return true;
347 }
348 }
349 return false;
350}
351
Sebastien Hertz52d131d2014-03-13 16:17:40 +0100352static bool IsSuspendedForDebugger(ScopedObjectAccessUnchecked& soa, Thread* thread)
Mathieu Chartier90443472015-07-16 20:32:27 -0700353 REQUIRES(!Locks::thread_suspend_count_lock_) {
Elliott Hughes9e0c1752013-01-09 14:02:58 -0800354 MutexLock mu(soa.Self(), *Locks::thread_suspend_count_lock_);
355 // A thread may be suspended for GC; in this code, we really want to know whether
356 // there's a debugger suspension active.
357 return thread->IsSuspended() && thread->GetDebugSuspendCount() > 0;
358}
359
Ian Rogersc0542af2014-09-03 16:16:56 -0700360static mirror::Array* DecodeNonNullArray(JDWP::RefTypeId id, JDWP::JdwpError* error)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700361 REQUIRES_SHARED(Locks::mutator_lock_) {
Sebastien Hertz6995c602014-09-09 12:10:13 +0200362 mirror::Object* o = Dbg::GetObjectRegistry()->Get<mirror::Object*>(id, error);
Ian Rogersc0542af2014-09-03 16:16:56 -0700363 if (o == nullptr) {
364 *error = JDWP::ERR_INVALID_OBJECT;
365 return nullptr;
Elliott Hughes436e3722012-02-17 20:01:47 -0800366 }
367 if (!o->IsArrayInstance()) {
Ian Rogersc0542af2014-09-03 16:16:56 -0700368 *error = JDWP::ERR_INVALID_ARRAY;
369 return nullptr;
Elliott Hughes436e3722012-02-17 20:01:47 -0800370 }
Ian Rogersc0542af2014-09-03 16:16:56 -0700371 *error = JDWP::ERR_NONE;
Elliott Hughes436e3722012-02-17 20:01:47 -0800372 return o->AsArray();
373}
374
Ian Rogersc0542af2014-09-03 16:16:56 -0700375static mirror::Class* DecodeClass(JDWP::RefTypeId id, JDWP::JdwpError* error)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700376 REQUIRES_SHARED(Locks::mutator_lock_) {
Sebastien Hertz6995c602014-09-09 12:10:13 +0200377 mirror::Object* o = Dbg::GetObjectRegistry()->Get<mirror::Object*>(id, error);
Ian Rogersc0542af2014-09-03 16:16:56 -0700378 if (o == nullptr) {
379 *error = JDWP::ERR_INVALID_OBJECT;
380 return nullptr;
Elliott Hughes436e3722012-02-17 20:01:47 -0800381 }
382 if (!o->IsClass()) {
Ian Rogersc0542af2014-09-03 16:16:56 -0700383 *error = JDWP::ERR_INVALID_CLASS;
384 return nullptr;
Elliott Hughes436e3722012-02-17 20:01:47 -0800385 }
Ian Rogersc0542af2014-09-03 16:16:56 -0700386 *error = JDWP::ERR_NONE;
Elliott Hughes436e3722012-02-17 20:01:47 -0800387 return o->AsClass();
388}
389
Ian Rogersc0542af2014-09-03 16:16:56 -0700390static Thread* DecodeThread(ScopedObjectAccessUnchecked& soa, JDWP::ObjectId thread_id,
391 JDWP::JdwpError* error)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700392 REQUIRES_SHARED(Locks::mutator_lock_)
Mathieu Chartier90443472015-07-16 20:32:27 -0700393 REQUIRES(!Locks::thread_list_lock_, !Locks::thread_suspend_count_lock_) {
Sebastien Hertz6995c602014-09-09 12:10:13 +0200394 mirror::Object* thread_peer = Dbg::GetObjectRegistry()->Get<mirror::Object*>(thread_id, error);
Ian Rogersc0542af2014-09-03 16:16:56 -0700395 if (thread_peer == nullptr) {
Elliott Hughes221229c2013-01-08 18:17:50 -0800396 // This isn't even an object.
Ian Rogersc0542af2014-09-03 16:16:56 -0700397 *error = JDWP::ERR_INVALID_OBJECT;
398 return nullptr;
Elliott Hughes436e3722012-02-17 20:01:47 -0800399 }
Elliott Hughes221229c2013-01-08 18:17:50 -0800400
Mathieu Chartier0795f232016-09-27 18:43:30 -0700401 ObjPtr<mirror::Class> java_lang_Thread =
402 soa.Decode<mirror::Class>(WellKnownClasses::java_lang_Thread);
Elliott Hughes221229c2013-01-08 18:17:50 -0800403 if (!java_lang_Thread->IsAssignableFrom(thread_peer->GetClass())) {
404 // This isn't a thread.
Ian Rogersc0542af2014-09-03 16:16:56 -0700405 *error = JDWP::ERR_INVALID_THREAD;
406 return nullptr;
Elliott Hughes221229c2013-01-08 18:17:50 -0800407 }
408
Sebastien Hertz69206392015-04-07 15:54:25 +0200409 MutexLock mu(soa.Self(), *Locks::thread_list_lock_);
Ian Rogersc0542af2014-09-03 16:16:56 -0700410 Thread* thread = Thread::FromManagedThread(soa, thread_peer);
411 // If thread is null then this a java.lang.Thread without a Thread*. Must be a un-started or a
412 // zombie.
413 *error = (thread == nullptr) ? JDWP::ERR_THREAD_NOT_ALIVE : JDWP::ERR_NONE;
414 return thread;
Elliott Hughes436e3722012-02-17 20:01:47 -0800415}
416
Elliott Hughes24437992011-11-30 14:49:33 -0800417static JDWP::JdwpTag BasicTagFromDescriptor(const char* descriptor) {
418 // JDWP deliberately uses the descriptor characters' ASCII values for its enum.
419 // Note that by "basic" we mean that we don't get more specific than JT_OBJECT.
420 return static_cast<JDWP::JdwpTag>(descriptor[0]);
421}
422
Ian Rogers1ff3c982014-08-12 02:30:58 -0700423static JDWP::JdwpTag BasicTagFromClass(mirror::Class* klass)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700424 REQUIRES_SHARED(Locks::mutator_lock_) {
Ian Rogers1ff3c982014-08-12 02:30:58 -0700425 std::string temp;
426 const char* descriptor = klass->GetDescriptor(&temp);
427 return BasicTagFromDescriptor(descriptor);
428}
429
Ian Rogers98379392014-02-24 16:53:16 -0800430static JDWP::JdwpTag TagFromClass(const ScopedObjectAccessUnchecked& soa, mirror::Class* c)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700431 REQUIRES_SHARED(Locks::mutator_lock_) {
Ian Rogersc0542af2014-09-03 16:16:56 -0700432 CHECK(c != nullptr);
Elliott Hughes24437992011-11-30 14:49:33 -0800433 if (c->IsArrayClass()) {
434 return JDWP::JT_ARRAY;
435 }
Elliott Hughes24437992011-11-30 14:49:33 -0800436 if (c->IsStringClass()) {
437 return JDWP::JT_STRING;
Elliott Hughes24437992011-11-30 14:49:33 -0800438 }
Ian Rogers98379392014-02-24 16:53:16 -0800439 if (c->IsClassClass()) {
440 return JDWP::JT_CLASS_OBJECT;
441 }
442 {
Mathieu Chartier0795f232016-09-27 18:43:30 -0700443 ObjPtr<mirror::Class> thread_class =
444 soa.Decode<mirror::Class>(WellKnownClasses::java_lang_Thread);
Ian Rogers98379392014-02-24 16:53:16 -0800445 if (thread_class->IsAssignableFrom(c)) {
446 return JDWP::JT_THREAD;
447 }
448 }
449 {
Mathieu Chartier0795f232016-09-27 18:43:30 -0700450 ObjPtr<mirror::Class> thread_group_class =
451 soa.Decode<mirror::Class>(WellKnownClasses::java_lang_ThreadGroup);
Ian Rogers98379392014-02-24 16:53:16 -0800452 if (thread_group_class->IsAssignableFrom(c)) {
453 return JDWP::JT_THREAD_GROUP;
454 }
455 }
456 {
Mathieu Chartier0795f232016-09-27 18:43:30 -0700457 ObjPtr<mirror::Class> class_loader_class =
458 soa.Decode<mirror::Class>(WellKnownClasses::java_lang_ClassLoader);
Ian Rogers98379392014-02-24 16:53:16 -0800459 if (class_loader_class->IsAssignableFrom(c)) {
460 return JDWP::JT_CLASS_LOADER;
461 }
462 }
463 return JDWP::JT_OBJECT;
Elliott Hughes24437992011-11-30 14:49:33 -0800464}
465
466/*
467 * Objects declared to hold Object might actually hold a more specific
468 * type. The debugger may take a special interest in these (e.g. it
469 * wants to display the contents of Strings), so we want to return an
470 * appropriate tag.
471 *
472 * Null objects are tagged JT_OBJECT.
473 */
Sebastien Hertz6995c602014-09-09 12:10:13 +0200474JDWP::JdwpTag Dbg::TagFromObject(const ScopedObjectAccessUnchecked& soa, mirror::Object* o) {
Ian Rogersc0542af2014-09-03 16:16:56 -0700475 return (o == nullptr) ? JDWP::JT_OBJECT : TagFromClass(soa, o->GetClass());
Elliott Hughes24437992011-11-30 14:49:33 -0800476}
477
478static bool IsPrimitiveTag(JDWP::JdwpTag tag) {
479 switch (tag) {
480 case JDWP::JT_BOOLEAN:
481 case JDWP::JT_BYTE:
482 case JDWP::JT_CHAR:
483 case JDWP::JT_FLOAT:
484 case JDWP::JT_DOUBLE:
485 case JDWP::JT_INT:
486 case JDWP::JT_LONG:
487 case JDWP::JT_SHORT:
488 case JDWP::JT_VOID:
489 return true;
490 default:
491 return false;
492 }
493}
494
Sebastien Hertzb3b173b2015-02-06 09:16:32 +0100495void Dbg::StartJdwp() {
Elliott Hughesc0f09332012-03-26 13:27:06 -0700496 if (!gJdwpAllowed || !IsJdwpConfigured()) {
Elliott Hughes376a7a02011-10-24 18:35:55 -0700497 // No JDWP for you!
498 return;
499 }
500
Ian Rogers719d1a32014-03-06 12:13:39 -0800501 CHECK(gRegistry == nullptr);
Elliott Hughes475fc232011-10-25 15:00:35 -0700502 gRegistry = new ObjectRegistry;
503
Elliott Hughesd1cc8362011-10-24 16:58:50 -0700504 // Init JDWP if the debugger is enabled. This may connect out to a
505 // debugger, passively listen for a debugger, or block waiting for a
506 // debugger.
Sebastien Hertzb3b173b2015-02-06 09:16:32 +0100507 gJdwpState = JDWP::JdwpState::Create(&gJdwpOptions);
Ian Rogersc0542af2014-09-03 16:16:56 -0700508 if (gJdwpState == nullptr) {
Elliott Hughesf8a2df72011-12-01 12:19:54 -0800509 // We probably failed because some other process has the port already, which means that
510 // if we don't abort the user is likely to think they're talking to us when they're actually
511 // talking to that other process.
Elliott Hughes3d30d9b2011-12-07 17:35:48 -0800512 LOG(FATAL) << "Debugger thread failed to initialize";
Elliott Hughesd1cc8362011-10-24 16:58:50 -0700513 }
514
515 // If a debugger has already attached, send the "welcome" message.
516 // This may cause us to suspend all threads.
Elliott Hughes376a7a02011-10-24 18:35:55 -0700517 if (gJdwpState->IsActive()) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700518 ScopedObjectAccess soa(Thread::Current());
Sebastien Hertz7d955652014-10-22 10:57:10 +0200519 gJdwpState->PostVMStart();
Elliott Hughesd1cc8362011-10-24 16:58:50 -0700520 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700521}
522
Elliott Hughesd1cc8362011-10-24 16:58:50 -0700523void Dbg::StopJdwp() {
Sebastien Hertzc6345ef2014-08-18 19:26:39 +0200524 // Post VM_DEATH event before the JDWP connection is closed (either by the JDWP thread or the
525 // destruction of gJdwpState).
526 if (gJdwpState != nullptr && gJdwpState->IsActive()) {
527 gJdwpState->PostVMDeath();
528 }
Sebastien Hertz0376e6b2014-02-06 18:12:59 +0100529 // Prevent the JDWP thread from processing JDWP incoming packets after we close the connection.
Sebastien Hertz4e5b2082015-03-24 19:03:40 +0100530 Dispose();
Elliott Hughes376a7a02011-10-24 18:35:55 -0700531 delete gJdwpState;
Ian Rogers719d1a32014-03-06 12:13:39 -0800532 gJdwpState = nullptr;
Elliott Hughes475fc232011-10-25 15:00:35 -0700533 delete gRegistry;
Ian Rogers719d1a32014-03-06 12:13:39 -0800534 gRegistry = nullptr;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700535}
536
Elliott Hughes767a1472011-10-26 18:49:02 -0700537void Dbg::GcDidFinish() {
538 if (gDdmHpifWhen != HPIF_WHEN_NEVER) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700539 ScopedObjectAccess soa(Thread::Current());
Brian Carlstrom4d466a82014-05-08 19:05:29 -0700540 VLOG(jdwp) << "Sending heap info to DDM";
Elliott Hughes7162ad92011-10-27 14:08:42 -0700541 DdmSendHeapInfo(gDdmHpifWhen);
Elliott Hughes767a1472011-10-26 18:49:02 -0700542 }
543 if (gDdmHpsgWhen != HPSG_WHEN_NEVER) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700544 ScopedObjectAccess soa(Thread::Current());
Brian Carlstrom4d466a82014-05-08 19:05:29 -0700545 VLOG(jdwp) << "Dumping heap to DDM";
Elliott Hughes6a5bd492011-10-28 14:33:57 -0700546 DdmSendHeapSegments(false);
Elliott Hughes767a1472011-10-26 18:49:02 -0700547 }
548 if (gDdmNhsgWhen != HPSG_WHEN_NEVER) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700549 ScopedObjectAccess soa(Thread::Current());
Brian Carlstrom4d466a82014-05-08 19:05:29 -0700550 VLOG(jdwp) << "Dumping native heap to DDM";
Elliott Hughes6a5bd492011-10-28 14:33:57 -0700551 DdmSendHeapSegments(true);
Elliott Hughes767a1472011-10-26 18:49:02 -0700552 }
553}
554
Elliott Hughes4ffd3132011-10-24 12:06:42 -0700555void Dbg::SetJdwpAllowed(bool allowed) {
556 gJdwpAllowed = allowed;
557}
558
Leonard Mosescueb842212016-10-06 17:26:36 -0700559bool Dbg::IsJdwpAllowed() {
560 return gJdwpAllowed;
561}
562
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700563DebugInvokeReq* Dbg::GetInvokeReq() {
Elliott Hughes475fc232011-10-25 15:00:35 -0700564 return Thread::Current()->GetInvokeReq();
565}
566
567Thread* Dbg::GetDebugThread() {
Ian Rogersc0542af2014-09-03 16:16:56 -0700568 return (gJdwpState != nullptr) ? gJdwpState->GetDebugThread() : nullptr;
Elliott Hughes475fc232011-10-25 15:00:35 -0700569}
570
571void Dbg::ClearWaitForEventThread() {
Sebastien Hertz2bf93f42015-01-09 18:44:05 +0100572 gJdwpState->ReleaseJdwpTokenForEvent();
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700573}
574
575void Dbg::Connected() {
Elliott Hughes3bb81562011-10-21 18:52:59 -0700576 CHECK(!gDebuggerConnected);
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800577 VLOG(jdwp) << "JDWP has attached";
Elliott Hughes3bb81562011-10-21 18:52:59 -0700578 gDebuggerConnected = true;
Elliott Hughes86964332012-02-15 19:37:42 -0800579 gDisposed = false;
580}
581
Sebastien Hertzf3928792014-11-17 19:00:37 +0100582bool Dbg::RequiresDeoptimization() {
583 // We don't need deoptimization if everything runs with interpreter after
584 // enabling -Xint mode.
585 return !Runtime::Current()->GetInstrumentation()->IsForcedInterpretOnly();
586}
587
Mingyao Yang6ea1a0e2016-01-29 12:12:49 -0800588// Used to patch boot image method entry point to interpreter bridge.
589class UpdateEntryPointsClassVisitor : public ClassVisitor {
590 public:
591 explicit UpdateEntryPointsClassVisitor(instrumentation::Instrumentation* instrumentation)
592 : instrumentation_(instrumentation) {}
593
Mathieu Chartier28357fa2016-10-18 16:27:40 -0700594 bool operator()(ObjPtr<mirror::Class> klass) OVERRIDE REQUIRES(Locks::mutator_lock_) {
Mingyao Yang6ea1a0e2016-01-29 12:12:49 -0800595 auto pointer_size = Runtime::Current()->GetClassLinker()->GetImagePointerSize();
596 for (auto& m : klass->GetMethods(pointer_size)) {
597 const void* code = m.GetEntryPointFromQuickCompiledCode();
598 if (Runtime::Current()->GetHeap()->IsInBootImageOatFile(code) &&
599 !m.IsNative() &&
600 !m.IsProxyMethod()) {
Mingyao Yang3fd448a2016-05-10 14:30:41 -0700601 instrumentation_->UpdateMethodsCodeFromDebugger(&m, GetQuickToInterpreterBridge());
Mingyao Yang6ea1a0e2016-01-29 12:12:49 -0800602 }
603 }
604 return true;
605 }
606
607 private:
608 instrumentation::Instrumentation* const instrumentation_;
609};
610
Elliott Hughesa2155262011-11-16 16:26:58 -0800611void Dbg::GoActive() {
612 // Enable all debugging features, including scans for breakpoints.
613 // This is a no-op if we're already active.
614 // Only called from the JDWP handler thread.
Daniel Mihalyieb076692014-08-22 17:33:31 +0200615 if (IsDebuggerActive()) {
Elliott Hughesa2155262011-11-16 16:26:58 -0800616 return;
617 }
618
Mathieu Chartieraa516822015-10-02 15:53:37 -0700619 Thread* const self = Thread::Current();
Elliott Hughesc0f09332012-03-26 13:27:06 -0700620 {
621 // TODO: dalvik only warned if there were breakpoints left over. clear in Dbg::Disconnected?
Mathieu Chartieraa516822015-10-02 15:53:37 -0700622 ReaderMutexLock mu(self, *Locks::breakpoint_lock_);
Elliott Hughesc0f09332012-03-26 13:27:06 -0700623 CHECK_EQ(gBreakpoints.size(), 0U);
624 }
Elliott Hughesa2155262011-11-16 16:26:58 -0800625
Sebastien Hertz138dbfc2013-12-04 18:15:25 +0100626 {
Mathieu Chartieraa516822015-10-02 15:53:37 -0700627 MutexLock mu(self, *Locks::deoptimization_lock_);
Sebastien Hertz4d25df32014-03-21 17:44:46 +0100628 CHECK_EQ(deoptimization_requests_.size(), 0U);
629 CHECK_EQ(full_deoptimization_event_count_, 0U);
Sebastien Hertz42cd43f2014-05-13 14:15:41 +0200630 CHECK_EQ(dex_pc_change_event_ref_count_, 0U);
631 CHECK_EQ(method_enter_event_ref_count_, 0U);
632 CHECK_EQ(method_exit_event_ref_count_, 0U);
633 CHECK_EQ(field_read_event_ref_count_, 0U);
634 CHECK_EQ(field_write_event_ref_count_, 0U);
635 CHECK_EQ(exception_catch_event_ref_count_, 0U);
Sebastien Hertz138dbfc2013-12-04 18:15:25 +0100636 }
637
Ian Rogers62d6c772013-02-27 08:32:07 -0800638 Runtime* runtime = Runtime::Current();
David Srbeckyf4480162016-03-16 00:06:24 +0000639 // Since boot image code may be AOT compiled as not debuggable, we need to patch
Mingyao Yang6ea1a0e2016-01-29 12:12:49 -0800640 // entry points of methods in boot image to interpreter bridge.
David Srbeckyf4480162016-03-16 00:06:24 +0000641 // However, the performance cost of this is non-negligible during native-debugging due to the
642 // forced JIT, so we keep the AOT code in that case in exchange for limited native debugging.
643 if (!runtime->GetInstrumentation()->IsForcedInterpretOnly() && !runtime->IsNativeDebuggable()) {
Mingyao Yang6ea1a0e2016-01-29 12:12:49 -0800644 ScopedObjectAccess soa(self);
645 UpdateEntryPointsClassVisitor visitor(runtime->GetInstrumentation());
646 runtime->GetClassLinker()->VisitClasses(&visitor);
647 }
648
Mathieu Chartier4f55e222015-09-04 13:26:21 -0700649 ScopedSuspendAll ssa(__FUNCTION__);
Sebastien Hertzf3928792014-11-17 19:00:37 +0100650 if (RequiresDeoptimization()) {
651 runtime->GetInstrumentation()->EnableDeoptimization();
652 }
Sebastien Hertz42cd43f2014-05-13 14:15:41 +0200653 instrumentation_events_ = 0;
Elliott Hughesa2155262011-11-16 16:26:58 -0800654 gDebuggerActive = true;
Ian Rogers62d6c772013-02-27 08:32:07 -0800655 LOG(INFO) << "Debugger is active";
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700656}
657
658void Dbg::Disconnected() {
Elliott Hughes234ab152011-10-26 14:02:26 -0700659 CHECK(gDebuggerConnected);
660
Elliott Hughesc0f09332012-03-26 13:27:06 -0700661 LOG(INFO) << "Debugger is no longer active";
Elliott Hughes234ab152011-10-26 14:02:26 -0700662
Hiroshi Yamauchi98810e32016-05-24 14:55:40 -0700663 // Suspend all threads and exclusively acquire the mutator lock. Remove the debugger as a listener
Ian Rogers62d6c772013-02-27 08:32:07 -0800664 // and clear the object registry.
665 Runtime* runtime = Runtime::Current();
Ian Rogers62d6c772013-02-27 08:32:07 -0800666 Thread* self = Thread::Current();
Mathieu Chartier4f55e222015-09-04 13:26:21 -0700667 {
Mathieu Chartieraa516822015-10-02 15:53:37 -0700668 // Required for DisableDeoptimization.
669 gc::ScopedGCCriticalSection gcs(self,
670 gc::kGcCauseInstrumentation,
671 gc::kCollectorTypeInstrumentation);
Mathieu Chartier4f55e222015-09-04 13:26:21 -0700672 ScopedSuspendAll ssa(__FUNCTION__);
Mathieu Chartier4f55e222015-09-04 13:26:21 -0700673 // Debugger may not be active at this point.
674 if (IsDebuggerActive()) {
675 {
676 // Since we're going to disable deoptimization, we clear the deoptimization requests queue.
677 // This prevents us from having any pending deoptimization request when the debugger attaches
678 // to us again while no event has been requested yet.
Mathieu Chartiera6b1ead2015-10-06 10:32:38 -0700679 MutexLock mu(self, *Locks::deoptimization_lock_);
Mathieu Chartier4f55e222015-09-04 13:26:21 -0700680 deoptimization_requests_.clear();
681 full_deoptimization_event_count_ = 0U;
682 }
683 if (instrumentation_events_ != 0) {
684 runtime->GetInstrumentation()->RemoveListener(&gDebugInstrumentationListener,
685 instrumentation_events_);
686 instrumentation_events_ = 0;
687 }
688 if (RequiresDeoptimization()) {
689 runtime->GetInstrumentation()->DisableDeoptimization(kDbgInstrumentationKey);
690 }
691 gDebuggerActive = false;
Sebastien Hertzaaea7342014-02-25 15:10:04 +0100692 }
Sebastien Hertz138dbfc2013-12-04 18:15:25 +0100693 }
Sebastien Hertz55f65342015-01-13 22:48:34 +0100694
695 {
696 ScopedObjectAccess soa(self);
697 gRegistry->Clear();
698 }
699
700 gDebuggerConnected = false;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700701}
702
Sebastien Hertzb3b173b2015-02-06 09:16:32 +0100703void Dbg::ConfigureJdwp(const JDWP::JdwpOptions& jdwp_options) {
704 CHECK_NE(jdwp_options.transport, JDWP::kJdwpTransportUnknown);
705 gJdwpOptions = jdwp_options;
706 gJdwpConfigured = true;
707}
708
Elliott Hughesc0f09332012-03-26 13:27:06 -0700709bool Dbg::IsJdwpConfigured() {
Elliott Hughes3bb81562011-10-21 18:52:59 -0700710 return gJdwpConfigured;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700711}
712
713int64_t Dbg::LastDebuggerActivity() {
Elliott Hughesca951522011-12-05 12:01:32 -0800714 return gJdwpState->LastDebuggerActivity();
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700715}
716
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700717void Dbg::UndoDebuggerSuspensions() {
Elliott Hughes234ab152011-10-26 14:02:26 -0700718 Runtime::Current()->GetThreadList()->UndoDebuggerSuspensions();
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700719}
720
Elliott Hughes88d63092013-01-09 09:55:54 -0800721std::string Dbg::GetClassName(JDWP::RefTypeId class_id) {
Ian Rogersc0542af2014-09-03 16:16:56 -0700722 JDWP::JdwpError error;
723 mirror::Object* o = gRegistry->Get<mirror::Object*>(class_id, &error);
724 if (o == nullptr) {
725 if (error == JDWP::ERR_NONE) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700726 return "null";
Ian Rogersc0542af2014-09-03 16:16:56 -0700727 } else {
728 return StringPrintf("invalid object %p", reinterpret_cast<void*>(class_id));
729 }
Elliott Hughes436e3722012-02-17 20:01:47 -0800730 }
731 if (!o->IsClass()) {
Brian Carlstrom7934ac22013-07-26 10:54:15 -0700732 return StringPrintf("non-class %p", o); // This is only used for debugging output anyway.
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800733 }
Sebastien Hertz6995c602014-09-09 12:10:13 +0200734 return GetClassName(o->AsClass());
735}
736
737std::string Dbg::GetClassName(mirror::Class* klass) {
Sebastien Hertza9aa0ff2014-09-19 12:07:51 +0200738 if (klass == nullptr) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -0700739 return "null";
Sebastien Hertza9aa0ff2014-09-19 12:07:51 +0200740 }
Ian Rogers1ff3c982014-08-12 02:30:58 -0700741 std::string temp;
Sebastien Hertz6995c602014-09-09 12:10:13 +0200742 return DescriptorToName(klass->GetDescriptor(&temp));
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700743}
744
Ian Rogersc0542af2014-09-03 16:16:56 -0700745JDWP::JdwpError Dbg::GetClassObject(JDWP::RefTypeId id, JDWP::ObjectId* class_object_id) {
Elliott Hughes436e3722012-02-17 20:01:47 -0800746 JDWP::JdwpError status;
Ian Rogersc0542af2014-09-03 16:16:56 -0700747 mirror::Class* c = DecodeClass(id, &status);
748 if (c == nullptr) {
749 *class_object_id = 0;
Elliott Hughes436e3722012-02-17 20:01:47 -0800750 return status;
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800751 }
Ian Rogersc0542af2014-09-03 16:16:56 -0700752 *class_object_id = gRegistry->Add(c);
Elliott Hughes436e3722012-02-17 20:01:47 -0800753 return JDWP::ERR_NONE;
Elliott Hughes86964332012-02-15 19:37:42 -0800754}
755
Ian Rogersc0542af2014-09-03 16:16:56 -0700756JDWP::JdwpError Dbg::GetSuperclass(JDWP::RefTypeId id, JDWP::RefTypeId* superclass_id) {
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -0800757 JDWP::JdwpError status;
Ian Rogersc0542af2014-09-03 16:16:56 -0700758 mirror::Class* c = DecodeClass(id, &status);
759 if (c == nullptr) {
760 *superclass_id = 0;
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -0800761 return status;
762 }
763 if (c->IsInterface()) {
764 // http://code.google.com/p/android/issues/detail?id=20856
Ian Rogersc0542af2014-09-03 16:16:56 -0700765 *superclass_id = 0;
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -0800766 } else {
Ian Rogersc0542af2014-09-03 16:16:56 -0700767 *superclass_id = gRegistry->Add(c->GetSuperClass());
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -0800768 }
769 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700770}
771
Elliott Hughes436e3722012-02-17 20:01:47 -0800772JDWP::JdwpError Dbg::GetClassLoader(JDWP::RefTypeId id, JDWP::ExpandBuf* pReply) {
Ian Rogersc0542af2014-09-03 16:16:56 -0700773 JDWP::JdwpError error;
Andreas Gampe7929a482015-12-30 19:33:49 -0800774 mirror::Class* c = DecodeClass(id, &error);
775 if (c == nullptr) {
776 return error;
Elliott Hughes436e3722012-02-17 20:01:47 -0800777 }
Andreas Gampe7929a482015-12-30 19:33:49 -0800778 expandBufAddObjectId(pReply, gRegistry->Add(c->GetClassLoader()));
Elliott Hughes436e3722012-02-17 20:01:47 -0800779 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700780}
781
Elliott Hughes436e3722012-02-17 20:01:47 -0800782JDWP::JdwpError Dbg::GetModifiers(JDWP::RefTypeId id, JDWP::ExpandBuf* pReply) {
Ian Rogersc0542af2014-09-03 16:16:56 -0700783 JDWP::JdwpError error;
784 mirror::Class* c = DecodeClass(id, &error);
785 if (c == nullptr) {
786 return error;
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800787 }
Elliott Hughes436e3722012-02-17 20:01:47 -0800788
789 uint32_t access_flags = c->GetAccessFlags() & kAccJavaFlagsMask;
790
Yevgeny Roubande34eea2014-02-15 01:06:03 +0700791 // Set ACC_SUPER. Dex files don't contain this flag but only classes are supposed to have it set,
792 // not interfaces.
Elliott Hughes436e3722012-02-17 20:01:47 -0800793 // Class.getModifiers doesn't return it, but JDWP does, so we set it here.
Yevgeny Roubande34eea2014-02-15 01:06:03 +0700794 if ((access_flags & kAccInterface) == 0) {
795 access_flags |= kAccSuper;
796 }
Elliott Hughes436e3722012-02-17 20:01:47 -0800797
798 expandBufAdd4BE(pReply, access_flags);
799
800 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700801}
802
Ian Rogersc0542af2014-09-03 16:16:56 -0700803JDWP::JdwpError Dbg::GetMonitorInfo(JDWP::ObjectId object_id, JDWP::ExpandBuf* reply) {
804 JDWP::JdwpError error;
805 mirror::Object* o = gRegistry->Get<mirror::Object*>(object_id, &error);
806 if (o == nullptr) {
Elliott Hughesf327e072013-01-09 16:01:26 -0800807 return JDWP::ERR_INVALID_OBJECT;
808 }
809
810 // Ensure all threads are suspended while we read objects' lock words.
811 Thread* self = Thread::Current();
Sebastien Hertz54263242014-03-19 18:16:50 +0100812 CHECK_EQ(self->GetState(), kRunnable);
Elliott Hughesf327e072013-01-09 16:01:26 -0800813
Mathieu Chartierf1d666e2015-09-03 16:13:34 -0700814 MonitorInfo monitor_info;
815 {
816 ScopedThreadSuspension sts(self, kSuspended);
Mathieu Chartier4f55e222015-09-04 13:26:21 -0700817 ScopedSuspendAll ssa(__FUNCTION__);
Mathieu Chartierf1d666e2015-09-03 16:13:34 -0700818 monitor_info = MonitorInfo(o);
Mathieu Chartierf1d666e2015-09-03 16:13:34 -0700819 }
Ian Rogersc0542af2014-09-03 16:16:56 -0700820 if (monitor_info.owner_ != nullptr) {
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700821 expandBufAddObjectId(reply, gRegistry->Add(monitor_info.owner_->GetPeer()));
Elliott Hughesf327e072013-01-09 16:01:26 -0800822 } else {
Ian Rogersc0542af2014-09-03 16:16:56 -0700823 expandBufAddObjectId(reply, gRegistry->Add(nullptr));
Elliott Hughesf327e072013-01-09 16:01:26 -0800824 }
Ian Rogersd9c4fc92013-10-01 19:45:43 -0700825 expandBufAdd4BE(reply, monitor_info.entry_count_);
826 expandBufAdd4BE(reply, monitor_info.waiters_.size());
827 for (size_t i = 0; i < monitor_info.waiters_.size(); ++i) {
828 expandBufAddObjectId(reply, gRegistry->Add(monitor_info.waiters_[i]->GetPeer()));
Elliott Hughesf327e072013-01-09 16:01:26 -0800829 }
830 return JDWP::ERR_NONE;
831}
832
Elliott Hughes734b8c62013-01-11 15:32:45 -0800833JDWP::JdwpError Dbg::GetOwnedMonitors(JDWP::ObjectId thread_id,
Ian Rogersc0542af2014-09-03 16:16:56 -0700834 std::vector<JDWP::ObjectId>* monitors,
835 std::vector<uint32_t>* stack_depths) {
Elliott Hughes4993bbc2013-01-10 15:41:25 -0800836 struct OwnedMonitorVisitor : public StackVisitor {
Hiroshi Yamauchib5a9e3d2014-06-09 12:11:20 -0700837 OwnedMonitorVisitor(Thread* thread, Context* context,
Hiroshi Yamauchicc8c5c52014-06-13 15:08:05 -0700838 std::vector<JDWP::ObjectId>* monitor_vector,
Hiroshi Yamauchib5a9e3d2014-06-09 12:11:20 -0700839 std::vector<uint32_t>* stack_depth_vector)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700840 REQUIRES_SHARED(Locks::mutator_lock_)
Nicolas Geoffray8e5bd182015-05-06 11:34:34 +0100841 : StackVisitor(thread, context, StackVisitor::StackWalkKind::kIncludeInlinedFrames),
842 current_stack_depth(0),
843 monitors(monitor_vector),
844 stack_depths(stack_depth_vector) {}
Elliott Hughes4993bbc2013-01-10 15:41:25 -0800845
846 // TODO: Enable annotalysis. We know lock is held in constructor, but abstraction confuses
847 // annotalysis.
848 bool VisitFrame() NO_THREAD_SAFETY_ANALYSIS {
849 if (!GetMethod()->IsRuntimeMethod()) {
850 Monitor::VisitLocks(this, AppendOwnedMonitors, this);
Elliott Hughes734b8c62013-01-11 15:32:45 -0800851 ++current_stack_depth;
Elliott Hughes4993bbc2013-01-10 15:41:25 -0800852 }
853 return true;
854 }
855
Hiroshi Yamauchicc8c5c52014-06-13 15:08:05 -0700856 static void AppendOwnedMonitors(mirror::Object* owned_monitor, void* arg)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -0700857 REQUIRES_SHARED(Locks::mutator_lock_) {
Ian Rogers7a22fa62013-01-23 12:16:16 -0800858 OwnedMonitorVisitor* visitor = reinterpret_cast<OwnedMonitorVisitor*>(arg);
Hiroshi Yamauchicc8c5c52014-06-13 15:08:05 -0700859 visitor->monitors->push_back(gRegistry->Add(owned_monitor));
Hiroshi Yamauchib5a9e3d2014-06-09 12:11:20 -0700860 visitor->stack_depths->push_back(visitor->current_stack_depth);
Elliott Hughes4993bbc2013-01-10 15:41:25 -0800861 }
862
Elliott Hughes734b8c62013-01-11 15:32:45 -0800863 size_t current_stack_depth;
Ian Rogersc0542af2014-09-03 16:16:56 -0700864 std::vector<JDWP::ObjectId>* const monitors;
865 std::vector<uint32_t>* const stack_depths;
Elliott Hughes4993bbc2013-01-10 15:41:25 -0800866 };
Elliott Hughes4993bbc2013-01-10 15:41:25 -0800867
Hiroshi Yamauchib5a9e3d2014-06-09 12:11:20 -0700868 ScopedObjectAccessUnchecked soa(Thread::Current());
Sebastien Hertz69206392015-04-07 15:54:25 +0200869 JDWP::JdwpError error;
870 Thread* thread = DecodeThread(soa, thread_id, &error);
871 if (thread == nullptr) {
872 return error;
873 }
874 if (!IsSuspendedForDebugger(soa, thread)) {
875 return JDWP::ERR_THREAD_NOT_SUSPENDED;
Hiroshi Yamauchib5a9e3d2014-06-09 12:11:20 -0700876 }
Hiroshi Yamauchicc8c5c52014-06-13 15:08:05 -0700877 std::unique_ptr<Context> context(Context::Create());
Ian Rogersc0542af2014-09-03 16:16:56 -0700878 OwnedMonitorVisitor visitor(thread, context.get(), monitors, stack_depths);
Hiroshi Yamauchicc8c5c52014-06-13 15:08:05 -0700879 visitor.WalkStack();
Elliott Hughes4993bbc2013-01-10 15:41:25 -0800880 return JDWP::ERR_NONE;
881}
882
Sebastien Hertz52d131d2014-03-13 16:17:40 +0100883JDWP::JdwpError Dbg::GetContendedMonitor(JDWP::ObjectId thread_id,
Ian Rogersc0542af2014-09-03 16:16:56 -0700884 JDWP::ObjectId* contended_monitor) {
Elliott Hughesf9501702013-01-11 11:22:27 -0800885 ScopedObjectAccessUnchecked soa(Thread::Current());
Ian Rogersc0542af2014-09-03 16:16:56 -0700886 *contended_monitor = 0;
Sebastien Hertz69206392015-04-07 15:54:25 +0200887 JDWP::JdwpError error;
888 Thread* thread = DecodeThread(soa, thread_id, &error);
889 if (thread == nullptr) {
890 return error;
Elliott Hughesf9501702013-01-11 11:22:27 -0800891 }
Sebastien Hertz69206392015-04-07 15:54:25 +0200892 if (!IsSuspendedForDebugger(soa, thread)) {
893 return JDWP::ERR_THREAD_NOT_SUSPENDED;
894 }
895 mirror::Object* contended_monitor_obj = Monitor::GetContendedMonitor(thread);
Hiroshi Yamauchib5a9e3d2014-06-09 12:11:20 -0700896 // Add() requires the thread_list_lock_ not held to avoid the lock
897 // level violation.
Ian Rogersc0542af2014-09-03 16:16:56 -0700898 *contended_monitor = gRegistry->Add(contended_monitor_obj);
Elliott Hughesf9501702013-01-11 11:22:27 -0800899 return JDWP::ERR_NONE;
900}
901
Elliott Hughesec0f83d2013-01-15 16:54:08 -0800902JDWP::JdwpError Dbg::GetInstanceCounts(const std::vector<JDWP::RefTypeId>& class_ids,
Ian Rogersc0542af2014-09-03 16:16:56 -0700903 std::vector<uint64_t>* counts) {
Mathieu Chartier412c7fc2014-02-07 12:18:39 -0800904 gc::Heap* heap = Runtime::Current()->GetHeap();
905 heap->CollectGarbage(false);
Mathieu Chartiere8a3c572016-10-11 16:52:17 -0700906 VariableSizedHandleScope hs(Thread::Current());
Mathieu Chartier9d156d52016-10-06 17:44:26 -0700907 std::vector<Handle<mirror::Class>> classes;
Ian Rogersc0542af2014-09-03 16:16:56 -0700908 counts->clear();
Elliott Hughesec0f83d2013-01-15 16:54:08 -0800909 for (size_t i = 0; i < class_ids.size(); ++i) {
Ian Rogersc0542af2014-09-03 16:16:56 -0700910 JDWP::JdwpError error;
Mathieu Chartier9d156d52016-10-06 17:44:26 -0700911 ObjPtr<mirror::Class> c = DecodeClass(class_ids[i], &error);
Ian Rogersc0542af2014-09-03 16:16:56 -0700912 if (c == nullptr) {
913 return error;
Elliott Hughesec0f83d2013-01-15 16:54:08 -0800914 }
Mathieu Chartier9d156d52016-10-06 17:44:26 -0700915 classes.push_back(hs.NewHandle(c));
Ian Rogersc0542af2014-09-03 16:16:56 -0700916 counts->push_back(0);
Elliott Hughesec0f83d2013-01-15 16:54:08 -0800917 }
Ian Rogersc0542af2014-09-03 16:16:56 -0700918 heap->CountInstances(classes, false, &(*counts)[0]);
Elliott Hughesec0f83d2013-01-15 16:54:08 -0800919 return JDWP::ERR_NONE;
920}
921
Ian Rogersc0542af2014-09-03 16:16:56 -0700922JDWP::JdwpError Dbg::GetInstances(JDWP::RefTypeId class_id, int32_t max_count,
923 std::vector<JDWP::ObjectId>* instances) {
Mathieu Chartier412c7fc2014-02-07 12:18:39 -0800924 gc::Heap* heap = Runtime::Current()->GetHeap();
925 // We only want reachable instances, so do a GC.
926 heap->CollectGarbage(false);
Ian Rogersc0542af2014-09-03 16:16:56 -0700927 JDWP::JdwpError error;
Mathieu Chartier9d156d52016-10-06 17:44:26 -0700928 ObjPtr<mirror::Class> c = DecodeClass(class_id, &error);
Mathieu Chartier412c7fc2014-02-07 12:18:39 -0800929 if (c == nullptr) {
Ian Rogersc0542af2014-09-03 16:16:56 -0700930 return error;
Elliott Hughes3b78c942013-01-15 17:35:41 -0800931 }
Mathieu Chartier2d855952016-10-12 19:37:59 -0700932 VariableSizedHandleScope hs(Thread::Current());
933 std::vector<Handle<mirror::Object>> raw_instances;
934 Runtime::Current()->GetHeap()->GetInstances(hs, hs.NewHandle(c), max_count, raw_instances);
Elliott Hughes3b78c942013-01-15 17:35:41 -0800935 for (size_t i = 0; i < raw_instances.size(); ++i) {
Mathieu Chartier2d855952016-10-12 19:37:59 -0700936 instances->push_back(gRegistry->Add(raw_instances[i].Get()));
Elliott Hughes3b78c942013-01-15 17:35:41 -0800937 }
938 return JDWP::ERR_NONE;
939}
940
Elliott Hughes0cbaff52013-01-16 15:28:01 -0800941JDWP::JdwpError Dbg::GetReferringObjects(JDWP::ObjectId object_id, int32_t max_count,
Ian Rogersc0542af2014-09-03 16:16:56 -0700942 std::vector<JDWP::ObjectId>* referring_objects) {
Mathieu Chartier412c7fc2014-02-07 12:18:39 -0800943 gc::Heap* heap = Runtime::Current()->GetHeap();
944 heap->CollectGarbage(false);
Ian Rogersc0542af2014-09-03 16:16:56 -0700945 JDWP::JdwpError error;
Mathieu Chartier9d156d52016-10-06 17:44:26 -0700946 ObjPtr<mirror::Object> o = gRegistry->Get<mirror::Object*>(object_id, &error);
Ian Rogersc0542af2014-09-03 16:16:56 -0700947 if (o == nullptr) {
Elliott Hughes0cbaff52013-01-16 15:28:01 -0800948 return JDWP::ERR_INVALID_OBJECT;
949 }
Mathieu Chartieraea9bfb2016-10-12 19:19:56 -0700950 VariableSizedHandleScope hs(Thread::Current());
951 std::vector<Handle<mirror::Object>> raw_instances;
952 heap->GetReferringObjects(hs, hs.NewHandle(o), max_count, raw_instances);
Elliott Hughes0cbaff52013-01-16 15:28:01 -0800953 for (size_t i = 0; i < raw_instances.size(); ++i) {
Mathieu Chartieraea9bfb2016-10-12 19:19:56 -0700954 referring_objects->push_back(gRegistry->Add(raw_instances[i].Get()));
Elliott Hughes0cbaff52013-01-16 15:28:01 -0800955 }
956 return JDWP::ERR_NONE;
957}
958
Ian Rogersc0542af2014-09-03 16:16:56 -0700959JDWP::JdwpError Dbg::DisableCollection(JDWP::ObjectId object_id) {
960 JDWP::JdwpError error;
961 mirror::Object* o = gRegistry->Get<mirror::Object*>(object_id, &error);
962 if (o == nullptr) {
Sebastien Hertze96060a2013-12-11 12:06:28 +0100963 return JDWP::ERR_INVALID_OBJECT;
964 }
Elliott Hughes64f574f2013-02-20 14:57:12 -0800965 gRegistry->DisableCollection(object_id);
966 return JDWP::ERR_NONE;
967}
968
Ian Rogersc0542af2014-09-03 16:16:56 -0700969JDWP::JdwpError Dbg::EnableCollection(JDWP::ObjectId object_id) {
970 JDWP::JdwpError error;
971 mirror::Object* o = gRegistry->Get<mirror::Object*>(object_id, &error);
Sebastien Hertze96060a2013-12-11 12:06:28 +0100972 // Unlike DisableCollection, JDWP specs do not state an invalid object causes an error. The RI
973 // also ignores these cases and never return an error. However it's not obvious why this command
974 // should behave differently from DisableCollection and IsCollected commands. So let's be more
975 // strict and return an error if this happens.
Ian Rogersc0542af2014-09-03 16:16:56 -0700976 if (o == nullptr) {
Sebastien Hertze96060a2013-12-11 12:06:28 +0100977 return JDWP::ERR_INVALID_OBJECT;
978 }
Elliott Hughes64f574f2013-02-20 14:57:12 -0800979 gRegistry->EnableCollection(object_id);
980 return JDWP::ERR_NONE;
981}
982
Ian Rogersc0542af2014-09-03 16:16:56 -0700983JDWP::JdwpError Dbg::IsCollected(JDWP::ObjectId object_id, bool* is_collected) {
984 *is_collected = true;
Sebastien Hertz65637eb2014-01-10 17:40:02 +0100985 if (object_id == 0) {
986 // Null object id is invalid.
Sebastien Hertze96060a2013-12-11 12:06:28 +0100987 return JDWP::ERR_INVALID_OBJECT;
988 }
Sebastien Hertz65637eb2014-01-10 17:40:02 +0100989 // JDWP specs state an INVALID_OBJECT error is returned if the object ID is not valid. However
990 // the RI seems to ignore this and assume object has been collected.
Ian Rogersc0542af2014-09-03 16:16:56 -0700991 JDWP::JdwpError error;
992 mirror::Object* o = gRegistry->Get<mirror::Object*>(object_id, &error);
993 if (o != nullptr) {
994 *is_collected = gRegistry->IsCollected(object_id);
Sebastien Hertz65637eb2014-01-10 17:40:02 +0100995 }
Elliott Hughes64f574f2013-02-20 14:57:12 -0800996 return JDWP::ERR_NONE;
997}
998
Ian Rogersc0542af2014-09-03 16:16:56 -0700999void Dbg::DisposeObject(JDWP::ObjectId object_id, uint32_t reference_count) {
Elliott Hughes64f574f2013-02-20 14:57:12 -08001000 gRegistry->DisposeObject(object_id, reference_count);
1001}
1002
Mathieu Chartier3398c782016-09-30 10:27:43 -07001003JDWP::JdwpTypeTag Dbg::GetTypeTag(ObjPtr<mirror::Class> klass) {
Sebastien Hertz4d8fd492014-03-28 16:29:41 +01001004 DCHECK(klass != nullptr);
1005 if (klass->IsArrayClass()) {
1006 return JDWP::TT_ARRAY;
1007 } else if (klass->IsInterface()) {
1008 return JDWP::TT_INTERFACE;
1009 } else {
1010 return JDWP::TT_CLASS;
1011 }
1012}
1013
Elliott Hughes88d63092013-01-09 09:55:54 -08001014JDWP::JdwpError Dbg::GetReflectedType(JDWP::RefTypeId class_id, JDWP::ExpandBuf* pReply) {
Ian Rogersc0542af2014-09-03 16:16:56 -07001015 JDWP::JdwpError error;
1016 mirror::Class* c = DecodeClass(class_id, &error);
1017 if (c == nullptr) {
1018 return error;
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -08001019 }
Elliott Hughes436e3722012-02-17 20:01:47 -08001020
Sebastien Hertz4d8fd492014-03-28 16:29:41 +01001021 JDWP::JdwpTypeTag type_tag = GetTypeTag(c);
1022 expandBufAdd1(pReply, type_tag);
Elliott Hughes88d63092013-01-09 09:55:54 -08001023 expandBufAddRefTypeId(pReply, class_id);
Elliott Hughes436e3722012-02-17 20:01:47 -08001024 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001025}
1026
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07001027// Get the complete list of reference classes (i.e. all classes except
1028// the primitive types).
1029// Returns a newly-allocated buffer full of RefTypeId values.
1030class ClassListCreator : public ClassVisitor {
1031 public:
1032 explicit ClassListCreator(std::vector<JDWP::RefTypeId>* classes) : classes_(classes) {}
1033
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001034 bool operator()(ObjPtr<mirror::Class> c) OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07001035 if (!c->IsPrimitive()) {
1036 classes_->push_back(Dbg::GetObjectRegistry()->AddRefType(c));
1037 }
1038 return true;
1039 }
1040
1041 private:
1042 std::vector<JDWP::RefTypeId>* const classes_;
1043};
1044
Ian Rogersc0542af2014-09-03 16:16:56 -07001045void Dbg::GetClassList(std::vector<JDWP::RefTypeId>* classes) {
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -08001046 ClassListCreator clc(classes);
Mathieu Chartiere0671ce2015-07-28 17:23:28 -07001047 Runtime::Current()->GetClassLinker()->VisitClassesWithoutClassesLock(&clc);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001048}
1049
Ian Rogers1ff3c982014-08-12 02:30:58 -07001050JDWP::JdwpError Dbg::GetClassInfo(JDWP::RefTypeId class_id, JDWP::JdwpTypeTag* pTypeTag,
1051 uint32_t* pStatus, std::string* pDescriptor) {
Ian Rogersc0542af2014-09-03 16:16:56 -07001052 JDWP::JdwpError error;
1053 mirror::Class* c = DecodeClass(class_id, &error);
1054 if (c == nullptr) {
1055 return error;
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -08001056 }
1057
Elliott Hughesa2155262011-11-16 16:26:58 -08001058 if (c->IsArrayClass()) {
1059 *pStatus = JDWP::CS_VERIFIED | JDWP::CS_PREPARED;
1060 *pTypeTag = JDWP::TT_ARRAY;
1061 } else {
1062 if (c->IsErroneous()) {
1063 *pStatus = JDWP::CS_ERROR;
1064 } else {
1065 *pStatus = JDWP::CS_VERIFIED | JDWP::CS_PREPARED | JDWP::CS_INITIALIZED;
1066 }
1067 *pTypeTag = c->IsInterface() ? JDWP::TT_INTERFACE : JDWP::TT_CLASS;
1068 }
1069
Ian Rogersc0542af2014-09-03 16:16:56 -07001070 if (pDescriptor != nullptr) {
Ian Rogers1ff3c982014-08-12 02:30:58 -07001071 std::string temp;
1072 *pDescriptor = c->GetDescriptor(&temp);
Elliott Hughesa2155262011-11-16 16:26:58 -08001073 }
Elliott Hughes436e3722012-02-17 20:01:47 -08001074 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001075}
1076
Ian Rogersc0542af2014-09-03 16:16:56 -07001077void Dbg::FindLoadedClassBySignature(const char* descriptor, std::vector<JDWP::RefTypeId>* ids) {
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001078 std::vector<ObjPtr<mirror::Class>> classes;
Igor Murashkinb1d8c312015-08-04 11:18:43 -07001079 Runtime::Current()->GetClassLinker()->LookupClasses(descriptor, classes);
Ian Rogersc0542af2014-09-03 16:16:56 -07001080 ids->clear();
Mathieu Chartier28357fa2016-10-18 16:27:40 -07001081 for (ObjPtr<mirror::Class> c : classes) {
1082 ids->push_back(gRegistry->Add(c));
Elliott Hughes6fa602d2011-12-02 17:54:25 -08001083 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001084}
1085
Ian Rogersc0542af2014-09-03 16:16:56 -07001086JDWP::JdwpError Dbg::GetReferenceType(JDWP::ObjectId object_id, JDWP::ExpandBuf* pReply) {
1087 JDWP::JdwpError error;
1088 mirror::Object* o = gRegistry->Get<mirror::Object*>(object_id, &error);
1089 if (o == nullptr) {
Elliott Hughes2435a572012-02-17 16:07:41 -08001090 return JDWP::ERR_INVALID_OBJECT;
Elliott Hughes499c5132011-11-17 14:55:11 -08001091 }
Elliott Hughes2435a572012-02-17 16:07:41 -08001092
Sebastien Hertz4d8fd492014-03-28 16:29:41 +01001093 JDWP::JdwpTypeTag type_tag = GetTypeTag(o->GetClass());
Elliott Hughes64f574f2013-02-20 14:57:12 -08001094 JDWP::RefTypeId type_id = gRegistry->AddRefType(o->GetClass());
Elliott Hughes2435a572012-02-17 16:07:41 -08001095
1096 expandBufAdd1(pReply, type_tag);
1097 expandBufAddRefTypeId(pReply, type_id);
1098
1099 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001100}
1101
Ian Rogersfc0e94b2013-09-23 23:51:32 -07001102JDWP::JdwpError Dbg::GetSignature(JDWP::RefTypeId class_id, std::string* signature) {
Ian Rogersc0542af2014-09-03 16:16:56 -07001103 JDWP::JdwpError error;
1104 mirror::Class* c = DecodeClass(class_id, &error);
1105 if (c == nullptr) {
1106 return error;
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -08001107 }
Ian Rogers1ff3c982014-08-12 02:30:58 -07001108 std::string temp;
1109 *signature = c->GetDescriptor(&temp);
Elliott Hughes1fe7afb2012-02-13 17:23:03 -08001110 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001111}
1112
Ian Rogersc0542af2014-09-03 16:16:56 -07001113JDWP::JdwpError Dbg::GetSourceFile(JDWP::RefTypeId class_id, std::string* result) {
1114 JDWP::JdwpError error;
1115 mirror::Class* c = DecodeClass(class_id, &error);
Sebastien Hertz4206eb52014-06-05 10:15:45 +02001116 if (c == nullptr) {
Ian Rogersc0542af2014-09-03 16:16:56 -07001117 return error;
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -08001118 }
Sebastien Hertz4206eb52014-06-05 10:15:45 +02001119 const char* source_file = c->GetSourceFile();
1120 if (source_file == nullptr) {
Sebastien Hertzb7054ba2014-03-13 11:52:31 +01001121 return JDWP::ERR_ABSENT_INFORMATION;
1122 }
Ian Rogersc0542af2014-09-03 16:16:56 -07001123 *result = source_file;
Elliott Hughes436e3722012-02-17 20:01:47 -08001124 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001125}
1126
Ian Rogersc0542af2014-09-03 16:16:56 -07001127JDWP::JdwpError Dbg::GetObjectTag(JDWP::ObjectId object_id, uint8_t* tag) {
Ian Rogers98379392014-02-24 16:53:16 -08001128 ScopedObjectAccessUnchecked soa(Thread::Current());
Ian Rogersc0542af2014-09-03 16:16:56 -07001129 JDWP::JdwpError error;
1130 mirror::Object* o = gRegistry->Get<mirror::Object*>(object_id, &error);
1131 if (error != JDWP::ERR_NONE) {
1132 *tag = JDWP::JT_VOID;
1133 return error;
Elliott Hughes546b9862012-06-20 16:06:13 -07001134 }
Ian Rogersc0542af2014-09-03 16:16:56 -07001135 *tag = TagFromObject(soa, o);
Elliott Hughes546b9862012-06-20 16:06:13 -07001136 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001137}
1138
Elliott Hughesaed4be92011-12-02 16:16:23 -08001139size_t Dbg::GetTagWidth(JDWP::JdwpTag tag) {
Elliott Hughesdbb40792011-11-18 17:05:22 -08001140 switch (tag) {
1141 case JDWP::JT_VOID:
1142 return 0;
1143 case JDWP::JT_BYTE:
1144 case JDWP::JT_BOOLEAN:
1145 return 1;
1146 case JDWP::JT_CHAR:
1147 case JDWP::JT_SHORT:
1148 return 2;
1149 case JDWP::JT_FLOAT:
1150 case JDWP::JT_INT:
1151 return 4;
1152 case JDWP::JT_ARRAY:
1153 case JDWP::JT_OBJECT:
1154 case JDWP::JT_STRING:
1155 case JDWP::JT_THREAD:
1156 case JDWP::JT_THREAD_GROUP:
1157 case JDWP::JT_CLASS_LOADER:
1158 case JDWP::JT_CLASS_OBJECT:
1159 return sizeof(JDWP::ObjectId);
1160 case JDWP::JT_DOUBLE:
1161 case JDWP::JT_LONG:
1162 return 8;
1163 default:
Elliott Hughes3d30d9b2011-12-07 17:35:48 -08001164 LOG(FATAL) << "Unknown tag " << tag;
Elliott Hughesdbb40792011-11-18 17:05:22 -08001165 return -1;
1166 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001167}
1168
Ian Rogersc0542af2014-09-03 16:16:56 -07001169JDWP::JdwpError Dbg::GetArrayLength(JDWP::ObjectId array_id, int32_t* length) {
1170 JDWP::JdwpError error;
1171 mirror::Array* a = DecodeNonNullArray(array_id, &error);
1172 if (a == nullptr) {
1173 return error;
Elliott Hughes24437992011-11-30 14:49:33 -08001174 }
Ian Rogersc0542af2014-09-03 16:16:56 -07001175 *length = a->GetLength();
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -08001176 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001177}
1178
Elliott Hughes88d63092013-01-09 09:55:54 -08001179JDWP::JdwpError Dbg::OutputArray(JDWP::ObjectId array_id, int offset, int count, JDWP::ExpandBuf* pReply) {
Ian Rogersc0542af2014-09-03 16:16:56 -07001180 JDWP::JdwpError error;
1181 mirror::Array* a = DecodeNonNullArray(array_id, &error);
Ian Rogers98379392014-02-24 16:53:16 -08001182 if (a == nullptr) {
Ian Rogersc0542af2014-09-03 16:16:56 -07001183 return error;
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -08001184 }
Elliott Hughes24437992011-11-30 14:49:33 -08001185
1186 if (offset < 0 || count < 0 || offset > a->GetLength() || a->GetLength() - offset < count) {
1187 LOG(WARNING) << __FUNCTION__ << " access out of bounds: offset=" << offset << "; count=" << count;
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -08001188 return JDWP::ERR_INVALID_LENGTH;
Elliott Hughes24437992011-11-30 14:49:33 -08001189 }
Ian Rogers1ff3c982014-08-12 02:30:58 -07001190 JDWP::JdwpTag element_tag = BasicTagFromClass(a->GetClass()->GetComponentType());
1191 expandBufAdd1(pReply, element_tag);
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -08001192 expandBufAdd4BE(pReply, count);
1193
Ian Rogers1ff3c982014-08-12 02:30:58 -07001194 if (IsPrimitiveTag(element_tag)) {
1195 size_t width = GetTagWidth(element_tag);
Elliott Hughes24437992011-11-30 14:49:33 -08001196 uint8_t* dst = expandBufAddSpace(pReply, count * width);
1197 if (width == 8) {
Ian Rogersef7d42f2014-01-06 12:55:46 -08001198 const uint64_t* src8 = reinterpret_cast<uint64_t*>(a->GetRawData(sizeof(uint64_t), 0));
Elliott Hughes24437992011-11-30 14:49:33 -08001199 for (int i = 0; i < count; ++i) JDWP::Write8BE(&dst, src8[offset + i]);
1200 } else if (width == 4) {
Ian Rogersef7d42f2014-01-06 12:55:46 -08001201 const uint32_t* src4 = reinterpret_cast<uint32_t*>(a->GetRawData(sizeof(uint32_t), 0));
Elliott Hughes24437992011-11-30 14:49:33 -08001202 for (int i = 0; i < count; ++i) JDWP::Write4BE(&dst, src4[offset + i]);
1203 } else if (width == 2) {
Ian Rogersef7d42f2014-01-06 12:55:46 -08001204 const uint16_t* src2 = reinterpret_cast<uint16_t*>(a->GetRawData(sizeof(uint16_t), 0));
Elliott Hughes24437992011-11-30 14:49:33 -08001205 for (int i = 0; i < count; ++i) JDWP::Write2BE(&dst, src2[offset + i]);
1206 } else {
Ian Rogersef7d42f2014-01-06 12:55:46 -08001207 const uint8_t* src = reinterpret_cast<uint8_t*>(a->GetRawData(sizeof(uint8_t), 0));
Elliott Hughes24437992011-11-30 14:49:33 -08001208 memcpy(dst, &src[offset * width], count * width);
1209 }
1210 } else {
Ian Rogers98379392014-02-24 16:53:16 -08001211 ScopedObjectAccessUnchecked soa(Thread::Current());
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001212 mirror::ObjectArray<mirror::Object>* oa = a->AsObjectArray<mirror::Object>();
Elliott Hughes24437992011-11-30 14:49:33 -08001213 for (int i = 0; i < count; ++i) {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001214 mirror::Object* element = oa->Get(offset + i);
Ian Rogers98379392014-02-24 16:53:16 -08001215 JDWP::JdwpTag specific_tag = (element != nullptr) ? TagFromObject(soa, element)
Ian Rogers1ff3c982014-08-12 02:30:58 -07001216 : element_tag;
Elliott Hughes24437992011-11-30 14:49:33 -08001217 expandBufAdd1(pReply, specific_tag);
1218 expandBufAddObjectId(pReply, gRegistry->Add(element));
1219 }
1220 }
1221
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -08001222 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001223}
1224
Ian Rogersef7d42f2014-01-06 12:55:46 -08001225template <typename T>
Ian Rogersc0542af2014-09-03 16:16:56 -07001226static void CopyArrayData(mirror::Array* a, JDWP::Request* src, int offset, int count)
Ian Rogersef7d42f2014-01-06 12:55:46 -08001227 NO_THREAD_SAFETY_ANALYSIS {
1228 // TODO: fix when annotalysis correctly handles non-member functions.
Elliott Hughes4b9702c2013-02-20 18:13:24 -08001229 DCHECK(a->GetClass()->IsPrimitiveArray());
1230
Ian Rogersef7d42f2014-01-06 12:55:46 -08001231 T* dst = reinterpret_cast<T*>(a->GetRawData(sizeof(T), offset));
Elliott Hughes4b9702c2013-02-20 18:13:24 -08001232 for (int i = 0; i < count; ++i) {
Ian Rogersc0542af2014-09-03 16:16:56 -07001233 *dst++ = src->ReadValue(sizeof(T));
Elliott Hughes4b9702c2013-02-20 18:13:24 -08001234 }
1235}
1236
Elliott Hughes88d63092013-01-09 09:55:54 -08001237JDWP::JdwpError Dbg::SetArrayElements(JDWP::ObjectId array_id, int offset, int count,
Ian Rogersc0542af2014-09-03 16:16:56 -07001238 JDWP::Request* request) {
1239 JDWP::JdwpError error;
1240 mirror::Array* dst = DecodeNonNullArray(array_id, &error);
1241 if (dst == nullptr) {
1242 return error;
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -08001243 }
Elliott Hughesf03b8f62011-12-02 14:26:25 -08001244
Elliott Hughes4b9702c2013-02-20 18:13:24 -08001245 if (offset < 0 || count < 0 || offset > dst->GetLength() || dst->GetLength() - offset < count) {
Elliott Hughesf03b8f62011-12-02 14:26:25 -08001246 LOG(WARNING) << __FUNCTION__ << " access out of bounds: offset=" << offset << "; count=" << count;
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -08001247 return JDWP::ERR_INVALID_LENGTH;
Elliott Hughesf03b8f62011-12-02 14:26:25 -08001248 }
Ian Rogers1ff3c982014-08-12 02:30:58 -07001249 JDWP::JdwpTag element_tag = BasicTagFromClass(dst->GetClass()->GetComponentType());
Elliott Hughesf03b8f62011-12-02 14:26:25 -08001250
Ian Rogers1ff3c982014-08-12 02:30:58 -07001251 if (IsPrimitiveTag(element_tag)) {
1252 size_t width = GetTagWidth(element_tag);
Elliott Hughesf03b8f62011-12-02 14:26:25 -08001253 if (width == 8) {
Elliott Hughes4b9702c2013-02-20 18:13:24 -08001254 CopyArrayData<uint64_t>(dst, request, offset, count);
Elliott Hughesf03b8f62011-12-02 14:26:25 -08001255 } else if (width == 4) {
Elliott Hughes4b9702c2013-02-20 18:13:24 -08001256 CopyArrayData<uint32_t>(dst, request, offset, count);
Elliott Hughesf03b8f62011-12-02 14:26:25 -08001257 } else if (width == 2) {
Elliott Hughes4b9702c2013-02-20 18:13:24 -08001258 CopyArrayData<uint16_t>(dst, request, offset, count);
Elliott Hughesf03b8f62011-12-02 14:26:25 -08001259 } else {
Elliott Hughes4b9702c2013-02-20 18:13:24 -08001260 CopyArrayData<uint8_t>(dst, request, offset, count);
Elliott Hughesf03b8f62011-12-02 14:26:25 -08001261 }
1262 } else {
Elliott Hughes4b9702c2013-02-20 18:13:24 -08001263 mirror::ObjectArray<mirror::Object>* oa = dst->AsObjectArray<mirror::Object>();
Elliott Hughesf03b8f62011-12-02 14:26:25 -08001264 for (int i = 0; i < count; ++i) {
Ian Rogersc0542af2014-09-03 16:16:56 -07001265 JDWP::ObjectId id = request->ReadObjectId();
Ian Rogersc0542af2014-09-03 16:16:56 -07001266 mirror::Object* o = gRegistry->Get<mirror::Object*>(id, &error);
1267 if (error != JDWP::ERR_NONE) {
1268 return error;
Elliott Hughes436e3722012-02-17 20:01:47 -08001269 }
Sebastien Hertz2e1c16d2015-08-28 11:57:49 +02001270 // Check if the object's type is compatible with the array's type.
1271 if (o != nullptr && !o->InstanceOf(oa->GetClass()->GetComponentType())) {
1272 return JDWP::ERR_TYPE_MISMATCH;
1273 }
Sebastien Hertzd2fe10a2014-01-15 10:20:56 +01001274 oa->Set<false>(offset + i, o);
Elliott Hughesf03b8f62011-12-02 14:26:25 -08001275 }
1276 }
1277
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -08001278 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001279}
1280
Sebastien Hertz2c3e77a2015-04-02 16:26:48 +02001281JDWP::JdwpError Dbg::CreateString(const std::string& str, JDWP::ObjectId* new_string_id) {
1282 Thread* self = Thread::Current();
1283 mirror::String* new_string = mirror::String::AllocFromModifiedUtf8(self, str.c_str());
1284 if (new_string == nullptr) {
1285 DCHECK(self->IsExceptionPending());
1286 self->ClearException();
1287 LOG(ERROR) << "Could not allocate string";
1288 *new_string_id = 0;
1289 return JDWP::ERR_OUT_OF_MEMORY;
1290 }
1291 *new_string_id = gRegistry->Add(new_string);
1292 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001293}
1294
Sebastien Hertz2c3e77a2015-04-02 16:26:48 +02001295JDWP::JdwpError Dbg::CreateObject(JDWP::RefTypeId class_id, JDWP::ObjectId* new_object_id) {
Ian Rogersc0542af2014-09-03 16:16:56 -07001296 JDWP::JdwpError error;
1297 mirror::Class* c = DecodeClass(class_id, &error);
1298 if (c == nullptr) {
Sebastien Hertz2c3e77a2015-04-02 16:26:48 +02001299 *new_object_id = 0;
Ian Rogersc0542af2014-09-03 16:16:56 -07001300 return error;
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -08001301 }
Sebastien Hertz2c3e77a2015-04-02 16:26:48 +02001302 Thread* self = Thread::Current();
Mathieu Chartier28bd2e42016-10-04 13:54:57 -07001303 ObjPtr<mirror::Object> new_object;
Sebastien Hertz56d5e502015-11-03 17:38:35 +01001304 if (c->IsStringClass()) {
1305 // Special case for java.lang.String.
1306 gc::AllocatorType allocator_type = Runtime::Current()->GetHeap()->GetCurrentAllocator();
jessicahandojo3aaa37b2016-07-29 14:46:37 -07001307 new_object = mirror::String::AllocEmptyString<true>(self, allocator_type);
Sebastien Hertz56d5e502015-11-03 17:38:35 +01001308 } else {
1309 new_object = c->AllocObject(self);
1310 }
Sebastien Hertz2c3e77a2015-04-02 16:26:48 +02001311 if (new_object == nullptr) {
1312 DCHECK(self->IsExceptionPending());
1313 self->ClearException();
David Sehr709b0702016-10-13 09:12:37 -07001314 LOG(ERROR) << "Could not allocate object of type " << mirror::Class::PrettyDescriptor(c);
Sebastien Hertz2c3e77a2015-04-02 16:26:48 +02001315 *new_object_id = 0;
1316 return JDWP::ERR_OUT_OF_MEMORY;
1317 }
Mathieu Chartier28bd2e42016-10-04 13:54:57 -07001318 *new_object_id = gRegistry->Add(new_object.Ptr());
Elliott Hughes436e3722012-02-17 20:01:47 -08001319 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001320}
1321
Elliott Hughesbf13d362011-12-08 15:51:37 -08001322/*
1323 * Used by Eclipse's "Display" view to evaluate "new byte[5]" to get "(byte[]) [0, 0, 0, 0, 0]".
1324 */
Elliott Hughes88d63092013-01-09 09:55:54 -08001325JDWP::JdwpError Dbg::CreateArrayObject(JDWP::RefTypeId array_class_id, uint32_t length,
Sebastien Hertz2c3e77a2015-04-02 16:26:48 +02001326 JDWP::ObjectId* new_array_id) {
Ian Rogersc0542af2014-09-03 16:16:56 -07001327 JDWP::JdwpError error;
1328 mirror::Class* c = DecodeClass(array_class_id, &error);
1329 if (c == nullptr) {
Sebastien Hertz2c3e77a2015-04-02 16:26:48 +02001330 *new_array_id = 0;
Ian Rogersc0542af2014-09-03 16:16:56 -07001331 return error;
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -08001332 }
Sebastien Hertz2c3e77a2015-04-02 16:26:48 +02001333 Thread* self = Thread::Current();
1334 gc::Heap* heap = Runtime::Current()->GetHeap();
1335 mirror::Array* new_array = mirror::Array::Alloc<true>(self, c, length,
1336 c->GetComponentSizeShift(),
1337 heap->GetCurrentAllocator());
1338 if (new_array == nullptr) {
1339 DCHECK(self->IsExceptionPending());
1340 self->ClearException();
David Sehr709b0702016-10-13 09:12:37 -07001341 LOG(ERROR) << "Could not allocate array of type " << mirror::Class::PrettyDescriptor(c);
Sebastien Hertz2c3e77a2015-04-02 16:26:48 +02001342 *new_array_id = 0;
1343 return JDWP::ERR_OUT_OF_MEMORY;
1344 }
1345 *new_array_id = gRegistry->Add(new_array);
Elliott Hughes436e3722012-02-17 20:01:47 -08001346 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001347}
1348
Mathieu Chartierc7853442015-03-27 14:35:38 -07001349JDWP::FieldId Dbg::ToFieldId(const ArtField* f) {
Elliott Hughes03181a82011-11-17 17:22:21 -08001350 return static_cast<JDWP::FieldId>(reinterpret_cast<uintptr_t>(f));
Elliott Hughes03181a82011-11-17 17:22:21 -08001351}
1352
Alex Light6c8467f2015-11-20 15:03:26 -08001353static JDWP::MethodId ToMethodId(ArtMethod* m)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001354 REQUIRES_SHARED(Locks::mutator_lock_) {
Alex Light6c8467f2015-11-20 15:03:26 -08001355 return static_cast<JDWP::MethodId>(reinterpret_cast<uintptr_t>(GetCanonicalMethod(m)));
Elliott Hughes03181a82011-11-17 17:22:21 -08001356}
1357
Mathieu Chartierc7853442015-03-27 14:35:38 -07001358static ArtField* FromFieldId(JDWP::FieldId fid)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001359 REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartierc7853442015-03-27 14:35:38 -07001360 return reinterpret_cast<ArtField*>(static_cast<uintptr_t>(fid));
Elliott Hughesaed4be92011-12-02 16:16:23 -08001361}
1362
Mathieu Chartiere401d142015-04-22 13:56:20 -07001363static ArtMethod* FromMethodId(JDWP::MethodId mid)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001364 REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07001365 return reinterpret_cast<ArtMethod*>(static_cast<uintptr_t>(mid));
Elliott Hughes03181a82011-11-17 17:22:21 -08001366}
1367
Sebastien Hertz6995c602014-09-09 12:10:13 +02001368bool Dbg::MatchThread(JDWP::ObjectId expected_thread_id, Thread* event_thread) {
1369 CHECK(event_thread != nullptr);
1370 JDWP::JdwpError error;
Mathieu Chartiere401d142015-04-22 13:56:20 -07001371 mirror::Object* expected_thread_peer = gRegistry->Get<mirror::Object*>(
1372 expected_thread_id, &error);
Sebastien Hertz6995c602014-09-09 12:10:13 +02001373 return expected_thread_peer == event_thread->GetPeer();
1374}
1375
1376bool Dbg::MatchLocation(const JDWP::JdwpLocation& expected_location,
1377 const JDWP::EventLocation& event_location) {
1378 if (expected_location.dex_pc != event_location.dex_pc) {
1379 return false;
1380 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07001381 ArtMethod* m = FromMethodId(expected_location.method_id);
Sebastien Hertz6995c602014-09-09 12:10:13 +02001382 return m == event_location.method;
1383}
1384
Mathieu Chartier3398c782016-09-30 10:27:43 -07001385bool Dbg::MatchType(ObjPtr<mirror::Class> event_class, JDWP::RefTypeId class_id) {
Sebastien Hertza9aa0ff2014-09-19 12:07:51 +02001386 if (event_class == nullptr) {
1387 return false;
1388 }
Sebastien Hertz6995c602014-09-09 12:10:13 +02001389 JDWP::JdwpError error;
Mathieu Chartier3398c782016-09-30 10:27:43 -07001390 ObjPtr<mirror::Class> expected_class = DecodeClass(class_id, &error);
Sebastien Hertz6995c602014-09-09 12:10:13 +02001391 CHECK(expected_class != nullptr);
1392 return expected_class->IsAssignableFrom(event_class);
1393}
1394
1395bool Dbg::MatchField(JDWP::RefTypeId expected_type_id, JDWP::FieldId expected_field_id,
Mathieu Chartierc7853442015-03-27 14:35:38 -07001396 ArtField* event_field) {
1397 ArtField* expected_field = FromFieldId(expected_field_id);
Sebastien Hertz6995c602014-09-09 12:10:13 +02001398 if (expected_field != event_field) {
1399 return false;
1400 }
1401 return Dbg::MatchType(event_field->GetDeclaringClass(), expected_type_id);
1402}
1403
1404bool Dbg::MatchInstance(JDWP::ObjectId expected_instance_id, mirror::Object* event_instance) {
1405 JDWP::JdwpError error;
1406 mirror::Object* modifier_instance = gRegistry->Get<mirror::Object*>(expected_instance_id, &error);
1407 return modifier_instance == event_instance;
1408}
1409
Mathieu Chartier90443472015-07-16 20:32:27 -07001410void Dbg::SetJdwpLocation(JDWP::JdwpLocation* location, ArtMethod* m, uint32_t dex_pc) {
Ian Rogersc0542af2014-09-03 16:16:56 -07001411 if (m == nullptr) {
Sebastien Hertza9aa0ff2014-09-19 12:07:51 +02001412 memset(location, 0, sizeof(*location));
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08001413 } else {
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001414 mirror::Class* c = m->GetDeclaringClass();
Ian Rogersc0542af2014-09-03 16:16:56 -07001415 location->type_tag = GetTypeTag(c);
1416 location->class_id = gRegistry->AddRefType(c);
1417 location->method_id = ToMethodId(m);
1418 location->dex_pc = (m->IsNative() || m->IsProxyMethod()) ? static_cast<uint64_t>(-1) : dex_pc;
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08001419 }
Elliott Hughesd07986f2011-12-06 18:27:45 -08001420}
1421
Ian Rogersc0542af2014-09-03 16:16:56 -07001422std::string Dbg::GetMethodName(JDWP::MethodId method_id) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07001423 ArtMethod* m = FromMethodId(method_id);
Sebastien Hertza9aa0ff2014-09-19 12:07:51 +02001424 if (m == nullptr) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001425 return "null";
Sebastien Hertza9aa0ff2014-09-19 12:07:51 +02001426 }
Andreas Gampe542451c2016-07-26 09:02:02 -07001427 return m->GetInterfaceMethodIfProxy(kRuntimePointerSize)->GetName();
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001428}
1429
Ian Rogersc0542af2014-09-03 16:16:56 -07001430std::string Dbg::GetFieldName(JDWP::FieldId field_id) {
Mathieu Chartierc7853442015-03-27 14:35:38 -07001431 ArtField* f = FromFieldId(field_id);
Sebastien Hertza9aa0ff2014-09-19 12:07:51 +02001432 if (f == nullptr) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001433 return "null";
Sebastien Hertza9aa0ff2014-09-19 12:07:51 +02001434 }
1435 return f->GetName();
Elliott Hughesa96836a2013-01-17 12:27:49 -08001436}
1437
Elliott Hughesa2e54f62011-11-17 13:01:30 -08001438/*
1439 * Augment the access flags for synthetic methods and fields by setting
1440 * the (as described by the spec) "0xf0000000 bit". Also, strip out any
1441 * flags not specified by the Java programming language.
1442 */
1443static uint32_t MangleAccessFlags(uint32_t accessFlags) {
1444 accessFlags &= kAccJavaFlagsMask;
1445 if ((accessFlags & kAccSynthetic) != 0) {
1446 accessFlags |= 0xf0000000;
1447 }
1448 return accessFlags;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001449}
1450
Elliott Hughesdbb40792011-11-18 17:05:22 -08001451/*
Jeff Haob7cefc72013-11-14 14:51:09 -08001452 * Circularly shifts registers so that arguments come first. Debuggers
1453 * expect slots to begin with arguments, but dex code places them at
1454 * the end.
Elliott Hughesdbb40792011-11-18 17:05:22 -08001455 */
Mathieu Chartiere401d142015-04-22 13:56:20 -07001456static uint16_t MangleSlot(uint16_t slot, ArtMethod* m)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001457 REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07001458 const DexFile::CodeItem* code_item = m->GetCodeItem();
Sebastien Hertzcb19ebf2014-03-11 15:26:35 +01001459 if (code_item == nullptr) {
1460 // We should not get here for a method without code (native, proxy or abstract). Log it and
1461 // return the slot as is since all registers are arguments.
David Sehr709b0702016-10-13 09:12:37 -07001462 LOG(WARNING) << "Trying to mangle slot for method without code " << m->PrettyMethod();
Sebastien Hertzcb19ebf2014-03-11 15:26:35 +01001463 return slot;
1464 }
Jeff Haob7cefc72013-11-14 14:51:09 -08001465 uint16_t ins_size = code_item->ins_size_;
1466 uint16_t locals_size = code_item->registers_size_ - ins_size;
1467 if (slot >= locals_size) {
1468 return slot - locals_size;
1469 } else {
1470 return slot + ins_size;
Elliott Hughesdbb40792011-11-18 17:05:22 -08001471 }
Elliott Hughesdbb40792011-11-18 17:05:22 -08001472}
1473
Sebastien Hertzaef0c912016-08-08 10:20:28 +02001474static size_t GetMethodNumArgRegistersIncludingThis(ArtMethod* method)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001475 REQUIRES_SHARED(Locks::mutator_lock_) {
Sebastien Hertzaef0c912016-08-08 10:20:28 +02001476 uint32_t num_registers = ArtMethod::NumArgRegisters(method->GetShorty());
1477 if (!method->IsStatic()) {
1478 ++num_registers;
1479 }
1480 return num_registers;
1481}
1482
Jeff Haob7cefc72013-11-14 14:51:09 -08001483/*
1484 * Circularly shifts registers so that arguments come last. Reverts
1485 * slots to dex style argument placement.
1486 */
Mathieu Chartiere401d142015-04-22 13:56:20 -07001487static uint16_t DemangleSlot(uint16_t slot, ArtMethod* m, JDWP::JdwpError* error)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001488 REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07001489 const DexFile::CodeItem* code_item = m->GetCodeItem();
Sebastien Hertzcb19ebf2014-03-11 15:26:35 +01001490 if (code_item == nullptr) {
1491 // We should not get here for a method without code (native, proxy or abstract). Log it and
1492 // return the slot as is since all registers are arguments.
David Sehr709b0702016-10-13 09:12:37 -07001493 LOG(WARNING) << "Trying to demangle slot for method without code "
1494 << m->PrettyMethod();
Sebastien Hertzaef0c912016-08-08 10:20:28 +02001495 uint16_t vreg_count = GetMethodNumArgRegistersIncludingThis(m);
Sebastien Hertzabbabc82015-03-26 08:47:47 +01001496 if (slot < vreg_count) {
1497 *error = JDWP::ERR_NONE;
1498 return slot;
1499 }
Jeff Haob7cefc72013-11-14 14:51:09 -08001500 } else {
Sebastien Hertzabbabc82015-03-26 08:47:47 +01001501 if (slot < code_item->registers_size_) {
1502 uint16_t ins_size = code_item->ins_size_;
1503 uint16_t locals_size = code_item->registers_size_ - ins_size;
1504 *error = JDWP::ERR_NONE;
1505 return (slot < ins_size) ? slot + locals_size : slot - ins_size;
1506 }
Elliott Hughesdbb40792011-11-18 17:05:22 -08001507 }
Sebastien Hertzabbabc82015-03-26 08:47:47 +01001508
1509 // Slot is invalid in the method.
David Sehr709b0702016-10-13 09:12:37 -07001510 LOG(ERROR) << "Invalid local slot " << slot << " for method " << m->PrettyMethod();
Sebastien Hertzabbabc82015-03-26 08:47:47 +01001511 *error = JDWP::ERR_INVALID_SLOT;
1512 return DexFile::kDexNoIndex16;
Elliott Hughesdbb40792011-11-18 17:05:22 -08001513}
1514
Mathieu Chartier90443472015-07-16 20:32:27 -07001515JDWP::JdwpError Dbg::OutputDeclaredFields(JDWP::RefTypeId class_id, bool with_generic,
1516 JDWP::ExpandBuf* pReply) {
Ian Rogersc0542af2014-09-03 16:16:56 -07001517 JDWP::JdwpError error;
1518 mirror::Class* c = DecodeClass(class_id, &error);
1519 if (c == nullptr) {
1520 return error;
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -08001521 }
Elliott Hughesa2e54f62011-11-17 13:01:30 -08001522
1523 size_t instance_field_count = c->NumInstanceFields();
1524 size_t static_field_count = c->NumStaticFields();
1525
1526 expandBufAdd4BE(pReply, instance_field_count + static_field_count);
1527
1528 for (size_t i = 0; i < instance_field_count + static_field_count; ++i) {
Mathieu Chartier90443472015-07-16 20:32:27 -07001529 ArtField* f = (i < instance_field_count) ? c->GetInstanceField(i) :
1530 c->GetStaticField(i - instance_field_count);
Elliott Hughesa2e54f62011-11-17 13:01:30 -08001531 expandBufAddFieldId(pReply, ToFieldId(f));
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -07001532 expandBufAddUtf8String(pReply, f->GetName());
1533 expandBufAddUtf8String(pReply, f->GetTypeDescriptor());
Elliott Hughesc5b734a2011-12-01 17:20:58 -08001534 if (with_generic) {
Elliott Hughesa2e54f62011-11-17 13:01:30 -08001535 static const char genericSignature[1] = "";
1536 expandBufAddUtf8String(pReply, genericSignature);
1537 }
1538 expandBufAdd4BE(pReply, MangleAccessFlags(f->GetAccessFlags()));
1539 }
Elliott Hughes436e3722012-02-17 20:01:47 -08001540 return JDWP::ERR_NONE;
Elliott Hughesa2e54f62011-11-17 13:01:30 -08001541}
1542
Elliott Hughes88d63092013-01-09 09:55:54 -08001543JDWP::JdwpError Dbg::OutputDeclaredMethods(JDWP::RefTypeId class_id, bool with_generic,
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001544 JDWP::ExpandBuf* pReply) {
Ian Rogersc0542af2014-09-03 16:16:56 -07001545 JDWP::JdwpError error;
1546 mirror::Class* c = DecodeClass(class_id, &error);
1547 if (c == nullptr) {
1548 return error;
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -08001549 }
Elliott Hughesa2e54f62011-11-17 13:01:30 -08001550
Alex Light51a64d52015-12-17 13:55:59 -08001551 expandBufAdd4BE(pReply, c->NumMethods());
Elliott Hughesa2e54f62011-11-17 13:01:30 -08001552
Mathieu Chartiere401d142015-04-22 13:56:20 -07001553 auto* cl = Runtime::Current()->GetClassLinker();
1554 auto ptr_size = cl->GetImagePointerSize();
Alex Light51a64d52015-12-17 13:55:59 -08001555 for (ArtMethod& m : c->GetMethods(ptr_size)) {
1556 expandBufAddMethodId(pReply, ToMethodId(&m));
Andreas Gampe542451c2016-07-26 09:02:02 -07001557 expandBufAddUtf8String(pReply, m.GetInterfaceMethodIfProxy(kRuntimePointerSize)->GetName());
1558 expandBufAddUtf8String(
1559 pReply, m.GetInterfaceMethodIfProxy(kRuntimePointerSize)->GetSignature().ToString());
Elliott Hughesc5b734a2011-12-01 17:20:58 -08001560 if (with_generic) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07001561 const char* generic_signature = "";
1562 expandBufAddUtf8String(pReply, generic_signature);
Elliott Hughesa2e54f62011-11-17 13:01:30 -08001563 }
Alex Light51a64d52015-12-17 13:55:59 -08001564 expandBufAdd4BE(pReply, MangleAccessFlags(m.GetAccessFlags()));
Elliott Hughesa2e54f62011-11-17 13:01:30 -08001565 }
Elliott Hughes436e3722012-02-17 20:01:47 -08001566 return JDWP::ERR_NONE;
Elliott Hughesa2e54f62011-11-17 13:01:30 -08001567}
1568
Elliott Hughes88d63092013-01-09 09:55:54 -08001569JDWP::JdwpError Dbg::OutputDeclaredInterfaces(JDWP::RefTypeId class_id, JDWP::ExpandBuf* pReply) {
Ian Rogersc0542af2014-09-03 16:16:56 -07001570 JDWP::JdwpError error;
Mathieu Chartierf8322842014-05-16 10:59:25 -07001571 Thread* self = Thread::Current();
Vladimir Marko19a4d372016-12-08 14:41:46 +00001572 ObjPtr<mirror::Class> c = DecodeClass(class_id, &error);
1573 if (c == nullptr) {
Ian Rogersc0542af2014-09-03 16:16:56 -07001574 return error;
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -08001575 }
Mathieu Chartierf8322842014-05-16 10:59:25 -07001576 size_t interface_count = c->NumDirectInterfaces();
Elliott Hughesa2e54f62011-11-17 13:01:30 -08001577 expandBufAdd4BE(pReply, interface_count);
1578 for (size_t i = 0; i < interface_count; ++i) {
Vladimir Marko19a4d372016-12-08 14:41:46 +00001579 ObjPtr<mirror::Class> interface = mirror::Class::GetDirectInterface(self, c, i);
1580 DCHECK(interface != nullptr);
1581 expandBufAddRefTypeId(pReply, gRegistry->AddRefType(interface));
Elliott Hughesa2e54f62011-11-17 13:01:30 -08001582 }
Elliott Hughes436e3722012-02-17 20:01:47 -08001583 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001584}
1585
Ian Rogersc0542af2014-09-03 16:16:56 -07001586void Dbg::OutputLineTable(JDWP::RefTypeId, JDWP::MethodId method_id, JDWP::ExpandBuf* pReply) {
Elliott Hughes03181a82011-11-17 17:22:21 -08001587 struct DebugCallbackContext {
1588 int numItems;
1589 JDWP::ExpandBuf* pReply;
1590
David Srbeckyb06e28e2015-12-10 13:15:00 +00001591 static bool Callback(void* context, const DexFile::PositionInfo& entry) {
Elliott Hughes03181a82011-11-17 17:22:21 -08001592 DebugCallbackContext* pContext = reinterpret_cast<DebugCallbackContext*>(context);
David Srbeckyb06e28e2015-12-10 13:15:00 +00001593 expandBufAdd8BE(pContext->pReply, entry.address_);
1594 expandBufAdd4BE(pContext->pReply, entry.line_);
Elliott Hughes03181a82011-11-17 17:22:21 -08001595 pContext->numItems++;
Sebastien Hertzf2910ee2013-10-19 16:39:24 +02001596 return false;
Elliott Hughes03181a82011-11-17 17:22:21 -08001597 }
1598 };
Mathieu Chartiere401d142015-04-22 13:56:20 -07001599 ArtMethod* m = FromMethodId(method_id);
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07001600 const DexFile::CodeItem* code_item = m->GetCodeItem();
Elliott Hughes03181a82011-11-17 17:22:21 -08001601 uint64_t start, end;
Sebastien Hertzcb19ebf2014-03-11 15:26:35 +01001602 if (code_item == nullptr) {
1603 DCHECK(m->IsNative() || m->IsProxyMethod());
Elliott Hughes03181a82011-11-17 17:22:21 -08001604 start = -1;
1605 end = -1;
1606 } else {
1607 start = 0;
jeffhao14f0db92012-12-14 17:50:42 -08001608 // Return the index of the last instruction
Sebastien Hertzcb19ebf2014-03-11 15:26:35 +01001609 end = code_item->insns_size_in_code_units_ - 1;
Elliott Hughes03181a82011-11-17 17:22:21 -08001610 }
1611
1612 expandBufAdd8BE(pReply, start);
1613 expandBufAdd8BE(pReply, end);
1614
1615 // Add numLines later
1616 size_t numLinesOffset = expandBufGetLength(pReply);
1617 expandBufAdd4BE(pReply, 0);
1618
1619 DebugCallbackContext context;
1620 context.numItems = 0;
1621 context.pReply = pReply;
1622
Sebastien Hertzcb19ebf2014-03-11 15:26:35 +01001623 if (code_item != nullptr) {
David Srbeckyb06e28e2015-12-10 13:15:00 +00001624 m->GetDexFile()->DecodeDebugPositionInfo(code_item, DebugCallbackContext::Callback, &context);
Sebastien Hertzcb19ebf2014-03-11 15:26:35 +01001625 }
Elliott Hughes03181a82011-11-17 17:22:21 -08001626
1627 JDWP::Set4BE(expandBufGetBuffer(pReply) + numLinesOffset, context.numItems);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001628}
1629
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07001630void Dbg::OutputVariableTable(JDWP::RefTypeId, JDWP::MethodId method_id, bool with_generic,
1631 JDWP::ExpandBuf* pReply) {
Elliott Hughesdbb40792011-11-18 17:05:22 -08001632 struct DebugCallbackContext {
Mathieu Chartiere401d142015-04-22 13:56:20 -07001633 ArtMethod* method;
Elliott Hughesdbb40792011-11-18 17:05:22 -08001634 JDWP::ExpandBuf* pReply;
Elliott Hughesc5b734a2011-12-01 17:20:58 -08001635 size_t variable_count;
1636 bool with_generic;
Elliott Hughesdbb40792011-11-18 17:05:22 -08001637
David Srbeckyb06e28e2015-12-10 13:15:00 +00001638 static void Callback(void* context, const DexFile::LocalInfo& entry)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001639 REQUIRES_SHARED(Locks::mutator_lock_) {
Elliott Hughesdbb40792011-11-18 17:05:22 -08001640 DebugCallbackContext* pContext = reinterpret_cast<DebugCallbackContext*>(context);
1641
David Srbeckyb06e28e2015-12-10 13:15:00 +00001642 uint16_t slot = entry.reg_;
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07001643 VLOG(jdwp) << StringPrintf(" %2zd: %d(%d) '%s' '%s' '%s' actual slot=%d mangled slot=%d",
David Srbeckyb06e28e2015-12-10 13:15:00 +00001644 pContext->variable_count, entry.start_address_,
1645 entry.end_address_ - entry.start_address_,
1646 entry.name_, entry.descriptor_, entry.signature_, slot,
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07001647 MangleSlot(slot, pContext->method));
Elliott Hughesdbb40792011-11-18 17:05:22 -08001648
Jeff Haob7cefc72013-11-14 14:51:09 -08001649 slot = MangleSlot(slot, pContext->method);
Elliott Hughes68fdbd02011-11-29 19:22:47 -08001650
David Srbeckyb06e28e2015-12-10 13:15:00 +00001651 expandBufAdd8BE(pContext->pReply, entry.start_address_);
1652 expandBufAddUtf8String(pContext->pReply, entry.name_);
1653 expandBufAddUtf8String(pContext->pReply, entry.descriptor_);
Elliott Hughesc5b734a2011-12-01 17:20:58 -08001654 if (pContext->with_generic) {
David Srbeckyb06e28e2015-12-10 13:15:00 +00001655 expandBufAddUtf8String(pContext->pReply, entry.signature_);
Elliott Hughesdbb40792011-11-18 17:05:22 -08001656 }
David Srbeckyb06e28e2015-12-10 13:15:00 +00001657 expandBufAdd4BE(pContext->pReply, entry.end_address_- entry.start_address_);
Elliott Hughesdbb40792011-11-18 17:05:22 -08001658 expandBufAdd4BE(pContext->pReply, slot);
1659
Elliott Hughesc5b734a2011-12-01 17:20:58 -08001660 ++pContext->variable_count;
Elliott Hughesdbb40792011-11-18 17:05:22 -08001661 }
1662 };
Mathieu Chartiere401d142015-04-22 13:56:20 -07001663 ArtMethod* m = FromMethodId(method_id);
Elliott Hughesdbb40792011-11-18 17:05:22 -08001664
Elliott Hughesc5b734a2011-12-01 17:20:58 -08001665 // arg_count considers doubles and longs to take 2 units.
1666 // variable_count considers everything to take 1 unit.
Sebastien Hertzaef0c912016-08-08 10:20:28 +02001667 expandBufAdd4BE(pReply, GetMethodNumArgRegistersIncludingThis(m));
Elliott Hughesdbb40792011-11-18 17:05:22 -08001668
Elliott Hughesc5b734a2011-12-01 17:20:58 -08001669 // We don't know the total number of variables yet, so leave a blank and update it later.
1670 size_t variable_count_offset = expandBufGetLength(pReply);
Elliott Hughesdbb40792011-11-18 17:05:22 -08001671 expandBufAdd4BE(pReply, 0);
1672
1673 DebugCallbackContext context;
Jeff Haob7cefc72013-11-14 14:51:09 -08001674 context.method = m;
Elliott Hughesdbb40792011-11-18 17:05:22 -08001675 context.pReply = pReply;
Elliott Hughesc5b734a2011-12-01 17:20:58 -08001676 context.variable_count = 0;
1677 context.with_generic = with_generic;
Elliott Hughesdbb40792011-11-18 17:05:22 -08001678
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07001679 const DexFile::CodeItem* code_item = m->GetCodeItem();
Sebastien Hertzcb19ebf2014-03-11 15:26:35 +01001680 if (code_item != nullptr) {
David Srbeckyb06e28e2015-12-10 13:15:00 +00001681 m->GetDexFile()->DecodeDebugLocalInfo(
1682 code_item, m->IsStatic(), m->GetDexMethodIndex(), DebugCallbackContext::Callback,
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07001683 &context);
Sebastien Hertzcb19ebf2014-03-11 15:26:35 +01001684 }
Elliott Hughesdbb40792011-11-18 17:05:22 -08001685
Elliott Hughesc5b734a2011-12-01 17:20:58 -08001686 JDWP::Set4BE(expandBufGetBuffer(pReply) + variable_count_offset, context.variable_count);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001687}
1688
Jeff Hao579b0242013-11-18 13:16:49 -08001689void Dbg::OutputMethodReturnValue(JDWP::MethodId method_id, const JValue* return_value,
1690 JDWP::ExpandBuf* pReply) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07001691 ArtMethod* m = FromMethodId(method_id);
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07001692 JDWP::JdwpTag tag = BasicTagFromDescriptor(m->GetShorty());
Jeff Hao579b0242013-11-18 13:16:49 -08001693 OutputJValue(tag, return_value, pReply);
1694}
1695
Sebastien Hertz3f52eaf2014-04-04 17:50:18 +02001696void Dbg::OutputFieldValue(JDWP::FieldId field_id, const JValue* field_value,
1697 JDWP::ExpandBuf* pReply) {
Mathieu Chartierc7853442015-03-27 14:35:38 -07001698 ArtField* f = FromFieldId(field_id);
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -07001699 JDWP::JdwpTag tag = BasicTagFromDescriptor(f->GetTypeDescriptor());
Sebastien Hertz3f52eaf2014-04-04 17:50:18 +02001700 OutputJValue(tag, field_value, pReply);
1701}
1702
Elliott Hughes9777ba22013-01-17 09:04:19 -08001703JDWP::JdwpError Dbg::GetBytecodes(JDWP::RefTypeId, JDWP::MethodId method_id,
Ian Rogersc0542af2014-09-03 16:16:56 -07001704 std::vector<uint8_t>* bytecodes) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07001705 ArtMethod* m = FromMethodId(method_id);
Ian Rogersc0542af2014-09-03 16:16:56 -07001706 if (m == nullptr) {
Elliott Hughes9777ba22013-01-17 09:04:19 -08001707 return JDWP::ERR_INVALID_METHODID;
1708 }
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07001709 const DexFile::CodeItem* code_item = m->GetCodeItem();
Elliott Hughes9777ba22013-01-17 09:04:19 -08001710 size_t byte_count = code_item->insns_size_in_code_units_ * 2;
1711 const uint8_t* begin = reinterpret_cast<const uint8_t*>(code_item->insns_);
1712 const uint8_t* end = begin + byte_count;
1713 for (const uint8_t* p = begin; p != end; ++p) {
Ian Rogersc0542af2014-09-03 16:16:56 -07001714 bytecodes->push_back(*p);
Elliott Hughes9777ba22013-01-17 09:04:19 -08001715 }
1716 return JDWP::ERR_NONE;
1717}
1718
Elliott Hughes88d63092013-01-09 09:55:54 -08001719JDWP::JdwpTag Dbg::GetFieldBasicTag(JDWP::FieldId field_id) {
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -07001720 return BasicTagFromDescriptor(FromFieldId(field_id)->GetTypeDescriptor());
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001721}
1722
Elliott Hughes88d63092013-01-09 09:55:54 -08001723JDWP::JdwpTag Dbg::GetStaticFieldBasicTag(JDWP::FieldId field_id) {
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -07001724 return BasicTagFromDescriptor(FromFieldId(field_id)->GetTypeDescriptor());
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001725}
1726
Sebastien Hertz05c26b32015-06-11 18:42:58 +02001727static JValue GetArtFieldValue(ArtField* f, mirror::Object* o)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001728 REQUIRES_SHARED(Locks::mutator_lock_) {
Sebastien Hertz05c26b32015-06-11 18:42:58 +02001729 Primitive::Type fieldType = f->GetTypeAsPrimitiveType();
1730 JValue field_value;
1731 switch (fieldType) {
1732 case Primitive::kPrimBoolean:
1733 field_value.SetZ(f->GetBoolean(o));
1734 return field_value;
1735
1736 case Primitive::kPrimByte:
1737 field_value.SetB(f->GetByte(o));
1738 return field_value;
1739
1740 case Primitive::kPrimChar:
1741 field_value.SetC(f->GetChar(o));
1742 return field_value;
1743
1744 case Primitive::kPrimShort:
1745 field_value.SetS(f->GetShort(o));
1746 return field_value;
1747
1748 case Primitive::kPrimInt:
1749 case Primitive::kPrimFloat:
1750 // Int and Float must be treated as 32-bit values in JDWP.
1751 field_value.SetI(f->GetInt(o));
1752 return field_value;
1753
1754 case Primitive::kPrimLong:
1755 case Primitive::kPrimDouble:
1756 // Long and Double must be treated as 64-bit values in JDWP.
1757 field_value.SetJ(f->GetLong(o));
1758 return field_value;
1759
1760 case Primitive::kPrimNot:
Mathieu Chartier1cc62e42016-10-03 18:01:28 -07001761 field_value.SetL(f->GetObject(o).Ptr());
Sebastien Hertz05c26b32015-06-11 18:42:58 +02001762 return field_value;
1763
1764 case Primitive::kPrimVoid:
1765 LOG(FATAL) << "Attempt to read from field of type 'void'";
1766 UNREACHABLE();
1767 }
1768 LOG(FATAL) << "Attempt to read from field of unknown type";
1769 UNREACHABLE();
1770}
1771
Elliott Hughes88d63092013-01-09 09:55:54 -08001772static JDWP::JdwpError GetFieldValueImpl(JDWP::RefTypeId ref_type_id, JDWP::ObjectId object_id,
1773 JDWP::FieldId field_id, JDWP::ExpandBuf* pReply,
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001774 bool is_static)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001775 REQUIRES_SHARED(Locks::mutator_lock_) {
Ian Rogersc0542af2014-09-03 16:16:56 -07001776 JDWP::JdwpError error;
1777 mirror::Class* c = DecodeClass(ref_type_id, &error);
1778 if (ref_type_id != 0 && c == nullptr) {
1779 return error;
Elliott Hughes0cf74332012-02-23 23:14:00 -08001780 }
1781
Jeff Haode19a252016-09-14 15:56:35 -07001782 Thread* self = Thread::Current();
1783 StackHandleScope<2> hs(self);
1784 MutableHandle<mirror::Object>
1785 o(hs.NewHandle(Dbg::GetObjectRegistry()->Get<mirror::Object*>(object_id, &error)));
1786 if ((!is_static && o.Get() == nullptr) || error != JDWP::ERR_NONE) {
Elliott Hughes3f4d58f2012-02-18 20:05:37 -08001787 return JDWP::ERR_INVALID_OBJECT;
1788 }
Mathieu Chartierc7853442015-03-27 14:35:38 -07001789 ArtField* f = FromFieldId(field_id);
Elliott Hughes0cf74332012-02-23 23:14:00 -08001790
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08001791 mirror::Class* receiver_class = c;
Jeff Haode19a252016-09-14 15:56:35 -07001792 if (receiver_class == nullptr && o.Get() != nullptr) {
Elliott Hughes0cf74332012-02-23 23:14:00 -08001793 receiver_class = o->GetClass();
1794 }
Jeff Haode19a252016-09-14 15:56:35 -07001795
Mathieu Chartier2cebb242015-04-21 16:50:40 -07001796 // TODO: should we give up now if receiver_class is null?
Ian Rogersc0542af2014-09-03 16:16:56 -07001797 if (receiver_class != nullptr && !f->GetDeclaringClass()->IsAssignableFrom(receiver_class)) {
David Sehr709b0702016-10-13 09:12:37 -07001798 LOG(INFO) << "ERR_INVALID_FIELDID: " << f->PrettyField() << " "
1799 << receiver_class->PrettyClass();
Elliott Hughes3f4d58f2012-02-18 20:05:37 -08001800 return JDWP::ERR_INVALID_FIELDID;
1801 }
Elliott Hughesaed4be92011-12-02 16:16:23 -08001802
Jeff Haode19a252016-09-14 15:56:35 -07001803 // Ensure the field's class is initialized.
1804 Handle<mirror::Class> klass(hs.NewHandle(f->GetDeclaringClass()));
1805 if (!Runtime::Current()->GetClassLinker()->EnsureInitialized(self, klass, true, false)) {
David Sehr709b0702016-10-13 09:12:37 -07001806 LOG(WARNING) << "Not able to initialize class for SetValues: "
1807 << mirror::Class::PrettyClass(klass.Get());
Jeff Haode19a252016-09-14 15:56:35 -07001808 }
1809
Elliott Hughes0cf74332012-02-23 23:14:00 -08001810 // The RI only enforces the static/non-static mismatch in one direction.
1811 // TODO: should we change the tests and check both?
1812 if (is_static) {
1813 if (!f->IsStatic()) {
1814 return JDWP::ERR_INVALID_FIELDID;
1815 }
1816 } else {
1817 if (f->IsStatic()) {
Sebastien Hertz05c26b32015-06-11 18:42:58 +02001818 LOG(WARNING) << "Ignoring non-nullptr receiver for ObjectReference.GetValues"
David Sehr709b0702016-10-13 09:12:37 -07001819 << " on static field " << f->PrettyField();
Elliott Hughes0cf74332012-02-23 23:14:00 -08001820 }
1821 }
jeffhao0dfbb7e2012-11-28 15:26:03 -08001822 if (f->IsStatic()) {
Jeff Haode19a252016-09-14 15:56:35 -07001823 o.Assign(f->GetDeclaringClass());
jeffhao0dfbb7e2012-11-28 15:26:03 -08001824 }
Elliott Hughes0cf74332012-02-23 23:14:00 -08001825
Jeff Haode19a252016-09-14 15:56:35 -07001826 JValue field_value(GetArtFieldValue(f, o.Get()));
Mathieu Chartier61c5ebc2014-06-05 17:42:53 -07001827 JDWP::JdwpTag tag = BasicTagFromDescriptor(f->GetTypeDescriptor());
Jeff Hao579b0242013-11-18 13:16:49 -08001828 Dbg::OutputJValue(tag, &field_value, pReply);
Elliott Hughes3f4d58f2012-02-18 20:05:37 -08001829 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001830}
1831
Elliott Hughes88d63092013-01-09 09:55:54 -08001832JDWP::JdwpError Dbg::GetFieldValue(JDWP::ObjectId object_id, JDWP::FieldId field_id,
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001833 JDWP::ExpandBuf* pReply) {
Elliott Hughes88d63092013-01-09 09:55:54 -08001834 return GetFieldValueImpl(0, object_id, field_id, pReply, false);
Elliott Hughes3f4d58f2012-02-18 20:05:37 -08001835}
1836
Ian Rogersc0542af2014-09-03 16:16:56 -07001837JDWP::JdwpError Dbg::GetStaticFieldValue(JDWP::RefTypeId ref_type_id, JDWP::FieldId field_id,
1838 JDWP::ExpandBuf* pReply) {
Elliott Hughes88d63092013-01-09 09:55:54 -08001839 return GetFieldValueImpl(ref_type_id, 0, field_id, pReply, true);
Elliott Hughes3f4d58f2012-02-18 20:05:37 -08001840}
1841
Sebastien Hertz05c26b32015-06-11 18:42:58 +02001842static JDWP::JdwpError SetArtFieldValue(ArtField* f, mirror::Object* o, uint64_t value, int width)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001843 REQUIRES_SHARED(Locks::mutator_lock_) {
Sebastien Hertz05c26b32015-06-11 18:42:58 +02001844 Primitive::Type fieldType = f->GetTypeAsPrimitiveType();
1845 // Debugging only happens at runtime so we know we are not running in a transaction.
1846 static constexpr bool kNoTransactionMode = false;
1847 switch (fieldType) {
1848 case Primitive::kPrimBoolean:
1849 CHECK_EQ(width, 1);
1850 f->SetBoolean<kNoTransactionMode>(o, static_cast<uint8_t>(value));
1851 return JDWP::ERR_NONE;
1852
1853 case Primitive::kPrimByte:
1854 CHECK_EQ(width, 1);
1855 f->SetByte<kNoTransactionMode>(o, static_cast<uint8_t>(value));
1856 return JDWP::ERR_NONE;
1857
1858 case Primitive::kPrimChar:
1859 CHECK_EQ(width, 2);
1860 f->SetChar<kNoTransactionMode>(o, static_cast<uint16_t>(value));
1861 return JDWP::ERR_NONE;
1862
1863 case Primitive::kPrimShort:
1864 CHECK_EQ(width, 2);
1865 f->SetShort<kNoTransactionMode>(o, static_cast<int16_t>(value));
1866 return JDWP::ERR_NONE;
1867
1868 case Primitive::kPrimInt:
1869 case Primitive::kPrimFloat:
1870 CHECK_EQ(width, 4);
1871 // Int and Float must be treated as 32-bit values in JDWP.
1872 f->SetInt<kNoTransactionMode>(o, static_cast<int32_t>(value));
1873 return JDWP::ERR_NONE;
1874
1875 case Primitive::kPrimLong:
1876 case Primitive::kPrimDouble:
1877 CHECK_EQ(width, 8);
1878 // Long and Double must be treated as 64-bit values in JDWP.
1879 f->SetLong<kNoTransactionMode>(o, value);
1880 return JDWP::ERR_NONE;
1881
1882 case Primitive::kPrimNot: {
1883 JDWP::JdwpError error;
1884 mirror::Object* v = Dbg::GetObjectRegistry()->Get<mirror::Object*>(value, &error);
1885 if (error != JDWP::ERR_NONE) {
1886 return JDWP::ERR_INVALID_OBJECT;
1887 }
1888 if (v != nullptr) {
Mathieu Chartier3398c782016-09-30 10:27:43 -07001889 ObjPtr<mirror::Class> field_type;
Sebastien Hertz05c26b32015-06-11 18:42:58 +02001890 {
1891 StackHandleScope<2> hs(Thread::Current());
1892 HandleWrapper<mirror::Object> h_v(hs.NewHandleWrapper(&v));
1893 HandleWrapper<mirror::Object> h_o(hs.NewHandleWrapper(&o));
1894 field_type = f->GetType<true>();
1895 }
1896 if (!field_type->IsAssignableFrom(v->GetClass())) {
1897 return JDWP::ERR_INVALID_OBJECT;
1898 }
1899 }
1900 f->SetObject<kNoTransactionMode>(o, v);
1901 return JDWP::ERR_NONE;
1902 }
1903
1904 case Primitive::kPrimVoid:
1905 LOG(FATAL) << "Attempt to write to field of type 'void'";
1906 UNREACHABLE();
1907 }
1908 LOG(FATAL) << "Attempt to write to field of unknown type";
1909 UNREACHABLE();
1910}
1911
Elliott Hughes88d63092013-01-09 09:55:54 -08001912static JDWP::JdwpError SetFieldValueImpl(JDWP::ObjectId object_id, JDWP::FieldId field_id,
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001913 uint64_t value, int width, bool is_static)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07001914 REQUIRES_SHARED(Locks::mutator_lock_) {
Ian Rogersc0542af2014-09-03 16:16:56 -07001915 JDWP::JdwpError error;
Jeff Haode19a252016-09-14 15:56:35 -07001916 Thread* self = Thread::Current();
1917 StackHandleScope<2> hs(self);
1918 MutableHandle<mirror::Object>
1919 o(hs.NewHandle(Dbg::GetObjectRegistry()->Get<mirror::Object*>(object_id, &error)));
1920 if ((!is_static && o.Get() == nullptr) || error != JDWP::ERR_NONE) {
Elliott Hughes3f4d58f2012-02-18 20:05:37 -08001921 return JDWP::ERR_INVALID_OBJECT;
1922 }
Mathieu Chartierc7853442015-03-27 14:35:38 -07001923 ArtField* f = FromFieldId(field_id);
Elliott Hughes0cf74332012-02-23 23:14:00 -08001924
Jeff Haode19a252016-09-14 15:56:35 -07001925 // Ensure the field's class is initialized.
1926 Handle<mirror::Class> klass(hs.NewHandle(f->GetDeclaringClass()));
1927 if (!Runtime::Current()->GetClassLinker()->EnsureInitialized(self, klass, true, false)) {
David Sehr709b0702016-10-13 09:12:37 -07001928 LOG(WARNING) << "Not able to initialize class for SetValues: "
1929 << mirror::Class::PrettyClass(klass.Get());
Jeff Haode19a252016-09-14 15:56:35 -07001930 }
1931
Elliott Hughes0cf74332012-02-23 23:14:00 -08001932 // The RI only enforces the static/non-static mismatch in one direction.
1933 // TODO: should we change the tests and check both?
1934 if (is_static) {
1935 if (!f->IsStatic()) {
1936 return JDWP::ERR_INVALID_FIELDID;
1937 }
1938 } else {
1939 if (f->IsStatic()) {
Sebastien Hertz05c26b32015-06-11 18:42:58 +02001940 LOG(WARNING) << "Ignoring non-nullptr receiver for ObjectReference.SetValues"
David Sehr709b0702016-10-13 09:12:37 -07001941 << " on static field " << f->PrettyField();
Elliott Hughes0cf74332012-02-23 23:14:00 -08001942 }
Elliott Hughes3f4d58f2012-02-18 20:05:37 -08001943 }
jeffhao0dfbb7e2012-11-28 15:26:03 -08001944 if (f->IsStatic()) {
Jeff Haode19a252016-09-14 15:56:35 -07001945 o.Assign(f->GetDeclaringClass());
jeffhao0dfbb7e2012-11-28 15:26:03 -08001946 }
Jeff Haode19a252016-09-14 15:56:35 -07001947 return SetArtFieldValue(f, o.Get(), value, width);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001948}
1949
Elliott Hughes88d63092013-01-09 09:55:54 -08001950JDWP::JdwpError Dbg::SetFieldValue(JDWP::ObjectId object_id, JDWP::FieldId field_id, uint64_t value,
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001951 int width) {
Elliott Hughes88d63092013-01-09 09:55:54 -08001952 return SetFieldValueImpl(object_id, field_id, value, width, false);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001953}
1954
Elliott Hughes88d63092013-01-09 09:55:54 -08001955JDWP::JdwpError Dbg::SetStaticFieldValue(JDWP::FieldId field_id, uint64_t value, int width) {
1956 return SetFieldValueImpl(0, field_id, value, width, true);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001957}
1958
Sebastien Hertzb0b0b492014-09-15 11:27:27 +02001959JDWP::JdwpError Dbg::StringToUtf8(JDWP::ObjectId string_id, std::string* str) {
Ian Rogersc0542af2014-09-03 16:16:56 -07001960 JDWP::JdwpError error;
Sebastien Hertzb0b0b492014-09-15 11:27:27 +02001961 mirror::Object* obj = gRegistry->Get<mirror::Object*>(string_id, &error);
1962 if (error != JDWP::ERR_NONE) {
1963 return error;
1964 }
1965 if (obj == nullptr) {
1966 return JDWP::ERR_INVALID_OBJECT;
1967 }
1968 {
1969 ScopedObjectAccessUnchecked soa(Thread::Current());
Mathieu Chartier0795f232016-09-27 18:43:30 -07001970 ObjPtr<mirror::Class> java_lang_String =
1971 soa.Decode<mirror::Class>(WellKnownClasses::java_lang_String);
Sebastien Hertzb0b0b492014-09-15 11:27:27 +02001972 if (!java_lang_String->IsAssignableFrom(obj->GetClass())) {
1973 // This isn't a string.
1974 return JDWP::ERR_INVALID_STRING;
1975 }
1976 }
1977 *str = obj->AsString()->ToModifiedUtf8();
1978 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001979}
1980
Jeff Hao579b0242013-11-18 13:16:49 -08001981void Dbg::OutputJValue(JDWP::JdwpTag tag, const JValue* return_value, JDWP::ExpandBuf* pReply) {
1982 if (IsPrimitiveTag(tag)) {
1983 expandBufAdd1(pReply, tag);
1984 if (tag == JDWP::JT_BOOLEAN || tag == JDWP::JT_BYTE) {
1985 expandBufAdd1(pReply, return_value->GetI());
1986 } else if (tag == JDWP::JT_CHAR || tag == JDWP::JT_SHORT) {
1987 expandBufAdd2BE(pReply, return_value->GetI());
1988 } else if (tag == JDWP::JT_FLOAT || tag == JDWP::JT_INT) {
1989 expandBufAdd4BE(pReply, return_value->GetI());
1990 } else if (tag == JDWP::JT_DOUBLE || tag == JDWP::JT_LONG) {
1991 expandBufAdd8BE(pReply, return_value->GetJ());
1992 } else {
1993 CHECK_EQ(tag, JDWP::JT_VOID);
1994 }
1995 } else {
Ian Rogers98379392014-02-24 16:53:16 -08001996 ScopedObjectAccessUnchecked soa(Thread::Current());
Jeff Hao579b0242013-11-18 13:16:49 -08001997 mirror::Object* value = return_value->GetL();
Ian Rogers98379392014-02-24 16:53:16 -08001998 expandBufAdd1(pReply, TagFromObject(soa, value));
Jeff Hao579b0242013-11-18 13:16:49 -08001999 expandBufAddObjectId(pReply, gRegistry->Add(value));
2000 }
2001}
2002
Ian Rogersc0542af2014-09-03 16:16:56 -07002003JDWP::JdwpError Dbg::GetThreadName(JDWP::ObjectId thread_id, std::string* name) {
jeffhaoa77f0f62012-12-05 17:19:31 -08002004 ScopedObjectAccessUnchecked soa(Thread::Current());
Ian Rogersc0542af2014-09-03 16:16:56 -07002005 JDWP::JdwpError error;
Roland Levillain4b8f1ec2015-08-26 18:34:03 +01002006 DecodeThread(soa, thread_id, &error);
Elliott Hughes221229c2013-01-08 18:17:50 -08002007 if (error != JDWP::ERR_NONE && error != JDWP::ERR_THREAD_NOT_ALIVE) {
2008 return error;
Elliott Hughesa2e54f62011-11-17 13:01:30 -08002009 }
Elliott Hughes221229c2013-01-08 18:17:50 -08002010
2011 // We still need to report the zombie threads' names, so we can't just call Thread::GetThreadName.
Ian Rogersc0542af2014-09-03 16:16:56 -07002012 mirror::Object* thread_object = gRegistry->Get<mirror::Object*>(thread_id, &error);
2013 CHECK(thread_object != nullptr) << error;
Mathieu Chartierc7853442015-03-27 14:35:38 -07002014 ArtField* java_lang_Thread_name_field =
Andreas Gampe08883de2016-11-08 13:20:52 -08002015 jni::DecodeArtField(WellKnownClasses::java_lang_Thread_name);
Mathieu Chartierf8ac97f2016-10-05 15:56:52 -07002016 ObjPtr<mirror::String> s(java_lang_Thread_name_field->GetObject(thread_object)->AsString());
Ian Rogersc0542af2014-09-03 16:16:56 -07002017 if (s != nullptr) {
2018 *name = s->ToModifiedUtf8();
Elliott Hughes221229c2013-01-08 18:17:50 -08002019 }
2020 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002021}
2022
Elliott Hughes221229c2013-01-08 18:17:50 -08002023JDWP::JdwpError Dbg::GetThreadGroup(JDWP::ObjectId thread_id, JDWP::ExpandBuf* pReply) {
Sebastien Hertza06430c2014-09-15 19:21:30 +02002024 ScopedObjectAccessUnchecked soa(Thread::Current());
Ian Rogersc0542af2014-09-03 16:16:56 -07002025 JDWP::JdwpError error;
2026 mirror::Object* thread_object = gRegistry->Get<mirror::Object*>(thread_id, &error);
2027 if (error != JDWP::ERR_NONE) {
Elliott Hughes2435a572012-02-17 16:07:41 -08002028 return JDWP::ERR_INVALID_OBJECT;
2029 }
Mathieu Chartier268764d2016-09-13 12:09:38 -07002030 ScopedAssertNoThreadSuspension ants("Debugger: GetThreadGroup");
Elliott Hughes2435a572012-02-17 16:07:41 -08002031 // Okay, so it's an object, but is it actually a thread?
Roland Levillain4b8f1ec2015-08-26 18:34:03 +01002032 DecodeThread(soa, thread_id, &error);
Elliott Hughes221229c2013-01-08 18:17:50 -08002033 if (error == JDWP::ERR_THREAD_NOT_ALIVE) {
2034 // Zombie threads are in the null group.
2035 expandBufAddObjectId(pReply, JDWP::ObjectId(0));
Sebastien Hertz52d131d2014-03-13 16:17:40 +01002036 error = JDWP::ERR_NONE;
2037 } else if (error == JDWP::ERR_NONE) {
Mathieu Chartier0795f232016-09-27 18:43:30 -07002038 ObjPtr<mirror::Class> c = soa.Decode<mirror::Class>(WellKnownClasses::java_lang_Thread);
Sebastien Hertz52d131d2014-03-13 16:17:40 +01002039 CHECK(c != nullptr);
Andreas Gampe08883de2016-11-08 13:20:52 -08002040 ArtField* f = jni::DecodeArtField(WellKnownClasses::java_lang_Thread_group);
Hiroshi Yamauchib5a9e3d2014-06-09 12:11:20 -07002041 CHECK(f != nullptr);
Mathieu Chartier3398c782016-09-30 10:27:43 -07002042 ObjPtr<mirror::Object> group = f->GetObject(thread_object);
Hiroshi Yamauchib5a9e3d2014-06-09 12:11:20 -07002043 CHECK(group != nullptr);
Sebastien Hertz52d131d2014-03-13 16:17:40 +01002044 JDWP::ObjectId thread_group_id = gRegistry->Add(group);
2045 expandBufAddObjectId(pReply, thread_group_id);
Elliott Hughes221229c2013-01-08 18:17:50 -08002046 }
Sebastien Hertz52d131d2014-03-13 16:17:40 +01002047 return error;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002048}
2049
Sebastien Hertza06430c2014-09-15 19:21:30 +02002050static mirror::Object* DecodeThreadGroup(ScopedObjectAccessUnchecked& soa,
2051 JDWP::ObjectId thread_group_id, JDWP::JdwpError* error)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07002052 REQUIRES_SHARED(Locks::mutator_lock_) {
Sebastien Hertz6995c602014-09-09 12:10:13 +02002053 mirror::Object* thread_group = Dbg::GetObjectRegistry()->Get<mirror::Object*>(thread_group_id,
2054 error);
Sebastien Hertza06430c2014-09-15 19:21:30 +02002055 if (*error != JDWP::ERR_NONE) {
2056 return nullptr;
2057 }
2058 if (thread_group == nullptr) {
2059 *error = JDWP::ERR_INVALID_OBJECT;
2060 return nullptr;
2061 }
Mathieu Chartier0795f232016-09-27 18:43:30 -07002062 ObjPtr<mirror::Class> c =
2063 soa.Decode<mirror::Class>(WellKnownClasses::java_lang_ThreadGroup);
Ian Rogers98379392014-02-24 16:53:16 -08002064 CHECK(c != nullptr);
Sebastien Hertza06430c2014-09-15 19:21:30 +02002065 if (!c->IsAssignableFrom(thread_group->GetClass())) {
2066 // This is not a java.lang.ThreadGroup.
2067 *error = JDWP::ERR_INVALID_THREAD_GROUP;
2068 return nullptr;
2069 }
2070 *error = JDWP::ERR_NONE;
2071 return thread_group;
2072}
2073
2074JDWP::JdwpError Dbg::GetThreadGroupName(JDWP::ObjectId thread_group_id, JDWP::ExpandBuf* pReply) {
2075 ScopedObjectAccessUnchecked soa(Thread::Current());
2076 JDWP::JdwpError error;
2077 mirror::Object* thread_group = DecodeThreadGroup(soa, thread_group_id, &error);
2078 if (error != JDWP::ERR_NONE) {
2079 return error;
2080 }
Mathieu Chartier268764d2016-09-13 12:09:38 -07002081 ScopedAssertNoThreadSuspension ants("Debugger: GetThreadGroupName");
Andreas Gampe08883de2016-11-08 13:20:52 -08002082 ArtField* f = jni::DecodeArtField(WellKnownClasses::java_lang_ThreadGroup_name);
Ian Rogersc0542af2014-09-03 16:16:56 -07002083 CHECK(f != nullptr);
Mathieu Chartier3398c782016-09-30 10:27:43 -07002084 ObjPtr<mirror::String> s = f->GetObject(thread_group)->AsString();
Sebastien Hertza06430c2014-09-15 19:21:30 +02002085
2086 std::string thread_group_name(s->ToModifiedUtf8());
2087 expandBufAddUtf8String(pReply, thread_group_name);
2088 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002089}
2090
Sebastien Hertza06430c2014-09-15 19:21:30 +02002091JDWP::JdwpError Dbg::GetThreadGroupParent(JDWP::ObjectId thread_group_id, JDWP::ExpandBuf* pReply) {
Ian Rogers98379392014-02-24 16:53:16 -08002092 ScopedObjectAccessUnchecked soa(Thread::Current());
Ian Rogersc0542af2014-09-03 16:16:56 -07002093 JDWP::JdwpError error;
Sebastien Hertza06430c2014-09-15 19:21:30 +02002094 mirror::Object* thread_group = DecodeThreadGroup(soa, thread_group_id, &error);
2095 if (error != JDWP::ERR_NONE) {
2096 return error;
2097 }
Mathieu Chartier3398c782016-09-30 10:27:43 -07002098 ObjPtr<mirror::Object> parent;
Mathieu Chartier2d5f39e2014-09-19 17:52:37 -07002099 {
Mathieu Chartier268764d2016-09-13 12:09:38 -07002100 ScopedAssertNoThreadSuspension ants("Debugger: GetThreadGroupParent");
Andreas Gampe08883de2016-11-08 13:20:52 -08002101 ArtField* f = jni::DecodeArtField(WellKnownClasses::java_lang_ThreadGroup_parent);
Mathieu Chartier2d5f39e2014-09-19 17:52:37 -07002102 CHECK(f != nullptr);
2103 parent = f->GetObject(thread_group);
2104 }
Sebastien Hertza06430c2014-09-15 19:21:30 +02002105 JDWP::ObjectId parent_group_id = gRegistry->Add(parent);
2106 expandBufAddObjectId(pReply, parent_group_id);
2107 return JDWP::ERR_NONE;
2108}
2109
Andreas Gampe08883de2016-11-08 13:20:52 -08002110static void GetChildThreadGroups(mirror::Object* thread_group,
Sebastien Hertza06430c2014-09-15 19:21:30 +02002111 std::vector<JDWP::ObjectId>* child_thread_group_ids)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07002112 REQUIRES_SHARED(Locks::mutator_lock_) {
Sebastien Hertza06430c2014-09-15 19:21:30 +02002113 CHECK(thread_group != nullptr);
2114
Przemyslaw Szczepaniak464595f2015-11-24 11:59:59 +00002115 // Get the int "ngroups" count of this thread group...
Andreas Gampe08883de2016-11-08 13:20:52 -08002116 ArtField* ngroups_field = jni::DecodeArtField(WellKnownClasses::java_lang_ThreadGroup_ngroups);
Przemyslaw Szczepaniak464595f2015-11-24 11:59:59 +00002117 CHECK(ngroups_field != nullptr);
2118 const int32_t size = ngroups_field->GetInt(thread_group);
2119 if (size == 0) {
2120 return;
Sebastien Hertze49e1952014-10-13 11:27:13 +02002121 }
Sebastien Hertza06430c2014-09-15 19:21:30 +02002122
Przemyslaw Szczepaniak464595f2015-11-24 11:59:59 +00002123 // Get the ThreadGroup[] "groups" out of this thread group...
Andreas Gampe08883de2016-11-08 13:20:52 -08002124 ArtField* groups_field = jni::DecodeArtField(WellKnownClasses::java_lang_ThreadGroup_groups);
Mathieu Chartier3398c782016-09-30 10:27:43 -07002125 ObjPtr<mirror::Object> groups_array = groups_field->GetObject(thread_group);
Przemyslaw Szczepaniak464595f2015-11-24 11:59:59 +00002126
2127 CHECK(groups_array != nullptr);
2128 CHECK(groups_array->IsObjectArray());
2129
Mathieu Chartier3398c782016-09-30 10:27:43 -07002130 ObjPtr<mirror::ObjectArray<mirror::Object>> groups_array_as_array =
Przemyslaw Szczepaniak464595f2015-11-24 11:59:59 +00002131 groups_array->AsObjectArray<mirror::Object>();
Sebastien Hertza06430c2014-09-15 19:21:30 +02002132
2133 // Copy the first 'size' elements out of the array into the result.
Sebastien Hertz6995c602014-09-09 12:10:13 +02002134 ObjectRegistry* registry = Dbg::GetObjectRegistry();
Sebastien Hertza06430c2014-09-15 19:21:30 +02002135 for (int32_t i = 0; i < size; ++i) {
Przemyslaw Szczepaniak464595f2015-11-24 11:59:59 +00002136 child_thread_group_ids->push_back(registry->Add(groups_array_as_array->Get(i)));
Sebastien Hertza06430c2014-09-15 19:21:30 +02002137 }
2138}
2139
2140JDWP::JdwpError Dbg::GetThreadGroupChildren(JDWP::ObjectId thread_group_id,
2141 JDWP::ExpandBuf* pReply) {
2142 ScopedObjectAccessUnchecked soa(Thread::Current());
2143 JDWP::JdwpError error;
2144 mirror::Object* thread_group = DecodeThreadGroup(soa, thread_group_id, &error);
2145 if (error != JDWP::ERR_NONE) {
2146 return error;
2147 }
2148
2149 // Add child threads.
2150 {
2151 std::vector<JDWP::ObjectId> child_thread_ids;
2152 GetThreads(thread_group, &child_thread_ids);
2153 expandBufAdd4BE(pReply, child_thread_ids.size());
2154 for (JDWP::ObjectId child_thread_id : child_thread_ids) {
2155 expandBufAddObjectId(pReply, child_thread_id);
2156 }
2157 }
2158
2159 // Add child thread groups.
2160 {
2161 std::vector<JDWP::ObjectId> child_thread_groups_ids;
Andreas Gampe08883de2016-11-08 13:20:52 -08002162 GetChildThreadGroups(thread_group, &child_thread_groups_ids);
Sebastien Hertza06430c2014-09-15 19:21:30 +02002163 expandBufAdd4BE(pReply, child_thread_groups_ids.size());
2164 for (JDWP::ObjectId child_thread_group_id : child_thread_groups_ids) {
2165 expandBufAddObjectId(pReply, child_thread_group_id);
2166 }
2167 }
2168
2169 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002170}
2171
2172JDWP::ObjectId Dbg::GetSystemThreadGroupId() {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002173 ScopedObjectAccessUnchecked soa(Thread::Current());
Andreas Gampe08883de2016-11-08 13:20:52 -08002174 ArtField* f = jni::DecodeArtField(WellKnownClasses::java_lang_ThreadGroup_systemThreadGroup);
Mathieu Chartier3398c782016-09-30 10:27:43 -07002175 ObjPtr<mirror::Object> group = f->GetObject(f->GetDeclaringClass());
Ian Rogers365c1022012-06-22 15:05:28 -07002176 return gRegistry->Add(group);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002177}
2178
Jeff Hao920af3e2013-08-28 15:46:38 -07002179JDWP::JdwpThreadStatus Dbg::ToJdwpThreadStatus(ThreadState state) {
2180 switch (state) {
2181 case kBlocked:
2182 return JDWP::TS_MONITOR;
2183 case kNative:
2184 case kRunnable:
2185 case kSuspended:
2186 return JDWP::TS_RUNNING;
2187 case kSleeping:
2188 return JDWP::TS_SLEEPING;
2189 case kStarting:
2190 case kTerminated:
2191 return JDWP::TS_ZOMBIE;
2192 case kTimedWaiting:
Sebastien Hertzbae182c2013-12-17 10:42:03 +01002193 case kWaitingForCheckPointsToRun:
Jeff Hao920af3e2013-08-28 15:46:38 -07002194 case kWaitingForDebuggerSend:
2195 case kWaitingForDebuggerSuspension:
2196 case kWaitingForDebuggerToAttach:
Sebastien Hertz138dbfc2013-12-04 18:15:25 +01002197 case kWaitingForDeoptimization:
Jeff Hao920af3e2013-08-28 15:46:38 -07002198 case kWaitingForGcToComplete:
Mathieu Chartierb43390c2015-05-12 10:47:11 -07002199 case kWaitingForGetObjectsAllocated:
Jeff Hao920af3e2013-08-28 15:46:38 -07002200 case kWaitingForJniOnLoad:
Sebastien Hertzbae182c2013-12-17 10:42:03 +01002201 case kWaitingForMethodTracingStart:
Jeff Hao920af3e2013-08-28 15:46:38 -07002202 case kWaitingForSignalCatcherOutput:
Hiroshi Yamauchi0c8c3032015-01-16 16:54:35 -08002203 case kWaitingForVisitObjects:
Jeff Hao920af3e2013-08-28 15:46:38 -07002204 case kWaitingInMainDebuggerLoop:
2205 case kWaitingInMainSignalCatcherLoop:
2206 case kWaitingPerformingGc:
Mathieu Chartier90ef3db2015-08-04 15:19:41 -07002207 case kWaitingWeakGcRootRead:
Hiroshi Yamauchi76f55b02015-08-21 16:10:39 -07002208 case kWaitingForGcThreadFlip:
Jeff Hao920af3e2013-08-28 15:46:38 -07002209 case kWaiting:
2210 return JDWP::TS_WAIT;
2211 // Don't add a 'default' here so the compiler can spot incompatible enum changes.
2212 }
2213 LOG(FATAL) << "Unknown thread state: " << state;
2214 return JDWP::TS_ZOMBIE;
2215}
2216
Sebastien Hertz52d131d2014-03-13 16:17:40 +01002217JDWP::JdwpError Dbg::GetThreadStatus(JDWP::ObjectId thread_id, JDWP::JdwpThreadStatus* pThreadStatus,
2218 JDWP::JdwpSuspendStatus* pSuspendStatus) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002219 ScopedObjectAccess soa(Thread::Current());
Elliott Hughes499c5132011-11-17 14:55:11 -08002220
Elliott Hughes9e0c1752013-01-09 14:02:58 -08002221 *pSuspendStatus = JDWP::SUSPEND_STATUS_NOT_SUSPENDED;
2222
Ian Rogersc0542af2014-09-03 16:16:56 -07002223 JDWP::JdwpError error;
2224 Thread* thread = DecodeThread(soa, thread_id, &error);
Elliott Hughes221229c2013-01-08 18:17:50 -08002225 if (error != JDWP::ERR_NONE) {
2226 if (error == JDWP::ERR_THREAD_NOT_ALIVE) {
2227 *pThreadStatus = JDWP::TS_ZOMBIE;
Elliott Hughes221229c2013-01-08 18:17:50 -08002228 return JDWP::ERR_NONE;
2229 }
2230 return error;
Elliott Hughes499c5132011-11-17 14:55:11 -08002231 }
2232
Elliott Hughes9e0c1752013-01-09 14:02:58 -08002233 if (IsSuspendedForDebugger(soa, thread)) {
2234 *pSuspendStatus = JDWP::SUSPEND_STATUS_SUSPENDED;
Elliott Hughes499c5132011-11-17 14:55:11 -08002235 }
2236
Jeff Hao920af3e2013-08-28 15:46:38 -07002237 *pThreadStatus = ToJdwpThreadStatus(thread->GetState());
Elliott Hughes221229c2013-01-08 18:17:50 -08002238 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002239}
2240
Elliott Hughes221229c2013-01-08 18:17:50 -08002241JDWP::JdwpError Dbg::GetThreadDebugSuspendCount(JDWP::ObjectId thread_id, JDWP::ExpandBuf* pReply) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002242 ScopedObjectAccess soa(Thread::Current());
Ian Rogersc0542af2014-09-03 16:16:56 -07002243 JDWP::JdwpError error;
2244 Thread* thread = DecodeThread(soa, thread_id, &error);
Elliott Hughes221229c2013-01-08 18:17:50 -08002245 if (error != JDWP::ERR_NONE) {
2246 return error;
Elliott Hughes2435a572012-02-17 16:07:41 -08002247 }
Ian Rogers50b35e22012-10-04 10:09:15 -07002248 MutexLock mu2(soa.Self(), *Locks::thread_suspend_count_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002249 expandBufAdd4BE(pReply, thread->GetDebugSuspendCount());
Elliott Hughes2435a572012-02-17 16:07:41 -08002250 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002251}
2252
Elliott Hughesf9501702013-01-11 11:22:27 -08002253JDWP::JdwpError Dbg::Interrupt(JDWP::ObjectId thread_id) {
2254 ScopedObjectAccess soa(Thread::Current());
Ian Rogersc0542af2014-09-03 16:16:56 -07002255 JDWP::JdwpError error;
2256 Thread* thread = DecodeThread(soa, thread_id, &error);
Elliott Hughesf9501702013-01-11 11:22:27 -08002257 if (error != JDWP::ERR_NONE) {
2258 return error;
2259 }
Ian Rogersdd7624d2014-03-14 17:43:00 -07002260 thread->Interrupt(soa.Self());
Elliott Hughesf9501702013-01-11 11:22:27 -08002261 return JDWP::ERR_NONE;
2262}
2263
Andreas Gampe08883de2016-11-08 13:20:52 -08002264static bool IsInDesiredThreadGroup(mirror::Object* desired_thread_group, mirror::Object* peer)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07002265 REQUIRES_SHARED(Locks::mutator_lock_) {
Sebastien Hertz070f7322014-09-09 12:08:49 +02002266 // Do we want threads from all thread groups?
2267 if (desired_thread_group == nullptr) {
2268 return true;
2269 }
Andreas Gampe08883de2016-11-08 13:20:52 -08002270 ArtField* thread_group_field = jni::DecodeArtField(WellKnownClasses::java_lang_Thread_group);
Sebastien Hertz070f7322014-09-09 12:08:49 +02002271 DCHECK(thread_group_field != nullptr);
Mathieu Chartier3398c782016-09-30 10:27:43 -07002272 ObjPtr<mirror::Object> group = thread_group_field->GetObject(peer);
Sebastien Hertz070f7322014-09-09 12:08:49 +02002273 return (group == desired_thread_group);
2274}
2275
Sebastien Hertza06430c2014-09-15 19:21:30 +02002276void Dbg::GetThreads(mirror::Object* thread_group, std::vector<JDWP::ObjectId>* thread_ids) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002277 ScopedObjectAccessUnchecked soa(Thread::Current());
Sebastien Hertz070f7322014-09-09 12:08:49 +02002278 std::list<Thread*> all_threads_list;
2279 {
2280 MutexLock mu(Thread::Current(), *Locks::thread_list_lock_);
2281 all_threads_list = Runtime::Current()->GetThreadList()->GetList();
2282 }
2283 for (Thread* t : all_threads_list) {
2284 if (t == Dbg::GetDebugThread()) {
2285 // Skip the JDWP thread. Some debuggers get bent out of shape when they can't suspend and
2286 // query all threads, so it's easier if we just don't tell them about this thread.
2287 continue;
2288 }
2289 if (t->IsStillStarting()) {
2290 // This thread is being started (and has been registered in the thread list). However, it is
2291 // not completely started yet so we must ignore it.
2292 continue;
2293 }
2294 mirror::Object* peer = t->GetPeer();
2295 if (peer == nullptr) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -07002296 // peer might be null if the thread is still starting up. We can't tell the debugger about
Sebastien Hertz070f7322014-09-09 12:08:49 +02002297 // this thread yet.
2298 // TODO: if we identified threads to the debugger by their Thread*
2299 // rather than their peer's mirror::Object*, we could fix this.
2300 // Doing so might help us report ZOMBIE threads too.
2301 continue;
2302 }
Andreas Gampe08883de2016-11-08 13:20:52 -08002303 if (IsInDesiredThreadGroup(thread_group, peer)) {
Sebastien Hertz070f7322014-09-09 12:08:49 +02002304 thread_ids->push_back(gRegistry->Add(peer));
2305 }
2306 }
Elliott Hughescaf76542012-06-28 16:08:22 -07002307}
Elliott Hughesa2155262011-11-16 16:26:58 -08002308
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07002309static int GetStackDepth(Thread* thread) REQUIRES_SHARED(Locks::mutator_lock_) {
Ian Rogers0399dde2012-06-06 17:09:28 -07002310 struct CountStackDepthVisitor : public StackVisitor {
Andreas Gampe277ccbd2014-11-03 21:36:10 -08002311 explicit CountStackDepthVisitor(Thread* thread_in)
Nicolas Geoffray8e5bd182015-05-06 11:34:34 +01002312 : StackVisitor(thread_in, nullptr, StackVisitor::StackWalkKind::kIncludeInlinedFrames),
2313 depth(0) {}
Ian Rogers0399dde2012-06-06 17:09:28 -07002314
Elliott Hughes64f574f2013-02-20 14:57:12 -08002315 // TODO: Enable annotalysis. We know lock is held in constructor, but abstraction confuses
2316 // annotalysis.
2317 bool VisitFrame() NO_THREAD_SAFETY_ANALYSIS {
Ian Rogers0399dde2012-06-06 17:09:28 -07002318 if (!GetMethod()->IsRuntimeMethod()) {
Elliott Hughesf8a2df72011-12-01 12:19:54 -08002319 ++depth;
2320 }
Elliott Hughes530fa002012-03-12 11:44:49 -07002321 return true;
Elliott Hughesa2e54f62011-11-17 13:01:30 -08002322 }
2323 size_t depth;
2324 };
Elliott Hughes08fc03a2012-06-26 17:34:00 -07002325
Ian Rogers7a22fa62013-01-23 12:16:16 -08002326 CountStackDepthVisitor visitor(thread);
Ian Rogers0399dde2012-06-06 17:09:28 -07002327 visitor.WalkStack();
Elliott Hughesa2e54f62011-11-17 13:01:30 -08002328 return visitor.depth;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002329}
2330
Ian Rogersc0542af2014-09-03 16:16:56 -07002331JDWP::JdwpError Dbg::GetThreadFrameCount(JDWP::ObjectId thread_id, size_t* result) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002332 ScopedObjectAccess soa(Thread::Current());
Ian Rogersc0542af2014-09-03 16:16:56 -07002333 JDWP::JdwpError error;
2334 *result = 0;
2335 Thread* thread = DecodeThread(soa, thread_id, &error);
Elliott Hughes221229c2013-01-08 18:17:50 -08002336 if (error != JDWP::ERR_NONE) {
2337 return error;
2338 }
Elliott Hughesf15f4a02013-01-09 10:09:38 -08002339 if (!IsSuspendedForDebugger(soa, thread)) {
2340 return JDWP::ERR_THREAD_NOT_SUSPENDED;
2341 }
Ian Rogersc0542af2014-09-03 16:16:56 -07002342 *result = GetStackDepth(thread);
Elliott Hughes221229c2013-01-08 18:17:50 -08002343 return JDWP::ERR_NONE;
Elliott Hughes86964332012-02-15 19:37:42 -08002344}
2345
Ian Rogers306057f2012-11-26 12:45:53 -08002346JDWP::JdwpError Dbg::GetThreadFrames(JDWP::ObjectId thread_id, size_t start_frame,
2347 size_t frame_count, JDWP::ExpandBuf* buf) {
Elliott Hughes6e9d22c2012-06-22 15:02:37 -07002348 class GetFrameVisitor : public StackVisitor {
2349 public:
Andreas Gampe277ccbd2014-11-03 21:36:10 -08002350 GetFrameVisitor(Thread* thread, size_t start_frame_in, size_t frame_count_in,
2351 JDWP::ExpandBuf* buf_in)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07002352 REQUIRES_SHARED(Locks::mutator_lock_)
Nicolas Geoffray8e5bd182015-05-06 11:34:34 +01002353 : StackVisitor(thread, nullptr, StackVisitor::StackWalkKind::kIncludeInlinedFrames),
2354 depth_(0),
2355 start_frame_(start_frame_in),
2356 frame_count_(frame_count_in),
2357 buf_(buf_in) {
Elliott Hughes6e9d22c2012-06-22 15:02:37 -07002358 expandBufAdd4BE(buf_, frame_count_);
Elliott Hughes03181a82011-11-17 17:22:21 -08002359 }
Ian Rogers0399dde2012-06-06 17:09:28 -07002360
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07002361 bool VisitFrame() OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) {
Ian Rogers0399dde2012-06-06 17:09:28 -07002362 if (GetMethod()->IsRuntimeMethod()) {
Brian Carlstrom7934ac22013-07-26 10:54:15 -07002363 return true; // The debugger can't do anything useful with a frame that has no Method*.
Elliott Hughes03181a82011-11-17 17:22:21 -08002364 }
Elliott Hughes6e9d22c2012-06-22 15:02:37 -07002365 if (depth_ >= start_frame_ + frame_count_) {
Elliott Hughes530fa002012-03-12 11:44:49 -07002366 return false;
Elliott Hughes03181a82011-11-17 17:22:21 -08002367 }
Elliott Hughes6e9d22c2012-06-22 15:02:37 -07002368 if (depth_ >= start_frame_) {
2369 JDWP::FrameId frame_id(GetFrameId());
2370 JDWP::JdwpLocation location;
Sebastien Hertz6995c602014-09-09 12:10:13 +02002371 SetJdwpLocation(&location, GetMethod(), GetDexPc());
Ian Rogersef7d42f2014-01-06 12:55:46 -08002372 VLOG(jdwp) << StringPrintf(" Frame %3zd: id=%3" PRIu64 " ", depth_, frame_id) << location;
Elliott Hughes6e9d22c2012-06-22 15:02:37 -07002373 expandBufAdd8BE(buf_, frame_id);
2374 expandBufAddLocation(buf_, location);
2375 }
2376 ++depth_;
Elliott Hughes530fa002012-03-12 11:44:49 -07002377 return true;
Elliott Hughes03181a82011-11-17 17:22:21 -08002378 }
Elliott Hughes6e9d22c2012-06-22 15:02:37 -07002379
2380 private:
2381 size_t depth_;
2382 const size_t start_frame_;
2383 const size_t frame_count_;
2384 JDWP::ExpandBuf* buf_;
Elliott Hughes03181a82011-11-17 17:22:21 -08002385 };
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002386
2387 ScopedObjectAccessUnchecked soa(Thread::Current());
Ian Rogersc0542af2014-09-03 16:16:56 -07002388 JDWP::JdwpError error;
2389 Thread* thread = DecodeThread(soa, thread_id, &error);
Elliott Hughes221229c2013-01-08 18:17:50 -08002390 if (error != JDWP::ERR_NONE) {
2391 return error;
2392 }
Elliott Hughesf15f4a02013-01-09 10:09:38 -08002393 if (!IsSuspendedForDebugger(soa, thread)) {
2394 return JDWP::ERR_THREAD_NOT_SUSPENDED;
2395 }
Ian Rogers7a22fa62013-01-23 12:16:16 -08002396 GetFrameVisitor visitor(thread, start_frame, frame_count, buf);
Ian Rogers0399dde2012-06-06 17:09:28 -07002397 visitor.WalkStack();
Elliott Hughes6e9d22c2012-06-22 15:02:37 -07002398 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002399}
2400
2401JDWP::ObjectId Dbg::GetThreadSelfId() {
Sebastien Hertz6995c602014-09-09 12:10:13 +02002402 return GetThreadId(Thread::Current());
2403}
2404
2405JDWP::ObjectId Dbg::GetThreadId(Thread* thread) {
Mathieu Chartierdbe6f462012-09-25 16:54:50 -07002406 ScopedObjectAccessUnchecked soa(Thread::Current());
Sebastien Hertz6995c602014-09-09 12:10:13 +02002407 return gRegistry->Add(thread->GetPeer());
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002408}
2409
Elliott Hughes475fc232011-10-25 15:00:35 -07002410void Dbg::SuspendVM() {
Hiroshi Yamauchi8f95cf32016-04-19 11:14:06 -07002411 // Avoid a deadlock between GC and debugger where GC gets suspended during GC. b/25800335.
2412 gc::ScopedGCCriticalSection gcs(Thread::Current(),
2413 gc::kGcCauseDebugger,
2414 gc::kCollectorTypeDebugger);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002415 Runtime::Current()->GetThreadList()->SuspendAllForDebugger();
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002416}
2417
2418void Dbg::ResumeVM() {
Sebastien Hertz253fa552014-10-14 17:27:15 +02002419 Runtime::Current()->GetThreadList()->ResumeAllForDebugger();
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002420}
2421
Elliott Hughes221229c2013-01-08 18:17:50 -08002422JDWP::JdwpError Dbg::SuspendThread(JDWP::ObjectId thread_id, bool request_suspension) {
Ian Rogersf3d874c2014-07-17 18:52:42 -07002423 Thread* self = Thread::Current();
Ian Rogersc0542af2014-09-03 16:16:56 -07002424 ScopedLocalRef<jobject> peer(self->GetJniEnv(), nullptr);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002425 {
Ian Rogersf3d874c2014-07-17 18:52:42 -07002426 ScopedObjectAccess soa(self);
Ian Rogersc0542af2014-09-03 16:16:56 -07002427 JDWP::JdwpError error;
2428 peer.reset(soa.AddLocalReference<jobject>(gRegistry->Get<mirror::Object*>(thread_id, &error)));
Elliott Hughes4e235312011-12-02 11:34:15 -08002429 }
Ian Rogersc0542af2014-09-03 16:16:56 -07002430 if (peer.get() == nullptr) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002431 return JDWP::ERR_THREAD_NOT_ALIVE;
2432 }
Ian Rogers4ad5cd32014-11-11 23:08:07 -08002433 // Suspend thread to build stack trace.
Elliott Hughesf327e072013-01-09 16:01:26 -08002434 bool timed_out;
Brian Carlstromba32de42014-08-27 23:43:46 -07002435 ThreadList* thread_list = Runtime::Current()->GetThreadList();
2436 Thread* thread = thread_list->SuspendThreadByPeer(peer.get(), request_suspension, true,
2437 &timed_out);
Ian Rogersc0542af2014-09-03 16:16:56 -07002438 if (thread != nullptr) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002439 return JDWP::ERR_NONE;
Elliott Hughesf327e072013-01-09 16:01:26 -08002440 } else if (timed_out) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002441 return JDWP::ERR_INTERNAL;
2442 } else {
2443 return JDWP::ERR_THREAD_NOT_ALIVE;
2444 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002445}
2446
Elliott Hughes221229c2013-01-08 18:17:50 -08002447void Dbg::ResumeThread(JDWP::ObjectId thread_id) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002448 ScopedObjectAccessUnchecked soa(Thread::Current());
Ian Rogersc0542af2014-09-03 16:16:56 -07002449 JDWP::JdwpError error;
2450 mirror::Object* peer = gRegistry->Get<mirror::Object*>(thread_id, &error);
2451 CHECK(peer != nullptr) << error;
jeffhaoa77f0f62012-12-05 17:19:31 -08002452 Thread* thread;
2453 {
2454 MutexLock mu(soa.Self(), *Locks::thread_list_lock_);
2455 thread = Thread::FromManagedThread(soa, peer);
2456 }
Ian Rogersc0542af2014-09-03 16:16:56 -07002457 if (thread == nullptr) {
Elliott Hughes4e235312011-12-02 11:34:15 -08002458 LOG(WARNING) << "No such thread for resume: " << peer;
2459 return;
2460 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002461 bool needs_resume;
2462 {
Ian Rogers50b35e22012-10-04 10:09:15 -07002463 MutexLock mu2(soa.Self(), *Locks::thread_suspend_count_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002464 needs_resume = thread->GetSuspendCount() > 0;
2465 }
2466 if (needs_resume) {
Elliott Hughes546b9862012-06-20 16:06:13 -07002467 Runtime::Current()->GetThreadList()->Resume(thread, true);
2468 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002469}
2470
2471void Dbg::SuspendSelf() {
Elliott Hughes475fc232011-10-25 15:00:35 -07002472 Runtime::Current()->GetThreadList()->SuspendSelfForDebugger();
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002473}
2474
Ian Rogers0399dde2012-06-06 17:09:28 -07002475struct GetThisVisitor : public StackVisitor {
Andreas Gampe277ccbd2014-11-03 21:36:10 -08002476 GetThisVisitor(Thread* thread, Context* context, JDWP::FrameId frame_id_in)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07002477 REQUIRES_SHARED(Locks::mutator_lock_)
Nicolas Geoffray8e5bd182015-05-06 11:34:34 +01002478 : StackVisitor(thread, context, StackVisitor::StackWalkKind::kIncludeInlinedFrames),
2479 this_object(nullptr),
2480 frame_id(frame_id_in) {}
Ian Rogers0399dde2012-06-06 17:09:28 -07002481
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002482 // TODO: Enable annotalysis. We know lock is held in constructor, but abstraction confuses
2483 // annotalysis.
2484 virtual bool VisitFrame() NO_THREAD_SAFETY_ANALYSIS {
Elliott Hughes6e9d22c2012-06-22 15:02:37 -07002485 if (frame_id != GetFrameId()) {
Ian Rogers0399dde2012-06-06 17:09:28 -07002486 return true; // continue
Ian Rogers0399dde2012-06-06 17:09:28 -07002487 } else {
Ian Rogers62d6c772013-02-27 08:32:07 -08002488 this_object = GetThisObject();
2489 return false;
Ian Rogers0399dde2012-06-06 17:09:28 -07002490 }
Elliott Hughes86b00102011-12-05 17:54:26 -08002491 }
Ian Rogers0399dde2012-06-06 17:09:28 -07002492
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08002493 mirror::Object* this_object;
Elliott Hughes6e9d22c2012-06-22 15:02:37 -07002494 JDWP::FrameId frame_id;
Ian Rogers0399dde2012-06-06 17:09:28 -07002495};
2496
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002497JDWP::JdwpError Dbg::GetThisObject(JDWP::ObjectId thread_id, JDWP::FrameId frame_id,
2498 JDWP::ObjectId* result) {
2499 ScopedObjectAccessUnchecked soa(Thread::Current());
Sebastien Hertz69206392015-04-07 15:54:25 +02002500 JDWP::JdwpError error;
2501 Thread* thread = DecodeThread(soa, thread_id, &error);
2502 if (error != JDWP::ERR_NONE) {
2503 return error;
2504 }
2505 if (!IsSuspendedForDebugger(soa, thread)) {
2506 return JDWP::ERR_THREAD_NOT_SUSPENDED;
Elliott Hughes6e9d22c2012-06-22 15:02:37 -07002507 }
Ian Rogers700a4022014-05-19 16:49:03 -07002508 std::unique_ptr<Context> context(Context::Create());
Ian Rogers7a22fa62013-01-23 12:16:16 -08002509 GetThisVisitor visitor(thread, context.get(), frame_id);
Ian Rogers0399dde2012-06-06 17:09:28 -07002510 visitor.WalkStack();
Elliott Hughes6e9d22c2012-06-22 15:02:37 -07002511 *result = gRegistry->Add(visitor.this_object);
2512 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002513}
2514
Sebastien Hertz8009f392014-09-01 17:07:11 +02002515// Walks the stack until we find the frame with the given FrameId.
2516class FindFrameVisitor FINAL : public StackVisitor {
2517 public:
2518 FindFrameVisitor(Thread* thread, Context* context, JDWP::FrameId frame_id)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07002519 REQUIRES_SHARED(Locks::mutator_lock_)
Nicolas Geoffray8e5bd182015-05-06 11:34:34 +01002520 : StackVisitor(thread, context, StackVisitor::StackWalkKind::kIncludeInlinedFrames),
2521 frame_id_(frame_id),
2522 error_(JDWP::ERR_INVALID_FRAMEID) {}
Ian Rogersca190662012-06-26 15:45:57 -07002523
Sebastien Hertz8009f392014-09-01 17:07:11 +02002524 // TODO: Enable annotalysis. We know lock is held in constructor, but abstraction confuses
2525 // annotalysis.
2526 bool VisitFrame() NO_THREAD_SAFETY_ANALYSIS {
2527 if (GetFrameId() != frame_id_) {
2528 return true; // Not our frame, carry on.
Ian Rogers0399dde2012-06-06 17:09:28 -07002529 }
Mathieu Chartiere401d142015-04-22 13:56:20 -07002530 ArtMethod* m = GetMethod();
Sebastien Hertz8009f392014-09-01 17:07:11 +02002531 if (m->IsNative()) {
2532 // We can't read/write local value from/into native method.
2533 error_ = JDWP::ERR_OPAQUE_FRAME;
2534 } else {
2535 // We found our frame.
2536 error_ = JDWP::ERR_NONE;
2537 }
2538 return false;
2539 }
2540
2541 JDWP::JdwpError GetError() const {
2542 return error_;
2543 }
2544
2545 private:
2546 const JDWP::FrameId frame_id_;
2547 JDWP::JdwpError error_;
Sebastien Hertz26f72862015-09-15 09:52:07 +02002548
2549 DISALLOW_COPY_AND_ASSIGN(FindFrameVisitor);
Sebastien Hertz8009f392014-09-01 17:07:11 +02002550};
2551
2552JDWP::JdwpError Dbg::GetLocalValues(JDWP::Request* request, JDWP::ExpandBuf* pReply) {
2553 JDWP::ObjectId thread_id = request->ReadThreadId();
2554 JDWP::FrameId frame_id = request->ReadFrameId();
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002555
2556 ScopedObjectAccessUnchecked soa(Thread::Current());
Sebastien Hertz69206392015-04-07 15:54:25 +02002557 JDWP::JdwpError error;
2558 Thread* thread = DecodeThread(soa, thread_id, &error);
2559 if (error != JDWP::ERR_NONE) {
2560 return error;
2561 }
2562 if (!IsSuspendedForDebugger(soa, thread)) {
2563 return JDWP::ERR_THREAD_NOT_SUSPENDED;
Elliott Hughes221229c2013-01-08 18:17:50 -08002564 }
Sebastien Hertz8009f392014-09-01 17:07:11 +02002565 // Find the frame with the given frame_id.
Ian Rogers700a4022014-05-19 16:49:03 -07002566 std::unique_ptr<Context> context(Context::Create());
Sebastien Hertz8009f392014-09-01 17:07:11 +02002567 FindFrameVisitor visitor(thread, context.get(), frame_id);
Ian Rogers0399dde2012-06-06 17:09:28 -07002568 visitor.WalkStack();
Sebastien Hertz8009f392014-09-01 17:07:11 +02002569 if (visitor.GetError() != JDWP::ERR_NONE) {
2570 return visitor.GetError();
2571 }
2572
2573 // Read the values from visitor's context.
2574 int32_t slot_count = request->ReadSigned32("slot count");
2575 expandBufAdd4BE(pReply, slot_count); /* "int values" */
2576 for (int32_t i = 0; i < slot_count; ++i) {
2577 uint32_t slot = request->ReadUnsigned32("slot");
2578 JDWP::JdwpTag reqSigByte = request->ReadTag();
2579
2580 VLOG(jdwp) << " --> slot " << slot << " " << reqSigByte;
2581
2582 size_t width = Dbg::GetTagWidth(reqSigByte);
Sebastien Hertz7d955652014-10-22 10:57:10 +02002583 uint8_t* ptr = expandBufAddSpace(pReply, width + 1);
Sebastien Hertz69206392015-04-07 15:54:25 +02002584 error = Dbg::GetLocalValue(visitor, soa, slot, reqSigByte, ptr, width);
Sebastien Hertz8009f392014-09-01 17:07:11 +02002585 if (error != JDWP::ERR_NONE) {
2586 return error;
2587 }
2588 }
2589 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002590}
2591
Sebastien Hertzabbabc82015-03-26 08:47:47 +01002592constexpr JDWP::JdwpError kStackFrameLocalAccessError = JDWP::ERR_ABSENT_INFORMATION;
2593
2594static std::string GetStackContextAsString(const StackVisitor& visitor)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07002595 REQUIRES_SHARED(Locks::mutator_lock_) {
Sebastien Hertzabbabc82015-03-26 08:47:47 +01002596 return StringPrintf(" at DEX pc 0x%08x in method %s", visitor.GetDexPc(false),
David Sehr709b0702016-10-13 09:12:37 -07002597 ArtMethod::PrettyMethod(visitor.GetMethod()).c_str());
Sebastien Hertzabbabc82015-03-26 08:47:47 +01002598}
2599
2600static JDWP::JdwpError FailGetLocalValue(const StackVisitor& visitor, uint16_t vreg,
2601 JDWP::JdwpTag tag)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07002602 REQUIRES_SHARED(Locks::mutator_lock_) {
Sebastien Hertzabbabc82015-03-26 08:47:47 +01002603 LOG(ERROR) << "Failed to read " << tag << " local from register v" << vreg
2604 << GetStackContextAsString(visitor);
2605 return kStackFrameLocalAccessError;
2606}
2607
Sebastien Hertz8009f392014-09-01 17:07:11 +02002608JDWP::JdwpError Dbg::GetLocalValue(const StackVisitor& visitor, ScopedObjectAccessUnchecked& soa,
2609 int slot, JDWP::JdwpTag tag, uint8_t* buf, size_t width) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07002610 ArtMethod* m = visitor.GetMethod();
Sebastien Hertzabbabc82015-03-26 08:47:47 +01002611 JDWP::JdwpError error = JDWP::ERR_NONE;
2612 uint16_t vreg = DemangleSlot(slot, m, &error);
2613 if (error != JDWP::ERR_NONE) {
2614 return error;
2615 }
Sebastien Hertz8009f392014-09-01 17:07:11 +02002616 // TODO: check that the tag is compatible with the actual type of the slot!
Sebastien Hertz8009f392014-09-01 17:07:11 +02002617 switch (tag) {
2618 case JDWP::JT_BOOLEAN: {
2619 CHECK_EQ(width, 1U);
2620 uint32_t intVal;
Sebastien Hertzabbabc82015-03-26 08:47:47 +01002621 if (!visitor.GetVReg(m, vreg, kIntVReg, &intVal)) {
2622 return FailGetLocalValue(visitor, vreg, tag);
Ian Rogers0399dde2012-06-06 17:09:28 -07002623 }
Sebastien Hertzabbabc82015-03-26 08:47:47 +01002624 VLOG(jdwp) << "get boolean local " << vreg << " = " << intVal;
2625 JDWP::Set1(buf + 1, intVal != 0);
Sebastien Hertz8009f392014-09-01 17:07:11 +02002626 break;
Ian Rogers0399dde2012-06-06 17:09:28 -07002627 }
Sebastien Hertz8009f392014-09-01 17:07:11 +02002628 case JDWP::JT_BYTE: {
2629 CHECK_EQ(width, 1U);
2630 uint32_t intVal;
Sebastien Hertzabbabc82015-03-26 08:47:47 +01002631 if (!visitor.GetVReg(m, vreg, kIntVReg, &intVal)) {
2632 return FailGetLocalValue(visitor, vreg, tag);
Sebastien Hertz8009f392014-09-01 17:07:11 +02002633 }
Sebastien Hertzabbabc82015-03-26 08:47:47 +01002634 VLOG(jdwp) << "get byte local " << vreg << " = " << intVal;
2635 JDWP::Set1(buf + 1, intVal);
Sebastien Hertz8009f392014-09-01 17:07:11 +02002636 break;
2637 }
2638 case JDWP::JT_SHORT:
2639 case JDWP::JT_CHAR: {
2640 CHECK_EQ(width, 2U);
2641 uint32_t intVal;
Sebastien Hertzabbabc82015-03-26 08:47:47 +01002642 if (!visitor.GetVReg(m, vreg, kIntVReg, &intVal)) {
2643 return FailGetLocalValue(visitor, vreg, tag);
Sebastien Hertz8009f392014-09-01 17:07:11 +02002644 }
Sebastien Hertzabbabc82015-03-26 08:47:47 +01002645 VLOG(jdwp) << "get short/char local " << vreg << " = " << intVal;
2646 JDWP::Set2BE(buf + 1, intVal);
Sebastien Hertz8009f392014-09-01 17:07:11 +02002647 break;
2648 }
2649 case JDWP::JT_INT: {
2650 CHECK_EQ(width, 4U);
2651 uint32_t intVal;
Sebastien Hertzabbabc82015-03-26 08:47:47 +01002652 if (!visitor.GetVReg(m, vreg, kIntVReg, &intVal)) {
2653 return FailGetLocalValue(visitor, vreg, tag);
Sebastien Hertz8009f392014-09-01 17:07:11 +02002654 }
Sebastien Hertzabbabc82015-03-26 08:47:47 +01002655 VLOG(jdwp) << "get int local " << vreg << " = " << intVal;
2656 JDWP::Set4BE(buf + 1, intVal);
Sebastien Hertz8009f392014-09-01 17:07:11 +02002657 break;
2658 }
2659 case JDWP::JT_FLOAT: {
2660 CHECK_EQ(width, 4U);
2661 uint32_t intVal;
Sebastien Hertzabbabc82015-03-26 08:47:47 +01002662 if (!visitor.GetVReg(m, vreg, kFloatVReg, &intVal)) {
2663 return FailGetLocalValue(visitor, vreg, tag);
Sebastien Hertz8009f392014-09-01 17:07:11 +02002664 }
Sebastien Hertzabbabc82015-03-26 08:47:47 +01002665 VLOG(jdwp) << "get float local " << vreg << " = " << intVal;
2666 JDWP::Set4BE(buf + 1, intVal);
Sebastien Hertz8009f392014-09-01 17:07:11 +02002667 break;
2668 }
2669 case JDWP::JT_ARRAY:
2670 case JDWP::JT_CLASS_LOADER:
2671 case JDWP::JT_CLASS_OBJECT:
2672 case JDWP::JT_OBJECT:
2673 case JDWP::JT_STRING:
2674 case JDWP::JT_THREAD:
2675 case JDWP::JT_THREAD_GROUP: {
2676 CHECK_EQ(width, sizeof(JDWP::ObjectId));
2677 uint32_t intVal;
Sebastien Hertzabbabc82015-03-26 08:47:47 +01002678 if (!visitor.GetVReg(m, vreg, kReferenceVReg, &intVal)) {
2679 return FailGetLocalValue(visitor, vreg, tag);
Sebastien Hertz8009f392014-09-01 17:07:11 +02002680 }
Sebastien Hertzabbabc82015-03-26 08:47:47 +01002681 mirror::Object* o = reinterpret_cast<mirror::Object*>(intVal);
2682 VLOG(jdwp) << "get " << tag << " object local " << vreg << " = " << o;
2683 if (!Runtime::Current()->GetHeap()->IsValidObjectAddress(o)) {
2684 LOG(FATAL) << StringPrintf("Found invalid object %#" PRIxPTR " in register v%u",
2685 reinterpret_cast<uintptr_t>(o), vreg)
2686 << GetStackContextAsString(visitor);
2687 UNREACHABLE();
2688 }
2689 tag = TagFromObject(soa, o);
2690 JDWP::SetObjectId(buf + 1, gRegistry->Add(o));
Sebastien Hertz8009f392014-09-01 17:07:11 +02002691 break;
2692 }
2693 case JDWP::JT_DOUBLE: {
2694 CHECK_EQ(width, 8U);
2695 uint64_t longVal;
Sebastien Hertzabbabc82015-03-26 08:47:47 +01002696 if (!visitor.GetVRegPair(m, vreg, kDoubleLoVReg, kDoubleHiVReg, &longVal)) {
2697 return FailGetLocalValue(visitor, vreg, tag);
Sebastien Hertz8009f392014-09-01 17:07:11 +02002698 }
Sebastien Hertzabbabc82015-03-26 08:47:47 +01002699 VLOG(jdwp) << "get double local " << vreg << " = " << longVal;
2700 JDWP::Set8BE(buf + 1, longVal);
Sebastien Hertz8009f392014-09-01 17:07:11 +02002701 break;
2702 }
2703 case JDWP::JT_LONG: {
2704 CHECK_EQ(width, 8U);
2705 uint64_t longVal;
Sebastien Hertzabbabc82015-03-26 08:47:47 +01002706 if (!visitor.GetVRegPair(m, vreg, kLongLoVReg, kLongHiVReg, &longVal)) {
2707 return FailGetLocalValue(visitor, vreg, tag);
Sebastien Hertz8009f392014-09-01 17:07:11 +02002708 }
Sebastien Hertzabbabc82015-03-26 08:47:47 +01002709 VLOG(jdwp) << "get long local " << vreg << " = " << longVal;
2710 JDWP::Set8BE(buf + 1, longVal);
Sebastien Hertz8009f392014-09-01 17:07:11 +02002711 break;
2712 }
2713 default:
2714 LOG(FATAL) << "Unknown tag " << tag;
Sebastien Hertzabbabc82015-03-26 08:47:47 +01002715 UNREACHABLE();
Sebastien Hertz8009f392014-09-01 17:07:11 +02002716 }
Ian Rogers0399dde2012-06-06 17:09:28 -07002717
Sebastien Hertz8009f392014-09-01 17:07:11 +02002718 // Prepend tag, which may have been updated.
2719 JDWP::Set1(buf, tag);
2720 return JDWP::ERR_NONE;
2721}
2722
2723JDWP::JdwpError Dbg::SetLocalValues(JDWP::Request* request) {
2724 JDWP::ObjectId thread_id = request->ReadThreadId();
2725 JDWP::FrameId frame_id = request->ReadFrameId();
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002726
2727 ScopedObjectAccessUnchecked soa(Thread::Current());
Sebastien Hertz69206392015-04-07 15:54:25 +02002728 JDWP::JdwpError error;
2729 Thread* thread = DecodeThread(soa, thread_id, &error);
2730 if (error != JDWP::ERR_NONE) {
2731 return error;
2732 }
2733 if (!IsSuspendedForDebugger(soa, thread)) {
2734 return JDWP::ERR_THREAD_NOT_SUSPENDED;
Elliott Hughes221229c2013-01-08 18:17:50 -08002735 }
Sebastien Hertz8009f392014-09-01 17:07:11 +02002736 // Find the frame with the given frame_id.
Ian Rogers700a4022014-05-19 16:49:03 -07002737 std::unique_ptr<Context> context(Context::Create());
Sebastien Hertz8009f392014-09-01 17:07:11 +02002738 FindFrameVisitor visitor(thread, context.get(), frame_id);
Ian Rogers0399dde2012-06-06 17:09:28 -07002739 visitor.WalkStack();
Sebastien Hertz8009f392014-09-01 17:07:11 +02002740 if (visitor.GetError() != JDWP::ERR_NONE) {
2741 return visitor.GetError();
2742 }
2743
2744 // Writes the values into visitor's context.
2745 int32_t slot_count = request->ReadSigned32("slot count");
2746 for (int32_t i = 0; i < slot_count; ++i) {
2747 uint32_t slot = request->ReadUnsigned32("slot");
2748 JDWP::JdwpTag sigByte = request->ReadTag();
2749 size_t width = Dbg::GetTagWidth(sigByte);
2750 uint64_t value = request->ReadValue(width);
2751
2752 VLOG(jdwp) << " --> slot " << slot << " " << sigByte << " " << value;
Mingyao Yang99170c62015-07-06 11:10:37 -07002753 error = Dbg::SetLocalValue(thread, visitor, slot, sigByte, value, width);
Sebastien Hertz8009f392014-09-01 17:07:11 +02002754 if (error != JDWP::ERR_NONE) {
2755 return error;
2756 }
2757 }
2758 return JDWP::ERR_NONE;
2759}
2760
Sebastien Hertzabbabc82015-03-26 08:47:47 +01002761template<typename T>
2762static JDWP::JdwpError FailSetLocalValue(const StackVisitor& visitor, uint16_t vreg,
2763 JDWP::JdwpTag tag, T value)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07002764 REQUIRES_SHARED(Locks::mutator_lock_) {
Sebastien Hertzabbabc82015-03-26 08:47:47 +01002765 LOG(ERROR) << "Failed to write " << tag << " local " << value
2766 << " (0x" << std::hex << value << ") into register v" << vreg
2767 << GetStackContextAsString(visitor);
2768 return kStackFrameLocalAccessError;
2769}
2770
Mingyao Yang99170c62015-07-06 11:10:37 -07002771JDWP::JdwpError Dbg::SetLocalValue(Thread* thread, StackVisitor& visitor, int slot,
2772 JDWP::JdwpTag tag, uint64_t value, size_t width) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07002773 ArtMethod* m = visitor.GetMethod();
Sebastien Hertzabbabc82015-03-26 08:47:47 +01002774 JDWP::JdwpError error = JDWP::ERR_NONE;
2775 uint16_t vreg = DemangleSlot(slot, m, &error);
2776 if (error != JDWP::ERR_NONE) {
2777 return error;
2778 }
Sebastien Hertz8009f392014-09-01 17:07:11 +02002779 // TODO: check that the tag is compatible with the actual type of the slot!
Sebastien Hertz8009f392014-09-01 17:07:11 +02002780 switch (tag) {
2781 case JDWP::JT_BOOLEAN:
2782 case JDWP::JT_BYTE:
2783 CHECK_EQ(width, 1U);
Mingyao Yang636b9252015-07-31 16:40:24 -07002784 if (!visitor.SetVReg(m, vreg, static_cast<uint32_t>(value), kIntVReg)) {
Sebastien Hertzabbabc82015-03-26 08:47:47 +01002785 return FailSetLocalValue(visitor, vreg, tag, static_cast<uint32_t>(value));
Sebastien Hertz8009f392014-09-01 17:07:11 +02002786 }
2787 break;
2788 case JDWP::JT_SHORT:
2789 case JDWP::JT_CHAR:
2790 CHECK_EQ(width, 2U);
Mingyao Yang636b9252015-07-31 16:40:24 -07002791 if (!visitor.SetVReg(m, vreg, static_cast<uint32_t>(value), kIntVReg)) {
Sebastien Hertzabbabc82015-03-26 08:47:47 +01002792 return FailSetLocalValue(visitor, vreg, tag, static_cast<uint32_t>(value));
Sebastien Hertz8009f392014-09-01 17:07:11 +02002793 }
2794 break;
2795 case JDWP::JT_INT:
2796 CHECK_EQ(width, 4U);
Mingyao Yang636b9252015-07-31 16:40:24 -07002797 if (!visitor.SetVReg(m, vreg, static_cast<uint32_t>(value), kIntVReg)) {
Sebastien Hertzabbabc82015-03-26 08:47:47 +01002798 return FailSetLocalValue(visitor, vreg, tag, static_cast<uint32_t>(value));
Sebastien Hertz8009f392014-09-01 17:07:11 +02002799 }
2800 break;
2801 case JDWP::JT_FLOAT:
2802 CHECK_EQ(width, 4U);
Mingyao Yang636b9252015-07-31 16:40:24 -07002803 if (!visitor.SetVReg(m, vreg, static_cast<uint32_t>(value), kFloatVReg)) {
Sebastien Hertzabbabc82015-03-26 08:47:47 +01002804 return FailSetLocalValue(visitor, vreg, tag, static_cast<uint32_t>(value));
Sebastien Hertz8009f392014-09-01 17:07:11 +02002805 }
2806 break;
2807 case JDWP::JT_ARRAY:
2808 case JDWP::JT_CLASS_LOADER:
2809 case JDWP::JT_CLASS_OBJECT:
2810 case JDWP::JT_OBJECT:
2811 case JDWP::JT_STRING:
2812 case JDWP::JT_THREAD:
2813 case JDWP::JT_THREAD_GROUP: {
2814 CHECK_EQ(width, sizeof(JDWP::ObjectId));
Sebastien Hertz8009f392014-09-01 17:07:11 +02002815 mirror::Object* o = gRegistry->Get<mirror::Object*>(static_cast<JDWP::ObjectId>(value),
2816 &error);
2817 if (error != JDWP::ERR_NONE) {
2818 VLOG(jdwp) << tag << " object " << o << " is an invalid object";
2819 return JDWP::ERR_INVALID_OBJECT;
Sebastien Hertzabbabc82015-03-26 08:47:47 +01002820 }
Mingyao Yang636b9252015-07-31 16:40:24 -07002821 if (!visitor.SetVReg(m, vreg, static_cast<uint32_t>(reinterpret_cast<uintptr_t>(o)),
Sebastien Hertzabbabc82015-03-26 08:47:47 +01002822 kReferenceVReg)) {
2823 return FailSetLocalValue(visitor, vreg, tag, reinterpret_cast<uintptr_t>(o));
Sebastien Hertz8009f392014-09-01 17:07:11 +02002824 }
2825 break;
2826 }
2827 case JDWP::JT_DOUBLE: {
2828 CHECK_EQ(width, 8U);
Mingyao Yang636b9252015-07-31 16:40:24 -07002829 if (!visitor.SetVRegPair(m, vreg, value, kDoubleLoVReg, kDoubleHiVReg)) {
Sebastien Hertzabbabc82015-03-26 08:47:47 +01002830 return FailSetLocalValue(visitor, vreg, tag, value);
Sebastien Hertz8009f392014-09-01 17:07:11 +02002831 }
2832 break;
2833 }
2834 case JDWP::JT_LONG: {
2835 CHECK_EQ(width, 8U);
Mingyao Yang636b9252015-07-31 16:40:24 -07002836 if (!visitor.SetVRegPair(m, vreg, value, kLongLoVReg, kLongHiVReg)) {
Sebastien Hertzabbabc82015-03-26 08:47:47 +01002837 return FailSetLocalValue(visitor, vreg, tag, value);
Sebastien Hertz8009f392014-09-01 17:07:11 +02002838 }
2839 break;
2840 }
2841 default:
2842 LOG(FATAL) << "Unknown tag " << tag;
Sebastien Hertzabbabc82015-03-26 08:47:47 +01002843 UNREACHABLE();
Sebastien Hertz8009f392014-09-01 17:07:11 +02002844 }
Mingyao Yang99170c62015-07-06 11:10:37 -07002845
2846 // If we set the local variable in a compiled frame, we need to trigger a deoptimization of
2847 // the stack so we continue execution with the interpreter using the new value(s) of the updated
2848 // local variable(s). To achieve this, we install instrumentation exit stub on each method of the
2849 // thread's stack. The stub will cause the deoptimization to happen.
2850 if (!visitor.IsShadowFrame() && thread->HasDebuggerShadowFrames()) {
2851 Runtime::Current()->GetInstrumentation()->InstrumentThreadStack(thread);
2852 }
2853
Sebastien Hertz8009f392014-09-01 17:07:11 +02002854 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002855}
2856
Mathieu Chartiere401d142015-04-22 13:56:20 -07002857static void SetEventLocation(JDWP::EventLocation* location, ArtMethod* m, uint32_t dex_pc)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07002858 REQUIRES_SHARED(Locks::mutator_lock_) {
Sebastien Hertz6995c602014-09-09 12:10:13 +02002859 DCHECK(location != nullptr);
2860 if (m == nullptr) {
2861 memset(location, 0, sizeof(*location));
2862 } else {
Alex Light6c8467f2015-11-20 15:03:26 -08002863 location->method = GetCanonicalMethod(m);
Sebastien Hertz6995c602014-09-09 12:10:13 +02002864 location->dex_pc = (m->IsNative() || m->IsProxyMethod()) ? static_cast<uint32_t>(-1) : dex_pc;
Sebastien Hertz3f52eaf2014-04-04 17:50:18 +02002865 }
Sebastien Hertz3f52eaf2014-04-04 17:50:18 +02002866}
2867
Mathieu Chartiere401d142015-04-22 13:56:20 -07002868void Dbg::PostLocationEvent(ArtMethod* m, int dex_pc, mirror::Object* this_object,
Jeff Hao579b0242013-11-18 13:16:49 -08002869 int event_flags, const JValue* return_value) {
Sebastien Hertz3f52eaf2014-04-04 17:50:18 +02002870 if (!IsDebuggerActive()) {
2871 return;
2872 }
2873 DCHECK(m != nullptr);
2874 DCHECK_EQ(m->IsStatic(), this_object == nullptr);
Sebastien Hertz6995c602014-09-09 12:10:13 +02002875 JDWP::EventLocation location;
2876 SetEventLocation(&location, m, dex_pc);
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08002877
Sebastien Hertzde48aa62015-05-26 11:53:39 +02002878 // We need to be sure no exception is pending when calling JdwpState::PostLocationEvent.
2879 // This is required to be able to call JNI functions to create JDWP ids. To achieve this,
2880 // we temporarily clear the current thread's exception (if any) and will restore it after
2881 // the call.
2882 // Note: the only way to get a pending exception here is to suspend on a move-exception
2883 // instruction.
2884 Thread* const self = Thread::Current();
2885 StackHandleScope<1> hs(self);
2886 Handle<mirror::Throwable> pending_exception(hs.NewHandle(self->GetException()));
2887 self->ClearException();
2888 if (kIsDebugBuild && pending_exception.Get() != nullptr) {
2889 const DexFile::CodeItem* code_item = location.method->GetCodeItem();
2890 const Instruction* instr = Instruction::At(&code_item->insns_[location.dex_pc]);
2891 CHECK_EQ(Instruction::MOVE_EXCEPTION, instr->Opcode());
2892 }
2893
Sebastien Hertz6995c602014-09-09 12:10:13 +02002894 gJdwpState->PostLocationEvent(&location, this_object, event_flags, return_value);
Sebastien Hertzde48aa62015-05-26 11:53:39 +02002895
2896 if (pending_exception.Get() != nullptr) {
2897 self->SetException(pending_exception.Get());
2898 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002899}
2900
Mathieu Chartiere401d142015-04-22 13:56:20 -07002901void Dbg::PostFieldAccessEvent(ArtMethod* m, int dex_pc,
Mathieu Chartierc7853442015-03-27 14:35:38 -07002902 mirror::Object* this_object, ArtField* f) {
Sebastien Hertz3f52eaf2014-04-04 17:50:18 +02002903 if (!IsDebuggerActive()) {
2904 return;
2905 }
2906 DCHECK(m != nullptr);
2907 DCHECK(f != nullptr);
Sebastien Hertz6995c602014-09-09 12:10:13 +02002908 JDWP::EventLocation location;
2909 SetEventLocation(&location, m, dex_pc);
Sebastien Hertz3f52eaf2014-04-04 17:50:18 +02002910
Sebastien Hertz6995c602014-09-09 12:10:13 +02002911 gJdwpState->PostFieldEvent(&location, f, this_object, nullptr, false);
Sebastien Hertz3f52eaf2014-04-04 17:50:18 +02002912}
2913
Mathieu Chartiere401d142015-04-22 13:56:20 -07002914void Dbg::PostFieldModificationEvent(ArtMethod* m, int dex_pc,
Mathieu Chartierc7853442015-03-27 14:35:38 -07002915 mirror::Object* this_object, ArtField* f,
Sebastien Hertz3f52eaf2014-04-04 17:50:18 +02002916 const JValue* field_value) {
2917 if (!IsDebuggerActive()) {
2918 return;
2919 }
2920 DCHECK(m != nullptr);
2921 DCHECK(f != nullptr);
2922 DCHECK(field_value != nullptr);
Sebastien Hertz6995c602014-09-09 12:10:13 +02002923 JDWP::EventLocation location;
2924 SetEventLocation(&location, m, dex_pc);
Sebastien Hertz3f52eaf2014-04-04 17:50:18 +02002925
Sebastien Hertz6995c602014-09-09 12:10:13 +02002926 gJdwpState->PostFieldEvent(&location, f, this_object, field_value, true);
Sebastien Hertz3f52eaf2014-04-04 17:50:18 +02002927}
2928
Nicolas Geoffray14691c52015-03-05 10:40:17 +00002929/**
2930 * Finds the location where this exception will be caught. We search until we reach the top
2931 * frame, in which case this exception is considered uncaught.
2932 */
2933class CatchLocationFinder : public StackVisitor {
2934 public:
2935 CatchLocationFinder(Thread* self, const Handle<mirror::Throwable>& exception, Context* context)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07002936 REQUIRES_SHARED(Locks::mutator_lock_)
Nicolas Geoffray8e5bd182015-05-06 11:34:34 +01002937 : StackVisitor(self, context, StackVisitor::StackWalkKind::kIncludeInlinedFrames),
Nicolas Geoffray14691c52015-03-05 10:40:17 +00002938 exception_(exception),
2939 handle_scope_(self),
2940 this_at_throw_(handle_scope_.NewHandle<mirror::Object>(nullptr)),
Mathieu Chartiere401d142015-04-22 13:56:20 -07002941 catch_method_(nullptr),
2942 throw_method_(nullptr),
Nicolas Geoffray14691c52015-03-05 10:40:17 +00002943 catch_dex_pc_(DexFile::kDexNoIndex),
2944 throw_dex_pc_(DexFile::kDexNoIndex) {
2945 }
2946
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07002947 bool VisitFrame() OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07002948 ArtMethod* method = GetMethod();
Nicolas Geoffray14691c52015-03-05 10:40:17 +00002949 DCHECK(method != nullptr);
2950 if (method->IsRuntimeMethod()) {
2951 // Ignore callee save method.
2952 DCHECK(method->IsCalleeSaveMethod());
2953 return true;
2954 }
2955
2956 uint32_t dex_pc = GetDexPc();
Mathieu Chartiere401d142015-04-22 13:56:20 -07002957 if (throw_method_ == nullptr) {
Nicolas Geoffray14691c52015-03-05 10:40:17 +00002958 // First Java method found. It is either the method that threw the exception,
2959 // or the Java native method that is reporting an exception thrown by
2960 // native code.
2961 this_at_throw_.Assign(GetThisObject());
Mathieu Chartiere401d142015-04-22 13:56:20 -07002962 throw_method_ = method;
Nicolas Geoffray14691c52015-03-05 10:40:17 +00002963 throw_dex_pc_ = dex_pc;
2964 }
2965
2966 if (dex_pc != DexFile::kDexNoIndex) {
Sebastien Hertz26f72862015-09-15 09:52:07 +02002967 StackHandleScope<1> hs(GetThread());
Nicolas Geoffray14691c52015-03-05 10:40:17 +00002968 uint32_t found_dex_pc;
2969 Handle<mirror::Class> exception_class(hs.NewHandle(exception_->GetClass()));
Nicolas Geoffray14691c52015-03-05 10:40:17 +00002970 bool unused_clear_exception;
Mathieu Chartiere401d142015-04-22 13:56:20 -07002971 found_dex_pc = method->FindCatchBlock(exception_class, dex_pc, &unused_clear_exception);
Nicolas Geoffray14691c52015-03-05 10:40:17 +00002972 if (found_dex_pc != DexFile::kDexNoIndex) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07002973 catch_method_ = method;
Nicolas Geoffray14691c52015-03-05 10:40:17 +00002974 catch_dex_pc_ = found_dex_pc;
2975 return false; // End stack walk.
2976 }
2977 }
2978 return true; // Continue stack walk.
2979 }
2980
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07002981 ArtMethod* GetCatchMethod() REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07002982 return catch_method_;
Nicolas Geoffray14691c52015-03-05 10:40:17 +00002983 }
2984
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07002985 ArtMethod* GetThrowMethod() REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07002986 return throw_method_;
Nicolas Geoffray14691c52015-03-05 10:40:17 +00002987 }
2988
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07002989 mirror::Object* GetThisAtThrow() REQUIRES_SHARED(Locks::mutator_lock_) {
Nicolas Geoffray14691c52015-03-05 10:40:17 +00002990 return this_at_throw_.Get();
2991 }
2992
2993 uint32_t GetCatchDexPc() const {
2994 return catch_dex_pc_;
2995 }
2996
2997 uint32_t GetThrowDexPc() const {
2998 return throw_dex_pc_;
2999 }
3000
3001 private:
Nicolas Geoffray14691c52015-03-05 10:40:17 +00003002 const Handle<mirror::Throwable>& exception_;
Mathieu Chartiere401d142015-04-22 13:56:20 -07003003 StackHandleScope<1> handle_scope_;
Nicolas Geoffray14691c52015-03-05 10:40:17 +00003004 MutableHandle<mirror::Object> this_at_throw_;
Mathieu Chartiere401d142015-04-22 13:56:20 -07003005 ArtMethod* catch_method_;
3006 ArtMethod* throw_method_;
Nicolas Geoffray14691c52015-03-05 10:40:17 +00003007 uint32_t catch_dex_pc_;
3008 uint32_t throw_dex_pc_;
3009
3010 DISALLOW_COPY_AND_ASSIGN(CatchLocationFinder);
3011};
3012
3013void Dbg::PostException(mirror::Throwable* exception_object) {
Elliott Hughesc0f09332012-03-26 13:27:06 -07003014 if (!IsDebuggerActive()) {
Ian Rogers0ad5bb82011-12-07 10:16:32 -08003015 return;
3016 }
Sebastien Hertz261bc042015-04-08 09:36:07 +02003017 Thread* const self = Thread::Current();
3018 StackHandleScope<1> handle_scope(self);
Nicolas Geoffray14691c52015-03-05 10:40:17 +00003019 Handle<mirror::Throwable> h_exception(handle_scope.NewHandle(exception_object));
3020 std::unique_ptr<Context> context(Context::Create());
Sebastien Hertz261bc042015-04-08 09:36:07 +02003021 CatchLocationFinder clf(self, h_exception, context.get());
Nicolas Geoffray14691c52015-03-05 10:40:17 +00003022 clf.WalkStack(/* include_transitions */ false);
Sebastien Hertz6995c602014-09-09 12:10:13 +02003023 JDWP::EventLocation exception_throw_location;
Nicolas Geoffray14691c52015-03-05 10:40:17 +00003024 SetEventLocation(&exception_throw_location, clf.GetThrowMethod(), clf.GetThrowDexPc());
Sebastien Hertz6995c602014-09-09 12:10:13 +02003025 JDWP::EventLocation exception_catch_location;
Nicolas Geoffray14691c52015-03-05 10:40:17 +00003026 SetEventLocation(&exception_catch_location, clf.GetCatchMethod(), clf.GetCatchDexPc());
Elliott Hughes4740cdf2011-12-07 14:07:12 -08003027
Nicolas Geoffray14691c52015-03-05 10:40:17 +00003028 gJdwpState->PostException(&exception_throw_location, h_exception.Get(), &exception_catch_location,
3029 clf.GetThisAtThrow());
Elliott Hughes872d4ec2011-10-21 17:07:15 -07003030}
3031
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08003032void Dbg::PostClassPrepare(mirror::Class* c) {
Elliott Hughesc0f09332012-03-26 13:27:06 -07003033 if (!IsDebuggerActive()) {
Elliott Hughes4740cdf2011-12-07 14:07:12 -08003034 return;
3035 }
Sebastien Hertz6995c602014-09-09 12:10:13 +02003036 gJdwpState->PostClassPrepare(c);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07003037}
3038
Ian Rogers62d6c772013-02-27 08:32:07 -08003039void Dbg::UpdateDebugger(Thread* thread, mirror::Object* this_object,
Mathieu Chartiere401d142015-04-22 13:56:20 -07003040 ArtMethod* m, uint32_t dex_pc,
Sebastien Hertz8379b222014-02-24 17:38:15 +01003041 int event_flags, const JValue* return_value) {
Ian Rogers62d6c772013-02-27 08:32:07 -08003042 if (!IsDebuggerActive() || dex_pc == static_cast<uint32_t>(-2) /* fake method exit */) {
Elliott Hughes2aa2e392012-02-17 17:15:43 -08003043 return;
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08003044 }
3045
Elliott Hughes86964332012-02-15 19:37:42 -08003046 if (IsBreakpoint(m, dex_pc)) {
3047 event_flags |= kBreakpoint;
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08003048 }
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08003049
Sebastien Hertz61b7f1b2013-11-15 15:59:30 +01003050 // If the debugger is single-stepping one of our threads, check to
3051 // see if we're that thread and we've reached a step point.
3052 const SingleStepControl* single_step_control = thread->GetSingleStepControl();
Sebastien Hertz597c4f02015-01-26 17:37:14 +01003053 if (single_step_control != nullptr) {
Sebastien Hertz61b7f1b2013-11-15 15:59:30 +01003054 CHECK(!m->IsNative());
Sebastien Hertz597c4f02015-01-26 17:37:14 +01003055 if (single_step_control->GetStepDepth() == JDWP::SD_INTO) {
Sebastien Hertz61b7f1b2013-11-15 15:59:30 +01003056 // Step into method calls. We break when the line number
3057 // or method pointer changes. If we're in SS_MIN mode, we
3058 // always stop.
Sebastien Hertz597c4f02015-01-26 17:37:14 +01003059 if (single_step_control->GetMethod() != m) {
Sebastien Hertz61b7f1b2013-11-15 15:59:30 +01003060 event_flags |= kSingleStep;
3061 VLOG(jdwp) << "SS new method";
Sebastien Hertz597c4f02015-01-26 17:37:14 +01003062 } else if (single_step_control->GetStepSize() == JDWP::SS_MIN) {
Sebastien Hertz61b7f1b2013-11-15 15:59:30 +01003063 event_flags |= kSingleStep;
3064 VLOG(jdwp) << "SS new instruction";
Sebastien Hertzbb43b432014-04-14 11:59:08 +02003065 } else if (single_step_control->ContainsDexPc(dex_pc)) {
Sebastien Hertz61b7f1b2013-11-15 15:59:30 +01003066 event_flags |= kSingleStep;
3067 VLOG(jdwp) << "SS new line";
3068 }
Sebastien Hertz597c4f02015-01-26 17:37:14 +01003069 } else if (single_step_control->GetStepDepth() == JDWP::SD_OVER) {
Sebastien Hertz61b7f1b2013-11-15 15:59:30 +01003070 // Step over method calls. We break when the line number is
3071 // different and the frame depth is <= the original frame
3072 // depth. (We can't just compare on the method, because we
3073 // might get unrolled past it by an exception, and it's tricky
3074 // to identify recursion.)
3075
3076 int stack_depth = GetStackDepth(thread);
3077
Sebastien Hertz597c4f02015-01-26 17:37:14 +01003078 if (stack_depth < single_step_control->GetStackDepth()) {
Sebastien Hertz61b7f1b2013-11-15 15:59:30 +01003079 // Popped up one or more frames, always trigger.
3080 event_flags |= kSingleStep;
3081 VLOG(jdwp) << "SS method pop";
Sebastien Hertz597c4f02015-01-26 17:37:14 +01003082 } else if (stack_depth == single_step_control->GetStackDepth()) {
Sebastien Hertz61b7f1b2013-11-15 15:59:30 +01003083 // Same depth, see if we moved.
Sebastien Hertz597c4f02015-01-26 17:37:14 +01003084 if (single_step_control->GetStepSize() == JDWP::SS_MIN) {
Elliott Hughes86964332012-02-15 19:37:42 -08003085 event_flags |= kSingleStep;
3086 VLOG(jdwp) << "SS new instruction";
Sebastien Hertzbb43b432014-04-14 11:59:08 +02003087 } else if (single_step_control->ContainsDexPc(dex_pc)) {
Elliott Hughes2435a572012-02-17 16:07:41 -08003088 event_flags |= kSingleStep;
3089 VLOG(jdwp) << "SS new line";
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08003090 }
Sebastien Hertz61b7f1b2013-11-15 15:59:30 +01003091 }
3092 } else {
Sebastien Hertz597c4f02015-01-26 17:37:14 +01003093 CHECK_EQ(single_step_control->GetStepDepth(), JDWP::SD_OUT);
Sebastien Hertz61b7f1b2013-11-15 15:59:30 +01003094 // Return from the current method. We break when the frame
3095 // depth pops up.
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08003096
Sebastien Hertz61b7f1b2013-11-15 15:59:30 +01003097 // This differs from the "method exit" break in that it stops
3098 // with the PC at the next instruction in the returned-to
3099 // function, rather than the end of the returning function.
Elliott Hughes86964332012-02-15 19:37:42 -08003100
Sebastien Hertz61b7f1b2013-11-15 15:59:30 +01003101 int stack_depth = GetStackDepth(thread);
Sebastien Hertz597c4f02015-01-26 17:37:14 +01003102 if (stack_depth < single_step_control->GetStackDepth()) {
Sebastien Hertz61b7f1b2013-11-15 15:59:30 +01003103 event_flags |= kSingleStep;
3104 VLOG(jdwp) << "SS method pop";
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08003105 }
3106 }
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08003107 }
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08003108
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08003109 // If there's something interesting going on, see if it matches one
3110 // of the debugger filters.
3111 if (event_flags != 0) {
Sebastien Hertz8379b222014-02-24 17:38:15 +01003112 Dbg::PostLocationEvent(m, dex_pc, this_object, event_flags, return_value);
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08003113 }
3114}
3115
Sebastien Hertz42cd43f2014-05-13 14:15:41 +02003116size_t* Dbg::GetReferenceCounterForEvent(uint32_t instrumentation_event) {
3117 switch (instrumentation_event) {
3118 case instrumentation::Instrumentation::kMethodEntered:
3119 return &method_enter_event_ref_count_;
3120 case instrumentation::Instrumentation::kMethodExited:
3121 return &method_exit_event_ref_count_;
3122 case instrumentation::Instrumentation::kDexPcMoved:
3123 return &dex_pc_change_event_ref_count_;
3124 case instrumentation::Instrumentation::kFieldRead:
3125 return &field_read_event_ref_count_;
3126 case instrumentation::Instrumentation::kFieldWritten:
3127 return &field_write_event_ref_count_;
3128 case instrumentation::Instrumentation::kExceptionCaught:
3129 return &exception_catch_event_ref_count_;
3130 default:
3131 return nullptr;
3132 }
3133}
3134
Sebastien Hertz4d25df32014-03-21 17:44:46 +01003135// Process request while all mutator threads are suspended.
3136void Dbg::ProcessDeoptimizationRequest(const DeoptimizationRequest& request) {
Sebastien Hertz138dbfc2013-12-04 18:15:25 +01003137 instrumentation::Instrumentation* instrumentation = Runtime::Current()->GetInstrumentation();
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -07003138 switch (request.GetKind()) {
Sebastien Hertz4d25df32014-03-21 17:44:46 +01003139 case DeoptimizationRequest::kNothing:
3140 LOG(WARNING) << "Ignoring empty deoptimization request.";
3141 break;
Sebastien Hertz42cd43f2014-05-13 14:15:41 +02003142 case DeoptimizationRequest::kRegisterForEvent:
3143 VLOG(jdwp) << StringPrintf("Add debugger as listener for instrumentation event 0x%x",
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -07003144 request.InstrumentationEvent());
3145 instrumentation->AddListener(&gDebugInstrumentationListener, request.InstrumentationEvent());
3146 instrumentation_events_ |= request.InstrumentationEvent();
Sebastien Hertz42cd43f2014-05-13 14:15:41 +02003147 break;
3148 case DeoptimizationRequest::kUnregisterForEvent:
3149 VLOG(jdwp) << StringPrintf("Remove debugger as listener for instrumentation event 0x%x",
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -07003150 request.InstrumentationEvent());
Sebastien Hertz42cd43f2014-05-13 14:15:41 +02003151 instrumentation->RemoveListener(&gDebugInstrumentationListener,
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -07003152 request.InstrumentationEvent());
3153 instrumentation_events_ &= ~request.InstrumentationEvent();
Sebastien Hertz42cd43f2014-05-13 14:15:41 +02003154 break;
Sebastien Hertz4d25df32014-03-21 17:44:46 +01003155 case DeoptimizationRequest::kFullDeoptimization:
Sebastien Hertz7ec2f1c2014-03-27 20:06:47 +01003156 VLOG(jdwp) << "Deoptimize the world ...";
Sebastien Hertz0462c4c2015-04-01 16:34:17 +02003157 instrumentation->DeoptimizeEverything(kDbgInstrumentationKey);
Sebastien Hertz7ec2f1c2014-03-27 20:06:47 +01003158 VLOG(jdwp) << "Deoptimize the world DONE";
Sebastien Hertz4d25df32014-03-21 17:44:46 +01003159 break;
3160 case DeoptimizationRequest::kFullUndeoptimization:
Sebastien Hertz7ec2f1c2014-03-27 20:06:47 +01003161 VLOG(jdwp) << "Undeoptimize the world ...";
Sebastien Hertz0462c4c2015-04-01 16:34:17 +02003162 instrumentation->UndeoptimizeEverything(kDbgInstrumentationKey);
Sebastien Hertz7ec2f1c2014-03-27 20:06:47 +01003163 VLOG(jdwp) << "Undeoptimize the world DONE";
Sebastien Hertz4d25df32014-03-21 17:44:46 +01003164 break;
3165 case DeoptimizationRequest::kSelectiveDeoptimization:
David Sehr709b0702016-10-13 09:12:37 -07003166 VLOG(jdwp) << "Deoptimize method " << ArtMethod::PrettyMethod(request.Method()) << " ...";
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -07003167 instrumentation->Deoptimize(request.Method());
David Sehr709b0702016-10-13 09:12:37 -07003168 VLOG(jdwp) << "Deoptimize method " << ArtMethod::PrettyMethod(request.Method()) << " DONE";
Sebastien Hertz4d25df32014-03-21 17:44:46 +01003169 break;
3170 case DeoptimizationRequest::kSelectiveUndeoptimization:
David Sehr709b0702016-10-13 09:12:37 -07003171 VLOG(jdwp) << "Undeoptimize method " << ArtMethod::PrettyMethod(request.Method()) << " ...";
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -07003172 instrumentation->Undeoptimize(request.Method());
David Sehr709b0702016-10-13 09:12:37 -07003173 VLOG(jdwp) << "Undeoptimize method " << ArtMethod::PrettyMethod(request.Method()) << " DONE";
Sebastien Hertz4d25df32014-03-21 17:44:46 +01003174 break;
3175 default:
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -07003176 LOG(FATAL) << "Unsupported deoptimization request kind " << request.GetKind();
Sebastien Hertz4d25df32014-03-21 17:44:46 +01003177 break;
Sebastien Hertz138dbfc2013-12-04 18:15:25 +01003178 }
Sebastien Hertz138dbfc2013-12-04 18:15:25 +01003179}
3180
Sebastien Hertz4d25df32014-03-21 17:44:46 +01003181void Dbg::RequestDeoptimization(const DeoptimizationRequest& req) {
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -07003182 if (req.GetKind() == DeoptimizationRequest::kNothing) {
Sebastien Hertz4d25df32014-03-21 17:44:46 +01003183 // Nothing to do.
3184 return;
3185 }
Brian Carlstrom306db812014-09-05 13:01:41 -07003186 MutexLock mu(Thread::Current(), *Locks::deoptimization_lock_);
Sebastien Hertz7ec2f1c2014-03-27 20:06:47 +01003187 RequestDeoptimizationLocked(req);
3188}
3189
3190void Dbg::RequestDeoptimizationLocked(const DeoptimizationRequest& req) {
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -07003191 switch (req.GetKind()) {
Sebastien Hertz42cd43f2014-05-13 14:15:41 +02003192 case DeoptimizationRequest::kRegisterForEvent: {
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -07003193 DCHECK_NE(req.InstrumentationEvent(), 0u);
3194 size_t* counter = GetReferenceCounterForEvent(req.InstrumentationEvent());
Sebastien Hertz42cd43f2014-05-13 14:15:41 +02003195 CHECK(counter != nullptr) << StringPrintf("No counter for instrumentation event 0x%x",
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -07003196 req.InstrumentationEvent());
Sebastien Hertz42cd43f2014-05-13 14:15:41 +02003197 if (*counter == 0) {
Sebastien Hertz7d2ae432014-05-15 11:26:34 +02003198 VLOG(jdwp) << StringPrintf("Queue request #%zd to start listening to instrumentation event 0x%x",
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -07003199 deoptimization_requests_.size(), req.InstrumentationEvent());
Sebastien Hertz42cd43f2014-05-13 14:15:41 +02003200 deoptimization_requests_.push_back(req);
3201 }
3202 *counter = *counter + 1;
3203 break;
3204 }
3205 case DeoptimizationRequest::kUnregisterForEvent: {
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -07003206 DCHECK_NE(req.InstrumentationEvent(), 0u);
3207 size_t* counter = GetReferenceCounterForEvent(req.InstrumentationEvent());
Sebastien Hertz42cd43f2014-05-13 14:15:41 +02003208 CHECK(counter != nullptr) << StringPrintf("No counter for instrumentation event 0x%x",
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -07003209 req.InstrumentationEvent());
Sebastien Hertz42cd43f2014-05-13 14:15:41 +02003210 *counter = *counter - 1;
3211 if (*counter == 0) {
Sebastien Hertz7d2ae432014-05-15 11:26:34 +02003212 VLOG(jdwp) << StringPrintf("Queue request #%zd to stop listening to instrumentation event 0x%x",
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -07003213 deoptimization_requests_.size(), req.InstrumentationEvent());
Sebastien Hertz42cd43f2014-05-13 14:15:41 +02003214 deoptimization_requests_.push_back(req);
3215 }
3216 break;
3217 }
Sebastien Hertz4d25df32014-03-21 17:44:46 +01003218 case DeoptimizationRequest::kFullDeoptimization: {
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -07003219 DCHECK(req.Method() == nullptr);
Sebastien Hertz4d25df32014-03-21 17:44:46 +01003220 if (full_deoptimization_event_count_ == 0) {
Sebastien Hertz7ec2f1c2014-03-27 20:06:47 +01003221 VLOG(jdwp) << "Queue request #" << deoptimization_requests_.size()
3222 << " for full deoptimization";
Sebastien Hertz4d25df32014-03-21 17:44:46 +01003223 deoptimization_requests_.push_back(req);
3224 }
3225 ++full_deoptimization_event_count_;
3226 break;
3227 }
3228 case DeoptimizationRequest::kFullUndeoptimization: {
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -07003229 DCHECK(req.Method() == nullptr);
Sebastien Hertze713d932014-05-15 10:48:53 +02003230 DCHECK_GT(full_deoptimization_event_count_, 0U);
Sebastien Hertz4d25df32014-03-21 17:44:46 +01003231 --full_deoptimization_event_count_;
3232 if (full_deoptimization_event_count_ == 0) {
Sebastien Hertz7ec2f1c2014-03-27 20:06:47 +01003233 VLOG(jdwp) << "Queue request #" << deoptimization_requests_.size()
3234 << " for full undeoptimization";
Sebastien Hertz4d25df32014-03-21 17:44:46 +01003235 deoptimization_requests_.push_back(req);
3236 }
3237 break;
3238 }
3239 case DeoptimizationRequest::kSelectiveDeoptimization: {
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -07003240 DCHECK(req.Method() != nullptr);
Sebastien Hertz7ec2f1c2014-03-27 20:06:47 +01003241 VLOG(jdwp) << "Queue request #" << deoptimization_requests_.size()
David Sehr709b0702016-10-13 09:12:37 -07003242 << " for deoptimization of " << req.Method()->PrettyMethod();
Sebastien Hertz4d25df32014-03-21 17:44:46 +01003243 deoptimization_requests_.push_back(req);
3244 break;
3245 }
3246 case DeoptimizationRequest::kSelectiveUndeoptimization: {
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -07003247 DCHECK(req.Method() != nullptr);
Sebastien Hertz7ec2f1c2014-03-27 20:06:47 +01003248 VLOG(jdwp) << "Queue request #" << deoptimization_requests_.size()
David Sehr709b0702016-10-13 09:12:37 -07003249 << " for undeoptimization of " << req.Method()->PrettyMethod();
Sebastien Hertz4d25df32014-03-21 17:44:46 +01003250 deoptimization_requests_.push_back(req);
3251 break;
3252 }
3253 default: {
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -07003254 LOG(FATAL) << "Unknown deoptimization request kind " << req.GetKind();
Sebastien Hertz4d25df32014-03-21 17:44:46 +01003255 break;
3256 }
3257 }
3258}
3259
Sebastien Hertz138dbfc2013-12-04 18:15:25 +01003260void Dbg::ManageDeoptimization() {
3261 Thread* const self = Thread::Current();
3262 {
3263 // Avoid suspend/resume if there is no pending request.
Brian Carlstrom306db812014-09-05 13:01:41 -07003264 MutexLock mu(self, *Locks::deoptimization_lock_);
Sebastien Hertz4d25df32014-03-21 17:44:46 +01003265 if (deoptimization_requests_.empty()) {
Sebastien Hertz138dbfc2013-12-04 18:15:25 +01003266 return;
3267 }
3268 }
3269 CHECK_EQ(self->GetState(), kRunnable);
Mathieu Chartierf1d666e2015-09-03 16:13:34 -07003270 ScopedThreadSuspension sts(self, kWaitingForDeoptimization);
Mathieu Chartieraa516822015-10-02 15:53:37 -07003271 // Required for ProcessDeoptimizationRequest.
3272 gc::ScopedGCCriticalSection gcs(self,
3273 gc::kGcCauseInstrumentation,
3274 gc::kCollectorTypeInstrumentation);
Sebastien Hertz138dbfc2013-12-04 18:15:25 +01003275 // We need to suspend mutator threads first.
Mathieu Chartier4f55e222015-09-04 13:26:21 -07003276 ScopedSuspendAll ssa(__FUNCTION__);
Sebastien Hertz138dbfc2013-12-04 18:15:25 +01003277 const ThreadState old_state = self->SetStateUnsafe(kRunnable);
Sebastien Hertz4d25df32014-03-21 17:44:46 +01003278 {
Brian Carlstrom306db812014-09-05 13:01:41 -07003279 MutexLock mu(self, *Locks::deoptimization_lock_);
Sebastien Hertz7ec2f1c2014-03-27 20:06:47 +01003280 size_t req_index = 0;
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -07003281 for (DeoptimizationRequest& request : deoptimization_requests_) {
Sebastien Hertz7ec2f1c2014-03-27 20:06:47 +01003282 VLOG(jdwp) << "Process deoptimization request #" << req_index++;
Sebastien Hertz4d25df32014-03-21 17:44:46 +01003283 ProcessDeoptimizationRequest(request);
3284 }
3285 deoptimization_requests_.clear();
3286 }
Sebastien Hertz138dbfc2013-12-04 18:15:25 +01003287 CHECK_EQ(self->SetStateUnsafe(old_state), kRunnable);
Sebastien Hertz138dbfc2013-12-04 18:15:25 +01003288}
3289
Mathieu Chartiere401d142015-04-22 13:56:20 -07003290static const Breakpoint* FindFirstBreakpointForMethod(ArtMethod* m)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07003291 REQUIRES_SHARED(Locks::mutator_lock_, Locks::breakpoint_lock_) {
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -07003292 for (Breakpoint& breakpoint : gBreakpoints) {
Alex Light6c8467f2015-11-20 15:03:26 -08003293 if (breakpoint.IsInMethod(m)) {
Sebastien Hertza76a6d42014-03-20 16:40:17 +01003294 return &breakpoint;
3295 }
3296 }
3297 return nullptr;
3298}
3299
Mathieu Chartiere401d142015-04-22 13:56:20 -07003300bool Dbg::MethodHasAnyBreakpoints(ArtMethod* method) {
Mathieu Chartierd8565452015-03-26 09:41:50 -07003301 ReaderMutexLock mu(Thread::Current(), *Locks::breakpoint_lock_);
3302 return FindFirstBreakpointForMethod(method) != nullptr;
3303}
3304
Sebastien Hertza76a6d42014-03-20 16:40:17 +01003305// Sanity checks all existing breakpoints on the same method.
Mathieu Chartiere401d142015-04-22 13:56:20 -07003306static void SanityCheckExistingBreakpoints(ArtMethod* m,
Sebastien Hertzf3928792014-11-17 19:00:37 +01003307 DeoptimizationRequest::Kind deoptimization_kind)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07003308 REQUIRES_SHARED(Locks::mutator_lock_, Locks::breakpoint_lock_) {
Sebastien Hertz4d1e9ab2014-09-18 16:03:34 +02003309 for (const Breakpoint& breakpoint : gBreakpoints) {
Alex Light6c8467f2015-11-20 15:03:26 -08003310 if (breakpoint.IsInMethod(m)) {
Sebastien Hertzf3928792014-11-17 19:00:37 +01003311 CHECK_EQ(deoptimization_kind, breakpoint.GetDeoptimizationKind());
3312 }
Sebastien Hertz4d1e9ab2014-09-18 16:03:34 +02003313 }
Sebastien Hertzf3928792014-11-17 19:00:37 +01003314 instrumentation::Instrumentation* instrumentation = Runtime::Current()->GetInstrumentation();
3315 if (deoptimization_kind == DeoptimizationRequest::kFullDeoptimization) {
Sebastien Hertz4d1e9ab2014-09-18 16:03:34 +02003316 // We should have deoptimized everything but not "selectively" deoptimized this method.
Sebastien Hertzf3928792014-11-17 19:00:37 +01003317 CHECK(instrumentation->AreAllMethodsDeoptimized());
3318 CHECK(!instrumentation->IsDeoptimized(m));
3319 } else if (deoptimization_kind == DeoptimizationRequest::kSelectiveDeoptimization) {
Sebastien Hertz4d1e9ab2014-09-18 16:03:34 +02003320 // We should have "selectively" deoptimized this method.
3321 // Note: while we have not deoptimized everything for this method, we may have done it for
3322 // another event.
Sebastien Hertzf3928792014-11-17 19:00:37 +01003323 CHECK(instrumentation->IsDeoptimized(m));
3324 } else {
3325 // This method does not require deoptimization.
3326 CHECK_EQ(deoptimization_kind, DeoptimizationRequest::kNothing);
3327 CHECK(!instrumentation->IsDeoptimized(m));
3328 }
3329}
3330
Sebastien Hertzabe93e02014-12-17 16:35:50 +01003331// Returns the deoptimization kind required to set a breakpoint in a method.
3332// If a breakpoint has already been set, we also return the first breakpoint
3333// through the given 'existing_brkpt' pointer.
Sebastien Hertzf3928792014-11-17 19:00:37 +01003334static DeoptimizationRequest::Kind GetRequiredDeoptimizationKind(Thread* self,
Mathieu Chartiere401d142015-04-22 13:56:20 -07003335 ArtMethod* m,
Sebastien Hertzabe93e02014-12-17 16:35:50 +01003336 const Breakpoint** existing_brkpt)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07003337 REQUIRES_SHARED(Locks::mutator_lock_) {
Sebastien Hertzf3928792014-11-17 19:00:37 +01003338 if (!Dbg::RequiresDeoptimization()) {
3339 // We already run in interpreter-only mode so we don't need to deoptimize anything.
3340 VLOG(jdwp) << "No need for deoptimization when fully running with interpreter for method "
David Sehr709b0702016-10-13 09:12:37 -07003341 << ArtMethod::PrettyMethod(m);
Sebastien Hertzf3928792014-11-17 19:00:37 +01003342 return DeoptimizationRequest::kNothing;
3343 }
Sebastien Hertzabe93e02014-12-17 16:35:50 +01003344 const Breakpoint* first_breakpoint;
Sebastien Hertzf3928792014-11-17 19:00:37 +01003345 {
3346 ReaderMutexLock mu(self, *Locks::breakpoint_lock_);
Sebastien Hertzabe93e02014-12-17 16:35:50 +01003347 first_breakpoint = FindFirstBreakpointForMethod(m);
3348 *existing_brkpt = first_breakpoint;
Sebastien Hertzf3928792014-11-17 19:00:37 +01003349 }
Sebastien Hertzabe93e02014-12-17 16:35:50 +01003350
3351 if (first_breakpoint == nullptr) {
Nicolas Geoffray6300fd72016-03-18 09:40:17 +00003352 // There is no breakpoint on this method yet: we need to deoptimize. If this method is default,
3353 // we deoptimize everything; otherwise we deoptimize only this method. We
Alex Light6c8467f2015-11-20 15:03:26 -08003354 // deoptimize with defaults because we do not know everywhere they are used. It is possible some
Nicolas Geoffray6300fd72016-03-18 09:40:17 +00003355 // of the copies could be missed.
Alex Light6c8467f2015-11-20 15:03:26 -08003356 // TODO Deoptimizing on default methods might not be necessary in all cases.
Nicolas Geoffray6300fd72016-03-18 09:40:17 +00003357 bool need_full_deoptimization = m->IsDefault();
Sebastien Hertzf3928792014-11-17 19:00:37 +01003358 if (need_full_deoptimization) {
Nicolas Geoffray6300fd72016-03-18 09:40:17 +00003359 VLOG(jdwp) << "Need full deoptimization because of copying of method "
David Sehr709b0702016-10-13 09:12:37 -07003360 << ArtMethod::PrettyMethod(m);
Sebastien Hertzf3928792014-11-17 19:00:37 +01003361 return DeoptimizationRequest::kFullDeoptimization;
3362 } else {
3363 // We don't need to deoptimize if the method has not been compiled.
Nicolas Geoffraya5891e82015-11-06 14:18:27 +00003364 const bool is_compiled = m->HasAnyCompiledCode();
Sebastien Hertzf3928792014-11-17 19:00:37 +01003365 if (is_compiled) {
David Sehr709b0702016-10-13 09:12:37 -07003366 VLOG(jdwp) << "Need selective deoptimization for compiled method "
3367 << ArtMethod::PrettyMethod(m);
Nicolas Geoffray6300fd72016-03-18 09:40:17 +00003368 return DeoptimizationRequest::kSelectiveDeoptimization;
Sebastien Hertzf3928792014-11-17 19:00:37 +01003369 } else {
3370 // Method is not compiled: we don't need to deoptimize.
David Sehr709b0702016-10-13 09:12:37 -07003371 VLOG(jdwp) << "No need for deoptimization for non-compiled method "
3372 << ArtMethod::PrettyMethod(m);
Sebastien Hertzf3928792014-11-17 19:00:37 +01003373 return DeoptimizationRequest::kNothing;
3374 }
3375 }
3376 } else {
3377 // There is at least one breakpoint for this method: we don't need to deoptimize.
3378 // Let's check that all breakpoints are configured the same way for deoptimization.
3379 VLOG(jdwp) << "Breakpoint already set: no deoptimization is required";
Sebastien Hertzabe93e02014-12-17 16:35:50 +01003380 DeoptimizationRequest::Kind deoptimization_kind = first_breakpoint->GetDeoptimizationKind();
Sebastien Hertzf3928792014-11-17 19:00:37 +01003381 if (kIsDebugBuild) {
3382 ReaderMutexLock mu(self, *Locks::breakpoint_lock_);
3383 SanityCheckExistingBreakpoints(m, deoptimization_kind);
3384 }
3385 return DeoptimizationRequest::kNothing;
Sebastien Hertz138dbfc2013-12-04 18:15:25 +01003386 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -07003387}
3388
Sebastien Hertza76a6d42014-03-20 16:40:17 +01003389// Installs a breakpoint at the specified location. Also indicates through the deoptimization
3390// request if we need to deoptimize.
3391void Dbg::WatchLocation(const JDWP::JdwpLocation* location, DeoptimizationRequest* req) {
3392 Thread* const self = Thread::Current();
Mathieu Chartiere401d142015-04-22 13:56:20 -07003393 ArtMethod* m = FromMethodId(location->method_id);
Sebastien Hertza76a6d42014-03-20 16:40:17 +01003394 DCHECK(m != nullptr) << "No method for method id " << location->method_id;
Sebastien Hertz138dbfc2013-12-04 18:15:25 +01003395
Sebastien Hertzabe93e02014-12-17 16:35:50 +01003396 const Breakpoint* existing_breakpoint = nullptr;
3397 const DeoptimizationRequest::Kind deoptimization_kind =
3398 GetRequiredDeoptimizationKind(self, m, &existing_breakpoint);
Sebastien Hertzf3928792014-11-17 19:00:37 +01003399 req->SetKind(deoptimization_kind);
3400 if (deoptimization_kind == DeoptimizationRequest::kSelectiveDeoptimization) {
3401 req->SetMethod(m);
Sebastien Hertza76a6d42014-03-20 16:40:17 +01003402 } else {
Sebastien Hertzf3928792014-11-17 19:00:37 +01003403 CHECK(deoptimization_kind == DeoptimizationRequest::kNothing ||
3404 deoptimization_kind == DeoptimizationRequest::kFullDeoptimization);
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -07003405 req->SetMethod(nullptr);
Sebastien Hertz138dbfc2013-12-04 18:15:25 +01003406 }
3407
Sebastien Hertz4d1e9ab2014-09-18 16:03:34 +02003408 {
3409 WriterMutexLock mu(self, *Locks::breakpoint_lock_);
Sebastien Hertzabe93e02014-12-17 16:35:50 +01003410 // If there is at least one existing breakpoint on the same method, the new breakpoint
3411 // must have the same deoptimization kind than the existing breakpoint(s).
3412 DeoptimizationRequest::Kind breakpoint_deoptimization_kind;
3413 if (existing_breakpoint != nullptr) {
3414 breakpoint_deoptimization_kind = existing_breakpoint->GetDeoptimizationKind();
3415 } else {
3416 breakpoint_deoptimization_kind = deoptimization_kind;
3417 }
3418 gBreakpoints.push_back(Breakpoint(m, location->dex_pc, breakpoint_deoptimization_kind));
Sebastien Hertz4d1e9ab2014-09-18 16:03:34 +02003419 VLOG(jdwp) << "Set breakpoint #" << (gBreakpoints.size() - 1) << ": "
3420 << gBreakpoints[gBreakpoints.size() - 1];
3421 }
Sebastien Hertza76a6d42014-03-20 16:40:17 +01003422}
3423
3424// Uninstalls a breakpoint at the specified location. Also indicates through the deoptimization
3425// request if we need to undeoptimize.
3426void Dbg::UnwatchLocation(const JDWP::JdwpLocation* location, DeoptimizationRequest* req) {
Sebastien Hertzed2be172014-08-19 15:33:43 +02003427 WriterMutexLock mu(Thread::Current(), *Locks::breakpoint_lock_);
Mathieu Chartiere401d142015-04-22 13:56:20 -07003428 ArtMethod* m = FromMethodId(location->method_id);
Sebastien Hertza76a6d42014-03-20 16:40:17 +01003429 DCHECK(m != nullptr) << "No method for method id " << location->method_id;
Sebastien Hertzf3928792014-11-17 19:00:37 +01003430 DeoptimizationRequest::Kind deoptimization_kind = DeoptimizationRequest::kNothing;
Sebastien Hertza76a6d42014-03-20 16:40:17 +01003431 for (size_t i = 0, e = gBreakpoints.size(); i < e; ++i) {
Alex Light6c8467f2015-11-20 15:03:26 -08003432 if (gBreakpoints[i].DexPc() == location->dex_pc && gBreakpoints[i].IsInMethod(m)) {
Sebastien Hertza76a6d42014-03-20 16:40:17 +01003433 VLOG(jdwp) << "Removed breakpoint #" << i << ": " << gBreakpoints[i];
Sebastien Hertzf3928792014-11-17 19:00:37 +01003434 deoptimization_kind = gBreakpoints[i].GetDeoptimizationKind();
3435 DCHECK_EQ(deoptimization_kind == DeoptimizationRequest::kSelectiveDeoptimization,
3436 Runtime::Current()->GetInstrumentation()->IsDeoptimized(m));
Sebastien Hertza76a6d42014-03-20 16:40:17 +01003437 gBreakpoints.erase(gBreakpoints.begin() + i);
3438 break;
3439 }
3440 }
3441 const Breakpoint* const existing_breakpoint = FindFirstBreakpointForMethod(m);
3442 if (existing_breakpoint == nullptr) {
3443 // There is no more breakpoint on this method: we need to undeoptimize.
Sebastien Hertzf3928792014-11-17 19:00:37 +01003444 if (deoptimization_kind == DeoptimizationRequest::kFullDeoptimization) {
Sebastien Hertza76a6d42014-03-20 16:40:17 +01003445 // This method required full deoptimization: we need to undeoptimize everything.
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -07003446 req->SetKind(DeoptimizationRequest::kFullUndeoptimization);
3447 req->SetMethod(nullptr);
Sebastien Hertzf3928792014-11-17 19:00:37 +01003448 } else if (deoptimization_kind == DeoptimizationRequest::kSelectiveDeoptimization) {
Sebastien Hertza76a6d42014-03-20 16:40:17 +01003449 // This method required selective deoptimization: we need to undeoptimize only that method.
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -07003450 req->SetKind(DeoptimizationRequest::kSelectiveUndeoptimization);
3451 req->SetMethod(m);
Sebastien Hertzf3928792014-11-17 19:00:37 +01003452 } else {
3453 // This method had no need for deoptimization: do nothing.
3454 CHECK_EQ(deoptimization_kind, DeoptimizationRequest::kNothing);
3455 req->SetKind(DeoptimizationRequest::kNothing);
3456 req->SetMethod(nullptr);
Sebastien Hertza76a6d42014-03-20 16:40:17 +01003457 }
3458 } else {
3459 // There is at least one breakpoint for this method: we don't need to undeoptimize.
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -07003460 req->SetKind(DeoptimizationRequest::kNothing);
3461 req->SetMethod(nullptr);
Sebastien Hertz4d1e9ab2014-09-18 16:03:34 +02003462 if (kIsDebugBuild) {
Sebastien Hertzf3928792014-11-17 19:00:37 +01003463 SanityCheckExistingBreakpoints(m, deoptimization_kind);
Sebastien Hertz4d1e9ab2014-09-18 16:03:34 +02003464 }
Elliott Hughes86964332012-02-15 19:37:42 -08003465 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -07003466}
3467
Mathieu Chartiere401d142015-04-22 13:56:20 -07003468bool Dbg::IsForcedInterpreterNeededForCallingImpl(Thread* thread, ArtMethod* m) {
Daniel Mihalyieb076692014-08-22 17:33:31 +02003469 const SingleStepControl* const ssc = thread->GetSingleStepControl();
3470 if (ssc == nullptr) {
3471 // If we are not single-stepping, then we don't have to force interpreter.
3472 return false;
3473 }
3474 if (Runtime::Current()->GetInstrumentation()->InterpretOnly()) {
3475 // If we are in interpreter only mode, then we don't have to force interpreter.
3476 return false;
3477 }
3478
3479 if (!m->IsNative() && !m->IsProxyMethod()) {
3480 // If we want to step into a method, then we have to force interpreter on that call.
3481 if (ssc->GetStepDepth() == JDWP::SD_INTO) {
3482 return true;
3483 }
3484 }
3485 return false;
3486}
3487
Mathieu Chartiere401d142015-04-22 13:56:20 -07003488bool Dbg::IsForcedInterpreterNeededForResolutionImpl(Thread* thread, ArtMethod* m) {
Daniel Mihalyieb076692014-08-22 17:33:31 +02003489 instrumentation::Instrumentation* const instrumentation =
3490 Runtime::Current()->GetInstrumentation();
3491 // If we are in interpreter only mode, then we don't have to force interpreter.
3492 if (instrumentation->InterpretOnly()) {
3493 return false;
3494 }
3495 // We can only interpret pure Java method.
3496 if (m->IsNative() || m->IsProxyMethod()) {
3497 return false;
3498 }
3499 const SingleStepControl* const ssc = thread->GetSingleStepControl();
3500 if (ssc != nullptr) {
3501 // If we want to step into a method, then we have to force interpreter on that call.
3502 if (ssc->GetStepDepth() == JDWP::SD_INTO) {
3503 return true;
3504 }
3505 // If we are stepping out from a static initializer, by issuing a step
3506 // in or step over, that was implicitly invoked by calling a static method,
3507 // then we need to step into that method. Having a lower stack depth than
3508 // the one the single step control has indicates that the step originates
3509 // from the static initializer.
3510 if (ssc->GetStepDepth() != JDWP::SD_OUT &&
3511 ssc->GetStackDepth() > GetStackDepth(thread)) {
3512 return true;
3513 }
3514 }
3515 // There are cases where we have to force interpreter on deoptimized methods,
3516 // because in some cases the call will not be performed by invoking an entry
3517 // point that has been replaced by the deoptimization, but instead by directly
3518 // invoking the compiled code of the method, for example.
3519 return instrumentation->IsDeoptimized(m);
3520}
3521
Mathieu Chartiere401d142015-04-22 13:56:20 -07003522bool Dbg::IsForcedInstrumentationNeededForResolutionImpl(Thread* thread, ArtMethod* m) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -07003523 // The upcall can be null and in that case we don't need to do anything.
Daniel Mihalyieb076692014-08-22 17:33:31 +02003524 if (m == nullptr) {
3525 return false;
3526 }
3527 instrumentation::Instrumentation* const instrumentation =
3528 Runtime::Current()->GetInstrumentation();
3529 // If we are in interpreter only mode, then we don't have to force interpreter.
3530 if (instrumentation->InterpretOnly()) {
3531 return false;
3532 }
3533 // We can only interpret pure Java method.
3534 if (m->IsNative() || m->IsProxyMethod()) {
3535 return false;
3536 }
3537 const SingleStepControl* const ssc = thread->GetSingleStepControl();
3538 if (ssc != nullptr) {
3539 // If we are stepping out from a static initializer, by issuing a step
3540 // out, that was implicitly invoked by calling a static method, then we
3541 // need to step into the caller of that method. Having a lower stack
3542 // depth than the one the single step control has indicates that the
3543 // step originates from the static initializer.
3544 if (ssc->GetStepDepth() == JDWP::SD_OUT &&
3545 ssc->GetStackDepth() > GetStackDepth(thread)) {
3546 return true;
3547 }
3548 }
3549 // If we are returning from a static intializer, that was implicitly
3550 // invoked by calling a static method and the caller is deoptimized,
3551 // then we have to deoptimize the stack without forcing interpreter
3552 // on the static method that was called originally. This problem can
3553 // be solved easily by forcing instrumentation on the called method,
3554 // because the instrumentation exit hook will recognise the need of
3555 // stack deoptimization by calling IsForcedInterpreterNeededForUpcall.
3556 return instrumentation->IsDeoptimized(m);
3557}
3558
Mathieu Chartiere401d142015-04-22 13:56:20 -07003559bool Dbg::IsForcedInterpreterNeededForUpcallImpl(Thread* thread, ArtMethod* m) {
Mathieu Chartier2cebb242015-04-21 16:50:40 -07003560 // The upcall can be null and in that case we don't need to do anything.
Daniel Mihalyieb076692014-08-22 17:33:31 +02003561 if (m == nullptr) {
3562 return false;
3563 }
3564 instrumentation::Instrumentation* const instrumentation =
3565 Runtime::Current()->GetInstrumentation();
3566 // If we are in interpreter only mode, then we don't have to force interpreter.
3567 if (instrumentation->InterpretOnly()) {
3568 return false;
3569 }
3570 // We can only interpret pure Java method.
3571 if (m->IsNative() || m->IsProxyMethod()) {
3572 return false;
3573 }
3574 const SingleStepControl* const ssc = thread->GetSingleStepControl();
3575 if (ssc != nullptr) {
3576 // The debugger is not interested in what is happening under the level
3577 // of the step, thus we only force interpreter when we are not below of
3578 // the step.
3579 if (ssc->GetStackDepth() >= GetStackDepth(thread)) {
3580 return true;
3581 }
3582 }
Mingyao Yang99170c62015-07-06 11:10:37 -07003583 if (thread->HasDebuggerShadowFrames()) {
3584 // We need to deoptimize the stack for the exception handling flow so that
3585 // we don't miss any deoptimization that should be done when there are
3586 // debugger shadow frames.
3587 return true;
3588 }
Daniel Mihalyieb076692014-08-22 17:33:31 +02003589 // We have to require stack deoptimization if the upcall is deoptimized.
3590 return instrumentation->IsDeoptimized(m);
3591}
3592
Mingyao Yang99170c62015-07-06 11:10:37 -07003593class NeedsDeoptimizationVisitor : public StackVisitor {
Sebastien Hertz520633b2015-09-08 17:03:36 +02003594 public:
3595 explicit NeedsDeoptimizationVisitor(Thread* self)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07003596 REQUIRES_SHARED(Locks::mutator_lock_)
Sebastien Hertz520633b2015-09-08 17:03:36 +02003597 : StackVisitor(self, nullptr, StackVisitor::StackWalkKind::kIncludeInlinedFrames),
3598 needs_deoptimization_(false) {}
3599
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07003600 bool VisitFrame() OVERRIDE REQUIRES_SHARED(Locks::mutator_lock_) {
Sebastien Hertz520633b2015-09-08 17:03:36 +02003601 // The visitor is meant to be used when handling exception from compiled code only.
David Sehr709b0702016-10-13 09:12:37 -07003602 CHECK(!IsShadowFrame()) << "We only expect to visit compiled frame: "
3603 << ArtMethod::PrettyMethod(GetMethod());
Sebastien Hertz520633b2015-09-08 17:03:36 +02003604 ArtMethod* method = GetMethod();
3605 if (method == nullptr) {
3606 // We reach an upcall and don't need to deoptimize this part of the stack (ManagedFragment)
3607 // so we can stop the visit.
3608 DCHECK(!needs_deoptimization_);
3609 return false;
3610 }
3611 if (Runtime::Current()->GetInstrumentation()->InterpretOnly()) {
3612 // We found a compiled frame in the stack but instrumentation is set to interpret
3613 // everything: we need to deoptimize.
3614 needs_deoptimization_ = true;
3615 return false;
3616 }
3617 if (Runtime::Current()->GetInstrumentation()->IsDeoptimized(method)) {
3618 // We found a deoptimized method in the stack.
3619 needs_deoptimization_ = true;
3620 return false;
3621 }
Mingyao Yang99170c62015-07-06 11:10:37 -07003622 ShadowFrame* frame = GetThread()->FindDebuggerShadowFrame(GetFrameId());
3623 if (frame != nullptr) {
3624 // The debugger allocated a ShadowFrame to update a variable in the stack: we need to
3625 // deoptimize the stack to execute (and deallocate) this frame.
3626 needs_deoptimization_ = true;
3627 return false;
3628 }
Sebastien Hertz520633b2015-09-08 17:03:36 +02003629 return true;
3630 }
3631
3632 bool NeedsDeoptimization() const {
3633 return needs_deoptimization_;
3634 }
3635
3636 private:
3637 // Do we need to deoptimize the stack?
3638 bool needs_deoptimization_;
3639
3640 DISALLOW_COPY_AND_ASSIGN(NeedsDeoptimizationVisitor);
3641};
3642
3643// Do we need to deoptimize the stack to handle an exception?
3644bool Dbg::IsForcedInterpreterNeededForExceptionImpl(Thread* thread) {
3645 const SingleStepControl* const ssc = thread->GetSingleStepControl();
3646 if (ssc != nullptr) {
3647 // We deopt to step into the catch handler.
3648 return true;
3649 }
3650 // Deoptimization is required if at least one method in the stack needs it. However we
3651 // skip frames that will be unwound (thus not executed).
3652 NeedsDeoptimizationVisitor visitor(thread);
3653 visitor.WalkStack(true); // includes upcall.
3654 return visitor.NeedsDeoptimization();
3655}
3656
Jeff Hao449db332013-04-12 18:30:52 -07003657// Scoped utility class to suspend a thread so that we may do tasks such as walk its stack. Doesn't
3658// cause suspension if the thread is the current thread.
Mathieu Chartierf1d666e2015-09-03 16:13:34 -07003659class ScopedDebuggerThreadSuspension {
Jeff Hao449db332013-04-12 18:30:52 -07003660 public:
Mathieu Chartierf1d666e2015-09-03 16:13:34 -07003661 ScopedDebuggerThreadSuspension(Thread* self, JDWP::ObjectId thread_id)
Mathieu Chartier90443472015-07-16 20:32:27 -07003662 REQUIRES(!Locks::thread_list_lock_)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07003663 REQUIRES_SHARED(Locks::mutator_lock_) :
Ian Rogersf3d874c2014-07-17 18:52:42 -07003664 thread_(nullptr),
Jeff Hao449db332013-04-12 18:30:52 -07003665 error_(JDWP::ERR_NONE),
3666 self_suspend_(false),
Ian Rogers33e95662013-05-20 20:29:14 -07003667 other_suspend_(false) {
Jeff Hao449db332013-04-12 18:30:52 -07003668 ScopedObjectAccessUnchecked soa(self);
Sebastien Hertz69206392015-04-07 15:54:25 +02003669 thread_ = DecodeThread(soa, thread_id, &error_);
Jeff Hao449db332013-04-12 18:30:52 -07003670 if (error_ == JDWP::ERR_NONE) {
3671 if (thread_ == soa.Self()) {
3672 self_suspend_ = true;
3673 } else {
Mathieu Chartierf1d666e2015-09-03 16:13:34 -07003674 Thread* suspended_thread;
3675 {
3676 ScopedThreadSuspension sts(self, kWaitingForDebuggerSuspension);
3677 jobject thread_peer = Dbg::GetObjectRegistry()->GetJObject(thread_id);
3678 bool timed_out;
3679 ThreadList* const thread_list = Runtime::Current()->GetThreadList();
3680 suspended_thread = thread_list->SuspendThreadByPeer(thread_peer, true, true, &timed_out);
3681 }
Ian Rogersf3d874c2014-07-17 18:52:42 -07003682 if (suspended_thread == nullptr) {
Jeff Hao449db332013-04-12 18:30:52 -07003683 // Thread terminated from under us while suspending.
3684 error_ = JDWP::ERR_INVALID_THREAD;
3685 } else {
3686 CHECK_EQ(suspended_thread, thread_);
3687 other_suspend_ = true;
3688 }
3689 }
3690 }
Elliott Hughes2435a572012-02-17 16:07:41 -08003691 }
Elliott Hughes86964332012-02-15 19:37:42 -08003692
Jeff Hao449db332013-04-12 18:30:52 -07003693 Thread* GetThread() const {
3694 return thread_;
3695 }
3696
3697 JDWP::JdwpError GetError() const {
3698 return error_;
3699 }
3700
Mathieu Chartierf1d666e2015-09-03 16:13:34 -07003701 ~ScopedDebuggerThreadSuspension() {
Jeff Hao449db332013-04-12 18:30:52 -07003702 if (other_suspend_) {
3703 Runtime::Current()->GetThreadList()->Resume(thread_, true);
3704 }
3705 }
3706
3707 private:
3708 Thread* thread_;
3709 JDWP::JdwpError error_;
3710 bool self_suspend_;
3711 bool other_suspend_;
3712};
3713
3714JDWP::JdwpError Dbg::ConfigureStep(JDWP::ObjectId thread_id, JDWP::JdwpStepSize step_size,
3715 JDWP::JdwpStepDepth step_depth) {
3716 Thread* self = Thread::Current();
Mathieu Chartierf1d666e2015-09-03 16:13:34 -07003717 ScopedDebuggerThreadSuspension sts(self, thread_id);
Jeff Hao449db332013-04-12 18:30:52 -07003718 if (sts.GetError() != JDWP::ERR_NONE) {
3719 return sts.GetError();
3720 }
3721
Sebastien Hertz597c4f02015-01-26 17:37:14 +01003722 // Work out what ArtMethod* we're in, the current line number, and how deep the stack currently
Elliott Hughes2435a572012-02-17 16:07:41 -08003723 // is for step-out.
Ian Rogers0399dde2012-06-06 17:09:28 -07003724 struct SingleStepStackVisitor : public StackVisitor {
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07003725 explicit SingleStepStackVisitor(Thread* thread) REQUIRES_SHARED(Locks::mutator_lock_)
Nicolas Geoffray8e5bd182015-05-06 11:34:34 +01003726 : StackVisitor(thread, nullptr, StackVisitor::StackWalkKind::kIncludeInlinedFrames),
3727 stack_depth(0),
3728 method(nullptr),
3729 line_number(-1) {}
Ian Rogersca190662012-06-26 15:45:57 -07003730
Ian Rogers00f7d0e2012-07-19 15:28:27 -07003731 // TODO: Enable annotalysis. We know lock is held in constructor, but abstraction confuses
3732 // annotalysis.
3733 bool VisitFrame() NO_THREAD_SAFETY_ANALYSIS {
Mathieu Chartiere401d142015-04-22 13:56:20 -07003734 ArtMethod* m = GetMethod();
Ian Rogers0399dde2012-06-06 17:09:28 -07003735 if (!m->IsRuntimeMethod()) {
Sebastien Hertz597c4f02015-01-26 17:37:14 +01003736 ++stack_depth;
3737 if (method == nullptr) {
Ian Rogersef7d42f2014-01-06 12:55:46 -08003738 mirror::DexCache* dex_cache = m->GetDeclaringClass()->GetDexCache();
Sebastien Hertz597c4f02015-01-26 17:37:14 +01003739 method = m;
Ian Rogersc0542af2014-09-03 16:16:56 -07003740 if (dex_cache != nullptr) {
David Sehr9323e6e2016-09-13 08:58:35 -07003741 const DexFile* dex_file = dex_cache->GetDexFile();
3742 line_number = annotations::GetLineNumFromPC(dex_file, m, GetDexPc());
Elliott Hughes2435a572012-02-17 16:07:41 -08003743 }
Elliott Hughes86964332012-02-15 19:37:42 -08003744 }
3745 }
Elliott Hughes530fa002012-03-12 11:44:49 -07003746 return true;
Elliott Hughes86964332012-02-15 19:37:42 -08003747 }
Sebastien Hertz61b7f1b2013-11-15 15:59:30 +01003748
Sebastien Hertz597c4f02015-01-26 17:37:14 +01003749 int stack_depth;
Mathieu Chartiere401d142015-04-22 13:56:20 -07003750 ArtMethod* method;
Sebastien Hertz597c4f02015-01-26 17:37:14 +01003751 int32_t line_number;
Elliott Hughes86964332012-02-15 19:37:42 -08003752 };
Jeff Hao449db332013-04-12 18:30:52 -07003753
Sebastien Hertz61b7f1b2013-11-15 15:59:30 +01003754 Thread* const thread = sts.GetThread();
Sebastien Hertz597c4f02015-01-26 17:37:14 +01003755 SingleStepStackVisitor visitor(thread);
Ian Rogers0399dde2012-06-06 17:09:28 -07003756 visitor.WalkStack();
Elliott Hughes86964332012-02-15 19:37:42 -08003757
Elliott Hughes2435a572012-02-17 16:07:41 -08003758 // Find the dex_pc values that correspond to the current line, for line-based single-stepping.
Elliott Hughes2435a572012-02-17 16:07:41 -08003759 struct DebugCallbackContext {
Roland Levillain3887c462015-08-12 18:15:42 +01003760 DebugCallbackContext(SingleStepControl* single_step_control_cb,
3761 int32_t line_number_cb, const DexFile::CodeItem* code_item)
3762 : single_step_control_(single_step_control_cb), line_number_(line_number_cb),
3763 code_item_(code_item), last_pc_valid(false), last_pc(0) {
Elliott Hughes2435a572012-02-17 16:07:41 -08003764 }
3765
David Srbeckyb06e28e2015-12-10 13:15:00 +00003766 static bool Callback(void* raw_context, const DexFile::PositionInfo& entry) {
Elliott Hughes2435a572012-02-17 16:07:41 -08003767 DebugCallbackContext* context = reinterpret_cast<DebugCallbackContext*>(raw_context);
David Srbeckyb06e28e2015-12-10 13:15:00 +00003768 if (static_cast<int32_t>(entry.line_) == context->line_number_) {
Elliott Hughes2435a572012-02-17 16:07:41 -08003769 if (!context->last_pc_valid) {
3770 // Everything from this address until the next line change is ours.
David Srbeckyb06e28e2015-12-10 13:15:00 +00003771 context->last_pc = entry.address_;
Elliott Hughes2435a572012-02-17 16:07:41 -08003772 context->last_pc_valid = true;
3773 }
3774 // Otherwise, if we're already in a valid range for this line,
3775 // just keep going (shouldn't really happen)...
Brian Carlstrom7934ac22013-07-26 10:54:15 -07003776 } else if (context->last_pc_valid) { // and the line number is new
Elliott Hughes2435a572012-02-17 16:07:41 -08003777 // Add everything from the last entry up until here to the set
David Srbeckyb06e28e2015-12-10 13:15:00 +00003778 for (uint32_t dex_pc = context->last_pc; dex_pc < entry.address_; ++dex_pc) {
Sebastien Hertz597c4f02015-01-26 17:37:14 +01003779 context->single_step_control_->AddDexPc(dex_pc);
Elliott Hughes2435a572012-02-17 16:07:41 -08003780 }
3781 context->last_pc_valid = false;
3782 }
Brian Carlstrom7934ac22013-07-26 10:54:15 -07003783 return false; // There may be multiple entries for any given line.
Elliott Hughes2435a572012-02-17 16:07:41 -08003784 }
3785
Sebastien Hertz61b7f1b2013-11-15 15:59:30 +01003786 ~DebugCallbackContext() {
Elliott Hughes2435a572012-02-17 16:07:41 -08003787 // If the line number was the last in the position table...
3788 if (last_pc_valid) {
Sebastien Hertzbb43b432014-04-14 11:59:08 +02003789 size_t end = code_item_->insns_size_in_code_units_;
Elliott Hughes2435a572012-02-17 16:07:41 -08003790 for (uint32_t dex_pc = last_pc; dex_pc < end; ++dex_pc) {
Sebastien Hertz597c4f02015-01-26 17:37:14 +01003791 single_step_control_->AddDexPc(dex_pc);
Elliott Hughes2435a572012-02-17 16:07:41 -08003792 }
3793 }
3794 }
3795
Sebastien Hertz61b7f1b2013-11-15 15:59:30 +01003796 SingleStepControl* const single_step_control_;
3797 const int32_t line_number_;
Sebastien Hertzbb43b432014-04-14 11:59:08 +02003798 const DexFile::CodeItem* const code_item_;
Elliott Hughes2435a572012-02-17 16:07:41 -08003799 bool last_pc_valid;
3800 uint32_t last_pc;
3801 };
Sebastien Hertz597c4f02015-01-26 17:37:14 +01003802
3803 // Allocate single step.
Sebastien Hertz1558b572015-02-25 15:05:59 +01003804 SingleStepControl* single_step_control =
3805 new (std::nothrow) SingleStepControl(step_size, step_depth,
3806 visitor.stack_depth, visitor.method);
3807 if (single_step_control == nullptr) {
3808 LOG(ERROR) << "Failed to allocate SingleStepControl";
3809 return JDWP::ERR_OUT_OF_MEMORY;
3810 }
3811
Mathieu Chartiere401d142015-04-22 13:56:20 -07003812 ArtMethod* m = single_step_control->GetMethod();
Sebastien Hertz597c4f02015-01-26 17:37:14 +01003813 const int32_t line_number = visitor.line_number;
Sebastien Hertz52f5f932015-05-28 11:00:57 +02003814 // Note: if the thread is not running Java code (pure native thread), there is no "current"
3815 // method on the stack (and no line number either).
3816 if (m != nullptr && !m->IsNative()) {
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07003817 const DexFile::CodeItem* const code_item = m->GetCodeItem();
Sebastien Hertzbb43b432014-04-14 11:59:08 +02003818 DebugCallbackContext context(single_step_control, line_number, code_item);
David Srbeckyb06e28e2015-12-10 13:15:00 +00003819 m->GetDexFile()->DecodeDebugPositionInfo(code_item, DebugCallbackContext::Callback, &context);
Elliott Hughes3e2e1a22012-02-21 11:33:41 -08003820 }
Elliott Hughes2435a572012-02-17 16:07:41 -08003821
Sebastien Hertz597c4f02015-01-26 17:37:14 +01003822 // Activate single-step in the thread.
3823 thread->ActivateSingleStepControl(single_step_control);
Elliott Hughes86964332012-02-15 19:37:42 -08003824
Elliott Hughes2435a572012-02-17 16:07:41 -08003825 if (VLOG_IS_ON(jdwp)) {
Sebastien Hertz61b7f1b2013-11-15 15:59:30 +01003826 VLOG(jdwp) << "Single-step thread: " << *thread;
Sebastien Hertz597c4f02015-01-26 17:37:14 +01003827 VLOG(jdwp) << "Single-step step size: " << single_step_control->GetStepSize();
3828 VLOG(jdwp) << "Single-step step depth: " << single_step_control->GetStepDepth();
David Sehr709b0702016-10-13 09:12:37 -07003829 VLOG(jdwp) << "Single-step current method: "
3830 << ArtMethod::PrettyMethod(single_step_control->GetMethod());
Sebastien Hertz61b7f1b2013-11-15 15:59:30 +01003831 VLOG(jdwp) << "Single-step current line: " << line_number;
Sebastien Hertz597c4f02015-01-26 17:37:14 +01003832 VLOG(jdwp) << "Single-step current stack depth: " << single_step_control->GetStackDepth();
Elliott Hughes2435a572012-02-17 16:07:41 -08003833 VLOG(jdwp) << "Single-step dex_pc values:";
Sebastien Hertz597c4f02015-01-26 17:37:14 +01003834 for (uint32_t dex_pc : single_step_control->GetDexPcs()) {
Sebastien Hertzbb43b432014-04-14 11:59:08 +02003835 VLOG(jdwp) << StringPrintf(" %#x", dex_pc);
Elliott Hughes2435a572012-02-17 16:07:41 -08003836 }
3837 }
3838
3839 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07003840}
3841
Sebastien Hertz61b7f1b2013-11-15 15:59:30 +01003842void Dbg::UnconfigureStep(JDWP::ObjectId thread_id) {
3843 ScopedObjectAccessUnchecked soa(Thread::Current());
Ian Rogersc0542af2014-09-03 16:16:56 -07003844 JDWP::JdwpError error;
3845 Thread* thread = DecodeThread(soa, thread_id, &error);
Sebastien Hertz87118ed2013-11-26 17:57:18 +01003846 if (error == JDWP::ERR_NONE) {
Sebastien Hertz597c4f02015-01-26 17:37:14 +01003847 thread->DeactivateSingleStepControl();
Sebastien Hertz61b7f1b2013-11-15 15:59:30 +01003848 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -07003849}
3850
Elliott Hughes45651fd2012-02-21 15:48:20 -08003851static char JdwpTagToShortyChar(JDWP::JdwpTag tag) {
3852 switch (tag) {
3853 default:
3854 LOG(FATAL) << "unknown JDWP tag: " << PrintableChar(tag);
Ian Rogersfc787ec2014-10-09 21:56:44 -07003855 UNREACHABLE();
Elliott Hughes45651fd2012-02-21 15:48:20 -08003856
3857 // Primitives.
3858 case JDWP::JT_BYTE: return 'B';
3859 case JDWP::JT_CHAR: return 'C';
3860 case JDWP::JT_FLOAT: return 'F';
3861 case JDWP::JT_DOUBLE: return 'D';
3862 case JDWP::JT_INT: return 'I';
3863 case JDWP::JT_LONG: return 'J';
3864 case JDWP::JT_SHORT: return 'S';
3865 case JDWP::JT_VOID: return 'V';
3866 case JDWP::JT_BOOLEAN: return 'Z';
3867
3868 // Reference types.
3869 case JDWP::JT_ARRAY:
3870 case JDWP::JT_OBJECT:
3871 case JDWP::JT_STRING:
3872 case JDWP::JT_THREAD:
3873 case JDWP::JT_THREAD_GROUP:
3874 case JDWP::JT_CLASS_LOADER:
3875 case JDWP::JT_CLASS_OBJECT:
3876 return 'L';
3877 }
3878}
3879
Sebastien Hertzcbc50642015-06-01 17:33:12 +02003880JDWP::JdwpError Dbg::PrepareInvokeMethod(uint32_t request_id, JDWP::ObjectId thread_id,
3881 JDWP::ObjectId object_id, JDWP::RefTypeId class_id,
3882 JDWP::MethodId method_id, uint32_t arg_count,
3883 uint64_t arg_values[], JDWP::JdwpTag* arg_types,
3884 uint32_t options) {
3885 Thread* const self = Thread::Current();
3886 CHECK_EQ(self, GetDebugThread()) << "This must be called by the JDWP thread";
Sebastien Hertzd4032e42015-06-12 15:47:34 +02003887 const bool resume_all_threads = ((options & JDWP::INVOKE_SINGLE_THREADED) == 0);
Elliott Hughesd07986f2011-12-06 18:27:45 -08003888
Sebastien Hertzcbc50642015-06-01 17:33:12 +02003889 ThreadList* thread_list = Runtime::Current()->GetThreadList();
Ian Rogersc0542af2014-09-03 16:16:56 -07003890 Thread* targetThread = nullptr;
Elliott Hughesd07986f2011-12-06 18:27:45 -08003891 {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07003892 ScopedObjectAccessUnchecked soa(self);
Ian Rogersc0542af2014-09-03 16:16:56 -07003893 JDWP::JdwpError error;
3894 targetThread = DecodeThread(soa, thread_id, &error);
Elliott Hughes221229c2013-01-08 18:17:50 -08003895 if (error != JDWP::ERR_NONE) {
3896 LOG(ERROR) << "InvokeMethod request for invalid thread id " << thread_id;
3897 return error;
Elliott Hughesd07986f2011-12-06 18:27:45 -08003898 }
Sebastien Hertz1558b572015-02-25 15:05:59 +01003899 if (targetThread->GetInvokeReq() != nullptr) {
3900 // Thread is already invoking a method on behalf of the debugger.
3901 LOG(ERROR) << "InvokeMethod request for thread already invoking a method: " << *targetThread;
3902 return JDWP::ERR_ALREADY_INVOKING;
3903 }
3904 if (!targetThread->IsReadyForDebugInvoke()) {
3905 // Thread is not suspended by an event so it cannot invoke a method.
Elliott Hughesd07986f2011-12-06 18:27:45 -08003906 LOG(ERROR) << "InvokeMethod request for thread not stopped by event: " << *targetThread;
3907 return JDWP::ERR_INVALID_THREAD;
3908 }
3909
3910 /*
Sebastien Hertzd4032e42015-06-12 15:47:34 +02003911 * According to the JDWP specs, we are expected to resume all threads (or only the
3912 * target thread) once. So if a thread has been suspended more than once (either by
3913 * the debugger for an event or by the runtime for GC), it will remain suspended before
3914 * the invoke is executed. This means the debugger is responsible to properly resume all
3915 * the threads it has suspended so the target thread can execute the method.
Elliott Hughesd07986f2011-12-06 18:27:45 -08003916 *
Sebastien Hertzd4032e42015-06-12 15:47:34 +02003917 * However, for compatibility reason with older versions of debuggers (like Eclipse), we
3918 * fully resume all threads (by canceling *all* debugger suspensions) when the debugger
3919 * wants us to resume all threads. This is to avoid ending up in deadlock situation.
3920 *
3921 * On the other hand, if we are asked to only resume the target thread, then we follow the
3922 * JDWP specs by resuming that thread only once. This means the thread will remain suspended
3923 * if it has been suspended more than once before the invoke (and again, this is the
3924 * responsibility of the debugger to properly resume that thread before invoking a method).
Elliott Hughesd07986f2011-12-06 18:27:45 -08003925 */
Ian Rogers00f7d0e2012-07-19 15:28:27 -07003926 int suspend_count;
3927 {
Ian Rogers50b35e22012-10-04 10:09:15 -07003928 MutexLock mu2(soa.Self(), *Locks::thread_suspend_count_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07003929 suspend_count = targetThread->GetSuspendCount();
3930 }
Sebastien Hertzd4032e42015-06-12 15:47:34 +02003931 if (suspend_count > 1 && resume_all_threads) {
3932 // The target thread will remain suspended even after we resume it. Let's emit a warning
3933 // to indicate the invoke won't be executed until the thread is resumed.
3934 LOG(WARNING) << *targetThread << " suspended more than once (suspend count == "
3935 << suspend_count << "). This thread will invoke the method only once "
3936 << "it is fully resumed.";
Elliott Hughesd07986f2011-12-06 18:27:45 -08003937 }
3938
Ian Rogersc0542af2014-09-03 16:16:56 -07003939 mirror::Object* receiver = gRegistry->Get<mirror::Object*>(object_id, &error);
3940 if (error != JDWP::ERR_NONE) {
Elliott Hughes3f4d58f2012-02-18 20:05:37 -08003941 return JDWP::ERR_INVALID_OBJECT;
3942 }
Elliott Hughes45651fd2012-02-21 15:48:20 -08003943
Sebastien Hertz1558b572015-02-25 15:05:59 +01003944 gRegistry->Get<mirror::Object*>(thread_id, &error);
Ian Rogersc0542af2014-09-03 16:16:56 -07003945 if (error != JDWP::ERR_NONE) {
Elliott Hughes3f4d58f2012-02-18 20:05:37 -08003946 return JDWP::ERR_INVALID_OBJECT;
3947 }
Elliott Hughes45651fd2012-02-21 15:48:20 -08003948
Ian Rogersc0542af2014-09-03 16:16:56 -07003949 mirror::Class* c = DecodeClass(class_id, &error);
3950 if (c == nullptr) {
3951 return error;
Elliott Hughes3f4d58f2012-02-18 20:05:37 -08003952 }
Elliott Hughes45651fd2012-02-21 15:48:20 -08003953
Mathieu Chartiere401d142015-04-22 13:56:20 -07003954 ArtMethod* m = FromMethodId(method_id);
Ian Rogersc0542af2014-09-03 16:16:56 -07003955 if (m->IsStatic() != (receiver == nullptr)) {
Elliott Hughes45651fd2012-02-21 15:48:20 -08003956 return JDWP::ERR_INVALID_METHODID;
3957 }
3958 if (m->IsStatic()) {
3959 if (m->GetDeclaringClass() != c) {
3960 return JDWP::ERR_INVALID_METHODID;
3961 }
3962 } else {
3963 if (!m->GetDeclaringClass()->IsAssignableFrom(c)) {
3964 return JDWP::ERR_INVALID_METHODID;
3965 }
3966 }
3967
3968 // Check the argument list matches the method.
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07003969 uint32_t shorty_len = 0;
3970 const char* shorty = m->GetShorty(&shorty_len);
3971 if (shorty_len - 1 != arg_count) {
Elliott Hughes45651fd2012-02-21 15:48:20 -08003972 return JDWP::ERR_ILLEGAL_ARGUMENT;
3973 }
Elliott Hughes09201632013-04-15 15:50:07 -07003974
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07003975 {
Mathieu Chartiere401d142015-04-22 13:56:20 -07003976 StackHandleScope<2> hs(soa.Self());
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07003977 HandleWrapper<mirror::Object> h_obj(hs.NewHandleWrapper(&receiver));
3978 HandleWrapper<mirror::Class> h_klass(hs.NewHandleWrapper(&c));
3979 const DexFile::TypeList* types = m->GetParameterTypeList();
3980 for (size_t i = 0; i < arg_count; ++i) {
3981 if (shorty[i + 1] != JdwpTagToShortyChar(arg_types[i])) {
Elliott Hughes09201632013-04-15 15:50:07 -07003982 return JDWP::ERR_ILLEGAL_ARGUMENT;
3983 }
3984
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07003985 if (shorty[i + 1] == 'L') {
3986 // Did we really get an argument of an appropriate reference type?
Ian Rogersa0485602014-12-02 15:48:04 -08003987 mirror::Class* parameter_type =
Vladimir Marko05792b92015-08-03 11:56:49 +01003988 m->GetClassFromTypeIndex(types->GetTypeItem(i).type_idx_,
3989 true /* resolve */,
Andreas Gampe542451c2016-07-26 09:02:02 -07003990 kRuntimePointerSize);
Ian Rogersc0542af2014-09-03 16:16:56 -07003991 mirror::Object* argument = gRegistry->Get<mirror::Object*>(arg_values[i], &error);
3992 if (error != JDWP::ERR_NONE) {
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07003993 return JDWP::ERR_INVALID_OBJECT;
3994 }
Ian Rogersc0542af2014-09-03 16:16:56 -07003995 if (argument != nullptr && !argument->InstanceOf(parameter_type)) {
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07003996 return JDWP::ERR_ILLEGAL_ARGUMENT;
3997 }
3998
3999 // Turn the on-the-wire ObjectId into a jobject.
4000 jvalue& v = reinterpret_cast<jvalue&>(arg_values[i]);
4001 v.l = gRegistry->GetJObject(arg_values[i]);
4002 }
Elliott Hughes09201632013-04-15 15:50:07 -07004003 }
Elliott Hughes45651fd2012-02-21 15:48:20 -08004004 }
4005
Sebastien Hertz1558b572015-02-25 15:05:59 +01004006 // Allocates a DebugInvokeReq.
Sebastien Hertzcbc50642015-06-01 17:33:12 +02004007 DebugInvokeReq* req = new (std::nothrow) DebugInvokeReq(request_id, thread_id, receiver, c, m,
4008 options, arg_values, arg_count);
4009 if (req == nullptr) {
Sebastien Hertz1558b572015-02-25 15:05:59 +01004010 LOG(ERROR) << "Failed to allocate DebugInvokeReq";
4011 return JDWP::ERR_OUT_OF_MEMORY;
4012 }
4013
Sebastien Hertzcbc50642015-06-01 17:33:12 +02004014 // Attaches the DebugInvokeReq to the target thread so it executes the method when
4015 // it is resumed. Once the invocation completes, the target thread will delete it before
4016 // suspending itself (see ThreadList::SuspendSelfForDebugger).
4017 targetThread->SetDebugInvokeReq(req);
Elliott Hughesd07986f2011-12-06 18:27:45 -08004018 }
4019
4020 // The fact that we've released the thread list lock is a bit risky --- if the thread goes
Sebastien Hertzcbc50642015-06-01 17:33:12 +02004021 // away we're sitting high and dry -- but we must release this before the UndoDebuggerSuspensions
4022 // call.
Sebastien Hertzd4032e42015-06-12 15:47:34 +02004023 if (resume_all_threads) {
Sebastien Hertzcbc50642015-06-01 17:33:12 +02004024 VLOG(jdwp) << " Resuming all threads";
4025 thread_list->UndoDebuggerSuspensions();
4026 } else {
4027 VLOG(jdwp) << " Resuming event thread only";
Elliott Hughesd07986f2011-12-06 18:27:45 -08004028 thread_list->Resume(targetThread, true);
4029 }
4030
Sebastien Hertzcbc50642015-06-01 17:33:12 +02004031 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07004032}
4033
4034void Dbg::ExecuteMethod(DebugInvokeReq* pReq) {
Sebastien Hertzcbc50642015-06-01 17:33:12 +02004035 Thread* const self = Thread::Current();
4036 CHECK_NE(self, GetDebugThread()) << "This must be called by the event thread";
4037
4038 ScopedObjectAccess soa(self);
Elliott Hughesd07986f2011-12-06 18:27:45 -08004039
Elliott Hughes81ff3182012-03-23 20:35:56 -07004040 // We can be called while an exception is pending. We need
Elliott Hughesd07986f2011-12-06 18:27:45 -08004041 // to preserve that across the method invocation.
Sebastien Hertzcbc50642015-06-01 17:33:12 +02004042 StackHandleScope<1> hs(soa.Self());
4043 Handle<mirror::Throwable> old_exception = hs.NewHandle(soa.Self()->GetException());
Sebastien Hertz1558b572015-02-25 15:05:59 +01004044 soa.Self()->ClearException();
Elliott Hughesd07986f2011-12-06 18:27:45 -08004045
Sebastien Hertzcbc50642015-06-01 17:33:12 +02004046 // Execute the method then sends reply to the debugger.
4047 ExecuteMethodWithoutPendingException(soa, pReq);
4048
4049 // If an exception was pending before the invoke, restore it now.
4050 if (old_exception.Get() != nullptr) {
4051 soa.Self()->SetException(old_exception.Get());
4052 }
4053}
4054
4055// Helper function: write a variable-width value into the output input buffer.
4056static void WriteValue(JDWP::ExpandBuf* pReply, int width, uint64_t value) {
4057 switch (width) {
4058 case 1:
4059 expandBufAdd1(pReply, value);
4060 break;
4061 case 2:
4062 expandBufAdd2BE(pReply, value);
4063 break;
4064 case 4:
4065 expandBufAdd4BE(pReply, value);
4066 break;
4067 case 8:
4068 expandBufAdd8BE(pReply, value);
4069 break;
4070 default:
4071 LOG(FATAL) << width;
4072 UNREACHABLE();
4073 }
4074}
4075
4076void Dbg::ExecuteMethodWithoutPendingException(ScopedObjectAccess& soa, DebugInvokeReq* pReq) {
4077 soa.Self()->AssertNoPendingException();
4078
Elliott Hughesd07986f2011-12-06 18:27:45 -08004079 // Translate the method through the vtable, unless the debugger wants to suppress it.
Sebastien Hertzcbc50642015-06-01 17:33:12 +02004080 ArtMethod* m = pReq->method;
Andreas Gampe542451c2016-07-26 09:02:02 -07004081 PointerSize image_pointer_size = Runtime::Current()->GetClassLinker()->GetImagePointerSize();
Sebastien Hertz1558b572015-02-25 15:05:59 +01004082 if ((pReq->options & JDWP::INVOKE_NONVIRTUAL) == 0 && pReq->receiver.Read() != nullptr) {
Mathieu Chartiere401d142015-04-22 13:56:20 -07004083 ArtMethod* actual_method =
4084 pReq->klass.Read()->FindVirtualMethodForVirtualOrInterface(m, image_pointer_size);
4085 if (actual_method != m) {
David Sehr709b0702016-10-13 09:12:37 -07004086 VLOG(jdwp) << "ExecuteMethod translated " << ArtMethod::PrettyMethod(m)
4087 << " to " << ArtMethod::PrettyMethod(actual_method);
Mathieu Chartiere401d142015-04-22 13:56:20 -07004088 m = actual_method;
Elliott Hughes45651fd2012-02-21 15:48:20 -08004089 }
Elliott Hughesd07986f2011-12-06 18:27:45 -08004090 }
David Sehr709b0702016-10-13 09:12:37 -07004091 VLOG(jdwp) << "ExecuteMethod " << ArtMethod::PrettyMethod(m)
Sebastien Hertz1558b572015-02-25 15:05:59 +01004092 << " receiver=" << pReq->receiver.Read()
Sebastien Hertzd38667a2013-11-25 15:43:54 +01004093 << " arg_count=" << pReq->arg_count;
Mathieu Chartiere401d142015-04-22 13:56:20 -07004094 CHECK(m != nullptr);
Elliott Hughesd07986f2011-12-06 18:27:45 -08004095
Roland Levillain33d69032015-06-18 18:20:59 +01004096 static_assert(sizeof(jvalue) == sizeof(uint64_t), "jvalue and uint64_t have different sizes.");
Elliott Hughesd07986f2011-12-06 18:27:45 -08004097
Sebastien Hertzcbc50642015-06-01 17:33:12 +02004098 // Invoke the method.
Jeff Hao39b6c242015-05-19 20:30:23 -07004099 ScopedLocalRef<jobject> ref(soa.Env(), soa.AddLocalReference<jobject>(pReq->receiver.Read()));
Andreas Gampe13b27842016-11-07 16:48:23 -08004100 JValue result = InvokeWithJValues(soa, ref.get(), jni::EncodeArtMethod(m),
Sebastien Hertzcbc50642015-06-01 17:33:12 +02004101 reinterpret_cast<jvalue*>(pReq->arg_values.get()));
Elliott Hughesd07986f2011-12-06 18:27:45 -08004102
Sebastien Hertzcbc50642015-06-01 17:33:12 +02004103 // Prepare JDWP ids for the reply.
4104 JDWP::JdwpTag result_tag = BasicTagFromDescriptor(m->GetShorty());
4105 const bool is_object_result = (result_tag == JDWP::JT_OBJECT);
Jeff Hao064d24e2016-08-25 03:52:40 +00004106 StackHandleScope<3> hs(soa.Self());
Sebastien Hertz1558b572015-02-25 15:05:59 +01004107 Handle<mirror::Object> object_result = hs.NewHandle(is_object_result ? result.GetL() : nullptr);
4108 Handle<mirror::Throwable> exception = hs.NewHandle(soa.Self()->GetException());
4109 soa.Self()->ClearException();
Sebastien Hertzcbc50642015-06-01 17:33:12 +02004110
4111 if (!IsDebuggerActive()) {
4112 // The debugger detached: we must not re-suspend threads. We also don't need to fill the reply
4113 // because it won't be sent either.
4114 return;
4115 }
4116
4117 JDWP::ObjectId exceptionObjectId = gRegistry->Add(exception);
4118 uint64_t result_value = 0;
4119 if (exceptionObjectId != 0) {
Sebastien Hertz1558b572015-02-25 15:05:59 +01004120 VLOG(jdwp) << " JDWP invocation returning with exception=" << exception.Get()
4121 << " " << exception->Dump();
Sebastien Hertzcbc50642015-06-01 17:33:12 +02004122 result_value = 0;
Sebastien Hertz1558b572015-02-25 15:05:59 +01004123 } else if (is_object_result) {
Sebastien Hertzcbc50642015-06-01 17:33:12 +02004124 /* if no exception was thrown, examine object result more closely */
Sebastien Hertz1558b572015-02-25 15:05:59 +01004125 JDWP::JdwpTag new_tag = TagFromObject(soa, object_result.Get());
Sebastien Hertzcbc50642015-06-01 17:33:12 +02004126 if (new_tag != result_tag) {
4127 VLOG(jdwp) << " JDWP promoted result from " << result_tag << " to " << new_tag;
4128 result_tag = new_tag;
Elliott Hughesd07986f2011-12-06 18:27:45 -08004129 }
4130
Sebastien Hertz1558b572015-02-25 15:05:59 +01004131 // Register the object in the registry and reference its ObjectId. This ensures
4132 // GC safety and prevents from accessing stale reference if the object is moved.
Sebastien Hertzcbc50642015-06-01 17:33:12 +02004133 result_value = gRegistry->Add(object_result.Get());
Sebastien Hertz1558b572015-02-25 15:05:59 +01004134 } else {
4135 // Primitive result.
Sebastien Hertzcbc50642015-06-01 17:33:12 +02004136 DCHECK(IsPrimitiveTag(result_tag));
4137 result_value = result.GetJ();
4138 }
4139 const bool is_constructor = m->IsConstructor() && !m->IsStatic();
4140 if (is_constructor) {
4141 // If we invoked a constructor (which actually returns void), return the receiver,
4142 // unless we threw, in which case we return null.
Sebastien Hertza3e13772015-11-05 12:09:44 +01004143 DCHECK_EQ(JDWP::JT_VOID, result_tag);
Sebastien Hertzcbc50642015-06-01 17:33:12 +02004144 if (exceptionObjectId == 0) {
Jeff Hao064d24e2016-08-25 03:52:40 +00004145 if (m->GetDeclaringClass()->IsStringClass()) {
4146 // For string constructors, the new string is remapped to the receiver (stored in ref).
4147 Handle<mirror::Object> decoded_ref = hs.NewHandle(soa.Self()->DecodeJObject(ref.get()));
4148 result_value = gRegistry->Add(decoded_ref);
4149 result_tag = TagFromObject(soa, decoded_ref.Get());
4150 } else {
4151 // TODO we could keep the receiver ObjectId in the DebugInvokeReq to avoid looking into the
4152 // object registry.
4153 result_value = GetObjectRegistry()->Add(pReq->receiver.Read());
4154 result_tag = TagFromObject(soa, pReq->receiver.Read());
4155 }
Sebastien Hertzcbc50642015-06-01 17:33:12 +02004156 } else {
4157 result_value = 0;
Sebastien Hertza3e13772015-11-05 12:09:44 +01004158 result_tag = JDWP::JT_OBJECT;
Sebastien Hertzcbc50642015-06-01 17:33:12 +02004159 }
Elliott Hughesd07986f2011-12-06 18:27:45 -08004160 }
4161
Sebastien Hertzcbc50642015-06-01 17:33:12 +02004162 // Suspend other threads if the invoke is not single-threaded.
4163 if ((pReq->options & JDWP::INVOKE_SINGLE_THREADED) == 0) {
Mathieu Chartierf1d666e2015-09-03 16:13:34 -07004164 ScopedThreadSuspension sts(soa.Self(), kWaitingForDebuggerSuspension);
Hiroshi Yamauchi8f95cf32016-04-19 11:14:06 -07004165 // Avoid a deadlock between GC and debugger where GC gets suspended during GC. b/25800335.
4166 gc::ScopedGCCriticalSection gcs(soa.Self(), gc::kGcCauseDebugger, gc::kCollectorTypeDebugger);
Sebastien Hertzcbc50642015-06-01 17:33:12 +02004167 VLOG(jdwp) << " Suspending all threads";
4168 Runtime::Current()->GetThreadList()->SuspendAllForDebugger();
Sebastien Hertzcbc50642015-06-01 17:33:12 +02004169 }
4170
4171 VLOG(jdwp) << " --> returned " << result_tag
4172 << StringPrintf(" %#" PRIx64 " (except=%#" PRIx64 ")", result_value,
4173 exceptionObjectId);
4174
4175 // Show detailed debug output.
4176 if (result_tag == JDWP::JT_STRING && exceptionObjectId == 0) {
4177 if (result_value != 0) {
4178 if (VLOG_IS_ON(jdwp)) {
4179 std::string result_string;
4180 JDWP::JdwpError error = Dbg::StringToUtf8(result_value, &result_string);
4181 CHECK_EQ(error, JDWP::ERR_NONE);
4182 VLOG(jdwp) << " string '" << result_string << "'";
4183 }
4184 } else {
4185 VLOG(jdwp) << " string (null)";
4186 }
4187 }
4188
4189 // Attach the reply to DebugInvokeReq so it can be sent to the debugger when the event thread
4190 // is ready to suspend.
4191 BuildInvokeReply(pReq->reply, pReq->request_id, result_tag, result_value, exceptionObjectId);
4192}
4193
4194void Dbg::BuildInvokeReply(JDWP::ExpandBuf* pReply, uint32_t request_id, JDWP::JdwpTag result_tag,
4195 uint64_t result_value, JDWP::ObjectId exception) {
4196 // Make room for the JDWP header since we do not know the size of the reply yet.
4197 JDWP::expandBufAddSpace(pReply, kJDWPHeaderLen);
4198
4199 size_t width = GetTagWidth(result_tag);
4200 JDWP::expandBufAdd1(pReply, result_tag);
4201 if (width != 0) {
4202 WriteValue(pReply, width, result_value);
4203 }
4204 JDWP::expandBufAdd1(pReply, JDWP::JT_OBJECT);
4205 JDWP::expandBufAddObjectId(pReply, exception);
4206
4207 // Now we know the size, we can complete the JDWP header.
4208 uint8_t* buf = expandBufGetBuffer(pReply);
4209 JDWP::Set4BE(buf + kJDWPHeaderSizeOffset, expandBufGetLength(pReply));
4210 JDWP::Set4BE(buf + kJDWPHeaderIdOffset, request_id);
4211 JDWP::Set1(buf + kJDWPHeaderFlagsOffset, kJDWPFlagReply); // flags
4212 JDWP::Set2BE(buf + kJDWPHeaderErrorCodeOffset, JDWP::ERR_NONE);
4213}
4214
4215void Dbg::FinishInvokeMethod(DebugInvokeReq* pReq) {
4216 CHECK_NE(Thread::Current(), GetDebugThread()) << "This must be called by the event thread";
4217
4218 JDWP::ExpandBuf* const pReply = pReq->reply;
4219 CHECK(pReply != nullptr) << "No reply attached to DebugInvokeReq";
4220
4221 // We need to prevent other threads (including JDWP thread) from interacting with the debugger
4222 // while we send the reply but are not yet suspended. The JDWP token will be released just before
4223 // we suspend ourself again (see ThreadList::SuspendSelfForDebugger).
4224 gJdwpState->AcquireJdwpTokenForEvent(pReq->thread_id);
4225
4226 // Send the reply unless the debugger detached before the completion of the method.
4227 if (IsDebuggerActive()) {
4228 const size_t replyDataLength = expandBufGetLength(pReply) - kJDWPHeaderLen;
4229 VLOG(jdwp) << StringPrintf("REPLY INVOKE id=0x%06x (length=%zu)",
4230 pReq->request_id, replyDataLength);
4231
4232 gJdwpState->SendRequest(pReply);
4233 } else {
4234 VLOG(jdwp) << "Not sending invoke reply because debugger detached";
Elliott Hughesd07986f2011-12-06 18:27:45 -08004235 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -07004236}
4237
Elliott Hughesd07986f2011-12-06 18:27:45 -08004238/*
Elliott Hughes4b9702c2013-02-20 18:13:24 -08004239 * "request" contains a full JDWP packet, possibly with multiple chunks. We
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -07004240 * need to process each, accumulate the replies, and ship the whole thing
4241 * back.
4242 *
4243 * Returns "true" if we have a reply. The reply buffer is newly allocated,
4244 * and includes the chunk type/length, followed by the data.
4245 *
Elliott Hughes3d30d9b2011-12-07 17:35:48 -08004246 * OLD-TODO: we currently assume that the request and reply include a single
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -07004247 * chunk. If this becomes inconvenient we will need to adapt.
4248 */
Ian Rogersc0542af2014-09-03 16:16:56 -07004249bool Dbg::DdmHandlePacket(JDWP::Request* request, uint8_t** pReplyBuf, int* pReplyLen) {
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -07004250 Thread* self = Thread::Current();
4251 JNIEnv* env = self->GetJniEnv();
4252
Ian Rogersc0542af2014-09-03 16:16:56 -07004253 uint32_t type = request->ReadUnsigned32("type");
4254 uint32_t length = request->ReadUnsigned32("length");
Elliott Hughes4b9702c2013-02-20 18:13:24 -08004255
4256 // Create a byte[] corresponding to 'request'.
Ian Rogersc0542af2014-09-03 16:16:56 -07004257 size_t request_length = request->size();
Elliott Hughes4b9702c2013-02-20 18:13:24 -08004258 ScopedLocalRef<jbyteArray> dataArray(env, env->NewByteArray(request_length));
Ian Rogersc0542af2014-09-03 16:16:56 -07004259 if (dataArray.get() == nullptr) {
Elliott Hughes4b9702c2013-02-20 18:13:24 -08004260 LOG(WARNING) << "byte[] allocation failed: " << request_length;
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -07004261 env->ExceptionClear();
4262 return false;
4263 }
Ian Rogersc0542af2014-09-03 16:16:56 -07004264 env->SetByteArrayRegion(dataArray.get(), 0, request_length,
4265 reinterpret_cast<const jbyte*>(request->data()));
4266 request->Skip(request_length);
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -07004267
4268 // Run through and find all chunks. [Currently just find the first.]
Elliott Hughes6a5bd492011-10-28 14:33:57 -07004269 ScopedByteArrayRO contents(env, dataArray.get());
Elliott Hughes4b9702c2013-02-20 18:13:24 -08004270 if (length != request_length) {
Ian Rogersef7d42f2014-01-06 12:55:46 -08004271 LOG(WARNING) << StringPrintf("bad chunk found (len=%u pktLen=%zd)", length, request_length);
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -07004272 return false;
4273 }
4274
4275 // Call "private static Chunk dispatch(int type, byte[] data, int offset, int length)".
Elliott Hugheseac76672012-05-24 21:56:51 -07004276 ScopedLocalRef<jobject> chunk(env, env->CallStaticObjectMethod(WellKnownClasses::org_apache_harmony_dalvik_ddmc_DdmServer,
4277 WellKnownClasses::org_apache_harmony_dalvik_ddmc_DdmServer_dispatch,
Elliott Hughes4b9702c2013-02-20 18:13:24 -08004278 type, dataArray.get(), 0, length));
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -07004279 if (env->ExceptionCheck()) {
4280 LOG(INFO) << StringPrintf("Exception thrown by dispatcher for 0x%08x", type);
4281 env->ExceptionDescribe();
4282 env->ExceptionClear();
4283 return false;
4284 }
4285
Ian Rogersc0542af2014-09-03 16:16:56 -07004286 if (chunk.get() == nullptr) {
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -07004287 return false;
4288 }
4289
4290 /*
4291 * Pull the pieces out of the chunk. We copy the results into a
4292 * newly-allocated buffer that the caller can free. We don't want to
4293 * continue using the Chunk object because nothing has a reference to it.
4294 *
4295 * We could avoid this by returning type/data/offset/length and having
4296 * the caller be aware of the object lifetime issues, but that
Elliott Hughes81ff3182012-03-23 20:35:56 -07004297 * integrates the JDWP code more tightly into the rest of the runtime, and doesn't work
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -07004298 * if we have responses for multiple chunks.
4299 *
4300 * So we're pretty much stuck with copying data around multiple times.
4301 */
Elliott Hugheseac76672012-05-24 21:56:51 -07004302 ScopedLocalRef<jbyteArray> replyData(env, reinterpret_cast<jbyteArray>(env->GetObjectField(chunk.get(), WellKnownClasses::org_apache_harmony_dalvik_ddmc_Chunk_data)));
Elliott Hughes4b9702c2013-02-20 18:13:24 -08004303 jint offset = env->GetIntField(chunk.get(), WellKnownClasses::org_apache_harmony_dalvik_ddmc_Chunk_offset);
Elliott Hugheseac76672012-05-24 21:56:51 -07004304 length = env->GetIntField(chunk.get(), WellKnownClasses::org_apache_harmony_dalvik_ddmc_Chunk_length);
Elliott Hugheseac76672012-05-24 21:56:51 -07004305 type = env->GetIntField(chunk.get(), WellKnownClasses::org_apache_harmony_dalvik_ddmc_Chunk_type);
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -07004306
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08004307 VLOG(jdwp) << StringPrintf("DDM reply: type=0x%08x data=%p offset=%d length=%d", type, replyData.get(), offset, length);
Ian Rogersc0542af2014-09-03 16:16:56 -07004308 if (length == 0 || replyData.get() == nullptr) {
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -07004309 return false;
4310 }
4311
Elliott Hughes4b9702c2013-02-20 18:13:24 -08004312 const int kChunkHdrLen = 8;
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -07004313 uint8_t* reply = new uint8_t[length + kChunkHdrLen];
Ian Rogersc0542af2014-09-03 16:16:56 -07004314 if (reply == nullptr) {
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -07004315 LOG(WARNING) << "malloc failed: " << (length + kChunkHdrLen);
4316 return false;
4317 }
Elliott Hughesf7c3b662011-10-27 12:04:56 -07004318 JDWP::Set4BE(reply + 0, type);
4319 JDWP::Set4BE(reply + 4, length);
Elliott Hughes6a5bd492011-10-28 14:33:57 -07004320 env->GetByteArrayRegion(replyData.get(), offset, length, reinterpret_cast<jbyte*>(reply + kChunkHdrLen));
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -07004321
4322 *pReplyBuf = reply;
4323 *pReplyLen = length + kChunkHdrLen;
4324
Elliott Hughes4b9702c2013-02-20 18:13:24 -08004325 VLOG(jdwp) << StringPrintf("dvmHandleDdm returning type=%.4s %p len=%d", reinterpret_cast<char*>(reply), reply, length);
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -07004326 return true;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07004327}
4328
Elliott Hughesa2155262011-11-16 16:26:58 -08004329void Dbg::DdmBroadcast(bool connect) {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08004330 VLOG(jdwp) << "Broadcasting DDM " << (connect ? "connect" : "disconnect") << "...";
Elliott Hughes47fce012011-10-25 18:37:19 -07004331
4332 Thread* self = Thread::Current();
Ian Rogers50b35e22012-10-04 10:09:15 -07004333 if (self->GetState() != kRunnable) {
4334 LOG(ERROR) << "DDM broadcast in thread state " << self->GetState();
4335 /* try anyway? */
Elliott Hughes47fce012011-10-25 18:37:19 -07004336 }
4337
4338 JNIEnv* env = self->GetJniEnv();
Elliott Hughes47fce012011-10-25 18:37:19 -07004339 jint event = connect ? 1 /*DdmServer.CONNECTED*/ : 2 /*DdmServer.DISCONNECTED*/;
Elliott Hugheseac76672012-05-24 21:56:51 -07004340 env->CallStaticVoidMethod(WellKnownClasses::org_apache_harmony_dalvik_ddmc_DdmServer,
4341 WellKnownClasses::org_apache_harmony_dalvik_ddmc_DdmServer_broadcast,
4342 event);
Elliott Hughes47fce012011-10-25 18:37:19 -07004343 if (env->ExceptionCheck()) {
4344 LOG(ERROR) << "DdmServer.broadcast " << event << " failed";
4345 env->ExceptionDescribe();
4346 env->ExceptionClear();
4347 }
4348}
4349
Elliott Hughes872d4ec2011-10-21 17:07:15 -07004350void Dbg::DdmConnected() {
Elliott Hughesa2155262011-11-16 16:26:58 -08004351 Dbg::DdmBroadcast(true);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07004352}
4353
4354void Dbg::DdmDisconnected() {
Elliott Hughesa2155262011-11-16 16:26:58 -08004355 Dbg::DdmBroadcast(false);
Elliott Hughes47fce012011-10-25 18:37:19 -07004356 gDdmThreadNotification = false;
4357}
4358
4359/*
Elliott Hughes82188472011-11-07 18:11:48 -08004360 * Send a notification when a thread starts, stops, or changes its name.
Elliott Hughes47fce012011-10-25 18:37:19 -07004361 *
4362 * Because we broadcast the full set of threads when the notifications are
4363 * first enabled, it's possible for "thread" to be actively executing.
4364 */
Elliott Hughes82188472011-11-07 18:11:48 -08004365void Dbg::DdmSendThreadNotification(Thread* t, uint32_t type) {
Elliott Hughes47fce012011-10-25 18:37:19 -07004366 if (!gDdmThreadNotification) {
4367 return;
4368 }
4369
Elliott Hughes82188472011-11-07 18:11:48 -08004370 if (type == CHUNK_TYPE("THDE")) {
Elliott Hughes47fce012011-10-25 18:37:19 -07004371 uint8_t buf[4];
Ian Rogersd9c4fc92013-10-01 19:45:43 -07004372 JDWP::Set4BE(&buf[0], t->GetThreadId());
Elliott Hughes47fce012011-10-25 18:37:19 -07004373 Dbg::DdmSendChunk(CHUNK_TYPE("THDE"), 4, buf);
Elliott Hughes82188472011-11-07 18:11:48 -08004374 } else {
4375 CHECK(type == CHUNK_TYPE("THCR") || type == CHUNK_TYPE("THNM")) << type;
Ian Rogers00f7d0e2012-07-19 15:28:27 -07004376 ScopedObjectAccessUnchecked soa(Thread::Current());
Mathieu Chartiereb8167a2014-05-07 15:43:14 -07004377 StackHandleScope<1> hs(soa.Self());
Andreas Gampe08883de2016-11-08 13:20:52 -08004378 Handle<mirror::String> name(hs.NewHandle(t->GetThreadName()));
Ian Rogersc0542af2014-09-03 16:16:56 -07004379 size_t char_count = (name.Get() != nullptr) ? name->GetLength() : 0;
Jeff Hao848f70a2014-01-15 13:49:50 -08004380 const jchar* chars = (name.Get() != nullptr) ? name->GetValue() : nullptr;
jessicahandojo3aaa37b2016-07-29 14:46:37 -07004381 bool is_compressed = (name.Get() != nullptr) ? name->IsCompressed() : false;
Elliott Hughes82188472011-11-07 18:11:48 -08004382
Elliott Hughes21f32d72011-11-09 17:44:13 -08004383 std::vector<uint8_t> bytes;
Ian Rogersd9c4fc92013-10-01 19:45:43 -07004384 JDWP::Append4BE(bytes, t->GetThreadId());
jessicahandojo3aaa37b2016-07-29 14:46:37 -07004385 if (is_compressed) {
4386 const uint8_t* chars_compressed = name->GetValueCompressed();
4387 JDWP::AppendUtf16CompressedBE(bytes, chars_compressed, char_count);
4388 } else {
4389 JDWP::AppendUtf16BE(bytes, chars, char_count);
4390 }
Elliott Hughes21f32d72011-11-09 17:44:13 -08004391 CHECK_EQ(bytes.size(), char_count*2 + sizeof(uint32_t)*2);
4392 Dbg::DdmSendChunk(type, bytes);
Elliott Hughes47fce012011-10-25 18:37:19 -07004393 }
4394}
4395
Elliott Hughes47fce012011-10-25 18:37:19 -07004396void Dbg::DdmSetThreadNotification(bool enable) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07004397 // Enable/disable thread notifications.
Elliott Hughes47fce012011-10-25 18:37:19 -07004398 gDdmThreadNotification = enable;
4399 if (enable) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07004400 // Suspend the VM then post thread start notifications for all threads. Threads attaching will
4401 // see a suspension in progress and block until that ends. They then post their own start
4402 // notification.
4403 SuspendVM();
4404 std::list<Thread*> threads;
Ian Rogers50b35e22012-10-04 10:09:15 -07004405 Thread* self = Thread::Current();
Ian Rogers00f7d0e2012-07-19 15:28:27 -07004406 {
Ian Rogers50b35e22012-10-04 10:09:15 -07004407 MutexLock mu(self, *Locks::thread_list_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07004408 threads = Runtime::Current()->GetThreadList()->GetList();
4409 }
4410 {
Ian Rogers50b35e22012-10-04 10:09:15 -07004411 ScopedObjectAccess soa(self);
Mathieu Chartier02e25112013-08-14 16:14:24 -07004412 for (Thread* thread : threads) {
4413 Dbg::DdmSendThreadNotification(thread, CHUNK_TYPE("THCR"));
Ian Rogers00f7d0e2012-07-19 15:28:27 -07004414 }
4415 }
4416 ResumeVM();
Elliott Hughes47fce012011-10-25 18:37:19 -07004417 }
4418}
4419
Elliott Hughesa2155262011-11-16 16:26:58 -08004420void Dbg::PostThreadStartOrStop(Thread* t, uint32_t type) {
Elliott Hughesc0f09332012-03-26 13:27:06 -07004421 if (IsDebuggerActive()) {
Sebastien Hertz6995c602014-09-09 12:10:13 +02004422 gJdwpState->PostThreadChange(t, type == CHUNK_TYPE("THCR"));
Elliott Hughes47fce012011-10-25 18:37:19 -07004423 }
Elliott Hughes82188472011-11-07 18:11:48 -08004424 Dbg::DdmSendThreadNotification(t, type);
Elliott Hughes47fce012011-10-25 18:37:19 -07004425}
4426
4427void Dbg::PostThreadStart(Thread* t) {
Elliott Hughesa2155262011-11-16 16:26:58 -08004428 Dbg::PostThreadStartOrStop(t, CHUNK_TYPE("THCR"));
Elliott Hughes47fce012011-10-25 18:37:19 -07004429}
4430
4431void Dbg::PostThreadDeath(Thread* t) {
Elliott Hughesa2155262011-11-16 16:26:58 -08004432 Dbg::PostThreadStartOrStop(t, CHUNK_TYPE("THDE"));
Elliott Hughes872d4ec2011-10-21 17:07:15 -07004433}
4434
Elliott Hughes82188472011-11-07 18:11:48 -08004435void Dbg::DdmSendChunk(uint32_t type, size_t byte_count, const uint8_t* buf) {
Ian Rogersc0542af2014-09-03 16:16:56 -07004436 CHECK(buf != nullptr);
Elliott Hughes3bb81562011-10-21 18:52:59 -07004437 iovec vec[1];
4438 vec[0].iov_base = reinterpret_cast<void*>(const_cast<uint8_t*>(buf));
4439 vec[0].iov_len = byte_count;
4440 Dbg::DdmSendChunkV(type, vec, 1);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07004441}
4442
Elliott Hughes21f32d72011-11-09 17:44:13 -08004443void Dbg::DdmSendChunk(uint32_t type, const std::vector<uint8_t>& bytes) {
4444 DdmSendChunk(type, bytes.size(), &bytes[0]);
4445}
4446
Brian Carlstromf5293522013-07-19 00:24:00 -07004447void Dbg::DdmSendChunkV(uint32_t type, const iovec* iov, int iov_count) {
Ian Rogersc0542af2014-09-03 16:16:56 -07004448 if (gJdwpState == nullptr) {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08004449 VLOG(jdwp) << "Debugger thread not active, ignoring DDM send: " << type;
Elliott Hughes3bb81562011-10-21 18:52:59 -07004450 } else {
Elliott Hughescccd84f2011-12-05 16:51:54 -08004451 gJdwpState->DdmSendChunkV(type, iov, iov_count);
Elliott Hughes3bb81562011-10-21 18:52:59 -07004452 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -07004453}
4454
Mathieu Chartierad466ad2015-01-08 16:28:08 -08004455JDWP::JdwpState* Dbg::GetJdwpState() {
4456 return gJdwpState;
4457}
4458
Elliott Hughes767a1472011-10-26 18:49:02 -07004459int Dbg::DdmHandleHpifChunk(HpifWhen when) {
4460 if (when == HPIF_WHEN_NOW) {
Elliott Hughes7162ad92011-10-27 14:08:42 -07004461 DdmSendHeapInfo(when);
Elliott Hughes767a1472011-10-26 18:49:02 -07004462 return true;
4463 }
4464
4465 if (when != HPIF_WHEN_NEVER && when != HPIF_WHEN_NEXT_GC && when != HPIF_WHEN_EVERY_GC) {
4466 LOG(ERROR) << "invalid HpifWhen value: " << static_cast<int>(when);
4467 return false;
4468 }
4469
4470 gDdmHpifWhen = when;
4471 return true;
4472}
4473
4474bool Dbg::DdmHandleHpsgNhsgChunk(Dbg::HpsgWhen when, Dbg::HpsgWhat what, bool native) {
4475 if (when != HPSG_WHEN_NEVER && when != HPSG_WHEN_EVERY_GC) {
4476 LOG(ERROR) << "invalid HpsgWhen value: " << static_cast<int>(when);
4477 return false;
4478 }
4479
4480 if (what != HPSG_WHAT_MERGED_OBJECTS && what != HPSG_WHAT_DISTINCT_OBJECTS) {
4481 LOG(ERROR) << "invalid HpsgWhat value: " << static_cast<int>(what);
4482 return false;
4483 }
4484
4485 if (native) {
4486 gDdmNhsgWhen = when;
4487 gDdmNhsgWhat = what;
4488 } else {
4489 gDdmHpsgWhen = when;
4490 gDdmHpsgWhat = what;
4491 }
4492 return true;
4493}
4494
Elliott Hughes7162ad92011-10-27 14:08:42 -07004495void Dbg::DdmSendHeapInfo(HpifWhen reason) {
4496 // If there's a one-shot 'when', reset it.
4497 if (reason == gDdmHpifWhen) {
4498 if (gDdmHpifWhen == HPIF_WHEN_NEXT_GC) {
4499 gDdmHpifWhen = HPIF_WHEN_NEVER;
4500 }
4501 }
4502
4503 /*
4504 * Chunk HPIF (client --> server)
4505 *
4506 * Heap Info. General information about the heap,
4507 * suitable for a summary display.
4508 *
4509 * [u4]: number of heaps
4510 *
4511 * For each heap:
4512 * [u4]: heap ID
4513 * [u8]: timestamp in ms since Unix epoch
4514 * [u1]: capture reason (same as 'when' value from server)
4515 * [u4]: max heap size in bytes (-Xmx)
4516 * [u4]: current heap size in bytes
4517 * [u4]: current number of bytes allocated
4518 * [u4]: current number of objects allocated
4519 */
4520 uint8_t heap_count = 1;
Ian Rogers1d54e732013-05-02 21:10:01 -07004521 gc::Heap* heap = Runtime::Current()->GetHeap();
Elliott Hughes21f32d72011-11-09 17:44:13 -08004522 std::vector<uint8_t> bytes;
Elliott Hughes545a0642011-11-08 19:10:03 -08004523 JDWP::Append4BE(bytes, heap_count);
Brian Carlstrom7934ac22013-07-26 10:54:15 -07004524 JDWP::Append4BE(bytes, 1); // Heap id (bogus; we only have one heap).
Elliott Hughes545a0642011-11-08 19:10:03 -08004525 JDWP::Append8BE(bytes, MilliTime());
4526 JDWP::Append1BE(bytes, reason);
Brian Carlstrom7934ac22013-07-26 10:54:15 -07004527 JDWP::Append4BE(bytes, heap->GetMaxMemory()); // Max allowed heap size in bytes.
4528 JDWP::Append4BE(bytes, heap->GetTotalMemory()); // Current heap size in bytes.
Elliott Hughesb3bd5f02012-03-08 21:05:27 -08004529 JDWP::Append4BE(bytes, heap->GetBytesAllocated());
4530 JDWP::Append4BE(bytes, heap->GetObjectsAllocated());
Elliott Hughes21f32d72011-11-09 17:44:13 -08004531 CHECK_EQ(bytes.size(), 4U + (heap_count * (4 + 8 + 1 + 4 + 4 + 4 + 4)));
4532 Dbg::DdmSendChunk(CHUNK_TYPE("HPIF"), bytes);
Elliott Hughes767a1472011-10-26 18:49:02 -07004533}
4534
Elliott Hughes6a5bd492011-10-28 14:33:57 -07004535enum HpsgSolidity {
4536 SOLIDITY_FREE = 0,
4537 SOLIDITY_HARD = 1,
4538 SOLIDITY_SOFT = 2,
4539 SOLIDITY_WEAK = 3,
4540 SOLIDITY_PHANTOM = 4,
4541 SOLIDITY_FINALIZABLE = 5,
4542 SOLIDITY_SWEEP = 6,
4543};
4544
4545enum HpsgKind {
4546 KIND_OBJECT = 0,
4547 KIND_CLASS_OBJECT = 1,
4548 KIND_ARRAY_1 = 2,
4549 KIND_ARRAY_2 = 3,
4550 KIND_ARRAY_4 = 4,
4551 KIND_ARRAY_8 = 5,
4552 KIND_UNKNOWN = 6,
4553 KIND_NATIVE = 7,
4554};
4555
4556#define HPSG_PARTIAL (1<<7)
4557#define HPSG_STATE(solidity, kind) ((uint8_t)((((kind) & 0x7) << 3) | ((solidity) & 0x7)))
4558
Ian Rogers30fab402012-01-23 15:43:46 -08004559class HeapChunkContext {
4560 public:
Elliott Hughes6a5bd492011-10-28 14:33:57 -07004561 // Maximum chunk size. Obtain this from the formula:
4562 // (((maximum_heap_size / ALLOCATION_UNIT_SIZE) + 255) / 256) * 2
4563 HeapChunkContext(bool merge, bool native)
Ian Rogers30fab402012-01-23 15:43:46 -08004564 : buf_(16384 - 16),
4565 type_(0),
Mathieu Chartier36dab362014-07-30 14:59:56 -07004566 chunk_overhead_(0) {
Elliott Hughes6a5bd492011-10-28 14:33:57 -07004567 Reset();
4568 if (native) {
Ian Rogers30fab402012-01-23 15:43:46 -08004569 type_ = CHUNK_TYPE("NHSG");
Elliott Hughes6a5bd492011-10-28 14:33:57 -07004570 } else {
Ian Rogers30fab402012-01-23 15:43:46 -08004571 type_ = merge ? CHUNK_TYPE("HPSG") : CHUNK_TYPE("HPSO");
Elliott Hughes6a5bd492011-10-28 14:33:57 -07004572 }
4573 }
4574
4575 ~HeapChunkContext() {
Ian Rogers30fab402012-01-23 15:43:46 -08004576 if (p_ > &buf_[0]) {
Elliott Hughes6a5bd492011-10-28 14:33:57 -07004577 Flush();
4578 }
4579 }
4580
Mathieu Chartier36dab362014-07-30 14:59:56 -07004581 void SetChunkOverhead(size_t chunk_overhead) {
4582 chunk_overhead_ = chunk_overhead;
4583 }
4584
4585 void ResetStartOfNextChunk() {
4586 startOfNextMemoryChunk_ = nullptr;
4587 }
4588
Elliott Hughes6a5bd492011-10-28 14:33:57 -07004589 void EnsureHeader(const void* chunk_ptr) {
Ian Rogers30fab402012-01-23 15:43:46 -08004590 if (!needHeader_) {
Elliott Hughes6a5bd492011-10-28 14:33:57 -07004591 return;
4592 }
4593
4594 // Start a new HPSx chunk.
Brian Carlstrom7934ac22013-07-26 10:54:15 -07004595 JDWP::Write4BE(&p_, 1); // Heap id (bogus; we only have one heap).
4596 JDWP::Write1BE(&p_, 8); // Size of allocation unit, in bytes.
Elliott Hughes6a5bd492011-10-28 14:33:57 -07004597
Brian Carlstrom7934ac22013-07-26 10:54:15 -07004598 JDWP::Write4BE(&p_, reinterpret_cast<uintptr_t>(chunk_ptr)); // virtual address of segment start.
4599 JDWP::Write4BE(&p_, 0); // offset of this piece (relative to the virtual address).
Elliott Hughes6a5bd492011-10-28 14:33:57 -07004600 // [u4]: length of piece, in allocation units
4601 // We won't know this until we're done, so save the offset and stuff in a dummy value.
Ian Rogers30fab402012-01-23 15:43:46 -08004602 pieceLenField_ = p_;
4603 JDWP::Write4BE(&p_, 0x55555555);
4604 needHeader_ = false;
Elliott Hughes6a5bd492011-10-28 14:33:57 -07004605 }
4606
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07004607 void Flush() REQUIRES_SHARED(Locks::mutator_lock_) {
Ian Rogersc0542af2014-09-03 16:16:56 -07004608 if (pieceLenField_ == nullptr) {
Ian Rogersd636b062013-01-18 17:51:18 -08004609 // Flush immediately post Reset (maybe back-to-back Flush). Ignore.
4610 CHECK(needHeader_);
4611 return;
4612 }
Elliott Hughes6a5bd492011-10-28 14:33:57 -07004613 // Patch the "length of piece" field.
Ian Rogers30fab402012-01-23 15:43:46 -08004614 CHECK_LE(&buf_[0], pieceLenField_);
4615 CHECK_LE(pieceLenField_, p_);
4616 JDWP::Set4BE(pieceLenField_, totalAllocationUnits_);
Elliott Hughes6a5bd492011-10-28 14:33:57 -07004617
Ian Rogers30fab402012-01-23 15:43:46 -08004618 Dbg::DdmSendChunk(type_, p_ - &buf_[0], &buf_[0]);
Elliott Hughes6a5bd492011-10-28 14:33:57 -07004619 Reset();
4620 }
4621
Mathieu Chartierbc689b72014-12-14 17:01:31 -08004622 static void HeapChunkJavaCallback(void* start, void* end, size_t used_bytes, void* arg)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07004623 REQUIRES_SHARED(Locks::heap_bitmap_lock_,
Ian Rogersb726dcb2012-09-05 08:57:23 -07004624 Locks::mutator_lock_) {
Mathieu Chartierbc689b72014-12-14 17:01:31 -08004625 reinterpret_cast<HeapChunkContext*>(arg)->HeapChunkJavaCallback(start, end, used_bytes);
4626 }
4627
4628 static void HeapChunkNativeCallback(void* start, void* end, size_t used_bytes, void* arg)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07004629 REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartierbc689b72014-12-14 17:01:31 -08004630 reinterpret_cast<HeapChunkContext*>(arg)->HeapChunkNativeCallback(start, end, used_bytes);
Elliott Hughesa2155262011-11-16 16:26:58 -08004631 }
4632
Elliott Hughes6a5bd492011-10-28 14:33:57 -07004633 private:
Elliott Hughesa2155262011-11-16 16:26:58 -08004634 enum { ALLOCATION_UNIT_SIZE = 8 };
4635
Elliott Hughes6a5bd492011-10-28 14:33:57 -07004636 void Reset() {
Ian Rogers30fab402012-01-23 15:43:46 -08004637 p_ = &buf_[0];
Mathieu Chartier36dab362014-07-30 14:59:56 -07004638 ResetStartOfNextChunk();
Ian Rogers30fab402012-01-23 15:43:46 -08004639 totalAllocationUnits_ = 0;
4640 needHeader_ = true;
Ian Rogersc0542af2014-09-03 16:16:56 -07004641 pieceLenField_ = nullptr;
Elliott Hughes6a5bd492011-10-28 14:33:57 -07004642 }
4643
Mathieu Chartierbc689b72014-12-14 17:01:31 -08004644 bool IsNative() const {
4645 return type_ == CHUNK_TYPE("NHSG");
4646 }
4647
4648 // Returns true if the object is not an empty chunk.
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07004649 bool ProcessRecord(void* start, size_t used_bytes) REQUIRES_SHARED(Locks::mutator_lock_) {
Ian Rogers30fab402012-01-23 15:43:46 -08004650 // Note: heap call backs cannot manipulate the heap upon which they are crawling, care is taken
4651 // in the following code not to allocate memory, by ensuring buf_ is of the correct size
Ian Rogers15bf2d32012-08-28 17:33:04 -07004652 if (used_bytes == 0) {
Mathieu Chartierbc689b72014-12-14 17:01:31 -08004653 if (start == nullptr) {
4654 // Reset for start of new heap.
4655 startOfNextMemoryChunk_ = nullptr;
4656 Flush();
4657 }
4658 // Only process in use memory so that free region information
4659 // also includes dlmalloc book keeping.
4660 return false;
Elliott Hughesa2155262011-11-16 16:26:58 -08004661 }
Ian Rogersc0542af2014-09-03 16:16:56 -07004662 if (startOfNextMemoryChunk_ != nullptr) {
Mathieu Chartierbc689b72014-12-14 17:01:31 -08004663 // Transmit any pending free memory. Native free memory of over kMaxFreeLen could be because
4664 // of the use of mmaps, so don't report. If not free memory then start a new segment.
4665 bool flush = true;
4666 if (start > startOfNextMemoryChunk_) {
4667 const size_t kMaxFreeLen = 2 * kPageSize;
4668 void* free_start = startOfNextMemoryChunk_;
4669 void* free_end = start;
4670 const size_t free_len =
4671 reinterpret_cast<uintptr_t>(free_end) - reinterpret_cast<uintptr_t>(free_start);
4672 if (!IsNative() || free_len < kMaxFreeLen) {
4673 AppendChunk(HPSG_STATE(SOLIDITY_FREE, 0), free_start, free_len, IsNative());
4674 flush = false;
Ian Rogers15bf2d32012-08-28 17:33:04 -07004675 }
Mathieu Chartierbc689b72014-12-14 17:01:31 -08004676 }
4677 if (flush) {
4678 startOfNextMemoryChunk_ = nullptr;
4679 Flush();
4680 }
Ian Rogers15bf2d32012-08-28 17:33:04 -07004681 }
Mathieu Chartierbc689b72014-12-14 17:01:31 -08004682 return true;
Ian Rogers15bf2d32012-08-28 17:33:04 -07004683 }
Elliott Hughesa2155262011-11-16 16:26:58 -08004684
Mathieu Chartierbc689b72014-12-14 17:01:31 -08004685 void HeapChunkNativeCallback(void* start, void* /*end*/, size_t used_bytes)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07004686 REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartierbc689b72014-12-14 17:01:31 -08004687 if (ProcessRecord(start, used_bytes)) {
4688 uint8_t state = ExamineNativeObject(start);
4689 AppendChunk(state, start, used_bytes + chunk_overhead_, true /*is_native*/);
4690 startOfNextMemoryChunk_ = reinterpret_cast<char*>(start) + used_bytes + chunk_overhead_;
4691 }
4692 }
4693
4694 void HeapChunkJavaCallback(void* start, void* /*end*/, size_t used_bytes)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07004695 REQUIRES_SHARED(Locks::heap_bitmap_lock_, Locks::mutator_lock_) {
Mathieu Chartierbc689b72014-12-14 17:01:31 -08004696 if (ProcessRecord(start, used_bytes)) {
4697 // Determine the type of this chunk.
4698 // OLD-TODO: if context.merge, see if this chunk is different from the last chunk.
4699 // If it's the same, we should combine them.
4700 uint8_t state = ExamineJavaObject(reinterpret_cast<mirror::Object*>(start));
4701 AppendChunk(state, start, used_bytes + chunk_overhead_, false /*is_native*/);
4702 startOfNextMemoryChunk_ = reinterpret_cast<char*>(start) + used_bytes + chunk_overhead_;
4703 }
4704 }
4705
4706 void AppendChunk(uint8_t state, void* ptr, size_t length, bool is_native)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07004707 REQUIRES_SHARED(Locks::mutator_lock_) {
Ian Rogers15bf2d32012-08-28 17:33:04 -07004708 // Make sure there's enough room left in the buffer.
4709 // We need to use two bytes for every fractional 256 allocation units used by the chunk plus
4710 // 17 bytes for any header.
Mathieu Chartierbc689b72014-12-14 17:01:31 -08004711 const size_t needed = ((RoundUp(length / ALLOCATION_UNIT_SIZE, 256) / 256) * 2) + 17;
4712 size_t byte_left = &buf_.back() - p_;
4713 if (byte_left < needed) {
4714 if (is_native) {
Pavel Vyssotski7522c742014-12-08 13:38:26 +06004715 // Cannot trigger memory allocation while walking native heap.
Pavel Vyssotski7522c742014-12-08 13:38:26 +06004716 return;
4717 }
Ian Rogers15bf2d32012-08-28 17:33:04 -07004718 Flush();
4719 }
4720
Mathieu Chartierbc689b72014-12-14 17:01:31 -08004721 byte_left = &buf_.back() - p_;
4722 if (byte_left < needed) {
Ian Rogers15bf2d32012-08-28 17:33:04 -07004723 LOG(WARNING) << "Chunk is too big to transmit (chunk_len=" << length << ", "
4724 << needed << " bytes)";
4725 return;
4726 }
4727 EnsureHeader(ptr);
Elliott Hughesa2155262011-11-16 16:26:58 -08004728 // Write out the chunk description.
Ian Rogers15bf2d32012-08-28 17:33:04 -07004729 length /= ALLOCATION_UNIT_SIZE; // Convert to allocation units.
4730 totalAllocationUnits_ += length;
4731 while (length > 256) {
Ian Rogers30fab402012-01-23 15:43:46 -08004732 *p_++ = state | HPSG_PARTIAL;
4733 *p_++ = 255; // length - 1
Ian Rogers15bf2d32012-08-28 17:33:04 -07004734 length -= 256;
Elliott Hughesa2155262011-11-16 16:26:58 -08004735 }
Ian Rogers30fab402012-01-23 15:43:46 -08004736 *p_++ = state;
Ian Rogers15bf2d32012-08-28 17:33:04 -07004737 *p_++ = length - 1;
Elliott Hughes6a5bd492011-10-28 14:33:57 -07004738 }
4739
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07004740 uint8_t ExamineNativeObject(const void* p) REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartierbc689b72014-12-14 17:01:31 -08004741 return p == nullptr ? HPSG_STATE(SOLIDITY_FREE, 0) : HPSG_STATE(SOLIDITY_HARD, KIND_NATIVE);
4742 }
4743
4744 uint8_t ExamineJavaObject(mirror::Object* o)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07004745 REQUIRES_SHARED(Locks::mutator_lock_, Locks::heap_bitmap_lock_) {
Ian Rogersc0542af2014-09-03 16:16:56 -07004746 if (o == nullptr) {
Elliott Hughesa2155262011-11-16 16:26:58 -08004747 return HPSG_STATE(SOLIDITY_FREE, 0);
4748 }
Elliott Hughesa2155262011-11-16 16:26:58 -08004749 // It's an allocated chunk. Figure out what it is.
Mathieu Chartierbc689b72014-12-14 17:01:31 -08004750 gc::Heap* heap = Runtime::Current()->GetHeap();
4751 if (!heap->IsLiveObjectLocked(o)) {
4752 LOG(ERROR) << "Invalid object in managed heap: " << o;
Elliott Hughesa2155262011-11-16 16:26:58 -08004753 return HPSG_STATE(SOLIDITY_HARD, KIND_NATIVE);
4754 }
Ian Rogers2dd0e2c2013-01-24 12:42:14 -08004755 mirror::Class* c = o->GetClass();
Ian Rogersc0542af2014-09-03 16:16:56 -07004756 if (c == nullptr) {
Elliott Hughesa2155262011-11-16 16:26:58 -08004757 // The object was probably just created but hasn't been initialized yet.
4758 return HPSG_STATE(SOLIDITY_HARD, KIND_OBJECT);
4759 }
Mathieu Chartierbc689b72014-12-14 17:01:31 -08004760 if (!heap->IsValidObjectAddress(c)) {
Ian Rogers15bf2d32012-08-28 17:33:04 -07004761 LOG(ERROR) << "Invalid class for managed heap object: " << o << " " << c;
Elliott Hughesa2155262011-11-16 16:26:58 -08004762 return HPSG_STATE(SOLIDITY_HARD, KIND_UNKNOWN);
4763 }
Mathieu Chartierf26e1b32015-01-29 10:47:10 -08004764 if (c->GetClass() == nullptr) {
4765 LOG(ERROR) << "Null class of class " << c << " for object " << o;
4766 return HPSG_STATE(SOLIDITY_HARD, KIND_UNKNOWN);
4767 }
Elliott Hughesa2155262011-11-16 16:26:58 -08004768 if (c->IsClassClass()) {
4769 return HPSG_STATE(SOLIDITY_HARD, KIND_CLASS_OBJECT);
4770 }
Elliott Hughesa2155262011-11-16 16:26:58 -08004771 if (c->IsArrayClass()) {
Elliott Hughesa2155262011-11-16 16:26:58 -08004772 switch (c->GetComponentSize()) {
4773 case 1: return HPSG_STATE(SOLIDITY_HARD, KIND_ARRAY_1);
4774 case 2: return HPSG_STATE(SOLIDITY_HARD, KIND_ARRAY_2);
4775 case 4: return HPSG_STATE(SOLIDITY_HARD, KIND_ARRAY_4);
4776 case 8: return HPSG_STATE(SOLIDITY_HARD, KIND_ARRAY_8);
4777 }
4778 }
Elliott Hughes6a5bd492011-10-28 14:33:57 -07004779 return HPSG_STATE(SOLIDITY_HARD, KIND_OBJECT);
4780 }
4781
Ian Rogers30fab402012-01-23 15:43:46 -08004782 std::vector<uint8_t> buf_;
4783 uint8_t* p_;
4784 uint8_t* pieceLenField_;
Ian Rogers15bf2d32012-08-28 17:33:04 -07004785 void* startOfNextMemoryChunk_;
Ian Rogers30fab402012-01-23 15:43:46 -08004786 size_t totalAllocationUnits_;
4787 uint32_t type_;
Ian Rogers30fab402012-01-23 15:43:46 -08004788 bool needHeader_;
Mathieu Chartier36dab362014-07-30 14:59:56 -07004789 size_t chunk_overhead_;
Ian Rogers30fab402012-01-23 15:43:46 -08004790
Elliott Hughesa2155262011-11-16 16:26:58 -08004791 DISALLOW_COPY_AND_ASSIGN(HeapChunkContext);
4792};
Elliott Hughes6a5bd492011-10-28 14:33:57 -07004793
Mathieu Chartier36dab362014-07-30 14:59:56 -07004794static void BumpPointerSpaceCallback(mirror::Object* obj, void* arg)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07004795 REQUIRES_SHARED(Locks::mutator_lock_) REQUIRES(Locks::heap_bitmap_lock_) {
Mathieu Chartier36dab362014-07-30 14:59:56 -07004796 const size_t size = RoundUp(obj->SizeOf(), kObjectAlignment);
Mathieu Chartierbc689b72014-12-14 17:01:31 -08004797 HeapChunkContext::HeapChunkJavaCallback(
Mathieu Chartier36dab362014-07-30 14:59:56 -07004798 obj, reinterpret_cast<void*>(reinterpret_cast<uintptr_t>(obj) + size), size, arg);
4799}
4800
Elliott Hughes6a5bd492011-10-28 14:33:57 -07004801void Dbg::DdmSendHeapSegments(bool native) {
Mathieu Chartierbc689b72014-12-14 17:01:31 -08004802 Dbg::HpsgWhen when = native ? gDdmNhsgWhen : gDdmHpsgWhen;
4803 Dbg::HpsgWhat what = native ? gDdmNhsgWhat : gDdmHpsgWhat;
Elliott Hughes6a5bd492011-10-28 14:33:57 -07004804 if (when == HPSG_WHEN_NEVER) {
4805 return;
4806 }
Elliott Hughes6a5bd492011-10-28 14:33:57 -07004807 // Figure out what kind of chunks we'll be sending.
Mathieu Chartierbc689b72014-12-14 17:01:31 -08004808 CHECK(what == HPSG_WHAT_MERGED_OBJECTS || what == HPSG_WHAT_DISTINCT_OBJECTS)
4809 << static_cast<int>(what);
Elliott Hughes6a5bd492011-10-28 14:33:57 -07004810
4811 // First, send a heap start chunk.
4812 uint8_t heap_id[4];
Brian Carlstrom7934ac22013-07-26 10:54:15 -07004813 JDWP::Set4BE(&heap_id[0], 1); // Heap id (bogus; we only have one heap).
Elliott Hughes6a5bd492011-10-28 14:33:57 -07004814 Dbg::DdmSendChunk(native ? CHUNK_TYPE("NHST") : CHUNK_TYPE("HPST"), sizeof(heap_id), heap_id);
Hiroshi Yamauchicf58d4a2013-09-26 14:21:22 -07004815 Thread* self = Thread::Current();
Hiroshi Yamauchicf58d4a2013-09-26 14:21:22 -07004816 Locks::mutator_lock_->AssertSharedHeld(self);
Hiroshi Yamauchicf58d4a2013-09-26 14:21:22 -07004817
Elliott Hughes6a5bd492011-10-28 14:33:57 -07004818 // Send a series of heap segment chunks.
Mathieu Chartierbc689b72014-12-14 17:01:31 -08004819 HeapChunkContext context(what == HPSG_WHAT_MERGED_OBJECTS, native);
Elliott Hughesa2155262011-11-16 16:26:58 -08004820 if (native) {
Dimitry Ivanove6465bc2015-12-14 18:55:02 -08004821 UNIMPLEMENTED(WARNING) << "Native heap inspection is not supported";
Elliott Hughesa2155262011-11-16 16:26:58 -08004822 } else {
Ian Rogers1d54e732013-05-02 21:10:01 -07004823 gc::Heap* heap = Runtime::Current()->GetHeap();
Mathieu Chartier36dab362014-07-30 14:59:56 -07004824 for (const auto& space : heap->GetContinuousSpaces()) {
4825 if (space->IsDlMallocSpace()) {
Mathieu Chartier4c69d7f2014-10-10 12:45:50 -07004826 ReaderMutexLock mu(self, *Locks::heap_bitmap_lock_);
Mathieu Chartier36dab362014-07-30 14:59:56 -07004827 // dlmalloc's chunk header is 2 * sizeof(size_t), but if the previous chunk is in use for an
4828 // allocation then the first sizeof(size_t) may belong to it.
4829 context.SetChunkOverhead(sizeof(size_t));
Mathieu Chartierbc689b72014-12-14 17:01:31 -08004830 space->AsDlMallocSpace()->Walk(HeapChunkContext::HeapChunkJavaCallback, &context);
Mathieu Chartier36dab362014-07-30 14:59:56 -07004831 } else if (space->IsRosAllocSpace()) {
4832 context.SetChunkOverhead(0);
Mathieu Chartier4c69d7f2014-10-10 12:45:50 -07004833 // Need to acquire the mutator lock before the heap bitmap lock with exclusive access since
4834 // RosAlloc's internal logic doesn't know to release and reacquire the heap bitmap lock.
Mathieu Chartierf1d666e2015-09-03 16:13:34 -07004835 ScopedThreadSuspension sts(self, kSuspended);
Mathieu Chartier4f55e222015-09-04 13:26:21 -07004836 ScopedSuspendAll ssa(__FUNCTION__);
4837 ReaderMutexLock mu(self, *Locks::heap_bitmap_lock_);
4838 space->AsRosAllocSpace()->Walk(HeapChunkContext::HeapChunkJavaCallback, &context);
Mathieu Chartier36dab362014-07-30 14:59:56 -07004839 } else if (space->IsBumpPointerSpace()) {
Mathieu Chartier4c69d7f2014-10-10 12:45:50 -07004840 ReaderMutexLock mu(self, *Locks::heap_bitmap_lock_);
Mathieu Chartier36dab362014-07-30 14:59:56 -07004841 context.SetChunkOverhead(0);
Mathieu Chartier36dab362014-07-30 14:59:56 -07004842 space->AsBumpPointerSpace()->Walk(BumpPointerSpaceCallback, &context);
Mathieu Chartierbc689b72014-12-14 17:01:31 -08004843 HeapChunkContext::HeapChunkJavaCallback(nullptr, nullptr, 0, &context);
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -08004844 } else if (space->IsRegionSpace()) {
4845 heap->IncrementDisableMovingGC(self);
Mathieu Chartierf1d666e2015-09-03 16:13:34 -07004846 {
4847 ScopedThreadSuspension sts(self, kSuspended);
Mathieu Chartier4f55e222015-09-04 13:26:21 -07004848 ScopedSuspendAll ssa(__FUNCTION__);
Mathieu Chartierf1d666e2015-09-03 16:13:34 -07004849 ReaderMutexLock mu(self, *Locks::heap_bitmap_lock_);
4850 context.SetChunkOverhead(0);
4851 space->AsRegionSpace()->Walk(BumpPointerSpaceCallback, &context);
4852 HeapChunkContext::HeapChunkJavaCallback(nullptr, nullptr, 0, &context);
Mathieu Chartierf1d666e2015-09-03 16:13:34 -07004853 }
Hiroshi Yamauchi2cd334a2015-01-09 14:03:35 -08004854 heap->DecrementDisableMovingGC(self);
Mathieu Chartier36dab362014-07-30 14:59:56 -07004855 } else {
4856 UNIMPLEMENTED(WARNING) << "Not counting objects in space " << *space;
Mathieu Chartierb062fdd2012-07-03 09:51:48 -07004857 }
Mathieu Chartier36dab362014-07-30 14:59:56 -07004858 context.ResetStartOfNextChunk();
Mathieu Chartierb062fdd2012-07-03 09:51:48 -07004859 }
Mathieu Chartier4c69d7f2014-10-10 12:45:50 -07004860 ReaderMutexLock mu(self, *Locks::heap_bitmap_lock_);
Mathieu Chartiere0f0cb32012-08-28 11:26:00 -07004861 // Walk the large objects, these are not in the AllocSpace.
Mathieu Chartier36dab362014-07-30 14:59:56 -07004862 context.SetChunkOverhead(0);
Mathieu Chartierbc689b72014-12-14 17:01:31 -08004863 heap->GetLargeObjectsSpace()->Walk(HeapChunkContext::HeapChunkJavaCallback, &context);
Elliott Hughesa2155262011-11-16 16:26:58 -08004864 }
Elliott Hughes6a5bd492011-10-28 14:33:57 -07004865
4866 // Finally, send a heap end chunk.
4867 Dbg::DdmSendChunk(native ? CHUNK_TYPE("NHEN") : CHUNK_TYPE("HPEN"), sizeof(heap_id), heap_id);
Elliott Hughes767a1472011-10-26 18:49:02 -07004868}
4869
Brian Carlstrom306db812014-09-05 13:01:41 -07004870void Dbg::SetAllocTrackingEnabled(bool enable) {
Man Cao8c2ff642015-05-27 17:25:30 -07004871 gc::AllocRecordObjectMap::SetAllocTrackingEnabled(enable);
Elliott Hughes545a0642011-11-08 19:10:03 -08004872}
4873
4874void Dbg::DumpRecentAllocations() {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07004875 ScopedObjectAccess soa(Thread::Current());
Brian Carlstrom306db812014-09-05 13:01:41 -07004876 MutexLock mu(soa.Self(), *Locks::alloc_tracker_lock_);
Man Cao8c2ff642015-05-27 17:25:30 -07004877 if (!Runtime::Current()->GetHeap()->IsAllocTrackingEnabled()) {
Elliott Hughes545a0642011-11-08 19:10:03 -08004878 LOG(INFO) << "Not recording tracked allocations";
4879 return;
4880 }
Man Cao8c2ff642015-05-27 17:25:30 -07004881 gc::AllocRecordObjectMap* records = Runtime::Current()->GetHeap()->GetAllocationRecords();
4882 CHECK(records != nullptr);
Elliott Hughes545a0642011-11-08 19:10:03 -08004883
Man Cao1ed11b92015-06-11 22:47:35 -07004884 const uint16_t capped_count = CappedAllocRecordCount(records->GetRecentAllocationSize());
Brian Carlstrom306db812014-09-05 13:01:41 -07004885 uint16_t count = capped_count;
Elliott Hughes545a0642011-11-08 19:10:03 -08004886
Man Cao8c2ff642015-05-27 17:25:30 -07004887 LOG(INFO) << "Tracked allocations, (count=" << count << ")";
4888 for (auto it = records->RBegin(), end = records->REnd();
4889 count > 0 && it != end; count--, it++) {
Mathieu Chartier458b1052016-03-29 14:02:55 -07004890 const gc::AllocRecord* record = &it->second;
Elliott Hughes545a0642011-11-08 19:10:03 -08004891
Man Cao8c2ff642015-05-27 17:25:30 -07004892 LOG(INFO) << StringPrintf(" Thread %-2d %6zd bytes ", record->GetTid(), record->ByteCount())
David Sehr709b0702016-10-13 09:12:37 -07004893 << mirror::Class::PrettyClass(record->GetClass());
Elliott Hughes545a0642011-11-08 19:10:03 -08004894
Man Cao8c2ff642015-05-27 17:25:30 -07004895 for (size_t stack_frame = 0, depth = record->GetDepth(); stack_frame < depth; ++stack_frame) {
4896 const gc::AllocRecordStackTraceElement& stack_element = record->StackElement(stack_frame);
4897 ArtMethod* m = stack_element.GetMethod();
David Sehr709b0702016-10-13 09:12:37 -07004898 LOG(INFO) << " " << ArtMethod::PrettyMethod(m) << " line "
4899 << stack_element.ComputeLineNumber();
Elliott Hughes545a0642011-11-08 19:10:03 -08004900 }
4901
4902 // pause periodically to help logcat catch up
4903 if ((count % 5) == 0) {
4904 usleep(40000);
4905 }
Elliott Hughes545a0642011-11-08 19:10:03 -08004906 }
4907}
4908
4909class StringTable {
4910 public:
4911 StringTable() {
4912 }
4913
Mathieu Chartier4345c462014-06-27 10:20:14 -07004914 void Add(const std::string& str) {
4915 table_.insert(str);
4916 }
4917
4918 void Add(const char* str) {
4919 table_.insert(str);
Elliott Hughes545a0642011-11-08 19:10:03 -08004920 }
4921
Elliott Hughesa8f93cb2012-06-08 17:08:48 -07004922 size_t IndexOf(const char* s) const {
Mathieu Chartier02e25112013-08-14 16:14:24 -07004923 auto it = table_.find(s);
Elliott Hughesa8f93cb2012-06-08 17:08:48 -07004924 if (it == table_.end()) {
4925 LOG(FATAL) << "IndexOf(\"" << s << "\") failed";
4926 }
4927 return std::distance(table_.begin(), it);
Elliott Hughes545a0642011-11-08 19:10:03 -08004928 }
4929
Elliott Hughesa8f93cb2012-06-08 17:08:48 -07004930 size_t Size() const {
Elliott Hughes545a0642011-11-08 19:10:03 -08004931 return table_.size();
4932 }
4933
Elliott Hughesa8f93cb2012-06-08 17:08:48 -07004934 void WriteTo(std::vector<uint8_t>& bytes) const {
Mathieu Chartier02e25112013-08-14 16:14:24 -07004935 for (const std::string& str : table_) {
4936 const char* s = str.c_str();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08004937 size_t s_len = CountModifiedUtf8Chars(s);
Christopher Ferris8a354052015-04-24 17:23:53 -07004938 std::unique_ptr<uint16_t[]> s_utf16(new uint16_t[s_len]);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08004939 ConvertModifiedUtf8ToUtf16(s_utf16.get(), s);
4940 JDWP::AppendUtf16BE(bytes, s_utf16.get(), s_len);
Elliott Hughes545a0642011-11-08 19:10:03 -08004941 }
4942 }
4943
4944 private:
Elliott Hughesa8f93cb2012-06-08 17:08:48 -07004945 std::set<std::string> table_;
Elliott Hughes545a0642011-11-08 19:10:03 -08004946 DISALLOW_COPY_AND_ASSIGN(StringTable);
4947};
4948
Mathieu Chartiere401d142015-04-22 13:56:20 -07004949static const char* GetMethodSourceFile(ArtMethod* method)
Andreas Gampebdf7f1c2016-08-30 16:38:47 -07004950 REQUIRES_SHARED(Locks::mutator_lock_) {
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07004951 DCHECK(method != nullptr);
4952 const char* source_file = method->GetDeclaringClassSourceFile();
Sebastien Hertz280286a2014-04-28 09:26:50 +02004953 return (source_file != nullptr) ? source_file : "";
4954}
4955
Elliott Hughes545a0642011-11-08 19:10:03 -08004956/*
4957 * The data we send to DDMS contains everything we have recorded.
4958 *
4959 * Message header (all values big-endian):
4960 * (1b) message header len (to allow future expansion); includes itself
4961 * (1b) entry header len
4962 * (1b) stack frame len
4963 * (2b) number of entries
4964 * (4b) offset to string table from start of message
4965 * (2b) number of class name strings
4966 * (2b) number of method name strings
4967 * (2b) number of source file name strings
4968 * For each entry:
4969 * (4b) total allocation size
Elliott Hughes221229c2013-01-08 18:17:50 -08004970 * (2b) thread id
Elliott Hughes545a0642011-11-08 19:10:03 -08004971 * (2b) allocated object's class name index
4972 * (1b) stack depth
4973 * For each stack frame:
4974 * (2b) method's class name
4975 * (2b) method name
4976 * (2b) method source file
4977 * (2b) line number, clipped to 32767; -2 if native; -1 if no source
4978 * (xb) class name strings
4979 * (xb) method name strings
4980 * (xb) source file strings
4981 *
4982 * As with other DDM traffic, strings are sent as a 4-byte length
4983 * followed by UTF-16 data.
4984 *
4985 * We send up 16-bit unsigned indexes into string tables. In theory there
Brian Carlstrom306db812014-09-05 13:01:41 -07004986 * can be (kMaxAllocRecordStackDepth * alloc_record_max_) unique strings in
Elliott Hughes545a0642011-11-08 19:10:03 -08004987 * each table, but in practice there should be far fewer.
4988 *
4989 * The chief reason for using a string table here is to keep the size of
4990 * the DDMS message to a minimum. This is partly to make the protocol
4991 * efficient, but also because we have to form the whole thing up all at
4992 * once in a memory buffer.
4993 *
4994 * We use separate string tables for class names, method names, and source
4995 * files to keep the indexes small. There will generally be no overlap
4996 * between the contents of these tables.
4997 */
4998jbyteArray Dbg::GetRecentAllocations() {
Ian Rogerscf7f1912014-10-22 22:06:39 -07004999 if ((false)) {
Elliott Hughes545a0642011-11-08 19:10:03 -08005000 DumpRecentAllocations();
5001 }
5002
Ian Rogers50b35e22012-10-04 10:09:15 -07005003 Thread* self = Thread::Current();
Elliott Hughes545a0642011-11-08 19:10:03 -08005004 std::vector<uint8_t> bytes;
Mathieu Chartier46e811b2013-07-10 17:09:14 -07005005 {
Brian Carlstrom306db812014-09-05 13:01:41 -07005006 MutexLock mu(self, *Locks::alloc_tracker_lock_);
Man Cao8c2ff642015-05-27 17:25:30 -07005007 gc::AllocRecordObjectMap* records = Runtime::Current()->GetHeap()->GetAllocationRecords();
5008 // In case this method is called when allocation tracker is disabled,
5009 // we should still send some data back.
5010 gc::AllocRecordObjectMap dummy;
5011 if (records == nullptr) {
5012 CHECK(!Runtime::Current()->GetHeap()->IsAllocTrackingEnabled());
5013 records = &dummy;
5014 }
Man Cao41656de2015-07-06 18:53:15 -07005015 // We don't need to wait on the condition variable records->new_record_condition_, because this
5016 // function only reads the class objects, which are already marked so it doesn't change their
5017 // reachability.
Man Cao8c2ff642015-05-27 17:25:30 -07005018
Mathieu Chartier46e811b2013-07-10 17:09:14 -07005019 //
5020 // Part 1: generate string tables.
5021 //
5022 StringTable class_names;
5023 StringTable method_names;
5024 StringTable filenames;
Elliott Hughes545a0642011-11-08 19:10:03 -08005025
Man Cao1ed11b92015-06-11 22:47:35 -07005026 const uint16_t capped_count = CappedAllocRecordCount(records->GetRecentAllocationSize());
Brian Carlstrom306db812014-09-05 13:01:41 -07005027 uint16_t count = capped_count;
Man Cao8c2ff642015-05-27 17:25:30 -07005028 for (auto it = records->RBegin(), end = records->REnd();
5029 count > 0 && it != end; count--, it++) {
Mathieu Chartier458b1052016-03-29 14:02:55 -07005030 const gc::AllocRecord* record = &it->second;
Ian Rogers1ff3c982014-08-12 02:30:58 -07005031 std::string temp;
Man Cao41656de2015-07-06 18:53:15 -07005032 class_names.Add(record->GetClassDescriptor(&temp));
Man Cao8c2ff642015-05-27 17:25:30 -07005033 for (size_t i = 0, depth = record->GetDepth(); i < depth; i++) {
5034 ArtMethod* m = record->StackElement(i).GetMethod();
5035 class_names.Add(m->GetDeclaringClassDescriptor());
5036 method_names.Add(m->GetName());
5037 filenames.Add(GetMethodSourceFile(m));
Mathieu Chartier46e811b2013-07-10 17:09:14 -07005038 }
Elliott Hughes545a0642011-11-08 19:10:03 -08005039 }
5040
Man Cao8c2ff642015-05-27 17:25:30 -07005041 LOG(INFO) << "recent allocation records: " << capped_count;
5042 LOG(INFO) << "allocation records all objects: " << records->Size();
Mathieu Chartier46e811b2013-07-10 17:09:14 -07005043
5044 //
5045 // Part 2: Generate the output and store it in the buffer.
5046 //
5047
5048 // (1b) message header len (to allow future expansion); includes itself
5049 // (1b) entry header len
5050 // (1b) stack frame len
5051 const int kMessageHeaderLen = 15;
5052 const int kEntryHeaderLen = 9;
5053 const int kStackFrameLen = 8;
5054 JDWP::Append1BE(bytes, kMessageHeaderLen);
5055 JDWP::Append1BE(bytes, kEntryHeaderLen);
5056 JDWP::Append1BE(bytes, kStackFrameLen);
5057
5058 // (2b) number of entries
5059 // (4b) offset to string table from start of message
5060 // (2b) number of class name strings
5061 // (2b) number of method name strings
5062 // (2b) number of source file name strings
Brian Carlstrom306db812014-09-05 13:01:41 -07005063 JDWP::Append2BE(bytes, capped_count);
Mathieu Chartier46e811b2013-07-10 17:09:14 -07005064 size_t string_table_offset = bytes.size();
Brian Carlstrom7934ac22013-07-26 10:54:15 -07005065 JDWP::Append4BE(bytes, 0); // We'll patch this later...
Mathieu Chartier46e811b2013-07-10 17:09:14 -07005066 JDWP::Append2BE(bytes, class_names.Size());
5067 JDWP::Append2BE(bytes, method_names.Size());
5068 JDWP::Append2BE(bytes, filenames.Size());
5069
Ian Rogers1ff3c982014-08-12 02:30:58 -07005070 std::string temp;
Man Cao8c2ff642015-05-27 17:25:30 -07005071 count = capped_count;
5072 // The last "count" number of allocation records in "records" are the most recent "count" number
5073 // of allocations. Reverse iterate to get them. The most recent allocation is sent first.
5074 for (auto it = records->RBegin(), end = records->REnd();
5075 count > 0 && it != end; count--, it++) {
Mathieu Chartier46e811b2013-07-10 17:09:14 -07005076 // For each entry:
5077 // (4b) total allocation size
5078 // (2b) thread id
5079 // (2b) allocated object's class name index
5080 // (1b) stack depth
Mathieu Chartier458b1052016-03-29 14:02:55 -07005081 const gc::AllocRecord* record = &it->second;
Mathieu Chartier46e811b2013-07-10 17:09:14 -07005082 size_t stack_depth = record->GetDepth();
Mathieu Chartierf8322842014-05-16 10:59:25 -07005083 size_t allocated_object_class_name_index =
Man Cao41656de2015-07-06 18:53:15 -07005084 class_names.IndexOf(record->GetClassDescriptor(&temp));
Hiroshi Yamauchib5a9e3d2014-06-09 12:11:20 -07005085 JDWP::Append4BE(bytes, record->ByteCount());
Man Cao8c2ff642015-05-27 17:25:30 -07005086 JDWP::Append2BE(bytes, static_cast<uint16_t>(record->GetTid()));
Mathieu Chartier46e811b2013-07-10 17:09:14 -07005087 JDWP::Append2BE(bytes, allocated_object_class_name_index);
5088 JDWP::Append1BE(bytes, stack_depth);
5089
Mathieu Chartier46e811b2013-07-10 17:09:14 -07005090 for (size_t stack_frame = 0; stack_frame < stack_depth; ++stack_frame) {
5091 // For each stack frame:
5092 // (2b) method's class name
5093 // (2b) method name
5094 // (2b) method source file
5095 // (2b) line number, clipped to 32767; -2 if native; -1 if no source
Man Cao8c2ff642015-05-27 17:25:30 -07005096 ArtMethod* m = record->StackElement(stack_frame).GetMethod();
Mathieu Chartierbfd9a432014-05-21 17:43:44 -07005097 size_t class_name_index = class_names.IndexOf(m->GetDeclaringClassDescriptor());
5098 size_t method_name_index = method_names.IndexOf(m->GetName());
5099 size_t file_name_index = filenames.IndexOf(GetMethodSourceFile(m));
Mathieu Chartier46e811b2013-07-10 17:09:14 -07005100 JDWP::Append2BE(bytes, class_name_index);
5101 JDWP::Append2BE(bytes, method_name_index);
5102 JDWP::Append2BE(bytes, file_name_index);
Man Cao8c2ff642015-05-27 17:25:30 -07005103 JDWP::Append2BE(bytes, record->StackElement(stack_frame).ComputeLineNumber());
Mathieu Chartier46e811b2013-07-10 17:09:14 -07005104 }
Mathieu Chartier46e811b2013-07-10 17:09:14 -07005105 }
5106
5107 // (xb) class name strings
5108 // (xb) method name strings
5109 // (xb) source file strings
5110 JDWP::Set4BE(&bytes[string_table_offset], bytes.size());
5111 class_names.WriteTo(bytes);
5112 method_names.WriteTo(bytes);
5113 filenames.WriteTo(bytes);
Elliott Hughes545a0642011-11-08 19:10:03 -08005114 }
Ian Rogers50b35e22012-10-04 10:09:15 -07005115 JNIEnv* env = self->GetJniEnv();
Elliott Hughes545a0642011-11-08 19:10:03 -08005116 jbyteArray result = env->NewByteArray(bytes.size());
Ian Rogersc0542af2014-09-03 16:16:56 -07005117 if (result != nullptr) {
Elliott Hughes545a0642011-11-08 19:10:03 -08005118 env->SetByteArrayRegion(result, 0, bytes.size(), reinterpret_cast<const jbyte*>(&bytes[0]));
5119 }
5120 return result;
5121}
5122
Mathieu Chartiere401d142015-04-22 13:56:20 -07005123ArtMethod* DeoptimizationRequest::Method() const {
Andreas Gampe13b27842016-11-07 16:48:23 -08005124 return jni::DecodeArtMethod(method_);
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -07005125}
5126
Mathieu Chartiere401d142015-04-22 13:56:20 -07005127void DeoptimizationRequest::SetMethod(ArtMethod* m) {
Andreas Gampe13b27842016-11-07 16:48:23 -08005128 method_ = jni::EncodeArtMethod(m);
Hiroshi Yamauchi0ec17d22014-07-07 13:07:08 -07005129}
5130
Mathieu Chartiera6b1ead2015-10-06 10:32:38 -07005131void Dbg::VisitRoots(RootVisitor* visitor) {
5132 // Visit breakpoint roots, used to prevent unloading of methods with breakpoints.
5133 ReaderMutexLock mu(Thread::Current(), *Locks::breakpoint_lock_);
5134 BufferedRootVisitor<128> root_visitor(visitor, RootInfo(kRootVMInternal));
5135 for (Breakpoint& breakpoint : gBreakpoints) {
Andreas Gampe542451c2016-07-26 09:02:02 -07005136 breakpoint.Method()->VisitRoots(root_visitor, kRuntimePointerSize);
Mathieu Chartiera6b1ead2015-10-06 10:32:38 -07005137 }
5138}
5139
Elliott Hughes872d4ec2011-10-21 17:07:15 -07005140} // namespace art