@X @~
~V7 56 2 -5
~D10
~H                    MUSS
~
~
~D10
~H            MTL215
~D10
~MMANCHESTER UNIVERSITY  -  CONFIDENTIAL~
~
~
                                                            ISSUE 11~
~V9 -1
~P
~V9 1
~YMTL215
~S~M~OMUTL IMPLEMENTATION DESCRIPTION
~S~M~OSection 21 Version 5 (MC68000)
~S~OSection 21.5 MUTL Support
~S~O1. General Description
~BThis module is concerned with the implementation of machine dependent
procedures associated with MUTL but not directly concerned with code
generation. For example the entry of programs and the printing of
machine registers for trapping purposes are functions of this section.
This module is compiled as part of the MUSS Basic Library.
~S~O2. Interfaces
~
MUTL Library Procedures~
   TL.ENTER(SEGMENT)~
   RETURN.FROM.TRAP()~
~
Interface Procedure~
   TL.DUMP.REGISTERS()~
   TL.OUT.DUMPED.REGS()~
   TL.STACK.PRINT~
   ADDR.PROC~
~S~O2.1 Hardware Interface
~BMC68000.
~S~O2.2 Software Interface
~BThis is described in MTL211.
~S~O3. Implementation
~S~O3.1 Outline of Operation
~BOperation is straightforward.
~S~O3.2 Data Structures
~BNone.
~Y
~V9 -1
~P
~D15
~HFLOWCHARTS
~
~
~H               MTL215
~V9 -1
~F
@TITLE MTL21(5,8)

@COL 1S-2R-3R-4R-5R-6F
@FLOW 1-2-3-4-5-6
@BOX 1.0
MACHINE DEPENDENT LIBRARY CODE
@BOX 4.0
PROCEDURES IN MODULE:
   1 TL ENTER
   2 RETURN FROM TRAP
   3 TL DUMP REGISTERS
   4 TL OUT DUMPED REGISTERS
   5 TL STACK PRINT
@BOX 6.0
END
@BOX 1.1
#MTL21/1
MODULE (TL.ENTER, RETURN.FROM.TRAP, TL.DUMP.REGISTERS,
   TL.OUT.DUMPED.REGS, TL.STACK.PRINT,ADDR.PROC);
@BOX 3.1
PSPEC TL.ENTER (INTEGER);
LSPEC RETURN.FROM.TRAP ();
PSPEC TL.DUMP.REGISTERS ();
PSPEC TL.OUT.DUMPED.REGS ();
PSPEC TL.STACK.PRINT ();
PSPEC DUMMYP();
PSPEC ADDR.PROC($LO32)/ADDR DUMMYP;
   #MTL21.1
   #MTL21.2
   #MTL21.3
   #MTL21.4
   #MTL21.5
   #MTL21.6
@BOX 6.1
*END
@END
@TITLE MTL21A(5,10)
@COL 1S-2R-3R-4R-5R-6F
@FLOW 1-2-3-4-5-6
@BOX 1.0
CROSS COMPILE LIBRARY
@BOX 2.0
@BOX 3.0
@BOX 4.0
PROCEDURES IN MODULE
   ADDR.PROC
@BOX 5.0
@BOX 6.0
END
@BOX 1.1
IMPORT LITERAL ADDR SYS14.SEG.SIZE;
IMPORT LITERAL INTEGER SYS14.SEG.SHIFT;
MODULE(DUMMYP,ADDR.PROC);
@BOX 2.1
@BOX 3.1
@BOX 4.1
PSPEC DUMMYP();
PSPEC ADDR.PROC($LO32)/ADDR DUMMYP;
   #MTL21.6
@BOX 5.1
@BOX 6.1
*END
@END
@TITLE MTL21/1(5,8)

