DIRECTORY
Basics USING [BYTE, RawBytes],
MesaRuntimeInit USING [],
PrincOps USING [ControlLink, ControlModule, Frame, FrameCodeBase, FrameHandle, GFT, GFTItem, GlobalFrameHandle, MainBodyIndex, NullControl, NullFrame, NullGlobalFrame, Port, PortHandle, PrefixHandle, sBoundsFault, sControlFault, SD, sDivideCheck, sError, sHardwareError, sPointerFault, sRestart, sStackError, sStart, sSwapTrap, StateVector, sUnbound, SVPointer, sWakeupError, sZeroDivisor, zAND, zDESCBS, zLDIV, zPORTI, zPORTO, zSFC],
PrincOpsUtils USING [Codebase, Free, GetReturnFrame, GetReturnLink, MyLocalFrame, ReadOTP, SetReturnFrame, SetReturnLink],
RuntimeError USING [];

TrapsImpl: PROGRAM
IMPORTS PrincOpsUtils
EXPORTS MesaRuntimeInit, RuntimeError
= BEGIN OPEN PrincOps;


CodeBytesPtr: TYPE = LONG POINTER TO Basics.RawBytes;


BoundsFault: PUBLIC ERROR = CODE;
ControlFault: PUBLIC SIGNAL [source: ControlLink] RETURNS [ControlLink] = CODE;
DivideCheck: PUBLIC SAFE SIGNAL = CODE;
HardwareError: PRIVATE ERROR = CODE;
LinkageFault: PUBLIC ERROR = CODE;
PointerFault: PUBLIC ERROR = CODE;
PortFault: PUBLIC ERROR = CODE;
StartFault: PUBLIC SIGNAL [dest: PROGRAM] = CODE;
StackError: PUBLIC ERROR = CODE;
UnboundProcedure: PUBLIC SIGNAL [dest: ControlLink] RETURNS [ControlLink] = CODE;
WakeupError: ERROR = CODE;
ZeroDivisor: PUBLIC SAFE SIGNAL = CODE;

Start: PUBLIC PROC [cm: PrincOps.ControlModule] = {
CM: PROGRAM _ LOOPHOLE[cm];
state: StateVector;
state _ STATE;
IF ~cm.multiple THEN {
OPEN f: cm.frame;
IF @f = NullGlobalFrame OR f.started THEN ERROR StartFault[CM];
StartCM[LOOPHOLE[f.global[0]], @f, @state];
IF ~f.started THEN {f.started _ TRUE; StartWithState[@f, @state]}
ELSE IF state.stkptr ~= 0 THEN SIGNAL StartFault[CM];
}
ELSE {
StartCM[cm, NIL, NIL];
IF state.stkptr ~= 0 THEN SIGNAL StartFault[CM];
};
};


Restart: PUBLIC PROC [dest: GlobalFrameHandle] = {
stops: BOOL;
frame: FrameHandle;
IF dest = NullGlobalFrame THEN ERROR StartFault[LOOPHOLE[dest, PROGRAM]];
IF ~dest.started THEN Start[[frame[dest]]];
stops _ PrincOpsUtils.Codebase[dest].header.info.stops;
IF ~stops THEN ERROR StartFault[LOOPHOLE[dest, PROGRAM]];
IF (frame _ LOOPHOLE[dest.global[0]]) ~= NullFrame THEN {
frame.returnlink _ PrincOpsUtils.GetReturnLink[];
PrincOpsUtils.SetReturnFrame[frame]
}
};

StartCM: PROC [cm: ControlModule, frame: GlobalFrameHandle, state: SVPointer] = {
Call: PROC [ControlLink] = MACHINE CODE {zSFC};
SELECT TRUE FROM
cm = NullControl => RETURN;
cm.multiple => {
length: CARDINAL;
cm.multiple _ FALSE;
IF (length _ cm.list.nModules) = 0 THEN RETURN;
cm.list.nModules _ 0;
FOR i: CARDINAL IN [0..length) DO
StartCM[[frame[cm.list.frames[i]]], frame, state];
ENDLOOP;
PrincOpsUtils.Free[cm.list];
};
cm.frame.started => RETURN;
ENDCASE => {
control: ControlModule _ LOOPHOLE[cm.frame.global[0]];
IF control ~= cm THEN StartCM[control, frame, state];
IF ~cm.frame.started THEN {
cm.frame.started _ TRUE;
IF frame ~= cm.frame THEN Call[MainBody[cm.frame]]
ELSE StartWithState[frame, state];
};
};
};

