Eliminate extended mode, and other modes clean-up

src/a64/code-stubs-a64.cc

 // Copyright 2013 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 2401 matching lines @@
   __ Mov(size, Operand(mapped_params, LSL, kPointerSizeLog2));
   __ Add(size, size, kParameterMapHeaderSize);
 
   // If there are no mapped parameters, set the running size total to zero.
   // Otherwise, use the parameter map size calculated earlier.
   __ Cmp(mapped_params, 0);
   __ CzeroX(size, eq);
 
   // 2. Add the size of the backing store and arguments object.
   __ Add(size, size, Operand(arg_count, LSL, kPointerSizeLog2));
-  __ Add(size, size, FixedArray::kHeaderSize + Heap::kArgumentsObjectSize);
+  __ Add(size, size,
+         FixedArray::kHeaderSize + Heap::kSloppyArgumentsObjectSize);
 
   // Do the allocation of all three objects in one go. Assign this to x0, as it
   // will be returned to the caller.
   Register alloc_obj = x0;
   __ Allocate(size, alloc_obj, x11, x12, &runtime, TAG_OBJECT);
 
   // Get the arguments boilerplate from the current (global) context.
 
   //   x0   alloc_obj     pointer to allocated objects (param map, backing
   //                      store, arguments)
   //   x1   mapped_params number of mapped parameters, min(params, args)
   //   x2   arg_count     number of function arguments
   //   x3   arg_count_smi number of function arguments (smi)
   //   x4   function      function pointer
   //   x7   param_count   number of function parameters
   //   x11  args_offset   offset to args (or aliased args) boilerplate (uninit)
   //   x14  recv_arg      pointer to receiver arguments
 
   Register global_object = x10;
   Register global_ctx = x10;
   Register args_offset = x11;
   Register aliased_args_offset = x10;
   __ Ldr(global_object, GlobalObjectMemOperand());
   __ Ldr(global_ctx, FieldMemOperand(global_object,
                                      GlobalObject::kNativeContextOffset));
 
-  __ Ldr(args_offset, ContextMemOperand(global_ctx,
-                                        Context::ARGUMENTS_BOILERPLATE_INDEX));
+  __ Ldr(args_offset,
+         ContextMemOperand(global_ctx,
+                           Context::SLOPPY_ARGUMENTS_BOILERPLATE_INDEX));
   __ Ldr(aliased_args_offset,
          ContextMemOperand(global_ctx,
                            Context::ALIASED_ARGUMENTS_BOILERPLATE_INDEX));
   __ Cmp(mapped_params, 0);
   __ CmovX(args_offset, aliased_args_offset, ne);
 
   // Copy the JS object part.
   __ CopyFields(alloc_obj, args_offset, CPURegList(x10, x12, x13),
                 JSObject::kHeaderSize / kPointerSize);
 
@@ skipping 18 matching lines @@
   //   x1   mapped_params number of mapped parameters, min(params, args)
   //   x2   arg_count     number of function arguments
   //   x3   arg_count_smi number of function arguments (smi)
   //   x4   function      function pointer
   //   x5   elements      pointer to parameter map or backing store (uninit)
   //   x6   backing_store pointer to backing store (uninit)
   //   x7   param_count   number of function parameters
   //   x14  recv_arg      pointer to receiver arguments
 
   Register elements = x5;
-  __ Add(elements, alloc_obj, Heap::kArgumentsObjectSize);
+  __ Add(elements, alloc_obj, Heap::kSloppyArgumentsObjectSize);
   __ Str(elements, FieldMemOperand(alloc_obj, JSObject::kElementsOffset));
 
   // Initialize parameter map. If there are no mapped arguments, we're done.
   Label skip_parameter_map;
   __ Cmp(mapped_params, 0);
   // Set up backing store address, because it is needed later for filling in
   // the unmapped arguments.
   Register backing_store = x6;
   __ CmovX(backing_store, elements, eq);
   __ B(eq, &skip_parameter_map);
@@ skipping 144 matching lines @@
   __ Add(x10, caller_fp, Operand(param_count, LSL, kPointerSizeLog2));
   __ Add(params, x10, StandardFrameConstants::kCallerSPOffset);
 
   // Try the new space allocation. Start out with computing the size of the
   // arguments object and the elements array in words.
   Register size = x10;
   __ Bind(&try_allocate);
   __ Add(size, param_count, FixedArray::kHeaderSize / kPointerSize);
   __ Cmp(param_count, 0);
   __ CzeroX(size, eq);
-  __ Add(size, size, Heap::kArgumentsObjectSizeStrict / kPointerSize);
+  __ Add(size, size, Heap::kStrictArgumentsObjectSize / kPointerSize);
 
   // Do the allocation of both objects in one go. Assign this to x0, as it will
   // be returned to the caller.
   Register alloc_obj = x0;
   __ Allocate(size, alloc_obj, x11, x12, &runtime,
               static_cast<AllocationFlags>(TAG_OBJECT | SIZE_IN_WORDS));
 
   // Get the arguments boilerplate from the current (native) context.
   Register global_object = x10;
   Register global_ctx = x10;
   Register args_offset = x4;
   __ Ldr(global_object, GlobalObjectMemOperand());
   __ Ldr(global_ctx, FieldMemOperand(global_object,
                                      GlobalObject::kNativeContextOffset));
   __ Ldr(args_offset,
          ContextMemOperand(global_ctx,
-                           Context::STRICT_MODE_ARGUMENTS_BOILERPLATE_INDEX));
+                           Context::STRICT_ARGUMENTS_BOILERPLATE_INDEX));
 
   //   x0   alloc_obj         pointer to allocated objects: parameter array and
   //                          arguments object
   //   x1   param_count_smi   number of parameters passed to function (smi)
   //   x2   params            pointer to parameters
   //   x3   function          function pointer
   //   x4   args_offset       offset to arguments boilerplate
   //   x13  param_count       number of parameters passed to function
 
   // Copy the JS object part.
   __ CopyFields(alloc_obj, args_offset, CPURegList(x5, x6, x7),
                 JSObject::kHeaderSize / kPointerSize);
 
   // Set the smi-tagged length as an in-object property.
   STATIC_ASSERT(Heap::kArgumentsLengthIndex == 0);
   const int kLengthOffset = JSObject::kHeaderSize +
                             Heap::kArgumentsLengthIndex * kPointerSize;
   __ Str(param_count_smi, FieldMemOperand(alloc_obj, kLengthOffset));
 
   // If there are no actual arguments, we're done.
   Label done;
   __ Cbz(param_count, &done);
 
   // Set up the elements pointer in the allocated arguments object and
   // initialize the header in the elements fixed array.
   Register elements = x5;
-  __ Add(elements, alloc_obj, Heap::kArgumentsObjectSizeStrict);
+  __ Add(elements, alloc_obj, Heap::kStrictArgumentsObjectSize);
   __ Str(elements, FieldMemOperand(alloc_obj, JSObject::kElementsOffset));
   __ LoadRoot(x10, Heap::kFixedArrayMapRootIndex);
   __ Str(x10, FieldMemOperand(elements, FixedArray::kMapOffset));
   __ Str(param_count_smi, FieldMemOperand(elements, FixedArray::kLengthOffset));
 
   //   x0   alloc_obj         pointer to allocated objects: parameter array and
   //                          arguments object
   //   x1   param_count_smi   number of parameters passed to function (smi)
   //   x2   params            pointer to parameters
   //   x3   function          function pointer
@@ skipping 3090 matching lines @@
                               MemOperand(fp, 6 * kPointerSize),
                               NULL);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64