@COL 1S-2R-3R-4R
@FLOW 1-2
@BOX 1.0
EXTERNAL ENVIRONMENT
@BOX 1.1
:: EXTERNAL ENVIRONMENT
@BOX 2.1
PSPEC OUT.HEX (LOGICAL32, INTEGER);
PSPEC SPACES (INTEGER);
PSPEC NEW.LINES (INTEGER);
PSPEC CAPTION (ADDR [LOGICAL8]);
PSPEC OUT.STACK (ADDR, ADDR);
IMPORT LITERAL INTEGER SYS14.SEG.SHIFT;
IMPORT LITERAL ADDR SYS14.SEG.SIZE;
@END

@TITLE MTL21.1(5,8)

@COL 1S-2R-3R-4R-5F
@FLOW 1-2-3-4
@BOX 1.0
TL ENTER
@BOX 2.0
CALCULATE ENTRY ADDRESS
@BOX 3.0
REMOVE TL ENTER'S STACK FRAME
@BOX 4.0
JUMP TO ENTRY ADDRESS
@BOX 5.0
END
@BOX 1.1
PROC TL.ENTER (SEG);
ADDR ENTRY.ADDR;
@BOX 2.1
SEG <<- SYS14.SEG.SHIFT => ENTRY.ADDR;
@BOX 3.1
*#%225F; :: MOVEAL (A7)+, A1
*#%2A5F; :: MOVEAL (A7)+, A5
*#%4E5E; :: UNLK A6
@BOX 4.1
*#%4ED1; :: JMP (A1)
@BOX 5.1
END
@END
@TITLE MTL21.2(5,8)

@COL 1S-2R-3R-4R-5R-6R-7F
@FLOW 1-2-3-4-5-6
@BOX 1.0
RETURN FROM TRAP
@BOX 2.0
UNWIND STACK BY ONE FRAME
@BOX 3.0
MOVE LINK INTO GAP ON STACK
@BOX 4.0
UNWIND STACK BY ONE FRAME
@BOX 5.0
RELOAD REGISTERS FROM
DUMP ON STACK
@BOX 6.0
RETURN AND SET CONDITION CODES
@BOX 7.0
END
@BOX 1.1
PROC RETURN.FROM.TRAP;
@BOX 2.1
*#%2C56; :: MOVEAL (A6), A6
@BOX 3.1
*#%2E4E; :: MOVEAL A6, A7
*#%2D6E %0004 %0046; :: MOVEL 4(A6), 70(A6)
@BOX 4.1
*#%2C56; :: MOVEAL (A6), A6
@BOX 5.1
*#%DFFC %0000 %000C; :: ADDAL #12, A7
*#%4CDF %3FFF; :: MOVEML (A7)+, D0 - D7, A0 - A5
@BOX 6.1
*#%4E77; :: RTR
@BOX 7.1
END
@END

@TITLE MTL21.3(5,8)

@COL 1S-2R-3R-4R-5F
@FLOW 1-2-3-4-5
@BOX 1.0
DUMP REGISTERS ON STACK
@BOX 2.0
MAKE ROOM ON STACK
@BOX 3.0
MOVE STACK FRAME DOWN
@BOX 4.0
MOVE REGISTERS INTO SPACE
CREATED ON STACK
@BOX 5.0
END
@BOX 1.1
PROC TL.DUMP.REGISTERS;
@BOX 2.1
*#%9EFC %003E; :: SUBAW #62, A7
@BOX 3.1
*#%2EAE %FFFC; :: MOVEL -4(A6), (A7)
*#%2F56 %0004; :: MOVEL (A6), 4(A7)
*#%2F6E %0004 %0008; :: MOVEL 4(A6), 8(A7)
@BOX 4.1
*#%9CFC %003E; :: SUBAW #62, A6
*#%48EE %1FFF %0008; :: MOVEML D0 - D7, A0 - A4, 8(A6)
*#%2D57 %003C; :: MOVEL (A7), 60(A6)
*#%426E %0040; :: CLRW 64(A6)
@BOX 5.1
END
@END

@TITLE MTL21.4(5,8)

