blob: 84770542992f5e7f6f9d8e5266bdac0a977981ea [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"
26#if !defined(ART_USE_LLVM_COMPILER)
27#include "oat/runtime/context.h" // For VmapTable
28#endif
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 Rogers30fab402012-01-23 15:43:46 -080034#include "space.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));
57 MutexLock mu(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() {
63 MutexLock mu(lock_);
64 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) {
69 MutexLock mu(lock_);
70 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
Elliott Hughesa2155262011-11-16 16:26:58 -080078 MutexLock mu(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) {
85 MutexLock mu(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.
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700180static Mutex gBreakpointsLock DEFAULT_MUTEX_ACQUIRED_AFTER ("breakpoints lock");
Elliott Hughesf8349362012-06-18 15:00:06 -0700181static std::vector<Breakpoint> gBreakpoints GUARDED_BY(gBreakpointsLock);
182static SingleStepControl gSingleStepControl GUARDED_BY(gBreakpointsLock);
Elliott Hughes86964332012-02-15 19:37:42 -0800183
Mathieu Chartier66f19252012-09-18 08:57:04 -0700184static bool IsBreakpoint(AbstractMethod* m, uint32_t dex_pc)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700185 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughes86964332012-02-15 19:37:42 -0800186 MutexLock mu(gBreakpointsLock);
187 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
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700196static Array* DecodeArray(JDWP::RefTypeId id, JDWP::JdwpError& status)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700197 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughes436e3722012-02-17 20:01:47 -0800198 Object* o = gRegistry->Get<Object*>(id);
199 if (o == NULL || o == kInvalidObject) {
200 status = JDWP::ERR_INVALID_OBJECT;
201 return NULL;
202 }
203 if (!o->IsArrayInstance()) {
204 status = JDWP::ERR_INVALID_ARRAY;
205 return NULL;
206 }
207 status = JDWP::ERR_NONE;
208 return o->AsArray();
209}
210
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700211static Class* DecodeClass(JDWP::RefTypeId id, JDWP::JdwpError& status)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700212 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughes436e3722012-02-17 20:01:47 -0800213 Object* o = gRegistry->Get<Object*>(id);
214 if (o == NULL || o == kInvalidObject) {
215 status = JDWP::ERR_INVALID_OBJECT;
216 return NULL;
217 }
218 if (!o->IsClass()) {
219 status = JDWP::ERR_INVALID_CLASS;
220 return NULL;
221 }
222 status = JDWP::ERR_NONE;
223 return o->AsClass();
224}
225
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700226static Thread* DecodeThread(ScopedObjectAccessUnchecked& soa, JDWP::ObjectId threadId)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700227 LOCKS_EXCLUDED(Locks::thread_suspend_count_lock_)
228 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughes436e3722012-02-17 20:01:47 -0800229 Object* thread_peer = gRegistry->Get<Object*>(threadId);
230 if (thread_peer == NULL || thread_peer == kInvalidObject) {
231 return NULL;
232 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700233 Thread* thread = Thread::FromManagedThread(soa, thread_peer);
234 return thread;
Elliott Hughes436e3722012-02-17 20:01:47 -0800235}
236
Elliott Hughes24437992011-11-30 14:49:33 -0800237static JDWP::JdwpTag BasicTagFromDescriptor(const char* descriptor) {
238 // JDWP deliberately uses the descriptor characters' ASCII values for its enum.
239 // Note that by "basic" we mean that we don't get more specific than JT_OBJECT.
240 return static_cast<JDWP::JdwpTag>(descriptor[0]);
241}
242
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700243static JDWP::JdwpTag TagFromClass(Class* c)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700244 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughes86b00102011-12-05 17:54:26 -0800245 CHECK(c != NULL);
Elliott Hughes24437992011-11-30 14:49:33 -0800246 if (c->IsArrayClass()) {
247 return JDWP::JT_ARRAY;
248 }
249
Elliott Hughes3d30d9b2011-12-07 17:35:48 -0800250 ClassLinker* class_linker = Runtime::Current()->GetClassLinker();
Elliott Hughes24437992011-11-30 14:49:33 -0800251 if (c->IsStringClass()) {
252 return JDWP::JT_STRING;
253 } else if (c->IsClassClass()) {
254 return JDWP::JT_CLASS_OBJECT;
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -0800255 } else if (class_linker->FindSystemClass("Ljava/lang/Thread;")->IsAssignableFrom(c)) {
Elliott Hughes24437992011-11-30 14:49:33 -0800256 return JDWP::JT_THREAD;
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -0800257 } else if (class_linker->FindSystemClass("Ljava/lang/ThreadGroup;")->IsAssignableFrom(c)) {
Elliott Hughes24437992011-11-30 14:49:33 -0800258 return JDWP::JT_THREAD_GROUP;
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -0800259 } else if (class_linker->FindSystemClass("Ljava/lang/ClassLoader;")->IsAssignableFrom(c)) {
Elliott Hughes24437992011-11-30 14:49:33 -0800260 return JDWP::JT_CLASS_LOADER;
Elliott Hughes24437992011-11-30 14:49:33 -0800261 } else {
262 return JDWP::JT_OBJECT;
263 }
264}
265
266/*
267 * Objects declared to hold Object might actually hold a more specific
268 * type. The debugger may take a special interest in these (e.g. it
269 * wants to display the contents of Strings), so we want to return an
270 * appropriate tag.
271 *
272 * Null objects are tagged JT_OBJECT.
273 */
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700274static JDWP::JdwpTag TagFromObject(const Object* o)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700275 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughes24437992011-11-30 14:49:33 -0800276 return (o == NULL) ? JDWP::JT_OBJECT : TagFromClass(o->GetClass());
277}
278
279static bool IsPrimitiveTag(JDWP::JdwpTag tag) {
280 switch (tag) {
281 case JDWP::JT_BOOLEAN:
282 case JDWP::JT_BYTE:
283 case JDWP::JT_CHAR:
284 case JDWP::JT_FLOAT:
285 case JDWP::JT_DOUBLE:
286 case JDWP::JT_INT:
287 case JDWP::JT_LONG:
288 case JDWP::JT_SHORT:
289 case JDWP::JT_VOID:
290 return true;
291 default:
292 return false;
293 }
294}
295
Elliott Hughes3bb81562011-10-21 18:52:59 -0700296/*
297 * Handle one of the JDWP name/value pairs.
298 *
299 * JDWP options are:
300 * help: if specified, show help message and bail
301 * transport: may be dt_socket or dt_shmem
302 * address: for dt_socket, "host:port", or just "port" when listening
303 * server: if "y", wait for debugger to attach; if "n", attach to debugger
304 * timeout: how long to wait for debugger to connect / listen
305 *
306 * Useful with server=n (these aren't supported yet):
307 * onthrow=<exception-name>: connect to debugger when exception thrown
308 * onuncaught=y|n: connect to debugger when uncaught exception thrown
309 * launch=<command-line>: launch the debugger itself
310 *
311 * The "transport" option is required, as is "address" if server=n.
312 */
313static bool ParseJdwpOption(const std::string& name, const std::string& value) {
314 if (name == "transport") {
315 if (value == "dt_socket") {
Elliott Hughes376a7a02011-10-24 18:35:55 -0700316 gJdwpOptions.transport = JDWP::kJdwpTransportSocket;
Elliott Hughes3bb81562011-10-21 18:52:59 -0700317 } else if (value == "dt_android_adb") {
Elliott Hughes376a7a02011-10-24 18:35:55 -0700318 gJdwpOptions.transport = JDWP::kJdwpTransportAndroidAdb;
Elliott Hughes3bb81562011-10-21 18:52:59 -0700319 } else {
320 LOG(ERROR) << "JDWP transport not supported: " << value;
321 return false;
322 }
323 } else if (name == "server") {
324 if (value == "n") {
Elliott Hughes376a7a02011-10-24 18:35:55 -0700325 gJdwpOptions.server = false;
Elliott Hughes3bb81562011-10-21 18:52:59 -0700326 } else if (value == "y") {
Elliott Hughes376a7a02011-10-24 18:35:55 -0700327 gJdwpOptions.server = true;
Elliott Hughes3bb81562011-10-21 18:52:59 -0700328 } else {
329 LOG(ERROR) << "JDWP option 'server' must be 'y' or 'n'";
330 return false;
331 }
332 } else if (name == "suspend") {
333 if (value == "n") {
Elliott Hughes376a7a02011-10-24 18:35:55 -0700334 gJdwpOptions.suspend = false;
Elliott Hughes3bb81562011-10-21 18:52:59 -0700335 } else if (value == "y") {
Elliott Hughes376a7a02011-10-24 18:35:55 -0700336 gJdwpOptions.suspend = true;
Elliott Hughes3bb81562011-10-21 18:52:59 -0700337 } else {
338 LOG(ERROR) << "JDWP option 'suspend' must be 'y' or 'n'";
339 return false;
340 }
341 } else if (name == "address") {
342 /* this is either <port> or <host>:<port> */
343 std::string port_string;
Elliott Hughes376a7a02011-10-24 18:35:55 -0700344 gJdwpOptions.host.clear();
Elliott Hughes3bb81562011-10-21 18:52:59 -0700345 std::string::size_type colon = value.find(':');
346 if (colon != std::string::npos) {
Elliott Hughes376a7a02011-10-24 18:35:55 -0700347 gJdwpOptions.host = value.substr(0, colon);
Elliott Hughes3bb81562011-10-21 18:52:59 -0700348 port_string = value.substr(colon + 1);
349 } else {
350 port_string = value;
351 }
352 if (port_string.empty()) {
353 LOG(ERROR) << "JDWP address missing port: " << value;
354 return false;
355 }
356 char* end;
Elliott Hughesba8eee12012-01-24 20:25:24 -0800357 uint64_t port = strtoul(port_string.c_str(), &end, 10);
358 if (*end != '\0' || port > 0xffff) {
Elliott Hughes3bb81562011-10-21 18:52:59 -0700359 LOG(ERROR) << "JDWP address has junk in port field: " << value;
360 return false;
361 }
Elliott Hughes376a7a02011-10-24 18:35:55 -0700362 gJdwpOptions.port = port;
Elliott Hughes3bb81562011-10-21 18:52:59 -0700363 } else if (name == "launch" || name == "onthrow" || name == "oncaught" || name == "timeout") {
364 /* valid but unsupported */
365 LOG(INFO) << "Ignoring JDWP option '" << name << "'='" << value << "'";
366 } else {
367 LOG(INFO) << "Ignoring unrecognized JDWP option '" << name << "'='" << value << "'";
368 }
369
370 return true;
371}
372
373/*
374 * Parse the latter half of a -Xrunjdwp/-agentlib:jdwp= string, e.g.:
375 * "transport=dt_socket,address=8000,server=y,suspend=n"
376 */
377bool Dbg::ParseJdwpOptions(const std::string& options) {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800378 VLOG(jdwp) << "ParseJdwpOptions: " << options;
Elliott Hughes47fce012011-10-25 18:37:19 -0700379
Elliott Hughes3bb81562011-10-21 18:52:59 -0700380 std::vector<std::string> pairs;
381 Split(options, ',', pairs);
382
383 for (size_t i = 0; i < pairs.size(); ++i) {
384 std::string::size_type equals = pairs[i].find('=');
385 if (equals == std::string::npos) {
386 LOG(ERROR) << "Can't parse JDWP option '" << pairs[i] << "' in '" << options << "'";
387 return false;
388 }
389 ParseJdwpOption(pairs[i].substr(0, equals), pairs[i].substr(equals + 1));
390 }
391
Elliott Hughes376a7a02011-10-24 18:35:55 -0700392 if (gJdwpOptions.transport == JDWP::kJdwpTransportUnknown) {
Elliott Hughes3bb81562011-10-21 18:52:59 -0700393 LOG(ERROR) << "Must specify JDWP transport: " << options;
394 }
Elliott Hughes376a7a02011-10-24 18:35:55 -0700395 if (!gJdwpOptions.server && (gJdwpOptions.host.empty() || gJdwpOptions.port == 0)) {
Elliott Hughes3bb81562011-10-21 18:52:59 -0700396 LOG(ERROR) << "Must specify JDWP host and port when server=n: " << options;
397 return false;
398 }
399
400 gJdwpConfigured = true;
401 return true;
402}
403
Elliott Hughesd1cc8362011-10-24 16:58:50 -0700404void Dbg::StartJdwp() {
Elliott Hughesc0f09332012-03-26 13:27:06 -0700405 if (!gJdwpAllowed || !IsJdwpConfigured()) {
Elliott Hughes376a7a02011-10-24 18:35:55 -0700406 // No JDWP for you!
407 return;
408 }
409
Elliott Hughes475fc232011-10-25 15:00:35 -0700410 CHECK(gRegistry == NULL);
411 gRegistry = new ObjectRegistry;
412
Elliott Hughesd1cc8362011-10-24 16:58:50 -0700413 // Init JDWP if the debugger is enabled. This may connect out to a
414 // debugger, passively listen for a debugger, or block waiting for a
415 // debugger.
Elliott Hughes376a7a02011-10-24 18:35:55 -0700416 gJdwpState = JDWP::JdwpState::Create(&gJdwpOptions);
417 if (gJdwpState == NULL) {
Elliott Hughesf8a2df72011-12-01 12:19:54 -0800418 // We probably failed because some other process has the port already, which means that
419 // if we don't abort the user is likely to think they're talking to us when they're actually
420 // talking to that other process.
Elliott Hughes3d30d9b2011-12-07 17:35:48 -0800421 LOG(FATAL) << "Debugger thread failed to initialize";
Elliott Hughesd1cc8362011-10-24 16:58:50 -0700422 }
423
424 // If a debugger has already attached, send the "welcome" message.
425 // This may cause us to suspend all threads.
Elliott Hughes376a7a02011-10-24 18:35:55 -0700426 if (gJdwpState->IsActive()) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700427 ScopedObjectAccess soa(Thread::Current());
Elliott Hughes376a7a02011-10-24 18:35:55 -0700428 if (!gJdwpState->PostVMStart()) {
Elliott Hughes3d30d9b2011-12-07 17:35:48 -0800429 LOG(WARNING) << "Failed to post 'start' message to debugger";
Elliott Hughesd1cc8362011-10-24 16:58:50 -0700430 }
431 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700432}
433
Elliott Hughesd1cc8362011-10-24 16:58:50 -0700434void Dbg::StopJdwp() {
Elliott Hughes376a7a02011-10-24 18:35:55 -0700435 delete gJdwpState;
Elliott Hughes475fc232011-10-25 15:00:35 -0700436 delete gRegistry;
437 gRegistry = NULL;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700438}
439
Elliott Hughes767a1472011-10-26 18:49:02 -0700440void Dbg::GcDidFinish() {
441 if (gDdmHpifWhen != HPIF_WHEN_NEVER) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700442 ScopedObjectAccess soa(Thread::Current());
Elliott Hughes81ff3182012-03-23 20:35:56 -0700443 LOG(DEBUG) << "Sending heap info to DDM";
Elliott Hughes7162ad92011-10-27 14:08:42 -0700444 DdmSendHeapInfo(gDdmHpifWhen);
Elliott Hughes767a1472011-10-26 18:49:02 -0700445 }
446 if (gDdmHpsgWhen != HPSG_WHEN_NEVER) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700447 ScopedObjectAccess soa(Thread::Current());
Elliott Hughes81ff3182012-03-23 20:35:56 -0700448 LOG(DEBUG) << "Dumping heap to DDM";
Elliott Hughes6a5bd492011-10-28 14:33:57 -0700449 DdmSendHeapSegments(false);
Elliott Hughes767a1472011-10-26 18:49:02 -0700450 }
451 if (gDdmNhsgWhen != HPSG_WHEN_NEVER) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700452 ScopedObjectAccess soa(Thread::Current());
Elliott Hughes767a1472011-10-26 18:49:02 -0700453 LOG(DEBUG) << "Dumping native heap to DDM";
Elliott Hughes6a5bd492011-10-28 14:33:57 -0700454 DdmSendHeapSegments(true);
Elliott Hughes767a1472011-10-26 18:49:02 -0700455 }
456}
457
Elliott Hughes4ffd3132011-10-24 12:06:42 -0700458void Dbg::SetJdwpAllowed(bool allowed) {
459 gJdwpAllowed = allowed;
460}
461
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700462DebugInvokeReq* Dbg::GetInvokeReq() {
Elliott Hughes475fc232011-10-25 15:00:35 -0700463 return Thread::Current()->GetInvokeReq();
464}
465
466Thread* Dbg::GetDebugThread() {
467 return (gJdwpState != NULL) ? gJdwpState->GetDebugThread() : NULL;
468}
469
470void Dbg::ClearWaitForEventThread() {
471 gJdwpState->ClearWaitForEventThread();
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700472}
473
474void Dbg::Connected() {
Elliott Hughes3bb81562011-10-21 18:52:59 -0700475 CHECK(!gDebuggerConnected);
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -0800476 VLOG(jdwp) << "JDWP has attached";
Elliott Hughes3bb81562011-10-21 18:52:59 -0700477 gDebuggerConnected = true;
Elliott Hughes86964332012-02-15 19:37:42 -0800478 gDisposed = false;
479}
480
481void Dbg::Disposed() {
482 gDisposed = true;
483}
484
485bool Dbg::IsDisposed() {
486 return gDisposed;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700487}
488
Elliott Hughesc0f09332012-03-26 13:27:06 -0700489static void SetDebuggerUpdatesEnabledCallback(Thread* t, void* user_data) {
490 t->SetDebuggerUpdatesEnabled(*reinterpret_cast<bool*>(user_data));
491}
492
493static void SetDebuggerUpdatesEnabled(bool enabled) {
Ian Rogersb726dcb2012-09-05 08:57:23 -0700494 MutexLock mu(*Locks::thread_list_lock_);
Elliott Hughesf8349362012-06-18 15:00:06 -0700495 Runtime::Current()->GetThreadList()->ForEach(SetDebuggerUpdatesEnabledCallback, &enabled);
Elliott Hughesc0f09332012-03-26 13:27:06 -0700496}
497
Elliott Hughesa2155262011-11-16 16:26:58 -0800498void Dbg::GoActive() {
499 // Enable all debugging features, including scans for breakpoints.
500 // This is a no-op if we're already active.
501 // Only called from the JDWP handler thread.
502 if (gDebuggerActive) {
503 return;
504 }
505
506 LOG(INFO) << "Debugger is active";
507
Elliott Hughesc0f09332012-03-26 13:27:06 -0700508 {
509 // TODO: dalvik only warned if there were breakpoints left over. clear in Dbg::Disconnected?
510 MutexLock mu(gBreakpointsLock);
511 CHECK_EQ(gBreakpoints.size(), 0U);
512 }
Elliott Hughesa2155262011-11-16 16:26:58 -0800513
514 gDebuggerActive = true;
Elliott Hughesc0f09332012-03-26 13:27:06 -0700515 SetDebuggerUpdatesEnabled(true);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700516}
517
518void Dbg::Disconnected() {
Elliott Hughes234ab152011-10-26 14:02:26 -0700519 CHECK(gDebuggerConnected);
520
Elliott Hughesc0f09332012-03-26 13:27:06 -0700521 LOG(INFO) << "Debugger is no longer active";
Elliott Hughes234ab152011-10-26 14:02:26 -0700522
Elliott Hughesc0f09332012-03-26 13:27:06 -0700523 gDebuggerActive = false;
524 SetDebuggerUpdatesEnabled(false);
Elliott Hughes234ab152011-10-26 14:02:26 -0700525
526 gRegistry->Clear();
527 gDebuggerConnected = false;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700528}
529
Elliott Hughesc0f09332012-03-26 13:27:06 -0700530bool Dbg::IsDebuggerActive() {
Elliott Hughes3bb81562011-10-21 18:52:59 -0700531 return gDebuggerActive;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700532}
533
Elliott Hughesc0f09332012-03-26 13:27:06 -0700534bool Dbg::IsJdwpConfigured() {
Elliott Hughes3bb81562011-10-21 18:52:59 -0700535 return gJdwpConfigured;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700536}
537
538int64_t Dbg::LastDebuggerActivity() {
Elliott Hughesca951522011-12-05 12:01:32 -0800539 return gJdwpState->LastDebuggerActivity();
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700540}
541
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700542void Dbg::UndoDebuggerSuspensions() {
Elliott Hughes234ab152011-10-26 14:02:26 -0700543 Runtime::Current()->GetThreadList()->UndoDebuggerSuspensions();
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700544}
545
546void Dbg::Exit(int status) {
Elliott Hughes1bba14f2011-12-01 18:00:36 -0800547 exit(status); // This is all dalvik did.
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700548}
549
Elliott Hughesbfe487b2011-10-26 15:48:55 -0700550void Dbg::VisitRoots(Heap::RootVisitor* visitor, void* arg) {
551 if (gRegistry != NULL) {
552 gRegistry->VisitRoots(visitor, arg);
553 }
554}
555
Elliott Hughesc308a5d2012-02-16 17:12:06 -0800556std::string Dbg::GetClassName(JDWP::RefTypeId classId) {
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800557 Object* o = gRegistry->Get<Object*>(classId);
Elliott Hughes436e3722012-02-17 20:01:47 -0800558 if (o == NULL) {
559 return "NULL";
560 }
561 if (o == kInvalidObject) {
562 return StringPrintf("invalid object %p", reinterpret_cast<void*>(classId));
563 }
564 if (!o->IsClass()) {
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800565 return StringPrintf("non-class %p", o); // This is only used for debugging output anyway.
566 }
Elliott Hughesc308a5d2012-02-16 17:12:06 -0800567 return DescriptorToName(ClassHelper(o->AsClass()).GetDescriptor());
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700568}
569
Elliott Hughes436e3722012-02-17 20:01:47 -0800570JDWP::JdwpError Dbg::GetClassObject(JDWP::RefTypeId id, JDWP::ObjectId& classObjectId) {
571 JDWP::JdwpError status;
572 Class* c = DecodeClass(id, status);
573 if (c == NULL) {
574 return status;
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800575 }
Elliott Hughes436e3722012-02-17 20:01:47 -0800576 classObjectId = gRegistry->Add(c);
577 return JDWP::ERR_NONE;
Elliott Hughes86964332012-02-15 19:37:42 -0800578}
579
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -0800580JDWP::JdwpError Dbg::GetSuperclass(JDWP::RefTypeId id, JDWP::RefTypeId& superclassId) {
581 JDWP::JdwpError status;
582 Class* c = DecodeClass(id, status);
583 if (c == NULL) {
584 return status;
585 }
586 if (c->IsInterface()) {
587 // http://code.google.com/p/android/issues/detail?id=20856
Elliott Hughesa0933622012-04-17 10:46:02 -0700588 superclassId = 0;
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -0800589 } else {
590 superclassId = gRegistry->Add(c->GetSuperClass());
591 }
592 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700593}
594
Elliott Hughes436e3722012-02-17 20:01:47 -0800595JDWP::JdwpError Dbg::GetClassLoader(JDWP::RefTypeId id, JDWP::ExpandBuf* pReply) {
Elliott Hughes1bba14f2011-12-01 18:00:36 -0800596 Object* o = gRegistry->Get<Object*>(id);
Elliott Hughes436e3722012-02-17 20:01:47 -0800597 if (o == NULL || o == kInvalidObject) {
598 return JDWP::ERR_INVALID_OBJECT;
599 }
600 expandBufAddObjectId(pReply, gRegistry->Add(o->GetClass()->GetClassLoader()));
601 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700602}
603
Elliott Hughes436e3722012-02-17 20:01:47 -0800604JDWP::JdwpError Dbg::GetModifiers(JDWP::RefTypeId id, JDWP::ExpandBuf* pReply) {
605 JDWP::JdwpError status;
606 Class* c = DecodeClass(id, status);
607 if (c == NULL) {
608 return status;
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800609 }
Elliott Hughes436e3722012-02-17 20:01:47 -0800610
611 uint32_t access_flags = c->GetAccessFlags() & kAccJavaFlagsMask;
612
613 // Set ACC_SUPER; dex files don't contain this flag, but all classes are supposed to have it set.
614 // Class.getModifiers doesn't return it, but JDWP does, so we set it here.
615 access_flags |= kAccSuper;
616
617 expandBufAdd4BE(pReply, access_flags);
618
619 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700620}
621
Elliott Hughes436e3722012-02-17 20:01:47 -0800622JDWP::JdwpError Dbg::GetReflectedType(JDWP::RefTypeId classId, JDWP::ExpandBuf* pReply) {
623 JDWP::JdwpError status;
624 Class* c = DecodeClass(classId, status);
625 if (c == NULL) {
626 return status;
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800627 }
Elliott Hughes436e3722012-02-17 20:01:47 -0800628
629 expandBufAdd1(pReply, c->IsInterface() ? JDWP::TT_INTERFACE : JDWP::TT_CLASS);
630 expandBufAddRefTypeId(pReply, classId);
631 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700632}
633
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800634void Dbg::GetClassList(std::vector<JDWP::RefTypeId>& classes) {
Elliott Hughesa2155262011-11-16 16:26:58 -0800635 // Get the complete list of reference classes (i.e. all classes except
636 // the primitive types).
637 // Returns a newly-allocated buffer full of RefTypeId values.
638 struct ClassListCreator {
Elliott Hughesba8eee12012-01-24 20:25:24 -0800639 explicit ClassListCreator(std::vector<JDWP::RefTypeId>& classes) : classes(classes) {
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800640 }
641
Elliott Hughesa2155262011-11-16 16:26:58 -0800642 static bool Visit(Class* c, void* arg) {
643 return reinterpret_cast<ClassListCreator*>(arg)->Visit(c);
644 }
645
646 bool Visit(Class* c) {
647 if (!c->IsPrimitive()) {
648 classes.push_back(static_cast<JDWP::RefTypeId>(gRegistry->Add(c)));
649 }
650 return true;
651 }
652
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800653 std::vector<JDWP::RefTypeId>& classes;
Elliott Hughesa2155262011-11-16 16:26:58 -0800654 };
655
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800656 ClassListCreator clc(classes);
Elliott Hughesa2155262011-11-16 16:26:58 -0800657 Runtime::Current()->GetClassLinker()->VisitClasses(ClassListCreator::Visit, &clc);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700658}
659
Elliott Hughes436e3722012-02-17 20:01:47 -0800660JDWP::JdwpError Dbg::GetClassInfo(JDWP::RefTypeId classId, JDWP::JdwpTypeTag* pTypeTag, uint32_t* pStatus, std::string* pDescriptor) {
661 JDWP::JdwpError status;
662 Class* c = DecodeClass(classId, status);
663 if (c == NULL) {
664 return status;
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800665 }
666
Elliott Hughesa2155262011-11-16 16:26:58 -0800667 if (c->IsArrayClass()) {
668 *pStatus = JDWP::CS_VERIFIED | JDWP::CS_PREPARED;
669 *pTypeTag = JDWP::TT_ARRAY;
670 } else {
671 if (c->IsErroneous()) {
672 *pStatus = JDWP::CS_ERROR;
673 } else {
674 *pStatus = JDWP::CS_VERIFIED | JDWP::CS_PREPARED | JDWP::CS_INITIALIZED;
675 }
676 *pTypeTag = c->IsInterface() ? JDWP::TT_INTERFACE : JDWP::TT_CLASS;
677 }
678
679 if (pDescriptor != NULL) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800680 *pDescriptor = ClassHelper(c).GetDescriptor();
Elliott Hughesa2155262011-11-16 16:26:58 -0800681 }
Elliott Hughes436e3722012-02-17 20:01:47 -0800682 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700683}
684
Elliott Hughesc3b77c72011-12-15 20:56:48 -0800685void Dbg::FindLoadedClassBySignature(const char* descriptor, std::vector<JDWP::RefTypeId>& ids) {
Elliott Hughes6fa602d2011-12-02 17:54:25 -0800686 std::vector<Class*> classes;
687 Runtime::Current()->GetClassLinker()->LookupClasses(descriptor, classes);
688 ids.clear();
689 for (size_t i = 0; i < classes.size(); ++i) {
690 ids.push_back(gRegistry->Add(classes[i]));
691 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700692}
693
Elliott Hughes2435a572012-02-17 16:07:41 -0800694JDWP::JdwpError Dbg::GetReferenceType(JDWP::ObjectId objectId, JDWP::ExpandBuf* pReply) {
Elliott Hughes499c5132011-11-17 14:55:11 -0800695 Object* o = gRegistry->Get<Object*>(objectId);
Elliott Hughes436e3722012-02-17 20:01:47 -0800696 if (o == NULL || o == kInvalidObject) {
Elliott Hughes2435a572012-02-17 16:07:41 -0800697 return JDWP::ERR_INVALID_OBJECT;
Elliott Hughes499c5132011-11-17 14:55:11 -0800698 }
Elliott Hughes2435a572012-02-17 16:07:41 -0800699
700 JDWP::JdwpTypeTag type_tag;
701 if (o->GetClass()->IsArrayClass()) {
702 type_tag = JDWP::TT_ARRAY;
703 } else if (o->GetClass()->IsInterface()) {
704 type_tag = JDWP::TT_INTERFACE;
705 } else {
706 type_tag = JDWP::TT_CLASS;
707 }
708 JDWP::RefTypeId type_id = gRegistry->Add(o->GetClass());
709
710 expandBufAdd1(pReply, type_tag);
711 expandBufAddRefTypeId(pReply, type_id);
712
713 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700714}
715
Elliott Hughes436e3722012-02-17 20:01:47 -0800716JDWP::JdwpError Dbg::GetSignature(JDWP::RefTypeId classId, std::string& signature) {
Elliott Hughes1fe7afb2012-02-13 17:23:03 -0800717 JDWP::JdwpError status;
Elliott Hughes436e3722012-02-17 20:01:47 -0800718 Class* c = DecodeClass(classId, status);
Elliott Hughes1fe7afb2012-02-13 17:23:03 -0800719 if (c == NULL) {
720 return status;
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800721 }
Elliott Hughes1fe7afb2012-02-13 17:23:03 -0800722 signature = ClassHelper(c).GetDescriptor();
723 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700724}
725
Elliott Hughes436e3722012-02-17 20:01:47 -0800726JDWP::JdwpError Dbg::GetSourceFile(JDWP::RefTypeId classId, std::string& result) {
727 JDWP::JdwpError status;
728 Class* c = DecodeClass(classId, status);
729 if (c == NULL) {
730 return status;
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800731 }
Elliott Hughes436e3722012-02-17 20:01:47 -0800732 result = ClassHelper(c).GetSourceFile();
733 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700734}
735
Elliott Hughes546b9862012-06-20 16:06:13 -0700736JDWP::JdwpError Dbg::GetObjectTag(JDWP::ObjectId objectId, uint8_t& tag) {
Elliott Hughes24437992011-11-30 14:49:33 -0800737 Object* o = gRegistry->Get<Object*>(objectId);
Elliott Hughes546b9862012-06-20 16:06:13 -0700738 if (o == kInvalidObject) {
739 return JDWP::ERR_INVALID_OBJECT;
740 }
741 tag = TagFromObject(o);
742 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700743}
744
Elliott Hughesaed4be92011-12-02 16:16:23 -0800745size_t Dbg::GetTagWidth(JDWP::JdwpTag tag) {
Elliott Hughesdbb40792011-11-18 17:05:22 -0800746 switch (tag) {
747 case JDWP::JT_VOID:
748 return 0;
749 case JDWP::JT_BYTE:
750 case JDWP::JT_BOOLEAN:
751 return 1;
752 case JDWP::JT_CHAR:
753 case JDWP::JT_SHORT:
754 return 2;
755 case JDWP::JT_FLOAT:
756 case JDWP::JT_INT:
757 return 4;
758 case JDWP::JT_ARRAY:
759 case JDWP::JT_OBJECT:
760 case JDWP::JT_STRING:
761 case JDWP::JT_THREAD:
762 case JDWP::JT_THREAD_GROUP:
763 case JDWP::JT_CLASS_LOADER:
764 case JDWP::JT_CLASS_OBJECT:
765 return sizeof(JDWP::ObjectId);
766 case JDWP::JT_DOUBLE:
767 case JDWP::JT_LONG:
768 return 8;
769 default:
Elliott Hughes3d30d9b2011-12-07 17:35:48 -0800770 LOG(FATAL) << "Unknown tag " << tag;
Elliott Hughesdbb40792011-11-18 17:05:22 -0800771 return -1;
772 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700773}
774
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -0800775JDWP::JdwpError Dbg::GetArrayLength(JDWP::ObjectId arrayId, int& length) {
776 JDWP::JdwpError status;
777 Array* a = DecodeArray(arrayId, status);
778 if (a == NULL) {
779 return status;
Elliott Hughes24437992011-11-30 14:49:33 -0800780 }
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -0800781 length = a->GetLength();
782 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700783}
784
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -0800785JDWP::JdwpError Dbg::OutputArray(JDWP::ObjectId arrayId, int offset, int count, JDWP::ExpandBuf* pReply) {
786 JDWP::JdwpError status;
787 Array* a = DecodeArray(arrayId, status);
788 if (a == NULL) {
789 return status;
790 }
Elliott Hughes24437992011-11-30 14:49:33 -0800791
792 if (offset < 0 || count < 0 || offset > a->GetLength() || a->GetLength() - offset < count) {
793 LOG(WARNING) << __FUNCTION__ << " access out of bounds: offset=" << offset << "; count=" << count;
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -0800794 return JDWP::ERR_INVALID_LENGTH;
Elliott Hughes24437992011-11-30 14:49:33 -0800795 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800796 std::string descriptor(ClassHelper(a->GetClass()).GetDescriptor());
Elliott Hughes24437992011-11-30 14:49:33 -0800797 JDWP::JdwpTag tag = BasicTagFromDescriptor(descriptor.c_str() + 1);
798
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -0800799 expandBufAdd1(pReply, tag);
800 expandBufAdd4BE(pReply, count);
801
Elliott Hughes24437992011-11-30 14:49:33 -0800802 if (IsPrimitiveTag(tag)) {
803 size_t width = GetTagWidth(tag);
Elliott Hughes24437992011-11-30 14:49:33 -0800804 uint8_t* dst = expandBufAddSpace(pReply, count * width);
805 if (width == 8) {
Ian Rogersa15e67d2012-02-28 13:51:55 -0800806 const uint64_t* src8 = reinterpret_cast<uint64_t*>(a->GetRawData(sizeof(uint64_t)));
Elliott Hughes24437992011-11-30 14:49:33 -0800807 for (int i = 0; i < count; ++i) JDWP::Write8BE(&dst, src8[offset + i]);
808 } else if (width == 4) {
Ian Rogersa15e67d2012-02-28 13:51:55 -0800809 const uint32_t* src4 = reinterpret_cast<uint32_t*>(a->GetRawData(sizeof(uint32_t)));
Elliott Hughes24437992011-11-30 14:49:33 -0800810 for (int i = 0; i < count; ++i) JDWP::Write4BE(&dst, src4[offset + i]);
811 } else if (width == 2) {
Ian Rogersa15e67d2012-02-28 13:51:55 -0800812 const uint16_t* src2 = reinterpret_cast<uint16_t*>(a->GetRawData(sizeof(uint16_t)));
Elliott Hughes24437992011-11-30 14:49:33 -0800813 for (int i = 0; i < count; ++i) JDWP::Write2BE(&dst, src2[offset + i]);
814 } else {
Ian Rogersa15e67d2012-02-28 13:51:55 -0800815 const uint8_t* src = reinterpret_cast<uint8_t*>(a->GetRawData(sizeof(uint8_t)));
Elliott Hughes24437992011-11-30 14:49:33 -0800816 memcpy(dst, &src[offset * width], count * width);
817 }
818 } else {
819 ObjectArray<Object>* oa = a->AsObjectArray<Object>();
820 for (int i = 0; i < count; ++i) {
Elliott Hughesf03b8f62011-12-02 14:26:25 -0800821 Object* element = oa->Get(offset + i);
Elliott Hughes24437992011-11-30 14:49:33 -0800822 JDWP::JdwpTag specific_tag = (element != NULL) ? TagFromObject(element) : tag;
823 expandBufAdd1(pReply, specific_tag);
824 expandBufAddObjectId(pReply, gRegistry->Add(element));
825 }
826 }
827
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -0800828 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700829}
830
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700831JDWP::JdwpError Dbg::SetArrayElements(JDWP::ObjectId arrayId, int offset, int count,
832 const uint8_t* src)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700833 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -0800834 JDWP::JdwpError status;
835 Array* a = DecodeArray(arrayId, status);
836 if (a == NULL) {
837 return status;
838 }
Elliott Hughesf03b8f62011-12-02 14:26:25 -0800839
840 if (offset < 0 || count < 0 || offset > a->GetLength() || a->GetLength() - offset < count) {
841 LOG(WARNING) << __FUNCTION__ << " access out of bounds: offset=" << offset << "; count=" << count;
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -0800842 return JDWP::ERR_INVALID_LENGTH;
Elliott Hughesf03b8f62011-12-02 14:26:25 -0800843 }
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800844 std::string descriptor(ClassHelper(a->GetClass()).GetDescriptor());
Elliott Hughesf03b8f62011-12-02 14:26:25 -0800845 JDWP::JdwpTag tag = BasicTagFromDescriptor(descriptor.c_str() + 1);
846
847 if (IsPrimitiveTag(tag)) {
848 size_t width = GetTagWidth(tag);
Elliott Hughesf03b8f62011-12-02 14:26:25 -0800849 if (width == 8) {
Ian Rogersa15e67d2012-02-28 13:51:55 -0800850 uint8_t* dst = &(reinterpret_cast<uint8_t*>(a->GetRawData(sizeof(uint64_t)))[offset * width]);
Elliott Hughesf03b8f62011-12-02 14:26:25 -0800851 for (int i = 0; i < count; ++i) {
852 // Handle potentially non-aligned memory access one byte at a time for ARM's benefit.
853 uint64_t value;
854 for (size_t j = 0; j < sizeof(uint64_t); ++j) reinterpret_cast<uint8_t*>(&value)[j] = src[j];
855 src += sizeof(uint64_t);
856 JDWP::Write8BE(&dst, value);
857 }
858 } else if (width == 4) {
Ian Rogersa15e67d2012-02-28 13:51:55 -0800859 uint8_t* dst = &(reinterpret_cast<uint8_t*>(a->GetRawData(sizeof(uint32_t)))[offset * width]);
Elliott Hughesf03b8f62011-12-02 14:26:25 -0800860 const uint32_t* src4 = reinterpret_cast<const uint32_t*>(src);
861 for (int i = 0; i < count; ++i) JDWP::Write4BE(&dst, src4[i]);
862 } else if (width == 2) {
Ian Rogersa15e67d2012-02-28 13:51:55 -0800863 uint8_t* dst = &(reinterpret_cast<uint8_t*>(a->GetRawData(sizeof(uint16_t)))[offset * width]);
Elliott Hughesf03b8f62011-12-02 14:26:25 -0800864 const uint16_t* src2 = reinterpret_cast<const uint16_t*>(src);
865 for (int i = 0; i < count; ++i) JDWP::Write2BE(&dst, src2[i]);
866 } else {
Ian Rogersa15e67d2012-02-28 13:51:55 -0800867 uint8_t* dst = &(reinterpret_cast<uint8_t*>(a->GetRawData(sizeof(uint8_t)))[offset * width]);
Elliott Hughesf03b8f62011-12-02 14:26:25 -0800868 memcpy(&dst[offset * width], src, count * width);
869 }
870 } else {
871 ObjectArray<Object>* oa = a->AsObjectArray<Object>();
872 for (int i = 0; i < count; ++i) {
873 JDWP::ObjectId id = JDWP::ReadObjectId(&src);
Elliott Hughes436e3722012-02-17 20:01:47 -0800874 Object* o = gRegistry->Get<Object*>(id);
875 if (o == kInvalidObject) {
876 return JDWP::ERR_INVALID_OBJECT;
877 }
878 oa->Set(offset + i, o);
Elliott Hughesf03b8f62011-12-02 14:26:25 -0800879 }
880 }
881
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -0800882 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700883}
884
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800885JDWP::ObjectId Dbg::CreateString(const std::string& str) {
886 return gRegistry->Add(String::AllocFromModifiedUtf8(str.c_str()));
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700887}
888
Elliott Hughes436e3722012-02-17 20:01:47 -0800889JDWP::JdwpError Dbg::CreateObject(JDWP::RefTypeId classId, JDWP::ObjectId& new_object) {
890 JDWP::JdwpError status;
891 Class* c = DecodeClass(classId, status);
892 if (c == NULL) {
893 return status;
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800894 }
Elliott Hughes436e3722012-02-17 20:01:47 -0800895 new_object = gRegistry->Add(c->AllocObject());
896 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700897}
898
Elliott Hughesbf13d362011-12-08 15:51:37 -0800899/*
900 * Used by Eclipse's "Display" view to evaluate "new byte[5]" to get "(byte[]) [0, 0, 0, 0, 0]".
901 */
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700902JDWP::JdwpError Dbg::CreateArrayObject(JDWP::RefTypeId arrayClassId, uint32_t length,
903 JDWP::ObjectId& new_array) {
Elliott Hughes436e3722012-02-17 20:01:47 -0800904 JDWP::JdwpError status;
905 Class* c = DecodeClass(arrayClassId, status);
906 if (c == NULL) {
907 return status;
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -0800908 }
Elliott Hughes436e3722012-02-17 20:01:47 -0800909 new_array = gRegistry->Add(Array::Alloc(c, length));
910 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700911}
912
913bool Dbg::MatchType(JDWP::RefTypeId instClassId, JDWP::RefTypeId classId) {
Elliott Hughes436e3722012-02-17 20:01:47 -0800914 JDWP::JdwpError status;
915 Class* c1 = DecodeClass(instClassId, status);
Elliott Hughesa656a0f2012-02-21 18:03:44 -0800916 CHECK(c1 != NULL);
Elliott Hughes436e3722012-02-17 20:01:47 -0800917 Class* c2 = DecodeClass(classId, status);
Elliott Hughesa656a0f2012-02-21 18:03:44 -0800918 CHECK(c2 != NULL);
919 return c1->IsAssignableFrom(c2);
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700920}
921
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700922static JDWP::FieldId ToFieldId(const Field* f)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700923 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughes03181a82011-11-17 17:22:21 -0800924#ifdef MOVING_GARBAGE_COLLECTOR
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700925 UNIMPLEMENTED(FATAL);
Elliott Hughes03181a82011-11-17 17:22:21 -0800926#else
927 return static_cast<JDWP::FieldId>(reinterpret_cast<uintptr_t>(f));
928#endif
929}
930
Mathieu Chartier66f19252012-09-18 08:57:04 -0700931static JDWP::MethodId ToMethodId(const AbstractMethod* m)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700932 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughes03181a82011-11-17 17:22:21 -0800933#ifdef MOVING_GARBAGE_COLLECTOR
934 UNIMPLEMENTED(FATAL);
935#else
936 return static_cast<JDWP::MethodId>(reinterpret_cast<uintptr_t>(m));
937#endif
938}
939
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700940static Field* FromFieldId(JDWP::FieldId fid)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700941 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughesaed4be92011-12-02 16:16:23 -0800942#ifdef MOVING_GARBAGE_COLLECTOR
943 UNIMPLEMENTED(FATAL);
944#else
945 return reinterpret_cast<Field*>(static_cast<uintptr_t>(fid));
946#endif
947}
948
Mathieu Chartier66f19252012-09-18 08:57:04 -0700949static AbstractMethod* FromMethodId(JDWP::MethodId mid)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700950 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughes03181a82011-11-17 17:22:21 -0800951#ifdef MOVING_GARBAGE_COLLECTOR
952 UNIMPLEMENTED(FATAL);
953#else
Mathieu Chartier66f19252012-09-18 08:57:04 -0700954 return reinterpret_cast<AbstractMethod*>(static_cast<uintptr_t>(mid));
Elliott Hughes03181a82011-11-17 17:22:21 -0800955#endif
956}
957
Mathieu Chartier66f19252012-09-18 08:57:04 -0700958static void SetLocation(JDWP::JdwpLocation& location, AbstractMethod* m, uint32_t dex_pc)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700959 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughes91bf6cd2012-02-14 17:27:48 -0800960 if (m == NULL) {
961 memset(&location, 0, sizeof(location));
962 } else {
963 Class* c = m->GetDeclaringClass();
Elliott Hughes74847412012-06-20 18:10:21 -0700964 location.type_tag = c->IsInterface() ? JDWP::TT_INTERFACE : JDWP::TT_CLASS;
965 location.class_id = gRegistry->Add(c);
966 location.method_id = ToMethodId(m);
Ian Rogers0399dde2012-06-06 17:09:28 -0700967 location.dex_pc = dex_pc;
Elliott Hughes91bf6cd2012-02-14 17:27:48 -0800968 }
Elliott Hughesd07986f2011-12-06 18:27:45 -0800969}
970
Ian Rogers00f7d0e2012-07-19 15:28:27 -0700971std::string Dbg::GetMethodName(JDWP::RefTypeId, JDWP::MethodId methodId)
Ian Rogersb726dcb2012-09-05 08:57:23 -0700972 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Mathieu Chartier66f19252012-09-18 08:57:04 -0700973 AbstractMethod* m = FromMethodId(methodId);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -0800974 return MethodHelper(m).GetName();
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700975}
976
Elliott Hughesa2e54f62011-11-17 13:01:30 -0800977/*
978 * Augment the access flags for synthetic methods and fields by setting
979 * the (as described by the spec) "0xf0000000 bit". Also, strip out any
980 * flags not specified by the Java programming language.
981 */
982static uint32_t MangleAccessFlags(uint32_t accessFlags) {
983 accessFlags &= kAccJavaFlagsMask;
984 if ((accessFlags & kAccSynthetic) != 0) {
985 accessFlags |= 0xf0000000;
986 }
987 return accessFlags;
Elliott Hughes872d4ec2011-10-21 17:07:15 -0700988}
989
Elliott Hughesdbb40792011-11-18 17:05:22 -0800990static const uint16_t kEclipseWorkaroundSlot = 1000;
991
992/*
993 * Eclipse appears to expect that the "this" reference is in slot zero.
994 * If it's not, the "variables" display will show two copies of "this",
995 * possibly because it gets "this" from SF.ThisObject and then displays
996 * all locals with nonzero slot numbers.
997 *
998 * So, we remap the item in slot 0 to 1000, and remap "this" to zero. On
999 * SF.GetValues / SF.SetValues we map them back.
Elliott Hughesc5b734a2011-12-01 17:20:58 -08001000 *
1001 * TODO: jdb uses the value to determine whether a variable is a local or an argument,
1002 * by checking whether it's less than the number of arguments. To make that work, we'd
1003 * have to "mangle" all the arguments to come first, not just the implicit argument 'this'.
Elliott Hughesdbb40792011-11-18 17:05:22 -08001004 */
1005static uint16_t MangleSlot(uint16_t slot, const char* name) {
1006 uint16_t newSlot = slot;
1007 if (strcmp(name, "this") == 0) {
1008 newSlot = 0;
1009 } else if (slot == 0) {
1010 newSlot = kEclipseWorkaroundSlot;
1011 }
1012 return newSlot;
1013}
1014
Mathieu Chartier66f19252012-09-18 08:57:04 -07001015static uint16_t DemangleSlot(uint16_t slot, AbstractMethod* m)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001016 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughesdbb40792011-11-18 17:05:22 -08001017 if (slot == kEclipseWorkaroundSlot) {
Elliott Hughes68fdbd02011-11-29 19:22:47 -08001018 return 0;
Elliott Hughesdbb40792011-11-18 17:05:22 -08001019 } else if (slot == 0) {
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08001020 const DexFile::CodeItem* code_item = MethodHelper(m).GetCodeItem();
Elliott Hughescaf76542012-06-28 16:08:22 -07001021 CHECK(code_item != NULL) << PrettyMethod(m);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001022 return code_item->registers_size_ - code_item->ins_size_;
Elliott Hughesdbb40792011-11-18 17:05:22 -08001023 }
Elliott Hughes68fdbd02011-11-29 19:22:47 -08001024 return slot;
Elliott Hughesdbb40792011-11-18 17:05:22 -08001025}
1026
Elliott Hughes436e3722012-02-17 20:01:47 -08001027JDWP::JdwpError Dbg::OutputDeclaredFields(JDWP::RefTypeId classId, bool with_generic, JDWP::ExpandBuf* pReply) {
1028 JDWP::JdwpError status;
1029 Class* c = DecodeClass(classId, status);
1030 if (c == NULL) {
1031 return status;
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -08001032 }
Elliott Hughesa2e54f62011-11-17 13:01:30 -08001033
1034 size_t instance_field_count = c->NumInstanceFields();
1035 size_t static_field_count = c->NumStaticFields();
1036
1037 expandBufAdd4BE(pReply, instance_field_count + static_field_count);
1038
1039 for (size_t i = 0; i < instance_field_count + static_field_count; ++i) {
1040 Field* f = (i < instance_field_count) ? c->GetInstanceField(i) : c->GetStaticField(i - instance_field_count);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001041 FieldHelper fh(f);
Elliott Hughesa2e54f62011-11-17 13:01:30 -08001042 expandBufAddFieldId(pReply, ToFieldId(f));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001043 expandBufAddUtf8String(pReply, fh.GetName());
1044 expandBufAddUtf8String(pReply, fh.GetTypeDescriptor());
Elliott Hughesc5b734a2011-12-01 17:20:58 -08001045 if (with_generic) {
Elliott Hughesa2e54f62011-11-17 13:01:30 -08001046 static const char genericSignature[1] = "";
1047 expandBufAddUtf8String(pReply, genericSignature);
1048 }
1049 expandBufAdd4BE(pReply, MangleAccessFlags(f->GetAccessFlags()));
1050 }
Elliott Hughes436e3722012-02-17 20:01:47 -08001051 return JDWP::ERR_NONE;
Elliott Hughesa2e54f62011-11-17 13:01:30 -08001052}
1053
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001054JDWP::JdwpError Dbg::OutputDeclaredMethods(JDWP::RefTypeId classId, bool with_generic,
1055 JDWP::ExpandBuf* pReply) {
Elliott Hughes436e3722012-02-17 20:01:47 -08001056 JDWP::JdwpError status;
1057 Class* c = DecodeClass(classId, status);
1058 if (c == NULL) {
1059 return status;
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -08001060 }
Elliott Hughesa2e54f62011-11-17 13:01:30 -08001061
1062 size_t direct_method_count = c->NumDirectMethods();
1063 size_t virtual_method_count = c->NumVirtualMethods();
1064
1065 expandBufAdd4BE(pReply, direct_method_count + virtual_method_count);
1066
1067 for (size_t i = 0; i < direct_method_count + virtual_method_count; ++i) {
Mathieu Chartier66f19252012-09-18 08:57:04 -07001068 AbstractMethod* m = (i < direct_method_count) ? c->GetDirectMethod(i) : c->GetVirtualMethod(i - direct_method_count);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001069 MethodHelper mh(m);
Elliott Hughesa2e54f62011-11-17 13:01:30 -08001070 expandBufAddMethodId(pReply, ToMethodId(m));
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001071 expandBufAddUtf8String(pReply, mh.GetName());
Elliott Hughes4740cdf2011-12-07 14:07:12 -08001072 expandBufAddUtf8String(pReply, mh.GetSignature());
Elliott Hughesc5b734a2011-12-01 17:20:58 -08001073 if (with_generic) {
Elliott Hughesa2e54f62011-11-17 13:01:30 -08001074 static const char genericSignature[1] = "";
1075 expandBufAddUtf8String(pReply, genericSignature);
1076 }
1077 expandBufAdd4BE(pReply, MangleAccessFlags(m->GetAccessFlags()));
1078 }
Elliott Hughes436e3722012-02-17 20:01:47 -08001079 return JDWP::ERR_NONE;
Elliott Hughesa2e54f62011-11-17 13:01:30 -08001080}
1081
Elliott Hughes436e3722012-02-17 20:01:47 -08001082JDWP::JdwpError Dbg::OutputDeclaredInterfaces(JDWP::RefTypeId classId, JDWP::ExpandBuf* pReply) {
1083 JDWP::JdwpError status;
1084 Class* c = DecodeClass(classId, status);
1085 if (c == NULL) {
1086 return status;
Elliott Hughes7b3cdfc2011-12-08 21:28:17 -08001087 }
Elliott Hughes436e3722012-02-17 20:01:47 -08001088
1089 ClassHelper kh(c);
Ian Rogersd24e2642012-06-06 21:21:43 -07001090 size_t interface_count = kh.NumDirectInterfaces();
Elliott Hughesa2e54f62011-11-17 13:01:30 -08001091 expandBufAdd4BE(pReply, interface_count);
1092 for (size_t i = 0; i < interface_count; ++i) {
Ian Rogersd24e2642012-06-06 21:21:43 -07001093 expandBufAddRefTypeId(pReply, gRegistry->Add(kh.GetDirectInterface(i)));
Elliott Hughesa2e54f62011-11-17 13:01:30 -08001094 }
Elliott Hughes436e3722012-02-17 20:01:47 -08001095 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001096}
1097
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001098void Dbg::OutputLineTable(JDWP::RefTypeId, JDWP::MethodId methodId, JDWP::ExpandBuf* pReply)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001099 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughes03181a82011-11-17 17:22:21 -08001100 struct DebugCallbackContext {
1101 int numItems;
1102 JDWP::ExpandBuf* pReply;
1103
Elliott Hughes2435a572012-02-17 16:07:41 -08001104 static bool Callback(void* context, uint32_t address, uint32_t line_number) {
Elliott Hughes03181a82011-11-17 17:22:21 -08001105 DebugCallbackContext* pContext = reinterpret_cast<DebugCallbackContext*>(context);
1106 expandBufAdd8BE(pContext->pReply, address);
Elliott Hughes2435a572012-02-17 16:07:41 -08001107 expandBufAdd4BE(pContext->pReply, line_number);
Elliott Hughes03181a82011-11-17 17:22:21 -08001108 pContext->numItems++;
1109 return true;
1110 }
1111 };
Mathieu Chartier66f19252012-09-18 08:57:04 -07001112 AbstractMethod* m = FromMethodId(methodId);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001113 MethodHelper mh(m);
Elliott Hughes03181a82011-11-17 17:22:21 -08001114 uint64_t start, end;
1115 if (m->IsNative()) {
1116 start = -1;
1117 end = -1;
1118 } else {
1119 start = 0;
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001120 // TODO: what are the units supposed to be? *2?
1121 end = mh.GetCodeItem()->insns_size_in_code_units_;
Elliott Hughes03181a82011-11-17 17:22:21 -08001122 }
1123
1124 expandBufAdd8BE(pReply, start);
1125 expandBufAdd8BE(pReply, end);
1126
1127 // Add numLines later
1128 size_t numLinesOffset = expandBufGetLength(pReply);
1129 expandBufAdd4BE(pReply, 0);
1130
1131 DebugCallbackContext context;
1132 context.numItems = 0;
1133 context.pReply = pReply;
1134
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001135 mh.GetDexFile().DecodeDebugInfo(mh.GetCodeItem(), m->IsStatic(), m->GetDexMethodIndex(),
1136 DebugCallbackContext::Callback, NULL, &context);
Elliott Hughes03181a82011-11-17 17:22:21 -08001137
1138 JDWP::Set4BE(expandBufGetBuffer(pReply) + numLinesOffset, context.numItems);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001139}
1140
Elliott Hughes436e3722012-02-17 20:01:47 -08001141void Dbg::OutputVariableTable(JDWP::RefTypeId, JDWP::MethodId methodId, bool with_generic, JDWP::ExpandBuf* pReply) {
Elliott Hughesdbb40792011-11-18 17:05:22 -08001142 struct DebugCallbackContext {
Elliott Hughesdbb40792011-11-18 17:05:22 -08001143 JDWP::ExpandBuf* pReply;
Elliott Hughesc5b734a2011-12-01 17:20:58 -08001144 size_t variable_count;
1145 bool with_generic;
Elliott Hughesdbb40792011-11-18 17:05:22 -08001146
Elliott Hughesc5b734a2011-12-01 17:20:58 -08001147 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 -08001148 DebugCallbackContext* pContext = reinterpret_cast<DebugCallbackContext*>(context);
1149
Elliott Hughesad3da692012-02-24 16:51:35 -08001150 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 -08001151
Elliott Hughes68fdbd02011-11-29 19:22:47 -08001152 slot = MangleSlot(slot, name);
1153
Elliott Hughesdbb40792011-11-18 17:05:22 -08001154 expandBufAdd8BE(pContext->pReply, startAddress);
1155 expandBufAddUtf8String(pContext->pReply, name);
1156 expandBufAddUtf8String(pContext->pReply, descriptor);
Elliott Hughesc5b734a2011-12-01 17:20:58 -08001157 if (pContext->with_generic) {
Elliott Hughesdbb40792011-11-18 17:05:22 -08001158 expandBufAddUtf8String(pContext->pReply, signature);
1159 }
1160 expandBufAdd4BE(pContext->pReply, endAddress - startAddress);
1161 expandBufAdd4BE(pContext->pReply, slot);
1162
Elliott Hughesc5b734a2011-12-01 17:20:58 -08001163 ++pContext->variable_count;
Elliott Hughesdbb40792011-11-18 17:05:22 -08001164 }
1165 };
Mathieu Chartier66f19252012-09-18 08:57:04 -07001166 AbstractMethod* m = FromMethodId(methodId);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001167 MethodHelper mh(m);
1168 const DexFile::CodeItem* code_item = mh.GetCodeItem();
Elliott Hughesdbb40792011-11-18 17:05:22 -08001169
Elliott Hughesc5b734a2011-12-01 17:20:58 -08001170 // arg_count considers doubles and longs to take 2 units.
1171 // variable_count considers everything to take 1 unit.
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001172 std::string shorty(mh.GetShorty());
Elliott Hughesc5b734a2011-12-01 17:20:58 -08001173 expandBufAdd4BE(pReply, m->NumArgRegisters(shorty));
Elliott Hughesdbb40792011-11-18 17:05:22 -08001174
Elliott Hughesc5b734a2011-12-01 17:20:58 -08001175 // We don't know the total number of variables yet, so leave a blank and update it later.
1176 size_t variable_count_offset = expandBufGetLength(pReply);
Elliott Hughesdbb40792011-11-18 17:05:22 -08001177 expandBufAdd4BE(pReply, 0);
1178
1179 DebugCallbackContext context;
Elliott Hughesdbb40792011-11-18 17:05:22 -08001180 context.pReply = pReply;
Elliott Hughesc5b734a2011-12-01 17:20:58 -08001181 context.variable_count = 0;
1182 context.with_generic = with_generic;
Elliott Hughesdbb40792011-11-18 17:05:22 -08001183
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001184 mh.GetDexFile().DecodeDebugInfo(code_item, m->IsStatic(), m->GetDexMethodIndex(), NULL,
1185 DebugCallbackContext::Callback, &context);
Elliott Hughesdbb40792011-11-18 17:05:22 -08001186
Elliott Hughesc5b734a2011-12-01 17:20:58 -08001187 JDWP::Set4BE(expandBufGetBuffer(pReply) + variable_count_offset, context.variable_count);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001188}
1189
Elliott Hughesaed4be92011-12-02 16:16:23 -08001190JDWP::JdwpTag Dbg::GetFieldBasicTag(JDWP::FieldId fieldId) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001191 return BasicTagFromDescriptor(FieldHelper(FromFieldId(fieldId)).GetTypeDescriptor());
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001192}
1193
Elliott Hughesaed4be92011-12-02 16:16:23 -08001194JDWP::JdwpTag Dbg::GetStaticFieldBasicTag(JDWP::FieldId fieldId) {
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001195 return BasicTagFromDescriptor(FieldHelper(FromFieldId(fieldId)).GetTypeDescriptor());
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001196}
1197
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001198static JDWP::JdwpError GetFieldValueImpl(JDWP::RefTypeId refTypeId, JDWP::ObjectId objectId,
1199 JDWP::FieldId fieldId, JDWP::ExpandBuf* pReply,
1200 bool is_static)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001201 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughes0cf74332012-02-23 23:14:00 -08001202 JDWP::JdwpError status;
1203 Class* c = DecodeClass(refTypeId, status);
1204 if (refTypeId != 0 && c == NULL) {
1205 return status;
1206 }
1207
Elliott Hughesaed4be92011-12-02 16:16:23 -08001208 Object* o = gRegistry->Get<Object*>(objectId);
Elliott Hughes3f4d58f2012-02-18 20:05:37 -08001209 if ((!is_static && o == NULL) || o == kInvalidObject) {
1210 return JDWP::ERR_INVALID_OBJECT;
1211 }
Elliott Hughesaed4be92011-12-02 16:16:23 -08001212 Field* f = FromFieldId(fieldId);
Elliott Hughes0cf74332012-02-23 23:14:00 -08001213
1214 Class* receiver_class = c;
1215 if (receiver_class == NULL && o != NULL) {
1216 receiver_class = o->GetClass();
1217 }
1218 // TODO: should we give up now if receiver_class is NULL?
1219 if (receiver_class != NULL && !f->GetDeclaringClass()->IsAssignableFrom(receiver_class)) {
1220 LOG(INFO) << "ERR_INVALID_FIELDID: " << PrettyField(f) << " " << PrettyClass(receiver_class);
Elliott Hughes3f4d58f2012-02-18 20:05:37 -08001221 return JDWP::ERR_INVALID_FIELDID;
1222 }
Elliott Hughesaed4be92011-12-02 16:16:23 -08001223
Elliott Hughes0cf74332012-02-23 23:14:00 -08001224 // The RI only enforces the static/non-static mismatch in one direction.
1225 // TODO: should we change the tests and check both?
1226 if (is_static) {
1227 if (!f->IsStatic()) {
1228 return JDWP::ERR_INVALID_FIELDID;
1229 }
1230 } else {
1231 if (f->IsStatic()) {
1232 LOG(WARNING) << "Ignoring non-NULL receiver for ObjectReference.SetValues on static field " << PrettyField(f);
1233 o = NULL;
1234 }
1235 }
1236
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001237 JDWP::JdwpTag tag = BasicTagFromDescriptor(FieldHelper(f).GetTypeDescriptor());
Elliott Hughesaed4be92011-12-02 16:16:23 -08001238
1239 if (IsPrimitiveTag(tag)) {
1240 expandBufAdd1(pReply, tag);
1241 if (tag == JDWP::JT_BOOLEAN || tag == JDWP::JT_BYTE) {
1242 expandBufAdd1(pReply, f->Get32(o));
1243 } else if (tag == JDWP::JT_CHAR || tag == JDWP::JT_SHORT) {
1244 expandBufAdd2BE(pReply, f->Get32(o));
1245 } else if (tag == JDWP::JT_FLOAT || tag == JDWP::JT_INT) {
1246 expandBufAdd4BE(pReply, f->Get32(o));
1247 } else if (tag == JDWP::JT_DOUBLE || tag == JDWP::JT_LONG) {
1248 expandBufAdd8BE(pReply, f->Get64(o));
1249 } else {
Elliott Hughes3d30d9b2011-12-07 17:35:48 -08001250 LOG(FATAL) << "Unknown tag: " << tag;
Elliott Hughesaed4be92011-12-02 16:16:23 -08001251 }
1252 } else {
1253 Object* value = f->GetObject(o);
1254 expandBufAdd1(pReply, TagFromObject(value));
1255 expandBufAddObjectId(pReply, gRegistry->Add(value));
1256 }
Elliott Hughes3f4d58f2012-02-18 20:05:37 -08001257 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001258}
1259
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001260JDWP::JdwpError Dbg::GetFieldValue(JDWP::ObjectId objectId, JDWP::FieldId fieldId,
1261 JDWP::ExpandBuf* pReply) {
Elliott Hughes0cf74332012-02-23 23:14:00 -08001262 return GetFieldValueImpl(0, objectId, fieldId, pReply, false);
Elliott Hughes3f4d58f2012-02-18 20:05:37 -08001263}
1264
Elliott Hughes0cf74332012-02-23 23:14:00 -08001265JDWP::JdwpError Dbg::GetStaticFieldValue(JDWP::RefTypeId refTypeId, JDWP::FieldId fieldId, JDWP::ExpandBuf* pReply) {
1266 return GetFieldValueImpl(refTypeId, 0, fieldId, pReply, true);
Elliott Hughes3f4d58f2012-02-18 20:05:37 -08001267}
1268
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001269static JDWP::JdwpError SetFieldValueImpl(JDWP::ObjectId objectId, JDWP::FieldId fieldId,
1270 uint64_t value, int width, bool is_static)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001271 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughesaed4be92011-12-02 16:16:23 -08001272 Object* o = gRegistry->Get<Object*>(objectId);
Elliott Hughes3f4d58f2012-02-18 20:05:37 -08001273 if ((!is_static && o == NULL) || o == kInvalidObject) {
1274 return JDWP::ERR_INVALID_OBJECT;
1275 }
Elliott Hughesaed4be92011-12-02 16:16:23 -08001276 Field* f = FromFieldId(fieldId);
Elliott Hughes0cf74332012-02-23 23:14:00 -08001277
1278 // The RI only enforces the static/non-static mismatch in one direction.
1279 // TODO: should we change the tests and check both?
1280 if (is_static) {
1281 if (!f->IsStatic()) {
1282 return JDWP::ERR_INVALID_FIELDID;
1283 }
1284 } else {
1285 if (f->IsStatic()) {
1286 LOG(WARNING) << "Ignoring non-NULL receiver for ObjectReference.SetValues on static field " << PrettyField(f);
1287 o = NULL;
1288 }
Elliott Hughes3f4d58f2012-02-18 20:05:37 -08001289 }
Elliott Hughesaed4be92011-12-02 16:16:23 -08001290
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08001291 JDWP::JdwpTag tag = BasicTagFromDescriptor(FieldHelper(f).GetTypeDescriptor());
Elliott Hughesaed4be92011-12-02 16:16:23 -08001292
1293 if (IsPrimitiveTag(tag)) {
1294 if (tag == JDWP::JT_DOUBLE || tag == JDWP::JT_LONG) {
Elliott Hughes1bac54f2012-03-16 12:48:31 -07001295 CHECK_EQ(width, 8);
Elliott Hughesaed4be92011-12-02 16:16:23 -08001296 f->Set64(o, value);
1297 } else {
Elliott Hughes1bac54f2012-03-16 12:48:31 -07001298 CHECK_LE(width, 4);
Elliott Hughesaed4be92011-12-02 16:16:23 -08001299 f->Set32(o, value);
1300 }
1301 } else {
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -08001302 Object* v = gRegistry->Get<Object*>(value);
Elliott Hughes3f4d58f2012-02-18 20:05:37 -08001303 if (v == kInvalidObject) {
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -08001304 return JDWP::ERR_INVALID_OBJECT;
1305 }
Elliott Hughes3f4d58f2012-02-18 20:05:37 -08001306 if (v != NULL) {
1307 Class* field_type = FieldHelper(f).GetType();
1308 if (!field_type->IsAssignableFrom(v->GetClass())) {
1309 return JDWP::ERR_INVALID_OBJECT;
1310 }
1311 }
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -08001312 f->SetObject(o, v);
Elliott Hughesaed4be92011-12-02 16:16:23 -08001313 }
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -08001314
1315 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001316}
1317
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001318JDWP::JdwpError Dbg::SetFieldValue(JDWP::ObjectId objectId, JDWP::FieldId fieldId, uint64_t value,
1319 int width) {
Elliott Hughes3f4d58f2012-02-18 20:05:37 -08001320 return SetFieldValueImpl(objectId, fieldId, value, width, false);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001321}
1322
Elliott Hughes3d1ca6d2012-02-13 15:43:19 -08001323JDWP::JdwpError Dbg::SetStaticFieldValue(JDWP::FieldId fieldId, uint64_t value, int width) {
Elliott Hughes3f4d58f2012-02-18 20:05:37 -08001324 return SetFieldValueImpl(0, fieldId, value, width, true);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001325}
1326
Elliott Hughes68fdbd02011-11-29 19:22:47 -08001327std::string Dbg::StringToUtf8(JDWP::ObjectId strId) {
1328 String* s = gRegistry->Get<String*>(strId);
1329 return s->ToModifiedUtf8();
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001330}
1331
Elliott Hughesa2e54f62011-11-17 13:01:30 -08001332bool Dbg::GetThreadName(JDWP::ObjectId threadId, std::string& name) {
Ian Rogersb726dcb2012-09-05 08:57:23 -07001333 MutexLock mu(*Locks::thread_list_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001334 ScopedObjectAccessUnchecked soa(Thread::Current());
1335 Thread* thread = DecodeThread(soa, threadId);
Elliott Hughesa2e54f62011-11-17 13:01:30 -08001336 if (thread == NULL) {
1337 return false;
1338 }
Elliott Hughesffb465f2012-03-01 18:46:05 -08001339 thread->GetThreadName(name);
Elliott Hughesa2e54f62011-11-17 13:01:30 -08001340 return true;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001341}
1342
Elliott Hughes2435a572012-02-17 16:07:41 -08001343JDWP::JdwpError Dbg::GetThreadGroup(JDWP::ObjectId threadId, JDWP::ExpandBuf* pReply) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001344 ScopedObjectAccess soa(Thread::Current());
Elliott Hughes499c5132011-11-17 14:55:11 -08001345 Object* thread = gRegistry->Get<Object*>(threadId);
Elliott Hughes436e3722012-02-17 20:01:47 -08001346 if (thread == kInvalidObject) {
Elliott Hughes2435a572012-02-17 16:07:41 -08001347 return JDWP::ERR_INVALID_OBJECT;
1348 }
1349
1350 // Okay, so it's an object, but is it actually a thread?
Ian Rogersb726dcb2012-09-05 08:57:23 -07001351 MutexLock mu(*Locks::thread_list_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001352 if (DecodeThread(soa, threadId) == NULL) {
Elliott Hughes2435a572012-02-17 16:07:41 -08001353 return JDWP::ERR_INVALID_THREAD;
1354 }
Elliott Hughes499c5132011-11-17 14:55:11 -08001355
1356 Class* c = Runtime::Current()->GetClassLinker()->FindSystemClass("Ljava/lang/Thread;");
1357 CHECK(c != NULL);
1358 Field* f = c->FindInstanceField("group", "Ljava/lang/ThreadGroup;");
1359 CHECK(f != NULL);
1360 Object* group = f->GetObject(thread);
1361 CHECK(group != NULL);
Elliott Hughes2435a572012-02-17 16:07:41 -08001362 JDWP::ObjectId thread_group_id = gRegistry->Add(group);
1363
1364 expandBufAddObjectId(pReply, thread_group_id);
1365 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001366}
1367
Elliott Hughes499c5132011-11-17 14:55:11 -08001368std::string Dbg::GetThreadGroupName(JDWP::ObjectId threadGroupId) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001369 ScopedObjectAccess soa(Thread::Current());
Elliott Hughes499c5132011-11-17 14:55:11 -08001370 Object* thread_group = gRegistry->Get<Object*>(threadGroupId);
1371 CHECK(thread_group != NULL);
1372
1373 Class* c = Runtime::Current()->GetClassLinker()->FindSystemClass("Ljava/lang/ThreadGroup;");
1374 CHECK(c != NULL);
1375 Field* f = c->FindInstanceField("name", "Ljava/lang/String;");
1376 CHECK(f != NULL);
1377 String* s = reinterpret_cast<String*>(f->GetObject(thread_group));
1378 return s->ToModifiedUtf8();
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001379}
1380
1381JDWP::ObjectId Dbg::GetThreadGroupParent(JDWP::ObjectId threadGroupId) {
Elliott Hughes4e235312011-12-02 11:34:15 -08001382 Object* thread_group = gRegistry->Get<Object*>(threadGroupId);
1383 CHECK(thread_group != NULL);
1384
1385 Class* c = Runtime::Current()->GetClassLinker()->FindSystemClass("Ljava/lang/ThreadGroup;");
1386 CHECK(c != NULL);
1387 Field* f = c->FindInstanceField("parent", "Ljava/lang/ThreadGroup;");
1388 CHECK(f != NULL);
1389 Object* parent = f->GetObject(thread_group);
1390 return gRegistry->Add(parent);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001391}
1392
1393JDWP::ObjectId Dbg::GetSystemThreadGroupId() {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001394 ScopedObjectAccessUnchecked soa(Thread::Current());
Ian Rogers365c1022012-06-22 15:05:28 -07001395 Object* group =
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001396 soa.DecodeField(WellKnownClasses::java_lang_ThreadGroup_systemThreadGroup)->GetObject(NULL);
Ian Rogers365c1022012-06-22 15:05:28 -07001397 return gRegistry->Add(group);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001398}
1399
1400JDWP::ObjectId Dbg::GetMainThreadGroupId() {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001401 ScopedObjectAccess soa(Thread::Current());
Ian Rogers365c1022012-06-22 15:05:28 -07001402 Object* group =
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001403 soa.DecodeField(WellKnownClasses::java_lang_ThreadGroup_mainThreadGroup)->GetObject(NULL);
Ian Rogers365c1022012-06-22 15:05:28 -07001404 return gRegistry->Add(group);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001405}
1406
Elliott Hughes3d30d9b2011-12-07 17:35:48 -08001407bool Dbg::GetThreadStatus(JDWP::ObjectId threadId, JDWP::JdwpThreadStatus* pThreadStatus, JDWP::JdwpSuspendStatus* pSuspendStatus) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001408 ScopedObjectAccess soa(Thread::Current());
Elliott Hughes499c5132011-11-17 14:55:11 -08001409
Ian Rogersb726dcb2012-09-05 08:57:23 -07001410 MutexLock mu(*Locks::thread_list_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001411 Thread* thread = DecodeThread(soa, threadId);
Elliott Hughes499c5132011-11-17 14:55:11 -08001412 if (thread == NULL) {
1413 return false;
1414 }
1415
Ian Rogersb726dcb2012-09-05 08:57:23 -07001416 MutexLock mu2(*Locks::thread_suspend_count_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001417
Elliott Hughes3ce4b262012-02-24 11:24:02 -08001418 // TODO: if we're in Thread.sleep(long), we should return TS_SLEEPING,
1419 // even if it's implemented using Object.wait(long).
Elliott Hughes499c5132011-11-17 14:55:11 -08001420 switch (thread->GetState()) {
Elliott Hughes34e06962012-04-09 13:55:55 -07001421 case kTerminated: *pThreadStatus = JDWP::TS_ZOMBIE; break;
1422 case kRunnable: *pThreadStatus = JDWP::TS_RUNNING; break;
1423 case kTimedWaiting: *pThreadStatus = JDWP::TS_WAIT; break;
1424 case kBlocked: *pThreadStatus = JDWP::TS_MONITOR; break;
1425 case kWaiting: *pThreadStatus = JDWP::TS_WAIT; break;
1426 case kStarting: *pThreadStatus = JDWP::TS_ZOMBIE; break;
1427 case kNative: *pThreadStatus = JDWP::TS_RUNNING; break;
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001428 case kWaitingForGcToComplete: // Fall-through.
1429 case kWaitingPerformingGc: // Fall-through.
1430 case kWaitingForDebuggerSend: // Fall-through.
1431 case kWaitingForDebuggerToAttach: // Fall-through.
1432 case kWaitingInMainDebuggerLoop: // Fall-through.
1433 case kWaitingForDebuggerSuspension: // Fall-through.
1434 case kWaitingForJniOnLoad: // Fall-through.
1435 case kWaitingForSignalCatcherOutput: // Fall-through.
1436 case kWaitingInMainSignalCatcherLoop:
1437 *pThreadStatus = JDWP::TS_WAIT; break;
Elliott Hughes34e06962012-04-09 13:55:55 -07001438 case kSuspended: *pThreadStatus = JDWP::TS_RUNNING; break;
Elliott Hughescf2b2d42012-03-27 17:11:42 -07001439 // Don't add a 'default' here so the compiler can spot incompatible enum changes.
Elliott Hughes499c5132011-11-17 14:55:11 -08001440 }
1441
Elliott Hughes3d30d9b2011-12-07 17:35:48 -08001442 *pSuspendStatus = (thread->IsSuspended() ? JDWP::SUSPEND_STATUS_SUSPENDED : JDWP::SUSPEND_STATUS_NOT_SUSPENDED);
Elliott Hughes499c5132011-11-17 14:55:11 -08001443
1444 return true;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001445}
1446
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001447JDWP::JdwpError Dbg::GetThreadDebugSuspendCount(JDWP::ObjectId threadId, JDWP::ExpandBuf* pReply) {
1448 ScopedObjectAccess soa(Thread::Current());
1449
Ian Rogersb726dcb2012-09-05 08:57:23 -07001450 MutexLock mu(*Locks::thread_list_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001451 Thread* thread = DecodeThread(soa, threadId);
Elliott Hughes2435a572012-02-17 16:07:41 -08001452 if (thread == NULL) {
1453 return JDWP::ERR_INVALID_THREAD;
1454 }
Ian Rogersb726dcb2012-09-05 08:57:23 -07001455 MutexLock mu2(*Locks::thread_suspend_count_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001456 expandBufAdd4BE(pReply, thread->GetDebugSuspendCount());
Elliott Hughes2435a572012-02-17 16:07:41 -08001457 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001458}
1459
1460bool Dbg::ThreadExists(JDWP::ObjectId threadId) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001461 ScopedObjectAccess soa(Thread::Current());
Ian Rogersb726dcb2012-09-05 08:57:23 -07001462 MutexLock mu(*Locks::thread_list_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001463 return DecodeThread(soa, threadId) != NULL;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001464}
1465
1466bool Dbg::IsSuspended(JDWP::ObjectId threadId) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001467 ScopedObjectAccess soa(Thread::Current());
Ian Rogersb726dcb2012-09-05 08:57:23 -07001468 MutexLock mu(*Locks::thread_list_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001469 Thread* thread = DecodeThread(soa, threadId);
1470 CHECK(thread != NULL);
Ian Rogersb726dcb2012-09-05 08:57:23 -07001471 MutexLock mu2(*Locks::thread_suspend_count_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001472 return thread->IsSuspended();
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001473}
1474
Elliott Hughescaf76542012-06-28 16:08:22 -07001475void Dbg::GetThreads(JDWP::ObjectId thread_group_id, std::vector<JDWP::ObjectId>& thread_ids) {
Ian Rogers365c1022012-06-22 15:05:28 -07001476 class ThreadListVisitor {
1477 public:
Mathieu Chartierdbe6f462012-09-25 16:54:50 -07001478 ThreadListVisitor(const ScopedObjectAccessUnchecked& soa, Object* thread_group,
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001479 std::vector<JDWP::ObjectId>& thread_ids)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001480 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
Mathieu Chartierdbe6f462012-09-25 16:54:50 -07001481 : soa_(soa), thread_group_(thread_group), thread_ids_(thread_ids) {}
Ian Rogers365c1022012-06-22 15:05:28 -07001482
Elliott Hughesa2155262011-11-16 16:26:58 -08001483 static void Visit(Thread* t, void* arg) {
1484 reinterpret_cast<ThreadListVisitor*>(arg)->Visit(t);
1485 }
1486
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001487 // TODO: Enable annotalysis. We know lock is held in constructor, but abstraction confuses
1488 // annotalysis.
1489 void Visit(Thread* t) NO_THREAD_SAFETY_ANALYSIS {
Elliott Hughesa2155262011-11-16 16:26:58 -08001490 if (t == Dbg::GetDebugThread()) {
1491 // Skip the JDWP thread. Some debuggers get bent out of shape when they can't suspend and
1492 // query all threads, so it's easier if we just don't tell them about this thread.
1493 return;
1494 }
Mathieu Chartierdbe6f462012-09-25 16:54:50 -07001495 if (thread_group_ == NULL || t->GetThreadGroup(soa_) == thread_group_) {
1496 thread_ids_.push_back(gRegistry->Add(soa_.Decode<Object*>(t->GetPeer())));
Elliott Hughesa2155262011-11-16 16:26:58 -08001497 }
1498 }
1499
Ian Rogers365c1022012-06-22 15:05:28 -07001500 private:
Mathieu Chartierdbe6f462012-09-25 16:54:50 -07001501 const ScopedObjectAccessUnchecked& soa_;
Ian Rogers365c1022012-06-22 15:05:28 -07001502 Object* const thread_group_;
Elliott Hughescaf76542012-06-28 16:08:22 -07001503 std::vector<JDWP::ObjectId>& thread_ids_;
Elliott Hughesa2155262011-11-16 16:26:58 -08001504 };
1505
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001506 ScopedObjectAccessUnchecked soa(Thread::Current());
Elliott Hughescaf76542012-06-28 16:08:22 -07001507 Object* thread_group = gRegistry->Get<Object*>(thread_group_id);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001508 ThreadListVisitor tlv(soa, thread_group, thread_ids);
Ian Rogersb726dcb2012-09-05 08:57:23 -07001509 MutexLock mu(*Locks::thread_list_lock_);
Elliott Hughesf8349362012-06-18 15:00:06 -07001510 Runtime::Current()->GetThreadList()->ForEach(ThreadListVisitor::Visit, &tlv);
Elliott Hughescaf76542012-06-28 16:08:22 -07001511}
Elliott Hughesa2155262011-11-16 16:26:58 -08001512
Elliott Hughescaf76542012-06-28 16:08:22 -07001513void Dbg::GetChildThreadGroups(JDWP::ObjectId thread_group_id, std::vector<JDWP::ObjectId>& child_thread_group_ids) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001514 ScopedObjectAccess soa(Thread::Current());
Elliott Hughescaf76542012-06-28 16:08:22 -07001515 Object* thread_group = gRegistry->Get<Object*>(thread_group_id);
1516
1517 // Get the ArrayList<ThreadGroup> "groups" out of this thread group...
1518 Field* groups_field = thread_group->GetClass()->FindInstanceField("groups", "Ljava/util/List;");
1519 Object* groups_array_list = groups_field->GetObject(thread_group);
1520
1521 // Get the array and size out of the ArrayList<ThreadGroup>...
1522 Field* array_field = groups_array_list->GetClass()->FindInstanceField("array", "[Ljava/lang/Object;");
1523 Field* size_field = groups_array_list->GetClass()->FindInstanceField("size", "I");
1524 ObjectArray<Object>* groups_array = array_field->GetObject(groups_array_list)->AsObjectArray<Object>();
1525 const int32_t size = size_field->GetInt(groups_array_list);
1526
1527 // Copy the first 'size' elements out of the array into the result.
1528 for (int32_t i = 0; i < size; ++i) {
1529 child_thread_group_ids.push_back(gRegistry->Add(groups_array->Get(i)));
Elliott Hughesa2155262011-11-16 16:26:58 -08001530 }
1531}
1532
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001533static int GetStackDepth(Thread* thread)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001534 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers0399dde2012-06-06 17:09:28 -07001535 struct CountStackDepthVisitor : public StackVisitor {
1536 CountStackDepthVisitor(const ManagedStack* stack,
Ian Rogersca190662012-06-26 15:45:57 -07001537 const std::vector<TraceStackFrame>* trace_stack)
Elliott Hughes08fc03a2012-06-26 17:34:00 -07001538 : StackVisitor(stack, trace_stack, NULL), depth(0) {}
Ian Rogers0399dde2012-06-06 17:09:28 -07001539
1540 bool VisitFrame() {
1541 if (!GetMethod()->IsRuntimeMethod()) {
Elliott Hughesf8a2df72011-12-01 12:19:54 -08001542 ++depth;
1543 }
Elliott Hughes530fa002012-03-12 11:44:49 -07001544 return true;
Elliott Hughesa2e54f62011-11-17 13:01:30 -08001545 }
1546 size_t depth;
1547 };
Elliott Hughes08fc03a2012-06-26 17:34:00 -07001548
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001549 if (kIsDebugBuild) {
Ian Rogersb726dcb2012-09-05 08:57:23 -07001550 MutexLock mu(*Locks::thread_suspend_count_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001551 CHECK(thread->IsSuspended());
1552 }
Ian Rogers0399dde2012-06-06 17:09:28 -07001553 CountStackDepthVisitor visitor(thread->GetManagedStack(), thread->GetTraceStack());
1554 visitor.WalkStack();
Elliott Hughesa2e54f62011-11-17 13:01:30 -08001555 return visitor.depth;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001556}
1557
Elliott Hughes86964332012-02-15 19:37:42 -08001558int Dbg::GetThreadFrameCount(JDWP::ObjectId threadId) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001559 ScopedObjectAccess soa(Thread::Current());
1560 return GetStackDepth(DecodeThread(soa, threadId));
Elliott Hughes86964332012-02-15 19:37:42 -08001561}
1562
Elliott Hughes6e9d22c2012-06-22 15:02:37 -07001563JDWP::JdwpError Dbg::GetThreadFrames(JDWP::ObjectId thread_id, size_t start_frame, size_t frame_count, JDWP::ExpandBuf* buf) {
Elliott Hughes6e9d22c2012-06-22 15:02:37 -07001564 class GetFrameVisitor : public StackVisitor {
1565 public:
Ian Rogers0399dde2012-06-06 17:09:28 -07001566 GetFrameVisitor(const ManagedStack* stack, const std::vector<TraceStackFrame>* trace_stack,
Elliott Hughes6e9d22c2012-06-22 15:02:37 -07001567 size_t start_frame, size_t frame_count, JDWP::ExpandBuf* buf)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001568 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
Elliott Hughes08fc03a2012-06-26 17:34:00 -07001569 : StackVisitor(stack, trace_stack, NULL), depth_(0),
Elliott Hughes6e9d22c2012-06-22 15:02:37 -07001570 start_frame_(start_frame), frame_count_(frame_count), buf_(buf) {
1571 expandBufAdd4BE(buf_, frame_count_);
Elliott Hughes03181a82011-11-17 17:22:21 -08001572 }
Ian Rogers0399dde2012-06-06 17:09:28 -07001573
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001574 // TODO: Enable annotalysis. We know lock is held in constructor, but abstraction confuses
1575 // annotalysis.
1576 virtual bool VisitFrame() NO_THREAD_SAFETY_ANALYSIS {
Ian Rogers0399dde2012-06-06 17:09:28 -07001577 if (GetMethod()->IsRuntimeMethod()) {
Elliott Hughes530fa002012-03-12 11:44:49 -07001578 return true; // The debugger can't do anything useful with a frame that has no Method*.
Elliott Hughes03181a82011-11-17 17:22:21 -08001579 }
Elliott Hughes6e9d22c2012-06-22 15:02:37 -07001580 if (depth_ >= start_frame_ + frame_count_) {
Elliott Hughes530fa002012-03-12 11:44:49 -07001581 return false;
Elliott Hughes03181a82011-11-17 17:22:21 -08001582 }
Elliott Hughes6e9d22c2012-06-22 15:02:37 -07001583 if (depth_ >= start_frame_) {
1584 JDWP::FrameId frame_id(GetFrameId());
1585 JDWP::JdwpLocation location;
1586 SetLocation(location, GetMethod(), GetDexPc());
Elliott Hughes7baf96f2012-06-22 16:33:50 -07001587 VLOG(jdwp) << StringPrintf(" Frame %3zd: id=%3lld ", depth_, frame_id) << location;
Elliott Hughes6e9d22c2012-06-22 15:02:37 -07001588 expandBufAdd8BE(buf_, frame_id);
1589 expandBufAddLocation(buf_, location);
1590 }
1591 ++depth_;
Elliott Hughes530fa002012-03-12 11:44:49 -07001592 return true;
Elliott Hughes03181a82011-11-17 17:22:21 -08001593 }
Elliott Hughes6e9d22c2012-06-22 15:02:37 -07001594
1595 private:
1596 size_t depth_;
1597 const size_t start_frame_;
1598 const size_t frame_count_;
1599 JDWP::ExpandBuf* buf_;
Elliott Hughes03181a82011-11-17 17:22:21 -08001600 };
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001601
1602 ScopedObjectAccessUnchecked soa(Thread::Current());
1603 Thread* thread = DecodeThread(soa, thread_id); // Caller already checked thread is suspended.
Elliott Hughes6e9d22c2012-06-22 15:02:37 -07001604 GetFrameVisitor visitor(thread->GetManagedStack(), thread->GetTraceStack(), start_frame, frame_count, buf);
Ian Rogers0399dde2012-06-06 17:09:28 -07001605 visitor.WalkStack();
Elliott Hughes6e9d22c2012-06-22 15:02:37 -07001606 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001607}
1608
1609JDWP::ObjectId Dbg::GetThreadSelfId() {
Mathieu Chartierdbe6f462012-09-25 16:54:50 -07001610 ScopedObjectAccessUnchecked soa(Thread::Current());
1611 return gRegistry->Add(soa.Decode<Object*>(Thread::Current()->GetPeer()));
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001612}
1613
Elliott Hughes475fc232011-10-25 15:00:35 -07001614void Dbg::SuspendVM() {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001615 Runtime::Current()->GetThreadList()->SuspendAllForDebugger();
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001616}
1617
1618void Dbg::ResumeVM() {
Elliott Hughesc61a2672012-06-21 14:52:29 -07001619 Runtime::Current()->GetThreadList()->UndoDebuggerSuspensions();
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001620}
1621
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001622JDWP::JdwpError Dbg::SuspendThread(JDWP::ObjectId threadId, bool request_suspension) {
1623
1624 bool timeout;
1625 ScopedLocalRef<jobject> peer(Thread::Current()->GetJniEnv(), NULL);
1626 {
1627 ScopedObjectAccess soa(Thread::Current());
1628 peer.reset(soa.AddLocalReference<jobject>(gRegistry->Get<Object*>(threadId)));
Elliott Hughes4e235312011-12-02 11:34:15 -08001629 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001630 if (peer.get() == NULL) {
1631 LOG(WARNING) << "No such thread for suspend: " << threadId;
1632 return JDWP::ERR_THREAD_NOT_ALIVE;
1633 }
1634 // Suspend thread to build stack trace.
1635 Thread* thread = Thread::SuspendForDebugger(peer.get(), request_suspension, &timeout);
1636 if (thread != NULL) {
1637 return JDWP::ERR_NONE;
1638 } else if (timeout) {
1639 return JDWP::ERR_INTERNAL;
1640 } else {
1641 return JDWP::ERR_THREAD_NOT_ALIVE;
1642 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001643}
1644
1645void Dbg::ResumeThread(JDWP::ObjectId threadId) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001646 ScopedObjectAccessUnchecked soa(Thread::Current());
Elliott Hughes4e235312011-12-02 11:34:15 -08001647 Object* peer = gRegistry->Get<Object*>(threadId);
Ian Rogersb726dcb2012-09-05 08:57:23 -07001648 MutexLock mu(*Locks::thread_list_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001649 Thread* thread = Thread::FromManagedThread(soa, peer);
Elliott Hughes4e235312011-12-02 11:34:15 -08001650 if (thread == NULL) {
1651 LOG(WARNING) << "No such thread for resume: " << peer;
1652 return;
1653 }
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001654 bool needs_resume;
1655 {
Ian Rogersb726dcb2012-09-05 08:57:23 -07001656 MutexLock mu2(*Locks::thread_suspend_count_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001657 needs_resume = thread->GetSuspendCount() > 0;
1658 }
1659 if (needs_resume) {
Elliott Hughes546b9862012-06-20 16:06:13 -07001660 Runtime::Current()->GetThreadList()->Resume(thread, true);
1661 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001662}
1663
1664void Dbg::SuspendSelf() {
Elliott Hughes475fc232011-10-25 15:00:35 -07001665 Runtime::Current()->GetThreadList()->SuspendSelfForDebugger();
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001666}
1667
Ian Rogers0399dde2012-06-06 17:09:28 -07001668struct GetThisVisitor : public StackVisitor {
1669 GetThisVisitor(const ManagedStack* stack, const std::vector<TraceStackFrame>* trace_stack,
Elliott Hughes6e9d22c2012-06-22 15:02:37 -07001670 Context* context, JDWP::FrameId frameId)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001671 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
Elliott Hughes6e9d22c2012-06-22 15:02:37 -07001672 : StackVisitor(stack, trace_stack, context), this_object(NULL), frame_id(frameId) {}
Ian Rogers0399dde2012-06-06 17:09:28 -07001673
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001674 // TODO: Enable annotalysis. We know lock is held in constructor, but abstraction confuses
1675 // annotalysis.
1676 virtual bool VisitFrame() NO_THREAD_SAFETY_ANALYSIS {
Elliott Hughes6e9d22c2012-06-22 15:02:37 -07001677 if (frame_id != GetFrameId()) {
Ian Rogers0399dde2012-06-06 17:09:28 -07001678 return true; // continue
1679 }
Mathieu Chartier66f19252012-09-18 08:57:04 -07001680 AbstractMethod* m = GetMethod();
Ian Rogers0399dde2012-06-06 17:09:28 -07001681 if (m->IsNative() || m->IsStatic()) {
Elliott Hughes6e9d22c2012-06-22 15:02:37 -07001682 this_object = NULL;
Ian Rogers0399dde2012-06-06 17:09:28 -07001683 } else {
1684 uint16_t reg = DemangleSlot(0, m);
Elliott Hughes6e9d22c2012-06-22 15:02:37 -07001685 this_object = reinterpret_cast<Object*>(GetVReg(m, reg));
Ian Rogers0399dde2012-06-06 17:09:28 -07001686 }
1687 return false;
Elliott Hughes86b00102011-12-05 17:54:26 -08001688 }
Ian Rogers0399dde2012-06-06 17:09:28 -07001689
Elliott Hughes6e9d22c2012-06-22 15:02:37 -07001690 Object* this_object;
1691 JDWP::FrameId frame_id;
Ian Rogers0399dde2012-06-06 17:09:28 -07001692};
1693
Mathieu Chartier66f19252012-09-18 08:57:04 -07001694static Object* GetThis(Thread* self, AbstractMethod* m, size_t frame_id)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001695 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughescaf76542012-06-28 16:08:22 -07001696 // TODO: should we return the 'this' we passed through to non-static native methods?
Ian Rogers0399dde2012-06-06 17:09:28 -07001697 if (m->IsNative() || m->IsStatic()) {
1698 return NULL;
1699 }
Elliott Hughescaf76542012-06-28 16:08:22 -07001700
Ian Rogers0399dde2012-06-06 17:09:28 -07001701 UniquePtr<Context> context(Context::Create());
Elliott Hughescaf76542012-06-28 16:08:22 -07001702 GetThisVisitor visitor(self->GetManagedStack(), self->GetTraceStack(), context.get(), frame_id);
1703 visitor.WalkStack();
1704 return visitor.this_object;
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08001705}
1706
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001707JDWP::JdwpError Dbg::GetThisObject(JDWP::ObjectId thread_id, JDWP::FrameId frame_id,
1708 JDWP::ObjectId* result) {
1709 ScopedObjectAccessUnchecked soa(Thread::Current());
1710 Thread* thread;
1711 {
Ian Rogersb726dcb2012-09-05 08:57:23 -07001712 MutexLock mu(*Locks::thread_list_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001713 thread = DecodeThread(soa, thread_id);
1714 if (thread == NULL) {
1715 return JDWP::ERR_INVALID_THREAD;
1716 }
Ian Rogersb726dcb2012-09-05 08:57:23 -07001717 MutexLock mu2(*Locks::thread_suspend_count_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001718 if (!thread->IsSuspended()) {
1719 return JDWP::ERR_THREAD_NOT_SUSPENDED;
1720 }
Elliott Hughes6e9d22c2012-06-22 15:02:37 -07001721 }
Elliott Hughescaf76542012-06-28 16:08:22 -07001722 UniquePtr<Context> context(Context::Create());
Elliott Hughes6e9d22c2012-06-22 15:02:37 -07001723 GetThisVisitor visitor(thread->GetManagedStack(), thread->GetTraceStack(), context.get(), frame_id);
Ian Rogers0399dde2012-06-06 17:09:28 -07001724 visitor.WalkStack();
Elliott Hughes6e9d22c2012-06-22 15:02:37 -07001725 *result = gRegistry->Add(visitor.this_object);
1726 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001727}
1728
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001729void Dbg::GetLocalValue(JDWP::ObjectId threadId, JDWP::FrameId frameId, int slot, JDWP::JdwpTag tag,
1730 uint8_t* buf, size_t width) {
Ian Rogers0399dde2012-06-06 17:09:28 -07001731 struct GetLocalVisitor : public StackVisitor {
1732 GetLocalVisitor(const ManagedStack* stack, const std::vector<TraceStackFrame>* trace_stack,
1733 Context* context, JDWP::FrameId frameId, int slot, JDWP::JdwpTag tag,
Ian Rogersca190662012-06-26 15:45:57 -07001734 uint8_t* buf, size_t width)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001735 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
Ian Rogersca190662012-06-26 15:45:57 -07001736 : StackVisitor(stack, trace_stack, context), frame_id_(frameId), slot_(slot), tag_(tag),
1737 buf_(buf), width_(width) {}
1738
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001739 // TODO: Enable annotalysis. We know lock is held in constructor, but abstraction confuses
1740 // annotalysis.
1741 bool VisitFrame() NO_THREAD_SAFETY_ANALYSIS {
Ian Rogers0399dde2012-06-06 17:09:28 -07001742 if (GetFrameId() != frame_id_) {
1743 return true; // Not our frame, carry on.
Elliott Hughesdbb40792011-11-18 17:05:22 -08001744 }
Ian Rogers0399dde2012-06-06 17:09:28 -07001745 // TODO: check that the tag is compatible with the actual type of the slot!
Mathieu Chartier66f19252012-09-18 08:57:04 -07001746 AbstractMethod* m = GetMethod();
Ian Rogers0399dde2012-06-06 17:09:28 -07001747 uint16_t reg = DemangleSlot(slot_, m);
Elliott Hughesdbb40792011-11-18 17:05:22 -08001748
Ian Rogers0399dde2012-06-06 17:09:28 -07001749 switch (tag_) {
1750 case JDWP::JT_BOOLEAN:
1751 {
1752 CHECK_EQ(width_, 1U);
1753 uint32_t intVal = GetVReg(m, reg);
1754 VLOG(jdwp) << "get boolean local " << reg << " = " << intVal;
1755 JDWP::Set1(buf_+1, intVal != 0);
1756 }
1757 break;
1758 case JDWP::JT_BYTE:
1759 {
1760 CHECK_EQ(width_, 1U);
1761 uint32_t intVal = GetVReg(m, reg);
1762 VLOG(jdwp) << "get byte local " << reg << " = " << intVal;
1763 JDWP::Set1(buf_+1, intVal);
1764 }
1765 break;
1766 case JDWP::JT_SHORT:
1767 case JDWP::JT_CHAR:
1768 {
1769 CHECK_EQ(width_, 2U);
1770 uint32_t intVal = GetVReg(m, reg);
1771 VLOG(jdwp) << "get short/char local " << reg << " = " << intVal;
1772 JDWP::Set2BE(buf_+1, intVal);
1773 }
1774 break;
1775 case JDWP::JT_INT:
1776 case JDWP::JT_FLOAT:
1777 {
1778 CHECK_EQ(width_, 4U);
1779 uint32_t intVal = GetVReg(m, reg);
1780 VLOG(jdwp) << "get int/float local " << reg << " = " << intVal;
1781 JDWP::Set4BE(buf_+1, intVal);
1782 }
1783 break;
1784 case JDWP::JT_ARRAY:
1785 {
1786 CHECK_EQ(width_, sizeof(JDWP::ObjectId));
1787 Object* o = reinterpret_cast<Object*>(GetVReg(m, reg));
1788 VLOG(jdwp) << "get array local " << reg << " = " << o;
1789 if (!Runtime::Current()->GetHeap()->IsHeapAddress(o)) {
1790 LOG(FATAL) << "Register " << reg << " expected to hold array: " << o;
1791 }
1792 JDWP::SetObjectId(buf_+1, gRegistry->Add(o));
1793 }
1794 break;
1795 case JDWP::JT_CLASS_LOADER:
1796 case JDWP::JT_CLASS_OBJECT:
1797 case JDWP::JT_OBJECT:
1798 case JDWP::JT_STRING:
1799 case JDWP::JT_THREAD:
1800 case JDWP::JT_THREAD_GROUP:
1801 {
1802 CHECK_EQ(width_, sizeof(JDWP::ObjectId));
1803 Object* o = reinterpret_cast<Object*>(GetVReg(m, reg));
1804 VLOG(jdwp) << "get object local " << reg << " = " << o;
1805 if (!Runtime::Current()->GetHeap()->IsHeapAddress(o)) {
1806 LOG(FATAL) << "Register " << reg << " expected to hold object: " << o;
1807 }
1808 tag_ = TagFromObject(o);
1809 JDWP::SetObjectId(buf_+1, gRegistry->Add(o));
1810 }
1811 break;
1812 case JDWP::JT_DOUBLE:
1813 case JDWP::JT_LONG:
1814 {
1815 CHECK_EQ(width_, 8U);
1816 uint32_t lo = GetVReg(m, reg);
1817 uint64_t hi = GetVReg(m, reg + 1);
1818 uint64_t longVal = (hi << 32) | lo;
1819 VLOG(jdwp) << "get double/long local " << hi << ":" << lo << " = " << longVal;
1820 JDWP::Set8BE(buf_+1, longVal);
1821 }
1822 break;
1823 default:
1824 LOG(FATAL) << "Unknown tag " << tag_;
1825 break;
1826 }
1827
1828 // Prepend tag, which may have been updated.
1829 JDWP::Set1(buf_, tag_);
1830 return false;
1831 }
1832
1833 const JDWP::FrameId frame_id_;
1834 const int slot_;
1835 JDWP::JdwpTag tag_;
1836 uint8_t* const buf_;
1837 const size_t width_;
1838 };
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001839
1840 ScopedObjectAccessUnchecked soa(Thread::Current());
1841 Thread* thread = DecodeThread(soa, threadId);
Ian Rogers0399dde2012-06-06 17:09:28 -07001842 UniquePtr<Context> context(Context::Create());
1843 GetLocalVisitor visitor(thread->GetManagedStack(), thread->GetTraceStack(), context.get(),
1844 frameId, slot, tag, buf, width);
1845 visitor.WalkStack();
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001846}
1847
Ian Rogers0399dde2012-06-06 17:09:28 -07001848void Dbg::SetLocalValue(JDWP::ObjectId threadId, JDWP::FrameId frameId, int slot, JDWP::JdwpTag tag,
1849 uint64_t value, size_t width) {
1850 struct SetLocalVisitor : public StackVisitor {
Elliott Hughes08fc03a2012-06-26 17:34:00 -07001851 SetLocalVisitor(const ManagedStack* stack, const std::vector<TraceStackFrame>* trace_stack, Context* context,
Ian Rogers0399dde2012-06-06 17:09:28 -07001852 JDWP::FrameId frame_id, int slot, JDWP::JdwpTag tag, uint64_t value,
Ian Rogersca190662012-06-26 15:45:57 -07001853 size_t width)
Ian Rogersb726dcb2012-09-05 08:57:23 -07001854 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
Elliott Hughes08fc03a2012-06-26 17:34:00 -07001855 : StackVisitor(stack, trace_stack, context),
1856 frame_id_(frame_id), slot_(slot), tag_(tag), value_(value), width_(width) {}
Ian Rogersca190662012-06-26 15:45:57 -07001857
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001858 // TODO: Enable annotalysis. We know lock is held in constructor, but abstraction confuses
1859 // annotalysis.
1860 bool VisitFrame() NO_THREAD_SAFETY_ANALYSIS {
Ian Rogers0399dde2012-06-06 17:09:28 -07001861 if (GetFrameId() != frame_id_) {
1862 return true; // Not our frame, carry on.
1863 }
1864 // TODO: check that the tag is compatible with the actual type of the slot!
Mathieu Chartier66f19252012-09-18 08:57:04 -07001865 AbstractMethod* m = GetMethod();
Ian Rogers0399dde2012-06-06 17:09:28 -07001866 uint16_t reg = DemangleSlot(slot_, m);
1867
1868 switch (tag_) {
1869 case JDWP::JT_BOOLEAN:
1870 case JDWP::JT_BYTE:
1871 CHECK_EQ(width_, 1U);
1872 SetVReg(m, reg, static_cast<uint32_t>(value_));
1873 break;
1874 case JDWP::JT_SHORT:
1875 case JDWP::JT_CHAR:
1876 CHECK_EQ(width_, 2U);
1877 SetVReg(m, reg, static_cast<uint32_t>(value_));
1878 break;
1879 case JDWP::JT_INT:
1880 case JDWP::JT_FLOAT:
1881 CHECK_EQ(width_, 4U);
1882 SetVReg(m, reg, static_cast<uint32_t>(value_));
1883 break;
1884 case JDWP::JT_ARRAY:
1885 case JDWP::JT_OBJECT:
1886 case JDWP::JT_STRING:
1887 {
1888 CHECK_EQ(width_, sizeof(JDWP::ObjectId));
1889 Object* o = gRegistry->Get<Object*>(static_cast<JDWP::ObjectId>(value_));
1890 if (o == kInvalidObject) {
1891 UNIMPLEMENTED(FATAL) << "return an error code when given an invalid object to store";
1892 }
1893 SetVReg(m, reg, static_cast<uint32_t>(reinterpret_cast<uintptr_t>(o)));
1894 }
1895 break;
1896 case JDWP::JT_DOUBLE:
1897 case JDWP::JT_LONG:
1898 CHECK_EQ(width_, 8U);
1899 SetVReg(m, reg, static_cast<uint32_t>(value_));
1900 SetVReg(m, reg + 1, static_cast<uint32_t>(value_ >> 32));
1901 break;
1902 default:
1903 LOG(FATAL) << "Unknown tag " << tag_;
1904 break;
1905 }
1906 return false;
1907 }
1908
1909 const JDWP::FrameId frame_id_;
1910 const int slot_;
1911 const JDWP::JdwpTag tag_;
1912 const uint64_t value_;
1913 const size_t width_;
1914 };
Ian Rogers00f7d0e2012-07-19 15:28:27 -07001915
1916 ScopedObjectAccessUnchecked soa(Thread::Current());
1917 Thread* thread = DecodeThread(soa, threadId);
Elliott Hughes08fc03a2012-06-26 17:34:00 -07001918 UniquePtr<Context> context(Context::Create());
1919 SetLocalVisitor visitor(thread->GetManagedStack(), thread->GetTraceStack(), context.get(),
1920 frameId, slot, tag, value, width);
Ian Rogers0399dde2012-06-06 17:09:28 -07001921 visitor.WalkStack();
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001922}
1923
Mathieu Chartier66f19252012-09-18 08:57:04 -07001924void Dbg::PostLocationEvent(const AbstractMethod* m, int dex_pc, Object* this_object, int event_flags) {
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08001925 Class* c = m->GetDeclaringClass();
1926
1927 JDWP::JdwpLocation location;
Elliott Hughes74847412012-06-20 18:10:21 -07001928 location.type_tag = c->IsInterface() ? JDWP::TT_INTERFACE : JDWP::TT_CLASS;
1929 location.class_id = gRegistry->Add(c);
1930 location.method_id = ToMethodId(m);
Elliott Hughes972a47b2012-02-21 18:16:06 -08001931 location.dex_pc = m->IsNative() ? -1 : dex_pc;
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08001932
1933 // Note we use "NoReg" so we don't keep track of references that are
1934 // never actually sent to the debugger. 'this_id' is only used to
1935 // compare against registered events...
1936 JDWP::ObjectId this_id = static_cast<JDWP::ObjectId>(reinterpret_cast<uintptr_t>(this_object));
1937 if (gJdwpState->PostLocationEvent(&location, this_id, event_flags)) {
1938 // ...unless there's a registered event, in which case we
1939 // need to really track the class and 'this'.
1940 gRegistry->Add(c);
1941 gRegistry->Add(this_object);
1942 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001943}
1944
Elliott Hughescaf76542012-06-28 16:08:22 -07001945void Dbg::PostException(Thread* thread,
Mathieu Chartier66f19252012-09-18 08:57:04 -07001946 JDWP::FrameId throw_frame_id, AbstractMethod* throw_method, uint32_t throw_dex_pc,
1947 AbstractMethod* catch_method, uint32_t catch_dex_pc, Throwable* exception) {
Elliott Hughesc0f09332012-03-26 13:27:06 -07001948 if (!IsDebuggerActive()) {
Ian Rogers0ad5bb82011-12-07 10:16:32 -08001949 return;
1950 }
Elliott Hughes4740cdf2011-12-07 14:07:12 -08001951
Elliott Hughesd07986f2011-12-06 18:27:45 -08001952 JDWP::JdwpLocation throw_location;
Elliott Hughescaf76542012-06-28 16:08:22 -07001953 SetLocation(throw_location, throw_method, throw_dex_pc);
Elliott Hughesd07986f2011-12-06 18:27:45 -08001954 JDWP::JdwpLocation catch_location;
Elliott Hughescaf76542012-06-28 16:08:22 -07001955 SetLocation(catch_location, catch_method, catch_dex_pc);
Elliott Hughesd07986f2011-12-06 18:27:45 -08001956
1957 // We need 'this' for InstanceOnly filters.
Elliott Hughescaf76542012-06-28 16:08:22 -07001958 UniquePtr<Context> context(Context::Create());
1959 GetThisVisitor visitor(thread->GetManagedStack(), thread->GetTraceStack(), context.get(), throw_frame_id);
1960 visitor.WalkStack();
1961 JDWP::ObjectId this_id = gRegistry->Add(visitor.this_object);
Elliott Hughesd07986f2011-12-06 18:27:45 -08001962
1963 /*
1964 * Hand the event to the JDWP exception handler. Note we're using the
1965 * "NoReg" objectID on the exception, which is not strictly correct --
1966 * the exception object WILL be passed up to the debugger if the
1967 * debugger is interested in the event. We do this because the current
1968 * implementation of the debugger object registry never throws anything
1969 * away, and some people were experiencing a fatal build up of exception
1970 * objects when dealing with certain libraries.
1971 */
1972 JDWP::ObjectId exception_id = static_cast<JDWP::ObjectId>(reinterpret_cast<uintptr_t>(exception));
1973 JDWP::RefTypeId exception_class_id = gRegistry->Add(exception->GetClass());
1974
1975 gJdwpState->PostException(&throw_location, exception_id, exception_class_id, &catch_location, this_id);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001976}
1977
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001978void Dbg::PostClassPrepare(Class* c) {
Elliott Hughesc0f09332012-03-26 13:27:06 -07001979 if (!IsDebuggerActive()) {
Elliott Hughes4740cdf2011-12-07 14:07:12 -08001980 return;
1981 }
1982
Elliott Hughes3d30d9b2011-12-07 17:35:48 -08001983 // OLD-TODO - we currently always send both "verified" and "prepared" since
Elliott Hughes4740cdf2011-12-07 14:07:12 -08001984 // debuggers seem to like that. There might be some advantage to honesty,
1985 // since the class may not yet be verified.
1986 int state = JDWP::CS_VERIFIED | JDWP::CS_PREPARED;
1987 JDWP::JdwpTypeTag tag = c->IsInterface() ? JDWP::TT_INTERFACE : JDWP::TT_CLASS;
1988 gJdwpState->PostClassPrepare(tag, gRegistry->Add(c), ClassHelper(c).GetDescriptor(), state);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07001989}
1990
Elliott Hughescaf76542012-06-28 16:08:22 -07001991void Dbg::UpdateDebugger(int32_t dex_pc, Thread* self) {
Elliott Hughesc0f09332012-03-26 13:27:06 -07001992 if (!IsDebuggerActive() || dex_pc == -2 /* fake method exit */) {
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08001993 return;
1994 }
1995
Elliott Hughescaf76542012-06-28 16:08:22 -07001996 size_t frame_id;
Mathieu Chartier66f19252012-09-18 08:57:04 -07001997 AbstractMethod* m = self->GetCurrentMethod(NULL, &frame_id);
Elliott Hughescaf76542012-06-28 16:08:22 -07001998 //LOG(INFO) << "UpdateDebugger " << PrettyMethod(m) << "@" << dex_pc << " frame " << frame_id;
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08001999
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08002000 if (dex_pc == -1) {
Elliott Hughes2aa2e392012-02-17 17:15:43 -08002001 // We use a pc of -1 to represent method entry, since we might branch back to pc 0 later.
2002 // This means that for this special notification, there can't be anything else interesting
2003 // going on, so we're done already.
Elliott Hughescaf76542012-06-28 16:08:22 -07002004 Dbg::PostLocationEvent(m, 0, GetThis(self, m, frame_id), kMethodEntry);
Elliott Hughes2aa2e392012-02-17 17:15:43 -08002005 return;
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08002006 }
2007
Elliott Hughes2aa2e392012-02-17 17:15:43 -08002008 int event_flags = 0;
2009
Elliott Hughes86964332012-02-15 19:37:42 -08002010 if (IsBreakpoint(m, dex_pc)) {
2011 event_flags |= kBreakpoint;
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08002012 }
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08002013
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08002014 // If the debugger is single-stepping one of our threads, check to
2015 // see if we're that thread and we've reached a step point.
Elliott Hughesf8349362012-06-18 15:00:06 -07002016 MutexLock mu(gBreakpointsLock);
Elliott Hughes86964332012-02-15 19:37:42 -08002017 if (gSingleStepControl.is_active && gSingleStepControl.thread == self) {
2018 CHECK(!m->IsNative());
2019 if (gSingleStepControl.step_depth == JDWP::SD_INTO) {
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08002020 // Step into method calls. We break when the line number
2021 // or method pointer changes. If we're in SS_MIN mode, we
2022 // always stop.
Elliott Hughes86964332012-02-15 19:37:42 -08002023 if (gSingleStepControl.method != m) {
2024 event_flags |= kSingleStep;
2025 VLOG(jdwp) << "SS new method";
2026 } else if (gSingleStepControl.step_size == JDWP::SS_MIN) {
2027 event_flags |= kSingleStep;
2028 VLOG(jdwp) << "SS new instruction";
Elliott Hughes2435a572012-02-17 16:07:41 -08002029 } else if (gSingleStepControl.dex_pcs.find(dex_pc) == gSingleStepControl.dex_pcs.end()) {
2030 event_flags |= kSingleStep;
2031 VLOG(jdwp) << "SS new line";
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08002032 }
Elliott Hughes86964332012-02-15 19:37:42 -08002033 } else if (gSingleStepControl.step_depth == JDWP::SD_OVER) {
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08002034 // Step over method calls. We break when the line number is
2035 // different and the frame depth is <= the original frame
2036 // depth. (We can't just compare on the method, because we
2037 // might get unrolled past it by an exception, and it's tricky
2038 // to identify recursion.)
Elliott Hughes86964332012-02-15 19:37:42 -08002039
2040 // TODO: can we just use the value of 'sp'?
2041 int stack_depth = GetStackDepth(self);
2042
2043 if (stack_depth < gSingleStepControl.stack_depth) {
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08002044 // popped up one or more frames, always trigger
Elliott Hughes86964332012-02-15 19:37:42 -08002045 event_flags |= kSingleStep;
2046 VLOG(jdwp) << "SS method pop";
2047 } else if (stack_depth == gSingleStepControl.stack_depth) {
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08002048 // same depth, see if we moved
Elliott Hughes86964332012-02-15 19:37:42 -08002049 if (gSingleStepControl.step_size == JDWP::SS_MIN) {
2050 event_flags |= kSingleStep;
2051 VLOG(jdwp) << "SS new instruction";
Elliott Hughes2435a572012-02-17 16:07:41 -08002052 } else if (gSingleStepControl.dex_pcs.find(dex_pc) == gSingleStepControl.dex_pcs.end()) {
2053 event_flags |= kSingleStep;
2054 VLOG(jdwp) << "SS new line";
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08002055 }
2056 }
2057 } else {
Elliott Hughes86964332012-02-15 19:37:42 -08002058 CHECK_EQ(gSingleStepControl.step_depth, JDWP::SD_OUT);
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08002059 // Return from the current method. We break when the frame
2060 // depth pops up.
2061
2062 // This differs from the "method exit" break in that it stops
2063 // with the PC at the next instruction in the returned-to
2064 // function, rather than the end of the returning function.
Elliott Hughes86964332012-02-15 19:37:42 -08002065
2066 // TODO: can we just use the value of 'sp'?
2067 int stack_depth = GetStackDepth(self);
2068 if (stack_depth < gSingleStepControl.stack_depth) {
2069 event_flags |= kSingleStep;
2070 VLOG(jdwp) << "SS method pop";
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08002071 }
2072 }
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08002073 }
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08002074
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08002075 // Check to see if this is a "return" instruction. JDWP says we should
2076 // send the event *after* the code has been executed, but it also says
2077 // the location we provide is the last instruction. Since the "return"
2078 // instruction has no interesting side effects, we should be safe.
2079 // (We can't just move this down to the returnFromMethod label because
2080 // we potentially need to combine it with other events.)
2081 // We're also not supposed to generate a method exit event if the method
2082 // terminates "with a thrown exception".
Elliott Hughes86964332012-02-15 19:37:42 -08002083 if (dex_pc >= 0) {
2084 const DexFile::CodeItem* code_item = MethodHelper(m).GetCodeItem();
Elliott Hughescaf76542012-06-28 16:08:22 -07002085 CHECK(code_item != NULL) << PrettyMethod(m) << " @" << dex_pc;
Elliott Hughes86964332012-02-15 19:37:42 -08002086 CHECK_LT(dex_pc, static_cast<int32_t>(code_item->insns_size_in_code_units_));
2087 if (Instruction::At(&code_item->insns_[dex_pc])->IsReturn()) {
2088 event_flags |= kMethodExit;
2089 }
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08002090 }
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08002091
2092 // If there's something interesting going on, see if it matches one
2093 // of the debugger filters.
2094 if (event_flags != 0) {
Elliott Hughescaf76542012-06-28 16:08:22 -07002095 Dbg::PostLocationEvent(m, dex_pc, GetThis(self, m, frame_id), event_flags);
Elliott Hughes91bf6cd2012-02-14 17:27:48 -08002096 }
2097}
2098
Elliott Hughes86964332012-02-15 19:37:42 -08002099void Dbg::WatchLocation(const JDWP::JdwpLocation* location) {
2100 MutexLock mu(gBreakpointsLock);
Mathieu Chartier66f19252012-09-18 08:57:04 -07002101 AbstractMethod* m = FromMethodId(location->method_id);
Elliott Hughes972a47b2012-02-21 18:16:06 -08002102 gBreakpoints.push_back(Breakpoint(m, location->dex_pc));
Elliott Hughes86964332012-02-15 19:37:42 -08002103 VLOG(jdwp) << "Set breakpoint #" << (gBreakpoints.size() - 1) << ": " << gBreakpoints[gBreakpoints.size() - 1];
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002104}
2105
Elliott Hughes86964332012-02-15 19:37:42 -08002106void Dbg::UnwatchLocation(const JDWP::JdwpLocation* location) {
2107 MutexLock mu(gBreakpointsLock);
Mathieu Chartier66f19252012-09-18 08:57:04 -07002108 AbstractMethod* m = FromMethodId(location->method_id);
Elliott Hughes86964332012-02-15 19:37:42 -08002109 for (size_t i = 0; i < gBreakpoints.size(); ++i) {
Elliott Hughes972a47b2012-02-21 18:16:06 -08002110 if (gBreakpoints[i].method == m && gBreakpoints[i].dex_pc == location->dex_pc) {
Elliott Hughes86964332012-02-15 19:37:42 -08002111 VLOG(jdwp) << "Removed breakpoint #" << i << ": " << gBreakpoints[i];
2112 gBreakpoints.erase(gBreakpoints.begin() + i);
2113 return;
2114 }
2115 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002116}
2117
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002118JDWP::JdwpError Dbg::ConfigureStep(JDWP::ObjectId threadId, JDWP::JdwpStepSize step_size,
2119 JDWP::JdwpStepDepth step_depth) {
2120 ScopedObjectAccessUnchecked soa(Thread::Current());
2121 Thread* thread = DecodeThread(soa, threadId);
Elliott Hughes2435a572012-02-17 16:07:41 -08002122 if (thread == NULL) {
2123 return JDWP::ERR_INVALID_THREAD;
2124 }
Elliott Hughes86964332012-02-15 19:37:42 -08002125
Elliott Hughesf8349362012-06-18 15:00:06 -07002126 MutexLock mu(gBreakpointsLock);
Elliott Hughes86964332012-02-15 19:37:42 -08002127 // TODO: there's no theoretical reason why we couldn't support single-stepping
2128 // of multiple threads at once, but we never did so historically.
2129 if (gSingleStepControl.thread != NULL && thread != gSingleStepControl.thread) {
2130 LOG(WARNING) << "single-step already active for " << *gSingleStepControl.thread
2131 << "; switching to " << *thread;
2132 }
2133
Elliott Hughes2435a572012-02-17 16:07:41 -08002134 //
2135 // Work out what Method* we're in, the current line number, and how deep the stack currently
2136 // is for step-out.
2137 //
2138
Ian Rogers0399dde2012-06-06 17:09:28 -07002139 struct SingleStepStackVisitor : public StackVisitor {
2140 SingleStepStackVisitor(const ManagedStack* stack,
Ian Rogersca190662012-06-26 15:45:57 -07002141 const std::vector<TraceStackFrame>* trace_stack)
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002142 EXCLUSIVE_LOCKS_REQUIRED(gBreakpointsLock)
Ian Rogersb726dcb2012-09-05 08:57:23 -07002143 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
Elliott Hughes08fc03a2012-06-26 17:34:00 -07002144 : StackVisitor(stack, trace_stack, NULL) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002145 gBreakpointsLock.AssertHeld();
Elliott Hughes86964332012-02-15 19:37:42 -08002146 gSingleStepControl.method = NULL;
2147 gSingleStepControl.stack_depth = 0;
2148 }
Ian Rogersca190662012-06-26 15:45:57 -07002149
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002150 // TODO: Enable annotalysis. We know lock is held in constructor, but abstraction confuses
2151 // annotalysis.
2152 bool VisitFrame() NO_THREAD_SAFETY_ANALYSIS {
2153 gBreakpointsLock.AssertHeld();
Mathieu Chartier66f19252012-09-18 08:57:04 -07002154 const AbstractMethod* m = GetMethod();
Ian Rogers0399dde2012-06-06 17:09:28 -07002155 if (!m->IsRuntimeMethod()) {
Elliott Hughes86964332012-02-15 19:37:42 -08002156 ++gSingleStepControl.stack_depth;
2157 if (gSingleStepControl.method == NULL) {
Elliott Hughes2435a572012-02-17 16:07:41 -08002158 const DexCache* dex_cache = m->GetDeclaringClass()->GetDexCache();
2159 gSingleStepControl.method = m;
2160 gSingleStepControl.line_number = -1;
2161 if (dex_cache != NULL) {
2162 const DexFile& dex_file = Runtime::Current()->GetClassLinker()->FindDexFile(dex_cache);
Ian Rogers0399dde2012-06-06 17:09:28 -07002163 gSingleStepControl.line_number = dex_file.GetLineNumFromPC(m, GetDexPc());
Elliott Hughes2435a572012-02-17 16:07:41 -08002164 }
Elliott Hughes86964332012-02-15 19:37:42 -08002165 }
2166 }
Elliott Hughes530fa002012-03-12 11:44:49 -07002167 return true;
Elliott Hughes86964332012-02-15 19:37:42 -08002168 }
2169 };
Ian Rogers0399dde2012-06-06 17:09:28 -07002170 SingleStepStackVisitor visitor(thread->GetManagedStack(), thread->GetTraceStack());
2171 visitor.WalkStack();
Elliott Hughes86964332012-02-15 19:37:42 -08002172
Elliott Hughes2435a572012-02-17 16:07:41 -08002173 //
2174 // Find the dex_pc values that correspond to the current line, for line-based single-stepping.
2175 //
2176
2177 struct DebugCallbackContext {
2178 DebugCallbackContext() {
2179 last_pc_valid = false;
2180 last_pc = 0;
Elliott Hughes2435a572012-02-17 16:07:41 -08002181 }
2182
2183 static bool Callback(void* raw_context, uint32_t address, uint32_t line_number) {
Elliott Hughesf8349362012-06-18 15:00:06 -07002184 MutexLock mu(gBreakpointsLock); // Keep GCC happy.
Elliott Hughes2435a572012-02-17 16:07:41 -08002185 DebugCallbackContext* context = reinterpret_cast<DebugCallbackContext*>(raw_context);
2186 if (static_cast<int32_t>(line_number) == gSingleStepControl.line_number) {
2187 if (!context->last_pc_valid) {
2188 // Everything from this address until the next line change is ours.
2189 context->last_pc = address;
2190 context->last_pc_valid = true;
2191 }
2192 // Otherwise, if we're already in a valid range for this line,
2193 // just keep going (shouldn't really happen)...
2194 } else if (context->last_pc_valid) { // and the line number is new
2195 // Add everything from the last entry up until here to the set
2196 for (uint32_t dex_pc = context->last_pc; dex_pc < address; ++dex_pc) {
2197 gSingleStepControl.dex_pcs.insert(dex_pc);
2198 }
2199 context->last_pc_valid = false;
2200 }
2201 return false; // There may be multiple entries for any given line.
2202 }
2203
2204 ~DebugCallbackContext() {
Elliott Hughesf8349362012-06-18 15:00:06 -07002205 MutexLock mu(gBreakpointsLock); // Keep GCC happy.
Elliott Hughes2435a572012-02-17 16:07:41 -08002206 // If the line number was the last in the position table...
2207 if (last_pc_valid) {
2208 size_t end = MethodHelper(gSingleStepControl.method).GetCodeItem()->insns_size_in_code_units_;
2209 for (uint32_t dex_pc = last_pc; dex_pc < end; ++dex_pc) {
2210 gSingleStepControl.dex_pcs.insert(dex_pc);
2211 }
2212 }
2213 }
2214
2215 bool last_pc_valid;
2216 uint32_t last_pc;
2217 };
Elliott Hughes3e2e1a22012-02-21 11:33:41 -08002218 gSingleStepControl.dex_pcs.clear();
Mathieu Chartier66f19252012-09-18 08:57:04 -07002219 const AbstractMethod* m = gSingleStepControl.method;
Elliott Hughes3e2e1a22012-02-21 11:33:41 -08002220 if (m->IsNative()) {
2221 gSingleStepControl.line_number = -1;
2222 } else {
2223 DebugCallbackContext context;
2224 MethodHelper mh(m);
2225 mh.GetDexFile().DecodeDebugInfo(mh.GetCodeItem(), m->IsStatic(), m->GetDexMethodIndex(),
2226 DebugCallbackContext::Callback, NULL, &context);
2227 }
Elliott Hughes2435a572012-02-17 16:07:41 -08002228
2229 //
2230 // Everything else...
2231 //
2232
Elliott Hughes86964332012-02-15 19:37:42 -08002233 gSingleStepControl.thread = thread;
2234 gSingleStepControl.step_size = step_size;
2235 gSingleStepControl.step_depth = step_depth;
2236 gSingleStepControl.is_active = true;
2237
Elliott Hughes2435a572012-02-17 16:07:41 -08002238 if (VLOG_IS_ON(jdwp)) {
2239 VLOG(jdwp) << "Single-step thread: " << *gSingleStepControl.thread;
2240 VLOG(jdwp) << "Single-step step size: " << gSingleStepControl.step_size;
2241 VLOG(jdwp) << "Single-step step depth: " << gSingleStepControl.step_depth;
2242 VLOG(jdwp) << "Single-step current method: " << PrettyMethod(gSingleStepControl.method);
2243 VLOG(jdwp) << "Single-step current line: " << gSingleStepControl.line_number;
2244 VLOG(jdwp) << "Single-step current stack depth: " << gSingleStepControl.stack_depth;
2245 VLOG(jdwp) << "Single-step dex_pc values:";
2246 for (std::set<uint32_t>::iterator it = gSingleStepControl.dex_pcs.begin() ; it != gSingleStepControl.dex_pcs.end(); ++it) {
Elliott Hughes229feb72012-02-23 13:33:29 -08002247 VLOG(jdwp) << StringPrintf(" %#x", *it);
Elliott Hughes2435a572012-02-17 16:07:41 -08002248 }
2249 }
2250
2251 return JDWP::ERR_NONE;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002252}
2253
Elliott Hughes1bac54f2012-03-16 12:48:31 -07002254void Dbg::UnconfigureStep(JDWP::ObjectId /*threadId*/) {
Elliott Hughesf8349362012-06-18 15:00:06 -07002255 MutexLock mu(gBreakpointsLock);
2256
Elliott Hughes86964332012-02-15 19:37:42 -08002257 gSingleStepControl.is_active = false;
2258 gSingleStepControl.thread = NULL;
Elliott Hughes2435a572012-02-17 16:07:41 -08002259 gSingleStepControl.dex_pcs.clear();
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002260}
2261
Elliott Hughes45651fd2012-02-21 15:48:20 -08002262static char JdwpTagToShortyChar(JDWP::JdwpTag tag) {
2263 switch (tag) {
2264 default:
2265 LOG(FATAL) << "unknown JDWP tag: " << PrintableChar(tag);
2266
2267 // Primitives.
2268 case JDWP::JT_BYTE: return 'B';
2269 case JDWP::JT_CHAR: return 'C';
2270 case JDWP::JT_FLOAT: return 'F';
2271 case JDWP::JT_DOUBLE: return 'D';
2272 case JDWP::JT_INT: return 'I';
2273 case JDWP::JT_LONG: return 'J';
2274 case JDWP::JT_SHORT: return 'S';
2275 case JDWP::JT_VOID: return 'V';
2276 case JDWP::JT_BOOLEAN: return 'Z';
2277
2278 // Reference types.
2279 case JDWP::JT_ARRAY:
2280 case JDWP::JT_OBJECT:
2281 case JDWP::JT_STRING:
2282 case JDWP::JT_THREAD:
2283 case JDWP::JT_THREAD_GROUP:
2284 case JDWP::JT_CLASS_LOADER:
2285 case JDWP::JT_CLASS_OBJECT:
2286 return 'L';
2287 }
2288}
2289
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002290JDWP::JdwpError Dbg::InvokeMethod(JDWP::ObjectId threadId, JDWP::ObjectId objectId,
2291 JDWP::RefTypeId classId, JDWP::MethodId methodId,
2292 uint32_t arg_count, uint64_t* arg_values,
2293 JDWP::JdwpTag* arg_types, uint32_t options,
2294 JDWP::JdwpTag* pResultTag, uint64_t* pResultValue,
2295 JDWP::ObjectId* pExceptionId) {
Elliott Hughesd07986f2011-12-06 18:27:45 -08002296 ThreadList* thread_list = Runtime::Current()->GetThreadList();
2297
2298 Thread* targetThread = NULL;
2299 DebugInvokeReq* req = NULL;
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002300 Thread* self = Thread::Current();
Elliott Hughesd07986f2011-12-06 18:27:45 -08002301 {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002302 ScopedObjectAccessUnchecked soa(self);
Ian Rogersb726dcb2012-09-05 08:57:23 -07002303 MutexLock mu(*Locks::thread_list_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002304 targetThread = DecodeThread(soa, threadId);
Elliott Hughesd07986f2011-12-06 18:27:45 -08002305 if (targetThread == NULL) {
2306 LOG(ERROR) << "InvokeMethod request for non-existent thread " << threadId;
2307 return JDWP::ERR_INVALID_THREAD;
2308 }
2309 req = targetThread->GetInvokeReq();
2310 if (!req->ready) {
2311 LOG(ERROR) << "InvokeMethod request for thread not stopped by event: " << *targetThread;
2312 return JDWP::ERR_INVALID_THREAD;
2313 }
2314
2315 /*
2316 * We currently have a bug where we don't successfully resume the
2317 * target thread if the suspend count is too deep. We're expected to
2318 * require one "resume" for each "suspend", but when asked to execute
2319 * a method we have to resume fully and then re-suspend it back to the
2320 * same level. (The easiest way to cause this is to type "suspend"
2321 * multiple times in jdb.)
2322 *
2323 * It's unclear what this means when the event specifies "resume all"
2324 * and some threads are suspended more deeply than others. This is
2325 * a rare problem, so for now we just prevent it from hanging forever
2326 * by rejecting the method invocation request. Without this, we will
2327 * be stuck waiting on a suspended thread.
2328 */
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002329 int suspend_count;
2330 {
Ian Rogersb726dcb2012-09-05 08:57:23 -07002331 MutexLock mu2(*Locks::thread_suspend_count_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002332 suspend_count = targetThread->GetSuspendCount();
2333 }
Elliott Hughesd07986f2011-12-06 18:27:45 -08002334 if (suspend_count > 1) {
2335 LOG(ERROR) << *targetThread << " suspend count too deep for method invocation: " << suspend_count;
2336 return JDWP::ERR_THREAD_SUSPENDED; // Probably not expected here.
2337 }
2338
Elliott Hughes3f4d58f2012-02-18 20:05:37 -08002339 JDWP::JdwpError status;
Elliott Hughes45651fd2012-02-21 15:48:20 -08002340 Object* receiver = gRegistry->Get<Object*>(objectId);
2341 if (receiver == kInvalidObject) {
Elliott Hughes3f4d58f2012-02-18 20:05:37 -08002342 return JDWP::ERR_INVALID_OBJECT;
2343 }
Elliott Hughes45651fd2012-02-21 15:48:20 -08002344
2345 Object* thread = gRegistry->Get<Object*>(threadId);
2346 if (thread == kInvalidObject) {
Elliott Hughes3f4d58f2012-02-18 20:05:37 -08002347 return JDWP::ERR_INVALID_OBJECT;
2348 }
Elliott Hughes45651fd2012-02-21 15:48:20 -08002349 // TODO: check that 'thread' is actually a java.lang.Thread!
2350
2351 Class* c = DecodeClass(classId, status);
2352 if (c == NULL) {
Elliott Hughes3f4d58f2012-02-18 20:05:37 -08002353 return status;
2354 }
Elliott Hughes45651fd2012-02-21 15:48:20 -08002355
Mathieu Chartier66f19252012-09-18 08:57:04 -07002356 AbstractMethod* m = FromMethodId(methodId);
Elliott Hughes45651fd2012-02-21 15:48:20 -08002357 if (m->IsStatic() != (receiver == NULL)) {
2358 return JDWP::ERR_INVALID_METHODID;
2359 }
2360 if (m->IsStatic()) {
2361 if (m->GetDeclaringClass() != c) {
2362 return JDWP::ERR_INVALID_METHODID;
2363 }
2364 } else {
2365 if (!m->GetDeclaringClass()->IsAssignableFrom(c)) {
2366 return JDWP::ERR_INVALID_METHODID;
2367 }
2368 }
2369
2370 // Check the argument list matches the method.
2371 MethodHelper mh(m);
2372 if (mh.GetShortyLength() - 1 != arg_count) {
2373 return JDWP::ERR_ILLEGAL_ARGUMENT;
2374 }
2375 const char* shorty = mh.GetShorty();
2376 for (size_t i = 0; i < arg_count; ++i) {
2377 if (shorty[i + 1] != JdwpTagToShortyChar(arg_types[i])) {
2378 return JDWP::ERR_ILLEGAL_ARGUMENT;
2379 }
2380 }
2381
2382 req->receiver_ = receiver;
2383 req->thread_ = thread;
2384 req->class_ = c;
2385 req->method_ = m;
2386 req->arg_count_ = arg_count;
2387 req->arg_values_ = arg_values;
Elliott Hughesd07986f2011-12-06 18:27:45 -08002388 req->options_ = options;
2389 req->invoke_needed_ = true;
2390 }
2391
2392 // The fact that we've released the thread list lock is a bit risky --- if the thread goes
2393 // away we're sitting high and dry -- but we must release this before the ResumeAllThreads
2394 // call, and it's unwise to hold it during WaitForSuspend.
2395
2396 {
2397 /*
2398 * We change our (JDWP thread) status, which should be THREAD_RUNNING,
Elliott Hughes81ff3182012-03-23 20:35:56 -07002399 * so we can suspend for a GC if the invoke request causes us to
Elliott Hughesd07986f2011-12-06 18:27:45 -08002400 * run out of memory. It's also a good idea to change it before locking
2401 * the invokeReq mutex, although that should never be held for long.
2402 */
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002403 self->TransitionFromRunnableToSuspended(kWaitingForDebuggerSend);
Elliott Hughesd07986f2011-12-06 18:27:45 -08002404
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08002405 VLOG(jdwp) << " Transferring control to event thread";
Elliott Hughesd07986f2011-12-06 18:27:45 -08002406 {
2407 MutexLock mu(req->lock_);
2408
2409 if ((options & JDWP::INVOKE_SINGLE_THREADED) == 0) {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08002410 VLOG(jdwp) << " Resuming all threads";
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002411 thread_list->UndoDebuggerSuspensions();
Elliott Hughesd07986f2011-12-06 18:27:45 -08002412 } else {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08002413 VLOG(jdwp) << " Resuming event thread only";
Elliott Hughesd07986f2011-12-06 18:27:45 -08002414 thread_list->Resume(targetThread, true);
2415 }
2416
2417 // Wait for the request to finish executing.
2418 while (req->invoke_needed_) {
Ian Rogers81d425b2012-09-27 16:03:43 -07002419 req->cond_.Wait(self, req->lock_);
Elliott Hughesd07986f2011-12-06 18:27:45 -08002420 }
2421 }
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08002422 VLOG(jdwp) << " Control has returned from event thread";
Elliott Hughesd07986f2011-12-06 18:27:45 -08002423
2424 /* wait for thread to re-suspend itself */
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002425 SuspendThread(threadId, false /* request_suspension */ );
2426 self->TransitionFromSuspendedToRunnable();
Elliott Hughesd07986f2011-12-06 18:27:45 -08002427 }
2428
2429 /*
2430 * Suspend the threads. We waited for the target thread to suspend
2431 * itself, so all we need to do is suspend the others.
2432 *
2433 * The suspendAllThreads() call will double-suspend the event thread,
2434 * so we want to resume the target thread once to keep the books straight.
2435 */
2436 if ((options & JDWP::INVOKE_SINGLE_THREADED) == 0) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002437 self->TransitionFromRunnableToSuspended(kWaitingForDebuggerSuspension);
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08002438 VLOG(jdwp) << " Suspending all threads";
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002439 thread_list->SuspendAllForDebugger();
2440 self->TransitionFromSuspendedToRunnable();
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08002441 VLOG(jdwp) << " Resuming event thread to balance the count";
Elliott Hughesd07986f2011-12-06 18:27:45 -08002442 thread_list->Resume(targetThread, true);
2443 }
2444
2445 // Copy the result.
2446 *pResultTag = req->result_tag;
2447 if (IsPrimitiveTag(req->result_tag)) {
Elliott Hughesf24d3ce2012-04-11 17:43:37 -07002448 *pResultValue = req->result_value.GetJ();
Elliott Hughesd07986f2011-12-06 18:27:45 -08002449 } else {
Elliott Hughesf24d3ce2012-04-11 17:43:37 -07002450 *pResultValue = gRegistry->Add(req->result_value.GetL());
Elliott Hughesd07986f2011-12-06 18:27:45 -08002451 }
2452 *pExceptionId = req->exception;
2453 return req->error;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002454}
2455
2456void Dbg::ExecuteMethod(DebugInvokeReq* pReq) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002457 ScopedObjectAccess soa(Thread::Current());
Elliott Hughesd07986f2011-12-06 18:27:45 -08002458
Elliott Hughes81ff3182012-03-23 20:35:56 -07002459 // We can be called while an exception is pending. We need
Elliott Hughesd07986f2011-12-06 18:27:45 -08002460 // to preserve that across the method invocation.
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002461 SirtRef<Throwable> old_exception(soa.Self()->GetException());
2462 soa.Self()->ClearException();
Elliott Hughesd07986f2011-12-06 18:27:45 -08002463
2464 // Translate the method through the vtable, unless the debugger wants to suppress it.
Mathieu Chartier66f19252012-09-18 08:57:04 -07002465 AbstractMethod* m = pReq->method_;
Elliott Hughesd07986f2011-12-06 18:27:45 -08002466 if ((pReq->options_ & JDWP::INVOKE_NONVIRTUAL) == 0 && pReq->receiver_ != NULL) {
Mathieu Chartier66f19252012-09-18 08:57:04 -07002467 AbstractMethod* actual_method = pReq->class_->FindVirtualMethodForVirtualOrInterface(pReq->method_);
Elliott Hughes45651fd2012-02-21 15:48:20 -08002468 if (actual_method != m) {
2469 VLOG(jdwp) << "ExecuteMethod translated " << PrettyMethod(m) << " to " << PrettyMethod(actual_method);
2470 m = actual_method;
2471 }
Elliott Hughesd07986f2011-12-06 18:27:45 -08002472 }
Elliott Hughes45651fd2012-02-21 15:48:20 -08002473 VLOG(jdwp) << "ExecuteMethod " << PrettyMethod(m);
Elliott Hughesd07986f2011-12-06 18:27:45 -08002474 CHECK(m != NULL);
2475
2476 CHECK_EQ(sizeof(jvalue), sizeof(uint64_t));
2477
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002478 LOG(INFO) << "self=" << soa.Self() << " pReq->receiver_=" << pReq->receiver_ << " m=" << m
2479 << " #" << pReq->arg_count_ << " " << pReq->arg_values_;
2480 pReq->result_value = InvokeWithJValues(soa, pReq->receiver_, m,
2481 reinterpret_cast<JValue*>(pReq->arg_values_));
Elliott Hughesd07986f2011-12-06 18:27:45 -08002482
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002483 pReq->exception = gRegistry->Add(soa.Self()->GetException());
Elliott Hughesd07986f2011-12-06 18:27:45 -08002484 pReq->result_tag = BasicTagFromDescriptor(MethodHelper(m).GetShorty());
2485 if (pReq->exception != 0) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002486 Object* exc = soa.Self()->GetException();
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08002487 VLOG(jdwp) << " JDWP invocation returning with exception=" << exc << " " << PrettyTypeOf(exc);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002488 soa.Self()->ClearException();
Elliott Hughesf24d3ce2012-04-11 17:43:37 -07002489 pReq->result_value.SetJ(0);
Elliott Hughesd07986f2011-12-06 18:27:45 -08002490 } else if (pReq->result_tag == JDWP::JT_OBJECT) {
2491 /* if no exception thrown, examine object result more closely */
Elliott Hughesf24d3ce2012-04-11 17:43:37 -07002492 JDWP::JdwpTag new_tag = TagFromObject(pReq->result_value.GetL());
Elliott Hughesd07986f2011-12-06 18:27:45 -08002493 if (new_tag != pReq->result_tag) {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08002494 VLOG(jdwp) << " JDWP promoted result from " << pReq->result_tag << " to " << new_tag;
Elliott Hughesd07986f2011-12-06 18:27:45 -08002495 pReq->result_tag = new_tag;
2496 }
2497
2498 /*
2499 * Register the object. We don't actually need an ObjectId yet,
2500 * but we do need to be sure that the GC won't move or discard the
2501 * object when we switch out of RUNNING. The ObjectId conversion
2502 * will add the object to the "do not touch" list.
2503 *
2504 * We can't use the "tracked allocation" mechanism here because
2505 * the object is going to be handed off to a different thread.
2506 */
Elliott Hughesf24d3ce2012-04-11 17:43:37 -07002507 gRegistry->Add(pReq->result_value.GetL());
Elliott Hughesd07986f2011-12-06 18:27:45 -08002508 }
2509
2510 if (old_exception.get() != NULL) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002511 soa.Self()->SetException(old_exception.get());
Elliott Hughesd07986f2011-12-06 18:27:45 -08002512 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002513}
2514
Elliott Hughesd07986f2011-12-06 18:27:45 -08002515/*
2516 * Register an object ID that might not have been registered previously.
2517 *
2518 * Normally this wouldn't happen -- the conversion to an ObjectId would
2519 * have added the object to the registry -- but in some cases (e.g.
2520 * throwing exceptions) we really want to do the registration late.
2521 */
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002522void Dbg::RegisterObjectId(JDWP::ObjectId id) {
Elliott Hughesd07986f2011-12-06 18:27:45 -08002523 gRegistry->Add(reinterpret_cast<Object*>(id));
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002524}
2525
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -07002526/*
2527 * "buf" contains a full JDWP packet, possibly with multiple chunks. We
2528 * need to process each, accumulate the replies, and ship the whole thing
2529 * back.
2530 *
2531 * Returns "true" if we have a reply. The reply buffer is newly allocated,
2532 * and includes the chunk type/length, followed by the data.
2533 *
Elliott Hughes3d30d9b2011-12-07 17:35:48 -08002534 * OLD-TODO: we currently assume that the request and reply include a single
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -07002535 * chunk. If this becomes inconvenient we will need to adapt.
2536 */
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002537bool Dbg::DdmHandlePacket(const uint8_t* buf, int dataLen, uint8_t** pReplyBuf, int* pReplyLen) {
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -07002538 CHECK_GE(dataLen, 0);
2539
2540 Thread* self = Thread::Current();
2541 JNIEnv* env = self->GetJniEnv();
2542
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -07002543 // Create a byte[] corresponding to 'buf'.
Elliott Hughes6a5bd492011-10-28 14:33:57 -07002544 ScopedLocalRef<jbyteArray> dataArray(env, env->NewByteArray(dataLen));
2545 if (dataArray.get() == NULL) {
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -07002546 LOG(WARNING) << "byte[] allocation failed: " << dataLen;
2547 env->ExceptionClear();
2548 return false;
2549 }
Elliott Hughes6a5bd492011-10-28 14:33:57 -07002550 env->SetByteArrayRegion(dataArray.get(), 0, dataLen, reinterpret_cast<const jbyte*>(buf));
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -07002551
2552 const int kChunkHdrLen = 8;
2553
2554 // Run through and find all chunks. [Currently just find the first.]
Elliott Hughes6a5bd492011-10-28 14:33:57 -07002555 ScopedByteArrayRO contents(env, dataArray.get());
Elliott Hughesf7c3b662011-10-27 12:04:56 -07002556 jint type = JDWP::Get4BE(reinterpret_cast<const uint8_t*>(&contents[0]));
2557 jint length = JDWP::Get4BE(reinterpret_cast<const uint8_t*>(&contents[4]));
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -07002558 jint offset = kChunkHdrLen;
2559 if (offset + length > dataLen) {
2560 LOG(WARNING) << StringPrintf("bad chunk found (len=%u pktLen=%d)", length, dataLen);
2561 return false;
2562 }
2563
2564 // Call "private static Chunk dispatch(int type, byte[] data, int offset, int length)".
Elliott Hugheseac76672012-05-24 21:56:51 -07002565 ScopedLocalRef<jobject> chunk(env, env->CallStaticObjectMethod(WellKnownClasses::org_apache_harmony_dalvik_ddmc_DdmServer,
2566 WellKnownClasses::org_apache_harmony_dalvik_ddmc_DdmServer_dispatch,
2567 type, dataArray.get(), offset, length));
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -07002568 if (env->ExceptionCheck()) {
2569 LOG(INFO) << StringPrintf("Exception thrown by dispatcher for 0x%08x", type);
2570 env->ExceptionDescribe();
2571 env->ExceptionClear();
2572 return false;
2573 }
2574
Elliott Hughes6a5bd492011-10-28 14:33:57 -07002575 if (chunk.get() == NULL) {
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -07002576 return false;
2577 }
2578
2579 /*
2580 * Pull the pieces out of the chunk. We copy the results into a
2581 * newly-allocated buffer that the caller can free. We don't want to
2582 * continue using the Chunk object because nothing has a reference to it.
2583 *
2584 * We could avoid this by returning type/data/offset/length and having
2585 * the caller be aware of the object lifetime issues, but that
Elliott Hughes81ff3182012-03-23 20:35:56 -07002586 * integrates the JDWP code more tightly into the rest of the runtime, and doesn't work
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -07002587 * if we have responses for multiple chunks.
2588 *
2589 * So we're pretty much stuck with copying data around multiple times.
2590 */
Elliott Hugheseac76672012-05-24 21:56:51 -07002591 ScopedLocalRef<jbyteArray> replyData(env, reinterpret_cast<jbyteArray>(env->GetObjectField(chunk.get(), WellKnownClasses::org_apache_harmony_dalvik_ddmc_Chunk_data)));
2592 length = env->GetIntField(chunk.get(), WellKnownClasses::org_apache_harmony_dalvik_ddmc_Chunk_length);
2593 offset = env->GetIntField(chunk.get(), WellKnownClasses::org_apache_harmony_dalvik_ddmc_Chunk_offset);
2594 type = env->GetIntField(chunk.get(), WellKnownClasses::org_apache_harmony_dalvik_ddmc_Chunk_type);
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -07002595
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08002596 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 -07002597 if (length == 0 || replyData.get() == NULL) {
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -07002598 return false;
2599 }
2600
Elliott Hughes6a5bd492011-10-28 14:33:57 -07002601 jsize replyLength = env->GetArrayLength(replyData.get());
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -07002602 if (offset + length > replyLength) {
2603 LOG(WARNING) << StringPrintf("chunk off=%d len=%d exceeds reply array len %d", offset, length, replyLength);
2604 return false;
2605 }
2606
2607 uint8_t* reply = new uint8_t[length + kChunkHdrLen];
2608 if (reply == NULL) {
2609 LOG(WARNING) << "malloc failed: " << (length + kChunkHdrLen);
2610 return false;
2611 }
Elliott Hughesf7c3b662011-10-27 12:04:56 -07002612 JDWP::Set4BE(reply + 0, type);
2613 JDWP::Set4BE(reply + 4, length);
Elliott Hughes6a5bd492011-10-28 14:33:57 -07002614 env->GetByteArrayRegion(replyData.get(), offset, length, reinterpret_cast<jbyte*>(reply + kChunkHdrLen));
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -07002615
2616 *pReplyBuf = reply;
2617 *pReplyLen = length + kChunkHdrLen;
2618
Elliott Hughesba8eee12012-01-24 20:25:24 -08002619 VLOG(jdwp) << StringPrintf("dvmHandleDdm returning type=%.4s buf=%p len=%d", reinterpret_cast<char*>(reply), reply, length);
Elliott Hughesf6a1e1e2011-10-25 16:28:04 -07002620 return true;
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002621}
2622
Elliott Hughesa2155262011-11-16 16:26:58 -08002623void Dbg::DdmBroadcast(bool connect) {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08002624 VLOG(jdwp) << "Broadcasting DDM " << (connect ? "connect" : "disconnect") << "...";
Elliott Hughes47fce012011-10-25 18:37:19 -07002625
2626 Thread* self = Thread::Current();
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002627 {
Ian Rogersb726dcb2012-09-05 08:57:23 -07002628 MutexLock mu(*Locks::thread_suspend_count_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002629 if (self->GetState() != kRunnable) {
2630 LOG(ERROR) << "DDM broadcast in thread state " << self->GetState();
2631 /* try anyway? */
2632 }
Elliott Hughes47fce012011-10-25 18:37:19 -07002633 }
2634
2635 JNIEnv* env = self->GetJniEnv();
Elliott Hughes47fce012011-10-25 18:37:19 -07002636 jint event = connect ? 1 /*DdmServer.CONNECTED*/ : 2 /*DdmServer.DISCONNECTED*/;
Elliott Hugheseac76672012-05-24 21:56:51 -07002637 env->CallStaticVoidMethod(WellKnownClasses::org_apache_harmony_dalvik_ddmc_DdmServer,
2638 WellKnownClasses::org_apache_harmony_dalvik_ddmc_DdmServer_broadcast,
2639 event);
Elliott Hughes47fce012011-10-25 18:37:19 -07002640 if (env->ExceptionCheck()) {
2641 LOG(ERROR) << "DdmServer.broadcast " << event << " failed";
2642 env->ExceptionDescribe();
2643 env->ExceptionClear();
2644 }
2645}
2646
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002647void Dbg::DdmConnected() {
Elliott Hughesa2155262011-11-16 16:26:58 -08002648 Dbg::DdmBroadcast(true);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002649}
2650
2651void Dbg::DdmDisconnected() {
Elliott Hughesa2155262011-11-16 16:26:58 -08002652 Dbg::DdmBroadcast(false);
Elliott Hughes47fce012011-10-25 18:37:19 -07002653 gDdmThreadNotification = false;
2654}
2655
2656/*
Elliott Hughes82188472011-11-07 18:11:48 -08002657 * Send a notification when a thread starts, stops, or changes its name.
Elliott Hughes47fce012011-10-25 18:37:19 -07002658 *
2659 * Because we broadcast the full set of threads when the notifications are
2660 * first enabled, it's possible for "thread" to be actively executing.
2661 */
Elliott Hughes82188472011-11-07 18:11:48 -08002662void Dbg::DdmSendThreadNotification(Thread* t, uint32_t type) {
Elliott Hughes47fce012011-10-25 18:37:19 -07002663 if (!gDdmThreadNotification) {
2664 return;
2665 }
2666
Elliott Hughes82188472011-11-07 18:11:48 -08002667 if (type == CHUNK_TYPE("THDE")) {
Elliott Hughes47fce012011-10-25 18:37:19 -07002668 uint8_t buf[4];
Elliott Hughesf7c3b662011-10-27 12:04:56 -07002669 JDWP::Set4BE(&buf[0], t->GetThinLockId());
Elliott Hughes47fce012011-10-25 18:37:19 -07002670 Dbg::DdmSendChunk(CHUNK_TYPE("THDE"), 4, buf);
Elliott Hughes82188472011-11-07 18:11:48 -08002671 } else {
2672 CHECK(type == CHUNK_TYPE("THCR") || type == CHUNK_TYPE("THNM")) << type;
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002673 ScopedObjectAccessUnchecked soa(Thread::Current());
2674 SirtRef<String> name(t->GetThreadName(soa));
Elliott Hughes82188472011-11-07 18:11:48 -08002675 size_t char_count = (name.get() != NULL) ? name->GetLength() : 0;
2676 const jchar* chars = name->GetCharArray()->GetData();
2677
Elliott Hughes21f32d72011-11-09 17:44:13 -08002678 std::vector<uint8_t> bytes;
Elliott Hughes545a0642011-11-08 19:10:03 -08002679 JDWP::Append4BE(bytes, t->GetThinLockId());
2680 JDWP::AppendUtf16BE(bytes, chars, char_count);
Elliott Hughes21f32d72011-11-09 17:44:13 -08002681 CHECK_EQ(bytes.size(), char_count*2 + sizeof(uint32_t)*2);
2682 Dbg::DdmSendChunk(type, bytes);
Elliott Hughes47fce012011-10-25 18:37:19 -07002683 }
2684}
2685
Elliott Hughes47fce012011-10-25 18:37:19 -07002686void Dbg::DdmSetThreadNotification(bool enable) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002687 // Enable/disable thread notifications.
Elliott Hughes47fce012011-10-25 18:37:19 -07002688 gDdmThreadNotification = enable;
2689 if (enable) {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002690 // Suspend the VM then post thread start notifications for all threads. Threads attaching will
2691 // see a suspension in progress and block until that ends. They then post their own start
2692 // notification.
2693 SuspendVM();
2694 std::list<Thread*> threads;
2695 {
Ian Rogersb726dcb2012-09-05 08:57:23 -07002696 MutexLock mu(*Locks::thread_list_lock_);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002697 threads = Runtime::Current()->GetThreadList()->GetList();
2698 }
2699 {
2700 ScopedObjectAccess soa(Thread::Current());
2701 typedef std::list<Thread*>::const_iterator It; // TODO: C++0x auto
2702 for (It it = threads.begin(), end = threads.end(); it != end; ++it) {
2703 Dbg::DdmSendThreadNotification(*it, CHUNK_TYPE("THCR"));
2704 }
2705 }
2706 ResumeVM();
Elliott Hughes47fce012011-10-25 18:37:19 -07002707 }
2708}
2709
Elliott Hughesa2155262011-11-16 16:26:58 -08002710void Dbg::PostThreadStartOrStop(Thread* t, uint32_t type) {
Elliott Hughesc0f09332012-03-26 13:27:06 -07002711 if (IsDebuggerActive()) {
Mathieu Chartierdbe6f462012-09-25 16:54:50 -07002712 ScopedObjectAccessUnchecked soa(Thread::Current());
2713 JDWP::ObjectId id = gRegistry->Add(soa.Decode<Object*>(t->GetPeer()));
Elliott Hughes82188472011-11-07 18:11:48 -08002714 gJdwpState->PostThreadChange(id, type == CHUNK_TYPE("THCR"));
Elliott Hughesc0f09332012-03-26 13:27:06 -07002715 // If this thread's just joined the party while we're already debugging, make sure it knows
2716 // to give us updates when it's running.
2717 t->SetDebuggerUpdatesEnabled(true);
Elliott Hughes47fce012011-10-25 18:37:19 -07002718 }
Elliott Hughes82188472011-11-07 18:11:48 -08002719 Dbg::DdmSendThreadNotification(t, type);
Elliott Hughes47fce012011-10-25 18:37:19 -07002720}
2721
2722void Dbg::PostThreadStart(Thread* t) {
Elliott Hughesa2155262011-11-16 16:26:58 -08002723 Dbg::PostThreadStartOrStop(t, CHUNK_TYPE("THCR"));
Elliott Hughes47fce012011-10-25 18:37:19 -07002724}
2725
2726void Dbg::PostThreadDeath(Thread* t) {
Elliott Hughesa2155262011-11-16 16:26:58 -08002727 Dbg::PostThreadStartOrStop(t, CHUNK_TYPE("THDE"));
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002728}
2729
Elliott Hughes82188472011-11-07 18:11:48 -08002730void Dbg::DdmSendChunk(uint32_t type, size_t byte_count, const uint8_t* buf) {
Elliott Hughes3bb81562011-10-21 18:52:59 -07002731 CHECK(buf != NULL);
2732 iovec vec[1];
2733 vec[0].iov_base = reinterpret_cast<void*>(const_cast<uint8_t*>(buf));
2734 vec[0].iov_len = byte_count;
2735 Dbg::DdmSendChunkV(type, vec, 1);
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002736}
2737
Elliott Hughes21f32d72011-11-09 17:44:13 -08002738void Dbg::DdmSendChunk(uint32_t type, const std::vector<uint8_t>& bytes) {
2739 DdmSendChunk(type, bytes.size(), &bytes[0]);
2740}
2741
Elliott Hughescccd84f2011-12-05 16:51:54 -08002742void Dbg::DdmSendChunkV(uint32_t type, const struct iovec* iov, int iov_count) {
Elliott Hughes3bb81562011-10-21 18:52:59 -07002743 if (gJdwpState == NULL) {
Elliott Hughes4dd9b4d2011-12-12 18:29:24 -08002744 VLOG(jdwp) << "Debugger thread not active, ignoring DDM send: " << type;
Elliott Hughes3bb81562011-10-21 18:52:59 -07002745 } else {
Elliott Hughescccd84f2011-12-05 16:51:54 -08002746 gJdwpState->DdmSendChunkV(type, iov, iov_count);
Elliott Hughes3bb81562011-10-21 18:52:59 -07002747 }
Elliott Hughes872d4ec2011-10-21 17:07:15 -07002748}
2749
Elliott Hughes767a1472011-10-26 18:49:02 -07002750int Dbg::DdmHandleHpifChunk(HpifWhen when) {
2751 if (when == HPIF_WHEN_NOW) {
Elliott Hughes7162ad92011-10-27 14:08:42 -07002752 DdmSendHeapInfo(when);
Elliott Hughes767a1472011-10-26 18:49:02 -07002753 return true;
2754 }
2755
2756 if (when != HPIF_WHEN_NEVER && when != HPIF_WHEN_NEXT_GC && when != HPIF_WHEN_EVERY_GC) {
2757 LOG(ERROR) << "invalid HpifWhen value: " << static_cast<int>(when);
2758 return false;
2759 }
2760
2761 gDdmHpifWhen = when;
2762 return true;
2763}
2764
2765bool Dbg::DdmHandleHpsgNhsgChunk(Dbg::HpsgWhen when, Dbg::HpsgWhat what, bool native) {
2766 if (when != HPSG_WHEN_NEVER && when != HPSG_WHEN_EVERY_GC) {
2767 LOG(ERROR) << "invalid HpsgWhen value: " << static_cast<int>(when);
2768 return false;
2769 }
2770
2771 if (what != HPSG_WHAT_MERGED_OBJECTS && what != HPSG_WHAT_DISTINCT_OBJECTS) {
2772 LOG(ERROR) << "invalid HpsgWhat value: " << static_cast<int>(what);
2773 return false;
2774 }
2775
2776 if (native) {
2777 gDdmNhsgWhen = when;
2778 gDdmNhsgWhat = what;
2779 } else {
2780 gDdmHpsgWhen = when;
2781 gDdmHpsgWhat = what;
2782 }
2783 return true;
2784}
2785
Elliott Hughes7162ad92011-10-27 14:08:42 -07002786void Dbg::DdmSendHeapInfo(HpifWhen reason) {
2787 // If there's a one-shot 'when', reset it.
2788 if (reason == gDdmHpifWhen) {
2789 if (gDdmHpifWhen == HPIF_WHEN_NEXT_GC) {
2790 gDdmHpifWhen = HPIF_WHEN_NEVER;
2791 }
2792 }
2793
2794 /*
2795 * Chunk HPIF (client --> server)
2796 *
2797 * Heap Info. General information about the heap,
2798 * suitable for a summary display.
2799 *
2800 * [u4]: number of heaps
2801 *
2802 * For each heap:
2803 * [u4]: heap ID
2804 * [u8]: timestamp in ms since Unix epoch
2805 * [u1]: capture reason (same as 'when' value from server)
2806 * [u4]: max heap size in bytes (-Xmx)
2807 * [u4]: current heap size in bytes
2808 * [u4]: current number of bytes allocated
2809 * [u4]: current number of objects allocated
2810 */
2811 uint8_t heap_count = 1;
Elliott Hughesb3bd5f02012-03-08 21:05:27 -08002812 Heap* heap = Runtime::Current()->GetHeap();
Elliott Hughes21f32d72011-11-09 17:44:13 -08002813 std::vector<uint8_t> bytes;
Elliott Hughes545a0642011-11-08 19:10:03 -08002814 JDWP::Append4BE(bytes, heap_count);
2815 JDWP::Append4BE(bytes, 1); // Heap id (bogus; we only have one heap).
2816 JDWP::Append8BE(bytes, MilliTime());
2817 JDWP::Append1BE(bytes, reason);
Elliott Hughesb3bd5f02012-03-08 21:05:27 -08002818 JDWP::Append4BE(bytes, heap->GetMaxMemory()); // Max allowed heap size in bytes.
2819 JDWP::Append4BE(bytes, heap->GetTotalMemory()); // Current heap size in bytes.
2820 JDWP::Append4BE(bytes, heap->GetBytesAllocated());
2821 JDWP::Append4BE(bytes, heap->GetObjectsAllocated());
Elliott Hughes21f32d72011-11-09 17:44:13 -08002822 CHECK_EQ(bytes.size(), 4U + (heap_count * (4 + 8 + 1 + 4 + 4 + 4 + 4)));
2823 Dbg::DdmSendChunk(CHUNK_TYPE("HPIF"), bytes);
Elliott Hughes767a1472011-10-26 18:49:02 -07002824}
2825
Elliott Hughes6a5bd492011-10-28 14:33:57 -07002826enum HpsgSolidity {
2827 SOLIDITY_FREE = 0,
2828 SOLIDITY_HARD = 1,
2829 SOLIDITY_SOFT = 2,
2830 SOLIDITY_WEAK = 3,
2831 SOLIDITY_PHANTOM = 4,
2832 SOLIDITY_FINALIZABLE = 5,
2833 SOLIDITY_SWEEP = 6,
2834};
2835
2836enum HpsgKind {
2837 KIND_OBJECT = 0,
2838 KIND_CLASS_OBJECT = 1,
2839 KIND_ARRAY_1 = 2,
2840 KIND_ARRAY_2 = 3,
2841 KIND_ARRAY_4 = 4,
2842 KIND_ARRAY_8 = 5,
2843 KIND_UNKNOWN = 6,
2844 KIND_NATIVE = 7,
2845};
2846
2847#define HPSG_PARTIAL (1<<7)
2848#define HPSG_STATE(solidity, kind) ((uint8_t)((((kind) & 0x7) << 3) | ((solidity) & 0x7)))
2849
Ian Rogers30fab402012-01-23 15:43:46 -08002850class HeapChunkContext {
2851 public:
Elliott Hughes6a5bd492011-10-28 14:33:57 -07002852 // Maximum chunk size. Obtain this from the formula:
2853 // (((maximum_heap_size / ALLOCATION_UNIT_SIZE) + 255) / 256) * 2
2854 HeapChunkContext(bool merge, bool native)
Ian Rogers30fab402012-01-23 15:43:46 -08002855 : buf_(16384 - 16),
2856 type_(0),
2857 merge_(merge) {
Elliott Hughes6a5bd492011-10-28 14:33:57 -07002858 Reset();
2859 if (native) {
Ian Rogers30fab402012-01-23 15:43:46 -08002860 type_ = CHUNK_TYPE("NHSG");
Elliott Hughes6a5bd492011-10-28 14:33:57 -07002861 } else {
Ian Rogers30fab402012-01-23 15:43:46 -08002862 type_ = merge ? CHUNK_TYPE("HPSG") : CHUNK_TYPE("HPSO");
Elliott Hughes6a5bd492011-10-28 14:33:57 -07002863 }
2864 }
2865
2866 ~HeapChunkContext() {
Ian Rogers30fab402012-01-23 15:43:46 -08002867 if (p_ > &buf_[0]) {
Elliott Hughes6a5bd492011-10-28 14:33:57 -07002868 Flush();
2869 }
2870 }
2871
2872 void EnsureHeader(const void* chunk_ptr) {
Ian Rogers30fab402012-01-23 15:43:46 -08002873 if (!needHeader_) {
Elliott Hughes6a5bd492011-10-28 14:33:57 -07002874 return;
2875 }
2876
2877 // Start a new HPSx chunk.
Ian Rogers30fab402012-01-23 15:43:46 -08002878 JDWP::Write4BE(&p_, 1); // Heap id (bogus; we only have one heap).
2879 JDWP::Write1BE(&p_, 8); // Size of allocation unit, in bytes.
Elliott Hughes6a5bd492011-10-28 14:33:57 -07002880
Ian Rogers30fab402012-01-23 15:43:46 -08002881 JDWP::Write4BE(&p_, reinterpret_cast<uintptr_t>(chunk_ptr)); // virtual address of segment start.
2882 JDWP::Write4BE(&p_, 0); // offset of this piece (relative to the virtual address).
Elliott Hughes6a5bd492011-10-28 14:33:57 -07002883 // [u4]: length of piece, in allocation units
2884 // 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 -08002885 pieceLenField_ = p_;
2886 JDWP::Write4BE(&p_, 0x55555555);
2887 needHeader_ = false;
Elliott Hughes6a5bd492011-10-28 14:33:57 -07002888 }
2889
Ian Rogersb726dcb2012-09-05 08:57:23 -07002890 void Flush() SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Elliott Hughes6a5bd492011-10-28 14:33:57 -07002891 // Patch the "length of piece" field.
Ian Rogers30fab402012-01-23 15:43:46 -08002892 CHECK_LE(&buf_[0], pieceLenField_);
2893 CHECK_LE(pieceLenField_, p_);
2894 JDWP::Set4BE(pieceLenField_, totalAllocationUnits_);
Elliott Hughes6a5bd492011-10-28 14:33:57 -07002895
Ian Rogers30fab402012-01-23 15:43:46 -08002896 Dbg::DdmSendChunk(type_, p_ - &buf_[0], &buf_[0]);
Elliott Hughes6a5bd492011-10-28 14:33:57 -07002897 Reset();
2898 }
2899
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002900 static void HeapChunkCallback(void* start, void* end, size_t used_bytes, void* arg)
Ian Rogersb726dcb2012-09-05 08:57:23 -07002901 SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_,
2902 Locks::mutator_lock_) {
Ian Rogers30fab402012-01-23 15:43:46 -08002903 reinterpret_cast<HeapChunkContext*>(arg)->HeapChunkCallback(start, end, used_bytes);
Elliott Hughesa2155262011-11-16 16:26:58 -08002904 }
2905
Elliott Hughes6a5bd492011-10-28 14:33:57 -07002906 private:
Elliott Hughesa2155262011-11-16 16:26:58 -08002907 enum { ALLOCATION_UNIT_SIZE = 8 };
2908
Elliott Hughes6a5bd492011-10-28 14:33:57 -07002909 void Reset() {
Ian Rogers30fab402012-01-23 15:43:46 -08002910 p_ = &buf_[0];
Ian Rogers15bf2d32012-08-28 17:33:04 -07002911 startOfNextMemoryChunk_ = NULL;
Ian Rogers30fab402012-01-23 15:43:46 -08002912 totalAllocationUnits_ = 0;
2913 needHeader_ = true;
2914 pieceLenField_ = NULL;
Elliott Hughes6a5bd492011-10-28 14:33:57 -07002915 }
2916
Ian Rogers00f7d0e2012-07-19 15:28:27 -07002917 void HeapChunkCallback(void* start, void* /*end*/, size_t used_bytes)
Ian Rogersb726dcb2012-09-05 08:57:23 -07002918 SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_,
2919 Locks::mutator_lock_) {
Ian Rogers30fab402012-01-23 15:43:46 -08002920 // Note: heap call backs cannot manipulate the heap upon which they are crawling, care is taken
2921 // in the following code not to allocate memory, by ensuring buf_ is of the correct size
Ian Rogers15bf2d32012-08-28 17:33:04 -07002922 if (used_bytes == 0) {
2923 if (start == NULL) {
2924 // Reset for start of new heap.
2925 startOfNextMemoryChunk_ = NULL;
2926 Flush();
2927 }
2928 // Only process in use memory so that free region information
2929 // also includes dlmalloc book keeping.
Elliott Hughesa2155262011-11-16 16:26:58 -08002930 return;
Elliott Hughesa2155262011-11-16 16:26:58 -08002931 }
2932
Ian Rogers15bf2d32012-08-28 17:33:04 -07002933 /* If we're looking at the native heap, we'll just return
2934 * (SOLIDITY_HARD, KIND_NATIVE) for all allocated chunks
2935 */
2936 bool native = type_ == CHUNK_TYPE("NHSG");
2937
2938 if (startOfNextMemoryChunk_ != NULL) {
2939 // Transmit any pending free memory. Native free memory of
2940 // over kMaxFreeLen could be because of the use of mmaps, so
2941 // don't report. If not free memory then start a new segment.
2942 bool flush = true;
2943 if (start > startOfNextMemoryChunk_) {
2944 const size_t kMaxFreeLen = 2 * kPageSize;
2945 void* freeStart = startOfNextMemoryChunk_;
2946 void* freeEnd = start;
2947 size_t freeLen = (char*)freeEnd - (char*)freeStart;
2948 if (!native || freeLen < kMaxFreeLen) {
2949 AppendChunk(HPSG_STATE(SOLIDITY_FREE, 0), freeStart, freeLen);
2950 flush = false;
2951 }
2952 }
2953 if (flush) {
2954 startOfNextMemoryChunk_ = NULL;
2955 Flush();
2956 }
2957 }
2958 const Object *obj = (const Object *)start;
Elliott Hughesa2155262011-11-16 16:26:58 -08002959
2960 // Determine the type of this chunk.
2961 // OLD-TODO: if context.merge, see if this chunk is different from the last chunk.
2962 // If it's the same, we should combine them.
Ian Rogers15bf2d32012-08-28 17:33:04 -07002963 uint8_t state = ExamineObject(obj, native);
2964 // dlmalloc's chunk header is 2 * sizeof(size_t), but if the previous chunk is in use for an
2965 // allocation then the first sizeof(size_t) may belong to it.
2966 const size_t dlMallocOverhead = sizeof(size_t);
2967 AppendChunk(state, start, used_bytes + dlMallocOverhead);
2968 startOfNextMemoryChunk_ = (char*)start + used_bytes + dlMallocOverhead;
2969 }
Elliott Hughesa2155262011-11-16 16:26:58 -08002970
Ian Rogers15bf2d32012-08-28 17:33:04 -07002971 void AppendChunk(uint8_t state, void* ptr, size_t length)
Ian Rogersb726dcb2012-09-05 08:57:23 -07002972 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_) {
Ian Rogers15bf2d32012-08-28 17:33:04 -07002973 // Make sure there's enough room left in the buffer.
2974 // We need to use two bytes for every fractional 256 allocation units used by the chunk plus
2975 // 17 bytes for any header.
2976 size_t needed = (((length/ALLOCATION_UNIT_SIZE + 255) / 256) * 2) + 17;
2977 size_t bytesLeft = buf_.size() - (size_t)(p_ - &buf_[0]);
2978 if (bytesLeft < needed) {
2979 Flush();
2980 }
2981
2982 bytesLeft = buf_.size() - (size_t)(p_ - &buf_[0]);
2983 if (bytesLeft < needed) {
2984 LOG(WARNING) << "Chunk is too big to transmit (chunk_len=" << length << ", "
2985 << needed << " bytes)";
2986 return;
2987 }
2988 EnsureHeader(ptr);
Elliott Hughesa2155262011-11-16 16:26:58 -08002989 // Write out the chunk description.
Ian Rogers15bf2d32012-08-28 17:33:04 -07002990 length /= ALLOCATION_UNIT_SIZE; // Convert to allocation units.
2991 totalAllocationUnits_ += length;
2992 while (length > 256) {
Ian Rogers30fab402012-01-23 15:43:46 -08002993 *p_++ = state | HPSG_PARTIAL;
2994 *p_++ = 255; // length - 1
Ian Rogers15bf2d32012-08-28 17:33:04 -07002995 length -= 256;
Elliott Hughesa2155262011-11-16 16:26:58 -08002996 }
Ian Rogers30fab402012-01-23 15:43:46 -08002997 *p_++ = state;
Ian Rogers15bf2d32012-08-28 17:33:04 -07002998 *p_++ = length - 1;
Elliott Hughes6a5bd492011-10-28 14:33:57 -07002999 }
3000
Ian Rogers5bfa60f2012-09-02 21:17:56 -07003001 uint8_t ExamineObject(const Object* o, bool is_native_heap)
Ian Rogersb726dcb2012-09-05 08:57:23 -07003002 SHARED_LOCKS_REQUIRED(Locks::heap_bitmap_lock_) {
Elliott Hughesa2155262011-11-16 16:26:58 -08003003 if (o == NULL) {
3004 return HPSG_STATE(SOLIDITY_FREE, 0);
3005 }
Elliott Hughes6a5bd492011-10-28 14:33:57 -07003006
Elliott Hughesa2155262011-11-16 16:26:58 -08003007 // It's an allocated chunk. Figure out what it is.
Elliott Hughes6a5bd492011-10-28 14:33:57 -07003008
Elliott Hughesa2155262011-11-16 16:26:58 -08003009 // If we're looking at the native heap, we'll just return
3010 // (SOLIDITY_HARD, KIND_NATIVE) for all allocated chunks.
Ian Rogers00f7d0e2012-07-19 15:28:27 -07003011 if (is_native_heap) {
Elliott Hughesa2155262011-11-16 16:26:58 -08003012 return HPSG_STATE(SOLIDITY_HARD, KIND_NATIVE);
3013 }
3014
Ian Rogers5bfa60f2012-09-02 21:17:56 -07003015 if (!Runtime::Current()->GetHeap()->IsLiveObjectLocked(o)) {
Ian Rogers15bf2d32012-08-28 17:33:04 -07003016 return HPSG_STATE(SOLIDITY_HARD, KIND_NATIVE);
Ian Rogers00f7d0e2012-07-19 15:28:27 -07003017 }
3018
Elliott Hughesa2155262011-11-16 16:26:58 -08003019 Class* c = o->GetClass();
3020 if (c == NULL) {
3021 // The object was probably just created but hasn't been initialized yet.
3022 return HPSG_STATE(SOLIDITY_HARD, KIND_OBJECT);
3023 }
3024
Elliott Hughesb3bd5f02012-03-08 21:05:27 -08003025 if (!Runtime::Current()->GetHeap()->IsHeapAddress(c)) {
Ian Rogers15bf2d32012-08-28 17:33:04 -07003026 LOG(ERROR) << "Invalid class for managed heap object: " << o << " " << c;
Elliott Hughesa2155262011-11-16 16:26:58 -08003027 return HPSG_STATE(SOLIDITY_HARD, KIND_UNKNOWN);
3028 }
3029
3030 if (c->IsClassClass()) {
3031 return HPSG_STATE(SOLIDITY_HARD, KIND_CLASS_OBJECT);
3032 }
3033
3034 if (c->IsArrayClass()) {
3035 if (o->IsObjectArray()) {
3036 return HPSG_STATE(SOLIDITY_HARD, KIND_ARRAY_4);
3037 }
3038 switch (c->GetComponentSize()) {
3039 case 1: return HPSG_STATE(SOLIDITY_HARD, KIND_ARRAY_1);
3040 case 2: return HPSG_STATE(SOLIDITY_HARD, KIND_ARRAY_2);
3041 case 4: return HPSG_STATE(SOLIDITY_HARD, KIND_ARRAY_4);
3042 case 8: return HPSG_STATE(SOLIDITY_HARD, KIND_ARRAY_8);
3043 }
3044 }
3045
Elliott Hughes6a5bd492011-10-28 14:33:57 -07003046 return HPSG_STATE(SOLIDITY_HARD, KIND_OBJECT);
3047 }
3048
Ian Rogers30fab402012-01-23 15:43:46 -08003049 std::vector<uint8_t> buf_;
3050 uint8_t* p_;
3051 uint8_t* pieceLenField_;
Ian Rogers15bf2d32012-08-28 17:33:04 -07003052 void* startOfNextMemoryChunk_;
Ian Rogers30fab402012-01-23 15:43:46 -08003053 size_t totalAllocationUnits_;
3054 uint32_t type_;
3055 bool merge_;
3056 bool needHeader_;
3057
Elliott Hughesa2155262011-11-16 16:26:58 -08003058 DISALLOW_COPY_AND_ASSIGN(HeapChunkContext);
3059};
Elliott Hughes6a5bd492011-10-28 14:33:57 -07003060
3061void Dbg::DdmSendHeapSegments(bool native) {
3062 Dbg::HpsgWhen when;
3063 Dbg::HpsgWhat what;
3064 if (!native) {
3065 when = gDdmHpsgWhen;
3066 what = gDdmHpsgWhat;
3067 } else {
3068 when = gDdmNhsgWhen;
3069 what = gDdmNhsgWhat;
3070 }
3071 if (when == HPSG_WHEN_NEVER) {
3072 return;
3073 }
3074
3075 // Figure out what kind of chunks we'll be sending.
3076 CHECK(what == HPSG_WHAT_MERGED_OBJECTS || what == HPSG_WHAT_DISTINCT_OBJECTS) << static_cast<int>(what);
3077
3078 // First, send a heap start chunk.
3079 uint8_t heap_id[4];
3080 JDWP::Set4BE(&heap_id[0], 1); // Heap id (bogus; we only have one heap).
3081 Dbg::DdmSendChunk(native ? CHUNK_TYPE("NHST") : CHUNK_TYPE("HPST"), sizeof(heap_id), heap_id);
3082
3083 // Send a series of heap segment chunks.
Elliott Hughesa2155262011-11-16 16:26:58 -08003084 HeapChunkContext context((what == HPSG_WHAT_MERGED_OBJECTS), native);
3085 if (native) {
Ian Rogers30fab402012-01-23 15:43:46 -08003086 // TODO: enable when bionic has moved to dlmalloc 2.8.5
3087 // dlmalloc_inspect_all(HeapChunkContext::HeapChunkCallback, &context);
3088 UNIMPLEMENTED(WARNING) << "Native heap send heap segments";
Elliott Hughesa2155262011-11-16 16:26:58 -08003089 } else {
Elliott Hughesb3bd5f02012-03-08 21:05:27 -08003090 Heap* heap = Runtime::Current()->GetHeap();
Mathieu Chartierfd678be2012-08-30 14:50:54 -07003091 const Spaces& spaces = heap->GetSpaces();
3092 for (Spaces::const_iterator cur = spaces.begin(); cur != spaces.end(); ++cur) {
Mathieu Chartierb062fdd2012-07-03 09:51:48 -07003093 if ((*cur)->IsAllocSpace()) {
Ian Rogersb726dcb2012-09-05 08:57:23 -07003094 ReaderMutexLock mu(*Locks::heap_bitmap_lock_);
Mathieu Chartierb062fdd2012-07-03 09:51:48 -07003095 (*cur)->AsAllocSpace()->Walk(HeapChunkContext::HeapChunkCallback, &context);
3096 }
3097 }
Mathieu Chartiere0f0cb32012-08-28 11:26:00 -07003098 // Walk the large objects, these are not in the AllocSpace.
3099 heap->GetLargeObjectsSpace()->Walk(HeapChunkContext::HeapChunkCallback, &context);
Elliott Hughesa2155262011-11-16 16:26:58 -08003100 }
Elliott Hughes6a5bd492011-10-28 14:33:57 -07003101
3102 // Finally, send a heap end chunk.
3103 Dbg::DdmSendChunk(native ? CHUNK_TYPE("NHEN") : CHUNK_TYPE("HPEN"), sizeof(heap_id), heap_id);
Elliott Hughes767a1472011-10-26 18:49:02 -07003104}
3105
Elliott Hughes545a0642011-11-08 19:10:03 -08003106void Dbg::SetAllocTrackingEnabled(bool enabled) {
3107 MutexLock mu(gAllocTrackerLock);
3108 if (enabled) {
3109 if (recent_allocation_records_ == NULL) {
3110 LOG(INFO) << "Enabling alloc tracker (" << kNumAllocRecords << " entries, "
3111 << kMaxAllocRecordStackDepth << " frames --> "
3112 << (sizeof(AllocRecord) * kNumAllocRecords) << " bytes)";
3113 gAllocRecordHead = gAllocRecordCount = 0;
3114 recent_allocation_records_ = new AllocRecord[kNumAllocRecords];
3115 CHECK(recent_allocation_records_ != NULL);
3116 }
3117 } else {
3118 delete[] recent_allocation_records_;
3119 recent_allocation_records_ = NULL;
3120 }
3121}
3122
Ian Rogers0399dde2012-06-06 17:09:28 -07003123struct AllocRecordStackVisitor : public StackVisitor {
3124 AllocRecordStackVisitor(const ManagedStack* stack,
Ian Rogersca190662012-06-26 15:45:57 -07003125 const std::vector<TraceStackFrame>* trace_stack, AllocRecord* record)
Ian Rogersb726dcb2012-09-05 08:57:23 -07003126 SHARED_LOCKS_REQUIRED(Locks::mutator_lock_)
Elliott Hughes08fc03a2012-06-26 17:34:00 -07003127 : StackVisitor(stack, trace_stack, NULL), record(record), depth(0) {}
Elliott Hughes545a0642011-11-08 19:10:03 -08003128
Ian Rogers00f7d0e2012-07-19 15:28:27 -07003129 // TODO: Enable annotalysis. We know lock is held in constructor, but abstraction confuses
3130 // annotalysis.
3131 bool VisitFrame() NO_THREAD_SAFETY_ANALYSIS {
Elliott Hughes545a0642011-11-08 19:10:03 -08003132 if (depth >= kMaxAllocRecordStackDepth) {
Elliott Hughes530fa002012-03-12 11:44:49 -07003133 return false;
Elliott Hughes545a0642011-11-08 19:10:03 -08003134 }
Mathieu Chartier66f19252012-09-18 08:57:04 -07003135 AbstractMethod* m = GetMethod();
Ian Rogers0399dde2012-06-06 17:09:28 -07003136 if (!m->IsRuntimeMethod()) {
3137 record->stack[depth].method = m;
3138 record->stack[depth].dex_pc = GetDexPc();
Elliott Hughes530fa002012-03-12 11:44:49 -07003139 ++depth;
Elliott Hughes545a0642011-11-08 19:10:03 -08003140 }
Elliott Hughes530fa002012-03-12 11:44:49 -07003141 return true;
Elliott Hughes545a0642011-11-08 19:10:03 -08003142 }
3143
3144 ~AllocRecordStackVisitor() {
3145 // Clear out any unused stack trace elements.
3146 for (; depth < kMaxAllocRecordStackDepth; ++depth) {
3147 record->stack[depth].method = NULL;
Ian Rogers0399dde2012-06-06 17:09:28 -07003148 record->stack[depth].dex_pc = 0;
Elliott Hughes545a0642011-11-08 19:10:03 -08003149 }
3150 }
3151
3152 AllocRecord* record;
3153 size_t depth;
3154};
3155
3156void Dbg::RecordAllocation(Class* type, size_t byte_count) {
3157 Thread* self = Thread::Current();
3158 CHECK(self != NULL);
3159
3160 MutexLock mu(gAllocTrackerLock);
3161 if (recent_allocation_records_ == NULL) {
3162 return;
3163 }
3164
3165 // Advance and clip.
3166 if (++gAllocRecordHead == kNumAllocRecords) {
3167 gAllocRecordHead = 0;
3168 }
3169
3170 // Fill in the basics.
3171 AllocRecord* record = &recent_allocation_records_[gAllocRecordHead];
3172 record->type = type;
3173 record->byte_count = byte_count;
3174 record->thin_lock_id = self->GetThinLockId();
3175
3176 // Fill in the stack trace.
Ian Rogers0399dde2012-06-06 17:09:28 -07003177 AllocRecordStackVisitor visitor(self->GetManagedStack(), self->GetTraceStack(), record);
3178 visitor.WalkStack();
Elliott Hughes545a0642011-11-08 19:10:03 -08003179
3180 if (gAllocRecordCount < kNumAllocRecords) {
3181 ++gAllocRecordCount;
3182 }
3183}
3184
Elliott Hughesa8f93cb2012-06-08 17:08:48 -07003185// Returns the index of the head element.
3186//
3187// We point at the most-recently-written record, so if gAllocRecordCount is 1
3188// we want to use the current element. Take "head+1" and subtract count
3189// from it.
3190//
3191// We need to handle underflow in our circular buffer, so we add
3192// kNumAllocRecords and then mask it back down.
Elliott Hughesf8349362012-06-18 15:00:06 -07003193static inline int HeadIndex() EXCLUSIVE_LOCKS_REQUIRED(gAllocTrackerLock) {
Elliott Hughes545a0642011-11-08 19:10:03 -08003194 return (gAllocRecordHead+1 + kNumAllocRecords - gAllocRecordCount) & (kNumAllocRecords-1);
3195}
3196
3197void Dbg::DumpRecentAllocations() {
Ian Rogers00f7d0e2012-07-19 15:28:27 -07003198 ScopedObjectAccess soa(Thread::Current());
Elliott Hughes545a0642011-11-08 19:10:03 -08003199 MutexLock mu(gAllocTrackerLock);
3200 if (recent_allocation_records_ == NULL) {
3201 LOG(INFO) << "Not recording tracked allocations";
3202 return;
3203 }
3204
3205 // "i" is the head of the list. We want to start at the end of the
3206 // list and move forward to the tail.
Elliott Hughesa8f93cb2012-06-08 17:08:48 -07003207 size_t i = HeadIndex();
Elliott Hughes545a0642011-11-08 19:10:03 -08003208 size_t count = gAllocRecordCount;
3209
3210 LOG(INFO) << "Tracked allocations, (head=" << gAllocRecordHead << " count=" << count << ")";
3211 while (count--) {
3212 AllocRecord* record = &recent_allocation_records_[i];
3213
Elliott Hughesa8f93cb2012-06-08 17:08:48 -07003214 LOG(INFO) << StringPrintf(" Thread %-2d %6zd bytes ", record->thin_lock_id, record->byte_count)
Elliott Hughes545a0642011-11-08 19:10:03 -08003215 << PrettyClass(record->type);
3216
3217 for (size_t stack_frame = 0; stack_frame < kMaxAllocRecordStackDepth; ++stack_frame) {
Mathieu Chartier66f19252012-09-18 08:57:04 -07003218 const AbstractMethod* m = record->stack[stack_frame].method;
Elliott Hughes545a0642011-11-08 19:10:03 -08003219 if (m == NULL) {
3220 break;
3221 }
3222 LOG(INFO) << " " << PrettyMethod(m) << " line " << record->stack[stack_frame].LineNumber();
3223 }
3224
3225 // pause periodically to help logcat catch up
3226 if ((count % 5) == 0) {
3227 usleep(40000);
3228 }
3229
3230 i = (i + 1) & (kNumAllocRecords-1);
3231 }
3232}
3233
3234class StringTable {
3235 public:
3236 StringTable() {
3237 }
3238
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003239 void Add(const char* s) {
Elliott Hughes545a0642011-11-08 19:10:03 -08003240 table_.insert(s);
3241 }
3242
Elliott Hughesa8f93cb2012-06-08 17:08:48 -07003243 size_t IndexOf(const char* s) const {
3244 typedef std::set<std::string>::const_iterator It; // TODO: C++0x auto
3245 It it = table_.find(s);
3246 if (it == table_.end()) {
3247 LOG(FATAL) << "IndexOf(\"" << s << "\") failed";
3248 }
3249 return std::distance(table_.begin(), it);
Elliott Hughes545a0642011-11-08 19:10:03 -08003250 }
3251
Elliott Hughesa8f93cb2012-06-08 17:08:48 -07003252 size_t Size() const {
Elliott Hughes545a0642011-11-08 19:10:03 -08003253 return table_.size();
3254 }
3255
Elliott Hughesa8f93cb2012-06-08 17:08:48 -07003256 void WriteTo(std::vector<uint8_t>& bytes) const {
3257 typedef std::set<std::string>::const_iterator It; // TODO: C++0x auto
Elliott Hughes545a0642011-11-08 19:10:03 -08003258 for (It it = table_.begin(); it != table_.end(); ++it) {
Elliott Hughesa8f93cb2012-06-08 17:08:48 -07003259 const char* s = (*it).c_str();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003260 size_t s_len = CountModifiedUtf8Chars(s);
3261 UniquePtr<uint16_t> s_utf16(new uint16_t[s_len]);
3262 ConvertModifiedUtf8ToUtf16(s_utf16.get(), s);
3263 JDWP::AppendUtf16BE(bytes, s_utf16.get(), s_len);
Elliott Hughes545a0642011-11-08 19:10:03 -08003264 }
3265 }
3266
3267 private:
Elliott Hughesa8f93cb2012-06-08 17:08:48 -07003268 std::set<std::string> table_;
Elliott Hughes545a0642011-11-08 19:10:03 -08003269 DISALLOW_COPY_AND_ASSIGN(StringTable);
3270};
3271
3272/*
3273 * The data we send to DDMS contains everything we have recorded.
3274 *
3275 * Message header (all values big-endian):
3276 * (1b) message header len (to allow future expansion); includes itself
3277 * (1b) entry header len
3278 * (1b) stack frame len
3279 * (2b) number of entries
3280 * (4b) offset to string table from start of message
3281 * (2b) number of class name strings
3282 * (2b) number of method name strings
3283 * (2b) number of source file name strings
3284 * For each entry:
3285 * (4b) total allocation size
3286 * (2b) threadId
3287 * (2b) allocated object's class name index
3288 * (1b) stack depth
3289 * For each stack frame:
3290 * (2b) method's class name
3291 * (2b) method name
3292 * (2b) method source file
3293 * (2b) line number, clipped to 32767; -2 if native; -1 if no source
3294 * (xb) class name strings
3295 * (xb) method name strings
3296 * (xb) source file strings
3297 *
3298 * As with other DDM traffic, strings are sent as a 4-byte length
3299 * followed by UTF-16 data.
3300 *
3301 * We send up 16-bit unsigned indexes into string tables. In theory there
3302 * can be (kMaxAllocRecordStackDepth * kNumAllocRecords) unique strings in
3303 * each table, but in practice there should be far fewer.
3304 *
3305 * The chief reason for using a string table here is to keep the size of
3306 * the DDMS message to a minimum. This is partly to make the protocol
3307 * efficient, but also because we have to form the whole thing up all at
3308 * once in a memory buffer.
3309 *
3310 * We use separate string tables for class names, method names, and source
3311 * files to keep the indexes small. There will generally be no overlap
3312 * between the contents of these tables.
3313 */
3314jbyteArray Dbg::GetRecentAllocations() {
3315 if (false) {
3316 DumpRecentAllocations();
3317 }
3318
3319 MutexLock mu(gAllocTrackerLock);
3320
Elliott Hughesa8f93cb2012-06-08 17:08:48 -07003321 //
3322 // Part 1: generate string tables.
3323 //
Elliott Hughes545a0642011-11-08 19:10:03 -08003324 StringTable class_names;
3325 StringTable method_names;
3326 StringTable filenames;
3327
3328 int count = gAllocRecordCount;
Elliott Hughesa8f93cb2012-06-08 17:08:48 -07003329 int idx = HeadIndex();
Elliott Hughes545a0642011-11-08 19:10:03 -08003330 while (count--) {
3331 AllocRecord* record = &recent_allocation_records_[idx];
3332
Elliott Hughes91250e02011-12-13 22:30:35 -08003333 class_names.Add(ClassHelper(record->type).GetDescriptor());
Elliott Hughes545a0642011-11-08 19:10:03 -08003334
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003335 MethodHelper mh;
Elliott Hughes545a0642011-11-08 19:10:03 -08003336 for (size_t i = 0; i < kMaxAllocRecordStackDepth; i++) {
Mathieu Chartier66f19252012-09-18 08:57:04 -07003337 AbstractMethod* m = record->stack[i].method;
Elliott Hughes545a0642011-11-08 19:10:03 -08003338 if (m != NULL) {
Ian Rogersba377812012-05-28 21:16:29 -07003339 mh.ChangeMethod(m);
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003340 class_names.Add(mh.GetDeclaringClassDescriptor());
3341 method_names.Add(mh.GetName());
3342 filenames.Add(mh.GetDeclaringClassSourceFile());
Elliott Hughes545a0642011-11-08 19:10:03 -08003343 }
3344 }
3345
3346 idx = (idx + 1) & (kNumAllocRecords-1);
3347 }
3348
3349 LOG(INFO) << "allocation records: " << gAllocRecordCount;
3350
Elliott Hughesa8f93cb2012-06-08 17:08:48 -07003351 //
3352 // Part 2: allocate a buffer and generate the output.
3353 //
Elliott Hughes545a0642011-11-08 19:10:03 -08003354 std::vector<uint8_t> bytes;
3355
3356 // (1b) message header len (to allow future expansion); includes itself
3357 // (1b) entry header len
3358 // (1b) stack frame len
3359 const int kMessageHeaderLen = 15;
3360 const int kEntryHeaderLen = 9;
3361 const int kStackFrameLen = 8;
3362 JDWP::Append1BE(bytes, kMessageHeaderLen);
3363 JDWP::Append1BE(bytes, kEntryHeaderLen);
3364 JDWP::Append1BE(bytes, kStackFrameLen);
3365
3366 // (2b) number of entries
3367 // (4b) offset to string table from start of message
3368 // (2b) number of class name strings
3369 // (2b) number of method name strings
3370 // (2b) number of source file name strings
3371 JDWP::Append2BE(bytes, gAllocRecordCount);
3372 size_t string_table_offset = bytes.size();
3373 JDWP::Append4BE(bytes, 0); // We'll patch this later...
3374 JDWP::Append2BE(bytes, class_names.Size());
3375 JDWP::Append2BE(bytes, method_names.Size());
3376 JDWP::Append2BE(bytes, filenames.Size());
3377
3378 count = gAllocRecordCount;
Elliott Hughesa8f93cb2012-06-08 17:08:48 -07003379 idx = HeadIndex();
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003380 ClassHelper kh;
Elliott Hughes545a0642011-11-08 19:10:03 -08003381 while (count--) {
3382 // For each entry:
3383 // (4b) total allocation size
3384 // (2b) thread id
3385 // (2b) allocated object's class name index
3386 // (1b) stack depth
3387 AllocRecord* record = &recent_allocation_records_[idx];
3388 size_t stack_depth = record->GetDepth();
Elliott Hughesa8f93cb2012-06-08 17:08:48 -07003389 kh.ChangeClass(record->type);
3390 size_t allocated_object_class_name_index = class_names.IndexOf(kh.GetDescriptor());
Elliott Hughes545a0642011-11-08 19:10:03 -08003391 JDWP::Append4BE(bytes, record->byte_count);
3392 JDWP::Append2BE(bytes, record->thin_lock_id);
Elliott Hughesa8f93cb2012-06-08 17:08:48 -07003393 JDWP::Append2BE(bytes, allocated_object_class_name_index);
Elliott Hughes545a0642011-11-08 19:10:03 -08003394 JDWP::Append1BE(bytes, stack_depth);
3395
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003396 MethodHelper mh;
Elliott Hughes545a0642011-11-08 19:10:03 -08003397 for (size_t stack_frame = 0; stack_frame < stack_depth; ++stack_frame) {
3398 // For each stack frame:
3399 // (2b) method's class name
3400 // (2b) method name
3401 // (2b) method source file
3402 // (2b) line number, clipped to 32767; -2 if native; -1 if no source
Ian Rogers6d4d9fc2011-11-30 16:24:48 -08003403 mh.ChangeMethod(record->stack[stack_frame].method);
Elliott Hughesa8f93cb2012-06-08 17:08:48 -07003404 size_t class_name_index = class_names.IndexOf(mh.GetDeclaringClassDescriptor());
3405 size_t method_name_index = method_names.IndexOf(mh.GetName());
3406 size_t file_name_index = filenames.IndexOf(mh.GetDeclaringClassSourceFile());
3407 JDWP::Append2BE(bytes, class_name_index);
3408 JDWP::Append2BE(bytes, method_name_index);
3409 JDWP::Append2BE(bytes, file_name_index);
Elliott Hughes545a0642011-11-08 19:10:03 -08003410 JDWP::Append2BE(bytes, record->stack[stack_frame].LineNumber());
3411 }
3412
3413 idx = (idx + 1) & (kNumAllocRecords-1);
3414 }
3415
3416 // (xb) class name strings
3417 // (xb) method name strings
3418 // (xb) source file strings
3419 JDWP::Set4BE(&bytes[string_table_offset], bytes.size());
3420 class_names.WriteTo(bytes);
3421 method_names.WriteTo(bytes);
3422 filenames.WriteTo(bytes);
3423
3424 JNIEnv* env = Thread::Current()->GetJniEnv();
3425 jbyteArray result = env->NewByteArray(bytes.size());
3426 if (result != NULL) {
3427 env->SetByteArrayRegion(result, 0, bytes.size(), reinterpret_cast<const jbyte*>(&bytes[0]));
3428 }
3429 return result;
3430}
3431
Elliott Hughes872d4ec2011-10-21 17:07:15 -07003432} // namespace art