[builtins] move builtin files to src/builtins/.

src/builtins/builtins.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/builtins.h"
+#include "src/builtins/builtins.h"
 
 #include "src/api-arguments.h"
 #include "src/api-natives.h"
 #include "src/api.h"
 #include "src/base/ieee754.h"
 #include "src/base/once.h"
 #include "src/bootstrapper.h"
 #include "src/code-factory.h"
 #include "src/code-stub-assembler.h"
 #include "src/dateparser-inl.h"
@@ skipping 20 matching lines @@
 
 // Arguments object passed to C++ builtins.
 class BuiltinArguments : public Arguments {
  public:
   BuiltinArguments(int length, Object** arguments)
       : Arguments(length, arguments) {
     // Check we have at least the receiver.
     DCHECK_LE(1, this->length());
   }
 
-  Object*& operator[] (int index) {
+  Object*& operator[](int index) {
     DCHECK_LT(index, length());
     return Arguments::operator[](index);
   }
 
-  template <class S> Handle<S> at(int index) {
+  template <class S>
+  Handle<S> at(int index) {
     DCHECK_LT(index, length());
     return Arguments::at<S>(index);
   }
 
   Handle<Object> atOrUndefined(Isolate* isolate, int index) {
     if (index >= length()) {
       return isolate->factory()->undefined_value();
     }
     return at<Object>(index);
   }
 
-  Handle<Object> receiver() {
-    return Arguments::at<Object>(0);
-  }
+  Handle<Object> receiver() { return Arguments::at<Object>(0); }
 
   static const int kNewTargetOffset = 0;
   static const int kTargetOffset = 1;
   static const int kArgcOffset = 2;
   static const int kNumExtraArgs = 3;
   static const int kNumExtraArgsWithReceiver = 4;
 
   template <class S>
   Handle<S> target() {
     return Arguments::at<S>(Arguments::length() - 1 - kTargetOffset);
   }
   Handle<HeapObject> new_target() {
     return Arguments::at<HeapObject>(Arguments::length() - 1 -
                                      kNewTargetOffset);
   }
 
   // Gets the total number of arguments including the receiver (but
   // excluding extra arguments).
   int length() const { return Arguments::length() - kNumExtraArgs; }
 };
 
-
 // ----------------------------------------------------------------------------
 // Support macro for defining builtins in C++.
 // ----------------------------------------------------------------------------
 //
 // A builtin function is defined by writing:
 //
 //   BUILTIN(name) {
 //     ...
 //   }
 //
@@ skipping 74 matching lines @@
   } else if (object->IsUndefined(isolate) || object->IsNull(isolate)) {
     *out = 0;
     return true;
   } else if (object->IsBoolean()) {
     *out = object->IsTrue(isolate);
     return true;
   }
   return false;
 }
 
-
 inline bool GetSloppyArgumentsLength(Isolate* isolate, Handle<JSObject> object,
                                      int* out) {
   Context* context = *isolate->native_context();
   Map* map = object->map();
   if (map != context->sloppy_arguments_map() &&
       map != context->strict_arguments_map() &&
       map != context->fast_aliased_arguments_map()) {
     return false;
   }
   DCHECK(object->HasFastElements() || object->HasFastArgumentsElements());
@@ skipping 94 matching lines @@
     JSObject::TransitionElementsKind(array, target_kind);
   }
   return true;
 }
 
 MUST_USE_RESULT static Object* CallJsIntrinsic(Isolate* isolate,
                                                Handle<JSFunction> function,
                                                BuiltinArguments args) {
   HandleScope handleScope(isolate);
   int argc = args.length() - 1;
-  ScopedVector<Handle<Object> > argv(argc);
+  ScopedVector<Handle<Object>> argv(argc);
   for (int i = 0; i < argc; ++i) {
     argv[i] = args.at<Object>(i + 1);
   }
   RETURN_RESULT_OR_FAILURE(
       isolate,
       Execution::Call(isolate, function, args.receiver(), argc, argv.start()));
 }
 
-
 }  // namespace
 
-
 BUILTIN(Illegal) {
   UNREACHABLE();
   return isolate->heap()->undefined_value();  // Make compiler happy.
 }
 
-
 BUILTIN(EmptyFunction) { return isolate->heap()->undefined_value(); }
 
 void Builtins::Generate_ArrayIsArray(CodeStubAssembler* assembler) {
   typedef compiler::Node Node;
   typedef CodeStubAssembler::Label Label;
 
   Node* object = assembler->Parameter(1);
   Node* context = assembler->Parameter(4);
 
   Label call_runtime(assembler), return_true(assembler),
@@ skipping 132 matching lines @@
   } else {
     // Use Slow Lookup otherwise
     uint32_t new_length = len - 1;
     ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
         isolate, result, JSReceiver::GetElement(isolate, array, new_length));
     JSArray::SetLength(array, new_length);
   }
   return *result;
 }
 
-
 BUILTIN(ArrayShift) {
   HandleScope scope(isolate);
   Heap* heap = isolate->heap();
   Handle<Object> receiver = args.receiver();
   if (!EnsureJSArrayWithWritableFastElements(isolate, receiver, nullptr, 0) ||
       !IsJSArrayFastElementMovingAllowed(isolate, JSArray::cast(*receiver))) {
     return CallJsIntrinsic(isolate, isolate->array_shift(), args);
   }
   Handle<JSArray> array = Handle<JSArray>::cast(receiver);
 
   int len = Smi::cast(array->length())->value();
   if (len == 0) return heap->undefined_value();
 
   if (JSArray::HasReadOnlyLength(array)) {
     return CallJsIntrinsic(isolate, isolate->array_shift(), args);
   }
 
   Handle<Object> first = array->GetElementsAccessor()->Shift(array);
   return *first;
 }
 
-
 BUILTIN(ArrayUnshift) {
   HandleScope scope(isolate);
   Handle<Object> receiver = args.receiver();
   if (!EnsureJSArrayWithWritableFastElements(isolate, receiver, &args, 1)) {
     return CallJsIntrinsic(isolate, isolate->array_unshift(), args);
   }
   Handle<JSArray> array = Handle<JSArray>::cast(receiver);
   int to_add = args.length() - 1;
   if (to_add == 0) return array->length();
 
   // Currently fixed arrays cannot grow too big, so we should never hit this.
   DCHECK_LE(to_add, Smi::kMaxValue - Smi::cast(array->length())->value());
 
   if (JSArray::HasReadOnlyLength(array)) {
     return CallJsIntrinsic(isolate, isolate->array_unshift(), args);
   }
 
   ElementsAccessor* accessor = array->GetElementsAccessor();
   int new_length = accessor->Unshift(array, &args, to_add);
   return Smi::FromInt(new_length);
 }
 
-
 BUILTIN(ArraySlice) {
   HandleScope scope(isolate);
   Handle<Object> receiver = args.receiver();
   int len = -1;
   int relative_start = 0;
   int relative_end = 0;
 
   if (receiver->IsJSArray()) {
     DisallowHeapAllocation no_gc;
     JSArray* array = JSArray::cast(*receiver);
@@ skipping 49 matching lines @@
 
   // ECMAScript 232, 3rd Edition, Section 15.4.4.10, step 8.
   uint32_t actual_end =
       (relative_end < 0) ? Max(len + relative_end, 0) : Min(relative_end, len);
 
   Handle<JSObject> object = Handle<JSObject>::cast(receiver);
   ElementsAccessor* accessor = object->GetElementsAccessor();
   return *accessor->Slice(object, actual_start, actual_end);
 }
 
-
 BUILTIN(ArraySplice) {
   HandleScope scope(isolate);
   Handle<Object> receiver = args.receiver();
   if (V8_UNLIKELY(
           !EnsureJSArrayWithWritableFastElements(isolate, receiver, &args, 3) ||
           // If this is a subclass of Array, then call out to JS.
           !Handle<JSArray>::cast(receiver)->HasArrayPrototype(isolate) ||
           // If anything with @@species has been messed with, call out to JS.
           !isolate->IsArraySpeciesLookupChainIntact())) {
     return CallJsIntrinsic(isolate, isolate->array_splice(), args);
@@ skipping 40 matching lines @@
   if (new_length != len && JSArray::HasReadOnlyLength(array)) {
     AllowHeapAllocation allow_allocation;
     return CallJsIntrinsic(isolate, isolate->array_splice(), args);
   }
   ElementsAccessor* accessor = array->GetElementsAccessor();
   Handle<JSArray> result_array = accessor->Splice(
       array, actual_start, actual_delete_count, &args, add_count);
   return *result_array;
 }
 
-
 // Array Concat -------------------------------------------------------------
 
 namespace {
 
 /**
  * A simple visitor visits every element of Array's.
  * The backend storage can be a fixed array for fast elements case,
  * or a dictionary for sparse array. Since Dictionary is a subtype
  * of FixedArray, the class can be used by both fast and slow cases.
  * The second parameter of the constructor, fast_elements, specifies
@@ skipping 155 matching lines @@
   bool is_fixed_array() const { return IsFixedArrayField::decode(bit_field_); }
 
   Isolate* isolate_;
   Handle<Object> storage_;  // Always a global handle.
   // Index after last seen index. Always less than or equal to
   // JSObject::kMaxElementCount.
   uint32_t index_offset_;
   uint32_t bit_field_;
 };
 
-
 uint32_t EstimateElementCount(Handle<JSArray> array) {
   DisallowHeapAllocation no_gc;
   uint32_t length = static_cast<uint32_t>(array->length()->Number());
   int element_count = 0;
   switch (array->GetElementsKind()) {
     case FAST_SMI_ELEMENTS:
     case FAST_HOLEY_SMI_ELEMENTS:
     case FAST_ELEMENTS:
     case FAST_HOLEY_ELEMENTS: {
       // Fast elements can't have lengths that are not representable by
@@ skipping 49 matching lines @@
     case FAST_STRING_WRAPPER_ELEMENTS:
     case SLOW_STRING_WRAPPER_ELEMENTS:
       UNREACHABLE();
       return 0;
   }
   // As an estimate, we assume that the prototype doesn't contain any
   // inherited elements.
   return element_count;
 }
 
-
 // Used for sorting indices in a List<uint32_t>.
 int compareUInt32(const uint32_t* ap, const uint32_t* bp) {
   uint32_t a = *ap;
   uint32_t b = *bp;
   return (a == b) ? 0 : (a < b) ? -1 : 1;
 }
 
-
 void CollectElementIndices(Handle<JSObject> object, uint32_t range,
                            List<uint32_t>* indices) {
   Isolate* isolate = object->GetIsolate();
   ElementsKind kind = object->GetElementsKind();
   switch (kind) {
     case FAST_SMI_ELEMENTS:
     case FAST_ELEMENTS:
     case FAST_HOLEY_SMI_ELEMENTS:
     case FAST_HOLEY_ELEMENTS: {
       DisallowHeapAllocation no_gc;
@@ skipping 95 matching lines @@
 
   PrototypeIterator iter(isolate, object);
   if (!iter.IsAtEnd()) {
     // The prototype will usually have no inherited element indices,
     // but we have to check.
     CollectElementIndices(PrototypeIterator::GetCurrent<JSObject>(iter), range,
                           indices);
   }
 }
 
-
 bool IterateElementsSlow(Isolate* isolate, Handle<JSReceiver> receiver,
                          uint32_t length, ArrayConcatVisitor* visitor) {
   FOR_WITH_HANDLE_SCOPE(isolate, uint32_t, i = 0, i, i < length, ++i, {
     Maybe<bool> maybe = JSReceiver::HasElement(receiver, i);
     if (!maybe.IsJust()) return false;
     if (maybe.FromJust()) {
       Handle<Object> element_value;
       ASSIGN_RETURN_ON_EXCEPTION_VALUE(
           isolate, element_value, JSReceiver::GetElement(isolate, receiver, i),
           false);
       if (!visitor->visit(i, element_value)) return false;
     }
   });
   visitor->increase_index_offset(length);
   return true;
 }
 
-
 /**
  * A helper function that visits "array" elements of a JSReceiver in numerical
  * order.
  *
  * The visitor argument called for each existing element in the array
  * with the element index and the element's value.
  * Afterwards it increments the base-index of the visitor by the array
  * length.
  * Returns false if any access threw an exception, otherwise true.
  */
@@ skipping 392 matching lines @@
                         NewRangeError(MessageTemplate::kInvalidArrayLength),
                         JSArray);
       }
     }
   }
   return ElementsAccessor::Concat(isolate, args, n_arguments, result_len);
 }
 
 }  // namespace
 
