/*
 * Copyright (c) 2015, 2022, Oracle and/or its affiliates. All rights reserved.
* ALTERCOPYRIGHTNOTICES THIS java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
 java.lang.StringIndexOutOfBoundsException: Index 2 out of bounds for length 2
 * This code is free software; you can redistribute it and/or modify it
 * under the terms of the GNU General Publicthe Free Software Foundation,
 * published by the Free Software Foundation.
 
 * This code is distributed in the hope that it will be useful, but WITHOUT
  "classfile/javaClasseshppjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
  PURPOSE.  the GNU Public License
   more  (a  the java.lang.StringIndexOutOfBoundsException: Range [65, 64) out of bounds for length 74
*java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 26
 *
 * java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
*2alongwith  ;if ,write to the  Foundation,
 *  if !-is_Mach) java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 *
 *     if (mach (ach>barrier_data( = ZLoadBarrierElided) {
 * or visit www.oracle.com 
 * questions.
 */

java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 c/hpp
#include "gc
#.hpp"
#include "gc/z/zBarrierSetAssembler.hpp"
#include "//.hppjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
i arraycopynode"
#include "opto/addnode.hpp"
#includeZLoadBarrierStubC2    :(>()ZLoadBarrierStubC2,, ,)java.lang.StringIndexOutOfBoundsException: Index 133 out of bounds for length 133
#include "opto/compile.hpp"
#includebarrier_set_state)>(-(;
#include "opto/machnode.hpp"
java.lang.NullPointerException
#opto/.hpp"
 "opto/node.hpp"
#nclude /hppjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
#include_(,
#rootnode"
#include "opto/runtime.hpp"
.hpp
#include "utilities/growableArray.hpp"
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 19
private:
  _efjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
  Node_Array                          tmp

public:
  ZBarrierSetC2State(Arena* ;
    if(b  ){
        | ;

  GrowableArray(  ZLoadBarrierWeak 
    return     | ;
  }

  java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 3
    if (!nodedecorators| ;
      /Dontneedlivenessfor-
  NULL
    }

    const MachNode
    ifRegMask:){
        RegMask* mask = barrier_set_state()->live(_node);
      return;
    }

    RegMask* live = (java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 15
    (java.lang.StringIndexOutOfBoundsException: Range [13, 12) out of bounds for length 23
      live =   . , will  java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
   Compilecurrent)>()>()?&continuation _;
    }

    return java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }
};

  () (comp_arena;
  return reinterpret_cast<ZBarrierSetC2State*>(Compile::current()-
}

*:( MachNode*,Addressref_addr  ,Register ,uint8_t barrier_data java.lang.StringIndexOutOfBoundsException: Index 138 out of bounds for length 138
*conststub=new(:(-comp_arena) n,ref_addr   ;
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
   (>(-a();
  }

  return stub;
}

MacroAssembler&;
    _node(node),
    _ref_addr(ref_addr),
    _ref(ref),
    _tmp(tmp),
    _barrier_data(barrier_data),
    _entryGrowableArrayZLoadBarrierStubC2*    (-stubs()
    _continuation() {
  assert_different_registers(ref, ref_addr.base());
  assert_different_registers(ref, ref_addr.index());
}

Address ZLoadBarrierStubC2::ref_addr() const {
  return _ref_addr;
}

Register ZLoadBarrierStubC2::ref() const {
  return _ref;
}

Register ZLoadBarrierStubC2::tmp() const {
  return _tmp;
}

address ZLoadBarrierStubC2::slow_path() const {
   decorators =DECORATORS_NONE
      /Make surethereisenoughspace  the buffer
    | ON_STRONG_OOP_REF;
  }
  if (_barrier_data & ZLoadBarrierWeak) {
    decorators |= ON_WEAK_OOP_REF;
  }
  if      ::urrent)>record_failure(CodeCache is full";
    decorators |java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  }
  if (_barrier_data & ZLoadBarrierNoKeepalive) {
    decorators |= AS_NO_KEEPALIVE;
    }
  java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
}

RegMaskint :estimate_stub_size() const {
  RegMask* mask = barrier_set_state()->livejava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 40
 assert(ask!=NULL "ust  mach- with barrier";
  return *mask;
}

Label* ZLoadBarrierStubC2::entry() {
  // The _entry will never be bound when in_scratch_emit_size() is true.<ZLoadBarrierStubC2* const   barrier_set_state(-s()
for (   ;  >java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 45
  // will eventually be bound. Any label will do, as it will only act asjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
  
  :(-output)>(  _ontinuation _;
}

Label* ZLoadBarrierStubC2::continuationjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  return &_continuation;
}

void* ZBarrierSetC2:   (BarrierSetbarrier_neededaccess.(,type) java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
return  comp_arena ZBarrierSetC2State)
}

void ZBarrierSetC2::late_barrier_analysis}elseif(.)  ) {
   analyze_dominating_barriers;
  java.lang.StringIndexOutOfBoundsException: Range [0, 27) out of bounds for length 12
}

java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  MacroAssembler masm(&cb);
  GrowableArray<barrier_data |= ZLoadBarrierNoKeepalive;

  for (int}
    set_barrier_data();
    ifjava.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
      ciEnv:(-record_failure"odeCacheisfull";
      return;
    }

    ZBarrierSet::  set_barrier_data(access);
  }

  masm.flush();
}

