A64: Synchronize with r15814.

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 20 matching lines @@
 
 #include "bootstrapper.h"
 #include "code-stubs.h"
 #include "regexp-macro-assembler.h"
 #include "stub-cache.h"
 
 namespace v8 {
 namespace internal {
 
 
+void ToNumberStub::InitializeInterfaceDescriptor(
+    Isolate* isolate,
+    CodeStubInterfaceDescriptor* descriptor) {
+  // x0: value
+  static Register registers[] = { x0 };
+  descriptor->register_param_count_ = sizeof(registers) / sizeof(registers[0]);
+  descriptor->register_params_ = registers;
+  descriptor->deoptimization_handler_ = NULL;
+}
+
+
 void FastCloneShallowArrayStub::InitializeInterfaceDescriptor(
     Isolate* isolate,
     CodeStubInterfaceDescriptor* descriptor) {
   // x3: array literals array
   // x2: array literal index
   // x1: constant elements
   static Register registers[] = { x3, x2, x1 };
   descriptor->register_param_count_ = sizeof(registers) / sizeof(registers[0]);
   descriptor->register_params_ = registers;
   descriptor->deoptimization_handler_ =
@@ skipping 218 matching lines @@
   // x2: key (unused)
   // x0: value
   static Register registers[] = { x1, x2, x0 };
   descriptor->register_param_count_ = sizeof(registers) / sizeof(registers[0]);
   descriptor->register_params_ = registers;
   descriptor->deoptimization_handler_ =
       FUNCTION_ADDR(StoreIC_MissFromStubFailure);
 }
 
 
-#if 0
-// TODO(jbramley): This was added in r15635, then reverted in r15674, but it
-// will come back again in r15713.
 void ElementsTransitionAndStoreStub::InitializeInterfaceDescriptor(
     Isolate* isolate,
     CodeStubInterfaceDescriptor* descriptor) {
   // x0: value
   // x3: target map
   // x1: key
   // x2: receiver
   static Register registers[] = { x0, x3, x1, x2 };
   descriptor->register_param_count_ = sizeof(registers) / sizeof(registers[0]);
   descriptor->register_params_ = registers;
   descriptor->deoptimization_handler_ =
       FUNCTION_ADDR(ElementsTransitionAndStoreIC_Miss);
 }
-#endif
 
 
 #define __ ACCESS_MASM(masm)
 
 
 void HydrogenCodeStub::GenerateLightweightMiss(MacroAssembler* masm) {
   // Update the static counter each time a new code stub is generated.
   Isolate* isolate = masm->isolate();
   isolate->counters()->code_stubs()->Increment();
 
@@ skipping 10 matching lines @@
       __ Push(descriptor->register_params_[i]);
     }
     ExternalReference miss = descriptor->miss_handler();
     __ CallExternalReference(miss, descriptor->register_param_count_);
   }
 
   __ Ret();
 }
 
 
