fixup! src: use new SystemPointerSize constant

Author: mmarchini

src/constants.cc

@@ -23,22 +23,19 @@ T ReadSymbolFromTarget(SBTarget& target, SBAddress& start, const char* name,
   return res;
 }
 
-std::pair<int64_t, bool> Constants::LookupConstant(SBTarget target,
-                                                   const char* name,
-                                                   int64_t def) {
-  int64_t res = 0;
-  res = def;
+Constant<int64_t> Constants::LookupConstant(SBTarget target, const char* name) {
+  int64_t res;
 
   SBSymbolContextList context_list = target.FindSymbols(name);
 
   if (!context_list.IsValid() || context_list.GetSize() == 0) {
-    return {res, false};
+    return Constant<int64_t>();
   }
 
   SBSymbolContext context = context_list.GetContextAtIndex(0);
   SBSymbol symbol = context.GetSymbol();
   if (!symbol.IsValid()) {
-    return {res, false};
+    return Constant<int64_t>();
   }
 
   SBAddress start = symbol.GetStartAddress();
@@ -59,10 +56,12 @@ std::pair<int64_t, bool> Constants::LookupConstant(SBTarget target,
     int8_t tmp = ReadSymbolFromTarget<int8_t>(target, start, name, sberr);
     res = static_cast<int64_t>(tmp);
   } else {
-    return {res, false};
+    return Constant<int64_t>();
   }
 
-  return {res, !sberr.Fail()};
+  if (sberr.Fail()) return Constant<int64_t>();
+
+  return Constant<int64_t>(res, name);
 }
 
 void Constants::Assign(SBTarget target) {
@@ -72,46 +71,49 @@ void Constants::Assign(SBTarget target) {
 
 
 int64_t Constants::LoadRawConstant(const char* name, int64_t def) {
-  auto v = Constants::LookupConstant(target_, name, def);
-  if (!v.second) {
+  auto constant = Constants::LookupConstant(target_, name);
+  if (!constant.Check()) {
     PRINT_DEBUG("Failed to load raw constant %s, default to %" PRId64, name,
                 def);
+    return def;
   }
 
-  return v.first;
+  return *constant;
 }
 
 int64_t Constants::LoadConstant(const char* name, int64_t def) {
-  auto v = Constants::LookupConstant(target_,
-                                     (constant_prefix() + name).c_str(), def);
-  if (!v.second) {
-    PRINT_DEBUG("Failed to load constant %s, default to %" PRId64, name, def);
+  auto constant =
+      Constants::LookupConstant(target_, (constant_prefix() + name).c_str());
+  if (!constant.Check()) {
+    PRINT_DEBUG("Failed to load constant %s, default to %" PRId64, name);
+    return def;
   }
 
-  return v.first;
+  return *constant;
 }
 
 int64_t Constants::LoadConstant(const char* name, const char* fallback,
                                 int64_t def) {
-  auto v = Constants::LookupConstant(target_,
-                                     (constant_prefix() + name).c_str(), def);
-  if (!v.second)
-    v = Constants::LookupConstant(target_,
-                                  (constant_prefix() + fallback).c_str(), def);
-  if (!v.second) {
+  auto constant =
+      Constants::LookupConstant(target_, (constant_prefix() + name).c_str());
+  if (!constant.Check())
+    constant = Constants::LookupConstant(
+        target_, (constant_prefix() + fallback).c_str());
+  if (!constant.Check()) {
     PRINT_DEBUG("Failed to load constant %s, fallback %s, default to %" PRId64,
                 name, fallback, def);
+    return def;
   }
 
-  return v.first;
+  return *constant;
 }
 
 Constant<int64_t> Constants::LoadConstant(
     std::initializer_list<const char*> names) {
   for (std::string name : names) {
-    auto v = Constants::LookupConstant(target_,
-                                       (constant_prefix() + name).c_str(), -1);
-    if (v.second) return Constant<int64_t>(v.first, name);
+    auto constant =
+        Constants::LookupConstant(target_, (constant_prefix() + name).c_str());
+    if (constant.Check()) return constant;
   }
 
   if (Error::IsDebugMode()) {
@@ -128,9 +130,9 @@ Constant<int64_t> Constants::LoadConstant(
 Constant<int64_t> Constants::LoadOptionalConstant(
     std::initializer_list<const char*> names, int def) {
   for (std::string name : names) {
-    auto v = Constants::LookupConstant(target_,
-                                       (constant_prefix() + name).c_str(), -1);
-    if (v.second) return Constant<int64_t>(v.first, name);
+    auto constant =
+        Constants::LookupConstant(target_, (constant_prefix() + name).c_str());
+    if (constant.Check()) return constant;
   }
 
   return Constant<int64_t>(def);

src/constants.h

@@ -10,18 +10,36 @@ using lldb::SBTarget;
 
 namespace llnode {
 
+enum ConstantStatus { kInvalid, kValid, kLoaded };
+
+// Class representing a constant which is used to interpret memory data. Most
+// constants represent offset of fields on an object, bit-masks or "tags" which
+// are used to identify types, but there are some constants with different
+// meanings as well.
+//
+// By default, constants are loaded from the binary debug symbols, and usually
+// those debug symbols are generated by V8's gen-postmortem-metadata.py or by
+// Node.js' node-postmortem-metadata.cc. Some constants can also come from C++
+// generated debug symbols.
+//
+// When a constant is successfully loaded, Check() and Loaded() will return
+// true, which means we can safely use this constant and make assumptions based
+// on its existence. In some cases, it's safe to assume defaults for a given
+// constant. If that's the case, the constant will return false on Loaded() but
+// true on Check(). A constant returning false for both Check() and Loaded() is
+// not safe to use.
+//
+// Use the dereference operator (*constant) to access a constant value.
 template <typename T>
 class Constant {
  public:
-  Constant() : value_(-1), valid_(false), loaded_(false) {}
-  explicit Constant(T value)
-      : value_(value), valid_(true), loaded_(false), name_("") {}
-  Constant(T value, std::string name)
-      : value_(value), valid_(true), loaded_(true), name_(name) {}
-
-  inline bool Check() { return valid_; }
+  Constant() : value_(-1), status_(kInvalid) {}
+  inline bool Check() {
+    return (status_ == ConstantStatus::kValid ||
+            status_ == ConstantStatus::kLoaded);
+  }
 
-  inline bool Loaded() { return loaded_; }
+  inline bool Loaded() { return status_ == kLoaded; }
 
   T operator*() {
     // TODO(mmarchini): Check()
@@ -31,9 +49,14 @@ class Constant {
   inline std::string name() { return name_; }
 
  protected:
+  friend class Constants;
+  explicit Constant(T value) : value_(value), status_(kValid), name_("") {}
+  Constant(T value, std::string name)
+      : value_(value), status_(kLoaded), name_(name) {}
+
+ private:
   T value_;
-  bool valid_;
-  bool loaded_;
+  ConstantStatus status_;
   std::string name_;
 };
 
@@ -55,8 +78,7 @@ class Constants {
 
   inline virtual std::string constant_prefix() { return ""; };
 
-  static std::pair<int64_t, bool> LookupConstant(SBTarget target,
-                                                 const char* name, int64_t def);
+  static Constant<int64_t> LookupConstant(SBTarget target, const char* name);
 
  protected:
   int64_t LoadRawConstant(const char* name, int64_t def = -1);