[turbofan] Add support for eager/soft deoptimization reasons.

src/code-stubs-hydrogen.cc

 // 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.
 
 #include "src/code-stubs.h"
 
 #include "src/bailout-reason.h"
 #include "src/crankshaft/hydrogen.h"
 #include "src/crankshaft/lithium.h"
 #include "src/field-index.h"
@@ skipping 189 matching lines @@
     UNIMPLEMENTED();
     return NULL;
   }
 
   virtual HValue* BuildCodeUninitializedStub() {
     // Force a deopt that falls back to the runtime.
     HValue* undefined = graph()->GetConstantUndefined();
     IfBuilder builder(this);
     builder.IfNot<HCompareObjectEqAndBranch, HValue*>(undefined, undefined);
     builder.Then();
-    builder.ElseDeopt(Deoptimizer::kForcedDeoptToRuntime);
+    builder.ElseDeopt(DeoptimizeReason::kForcedDeoptToRuntime);
     return undefined;
   }
 
   Stub* casted_stub() { return static_cast<Stub*>(stub()); }
 };
 
 
 Handle<Code> HydrogenCodeStub::GenerateLightweightMissCode(
     ExternalReference miss) {
   Factory* factory = isolate()->factory();
@@ skipping 219 matching lines @@
         Add<HLoadNamedField>(boilerplate, nullptr,
                              HObjectAccess::ForElementsPointer()));
     for (int offset = JSObject::kHeaderSize; offset < result_size;
          offset += kPointerSize) {
       HObjectAccess access = HObjectAccess::ForObservableJSObjectOffset(offset);
       Add<HStoreNamedField>(result, access,
                             Add<HLoadNamedField>(boilerplate, nullptr, access));
     }
     Push(result);
   }
-  if_notundefined.ElseDeopt(Deoptimizer::kUninitializedBoilerplateInFastClone);
+  if_notundefined.ElseDeopt(
+      DeoptimizeReason::kUninitializedBoilerplateInFastClone);
   if_notundefined.End();
 
   return Pop();
 }
 
 
 Handle<Code> FastCloneRegExpStub::GenerateCode() {
   return DoGenerateCode(this);
 }
 
@@ skipping 58 matching lines @@
 
   if_fixed.Else();
   Push(BuildCloneShallowArrayNonEmpty(boilerplate,
                                       allocation_site,
                                       alloc_site_mode,
                                       FAST_DOUBLE_ELEMENTS));
   if_fixed.End();
   if_fixed_cow.End();
   zero_capacity.End();
 
-  checker.ElseDeopt(Deoptimizer::kUninitializedBoilerplateLiterals);
+  checker.ElseDeopt(DeoptimizeReason::kUninitializedBoilerplateLiterals);
   checker.End();
 
   return environment()->Pop();
 }
 
 
 Handle<Code> FastCloneShallowArrayStub::GenerateCode() {
   return DoGenerateCode(this);
 }
 
@@ skipping 152 matching lines @@
     {
       HInstruction* argument =
           Add<HAccessArgumentsAt>(argument_elements, argc, key);
       IfBuilder can_store(this);
       can_store.IfNot<HIsSmiAndBranch>(argument);
       if (IsFastDoubleElementsKind(kind)) {
         can_store.And();
         can_store.IfNot<HCompareMap>(argument,
                                      isolate()->factory()->heap_number_map());
       }
-      can_store.ThenDeopt(Deoptimizer::kFastPathFailed);
+      can_store.ThenDeopt(DeoptimizeReason::kFastPathFailed);
       can_store.End();
     }
     builder.EndBody();
   }
 
   HValue* length = Add<HLoadNamedField>(object, nullptr,
                                         HObjectAccess::ForArrayLength(kind));
   HValue* new_length = AddUncasted<HAdd>(length, argc);
   HValue* max_key = AddUncasted<HSub>(new_length, graph()->GetConstant1());
 
