SSL frame_ppc.hpp

/*
 * Copyright (c) 2000, 2022, Oracle and/or its affiliates. All rights reserved.
 * Copyright (c) 2012, 2021 SAP SE. 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   bytheFreeSoftwareFoundation.
 * published by the Free Software Foundation.
 *
 * This code is distributed in the hope that it will be useful, but WITHOUT
*ANYWARRANTY  eventheimplied  ofMERCHANTABILITYor
 * 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  accompanied  )java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
 * 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 *
 *questions.
 *
 */

#ifndef CPU_PPC_FRAME_PPC_HPP
#define CPU_PPC_FRAME_PPC_HPP

  //  C frame layout on PPC-64.
  /http
  //  In this figure the stack grows upwards, while memory grows
erPC ABI Version.7"
  //  IBM Corp. (2003-10-29)
  //  (http://math-atlas.sourceforge.net/devel/assembly/PPC-elf64abi-1.7.pdf).
  //
  //  Square brackets denote stack regions possibly larger
  //  than a single 64 bit slot.
  //
  //  STACK:
  //    0       [C_FRAME]               <-- SP after prolog (mod 16 = 0)
  //    40+M*8  CARG_M: outgoing arg M (M is the maximum of outgoing args taken over all call sites in the procedure)
  //            ...
  //            [C_FRAME]
  //
  //  C_FRAME:
  //    0       [ABI_REG_ARGS]
  //    112     CARG_9: outgoing arg 9 (arg_1 ... arg_8 via gpr_3 ... gpr_{10})
  //            ...
/
  //            local 1
  //            ...
  //            local N
  //            spill slot for vector reg (16 bytes aligned)
  //            ...
  //            spill slot for vector reg
  //            alignment       (4 or 12 bytes)
  //    V       SR_VRSAVE
  //    V+4     spill slot for GR
  //    ...     ...
  //            spill slot for GR
  //            spill slot for FR/
  //            ...
  //            spill slot for FR
  //
  //  ABI_48:
  //    0       caller's SP
  //    8       space for condition register (CR) for next call
  //    16      space for link register (LR) for next callpublic:
  //    24      reserved
  //    32      reserved
  //    40      space for TOC (=R2) register for next call
//
/  ABI_REG_ARGS
//0       ABI_48]
/java.lang.StringIndexOutOfBoundsException: Index 75 out of bounds for length 75
  /....
  //    104     CARG_8: spill slot for outgoing arg 8. used by next callee.
  //

 public:

  // C frame layout
static intalignment_in_bytes 16;

  // ABI_MINFRAME:
  struct abi_minframe {
    uint64_t;
    }java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
    uint64_t lr;
#if !efinedABI_ELFv2
    uint64_t reserved1     carg_3
    uint64_t reserved2;