-
 // ES6 22.1.3.1 Array.prototype.concat
 BUILTIN(ArrayConcat) {
   HandleScope scope(isolate);
 
   Handle<Object> receiver = args.receiver();
   // TODO(bmeurer): Do we really care about the exact exception message here?
   if (receiver->IsNull(isolate) || receiver->IsUndefined(isolate)) {
     THROW_NEW_ERROR_RETURN_FAILURE(
         isolate, NewTypeError(MessageTemplate::kCalledOnNullOrUndefined,
                               isolate->factory()->NewStringFromAsciiChecked(
@@ skipping 21 matching lines @@
       isolate, species, Object::ArraySpeciesConstructor(isolate, receiver));
   if (*species == *isolate->array_function()) {
     if (Fast_ArrayConcat(isolate, &args).ToHandle(&result_array)) {
       return *result_array;
     }
     if (isolate->has_pending_exception()) return isolate->heap()->exception();
   }
   return Slow_ArrayConcat(&args, species, isolate);
 }
 
-
 namespace {
 
 MUST_USE_RESULT Maybe<bool> FastAssign(Handle<JSReceiver> to,
                                        Handle<Object> next_source) {
   // Non-empty strings are the only non-JSReceivers that need to be handled
   // explicitly by Object.assign.
   if (!next_source->IsJSReceiver()) {
     return Just(!next_source->IsString() ||
                 String::cast(*next_source)->length() == 0);
   }
@@ skipping 119 matching lines @@
         ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
             isolate, status, Runtime::SetObjectProperty(isolate, to, next_key,
                                                         prop_value, STRICT));
       }
     }
   }
   // 5. Return to.
   return *to;
 }
 
-
 // ES6 section 19.1.2.2 Object.create ( O [ , Properties ] )
 // TODO(verwaest): Support the common cases with precached map directly in
 // an Object.create stub.
 BUILTIN(ObjectCreate) {
   HandleScope scope(isolate);
   Handle<Object> prototype = args.atOrUndefined(isolate, 1);
   if (!prototype->IsNull(isolate) && !prototype->IsJSReceiver()) {
     THROW_NEW_ERROR_RETURN_FAILURE(
         isolate, NewTypeError(MessageTemplate::kProtoObjectOrNull, prototype));
   }
@@ skipping 196 matching lines @@
   HandleScope scope(isolate);
   Handle<Object> object = args.atOrUndefined(isolate, 1);
   if (object->IsJSReceiver()) {
     MAYBE_RETURN(JSReceiver::SetIntegrityLevel(Handle<JSReceiver>::cast(object),
                                                FROZEN, Object::THROW_ON_ERROR),
                  isolate->heap()->exception());
   }
   return *object;
 }
 
-
 // ES section 19.1.2.9 Object.getPrototypeOf ( O )
 BUILTIN(ObjectGetPrototypeOf) {
   HandleScope scope(isolate);
   Handle<Object> object = args.atOrUndefined(isolate, 1);
 
   Handle<JSReceiver> receiver;
-  ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
-      isolate, receiver, Object::ToObject(isolate, object));
+  ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, receiver,
+                                     Object::ToObject(isolate, object));
 
   RETURN_RESULT_OR_FAILURE(isolate,
                            JSReceiver::GetPrototype(isolate, receiver));
 }
 
-
 // ES6 section 19.1.2.6 Object.getOwnPropertyDescriptor ( O, P )
 BUILTIN(ObjectGetOwnPropertyDescriptor) {
   HandleScope scope(isolate);
   // 1. Let obj be ? ToObject(O).
   Handle<Object> object = args.atOrUndefined(isolate, 1);
   Handle<JSReceiver> receiver;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, receiver,
                                      Object::ToObject(isolate, object));
   // 2. Let key be ? ToPropertyKey(P).
   Handle<Object> property = args.atOrUndefined(isolate, 2);
   Handle<Name> key;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, key,
                                      Object::ToName(isolate, property));
   // 3. Let desc be ? obj.[[GetOwnProperty]](key).
   PropertyDescriptor desc;
   Maybe<bool> found =
       JSReceiver::GetOwnPropertyDescriptor(isolate, receiver, key, &desc);
   MAYBE_RETURN(found, isolate->heap()->exception());
   // 4. Return FromPropertyDescriptor(desc).
   if (!found.FromJust()) return isolate->heap()->undefined_value();
   return *desc.ToObject(isolate);
 }
 
-
 namespace {
 
 Object* GetOwnPropertyKeys(Isolate* isolate, BuiltinArguments args,
                            PropertyFilter filter) {
   HandleScope scope(isolate);
   Handle<Object> object = args.atOrUndefined(isolate, 1);
   Handle<JSReceiver> receiver;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, receiver,
                                      Object::ToObject(isolate, object));
   Handle<FixedArray> keys;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
       isolate, keys,
       KeyAccumulator::GetKeys(receiver, KeyCollectionMode::kOwnOnly, filter,
                               GetKeysConversion::kConvertToString));
   return *isolate->factory()->NewJSArrayWithElements(keys);
 }
 
 }  // namespace
 
-
 // ES6 section 19.1.2.7 Object.getOwnPropertyNames ( O )
 BUILTIN(ObjectGetOwnPropertyNames) {
   return GetOwnPropertyKeys(isolate, args, SKIP_SYMBOLS);
 }
 
-
 // ES6 section 19.1.2.8 Object.getOwnPropertySymbols ( O )
 BUILTIN(ObjectGetOwnPropertySymbols) {
   return GetOwnPropertyKeys(isolate, args, SKIP_STRINGS);
 }
 
-
 // ES#sec-object.is Object.is ( value1, value2 )
 BUILTIN(ObjectIs) {
   SealHandleScope shs(isolate);
   DCHECK_EQ(3, args.length());
   Handle<Object> value1 = args.at<Object>(1);
   Handle<Object> value2 = args.at<Object>(2);
   return isolate->heap()->ToBoolean(value1->SameValue(*value2));
 }
 
-
 // ES6 section 19.1.2.11 Object.isExtensible ( O )
 BUILTIN(ObjectIsExtensible) {
   HandleScope scope(isolate);
   Handle<Object> object = args.atOrUndefined(isolate, 1);
   Maybe<bool> result =
       object->IsJSReceiver()
           ? JSReceiver::IsExtensible(Handle<JSReceiver>::cast(object))
           : Just(false);
   MAYBE_RETURN(result, isolate->heap()->exception());
   return isolate->heap()->ToBoolean(result.FromJust());
 }
 
-
 // ES6 section 19.1.2.12 Object.isFrozen ( O )
 BUILTIN(ObjectIsFrozen) {
   HandleScope scope(isolate);
   Handle<Object> object = args.atOrUndefined(isolate, 1);
   Maybe<bool> result = object->IsJSReceiver()
                            ? JSReceiver::TestIntegrityLevel(
                                  Handle<JSReceiver>::cast(object), FROZEN)
                            : Just(true);
   MAYBE_RETURN(result, isolate->heap()->exception());
   return isolate->heap()->ToBoolean(result.FromJust());
 }
 
-
 // ES6 section 19.1.2.13 Object.isSealed ( O )
 BUILTIN(ObjectIsSealed) {
   HandleScope scope(isolate);
   Handle<Object> object = args.atOrUndefined(isolate, 1);
   Maybe<bool> result = object->IsJSReceiver()
                            ? JSReceiver::TestIntegrityLevel(
                                  Handle<JSReceiver>::cast(object), SEALED)
                            : Just(true);
   MAYBE_RETURN(result, isolate->heap()->exception());
   return isolate->heap()->ToBoolean(result.FromJust());
 }
 
-
 // ES6 section 19.1.2.14 Object.keys ( O )
 BUILTIN(ObjectKeys) {
   HandleScope scope(isolate);
   Handle<Object> object = args.atOrUndefined(isolate, 1);
   Handle<JSReceiver> receiver;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, receiver,
                                      Object::ToObject(isolate, object));
 
   Handle<FixedArray> keys;
   int enum_length = receiver->map()->EnumLength();
@@ skipping 27 matching lines @@
   Handle<Object> object = args.atOrUndefined(isolate, 1);
   Handle<JSReceiver> receiver;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, receiver,
                                      Object::ToObject(isolate, object));
   Handle<FixedArray> values;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
       isolate, values, JSReceiver::GetOwnValues(receiver, ENUMERABLE_STRINGS));
   return *isolate->factory()->NewJSArrayWithElements(values);
 }
 
-
 BUILTIN(ObjectEntries) {
   HandleScope scope(isolate);
   Handle<Object> object = args.atOrUndefined(isolate, 1);
   Handle<JSReceiver> receiver;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, receiver,
                                      Object::ToObject(isolate, object));
   Handle<FixedArray> entries;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
       isolate, entries,
       JSReceiver::GetOwnEntries(receiver, ENUMERABLE_STRINGS));
@@ skipping 42 matching lines @@
   HandleScope scope(isolate);
   Handle<Object> object = args.atOrUndefined(isolate, 1);
   if (object->IsJSReceiver()) {
     MAYBE_RETURN(JSReceiver::PreventExtensions(Handle<JSReceiver>::cast(object),
                                                Object::THROW_ON_ERROR),
                  isolate->heap()->exception());
   }
   return *object;
 }
 
-
 // ES6 section 19.1.2.17 Object.seal ( O )
 BUILTIN(ObjectSeal) {
   HandleScope scope(isolate);
   Handle<Object> object = args.atOrUndefined(isolate, 1);
   if (object->IsJSReceiver()) {
     MAYBE_RETURN(JSReceiver::SetIntegrityLevel(Handle<JSReceiver>::cast(object),
                                                SEALED, Object::THROW_ON_ERROR),
                  isolate->heap()->exception());
   }
   return *object;
@@ skipping 77 matching lines @@
   if (callback == NULL) {
     // No callback set and code generation disallowed.
     return false;
   } else {
     // Callback set. Let it decide if code generation is allowed.
     VMState<EXTERNAL> state(isolate);
     return callback(v8::Utils::ToLocal(context));
   }
 }
 
