Replace C++ bitfields with our own BitFields

src/hydrogen.cc

 // Copyright 2013 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.
 
 #include "src/hydrogen.h"
 
 #include <sstream>
 
 #include "src/v8.h"
 
@@ skipping 64 matching lines @@
       predecessors_(2, graph->zone()),
       dominator_(NULL),
       dominated_blocks_(4, graph->zone()),
       last_environment_(NULL),
       argument_count_(-1),
       first_instruction_index_(-1),
       last_instruction_index_(-1),
       deleted_phis_(4, graph->zone()),
       parent_loop_header_(NULL),
       inlined_entry_block_(NULL),
-      is_inline_return_target_(false),
-      is_reachable_(true),
-      dominates_loop_successors_(false),
-      is_osr_entry_(false),
-      is_ordered_(false) { }
+      bit_field_(IsInlineReturnTargetField::encode(false) |
+                 IsReachableField::encode(true) |
+                 DominatesLoopSuccessorsField::encode(false) |
+                 IsOsrEntryField::encode(false) |
+                 IsOrderedField::encode(false)) {}
 
 
 Isolate* HBasicBlock::isolate() const {
   return graph_->isolate();
 }
 
 
 void HBasicBlock::MarkUnreachable() {
-  is_reachable_ = false;
+  bit_field_ = IsReachableField::update(bit_field_, false);
 }
 
 
 void HBasicBlock::AttachLoopInformation() {
   DCHECK(!IsLoopHeader());
   loop_information_ = new(zone()) HLoopInformation(this, zone());
 }
 
 
 void HBasicBlock::DetachLoopInformation() {
@@ skipping 632 matching lines @@
   if (IsConstant1(constant)) return true;
   if (IsConstantMinus1(constant)) return true;
   if (IsConstantTrue(constant)) return true;
   if (IsConstantFalse(constant)) return true;
   if (IsConstantHole(constant)) return true;
   if (IsConstantNull(constant)) return true;
   return false;
 }
 
 
-HGraphBuilder::IfBuilder::IfBuilder() : builder_(NULL), needs_compare_(true) {}
+HGraphBuilder::IfBuilder::IfBuilder()
+    : builder_(NULL), bit_field_(NeedsCompareField::encode(true)) {}
 
 
 HGraphBuilder::IfBuilder::IfBuilder(HGraphBuilder* builder)