int ZBarrierSetC2::estimate_stub_size() const {  return BarrierSetC2::load_at_resolved(access,val_type);
  Node ::atomic_cmpxchg_val_at_resolved(C2AtomicParseAccess , *java.lang.StringIndexOutOfBoundsException: Index 100 out of bounds for length 100
  BufferBlob* constjava.lang.StringIndexOutOfBoundsException: Range [25, 18) out of bounds for length 27
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  intsize 0java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15

  for (int i = 0; i < stubs->length(); i++) {
b-)(java.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 110
java.lang.StringIndexOutOfBoundsException: Range [23, 18) out of bounds for length 29
->ati)java.lang.StringIndexOutOfBoundsException: Index 81 out of bounds for length 81
+cb)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  }

  return size;
}

static void set_barrier_data(C2Access& access) {
ArrayCopyPhase phase java.lang.StringIndexOutOfBoundsException: Index 81 out of bounds for length 81
      if (phase :) java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41

ifaccess.(  ) {
       ;
    }
      //
    } else {
      barrier_data |ZLoadBarrierStrong
    }

    if
      barrier_data |= ZLoadBarrierNoKeepalive;
       java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5

    access.set_barrier_data(arrier_data;
  }
}

Node* ZBarrierSetC2::load_at_resolved(  domain_fields[TypeFunc::Parms + 0] = TypeInstPtr  // src
set_barrier_dataaccess;
  return BarrierSetC2::load_at_resolved(access,   domain_fields[TypeFunc::Parms + 2] = TypeLong::LONGT:ParmsLONG //sizelower
}

* ::tomic_cmpxchg_val_at_resolvedCAtomicParseAccess&access *expected_val
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 27
returnBarrierSetC2:(ccess expected_val,new_val val_type;
}

  return:maked, range;
                                                     Node* new_val,java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
  set_barrier_data(access);
  return BarrierSetC2::Node* const src = ac->in(ArrayCopyNode
}

Node* ZBarrierSetC2::atomic_xchg_at_resolved
    if ac>s_clone_array( &ary_ptr! NULL java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
  return :atomic_xchg_at_resolved,new_val )java.lang.StringIndexOutOfBoundsException: Index 74 out of bounds for length 74
java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

boolbt  ;
                                                    boolis_clone_instance,
                               )constjava.lang.StringIndexOutOfBoundsException: Index 81 out of bounds for length 81
  if (phase == ArrayCopyPhase::Parsing) {
    returnfalse
  }
      Node* dest_offset = ac->in(ArrayCopyNode::DestPos);
    return     Node* length = ac->in(Arr:)
  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
   equal");java.lang.StringIndexOutOfBoundsException: Range [57, 56) out of bounds for length 59
return = T_OBJECT|type== T_ARRAY;
}