-
 MaybeHandle<JSFunction> CompileString(Handle<Context> context,
                                       Handle<String> source,
                                       ParseRestriction restriction) {
   Isolate* const isolate = context->GetIsolate();
   Handle<Context> native_context(context->native_context(), isolate);
 
   // Check if native context allows code generation from
   // strings. Throw an exception if it doesn't.
   if (native_context->allow_code_gen_from_strings()->IsFalse(isolate) &&
       !CodeGenerationFromStringsAllowed(isolate, native_context)) {
     Handle<Object> error_message =
         native_context->ErrorMessageForCodeGenerationFromStrings();
     THROW_NEW_ERROR(isolate, NewEvalError(MessageTemplate::kCodeGenFromStrings,
                                           error_message),
                     JSFunction);
   }
 
   // Compile source string in the native context.
   int eval_scope_position = 0;
   int eval_position = kNoSourcePosition;
   Handle<SharedFunctionInfo> outer_info(native_context->closure()->shared());
   return Compiler::GetFunctionFromEval(source, outer_info, native_context,
                                        SLOPPY, restriction, eval_scope_position,
                                        eval_position);
 }
 
 }  // namespace
 
-
 // ES6 section 18.2.1 eval (x)
 BUILTIN(GlobalEval) {
   HandleScope scope(isolate);
   Handle<Object> x = args.atOrUndefined(isolate, 1);
   Handle<JSFunction> target = args.target<JSFunction>();
   Handle<JSObject> target_global_proxy(target->global_proxy(), isolate);
   if (!x->IsString()) return *x;
   Handle<JSFunction> function;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
       isolate, function,
@@ skipping 814 matching lines @@
 
 void Generate_GeneratorPrototypeResume(
     CodeStubAssembler* assembler, JSGeneratorObject::ResumeMode resume_mode,
     char const* const method_name) {
   typedef CodeStubAssembler::Label Label;
   typedef compiler::Node Node;
 
   Node* receiver = assembler->Parameter(0);
   Node* value = assembler->Parameter(1);
   Node* context = assembler->Parameter(4);
-  Node* closed = assembler->SmiConstant(
-      Smi::FromInt(JSGeneratorObject::kGeneratorClosed));
+  Node* closed =
+      assembler->SmiConstant(Smi::FromInt(JSGeneratorObject::kGeneratorClosed));
 
   // Check if the {receiver} is actually a JSGeneratorObject.
   Label if_receiverisincompatible(assembler, Label::kDeferred);
   assembler->GotoIf(assembler->WordIsSmi(receiver), &if_receiverisincompatible);
   Node* receiver_instance_type = assembler->LoadInstanceType(receiver);
   assembler->GotoUnless(assembler->Word32Equal(
                             receiver_instance_type,
                             assembler->Int32Constant(JS_GENERATOR_OBJECT_TYPE)),
                         &if_receiverisincompatible);
 
@@ skipping 103 matching lines @@
     return isolate->heap()->exception();
   }
 
   Maybe<bool> result =
       JSReceiver::DefineOwnProperty(isolate, Handle<JSReceiver>::cast(target),
                                     name, &desc, Object::DONT_THROW);
   MAYBE_RETURN(result, isolate->heap()->exception());
   return *isolate->factory()->ToBoolean(result.FromJust());
 }
 
-
 // ES6 section 26.1.4 Reflect.deleteProperty
 BUILTIN(ReflectDeleteProperty) {
   HandleScope scope(isolate);
   DCHECK_EQ(3, args.length());
   Handle<Object> target = args.at<Object>(1);
   Handle<Object> key = args.at<Object>(2);
 
   if (!target->IsJSReceiver()) {
     THROW_NEW_ERROR_RETURN_FAILURE(
         isolate, NewTypeError(MessageTemplate::kCalledOnNonObject,
                               isolate->factory()->NewStringFromAsciiChecked(
                                   "Reflect.deleteProperty")));
   }
 
   Handle<Name> name;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, name,
                                      Object::ToName(isolate, key));
 
   Maybe<bool> result = JSReceiver::DeletePropertyOrElement(
       Handle<JSReceiver>::cast(target), name, SLOPPY);
   MAYBE_RETURN(result, isolate->heap()->exception());
   return *isolate->factory()->ToBoolean(result.FromJust());
 }
 
-
 // ES6 section 26.1.6 Reflect.get
 BUILTIN(ReflectGet) {
   HandleScope scope(isolate);
   Handle<Object> target = args.atOrUndefined(isolate, 1);
   Handle<Object> key = args.atOrUndefined(isolate, 2);
   Handle<Object> receiver = args.length() > 3 ? args.at<Object>(3) : target;
 
   if (!target->IsJSReceiver()) {
     THROW_NEW_ERROR_RETURN_FAILURE(
         isolate, NewTypeError(MessageTemplate::kCalledOnNonObject,
                               isolate->factory()->NewStringFromAsciiChecked(
                                   "Reflect.get")));
   }
 
   Handle<Name> name;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, name,
                                      Object::ToName(isolate, key));
 
   RETURN_RESULT_OR_FAILURE(
       isolate, Object::GetPropertyOrElement(receiver, name,
                                             Handle<JSReceiver>::cast(target)));
 }
 
-
 // ES6 section 26.1.7 Reflect.getOwnPropertyDescriptor
 BUILTIN(ReflectGetOwnPropertyDescriptor) {
   HandleScope scope(isolate);
   DCHECK_EQ(3, args.length());
   Handle<Object> target = args.at<Object>(1);
   Handle<Object> key = args.at<Object>(2);
 
   if (!target->IsJSReceiver()) {
     THROW_NEW_ERROR_RETURN_FAILURE(
         isolate, NewTypeError(MessageTemplate::kCalledOnNonObject,
                               isolate->factory()->NewStringFromAsciiChecked(
                                   "Reflect.getOwnPropertyDescriptor")));
   }
 
   Handle<Name> name;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, name,
                                      Object::ToName(isolate, key));
 
   PropertyDescriptor desc;
   Maybe<bool> found = JSReceiver::GetOwnPropertyDescriptor(
       isolate, Handle<JSReceiver>::cast(target), name, &desc);
   MAYBE_RETURN(found, isolate->heap()->exception());
   if (!found.FromJust()) return isolate->heap()->undefined_value();
   return *desc.ToObject(isolate);
 }
 
-
 // ES6 section 26.1.8 Reflect.getPrototypeOf
 BUILTIN(ReflectGetPrototypeOf) {
   HandleScope scope(isolate);
   DCHECK_EQ(2, args.length());
   Handle<Object> target = args.at<Object>(1);
 
   if (!target->IsJSReceiver()) {
     THROW_NEW_ERROR_RETURN_FAILURE(
         isolate, NewTypeError(MessageTemplate::kCalledOnNonObject,
                               isolate->factory()->NewStringFromAsciiChecked(
                                   "Reflect.getPrototypeOf")));
   }
   Handle<JSReceiver> receiver = Handle<JSReceiver>::cast(target);
   RETURN_RESULT_OR_FAILURE(isolate,
                            JSReceiver::GetPrototype(isolate, receiver));
 }
 
-
 // ES6 section 26.1.9 Reflect.has
 BUILTIN(ReflectHas) {
   HandleScope scope(isolate);
   DCHECK_EQ(3, args.length());
   Handle<Object> target = args.at<Object>(1);
   Handle<Object> key = args.at<Object>(2);
 
   if (!target->IsJSReceiver()) {
     THROW_NEW_ERROR_RETURN_FAILURE(
         isolate, NewTypeError(MessageTemplate::kCalledOnNonObject,
                               isolate->factory()->NewStringFromAsciiChecked(
                                   "Reflect.has")));
   }
 
   Handle<Name> name;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, name,
                                      Object::ToName(isolate, key));
 
   Maybe<bool> result =
       JSReceiver::HasProperty(Handle<JSReceiver>::cast(target), name);
   return result.IsJust() ? *isolate->factory()->ToBoolean(result.FromJust())
                          : isolate->heap()->exception();
 }
 
-
 // ES6 section 26.1.10 Reflect.isExtensible
 BUILTIN(ReflectIsExtensible) {
   HandleScope scope(isolate);
   DCHECK_EQ(2, args.length());
   Handle<Object> target = args.at<Object>(1);
 
   if (!target->IsJSReceiver()) {
     THROW_NEW_ERROR_RETURN_FAILURE(
         isolate, NewTypeError(MessageTemplate::kCalledOnNonObject,
                               isolate->factory()->NewStringFromAsciiChecked(
                                   "Reflect.isExtensible")));
   }
 
   Maybe<bool> result =
       JSReceiver::IsExtensible(Handle<JSReceiver>::cast(target));
   MAYBE_RETURN(result, isolate->heap()->exception());
   return *isolate->factory()->ToBoolean(result.FromJust());
 }
 
-
 // ES6 section 26.1.11 Reflect.ownKeys
 BUILTIN(ReflectOwnKeys) {
   HandleScope scope(isolate);
   DCHECK_EQ(2, args.length());
   Handle<Object> target = args.at<Object>(1);
 
   if (!target->IsJSReceiver()) {
     THROW_NEW_ERROR_RETURN_FAILURE(
         isolate, NewTypeError(MessageTemplate::kCalledOnNonObject,
                               isolate->factory()->NewStringFromAsciiChecked(
                                   "Reflect.ownKeys")));
   }
 
   Handle<FixedArray> keys;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
       isolate, keys,
       KeyAccumulator::GetKeys(Handle<JSReceiver>::cast(target),
                               KeyCollectionMode::kOwnOnly, ALL_PROPERTIES,
                               GetKeysConversion::kConvertToString));
   return *isolate->factory()->NewJSArrayWithElements(keys);
 }
 
-
 // ES6 section 26.1.12 Reflect.preventExtensions
 BUILTIN(ReflectPreventExtensions) {
   HandleScope scope(isolate);
   DCHECK_EQ(2, args.length());
   Handle<Object> target = args.at<Object>(1);
 
   if (!target->IsJSReceiver()) {
     THROW_NEW_ERROR_RETURN_FAILURE(
         isolate, NewTypeError(MessageTemplate::kCalledOnNonObject,
                               isolate->factory()->NewStringFromAsciiChecked(
                                   "Reflect.preventExtensions")));
   }
 
   Maybe<bool> result = JSReceiver::PreventExtensions(
       Handle<JSReceiver>::cast(target), Object::DONT_THROW);
   MAYBE_RETURN(result, isolate->heap()->exception());
   return *isolate->factory()->ToBoolean(result.FromJust());
 }
 
