Replace C++ bitfields with our own BitFields

src/hydrogen.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #ifndef V8_HYDROGEN_H_
 #define V8_HYDROGEN_H_
 
 #include "src/v8.h"
 
 #include "src/accessors.h"
@@ skipping 58 matching lines @@
   int argument_count() const { return argument_count_; }
   void set_argument_count(int count) { argument_count_ = count; }
   int first_instruction_index() const { return first_instruction_index_; }
   void set_first_instruction_index(int index) {
     first_instruction_index_ = index;
   }
   int last_instruction_index() const { return last_instruction_index_; }
   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();
   bool IsLoopHeader() const { return loop_information() != NULL; }
   bool IsStartBlock() const { return block_id() == 0; }
   void PostProcessLoopHeader(IterationStatement* stmt);
 
   bool IsFinished() const { return end_ != NULL; }
   void AddPhi(HPhi* phi);
   void RemovePhi(HPhi* phi);
@@ skipping 32 matching lines @@
   }
   void AssignCommonDominator(HBasicBlock* other);
   void AssignLoopSuccessorDominators();
 
   // If a target block is tagged as an inline function return, all
   // predecessors should contain the inlined exit sequence:
   //
   // 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_; }
 
   bool IsDeoptimizing() const {
     return end() != NULL && end()->IsDeoptimize();
   }
 
   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);
 
   inline Zone* zone() const;
 
 #ifdef DEBUG
   void Verify();
 #endif
 
  protected:
@@ skipping 13 matching lines @@
   // Add the inlined function exit sequence, adding an HLeaveInlined
   // instruction and updating the bailout environment.
   void AddLeaveInlined(HValue* return_value,
                        FunctionState* state,
                        HSourcePosition position);
 
  private:
   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_;
   HInstruction* first_;
   HInstruction* last_;
   HControlInstruction* end_;
   HLoopInformation* loop_information_;
   ZoneList<HBasicBlock*> predecessors_;
   HBasicBlock* dominator_;
   ZoneList<HBasicBlock*> dominated_blocks_;
   HEnvironment* last_environment_;
   // Outgoing parameter count at block exit, set during lithium translation.
   int argument_count_;
   // Instruction indices into the lithium code stream.
   int first_instruction_index_;
   int last_instruction_index_;
   ZoneList<int> deleted_phis_;
   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.)

 };
 
 
 std::ostream& operator<<(std::ostream& os, const HBasicBlock& b);
 
 
 class HPredecessorIterator FINAL BASE_EMBEDDED {
  public:
   explicit HPredecessorIterator(HBasicBlock* block)
       : predecessor_list_(block->predecessors()), current_(0) { }
@@ skipping 1250 matching lines @@
   class IfBuilder FINAL {
    public:
     // If using this constructor, Initialize() must be called explicitly!
     IfBuilder();
 
     explicit IfBuilder(HGraphBuilder* builder);
     IfBuilder(HGraphBuilder* builder,
               HIfContinuation* continuation);
 
     ~IfBuilder() {
-      if (!finished_) End();
+      if (!finished()) End();
     }
 
     void Initialize(HGraphBuilder* builder);
 
     template<class Condition>
     Condition* If(HValue *p) {
       Condition* compare = builder()->New<Condition>(p);
       AddCompare(compare);
       return compare;
     }
@@ skipping 154 matching lines @@
                        bool deopt,
                        MergeAtJoinBlock* next)
         : block_(block),
           deopt_(deopt),
           next_(next) {}
       HBasicBlock* block_;
       bool deopt_;
       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_;
     MergeAtJoinBlock* merge_at_join_blocks_;
     int normal_merge_at_join_block_count_;
     int deopt_merge_at_join_block_count_;
   };
 
   class LoopBuilder FINAL {
    public:
@@ skipping 1230 matching lines @@
   }
 
  private:
   HGraphBuilder* builder_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_H_