Unify SoftDeoptimize and Deoptimize hydrogen instructions

src/code-stubs-hydrogen.cc

 // Copyright 2012 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 160 matching lines @@
   } else {
     ASSERT(descriptor_->environment_length() == param_count);
     stack_parameter_count = graph()->GetConstantMinus1();
     arguments_length_ = graph()->GetConstant0();
   }
 
   context_ = new(zone) HContext();
   AddInstruction(context_);
   start_environment->BindContext(context_);
 
-  AddSimulate(BailoutId::StubEntry());
+  Add<HSimulate>(BailoutId::StubEntry());
 
   NoObservableSideEffectsScope no_effects(this);
 
   HValue* return_value = BuildCodeStub();
 
   // We might have extra expressions to pop from the stack in addition to the
   // arguments above.
   HInstruction* stack_pop_count = stack_parameter_count;
   if (descriptor_->function_mode_ == JS_FUNCTION_STUB_MODE) {
     if (!stack_parameter_count->IsConstant() &&
@@ skipping 167 matching lines @@
   } else {
     ElementsKind elements_kind = casted_stub()->ComputeElementsKind();
     environment()->Push(BuildCloneShallowArray(context(),
                                                boilerplate,
                                                allocation_site,
                                                alloc_site_mode,
                                                elements_kind,
                                                length));
   }
 
-  HValue* result = environment()->Pop();
   checker.ElseDeopt();
-  return result;
+  checker.End();
+
+  return environment()->Pop();
 }
 
 
 Handle<Code> FastCloneShallowArrayStub::GenerateCode() {
   return DoGenerateCode(this);
 }
 
 
 template <>
 HValue* CodeStubGraphBuilder<FastCloneShallowObjectStub>::BuildCodeStub() {
@@ skipping 27 matching lines @@
   }
 
   HInstruction* object = AddInstruction(new(zone)
       HAllocate(context(), size_in_bytes, HType::JSObject(), flags));
 
   for (int i = 0; i < size; i += kPointerSize) {
     HObjectAccess access = HObjectAccess::ForJSObjectOffset(i);
     AddStore(object, access, AddLoad(boilerplate, access));
   }
 
+  environment()->Push(object);

[Jakob Kummerow, 2013/07/22 16:53:12]

I don't understand why this Push/Pop sequence is necessary. Why was the old code
not safe?

[danno, 2013/07/23 12:18:14]

Sort of. The problem is that there was no real merge of paths before, so no phi
node was needed at all for the result. Now that the deoptimize path actually
merges into the join at the end of the if, the return value from the "true" path
must be the input to a phi that the "else deopt" path contributes a undefined or
some other dummy value to. Otherwise, the register allocator complains that
there is a use before a definition along the else path. It doesn't know that the
the deoptimize instruction makes the else value of the phi irrelevant.

   checker.ElseDeopt();
-  return object;
+  checker.End();
+
+  return environment()->Pop();
 }
 
 
 Handle<Code> FastCloneShallowObjectStub::GenerateCode() {
   return DoGenerateCode(this);
 }
 
 
 template <>
 HValue* CodeStubGraphBuilder<CreateAllocationSiteStub>::BuildCodeStub() {
@@ skipping 414 matching lines @@
   Handle<Object> hole(isolate()->heap()->the_hole_value(), isolate());
   Handle<Object> placeholer_value(Smi::FromInt(0), isolate());
   Handle<PropertyCell> placeholder_cell =
       isolate()->factory()->NewPropertyCell(placeholer_value);
 
   HParameter* receiver = GetParameter(0);
   HParameter* value = GetParameter(2);
 
   if (stub->is_constant()) {
     // Assume every store to a constant value changes it.
-    current_block()->FinishExitWithDeoptimization(HDeoptimize::kUseAll);
-    set_current_block(NULL);
+    Add<HDeoptimize>(Deoptimizer::EAGER);
   } else {
     HValue* cell = Add<HConstant>(placeholder_cell, Representation::Tagged());
 
     // Check that the map of the global has not changed: use a placeholder map
     // that will be replaced later with the global object's map.
     Handle<Map> placeholder_map = isolate()->factory()->meta_map();
     AddInstruction(HCheckMaps::New(receiver, placeholder_map, zone()));
 
     // Load the payload of the global parameter cell. A hole indicates that the
     // property has been deleted and that the store must be handled by the
@@ skipping 20 matching lines @@
 
 template<>
 HValue* CodeStubGraphBuilder<ElementsTransitionAndStoreStub>::BuildCodeStub() {
   HValue* value = GetParameter(0);
   HValue* map = GetParameter(1);
   HValue* key = GetParameter(2);
   HValue* object = GetParameter(3);
 
   if (FLAG_trace_elements_transitions) {
     // Tracing elements transitions is the job of the runtime.
-    current_block()->FinishExitWithDeoptimization(HDeoptimize::kUseAll);
-    set_current_block(NULL);
+    Add<HDeoptimize>(Deoptimizer::EAGER);
   } else {
     info()->MarkAsSavesCallerDoubles();
 
     BuildTransitionElementsKind(object, map,
                                 casted_stub()->from_kind(),
                                 casted_stub()->to_kind(),
                                 casted_stub()->is_jsarray());
 
     BuildUncheckedMonomorphicElementAccess(object, key, value, NULL,
                                           casted_stub()->is_jsarray(),
                                           casted_stub()->to_kind(),
                                           true, ALLOW_RETURN_HOLE,
                                           casted_stub()->store_mode());
   }
 
   return value;
 }
 
 
 Handle<Code> ElementsTransitionAndStoreStub::GenerateCode() {
   return DoGenerateCode(this);
 }
 
 
 } }  // namespace v8::internal