Revert "[Arguments] Merge (7442,7496] from bleeding_edge."

src/ia32/codegen-ia32.cc

 // Copyright 2010 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 538 matching lines @@
 void CodeGenerator::ConvertInt32ResultToNumber(Result* value) {
   ASSERT(value->is_untagged_int32());
   if (value->is_register()) {
     Register val = value->reg();
     JumpTarget done;
     __ add(val, Operand(val));
     done.Branch(no_overflow, value);
     __ sar(val, 1);
     // If there was an overflow, bits 30 and 31 of the original number disagree.
     __ xor_(val, 0x80000000u);
-    if (CpuFeatures::IsSupported(SSE2)) {
+    if (masm()->isolate()->cpu_features()->IsSupported(SSE2)) {
       CpuFeatures::Scope fscope(SSE2);
       __ cvtsi2sd(xmm0, Operand(val));
     } else {
       // Move val to ST[0] in the FPU
       // Push and pop are safe with respect to the virtual frame because
       // all synced elements are below the actual stack pointer.
       __ push(val);
       __ fild_s(Operand(esp, 0));
       __ pop(val);
     }
     Result scratch = allocator_->Allocate();
     ASSERT(scratch.is_register());
     Label allocation_failed;
     __ AllocateHeapNumber(val, scratch.reg(),
                           no_reg, &allocation_failed);
     VirtualFrame* clone = new VirtualFrame(frame_);
     scratch.Unuse();
-    if (CpuFeatures::IsSupported(SSE2)) {
+    if (masm()->isolate()->cpu_features()->IsSupported(SSE2)) {
       CpuFeatures::Scope fscope(SSE2);
       __ movdbl(FieldOperand(val, HeapNumber::kValueOffset), xmm0);
     } else {
       __ fstp_d(FieldOperand(val, HeapNumber::kValueOffset));
     }
     done.Jump(value);
 
     // Establish the virtual frame, cloned from where AllocateHeapNumber
     // jumped to allocation_failed.
     RegisterFile empty_regs;
     SetFrame(clone, &empty_regs);
     __ bind(&allocation_failed);
-    if (!CpuFeatures::IsSupported(SSE2)) {
+    if (!masm()->isolate()->cpu_features()->IsSupported(SSE2)) {
       // Pop the value from the floating point stack.
       __ fstp(0);
     }
     unsafe_bailout_->Jump();
 
     done.Bind(value);
   } else {
     ASSERT(value->is_constant());
   }
   value->set_untagged_int32(false);
   value->set_type_info(TypeInfo::Integer32());
 }
 
 
 void CodeGenerator::Load(Expression* expr) {
 #ifdef DEBUG
   int original_height = frame_->height();
 #endif
   ASSERT(!in_spilled_code());
 
   // If the expression should be a side-effect-free 32-bit int computation,
   // compile that SafeInt32 path, and a bailout path.
   if (!in_safe_int32_mode() &&
       safe_int32_mode_enabled() &&
       expr->side_effect_free() &&
       expr->num_bit_ops() > 2 &&
-      CpuFeatures::IsSupported(SSE2)) {
+      masm()->isolate()->cpu_features()->IsSupported(SSE2)) {
     BreakTarget unsafe_bailout;
     JumpTarget done;
     unsafe_bailout.set_expected_height(frame_->height());
     LoadInSafeInt32Mode(expr, &unsafe_bailout);
     done.Jump();
 
     if (unsafe_bailout.is_linked()) {
       unsafe_bailout.Bind();
       LoadWithSafeInt32ModeDisabled(expr);
     }
@@ skipping 350 matching lines @@
   OverwriteMode mode_;
   Label answer_out_of_range_;
   Label non_smi_input_;
   Label constant_rhs_;
   Smi* smi_value_;
 };
 
 
 Label* DeferredInlineBinaryOperation::NonSmiInputLabel() {
   if (Token::IsBitOp(op_) &&
-      CpuFeatures::IsSupported(SSE2)) {
+      masm()->isolate()->cpu_features()->IsSupported(SSE2)) {
     return &non_smi_input_;
   } else {
     return entry_label();
   }
 }
 
 
 void DeferredInlineBinaryOperation::JumpToAnswerOutOfRange(Condition cond) {
   __ j(cond, &answer_out_of_range_);
 }
 
 
 void DeferredInlineBinaryOperation::JumpToConstantRhs(Condition cond,
                                                       Smi* smi_value) {
   smi_value_ = smi_value;
   __ j(cond, &constant_rhs_);
 }
 
 
 void DeferredInlineBinaryOperation::Generate() {
   // Registers are not saved implicitly for this stub, so we should not
   // tread on the registers that were not passed to us.
-  if (CpuFeatures::IsSupported(SSE2) &&
+  if (masm()->isolate()->cpu_features()->IsSupported(SSE2) &&
       ((op_ == Token::ADD) ||
        (op_ == Token::SUB) ||
        (op_ == Token::MUL) ||
        (op_ == Token::DIV))) {
     CpuFeatures::Scope use_sse2(SSE2);
     Label call_runtime, after_alloc_failure;
     Label left_smi, right_smi, load_right, do_op;
     if (!left_info_.IsSmi()) {
       __ test(left_, Immediate(kSmiTagMask));
       __ j(zero, &left_smi);
@@ skipping 115 matching lines @@
   }
 
   __ bind(&non_smi_input_);
 
   if (rhs_is_constant) {
     __ bind(&constant_rhs_);
     // In this case the input is a heap object and it is in the dst_ register.
     // The left_ and right_ registers have not been initialized yet.
     __ mov(right_, Immediate(smi_value_));
     __ mov(left_, Operand(dst_));
-    if (!CpuFeatures::IsSupported(SSE2)) {
+    if (!masm()->isolate()->cpu_features()->IsSupported(SSE2)) {
       __ jmp(entry_label());
       return;
     } else {
       CpuFeatures::Scope use_sse2(SSE2);
       __ JumpIfNotNumber(dst_, left_info_, entry_label());
       __ ConvertToInt32(dst_, left_, dst_, left_info_, entry_label());
       __ SmiUntag(right_);
     }
   } else {
     // We know we have SSE2 here because otherwise the label is not linked (see
@@ skipping 92 matching lines @@
   // Put a heap number pointer in left_.
   __ bind(&answer_out_of_range_);
   SaveRegisters();
   if (mode_ == OVERWRITE_LEFT) {
     __ test(left_, Immediate(kSmiTagMask));
     __ j(not_zero, &allocation_ok);
   }
   // This trashes right_.
   __ AllocateHeapNumber(left_, right_, no_reg, &after_alloc_failure2);
   __ bind(&allocation_ok);
-  if (CpuFeatures::IsSupported(SSE2) &&
+  if (masm()->isolate()->cpu_features()->IsSupported(SSE2) &&
       op_ != Token::SHR) {
     CpuFeatures::Scope use_sse2(SSE2);
     ASSERT(Token::IsBitOp(op_));
     // Signed conversion.
     __ cvtsi2sd(xmm0, Operand(dst_));
     __ movdbl(FieldOperand(left_, HeapNumber::kValueOffset), xmm0);
   } else {
     if (op_ == Token::SHR) {
       __ push(Immediate(0));  // High word of unsigned value.
       __ push(dst_);
@@ skipping 1744 matching lines @@
       } else {
         // Do the smi check, then the comparison.
         __ test(left_reg, Immediate(kSmiTagMask));
         is_smi.Branch(zero, left_side, right_side);
       }
 
       // Jump or fall through to here if we are comparing a non-smi to a
       // constant smi.  If the non-smi is a heap number and this is not
       // a loop condition, inline the floating point code.
       if (!is_loop_condition &&
-          CpuFeatures::IsSupported(SSE2)) {
+          masm()->isolate()->cpu_features()->IsSupported(SSE2)) {
         // Right side is a constant smi and left side has been checked
         // not to be a smi.
         CpuFeatures::Scope use_sse2(SSE2);
         JumpTarget not_number;
         __ cmp(FieldOperand(left_reg, HeapObject::kMapOffset),
                Immediate(FACTORY->heap_number_map()));
         not_number.Branch(not_equal, left_side);
         __ movdbl(xmm1,
                   FieldOperand(left_reg, HeapNumber::kValueOffset));
         int value = Smi::cast(*right_val)->value();
@@ skipping 143 matching lines @@
 
 
 void CodeGenerator::GenerateInlineNumberComparison(Result* left_side,
                                                    Result* right_side,
                                                    Condition cc,
                                                    ControlDestination* dest) {
   ASSERT(left_side->is_register());
   ASSERT(right_side->is_register());
 
   JumpTarget not_numbers;
-  if (CpuFeatures::IsSupported(SSE2)) {
+  if (masm()->isolate()->cpu_features()->IsSupported(SSE2)) {
     CpuFeatures::Scope use_sse2(SSE2);
 
     // Load left and right operand into registers xmm0 and xmm1 and compare.
     LoadComparisonOperandSSE2(masm_, left_side, xmm0, left_side, right_side,
                               &not_numbers);
     LoadComparisonOperandSSE2(masm_, right_side, xmm1, left_side, right_side,
                               &not_numbers);
     __ ucomisd(xmm0, xmm1);
   } else {
     Label check_right, compare;
@@ skipping 4221 matching lines @@
   __ AllocateHeapNumber(edi, ebx, ecx, &slow_allocate_heapnumber);
   __ jmp(&heapnumber_allocated);
 
   __ bind(&slow_allocate_heapnumber);
   // Allocate a heap number.
   __ CallRuntime(Runtime::kNumberAlloc, 0);
   __ mov(edi, eax);
 
   __ bind(&heapnumber_allocated);
 
-  __ PrepareCallCFunction(1, ebx);
-  __ mov(Operand(esp, 0), Immediate(ExternalReference::isolate_address()));
+  __ PrepareCallCFunction(0, ebx);
   __ CallCFunction(ExternalReference::random_uint32_function(masm()->isolate()),
-                   1);
+                   0);
 
   // Convert 32 random bits in eax to 0.(32 random bits) in a double
   // by computing:
   // ( 1.(20 0s)(32 random bits) x 2^20 ) - (1.0 x 2^20)).
   // This is implemented on both SSE2 and FPU.
-  if (CpuFeatures::IsSupported(SSE2)) {
+  if (masm()->isolate()->cpu_features()->IsSupported(SSE2)) {
     CpuFeatures::Scope fscope(SSE2);
     __ mov(ebx, Immediate(0x49800000));  // 1.0 x 2^20 as single.
     __ movd(xmm1, Operand(ebx));
     __ movd(xmm0, Operand(eax));
     __ cvtss2sd(xmm1, xmm1);
     __ pxor(xmm0, xmm1);
     __ subsd(xmm0, xmm1);
     __ movdbl(FieldOperand(edi, HeapNumber::kValueOffset), xmm0);
   } else {
     // 0x4130000000000000 is 1.0 x 2^20 as a double.
@@ skipping 385 matching lines @@
 
 
 // Generates the Math.pow method. Only handles special cases and
 // branches to the runtime system for everything else. Please note
 // that this function assumes that the callsite has executed ToNumber
 // on both arguments.
 void CodeGenerator::GenerateMathPow(ZoneList<Expression*>* args) {
   ASSERT(args->length() == 2);
   Load(args->at(0));
   Load(args->at(1));
-  if (!CpuFeatures::IsSupported(SSE2)) {
+  if (!masm()->isolate()->cpu_features()->IsSupported(SSE2)) {
     Result res = frame_->CallRuntime(Runtime::kMath_pow, 2);
     frame_->Push(&res);
   } else {
     CpuFeatures::Scope use_sse2(SSE2);
     Label allocate_return;
     // Load the two operands while leaving the values on the frame.
     frame()->Dup();
     Result exponent = frame()->Pop();
     exponent.ToRegister();
     frame()->Spill(exponent.reg());
@@ skipping 196 matching lines @@
   frame_->Push(&result);
 }
 
 
 // Generates the Math.sqrt method. Please note - this function assumes that
 // the callsite has executed ToNumber on the argument.
 void CodeGenerator::GenerateMathSqrt(ZoneList<Expression*>* args) {
   ASSERT_EQ(args->length(), 1);
   Load(args->at(0));
 
-  if (!CpuFeatures::IsSupported(SSE2)) {
+  if (!masm()->isolate()->cpu_features()->IsSupported(SSE2)) {
     Result result = frame()->CallRuntime(Runtime::kMath_sqrt, 1);
     frame()->Push(&result);
   } else {
     CpuFeatures::Scope use_sse2(SSE2);
     // Leave original value on the frame if we need to call runtime.
     frame()->Dup();
     Result result = frame()->Pop();
     result.ToRegister();
     frame()->Spill(result.reg());
     Label runtime;
@@ skipping 2075 matching lines @@
 
 #define __ masm.
 
 
 static void MemCopyWrapper(void* dest, const void* src, size_t size) {
   memcpy(dest, src, size);
 }
 
 
 OS::MemCopyFunction CreateMemCopyFunction() {
-  size_t actual_size;
-  // Allocate buffer in executable space.
-  byte* buffer = static_cast<byte*>(OS::Allocate(1 * KB,
-                                                 &actual_size,
-                                                 true));
-  if (buffer == NULL) return &MemCopyWrapper;
-  MacroAssembler masm(NULL, buffer, static_cast<int>(actual_size));
+  HandleScope scope;
+  MacroAssembler masm(NULL, 1 * KB);
 
   // Generated code is put into a fixed, unmovable, buffer, and not into
   // the V8 heap. We can't, and don't, refer to any relocatable addresses
   // (e.g. the JavaScript nan-object).
 
   // 32-bit C declaration function calls pass arguments on stack.
 
   // Stack layout:
   // esp[12]: Third argument, size.
   // esp[8]: Second argument, source pointer.
   // esp[4]: First argument, destination pointer.
   // esp[0]: return address
 
   const int kDestinationOffset = 1 * kPointerSize;
   const int kSourceOffset = 2 * kPointerSize;
   const int kSizeOffset = 3 * kPointerSize;
 
   int stack_offset = 0;  // Update if we change the stack height.
 
   if (FLAG_debug_code) {
     __ cmp(Operand(esp, kSizeOffset + stack_offset),
            Immediate(OS::kMinComplexMemCopy));
     Label ok;
     __ j(greater_equal, &ok);
     __ int3();
     __ bind(&ok);
   }
-  if (CpuFeatures::IsSupported(SSE2)) {
+  if (masm.isolate()->cpu_features()->IsSupported(SSE2)) {
     CpuFeatures::Scope enable(SSE2);
     __ push(edi);
     __ push(esi);
     stack_offset += 2 * kPointerSize;
     Register dst = edi;
     Register src = esi;
     Register count = ecx;
     __ mov(dst, Operand(esp, stack_offset + kDestinationOffset));
     __ mov(src, Operand(esp, stack_offset + kSourceOffset));
     __ mov(count, Operand(esp, stack_offset + kSizeOffset));
 
 
     __ movdqu(xmm0, Operand(src, 0));
     __ movdqu(Operand(dst, 0), xmm0);
     __ mov(edx, dst);
     __ and_(edx, 0xF);
     __ neg(edx);
     __ add(Operand(edx), Immediate(16));
     __ add(dst, Operand(edx));
     __ add(src, Operand(edx));
     __ sub(Operand(count), edx);
 
     // edi is now aligned. Check if esi is also aligned.
     Label unaligned_source;
     __ test(Operand(src), Immediate(0x0F));
     __ j(not_zero, &unaligned_source);
     {
+      __ IncrementCounter(masm.isolate()->counters()->memcopy_aligned(), 1);
       // Copy loop for aligned source and destination.
       __ mov(edx, count);
       Register loop_count = ecx;
       Register count = edx;
       __ shr(loop_count, 5);
       {
         // Main copy loop.
         Label loop;
         __ bind(&loop);
         __ prefetch(Operand(src, 0x20), 1);
@@ skipping 27 matching lines @@
       __ mov(eax, Operand(esp, stack_offset + kDestinationOffset));
       __ pop(esi);
       __ pop(edi);
       __ ret(0);
     }
     __ Align(16);
     {
       // Copy loop for unaligned source and aligned destination.
       // If source is not aligned, we can't read it as efficiently.
       __ bind(&unaligned_source);
+      __ IncrementCounter(masm.isolate()->counters()->memcopy_unaligned(), 1);
       __ mov(edx, ecx);
       Register loop_count = ecx;
       Register count = edx;
       __ shr(loop_count, 5);
       {
         // Main copy loop
         Label loop;
         __ bind(&loop);
         __ prefetch(Operand(src, 0x20), 1);
         __ movdqu(xmm0, Operand(src, 0x00));
@@ skipping 23 matching lines @@
       __ movdqu(xmm0, Operand(src, count, times_1, -0x10));
       __ movdqu(Operand(dst, count, times_1, -0x10), xmm0);
 
       __ mov(eax, Operand(esp, stack_offset + kDestinationOffset));
       __ pop(esi);
       __ pop(edi);
       __ ret(0);
     }
 
   } else {
+    __ IncrementCounter(masm.isolate()->counters()->memcopy_noxmm(), 1);
     // SSE2 not supported. Unlikely to happen in practice.
     __ push(edi);
     __ push(esi);
     stack_offset += 2 * kPointerSize;
     __ cld();
     Register dst = edi;
     Register src = esi;
     Register count = ecx;
     __ mov(dst, Operand(esp, stack_offset + kDestinationOffset));
     __ mov(src, Operand(esp, stack_offset + kSourceOffset));
@@ skipping 26 matching lines @@
     __ mov(eax, Operand(esp, stack_offset + kDestinationOffset));
     __ pop(esi);
     __ pop(edi);
     __ ret(0);
   }
 
   CodeDesc desc;
   masm.GetCode(&desc);
   ASSERT(desc.reloc_size == 0);
 
-  CPU::FlushICache(buffer, actual_size);
-  return FUNCTION_CAST<OS::MemCopyFunction>(buffer);
+  // Copy the generated code into an executable chunk and return a pointer
+  // to the first instruction in it as a C++ function pointer.
+  LargeObjectChunk* chunk = LargeObjectChunk::New(desc.instr_size, EXECUTABLE);
+  if (chunk == NULL) return &MemCopyWrapper;
+  memcpy(chunk->GetStartAddress(), desc.buffer, desc.instr_size);
+  CPU::FlushICache(chunk->GetStartAddress(), desc.instr_size);
+  return FUNCTION_CAST<OS::MemCopyFunction>(chunk->GetStartAddress());
 }
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_IA32