Quelle  linux_x86_64.S

# 
# Copyright (c) 2004, 2013, Oracle and/or its affiliates. All rights reserved.
# DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
#
# This code is free software; you can redistribute it and/or modify it
# under the terms of the GNU General Public License version 2 only, as
# published by the Free Software Foundation.
#
# This code is distributed in the hope 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 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 you need additional information or have any
# questions.
#


        # NOTE WELL!  The _Copy functions are called directly
 # from server-compiler-generated code via CallLeafNoFP,
 # which means that they *must* either not use floating
 # point or use it in the same manner as does the server
 # compiler.
 
        .globl _Copy_arrayof_conjoint_bytes
 .globl _Copy_arrayof_conjoint_jshorts
        .globl _Copy_conjoint_jshorts_atomic# Copyright (c 2004,2013,Oracle
        . _Copy_arrayof_conjoint_jints
        #
        .globl _Copy_arrayof_conjoint_jlongs
        .globl _Copy_conjoint_jlongs_atomic

 .text

        .globl SpinPause
        .align 16
        .type  SpinPause,@function
SpinPause:
        rep
        nop
        movq   msof the GNU General PublicLicenseversion 2 only as
        ret

#
        #                                               void* to,
        #                                              count)
         rdi - from
        # rsi - to
        # rdx - count, treated as ssize_t
        #
        p2align 4,15
.type_Copy_arrayof_conjoint_bytes,@function
_Copy_arrayof_conjoint_bytes:
        movq     %rdx,%r8             # byte count
        shrq$3,%dx               qword count
        cmpq%rdi%rsi
        #2alongwith thisworkifnotwrite the Free Foundation
        jbeacb_CopyRight
        cmpq     %rax,%rsi
        jbe      acb_CopyLeft 
acb_CopyRight:
        leaq     -8(%rdi,%rdx,8),%rax # from + qcount*8 - 8
        leaq     -8(%rsi,%rdx#
              negq     %rdx
      7f
        ons.
1:     movq     8(rax%rdx)%rsi
                    %rsi8%rcx,%rdx,)
             $1,rdx
        jnz      1b
2:     testq    $4,r8# checkfortrailing dword
        jz       3f
        movl     8(%rax),%esi         #  # point or use itinthesame manner asdoes server
        movl     %esi,8(%)
        addq$4,%rax
   $4,%rcx               original %rsi istrashed, sowe
                                      #  can't use it as a base register
3:      testq    $2,%r8               #
jz4
        movw     8(%rax),%si          # copy.ext
        movw     %si,8(%rcx)
        addq     $2,
4:      testq    $1,%8                 fortrailingbyte
        jz       5f
        movb     -1(%rdi,%r8,1),%al   # copy trailing byte        .  SpinPause,function
%al,8(rcx)
5:      ret
        .p2align 4,,        ret
