Use asserts instead of branches to avoid fast array methods for observed arrays

src/builtins.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 507 matching lines @@
   Heap* heap = isolate->heap();
   Object* receiver = *args.receiver();
   FixedArrayBase* elms_obj;
   MaybeObject* maybe_elms_obj =
       EnsureJSArrayWithWritableFastElements(heap, receiver, &args, 1);
   if (maybe_elms_obj == NULL) {
     return CallJsBuiltin(isolate, "ArrayPush", args);
   }
   if (!maybe_elms_obj->To(&elms_obj)) return maybe_elms_obj;
 
-  if (FLAG_harmony_observation &&
-      JSObject::cast(receiver)->map()->is_observed()) {
-    return CallJsBuiltin(isolate, "ArrayPush", args);
-  }
+  JSArray* array = JSArray::cast(receiver);
+  ASSERT(!array->map()->is_observed());
 
-  JSArray* array = JSArray::cast(receiver);
   ElementsKind kind = array->GetElementsKind();
 
   if (IsFastSmiOrObjectElementsKind(kind)) {
     FixedArray* elms = FixedArray::cast(elms_obj);
 
     int len = Smi::cast(array->length())->value();
     int to_add = args.length() - 1;
     if (to_add == 0) {
       return Smi::FromInt(len);
     }
@@ skipping 91 matching lines @@
 BUILTIN(ArrayPop) {
   Heap* heap = isolate->heap();
   Object* receiver = *args.receiver();
   FixedArrayBase* elms_obj;
   MaybeObject* maybe_elms =
       EnsureJSArrayWithWritableFastElements(heap, receiver, NULL, 0);
   if (maybe_elms == NULL) return CallJsBuiltin(isolate, "ArrayPop", args);
   if (!maybe_elms->To(&elms_obj)) return maybe_elms;
 
   JSArray* array = JSArray::cast(receiver);
-
-  if (FLAG_harmony_observation && array->map()->is_observed()) {
-    return CallJsBuiltin(isolate, "ArrayPop", args);
-  }
+  ASSERT(!array->map()->is_observed());
 
   int len = Smi::cast(array->length())->value();
   if (len == 0) return heap->undefined_value();
 
   ElementsAccessor* accessor = array->GetElementsAccessor();
   int new_length = len - 1;
   MaybeObject* maybe_result;
   if (accessor->HasElement(array, array, new_length, elms_obj)) {
     maybe_result = accessor->Get(array, array, new_length, elms_obj);
   } else {
@@ skipping 14 matching lines @@
   MaybeObject* maybe_elms_obj =
       EnsureJSArrayWithWritableFastElements(heap, receiver, NULL, 0);
   if (maybe_elms_obj == NULL)
       return CallJsBuiltin(isolate, "ArrayShift", args);
   if (!maybe_elms_obj->To(&elms_obj)) return maybe_elms_obj;
 
   if (!IsJSArrayFastElementMovingAllowed(heap, JSArray::cast(receiver))) {
     return CallJsBuiltin(isolate, "ArrayShift", args);
   }
   JSArray* array = JSArray::cast(receiver);
-
-  if (FLAG_harmony_observation && array->map()->is_observed()) {
-    return CallJsBuiltin(isolate, "ArrayShift", args);
-  }
+  ASSERT(!array->map()->is_observed());
 
   int len = Smi::cast(array->length())->value();
   if (len == 0) return heap->undefined_value();
 
   // Get first element
   ElementsAccessor* accessor = array->GetElementsAccessor();
   Object* first;
   MaybeObject* maybe_first = accessor->Get(receiver, array, 0, elms_obj);
   if (!maybe_first->To(&first)) return maybe_first;
   if (first->IsTheHole()) {
@@ skipping 30 matching lines @@
   MaybeObject* maybe_elms_obj =
       EnsureJSArrayWithWritableFastElements(heap, receiver, NULL, 0);
   if (maybe_elms_obj == NULL)
       return CallJsBuiltin(isolate, "ArrayUnshift", args);
   if (!maybe_elms_obj->To(&elms_obj)) return maybe_elms_obj;
 
   if (!IsJSArrayFastElementMovingAllowed(heap, JSArray::cast(receiver))) {
     return CallJsBuiltin(isolate, "ArrayUnshift", args);
   }
   JSArray* array = JSArray::cast(receiver);
+  ASSERT(!array->map()->is_observed());
   if (!array->HasFastSmiOrObjectElements()) {
     return CallJsBuiltin(isolate, "ArrayUnshift", args);
   }
   FixedArray* elms = FixedArray::cast(elms_obj);
 
-  if (FLAG_harmony_observation && array->map()->is_observed()) {
-    return CallJsBuiltin(isolate, "ArrayUnshift", args);
-  }
-
   int len = Smi::cast(array->length())->value();
   int to_add = args.length() - 1;
   int new_length = len + to_add;
   // Currently fixed arrays cannot grow too big, so
   // we should never hit this case.
   ASSERT(to_add <= (Smi::kMaxValue - len));
 
   MaybeObject* maybe_object =
       array->EnsureCanContainElements(&args, 1, to_add,
                                       DONT_ALLOW_DOUBLE_ELEMENTS);
@@ skipping 175 matching lines @@
       EnsureJSArrayWithWritableFastElements(heap, receiver, &args, 3);
   if (maybe_elms == NULL) {
     return CallJsBuiltin(isolate, "ArraySplice", args);
   }
   if (!maybe_elms->To(&elms_obj)) return maybe_elms;
 
   if (!IsJSArrayFastElementMovingAllowed(heap, JSArray::cast(receiver))) {
     return CallJsBuiltin(isolate, "ArraySplice", args);
   }
   JSArray* array = JSArray::cast(receiver);
-
-  if (FLAG_harmony_observation && array->map()->is_observed()) {
-    return CallJsBuiltin(isolate, "ArraySplice", args);
-  }
+  ASSERT(!array->map()->is_observed());
 
   int len = Smi::cast(array->length())->value();
 
   int n_arguments = args.length() - 1;
 
   int relative_start = 0;
   if (n_arguments > 0) {
     Object* arg1 = args[1];
     if (arg1->IsSmi()) {
       relative_start = Smi::cast(arg1)->value();
@@ skipping 935 matching lines @@
   return Handle<Code>(code_address);                        \
 }
 BUILTIN_LIST_C(DEFINE_BUILTIN_ACCESSOR_C)
 BUILTIN_LIST_A(DEFINE_BUILTIN_ACCESSOR_A)
 BUILTIN_LIST_DEBUG_A(DEFINE_BUILTIN_ACCESSOR_A)
 #undef DEFINE_BUILTIN_ACCESSOR_C
 #undef DEFINE_BUILTIN_ACCESSOR_A
 
 
 } }  // namespace v8::internal