CSE2410 Fall 2014 Bounce

                                            Register receiver,

                                            Register scratch1,

                                            Register scratch2,

  Label check_wrapper;

  // Check if the object is a string leaving the instance type in the

  // scratch register.

  // Load length from the string and convert to a smi.

  __ mov(eax, FieldOperand(receiver, String::kLengthOffset));

  __ ret(0);

}

// Generates call to API function.

static void GenerateFastApiCall(MacroAssembler* masm,

                                const CallOptimization& optimization,

  // ----------- S t a t e -------------

  //  -- esp[0]              : return address

  //  -- ...

  // -----------------------------------

  // Get the function and setup the context.

  Handle<JSFunction> function = optimization.constant_function();

  __ LoadHeapObject(edi, function);

  __ mov(esi, FieldOperand(edi, JSFunction::kContextOffset));

  Handle<CallHandlerInfo> api_call_info = optimization.api_call_info();

  Handle<Object> call_data(api_call_info->data(), masm->isolate());

  if (masm->isolate()->heap()->InNewSpace(*call_data)) {

    __ mov(ecx, api_call_info);

    __ mov(ebx, FieldOperand(ecx, CallHandlerInfo::kDataOffset));

  } else {

  }

         Immediate(reinterpret_cast<int>(masm->isolate())));

         masm->isolate()->factory()->undefined_value());

         masm->isolate()->factory()->undefined_value());

  // Prepare arguments.

  // API function gets reference to the v8::Arguments. If CPU profiler

  // is enabled wrapper function will be called and we need to pass

  Address function_address = v8::ToCData<Address>(api_call_info->callback());

  __ PrepareCallApiFunction(kApiArgc + kApiStackSpace);

  __ mov(ApiParameterOperand(2), eax);

  __ mov(ApiParameterOperand(3), eax);

  __ Set(ApiParameterOperand(4), Immediate(argc));

  __ Set(ApiParameterOperand(5), Immediate(0));

  // v8::InvocationCallback's argument.

  Address thunk_address = FUNCTION_ADDR(&InvokeFunctionCallback);

  __ CallApiFunctionAndReturn(function_address,

                              thunk_address,

                              ApiParameterOperand(1),

                              argc + kFastApiCallArguments + 1,

}

  ASSERT(!receiver.is(scratch));

  const int stack_space = kFastApiCallArguments + argc + 1;

  // Copy return value.

  __ mov(scratch, Operand(esp, 0));

  // Assign stack space for the call arguments.

  // Move the return address on top of the stack.

  __ mov(Operand(esp, 0), scratch);

  // Write holder to stack frame.

  // Write receiver to stack frame.

  int index = stack_space;

  __ mov(Operand(esp, index-- * kPointerSize), receiver);

    __ mov(Operand(esp, index-- * kPointerSize), values[i]);

  }

}

    // Invoke function.

    if (can_do_fast_api_call) {

    } else {

      CallKind call_kind = CallICBase::Contextual::decode(extra_state_)

          ? CALL_AS_FUNCTION

};

  if (!label->is_unused()) {

    __ bind(label);

    __ mov(this->name(), Immediate(name));

}

    MacroAssembler* masm,

    Handle<JSObject> holder,

    Register holder_reg,

// Receiver_reg is preserved on jumps to miss_label, but may be destroyed if

// store is successful.

  int descriptor = transition->LastAdded();

  DescriptorArray* descriptors = transition->instance_descriptors();

  PropertyDetails details = descriptors->GetDetails(descriptor);

    __ SmiUntag(value_reg);

    if (CpuFeatures::IsSupported(SSE2)) {

      CpuFeatureScope use_sse2(masm, SSE2);

    } else {

      __ push(value_reg);

      __ fild_s(Operand(esp, 0));

                miss_label, DONT_DO_SMI_CHECK);

    if (CpuFeatures::IsSupported(SSE2)) {

      CpuFeatureScope use_sse2(masm, SSE2);

    } else {

      __ fld_d(FieldOperand(value_reg, HeapNumber::kValueOffset));

    }

    __ bind(&do_store);

    if (CpuFeatures::IsSupported(SSE2)) {

      CpuFeatureScope use_sse2(masm, SSE2);

    } else {

      __ fstp_d(FieldOperand(storage_reg, HeapNumber::kValueOffset));

    }

// Both name_reg and receiver_reg are preserved on jumps to miss_label,

