S390: Upstream changes from the past 2 weeks

src/s390/code-stubs-s390.cc

 // Copyright 2014 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.
 
 #if V8_TARGET_ARCH_S390
 
 #include "src/code-stubs.h"
 #include "src/api-arguments.h"
 #include "src/base/bits.h"
 #include "src/bootstrapper.h"
@@ skipping 459 matching lines @@
   __ bne(slow);  // First was a heap number, second wasn't.  Go slow case.
 
   // Both are heap numbers.  Load them up then jump to the code we have
   // for that.
   __ LoadDouble(d6, FieldMemOperand(rhs, HeapNumber::kValueOffset));
   __ LoadDouble(d7, FieldMemOperand(lhs, HeapNumber::kValueOffset));
 
   __ b(both_loaded_as_doubles);
 }
 
-// Fast negative check for internalized-to-internalized equality.
+// Fast negative check for internalized-to-internalized equality or receiver
+// equality. Also handles the undetectable receiver to null/undefined
+// comparison.
 static void EmitCheckForInternalizedStringsOrObjects(MacroAssembler* masm,
                                                      Register lhs, Register rhs,
                                                      Label* possible_strings,
                                                      Label* runtime_call) {
   DCHECK((lhs.is(r2) && rhs.is(r3)) || (lhs.is(r3) && rhs.is(r2)));
 
   // r4 is object type of rhs.
-  Label object_test, return_unequal, undetectable;
+  Label object_test, return_equal, return_unequal, undetectable;
   STATIC_ASSERT(kInternalizedTag == 0 && kStringTag == 0);
   __ mov(r0, Operand(kIsNotStringMask));
   __ AndP(r0, r4);
   __ bne(&object_test, Label::kNear);
   __ mov(r0, Operand(kIsNotInternalizedMask));
   __ AndP(r0, r4);
   __ bne(possible_strings);
   __ CompareObjectType(lhs, r5, r5, FIRST_NONSTRING_TYPE);
   __ bge(runtime_call);
   __ mov(r0, Operand(kIsNotInternalizedMask));
@@ skipping 20 matching lines @@
   __ CompareInstanceType(r5, r5, FIRST_JS_RECEIVER_TYPE);
   __ blt(runtime_call);
 
   __ bind(&return_unequal);
   // Return non-equal by returning the non-zero object pointer in r2.
   __ Ret();
 
   __ bind(&undetectable);
   __ AndP(r0, r7, Operand(1 << Map::kIsUndetectable));
   __ beq(&return_unequal);
+
+  // If both sides are JSReceivers, then the result is false according to
+  // the HTML specification, which says that only comparisons with null or
+  // undefined are affected by special casing for document.all.
+  __ CompareInstanceType(r4, r4, ODDBALL_TYPE);
+  __ beq(&return_equal);
+  __ CompareInstanceType(r5, r5, ODDBALL_TYPE);
+  __ bne(&return_unequal);
+
+  __ bind(&return_equal);
   __ LoadImmP(r2, Operand(EQUAL));
   __ Ret();
 }
 
 static void CompareICStub_CheckInputType(MacroAssembler* masm, Register input,
                                          Register scratch,
                                          CompareICState::State expected,
                                          Label* fail) {
   Label ok;
   if (expected == CompareICState::SMI) {
@@ skipping 130 matching lines @@
     StringHelper::GenerateCompareFlatOneByteStrings(masm, lhs, rhs, r4, r5, r6);
   }
   // Never falls through to here.
 
   __ bind(&slow);
 
   if (cc == eq) {
     {
       FrameAndConstantPoolScope scope(masm, StackFrame::INTERNAL);
       __ Push(lhs, rhs);
-      __ CallRuntime(strict() ? Runtime::kStrictEquals : Runtime::kEquals);
+      __ CallRuntime(strict() ? Runtime::kStrictEqual : Runtime::kEqual);
     }
     // Turn true into 0 and false into some non-zero value.
     STATIC_ASSERT(EQUAL == 0);
-    __ LoadRoot(r4, Heap::kTrueValueRootIndex);
-    __ sub(r3, r3, r4);
+    __ LoadRoot(r3, Heap::kTrueValueRootIndex);
+    __ SubP(r2, r2, r3);
     __ Ret();
   } else {
     __ Push(lhs, rhs);
     int ncr;  // NaN compare result
     if (cc == lt || cc == le) {
       ncr = GREATER;
     } else {
       DCHECK(cc == gt || cc == ge);  // remaining cases
       ncr = LESS;
     }
@@ skipping 2216 matching lines @@
   __ bind(&loop);
   __ LoadlB(scratch1, MemOperand(left, index));
   __ LoadlB(r0, MemOperand(right, index));
   __ CmpP(scratch1, r0);
   __ bne(chars_not_equal);
   __ AddP(index, Operand(1));
   __ CmpP(index, Operand::Zero());
   __ bne(&loop);
 }
 
-void StringCompareStub::Generate(MacroAssembler* masm) {
-  // ----------- S t a t e -------------
-  //  -- r3    : left
-  //  -- r2    : right
-  //  -- r14   : return address
-  // -----------------------------------
-  __ AssertString(r3);
-  __ AssertString(r2);
-
-  Label not_same;
-  __ CmpP(r2, r3);
-  __ bne(&not_same);
-  __ LoadSmiLiteral(r2, Smi::FromInt(EQUAL));
-  __ IncrementCounter(isolate()->counters()->string_compare_native(), 1, r3,
-                      r4);
-  __ Ret();
-
-  __ bind(&not_same);
-
-  // Check that both objects are sequential one-byte strings.
-  Label runtime;
-  __ JumpIfNotBothSequentialOneByteStrings(r3, r2, r4, r5, &runtime);
-
-  // Compare flat one-byte strings natively.
-  __ IncrementCounter(isolate()->counters()->string_compare_native(), 1, r4,
-                      r5);
-  StringHelper::GenerateCompareFlatOneByteStrings(masm, r3, r2, r4, r5, r6);
-
-  // Call the runtime; it returns -1 (less), 0 (equal), or 1 (greater)
-  // tagged as a small integer.
-  __ bind(&runtime);
-  __ Push(r3, r2);
-  __ TailCallRuntime(Runtime::kStringCompare);
-}
-
 void BinaryOpICWithAllocationSiteStub::Generate(MacroAssembler* masm) {
   // ----------- S t a t e -------------
   //  -- r3    : left
   //  -- r2    : right
   // r3: second string
   // -----------------------------------
 
   // Load r4 with the allocation site.  We stick an undefined dummy value here
   // and replace it with the real allocation site later when we instantiate this
   // stub in BinaryOpICWithAllocationSiteStub::GetCodeCopyFromTemplate().
@@ skipping 282 matching lines @@
   if (equality) {
     StringHelper::GenerateFlatOneByteStringEquals(masm, left, right, tmp1,
                                                   tmp2);
   } else {
     StringHelper::GenerateCompareFlatOneByteStrings(masm, left, right, tmp1,
                                                     tmp2, tmp3);
   }
 
   // Handle more complex cases in runtime.
   __ bind(&runtime);
-  __ Push(left, right);
   if (equality) {
-    __ TailCallRuntime(Runtime::kStringEquals);
+    {
+      FrameAndConstantPoolScope scope(masm, StackFrame::INTERNAL);
+      __ Push(left, right);
+      __ CallRuntime(Runtime::kStringEqual);
+    }
+    __ LoadRoot(r3, Heap::kTrueValueRootIndex);
+    __ SubP(r2, r2, r3);
+    __ Ret();
   } else {
+    __ Push(left, right);
     __ TailCallRuntime(Runtime::kStringCompare);
   }
 
   __ bind(&miss);
   GenerateMiss(masm);
 }
 
 void CompareICStub::GenerateReceivers(MacroAssembler* masm) {
   DCHECK_EQ(CompareICState::RECEIVER, state());
   Label miss;
@@ skipping 503 matching lines @@
 
   __ bind(&need_incremental);
 
   // Fall through when we need to inform the incremental marker.
 }
 
 void StubFailureTrampolineStub::Generate(MacroAssembler* masm) {
   CEntryStub ces(isolate(), 1, kSaveFPRegs);
   __ Call(ces.GetCode(), RelocInfo::CODE_TARGET);
   int parameter_count_offset =
-      StubFailureTrampolineFrame::kCallerStackParameterCountFrameOffset;
+      StubFailureTrampolineFrameConstants::kArgumentsLengthOffset;
   __ LoadP(r3, MemOperand(fp, parameter_count_offset));
   if (function_mode() == JS_FUNCTION_STUB_MODE) {
     __ AddP(r3, Operand(1));
   }
   masm->LeaveFrame(StackFrame::STUB_FAILURE_TRAMPOLINE);
   __ ShiftLeftP(r3, r3, Operand(kPointerSizeLog2));
   __ la(sp, MemOperand(r3, sp));
   __ Ret();
 }
 
@@ skipping 971 matching lines @@
   // we reach the JavaScript frame for the function (similar to what the
   // runtime fallback implementation does). So make r4 point to that
   // JavaScript frame.
   {
     Label loop, loop_entry;
     __ LoadRR(r4, fp);
     __ b(&loop_entry);
     __ bind(&loop);
     __ LoadP(r4, MemOperand(r4, StandardFrameConstants::kCallerFPOffset));
     __ bind(&loop_entry);
-    __ LoadP(ip, MemOperand(r4, StandardFrameConstants::kMarkerOffset));
+    __ LoadP(ip, MemOperand(r4, StandardFrameConstants::kFunctionOffset));
     __ CmpP(ip, r3);
     __ bne(&loop);
   }
 
   // Check if we have rest parameters (only possible if we have an
   // arguments adaptor frame below the function frame).
   Label no_rest_parameters;
   __ LoadP(r4, MemOperand(r4, StandardFrameConstants::kCallerFPOffset));
-  __ LoadP(ip, MemOperand(r4, StandardFrameConstants::kContextOffset));
+  __ LoadP(ip, MemOperand(r4, CommonFrameConstants::kContextOrFrameTypeOffset));
   __ CmpSmiLiteral(ip, Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR), r0);
   __ bne(&no_rest_parameters);
 
   // Check if the arguments adaptor frame contains more arguments than
   // specified by the function's internal formal parameter count.
   Label rest_parameters;
   __ LoadP(r2, MemOperand(r4, ArgumentsAdaptorFrameConstants::kLengthOffset));
   __ LoadP(r3, FieldMemOperand(r3, JSFunction::kSharedFunctionInfoOffset));
   __ LoadW(
       r3, FieldMemOperand(r3, SharedFunctionInfo::kFormalParameterCountOffset));
