Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1 | /* |
| 2 | * Copyright (C) 2008 The Android Open Source Project |
| 3 | * |
| 4 | * Licensed under the Apache License, Version 2.0 (the "License"); |
| 5 | * you may not use this file except in compliance with the License. |
| 6 | * You may obtain a copy of the License at |
| 7 | * |
| 8 | * http://www.apache.org/licenses/LICENSE-2.0 |
| 9 | * |
| 10 | * Unless required by applicable law or agreed to in writing, software |
| 11 | * distributed under the License is distributed on an "AS IS" BASIS, |
| 12 | * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| 13 | * See the License for the specific language governing permissions and |
| 14 | * limitations under the License. |
| 15 | */ |
| 16 | |
| 17 | /* |
| 18 | * Handle messages from debugger. |
| 19 | * |
| 20 | * GENERAL NOTE: we're not currently testing the message length for |
| 21 | * correctness. This is usually a bad idea, but here we can probably |
| 22 | * get away with it so long as the debugger isn't broken. We can |
| 23 | * change the "read" macros to use "dataLen" to avoid wandering into |
| 24 | * bad territory, and have a single "is dataLen correct" check at the |
| 25 | * end of each function. Not needed at this time. |
| 26 | */ |
| 27 | |
| 28 | #include "atomic.h" |
| 29 | #include "debugger.h" |
| 30 | #include "jdwp/jdwp_priv.h" |
| 31 | #include "jdwp/jdwp_handler.h" |
| 32 | #include "jdwp/jdwp_event.h" |
| 33 | #include "jdwp/jdwp_constants.h" |
| 34 | #include "jdwp/jdwp_expand_buf.h" |
| 35 | #include "logging.h" |
| 36 | #include "macros.h" |
| 37 | #include "stringprintf.h" |
| 38 | |
| 39 | #include <stdlib.h> |
| 40 | #include <string.h> |
| 41 | #include <unistd.h> |
| 42 | |
| 43 | namespace art { |
| 44 | |
| 45 | namespace JDWP { |
| 46 | |
| 47 | /* |
| 48 | * Helper function: read a "location" from an input buffer. |
| 49 | */ |
| 50 | static void jdwpReadLocation(const uint8_t** pBuf, JdwpLocation* pLoc) { |
| 51 | memset(pLoc, 0, sizeof(*pLoc)); /* allows memcmp() later */ |
Elliott Hughes | d07986f | 2011-12-06 18:27:45 -0800 | [diff] [blame] | 52 | pLoc->typeTag = ReadTypeTag(pBuf); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 53 | pLoc->classId = ReadObjectId(pBuf); |
| 54 | pLoc->methodId = ReadMethodId(pBuf); |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 55 | pLoc->idx = Read8BE(pBuf); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 56 | } |
| 57 | |
| 58 | /* |
| 59 | * Helper function: write a "location" into the reply buffer. |
| 60 | */ |
| 61 | void AddLocation(ExpandBuf* pReply, const JdwpLocation* pLoc) { |
| 62 | expandBufAdd1(pReply, pLoc->typeTag); |
| 63 | expandBufAddObjectId(pReply, pLoc->classId); |
| 64 | expandBufAddMethodId(pReply, pLoc->methodId); |
| 65 | expandBufAdd8BE(pReply, pLoc->idx); |
| 66 | } |
| 67 | |
| 68 | /* |
| 69 | * Helper function: read a variable-width value from the input buffer. |
| 70 | */ |
Elliott Hughes | dbb4079 | 2011-11-18 17:05:22 -0800 | [diff] [blame] | 71 | static uint64_t jdwpReadValue(const uint8_t** pBuf, size_t width) { |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 72 | uint64_t value = -1; |
| 73 | switch (width) { |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 74 | case 1: value = Read1(pBuf); break; |
| 75 | case 2: value = Read2BE(pBuf); break; |
| 76 | case 4: value = Read4BE(pBuf); break; |
| 77 | case 8: value = Read8BE(pBuf); break; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 78 | default: LOG(FATAL) << width; break; |
| 79 | } |
| 80 | return value; |
| 81 | } |
| 82 | |
| 83 | /* |
| 84 | * Helper function: write a variable-width value into the output input buffer. |
| 85 | */ |
| 86 | static void jdwpWriteValue(ExpandBuf* pReply, int width, uint64_t value) { |
| 87 | switch (width) { |
| 88 | case 1: expandBufAdd1(pReply, value); break; |
| 89 | case 2: expandBufAdd2BE(pReply, value); break; |
| 90 | case 4: expandBufAdd4BE(pReply, value); break; |
| 91 | case 8: expandBufAdd8BE(pReply, value); break; |
| 92 | default: LOG(FATAL) << width; break; |
| 93 | } |
| 94 | } |
| 95 | |
| 96 | /* |
| 97 | * Common code for *_InvokeMethod requests. |
| 98 | * |
| 99 | * If "isConstructor" is set, this returns "objectId" rather than the |
| 100 | * expected-to-be-void return value of the called function. |
| 101 | */ |
| 102 | static JdwpError finishInvoke(JdwpState* state, |
| 103 | const uint8_t* buf, int dataLen, ExpandBuf* pReply, |
| 104 | ObjectId threadId, ObjectId objectId, RefTypeId classId, MethodId methodId, |
| 105 | bool isConstructor) |
| 106 | { |
| 107 | CHECK(!isConstructor || objectId != 0); |
| 108 | |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 109 | uint32_t numArgs = Read4BE(&buf); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 110 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 111 | VLOG(jdwp) << StringPrintf(" --> threadId=%llx objectId=%llx", threadId, objectId); |
| 112 | VLOG(jdwp) << StringPrintf(" classId=%llx methodId=%x %s.%s", classId, methodId, Dbg::GetClassDescriptor(classId).c_str(), Dbg::GetMethodName(classId, methodId).c_str()); |
| 113 | VLOG(jdwp) << StringPrintf(" %d args:", numArgs); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 114 | |
| 115 | uint64_t* argArray = NULL; |
| 116 | if (numArgs > 0) { |
| 117 | argArray = (ObjectId*) malloc(sizeof(ObjectId) * numArgs); |
| 118 | } |
| 119 | |
| 120 | for (uint32_t i = 0; i < numArgs; i++) { |
Elliott Hughes | aed4be9 | 2011-12-02 16:16:23 -0800 | [diff] [blame] | 121 | JDWP::JdwpTag typeTag = ReadTag(&buf); |
Elliott Hughes | dbb4079 | 2011-11-18 17:05:22 -0800 | [diff] [blame] | 122 | size_t width = Dbg::GetTagWidth(typeTag); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 123 | uint64_t value = jdwpReadValue(&buf, width); |
| 124 | |
Elliott Hughes | abd04b9 | 2012-01-18 22:46:41 -0800 | [diff] [blame] | 125 | VLOG(jdwp) << StringPrintf(" '%c'(%zd): 0x%llx", typeTag, width, value); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 126 | argArray[i] = value; |
| 127 | } |
| 128 | |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 129 | uint32_t options = Read4BE(&buf); /* enum InvokeOptions bit flags */ |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 130 | VLOG(jdwp) << StringPrintf(" options=0x%04x%s%s", options, (options & INVOKE_SINGLE_THREADED) ? " (SINGLE_THREADED)" : "", (options & INVOKE_NONVIRTUAL) ? " (NONVIRTUAL)" : ""); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 131 | |
Elliott Hughes | aed4be9 | 2011-12-02 16:16:23 -0800 | [diff] [blame] | 132 | JDWP::JdwpTag resultTag; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 133 | uint64_t resultValue; |
| 134 | ObjectId exceptObjId; |
| 135 | JdwpError err = Dbg::InvokeMethod(threadId, objectId, classId, methodId, numArgs, argArray, options, &resultTag, &resultValue, &exceptObjId); |
| 136 | if (err != ERR_NONE) { |
| 137 | goto bail; |
| 138 | } |
| 139 | |
| 140 | if (err == ERR_NONE) { |
| 141 | if (isConstructor) { |
| 142 | expandBufAdd1(pReply, JT_OBJECT); |
| 143 | expandBufAddObjectId(pReply, objectId); |
| 144 | } else { |
Elliott Hughes | dbb4079 | 2011-11-18 17:05:22 -0800 | [diff] [blame] | 145 | size_t width = Dbg::GetTagWidth(resultTag); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 146 | |
| 147 | expandBufAdd1(pReply, resultTag); |
| 148 | if (width != 0) { |
| 149 | jdwpWriteValue(pReply, width, resultValue); |
| 150 | } |
| 151 | } |
| 152 | expandBufAdd1(pReply, JT_OBJECT); |
| 153 | expandBufAddObjectId(pReply, exceptObjId); |
| 154 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 155 | VLOG(jdwp) << StringPrintf(" --> returned '%c' 0x%llx (except=%08llx)", resultTag, resultValue, exceptObjId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 156 | |
| 157 | /* show detailed debug output */ |
| 158 | if (resultTag == JT_STRING && exceptObjId == 0) { |
| 159 | if (resultValue != 0) { |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 160 | VLOG(jdwp) << " string '" << Dbg::StringToUtf8(resultValue) << "'"; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 161 | } else { |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 162 | VLOG(jdwp) << " string (null)"; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 163 | } |
| 164 | } |
| 165 | } |
| 166 | |
| 167 | bail: |
| 168 | free(argArray); |
| 169 | return err; |
| 170 | } |
| 171 | |
| 172 | |
| 173 | /* |
| 174 | * Request for version info. |
| 175 | */ |
| 176 | static JdwpError handleVM_Version(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 177 | /* text information on runtime version */ |
| 178 | std::string version(StringPrintf("Android Runtime %s", Runtime::Current()->GetVersion())); |
Elliott Hughes | 4740cdf | 2011-12-07 14:07:12 -0800 | [diff] [blame] | 179 | expandBufAddUtf8String(pReply, version); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 180 | /* JDWP version numbers */ |
| 181 | expandBufAdd4BE(pReply, 1); // major |
| 182 | expandBufAdd4BE(pReply, 5); // minor |
| 183 | /* VM JRE version */ |
Elliott Hughes | a215526 | 2011-11-16 16:26:58 -0800 | [diff] [blame] | 184 | expandBufAddUtf8String(pReply, "1.6.0"); /* e.g. 1.6.0_22 */ |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 185 | /* target VM name */ |
Elliott Hughes | a215526 | 2011-11-16 16:26:58 -0800 | [diff] [blame] | 186 | expandBufAddUtf8String(pReply, "DalvikVM"); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 187 | |
| 188 | return ERR_NONE; |
| 189 | } |
| 190 | |
| 191 | /* |
| 192 | * Given a class JNI signature (e.g. "Ljava/lang/Error;"), return the |
| 193 | * referenceTypeID. We need to send back more than one if the class has |
| 194 | * been loaded by multiple class loaders. |
| 195 | */ |
| 196 | static JdwpError handleVM_ClassesBySignature(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 197 | std::string classDescriptor(ReadNewUtf8String(&buf)); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 198 | VLOG(jdwp) << " Req for class by signature '" << classDescriptor << "'"; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 199 | |
Elliott Hughes | 6fa602d | 2011-12-02 17:54:25 -0800 | [diff] [blame] | 200 | std::vector<RefTypeId> ids; |
Elliott Hughes | c3b77c7 | 2011-12-15 20:56:48 -0800 | [diff] [blame] | 201 | Dbg::FindLoadedClassBySignature(classDescriptor.c_str(), ids); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 202 | |
Elliott Hughes | 6fa602d | 2011-12-02 17:54:25 -0800 | [diff] [blame] | 203 | expandBufAdd4BE(pReply, ids.size()); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 204 | |
Elliott Hughes | 6fa602d | 2011-12-02 17:54:25 -0800 | [diff] [blame] | 205 | for (size_t i = 0; i < ids.size(); ++i) { |
| 206 | // Get class vs. interface and status flags. |
| 207 | JDWP::JdwpTypeTag typeTag; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 208 | uint32_t status; |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 209 | if (!Dbg::GetClassInfo(ids[i], &typeTag, &status, NULL)) { |
| 210 | return ERR_INVALID_CLASS; |
| 211 | } |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 212 | |
| 213 | expandBufAdd1(pReply, typeTag); |
Elliott Hughes | 6fa602d | 2011-12-02 17:54:25 -0800 | [diff] [blame] | 214 | expandBufAddRefTypeId(pReply, ids[i]); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 215 | expandBufAdd4BE(pReply, status); |
| 216 | } |
| 217 | |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 218 | return ERR_NONE; |
| 219 | } |
| 220 | |
| 221 | /* |
| 222 | * Handle request for the thread IDs of all running threads. |
| 223 | * |
| 224 | * We exclude ourselves from the list, because we don't allow ourselves |
| 225 | * to be suspended, and that violates some JDWP expectations. |
| 226 | */ |
| 227 | static JdwpError handleVM_AllThreads(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 228 | ObjectId* pThreadIds; |
| 229 | uint32_t threadCount; |
| 230 | Dbg::GetAllThreads(&pThreadIds, &threadCount); |
| 231 | |
| 232 | expandBufAdd4BE(pReply, threadCount); |
| 233 | |
| 234 | ObjectId* walker = pThreadIds; |
| 235 | for (uint32_t i = 0; i < threadCount; i++) { |
| 236 | expandBufAddObjectId(pReply, *walker++); |
| 237 | } |
| 238 | |
| 239 | free(pThreadIds); |
| 240 | |
| 241 | return ERR_NONE; |
| 242 | } |
| 243 | |
| 244 | /* |
| 245 | * List all thread groups that do not have a parent. |
| 246 | */ |
| 247 | static JdwpError handleVM_TopLevelThreadGroups(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 248 | /* |
| 249 | * TODO: maintain a list of parentless thread groups in the VM. |
| 250 | * |
| 251 | * For now, just return "system". Application threads are created |
| 252 | * in "main", which is a child of "system". |
| 253 | */ |
| 254 | uint32_t groups = 1; |
| 255 | expandBufAdd4BE(pReply, groups); |
| 256 | //threadGroupId = debugGetMainThreadGroup(); |
| 257 | //expandBufAdd8BE(pReply, threadGroupId); |
| 258 | ObjectId threadGroupId = Dbg::GetSystemThreadGroupId(); |
| 259 | expandBufAddObjectId(pReply, threadGroupId); |
| 260 | |
| 261 | return ERR_NONE; |
| 262 | } |
| 263 | |
| 264 | /* |
| 265 | * Respond with the sizes of the basic debugger types. |
| 266 | * |
| 267 | * All IDs are 8 bytes. |
| 268 | */ |
| 269 | static JdwpError handleVM_IDSizes(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 270 | expandBufAdd4BE(pReply, sizeof(FieldId)); |
| 271 | expandBufAdd4BE(pReply, sizeof(MethodId)); |
| 272 | expandBufAdd4BE(pReply, sizeof(ObjectId)); |
| 273 | expandBufAdd4BE(pReply, sizeof(RefTypeId)); |
| 274 | expandBufAdd4BE(pReply, sizeof(FrameId)); |
| 275 | return ERR_NONE; |
| 276 | } |
| 277 | |
| 278 | /* |
| 279 | * The debugger is politely asking to disconnect. We're good with that. |
| 280 | * |
| 281 | * We could resume threads and clean up pinned references, but we can do |
| 282 | * that when the TCP connection drops. |
| 283 | */ |
| 284 | static JdwpError handleVM_Dispose(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 285 | return ERR_NONE; |
| 286 | } |
| 287 | |
| 288 | /* |
| 289 | * Suspend the execution of the application running in the VM (i.e. suspend |
| 290 | * all threads). |
| 291 | * |
| 292 | * This needs to increment the "suspend count" on all threads. |
| 293 | */ |
| 294 | static JdwpError handleVM_Suspend(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
Elliott Hughes | 475fc23 | 2011-10-25 15:00:35 -0700 | [diff] [blame] | 295 | Dbg::SuspendVM(); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 296 | return ERR_NONE; |
| 297 | } |
| 298 | |
| 299 | /* |
| 300 | * Resume execution. Decrements the "suspend count" of all threads. |
| 301 | */ |
| 302 | static JdwpError handleVM_Resume(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 303 | Dbg::ResumeVM(); |
| 304 | return ERR_NONE; |
| 305 | } |
| 306 | |
| 307 | /* |
| 308 | * The debugger wants the entire VM to exit. |
| 309 | */ |
| 310 | static JdwpError handleVM_Exit(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 311 | uint32_t exitCode = Get4BE(buf); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 312 | |
| 313 | LOG(WARNING) << "Debugger is telling the VM to exit with code=" << exitCode; |
| 314 | |
| 315 | Dbg::Exit(exitCode); |
| 316 | return ERR_NOT_IMPLEMENTED; // shouldn't get here |
| 317 | } |
| 318 | |
| 319 | /* |
| 320 | * Create a new string in the VM and return its ID. |
| 321 | * |
| 322 | * (Ctrl-Shift-I in Eclipse on an array of objects causes it to create the |
| 323 | * string "java.util.Arrays".) |
| 324 | */ |
| 325 | static JdwpError handleVM_CreateString(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 326 | std::string str(ReadNewUtf8String(&buf)); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 327 | VLOG(jdwp) << " Req to create string '" << str << "'"; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 328 | ObjectId stringId = Dbg::CreateString(str); |
| 329 | if (stringId == 0) { |
| 330 | return ERR_OUT_OF_MEMORY; |
| 331 | } |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 332 | expandBufAddObjectId(pReply, stringId); |
| 333 | return ERR_NONE; |
| 334 | } |
| 335 | |
| 336 | /* |
| 337 | * Tell the debugger what we are capable of. |
| 338 | */ |
| 339 | static JdwpError handleVM_Capabilities(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 340 | expandBufAdd1(pReply, false); /* canWatchFieldModification */ |
| 341 | expandBufAdd1(pReply, false); /* canWatchFieldAccess */ |
| 342 | expandBufAdd1(pReply, false); /* canGetBytecodes */ |
| 343 | expandBufAdd1(pReply, true); /* canGetSyntheticAttribute */ |
| 344 | expandBufAdd1(pReply, false); /* canGetOwnedMonitorInfo */ |
| 345 | expandBufAdd1(pReply, false); /* canGetCurrentContendedMonitor */ |
| 346 | expandBufAdd1(pReply, false); /* canGetMonitorInfo */ |
| 347 | return ERR_NONE; |
| 348 | } |
| 349 | |
| 350 | /* |
| 351 | * Return classpath and bootclasspath. |
| 352 | */ |
| 353 | static JdwpError handleVM_ClassPaths(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 354 | char baseDir[2] = "/"; |
| 355 | |
| 356 | /* |
| 357 | * TODO: make this real. Not important for remote debugging, but |
| 358 | * might be useful for local debugging. |
| 359 | */ |
| 360 | uint32_t classPaths = 1; |
| 361 | uint32_t bootClassPaths = 0; |
| 362 | |
Elliott Hughes | a215526 | 2011-11-16 16:26:58 -0800 | [diff] [blame] | 363 | expandBufAddUtf8String(pReply, baseDir); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 364 | expandBufAdd4BE(pReply, classPaths); |
| 365 | for (uint32_t i = 0; i < classPaths; i++) { |
Elliott Hughes | a215526 | 2011-11-16 16:26:58 -0800 | [diff] [blame] | 366 | expandBufAddUtf8String(pReply, "."); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 367 | } |
| 368 | |
| 369 | expandBufAdd4BE(pReply, bootClassPaths); |
| 370 | for (uint32_t i = 0; i < classPaths; i++) { |
| 371 | /* add bootclasspath components as strings */ |
| 372 | } |
| 373 | |
| 374 | return ERR_NONE; |
| 375 | } |
| 376 | |
| 377 | /* |
| 378 | * Release a list of object IDs. (Seen in jdb.) |
| 379 | * |
| 380 | * Currently does nothing. |
| 381 | */ |
| 382 | static JdwpError HandleVM_DisposeObjects(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 383 | return ERR_NONE; |
| 384 | } |
| 385 | |
| 386 | /* |
| 387 | * Tell the debugger what we are capable of. |
| 388 | */ |
| 389 | static JdwpError handleVM_CapabilitiesNew(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 390 | expandBufAdd1(pReply, false); /* canWatchFieldModification */ |
| 391 | expandBufAdd1(pReply, false); /* canWatchFieldAccess */ |
| 392 | expandBufAdd1(pReply, false); /* canGetBytecodes */ |
| 393 | expandBufAdd1(pReply, true); /* canGetSyntheticAttribute */ |
| 394 | expandBufAdd1(pReply, false); /* canGetOwnedMonitorInfo */ |
| 395 | expandBufAdd1(pReply, false); /* canGetCurrentContendedMonitor */ |
| 396 | expandBufAdd1(pReply, false); /* canGetMonitorInfo */ |
| 397 | expandBufAdd1(pReply, false); /* canRedefineClasses */ |
| 398 | expandBufAdd1(pReply, false); /* canAddMethod */ |
| 399 | expandBufAdd1(pReply, false); /* canUnrestrictedlyRedefineClasses */ |
| 400 | expandBufAdd1(pReply, false); /* canPopFrames */ |
| 401 | expandBufAdd1(pReply, false); /* canUseInstanceFilters */ |
| 402 | expandBufAdd1(pReply, false); /* canGetSourceDebugExtension */ |
| 403 | expandBufAdd1(pReply, false); /* canRequestVMDeathEvent */ |
| 404 | expandBufAdd1(pReply, false); /* canSetDefaultStratum */ |
| 405 | expandBufAdd1(pReply, false); /* 1.6: canGetInstanceInfo */ |
| 406 | expandBufAdd1(pReply, false); /* 1.6: canRequestMonitorEvents */ |
| 407 | expandBufAdd1(pReply, false); /* 1.6: canGetMonitorFrameInfo */ |
| 408 | expandBufAdd1(pReply, false); /* 1.6: canUseSourceNameFilters */ |
| 409 | expandBufAdd1(pReply, false); /* 1.6: canGetConstantPool */ |
| 410 | expandBufAdd1(pReply, false); /* 1.6: canForceEarlyReturn */ |
| 411 | |
| 412 | /* fill in reserved22 through reserved32; note count started at 1 */ |
| 413 | for (int i = 22; i <= 32; i++) { |
| 414 | expandBufAdd1(pReply, false); /* reservedN */ |
| 415 | } |
| 416 | return ERR_NONE; |
| 417 | } |
| 418 | |
| 419 | /* |
| 420 | * Cough up the complete list of classes. |
| 421 | */ |
| 422 | static JdwpError handleVM_AllClassesWithGeneric(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 423 | std::vector<JDWP::RefTypeId> classes; |
| 424 | Dbg::GetClassList(classes); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 425 | |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 426 | expandBufAdd4BE(pReply, classes.size()); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 427 | |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 428 | for (size_t i = 0; i < classes.size(); ++i) { |
Elliott Hughes | a215526 | 2011-11-16 16:26:58 -0800 | [diff] [blame] | 429 | static const char genericSignature[1] = ""; |
Elliott Hughes | 6fa602d | 2011-12-02 17:54:25 -0800 | [diff] [blame] | 430 | JDWP::JdwpTypeTag refTypeTag; |
Elliott Hughes | a215526 | 2011-11-16 16:26:58 -0800 | [diff] [blame] | 431 | std::string descriptor; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 432 | uint32_t status; |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 433 | if (!Dbg::GetClassInfo(classes[i], &refTypeTag, &status, &descriptor)) { |
| 434 | return ERR_INVALID_CLASS; |
| 435 | } |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 436 | |
| 437 | expandBufAdd1(pReply, refTypeTag); |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 438 | expandBufAddRefTypeId(pReply, classes[i]); |
Elliott Hughes | 4740cdf | 2011-12-07 14:07:12 -0800 | [diff] [blame] | 439 | expandBufAddUtf8String(pReply, descriptor); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 440 | expandBufAddUtf8String(pReply, genericSignature); |
| 441 | expandBufAdd4BE(pReply, status); |
| 442 | } |
| 443 | |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 444 | return ERR_NONE; |
| 445 | } |
| 446 | |
| 447 | /* |
| 448 | * Given a referenceTypeID, return a string with the JNI reference type |
| 449 | * signature (e.g. "Ljava/lang/Error;"). |
| 450 | */ |
| 451 | static JdwpError handleRT_Signature(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 452 | RefTypeId refTypeId = ReadRefTypeId(&buf); |
| 453 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 454 | VLOG(jdwp) << StringPrintf(" Req for signature of refTypeId=0x%llx", refTypeId); |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 455 | std::string signature; |
| 456 | if (!Dbg::GetSignature(refTypeId, signature)) { |
| 457 | return ERR_INVALID_CLASS; |
| 458 | } |
Elliott Hughes | 4740cdf | 2011-12-07 14:07:12 -0800 | [diff] [blame] | 459 | expandBufAddUtf8String(pReply, signature); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 460 | return ERR_NONE; |
| 461 | } |
| 462 | |
| 463 | /* |
| 464 | * Return the modifiers (a/k/a access flags) for a reference type. |
| 465 | */ |
| 466 | static JdwpError handleRT_Modifiers(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 467 | RefTypeId refTypeId = ReadRefTypeId(&buf); |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 468 | uint32_t access_flags; |
| 469 | if (!Dbg::GetAccessFlags(refTypeId, access_flags)) { |
| 470 | return ERR_INVALID_CLASS; |
| 471 | } |
| 472 | expandBufAdd4BE(pReply, access_flags); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 473 | return ERR_NONE; |
| 474 | } |
| 475 | |
| 476 | /* |
| 477 | * Get values from static fields in a reference type. |
| 478 | */ |
| 479 | static JdwpError handleRT_GetValues(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
Elliott Hughes | 6fa602d | 2011-12-02 17:54:25 -0800 | [diff] [blame] | 480 | ReadRefTypeId(&buf); // We don't need this, but we need to skip over it in the request. |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 481 | uint32_t numFields = Read4BE(&buf); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 482 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 483 | VLOG(jdwp) << " RT_GetValues " << numFields << ":"; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 484 | |
| 485 | expandBufAdd4BE(pReply, numFields); |
| 486 | for (uint32_t i = 0; i < numFields; i++) { |
| 487 | FieldId fieldId = ReadFieldId(&buf); |
Elliott Hughes | 6fa602d | 2011-12-02 17:54:25 -0800 | [diff] [blame] | 488 | Dbg::GetStaticFieldValue(fieldId, pReply); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 489 | } |
| 490 | |
| 491 | return ERR_NONE; |
| 492 | } |
| 493 | |
| 494 | /* |
| 495 | * Get the name of the source file in which a reference type was declared. |
| 496 | */ |
| 497 | static JdwpError handleRT_SourceFile(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 498 | RefTypeId refTypeId = ReadRefTypeId(&buf); |
Elliott Hughes | 03181a8 | 2011-11-17 17:22:21 -0800 | [diff] [blame] | 499 | std::string source_file; |
| 500 | if (!Dbg::GetSourceFile(refTypeId, source_file)) { |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 501 | return ERR_ABSENT_INFORMATION; |
| 502 | } |
Elliott Hughes | 4740cdf | 2011-12-07 14:07:12 -0800 | [diff] [blame] | 503 | expandBufAddUtf8String(pReply, source_file); |
Elliott Hughes | 03181a8 | 2011-11-17 17:22:21 -0800 | [diff] [blame] | 504 | return ERR_NONE; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 505 | } |
| 506 | |
| 507 | /* |
| 508 | * Return the current status of the reference type. |
| 509 | */ |
| 510 | static JdwpError handleRT_Status(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 511 | RefTypeId refTypeId = ReadRefTypeId(&buf); |
Elliott Hughes | 6fa602d | 2011-12-02 17:54:25 -0800 | [diff] [blame] | 512 | JDWP::JdwpTypeTag typeTag; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 513 | uint32_t status; |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 514 | if (!Dbg::GetClassInfo(refTypeId, &typeTag, &status, NULL)) { |
| 515 | return ERR_INVALID_CLASS; |
| 516 | } |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 517 | expandBufAdd4BE(pReply, status); |
| 518 | return ERR_NONE; |
| 519 | } |
| 520 | |
| 521 | /* |
| 522 | * Return interfaces implemented directly by this class. |
| 523 | */ |
| 524 | static JdwpError handleRT_Interfaces(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 525 | RefTypeId refTypeId = ReadRefTypeId(&buf); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 526 | VLOG(jdwp) << StringPrintf(" Req for interfaces in %llx (%s)", refTypeId, Dbg::GetClassDescriptor(refTypeId).c_str()); |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 527 | return Dbg::OutputDeclaredInterfaces(refTypeId, pReply) ? ERR_NONE : ERR_INVALID_CLASS; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 528 | } |
| 529 | |
| 530 | /* |
| 531 | * Return the class object corresponding to this type. |
| 532 | */ |
| 533 | static JdwpError handleRT_ClassObject(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 534 | RefTypeId refTypeId = ReadRefTypeId(&buf); |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 535 | ObjectId classObjectId; |
| 536 | if (!Dbg::GetClassObject(refTypeId, classObjectId)) { |
| 537 | return ERR_INVALID_CLASS; |
| 538 | } |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 539 | VLOG(jdwp) << StringPrintf(" RefTypeId %llx -> ObjectId %llx", refTypeId, classObjectId); |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 540 | expandBufAddObjectId(pReply, classObjectId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 541 | return ERR_NONE; |
| 542 | } |
| 543 | |
| 544 | /* |
| 545 | * Returns the value of the SourceDebugExtension attribute. |
| 546 | * |
| 547 | * JDB seems interested, but DEX files don't currently support this. |
| 548 | */ |
| 549 | static JdwpError handleRT_SourceDebugExtension(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 550 | /* referenceTypeId in, string out */ |
| 551 | return ERR_ABSENT_INFORMATION; |
| 552 | } |
| 553 | |
| 554 | /* |
| 555 | * Like RT_Signature but with the possibility of a "generic signature". |
| 556 | */ |
| 557 | static JdwpError handleRT_SignatureWithGeneric(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
Elliott Hughes | a215526 | 2011-11-16 16:26:58 -0800 | [diff] [blame] | 558 | static const char genericSignature[1] = ""; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 559 | |
| 560 | RefTypeId refTypeId = ReadRefTypeId(&buf); |
| 561 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 562 | VLOG(jdwp) << StringPrintf(" Req for signature of refTypeId=0x%llx", refTypeId); |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 563 | std::string signature; |
| 564 | if (Dbg::GetSignature(refTypeId, signature)) { |
Elliott Hughes | 4740cdf | 2011-12-07 14:07:12 -0800 | [diff] [blame] | 565 | expandBufAddUtf8String(pReply, signature); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 566 | } else { |
| 567 | LOG(WARNING) << StringPrintf("No signature for refTypeId=0x%llx", refTypeId); |
Elliott Hughes | a215526 | 2011-11-16 16:26:58 -0800 | [diff] [blame] | 568 | expandBufAddUtf8String(pReply, "Lunknown;"); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 569 | } |
| 570 | expandBufAddUtf8String(pReply, genericSignature); |
| 571 | |
| 572 | return ERR_NONE; |
| 573 | } |
| 574 | |
| 575 | /* |
| 576 | * Return the instance of java.lang.ClassLoader that loaded the specified |
| 577 | * reference type, or null if it was loaded by the system loader. |
| 578 | */ |
| 579 | static JdwpError handleRT_ClassLoader(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 580 | RefTypeId refTypeId = ReadRefTypeId(&buf); |
| 581 | |
| 582 | expandBufAddObjectId(pReply, Dbg::GetClassLoader(refTypeId)); |
| 583 | |
| 584 | return ERR_NONE; |
| 585 | } |
| 586 | |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 587 | static std::string Describe(const RefTypeId& refTypeId) { |
| 588 | std::string signature("unknown"); |
| 589 | Dbg::GetSignature(refTypeId, signature); |
| 590 | return StringPrintf("refTypeId=0x%llx (%s)", refTypeId, signature.c_str()); |
| 591 | } |
| 592 | |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 593 | /* |
| 594 | * Given a referenceTypeId, return a block of stuff that describes the |
| 595 | * fields declared by a class. |
| 596 | */ |
| 597 | static JdwpError handleRT_FieldsWithGeneric(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 598 | RefTypeId refTypeId = ReadRefTypeId(&buf); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 599 | VLOG(jdwp) << " Req for fields in " << Describe(refTypeId); |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 600 | return Dbg::OutputDeclaredFields(refTypeId, true, pReply) ? ERR_NONE : ERR_INVALID_CLASS; |
| 601 | } |
| 602 | |
| 603 | // Obsolete equivalent of FieldsWithGeneric, without the generic type information. |
| 604 | static JdwpError handleRT_Fields(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 605 | RefTypeId refTypeId = ReadRefTypeId(&buf); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 606 | VLOG(jdwp) << " Req for fields in " << Describe(refTypeId); |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 607 | return Dbg::OutputDeclaredFields(refTypeId, false, pReply) ? ERR_NONE : ERR_INVALID_CLASS; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 608 | } |
| 609 | |
| 610 | /* |
| 611 | * Given a referenceTypeID, return a block of goodies describing the |
| 612 | * methods declared by a class. |
| 613 | */ |
| 614 | static JdwpError handleRT_MethodsWithGeneric(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 615 | RefTypeId refTypeId = ReadRefTypeId(&buf); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 616 | VLOG(jdwp) << " Req for methods in " << Describe(refTypeId); |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 617 | return Dbg::OutputDeclaredMethods(refTypeId, true, pReply) ? ERR_NONE : ERR_INVALID_CLASS; |
| 618 | } |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 619 | |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 620 | // Obsolete equivalent of MethodsWithGeneric, without the generic type information. |
| 621 | static JdwpError handleRT_Methods(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 622 | RefTypeId refTypeId = ReadRefTypeId(&buf); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 623 | VLOG(jdwp) << " Req for methods in " << Describe(refTypeId); |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 624 | return Dbg::OutputDeclaredMethods(refTypeId, false, pReply) ? ERR_NONE : ERR_INVALID_CLASS; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 625 | } |
| 626 | |
| 627 | /* |
| 628 | * Return the immediate superclass of a class. |
| 629 | */ |
| 630 | static JdwpError handleCT_Superclass(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 631 | RefTypeId classId = ReadRefTypeId(&buf); |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 632 | RefTypeId superClassId; |
Elliott Hughes | 3d1ca6d | 2012-02-13 15:43:19 -0800 | [diff] [blame] | 633 | JdwpError status = Dbg::GetSuperclass(classId, superClassId); |
| 634 | if (status != ERR_NONE) { |
| 635 | return status; |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 636 | } |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 637 | expandBufAddRefTypeId(pReply, superClassId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 638 | return ERR_NONE; |
| 639 | } |
| 640 | |
| 641 | /* |
| 642 | * Set static class values. |
| 643 | */ |
| 644 | static JdwpError handleCT_SetValues(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 645 | RefTypeId classId = ReadRefTypeId(&buf); |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 646 | uint32_t values = Read4BE(&buf); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 647 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 648 | VLOG(jdwp) << StringPrintf(" Req to set %d values in classId=%llx", values, classId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 649 | |
| 650 | for (uint32_t i = 0; i < values; i++) { |
| 651 | FieldId fieldId = ReadFieldId(&buf); |
Elliott Hughes | aed4be9 | 2011-12-02 16:16:23 -0800 | [diff] [blame] | 652 | JDWP::JdwpTag fieldTag = Dbg::GetStaticFieldBasicTag(fieldId); |
Elliott Hughes | dbb4079 | 2011-11-18 17:05:22 -0800 | [diff] [blame] | 653 | size_t width = Dbg::GetTagWidth(fieldTag); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 654 | uint64_t value = jdwpReadValue(&buf, width); |
| 655 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 656 | VLOG(jdwp) << StringPrintf(" --> field=%x tag=%c -> %lld", fieldId, fieldTag, value); |
Elliott Hughes | 3d1ca6d | 2012-02-13 15:43:19 -0800 | [diff] [blame] | 657 | JdwpError status = Dbg::SetStaticFieldValue(fieldId, value, width); |
| 658 | if (status != ERR_NONE) { |
| 659 | return status; |
| 660 | } |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 661 | } |
| 662 | |
| 663 | return ERR_NONE; |
| 664 | } |
| 665 | |
| 666 | /* |
| 667 | * Invoke a static method. |
| 668 | * |
| 669 | * Example: Eclipse sometimes uses java/lang/Class.forName(String s) on |
| 670 | * values in the "variables" display. |
| 671 | */ |
| 672 | static JdwpError handleCT_InvokeMethod(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 673 | RefTypeId classId = ReadRefTypeId(&buf); |
| 674 | ObjectId threadId = ReadObjectId(&buf); |
| 675 | MethodId methodId = ReadMethodId(&buf); |
| 676 | |
| 677 | return finishInvoke(state, buf, dataLen, pReply, threadId, 0, classId, methodId, false); |
| 678 | } |
| 679 | |
| 680 | /* |
| 681 | * Create a new object of the requested type, and invoke the specified |
| 682 | * constructor. |
| 683 | * |
| 684 | * Example: in IntelliJ, create a watch on "new String(myByteArray)" to |
| 685 | * see the contents of a byte[] as a string. |
| 686 | */ |
| 687 | static JdwpError handleCT_NewInstance(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 688 | RefTypeId classId = ReadRefTypeId(&buf); |
| 689 | ObjectId threadId = ReadObjectId(&buf); |
| 690 | MethodId methodId = ReadMethodId(&buf); |
| 691 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 692 | VLOG(jdwp) << "Creating instance of " << Dbg::GetClassDescriptor(classId); |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 693 | ObjectId objectId; |
| 694 | if (!Dbg::CreateObject(classId, objectId)) { |
| 695 | return ERR_INVALID_CLASS; |
| 696 | } |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 697 | if (objectId == 0) { |
| 698 | return ERR_OUT_OF_MEMORY; |
| 699 | } |
| 700 | return finishInvoke(state, buf, dataLen, pReply, threadId, objectId, classId, methodId, true); |
| 701 | } |
| 702 | |
| 703 | /* |
| 704 | * Create a new array object of the requested type and length. |
| 705 | */ |
| 706 | static JdwpError handleAT_newInstance(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 707 | RefTypeId arrayTypeId = ReadRefTypeId(&buf); |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 708 | uint32_t length = Read4BE(&buf); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 709 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 710 | VLOG(jdwp) << StringPrintf("Creating array %s[%u]", Dbg::GetClassDescriptor(arrayTypeId).c_str(), length); |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 711 | ObjectId objectId; |
| 712 | if (!Dbg::CreateArrayObject(arrayTypeId, length, objectId)) { |
| 713 | return ERR_INVALID_CLASS; |
| 714 | } |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 715 | if (objectId == 0) { |
| 716 | return ERR_OUT_OF_MEMORY; |
| 717 | } |
| 718 | expandBufAdd1(pReply, JT_ARRAY); |
| 719 | expandBufAddObjectId(pReply, objectId); |
| 720 | return ERR_NONE; |
| 721 | } |
| 722 | |
| 723 | /* |
| 724 | * Return line number information for the method, if present. |
| 725 | */ |
| 726 | static JdwpError handleM_LineTable(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 727 | RefTypeId refTypeId = ReadRefTypeId(&buf); |
| 728 | MethodId methodId = ReadMethodId(&buf); |
| 729 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 730 | VLOG(jdwp) << StringPrintf(" Req for line table in %s.%s", Dbg::GetClassDescriptor(refTypeId).c_str(), Dbg::GetMethodName(refTypeId,methodId).c_str()); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 731 | |
| 732 | Dbg::OutputLineTable(refTypeId, methodId, pReply); |
| 733 | |
| 734 | return ERR_NONE; |
| 735 | } |
| 736 | |
Elliott Hughes | 3d1ca6d | 2012-02-13 15:43:19 -0800 | [diff] [blame] | 737 | static JdwpError handleM_VariableTable(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply, bool generic) { |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 738 | RefTypeId classId = ReadRefTypeId(&buf); |
| 739 | MethodId methodId = ReadMethodId(&buf); |
| 740 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 741 | VLOG(jdwp) << StringPrintf(" Req for LocalVarTab in class=%s method=%s", Dbg::GetClassDescriptor(classId).c_str(), Dbg::GetMethodName(classId, methodId).c_str()); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 742 | |
Elliott Hughes | 3d1ca6d | 2012-02-13 15:43:19 -0800 | [diff] [blame] | 743 | // We could return ERR_ABSENT_INFORMATION here if the DEX file was built without local variable |
| 744 | // information. That will cause Eclipse to make a best-effort attempt at displaying local |
| 745 | // variables anonymously. However, the attempt isn't very good, so we're probably better off just |
| 746 | // not showing anything. |
| 747 | Dbg::OutputVariableTable(classId, methodId, generic, pReply); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 748 | return ERR_NONE; |
| 749 | } |
| 750 | |
Elliott Hughes | 3d1ca6d | 2012-02-13 15:43:19 -0800 | [diff] [blame] | 751 | static JdwpError handleM_VariableTable(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 752 | return handleM_VariableTable(state, buf, dataLen, pReply, false); |
| 753 | } |
| 754 | |
| 755 | static JdwpError handleM_VariableTableWithGeneric(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 756 | return handleM_VariableTable(state, buf, dataLen, pReply, true); |
| 757 | } |
| 758 | |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 759 | /* |
| 760 | * Given an object reference, return the runtime type of the object |
| 761 | * (class or array). |
| 762 | * |
| 763 | * This can get called on different things, e.g. threadId gets |
| 764 | * passed in here. |
| 765 | */ |
| 766 | static JdwpError handleOR_ReferenceType(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 767 | ObjectId objectId = ReadObjectId(&buf); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 768 | VLOG(jdwp) << StringPrintf(" Req for type of objectId=0x%llx", objectId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 769 | |
Elliott Hughes | 6fa602d | 2011-12-02 17:54:25 -0800 | [diff] [blame] | 770 | JDWP::JdwpTypeTag refTypeTag; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 771 | RefTypeId typeId; |
| 772 | Dbg::GetObjectType(objectId, &refTypeTag, &typeId); |
| 773 | |
| 774 | expandBufAdd1(pReply, refTypeTag); |
| 775 | expandBufAddRefTypeId(pReply, typeId); |
| 776 | |
| 777 | return ERR_NONE; |
| 778 | } |
| 779 | |
| 780 | /* |
| 781 | * Get values from the fields of an object. |
| 782 | */ |
| 783 | static JdwpError handleOR_GetValues(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 784 | ObjectId objectId = ReadObjectId(&buf); |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 785 | uint32_t numFields = Read4BE(&buf); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 786 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 787 | VLOG(jdwp) << StringPrintf(" Req for %d fields from objectId=0x%llx", numFields, objectId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 788 | |
| 789 | expandBufAdd4BE(pReply, numFields); |
| 790 | |
| 791 | for (uint32_t i = 0; i < numFields; i++) { |
| 792 | FieldId fieldId = ReadFieldId(&buf); |
| 793 | Dbg::GetFieldValue(objectId, fieldId, pReply); |
| 794 | } |
| 795 | |
| 796 | return ERR_NONE; |
| 797 | } |
| 798 | |
| 799 | /* |
| 800 | * Set values in the fields of an object. |
| 801 | */ |
| 802 | static JdwpError handleOR_SetValues(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 803 | ObjectId objectId = ReadObjectId(&buf); |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 804 | uint32_t numFields = Read4BE(&buf); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 805 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 806 | VLOG(jdwp) << StringPrintf(" Req to set %d fields in objectId=0x%llx", numFields, objectId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 807 | |
| 808 | for (uint32_t i = 0; i < numFields; i++) { |
| 809 | FieldId fieldId = ReadFieldId(&buf); |
| 810 | |
Elliott Hughes | aed4be9 | 2011-12-02 16:16:23 -0800 | [diff] [blame] | 811 | JDWP::JdwpTag fieldTag = Dbg::GetFieldBasicTag(fieldId); |
Elliott Hughes | dbb4079 | 2011-11-18 17:05:22 -0800 | [diff] [blame] | 812 | size_t width = Dbg::GetTagWidth(fieldTag); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 813 | uint64_t value = jdwpReadValue(&buf, width); |
| 814 | |
Elliott Hughes | abd04b9 | 2012-01-18 22:46:41 -0800 | [diff] [blame] | 815 | VLOG(jdwp) << StringPrintf(" --> fieldId=%x tag='%c'(%zd) value=%lld", fieldId, fieldTag, width, value); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 816 | |
| 817 | Dbg::SetFieldValue(objectId, fieldId, value, width); |
| 818 | } |
| 819 | |
| 820 | return ERR_NONE; |
| 821 | } |
| 822 | |
| 823 | /* |
| 824 | * Invoke an instance method. The invocation must occur in the specified |
| 825 | * thread, which must have been suspended by an event. |
| 826 | * |
| 827 | * The call is synchronous. All threads in the VM are resumed, unless the |
| 828 | * SINGLE_THREADED flag is set. |
| 829 | * |
| 830 | * If you ask Eclipse to "inspect" an object (or ask JDB to "print" an |
| 831 | * object), it will try to invoke the object's toString() function. This |
| 832 | * feature becomes crucial when examining ArrayLists with Eclipse. |
| 833 | */ |
| 834 | static JdwpError handleOR_InvokeMethod(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 835 | ObjectId objectId = ReadObjectId(&buf); |
| 836 | ObjectId threadId = ReadObjectId(&buf); |
| 837 | RefTypeId classId = ReadRefTypeId(&buf); |
| 838 | MethodId methodId = ReadMethodId(&buf); |
| 839 | |
| 840 | return finishInvoke(state, buf, dataLen, pReply, threadId, objectId, classId, methodId, false); |
| 841 | } |
| 842 | |
| 843 | /* |
| 844 | * Disable garbage collection of the specified object. |
| 845 | */ |
| 846 | static JdwpError handleOR_DisableCollection(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 847 | // this is currently a no-op |
| 848 | return ERR_NONE; |
| 849 | } |
| 850 | |
| 851 | /* |
| 852 | * Enable garbage collection of the specified object. |
| 853 | */ |
| 854 | static JdwpError handleOR_EnableCollection(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 855 | // this is currently a no-op |
| 856 | return ERR_NONE; |
| 857 | } |
| 858 | |
| 859 | /* |
| 860 | * Determine whether an object has been garbage collected. |
| 861 | */ |
| 862 | static JdwpError handleOR_IsCollected(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 863 | ObjectId objectId; |
| 864 | |
| 865 | objectId = ReadObjectId(&buf); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 866 | VLOG(jdwp) << StringPrintf(" Req IsCollected(0x%llx)", objectId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 867 | |
| 868 | // TODO: currently returning false; must integrate with GC |
| 869 | expandBufAdd1(pReply, 0); |
| 870 | |
| 871 | return ERR_NONE; |
| 872 | } |
| 873 | |
| 874 | /* |
| 875 | * Return the string value in a string object. |
| 876 | */ |
| 877 | static JdwpError handleSR_Value(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 878 | ObjectId stringObject = ReadObjectId(&buf); |
Elliott Hughes | 68fdbd0 | 2011-11-29 19:22:47 -0800 | [diff] [blame] | 879 | std::string str(Dbg::StringToUtf8(stringObject)); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 880 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 881 | VLOG(jdwp) << StringPrintf(" Req for str %llx --> '%s'", stringObject, PrintableString(str).c_str()); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 882 | |
Elliott Hughes | 4740cdf | 2011-12-07 14:07:12 -0800 | [diff] [blame] | 883 | expandBufAddUtf8String(pReply, str); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 884 | |
| 885 | return ERR_NONE; |
| 886 | } |
| 887 | |
| 888 | /* |
| 889 | * Return a thread's name. |
| 890 | */ |
| 891 | static JdwpError handleTR_Name(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 892 | ObjectId threadId = ReadObjectId(&buf); |
| 893 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 894 | VLOG(jdwp) << StringPrintf(" Req for name of thread 0x%llx", threadId); |
Elliott Hughes | a2e54f6 | 2011-11-17 13:01:30 -0800 | [diff] [blame] | 895 | std::string name; |
| 896 | if (!Dbg::GetThreadName(threadId, name)) { |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 897 | return ERR_INVALID_THREAD; |
| 898 | } |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 899 | VLOG(jdwp) << StringPrintf(" Name of thread 0x%llx is \"%s\"", threadId, name.c_str()); |
Elliott Hughes | 4740cdf | 2011-12-07 14:07:12 -0800 | [diff] [blame] | 900 | expandBufAddUtf8String(pReply, name); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 901 | |
| 902 | return ERR_NONE; |
| 903 | } |
| 904 | |
| 905 | /* |
| 906 | * Suspend the specified thread. |
| 907 | * |
| 908 | * It's supposed to remain suspended even if interpreted code wants to |
| 909 | * resume it; only the JDI is allowed to resume it. |
| 910 | */ |
| 911 | static JdwpError handleTR_Suspend(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 912 | ObjectId threadId = ReadObjectId(&buf); |
| 913 | |
| 914 | if (threadId == Dbg::GetThreadSelfId()) { |
| 915 | LOG(INFO) << " Warning: ignoring request to suspend self"; |
| 916 | return ERR_THREAD_NOT_SUSPENDED; |
| 917 | } |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 918 | VLOG(jdwp) << StringPrintf(" Req to suspend thread 0x%llx", threadId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 919 | Dbg::SuspendThread(threadId); |
| 920 | return ERR_NONE; |
| 921 | } |
| 922 | |
| 923 | /* |
| 924 | * Resume the specified thread. |
| 925 | */ |
| 926 | static JdwpError handleTR_Resume(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 927 | ObjectId threadId = ReadObjectId(&buf); |
| 928 | |
| 929 | if (threadId == Dbg::GetThreadSelfId()) { |
| 930 | LOG(INFO) << " Warning: ignoring request to resume self"; |
| 931 | return ERR_NONE; |
| 932 | } |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 933 | VLOG(jdwp) << StringPrintf(" Req to resume thread 0x%llx", threadId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 934 | Dbg::ResumeThread(threadId); |
| 935 | return ERR_NONE; |
| 936 | } |
| 937 | |
| 938 | /* |
| 939 | * Return status of specified thread. |
| 940 | */ |
| 941 | static JdwpError handleTR_Status(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 942 | ObjectId threadId = ReadObjectId(&buf); |
| 943 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 944 | VLOG(jdwp) << StringPrintf(" Req for status of thread 0x%llx", threadId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 945 | |
Elliott Hughes | 3d30d9b | 2011-12-07 17:35:48 -0800 | [diff] [blame] | 946 | JDWP::JdwpThreadStatus threadStatus; |
| 947 | JDWP::JdwpSuspendStatus suspendStatus; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 948 | if (!Dbg::GetThreadStatus(threadId, &threadStatus, &suspendStatus)) { |
| 949 | return ERR_INVALID_THREAD; |
| 950 | } |
| 951 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 952 | VLOG(jdwp) << " --> " << threadStatus << ", " << suspendStatus; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 953 | |
| 954 | expandBufAdd4BE(pReply, threadStatus); |
| 955 | expandBufAdd4BE(pReply, suspendStatus); |
| 956 | |
| 957 | return ERR_NONE; |
| 958 | } |
| 959 | |
| 960 | /* |
| 961 | * Return the thread group that the specified thread is a member of. |
| 962 | */ |
| 963 | static JdwpError handleTR_ThreadGroup(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 964 | ObjectId threadId = ReadObjectId(&buf); |
| 965 | |
| 966 | /* currently not handling these */ |
| 967 | ObjectId threadGroupId = Dbg::GetThreadGroup(threadId); |
| 968 | expandBufAddObjectId(pReply, threadGroupId); |
| 969 | |
| 970 | return ERR_NONE; |
| 971 | } |
| 972 | |
| 973 | /* |
| 974 | * Return the current call stack of a suspended thread. |
| 975 | * |
| 976 | * If the thread isn't suspended, the error code isn't defined, but should |
| 977 | * be THREAD_NOT_SUSPENDED. |
| 978 | */ |
| 979 | static JdwpError handleTR_Frames(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 980 | ObjectId threadId = ReadObjectId(&buf); |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 981 | uint32_t startFrame = Read4BE(&buf); |
| 982 | uint32_t length = Read4BE(&buf); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 983 | |
| 984 | if (!Dbg::ThreadExists(threadId)) { |
| 985 | return ERR_INVALID_THREAD; |
| 986 | } |
| 987 | if (!Dbg::IsSuspended(threadId)) { |
Elliott Hughes | a2e54f6 | 2011-11-17 13:01:30 -0800 | [diff] [blame] | 988 | LOG(WARNING) << StringPrintf(" Rejecting req for frames in running thread %llx", threadId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 989 | return ERR_THREAD_NOT_SUSPENDED; |
| 990 | } |
| 991 | |
Elliott Hughes | 761928d | 2011-11-16 18:33:03 -0800 | [diff] [blame] | 992 | size_t frameCount = Dbg::GetThreadFrameCount(threadId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 993 | |
Elliott Hughes | abd04b9 | 2012-01-18 22:46:41 -0800 | [diff] [blame] | 994 | VLOG(jdwp) << StringPrintf(" Request for frames: threadId=%llx start=%d length=%d [count=%zd]", threadId, startFrame, length, frameCount); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 995 | if (frameCount <= 0) { |
| 996 | return ERR_THREAD_NOT_SUSPENDED; /* == 0 means 100% native */ |
| 997 | } |
| 998 | if (length == (uint32_t) -1) { |
| 999 | length = frameCount; |
| 1000 | } |
Elliott Hughes | 761928d | 2011-11-16 18:33:03 -0800 | [diff] [blame] | 1001 | CHECK_GE(startFrame, 0U); |
| 1002 | CHECK_LT(startFrame, frameCount); |
| 1003 | CHECK_LE(startFrame + length, frameCount); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1004 | |
| 1005 | uint32_t frames = length; |
| 1006 | expandBufAdd4BE(pReply, frames); |
| 1007 | for (uint32_t i = startFrame; i < (startFrame+length); i++) { |
| 1008 | FrameId frameId; |
| 1009 | JdwpLocation loc; |
| 1010 | |
| 1011 | Dbg::GetThreadFrame(threadId, i, &frameId, &loc); |
| 1012 | |
| 1013 | expandBufAdd8BE(pReply, frameId); |
| 1014 | AddLocation(pReply, &loc); |
| 1015 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1016 | VLOG(jdwp) << StringPrintf(" Frame %d: id=%llx loc={type=%d cls=%llx mth=%x loc=%llx}", i, frameId, loc.typeTag, loc.classId, loc.methodId, loc.idx); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1017 | } |
| 1018 | |
| 1019 | return ERR_NONE; |
| 1020 | } |
| 1021 | |
| 1022 | /* |
| 1023 | * Returns the #of frames on the specified thread, which must be suspended. |
| 1024 | */ |
| 1025 | static JdwpError handleTR_FrameCount(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 1026 | ObjectId threadId = ReadObjectId(&buf); |
| 1027 | |
| 1028 | if (!Dbg::ThreadExists(threadId)) { |
| 1029 | return ERR_INVALID_THREAD; |
| 1030 | } |
| 1031 | if (!Dbg::IsSuspended(threadId)) { |
Elliott Hughes | a2e54f6 | 2011-11-17 13:01:30 -0800 | [diff] [blame] | 1032 | LOG(WARNING) << StringPrintf(" Rejecting req for frames in running thread %llx", threadId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1033 | return ERR_THREAD_NOT_SUSPENDED; |
| 1034 | } |
| 1035 | |
| 1036 | int frameCount = Dbg::GetThreadFrameCount(threadId); |
| 1037 | if (frameCount < 0) { |
| 1038 | return ERR_INVALID_THREAD; |
| 1039 | } |
| 1040 | expandBufAdd4BE(pReply, (uint32_t)frameCount); |
| 1041 | |
| 1042 | return ERR_NONE; |
| 1043 | } |
| 1044 | |
| 1045 | /* |
| 1046 | * Get the monitor that the thread is waiting on. |
| 1047 | */ |
| 1048 | static JdwpError handleTR_CurrentContendedMonitor(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 1049 | ObjectId threadId; |
| 1050 | |
| 1051 | threadId = ReadObjectId(&buf); |
| 1052 | |
| 1053 | // TODO: create an Object to represent the monitor (we're currently |
| 1054 | // just using a raw Monitor struct in the VM) |
| 1055 | |
| 1056 | return ERR_NOT_IMPLEMENTED; |
| 1057 | } |
| 1058 | |
| 1059 | /* |
| 1060 | * Return the suspend count for the specified thread. |
| 1061 | * |
| 1062 | * (The thread *might* still be running -- it might not have examined |
| 1063 | * its suspend count recently.) |
| 1064 | */ |
| 1065 | static JdwpError handleTR_SuspendCount(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 1066 | ObjectId threadId = ReadObjectId(&buf); |
| 1067 | |
| 1068 | uint32_t suspendCount = Dbg::GetThreadSuspendCount(threadId); |
| 1069 | expandBufAdd4BE(pReply, suspendCount); |
| 1070 | |
| 1071 | return ERR_NONE; |
| 1072 | } |
| 1073 | |
| 1074 | /* |
| 1075 | * Return the name of a thread group. |
| 1076 | * |
| 1077 | * The Eclipse debugger recognizes "main" and "system" as special. |
| 1078 | */ |
| 1079 | static JdwpError handleTGR_Name(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 1080 | ObjectId threadGroupId = ReadObjectId(&buf); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1081 | VLOG(jdwp) << StringPrintf(" Req for name of threadGroupId=0x%llx", threadGroupId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1082 | |
Elliott Hughes | 4740cdf | 2011-12-07 14:07:12 -0800 | [diff] [blame] | 1083 | expandBufAddUtf8String(pReply, Dbg::GetThreadGroupName(threadGroupId)); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1084 | |
| 1085 | return ERR_NONE; |
| 1086 | } |
| 1087 | |
| 1088 | /* |
| 1089 | * Returns the thread group -- if any -- that contains the specified |
| 1090 | * thread group. |
| 1091 | */ |
| 1092 | static JdwpError handleTGR_Parent(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 1093 | ObjectId groupId = ReadObjectId(&buf); |
| 1094 | |
| 1095 | ObjectId parentGroup = Dbg::GetThreadGroupParent(groupId); |
| 1096 | expandBufAddObjectId(pReply, parentGroup); |
| 1097 | |
| 1098 | return ERR_NONE; |
| 1099 | } |
| 1100 | |
| 1101 | /* |
| 1102 | * Return the active threads and thread groups that are part of the |
| 1103 | * specified thread group. |
| 1104 | */ |
| 1105 | static JdwpError handleTGR_Children(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 1106 | ObjectId threadGroupId = ReadObjectId(&buf); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1107 | VLOG(jdwp) << StringPrintf(" Req for threads in threadGroupId=0x%llx", threadGroupId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1108 | |
| 1109 | ObjectId* pThreadIds; |
| 1110 | uint32_t threadCount; |
| 1111 | Dbg::GetThreadGroupThreads(threadGroupId, &pThreadIds, &threadCount); |
| 1112 | |
| 1113 | expandBufAdd4BE(pReply, threadCount); |
| 1114 | |
| 1115 | for (uint32_t i = 0; i < threadCount; i++) { |
| 1116 | expandBufAddObjectId(pReply, pThreadIds[i]); |
| 1117 | } |
| 1118 | free(pThreadIds); |
| 1119 | |
| 1120 | /* |
| 1121 | * TODO: finish support for child groups |
| 1122 | * |
| 1123 | * For now, just show that "main" is a child of "system". |
| 1124 | */ |
| 1125 | if (threadGroupId == Dbg::GetSystemThreadGroupId()) { |
| 1126 | expandBufAdd4BE(pReply, 1); |
| 1127 | expandBufAddObjectId(pReply, Dbg::GetMainThreadGroupId()); |
| 1128 | } else { |
| 1129 | expandBufAdd4BE(pReply, 0); |
| 1130 | } |
| 1131 | |
| 1132 | return ERR_NONE; |
| 1133 | } |
| 1134 | |
| 1135 | /* |
| 1136 | * Return the #of components in the array. |
| 1137 | */ |
| 1138 | static JdwpError handleAR_Length(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 1139 | ObjectId arrayId = ReadObjectId(&buf); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1140 | VLOG(jdwp) << StringPrintf(" Req for length of array 0x%llx", arrayId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1141 | |
Elliott Hughes | 3d1ca6d | 2012-02-13 15:43:19 -0800 | [diff] [blame] | 1142 | int length; |
| 1143 | JdwpError status = Dbg::GetArrayLength(arrayId, length); |
| 1144 | if (status != ERR_NONE) { |
| 1145 | return status; |
| 1146 | } |
| 1147 | VLOG(jdwp) << StringPrintf(" --> %d", length); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1148 | |
Elliott Hughes | 3d1ca6d | 2012-02-13 15:43:19 -0800 | [diff] [blame] | 1149 | expandBufAdd4BE(pReply, length); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1150 | |
| 1151 | return ERR_NONE; |
| 1152 | } |
| 1153 | |
| 1154 | /* |
| 1155 | * Return the values from an array. |
| 1156 | */ |
| 1157 | static JdwpError handleAR_GetValues(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 1158 | ObjectId arrayId = ReadObjectId(&buf); |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 1159 | uint32_t firstIndex = Read4BE(&buf); |
| 1160 | uint32_t length = Read4BE(&buf); |
Elliott Hughes | 3d1ca6d | 2012-02-13 15:43:19 -0800 | [diff] [blame] | 1161 | VLOG(jdwp) << StringPrintf(" Req for array values 0x%llx first=%d len=%d", arrayId, firstIndex, length); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1162 | |
Elliott Hughes | 3d1ca6d | 2012-02-13 15:43:19 -0800 | [diff] [blame] | 1163 | return Dbg::OutputArray(arrayId, firstIndex, length, pReply); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1164 | } |
| 1165 | |
| 1166 | /* |
| 1167 | * Set values in an array. |
| 1168 | */ |
| 1169 | static JdwpError handleAR_SetValues(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 1170 | ObjectId arrayId = ReadObjectId(&buf); |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 1171 | uint32_t firstIndex = Read4BE(&buf); |
| 1172 | uint32_t values = Read4BE(&buf); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1173 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1174 | VLOG(jdwp) << StringPrintf(" Req to set array values 0x%llx first=%d count=%d", arrayId, firstIndex, values); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1175 | |
Elliott Hughes | 3d1ca6d | 2012-02-13 15:43:19 -0800 | [diff] [blame] | 1176 | return Dbg::SetArrayElements(arrayId, firstIndex, values, buf); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1177 | } |
| 1178 | |
| 1179 | /* |
| 1180 | * Return the set of classes visible to a class loader. All classes which |
| 1181 | * have the class loader as a defining or initiating loader are returned. |
| 1182 | */ |
| 1183 | static JdwpError handleCLR_VisibleClasses(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 1184 | ObjectId classLoaderObject; |
| 1185 | uint32_t numClasses = 0; |
| 1186 | RefTypeId* classRefBuf = NULL; |
| 1187 | int i; |
| 1188 | |
| 1189 | classLoaderObject = ReadObjectId(&buf); |
| 1190 | |
| 1191 | Dbg::GetVisibleClassList(classLoaderObject, &numClasses, &classRefBuf); |
| 1192 | |
| 1193 | expandBufAdd4BE(pReply, numClasses); |
| 1194 | for (i = 0; i < (int) numClasses; i++) { |
| 1195 | uint8_t refTypeTag = Dbg::GetClassObjectType(classRefBuf[i]); |
| 1196 | |
| 1197 | expandBufAdd1(pReply, refTypeTag); |
| 1198 | expandBufAddRefTypeId(pReply, classRefBuf[i]); |
| 1199 | } |
| 1200 | |
| 1201 | return ERR_NONE; |
| 1202 | } |
| 1203 | |
| 1204 | /* |
| 1205 | * Return a newly-allocated string in which all occurrences of '.' have |
| 1206 | * been changed to '/'. If we find a '/' in the original string, NULL |
| 1207 | * is returned to avoid ambiguity. |
| 1208 | */ |
| 1209 | char* dvmDotToSlash(const char* str) { |
| 1210 | char* newStr = strdup(str); |
| 1211 | char* cp = newStr; |
| 1212 | |
| 1213 | if (newStr == NULL) { |
| 1214 | return NULL; |
| 1215 | } |
| 1216 | |
| 1217 | while (*cp != '\0') { |
| 1218 | if (*cp == '/') { |
| 1219 | CHECK(false); |
| 1220 | return NULL; |
| 1221 | } |
| 1222 | if (*cp == '.') { |
| 1223 | *cp = '/'; |
| 1224 | } |
| 1225 | cp++; |
| 1226 | } |
| 1227 | |
| 1228 | return newStr; |
| 1229 | } |
| 1230 | |
| 1231 | /* |
| 1232 | * Set an event trigger. |
| 1233 | * |
| 1234 | * Reply with a requestID. |
| 1235 | */ |
| 1236 | static JdwpError handleER_Set(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 1237 | const uint8_t* origBuf = buf; |
| 1238 | |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 1239 | uint8_t eventKind = Read1(&buf); |
| 1240 | uint8_t suspendPolicy = Read1(&buf); |
| 1241 | uint32_t modifierCount = Read4BE(&buf); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1242 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1243 | VLOG(jdwp) << " Set(kind=" << JdwpEventKind(eventKind) |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1244 | << " suspend=" << JdwpSuspendPolicy(suspendPolicy) |
| 1245 | << " mods=" << modifierCount << ")"; |
| 1246 | |
| 1247 | CHECK_LT(modifierCount, 256U); /* reasonableness check */ |
| 1248 | |
| 1249 | JdwpEvent* pEvent = EventAlloc(modifierCount); |
| 1250 | pEvent->eventKind = static_cast<JdwpEventKind>(eventKind); |
| 1251 | pEvent->suspendPolicy = static_cast<JdwpSuspendPolicy>(suspendPolicy); |
| 1252 | pEvent->modCount = modifierCount; |
| 1253 | |
| 1254 | /* |
| 1255 | * Read modifiers. Ordering may be significant (see explanation of Count |
| 1256 | * mods in JDWP doc). |
| 1257 | */ |
| 1258 | for (uint32_t idx = 0; idx < modifierCount; idx++) { |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 1259 | JdwpModKind modKind = static_cast<JdwpModKind>(Read1(&buf)); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1260 | |
| 1261 | pEvent->mods[idx].modKind = modKind; |
| 1262 | |
| 1263 | switch (modKind) { |
| 1264 | case MK_COUNT: /* report once, when "--count" reaches 0 */ |
| 1265 | { |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 1266 | uint32_t count = Read4BE(&buf); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1267 | VLOG(jdwp) << " Count: " << count; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1268 | if (count == 0) { |
| 1269 | return ERR_INVALID_COUNT; |
| 1270 | } |
| 1271 | pEvent->mods[idx].count.count = count; |
| 1272 | } |
| 1273 | break; |
| 1274 | case MK_CONDITIONAL: /* conditional on expression) */ |
| 1275 | { |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 1276 | uint32_t exprId = Read4BE(&buf); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1277 | VLOG(jdwp) << " Conditional: " << exprId; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1278 | pEvent->mods[idx].conditional.exprId = exprId; |
| 1279 | } |
| 1280 | break; |
| 1281 | case MK_THREAD_ONLY: /* only report events in specified thread */ |
| 1282 | { |
| 1283 | ObjectId threadId = ReadObjectId(&buf); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1284 | VLOG(jdwp) << StringPrintf(" ThreadOnly: %llx", threadId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1285 | pEvent->mods[idx].threadOnly.threadId = threadId; |
| 1286 | } |
| 1287 | break; |
| 1288 | case MK_CLASS_ONLY: /* for ClassPrepare, MethodEntry */ |
| 1289 | { |
| 1290 | RefTypeId clazzId = ReadRefTypeId(&buf); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1291 | VLOG(jdwp) << StringPrintf(" ClassOnly: %llx (%s)", clazzId, Dbg::GetClassDescriptor(clazzId).c_str()); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1292 | pEvent->mods[idx].classOnly.refTypeId = clazzId; |
| 1293 | } |
| 1294 | break; |
| 1295 | case MK_CLASS_MATCH: /* restrict events to matching classes */ |
| 1296 | { |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 1297 | std::string pattern(ReadNewUtf8String(&buf)); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1298 | VLOG(jdwp) << StringPrintf(" ClassMatch: '%s'", pattern.c_str()); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1299 | /* pattern is "java.foo.*", we want "java/foo/ *" */ |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 1300 | pEvent->mods[idx].classMatch.classPattern = dvmDotToSlash(pattern.c_str()); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1301 | } |
| 1302 | break; |
| 1303 | case MK_CLASS_EXCLUDE: /* restrict events to non-matching classes */ |
| 1304 | { |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 1305 | std::string pattern(ReadNewUtf8String(&buf)); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1306 | VLOG(jdwp) << StringPrintf(" ClassExclude: '%s'", pattern.c_str()); |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 1307 | pEvent->mods[idx].classExclude.classPattern = dvmDotToSlash(pattern.c_str()); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1308 | } |
| 1309 | break; |
| 1310 | case MK_LOCATION_ONLY: /* restrict certain events based on loc */ |
| 1311 | { |
| 1312 | JdwpLocation loc; |
| 1313 | |
| 1314 | jdwpReadLocation(&buf, &loc); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1315 | VLOG(jdwp) << StringPrintf(" LocationOnly: typeTag=%d classId=%llx methodId=%x idx=%llx", |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1316 | loc.typeTag, loc.classId, loc.methodId, loc.idx); |
| 1317 | pEvent->mods[idx].locationOnly.loc = loc; |
| 1318 | } |
| 1319 | break; |
| 1320 | case MK_EXCEPTION_ONLY: /* modifies EK_EXCEPTION events */ |
| 1321 | { |
| 1322 | RefTypeId exceptionOrNull; /* null == all exceptions */ |
| 1323 | uint8_t caught, uncaught; |
| 1324 | |
| 1325 | exceptionOrNull = ReadRefTypeId(&buf); |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 1326 | caught = Read1(&buf); |
| 1327 | uncaught = Read1(&buf); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1328 | VLOG(jdwp) << StringPrintf(" ExceptionOnly: type=%llx(%s) caught=%d uncaught=%d", |
Elliott Hughes | a215526 | 2011-11-16 16:26:58 -0800 | [diff] [blame] | 1329 | exceptionOrNull, (exceptionOrNull == 0) ? "null" : Dbg::GetClassDescriptor(exceptionOrNull).c_str(), caught, uncaught); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1330 | |
| 1331 | pEvent->mods[idx].exceptionOnly.refTypeId = exceptionOrNull; |
| 1332 | pEvent->mods[idx].exceptionOnly.caught = caught; |
| 1333 | pEvent->mods[idx].exceptionOnly.uncaught = uncaught; |
| 1334 | } |
| 1335 | break; |
| 1336 | case MK_FIELD_ONLY: /* for field access/mod events */ |
| 1337 | { |
| 1338 | RefTypeId declaring = ReadRefTypeId(&buf); |
| 1339 | FieldId fieldId = ReadFieldId(&buf); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1340 | VLOG(jdwp) << StringPrintf(" FieldOnly: %llx %x", declaring, fieldId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1341 | pEvent->mods[idx].fieldOnly.refTypeId = declaring; |
| 1342 | pEvent->mods[idx].fieldOnly.fieldId = fieldId; |
| 1343 | } |
| 1344 | break; |
| 1345 | case MK_STEP: /* for use with EK_SINGLE_STEP */ |
| 1346 | { |
| 1347 | ObjectId threadId; |
| 1348 | uint32_t size, depth; |
| 1349 | |
| 1350 | threadId = ReadObjectId(&buf); |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 1351 | size = Read4BE(&buf); |
| 1352 | depth = Read4BE(&buf); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1353 | VLOG(jdwp) << StringPrintf(" Step: thread=%llx", threadId) |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1354 | << " size=" << JdwpStepSize(size) << " depth=" << JdwpStepDepth(depth); |
| 1355 | |
| 1356 | pEvent->mods[idx].step.threadId = threadId; |
| 1357 | pEvent->mods[idx].step.size = size; |
| 1358 | pEvent->mods[idx].step.depth = depth; |
| 1359 | } |
| 1360 | break; |
| 1361 | case MK_INSTANCE_ONLY: /* report events related to a specific obj */ |
| 1362 | { |
| 1363 | ObjectId instance = ReadObjectId(&buf); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1364 | VLOG(jdwp) << StringPrintf(" InstanceOnly: %llx", instance); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1365 | pEvent->mods[idx].instanceOnly.objectId = instance; |
| 1366 | } |
| 1367 | break; |
| 1368 | default: |
| 1369 | LOG(WARNING) << "GLITCH: unsupported modKind=" << modKind; |
| 1370 | break; |
| 1371 | } |
| 1372 | } |
| 1373 | |
| 1374 | /* |
| 1375 | * Make sure we consumed all data. It is possible that the remote side |
| 1376 | * has sent us bad stuff, but for now we blame ourselves. |
| 1377 | */ |
| 1378 | if (buf != origBuf + dataLen) { |
| 1379 | LOG(WARNING) << "GLITCH: dataLen is " << dataLen << ", we have consumed " << (buf - origBuf); |
| 1380 | } |
| 1381 | |
| 1382 | /* |
| 1383 | * We reply with an integer "requestID". |
| 1384 | */ |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 1385 | uint32_t requestId = state->NextEventSerial(); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1386 | expandBufAdd4BE(pReply, requestId); |
| 1387 | |
| 1388 | pEvent->requestId = requestId; |
| 1389 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1390 | VLOG(jdwp) << StringPrintf(" --> event requestId=%#x", requestId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1391 | |
| 1392 | /* add it to the list */ |
Elliott Hughes | 761928d | 2011-11-16 18:33:03 -0800 | [diff] [blame] | 1393 | JdwpError err = state->RegisterEvent(pEvent); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1394 | if (err != ERR_NONE) { |
| 1395 | /* registration failed, probably because event is bogus */ |
| 1396 | EventFree(pEvent); |
| 1397 | LOG(WARNING) << "WARNING: event request rejected"; |
| 1398 | } |
| 1399 | return err; |
| 1400 | } |
| 1401 | |
| 1402 | /* |
| 1403 | * Clear an event. Failure to find an event with a matching ID is a no-op |
| 1404 | * and does not return an error. |
| 1405 | */ |
| 1406 | static JdwpError handleER_Clear(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 1407 | uint8_t eventKind; |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 1408 | eventKind = Read1(&buf); |
| 1409 | uint32_t requestId = Read4BE(&buf); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1410 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1411 | VLOG(jdwp) << StringPrintf(" Req to clear eventKind=%d requestId=%#x", eventKind, requestId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1412 | |
Elliott Hughes | 761928d | 2011-11-16 18:33:03 -0800 | [diff] [blame] | 1413 | state->UnregisterEventById(requestId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1414 | |
| 1415 | return ERR_NONE; |
| 1416 | } |
| 1417 | |
| 1418 | /* |
| 1419 | * Return the values of arguments and local variables. |
| 1420 | */ |
| 1421 | static JdwpError handleSF_GetValues(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 1422 | ObjectId threadId = ReadObjectId(&buf); |
| 1423 | FrameId frameId = ReadFrameId(&buf); |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 1424 | uint32_t slots = Read4BE(&buf); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1425 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1426 | VLOG(jdwp) << StringPrintf(" Req for %d slots in threadId=%llx frameId=%llx", slots, threadId, frameId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1427 | |
| 1428 | expandBufAdd4BE(pReply, slots); /* "int values" */ |
| 1429 | for (uint32_t i = 0; i < slots; i++) { |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 1430 | uint32_t slot = Read4BE(&buf); |
Elliott Hughes | aed4be9 | 2011-12-02 16:16:23 -0800 | [diff] [blame] | 1431 | JDWP::JdwpTag reqSigByte = ReadTag(&buf); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1432 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1433 | VLOG(jdwp) << StringPrintf(" --> slot %d '%c'", slot, reqSigByte); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1434 | |
Elliott Hughes | dbb4079 | 2011-11-18 17:05:22 -0800 | [diff] [blame] | 1435 | size_t width = Dbg::GetTagWidth(reqSigByte); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1436 | uint8_t* ptr = expandBufAddSpace(pReply, width+1); |
| 1437 | Dbg::GetLocalValue(threadId, frameId, slot, reqSigByte, ptr, width); |
| 1438 | } |
| 1439 | |
| 1440 | return ERR_NONE; |
| 1441 | } |
| 1442 | |
| 1443 | /* |
| 1444 | * Set the values of arguments and local variables. |
| 1445 | */ |
| 1446 | static JdwpError handleSF_SetValues(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 1447 | ObjectId threadId = ReadObjectId(&buf); |
| 1448 | FrameId frameId = ReadFrameId(&buf); |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 1449 | uint32_t slots = Read4BE(&buf); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1450 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1451 | VLOG(jdwp) << StringPrintf(" Req to set %d slots in threadId=%llx frameId=%llx", slots, threadId, frameId); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1452 | |
| 1453 | for (uint32_t i = 0; i < slots; i++) { |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 1454 | uint32_t slot = Read4BE(&buf); |
Elliott Hughes | aed4be9 | 2011-12-02 16:16:23 -0800 | [diff] [blame] | 1455 | JDWP::JdwpTag sigByte = ReadTag(&buf); |
Elliott Hughes | dbb4079 | 2011-11-18 17:05:22 -0800 | [diff] [blame] | 1456 | size_t width = Dbg::GetTagWidth(sigByte); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1457 | uint64_t value = jdwpReadValue(&buf, width); |
| 1458 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1459 | VLOG(jdwp) << StringPrintf(" --> slot %d '%c' %llx", slot, sigByte, value); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1460 | Dbg::SetLocalValue(threadId, frameId, slot, sigByte, value, width); |
| 1461 | } |
| 1462 | |
| 1463 | return ERR_NONE; |
| 1464 | } |
| 1465 | |
| 1466 | /* |
| 1467 | * Returns the value of "this" for the specified frame. |
| 1468 | */ |
| 1469 | static JdwpError handleSF_ThisObject(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
Elliott Hughes | d07986f | 2011-12-06 18:27:45 -0800 | [diff] [blame] | 1470 | ReadObjectId(&buf); // Skip thread id. |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1471 | FrameId frameId = ReadFrameId(&buf); |
| 1472 | |
| 1473 | ObjectId objectId; |
Elliott Hughes | d07986f | 2011-12-06 18:27:45 -0800 | [diff] [blame] | 1474 | if (!Dbg::GetThisObject(frameId, &objectId)) { |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1475 | return ERR_INVALID_FRAMEID; |
| 1476 | } |
| 1477 | |
| 1478 | uint8_t objectTag = Dbg::GetObjectTag(objectId); |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1479 | VLOG(jdwp) << StringPrintf(" Req for 'this' in frame=%llx --> %llx '%c'", frameId, objectId, (char)objectTag); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1480 | |
| 1481 | expandBufAdd1(pReply, objectTag); |
| 1482 | expandBufAddObjectId(pReply, objectId); |
| 1483 | |
| 1484 | return ERR_NONE; |
| 1485 | } |
| 1486 | |
| 1487 | /* |
| 1488 | * Return the reference type reflected by this class object. |
| 1489 | * |
| 1490 | * This appears to be required because ReferenceTypeId values are NEVER |
| 1491 | * reused, whereas ClassIds can be recycled like any other object. (Either |
| 1492 | * that, or I have no idea what this is for.) |
| 1493 | */ |
| 1494 | static JdwpError handleCOR_ReflectedType(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 1495 | RefTypeId classObjectId = ReadRefTypeId(&buf); |
| 1496 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1497 | VLOG(jdwp) << StringPrintf(" Req for refTypeId for class=%llx (%s)", classObjectId, Dbg::GetClassDescriptor(classObjectId).c_str()); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1498 | |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 1499 | bool is_interface; |
| 1500 | if (!Dbg::IsInterface(classObjectId, is_interface)) { |
| 1501 | return ERR_INVALID_CLASS; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1502 | } |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 1503 | |
| 1504 | expandBufAdd1(pReply, is_interface ? TT_INTERFACE : TT_CLASS); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1505 | expandBufAddRefTypeId(pReply, classObjectId); |
| 1506 | |
| 1507 | return ERR_NONE; |
| 1508 | } |
| 1509 | |
| 1510 | /* |
| 1511 | * Handle a DDM packet with a single chunk in it. |
| 1512 | */ |
| 1513 | static JdwpError handleDDM_Chunk(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
| 1514 | uint8_t* replyBuf = NULL; |
| 1515 | int replyLen = -1; |
| 1516 | |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1517 | VLOG(jdwp) << StringPrintf(" Handling DDM packet (%.4s)", buf); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1518 | |
| 1519 | /* |
| 1520 | * On first DDM packet, notify all handlers that DDM is running. |
| 1521 | */ |
| 1522 | if (!state->ddmActive) { |
| 1523 | state->ddmActive = true; |
| 1524 | Dbg::DdmConnected(); |
| 1525 | } |
| 1526 | |
| 1527 | /* |
| 1528 | * If they want to send something back, we copy it into the buffer. |
| 1529 | * A no-copy approach would be nicer. |
| 1530 | * |
| 1531 | * TODO: consider altering the JDWP stuff to hold the packet header |
| 1532 | * in a separate buffer. That would allow us to writev() DDM traffic |
| 1533 | * instead of copying it into the expanding buffer. The reduction in |
| 1534 | * heap requirements is probably more valuable than the efficiency. |
| 1535 | */ |
| 1536 | if (Dbg::DdmHandlePacket(buf, dataLen, &replyBuf, &replyLen)) { |
| 1537 | CHECK(replyLen > 0 && replyLen < 1*1024*1024); |
| 1538 | memcpy(expandBufAddSpace(pReply, replyLen), replyBuf, replyLen); |
| 1539 | free(replyBuf); |
| 1540 | } |
| 1541 | return ERR_NONE; |
| 1542 | } |
| 1543 | |
| 1544 | /* |
| 1545 | * Handler map decl. |
| 1546 | */ |
| 1547 | typedef JdwpError (*JdwpRequestHandler)(JdwpState* state, const uint8_t* buf, int dataLen, ExpandBuf* reply); |
| 1548 | |
| 1549 | struct JdwpHandlerMap { |
| 1550 | uint8_t cmdSet; |
| 1551 | uint8_t cmd; |
| 1552 | JdwpRequestHandler func; |
| 1553 | const char* descr; |
| 1554 | }; |
| 1555 | |
| 1556 | /* |
| 1557 | * Map commands to functions. |
| 1558 | * |
| 1559 | * Command sets 0-63 are incoming requests, 64-127 are outbound requests, |
| 1560 | * and 128-256 are vendor-defined. |
| 1561 | */ |
| 1562 | static const JdwpHandlerMap gHandlerMap[] = { |
| 1563 | /* VirtualMachine command set (1) */ |
| 1564 | { 1, 1, handleVM_Version, "VirtualMachine.Version" }, |
| 1565 | { 1, 2, handleVM_ClassesBySignature, "VirtualMachine.ClassesBySignature" }, |
Elliott Hughes | a3c24aa | 2011-12-07 15:34:09 -0800 | [diff] [blame] | 1566 | { 1, 3, NULL, "VirtualMachine.AllClasses" }, |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1567 | { 1, 4, handleVM_AllThreads, "VirtualMachine.AllThreads" }, |
| 1568 | { 1, 5, handleVM_TopLevelThreadGroups, "VirtualMachine.TopLevelThreadGroups" }, |
| 1569 | { 1, 6, handleVM_Dispose, "VirtualMachine.Dispose" }, |
| 1570 | { 1, 7, handleVM_IDSizes, "VirtualMachine.IDSizes" }, |
| 1571 | { 1, 8, handleVM_Suspend, "VirtualMachine.Suspend" }, |
| 1572 | { 1, 9, handleVM_Resume, "VirtualMachine.Resume" }, |
| 1573 | { 1, 10, handleVM_Exit, "VirtualMachine.Exit" }, |
| 1574 | { 1, 11, handleVM_CreateString, "VirtualMachine.CreateString" }, |
| 1575 | { 1, 12, handleVM_Capabilities, "VirtualMachine.Capabilities" }, |
| 1576 | { 1, 13, handleVM_ClassPaths, "VirtualMachine.ClassPaths" }, |
| 1577 | { 1, 14, HandleVM_DisposeObjects, "VirtualMachine.DisposeObjects" }, |
Elliott Hughes | a3c24aa | 2011-12-07 15:34:09 -0800 | [diff] [blame] | 1578 | { 1, 15, NULL, "VirtualMachine.HoldEvents" }, |
| 1579 | { 1, 16, NULL, "VirtualMachine.ReleaseEvents" }, |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1580 | { 1, 17, handleVM_CapabilitiesNew, "VirtualMachine.CapabilitiesNew" }, |
Elliott Hughes | a3c24aa | 2011-12-07 15:34:09 -0800 | [diff] [blame] | 1581 | { 1, 18, NULL, "VirtualMachine.RedefineClasses" }, |
| 1582 | { 1, 19, NULL, "VirtualMachine.SetDefaultStratum" }, |
| 1583 | { 1, 20, handleVM_AllClassesWithGeneric, "VirtualMachine.AllClassesWithGeneric" }, |
| 1584 | { 1, 21, NULL, "VirtualMachine.InstanceCounts" }, |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1585 | |
| 1586 | /* ReferenceType command set (2) */ |
| 1587 | { 2, 1, handleRT_Signature, "ReferenceType.Signature" }, |
| 1588 | { 2, 2, handleRT_ClassLoader, "ReferenceType.ClassLoader" }, |
| 1589 | { 2, 3, handleRT_Modifiers, "ReferenceType.Modifiers" }, |
Elliott Hughes | 7b3cdfc | 2011-12-08 21:28:17 -0800 | [diff] [blame] | 1590 | { 2, 4, handleRT_Fields, "ReferenceType.Fields" }, |
| 1591 | { 2, 5, handleRT_Methods, "ReferenceType.Methods" }, |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1592 | { 2, 6, handleRT_GetValues, "ReferenceType.GetValues" }, |
| 1593 | { 2, 7, handleRT_SourceFile, "ReferenceType.SourceFile" }, |
Elliott Hughes | a3c24aa | 2011-12-07 15:34:09 -0800 | [diff] [blame] | 1594 | { 2, 8, NULL, "ReferenceType.NestedTypes" }, |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1595 | { 2, 9, handleRT_Status, "ReferenceType.Status" }, |
| 1596 | { 2, 10, handleRT_Interfaces, "ReferenceType.Interfaces" }, |
| 1597 | { 2, 11, handleRT_ClassObject, "ReferenceType.ClassObject" }, |
| 1598 | { 2, 12, handleRT_SourceDebugExtension, "ReferenceType.SourceDebugExtension" }, |
| 1599 | { 2, 13, handleRT_SignatureWithGeneric, "ReferenceType.SignatureWithGeneric" }, |
| 1600 | { 2, 14, handleRT_FieldsWithGeneric, "ReferenceType.FieldsWithGeneric" }, |
| 1601 | { 2, 15, handleRT_MethodsWithGeneric, "ReferenceType.MethodsWithGeneric" }, |
Elliott Hughes | a3c24aa | 2011-12-07 15:34:09 -0800 | [diff] [blame] | 1602 | { 2, 16, NULL, "ReferenceType.Instances" }, |
| 1603 | { 2, 17, NULL, "ReferenceType.ClassFileVersion" }, |
| 1604 | { 2, 18, NULL, "ReferenceType.ConstantPool" }, |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1605 | |
| 1606 | /* ClassType command set (3) */ |
| 1607 | { 3, 1, handleCT_Superclass, "ClassType.Superclass" }, |
| 1608 | { 3, 2, handleCT_SetValues, "ClassType.SetValues" }, |
| 1609 | { 3, 3, handleCT_InvokeMethod, "ClassType.InvokeMethod" }, |
| 1610 | { 3, 4, handleCT_NewInstance, "ClassType.NewInstance" }, |
| 1611 | |
| 1612 | /* ArrayType command set (4) */ |
| 1613 | { 4, 1, handleAT_newInstance, "ArrayType.NewInstance" }, |
| 1614 | |
| 1615 | /* InterfaceType command set (5) */ |
| 1616 | |
| 1617 | /* Method command set (6) */ |
| 1618 | { 6, 1, handleM_LineTable, "Method.LineTable" }, |
Elliott Hughes | 3d1ca6d | 2012-02-13 15:43:19 -0800 | [diff] [blame] | 1619 | { 6, 2, handleM_VariableTable, "Method.VariableTable" }, |
Elliott Hughes | a3c24aa | 2011-12-07 15:34:09 -0800 | [diff] [blame] | 1620 | { 6, 3, NULL, "Method.Bytecodes" }, |
| 1621 | { 6, 4, NULL, "Method.IsObsolete" }, |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1622 | { 6, 5, handleM_VariableTableWithGeneric, "Method.VariableTableWithGeneric" }, |
| 1623 | |
| 1624 | /* Field command set (8) */ |
| 1625 | |
| 1626 | /* ObjectReference command set (9) */ |
| 1627 | { 9, 1, handleOR_ReferenceType, "ObjectReference.ReferenceType" }, |
| 1628 | { 9, 2, handleOR_GetValues, "ObjectReference.GetValues" }, |
| 1629 | { 9, 3, handleOR_SetValues, "ObjectReference.SetValues" }, |
Elliott Hughes | a3c24aa | 2011-12-07 15:34:09 -0800 | [diff] [blame] | 1630 | { 9, 4, NULL, "ObjectReference.UNUSED" }, |
| 1631 | { 9, 5, NULL, "ObjectReference.MonitorInfo" }, |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1632 | { 9, 6, handleOR_InvokeMethod, "ObjectReference.InvokeMethod" }, |
| 1633 | { 9, 7, handleOR_DisableCollection, "ObjectReference.DisableCollection" }, |
| 1634 | { 9, 8, handleOR_EnableCollection, "ObjectReference.EnableCollection" }, |
| 1635 | { 9, 9, handleOR_IsCollected, "ObjectReference.IsCollected" }, |
Elliott Hughes | a3c24aa | 2011-12-07 15:34:09 -0800 | [diff] [blame] | 1636 | { 9, 10, NULL, "ObjectReference.ReferringObjects" }, |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1637 | |
| 1638 | /* StringReference command set (10) */ |
| 1639 | { 10, 1, handleSR_Value, "StringReference.Value" }, |
| 1640 | |
| 1641 | /* ThreadReference command set (11) */ |
| 1642 | { 11, 1, handleTR_Name, "ThreadReference.Name" }, |
| 1643 | { 11, 2, handleTR_Suspend, "ThreadReference.Suspend" }, |
| 1644 | { 11, 3, handleTR_Resume, "ThreadReference.Resume" }, |
| 1645 | { 11, 4, handleTR_Status, "ThreadReference.Status" }, |
| 1646 | { 11, 5, handleTR_ThreadGroup, "ThreadReference.ThreadGroup" }, |
| 1647 | { 11, 6, handleTR_Frames, "ThreadReference.Frames" }, |
| 1648 | { 11, 7, handleTR_FrameCount, "ThreadReference.FrameCount" }, |
Elliott Hughes | a3c24aa | 2011-12-07 15:34:09 -0800 | [diff] [blame] | 1649 | { 11, 8, NULL, "ThreadReference.OwnedMonitors" }, |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1650 | { 11, 9, handleTR_CurrentContendedMonitor, "ThreadReference.CurrentContendedMonitor" }, |
Elliott Hughes | a3c24aa | 2011-12-07 15:34:09 -0800 | [diff] [blame] | 1651 | { 11, 10, NULL, "ThreadReference.Stop" }, |
| 1652 | { 11, 11, NULL,"ThreadReference.Interrupt" }, |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1653 | { 11, 12, handleTR_SuspendCount, "ThreadReference.SuspendCount" }, |
Elliott Hughes | a3c24aa | 2011-12-07 15:34:09 -0800 | [diff] [blame] | 1654 | { 11, 13, NULL, "ThreadReference.OwnedMonitorsStackDepthInfo" }, |
| 1655 | { 11, 14, NULL, "ThreadReference.ForceEarlyReturn" }, |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1656 | |
| 1657 | /* ThreadGroupReference command set (12) */ |
| 1658 | { 12, 1, handleTGR_Name, "ThreadGroupReference.Name" }, |
| 1659 | { 12, 2, handleTGR_Parent, "ThreadGroupReference.Parent" }, |
| 1660 | { 12, 3, handleTGR_Children, "ThreadGroupReference.Children" }, |
| 1661 | |
| 1662 | /* ArrayReference command set (13) */ |
| 1663 | { 13, 1, handleAR_Length, "ArrayReference.Length" }, |
| 1664 | { 13, 2, handleAR_GetValues, "ArrayReference.GetValues" }, |
| 1665 | { 13, 3, handleAR_SetValues, "ArrayReference.SetValues" }, |
| 1666 | |
| 1667 | /* ClassLoaderReference command set (14) */ |
| 1668 | { 14, 1, handleCLR_VisibleClasses, "ClassLoaderReference.VisibleClasses" }, |
| 1669 | |
| 1670 | /* EventRequest command set (15) */ |
| 1671 | { 15, 1, handleER_Set, "EventRequest.Set" }, |
| 1672 | { 15, 2, handleER_Clear, "EventRequest.Clear" }, |
Elliott Hughes | a3c24aa | 2011-12-07 15:34:09 -0800 | [diff] [blame] | 1673 | { 15, 3, NULL, "EventRequest.ClearAllBreakpoints" }, |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1674 | |
| 1675 | /* StackFrame command set (16) */ |
| 1676 | { 16, 1, handleSF_GetValues, "StackFrame.GetValues" }, |
| 1677 | { 16, 2, handleSF_SetValues, "StackFrame.SetValues" }, |
| 1678 | { 16, 3, handleSF_ThisObject, "StackFrame.ThisObject" }, |
Elliott Hughes | a3c24aa | 2011-12-07 15:34:09 -0800 | [diff] [blame] | 1679 | { 16, 4, NULL, "StackFrame.PopFrames" }, |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1680 | |
| 1681 | /* ClassObjectReference command set (17) */ |
| 1682 | { 17, 1, handleCOR_ReflectedType,"ClassObjectReference.ReflectedType" }, |
| 1683 | |
| 1684 | /* Event command set (64) */ |
Elliott Hughes | a3c24aa | 2011-12-07 15:34:09 -0800 | [diff] [blame] | 1685 | { 64, 100, NULL, "Event.Composite" }, // sent from VM to debugger, never received by VM |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1686 | |
| 1687 | { 199, 1, handleDDM_Chunk, "DDM.Chunk" }, |
| 1688 | }; |
| 1689 | |
Elliott Hughes | a3c24aa | 2011-12-07 15:34:09 -0800 | [diff] [blame] | 1690 | static const char* GetCommandName(size_t cmdSet, size_t cmd) { |
| 1691 | for (int i = 0; i < (int) arraysize(gHandlerMap); i++) { |
| 1692 | if (gHandlerMap[i].cmdSet == cmdSet && gHandlerMap[i].cmd == cmd) { |
| 1693 | return gHandlerMap[i].descr; |
| 1694 | } |
| 1695 | } |
| 1696 | return "?UNKNOWN?"; |
| 1697 | } |
| 1698 | |
| 1699 | static std::string DescribeCommand(const JdwpReqHeader* pHeader, int dataLen) { |
| 1700 | std::string result; |
| 1701 | result += "REQ: "; |
| 1702 | result += GetCommandName(pHeader->cmdSet, pHeader->cmd); |
| 1703 | result += StringPrintf(" (dataLen=%d id=0x%06x)", dataLen, pHeader->id); |
| 1704 | return result; |
| 1705 | } |
| 1706 | |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1707 | /* |
| 1708 | * Process a request from the debugger. |
| 1709 | * |
| 1710 | * On entry, the JDWP thread is in VMWAIT. |
| 1711 | */ |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 1712 | void JdwpState::ProcessRequest(const JdwpReqHeader* pHeader, const uint8_t* buf, int dataLen, ExpandBuf* pReply) { |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1713 | JdwpError result = ERR_NONE; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1714 | |
| 1715 | if (pHeader->cmdSet != kJDWPDdmCmdSet) { |
| 1716 | /* |
| 1717 | * Activity from a debugger, not merely ddms. Mark us as having an |
| 1718 | * active debugger session, and zero out the last-activity timestamp |
| 1719 | * so waitForDebugger() doesn't return if we stall for a bit here. |
| 1720 | */ |
Elliott Hughes | a215526 | 2011-11-16 16:26:58 -0800 | [diff] [blame] | 1721 | Dbg::GoActive(); |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 1722 | QuasiAtomicSwap64(0, &lastActivityWhen); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1723 | } |
| 1724 | |
| 1725 | /* |
| 1726 | * If a debugger event has fired in another thread, wait until the |
| 1727 | * initiating thread has suspended itself before processing messages |
| 1728 | * from the debugger. Otherwise we (the JDWP thread) could be told to |
| 1729 | * resume the thread before it has suspended. |
| 1730 | * |
| 1731 | * We call with an argument of zero to wait for the current event |
| 1732 | * thread to finish, and then clear the block. Depending on the thread |
| 1733 | * suspend policy, this may allow events in other threads to fire, |
| 1734 | * but those events have no bearing on what the debugger has sent us |
| 1735 | * in the current request. |
| 1736 | * |
| 1737 | * Note that we MUST clear the event token before waking the event |
| 1738 | * thread up, or risk waiting for the thread to suspend after we've |
| 1739 | * told it to resume. |
| 1740 | */ |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 1741 | SetWaitForEventThread(0); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1742 | |
| 1743 | /* |
| 1744 | * Tell the VM that we're running and shouldn't be interrupted by GC. |
| 1745 | * Do this after anything that can stall indefinitely. |
| 1746 | */ |
| 1747 | Dbg::ThreadRunning(); |
| 1748 | |
| 1749 | expandBufAddSpace(pReply, kJDWPHeaderLen); |
| 1750 | |
Elliott Hughes | a3c24aa | 2011-12-07 15:34:09 -0800 | [diff] [blame] | 1751 | size_t i; |
| 1752 | for (i = 0; i < arraysize(gHandlerMap); i++) { |
| 1753 | if (gHandlerMap[i].cmdSet == pHeader->cmdSet && gHandlerMap[i].cmd == pHeader->cmd && gHandlerMap[i].func != NULL) { |
Elliott Hughes | 4dd9b4d | 2011-12-12 18:29:24 -0800 | [diff] [blame] | 1754 | VLOG(jdwp) << DescribeCommand(pHeader, dataLen); |
Elliott Hughes | 376a7a0 | 2011-10-24 18:35:55 -0700 | [diff] [blame] | 1755 | result = (*gHandlerMap[i].func)(this, buf, dataLen, pReply); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1756 | break; |
| 1757 | } |
| 1758 | } |
| 1759 | if (i == arraysize(gHandlerMap)) { |
Elliott Hughes | a3c24aa | 2011-12-07 15:34:09 -0800 | [diff] [blame] | 1760 | LOG(ERROR) << DescribeCommand(pHeader, dataLen); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1761 | if (dataLen > 0) { |
| 1762 | HexDump(buf, dataLen); |
| 1763 | } |
Elliott Hughes | a3c24aa | 2011-12-07 15:34:09 -0800 | [diff] [blame] | 1764 | LOG(ERROR) << "command not implemented"; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1765 | result = ERR_NOT_IMPLEMENTED; |
| 1766 | } |
| 1767 | |
| 1768 | /* |
| 1769 | * Set up the reply header. |
| 1770 | * |
| 1771 | * If we encountered an error, only send the header back. |
| 1772 | */ |
| 1773 | uint8_t* replyBuf = expandBufGetBuffer(pReply); |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 1774 | Set4BE(replyBuf + 4, pHeader->id); |
| 1775 | Set1(replyBuf + 8, kJDWPFlagReply); |
| 1776 | Set2BE(replyBuf + 9, result); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1777 | if (result == ERR_NONE) { |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 1778 | Set4BE(replyBuf + 0, expandBufGetLength(pReply)); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1779 | } else { |
Elliott Hughes | f7c3b66 | 2011-10-27 12:04:56 -0700 | [diff] [blame] | 1780 | Set4BE(replyBuf + 0, kJDWPHeaderLen); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1781 | } |
| 1782 | |
Elliott Hughes | a3c24aa | 2011-12-07 15:34:09 -0800 | [diff] [blame] | 1783 | size_t respLen = expandBufGetLength(pReply) - kJDWPHeaderLen; |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1784 | if (false) { |
| 1785 | LOG(INFO) << "reply: dataLen=" << respLen << " err=" << result << (result != ERR_NONE ? " **FAILED**" : ""); |
| 1786 | if (respLen > 0) { |
| 1787 | HexDump(expandBufGetBuffer(pReply) + kJDWPHeaderLen, respLen); |
| 1788 | } |
| 1789 | } |
| 1790 | |
| 1791 | /* |
| 1792 | * Update last-activity timestamp. We really only need this during |
| 1793 | * the initial setup. Only update if this is a non-DDMS packet. |
| 1794 | */ |
| 1795 | if (pHeader->cmdSet != kJDWPDdmCmdSet) { |
Elliott Hughes | 7162ad9 | 2011-10-27 14:08:42 -0700 | [diff] [blame] | 1796 | QuasiAtomicSwap64(MilliTime(), &lastActivityWhen); |
Elliott Hughes | 872d4ec | 2011-10-21 17:07:15 -0700 | [diff] [blame] | 1797 | } |
| 1798 | |
| 1799 | /* tell the VM that GC is okay again */ |
| 1800 | Dbg::ThreadWaiting(); |
| 1801 | } |
| 1802 | |
| 1803 | } // namespace JDWP |
| 1804 | |
| 1805 | } // namespace art |