IDT 'DISASM' DXOP SVC,15 DISASM DATA REG,MAIN00,0 * SYMBOLIC DISASSEMBLER FOR TI 990 (TXDS / DX10) * AUTHOR : DONALD E B MILLER * COMMANDER SYSTEMS, INC. * PO BOX 494 * WORTHINGTON OH, 43085 * (614) 888-9287 * THIS PROGRAM DOES NOT PROCESS MULTIPLY USED * 'REF'S, OR DSEG DATA PROPERLY. * TXDS CALLING SEQUENCE: * PROGRAM : :DISASM/SYS * INPUT : :FILE/OBJ * OUTPUT : :FILE/LST * OPTIONS : M = INPUT IS IN MEMORY. * DX10 (REL 2.2) : * AL,A5,INPUT.AL,A6,OUTPUT. * EX,DA,S. (S : 1=LIST, 2=SOURCE.) * DX10 (REL 3.X) : * XDIS INPUT=ACNM, * OUTPUT=ACNM, * OUTPUT FORMAT=LIST (OR "SOURCE") * TEXT OF 'XDIS' PROC FOR DX10 REL 3.X *XDIS(EXECUTE DISASSEMBLER UTILITY), *INPUT ACCESS NAME = ACNM(@$XDIN), *OUTPUT ACCESS NAME = ACNM, *FORMAT = *STRING(LIST) *RL LUNO=0A5 *RL LUNO=0A6 *AL LUNO=0A5, ACCESS NAME= @&INPUT ACCESS NAME *AL LUNO=0A6, ACCESS NAME= @&OUTPUT ACCESS NAME *.SYN $XDIN="@&INPUT ACCESS NAME" *.IF &OUTPUT ACCESS NAME, EQ, "ME" *.SYN $BID=XTS *.ELSE *.SYN $BID=XT *.ENDIF *.IF "@&FORMAT", EQ, "LIST" *.SYN $PRM=1 *.ELSE *.SYN $PRM=2 *.ENDIF *@$BID PROG=.S$SDS$, TASK=DISASM, P1=@$PRM-0, STA=ME *.SYN $PRM="" *.SYN $BID="" DEF DISASM REG BSS 32 PAGE DATA 0 CURRENT PAGE COUNT. PAGSIZ DATA 60 LINES PER PAGE. LINCNT DATA 0 CURRENT LINE COUNT. PCSTRT DATA 0 INITIAL PC VALUE. * FLAG SIGNIFIGANCE : 0 / 1 DX10 DATA 0 TXDS/DX10 OS FLAG. FRMT DATA 0 STD/COMPRESSED FORMAT FLAG. FILE DATA 0 MEMORY/FILE FLAG. LSTFLG DATA 0 LIST/SRC FLAG. TXFLAG DATA 0 SDSMAC/TXMIRA FLAG. SVCFLG DATA 0 SVC USED FLAG. REFTYP DATA 0 STD / INDEXED REF TYPE FLAG. ETAG DATA 0 NO / YES, CURRENT WORD = E TAG. MAXSIZ EQU 46 SIZE OF NEXT TWO TABLES. PC0 BSS MAXSIZ STORAGE FOR INSTRUCTION/TEXT. RELWD BSS MAXSIZ RELOCATABILITY FLAGS. LINNUM DATA 0 PRINT LINE COUNTER. LINTMP DATA 0 TEMP STORAGE FOR PRINT COUNTER. OP1 BYTE 0 CODE OF SOURCE PROCESSOR. OP2 BYTE 0 CODE OF DESTINATION PROC. INSTSZ DATA 0 LENGTH OF CURRENT INSTRUCTION. FIELD DATA 0 CURRENT FIELD = LABEL FLAG. MNEMNC DATA 0 ADDRESS OF MNEMONIC TEXT. PASS DATA 0 DISASM PASS NUMBER PC DATA 0 PROGRAM COUNTER * * * DUMMY CRU TABLE * * * * (ALTER 'EQU' FOR SYMBOLIC BIT NAMES) BTBLSZ EQU 0 SIZE OF BIT TABLE BCNT DATA 0 HIGHEST CRU EQUATE DATA BTBLSZ TABLE SIZE. BTBL DATA CRUTBL TABLE POINTER. LTBLSZ EQU 800 SIZE OF SYMBOL TABLE. LCNT DATA 0 HIGHEST LABEL GENERATED DATA LTBLSZ TABLE SIZE. LTBL DATA LBLTBL TABLE POINTER. RTBLSZ EQU 400 MAXIMUM NUMBER OF REFS. RCNT DATA 0 ACTUAL REF COUNT. DATA RTBLSZ MAXIMUM VALUE. RTBL DATA REFTBL TABLE POINTER. GETLBL DATA GETWP,GETPC SEARCH FOR LABEL. GETCRU DATA GETWP,GETPC2 SEARCH FOR CRU SYMBOL. GETREF DATA GETWP,GETPC3 SEARCH FOR REF SYMBOL. DEFLBL DATA DEFWP,DEFPC DEFINE NEW SYMBOL. DEFCRU DATA DEFWP,DEFPC2 DEFINE CRU SYMBOL (EQU). DEFSYM DATA DEFWP,DEFPC3 DEFINE TAG 5 SYMBOL. DEFREF DATA DEFWP,DEFPC4 DEFINE REF SYMBOL. NEXTWD DATA NXTWP,NXTWD FETCH NEXT OBJECT WORD. NXTASC DATA NXTWP,NXTPC2 FETCH NEXT WORD IF ASCII. OPEN DATA 0,>3A6,>20,0,0,0 WRT DATA 0,>BA6,>20,BUF,0,80 CLOSE DATA 0,>2A6,0,0,0,0 CLOSIN DATA 0,>1A5,0,0,0,0 RDSTRT DATA 0,>B00,>40,MSG1,0,21,INPRB RDSTOP DATA 0,>B00,>40,MSG2,0,21,INPRB OPENIN DATA 0,>3A5,>20,0,0,0 RDIN DATA 0,>9A5,>20,IBUF,80,0 ICNT EQU $-2 INPRB DATA BUF,4,0 RDCCNT EQU $-2 GETPRM DATA >1700,0,0 GET BID PARAMETER SVC BLOCK. HDNG DATA 0,>BA6,>20,MSG0,0,MSG1-MSG0 MSG0 BYTE >D,>C,>A MSG0I TEXT 'IIIIIIII DISASM ** COMMANDER SYST' TEXT 'EMS, INC. PAGE ' PAGENO TEXT '0000' BYTE >D,>A,>A MSG1 BYTE >D,>A TEXT 'STARTING ADDRESS ? ' MSG2 EQU $ HX0D BYTE >0D HX0A BYTE >0A TEXT 'ENDING ADDRESS ? ' CSPACE EQU $-1 EVEN IBUF BSS 80 BUF BSS 80 COMMA TEXT ',' CR TEXT 'R' CAT TEXT '@' CSTAR TEXT '*' CDOLR TEXT '$' CHEX TEXT '>' CMINUS TEXT '-' CPLUS TEXT '+' COPN TEXT '(' CCLS TEXT ')' TXTNAM TEXT 'TEXT' DXPNAM TEXT 'DXOP SVC,15' END BYTE >16 B16 BYTE 16 IDTVAL DATA 0 LENGTH OF OBJECT IDTNAM TEXT 'IDT ''' CQUOTE EQU $-1 IDTSYM TEXT 'IIIIIIII''' ERRTXT TEXT '*********** REF ERROR' BSSNAM TEXT 'BSS' ENDNAM TEXT 'END' EQUNAM TEXT 'EQU ' REFNAM TEXT 'REF ' DEFNAM TEXT 'DEF ' COMN DATA >1000 D80 DATA 80 NOMINAL PRINT LENGTH. EQMSK DATA >2000 EQ BIT IN STATUS WORD. ALUNO DATA 0,>9105,0,0,0,0 DATA 0,0,>1285,0,0,BUF CBDA DATA >A00,0,0,0 CBHA DATA >C00,0,0 PAGE MAIN00 SETO OPEN CLEAR THE OUTPUT-OPEN FLAG. CLR PAGE INITIALIZE THE PAGE NUMBER. CLR LINCNT INITIALIZE PAGE = EMPTY. CLR SVCFLG CLEAR THE SVC-USED FLAG. CLR IDTSYM CLEAR THE IDT FLAG. CLR PCSTRT CLEAR THE 'INITIAL PC'. SETO R7 SET THE ENDING ADDRESS. CLR BCNT CLEAR THE EQUATE COUNTER. CLR LCNT CLEAR THE LABEL COUNTER. CLR RCNT CLEAR THE REF COUNTER. SETO REFTYP SET THE 'INDEXED REFS' FLAG. CLR PASS CLEAR THE DISASM PASS COUNTER. BL @OPTION SETUP THE OPTIONS REQUESTED. MOV DX10,R0 TEST WHETHER OS = DX10. JNE MAIN02 JUMP IF SO, (SKIP LUNO ASSIGN). MOV FILE,R0 TEST WHETHER TO ASSIGN INPUT. JEQ MAIN01 JUMP IF INPUT IS FROM MEMORY. BL @LUNO ASSIGN THE INPUT UNIT. DATA >91A5,16 ..SCB+2, COMMON OFFSET. MAIN01 BL @LUNO ASSIGN THE OUTPUT UNIT. DATA >91A6,64 ..SCB+2, COMMON OFFSET. MOV FILE,R0 TEST WHETHER TO ASK FOR LIMITS. JNE MAIN02 DON'T ASK FOR LIMITS IF FILE SVC RDSTRT ASK FOR THE LOW ADDRESS BL @CVTRPY CONVERT THE INPUT TO HEX MOV 0,PCSTRT COPY THE INITIAL ADDRESS SVC RDSTOP ASK FOR THE HIGH ADDRESS BL @CVTRPY CONVERT THE INPUT TO HEX MOV 0,7 SAVE THE ENDING ADDRESS MAIN02 SETO OPENIN CLEAR THE 'INPUT OPEN' FLAG. MOV PCSTRT,PC RESET THE PROGRAM COUNTER. MAIN03 CLR INSTSZ CLEAR THE INSTRUCTION SIZE. CLR LINNUM CLEAR THE PRINT COUNT. BLWP NEXTWD FETCH THE INSTRUCTION. MOV 0,8 STORE FOR OTHERS TO USE. BL @DECODE DECODE THE INSTRUCTION & OPERANDS. BL @OUTPUT OUTPUT THE LINE(S). BL @ERRMSG WRITE AN ERROR MESSAGE IF NEEDED. A INSTSZ,PC BUMP THE PC AS REQUIRED. JNC MAIN03 LOOP UNTIL NEXTWD KILLS US. * END OF DISASSEMBLER PASS. EXIT2 MOV PASS,0 TEST PASS COUNTER. JNE EXIT1 JUMP IF END OF PASS 2. BL @ADJUST ADJUST TABLE IF ANY ARE FULL. DATA MAIN00 ..RESTART PASS 1 IF ADJUSTED. INC PASS INCREMENT THE PASS NUMBER. SVC CLOSIN CLOSE THE INPUT FILE. BL @IDTREC FORMAT THE IDT RECORD. BL @DMPSVC GENERATE DXOP IF NEEDED. BL @DUMPCR DUMP THE CRU EQUATES. JMP MAIN02 START A NEW PASS. EXIT1 BL @LIST FORMAT THE BUFFER BYTE 1,1 ..INHIBIT PC AND DATA. DATA 3,ENDNAM SET POINTER TO 'END'. BL @LENGTH WRITE THE LINE OUT. SVC CLOSE CLOSE & WRITE EOF EXIT SVC END TERMINATE PROGRAM. PAGE * CONVERT THE REPLY TO BINARY CVTRPY LI 0,BUF SET POINTER TO THE INPUT BUFFER LI 2,'00' INITIALIZE THE FOUR DIGIT LI 3,'00' FIELD TO ZEROES MOV RDCCNT,1 GET THE INPUT CHAR COUNT CNVT01 JEQ CNVT02 JUMP WHEN ALL INPUT PROCESSED MOVB 3,2 SHIFT THE MOVB *0+,3 FIELD LEFT SWPB 2 TO POSITION SWPB 3 ALL DIGITS DEC 1 DECREMENT THE CHAR COUNT JMP CNVT01 LOOP FOR NEXT DIGIT CNVT02 LI 1,>D00 SET R1 = 'CONVERT HEX ASCII TO BIN' SVC 1 CONVERT THE INPUT TO BINARY (R0) SLA 1,8 SHIFT THE STATUS BYTE UP JNE EXIT TO TEST FOR CONVERSION ERRORS RT RETURN, R0 = INPUT PAGE LUNO MOV *R11+,ALUNO+2 SELECT THE UNIT NUMBER. MOV R9,R0 COPY THE ADDRESS OF COMMON. A *R11+,R0 ADD THE OFFSET. LI R1,16 SET A POINTER FOR NAME. LI R2,BUF+1 SET THE BUFFER ADDRESS. CLR R4 INITIALIZE THE LENGTH. LUNO2 MOVB *R0+,R3 GET A BYTE FROM COMMON. JEQ LUNO3 JUMP IF A NULL. INC R4 COUNT THE LENGTH. MOVB R3,*R2+ STORE INTO BUFFER. LUNO3 DEC R1 DECREMENT THE LOOP COUNTER. JNE LUNO2 LOOP UNTIL ALL COPIED. SWPB R4 REPOSITION THE COUNT. MOVB R4,BUF STORE THE CHAR COUNT. SVC ALUNO TRY TO DO THE ASSIGNMENT. MOV ALUNO,R0 TEST WHETHER ANY ERROR. JNE EXIT ABORT ON AN ERROR. RT RETURN TO MAIN LINE. PAGE * INSTRUCTION DECODER * ENTRY : BL @DECODE * R8 = INSTRUCTION VALUE * RETURN : R1 = ADDRESS OF TEXT * OP1,2 = SRC,DST OPERAND FMTS DECODE CLR FIELD CLEAR THE FIELD FLAG FOR LABEL. MOV RELWD,0 TEST FOR RELOCATABLE VALUE. JNE DEC05 JUMP IF RELOCATABLE (DATA). CI R8,-1 TEST FOR SPECIAL VALUE. JEQ DEC05 DECODE AS 'DATA'. MOV R8,R0 POSITION THE DATA WORD. MOV R11,R15 SAVE OUR RETURN LINKAGE. BL @ASCLIM TEST FOR ASCII DATA (TEXT). DATA DEC00 ..RETURN IF NOT ASCII. JMP DEC06 JUMP TO PROCESS TEXT. DEC00 MOV R15,R11 RESTORE RETURN LINKAGE. LI 15,OPTBL INITIALIZE TABLE POINTER JMP DEC01 JUMP TO PROCESS A SUBTABLE. * END OF A SUBTABLE. DEC10 MOV 1,15 COPY SUBTABLE END ADDRESS. INCT 15 INCREMENT TO PASS IT. * SEARCH INSTRUCTION SUBTABLE. DEC01 MOV *15+,1 GET THE INSTRUCTION MASK. JEQ DEC05 JUMP WHEN TABLES ALL EMPTY. MOV 8,0 GET THE INSTRUCTION. INV 1 INVERT THE OPCODE MASK. SZC 1,0 CLEAR OPERAND FIELDS. MOV 15,1 COPY THE TABLE POINTER. INCT R1 BUMP TWO BYTES (OPRND PROCS). DEC02 MOV *1,*1 TEST FOR END OF SUBTABLE. JEQ DEC10 JUMP IF FINISHED. C 0,*1+ COMPARE INST : TEMPLATE. JEQ DEC03 JUMP IF CORRECT INSTRUCTION. C *1+,*1+ SKIP THE TEXT (4 BYTES). JMP DEC02 AND LOOP FOR MORE INSTR TEMPLATES. * FOUND THE PROPER INSTRUCTION TEMPLATE DEC03 MOVB *15+,OP1 GET 'SOURCE FORMAT ROUTINE'. MOVB *15+,OP2 GET 'DESTINATION FORMAT ROUTINE'. CI 1,SVCTBL TEST FOR 'SVC' INSTRUCTION. JNE $+6 JUMP IF NOT AN SVC. SETO SVCFLG SET THE FLAG IF IT IS AN SVC. MOV 11,15 SAVE OUR RETURN LINKAGE. CLR R0 CLEAR THE INDEX OF PC0. BL @LIST INITIALIZE THE OUTPUT BUFFER. BYTE 0,0 ..ALLOW 'PC' AND 'DATA'. DATA 0,0 ..USE R1 FOR MNEMONIC POINTER. INC 10 BUMP FOR NEXT FIELD. INC FIELD SET FLAG TO FREEZE NXTLBL. CLR @ERRFLG CLEAR THE REF ERROR FLAG. JMP OPERND PROCESS THE OPERANDS NOW. * 'DATA' SETUP DEC05 LI 15,DATTBL SET POINTER TO 'DATA'. MOV 15,1 COPY THE TABLE POINTER C *R1+,*R1+ SKIP THE OPERAND PROCS & TEMPLATE. MOV ETAG,ETAG TEST WHETHER TO ZERO REF VALUE. JEQ DEC03 JUMP IF VALUE SHOULD DISPLAY. CLR PC0 ZERO THE DATA VALUE. JMP DEC03 PROCESS AS 'DATA' * TEXT RECOGNITION AND PROCESSING DEC06 CLR R4 CLEAR THE TEXT COUNTER. MOV PASS,R2 TEST WHICH PASS THIS IS. JNE DEC08 JUMP FOR PASS TWO. * PASS ONE TEXT PROCESSOR. DEC07 BLWP NXTASC GET NEXT ASCII WORD. JNE DEC11 JUMP WHEN NEXT ISN'T ASCII. INC R4 COUNT THE TEXT. JMP DEC07 LOOP TO CONTINUE TEXT. * PASS TWO TEXT PROCESSOR. DEC08 CLR R0 CLEAR THE INDEX OF PC0. BL @LIST FORMAT THE OUTPUT BUFFER. BYTE 0,0 ..ALLOW THE PC AND DATA. DATA 4,TXTNAM ..COUNT AND MNEMONIC. INC R10 SKIP A SPACE AFTER MNEMONIC. MOV R10,R5 COPY THE BUFFER POINTER. AI R5,46 ADD MAXIMUM TEXT LENGTH. MOVB CQUOTE,*R10+ START WITH A QUOTE. MOV R8,R0 RESTORE THE DATA. DEC09 BL @FMTTXT FORMAT THE TEXT WORD. MOV PC,R0 GET THE STARTING PC. A INSTSZ,R0 ADD THE CURRENT COUNTER. C R0,@NXTLBL TEST WHETHER A LABEL IS NEXT. JHE DEC12 END TEXT IF LABEL IS NEXT. C R10,R5 TEST WHETHER BUFFER IS FULL. JHE DEC11 WRITE LINE IF FULL. BLWP NXTASC GET NEXT WORD IF ASCII. JNE DEC11 JUMP IF NEXT IS NOT ASCII. INC R4 COUNT THE TEXT WORD. JMP DEC09 LOOP FOR NEXT WORD. DEC11 MOV R15,R11 RESTORE RETURN LINKAGE. MOV R4,R4 TEST WHETHER SINGLE TEXT WORD. JEQ DEC00 REPROCESS AS AN INSTRUCTION. DEC12 MOV R15,R11 RESTORE RETURN LINKAGE. MOV PASS,R0 TEST WHICH PASS THIS IS. JEQ DEC13 SKIP QUOTE IF PASS ONE. MOVB CQUOTE,*R10+ ADD A FINAL QUOTE TO BUFFER. DEC13 RT RETURN TO MAIN LINE CODE. PAGE * OPERAND PROCESSOR * ENTRY : FROM DECODE * R0 = PASS NUMBER * R8 = INSTRUCTION VALUE. * RETURN : THROUGH OPERAND ROUTINES * SYMGS, FMTGS, ETC. OPERND MOV 0,0 TEST FOR PASS 1. JNE OPERN2 JUMP FOR PASS 2. MOVB OP1,1 FETCH FIRST OPERND CODE. SRL 1,7 SHIFT FOR WORD INDEX. MOV OPTBL1(1),1 GET ROUTINE ADDRESS MOV 8,0 POSITION THE INSTRUCTION. BL *1 PROCESS THE OPERAND MOVB OP2,1 FETCH SECOND OPERAND CODE. SRL 1,7 SHIFT FOR WORD INDEX. MOV OPTBL1(1),1 GET ROUTINE ADDRESS. MOV 8,0 POSITION THE INSTRUCTION. BL *1 PROCESS THE SECOND OPERAND. B *15 RETURN TO CALLER. OPERN2 MOVB OP1,1 GET THE FIRST OPERAND CODE. SRL 1,7 SHIFT FOR WORD INDEX. MOV OPTBL2(1),1 GET ROUTINE ADDRESS. MOV 8,0 POSITION THE INSTRUCTION. BL *1 FORMAT THE OPERAND. MOVB OP2,1 GET THE SECOND OPERAND CODE. JEQ OPERN3 JUMP IF NO SECOND OPERAND SRL 1,7 SHIFT FOR WORD INDEX. MOV OPTBL2(1),1 GET ROUTINE ADDRESS. MOVB COMMA,*R10+ INSERT A COMMA BETWEEN OPERANDS MOV 8,0 POSITION THE INSTRUCTION. BL *1 FORMAT THE OPERAND. OPERN3 B *R15 RETURN TO CALLER PAGE * OPERAND PROCESSORS, PASS 1. OPTBL1 DATA RTN 0 DATA SYMGS 1 GS DATA SYMGD 2 GD DATA RTN 3 C6 DATA RTN 4 C8 DATA RTN 5 W6 DATA RTN 6 W12 DATA SYMSD 7 SD DATA SYMCRU 8 CRU DATA SYMIMM 9 IMM DATA RTN 10 M DATA SYMHX 11 HX * OPERAND ROUTINES, PASS 2. OPTBL2 DATA RTN 0 DATA FMTGS 1 GS DATA FMTGD 2 GD DATA FMTC6 3 C6 DATA FMTC8 4 C8 DATA FMTW6 5 W6 DATA FMTW12 6 W12 DATA FMTSD 7 SD DATA FMTCRU 8 CRU DATA FMTIMM 9 IMM DATA FMTM 10 M DATA FMTHX 11 HEX PAGE * PASS 1 OPERAND PROCESSOR ROUTINES * EACH ROUTINE PROCESSES A SPECIFIC FIELD, DEFINING * A SYMBOL IF POSSIBLE. * THE ROUTINES WHICH CAN DEFINE SYMBOLS ARE : * ROUTINE CONDITIONS * GS TAG = 2, WORD IS RELOCATABLE. * GD TAG = 2, WORD IS RELOCATABLE. * SD DISPLACEMENT IS > 6. * CRU ALL VALUES ARE DEFINED. * HX WORD IS RELOCATABLE. * IMM WORD IS RELOCATABLE. SYMGD SRL R0,6 ALIGN THE INSTRUCTION. SYMGS ANDI R0,>30 MASK THE TAG FIELD ALONE. CI R0,>20 TEST FOR TAG = 2. JNE SYMRT JUMP IF NOT TAG 2. SYMIMM BLWP NEXTWD GET THE NEXT WORD. SYMHX MOV INSTSZ,1 GET THE CURRENT WORD NUMBER. MOV RELWD-2(1),1 TEST THE RELOCATABILITY FLAG. SYMCHK JEQ SYMRT JUMP IF ABSOLUTE VALUE. SYMDF BLWP DEFLBL DEFINE THIS VALUE AS A SYMBOL. SYMRT RT RETURN TO OPERND. SYMSD SLA R0,8 SHIFT THE DISPLACEMENT UP. SRA R0,7 ARITHMETIC SHIFT DOWN. INCT 0 INCREMENT THE DISPLACEMENT. MOV 0,1 COPY THE VALUE. ABS 1 TAKE THE ABSOLUTE VALUE OF IT. CI 1,6 COMPARE TO ARBITRARY VALUE. JLE SYMRT RETURN IF ONLY SHORT JUMP. A PC,0 ADD THE CURRENT PC TO DISP. JMP SYMDF DEFINE THE LOCATION AS SYMBOL. SYMCRU SLA 0,8 SHIFT THE BIT DISPLACEMENT. SRA 0,8 ARITHMETIC SHIFT DOWN. BLWP DEFCRU DEFINE THE VALUE AS CRU EQUATE. RT RETURN TO CALLER. PAGE * PASS 2 OPERAND PROCESSOR ROUTINES * EACH ROUTINE PROCESSES A SPECIFIC PORTION OF * THE INSTRUCTION (PASSED IN R0), PUTTING THE * RESULTING CODE IN THE BUFFER (*R10+). * THE ROUTINES USE R0,R1,R2,R11. * THE ROUTINES AND RESULTS ARE : * 1 GS GENERAL ADDRESS FORMAT (SOURCE) * 00 RXX * 01 *RXX * 02 >XXXX(RXX) OR >XXXX * 03 *RXX+ * 2 GD GENERAL ADDRESS FORMAT (DESTINATION) * SAME RESULT AS 'GS' * 3 C6 SHIFT COUNT, FIELD AT BIT 6-9 * XX * 4 C8 SHIFT COUNT, FIELD AT BIT 8-11 * XX * 5 W6 WORKSPACE REGISTER, FIELD AT BIT 6-9 * RXX * 6 W12 WORKSPACE REGISTER, FIELD AT BIT 12-15 * RXX * 7 SD SIGNED DISPLACEMENT * >XXXX * 8 CRU SIGNED CRU VALUE * XX OR -XX * 9 IMM IMMEDIATE OPERAND * >XXXX * 10 M MAP FILE NUMBER * X * 11 HX HEXADECIMAL OPERAND * >XXXX * HXN HEXADECIMAL VALUE * XXXX FMTW6 MOVB CR,*10+ MOVE 'R' INTO BUFFER FMTC6 SRL 0,6 SHIFT THE OPERAND DOWN JMP CX JUMP FOR COMMON PROCESSING FMTC8 SRL 0,4 SHIFT THE OPERAND DOWN CX ANDI 0,15 MASK THE OPERAND FIELD CX01 SVC @CBDA CONVERT TO DECIMAL ASCII CI 0,100 TEST FOR DOUBLE DIGIT FIELD. JL CX02 JUMP IF NOT TRIPLE. MOVB @CBDA+5,*10+ INSERT THE HUNDREDS DIGIT. CX02 CI 0,10 TEST FOR SINGLE DIGIT FIELD JL CX03 JUMP IF SINGLE. MOVB @CBDA+6,*10+ MOVE TENS DIGIT. CX03 MOVB @CBDA+7,*10+ MOVE UNITS DIGIT. RT RETURN TO CALLER FMTIND MOVB CSTAR,*10+ PUT '*' INTO BUFFER FMTW12 MOVB CR,*10+ PUT 'R' INTO BUFFER JMP CX PROCESS REGISTER FIELD FMTSD SETO @ATFLAG INHIBIT THE '@' FROM SYMBOLS. SLA 0,8 SHIFT THE INSTRUCTION UP SRA 0,7 THEN DOWN (ARITMETIC SHIFT) INCT 0 BUMP THE PC FIRST. MOV 0,1 COPY THE DESTINATION. A PC,0 ADD CURRENT PC VALUE BLWP GETLBL USE A LABEL IF AVAILABLE. JEQ RTN JUMP IF LABEL USED. SD01 MOVB CDOLR,*10+ PUT '$' INTO BUFFER MOV 1,1 TEST THE DISPLACEMENT. JEQ RTN RETURN IF EQUAL (JMP $) JLT SD02 JUMP IF GOING BACK MOVB CPLUS,*10+ PUT '+' INTO BUFFER JMP SD03 CONVERT AND STORE IT. SD02 MOVB CMINUS,*10+ PUT '-' INTO BUFFER NEG R1 TAKE ABSOLUTE VALUE OF DISP. SD03 MOV 1,0 COPY THE (ABS) RANGE JMP CX01 CONVERT AND STORE IT. FMTIMM BLWP @NEXTWD GET THE NEXT WORD MOV R11,R3 SAVE THE RETURN LINKAGE. MOV INSTSZ,1 GET CURRENT WORD NUMBER. MOV RELWD-2(1),1 GET RELOCATION FLAG. JNE IMM02 JUMP IF NOT ABSOLUTE VALUE. BL @ASCLIM TEST FOR ASCII OPERAND. DATA IMM02 ..RETURN IF NOT ASCII. MOVB CQUOTE,*R10+ START WITH A QUOTE. BL @FMTTXT FORMAT AS TEXT, MOVB CQUOTE,*R10+ FINISH WITH ANOTHER QUOTE. B *R3 RETURN TO CALLER. IMM02 MOV R3,R11 RESTORE RETURN LINKAGE. FMTHX SETO @ATFLAG INHIBIT THE '@' FLAG. BLWP GETREF TRY TO USE REF'D SYMBOL. JEQ RTN JUMP IF SUCCESSFUL. MOV INSTSZ,1 GET CURRENT WORD NUMBER. MOV RELWD-2(1),1 GET RELOCATION FLAG. JEQ FMTHX2 JUMP IF ABSOLUTE VALUE. BLWP GETLBL TRY TO USE LABEL FOR VALUE. JEQ RTN JUMP IF SUCCESSFUL. FMTHX2 MOVB CHEX,*10+ PUT '>' INTO BUFFER HXN LI 1,CBHA SET POINTER TO SCB SVC *R1+ CONVERT R0 TO HEX ASCII MOVB *1+,*10+ MOVE FOUR MOVB *1+,*10+ DIGIT MOVB *1+,*10+ FIELD INTO MOVB *1+,*10+ BUFFER RTN RT RETURN FMTCRU SLA 0,8 SHIFT OPERAND UP SRA 0,8 SHIFT DOWN (SIGN FILLED) BLWP GETCRU USE SYMBOL FOR CRU VALUE. JEQ RTN JUMP IF SYMBOL FOUND. MOV 0,0 TEST THE BIT VALUE. JGT CRU02 JUMP FOR A POSITIVE JEQ CRU02 OR ZERO VALUE. NEG R0 CONVERT NEGATIVE TO POSITIVE. MOVB CMINUS,*10+ SET '-' INTO BUFFER. CRU02 CLR R2 CLEAR THE 'INDEX'. JMP SYM01 AND PROCESS AS HEX VALUE. FMTM LI 1,'01' GENERATE THE MAP OPERAND CONSTANTS ANDI 0,>0010 ISOLATE THE FIELD JEQ M02 JUMP IF CONSTANT OKAY SWPB.1 REVERSE CONSTANTS M02 MOVB 1,*10+ PUT DIGIT INTO BUFFER RT FMTGD SRL 0,6 SHIFT THE INSTRUCTION DOWN FMTGS ANDI 0,>3F MASK THE OPERAND FIELD(S) MOV 0,1 COPY FOR LATER SRL 1,4 SHIFT THE TAG FIELD DOWN SLA 1,1 DOUBLE FOR WORD INDEX MOV @TAGTBL(1),1 GET THE SPECIFIC PROCESSOR B *1 AND DO IT TAGTBL DATA FMTW12 0 WORKSPACE REGISTER DATA FMTIND 1 INDIRECT REGISTER DATA FMTSYM 2 SYMBOLIC MEMORY / INDEXED DATA FMTATO 3 AUTOINCREMENT REGISTER FMTATO MOV 11,1 SAVE THE RETURN LINKAGE BL @FMTIND FORMAT VIA 'INDIRECT REG' MOVB CPLUS,*10+ ADD A TRAILING '+' B *1 RETURN TO CALLER (DECODE) FMTSYM MOV 0,2 SAVE OPERAND REGISTER BLWP @NEXTWD FETCH EXTRA INSTRUCTION WORD CLR @ATFLAG ALLOW THE '@' IN SYMBOLS. MOV FILE,1 TEST WHETHER READING OBJECT JEQ SYM00 JUMP IF READING MEMORY. BLWP GETREF TRY TO USE REF'D SYMBOL. JEQ SYM09 JUMP IF SUCCESSFUL. MOV 0,3 SAVE THE DISPLACEMENT. MOV INSTSZ,1 GET THE INSTRUCTION WORD NUMBER. MOV RELWD-2(1),1 TEST WHETHER DATA IS RELOCATABLE. JEQ SYM08 JUMP IF DATA IS ABSOLUTE. SYM00 BLWP GETLBL TRY TO USE SYMBOLIC NAME. JEQ SYM09 JUMP IF SUCCESSFUL. SYM08 MOV TXFLAG,R0 TEST THE TXMIRA FLAG. JNE SYM08A JUMP TO FORCE THE '@' INTO TEXT. MOV R2,R0 TEST FOR INDEXED DISPLACEMENT. ANDI 0,>F MASK THE INDEX REGISTER. JNE SYM10 JUMP IF INDEXED. SYM08A MOVB CAT,*R10+ INSERT '@' INTO TEXT. SYM10 MOV 3,0 RESTORE THE SYMBOL VALUE. SYM01 LI 1,CBHA SET POINTER TO SCB SVC *1+ CONVERT TO HEX ASCII CI 0,10 TEST FOR DECIMAL EXPRESSION JL SYM02 JUMP IF DECIMAL VALID MOVB CHEX,*10+ PUT '>' INTO BUFFER SYM02 MOV 2,0 COPY OPERAND FIELD (4 BITS) INTO R0 LI 2,'00' PREPARE CONSTANT FOR ZERO BLANKING MOVB *1+,0 GET FIRST HEX DIGIT CB 0,2 TEST FOR LEADING ZEROES JEQ SYM03 JUMP TO BLANK IT CLR 2 CLEAR TO FOUL UP FUTURE TESTING MOVB 0,*10+ PUT DIGIT INTO BUFFER SYM03 MOVB *1+,0 GET SECOND HEX DIGIT CB 0,2 TEST FOR LEADING ZEROES JEQ SYM04 JUMP TO BLANK IT CLR 2 CLEAR TEST VALUE MOVB 0,*10+ PUT DIGIT INTO BUFFER SYM04 MOVB *1+,0 GET THIRD HEX DIGIT CB 0,2 TEST FOR LEADING ZERO JEQ SYM05 JUMP TO BLANK IT MOVB 0,*10+ PUT DIGIT INTO BUFFER SYM05 MOVB *1,*10+ ALWAYS PUT FOURTH DIGIT INTO BUFFER JMP SYM07 PROCESS THE INDEX REGISTER TEXT. SYM09 MOV 2,0 POSITION THE ORIGINAL INSTRUCTION SYM07 MOV 11,1 SAVE OUR RETURN LINKAGE ANDI 0,>F MASK OPERAND FIELD (REG NUMBER) JEQ SYM06 JUMP IF PURE SYMBOLIC REFERENCE MOVB COPN,*10+ PUT '(' INTO BUFFER BL @FMTW12 FORMAT THE REG NUMBER MOVB CCLS,*10+ PUT ')' INTO BUFFER