@@ skipping 127 matching lines @@
   // r3 : function
   // r4 : number of parameters (tagged)
   // r5 : parameters pointer
   // Registers used over whole function:
   // r7 : arguments count (tagged)
   // r8 : mapped parameter count (tagged)
 
   // Check if the calling frame is an arguments adaptor frame.
   Label adaptor_frame, try_allocate, runtime;
   __ LoadP(r6, MemOperand(fp, StandardFrameConstants::kCallerFPOffset));
-  __ LoadP(r2, MemOperand(r6, StandardFrameConstants::kContextOffset));
+  __ LoadP(r2, MemOperand(r6, CommonFrameConstants::kContextOrFrameTypeOffset));
   __ CmpSmiLiteral(r2, Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR), r0);
   __ beq(&adaptor_frame);
 
   // No adaptor, parameter count = argument count.
   __ LoadRR(r7, r4);
   __ LoadRR(r8, r4);
   __ b(&try_allocate);
 
   // We have an adaptor frame. Patch the parameters pointer.
   __ bind(&adaptor_frame);
@@ skipping 206 matching lines @@
   // we reach the JavaScript frame for the function (similar to what the
   // runtime fallback implementation does). So make r4 point to that
   // JavaScript frame.
   {
     Label loop, loop_entry;
     __ LoadRR(r4, fp);
     __ b(&loop_entry);
     __ bind(&loop);
     __ LoadP(r4, MemOperand(r4, StandardFrameConstants::kCallerFPOffset));
     __ bind(&loop_entry);
-    __ LoadP(ip, MemOperand(r4, StandardFrameConstants::kMarkerOffset));
+    __ LoadP(ip, MemOperand(r4, StandardFrameConstants::kFunctionOffset));
     __ CmpP(ip, r3);
     __ bne(&loop);
   }
 
   // Check if we have an arguments adaptor frame below the function frame.
   Label arguments_adaptor, arguments_done;
   __ LoadP(r5, MemOperand(r4, StandardFrameConstants::kCallerFPOffset));
