操作系统开发

开发平台：
C/C++

LIB386.TXT：源码内容
							
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/byte_order.h	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#define CHAR_UNSIGNED   0
#define MSB_AT_LOW_ADDRESS      0
#define MSW_AT_LOW_ADDRESS      0
#define FL_MSB_AT_LOW_ADDRESS   0
#define FL_MSW_AT_LOW_ADDRESS   0
#define FL_MSL_AT_LOW_ADDRESS   0
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_adf4.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.define .adf4

        .sect .text
.adf4:
        mov     bx,sp
        flds    4(bx)
        fadds   8(bx)
        fstps   8(bx)
        wait
        ret
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_adf8.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.define .adf8

        .sect .text
.adf8:
        mov     bx,sp
        fldd    4(bx)
        faddd   12(bx)
        fstpd   12(bx)
        wait
        ret
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_adi.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.define .adi

        ! #bytes in ecx , top of stack in eax
        .sect .text
.adi:
        pop     ebx              ! return address
        cmp     ecx,4
        jne     9f
        pop     ecx
        add     eax,ecx
        jmp     ebx
9:
.extern EODDZ
.extern .trp
        mov     eax,EODDZ
        push    ebx
        jmp     .trp
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_and.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.define .and

        ! #bytes in ecx
        ! save edi; it might be a register variable

        .sect .text
.and:
        pop     ebx             ! return address
        mov     edx,edi
        mov     edi,esp
        add     edi,ecx
        sar     ecx,2
1:
        pop     eax
        and     eax,(edi)
        stos
        loop    1b
        mov     edi,edx
        jmp     ebx
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_blm.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.sect .text
.define .blm

        ! ecx: count in words
.blm:
        mov     ebx,esp
        mov     eax,esi
        mov     edx,edi
        mov     edi,4(ebx)
        mov     esi,8(ebx)
        rep     movs
        mov     esi,eax
        mov     edi,edx
        ret     8

++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_cff4.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.define .cff4

        .sect .text
.cff4:
        mov     bx,sp
        fldd    4(bx)
        fstcw   4(bx)
        wait
        mov     dx,4(bx)
        and     4(bx),0xf3ff    ! set to rounding mode
        wait
        fldcw   4(bx)
        fstps   8(bx)
        mov     4(bx),dx
        wait
        fldcw   4(bx)
        wait
        ret
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_cff8.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.define .cff8

        .sect .text
.cff8:
        mov     bx,sp
        flds    4(bx)
        fstpd   4(bx)
        wait
        ret
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_cfi.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.define .cfi

        .sect .text
.cfi:
        mov     bx,sp
        fstcw   4(bx)
        wait
        mov     dx,4(bx)
        or      4(bx),0xc00     ! truncating mode
        wait
        fldcw   4(bx)
        cmp     8(bx),4
        jne     2f
                                ! loc 4 loc ? cfi
        flds    12(bx)
        fistpl  12(bx)
1:
        mov     4(bx),dx
        wait
        fldcw   4(bx)
        ret
2:
                                ! loc 8 loc ? cfi
        fldd    12(bx)
        fistpl  16(bx)
        jmp     1b
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_cfu.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.define .cfu

        .sect .text
.cfu:
        mov     bx,sp
        fstcw   4(bx)
        wait
        mov     dx,4(bx)
        or      4(bx),0xc00     ! truncating mode
        wait
        fldcw   4(bx)
        cmp     8(bx),4
        jne     2f
                                ! loc 4 loc ? cfu
        flds    12(bx)
        fabs                    ! ???
        fiaddl  (bigmin)
        fistpl  12(bx)
        wait
        mov     ax,12(bx)
        sub     ax,(bigmin)
        mov     12(bx),ax
1:
        mov     4(bx),dx
        wait
        fldcw   4(bx)
        ret
2:
                                ! loc 8 loc ? cfu
        fldd    12(bx)
        fabs                    ! ???
        fiaddl  (bigmin)
        fistpl  16(bx)
        mov     ax,16(bx)
        sub     ax,(bigmin)
        mov     16(bx),ax
        jmp     1b
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_cif4.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.define .cif4

        .sect .text
.cif4:
        mov     bx,sp
        fildl   8(bx)
        fstps   8(bx)
        wait
        ret
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_cif8.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.define .cif8

        .sect .text
.cif8:
        mov     bx,sp
        fildl   8(bx)
        fstpd   4(bx)
        wait
        ret
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_cii.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.define .cii

.sect .text
.cii:
        pop     ebx              ! return address
                                ! pop     ecx, dest. size
                                ! pop     edx, src. size
                                ! eax is source
        cmp     edx,1
        jne     2f
        movsxb  eax,al
        mov     edx,4
        jmp     1f
2:
        cmp     edx,2
        jne     1f
        cwde                    ! convert from 2 to 4 bytes
        mov     edx,4
1:
        cmp     edx,ecx
        jne     9f
        cmp     edx,4
        jne     9f
        jmp     ebx
9:
.extern EILLINS
.extern .fat
        mov     eax,EILLINS
        push    eax
        jmp     .fat
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_cmf4.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.define .cmf4

        .sect .text
.cmf4:
        mov     bx,sp
        xor     cx,cx
        flds    8(bx)
        flds    4(bx)
        fcompp                  ! compare and pop operands
        fstsw   ax
        wait
        sahf
        je      1f
        jb      2f
        dec     cx
        jmp     1f
2:
        inc     cx
1:
        mov     ax,cx
        ret
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_cmf8.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.define .cmf8

        .sect .text
.cmf8:
        mov     bx,sp
        xor     cx,cx
        fldd    12(bx)
        fldd    4(bx)
        fcompp                  ! compare and pop operands
        fstsw   ax
        wait
        sahf
        je      1f
        jb      2f
        dec     cx
        jmp     1f
2:
        inc     cx
1:
        mov     ax,cx
        ret
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_cms.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.define .cms

        ! #bytes in ecx
        .sect .text
.cms:
        pop     ebx              ! return address
        mov     edx,esp
        push    esi
        push    edi
        mov     esi,edx
        add     edx,ecx
        mov     edi,edx
        add     edx,ecx
        sar     ecx,2
        repe cmps
        je      1f
        inc     ecx
1:
        pop     edi
        pop     esi
        mov     esp,edx
        jmp     ebx
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_com.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.define .com

        ! #bytes in ecx
        .sect .text
.com:
        mov     ebx,esp
        add     ebx,4
        sar     ecx,2
1:
        not     (ebx)
        add     ebx,4
        loop    1b
        ret
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_csa4.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.define .csa4

.sect .text
.csa4:
                                ! ebx, descriptor address
                                ! eax, index
        mov     edx,(ebx)         ! default
        sub     eax,4(ebx)
        cmp     eax,8(ebx)
        ja      1f
        sal     eax,2
        add     ebx,eax
        mov     ebx,12(ebx)
        test    ebx,ebx
        jnz     2f
1:
        mov     ebx,edx
        test    ebx,ebx
        jnz     2f
.extern ECASE
.extern .fat
        mov     eax,ECASE
        push    eax
        jmp     .fat
2:
        jmp     ebx
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_csb4.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.define .csb4

.sect .text
.csb4:
                                !ebx, descriptor address
                                !eax,  index
        mov     edx,(ebx)
        mov     ecx,4(ebx)
1:
        add     ebx,8
        dec     ecx
        jl      4f
        cmp     eax,(ebx)
        jne     1b
        mov     ebx,4(ebx)
2:
        test    ebx,ebx
        jnz     3f
.extern ECASE
.extern .fat
        mov     eax,ECASE
        push    eax
        jmp     .fat
3:
        jmp     ebx
4:
        mov     ebx,edx
        jmp     2b
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_cuf4.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.define .cuf4

        .sect .text
.cuf4:
        mov     bx,sp
        fildl   8(bx)
        cmp     8(bx),0
        jge     1f
        fisubl  (bigmin)
        fisubl  (bigmin)
1:
        fstps   8(bx)
        wait
        ret
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_cuf8.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.define .cuf8

        .sect .text
.cuf8:
        mov     bx,sp
        fildl   8(bx)
        cmp     8(bx),0
        jge     1f
        fisubl  (bigmin)
        fisubl  (bigmin)
1:
        fstpd   4(bx)
        wait
        ret
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_cuu.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.define .ciu
.define .cui
.define .cuu

