@X @~
~V7 56 2 -5
~D10
~H                    MUSS
~
~
~D10
~H            MTL213
~D10
~MMANCHESTER UNIVERSITY  -  CONFIDENTIAL~
~
~
                                                                      ISSUE 11~
~V9 -1
~P
~V9 1
~YMTL213
~S~M~OMUTL IMPLEMENTATION DESCRIPTION
~S~M~OSection 21 Version 3 (VAX)
~S~OSection 21.3 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~
~S~O2.1 Hardware Interface
~BVax.
~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               MTL213
~V9 -1
~F
@TITLE MTL21(3,10)
@COL 1S-2R-3R-4F
@FLOW 1-2-3-4
@BOX 1.0
MUTL RUN TIME
MACHINE DEPENDENT SUPPORT
@BOX 2.0
INITIALISATION AND
DECLARATIONS
@BOX 3.0
PROCEDURES
MTL21.2 TL.ENTER
MTL21.3 RETURN.FROM.TRAP
MTL21.4 TL.DUMP.REGISTERS
MTL21.5 TL.OUT.DUMPED.REGS
MTL21.6 TL.STACK.PRINT
MTL21.7 ADDR.PROC
@BOX 4.0
END
@BOX 1.1
PSPEC OUTHEX (LOGICAL32, INTEGER);
PSPEC SPACES (INTEGER);
PSPEC NEWLINES (INTEGER);
PSPEC CAPTION  (ADDR [LOGICAL8]);
PSPEC OUTSTACK (ADDR, ADDR);
PSPEC OUT.I(INTEGER,INTEGER);
PSPEC OUT.CH(INTEGER);
ADDR PW1;
IMPORT LITERAL SYS14.SEG.SHIFT;
MODULE( TL.ENTER, RETURN.FROM.TRAP,
          TL.DUMP.REGISTERS, TL.OUT.DUMPED.REGS,
          TL.STACK.PRINT,ADDR.PROC)