-// Input:
-//   x0: object to convert.
-// Output:
-//   x0: result number.
-void ToNumberStub::Generate(MacroAssembler* masm) {
-  // See ECMA-262 section 9.3.
-
-  // If it is a Smi or a HeapNumber, just return the value.
-  Label done;
-  __ JumpIfSmi(x0, &done);
-  __ JumpIfHeapNumber(x0, &done);
-
-  // Inline checks for specific values that we can easily convert.
-  Label return_zero, return_one;
-
-  // Check for 'true', 'false', and 'null'.
-  __ JumpIfRoot(x0, Heap::kTrueValueRootIndex, &return_one);
-  __ JumpIfRoot(x0, Heap::kFalseValueRootIndex, &return_zero);
-  __ JumpIfRoot(x0, Heap::kNullValueRootIndex, &return_zero);
-
-  // Call a builtin to do the job.
-  __ Push(x0);
-  __ InvokeBuiltin(Builtins::TO_NUMBER, JUMP_FUNCTION);
-
-  // We never fall through here.
-  if (FLAG_debug_code) {
-    __ Abort("We should never reach this code.");
-  }
-
-  __ Bind(&return_zero);
-  __ Mov(x0, Operand(Smi::FromInt(0)));
-  __ Ret();
-
-  __ Bind(&return_one);
-  __ Mov(x0, Operand(Smi::FromInt(1)));
-  __ Bind(&done);
-  __ Ret();
-}
-
-
 void FastNewClosureStub::Generate(MacroAssembler* masm) {
   // Create a new closure from the given function info in new space. Set the
   // context to the current context in cp.
   Register new_fn = x0;
   Register function = x1;
 
   Counters* counters = masm->isolate()->counters();
 
   Label gc;
 
@@ skipping 399 matching lines @@
 
   // If right or left is not ODDBALL, test left >= FIRST_SPEC_OBJECT_TYPE.
   // Otherwise, right or left is ODDBALL, so set a ge condition.
   __ Ccmp(left_type, FIRST_SPEC_OBJECT_TYPE, NVFlag, ne);
 
   __ B(ge, &return_not_equal);
 
   // Internalized strings are unique, so they can only be equal if they are the
   // same object. We have already tested that case, so if left and right are
   // both internalized strings, they cannot be equal.
-  __ And(scratch, right_type, kIsNotStringMask | kIsInternalizedMask);
-  __ Cmp(scratch, kInternalizedTag | kStringTag);
-  __ And(scratch, left_type, kIsNotStringMask | kIsInternalizedMask);
-  __ Ccmp(scratch, kInternalizedTag | kStringTag, NoFlag, eq);
-  __ B(eq, &return_not_equal);
+  STATIC_ASSERT((kInternalizedTag == 0) && (kStringTag == 0));
+  __ Orr(scratch, left_type, right_type);
+  __ TestAndBranchIfAllClear(
+      scratch, kIsNotStringMask | kIsNotInternalizedMask, &return_not_equal);
 }
 
 
 // See call site for description.
 static void EmitSmiNonsmiComparison(MacroAssembler* masm,
                                     Register left,
                                     Register right,
                                     FPRegister left_d,
                                     FPRegister right_d,
                                     Register scratch,
@@ skipping 71 matching lines @@
                                                      Register left_map,
                                                      Register right_map,
                                                      Register left_type,
                                                      Register right_type,
                                                      Label* possible_strings,
                                                      Label* not_both_strings) {
   ASSERT(!AreAliased(left, right, left_map, right_map, left_type, right_type));
   Register result = x0;
 
   Label object_test;
-  STATIC_ASSERT(kStringTag == 0);
-  STATIC_ASSERT(kInternalizedTag != 0);
+  STATIC_ASSERT((kInternalizedTag == 0) && (kStringTag == 0));
   // TODO(all): reexamine this branch sequence for optimisation wrt branch
   // prediction.
   __ Tbnz(right_type, MaskToBit(kIsNotStringMask), &object_test);
-  __ Tbz(right_type, MaskToBit(kIsInternalizedMask), possible_strings);
+  __ Tbnz(right_type, MaskToBit(kIsNotInternalizedMask), possible_strings);
   __ Tbnz(left_type, MaskToBit(kIsNotStringMask), not_both_strings);
-  __ Tbz(left_type, MaskToBit(kIsInternalizedMask), possible_strings);
+  __ Tbnz(left_type, MaskToBit(kIsNotInternalizedMask), possible_strings);
 
   // Both are internalized. We already checked that they weren't the same
   // pointer, so they are not equal.
   __ Mov(result, NOT_EQUAL);
   __ Ret();
 
   __ Bind(&object_test);
 
   __ Cmp(right_type, FIRST_SPEC_OBJECT_TYPE);
 
@@ skipping 745 matching lines @@
   // Test if left operand is a smi or string.
   __ JumpIfSmi(left, &call_transition);
   __ JumpIfObjectType(left, x2, x2, FIRST_NONSTRING_TYPE, &call_transition, ge);
 
   // Test if right operand is a smi or string.
   __ JumpIfSmi(right, &call_transition);
   __ JumpIfObjectType(right, x2, x2, FIRST_NONSTRING_TYPE, &call_transition,
                       ge);
 
   StringAddStub string_add_stub(
-      static_cast<StringAddFlags>(ERECT_FRAME | NO_STRING_CHECK_IN_STUB));
+      static_cast<StringAddFlags>(STRING_ADD_CHECK_NONE |
+                                  STRING_ADD_ERECT_FRAME));
   GenerateRegisterArgsPush(masm);
   __ TailCallStub(&string_add_stub);
 
   __ Bind(&call_transition);
   GenerateTypeTransition(masm);
 }
 
 
 void BinaryOpStub::GenerateInt32Stub(MacroAssembler* masm) {
   // On a64 the smis are 32 bits, so we should never see the INT32 type.
@@ skipping 92 matching lines @@
   Label left_not_string, call_runtime;
 
   Register left = x1;
   Register right = x0;
 
   // Check if left argument is a string.
   __ JumpIfSmi(left, &left_not_string);
   __ JumpIfObjectType(left, x2, x2, FIRST_NONSTRING_TYPE, &left_not_string, ge);
 
   StringAddStub string_add_left_stub(
-      static_cast<StringAddFlags>(ERECT_FRAME | NO_STRING_CHECK_LEFT_IN_STUB));
+      static_cast<StringAddFlags>(STRING_ADD_CHECK_RIGHT |
+                                  STRING_ADD_ERECT_FRAME));
   GenerateRegisterArgsPush(masm);
   __ TailCallStub(&string_add_left_stub);
 
   // Left operand is not a string, test right.
   __ Bind(&left_not_string);
   __ JumpIfSmi(right, &call_runtime);
   __ JumpIfObjectType(right, x2, x2, FIRST_NONSTRING_TYPE, &call_runtime, ge);
 
   StringAddStub string_add_right_stub(
-      static_cast<StringAddFlags>(ERECT_FRAME | NO_STRING_CHECK_RIGHT_IN_STUB));
+      static_cast<StringAddFlags>(STRING_ADD_CHECK_LEFT |
+                                  STRING_ADD_ERECT_FRAME));
   GenerateRegisterArgsPush(masm);
   __ TailCallStub(&string_add_right_stub);
 
   // Neither argument is a string.
   __ Bind(&call_runtime);
 }
 
 
 void BinaryOpStub_GenerateHeapResultAllocation(MacroAssembler* masm,
                                                Register result,
@@ skipping 2936 matching lines @@
   // Check that both operands are internalized strings.
   Register rhs_map = x10;
   Register lhs_map = x11;
   Register rhs_type = x10;
   Register lhs_type = x11;
   __ Ldr(lhs_map, FieldMemOperand(lhs, HeapObject::kMapOffset));
   __ Ldr(rhs_map, FieldMemOperand(rhs, HeapObject::kMapOffset));
   __ Ldrb(lhs_type, FieldMemOperand(lhs_map, Map::kInstanceTypeOffset));
   __ Ldrb(rhs_type, FieldMemOperand(rhs_map, Map::kInstanceTypeOffset));
 
-  __ And(x12, rhs_type, kIsNotStringMask | kIsInternalizedMask);
-  __ And(x13, lhs_type, kIsNotStringMask | kIsInternalizedMask);
-  __ Cmp(x12, kInternalizedTag | kStringTag);
-  __ Ccmp(x13, kInternalizedTag | kStringTag, NoFlag, eq);
-  __ B(ne, &miss);
+  STATIC_ASSERT((kInternalizedTag == 0) && (kStringTag == 0));
+  __ Orr(x12, lhs_type, rhs_type);
+  __ TestAndBranchIfAnySet(
+      x12, kIsNotStringMask | kIsNotInternalizedMask, &miss);
 
   // Internalized strings are compared by identity.
   STATIC_ASSERT(EQUAL == 0);
   __ Cmp(lhs, rhs);
   __ Cset(result, ne);
   __ Ret();
 
   __ Bind(&miss);
   GenerateMiss(masm);
 }