.sect .text
.ciu:
.cui:
.cuu:
        pop     ebx              ! return address
                                ! pop     ecx, dest. size
                                ! pop     edx, source size
                                ! eax is source
        cmp     edx,ecx
        jne     8f
        jmp     ebx
8:
.extern EILLINS
.extern .fat
        mov     eax,EILLINS
        push    eax
        jmp     .fat
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_dup.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.define .dup

        ! #bytes in ecx
        .sect .text
.dup:
        pop     ebx             ! return address
        mov     eax,esi
        mov     edx,edi
        mov     esi,esp
        sub     esp,ecx
        mov     edi,esp
        sar     ecx,2
        rep movs
        mov     esi,eax
        mov     edi,edx
        jmp     ebx
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_dvf4.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.define .dvf4

        .sect .text
.dvf4:
        mov     bx,sp
        flds    8(bx)
        fdivs   4(bx)
        fstps   8(bx)
        wait
        ret
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_dvf8.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.define .dvf8

        .sect .text
.dvf8:
        mov     bx,sp
        fldd    12(bx)
        fdivd   4(bx)
        fstpd   12(bx)
        wait
        ret
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_dvi.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.define .dvi

        ! #bytes in eax
        .sect .text
.dvi:
        pop     ebx              ! return address
        cmp     eax,4
        jne     1f
        pop     eax
        cwd
        pop     ecx
        idiv    ecx
        push    eax
        jmp     ebx
1:
.extern EODDZ
.extern .trp
        mov     eax,EODDZ
        push    ebx
        jmp     .trp
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_dvu.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.define .dvu

        ! #bytes in eax
        .sect .text
.dvu:
        pop     ebx              ! return address
        cmp     eax,4
        jne     1f
        pop     eax
        xor     edx,edx
        pop     ecx
        div     ecx
        push    eax
        jmp     ebx
1:
.extern EODDZ
.extern .trp
        mov     eax,EODDZ
        push    ebx
        jmp     .trp
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_error.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.define .error
.define .Xtrp

        ! eax is trap number
        ! all registers must be saved
        ! because return is possible
        ! May only be called with error no's <16
.sect .text
.error:
        mov  ecx,eax
        mov  ebx,1
        sal  ebx,cl
.extern .ignmask
.extern .trp
        test ebx,(.ignmask)
        jne  2f
        call    .trp
2:
        ret

.Xtrp:
        pusha
        cmp     eax,16
        jge     1f
        call    .error
        popa
        ret
1:
        call    .trp
        popa
        ret
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_exg.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.define .exg

        ! #bytes in ecx
.sect .text
.exg:
        push    edi
        mov     edi,esp
        add     edi,8
        mov     ebx,edi
        add     ebx,ecx
        sar     ecx,2
1:
        mov     eax,(ebx)
        xchg    eax,(edi)
        mov     (ebx),eax
        add     edi,4
        add     ebx,4
        loop    1b
2:
        pop     edi
        ret
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_fat.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.sect .text
.define .fat

.fat:
.extern .trp
.extern .stop
        call    .trp
        call    .stop
        ! no return
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_fef4.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.define .fef4

        .sect .text
.fef4:
                                ! this could be simpler, if only the
                                ! fxtract instruction was emulated properly
        mov     bx,sp
        mov     ax,8(bx)
        and     ax,0x7f800000
        je      1f              ! zero exponent
        shr     ax,23
        sub     ax,126
        mov     cx,ax           ! exponent in cx
        mov     ax,8(bx)
        and     ax,0x807fffff
        or      ax,0x3f000000   ! load -1 exponent
        mov     bx,4(bx)
        mov     4(bx),ax
        mov     (bx),cx
        ret
1:                              ! we get here on zero exp
        mov     ax,8(bx)
        and     ax,0x007fffff
        jne     1f              ! zero result
        mov     bx,4(bx)
        mov     (bx),ax
        mov     4(bx),ax
        ret
1:                              ! otherwise unnormalized number
        mov     cx,8(bx)
        and     cx,0x807fffff
        mov     dx,cx
        and     cx,0x80000000
        mov     ax,-125
2:
        test    dx,0x800000
        jne     1f
        dec     ax
        shl     dx,1
        or      dx,cx
        jmp     2b
1:
        mov     bx,4(bx)
        mov     (bx),ax
        and     dx,0x807fffff
        or      dx,0x3f000000   ! load -1 exponent
        mov     4(bx),dx
        ret
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_fef8.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.define .fef8

        .sect .text
.fef8:
                                ! this could be simpler, if only the
                                ! fxtract instruction was emulated properly
        mov     bx,sp
        mov     ax,12(bx)
        and     ax,0x7ff00000
        je      1f              ! zero exponent
        shr     ax,20
        sub     ax,1022
        mov     cx,ax           ! exponent in cx
        mov     ax,12(bx)
        and     ax,0x800fffff
        or      ax,0x3fe00000   ! load -1 exponent
        mov     dx,8(bx)
        mov     bx,4(bx)
        mov     4(bx),dx
        mov     8(bx),ax
        mov     (bx),cx
        ret
1:                              ! we get here on zero exp
        mov     ax,12(bx)
        and     ax,0xfffff
        or      ax,8(bx)
        jne     1f              ! zero result
        mov     bx,4(bx)
        mov     (bx),ax
        mov     4(bx),ax
        mov     8(bx),ax
        ret
1:                              ! otherwise unnormalized number
        mov     cx,12(bx)
        and     cx,0x800fffff
        mov     dx,cx
        and     cx,0x80000000
        mov     ax,-1021
2:
        test    dx,0x100000
        jne     1f
        dec     ax
        shl     8(bx),1
        rcl     dx,1
        or      dx,cx
        jmp     2b
1:
        and     dx,0x800fffff
        or      dx,0x3fe00000   ! load -1 exponent
        mov     cx,8(bx)
        mov     bx,4(bx)
        mov     (bx),ax
        mov     8(bx),dx
        mov     4(bx),cx
        ret
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_fif4.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.define .fif4

        .sect .text
.fif4:
        mov     bx,sp
        flds    8(bx)
        fmuls   12(bx)          ! multiply
        fld     st              ! copy result
        ftst                    ! test sign; handle negative separately
        fstsw   ax
        wait
        sahf                    ! result of test in condition codes
        jb      1f
        frndint                 ! this one rounds (?)
        fcom    st(1)           ! compare with original; if <=, then OK
        fstsw   ax
        wait
        sahf
        jbe     2f
        fisubs  (one)           ! else subtract 1
        jmp     2f
1:                              ! here, negative case
        frndint                 ! this one rounds (?)
        fcom    st(1)           ! compare with original; if >=, then OK
        fstsw   ax
        wait
        sahf
        jae     2f
        fiadds  (one)           ! else add 1
2:
        fsub    st(1),st        ! subtract integer part
        mov     bx,4(bx)
        fstps   (bx)
        fstps   4(bx)
        wait
        ret
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_fif8.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.define .fif8

        .sect .text
.fif8:
        mov     bx,sp
        fldd    8(bx)
        fmuld   16(bx)          ! multiply
        fld     st              ! and copy result
        ftst                    ! test sign; handle negative separately
        fstsw   ax
        wait
        sahf                    ! result of test in condition codes
        jb      1f
        frndint                 ! this one rounds (?)
        fcom    st(1)           ! compare with original; if <=, then OK
        fstsw   ax
        wait
        sahf
        jbe     2f
        fisubs  (one)           ! else subtract 1
        jmp     2f
1:                              ! here, negative case
        frndint                 ! this one rounds (?)
        fcom    st(1)           ! compare with original; if >=, then OK
        fstsw   ax
        wait
        sahf
        jae     2f
        fiadds  (one)           ! else add 1
2:
        fsub    st(1),st        ! subtract integer part
        mov     bx,4(bx)
        fstpd   (bx)
        fstpd   8(bx)
        wait
        ret
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_fp8087.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.define one, bigmin

        .sect .rom
one:
        .data2  1
two:
        .data2  2
bigmin:
        .data4  -2147483648
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_gto.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.sect .text
.define .gto

.gto:
        mov     ebp,8(ebx)
        mov     esp,4(ebx)
        jmp     (ebx)
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_iaar.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.sect .text
.define .iaar

.iaar:
        pop     ecx
        pop     edx
        cmp     edx,4
