src: fix backtrace with v8 6.4 (#168)

This is the minimum patch to make llnode display stack traces
produced by v8 6.4.

PR-URL: #168
Reviewed-By: Ben Noordhuis <[email protected]>
Reviewed-By: Colin Ihrig <[email protected]>
Reviewed-By: Fedor Indutny <[email protected]>

Author: joyeecheung

src/llv8-constants.cc

@@ -93,35 +93,39 @@ int64_t Module::LoadRawConstant(const char* name, int64_t def) {
   Error err;
   int64_t v = LookupConstant(target_, name, def, err);
   if (err.Fail()) {
-    Error::PrintInDebugMode("Failed to load raw constant %s", name);
+    Error::PrintInDebugMode(
+        "Failed to load raw constant %s, default to %" PRId64, name, def);
   }
 
   return v;
 }
 
+int64_t Module::LoadConstant(const char* name, Error& err, int64_t def) {
+  int64_t v =
+      LookupConstant(target_, (kConstantPrefix + name).c_str(), def, err);
+  return v;
+}
 
 int64_t Module::LoadConstant(const char* name, int64_t def) {
   Error err;
-  int64_t v =
-      LookupConstant(target_, (kConstantPrefix + name).c_str(), def, err);
+  int64_t v = LoadConstant(name, err, def);
   if (err.Fail()) {
-    Error::PrintInDebugMode("Failed to load constant %s", name);
+    Error::PrintInDebugMode("Failed to load constant %s, default to %" PRId64,
+                            name, def);
   }
 
   return v;
 }
 
-
 int64_t Module::LoadConstant(const char* name, const char* fallback,
                              int64_t def) {
   Error err;
-  int64_t v =
-      LookupConstant(target_, (kConstantPrefix + name).c_str(), def, err);
-  if (err.Fail())
-    v = LookupConstant(target_, (kConstantPrefix + fallback).c_str(), def, err);
+  int64_t v = LoadConstant(name, err, def);
+  if (err.Fail()) v = LoadConstant(fallback, err, def);
   if (err.Fail()) {
-    Error::PrintInDebugMode("Failed to load constant %s, fallback %s", name,
-                            fallback);
+    Error::PrintInDebugMode(
+        "Failed to load constant %s, fallback %s, default to %" PRId64, name,
+        fallback, def);
   }
 
   return v;
@@ -179,7 +183,16 @@ void HeapObject::Load() {
 
 
 void Map::Load() {
-  kInstanceAttrsOffset = LoadConstant("class_Map__instance_attributes__int");
+  Error err;
+  kInstanceAttrsOffset =
+      LoadConstant("class_Map__instance_attributes__int", err);
+  if (err.Fail()) {
+    kInstanceAttrsOffset = LoadConstant("class_Map__instance_type__uint16_t");
+    kMapTypeMask = 0xffff;
+  } else {
+    kMapTypeMask = 0xff;
+  }
+
   kMaybeConstructorOffset =
       LoadConstant("class_Map__constructor_or_backpointer__Object",
                    "class_Map__constructor__Object");

src/llv8-constants.h

@@ -5,11 +5,15 @@
 
 namespace llnode {
 namespace v8 {
+
+class Error;
+
 namespace constants {
 
 // Forward declarations
 class Common;
 
+
 class Module {
  public:
   Module() : loaded_(false) {}
@@ -20,6 +24,7 @@ class Module {
 
  protected:
   int64_t LoadRawConstant(const char* name, int64_t def = -1);
+  int64_t LoadConstant(const char* name, Error& err, int64_t def = -1);
   int64_t LoadConstant(const char* name, int64_t def = -1);
   int64_t LoadConstant(const char* name, const char* fallback,
                        int64_t def = -1);
@@ -83,6 +88,7 @@ class Map : public Module {
  public:
   MODULE_DEFAULT_METHODS(Map);
 
+  int64_t kMapTypeMask;
   int64_t kInstanceAttrsOffset;
   int64_t kMaybeConstructorOffset;
   int64_t kInstanceDescriptorsOffset;

src/llv8-inl.h

@@ -89,7 +89,7 @@ inline int64_t Map::GetType(Error& err) {
       v8()->LoadUnsigned(LeaField(v8()->map()->kInstanceAttrsOffset), 2, err);
   if (err.Fail()) return -1;
 
-  return type & 0xff;
+  return type & v8()->map()->kMapTypeMask;
 }