Return to xbiostst.s CVS log

Up to [HATARI the Atari ST Emulator] / hatari / tests / xbios

Annotation of hatari/tests/xbios/xbiostst.s, revision 1.1.1.1

1.1       root        1: ; Test Hatari's XBIOS functions (which can be enabled with --bios-intercept).
                      2: ; Assemble this code with TurboAss.
                      3: 
                      4:        movea.l 4(SP),A5        ; Get pointer to basepage
                      5:        move.l  $0C(A5),D0      ; Text segment length
                      6:        add.l   $14(A5),D0      ; Data segment length
                      7:        add.l   $1C(A5),D0      ; BSS segment length
                      8:        add.l   #$0800,D0       ; Space for the stack
                      9: 
                     10:        move.l  D0,D1
                     11:        add.l   A5,D1
                     12:        and.l   #-2,D1
                     13: 
                     14:        movea.l D1,SP
                     15:        move.l  D0,-(SP)
                     16:        move.l  A5,-(SP)
                     17:        clr.w   -(SP)
                     18:        move.w  #$4A,-(SP)
                     19:        trap    #1              ; Mshrink
                     20:        lea     12(SP),SP
                     21: 
                     22: 
                     23: ; Test XBIOS 255 - Send Hatari control command
                     24:        pea     hatcontrol(PC)
                     25:        move.w  #255,-(SP)
                     26:        trap    #14
                     27:        addq.l  #6,SP
                     28: 
                     29: 
                     30: ; Test XBIOS 11 - the Atari debugger XBIOS call
                     31: ; See:
                     32: ; - http://dev-docs.atariforge.org/files/Atari_Debugger_1-24-1990.pdf
                     33: ; - http://toshyp.atari.org/en/004013.html#Dbmsg
                     34: 
                     35:        ; Print string (with length encoded in msg_num), and invoke debugger
                     36:        pea     dbmsg_start(PC)
                     37:        move.w  #$F000+dbmsg_end-dbmsg_start,-(SP)
                     38:        move.w  #5,-(SP)
                     39:        move.w  #11,-(SP)
                     40:        trap    #14
                     41:        lea     10(SP),SP
                     42: 
                     43:        ; Print NUL-terminated string
                     44:        pea     dbmsg_nul(PC)
                     45:        move.w  #$F000,-(SP)
                     46:        move.w  #5,-(SP)
                     47:        move.w  #11,-(SP)
                     48:        trap    #14
                     49:        lea     10(SP),SP
                     50: 
                     51:        ; Print given value and invoke debugger
                     52:        move.l  #$DEADC0DE,-(SP)
                     53:        move.w  #$1234,-(SP)
                     54:        move.w  #5,-(SP)
                     55:        move.w  #11,-(SP)
                     56:        trap    #14
                     57:        lea     10(SP),SP
                     58: 
                     59: 
                     60:        clr.w   -(SP)
                     61:        trap    #1              ; Pterm0
                     62: 
                     63: 
                     64:        DATA
                     65: 
                     66: hatcontrol:
                     67:        DC.B "hatari-debug evaluate 23 + 19",0
                     68: 
                     69: dbmsg_start:
                     70:        DC.B "This is a Dbmsg test for a string with fixed size."
                     71: dbmsg_end:
                     72: 
                     73: dbmsg_nul:
                     74:        DC.B "This is a Dbmsg test for a NUL-terminated string.",0
                     75: 
                     76:        EVEN
                     77: 
                     78:        END

This archive runs on limited infrastructure. Preserving old code on modern bandwidth. Automated agents are requested to crawl responsibly.