.extern .unknown
        jne     .unknown
        pop     ebx     ! descriptor address
        pop     eax     ! index
        sub     eax,(ebx)
        mul     8(ebx)
        pop     ebx     ! array base
        add     ebx,eax
        push    ecx
        ret
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_ilar.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.sect .text
.define .ilar

.ilar:
        pop     ecx
        pop     edx
.extern .unknown
        cmp     edx,4
        jne     .unknown
        pop     ebx      ! descriptor address
        pop     eax      ! index
        push    ecx
.extern .lar4
        jmp    .lar4
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_inn.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.sect .text
.define .inn

        ! #bytes in ecx
        ! bit # in eax
.inn:
        xor     edx,edx
        mov     ebx,8
        div     ebx
        mov     ebx,esp
        add     ebx,4
        add     ebx,eax
        cmp     eax,ecx
        jae     1f
        movb    al,(ebx)
        mov     ebx,edx
        testb   al,bits(ebx)
        jz      1f
        mov     eax,1
        jmp     2f
1:
        xor     eax,eax
2:
        pop     ebx
        add     esp,ecx
        ! eax is result
        jmp     ebx

        .sect .rom
bits:
        .data1 1,2,4,8,16,32,64,128
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_ior.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.sect .text
.define .ior

        ! #bytes in ecx
.ior:
        pop     ebx             ! return address
        mov     edx,edi
        mov     edi,esp
        add     edi,ecx
        sar     ecx,2
1:
        pop     eax
        or      eax,(edi)
        stos
        loop    1b
        mov     edi,edx
        jmp     ebx
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_isar.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.sect .text
.define .isar

.isar:
        pop     ecx
        pop     eax
        cmp     eax,4
.extern .unknown
        jne     .unknown
        pop     ebx      ! descriptor address
        pop     eax      ! index
        push    ecx
.extern .sar4
        jmp    .sar4
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_lar4.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.sect .text
.define .lar4

.lar4:
                                ! ebx, descriptor address
                                ! eax, index
        sub     eax,(ebx)
        mov     ecx,8(ebx)
        imul    ecx
        pop     ebx
        pop     edx             ! base address
        add     edx,eax
        sar     ecx,1
        jnb     1f
        xor     eax,eax
        movb    al,(edx)
        push    eax
        jmp     ebx
1:
        sar     ecx,1
        jnb     1f
        xor     eax,eax
        o16 mov ax,(edx)
        push    eax
        jmp     ebx
1:
        xchg    edx,esi         ! saved esi
        mov     eax,ecx
        sal     eax,2
        sub     esp,eax
        mov     eax,edi         ! save edi
        mov     edi,esp
        rep movs
        mov     edi,eax
        mov     esi,edx
        jmp     ebx
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_loi.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.sect .text
.define .loi
.define .los

        ! #bytes in ecx
        ! address in ebx
        ! save esi/edi. they might be register variables
.los:
        pop     edx
        mov     eax,ecx
        sar     ecx,1
        jnb     1f
        movsxb  eax,(ebx)
        push    eax
        jmp     edx
1:
        sar     ecx,1
        jnb     1f
        movsx   eax,(ebx)
        push    eax
        jmp     edx
1:
        push    edx
        mov     edx,esi
        mov     esi,ebx
        pop     ebx
        sub     esp,eax
        jmp     1f

.loi:
        ! only called with size >= 4
        mov     edx,esi
        mov     esi,ebx
        pop     ebx
        sub     esp,ecx
        sar     ecx,2
1:
        mov     eax,edi
        mov     edi,esp
        rep movs
        mov     esi,edx
        mov     edi,eax
        jmp     ebx
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_mlf4.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.define .mlf4

        .sect .text
.mlf4:
        mov     bx,sp
        flds    4(bx)
        fmuls   8(bx)
        fstps   8(bx)
        wait
        ret
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_mlf8.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.define .mlf8

        .sect .text
.mlf8:
        mov     bx,sp
        fldd    4(bx)
        fmuld   12(bx)
        fstpd   12(bx)
        wait
        ret
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_mli.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.sect .text
.define .mli

        ! #bytes in eax
.mli:
        pop     ebx              ! return address
        cmp     eax,4
        jne     1f
        pop     eax
        pop     ecx
        mul     ecx
        push    eax
        jmp     ebx
1:
.extern EODDZ
.extern .trp
        mov     eax,EODDZ
        push    ebx
        jmp     .trp
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_mon.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.sect .text
.define .mon

.mon:
.extern .stop
        call    .stop
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_ngf4.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.define .ngf4

        .sect .text
.ngf4:
        mov     bx,sp
        flds    4(bx)
        fchs
        fstps   4(bx)
        wait
        ret
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_ngf8.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.define .ngf8

        .sect .text
.ngf8:
        mov     bx,sp
        fldd    4(bx)
        fchs
        fstpd   4(bx)
        wait
        ret
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_ngi.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.sect .text
.define .ngi

        ! #bytes in eax
.ngi:
        pop     ebx              ! return address
        cmp     eax,4
        jne     1f
        pop     ecx
        neg     ecx
        push    ecx
        jmp     ebx
1:
.extern EODDZ
.extern .trp
        mov     eax,EODDZ
        push    ebx
        jmp     .trp
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_nop.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.sect .text
.define .nop
.extern printd, printc, hol0

.nop:
        mov     eax,(hol0)
        call    printd
        movb    al,'n'
        jmp     printc
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_print.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.sect .text
.define printc,printd,prints

        ! argument in eax
        ! uses ebx
prints:
        xchg    eax,ebx
1:
        movb    al,(ebx)
        inc     ebx
        testb   al,al
        jz      2f
        call    printc
        jmp     1b
2:
        ret

        ! argument in eax
        ! uses ecx and edx
printd:
        xor     edx,edx
        mov     ecx,10
        div     ecx
        test    eax,eax
        jz      1f
        push    edx
        call    printd
        pop     edx
1:
        xchg    eax,edx
        addb    al,'0'

        ! argument in eax
printc:
        push    eax
        mov     ebx,esp
        mov     eax,1
        push    eax
        push    ebx
        push    eax
        call    __write
        pop     ebx
        pop     ebx
        pop     ebx
        pop     ebx
        ret
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_rck.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.sect .text
.define .rck

        ! descriptor address in ebx
        ! value in eax, must be left there
.rck:
        cmp     eax,(ebx)
        jl      2f
        cmp     eax,4(ebx)
        jg      2f
        ret
2:
        push    eax
.extern ERANGE
.extern .error
        mov     eax,ERANGE
        call    .error
        pop     eax
        ret
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_rmi.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.sect .text
.define .rmi

        ! #bytes in eax
.rmi:
        pop     ebx              ! return address
        cmp     eax,4
        jne     1f
        pop     eax
        cwd
        pop     ecx
        idiv    ecx
        push    edx
        jmp     ebx
1:
.extern EODDZ
.extern .trp
        mov     eax,EODDZ
        push    ebx
        jmp     .trp
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_rmu.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.sect .text
.define .rmu

        ! #bytes in eax
.rmu:
        pop     ebx              ! return address
        cmp     eax,4
        jne     1f
        pop     eax
        xor     edx,edx
        pop     ecx
        idiv    ecx
        push    edx
        jmp     ebx
1:
.extern EODDZ
.extern .trp
        mov     eax,EODDZ
        push    ebx
        jmp     .trp
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_rol.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.sect .text
.define .rol

        ! #bytes in eax
.rol:
        pop     edx              ! return address
        cmp     eax,4
        jne     1f
        pop     eax
        pop     ecx
        rol     eax,cl
        push    eax
        jmp     edx
1:
.extern EODDZ
.extern .trp
        mov     eax,EODDZ
        push    edx
        jmp     .trp
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_ror.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.sect .text
.define .ror

        ! #bytes in eax
.ror:
        pop     edx              ! return address
        cmp     eax,4
        jne     1f
        pop     eax
        pop     ecx
        ror     eax,cl
        push    eax
        jmp     edx
1:
.extern EODDZ
.extern .trp
        mov     eax,EODDZ
        push    edx
        jmp     .trp
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_sar4.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.sect .text
.define .sar4

.sar4:
                                ! ebx, descriptor address
                                ! eax, index
        sub     eax,(ebx)
        mov     ecx,8(ebx)
        imul    ecx
        pop     ebx
        pop     edx             ! base address
        add     edx,eax
        sar     ecx,1
        jnb     1f
        pop     eax
        movb    (edx),al
        jmp     ebx