@@ skipping 30 matching lines @@
   {
     HValue* bit_field2 =
         Add<HLoadNamedField>(map, nullptr, HObjectAccess::ForMapBitField2());
     HValue* mask =
         Add<HConstant>(static_cast<int>(Map::IsPrototypeMapBits::kMask) |
                        (1 << Map::kIsExtensible));
     HValue* bits = AddUncasted<HBitwise>(Token::BIT_AND, bit_field2, mask);
     IfBuilder check(this);
     check.If<HCompareNumericAndBranch>(
         bits, Add<HConstant>(1 << Map::kIsExtensible), Token::NE);
-    check.ThenDeopt(Deoptimizer::kFastPathFailed);
+    check.ThenDeopt(DeoptimizeReason::kFastPathFailed);
     check.End();
   }
 
   // Disallow pushing onto arrays in dictionary named property mode. We need to
   // figure out whether the length property is still writable.
   {
     HValue* bit_field3 =
         Add<HLoadNamedField>(map, nullptr, HObjectAccess::ForMapBitField3());
     HValue* mask = Add<HConstant>(static_cast<int>(Map::DictionaryMap::kMask));
     HValue* bit = AddUncasted<HBitwise>(Token::BIT_AND, bit_field3, mask);
     IfBuilder check(this);
     check.If<HCompareNumericAndBranch>(bit, mask, Token::EQ);
-    check.ThenDeopt(Deoptimizer::kFastPathFailed);
+    check.ThenDeopt(DeoptimizeReason::kFastPathFailed);
     check.End();
   }
 
   // Check whether the length property is writable. The length property is the
   // only default named property on arrays. It's nonconfigurable, hence is
   // guaranteed to stay the first property.
   {
     HValue* descriptors =
         Add<HLoadNamedField>(map, nullptr, HObjectAccess::ForMapDescriptors());
     HValue* details = Add<HLoadKeyed>(
         descriptors, Add<HConstant>(DescriptorArray::ToDetailsIndex(0)),
         nullptr, nullptr, FAST_SMI_ELEMENTS);
     HValue* mask =
         Add<HConstant>(READ_ONLY << PropertyDetails::AttributesField::kShift);
     HValue* bit = AddUncasted<HBitwise>(Token::BIT_AND, details, mask);
     IfBuilder readonly(this);
     readonly.If<HCompareNumericAndBranch>(bit, mask, Token::EQ);
-    readonly.ThenDeopt(Deoptimizer::kFastPathFailed);
+    readonly.ThenDeopt(DeoptimizeReason::kFastPathFailed);
     readonly.End();
   }
 
   HValue* null = Add<HLoadRoot>(Heap::kNullValueRootIndex);
   HValue* empty = Add<HLoadRoot>(Heap::kEmptyFixedArrayRootIndex);
   environment()->Push(map);
   LoopBuilder check_prototypes(this);
   check_prototypes.BeginBody(1);
   {
     HValue* parent_map = environment()->Pop();
     HValue* prototype = Add<HLoadNamedField>(parent_map, nullptr,
                                              HObjectAccess::ForPrototype());
 
     IfBuilder is_null(this);
     is_null.If<HCompareObjectEqAndBranch>(prototype, null);
     is_null.Then();
     check_prototypes.Break();
     is_null.End();
 
     HValue* prototype_map =
         Add<HLoadNamedField>(prototype, nullptr, HObjectAccess::ForMap());
     HValue* instance_type = Add<HLoadNamedField>(
         prototype_map, nullptr, HObjectAccess::ForMapInstanceType());
     IfBuilder check_instance_type(this);
     check_instance_type.If<HCompareNumericAndBranch>(
         instance_type, Add<HConstant>(LAST_CUSTOM_ELEMENTS_RECEIVER),
         Token::LTE);
-    check_instance_type.ThenDeopt(Deoptimizer::kFastPathFailed);
+    check_instance_type.ThenDeopt(DeoptimizeReason::kFastPathFailed);
     check_instance_type.End();
 
     HValue* elements = Add<HLoadNamedField>(
         prototype, nullptr, HObjectAccess::ForElementsPointer());
     IfBuilder no_elements(this);
     no_elements.IfNot<HCompareObjectEqAndBranch>(elements, empty);
-    no_elements.ThenDeopt(Deoptimizer::kFastPathFailed);
+    no_elements.ThenDeopt(DeoptimizeReason::kFastPathFailed);
     no_elements.End();
 
     environment()->Push(prototype_map);
   }
   check_prototypes.EndBody();
 
   HValue* bit_field2 =
       Add<HLoadNamedField>(map, nullptr, HObjectAccess::ForMapBitField2());
   HValue* kind = BuildDecodeField<Map::ElementsKindBits>(bit_field2);
 
