/*

 * Copyright (c) 2000, 2019, Oracle and/or its affiliates. All rights reserved.

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

 *

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

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

 * published by the Free Software Foundation.

 *

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

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

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

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

 * accompanied this code).

 *

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

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

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

 *

 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA

 * or visit www.oracle.com if you need additional information or have any

 * questions.

 *

 */

#include "precompiled.hpp"

#include "compiler/compileLog.hpp"

#include "compiler/oopMap.hpp"

#include "memory/allocation.inline.hpp"

#include "memory/resourceArea.hpp"

#include "opto/addnode.hpp"

#include "opto/block.hpp"

#include "opto/callnode.hpp"

#include "opto/cfgnode.hpp"

#include "opto/chaitin.hpp"

#include "opto/coalesce.hpp"

#include "opto/connode.hpp"

#include "opto/idealGraphPrinter.hpp"

#include "opto/indexSet.hpp"

#include "opto/machnode.hpp"

#include "opto/memnode.hpp"

#include "opto/movenode.hpp"

#include "opto/opcodes.hpp"

#include "opto/rootnode.hpp"

#include "utilities/align.hpp"

#ifndef PRODUCT

void LRG::dump() const {

  ttyLocker ttyl;

  tty->print("%d ",num_regs());

  _mask.dump();

  if( _msize_valid ) {

    if( mask_size() == compute_mask_size() ) tty->print(", #%d ",_mask_size);

    else tty->print(", #!!!_%d_vs_%d ",_mask_size,_mask.Size());

  } else {

    tty->print(", #?(%d) ",_mask.Size());

  }

  tty->print("EffDeg: ");

  if( _degree_valid ) tty->print( "%d ", _eff_degree );

  else tty->print("? ");

  if( is_multidef() ) {

    tty->print("MultiDef ");

    if (_defs != NULL) {

      tty->print("(");

      for (int i = 0; i < _defs->length(); i++) {

        tty->print("N%d ", _defs->at(i)->_idx);

      }

      tty->print(") ");

    }

  }

  else if( _def == 0 ) tty->print("Dead ");

  else tty->print("Def: N%d ",_def->_idx);

  tty->print("Cost:%4.2g Area:%4.2g Score:%4.2g ",_cost,_area, score());

  // Flags

  if( _is_oop ) tty->print("Oop ");

  if( _is_float ) tty->print("Float ");

  if( _is_vector ) tty->print("Vector ");

  if( _was_spilled1 ) tty->print("Spilled ");

  if( _was_spilled2 ) tty->print("Spilled2 ");

  if( _direct_conflict ) tty->print("Direct_conflict ");

  if( _fat_proj ) tty->print("Fat ");

  if( _was_lo ) tty->print("Lo ");

  if( _has_copy ) tty->print("Copy ");

  if( _at_risk ) tty->print("Risk ");

  if( _must_spill ) tty->print("Must_spill ");

  if( _is_bound ) tty->print("Bound ");

  if( _msize_valid ) {

    if( _degree_valid && lo_degree() ) tty->print("Trivial ");

  }

  tty->cr();

}

#endif

// Compute score from cost and area.  Low score is best to spill.

static double raw_score( double cost, double area ) {

  return cost - (area*RegisterCostAreaRatio) * 1.52588e-5;

}

double LRG::score() const {

  // Scale _area by RegisterCostAreaRatio/64K then subtract from cost.

  // Bigger area lowers score, encourages spilling this live range.

  // Bigger cost raise score, prevents spilling this live range.

  // (Note: 1/65536 is the magic constant below; I dont trust the C optimizer

  // to turn a divide by a constant into a multiply by the reciprical).

  double score = raw_score( _cost, _area);

  // Account for area.  Basically, LRGs covering large areas are better

  // to spill because more other LRGs get freed up.

  if( _area == 0.0 )            // No area?  Then no progress to spill

    return 1e35;

  if( _was_spilled2 )           // If spilled once before, we are unlikely

    return score + 1e30;        // to make progress again.

  if( _cost >= _area*3.0 )      // Tiny area relative to cost

    return score + 1e17;        // Probably no progress to spill

  if( (_cost+_cost) >= _area*3.0 ) // Small area relative to cost

    return score + 1e10;        // Likely no progress to spill

  return score;

}