1:
        sar     ecx,1
        jnb     1f
        pop     eax
        o16 mov (edx),ax
        jmp     ebx
1:
        xchg    edi,edx         ! edi = base address, edx is saved edi
        mov     eax,esi
        mov     esi,esp
        rep movs
        mov     esp,esi
        mov     esi,eax
        mov     edi,edx
        jmp     ebx
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_sbf4.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.define .sbf4

        .sect .text
.sbf4:
        mov     bx,sp
        flds    8(bx)
        fsubs   4(bx)
        fstps   8(bx)
        wait
        ret
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_sbf8.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.define .sbf8

        .sect .text
.sbf8:
        mov     bx,sp
        fldd    12(bx)
        fsubd   4(bx)
        fstpd   12(bx)
        wait
        ret
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_sbi.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.sect .text
.define .sbi

        ! #bytes in ecx , top of stack in eax
.sbi:
        pop     ebx              ! return subress
        cmp     ecx,4
        jne     1f
        pop     ecx
        sub     eax,ecx
        neg     eax
        jmp     ebx
1:
.extern EODDZ
.extern .trp
        mov     eax,EODDZ
        push    ebx
        jmp     .trp
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_set.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.sect .text
.define .set

        ! #bytes in ecx
        ! bit # in eax
.set:
        pop     ebx              ! return address
        xor     edx,edx
!ifdef create set
        sub     esp,ecx
        push    ebx
        push    edi
        mov     ebx,esp
        xor     edi,edi
        sar     ecx,2
1:
        mov     8(ebx)(edi),edx
        add     edi,4
        loop    1b
!endif
        mov     ebx,8
        div     ebx
        cmp     eax,edi
        jae     2f
        mov     edi,edx
        movb    dl,bits(edi)
        mov     edi,esp
        add     edi,eax
        orb     8(edi),dl
        pop     edi
        ret
2:
.extern ESET
.extern .trp
        pop     edi
        mov     eax,ESET
        jmp     .trp

        .sect .rom
bits:
        .data1   1,2,4,8,16,32,64,128
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_sli.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.sect .text
.define .sli

        ! #bytes in eax
.sli:
        pop     edx              ! return address
        cmp     eax,4
        jne     1f
        pop     eax
        pop     ecx
        sal     eax,cl
        push    eax
        jmp     edx
1:
.extern EODDZ
.extern .trp
        mov     eax,EODDZ
        push    edx
        jmp     .trp
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_sri.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.sect .text
.define .sri

        ! #bytes in eax
.sri:
        pop     edx              ! return address
        cmp     eax,4
        jne     1f
        pop     eax
        pop     ecx
        sar     eax,cl
        push    eax
        jmp     edx
1:
.extern EODDZ
.extern .trp
        mov     eax,EODDZ
        push    edx
        jmp     .trp
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_sti.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.sect .text
.define .sti
.define .sts

        ! #bytes in ecx
        ! address in ebx
        ! save edi/esi. they might be register variables
.sts:
        pop     edx
        sar     ecx,1
        jnb     1f
        pop     eax
        movb    (ebx),al
        jmp     edx
1:
        sar     ecx,1
        jnb     1f
        pop     eax
        o16 mov (ebx),ax
        jmp     edx
1:
        push    edx
        mov     edx,edi
        mov     edi,ebx
        pop     ebx
        jmp     1f
.sti:
        ! only called with count >> 4
        mov     edx,edi
        mov     edi,ebx
        pop     ebx
        sar     ecx,2
1:
        mov     eax,esi
        mov     esi,esp
        rep movs
        mov     esp,esi
        mov     edi,edx
        mov     esi,eax
        jmp     ebx
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_stop.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.sect .text
.define .stop
.stop:
        jmp     ___exit
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_strhp.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.sect .text
.define .strhp
.extern .reghp, .limhp, EHEAP, .trp

.strhp:
        pop     ebx
        pop     eax
        mov     (.reghp),eax
        cmp     eax,(.limhp)
        jb      1f
        add     eax,02000
        and     eax,~0777
        push    ebx
        push    eax
        call    __brk
        pop     ecx
        pop     ebx
        cmp     eax,-1
        je      2f
1:
        mov     (.limhp),ecx
        jmp     ebx
2:
        mov     eax,EHEAP
        push    ebx
        jmp     .trp
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_trp.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.sect .text
.define .trp
.extern .trppc, .stop

                ! eax is trap number
.trp:
        xor     ebx,ebx
        xchg    ebx,(.trppc)
        test    ebx,ebx
        jz      2f
        push    eax
        call    ebx
        pop     eax
        ret
2:
        push    eax
        call    .stop
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_unknown.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.sect .text
.define .unknown
.extern EILLINS, .fat

.unknown:
        mov  eax,EILLINS
        push eax
        jmp  .fat
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/em/em_xor.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.sect .text
.define .xor

        ! #bytes in ecx
.xor:
        pop     ebx             ! return address
        mov     edx,edi
        mov     edi,esp
        add     edi,ecx
        sar     ecx,2
1:
        pop     eax
        xor     eax,(edi)
        stos
        loop    1b
        mov     edi,edx
        jmp     ebx
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/head/em_abs.h	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
/* $Header: em_abs.h,v 1.3 87/03/10 08:58:45 ceriel Exp $ */
/*
 * (c) copyright 1987 by the Vrije Universiteit, Amsterdam, The Netherlands.
 * See the copyright notice in the ACK home directory, in the file "Copyright".
 */
#define LINO_AD         0
#define FILN_AD         4

#define LINO            (*(int    *)(_hol0()+LINO_AD))
#define FILN            (*(char  **)(_hol0()+FILN_AD))

#define EARRAY          0
#define ERANGE          1
#define ESET            2
#define EIOVFL          3
#define EFOVFL          4
#define EFUNFL          5
#define EIDIVZ          6
#define EFDIVZ          7
#define EIUND           8
#define EFUND           9
#define ECONV           10

#define ESTACK          16
#define EHEAP           17
#define EILLINS         18
#define EODDZ           19
#define ECASE           20
#define EMEMFLT         21
#define EBADPTR         22
#define EBADPC          23
#define EBADLAE         24
#define EBADMON         25
#define EBADLIN         26
#define EBADGTO         27
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/head/em_head.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#
.sect .text; .sect .rom; .sect .data; .sect .bss
.define ERANGE,ESET,EHEAP,ECASE,EILLINS,EIDIVZ,EODDZ
.define .trppc, .ignmask

ERANGE          = 1
ESET            = 2
EIDIVZ          = 6
EHEAP           = 17
EILLINS         = 18
EODDZ           = 19
ECASE           = 20

#include <em_abs.h>

.sect .data
.trppc:
        .data4  0
.ignmask:
        .data4  EIOVFL | EIUND | ECONV | EFOVFL | EFUNFL
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/misc/alloca.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#
!       alloca() - allocate space on the stack          Author: Kees J. Bot
!                                                               2 Dec 1993
.sect .text; .sect .rom; .sect .data; .sect .bss

.sect .text
        .align  16
.define _alloca
_alloca:
#if __ACK__
        pop     ecx             ! Return address
        pop     eax             ! Bytes to allocate
        add     eax, 2*4+3      ! Add space for two saved register variables
        andb    al, 0xFC        ! Align
        mov     ebx, esp        ! Keep current esp
        sub     esp, eax        ! Lower stack
        mov     eax, esp        ! Return value
        push    4(ebx)          ! Push what is probably the saved esi
        push    (ebx)           ! Saved edi
                                ! Now ACK can still do:
                                !       pop edi; pop esi; leave; ret
        push    eax             ! Dummy argument
        jmp     ecx
#else
        pop     ecx             ! Return address
        pop     eax             ! Bytes to allocate
        add     eax, 3
        andb    al, 0xFC        ! Align
        sub     esp, eax        ! Lower stack
        mov     eax, esp        ! Return value
        push    eax             ! Dummy argument
        jmp     ecx
#endif
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/misc/getprocessor.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
!       getprocessor() - determine processor type       Author: Kees J. Bot
!                                                               26 Jan 1994

.sect .text; .sect .rom; .sect .data; .sect .bss
.sect .text

! int getprocessor(void);
!       Return 386, 486, 586, ...

.define _getprocessor