@COL 1S-2R-3R-4R-5R-6R-7F
@FLOW 1-2-3-4-5-6-7
@BOX 1.0
OUT DUMPED REGISTERS
@BOX 2.0
INITIALIZE POINTER
@BOX 3.0
INITIALIZE STRING
@BOX 4.0
OUTPUT HARDWARE REGISTERS
@BOX 5.0
OUTPUT PW'S
@BOX 6.0
OUTPUT PWW'S
@BOX 7.0
END
@BOX 1.1
PROC TL.OUT.DUMPED.REGS;
ADDR DUMP.BASE, TEMP;
INTEGER I, J;
ADDR [ADDR] REG.PTR;
LOGICAL8 [7] STR;
@BOX 2.1
*#%2056; :: MOVEAL (A6), A0
*#%2D50 %FFF8; :: MOVEL (A0), -8(A6)
MAKE (ADDR, 17, DUMP.BASE) => REG.PTR;
@BOX 3.1
"D" => STR [0];
"0" => STR [1];
" " => STR [2] => STR [3] => STR [4] => STR [6];
"=" => STR [5];
CAPTION (%"$LREGISTER DUMP:$L$L");
@BOX 4.1
0 => J;
2 => I;
WHILE 1 +> I < 11 DO
   SPACES (4); CAPTION (^STR);
   OUT.HEX (REG.PTR^ [I] ,8);
   1 +> STR [1];
   IF 1 +> J = 4 THEN
      0 => J;
      NEWLINES (1);
   FI
OD
"A" => STR [0]; "0" => STR [1];
10 => I;
WHILE 1 +> I < 17 DO
   SPACES (4); CAPTION (^STR);
   OUT.HEX (REG.PTR^ [I], 8);
   1 +> STR [1];
   IF 1 +> J = 4 THEN
      0 => J;
      NEWLINES (1);
   FI
OD
SPACES (4); CAPTION (^STR);
OUT.HEX (REG.PTR^ [0], 8);
1 +> STR [1];
SPACES (4); CAPTION (^STR);
OUT.HEX (DUMP.BASE + 74, 8);
NEWLINES (1);
CAPTION (%"    PC   = ");
OUT.HEX (REG.PTR^ [1], 8);
NEWLINES (2);
@BOX 5.1
"P" => STR [0];
"W" => STR [1];
"0" => STR [2];
MAKE (ADDR, 11, 0) => REG.PTR;
FOR I < 7 DO
   SPACES (4); CAPTION (^STR);
   OUT.HEX (REG.PTR^ [I], 8);
   1 +> STR [2];
   IF I = 3 THEN
      NEWLINES (1);
   FI
OD
NEWLINES (2);
@BOX 6.1
"W" => STR [2];
"1" => STR [3];
5 => I;
WHILE 2 +> I < 11 DO
   SPACES (4); CAPTION (^STR);
   OUT.HEX (REG.PTR^ [I], 8);
   OUT.HEX (REG.PTR^ [I + 1], 8);
   1 +> STR [3];
OD
NEWLINES (2);
@BOX 7.1
END
@END

@TITLE MTL21.5(5,8)

@COL 1S-2R-3F

@FLOW 1-2-3

@BOX 1.0
STACK PRINT
@BOX 2.0
PRINT THE STACK
@BOX 3.0
END
@BOX 1.1
PROC TL.STACK.PRINT;
@BOX 2.1
OUT.STACK (0, SYS14.SEG.SIZE - 1);
@BOX 3.1
END
@END

@TITLE MTL21.6(5,10)
@COL 1S-2R-3F
@FLOW 1-2-3
@BOX 1.0
ADDR.PROC(FIND.N)PROC.ADDRESS
@BOX 2.0
CALCULATE PROC ADDRESS
@BOX 3.0
END
@BOX 1.1
PROC ADDR.PROC(FN);
TYPE T IS $LO32 AD OR ADDR DUMMYP P.AD;
T V;
@BOX 2.1
FN & %FF * 6 !(FN ->> 16 & %7FFF
<<- SYS14.SEG.SHIFT) =>  AD OF V;
P.AD OF V => ADDR.PROC;
@BOX 3.1
END
@END
