Oakland CPM Archive/oakcpm.iso/cpm/22rsx/rsx12.ark/RELOCCP.MAC

Text File | 1985-11-09 | 9.1 KB | 342 lines

    title    'RELOCCP 1.2 - load programs below CCP (84/07/28)'
; ***********************************************
; * Copyright (C) 1982,1984            *
; *                        *
; * by    C.B. Falconer        [phone]    *
; *    680 Hartford Tpk.            *
; *    Hamden, Conn. 06517            *
; *                        *
; * All rights reserved                *
; ***********************************************
;
; Relocate a program, by pages, to reside below BDOS. The program
; is loaded below CCP, assumed present.  The program to be relocated
; is at 0200h up, and is assembled as if it begins at location 0.
; Following the program code proper is a relocation bit map.  Each
; byte specifies relocation for 8 bytes of the program, with the ms
; bit of the relocation byte corresponding to the lower of the 8
; object bytes.  See revision 1.2 below for format of program size
; and space requirement data.
;
; The bit image is formed by comparing the code image with another
; assembled for org 0.  See "makeprl" and "vect" below for details.
;
; The first execution of this system forms the relocation bit vector
; from the two images, and self-modifies to become a loader on the
; next execution.
;
; Note that any data areas to be reserved for the relocated program
; must be reserved by the pages value at 205h.
;
; If the program image extends beyond the relocated origin, this
; system will fail. It relocates first, then moves, and thus would
; self destroy its upper portion.
;
; Revisions etc
; =============
; 85/11/09    No changes. Converted to Intel mnemnonics cbf.
; 84/07/28    Ver 1.2            C.B. Falconer
;    Converted for standard code unit size data.
;    The 0 based image at location 0200h is:
;        jmp somewhere;    the entry point.
;        dw  codesize;    to be moved/relocated
;        db  pages;    of memory required, total
;    added the overlay conditional to modify application load
;
; 84/06/02     Ver 1.1            C.B. Falconer
;    converted to Zilog mnemnonic set.  Added prompt for
;    CCPLUS 1/2 page save ability.
;
    aseg;            For M80 compatibility
;
true    equ    -1
false    equ    not true
overlay    equ    false;        Handy for creating overlays
;
    if    overlay
     subttl    'Overlay system, load/execute only'
    else
     subttl    'Create relocation bits and load/execute'
    endif
;
; cp/m values
cout    equ    2
tstr    equ    9
reboot    equ    0
sysfnc    equ    5
@bdos    equ    sysfnc+1
;
; This governs the code below BDOS retained.  0 to discard CCP
ccpsiz    equ    8;        256 byte pages, preserve this
bdosiz    equ    14;        pages, normal bios/bdos relation
;
    org    0100h;        cp/m compatible
;
; Use the CCP stack so that moved/executed systems can "ret"
; This stack is limited.  CCPLUS supplies adequate room.
    lxi    h,@prgimg+3
    mov    c,m;
    inx    h
    mov    b,m;        get size
    inx    h
    mov    a,m;        get pages
    lxi    h,@prgimg
    mov    d,h
    mov    e,l;        save pointer to start
    dad    b;        ^ to 1st relocation byte
;    "    "
; (a) is pages, (bc) is size, (de) is start, (hl) is reloc bits
;    "    "
; The following location, after forming the relocation bits,
; is automatically patched to be "jmp relocup".  However it
; may be patched to a "call" instruction for system verification,
; which will then fall through to "reloc" below.  The overlaid
; verification/adjustment code may use the space from "makeprl"
; below through the end of the page.  For example the overlay
; may query the operator as to whether the CCP is to be retained,
; and if not subtract 8 from (a).  Such a system may also detect
; that CCP is already retained by the bios/bdos jump relationship,
; and automatically remove the CCP retention bias.
patch:    if    overlay;    Setup for creating an overlay
     call    adjust;        call the overlay code
    else
     jmp    makeprl;    on 1st execution only
    endif;        overlay
;    "    "        fall through as noted above
; do relocation, move and execute
; (a) is pages, (bc) is size, (de) is start, (hl) is reloc bits
relocup:
    push    h
    lxi    h,reboot
    shld    patch+1;    prevent another execution
    lhld    @bdos;        form origin for relocated
    cma;                code on page boundary
    add    h;        This trucates bdos ptr downward
    sui    ccpsiz-1;    allow for ccp retention
    pop    h;        ^ relocation bits
;    "    "
; relocate the image (de)^, length (bc), in place
; using the bit vector at (hl);
; relocate by (a) pages.
; At completion the image is ready to be moved
; into place at location (a) [entry] * 256.
; h,l
reloc:    push    b;        save length
    push    d;        save pointer to image
    push    psw;        save relocation amount
    call    vlength;    form bit vector length
reloc1:    pop    psw
    push    b;        save byte counter
    push    psw;        relocation amount
    mvi    c,8
    mov    b,m;        get reloc bits
    xchg
reloc2:    mov    a,b
    add    a
    mov    b,a
    jnc    reloc3;        dont relocate this
    pop    psw;        relocation amount
    push    psw
    add    m
    mov    m,a
reloc3:    inx    h;        next object byte
    dcr    c
    jnz    reloc2;        more bits to scan
    xchg
    inx    h;        next reloc bit vector
    pop    psw
    pop    b
    push    psw
    dcx    b
    mov    a,b
    ora    c
    jnz    reloc1;        not done
    pop    h;        h := pushed a
    mov    l,b;        zero, form origin
    pop    d;        ^image
    pop    b;        restore length