-  __ LoadP(ip, MemOperand(r5, StandardFrameConstants::kContextOffset));
+  __ LoadP(ip, MemOperand(r5, CommonFrameConstants::kContextOrFrameTypeOffset));
   __ CmpSmiLiteral(ip, Smi::FromInt(StackFrame::ARGUMENTS_ADAPTOR), r0);
   __ beq(&arguments_adaptor);
   {
     __ LoadP(r3, FieldMemOperand(r3, JSFunction::kSharedFunctionInfoOffset));
     __ LoadW(r2, FieldMemOperand(
                      r3, SharedFunctionInfo::kFormalParameterCountOffset));
 #if V8_TARGET_ARCH_S390X
     __ SmiTag(r2);
 #endif
     __ SmiToPtrArrayOffset(r8, r2);
@@ skipping 390 matching lines @@
   STATIC_ASSERT(FCA::kCalleeIndex == 5);
   STATIC_ASSERT(FCA::kDataIndex == 4);
   STATIC_ASSERT(FCA::kReturnValueOffset == 3);
   STATIC_ASSERT(FCA::kReturnValueDefaultValueIndex == 2);
   STATIC_ASSERT(FCA::kIsolateIndex == 1);
   STATIC_ASSERT(FCA::kHolderIndex == 0);
   STATIC_ASSERT(FCA::kArgsLength == 7);
 
   // context save
   __ push(context);
-  if (!is_lazy) {
+  if (!is_lazy()) {
     // load context from callee
     __ LoadP(context, FieldMemOperand(callee, JSFunction::kContextOffset));
   }
 
   // callee
   __ push(callee);
 
   // call data
   __ push(call_data);
 
@@ skipping 135 matching lines @@
   CallApiFunctionAndReturn(masm, api_function_address, thunk_ref,
                            kStackUnwindSpace, NULL, return_value_operand, NULL);
 }
 
 #undef __
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TARGET_ARCH_S390