src: Add support for big endian systems (#120)

Read values correctly converting for endianess as required.
Generally this just means using LLDB's ReadUnsignedFromMemory
function but there are a few places where we optimise
reading values or where we only want one byte from a larger
field where we need to account for endianess ourselves.

PR-URL: #120
Reviewed-By: Ben Noordhuis <info@bnoordhuis.nl>
Reviewed-By: Fedor Indutny <fedor@indutny.com>

Author: hhellyer

src/llnode.cc

@@ -200,7 +200,7 @@ bool PrintCmd::DoExecute(SBDebugger d, char** cmd,
   v8::Error err;
   std::string res = v8_value.Inspect(&inspect_options, err);
   if (err.Fail()) {
-    result.SetError("Failed to evaluate expression");
+    result.SetError(err.GetMessage());
     return false;
   }
 

src/llscan.cc

@@ -17,6 +17,7 @@
 
 namespace llnode {
 
+using lldb::ByteOrder;
 using lldb::SBCommandReturnObject;
 using lldb::SBDebugger;
 using lldb::SBError;
@@ -1204,11 +1205,19 @@ bool LLScan::ScanHeapForObjects(lldb::SBTarget target,
   return true;
 }
 
+inline static ByteOrder GetHostByteOrder() {
+  union {
+    uint8_t a[2];
+    uint16_t b;
+  } u = {{0, 1}};
+  return u.b == 1 ? ByteOrder::eByteOrderBig : ByteOrder::eByteOrderLittle;
+}
 
 void LLScan::ScanMemoryRanges(FindJSObjectsVisitor& v) {
   bool done = false;
 
   const uint64_t addr_size = process_.GetAddressByteSize();
+  bool swap_bytes = process_.GetByteOrder() != GetHostByteOrder();
 
   // Pages are usually around 1mb, so this should more than enough
   const uint64_t block_size = 1024 * 1024 * addr_size;
@@ -1258,12 +1267,19 @@ void LLScan::ScanMemoryRanges(FindJSObjectsVisitor& v) {
       for (size_t j = 0; j + addr_size <= loaded;) {
         uint64_t value;
 
-        if (addr_size == 4)
+        if (addr_size == 4) {
           value = *reinterpret_cast<uint32_t*>(&block[j]);
-        else if (addr_size == 8)
+          if (swap_bytes) {
+            value = __builtin_bswap32(value);
+          }
+        } else if (addr_size == 8) {
           value = *reinterpret_cast<uint64_t*>(&block[j]);
-        else
+          if (swap_bytes) {
+            value = __builtin_bswap64(value);
+          }
+        } else {
           break;
+        }
 
         increment = v.Visit(j + searchAddress, value);
         if (increment == 0) break;

src/llv8-constants.cc

@@ -68,18 +68,15 @@ static int64_t LookupConstant(SBTarget target, const char* name, int64_t def,
 
   // NOTE: size could be bigger for at the end symbols
   if (size >= 8) {
-    process.ReadMemory(addr, &res, 8, sberr);
+    res = process.ReadUnsignedFromMemory(addr, 8, sberr);
   } else if (size == 4) {
-    int32_t tmp;
-    process.ReadMemory(addr, &tmp, size, sberr);
+    int32_t tmp = process.ReadUnsignedFromMemory(addr, size, sberr);
     res = static_cast<int64_t>(tmp);
   } else if (size == 2) {
-    int16_t tmp;
-    process.ReadMemory(addr, &tmp, size, sberr);
+    int16_t tmp = process.ReadUnsignedFromMemory(addr, size, sberr);
     res = static_cast<int64_t>(tmp);
   } else if (size == 1) {
-    int8_t tmp;
-    process.ReadMemory(addr, &tmp, size, sberr);
+    int8_t tmp = process.ReadUnsignedFromMemory(addr, size, sberr);
     res = static_cast<int64_t>(tmp);
   } else {
     err = Error::Failure("Unexpected symbol size");

src/llv8-inl.h

@@ -81,8 +81,10 @@ inline int64_t HeapObject::GetType(Error& err) {
 
 
 inline int64_t Map::GetType(Error& err) {
-  int64_t type = LoadField(v8()->map()->kInstanceAttrsOffset, err);
+  int64_t type =
+      v8()->LoadUnsigned(LeaField(v8()->map()->kInstanceAttrsOffset), 2, err);
   if (err.Fail()) return -1;
+
   return type & 0xff;
 }
 
@@ -150,15 +152,16 @@ ACCESSOR(Map, InstanceDescriptors, map()->kInstanceDescriptorsOffset,
          HeapObject)
 
 inline int64_t Map::BitField3(Error& err) {
-  return LoadField(v8()->map()->kBitField3Offset, err) & 0xffffffff;
+  return v8()->LoadUnsigned(LeaField(v8()->map()->kBitField3Offset), 4, err);
 }
 
 inline int64_t Map::InObjectProperties(Error& err) {
   return LoadField(v8()->map()->kInObjectPropertiesOffset, err) & 0xff;
 }
 
 inline int64_t Map::InstanceSize(Error& err) {
-  return (LoadField(v8()->map()->kInstanceSizeOffset, err) & 0xff) *
+  return v8()->LoadUnsigned(LeaField(v8()->map()->kInstanceSizeOffset), 1,
+                            err) *
          v8()->common()->kPointerSize;
 }
 

src/llv8.cc

@@ -73,6 +73,22 @@ int64_t LLV8::LoadPtr(int64_t addr, Error& err) {
 }
 
 
+int64_t LLV8::LoadUnsigned(int64_t addr, uint32_t byte_size, Error& err) {
+  SBError sberr;
+  int64_t value = process_.ReadUnsignedFromMemory(static_cast<addr_t>(addr),
+                                                  byte_size, sberr);
+
+  if (sberr.Fail()) {
+    // TODO(indutny): add more information
+    err = Error::Failure("Failed to load V8 value");
+    return -1;
+  }
+
+  err = Error::Ok();
+  return value;
+}
+
+
 double LLV8::LoadDouble(int64_t addr, Error& err) {
   SBError sberr;
   int64_t value = process_.ReadUnsignedFromMemory(static_cast<addr_t>(addr),

src/llv8.h

@@ -462,6 +462,7 @@ class LLV8 {
 
   int64_t LoadConstant(const char* name);
   int64_t LoadPtr(int64_t addr, Error& err);
+  int64_t LoadUnsigned(int64_t addr, uint32_t byte_size, Error& err);
   double LoadDouble(int64_t addr, Error& err);
   std::string LoadBytes(int64_t length, int64_t addr, Error& err);
   std::string LoadString(int64_t addr, int64_t length, Error& err);