Geek Gadgets 1/ADE-1.bin/ade-dist/gdb-4.16-base.tgz/gdb-4.16-base.tar/fsf/gdb/utils/amd-udi/udi/dostip.asm

Assembly Source File | 1993-12-23 | 10.5 KB | 399 lines

;******************************************************************************
;* Copyright 1991 Advanced Micro Devices, Inc.
;*
;* This software is the property of Advanced Micro Devices, Inc  (AMD)  which
;* specifically  grants the user the right to modify, use and distribute this
;* software provided this notice is not removed or altered.  All other rights
;* are reserved by AMD.
;*
;* AMD MAKES NO WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, WITH REGARD TO THIS
;* SOFTWARE.  IN NO EVENT SHALL AMD BE LIABLE FOR INCIDENTAL OR CONSEQUENTIAL
;* DAMAGES IN CONNECTION WITH OR ARISING FROM THE FURNISHING, PERFORMANCE, OR
;* USE OF THIS SOFTWARE.
;*
;* Comments about this software should be directed to [e-mail]. If access
;* to electronic mail isn't available, send mail to:
;*
;* Advanced Micro Devices, Inc.
;* 29K Support Products
;* Mail Stop 573
;* 5900 E. Ben White Blvd.
;* Austin, TX 78741
;* 800-292-9263
;*****************************************************************************
;*       $Id: dostip.asm,v 1.2 1993/12/23 04:44:45 cassidy Exp $
;*     $Id: @(#)dostip.asm    2.7, AMD
;******************************************************************************
;*/

IFNDEF DOS386
    DOSSEG
    .MODEL    LARGE
    PUBLIC    _UDIASMConnect
    PUBLIC    _UDIASMDisconnect
    EXTRN    _UDICDisconnect:FAR
    EXTRN    _UDICConnect:FAR
    .CODE
ELSE
;
; Segment ordering and attributes for DOS386.  We make sure the
; real mode code and data comes first.  The real and
; prot mode data are together so they can be grouped.
;

rmcode    segment byte public use16
; We need to mark the first byte in rmcode to figure the real segment value
    public   rmcode_firstbyte
rmcode_firstbyte    label byte

rmcode    ends
rmdata    segment dword public use16
rmdata    ends
pmdata    segment dword public use32
pmdata    ends
pmcode    segment byte public use32
pmcode    ends
dgroup    group    rmdata,pmdata



rmcode segment        ; _UDIASMDisconnect will be in rmcode segment

ENDIF


    INCLUDE udidos.ah        ; TermStruct Definitions from DFE

_UDIASMDisconnect    LABEL   FAR
;
; Save off important stuff in structure whose address
; is given as third parameter to this function.
    mov    bx, sp
    les    bx, ss:8[bx]
    mov    es:[bx].sss, ss
    mov    es:[bx].ssp, sp
    mov    es:[bx].ssi, si
    mov    es:[bx].sdi, di
    mov    es:[bx].sbp, bp
    mov    es:[bx].sds, ds

IFNDEF DOS386
    jmp    _UDICDisconnect        ; real mode, just jump to the C routine
ELSE
    jmp    rm_UDIDisconnect    ; DOS386, jump to the real mode stub
ENDIF

_UDIASMConnect    LABEL   FAR
;
; Save off important stuff in structure whose address
; is given as third parameter to this function.
    mov    bx, sp
    les    bx, ss:12[bx]
    mov    es:[bx].sss, ss
    mov    es:[bx].ssp, sp
    mov    es:[bx].ssi, si
    mov    es:[bx].sdi, di
    mov    es:[bx].sbp, bp
    mov    es:[bx].sds, ds
IFNDEF DOS386
    jmp    _UDICConnect        ; real mode, just jump to the C routine
ELSE
    jmp    rm_UDIConnect        ; DOS386, jump to the real mode stub
ENDIF

IFDEF DOS386
    ; Note: the rest of this file is just DOS386 support

rmcode ends

;
; Data that needs to be accessed in both real
; mode and protected mode
;
rmdata    segment

    public code_selector, data_selector, call_prot
    public    segregblock
    ; these get filled in by protected mode startup code
code_selector  DW ?
data_selector  DW ?
call_prot    DD ?
segregblock    DW ?    ; ds value    ; seg reg block filled in at startup time
        DW ?    ; es value
        DW ?    ; fs value
        DW ?    ; gs value

    public TIPName
TIPName        DB  256 DUP(?)

    public TIPVecRec
TIPVecRec    DB  0,0,0,0    ; will get filled in by main
         DD  0        ; next ptr
        DD  0        ; prev ptr
        DD  TIPName    ; exeName
                ; the other entries get added by the udi_table macro below
TIPVecRecEnd    LABEL BYTE

rmdata    ends




;
; Data that is only accessed in prot mode
;
    extrn  conventional_memory:DWORD    ; set up by dx_map_physical
    extrn  stack_table: DWORD        ; set up by C-level code.

pmdata   segment
dos386glue_table LABEL DWORD    ; so we can reference it later in the udi_table macro
                ; the entries get added by the udi_table macro below
pmdata   ends



;; The udi_table macro does three things
;;    1) generates real mode entry point for each UDI function
;;       This code just sets an index in bl and jumps to rm_common
;;    2) adds an entry into the TIPVecRec to point to the above real mode entry point
;;    3) adds an entry into the dos386glue_table table which is used by the prot.mode stub
;;       to call the actual C glue routine.