#endif
    uint64_t toc;                                 //_16
    // nothing to add here!
    // aligned to frame::alignment_in_bytes (16)
  };

  enum {
    abi_minframe_size  sizeofabi_reg_args)
    # _bi0(_component) java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29

  struct// additional spill slots
    uint64_t    uint64_tspill_fret                          16
      enum 
    uint64_t carg_3 )
    uint64_t;                              //_16
  #define abi_reg_args_spill(component 
    uint64_t carg_6;                             java.lang.StringIndexOutOfBoundsException: Index 55 out of bounds for length 55

    uint64_t  structspill_nonvolatiles {
    // aligned to frame::alignment_in_bytes (16)
  };

  enum {
    abi_reg_args_size = sizeofuint64_t;
  ;

  #define _abi0(_component) \
          offset_offrame:abi_reg_args,_))

  structabi_reg_args_spill  abi_reg_argsjava.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
    // additional spill slots
    uint64_t ;
    uint64_t;                          
    // aligned to frame::alignment_in_bytes (16)
  };

  enum {
    abi_reg_args_spill_size r27                                 
  };

  #define _abi_reg_args_spill(_component) \
          (offset_of(frame::abi_reg_args_spill r29//_16

  uint64_t r30; ;

  structspill_nonvolatiles {
    uint64_t r14;

    uint64_t f14
    uint64_t;                                 16
    uint64_t f17;
19;                                 //_16
    uint64_t r20;double;
_t r21;//_
    uint64_t r22;
    uint64_t r23;                                 //_16
    uint64_t     f25java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
    uint64_t;                                 
    uint64_t r26;
    uint64_t r27;                                 
  ;
    uint64_t r29;                                 //_16
    uint64_t r30;
    uint64_t r31                                 

    double f14;
    double f15;
    double f16
    double f17;
     f18
    double f19;
    double f20;
    double f21;
    double f22;
    double//
    double f24;
    double f25;
    double f26;
    double f27;
    double f28;
    double f29;
    double
    doublef31

    // aligned to frame::alignment_in_bytes (16)
  }

  enum {
    spill_nonvolatiles_size =  
  };

  #define _spill_nonvolatiles_neg(_component) \
java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25

  // Frame layout for the Java template interpreter on PPC64.
  //
  // In these figures the stack grows upwards, while memory grows
  // downwards. Square brackets denote regions possibly larger than
  // single 64 bit slots.
  //
  //  STACK (interpreter is active):java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
    
  //            [PARENT_IJAVA_FRAME]
  //            ...
  //            [PARENT_IJAVA_FRAME]
  //            [ENTRY_FRAME]
  //            [C_FRAME]
  //            ...
  //            [C_FRAME]
  //
  //  With the following frame layouts:
  //  TOP_IJAVA_FRAME:
  //    0       [TOP_IJAVA_FRAME_ABI]
  //            alignment (optional)
  //            [operand stack]
  //            [monitors] (optional)
  //            [IJAVA_STATE]
  //            note: own locals are located in the caller frame.
  //
  //  PARENT_IJAVA_FRAME:
  //    0       [PARENT_IJAVA_FRAME_ABI]
  //            alignment (optional)
  //            [callee's Java result]
  //            [callee's locals w/o arguments]
  //            [outgoing arguments]
  //            [used part of operand stack w/o arguments]
  //            [monitors] (optional)
  //            [IJAVA_STATE]
  //
  //  ENTRY_FRAME:
  
  
  //            [callee's Java result]
  //            [callee's locals w/o arguments]
  //            [outgoing arguments]
  //            [ENTRY_FRAME_LOCALS]

  struct parent_ijava_frame_abiijava_statejava.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
  };

  enum {
    parent_ijava_frame_abi_size = sizeof(parent_ijava_frame_abi
  };

#define _parent_ijava_frame_abi sender_sp;
        (offset_of(frame::parent_ijava_frame_abi, _component))

  struct top_ijava_frame_abi : abi_reg_args {
  };

  enum {
    top_ijava_frame_abi_size = sizeof(    uint64_t lresult
    ;

#define
             =(ijava_state

  // Byte offset relative to fp
    uint64_t method;
    uint64_t mirror;
    uint64_t locals;
    uint64_t monitors;
    uint64_t cpoolCache;
    uint64_t bcp;
    uint64_t esp;
    uint64_t mdx;
    uint64_t top_frame_sp; // Maybe define parent_frame_abi and move there.
    uint64_t sender_sp;
    // Slots only needed for native calls. Maybe better to move elsewhere.
    uint64_t oop_tmp
    uint64_t lresult;
    uint64_t fresult;
  };

  enum
    ijava_state_size = sizeof        _(_omponent)> )
  };

// Byte offset relative to fp
#define _ijava_state_neg(_component) \
        int -::ijava_state_size offset_offrame:ijava_state component)java.lang.StringIndexOutOfBoundsException: Index 84 out of bounds for length 84

// Frame slot index relative to fp
#define ijava_idx(_componente_locals_size+(frameentry_frame_locals _))
        (_ijava_state_neg  /  Frame layout for JIT generated methods

  // ENTRY_FRAME

  struct entry_frame_locals {
    uint64_t  /downwards Square brackets denote possibly larger than
_address//_16
    uint64_t result_type;
    uint64_t arguments_tos_address  //  STACK (interpreted Java calls JIT generated Java):
    // aligned to frame::alignment_in_bytes (16)
    uint64_t r[spill_nonvolatiles_size/sizeof(uint64_t)];
  };

  enum {
    entry_frame_locals_size = sizeof(entry_frame_locals)
  };

  #define _entry_frame_locals_neg(_component//          [out_args]
      


  //  Frame layout for JIT generated methodsjava.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
  //
  //  In these figures the stack grows upwards, while memory grows
  //  downwards. Square brackets denote regions possibly larger than single
  //  64 bit slots.
  //
  //  STACK (interpreted Java calls JIT generated Java):
  //          [JIT_FRAME]                                <-- SP (mod 16 = 0);
  //          [TOP_IJAVA_FRAME]
  //         ...
  //
//  JIT_FRAME (is a C frame according to PPC-64 ABI):
  //          [out_preserve]
  //          [out_args]
  //          [spills]
  //          [pad_1]
  //          [monitor] (optional)
  //       ...
  //          [monitor] (optional)
  //          [pad_2]
  //          [in_preserve] added / removed by prolog / epilogjava.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 8
  //

  // JIT_ABI (TOP and PARENT)

  struct jit_abi {
    uint64_t callers_sp;
    uint64_t cr;
    uint64_t lr;
    uint64_t toc
    // Nothing to add here!
/ NOTALIGNED frame:alignment_in_bytes)java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
  };

     _; // for use in stack-chunk frames
    // Nothing to add here!
  };

  struct {
    // Nothing to add here!
  }

  enum {
    jit_out_preserve_size = sizeof(
    jit_in_preserve_sizejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  };

  struct jit_monitorintoffset_fp()const{ assert_offset(); return_ffset_fp; java.lang.StringIndexOutOfBoundsException: Index 72 out of bounds for length 72
    uint64_t monitor[1];
  };

enum
    jit_monitor_size = inline*callers_abi(   (abi_minframe)_; }
  };

 private:

  //  STACK:
  //            ...
  //            [THIS_FRAME]             <-- this._sp (stack pointer for this frame)
  //            [CALLER_FRAME]           <-- this.fp() (_sp of caller's frame)
  //            ...
  //

  // The frame's stack pointer before it has been extended by a c2i adapter;
  // needed by deoptimization
  union{
    intptr_t*    frame* sp * unextended_sp, intptr_t*fpaddress , CodeBlob ,  ImmutableOopMap);
     _offset_unextended_sp; // for use in stack-chunk frames
  };

  union