@@ skipping 29 matching lines @@
     {
       IfBuilder has_double_elements(this);
       has_double_elements.If<HCompareNumericAndBranch>(
           kind, Add<HConstant>(FAST_HOLEY_DOUBLE_ELEMENTS), Token::LTE);
       has_double_elements.Then();
       {
         HValue* new_length = BuildPushElement(object, argc, argument_elements,
                                               FAST_HOLEY_DOUBLE_ELEMENTS);
         environment()->Push(new_length);
       }
-      has_double_elements.ElseDeopt(Deoptimizer::kFastPathFailed);
+      has_double_elements.ElseDeopt(DeoptimizeReason::kFastPathFailed);
       has_double_elements.End();
     }
     has_object_elements.End();
   }
   has_smi_elements.End();
 
   return environment()->Pop();
 }
 
 Handle<Code> FastArrayPushStub::GenerateCode() { return DoGenerateCode(this); }
@@ skipping 11 matching lines @@
 
   // Disallow binding of slow-mode functions. We need to figure out whether the
   // length and name property are in the original state.
   {
     HValue* bit_field3 =
         Add<HLoadNamedField>(map, nullptr, HObjectAccess::ForMapBitField3());
     HValue* mask = Add<HConstant>(static_cast<int>(Map::DictionaryMap::kMask));
     HValue* bit = AddUncasted<HBitwise>(Token::BIT_AND, bit_field3, mask);
     IfBuilder check(this);
     check.If<HCompareNumericAndBranch>(bit, mask, Token::EQ);
-    check.ThenDeopt(Deoptimizer::kFastPathFailed);
+    check.ThenDeopt(DeoptimizeReason::kFastPathFailed);
     check.End();
   }
 
   // Check whether the length and name properties are still present as
   // AccessorInfo objects. In that case, their value can be recomputed even if
   // the actual value on the object changes.
   {
     HValue* descriptors =
         Add<HLoadNamedField>(map, nullptr, HObjectAccess::ForMapDescriptors());
 
     HValue* descriptors_length = Add<HLoadNamedField>(
         descriptors, nullptr, HObjectAccess::ForFixedArrayLength());
     IfBuilder range(this);
     range.If<HCompareNumericAndBranch>(descriptors_length,
                                        graph()->GetConstant1(), Token::LTE);
-    range.ThenDeopt(Deoptimizer::kFastPathFailed);
+    range.ThenDeopt(DeoptimizeReason::kFastPathFailed);
     range.End();
 
     // Verify .length.
     const int length_index = JSFunction::kLengthDescriptorIndex;
     HValue* maybe_length = Add<HLoadKeyed>(
         descriptors, Add<HConstant>(DescriptorArray::ToKeyIndex(length_index)),
         nullptr, nullptr, FAST_ELEMENTS);
     Unique<Name> length_string = Unique<Name>::CreateUninitialized(
         isolate()->factory()->length_string());
     Add<HCheckValue>(maybe_length, length_string, false);
@@ skipping 56 matching lines @@
 
   // Verify that __proto__ matches that of a the target bound function.
   {
     HValue* prototype =
         Add<HLoadNamedField>(map, nullptr, HObjectAccess::ForPrototype());
     HValue* expected_prototype = Add<HLoadNamedField>(
         bound_function_map, nullptr, HObjectAccess::ForPrototype());
     IfBuilder equal_prototype(this);
     equal_prototype.IfNot<HCompareObjectEqAndBranch>(prototype,
                                                      expected_prototype);
-    equal_prototype.ThenDeopt(Deoptimizer::kFastPathFailed);
+    equal_prototype.ThenDeopt(DeoptimizeReason::kFastPathFailed);
     equal_prototype.End();
   }
 
   // Allocate the arguments array.
   IfBuilder empty_args(this);
   empty_args.If<HCompareNumericAndBranch>(argc, graph()->GetConstant1(),
                                           Token::LTE);
   empty_args.Then();
   { environment()->Push(Add<HLoadRoot>(Heap::kEmptyFixedArrayRootIndex)); }
   empty_args.Else();
@@ skipping 169 matching lines @@
                                                  Token::LT);
   in_unmapped_range.Then();
   {
     if (value == NULL) {
       result = Add<HLoadKeyed>(backing_store, key, nullptr, nullptr,
                                FAST_HOLEY_ELEMENTS, NEVER_RETURN_HOLE);
     } else {
       Add<HStoreKeyed>(backing_store, key, value, nullptr, FAST_HOLEY_ELEMENTS);
     }
   }
