Make instruction counter in simulators 64-bit (issue 22302).

runtime/vm/flags.cc

 // Copyright (c) 2012, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #include "vm/flags.h"
 
 #include "platform/assert.h"
 #include "vm/json_stream.h"
 #include "vm/os.h"
 
 namespace dart {
 
 DEFINE_FLAG(bool, print_flags, false, "Print flags as they are being parsed.");
 DEFINE_FLAG(bool, ignore_unrecognized_flags, false,
     "Ignore unrecognized flags.");
 
 bool Flags::initialized_ = false;
 
 // List of registered flags.
 Flag** Flags::flags_ = NULL;
 intptr_t Flags::capacity_ = 0;
 intptr_t Flags::num_flags_ = 0;
 
 class Flag {
  public:
   enum FlagType {
     kBoolean,
     kInteger,
+    kUint64,
     kString,
     kFunc,
     kNumFlagTypes
   };
 
   Flag(const char* name, const char* comment, void* addr, FlagType type)
       : name_(name), comment_(comment), addr_(addr), type_(type) {
   }
   Flag(const char* name, const char* comment, FlagHandler handler)
       : name_(name), comment_(comment), handler_(handler), type_(kFunc) {
   }
 
   void Print() {
     if (IsUnrecognized()) {
       OS::Print("%s: unrecognized\n", name_);
       return;
     }
     switch (type_) {
       case kBoolean: {
         OS::Print("%s: %s (%s)\n",
             name_, *this->bool_ptr_ ? "true" : "false", comment_);
         break;
       }
       case kInteger: {
         OS::Print("%s: %d (%s)\n", name_, *this->int_ptr_, comment_);
         break;
       }
+      case kUint64: {
+        OS::Print("%s: %"Pu64" (%s)\n", name_, *this->uint64_ptr_, comment_);
+        break;
+      }
       case kString: {
         if (*this->charp_ptr_ != NULL) {
           OS::Print("%s: '%s' (%s)\n", name_, *this->charp_ptr_, comment_);
         } else {
           OS::Print("%s: (null) (%s)\n", name_, comment_);
         }
         break;
       }
       case kFunc: {
         OS::Print("%s: (%s)\n", name_, comment_);
         break;
       }
       default:
         UNREACHABLE();
         break;
     }
   }
 
   bool IsUnrecognized() const {
     return (type_ == kBoolean) && (bool_ptr_ == NULL);
   }
 
   const char* name_;
   const char* comment_;
   union {
     void* addr_;
     bool* bool_ptr_;
     int* int_ptr_;
+    uint64_t* uint64_ptr_;
     charp* charp_ptr_;
     FlagHandler handler_;
   };
   FlagType type_;
   bool changed_;
 };
 
 
 Flag* Flags::Lookup(const char* name) {
   for (intptr_t i = 0; i < num_flags_; i++) {
@@ skipping 57 matching lines @@
                         const char* comment) {
   ASSERT(Lookup(name) == NULL);
 
   Flag* flag = new Flag(name, comment, addr, Flag::kInteger);
   AddFlag(flag);
 
   return default_value;
 }
 
 
+uint64_t Flags::Register_uint64_t(uint64_t* addr,
+                                  const char* name,
+                                  uint64_t default_value,
+                                  const char* comment) {
+  ASSERT(Lookup(name) == NULL);
+
+  Flag* flag = new Flag(name, comment, addr, Flag::kUint64);
+  AddFlag(flag);
+
+  return default_value;
+}
+
+
 const char* Flags::Register_charp(charp* addr,
                                   const char* name,
                                   const char* default_value,
                                   const char* comment) {
   ASSERT(Lookup(name) == NULL);
   Flag* flag = new Flag(name, comment, addr, Flag::kString);
   AddFlag(flag);
   return default_value;
 }
 
@@ skipping 43 matching lines @@
         base = 16;
       }
       int val = strtol(argument, &endptr, base);
       if (endptr == argument + len) {
         *flag->int_ptr_ = val;
       } else {
         return false;
       }
       break;
     }
+    case Flag::kUint64: {
+      char* endptr = NULL;
+      const intptr_t len = strlen(argument);
+      int base = 10;
+      if ((len > 2) && (argument[0] == '0') && (argument[1] == 'x')) {
+        base = 16;
+      }
+      int64_t val = strtoll(argument, &endptr, base);
+      if (endptr == argument + len) {
+        *flag->uint64_ptr_ = static_cast<uint64_t>(val);
+      } else {
+        return false;
+      }
+      break;
+    }
     case Flag::kFunc: {
       if (strcmp(argument, "true") == 0) {
         (flag->handler_)(true);
       } else if (strcmp(argument, "false") == 0) {
         (flag->handler_)(false);
       } else {
         return false;
       }
       break;
     }
@@ skipping 164 matching lines @@
       jsflag.AddProperty("flagType", "bool");
       jsflag.AddProperty("valueAsString",
                          (*flag->bool_ptr_ ? "true" : "false"));
       break;
     }
     case Flag::kInteger: {
       jsflag.AddProperty("flagType", "int");
       jsflag.AddPropertyF("valueAsString", "%d", *flag->int_ptr_);
       break;
     }
+    case Flag::kUint64: {
+      jsflag.AddProperty("flagType", "uint64_t");
+      jsflag.AddPropertyF("valueAsString", "%"Pu64, *flag->uint64_ptr_);
+      break;
+    }
     case Flag::kString: {
       jsflag.AddProperty("flagType", "string");
       if (flag->charp_ptr_ != NULL) {
         jsflag.AddPropertyF("valueAsString", "%s", *flag->charp_ptr_);
       } else {
         // valueAsString missing means NULL.
       }
       break;
     }
     default:
@@ skipping 22 matching lines @@
     for (intptr_t i = 0; i < num_flags_; ++i) {
       Flag* flag = flags_[i];
       if (flag->changed_) {
         PrintFlagToJSONArray(&jsarr, flag);
       }
     }
   }
 }
 
 }  // namespace dart