Cross Reference: /openjdk7/hotspot/src/share/vm/c1/c1

Lines Matching defs:Interval
38 class Interval;
45 define_array(IntervalArray, Interval*)
117   friend class Interval;
150   IntervalArray*            _sorted_intervals;  // intervals sorted by Interval::from()
151   bool                      _needs_full_resort; // set to true if an Interval::from() is changed and _sorted_intervals must be resorted
201   Interval*     interval_at(int reg_num) const   { return _intervals.at(reg_num); }
223   static bool is_precolored_interval(const Interval* i);
224   static bool is_virtual_interval(const Interval* i);
226   static bool is_precolored_cpu_interval(const Interval* i);
227   static bool is_virtual_cpu_interval(const Interval* i);
228   static bool is_precolored_fpu_interval(const Interval* i);
229   static bool is_virtual_fpu_interval(const Interval* i);
231   static bool is_in_fpu_register(const Interval* i);
232   static bool is_oop_interval(const Interval* i);
237   void        assign_spill_slot(Interval* it);
240   Interval*   create_interval(int reg_num);
241   void        append_interval(Interval* it);
242   void        copy_register_flags(Interval* from, Interval* to);
252   void        change_spill_definition_pos(Interval* interval, int def_pos);
253   void        change_spill_state(Interval* interval, int spill_pos);
254   static bool must_store_at_definition(const Interval* i);
305   static int interval_cmp(Interval** a, Interval** b);
306   void add_to_list(Interval** first, Interval** prev, Interval* interval);
307   void create_unhandled_lists(Interval** list1, Interval** list2, bool (is_list1)(const Interval* i), bool (is_list2)(const Interval* i));
318   Interval* split_child_at_op_id(Interval* interval, int op_id, LIR_OpVisitState::OprMode mode);
319   Interval* interval_at_block_begin(BlockBegin* block, int reg_num);
320   Interval* interval_at_block_end(BlockBegin* block, int reg_num);
321   Interval* interval_at_op_id(int reg_num, int op_id);
336   VMReg vm_reg_for_interval(Interval* interval);
339   static LIR_Opr operand_for_interval(Interval* interval);
340   static LIR_Opr calc_operand_for_interval(const Interval* interval);
341   LIR_Opr       canonical_spill_opr(Interval* interval);
439   void block_registers(Interval* it);
440   void unblock_registers(Interval* it);
441   bool save_to_process_move(Interval* from, Interval* to);
445   void insert_move(Interval* from_interval, Interval* to_interval);
446   void insert_move(LIR_Opr from_opr, Interval* to_interval);
457   void add_mapping(Interval* from, Interval* to);
458   void add_mapping(LIR_Opr from, Interval* to);
467   friend class Interval;
476   // used only by class Interval, so hide them
498 // Interval is an ordered list of disjoint ranges.
514 class Interval : public CompilationResourceObj {
516   static Interval* _end;          // sentinel (interval with only range Range::end())
524   Interval*        _next;         // interval iteration: sorted list of Intervals (ends with sentinel)
535   Interval*        _split_parent;           // the original interval where this interval is derived from
537   Interval*        _current_split_child;    // the current split child that has been active or inactive last (always stored in split parents)
543   Interval*        _register_hint;          // this interval should be in the same register as the hint interval
546   Interval*        new_split_child();
548   Interval(int reg_num);
551   static Interval* end()                         { return _end; }
564   Interval*        next() const                  { return _next; }
565   Interval**       next_addr()                   { return &_next; }
566   void             set_next(Interval* next)      { _next = next; }
573   Interval*        register_hint(bool search_split_child = true) const; // calculation needed
574   void             set_register_hint(Interval* i) { _register_hint = i; }
582   Interval*        split_parent() const          { assert(_split_parent->is_split_parent(), "must be"); return _split_parent; }
583   Interval*        split_child_at_op_id(int op_id, LIR_OpVisitState::OprMode mode);
584   Interval*        split_child_before_op_id(int op_id);
591   Interval*        current_split_child() const             { return split_parent()->_current_split_child; }
620   Interval* split(int split_pos);
621   Interval* split_from_start(int split_pos);
627   bool   intersects(Interval* i) const           { return _first->intersects(i->_first); }
628   int    intersects_at(Interval* i) const        { return _first->intersects_at(i->_first); }
636   bool   current_intersects(Interval* it)        { return _current->intersects(it->_current); };
637   int    current_intersects_at(Interval* it)     { return _current->intersects_at(it->_current); };
649   Interval*        _unhandled_first[nofKinds];  // sorted list of intervals, not life before the current position
650   Interval*        _active_first   [nofKinds];  // sorted list of intervals, life at the current position
651   Interval*        _inactive_first [nofKinds];  // sorted list of intervals, intervals in a life time hole at the current position
653   Interval*        _current;                     // the current interval coming from unhandled list
667   Interval** unhandled_first_addr(IntervalKind kind) { check_bounds(kind); return &_unhandled_first[kind]; }
668   Interval** active_first_addr(IntervalKind kind)    { check_bounds(kind); return &_active_first[kind]; }
669   Interval** inactive_first_addr(IntervalKind kind)  { check_bounds(kind); return &_inactive_first[kind]; }
671   void append_unsorted(Interval** first, Interval* interval);
672   void append_sorted(Interval** first, Interval* interval);
673   void append_to_unhandled(Interval** list, Interval* interval);
675   bool remove_from_list(Interval** list, Interval* i);
676   void remove_from_list(Interval* i);
679   Interval*        current() const               { return _current; }
691   virtual void interval_moved(Interval* interval, IntervalKind kind, IntervalState from, IntervalState to);
694   IntervalWalker(LinearScan* allocator, Interval* unhandled_fixed_first, Interval* unhandled_any_first);
696   Interval* unhandled_first(IntervalKind kind)   { check_bounds(kind); return _unhandled_first[kind]; }
697   Interval* active_first(IntervalKind kind)      { check_bounds(kind); return _active_first[kind]; }
698   Interval* inactive_first(IntervalKind kind)    { check_bounds(kind); return _inactive_first[kind]; }
736   void exclude_from_use(Interval* i);
737   void set_use_pos(int reg, Interval* i, int use_pos, bool only_process_use_pos);
738   void set_use_pos(Interval* i, int use_pos, bool only_process_use_pos);
739   void set_block_pos(int reg, Interval* i, int block_pos);
740   void set_block_pos(Interval* i, int block_pos);
744   void free_collect_inactive_fixed(Interval* cur);
745   void free_collect_inactive_any(Interval* cur);
746   void free_collect_unhandled(IntervalKind kind, Interval* cur);
748   void spill_block_unhandled_fixed(Interval* cur);
749   void spill_block_inactive_fixed(Interval* cur);
751   void spill_collect_inactive_any(Interval* cur);
753   void insert_move(int op_id, Interval* src_it, Interval* dst_it);
755   int  find_optimal_split_pos(Interval* it, int min_split_pos, int max_split_pos, bool do_loop_optimization);
756   void split_before_usage(Interval* it, int min_split_pos, int max_split_pos);
757   void split_for_spilling(Interval* it);
758   void split_stack_interval(Interval* it);
759   void split_when_partial_register_available(Interval* it, int register_available_until);
760   void split_and_spill_interval(Interval* it);
764   bool alloc_free_reg(Interval* cur);
769   void alloc_locked_reg(Interval* cur);
771   bool no_allocation_possible(Interval* cur);
773   void init_vars_for_alloc(Interval* cur);
774   bool pd_init_regs_for_alloc(Interval* cur);
776   void combine_spilled_intervals(Interval* cur);
777   bool is_move(LIR_Op* op, Interval* from, Interval* to);
782   LinearScanWalker(LinearScan* allocator, Interval* unhandled_fixed_first, Interval* unhandled_any_first);