MIPS: Minor fixes to simulator and builtins-mips.

src/mips/code-stubs-mips.cc

 // Copyright 2011 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 1454 matching lines @@
   Label is_smi;
   Label load_result_from_cache;
   if (!object_is_smi) {
     __ JumpIfSmi(object, &is_smi);
     if (CpuFeatures::IsSupported(FPU)) {
       CpuFeatures::Scope scope(FPU);
       __ CheckMap(object,
                   scratch1,
                   Heap::kHeapNumberMapRootIndex,
                   not_found,
-                  true);
+                  DONT_DO_SMI_CHECK);
 
       STATIC_ASSERT(8 == kDoubleSize);
       __ Addu(scratch1,
               object,
               Operand(HeapNumber::kValueOffset - kHeapObjectTag));
       __ lw(scratch2, MemOperand(scratch1, kPointerSize));
       __ lw(scratch1, MemOperand(scratch1, 0));
       __ Xor(scratch1, scratch1, Operand(scratch2));
       __ And(scratch1, scratch1, Operand(mask));
 
@@ skipping 243 matching lines @@
   // Call the native; it returns -1 (less), 0 (equal), or 1 (greater)
   // tagged as a small integer.
   __ InvokeBuiltin(native, JUMP_FUNCTION);
 }
 
 
 // This stub does not handle the inlined cases (Smis, Booleans, undefined).
 // The stub returns zero for false, and a non-zero value for true.
 void ToBooleanStub::Generate(MacroAssembler* masm) {
   // This stub uses FPU instructions.
-  ASSERT(CpuFeatures::IsEnabled(FPU));
+  CpuFeatures::Scope scope(FPU);
 
   Label false_result;
   Label not_heap_number;
   Register scratch0 = t5.is(tos_) ? t3 : t5;
 
+  // undefined -> false
+  __ LoadRoot(scratch0, Heap::kUndefinedValueRootIndex);
+  __ Branch(&false_result, eq, tos_, Operand(scratch0));
+
+  // Boolean -> its value
+  __ LoadRoot(scratch0, Heap::kFalseValueRootIndex);
+  __ Branch(&false_result, eq, tos_, Operand(scratch0));
+  __ LoadRoot(scratch0, Heap::kTrueValueRootIndex);
+  // "tos_" is a register and contains a non-zero value.  Hence we implicitly
+  // return true if the equal condition is satisfied.
+  __ Ret(eq, tos_, Operand(scratch0));
+
+  // Smis: 0 -> false, all other -> true
+  __ And(scratch0, tos_, tos_);
+  __ Branch(&false_result, eq, scratch0, Operand(zero_reg));
+  __ And(scratch0, tos_, Operand(kSmiTagMask));
+  // "tos_" is a register and contains a non-zero value.  Hence we implicitly
+  // return true if the not equal condition is satisfied.
+  __ Ret(eq, scratch0, Operand(zero_reg));
+
+  // 'null' -> false
   __ LoadRoot(scratch0, Heap::kNullValueRootIndex);
   __ Branch(&false_result, eq, tos_, Operand(scratch0));
 
   // HeapNumber => false if +0, -0, or NaN.
   __ lw(scratch0, FieldMemOperand(tos_, HeapObject::kMapOffset));
   __ LoadRoot(at, Heap::kHeapNumberMapRootIndex);
   __ Branch(&not_heap_number, ne, scratch0, Operand(at));
 
-  __ Subu(at, tos_, Operand(kHeapObjectTag));
-  __ ldc1(f12, MemOperand(at, HeapNumber::kValueOffset));
+  __ ldc1(f12, FieldMemOperand(tos_, HeapNumber::kValueOffset));
   __ fcmp(f12, 0.0, UEQ);
 
   // "tos_" is a register, and contains a non zero value by default.
   // Hence we only need to overwrite "tos_" with zero to return false for
   // FP_ZERO or FP_NAN cases. Otherwise, by default it returns true.
   __ movt(tos_, zero_reg);
   __ Ret();
 
   __ bind(&not_heap_number);
 
-  // Check if the value is 'null'.
-  // 'null' => false.
-  __ LoadRoot(at, Heap::kNullValueRootIndex);
-  __ Branch(&false_result, eq, tos_, Operand(at));
-
   // It can be an undetectable object.
   // Undetectable => false.
   __ lw(at, FieldMemOperand(tos_, HeapObject::kMapOffset));
   __ lbu(scratch0, FieldMemOperand(at, Map::kBitFieldOffset));
   __ And(scratch0, scratch0, Operand(1 << Map::kIsUndetectable));
   __ Branch(&false_result, eq, scratch0, Operand(1 << Map::kIsUndetectable));
 
   // JavaScript object => true.
   __ lw(scratch0, FieldMemOperand(tos_, HeapObject::kMapOffset));
   __ lbu(scratch0, FieldMemOperand(scratch0, Map::kInstanceTypeOffset));
@@ skipping 157 matching lines @@
     case Token::BIT_NOT:
       GenerateHeapNumberStubBitNot(masm);
       break;
     default:
       UNREACHABLE();
   }
 }
 
 
 void TypeRecordingUnaryOpStub::GenerateHeapNumberStubSub(MacroAssembler* masm) {
-  Label non_smi, slow;
-  GenerateSmiCodeSub(masm, &non_smi, &slow);
+  Label non_smi, slow, call_builtin;
+  GenerateSmiCodeSub(masm, &non_smi, &call_builtin);
   __ bind(&non_smi);
   GenerateHeapNumberCodeSub(masm, &slow);
   __ bind(&slow);
   GenerateTypeTransition(masm);
+  __ bind(&call_builtin);
+  GenerateGenericCodeFallback(masm);
 }
 
 
 void TypeRecordingUnaryOpStub::GenerateHeapNumberStubBitNot(
     MacroAssembler* masm) {
   Label non_smi, slow;
   GenerateSmiCodeBitNot(masm, &non_smi);
   __ bind(&non_smi);
   GenerateHeapNumberCodeBitNot(masm, &slow);
   __ bind(&slow);
@@ skipping 1215 matching lines @@
       __ mfc1(a2, f4);
       __ mfc1(a3, f5);
       __ Branch(&loaded);
 
       __ bind(&input_not_smi);
       // Check if input is a HeapNumber.
       __ CheckMap(a0,
                   a1,
                   Heap::kHeapNumberMapRootIndex,
                   &calculate,
-                  true);
+                  DONT_DO_SMI_CHECK);
       // Input is a HeapNumber. Store the
       // low and high words into a2, a3.
       __ lw(a2, FieldMemOperand(a0, HeapNumber::kValueOffset));
       __ lw(a3, FieldMemOperand(a0, HeapNumber::kValueOffset + 4));
     } else {
       // Input is untagged double in f4. Output goes to f4.
       __ mfc1(a2, f4);
       __ mfc1(a3, f5);
     }
     __ bind(&loaded);