-  in_unmapped_range.ElseDeopt(Deoptimizer::kOutsideOfRange);
+  in_unmapped_range.ElseDeopt(DeoptimizeReason::kOutsideOfRange);
   in_unmapped_range.End();
   return result;
 }
 
 
 HValue* CodeStubGraphBuilderBase::EmitKeyedSloppyArguments(HValue* receiver,
                                                            HValue* key,
                                                            HValue* value) {
   // Mapped arguments are actual arguments. Unmapped arguments are values added
   // to the arguments object after it was created for the call. Mapped arguments
@@ skipping 20 matching lines @@
   // in the unmapped arguments array, as described above. Otherwise, t is a Smi
   // index into the context array given at elements[0]. Return the value at
   // context[t].
 
   bool is_load = value == NULL;
 
   key = AddUncasted<HForceRepresentation>(key, Representation::Smi());
   IfBuilder positive_smi(this);
   positive_smi.If<HCompareNumericAndBranch>(key, graph()->GetConstant0(),
                                             Token::LT);
-  positive_smi.ThenDeopt(Deoptimizer::kKeyIsNegative);
+  positive_smi.ThenDeopt(DeoptimizeReason::kKeyIsNegative);
   positive_smi.End();
 
   HValue* constant_two = Add<HConstant>(2);
   HValue* elements = AddLoadElements(receiver, nullptr);
   HValue* elements_length = Add<HLoadNamedField>(
       elements, nullptr, HObjectAccess::ForFixedArrayLength());
   HValue* adjusted_length = AddUncasted<HSub>(elements_length, constant_two);
   IfBuilder in_range(this);
   in_range.If<HCompareNumericAndBranch>(key, adjusted_length, Token::LT);
   in_range.Then();
@@ skipping 564 matching lines @@
     HValue* global =
         Add<HLoadNamedField>(proxy_map, nullptr, HObjectAccess::ForPrototype());
     HValue* map_cell = Add<HConstant>(isolate()->factory()->NewWeakCell(
         StoreGlobalStub::global_map_placeholder(isolate())));
     HValue* expected_map = Add<HLoadNamedField>(
         map_cell, nullptr, HObjectAccess::ForWeakCellValue());
     HValue* map =
         Add<HLoadNamedField>(global, nullptr, HObjectAccess::ForMap());
     IfBuilder map_check(this);
     map_check.IfNot<HCompareObjectEqAndBranch>(expected_map, map);
-    map_check.ThenDeopt(Deoptimizer::kUnknownMap);
+    map_check.ThenDeopt(DeoptimizeReason::kUnknownMap);
     map_check.End();
   }
 
   HValue* weak_cell = Add<HConstant>(isolate()->factory()->NewWeakCell(
       StoreGlobalStub::property_cell_placeholder(isolate())));
   HValue* cell = Add<HLoadNamedField>(weak_cell, nullptr,
                                       HObjectAccess::ForWeakCellValue());
   Add<HCheckHeapObject>(cell);
   HObjectAccess access = HObjectAccess::ForPropertyCellValue();
   // Load the payload of the global parameter cell. A hole indicates that the
   // cell has been invalidated and that the store must be handled by the
   // runtime.
   HValue* cell_contents = Add<HLoadNamedField>(cell, nullptr, access);
 
   auto cell_type = stub->cell_type();
   if (cell_type == PropertyCellType::kConstant ||
       cell_type == PropertyCellType::kUndefined) {
     // This is always valid for all states a cell can be in.
     IfBuilder builder(this);
     builder.If<HCompareObjectEqAndBranch>(cell_contents, value);
     builder.Then();
     builder.ElseDeopt(
-        Deoptimizer::kUnexpectedCellContentsInConstantGlobalStore);
+        DeoptimizeReason::kUnexpectedCellContentsInConstantGlobalStore);
     builder.End();
   } else {
     IfBuilder builder(this);
     HValue* hole_value = graph()->GetConstantHole();
     builder.If<HCompareObjectEqAndBranch>(cell_contents, hole_value);
     builder.Then();
-    builder.Deopt(Deoptimizer::kUnexpectedCellContentsInGlobalStore);
+    builder.Deopt(DeoptimizeReason::kUnexpectedCellContentsInGlobalStore);
     builder.Else();
     // When dealing with constant types, the type may be allowed to change, as
     // long as optimized code remains valid.
     if (cell_type == PropertyCellType::kConstantType) {
       switch (stub->constant_type()) {
         case PropertyCellConstantType::kSmi:
           access = access.WithRepresentation(Representation::Smi());
           break;
         case PropertyCellConstantType::kStableMap: {
           // It is sufficient here to check that the value and cell contents
           // have identical maps, no matter if they are stable or not or if they
           // are the maps that were originally in the cell or not. If optimized
           // code will deopt when a cell has a unstable map and if it has a
           // dependency on a stable map, it will deopt if the map destabilizes.
           Add<HCheckHeapObject>(value);
           Add<HCheckHeapObject>(cell_contents);
           HValue* expected_map = Add<HLoadNamedField>(cell_contents, nullptr,
                                                       HObjectAccess::ForMap());
           HValue* map =
               Add<HLoadNamedField>(value, nullptr, HObjectAccess::ForMap());
           IfBuilder map_check(this);
           map_check.IfNot<HCompareObjectEqAndBranch>(expected_map, map);
-          map_check.ThenDeopt(Deoptimizer::kUnknownMap);
+          map_check.ThenDeopt(DeoptimizeReason::kUnknownMap);
           map_check.End();
           access = access.WithRepresentation(Representation::HeapObject());
           break;
         }
       }
     }
     Add<HStoreNamedField>(cell, access, value);
     builder.End();
   }
 
   return value;
 }
 
 
 Handle<Code> StoreGlobalStub::GenerateCode() {
   return DoGenerateCode(this);
 }
 
 
 template <>
 HValue* CodeStubGraphBuilder<ElementsTransitionAndStoreStub>::BuildCodeStub() {
   HValue* object = GetParameter(StoreTransitionHelper::ReceiverIndex());
   HValue* key = GetParameter(StoreTransitionHelper::NameIndex());
   HValue* value = GetParameter(StoreTransitionHelper::ValueIndex());
   HValue* map = GetParameter(StoreTransitionHelper::MapIndex());
 
   if (FLAG_trace_elements_transitions) {
     // Tracing elements transitions is the job of the runtime.
-    Add<HDeoptimize>(Deoptimizer::kTracingElementsTransitions,
+    Add<HDeoptimize>(DeoptimizeReason::kTracingElementsTransitions,
                      Deoptimizer::EAGER);
   } else {
     info()->MarkAsSavesCallerDoubles();
 
     BuildTransitionElementsKind(object, map,
                                 casted_stub()->from_kind(),
                                 casted_stub()->to_kind(),
                                 casted_stub()->is_jsarray());
 
     BuildUncheckedMonomorphicElementAccess(object, key, value,
@@ skipping 174 matching lines @@
       Push(BuildUncheckedDictionaryElementLoad(receiver, elements, key, hash));
     }
     kind_if.Else();
 
     // The SLOW_SLOPPY_ARGUMENTS_ELEMENTS check generates a "kind_if.Then"
     STATIC_ASSERT(FAST_SLOPPY_ARGUMENTS_ELEMENTS <
                   SLOW_SLOPPY_ARGUMENTS_ELEMENTS);
     BuildElementsKindLimitCheck(&kind_if, bit_field2,
                                 SLOW_SLOPPY_ARGUMENTS_ELEMENTS);
     // Non-strict elements are not handled.
-    Add<HDeoptimize>(Deoptimizer::kNonStrictElementsInKeyedLoadGenericStub,
+    Add<HDeoptimize>(DeoptimizeReason::kNonStrictElementsInKeyedLoadGenericStub,
                      Deoptimizer::EAGER);
     Push(graph()->GetConstant0());
 
     kind_if.ElseDeopt(
-        Deoptimizer::kElementsKindUnhandledInKeyedLoadGenericStub);
+        DeoptimizeReason::kElementsKindUnhandledInKeyedLoadGenericStub);
 
     kind_if.End();
   }
   index_name_split.Else();
   {
     // Key is a unique string.
     key = Pop();
 
     int bit_field_mask = (1 << Map::kIsAccessCheckNeeded) |
         (1 << Map::kHasNamedInterceptor);
@@ skipping 104 matching lines @@
   return Pop();
 }
 
 
 Handle<Code> KeyedLoadGenericStub::GenerateCode() {
   return DoGenerateCode(this);
 }
 
 }  // namespace internal
 }  // namespace v8