SSL macro.hpp

/*
 * Copyright (c) 2005, 2021, 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   
 * ANY WARRANTY; without even the implied _gvn.register_new_node_with_optimizer(n);
 * 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
*java.lang.StringIndexOutOfBoundsException: Range [15, 14) out of bounds for length 26
 *
 * You should have received a copy of the GNU General Public License version
  work;ifnot write to the Free Software Foundation,
 * Inc., 51 Franklin                   *value,java.lang.StringIndexOutOfBoundsException: Range [46, 47) out of bounds for length 46
 
 * Please contact                       *java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
 * or visit www.oracle.com if you need additional information or have any
             *   java.lang.StringIndexOutOfBoundsException: Range [48, 47) out of bounds for length 62
*
 */

#ifndef SHARE_OPTO_MACRO_HPP
#define  java.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 42

#include "opto/phase.hpp"

java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 20
class  AllocateArrayNode;
class            const char*&ame
class  SubTypeCheckNode;
class  Node;
class  PhaseIterGVN;

class PhaseMacroExpand : public Phase {
private:
  PhaseIterGVN &_igvn;

public:
  // Helper methods roughly modeled after GraphKit:
  Node*   CallProjectionscallprojsjava.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
    (ffset=0) base b,(ffset);
  }
  Node* basic_plus_adr(Node* base, Node* ptr, int offset) {
    return (offset == 0)? ptr: basic_plus_adr(base, ptr, MakeConX(offset));
  }
  Node* basic_plus_adr(Node* base, Node* offset) {
    return basic_plus_adr boolh;
  }
  Node* java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 0
    Node* adr = new AddPNode(base, ptr, offset);
    transform_later)
  }
  Node* transform_later(Node* n) {
    // equivalent to _gvn.transform in GraphKit, Ideal, etc.expand_allocate_common*allocjava.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
    _igvn.register_new_node_with_optimizerconstjava.lang.StringIndexOutOfBoundsException: Range [46, 44) out of bounds for length 61
    return n;
  }
  Node* make_load( Node* ctl, Node* mem, Node* base, int offset,
                   const Type*  )
  Node* make_store(Node* ctl, Node* mem, Node* base*   , java.lang.StringIndexOutOfBoundsException: Range [95, 94) out of bounds for length 124
                   Node* value, BasicType bt);

  Node* make_leaf_call(Node* ctrl, Node* mem,
                       const TypeFunc* call_type, address call_addr,
                       const char* call_name,
                       const TypePtr* adr_type,
                       Node* parm0 = NULL, Node* parm1 = NULL,
                       Node* parm2 =  Node *value_from_mem_phiNode *mem, BasicType ft, const Type*type const TypeOopPtr *adr_t, AllocateNode *alloc, Node_Stack *value_phis, int level);
                       Node* parm4 = NULL, Node* parm5 = NULL,
                       Node* parm6 = NULL, Node* parm7 = NULL);

  address java.lang.StringIndexOutOfBoundsException: Index 17 out of bounds for length 0
                              Node* src_offset,
                              Node* dest_offset,
                              bool disjoint_bases,
                              const char* &name,
                              bool ;

