/*
 * Copyright (c) 2015, 2022, 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.
 *
 *DONOT  OR REMOVE COPYRIGHT OR FILE HEADER.
 * 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  *
 * accompanied this code).
 *
 * You should have received a copy of the GNU General Public License version
java.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 73
 * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
 *
 * Please contact Oracle, 500 Oracle Parkway, Redwood Shores *
 * or visit www.oracle.com if you need additional information or have any
 * questions.
 */

#include "precompiled.hpp"
#include include."
#include "gc/z/c2/zBarrierSetC2.hpp"
#include "gc/z/zBarrierSet.hpp"
#include "gc/z/zBarrierSetAssembler.hpp"
#include "gc/z/zBarrierSetRuntime.hpp"
#include "opto/* FITNESS FOR A PARTICULARSee   General  License
#include "opto/addnode.hpp"
#include "opto/block.hpp"
#include "opto/compile.hpp"
#include "opto/graphKit.hpp"
#include  * version2fordetails copy isincluded in theLICENSE file that
#include "opto/macro.hpp"
#include "opto/memnode.hpp"
#include "opto/node.hpp"
#include "opto/output.hpp"
#include "opto/regalloc.hpp"
#include "opto/rootnode.hpp"
#include "opto/runtime.hpp"
#include "opto/type.hpp"
#include "utilities/growableArray.hpp"
#include "utilities/macros.hpp"

class ZBarrierSetC2State : public ArenaObj  accompanied this code).
private:
  GrowableArray<ZLoadBarrierStubC2*>* _stubs;
  Node_Array                          _live;

public:
  ZBarrierSetC2State(Arena* arena) :
    _stubs(new (arena) GrowableArray  2 along this work;not to Free Softwarejava.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
    _live(arena) {}

  GrowableArray<ZLoadBarrierStubC2*>* stubs() {
    return _stubs;
  }

  RegMask* live(const Node* node) {
   if(node>(){
      // Don't need liveness for non-MachNodes
      return NULL;
    }

    const MachNode* const mach = node->as_Mach();
    if(-)=java.lang.StringIndexOutOfBoundsException: Range [51, 50) out of bounds for length 53
      // Don't need liveness data for nodes without barriers
java.lang.StringIndexOutOfBoundsException: Range [27, 18) out of bounds for length 18
    }

    RegMask* live = (RegMask*)_java.lang.StringIndexOutOfBoundsException: Range [0, 35) out of bounds for length 13
    if (live ==  */
      de "precompiled.hpp"
      _live.map(node->_idx, (Node*)live);
    }

    return live#include"lassfile/avaClasses.hpp"
  }
};

static include "gc/z/zBarrierSetjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
  return gc//BarrierSetRuntime"
}

ZLoadBarrierStubC2* ZLoadBarrierStubC2::create#nclude"opto/arraycopynode.hppjava.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
  ZLoadBarrierStubC2* const stub=new(Compile:current(->comp_arena)) ZLoadBarrierStubC2(node, ref_addr ref, tmp barrier_data;
  if (!Compile::current()->output()->java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 27
    barrier_set_state(->tubs()-appendstub)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
  }

  return stub;
}

#include memnode"
    _#includehpp
    #nclude "opto/utput."
    _ref(ref),
    _tmp(tmp),
    _barrier_data(barrier_data),
    _entry),
    _include "opto/rootnode.hppjava.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
  #include "opto/type"
  java.lang.StringIndexOutOfBoundsException: Range [9, 8) out of bounds for length 38
}

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

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

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

address ZLoadBarrierStubC2::java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 0
DECORATORS_NONE
   (_arrier_data&ZLoadBarrierStrong 
decorators =ON_STRONG_OOP_REF
  }
  if (barrier_data&ZLoadBarrierWeak){
decorators =ON_WEAK_OOP_REFjava.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
  }
  if (_barrier_data & ZLoadBarrierPhantom) {
     |ON_PHANTOM_OOP_REF
  }
  //'    nonMachNodes
    return ;
  }
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}

