Bring across the JDWP implementation.
This compiles and links, but does nothing until we fill out the 100 or so
unimplemented methods in "debugger.cc". Note that I also need to add the
extra command-line handling for the JDWP agent stuff, and add calls from
the runtime to the various "something interesting is going on" hooks.
Change-Id: I477cf3caf9e248c384ce1d739cbfadb60e2008bc
diff --git a/src/jdwp/jdwp_bits.h b/src/jdwp/jdwp_bits.h
new file mode 100644
index 0000000..b0041f1
--- /dev/null
+++ b/src/jdwp/jdwp_bits.h
@@ -0,0 +1,123 @@
+/*
+ * Copyright (C) 2008 The Android Open Source Project
+ *
+ * Licensed under the Apache License, Version 2.0 (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ *
+ * http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+#ifndef ART_JDWP_BITS_H_
+#define ART_JDWP_BITS_H_
+
+#include <stddef.h>
+#include <stdint.h>
+#include <stdlib.h>
+#include <string.h>
+
+namespace art {
+
+namespace JDWP {
+
+static inline uint32_t get4BE(unsigned char const* pSrc) {
+ return (pSrc[0] << 24) | (pSrc[1] << 16) | (pSrc[2] << 8) | pSrc[3];
+}
+
+static inline uint8_t read1(unsigned const char** ppSrc) {
+ return *(*ppSrc)++;
+}
+
+static inline uint16_t read2BE(unsigned char const** ppSrc) {
+ const unsigned char* pSrc = *ppSrc;
+ *ppSrc = pSrc + 2;
+ return pSrc[0] << 8 | pSrc[1];
+}
+
+static inline uint32_t read4BE(unsigned char const** ppSrc) {
+ const unsigned char* pSrc = *ppSrc;
+ uint32_t result = pSrc[0] << 24;
+ result |= pSrc[1] << 16;
+ result |= pSrc[2] << 8;
+ result |= pSrc[3];
+ *ppSrc = pSrc + 4;
+ return result;
+}
+
+static inline uint64_t read8BE(unsigned char const** ppSrc) {
+ const unsigned char* pSrc = *ppSrc;
+ uint32_t high = pSrc[0];
+ high = (high << 8) | pSrc[1];
+ high = (high << 8) | pSrc[2];
+ high = (high << 8) | pSrc[3];
+ uint32_t low = pSrc[4];
+ low = (low << 8) | pSrc[5];
+ low = (low << 8) | pSrc[6];
+ low = (low << 8) | pSrc[7];
+ *ppSrc = pSrc + 8;
+ return ((uint64_t) high << 32) | (uint64_t) low;
+}
+
+/*
+ * Read a UTF-8 string into newly-allocated storage, and null-terminate it.
+ *
+ * Returns the string and its length. (The latter is probably unnecessary
+ * for the way we're using UTF8.)
+ */
+static inline char* readNewUtf8String(unsigned char const** ppSrc, size_t* pLength) {
+ uint32_t length = read4BE(ppSrc);
+ char* buf = (char*) malloc(length+1);
+ memcpy(buf, *ppSrc, length);
+ buf[length] = '\0';
+ (*ppSrc) += length;
+ *pLength = length;
+ return buf;
+}
+
+static inline void set1(uint8_t* buf, uint8_t val) {
+ *buf = (uint8_t)(val);
+}
+
+static inline void set2BE(uint8_t* buf, uint16_t val) {
+ *buf++ = (uint8_t)(val >> 8);
+ *buf = (uint8_t)(val);
+}
+
+static inline void set4BE(uint8_t* buf, uint32_t val) {
+ *buf++ = (uint8_t)(val >> 24);
+ *buf++ = (uint8_t)(val >> 16);
+ *buf++ = (uint8_t)(val >> 8);
+ *buf = (uint8_t)(val);
+}
+
+static inline void set8BE(uint8_t* buf, uint64_t val) {
+ *buf++ = (uint8_t)(val >> 56);
+ *buf++ = (uint8_t)(val >> 48);
+ *buf++ = (uint8_t)(val >> 40);
+ *buf++ = (uint8_t)(val >> 32);
+ *buf++ = (uint8_t)(val >> 24);
+ *buf++ = (uint8_t)(val >> 16);
+ *buf++ = (uint8_t)(val >> 8);
+ *buf = (uint8_t)(val);
+}
+
+/*
+ * Stuff a UTF-8 string into the buffer.
+ */
+static inline void setUtf8String(uint8_t* buf, const uint8_t* str) {
+ uint32_t strLen = strlen((const char*)str);
+ set4BE(buf, strLen);
+ memcpy(buf + sizeof(uint32_t), str, strLen);
+}
+
+} // namespace JDWP
+
+} // namespace art
+
+#endif // ART_JDWP_BITS_H_