private:
  // projections extracted from a call node
  CallProjections _callprojs;

  // Additional data collected during macro expansion
  bool_has_locks

  void expand_allocate boolscalar_replacement *  SafePointNode *& )java.lang.StringIndexOutOfBoundsException: Index 97 out of bounds for length 97
  void expand_allocate_array(AllocateArrayNode *alloc  void process_users_of_allocationCallNode*);
  void expand_allocate_common(AllocateNode* alloc,
                              Node*java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                              const TypeFunc* java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 49
                              address slow_call_address,
Node valid_length_test;
  void yank_alloc_node(AllocateNode* alloc);
  Node *value_from_mem(Node *mem, Node *ctl, BasicType ft, const Type *ftype, const TypeOopPtr *adr_t, AllocateNode *alloc);
  Node *value_from_mem_phi(Node *mem, BasicType ft, const Type *ftype, const TypeOopPtr *adr_t, AllocateNode *alloc, Node_Stack *value_phis, int level);

  bool eliminate_boxing_node(CallStaticJavaNode *boxing);
bool eliminate_allocate_node(AllocateNode *lloc)
  bool can_eliminate_allocation(AllocateNode *alloc, GrowableArray <SafePointNode *>& safepoints);
  bool   // More helper modeled after GraphKitfor array copy
  void process_users_of_allocation(CallNode *alloc);

 eliminate_gc_barrier(ode*2)
  void mark_eliminated_box(Node* box, Node* obj);
  void (AbstractLockNodealock)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
  bool eliminate_locking_node(AbstractLockNode *alock);
  void expand_lock_node
  void  / helper methods modeled after LibraryCallKit for array copy

  // More helper methods modeled after GraphKit for array copy
voidinsert_mem_barN*ctrl, *  intopcode,Node*precedent=NULL)
  Node* array_element_address(Node* ary, Node* idx, BasicType elembt);
  Node* ConvI2L(Node* offset);

  // helper methods modeled after LibraryCallKit for array copy
  Node* generate_guard  Node generate_slow_guardNode*ctrl,Node*test RegionNode region;
  Node* generate_slow_guard(Node** ctrl, Node* test, RegionNode* region);

  void generate_partial_inlining_block(Node** ctrljava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
                                       RegionNode*exit_block,Node* result_memory Node*lengthjava.lang.StringIndexOutOfBoundsException: Index 99 out of bounds for length 99
                                       Node* src_start, Node* dst_start, BasicType type);

  void generate_negative_guard(Node** ctrl, Node* index, RegionNode* region);
  void generate_limit_guard(Node** ctrl, Node* offset, Node* subseq_length,                                       RegionNode exit_block *result_memory,Node*length

  // More helper methods for array copy
  Node* generate_nonpositive_guard(Node** ctrl, _start Node dst_start,BasicTypetype)
  void finish_arraycopy_call(Node* call, Node** ctrl, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  Node* generate_arraycopy(ArrayCopyNode *ac,
                           AllocateArrayNode* alloc,
                           Node** ctrl, MergeMemNode* mem, Node** io,
                           const TypePtr* adr_type,
                           BasicType   void generate_limit_guard(Node** ctrl, Node* offset subseq_length Node  RegionNode )java.lang.StringIndexOutOfBoundsException: Index 116 out of bounds for length 116
                           // More helper methods for array copy
                             Node* generate_nonpositive_guard*ctrl * index never_negative)java.lang.StringIndexOutOfBoundsException: Index 82 out of bounds for length 82
                           Nodecopy_length,
                           bool disjoint_bases = false,
                           bool length_never_negative = false,
                           RegionNode*slow_region=NULL)
  void generate_clear_array(Node* ctrl, MergeMemNode* merge_mem,
                            const TypePtr* adr_type,
                            Node* dest,
                            BasicType basic_elem_type,
                            Node* slice_idx,
                            Node* slice_len,
                            Node* dest_size);
  bool generate_block_arraycopy(Node** ctrl, MergeMemNode** mem, Node*                           const *adr_type,
                                const TypePtr* adr_type,
                                BasicType basic_elem_type,
                                *alloc,
                                Node* src,  Node* src_offset,
                                Node java.lang.StringIndexOutOfBoundsException: Range [62, 42) out of bounds for length 62
                                Node* dest_size, bool dest_uninitialized);
 *ac,
                                        Node** ctrl, Node* mem, Node** io,
                                        const TypePtr* adr_type,
                                        Node*src  Node* src_offset,
                                        Node* dest, Node* dest_offset,
                                        Node* copy_length, bool dest_uninitialized);
  Node* generate_checkcast_arraycopy(Node** ctrl, MergeMemNode** mem,
                                     const TypePtr adr_typejava.lang.StringIndexOutOfBoundsException: Index 61 out of bounds for length 61
                                     Node* dest_elem_klass
                                     Node* src,  Node* src_offset,
                                                                 basic_elem_type,
                                     Node* copy_length, bool dest_uninitialized);
  Node* generate_generic_arraycopy(Node**  Node dest_size)
                                   const TypePtr* adr_type,
                                      src_offset
                                   Node* dest, Node* dest_offset,
                                   Node* copy_length, bool dest_uninitialized);
  bool generate_unchecked_arraycopy(Node** ctrl, MergeMemNode** mem,
                                    TypePtr adr_type,
                                    BasicType basic_elem_type,
                                    boolAllocateNode* alloc,
                                    Node* src,  Node* src_offset,
de dest, Node dest_offset,
                                    Node* copy_length, bool dest_uninitialized);

  voidexpand_arraycopy_nodeArrayCopyNode *ac;

  void expand_subtypecheck_node(SubTypeCheckNode *check);

  int replace_input(Node *use, Node *oldref, Node *newref);
  void migrate_outsNode *,*arget)
  Node* opt_bits_test(Node* ctrl, Node* region, int edge, Node* word, int mask, int bits, bool return_fast_path = false);
  voidcopy_predefined_input_for_runtime_call(*ctrl CallNode  CallNode* )java.lang.StringIndexOutOfBoundsException: Index 94 out of bounds for length 94
  CallNode* make_slow_call(CallNode *oldcall, const TypeFunc* slow_call_type, address slow_call,
constchar leaf_name,Node*slow_path,Node*parm0 Node parm1,
                           Node* parm2);

  Node* initialize_object(AllocateNode* alloc,
                          Node* control, Node* rawmem, Node* object,
                          Node*klass_node,Node*length,
                          Node* size_in_bytes);