;    "    "        relocation done
    push    h;        save as execution point, move exit
;    "    "        Note that CCP return is under this
;    "    "
; move (bc) bytes from (de)^ to (hl)^
; (bc) <> 0 on entry.
; a,f,b,c,d,e,h,l
move:    ldax    d;        move relocated image
    mov    m,a
    inx    d
    inx    h
    dcx    b
    mov    a,b
    ora    c
    jnz    move
    ret;            execute relocated image
;
; form length of relocation bit vector
;  = ((bc)+7) DIV 8)
; a,f,b,c
vlength:
    push    h;        round size up to
    lxi    h,7
    dad    b;        multiple of 8
    mov    c,l
    mov    b,h
    pop    h
;    "    "
; shift (bc) right 3 places, 0s in
; a,f,b,c
bcrz3:    call    bcrz
;    "    "
; shift (bc) right 2 places, 0s in
; a,f,b,c
bcrz2:    call    bcrz
;    "    "
; shift (bc) right, inserting zero bit
; a,f,b,c
bcrz:    ora    a;        clear any carry
    mov    a,b
    rar
    mov    b,a
    mov    a,c
    rar
    mov    c,a
    ret
;
; ***************************************************************
; * After initial execution to form the relocation bit vectori    *
; * the code from here up may be overlaid by load-time code to    *
; * verify system validity, modify parameters, etc.  Caution:    *
; * the CCP stack is in use.   Typical overlay code would be:    *
; *        org    patch                    *
; *        call    whatzis;    with regs as at patch    *
; *        org    makeprl                    *
; * whatzis:    ....;            preserving stack levels *
; *        ret;        reg. state governs relocation    *
; ***************************************************************
;
    if    overlay;    insert the overlay code here
;
; Check if the CCP has already been retained, and if so adjust
; the relocation values so as not to retain the space twice
adjust:     push    psw
     push    h
     lda    reboot+2;    Page for bios system
     lxi    h,sysfnc+2
     sub    m
     pop    h
     sui    bdosiz;        If this is not exact, assume
     jnz    adjust1;    that ccp is already saved
     pop    psw
     ret
adjust1: pop    psw;        Dont need this space reserved
     sui    ccpsiz;
     ret
    else;            form the relocation bits
; make relocatable code file from double image at 0200h up
; A second image is located immediately above the zero based
; image, assembled for origin at 0100h.
makeprl: push    h
     lxi    h,relocup
     shld    patch+1;        next execution moves
     pop    h
;     "    "
; make bit vector
; at entry, (bc) = bytes to examine
;           (de) = ^0 based image
;           (hl) = ^ 0100h based image,
;                   and to start of bit
;                   vector storage area.
; At exit (hl) points to free byte above
;   the computed relocation vector.
; a,f,b,c,d,e,h,l
vect:     call    vlength;    form bit vector length
     push    b;        save vector byte counter
     push    h;        save vector storage ptr.
vect1:     lxi    b,8;        bit count and zero reloc byte
vect2:     ldax    d
     sub    m
     adi    1;        carry if difference was 1
     mov    a,b
     adc    a;        2*a+cy
     mov    b,a
     inx    d
     inx    h
     dcr    c
     jnz    vect2;        same vector byte
     pop    b;        ^ vector storage
     stax    b;        save vector byte
     inx    b
     xthl;            save ^ 1 based,
     dcx    h;        get & decrement counter
     mov    a,h
     ora    l
     xthl;            restack counter
     push    b;        and vector pointer
     jnz    vect1;        more bytes to generate
     pop    h;        point to next free byte
     pop    b;        purge stack
;     "    "
     push    h
     lxi    d,pgmsg
     mvi    c,tstr
     call    sysfnc
     pop    h
     dcx    h;        ^ last used byte
     push    h
     mov    a,h
     call    tadzs;        signal pages to save
     pop    h
     mov    a,l
     ora    a
     jm    reboot;        last 1/2 page used
     mov    a,h
     dcr    a
     push    psw
     mvi    a,'('
     call    couta;        signal usage for "SAVE nn+"
     pop    psw;          available in CCPLUS
     call    tadzs
     mvi    a,'+'
     call    couta
     mvi    a,')'
     call    couta
     jmp    reboot;        cp/m exit
;
; output (a) in decimal to console, no leading zeroes
; a,f,b,c,d,e,h,l
tadzs:     mov    l,a
     mvi    h,0
;     "    "
; output (hl) in decimal to console.
;  suppress leading zeros.
; a,f,b,c,d,e,h,l
tdzs:     lxi    b,0f00ah;    c=divisor=1 , b=iter cnt=-16
     xra    a;        clear
tdzs1:     dad    h;        m := (hl)/10; rdr to (a)
     ral;            shift off into (a)
     cmp    c;        test
     jc    tdzs2;        no bit
     sub    c;        bit = 1
     inx    h
tdzs2:     inr    b
     jm    tdzs1;        not done
     push    psw;        save output digit
     mov    a,h
     ora    l
     cnz    tdzs;        not left digit, recursive
     pop    psw;        last unlisted digit
     adi    '0'
;     "    "
; output (a) to console
; a,f,b,c,d,e,h,l
couta:     mov    e,a;        output (a) to console
     mvi    c,cout
     jmp    sysfnc;        and exit
;
pgmsg:     db    'Now SAVE $'
    endif;        Not overlay
;
; Where the zero based program image belongs.
@prgimg    equ    ($+0ffh) AND 0ff00h
    end
U