Replace C++ bitfields with our own BitFields

src/hydrogen.h

Index: src/hydrogen.h
diff --git a/src/hydrogen.h b/src/hydrogen.h
index 0ff5a45e5911c73eff802404dc12bd33a84d1889..cf01ed0a542394445bb7c8de3b3a02d3772f0bad 100644
--- a/src/hydrogen.h
+++ b/src/hydrogen.h
@@ -76,8 +76,10 @@ class HBasicBlock FINAL : public ZoneObject {
   void set_last_instruction_index(int index) {
     last_instruction_index_ = index;
   }
-  bool is_osr_entry() { return is_osr_entry_; }
-  void set_osr_entry() { is_osr_entry_ = true; }
+  bool is_osr_entry() const { return IsOsrEntryField::decode(bit_field_); }
+  void set_osr_entry() {
+    bit_field_ = IsOsrEntryField::update(bit_field_, true);
+  }
 
   void AttachLoopInformation();
   void DetachLoopInformation();
@@ -130,9 +132,11 @@ class HBasicBlock FINAL : public ZoneObject {
   // LeaveInlined
   // Simulate (caller's environment)
   // Goto (target block)
-  bool IsInlineReturnTarget() const { return is_inline_return_target_; }
+  bool IsInlineReturnTarget() const {
+    return IsInlineReturnTargetField::decode(bit_field_);
+  }
   void MarkAsInlineReturnTarget(HBasicBlock* inlined_entry_block) {
-    is_inline_return_target_ = true;
+    bit_field_ = IsInlineReturnTargetField::update(bit_field_, true);
     inlined_entry_block_ = inlined_entry_block;
   }
   HBasicBlock* inlined_entry_block() { return inlined_entry_block_; }
@@ -142,18 +146,20 @@ class HBasicBlock FINAL : public ZoneObject {
   }
 
   void MarkUnreachable();
-  bool IsUnreachable() const { return !is_reachable_; }
-  bool IsReachable() const { return is_reachable_; }
+  bool IsUnreachable() const { return !IsReachable(); }
+  bool IsReachable() const { return IsReachableField::decode(bit_field_); }
 
   bool IsLoopSuccessorDominator() const {
-    return dominates_loop_successors_;
+    return DominatesLoopSuccessorsField::decode(bit_field_);
   }
   void MarkAsLoopSuccessorDominator() {
-    dominates_loop_successors_ = true;
+    bit_field_ = DominatesLoopSuccessorsField::update(bit_field_, true);
   }
 
-  bool IsOrdered() const { return is_ordered_; }
-  void MarkAsOrdered() { is_ordered_ = true; }
+  bool IsOrdered() const { return IsOrderedField::decode(bit_field_); }
+  void MarkAsOrdered() {
+    bit_field_ = IsOrderedField::update(bit_field_, true);
+  }
 
   void MarkSuccEdgeUnreachable(int succ);
 
@@ -187,6 +193,12 @@ class HBasicBlock FINAL : public ZoneObject {
   void RegisterPredecessor(HBasicBlock* pred);
   void AddDominatedBlock(HBasicBlock* block);
 
+  class IsInlineReturnTargetField : public BitField<bool, 0, 1> {};
+  class IsReachableField : public BitField<bool, 1, 1> {};
+  class DominatesLoopSuccessorsField : public BitField<bool, 2, 1> {};
+  class IsOsrEntryField : public BitField<bool, 3, 1> {};
+  class IsOrderedField : public BitField<bool, 4, 1> {};
+
   int block_id_;
   HGraph* graph_;
   ZoneList<HPhi*> phis_;
@@ -207,11 +219,7 @@ class HBasicBlock FINAL : public ZoneObject {
   HBasicBlock* parent_loop_header_;
   // For blocks marked as inline return target: the block with HEnterInlined.
   HBasicBlock* inlined_entry_block_;
-  bool is_inline_return_target_ : 1;
-  bool is_reachable_ : 1;
-  bool dominates_loop_successors_ : 1;
-  bool is_osr_entry_ : 1;
-  bool is_ordered_ : 1;
+  uint32_t bit_field_;

[Sven Panne, 2014/11/05 09:11:49]

Can we leave this as it is? It's only a sequence of booleans, which is OK, and
furthermore HBasicBlock is not relevant for any kind of space savings. The
BitField stuff is only obfuscating things here.

[Jakob Kummerow, 2014/11/05 12:13:46]

Done. (Though I don't agree with the term "obfuscating"; yes it's more verbose,
but also more consistent and explicit/reliable which IMHO justifies the change.
But whatever.)

 };
 
 
@@ -1482,7 +1490,7 @@ class HGraphBuilder {
               HIfContinuation* continuation);
 
     ~IfBuilder() {
-      if (!finished_) End();
+      if (!finished()) End();
     }
 
     void Initialize(HGraphBuilder* builder);
@@ -1657,16 +1665,55 @@ class HGraphBuilder {
       MergeAtJoinBlock* next_;
     };
 
+    class FinishedField : public BitField<bool, 0, 1> {};
+    class DidThenField : public BitField<bool, 1, 1> {};
+    class DidElseField : public BitField<bool, 2, 1> {};
+    class DidElseIfField : public BitField<bool, 3, 1> {};
+    class DidAndField : public BitField<bool, 4, 1> {};
+    class DidOrField : public BitField<bool, 5, 1> {};
+    class CapturedField : public BitField<bool, 6, 1> {};
+    class NeedsCompareField : public BitField<bool, 7, 1> {};
+    class PendingMergeBlockField : public BitField<bool, 8, 1> {};
+
+    bool finished() const { return FinishedField::decode(bit_field_); }
+    void set_finished() {
+      bit_field_ = FinishedField::update(bit_field_, true);
+    }
+    bool did_then() const { return DidThenField::decode(bit_field_); }
+    void set_did_then(bool b) {
+      bit_field_ = DidThenField::update(bit_field_, b);
+    }
+    bool did_else() const { return DidElseField::decode(bit_field_); }
+    void set_did_else(bool b) {
+      bit_field_ = DidElseField::update(bit_field_, b);
+    }
+    bool did_else_if() const { return DidElseIfField::decode(bit_field_); }
+    void set_did_else_if(bool b) {
+      bit_field_ = DidElseIfField::update(bit_field_, b);
+    }
+    bool did_and() const { return DidAndField::decode(bit_field_); }
+    void set_did_and(bool b) {
+      bit_field_ = DidAndField::update(bit_field_, b);
+    }
+    bool did_or() const { return DidOrField::decode(bit_field_); }
+    void set_did_or(bool b) { bit_field_ = DidOrField::update(bit_field_, b); }
+    bool captured() const { return CapturedField::decode(bit_field_); }
+    void set_captured() {
+      bit_field_ = CapturedField::update(bit_field_, true);
+    }
+    bool needs_compare() const { return NeedsCompareField::decode(bit_field_); }
+    void set_needs_compare(bool b) {
+      bit_field_ = NeedsCompareField::update(bit_field_, b);
+    }
+    bool pending_merge_block() const {
+      return PendingMergeBlockField::decode(bit_field_);
+    }
+    void set_pending_merge_block(bool b) {
+      bit_field_ = PendingMergeBlockField::update(bit_field_, b);
+    }
+
     HGraphBuilder* builder_;
-    bool finished_ : 1;
-    bool did_then_ : 1;
-    bool did_else_ : 1;
-    bool did_else_if_ : 1;
-    bool did_and_ : 1;
-    bool did_or_ : 1;
-    bool captured_ : 1;
-    bool needs_compare_ : 1;
-    bool pending_merge_block_ : 1;
+    uint32_t bit_field_;

[Sven Panne, 2014/11/05 09:11:49]

Same here: This is obfuscating things, and IfBuilder is not relevant for space
efficiency.

[Jakob Kummerow, 2014/11/05 12:13:46]

Done.

     HBasicBlock* first_true_block_;
     HBasicBlock* first_false_block_;
     HBasicBlock* split_edge_merge_block_;