VirtualBox

Ignore:
Timestamp:
Oct 28, 2018 5:00:27 PM (6 years ago)
Author:
vboxsync
Message:

IPRT: Make Watcom C an alterntive for compiling the OS/2 kernel code (GA mainly), governed by VBOX_USE_WATCOM_FOR_OS2.

Location:
trunk/src/VBox/Runtime/common/string/watcom
Files:
1 added
14 copied

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Runtime/common/string/watcom/bzero.asm

    r75123 r75129  
    11; $Id$
    22;; @file
    3 ; IPRT - No-CRT bzero - AMD64 & X86.
     3; IPRT - No-CRT bzero - Watcom register calling convention.
    44;
    55
    … …  
    2727%include "iprt/asmdefs.mac"
    2828
    29 BEGINCODE
     29%define ASM_CALL32_WATCOM
     30%define NAME(name) name %+ _
     31%include "common/string/bzero.asm"
    3032
    31 ;;
    32 ; @param    pvDst   gcc: rdi  msc: rcx  x86:[esp+4]
    33 ; @param    cb      gcc: rsi  msc: rdx  x86:[esp+8]
    34 RT_NOCRT_BEGINPROC bzero
    35 %ifdef RT_OS_DARWIN
    36 GLOBALNAME __bzero
    37 %endif
    38         cld
    39 %ifdef RT_ARCH_AMD64
    40         xor     eax, eax
    41  %ifdef ASM_CALL64_MSC
    42         mov     r9, rdi                 ; save rdi in r9
    43         mov     rdi, rcx
    44 
    45         ; todo: alignment?
    46         mov     rcx, rdx
    47         shr     rcx, 3
    48         rep stosq
    49 
    50         and     rdx, 7
    51         mov     rcx, rdx
    52         rep stosb
    53 
    54         mov     rdi, r9                 ; restore rdi
    55 
    56  %else ; GCC
    57         ; todo: alignment?
    58         mov     rcx, rsi
    59         shr     rcx, 3
    60         rep stosq
    61 
    62         and     rsi, 7
    63         mov     rcx, rsi
    64         rep stosb
    65 
    66  %endif ; GCC
    67 
    68 %elif ARCH_BITS == 32
    69         push    ebp
    70         mov     ebp, esp
    71         push    edi
    72 
    73         mov     ecx, [ebp + 0ch]
    74         mov     edi, [ebp + 08h]
    75         xor     eax, eax
    76 
    77         mov     edx, ecx
    78         shr     ecx, 2
    79         rep stosd
    80 
    81         and     edx, 3
    82         mov     ecx, edx
    83         rep stosb
    84 
    85         pop     edi
    86         leave
    87 
    88 %elif ARCH_BITS == 16
    89         push    bp
    90         mov     bp, sp
    91         push    di
    92 
    93         mov     cx, [bp + 0ch]
    94         mov     di, [bp + 08h]
    95         xor     ax, ax
    96 
    97         ; align di.
    98         test    di, 1
    99         jz      .aligned
    100         jcxz    .done
    101         stosb
    102         dec     cx
    103         jz      .done
    104 
    105 .aligned:
    106         mov     dx, cx
    107         shr     cx, 1
    108         rep stosw
    109 
    110         test    dl, 1
    111         jz      .done
    112         stosb
    113 
    114 .done:
    115         pop     di
    116         pop     bp
    117 %else
    118  %error ARCH_BITS
    119 %endif ; X86
    120         ret
    121 ENDPROC RT_NOCRT(bzero)
    122 

  • trunk/src/VBox/Runtime/common/string/watcom/memchr.asm

    r75123 r75129  
    11; $Id$
    22;; @file
    3 ; IPRT - No-CRT memchr - AMD64 & X86.
     3; IPRT - No-CRT memchr - Watcom register calling convention.
    44;
    55
    … …  
    2727%include "iprt/asmdefs.mac"
    2828
    29 BEGINCODE
     29%define ASM_CALL32_WATCOM
     30%define NAME(name) name %+ _
     31%include "common/string/memchr.asm"
    3032
    31 ;;
    32 ; @param    pv      gcc: rdi  msc: ecx  x86:[esp+4]
    33 ; @param    ch      gcc: esi  msc: edx  x86:[esp+8]
    34 ; @param    cb      gcc: rdx  msc: r8   x86:[esp+0ch]
    35 RT_NOCRT_BEGINPROC memchr
    36         cld
    37 %ifdef RT_ARCH_AMD64
    38  %ifdef ASM_CALL64_MSC
    39         or      r8, r8
    40         jz      .not_found_early
    41 
    42         mov     r9, rdi                 ; save rdi
    43         mov     eax, edx
    44         mov     rdi, rcx
    45         mov     rcx, r8
    46  %else
    47         mov     rcx, rdx
    48         jrcxz   .not_found_early
    49 
    50         mov     eax, esi
    51  %endif
    52 
    53 %else
    54         mov     ecx, [esp + 0ch]
    55         jecxz   .not_found_early
    56         mov     edx, edi                ; save edi
    57         mov     eax, [esp + 8]
    58         mov     edi, [esp + 4]
    59 %endif
    60 
    61         ; do the search
    62         repne   scasb
    63         jne     .not_found
    64 
    65         ; found it
    66         lea     xAX, [xDI - 1]
    67 %ifdef ASM_CALL64_MSC
    68         mov     rdi, r9
    69 %endif
    70 %ifdef RT_ARCH_X86
    71         mov     edi, edx
    72 %endif
    73         ret
    74 
    75 .not_found:
    76 %ifdef ASM_CALL64_MSC
    77         mov     rdi, r9
    78 %endif
    79 %ifdef RT_ARCH_X86
    80         mov     edi, edx
    81 %endif
    82 .not_found_early:
    83         xor     eax, eax
    84         ret
    85 ENDPROC RT_NOCRT(memchr)
    86 

  • trunk/src/VBox/Runtime/common/string/watcom/memcmp.asm

    r75123 r75129  
    11; $Id$
    22;; @file
    3 ; IPRT - No-CRT memcmp - AMD64 & X86.
     3; IPRT - No-CRT memcmp - Watcom register calling convention.
    44;
    55
    … …  
    2727%include "iprt/asmdefs.mac"
    2828
    29 BEGINCODE
     29%define ASM_CALL32_WATCOM
     30%define NAME(name) name %+ _
     31%include "common/string/memcmp.asm"
    3032
    31 ;;
    32 ; @param    pv1     gcc: rdi  msc: rcx  x86:[esp+4]
    33 ; @param    pv2     gcc: rsi  msc: rdx  x86:[esp+8]
    34 ; @param    cb      gcc: rdx  msc: r8   x86:[esp+0ch]
    35 RT_NOCRT_BEGINPROC memcmp
    36         cld
    37         xor     eax, eax
    38 
    39         ; Do the bulk of the work.
    40 %ifdef RT_ARCH_AMD64
    41  %ifdef ASM_CALL64_MSC
    42         mov     r10, rdi                ; save
    43         mov     r11, rsi                ; save
    44         mov     rdi, rcx
    45         mov     rsi, rdx
    46         mov     rcx, r8
    47         mov     rdx, r8
    48  %else
    49         mov     rcx, rdx
    50  %endif
    51         shr     rcx, 3
    52         repe cmpsq
    53         jne     .not_equal_qword
    54 %else
    55         push    edi
    56         push    esi
    57 
    58         mov     ecx, [esp + 0ch + 8]
    59         mov     edi, [esp + 04h + 8]
    60         mov     esi, [esp + 08h + 8]
    61         mov     edx, ecx
    62         jecxz   .done
    63         shr     ecx, 2
    64         repe cmpsd
    65         jne     .not_equal_dword
    66 %endif
    67 
    68         ; The remaining bytes.
    69 %ifdef RT_ARCH_AMD64
    70         test    dl, 4
    71         jz      .dont_cmp_dword
    72         cmpsd
    73         jne     .not_equal_dword
    74 %endif
    75 .dont_cmp_dword:
    76         test    dl, 2
    77         jz      .dont_cmp_word
    78         cmpsw
    79         jne     .not_equal_word
    80 .dont_cmp_word:
    81         test    dl, 1
    82         jz      .dont_cmp_byte
    83         cmpsb
    84         jne     .not_equal_byte
    85 .dont_cmp_byte:
    86 
    87 .done:
    88 %ifdef RT_ARCH_AMD64
    89  %ifdef ASM_CALL64_MSC
    90         mov     rdi, r10
    91         mov     rsi, r11
    92  %endif
    93 %else
    94         pop     esi
    95         pop     edi
    96 %endif
    97         ret
    98 
    99 ;
    100 ; Mismatches.
    101 ;
    102 %ifdef RT_ARCH_AMD64
    103 .not_equal_qword:
    104         mov     ecx, 8
    105         sub     rsi, 8
    106         sub     rdi, 8
    107         repe cmpsb
    108 .not_equal_byte:
    109         mov     al, [xDI-1]
    110         movzx   ecx, byte [xSI-1]
    111         sub     eax, ecx
    112         jmp     .done
    113 %endif
    114 
    115 .not_equal_dword:
    116         mov     ecx, 4
    117         sub     xSI, 4
    118         sub     xDI, 4
    119         repe cmpsb
    120 %ifdef RT_ARCH_AMD64
    121         jmp     .not_equal_byte
    122 %else
    123 .not_equal_byte:
    124         mov     al, [xDI-1]
    125         movzx   ecx, byte [xSI-1]
    126         sub     eax, ecx
    127         jmp     .done
    128 %endif
    129 
    130 .not_equal_word:
    131         mov     ecx, 2
    132         sub     xSI, 2
    133         sub     xDI, 2
    134         repe cmpsb
    135         jmp     .not_equal_byte
    136 ENDPROC RT_NOCRT(memcmp)
    137 

  • trunk/src/VBox/Runtime/common/string/watcom/memcpy.asm

    r75123 r75129  
    11; $Id$
    22;; @file
    3 ; IPRT - No-CRT memcpy - AMD64 & X86.
     3; IPRT - No-CRT memcpy - Watcom register calling convention.
    44;
    55
    … …  
    2727%include "iprt/asmdefs.mac"
    2828
    29 BEGINCODE
     29%define ASM_CALL32_WATCOM
     30%define NAME(name) name %+ _
     31%include "common/string/memcpy.asm"
    3032
    31 ;;
    32 ; @param    pvDst   gcc: rdi  msc: rcx  x86:[esp+4]
    33 ; @param    pvSrc   gcc: rsi  msc: rdx  x86:[esp+8]
    34 ; @param    cb      gcc: rdx  msc: r8   x86:[esp+0ch]
    35 RT_NOCRT_BEGINPROC memcpy
    36         cld
    37 
    38         ; Do the bulk of the work.
    39 %ifdef RT_ARCH_AMD64
    40  %ifdef ASM_CALL64_MSC
    41         mov     r10, rdi                ; save
    42         mov     r11, rsi                ; save
    43         mov     rdi, rcx
    44         mov     rsi, rdx
    45         mov     rcx, r8
    46         mov     rdx, r8
    47  %else
    48         mov     rcx, rdx
    49  %endif
    50         mov     rax, rdi                ; save the return value
    51         shr     rcx, 3
    52         rep movsq
    53 %else
    54         push    edi
    55         push    esi
    56 
    57         mov     ecx, [esp + 0ch + 8]
    58         mov     edi, [esp + 04h + 8]
    59         mov     esi, [esp + 08h + 8]
    60         mov     edx, ecx
    61         mov     eax, edi                ; save the return value
    62         shr     ecx, 2
    63         rep movsd
    64 %endif
    65 
    66         ; The remaining bytes.
    67 %ifdef RT_ARCH_AMD64
    68         test    dl, 4
    69         jz      .dont_move_dword
    70         movsd
    71 %endif
    72 .dont_move_dword:
    73         test    dl, 2
    74         jz      .dont_move_word
    75         movsw
    76 .dont_move_word:
    77         test    dl, 1
    78         jz      .dont_move_byte
    79         movsb
    80 .dont_move_byte:
    81 
    82 %ifdef RT_ARCH_AMD64
    83  %ifdef ASM_CALL64_MSC
    84         mov     rdi, r10
    85         mov     rsi, r11
    86  %endif
    87 %else
    88         pop     esi
    89         pop     edi
    90 %endif
    91         ret
    92 ENDPROC RT_NOCRT(memcpy)
    93 

  • trunk/src/VBox/Runtime/common/string/watcom/memmove.asm

    r75123 r75129  
    11; $Id$
    22;; @file
    3 ; IPRT - No-CRT memmove - AMD64 & X86.
     3; IPRT - No-CRT memmove - Watcom register calling convention.
    44;
    55
    … …  
    2727%include "iprt/asmdefs.mac"
    2828
    29 BEGINCODE
     29%define ASM_CALL32_WATCOM
     30%define NAME(name) name %+ _
     31%include "common/string/memmove.asm"
    3032
    31 ;;
    32 ; @param    pvDst   gcc: rdi  msc: rcx  x86:[esp+4]
    33 ; @param    pvSrc   gcc: rsi  msc: rdx  x86:[esp+8]
    34 ; @param    cb      gcc: rdx  msc: r8   x86:[esp+0ch]
    35 RT_NOCRT_BEGINPROC memmove
    36         ; Prolog.
    37 %ifdef RT_ARCH_AMD64
    38  %ifdef ASM_CALL64_MSC
    39         mov     r10, rdi                ; save
    40         mov     r11, rsi                ; save
    41         mov     rdi, rcx
    42         mov     rsi, rdx
    43         mov     rcx, r8
    44         mov     rdx, r8
    45  %else
    46         mov     rcx, rdx
    47  %endif
    48         mov     rax, rdi                ; save the return value
    49 %else
    50         push    edi
    51         push    esi
    52         mov     edi, [esp + 04h + 8]
    53         mov     esi, [esp + 08h + 8]
    54         mov     ecx, [esp + 0ch + 8]
    55         mov     edx, ecx
    56         mov     eax, edi                ; save the return value
    57 %endif
    58 
    59         ;
    60         ; Decide which direction to perform the copy in.
    61         ;
    62 %if 1 ; keep it simple for now.
    63         cmp     xDI, xSI
    64         jnb     .backward
    65 
    66         ;
    67         ; Slow/simple forward copy.
    68         ;
    69         cld
    70         rep movsb
    71         jmp .epilog
    72 
    73 %else ; disabled - it seems to work, but play safe for now.
    74         ;sub     xAX, xSI
    75         ;jnb     .backward
    76         cmp     xDI, xSI
    77         jnb     .backward
    78 
    79         ;
    80         ; Fast forward copy.
    81         ;
    82 .fast_forward:
    83         cld
    84 %ifdef RT_ARCH_AMD64
    85         shr     rcx, 3
    86         rep movsq
    87 %else
    88         shr     ecx, 2
    89         rep movsd
    90 %endif
    91 
    92         ; The remaining bytes.
    93 %ifdef RT_ARCH_AMD64
    94         test    dl, 4
    95         jz      .forward_dont_move_dword
    96         movsd
    97 %endif
    98 .forward_dont_move_dword:
    99         test    dl, 2
    100         jz      .forward_dont_move_word
    101         movsw
    102 .forward_dont_move_word:
    103         test    dl, 1
    104         jz      .forward_dont_move_byte
    105         movsb
    106 .forward_dont_move_byte:
    107 
    108 %endif ; disabled
    109 
    110         ;
    111         ; The epilog.
    112         ;
    113 .epilog:
    114 %ifdef RT_ARCH_AMD64
    115  %ifdef ASM_CALL64_MSC
    116         mov     rdi, r10
    117         mov     rsi, r11
    118  %endif
    119 %else
    120         pop     esi
    121         pop     edi
    122 %endif
    123         ret
    124 
    125         ;
    126         ; Slow/simple backward copy.
    127         ;
    128 ALIGNCODE(16)
    129 .backward:
    130         ;; @todo check if they overlap.
    131         lea     xDI, [xDI + xCX - 1]
    132         lea     xSI, [xSI + xCX - 1]
    133         std
    134         rep movsb
    135         cld
    136         jmp .epilog
    137 ENDPROC RT_NOCRT(memmove)
    138 

  • trunk/src/VBox/Runtime/common/string/watcom/mempcpy.asm

    r75123 r75129  
    11; $Id$
    22;; @file
    3 ; IPRT - No-CRT mempcpy - AMD64 & X86.
     3; IPRT - No-CRT mempcpy - Watcom register calling convention.
    44;
    55
    … …  
    2727%include "iprt/asmdefs.mac"
    2828
    29 BEGINCODE
     29%define ASM_CALL32_WATCOM
     30%define NAME(name) name %+ _
     31%include "common/string/mempcpy.asm"
    3032
    31 ;;
    32 ; @param    pvDst   gcc: rdi  msc: rcx  x86:[esp+4]
    33 ; @param    pvSrc   gcc: rsi  msc: rdx  x86:[esp+8]
    34 ; @param    cb      gcc: rdx  msc: r8   x86:[esp+0ch]
    35 RT_NOCRT_BEGINPROC mempcpy
    36         cld                             ; paranoia
    37 
    38         ; Do the bulk of the work.
    39 %ifdef RT_ARCH_AMD64
    40  %ifdef ASM_CALL64_MSC
    41         mov     r10, rdi                ; save
    42         mov     r11, rsi                ; save
    43         mov     rdi, rcx
    44         mov     rsi, rdx
    45         mov     rcx, r8
    46         mov     rdx, r8
    47  %else
    48         mov     rcx, rdx
    49  %endif
    50         shr     rcx, 3
    51         rep movsq
    52 %else
    53         mov     eax, edi                ; saving edi in eax
    54         push    esi
    55 
    56         mov     ecx, [esp + 0ch + 4]
    57         mov     edi, [esp + 04h + 4]
    58         mov     esi, [esp + 08h + 4]
    59         mov     edx, ecx
    60         shr     ecx, 2
    61         rep movsd
    62 %endif
    63 
    64         ; The remaining bytes.
    65 %ifdef RT_ARCH_AMD64
    66         test    dl, 4
    67         jz      .dont_move_dword
    68         movsd
    69 %endif
    70 .dont_move_dword:
    71         test    dl, 2
    72         jz      .dont_move_word
    73         movsw
    74 .dont_move_word:
    75         test    dl, 1
    76         jz      .dont_move_byte
    77         movsb
    78 .dont_move_byte:
    79 
    80         ; restore & return
    81 %ifdef RT_ARCH_AMD64
    82         mov     rax, rdi
    83  %ifdef ASM_CALL64_MSC
    84         mov     rsi, r11
    85         mov     rdi, r10
    86  %endif
    87 %else
    88         pop     esi
    89         xchg    eax, edi
    90 %endif
    91         ret
    92 ENDPROC RT_NOCRT(mempcpy)
    93 

  • trunk/src/VBox/Runtime/common/string/watcom/memrchr.asm

    r75123 r75129  
    11; $Id$
    22;; @file
    3 ; IPRT - No-CRT memrchr - AMD64 & X86.
     3; IPRT - No-CRT memrchr - Watcom register calling convention.
    44;
    55
    … …  
    2727%include "iprt/asmdefs.mac"
    2828
    29 BEGINCODE
     29%define ASM_CALL32_WATCOM
     30%define NAME(name) name %+ _
     31%include "common/string/memrchr.asm"
    3032
    31 ;;
    32 ; @param    pv      gcc: rdi  msc: ecx  x86:[esp+4]
    33 ; @param    ch      gcc: esi  msc: edx  x86:[esp+8]
    34 ; @param    cb      gcc: rdx  msc: r8   x86:[esp+0ch]
    35 RT_NOCRT_BEGINPROC memrchr
    36         std
    37 %ifdef RT_ARCH_AMD64
    38  %ifdef ASM_CALL64_MSC
    39         or      r8, r8
    40         jz      .not_found_early
    41 
    42         mov     r9, rdi                 ; save rdi
    43         mov     eax, edx
    44         lea     rdi, [rcx + r8 - 1]
    45         mov     rcx, r8
    46  %else
    47         mov     rcx, rdx
    48         jrcxz   .not_found_early
    49 
    50         mov     eax, esi
    51         lea     rdi, [rdi + rcx - 1]
    52  %endif
    53 
    54 %else
    55         mov     ecx, [esp + 0ch]
    56         jecxz   .not_found_early
    57         mov     edx, edi                ; save edi
    58         mov     eax, [esp + 8]
    59         mov     edi, [esp + 4]
    60         lea     edi, [edi + ecx - 1]
    61 %endif
    62 
    63         ; do the search
    64         repne   scasb
    65         jne     .not_found
    66 
    67         ; found it
    68         lea     xAX, [xDI + 1]
    69 %ifdef ASM_CALL64_MSC
    70         mov     rdi, r9
    71 %endif
    72 %ifdef RT_ARCH_X86
    73         mov     edi, edx
    74 %endif
    75         cld
    76         ret
    77 
    78 .not_found:
    79 %ifdef ASM_CALL64_MSC
    80         mov     rdi, r9
    81 %endif
    82 %ifdef RT_ARCH_X86
    83         mov     edi, edx
    84 %endif
    85 .not_found_early:
    86         xor     eax, eax
    87         cld
    88         ret
    89 ENDPROC RT_NOCRT(memrchr)
    90 

  • trunk/src/VBox/Runtime/common/string/watcom/memset.asm

    r75123 r75129  
    11; $Id$
    22;; @file
    3 ; IPRT - No-CRT memset - AMD64 & X86.
     3; IPRT - No-CRT memset - Watcom register calling convention.
    44;
    55
    … …  
    2727%include "iprt/asmdefs.mac"
    2828
    29 BEGINCODE
     29%define ASM_CALL32_WATCOM
     30%define NAME(name) name %+ _
     31%include "common/string/memset.asm"
    3032
    31 ;;
    32 ; @param    pvDst   gcc: rdi  msc: ecx  x86:[esp+4]
    33 ; @param    ch      gcc: esi  msc: edx  x86:[esp+8]
    34 ; @param    cb      gcc: rdx  msc: r8   x86:[esp+0ch]
    35 RT_NOCRT_BEGINPROC memset
    36         cld
    37 %ifdef RT_ARCH_AMD64
    38  %ifdef ASM_CALL64_MSC
    39         mov     r9, rdi                 ; save rdi in r9
    40         mov     rdi, rcx
    41         mov     r10, rcx                ; the return value.
    42         movzx   eax, dl
    43         cmp     r8, 32
    44         jb      .dobytes
    45 
    46         ; eax = (al << 24) | (al << 16) | (al << 8) | al;
    47         ; rdx = (eax << 32) | eax
    48         movzx   edx, dl
    49         mov     rax, qword 0101010101010101h
    50         imul    rax, rdx
    51 
    52         ; todo: alignment.
    53         mov     rcx, r8
    54         shr     rcx, 3
    55         rep stosq
    56 
    57         and     r8, 7
    58 .dobytes:
    59         mov     rcx, r8
    60         rep stosb
    61 
    62         mov     rdi, r9                 ; restore rdi
    63         mov     rax, r10
    64 
    65  %else ; GCC
    66         mov     r10, rdi                ; the return value.
    67         movzx   eax, sil
    68         cmp     rdx, 32
    69         jb      .dobytes
    70 
    71         ; eax = (al << 24) | (al << 16) | (al << 8) | al;
    72         ; rdx = (eax << 32) | eax
    73         movzx   esi, sil
    74         mov     rax, qword 0101010101010101h
    75         imul    rax, rsi
    76 
    77         ; todo: alignment.
    78         mov     rcx, rdx
    79         shr     rcx, 3
    80         rep stosq
    81 
    82         and     rdx, 7
    83 .dobytes:
    84         mov     rcx, rdx
    85         rep stosb
    86 
    87         mov     rax, r10
    88  %endif ; GCC
    89 
    90 %else ; X86
    91         push    edi
    92 
    93         mov     ecx, [esp + 0ch + 4]
    94         movzx   eax, byte [esp + 08h + 4]
    95         mov     edi, [esp + 04h + 4]
    96         cmp     ecx, 12
    97         jb      .dobytes
    98 
    99         ; eax = (al << 24) | (al << 16) | (al << 8) | al;
    100         mov     ah, al
    101         mov     edx, eax
    102         shl     edx, 16
    103         or      eax, edx
    104 
    105         mov     edx, ecx
    106         shr     ecx, 2
    107         rep stosd
    108 
    109         and     edx, 3
    110         mov     ecx, edx
    111 .dobytes:
    112         rep stosb
    113 
    114         pop     edi
    115         mov     eax, [esp + 4]
    116 %endif ; X86
    117         ret
    118 ENDPROC RT_NOCRT(memset)
    119 

  • trunk/src/VBox/Runtime/common/string/watcom/strchr.asm

    r75123 r75129  
    11; $Id$
    22;; @file
    3 ; IPRT - No-CRT strchr - AMD64 & X86.
     3; IPRT - No-CRT strchr - Watcom register calling convention.
    44;
    55
    … …  
    2727%include "iprt/asmdefs.mac"
    2828
    29 BEGINCODE
     29%define ASM_CALL32_WATCOM
     30%define NAME(name) name %+ _
     31%include "common/string/strchr.asm"
    3032
    31 ;;
    32 ; @param    psz     gcc: rdi  msc: rcx  x86:[esp+4]
    33 ; @param    ch      gcc: esi  msc: edx  x86:[esp+8]
    34 RT_NOCRT_BEGINPROC strchr
    35         cld
    36 
    37         ; check for ch == 0 and setup normal strchr.
    38 %ifdef RT_ARCH_AMD64
    39  %ifdef ASM_CALL64_MSC
    40         or      dl, dl
    41         jz near .strlen
    42         mov     r9, rsi                 ; save rsi
    43         mov     rsi, rcx
    44  %else
    45         or      sil, sil
    46         jz near .strlen
    47         mov     edx, esi
    48         mov     rsi, rdi
    49  %endif
    50 %else
    51         mov     edx, [esp + 8]
    52         or      dl, dl
    53         jz near .strlen
    54         mov     ecx, esi                ; save esi
    55         mov     esi, [esp + 4]
    56 %endif
    57 
    58         ; do the search
    59 .next:
    60         lodsb
    61         cmp     al, dl
    62         je      .found
    63         test    al, al
    64         jz      .not_found
    65 
    66         lodsb
    67         cmp     al, dl
    68         je      .found
    69         test    al, al
    70         jz      .not_found
    71 
    72         lodsb
    73         cmp     al, dl
    74         je      .found
    75         test    al, al
    76         jz      .not_found
    77 
    78         lodsb
    79         cmp     al, dl
    80         je      .found
    81         test    al, al
    82         jz      .not_found
    83         jmp .next
    84 
    85 .found:
    86         lea     xAX, [xSI - 1]
    87 %ifdef ASM_CALL64_MSC
    88         mov     rsi, r9
    89 %endif
    90 %ifdef RT_ARCH_X86
    91         mov     esi, ecx
    92 %endif
    93         ret
    94 
    95 .not_found:
    96 %ifdef ASM_CALL64_MSC
    97         mov     rsi, r9
    98 %endif
    99 %ifdef RT_ARCH_X86
    100         mov     esi, ecx
    101 %endif
    102         xor     eax, eax
    103         ret
    104 
    105 ;
    106 ; Special case: strchr(str, '\0');
    107 ;
    108 align 16
    109 .strlen:
    110 %ifdef RT_ARCH_AMD64
    111  %ifdef ASM_CALL64_MSC
    112         mov     r9, rdi                 ; save rdi
    113         mov     rdi, rcx
    114  %endif
    115 %else
    116         mov     edx, edi                ; save edi
    117         mov     edi, [esp + 4]
    118 %endif
    119         mov     xCX, -1
    120         xor     eax, eax
    121         repne scasb
    122 
    123         lea     xAX, [xDI - 1]
    124 %ifdef ASM_CALL64_MSC
    125         mov     rdi, r9
    126 %endif
    127 %ifdef RT_ARCH_X86
    128         mov     edi, edx
    129 %endif
    130         ret
    131 ENDPROC RT_NOCRT(strchr)
    132 

  • trunk/src/VBox/Runtime/common/string/watcom/strcmp.asm

    r75123 r75129  
    11; $Id$
    22;; @file
    3 ; IPRT - No-CRT strcmp - AMD64 & X86.
     3; IPRT - No-CRT strcmp - Watcom register calling convention.
    44;
    55
    … …  
    2727%include "iprt/asmdefs.mac"
    2828
    29 BEGINCODE
     29%define ASM_CALL32_WATCOM
     30%define NAME(name) name %+ _
     31%include "common/string/strcmp.asm"
    3032
    31 ;;
    32 ; @param    psz1   gcc: rdi  msc: rcx  x86:[esp+4]
    33 ; @param    psz2   gcc: rsi  msc: rdx  x86:[esp+8]
    34 RT_NOCRT_BEGINPROC strcmp
    35         ; input
    36 %ifdef RT_ARCH_AMD64
    37  %ifdef ASM_CALL64_MSC
    38   %define psz1 rcx
    39   %define psz2 rdx
    40  %else
    41   %define psz1 rdi
    42   %define psz2 rsi
    43  %endif
    44 %else
    45         mov     ecx, [esp + 4]
    46         mov     edx, [esp + 8]
    47   %define psz1 ecx
    48   %define psz2 edx
    49 %endif
    50 
    51         ;
    52         ; The loop.
    53         ;
    54 .next:
    55         mov     al, [psz1]
    56         mov     ah, [psz2]
    57         cmp     al, ah
    58         jne     .not_equal
    59         test    al, al
    60         jz      .equal
    61 
    62         mov     al, [psz1 + 1]
    63         mov     ah, [psz2 + 1]
    64         cmp     al, ah
    65         jne     .not_equal
    66         test    al, al
    67         jz      .equal
    68 
    69         mov     al, [psz1 + 2]
    70         mov     ah, [psz2 + 2]
    71         cmp     al, ah
    72         jne     .not_equal
    73         test    al, al
    74         jz      .equal
    75 
    76         mov     al, [psz1 + 3]
    77         mov     ah, [psz2 + 3]
    78         cmp     al, ah
    79         jne     .not_equal
    80         test    al, al
    81         jz      .equal
    82 
    83         add     psz1, 4
    84         add     psz2, 4
    85         jmp     .next
    86 
    87 .equal:
    88         xor     eax, eax
    89         ret
    90 
    91 .not_equal:
    92         movzx   ecx, ah
    93         and     eax, 0ffh
    94         sub     eax, ecx
    95         ret
    96 ENDPROC RT_NOCRT(strcmp)
    97 

  • trunk/src/VBox/Runtime/common/string/watcom/strcpy.asm

    r75123 r75129  
    11; $Id$
    22;; @file
    3 ; IPRT - No-CRT strcpy - AMD64 & X86.
     3; IPRT - No-CRT strcpy - Watcom register calling convention.
    44;
    55
    … …  
    2727%include "iprt/asmdefs.mac"
    2828
    29 BEGINCODE
     29%define ASM_CALL32_WATCOM
     30%define NAME(name) name %+ _
     31%include "common/string/strcpy.asm"
    3032
    31 ;;
    32 ; @param    pszDst   gcc: rdi  msc: rcx  x86:[esp+4]
    33 ; @param    pszSrc   gcc: rsi  msc: rdx  x86:[esp+8]
    34 RT_NOCRT_BEGINPROC strcpy
    35         ; input
    36 %ifdef RT_ARCH_AMD64
    37  %ifdef ASM_CALL64_MSC
    38   %define pszDst rcx
    39   %define pszSrc rdx
    40  %else
    41   %define pszDst rdi
    42   %define pszSrc rsi
    43  %endif
    44         mov     r8, pszDst
    45 %else
    46         mov     ecx, [esp + 4]
    47         mov     edx, [esp + 8]
    48   %define pszDst ecx
    49   %define pszSrc edx
    50         push    pszDst
    51 %endif
    52 
    53         ;
    54         ; The loop.
    55         ;
    56 .next:
    57         mov     al, [pszSrc]
    58         mov     [pszDst], al
    59         test    al, al
    60         jz      .done
    61 
    62         mov     al, [pszSrc + 1]
    63         mov     [pszDst + 1], al
    64         test    al, al
    65         jz      .done
    66 
    67         mov     al, [pszSrc + 2]
    68         mov     [pszDst + 2], al
    69         test    al, al
    70         jz      .done
    71 
    72         mov     al, [pszSrc + 3]
    73         mov     [pszDst + 3], al
    74         test    al, al
    75         jz      .done
    76 
    77         add     pszDst, 4
    78         add     pszSrc, 4
    79         jmp     .next
    80 
    81 .done:
    82 %ifdef RT_ARCH_AMD64
    83         mov     rax, r8
    84 %else
    85         pop     eax
    86 %endif
    87         ret
    88 ENDPROC RT_NOCRT(strcpy)
    89 

  • trunk/src/VBox/Runtime/common/string/watcom/strlen.asm

    r75123 r75129  
    11; $Id$
    22;; @file
    3 ; IPRT - No-CRT strlen - AMD64 & X86.
     3; IPRT - No-CRT strlen - Watcom register calling convention.
    44;
    55
    … …  
    2727%include "iprt/asmdefs.mac"
    2828
    29 BEGINCODE
     29%define ASM_CALL32_WATCOM
     30%define NAME(name) name %+ _
     31%include "common/string/strlen.asm"
    3032
    31 ;;
    32 ; @param    psz     gcc: rdi  msc: rcx  x86: [esp+4]
    33 RT_NOCRT_BEGINPROC strlen
    34         cld
    35 %ifdef RT_ARCH_AMD64
    36  %ifdef ASM_CALL64_MSC
    37         mov     r9, rdi                 ; save rdi
    38         mov     rdi, rcx
    39  %endif
    40 %else
    41         mov     edx, edi                ; save edi
    42         mov     edi, [esp + 4]
    43 %endif
    44 
    45         ; do the search
    46         mov     xCX, -1
    47         xor     eax, eax
    48         repne   scasb
    49 
    50         ; found it
    51         neg     xCX
    52         lea     xAX, [xCX - 2]
    53 %ifdef ASM_CALL64_MSC
    54         mov     rdi, r9
    55 %endif
    56 %ifdef RT_ARCH_X86
    57         mov     edi, edx
    58 %endif
    59         ret
    60 ENDPROC RT_NOCRT(strlen)
    61 

  • trunk/src/VBox/Runtime/common/string/watcom/strncmp.asm

    r75123 r75129  
    11; $Id$
    22;; @file
    3 ; IPRT - No-CRT strncmp - AMD64 & X86.
     3; IPRT - No-CRT strncmp - Watcom register calling convention.
    44;
    55
    … …  
    2727%include "iprt/asmdefs.mac"
    2828
    29 BEGINCODE
     29%define ASM_CALL32_WATCOM
     30%define NAME(name) name %+ _
     31%include "common/string/strncmp.asm"
    3032
    31 ;;
    32 ; @param    psz1   gcc: rdi  msc: rcx  x86:[esp+4]
    33 ; @param    psz2   gcc: rsi  msc: rdx  x86:[esp+8]
    34 ; @param    cch    gcc: rdx  msc: r8   x86:[esp+12]
    35 RT_NOCRT_BEGINPROC strncmp
    36         ; input
    37 %ifdef RT_ARCH_AMD64
    38  %ifdef ASM_CALL64_MSC
    39   %define psz1 rcx
    40   %define psz2 rdx
    41   %define cch  r8
    42  %else
    43   %define psz1 rdi
    44   %define psz2 rsi
    45   %define cch  rdx
    46  %endif
    47 %elifdef RT_ARCH_X86
    48         mov     ecx, [esp + 4]
    49         mov     edx, [esp + 8]
    50         push    ebx
    51         mov     ebx, [esp + 12+4]
    52   %define psz1 ecx
    53   %define psz2 edx
    54   %define cch  ebx
    55 %else
    56  %error "Unknown arch"
    57 %endif
    58 
    59         ;
    60         ; The loop.
    61         ;
    62         test    cch, cch
    63         jz      .equal
    64 .next:
    65         mov     al, [psz1]
    66         mov     ah, [psz2]
    67         cmp     al, ah
    68         jne     .not_equal
    69         test    al, al
    70         jz      .equal
    71         dec     cch
    72         jz      .equal
    73 
    74         mov     al, [psz1 + 1]
    75         mov     ah, [psz2 + 1]
    76         cmp     al, ah
    77         jne     .not_equal
    78         test    al, al
    79         jz      .equal
    80         dec     cch
    81         jz      .equal
    82 
    83         mov     al, [psz1 + 2]
    84         mov     ah, [psz2 + 2]
    85         cmp     al, ah
    86         jne     .not_equal
    87         test    al, al
    88         jz      .equal
    89         dec     cch
    90         jz      .equal
    91 
    92         mov     al, [psz1 + 3]
    93         mov     ah, [psz2 + 3]
    94         cmp     al, ah
    95         jne     .not_equal
    96         test    al, al
    97         jz      .equal
    98         dec     cch
    99         jz      .equal
    100 
    101         add     psz1, 4
    102         add     psz2, 4
    103         jmp     .next
    104 
    105 .equal:
    106         xor     eax, eax
    107 %ifdef RT_ARCH_X86
    108         pop     ebx
    109 %endif
    110         ret
    111 
    112 .not_equal:
    113         movzx   ecx, ah
    114         and     eax, 0ffh
    115         sub     eax, ecx
    116 %ifdef RT_ARCH_X86
    117         pop     ebx
    118 %endif
    119         ret
    120 ENDPROC RT_NOCRT(strncmp)
    121 

  • trunk/src/VBox/Runtime/common/string/watcom/strncpy.asm

    r75123 r75129  
    11; $Id$
    22;; @file
    3 ; IPRT - No-CRT strncpy - AMD64 & X86.
     3; IPRT - No-CRT strncpy - Watcom register calling convention.
    44;
    55
    … …  
    2727%include "iprt/asmdefs.mac"
    2828
    29 BEGINCODE
     29%define ASM_CALL32_WATCOM
     30%define NAME(name) name %+ _
     31%include "common/string/strncpy.asm"
    3032
    31 ;;
    32 ; @param    pszDst   gcc: rdi  msc: rcx  x86:[esp+4]
    33 ; @param    pszSrc   gcc: rsi  msc: rdx  x86:[esp+8]
    34 ; @param    cbMax    gcc: rdx  msc: r8   x86:[esp+12]
    35 RT_NOCRT_BEGINPROC strncpy
    36         ; input
    37 %ifdef RT_ARCH_AMD64
    38  %ifdef ASM_CALL64_MSC
    39   %define pszDst rcx
    40   %define pszSrc rdx
    41   %define cbMax  r8
    42  %else
    43   %define pszDst rdi
    44   %define pszSrc rsi
    45   %define cbMax  rdx
    46  %endif
    47         mov     r9, pszDst
    48 %else
    49         mov     ecx, [esp + 4]
    50         mov     edx, [esp + 8]
    51         push    ebx
    52         mov     ebx, [esp + 12 + 4]
    53   %define pszDst ecx
    54   %define pszSrc edx
    55   %define cbMax  ebx
    56         push    pszDst
    57 %endif
    58 
    59         ;
    60         ; The rolled out loop.
    61         ;
    62 .next:
    63         cmp     cbMax, 4
    64         jb      .simple_intro
    65 
    66         mov     al, [pszSrc]
    67         mov     [pszDst], al
    68         test    al, al
    69         jz      .done
    70 
    71         mov     al, [pszSrc + 1]
    72         mov     [pszDst + 1], al
    73         test    al, al
    74         jz      .done
    75 
    76         mov     al, [pszSrc + 2]
    77         mov     [pszDst + 2], al
    78         test    al, al
    79         jz      .done
    80 
    81         mov     al, [pszSrc + 3]
    82         mov     [pszDst + 3], al
    83         test    al, al
    84         jz      .done
    85 
    86         add     pszDst, 4
    87         add     pszSrc, 4
    88         sub     cbMax,  4
    89         jmp     .next
    90 
    91         ;
    92         ; Char by char.
    93         ;
    94 .simple_intro:
    95         test    cbMax, cbMax
    96         jz      .done
    97 
    98 .simple_next:
    99         mov     al, [pszSrc]
    100         mov     [pszDst], al
    101         test    al, al
    102         jz      .done
    103 
    104         dec     cbMax
    105         jz      .done
    106 
    107         inc     pszSrc
    108         inc     pszDst
    109         jmp     .simple_next
    110 
    111 .done:
    112 %ifdef RT_ARCH_AMD64
    113         mov     rax, r9
    114 %else
    115         pop     ebx
    116         pop     eax
    117 %endif
    118         ret
    119 ENDPROC RT_NOCRT(strncpy)
    120 
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette