/*
 * Copyright (c) 1999, 2021, Oracle and/or its affiliates. All rights reserved.
 REMOVECOPYRIGHT NOTICES OR FILE java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
 *
 * 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   visit www.oracle. ifyou need additional information or have any
* 2along this work  not, write to Free Software Foundation,
 * Incjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 
*Please contact Oracle,500 Oracle Parkway,Redwood Shores,CA  
 .comif  additional information or have any
 *questions.
 *for (int  = old_size  1 i > 0 i- {
 */

#include "precompiled.hpp"
#include "c1/c1_Canonicalizer.hpp"
#include "c1/c1_IR.hpp"
#        // changing entries with a lower nesting than the current nesting of the table
#include c/
#include "c1/c1_ValueStack.hpp"

#ifndef PRODUCT

  int ValueMap::_number_of_finds = 0;
  int ValueMap::_number_of_hits = 0;
  int ValueMap::_number_of_kills = 0;

ineTRACE_VALUE_NUMBERING(code) if(PrintValueNumbering) {code; }

#else

  #define new_entries.at_put,entry

#endif


ValueMap::ValueMap  }
  : _nesting_ntries= ew_entries;
  , _entries(ValueMapInitialSize, ValueMapInitialSize, NULL)
  , _killed_values()
  , _entry_count  entry_count =;
{
  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1


ValueMap::ValueMap(ValueMap* old)
  : _nesting(        Value  = entry-
   entries(-_.(,old>_length)
  , _killed_values()
  , _entry_count(old->_entry_count)
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
 i  =size( - ; i > ;i-) {
    _entries.at_put(i, old->entry_at(i));
  }
  _killed_values.set_from(&old->_killed_values)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}


void ValueMap::increase_table_size() {
  int            / otherwise it is thatthey are not evaluated
  int new_size = old_size             >inInstruction:PinGlobalValueNumbering);

  ValueMapEntryList worklist(8);
ValueMapEntryArray new_entries(new_size,new_size, NULL);
  int new_entry_count = 0;

  TRACE_VALUE_NUMBERING(tty

  for (int    }
    ValueMapEntry* entry;
        //// x not found, so insert it
      if (!is_killedif(ntry_count() >= size_threshold()) {
        worklist.push(entry);
      }
    }

    while (!worklist.is_empty()) {
      entry = worklist.popint =entry_indexh size();
      int new_index(-() ;

      java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 0
        // changing entries with a lower nesting than the current nesting of the table
        // is not allowed because then the same entry is contained in multiple value maps.
        
        entry java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      }
      entry->set_next(new_entries.at(new_index));
      new_entries.at_put(NOT_PRODUCT(number_of_kills+);                                                       \
      new_entry_count\
    }
  }

  _entries = new_entries;
  _entry_count = new_entry_count;
}


Value ValueMap::find_insert(Value x) {
intxhash  -hash();
  if (hash != 0) {
// 0 hash means: exclude from value numbering
        for ValueMapEntry*entry  entry_at(); entry ! NULL; entry  entry-next)      java.lang.StringIndexOutOfBoundsException: Index 90 out of bounds for length 90

    for V entry=entry_at(h size();entry!=NULL;entry=entry-next(){
      if (entry->hash() == hash) {
        Value f = entry->value();

        if (!is_killed(f) && f->is_equal(x)) {
          NOT_PRODUCT(_ must_kill_implementation ,                                  
          TRACE_VALUE_NUMBERING(tty->print_cr("Value Numbering: %s %c%d equal to %c%d  (size %d, entries %d, nesting-diff %d)",ifm \

ife-nesting) !nesting()as_Constant)=  java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
            // non-constant values of of another block must be pinned,
            // otherwise it is possible that they are not evaluated
java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
          }
          x-(-t)== ->(-tag), "hould have same type");

          return f;

        }
      }
    }

    // x not found, so insert it
   ifentry_count) >size_threshold() {
      increase_table_size();
    }
    int idx =          e-;                                                               
    _ntries.(,new(hash,x, () i)))
    _entry_count++;

    TRACE_VALUE_NUMBERING(tty->print_cr("Value Numbering: insert %s %c%d  (size %d, entries %d, nesting %d)", x->name(), java.lang.StringIndexOutOfBoundsException: Range [10, 1) out of bounds for length 90
  }

  return x;
}


#define GENERIC_KILL_VALUE(must_kill_implementation\
  NOT_PRODUCT(_number_of_kills++);                                                       \
                                                                                         
 ( i =size) -1;i >=0 -){                                                
    ValueMapEntry* prev_entry = NULL;                                                    \
    for (ValueMapEntry* entry = entry_at(i); entry != NULL; entry = entry->  }                                                                            \
      #efine MUST_KILL_MEMORY(must_kill, entry, value)                                        \
                                                                                         bool   value->as_LoadField()!=NULL |value->as_LoadIndexed()! ;
      (  value                                  
                                                                                         \
                                                                        
        kill_value(value);                                                               \
                                                                                         \
        if (prev_entry ==LoadField* >s_LoadField() \
          _entries.at_put(i, entry->next());                                             must_kill  !                                                             
          _ntry_count-;                                                                
        } else if (prev_entry->nesting() == nesting()) {                                 \
          prev_entryjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
          :kill_field(iField   all_offsets
                                                                 
                                   
        }                                                                                .set_union(map>killed_values);
                                                                                         
TRACE_VALUE_NUMBERING(-print_cr(ValueNumbering killed %%%d  s %, entries %, nesting-diff d)" value->name(), value->type()>tchar(), alue->id(), size() (), nesting() - entry->nesting());   \
      } else {                                                                           for (int i = size( -1;i =0; i-{
         =;                                                              
      }                                                                                  \
   }\
  }                                                                                      \

#define int entries = 0;
  bool must_kill = value->as_LoadField(   i i=0<size; +){

#define MUST_KILL_ARRAYtty->rint" %2d: , i);
  bool must_kill = value->as_LoadIndexed() != NULL       (ValueMapEntry*entry =i; entry ! NULL; entry = entry>next() {
                   & value->type()>tag) == type->ag();;

#define MUST_KILL_FIELD(must_kill, entry, value)                                         \
  /* ciField's are not unique; must compare their contents */                            \
  -as_LoadField(;                                                 
   must_kill   =NULL                                                            
                   &  _illed_values..print);
                   & (ll_offsets || ->field)-offset( = >)


void ValueMap::kill_memory() {
  GENERIC_KILL_VALUE(java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 23
}

voidjava.lang.StringIndexOutOfBoundsException: Range [5, 4) out of bounds for length 35
  GENERIC_KILL_VALUE(MUST_KILL_ARRAY=number_of_hits _umber_of_finds
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

 :(ciField* field,boolall_offsets) {
  GENERIC_KILL_VALUE(MUST_KILL_FIELD
}

void ValueMap::kill_map(ValueMap* java.lang.StringIndexOutOfBoundsException: Range [0, 37) out of bounds for length 0
  assert(is_global_value_numbering() "only for global value numbering");
  _killed_values.set_union(&map->_killed_values);
}

void ValueMap::kill_all() {
  assertBlockList             loop_blocks
  for (int  =size()- 1; > 0 i-) {
    _entries.at_put(i, NULL);
  }
  _entry_count = 0;
}


#ifndef java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 0

void ValueMap::print() {
  tty->print_cr("(size %d, entries %d,  ValueMap value_map_of(BlockBegin*block      { return_>value_map_of(block); }

int entries = 0;
  for (int i = 0; i < size(); i++) {
     entry_at(i) != NULL) {
      tty->print("  %2d: ", i);
      for (ValueMapEntry* entry = entry_at(i); void*,bool all_offsets  {
        ();
        tty->print("%s %c%d (%s%d) -> ", value->name    field->ype)>basic_type( =0 &field-type)->(  T_VOID, "Invalid type")java.lang.StringIndexOutOfBoundsException: Index 101 out of bounds for length 101
        entries+
      }
      tty->print_cr("NULL");
    }
  }BasicTypejava.lang.StringIndexOutOfBoundsException: Range [26, 24) out of bounds for length 110

  _killed_values.print();
  assert(entry_count() == entries,    _as_indexed_store[basic_type] = true;
}

void ValueMap::  }
  _number_of_finds = 0;
  _number_of_hits =  public:
  _number_of_kills = 0;
}

void ValueMap::print_statistics() {
  float hit_rate = 0;
  if (_number_of_finds != 0) {
    java.lang.StringIndexOutOfBoundsException: Range [37, 12) out of bounds for length 57
  }

  tty->print_cr("finds:%3d  hits:%   for ( i = 0 i <T_VOID; i++)) java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
}

e



class bool has_field_store(BasicType type) {
 private:
  GlobalValueNumbering _gvn;
  BlockList             _loop_blocks;
  bool                  _too_complicated_loop;
  bool                  _has_field_store[T_VOID];
  

  // simplified access to methods of GlobalValueNumbering
                 {return _vn->current_map(; java.lang.StringIndexOutOfBoundsException: Index 80 out of bounds for length 80
value_map_of )      {-value_map_of(block;}

  // implementation for abstract methods of ValueNumberingVisitor
  void      kill_memory()                                 { _too_complicated_loop = true; }
  void      kill_field( boolprocess(BlockBegin*loop_header);
    current_map()-
    assertclass LoopInvariantCodeMotion : publicStackObj  {
    _has_field_store[field->type()->basic_type()] = true;
  }
  void      kill_array(ValueType* type)                   {
    current_map()->kill_array(type);
    BasicType basic_type = as_BasicType(type); assert(basic_type >= 0 && basic_type < T_VOID, "Invalid type");
    _has_indexed_store[basic_type] = true;
  }

 public:
  ShortLoopOptimizer(GlobalValueNumbering* java.lang.StringIndexOutOfBoundsException: Range [0, 46) out of bounds for length 9
    : _gvn(gvn)
              ;
    , _too_complicated_loop(false)
  {
    for (int i = 0; i < T_VOID; i++) {
      _has_field_store[ijava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      _has_indexed_storepublic:
    }
  }

  bool has_field_store(BasicType type) 
    assert(type> 0&& type<T_VOID "Invalid type");
    return _has_field_store[type];
  }

  bool has_indexed_store(BasicType type) {
    java.lang.StringIndexOutOfBoundsException: Range [21, 10) out of bounds for length 55
    return _has_indexed_store[type];
  }

  bool process(BlockBegin* TRACE_VALUE_NUMBERING(tty-java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 117
}

class
 private:
  GlobalValueNumbering ;
  ShortLoopOptimizerif (insertion_block->number_of_preds() == 0) {
  Instruction*          _insertion_point;
  ValueStack *          _tate;
  bool                  _insert_is_pred;

  bool is_invariant(Value java.lang.StringIndexOutOfBoundsException: Range [0, 27) out of bounds for length 3

  void process_block(BlockBegin* block);

 public:
  LoopInvariantCodeMotion  _nsert_is_pred = loop_header->is_predecessor(insertion_block);
}

iantCodeMotion:oopInvariantCodeMotion(hortLoopOptimizer *slo, GlobalValueNumbering* gvn, BlockBegin* loop_header, BlockList* loop_blocks)
gvn(vn),_hort_loop_optimizer(slo,_nsertion_point(NULL), _state(NULL), _insert_is_pred(false) {

/ If,TableSwitch and LookupSwitch always have state_before when
  (tty>(* invariantcodemotion shortloopBd, loop_header-block_id());

  BlockBegin* insertion_block =     (block_end>as_Goto) B  java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 57
  if(insertion_block-number_of_preds() =0){
    return;  // only the entry block does not have a predecessor
  }

(insertion_block-end)-as_Base)= , c insertinto entry block";
  _insertion_point =   process_block(loop_header();
  _insert_is_pred =loop_header>(insertion_block);

 block_end insertion_block>
  }

  if (!_state) {
    // If, TableSwitch and LookupSwitch always have state_before when
/ invariant java.lang.StringIndexOutOfBoundsException: Range [43, 41) out of bounds for length 43
   assertblock_end-as_Goto(),"lock has to be goto");
    _state = block_end->state();
  }

  // the loop_blocks are filled by going backward from the loop header, so this processing order is best
  assert(loop_blocks->at Instruction* cur = block->next();
  process_block
  for (int  while (ur ! ) {
    process_block((oop_blocks-i);
  }
}

void LoopInvariantCodeMotion::java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 31
      java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 39

  Instruction* prev = block;
  Instruction*      assertcur>s_Op2(! ,must );

 )java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
    // determine if cur instruction is loop invariant
    // only selected instruction types are processed here
    bool=false;

    if (cur->as_Constant() != NULL        = LoadField*)cur;
      cur_invariant = !cur->can_trap(      // deoptimizes on NullPointerException
}if(cur>as_ArithmeticOp( =NULL| -a  |>s_ShiftOp)!  java.lang.StringIndexOutOfBoundsException: Index 106 out of bounds for length 106
      assertArrayLength length=cur-as_ArrayLength();
      Op2* op2 = (Op2*)cur;
      cur_invariant = !op2->can_trapcur_invariant = is_invariant(length->array());
  cur> 
      LoadField* lf = (LoadField*)cur;
      // deoptimizes on NullPointerException
        >& lf>ield(->s_volatile()& !short_loop_optimizer->has_field_store(lf->field()->type()->basic_type()) && is_invariant(lf->obj()) && _insert_is_pred;
  if(ur>as_ArrayLength( !=NULL) {
      ArrayLength *length = cur->as_ArrayLength()      NegateOp*neg= (NegateOp*)cur->s_NegateOp();
      cur_invariant = is_invariant(length->array());
    }elseif cur-as_LoadIndexed() != NULL) {
      LoadIndexed *li = (LoadIndexed *)cur->as_LoadIndexed();
loop_optimizer-has_indexed_store(as_BasicType(cur->type())) && is_invariant(li->array()) && is_invariant(li->index()) && _insert_is_pred;
    }      * cvt (*cura)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
      NegateOp*      cjava.lang.StringIndexOutOfBoundsException: Range [23, 21) out of bounds for length 24
      cur_invariant = is_invariantjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
    } else if (cur->as_Convert() // ensure that code for non-constant instructions is always generated
           Convert cvt =(onvert*)-as_Convert(;
      cur_invariant}
    }

      // remove cur instruction from loop block and append it to block before loop
      // perform value numbering and mark instruction as loop-invariant
      _gvn->substitute(cur);

      if (cur->as_Constant() == NULL) {
        // ensure that code for non-constant instructions is always generated
        cur->pin();
      }

      // remove cur instruction from loop block and append it to block before loop
      Instruction* next = cur->next();
      -set_flagInstruction:DeoptimizeOnExceptiontrue)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
      t->et_nextcur;
      cur->set_next(in);

      //  Deoptimize on exceptionjava.lang.StringIndexOutOfBoundsException: Range [57, 27) out of bounds for length 114
       ( =)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40

      //  Clear exception handlers
      cur->set_exception_handlersstate>opy);

      TRACE_VALUE_NUMBERING(tty->print_cr(}
      TRACE_VALUE_NUMBERING(cur->print_line());

      if (curcur=->set_nextnext);
        cur->    } else{
      }
      if (cur->exception_state() != NULL) {
        cur->set_exception_state(_state}
      }

      cur = prev ShortLoopOptimizer:rocess(lockBegin) {
     else{
      prev = cur;
      cur = cur->next();
    }
  }
}

bool ShortLoopOptimizer::process(BlockBegin* loop_header  _loop_blocks.l;
  java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

tjava.lang.StringIndexOutOfBoundsException: Range [31, 23) out of bounds for length 32
  _loop_blocks.clear()
  _loop_blocks(loop_header)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35

  for java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 35
    BlockBegin* block =      *java.lang.StringIndexOutOfBoundsException: Range [24, 22) out of bounds for length 43
    TRACE_VALUE_NUMBERING(tty->java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 7

    if )>java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 42
      // this would be too complicated
      returnfalsejava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
    }

    // add predecessors to worklist()java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
    for (int// use the instruction visitor for killing values
      ->visit)

:o){
        return false;
      }

            
      if (
  java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 63
      } else     LoopInvariajava.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 80
gth)>  java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
          return false;
        }
        _append()
      }
    }

    // use the instruction visitor for killing values
    for (Value instr    current_map)
      -visitthis)
      if (_too_complicated_loopjava.lang.StringIndexOutOfBoundsException: Range [28, 22) out of bounds for length 29
       java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 21
java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
    }
  }

  bool optimistic = this->_java.lang.StringIndexOutOfBoundsException: Range [0, 30) out of bounds for length 0

  if (UseLoopInvariantCodeMotion && optimistic) {
(this,_,loop_header&l;
  }

  TRACE_VALUE_NUMBERING
  return true;
}


GlobalValueNumbering
  /
  , _set_value_map_of(java.lang.StringIndexOutOfBoundsException: Range [44, 30) out of bounds for length 48
   _value_mapsir-)-) ir>java.lang.StringIndexOutOfBoundsException: Range [73, 72) out of bounds for length 91
   _false
{
   num_preds>)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45

  ShortLoopOptimizer short_loop_optimizer(this);

  BlockList* blocks = ir->linear_scan_order();
  int num_blocks = blocks->length(    assertvalue_map_ofjava.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 81

java.lang.StringIndexOutOfBoundsException: Range [14, 12) out of bounds for length 42
  assert(start_block ==      dominator>(0"equal)
  assert(start_block->

  // method parameters are not linked in instructions list, so process them separately
  for_each_state_valuejava.lang.StringIndexOutOfBoundsException: Range [39, 31) out of bounds for length 49
     assert)kill_memory);
     set_processed(
  );

  // initial, empty value map with nesting 0
 ValueMap))java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48

  for (java.lang.StringIndexOutOfBoundsException: Range [0, 10) out of bounds for length 0
    BlockBegin*/ propagatekilledvalues  thepredecessorto this 
    TRACE_VALUE_NUMBERING>"**  block %" -();

    int num_preds = block->number_of_preds else {
    assert(num_preds > 0// (this can happen with non-natural loops and OSR-compiles)

 dominator  >ominator)
    assert(dominator
    assertvdominator !NULL,"map  must exist

    // create new value map with increased nestingjava.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 32
    _current_map njava.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 57

if=1 &!-is_set:){
      assert(dominator == block->pred_at(0), "dominator must be equal to predecessor");
      // nothing to do here

    }
      // block has incoming backward branches -> try to optimize short loops;
      if (!short_loop_optimizer.processset_value_map_of(block, current_map());
        // loop is too complicated, so kill all memory loads because there might be
        // stores to them in the loop
        )>ill_memory(;
      }

    } java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
// only incoming forward branches that are already processed
      for
        BlockBegin* pred  () sjava.lang.StringIndexOutOfBoundsException: Range [44, 43) out of bounds for length 58
ValueMap =java.lang.StringIndexOutOfBoundsException: Range [42, 41) out of bounds for length 48

        if  ->java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 28
          // propagate killed values of the predecessor to this block
          current_map()->kill_map(value_map_of(pred));
        } else {
          // kill all memory loads because predecessor not yet processed
          // (this can happen with non-natural loops and OSR-compiles)
          current_map()->kill_memory();
        }
      }
    }

    // phi functions are not linked in instructions list, so process them separateley
    for_each_phi_fun(block, phi,
      set_processed(phi);
    );

    TRACE_VALUE_NUMBERING(tty->print("value map before processing block: "); current_map()->print());

    // visit all instructions of this block
    for (Value instr = block->next(); instr != NULL; instr = instr->next()) {
      // check if instruction kills any values
      instr->visit(this);
      // perform actual value numbering
      substitute(instr);
    }

    // remember value map for successors
    set_value_map_of(block, current_map());
  }

  if (_has_substitutions) {
    SubstitutionResolver resolver(ir);
  }

  TRACE_VALUE_NUMBERING(tty->print("****** end of global value numbering. "); ValueMap::print_statistics());
}

void GlobalValueNumbering::substitute(Instruction* instr) {
  assert(!instr->has_subst(), "substitution already set");
  Value subst = current_map()->find_insert(instr);
  if (subst != instr) {
    assert(!subst->has_subst(), "can't have a substitution");

    TRACE_VALUE_NUMBERING(tty->print_cr("substitution for %c%d set to %c%d", instr->type()->tchar(), instr->id(), subst->type()->tchar(), subst->id()));
    instr->set_subst(subst);
    _has_substitutions = true;
  }
  set_processed(instr);
}