-
 // ES6 section 26.1.13 Reflect.set
 BUILTIN(ReflectSet) {
   HandleScope scope(isolate);
   Handle<Object> target = args.atOrUndefined(isolate, 1);
   Handle<Object> key = args.atOrUndefined(isolate, 2);
   Handle<Object> value = args.atOrUndefined(isolate, 3);
   Handle<Object> receiver = args.length() > 4 ? args.at<Object>(4) : target;
 
   if (!target->IsJSReceiver()) {
     THROW_NEW_ERROR_RETURN_FAILURE(
         isolate, NewTypeError(MessageTemplate::kCalledOnNonObject,
                               isolate->factory()->NewStringFromAsciiChecked(
                                   "Reflect.set")));
   }
 
   Handle<Name> name;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, name,
                                      Object::ToName(isolate, key));
 
   LookupIterator it = LookupIterator::PropertyOrElement(
       isolate, receiver, name, Handle<JSReceiver>::cast(target));
   Maybe<bool> result = Object::SetSuperProperty(
       &it, value, SLOPPY, Object::MAY_BE_STORE_FROM_KEYED);
   MAYBE_RETURN(result, isolate->heap()->exception());
   return *isolate->factory()->ToBoolean(result.FromJust());
 }
 
-
 // ES6 section 26.1.14 Reflect.setPrototypeOf
 BUILTIN(ReflectSetPrototypeOf) {
   HandleScope scope(isolate);
   DCHECK_EQ(3, args.length());
   Handle<Object> target = args.at<Object>(1);
   Handle<Object> proto = args.at<Object>(2);
 
   if (!target->IsJSReceiver()) {
     THROW_NEW_ERROR_RETURN_FAILURE(
         isolate, NewTypeError(MessageTemplate::kCalledOnNonObject,
                               isolate->factory()->NewStringFromAsciiChecked(
                                   "Reflect.setPrototypeOf")));
   }
 
   if (!proto->IsJSReceiver() && !proto->IsNull(isolate)) {
     THROW_NEW_ERROR_RETURN_FAILURE(
         isolate, NewTypeError(MessageTemplate::kProtoObjectOrNull, proto));
   }
 
   Maybe<bool> result = JSReceiver::SetPrototype(
       Handle<JSReceiver>::cast(target), proto, true, Object::DONT_THROW);
   MAYBE_RETURN(result, isolate->heap()->exception());
   return *isolate->factory()->ToBoolean(result.FromJust());
 }
 
-
 // -----------------------------------------------------------------------------
 // ES6 section 19.3 Boolean Objects
 
-
 // ES6 section 19.3.1.1 Boolean ( value ) for the [[Call]] case.
 BUILTIN(BooleanConstructor) {
   HandleScope scope(isolate);
   Handle<Object> value = args.atOrUndefined(isolate, 1);
   return isolate->heap()->ToBoolean(value->BooleanValue());
 }
 
-
 // ES6 section 19.3.1.1 Boolean ( value ) for the [[Construct]] case.
 BUILTIN(BooleanConstructor_ConstructStub) {
   HandleScope scope(isolate);
   Handle<Object> value = args.atOrUndefined(isolate, 1);
   Handle<JSFunction> target = args.target<JSFunction>();
   Handle<JSReceiver> new_target = Handle<JSReceiver>::cast(args.new_target());
   DCHECK(*target == target->native_context()->boolean_function());
   Handle<JSObject> result;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, result,
                                      JSObject::New(target, new_target));
   Handle<JSValue>::cast(result)->set_value(
       isolate->heap()->ToBoolean(value->BooleanValue()));
   return *result;
 }
 
-
 // ES6 section 19.3.3.2 Boolean.prototype.toString ( )
 void Builtins::Generate_BooleanPrototypeToString(CodeStubAssembler* assembler) {
   typedef compiler::Node Node;
 
   Node* receiver = assembler->Parameter(0);
   Node* context = assembler->Parameter(3);
 
   Node* value = assembler->ToThisValue(
       context, receiver, PrimitiveType::kBoolean, "Boolean.prototype.toString");
   Node* result = assembler->LoadObjectField(value, Oddball::kToStringOffset);
   assembler->Return(result);
 }
 
 // ES6 section 19.3.3.3 Boolean.prototype.valueOf ( )
 void Builtins::Generate_BooleanPrototypeValueOf(CodeStubAssembler* assembler) {
   typedef compiler::Node Node;
 
   Node* receiver = assembler->Parameter(0);
   Node* context = assembler->Parameter(3);
 
   Node* result = assembler->ToThisValue(
       context, receiver, PrimitiveType::kBoolean, "Boolean.prototype.valueOf");
   assembler->Return(result);
 }
 
 // -----------------------------------------------------------------------------
 // ES6 section 24.2 DataView Objects
 
-
 // ES6 section 24.2.2 The DataView Constructor for the [[Call]] case.
 BUILTIN(DataViewConstructor) {
   HandleScope scope(isolate);
   THROW_NEW_ERROR_RETURN_FAILURE(
       isolate,
       NewTypeError(MessageTemplate::kConstructorNotFunction,
                    isolate->factory()->NewStringFromAsciiChecked("DataView")));
 }
 
-
 // ES6 section 24.2.2 The DataView Constructor for the [[Construct]] case.
 BUILTIN(DataViewConstructor_ConstructStub) {
   HandleScope scope(isolate);
   Handle<JSFunction> target = args.target<JSFunction>();
   Handle<JSReceiver> new_target = Handle<JSReceiver>::cast(args.new_target());
   Handle<Object> buffer = args.atOrUndefined(isolate, 1);
   Handle<Object> byte_offset = args.atOrUndefined(isolate, 2);
   Handle<Object> byte_length = args.atOrUndefined(isolate, 3);
 
   // 2. If Type(buffer) is not Object, throw a TypeError exception.
@@ skipping 45 matching lines @@
   if (byte_length->IsUndefined(isolate)) {
     // 10. If byteLength is undefined, then
     //       a. Let viewByteLength be bufferByteLength - offset.
     view_byte_length =
         isolate->factory()->NewNumber(buffer_byte_length - offset->Number());
   } else {
     // 11. Else,
     //       a. Let viewByteLength be ? ToLength(byteLength).
     //       b. If offset+viewByteLength > bufferByteLength, throw a RangeError
     //          exception
-    ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
-        isolate, view_byte_length, Object::ToLength(isolate, byte_length));
+    ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, view_byte_length,
+                                       Object::ToLength(isolate, byte_length));
     if (offset->Number() + view_byte_length->Number() > buffer_byte_length) {
       THROW_NEW_ERROR_RETURN_FAILURE(
           isolate, NewRangeError(MessageTemplate::kInvalidDataViewLength));
     }
   }
 
   // 12. Let O be ? OrdinaryCreateFromConstructor(NewTarget,
   //     "%DataViewPrototype%", «[[DataView]], [[ViewedArrayBuffer]],
   //     [[ByteLength]], [[ByteOffset]]»).
   // 13. Set O's [[DataView]] internal slot to true.
@@ skipping 127 matching lines @@
 void Builtins::Generate_TypedArrayPrototypeLength(
     CodeStubAssembler* assembler) {
   Generate_TypedArrayProtoypeGetter(assembler,
                                     "get TypedArray.prototype.length",
                                     JSTypedArray::kLengthOffset);
 }
 
 // -----------------------------------------------------------------------------
 // ES6 section 20.3 Date Objects
 
-
 namespace {
 
 // ES6 section 20.3.1.1 Time Values and Time Range
 const double kMinYear = -1000000.0;
 const double kMaxYear = -kMinYear;
 const double kMinMonth = -10000000.0;
 const double kMaxMonth = -kMinMonth;
 
-
 // 20.3.1.2 Day Number and Time within Day
 const double kMsPerDay = 86400000.0;
 
-
 // ES6 section 20.3.1.11 Hours, Minutes, Second, and Milliseconds
 const double kMsPerSecond = 1000.0;
 const double kMsPerMinute = 60000.0;
 const double kMsPerHour = 3600000.0;
 
-
 // ES6 section 20.3.1.14 MakeDate (day, time)
 double MakeDate(double day, double time) {
   if (std::isfinite(day) && std::isfinite(time)) {
     return time + day * kMsPerDay;
   }
   return std::numeric_limits<double>::quiet_NaN();
 }
 
-
 // ES6 section 20.3.1.13 MakeDay (year, month, date)
 double MakeDay(double year, double month, double date) {
   if ((kMinYear <= year && year <= kMaxYear) &&
       (kMinMonth <= month && month <= kMaxMonth) && std::isfinite(date)) {
     int y = FastD2I(year);
     int m = FastD2I(month);
     y += m / 12;
     m %= 12;
     if (m < 0) {
       m += 12;
@@ skipping 24 matching lines @@
     } else {
       static const int kDayFromMonth[] = {0,   31,  60,  91,  121, 152,
                                           182, 213, 244, 274, 305, 335};
       day_from_year += kDayFromMonth[m];
     }
     return static_cast<double>(day_from_year - 1) + date;
   }
   return std::numeric_limits<double>::quiet_NaN();
 }
 
-
 // ES6 section 20.3.1.12 MakeTime (hour, min, sec, ms)
 double MakeTime(double hour, double min, double sec, double ms) {
   if (std::isfinite(hour) && std::isfinite(min) && std::isfinite(sec) &&
       std::isfinite(ms)) {
     double const h = DoubleToInteger(hour);
     double const m = DoubleToInteger(min);
     double const s = DoubleToInteger(sec);
     double const milli = DoubleToInteger(ms);
     return h * kMsPerHour + m * kMsPerMinute + s * kMsPerSecond + milli;
   }
   return std::numeric_limits<double>::quiet_NaN();
 }
 
-
 // ES6 section 20.3.1.15 TimeClip (time)
 double TimeClip(double time) {
   if (-DateCache::kMaxTimeInMs <= time && time <= DateCache::kMaxTimeInMs) {
     return DoubleToInteger(time) + 0.0;
   }
   return std::numeric_limits<double>::quiet_NaN();
 }
 
-
 const char* kShortWeekDays[] = {"Sun", "Mon", "Tue", "Wed",
                                 "Thu", "Fri", "Sat"};
 const char* kShortMonths[] = {"Jan", "Feb", "Mar", "Apr", "May", "Jun",
                               "Jul", "Aug", "Sep", "Oct", "Nov", "Dec"};
 
-
 // ES6 section 20.3.1.16 Date Time String Format
 double ParseDateTimeString(Handle<String> str) {
   Isolate* const isolate = str->GetIsolate();
   str = String::Flatten(str);
   // TODO(bmeurer): Change DateParser to not use the FixedArray.
   Handle<FixedArray> tmp =
       isolate->factory()->NewFixedArray(DateParser::OUTPUT_SIZE);
   DisallowHeapAllocation no_gc;
   String::FlatContent str_content = str->GetFlatContent();
   bool result;
@@ skipping 11 matching lines @@
   if (tmp->get(7)->IsNull(isolate)) {
     if (!std::isnan(date)) {
       date = isolate->date_cache()->ToUTC(static_cast<int64_t>(date));
     }
   } else {
     date -= tmp->get(7)->Number() * 1000.0;
   }
   return date;
 }
 
-
 enum ToDateStringMode { kDateOnly, kTimeOnly, kDateAndTime };
 
-
 // ES6 section 20.3.4.41.1 ToDateString(tv)
 void ToDateString(double time_val, Vector<char> str, DateCache* date_cache,
                   ToDateStringMode mode = kDateAndTime) {
   if (std::isnan(time_val)) {
     SNPrintF(str, "Invalid Date");
     return;
   }
   int64_t time_ms = static_cast<int64_t>(time_val);
   int64_t local_time_ms = date_cache->ToLocal(time_ms);
   int year, month, day, weekday, hour, min, sec, ms;
@@ skipping 16 matching lines @@
     case kDateAndTime:
       SNPrintF(str, "%s %s %02d %4d %02d:%02d:%02d GMT%c%02d%02d (%s)",
                kShortWeekDays[weekday], kShortMonths[month], day, year, hour,
                min, sec, (timezone_offset < 0) ? '-' : '+', timezone_hour,
                timezone_min, local_timezone);
       return;
   }
   UNREACHABLE();
 }
 
