A follow-up to r5211: fix a couple of issues detected on Windows.

src/profile-generator.h

 // Copyright 2010 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 420 matching lines @@
     kContextVariable = v8::HeapGraphEdge::kContextVariable,
     kElement = v8::HeapGraphEdge::kElement,
     kProperty = v8::HeapGraphEdge::kProperty,
     kInternal = v8::HeapGraphEdge::kInternal
   };
 
   HeapGraphEdge() { }
   void Init(int child_index, Type type, const char* name, HeapEntry* to);
   void Init(int child_index, int index, HeapEntry* to);
 
-  Type type() { return type_; }
+  Type type() { return static_cast<Type>(type_); }
   int index() {
     ASSERT(type_ == kElement);
     return index_;
   }
   const char* name() {
     ASSERT(type_ == kContextVariable
            || type_ == kProperty
            || type_ == kInternal);
     return name_;
   }
   HeapEntry* to() { return to_; }
 
   HeapEntry* From();
 
  private:
   int child_index_ : 30;
-  Type type_ : 2;
+  unsigned type_ : 2;
   union {
     int index_;
     const char* name_;
   };
   HeapEntry* to_;
 
   DISALLOW_COPY_AND_ASSIGN(HeapGraphEdge);
 };
 
 
@@ skipping 35 matching lines @@
   void Init(HeapSnapshot* snapshot, int children_count, int retainers_count);
   void Init(HeapSnapshot* snapshot,
             Type type,
             const char* name,
             uint64_t id,
             int self_size,
             int children_count,
             int retainers_count);
 
   HeapSnapshot* snapshot() { return snapshot_; }
-  Type type() { return type_; }
+  Type type() { return static_cast<Type>(type_); }
   const char* name() { return name_; }
   uint64_t id() { return id_; }
   int self_size() { return self_size_; }
 
   Vector<HeapGraphEdge> children() {
     return Vector<HeapGraphEdge>(children_arr(), children_count_); }
   Vector<HeapGraphEdge*> retainers() {
     return Vector<HeapGraphEdge*>(retainers_arr(), retainers_count_); }
   List<HeapGraphPath*>* GetRetainingPaths();
 
@@ skipping 34 matching lines @@
 
  private:
   HeapGraphEdge* children_arr() {
     return reinterpret_cast<HeapGraphEdge*>(this + 1);
   }
   HeapGraphEdge** retainers_arr() {
     return reinterpret_cast<HeapGraphEdge**>(children_arr() + children_count_);
   }
   const char* TypeAsString();
 
-  HeapSnapshot* snapshot_;
   unsigned painted_: 2;
-  Type type_: 3;
+  unsigned type_: 3;
   // The calculated data is stored in HeapSnapshot in HeapEntryCalculatedData
   // entries. See AddCalculatedData and GetCalculatedData.
   int calculated_data_index_: 27;
-  const char* name_;
-  uint64_t id_;
   int self_size_;
   int children_count_;
   int retainers_count_;
+  HeapSnapshot* snapshot_;
+  const char* name_;
+  uint64_t id_;

[Søren Thygesen Gjesse, 2010/08/09 14:44:10]

Could we have a STATIC_ASSERT on sizeof(HeapEntry)? Or maybe a simple cctest?

[mnaganov (inactive), 2010/08/09 15:18:37]

OK, will do this as a separate commit.

 
   static const unsigned kUnpainted = 0;
   static const unsigned kPainted = 1;
   static const unsigned kPaintedReachableFromOthers = 2;
   static const int kNoCalculatedData = -1;
 
   DISALLOW_COPY_AND_ASSIGN(HeapEntry);
 };
 
 
@@ skipping 356 matching lines @@
   friend class IndexedReferencesExtractor;
 
   DISALLOW_COPY_AND_ASSIGN(HeapSnapshotGenerator);
 };
 
 } }  // namespace v8::internal
 
 #endif  // ENABLE_LOGGING_AND_PROFILING
 
 #endif  // V8_PROFILE_GENERATOR_H_