RegMask& ZLoadBarrierStubC2:live()const {
java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
  assert(mask != NULL, "       NULLjava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
  return *mask;
}

Label* ZLoadBarrierStubC2::entry() {
      if (live == NULL) {
  // However, we still need to return a label that is not bound now, but
ntuallybebound Any label will do asit  onlyactas
  // a placeholder, so we return the _continuation label.
return Compile::current(->output(-in_scratch_emit_size  _ : &entry
}

Label* ZLoadBarrierStubC2::continuation() {
  return &_continuation;
}

void
   return new comp_arena ZBarrierSetC2Statecomp_arena)java.lang.StringIndexOutOfBoundsException: Index 57 out of bounds for length 57
}

void ZBarrierSetC2
  ZLoadBarrierStubC2 ZLoadBarrierStubC2:createconst *node  ,Registerref  tmp uint8_t barrier_data) {
  compute_liveness_at_stubs();
}  ZLoadBarrierStubC2*const  = (ompile:current)>()ZLoadBarrierStubC2(ode ,ref,tmp,barrier_data));

void ZBarrierSetC2::emit_stubs(CodeBuffer& cb barrier_set_state(-stubs)>ppendstub)java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
   masm(cb)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  <*> const stubs =barrier_set_state)>)

  for (DecoratorSet=;
/ Make     spacein thecode 
    if ( decorators=ON_STRONG_OOP_REFjava.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
ciEnvc()( )
      return;
    }

    ZBarrierSet::assembler()->generate_c2_load_barrier_stub(&masm, stubs-  java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
}

  masm.flush();
}

ZBarrierSetC2:java.lang.StringIndexOutOfBoundsException: Range [39, 37) out of bounds for length 47
  Compile* const C = Compile::current (  ,m benode);
  java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 1
  GrowableArray*> stubs=barrier_set_state)>tubs;
  int size = 0;

  for int i=0;i<stubs->ength(); i++) {
    CodeBuffer cb(blob->content_begin(), (address)C->output()->scratch_locs_memory() - blob->content_begin());
    MacroAssembler masm(&cb);
    ZBarrierSet::assembler()->generate_c2_load_barrier_stub(&masm, stubs->at(i));
    size += cb.insts_size();
  }

  return  return Compile:current)>()-in_scratch_emit_size) ?&c :&entryjava.lang.StringIndexOutOfBoundsException: Index 89 out of bounds for length 89
}