StartWithState: PROC [frame: GlobalFrameHandle, state: PrincOps.SVPointer] = {
s: StateVector _ state^;
retFrame: FrameHandle _ PrincOpsUtils.GetReturnLink[].frame;
s.dest _ MainBody[frame];
PrincOpsUtils.SetReturnLink[s.source _ retFrame.returnlink];  -- allows stack trace if RETURN WITH s faults.
PrincOpsUtils.Free[retFrame];
RETURN WITH s
};


BoundsFaultTrap: PROC = {
frame: FrameHandle;
state: RECORD [a: WORD, v: StateVector];
state.v _ STATE;
state.v.dest _ ControlLink[frame[frame _ PrincOpsUtils.GetReturnFrame[]]];
BumpPC[frame, 1];
state.v.stkptr _ state.v.stkptr - 1;
ERROR BoundsFault;  -- pc is advanced on this trap
};

CodeTrap: PROC = {
dest: ControlLink;
state: StateVector;
frame: GlobalFrameHandle;
state _ STATE;
dest _ PrincOpsUtils.ReadOTP[];
state.dest _ PrincOpsUtils.GetReturnLink[];
DO
IF dest.proc THEN {frame _ GetFrame[GFT[dest.gfi]]; EXIT};
IF NOT dest.indirect THEN {frame _ dest.frame.accesslink; EXIT};
dest _ dest.link^;
ENDLOOP;
IF ~frame.started THEN Start[[frame[frame]]];
frame.code.out _ FALSE;
RETURN WITH state
};

DivideCheckTrap: PROC = {
frame: FrameHandle;
state: RECORD [a: WORD, v: StateVector];
state.v _ STATE;
state.v.dest _ ControlLink[frame[frame _ PrincOpsUtils.GetReturnFrame[]]];
BumpPC[frame, 1];
state.v.stkptr _ state.v.stkptr - 2;
SIGNAL DivideCheck; -- pc is advanced on this trap
RETURN WITH state.v
};

HardwareErrorTrap: PROC = {
state: RECORD [a, b: WORD, v: StateVector];
state.v _ STATE;
ERROR HardwareError
};

PointerFaultTrap: PROC = {
frame: FrameHandle;
state: RECORD [a: WORD, v: StateVector];
state.v _ STATE;
state.v.dest _ ControlLink[frame[frame _ PrincOpsUtils.GetReturnFrame[]]];
BumpPC[frame, 1];
ERROR PointerFault; -- pc is advanced on this trap
};

StackErrorTrap: PROC = {
state: RECORD [a: WORD, v: StateVector];
foo: BOOL;
state.v _ STATE;
foo _ TRUE; -- The garbage with foo is so all the code for the next statement
IF foo THEN ERROR StackError
};

OpcodeLengths: PACKED ARRAY [0..255] OF [0..3] = [
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2, 2, 1, 1, 1, 1, 1, 1, 1, 1, 2, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 2, 2, 1, 1, 1, 1, 2, 1, 1,
1, 1, 1, 1, 1, 1, 1, 2, 3, 2, 2, 2, 3, 0, 0, 0,
1, 1, 1, 1, 1, 2, 1, 1, 1, 2, 3, 3, 2, 1, 2, 1,
2, 2, 2, 2, 2, 2, 2, 1, 1, 2, 3, 2, 3, 1, 1, 2,
2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 2, 3, 3, 1,
1, 1, 2, 2, 1, 1, 1, 2, 1, 1, 1, 1, 0, 0, 0, 0,
1, 1, 1, 1, 1, 1, 1, 1, 2, 3, 1, 1, 1, 1, 1, 1,
1, 1, 2, 1, 1, 1, 1, 1, 1, 1, 1, 2, 2, 2, 2, 2,
2, 2, 2, 2, 2, 2, 3, 3, 1, 1, 1, 1, 1, 1, 1, 1,
1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, 0, 0,
1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
2, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1,
1, 2, 1, 1, 2, 1, 1, 2, 2, 2, 1, 1, 1, 1, 1, 1,
1, 1, 1, 2, 2, 1, 1, 1, 2, 2, 2, 0, 2, 2, 1, 0];