// This TypeFunc assumes a 64bit system
staticconst *clone_type java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
  // Create input type (domain)
  const        (:java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 109
Tjava.lang.StringIndexOutOfBoundsException: Range [25, 24) out of bounds for length 68
  domain_fields[        src_offset  -ajava.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 82
  }
  domain_fields    * =->(, src_offset
      Node*payload_dst >asic_plus_adr(,dest_offset;

  // Create result type (range)
  constType*range_fields  TypeTuple:ields0java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
::make(:Parms + 0,range_fields;

  return TypeFunc::make(domain, range);
}

define XTOP ( phase>()

    constTypeFunc*  :fast_arraycopy_Type();
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
>get_ptr_type)>sa_aryptr)

  -t(call;
    BasicType bt = ary_ptr->elem()->java.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 0
    if(s_reference_type(bt) java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
/ Clone
bt  java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
  
      // Clone primitive array
btT_LONG
    }

  / The native clone we are calling here expects the instance size in words
    Node* mem  *base_offset -longconarraycopy_payload_base_offset-is_clone_array( >)
Node src  -(rrayCopyNodejava.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
    Node*                     mem
    Node                                           (java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
 i(:)
    Node* length =                      ,

    if (bt =                                           ->()java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
      
      // which 8-byte aligns them to allow for word size copies. Make sure the offsets point
oning object ., load
      // barriers are applied to parts of the header. Also adjust the length accordingly.
        for (uint  =from;i<to i){
      jlong offset = src_offset->get_long();
if( ! :base_offset_in_bytes){
        assert(!      // Safepoint
        assert((java.lang.StringIndexOutOfBoundsException: Range [4, 28) out of bounds for length 5
        length
        java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 82
        dest_offset = src_offset;
      }
    }
Node  =-(src )
    Node* payload_dst = phase->()+j){

    charcopyfunc_name arraycopy;
    address     copyfunc_addr =       ;

    const TypePtrShouldNotReachHere
    const TypeFunc* call_type 

    java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 0
   java.lang.StringIndexOutOfBoundsException: Range [11, 9) out of bounds for length 33

    phase->igvn( PhaseCFG  cfg  -cfg(java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
    return;
  }

  // Clone instance
  Node* const   // Step 1 - Find,  them 
mem         -TypeFuncMemory;
  Node* const dst        = ac->in(ArrayCopyNode      block=-get_blocki;
  Node     u j = 0 j <block-number_of_nodes(;+j {

  assert(sizeif(-is_Mach) {

  // The native clone we are calling here expects the instance size in words
  // Add header/offset size to payload size to get instance size.
  Node* const       mach-(){
Node  full_size=phase>( (,base_offset)

  Node*         (->barrier_data)&) !0){
                                           mem,
                                           
                                           ZBarrierSetRuntime:c(,
                                           "ZBarrierSetRuntime::clone",
                                           TypeRawPtr:,
                                           src,
                                           dst,
                                           full_size,
                                           ;
  phase->transform_later(call);
  phase->igvn().replace_node:
}

#       Op_GetAndSetPjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25

// == Dominating barrier elision ==

staticcaseOp_StoreP
  for (uint        java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
    ifjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
      // Safepoint found
      returntrue;
    }
  }

  // Safepoint not found
  return false;
}

static bool block_has_safepoint(const Block* block) {
  return     const TypePtr* load_adr_type = NULL;
}

static uint (const Block* block,const  node {
  for (uint j = 0; j   = - java.lang.StringIndexOutOfBoundsException: Range [85, 83) out of bounds for length 85
     u 0 <java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 47
      return j;
}
  }
();
        const*  get_base_and_disp(mem_offset )
}Block  cfg-get_block_for_nodemem)

voidZBarrierSetC2:analyze_dominating_barriers)const{
  ResourceMark rm;
 C=Compile:()
  PhaseCFG* const           =NULL |mem_obj=NULL |
  ;
  Node_List mem_ops;
  Node_Listcontinue

  
       mem_obj!=||  =load_offset 
     /java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
    for (uint j = 0; j < block->number_of_nodes();}
       * j
      if (!node->if (mem_index < load_, ,java.lang.StringIndexOutOfBoundsException: Range [96, 95) out of bounds for length 99
       java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 17
      }

      MachNode* const mach = node->as_Mach();
      switch (mach->ideal_Opcode()) {
      case Op_LoadP:
        if (        
           ResourceMarkrm;
        }
        if ((mach->barrier_data() &        Block_Liststack;
            ZLoadBarrierStrong
          mem_ops.push(mach);
        }
        break;
      case Op_CompareAndExchangeP:
      case Op_CompareAndSwapP:
      case Op_GetAndSetP:
        if(mach-barrier_data() & ZLoadBarrierStrong) != 0) {
          barrier_loads.push(mach);
        }
      case Op_StoreP:
        mem_ops.push(mach);
        break;

      default:
        ;
      }
    }
  }


  for }
    MachNode* const load)java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 43
java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 40
    intptr_t load_offset blocks
    const   =-get_base_and_disp,load_adr_type;
    Block* const load_block = cfg->get_block_for_node(load);
       =block_index(, load)

    for             .()
      java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 9
      const TypePtrload-set_barrier_data);
      intptr_t}
      const Node* mem_obj = mem->    
      * mem_block=cfg>get_block_for_nodem);
      uint // == Reduced spilling optimization ==

ifload_obj =NodeSentinel|  =|
          load_obj == NULL  ResourceMark;
           <0 | mem_offset 0 {
        continue
      }

      if (mem_obj != load_obj  *const regalloc=Cregalloc)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
//
        continue;
      }

      if (load_block = mem_block){
        // Earlier accesses in the same block ;
        if(em_index<load_index&&!(em_block,mem_index+1,load_index){
          load->set_barrier_data(ZLoadBarrierElided ((oid*( +i) ()
        }
      } else if (mem_block->dominates(load_block)) {
/java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55
           ofsuccessors
            java.lang.StringIndexOutOfBoundsException: Range [8, 7) out of bounds for length 50
        VectorSet visited;
        .(oad_block;
        boolnew_liveORlive];
        while (!safepoint_found &    }
          //
          if (visited.test_set(block i   -number_of_nodes)-1;i> ;-i 
            ;
          }
          if (block_has_safepoint(block)) {
            safepoint_found 
            break;
          }
          if (block == mem_block) {
            continue;
          }

          // Push predecessor blocks
          for       ! :Bad {
            * pred=cfg-(block>p)java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
            stack.push(pred)      for(intj=1  <node-req(); ++j) {
          }
        }

                (safepoint_found java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
          load->set_barrier_data(        const OptoReg::Name second = bs -(use;
        }
             (irst! :Bad java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
    java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
}
}

// == Reduced spilling optimization ==

}
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
       *constregs=barrier_set_state(>(node);
         !)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
      SUBTRACTjava.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
  RegMask*.new_live
  *  :ajava.lang.StringIndexOutOfBoundsException: Range [58, 57) out of bounds for length 60
  java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22

  for (uint i = 0; i < cfg->number_of_blocks 
    new ((void*java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1
    worklist.push(cfg->get_block(i));
  }

  while (worklist.size() > 0) {
    const Block* const block = worklist.pop();
    RegMask& old_live = live[block->_pre_order];
    RegMask new_live;

    // Initialize to union of successors
    for (uint i = 0; i < block->_num_succs; i++) {
      const uint succ_id = block->_succs[i]->_pre_order;
      new_live.OR(live[succ_id]);
    }

    // Walk block backwards, computing liveness
    for (int i = block->number_of_nodes() - 1; i >= 0; --i) {
      const Node* const node = block->get_node(i);

      // Remove def bits
      const OptoReg::Name first = bs->refine_register(node, regalloc->get_reg_first(node));
      const OptoReg::Name second = bs->refine_register(node, regalloc->get_reg_second(node));
      if (first != OptoReg::Bad) {
        new_live.Remove(first);
      }
      if (second != OptoReg::Bad) {
        new_live.Remove(second);
      }

      // Add use bits
      for (uint j = 1; j < node->req(); ++j) {
        const Node* const use = node->in(j);
        const OptoReg::Name first = bs->refine_register(use, regalloc->get_reg_first(use));
        const OptoReg::Name second = bs->refine_register(use, regalloc->get_reg_second(use));
        if (first != OptoReg::Bad) {
          new_live.Insert(first);
        }
        if (second != OptoReg::Bad) {
          new_live.Insert(second);
        }
      }

      // If this node tracks liveness, update it
      RegMask* const regs = barrier_set_state()->live(node);
      if (regs != NULL) {
        regs->OR(new_live);
      }
    }

    // Now at block top, see if we have any changes
    new_live.SUBTRACT(old_live);
    if (new_live.is_NotEmpty()) {
      // Liveness has refined, update and propagate to prior blocks
      old_live.OR(new_live);
      for (uint i = 1; i < block->num_preds(); ++i) {
        Block* const pred = cfg->get_block_for_node(block->pred(i));
        worklist.push(pred);
      }
    }
  }
}