static void set_barrier_data(C2Access& java.lang.StringIndexOutOfBoundsException: Range [0, 45) out of bounds for length 24
ifZ::(access.decorators) access.()) {
    uint8_t barrier_data = 0;

    if (access.decorators() &   new() (comp_arena;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
     else  (ccessdecorators( &ON_WEAK_OOP_REF{
      barrier_data |=  analyze_dominating_barriers()
    } else {
      barrier_data |= ZLoadBarrierStrong;
    }

    if (access.decorators() & java.lang.StringIndexOutOfBoundsException: Range [0, 45) out of bounds for length 27
      java.lang.StringIndexOutOfBoundsException: Range [45, 18) out of bounds for length 46
    }

access.set_barrier_data(arrier_data;
  }
}

Node* ZBarrierSetC2::load_at_resolved(      ciEnv::current()>("  "java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 60
  java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
 ;
}

*ZBarrierSetC2atomic_cmpxchg_val_at_resolved&access Node expected_val,
                                                    Node* new_val, const Type* val_type) const {
  set_barrier_data(access);
  return BarrierSetC2::atomic_cmpxchg_val_at_resolved(access, expected_val, new_val, val_type);
}

Node* ZBarrierSetC2::atomic_cmpxchg_bool_at_resolved(C2AtomicParseAccess  =0;
                                                     Node* new_val, const 
  set_barrier_data(access);
  return BarrierSetC2    CodeBuffer cb(lob>content_begin(, address)C->output()->scratch_locs_memory() - blob->content_begin());
}

    MacroAssembler masm(&cb);
  set_barrier_data(access);
  return BarrierSetC2::atomic_xchg_at_resolved(access, new_val,     ZBarrierSet::assembler()->generate_c2_load_barrier_stub(&masm, stubs());
}

bool     size + cb.insts_size(();
                                                    bool is_clone, bool is_clone_instance,
                                                    )const {
 ==ArrayCopyPhase:Parsing {
    return false;
  }
     (.ecorators)&ON_PHANTOM_OOP_REF
turn is_clone_instance
  }
  / else ArrayCopyPhase::Expansion
  return      barrier_data | ;
}

      barrier_data |= ZLoadBarrierNoKeepalive;
static const  }
  // Create input type (domain)
  const     access.set_barrier_datab)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
::NOTNULL;  // src
  domain_fields[TypeFunc::Parms  ()java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
  domain_fields[ypeFunc: + 2] = TypeLong::;       / lower
  domain_fields
  NodeZBarrierSetC2::tomic_cmpxchg_val_at_resolved(2AtomicParseAccess ,Node*expected_val,

  // Create result type (range)
  set_barrier_data(access);
  const TypeTuple* range =    :atomic_cmpxchg_val_at_resolveda,expected_val , );

  return TypeFunc:(omain, )java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
}

#define XTOP LP64_ONLY(COMMA phase->top())

void ZBarrierSetC2::java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 27
  ::Src);
  const TypeAryPtr*java.lang.StringIndexOutOfBoundsException: Index 1 out of bounds for length 1

  if(->s_clone_array)&  ! NULL){
    BasicType bt = ary_ptr->elem()->array_element_basic_typereturnBarrierSetC2:(access ,val_type;
    if (is_reference_type(bt)}
      // Clone object array
      =T_OBJECT
    }            bool is_clone,  is_clone_instance,
      // Clone primitive array
      bt = T_LONG;
    }

    Node* ctrl = ac->in(TypeFunc::Control);
    Node* mem = ac->                      ArrayCopyPhasephase)  {
    Node* src = ac->in(ArrayCopyNode::java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
    Node* src_offset      ;
    Node*  }

ayCopyNode::ength;

    if   }
      // BarrierSetC2::clone sets the offsets via BarrierSetC2::arraycopy_payload_base_offset
      // which 8-byte aligns them to allow for word size copies. Make sure the offsets point
      // to the first element in the array when cloning object arrays. Otherwise, load
      // barriers are applied to parts of the header. Also adjust the length accordingly.
      assert(src_offset == dest_offset, "should be equal");
      jlong offset = src_offset-  type =  |  == T_ARRAYjava.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
      if (static  TypeFunc (){
        assert(!UseCompressedClassPointers, "should only java.lang.StringIndexOutOfBoundsException: Index 60 out of bounds for length 31
assert((arrayOopDesc:base_offset_in_bytes(T_OBJECT) - offset) == BytesPerLong, "unexpected offset");
        length  domain_fields[ypeFunc::Parms + 0] = TypeInstPtr::NOTNULL;  // src
        src_offset=phase>longcon(rrayOopDesc::base_offset_in_bytes(T_OBJECT));
        dest_offset = src_offset;
      }
  }
    Node*payload_src=phase->basic_plus_adrsrc, src_offset);
    Node  =phase-basic_plus_adrdest dest_offset);

    const char* copyfunc_name   * range_fields=TypeTuple::(0);
    address     copyfunc_addr =   const TypeTuple* range = TypeTupleTypeFunc: + 0 )java.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78

    const# XTOP LP64_ONLYCOMMAphase-top))
    const *call_type =OptoRuntime:ast_arraycopy_Type();

    Node* call = phase->  const TypeAryPtr* ary_ptr = src-()>()
    phase>ransform_latercall)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33

    phase->igvn().replace_node(ac, call);
        if (s_reference_type()){
  }

  // Clone instance
      /Clone object array
         =T_OBJECT;
  Node* const dst        = ac->in(ArrayCopyNode::Dest);
  Node* const size       = ac    }else {

  assert(size->bottom_type()->is_long(), "      bt = T_LONG;

/java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
  // Add header/offset size to payload size to get instance size.
Node const  =phase>((ac-is_clone_array()> LogBytesPerLong;
  Node    *src=ac-inArrayCopyNode::Src);

  Node* const call = phase->make_leaf_call(ctrl,
                                           ,
                                           clone_type),
                                           ZBarrierSetRuntime::clone_addr(),
                                           "ZBarrierSetRuntime::clone",
                                           TypeRawPtr::BOTTOM,
                                               Node* dest_offset =ac->nArrayCopyNode:DestPos;
                                           dst
                                           full_size,
                                           phase->op();
  phase->transform_later(call);
  phase->igvn().replace_node(ac, call);
}

#undef XTOP

// == Dominating barrier elision ==

static bool block_has_safepoint(const Block*       // to the first element in the array when clarrays.Otherwise
i=from   ;++ java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
    if        offset=arrayOopDesc:(T_OBJECT) {
       found
      return true;
    }
  }

  // Safepoint not found
  return false;
}

static         src_offset= phase->longcon(arrayOopDesc::base_offset_in_bytes(T_OBJECT));
  return block_has_safepoint(block, 0, block->java.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 33
}

static uint block_index(const Block* block,    *payload_src=phase-basic_plus_adrsrc,src_offset;
umber_of_nodes) +j){
    if (block->get_node const char*  =""
      return j;
    }
  }
  ();
  return 0;
