jdk8-mips64-public/hotspot: src/share/vm/opto/regalloc.cpp@4a4c365f777d

     1 /*

     2  * Copyright 2000-2006 Sun Microsystems, Inc.  All Rights Reserved.

     3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.

     4  *

     5  * This code is free software; you can redistribute it and/or modify it

     6  * under the terms of the GNU General Public License version 2 only, as

     7  * published by the Free Software Foundation.

     8  *

     9  * This code is distributed in the hope that it will be useful, but WITHOUT

    10  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or

    11  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License

    12  * version 2 for more details (a copy is included in the LICENSE file that

    13  * accompanied this code).

    14  *

    15  * You should have received a copy of the GNU General Public License version

    16  * 2 along with this work; if not, write to the Free Software Foundation,

    17  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.

    18  *

    19  * Please contact Sun Microsystems, Inc., 4150 Network Circle, Santa Clara,

    20  * CA 95054 USA or visit www.sun.com if you need additional information or

    21  * have any questions.

    22  *

    23  */

    25 #include "incls/_precompiled.incl"

    26 #include "incls/_regalloc.cpp.incl"

    28 static const int NodeRegsOverflowSize = 200;

    30 void (*PhaseRegAlloc::_alloc_statistics[MAX_REG_ALLOCATORS])();

    31 int PhaseRegAlloc::_num_allocators = 0;

    32 #ifndef PRODUCT

    33 int PhaseRegAlloc::_total_framesize = 0;

    34 int PhaseRegAlloc::_max_framesize = 0;

    35 #endif

    37 PhaseRegAlloc::PhaseRegAlloc( uint unique, PhaseCFG &cfg,

    38                               Matcher &matcher,

    39                               void (*pr_stats)() ):

    40                Phase(Register_Allocation), _cfg(cfg), _matcher(matcher),

    41                _node_oops(Thread::current()->resource_area()),

    42                _node_regs(0),

    43                _framesize(0xdeadbeef)

    44 {

    45     int i;

    47     for (i=0; i < _num_allocators; i++) {

    48         if (_alloc_statistics[i] == pr_stats)

    49             return;

    50     }

    51     assert((_num_allocators + 1) < MAX_REG_ALLOCATORS, "too many register allocators");

    52     _alloc_statistics[_num_allocators++] = pr_stats;

    53 }

    56 //------------------------------reg2offset-------------------------------------

    57 int PhaseRegAlloc::reg2offset_unchecked( OptoReg::Name reg ) const {

    58   // Slots below _max_in_arg_stack_reg are offset by the entire frame.

    59   // Slots above _max_in_arg_stack_reg are frame_slots and are not offset.

    60   int slot = (reg < _matcher._new_SP)

    61     ? reg - OptoReg::stack0() + _framesize

    62     : reg - _matcher._new_SP;

    63   // Note:  We use the direct formula (reg - SharedInfo::stack0) instead of

    64   // OptoReg::reg2stack(reg), in order to avoid asserts in the latter

    65   // function.  This routine must remain unchecked, so that dump_frame()

    66   // can do its work undisturbed.

    67   // %%% not really clear why reg2stack would assert here

    69   return slot*VMRegImpl::stack_slot_size;

    70 }

    72 int PhaseRegAlloc::reg2offset( OptoReg::Name reg ) const {

    74   // Not allowed in the out-preserve area.

    75   // In-preserve area is allowed so Intel can fetch the return pc out.

    76   assert( reg <  _matcher._old_SP ||

    77           (reg >= OptoReg::add(_matcher._old_SP,C->out_preserve_stack_slots()) &&

    78            reg <  _matcher._in_arg_limit) ||

    79           reg >=  OptoReg::add(_matcher._new_SP,C->out_preserve_stack_slots()),

    80           "register allocated in a preserve area" );

    81   return reg2offset_unchecked( reg );

    82 }

    84 //------------------------------offset2reg-------------------------------------

    85 OptoReg::Name PhaseRegAlloc::offset2reg(int stk_offset) const {

    86   int slot = stk_offset / jintSize;

    87   int reg = (slot < (int) _framesize)

    88     ? slot + _matcher._new_SP

    89     : OptoReg::stack2reg(slot) - _framesize;

    90   assert(stk_offset == reg2offset((OptoReg::Name) reg),

    91          "offset2reg does not invert properly");

    92   return (OptoReg::Name) reg;

    93 }

    95 //------------------------------set_oop----------------------------------------

    96 void PhaseRegAlloc::set_oop( const Node *n, bool is_an_oop ) {

    97   if( is_an_oop ) {

    98     _node_oops.set(n->_idx);

    99   }

   100 }

   102 //------------------------------is_oop-----------------------------------------

   103 bool PhaseRegAlloc::is_oop( const Node *n ) const {

   104   return _node_oops.test(n->_idx) != 0;

   105 }

   107 // Allocate _node_regs table with at least "size" elements

   108 void PhaseRegAlloc::alloc_node_regs(int size) {

   109   _node_regs_max_index = size + (size >> 1) + NodeRegsOverflowSize;

   110   _node_regs = NEW_RESOURCE_ARRAY( OptoRegPair, _node_regs_max_index );

   111   // We assume our caller will fill in all elements up to size-1, so

   112   // only the extra space we allocate is initialized here.

   113   for( uint i = size; i < _node_regs_max_index; ++i )

   114     _node_regs[i].set_bad();

   115 }

   117 #ifndef PRODUCT

   118 void

   119 PhaseRegAlloc::print_statistics() {

   120   tty->print_cr("Total frameslots = %d, Max frameslots = %d", _total_framesize, _max_framesize);

   121   int i;

   123   for (i=0; i < _num_allocators; i++) {

   124     _alloc_statistics[i]();

   125   }

   126 }

   127 #endif

Mercurial > jdk8-mips64-public > hotspot / file revision