@@ skipping 558 matching lines @@
   // caller fp          |
   // function slot      | entry frame
   // context slot       |
   // bad fp (0xff...f)  |
   // callee saved registers + ra
   // 4 args slots
   // args
 
   #ifdef ENABLE_LOGGING_AND_PROFILING
     // If this is the outermost JS call, set js_entry_sp value.
+    Label non_outermost_js;
     ExternalReference js_entry_sp(Isolate::k_js_entry_sp_address,
                                   masm->isolate());
     __ li(t1, Operand(ExternalReference(js_entry_sp)));
     __ lw(t2, MemOperand(t1));
-    {
-      Label skip;
-      __ Branch(&skip, ne, t2, Operand(zero_reg));
-      __ sw(fp, MemOperand(t1));
-      __ bind(&skip);
-    }
+    __ Branch(&non_outermost_js, ne, t2, Operand(zero_reg));
+    __ sw(fp, MemOperand(t1));
+    __ li(t0, Operand(Smi::FromInt(StackFrame::OUTERMOST_JSENTRY_FRAME)));
+    Label cont;
+    __ b(&cont);
+    __ nop();   // Branch delay slot nop.
+    __ bind(&non_outermost_js);
+    __ li(t0, Operand(Smi::FromInt(StackFrame::INNER_JSENTRY_FRAME)));
+    __ bind(&cont);
+    __ push(t0);
   #endif
 
   // Call a faked try-block that does the invoke.
   __ bal(&invoke);  // bal exposes branch delay slot.
   __ nop();   // Branch delay slot nop.
 
   // Caught exception: Store result (exception) in the pending
   // exception field in the JSEnv and return a failure sentinel.
   // Coming in here the fp will be invalid because the PushTryHandler below
   // sets it to 0 to signal the existence of the JSEntry frame.
