Merge bleeding_edge revision (5922, 5934] to isolates branch....

src/hydrogen.cc

 // 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 1146 matching lines @@
         }
       } else {
         present_flags_ |= array_[i].value->flags();  // Keep it.
       }
     }
   }
 }
 
 
 HValue* HValueMap::Lookup(HValue* value) const {
-  uint32_t hash = value->Hashcode();
+  uint32_t hash = static_cast<uint32_t>(value->Hashcode());
   uint32_t pos = Bound(hash);
   if (array_[pos].value != NULL) {
     if (array_[pos].value->Equals(value)) return array_[pos].value;
     int next = array_[pos].next;
     while (next != kNil) {
       if (lists_[next].value->Equals(value)) return lists_[next].value;
       next = lists_[next].next;
     }
   }
   return NULL;
@@ skipping 67 matching lines @@
   }
 }
 
 
 void HValueMap::Insert(HValue* value) {
   ASSERT(value != NULL);
   // Resizing when half of the hashtable is filled up.
   if (count_ >= array_size_ >> 1) Resize(array_size_ << 1);
   ASSERT(count_ < array_size_);
   count_++;
-  uint32_t pos = Bound(value->Hashcode());
+  uint32_t pos = Bound(static_cast<uint32_t>(value->Hashcode()));
   if (array_[pos].value == NULL) {
     array_[pos].value = value;
     array_[pos].next = kNil;
   } else {
     if (free_list_head_ == kNil) {
       ResizeLists(lists_size_ << 1);
     }
     int new_element_pos = free_list_head_;
     ASSERT(new_element_pos != kNil);
     free_list_head_ = lists_[free_list_head_].next;
@@ skipping 2704 matching lines @@
   }
 
   // Update inlined nodes count.
   inlined_count_ += nodes_added;
 
   if (FLAG_trace_inlining) TraceInline(target, true);
 
   if (body->HasExit()) {
     // Add a return of undefined if control can fall off the body.  In a
     // test context, undefined is false.
-    HValue* return_value = NULL;
-    HBasicBlock* target = NULL;
+    HValue* return_value = graph()->GetConstantUndefined();
     if (test_context == NULL) {
       ASSERT(function_return_ != NULL);
-      return_value = graph()->GetConstantUndefined();
-      target = function_return_;
+      body->exit_block()->AddLeaveInlined(return_value, function_return_);
     } else {
-      return_value = graph()->GetConstantFalse();
-      target = test_context->if_false();
+      // The graph builder assumes control can reach both branches of a
+      // test, so we materialize the undefined value and test it rather than
+      // simply jumping to the false target.
+      //
+      // TODO(3168478): refactor to avoid this.
+      HBasicBlock* materialize_true = graph()->CreateBasicBlock();
+      HBasicBlock* materialize_false = graph()->CreateBasicBlock();
+      HBranch* branch =
+          new HBranch(materialize_true, materialize_false, return_value);
+      body->exit_block()->Finish(branch);
+
+      materialize_true->AddLeaveInlined(graph()->GetConstantTrue(),
+                                        test_context->if_true());
+      materialize_false->AddLeaveInlined(graph()->GetConstantFalse(),
+                                         test_context->if_false());
     }
-    body->exit_block()->AddLeaveInlined(return_value, target);
     body->set_exit_block(NULL);
   }
 
   // Record the environment at the inlined function call.
   AddSimulate(expr->ReturnId());
 
   // Jump to the function entry (without re-recording the environment).
   subgraph()->exit_block()->Finish(new HGoto(body->entry_block()));
 
   // Fix up the function exits.
@@ skipping 1530 matching lines @@
   }
 
 #ifdef DEBUG
   if (graph_ != NULL) graph_->Verify();
   if (chunk_ != NULL) chunk_->Verify();
   if (allocator_ != NULL) allocator_->Verify();
 #endif
 }
 
 } }  // namespace v8::internal