#define NUMBUCKS 3

// Straight out of Tarjan's union-find algorithm

uint LiveRangeMap::find_compress(uint lrg) {

  uint cur = lrg;

  uint next = _uf_map.at(cur);

  while (next != cur) { // Scan chain of equivalences

    assert( next < cur, "always union smaller");

    cur = next; // until find a fixed-point

    next = _uf_map.at(cur);

  }

  // Core of union-find algorithm: update chain of

  // equivalences to be equal to the root.

  while (lrg != next) {

    uint tmp = _uf_map.at(lrg);

    _uf_map.at_put(lrg, next);

    lrg = tmp;

  }

  return lrg;

}

// Reset the Union-Find map to identity

void LiveRangeMap::reset_uf_map(uint max_lrg_id) {

  _max_lrg_id= max_lrg_id;

  // Force the Union-Find mapping to be at least this large

  _uf_map.at_put_grow(_max_lrg_id, 0);

  // Initialize it to be the ID mapping.

  for (uint i = 0; i < _max_lrg_id; ++i) {

    _uf_map.at_put(i, i);

  }

}

// Make all Nodes map directly to their final live range; no need for

// the Union-Find mapping after this call.

void LiveRangeMap::compress_uf_map_for_nodes() {

  // For all Nodes, compress mapping

  uint unique = _names.length();

  for (uint i = 0; i < unique; ++i) {

    uint lrg = _names.at(i);

    uint compressed_lrg = find(lrg);

    if (lrg != compressed_lrg) {

      _names.at_put(i, compressed_lrg);

    }

  }

}

// Like Find above, but no path compress, so bad asymptotic behavior

uint LiveRangeMap::find_const(uint lrg) const {

  if (!lrg) {

    return lrg; // Ignore the zero LRG

  }

  // Off the end?  This happens during debugging dumps when you got

  // brand new live ranges but have not told the allocator yet.

  if (lrg >= _max_lrg_id) {

    return lrg;

  }

  uint next = _uf_map.at(lrg);

  while (next != lrg) { // Scan chain of equivalences

    assert(next < lrg, "always union smaller");

    lrg = next; // until find a fixed-point

    next = _uf_map.at(lrg);

  }

  return next;

}

PhaseChaitin::PhaseChaitin(uint unique, PhaseCFG &cfg, Matcher &matcher, bool scheduling_info_generated)

  : PhaseRegAlloc(unique, cfg, matcher,

#ifndef PRODUCT

       print_chaitin_statistics

#else

       NULL

#endif

       )

  , _live(0)

  , _spilled_once(Thread::current()->resource_area())

  , _spilled_twice(Thread::current()->resource_area())

  , _lo_degree(0), _lo_stk_degree(0), _hi_degree(0), _simplified(0)

  , _oldphi(unique)

#ifndef PRODUCT

  , _trace_spilling(C->directive()->TraceSpillingOption)

#endif

  , _lrg_map(Thread::current()->resource_area(), unique)

  , _scheduling_info_generated(scheduling_info_generated)

  , _sched_int_pressure(0, INTPRESSURE)

  , _sched_float_pressure(0, FLOATPRESSURE)

  , _scratch_int_pressure(0, INTPRESSURE)

  , _scratch_float_pressure(0, FLOATPRESSURE)