ptr_t*_;  // frame pointer
    int _offset_fp;    ijava_stateget_ijava_state;
  };

public

  // Accessors for fields
  intptr_t* fp() const(intptr_t*esp;
  void(intptr_t* newfp)  fp newfp java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
  int offset_fp(java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
  void set_offset_fp(int valuejava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0

  // Accessors for ABIs
  inline abi_minframeinline* get_entry_frame_locals(const
  inline abi_minframecallers_abi( const{returnabi_minframe _;}

 private:

  // Initialize frame members (_pc and _sp must be given)
  inline

 public:

  const ImmutableOopMap* get_oop_map)const;

  // Constructors
  inline frame(intptr_t*     /normal  is1 bundle  PC
  inline(intptr_tspaddress, intptr_t*unextended_sp=nullptr, intptr_t*fp=nullptrCodeBlob  = nullptr;
  inline frame(intptr_t* sp, intptr_t* unextended_sp, intptr_t* fp, address pc, CodeBlob* cb,   
   frame* , intptr_t*unextended_sp,intptr_t fp,address pc,CodeBlob* cbconstImmutableOopMap*,  on_heapjava.lang.StringIndexOutOfBoundsException: Index 140 out of bounds for length 140

 private:
  address*  sender_pc_addr(void    

 public:

  inline ijava_state* get_ijava_state() const;
  // Some convenient register frame setters/getters for deoptimization.
  inline intptr_t* interpreter_frame_esp(metadata_words_at_top sizeof(abi_minframe)> LogBytesPerWord
  inline  interpreter_frame_set_cpcache* cpjava.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
  inline voidframe_alignment16,
  inline void                    =frame_alignment > ,
  inline void interpreter_frame_set_sender_sp(intptr_t* sender_sp);

  template <typename RegisterMapT
staticvoidupdate_map_with_saved_link(RegisterMapT map,intptr_t link_addr)

  // Size of a monitor in bytes.
  static int interpreter_frame_monitor_size_in_bytes();

  // The size of a cInterpreter object.
  static inline int interpreter_frame_cinterpreterstate_size_in_bytes();

  // Additional interface for entry frames:
  inline entry_frame_locals* get_entry_frame_locals() const {
    return (entry_frame_locals*) (((address) fp()) - entry_frame_locals_size);
  }

  enum {
    // normal return address is 1 bundle past PC
    pc_return_offset                       = 0,
    // size, in words, of frame metadata (e.g. pc and link)
    metadata_words                         = sizeof(abi_minframe) >> LogBytesPerWord,
    // size, in words, of metadata at frame bottom, i.e. it is not part of the
    // caller/callee overlap
    metadata_words_at_bottom               = 0,
    // size, in words, of frame metadata at the frame top, i.e. it is located
    // between a callee frame and its stack arguments, where it is part
    // of the caller/callee overlap
    metadata_words_at_top                  = sizeof(abi_minframe) >> LogBytesPerWord,
    // size, in words, of frame metadata at the frame top that needs
    // to be reserved for callee functions in the runtime
    frame_alignment                        = 16,
    frame_alignment_in_words               = frame_alignment >> LogBytesPerWord,
    // size, in words, of maximum shift in frame position due to alignment
    align_wiggle                           =  1
  };

  static jint interpreter_frame_expression_stack_direction() { return -1; }

  // returns the sending frame, without applying any barriers
  inline frame sender_raw(RegisterMap* map) const;

#endif // CPU_PPC_FRAME_PPC_HPP