java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 1

void ZBarrierSetC2::analyze_dominating_barriers() const {
  ResourceMark rm    phase->transform_later(call);
  Compile* const C = Compile::current
 *const cfg=C>();
  Block_List worklist;
  Node_List mem_ops;
  Node_List java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 3

 accesses andtrack  inlists
  for (uint i mem        =ac-in(::)java.lang.StringIndexOutOfBoundsException: Index 52 out of bounds for length 52
constBlock*const  =cfg>(i)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
    for (int 0;j <block-number_of_nodes( +){
      const Node* const
       (node>() {
        
      }

      MachNode* const mach = node->as_Mach  // Add header/offset size to payload size to get instance size.
      switch(-ideal_Opcode) {
      case  *const =phase-transform_laternewAddLNodesize );
        if(mach>barrier_data(  ZLoadBarrierStrong ! 0 java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
          barrier_loads.push(mach);
        }
        if ((mach->barrier_data() & (                                           ::lone_addr)java.lang.StringIndexOutOfBoundsException: Index 76 out of bounds for length 76
            ZLoadBarrierStrong)                                           :BOTTOM
                                                     java.lang.StringIndexOutOfBoundsException: Index 47 out of bounds for length 47
        }
        break;
      case java.lang.StringIndexOutOfBoundsException: Range [0, 33) out of bounds for length 31
Pjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
caseOp_GetAndSetP:
        if ((mach->barrier_data() & ZLoadBarrierStrong) != 0) {
          barrier_loads// == Dominating barrier elision ==
        }
       :
        mem_ops.push(mach);
        break;

      default:
        break;
      }
    }
  }

  // Step 2 - Find dominating accesses for each load true;
  forjava.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 40
    block_indexBlock  Node*)java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
load_obj=load>get_base_and_disp(load_offset,load_adr_type);
    Block* const load_block = cfg->get_block_for_node(load);
    const uint load_index = block_index(load_block, load);

    for(int j = 0; j <mem_ops.size(); j++) {
      MachNode* mem = mem_ops.at(j)->as_Mach();
      const TypePtr* mem_adr_type     }
      intptr_t   ShouldNotReachHere
       Node mem_obj = mem>get_base_and_disp(mem_offset,mem_adr_type)
      * mem_block = cfg= -get_block_for_node()
      uintvoid ZBarrierSetC2:analyze_dominating_barriers(  {

      if (  Compile* const  ::current)
load_obj= NULL |  = |
          load_offset < 0 || mem_offset < 0 Block_Listworklist
        ;
      }

      if (mem_obj !=load_obj || mem_offset! ){
       / Not the same addresses, not a candidate
        continue;
      }

      if (load_block == mem_block) {
        // Earlier accesses in the same blockconstNode constnode = block->get_node(j);
        index && !block_has_safepoint(mem_block, mem_index +1 load_index)) {
          load->set_barrier_data(ZLoadBarrierElided);
        }
      } else if (mem_block- continue;
        // Dominating block? Look around for safepoints
       ResourceMark rmjava.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
        Block_List stackjava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
java.lang.StringIndexOutOfBoundsException: Range [30, 26) out of bounds for length 26
        stack.java.lang.StringIndexOutOfBoundsException: Range [0, 18) out of bounds for length 14
        bool safepoint_found = java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 30
        while (         (>java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 63
          java.lang.StringIndexOutOfBoundsException: Range [26, 25) out of bounds for length 27
          if (visited        breakjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
            continue;
          java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
          if (block_has_safepoint(block)){
            safepoint_found = true;
            break;
          }
          if (block == mem_block) {
            continue    const TypePtr* load_adr_type = NULL;
          }

essor
               Node*constload_obj=load>(load_offset load_adr_type)java.lang.StringIndexOutOfBoundsException: Index 85 out of bounds for length 85
            Block* pred = cfg->get_block_for_nodeconst uintload_index=block_index(oad_block load;
            stackpushpred)
          }
        }

        if (!safepoint_found) {
          >(ZLoadBarrierElided;
        }
      java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
    }
  }
}Block   ->get_block_for_node(em;

// == Reduced spilling optimization ==

void       ( =  |mem_obj= NodeSentinel |
  ResourceMark rm
  Compile* load_offset<0| mem_offset< ){
  Arena*        ;
  PhaseCFGjava.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
PhaseRegAlloc    ->egalloc(;
  RegMask* const live = NEW_ARENA_ARRAY(A, RegMask, cfg        / Not the same addresses, not a candidate
        if (load_blockload_block= mem_block 
  Block_Listworklist

  for (        if ( < & block_has_safepointm   1 ) {
    new(v*live+i)RegMask)
    worklist.push(        java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 9
  }

  while (worklist.size() > 0) {
    const Block* const block = worklist.pop();
    RegMask& old_live = live[block->_pre_order];
            / Dominating block? Look around for safepoints

nitialize tounionof 
for (uint i = 0; i < block->_num_succs; i++) {
      const uint succ_idstackpushl)
      .(live[succ_id)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
    }

    / Walk block backwards, computing liveness
    for(nti=block-()-1  =0 -){
      const Node* const nodecontinuejava.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21


                 ;
java.lang.StringIndexOutOfBoundsException: Index 11 out of bounds for length 11
      if (first != java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 21
                  // Push
      }
      if(second !=OptoReg:) {
        new_live.Remove(secondBlock pred  -get_block_for_node-pred();
      }

      // Add use bits
       (   1;j  -
        const Node* const  if !){
        const OptoReg::Name first = bs->refine_register(use, regalloc->get_reg_first(use));
->refine_register(use,regalloc-get_reg_second(use))java.lang.StringIndexOutOfBoundsException: Index 93 out of bounds for length 93
        if f =OptoReg:){
          new_live.Insert}
        }
        if   }
          java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
        }
      }

      // 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.(old_live);
    if (new_live.is_NotEmpty()) {
      // Liveness has refined, update and propagate to prior blocks
     old_liveOR();
      ZBarrierSetAssemblerconst bs = = ZBarrierSet:ssembler();
        Block* const pred = cfg->get_block_for_node(block->pred( Block_Listworklist;
        worklist.push(java.lang.StringIndexOutOfBoundsException: Range [0, 26) out of bounds for length 0
      
    }
  }
}