-
 Object* SetLocalDateValue(Handle<JSDate> date, double time_val) {
   if (time_val >= -DateCache::kMaxTimeBeforeUTCInMs &&
       time_val <= DateCache::kMaxTimeBeforeUTCInMs) {
     Isolate* const isolate = date->GetIsolate();
     time_val = isolate->date_cache()->ToUTC(static_cast<int64_t>(time_val));
   } else {
     time_val = std::numeric_limits<double>::quiet_NaN();
   }
   return *JSDate::SetValue(date, TimeClip(time_val));
 }
 
 }  // namespace
 
-
 // ES6 section 20.3.2 The Date Constructor for the [[Call]] case.
 BUILTIN(DateConstructor) {
   HandleScope scope(isolate);
   double const time_val = JSDate::CurrentTimeValue(isolate);
   char buffer[128];
   ToDateString(time_val, ArrayVector(buffer), isolate->date_cache());
   RETURN_RESULT_OR_FAILURE(
       isolate, isolate->factory()->NewStringFromUtf8(CStrVector(buffer)));
 }
 
-
 // ES6 section 20.3.2 The Date Constructor for the [[Construct]] case.
 BUILTIN(DateConstructor_ConstructStub) {
   HandleScope scope(isolate);
   int const argc = args.length() - 1;
   Handle<JSFunction> target = args.target<JSFunction>();
   Handle<JSReceiver> new_target = Handle<JSReceiver>::cast(args.new_target());
   double time_val;
   if (argc == 0) {
     time_val = JSDate::CurrentTimeValue(isolate);
   } else if (argc == 1) {
@@ skipping 61 matching lines @@
     if (time_val >= -DateCache::kMaxTimeBeforeUTCInMs &&
         time_val <= DateCache::kMaxTimeBeforeUTCInMs) {
       time_val = isolate->date_cache()->ToUTC(static_cast<int64_t>(time_val));
     } else {
       time_val = std::numeric_limits<double>::quiet_NaN();
     }
   }
   RETURN_RESULT_OR_FAILURE(isolate, JSDate::New(target, new_target, time_val));
 }
 
-
 // ES6 section 20.3.3.1 Date.now ( )
 BUILTIN(DateNow) {
   HandleScope scope(isolate);
   return *isolate->factory()->NewNumber(JSDate::CurrentTimeValue(isolate));
 }
 
-
 // ES6 section 20.3.3.2 Date.parse ( string )
 BUILTIN(DateParse) {
   HandleScope scope(isolate);
   Handle<String> string;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
       isolate, string,
       Object::ToString(isolate, args.atOrUndefined(isolate, 1)));
   return *isolate->factory()->NewNumber(ParseDateTimeString(string));
 }
 
-
 // ES6 section 20.3.3.4 Date.UTC (year,month,date,hours,minutes,seconds,ms)
 BUILTIN(DateUTC) {
   HandleScope scope(isolate);
   int const argc = args.length() - 1;
   double year = std::numeric_limits<double>::quiet_NaN();
   double month = std::numeric_limits<double>::quiet_NaN();
   double date = 1.0, hours = 0.0, minutes = 0.0, seconds = 0.0, ms = 0.0;
   if (argc >= 1) {
     Handle<Object> year_object;
     ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, year_object,
@@ skipping 39 matching lines @@
   }
   if (!std::isnan(year)) {
     double const y = DoubleToInteger(year);
     if (0.0 <= y && y <= 99) year = 1900 + y;
   }
   double const day = MakeDay(year, month, date);
   double const time = MakeTime(hours, minutes, seconds, ms);
   return *isolate->factory()->NewNumber(TimeClip(MakeDate(day, time)));
 }
 
-
 // ES6 section 20.3.4.20 Date.prototype.setDate ( date )
 BUILTIN(DatePrototypeSetDate) {
   HandleScope scope(isolate);
   CHECK_RECEIVER(JSDate, date, "Date.prototype.setDate");
   Handle<Object> value = args.atOrUndefined(isolate, 1);
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, value, Object::ToNumber(value));
   double time_val = date->value()->Number();
   if (!std::isnan(time_val)) {
     int64_t const time_ms = static_cast<int64_t>(time_val);
     int64_t local_time_ms = isolate->date_cache()->ToLocal(time_ms);
     int const days = isolate->date_cache()->DaysFromTime(local_time_ms);
     int time_within_day = isolate->date_cache()->TimeInDay(local_time_ms, days);
     int year, month, day;
     isolate->date_cache()->YearMonthDayFromDays(days, &year, &month, &day);
     time_val = MakeDate(MakeDay(year, month, value->Number()), time_within_day);
   }
   return SetLocalDateValue(date, time_val);
 }
 
-
 // ES6 section 20.3.4.21 Date.prototype.setFullYear (year, month, date)
 BUILTIN(DatePrototypeSetFullYear) {
   HandleScope scope(isolate);
   CHECK_RECEIVER(JSDate, date, "Date.prototype.setFullYear");
   int const argc = args.length() - 1;
   Handle<Object> year = args.atOrUndefined(isolate, 1);
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, year, Object::ToNumber(year));
   double y = year->Number(), m = 0.0, dt = 1.0;
   int time_within_day = 0;
   if (!std::isnan(date->value()->Number())) {
@@ skipping 13 matching lines @@
     if (argc >= 3) {
       Handle<Object> date = args.at<Object>(3);
       ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, date, Object::ToNumber(date));
       dt = date->Number();
     }
   }
   double time_val = MakeDate(MakeDay(y, m, dt), time_within_day);
   return SetLocalDateValue(date, time_val);
 }
 
-
 // ES6 section 20.3.4.22 Date.prototype.setHours(hour, min, sec, ms)
 BUILTIN(DatePrototypeSetHours) {
   HandleScope scope(isolate);
   CHECK_RECEIVER(JSDate, date, "Date.prototype.setHours");
   int const argc = args.length() - 1;
   Handle<Object> hour = args.atOrUndefined(isolate, 1);
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, hour, Object::ToNumber(hour));
   double h = hour->Number();
   double time_val = date->value()->Number();
   if (!std::isnan(time_val)) {
@@ skipping 17 matching lines @@
           ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, ms, Object::ToNumber(ms));
           milli = ms->Number();
         }
       }
     }
     time_val = MakeDate(day, MakeTime(h, m, s, milli));
   }
   return SetLocalDateValue(date, time_val);
 }
 
-
 // ES6 section 20.3.4.23 Date.prototype.setMilliseconds(ms)
 BUILTIN(DatePrototypeSetMilliseconds) {
   HandleScope scope(isolate);
   CHECK_RECEIVER(JSDate, date, "Date.prototype.setMilliseconds");
   Handle<Object> ms = args.atOrUndefined(isolate, 1);
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, ms, Object::ToNumber(ms));
   double time_val = date->value()->Number();
   if (!std::isnan(time_val)) {
     int64_t const time_ms = static_cast<int64_t>(time_val);
     int64_t local_time_ms = isolate->date_cache()->ToLocal(time_ms);
     int day = isolate->date_cache()->DaysFromTime(local_time_ms);
     int time_within_day = isolate->date_cache()->TimeInDay(local_time_ms, day);
     int h = time_within_day / (60 * 60 * 1000);
     int m = (time_within_day / (60 * 1000)) % 60;
     int s = (time_within_day / 1000) % 60;
     time_val = MakeDate(day, MakeTime(h, m, s, ms->Number()));
   }
   return SetLocalDateValue(date, time_val);
 }
 
-
 // ES6 section 20.3.4.24 Date.prototype.setMinutes ( min, sec, ms )
 BUILTIN(DatePrototypeSetMinutes) {
   HandleScope scope(isolate);
   CHECK_RECEIVER(JSDate, date, "Date.prototype.setMinutes");
   int const argc = args.length() - 1;
   Handle<Object> min = args.atOrUndefined(isolate, 1);
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, min, Object::ToNumber(min));
   double time_val = date->value()->Number();
   if (!std::isnan(time_val)) {
     int64_t const time_ms = static_cast<int64_t>(time_val);
@@ skipping 12 matching lines @@
         Handle<Object> ms = args.at<Object>(3);
         ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, ms, Object::ToNumber(ms));
         milli = ms->Number();
       }
     }
     time_val = MakeDate(day, MakeTime(h, m, s, milli));
   }
   return SetLocalDateValue(date, time_val);
 }
 
-
 // ES6 section 20.3.4.25 Date.prototype.setMonth ( month, date )
 BUILTIN(DatePrototypeSetMonth) {
   HandleScope scope(isolate);
   CHECK_RECEIVER(JSDate, date, "Date.prototype.setMonth");
   int const argc = args.length() - 1;
   Handle<Object> month = args.atOrUndefined(isolate, 1);
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, month, Object::ToNumber(month));
   double time_val = date->value()->Number();
   if (!std::isnan(time_val)) {
     int64_t const time_ms = static_cast<int64_t>(time_val);
     int64_t local_time_ms = isolate->date_cache()->ToLocal(time_ms);
     int days = isolate->date_cache()->DaysFromTime(local_time_ms);
     int time_within_day = isolate->date_cache()->TimeInDay(local_time_ms, days);
     int year, unused, day;
     isolate->date_cache()->YearMonthDayFromDays(days, &year, &unused, &day);
     double m = month->Number();
     double dt = day;
     if (argc >= 2) {
       Handle<Object> date = args.at<Object>(2);
       ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, date, Object::ToNumber(date));
       dt = date->Number();
     }
     time_val = MakeDate(MakeDay(year, m, dt), time_within_day);
   }
   return SetLocalDateValue(date, time_val);
 }
 
-
 // ES6 section 20.3.4.26 Date.prototype.setSeconds ( sec, ms )
 BUILTIN(DatePrototypeSetSeconds) {
   HandleScope scope(isolate);
   CHECK_RECEIVER(JSDate, date, "Date.prototype.setSeconds");
   int const argc = args.length() - 1;
   Handle<Object> sec = args.atOrUndefined(isolate, 1);
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, sec, Object::ToNumber(sec));
   double time_val = date->value()->Number();
   if (!std::isnan(time_val)) {
     int64_t const time_ms = static_cast<int64_t>(time_val);
     int64_t local_time_ms = isolate->date_cache()->ToLocal(time_ms);
     int day = isolate->date_cache()->DaysFromTime(local_time_ms);
     int time_within_day = isolate->date_cache()->TimeInDay(local_time_ms, day);
     int h = time_within_day / (60 * 60 * 1000);
     double m = (time_within_day / (60 * 1000)) % 60;
     double s = sec->Number();
     double milli = time_within_day % 1000;
     if (argc >= 2) {
       Handle<Object> ms = args.at<Object>(2);
       ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, ms, Object::ToNumber(ms));
       milli = ms->Number();
     }
     time_val = MakeDate(day, MakeTime(h, m, s, milli));
   }
   return SetLocalDateValue(date, time_val);
 }
 