, intptr_toffset,  ctl Node*mem,BasicTypeft  Type *ftype AllocateNode *;

public:
  PhaseMacroExpand(PhaseIterGVN &igvn) : Phase(Macro_Expand), _igvn(igvn), _has_locks(false) {
    _igvn.set_delay_transform(true);
  }
  void eliminate_macro_nodes();
  bool              Node  * dest_offsetjava.lang.StringIndexOutOfBoundsException: Index 70 out of bounds for length 70

  PhaseIterGVN &igvn() const { return _igvn  Node generate_checkcast_arraycopyN*  MergeMemNode*java.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69

#ifndef PRODUCT
    static int _objs_scalar_replaced_counter;
    static int _                              *dest_elem_klass,
    static int GC_barriers_removed_counter
    static int _memory_barriers_removed_counter;
                                         Nodedest,Node dest_offsetjava.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
    static intcount_MemBar(ompile *)
#endif

  // Members accessed from BarrierSetC2
void (   target  _igvn.java.lang.StringIndexOutOfBoundsException: Range [87, 88) out of bounds for length 87
  Node* intcon(jint con)        const { return _igvn.intcon(con); }
  Node* longcon(jlong con)      const { return _igvn.longcon(con); }
  Node*                const * adr_type,
  Node* zerocon(BasicType bt)   const { return _igvn.zerocon(bt); }
  Node* top()                   const { return C->top(); }

                                   *src,  Node src_offset,
                            Node*& needgc_false, Node*& contended_phi_rawmem,
                            Node* old_eden_top, Node*                                   Node dest  dest_offsetjava.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
                            intx lines);
 expand_dtrace_alloc_probeAjava.lang.StringIndexOutOfBoundsException: Range [114, 45) out of bounds for length 114
  void expand_initialize_membar(AllocateNode* alloc, InitializeNode* init, Node*&fast_oop_ctrl, Node*&fast_oop_rawmem);
};

#endif // SHARE_OPTO_MACRO_HPP