-    : needs_compare_(true) {
+    : bit_field_(NeedsCompareField::encode(true)) {
   Initialize(builder);
 }
 
 
 HGraphBuilder::IfBuilder::IfBuilder(HGraphBuilder* builder,
                                     HIfContinuation* continuation)
-    : needs_compare_(false), first_true_block_(NULL), first_false_block_(NULL) {
+    : bit_field_(NeedsCompareField::encode(false)),
+      first_true_block_(NULL),
+      first_false_block_(NULL) {
   InitializeDontCreateBlocks(builder);
   continuation->Continue(&first_true_block_, &first_false_block_);
 }
 
 
 void HGraphBuilder::IfBuilder::InitializeDontCreateBlocks(
     HGraphBuilder* builder) {
   builder_ = builder;
-  finished_ = false;
-  did_then_ = false;
-  did_else_ = false;
-  did_else_if_ = false;
-  did_and_ = false;
-  did_or_ = false;
-  captured_ = false;
-  pending_merge_block_ = false;
+  bool needs_compare = NeedsCompareField::decode(bit_field_);
+  bit_field_ = FinishedField::encode(false) | DidThenField::encode(false) |
+               DidElseField::encode(false) | DidElseIfField::encode(false) |
+               DidAndField::encode(false) | DidOrField::encode(false) |
+               CapturedField::encode(false) |
+               NeedsCompareField::encode(needs_compare) |
+               PendingMergeBlockField::encode(false);
   split_edge_merge_block_ = NULL;
   merge_at_join_blocks_ = NULL;
   normal_merge_at_join_block_count_ = 0;
   deopt_merge_at_join_block_count_ = 0;
 }
 
 
 void HGraphBuilder::IfBuilder::Initialize(HGraphBuilder* builder) {
   InitializeDontCreateBlocks(builder);
   HEnvironment* env = builder->environment();
   first_true_block_ = builder->CreateBasicBlock(env->Copy());
   first_false_block_ = builder->CreateBasicBlock(env->Copy());
 }
 
 
 HControlInstruction* HGraphBuilder::IfBuilder::AddCompare(
     HControlInstruction* compare) {
-  DCHECK(did_then_ == did_else_);
-  if (did_else_) {
+  DCHECK(did_then() == did_else());
+  if (did_else()) {
     // Handle if-then-elseif
-    did_else_if_ = true;
-    did_else_ = false;
-    did_then_ = false;
-    did_and_ = false;
-    did_or_ = false;
-    pending_merge_block_ = false;
+    set_did_else_if(true);
+    set_did_else(false);
+    set_did_then(false);
+    set_did_and(false);
+    set_did_or(false);
+    set_pending_merge_block(false);
     split_edge_merge_block_ = NULL;
     HEnvironment* env = builder()->environment();
     first_true_block_ = builder()->CreateBasicBlock(env->Copy());
     first_false_block_ = builder()->CreateBasicBlock(env->Copy());
   }
   if (split_edge_merge_block_ != NULL) {
     HEnvironment* env = first_false_block_->last_environment();
     HBasicBlock* split_edge = builder()->CreateBasicBlock(env->Copy());
-    if (did_or_) {
+    if (did_or()) {
       compare->SetSuccessorAt(0, split_edge);
       compare->SetSuccessorAt(1, first_false_block_);
     } else {
       compare->SetSuccessorAt(0, first_true_block_);
       compare->SetSuccessorAt(1, split_edge);
     }
     builder()->GotoNoSimulate(split_edge, split_edge_merge_block_);
   } else {
     compare->SetSuccessorAt(0, first_true_block_);
     compare->SetSuccessorAt(1, first_false_block_);
   }
   builder()->FinishCurrentBlock(compare);
-  needs_compare_ = false;
+  set_needs_compare(false);
   return compare;
 }
 
 
 void HGraphBuilder::IfBuilder::Or() {
-  DCHECK(!needs_compare_);
-  DCHECK(!did_and_);
-  did_or_ = true;
+  DCHECK(!needs_compare());
+  DCHECK(!did_and());
+  set_did_or(true);
   HEnvironment* env = first_false_block_->last_environment();
   if (split_edge_merge_block_ == NULL) {
     split_edge_merge_block_ = builder()->CreateBasicBlock(env->Copy());
     builder()->GotoNoSimulate(first_true_block_, split_edge_merge_block_);
     first_true_block_ = split_edge_merge_block_;
   }
   builder()->set_current_block(first_false_block_);
   first_false_block_ = builder()->CreateBasicBlock(env->Copy());
 }
 
 
 void HGraphBuilder::IfBuilder::And() {
-  DCHECK(!needs_compare_);
-  DCHECK(!did_or_);
-  did_and_ = true;
+  DCHECK(!needs_compare());
+  DCHECK(!did_or());
+  set_did_and(true);
   HEnvironment* env = first_false_block_->last_environment();
   if (split_edge_merge_block_ == NULL) {
     split_edge_merge_block_ = builder()->CreateBasicBlock(env->Copy());
     builder()->GotoNoSimulate(first_false_block_, split_edge_merge_block_);
     first_false_block_ = split_edge_merge_block_;
   }
   builder()->set_current_block(first_true_block_);
   first_true_block_ = builder()->CreateBasicBlock(env->Copy());
 }
 
 
 void HGraphBuilder::IfBuilder::CaptureContinuation(
     HIfContinuation* continuation) {
-  DCHECK(!did_else_if_);
-  DCHECK(!finished_);
-  DCHECK(!captured_);
+  DCHECK(!did_else_if());
+  DCHECK(!finished());
+  DCHECK(!captured());
 
   HBasicBlock* true_block = NULL;
   HBasicBlock* false_block = NULL;
   Finish(&true_block, &false_block);
   DCHECK(true_block != NULL);
   DCHECK(false_block != NULL);
   continuation->Capture(true_block, false_block);
-  captured_ = true;
+  set_captured();
   builder()->set_current_block(NULL);
   End();
 }
 
 
 void HGraphBuilder::IfBuilder::JoinContinuation(HIfContinuation* continuation) {
-  DCHECK(!did_else_if_);
-  DCHECK(!finished_);
-  DCHECK(!captured_);
+  DCHECK(!did_else_if());
+  DCHECK(!finished());
+  DCHECK(!captured());
   HBasicBlock* true_block = NULL;
   HBasicBlock* false_block = NULL;
   Finish(&true_block, &false_block);
   merge_at_join_blocks_ = NULL;
   if (true_block != NULL && !true_block->IsFinished()) {
     DCHECK(continuation->IsTrueReachable());
     builder()->GotoNoSimulate(true_block, continuation->true_branch());
   }
   if (false_block != NULL && !false_block->IsFinished()) {
     DCHECK(continuation->IsFalseReachable());
     builder()->GotoNoSimulate(false_block, continuation->false_branch());
   }
-  captured_ = true;
+  set_captured();
   End();
 }
 
 
 void HGraphBuilder::IfBuilder::Then() {
-  DCHECK(!captured_);
-  DCHECK(!finished_);
-  did_then_ = true;
-  if (needs_compare_) {
+  DCHECK(!captured());
+  DCHECK(!finished());
+  set_did_then(true);
+  if (needs_compare()) {
     // Handle if's without any expressions, they jump directly to the "else"
     // branch. However, we must pretend that the "then" branch is reachable,
     // so that the graph builder visits it and sees any live range extending
     // constructs within it.
     HConstant* constant_false = builder()->graph()->GetConstantFalse();
     ToBooleanStub::Types boolean_type = ToBooleanStub::Types();
     boolean_type.Add(ToBooleanStub::BOOLEAN);
     HBranch* branch = builder()->New<HBranch>(
         constant_false, boolean_type, first_true_block_, first_false_block_);
     builder()->FinishCurrentBlock(branch);
   }
   builder()->set_current_block(first_true_block_);
-  pending_merge_block_ = true;
+  set_pending_merge_block(true);
 }
 
 
 void HGraphBuilder::IfBuilder::Else() {
-  DCHECK(did_then_);
-  DCHECK(!captured_);
-  DCHECK(!finished_);
+  DCHECK(did_then());
+  DCHECK(!captured());
+  DCHECK(!finished());
   AddMergeAtJoinBlock(false);
   builder()->set_current_block(first_false_block_);
-  pending_merge_block_ = true;
-  did_else_ = true;
+  set_pending_merge_block(true);
+  set_did_else(true);
 }
 
 
 void HGraphBuilder::IfBuilder::Deopt(const char* reason) {
-  DCHECK(did_then_);
+  DCHECK(did_then());
   builder()->Add<HDeoptimize>(reason, Deoptimizer::EAGER);
   AddMergeAtJoinBlock(true);
 }
 
 
 void HGraphBuilder::IfBuilder::Return(HValue* value) {
   HValue* parameter_count = builder()->graph()->GetConstantMinus1();
   builder()->FinishExitCurrentBlock(
       builder()->New<HReturn>(value, parameter_count));
   AddMergeAtJoinBlock(false);
 }
 
 
 void HGraphBuilder::IfBuilder::AddMergeAtJoinBlock(bool deopt) {
-  if (!pending_merge_block_) return;
+  if (!pending_merge_block()) return;
   HBasicBlock* block = builder()->current_block();
   DCHECK(block == NULL || !block->IsFinished());
   MergeAtJoinBlock* record = new (builder()->zone())
       MergeAtJoinBlock(block, deopt, merge_at_join_blocks_);
   merge_at_join_blocks_ = record;
   if (block != NULL) {
     DCHECK(block->end() == NULL);
     if (deopt) {
       normal_merge_at_join_block_count_++;
     } else {
       deopt_merge_at_join_block_count_++;
     }
   }
   builder()->set_current_block(NULL);
-  pending_merge_block_ = false;
+  set_pending_merge_block(false);
 }
 
 
 void HGraphBuilder::IfBuilder::Finish() {
-  DCHECK(!finished_);
-  if (!did_then_) {
+  DCHECK(!finished());
+  if (!did_then()) {
     Then();
   }
   AddMergeAtJoinBlock(false);
-  if (!did_else_) {
+  if (!did_else()) {
     Else();
     AddMergeAtJoinBlock(false);
   }
-  finished_ = true;
+  set_finished();
 }
 
 
 void HGraphBuilder::IfBuilder::Finish(HBasicBlock** then_continuation,
                                       HBasicBlock** else_continuation) {
   Finish();
 
   MergeAtJoinBlock* else_record = merge_at_join_blocks_;
   if (else_continuation != NULL) {
     *else_continuation = else_record->block_;
   }
   MergeAtJoinBlock* then_record = else_record->next_;
   if (then_continuation != NULL) {
     *then_continuation = then_record->block_;
   }
   DCHECK(then_record->next_ == NULL);
 }
 
 
 void HGraphBuilder::IfBuilder::End() {
-  if (captured_) return;
+  if (captured()) return;
   Finish();
 
   int total_merged_blocks = normal_merge_at_join_block_count_ +
     deopt_merge_at_join_block_count_;
   DCHECK(total_merged_blocks >= 1);
   HBasicBlock* merge_block =
       total_merged_blocks == 1 ? NULL : builder()->graph()->CreateBasicBlock();
 
   // Merge non-deopt blocks first to ensure environment has right size for
   // padding.
@@ skipping 11663 matching lines @@
   if (ShouldProduceTraceOutput()) {
     isolate()->GetHTracer()->TraceHydrogen(name(), graph_);
   }
 
 #ifdef DEBUG
   graph_->Verify(false);  // No full verify.
 #endif
 }
 
 } }  // namespace v8::internal