_getprocessor:
        push    ebp
        mov     ebp, esp
        and     esp, 0xFFFFFFFC ! Align stack to avoid AC fault
        mov     ecx, 0x00040000 ! Try to flip the AC bit introduced on the 486
        call    flip
        mov     eax, 386        ! 386 if it didn't react to "flipping"
        jz      gotprocessor
        mov     ecx, 0x00200000 ! Try to flip the ID bit introduced on the 586
        call    flip
        mov     eax, 486        ! 486 if it didn't react
        jz      gotprocessor
        pushf
        pusha                   ! Save the world
        mov     eax, 1
        .data1  0x0F, 0xA2      ! CPUID instruction tells the processor type
        andb    ah, 0x0F        ! Extract the family (5, 6, ...)
        movzxb  eax, ah
        imul    eax, 100        ! 500, 600, ...
        add     eax, 86         ! 586, 686, ...
        mov     7*4(esp), eax   ! Pass eax through
        popa
        popf
gotprocessor:
        leave
        ret

flip:
        pushf                   ! Push eflags
        pop     eax             ! eax = eflags
        mov     edx, eax        ! Save original eflags
        xor     eax, ecx        ! Flip the bit to test
        push    eax             ! Push modified eflags value
        popf                    ! Load modified eflags register
        pushf
        pop     eax             ! Get it again
        push    edx
        popf                    ! Restore original eflags register
        xor     eax, edx        ! See if the bit changed
        test    eax, ecx
        ret
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/misc/iolib.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
! Some I/O related routines like:
!       unsigned char inb(int port);
!       unsigned short inw(int port);
!       void outb(int port, int value);
!       void outw(int port, int value);
!       void rep_inb(int port, unsigned char *buf, size_t count);
!       void rep_inw(int port, unsigned short *buf, size_t count);
!       void rep_outb(int port, unsigned char *buf, size_t count);
!       void rep_outw(int port, unsigned short *buf, size_t count);
!       void intr_enable(void);
!       void intr_disable(void);

.sect .text; .sect .rom; .sect .data; .sect .bss

.sect .text
.define _inb
_inb:
        push    ebp
        mov     ebp, esp
        mov     edx, 8(ebp)             ! port
        xor     eax, eax
        inb     dx                      ! read 1 byte
        pop     ebp
        ret

.define _inw
_inw:
        push    ebp
        mov     ebp, esp
        mov     edx, 8(ebp)             ! port
        xor     eax, eax
    o16 in      dx                      ! read 1 word
        pop     ebp
        ret

.define _outb
_outb:
        push    ebp
        mov     ebp, esp
        mov     edx, 8(ebp)             ! port
        mov     eax, 8+4(ebp)           ! value
        outb    dx                      ! output 1 byte
        pop     ebp
        ret

.define _outw
_outw:
        push    ebp
        mov     ebp, esp
        mov     edx, 8(ebp)             ! port
        mov     eax, 8+4(ebp)           ! value
    o16 out     dx                      ! output 1 word
        pop     ebp
        ret

.define _rep_inb
_rep_inb:
        push    ebp
        mov     ebp, esp
        push    edi
        mov     edx, 8(ebp)             ! port
        mov     edi, 12(ebp)            ! buf
        mov     ecx, 16(ebp)            ! byte count
        rep
        inb     dx                      ! input many bytes
        pop     edi
        pop     ebp
        ret

.define _rep_inw
_rep_inw:
        push    ebp
        mov     ebp, esp
        push    edi
        mov     edx, 8(ebp)             ! port
        mov     edi, 12(ebp)            ! buf
        mov     ecx, 16(ebp)            ! byte count
        shr     ecx, 1                  ! word count
        rep
    o16 in      dx                      ! input many words
        pop     edi
        pop     ebp
        ret

.define _rep_outb
_rep_outb:
        push    ebp
        mov     ebp, esp
        push    esi
        mov     edx, 8(ebp)             ! port
        mov     esi, 12(ebp)            ! buf
        mov     ecx, 16(ebp)            ! byte count
        rep
        outb    dx                      ! output many bytes
        pop     esi
        pop     ebp
        ret

.define _rep_outw
_rep_outw:
        push    ebp
        mov     ebp, esp
        push    esi
        mov     edx, 8(ebp)             ! port
        mov     esi, 12(ebp)            ! buf
        mov     ecx, 16(ebp)            ! byte count
        shr     ecx, 1                  ! word count
        rep
    o16 out     dx                      ! output many words
        pop     esi
        pop     ebp
        ret

.define _intr_disable
_intr_disable:
        push    ebp
        mov     ebp, esp
        cli
        pop     ebp
        ret

.define _intr_enable
_intr_enable:
        push    ebp
        mov     ebp, esp
        sti
        pop     ebp
        ret
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/rts/__sigreturn.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
! This routine is the low-level code for returning from signals.  
! It calls __sigreturn, which is the normal "system call" routine.
! Both ___sigreturn and __sigreturn are needed.
.sect .text; .sect .rom; .sect .data; .sect .bss
.sect .text
.define ___sigreturn
.extern __sigreturn
___sigreturn:
        add esp, 16
        jmp __sigreturn
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/rts/_sendrec.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.define __send, __receive, __sendrec

! See ../h/com.h for C definitions
SEND = 1
RECEIVE = 2
BOTH = 3
SYSVEC = 33

SRCDEST = 8
MESSAGE = 12

!*========================================================================*
!                           _send and _receive                            *
!*========================================================================*
! _send(), _receive(), _sendrec() all save ebp, but destroy eax and ecx.
.define __send, __receive, __sendrec
.sect .text
__send:
        push    ebp
        mov     ebp, esp
        push    ebx
        mov     eax, SRCDEST(ebp)       ! eax = dest-src
        mov     ebx, MESSAGE(ebp)       ! ebx = message pointer
        mov     ecx, SEND               ! _send(dest, ptr)
        int     SYSVEC                  ! trap to the kernel
        pop     ebx
        pop     ebp
        ret

__receive:
        push    ebp
        mov     ebp, esp
        push    ebx
        mov     eax, SRCDEST(ebp)       ! eax = dest-src
        mov     ebx, MESSAGE(ebp)       ! ebx = message pointer
        mov     ecx, RECEIVE            ! _receive(src, ptr)
        int     SYSVEC                  ! trap to the kernel
        pop     ebx
        pop     ebp
        ret

__sendrec:
        push    ebp
        mov     ebp, esp
        push    ebx
        mov     eax, SRCDEST(ebp)       ! eax = dest-src
        mov     ebx, MESSAGE(ebp)       ! ebx = message pointer
        mov     ecx, BOTH               ! _sendrec(srcdest, ptr)
        int     SYSVEC                  ! trap to the kernel
        pop     ebx
        pop     ebp
        ret
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/rts/brksize.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
.sect .text; .sect .rom; .sect .data; .sect .bss
.define __brksize
.sect .data
.extern endbss, __brksize
__brksize: .data4 endbss
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/rts/crtso.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
! This is the C run-time start-off routine.  It's job is to take the
! arguments as put on the stack by EXEC, and to parse them and set them up the
! way _main expects them.
! It also initializes _environ when this variable isn't defined by the
! programmer.  The detection of whether _environ belong to us is rather
! simplistic.  We simply check for some magic value, but there is no other
! way.

.sect .text; .sect .rom; .sect .data; .sect .bss

.define begtext, begdata, begbss
.sect .text
begtext:
.sect .rom
begrom:
.sect .data
begdata:
.sect .bss
begbss:

.define crtso, ___main, __penvp, __fpu_present
.extern _main, _exit
.sect .text
crtso:
        xor     ebp, ebp                ! clear for backtrace of core files
        mov     eax, (esp)              ! argc
        lea     edx, 4(esp)             ! argv
        lea     ecx, 8(esp)(eax*4)      ! envp

        mov     (__penvp), ecx          ! save envp in __envp

        ! Test whether address of environ < address of end.
        ! This is done for separate I&D systems.
        mov     ebx, _environ
        cmp     ebx, __end
        jae     0f
        cmp     (_environ), 0x53535353  ! is it our _environ?
        jne     0f
        mov     (_environ), ecx
0:
        push    ecx                     ! push environ
        push    edx                     ! push argv
        push    eax                     ! push argc

        ! Test the EM bit of the MSW to determine if an FPU is present and
        ! set __fpu_present if one is found.
        smsw    ax
        testb   al, 0x4                 ! EM bit in MSW
        setz    al                      ! True if not set
        movb    (__fpu_present), al

        call    _main                   ! main(argc, argv, envp)

        push    eax                     ! push exit status
        call    _exit

        hlt                             ! force a trap if exit fails

