[BACK]Return to bcopy.m4 CVS log [TXT][DIR] Up to [local] / sys / lib / libkern / arch / hppa64

Annotation of sys/lib/libkern/arch/hppa64/bcopy.m4, Revision 1.1.1.1

1.1       nbrk        1: define(_rcsid,``$OpenBSD: bcopy.m4,v 1.2 2005/08/01 12:10:26 miod Exp $'')dnl
                      2: dnl
                      3: dnl
                      4: dnl  This is the source file for bcopy.S, spcopy.S
                      5: dnl
                      6: dnl
                      7: define(`versionmacro',substr(_rcsid,1,eval(len(_rcsid)-2)))dnl
                      8: dnl
                      9: /* This is a generated file. DO NOT EDIT. */
                     10: /*
                     11:  * Generated from:
                     12:  *
                     13:  *     versionmacro
                     14:  */
                     15: /*
                     16:  * Copyright (c) 1999,2004 Michael Shalayeff
                     17:  * All rights reserved.
                     18:  *
                     19:  * Permission to use, copy, modify, and distribute this software for any
                     20:  * purpose with or without fee is hereby granted, provided that the above
                     21:  * copyright notice and this permission notice appear in all copies.
                     22:  *
                     23:  * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
                     24:  * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
                     25:  * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
                     26:  * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
                     27:  * WHATSOEVER RESULTING FROM LOSS OF MIND, USE, DATA OR PROFITS, WHETHER IN
                     28:  * AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT
                     29:  * OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
                     30:  */
                     31: dnl
                     32: dnl    macro: L(`%arg1',`%arg2')
                     33: dnl synopsis: creates an assembly label based on args resulting in $%arg1.%arg2
                     34: dnl
                     35: define(`L', `$$1.$2')dnl
                     36: dnl
                     37: dnl
                     38: dnl
                     39: define(`STWS',`ifelse($5, `u',dnl
                     40: `ifelse($1, `1', `vshd $4, %r`$1', %r31
                     41:        stbys,B,m %r31, F`'4($2, $3)',
                     42: `0', `0', `vshd        %r`'decr($1), %r`$1', %r31
                     43:        stws,M  %r31, F`'4($2, $3)')',dnl
                     44: `0', `0',
                     45: `ifelse($1, `1',
                     46: `stbys,B`'ifelse(B, `b', `,m ', `0', `0', `    ')`'%r`$1', F`'4($2, $3)',
                     47: `0', `0', `stws,M      %r`$1', F`'4($2, $3)')')')dnl
                     48: define(`STWSS', `ifelse(`$3', `19', `dnl',
                     49: `0', `0', `STWSS($1, $2, eval($3 - 1), $4, $5)')
                     50:        STWS($3, $1, $2, $4, $5)dnl
                     51: ')dnl
                     52: define(`LDWSS', `ifelse(`$3', `19', `dnl',
                     53: `0', `0', `LDWSS($1, $2, eval($3 - 1))')
                     54:        ldws,M  F`'4($1, $2), %r`'$3`'dnl
                     55: ')dnl
                     56: dnl
                     57: dnl copy data in 4-words blocks
                     58: dnl
                     59: define(`hppa_blcopy',`
                     60:        addi    -16, $6, $6
                     61: L($1, `loop16'`$7')
                     62:        ldw     F 32($2, $3), %r0
                     63: ifelse(F, `-', `dnl
                     64:        addi    F`'4, $5, $5', `0', `0', `dnl')
                     65: LDWSS($2, $3, 22)
                     66: STWSS($4, $5, 21, `%ret1', $7)
                     67: ifelse($7, `u', `dnl
                     68:        STWS(4, $4, $5, `%ret1', $7)', $7, `a', `dnl')
                     69:        addib,>= -16, $6, L($1, `loop16'`$7')
                     70: ifelse($7, `a', `dnl
                     71:        STWS(4, $4, $5, `%ret1', $7)dnl
                     72: ', $7, `u', `dnl
                     73:        copy    %r19, %ret1')')dnl
                     74: dnl
                     75: dnl copy in words
                     76: dnl
                     77: define(`STWL', `addib,<,n 12, $6, L($1, cleanup)
                     78: ifelse($7, `u', `      copy    %ret1, %r22', $7, `a', `dnl')
                     79: L($1, word)
                     80:        ldws,M  F`'4($2, $3), %r22
                     81:        addib,>= -4, $6, L($1, word)
                     82:        stws,M  %r22, F`'4($4, $5)
                     83:
                     84: L($1, cleanup)
                     85:        addib,=,n 4, $6, L($1, done)
                     86:        ldws    0($2, $3), %r22
                     87:        add     $5, $6, $5
                     88:        b       L($1, done)
                     89:        stbys,E %r22, 0($4, $5)
                     90: ')
                     91: dnl
                     92: dnl
                     93: dnl parameters:
                     94: dnl  $1        name
                     95: dnl  $2        source space
                     96: dnl  $3        source address
                     97: dnl  $4        destination space
                     98: dnl  $5        destination address
                     99: dnl  $6        length
                    100: dnl  $7        direction
                    101: dnl
                    102: define(hppa_copy,
                    103: `dnl
                    104: dnl
                    105: dnl    if direction is `-' (backwards copy), adjust src, dst
                    106: dnl
                    107: ifelse($7,`-', `add    $3, $6, $3
                    108:        add     $5, $6, $5
                    109: define(`F', `-')dnl
                    110: define(`R', `')dnl
                    111: define(`M', `mb')dnl
                    112: define(`B', `e')dnl
                    113: define(`E', `b')dnl
                    114: ',dnl ifelse
                    115: `0',`0',
                    116: `define(`F', `')dnl
                    117: define(`R', `-')dnl
                    118: define(`M', `ma')dnl
                    119: define(`B', `b')dnl
                    120: define(`E', `e')dnl
                    121: ')dnl ifelse
                    122:
                    123: ifelse($7,`-', `', `0',`0',
                    124: `      comib,>=,n 15, $6, L($1, byte)
                    125:
                    126:        extru   $3, 31, 2, %r20
                    127:        extru   $5, 31, 2, %r19
                    128:        add     $6, %r19, $6
                    129:        comb,<> %r20, %r19, L($1, unaligned)
                    130:        dep     %r0, 31, 2, $3
                    131:        hppa_blcopy($1, $2, $3, $4, $5, $6, `a')
                    132:
                    133:        STWL($1, $2, $3, $4, $5, $6, `a')dnl
                    134:
                    135: L($1, unaligned)
                    136:        sub,>=  %r19, %r20, %r21
                    137:        ldwm    F`'4($2, $3), %ret1
                    138:        zdep    %r21, 28, 29, %r22
                    139:        mtsar   %r22
                    140:        hppa_blcopy($1, $2, $3, $4, $5, $6, `u')
                    141:
                    142: dnl    STWL($1, $2, $3, $4, $5, $6, `u')
                    143:        addib,<,n 12, $6, L($1, cleanup_un)
                    144: L($1, word_un)
                    145:        ldws,M  F`'4($2, $3), %r22
                    146:        vshd    %ret1, %r22, %r21
                    147:        addib,< -4, $6, L($1, cleanup1_un)
                    148:        stws,M  %r21, F`'4($4, $5)
                    149:        ldws,M  F`'4($2, $3), %ret1
                    150:        vshd    %r22, %ret1, %r21
                    151:        addib,>= -4, $6, L($1, word_un)
                    152:        stws,M  %r21, F`'4($4, $5)
                    153:
                    154: L($1, cleanup_un)
                    155:        addib,<=,n 4, $6, L($1, done)
                    156:        mfctl   %sar, %r19
                    157:        add     $5, $6, $5
                    158:        extru   %r19, 28, 2, %r19
                    159:        sub,<=  $6, %r19, %r0
                    160:        ldws,M  F`'4($2, $3), %r22
                    161:        vshd    %ret1, %r22, %r21
                    162:        b       L($1, done)
                    163:        stbys,E %r21, 0($4, $5)
                    164:
                    165: L($1, cleanup1_un)
                    166:        b       L($1, cleanup_un)
                    167:        copy    %r22, %ret1
                    168: ')dnl ifelse
                    169:
                    170: L($1, byte)
                    171:        comb,>=,n %r0, $6, L($1, done)
                    172: L($1, byte_loop)
                    173:        ldbs,M  F`'1($2, $3), %r22
                    174:        addib,<> -1, $6, L($1, byte_loop)
                    175:        stbs,M  %r22, F`'1($4, $5)
                    176: L($1, done)
                    177: ')dnl
                    178: `
                    179: #undef _LOCORE
                    180: #define _LOCORE
                    181: #include <machine/asm.h>
                    182: #include <machine/frame.h>
                    183: '
                    184: ifelse(NAME, `bcopy',
                    185: `
                    186: #if defined(LIBC_SCCS)
                    187:        .text
                    188:        .asciz "versionmacro"
                    189:        .align  4
                    190: #endif
                    191:
                    192: LEAF_ENTRY(memcpy)
                    193: ALTENTRY(memmove)
                    194:        copy    %arg0, %r22
                    195:        copy    %arg1, %arg0
                    196:        copy    %r22, %arg1
                    197:        copy    %arg0, %ret0
                    198: ALTENTRY(ovbcopy)
                    199: ALTENTRY(bcopy)
                    200:        comb,>,n %arg1, %arg0, L(bcopy, reverse)
                    201:        hppa_copy(bcopy_f, %sr0, %arg0, %sr0, %arg1, %arg2, `+')
                    202:        bv      %r0(%rp)
                    203:        nop
                    204: L(bcopy, reverse)
                    205:        hppa_copy(bcopy_r, %sr0, %arg0, %sr0, %arg1, %arg2, `-')
                    206:        bv      %r0(%rp)
                    207:        nop
                    208: EXIT(memcpy)
                    209: ')dnl
                    210: dnl
                    211: ifelse(NAME, `spcopy',
                    212: `
                    213: #ifdef _KERNEL
                    214: #include <assym.h>
                    215:
                    216: /*
                    217:  * int spcopy (pa_space_t ssp, const void *src, pa_space_t dsp, void *dst,
                    218:  *              size_t size)
                    219:  * do a space to space bcopy.
                    220:  *
                    221:  * assumes that spaces do not clash, otherwise we lose
                    222:  */
                    223:        .import copy_on_fault, code
                    224: LEAF_ENTRY(spcopy)
                    225:        sub,<>  %r0, arg4, %r0
                    226:        bv      %r0(%rp)
                    227:        nop
                    228: `
                    229:        std     %rp, HPPA_FRAME_RP(%sp)
                    230:        ldo     HPPA_FRAME_SIZE(%sp), %sp
                    231:        /* setup fault handler */
                    232:        mfctl   %cr24, %arg1
                    233:        ldd     CI_CURPROC(%arg1), %r1
                    234:        ldil    L%copy_on_fault, %r21
                    235:        ldd     P_ADDR(%r20), %r2
                    236:        ldo     R%copy_on_fault(%r21), %r21
                    237:        ldd     PCB_ONFAULT+U_PCB(%r2), %r1
                    238:        std     %r21, PCB_ONFAULT+U_PCB(%r2)
                    239: '
                    240:        mtsp    %arg0, %sr1
                    241:        mtsp    %arg2, %sr2
                    242:
                    243:        copy    arg4, %ret0
                    244:        hppa_copy(spcopy, %sr1, %arg1, %sr2, %arg3, %ret0, `+')
                    245:
                    246:        mtsp    %r0, %sr1
                    247:        mtsp    %r0, %sr2
                    248:        /* reset fault handler */
                    249:        std     %r1, PCB_ONFAULT+U_PCB(%r2)
                    250:        ldo     -HPPA_FRAME_SIZE(%sp), %sp
                    251:        ldd     HPPA_FRAME_RP(%sp), %rp
                    252:        bv      %r0(%rp)
                    253:        copy    %r0, %ret0
                    254: EXIT(spcopy)
                    255: #endif
                    256: ')dnl
                    257:
                    258:        .end

CVSweb