UnboundProcedureTrap: PROC = {
sourceOp: Basics.BYTE;
frame: FrameHandle;
dest: ControlLink;
state: StateVector;
state _ STATE;
dest _ PrincOpsUtils.ReadOTP[];
state.dest _ ControlLink[frame[frame _ PrincOpsUtils.GetReturnFrame[]]];
BumpPC[frame, OpcodeLengths[sourceOp _ GetCodeBytes[frame][frame.pc]]];
IF sourceOp = zSFC OR sourceOp = zPORTO THEN state.stkptr _ state.stkptr - 1;
[] _ SIGNAL UnboundProcedure[dest];
RETURN WITH state
};

WakeupErrorTrap: PROC = {
state: RECORD [a, b: WORD, v: StateVector];
state.v _ STATE;
ERROR WakeupError
};

ZeroDivisorTrap: PROC = {
frame: FrameHandle;
state: RECORD [a: WORD, v: StateVector];
state.v _ STATE;
state.v.dest _ ControlLink[frame[frame _ PrincOpsUtils.GetReturnFrame[]]];
state.v.stkptr _ state.v.stkptr - (IF GetCodeBytes[frame][frame.pc] = zLDIV THEN 2 ELSE 1);
BumpPC[frame, 1];
SIGNAL ZeroDivisor; -- pc is advanced on this trap
RETURN WITH state.v
};

ControlFaultTrap: PROC = {
errorStart, savedState: StateVector;
sourceOp: Basics.BYTE;
PORTI: PROC = MACHINE CODE {zPORTI};
p, q: PortHandle;
sourceFrame, self: FrameHandle;
source: ControlLink;
savedState _ STATE;
self _ PrincOpsUtils.MyLocalFrame[];
sourceFrame _ self.returnlink.frame;
source _ PrincOpsUtils.ReadOTP[];
sourceOp _ GetCodeBytes[sourceFrame][sourceFrame.pc];
BumpPC[sourceFrame, OpcodeLengths[sourceOp]];
IF sourceOp = zPORTO
THEN {
savedState.stkptr _ savedState.stkptr - 1;
p _ source.port;
q _ p.dest.port;
IF q = NIL
THEN errorStart.stk[0] _ LOOPHOLE[LinkageFault]
ELSE {
q^ _ Port[links[NullFrame, [indirect[port[p]]]]];
errorStart.stk[0] _ LOOPHOLE[PortFault];
};
errorStart.stk[1] _ 0; -- message
errorStart.instbyte _ 0;
errorStart.stkptr _ 2;
errorStart.source _ sourceFrame.returnlink;
errorStart.dest _ LOOPHOLE[SD[sError]];
IF savedState.stkptr = 0 THEN RETURN WITH errorStart --  RESPONDING port
ELSE {
p.frame _ self;
TRANSFER WITH errorStart;
PORTI[];
p.frame _ sourceFrame;
savedState.stk[savedState.stkptr + 1] _ LOOPHOLE[savedState.source _ ControlLink[indirect[port[p]]]];
savedState.stk[savedState.stkptr] _ LOOPHOLE[savedState.dest _ p.dest];
RETURN WITH savedState
}
}
ELSE {-- not a port call
IF sourceOp = zSFC THEN savedState.stkptr _ savedState.stkptr - 1;
savedState.dest _ ControlLink[frame[sourceFrame]];
[] _ SIGNAL ControlFault[LOOPHOLE[sourceFrame]];
RETURN WITH savedState -- to press on
}
};


BumpPC: PROC [f: FrameHandle, i: INTEGER] = INLINE {f.pc _ [f.pc + i]};

GetCodeBytes: PROC [frame: FrameHandle] RETURNS [CodeBytesPtr] = INLINE {
RETURN[LOOPHOLE[frame.accesslink.code.longbase]]};

MainBody: PROC [GlobalFrameHandle] RETURNS [ControlLink] =
MACHINE CODE {zDESCBS, MainBodyIndex};

GetFrame: PROC [g: GFTItem] RETURNS [GlobalFrameHandle] = INLINE {
And: PROC [g: GFTItem, mask: GFTItem] RETURNS [GlobalFrameHandle] = 
MACHINE CODE {zAND};
maskFrame: GFTItem = [ep[data: 37777B, epbias: 0]];
RETURN[And[g, maskFrame]]
};

