CSE2410 Fall 2014 Bounce

#include "isolate-inl.h"

  Label align_loop_1, word_loop, byte_loop, byte_loop_1, done;

  Branch(&byte_loop, le, length, Operand(kPointerSize));

  Branch(&align_loop_1, ne, length, Operand(zero_reg));

void MacroAssembler::CallApiFunctionAndReturn(

    ExternalReference function,

    Address function_address,

    ExternalReference thunk_ref,

    Register thunk_last_arg,

    int stack_space,

    MemOperand return_value_operand,

    MemOperand* context_restore_operand) {

  Label exception_handled;

  lw(v0, return_value_operand);

  bind(&exception_handled);

  bool restore_context = context_restore_operand != NULL;

  if (restore_context) {

    lw(cp, *context_restore_operand);

  }

  LeaveExitFrame(false, s0, !restore_context, EMIT_RETURN);

  {

    FrameScope frame(this, StackFrame::INTERNAL);

    CallExternalReference(

        ExternalReference(Runtime::kPromoteScheduledException, isolate()),

        0);

  }

  jmp(&exception_handled);

                                 int num_arguments,

                                 SaveFPRegsMode save_doubles) {

  CEntryStub stub(1, save_doubles);

void MacroAssembler::Prologue(PrologueFrameMode frame_mode) {

  if (frame_mode == BUILD_STUB_FRAME) {

    Push(ra, fp, cp);

    Push(Smi::FromInt(StackFrame::STUB));

    // Adjust FP to point to saved FP.

    Addu(fp, sp, Operand(2 * kPointerSize));

  } else {

    PredictableCodeSizeScope predictible_code_size_scope(

      this, kNoCodeAgeSequenceLength * Assembler::kInstrSize);

    // The following three instructions must remain together and unmodified

    // for code aging to work properly.

    if (isolate()->IsCodePreAgingActive()) {

      // Pre-age the code.

      Code* stub = Code::GetPreAgedCodeAgeStub(isolate());

      nop(Assembler::CODE_AGE_MARKER_NOP);

      // Save the function's original return address

      // (it will be clobbered by Call(t9))

      mov(at, ra);

      // Load the stub address to t9 and call it

      li(t9,

         Operand(reinterpret_cast<uint32_t>(stub->instruction_start())));

      Call(t9);

      // Record the stub address in the empty space for GetCodeAgeAndParity()

      dd(reinterpret_cast<uint32_t>(stub->instruction_start()));

    } else {

      Push(ra, fp, cp, a1);

      nop(Assembler::CODE_AGE_SEQUENCE_NOP);

      // Adjust fp to point to caller's fp.

      Addu(fp, sp, Operand(2 * kPointerSize));

    }

  }

}

                                    bool restore_context,

  if (restore_context) {

    li(t8, Operand(ExternalReference(Isolate::kContextAddress, isolate())));

    lw(cp, MemOperand(t8));

  }

  li(t8, Operand(ExternalReference(Isolate::kContextAddress, isolate())));

void MacroAssembler::LookupNumberStringCache(Register object,

                                             Register result,

                                             Register scratch1,

                                             Register scratch2,

                                             Register scratch3,

                                             Label* not_found) {

  // 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.

  lw(mask, FieldMemOperand(number_string_cache, FixedArray::kLengthOffset));

  // Divide length by two (length is a smi).

  sra(mask, mask, kSmiTagSize + 1);

  Addu(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.

  Label is_smi;

  Label load_result_from_cache;

  JumpIfSmi(object, &is_smi);

  CheckMap(object,

           scratch1,

           Heap::kHeapNumberMapRootIndex,

           not_found,

           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));

  // Calculate address of entry in string cache: each entry consists

  // of two pointer sized fields.

  sll(scratch1, scratch1, kPointerSizeLog2 + 1);

  Addu(scratch1, number_string_cache, scratch1);

  Register probe = mask;

  lw(probe, FieldMemOperand(scratch1, FixedArray::kHeaderSize));

  JumpIfSmi(probe, not_found);

  ldc1(f12, FieldMemOperand(object, HeapNumber::kValueOffset));

  ldc1(f14, FieldMemOperand(probe, HeapNumber::kValueOffset));

  BranchF(&load_result_from_cache, NULL, eq, f12, f14);

  Branch(not_found);

  bind(&is_smi);

  Register scratch = scratch1;

  sra(scratch, object, 1);   // Shift away the tag.

  And(scratch, mask, Operand(scratch));

  // Calculate address of entry in string cache: each entry consists

  // of two pointer sized fields.

  sll(scratch, scratch, kPointerSizeLog2 + 1);

  Addu(scratch, number_string_cache, scratch);

  // Check if the entry is the smi we are looking for.

  lw(probe, FieldMemOperand(scratch, FixedArray::kHeaderSize));

  Branch(not_found, ne, object, Operand(probe));

  // Get the result from the cache.

  bind(&load_result_from_cache);

  lw(result, FieldMemOperand(scratch, FixedArray::kHeaderSize + kPointerSize));

  IncrementCounter(isolate()->counters()->number_to_string_native(),

                   1,

                   scratch1,

                   scratch2);

}

    Label* no_memento_found,

  Branch(no_memento_found, lt, scratch_reg, Operand(new_space_start));

  Branch(no_memento_found, gt, scratch_reg, Operand(at));

  if (allocation_memento_present) {

    Branch(allocation_memento_present, cond, scratch_reg,

           Operand(isolate()->factory()->allocation_memento_map()));

  }