udi_table    MACRO   UDIProcName,val
rmcode segment
    public    rm_&UDIProcName
rm_&UDIProcName LABEL NEAR
    mov    bl, val        ;; bl will indicate which UDI Proc was called
    jmp    short rm_common
rmcode  ends

rmdata segment
    ORG    TIPVecRec + 16 + 4*val    ;; Entry in TIPVecRec (+16 for first 4 fields)
    IF    val EQ 0
    DD    _UDIASMConnect        ;; special case for Connect
    ELSE
    IF    val EQ 1
    DD    _UDIASMDisconnect    ;; special case for Disconnect
    ELSE
    DD    rm_&UDIProcName        ;; normal entry is rm_ stub
    ENDIF
    ENDIF
rmdata ends

pmdata segment
    EXTRN    d386_&UDIProcName:NEAR
    ORG    dos386glue_table + 4*val    ;; this builds the jump table that pmstub uses
    DD    d386_&UDIProcName
pmdata ends

    ENDM

    udi_table   UDIConnect,0
    udi_table   UDIDisconnect,1
        udi_table   UDISetCurrentConnection,2
        udi_table   UDICapabilities,3
        udi_table   UDIGetErrorMsg,4
        udi_table   UDIGetTargetConfig,5
        udi_table   UDICreateProcess,6
        udi_table   UDISetCurrentProcess,7
        udi_table   UDIDestroyProcess,8
        udi_table   UDIInitializeProcess,9
        udi_table   UDIRead,10
        udi_table   UDIWrite,11
        udi_table   UDICopy,12
        udi_table   UDIExecute,13
        udi_table   UDIStep,14
        udi_table   UDIStop,15
        udi_table   UDIWait,16
        udi_table   UDISetBreakpoint,17
        udi_table   UDIQueryBreakpoint,18
        udi_table   UDIClearBreakpoint,19
        udi_table   UDIGetStdout,20
        udi_table   UDIGetStderr,21
        udi_table   UDIPutStdin,22
        udi_table   UDIStdinMode,23
        udi_table   UDIPutTrans,24
        udi_table   UDIGetTrans,25
        udi_table   UDITransMode,26


rmcode  segment
    ASSUME    nothing, CS:rmcode    ; all we know is that CS=rmcode


    ; Common real mode stub code
    ; bl is an index indicating which UDI function was called
    ; we need to switch to protected mode (ebx will be passed thru unchanged)
rm_common  PROC FAR        ; UDI always called as far (real mode)
    push    ds        ; save ds
    push    bp        ; and save bp
    push    si        ; and si, di
    push    di
                ; note: if anything else gets pushed here, you must
                ; change the MSCPARAMS macro in dos386c.c
    push    cs
    pop    ds        ; set ds = cs
    ASSUME ds:dgroup
    ; to switch to protected mode, we push a dword ptr to a block which
    ; contains the protected mode segment registers to use
    ; and we push the 48-bit protected address of pmstub
    ; then we call the call_prot routine which was returned by dx_rmlink_get

    push    cs        ; segment of seg reg block
    lea    ax, segregblock
    push    ax        ; offset of seg reg block
       push    code_selector
    lea    eax, pmstub
    push    eax
    call    call_prot
    add    sp, 10        ; unpop all things we pushed
                ; ax return code from prot mode passed thru

    pop    di        ; unpop di,si saved earlier
    pop    si
    pop    bp        ; unpop the BP we saved earlier
    pop    ds        ; unpop the DS we saved earlier
    ret             ; will do a FAR (real mode) ret to DFE