@@ skipping 74 matching lines @@
   __ Ret();
 
   __ Bind(&not_equal);
   // Handle not identical strings
 
   // Check that both strings are internalized strings. If they are, we're done
   // because we already know they are not identical. We know they are both
   // strings.
   if (equality) {
     ASSERT(GetCondition() == eq);
-    STATIC_ASSERT(kInternalizedTag != 0);
+    STATIC_ASSERT(kInternalizedTag == 0);
     Label not_internalized_strings;
-    __ And(x12, lhs_type, rhs_type);
-    __ Tbz(x12, MaskToBit(kIsInternalizedMask), &not_internalized_strings);
+    __ Orr(x12, lhs_type, rhs_type);
+    __ TestAndBranchIfAnySet(
+        x12, kIsNotInternalizedMask, &not_internalized_strings);
     // Result is in rhs (x0), and not EQUAL, as rhs is not a smi.
     __ Ret();
     __ Bind(&not_internalized_strings);
   }
 
   // Check that both strings are sequential ASCII.
   Label runtime;
   __ JumpIfBothInstanceTypesAreNotSequentialAscii(
       lhs_type, rhs_type, x12, x13, &runtime);
 
@@ skipping 107 matching lines @@
   __ Jump(stub_entry);
 }
 
 
 void NumberToStringStub::GenerateLookupNumberStringCache(MacroAssembler* masm,
                                                          Register object,
                                                          Register result,
                                                          Register scratch1,
                                                          Register scratch2,
                                                          Register scratch3,
-                                                         ObjectType object_type,
                                                          Label* not_found) {
   ASSERT(!AreAliased(object, result, scratch1, scratch2, scratch3));
 
   // Use of registers. Register result is used as a temporary.
   Register number_string_cache = result;
   Register mask = scratch3;
 
   // Load the number string cache.
   __ LoadRoot(number_string_cache, Heap::kNumberStringCacheRootIndex);
 
   // Make the hash mask from the length of the number string cache. It
   // contains two elements (number and string) for each cache entry.
   __ Ldrsw(mask, UntagSmiFieldMemOperand(number_string_cache,
                                          FixedArray::kLengthOffset));
   __ Asr(mask, mask, 1);  // Divide length by two.
   __ Sub(mask, mask, 1);  // Make mask.
 
   // Calculate the entry in the number string cache. The hash value in the
   // number string cache for smis is just the smi value, and the hash for
   // doubles is the xor of the upper and lower words. See
   // Heap::GetNumberStringCache.
   Isolate* isolate = masm->isolate();
   Label is_smi;
   Label load_result_from_cache;
-  if (object_type == OBJECT_IS_NOT_SMI) {
-    __ JumpIfSmi(object, &is_smi);
-    __ CheckMap(object, scratch1, Heap::kHeapNumberMapRootIndex, not_found,
-                DONT_DO_SMI_CHECK);
 
-    STATIC_ASSERT(kDoubleSize == (kWRegSizeInBytes * 2));
-    __ Add(scratch1, object, HeapNumber::kValueOffset - kHeapObjectTag);
-    __ Ldp(scratch1.W(), scratch2.W(), MemOperand(scratch1));
-    __ Eor(scratch1, scratch1, scratch2);
-    __ And(scratch1, scratch1, mask);
+  __ JumpIfSmi(object, &is_smi);
+  __ CheckMap(object, scratch1, Heap::kHeapNumberMapRootIndex, not_found,
+              DONT_DO_SMI_CHECK);
 
-    // Calculate address of entry in string cache: each entry consists of two
-    // pointer sized fields.
-    __ Add(scratch1, number_string_cache,
-           Operand(scratch1, LSL, kPointerSizeLog2 + 1));
+  STATIC_ASSERT(kDoubleSize == (kWRegSizeInBytes * 2));
+  __ Add(scratch1, object, HeapNumber::kValueOffset - kHeapObjectTag);
+  __ Ldp(scratch1.W(), scratch2.W(), MemOperand(scratch1));
+  __ Eor(scratch1, scratch1, scratch2);
+  __ And(scratch1, scratch1, mask);
 
-    Register probe = mask;
-    __ Ldr(probe, FieldMemOperand(scratch1, FixedArray::kHeaderSize));
-    __ JumpIfSmi(probe, not_found);
-    __ Ldr(d0, FieldMemOperand(object, HeapNumber::kValueOffset));
-    __ Ldr(d1, FieldMemOperand(probe, HeapNumber::kValueOffset));
-    __ Fcmp(d0, d1);
-    __ B(ne, not_found);
-    __ B(&load_result_from_cache);
-  }
+  // Calculate address of entry in string cache: each entry consists of two
+  // pointer sized fields.
+  __ Add(scratch1, number_string_cache,
+         Operand(scratch1, LSL, kPointerSizeLog2 + 1));
+
+  Register probe = mask;
+  __ Ldr(probe, FieldMemOperand(scratch1, FixedArray::kHeaderSize));
+  __ JumpIfSmi(probe, not_found);
+  __ Ldr(d0, FieldMemOperand(object, HeapNumber::kValueOffset));
+  __ Ldr(d1, FieldMemOperand(probe, HeapNumber::kValueOffset));
+  __ Fcmp(d0, d1);
+  __ B(ne, not_found);
+  __ B(&load_result_from_cache);
 
   __ Bind(&is_smi);
   Register scratch = scratch1;
   __ And(scratch, mask, Operand::UntagSmi(object));
   // Calculate address of entry in string cache: each entry consists
   // of two pointer sized fields.
   __ Add(scratch,
          number_string_cache,
          Operand(scratch, LSL, kPointerSizeLog2 + 1));
 
   // Check if the entry is the smi we are looking for.
-  Register probe = mask;
   __ Ldr(probe, FieldMemOperand(scratch, FixedArray::kHeaderSize));
   __ Cmp(object, probe);
   __ B(ne, not_found);
 
   // Get the result from the cache.
   __ Bind(&load_result_from_cache);
   __ Ldr(result,
          FieldMemOperand(scratch, FixedArray::kHeaderSize + kPointerSize));
   __ IncrementCounter(isolate->counters()->number_to_string_native(), 1,
                       scratch1, scratch2);
 }
 
 
 void NumberToStringStub::Generate(MacroAssembler* masm) {
   Register result = x0;
   Register object = x1;
   Label runtime;
 
   __ Pop(object);
 
   // Generate code to lookup number in the number string cache.
-  GenerateLookupNumberStringCache(masm, object, result, x2, x3, x4,
-                                  NumberToStringStub::OBJECT_IS_NOT_SMI,
-                                  &runtime);
+  GenerateLookupNumberStringCache(masm, object, result, x2, x3, x4, &runtime);
   __ Ret();
 
   // Handle number to string in the runtime system if not found in the cache.
   __ Bind(&runtime);
   __ Push(object);
   __ TailCallRuntime(Runtime::kNumberToStringSkipCache, 1, 1);
 }
 
 
 void StringHelper::GenerateTwoCharacterStringTableProbe(MacroAssembler* masm,
@@ skipping 632 matching lines @@
   Register result = x0;
   Register left = x10;
   Register right = x11;
   Register left_type = x12;
   Register right_type = x13;
 
   // Pop the two arguments from the stack.
   __ Pop(right, left);
 
   // Make sure that both arguments are strings if not known in advance.
-  if ((flags_ & NO_STRING_ADD_FLAGS) != 0) {
+  // Otherwise, at least one of the arguments is definitely a string,
+  // and we convert the one that is not known to be a string.
+  if ((flags_ & STRING_ADD_CHECK_BOTH) == STRING_ADD_CHECK_BOTH) {
+    ASSERT((flags_ & STRING_ADD_CHECK_LEFT) == STRING_ADD_CHECK_LEFT);
+    ASSERT((flags_ & STRING_ADD_CHECK_RIGHT) == STRING_ADD_CHECK_RIGHT);
     __ JumpIfEitherSmi(right, left, &call_runtime);
     // Load instance types.
     StringHelper::LoadPairInstanceTypes(masm, left_type, right_type, left,
                                         right);
     STATIC_ASSERT(kStringTag == 0);
     // If either is not a string, go to runtime.
     __ Tbnz(left_type, MaskToBit(kIsNotStringMask), &call_runtime);
     __ Tbnz(right_type, MaskToBit(kIsNotStringMask), &call_runtime);
-  } else {
-    // Here at least one of the arguments is definitely a string.
-    // We convert the one that is not known to be a string.
-    if ((flags_ & NO_STRING_CHECK_LEFT_IN_STUB) == 0) {
-      // NO_STRING_CHECK_LEFT flag is clear: convert the left string.
-      ASSERT((flags_ & NO_STRING_CHECK_RIGHT_IN_STUB) != 0);
-      GenerateConvertArgument(masm, left, x12, x13, x14, x15, &call_builtin);
-      builtin_id = Builtins::STRING_ADD_RIGHT;
-    } else if ((flags_ & NO_STRING_CHECK_RIGHT_IN_STUB) == 0) {
-      // NO_STRING_CHECK_RIGHT flag is clear: convert the right string.
-      ASSERT((flags_ & NO_STRING_CHECK_LEFT_IN_STUB) != 0);
-      GenerateConvertArgument(masm, right, x12, x13, x14, x15, &call_builtin);
-      builtin_id = Builtins::STRING_ADD_LEFT;
-    }
+  } else if ((flags_ & STRING_ADD_CHECK_LEFT) == STRING_ADD_CHECK_LEFT) {
+    ASSERT((flags_ & STRING_ADD_CHECK_RIGHT) == 0);
+    GenerateConvertArgument(masm, left, x12, x13, x14, x15, &call_builtin);
+    builtin_id = Builtins::STRING_ADD_RIGHT;
+  } else if ((flags_ & STRING_ADD_CHECK_RIGHT) == STRING_ADD_CHECK_RIGHT) {
+    ASSERT((flags_ & STRING_ADD_CHECK_LEFT) == 0);
+    GenerateConvertArgument(masm, right, x12, x13, x14, x15, &call_builtin);
+    builtin_id = Builtins::STRING_ADD_LEFT;
   }
 
   // Both arguments are strings.
   //   x0   result      pointer to result string object (uninit)
   //   x10  left        pointer to first string object
   //   x11  right       pointer to second string object
-  // if (flags_ == NO_STRING_ADD_FLAGS) {
-  //   x12  left_type   first string instance type
-  //   x13  right_type  second string instance type
-  // }
+  //   x12  left_type   first string instance type (if STRING_ADD_CHECK_BOTH)
+  //   x13  right_type  second string instance type (if STRING_ADD_CHECK_BOTH)
   Register left_len = x14;
   Register right_len = x15;
   {
     Label strings_not_empty;
     // Speculatively move pointer to left string into the result register.
     __ Mov(result, left);
     // Check if either of the strings are empty. In that case return the other.
     __ Ldrsw(left_len, UntagSmiFieldMemOperand(left, String::kLengthOffset));
     __ Ldrsw(right_len, UntagSmiFieldMemOperand(right, String::kLengthOffset));
     // Test if first string is empty.
     __ Cmp(left_len, 0);
     // If first is empty, return second.
     __ CmovX(result, right, eq);
     // Else test if second string is empty.
     __ Ccmp(right_len, 0, ZFlag, ne);
     // If either string was empty, return result.
     __ B(ne, &strings_not_empty);
 
     __ IncrementCounter(counters->string_add_native(), 1, x3, x4);
     __ Ret();
 
     __ Bind(&strings_not_empty);
   }
 
   // Load string instance types.
-  if (flags_ != NO_STRING_ADD_FLAGS) {
+  if ((flags_ & STRING_ADD_CHECK_BOTH) != STRING_ADD_CHECK_BOTH) {
     StringHelper::LoadPairInstanceTypes(masm, left_type, right_type, left,
                                         right);
   }
 
   // Both strings are non-empty.
   //   x10  left        first string
   //   x11  right       second string
   //   x12  left_type   first string instance type
   //   x13  right_type  second string instance type
   //   x14  left_len    length of first string
@@ skipping 237 matching lines @@
   __ Add(right_len, right_len, right_len);
   __ CopyBytes(result_char, right_char, right_len, temp, kCopyShort);
   __ IncrementCounter(counters->string_add_native(), 1, x3, x4);
   __ Ret();
 
 
   // Just jump to runtime to add the two strings.
   __ Bind(&call_runtime);
   // Restore stack arguments.
   __ Push(left, right);
-  if ((flags_ & ERECT_FRAME) != 0) {
+  if ((flags_ & STRING_ADD_ERECT_FRAME) != 0) {
     GenerateRegisterArgsPop(masm);
     // Build a frame
     {
       FrameScope scope(masm, StackFrame::INTERNAL);
       GenerateRegisterArgsPush(masm);
       __ CallRuntime(Runtime::kStringAdd, 2);
     }
     __ Ret();
   } else {
     __ TailCallRuntime(Runtime::kStringAdd, 2, 1);
   }
 
   if (call_builtin.is_linked()) {
     __ Bind(&call_builtin);
     // Restore stack arguments.
     __ Push(left, right);
-    if ((flags_ & ERECT_FRAME) != 0) {
+    if ((flags_ & STRING_ADD_ERECT_FRAME) != 0) {
       GenerateRegisterArgsPop(masm);
       // Build a frame
       {
         FrameScope scope(masm, StackFrame::INTERNAL);
         GenerateRegisterArgsPush(masm);
         __ InvokeBuiltin(builtin_id, CALL_FUNCTION);
       }
       __ Ret();
     } else {
       __ InvokeBuiltin(builtin_id, JUMP_FUNCTION);
@@ skipping 20 matching lines @@
   Label not_cached;
   __ Bind(&not_string);
   // Puts the cache result into scratch1.
   NumberToStringStub::GenerateLookupNumberStringCache(
       masm,
       arg,
       scratch1,
       scratch2,
       scratch3,
       scratch4,
-      NumberToStringStub::OBJECT_IS_NOT_SMI,
       &not_cached);
   __ Mov(arg, scratch1);
   __ B(&done);
 
   // Check if the argument is a safe string wrapper.
   __ Bind(&not_cached);
   __ JumpIfSmi(arg, slow);
   Register map = scratch1;
   __ JumpIfNotObjectType(arg, map, scratch2, JS_VALUE_TYPE, slow);
   __ Ldrb(scratch2, FieldMemOperand(map, Map::kBitField2Offset));
@@ skipping 995 matching lines @@
   __ Bind(&fast_elements_case);
   GenerateCase(masm, FAST_ELEMENTS);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_A64