___main:                                ! for GCC
        ret

.sect .rom
        .data4  0                       ! Common I&D: *NULL == 0
.sect .bss
        .comm   __penvp, 4              ! Environment vector
        .comm   __fpu_present, 4        ! FPU present flag

.extern endtext                         ! Force loading of end labels.
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/rts/setjmp.e	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
#
 mes 2,_EM_WSIZE,_EM_PSIZE
;
; layout of a setjmp buffer:
;
;  -----------------
; |      flag       |           (!0 when blocked signals saved (POSIX))
;  -----------------
; | signal mask/set |           (for Berkeley 4.[2-] / POSIX)
;  -----------------
; |                 |
; |  GTO descriptor |
; |   (SP, LB, PC)  |
; |                 |
;  -----------------
;
; setjmp saves the signalmask, PC, SP, and LB of caller, and creates a
; GTO descriptor from this.
; The big problem here is how to get the return address, i.e. the PC of
; the caller; This problem is solved by the front-end, which must pass
; it as an extra parameter to setjmp.

; a GTO descriptor must be in the global data area
gtobuf
 bss 3*_EM_PSIZE,0,0

 inp $fill_ret_area
 exp $__setjmp
 pro $__setjmp,0
#if     defined(_POSIX_SOURCE)
; save mask of currently blocked signals. 
; longjmp must restore this mask
 lol _EM_PSIZE                  ; the flag integer at offset _EM_PSIZE
 lal 0
 loi _EM_PSIZE
 stf 3*_EM_PSIZE+_EM_LSIZE
 lol _EM_PSIZE                  ; the flag integer at offset _EM_PSIZE
 zeq *1
 lal 0
 loi _EM_PSIZE
 adp 3*_EM_PSIZE
 cal $__newsigset
 asp _EM_PSIZE
1
#elif   defined(__BSD4_2)
 loc 0
 cal $sigblock
 asp _EM_WSIZE
 lfr _EM_WSIZE
 lal 0
 loi _EM_PSIZE
 stf 3*_EM_PSIZE
#endif
; create GTO descriptor for longjmp
 lxl 0
 dch            ; Local Base of caller
 lxa 0          ; Stackpointer of caller
 lal _EM_PSIZE+_EM_WSIZE
 loi _EM_PSIZE  ; Return address of caller
 lal 0
 loi _EM_PSIZE  ; address of jmpbuf
 sti 3*_EM_PSIZE        ; LB, SP, and PC stored in jmpbuf
 loc 0
 ret _EM_WSIZE  ; setjmp must return 0
 end 0

 pro $fill_ret_area,0
; put argument in function result area
 lol 0
 ret _EM_WSIZE
 end 0

 exp $longjmp
 pro $longjmp,?
#if     defined(_POSIX_SOURCE)
; restore blocked mask
 lal 0
 loi _EM_PSIZE
 lof 3*_EM_PSIZE+_EM_LSIZE
 zeq *2
 lal 0
 loi _EM_PSIZE
 adp 3*_EM_PSIZE
 cal $__oldsigset
 asp _EM_PSIZE
2
#elif   defined(__BSD4_2)
; restore signal mask
 lal 0
 loi _EM_PSIZE
 lof 3*_EM_PSIZE
 cal $_sigsetmask
 asp _EM_WSIZE
 lfr _EM_WSIZE
 asp _EM_WSIZE
#endif
 lal 0
 loi _EM_PSIZE  ; address of jmpbuf
 lae gtobuf
 blm 3*_EM_PSIZE        ; fill GTO descriptor from jmpbuf
 lol _EM_PSIZE  ; second parameter of longjmp: the return value
 dup _EM_WSIZE
 zne *3
; of course, longjmp may not return 0!
 inc
3
; put return value in function result area
 cal $fill_ret_area
 asp _EM_WSIZE
 gto gtobuf     ; there we go ...
; ASP and GTO do not damage function result area
 end 0
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/string/_memmove.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
!       _memmove()                                      Author: Kees J. Bot
!                                                               2 Jan 1994
.sect .text; .sect .rom; .sect .data; .sect .bss

! void *_memmove(void *s1, const void *s2, size_t n)
!       Copy a chunk of memory.  Handle overlap.
!
.sect .text
.define __memmove, __memcpy
        .align  16
__memmove:
        push    ebp
        mov     ebp, esp
        push    esi
        push    edi
        mov     edi, 8(ebp)     ! String s1
        mov     esi, 12(ebp)    ! String s2
        mov     ecx, 16(ebp)    ! Length
        mov     eax, edi
        sub     eax, esi
        cmp     eax, ecx
        jb      downwards       ! if (s2 - s1) < n then copy downwards
__memcpy:
        cld                     ! Clear direction bit: upwards
        cmp     ecx, 16
        jb      upbyte          ! Don't bother being smart with short arrays
        mov     eax, esi
        or      eax, edi
        testb   al, 1
        jnz     upbyte          ! Bit 0 set, use byte copy
        testb   al, 2
        jnz     upword          ! Bit 1 set, use word copy
uplword:shrd    eax, ecx, 2     ! Save low 2 bits of ecx in eax
        shr     ecx, 2
        rep
        movs                    ! Copy longwords.
        shld    ecx, eax, 2     ! Restore excess count
upword: shr     ecx, 1
        rep
    o16 movs                    ! Copy words
        adc     ecx, ecx        ! One more byte?
upbyte: rep
        movsb                   ! Copy bytes
done:   mov     eax, 8(ebp)     ! Absolutely noone cares about this value
        pop     edi
        pop     esi
        pop     ebp
        ret

! Handle bad overlap by copying downwards, don't bother to do word copies.
downwards:
        std                     ! Set direction bit: downwards
        lea     esi, -1(esi)(ecx*1)
        lea     edi, -1(edi)(ecx*1)
        rep
        movsb                   ! Copy bytes
        cld
        jmp     done
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/string/_strncat.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
!       _strncat()                                      Author: Kees J. Bot
!                                                               1 Jan 1994
.sect .text; .sect .rom; .sect .data; .sect .bss

! char *_strncat(char *s1, const char *s2, size_t edx)
!       Append string s2 to s1.
!
.sect .text
.define __strncat
        .align  16
__strncat:
        push    ebp
        mov     ebp, esp
        push    esi
        push    edi
        mov     edi, 8(ebp)     ! String s1
        mov     ecx, -1
        xorb    al, al          ! Null byte
        cld
        repne
        scasb                   ! Look for the zero byte in s1
        dec     edi             ! Back one up (and clear 'Z' flag)
        push    edi             ! Save end of s1
        mov     edi, 12(ebp)    ! edi = string s2
        mov     ecx, edx        ! Maximum count
        repne
        scasb                   ! Look for the end of s2
        jne     no0
        inc     ecx             ! Exclude null byte
no0:    sub     edx, ecx        ! Number of bytes in s2
        mov     ecx, edx
        mov     esi, 12(ebp)    ! esi = string s2
        pop     edi             ! edi = end of string s1
        rep
        movsb                   ! Copy bytes
        stosb                   ! Add a terminating null
        mov     eax, 8(ebp)     ! Return s1
        pop     edi
        pop     esi
        pop     ebp
        ret
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/string/_strncmp.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
!       strncmp()                                       Author: Kees J. Bot
!                                                               1 Jan 1994
.sect .text; .sect .rom; .sect .data; .sect .bss

! int strncmp(const char *s1, const char *s2, size_t ecx)
!       Compare two strings.
!
.sect .text
.define __strncmp
        .align  16
__strncmp:
        push    ebp
        mov     ebp, esp
        push    esi
        push    edi
        test    ecx, ecx        ! Max length is zero?
        je      done
        mov     esi, 8(ebp)     ! esi = string s1
        mov     edi, 12(ebp)    ! edi = string s2
        cld
compare:
        cmpsb                   ! Compare two bytes
        jne     done
        cmpb    -1(esi), 0      ! End of string?
        je      done
        dec     ecx             ! Length limit reached?
        jne     compare