-
 // ES6 section 20.3.4.27 Date.prototype.setTime ( time )
 BUILTIN(DatePrototypeSetTime) {
   HandleScope scope(isolate);
   CHECK_RECEIVER(JSDate, date, "Date.prototype.setTime");
   Handle<Object> value = args.atOrUndefined(isolate, 1);
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, value, Object::ToNumber(value));
   return *JSDate::SetValue(date, TimeClip(value->Number()));
 }
 
-
 // ES6 section 20.3.4.28 Date.prototype.setUTCDate ( date )
 BUILTIN(DatePrototypeSetUTCDate) {
   HandleScope scope(isolate);
   CHECK_RECEIVER(JSDate, date, "Date.prototype.setUTCDate");
   Handle<Object> value = args.atOrUndefined(isolate, 1);
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, value, Object::ToNumber(value));
   if (std::isnan(date->value()->Number())) return date->value();
   int64_t const time_ms = static_cast<int64_t>(date->value()->Number());
   int const days = isolate->date_cache()->DaysFromTime(time_ms);
   int const time_within_day = isolate->date_cache()->TimeInDay(time_ms, days);
   int year, month, day;
   isolate->date_cache()->YearMonthDayFromDays(days, &year, &month, &day);
   double const time_val =
       MakeDate(MakeDay(year, month, value->Number()), time_within_day);
   return *JSDate::SetValue(date, TimeClip(time_val));
 }
 
-
 // ES6 section 20.3.4.29 Date.prototype.setUTCFullYear (year, month, date)
 BUILTIN(DatePrototypeSetUTCFullYear) {
   HandleScope scope(isolate);
   CHECK_RECEIVER(JSDate, date, "Date.prototype.setUTCFullYear");
   int const argc = args.length() - 1;
   Handle<Object> year = args.atOrUndefined(isolate, 1);
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, year, Object::ToNumber(year));
   double y = year->Number(), m = 0.0, dt = 1.0;
   int time_within_day = 0;
   if (!std::isnan(date->value()->Number())) {
@@ skipping 12 matching lines @@
     if (argc >= 3) {
       Handle<Object> date = args.at<Object>(3);
       ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, date, Object::ToNumber(date));
       dt = date->Number();
     }
   }
   double const time_val = MakeDate(MakeDay(y, m, dt), time_within_day);
   return *JSDate::SetValue(date, TimeClip(time_val));
 }
 
-
 // ES6 section 20.3.4.30 Date.prototype.setUTCHours(hour, min, sec, ms)
 BUILTIN(DatePrototypeSetUTCHours) {
   HandleScope scope(isolate);
   CHECK_RECEIVER(JSDate, date, "Date.prototype.setUTCHours");
   int const argc = args.length() - 1;
   Handle<Object> hour = args.atOrUndefined(isolate, 1);
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, hour, Object::ToNumber(hour));
   double h = hour->Number();
   double time_val = date->value()->Number();
   if (!std::isnan(time_val)) {
@@ skipping 16 matching lines @@
           ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, ms, Object::ToNumber(ms));
           milli = ms->Number();
         }
       }
     }
     time_val = MakeDate(day, MakeTime(h, m, s, milli));
   }
   return *JSDate::SetValue(date, TimeClip(time_val));
 }
 
-
 // ES6 section 20.3.4.31 Date.prototype.setUTCMilliseconds(ms)
 BUILTIN(DatePrototypeSetUTCMilliseconds) {
   HandleScope scope(isolate);
   CHECK_RECEIVER(JSDate, date, "Date.prototype.setUTCMilliseconds");
   Handle<Object> ms = args.atOrUndefined(isolate, 1);
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, ms, Object::ToNumber(ms));
   double time_val = date->value()->Number();
   if (!std::isnan(time_val)) {
     int64_t const time_ms = static_cast<int64_t>(time_val);
     int day = isolate->date_cache()->DaysFromTime(time_ms);
     int time_within_day = isolate->date_cache()->TimeInDay(time_ms, day);
     int h = time_within_day / (60 * 60 * 1000);
     int m = (time_within_day / (60 * 1000)) % 60;
     int s = (time_within_day / 1000) % 60;
     time_val = MakeDate(day, MakeTime(h, m, s, ms->Number()));
   }
   return *JSDate::SetValue(date, TimeClip(time_val));
 }
 
-
 // ES6 section 20.3.4.32 Date.prototype.setUTCMinutes ( min, sec, ms )
 BUILTIN(DatePrototypeSetUTCMinutes) {
   HandleScope scope(isolate);
   CHECK_RECEIVER(JSDate, date, "Date.prototype.setUTCMinutes");
   int const argc = args.length() - 1;
   Handle<Object> min = args.atOrUndefined(isolate, 1);
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, min, Object::ToNumber(min));
   double time_val = date->value()->Number();
   if (!std::isnan(time_val)) {
     int64_t const time_ms = static_cast<int64_t>(time_val);
@@ skipping 11 matching lines @@
         Handle<Object> ms = args.at<Object>(3);
         ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, ms, Object::ToNumber(ms));
         milli = ms->Number();
       }
     }
     time_val = MakeDate(day, MakeTime(h, m, s, milli));
   }
   return *JSDate::SetValue(date, TimeClip(time_val));
 }
 
-
 // ES6 section 20.3.4.31 Date.prototype.setUTCMonth ( month, date )
 BUILTIN(DatePrototypeSetUTCMonth) {
   HandleScope scope(isolate);
   CHECK_RECEIVER(JSDate, date, "Date.prototype.setUTCMonth");
   int const argc = args.length() - 1;
   Handle<Object> month = args.atOrUndefined(isolate, 1);
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, month, Object::ToNumber(month));
   double time_val = date->value()->Number();
   if (!std::isnan(time_val)) {
     int64_t const time_ms = static_cast<int64_t>(time_val);
     int days = isolate->date_cache()->DaysFromTime(time_ms);
     int time_within_day = isolate->date_cache()->TimeInDay(time_ms, days);
     int year, unused, day;
     isolate->date_cache()->YearMonthDayFromDays(days, &year, &unused, &day);
     double m = month->Number();
     double dt = day;
     if (argc >= 2) {
       Handle<Object> date = args.at<Object>(2);
       ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, date, Object::ToNumber(date));
       dt = date->Number();
     }
     time_val = MakeDate(MakeDay(year, m, dt), time_within_day);
   }
   return *JSDate::SetValue(date, TimeClip(time_val));
 }
 
-
 // ES6 section 20.3.4.34 Date.prototype.setUTCSeconds ( sec, ms )
 BUILTIN(DatePrototypeSetUTCSeconds) {
   HandleScope scope(isolate);
   CHECK_RECEIVER(JSDate, date, "Date.prototype.setUTCSeconds");
   int const argc = args.length() - 1;
   Handle<Object> sec = args.atOrUndefined(isolate, 1);
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, sec, Object::ToNumber(sec));
   double time_val = date->value()->Number();
   if (!std::isnan(time_val)) {
     int64_t const time_ms = static_cast<int64_t>(time_val);
     int day = isolate->date_cache()->DaysFromTime(time_ms);
     int time_within_day = isolate->date_cache()->TimeInDay(time_ms, day);
     int h = time_within_day / (60 * 60 * 1000);
     double m = (time_within_day / (60 * 1000)) % 60;
     double s = sec->Number();
     double milli = time_within_day % 1000;
     if (argc >= 2) {
       Handle<Object> ms = args.at<Object>(2);
       ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, ms, Object::ToNumber(ms));
       milli = ms->Number();
     }
     time_val = MakeDate(day, MakeTime(h, m, s, milli));
   }
   return *JSDate::SetValue(date, TimeClip(time_val));
 }
 
-
 // ES6 section 20.3.4.35 Date.prototype.toDateString ( )
 BUILTIN(DatePrototypeToDateString) {
   HandleScope scope(isolate);
   CHECK_RECEIVER(JSDate, date, "Date.prototype.toDateString");
   char buffer[128];
   ToDateString(date->value()->Number(), ArrayVector(buffer),
                isolate->date_cache(), kDateOnly);
   RETURN_RESULT_OR_FAILURE(
       isolate, isolate->factory()->NewStringFromUtf8(CStrVector(buffer)));
 }
 
-
 // ES6 section 20.3.4.36 Date.prototype.toISOString ( )
 BUILTIN(DatePrototypeToISOString) {
   HandleScope scope(isolate);
   CHECK_RECEIVER(JSDate, date, "Date.prototype.toISOString");
   double const time_val = date->value()->Number();
   if (std::isnan(time_val)) {
     THROW_NEW_ERROR_RETURN_FAILURE(
         isolate, NewRangeError(MessageTemplate::kInvalidTimeValue));
   }
   int64_t const time_ms = static_cast<int64_t>(time_val);
   int year, month, day, weekday, hour, min, sec, ms;
   isolate->date_cache()->BreakDownTime(time_ms, &year, &month, &day, &weekday,
                                        &hour, &min, &sec, &ms);
   char buffer[128];
   if (year >= 0 && year <= 9999) {
     SNPrintF(ArrayVector(buffer), "%04d-%02d-%02dT%02d:%02d:%02d.%03dZ", year,
              month + 1, day, hour, min, sec, ms);
   } else if (year < 0) {
     SNPrintF(ArrayVector(buffer), "-%06d-%02d-%02dT%02d:%02d:%02d.%03dZ", -year,
              month + 1, day, hour, min, sec, ms);
   } else {
     SNPrintF(ArrayVector(buffer), "+%06d-%02d-%02dT%02d:%02d:%02d.%03dZ", year,
              month + 1, day, hour, min, sec, ms);
   }
   return *isolate->factory()->NewStringFromAsciiChecked(buffer);
 }
 
-
 // ES6 section 20.3.4.41 Date.prototype.toString ( )
 BUILTIN(DatePrototypeToString) {
   HandleScope scope(isolate);
   CHECK_RECEIVER(JSDate, date, "Date.prototype.toString");
   char buffer[128];
   ToDateString(date->value()->Number(), ArrayVector(buffer),
                isolate->date_cache());
   RETURN_RESULT_OR_FAILURE(
       isolate, isolate->factory()->NewStringFromUtf8(CStrVector(buffer)));
 }
 
-
 // ES6 section 20.3.4.42 Date.prototype.toTimeString ( )
 BUILTIN(DatePrototypeToTimeString) {
   HandleScope scope(isolate);
   CHECK_RECEIVER(JSDate, date, "Date.prototype.toTimeString");
   char buffer[128];
   ToDateString(date->value()->Number(), ArrayVector(buffer),
                isolate->date_cache(), kTimeOnly);
   RETURN_RESULT_OR_FAILURE(
       isolate, isolate->factory()->NewStringFromUtf8(CStrVector(buffer)));
 }
 
