CSE2410 Fall 2014 Bounce

  void DebugBreak();

#endif

  // Enter specific kind of exit frame; either in normal or

  // debug mode. Expects the number of arguments in register rax and

  // sets up the number of arguments in register rdi and the pointer

  // Leave the current exit frame. Expects/provides the return value in

  // register rax (untouched).

  // Push and pop the registers that can hold pointers.

  void PushSafepointRegisters() { Pushad(); }

  // Smis represent a subset of integers. The subset is always equivalent to

  // a two's complement interpretation of a fixed number of bits.

  // Add an integer constant to a tagged smi, giving a tagged smi as result.

  // No overflow testing on the result is done.

  void SmiAddConstant(Register dst, Register src, Smi* constant);

              Label::Distance near_jump = Label::kFar);

  // Adds smi values and return the result as a smi.

  void SmiAdd(Register dst,

              Register src1,

              Register src2,

              Register src2);

  // Subtracts smi values and return the result as a smi.

  void SmiSub(Register dst,

              Register src1,

              Register src2,

              Label* on_not_smi_result,

              Label::Distance near_jump = Label::kFar);

  void SmiSub(Register dst,

              Register src1,

              const Operand& src2,

  void SmiSub(Register dst,

              Register src1,

              const Operand& src2);

  // Multiplies smi values and return the result as a smi,

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

  // String macros.

  // If object is a string, its map is loaded into object_map.

  void JumpIfNotString(Register object,

                       Register object_map,

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

  // Macro instructions.

  // Load a register with a long value as efficiently as possible.

  void Set(Register dst, int64_t x);

  void Set(const Operand& dst, int64_t x);

  // Move if the registers are not identical.

  void Move(Register target, Register source);

  // Load a heap object and handle the case of new-space objects by

  // indirecting via a global cell.

  // Load a global cell into a register.

  void LoadGlobalCell(Register dst, Handle<Cell> cell);

  void Pop(Register dst) { pop(dst); }

  void PushReturnAddressFrom(Register src) { push(src); }

  void PopReturnAddressTo(Register dst) { pop(dst); }

  // Control Flow

  void Jump(Address destination, RelocInfo::Mode rmode);

                Label* gc_required,

                AllocationFlags flags);

  // Undo allocation in new space. The object passed and objects allocated after

  // it will no longer be allocated. Make sure that no pointers are left to the

  // object(s) no longer allocated as they would be invalid when allocation is

  void StubReturn(int argc);

  // Call a runtime routine.

  // Call a runtime function and save the value of XMM registers.

  // Convenience function: Same as above, but takes the fid instead.

  // Convenience function: call an external reference.

  void CallExternalReference(const ExternalReference& ext,

                                Address thunk_address,

                                Register thunk_last_arg,

                                int stack_space,

  // Before calling a C-function from generated code, align arguments on stack.

  // After aligning the frame, arguments must be stored in rsp[0], rsp[8],

  // to another type.

  // On entry, receiver_reg should point to the array object.

  // scratch_reg gets clobbered.

  void TestJSArrayForAllocationMemento(Register receiver_reg,

 private:

  // Order general registers are pushed by Pushad.

  // accessible via StackSpaceOperand.

  void EnterExitFrameEpilogue(int arg_stack_space, bool save_doubles);

  // Allocation support helpers.

  // Loads the top of new-space into the result register.