done:   seta    al              ! al = (s1 > s2)
        setb    ah              ! ah = (s1 < s2)
        subb    al, ah
        movsxb  eax, al         ! eax = (s1 > s2) - (s1 < s2), i.e. -1, 0, 1
        pop     edi
        pop     esi
        pop     ebp
        ret
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/string/_strncpy.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
!       _strncpy()                                      Author: Kees J. Bot
!                                                               1 Jan 1994
.sect .text; .sect .rom; .sect .data; .sect .bss

! char *_strncpy(char *s1, const char *s2, size_t ecx)
!       Copy string s2 to s1.
!
.sect .text
.define __strncpy
        .align  16
__strncpy:
        mov     edi, 12(ebp)    ! edi = string s2
        xorb    al, al          ! Look for a zero byte
        mov     edx, ecx        ! Save maximum count
        cld
        repne
        scasb                   ! Look for end of s2
        sub     edx, ecx        ! Number of bytes in s2 including null
        xchg    ecx, edx
        mov     esi, 12(ebp)    ! esi = string s2
        mov     edi, 8(ebp)     ! edi = string s1
        rep
        movsb                   ! Copy bytes
        ret
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/string/_strnlen.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
!       _strnlen()                                      Author: Kees J. Bot
!                                                               1 Jan 1994
.sect .text; .sect .rom; .sect .data; .sect .bss

! size_t _strnlen(const char *s, size_t ecx)
!       Return the length of a string.
!
.sect .text
.define __strnlen
        .align  16
__strnlen:
        push    ebp
        mov     ebp, esp
        push    edi
        mov     edi, 8(ebp)     ! edi = string
        xorb    al, al          ! Look for a zero byte
        mov     edx, ecx        ! Save maximum count
        cmpb    cl, 1           ! 'Z' bit must be clear if ecx = 0
        cld
        repne
        scasb                   ! Look for zero
        jne     no0
        inc     ecx             ! Don't count zero byte
no0:    mov     eax, edx
        sub     eax, ecx        ! Compute bytes scanned
        pop     edi
        pop     ebp
        ret
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/string/bcmp.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
!       bcmp()                                          Author: Kees J. Bot
!                                                               2 Jan 1994
.sect .text; .sect .rom; .sect .data; .sect .bss