-
 // ES6 section 20.3.4.43 Date.prototype.toUTCString ( )
 BUILTIN(DatePrototypeToUTCString) {
   HandleScope scope(isolate);
   CHECK_RECEIVER(JSDate, date, "Date.prototype.toUTCString");
   double const time_val = date->value()->Number();
   if (std::isnan(time_val)) {
     return *isolate->factory()->NewStringFromAsciiChecked("Invalid Date");
   }
   char buffer[128];
   int64_t time_ms = static_cast<int64_t>(time_val);
   int year, month, day, weekday, hour, min, sec, ms;
   isolate->date_cache()->BreakDownTime(time_ms, &year, &month, &day, &weekday,
                                        &hour, &min, &sec, &ms);
   SNPrintF(ArrayVector(buffer), "%s, %02d %s %4d %02d:%02d:%02d GMT",
            kShortWeekDays[weekday], day, kShortMonths[month], year, hour, min,
            sec);
   return *isolate->factory()->NewStringFromAsciiChecked(buffer);
 }
 
-
 // ES6 section 20.3.4.44 Date.prototype.valueOf ( )
 BUILTIN(DatePrototypeValueOf) {
   HandleScope scope(isolate);
   CHECK_RECEIVER(JSDate, date, "Date.prototype.valueOf");
   return date->value();
 }
 
-
 // ES6 section 20.3.4.45 Date.prototype [ @@toPrimitive ] ( hint )
 BUILTIN(DatePrototypeToPrimitive) {
   HandleScope scope(isolate);
   DCHECK_EQ(2, args.length());
   CHECK_RECEIVER(JSReceiver, receiver, "Date.prototype [ @@toPrimitive ]");
   Handle<Object> hint = args.at<Object>(1);
   RETURN_RESULT_OR_FAILURE(isolate, JSDate::ToPrimitive(receiver, hint));
 }
 
-
 // ES6 section B.2.4.1 Date.prototype.getYear ( )
 BUILTIN(DatePrototypeGetYear) {
   HandleScope scope(isolate);
   CHECK_RECEIVER(JSDate, date, "Date.prototype.getYear");
   double time_val = date->value()->Number();
   if (std::isnan(time_val)) return date->value();
   int64_t time_ms = static_cast<int64_t>(time_val);
   int64_t local_time_ms = isolate->date_cache()->ToLocal(time_ms);
   int days = isolate->date_cache()->DaysFromTime(local_time_ms);
   int year, month, day;
   isolate->date_cache()->YearMonthDayFromDays(days, &year, &month, &day);
   return Smi::FromInt(year - 1900);
 }
 
-
 // ES6 section B.2.4.2 Date.prototype.setYear ( year )
 BUILTIN(DatePrototypeSetYear) {
   HandleScope scope(isolate);
   CHECK_RECEIVER(JSDate, date, "Date.prototype.setYear");
   Handle<Object> year = args.atOrUndefined(isolate, 1);
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, year, Object::ToNumber(year));
   double m = 0.0, dt = 1.0, y = year->Number();
   if (0.0 <= y && y <= 99.0) {
     y = 1900.0 + DoubleToInteger(y);
   }
@@ skipping 38 matching lines @@
     RETURN_RESULT_OR_FAILURE(
         isolate, Execution::Call(isolate, function, receiver_obj, 0, NULL));
   }
 }
 
 // static
 void Builtins::Generate_DatePrototypeGetDate(MacroAssembler* masm) {
   Generate_DatePrototype_GetField(masm, JSDate::kDay);
 }
 
-
 // static
 void Builtins::Generate_DatePrototypeGetDay(MacroAssembler* masm) {
   Generate_DatePrototype_GetField(masm, JSDate::kWeekday);
 }
 
-
 // static
 void Builtins::Generate_DatePrototypeGetFullYear(MacroAssembler* masm) {
   Generate_DatePrototype_GetField(masm, JSDate::kYear);
 }
 
-
 // static
 void Builtins::Generate_DatePrototypeGetHours(MacroAssembler* masm) {
   Generate_DatePrototype_GetField(masm, JSDate::kHour);
 }
 
-
 // static
 void Builtins::Generate_DatePrototypeGetMilliseconds(MacroAssembler* masm) {
   Generate_DatePrototype_GetField(masm, JSDate::kMillisecond);
 }
 
-
 // static
 void Builtins::Generate_DatePrototypeGetMinutes(MacroAssembler* masm) {
   Generate_DatePrototype_GetField(masm, JSDate::kMinute);
 }
 
-
 // static
 void Builtins::Generate_DatePrototypeGetMonth(MacroAssembler* masm) {
   Generate_DatePrototype_GetField(masm, JSDate::kMonth);
 }
 
-
 // static
 void Builtins::Generate_DatePrototypeGetSeconds(MacroAssembler* masm) {
   Generate_DatePrototype_GetField(masm, JSDate::kSecond);
 }
 
-
 // static
 void Builtins::Generate_DatePrototypeGetTime(MacroAssembler* masm) {
   Generate_DatePrototype_GetField(masm, JSDate::kDateValue);
 }
 
-
 // static
 void Builtins::Generate_DatePrototypeGetTimezoneOffset(MacroAssembler* masm) {
   Generate_DatePrototype_GetField(masm, JSDate::kTimezoneOffset);
 }
 
-
 // static
 void Builtins::Generate_DatePrototypeGetUTCDate(MacroAssembler* masm) {
   Generate_DatePrototype_GetField(masm, JSDate::kDayUTC);
 }
 
-
 // static
 void Builtins::Generate_DatePrototypeGetUTCDay(MacroAssembler* masm) {
   Generate_DatePrototype_GetField(masm, JSDate::kWeekdayUTC);
 }
 
-
 // static
 void Builtins::Generate_DatePrototypeGetUTCFullYear(MacroAssembler* masm) {
   Generate_DatePrototype_GetField(masm, JSDate::kYearUTC);
 }
 
-
 // static
 void Builtins::Generate_DatePrototypeGetUTCHours(MacroAssembler* masm) {
   Generate_DatePrototype_GetField(masm, JSDate::kHourUTC);
 }
 
-
 // static
 void Builtins::Generate_DatePrototypeGetUTCMilliseconds(MacroAssembler* masm) {
   Generate_DatePrototype_GetField(masm, JSDate::kMillisecondUTC);
 }
 
-
 // static
 void Builtins::Generate_DatePrototypeGetUTCMinutes(MacroAssembler* masm) {
   Generate_DatePrototype_GetField(masm, JSDate::kMinuteUTC);
 }
 
-
 // static
 void Builtins::Generate_DatePrototypeGetUTCMonth(MacroAssembler* masm) {
   Generate_DatePrototype_GetField(masm, JSDate::kMonthUTC);
 }
 
-
 // static
 void Builtins::Generate_DatePrototypeGetUTCSeconds(MacroAssembler* masm) {
   Generate_DatePrototype_GetField(masm, JSDate::kSecondUTC);
 }
 
-
 namespace {
 
 // ES6 section 19.2.1.1.1 CreateDynamicFunction
 MaybeHandle<JSFunction> CreateDynamicFunction(Isolate* isolate,
                                               BuiltinArguments args,
                                               const char* token) {
   // Compute number of arguments, ignoring the receiver.
   DCHECK_LE(1, args.length());
   int const argc = args.length() - 1;
 
@@ skipping 93 matching lines @@
 
     Handle<Context> context(function->context(), isolate);
     function = isolate->factory()->NewFunctionFromSharedFunctionInfo(
         map, shared_info, context, NOT_TENURED);
   }
   return function;
 }
 
 }  // namespace
 
-
 // ES6 section 19.2.1.1 Function ( p1, p2, ... , pn, body )
 BUILTIN(FunctionConstructor) {
   HandleScope scope(isolate);
   Handle<JSFunction> result;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(
       isolate, result, CreateDynamicFunction(isolate, args, "function"));
   return *result;
 }
 
 namespace {
@@ skipping 106 matching lines @@
     return *JSBoundFunction::ToString(Handle<JSBoundFunction>::cast(receiver));
   } else if (receiver->IsJSFunction()) {
     return *JSFunction::ToString(Handle<JSFunction>::cast(receiver));
   }
   THROW_NEW_ERROR_RETURN_FAILURE(
       isolate, NewTypeError(MessageTemplate::kNotGeneric,
                             isolate->factory()->NewStringFromAsciiChecked(
                                 "Function.prototype.toString")));
 }
 
-
 // ES6 section 25.2.1.1 GeneratorFunction (p1, p2, ... , pn, body)
 BUILTIN(GeneratorFunctionConstructor) {
   HandleScope scope(isolate);
   RETURN_RESULT_OR_FAILURE(isolate,
                            CreateDynamicFunction(isolate, args, "function*"));
 }
 
 BUILTIN(AsyncFunctionConstructor) {
   HandleScope scope(isolate);
   Handle<JSFunction> func;
@@ skipping 45 matching lines @@
   Handle<Symbol> result = isolate->factory()->NewSymbol();
   Handle<Object> description = args.atOrUndefined(isolate, 1);
   if (!description->IsUndefined(isolate)) {
     ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, description,
                                        Object::ToString(isolate, description));
     result->set_name(*description);
   }
   return *result;
 }
 