rm_common  ENDP

rmcode  ends




pmcode segment

pmstub proc far
    ; at this point ss:sp -> far return (DF) back to dos-extender
    ;           sp+6     a word of 0
    ;          sp+8     the pushed DS (of rmstub)
    ;          sp+10  parameters
    ; we pop the far return and save it away
    ; then we call the real application procedure (the params still on stack)
    ASSUME CS:pmcode, DS:dgroup
    ; first let's switch ss:esp so that ss = ds
    ; (it will still point to the same physical memory location)
    ; (we'll save the old ss:esp on the stack in case they're needed)
    mov    dx, ss
    mov     ecx, esp
    ; at this point, ecx contains the physical 32-bit address of sp
    ; (selector 60h's offset mapped directly to 1meg physical memory)

    mov    eax, conventional_memory
    cmp    eax, 0        ; if conventional memory not mapped take other path
    je    short conv_mem_unmapped

          ; This is the code that is not DPMI compatible
        ; we add the ofst of beggining of conventional memory to esp
        ; to make it SS_DATA relative and then use data_selector as the SS
        ; thus no stack switch is necessary, we just remap the old stack
    add    eax, ecx    ; this adds esp to conventional_memory
    mov    ss, data_selector
    mov    esp, eax
    jmp    short got_ss_sp
        ; now ss:esp points to same place as before but using different segment


conv_mem_unmapped:
           ; This code is DPMI compatible
           ; we actually switch to a new stack that is in the TIPs DS
           ; the number and size of these stacks was allocated at startup time.
    lea    eax, stack_table
chk_stack:
    cmp    dword ptr [eax], 0
    je    short no_stack    ; stack pointer of 0 means end of table
    mov    esi, dword ptr [eax]    ; get stack pointer
    cmp    dword ptr [esi+4], 0    ; is it marked free?
    je    short take_stack
    add    eax, 4        ; to next stack entry in table
    jmp    chk_stack

no_stack:
    mov    eax, 25        ; IPC Limitation error
    ret

take_stack:
    mov    dword ptr [esi+4], 0ffffffffh    ; mark stack in use
    mov    ss, data_selector
    mov    esp, esi    ; get stack pointer from table
                ; now we have ss = ds, so we can go to C level.

got_ss_sp:
    ; push the old ss:esp on the stack
    push    edx        ; old ss (need to push as full 32-bit for C convention)
    push    ecx        ; old esp

    ; bl still contains the UDIProcedure Index (which was set up by the rm stub)
    ; use this to get to the correct dos386glue_table routine
    xor    bh, bh
    shl    bx,1        ; *4 for indexing into DD array
    shl    bx,1
    call    dos386glue_table[bx]
    ; on return, we just need to restore the old ss:esp
    pop    ecx
    pop    edx

    cmp    conventional_memory, 0    ; if we had switched stacks
    jne    short no_stack_clear
    mov    dword ptr [esp+4], 0    ; clear the stack in use indicator

no_stack_clear:
                ; this code is identical whether we switched stacks or not
                ; we just restore the old ss:sp and return
    mov    ss, dx
    mov    esp, ecx
                ; the stack should look as it did when we entered
                ; so we just do a far ret
    ret
pmstub endp


    public    GetCS
GetCS    PROC NEAR
    mov    ax, cs
    ret
GetCS    ENDP

    public    GetDS
GetDS    PROC NEAR
    mov    ax, ds
    ret
GetDS    ENDP


    public    _exp_return
    extrn    _top:dword

_exp_return PROC FAR
    ; set the stack pointer back to its initial state as left by dfe
    ; (leave the ss unchanged)
    ; then do a far ret which will get us back to the dfe.
    ; (which will then restore its own stack).
    mov    ebp, esp
    mov    eax, [ebp+4]    ; errcode
    mov    ecx, _top
    add    ecx, 2
    mov    esp, ecx
    ret
_exp_return ENDP

pmcode ends


rmdata   segment
;
; Symbol marking end of real mode code & data,
; used at link time to specify the real mode
; code & data size
;
    public    end_real
end_real label    byte
rmdata   ends



ENDIF    ; end of DOS386 conditional code

    END