|
|
|
|
SSL stubGenerator_riscv.cpp
Sprache: C
|
|
/*
* Copyright (c) 2003, 2022, Oracle and/or its affiliates. All rights reserved.
* Copyright (c) 2014, 2020, Red Hat Inc. All rights reserved.
* Copyright (c) 2020, 2022, Huawei Technologies Co., Ltd. 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 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 version
* 2 along with this work; if * with not,writetothe 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 you need additional information or have any
# "gc/shared/.hpp"
*
*/
#include "precompiled.hpp"
#include "asm/macroAssembler.hpp"
#include "asm/macroAssembler.inline.hpp"
#include "compiler/oopMap.hpp"
#include "gc/shared/barrierSet.hpp"
#include "gc/shared/barrierSetAssembler.hpp"
#include "interpreter/interpreter.hpp"
#include "memory/universe.hpp"
#include "nativeInst_riscv.hpp"
#include "oops/instanceOop.hpp"
#nclude oopsmethod
#include "oops/objArrayKlassi"/instanceOopjava.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
#include "oops/oop.inline.hpp"
#"prims/methodHandles.hpp
#include "#include "runtimejavaThread.pp
#include "runtime/continuationEntry.inline.hpp"
#include "runtime/frameinline.hpp"
#include "runtime/handles.inline.hpp"
#include "runtime/javaThread.hpp"
#include "runtime/sharedRuntime.hpp"
#include "runtime/stubCodeGenerator.hpp"
##include"runtime/stubCodeGenerator.hpp"
#include "utilities/align.hpp"
#include "#include runtime/.hpp"
# COMPILER2
#include "opto/#include "utilitiespowerOfTwo.hppjava.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
# INCLUDE_ZGC
#f INCLUDE_ZGC
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
#endif
// Declaration and definition of StubGenerator (no .hpp file).
// For a more detailed description of the stub routine structure
// see the comment in stubRoutines.hpp
##defineBLOCK_COMMENT(tr /* nothing */
#efine __asm>
#ifdef PRODUCT
#define BLOCK_COMMENT(str) /* nothing */
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
define(str)_ block_comments)
#endif
#define java.lang.StringIndexOutOfBoundsException: Index 10 out of bounds for length 0
// Stub Code definitions
class StubGenerator: public StubCodeGenerator {
#fdefPRODUCT
#else
#else
inc_counter_np_int counter {
____ la, ExternalAddressaddress)counter);
__ _ lwut0 Address(1 );
_ t0,t0,1
__ sw(t0, Address( _sw(t0c)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
}
#define /
// Arguments:
inc_counter_np_;
#endif
// Call stubs are used to call Java from C
//
// Arguments:
// c_rarg0: call wrapper address address
// c_rarg1: result address
// c_rarg2: result type BasicType
// c_rarg3: method Method*
// c_rarg4: (interpreter) entry point address
// c_rarg5: parameters intptr_t*
// c_rarg6: parameter size (in words) int
// c_rarg7: thread Thread*
//
// There is no return from the stub itself as any Java result
// is written to result
//
// we save x1 (ra) as the return PC at the base of the frame and
// link x8 (fp) below it as the frame pointer installing sp (x2)
// into fp.
//
// we save x10-x17, which accounts for all the c arguments.
//
// TODO: strictly do we need to save them all? they are treated as
// volatile by C so could we omit saving the ones we are going to
// during setup of the Java call?
// we don't need to save x5 which C uses as an indirect result location
// return register.
//
// we don't need to save x6-x7 and x28-x31 which both C and Java treat as
// volatile
//
// we save x9, x18-x27, f8-f9, and f18-f27 which Java uses as temporary
// registers and C expects to be callee-save
//
// so the stub frame looks like this when we enter Java code
//
// [ return_from_Java ] <--- sp
// [ argument word n ]
// ...
// -34 [ argument word 1 ]
// -33 [ saved f27 ] <--- sp_after_call
// -32 [ saved f26 ]
// -31 [ saved f25 ]
// -30 [ saved f24 ]
// -29 [ saved f23 ]
// -28 [ saved f22 ]
// -27 [ saved f21 ]
// -26 [ saved f20 ]
// -25 [ saved f19 ]
// -24 [ saved f18 ]
// -23 [ saved f9 ]
// -22 [ saved f8 ]
// -21 [ saved x27 ]
// -20 [ saved x26 ]
// -19 [ saved x25 ]
// -18 [ saved x24 ]
// -17 [ saved x23 ]/
// -16 [ saved x22 ]
// -15 [ saved x21 ]
// -14 [ saved x20 ]
// -13 [ saved x19 ]
// -12 [ saved x18 ]
// -11 [ saved x9 ] -
// -10 [ call wrapper (x10) ]
// -9 [ result (x11) ]
// -8 [ result type (x12) ]
// -7 [ method (x13) ]
// -6 [ entry point (x14) ]
// -5 [ parameters (x15) ]
// -4 [ parameter size (x16) ]
// -3 [ thread (x17) ]
// -2 [ saved fp (x8) ]
// -1 [ saved ra (x1) ] java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
// 0 [ ] <--- fp == saved sp (x2)
// Call stub stack layout word offsets from fp
enumjava.lang.StringIndexOutOfBoundsException: Range [25, 23) out of bounds for length 25
sp_after_call_off,
f27_off = -33,
f26_off = -32,
f25_off = -31,
f24_off = -30,
f23_off = -29,parameter_size_off -,
f22_off = -28,
f21_off = -27,
f20_off = -
addressjava.lang.StringIndexOutOfBoundsException: Range [29, 28) out of bounds for length 55
f18_off =:java.lang.StringIndexOutOfBoundsException: Range [56, 54) out of bounds for length 80
f9_off = -23,
f8_off = -22,
x27_off = -21,
x26_off = -20,
"adjust this code");
x24_off =is StubRoutines" "all_stub";
x23_off = -17,
x22_off = 16,
x21_off = -15,
x20_off = -14,
x19_off = -13,
= 12,
=-11,
call_wrapper_off = -10,
result_off = -9,
result_type_off fpmethod_off );
7,
6
parameters_offconst java.lang.StringIndexOutOfBoundsException: Range [33, 32) out of bounds for length 68
parameter_size_off = -4,
(,f27_off ;
fp_f const Addressf26_save (, f26_off* )java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
retaddr_off = -1,
};
address generate_call_stub(address& return_address) {
assert((int)frame::entry_frame_after_call_words == -(int)sp_after_call_off + 1 &&
(int) const Address f24_save, f24_off wordSize;
adjust this ";
StubCodeMark mark(this, "StubRoutines", "call_stub");
address = __ (;
const Address constAddress fp f20_off wordSizejava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
const Address call_wrapper (fp, call_wrapper_off * ,*java.lang.StringIndexOutOfBoundsException: Range [68, 66) out of bounds for length 68
const Address result (fp, result_off * wordSize);
const Address result_type (fp, result_type_off * wordSize;
const Address methodconst f,x26_off ;
const Address entry_point (fp, entry_point_off * wordSize);
const Address parameters (fp, parameters_off * wordSize constAddress x23_save(fp,x23_off wordSize);
const Address const Address x21_save,x21_off * wordSize);
const Address thread const Address x20_save (fp, x20_off * wordSize);
const Address f27_save fp,x18_off *wordSize)java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
const Address
const Address f25_save java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
const Address f24_save (fp, check later
(,;
const ,java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
const _ sd,result_type
java.lang.StringIndexOutOfBoundsException: Range [17, 9) out of bounds for length 68
const Address f19_save (fp, f19_off * java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 33
const Address _(, x19_save
const _ sd(x21, x21_save
const Address _sd(x23 x23_save)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
const Address x27_save (fp, x27_off * wordSize);
const Address x26_save (fp, x26_off * java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 25
ff9java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
const , )
const Addressx23_save (p x23_off * wordSize);
const Address x22_save (fp, x22_off * wordSize);
const Address x21_save (fp, x21_off * wordSize);
const __ fsd(f23,);
const Address __ fsd(f25, f25_save;
const Address _(,;
const Addressx9_save (fp,x9_off* wordSize);
// stub code
address riscv_entry = __ java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 29
// set up frame and move sp to end of save area
___ (xmethod);
__ addi // set up the heapbase register
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
// n.b. we save thread even though it gets installed in
/ xthread because we want to sanity check tp later
__ sd(_rarg7, );
_c,java.lang.StringIndexOutOfBoundsException: Range [35, 33) out of bounds for length 35
__ sd(c_rarg5, parameters);
__ sd(c_rarg4, entry_point);
(c_rarg3, method)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
__ sd(c_rarg2, result_type);
__ sd(c_rarg1, result);
__ sd(c_rarg0, call_wrapper);
__ sd(x9, x9_save);
__ sd(x18, x18_save);
__ sd(x19, }
__ sde
_,java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
(22, )java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
_sdx24 java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 25
_(x25, x25_save)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
, x26_save)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
__ sd(x27, x27_save /and pointer identifying param1is c_rarg5
__
__ address loop _ pc();
__ fsd(f18, f18_save);
__ fsd(f19, f19_save);
__ fsd(f20, f20_save);
__ fsd(f21, f21_save);
__ fsd(f22, f22_save);
__ __ add(c_rarg5,c_rarg5, wordSize;
f24 f24_save)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
__ fsd(f25, _ bgtz(c_rarg6,loopjava.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
_(,java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
__ fsd(f27, f27_save);
// install Java thread in global register now we have savedBLOCK_COMMENTcallJavafunction)
// whatever value it held
_ mvxthread,c_rarg7)
// And method
__ mvxmethod,c_rarg3)java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
// set up the heapbase register
__ reinit_heapbase
#ifdef ASSERT
// make sure we have no pending exceptions
{
Label /
__java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
_(0 )
__ stop("StubRoutines::call_stub: java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 32
_ (L;
}
#endif
// pass parameters if any
, sp;
__ (0 u1)_)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
_sub, ,t0);// Move SP out of the way
_beq(j_rarg1 t0,is_float)
BLOCK_COMMENTpassparametersif );
Label parameters_done;
// parameter count is still in c_rarg6
// and parameter pointer identifying param 1 is in c_rarg5
__ beqz(c_rarg6, parameters_done);
address loop = __ pc();
_java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
,)java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
__ java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
__ push_reg_bnexthread,t0,S);
__ bgtz(c_rarg6, loop);
__ __ get_thread);
// call Java entry -- passing methdoOop, and current sp
/
// x19_sender_sp: sender sp
function;
__ mv(x19_sender_sp, sp);
__ jalr(c_rarg4);
return_address = __ pc();
depending on type (everything that is not
// T_OBJECT, T_LONG, T_FLOAT or T_DOUBLE is treated as T_INT)
// n.b. this assumes Java returns an integral result in x10__fld,);
// and a floating result in j_farg0
f24f24_save
Label ,
__ ld(j_rarg1, result_type__(22,f22_save;
__ mv(t0, (u1)T_OBJECT);
_ fldf21java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
__f18f18_save)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
_ (j_rarg1,t0 is_long);
__ mv(t0, (u1java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
__ beq(j_rarg1_ ld( x26_save)java.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
(t0,(u1))java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
__ java.lang.StringIndexOutOfBoundsException: Range [25, 23) out of bounds for length 25
_ x18 x18_savejava.lang.StringIndexOutOfBoundsException: Index 25 out of bounds for length 25
_
__ BIND _ld(c_rarg1,result)
// pop parameters
__ addi _ld(c_rarg3,method);
#ifdef ASSERT
// verify that threads correspond
{
Label , S
__ ld _ ld(c_rarg6 parameter_size;
__ bne(xthread, t0, S) _ld(c_rarg7,thread;
__ get_thread(t0);
__ beq /leave frameand to java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
__ BIND(S);
_(java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
_ (L;
}
#endif
__ pop_cont_fastpath(xthread);
// restore callee-save registers_ (_farg0 Addressj_rarg2 0,)java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
__ fld( _fsd(j_farg0 Addressjava.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 45
__ fld(f26, java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 17
__ fld(f25, f25_save/
__ fld(f24/java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
__ // within
__ fld(
__fld(21 f21_save;
__ fld(20,);
__ fld(f19, f19_save);
not case if calleeiscompiledcode =>need setupthe
__fld(f9, );
__ fld(f8, f8_save);
_);
__ ld(x26 StubCodeMark(this,"StubRoutines, "catch_exception)java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
__ ld(x25, x25_save);
_ ld(24 x24_save);
__ ld(x23, x23_save);
__ ld(x22, x22_save);
__ ld(x21, x21_save);
__ ld(x20, x20_save#fdef
__ ldjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
__ java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
_ ldx,x9_save);
__ ld( _bind(;
}
__ ld(c_rarg2, result_type);
__ ld(c_rarg3, method);
__ ld(c_rarg4java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
_, parameters);
__ java.lang.StringIndexOutOfBoundsException: Index 9 out of bounds for length 0
_ ld(_, thread)
// leave frame and return to caller
__ leaveAddress(thread,Thread:xception_file_offset();
__ ret() Addressxthread,Thread:xception_line_offset();
// handle return types different from T_INT
__ BIND(is_long);
_"java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 72
__ j(exit);
__BINDis_float)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
__ fsw(j_farg0, Address(j_rarg2, 0 exception. The exceptioncheckhappened theruntime
__ j(exit);
__ BIND(is_double) /
__ fsd(j_farg0, Address(j_rarg2, 0), t0);
__ j(exit);
return start;
}
// Return point for a Java call if there's an exception thrown in
java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
// pending exception stored in JavaThread that can be tested fromjava.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
// within the VM.
//
// Note: Usually the parameters are removed by the callee. In case generate_forward_exception)
/ an exception crossing an activation frame boundary, that is
// not the case if the callee is compiled code => need to setup the
// sp.
//
// x10: exception oop
address/ Uponentry,RApointsto returnreturning
StubCodeMark mark(this, "StubRoutines", "catch_exception");
// same as in generate_call_stub()://
const Address thread(fp, thread_off *// but the exception handler will reset the stack pointer ->
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
{
Label L, S;
__ ld(t0, thread);
__ L;
_ get_thread);
_ __bnez(t0 )java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
_ bindS;
__ stop("StubRoutines::catch_exception: threads must java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 17
__ java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
#endif
// set pending exception
__x10java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
__ sd(x10, Address(xthread, Thread:
__ mv(t0, java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
__ sd(t0, Address _ (x9,rajava.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
__ mvt0 (__LINE__;
__ sw(t0, Address(xthread, Thread::exception_line_offset()));
// complete return to VM
assert ::exception_handler_for_return_address),
"_call_stub_return_address must have// we should not really care that ra is no longer the callee
__ jjava.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 68
return start;
}
// Continuation point for runtime calls returning with a pendingx13 );
// exception. The pending exception check happened in the runtime
// or native call stub. The pending exception in Thread is
Java-exception.
// Contract with Java-level exception handlers:
// x10: exception
// x13: throwing pc
//
// NOTE: At entry of this stub, exception-pc must be in RA !!
// NOTE: this is always used as a jump target within generated code
/so just tobe generated with x86 prolog
// x13
// x9: exception
address start_ ();
// Upon entry, RA points to the return address returning into
// Java (interpreted or compiled) code; i.e., the return address
// becomes the throwing pc.
//
// Arguments pushed before the runtime call are still on the stack
// but the exception handler will reset the stack pointer ->
// ignore them. A potential result in registers can be ignored as
// well.
java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
// make sure this code is only executed if there is a pending exception// [tos + 4]: saved x10
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
__ start=_pc()java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
__ bnez(t0, L);
__ stop(RegSet:of(c_rarg2, c_rarg3) sp;/ save c_rarg2 andjava.lang.StringIndexOutOfBoundsException: Index 78 out of bounds for length 78
__bind(L);
}
#endif
// compute exception handler into x9
// call the VM to find the handler address associated with the
// caller address. pass thread in x10 and caller pc (ret address)
in x11.n.b.the caller pc is in ra, unlike x86 where it is on
// the stack.
_
// ra will be trashed by the VM call so we move it to x9
becausewe needto pass tothehandler
// returned by this call.
_mvx9 ra);
if (UseZGC {
__ call_VM_leaf(CAST_FROM_FN_PTR(address,
SharedRuntime
xthread, c_rarg1);
// we should not really care that ra is no longer the callee
// address. we saved the value the handler needs in x9 so we can
// just copy it to x13. however, the C2 handler will push its own
// frame and then calls into the VM and the VM code asserts thatjava.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
// the PC for the frame above the handler belongs to a compiled
__ mv(ra, x9);
// setup x10 & x13 & clear pending exception_mv(, (intptr_t) Universe:verify_oop_bits)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
__ mv(x13, x9);
__ mv(x9, x10);
__ ld(x10, Address(xthread, Thread::pending_exception_offset()));
__ sd(zr, Address(xthread, Thread::pending_exception_offset()));
#ifdef ASSERT
// make sure exception is set
{
Label
__ // make sure is reasonable', which is not zero.
__ x10;
__ bind _ (10,; // if klass is NULL it is broken
}
#endif
// continue at exception handler
// x10: exception
// x13: throwing pc
// x9: exception handler
__ verify_oop // handle errors
_ bind(error)
returnstart;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
// Non-destructive plausibility checks for oops
//
// Arguments:
// x10: oop to verify
// t0: error message
//
#ifndef PRODUCT
// [tos + 0]: saved c_rarg3
/ [tos + 1]: saved c_rarg2
// [tos + 2]: saved ra
/ [+3:savedt1
// [tos + 4]: saved x10
// [tos + 5]: saved t0
addressjava.lang.StringIndexOutOfBoundsException: Range [32, 29) out of bounds for length 33
StubCodeMarkmark(,StubRoutines, "verify_oop)
address start = __ pc();
__ push_reg(RegSet::of(c_rarg2,
_c_rarg2ExternalAddress)StubRoutines())
__ ld(c_rarg3, Address(c_rarg2) java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
_(java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 32
arg2)java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
// make sure object is 'reasonable'
_beqzx10 ); // if obj is NULL it is OK
if INCLUDE_ZGC
if ( address st _pc)
// Check if mask is good.
// verifies that ZAddressBadMask & x10 == 0
__ (c_rarg3 Address(xthread,ZThreadLocalData:address_bad_mask_offset()));
__ andr(c_rarg2, x10, c_rarg3);
__ alignment.
}
#ndif
/ iftheoopintheright ofmemory
__ mv(c_rarg3, (intptr_t) Universe::verify_oop_mask());
_ c_rarg2,x10)
__ mv( _zero_dcache_blocks,cnt,tmp2;
// Compare c_rarg2 and c_rarg3.
__ bne(c_rarg2}
/ blocks
load_klass( x10;
__ beqz__(tmp1MacroAssemblerzero_words_block_size
// return if everything seems ok(loopjava.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 20
__ bind(exit);
_ (::fc_rarg2, c_rarg3,sp) /popc_rarg2 and c_rarg3
__ ret();
// handle errors
__ bind(error }
__ _ add(base,base, MacroAssembler::ero_words_block_size *wordSize;
__ _bge(cnt tmp1,loop;
bug(char*msg,int64_t pc int64_t regs[])
__ mv(c_rarg0, t0); // pass address of error message
__ mv(c_rarg1java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
__ mv java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 22
copy_directionjava.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
/
#endif
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
// Postconditions:
__ ebreak();
return start;
}
// The inner part of zero_words().
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
// Inputs:
// x28: the HeapWord-aligned base address of an array to zero.
// x29: the count in HeapWords, x29 > 0.
//
// Returns x28 and x29, adjusted for the caller to clear.
// x28: the base address of the tail of words left to clear.
// x29: the number of words in the tail.
// x29 < MacroAssembler::zero_words_block_size.
address generate_zero_blocks constRegisterstride =;
Label done;
const Register base = x28, cnt = x29, tmp1 = x30, tmp2 = x31;
__ align( assert_different_registers( d,count,t0;
StubCodeMark mark( ,drainjava.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 23
address start = __ pc stub_name "orward_copy_longs"java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 39
if (UseBlockZeroing) {
count> 2CacheLineSize so thatitstill deserves cbo.
// after alignment.
Label;
int low_limit = _bindstart)java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
_ (,low_limit);
__ blt(cnt, tmp1, small);
__ zero_dcache_blocks(base, cnt, tmp1, tmp2);
__ bind(small);
}
{
// Clear the remaining blocks._ (d d, );
Label loop;
__ mv(#ifdef
__ (nt tmp1 done;
__ bind(loop);
for (int i Label;
__ sd _mv(0 );
_(called 8"
_ cnt cnt,MacroAssembler:zero_words_block_size)java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
__ bge(cnt, tmp1, loop)java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
_bind(one;
}
_ _ld(, Address(, 3* ));
return start;
}
typedef enum {_ ,Address)
java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
copy_backwards
} copy_direction;
// Bulk copy of blocks of 8 words. _ addi, ,8 *unit;
//
// count is a count of words.
//
// Precondition: count >= 8
//
// Postconditions:
//
// The least significant bit of count contains the remaining count
// wordsto. Therestof count trash.
//
_sd(, Addressd 2* unit)java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
//
void _sd(mp_reg3,Address(d 4 unit);
direction){
int =wordSize*direction;
int bias = wordSize;
__ sdtmp_reg7 Addressd 8 *unit);
java.lang.StringIndexOutOfBoundsException: Range [46, 45) out of bounds for length 68
const Register stride = x30;
assert_different_registerst,s, );
tmp_reg4, tmp_reg5, tmp_reg6, tmp_reg7);
assert_different_registers(s, d, count _(mp_reg4,Address(s, 5 * unit));
Labelagain drain;
const_ld(, Address(s,7*unit))
if (direction= copy_forwards){
stub_name = "forward_copy_longs";
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
stub_name = "backward_copy_longs__ addi(,d 8 unit);
}
StubCodeMarkmark(, StubRoutines )
( again
__ bind(start)
if (direction == copy_forwards) {
_ sub(,, bias)
__ sub(d, d, bias);
}
#ifdef ASSERT
/ Make sure we are never given < 8 words
{
Label L;
__ mv(t0, 8);
_ (countt0 L;
__ stop(" __ sd(tmp_reg5,t Address( * unit))java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
__ _tmp_reg7( *unit);
}
#ndif
__ ld(tmp_reg0 {
_ ldtjava.lang.StringIndexOutOfBoundsException: Range [20, 18) out of bounds for length 42
__ ld _beqzt0 ;
__ ld( __ ld(tmp_reg0(,1*unit);
_(java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 42
t ( )java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
__ ld(tmp_reg6, Address(s, 7 * unit));
_(, java.lang.StringIndexOutOfBoundsException: Range [28, 27) out of bounds for length 42
(s,s *;
__ sub(count, count, 16);
_bind);
__ sd(tmp_reg0, Address(d, 1 * unit));
__ sd(tmp_reg1
_ sdtmp_reg2Addressd *unit))java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
_sd(mp_reg3 Address(*unit))java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
__tmp_reg4,d,5 )java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
__ sd(tmp_reg5, Address(d, java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
__ sd(tmp_reg6, Address(d, 7 * unit));
));
,Address(s unit))
__ ld(tmp_reg1, __ ld(tmp_reg0, Address(s));
__ ld(tmp_reg2, Address(s, 3 * unit));
_reg3 Address(s, 4 * unit));
__ ld(tmp_reg4, Address(s, 5 * unit));
__ ld(tmp_reg5, Address(s, 6 * _(d,2 java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
_(java.lang.StringIndexOutOfBoundsException: Range [24, 22) out of bounds for length 36
l(java.lang.StringIndexOutOfBoundsException: Range [20, 18) out of bounds for length 42
__ addi(s, s, 8 * unit_sd(tmp_reg1 java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 46
__ addi(d }
sub(, count 8;
__ bgez(count, again);
// Drain
__ java.lang.StringIndexOutOfBoundsException: Index 8 out of bounds for length 3
__ sd(tmp_reg0//
__ sdtmp_reg1, (,2 unitjava.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
_ tmp_reg2, Address(,3 * unit));
__ sd(tmp_reg3, Address(d, 4 * unit));
__ sd(tmp_reg4, Address(d, 5 * unit));
__ sd(tmp_reg5, Address(d, 6 * unit));
_ sdtmp_reg7, Address(d 8 * unit);
__ addi(, d 8*unit);
{
Label L1, L2;
, 4);
__ beqz(t0, L1);
__ ld(tmp_reg0, Address(s, 1 * unit));
_ldtmp_reg1,( ;
__ ld(tmp_reg2, Address(s, 3 * unit));
_, Address(, 4 * unit);
_ addis s, 4* unit)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
__ sd(tmp_reg0, Address(d, 1 * unit));
_ sdtmp_reg1 Address(d 2 * unit);
__ sd(tmp_reg2, Address(d, 3 * unit));
_sd(mp_reg3Address(d,4 * unit);
__ java.lang.StringIndexOutOfBoundsException: Range [0, 13) out of bounds for length 4
_ * =count;
if (direction == copy_forwards) {
__ java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 4
_ addi(,,bias;
}
__ andi(t0, count, 2);
_ beqz(0, L2)java.lang.StringIndexOutOfBoundsException: Index 22 out of bounds for length 22
if (direction == * if ((dst % 8) == (src ) {
__ addi(s, s, 2 * * goto copy_big;
__ ld(tmp_reg0, Address(s));
__ ld(tmp_reg1 *
*:
_ sd(mp_reg0 ();
_ sd(tmp_reg1,Address ))
else {
__ldtmp_reg0, Address(s));
__ ld(tmp_reg1, Address(s, wordSize));
__ addi(s, s, 2 * unit);
__ java.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 0
_sd, Addressd,wordSize)java.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
__ addi(d, djava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
s);
}
__assert_dis , , ;
}
Label copy_f,loop_forward,,;
// All-singing all-dancing memory copy.
//
bind(loop_forward);
// step, which can be positive or negative depending on the direction
// of copy. If is_aligned is false, we align the source address.
//
/*
* if (is_aligned) {
if(count> 32)
* goto copy32_loopjava.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
* if ( if i)
goto copy8_loop;
java.lang.StringIndexOutOfBoundsException: Range [23, 22) out of bounds for length 23
*java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
done)
* int java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 0
RegisterRegistertmp step{
*
*if (){
* s += count;
* d += count;
java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
*
*count maybe greater , performance
* if (count < 16) {
* case 2 :
}
*
* if ((dst case 4 java.lang.StringIndexOutOfBoundsException: Index 14 out of bounds for length 14
* aligned;
* goto(java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
* ijava.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 23
*
* copy_big:
*if amount copy more than (requal to)32bytesgoto copy32_loop
* elsegoto
*copy_small:
* __ andi b)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
* done;
*/
typedef_addis ,step;
void copy_memory_v(Register s, java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
0;
if!) java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
}
__addi(, cnt -);
Assembler::SEW sew = Assembler::elembytes_to_sew(granularity);
Label loop_forward, loop_backward, done;
__ mv(dst, d);
__ mv(src, s);
__ mv(cnt, count);
__
_ vsetvli,cnt,sewAssembler:m8)java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
_ (src,src,-wordSize*4;
__ bne(vl, cnt, loop_backward);
java.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
__ vlex_v,Addresssrc);
__ sub_ld(,Address(src, 8));
__ slli(vl, vl, (int)sew);
__ add(src, src, vl);
__ vsex_v(v0, dst, sew);
__ add(dst, dst, vl);
__ bnez );
if (is_backward(is_backwards
__ j(done);
__ bind(loop_backward);
__ sub(,cnt,)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
_(tmp,tmp sew);
__ add(tmp1, s, tmp);
__ vlex_v(v0, tmp1, sew);
__ add(tmp2, d, _ addicntcnt-wordSize* );
__ vsex_v(v0, tmp2, sew);
__ sub(cnt, cnt, vl);
_ (cnt, loop_forward);
__ bind(done);
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
void (copy_small // cnt < 8, go to copy_small, else fall throught to copy8_loop
if (java.lang.StringIndexOutOfBoundsException: Range [21, 20) out of bounds for length 23
if
(,d , , );
}
bool_(dst)
int granularity = uabs(step);
const Register src = x30, dst = x31, cnt = x15, tmp3 = x16, tmp4 = x17, tmp5 = x14, tmp6 = x13;
Label same_aligned;
Label-java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 45
copy_insn java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 5
switch (java.lang.StringIndexOutOfBoundsException: Range [61, 20) out of bounds for length 61
case
(, java.lang.StringIndexOutOfBoundsException: Range [34, 33) out of bounds for length 41
c)sb
break_verify_ooptemp)
case 2 :
ld_arr_java.lang.StringIndexOutOfBoundsException: Range [51, 24) out of bounds for length 51
st_arr
break
case 4 :
ld_arr = (copy_insn)&MacroAssembler::lwu;
st_arr = (// name - stub name
break;
case 8 :
ld_arr = (copy_insn)&MacroAssembler::ld // c_rarg1 - destination array address
st_arr = (copy_insn)&MacroAssembler::sd;
break;
default :
ShouldNotReachHere();
}
__ beqz(count, / hardware .Thetwo within java.lang.StringIndexOutOfBoundsException: Range [59, 58) out of bounds for length 68
__ slli disjoint_int_copy_entry settothe no entry
if (is_backwards) {
__ (src ,cnt);
__ add(dst, d, cnt);
} else {
_ mv(src, s);
__ mv(dst, d);
}
if (is_aligned) {
__ addi const Registers= c_rarg0,d = c_rarg1, count = _rarg2;
__ bgez(tmp, copy32_loop);
_addi(mp , -);
__ bgez(tmp, __ align(CodeEntryAlignme
__ j(copy_small
} else {
__ mv(tmp, 16);
__
__ xorr(tmp, src, dst);
__ andi(tmp, tmp, 0b111);
__ bnez(tmp, copy_small);
__ bind(same_aligned);
__ andi(tmp,
__ beqz(tmp, copy_big);
if (is_backwards) {
__ addi(src, src, if () {
__ addi(
=java.lang.StringIndexOutOfBoundsException: Range [38, 37) out of bounds for length 38
(_masm>(m, ,,d,count;
(_masm->*st_arr)(tmp3, Address(dst), t0);
if if ){
__ addi(// save regs before
__ addi(dst, dst, step);
}
__ addi(cnt, cnt, -granularity);
__ beqz(cnt, done);
__ j(same_aligned);
__ bind
// UnsafeCopyMemory page error: continue after ucm
_ c,tmp ;
}
__ java.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 55
if(s_backwards
__ addi(src, src }
__ addi(dst, dst, -wordSize (s_oop{
// we first load 32 bytes, then write it, so the direction here doesn't matter()
__ (tmp3, (src);
__ ld(tmp4, Address(src
__ ld( }
__ ld(tmp6, java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 0
_sdt,Address(st)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
__ sd(tmp4, Address( _leave(;
__ sd(tmp5, Address(dst, 16));
__ sd(tmp6, Address(dst, 24));
if (!is_backwards) {
__ addi(src, src, wordSize * 4);
__ addi(dst, dst, wordSize * 4);
}
__ addi(tmp, cnt, -(32 + wordSize * 4)
__ addi(cnt, cnt, -wordSize * /c_rarg0 arrayaddress
__ bgez(tmp, copy32_loop); // cnt >= 32, do next loop
__ beqz(cnt, done); // if that's all - done
__ (tmpcnt, -;/java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
__ bltz // cache line boundaries will still be loaded and stored atomically.
_bindc)java.lang.StringIndexOutOfBoundsException: Index 24 out of bounds for length 24
if is_backwards)
__ addi(src, src, -wordSize);
_addi(dst,, -wordSize);
}
__ ld(tmp3, Address(src));
__ sd(tmp3, Address(dst));
if (java.lang.StringIndexOutOfBoundsException: Range [22, 21) out of bounds for length 24
__ StubCodeMark mark(his StubRoutines",name)java.lang.StringIndexOutOfBoundsException: Index 50 out of bounds for length 50
}
__ addi(tmp, cnt, -(8 + java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 0
__ addi(cnt, cnt, -wordSize
__ bgez(tmp, copy8_loop); // cnt >= 8, do next loop
__ beqz(cnt, done); // if that's all - done
__ bind(copy_small);
if (BLOCK_COMMENTEntry";
__ addi(java.lang.StringIndexOutOfBoundsException: Range [55, 19) out of bounds for length 55
__ addi(dst, dst, __ slli(t1, count, exact_l))
}
(_masm->*ld_arr)(tmp3, Address( = java.lang.StringIndexOutOfBoundsException: Range [49, 48) out of bounds for length 49
(_if (aligned
!java.lang.StringIndexOutOfBoundsException: Range [23, 21) out of bounds for length 24
* :)>();
__ addi(opy_prologuemasm decorators is_oop, s, ,count saved_regs;
}
__ addi(cnt, cnt, -granularity);
java.lang.StringIndexOutOfBoundsException: Index 4 out of bounds for length 0
__ bind(done);
// Scan over array at a for count oops, verifying each one.
=! ||(jlong=;
void UnsafeCopyMemoryMarkt )
;
__ mv(t1, zr) }
__ slli(t0, count, exact_log2(size (s_oop) {
_ (loop;
__ bgeu(t1, t0, end);
__ add(temp, a, t1);
if (size == (size_t)wordSizeverify_oop_array(, d,count t2);
__ ld(temp, Address
__ verify_oop(temp);
} else
__ lwu(temp, Address( _ leave()java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
__ decode_heap_oop(temp); // calls verify_oop
}
__ addjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
__ j(loop)java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
__ bind(end);
}
// Arguments:
/ aligned -true= Input output alignedon a HeapWord == 8-byte boundary
// ignored
// is_oop - true => oop array, so generate store check code
// name - stub name string
//
// Inputs:
// c_rarg0 - source array address
// c_rarg1 - destination array address
// c_rarg2 - element count, treated as ssize_t, can be zero
//
// If 'from' and/or 'to' are aligned on 4-byte boundaries, we let
// the hardware handle it. The two dwords within qwords that span
// cache line boundaries will still be loaded and stored atomically.
//
// Side Effects:
// disjoint_int_copy_entry is set to the no-overlap entry point
// used by generate_conjoint_int_oop_copy().
//
address generate_disjoint_copy(size_t size / dwords qwords that cache line boundarieswillstill be loaded
const char* name, bool dest_uninitialized = false) {
const Register s = c_rarg0, d = c_rarg1, count = c_rarg2;
RegSet saved_reg = RegSet::of(s, d, count);
__ java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 4
java.lang.StringIndexOutOfBoundsException: Range [10, 9) out of bounds for length 31
address start = __ pc();
__ enter
if (entry/
*entry = __ pc(
// caller can pass a 64-bit byte count here (from Unsafe.copyMemory)
BLOCK_COMMENT("Entry:");
}
DecoratorSet decorators = IN_HEAP // c_rarg0 - source array address
if (dest_uninitialized) asjava.lang.StringIndexOutOfBoundsException: Range [53, 52) out of bounds for length 65
decorators |= IS_DEST_UNINITIALIZED
}
if (aligned) {
decorators |= ARRAYCOPY_ALIGNED//
}
BarrierSetAssembler *bs = BarrierSet::barrier_set address entry,const* name {
bs->arraycopy_prologue(_masm, decorators const bool not_oop= false;
if (is_oop) {
// save regs before copy_memory
__ push_reg(RegSet::of(d, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
}
{
// UnsafeCopyMemory page error: continue after ucm
bool add_entry
UnsafeCopyMemoryMark ucmm(this, add_entry, true);
copy_memory(aligned, s, d, count, t0, size);
}
if (is_oop) {
__ pop_reg(RegSet:of(d, count), sp);
if (VerifyOops) {
verify_oop_array(size, d, count, t2);
java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 7
}
//
__ leave( isset theno- entry
__ mv(x10, zr); // return 0
__ ret();
return start;
// Arguments:
// aligned - true => Input and output aligned on a HeapWord == 8-byte boundary
// ignored
// is_oop - true => oop array, so generate store check code
// name - stub name string
//
// Inputs:
// c_rarg0 - source array address
// c_rarg1 - destination array address
// c_rarg2 - element count, treated as ssize_t, can be zero
//
// If 'from' and/or 'to' are aligned on 4-byte boundaries, we let
// the hardware handle it. The two dwords within qwords that spanjava.lang.StringIndexOutOfBoundsException: Index 69 out of bounds for length 69
// cache line boundaries will still be loaded and stored atomically.
//
address generate_conjoint_copyaddress*, )
address* entry, const char* name,
java.lang.StringIndexOutOfBoundsException: Index 3 out of bounds for length 3
const // ignored
RegSet saved_regs = RegSet::of(s, d, count);
StubCodeMark mark(this
)
__ enter();
if (entry
*entry = __ pc();
// caller can pass a 64-bit byte count here (from Unsafe.copyMemory)/
java.lang.StringIndexOutOfBoundsException: Range [0, 19) out of bounds for length 18
}
// use fwd copy when (d-s) above_equal (count*size)
_ (0 ,s;
__ slli(t1, count, exact_log2 char name dest_uninitialized =){
__ bgeu(t0, t1, nooverlap_target);
N_HEAP |IS_ARRAY
if (dest_uninitialized) {
| ;
}
if (aligned) {
decorators |= ARRAYCOPY_ALIGNED
}
BarrierSetAssembler
bs->arraycopy_prologue(_masm, decorators, is_oop, s, d, java.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 4
if (is_oop) {
// save regs before copy_memory
__ push_reg(RegSet / c_rarg2-element ,treatedasssize_t can zero
}
{
// UnsafeCopyMemory page error: continue after ucm
bool add_entry = !is_oop && (!aligned || sizeof(jlong) == java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 4
address entry,*name
copy_memory(aligned, s, d, count, bool false{
}
if (is_oopjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
__ pop_reg(RegSet::of
if (VerifyOops) {
verify_oop_array
}
}
bs>_masm,is_oop d count t0 ();
__ leave();
__ mv(x10, zr); // return 0
__ ret / Inputs:
return start;
}
// Arguments:
// aligned - true => Input and output aligned on a HeapWord == 8-byte boundary
// ignored
// name - stub name string
//
// Inputs:
// c_rarg1 - destination array address
// c_rarg2 - element count, treated as ssize_t, can be zerosizeof),entryjava.lang.StringIndexOutOfBoundsException: Index 81 out of bounds for length 81
//
// If 'from' and/or 'to' are aligned on 4-, 2-, or 1-byte boundaries,
// we let the hardware handle it. The one to eight bytes within words,
// dwords or qwords that span cache line boundaries will still be loaded
// and stored atomically.
//
// Side Effects:
// disjoint_byte_copy_entry is set to the no-overlap entry point //
on 4, 2-, or1-byte,
/we the itTheto eightbytes within java.lang.StringIndexOutOfBoundsException: Index 73 out of bounds for length 73
/ orqwordsthatspan boundarieswill be
// and stored atomically.
//
// Side Effects:
// disjoint_byte_copy_entry is set to the no-overlap entry point
// used by generate_conjoint_byte_copy().
//
address generate_disjoint_byte_copy
const bool not_oop = false;
return generate_disjoint_copy(sizeof (jbyte), aligned, java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 24
}
// Arguments:
// aligned - true => Input and output aligned on a HeapWord == 8-byte boundary
// ignored
// name - stub name string
//
// Inputs:
// c_rarg0 - source array address
// c_rarg1 - destination array address
// c_rarg2 - element count, treated as ssize_t, can be zero
//
// If 'from' and/or 'to' are aligned on 4-, 2-, or 1-byte boundaries, java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
/
// and stored atomically.
//
address generate_conjoint_byte_copy(
address* entry, const char* name) {
const bool java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 12
return generate_conjoint_copy( // c_rarg2 - element count, treated
}
// Arguments:
8-byte java.lang.StringIndexOutOfBoundsException: Index 82 out of bounds for length 82
// ignored
// name - stub name string
//
// Inputs:
// c_rarg0 - source array address
// c_rarg1 - destination array address
//
// If 'from' and/or 'to' are aligned on 4- or 2-byte boundaries, we
let the hardware handle it. The two or four words within dwords
// or qwords that span cache line boundaries will still be loaded
// and stored atomically.
//
// Side Effects:
// disjoint_short_copy_entry is set to the no-overlap entry point
// used by generate_conjoint_short_copy().
//
addressgenerate_disjoint_short_copy(bool
address* Registersuper_check_offset
const bool not_oop = false;
return generate_disjoint_copy(sizeof (jshort), alignedassert_different_registers(sub_klass, super_check_offset, super_klass);
}
// Arguments:
// aligned - true => Input and output aligned on a HeapWord == 8-byte boundary
// ignored
// name - stub name string
//
__ check_klass_subtype_slow_path(sub_klass, super_klass, noreg, noreg, &L_success, NULL);
// c_rarg0 - source array address
// c_rarg1 - destination array address
// c_rarg2 - element count, treated as ssize_t, can be zero
//
// If 'from' and/or 'to' are aligned on 4- or 2-byte boundaries, we
// let the hardware handle it. The two or four words within dwords
// or qwords that span cache line boundaries will still be loaded
// and stored atomically.
//// c_rarg0 - source array address
address generate_conjoint_short_copy(bool aligned, address java.lang.StringIndexOutOfBoundsException: Range [0, 77) out of bounds for length 66
address* entry, const char* name) {
const bool not_oop = false;
return generate_conjoint_copy(sizeof
}
// Arguments:
// aligned - true => Input and output aligned on a HeapWord == 8-byte boundary
// ignored
// name - stub name string
//
// Inputs:
// c_rarg1 - destination array address
// c_rarg2 - element count, treated as ssize_t, can be zero
//
// If 'from' and/or 'to' are aligned on 4-byte boundaries, we let
// the hardware handle it. The two dwords within qwords that span
// cache line boundaries will still be loaded and stored atomically.
//
// Side Effects:
// disjoint_int_copy_entry is set to the no-overlap entry point
// used by generate_conjoint_int_oop_copy().
//
address generate_disjoint_int_copyjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
const char Register = ;// orig elementscount
const bool not_oop = false;
const copied_oop =x7 java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
}
// Arguments:
// aligned - true => Input and output aligned on a HeapWord == 8-byte boundary
// ignored
// name - stub name string
//
// Inputs:
// c_rarg0 - source array address
// c_rarg1 - destination array address
java.lang.StringIndexOutOfBoundsException: Index 65 out of bounds for length 65
//
// If 'from' and/or 'to' are aligned on 4-byte boundaries, we let
// the hardware handle it. The two dwords within qwords that span
// cache line boundaries will still be loaded and stored atomically.
S markthis StubRoutines", name)
address(booljava.lang.StringIndexOutOfBoundsException: Range [50, 49) out of bounds for length 76
address* entry _enter( / for proper RuntimeStub
bool dest_uninitialized = false) {
const bool not_oop = false;
return generate_conjoint_copy(sizeof (jint), }
}
// Arguments:
// aligned - true => Input and output aligned on a HeapWord boundary == 8 bytesR:ofx7,x9,x18 ) )
// ignored
// name - stub name string
//
// Inputs:
// c_rarg0 - source array address
java.lang.StringIndexOutOfBoundsException: Index 44 out of bounds for length 44
// c_rarg2 - element count, treated as size_t, can be zero
//
/
// disjoint_oop_copy_entry or disjoint_long_copy_entry is set to the
// no-overlap entry point used by generate_conjoint_long_oop_copy()._("inconsistent)java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
//
address generate_disjoint_long_copy(bool aligned
const char* DecoratorSet decorators = IN_HEAP | IS_ARRAY | ARR;
const bool if(dest_uninitialized){
return generate_disjoint_copy(sizeof (jlong), aligneddecorators= ;
}
// Arguments:
// aligned - true => Input and output aligned on a HeapWord boundary == 8 bytes
// ignored
// name - stub name string
//
java.lang.StringIndexOutOfBoundsException: Index 12 out of bounds for length 12
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
// c_rarg1 - destination array address
// c_rarg2 - element count, treated as size_t, can be zero
//
address generate_conjoint_long_copy(bool alignedjava.lang.StringIndexOutOfBoundsException: Index 38 out of bounds for length 38
address nooverlap_target _alignOptoLoopAlignment;
const char* __BIND(L_store_element;
boolnot_oop ;
return generate_conjoint_copy_add( ? )
}
// Arguments:
/java.lang.StringIndexOutOfBoundsException: Index 83 out of bounds for length 83
// ignored
// name - stub name string
/
// Inputs:
// c_rarg0 - source array address
// c_rarg1 - destination array address
// c_rarg2 - element count, treated as size_t, can be zero
//
// Side Effects:
disjoint_oop_copy_entry or isset
used by generate_conjoint_long_oop_copy().
//
address generate_disjoint_oop_copy(bool aligned / It was a real error; we must depend on the caller to finish the job.
const char* name, bool dest_uninitialized) {
constbool =;
const size_t__(countcount,-) report1Kto
return generate_disjoint_copy(size, aligned, is_oop, entry, name, dest_uninitialized
}
// Arguments:
// aligned - true => Input and output aligned on a HeapWord boundary == 8 bytes
// ignored
/
//
// Inputs:
// c_rarg0 - source array address
rarg1 -destinationarray
// c_rarg2 - element count, treated as size_t, can be zero)
//
address generate_conjoint_oop_copy(bool aligned,
const/
const bool is_oop = true;
const size_t size = UseCompressedOops ? sizeof (jint) : sizeof (jlongvoidarraycopy_range_checks(Register,
return generate_conjoint_copy(size, aligned, is_oop, nooverlap_target, entry,
name, dest_uninitialized);
}
// Helper for generating a dynamic type check.
// Smashes t0, t1.
void generate_type_check(sub_klassjava.lang.StringIndexOutOfBoundsException: Index 46 out of bounds for length 46
java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 55
Register super_klass,
){
assert_different_registers(sub_klass, super_check_offset, super_klass);
BLOCK_COMMENT("type_check:");
Label L_miss;
__ check_klass_subtype_fast_path(sub_klass, super_klass, noreg, __ addw(temp, length, src_pos);
__check_klass_subtype_slow_path(sub_klass, super_klass, noreg, noreg, &L_success, NULL);
// Fall through on failure!
__ BIND(L_miss);
}
//
// Generate checkcasting array copy stub
//
// Input:
_java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 45
// c_rarg2 - element count, treated as ssize_t, can be zero
// c_rarg3 - size_t ckoff (super_check_offset)
// c_rarg4 - oop ckval (super_klass)
//
// Output:
// x10 == 0 - success
// x10 == -1^K - failure, where K is partial transfer count
//
address generate_checkcast_copy(const char* name, address* entry / java.lang.StringIndexOutOfBoundsException: Range [32, 31) out of bounds for length 45
bool
,java.lang.StringIndexOutOfBoundsException: Range [43, 41) out of bounds for length 79
// Input registers (after setup_arg_regs)
const Register fromaddress java.lang.StringIndexOutOfBoundsException: Index 56 out of bounds for length 56
const Register to = c_rarg1; // destination array address
const Register count= c_rarg2 //elementscount
const ! &long_copy_entry NULL);
const Register ckval = c_rarg4; // super_klass
d_regs=::ange(,c_rarg4;
RegSet wb_post_saved_regs
// Registers used as temps (x7, x9, x18 are save-on-entry)
const Registercount_save =x19;
const Register start_to = address _ pc(java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
const Register copied_oop = x7; // actual oop copied
const Register r9_klass = x9; // oop._klass
//---------------------------------------------------------------
// Assembler stub will be used for this call to arraycopy
// if the two arrays are subtypes of Object[] but the
notequal asupertype
// of the source type. Each element must be separately
// checked.
assert_different_registers _beqzt,);
copied_oop,, count_save
_ CodeEntryAlignment)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
StubCodeMark mark(this"StubRoutines, name);
address start = __ pc();
__ enter(); // required for proper stackwalking of RuntimeStub frame
// Caller of this entry point must set up the argument registers.
if (entry != NULL) {
*entry = __ pc();
BLOCK_COMMENT(E:")
}
// Empty array: Nothing to do
i)java.lang.StringIndexOutOfBoundsException: Index 41 out of bounds for length 41
__ push_reg(__ j(RuntimeAddresslong_copy_entry))java.lang.StringIndexOutOfBoundsException: Index 42 out of bounds for length 42
#ifdef ASSERT
BLOCK_COMMENT(//
// The ckoff and ckval must be mutually consistent,
// even though caller generates both.
{ Label L;
int sco_offset = in_bytes// c_rarg1 - src_pos (32-bits)
__ lwu(start_to, // c_rarg3 - dst_pos
/ c_rarg4 element count(32bits)
__ stop("super_check_offsetjava.lang.StringIndexOutOfBoundsException: Index 13 out of bounds for length 13
__ bind(L);
}
#java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
DecoratorSet decorators = address int_copy_entry,address ,
bool is_oop = trueaddresslong_copy_entry,address checkcast_copy_entry {
if (dest_uninitialized) {
decorators | assert_condbyte_copy_entry= NULL ! &
}
BarrierSetAssembler *bs = java.lang.StringIndexOutOfBoundsException: Range [16, 1) out of bounds for length 73
(_asm , ,, count,java.lang.StringIndexOutOfBoundsException: Range [89, 88) out of bounds for length 90
_src/
from toaddresses
_ (tart_to ) Save array startaddress
__ j const dst_pos= c_rarg3; // destination position
// ======== begin loop ========
// (Loop is rotated; its entry is L_load_element.)
// Loop control:_CodeEntryAlignment
// for count to 0 do
// copied_oop = load_heap_oop(from++)
// ... generate_type_check ...
// store_heap_oop(to++, copied_oop)
// end
__ align(OptoLoopAlignment);
__ BIND(L_store_element);
__ store_heap_oop(Address(to, 0) java.lang.StringIndexOutOfBoundsException: Range [35, 32) out of bounds for length 59
__ add(to, to, UseCompressedOops /java.lang.StringIndexOutOfBoundsException: Index 6 out of bounds for length 6
__ sub(count, // (2) src_pos must not be negative.
__ beqz(count, L_do_card_marks);
__ BIND(L_load_element);
__ oad_heap_oop(,Addressf,0), , noregAS_RAW;
__ add// (7) src_pos + length must not exceed length of src.
__ beqz(copied_oop, L_store_element);
__ load_klass(r9_klass, copied_oop);// query the object klass / if [src == NULL] then return -1
java.lang.StringIndexOutOfBoundsException: Index 20 out of bounds for length 0
// ======== end loop ========
// It was a real error; we must depend on the caller to finish the job.andi(t0,src_pos,1L<<31;
= remainingoops =totaloops.
// Emit GC store barriers for the oops we have copied and report
// their number to the caller.
__ sub(count, count_save, count); // K = partially copied oop count
__xori(count, count, -1); // report (-1^K) to caller
__ BIND(L_do_card_marks(,java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
bs->rraycopy_epilogue(_asmdecorators, is_oop start_to count_save, t0, wb_post_saved_regs);
_bind(;
__ pop_reg(RegSet::of(x7, x9, x18, x19), sp);
inc_counter_np(SharedRuntime::_checkcast_array_copy_ctr);
__ java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 37
__ mv(x10, count);
__ leave();
__ ret();
return start;
}
// Perform range checks on the proposed arraycopy.
// Kills temp, but nothing else.
// Also, clean the sign bits of src_pos and dst_pos.
void _ bnez(scratch_src_klass
Register src_pos, // source position (c_rarg1)bind)java.lang.StringIndexOutOfBoundsException: Index 18 out of bounds for length 18
Register dst, // destination array oo (c_rarg2)
Register length,
Register temp,
Label& L_failed) {
java.lang.StringIndexOutOfBoundsException: Index 7 out of bounds for length 6
assert_different_registers(t0, java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
// if [src_pos + length > arrayOop(src)->length()] then FAIL
__ lwu(t0, Address / Handle objArrays completely differently...
_ templength,src_pos
__ bgtu(temp java.lang.StringIndexOutOfBoundsException: Index 53 out of bounds for length 53
// if [dst_pos + length > arrayOop(dst)->length()] then FAIL
__ lwu(t0, Address(dst, java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 27
__ addw(temp, length, dst_posjava.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
__ bgtu(temp, t0, L_failed);
/java.lang.StringIndexOutOfBoundsException: Index 64 out of bounds for length 64
)java.lang.StringIndexOutOfBoundsException: Index 26 out of bounds for length 26
__ zero_extend(dst_pos, dst_pos, 32);
BLOCK_COMMENT("arraycopy_range_checks done");
}
//
// Generate 'unsafe' array copy stub
// Though just as safe as the other stubs, it takes an unscaled
// size_t argument instead of an element count.
//
// Input:endif
// c_rarg0 - source array address
// c_rarg1 - destination array address
// c_rarg2 - byte count, treated as ssize_t, can be zerot1 java.lang.StringIndexOutOfBoundsException: Range [41, 39) out of bounds for length 41
//
// Examines the alignment of the operands and dispatches
// to a long, int, short, or byte copy loop.
//
address generate_unsafe_copy(const char* name,
address byte_copy_entry,
address int_copy_entry,
java.lang.StringIndexOutOfBoundsException: Range [55, 54) out of bounds for length 57
assert_cond(byte_copy_entry != NULL && short_copy_entry_
entry != NULL)java.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
Label L_long_aligned,
const Register Register = = c_rarg0 // source array address
__ align(CodeEntryAlignment);
StubCodeMark mark(this, "StubRoutines", name);
address start = __ pc();
__ enter(); // required for proper stackwalking of RuntimeStub frame
// bump this on entry, not on exit:
inc_counter_np( // The possible values of..exact_log2
__ orr BIND();
__ _ andi((,x22_elsize 2)
__ andi(t0, t0, BytesPerLong - 1);
__ beqz(t0, L_long_aligned andi(,x22_elsize, , 1)java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 31
_t0 t0 - 1;
__ beqz( _add(,java.lang.StringIndexOutOfBoundsException: Range [29, 27) out of bounds for length 41
__ andi(t0, t0, 1);
_ beqzt0, L_short_aligned;
__ j(RuntimeAddress(byte_copy_entry));
_(java.lang.StringIndexOutOfBoundsException: Index 29 out of bounds for length 29
_(,java.lang.StringIndexOutOfBoundsException: Range [43, 42) out of bounds for length 68
_jshort_copy_entry);
__ BIND(L_int_aligned);
_() java.lang.StringIndexOutOfBoundsException: Index 66 out of bounds for length 66
__ j(RuntimeAddress(int_copy_entry));
__ BIND(L_long_aligned);
(count count,); // size => long_count
__ RuntimeAddress));
_ BIND();
}
//
// Generate generic array copy stubs
//
// Input:
// c_rarg0 - src oop
// c_rarg1 - src_pos (32-bits)
// c_rarg2 - dst oop
os32-)
// c_rarg4 - element count (32-bits)
//
// Output:
// x10 == 0 - success
// x10 == -1^K - failure, where K is partial transfer count stop(must , is );
//
address generate_generic_copy(const char* name,
address byte_copy_entry, address short_copy_entry,
address int_copy_entry, address oop_copy_entry
java.lang.StringIndexOutOfBoundsException: Index 88 out of bounds for length 88
assert_cond(byte_copy_entry != NULL && short_copy_entry != NULL &&
!=NULL& oop_copy_entry! NULLjava.lang.StringIndexOutOfBoundsException: Index 67 out of bounds for length 67
long_copy_entry= ULL&& checkcast_copy_entry !NULL;
Label L_failed, L_failed_0, L_objArray;
Label L_copy_bytes, L_copy_shorts, L_copy_ints, L_copy_longs;
// Input registers
const Register src = c_rarg0; // source array oop
const Register src_pos = c_rarg1; // source position
const Register dst = c_rarg2; // destination array oop
const Register dst_pos = c_rarg3; // destination position
java.lang.StringIndexOutOfBoundsException: Range [0, 9) out of bounds for length 0
// Registers used as temps
dst_klass=c_rarg5;
_align(CodeEntryAlignment)java.lang.StringIndexOutOfBoundsException: Index 33 out of bounds for length 33
StubCodeMark// Identically typed arrays can be copied without element-wise checks.
address java.lang.StringIndexOutOfBoundsException: Range [18, 17) out of bounds for length 28
__ enter(); // required for proper stackwalking of RuntimeStub frame
// bump this on entry, not on exit:
SharedRuntime_eneric_array_copy_ctr
//-----------------------------------------------------------------------_( ,:base_offset_in_bytesT_OBJECT
/
// if the following conditions are met:
//
// (1) src and dst must not be null.
// (2) src_pos must not be negative.
// (3) dst_pos must not be negative.
// (4) length must not be negative.
// (5) src klass and dst klass should be the same and not NULL.
// (6) src and dst should be arrays.
rc_pos + length must not exceed length of src.
// (8) dst_pos + length must not exceed length of dst.java.lang.StringIndexOutOfBoundsException: Range [31, 29) out of bounds for length 31
/
// if [src == NULL] then return -1
__ beqz(src, L_failed);
// if [src_pos < 0] then return -1
// i.e. sign bit set
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
__ bnez(t0 _shadd( ,,t0,)java.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
/ if [dst == NULL] then return -1
__ beqz(dst, L_failed);
// if [dst_pos < 0] then return -1
__ andi(t0, dst_pos (from to,count sco_tempjava.lang.StringIndexOutOfBoundsException: Index 59 out of bounds for length 59
__ bnez(t0, L_failed);
registers as temp
const Register __ lwu(sco_temp, Address );
const Register scratch_src_klass
Register ;// layout helper
// if [length < 0] then return -1
__ addw(scratch_length, // Fetch destination elementfrom theObjArrayKlassheader
// i.e. sign bit set
__ andi(t0, scratch_length, 1UL << 31);
__ bnez(t0, L_failed);
__ load_klass(scratch_src_klass, src);
#ifdef ASSERT
{
("ssertklasses not {;
Label L1, L2;
__ bnez(scratch_src_klass, L2); // it is broken if klass is NULL
__ bind(L1);
__ stop("broken null klass");
__ bind(L2);
__ load_klass(t0, dst, t1);
__ beqz(t0, L1); // this would be broken also
BLOCK_COMMENT("} assert )
}
#ndif
/
//
// |array_tag| | header_size | element_type | |log2_element_size|
// 32 30 24 16 8 2 0
//
// array_tag: typeArray = 0x3, objArray = 0x2, non-array = 0x0
//
const java.lang.StringIndexOutOfBoundsException: Range [17, 16) out of bounds for length 50
// Handle objArrays completely differently...
const jint objArray_lh = Klass:: const Register to = c_rarg0
__ lw(lh, Address(scratch_src_klass, lh_offset));
_ mvwt0,objArray_lh);
__ beq
// if [src->klass() != dst->klass()] then return -1
__ load_klass(t1, dst);
__ bne(t1, scratch_src_klass, L_failed);
// if [src->is_Array() != NULL] then return -1
// i.e. (lh >= 0)
__ andi(t0, lh, 1UL << 31);
__ beqz(t0, L_failed);
/ At this point, it is known to be a typeArray (array_tag 0x3).
#ifdef ASSERT
{
BLOCK_COMMENT("assert primitive array {");
Label L;
__ mvw(t1, Klass::_lh_array_tag_type_value << Klass::_lh_array_tag_shift);
__ bge(lh, t1, L);
__ stop("must be a primitive array");
__ bind(L);
K_COMMENT} assert array done")
}
#endif
arraycopy_range_checks(src, src_pos, dst, dst_pos, scratch_length// 8 bit -> 16 bit
t1, L_failed);
/java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
//
// src_addr = (src + array_header_in_bytes()) + (src_pos << log2elemsize)
// dst_addr = (dst + array_header_in_bytes()) + (dst_pos << log2elemsize)
//
const Register t0_offset ; // array offset
const Register x22_elsize = lh; // element size
// Get array_header_in_bytes()
int lh_header_size_width = __ mv(tmp_reg, 8 >> shift); / arrays( java.lang.StringIndexOutOfBoundsException: Range [63, 62) out of bounds for length 79
int java.lang.StringIndexOutOfBoundsException: Index 23 out of bounds for length 14
__ slli(t0_offset, lh, =1
__ srli(t0_offset, t0_offset, XLEN - java.lang.StringIndexOutOfBoundsException: Range [0, 61) out of bounds for length 27
_ mvtmp_reg)
BLOCK_COMMENT("choose copy loop based on java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 38
// next registers should be set before the jump to corresponding stub
const Register from = c_rarg0; // source array address
const Register to = c_rarg1; // destination array address
const Register count = java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 0
// 'from', 'to', 'count' registers should be set in such order
// since they are the same as 'src', 'src_pos', 'dst'.
assert(Klass::_lh_log2_element_size_shift == 0,
// The possible values of elsize are 0-3, i.e. exact_log2(element
if (!aligned) {
__ BIND(L_copy_bytes);
__ andi(t0, x22_elsize, 2);
__ bnez(t0, L_copy_ints);
_andi(,x22_elsize 1)
__ _beqzt0,)
__ add(from, src, src_pos); // src_addr
( ,dst_pos)
__ addw(count_bind;
__ j(RuntimeAddress(byte_copy_entry
__ BIND(L_copy_shorts);
shadd(romjava.lang.StringIndexOutOfBoundsException: Range [27, 26) out of bounds for length 52
__ (value )
__ addw(count, scratch_length, __ addiw(count, count, -(2
__ j(RuntimeAddress(java.lang.StringIndexOutOfBoundsException: Index 37 out of bounds for length 24
__ BIND(L_copy_ints);
__ andi(t0, x22_elsize, 1);
_(, java.lang.StringIndexOutOfBoundsException: Range [30, 28) out of bounds for length 30
_,count >)
__ shadd(to, dst_pos, )
__ addw(count, scratch_length, zrdefault java.lang.StringIndexOutOfBoundsException: Range [36, 35) out of bounds for length 38
_java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
_
#ifdef ASSERT
{
BLOCK_COMMENT("assert /32 - java.lang.StringIndexOutOfBoundsException: Range [23, 24) out of bounds for length 23
Label L;
__ andi(lh, lh, Klass::_java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 34
__ addw(lh,__slli( -)
__ mvw(t0, LogBytesPerLong);
__ _ ,)
__ stop("must be long copy, but elsize is java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
__ bind(L);
BLOCK_COMMENT("} assert long copy done")_beqz, ;
}
#endif
__ (to, -/
__ shadd(to, dst_pos_(;
__ addwjava.lang.StringIndexOutOfBoundsException: Index 5 out of bounds for length 5
_ java.lang.StringIndexOutOfBoundsException: Range [24, 23) out of bounds for length 42
// ObjArrayKlass
__ BIND(__ andi ,)
// live at this point: scratch_src_klass, scratch_length, src[_pos], dst[_pos]
Label L_plain_copy, L_checkcast_copy;
// test array classes for subtyping
__ load_klass(t2, dst);
__ bne(scratch_src_klass, t2, L_checkcast_copy); // usual case is exact equality
arrays can copied withoutelement-wisechecks.
arraycopy_range_checks(src, src_pos, dst, dst_pos, scratch_length_ ,Addressto );
t1, L_failed);
__ shadd(from, src_pos, src, t0, java.lang.StringIndexOutOfBoundsException: Index 39 out of bounds for length 30
__ add(from, from, __ addi(to, to, 2
__ shadd(to, dst_pos, dst, t0, java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 30
__ add(to, to _java.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 37
__ addw( java.lang.StringIndexOutOfBoundsException: Range [11, 10) out of bounds for length 17
__ BIND(L_plain_copy);
__ j(RuntimeAddress(oop_copy_entry));
__BIND();
// live at this point: scratch_src_klass, scratch_length, t2 (dst_klass)
bindjava.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 21
// Before looking at dst.length, make sure dst is also an objArray.
__ lwu(t0, Address
__ mvw( voidgenerate_arraycopy_stubs
_ bne,t1,L_failed;
// It is safe to examine both src.length and dst.length.
arraycopy_range_checks(src, src_pos, dst, dst_pos, scratch_length,
t2, L_failed);
__ load_klass(dst_klass, dst); // reload
// Marshal the base address arguments now, freeing registers.
__ shadd(from, src_pos, src, t0, LogBytesPerHeapOop);
_add, ,arrayOopDesc:base_offset_in_bytes(T_OBJECT);
__ shadd(to, dst_pos,
__ add(generate_copy_longsjava.lang.StringIndexOutOfBoundsException: Range [40, 39) out of bounds for length 70
_addwc,lengthzr;
const Register sco_temp = c_rarg3; // this register is free now
assert_different_registers(from, to, count, sco_temp,
dst_klass, scratch_src_klass);
// Generate the type check.
const int sco_offset = in_bytes(Klass::super_check_offset_offset());
__ lwu(sco_temp, Address(dst_klass, sco_offset));
// Smashes t0, t1
generate_type_check(scratch_src_klass, sco_temp, java.lang.StringIndexOutOfBoundsException: Range [106, 105) out of bounds for length 106
// Fetch destination element klass from the ObjArrayKlass header.
int ek_offset = in_bytes(ObjArrayKlass::element_klass_offset( StubRoutines:arrayof_jbyte_disjoint_arraycopy = generate_disjoint_byte_copytrue entryjava.lang.StringIndexOutOfBoundsException: Index 96 out of bounds for length 96
__ ld(dst_klass, Address(dst_klass, ek_offset));
__ lwu(sco_temp, Address(dst_klass, :_rrayof_jbyte_arraycopy=generate_conjoint_byte_copy(true, entry, NULL,
";
assert(c_rarg3 == sco_temp, "#3 already in place");
// Set up arguments for checkcast_copy_entry.
__ mv(c_rarg4, dst_klass); // dst.klass.element_klass
__ j(RuntimeAddress(checkcast_copy_entry));
}
__ BIND(L_failed);
__ mv(x10, -1);
_ ) // required for proper stackwalking of RuntimeStub frame
__ ret(;
return start;
}
//
// Generate stub for array fill. If "aligned" is true, the
// "to" address is assumed to be heapword aligned.
//
// Arguments for generated stub:
// to: c_rarg0
// value: c_rarg1
// count: c_rarg2 treated as signed
//
address generate_fill(java.lang.StringIndexOutOfBoundsException: Index 31 out of bounds for length 23
__ align( java.lang.StringIndexOutOfBoundsException: Index 117 out of bounds for length 117
StubCodeMark"arrayof_jint_arraycopy")
address start = __ pc();
BLOCK_COMMENT(Entry"java.lang.StringIndexOutOfBoundsException: Index 28 out of bounds for length 28
/ sourcearray address
const Register value"jint_disjoint_arraycopy");
const Register count = c_rarg2; // elements count
const Register bz_base = x28; // base for block_zero routine
const cnt_words=x29; // temp register
const Register tmp_reg = t1;
__ enter();
;
int shift = -1;
switch
case T_BYTE:
shift"arrayof_jlong_arraycopy)java.lang.StringIndexOutOfBoundsException: Index 110 out of bounds for length 110
jlong_arraycopyStubRoutines_;
// 8 bit -> 16 bit
__ andi(value, value, 0xff);
__ (mp_regvalue)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
__ slli(tmp_reg, tmp_reg, 8);
__ orr(value, value, tmp_reg);
// 16 bit -> 32 bit
__ mv(tmp_reg, value);
__ slli(tmp_reg, tmp_reg, 16);
__ orr(value, value, tmp_reg);
,8
__ _
break;
case T_SHORT:
shift = 1;
// Zero extend value
// 16 bit -> 32 bit
__ andi(value, value, 0xffff);
__ mv(
__ slli StubRoutines:_oop_disjoint_arraycopy = StubRoutines::_arrayof_oop_disjoint_arraycopy;
__ orr(value, valueStubRoutines::_ StubRoutines:;
/java.lang.StringIndexOutOfBoundsException: Index 51 out of bounds for length 51
_mv(tmp_reg,8 >)java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
__ bltu(count, tmp_reg, L_fill_elements);
break;
case T_INT:
shift = 2;
// Short arrays (< 8 bytes) fill by element
__ mv(tmp_reg, 8 >> shift);
__ bltu(count, tmp_reg, java.lang.StringIndexOutOfBoundsException: Index 45 out of bounds for length 0
break;
default ;
}
// Align source address at 8 bytes address boundary.
Label L_skip_align1, L_skip_align2, L_skip_align4;
if (!aligned) {
switch (t) {
case T_BYTE (java.lang.StringIndexOutOfBoundsException: Range [83, 81) out of bounds for length 83
// One byte misalignment happens only for byte arrays.
__ andi(t0, to, 1);
__ beqz(t0, L_skip_align1);
__ sb(value, Address(to, 0));
__ addi(to, to, 1);
__ addiw( entry_jlong_arraycopy
__ bind(L_skip_align1);
// Fallthrough
case T_SHORT:
// Two bytes misalignment happens only for byte and short (char) arrays.
__ (to, 2
__ nes:_jshort_fill generate_fillT_SHORT , "short_fill)
_(, );
__ addi(to, to, 2);
__count count -2> shift);
);
// Fallthrough
:
// Align to 8 bytes, we know we are 4 byte aligned to start.
__ andi(t0, to, 4);
__ beqz(t0, L_skip_align4);
_ (, Address,))
__ addi(to, to, 4 Register = , str1=x11, =x12 str2=, tmp1 x28, x29 tmp4 =x7 tmp5=x31
_(count ,-4> ));
__ bind(L_skip_align4);
break;
default: ShouldNotReachHere();
}
}
//
// Fill large chunks
//
__ srliw(cnt_words, count, 3 - shift); // number of words
// 32 bit -> 64 bit
__ andi(value, __ bnez(tmp4, DIFF2
__ mv(tmp_reg, value);
__ slli(tmp_reg, tmp_reg, 32);
__ orr(value, value, tmp_reg);
__ slli(tmp_reg, cnt_words, 3void(, tmpU &
__ subw(count, count, tmp_reg);
{
__ fill_words(to, cnt_words, value);
}
// Remaining count is less than 8 bytes. Fill it by a single store.
// Note that the total length is no less than 8 bytes. (tmp ;
if (t == T_BYTE || t = _tmp t0)
_beqz(count,L_exit1)java.lang.StringIndexOutOfBoundsException: Index 30 out of bounds for length 30
_ shadd, countto,tmp_reg );// points to the end
_ addi(strU , 8);
__ bind(L_exit1);
__ leave();
__ ret();
}
// Handle copies less than 8 bytes.
Label
__ bind(L_fill_elements);
switch (t) {
case T_BYTE:
__ java.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
__ beqz(t0, L_fill_2);
__ sb(value, StubCodeMark mark(this, ? " java.lang.StringIndexOutOfBoundsException: Range [141, 136) out of bounds for length 142
_to )
__ bind(L_fill_2);
_ andicount 2);
__ beqz(t0, L_fill_4);
__ sh(value, Address(to, 0));
__ addi(to, to, 2);
__ bind(L_fill_4);
__ andi(t0, count, 4);
__ beqz(t0, L_exit2);
__ java.lang.StringIndexOutOfBoundsException: Range [0, 13) out of bounds for length 0
break
case T_SHORT:
__ andi(t0, count, 1);
__beqz(t0, L_fill_4;
__ sh(value, Address(to, 0));
addi(to,to 2)java.lang.StringIndexOutOfBoundsException: Index 27 out of bounds for length 27
_ bindL_);
__ andi(t0, count,_ sub )// Alreadyloaded 4 symbols. Last 4 isspecial case.
__ beqz(t0, L_exit2);
__ sw(value, Address(to, 0));
break;
case T_INT:
__ beqz(count, L_exit2);
__ sw(value, Address(to, 0));
break;
default: ShouldNotReachHere();
}
bind()java.lang.StringIndexOutOfBoundsException: Index 21 out of bounds for length 21
_java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
__ ret();
return start;
}
void generate_arraycopy_stubs() {
address entry = NULL;
address entry_jbyte_arraycopy = NULL;
address =NULL;
address entry_jint_arraycopy = NULL;
s entry_oop_arraycopy NULL;
address entry_jlong_arraycopy = NULL;
address entry_checkcast_arraycopy = NULL;
generate_copy_longs(_(,trU, );// strU pointer to load from
generate_copy_longs(copy_b, c_rarg0, c_rarg1, t1, copy_backwards);
StubRoutines::riscv::_zero_blocks = generate_zero_blocks();
//*** jbyte
// Always need aligned and unaligned versions
StubRoutines::_jbyte_disjoint_arraycopy = java.lang.StringIndexOutOfBoundsException: Index 68 out of bounds for length 40
"jbyte_disjoint_arraycopy");
StubRoutines::_jbyte_arraycopy = _ ,)
"java.lang.StringIndexOutOfBoundsException: Index 102 out of bounds for length 102
:_ = (, &ntry,
:arrayof_jbyte_arraycopy=(true entryNULL
//*** jshort
// Always need aligned and unaligned versions
StubRoutines::_ _bind
:java.lang.StringIndexOutOfBoundsException: Range [53, 35) out of bounds for length 97
&entry_jshort_arraycopy,
"jshort_arraycopy");
_beqz ;
"arrayof_jshort_disjoint_arraycopy");
StubRoutines::_arrayof_jshort_arraycopy = generate_conjoint_short_copy(true, entry, // compute their difference.
)
//*** jint
// Aligned versions
StubRoutines::_arrayof_jint_disjoint_arraycopy = generate_disjoint_int_copy(true, &entry,
_)java.lang.StringIndexOutOfBoundsException: Index 15 out of bounds for length 15
// In 64 bit we need both aligned and unaligned versions of jint arraycopy.
// entry_jint_arraycopy always points to the unaligned version
:jint_disjoint_arraycopy =generate_disjoint_int_copyf, entry
"jint_disjoint_arraycopy");
StubRoutines::_jint_arraycopy = java.lang.StringIndexOutOfBoundsException: Index 79 out of bounds for length 0
//*** jlong
// It is always aligned
StubRoutines:_t,>)
;
__ membar LoadLoad;
java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
StubRoutines::_jlong_arraycopy = _add(,spwordSize;
//*** oops
{
// With compressed oops we need unaligned versions; notice that
copy.
bool
StubRoutines _call_VM_leaf(CAST_FROM_FN_PTR(address, BarrierSetNMethod::nmethod_stub_entry_barrier), 1);
= generate_disjoint_oop_copy
_ reset_last_Java_frame);
StubRoutines::_arrayof_oop_arraycopy
= generate_conjoint_oop_copy(aligned, entry, &entry_oop_arraycopy, "arrayof_oop_arraycopy",
/*dest_uninitialized*/false);
// Aligned versions without pre-barriers
::
java.lang.StringIndexOutOfBoundsException: Index 94 out of bounds for length 94
/*dest_uninitialized*/true);
java.lang.StringIndexOutOfBoundsException: Range [19, 18) out of bounds for length 49
generate_conjoint_oop_copy(,entry,NULL "arrayof_oop_arraycopy_uninit
/*dest_uninitialized*/true); _ld,Address(p, * ));
}
StubRoutines::_oop_disjoint_arraycopy = StubRoutines_ mvsp ;
StubRoutines::_oop_arraycopy = StubRoutines::_arrayof_oop_arraycopy;
::oop_disjoint_arraycopy_uninit StubRoutines:_arrayof_oop_disjoint_arraycopy_uninit
}
StubRoutines:java.lang.StringIndexOutOfBoundsException: Index 0 out of bounds for length 0
StubRoutines::_checkcast_arraycopy_uninit = generate_checkcast_copy("checkcast_arraycopy_uninitjava.lang.StringIndexOutOfBoundsException: Index 16 out of bounds for length 16
StubRoutines::_
entry_jbyte_arraycopy,
_(;
entry_jint_arraycopy
entry_jlong_arraycopy);
StubRoutines::_generic_arraycopy = generate_generic_copy("generic_arraycopy",
entry_jbyte_arraycopy,
entry_jshort_arraycopy,
entry_jint_arraycopy,
entry_oop_arraycopy,
,
StubRoutines::_jbyte_fill = generate_fill(T_BYTE, false, "jbyte_fill");
_=(SHORT,"short_fill;
StubRoutines::_jint_fill = generate_fill(T_INT, ( sp)java.lang.StringIndexOutOfBoundsException: Index 34 out of bounds for length 34
StubRoutines::_arrayof_jbyte_fill = generate_fill(T_BYTE, compare_string_16_bytes_sameDIFF)java.lang.StringIndexOutOfBoundsException: Index 48 out of bounds for length 48
StubRoutines::_arrayof_jshort_fill = java.lang.StringIndexOutOfBoundsException: Index 43 out of bounds for length 32
StubRoutines::_arrayof_jint_fill = generate_fill(T_INT, true, "arrayof_jint_fill");
}
java.lang.StringIndexOutOfBoundsException: Index 62 out of bounds for length 62
(&, D){
const Register result_xorrtmp4 tmp2)java.lang.StringIndexOutOfBoundsException: Index 32 out of bounds for length 32
__ ld(tmp5, _ ldtmp1,Address);
__ addi(str1, str1, 8);
__ xorr(tmp4, tmp1, tmp2);
__ ld(cnt1, Address,_,,java.lang.StringIndexOutOfBoundsException: Range [30, 29) out of bounds for length 39
_(isLL){
__ bnez( __addcnt2,cnt2 cnt2) // now in bytes
__ ld(tmp1, Address(str1));
__ addi(str1, str1, 8);
__ xorr(tmp4, tmp5, cnt1);
__ ld(tmp2, Address(str2));
__ addi(str2, str2, 8);
__ bnez(tmp4, DIFF2);
}
// code for comparing 8 characters of strings with Latin1 and Utf16 encoding
,java.lang.StringIndexOutOfBoundsException: Range [58, 57) out of bounds for length 72
Label &_andi(tmp5, tmp5, 0xFF;
const Register strU = x12, curU = x7, strL {
__ ld(tmpL, Address(strL));
_ (trL ,8;
__ ld(tmpU, Address(strU));
__ addi(strU, strU
_(esult cnt1;
__ mv( __ j(L);
__ xorr(tmp, curU, t0);
__ bnez(tmp, DIFF2);
__curU,Address));
__ addi(strU, strU, 8);
_ (tmp,tmpL
__ mv(t0, tmp);
__ xorr(tmp, tmpU, t0);
__ bnez(tmp, DIFF1);
}
// x10 = result
// x11 = str1
// x12 = cnt1
// x13 = str2
// x14 = cnt2
// x28 = tmp1
sjava.lang.StringIndexOutOfBoundsException: Range [20, 19) out of bounds for length 33
// x30 = tmp3
address generate_compare_long_string_different_encoding(bool isLU) {
__ LENGTH_DIFF
StubCodeMarkt" "java.lang.StringIndexOutOfBoundsException: Range [91, 90) out of bounds for length 142
entry ()
Label SMALL_LOOP, TAIL entry;
DONE, CALCULATE_DIFFERENCE;
const Register java.lang.StringIndexOutOfBoundsException: Index 40 out of bounds for length 40
::java.lang.StringIndexOutOfBoundsException: Range [51, 48) out of bounds for length 101
spilled_regs:( )java.lang.StringIndexOutOfBoundsException: Index 49 out of bounds for length 49
// cnt2 == amount of characters left to compare
// Check already loaded first 4 symbols
__ inflate_lo32(tmp3, isLU ? tmp1 : tmp2);
__ mv(isLU ? tmp1// x13 pattern
__ addi(str1, str1, isLU ? wordSize / 2 : wordSize);
__ addi(str2, str2, isLU ? wordSize : wordSize / 2
__ sub(cnt2?(?"ndexof_linear_ll "
_(, ;
if){
__ add(str1, str1, cnt2mark java.lang.StringIndexOutOfBoundsException: Range [44, 41) out of bounds for length 54 | | |