Initialize: PROC = {
pSD: POINTER TO ARRAY NAT OF PROC ANY RETURNS ANY _ LOOPHOLE[SD];
pSD[sBoundsFault] _ BoundsFaultTrap;
pSD[sControlFault] _ ControlFaultTrap;
pSD[sDivideCheck] _ DivideCheckTrap;
pSD[sHardwareError] _ HardwareErrorTrap;
pSD[sPointerFault] _ PointerFaultTrap;
pSD[sRestart] _ Restart;
pSD[sStackError] _ StackErrorTrap;
pSD[sStart] _ Start;
pSD[sSwapTrap] _ CodeTrap;
pSD[sUnbound] _ UnboundProcedureTrap;
pSD[sWakeupError] _ WakeupErrorTrap;
pSD[sZeroDivisor] _ ZeroDivisorTrap;
};

Initialize[];

END.





ΞTrapsImpl.mesa
Copyright c 1985 by Xerox Corporation.  All rights reserved.
Levin on September 20, 1983 11:12 am
Russ Atkinson (RRA) February 19, 1985 1:18:43 pm PST
Types and Related Declarations
Exported to RuntimeError

Exported to MesaRuntimeInit
Language support routines
Internal Procedures to support language support routines

Trap Handlers
RETURN WITH state.v
RETURN WITH state.v
looks like it is in this procedure
to the debugger (when it looks in the fine grain table)
The following should be exported by InstructionsImpl, or, in Trinity, the ProcessorFace.

lets UNWIND skip trapping frame
Assert: there is a (possibly stubbed) signaller
Internal procedures to support trap handlers
Initialization

