blob: 1df7fe94ab3cbd6c089528fa4251fe5fcdddd16e [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
23#include "class_linker.h"
Elliott Hughes1bba14f2011-12-01 18:00:36 -080024#include "class_loader.h"
Ian Rogers776ac1f2012-04-13 23:36:36 -070025#include "dex_instruction.h"
Mathieu Chartier1c23e1e2012-10-12 14:14:11 -070026#include "gc/large_object_space.h"
27#include "gc/space.h"
Ian Rogers2bcb4a42012-11-08 10:39:18 -080028#include "oat/runtime/context.h"
Ian Rogers6d4d9fc2011-11-30 16:24:48 -080029#include "object_utils.h"
Elliott Hughesa0e18062012-04-13 15:59:59 -070030#include "safe_map.h"
Elliott Hughes6a5bd492011-10-28 14:33:57 -070031#include "ScopedLocalRef.h"
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -070032#include "ScopedPrimitiveArray.h"
Ian Rogers00f7d0e2012-07-19 15:28:27 -070033#include "scoped_thread_state_change.h"
Ian Rogers1f539342012-10-03 21:09:42 -070034#include "sirt_ref.h"
Elliott Hughes47fce012011-10-25 18:37:19 -070035#include "stack_indirect_reference_table.h"
Elliott Hughes475fc232011-10-25 15:00:35 -070036#include "thread_list.h"
Elliott Hugheseac76672012-05-24 21:56:51 -070037#include "well_known_classes.h"
Elliott Hughes475fc232011-10-25 15:00:35 -070038
Elliott Hughes872d4ec2011-10-21 17:07:15 -070039namespace art {
40
Elliott Hughes545a0642011-11-08 19:10:03 -080041static const size_t kMaxAllocRecordStackDepth = 16; // Max 255.
42static const size_t kNumAllocRecords = 512; // Must be power of 2.
43
Elliott Hughes436e3722012-02-17 20:01:47 -080044static const uintptr_t kInvalidId = 1;
45static const Object* kInvalidObject = reinterpret_cast<Object*>(kInvalidId);
46
Elliott Hughes475fc232011-10-25 15:00:35 -070047class ObjectRegistry {
48 public:
49 ObjectRegistry() : lock_("ObjectRegistry lock") {
50 }
51
52 JDWP::ObjectId Add(Object* o) {
53 if (o == NULL) {
54 return 0;
55 }
56 JDWP::ObjectId id = static_cast<JDWP::ObjectId>(reinterpret_cast<uintptr_t>(o));
Ian Rogers50b35e22012-10-04 10:09:15 -070057 MutexLock mu(Thread::Current(), lock_);
Elliott Hughesa0e18062012-04-13 15:59:59 -070058 map_.Overwrite(id, o);
Elliott Hughes475fc232011-10-25 15:00:35 -070059 return id;
60 }
61
Elliott Hughes234ab152011-10-26 14:02:26 -070062 void Clear() {
Ian Rogers50b35e22012-10-04 10:09:15 -070063 MutexLock mu(Thread::Current(), lock_);
Elliott Hughes234ab152011-10-26 14:02:26 -070064 LOG(DEBUG) << "Debugger has detached; object registry had " << map_.size() << " entries";
65 map_.clear();
66 }
67
Elliott Hughes475fc232011-10-25 15:00:35 -070068 bool Contains(JDWP::ObjectId id) {
Ian Rogers50b35e22012-10-04 10:09:15 -070069 MutexLock mu(Thread::Current(), lock_);
Elliott Hughes475fc232011-10-25 15:00:35 -070070 return map_.find(id) != map_.end();
71 }
72
Elliott Hughesa2155262011-11-16 16:26:58 -080073 template<typename T> T Get(JDWP::ObjectId id) {
Elliott Hughes436e3722012-02-17 20:01:47 -080074 if (id == 0) {
75 return NULL;
76 }
77
Ian Rogers50b35e22012-10-04 10:09:15 -070078 MutexLock mu(Thread::Current(), lock_);
Elliott Hughesa0e18062012-04-13 15:59:59 -070079 typedef SafeMap<JDWP::ObjectId, Object*>::iterator It; // C++0x auto
Elliott Hughesa2155262011-11-16 16:26:58 -080080 It it = map_.find(id);
Elliott Hughes436e3722012-02-17 20:01:47 -080081 return (it != map_.end()) ? reinterpret_cast<T>(it->second) : reinterpret_cast<T>(kInvalidId);
Elliott Hughesa2155262011-11-16 16:26:58 -080082 }
83
Elliott Hughesbfe487b2011-10-26 15:48:55 -070084 void VisitRoots(Heap::RootVisitor* visitor, void* arg) {
Ian Rogers50b35e22012-10-04 10:09:15 -070085 MutexLock mu(Thread::Current(), lock_);
Elliott Hughesa0e18062012-04-13 15:59:59 -070086 typedef SafeMap<JDWP::ObjectId, Object*>::iterator It; // C++0x auto
Elliott Hughesbfe487b2011-10-26 15:48:55 -070087 for (It it = map_.begin(); it != map_.end(); ++it) {
88 visitor(it->second, arg);
89 }
90 }
91
Elliott Hughes475fc232011-10-25 15:00:35 -070092 private:
Ian Rogers00f7d0e2012-07-19 15:28:27 -070093 Mutex lock_ DEFAULT_MUTEX_ACQUIRED_AFTER;
Elliott Hughesa0e18062012-04-13 15:59:59 -070094 SafeMap<JDWP::ObjectId, Object*> map_;
Elliott Hughes475fc232011-10-25 15:00:35 -070095};
96
Elliott Hughes545a0642011-11-08 19:10:03 -080097struct AllocRecordStackTraceElement {
Mathieu Chartier66f19252012-09-18 08:57:04 -070098 AbstractMethod* method;
Ian Rogers0399dde2012-06-06 17:09:28 -070099 uint32_t dex_pc;
Elliott Hughes545a0642011-11-08 19:10:03 -0800100
Ian Rogersb726dcb2012-09-05 08:57:23 -0700101 int32_t LineNumber() const SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers0399dde2012-06-06 17:09:28 -0700102 return MethodHelper(method).GetLineNumFromDexPC(dex_pc);
Elliott Hughes545a0642011-11-08 19:10:03 -0800103 }
104};
105
106struct AllocRecord {
107 Class* type;
108 size_t byte_count;
109 uint16_t thin_lock_id;
110 AllocRecordStackTraceElement stack[kMaxAllocRecordStackDepth]; // Unused entries have NULL method.
111
112 size_t GetDepth() {
113 size_t depth = 0;
114 while (depth < kMaxAllocRecordStackDepth && stack[depth].method != NULL) {
115 ++depth;
116 }
117 return depth;
118 }
119};
120
Elliott Hughes86964332012-02-15 19:37:42 -0800121struct Breakpoint {
Mathieu Chartier66f19252012-09-18 08:57:04 -0700122 AbstractMethod* method;
Elliott Hughesa656a0f2012-02-21 18:03:44 -0800123 uint32_t dex_pc;
Mathieu Chartier66f19252012-09-18 08:57:04 -0700124 Breakpoint(AbstractMethod* method, uint32_t dex_pc) : method(method), dex_pc(dex_pc) {}
Elliott Hughes86964332012-02-15 19:37:42 -0800125};
126
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700127static std::ostream& operator<<(std::ostream& os, const Breakpoint& rhs)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700128 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughes229feb72012-02-23 13:33:29 -0800129 os << StringPrintf("Breakpoint[%s @%#x]", PrettyMethod(rhs.method).c_str(), rhs.dex_pc);
Elliott Hughes86964332012-02-15 19:37:42 -0800130 return os;
131}
132
133struct SingleStepControl {
134 // Are we single-stepping right now?
135 bool is_active;
136 Thread* thread;
137
138 JDWP::JdwpStepSize step_size;
139 JDWP::JdwpStepDepth step_depth;
140
Mathieu Chartier66f19252012-09-18 08:57:04 -0700141 const AbstractMethod* method;
Elliott Hughes2435a572012-02-17 16:07:41 -0800142 int32_t line_number; // Or -1 for native methods.
143 std::set<uint32_t> dex_pcs;
Elliott Hughes86964332012-02-15 19:37:42 -0800144 int stack_depth;
145};
146
Elliott Hughes4ffd3132011-10-24 12:06:42 -0700147// JDWP is allowed unless the Zygote forbids it.
148static bool gJdwpAllowed = true;
149
Elliott Hughesc0f09332012-03-26 13:27:06 -0700150// Was there a -Xrunjdwp or -agentlib:jdwp= argument on the command line?
Elliott Hughes3bb81562011-10-21 18:52:59 -0700151static bool gJdwpConfigured = false;
152
Elliott Hughesc0f09332012-03-26 13:27:06 -0700153// Broken-down JDWP options. (Only valid if IsJdwpConfigured() is true.)
Elliott Hughes376a7a02011-10-24 18:35:55 -0700154static JDWP::JdwpOptions gJdwpOptions;
Elliott Hughes3bb81562011-10-21 18:52:59 -0700155
156// Runtime JDWP state.
157static JDWP::JdwpState* gJdwpState = NULL;
158static bool gDebuggerConnected; // debugger or DDMS is connected.
159static bool gDebuggerActive; // debugger is making requests.
Elliott Hughes86964332012-02-15 19:37:42 -0800160static bool gDisposed; // debugger called VirtualMachine.Dispose, so we should drop the connection.
Elliott Hughes3bb81562011-10-21 18:52:59 -0700161
Elliott Hughes47fce012011-10-25 18:37:19 -0700162static bool gDdmThreadNotification = false;
163
Elliott Hughes767a1472011-10-26 18:49:02 -0700164// DDMS GC-related settings.
165static Dbg::HpifWhen gDdmHpifWhen = Dbg::HPIF_WHEN_NEVER;
166static Dbg::HpsgWhen gDdmHpsgWhen = Dbg::HPSG_WHEN_NEVER;
167static Dbg::HpsgWhat gDdmHpsgWhat;
168static Dbg::HpsgWhen gDdmNhsgWhen = Dbg::HPSG_WHEN_NEVER;
169static Dbg::HpsgWhat gDdmNhsgWhat;
170
Elliott Hughes475fc232011-10-25 15:00:35 -0700171static ObjectRegistry* gRegistry = NULL;
172
Elliott Hughes545a0642011-11-08 19:10:03 -0800173// Recent allocation tracking.
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700174static Mutex gAllocTrackerLock DEFAULT_MUTEX_ACQUIRED_AFTER ("AllocTracker lock");
Elliott Hughesf8349362012-06-18 15:00:06 -0700175AllocRecord* Dbg::recent_allocation_records_ PT_GUARDED_BY(gAllocTrackerLock) = NULL; // TODO: CircularBuffer<AllocRecord>
176static size_t gAllocRecordHead GUARDED_BY(gAllocTrackerLock) = 0;
177static size_t gAllocRecordCount GUARDED_BY(gAllocTrackerLock) = 0;
Elliott Hughes545a0642011-11-08 19:10:03 -0800178
Elliott Hughes86964332012-02-15 19:37:42 -0800179// Breakpoints and single-stepping.
jeffhao09bfc6a2012-12-11 18:11:43 -0800180static std::vector<Breakpoint> gBreakpoints GUARDED_BY(Locks::breakpoint_lock_);
181static SingleStepControl gSingleStepControl GUARDED_BY(Locks::breakpoint_lock_);
Elliott Hughes86964332012-02-15 19:37:42 -0800182
Mathieu Chartier66f19252012-09-18 08:57:04 -0700183static bool IsBreakpoint(AbstractMethod* m, uint32_t dex_pc)
jeffhao09bfc6a2012-12-11 18:11:43 -0800184 LOCKS_EXCLUDED(Locks::breakpoint_lock_)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700185 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
jeffhao09bfc6a2012-12-11 18:11:43 -0800186 MutexLock mu(Thread::Current(), *Locks::breakpoint_lock_);
Elliott Hughes86964332012-02-15 19:37:42 -0800187 for (size_t i = 0; i < gBreakpoints.size(); ++i) {
Elliott Hughesa656a0f2012-02-21 18:03:44 -0800188 if (gBreakpoints[i].method == m && gBreakpoints[i].dex_pc == dex_pc) {
Elliott Hughes86964332012-02-15 19:37:42 -0800189 VLOG(jdwp) << "Hit breakpoint #" << i << ": " << gBreakpoints[i];
190 return true;
191 }
192 }
193 return false;
194}
195
Elliott Hughes9e0c1752013-01-09 14:02:58 -0800196static bool IsSuspendedForDebugger(ScopedObjectAccessUnchecked& soa, Thread* thread) {
197 MutexLock mu(soa.Self(), *Locks::thread_suspend_count_lock_);
198 // A thread may be suspended for GC; in this code, we really want to know whether
199 // there's a debugger suspension active.
200 return thread->IsSuspended() && thread->GetDebugSuspendCount() > 0;
201}
202
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700203static Array* DecodeArray(JDWP::RefTypeId id, JDWP::JdwpError& status)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700204 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughes436e3722012-02-17 20:01:47 -0800205 Object* o = gRegistry->Get<Object*>(id);
206 if (o == NULL || o == kInvalidObject) {
207 status = JDWP::ERR_INVALID_OBJECT;
208 return NULL;
209 }
210 if (!o->IsArrayInstance()) {
211 status = JDWP::ERR_INVALID_ARRAY;
212 return NULL;
213 }
214 status = JDWP::ERR_NONE;
215 return o->AsArray();
216}
217
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700218static Class* DecodeClass(JDWP::RefTypeId id, JDWP::JdwpError& status)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700219 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughes436e3722012-02-17 20:01:47 -0800220 Object* o = gRegistry->Get<Object*>(id);
221 if (o == NULL || o == kInvalidObject) {
222 status = JDWP::ERR_INVALID_OBJECT;
223 return NULL;
224 }
225 if (!o->IsClass()) {
226 status = JDWP::ERR_INVALID_CLASS;
227 return NULL;
228 }
229 status = JDWP::ERR_NONE;
230 return o->AsClass();
231}
232
Elliott Hughes221229c2013-01-08 18:17:50 -0800233static JDWP::JdwpError DecodeThread(ScopedObjectAccessUnchecked& soa, JDWP::ObjectId thread_id, Thread*& thread)
jeffhaoa77f0f62012-12-05 17:19:31 -0800234 EXCLUSIVE_LOCKS_REQUIRED(Locks::thread_list_lock_)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700235 LOCKS_EXCLUDED(Locks::thread_suspend_count_lock_)
236 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughes221229c2013-01-08 18:17:50 -0800237 Object* thread_peer = gRegistry->Get<Object*>(thread_id);
Elliott Hughes436e3722012-02-17 20:01:47 -0800238 if (thread_peer == NULL || thread_peer == kInvalidObject) {
Elliott Hughes221229c2013-01-08 18:17:50 -0800239 // This isn't even an object.
240 return JDWP::ERR_INVALID_OBJECT;
Elliott Hughes436e3722012-02-17 20:01:47 -0800241 }
Elliott Hughes221229c2013-01-08 18:17:50 -0800242
243 Class* java_lang_Thread = soa.Decode<Class*>(WellKnownClasses::java_lang_Thread);
244 if (!java_lang_Thread->IsAssignableFrom(thread_peer->GetClass())) {
245 // This isn't a thread.
246 return JDWP::ERR_INVALID_THREAD;
247 }
248
249 thread = Thread::FromManagedThread(soa, thread_peer);
250 if (thread == NULL) {
251 // This is a java.lang.Thread without a Thread*. Must be a zombie.
252 return JDWP::ERR_THREAD_NOT_ALIVE;
253 }
254 return JDWP::ERR_NONE;
Elliott Hughes436e3722012-02-17 20:01:47 -0800255}
256
Elliott Hughes24437992011-11-30 14:49:33 -0800257static JDWP::JdwpTag BasicTagFromDescriptor(const char* descriptor) {
258 // JDWP deliberately uses the descriptor characters' ASCII values for its enum.
259 // Note that by "basic" we mean that we don't get more specific than JT_OBJECT.
260 return static_cast<JDWP::JdwpTag>(descriptor[0]);
261}
262
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700263static JDWP::JdwpTag TagFromClass(Class* c)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700264 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughes86b00102011-12-05 17:54:26 -0800265 CHECK(c != NULL);
Elliott Hughes24437992011-11-30 14:49:33 -0800266 if (c->IsArrayClass()) {
267 return JDWP::JT_ARRAY;
268 }
269
Elliott Hughes3d30d9b2011-12-07 17:35:48 -0800270 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
Elliott Hughes24437992011-11-30 14:49:33 -0800271 if (c->IsStringClass()) {
272 return JDWP::JT_STRING;
273 } else if (c->IsClassClass()) {
274 return JDWP::JT_CLASS_OBJECT;
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -0800275 } else if (class_linker->FindSystemClass("Ljava/lang/Thread;")->IsAssignableFrom(c)) {
Elliott Hughes24437992011-11-30 14:49:33 -0800276 return JDWP::JT_THREAD;
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -0800277 } else if (class_linker->FindSystemClass("Ljava/lang/ThreadGroup;")->IsAssignableFrom(c)) {
Elliott Hughes24437992011-11-30 14:49:33 -0800278 return JDWP::JT_THREAD_GROUP;
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -0800279 } else if (class_linker->FindSystemClass("Ljava/lang/ClassLoader;")->IsAssignableFrom(c)) {
Elliott Hughes24437992011-11-30 14:49:33 -0800280 return JDWP::JT_CLASS_LOADER;
Elliott Hughes24437992011-11-30 14:49:33 -0800281 } else {
282 return JDWP::JT_OBJECT;
283 }
284}
285
286/*
287 * Objects declared to hold Object might actually hold a more specific
288 * type. The debugger may take a special interest in these (e.g. it
289 * wants to display the contents of Strings), so we want to return an
290 * appropriate tag.
291 *
292 * Null objects are tagged JT_OBJECT.
293 */
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700294static JDWP::JdwpTag TagFromObject(const Object* o)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700295 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughes24437992011-11-30 14:49:33 -0800296 return (o == NULL) ? JDWP::JT_OBJECT : TagFromClass(o->GetClass());
297}
298
299static bool IsPrimitiveTag(JDWP::JdwpTag tag) {
300 switch (tag) {
301 case JDWP::JT_BOOLEAN:
302 case JDWP::JT_BYTE:
303 case JDWP::JT_CHAR:
304 case JDWP::JT_FLOAT:
305 case JDWP::JT_DOUBLE:
306 case JDWP::JT_INT:
307 case JDWP::JT_LONG:
308 case JDWP::JT_SHORT:
309 case JDWP::JT_VOID:
310 return true;
311 default:
312 return false;
313 }
314}
315
Elliott Hughes3bb81562011-10-21 18:52:59 -0700316/*
317 * Handle one of the JDWP name/value pairs.
318 *
319 * JDWP options are:
320 * help: if specified, show help message and bail
321 * transport: may be dt_socket or dt_shmem
322 * address: for dt_socket, "host:port", or just "port" when listening
323 * server: if "y", wait for debugger to attach; if "n", attach to debugger
324 * timeout: how long to wait for debugger to connect / listen
325 *
326 * Useful with server=n (these aren't supported yet):
327 * onthrow=<exception-name>: connect to debugger when exception thrown
328 * onuncaught=y|n: connect to debugger when uncaught exception thrown
329 * launch=<command-line>: launch the debugger itself
330 *
331 * The "transport" option is required, as is "address" if server=n.
332 */
333static bool ParseJdwpOption(const std::string& name, const std::string& value) {
334 if (name == "transport") {
335 if (value == "dt_socket") {
Elliott Hughes376a7a02011-10-24 18:35:55 -0700336 gJdwpOptions.transport = JDWP::kJdwpTransportSocket;
Elliott Hughes3bb81562011-10-21 18:52:59 -0700337 } else if (value == "dt_android_adb") {
Elliott Hughes376a7a02011-10-24 18:35:55 -0700338 gJdwpOptions.transport = JDWP::kJdwpTransportAndroidAdb;
Elliott Hughes3bb81562011-10-21 18:52:59 -0700339 } else {
340 LOG(ERROR) << "JDWP transport not supported: " << value;
341 return false;
342 }
343 } else if (name == "server") {
344 if (value == "n") {
Elliott Hughes376a7a02011-10-24 18:35:55 -0700345 gJdwpOptions.server = false;
Elliott Hughes3bb81562011-10-21 18:52:59 -0700346 } else if (value == "y") {
Elliott Hughes376a7a02011-10-24 18:35:55 -0700347 gJdwpOptions.server = true;
Elliott Hughes3bb81562011-10-21 18:52:59 -0700348 } else {
349 LOG(ERROR) << "JDWP option 'server' must be 'y' or 'n'";
350 return false;
351 }
352 } else if (name == "suspend") {
353 if (value == "n") {
Elliott Hughes376a7a02011-10-24 18:35:55 -0700354 gJdwpOptions.suspend = false;
Elliott Hughes3bb81562011-10-21 18:52:59 -0700355 } else if (value == "y") {
Elliott Hughes376a7a02011-10-24 18:35:55 -0700356 gJdwpOptions.suspend = true;
Elliott Hughes3bb81562011-10-21 18:52:59 -0700357 } else {
358 LOG(ERROR) << "JDWP option 'suspend' must be 'y' or 'n'";
359 return false;
360 }
361 } else if (name == "address") {
362 /* this is either <port> or <host>:<port> */
363 std::string port_string;
Elliott Hughes376a7a02011-10-24 18:35:55 -0700364 gJdwpOptions.host.clear();
Elliott Hughes3bb81562011-10-21 18:52:59 -0700365 std::string::size_type colon = value.find(':');
366 if (colon != std::string::npos) {
Elliott Hughes376a7a02011-10-24 18:35:55 -0700367 gJdwpOptions.host = value.substr(0, colon);
Elliott Hughes3bb81562011-10-21 18:52:59 -0700368 port_string = value.substr(colon + 1);
369 } else {
370 port_string = value;
371 }
372 if (port_string.empty()) {
373 LOG(ERROR) << "JDWP address missing port: " << value;
374 return false;
375 }
376 char* end;
Elliott Hughesba8eee12012-01-24 20:25:24 -0800377 uint64_t port = strtoul(port_string.c_str(), &end, 10);
378 if (*end != '\0' || port > 0xffff) {
Elliott Hughes3bb81562011-10-21 18:52:59 -0700379 LOG(ERROR) << "JDWP address has junk in port field: " << value;
380 return false;
381 }
Elliott Hughes376a7a02011-10-24 18:35:55 -0700382 gJdwpOptions.port = port;
Elliott Hughes3bb81562011-10-21 18:52:59 -0700383 } else if (name == "launch" || name == "onthrow" || name == "oncaught" || name == "timeout") {
384 /* valid but unsupported */
385 LOG(INFO) << "Ignoring JDWP option '" << name << "'='" << value << "'";
386 } else {
387 LOG(INFO) << "Ignoring unrecognized JDWP option '" << name << "'='" << value << "'";
388 }
389
390 return true;
391}
392
393/*
394 * Parse the latter half of a -Xrunjdwp/-agentlib:jdwp= string, e.g.:
395 * "transport=dt_socket,address=8000,server=y,suspend=n"
396 */
397bool Dbg::ParseJdwpOptions(const std::string& options) {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800398 VLOG(jdwp) << "ParseJdwpOptions: " << options;
Elliott Hughes47fce012011-10-25 18:37:19 -0700399
Elliott Hughes3bb81562011-10-21 18:52:59 -0700400 std::vector<std::string> pairs;
401 Split(options, ',', pairs);
402
403 for (size_t i = 0; i < pairs.size(); ++i) {
404 std::string::size_type equals = pairs[i].find('=');
405 if (equals == std::string::npos) {
406 LOG(ERROR) << "Can't parse JDWP option '" << pairs[i] << "' in '" << options << "'";
407 return false;
408 }
409 ParseJdwpOption(pairs[i].substr(0, equals), pairs[i].substr(equals + 1));
410 }
411
Elliott Hughes376a7a02011-10-24 18:35:55 -0700412 if (gJdwpOptions.transport == JDWP::kJdwpTransportUnknown) {
Elliott Hughes3bb81562011-10-21 18:52:59 -0700413 LOG(ERROR) << "Must specify JDWP transport: " << options;
414 }
Elliott Hughes376a7a02011-10-24 18:35:55 -0700415 if (!gJdwpOptions.server && (gJdwpOptions.host.empty() || gJdwpOptions.port == 0)) {
Elliott Hughes3bb81562011-10-21 18:52:59 -0700416 LOG(ERROR) << "Must specify JDWP host and port when server=n: " << options;
417 return false;
418 }
419
420 gJdwpConfigured = true;
421 return true;
422}
423
Elliott Hughesd1cc8362011-10-24 16:58:50 -0700424void Dbg::StartJdwp() {
Elliott Hughesc0f09332012-03-26 13:27:06 -0700425 if (!gJdwpAllowed || !IsJdwpConfigured()) {
Elliott Hughes376a7a02011-10-24 18:35:55 -0700426 // No JDWP for you!
427 return;
428 }
429
Elliott Hughes475fc232011-10-25 15:00:35 -0700430 CHECK(gRegistry == NULL);
431 gRegistry = new ObjectRegistry;
432
Elliott Hughesd1cc8362011-10-24 16:58:50 -0700433 // Init JDWP if the debugger is enabled. This may connect out to a
434 // debugger, passively listen for a debugger, or block waiting for a
435 // debugger.
Elliott Hughes376a7a02011-10-24 18:35:55 -0700436 gJdwpState = JDWP::JdwpState::Create(&gJdwpOptions);
437 if (gJdwpState == NULL) {
Elliott Hughesf8a2df72011-12-01 12:19:54 -0800438 // We probably failed because some other process has the port already, which means that
439 // if we don't abort the user is likely to think they're talking to us when they're actually
440 // talking to that other process.
Elliott Hughes3d30d9b2011-12-07 17:35:48 -0800441 LOG(FATAL) << "Debugger thread failed to initialize";
Elliott Hughesd1cc8362011-10-24 16:58:50 -0700442 }
443
444 // If a debugger has already attached, send the "welcome" message.
445 // This may cause us to suspend all threads.
Elliott Hughes376a7a02011-10-24 18:35:55 -0700446 if (gJdwpState->IsActive()) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700447 ScopedObjectAccess soa(Thread::Current());
Elliott Hughes376a7a02011-10-24 18:35:55 -0700448 if (!gJdwpState->PostVMStart()) {
Elliott Hughes3d30d9b2011-12-07 17:35:48 -0800449 LOG(WARNING) << "Failed to post 'start' message to debugger";
Elliott Hughesd1cc8362011-10-24 16:58:50 -0700450 }
451 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700452}
453
Elliott Hughesd1cc8362011-10-24 16:58:50 -0700454void Dbg::StopJdwp() {
Elliott Hughes376a7a02011-10-24 18:35:55 -0700455 delete gJdwpState;
Elliott Hughes475fc232011-10-25 15:00:35 -0700456 delete gRegistry;
457 gRegistry = NULL;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700458}
459
Elliott Hughes767a1472011-10-26 18:49:02 -0700460void Dbg::GcDidFinish() {
461 if (gDdmHpifWhen != HPIF_WHEN_NEVER) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700462 ScopedObjectAccess soa(Thread::Current());
Elliott Hughes81ff3182012-03-23 20:35:56 -0700463 LOG(DEBUG) << "Sending heap info to DDM";
Elliott Hughes7162ad92011-10-27 14:08:42 -0700464 DdmSendHeapInfo(gDdmHpifWhen);
Elliott Hughes767a1472011-10-26 18:49:02 -0700465 }
466 if (gDdmHpsgWhen != HPSG_WHEN_NEVER) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700467 ScopedObjectAccess soa(Thread::Current());
Elliott Hughes81ff3182012-03-23 20:35:56 -0700468 LOG(DEBUG) << "Dumping heap to DDM";
Elliott Hughes6a5bd492011-10-28 14:33:57 -0700469 DdmSendHeapSegments(false);
Elliott Hughes767a1472011-10-26 18:49:02 -0700470 }
471 if (gDdmNhsgWhen != HPSG_WHEN_NEVER) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700472 ScopedObjectAccess soa(Thread::Current());
Elliott Hughes767a1472011-10-26 18:49:02 -0700473 LOG(DEBUG) << "Dumping native heap to DDM";
Elliott Hughes6a5bd492011-10-28 14:33:57 -0700474 DdmSendHeapSegments(true);
Elliott Hughes767a1472011-10-26 18:49:02 -0700475 }
476}
477
Elliott Hughes4ffd3132011-10-24 12:06:42 -0700478void Dbg::SetJdwpAllowed(bool allowed) {
479 gJdwpAllowed = allowed;
480}
481
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700482DebugInvokeReq* Dbg::GetInvokeReq() {
Elliott Hughes475fc232011-10-25 15:00:35 -0700483 return Thread::Current()->GetInvokeReq();
484}
485
486Thread* Dbg::GetDebugThread() {
487 return (gJdwpState != NULL) ? gJdwpState->GetDebugThread() : NULL;
488}
489
490void Dbg::ClearWaitForEventThread() {
491 gJdwpState->ClearWaitForEventThread();
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700492}
493
494void Dbg::Connected() {
Elliott Hughes3bb81562011-10-21 18:52:59 -0700495 CHECK(!gDebuggerConnected);
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800496 VLOG(jdwp) << "JDWP has attached";
Elliott Hughes3bb81562011-10-21 18:52:59 -0700497 gDebuggerConnected = true;
Elliott Hughes86964332012-02-15 19:37:42 -0800498 gDisposed = false;
499}
500
501void Dbg::Disposed() {
502 gDisposed = true;
503}
504
505bool Dbg::IsDisposed() {
506 return gDisposed;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700507}
508
Elliott Hughesc0f09332012-03-26 13:27:06 -0700509static void SetDebuggerUpdatesEnabledCallback(Thread* t, void* user_data) {
510 t->SetDebuggerUpdatesEnabled(*reinterpret_cast<bool*>(user_data));
511}
512
513static void SetDebuggerUpdatesEnabled(bool enabled) {
Ian Rogers50b35e22012-10-04 10:09:15 -0700514 MutexLock mu(Thread::Current(), *Locks::thread_list_lock_);
Elliott Hughesf8349362012-06-18 15:00:06 -0700515 Runtime::Current()->GetThreadList()->ForEach(SetDebuggerUpdatesEnabledCallback, &enabled);
Elliott Hughesc0f09332012-03-26 13:27:06 -0700516}
517
Elliott Hughesa2155262011-11-16 16:26:58 -0800518void Dbg::GoActive() {
519 // Enable all debugging features, including scans for breakpoints.
520 // This is a no-op if we're already active.
521 // Only called from the JDWP handler thread.
522 if (gDebuggerActive) {
523 return;
524 }
525
526 LOG(INFO) << "Debugger is active";
527
Elliott Hughesc0f09332012-03-26 13:27:06 -0700528 {
529 // TODO: dalvik only warned if there were breakpoints left over. clear in Dbg::Disconnected?
jeffhao09bfc6a2012-12-11 18:11:43 -0800530 MutexLock mu(Thread::Current(), *Locks::breakpoint_lock_);
Elliott Hughesc0f09332012-03-26 13:27:06 -0700531 CHECK_EQ(gBreakpoints.size(), 0U);
532 }
Elliott Hughesa2155262011-11-16 16:26:58 -0800533
534 gDebuggerActive = true;
Elliott Hughesc0f09332012-03-26 13:27:06 -0700535 SetDebuggerUpdatesEnabled(true);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700536}
537
538void Dbg::Disconnected() {
Elliott Hughes234ab152011-10-26 14:02:26 -0700539 CHECK(gDebuggerConnected);
540
Elliott Hughesc0f09332012-03-26 13:27:06 -0700541 LOG(INFO) << "Debugger is no longer active";
Elliott Hughes234ab152011-10-26 14:02:26 -0700542
Elliott Hughesc0f09332012-03-26 13:27:06 -0700543 gDebuggerActive = false;
544 SetDebuggerUpdatesEnabled(false);
Elliott Hughes234ab152011-10-26 14:02:26 -0700545
546 gRegistry->Clear();
547 gDebuggerConnected = false;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700548}
549
Elliott Hughesc0f09332012-03-26 13:27:06 -0700550bool Dbg::IsDebuggerActive() {
Elliott Hughes3bb81562011-10-21 18:52:59 -0700551 return gDebuggerActive;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700552}
553
Elliott Hughesc0f09332012-03-26 13:27:06 -0700554bool Dbg::IsJdwpConfigured() {
Elliott Hughes3bb81562011-10-21 18:52:59 -0700555 return gJdwpConfigured;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700556}
557
558int64_t Dbg::LastDebuggerActivity() {
Elliott Hughesca951522011-12-05 12:01:32 -0800559 return gJdwpState->LastDebuggerActivity();
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700560}
561
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700562void Dbg::UndoDebuggerSuspensions() {
Elliott Hughes234ab152011-10-26 14:02:26 -0700563 Runtime::Current()->GetThreadList()->UndoDebuggerSuspensions();
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700564}
565
566void Dbg::Exit(int status) {
Elliott Hughes1bba14f2011-12-01 18:00:36 -0800567 exit(status); // This is all dalvik did.
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700568}
569
Elliott Hughesbfe487b2011-10-26 15:48:55 -0700570void Dbg::VisitRoots(Heap::RootVisitor* visitor, void* arg) {
571 if (gRegistry != NULL) {
572 gRegistry->VisitRoots(visitor, arg);
573 }
574}
575
Elliott Hughes88d63092013-01-09 09:55:54 -0800576std::string Dbg::GetClassName(JDWP::RefTypeId class_id) {
577 Object* o = gRegistry->Get<Object*>(class_id);
Elliott Hughes436e3722012-02-17 20:01:47 -0800578 if (o == NULL) {
579 return "NULL";
580 }
581 if (o == kInvalidObject) {
Elliott Hughes88d63092013-01-09 09:55:54 -0800582 return StringPrintf("invalid object %p", reinterpret_cast<void*>(class_id));
Elliott Hughes436e3722012-02-17 20:01:47 -0800583 }
584 if (!o->IsClass()) {
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800585 return StringPrintf("non-class %p", o); // This is only used for debugging output anyway.
586 }
Elliott Hughesc308a5d2012-02-16 17:12:06 -0800587 return DescriptorToName(ClassHelper(o->AsClass()).GetDescriptor());
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700588}
589
Elliott Hughes88d63092013-01-09 09:55:54 -0800590JDWP::JdwpError Dbg::GetClassObject(JDWP::RefTypeId id, JDWP::ObjectId& class_object_id) {
Elliott Hughes436e3722012-02-17 20:01:47 -0800591 JDWP::JdwpError status;
592 Class* c = DecodeClass(id, status);
593 if (c == NULL) {
594 return status;
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800595 }
Elliott Hughes88d63092013-01-09 09:55:54 -0800596 class_object_id = gRegistry->Add(c);
Elliott Hughes436e3722012-02-17 20:01:47 -0800597 return JDWP::ERR_NONE;
Elliott Hughes86964332012-02-15 19:37:42 -0800598}
599
Elliott Hughes88d63092013-01-09 09:55:54 -0800600JDWP::JdwpError Dbg::GetSuperclass(JDWP::RefTypeId id, JDWP::RefTypeId& superclass_id) {
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -0800601 JDWP::JdwpError status;
602 Class* c = DecodeClass(id, status);
603 if (c == NULL) {
604 return status;
605 }
606 if (c->IsInterface()) {
607 // http://code.google.com/p/android/issues/detail?id=20856
Elliott Hughes88d63092013-01-09 09:55:54 -0800608 superclass_id = 0;
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -0800609 } else {
Elliott Hughes88d63092013-01-09 09:55:54 -0800610 superclass_id = gRegistry->Add(c->GetSuperClass());
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -0800611 }
612 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700613}
614
Elliott Hughes436e3722012-02-17 20:01:47 -0800615JDWP::JdwpError Dbg::GetClassLoader(JDWP::RefTypeId id, JDWP::ExpandBuf* pReply) {
Elliott Hughes1bba14f2011-12-01 18:00:36 -0800616 Object* o = gRegistry->Get<Object*>(id);
Elliott Hughes436e3722012-02-17 20:01:47 -0800617 if (o == NULL || o == kInvalidObject) {
618 return JDWP::ERR_INVALID_OBJECT;
619 }
620 expandBufAddObjectId(pReply, gRegistry->Add(o->GetClass()->GetClassLoader()));
621 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700622}
623
Elliott Hughes436e3722012-02-17 20:01:47 -0800624JDWP::JdwpError Dbg::GetModifiers(JDWP::RefTypeId id, JDWP::ExpandBuf* pReply) {
625 JDWP::JdwpError status;
626 Class* c = DecodeClass(id, status);
627 if (c == NULL) {
628 return status;
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800629 }
Elliott Hughes436e3722012-02-17 20:01:47 -0800630
631 uint32_t access_flags = c->GetAccessFlags() & kAccJavaFlagsMask;
632
633 // Set ACC_SUPER; dex files don't contain this flag, but all classes are supposed to have it set.
634 // Class.getModifiers doesn't return it, but JDWP does, so we set it here.
635 access_flags |= kAccSuper;
636
637 expandBufAdd4BE(pReply, access_flags);
638
639 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700640}
641
Elliott Hughesf327e072013-01-09 16:01:26 -0800642JDWP::JdwpError Dbg::GetMonitorInfo(JDWP::ObjectId object_id, JDWP::ExpandBuf* reply)
643 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
644 Object* o = gRegistry->Get<Object*>(object_id);
645 if (o == NULL || o == kInvalidObject) {
646 return JDWP::ERR_INVALID_OBJECT;
647 }
648
649 // Ensure all threads are suspended while we read objects' lock words.
650 Thread* self = Thread::Current();
651 Locks::mutator_lock_->SharedUnlock(self);
652 Locks::mutator_lock_->ExclusiveLock(self);
653
654 MonitorInfo monitor_info(o);
655
656 Locks::mutator_lock_->ExclusiveUnlock(self);
657 Locks::mutator_lock_->SharedLock(self);
658
659 if (monitor_info.owner != NULL) {
660 expandBufAddObjectId(reply, gRegistry->Add(monitor_info.owner->GetPeer()));
661 } else {
662 expandBufAddObjectId(reply, gRegistry->Add(NULL));
663 }
664 expandBufAdd4BE(reply, monitor_info.entry_count);
665 expandBufAdd4BE(reply, monitor_info.waiters.size());
666 for (size_t i = 0; i < monitor_info.waiters.size(); ++i) {
667 expandBufAddObjectId(reply, gRegistry->Add(monitor_info.waiters[i]->GetPeer()));
668 }
669 return JDWP::ERR_NONE;
670}
671
Elliott Hughes734b8c62013-01-11 15:32:45 -0800672JDWP::JdwpError Dbg::GetOwnedMonitors(JDWP::ObjectId thread_id,
673 std::vector<JDWP::ObjectId>& monitors,
674 std::vector<uint32_t>& stack_depths)
Elliott Hughes4993bbc2013-01-10 15:41:25 -0800675 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
676 ScopedObjectAccessUnchecked soa(Thread::Current());
677 MutexLock mu(soa.Self(), *Locks::thread_list_lock_);
678 Thread* thread;
679 JDWP::JdwpError error = DecodeThread(soa, thread_id, thread);
680 if (error != JDWP::ERR_NONE) {
681 return error;
682 }
683 if (!IsSuspendedForDebugger(soa, thread)) {
684 return JDWP::ERR_THREAD_NOT_SUSPENDED;
685 }
686
687 struct OwnedMonitorVisitor : public StackVisitor {
688 OwnedMonitorVisitor(const ManagedStack* stack,
689 const std::deque<InstrumentationStackFrame>* instrumentation_stack)
690 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
Elliott Hughes734b8c62013-01-11 15:32:45 -0800691 : StackVisitor(stack, instrumentation_stack, NULL), current_stack_depth(0) {}
Elliott Hughes4993bbc2013-01-10 15:41:25 -0800692
693 // TODO: Enable annotalysis. We know lock is held in constructor, but abstraction confuses
694 // annotalysis.
695 bool VisitFrame() NO_THREAD_SAFETY_ANALYSIS {
696 if (!GetMethod()->IsRuntimeMethod()) {
697 Monitor::VisitLocks(this, AppendOwnedMonitors, this);
Elliott Hughes734b8c62013-01-11 15:32:45 -0800698 ++current_stack_depth;
Elliott Hughes4993bbc2013-01-10 15:41:25 -0800699 }
700 return true;
701 }
702
703 static void AppendOwnedMonitors(Object* owned_monitor, void* context) {
Elliott Hughes734b8c62013-01-11 15:32:45 -0800704 OwnedMonitorVisitor* visitor = reinterpret_cast<OwnedMonitorVisitor*>(context);
705 visitor->monitors.push_back(owned_monitor);
706 visitor->stack_depths.push_back(visitor->current_stack_depth);
Elliott Hughes4993bbc2013-01-10 15:41:25 -0800707 }
708
Elliott Hughes734b8c62013-01-11 15:32:45 -0800709 size_t current_stack_depth;
Elliott Hughes4993bbc2013-01-10 15:41:25 -0800710 std::vector<Object*> monitors;
Elliott Hughes734b8c62013-01-11 15:32:45 -0800711 std::vector<uint32_t> stack_depths;
Elliott Hughes4993bbc2013-01-10 15:41:25 -0800712 };
713 OwnedMonitorVisitor visitor(thread->GetManagedStack(), thread->GetInstrumentationStack());
714 visitor.WalkStack();
715
716 for (size_t i = 0; i < visitor.monitors.size(); ++i) {
717 monitors.push_back(gRegistry->Add(visitor.monitors[i]));
Elliott Hughes734b8c62013-01-11 15:32:45 -0800718 stack_depths.push_back(visitor.stack_depths[i]);
Elliott Hughes4993bbc2013-01-10 15:41:25 -0800719 }
720
721 return JDWP::ERR_NONE;
722}
723
Elliott Hughesf9501702013-01-11 11:22:27 -0800724JDWP::JdwpError Dbg::GetContendedMonitor(JDWP::ObjectId thread_id, JDWP::ObjectId& contended_monitor)
725 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
726 ScopedObjectAccessUnchecked soa(Thread::Current());
727 MutexLock mu(soa.Self(), *Locks::thread_list_lock_);
728 Thread* thread;
729 JDWP::JdwpError error = DecodeThread(soa, thread_id, thread);
730 if (error != JDWP::ERR_NONE) {
731 return error;
732 }
733 if (!IsSuspendedForDebugger(soa, thread)) {
734 return JDWP::ERR_THREAD_NOT_SUSPENDED;
735 }
736
737 contended_monitor = gRegistry->Add(Monitor::GetContendedMonitor(thread));
738
739 return JDWP::ERR_NONE;
740}
741
Elliott Hughesec0f83d2013-01-15 16:54:08 -0800742JDWP::JdwpError Dbg::GetInstanceCounts(const std::vector<JDWP::RefTypeId>& class_ids,
743 std::vector<uint64_t>& counts)
744 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
745
746 std::vector<Class*> classes;
747 counts.clear();
748 for (size_t i = 0; i < class_ids.size(); ++i) {
749 JDWP::JdwpError status;
750 Class* c = DecodeClass(class_ids[i], status);
751 if (c == NULL) {
752 return status;
753 }
754 classes.push_back(c);
755 counts.push_back(0);
756 }
757
758 Runtime::Current()->GetHeap()->CountInstances(classes, false, &counts[0]);
759 return JDWP::ERR_NONE;
760}
761
Elliott Hughes3b78c942013-01-15 17:35:41 -0800762JDWP::JdwpError Dbg::GetInstances(JDWP::RefTypeId class_id, int32_t max_count, std::vector<JDWP::ObjectId>& instances)
763 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
764 JDWP::JdwpError status;
765 Class* c = DecodeClass(class_id, status);
766 if (c == NULL) {
767 return status;
768 }
769
770 std::vector<Object*> raw_instances;
771 Runtime::Current()->GetHeap()->GetInstances(c, max_count, raw_instances);
772 for (size_t i = 0; i < raw_instances.size(); ++i) {
773 instances.push_back(gRegistry->Add(raw_instances[i]));
774 }
775 return JDWP::ERR_NONE;
776}
777
Elliott Hughes0cbaff52013-01-16 15:28:01 -0800778JDWP::JdwpError Dbg::GetReferringObjects(JDWP::ObjectId object_id, int32_t max_count,
779 std::vector<JDWP::ObjectId>& referring_objects)
780 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
781 Object* o = gRegistry->Get<Object*>(object_id);
782 if (o == NULL || o == kInvalidObject) {
783 return JDWP::ERR_INVALID_OBJECT;
784 }
785
786 std::vector<Object*> raw_instances;
787 Runtime::Current()->GetHeap()->GetReferringObjects(o, max_count, raw_instances);
788 for (size_t i = 0; i < raw_instances.size(); ++i) {
789 referring_objects.push_back(gRegistry->Add(raw_instances[i]));
790 }
791 return JDWP::ERR_NONE;
792}
793
Elliott Hughes88d63092013-01-09 09:55:54 -0800794JDWP::JdwpError Dbg::GetReflectedType(JDWP::RefTypeId class_id, JDWP::ExpandBuf* pReply) {
Elliott Hughes436e3722012-02-17 20:01:47 -0800795 JDWP::JdwpError status;
Elliott Hughes88d63092013-01-09 09:55:54 -0800796 Class* c = DecodeClass(class_id, status);
Elliott Hughes436e3722012-02-17 20:01:47 -0800797 if (c == NULL) {
798 return status;
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800799 }
Elliott Hughes436e3722012-02-17 20:01:47 -0800800
801 expandBufAdd1(pReply, c->IsInterface() ? JDWP::TT_INTERFACE : JDWP::TT_CLASS);
Elliott Hughes88d63092013-01-09 09:55:54 -0800802 expandBufAddRefTypeId(pReply, class_id);
Elliott Hughes436e3722012-02-17 20:01:47 -0800803 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700804}
805
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800806void Dbg::GetClassList(std::vector<JDWP::RefTypeId>& classes) {
Elliott Hughesa2155262011-11-16 16:26:58 -0800807 // Get the complete list of reference classes (i.e. all classes except
808 // the primitive types).
809 // Returns a newly-allocated buffer full of RefTypeId values.
810 struct ClassListCreator {
Elliott Hughesba8eee12012-01-24 20:25:24 -0800811 explicit ClassListCreator(std::vector<JDWP::RefTypeId>& classes) : classes(classes) {
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800812 }
813
Elliott Hughesa2155262011-11-16 16:26:58 -0800814 static bool Visit(Class* c, void* arg) {
815 return reinterpret_cast<ClassListCreator*>(arg)->Visit(c);
816 }
817
818 bool Visit(Class* c) {
819 if (!c->IsPrimitive()) {
820 classes.push_back(static_cast<JDWP::RefTypeId>(gRegistry->Add(c)));
821 }
822 return true;
823 }
824
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800825 std::vector<JDWP::RefTypeId>& classes;
Elliott Hughesa2155262011-11-16 16:26:58 -0800826 };
827
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800828 ClassListCreator clc(classes);
Elliott Hughesa2155262011-11-16 16:26:58 -0800829 Runtime::Current()->GetClassLinker()->VisitClasses(ClassListCreator::Visit, &clc);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700830}
831
Elliott Hughes88d63092013-01-09 09:55:54 -0800832JDWP::JdwpError Dbg::GetClassInfo(JDWP::RefTypeId class_id, JDWP::JdwpTypeTag* pTypeTag, uint32_t* pStatus, std::string* pDescriptor) {
Elliott Hughes436e3722012-02-17 20:01:47 -0800833 JDWP::JdwpError status;
Elliott Hughes88d63092013-01-09 09:55:54 -0800834 Class* c = DecodeClass(class_id, status);
Elliott Hughes436e3722012-02-17 20:01:47 -0800835 if (c == NULL) {
836 return status;
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800837 }
838
Elliott Hughesa2155262011-11-16 16:26:58 -0800839 if (c->IsArrayClass()) {
840 *pStatus = JDWP::CS_VERIFIED | JDWP::CS_PREPARED;
841 *pTypeTag = JDWP::TT_ARRAY;
842 } else {
843 if (c->IsErroneous()) {
844 *pStatus = JDWP::CS_ERROR;
845 } else {
846 *pStatus = JDWP::CS_VERIFIED | JDWP::CS_PREPARED | JDWP::CS_INITIALIZED;
847 }
848 *pTypeTag = c->IsInterface() ? JDWP::TT_INTERFACE : JDWP::TT_CLASS;
849 }
850
851 if (pDescriptor != NULL) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800852 *pDescriptor = ClassHelper(c).GetDescriptor();
Elliott Hughesa2155262011-11-16 16:26:58 -0800853 }
Elliott Hughes436e3722012-02-17 20:01:47 -0800854 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700855}
856
Elliott Hughesc3b77c72011-12-15 20:56:48 -0800857void Dbg::FindLoadedClassBySignature(const char* descriptor, std::vector<JDWP::RefTypeId>& ids) {
Elliott Hughes6fa602d2011-12-02 17:54:25 -0800858 std::vector<Class*> classes;
859 Runtime::Current()->GetClassLinker()->LookupClasses(descriptor, classes);
860 ids.clear();
861 for (size_t i = 0; i < classes.size(); ++i) {
862 ids.push_back(gRegistry->Add(classes[i]));
863 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700864}
865
Elliott Hughes88d63092013-01-09 09:55:54 -0800866JDWP::JdwpError Dbg::GetReferenceType(JDWP::ObjectId object_id, JDWP::ExpandBuf* pReply) {
867 Object* o = gRegistry->Get<Object*>(object_id);
Elliott Hughes436e3722012-02-17 20:01:47 -0800868 if (o == NULL || o == kInvalidObject) {
Elliott Hughes2435a572012-02-17 16:07:41 -0800869 return JDWP::ERR_INVALID_OBJECT;
Elliott Hughes499c5132011-11-17 14:55:11 -0800870 }
Elliott Hughes2435a572012-02-17 16:07:41 -0800871
872 JDWP::JdwpTypeTag type_tag;
873 if (o->GetClass()->IsArrayClass()) {
874 type_tag = JDWP::TT_ARRAY;
875 } else if (o->GetClass()->IsInterface()) {
876 type_tag = JDWP::TT_INTERFACE;
877 } else {
878 type_tag = JDWP::TT_CLASS;
879 }
880 JDWP::RefTypeId type_id = gRegistry->Add(o->GetClass());
881
882 expandBufAdd1(pReply, type_tag);
883 expandBufAddRefTypeId(pReply, type_id);
884
885 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700886}
887
Elliott Hughes88d63092013-01-09 09:55:54 -0800888JDWP::JdwpError Dbg::GetSignature(JDWP::RefTypeId class_id, std::string& signature) {
Elliott Hughes1fe7afb2012-02-13 17:23:03 -0800889 JDWP::JdwpError status;
Elliott Hughes88d63092013-01-09 09:55:54 -0800890 Class* c = DecodeClass(class_id, status);
Elliott Hughes1fe7afb2012-02-13 17:23:03 -0800891 if (c == NULL) {
892 return status;
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800893 }
Elliott Hughes1fe7afb2012-02-13 17:23:03 -0800894 signature = ClassHelper(c).GetDescriptor();
895 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700896}
897
Elliott Hughes88d63092013-01-09 09:55:54 -0800898JDWP::JdwpError Dbg::GetSourceFile(JDWP::RefTypeId class_id, std::string& result) {
Elliott Hughes436e3722012-02-17 20:01:47 -0800899 JDWP::JdwpError status;
Elliott Hughes88d63092013-01-09 09:55:54 -0800900 Class* c = DecodeClass(class_id, status);
Elliott Hughes436e3722012-02-17 20:01:47 -0800901 if (c == NULL) {
902 return status;
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800903 }
Elliott Hughes436e3722012-02-17 20:01:47 -0800904 result = ClassHelper(c).GetSourceFile();
905 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700906}
907
Elliott Hughes88d63092013-01-09 09:55:54 -0800908JDWP::JdwpError Dbg::GetObjectTag(JDWP::ObjectId object_id, uint8_t& tag) {
909 Object* o = gRegistry->Get<Object*>(object_id);
Elliott Hughes546b9862012-06-20 16:06:13 -0700910 if (o == kInvalidObject) {
911 return JDWP::ERR_INVALID_OBJECT;
912 }
913 tag = TagFromObject(o);
914 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700915}
916
Elliott Hughesaed4be92011-12-02 16:16:23 -0800917size_t Dbg::GetTagWidth(JDWP::JdwpTag tag) {
Elliott Hughesdbb40792011-11-18 17:05:22 -0800918 switch (tag) {
919 case JDWP::JT_VOID:
920 return 0;
921 case JDWP::JT_BYTE:
922 case JDWP::JT_BOOLEAN:
923 return 1;
924 case JDWP::JT_CHAR:
925 case JDWP::JT_SHORT:
926 return 2;
927 case JDWP::JT_FLOAT:
928 case JDWP::JT_INT:
929 return 4;
930 case JDWP::JT_ARRAY:
931 case JDWP::JT_OBJECT:
932 case JDWP::JT_STRING:
933 case JDWP::JT_THREAD:
934 case JDWP::JT_THREAD_GROUP:
935 case JDWP::JT_CLASS_LOADER:
936 case JDWP::JT_CLASS_OBJECT:
937 return sizeof(JDWP::ObjectId);
938 case JDWP::JT_DOUBLE:
939 case JDWP::JT_LONG:
940 return 8;
941 default:
Elliott Hughes3d30d9b2011-12-07 17:35:48 -0800942 LOG(FATAL) << "Unknown tag " << tag;
Elliott Hughesdbb40792011-11-18 17:05:22 -0800943 return -1;
944 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700945}
946
Elliott Hughes88d63092013-01-09 09:55:54 -0800947JDWP::JdwpError Dbg::GetArrayLength(JDWP::ObjectId array_id, int& length) {
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -0800948 JDWP::JdwpError status;
Elliott Hughes88d63092013-01-09 09:55:54 -0800949 Array* a = DecodeArray(array_id, status);
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -0800950 if (a == NULL) {
951 return status;
Elliott Hughes24437992011-11-30 14:49:33 -0800952 }
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -0800953 length = a->GetLength();
954 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700955}
956
Elliott Hughes88d63092013-01-09 09:55:54 -0800957JDWP::JdwpError Dbg::OutputArray(JDWP::ObjectId array_id, int offset, int count, JDWP::ExpandBuf* pReply) {
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -0800958 JDWP::JdwpError status;
Elliott Hughes88d63092013-01-09 09:55:54 -0800959 Array* a = DecodeArray(array_id, status);
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -0800960 if (a == NULL) {
961 return status;
962 }
Elliott Hughes24437992011-11-30 14:49:33 -0800963
964 if (offset < 0 || count < 0 || offset > a->GetLength() || a->GetLength() - offset < count) {
965 LOG(WARNING) << __FUNCTION__ << " access out of bounds: offset=" << offset << "; count=" << count;
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -0800966 return JDWP::ERR_INVALID_LENGTH;
Elliott Hughes24437992011-11-30 14:49:33 -0800967 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800968 std::string descriptor(ClassHelper(a->GetClass()).GetDescriptor());
Elliott Hughes24437992011-11-30 14:49:33 -0800969 JDWP::JdwpTag tag = BasicTagFromDescriptor(descriptor.c_str() + 1);
970
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -0800971 expandBufAdd1(pReply, tag);
972 expandBufAdd4BE(pReply, count);
973
Elliott Hughes24437992011-11-30 14:49:33 -0800974 if (IsPrimitiveTag(tag)) {
975 size_t width = GetTagWidth(tag);
Elliott Hughes24437992011-11-30 14:49:33 -0800976 uint8_t* dst = expandBufAddSpace(pReply, count * width);
977 if (width == 8) {
Ian Rogersa15e67d2012-02-28 13:51:55 -0800978 const uint64_t* src8 = reinterpret_cast<uint64_t*>(a->GetRawData(sizeof(uint64_t)));
Elliott Hughes24437992011-11-30 14:49:33 -0800979 for (int i = 0; i < count; ++i) JDWP::Write8BE(&dst, src8[offset + i]);
980 } else if (width == 4) {
Ian Rogersa15e67d2012-02-28 13:51:55 -0800981 const uint32_t* src4 = reinterpret_cast<uint32_t*>(a->GetRawData(sizeof(uint32_t)));
Elliott Hughes24437992011-11-30 14:49:33 -0800982 for (int i = 0; i < count; ++i) JDWP::Write4BE(&dst, src4[offset + i]);
983 } else if (width == 2) {
Ian Rogersa15e67d2012-02-28 13:51:55 -0800984 const uint16_t* src2 = reinterpret_cast<uint16_t*>(a->GetRawData(sizeof(uint16_t)));
Elliott Hughes24437992011-11-30 14:49:33 -0800985 for (int i = 0; i < count; ++i) JDWP::Write2BE(&dst, src2[offset + i]);
986 } else {
Ian Rogersa15e67d2012-02-28 13:51:55 -0800987 const uint8_t* src = reinterpret_cast<uint8_t*>(a->GetRawData(sizeof(uint8_t)));
Elliott Hughes24437992011-11-30 14:49:33 -0800988 memcpy(dst, &src[offset * width], count * width);
989 }
990 } else {
991 ObjectArray<Object>* oa = a->AsObjectArray<Object>();
992 for (int i = 0; i < count; ++i) {
Elliott Hughesf03b8f62011-12-02 14:26:25 -0800993 Object* element = oa->Get(offset + i);
Elliott Hughes24437992011-11-30 14:49:33 -0800994 JDWP::JdwpTag specific_tag = (element != NULL) ? TagFromObject(element) : tag;
995 expandBufAdd1(pReply, specific_tag);
996 expandBufAddObjectId(pReply, gRegistry->Add(element));
997 }
998 }
999
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -08001000 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001001}
1002
Elliott Hughes88d63092013-01-09 09:55:54 -08001003JDWP::JdwpError Dbg::SetArrayElements(JDWP::ObjectId array_id, int offset, int count,
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001004 const uint8_t* src)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001005 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -08001006 JDWP::JdwpError status;
Elliott Hughes88d63092013-01-09 09:55:54 -08001007 Array* a = DecodeArray(array_id, status);
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -08001008 if (a == NULL) {
1009 return status;
1010 }
Elliott Hughesf03b8f62011-12-02 14:26:25 -08001011
1012 if (offset < 0 || count < 0 || offset > a->GetLength() || a->GetLength() - offset < count) {
1013 LOG(WARNING) << __FUNCTION__ << " access out of bounds: offset=" << offset << "; count=" << count;
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -08001014 return JDWP::ERR_INVALID_LENGTH;
Elliott Hughesf03b8f62011-12-02 14:26:25 -08001015 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001016 std::string descriptor(ClassHelper(a->GetClass()).GetDescriptor());
Elliott Hughesf03b8f62011-12-02 14:26:25 -08001017 JDWP::JdwpTag tag = BasicTagFromDescriptor(descriptor.c_str() + 1);
1018
1019 if (IsPrimitiveTag(tag)) {
1020 size_t width = GetTagWidth(tag);
Elliott Hughesf03b8f62011-12-02 14:26:25 -08001021 if (width == 8) {
Ian Rogersa15e67d2012-02-28 13:51:55 -08001022 uint8_t* dst = &(reinterpret_cast<uint8_t*>(a->GetRawData(sizeof(uint64_t)))[offset * width]);
Elliott Hughesf03b8f62011-12-02 14:26:25 -08001023 for (int i = 0; i < count; ++i) {
1024 // Handle potentially non-aligned memory access one byte at a time for ARM's benefit.
1025 uint64_t value;
1026 for (size_t j = 0; j < sizeof(uint64_t); ++j) reinterpret_cast<uint8_t*>(&value)[j] = src[j];
1027 src += sizeof(uint64_t);
1028 JDWP::Write8BE(&dst, value);
1029 }
1030 } else if (width == 4) {
Ian Rogersa15e67d2012-02-28 13:51:55 -08001031 uint8_t* dst = &(reinterpret_cast<uint8_t*>(a->GetRawData(sizeof(uint32_t)))[offset * width]);
Elliott Hughesf03b8f62011-12-02 14:26:25 -08001032 const uint32_t* src4 = reinterpret_cast<const uint32_t*>(src);
1033 for (int i = 0; i < count; ++i) JDWP::Write4BE(&dst, src4[i]);
1034 } else if (width == 2) {
Ian Rogersa15e67d2012-02-28 13:51:55 -08001035 uint8_t* dst = &(reinterpret_cast<uint8_t*>(a->GetRawData(sizeof(uint16_t)))[offset * width]);
Elliott Hughesf03b8f62011-12-02 14:26:25 -08001036 const uint16_t* src2 = reinterpret_cast<const uint16_t*>(src);
1037 for (int i = 0; i < count; ++i) JDWP::Write2BE(&dst, src2[i]);
1038 } else {
Ian Rogersa15e67d2012-02-28 13:51:55 -08001039 uint8_t* dst = &(reinterpret_cast<uint8_t*>(a->GetRawData(sizeof(uint8_t)))[offset * width]);
Elliott Hughesf03b8f62011-12-02 14:26:25 -08001040 memcpy(&dst[offset * width], src, count * width);
1041 }
1042 } else {
1043 ObjectArray<Object>* oa = a->AsObjectArray<Object>();
1044 for (int i = 0; i < count; ++i) {
1045 JDWP::ObjectId id = JDWP::ReadObjectId(&src);
Elliott Hughes436e3722012-02-17 20:01:47 -08001046 Object* o = gRegistry->Get<Object*>(id);
1047 if (o == kInvalidObject) {
1048 return JDWP::ERR_INVALID_OBJECT;
1049 }
1050 oa->Set(offset + i, o);
Elliott Hughesf03b8f62011-12-02 14:26:25 -08001051 }
1052 }
1053
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -08001054 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001055}
1056
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -08001057JDWP::ObjectId Dbg::CreateString(const std::string& str) {
Ian Rogers50b35e22012-10-04 10:09:15 -07001058 return gRegistry->Add(String::AllocFromModifiedUtf8(Thread::Current(), str.c_str()));
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001059}
1060
Elliott Hughes88d63092013-01-09 09:55:54 -08001061JDWP::JdwpError Dbg::CreateObject(JDWP::RefTypeId class_id, JDWP::ObjectId& new_object) {
Elliott Hughes436e3722012-02-17 20:01:47 -08001062 JDWP::JdwpError status;
Elliott Hughes88d63092013-01-09 09:55:54 -08001063 Class* c = DecodeClass(class_id, status);
Elliott Hughes436e3722012-02-17 20:01:47 -08001064 if (c == NULL) {
1065 return status;
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -08001066 }
Ian Rogers50b35e22012-10-04 10:09:15 -07001067 new_object = gRegistry->Add(c->AllocObject(Thread::Current()));
Elliott Hughes436e3722012-02-17 20:01:47 -08001068 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001069}
1070
Elliott Hughesbf13d362011-12-08 15:51:37 -08001071/*
1072 * Used by Eclipse's "Display" view to evaluate "new byte[5]" to get "(byte[]) [0, 0, 0, 0, 0]".
1073 */
Elliott Hughes88d63092013-01-09 09:55:54 -08001074JDWP::JdwpError Dbg::CreateArrayObject(JDWP::RefTypeId array_class_id, uint32_t length,
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001075 JDWP::ObjectId& new_array) {
Elliott Hughes436e3722012-02-17 20:01:47 -08001076 JDWP::JdwpError status;
Elliott Hughes88d63092013-01-09 09:55:54 -08001077 Class* c = DecodeClass(array_class_id, status);
Elliott Hughes436e3722012-02-17 20:01:47 -08001078 if (c == NULL) {
1079 return status;
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -08001080 }
Ian Rogers50b35e22012-10-04 10:09:15 -07001081 new_array = gRegistry->Add(Array::Alloc(Thread::Current(), c, length));
Elliott Hughes436e3722012-02-17 20:01:47 -08001082 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001083}
1084
Elliott Hughes88d63092013-01-09 09:55:54 -08001085bool Dbg::MatchType(JDWP::RefTypeId instance_class_id, JDWP::RefTypeId class_id) {
Elliott Hughes436e3722012-02-17 20:01:47 -08001086 JDWP::JdwpError status;
Elliott Hughes88d63092013-01-09 09:55:54 -08001087 Class* c1 = DecodeClass(instance_class_id, status);
Elliott Hughesa656a0f2012-02-21 18:03:44 -08001088 CHECK(c1 != NULL);
Elliott Hughes88d63092013-01-09 09:55:54 -08001089 Class* c2 = DecodeClass(class_id, status);
Elliott Hughesa656a0f2012-02-21 18:03:44 -08001090 CHECK(c2 != NULL);
1091 return c1->IsAssignableFrom(c2);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001092}
1093
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001094static JDWP::FieldId ToFieldId(const Field* f)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001095 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughes03181a82011-11-17 17:22:21 -08001096#ifdef MOVING_GARBAGE_COLLECTOR
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001097 UNIMPLEMENTED(FATAL);
Elliott Hughes03181a82011-11-17 17:22:21 -08001098#else
1099 return static_cast<JDWP::FieldId>(reinterpret_cast<uintptr_t>(f));
1100#endif
1101}
1102
Mathieu Chartier66f19252012-09-18 08:57:04 -07001103static JDWP::MethodId ToMethodId(const AbstractMethod* m)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001104 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughes03181a82011-11-17 17:22:21 -08001105#ifdef MOVING_GARBAGE_COLLECTOR
1106 UNIMPLEMENTED(FATAL);
1107#else
1108 return static_cast<JDWP::MethodId>(reinterpret_cast<uintptr_t>(m));
1109#endif
1110}
1111
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001112static Field* FromFieldId(JDWP::FieldId fid)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001113 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughesaed4be92011-12-02 16:16:23 -08001114#ifdef MOVING_GARBAGE_COLLECTOR
1115 UNIMPLEMENTED(FATAL);
1116#else
1117 return reinterpret_cast<Field*>(static_cast<uintptr_t>(fid));
1118#endif
1119}
1120
Mathieu Chartier66f19252012-09-18 08:57:04 -07001121static AbstractMethod* FromMethodId(JDWP::MethodId mid)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001122 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughes03181a82011-11-17 17:22:21 -08001123#ifdef MOVING_GARBAGE_COLLECTOR
1124 UNIMPLEMENTED(FATAL);
1125#else
Mathieu Chartier66f19252012-09-18 08:57:04 -07001126 return reinterpret_cast<AbstractMethod*>(static_cast<uintptr_t>(mid));
Elliott Hughes03181a82011-11-17 17:22:21 -08001127#endif
1128}
1129
Mathieu Chartier66f19252012-09-18 08:57:04 -07001130static void SetLocation(JDWP::JdwpLocation& location, AbstractMethod* m, uint32_t dex_pc)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001131 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08001132 if (m == NULL) {
1133 memset(&location, 0, sizeof(location));
1134 } else {
1135 Class* c = m->GetDeclaringClass();
Elliott Hughes74847412012-06-20 18:10:21 -07001136 location.type_tag = c->IsInterface() ? JDWP::TT_INTERFACE : JDWP::TT_CLASS;
1137 location.class_id = gRegistry->Add(c);
1138 location.method_id = ToMethodId(m);
Ian Rogers0399dde2012-06-06 17:09:28 -07001139 location.dex_pc = dex_pc;
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08001140 }
Elliott Hughesd07986f2011-12-06 18:27:45 -08001141}
1142
Elliott Hughes88d63092013-01-09 09:55:54 -08001143std::string Dbg::GetMethodName(JDWP::RefTypeId, JDWP::MethodId method_id)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001144 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughes88d63092013-01-09 09:55:54 -08001145 AbstractMethod* m = FromMethodId(method_id);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001146 return MethodHelper(m).GetName();
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001147}
1148
Elliott Hughesa2e54f62011-11-17 13:01:30 -08001149/*
1150 * Augment the access flags for synthetic methods and fields by setting
1151 * the (as described by the spec) "0xf0000000 bit". Also, strip out any
1152 * flags not specified by the Java programming language.
1153 */
1154static uint32_t MangleAccessFlags(uint32_t accessFlags) {
1155 accessFlags &= kAccJavaFlagsMask;
1156 if ((accessFlags & kAccSynthetic) != 0) {
1157 accessFlags |= 0xf0000000;
1158 }
1159 return accessFlags;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001160}
1161
Elliott Hughesdbb40792011-11-18 17:05:22 -08001162static const uint16_t kEclipseWorkaroundSlot = 1000;
1163
1164/*
1165 * Eclipse appears to expect that the "this" reference is in slot zero.
1166 * If it's not, the "variables" display will show two copies of "this",
1167 * possibly because it gets "this" from SF.ThisObject and then displays
1168 * all locals with nonzero slot numbers.
1169 *
1170 * So, we remap the item in slot 0 to 1000, and remap "this" to zero. On
1171 * SF.GetValues / SF.SetValues we map them back.
Elliott Hughesc5b734a2011-12-01 17:20:58 -08001172 *
1173 * TODO: jdb uses the value to determine whether a variable is a local or an argument,
1174 * by checking whether it's less than the number of arguments. To make that work, we'd
1175 * have to "mangle" all the arguments to come first, not just the implicit argument 'this'.
Elliott Hughesdbb40792011-11-18 17:05:22 -08001176 */
1177static uint16_t MangleSlot(uint16_t slot, const char* name) {
1178 uint16_t newSlot = slot;
1179 if (strcmp(name, "this") == 0) {
1180 newSlot = 0;
1181 } else if (slot == 0) {
1182 newSlot = kEclipseWorkaroundSlot;
1183 }
1184 return newSlot;
1185}
1186
Mathieu Chartier66f19252012-09-18 08:57:04 -07001187static uint16_t DemangleSlot(uint16_t slot, AbstractMethod* m)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001188 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughesdbb40792011-11-18 17:05:22 -08001189 if (slot == kEclipseWorkaroundSlot) {
Elliott Hughes68fdbd02011-11-29 19:22:47 -08001190 return 0;
Elliott Hughesdbb40792011-11-18 17:05:22 -08001191 } else if (slot == 0) {
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08001192 const DexFile::CodeItem* code_item = MethodHelper(m).GetCodeItem();
Elliott Hughescaf76542012-06-28 16:08:22 -07001193 CHECK(code_item != NULL) << PrettyMethod(m);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001194 return code_item->registers_size_ - code_item->ins_size_;
Elliott Hughesdbb40792011-11-18 17:05:22 -08001195 }
Elliott Hughes68fdbd02011-11-29 19:22:47 -08001196 return slot;
Elliott Hughesdbb40792011-11-18 17:05:22 -08001197}
1198
Elliott Hughes88d63092013-01-09 09:55:54 -08001199JDWP::JdwpError Dbg::OutputDeclaredFields(JDWP::RefTypeId class_id, bool with_generic, JDWP::ExpandBuf* pReply) {
Elliott Hughes436e3722012-02-17 20:01:47 -08001200 JDWP::JdwpError status;
Elliott Hughes88d63092013-01-09 09:55:54 -08001201 Class* c = DecodeClass(class_id, status);
Elliott Hughes436e3722012-02-17 20:01:47 -08001202 if (c == NULL) {
1203 return status;
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -08001204 }
Elliott Hughesa2e54f62011-11-17 13:01:30 -08001205
1206 size_t instance_field_count = c->NumInstanceFields();
1207 size_t static_field_count = c->NumStaticFields();
1208
1209 expandBufAdd4BE(pReply, instance_field_count + static_field_count);
1210
1211 for (size_t i = 0; i < instance_field_count + static_field_count; ++i) {
1212 Field* f = (i < instance_field_count) ? c->GetInstanceField(i) : c->GetStaticField(i - instance_field_count);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001213 FieldHelper fh(f);
Elliott Hughesa2e54f62011-11-17 13:01:30 -08001214 expandBufAddFieldId(pReply, ToFieldId(f));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001215 expandBufAddUtf8String(pReply, fh.GetName());
1216 expandBufAddUtf8String(pReply, fh.GetTypeDescriptor());
Elliott Hughesc5b734a2011-12-01 17:20:58 -08001217 if (with_generic) {
Elliott Hughesa2e54f62011-11-17 13:01:30 -08001218 static const char genericSignature[1] = "";
1219 expandBufAddUtf8String(pReply, genericSignature);
1220 }
1221 expandBufAdd4BE(pReply, MangleAccessFlags(f->GetAccessFlags()));
1222 }
Elliott Hughes436e3722012-02-17 20:01:47 -08001223 return JDWP::ERR_NONE;
Elliott Hughesa2e54f62011-11-17 13:01:30 -08001224}
1225
Elliott Hughes88d63092013-01-09 09:55:54 -08001226JDWP::JdwpError Dbg::OutputDeclaredMethods(JDWP::RefTypeId class_id, bool with_generic,
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001227 JDWP::ExpandBuf* pReply) {
Elliott Hughes436e3722012-02-17 20:01:47 -08001228 JDWP::JdwpError status;
Elliott Hughes88d63092013-01-09 09:55:54 -08001229 Class* c = DecodeClass(class_id, status);
Elliott Hughes436e3722012-02-17 20:01:47 -08001230 if (c == NULL) {
1231 return status;
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -08001232 }
Elliott Hughesa2e54f62011-11-17 13:01:30 -08001233
1234 size_t direct_method_count = c->NumDirectMethods();
1235 size_t virtual_method_count = c->NumVirtualMethods();
1236
1237 expandBufAdd4BE(pReply, direct_method_count + virtual_method_count);
1238
1239 for (size_t i = 0; i < direct_method_count + virtual_method_count; ++i) {
Mathieu Chartier66f19252012-09-18 08:57:04 -07001240 AbstractMethod* m = (i < direct_method_count) ? c->GetDirectMethod(i) : c->GetVirtualMethod(i - direct_method_count);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001241 MethodHelper mh(m);
Elliott Hughesa2e54f62011-11-17 13:01:30 -08001242 expandBufAddMethodId(pReply, ToMethodId(m));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001243 expandBufAddUtf8String(pReply, mh.GetName());
Elliott Hughes4740cdf2011-12-07 14:07:12 -08001244 expandBufAddUtf8String(pReply, mh.GetSignature());
Elliott Hughesc5b734a2011-12-01 17:20:58 -08001245 if (with_generic) {
Elliott Hughesa2e54f62011-11-17 13:01:30 -08001246 static const char genericSignature[1] = "";
1247 expandBufAddUtf8String(pReply, genericSignature);
1248 }
1249 expandBufAdd4BE(pReply, MangleAccessFlags(m->GetAccessFlags()));
1250 }
Elliott Hughes436e3722012-02-17 20:01:47 -08001251 return JDWP::ERR_NONE;
Elliott Hughesa2e54f62011-11-17 13:01:30 -08001252}
1253
Elliott Hughes88d63092013-01-09 09:55:54 -08001254JDWP::JdwpError Dbg::OutputDeclaredInterfaces(JDWP::RefTypeId class_id, JDWP::ExpandBuf* pReply) {
Elliott Hughes436e3722012-02-17 20:01:47 -08001255 JDWP::JdwpError status;
Elliott Hughes88d63092013-01-09 09:55:54 -08001256 Class* c = DecodeClass(class_id, status);
Elliott Hughes436e3722012-02-17 20:01:47 -08001257 if (c == NULL) {
1258 return status;
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -08001259 }
Elliott Hughes436e3722012-02-17 20:01:47 -08001260
1261 ClassHelper kh(c);
Ian Rogersd24e2642012-06-06 21:21:43 -07001262 size_t interface_count = kh.NumDirectInterfaces();
Elliott Hughesa2e54f62011-11-17 13:01:30 -08001263 expandBufAdd4BE(pReply, interface_count);
1264 for (size_t i = 0; i < interface_count; ++i) {
Ian Rogersd24e2642012-06-06 21:21:43 -07001265 expandBufAddRefTypeId(pReply, gRegistry->Add(kh.GetDirectInterface(i)));
Elliott Hughesa2e54f62011-11-17 13:01:30 -08001266 }
Elliott Hughes436e3722012-02-17 20:01:47 -08001267 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001268}
1269
Elliott Hughes88d63092013-01-09 09:55:54 -08001270void Dbg::OutputLineTable(JDWP::RefTypeId, JDWP::MethodId method_id, JDWP::ExpandBuf* pReply)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001271 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughes03181a82011-11-17 17:22:21 -08001272 struct DebugCallbackContext {
1273 int numItems;
1274 JDWP::ExpandBuf* pReply;
1275
Elliott Hughes2435a572012-02-17 16:07:41 -08001276 static bool Callback(void* context, uint32_t address, uint32_t line_number) {
Elliott Hughes03181a82011-11-17 17:22:21 -08001277 DebugCallbackContext* pContext = reinterpret_cast<DebugCallbackContext*>(context);
1278 expandBufAdd8BE(pContext->pReply, address);
Elliott Hughes2435a572012-02-17 16:07:41 -08001279 expandBufAdd4BE(pContext->pReply, line_number);
Elliott Hughes03181a82011-11-17 17:22:21 -08001280 pContext->numItems++;
1281 return true;
1282 }
1283 };
Elliott Hughes88d63092013-01-09 09:55:54 -08001284 AbstractMethod* m = FromMethodId(method_id);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001285 MethodHelper mh(m);
Elliott Hughes03181a82011-11-17 17:22:21 -08001286 uint64_t start, end;
1287 if (m->IsNative()) {
1288 start = -1;
1289 end = -1;
1290 } else {
1291 start = 0;
jeffhao14f0db92012-12-14 17:50:42 -08001292 // Return the index of the last instruction
1293 end = mh.GetCodeItem()->insns_size_in_code_units_ - 1;
Elliott Hughes03181a82011-11-17 17:22:21 -08001294 }
1295
1296 expandBufAdd8BE(pReply, start);
1297 expandBufAdd8BE(pReply, end);
1298
1299 // Add numLines later
1300 size_t numLinesOffset = expandBufGetLength(pReply);
1301 expandBufAdd4BE(pReply, 0);
1302
1303 DebugCallbackContext context;
1304 context.numItems = 0;
1305 context.pReply = pReply;
1306
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001307 mh.GetDexFile().DecodeDebugInfo(mh.GetCodeItem(), m->IsStatic(), m->GetDexMethodIndex(),
1308 DebugCallbackContext::Callback, NULL, &context);
Elliott Hughes03181a82011-11-17 17:22:21 -08001309
1310 JDWP::Set4BE(expandBufGetBuffer(pReply) + numLinesOffset, context.numItems);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001311}
1312
Elliott Hughes88d63092013-01-09 09:55:54 -08001313void Dbg::OutputVariableTable(JDWP::RefTypeId, JDWP::MethodId method_id, bool with_generic, JDWP::ExpandBuf* pReply) {
Elliott Hughesdbb40792011-11-18 17:05:22 -08001314 struct DebugCallbackContext {
Elliott Hughesdbb40792011-11-18 17:05:22 -08001315 JDWP::ExpandBuf* pReply;
Elliott Hughesc5b734a2011-12-01 17:20:58 -08001316 size_t variable_count;
1317 bool with_generic;
Elliott Hughesdbb40792011-11-18 17:05:22 -08001318
Elliott Hughesc5b734a2011-12-01 17:20:58 -08001319 static void Callback(void* context, uint16_t slot, uint32_t startAddress, uint32_t endAddress, const char* name, const char* descriptor, const char* signature) {
Elliott Hughesdbb40792011-11-18 17:05:22 -08001320 DebugCallbackContext* pContext = reinterpret_cast<DebugCallbackContext*>(context);
1321
Elliott Hughesad3da692012-02-24 16:51:35 -08001322 VLOG(jdwp) << StringPrintf(" %2zd: %d(%d) '%s' '%s' '%s' actual slot=%d mangled slot=%d", pContext->variable_count, startAddress, endAddress - startAddress, name, descriptor, signature, slot, MangleSlot(slot, name));
Elliott Hughesdbb40792011-11-18 17:05:22 -08001323
Elliott Hughes68fdbd02011-11-29 19:22:47 -08001324 slot = MangleSlot(slot, name);
1325
Elliott Hughesdbb40792011-11-18 17:05:22 -08001326 expandBufAdd8BE(pContext->pReply, startAddress);
1327 expandBufAddUtf8String(pContext->pReply, name);
1328 expandBufAddUtf8String(pContext->pReply, descriptor);
Elliott Hughesc5b734a2011-12-01 17:20:58 -08001329 if (pContext->with_generic) {
Elliott Hughesdbb40792011-11-18 17:05:22 -08001330 expandBufAddUtf8String(pContext->pReply, signature);
1331 }
1332 expandBufAdd4BE(pContext->pReply, endAddress - startAddress);
1333 expandBufAdd4BE(pContext->pReply, slot);
1334
Elliott Hughesc5b734a2011-12-01 17:20:58 -08001335 ++pContext->variable_count;
Elliott Hughesdbb40792011-11-18 17:05:22 -08001336 }
1337 };
Elliott Hughes88d63092013-01-09 09:55:54 -08001338 AbstractMethod* m = FromMethodId(method_id);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001339 MethodHelper mh(m);
1340 const DexFile::CodeItem* code_item = mh.GetCodeItem();
Elliott Hughesdbb40792011-11-18 17:05:22 -08001341
Elliott Hughesc5b734a2011-12-01 17:20:58 -08001342 // arg_count considers doubles and longs to take 2 units.
1343 // variable_count considers everything to take 1 unit.
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001344 std::string shorty(mh.GetShorty());
Ian Rogers2fa6b2e2012-10-17 00:10:17 -07001345 expandBufAdd4BE(pReply, AbstractMethod::NumArgRegisters(shorty));
Elliott Hughesdbb40792011-11-18 17:05:22 -08001346
Elliott Hughesc5b734a2011-12-01 17:20:58 -08001347 // We don't know the total number of variables yet, so leave a blank and update it later.
1348 size_t variable_count_offset = expandBufGetLength(pReply);
Elliott Hughesdbb40792011-11-18 17:05:22 -08001349 expandBufAdd4BE(pReply, 0);
1350
1351 DebugCallbackContext context;
Elliott Hughesdbb40792011-11-18 17:05:22 -08001352 context.pReply = pReply;
Elliott Hughesc5b734a2011-12-01 17:20:58 -08001353 context.variable_count = 0;
1354 context.with_generic = with_generic;
Elliott Hughesdbb40792011-11-18 17:05:22 -08001355
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001356 mh.GetDexFile().DecodeDebugInfo(code_item, m->IsStatic(), m->GetDexMethodIndex(), NULL,
1357 DebugCallbackContext::Callback, &context);
Elliott Hughesdbb40792011-11-18 17:05:22 -08001358
Elliott Hughesc5b734a2011-12-01 17:20:58 -08001359 JDWP::Set4BE(expandBufGetBuffer(pReply) + variable_count_offset, context.variable_count);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001360}
1361
Elliott Hughes88d63092013-01-09 09:55:54 -08001362JDWP::JdwpTag Dbg::GetFieldBasicTag(JDWP::FieldId field_id) {
1363 return BasicTagFromDescriptor(FieldHelper(FromFieldId(field_id)).GetTypeDescriptor());
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001364}
1365
Elliott Hughes88d63092013-01-09 09:55:54 -08001366JDWP::JdwpTag Dbg::GetStaticFieldBasicTag(JDWP::FieldId field_id) {
1367 return BasicTagFromDescriptor(FieldHelper(FromFieldId(field_id)).GetTypeDescriptor());
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001368}
1369
Elliott Hughes88d63092013-01-09 09:55:54 -08001370static JDWP::JdwpError GetFieldValueImpl(JDWP::RefTypeId ref_type_id, JDWP::ObjectId object_id,
1371 JDWP::FieldId field_id, JDWP::ExpandBuf* pReply,
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001372 bool is_static)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001373 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughes0cf74332012-02-23 23:14:00 -08001374 JDWP::JdwpError status;
Elliott Hughes88d63092013-01-09 09:55:54 -08001375 Class* c = DecodeClass(ref_type_id, status);
1376 if (ref_type_id != 0 && c == NULL) {
Elliott Hughes0cf74332012-02-23 23:14:00 -08001377 return status;
1378 }
1379
Elliott Hughes88d63092013-01-09 09:55:54 -08001380 Object* o = gRegistry->Get<Object*>(object_id);
Elliott Hughes3f4d58f2012-02-18 20:05:37 -08001381 if ((!is_static && o == NULL) || o == kInvalidObject) {
1382 return JDWP::ERR_INVALID_OBJECT;
1383 }
Elliott Hughes88d63092013-01-09 09:55:54 -08001384 Field* f = FromFieldId(field_id);
Elliott Hughes0cf74332012-02-23 23:14:00 -08001385
1386 Class* receiver_class = c;
1387 if (receiver_class == NULL && o != NULL) {
1388 receiver_class = o->GetClass();
1389 }
1390 // TODO: should we give up now if receiver_class is NULL?
1391 if (receiver_class != NULL && !f->GetDeclaringClass()->IsAssignableFrom(receiver_class)) {
1392 LOG(INFO) << "ERR_INVALID_FIELDID: " << PrettyField(f) << " " << PrettyClass(receiver_class);
Elliott Hughes3f4d58f2012-02-18 20:05:37 -08001393 return JDWP::ERR_INVALID_FIELDID;
1394 }
Elliott Hughesaed4be92011-12-02 16:16:23 -08001395
Elliott Hughes0cf74332012-02-23 23:14:00 -08001396 // The RI only enforces the static/non-static mismatch in one direction.
1397 // TODO: should we change the tests and check both?
1398 if (is_static) {
1399 if (!f->IsStatic()) {
1400 return JDWP::ERR_INVALID_FIELDID;
1401 }
1402 } else {
1403 if (f->IsStatic()) {
1404 LOG(WARNING) << "Ignoring non-NULL receiver for ObjectReference.SetValues on static field " << PrettyField(f);
Elliott Hughes0cf74332012-02-23 23:14:00 -08001405 }
1406 }
jeffhao0dfbb7e2012-11-28 15:26:03 -08001407 if (f->IsStatic()) {
1408 o = f->GetDeclaringClass();
1409 }
Elliott Hughes0cf74332012-02-23 23:14:00 -08001410
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001411 JDWP::JdwpTag tag = BasicTagFromDescriptor(FieldHelper(f).GetTypeDescriptor());
Elliott Hughesaed4be92011-12-02 16:16:23 -08001412
1413 if (IsPrimitiveTag(tag)) {
1414 expandBufAdd1(pReply, tag);
1415 if (tag == JDWP::JT_BOOLEAN || tag == JDWP::JT_BYTE) {
1416 expandBufAdd1(pReply, f->Get32(o));
1417 } else if (tag == JDWP::JT_CHAR || tag == JDWP::JT_SHORT) {
1418 expandBufAdd2BE(pReply, f->Get32(o));
1419 } else if (tag == JDWP::JT_FLOAT || tag == JDWP::JT_INT) {
1420 expandBufAdd4BE(pReply, f->Get32(o));
1421 } else if (tag == JDWP::JT_DOUBLE || tag == JDWP::JT_LONG) {
1422 expandBufAdd8BE(pReply, f->Get64(o));
1423 } else {
Elliott Hughes3d30d9b2011-12-07 17:35:48 -08001424 LOG(FATAL) << "Unknown tag: " << tag;
Elliott Hughesaed4be92011-12-02 16:16:23 -08001425 }
1426 } else {
1427 Object* value = f->GetObject(o);
1428 expandBufAdd1(pReply, TagFromObject(value));
1429 expandBufAddObjectId(pReply, gRegistry->Add(value));
1430 }
Elliott Hughes3f4d58f2012-02-18 20:05:37 -08001431 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001432}
1433
Elliott Hughes88d63092013-01-09 09:55:54 -08001434JDWP::JdwpError Dbg::GetFieldValue(JDWP::ObjectId object_id, JDWP::FieldId field_id,
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001435 JDWP::ExpandBuf* pReply) {
Elliott Hughes88d63092013-01-09 09:55:54 -08001436 return GetFieldValueImpl(0, object_id, field_id, pReply, false);
Elliott Hughes3f4d58f2012-02-18 20:05:37 -08001437}
1438
Elliott Hughes88d63092013-01-09 09:55:54 -08001439JDWP::JdwpError Dbg::GetStaticFieldValue(JDWP::RefTypeId ref_type_id, JDWP::FieldId field_id, JDWP::ExpandBuf* pReply) {
1440 return GetFieldValueImpl(ref_type_id, 0, field_id, pReply, true);
Elliott Hughes3f4d58f2012-02-18 20:05:37 -08001441}
1442
Elliott Hughes88d63092013-01-09 09:55:54 -08001443static JDWP::JdwpError SetFieldValueImpl(JDWP::ObjectId object_id, JDWP::FieldId field_id,
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001444 uint64_t value, int width, bool is_static)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001445 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughes88d63092013-01-09 09:55:54 -08001446 Object* o = gRegistry->Get<Object*>(object_id);
Elliott Hughes3f4d58f2012-02-18 20:05:37 -08001447 if ((!is_static && o == NULL) || o == kInvalidObject) {
1448 return JDWP::ERR_INVALID_OBJECT;
1449 }
Elliott Hughes88d63092013-01-09 09:55:54 -08001450 Field* f = FromFieldId(field_id);
Elliott Hughes0cf74332012-02-23 23:14:00 -08001451
1452 // The RI only enforces the static/non-static mismatch in one direction.
1453 // TODO: should we change the tests and check both?
1454 if (is_static) {
1455 if (!f->IsStatic()) {
1456 return JDWP::ERR_INVALID_FIELDID;
1457 }
1458 } else {
1459 if (f->IsStatic()) {
1460 LOG(WARNING) << "Ignoring non-NULL receiver for ObjectReference.SetValues on static field " << PrettyField(f);
Elliott Hughes0cf74332012-02-23 23:14:00 -08001461 }
Elliott Hughes3f4d58f2012-02-18 20:05:37 -08001462 }
jeffhao0dfbb7e2012-11-28 15:26:03 -08001463 if (f->IsStatic()) {
1464 o = f->GetDeclaringClass();
1465 }
Elliott Hughesaed4be92011-12-02 16:16:23 -08001466
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001467 JDWP::JdwpTag tag = BasicTagFromDescriptor(FieldHelper(f).GetTypeDescriptor());
Elliott Hughesaed4be92011-12-02 16:16:23 -08001468
1469 if (IsPrimitiveTag(tag)) {
1470 if (tag == JDWP::JT_DOUBLE || tag == JDWP::JT_LONG) {
Elliott Hughes1bac54f2012-03-16 12:48:31 -07001471 CHECK_EQ(width, 8);
Elliott Hughesaed4be92011-12-02 16:16:23 -08001472 f->Set64(o, value);
1473 } else {
Elliott Hughes1bac54f2012-03-16 12:48:31 -07001474 CHECK_LE(width, 4);
Elliott Hughesaed4be92011-12-02 16:16:23 -08001475 f->Set32(o, value);
1476 }
1477 } else {
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -08001478 Object* v = gRegistry->Get<Object*>(value);
Elliott Hughes3f4d58f2012-02-18 20:05:37 -08001479 if (v == kInvalidObject) {
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -08001480 return JDWP::ERR_INVALID_OBJECT;
1481 }
Elliott Hughes3f4d58f2012-02-18 20:05:37 -08001482 if (v != NULL) {
1483 Class* field_type = FieldHelper(f).GetType();
1484 if (!field_type->IsAssignableFrom(v->GetClass())) {
1485 return JDWP::ERR_INVALID_OBJECT;
1486 }
1487 }
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -08001488 f->SetObject(o, v);
Elliott Hughesaed4be92011-12-02 16:16:23 -08001489 }
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -08001490
1491 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001492}
1493
Elliott Hughes88d63092013-01-09 09:55:54 -08001494JDWP::JdwpError Dbg::SetFieldValue(JDWP::ObjectId object_id, JDWP::FieldId field_id, uint64_t value,
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001495 int width) {
Elliott Hughes88d63092013-01-09 09:55:54 -08001496 return SetFieldValueImpl(object_id, field_id, value, width, false);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001497}
1498
Elliott Hughes88d63092013-01-09 09:55:54 -08001499JDWP::JdwpError Dbg::SetStaticFieldValue(JDWP::FieldId field_id, uint64_t value, int width) {
1500 return SetFieldValueImpl(0, field_id, value, width, true);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001501}
1502
Elliott Hughes88d63092013-01-09 09:55:54 -08001503std::string Dbg::StringToUtf8(JDWP::ObjectId string_id) {
1504 String* s = gRegistry->Get<String*>(string_id);
Elliott Hughes68fdbd02011-11-29 19:22:47 -08001505 return s->ToModifiedUtf8();
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001506}
1507
Elliott Hughes221229c2013-01-08 18:17:50 -08001508JDWP::JdwpError Dbg::GetThreadName(JDWP::ObjectId thread_id, std::string& name) {
jeffhaoa77f0f62012-12-05 17:19:31 -08001509 ScopedObjectAccessUnchecked soa(Thread::Current());
1510 MutexLock mu(soa.Self(), *Locks::thread_list_lock_);
Elliott Hughes221229c2013-01-08 18:17:50 -08001511 Thread* thread;
1512 JDWP::JdwpError error = DecodeThread(soa, thread_id, thread);
1513 if (error != JDWP::ERR_NONE && error != JDWP::ERR_THREAD_NOT_ALIVE) {
1514 return error;
Elliott Hughesa2e54f62011-11-17 13:01:30 -08001515 }
Elliott Hughes221229c2013-01-08 18:17:50 -08001516
1517 // We still need to report the zombie threads' names, so we can't just call Thread::GetThreadName.
1518 Object* thread_object = gRegistry->Get<Object*>(thread_id);
1519 Field* java_lang_Thread_name_field = soa.DecodeField(WellKnownClasses::java_lang_Thread_name);
1520 String* s = reinterpret_cast<String*>(java_lang_Thread_name_field->GetObject(thread_object));
1521 if (s != NULL) {
1522 name = s->ToModifiedUtf8();
1523 }
1524 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001525}
1526
Elliott Hughes221229c2013-01-08 18:17:50 -08001527JDWP::JdwpError Dbg::GetThreadGroup(JDWP::ObjectId thread_id, JDWP::ExpandBuf* pReply) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001528 ScopedObjectAccess soa(Thread::Current());
Elliott Hughes221229c2013-01-08 18:17:50 -08001529 Object* thread_object = gRegistry->Get<Object*>(thread_id);
1530 if (thread_object == kInvalidObject) {
Elliott Hughes2435a572012-02-17 16:07:41 -08001531 return JDWP::ERR_INVALID_OBJECT;
1532 }
1533
1534 // Okay, so it's an object, but is it actually a thread?
Ian Rogers50b35e22012-10-04 10:09:15 -07001535 MutexLock mu(soa.Self(), *Locks::thread_list_lock_);
Elliott Hughes221229c2013-01-08 18:17:50 -08001536 Thread* thread;
1537 JDWP::JdwpError error = DecodeThread(soa, thread_id, thread);
1538 if (error == JDWP::ERR_THREAD_NOT_ALIVE) {
1539 // Zombie threads are in the null group.
1540 expandBufAddObjectId(pReply, JDWP::ObjectId(0));
1541 return JDWP::ERR_NONE;
1542 }
1543 if (error != JDWP::ERR_NONE) {
1544 return error;
Elliott Hughes2435a572012-02-17 16:07:41 -08001545 }
Elliott Hughes499c5132011-11-17 14:55:11 -08001546
1547 Class* c = Runtime::Current()->GetClassLinker()->FindSystemClass("Ljava/lang/Thread;");
1548 CHECK(c != NULL);
1549 Field* f = c->FindInstanceField("group", "Ljava/lang/ThreadGroup;");
1550 CHECK(f != NULL);
Elliott Hughes221229c2013-01-08 18:17:50 -08001551 Object* group = f->GetObject(thread_object);
Elliott Hughes499c5132011-11-17 14:55:11 -08001552 CHECK(group != NULL);
Elliott Hughes2435a572012-02-17 16:07:41 -08001553 JDWP::ObjectId thread_group_id = gRegistry->Add(group);
1554
1555 expandBufAddObjectId(pReply, thread_group_id);
1556 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001557}
1558
Elliott Hughes88d63092013-01-09 09:55:54 -08001559std::string Dbg::GetThreadGroupName(JDWP::ObjectId thread_group_id) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001560 ScopedObjectAccess soa(Thread::Current());
Elliott Hughes88d63092013-01-09 09:55:54 -08001561 Object* thread_group = gRegistry->Get<Object*>(thread_group_id);
Elliott Hughes499c5132011-11-17 14:55:11 -08001562 CHECK(thread_group != NULL);
1563
1564 Class* c = Runtime::Current()->GetClassLinker()->FindSystemClass("Ljava/lang/ThreadGroup;");
1565 CHECK(c != NULL);
1566 Field* f = c->FindInstanceField("name", "Ljava/lang/String;");
1567 CHECK(f != NULL);
1568 String* s = reinterpret_cast<String*>(f->GetObject(thread_group));
1569 return s->ToModifiedUtf8();
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001570}
1571
Elliott Hughes88d63092013-01-09 09:55:54 -08001572JDWP::ObjectId Dbg::GetThreadGroupParent(JDWP::ObjectId thread_group_id) {
1573 Object* thread_group = gRegistry->Get<Object*>(thread_group_id);
Elliott Hughes4e235312011-12-02 11:34:15 -08001574 CHECK(thread_group != NULL);
1575
1576 Class* c = Runtime::Current()->GetClassLinker()->FindSystemClass("Ljava/lang/ThreadGroup;");
1577 CHECK(c != NULL);
1578 Field* f = c->FindInstanceField("parent", "Ljava/lang/ThreadGroup;");
1579 CHECK(f != NULL);
1580 Object* parent = f->GetObject(thread_group);
1581 return gRegistry->Add(parent);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001582}
1583
1584JDWP::ObjectId Dbg::GetSystemThreadGroupId() {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001585 ScopedObjectAccessUnchecked soa(Thread::Current());
jeffhao0dfbb7e2012-11-28 15:26:03 -08001586 Field* f = soa.DecodeField(WellKnownClasses::java_lang_ThreadGroup_systemThreadGroup);
1587 Object* group = f->GetObject(f->GetDeclaringClass());
Ian Rogers365c1022012-06-22 15:05:28 -07001588 return gRegistry->Add(group);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001589}
1590
1591JDWP::ObjectId Dbg::GetMainThreadGroupId() {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001592 ScopedObjectAccess soa(Thread::Current());
jeffhao0dfbb7e2012-11-28 15:26:03 -08001593 Field* f = soa.DecodeField(WellKnownClasses::java_lang_ThreadGroup_mainThreadGroup);
1594 Object* group = f->GetObject(f->GetDeclaringClass());
Ian Rogers365c1022012-06-22 15:05:28 -07001595 return gRegistry->Add(group);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001596}
1597
Elliott Hughes221229c2013-01-08 18:17:50 -08001598JDWP::JdwpError Dbg::GetThreadStatus(JDWP::ObjectId thread_id, JDWP::JdwpThreadStatus* pThreadStatus, JDWP::JdwpSuspendStatus* pSuspendStatus) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001599 ScopedObjectAccess soa(Thread::Current());
Elliott Hughes499c5132011-11-17 14:55:11 -08001600
Elliott Hughes9e0c1752013-01-09 14:02:58 -08001601 *pSuspendStatus = JDWP::SUSPEND_STATUS_NOT_SUSPENDED;
1602
Ian Rogers50b35e22012-10-04 10:09:15 -07001603 MutexLock mu(soa.Self(), *Locks::thread_list_lock_);
Elliott Hughes221229c2013-01-08 18:17:50 -08001604 Thread* thread;
1605 JDWP::JdwpError error = DecodeThread(soa, thread_id, thread);
1606 if (error != JDWP::ERR_NONE) {
1607 if (error == JDWP::ERR_THREAD_NOT_ALIVE) {
1608 *pThreadStatus = JDWP::TS_ZOMBIE;
Elliott Hughes221229c2013-01-08 18:17:50 -08001609 return JDWP::ERR_NONE;
1610 }
1611 return error;
Elliott Hughes499c5132011-11-17 14:55:11 -08001612 }
1613
Elliott Hughes9e0c1752013-01-09 14:02:58 -08001614 if (IsSuspendedForDebugger(soa, thread)) {
1615 *pSuspendStatus = JDWP::SUSPEND_STATUS_SUSPENDED;
Elliott Hughes499c5132011-11-17 14:55:11 -08001616 }
1617
Elliott Hughes9e0c1752013-01-09 14:02:58 -08001618 switch (thread->GetState()) {
1619 case kBlocked: *pThreadStatus = JDWP::TS_MONITOR; break;
1620 case kNative: *pThreadStatus = JDWP::TS_RUNNING; break;
1621 case kRunnable: *pThreadStatus = JDWP::TS_RUNNING; break;
1622 case kSleeping: *pThreadStatus = JDWP::TS_SLEEPING; break;
1623 case kStarting: *pThreadStatus = JDWP::TS_ZOMBIE; break;
1624 case kSuspended: *pThreadStatus = JDWP::TS_RUNNING; break;
1625 case kTerminated: *pThreadStatus = JDWP::TS_ZOMBIE; break;
1626 case kTimedWaiting: *pThreadStatus = JDWP::TS_WAIT; break;
1627 case kWaitingForDebuggerSend: *pThreadStatus = JDWP::TS_WAIT; break;
1628 case kWaitingForDebuggerSuspension: *pThreadStatus = JDWP::TS_WAIT; break;
1629 case kWaitingForDebuggerToAttach: *pThreadStatus = JDWP::TS_WAIT; break;
1630 case kWaitingForGcToComplete: *pThreadStatus = JDWP::TS_WAIT; break;
1631 case kWaitingForJniOnLoad: *pThreadStatus = JDWP::TS_WAIT; break;
1632 case kWaitingForSignalCatcherOutput: *pThreadStatus = JDWP::TS_WAIT; break;
1633 case kWaitingInMainDebuggerLoop: *pThreadStatus = JDWP::TS_WAIT; break;
1634 case kWaitingInMainSignalCatcherLoop: *pThreadStatus = JDWP::TS_WAIT; break;
1635 case kWaitingPerformingGc: *pThreadStatus = JDWP::TS_WAIT; break;
1636 case kWaiting: *pThreadStatus = JDWP::TS_WAIT; break;
1637 // Don't add a 'default' here so the compiler can spot incompatible enum changes.
1638 }
Elliott Hughes221229c2013-01-08 18:17:50 -08001639 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001640}
1641
Elliott Hughes221229c2013-01-08 18:17:50 -08001642JDWP::JdwpError Dbg::GetThreadDebugSuspendCount(JDWP::ObjectId thread_id, JDWP::ExpandBuf* pReply) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001643 ScopedObjectAccess soa(Thread::Current());
Ian Rogers50b35e22012-10-04 10:09:15 -07001644 MutexLock mu(soa.Self(), *Locks::thread_list_lock_);
Elliott Hughes221229c2013-01-08 18:17:50 -08001645 Thread* thread;
1646 JDWP::JdwpError error = DecodeThread(soa, thread_id, thread);
1647 if (error != JDWP::ERR_NONE) {
1648 return error;
Elliott Hughes2435a572012-02-17 16:07:41 -08001649 }
Ian Rogers50b35e22012-10-04 10:09:15 -07001650 MutexLock mu2(soa.Self(), *Locks::thread_suspend_count_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001651 expandBufAdd4BE(pReply, thread->GetDebugSuspendCount());
Elliott Hughes2435a572012-02-17 16:07:41 -08001652 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001653}
1654
Elliott Hughesf9501702013-01-11 11:22:27 -08001655JDWP::JdwpError Dbg::Interrupt(JDWP::ObjectId thread_id) {
1656 ScopedObjectAccess soa(Thread::Current());
1657 MutexLock mu(soa.Self(), *Locks::thread_list_lock_);
1658 Thread* thread;
1659 JDWP::JdwpError error = DecodeThread(soa, thread_id, thread);
1660 if (error != JDWP::ERR_NONE) {
1661 return error;
1662 }
1663 thread->Interrupt();
1664 return JDWP::ERR_NONE;
1665}
1666
Elliott Hughescaf76542012-06-28 16:08:22 -07001667void Dbg::GetThreads(JDWP::ObjectId thread_group_id, std::vector<JDWP::ObjectId>& thread_ids) {
Ian Rogers365c1022012-06-22 15:05:28 -07001668 class ThreadListVisitor {
1669 public:
jeffhao0dfbb7e2012-11-28 15:26:03 -08001670 ThreadListVisitor(const ScopedObjectAccessUnchecked& soa, Object* desired_thread_group,
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001671 std::vector<JDWP::ObjectId>& thread_ids)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001672 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
jeffhao0dfbb7e2012-11-28 15:26:03 -08001673 : soa_(soa), desired_thread_group_(desired_thread_group), thread_ids_(thread_ids) {}
Ian Rogers365c1022012-06-22 15:05:28 -07001674
Elliott Hughesa2155262011-11-16 16:26:58 -08001675 static void Visit(Thread* t, void* arg) {
1676 reinterpret_cast<ThreadListVisitor*>(arg)->Visit(t);
1677 }
1678
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001679 // TODO: Enable annotalysis. We know lock is held in constructor, but abstraction confuses
1680 // annotalysis.
1681 void Visit(Thread* t) NO_THREAD_SAFETY_ANALYSIS {
Elliott Hughesa2155262011-11-16 16:26:58 -08001682 if (t == Dbg::GetDebugThread()) {
1683 // Skip the JDWP thread. Some debuggers get bent out of shape when they can't suspend and
1684 // query all threads, so it's easier if we just don't tell them about this thread.
1685 return;
1686 }
Ian Rogerscfaa4552012-11-26 21:00:08 -08001687 Object* peer = t->GetPeer();
jeffhao0dfbb7e2012-11-28 15:26:03 -08001688 if (IsInDesiredThreadGroup(peer)) {
Ian Rogers120f1c72012-09-28 17:17:10 -07001689 thread_ids_.push_back(gRegistry->Add(peer));
Elliott Hughesa2155262011-11-16 16:26:58 -08001690 }
1691 }
1692
Ian Rogers365c1022012-06-22 15:05:28 -07001693 private:
jeffhao0dfbb7e2012-11-28 15:26:03 -08001694 bool IsInDesiredThreadGroup(Object* peer)
1695 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
jeffhao0dfbb7e2012-11-28 15:26:03 -08001696 // peer might be NULL if the thread is still starting up.
1697 if (peer == NULL) {
1698 // We can't tell the debugger about this thread yet.
1699 // TODO: if we identified threads to the debugger by their Thread*
1700 // rather than their peer's Object*, we could fix this.
1701 // Doing so might help us report ZOMBIE threads too.
1702 return false;
1703 }
jeffhaoc1e04902012-12-13 12:41:10 -08001704 // Do we want threads from all thread groups?
1705 if (desired_thread_group_ == NULL) {
1706 return true;
1707 }
jeffhao0dfbb7e2012-11-28 15:26:03 -08001708 Object* group = soa_.DecodeField(WellKnownClasses::java_lang_Thread_group)->GetObject(peer);
1709 return (group == desired_thread_group_);
1710 }
1711
Mathieu Chartierdbe6f462012-09-25 16:54:50 -07001712 const ScopedObjectAccessUnchecked& soa_;
jeffhao0dfbb7e2012-11-28 15:26:03 -08001713 Object* const desired_thread_group_;
Elliott Hughescaf76542012-06-28 16:08:22 -07001714 std::vector<JDWP::ObjectId>& thread_ids_;
Elliott Hughesa2155262011-11-16 16:26:58 -08001715 };
1716
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001717 ScopedObjectAccessUnchecked soa(Thread::Current());
Elliott Hughescaf76542012-06-28 16:08:22 -07001718 Object* thread_group = gRegistry->Get<Object*>(thread_group_id);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001719 ThreadListVisitor tlv(soa, thread_group, thread_ids);
Ian Rogers50b35e22012-10-04 10:09:15 -07001720 MutexLock mu(soa.Self(), *Locks::thread_list_lock_);
Elliott Hughesf8349362012-06-18 15:00:06 -07001721 Runtime::Current()->GetThreadList()->ForEach(ThreadListVisitor::Visit, &tlv);
Elliott Hughescaf76542012-06-28 16:08:22 -07001722}
Elliott Hughesa2155262011-11-16 16:26:58 -08001723
Elliott Hughescaf76542012-06-28 16:08:22 -07001724void Dbg::GetChildThreadGroups(JDWP::ObjectId thread_group_id, std::vector<JDWP::ObjectId>& child_thread_group_ids) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001725 ScopedObjectAccess soa(Thread::Current());
Elliott Hughescaf76542012-06-28 16:08:22 -07001726 Object* thread_group = gRegistry->Get<Object*>(thread_group_id);
1727
1728 // Get the ArrayList<ThreadGroup> "groups" out of this thread group...
1729 Field* groups_field = thread_group->GetClass()->FindInstanceField("groups", "Ljava/util/List;");
1730 Object* groups_array_list = groups_field->GetObject(thread_group);
1731
1732 // Get the array and size out of the ArrayList<ThreadGroup>...
1733 Field* array_field = groups_array_list->GetClass()->FindInstanceField("array", "[Ljava/lang/Object;");
1734 Field* size_field = groups_array_list->GetClass()->FindInstanceField("size", "I");
1735 ObjectArray<Object>* groups_array = array_field->GetObject(groups_array_list)->AsObjectArray<Object>();
1736 const int32_t size = size_field->GetInt(groups_array_list);
1737
1738 // Copy the first 'size' elements out of the array into the result.
1739 for (int32_t i = 0; i < size; ++i) {
1740 child_thread_group_ids.push_back(gRegistry->Add(groups_array->Get(i)));
Elliott Hughesa2155262011-11-16 16:26:58 -08001741 }
1742}
1743
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001744static int GetStackDepth(Thread* thread)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001745 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers0399dde2012-06-06 17:09:28 -07001746 struct CountStackDepthVisitor : public StackVisitor {
1747 CountStackDepthVisitor(const ManagedStack* stack,
Ian Rogers306057f2012-11-26 12:45:53 -08001748 const std::deque<InstrumentationStackFrame>* instrumentation_stack)
jeffhao725a9572012-11-13 18:20:12 -08001749 : StackVisitor(stack, instrumentation_stack, NULL), depth(0) {}
Ian Rogers0399dde2012-06-06 17:09:28 -07001750
1751 bool VisitFrame() {
1752 if (!GetMethod()->IsRuntimeMethod()) {
Elliott Hughesf8a2df72011-12-01 12:19:54 -08001753 ++depth;
1754 }
Elliott Hughes530fa002012-03-12 11:44:49 -07001755 return true;
Elliott Hughesa2e54f62011-11-17 13:01:30 -08001756 }
1757 size_t depth;
1758 };
Elliott Hughes08fc03a2012-06-26 17:34:00 -07001759
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001760 if (kIsDebugBuild) {
Ian Rogers50b35e22012-10-04 10:09:15 -07001761 MutexLock mu(Thread::Current(), *Locks::thread_suspend_count_lock_);
jeffhao09bfc6a2012-12-11 18:11:43 -08001762 CHECK(thread == Thread::Current() || thread->IsSuspended());
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001763 }
jeffhao725a9572012-11-13 18:20:12 -08001764 CountStackDepthVisitor visitor(thread->GetManagedStack(), thread->GetInstrumentationStack());
Ian Rogers0399dde2012-06-06 17:09:28 -07001765 visitor.WalkStack();
Elliott Hughesa2e54f62011-11-17 13:01:30 -08001766 return visitor.depth;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001767}
1768
Elliott Hughes221229c2013-01-08 18:17:50 -08001769JDWP::JdwpError Dbg::GetThreadFrameCount(JDWP::ObjectId thread_id, size_t& result) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001770 ScopedObjectAccess soa(Thread::Current());
jeffhaoa77f0f62012-12-05 17:19:31 -08001771 MutexLock mu(soa.Self(), *Locks::thread_list_lock_);
Elliott Hughes221229c2013-01-08 18:17:50 -08001772 Thread* thread;
1773 JDWP::JdwpError error = DecodeThread(soa, thread_id, thread);
1774 if (error != JDWP::ERR_NONE) {
1775 return error;
1776 }
Elliott Hughesf15f4a02013-01-09 10:09:38 -08001777 if (!IsSuspendedForDebugger(soa, thread)) {
1778 return JDWP::ERR_THREAD_NOT_SUSPENDED;
1779 }
Elliott Hughes221229c2013-01-08 18:17:50 -08001780 result = GetStackDepth(thread);
1781 return JDWP::ERR_NONE;
Elliott Hughes86964332012-02-15 19:37:42 -08001782}
1783
Ian Rogers306057f2012-11-26 12:45:53 -08001784JDWP::JdwpError Dbg::GetThreadFrames(JDWP::ObjectId thread_id, size_t start_frame,
1785 size_t frame_count, JDWP::ExpandBuf* buf) {
Elliott Hughes6e9d22c2012-06-22 15:02:37 -07001786 class GetFrameVisitor : public StackVisitor {
1787 public:
Ian Rogers306057f2012-11-26 12:45:53 -08001788 GetFrameVisitor(const ManagedStack* stack,
1789 const std::deque<InstrumentationStackFrame>* instrumentation_stack,
Elliott Hughes6e9d22c2012-06-22 15:02:37 -07001790 size_t start_frame, size_t frame_count, JDWP::ExpandBuf* buf)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001791 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
jeffhao725a9572012-11-13 18:20:12 -08001792 : StackVisitor(stack, instrumentation_stack, NULL), depth_(0),
Elliott Hughes6e9d22c2012-06-22 15:02:37 -07001793 start_frame_(start_frame), frame_count_(frame_count), buf_(buf) {
1794 expandBufAdd4BE(buf_, frame_count_);
Elliott Hughes03181a82011-11-17 17:22:21 -08001795 }
Ian Rogers0399dde2012-06-06 17:09:28 -07001796
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001797 // TODO: Enable annotalysis. We know lock is held in constructor, but abstraction confuses
1798 // annotalysis.
1799 virtual bool VisitFrame() NO_THREAD_SAFETY_ANALYSIS {
Ian Rogers0399dde2012-06-06 17:09:28 -07001800 if (GetMethod()->IsRuntimeMethod()) {
Elliott Hughes530fa002012-03-12 11:44:49 -07001801 return true; // The debugger can't do anything useful with a frame that has no Method*.
Elliott Hughes03181a82011-11-17 17:22:21 -08001802 }
Elliott Hughes6e9d22c2012-06-22 15:02:37 -07001803 if (depth_ >= start_frame_ + frame_count_) {
Elliott Hughes530fa002012-03-12 11:44:49 -07001804 return false;
Elliott Hughes03181a82011-11-17 17:22:21 -08001805 }
Elliott Hughes6e9d22c2012-06-22 15:02:37 -07001806 if (depth_ >= start_frame_) {
1807 JDWP::FrameId frame_id(GetFrameId());
1808 JDWP::JdwpLocation location;
1809 SetLocation(location, GetMethod(), GetDexPc());
Elliott Hughes7baf96f2012-06-22 16:33:50 -07001810 VLOG(jdwp) << StringPrintf(" Frame %3zd: id=%3lld ", depth_, frame_id) << location;
Elliott Hughes6e9d22c2012-06-22 15:02:37 -07001811 expandBufAdd8BE(buf_, frame_id);
1812 expandBufAddLocation(buf_, location);
1813 }
1814 ++depth_;
Elliott Hughes530fa002012-03-12 11:44:49 -07001815 return true;
Elliott Hughes03181a82011-11-17 17:22:21 -08001816 }
Elliott Hughes6e9d22c2012-06-22 15:02:37 -07001817
1818 private:
1819 size_t depth_;
1820 const size_t start_frame_;
1821 const size_t frame_count_;
1822 JDWP::ExpandBuf* buf_;
Elliott Hughes03181a82011-11-17 17:22:21 -08001823 };
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001824
1825 ScopedObjectAccessUnchecked soa(Thread::Current());
jeffhaoa77f0f62012-12-05 17:19:31 -08001826 MutexLock mu(soa.Self(), *Locks::thread_list_lock_);
Elliott Hughes221229c2013-01-08 18:17:50 -08001827 Thread* thread;
1828 JDWP::JdwpError error = DecodeThread(soa, thread_id, thread);
1829 if (error != JDWP::ERR_NONE) {
1830 return error;
1831 }
Elliott Hughesf15f4a02013-01-09 10:09:38 -08001832 if (!IsSuspendedForDebugger(soa, thread)) {
1833 return JDWP::ERR_THREAD_NOT_SUSPENDED;
1834 }
Ian Rogers306057f2012-11-26 12:45:53 -08001835 GetFrameVisitor visitor(thread->GetManagedStack(), thread->GetInstrumentationStack(),
1836 start_frame, frame_count, buf);
Ian Rogers0399dde2012-06-06 17:09:28 -07001837 visitor.WalkStack();
Elliott Hughes6e9d22c2012-06-22 15:02:37 -07001838 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001839}
1840
1841JDWP::ObjectId Dbg::GetThreadSelfId() {
Mathieu Chartierdbe6f462012-09-25 16:54:50 -07001842 ScopedObjectAccessUnchecked soa(Thread::Current());
Ian Rogerscfaa4552012-11-26 21:00:08 -08001843 return gRegistry->Add(soa.Self()->GetPeer());
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001844}
1845
Elliott Hughes475fc232011-10-25 15:00:35 -07001846void Dbg::SuspendVM() {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001847 Runtime::Current()->GetThreadList()->SuspendAllForDebugger();
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001848}
1849
1850void Dbg::ResumeVM() {
Elliott Hughesc61a2672012-06-21 14:52:29 -07001851 Runtime::Current()->GetThreadList()->UndoDebuggerSuspensions();
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001852}
1853
Elliott Hughes221229c2013-01-08 18:17:50 -08001854JDWP::JdwpError Dbg::SuspendThread(JDWP::ObjectId thread_id, bool request_suspension) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001855 ScopedLocalRef<jobject> peer(Thread::Current()->GetJniEnv(), NULL);
1856 {
1857 ScopedObjectAccess soa(Thread::Current());
Elliott Hughes221229c2013-01-08 18:17:50 -08001858 peer.reset(soa.AddLocalReference<jobject>(gRegistry->Get<Object*>(thread_id)));
Elliott Hughes4e235312011-12-02 11:34:15 -08001859 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001860 if (peer.get() == NULL) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001861 return JDWP::ERR_THREAD_NOT_ALIVE;
1862 }
1863 // Suspend thread to build stack trace.
Elliott Hughesf327e072013-01-09 16:01:26 -08001864 bool timed_out;
1865 Thread* thread = Thread::SuspendForDebugger(peer.get(), request_suspension, &timed_out);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001866 if (thread != NULL) {
1867 return JDWP::ERR_NONE;
Elliott Hughesf327e072013-01-09 16:01:26 -08001868 } else if (timed_out) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001869 return JDWP::ERR_INTERNAL;
1870 } else {
1871 return JDWP::ERR_THREAD_NOT_ALIVE;
1872 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001873}
1874
Elliott Hughes221229c2013-01-08 18:17:50 -08001875void Dbg::ResumeThread(JDWP::ObjectId thread_id) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001876 ScopedObjectAccessUnchecked soa(Thread::Current());
Elliott Hughes221229c2013-01-08 18:17:50 -08001877 Object* peer = gRegistry->Get<Object*>(thread_id);
jeffhaoa77f0f62012-12-05 17:19:31 -08001878 Thread* thread;
1879 {
1880 MutexLock mu(soa.Self(), *Locks::thread_list_lock_);
1881 thread = Thread::FromManagedThread(soa, peer);
1882 }
Elliott Hughes4e235312011-12-02 11:34:15 -08001883 if (thread == NULL) {
1884 LOG(WARNING) << "No such thread for resume: " << peer;
1885 return;
1886 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001887 bool needs_resume;
1888 {
Ian Rogers50b35e22012-10-04 10:09:15 -07001889 MutexLock mu2(soa.Self(), *Locks::thread_suspend_count_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001890 needs_resume = thread->GetSuspendCount() > 0;
1891 }
1892 if (needs_resume) {
Elliott Hughes546b9862012-06-20 16:06:13 -07001893 Runtime::Current()->GetThreadList()->Resume(thread, true);
1894 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001895}
1896
1897void Dbg::SuspendSelf() {
Elliott Hughes475fc232011-10-25 15:00:35 -07001898 Runtime::Current()->GetThreadList()->SuspendSelfForDebugger();
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001899}
1900
Ian Rogers0399dde2012-06-06 17:09:28 -07001901struct GetThisVisitor : public StackVisitor {
Ian Rogers306057f2012-11-26 12:45:53 -08001902 GetThisVisitor(const ManagedStack* stack,
1903 const std::deque<InstrumentationStackFrame>* instrumentation_stack,
Elliott Hughes88d63092013-01-09 09:55:54 -08001904 Context* context, JDWP::FrameId frame_id)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001905 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
Elliott Hughes88d63092013-01-09 09:55:54 -08001906 : StackVisitor(stack, instrumentation_stack, context), this_object(NULL), frame_id(frame_id) {}
Ian Rogers0399dde2012-06-06 17:09:28 -07001907
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001908 // TODO: Enable annotalysis. We know lock is held in constructor, but abstraction confuses
1909 // annotalysis.
1910 virtual bool VisitFrame() NO_THREAD_SAFETY_ANALYSIS {
Elliott Hughes6e9d22c2012-06-22 15:02:37 -07001911 if (frame_id != GetFrameId()) {
Ian Rogers0399dde2012-06-06 17:09:28 -07001912 return true; // continue
1913 }
Mathieu Chartier66f19252012-09-18 08:57:04 -07001914 AbstractMethod* m = GetMethod();
Ian Rogers0399dde2012-06-06 17:09:28 -07001915 if (m->IsNative() || m->IsStatic()) {
Elliott Hughes6e9d22c2012-06-22 15:02:37 -07001916 this_object = NULL;
Ian Rogers0399dde2012-06-06 17:09:28 -07001917 } else {
1918 uint16_t reg = DemangleSlot(0, m);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001919 this_object = reinterpret_cast<Object*>(GetVReg(m, reg, kReferenceVReg));
Ian Rogers0399dde2012-06-06 17:09:28 -07001920 }
1921 return false;
Elliott Hughes86b00102011-12-05 17:54:26 -08001922 }
Ian Rogers0399dde2012-06-06 17:09:28 -07001923
Elliott Hughes6e9d22c2012-06-22 15:02:37 -07001924 Object* this_object;
1925 JDWP::FrameId frame_id;
Ian Rogers0399dde2012-06-06 17:09:28 -07001926};
1927
Mathieu Chartier66f19252012-09-18 08:57:04 -07001928static Object* GetThis(Thread* self, AbstractMethod* m, size_t frame_id)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001929 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughescaf76542012-06-28 16:08:22 -07001930 // TODO: should we return the 'this' we passed through to non-static native methods?
Ian Rogers0399dde2012-06-06 17:09:28 -07001931 if (m->IsNative() || m->IsStatic()) {
1932 return NULL;
1933 }
Elliott Hughescaf76542012-06-28 16:08:22 -07001934
Ian Rogers0399dde2012-06-06 17:09:28 -07001935 UniquePtr<Context> context(Context::Create());
jeffhao725a9572012-11-13 18:20:12 -08001936 GetThisVisitor visitor(self->GetManagedStack(), self->GetInstrumentationStack(), context.get(), frame_id);
Elliott Hughescaf76542012-06-28 16:08:22 -07001937 visitor.WalkStack();
1938 return visitor.this_object;
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08001939}
1940
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001941JDWP::JdwpError Dbg::GetThisObject(JDWP::ObjectId thread_id, JDWP::FrameId frame_id,
1942 JDWP::ObjectId* result) {
1943 ScopedObjectAccessUnchecked soa(Thread::Current());
1944 Thread* thread;
1945 {
Ian Rogers50b35e22012-10-04 10:09:15 -07001946 MutexLock mu(soa.Self(), *Locks::thread_list_lock_);
Elliott Hughes221229c2013-01-08 18:17:50 -08001947 JDWP::JdwpError error = DecodeThread(soa, thread_id, thread);
1948 if (error != JDWP::ERR_NONE) {
1949 return error;
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001950 }
Elliott Hughes9e0c1752013-01-09 14:02:58 -08001951 if (!IsSuspendedForDebugger(soa, thread)) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001952 return JDWP::ERR_THREAD_NOT_SUSPENDED;
1953 }
Elliott Hughes6e9d22c2012-06-22 15:02:37 -07001954 }
Elliott Hughescaf76542012-06-28 16:08:22 -07001955 UniquePtr<Context> context(Context::Create());
jeffhao725a9572012-11-13 18:20:12 -08001956 GetThisVisitor visitor(thread->GetManagedStack(), thread->GetInstrumentationStack(), context.get(), frame_id);
Ian Rogers0399dde2012-06-06 17:09:28 -07001957 visitor.WalkStack();
Elliott Hughes6e9d22c2012-06-22 15:02:37 -07001958 *result = gRegistry->Add(visitor.this_object);
1959 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001960}
1961
Elliott Hughes88d63092013-01-09 09:55:54 -08001962void Dbg::GetLocalValue(JDWP::ObjectId thread_id, JDWP::FrameId frame_id, int slot, JDWP::JdwpTag tag,
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001963 uint8_t* buf, size_t width) {
Ian Rogers0399dde2012-06-06 17:09:28 -07001964 struct GetLocalVisitor : public StackVisitor {
Ian Rogers306057f2012-11-26 12:45:53 -08001965 GetLocalVisitor(const ManagedStack* stack,
1966 const std::deque<InstrumentationStackFrame>* instrumentation_stack,
Elliott Hughes88d63092013-01-09 09:55:54 -08001967 Context* context, JDWP::FrameId frame_id, int slot, JDWP::JdwpTag tag,
Ian Rogersca190662012-06-26 15:45:57 -07001968 uint8_t* buf, size_t width)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001969 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
Elliott Hughes88d63092013-01-09 09:55:54 -08001970 : StackVisitor(stack, instrumentation_stack, context), frame_id_(frame_id), slot_(slot), tag_(tag),
Ian Rogersca190662012-06-26 15:45:57 -07001971 buf_(buf), width_(width) {}
1972
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001973 // TODO: Enable annotalysis. We know lock is held in constructor, but abstraction confuses
1974 // annotalysis.
1975 bool VisitFrame() NO_THREAD_SAFETY_ANALYSIS {
Ian Rogers0399dde2012-06-06 17:09:28 -07001976 if (GetFrameId() != frame_id_) {
1977 return true; // Not our frame, carry on.
Elliott Hughesdbb40792011-11-18 17:05:22 -08001978 }
Ian Rogers0399dde2012-06-06 17:09:28 -07001979 // TODO: check that the tag is compatible with the actual type of the slot!
Mathieu Chartier66f19252012-09-18 08:57:04 -07001980 AbstractMethod* m = GetMethod();
Ian Rogers0399dde2012-06-06 17:09:28 -07001981 uint16_t reg = DemangleSlot(slot_, m);
Elliott Hughesdbb40792011-11-18 17:05:22 -08001982
Ian Rogers0399dde2012-06-06 17:09:28 -07001983 switch (tag_) {
1984 case JDWP::JT_BOOLEAN:
1985 {
1986 CHECK_EQ(width_, 1U);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001987 uint32_t intVal = GetVReg(m, reg, kIntVReg);
Ian Rogers0399dde2012-06-06 17:09:28 -07001988 VLOG(jdwp) << "get boolean local " << reg << " = " << intVal;
1989 JDWP::Set1(buf_+1, intVal != 0);
1990 }
1991 break;
1992 case JDWP::JT_BYTE:
1993 {
1994 CHECK_EQ(width_, 1U);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08001995 uint32_t intVal = GetVReg(m, reg, kIntVReg);
Ian Rogers0399dde2012-06-06 17:09:28 -07001996 VLOG(jdwp) << "get byte local " << reg << " = " << intVal;
1997 JDWP::Set1(buf_+1, intVal);
1998 }
1999 break;
2000 case JDWP::JT_SHORT:
2001 case JDWP::JT_CHAR:
2002 {
2003 CHECK_EQ(width_, 2U);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002004 uint32_t intVal = GetVReg(m, reg, kIntVReg);
Ian Rogers0399dde2012-06-06 17:09:28 -07002005 VLOG(jdwp) << "get short/char local " << reg << " = " << intVal;
2006 JDWP::Set2BE(buf_+1, intVal);
2007 }
2008 break;
2009 case JDWP::JT_INT:
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002010 {
2011 CHECK_EQ(width_, 4U);
2012 uint32_t intVal = GetVReg(m, reg, kIntVReg);
2013 VLOG(jdwp) << "get int local " << reg << " = " << intVal;
2014 JDWP::Set4BE(buf_+1, intVal);
2015 }
2016 break;
Ian Rogers0399dde2012-06-06 17:09:28 -07002017 case JDWP::JT_FLOAT:
2018 {
2019 CHECK_EQ(width_, 4U);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002020 uint32_t intVal = GetVReg(m, reg, kFloatVReg);
Ian Rogers0399dde2012-06-06 17:09:28 -07002021 VLOG(jdwp) << "get int/float local " << reg << " = " << intVal;
2022 JDWP::Set4BE(buf_+1, intVal);
2023 }
2024 break;
2025 case JDWP::JT_ARRAY:
2026 {
2027 CHECK_EQ(width_, sizeof(JDWP::ObjectId));
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002028 Object* o = reinterpret_cast<Object*>(GetVReg(m, reg, kReferenceVReg));
Ian Rogers0399dde2012-06-06 17:09:28 -07002029 VLOG(jdwp) << "get array local " << reg << " = " << o;
2030 if (!Runtime::Current()->GetHeap()->IsHeapAddress(o)) {
2031 LOG(FATAL) << "Register " << reg << " expected to hold array: " << o;
2032 }
2033 JDWP::SetObjectId(buf_+1, gRegistry->Add(o));
2034 }
2035 break;
2036 case JDWP::JT_CLASS_LOADER:
2037 case JDWP::JT_CLASS_OBJECT:
2038 case JDWP::JT_OBJECT:
2039 case JDWP::JT_STRING:
2040 case JDWP::JT_THREAD:
2041 case JDWP::JT_THREAD_GROUP:
2042 {
2043 CHECK_EQ(width_, sizeof(JDWP::ObjectId));
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002044 Object* o = reinterpret_cast<Object*>(GetVReg(m, reg, kReferenceVReg));
Ian Rogers0399dde2012-06-06 17:09:28 -07002045 VLOG(jdwp) << "get object local " << reg << " = " << o;
2046 if (!Runtime::Current()->GetHeap()->IsHeapAddress(o)) {
2047 LOG(FATAL) << "Register " << reg << " expected to hold object: " << o;
2048 }
2049 tag_ = TagFromObject(o);
2050 JDWP::SetObjectId(buf_+1, gRegistry->Add(o));
2051 }
2052 break;
2053 case JDWP::JT_DOUBLE:
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002054 {
2055 CHECK_EQ(width_, 8U);
2056 uint32_t lo = GetVReg(m, reg, kDoubleLoVReg);
2057 uint64_t hi = GetVReg(m, reg + 1, kDoubleHiVReg);
2058 uint64_t longVal = (hi << 32) | lo;
2059 VLOG(jdwp) << "get double/long local " << hi << ":" << lo << " = " << longVal;
2060 JDWP::Set8BE(buf_+1, longVal);
2061 }
2062 break;
Ian Rogers0399dde2012-06-06 17:09:28 -07002063 case JDWP::JT_LONG:
2064 {
2065 CHECK_EQ(width_, 8U);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002066 uint32_t lo = GetVReg(m, reg, kLongLoVReg);
2067 uint64_t hi = GetVReg(m, reg + 1, kLongHiVReg);
Ian Rogers0399dde2012-06-06 17:09:28 -07002068 uint64_t longVal = (hi << 32) | lo;
2069 VLOG(jdwp) << "get double/long local " << hi << ":" << lo << " = " << longVal;
2070 JDWP::Set8BE(buf_+1, longVal);
2071 }
2072 break;
2073 default:
2074 LOG(FATAL) << "Unknown tag " << tag_;
2075 break;
2076 }
2077
2078 // Prepend tag, which may have been updated.
2079 JDWP::Set1(buf_, tag_);
2080 return false;
2081 }
2082
2083 const JDWP::FrameId frame_id_;
2084 const int slot_;
2085 JDWP::JdwpTag tag_;
2086 uint8_t* const buf_;
2087 const size_t width_;
2088 };
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002089
2090 ScopedObjectAccessUnchecked soa(Thread::Current());
jeffhaoa77f0f62012-12-05 17:19:31 -08002091 MutexLock mu(soa.Self(), *Locks::thread_list_lock_);
Elliott Hughes221229c2013-01-08 18:17:50 -08002092 Thread* thread;
2093 JDWP::JdwpError error = DecodeThread(soa, thread_id, thread);
2094 if (error != JDWP::ERR_NONE) {
2095 return;
2096 }
Ian Rogers0399dde2012-06-06 17:09:28 -07002097 UniquePtr<Context> context(Context::Create());
jeffhao725a9572012-11-13 18:20:12 -08002098 GetLocalVisitor visitor(thread->GetManagedStack(), thread->GetInstrumentationStack(), context.get(),
Elliott Hughes88d63092013-01-09 09:55:54 -08002099 frame_id, slot, tag, buf, width);
Ian Rogers0399dde2012-06-06 17:09:28 -07002100 visitor.WalkStack();
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002101}
2102
Elliott Hughes88d63092013-01-09 09:55:54 -08002103void Dbg::SetLocalValue(JDWP::ObjectId thread_id, JDWP::FrameId frame_id, int slot, JDWP::JdwpTag tag,
Ian Rogers0399dde2012-06-06 17:09:28 -07002104 uint64_t value, size_t width) {
2105 struct SetLocalVisitor : public StackVisitor {
Ian Rogers306057f2012-11-26 12:45:53 -08002106 SetLocalVisitor(const ManagedStack* stack, const std::deque<InstrumentationStackFrame>* instrumentation_stack, Context* context,
Ian Rogers0399dde2012-06-06 17:09:28 -07002107 JDWP::FrameId frame_id, int slot, JDWP::JdwpTag tag, uint64_t value,
Ian Rogersca190662012-06-26 15:45:57 -07002108 size_t width)
Ian Rogersb726dcb2012-09-05 08:57:23 -07002109 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
jeffhao725a9572012-11-13 18:20:12 -08002110 : StackVisitor(stack, instrumentation_stack, context),
Elliott Hughes08fc03a2012-06-26 17:34:00 -07002111 frame_id_(frame_id), slot_(slot), tag_(tag), value_(value), width_(width) {}
Ian Rogersca190662012-06-26 15:45:57 -07002112
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002113 // TODO: Enable annotalysis. We know lock is held in constructor, but abstraction confuses
2114 // annotalysis.
2115 bool VisitFrame() NO_THREAD_SAFETY_ANALYSIS {
Ian Rogers0399dde2012-06-06 17:09:28 -07002116 if (GetFrameId() != frame_id_) {
2117 return true; // Not our frame, carry on.
2118 }
2119 // TODO: check that the tag is compatible with the actual type of the slot!
Mathieu Chartier66f19252012-09-18 08:57:04 -07002120 AbstractMethod* m = GetMethod();
Ian Rogers0399dde2012-06-06 17:09:28 -07002121 uint16_t reg = DemangleSlot(slot_, m);
2122
2123 switch (tag_) {
2124 case JDWP::JT_BOOLEAN:
2125 case JDWP::JT_BYTE:
2126 CHECK_EQ(width_, 1U);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002127 SetVReg(m, reg, static_cast<uint32_t>(value_), kIntVReg);
Ian Rogers0399dde2012-06-06 17:09:28 -07002128 break;
2129 case JDWP::JT_SHORT:
2130 case JDWP::JT_CHAR:
2131 CHECK_EQ(width_, 2U);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002132 SetVReg(m, reg, static_cast<uint32_t>(value_), kIntVReg);
Ian Rogers0399dde2012-06-06 17:09:28 -07002133 break;
2134 case JDWP::JT_INT:
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002135 CHECK_EQ(width_, 4U);
2136 SetVReg(m, reg, static_cast<uint32_t>(value_), kIntVReg);
2137 break;
Ian Rogers0399dde2012-06-06 17:09:28 -07002138 case JDWP::JT_FLOAT:
2139 CHECK_EQ(width_, 4U);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002140 SetVReg(m, reg, static_cast<uint32_t>(value_), kFloatVReg);
Ian Rogers0399dde2012-06-06 17:09:28 -07002141 break;
2142 case JDWP::JT_ARRAY:
2143 case JDWP::JT_OBJECT:
2144 case JDWP::JT_STRING:
2145 {
2146 CHECK_EQ(width_, sizeof(JDWP::ObjectId));
2147 Object* o = gRegistry->Get<Object*>(static_cast<JDWP::ObjectId>(value_));
2148 if (o == kInvalidObject) {
2149 UNIMPLEMENTED(FATAL) << "return an error code when given an invalid object to store";
2150 }
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002151 SetVReg(m, reg, static_cast<uint32_t>(reinterpret_cast<uintptr_t>(o)), kReferenceVReg);
Ian Rogers0399dde2012-06-06 17:09:28 -07002152 }
2153 break;
2154 case JDWP::JT_DOUBLE:
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002155 CHECK_EQ(width_, 8U);
2156 SetVReg(m, reg, static_cast<uint32_t>(value_), kDoubleLoVReg);
2157 SetVReg(m, reg + 1, static_cast<uint32_t>(value_ >> 32), kDoubleHiVReg);
2158 break;
Ian Rogers0399dde2012-06-06 17:09:28 -07002159 case JDWP::JT_LONG:
2160 CHECK_EQ(width_, 8U);
Ian Rogers2bcb4a42012-11-08 10:39:18 -08002161 SetVReg(m, reg, static_cast<uint32_t>(value_), kLongLoVReg);
2162 SetVReg(m, reg + 1, static_cast<uint32_t>(value_ >> 32), kLongHiVReg);
Ian Rogers0399dde2012-06-06 17:09:28 -07002163 break;
2164 default:
2165 LOG(FATAL) << "Unknown tag " << tag_;
2166 break;
2167 }
2168 return false;
2169 }
2170
2171 const JDWP::FrameId frame_id_;
2172 const int slot_;
2173 const JDWP::JdwpTag tag_;
2174 const uint64_t value_;
2175 const size_t width_;
2176 };
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002177
2178 ScopedObjectAccessUnchecked soa(Thread::Current());
jeffhaoa77f0f62012-12-05 17:19:31 -08002179 MutexLock mu(soa.Self(), *Locks::thread_list_lock_);
Elliott Hughes221229c2013-01-08 18:17:50 -08002180 Thread* thread;
2181 JDWP::JdwpError error = DecodeThread(soa, thread_id, thread);
2182 if (error != JDWP::ERR_NONE) {
2183 return;
2184 }
Elliott Hughes08fc03a2012-06-26 17:34:00 -07002185 UniquePtr<Context> context(Context::Create());
jeffhao725a9572012-11-13 18:20:12 -08002186 SetLocalVisitor visitor(thread->GetManagedStack(), thread->GetInstrumentationStack(), context.get(),
Elliott Hughes88d63092013-01-09 09:55:54 -08002187 frame_id, slot, tag, value, width);
Ian Rogers0399dde2012-06-06 17:09:28 -07002188 visitor.WalkStack();
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002189}
2190
Mathieu Chartier66f19252012-09-18 08:57:04 -07002191void Dbg::PostLocationEvent(const AbstractMethod* m, int dex_pc, Object* this_object, int event_flags) {
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08002192 Class* c = m->GetDeclaringClass();
2193
2194 JDWP::JdwpLocation location;
Elliott Hughes74847412012-06-20 18:10:21 -07002195 location.type_tag = c->IsInterface() ? JDWP::TT_INTERFACE : JDWP::TT_CLASS;
2196 location.class_id = gRegistry->Add(c);
2197 location.method_id = ToMethodId(m);
Elliott Hughes972a47b2012-02-21 18:16:06 -08002198 location.dex_pc = m->IsNative() ? -1 : dex_pc;
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08002199
2200 // Note we use "NoReg" so we don't keep track of references that are
2201 // never actually sent to the debugger. 'this_id' is only used to
2202 // compare against registered events...
2203 JDWP::ObjectId this_id = static_cast<JDWP::ObjectId>(reinterpret_cast<uintptr_t>(this_object));
2204 if (gJdwpState->PostLocationEvent(&location, this_id, event_flags)) {
2205 // ...unless there's a registered event, in which case we
2206 // need to really track the class and 'this'.
2207 gRegistry->Add(c);
2208 gRegistry->Add(this_object);
2209 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002210}
2211
Elliott Hughescaf76542012-06-28 16:08:22 -07002212void Dbg::PostException(Thread* thread,
Mathieu Chartier66f19252012-09-18 08:57:04 -07002213 JDWP::FrameId throw_frame_id, AbstractMethod* throw_method, uint32_t throw_dex_pc,
2214 AbstractMethod* catch_method, uint32_t catch_dex_pc, Throwable* exception) {
Elliott Hughesc0f09332012-03-26 13:27:06 -07002215 if (!IsDebuggerActive()) {
Ian Rogers0ad5bb82011-12-07 10:16:32 -08002216 return;
2217 }
Elliott Hughes4740cdf2011-12-07 14:07:12 -08002218
Elliott Hughesd07986f2011-12-06 18:27:45 -08002219 JDWP::JdwpLocation throw_location;
Elliott Hughescaf76542012-06-28 16:08:22 -07002220 SetLocation(throw_location, throw_method, throw_dex_pc);
Elliott Hughesd07986f2011-12-06 18:27:45 -08002221 JDWP::JdwpLocation catch_location;
Elliott Hughescaf76542012-06-28 16:08:22 -07002222 SetLocation(catch_location, catch_method, catch_dex_pc);
Elliott Hughesd07986f2011-12-06 18:27:45 -08002223
2224 // We need 'this' for InstanceOnly filters.
Elliott Hughescaf76542012-06-28 16:08:22 -07002225 UniquePtr<Context> context(Context::Create());
jeffhao725a9572012-11-13 18:20:12 -08002226 GetThisVisitor visitor(thread->GetManagedStack(), thread->GetInstrumentationStack(), context.get(), throw_frame_id);
Elliott Hughescaf76542012-06-28 16:08:22 -07002227 visitor.WalkStack();
2228 JDWP::ObjectId this_id = gRegistry->Add(visitor.this_object);
Elliott Hughesd07986f2011-12-06 18:27:45 -08002229
2230 /*
2231 * Hand the event to the JDWP exception handler. Note we're using the
2232 * "NoReg" objectID on the exception, which is not strictly correct --
2233 * the exception object WILL be passed up to the debugger if the
2234 * debugger is interested in the event. We do this because the current
2235 * implementation of the debugger object registry never throws anything
2236 * away, and some people were experiencing a fatal build up of exception
2237 * objects when dealing with certain libraries.
2238 */
2239 JDWP::ObjectId exception_id = static_cast<JDWP::ObjectId>(reinterpret_cast<uintptr_t>(exception));
2240 JDWP::RefTypeId exception_class_id = gRegistry->Add(exception->GetClass());
2241
2242 gJdwpState->PostException(&throw_location, exception_id, exception_class_id, &catch_location, this_id);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002243}
2244
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002245void Dbg::PostClassPrepare(Class* c) {
Elliott Hughesc0f09332012-03-26 13:27:06 -07002246 if (!IsDebuggerActive()) {
Elliott Hughes4740cdf2011-12-07 14:07:12 -08002247 return;
2248 }
2249
Elliott Hughes3d30d9b2011-12-07 17:35:48 -08002250 // OLD-TODO - we currently always send both "verified" and "prepared" since
Elliott Hughes4740cdf2011-12-07 14:07:12 -08002251 // debuggers seem to like that. There might be some advantage to honesty,
2252 // since the class may not yet be verified.
2253 int state = JDWP::CS_VERIFIED | JDWP::CS_PREPARED;
2254 JDWP::JdwpTypeTag tag = c->IsInterface() ? JDWP::TT_INTERFACE : JDWP::TT_CLASS;
2255 gJdwpState->PostClassPrepare(tag, gRegistry->Add(c), ClassHelper(c).GetDescriptor(), state);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002256}
2257
Elliott Hughescaf76542012-06-28 16:08:22 -07002258void Dbg::UpdateDebugger(int32_t dex_pc, Thread* self) {
Elliott Hughesc0f09332012-03-26 13:27:06 -07002259 if (!IsDebuggerActive() || dex_pc == -2 /* fake method exit */) {
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08002260 return;
2261 }
2262
Elliott Hughescaf76542012-06-28 16:08:22 -07002263 size_t frame_id;
Mathieu Chartier66f19252012-09-18 08:57:04 -07002264 AbstractMethod* m = self->GetCurrentMethod(NULL, &frame_id);
Elliott Hughescaf76542012-06-28 16:08:22 -07002265 //LOG(INFO) << "UpdateDebugger " << PrettyMethod(m) << "@" << dex_pc << " frame " << frame_id;
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08002266
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08002267 if (dex_pc == -1) {
Elliott Hughes2aa2e392012-02-17 17:15:43 -08002268 // We use a pc of -1 to represent method entry, since we might branch back to pc 0 later.
2269 // This means that for this special notification, there can't be anything else interesting
2270 // going on, so we're done already.
Elliott Hughescaf76542012-06-28 16:08:22 -07002271 Dbg::PostLocationEvent(m, 0, GetThis(self, m, frame_id), kMethodEntry);
Elliott Hughes2aa2e392012-02-17 17:15:43 -08002272 return;
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08002273 }
2274
Elliott Hughes2aa2e392012-02-17 17:15:43 -08002275 int event_flags = 0;
2276
Elliott Hughes86964332012-02-15 19:37:42 -08002277 if (IsBreakpoint(m, dex_pc)) {
2278 event_flags |= kBreakpoint;
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08002279 }
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08002280
jeffhao09bfc6a2012-12-11 18:11:43 -08002281 {
2282 // If the debugger is single-stepping one of our threads, check to
2283 // see if we're that thread and we've reached a step point.
2284 MutexLock mu(Thread::Current(), *Locks::breakpoint_lock_);
2285 if (gSingleStepControl.is_active && gSingleStepControl.thread == self) {
2286 CHECK(!m->IsNative());
2287 if (gSingleStepControl.step_depth == JDWP::SD_INTO) {
2288 // Step into method calls. We break when the line number
2289 // or method pointer changes. If we're in SS_MIN mode, we
2290 // always stop.
2291 if (gSingleStepControl.method != m) {
2292 event_flags |= kSingleStep;
2293 VLOG(jdwp) << "SS new method";
2294 } else if (gSingleStepControl.step_size == JDWP::SS_MIN) {
Elliott Hughes86964332012-02-15 19:37:42 -08002295 event_flags |= kSingleStep;
2296 VLOG(jdwp) << "SS new instruction";
Elliott Hughes2435a572012-02-17 16:07:41 -08002297 } else if (gSingleStepControl.dex_pcs.find(dex_pc) == gSingleStepControl.dex_pcs.end()) {
2298 event_flags |= kSingleStep;
2299 VLOG(jdwp) << "SS new line";
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08002300 }
jeffhao09bfc6a2012-12-11 18:11:43 -08002301 } else if (gSingleStepControl.step_depth == JDWP::SD_OVER) {
2302 // Step over method calls. We break when the line number is
2303 // different and the frame depth is <= the original frame
2304 // depth. (We can't just compare on the method, because we
2305 // might get unrolled past it by an exception, and it's tricky
2306 // to identify recursion.)
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08002307
jeffhao09bfc6a2012-12-11 18:11:43 -08002308 int stack_depth = GetStackDepth(self);
Elliott Hughes86964332012-02-15 19:37:42 -08002309
jeffhao09bfc6a2012-12-11 18:11:43 -08002310 if (stack_depth < gSingleStepControl.stack_depth) {
2311 // popped up one or more frames, always trigger
2312 event_flags |= kSingleStep;
2313 VLOG(jdwp) << "SS method pop";
2314 } else if (stack_depth == gSingleStepControl.stack_depth) {
2315 // same depth, see if we moved
2316 if (gSingleStepControl.step_size == JDWP::SS_MIN) {
2317 event_flags |= kSingleStep;
2318 VLOG(jdwp) << "SS new instruction";
2319 } else if (gSingleStepControl.dex_pcs.find(dex_pc) == gSingleStepControl.dex_pcs.end()) {
2320 event_flags |= kSingleStep;
2321 VLOG(jdwp) << "SS new line";
2322 }
2323 }
2324 } else {
2325 CHECK_EQ(gSingleStepControl.step_depth, JDWP::SD_OUT);
2326 // Return from the current method. We break when the frame
2327 // depth pops up.
2328
2329 // This differs from the "method exit" break in that it stops
2330 // with the PC at the next instruction in the returned-to
2331 // function, rather than the end of the returning function.
2332
2333 int stack_depth = GetStackDepth(self);
2334 if (stack_depth < gSingleStepControl.stack_depth) {
2335 event_flags |= kSingleStep;
2336 VLOG(jdwp) << "SS method pop";
2337 }
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08002338 }
2339 }
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08002340 }
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08002341
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08002342 // Check to see if this is a "return" instruction. JDWP says we should
2343 // send the event *after* the code has been executed, but it also says
2344 // the location we provide is the last instruction. Since the "return"
2345 // instruction has no interesting side effects, we should be safe.
2346 // (We can't just move this down to the returnFromMethod label because
2347 // we potentially need to combine it with other events.)
2348 // We're also not supposed to generate a method exit event if the method
2349 // terminates "with a thrown exception".
Elliott Hughes86964332012-02-15 19:37:42 -08002350 if (dex_pc >= 0) {
2351 const DexFile::CodeItem* code_item = MethodHelper(m).GetCodeItem();
Elliott Hughescaf76542012-06-28 16:08:22 -07002352 CHECK(code_item != NULL) << PrettyMethod(m) << " @" << dex_pc;
Elliott Hughes86964332012-02-15 19:37:42 -08002353 CHECK_LT(dex_pc, static_cast<int32_t>(code_item->insns_size_in_code_units_));
2354 if (Instruction::At(&code_item->insns_[dex_pc])->IsReturn()) {
2355 event_flags |= kMethodExit;
2356 }
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08002357 }
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08002358
2359 // If there's something interesting going on, see if it matches one
2360 // of the debugger filters.
2361 if (event_flags != 0) {
Elliott Hughescaf76542012-06-28 16:08:22 -07002362 Dbg::PostLocationEvent(m, dex_pc, GetThis(self, m, frame_id), event_flags);
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08002363 }
2364}
2365
Elliott Hughes86964332012-02-15 19:37:42 -08002366void Dbg::WatchLocation(const JDWP::JdwpLocation* location) {
jeffhao09bfc6a2012-12-11 18:11:43 -08002367 MutexLock mu(Thread::Current(), *Locks::breakpoint_lock_);
Mathieu Chartier66f19252012-09-18 08:57:04 -07002368 AbstractMethod* m = FromMethodId(location->method_id);
Elliott Hughes972a47b2012-02-21 18:16:06 -08002369 gBreakpoints.push_back(Breakpoint(m, location->dex_pc));
Elliott Hughes86964332012-02-15 19:37:42 -08002370 VLOG(jdwp) << "Set breakpoint #" << (gBreakpoints.size() - 1) << ": " << gBreakpoints[gBreakpoints.size() - 1];
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002371}
2372
Elliott Hughes86964332012-02-15 19:37:42 -08002373void Dbg::UnwatchLocation(const JDWP::JdwpLocation* location) {
jeffhao09bfc6a2012-12-11 18:11:43 -08002374 MutexLock mu(Thread::Current(), *Locks::breakpoint_lock_);
Mathieu Chartier66f19252012-09-18 08:57:04 -07002375 AbstractMethod* m = FromMethodId(location->method_id);
Elliott Hughes86964332012-02-15 19:37:42 -08002376 for (size_t i = 0; i < gBreakpoints.size(); ++i) {
Elliott Hughes972a47b2012-02-21 18:16:06 -08002377 if (gBreakpoints[i].method == m && gBreakpoints[i].dex_pc == location->dex_pc) {
Elliott Hughes86964332012-02-15 19:37:42 -08002378 VLOG(jdwp) << "Removed breakpoint #" << i << ": " << gBreakpoints[i];
2379 gBreakpoints.erase(gBreakpoints.begin() + i);
2380 return;
2381 }
2382 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002383}
2384
Elliott Hughes221229c2013-01-08 18:17:50 -08002385JDWP::JdwpError Dbg::ConfigureStep(JDWP::ObjectId thread_id, JDWP::JdwpStepSize step_size,
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002386 JDWP::JdwpStepDepth step_depth) {
2387 ScopedObjectAccessUnchecked soa(Thread::Current());
jeffhaoa77f0f62012-12-05 17:19:31 -08002388 MutexLock mu(soa.Self(), *Locks::thread_list_lock_);
Elliott Hughes221229c2013-01-08 18:17:50 -08002389 Thread* thread;
2390 JDWP::JdwpError error = DecodeThread(soa, thread_id, thread);
2391 if (error != JDWP::ERR_NONE) {
2392 return error;
Elliott Hughes2435a572012-02-17 16:07:41 -08002393 }
Elliott Hughes86964332012-02-15 19:37:42 -08002394
jeffhao09bfc6a2012-12-11 18:11:43 -08002395 MutexLock mu2(soa.Self(), *Locks::breakpoint_lock_);
Elliott Hughes86964332012-02-15 19:37:42 -08002396 // TODO: there's no theoretical reason why we couldn't support single-stepping
2397 // of multiple threads at once, but we never did so historically.
2398 if (gSingleStepControl.thread != NULL && thread != gSingleStepControl.thread) {
2399 LOG(WARNING) << "single-step already active for " << *gSingleStepControl.thread
2400 << "; switching to " << *thread;
2401 }
2402
Elliott Hughes2435a572012-02-17 16:07:41 -08002403 //
2404 // Work out what Method* we're in, the current line number, and how deep the stack currently
2405 // is for step-out.
2406 //
2407
Ian Rogers0399dde2012-06-06 17:09:28 -07002408 struct SingleStepStackVisitor : public StackVisitor {
2409 SingleStepStackVisitor(const ManagedStack* stack,
Ian Rogers306057f2012-11-26 12:45:53 -08002410 const std::deque<InstrumentationStackFrame>* instrumentation_stack)
jeffhao09bfc6a2012-12-11 18:11:43 -08002411 EXCLUSIVE_LOCKS_REQUIRED(Locks::breakpoint_lock_)
Ian Rogersb726dcb2012-09-05 08:57:23 -07002412 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
jeffhao725a9572012-11-13 18:20:12 -08002413 : StackVisitor(stack, instrumentation_stack, NULL) {
Elliott Hughes86964332012-02-15 19:37:42 -08002414 gSingleStepControl.method = NULL;
2415 gSingleStepControl.stack_depth = 0;
2416 }
Ian Rogersca190662012-06-26 15:45:57 -07002417
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002418 // TODO: Enable annotalysis. We know lock is held in constructor, but abstraction confuses
2419 // annotalysis.
2420 bool VisitFrame() NO_THREAD_SAFETY_ANALYSIS {
jeffhao09bfc6a2012-12-11 18:11:43 -08002421 Locks::breakpoint_lock_->AssertHeld(Thread::Current());
Mathieu Chartier66f19252012-09-18 08:57:04 -07002422 const AbstractMethod* m = GetMethod();
Ian Rogers0399dde2012-06-06 17:09:28 -07002423 if (!m->IsRuntimeMethod()) {
Elliott Hughes86964332012-02-15 19:37:42 -08002424 ++gSingleStepControl.stack_depth;
2425 if (gSingleStepControl.method == NULL) {
Elliott Hughes2435a572012-02-17 16:07:41 -08002426 const DexCache* dex_cache = m->GetDeclaringClass()->GetDexCache();
2427 gSingleStepControl.method = m;
2428 gSingleStepControl.line_number = -1;
2429 if (dex_cache != NULL) {
Ian Rogers4445a7e2012-10-05 17:19:13 -07002430 const DexFile& dex_file = *dex_cache->GetDexFile();
Ian Rogers0399dde2012-06-06 17:09:28 -07002431 gSingleStepControl.line_number = dex_file.GetLineNumFromPC(m, GetDexPc());
Elliott Hughes2435a572012-02-17 16:07:41 -08002432 }
Elliott Hughes86964332012-02-15 19:37:42 -08002433 }
2434 }
Elliott Hughes530fa002012-03-12 11:44:49 -07002435 return true;
Elliott Hughes86964332012-02-15 19:37:42 -08002436 }
2437 };
jeffhao725a9572012-11-13 18:20:12 -08002438 SingleStepStackVisitor visitor(thread->GetManagedStack(), thread->GetInstrumentationStack());
Ian Rogers0399dde2012-06-06 17:09:28 -07002439 visitor.WalkStack();
Elliott Hughes86964332012-02-15 19:37:42 -08002440
Elliott Hughes2435a572012-02-17 16:07:41 -08002441 //
2442 // Find the dex_pc values that correspond to the current line, for line-based single-stepping.
2443 //
2444
2445 struct DebugCallbackContext {
jeffhao09bfc6a2012-12-11 18:11:43 -08002446 DebugCallbackContext() EXCLUSIVE_LOCKS_REQUIRED(Locks::breakpoint_lock_) {
Elliott Hughes2435a572012-02-17 16:07:41 -08002447 last_pc_valid = false;
2448 last_pc = 0;
Elliott Hughes2435a572012-02-17 16:07:41 -08002449 }
2450
jeffhao09bfc6a2012-12-11 18:11:43 -08002451 // TODO: Enable annotalysis. We know lock is held in constructor, but abstraction confuses
2452 // annotalysis.
2453 static bool Callback(void* raw_context, uint32_t address, uint32_t line_number) NO_THREAD_SAFETY_ANALYSIS {
2454 Locks::breakpoint_lock_->AssertHeld(Thread::Current());
Elliott Hughes2435a572012-02-17 16:07:41 -08002455 DebugCallbackContext* context = reinterpret_cast<DebugCallbackContext*>(raw_context);
2456 if (static_cast<int32_t>(line_number) == gSingleStepControl.line_number) {
2457 if (!context->last_pc_valid) {
2458 // Everything from this address until the next line change is ours.
2459 context->last_pc = address;
2460 context->last_pc_valid = true;
2461 }
2462 // Otherwise, if we're already in a valid range for this line,
2463 // just keep going (shouldn't really happen)...
2464 } else if (context->last_pc_valid) { // and the line number is new
2465 // Add everything from the last entry up until here to the set
2466 for (uint32_t dex_pc = context->last_pc; dex_pc < address; ++dex_pc) {
2467 gSingleStepControl.dex_pcs.insert(dex_pc);
2468 }
2469 context->last_pc_valid = false;
2470 }
2471 return false; // There may be multiple entries for any given line.
2472 }
2473
jeffhao09bfc6a2012-12-11 18:11:43 -08002474 // TODO: Enable annotalysis. We know lock is held in constructor, but abstraction confuses
2475 // annotalysis.
2476 ~DebugCallbackContext() NO_THREAD_SAFETY_ANALYSIS {
2477 Locks::breakpoint_lock_->AssertHeld(Thread::Current());
Elliott Hughes2435a572012-02-17 16:07:41 -08002478 // If the line number was the last in the position table...
2479 if (last_pc_valid) {
2480 size_t end = MethodHelper(gSingleStepControl.method).GetCodeItem()->insns_size_in_code_units_;
2481 for (uint32_t dex_pc = last_pc; dex_pc < end; ++dex_pc) {
2482 gSingleStepControl.dex_pcs.insert(dex_pc);
2483 }
2484 }
2485 }
2486
2487 bool last_pc_valid;
2488 uint32_t last_pc;
2489 };
Elliott Hughes3e2e1a22012-02-21 11:33:41 -08002490 gSingleStepControl.dex_pcs.clear();
Mathieu Chartier66f19252012-09-18 08:57:04 -07002491 const AbstractMethod* m = gSingleStepControl.method;
Elliott Hughes3e2e1a22012-02-21 11:33:41 -08002492 if (m->IsNative()) {
2493 gSingleStepControl.line_number = -1;
2494 } else {
2495 DebugCallbackContext context;
2496 MethodHelper mh(m);
2497 mh.GetDexFile().DecodeDebugInfo(mh.GetCodeItem(), m->IsStatic(), m->GetDexMethodIndex(),
2498 DebugCallbackContext::Callback, NULL, &context);
2499 }
Elliott Hughes2435a572012-02-17 16:07:41 -08002500
2501 //
2502 // Everything else...
2503 //
2504
Elliott Hughes86964332012-02-15 19:37:42 -08002505 gSingleStepControl.thread = thread;
2506 gSingleStepControl.step_size = step_size;
2507 gSingleStepControl.step_depth = step_depth;
2508 gSingleStepControl.is_active = true;
2509
Elliott Hughes2435a572012-02-17 16:07:41 -08002510 if (VLOG_IS_ON(jdwp)) {
2511 VLOG(jdwp) << "Single-step thread: " << *gSingleStepControl.thread;
2512 VLOG(jdwp) << "Single-step step size: " << gSingleStepControl.step_size;
2513 VLOG(jdwp) << "Single-step step depth: " << gSingleStepControl.step_depth;
2514 VLOG(jdwp) << "Single-step current method: " << PrettyMethod(gSingleStepControl.method);
2515 VLOG(jdwp) << "Single-step current line: " << gSingleStepControl.line_number;
2516 VLOG(jdwp) << "Single-step current stack depth: " << gSingleStepControl.stack_depth;
2517 VLOG(jdwp) << "Single-step dex_pc values:";
2518 for (std::set<uint32_t>::iterator it = gSingleStepControl.dex_pcs.begin() ; it != gSingleStepControl.dex_pcs.end(); ++it) {
Elliott Hughes229feb72012-02-23 13:33:29 -08002519 VLOG(jdwp) << StringPrintf(" %#x", *it);
Elliott Hughes2435a572012-02-17 16:07:41 -08002520 }
2521 }
2522
2523 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002524}
2525
Elliott Hughes221229c2013-01-08 18:17:50 -08002526void Dbg::UnconfigureStep(JDWP::ObjectId /*thread_id*/) {
jeffhao09bfc6a2012-12-11 18:11:43 -08002527 MutexLock mu(Thread::Current(), *Locks::breakpoint_lock_);
Elliott Hughesf8349362012-06-18 15:00:06 -07002528
Elliott Hughes86964332012-02-15 19:37:42 -08002529 gSingleStepControl.is_active = false;
2530 gSingleStepControl.thread = NULL;
Elliott Hughes2435a572012-02-17 16:07:41 -08002531 gSingleStepControl.dex_pcs.clear();
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002532}
2533
Elliott Hughes45651fd2012-02-21 15:48:20 -08002534static char JdwpTagToShortyChar(JDWP::JdwpTag tag) {
2535 switch (tag) {
2536 default:
2537 LOG(FATAL) << "unknown JDWP tag: " << PrintableChar(tag);
2538
2539 // Primitives.
2540 case JDWP::JT_BYTE: return 'B';
2541 case JDWP::JT_CHAR: return 'C';
2542 case JDWP::JT_FLOAT: return 'F';
2543 case JDWP::JT_DOUBLE: return 'D';
2544 case JDWP::JT_INT: return 'I';
2545 case JDWP::JT_LONG: return 'J';
2546 case JDWP::JT_SHORT: return 'S';
2547 case JDWP::JT_VOID: return 'V';
2548 case JDWP::JT_BOOLEAN: return 'Z';
2549
2550 // Reference types.
2551 case JDWP::JT_ARRAY:
2552 case JDWP::JT_OBJECT:
2553 case JDWP::JT_STRING:
2554 case JDWP::JT_THREAD:
2555 case JDWP::JT_THREAD_GROUP:
2556 case JDWP::JT_CLASS_LOADER:
2557 case JDWP::JT_CLASS_OBJECT:
2558 return 'L';
2559 }
2560}
2561
Elliott Hughes88d63092013-01-09 09:55:54 -08002562JDWP::JdwpError Dbg::InvokeMethod(JDWP::ObjectId thread_id, JDWP::ObjectId object_id,
2563 JDWP::RefTypeId class_id, JDWP::MethodId method_id,
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002564 uint32_t arg_count, uint64_t* arg_values,
2565 JDWP::JdwpTag* arg_types, uint32_t options,
2566 JDWP::JdwpTag* pResultTag, uint64_t* pResultValue,
2567 JDWP::ObjectId* pExceptionId) {
Elliott Hughesd07986f2011-12-06 18:27:45 -08002568 ThreadList* thread_list = Runtime::Current()->GetThreadList();
2569
2570 Thread* targetThread = NULL;
2571 DebugInvokeReq* req = NULL;
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002572 Thread* self = Thread::Current();
Elliott Hughesd07986f2011-12-06 18:27:45 -08002573 {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002574 ScopedObjectAccessUnchecked soa(self);
Ian Rogers50b35e22012-10-04 10:09:15 -07002575 MutexLock mu(soa.Self(), *Locks::thread_list_lock_);
Elliott Hughes221229c2013-01-08 18:17:50 -08002576 JDWP::JdwpError error = DecodeThread(soa, thread_id, targetThread);
2577 if (error != JDWP::ERR_NONE) {
2578 LOG(ERROR) << "InvokeMethod request for invalid thread id " << thread_id;
2579 return error;
Elliott Hughesd07986f2011-12-06 18:27:45 -08002580 }
2581 req = targetThread->GetInvokeReq();
2582 if (!req->ready) {
2583 LOG(ERROR) << "InvokeMethod request for thread not stopped by event: " << *targetThread;
2584 return JDWP::ERR_INVALID_THREAD;
2585 }
2586
2587 /*
2588 * We currently have a bug where we don't successfully resume the
2589 * target thread if the suspend count is too deep. We're expected to
2590 * require one "resume" for each "suspend", but when asked to execute
2591 * a method we have to resume fully and then re-suspend it back to the
2592 * same level. (The easiest way to cause this is to type "suspend"
2593 * multiple times in jdb.)
2594 *
2595 * It's unclear what this means when the event specifies "resume all"
2596 * and some threads are suspended more deeply than others. This is
2597 * a rare problem, so for now we just prevent it from hanging forever
2598 * by rejecting the method invocation request. Without this, we will
2599 * be stuck waiting on a suspended thread.
2600 */
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002601 int suspend_count;
2602 {
Ian Rogers50b35e22012-10-04 10:09:15 -07002603 MutexLock mu2(soa.Self(), *Locks::thread_suspend_count_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002604 suspend_count = targetThread->GetSuspendCount();
2605 }
Elliott Hughesd07986f2011-12-06 18:27:45 -08002606 if (suspend_count > 1) {
2607 LOG(ERROR) << *targetThread << " suspend count too deep for method invocation: " << suspend_count;
2608 return JDWP::ERR_THREAD_SUSPENDED; // Probably not expected here.
2609 }
2610
Elliott Hughes3f4d58f2012-02-18 20:05:37 -08002611 JDWP::JdwpError status;
Elliott Hughes88d63092013-01-09 09:55:54 -08002612 Object* receiver = gRegistry->Get<Object*>(object_id);
Elliott Hughes45651fd2012-02-21 15:48:20 -08002613 if (receiver == kInvalidObject) {
Elliott Hughes3f4d58f2012-02-18 20:05:37 -08002614 return JDWP::ERR_INVALID_OBJECT;
2615 }
Elliott Hughes45651fd2012-02-21 15:48:20 -08002616
Elliott Hughes221229c2013-01-08 18:17:50 -08002617 Object* thread = gRegistry->Get<Object*>(thread_id);
Elliott Hughes45651fd2012-02-21 15:48:20 -08002618 if (thread == kInvalidObject) {
Elliott Hughes3f4d58f2012-02-18 20:05:37 -08002619 return JDWP::ERR_INVALID_OBJECT;
2620 }
Elliott Hughes45651fd2012-02-21 15:48:20 -08002621 // TODO: check that 'thread' is actually a java.lang.Thread!
2622
Elliott Hughes88d63092013-01-09 09:55:54 -08002623 Class* c = DecodeClass(class_id, status);
Elliott Hughes45651fd2012-02-21 15:48:20 -08002624 if (c == NULL) {
Elliott Hughes3f4d58f2012-02-18 20:05:37 -08002625 return status;
2626 }
Elliott Hughes45651fd2012-02-21 15:48:20 -08002627
Elliott Hughes88d63092013-01-09 09:55:54 -08002628 AbstractMethod* m = FromMethodId(method_id);
Elliott Hughes45651fd2012-02-21 15:48:20 -08002629 if (m->IsStatic() != (receiver == NULL)) {
2630 return JDWP::ERR_INVALID_METHODID;
2631 }
2632 if (m->IsStatic()) {
2633 if (m->GetDeclaringClass() != c) {
2634 return JDWP::ERR_INVALID_METHODID;
2635 }
2636 } else {
2637 if (!m->GetDeclaringClass()->IsAssignableFrom(c)) {
2638 return JDWP::ERR_INVALID_METHODID;
2639 }
2640 }
2641
2642 // Check the argument list matches the method.
2643 MethodHelper mh(m);
2644 if (mh.GetShortyLength() - 1 != arg_count) {
2645 return JDWP::ERR_ILLEGAL_ARGUMENT;
2646 }
2647 const char* shorty = mh.GetShorty();
2648 for (size_t i = 0; i < arg_count; ++i) {
2649 if (shorty[i + 1] != JdwpTagToShortyChar(arg_types[i])) {
2650 return JDWP::ERR_ILLEGAL_ARGUMENT;
2651 }
2652 }
2653
2654 req->receiver_ = receiver;
2655 req->thread_ = thread;
2656 req->class_ = c;
2657 req->method_ = m;
2658 req->arg_count_ = arg_count;
2659 req->arg_values_ = arg_values;
Elliott Hughesd07986f2011-12-06 18:27:45 -08002660 req->options_ = options;
2661 req->invoke_needed_ = true;
2662 }
2663
2664 // The fact that we've released the thread list lock is a bit risky --- if the thread goes
2665 // away we're sitting high and dry -- but we must release this before the ResumeAllThreads
2666 // call, and it's unwise to hold it during WaitForSuspend.
2667
2668 {
2669 /*
2670 * We change our (JDWP thread) status, which should be THREAD_RUNNING,
Elliott Hughes81ff3182012-03-23 20:35:56 -07002671 * so we can suspend for a GC if the invoke request causes us to
Elliott Hughesd07986f2011-12-06 18:27:45 -08002672 * run out of memory. It's also a good idea to change it before locking
2673 * the invokeReq mutex, although that should never be held for long.
2674 */
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002675 self->TransitionFromRunnableToSuspended(kWaitingForDebuggerSend);
Elliott Hughesd07986f2011-12-06 18:27:45 -08002676
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08002677 VLOG(jdwp) << " Transferring control to event thread";
Elliott Hughesd07986f2011-12-06 18:27:45 -08002678 {
Ian Rogers50b35e22012-10-04 10:09:15 -07002679 MutexLock mu(self, req->lock_);
Elliott Hughesd07986f2011-12-06 18:27:45 -08002680
2681 if ((options & JDWP::INVOKE_SINGLE_THREADED) == 0) {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08002682 VLOG(jdwp) << " Resuming all threads";
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002683 thread_list->UndoDebuggerSuspensions();
Elliott Hughesd07986f2011-12-06 18:27:45 -08002684 } else {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08002685 VLOG(jdwp) << " Resuming event thread only";
Elliott Hughesd07986f2011-12-06 18:27:45 -08002686 thread_list->Resume(targetThread, true);
2687 }
2688
2689 // Wait for the request to finish executing.
2690 while (req->invoke_needed_) {
Ian Rogersc604d732012-10-14 16:09:54 -07002691 req->cond_.Wait(self);
Elliott Hughesd07986f2011-12-06 18:27:45 -08002692 }
2693 }
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08002694 VLOG(jdwp) << " Control has returned from event thread";
Elliott Hughesd07986f2011-12-06 18:27:45 -08002695
2696 /* wait for thread to re-suspend itself */
Elliott Hughes221229c2013-01-08 18:17:50 -08002697 SuspendThread(thread_id, false /* request_suspension */ );
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002698 self->TransitionFromSuspendedToRunnable();
Elliott Hughesd07986f2011-12-06 18:27:45 -08002699 }
2700
2701 /*
2702 * Suspend the threads. We waited for the target thread to suspend
2703 * itself, so all we need to do is suspend the others.
2704 *
2705 * The suspendAllThreads() call will double-suspend the event thread,
2706 * so we want to resume the target thread once to keep the books straight.
2707 */
2708 if ((options & JDWP::INVOKE_SINGLE_THREADED) == 0) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002709 self->TransitionFromRunnableToSuspended(kWaitingForDebuggerSuspension);
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08002710 VLOG(jdwp) << " Suspending all threads";
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002711 thread_list->SuspendAllForDebugger();
2712 self->TransitionFromSuspendedToRunnable();
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08002713 VLOG(jdwp) << " Resuming event thread to balance the count";
Elliott Hughesd07986f2011-12-06 18:27:45 -08002714 thread_list->Resume(targetThread, true);
2715 }
2716
2717 // Copy the result.
2718 *pResultTag = req->result_tag;
2719 if (IsPrimitiveTag(req->result_tag)) {
Elliott Hughesf24d3ce2012-04-11 17:43:37 -07002720 *pResultValue = req->result_value.GetJ();
Elliott Hughesd07986f2011-12-06 18:27:45 -08002721 } else {
Elliott Hughesf24d3ce2012-04-11 17:43:37 -07002722 *pResultValue = gRegistry->Add(req->result_value.GetL());
Elliott Hughesd07986f2011-12-06 18:27:45 -08002723 }
2724 *pExceptionId = req->exception;
2725 return req->error;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002726}
2727
2728void Dbg::ExecuteMethod(DebugInvokeReq* pReq) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002729 ScopedObjectAccess soa(Thread::Current());
Elliott Hughesd07986f2011-12-06 18:27:45 -08002730
Elliott Hughes81ff3182012-03-23 20:35:56 -07002731 // We can be called while an exception is pending. We need
Elliott Hughesd07986f2011-12-06 18:27:45 -08002732 // to preserve that across the method invocation.
Ian Rogers1f539342012-10-03 21:09:42 -07002733 SirtRef<Throwable> old_exception(soa.Self(), soa.Self()->GetException());
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002734 soa.Self()->ClearException();
Elliott Hughesd07986f2011-12-06 18:27:45 -08002735
2736 // Translate the method through the vtable, unless the debugger wants to suppress it.
Mathieu Chartier66f19252012-09-18 08:57:04 -07002737 AbstractMethod* m = pReq->method_;
Elliott Hughesd07986f2011-12-06 18:27:45 -08002738 if ((pReq->options_ & JDWP::INVOKE_NONVIRTUAL) == 0 && pReq->receiver_ != NULL) {
Mathieu Chartier66f19252012-09-18 08:57:04 -07002739 AbstractMethod* actual_method = pReq->class_->FindVirtualMethodForVirtualOrInterface(pReq->method_);
Elliott Hughes45651fd2012-02-21 15:48:20 -08002740 if (actual_method != m) {
2741 VLOG(jdwp) << "ExecuteMethod translated " << PrettyMethod(m) << " to " << PrettyMethod(actual_method);
2742 m = actual_method;
2743 }
Elliott Hughesd07986f2011-12-06 18:27:45 -08002744 }
Elliott Hughes45651fd2012-02-21 15:48:20 -08002745 VLOG(jdwp) << "ExecuteMethod " << PrettyMethod(m);
Elliott Hughesd07986f2011-12-06 18:27:45 -08002746 CHECK(m != NULL);
2747
2748 CHECK_EQ(sizeof(jvalue), sizeof(uint64_t));
2749
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002750 LOG(INFO) << "self=" << soa.Self() << " pReq->receiver_=" << pReq->receiver_ << " m=" << m
2751 << " #" << pReq->arg_count_ << " " << pReq->arg_values_;
2752 pReq->result_value = InvokeWithJValues(soa, pReq->receiver_, m,
2753 reinterpret_cast<JValue*>(pReq->arg_values_));
Elliott Hughesd07986f2011-12-06 18:27:45 -08002754
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002755 pReq->exception = gRegistry->Add(soa.Self()->GetException());
Elliott Hughesd07986f2011-12-06 18:27:45 -08002756 pReq->result_tag = BasicTagFromDescriptor(MethodHelper(m).GetShorty());
2757 if (pReq->exception != 0) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002758 Object* exc = soa.Self()->GetException();
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08002759 VLOG(jdwp) << " JDWP invocation returning with exception=" << exc << " " << PrettyTypeOf(exc);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002760 soa.Self()->ClearException();
Elliott Hughesf24d3ce2012-04-11 17:43:37 -07002761 pReq->result_value.SetJ(0);
Elliott Hughesd07986f2011-12-06 18:27:45 -08002762 } else if (pReq->result_tag == JDWP::JT_OBJECT) {
2763 /* if no exception thrown, examine object result more closely */
Elliott Hughesf24d3ce2012-04-11 17:43:37 -07002764 JDWP::JdwpTag new_tag = TagFromObject(pReq->result_value.GetL());
Elliott Hughesd07986f2011-12-06 18:27:45 -08002765 if (new_tag != pReq->result_tag) {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08002766 VLOG(jdwp) << " JDWP promoted result from " << pReq->result_tag << " to " << new_tag;
Elliott Hughesd07986f2011-12-06 18:27:45 -08002767 pReq->result_tag = new_tag;
2768 }
2769
2770 /*
2771 * Register the object. We don't actually need an ObjectId yet,
2772 * but we do need to be sure that the GC won't move or discard the
2773 * object when we switch out of RUNNING. The ObjectId conversion
2774 * will add the object to the "do not touch" list.
2775 *
2776 * We can't use the "tracked allocation" mechanism here because
2777 * the object is going to be handed off to a different thread.
2778 */
Elliott Hughesf24d3ce2012-04-11 17:43:37 -07002779 gRegistry->Add(pReq->result_value.GetL());
Elliott Hughesd07986f2011-12-06 18:27:45 -08002780 }
2781
2782 if (old_exception.get() != NULL) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002783 soa.Self()->SetException(old_exception.get());
Elliott Hughesd07986f2011-12-06 18:27:45 -08002784 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002785}
2786
Elliott Hughesd07986f2011-12-06 18:27:45 -08002787/*
2788 * Register an object ID that might not have been registered previously.
2789 *
2790 * Normally this wouldn't happen -- the conversion to an ObjectId would
2791 * have added the object to the registry -- but in some cases (e.g.
2792 * throwing exceptions) we really want to do the registration late.
2793 */
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002794void Dbg::RegisterObjectId(JDWP::ObjectId id) {
Elliott Hughesd07986f2011-12-06 18:27:45 -08002795 gRegistry->Add(reinterpret_cast<Object*>(id));
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002796}
2797
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -07002798/*
2799 * "buf" contains a full JDWP packet, possibly with multiple chunks. We
2800 * need to process each, accumulate the replies, and ship the whole thing
2801 * back.
2802 *
2803 * Returns "true" if we have a reply. The reply buffer is newly allocated,
2804 * and includes the chunk type/length, followed by the data.
2805 *
Elliott Hughes3d30d9b2011-12-07 17:35:48 -08002806 * OLD-TODO: we currently assume that the request and reply include a single
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -07002807 * chunk. If this becomes inconvenient we will need to adapt.
2808 */
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002809bool Dbg::DdmHandlePacket(const uint8_t* buf, int dataLen, uint8_t** pReplyBuf, int* pReplyLen) {
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -07002810 CHECK_GE(dataLen, 0);
2811
2812 Thread* self = Thread::Current();
2813 JNIEnv* env = self->GetJniEnv();
2814
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -07002815 // Create a byte[] corresponding to 'buf'.
Elliott Hughes6a5bd492011-10-28 14:33:57 -07002816 ScopedLocalRef<jbyteArray> dataArray(env, env->NewByteArray(dataLen));
2817 if (dataArray.get() == NULL) {
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -07002818 LOG(WARNING) << "byte[] allocation failed: " << dataLen;
2819 env->ExceptionClear();
2820 return false;
2821 }
Elliott Hughes6a5bd492011-10-28 14:33:57 -07002822 env->SetByteArrayRegion(dataArray.get(), 0, dataLen, reinterpret_cast<const jbyte*>(buf));
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -07002823
2824 const int kChunkHdrLen = 8;
2825
2826 // Run through and find all chunks. [Currently just find the first.]
Elliott Hughes6a5bd492011-10-28 14:33:57 -07002827 ScopedByteArrayRO contents(env, dataArray.get());
Elliott Hughesf7c3b662011-10-27 12:04:56 -07002828 jint type = JDWP::Get4BE(reinterpret_cast<const uint8_t*>(&contents[0]));
2829 jint length = JDWP::Get4BE(reinterpret_cast<const uint8_t*>(&contents[4]));
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -07002830 jint offset = kChunkHdrLen;
2831 if (offset + length > dataLen) {
2832 LOG(WARNING) << StringPrintf("bad chunk found (len=%u pktLen=%d)", length, dataLen);
2833 return false;
2834 }
2835
2836 // Call "private static Chunk dispatch(int type, byte[] data, int offset, int length)".
Elliott Hugheseac76672012-05-24 21:56:51 -07002837 ScopedLocalRef<jobject> chunk(env, env->CallStaticObjectMethod(WellKnownClasses::org_apache_harmony_dalvik_ddmc_DdmServer,
2838 WellKnownClasses::org_apache_harmony_dalvik_ddmc_DdmServer_dispatch,
2839 type, dataArray.get(), offset, length));
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -07002840 if (env->ExceptionCheck()) {
2841 LOG(INFO) << StringPrintf("Exception thrown by dispatcher for 0x%08x", type);
2842 env->ExceptionDescribe();
2843 env->ExceptionClear();
2844 return false;
2845 }
2846
Elliott Hughes6a5bd492011-10-28 14:33:57 -07002847 if (chunk.get() == NULL) {
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -07002848 return false;
2849 }
2850
2851 /*
2852 * Pull the pieces out of the chunk. We copy the results into a
2853 * newly-allocated buffer that the caller can free. We don't want to
2854 * continue using the Chunk object because nothing has a reference to it.
2855 *
2856 * We could avoid this by returning type/data/offset/length and having
2857 * the caller be aware of the object lifetime issues, but that
Elliott Hughes81ff3182012-03-23 20:35:56 -07002858 * integrates the JDWP code more tightly into the rest of the runtime, and doesn't work
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -07002859 * if we have responses for multiple chunks.
2860 *
2861 * So we're pretty much stuck with copying data around multiple times.
2862 */
Elliott Hugheseac76672012-05-24 21:56:51 -07002863 ScopedLocalRef<jbyteArray> replyData(env, reinterpret_cast<jbyteArray>(env->GetObjectField(chunk.get(), WellKnownClasses::org_apache_harmony_dalvik_ddmc_Chunk_data)));
2864 length = env->GetIntField(chunk.get(), WellKnownClasses::org_apache_harmony_dalvik_ddmc_Chunk_length);
2865 offset = env->GetIntField(chunk.get(), WellKnownClasses::org_apache_harmony_dalvik_ddmc_Chunk_offset);
2866 type = env->GetIntField(chunk.get(), WellKnownClasses::org_apache_harmony_dalvik_ddmc_Chunk_type);
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -07002867
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08002868 VLOG(jdwp) << StringPrintf("DDM reply: type=0x%08x data=%p offset=%d length=%d", type, replyData.get(), offset, length);
Elliott Hughes6a5bd492011-10-28 14:33:57 -07002869 if (length == 0 || replyData.get() == NULL) {
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -07002870 return false;
2871 }
2872
Elliott Hughes6a5bd492011-10-28 14:33:57 -07002873 jsize replyLength = env->GetArrayLength(replyData.get());
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -07002874 if (offset + length > replyLength) {
2875 LOG(WARNING) << StringPrintf("chunk off=%d len=%d exceeds reply array len %d", offset, length, replyLength);
2876 return false;
2877 }
2878
2879 uint8_t* reply = new uint8_t[length + kChunkHdrLen];
2880 if (reply == NULL) {
2881 LOG(WARNING) << "malloc failed: " << (length + kChunkHdrLen);
2882 return false;
2883 }
Elliott Hughesf7c3b662011-10-27 12:04:56 -07002884 JDWP::Set4BE(reply + 0, type);
2885 JDWP::Set4BE(reply + 4, length);
Elliott Hughes6a5bd492011-10-28 14:33:57 -07002886 env->GetByteArrayRegion(replyData.get(), offset, length, reinterpret_cast<jbyte*>(reply + kChunkHdrLen));
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -07002887
2888 *pReplyBuf = reply;
2889 *pReplyLen = length + kChunkHdrLen;
2890
Elliott Hughesba8eee12012-01-24 20:25:24 -08002891 VLOG(jdwp) << StringPrintf("dvmHandleDdm returning type=%.4s buf=%p len=%d", reinterpret_cast<char*>(reply), reply, length);
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -07002892 return true;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002893}
2894
Elliott Hughesa2155262011-11-16 16:26:58 -08002895void Dbg::DdmBroadcast(bool connect) {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08002896 VLOG(jdwp) << "Broadcasting DDM " << (connect ? "connect" : "disconnect") << "...";
Elliott Hughes47fce012011-10-25 18:37:19 -07002897
2898 Thread* self = Thread::Current();
Ian Rogers50b35e22012-10-04 10:09:15 -07002899 if (self->GetState() != kRunnable) {
2900 LOG(ERROR) << "DDM broadcast in thread state " << self->GetState();
2901 /* try anyway? */
Elliott Hughes47fce012011-10-25 18:37:19 -07002902 }
2903
2904 JNIEnv* env = self->GetJniEnv();
Elliott Hughes47fce012011-10-25 18:37:19 -07002905 jint event = connect ? 1 /*DdmServer.CONNECTED*/ : 2 /*DdmServer.DISCONNECTED*/;
Elliott Hugheseac76672012-05-24 21:56:51 -07002906 env->CallStaticVoidMethod(WellKnownClasses::org_apache_harmony_dalvik_ddmc_DdmServer,
2907 WellKnownClasses::org_apache_harmony_dalvik_ddmc_DdmServer_broadcast,
2908 event);
Elliott Hughes47fce012011-10-25 18:37:19 -07002909 if (env->ExceptionCheck()) {
2910 LOG(ERROR) << "DdmServer.broadcast " << event << " failed";
2911 env->ExceptionDescribe();
2912 env->ExceptionClear();
2913 }
2914}
2915
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002916void Dbg::DdmConnected() {
Elliott Hughesa2155262011-11-16 16:26:58 -08002917 Dbg::DdmBroadcast(true);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002918}
2919
2920void Dbg::DdmDisconnected() {
Elliott Hughesa2155262011-11-16 16:26:58 -08002921 Dbg::DdmBroadcast(false);
Elliott Hughes47fce012011-10-25 18:37:19 -07002922 gDdmThreadNotification = false;
2923}
2924
2925/*
Elliott Hughes82188472011-11-07 18:11:48 -08002926 * Send a notification when a thread starts, stops, or changes its name.
Elliott Hughes47fce012011-10-25 18:37:19 -07002927 *
2928 * Because we broadcast the full set of threads when the notifications are
2929 * first enabled, it's possible for "thread" to be actively executing.
2930 */
Elliott Hughes82188472011-11-07 18:11:48 -08002931void Dbg::DdmSendThreadNotification(Thread* t, uint32_t type) {
Elliott Hughes47fce012011-10-25 18:37:19 -07002932 if (!gDdmThreadNotification) {
2933 return;
2934 }
2935
Elliott Hughes82188472011-11-07 18:11:48 -08002936 if (type == CHUNK_TYPE("THDE")) {
Elliott Hughes47fce012011-10-25 18:37:19 -07002937 uint8_t buf[4];
Elliott Hughesf7c3b662011-10-27 12:04:56 -07002938 JDWP::Set4BE(&buf[0], t->GetThinLockId());
Elliott Hughes47fce012011-10-25 18:37:19 -07002939 Dbg::DdmSendChunk(CHUNK_TYPE("THDE"), 4, buf);
Elliott Hughes82188472011-11-07 18:11:48 -08002940 } else {
2941 CHECK(type == CHUNK_TYPE("THCR") || type == CHUNK_TYPE("THNM")) << type;
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002942 ScopedObjectAccessUnchecked soa(Thread::Current());
Ian Rogers1f539342012-10-03 21:09:42 -07002943 SirtRef<String> name(soa.Self(), t->GetThreadName(soa));
Elliott Hughes82188472011-11-07 18:11:48 -08002944 size_t char_count = (name.get() != NULL) ? name->GetLength() : 0;
jeffhao725a9572012-11-13 18:20:12 -08002945 const jchar* chars = (name.get() != NULL) ? name->GetCharArray()->GetData() : NULL;
Elliott Hughes82188472011-11-07 18:11:48 -08002946
Elliott Hughes21f32d72011-11-09 17:44:13 -08002947 std::vector<uint8_t> bytes;
Elliott Hughes545a0642011-11-08 19:10:03 -08002948 JDWP::Append4BE(bytes, t->GetThinLockId());
2949 JDWP::AppendUtf16BE(bytes, chars, char_count);
Elliott Hughes21f32d72011-11-09 17:44:13 -08002950 CHECK_EQ(bytes.size(), char_count*2 + sizeof(uint32_t)*2);
2951 Dbg::DdmSendChunk(type, bytes);
Elliott Hughes47fce012011-10-25 18:37:19 -07002952 }
2953}
2954
Elliott Hughes47fce012011-10-25 18:37:19 -07002955void Dbg::DdmSetThreadNotification(bool enable) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002956 // Enable/disable thread notifications.
Elliott Hughes47fce012011-10-25 18:37:19 -07002957 gDdmThreadNotification = enable;
2958 if (enable) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002959 // Suspend the VM then post thread start notifications for all threads. Threads attaching will
2960 // see a suspension in progress and block until that ends. They then post their own start
2961 // notification.
2962 SuspendVM();
2963 std::list<Thread*> threads;
Ian Rogers50b35e22012-10-04 10:09:15 -07002964 Thread* self = Thread::Current();
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002965 {
Ian Rogers50b35e22012-10-04 10:09:15 -07002966 MutexLock mu(self, *Locks::thread_list_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002967 threads = Runtime::Current()->GetThreadList()->GetList();
2968 }
2969 {
Ian Rogers50b35e22012-10-04 10:09:15 -07002970 ScopedObjectAccess soa(self);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002971 typedef std::list<Thread*>::const_iterator It; // TODO: C++0x auto
2972 for (It it = threads.begin(), end = threads.end(); it != end; ++it) {
2973 Dbg::DdmSendThreadNotification(*it, CHUNK_TYPE("THCR"));
2974 }
2975 }
2976 ResumeVM();
Elliott Hughes47fce012011-10-25 18:37:19 -07002977 }
2978}
2979
Elliott Hughesa2155262011-11-16 16:26:58 -08002980void Dbg::PostThreadStartOrStop(Thread* t, uint32_t type) {
Elliott Hughesc0f09332012-03-26 13:27:06 -07002981 if (IsDebuggerActive()) {
Mathieu Chartierdbe6f462012-09-25 16:54:50 -07002982 ScopedObjectAccessUnchecked soa(Thread::Current());
Ian Rogerscfaa4552012-11-26 21:00:08 -08002983 JDWP::ObjectId id = gRegistry->Add(t->GetPeer());
Elliott Hughes82188472011-11-07 18:11:48 -08002984 gJdwpState->PostThreadChange(id, type == CHUNK_TYPE("THCR"));
Elliott Hughesc0f09332012-03-26 13:27:06 -07002985 // If this thread's just joined the party while we're already debugging, make sure it knows
2986 // to give us updates when it's running.
2987 t->SetDebuggerUpdatesEnabled(true);
Elliott Hughes47fce012011-10-25 18:37:19 -07002988 }
Elliott Hughes82188472011-11-07 18:11:48 -08002989 Dbg::DdmSendThreadNotification(t, type);
Elliott Hughes47fce012011-10-25 18:37:19 -07002990}
2991
2992void Dbg::PostThreadStart(Thread* t) {
Elliott Hughesa2155262011-11-16 16:26:58 -08002993 Dbg::PostThreadStartOrStop(t, CHUNK_TYPE("THCR"));
Elliott Hughes47fce012011-10-25 18:37:19 -07002994}
2995
2996void Dbg::PostThreadDeath(Thread* t) {
Elliott Hughesa2155262011-11-16 16:26:58 -08002997 Dbg::PostThreadStartOrStop(t, CHUNK_TYPE("THDE"));
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002998}
2999
Elliott Hughes82188472011-11-07 18:11:48 -08003000void Dbg::DdmSendChunk(uint32_t type, size_t byte_count, const uint8_t* buf) {
Elliott Hughes3bb81562011-10-21 18:52:59 -07003001 CHECK(buf != NULL);
3002 iovec vec[1];
3003 vec[0].iov_base = reinterpret_cast<void*>(const_cast<uint8_t*>(buf));
3004 vec[0].iov_len = byte_count;
3005 Dbg::DdmSendChunkV(type, vec, 1);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07003006}
3007
Elliott Hughes21f32d72011-11-09 17:44:13 -08003008void Dbg::DdmSendChunk(uint32_t type, const std::vector<uint8_t>& bytes) {
3009 DdmSendChunk(type, bytes.size(), &bytes[0]);
3010}
3011
Elliott Hughescccd84f2011-12-05 16:51:54 -08003012void Dbg::DdmSendChunkV(uint32_t type, const struct iovec* iov, int iov_count) {
Elliott Hughes3bb81562011-10-21 18:52:59 -07003013 if (gJdwpState == NULL) {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08003014 VLOG(jdwp) << "Debugger thread not active, ignoring DDM send: " << type;
Elliott Hughes3bb81562011-10-21 18:52:59 -07003015 } else {
Elliott Hughescccd84f2011-12-05 16:51:54 -08003016 gJdwpState->DdmSendChunkV(type, iov, iov_count);
Elliott Hughes3bb81562011-10-21 18:52:59 -07003017 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -07003018}
3019
Elliott Hughes767a1472011-10-26 18:49:02 -07003020int Dbg::DdmHandleHpifChunk(HpifWhen when) {
3021 if (when == HPIF_WHEN_NOW) {
Elliott Hughes7162ad92011-10-27 14:08:42 -07003022 DdmSendHeapInfo(when);
Elliott Hughes767a1472011-10-26 18:49:02 -07003023 return true;
3024 }
3025
3026 if (when != HPIF_WHEN_NEVER && when != HPIF_WHEN_NEXT_GC && when != HPIF_WHEN_EVERY_GC) {
3027 LOG(ERROR) << "invalid HpifWhen value: " << static_cast<int>(when);
3028 return false;
3029 }
3030
3031 gDdmHpifWhen = when;
3032 return true;
3033}
3034
3035bool Dbg::DdmHandleHpsgNhsgChunk(Dbg::HpsgWhen when, Dbg::HpsgWhat what, bool native) {
3036 if (when != HPSG_WHEN_NEVER && when != HPSG_WHEN_EVERY_GC) {
3037 LOG(ERROR) << "invalid HpsgWhen value: " << static_cast<int>(when);
3038 return false;
3039 }
3040
3041 if (what != HPSG_WHAT_MERGED_OBJECTS && what != HPSG_WHAT_DISTINCT_OBJECTS) {
3042 LOG(ERROR) << "invalid HpsgWhat value: " << static_cast<int>(what);
3043 return false;
3044 }
3045
3046 if (native) {
3047 gDdmNhsgWhen = when;
3048 gDdmNhsgWhat = what;
3049 } else {
3050 gDdmHpsgWhen = when;
3051 gDdmHpsgWhat = what;
3052 }
3053 return true;
3054}
3055
Elliott Hughes7162ad92011-10-27 14:08:42 -07003056void Dbg::DdmSendHeapInfo(HpifWhen reason) {
3057 // If there's a one-shot 'when', reset it.
3058 if (reason == gDdmHpifWhen) {
3059 if (gDdmHpifWhen == HPIF_WHEN_NEXT_GC) {
3060 gDdmHpifWhen = HPIF_WHEN_NEVER;
3061 }
3062 }
3063
3064 /*
3065 * Chunk HPIF (client --> server)
3066 *
3067 * Heap Info. General information about the heap,
3068 * suitable for a summary display.
3069 *
3070 * [u4]: number of heaps
3071 *
3072 * For each heap:
3073 * [u4]: heap ID
3074 * [u8]: timestamp in ms since Unix epoch
3075 * [u1]: capture reason (same as 'when' value from server)
3076 * [u4]: max heap size in bytes (-Xmx)
3077 * [u4]: current heap size in bytes
3078 * [u4]: current number of bytes allocated
3079 * [u4]: current number of objects allocated
3080 */
3081 uint8_t heap_count = 1;
Elliott Hughesb3bd5f02012-03-08 21:05:27 -08003082 Heap* heap = Runtime::Current()->GetHeap();
Elliott Hughes21f32d72011-11-09 17:44:13 -08003083 std::vector<uint8_t> bytes;
Elliott Hughes545a0642011-11-08 19:10:03 -08003084 JDWP::Append4BE(bytes, heap_count);
3085 JDWP::Append4BE(bytes, 1); // Heap id (bogus; we only have one heap).
3086 JDWP::Append8BE(bytes, MilliTime());
3087 JDWP::Append1BE(bytes, reason);
Elliott Hughesb3bd5f02012-03-08 21:05:27 -08003088 JDWP::Append4BE(bytes, heap->GetMaxMemory()); // Max allowed heap size in bytes.
3089 JDWP::Append4BE(bytes, heap->GetTotalMemory()); // Current heap size in bytes.
3090 JDWP::Append4BE(bytes, heap->GetBytesAllocated());
3091 JDWP::Append4BE(bytes, heap->GetObjectsAllocated());
Elliott Hughes21f32d72011-11-09 17:44:13 -08003092 CHECK_EQ(bytes.size(), 4U + (heap_count * (4 + 8 + 1 + 4 + 4 + 4 + 4)));
3093 Dbg::DdmSendChunk(CHUNK_TYPE("HPIF"), bytes);
Elliott Hughes767a1472011-10-26 18:49:02 -07003094}
3095
Elliott Hughes6a5bd492011-10-28 14:33:57 -07003096enum HpsgSolidity {
3097 SOLIDITY_FREE = 0,
3098 SOLIDITY_HARD = 1,
3099 SOLIDITY_SOFT = 2,
3100 SOLIDITY_WEAK = 3,
3101 SOLIDITY_PHANTOM = 4,
3102 SOLIDITY_FINALIZABLE = 5,
3103 SOLIDITY_SWEEP = 6,
3104};
3105
3106enum HpsgKind {
3107 KIND_OBJECT = 0,
3108 KIND_CLASS_OBJECT = 1,
3109 KIND_ARRAY_1 = 2,
3110 KIND_ARRAY_2 = 3,
3111 KIND_ARRAY_4 = 4,
3112 KIND_ARRAY_8 = 5,
3113 KIND_UNKNOWN = 6,
3114 KIND_NATIVE = 7,
3115};
3116
3117#define HPSG_PARTIAL (1<<7)
3118#define HPSG_STATE(solidity, kind) ((uint8_t)((((kind) & 0x7) << 3) | ((solidity) & 0x7)))
3119
Ian Rogers30fab402012-01-23 15:43:46 -08003120class HeapChunkContext {
3121 public:
Elliott Hughes6a5bd492011-10-28 14:33:57 -07003122 // Maximum chunk size. Obtain this from the formula:
3123 // (((maximum_heap_size / ALLOCATION_UNIT_SIZE) + 255) / 256) * 2
3124 HeapChunkContext(bool merge, bool native)
Ian Rogers30fab402012-01-23 15:43:46 -08003125 : buf_(16384 - 16),
3126 type_(0),
3127 merge_(merge) {
Elliott Hughes6a5bd492011-10-28 14:33:57 -07003128 Reset();
3129 if (native) {
Ian Rogers30fab402012-01-23 15:43:46 -08003130 type_ = CHUNK_TYPE("NHSG");
Elliott Hughes6a5bd492011-10-28 14:33:57 -07003131 } else {
Ian Rogers30fab402012-01-23 15:43:46 -08003132 type_ = merge ? CHUNK_TYPE("HPSG") : CHUNK_TYPE("HPSO");
Elliott Hughes6a5bd492011-10-28 14:33:57 -07003133 }
3134 }
3135
3136 ~HeapChunkContext() {
Ian Rogers30fab402012-01-23 15:43:46 -08003137 if (p_ > &buf_[0]) {
Elliott Hughes6a5bd492011-10-28 14:33:57 -07003138 Flush();
3139 }
3140 }
3141
3142 void EnsureHeader(const void* chunk_ptr) {
Ian Rogers30fab402012-01-23 15:43:46 -08003143 if (!needHeader_) {
Elliott Hughes6a5bd492011-10-28 14:33:57 -07003144 return;
3145 }
3146
3147 // Start a new HPSx chunk.
Ian Rogers30fab402012-01-23 15:43:46 -08003148 JDWP::Write4BE(&p_, 1); // Heap id (bogus; we only have one heap).
3149 JDWP::Write1BE(&p_, 8); // Size of allocation unit, in bytes.
Elliott Hughes6a5bd492011-10-28 14:33:57 -07003150
Ian Rogers30fab402012-01-23 15:43:46 -08003151 JDWP::Write4BE(&p_, reinterpret_cast<uintptr_t>(chunk_ptr)); // virtual address of segment start.
3152 JDWP::Write4BE(&p_, 0); // offset of this piece (relative to the virtual address).
Elliott Hughes6a5bd492011-10-28 14:33:57 -07003153 // [u4]: length of piece, in allocation units
3154 // 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 -08003155 pieceLenField_ = p_;
3156 JDWP::Write4BE(&p_, 0x55555555);
3157 needHeader_ = false;
Elliott Hughes6a5bd492011-10-28 14:33:57 -07003158 }
3159
Ian Rogersb726dcb2012-09-05 08:57:23 -07003160 void Flush() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughes6a5bd492011-10-28 14:33:57 -07003161 // Patch the "length of piece" field.
Ian Rogers30fab402012-01-23 15:43:46 -08003162 CHECK_LE(&buf_[0], pieceLenField_);
3163 CHECK_LE(pieceLenField_, p_);
3164 JDWP::Set4BE(pieceLenField_, totalAllocationUnits_);
Elliott Hughes6a5bd492011-10-28 14:33:57 -07003165
Ian Rogers30fab402012-01-23 15:43:46 -08003166 Dbg::DdmSendChunk(type_, p_ - &buf_[0], &buf_[0]);
Elliott Hughes6a5bd492011-10-28 14:33:57 -07003167 Reset();
3168 }
3169
Ian Rogers00f7d0e2012-07-19 15:28:27 -07003170 static void HeapChunkCallback(void* start, void* end, size_t used_bytes, void* arg)
Ian Rogersb726dcb2012-09-05 08:57:23 -07003171 SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_,
3172 Locks::mutator_lock_) {
Ian Rogers30fab402012-01-23 15:43:46 -08003173 reinterpret_cast<HeapChunkContext*>(arg)->HeapChunkCallback(start, end, used_bytes);
Elliott Hughesa2155262011-11-16 16:26:58 -08003174 }
3175
Elliott Hughes6a5bd492011-10-28 14:33:57 -07003176 private:
Elliott Hughesa2155262011-11-16 16:26:58 -08003177 enum { ALLOCATION_UNIT_SIZE = 8 };
3178
Elliott Hughes6a5bd492011-10-28 14:33:57 -07003179 void Reset() {
Ian Rogers30fab402012-01-23 15:43:46 -08003180 p_ = &buf_[0];
Ian Rogers15bf2d32012-08-28 17:33:04 -07003181 startOfNextMemoryChunk_ = NULL;
Ian Rogers30fab402012-01-23 15:43:46 -08003182 totalAllocationUnits_ = 0;
3183 needHeader_ = true;
3184 pieceLenField_ = NULL;
Elliott Hughes6a5bd492011-10-28 14:33:57 -07003185 }
3186
Ian Rogers00f7d0e2012-07-19 15:28:27 -07003187 void HeapChunkCallback(void* start, void* /*end*/, size_t used_bytes)
Ian Rogersb726dcb2012-09-05 08:57:23 -07003188 SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_,
3189 Locks::mutator_lock_) {
Ian Rogers30fab402012-01-23 15:43:46 -08003190 // Note: heap call backs cannot manipulate the heap upon which they are crawling, care is taken
3191 // in the following code not to allocate memory, by ensuring buf_ is of the correct size
Ian Rogers15bf2d32012-08-28 17:33:04 -07003192 if (used_bytes == 0) {
3193 if (start == NULL) {
3194 // Reset for start of new heap.
3195 startOfNextMemoryChunk_ = NULL;
3196 Flush();
3197 }
3198 // Only process in use memory so that free region information
3199 // also includes dlmalloc book keeping.
Elliott Hughesa2155262011-11-16 16:26:58 -08003200 return;
Elliott Hughesa2155262011-11-16 16:26:58 -08003201 }
3202
Ian Rogers15bf2d32012-08-28 17:33:04 -07003203 /* If we're looking at the native heap, we'll just return
3204 * (SOLIDITY_HARD, KIND_NATIVE) for all allocated chunks
3205 */
3206 bool native = type_ == CHUNK_TYPE("NHSG");
3207
3208 if (startOfNextMemoryChunk_ != NULL) {
3209 // Transmit any pending free memory. Native free memory of
3210 // over kMaxFreeLen could be because of the use of mmaps, so
3211 // don't report. If not free memory then start a new segment.
3212 bool flush = true;
3213 if (start > startOfNextMemoryChunk_) {
3214 const size_t kMaxFreeLen = 2 * kPageSize;
3215 void* freeStart = startOfNextMemoryChunk_;
3216 void* freeEnd = start;
3217 size_t freeLen = (char*)freeEnd - (char*)freeStart;
3218 if (!native || freeLen < kMaxFreeLen) {
3219 AppendChunk(HPSG_STATE(SOLIDITY_FREE, 0), freeStart, freeLen);
3220 flush = false;
3221 }
3222 }
3223 if (flush) {
3224 startOfNextMemoryChunk_ = NULL;
3225 Flush();
3226 }
3227 }
3228 const Object *obj = (const Object *)start;
Elliott Hughesa2155262011-11-16 16:26:58 -08003229
3230 // Determine the type of this chunk.
3231 // OLD-TODO: if context.merge, see if this chunk is different from the last chunk.
3232 // If it's the same, we should combine them.
Ian Rogers15bf2d32012-08-28 17:33:04 -07003233 uint8_t state = ExamineObject(obj, native);
3234 // dlmalloc's chunk header is 2 * sizeof(size_t), but if the previous chunk is in use for an
3235 // allocation then the first sizeof(size_t) may belong to it.
3236 const size_t dlMallocOverhead = sizeof(size_t);
3237 AppendChunk(state, start, used_bytes + dlMallocOverhead);
3238 startOfNextMemoryChunk_ = (char*)start + used_bytes + dlMallocOverhead;
3239 }
Elliott Hughesa2155262011-11-16 16:26:58 -08003240
Ian Rogers15bf2d32012-08-28 17:33:04 -07003241 void AppendChunk(uint8_t state, void* ptr, size_t length)
Ian Rogersb726dcb2012-09-05 08:57:23 -07003242 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers15bf2d32012-08-28 17:33:04 -07003243 // Make sure there's enough room left in the buffer.
3244 // We need to use two bytes for every fractional 256 allocation units used by the chunk plus
3245 // 17 bytes for any header.
3246 size_t needed = (((length/ALLOCATION_UNIT_SIZE + 255) / 256) * 2) + 17;
3247 size_t bytesLeft = buf_.size() - (size_t)(p_ - &buf_[0]);
3248 if (bytesLeft < needed) {
3249 Flush();
3250 }
3251
3252 bytesLeft = buf_.size() - (size_t)(p_ - &buf_[0]);
3253 if (bytesLeft < needed) {
3254 LOG(WARNING) << "Chunk is too big to transmit (chunk_len=" << length << ", "
3255 << needed << " bytes)";
3256 return;
3257 }
3258 EnsureHeader(ptr);
Elliott Hughesa2155262011-11-16 16:26:58 -08003259 // Write out the chunk description.
Ian Rogers15bf2d32012-08-28 17:33:04 -07003260 length /= ALLOCATION_UNIT_SIZE; // Convert to allocation units.
3261 totalAllocationUnits_ += length;
3262 while (length > 256) {
Ian Rogers30fab402012-01-23 15:43:46 -08003263 *p_++ = state | HPSG_PARTIAL;
3264 *p_++ = 255; // length - 1
Ian Rogers15bf2d32012-08-28 17:33:04 -07003265 length -= 256;
Elliott Hughesa2155262011-11-16 16:26:58 -08003266 }
Ian Rogers30fab402012-01-23 15:43:46 -08003267 *p_++ = state;
Ian Rogers15bf2d32012-08-28 17:33:04 -07003268 *p_++ = length - 1;
Elliott Hughes6a5bd492011-10-28 14:33:57 -07003269 }
3270
Ian Rogers5bfa60f2012-09-02 21:17:56 -07003271 uint8_t ExamineObject(const Object* o, bool is_native_heap)
Ian Rogersb726dcb2012-09-05 08:57:23 -07003272 SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_) {
Elliott Hughesa2155262011-11-16 16:26:58 -08003273 if (o == NULL) {
3274 return HPSG_STATE(SOLIDITY_FREE, 0);
3275 }
Elliott Hughes6a5bd492011-10-28 14:33:57 -07003276
Elliott Hughesa2155262011-11-16 16:26:58 -08003277 // It's an allocated chunk. Figure out what it is.
Elliott Hughes6a5bd492011-10-28 14:33:57 -07003278
Elliott Hughesa2155262011-11-16 16:26:58 -08003279 // If we're looking at the native heap, we'll just return
3280 // (SOLIDITY_HARD, KIND_NATIVE) for all allocated chunks.
Ian Rogers00f7d0e2012-07-19 15:28:27 -07003281 if (is_native_heap) {
Elliott Hughesa2155262011-11-16 16:26:58 -08003282 return HPSG_STATE(SOLIDITY_HARD, KIND_NATIVE);
3283 }
3284
Ian Rogers5bfa60f2012-09-02 21:17:56 -07003285 if (!Runtime::Current()->GetHeap()->IsLiveObjectLocked(o)) {
Ian Rogers15bf2d32012-08-28 17:33:04 -07003286 return HPSG_STATE(SOLIDITY_HARD, KIND_NATIVE);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07003287 }
3288
Elliott Hughesa2155262011-11-16 16:26:58 -08003289 Class* c = o->GetClass();
3290 if (c == NULL) {
3291 // The object was probably just created but hasn't been initialized yet.
3292 return HPSG_STATE(SOLIDITY_HARD, KIND_OBJECT);
3293 }
3294
Elliott Hughesb3bd5f02012-03-08 21:05:27 -08003295 if (!Runtime::Current()->GetHeap()->IsHeapAddress(c)) {
Ian Rogers15bf2d32012-08-28 17:33:04 -07003296 LOG(ERROR) << "Invalid class for managed heap object: " << o << " " << c;
Elliott Hughesa2155262011-11-16 16:26:58 -08003297 return HPSG_STATE(SOLIDITY_HARD, KIND_UNKNOWN);
3298 }
3299
3300 if (c->IsClassClass()) {
3301 return HPSG_STATE(SOLIDITY_HARD, KIND_CLASS_OBJECT);
3302 }
3303
3304 if (c->IsArrayClass()) {
3305 if (o->IsObjectArray()) {
3306 return HPSG_STATE(SOLIDITY_HARD, KIND_ARRAY_4);
3307 }
3308 switch (c->GetComponentSize()) {
3309 case 1: return HPSG_STATE(SOLIDITY_HARD, KIND_ARRAY_1);
3310 case 2: return HPSG_STATE(SOLIDITY_HARD, KIND_ARRAY_2);
3311 case 4: return HPSG_STATE(SOLIDITY_HARD, KIND_ARRAY_4);
3312 case 8: return HPSG_STATE(SOLIDITY_HARD, KIND_ARRAY_8);
3313 }
3314 }
3315
Elliott Hughes6a5bd492011-10-28 14:33:57 -07003316 return HPSG_STATE(SOLIDITY_HARD, KIND_OBJECT);
3317 }
3318
Ian Rogers30fab402012-01-23 15:43:46 -08003319 std::vector<uint8_t> buf_;
3320 uint8_t* p_;
3321 uint8_t* pieceLenField_;
Ian Rogers15bf2d32012-08-28 17:33:04 -07003322 void* startOfNextMemoryChunk_;
Ian Rogers30fab402012-01-23 15:43:46 -08003323 size_t totalAllocationUnits_;
3324 uint32_t type_;
3325 bool merge_;
3326 bool needHeader_;
3327
Elliott Hughesa2155262011-11-16 16:26:58 -08003328 DISALLOW_COPY_AND_ASSIGN(HeapChunkContext);
3329};
Elliott Hughes6a5bd492011-10-28 14:33:57 -07003330
3331void Dbg::DdmSendHeapSegments(bool native) {
3332 Dbg::HpsgWhen when;
3333 Dbg::HpsgWhat what;
3334 if (!native) {
3335 when = gDdmHpsgWhen;
3336 what = gDdmHpsgWhat;
3337 } else {
3338 when = gDdmNhsgWhen;
3339 what = gDdmNhsgWhat;
3340 }
3341 if (when == HPSG_WHEN_NEVER) {
3342 return;
3343 }
3344
3345 // Figure out what kind of chunks we'll be sending.
3346 CHECK(what == HPSG_WHAT_MERGED_OBJECTS || what == HPSG_WHAT_DISTINCT_OBJECTS) << static_cast<int>(what);
3347
3348 // First, send a heap start chunk.
3349 uint8_t heap_id[4];
3350 JDWP::Set4BE(&heap_id[0], 1); // Heap id (bogus; we only have one heap).
3351 Dbg::DdmSendChunk(native ? CHUNK_TYPE("NHST") : CHUNK_TYPE("HPST"), sizeof(heap_id), heap_id);
3352
3353 // Send a series of heap segment chunks.
Elliott Hughesa2155262011-11-16 16:26:58 -08003354 HeapChunkContext context((what == HPSG_WHAT_MERGED_OBJECTS), native);
3355 if (native) {
Ian Rogers30fab402012-01-23 15:43:46 -08003356 // TODO: enable when bionic has moved to dlmalloc 2.8.5
3357 // dlmalloc_inspect_all(HeapChunkContext::HeapChunkCallback, &context);
3358 UNIMPLEMENTED(WARNING) << "Native heap send heap segments";
Elliott Hughesa2155262011-11-16 16:26:58 -08003359 } else {
Elliott Hughesb3bd5f02012-03-08 21:05:27 -08003360 Heap* heap = Runtime::Current()->GetHeap();
Mathieu Chartierfd678be2012-08-30 14:50:54 -07003361 const Spaces& spaces = heap->GetSpaces();
Ian Rogers50b35e22012-10-04 10:09:15 -07003362 Thread* self = Thread::Current();
Mathieu Chartierfd678be2012-08-30 14:50:54 -07003363 for (Spaces::const_iterator cur = spaces.begin(); cur != spaces.end(); ++cur) {
Mathieu Chartierb062fdd2012-07-03 09:51:48 -07003364 if ((*cur)->IsAllocSpace()) {
Ian Rogers50b35e22012-10-04 10:09:15 -07003365 ReaderMutexLock mu(self, *Locks::heap_bitmap_lock_);
Mathieu Chartierb062fdd2012-07-03 09:51:48 -07003366 (*cur)->AsAllocSpace()->Walk(HeapChunkContext::HeapChunkCallback, &context);
3367 }
3368 }
Mathieu Chartiere0f0cb32012-08-28 11:26:00 -07003369 // Walk the large objects, these are not in the AllocSpace.
3370 heap->GetLargeObjectsSpace()->Walk(HeapChunkContext::HeapChunkCallback, &context);
Elliott Hughesa2155262011-11-16 16:26:58 -08003371 }
Elliott Hughes6a5bd492011-10-28 14:33:57 -07003372
3373 // Finally, send a heap end chunk.
3374 Dbg::DdmSendChunk(native ? CHUNK_TYPE("NHEN") : CHUNK_TYPE("HPEN"), sizeof(heap_id), heap_id);
Elliott Hughes767a1472011-10-26 18:49:02 -07003375}
3376
Elliott Hughes545a0642011-11-08 19:10:03 -08003377void Dbg::SetAllocTrackingEnabled(bool enabled) {
Ian Rogers50b35e22012-10-04 10:09:15 -07003378 MutexLock mu(Thread::Current(), gAllocTrackerLock);
Elliott Hughes545a0642011-11-08 19:10:03 -08003379 if (enabled) {
3380 if (recent_allocation_records_ == NULL) {
3381 LOG(INFO) << "Enabling alloc tracker (" << kNumAllocRecords << " entries, "
3382 << kMaxAllocRecordStackDepth << " frames --> "
3383 << (sizeof(AllocRecord) * kNumAllocRecords) << " bytes)";
3384 gAllocRecordHead = gAllocRecordCount = 0;
3385 recent_allocation_records_ = new AllocRecord[kNumAllocRecords];
3386 CHECK(recent_allocation_records_ != NULL);
3387 }
3388 } else {
3389 delete[] recent_allocation_records_;
3390 recent_allocation_records_ = NULL;
3391 }
3392}
3393
Ian Rogers0399dde2012-06-06 17:09:28 -07003394struct AllocRecordStackVisitor : public StackVisitor {
3395 AllocRecordStackVisitor(const ManagedStack* stack,
Ian Rogers306057f2012-11-26 12:45:53 -08003396 const std::deque<InstrumentationStackFrame>* instrumentation_stack,
3397 AllocRecord* record)
Ian Rogersb726dcb2012-09-05 08:57:23 -07003398 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
jeffhao725a9572012-11-13 18:20:12 -08003399 : StackVisitor(stack, instrumentation_stack, NULL), record(record), depth(0) {}
Elliott Hughes545a0642011-11-08 19:10:03 -08003400
Ian Rogers00f7d0e2012-07-19 15:28:27 -07003401 // TODO: Enable annotalysis. We know lock is held in constructor, but abstraction confuses
3402 // annotalysis.
3403 bool VisitFrame() NO_THREAD_SAFETY_ANALYSIS {
Elliott Hughes545a0642011-11-08 19:10:03 -08003404 if (depth >= kMaxAllocRecordStackDepth) {
Elliott Hughes530fa002012-03-12 11:44:49 -07003405 return false;
Elliott Hughes545a0642011-11-08 19:10:03 -08003406 }
Mathieu Chartier66f19252012-09-18 08:57:04 -07003407 AbstractMethod* m = GetMethod();
Ian Rogers0399dde2012-06-06 17:09:28 -07003408 if (!m->IsRuntimeMethod()) {
3409 record->stack[depth].method = m;
3410 record->stack[depth].dex_pc = GetDexPc();
Elliott Hughes530fa002012-03-12 11:44:49 -07003411 ++depth;
Elliott Hughes545a0642011-11-08 19:10:03 -08003412 }
Elliott Hughes530fa002012-03-12 11:44:49 -07003413 return true;
Elliott Hughes545a0642011-11-08 19:10:03 -08003414 }
3415
3416 ~AllocRecordStackVisitor() {
3417 // Clear out any unused stack trace elements.
3418 for (; depth < kMaxAllocRecordStackDepth; ++depth) {
3419 record->stack[depth].method = NULL;
Ian Rogers0399dde2012-06-06 17:09:28 -07003420 record->stack[depth].dex_pc = 0;
Elliott Hughes545a0642011-11-08 19:10:03 -08003421 }
3422 }
3423
3424 AllocRecord* record;
3425 size_t depth;
3426};
3427
3428void Dbg::RecordAllocation(Class* type, size_t byte_count) {
3429 Thread* self = Thread::Current();
3430 CHECK(self != NULL);
3431
Ian Rogers50b35e22012-10-04 10:09:15 -07003432 MutexLock mu(self, gAllocTrackerLock);
Elliott Hughes545a0642011-11-08 19:10:03 -08003433 if (recent_allocation_records_ == NULL) {
3434 return;
3435 }
3436
3437 // Advance and clip.
3438 if (++gAllocRecordHead == kNumAllocRecords) {
3439 gAllocRecordHead = 0;
3440 }
3441
3442 // Fill in the basics.
3443 AllocRecord* record = &recent_allocation_records_[gAllocRecordHead];
3444 record->type = type;
3445 record->byte_count = byte_count;
3446 record->thin_lock_id = self->GetThinLockId();
3447
3448 // Fill in the stack trace.
jeffhao725a9572012-11-13 18:20:12 -08003449 AllocRecordStackVisitor visitor(self->GetManagedStack(), self->GetInstrumentationStack(), record);
Ian Rogers0399dde2012-06-06 17:09:28 -07003450 visitor.WalkStack();
Elliott Hughes545a0642011-11-08 19:10:03 -08003451
3452 if (gAllocRecordCount < kNumAllocRecords) {
3453 ++gAllocRecordCount;
3454 }
3455}
3456
Elliott Hughesa8f93cb2012-06-08 17:08:48 -07003457// Returns the index of the head element.
3458//
3459// We point at the most-recently-written record, so if gAllocRecordCount is 1
3460// we want to use the current element. Take "head+1" and subtract count
3461// from it.
3462//
3463// We need to handle underflow in our circular buffer, so we add
3464// kNumAllocRecords and then mask it back down.
Elliott Hughesf8349362012-06-18 15:00:06 -07003465static inline int HeadIndex() EXCLUSIVE_LOCKS_REQUIRED(gAllocTrackerLock) {
Elliott Hughes545a0642011-11-08 19:10:03 -08003466 return (gAllocRecordHead+1 + kNumAllocRecords - gAllocRecordCount) & (kNumAllocRecords-1);
3467}
3468
3469void Dbg::DumpRecentAllocations() {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07003470 ScopedObjectAccess soa(Thread::Current());
Ian Rogers50b35e22012-10-04 10:09:15 -07003471 MutexLock mu(soa.Self(), gAllocTrackerLock);
Elliott Hughes545a0642011-11-08 19:10:03 -08003472 if (recent_allocation_records_ == NULL) {
3473 LOG(INFO) << "Not recording tracked allocations";
3474 return;
3475 }
3476
3477 // "i" is the head of the list. We want to start at the end of the
3478 // list and move forward to the tail.
Elliott Hughesa8f93cb2012-06-08 17:08:48 -07003479 size_t i = HeadIndex();
Elliott Hughes545a0642011-11-08 19:10:03 -08003480 size_t count = gAllocRecordCount;
3481
3482 LOG(INFO) << "Tracked allocations, (head=" << gAllocRecordHead << " count=" << count << ")";
3483 while (count--) {
3484 AllocRecord* record = &recent_allocation_records_[i];
3485
Elliott Hughesa8f93cb2012-06-08 17:08:48 -07003486 LOG(INFO) << StringPrintf(" Thread %-2d %6zd bytes ", record->thin_lock_id, record->byte_count)
Elliott Hughes545a0642011-11-08 19:10:03 -08003487 << PrettyClass(record->type);
3488
3489 for (size_t stack_frame = 0; stack_frame < kMaxAllocRecordStackDepth; ++stack_frame) {
Mathieu Chartier66f19252012-09-18 08:57:04 -07003490 const AbstractMethod* m = record->stack[stack_frame].method;
Elliott Hughes545a0642011-11-08 19:10:03 -08003491 if (m == NULL) {
3492 break;
3493 }
3494 LOG(INFO) << " " << PrettyMethod(m) << " line " << record->stack[stack_frame].LineNumber();
3495 }
3496
3497 // pause periodically to help logcat catch up
3498 if ((count % 5) == 0) {
3499 usleep(40000);
3500 }
3501
3502 i = (i + 1) & (kNumAllocRecords-1);
3503 }
3504}
3505
3506class StringTable {
3507 public:
3508 StringTable() {
3509 }
3510
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003511 void Add(const char* s) {
Elliott Hughes545a0642011-11-08 19:10:03 -08003512 table_.insert(s);
3513 }
3514
Elliott Hughesa8f93cb2012-06-08 17:08:48 -07003515 size_t IndexOf(const char* s) const {
3516 typedef std::set<std::string>::const_iterator It; // TODO: C++0x auto
3517 It it = table_.find(s);
3518 if (it == table_.end()) {
3519 LOG(FATAL) << "IndexOf(\"" << s << "\") failed";
3520 }
3521 return std::distance(table_.begin(), it);
Elliott Hughes545a0642011-11-08 19:10:03 -08003522 }
3523
Elliott Hughesa8f93cb2012-06-08 17:08:48 -07003524 size_t Size() const {
Elliott Hughes545a0642011-11-08 19:10:03 -08003525 return table_.size();
3526 }
3527
Elliott Hughesa8f93cb2012-06-08 17:08:48 -07003528 void WriteTo(std::vector<uint8_t>& bytes) const {
3529 typedef std::set<std::string>::const_iterator It; // TODO: C++0x auto
Elliott Hughes545a0642011-11-08 19:10:03 -08003530 for (It it = table_.begin(); it != table_.end(); ++it) {
Elliott Hughesa8f93cb2012-06-08 17:08:48 -07003531 const char* s = (*it).c_str();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003532 size_t s_len = CountModifiedUtf8Chars(s);
3533 UniquePtr<uint16_t> s_utf16(new uint16_t[s_len]);
3534 ConvertModifiedUtf8ToUtf16(s_utf16.get(), s);
3535 JDWP::AppendUtf16BE(bytes, s_utf16.get(), s_len);
Elliott Hughes545a0642011-11-08 19:10:03 -08003536 }
3537 }
3538
3539 private:
Elliott Hughesa8f93cb2012-06-08 17:08:48 -07003540 std::set<std::string> table_;
Elliott Hughes545a0642011-11-08 19:10:03 -08003541 DISALLOW_COPY_AND_ASSIGN(StringTable);
3542};
3543
3544/*
3545 * The data we send to DDMS contains everything we have recorded.
3546 *
3547 * Message header (all values big-endian):
3548 * (1b) message header len (to allow future expansion); includes itself
3549 * (1b) entry header len
3550 * (1b) stack frame len
3551 * (2b) number of entries
3552 * (4b) offset to string table from start of message
3553 * (2b) number of class name strings
3554 * (2b) number of method name strings
3555 * (2b) number of source file name strings
3556 * For each entry:
3557 * (4b) total allocation size
Elliott Hughes221229c2013-01-08 18:17:50 -08003558 * (2b) thread id
Elliott Hughes545a0642011-11-08 19:10:03 -08003559 * (2b) allocated object's class name index
3560 * (1b) stack depth
3561 * For each stack frame:
3562 * (2b) method's class name
3563 * (2b) method name
3564 * (2b) method source file
3565 * (2b) line number, clipped to 32767; -2 if native; -1 if no source
3566 * (xb) class name strings
3567 * (xb) method name strings
3568 * (xb) source file strings
3569 *
3570 * As with other DDM traffic, strings are sent as a 4-byte length
3571 * followed by UTF-16 data.
3572 *
3573 * We send up 16-bit unsigned indexes into string tables. In theory there
3574 * can be (kMaxAllocRecordStackDepth * kNumAllocRecords) unique strings in
3575 * each table, but in practice there should be far fewer.
3576 *
3577 * The chief reason for using a string table here is to keep the size of
3578 * the DDMS message to a minimum. This is partly to make the protocol
3579 * efficient, but also because we have to form the whole thing up all at
3580 * once in a memory buffer.
3581 *
3582 * We use separate string tables for class names, method names, and source
3583 * files to keep the indexes small. There will generally be no overlap
3584 * between the contents of these tables.
3585 */
3586jbyteArray Dbg::GetRecentAllocations() {
3587 if (false) {
3588 DumpRecentAllocations();
3589 }
3590
Ian Rogers50b35e22012-10-04 10:09:15 -07003591 Thread* self = Thread::Current();
3592 MutexLock mu(self, gAllocTrackerLock);
Elliott Hughes545a0642011-11-08 19:10:03 -08003593
Elliott Hughesa8f93cb2012-06-08 17:08:48 -07003594 //
3595 // Part 1: generate string tables.
3596 //
Elliott Hughes545a0642011-11-08 19:10:03 -08003597 StringTable class_names;
3598 StringTable method_names;
3599 StringTable filenames;
3600
3601 int count = gAllocRecordCount;
Elliott Hughesa8f93cb2012-06-08 17:08:48 -07003602 int idx = HeadIndex();
Elliott Hughes545a0642011-11-08 19:10:03 -08003603 while (count--) {
3604 AllocRecord* record = &recent_allocation_records_[idx];
3605
Elliott Hughes91250e02011-12-13 22:30:35 -08003606 class_names.Add(ClassHelper(record->type).GetDescriptor());
Elliott Hughes545a0642011-11-08 19:10:03 -08003607
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003608 MethodHelper mh;
Elliott Hughes545a0642011-11-08 19:10:03 -08003609 for (size_t i = 0; i < kMaxAllocRecordStackDepth; i++) {
Mathieu Chartier66f19252012-09-18 08:57:04 -07003610 AbstractMethod* m = record->stack[i].method;
Elliott Hughes545a0642011-11-08 19:10:03 -08003611 if (m != NULL) {
Ian Rogersba377812012-05-28 21:16:29 -07003612 mh.ChangeMethod(m);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003613 class_names.Add(mh.GetDeclaringClassDescriptor());
3614 method_names.Add(mh.GetName());
3615 filenames.Add(mh.GetDeclaringClassSourceFile());
Elliott Hughes545a0642011-11-08 19:10:03 -08003616 }
3617 }
3618
3619 idx = (idx + 1) & (kNumAllocRecords-1);
3620 }
3621
3622 LOG(INFO) << "allocation records: " << gAllocRecordCount;
3623
Elliott Hughesa8f93cb2012-06-08 17:08:48 -07003624 //
3625 // Part 2: allocate a buffer and generate the output.
3626 //
Elliott Hughes545a0642011-11-08 19:10:03 -08003627 std::vector<uint8_t> bytes;
3628
3629 // (1b) message header len (to allow future expansion); includes itself
3630 // (1b) entry header len
3631 // (1b) stack frame len
3632 const int kMessageHeaderLen = 15;
3633 const int kEntryHeaderLen = 9;
3634 const int kStackFrameLen = 8;
3635 JDWP::Append1BE(bytes, kMessageHeaderLen);
3636 JDWP::Append1BE(bytes, kEntryHeaderLen);
3637 JDWP::Append1BE(bytes, kStackFrameLen);
3638
3639 // (2b) number of entries
3640 // (4b) offset to string table from start of message
3641 // (2b) number of class name strings
3642 // (2b) number of method name strings
3643 // (2b) number of source file name strings
3644 JDWP::Append2BE(bytes, gAllocRecordCount);
3645 size_t string_table_offset = bytes.size();
3646 JDWP::Append4BE(bytes, 0); // We'll patch this later...
3647 JDWP::Append2BE(bytes, class_names.Size());
3648 JDWP::Append2BE(bytes, method_names.Size());
3649 JDWP::Append2BE(bytes, filenames.Size());
3650
3651 count = gAllocRecordCount;
Elliott Hughesa8f93cb2012-06-08 17:08:48 -07003652 idx = HeadIndex();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003653 ClassHelper kh;
Elliott Hughes545a0642011-11-08 19:10:03 -08003654 while (count--) {
3655 // For each entry:
3656 // (4b) total allocation size
3657 // (2b) thread id
3658 // (2b) allocated object's class name index
3659 // (1b) stack depth
3660 AllocRecord* record = &recent_allocation_records_[idx];
3661 size_t stack_depth = record->GetDepth();
Elliott Hughesa8f93cb2012-06-08 17:08:48 -07003662 kh.ChangeClass(record->type);
3663 size_t allocated_object_class_name_index = class_names.IndexOf(kh.GetDescriptor());
Elliott Hughes545a0642011-11-08 19:10:03 -08003664 JDWP::Append4BE(bytes, record->byte_count);
3665 JDWP::Append2BE(bytes, record->thin_lock_id);
Elliott Hughesa8f93cb2012-06-08 17:08:48 -07003666 JDWP::Append2BE(bytes, allocated_object_class_name_index);
Elliott Hughes545a0642011-11-08 19:10:03 -08003667 JDWP::Append1BE(bytes, stack_depth);
3668
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003669 MethodHelper mh;
Elliott Hughes545a0642011-11-08 19:10:03 -08003670 for (size_t stack_frame = 0; stack_frame < stack_depth; ++stack_frame) {
3671 // For each stack frame:
3672 // (2b) method's class name
3673 // (2b) method name
3674 // (2b) method source file
3675 // (2b) line number, clipped to 32767; -2 if native; -1 if no source
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003676 mh.ChangeMethod(record->stack[stack_frame].method);
Elliott Hughesa8f93cb2012-06-08 17:08:48 -07003677 size_t class_name_index = class_names.IndexOf(mh.GetDeclaringClassDescriptor());
3678 size_t method_name_index = method_names.IndexOf(mh.GetName());
3679 size_t file_name_index = filenames.IndexOf(mh.GetDeclaringClassSourceFile());
3680 JDWP::Append2BE(bytes, class_name_index);
3681 JDWP::Append2BE(bytes, method_name_index);
3682 JDWP::Append2BE(bytes, file_name_index);
Elliott Hughes545a0642011-11-08 19:10:03 -08003683 JDWP::Append2BE(bytes, record->stack[stack_frame].LineNumber());
3684 }
3685
3686 idx = (idx + 1) & (kNumAllocRecords-1);
3687 }
3688
3689 // (xb) class name strings
3690 // (xb) method name strings
3691 // (xb) source file strings
3692 JDWP::Set4BE(&bytes[string_table_offset], bytes.size());
3693 class_names.WriteTo(bytes);
3694 method_names.WriteTo(bytes);
3695 filenames.WriteTo(bytes);
3696
Ian Rogers50b35e22012-10-04 10:09:15 -07003697 JNIEnv* env = self->GetJniEnv();
Elliott Hughes545a0642011-11-08 19:10:03 -08003698 jbyteArray result = env->NewByteArray(bytes.size());
3699 if (result != NULL) {
3700 env->SetByteArrayRegion(result, 0, bytes.size(), reinterpret_cast<const jbyte*>(&bytes[0]));
3701 }
3702 return result;
3703}
3704
Elliott Hughes872d4ec2011-10-21 17:07:15 -07003705} // namespace art