! int bcmp(const void *s1, const void *s2, size_t n)
!       Compare two chunks of memory.
!       This is a BSD routine that escaped from the kernel.  Don't use.
!       (Alas it is not without some use, it reports the number of bytes
!       after the bytes that are equal.  So it can't be simply replaced.)
!
.sect .text
.define _bcmp
        .align  16
_bcmp:
        push    ebp
        mov     ebp, esp
        push    16(ebp)
        push    12(ebp)
        push    8(ebp)
        call    _memcmp         ! Let memcmp do the work
        test    eax, eax
        jz      equal
        sub     edx, 8(ebp)     ! Memcmp was nice enough to leave "esi" in edx
        dec     edx             ! Number of bytes that are equal
        mov     eax, 16(ebp)
        sub     eax, edx        ! Number of bytes that are unequal
equal:  leave
        ret
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/string/bcopy.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
!       bcopy()                                         Author: Kees J. Bot
!                                                               2 Jan 1994
.sect .text; .sect .rom; .sect .data; .sect .bss

! void bcopy(const void *s1, void *s2, size_t n)
!       Copy a chunk of memory.  Handle overlap.
!       This is a BSD routine that escaped from the kernel.  Don't use.
!
.sect .text
.define _bcopy
        .align  16
_bcopy:
        mov     eax, 4(esp)     ! Exchange string arguments
        xchg    eax, 8(esp)
        mov     4(esp), eax
        jmp     __memmove       ! Call the proper routine
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/string/bzero.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
!       bzero()                                         Author: Kees J. Bot
!                                                               2 Jan 1994
.sect .text; .sect .rom; .sect .data; .sect .bss

! void bzero(void *s, size_t n)
!       Set a chunk of memory to zero.
!       This is a BSD routine that escaped from the kernel.  Don't use.
!
.sect .text
.define _bzero
        .align  16
_bzero:
        push    ebp
        mov     ebp, esp
        push    12(ebp)         ! Size
        push    0               ! Zero
        push    8(ebp)          ! String
        call    _memset         ! Call the proper routine
        leave
        ret
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/string/index.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
!       index()                                         Author: Kees J. Bot
!                                                               2 Jan 1994
.sect .text; .sect .rom; .sect .data; .sect .bss

! char *index(const char *s, int c)
!       Look for a character in a string.  Has suffered from a hostile
!       takeover by strchr().
!
.sect .text
.define _index
        .align  16
_index:
        jmp     _strchr
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/string/memchr.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
!       memchr()                                        Author: Kees J. Bot
!                                                               2 Jan 1994
.sect .text; .sect .rom; .sect .data; .sect .bss

! void *memchr(const void *s, int c, size_t n)
!       Look for a character in a chunk of memory.
!
.sect .text
.define _memchr
        .align  16
_memchr:
        push    ebp
        mov     ebp, esp
        push    edi
        mov     edi, 8(ebp)     ! edi = string
        movb    al, 12(ebp)     ! The character to look for
        mov     ecx, 16(ebp)    ! Length
        cmpb    cl, 1           ! 'Z' bit must be clear if ecx = 0
        cld
        repne
        scasb
        jne     failure
        lea     eax, -1(edi)    ! Found
        pop     edi
        pop     ebp
        ret
failure:xor     eax, eax
        pop     edi
        pop     ebp
        ret
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/string/memcmp.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
!       memcmp()                                        Author: Kees J. Bot
!                                                               2 Jan 1994
.sect .text; .sect .rom; .sect .data; .sect .bss

! int memcmp(const void *s1, const void *s2, size_t n)
!       Compare two chunks of memory.
!
.sect .text
.define _memcmp
        .align  16
_memcmp:
        cld
        push    ebp
        mov     ebp, esp
        push    esi
        push    edi
        mov     esi, 8(ebp)     ! String s1
        mov     edi, 12(ebp)    ! String s2
        mov     ecx, 16(ebp)    ! Length
        cmp     ecx, 16
        jb      cbyte           ! Don't bother being smart with short arrays
        mov     eax, esi
        or      eax, edi
        testb   al, 1
        jnz     cbyte           ! Bit 0 set, use byte compare
        testb   al, 2
        jnz     cword           ! Bit 1 set, use word compare
clword: shrd    eax, ecx, 2     ! Save low two bits of ecx in eax
        shr     ecx, 2
        repe
        cmps                    ! Compare longwords
        sub     esi, 4
        sub     edi, 4
        inc     ecx             ! Recompare the last longword
        shld    ecx, eax, 2     ! And any excess bytes
        jmp     last
cword:  shrd    eax, ecx, 1     ! Save low bit of ecx in eax
        shr     ecx, 1
        repe
    o16 cmps                    ! Compare words
        sub     esi, 2
        sub     edi, 2
        inc     ecx             ! Recompare the last word
        shld    ecx, eax, 1     ! And one more byte?
cbyte:  test    ecx, ecx        ! Set 'Z' flag if ecx = 0
last:   repe
        cmpsb                   ! Look for the first differing byte
        seta    al              ! al = (s1 > s2)
        setb    ah              ! ah = (s1 < s2)
        subb    al, ah
        movsxb  eax, al         ! eax = (s1 > s2) - (s1 < s2), i.e. -1, 0, 1
        mov     edx, esi        ! For bcmp() to play with
        pop     edi
        pop     esi
        pop     ebp
        ret
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/string/memcpy.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
!       memcpy()                                        Author: Kees J. Bot
!                                                               2 Jan 1994
.sect .text; .sect .rom; .sect .data; .sect .bss

! void *memcpy(void *s1, const void *s2, size_t n)
!       Copy a chunk of memory.
!       This routine need not handle overlap, so it does not handle overlap.
!       One could simply call __memmove, the cost of the overlap check is
!       negligible, but you are dealing with a programmer who believes that
!       if anything can go wrong, it should go wrong.
!
.sect .text
.define _memcpy
        .align  16
_memcpy:
        push    ebp
        mov     ebp, esp
        push    esi
        push    edi
        mov     edi, 8(ebp)     ! String s1
        mov     esi, 12(ebp)    ! String s2
        mov     ecx, 16(ebp)    ! Length
        ! No overlap check here
        jmp     __memcpy        ! Call the part of __memmove that copies up
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/string/memmove.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
!       memmove()                                       Author: Kees J. Bot
!                                                               2 Jan 1994
.sect .text; .sect .rom; .sect .data; .sect .bss

! void *memmove(void *s1, const void *s2, size_t n)
!       Copy a chunk of memory.  Handle overlap.
!
.sect .text
.define _memmove
        .align  16
_memmove:
        jmp     __memmove       ! Call common code
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/string/memset.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
!       memset()                                        Author: Kees J. Bot
!                                                               2 Jan 1994
.sect .text; .sect .rom; .sect .data; .sect .bss

! void *memset(void *s, int c, size_t n)
!       Set a chunk of memory to the same byte value.
!
.sect .text
.define _memset
        .align  16
_memset:
        push    ebp
        mov     ebp, esp
        push    edi
        mov     edi, 8(ebp)     ! The string
        movzxb  eax, 12(ebp)    ! The fill byte
        mov     ecx, 16(ebp)    ! Length
        cld
        cmp     ecx, 16
        jb      sbyte           ! Don't bother being smart with short arrays
        test    edi, 1
        jnz     sbyte           ! Bit 0 set, use byte store
        test    edi, 2
        jnz     sword           ! Bit 1 set, use word store
slword: movb    ah, al
        mov     edx, eax
        sal     edx, 16
        or      eax, edx        ! One byte to four bytes
        shrd    edx, ecx, 2     ! Save low two bits of ecx in edx
        shr     ecx, 2
        rep
        stos                    ! Store longwords.
        shld    ecx, edx, 2     ! Restore low two bits
sword:  movb    ah, al          ! One byte to two bytes
        shr     ecx, 1
        rep
    o16 stos                    ! Store words
        adc     ecx, ecx        ! One more byte?
sbyte:  rep
        stosb                   ! Store bytes
done:   mov     eax, 8(ebp)     ! Return some value you have no need for
        pop     edi
        pop     ebp
        ret
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/string/rindex.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
!       rindex()                                        Author: Kees J. Bot
!                                                               2 Jan 1994
.sect .text; .sect .rom; .sect .data; .sect .bss

! char *rindex(const char *s, int c)
!       Look for the last occurrence a character in a string.  Has suffered
!       from a hostile takeover by strrchr().
!
.sect .text
.define _rindex
        .align  16
_rindex:
        jmp     _strrchr
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/string/strcat.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
!       strcat()                                        Author: Kees J. Bot
!                                                               1 Jan 1994
.sect .text; .sect .rom; .sect .data; .sect .bss

! char *strcat(char *s1, const char *s2)
!       Append string s2 to s1.
!
.sect .text
.define _strcat
        .align  16
_strcat:
        mov     edx, -1         ! Unlimited length
        jmp     __strncat       ! Common code
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/string/strchr.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
!       strchr()                                        Author: Kees J. Bot
!                                                               1 Jan 1994
.sect .text; .sect .rom; .sect .data; .sect .bss

! char *strchr(const char *s, int c)
!       Look for a character in a string.
!
.sect .text
.define _strchr
        .align  16
_strchr:
        push    ebp
        mov     ebp, esp
        push    edi
        cld
        mov     edi, 8(ebp)     ! edi = string
        mov     edx, 16         ! Look at small chunks of the string
next:   shl     edx, 1          ! Chunks become bigger each time
        mov     ecx, edx
        xorb    al, al          ! Look for the zero at the end
        repne
        scasb
        pushf                   ! Remember the flags
        sub     ecx, edx
        neg     ecx             ! Some or all of the chunk
        sub     edi, ecx        ! Step back
        movb    al, 12(ebp)     ! The character to look for
        repne
        scasb
        je      found
        popf                    ! Did we find the end of string earlier?
        jne     next            ! No, try again
        xor     eax, eax        ! Return NULL
        pop     edi
        pop     ebp
        ret
found:  pop     eax             ! Get rid of those flags
        lea     eax, -1(edi)    ! Address of byte found
        pop     edi
        pop     ebp
        ret
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/string/strcmp.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
!       strcmp()                                        Author: Kees J. Bot
!                                                               1 Jan 1994
.sect .text; .sect .rom; .sect .data; .sect .bss

! int strcmp(const char *s1, const char *s2)
!       Compare two strings.
!
.sect .text
.define _strcmp
        .align  16
_strcmp:
        mov     ecx, -1         ! Unlimited length
        jmp     __strncmp       ! Common code
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/string/strcpy.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
!       strcpy()                                        Author: Kees J. Bot
!                                                               1 Jan 1994
.sect .text; .sect .rom; .sect .data; .sect .bss

! char *strcpy(char *s1, const char *s2)
!       Copy string s2 to s1.
!
.sect .text
.define _strcpy
        .align  16
_strcpy:
        push    ebp
        mov     ebp, esp
        push    esi
        push    edi
        mov     ecx, -1         ! Unlimited length
        call    __strncpy       ! Common code
        mov     eax, 8(ebp)     ! Return s1
        pop     edi
        pop     esi
        pop     ebp
        ret
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/string/strlen.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
!       strlen()                                        Author: Kees J. Bot
!                                                               1 Jan 1994
.sect .text; .sect .rom; .sect .data; .sect .bss

! size_t strlen(const char *s)
!       Return the length of a string.
!
.sect .text
.define _strlen
        .align  16
_strlen:
        mov     ecx, -1         ! Unlimited length
        jmp     __strnlen       ! Common code
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/string/strncat.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
!       strncat()                                       Author: Kees J. Bot
!                                                               1 Jan 1994
.sect .text; .sect .rom; .sect .data; .sect .bss

! size_t strncat(char *s1, const char *s2, size_t n)
!       Append string s2 to s1.
!
.sect .text
.define _strncat
        .align  16
_strncat:
        mov     edx, 12(esp)    ! Maximum length
        jmp     __strncat       ! Common code
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/string/strncmp.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
!       strncmp()                                       Author: Kees J. Bot
!                                                               1 Jan 1994
.sect .text; .sect .rom; .sect .data; .sect .bss

! int strncmp(const char *s1, const char *s2, size_t n)
!       Compare two strings.
!
.sect .text
.define _strncmp
        .align  16
_strncmp:
        mov     ecx, 12(esp)    ! Maximum length
        jmp     __strncmp       ! Common code
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/string/strncpy.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
!       strncpy()                                       Author: Kees J. Bot
!                                                               1 Jan 1994
.sect .text; .sect .rom; .sect .data; .sect .bss

! char *strncpy(char *s1, const char *s2, size_t n)
!       Copy string s2 to s1.
!
.sect .text
.define _strncpy
        .align  16
_strncpy:
        push    ebp
        mov     ebp, esp
        push    esi
        push    edi
        mov     ecx, 16(ebp)    ! Maximum length
        call    __strncpy       ! Common code
        mov     ecx, edx        ! Number of bytes not copied
        rep
        stosb                   ! strncpy always copies n bytes by null padding
        mov     eax, 8(ebp)     ! Return s1
        pop     edi
        pop     esi
        pop     ebp
        ret
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/string/strnlen.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
!       strnlen()                                       Author: Kees J. Bot
!                                                               1 Jan 1994
.sect .text; .sect .rom; .sect .data; .sect .bss

! size_t strnlen(const char *s, size_t n)
!       Return the length of a string.
!
.sect .text
.define _strnlen
        .align  16
_strnlen:
        mov     ecx, 8(esp)     ! Maximum length
        jmp     __strnlen       ! Common code
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
			src/lib/i386/string/strrchr.s	 	 
++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
!       strrchr()                                       Author: Kees J. Bot
!                                                               2 Jan 1994
.sect .text; .sect .rom; .sect .data; .sect .bss

! char *strrchr(const char *s, int c)
!       Look for the last occurrence a character in a string.
!
.sect .text
.define _strrchr
        .align  16
_strrchr:
        push    ebp
        mov     ebp, esp
        push    edi
        mov     edi, 8(ebp)     ! edi = string
        mov     ecx, -1
        xorb    al, al
        cld
        repne
        scasb                   ! Look for the end of the string
        not     ecx             ! -1 - ecx = Length of the string + null
        dec     edi             ! Put edi back on the zero byte
        movb    al, 12(ebp)     ! The character to look for
        std                     ! Downwards search
        repne
        scasb
        cld                     ! Direction bit back to default
        jne     failure
        lea     eax, 1(edi)     ! Found it
        pop     edi
        pop     ebp
        ret
failure:xor     eax, eax        ! Not there
        pop     edi
        pop     ebp
        ret


						