@BOX 2.1
*GLOBAL 9;
$IN RUN.ADDR;
*CODE 1;
PSPEC TL.ENTER ($IN);
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;
@BOX 3.1
#MTL21.2
#MTL21.3
#MTL21.4
#MTL21.5
#MTL21.6
#MTL21.7
@BOX 4.1
*END
@END
@TITLE MTL21A(3,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 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.7
@BOX 5.1
@BOX 6.1
*END
@END
@TITLE MTL21.2(3,8)
@COL 1S-3R-4F
@FLOW 1-3-4
@BOX 1.0
RUN
@BOX3.0
ENTER CUR. PROG
AT 'RUN.ADDR'
@BOX 4.0
END
@BOX 1.1
PROC TL.ENTER(SEG);
@BOX 3.1
SEG <<- SYS14.SEG.SHIFT => PW1;
*# %D0 %9F 4 0 0 0 %52  %17 %62;
@BOX 4.1
END
@END
@TITLE MTL21.3(3,8)

@COL 1S-2R-3R-4R-5F
@FLOW 1-2-3-4-5
@BOX 1.0
RETURN FROM TRAP
@BOX 2.0
ALTER STACK FRAME MASK
OF THE CALLING PROCEDURE
@BOX 3.0
INCORPORATE REGISTERS DUMPED
ABOVE THE CALLING PROCEDURE
INTO ITS STACK FRAME
@BOX 4.0
UNWIND STACK ONE FRAME
@BOX 5.0
END
@BOX 1.1
PROC RETURN.FROM.TRAP;
LOGICAL REG.BASE, TEMP.REG;
INTEGER I;
ADDR [LOGICAL] REG.PTR;
@BOX 2.1
*#%D0 %AD %0C %52; :: MOVL 12(R13), R2
*#%B0 %8F %FF %2F %A2 %06; :: M0VW %2FFF, 6(R2)
@BOX 3.1
*#%C1 %52 %14 %AD %FC; :: ADDL3 R2, 20, -4(R13)
MAKE (LOGICAL, 15, REG.BASE) => REG.PTR;
REG.PTR^ [0] => TEMP.REG;
FOR I < 11 DO
   REG.PTR^ [I + 4] => REG.PTR^ [I];
OD
TEMP.REG => REG.PTR^ [11];
2 => REG.PTR^ [12];
@BOX 4.1
*#%D0 %AD %0C %5D; :: MOVEL 12(R13), R13
@BOX 5.1
END
@END

@TITLE MTL21.4(3,8)

@COL 1S-2R-3R-4R-5R-6F
@FLOW 1-2-3-4-5-6
@BOX 1.0
DUMP REGISTERS ON STACK
@BOX 2.0
MAKE ROOM ON STACK
PUSH REGISTERS
@BOX 3.0
INITIALIZE POINTERS
@BOX 4.0
MOVE STACK FRAME DOWN
@BOX 5.0
MOVE DUMPED REGISTERS
INTO GAP CREATED
ABOVE STACK FRAME
@BOX 6.0
END
@BOX 1.1
PROC TL.DUMP.REGISTERS;
@BOX 2.1
*#%C2 %2C %5E; :: SUBL2 44, R14
*#%BB %8F %FF %07; :: PUSHR 0 - 10
@BOX 3.1
*#%C1 %1C %5D %51; :: ADDL3 28, R13, R1
*#%C2 %10 %5D; :: SUBL2 16, R13
*#%D0 %5D %52; :: MOVL R13, R2
@BOX 4.1
*#%D0 %07 %50; :: MOVL 7, R0
*#%F4 %50 %02; :: SOBGEQ R0, 2
*#%11 %05; :: BRB 5
*#%D0 %71 %7D; :: MOVL -(R1), -(R13)
*#%11 %F6; :: BRB -10
@BOX 5.1
*#%D0 %0B %50; :: MOVL 11, R0
*#%F4 %50 %02; :: SOBGEQ R0, 2
*#%11 %05; :: BRB 5
*#%D0 %8E %82; :: MOVL (R14)+, (R2)+
*#%11 %F6; :: BRB -10
@BOX 6.1
END
@END

@TITLE MTL21.5(3,,10)

@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;
LOGICAL DUMP.BASE;
INTEGER I, J;
ADDR [LOGICAL] REG.PTR;
LOGICAL8 [7] STR;
@BOX 2.1
*#%D0 %AD %0C %52; :: MOVL 12(R13), R2
*#%C1 %08 %A2 %0C %AD %FC; :: ADDL3 8, 12(R2), -4(R13)
MAKE (LOGICAL, 18, DUMP.BASE) => REG.PTR;
@BOX 3.1
"R" => 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;
6 => I;
WHILE 1 +> I < 17 DO
   SPACES (4); CAPTION (^STR); OUTHEX (REG.PTR^ [I], 8);
   1 +> STR [1];
   IF 1 +> J = 4 THEN
      0 => J;
      NEWLINES (1);
   FI
OD
"1" => STR [1]; "0" => STR [2];
SPACES (4); CAPTION (^STR); OUTHEX (REG.PTR^ [17], 8);
1 +> STR [2];
SPACES (4); CAPTION (^STR); OUTHEX (REG.PTR^ [3], 8);
NEWLINES (1);
1 +> STR [2];
FOR I < 2 DO
   SPACES (4); CAPTION (^STR); OUTHEX (REG.PTR^ [I], 8);
   1 +> STR [2];
OD
SPACES (4); CAPTION (^STR); OUTHEX (DUMP.BASE + 72, 8);
1 +> STR [2];
SPACES (4); CAPTION (^STR); OUTHEX (REG.PTR^ [2], 8);
NEWLINES (2);
@BOX 5.1
"P" => STR [0];
"W" => STR [1];
"0" => STR [2];
MAKE (LOGICAL, 12, 0) => REG.PTR;
FOR I < 7 DO
   SPACES (4); CAPTION (^STR); OUTHEX (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];
6 => I;
WHILE 2 +> I < 12 DO
   SPACES (4); CAPTION (^STR);
   OUTHEX (REG.PTR^ [I + 1], 8); OUTHEX (REG.PTR^ [I], 8);
   1 +> STR [3];
OD
NEWLINES (2);
@BOX 7.1
END
@END

@TITLE MTL21.6(3,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
OUTSTACK (0, %FFFF);
@BOX 3.1
END
@END

@TITLE MTL21.7(3,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 * 8 - 4 !(FN ->> 16 & %7FFF
<<- SYS14.SEG.SHIFT) =>  AD OF V;
P.AD OF V => ADDR.PROC;
@BOX 3.1
END
@END