-
 // ES6 section 19.4.1.1 Symbol ( [ description ] ) for the [[Construct]] case.
 BUILTIN(SymbolConstructor_ConstructStub) {
   HandleScope scope(isolate);
   THROW_NEW_ERROR_RETURN_FAILURE(
       isolate, NewTypeError(MessageTemplate::kNotConstructor,
                             isolate->factory()->Symbol_string()));
 }
 
 // ES6 section 19.4.3.4 Symbol.prototype [ @@toPrimitive ] ( hint )
 void Builtins::Generate_SymbolPrototypeToPrimitive(
@@ skipping 557 matching lines @@
 BUILTIN(ArrayBufferConstructor) {
   HandleScope scope(isolate);
   Handle<JSFunction> target = args.target<JSFunction>();
   DCHECK(*target == target->native_context()->array_buffer_fun() ||
          *target == target->native_context()->shared_array_buffer_fun());
   THROW_NEW_ERROR_RETURN_FAILURE(
       isolate, NewTypeError(MessageTemplate::kConstructorNotFunction,
                             handle(target->shared()->name(), isolate)));
 }
 
-
 // ES6 section 24.1.2.1 ArrayBuffer ( length ) for the [[Construct]] case.
 BUILTIN(ArrayBufferConstructor_ConstructStub) {
   HandleScope scope(isolate);
   Handle<JSFunction> target = args.target<JSFunction>();
   Handle<JSReceiver> new_target = Handle<JSReceiver>::cast(args.new_target());
   Handle<Object> length = args.atOrUndefined(isolate, 1);
   DCHECK(*target == target->native_context()->array_buffer_fun() ||
          *target == target->native_context()->shared_array_buffer_fun());
   Handle<Object> number_length;
   ASSIGN_RETURN_FAILURE_ON_EXCEPTION(isolate, number_length,
@@ skipping 66 matching lines @@
 
 // ES6 section 26.2.1.1 Proxy ( target, handler ) for the [[Call]] case.
 BUILTIN(ProxyConstructor) {
   HandleScope scope(isolate);
   THROW_NEW_ERROR_RETURN_FAILURE(
       isolate,
       NewTypeError(MessageTemplate::kConstructorNotFunction,
                    isolate->factory()->NewStringFromAsciiChecked("Proxy")));
 }
 
-
 // ES6 section 26.2.1.1 Proxy ( target, handler ) for the [[Construct]] case.
 BUILTIN(ProxyConstructor_ConstructStub) {
   HandleScope scope(isolate);
   DCHECK(isolate->proxy_function()->IsConstructor());
   Handle<Object> target = args.atOrUndefined(isolate, 1);
   Handle<Object> handler = args.atOrUndefined(isolate, 2);
   RETURN_RESULT_OR_FAILURE(isolate, JSProxy::New(isolate, target, handler));
 }
 
-
 // -----------------------------------------------------------------------------
 // Throwers for restricted function properties and strict arguments object
 // properties
 
-
 BUILTIN(RestrictedFunctionPropertiesThrower) {
   HandleScope scope(isolate);
   THROW_NEW_ERROR_RETURN_FAILURE(
       isolate, NewTypeError(MessageTemplate::kRestrictedFunctionProperties));
 }
 
-
 BUILTIN(RestrictedStrictArgumentsPropertiesThrower) {
   HandleScope scope(isolate);
   THROW_NEW_ERROR_RETURN_FAILURE(
       isolate, NewTypeError(MessageTemplate::kStrictPoisonPill));
 }
 
-
 // -----------------------------------------------------------------------------
 //
 
-
 namespace {
 
 // Returns the holder JSObject if the function can legally be called with this
 // receiver.  Returns nullptr if the call is illegal.
 // TODO(dcarney): CallOptimization duplicates this logic, merge.
 JSObject* GetCompatibleReceiver(Isolate* isolate, FunctionTemplateInfo* info,
                                 JSObject* receiver) {
   Object* recv_type = info->signature();
   // No signature, return holder.
   if (!recv_type->IsFunctionTemplateInfo()) return receiver;
@@ skipping 89 matching lines @@
     // Rebox the result.
     result->VerifyApiCallResultType();
     if (!is_construct || result->IsJSObject()) return handle(*result, isolate);
   }
 
   return js_receiver;
 }
 
 }  // namespace
 
-
 BUILTIN(HandleApiCall) {
   HandleScope scope(isolate);
   Handle<JSFunction> function = args.target<JSFunction>();
   Handle<Object> receiver = args.receiver();
   Handle<HeapObject> new_target = args.new_target();
   Handle<FunctionTemplateInfo> fun_data(function->shared()->get_api_func_data(),
                                         isolate);
   if (new_target->IsJSReceiver()) {
     RETURN_RESULT_OR_FAILURE(
         isolate, HandleApiCallHelper<true>(isolate, function, new_target,
                                            fun_data, receiver, args));
   } else {
     RETURN_RESULT_OR_FAILURE(
         isolate, HandleApiCallHelper<false>(isolate, function, new_target,
                                             fun_data, receiver, args));
   }
 }
 
-
 Handle<Code> Builtins::CallFunction(ConvertReceiverMode mode,
                                     TailCallMode tail_call_mode) {
   switch (tail_call_mode) {
     case TailCallMode::kDisallow:
       switch (mode) {
         case ConvertReceiverMode::kNullOrUndefined:
           return CallFunction_ReceiverIsNullOrUndefined();
         case ConvertReceiverMode::kNotNullOrUndefined:
           return CallFunction_ReceiverIsNotNullOrUndefined();
         case ConvertReceiverMode::kAny:
@@ skipping 140 matching lines @@
   MaybeHandle<Object> result;
   {
     RelocatableArguments arguments(isolate, frame_argc, &argv[frame_argc - 1]);
     result = HandleApiCallHelper<false>(isolate, function, new_target, fun_data,
                                         receiver, arguments);
   }
   if (argv != small_argv) delete[] argv;
   return result;
 }
 
-
 // Helper function to handle calls to non-function objects created through the
 // API. The object can be called as either a constructor (using new) or just as
 // a function (without new).
 MUST_USE_RESULT static Object* HandleApiCallAsFunctionOrConstructor(
     Isolate* isolate, bool is_construct_call, BuiltinArguments args) {
   Handle<Object> receiver = args.receiver();
 
   // Get the object called.
   JSObject* obj = JSObject::cast(*receiver);
 
@@ skipping 39 matching lines @@
       result = isolate->heap()->undefined_value();
     } else {
       result = *result_handle;
     }
   }
   // Check for exceptions and return result.
   RETURN_FAILURE_IF_SCHEDULED_EXCEPTION(isolate);
   return result;
 }
 
-
 // Handle calls to non-function objects created through the API. This delegate
 // function is used when the call is a normal function call.
 BUILTIN(HandleApiCallAsFunction) {
   return HandleApiCallAsFunctionOrConstructor(isolate, false, args);
 }
 
-
 // Handle calls to non-function objects created through the API. This delegate
 // function is used when the call is a construct call.
 BUILTIN(HandleApiCallAsConstructor) {
   return HandleApiCallAsFunctionOrConstructor(isolate, true, args);
 }
 
 namespace {
 
 void Generate_LoadIC_Miss(CodeStubAssembler* assembler) {
   typedef compiler::Node Node;
@@ skipping 149 matching lines @@
   DebugCodegen::GenerateFrameDropperLiveEdit(masm);
 }
 
 }  // namespace
 
 Builtins::Builtins() : initialized_(false) {
   memset(builtins_, 0, sizeof(builtins_[0]) * builtin_count);
   memset(names_, 0, sizeof(names_[0]) * builtin_count);
 }
 
-
-Builtins::~Builtins() {
-}
+Builtins::~Builtins() {}
 
 #define DEF_ENUM_C(name, ignore) FUNCTION_ADDR(Builtin_##name),
 Address const Builtins::c_functions_[cfunction_count] = {
-  BUILTIN_LIST_C(DEF_ENUM_C)
-};
+    BUILTIN_LIST_C(DEF_ENUM_C)};
 #undef DEF_ENUM_C
 
-
 struct BuiltinDesc {
   Handle<Code> (*builder)(Isolate*, struct BuiltinDesc const*);
   byte* generator;
   byte* c_code;
   const char* s_name;  // name is only used for generating log information.
   int name;
   Code::Flags flags;
   Builtins::ExitFrameType exit_frame_type;
   int argc;
 };
 
-#define BUILTIN_FUNCTION_TABLE_INIT { V8_ONCE_INIT, {} }
+#define BUILTIN_FUNCTION_TABLE_INIT \
+  {                                 \
+    V8_ONCE_INIT, {}                \
+  }
 
 class BuiltinFunctionTable {
  public:
   BuiltinDesc* functions() {
     base::CallOnce(&once_, &Builtins::InitBuiltinFunctionTable);
     return functions_;
   }
 
   base::OnceType once_;
   BuiltinDesc functions_[Builtins::builtin_count + 1];
@@ skipping 152 matching lines @@
   BUILTIN_LIST_H(DEF_FUNCTION_PTR_H)
   BUILTIN_LIST_DEBUG_A(DEF_FUNCTION_PTR_A)
 
 #undef DEF_FUNCTION_PTR_C
 #undef DEF_FUNCTION_PTR_A
 #undef DEF_FUNCTION_PTR_T
 #undef DEF_FUNCTION_PTR_S
 #undef DEF_FUNCTION_PTR_H
 }
 
-
 void Builtins::SetUp(Isolate* isolate, bool create_heap_objects) {
   DCHECK(!initialized_);
 
   // Create a scope for the handles in the builtins.
   HandleScope scope(isolate);
 
 #define INITIALIZE_CALL_DESCRIPTOR(name, kind, extra, interface_descriptor) \
   { interface_descriptor##Descriptor descriptor(isolate); }
   BUILTIN_LIST_S(INITIALIZE_CALL_DESCRIPTOR)
 #undef INITIALIZE_CALL_DESCRIPTOR
@@ skipping 24 matching lines @@
       // Deserializing. The values will be filled in during IterateBuiltins.
       builtins_[i] = NULL;
     }
     names_[i] = functions[i].s_name;
   }
 
   // Mark as initialized.
   initialized_ = true;
 }
 
-
-void Builtins::TearDown() {
-  initialized_ = false;
-}
-
+void Builtins::TearDown() { initialized_ = false; }
 
 void Builtins::IterateBuiltins(ObjectVisitor* v) {
   v->VisitPointers(&builtins_[0], &builtins_[0] + builtin_count);
 }
 
-
 const char* Builtins::Lookup(byte* pc) {
   // may be called during initialization (disassembler!)
   if (initialized_) {
     for (int i = 0; i < builtin_count; i++) {
       Code* entry = Code::cast(builtins_[i]);
       if (entry->contains(pc)) {
         return names_[i];
       }
     }
   }
   return NULL;
 }
 
-
 void Builtins::Generate_InterruptCheck(MacroAssembler* masm) {
   masm->TailCallRuntime(Runtime::kInterrupt);
 }
 
-
 void Builtins::Generate_StackCheck(MacroAssembler* masm) {
   masm->TailCallRuntime(Runtime::kStackGuard);
 }
 
 namespace {
 
 void ValidateSharedTypedArray(CodeStubAssembler* a, compiler::Node* tagged,
                               compiler::Node* context,
                               compiler::Node** out_instance_type,
                               compiler::Node** out_backing_store) {
@@ skipping 241 matching lines @@
 #define DEFINE_BUILTIN_ACCESSOR_T(name, argc)                                 \
   Handle<Code> Builtins::name() {                                             \
     Code** code_address = reinterpret_cast<Code**>(builtin_address(k##name)); \
     return Handle<Code>(code_address);                                        \
   }
 #define DEFINE_BUILTIN_ACCESSOR_S(name, kind, extra, interface_descriptor)    \
   Handle<Code> Builtins::name() {                                             \
     Code** code_address = reinterpret_cast<Code**>(builtin_address(k##name)); \
     return Handle<Code>(code_address);                                        \
   }
-#define DEFINE_BUILTIN_ACCESSOR_H(name, kind)               \
-Handle<Code> Builtins::name() {                             \
-  Code** code_address =                                     \
-      reinterpret_cast<Code**>(builtin_address(k##name));   \
-  return Handle<Code>(code_address);                        \
-}
+#define DEFINE_BUILTIN_ACCESSOR_H(name, kind)                                 \
+  Handle<Code> Builtins::name() {                                             \
+    Code** code_address = reinterpret_cast<Code**>(builtin_address(k##name)); \
+    return Handle<Code>(code_address);                                        \
+  }
 BUILTIN_LIST_C(DEFINE_BUILTIN_ACCESSOR_C)
 BUILTIN_LIST_A(DEFINE_BUILTIN_ACCESSOR_A)
 BUILTIN_LIST_T(DEFINE_BUILTIN_ACCESSOR_T)
 BUILTIN_LIST_S(DEFINE_BUILTIN_ACCESSOR_S)
 BUILTIN_LIST_H(DEFINE_BUILTIN_ACCESSOR_H)
 BUILTIN_LIST_DEBUG_A(DEFINE_BUILTIN_ACCESSOR_A)
 #undef DEFINE_BUILTIN_ACCESSOR_C
 #undef DEFINE_BUILTIN_ACCESSOR_A
 #undef DEFINE_BUILTIN_ACCESSOR_T
 #undef DEFINE_BUILTIN_ACCESSOR_S
 #undef DEFINE_BUILTIN_ACCESSOR_H
 
 }  // namespace internal
 }  // namespace v8