VirtualBox

Changeset 75129 in vbox for trunk/src/VBox/Runtime/common


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
Files:
3 added
17 edited
19 copied

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Runtime/common/math/watcom/I8D-x86-32.asm

    r75123 r75129  
    11; $Id$
    22;; @file
    3 ; BS3Kit - 32-bit Watcom C/C++, 64-bit unsigned integer division.
     3; BS3Kit - 32-bit Watcom C/C++, 64-bit signed integer division.
    44;
    55
    … …  
    2525;
    2626
    27 %include "bs3kit-template-header.mac"
     27%include "iprt/asmdefs.mac"
    2828
    29 BS3_EXTERN_CMN Bs3UInt64Div
     29
     30BEGINCODE
     31
     32extern __U8D
    3033
    3134
    3235;;
    33 ; 64-bit unsigned integer division.
     36; 64-bit signed integer division.
    3437;
    3538; @returns  EDX:EAX Quotient, ECX:EBX Remainder.
    … …  
    3740; @param    ECX:EBX     Divisor
    3841;
    39 global $??U8D
    40 $??U8D:
     42global __I8D
     43__I8D:
    4144        ;
    42         ; Convert to a C __cdecl call - not doing this in assembly.
     45        ; We use __U8D to do the work, we take care of the signedness.
    4346        ;
     47        or      edx, edx
     48        js      .negative_dividend
    4449
    45         ; Set up a frame, allocating 16 bytes for the result buffer.
    46         push    ebp
    47         mov     ebp, esp
    48         sub     esp, 10h
     50        or      ecx, ecx
     51        js      .negative_divisor_positive_dividend
     52        jmp     __U8D
    4953
    50         ; Pointer to the return buffer.
    51         push    esp
    5254
    53         ; The divisor.
    54         push    ecx
    55         push    ebx
     55.negative_divisor_positive_dividend:
     56        ; negate the divisor, do unsigned division, and negate the quotient.
     57        neg     ecx
     58        neg     ebx
     59        sbb     ecx, 0
    5660
    57         ; The dividend.
    58         push    edx
    59         push    eax
     61        call    __U8D
    6062
    61         call    Bs3UInt64Div
    62 
    63         ; Load the result.
    64         mov     ecx, [ebp - 10h + 12]
    65         mov     ebx, [ebp - 10h + 8]
    66         mov     edx, [ebp - 10h + 4]
    67         mov     eax, [ebp - 10h]
    68 
    69         leave
     63        neg     edx
     64        neg     eax
     65        sbb     edx, 0
    7066        ret
    7167
     68.negative_dividend:
     69        neg     edx
     70        neg     eax
     71        sbb     edx, 0
     72
     73        or      ecx, ecx
     74        js      .negative_dividend_negative_divisor
     75
     76.negative_dividend_positive_divisor:
     77        ; negate the dividend (above), do unsigned division, and negate both quotient and remainder
     78        call    __U8D
     79
     80        neg     edx
     81        neg     eax
     82        sbb     edx, 0
     83
     84.return_negated_remainder:
     85        neg     ecx
     86        neg     ebx
     87        sbb     ecx, 0
     88        ret
     89
     90.negative_dividend_negative_divisor:
     91        ; negate both dividend (above) and divisor, do unsigned division, and negate the remainder.
     92        neg     ecx
     93        neg     ebx
     94        sbb     ecx, 0
     95
     96        call    __U8D
     97        jmp     .return_negated_remainder
     98

  • trunk/src/VBox/Runtime/common/math/watcom/RTWatcomUInt64Div.c

    r75123 r75129  
    2929*   Header Files                                                                                                                 *
    3030*********************************************************************************************************************************/
    31 #include <bs3kit.h>
    3231#include <iprt/uint64.h>
    3332
    3433
    35 #undef Bs3UInt64Div
    36 BS3_CMN_DEF(void, Bs3UInt64Div,(RTUINT64U uDividend, RTUINT64U uDivisor, RTUINT64U BS3_FAR *paQuotientReminder))
     34DECLASM(void) RTWatcomUInt64Div(RTUINT64U uDividend, RTUINT64U uDivisor, RTUINT64U RT_FAR *paQuotientReminder)
    3735{
    3836    RTUInt64DivRem(&paQuotientReminder[0], &paQuotientReminder[1], &uDividend, &uDivisor);

  • trunk/src/VBox/Runtime/common/math/watcom/U8D-x86-32.asm

    r75123 r75129  
    2525;
    2626
    27 %include "bs3kit-template-header.mac"
     27%include "iprt/asmdefs.mac"
    2828
    29 BS3_EXTERN_CMN Bs3UInt64Div
     29
     30BEGINCODE
     31
     32extern NAME(RTWatcomUInt64Div)
    3033
    3134
    … …  
    3740; @param    ECX:EBX     Divisor
    3841;
    39 global $??U8D
    40 $??U8D:
     42global __U8D
     43__U8D:
    4144        ;
    4245        ; Convert to a C __cdecl call - not doing this in assembly.
    … …  
    5962        push    eax
    6063
    61         call    Bs3UInt64Div
     64        call    NAME(RTWatcomUInt64Div)
    6265
    6366        ; Load the result.

  • trunk/src/VBox/Runtime/common/math/watcom/U8LS-x86-32.asm

    r75123 r75129  
    2525;
    2626
    27 %include "bs3kit-template-header.mac"
     27%include "iprt/asmdefs.mac"
    2828
     29
     30BEGINCODE
    2931
    3032;;
    … …  
    3537; @param    BL          Shift count (it's specified as ECX:EBX, but we only use BL).
    3638;
    37 global $??U8LS
    38 $??U8LS:
    39 global $??I8LS
    40 $??I8LS:
     39global __U8LS
     40__U8LS:
     41global __I8LS
     42__I8LS:
    4143        push    ecx                     ; We're allowed to trash ECX, but why bother.
    4244

  • trunk/src/VBox/Runtime/common/math/watcom/U8RS-x86-32.asm

    r75123 r75129  
    2525;
    2626
    27 %include "bs3kit-template-header.mac"
     27%include "iprt/asmdefs.mac"
     28
     29
     30BEGINCODE
    2831
    2932
    … …  
    3538; @param    BL          Shift count (it's specified as ECX:EBX, but we only use BL).
    3639;
    37 global $??U8RS
    38 $??U8RS:
     40global __U8RS
     41__U8RS:
    3942        push    ecx                     ; We're allowed to trash ECX, but why bother.
    4043

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

    r69111 r75129  
    3030
    3131;;
    32 ; @param    pvDst   gcc: rdi  msc: rcx  x86:[esp+4]
    33 ; @param    cb      gcc: rsi  msc: rdx  x86:[esp+8]
     32; @param    pvDst   gcc: rdi  msc: rcx  x86:[esp+4]  wcall:eax
     33; @param    cb      gcc: rsi  msc: rdx  x86:[esp+8]  wcall:edx
    3434RT_NOCRT_BEGINPROC bzero
    3535%ifdef RT_OS_DARWIN
    … …  
    7171        push    edi
    7272
     73 %ifdef ASM_CALL32_WATCOM
     74        mov     ecx, edx
     75        mov     edi, eax
     76 %else
    7377        mov     ecx, [ebp + 0ch]
    7478        mov     edi, [ebp + 08h]
     79 %endif
    7580        xor     eax, eax
    7681

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

    r69219 r75129  
    3030
    3131;;
    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]
     32; @param    pv      gcc: rdi  msc: ecx  x86:[esp+4]   wcall: eax
     33; @param    ch      gcc: esi  msc: edx  x86:[esp+8]   wcall: edx
     34; @param    cb      gcc: rdx  msc: r8   x86:[esp+0ch] wcall: ebx
    3535RT_NOCRT_BEGINPROC memchr
    3636        cld
    … …  
    5252
    5353%else
     54 %ifdef ASM_CALL32_WATCOM
     55        mov     ecx, ebx
     56        jecxz   .not_found_early
     57        xchg    eax, edx
     58        xchg    edi, edx                ; load and save edi.
     59 %else
    5460        mov     ecx, [esp + 0ch]
    5561        jecxz   .not_found_early
    … …  
    5763        mov     eax, [esp + 8]
    5864        mov     edi, [esp + 4]
     65 %endif
    5966%endif
    6067

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

    r69219 r75129  
    3030
    3131;;
    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]
     32; @param    pv1     gcc: rdi  msc: rcx  x86:[esp+4]   wcall: eax
     33; @param    pv2     gcc: rsi  msc: rdx  x86:[esp+8]   wcall: edx
     34; @param    cb      gcc: rdx  msc: r8   x86:[esp+0ch] wcall: ebx
    3535RT_NOCRT_BEGINPROC memcmp
    3636        cld
    … …  
    5656        push    esi
    5757
     58 %ifdef ASM_CALL32_WATCOM
     59        mov     edi, eax
     60        mov     esi, edx
     61        mov     ecx, ebx
     62        mov     edx, ebx
     63 %else
    5864        mov     ecx, [esp + 0ch + 8]
    5965        mov     edi, [esp + 04h + 8]
    6066        mov     esi, [esp + 08h + 8]
    6167        mov     edx, ecx
     68 %endif
    6269        jecxz   .done
    6370        shr     ecx, 2

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

    r69219 r75129  
    3030
    3131;;
    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]
     32; @param    pvDst   gcc: rdi  msc: rcx  x86:[esp+4]   wcall: eax
     33; @param    pvSrc   gcc: rsi  msc: rdx  x86:[esp+8]   wcall: edx
     34; @param    cb      gcc: rdx  msc: r8   x86:[esp+0ch] wcall: ebx
    3535RT_NOCRT_BEGINPROC memcpy
    3636        cld
    … …  
    5555        push    esi
    5656
     57 %ifdef ASM_CALL32_WATCOM
     58        mov     edi, eax
     59        mov     esi, edx
     60        mov     ecx, ebx
     61        mov     edx, ebx
     62 %else
    5763        mov     ecx, [esp + 0ch + 8]
    5864        mov     edi, [esp + 04h + 8]
    … …  
    6066        mov     edx, ecx
    6167        mov     eax, edi                ; save the return value
     68 %endif
    6269        shr     ecx, 2
    6370        rep movsd

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

    r69219 r75129  
    3030
    3131;;
    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]
     32; @param    pvDst   gcc: rdi  msc: rcx  x86:[esp+4]    wcall: eax
     33; @param    pvSrc   gcc: rsi  msc: rdx  x86:[esp+8]    wcall: edx
     34; @param    cb      gcc: rdx  msc: r8   x86:[esp+0ch]  wcall: ebx
    3535RT_NOCRT_BEGINPROC memmove
    3636        ; Prolog.
    … …  
    5050        push    edi
    5151        push    esi
     52 %ifdef ASM_CALL32_WATCOM
     53        mov     edi, eax
     54        mov     esi, edx
     55        mov     ecx, ebx
     56        mov     edx, ebx
     57 %else
    5258        mov     edi, [esp + 04h + 8]
    5359        mov     esi, [esp + 08h + 8]
    … …  
    5561        mov     edx, ecx
    5662        mov     eax, edi                ; save the return value
     63 %endif
    5764%endif
    5865

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

    r69219 r75129  
    3030
    3131;;
    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]
     32; @param    pvDst   gcc: rdi  msc: rcx  x86:[esp+4]    wcall: eax
     33; @param    pvSrc   gcc: rsi  msc: rdx  x86:[esp+8]    wcall: edx
     34; @param    cb      gcc: rdx  msc: r8   x86:[esp+0ch]  wcall: ebx
    3535RT_NOCRT_BEGINPROC mempcpy
    3636        cld                             ; paranoia
    … …  
    5151        rep movsq
    5252%else
     53 %ifdef ASM_CALL32_WATCOM
     54        xchg    eax, edi                ; saving edi in eax and loading it
     55        push    esi
     56        mov     esi, edx
     57        mov     ecx, ebx
     58        mov     edx, ebx
     59 %else
    5360        mov     eax, edi                ; saving edi in eax
    5461        push    esi
    55 
    5662        mov     ecx, [esp + 0ch + 4]
    5763        mov     edi, [esp + 04h + 4]
    5864        mov     esi, [esp + 08h + 4]
    5965        mov     edx, ecx
     66 %endif
    6067        shr     ecx, 2
    6168        rep movsd

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

    r69219 r75129  
    3030
    3131;;
    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]
     32; @param    pv      gcc: rdi  msc: ecx  x86:[esp+4]   wcall: eax
     33; @param    ch      gcc: esi  msc: edx  x86:[esp+8]   wcall: edx
     34; @param    cb      gcc: rdx  msc: r8   x86:[esp+0ch] wcall: ebx
    3535RT_NOCRT_BEGINPROC memrchr
    3636        std
    … …  
    5353
    5454%else
     55 %ifdef ASM_CALL32_WATCOM
     56        mov     ecx, ebx
     57        jecxz   .not_found_early
     58        xchg    eax, edx
     59        xchg    edi, edx                ; load + save edi
     60 %else
    5561        mov     ecx, [esp + 0ch]
    5662        jecxz   .not_found_early
    … …  
    5864        mov     eax, [esp + 8]
    5965        mov     edi, [esp + 4]
     66 %endif
    6067        lea     edi, [edi + ecx - 1]
    6168%endif

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

    r69219 r75129  
    3030
    3131;;
    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]
     32; @param    pvDst   gcc: rdi  msc: ecx  x86:[esp+4]    wcall: eax
     33; @param    ch      gcc: esi  msc: edx  x86:[esp+8]    wcall: edx
     34; @param    cb      gcc: rdx  msc: r8   x86:[esp+0ch]  wcall: ebx
    3535RT_NOCRT_BEGINPROC memset
    3636        cld
    … …  
    9191        push    edi
    9292
     93 %ifdef ASM_CALL32_WATCOM
     94        push    eax
     95        mov     edi, eax
     96        mov     ecx, ebx
     97        movzx   eax, dl
     98 %else
    9399        mov     ecx, [esp + 0ch + 4]
    94100        movzx   eax, byte [esp + 08h + 4]
    95101        mov     edi, [esp + 04h + 4]
     102 %endif
    96103        cmp     ecx, 12
    97104        jb      .dobytes
    … …  
    112119        rep stosb
    113120
     121 %ifdef ASM_CALL32_WATCOM
     122        pop     eax
     123        pop     edi
     124 %else
    114125        pop     edi
    115126        mov     eax, [esp + 4]
     127 %endif
    116128%endif ; X86
    117129        ret

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

    r69219 r75129  
    3030
    3131;;
    32 ; @param    psz     gcc: rdi  msc: rcx  x86:[esp+4]
    33 ; @param    ch      gcc: esi  msc: edx  x86:[esp+8]
     32; @param    psz     gcc: rdi  msc: rcx  x86:[esp+4]  wcall: eax
     33; @param    ch      gcc: esi  msc: edx  x86:[esp+8]  wcall: edx
    3434RT_NOCRT_BEGINPROC strchr
    3535        cld
    … …  
    4949 %endif
    5050%else
     51 %ifndef ASM_CALL32_WATCOM
    5152        mov     edx, [esp + 8]
     53 %endif
    5254        or      dl, dl
    5355        jz near .strlen
    5456        mov     ecx, esi                ; save esi
     57 %ifdef ASM_CALL32_WATCOM
     58        mov     esi, eax
     59 %else
    5560        mov     esi, [esp + 4]
     61 %endif
    5662%endif
    5763
    … …  
    115121%else
    116122        mov     edx, edi                ; save edi
     123 %ifdef ASM_CALL32_WATCOM
     124        mov     edi, eax
     125 %else
    117126        mov     edi, [esp + 4]
     127 %endif
    118128%endif
    119129        mov     xCX, -1

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

    r69219 r75129  
    3030
    3131;;
    32 ; @param    psz1   gcc: rdi  msc: rcx  x86:[esp+4]
    33 ; @param    psz2   gcc: rsi  msc: rdx  x86:[esp+8]
     32; @param    psz1   gcc: rdi  msc: rcx  x86:[esp+4]  wcall: eax
     33; @param    psz2   gcc: rsi  msc: rdx  x86:[esp+8]  wcall: edx
    3434RT_NOCRT_BEGINPROC strcmp
    3535        ; input
    … …  
    4343 %endif
    4444%else
     45 %ifdef ASM_CALL32_WATCOM
     46        mov     ecx, eax
     47 %else
    4548        mov     ecx, [esp + 4]
    4649        mov     edx, [esp + 8]
    47   %define psz1 ecx
    48   %define psz2 edx
     50 %endif
     51 %define psz1 ecx
     52 %define psz2 edx
    4953%endif
    5054

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

    r69219 r75129  
    3030
    3131;;
    32 ; @param    pszDst   gcc: rdi  msc: rcx  x86:[esp+4]
    33 ; @param    pszSrc   gcc: rsi  msc: rdx  x86:[esp+8]
     32; @param    pszDst   gcc: rdi  msc: rcx  x86:[esp+4]  wcall:eax
     33; @param    pszSrc   gcc: rsi  msc: rdx  x86:[esp+8]  wcall:edx
    3434RT_NOCRT_BEGINPROC strcpy
    3535        ; input
    … …  
    4444        mov     r8, pszDst
    4545%else
     46 %ifdef ASM_CALL32_WATCOM
     47        mov     ecx, eax
     48 %else
    4649        mov     ecx, [esp + 4]
    4750        mov     edx, [esp + 8]
    48   %define pszDst ecx
    49   %define pszSrc edx
     51 %endif
     52 %define pszDst ecx
     53 %define pszSrc edx
    5054        push    pszDst
    5155%endif

  • trunk/src/VBox/Runtime/common/string/strformatnum.cpp

    r69111 r75129  
    249249    if (pr80Value->s.uExponent == 0)
    250250    {
     251#ifdef RT_COMPILER_GROKS_64BIT_BITFIELDS
    251252        if (   !pr80Value->sj64.u63Fraction
    252253            && pr80Value->sj64.fInteger)
     254#else
     255        if (   !pr80Value->sj.u32FractionLow
     256            && !pr80Value->sj.u31FractionHigh
     257            && pr80Value->sj.fInteger)
     258#endif
    253259            *pszTmp++ = '0';
    254260        /* else: Denormal, handled way below. */
    255261    }
     262#ifdef RT_COMPILER_GROKS_64BIT_BITFIELDS
    256263    else if (pr80Value->sj64.uExponent == UINT16_C(0x7fff))
     264#else
     265    else if (pr80Value->sj.uExponent == UINT16_C(0x7fff))
     266#endif
    257267    {
    258268        /** @todo Figure out Pseudo inf/nan... */
     269#ifdef RT_COMPILER_GROKS_64BIT_BITFIELDS
    259270        if (pr80Value->sj64.fInteger)
     271#else
     272        if (pr80Value->sj.fInteger)
     273#endif
    260274            *pszTmp++ = 'P';
     275#ifdef RT_COMPILER_GROKS_64BIT_BITFIELDS
    261276        if (pr80Value->sj64.u63Fraction == 0)
     277#else
     278        if (   pr80Value->sj.u32FractionLow == 0
     279            && pr80Value->sj.u31FractionHigh == 0)
     280#endif
    262281        {
    263282            *pszTmp++ = 'I';
    … …  
    276295    else
    277296    {
     297#ifdef RT_COMPILER_GROKS_64BIT_BITFIELDS
    278298        *pszTmp++ = pr80Value->sj64.fInteger ? '1' : '0';
     299#else
     300        *pszTmp++ = pr80Value->sj.fInteger ? '1' : '0';
     301#endif
    279302        *pszTmp++ = 'm';
     303#ifdef RT_COMPILER_GROKS_64BIT_BITFIELDS
    280304        pszTmp += RTStrFormatNumber(pszTmp, pr80Value->sj64.u63Fraction, 16, 2+16, 0,
    281305                                    RTSTR_F_SPECIAL | RTSTR_F_ZEROPAD | RTSTR_F_64BIT);
     306#else
     307        pszTmp += RTStrFormatNumber(pszTmp, RT_MAKE_U64(pr80Value->sj.u32FractionLow, pr80Value->sj.u31FractionHigh), 16, 2+16, 0,
     308                                    RTSTR_F_SPECIAL | RTSTR_F_ZEROPAD | RTSTR_F_64BIT);
     309#endif
    282310
    283311        *pszTmp++ = 'e';
     312#ifdef RT_COMPILER_GROKS_64BIT_BITFIELDS
    284313        pszTmp += RTStrFormatNumber(pszTmp, (int32_t)pr80Value->sj64.uExponent - 16383, 10, 0, 0,
    285314                                    RTSTR_F_ZEROPAD | RTSTR_F_32BIT | RTSTR_F_VALSIGNED);
     315#else
     316        pszTmp += RTStrFormatNumber(pszTmp, (int32_t)pr80Value->sj.uExponent - 16383, 10, 0, 0,
     317                                    RTSTR_F_ZEROPAD | RTSTR_F_32BIT | RTSTR_F_VALSIGNED);
     318#endif
    286319    }
    287320

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

    r69219 r75129  
    3030
    3131;;
    32 ; @param    psz     gcc: rdi  msc: rcx  x86: [esp+4]
     32; @param    psz     gcc: rdi  msc: rcx  x86: [esp+4]  wcall: eax
    3333RT_NOCRT_BEGINPROC strlen
    3434        cld
    … …  
    4040%else
    4141        mov     edx, edi                ; save edi
     42 %ifdef ASM_CALL32_WATCOM
     43        mov     edi, eax
     44 %else
    4245        mov     edi, [esp + 4]
     46 %endif
    4347%endif
    4448

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

    r69219 r75129  
    3030
    3131;;
    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]
     32; @param    psz1   gcc: rdi  msc: rcx  x86:[esp+4]   wcall: eax
     33; @param    psz2   gcc: rsi  msc: rdx  x86:[esp+8]   wcall: edx
     34; @param    cch    gcc: rdx  msc: r8   x86:[esp+12]  wcall: ebx
    3535RT_NOCRT_BEGINPROC strncmp
    3636        ; input
    … …  
    4545  %define cch  rdx
    4646 %endif
     47%elifdef ASM_CALL32_WATCOM
     48        mov    ecx, eax
     49  %define psz1 ecx
     50  %define psz2 edx
     51  %define cch  ebx
     52
    4753%elifdef RT_ARCH_X86
    4854        mov     ecx, [esp + 4]
    … …  
    105111.equal:
    106112        xor     eax, eax
    107 %ifdef RT_ARCH_X86
     113%ifndef ASM_CALL32_WATCOM
     114 %ifdef RT_ARCH_X86
    108115        pop     ebx
     116 %endif
    109117%endif
    110118        ret
    … …  
    114122        and     eax, 0ffh
    115123        sub     eax, ecx
    116 %ifdef RT_ARCH_X86
     124%ifndef ASM_CALL32_WATCOM
     125 %ifdef RT_ARCH_X86
    117126        pop     ebx
     127 %endif
    118128%endif
    119129        ret

  • trunk/src/VBox/Runtime/common/string/strncmp.cpp

    r69111 r75129  
    2929#ifdef _MSC_VER
    3030_CRTIMP int __cdecl strncmp
     31#elif defined(__WATCOMC__)
     32_WCRTLINK int std::strncmp
    3133#else
    3234int strncmp

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

    r69219 r75129  
    3030
    3131;;
    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]
     32; @param    pszDst   gcc: rdi  msc: rcx  x86:[esp+4]   wcall: eax
     33; @param    pszSrc   gcc: rsi  msc: rdx  x86:[esp+8]   wcall: edx
     34; @param    cbMax    gcc: rdx  msc: r8   x86:[esp+12]  wcall: ebx
    3535RT_NOCRT_BEGINPROC strncpy
    3636        ; input
    … …  
    4747        mov     r9, pszDst
    4848%else
     49 %ifdef ASM_CALL32_WATCOM
     50  mov   ecx, eax
     51  %define pszDst ecx
     52  %define pszSrc edx
     53  %define cbMax  ebx
     54 %else
    4955        mov     ecx, [esp + 4]
    5056        mov     edx, [esp + 8]
    … …  
    5460  %define pszSrc edx
    5561  %define cbMax  ebx
     62 %endif
    5663        push    pszDst
    5764%endif
    … …  
    113120        mov     rax, r9
    114121%else
     122 %ifndef ASM_CALL32_WATCOM
    115123        pop     ebx
     124 %endif
    116125        pop     eax
    117126%endif

  • trunk/src/VBox/Runtime/common/string/strpbrk.cpp

    r69111 r75129  
    4343_CRTIMP char * __cdecl strpbrk(const char *pszStr, const char *pszChars)
    4444# endif
     45#elif defined(__WATCOMC__)
     46_WCRTLINK char *std::strpbrk(const char *pszStr, const char *pszChars)
    4547#else
    4648char *strpbrk(const char *pszStr, const char *pszChars)

  • 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