{

  Compile::TracePhase tp("ctorChaitin", &timers[_t_ctorChaitin]);

  _high_frequency_lrg = MIN2(double(OPTO_LRG_HIGH_FREQ), _cfg.get_outer_loop_frequency());

  // Build a list of basic blocks, sorted by frequency

  _blks = NEW_RESOURCE_ARRAY(Block *, _cfg.number_of_blocks());

  // Experiment with sorting strategies to speed compilation

  double  cutoff = BLOCK_FREQUENCY(1.0); // Cutoff for high frequency bucket

  Block **buckets[NUMBUCKS];             // Array of buckets

  uint    buckcnt[NUMBUCKS];             // Array of bucket counters

  double  buckval[NUMBUCKS];             // Array of bucket value cutoffs

  for (uint i = 0; i < NUMBUCKS; i++) {

    buckets[i] = NEW_RESOURCE_ARRAY(Block *, _cfg.number_of_blocks());

    buckcnt[i] = 0;

    // Bump by three orders of magnitude each time

    cutoff *= 0.001;

    buckval[i] = cutoff;

    for (uint j = 0; j < _cfg.number_of_blocks(); j++) {

      buckets[i][j] = NULL;

    }

  }

  // Sort blocks into buckets

  for (uint i = 0; i < _cfg.number_of_blocks(); i++) {

    for (uint j = 0; j < NUMBUCKS; j++) {

      if ((j == NUMBUCKS - 1) || (_cfg.get_block(i)->_freq > buckval[j])) {

        // Assign block to end of list for appropriate bucket

        buckets[j][buckcnt[j]++] = _cfg.get_block(i);

        break; // kick out of inner loop

      }

    }

  }

  // Dump buckets into final block array

  uint blkcnt = 0;

  for (uint i = 0; i < NUMBUCKS; i++) {

    for (uint j = 0; j < buckcnt[i]; j++) {

      _blks[blkcnt++] = buckets[i][j];

    }

  }

  assert(blkcnt == _cfg.number_of_blocks(), "Block array not totally filled");

}

// union 2 sets together.

void PhaseChaitin::Union( const Node *src_n, const Node *dst_n ) {

  uint src = _lrg_map.find(src_n);

  uint dst = _lrg_map.find(dst_n);

  assert(src, "");

  assert(dst, "");

  assert(src < _lrg_map.max_lrg_id(), "oob");

  assert(dst < _lrg_map.max_lrg_id(), "oob");

  assert(src < dst, "always union smaller");

  _lrg_map.uf_map(dst, src);

}

void PhaseChaitin::new_lrg(const Node *x, uint lrg) {

  // Make the Node->LRG mapping

  _lrg_map.extend(x->_idx,lrg);

  // Make the Union-Find mapping an identity function

  _lrg_map.uf_extend(lrg, lrg);

}

int PhaseChaitin::clone_projs(Block* b, uint idx, Node* orig, Node* copy, uint& max_lrg_id) {

  assert(b->find_node(copy) == (idx - 1), "incorrect insert index for copy kill projections");

  DEBUG_ONLY( Block* borig = _cfg.get_block_for_node(orig); )

  int found_projs = 0;

  uint cnt = orig->outcnt();

  for (uint i = 0; i < cnt; i++) {

    Node* proj = orig->raw_out(i);

    if (proj->is_MachProj()) {

      assert(proj->outcnt() == 0, "only kill projections are expected here");

      assert(_cfg.get_block_for_node(proj) == borig, "incorrect block for kill projections");

      found_projs++;

      // Copy kill projections after the cloned node

      Node* kills = proj->clone();

      kills->set_req(0, copy);

      b->insert_node(kills, idx++);

      _cfg.map_node_to_block(kills, b);

      new_lrg(kills, max_lrg_id++);

    }

  }

  return found_projs;

}

// Renumber the live ranges to compact them.  Makes the IFG smaller.