// but may be destroyed if store is successful.

  // Stub never generated for non-global objects that require access

  // checks.

  ASSERT(object->IsJSGlobalProxy() || !object->IsAccessCheckNeeded());

    __ SmiUntag(value_reg);

    if (CpuFeatures::IsSupported(SSE2)) {

      CpuFeatureScope use_sse2(masm, SSE2);

    } else {

      __ push(value_reg);

      __ fild_s(Operand(esp, 0));

                miss_label, DONT_DO_SMI_CHECK);

    if (CpuFeatures::IsSupported(SSE2)) {

      CpuFeatureScope use_sse2(masm, SSE2);

    } else {

      __ fld_d(FieldOperand(value_reg, HeapNumber::kValueOffset));

    }

    __ bind(&do_store);

    if (CpuFeatures::IsSupported(SSE2)) {

      CpuFeatureScope use_sse2(masm, SSE2);

    } else {

      __ fstp_d(FieldOperand(scratch1, HeapNumber::kValueOffset));

    }

                                       int save_at_depth,

                                       Label* miss,

                                       PrototypeCheckType check) {

  // Make sure that the type feedback oracle harvests the receiver map.

  // TODO(svenpanne) Remove this hack when all ICs are reworked.

  __ mov(scratch1, Handle<Map>(object->map()));

  int depth = 0;

  if (save_at_depth == depth) {

  }

  // Traverse the prototype chain and check the maps in the prototype chain for

    }

    if (save_at_depth == depth) {

    }

    // Go to the next object in the prototype chain.

}

  if (!miss->is_unused()) {

    __ jmp(success);

    __ bind(miss);

}

  if (!miss->is_unused()) {

    __ jmp(success);

    GenerateRestoreName(masm(), miss, name);

}

    Handle<JSObject> object,

    Register object_reg,

    Handle<JSObject> holder,

}

    Handle<JSObject> object,

    Handle<JSObject> last,

    Handle<Name> name,

}

  if (!reg.is(receiver())) __ mov(receiver(), reg);

  if (kind() == Code::LOAD_IC) {

    LoadFieldStub stub(field.is_inobject(holder),

}

    const CallOptimization& call_optimization) {

  GenerateFastApiCall(

      masm(), call_optimization, receiver(), scratch3(), 0, NULL);

}

    Register reg,

    Handle<ExecutableAccessorInfo> callback) {

  // Insert additional parameters into the stack frame above return address.

  ASSERT(!scratch3().is(reg));

  __ pop(scratch3());  // Get return address to place it below.

  __ push(receiver());  // receiver

  // Push data from ExecutableAccessorInfo.

  if (isolate()->heap()->InNewSpace(callback->data())) {

  } else {

    __ push(Immediate(Handle<Object>(callback->data(), isolate())));

  }

  __ push(Immediate(reinterpret_cast<int>(isolate())));

  __ push(reg);  // holder

  __ push(name());  // name

  __ mov(ebx, esp);  // esp points to reference to name (handler).

                              thunk_address,

                              ApiParameterOperand(2),

                              kStackSpace,

}

  // Return the constant value.

  __ LoadObject(eax, value);

  __ ret(0);

}

    Register holder_reg,

    Handle<JSObject> object,

    Handle<JSObject> interceptor_holder,

  // Check if the argument is a heap number and load its value into xmm0.

  Label slow;

  __ CheckMap(eax, factory()->heap_number_map(), &slow, DONT_DO_SMI_CHECK);

  // Check if the argument is strictly positive. Note this also

  // discards NaN.

  // Return a new heap number.

  __ AllocateHeapNumber(eax, ebx, edx, &slow);

  __ ret(2 * kPointerSize);

  // Return the argument (when it's an already round heap number).

  // esp[2 * kPointerSize] is uninitialized, esp[3 * kPointerSize] contains

  // duplicate of return address and will be overwritten.

  __ bind(&miss);

  __ add(esp, Immediate(kFastApiCallArguments * kPointerSize));

void LoadStubCompiler::GenerateLoadViaGetter(MacroAssembler* masm,

                                             Handle<JSFunction> getter) {

  {

    FrameScope scope(masm, StackFrame::INTERNAL);

    if (!getter.is_null()) {

      // Call the JavaScript getter with the receiver on the stack.

      ParameterCount actual(0);

      ParameterCount expected(getter);

      __ InvokeFunction(getter, expected, actual,