Κ{–

"Cedar" style˜
codeš
œ™Kšœ
Οm
œ1™<K™$J™4—K˜š
Οk	˜	Kšœžœžœ˜Kšœžœ˜Kšœ	žœAžœ“
žœΛ
˜²Kšœžœg˜zKšœ
žœ˜K˜—šœž˜Kšžœ˜Kšžœ˜%Kšœž
œ
˜—K˜™K˜Kšœžœžœ
žœ
žœž
œ	˜5K˜—š
œ™K˜Kšœ
žœ
žœžœ
˜!Kš	œžœ
žœžœžœ
˜OKš	œ
žœ
žœ
žœžœ
˜'Kšœžœ
žœžœ
˜$Kšœžœ
žœžœ
˜"Kšœžœ
žœžœ
˜"Kšœžœ
žœžœ
˜Kš	œžœ
žœžœžœ
˜1Kšœžœ
žœžœ
˜ Kš	œžœ
žœžœžœ
˜QKšœ
žœžœ
˜Kš	œ
žœ
žœ
žœžœ
˜'—K™Kš
œ™˜šΟnœžœ
žœ!˜3Kšžœžœžœ˜Kš
œ˜Kšœžœ
˜šžœžœ˜Kšžœ
˜Kš
žœžœžœ
žœžœ˜?Kšœžœ˜+Kšžœžœžœ˜AKš
žœ
žœžœ
žœžœ˜5Kš
œ
˜
—šžœ˜Kšœžœžœ˜Kšžœžœ
žœžœ˜0Kš
œ˜—Kš
œ˜K˜——K™K˜šŸœžœ
žœ˜2Kšœžœ
˜K˜Kš
žœžœ
žœžœžœ˜IKšžœžœ˜+Kš
œ7˜7Kš
žœžœ
žœžœžœ˜9šžœ
žœžœ˜9Kš
œ1˜1Kš
œ#˜#Kš
œ
˜
—Kš
œ˜—K˜Kš
Οc8™8K™šŸœžœD˜QKšŸœžœžœ
žœ˜/šžœ
žœ
ž˜Kšœžœ
˜˜Kšœžœ
˜Kšœžœ
˜Kšžœ!žœ
žœ
˜/K˜šžœžœ
žœ
ž˜!Kš
œ2˜2Kšžœ
˜—K˜Kš
œ˜—Kšœžœ
˜šžœ˜Kšœžœ˜6Kšžœžœ ˜5šžœžœ˜Kšœžœ
˜Kšžœžœ˜2Kšžœ˜"Kš
œ˜—Kš
œ˜——Kš
œ˜K˜—šŸœžœ:˜NK˜K˜<K˜Kšœ> .˜lKš
œ˜Kšžœ
žœ˜
Kš
œ˜K˜—Kš
œ
™
K˜šŸœžœ˜K˜Kšœžœžœ˜(Kšœ
žœ
˜K˜JK˜K˜$Kšžœ ˜2Kš
œ™Kš
œ˜K˜—šŸœžœ˜K˜K˜K˜Kšœžœ
˜K˜K˜+š
ž˜Kšžœžœžœ
žœ˜:Kšžœ
žœžœ!žœ˜@Kš
œ˜Kšžœ
˜—Kšžœžœ˜-Kšœžœ
˜Kšžœ
žœ˜Kš
œ˜K˜—šŸœžœ˜K˜Kšœžœžœ˜(Kšœ
žœ
˜K˜JK˜K˜$Kšžœ ˜2Kšžœ
žœ˜Kš
œ˜K˜—šŸœžœ˜Kšœžœžœ˜+Kšœ
žœ
˜Kšžœ˜Kš
œ˜K˜—šŸœžœ˜K˜Kšœžœžœ˜(Kšœ
žœ
˜K˜JK˜Kšžœ ˜2Kš
œ™Kš
œ˜K˜—šŸœžœ˜Kšœžœžœ˜(Kšœžœ
˜
Kšœ
žœ
˜Kšœžœ A˜MKš
œ"™"Kš
œ7™7Kšžœžœ
žœ˜Kš
œ˜K˜—Kš
œX™XK™šœžœ
žœ
žœ˜2Kš
œ/˜/Kš
œ/˜/Kš
œ/˜/Kš
œ/˜/Kš
œ/˜/Kš
œ/˜/Kš
œ/˜/Kš
œ/˜/Kš
œ/˜/Kš
œ/˜/Kš
œ/˜/Kš
œ/˜/Kš
œ/˜/Kš
œ/˜/Kš
œ/˜/Kš
œ0˜0K˜—šŸœžœ˜Kšœžœ
˜K˜K˜K˜Kšœžœ
˜K˜K˜HK˜GKšžœžœžœ!˜MKšœžœ˜#Kšžœ
žœ˜Kš
œ˜K˜—šŸœžœ˜Kšœžœžœ˜+Kšœ
žœ
˜Kšžœ˜Kš
œ˜K˜—šŸœžœ˜K˜Kšœžœžœ˜(Kšœ
žœ
˜K˜JKšœ#žœ'žœžœ˜[K˜Kšžœ ˜2Kšžœ
žœ˜Kš
œ˜K˜—šŸœžœ˜K˜$Kšœžœ
˜Kšžœžœžœ
žœ
˜$K˜K˜K˜Kšœ
žœ
˜K˜$K˜$K˜!K˜5K˜-šžœ˜šžœ˜K˜*K˜K˜šžœž˜
Kšžœžœ˜/šžœ˜K˜1Kšœžœ˜(Kš
œ˜——Kšœ 
˜!K˜K˜K˜+Kš
œ™Kšœžœ
žœ
˜'Kš	žœžœ
žœ
žœ ˜Hšžœ˜K˜Kšžœ
žœ˜Kšžœ˜K˜Kšœ(žœ5˜eKšœ$žœ˜GKšžœ
žœ˜Kš
œ
˜
—Kš
œ
˜
—šžœ ˜Kšžœžœ+˜BKš
œ/™/K˜2Kšœžœžœ˜0Kšžœ
žœ ˜%Kš
œ
˜
——Kš
œ˜K˜—™,K˜KšŸœžœžœžœ˜GK˜šŸœžœžœžœ˜IKšžœ
žœ#˜2K˜—šŸœžœžœ˜:Kšžœ
žœ˜&—K˜šŸœžœžœžœ˜BšŸœžœžœ˜DKšžœ
žœ˜—K˜3Kšžœ˜K˜—K˜—š
œ™K™šŸ
œžœ˜Kšœžœ
žœ
žœ
žœ
žœ
žœ
žœ
žœ
žœžœ
žœ˜AK˜$K˜&K˜$K˜(K˜&K˜K˜"K˜K˜K˜%K˜$K˜$š
œ˜K˜——K˜
K˜—Kšžœ
˜K˜K˜K˜K˜K˜—…—#ζ2/