void PhaseChaitin::compact() {

  Compile::TracePhase tp("chaitinCompact", &timers[_t_chaitinCompact]);

  // Current the _uf_map contains a series of short chains which are headed

  // by a self-cycle.  All the chains run from big numbers to little numbers.

  // The Find() call chases the chains & shortens them for the next Find call.

  // We are going to change this structure slightly.  Numbers above a moving

  // wave 'i' are unchanged.  Numbers below 'j' point directly to their

  // compacted live range with no further chaining.  There are no chains or

  // cycles below 'i', so the Find call no longer works.

  uint j=1;

  uint i;

  for (i = 1; i < _lrg_map.max_lrg_id(); i++) {

    uint lr = _lrg_map.uf_live_range_id(i);

    // Ignore unallocated live ranges

    if (!lr) {

      continue;

    }

    assert(lr <= i, "");

    _lrg_map.uf_map(i, ( lr == i ) ? j++ : _lrg_map.uf_live_range_id(lr));

  }

  // Now change the Node->LR mapping to reflect the compacted names

  uint unique = _lrg_map.size();

  for (i = 0; i < unique; i++) {

    uint lrg_id = _lrg_map.live_range_id(i);

    _lrg_map.map(i, _lrg_map.uf_live_range_id(lrg_id));

  }

  // Reset the Union-Find mapping

  _lrg_map.reset_uf_map(j);

}