@@ skipping 45 matching lines @@
   } else {
     ExternalReference entry(Builtins::kJSEntryTrampoline, masm->isolate());
     __ li(t0, Operand(entry));
   }
   __ lw(t9, MemOperand(t0));  // Deref address.
 
   // Call JSEntryTrampoline.
   __ addiu(t9, t9, Code::kHeaderSize - kHeapObjectTag);
   __ Call(t9);
 
-  // Unlink this frame from the handler chain. When reading the
-  // address of the next handler, there is no need to use the address
-  // displacement since the current stack pointer (sp) points directly
-  // to the stack handler.
-  __ lw(t1, MemOperand(sp, StackHandlerConstants::kNextOffset));
-  __ li(t0, Operand(ExternalReference(Isolate::k_handler_address,
-                                      masm->isolate())));
-  __ sw(t1, MemOperand(t0));
+  // Unlink this frame from the handler chain.
+  __ PopTryHandler();
 
-  // This restores sp to its position before PushTryHandler.
-  __ addiu(sp, sp, StackHandlerConstants::kSize);
+  __ bind(&exit);  // v0 holds result
+  #ifdef ENABLE_LOGGING_AND_PROFILING
+    // Check if the current stack frame is marked as the outermost JS frame.
+    Label non_outermost_js_2;
+    __ pop(t1);
+    __ Branch(&non_outermost_js_2, ne, t1,
+              Operand(Smi::FromInt(StackFrame::OUTERMOST_JSENTRY_FRAME)));
+    __ li(t1, Operand(ExternalReference(js_entry_sp)));
+    __ sw(zero_reg, MemOperand(t1));
+    __ bind(&non_outermost_js_2);
+  #endif
 
-#ifdef ENABLE_LOGGING_AND_PROFILING
-  // If current FP value is the same as js_entry_sp value, it means that
-  // the current function is the outermost.
-  __ li(t1, Operand(ExternalReference(js_entry_sp)));
-  __ lw(t2, MemOperand(t1));
-  {
-    Label skip;
-    __ Branch(&skip, ne, fp, Operand(t2));
-    __ sw(zero_reg, MemOperand(t1));
-    __ bind(&skip);
-  }
-#endif
-
-  __ bind(&exit);  // v0 holds result.
   // Restore the top frame descriptors from the stack.
   __ pop(t1);
   __ li(t0, Operand(ExternalReference(Isolate::k_c_entry_fp_address,
                                       masm->isolate())));
   __ sw(t1, MemOperand(t0));
 
   // Reset the stack to the callee saved registers.
   __ addiu(sp, sp, -EntryFrameConstants::kCallerFPOffset);
 
   // Restore callee saved registers from the stack.
@@ skipping 961 matching lines @@
     MacroAssembler* masm, const RuntimeCallHelper& call_helper) {
   __ Abort("Unexpected fallthrough to CharCodeAt slow case");
 
   // Index is not a smi.
   __ bind(&index_not_smi_);
   // If index is a heap number, try converting it to an integer.
   __ CheckMap(index_,
               scratch_,
               Heap::kHeapNumberMapRootIndex,
               index_not_number_,
-              true);
+              DONT_DO_SMI_CHECK);
   call_helper.BeforeCall(masm);
   // Consumed by runtime conversion function:
   __ Push(object_, index_, index_);
   if (index_flags_ == STRING_INDEX_IS_NUMBER) {
     __ CallRuntime(Runtime::kNumberToIntegerMapMinusZero, 1);
   } else {
     ASSERT(index_flags_ == STRING_INDEX_IS_ARRAY_INDEX);
     // NumberToSmi discards numbers that are not exact integers.
     __ CallRuntime(Runtime::kNumberToSmi, 1);
   }
@@ skipping 1746 matching lines @@
   __ mov(result, zero_reg);
   __ Ret();
 }
 
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_MIPS