.NLIST LOC,BIN .NLIST ME .SBTTL TITLE PAGE .IDENT /V2.0/ ; ; ; AUTHOR: DANIEL T. SEDLACEK ; INFORMATICS GENERAL CORP. ; 1508 KENNEDY DR., SUITE 8 ; BELLEVUE, NE 68005 ; ; TELE: (402) 291-8300 ; ; ************************************************************* ; ************************************************************* ; **** **** ; **** PLEASE SEND ALL BUGS AND/OR FIXES AS YOU FIND THEM. **** ; **** (ENHANCEMENTS WILL ALSO BE APPRECIATED) **** ; **** **** ; ************************************************************* ; ************************************************************* ; ; INITIAL DEVELOPMENT DATE: MAR-83 (VERSION 1.0) ; ; ; THIS RELEASE: JUNE 4, 1984 ; VERSION 2.0 (IAS SIG LIBRARY GROUP) ; ; FUNCTIONAL DESCRIPTION: ; ; INTERACTIVE FULL-SCREEN IAS PDP-11 DISASSEMBLER AND DEBUGGER. ; DESIGNED FOR USE WITH A VT-52 OR VT-100 COMPATABLE TERMINAL. ; ; ; ; ; MACRO COMMAND STRING: ; (NOTE THAT BOTH BUG.MAC AND MACROS.MAC ARE REQUIRED) ; ; MAC BUG,BUG/-SP=MACROS,BUG ; ; ; TASK BUILDER COMMAND STRING ; ; BUG/MU,BUG/-SP=BUG ; / ; TASK=...BUG ; // ; ; .PAGE .SBTTL MODIFICATIONS ; ; DATE PROGRAMMER DESCRIPTION ; ==== ========== =========== ; ; DEC '83 JIM UNDERWOOD & FIXED MANY BUGS ; ROGER CLAYTON OF ADDED INSTALL BY TASK NAME ; DELTA RESOURCES ADDED SYMBOL TABLE SUPPORT ; ; .PAGE .LIST LOC,BIN .SBTTL MACROS, SYMBOLS AND DATA ; ; LOCAL MACRO DEFINITIONS AND SYSTEM MACRO CALLS ; .MCALL EXIT$S,QIOW$S,GCMLB$,GCML$,CSI$,CSI$1,CSI$2 .MCALL FCSMC$ GET$S .MCALL LBLSY$,HDRSY$ .MCALL SPWN$S,WTSE$S .MCALL VSDR$S,VRCT$S,VRCD$S,VSDA$S,IHAR$S,ENAR$S,GTSK$S .MCALL VSDR$,VRCT$,DIR$ FCSMC$ ; GET FCS MACROS LBLSY$ HDRSY$ ; .MACRO GETWRD CALL G.WORD .ENDM .MACRO NOTBIT CLR TRACE BIC #20,T.PS .ENDM .MACRO ERRMSG,MSG TYPEAT CMDLNO-1,1, CALL $BELL ;IRRITATE THE OPERATOR TYPEAT CMDLNO,1, INPUT VALUE,1 TAB #CMDLNO-1,#1 ERSEOL TAB #CMDLNO,#1 ERSEOL JMP T.TBIT .ENDM .MACRO OPCODE,TXT,MASK,VALUE,MODE .NCHR LEN, .WORD <2*</2>+TEXT> .WORD MASK .WORD VALUE .WORD MODE .ASCII /TXT/ .EVEN .ENDM ; ; DIRECTIVE INDICATOR CODE TABLE MACRO ; .MACRO DIC,TEXT,CODE,SIZE .BYTE CODE,SIZE .ASCII /TEXT/ .ENDM .MACRO REG,N,?TAG ; ; REGISTER MODE (SOURCE) ; CMP #'N'00,R2 BNE TAG .IF EQ, ; PC TYPE .ENDC .IF EQ, ; SP TYPE .ENDC .IF LE, ; OTHERS TYPE .ENDC JMP PRTDST TAG: .ENDM .MACRO REG1,N,?TAG ; ; REGISTER MODE DECODE (DESTINATION) ; CMP #'N',R2 BNE TAG .IF EQ, ; PC TYPE .ENDC .IF EQ, ; SP TYPE .ENDC .IF LE, ; OTHERS TYPE .ENDC JMP SDRTN TAG: .ENDM .MACRO DEFER,N,?TAG ; ; DEFERRED MODE (SOURCE) ; CMP #1'N'00,R2 BNE TAG .IF EQ, ; PC TYPE <(PC),> .ENDC .IF EQ, ; SP TYPE <(SP),> .ENDC .IF LE, ; OTHERS TYPE <(R'N'),> .ENDC JMP PRTDST TAG: .ENDM .MACRO DEFER1,N,?TAG ; ; DEFERRED MODE (DESTINATION) ; CMP #1'N',R2 BNE TAG .IF EQ, ; PC TYPE <(PC)> .ENDC .IF EQ, ; SP TYPE <(SP)> .ENDC .IF LE, ; OTHERS TYPE <(R'N')> .ENDC JMP SDRTN TAG: .ENDM .MACRO AUTOI,N,?TAG ; ; AUTO INCREMENT (SOURCE) ; CMP #2'N'00,R2 BNE TAG .IF EQ, ; PC TYPE <(PC)+,> .ENDC .IF EQ, ; SP TYPE <(SP)+,> .ENDC .IF LE, ; OTHERS TYPE <(R'N')+,> .ENDC JMP PRTDST TAG: .ENDM .MACRO AUTOI1,N,?TAG ; ; AUTO INCREMENT (DESTINATION) ; CMP #2'N',R2 BNE TAG .IF EQ, ; PC TYPE <(PC)+> .ENDC .IF EQ, ; SP TYPE <(SP)+> .ENDC .IF LE, ; OTHERS TYPE <(R'N')+> .ENDC JMP SDRTN TAG: .ENDM .MACRO AUTID,N,?TAG ; ; AUTO INCREMENT DEFERRED (SOURCE) ; CMP #3'N'00,R2 BNE TAG .IF EQ, ; PC TYPE <@(PC)+,> .ENDC .IF EQ, ; SP TYPE <@(SP)+,> .ENDC .IF LE, ; OTHERS TYPE <@(R'N')+,> .ENDC JMP PRTDST TAG: .ENDM .MACRO AUTID1,N,?TAG ; ; AUTO INCREMENT DEFERRED (DESTINATION) ; CMP #3'N',R2 BNE TAG .IF EQ, ; PC TYPE <@(PC)+> .ENDC .IF EQ, ; SP TYPE <@(SP)+> .ENDC .IF LE, ; OTHERS TYPE <@(R'N')+> .ENDC JMP SDRTN TAG: .ENDM .MACRO AUTOD,N,?TAG ; ; AUTO DECREMENT (SOURCE) ; CMP #4'N'00,R2 BNE TAG .IF EQ, ; PC TYPE <-(PC),> .ENDC .IF EQ, ; SP TYPE <-(SP),> .ENDC .IF LE, ; OTHERS TYPE <-(R'N'),> .ENDC JMP PRTDST TAG: .ENDM .MACRO AUTOD1,N,?TAG ; ; AUTO DECREMENT (DESTINATION) ; CMP #4'N',R2 BNE TAG .IF EQ, ; PC TYPE <-(PC)> .ENDC .IF EQ, ; SP TYPE <-(SP)> .ENDC .IF LE, ; OTHERS TYPE <-(R'N')> .ENDC JMP SDRTN TAG: .ENDM .MACRO AUTDD,N,?TAG ; ; AUTO DECREMENT DEFERRED (SOURCE) ; CMP #5'N'00,R2 BNE TAG .IF EQ, ; PC TYPE <@-(PC),> .ENDC .IF EQ, ; SP TYPE <@-(SP),> .ENDC .IF LE, ; OTHERS TYPE <@-(R'N'),> .ENDC JMP PRTDST TAG: .ENDM .MACRO AUTDD1,N,?TAG ; ; AUTO DECREMENT DEFERRED (DESTINATION) ; CMP #5'N',R2 BNE TAG .IF EQ, ; PC TYPE <@-(PC)> .ENDC .IF EQ, ; SP TYPE <@-(SP)> .ENDC .IF LE, ; OTHERS TYPE <@-(R'N')> .ENDC JMP SDRTN TAG: .ENDM .MACRO INDEX,N,?TAG ; ; INDEX MODE (SOURCE) ; CMP #6'N'00,R2 BNE TAG MOV (SP)+,R0 JSR PC,DMPADR .IF EQ, ; PC TYPE <(PC),> .ENDC .IF EQ, ; SP TYPE <(SP),> .ENDC .IF LE, ; OTHERS TYPE <(R'N'),> .ENDC MOV CURADR,R0 ADD #4,R0 GETWRD MOV R1,-(SP) JMP PRTDST TAG: .ENDM .MACRO INDEX1,N,?TAG ; ; INDEX MODE (DESTINATION) ; CMP #6'N',R2 BNE TAG MOV (SP)+,R0 JSR PC,DMPADR .IF EQ, ; PC TYPE <(PC)> .ENDC .IF EQ, ; SP TYPE <(SP)> .ENDC .IF LE, ; OTHERS TYPE <(R'N')> .ENDC JMP SDRTN TAG: .ENDM .MACRO INDXD,N,?TAG ; ; INDEX DEFERRED (SOURCE) ; CMP #7'N'00,R2 BNE TAG TYPE <@> MOV (SP)+,R0 JSR PC,DMPADR .IF EQ, ; PC TYPE <(PC),> .ENDC .IF EQ, ; SP TYPE <(SP),> .ENDC .IF LE, ; OTHERS TYPE <(R'N'),> .ENDC MOV CURADR,R0 ADD #4,R0 GETWRD MOV R1,-(SP) JMP PRTDST TAG: .ENDM .MACRO INDXD1,N,?TAG ; ; INDEX DEFERRED (DESTINATION) ; CMP #7'N',R2 BNE TAG TYPE <@> MOV (SP)+,R0 JSR PC,DMPADR .IF EQ, ; PC TYPE <(PC)> .ENDC .IF EQ, ; SP TYPE <(SP)> .ENDC .IF LE, ; OTHERS TYPE <(R'N')> .ENDC JMP SDRTN TAG: .ENDM .MACRO NUM,N,?TAG ; ; RXX REG. # DECODE ; CMP #'N'00,R2 BNE TAG .IF EQ, ; PC TYPE .ENDC .IF EQ, ; SP TYPE .ENDC .IF LE, ; OTHERS TYPE .ENDC JMP PRTDST TAG: .ENDM .MACRO NUM1,N,?TAG ; ; XR REG. # DECODE ; CMP #'N',R2 BNE TAG .IF EQ, ; PC TYPE .ENDC .IF EQ, ; SP TYPE .ENDC .IF LE, ; OTHERS TYPE .ENDC JMP SDRTN TAG: .ENDM .PAGE FSRSZ$ 1 CMD: GCMLB$ 5,BUG,CMDBUF,5,,CBLEN CSI$ .EVEN CSIBLK: .BLKB C.SIZE .EVEN CMDBUF: .BLKW 41. CBLEN=.-CMDBUF BUFFER: .BLKB 512. BUFLEN = .-BUFFER BUFEND=. STBFDB: FDBDF$ FDAT$A R.VAR,,512. FDRC$A ,BUFFER,512. FDOP$A LUN.IN,CSIBLK+C.DSDS,INFILE,FO.RD,FA.ENB!FA.DLK FDBF$A 1,,1 INFDB: FDBDF$ FDRC$A FD.RWM,BUFFER,BUFLEN FDBK$A ,,,EFN.IN,INIOST FDOP$A LUN.IN,CSIBLK+C.DSDS,INFILE,FO.RD OTFDB: FDBDF$ FDAT$A ,,BUFLEN,,10. FDRC$A FD.RWM FDBK$A BUFFER,BUFLEN,,EFN.OT,OTIOST FDOP$A LUN.OT,,OTFILE,FO.WRT,FA.DLK INFILE: NMBLK$ SAMPLE,TSK OTFILE: NMBLK$ BUGTSK,TSK ; ; I/O STATUS BLOCKS ; INIOST: .BLKW 2 ; INPUT FILE OTIOST: .BLKW 2 ; OUTPUT FILE GTBUF: .BLKW 16. ; BUGFFER FOR GET-TASK-PARAMS UICGRP=GTBUF+G.TSDU+1 ;GROUP CODE UICMEM=GTBUF+G.TSDU+0 ;MEMBER CODE .PAGE ;+ ; ; SYMBOL DEFINITIONS AND DATA ; ;- ESC=33 ; ESCAPE BS=10 ; BACKSPACE CR=15 CTRLR=18. CTRLT=20. CTRLK=11. SPACE=32. MASK=2 ; OPCODE MASK OP=4 ; OPCODE VALUE MODE=6 ; SRC AND DST MODE MASK TEXT=10 ; OPCODE TEXT LINE1=8. ; FIRST LINE OF DISASSEMBLY DISMAX =23. ; LAST LINE IN DISSASSEMBLY MODE DMPL1=4 ; 1ST LINE OF DUMP DMPMAX=18. ; LINES TO DUMP CMDLNO=6 BREAK=3 ; BPT INSTRUCTION RW4K=77406 ; READ/WRITE 4K UPAR3=177646 ; USER PAGE ADDR. REG. 3 UPDR3=177606 ; USER PAGE DESC. REG. 3 EFN.IN = 1 EFN.OT = 2 EF.RUN = 3 LUN.IN = 1 LUN.OT = 2 C.PROC = 1 ; PROCEED C.EXIT = 2 ; EXIT C.READ = 3 ; READ A BUFFER C.WRIT = 4 ; CHANGE DATA E.ODD = 1 E.SEG = 2 E.TBIT= 3 E.IOT = 4 E.RESV= 5 E.EMT = 6 E.TRAP= 7 E.FLT = 10 E.PAR = 11 BUG: .RAD50 /...BUG/ ;MY NAME DEBUG: .RAD50 /BUGTSK/ GET.TI: .WORD 0 ; SLAVE'S TI: RUNCMD: .ASCII !INS BUGTSK/TASK=! ;COMMAND FOR INSTALLING COPY OF TASK TNAME: .REPT 20. .ASCII / / .ENDR RUNLEN = .-RUNCMD REMCMD: .ASCII /REM / ;COMMAND TO REMOVE TASK AFTER SESSION REMNME: .REPT 20. .ASCII / / .ENDR REMLEN=.-REMCMD BELLS: .BYTE 7,7 BELLS$=.-BELLS .EVEN INSNAM: .RAD50 /...INS/ ;INSTALL TASK'S NAME IN R5 REMNAM: .RAD50 /...REM/ ;REMOVE TASK'S NAME IN R5 RUB: .BYTE BS,SPACE,BS RUBLEN=.-RUB .EVEN ADDRS: ; ; TABLE OF CURRENT ADDRESSES DISPLAYED ; .WORD 0,0,0,0,0,0,0,0,0,0,0,0 .WORD 0,0,0,0,0,0,0,0,0,0,0,0 STATS: .BLKW 2 SIZEH: .WORD 0 SIZEL: .WORD 0 .WORD 0 VALDAT: .WORD 0 ; VALID DATA IF = 1 VALLOW: .WORD -1 ; LOW ADDRESS OF VALID DATA NEWDAT: .WORD 0 ; WORK AREA TO HOLD NEW DATA INBUF: .BLKW 45. INLEN=.-INBUF PC.CMD: .WORD 0 ; PC FROM COMMAND MODE IOSB: .BLKW 2 CMDFLG: .WORD 0 ; COMMAND MODE (FOR RE-DISPLAY) JSRFLG: .WORD 0 ; IF =1, PERFORMING A JSR JSRPC: .WORD 0 ; FOR JSR BREAKPOINT JSRVAL: .WORD 0 ; ORIGINAL CONTENTS BEFORE JSR BRKPT DMPDSP: .WORD 1000 ; DUMP ADDRESS DMPLIN: .BLKW 39. ; DUMP LINE BUFFER DL=.-DMPLIN ; DUMP BUFFER CARRET: .BYTE CR .EVEN CURADR: .WORD 0 ; CURRENT ADDRESS TOPADR: .WORD 0 ; TOP ADDRESS DISPLAYED BOTADR: .WORD 0 ; LAST ADDRESS DISPLAYED OLDADR: .WORD 0 ; PREVIOUS SCREEN START ADDRESS TBLADR: .WORD 0 ; ADDRESS OF CURRRENT OPCODE TBL ENTRY SIZE: .WORD 0 ; INSTRUCTION LENGTH WRD1: .WORD 0 ; CURRENT INSTRUCTION SAVE AREA WRD2: .WORD 0 WRD3: .WORD 0 STADD: .BLKW 3 ; USER STARTING ADDRESS INPUT TRACE: .WORD 1 ; START OUT WITH T-BIT ON ERRFLG: .WORD 0 ; ENCOUNTERED AN ERROR T.PC: .WORD 0 ; PC SAVE AREA T.PS: .WORD 0 ; PS SAVE AREA MAXGSD=2000. GSD: .REPT MAXGSD+1 .BLKW 3 .ENDR ; ; ...BUG'S RECEIVE BUFFER FROM TASK'S SST CODE ; TASK: .BLKW 2 ODATA: O.SP: .WORD 0 O.R5: .WORD 0 O.R4: .WORD 0 O.R3: .WORD 0 O.R2: .WORD 0 O.R1: .WORD 0 O.R0: .WORD 0 O.DSW: .WORD 0 ; DSW O.ERR: .WORD 0 ; ERR NUMBER O.PC: .WORD 0 ; OLD PC O.PSW: .WORD 0 ; OLD PSW ODATAL=<.-ODATA>/2 ; ; ...BUG'S SEND DATA PACKET FOR A PROCEED ; NDATA: N.SP: .WORD 0 N.R5: .WORD 0 N.R4: .WORD 0 N.R3: .WORD 0 N.R2: .WORD 0 N.R1: .WORD 0 N.R0: .WORD 0 N.DSW: .WORD 0 ; NEW DSW N.CMD: .WORD 0 ; COMMAND N.WK1: N.PC: .WORD 0 ; NEW PC N.WK2: N.PSW: .WORD 0 ; NEW PSW NDATAL=<.-NDATA>/2 QDATA: ; ; ...BUG'S COMMAND DATA PACKET ; Q.SP: .WORD 0 Q.R5: .WORD 0 Q.R4: .WORD 0 Q.R3: .WORD 0 Q.R2: .WORD 0 Q.R1: .WORD 0 Q.R0: .WORD 0 Q.DSW: .WORD 0 ; DSW Q.CMD: .WORD 0 ; COMMAND Q.WK1: Q.PC: .WORD 0 ; NEW PC Q.WK2: Q.PSW: .WORD 0 ; NEW PSW QDATAL=<.-QDATA>/2 ; ; ...BUG'S RECEIVE DATA BUFFER AFTER A REQUEST FOR DATA ; GTASK: .BLKW 2 GDATA: .BLKW ODATAL GDATAL=<.-GDATA>/2 .PAGE .SBTTL OPS - OP-CODE DECODE TABLE OPS: OPCODE ,0,0,0 OPCODE ,0,241,0 OPCODE ,0,242,0 OPCODE ,0,244,0 OPCODE ,0,250,0 OPCODE ,0,257,0 OPCODE ,0,261,0 OPCODE ,0,262,0 OPCODE ,0,264,0 OPCODE ,0,270,0 OPCODE ,0,277,0 OPCODE ,0,1,0 OPCODE ,0,2,0 OPCODE ,0,3,0 OPCODE ,0,4,0 OPCODE ,0,5,0 OPCODE ,0,6,0 OPCODE ,77,100,77 OPCODE ,7,200,7 OPCODE ,7,230,0 OPCODE ,0,240,0 OPCODE ,77,300,77 OPCODE
,377,400,0 OPCODE ,377,1000,0 OPCODE ,377,1400,0 OPCODE ,377,2000,0 OPCODE ,377,2400,0 OPCODE ,377,3000,0 OPCODE ,377,3400,0 OPCODE ,777,4000,777 OPCODE ,77,5000,77 OPCODE ,77,5100,77 OPCODE ,77,5200,77 OPCODE ,77,5300,77 OPCODE ,77,5400,77 OPCODE ,77,5500,77 OPCODE ,77,5600,77 OPCODE ,77,5700,77 OPCODE ,77,6000,77 OPCODE ,77,6100,77 OPCODE ,77,6200,77 OPCODE ,77,6300,77 OPCODE ,77,6400,0 OPCODE ,77,6500,77 OPCODE ,77,6600,77 OPCODE ,77,6700,77 OPCODE ,7777,10000,7777 OPCODE ,7777,20000,7777 OPCODE ,7777,30000,7777 OPCODE ,7777,40000,7777 OPCODE ,7777,50000,7777 OPCODE ,7777,60000,7777 OPCODE ,777,70000,777 OPCODE
,777,71000,777 OPCODE ,777,72000,777 OPCODE ,777,73000,777 OPCODE ,777,74000,777 OPCODE ,7,75000,7 OPCODE ,7,75010,7 OPCODE ,7,75020,7 OPCODE ,7,75030,7 OPCODE ,777,77000,777 OPCODE ,377,100000,0 OPCODE ,377,100400,0 OPCODE ,377,101000,0 OPCODE ,377,101400,0 OPCODE ,377,102000,0 OPCODE ,377,102400,0 OPCODE ,377,103000,0 OPCODE ,377,103400,0 OPCODE ,377,104000,0 OPCODE ,377,104400,0 OPCODE ,77,105000,77 OPCODE ,77,105100,77 OPCODE ,77,105200,77 OPCODE ,77,105300,77 OPCODE ,77,105400,77 OPCODE ,77,105500,77 OPCODE ,77,105600,77 OPCODE ,77,105700,77 OPCODE ,77,106000,77 OPCODE ,77,106100,77 OPCODE ,77,106200,77 OPCODE ,77,106300,77 OPCODE ,77,106500,77 OPCODE ,77,106600,77 OPCODE ,7777,110000,7777 OPCODE ,7777,120000,7777 OPCODE ,7777,130000,7777 OPCODE ,7777,140000,7777 OPCODE ,7777,150000,7777 OPCODE ,7777,160000,7777 .WORD 0 ; TABLE END .PAGE .SBTTL DICTBL - DECODE TABLE FOR DIRECTIVE ID CODES DTLEN = 8. ; LENGTH OF DIC ENTRY DICTBL: DIC ,83.,3 DIC ,9.,4 DIC ,7,4 DIC ,115.,1 DIC ,57.,2 DIC ,31.,2 DIC ,27.,1 DIC ,27.,2 DIC ,27.,3 DIC ,27.,4 DIC ,117.,2 DIC ,55.,2 DIC ,25.,3 DIC ,35.,2 DIC ,35.,1 DIC ,91.,3 DIC ,95.,1 DIC ,59.,2 DIC ,119.,2 DIC ,101.,1 DIC ,93.,3 DIC ,97.,1 DIC ,13.,7 DIC ,53.,2 DIC ,51.,1 DIC ,29.,2 DIC ,89.,3 DIC < FIX$S>,85.,3 DIC ,67.,4 DIC ,5,3 DIC ,127.,41. DIC ,113.,2 DIC ,65.,4 DIC ,65.,4 ; THIS IS NON-UNIQUE DIC ,125.,1 DIC ,61.,2 DIC ,63.,2 DIC ,99.,1 DIC < MAP$S>,121.,2 DIC ,23.,5 DIC < QIO$S>,1,6 DIC < QIO$S>,1,7 DIC < QIO$S>,1,8. DIC < QIO$S>,1,9. DIC < QIO$S>,1,10. DIC < QIO$S>,1,11. DIC < QIO$S>,1,12. DIC ,3,6 DIC ,3,7 DIC ,3,8. DIC ,3,9. DIC ,3,10. DIC ,3,11. DIC ,3,12. DIC ,39.,2 DIC ,37.,2 DIC ,11.,7 DIC ,81.,3 DIC ,47.,3 DIC ,171.,3 DIC < RUN$S>,17.,11. DIC ,15.,13. DIC ,33.,2 DIC ,111.,2 DIC ,45.,1 DIC ,109.,2 DIC ,11.,13. DIC ,107.,2 DIC ,69.,5 DIC ,153.,0 ; NEEDS # OF WORDS DIC ,21.,2 DIC ,137.,3 DIC ,131.,1 DIC ,135.,2 DIC ,103.,3 DIC ,105.,3 DIC ,19.,12. DIC ,123.,2 DIC ,133.,3 DIC ,75.,4 ; AKA RCVD$S DIC ,75.,5 DIC ,75.,6 DIC ,79.,4 ; AKA RCVS$S DIC ,79.,5 DIC ,79.,6 DIC ,139.,4 ; AKA RCST$S DIC ,139.,5 DIC ,139.,6 DIC ,77.,4 ; AKA RCVX$S DIC ,77.,5 DIC ,77.,6 DIC ,71.,5 ; AKA SDAT$S DIC ,71.,6 DIC ,71.,7 DIC ,71.,8. DIC ,73.,9. ; AKA SDRQ$S DIC ,73.,10. DIC ,73.,11. DIC ,73.,12. DIC ,49.,1 DIC ,43.,3 DIC ,41.,2 .WORD 0 ; END OF TABLE .PAGE FLAG$S: .WORD 0 ; FLAG $S FORM OF DIRECTIVES VALUE: .WORD 0 ; USED FOR VALUE RETRIEVAL SAVER1: .WORD 0 REGVAL: .WORD 0 ; TEMP REGISTER VALUE REG00: .WORD 0 ; REGISTER SAVE AREAS REG01: .WORD 0 REG02: .WORD 0 REG03: .WORD 0 REG04: .WORD 0 REG05: .WORD 0 REG06: .WORD 0 REGX: .WORD 0 ; DISPLACEMENT REGISTER OLDR0: .WORD 10101 ; INITTIALIZE WITH JUNK OLDR1: .WORD 10101 OLDR2: .WORD 10101 OLDR3: .WORD 10101 OLDR4: .WORD 10101 OLDR5: .WORD 10101 OLDR6: .WORD 10101 OLDR7: .WORD 10101 BRK00: .WORD 0,0 ; BREAKPOINT DATA BRK01: .WORD 0,0 BRK02: .WORD 0,0 BRK03: .WORD 0,0 BRK04: .WORD 0,0 BRK05: .WORD 0,0 BRK06: .WORD 0,0 BRK07: .WORD 0,0 DSPMOD: .WORD 0 ; DISPLAY MODE ? LINENO: .WORD 0 ; DISPLAY LINE # .PAGE .SBTTL MAIN START: GTSK$S #GTBUF ;GET TASK PARAMS(UIC) TYPECR CRLF VRCD$S #DEBUG,#TASK,#ODATAL,#GET.TI CMP @#$DSW,#IS.SUC ; SLAVE TASK ACTIVE ALREADY? BNE 10$ JMP MON1 ; YES, BEGIN MONITORING 10$: ; ; SEND MYSELF SOMETHING, JUST TO GET MY TI: ; VSDA$S #BUG,#GDATA,#3 ; SEND TO MYSELF VRCD$S #BUG,#TASK,#3,#MY.TI ; ADD TI ADDRESS IN SLAVE'S CODE FINIT$ 5$: GCML$ #CMD MOV CMD+G.CMLD,CSIBLK+C.CMLD BLE 5$ CALL FNDNAM CSI$1 #CSIBLK,#CMDBUF CSI$2 #CSIBLK,OUTPUT MOV #STATS,INFDB+F.STBK ; REQUEST STATISTICS OPEN$M #INFDB ; OPEN INPUT FILE BCC 20$ JMP CERR1 20$: MOV SIZEL,OTFDB+F.CNTG ; NEW FILE SIZE SAME AS OLD OPEN$W #OTFDB ; OPEN OUTPUT FILE BCC 30$ JMP CERR2 ;PROBLEM OPENING OUTPUT(WORK) FILE 30$: TYPECR CRLF CALL LABEL CALL HEADER LOOP: CALL COPY BCS FIN ; BRANCH IF DONE COPYING TYPE <.> BR LOOP FIN: CRLF CLOSE$ #INFDB CLOSE$ #OTFDB SPWN$S #INSNAM,,,UICGRP,UICMEM,#EF.RUN,,,#RUNCMD,#RUNLEN ; WTSE$S #EF.RUN ;WAIT TILL TASK IS INSTALLED CALL BLDGSD ;BUILD THE GLOBAL SYMBOL ; DIRECTORY(IF POSSIBLE) SPWN$S #DEBUG,,,,,#EF.RUN,#TSKEXT ; JMP MONIT ; JOIN IDLE LOOP .PAGE .SBTTL BLDGSD--BUILD THE SYMBOL TABLE FNDNAM: CALL $SAVAL MOV #TNAME,R3 MOV #REMNME,R4 MOV CMD+G.CMLD+2,R2 ; ADDR OF CMD MOV CMD+G.CMLD,R1 ; LENGTH 100$: CMPB (R2),#SPACE BEQ 200$ CMPB (R2),#'> ; END OF BUG> PROMPT BEQ 200$ CMPB (R2),#'. BEQ 300$ CMPB (R2),#'[ BEQ 175$ MOVB (R2),(R3)+ ; VALID CHARACTER MOVB (R2)+,(R4)+ 150$: SOB R1,100$ BR 300$ 175$: MOV #REMNME,R5 MOV #20.,R0 180$: MOVB #SPACE,(R5)+ SOB R0,180$ MOV #REMNME,R4 200$: MOV #TNAME,R5 MOV #20.,R0 280$: MOV #SPACE,(R5)+ SOB R0,280$ INC R2 ; SKIP UNWANTED CHARACTER MOV #TNAME,R3 BR 150$ 300$: MOV #DEBUG,R5 MOV #TNAME,R0 CLR (R5) CLR 2(R5) CLR R1 CALL $CAT5 ; CONVERT TO RAD50 MOV R1,(R5)+ BCS 400$ CLR R1 CALL $CAT5 MOV R1,(R5)+ 400$: RETURN BLDGSD: CALL $SAVAL MOV #STBFDB,R0 MOV #MAXGSD,R2 ;GET THE NUMBER OF POSSIBLE ENTRIES MOV #GSD,R5 ;GET ADDRESS OF SYMBOL TABLE MOV #^RSTB,INFILE+N.FTYP ;MAKE A STB FILE 50$: OPEN$ R0 ;ATTEMPT TO OPEN STB FILE BCS 175$ ;NOI FILE-OUTSKY CRLF TYPE 100$: GET$S ;READ NEXT REC BCC 200$ ;GOOD READ-OUT 150$: CLOSE$ ;CLOSE THE FILE CALL DOSYMB ;SEE IF THEY WANT TO DO ANOTHER SYMBOL TABLE JMP 50$ ;YES-DO IT 175$: CLR (R5)+ ;SHOW END OF GSD CLR (R5) RETURN 200$: MOV #BUFFER+2,R4 ;GET ADDRESS OF FIRST GOOD PART ;OF THE RECORD MOV F.NRBD(R0),R3 ;GET THE # BYTES READ SUB #2,R3 ;SUBTRACT FIXED PART OF RECORD BLE 150$ ;BAD REC-OUTSKY ASH #-3,R3 ;GET THE NUMBER OF ENTRIES IN THIS ; RECORD TST R3 ;ANYTHING LEFT? BEQ 150$ ;NOPE-GET OUT 250$: CMP 4(R4),#2110 ;IS THIS A GLOBAL SYMBOL?? BNE 300$ ;NOPE-DROP IT MOV (R4)+,(R5)+ ;MOV IN THE RAD50 NAME MOV (R4)+,(R5)+ TST (R4)+ ;BUMP PAST FLAG WORDS MOV (R4)+,(R5)+ ;AND THEN THE VALUE OF THE SYMBOL DEC R2 ;BUMP DOWN COUNT OF AVAIL SPACE BNE 400$ ;MORE LEFT BR 150$ ;NO MORE ROOM-GET OUT 300$: ADD #8.,R4 ;POINT TO NEXT ENTRY 400$: DEC R3 ;DE-COUNT ENTRIES THIS REC BHI 250$ ;PROCESS NEXT ENTRY JMP 100$ ;GO READ THE NEXT RECORD DOSYMB: CALL $SAVAL CLR INFILE+N.FNAM+2 ;CLEAR OUT THE NAME FROM NAMBLK CLR INFILE+N.FNAM CLR INFILE+N.FVER ;AND ALSO VERSION NUMBER MOV #^RSTB,INFILE+N.FTYP ;AND DEFAULT EXTENSION = .STB CRLF TYPE CRLF GCML$ #CMD MOV CMD+G.CMLD,CSIBLK+C.CMLD CSI$1 #CSIBLK,#CMDBUF CSI$2 #CSIBLK,OUTPUT CLC RETURN .PAGE .SBTTL LABEL - PROCESS TASK LABEL DESCRIPTOR BLOCK LABEL: ; ; PROCESS LABEL BLOCK ; CALL READIN ;READ A BLOCK FROM TASK-IMAGE FILE BCS 40$ ;PRE-MATURE EOF ON INPUT MOVB #255.,L$BPOL+BUFFER ;SET POOL LIMIT TO 255.(IN HOPES OF AVOIDING ; ANY NODE PROBLEMS MOV BUFFER+L$BHRB,R1 ;GET BLOCK # OF START OF TASK HEADER CALL WRTOUT ;WRITE A COPY TO OUTPUT (WORK) FILE DEC R1 ;ACOUNT FOR ONE WE JUST READ 10$: DEC R1 ; COPY UP TO HEADER BLOCK BEQ 20$ ;WHEN .EQ. ,FIRST BLK OF TASK HEADER WILL ;BE NEXT BLOCK TO BE READ CALL COPY ;READ INPUT,WRITE TO OUTPUT BR 10$ 20$: RETURN 40$: JMP CERR3 ;PREMATURE EOF ON INPUT CERR1: TYPECR JMP EEXIT CERR2: CMP #INFDB,R0 ;WAS ERROR ON INPUT OR OUTPUT? BNE 50$ ;MUST BE OUTPUT TYPECR BR 100$ ;NOW PRINT ERROR 50$: TYPECR 100$: MOV F.ERR(R0),R1 ;GET ERROR CODE FROM FDB CRLF TYPE DMPR1 ;AND OUPUT IT TO TERMINAL CRLF JMP ERREX1 ;DO COMMON ERROR EXIT CERR3: TYPECR JMP ERREX1 CERR4: CRLF TYPECR EEXIT: ERREX1: DELET$ #OTFDB ;DELETE THE WORK FILE(IF ANY) ERREX2: CLOSE$ #INFDB ;AND CLOSE OUR INPUT(IF OPEN) EXIT$S ;EXIT THE SYSTEM(GRACEFULLY) .PAGE .SBTTL HEADER - PROCESS TASK HEADER/INSERT TASK-RESIDENT CODE HEADER: ; ; PROCESS HEADER BLOCK ; CALL READIN ;READ FIRST BLOCK OF TASK HEADER BCS 15$ ;PREMATURE EOF MOV #BUFFER,R0 ; BASE ADDRESS CMP H.ISP(R0),#1000 ; IS THE STACK LARGE ENOUGH? BPL 20$ JMP CERR4 ;STACK TOO SMALL 15$: JMP CERR3 ;PREMATURE EOF ON INPUT 20$: ; ;NOW INITIALIZE TASK PS/PC TO RUN TASK-RESIDENT CODE WHEN TASK IS LOADED ; MOV H.IPS(R0),INI.PS+2 ; INITIAL PSW MOV H.IPC(R0),INI.PC+2 ; PRESERVE INITIAL PC MOV #PC.GO,H.TPC(R0) ; CHANGE STARTING PC MOV #PC.GO,H.IPC(R0) ; ; ADD DEBUGGING SST VECTOR FOR TASK UNDER TEST ; MOV #SST.GO,H.DSV(R0) ; ADDR OF SST VECTOR TABLE MOVB #9.*2,H.DVZ(R0) ; SST VECTOR TABLE SIZE ADDCOD: ; ; ADD THE SST CODE INTO TASK BEING DEBUGGED. NOTE THAT CODE IS INSERTED ; NEAR THE BOTTOM OF THE TASK'S STACK(BUT ABOVE THE LOW MEMORY POINTERS) ; AND IS PUT INTO THE WORK COPY OF THE TASK ONLY. ; MOV #SSTCPY,R0 ; START ADDR OF TASK-RESIDENT CODE IMAGE MOV #BUFFER,R1 ;GET START OF BLOCK BUFFER ;(AND START OF TASK HEADER) MOV H.HSZ(R1),R2 ;GET MOD64 HEADER SIZE ASH #6,R2 ; CONVERT TO BYTE-SIZE OF HEADER ADD #LOWMEM,R2 ;ADD IN SIZE OF LOW-MEMORY POINTERS ; ;NOW R2 HAS THE BYTE OFFSET TO WHERE WE WANT TO PUT THE TASK-RESIDENT CODE. ;SEE IF START OF TARGET AREA IS WITHIN THE CURRENT BLOCK. WE MAY HAVE TO ;POSITION INTO A SUBSEQUENT BLOCK IF TASK'S LUT OR ADB COUNT IS HIGH. ; 5$: ; CMP R2,#512. ; IS TARGET AREA IN SUBSEQUENT BLOCK? BLO 7$ ; NOPE,IN CURRENT BLK CALL WRTRD ; WRITE CURRENT BLK TO OUTPUT ; AND READ NEXT FROM INPUT SUB #512.,R2 ; BUMP DOWN OFFSET SIZE BR 5$ ; GO TRY AGAIN 7$: ; ; ;NOW WE HAVE THE TASK IMAGE BLOCK IN MEMORY INTO WHICH WE WILL PUT ALL OR PART OF ;THE TASK-RESIDENT CODE. R2 NOW HAS OFFSET TO STARTING BYTE IN CURRENT BLOCK. ; ADD R2,R1 ; POSITION INTO TASK-IMAGE STACK MOV #/2,R5 ; TOTAL CODE LENGTH IN WORDS 10$: CMP #BUFFER+512.,R1 ; END OF CURRENT BUFFER? BNE 15$ ; NO,CONTINUE MOVING CALL WRTRD ; WRITE CURRENT BLK,READ NEXT MOV #BUFFER,R1 ; INITIALIZE POINTER TO TOP OF BUFFER 15$: ; MOV (R0)+,(R1)+ ; MOVE THE CODE SOB R5,10$ CALL WRTOUT ;WRITE LAST BLOCK CONTAINING SST CODE RETURN .PAGE .ENABL LSB READIN: ;READ FROM INPUT FILE READ$ #INFDB BCC 10$ CMPB F.ERR(R0),#IE.EOF ;WAS ERROR "EOF"? BNE 30$ ;NO,FATAL SEC ;INDICATE SO RETURN WRTOUT: ;WRITE TO OUPUT WRITE$ #OTFDB BCS 30$ ;ERROR 10$: WAIT$ R0 ;R0 IS SET-UP BY READ$/WRITE$ BCS 30$ ;FATAL READ/WRITE ERROR RETURN 30$: JMP CERR2 ;REPORT FILE ERROR(R0=FDB ADDR) .DSABL LSB WRTRD: ; CALL $SAVAL ; SAVE ALL REGS THROUGH CO-ROUTINE CALL WRTOUT ; WRITE OUT CURRENT BLOCK CALL READIN ; READ IN NEXT BLOCK OF INPUT BCS 20$ ; PREMATURE EOF RETURN ; AND RESTORE R0-R5 20$: JMP CERR3 ; REPORT ERROR COPY: ; ; COPY FROM INPUT TO OUTPUT ; CALL READIN ;READ NEXT BLOCK OF INPUT BCS 20$ ;MUST BE EOF CALL WRTOUT ;WRITE TO OUTPUT 20$: RETURN .PAGE .SBTTL TASK-RESIDENT SST CODE SSTCOD: ; ; THIS AN IMAGE OF THE CODE THAT HANDLES THE TASK'S SST'S. ; IT BEGINS AT TASK RELATIVE ZERO ; THIS CODE IS POSITION INDEPENDENT ; ; ; SEND RECEIVE DATA PACKET FORMAT (IN BOTH DIRECTIONS): ; ; SP ; R5 ; R4 ; R3 ; R2 ; R1 ; R0 ; DSW ; COMMAND / ERROR # ; PC / WRK1 ; PSW / WRK2 ; .WORD 0 ; RESERVE WORD FOR DSW .WORD 0,0,0,0 ; IMPURE AREA POINTERS LOWMEM = .-SSTCOD ; LENGTH OF LOW MEMORY ; RESERVED AREA SST.GO= .-SSTCOD SSTCPY: .WORD X.ODD-SSTCOD .WORD X.SEG-SSTCOD .WORD X.TBIT-SSTCOD .WORD X.IOT-SSTCOD .WORD X.RESV-SSTCOD .WORD X.EMT-SSTCOD .WORD X.TRAP-SSTCOD .WORD X.FLT-SSTCOD .WORD X.PAR-SSTCOD X.ODD: MOV #E.ODD,-(SP) BR SENDER X.SEG: ADD #6,SP ;GET RID OF SEGMENTATION REGISTERS CMP (SP),#;DID WE TRAP DURING THE TIME WE WERE PUSHING ;DATA ON THE STACK FOR A READ? BNE 20$ ;NO MOV (SP),-(SP) ;SHUFFLE DOWN THE PC/PS MOV 4(SP),2(SP) ; CLR 4(SP) ;SIMULATE A WORD OF ZERO RTT ;AND ALLOW DEBUG TO CONTINUE 20$: MOV #E.SEG,-(SP) BR SENDER X.TBIT: CMP (SP),#PC.GO ; ARE WE IN SST SERVICE WITH T-BIT ON? BLOS X.RTT ; IGNORE IF SO MOV #E.TBIT,-(SP) BR SENDER X.IOT: MOV #E.IOT,-(SP) BR SENDER X.RESV: MOV #E.RESV,-(SP) BR SENDER X.EMT: MOV #E.EMT,(SP) ; REPLACE TRAP CODE WITH ERROR CODE BR SENDER X.TRAP: MOV #E.TRAP,(SP) ; REPLACE TRAP CODE WITH ERROR CODE BR SENDER X.FLT: MOV #E.FLT,-(SP) BR SENDER X.PROC: MOV R.PSW,-(SP) ; NEW PSW MOV R.PC,-(SP) ; NEW PC MOV R.DSW,-(SP) MOV NOENB,-(SP) CLR NOENB TST (SP)+ ;ENABLE AST'S? BNE 20$ ;NO ENAR$S ;YES 20$: MOV (SP)+,@#$DSW ;NOW RESTORE DSW X.RTT: RTT ; CONTINUE EXECUTING X.PAR: MOV #E.PAR,-(SP) SENDER: MOV @#$DSW,-(SP) ; DSW IHAR$S ; DISABLE AST'S(IF ENABLED) BCC 20$ ;THEY WEREN'T UNTIL WE DID IT INC NOENB ;OTHERWISE SHOW TASK ALREADY HAD THEM DISABLED 20$: MOV R0,-(SP) MOV R1,-(SP) MOV R2,-(SP) MOV R3,-(SP) MOV R4,-(SP) MOV R5,-(SP) MOV #22.,-(SP) ;MOVE IN STANDARD STACK CORRECTION TO GET PRE-TRAP ;SP ADD SP,(SP) ;ADD IN STACK AS IT IS NOW SEND.1: ; ; SEND DATA TO ...BUG ; MOV SP,S.DATA+S.DRBA ;ESTABLISH BUFFER ADRESS DIR$ # ;DO THE SEND ; ; WAIT FOR REPLY ; SUB #<2*NDATAL>+4,SP ;MAKE ROOM FOR RECEIVED DATA MOV SP,R.DATA+R.VSBA ;ESTABLISH BUFER ADDRESS IN DPB 10$: DIR$ # ;RECEIVE RESPONSE FROM ...BUG CMP @#$DSW,#IS.SPD ; WAS I WAITING ? BEQ 10$ CMP (SP)+,(SP)+ ;DISCARD TASK NAME MOV (SP)+,R.SP ; NEW SP MOV (SP)+,R5 MOV (SP)+,R4 MOV (SP)+,R3 MOV (SP)+,R2 MOV (SP)+,R1 MOV (SP)+,R0 MOV (SP)+,R.DSW MOV (SP)+,R.CMD MOV (SP)+,R.PC MOV (SP)+,R.PSW MOV R.SP,SP ; SP TO GROUND ZERO X.CMD: ; ; SEE WHAT ...BUG WANTS. ; ; COMMAND MEANING ; ; ; C.PROC PROCEED ; C.READ READ AND RETURN A BUFFER OF DATA (ADDRESS IN R.WK1) ; C.WRIT WRITE (DATA IN R.WK1 AND ADDRESS IN R.WK2) ; CMP #C.PROC,R.CMD ; PROCEED? BEQ X.PROC MOV R.WK1,R0 ; BASE OF DATA FOR R/W CMP #C.READ,R.CMD ; READ? BEQ X.READ CMP #C.WRIT,R.CMD ; WRITE? BEQ X.WRIT X.EXIT: EXIT$S X.WRIT: MOV R.WK2,(R0) ; STORE A WORD BR SEND.1 X.READ: MOV #ODATAL,R5 ; SEND LENGTH 10$: MOV (R0)+,-(SP) RDFAIL=. SOB R5,10$ ; MOVE ALL DATA TO STACK BR SEND.1 NOENB: .WORD 0 ; AST STATUS FLAG R.SP: .WORD 0 ; NEW SP R.DSW: .WORD 0 ; NEW DSW FROM ...BUG R.CMD: .WORD 0 ; COMMAND FROM ...BUG R.WK1: R.PC: .WORD 0 ; NEW PC R.WK2: R.PSW: .WORD 0 ; NEW PSW S.DATA: VSDR$ ...BUG,,,,,0,ODATAL,,,0 ; TELL ...BUG I'M STOPPED MY.TI = S.DATA+S.DRTI ; ADD MY TI: AT PSEUDO TASK ; BUILD TIME R.DATA: VRCT$ ...BUG,0,NDATAL PC.GO = .-SSTCOD ; ; FAKE THE FIRST INTERRUPT WITH THE PC AND PSW ON THE STACK ; AT STARTUP (PC = NORMAL TASK STARTING ADDRESS) ; THIS SECTION OF CODE IS PATCHED BY THE TASK-COPY LOGIC TO INSERT THE TRUE ; TASK STARTING PC/PSW+TBIT ; NOTE: THIS CODE (UP TO PC.GO) CAN GET OVERLAID WITH STACK SINCE ; IT IS ONLY INITIALIZATION CODE. ; INI.PS: MOV #0,-(SP) ; PSW(FROM TASK HEADER) BIS #20,(SP) ; ADD T-BIT INI.PC: MOV #0,-(SP) ; PC(FROM TASK HEADER) MOV #-1,-(SP) ; ERROR # (SINGLE STEP = -1) JMP SENDER ; FAKE 1ST INTERRUPT SSTEND = . .PAGE .SBTTL MAIN CONTROL LOOP MONIT: ; ; TASK MONITORING LOOP ; VRCT$S ,#TASK,#ODATAL,#GET.TI ; RECEIVE FROM TASK UNDER TEST CMP @#$DSW,#IS.SPD ; WAS I SUSPENDED? BEQ MONIT MON1: ; ; SLAVE TASK HAS STOPPED. BEGIN DISASSEMBLY. ; BIT #20,O.PSW ; T.BIT ON ? BNE 5$ SUB #2,O.PC ; IT WAS A BPT INSTRUCTION TST JSRFLG ; PERFORMING A JSR ? BEQ 5$ ; NO, CONTINUE CLR JSRFLG ; TURN IT OFF MOV JSRVAL,R1 ; ORIGINAL CONTENTS MOV JSRPC,R0 ; ADDRESS OF CODE CALL P.WORD ; RESTORE ORIGINAL CODE 5$: MOV #1,TRACE ; MAKE SURE TRACE IS ON BIS #20,O.PSW ; MAKE IT LOOK LIKE T-BIT MOV #NDATAL,R5 ; ODATA ---> NDATA MOV #ODATA,R0 ; FROM MOV #NDATA,R1 ; TO 10$: MOV (R0)+,(R1)+ SOB R5,10$ CALL SHOWIT ; DISSASSEMBLY AND DUMP MODE ; ; RESUME TASK BEING MONITORED ; MOV #C.PROC,N.CMD ; PROCEED ; REPLY TO TASK UNDER TEST VSDR$S #TASK,,,,,#NDATA,#NDATAL,,,GET.TI JMP MONIT ; .PAGE .SBTTL TSKEXT -- SPAWNED-TASK EXIT AST SERVICE ; ; TSKEXT: ; CMP #C.EXIT,N.CMD ; DID TASK EXIT BECAUSE WE TOLD IT TO BEQ 100$ ; YES-, THEN GET OUT TYPEAT CMDLNO,1,<** TASK EXITED SYSTEM . . . SESSION TERMINATED **>; CALL $BELL ; MAKE SOME NOISE ON THE TERMINAL TAB #23.,#1 ; GO TO BOTTOM OF SCREEN 100$: CALL REMOVT ; THEN REMOVE IT FROM SYSTEM JMP EEXIT ; AND EXIT CLEANLY $BELL: TTYI #BELLS,#BELLS$ RETURN REMOVT: SPWN$S #REMNAM,,,,,#EF.RUN,,,#REMCMD,#REMLEN ; WTSE$S #EF.RUN ; WAIT TILL TASK IS REMOVED RETURN ; AND RETURN TO CALLER .PAGE .SBTTL SHOWIT - RECVD FUNCTION CODE DISPATCH SHOWIT: ; ; DISSASSEMBLE AND ALLOW DUMP MODE ; CMP O.ERR,#E.TBIT BNE 10$ JMP T.TBIT 10$: CMP O.ERR,#E.SEG BNE 20$ JMP T.SEG 20$: CMP O.ERR,#E.ODD BNE 30$ JMP T.ODD 30$: CMP O.ERR,#E.IOT BNE 40$ JMP T.IOT 40$: CMP O.ERR,#E.RESV BNE 50$ JMP T.RESV 50$: CMP O.ERR,#E.EMT BNE 60$ JMP T.EMT 60$: CMP O.ERR,#E.TRAP BNE 70$ JMP T.TRAP 70$: CMP O.ERR,#E.FLT BNE 80$ JMP T.FLT 80$: CMP O.ERR,#E.PAR BEQ T.PAR JMP T.TBIT T.PAR: ERRMSG T.FLT: ERRMSG T.TRAP: ERRMSG T.EMT: ERRMSG T.RESV: ERRMSG T.IOT: ERRMSG T.SEG: ERRMSG T.ODD: ERRMSG .PAGE .SBTTL T.TBIT - T-BIT/COMMON SST CODE SERVICE T.TBIT: MOV #E.TBIT,O.ERR ; T-BIT INTERRUPT MOV O.PC,PC.CMD ; COMMAND MODE PC MOV O.PC,T.PC ; SAVE PC MOV O.PSW,T.PS ; SAVE PS MOV O.R0,REG00 MOV O.R1,REG01 MOV O.R2,REG02 MOV O.R3,REG03 MOV O.R4,REG04 MOV O.R5,REG05 MOV O.SP,REG06 BIT1: CALL BRKOFF ; BREAKPOINT OCCUR ? CALL DISPLY ; UPDATE DISPLAY TST TRACE ; FULL SPEED? BEQ TRTN ; YES, GO! CALL TRYCMD TST CMDFLG ; COMMAND ENTERED ? BEQ TRTN JMP BIT1 TRTN: CALL BRKON ; RESTORE BREAKPOINTS MOV REG00,OLDR0 ; SAVE OLD REGS MOV REG01,OLDR1 MOV REG02,OLDR2 MOV REG03,OLDR3 MOV REG04,OLDR4 MOV REG05,OLDR5 MOV REG06,OLDR6 MOV REG00,N.R0 ; NEW REG VALUES MOV REG01,N.R1 MOV REG02,N.R2 MOV REG03,N.R3 MOV REG04,N.R4 MOV REG05,N.R5 MOV REG06,N.SP MOV T.PC,N.PC MOV T.PS,N.PSW RETURN .PAGE .SBTTL BRKOFF - REPLACE BREAKPOINT CODE BRKOFF: ; ; RE-INSERT CODE WHERE BREAKPOINT WAS ; MOV #BRK00,R0 ; SEE IF ANY BREAKPOINTS SET MOV #8.,R5 BKR1: TST (R0) ; NULL ? BEQ BKR2 MOV R0,-(SP) MOV 2(R0),R1 ; REPLACE CODE MOV (R0),R0 ; ADDRESS OF CODE CALL P.WORD ; STORE A WORD MOV (SP)+,R0 BKR2: ADD #4,R0 SOB R5,BKR1 BKRRTN: RETURN BRKON: ; ; PUT IN THE BREAKPOINTS ; MOV #BRK00,R0 ; SEE IF ANY BREAKPOINTS SET MOV #8.,R5 BRKON1: TST (R0) ; NULL ? BEQ BRKON2 CMP (R0),T.PC ; ELIMINATE IMMEDIATE BREAK BEQ BRKON2 MOV R0,-(SP) MOV (R0),R0 ; ADDRESS OF CODE MOV #BREAK,R1 ; DATA CALL P.WORD ; STORE A WORD MOV (SP)+,R0 BRKON2: ADD #4,R0 SOB R5,BRKON1 BRORTN: RETURN .PAGE .SBTTL TRYCMD - READ COMMAND CONTROL CHARACTER TRYCMD: ; ; TEST FOR COMMAND MODE (ESC); IF SO, READ AND INTERPRET ; THE COMMAND. ; QIOW$S #IO.RVB!TF.RAL!TF.RNE,#5,#1,,#IOSB,,<#INBUF,#1> CMPB #CR,INBUF ; SINGLE-STEP? BNE 5$ RETURN 5$: CALL RUBOUT ; ERASE CHARACTER ENTERED CMPB #ESC,INBUF ; ESCAPE BEQ 35$ ;++004 3 LINES REMOVED 10$: CMPB #CTRLR,INBUF ; PREVIOUS PAGE ? BNE 15$ CALL SCNUP ; SCREEN UP CALL CLRADR ; DISALLOW SIMPLE CURSOR MOVEMENT CALL DISPLY ; RE-DISPLAY BR TRYCMD 15$: CMPB #CTRLT,INBUF ; NEXT PAGE ? BNE 20$ CALL SCNDWN ; SCREEN DOWN CALL CLRADR ; DISALLOW SIMPLE CURSOR MOVEMENT CALL DISPLY ; RE-DISPLAY BR TRYCMD 20$: CMPB #CTRLK,INBUF ; UP 1 LINE ? BNE 25$ CALL WRDUP ; BACK UP 1 WORD CALL CLRADR ; DISALLOW SIMPLE CURSOR MOVEMENT CALL DISPLY ; RE-DISPLAY BR TRYCMD 25$: CMPB #'G,INBUF ; GO FULL SPEED? BNE 30$ CALL STOP ; STOP TRACING MOVB #ESC,INBUF ; FLIP TO DISSASSEMBLY MODE RETURN 30$: CMPB #'J,INBUF ; GO THRU JSR FULL SPEED ? BNE 32$ CALL STOP ; STOP TRACING MOVB #ESC,INBUF ; FLIP TO DISSASSEMBLY MODE ; ; ADD A BREAKPOINT AT INSTRUCTION AFTER THE JSR ; MOV T.PC,JSRPC ; ADD ADDRESS TO TABLE ADD #4,JSRPC ; INSTRUCTION AFTER JSR MOV JSRPC,R0 ; SAVE THE WORD AT BREAK CALL G.WORD ; GET ORIGINAL WORD MOV R1,JSRVAL ; ORIGINAL CONTENTS MOV #BREAK,R1 ; ADD THE BREAKPOINT MOV JSRPC,R0 ; AFTER THE JSR CALL P.WORD ; STORE A WORD INC JSRFLG ; FLAG TO BREAKPOINT RETURN 31$: JMP 50$ 32$: ; MOV #700$,R0 ;GET ADDRESS OF COMMAND TABLE MOV #L700,R1 ;AND THE LENGTH OF IT TOO 33$: CMPB (R0)+,INBUF ;SEE IF IT'S A VALID(POTENTIALLY)COMMAND BEQ 31$ ;YES-KEEP IT SOB R1,33$ ;KEEP LOOKING ;FELL THROUGH ; SO ASSUME HELP ; CALL HELP ; DISPLAY HELP SCREEN CALL CLRADR ; DISALLOW SIMPLE CURSOR MOVEMENT CALL DISPLY ; REDISPLAY BR TRYCMD 35$: CLEAR TYPE CALL DMPMEM ; MEMORY DUMP ROUTINE TAB #1,#10. 40$: CALL COMMD ; GET A COMMAND TAB #1,#10. ERSEOL CMPB #ESC,INBUF ; ESCAPE BNE 45$ ; EXIT COMMAND MODE JMP NEWRTN 45$: JMP 35$ ; TRY FOR MORE 50$: TYPEAT CMDLNO,1, TTYI #INBUF,#1 QIOW$S #IO.RVB,#5,#1,,#IOSB,,<#INBUF+1,#INLEN-1> INC IOSB+2 CALL COMMD2 TAB #CMDLNO,#1 ERSEOL CALL DISPLY ; REPOSITION CURSOR JMP TRYCMD 700$: .ASCII /BCDPQRSE/ L700=.-700$ .EVEN NEWRTN: RETURN RUBOUT: ; ; ERASE LAST CHARACTER ENTERED ; TTYI #RUB,#RUBLEN RETURN .PAGE .SBTTL HELP - MENU DISPLAY ROUTINE HELP: ; ; H E L P MENU ; CLEAR TYPEAT 1,20., TYPEAT 4,1, TYPEAT 6,1, HLP1: TYPEAT 8.,1, TYPEAT 10.,1, TYPEAT 12.,1, TYPEAT 14.,1, TYPEAT 16.,1, TYPEAT 18.,1, TYPEAT 4,35., HLP2: TYPEAT 6,35., TYPEAT 8.,35., TYPEAT 10.,35., TYPEAT 12.,35., TYPEAT 14.,35., HLP3: TYPEAT 15.,35.,< (R0-R7 AND PC,SP,RX)> TYPEAT 16.,35., TYPEAT 17.,35.,< RESET TO 0 TO CANCEL (B0=0)> HLP4: TYPEAT 18.,35., TYPEAT 22.,20., INPUT VALUE,1 RETURN .PAGE CLRADR: ; ; CLEAR ADDRESSES THAT ARE CURRENTLY DISPLAYED ; MOV #ADDRS,R0 ; TABLE OF CURRENT ADDRESSES MOV #25.,R1 ; SOB REGISTER CALOOP: CLR (R0)+ ; CLEAR DISPLAYED ADDRESS SOB R1,CALOOP RETURN WRDUP: ; ; BACKUP A WORD ; SUB #2,T.PC MOV PC.CMD,OLDADR ; COMMAND MODE PC RETURN SCNUP: ; ; DISPLAY PREVIOUS PAGE ; MOV OLDADR,T.PC ; PREVIOUS PAGE MOV PC.CMD,OLDADR ; COMMAND MODE PC RETURN SCNDWN: ; ; DISPLAY NEXT PAGE ; MOV TOPADR,OLDADR ; SET UP FOR CTRL-R MOV BOTADR,T.PC RETURN .PAGE .SBTTL COMMD - DECODE COMMAND STRING COMMD: ; ; COMMAND MODE ; QIOW$S #IO.RVB,#5,#1,,#IOSB,,<#INBUF,#INLEN> COMMD2: TST IOSB+2 ; ANY DATA ? BNE 10$ MOVB #ESC,INBUF ; GO BACK TO CODE JMP CMDRTN 10$: MOV #INBUF,R0 ; ADD A BLANK TO BUFFER ADD IOSB+2,R0 MOVB #' ,(R0) ; TO TERMINATE SOME SCANS MOVB #' ,1(R0) ; ADD 2 BLANKS MOV #INBUF+3,R0 ; ADDRESS OF NUMBER CMPB #'#,(R0) ; LOOK FOR '#' BNE 20$ INC R0 ; SKIP IT 20$: CALL $COTB ; CONVERT TO BINARY MOV R1,REGVAL ; SAVE VALUE CMP #"EX,INBUF ; EXIT ? BEQ EXIT CMP #"QU,INBUF ; QUIT ? BEQ EXIT CMP #"ST,INBUF ; STOP ? BEQ EXIT JMP NOEXIT ; ; EXIT ; EXIT: CLEAR TYPEAT 24.,1, CRLF ; ; TELL TASK BEING MONITORED TO EXIT ; MOV #C.EXIT,N.CMD ; EXIT VSDR$S #TASK,,,,,#NDATA,#NDATAL,,,GET.TI .MCALL STOP$S STOP$S ; STOP AND LET TASK EXIT AST ; FINISH UP .PAGE NOEXIT: CMP #"PC,INBUF ; PC=XXXXXX ? BNE TRYREG CHGPC: ADD REGX,REGVAL ; ADD DISPLACEMENT REGISTER MOV REGVAL,T.PC ; CHANGE RETURN PC MOV T.PC,PC.CMD ; PC IN COMMAND MODE RETURN TRYREG: CMPB #'R,INBUF ; RX=XXXXXX ? BNE TRSP CMPB #'X,INBUF+1 ; OFFSET REGISTER? BNE TR0TO5 MOV REGVAL,REGX ; DISPLACEMENT REGISTER JMP CMDRTN TR0TO5: MOVB INBUF+1,R0 ; DETERMINE WHICH REGISTER BIC #177770,R0 ; ONLY ALLOW R0-R7 CMP #7,R0 ; PC? BNE 10$ MOV #"PC,INBUF BR CHGPC 10$: ASL R0 ; SHIFT FOR WORD ALIGNMENTS ADD #REG00,R0 ; BASE ADDRESS MOV REGVAL,(R0) ; RESET REGISTER VALUE RETURN TRSP: CMP #"SP,INBUF ; STACK POINTER? BNE TRYBRK MOV REGVAL,REG06 RETURN .PAGE TRYBRK: ; ; BREAKPOINT ; CMPB #'B,INBUF ; BX=XXXXXX BEQ BRK0 JMP GOGO BRK0: ADD REGX,REGVAL ; ADD DISPLACEMENT REGISTER MOVB INBUF+1,R3 ; BREAKPOINT # BIC #177770,R3 ; 0-7 MOV #BRK00,R2 ; START OF TABLE ASH #2,R3 ; MULTIPLY BY 4 ADD R3,R2 ; INDEX CORRECT BREAKPOINT MOV REGVAL,(R2) ; ADD ADDRESS TO TABLE MOV REGVAL,R0 ; SAVE THE WORD AT BREAK CALL G.WORD ; GET ORIGINAL WORD MOV R1,2(R2) ; ORIGINAL CONTENTS RETURN GOGO: CMP #"GO,INBUF ; GO (PROCEED TO BREAK) BNE DMPER CALL STOP ; STOP TRACING MOVB #ESC,INBUF ; FLIP TO DISSASSEMBLY MODE JMP CMDRTN .PAGE DMPER: ; ; CHANGE DUMP ADDRESS "DA=XXXXXX" ; CMP #"DA,INBUF ; DUMP ADDRESS ? BNE CHGASC ; NO, EXIT CMPB #'#,INBUF+3 ; ABSOLUTE ADDRESS ? BEQ 10$ ADD REGX,REGVAL ; ADD DISPLACEMENT REGISTER 10$: MOV REGVAL,DMPDSP ; YES, SAVE ADDRESS JMP CMDRTN .PAGE CHGASC: ; ; CHANGE ASCII CA=XXXXXX,ASCII VALUE ANY LENGTH ; CMP #"CA,INBUF ; CHANGE ASCII ? BNE CHGRAD ; TRY RAD50 ; ; FIND THE VALUE ; MOV #INBUF,R5 ; INPUT BUFFER ADDRESS ADD IOSB+2,R5 ; A(TRAILING SPACE) CA1: CMPB #',,-(R5) ; FIND COMMA ? BEQ CA2 ; YES, GET VALUE CMP #INBUF+3,R5 ; DONE ? BEQ CAERR ; YES, NO COMMA BR CA1 CA2: INC R5 ; SOURCE ADDRESS MOV #INBUF,R4 ; INPUT BUFFER ADDRESS ADD IOSB+2,R4 ; A(TRAILING SPACE) ADD REGX,REGVAL ; ADD DISPLACEMENT REGISTER MOV REGVAL,R3 ; DESTINATION ADDRESS CA3: CMP R4,R5 ; DONE ? BEQ CARTN MOVB (R5)+,R2 ; GET A BYTE BIC #177400,R2 ; CLEAR UPPER BYTE MOV R3,R0 ; DESTINATION ADDRESS BIC #1,R0 ; WORD BOUNDRY CALL G.WORD ; GET A WORD BIT #1,R3 BEQ 10$ BIC #177400,R1 ; CLEAR UPPER BYTE SWAB R2 ; REPLACEMENT UPPER BYTE BR 20$ 10$: BIC #377,R1 ; CLEAR LOWER BYTE 20$: ADD R2,R1 ; ADD IN LOWER BYTE CALL P.WORD ; STORE MODIFIED WORD INC R3 BR CA3 CAERR: TYPE < MISSING COMMA!> INPUT INBUF,1 ; LET THEM SEE ERROR CARTN: JMP CMDRTN .PAGE CHGRAD: ; ; CHANGE RAD50 COMMAND CR=XXXXXX,RAD50 DATA OF ANY LENGTH ; CMP #"CR,INBUF ; CHANGE RAD50 ? BNE CHGOCT MOV #INBUF,R2 ; INPUT BUFFER ADDRESS ADD IOSB+2,R2 ; A(TRAILING SPACE) CR1: CMPB #',,-(R2) ; FIND COMMA ? BEQ CR2 ; YES, GET VALUE CMP #INBUF+3,R2 ; DONE ? BEQ CRERR ; YES, NO COMMA BR CR1 CR2: INC R2 ; SOURCE ADDRESS MOV R2,R0 ; SET UP FOR $CAT5B MOV #1,R1 ; ACCEPT "." ALSO CALL $CAT5B ; ASCII TO RAD50 ADD REGX,REGVAL ; ADD DISPLACEMENT REGISTER MOV REGVAL,R0 ; DESTINATION CALL P.WORD ; STORE NEW VALUE JMP CMDRTN CRERR: TYPE < MISSING COMMA!> INPUT INBUF,1 ; LET THEM SEE ERROR JMP CMDRTN .PAGE CHGOCT: ; ; CHANGE OCTAL VALUE CO=XXXXXX,YYYYYY ; CMP #"CO,INBUF ; CHANGE OCTAL ? BNE MAPPER ; TRY APR CHANGE ; ; FIND THE VALUE ; MOV #INBUF,R2 ; INPUT BUFFER ADDRESS ADD IOSB+2,R2 ; A(TRAILING SPACE) CO1: CMPB #',,-(R2) ; FIND COMMA ? BEQ CO2 ; YES, GET VALUE CMP #INBUF+3,R2 ; DONE ? BEQ COERR ; YES, NO COMMA BR CO1 CO2: INC R2 ; SOURCE ADDRESS MOV R2,R0 ; SET UP FOR $COTB CALL $COTB ; CONVERT TO BINARY ADD REGX,REGVAL ; ADD DISPLACEMENT REGISTER MOV REGVAL,R0 ; DESTINATION CALL P.WORD ; STORE NEW VALUE JMP CMDRTN COERR: TYPE < MISSING COMMA!> INPUT INBUF,1 ; LET THEM SEE ERROR JMP CMDRTN .PAGE MAPPER: ; ; NOTE THAT THE TASK MUST BE PRIVELEGED ; TO DO THIS REMAPPING ; CMP #"CM,INBUF ; CHANGE MAPPING ? BNE CMDERR ; NO, EXIT ADD REGX,REGVAL ; ADD DISPLACEMENT REGISTER MOV REGVAL,@#UPAR3 ; MAP TO NEW MEMORY MOV #RW4K,@#UPDR3 ; R/W 4K ACCESS JMP CMDRTN .PAGE CMDERR: ; ; COMMAND MODE ERROR ; TYPE < UNRECOGNIZED COMMAND!> INPUT INBUF,1 ; LET THEM SEE ERROR JMP CMDRTN CMDRTN: MOV #1,CMDFLG ; NEED TO RE-DISPLAY RETURN STOP: ; ; STOP TRACING ; NOTBIT RETURN .PAGE DMPMEM: ; ; DUMP MEMORY WINDOW IN OCTAL, ASCII, AND RAD50 ; MOV #DMPL1,R3 ; 1ST LINE OF DISPLAY MOV DMPDSP,R4 ; ADDRESS OF DUMP MOV #DMPMAX,R5 ; # OF LINES DM1: TAB R3,#1 ; TAB TO DATA LINE CALL DMLINE ; DUMP A LINE TTYI #DMPLIN,#DL CRLF ADD #8.,R4 ; INC MEMORY ADDRESS INC R3 ; NEXT LINE SOB R5,DM1 RETURN .PAGE DMLINE: ; ; DUMP A LINE (4 WORDS) IN OCTAL, ASCII, AND RAD50 ; R4 CONTAINS THE ADDRESS OF THE DATA. ; SAVE MOV #DMPLIN,R0 ; DESTINATION MOV #DL,R5 ; LENGTH DL1: MOVB #' ,(R0)+ ; BLANK FILL SOB R5,DL1 ; ; ADDRESS ; MOV #DMPLIN,R0 ; DESTINATION MOV R4,R1 ; DATA SUB REGX,R1 ; DISPLAY LISTING ADDRESS MOV #1,R2 ; LEADING ZEROS CALL $CBOMG ; OCTAL ; ; OCTAL ; MOV #DMPLIN+8.,R0 ; DESTINATION MOV R4,R3 ; DATA ADDRESS MOV #4,R5 ; LOOP COUNTER DL2: MOV R0,-(SP) ; SAVE R0 MOV R3,R0 ; SETUP FOR GETWRD ADD #2,R3 ; INCREMENT FOR NEXT WORD GETWRD ; GET A WORD MOV (SP)+,R0 ; RESTORE R0 MOV #1,R2 ; LEADING ZEROS CALL $CBOMG ; OCTAL CONVERSION ADD #2,R0 ; 2 SPACES BETWEEN #S SOB R5,DL2 ADD #2,R0 ; ; ASCII ; MOV R4,R3 ; DATA ADDRESS MOV #8.,R5 ; LOOP COUNTER DL3: MOV R0,-(SP) ; SAVE R0 MOV R3,R0 ; DATA ADDRESS BIC #1,R0 ; WORD BOUNDRY CALL G.WORD ; GET A WORD BIT #1,R3 BEQ 10$ SWAB R1 ; GET UPPER BYTE 10$: BIC #177400,R1 ; BYTE ONLY MOV (SP)+,R0 ; RESTORE R0 CMPB R1,#37 ; PRINTABLE ? BLE DL4 ; NO, PRINT DOT MOVB R1,(R0)+ ; GET DATA BR DL5 DL4: MOVB #'.,(R0)+ ; USE DOT DL5: INC R3 SOB R5,DL3 ADD #4,R0 ; DL6: ; ; RAD50 ; MOV R4,R3 ; DATA ADDRESS MOV #4,R5 ; LOOP COUNTER DL7: MOV R0,-(SP) ; SAVE R0 MOV R3,R0 CALL G.WORD ; GET DATA MOV (SP)+,R0 ; RESTORE R0 CALL $C5TA ; RAD50 TO ASCII ADD #2,R3 SOB R5,DL7 REST RETURN .PAGE DISPLY: ; ; UPDATE SCREEN DISPLAY ; SAVE MOV #1,DSPMOD ; DISABLE ERROR TRAPPING MOV T.PC,CURADR ; NEXT TASK RELATIVE ADDRESS TO DUMP MOV CURADR,TOPADR ; SAVE TOP & BOTTOM ADDRESSES TST CMDFLG ; NEED TO RE-DISPLAY? BNE DSP1 ; YES CALL FASTD ; TRY TO JUST MOVE CURSOR BCS DSP1 JMP DSPRTN DSP1: CLR CMDFLG ; CLEAR COMMAND MODE FLAG CLEAR CALL DSPID ; DISPLAY ID LINE CALL SCRAMB ; FORCE REWRITE OF REGS CALL DSPREG MOV #LINE1,LINENO ; BEGINNING LINE # MOV #ADDRS,R4 ; SAVE ADDRESSES CRLF DLINE: MOV LINENO,R0 CMP #DISMAX.,R0 ; LAST LINE IN DISSASSEMBLY BEQ DLDONE TAB R0,#1 MOV CURADR,R0 ; GET CURRENT ADDRESS MOV CURADR,(R4)+ ; SAVE IT IN THE TABLE MOV CURADR,BOTADR ; LATEST DISPLAYED ADDRESS CALL DECODE ; GET THE OPCODE INC LINENO ; NEXT LINE BR DLINE DLDONE: TAB #LINE1,#34. ; LINE ONE DSPRTN: REST CLR DSPMOD RETURN .PAGE SCRAMB: ; ; FORCE A MISMATCH ON OLD AND CURRENT REGISTERS ; CALL $SAVAL ; SAVE ALL REGS THROUGH CO-ROUTINE MOV #REG00,R0 MOV #OLDR0,R1 MOV #7.,R5 SCR1: MOV (R0)+,R3 COM R3 MOV R3,(R1)+ SOB R5,SCR1 RETURN FASTD: ; ; TRY TO DISPLAY WITH ONLY A CURSOR MOVEMENT ; CALL $SAVAL ; SAVE ALL REGS THROUGH CO-ROUTINE MOV #ADDRS,R0 ; TABLE OF CURRENT ADDRESSES MOV #25.,R1 ; SOB REGISTER MOV #LINE1,R3 ; 1ST LINE FDLOOP: TST (R0) ; END OF TABLE ? BEQ FDBAD CMP T.PC,(R0)+ ; SAME AS DISPLAYED ? BEQ FDGOOD INC R3 ; NEXT LINE SOB R1,FDLOOP FDGOOD: CALL DSPREG ; DISPLAY UPDATED REGS TAB R3,#34. ; POSITION CURSOR CLC ; GOOD STATUS RETURN FDBAD: SEC ; BAD STATUS RETURN .PAGE DSPREG: ; ; DISPLAY REGISTER CONTENT ON TOP OF SCREEN ; CALL $SAVAL ; SAVE ALL REGS THROUGH CO-ROUTINE DR0: CMP OLDR0,REG00 BEQ DR1 TYPEAT 3,1, MOV REG00,R1 OCVT DR1: CMP OLDR1,REG01 BEQ DR2 TYPEAT 3,15., MOV REG01,R1 OCVT DR2: CMP OLDR2,REG02 BEQ DR3 TYPEAT 3,29., MOV REG02,R1 OCVT DR3: CMP OLDR3,REG03 BEQ DR4 TYPEAT 3,43., MOV REG03,R1 OCVT DR4: CRLF CMP OLDR4,REG04 BEQ DR5 TYPEAT 4,1, MOV REG04,R1 OCVT DR5: CMP OLDR5,REG05 BEQ DR6 TYPEAT 4,15., MOV REG05,R1 OCVT DR6: CMP OLDR6,REG06 BEQ DR7 TYPEAT 4,29., MOV REG06,R1 OCVT DR7: TYPEAT 4,43., MOV T.PC,R1 OCVT DDSW: TYPEAT 3,57.,< DSW> TAB #4,#57. MOV O.DSW,R1 OCVT CRLF ; ; DUMP PROCESSOR STATUS BITS ; TYPEAT 3,71., DSPN: TAB #4,#71. BIT #10,T.PS CALL DO1OR0 ;DISPLAY 0 OR 1 DEPENDING ON Z-BIT DSPZ: TAB #4,#73. BIT #4,T.PS CALL DO1OR0 ;DISPLAY 0 OR 1 DEPENDING ON Z-BIT DSPV: TAB #4,#75. BIT #2,T.PS CALL DO1OR0 ;DISPLAY 0 OR 1 DEPENDING ON Z-BIT DSPC: TAB #4,#77. BIT #1,T.PS CALL DO1OR0 ;DISPLAY 0 OR 1 DEPENDING ON Z-BIT RETURN DO1OR0: BNE 20$ TYPE <0> BR 100$ 20$: TYPE <1> 100$: RETURN .PAGE DSPID: ; ; PRINT BUG VERSION ; CALL $SAVAL ; SAVE ALL REGS THROUGH CO-ROUTINE TYPEAT 1,1, RETURN .PAGE DECODE: ; ; DISSASSEMBLE AN INSTRUCTION. ; ENTER WITH R0 = PROGRAM RELATIVE ADDRESS. ; OUTPUT THE DISASSEMBLED INSTRUCTION ; RETURN WITH R0 = NEXT WORD ADDRESS ; SAVE MOV R0,CURADR ; SAVE CURRENT ADDRESS MOV R0,R1 ; DUMP ADDRESS SUB REGX,R1 ; DISPLAY LISTING ADDRESS OCVT TYPE <:> PUSH R0 ;SAVE WORK REG MOV R0,R1 MOV #WKBUF,R0 ;GET WORK BUFFER CALL SYMBOL ;SEE IF ADDRESS IS A DEFINED SYMBOL BCS 100$ ;NOPE TAB LINENO,#34. ;YES-PUT OUT THE LABEL SUB #WKBUF,R0 ;COMPUTE LENGTH OF SYMBOL TTYI #WKBUF,R0 ;THEN TYPE ON TERMINAL TYPE <:> 100$: POP TAB LINENO,#42. MOV #2,SIZE ; DEFAULT SIZE GETWRD MOV R1,WRD1 ; SAVE IT MOV #OPS,R0 SEARCH: TST (R0) ; END OF TABLE? BNE 10$ JMP NOFIND 10$: BIC MASK(R0),R1 ; CLEAR DON'T CARE BITS CMP OP(R0),R1 ; THIS OP CODE BEQ GOTOP MOV WRD1,R1 ; REFRESH WITH OPCODE ADD (R0),R0 ; NEXT ENTRY BR SEARCH GOTOP: ; ; GOT THE OP CODE ; MOV R0,TBLADR ; SAVE ENTRY ADDRESS MOV (R0),R1 ; CALC SIZE OF OP CODE SUB #TEXT,R1 MOV R0,R2 ; CALC ADDRESS OF TEXT ADD #TEXT,R2 TTYI R2,R1 CALL OPERND ; PROCESS THE OPERANDS DECRTN: CALL TRYEMT ; IF EMT, DECODE DIRECTIVE CRLF MOV SIZE,R5 ; INSTRUCTION LENGTH 10$: TAB LINENO,#10. ; POSITION FOR OCTAL DUMP MOV CURADR,R0 ; BEGINNING DUMP ADDRESS 20$: GETWRD OCVT ; DUMP OCTAL WORD TYPE < > ADD #2,R0 ; NEXT WORD SUB #2,R5 BNE 20$ CRLF REST MOV CURADR,R0 ; REFRESH CURRENT ADDRESS ADD SIZE,R0 ; NEXT WORD MOV R0,CURADR RETURN .PAGE TRYEMT: ; ; IF CURRENT INSTRUCTION IS AN EMT, DECODE DIRECTIVE TYPE ; CMP WRD1,EMTOP ; THIS A DIRECTIVE? BEQ 5$ JMP 50$ 5$: MOV #1,FLAG$S ; $S FORM MOV CURADR,R0 ; GET PREVIOUS WORD SUB #2,R0 GETWRD BIT #1,R1 ; $S FORM ? BNE 7$ ; YES, DECODE IT MOV R1,R0 GETWRD ; DIR$ FORM CLR FLAG$S ; NOT $S FORM 7$: TAB LINENO,#60. MOV #DICTBL,R0 ; TABLE OF DIRECTIVE INDICATOR CODES 10$: TST (R0) ; FINISHED ? BEQ 50$ ; COULDN'T FIND IT CMP (R0),R1 ; THIS DIRECTIVE? BEQ 20$ ; YES, TYPE IT ADD #DTLEN,R0 ; NEXT ENTRY BR 10$ 20$: TYPE <; **** > ADD #2,R0 ; ADDRESS OF TEXT MOV #DTLEN-2,R2 ; FULL $S FORM TST FLAG$S ; $S FORM? BNE 30$ ; YES DEC R2 ; LEAVE OFF THE "S" 30$: TTYI R0,R2 ; TYPE TEXT TYPE < ****> CRLF 50$: RETURN EMTOP: EMT 377 ; USED TO TEST FOR DIRECTIVES .PAGE NOFIND: TYPE <.WORD > MOV CURADR,R0 ; DUMP THIS WORD GETWRD MOV R1,R0 JSR PC,DMPADR JMP DECRTN OPERND: ; ; CALCULATE INSTRUCTION LENGTH ; MOV TBLADR,R0 ; OPCODE TABLE ENTRY ADDR. MOV MODE(R0),R1 ; GET MODE MASK TST R1 ; SINGLE WORD OP CODE? BEQ OPERTN OPDST: BIT #77,R1 ; LOOK AT DESTINATION BEQ OPSRC ; NO, TRY SOURCE MOV WRD1,R2 ; GET THE OP CODE BIC #177717,R2 ; DST= 6X OR 7X ? CMP #60,R2 BEQ DADD2 ; YES, ADD 2 TO LENGTH CMP #7,R1 ; REGISTER DEST MODE ? BEQ SHORT ; SINGLE WORD INSTR. MOV WRD1,R2 ; REFRESH OP CODE BIC #177700,R2 CMP #7,R2 ; DST= 07 (PC) ? BEQ OPSRC ; YES, LOOK AT SRC BIC #177770,R2 ; DST= X7 ? CMP #7,R2 BNE OPSRC ; PROCESS SOURCE FIELD DADD2: ADD #2,SIZE ; INCREMENT LENGTH OF INSTR. OPSRC: MOV TBLADR,R0 ; GET ENTRY ADDRESS MOV MODE(R0),R1 ; GET MODE MASK BIT #7000,R1 BEQ OPERTN MOV WRD1,R2 ; REFRESH OP CODE BIC #171777,R2 ; SRC = 6X OR 7X ? CMP #6000,R2 BEQ SADD2 ; YES, ADD 2 TO LENGTH MOV WRD1,R2 ; REFRESH OP CODE BIC #170077,R2 ; SRC = 07 (PC) ? CMP #700,R2 BEQ OPERTN ; YES, EXIT BIC #177077,R2 ; SRC = X7 ? CMP #700,R2 BNE OPERTN SADD2: ADD #2,SIZE ; INCREMENT SIZE OF INSTRUCTION OPERTN: MOV TBLADR,R0 CMP #6400,OP(R0) ; MARK BEQ SHORT CMP #77000,OP(R0) ; SOB BEQ SHORT JMP PRTOPS SHORT: MOV #2,SIZE ; SPECIAL CASES PRTOPS: CALL SRCDST ; PRINT THE OPERANDS RETURN SRCDST: ; ; DECODE AND PRINT THE OPERANDS ; MOV SP,R5 ; SAVE STACK POINTER MOV CURADR,R0 ; PICK UP WORD 2 ADD #2,R0 GETWRD MOV R1,-(SP) ; SAVE ON THE STACK MOV TBLADR,R0 ; LOOK AT OP CODE MOV MODE(R0),R1 ; MODE INDICATOR WORD TST R1 BNE SD1 JMP SDRTN ; NOTHING TO DO SD1: TYPE < > PRTSRC: BIT #700,R1 ; SOURCE DECODE NECESSARY? BNE RXX ; NO, TRY DESTINATION JMP PRTDST RXX: ; ; SOURCE REGISTER SPECIAL TYPES ; BIT #7000,R1 BEQ RXX1 ; MODE 07XX JMP S27 RXX1: MOV WRD1,R2 BIC #177077,R2 ; MASK OFF TO REGISTER # NUM 0 NUM 1 NUM 2 NUM 3 NUM 4 NUM 5 NUM 6 NUM 7 JMP PRTDST S27: ; ; IMMEDIATE MODE ; MOV WRD1,R2 ; GET OP CODE BIC #170077,R2 ; GET TYPE OF OPERAND ISOLATED CMP #2700,R2 BNE S37 MOV (SP)+,R0 ; GET THE OPERAND TYPE <#> JSR PC,DMPADR MOV CURADR,R0 ; GET WORD 3 ADD #4,R0 GETWRD MOV R1,-(SP) ; SAVE IT ON THE STACK TYPE <,> JMP PRTDST S37: ; ; ABSOLUTE (SOURCE) ; CMP #3700,R2 ; ABSOLUTE MODE? BNE S67 TYPE <@#> MOV (SP)+,R0 ; GET ADDRESS JSR PC,DMPADR MOV CURADR,R0 ; OP CODE ADDRESS ADD #4,R0 GETWRD MOV R1,-(SP) ; SAVE IT ON THE STACK TYPE <,> JMP PRTDST S67: ; ; RELATIVE MODE (SOURCE) ; CMP #6700,R2 ; RELATIVE MODE? BNE S77 MOV (SP)+,R0 ; GET ADDRESS MOV CURADR,R1 ; MAKE IT A TASK RELATIVE ADR. ADD R1,R0 ADD #4,R0 JSR PC,DMPADR MOV CURADR,R0 ; OP CODE ADDRESS ADD #4,R0 GETWRD MOV R1,-(SP) ; SAVE IT ON THE STACK TYPE <,> JMP PRTDST S77: ; ; RELATIVE DEFERRED (SOURCE) ; CMP #7700,R2 ; RELATIVE DEFERRED? BNE REG TYPE <@> MOV (SP)+,R0 ; GET ADDRESS JSR PC,DMPADR MOV CURADR,R0 ; OP CODE ADDRESS ADD #4,R0 GETWRD MOV R1,-(SP) ; SAVE IT ON THE STACK TYPE <,> JMP PRTDST REG: ; ; REGISTER MODE (SOURCE) ; REG 0 REG 1 REG 2 REG 3 REG 4 REG 5 REG 6 REG 7 DEFER: ; ; DEFERRED MODE (SOURCE) ; DEFER 0 DEFER 1 DEFER 2 DEFER 3 DEFER 4 DEFER 5 DEFER 6 DEFER 7 AUTOI: ; ; AUTO INCREMENT (SOURCE) ; AUTOI 0 AUTOI 1 AUTOI 2 AUTOI 3 AUTOI 4 AUTOI 5 AUTOI 6 AUTOI 7 AUTID: ; ; AUTO INCREMENT DEFERRED (SOURCE) ; AUTID 0 AUTID 1 AUTID 2 AUTID 3 AUTID 4 AUTID 5 AUTID 6 AUTID 7 AUTOD: ; ; AUTO DECREMENT (SOURCE) ; AUTOD 0 AUTOD 1 AUTOD 2 AUTOD 3 AUTOD 4 AUTOD 5 AUTOD 6 AUTOD 7 AUTDD: ; ; AUTO DECREMENT DEFERRED (SOURCE) ; AUTDD 0 AUTDD 1 AUTDD 2 AUTDD 3 AUTDD 4 AUTDD 5 AUTDD 6 AUTDD 7 INDEX: ; ; INDEX MODE (SOURCE) ; INDEX 0 INDEX 1 INDEX 2 INDEX 3 INDEX 4 INDEX 5 INDEX 6 INDEX 7 INDXD: ; ; INDEX DEFERRED (SOURCE) ; INDXD 0 INDXD 1 INDXD 2 INDXD 3 INDXD 4 INDXD 5 INDXD 6 INDXD 7 PRTDST: MOV TBLADR,R0 ; TABLE ADDRESS CMP #77000,OP(R0) ; SOB BEQ SOB JMP PD0 SOB: MOV WRD1,R1 ; GET OP CODE BIC #177700,R1 ; GET DISPLACEMENT DEC R1 ; PSEUDO MACHINE STILL POINTS TO SOB ASL R1 MOV CURADR,R0 ; CHANGE TO TASK RELATIVE SUB R1,R0 JSR PC,DMPADR ; OUTPUT THE ADDRESS JMP SDRTN PD0: MOV TBLADR,R0 ; GET THE MODE INDICATOR MOV MODE(R0),R1 BIT #7,R1 ; NEED TO PROCESS BNE PD1 JMP SDRTN PD1: BIT #70,R1 ; SPECIAL XX07 MODE BEQ PD2 ; YES JMP PD3 PD2: MOV WRD1,R2 BIC #177770,R2 ; GET REGISTER # NUM1 0 NUM1 1 NUM1 2 NUM1 3 NUM1 4 NUM1 5 NUM1 6 NUM1 7 JMP SDRTN PD3: MOV WRD1,R2 ; GET OP CODE BIC #177700,R2 ; ISOLATE MODE TYPE D27: ; ; IMMEDIATE MODE ; CMP #27,R2 ; IMMEDIATE MODE BNE D37 MOV (SP)+,R0 TYPE <#> JSR PC,DMPADR JMP SDRTN D37: ; ; ABSOLUTE MODE (DESTINATION) ; CMP #37,R2 ; ABSOLUTE MODE? BNE D67 TYPE <@#> MOV (SP)+,R0 ; GET ADDRESS JSR PC,DMPADR JMP SDRTN D67: ; ; RELATIVE MODE (DESTINATION) ; CMP #67,R2 ; RELATIVE MODE BNE D77 MOV (SP)+,R0 ; GET ADDRESS MOV CURADR,R1 ; MAKE TASK RELATIVE ADD R1,R0 ADD #4,R0 JSR PC,DMPADR JMP SDRTN D77: ; ; RELATIVE DEFERRED (DESTINATION) ; CMP #77,R2 ; RELATIVE DEFERRED? BNE REG1 TYPE <@> MOV (SP)+,R0 ; GET ADDRESS JSR PC,DMPADR JMP SDRTN REG1: ; ; REGISTER MODE (DESTINATION) ; REG1 0 REG1 1 REG1 2 REG1 3 REG1 4 REG1 5 REG1 6 REG1 7 DEFER1: ; ; DEFERRED MODE (DESTINATION) ; DEFER1 0 DEFER1 1 DEFER1 2 DEFER1 3 DEFER1 4 DEFER1 5 DEFER1 6 DEFER1 7 AUTOI1: ; ; AUTO INCREMENT (DESTINATION) ; AUTOI1 0 AUTOI1 1 AUTOI1 2 AUTOI1 3 AUTOI1 4 AUTOI1 5 AUTOI1 6 AUTOI1 7 AUTID1: ; ; AUTO INCREMENT DEFERRED (DESTINATION) ; AUTID1 0 AUTID1 1 AUTID1 2 AUTID1 3 AUTID1 4 AUTID1 5 AUTID1 6 AUTID1 7 AUTOD1: ; ; AUTO DECREMENT (DESTINATION) ; AUTOD1 0 AUTOD1 1 AUTOD1 2 AUTOD1 3 AUTOD1 4 AUTOD1 5 AUTOD1 6 AUTOD1 7 AUTDD1: ; ; AUTO DECREMENT DEFERRED (DESTINATION) ; AUTDD1 0 AUTDD1 1 AUTDD1 2 AUTDD1 3 AUTDD1 4 AUTDD1 5 AUTDD1 6 AUTDD1 7 INDEX1: ; ; INDEX MODE (DESTINATION) ; INDEX1 0 INDEX1 1 INDEX1 2 INDEX1 3 INDEX1 4 INDEX1 5 INDEX1 6 INDEX1 7 INDXD1: ; ; INDEX DEFERRED (DESTINATION) ; INDXD1 0 INDXD1 1 INDXD1 2 INDXD1 3 INDXD1 4 INDXD1 5 INDXD1 6 INDXD1 7 SDRTN: MOV TBLADR,R0 ; GET TABLE ADDRESS CMP #377,MASK(R0) ; BRANCH TYPE BEQ BRANCH JMP SDR3 BRANCH: TYPE < > MOV WRD1,R0 ; GET THE OP CODE BIC #177400,R0 ; MASK DOWN TO DISPLACEMENT MOV TBLADR,R1 ; GET TABLE ADDRESS CMP #104000,OP(R1) ; EMT ? BEQ SDR2 CMP #104400,OP(R1) ; TRAP ? BEQ SDR2 SDR1: BIT #200,R0 ; NEGATIVE BEQ SDR1A BIS #177400,R0 ; SIGN EXTEND! SDR1A: ASL R0 ; MULTIPLY BY 2 ADD #2,R0 ADD CURADR,R0 ; EFFECTIVE ADDRESS JSR PC,DMPADR BR SDR3 SDR2: JSR PC,DMPADR SDR3: MOV R5,SP ; REFRESH STACK POINTER RETURN .PAGE G.WORD: ; ; GET A WORD FROM TASK BEING MONITORED ; R0 = TASK VIRTUAL ADDRESS ; UPON EXIT R1 = DATA ; SAVE ; ; TRY TO USE OLD DATA ; CALL OLD.WD ; SEE IF WE ALREADY HAVE IT BCS 5$ REST JMP GOTDAT 5$: ; ; ASK FOR MORE DATA ; MOV #NDATAL,R5 ; NDATA ---> QDATA MOV #NDATA,R1 ; FROM MOV #QDATA,R2 ; TO 10$: MOV (R1)+,(R2)+ SOB R5,10$ MOV #C.READ,Q.CMD ; READ MOV R0,Q.WK1 ; VIRTUAL ADDRESS ; ASK FOR DATA VSDR$S #TASK,,,,,#QDATA,#QDATAL,,,GET.TI 20$: VRCT$S ,#GTASK,#GDATAL,#GET.TI ; RECEIVE DATA FROM TASK UNDER TEST CMP @#$DSW,#IS.SPD ; WAS I SUSPENDED? BEQ 20$ REST MOV GDATA+<2*GDATAL>-2,NEWDAT ; ; SHOW THAT WE HAVE A NEW BATCH OF DATA ; MOV R0,VALLOW ; 1ST VALID WORD ADDRESS MOV #1,VALDAT ; HAVE SOME VALID DATA GOTDAT: MOV NEWDAT,R1 ; SET UP FOR RETURN RETURN .PAGE OLD.WD: TST VALDAT ; VALID DATA ? BEQ 20$ ; NO, EXIT MOV #GDATAL,R5 ; # OF VALID WORDS MOV #-2>,R4 MOV VALLOW,R3 ; 1ST VALID ADDRESS 10$: CMP R0,R3 BEQ 30$ ; IF EQ,C-CLR ADD #2,R3 ; WORDS ARE IN REVERSE ORDER SUB #2,R4 ; AND WE START WITH LOW ADDRESS SOB R5,10$ ; TRY NEXT WORD 20$: SEC BR 40$ ; NOT THERE 30$: MOV (R4),NEWDAT ; GET THE DATA 40$: RETURN .PAGE P.WORD: ; ; STORE A WORD IN TARGET TASK ; R0 = TASK VIRTUAL ADDRESS ; R1 = DATA ; CALL $SAVAL ; SAVE ALL REGS THROUGH CO-ROUTINE CLR VALDAT ; INVALIDATE CURRENT DATA MOV #NDATAL,R5 ; NDATA ---> QDATA MOV #NDATA,R3 ; FROM MOV #QDATA,R2 ; TO 10$: MOV (R3)+,(R2)+ SOB R5,10$ MOV #C.WRIT,Q.CMD ; WRITE MOV R0,Q.WK1 ; VIRTUAL ADDRESS MOV R1,Q.WK2 ; DATA ; SEND DATA VSDR$S #TASK,,,,,#QDATA,#QDATAL,,,GET.TI 20$: VRCT$S ,#GTASK,#GDATAL,#GET.TI ; SYNCHRONIZE CMP @#$DSW,#IS.SPD ; WAS I SUSPENDED? BEQ 20$ RETURN .PAGE DMPADR: ; ; DUMP ADDRESS ROUTINE ; CALL $SAVAL ;SAVE ALL REGS MOV R0,R1 ; ADDRESS IN R1 CLR R2 ; ZERO SUPPRESSION MOV #WKBUF,R0 ; DESTINATION CALL SYMBOL ;SEE IF ADDRESS IS IN SYMBOL TABLE BCC 100$ ;YES- IT HAS BEEN CONVERTED AND PLACED IN ; OUTPUT AREA CALL $CBOMG 100$: MOV #WKBUF,R1 ; COMPUTE LENGTH SUB R1,R0 TTYI R1,R0 RETURN SYMBOL: CALL $SAVAL ;PRESERVE ALL REGS MOV #GSD,R5 ;GET ADDRESS OF GLOBAL SYMBOL TABLE 100$: MOV R5,R4 ;SAVE CURRENT POSITION IN TABLE TST (R5)+ ;AT END OF TABLE?? BNE 200$ ;NOT YET TST (R5) ;CHECK BOTH WORDS BEQ 300$ ;AT END--LET US QUIT 200$: TST (R5)+ ;BUMP TO VALUE CMP (R5)+,R1 ;HAVE WE GOT A MATCH YET?? BNE 100$ ;NOPE-KEEP LOOKING MOV (R4)+,R1 ;GOT A HIT, GET RAD50 SYMBOL NAME CALL $C5TA ;CONVERT AND PUT IN OUT BUF MOV (R4)+,R1 ;DO BOTH WORDS CALL $C5TA 250$: CMPB -(R0),#SPACE ;GET RID OF TRAILING SPACES BEQ 250$ INC R0 MOV R0,2(SP) ;PUT R0 WHERE STACK POPPER WILL REPLACE IT CLC ;INDICATE WE GOT A HIT RETURN ;AND OUT 300$: SEC ;INDICATE NO GOOD RETURN .END START