void PhaseChaitin::Register_Allocate() {

  // Above the OLD FP (and in registers) are the incoming arguments.  Stack

  // slots in this area are called "arg_slots".  Above the NEW FP (and in

  // registers) is the outgoing argument area; above that is the spill/temp

  // area.  These are all "frame_slots".  Arg_slots start at the zero

  // stack_slots and count up to the known arg_size.  Frame_slots start at

  // the stack_slot #arg_size and go up.  After allocation I map stack

  // slots to actual offsets.  Stack-slots in the arg_slot area are biased

  // by the frame_size; stack-slots in the frame_slot area are biased by 0.

  _trip_cnt = 0;

  _alternate = 0;

  _matcher._allocation_started = true;

  ResourceArea split_arena(mtCompiler);     // Arena for Split local resources

  ResourceArea live_arena(mtCompiler);      // Arena for liveness & IFG info

  ResourceMark rm(&live_arena);

  // Need live-ness for the IFG; need the IFG for coalescing.  If the

  // liveness is JUST for coalescing, then I can get some mileage by renaming

  // all copy-related live ranges low and then using the max copy-related

  // live range as a cut-off for LIVE and the IFG.  In other words, I can

  // build a subset of LIVE and IFG just for copies.

  PhaseLive live(_cfg, _lrg_map.names(), &live_arena, false);

  // Need IFG for coalescing and coloring

  PhaseIFG ifg(&live_arena);

  _ifg = &ifg;

  // Come out of SSA world to the Named world.  Assign (virtual) registers to

  // Nodes.  Use the same register for all inputs and the output of PhiNodes

  // - effectively ending SSA form.  This requires either coalescing live

  // ranges or inserting copies.  For the moment, we insert "virtual copies"

  // - we pretend there is a copy prior to each Phi in predecessor blocks.

  // We will attempt to coalesce such "virtual copies" before we manifest

  // them for real.

  de_ssa();

#ifdef ASSERT

  // Veify the graph before RA.

  verify(&live_arena);

#endif

  {

    Compile::TracePhase tp("computeLive", &timers[_t_computeLive]);

    _live = NULL;                 // Mark live as being not available

    rm.reset_to_mark();           // Reclaim working storage

    IndexSet::reset_memory(C, &live_arena);

    ifg.init(_lrg_map.max_lrg_id()); // Empty IFG

    gather_lrg_masks( false );    // Collect LRG masks

    live.compute(_lrg_map.max_lrg_id()); // Compute liveness

    _live = &live;                // Mark LIVE as being available

  }

  // Base pointers are currently "used" by instructions which define new

  // derived pointers.  This makes base pointers live up to the where the

  // derived pointer is made, but not beyond.  Really, they need to be live

  // across any GC point where the derived value is live.  So this code looks

  // at all the GC points, and "stretches" the live range of any base pointer

  // to the GC point.

  if (stretch_base_pointer_live_ranges(&live_arena)) {

    Compile::TracePhase tp("computeLive (sbplr)", &timers[_t_computeLive]);

    // Since some live range stretched, I need to recompute live

    _live = NULL;

    rm.reset_to_mark();         // Reclaim working storage

    IndexSet::reset_memory(C, &live_arena);

    ifg.init(_lrg_map.max_lrg_id());

    gather_lrg_masks(false);

    live.compute(_lrg_map.max_lrg_id());

    _live = &live;

  }

  // Create the interference graph using virtual copies

  build_ifg_virtual();  // Include stack slots this time

  // The IFG is/was triangular.  I am 'squaring it up' so Union can run

  // faster.  Union requires a 'for all' operation which is slow on the

  // triangular adjacency matrix (quick reminder: the IFG is 'sparse' -

  // meaning I can visit all the Nodes neighbors less than a Node in time

  // O(# of neighbors), but I have to visit all the Nodes greater than a

  // given Node and search them for an instance, i.e., time O(#MaxLRG)).

  _ifg->SquareUp();

  // Aggressive (but pessimistic) copy coalescing.

  // This pass works on virtual copies.  Any virtual copies which are not

  // coalesced get manifested as actual copies

  {

    Compile::TracePhase tp("chaitinCoalesce1", &timers[_t_chaitinCoalesce1]);

    PhaseAggressiveCoalesce coalesce(*this);

    coalesce.coalesce_driver();

    // Insert un-coalesced copies.  Visit all Phis.  Where inputs to a Phi do

    // not match the Phi itself, insert a copy.

    coalesce.insert_copies(_matcher);

    if (C->failing()) {

      return;

    }

  }

  // After aggressive coalesce, attempt a first cut at coloring.

  // To color, we need the IFG and for that we need LIVE.

  {

    Compile::TracePhase tp("computeLive", &timers[_t_computeLive]);

    _live = NULL;

    rm.reset_to_mark();           // Reclaim working storage

    IndexSet::reset_memory(C, &live_arena);

    ifg.init(_lrg_map.max_lrg_id());

    gather_lrg_masks( true );

    live.compute(_lrg_map.max_lrg_id());

    _live = &live;

  }

  // Build physical interference graph

  uint must_spill = 0;

  must_spill = build_ifg_physical(&live_arena);

  // If we have a guaranteed spill, might as well spill now

  if (must_spill) {

    if(!_lrg_map.max_lrg_id()) {

      return;

    }

    // Bail out if unique gets too large (ie - unique > MaxNodeLimit)

    C->check_node_count(10*must_spill, "out of nodes before split");

    if (C->failing()) {

      return;

    }

    uint new_max_lrg_id = Split(_lrg_map.max_lrg_id(), &split_arena);  // Split spilling LRG everywhere

    _lrg_map.set_max_lrg_id(new_max_lrg_id);

    // Bail out if unique gets too large (ie - unique > MaxNodeLimit - 2*NodeLimitFudgeFactor)

    // or we failed to split

    C->check_node_count(2*NodeLimitFudgeFactor, "out of nodes after physical split");

    if (C->failing()) {

      return;

    }

    NOT_PRODUCT(C->verify_graph_edges();)

    compact();                  // Compact LRGs; return new lower max lrg

    {

      Compile::TracePhase tp("computeLive", &timers[_t_computeLive]);

      _live = NULL;

      rm.reset_to_mark();         // Reclaim working storage

      IndexSet::reset_memory(C, &live_arena);

      ifg.init(_lrg_map.max_lrg_id()); // Build a new interference graph

      gather_lrg_masks( true );   // Collect intersect mask

      live.compute(_lrg_map.max_lrg_id()); // Compute LIVE

      _live = &live;

    }

    build_ifg_physical(&live_arena);

    _ifg->SquareUp();

    _ifg->Compute_Effective_Degree();

    // Only do conservative coalescing if requested

    if (OptoCoalesce) {

      Compile::TracePhase tp("chaitinCoalesce2", &timers[_t_chaitinCoalesce2]);

      // Conservative (and pessimistic) copy coalescing of those spills

      PhaseConservativeCoalesce coalesce(*this);

      // If max live ranges greater than cutoff, don't color the stack.

      // This cutoff can be larger than below since it is only done once.

      coalesce.coalesce_driver();

    }

    _lrg_map.compress_uf_map_for_nodes();

#ifdef ASSERT

    verify(&live_arena, true);

#endif

  } else {