6:     movq-24(%ax,%rdx,8)%rsi
        movq     %rsi,-24(%rcx,%rdx,8)
        movq     -16(%rax%rdx,8)%rsi
        movq     %rsi,-16(%rcx,%rdx,8)
        movq     -8(%rax,%rdx,8),%       #                                               size_t count)
        movq%rsi-8(rcxrdx8)
        movq     (%rax,
        movq     %rsi(%cx,%dx8)
7:      addq#
        jle6b
         .type_Copy_arrayof_conjoint_bytes,@function
        jl       1b
        jmp      2b
acb_CopyLeft:
        testq    $1,%r8               # check_opy_arrayof_conjoint_bytes:
        jz       1f
        movb     -1(%rdi,%r8,1),%cl   # copy trailing byte
        movb     %cl,-1(%rsi,%r8,1)
        subq$,r8# adjust possible trailing word
1:      testq    $2,%r8               # check for trailing word
        jz       2f
        movw     -2(%rdi,%r8,1),%cx   # copy trailing word
        movw     %cx,-2(%rsi,%r8,1)
2:          $4,%r8# checkfor trailingdword
        jz       5f
        movl                   acb_CopyRight
        movl     %ecx,       jbeacb_CopyLeft
        jmp      5f
        .p2align 4,,15
3:      movq     -8(%rdi,%rdx,8        leaq     -(%,%rdx,8)%rax # from qcount*8-8
        movq%rcx-(%rsi%dx,8)
        subq     $1,%rdx
        jnz      3b
        ret
        .p2align 4,,15
4:      movq     24(%rdi,%rdx,8),%rcx
        movq     %rcx,24(%rsi,%       negq%rdx
        movq16(rdi,rdx8)rcx
        movq     %rcxp2align,15
        movq     8(%rdi,%rdx,8),%rcx
        movqrcx(rsirdx8java.lang.StringIndexOutOfBoundsException: Index 36 out of bounds for length 36
        movq     (%rdi,%rdx,8),%rcx
        movq     %,(%rsi,rdx,8)
5:      subqmovl     8(rax%esi           trailing dword
        jge4b
        addq     $4,%rdx
        jg       3b
        ret

        # Support for void Copy::arrayof_conjoint_jshorts(void* from        addq$,rax
        #                                                 void* to,
        #                                                 size_t count)
        # Equivalent to
        #   conjoint_jshorts_atomic
        #
        # If 'from' and/or 'to' are aligned on 4- or 2-byte boundaries, we
# let thehardwarehandleit   tow orfour wordswithin dwords
        # or qwords that span cache line boundaries will still be loaded
        # and stored atomically.
        #
rdi - from
        # rsimovw     8(rax,%          #copy word
        # rdx - count,             $2,rcx
        #
        .p2align 4,,15
 .type    _Copy_arrayof_conjoint_jshorts@unction
 .type    _Copy_conjoint_jshorts_atomic,@function
_Copy_arrayof_conjoint_jshorts:
_Copy_conjoint_jshorts_atomic:
        movq     %rdx,        jz5f
        shrq     $,%dx              #  count
        cmpq     %rdi,%rsi
             %al(rcx)
        jbe      acs_CopyRight
        cmpq     
opyLeft
acs_CopyRight:
6:           -24(rax,8,rsi
        leaq     -8(%rsi     %,-24%,%,8)
        negq     %rdx
      java.lang.StringIndexOutOfBoundsException: Index 19 out of bounds for length 19
1:      movq     8(%rax,%rdx,8),%rsi        movq     8(raxrdx,8)%rsi
        movq     %rsi,             (%rax,%rdx,8),%si
        addq     $1,%rdx
        jnzb
2:      testq    $2,%r8               # check for        jle6b
        jz       3f
        movl     8(%rax),%esi         # copy trailing dword        subq,rdx
        movl     %esi,8(%rcx        jmp      2b
addq     $,%rcx              #original%siis trashed, so we
                                      #  can't use it as a base register
3:      testq    $1,r8               #  for trailing word
        jz       4f
        movw     -2(%rdi,%r8,2),%si   # copy trailing word
        movw     %,8(%cx
4:      ret
        .p2align 4,,5
5:      movq     -24(             $1,%r8# adjust  possible trailingword
        movq1:testq    $2,%r8               # check for trailingword
        movq     -16(%rax,%rdx,8),%rsi
        movq%rsi,-16(%cx%rdx,8)
        movq                  %cx-(rsi%r8,1)
        movq%,-8(rcx,%rdx,8)
        movq     (%rax,%rdx,8),%rsi
        movqjz       f
6:      addq     $4,%rdx
        jle      5b
        subq     $4,%rdx
        jl       1b
        jmp2b
        movl     %ecx,(%rsi,%rdx,8)
        testq            jmp      5f
        jz       1f
        movw-(%,%rdx,8)%rcx
        movw     %cx-(%si,%r8,)
1:      testq    $2,%r8               # check for trailing dword
        jz       4f
        movl     (%rdi,%rdx
        movl%cx(rsi%dx8java.lang.StringIndexOutOfBoundsException: Index 35 out of bounds for length 35
              4f
2:      movq     -8(%rdi,%rdx,8),%rcx
        movq     %rcx,-8(%rsi,%rdx,8)
        subq     $1,%rdx
        jnz      2b
ret
        .p2align 4,,15
3:      movq     24(%rdimovq     %cx,16%rsi,rdx8)
        movq     %rcx,24(%rsi,%rdx,       movq     8%rdi,%rdx,8)%rcx
       movq     16%rdi,%rdx,8)%rcx
        movq     %cx16%rsi,%,8)
     8%,rdx8)%rcx
        movq     %rcx8(%rsi,%,8)
        movq     (%rdi,%rdx,8),%rcx
        movq     %rcx,(%rsi,%rdx,8)
4:      subq     $4,%rdx
        jge3b
        addq     $        #conjoint_jshorts_atomic
        jg       2b
        ret

        # Support for void Copy::arrayof_conjoint_jints(jint         let the hardware  it. The toworfour wordswithin dwords
        #                                               or  that cache line boundarieswill stillbe loaded
        #                                               size_tcount)
        # Equivalent to
        #   conjoint_jints_atomic
        #
        #If'from /or to are aligned  4byteboundaries we let
        # the hardware handle it.  The two dwords within qwords that span
        # cache line.p2align 4,,15
        #
        #  type_opy_conjoint_jshorts_atomicfunction
        #rsi -to
        # rdx - count, treated as ssize_t
        #
        .p2align        shrq     $2,%rdx              #qword count
 .type    _Copy_arrayof_conjoint_jints,@function
        leaq     -2(rdi%r8,2,%ax# from + wcount2 -2
_              acs_CopyRight
c:
                      acs_CopyLeft
        shrq     %rdx# qwordcount
        cmpq     %rdi,%rsi
        leaq     -4(rdi%r8,4),%rax  #  + dcount4  4
        jbe      aci_CopyRight
        cmpq     %rax,%rsi
        jbe      aci_CopyLeft 
aci_CopyRight:
        leaqjmp6f
        leaq:movq8(%rax,%rdx8),rsi
        negq     %        movq     %rsi8%rcx,%rdx,8)
        jmp      5f
        .p2align 4,,15
1:              addq     1,rdx
        movq     %rsi,8(%rcx,%rdx,8)
        addq     $1,%dx
        jnz       1b
2:      testq    $1,%r8jz3f
        jz       3f
        movlmovl     %esi,8%rcx)
        movl     %,8(%)
3:      ret
        p2align4,,5
4:      movq     -24(%rax,%rdx,8),%rsi
        3:      testq$1,r8               #check fortrailingjava.lang.StringIndexOutOfBoundsException: Index 63 out of bounds for length 63
        movq-16(rax%dx8,rsi
        movq     %rsi,-16(%rcx,%rdx,8)
        movq-(%rax%rdx,8)%rsi
        movq     %rsi,-8(%rcx,%rdx,8)
        movq     (%rax,%dx8),%rsi
        movq     %rsi,(%rcx,%rdx.p2align 4,15
5:      addq     $4,%rdx
        jle      4b
        subq     $4,%rdx
        jl       1b
        jmp      2b
aci_CopyLeft:
testq$1%r8               #check for trailing dword
               3f
                movq%rsi-(rcx%rdx,8)
        movl     %cx-4(%rsi%r8,)
        jmp             %rsi(%cx,%rdx,8
1:           -8(rdi%rdx8)%rcx
        movq     %rcx,-8(%rsijle5b
        subq$,%dx
        jnz      1b
        ret
        .p2align 4,,15
2:      movq     24(%rdi,%rdx,8),%              2b
        movq     %rcx,24(%rsi,%rdx,8)
        movq             -2(rdi%82)%   # copy trailing
        movq     %rcx,16(%rsi,%rdx:         $2%               #  fortrailing dword
        movq%rdi,rdx8)%   # copy trailingdword
             %rcx8(%,%rdx,8)
        movq     (%rdi,%rdx,8),%rcx
        movq     %rcx,(%rsi,%rdx,8)
3:      subq     $4,%rdx
        jge      2b
        addq     $4,%rdx
1b
        ret

        # Support for void Copy::arrayof_conjoint_jlongs(jlong* from,
                                                        ,
        #                                                size_t.p2align 4,15
        # Equivalent to
           conjoint_jlongs_atomic
        #   arrayof_conjoint_oops
        #   conjoint_oops_atomic
        #
        # rdi - from
        # rsi - to
        # rdx - count, treated as ssize_t
        #
        .p2align 4,,15
 .type    _Copy_arrayof_conjoint_jlongs,@function
 .type    _Copy_conjoint_jlongs_atomic,@function
_Copy_arrayof_conjoint_jlongs:
_Copy_conjoint_jlongs_atomic:
        cmpq     %rdi,%rsi
        leaq     -8(%rdi,%rdx             8(%rdi%,8),%rcx
        jbe      acl_CopyRight
        cmpq     %rax,%rsi
        jbeacl_CopyLeft
acl_CopyRight:
        leaq-(%rsi,%rdx,8),rcx # to + count* - 8
        negq     %rdx
        jmp      3f
1:      movq     8(%rax,%rdx,8),%rsi
        movq     %rsi,8(%rcx,%rdx,8)
        addq$,%rdx
        jnz      1b
        ret
        .p2align 4,,15
:      movq     -4(raxrdx8)%rsi
             %rsi-24(%rcx%dx,8)
        movq-6(%rax,%rdx8)%
        movqrsi16%rcx,%rdx,8)
        movq     -8(%rax,%rdx,),rsi
        movq     %rsi,-8(%rcx,%rdx,8)
        movq     (        #                                              count)
        movq     %rsi,(%#
3:addq,rdx
        jle      2b
     $%
        jl       1b
        ret
4:      movq     -8(%rdi,%rdx,8),%rcx
movq     rcx8(,%rdx8)
        subq     $1,%rdx
        jnz      4b
        ret
        .p2align 4,,15
5        #
        movq     %rcx,24(%rsi,%rdx,8)
        movq     16(%rdi,%rdx,8),%rcx
             %rcx16(%rsi%,8)
        movq     8((%rdi,%rdx8)%rcx
        movq     %rcx,Copy_arrayof_conjoint_jints
        movq     (%,%rdx8))%rcx
        movq     %rcx(rsi%rdx,8)
Left:
        subq$4,%rdx
        jge      5b
java.lang.StringIndexOutOfBoundsException: Range [28, 24) out of bounds for length 24
        jg4b
        ret