CSE2410 Fall 2014 Bounce

  void SetExpressionPosition(Expression* expr);

class BackEdgeTable {

 public:

  BackEdgeTable(Code* code, DisallowHeapAllocation* required) {

    ASSERT(code->kind() == Code::FUNCTION);

    instruction_start_ = code->instruction_start();

    Address table_address = instruction_start_ + code->back_edge_table_offset();

    length_ = Memory::uint32_at(table_address);

    start_ = table_address + kTableLengthSize;

  }

  uint32_t length() { return length_; }

  BailoutId ast_id(uint32_t index) {

    return BailoutId(static_cast<int>(

        Memory::uint32_at(entry_at(index) + kAstIdOffset)));

  }

  uint32_t loop_depth(uint32_t index) {

    return Memory::uint32_at(entry_at(index) + kLoopDepthOffset);

  }

  uint32_t pc_offset(uint32_t index) {

    return Memory::uint32_at(entry_at(index) + kPcOffsetOffset);

  }

  Address pc(uint32_t index) {

    return instruction_start_ + pc_offset(index);

  }

  enum BackEdgeState {

    INTERRUPT,

    ON_STACK_REPLACEMENT,

    OSR_AFTER_STACK_CHECK

  };

  // Patch all interrupts with allowed loop depth in the unoptimized code to

  // unconditionally call replacement_code.

  static void Patch(Isolate* isolate,

                    Code* unoptimized_code);

  // Patch the back edge to the target state, provided the correct callee.

  static void PatchAt(Code* unoptimized_code,

                      Address pc,

                      BackEdgeState target_state,

                      Code* replacement_code);

  // Change all patched back edges back to normal interrupts.

  static void Revert(Isolate* isolate,

                     Code* unoptimized_code);

  // Change a back edge patched for on-stack replacement to perform a

  // stack check first.

  static void AddStackCheck(CompilationInfo* info);

  // Remove the stack check, if available, and replace by on-stack replacement.

  static void RemoveStackCheck(CompilationInfo* info);

  // Return the current patch state of the back edge.

  static BackEdgeState GetBackEdgeState(Isolate* isolate,

                                        Code* unoptimized_code,

                                        Address pc_after);

#ifdef DEBUG

  // Verify that all back edges of a certain loop depth are patched.

  static bool Verify(Isolate* isolate,

                     Code* unoptimized_code,

                     int loop_nesting_level);

#endif  // DEBUG

 private:

  Address entry_at(uint32_t index) {

    ASSERT(index < length_);

    return start_ + index * kEntrySize;

  }

  static const int kTableLengthSize = kIntSize;

  static const int kAstIdOffset = 0 * kIntSize;

  static const int kPcOffsetOffset = 1 * kIntSize;

  static const int kLoopDepthOffset = 2 * kIntSize;

  static const int kEntrySize = 3 * kIntSize;

  Address start_;

  Address instruction_start_;

  uint32_t length_;

};