DIRECTORY
Breakpoint,
BreakpointPrivate,
BreakWorldArchitecture,
Rope USING [ROPE],
Shepherd,
SPARCArchitecture,
SPARCBreakpoint,
SPARCBreakWorldUtilities,
SPARCManger,
TargetArchitecture;

SPARCBreakpointImpl: CEDAR PROGRAM 
IMPORTS 
Breakpoint, BreakpointPrivate, BreakWorldArchitecture, Shepherd, SPARCArchitecture, SPARCBreakWorldUtilities, SPARCManger, TargetArchitecture

~ {
SetBreakpoint: BreakpointPrivate.SetBreakProcType ~ {
break: Breakpoint.Break _ Breakpoint.nullBreak;
patch: Shepherd.Patch _ Shepherd.nullPatch;
errorCode: Breakpoint.ErrorCode _ Breakpoint.nullErrorCode;
errorMessage: Breakpoint.ErrorMessage _ Breakpoint.nullErrorMessage;
CheckForDelaySlot: PROCEDURE [address: BreakWorldArchitecture.Address] 
RETURNS [] ~{
instruction: SPARCArchitecture.SPARCInstruction ~
SPARCBreakWorldUtilities.SPARCInstructionFromBreakWorldAddress[address: address];
prevInstruction: SPARCArchitecture.SPARCInstruction ~
SPARCBreakWorldUtilities.SPARCInstructionFromBreakWorldAddress[
address: address, displacement: -BYTES[SPARCArchitecture.SPARCInstruction]];
nextInstruction: SPARCArchitecture.SPARCInstruction ~
SPARCBreakWorldUtilities.SPARCInstructionFromBreakWorldAddress[
address: address, displacement: +BYTES[SPARCArchitecture.SPARCInstruction]];
IF SPARCArchitecture.IsDelayedControlTransfer[instruction: prevInstruction] THEN {
ERROR Breakpoint.CantSet[
code: $NotInDelaySlot, message: "Cannot set breakpoint in delay slot"];
};
RETURN;
};

IF address.IsNullAddress[] THEN {
ERROR Breakpoint.CantSet[
code: $NotAtNullAddress, message: "Cannot set breakpoint at null address"];
};
IF breakProc.IsNullAddress[] THEN {
ERROR Breakpoint.CantSet[
code: $NotWithNullAddress, 
message: "Cannot set breakpoint with null break procedure world address"];
};
{
breakProcTargetAddress: TargetArchitecture.Address ~ 
breakProc.TargetAddressFromBreakWorldAddress[];

IF breakProcTargetAddress.IsNullAddress[] THEN {
ERROR Breakpoint.CantSet[
code: $NotWithNullAddress, 
message: "Cannot set breakpoint with null break procedure target address"];
};
};
CheckForDelaySlot[address: address];
{	-- extra scope to contain EXITS
patch _ Shepherd.ReservePatch[
pc: address, codeSize: BYTES[SPARCBreakpoint.PatchStruct]
! Shepherd.NoMeadow => {
errorCode _ $NoMeadow;
errorMessage _ message;
GO TO Cannot;
};
  Shepherd.BusyMeadow => {
errorCode _ $BusyMeadow;
errorMessage _ message;
GO TO Cannot;
};
  Shepherd.BusyPC => {
errorCode _ $BusyPC;
errorMessage _ message;
GO TO Cannot;
};
  Shepherd.NoRoom => {
errorCode _ $NoRoom;
errorMessage _ message;
GO TO Cannot;
};
  Shepherd.CantReach => {
errorCode _ $CantReach;
errorMessage _ message;
GO TO Cannot;
};
];
Install[
address: address, 
patch: patch, 
breakProc: breakProc, 
breakData: breakData, 
damages: damages];
break _ Breakpoint.NewBreak[address: address, patch: patch, clientData: clientData];
Breakpoint.RememberBreak[break
! Breakpoint.Cant => {
errorCode _ $CantRemember;
errorMessage _ message;
GO TO Cannot;
};];
EXITS
Cannot => {
ERROR Breakpoint.CantSet[code: errorCode, message: errorMessage];
};
};
RETURN [break];
};

Install: PROCEDURE [
address: BreakWorldArchitecture.Address, 
patch: Shepherd.Patch,
breakProc: Breakpoint.BreakProc,
breakData: Breakpoint.BreakData, 
damages: TargetArchitecture.RegisterClass] 
RETURNS [] ~ {
IF address.IsNullAddress[] THEN {
ERROR Breakpoint.CantSet[code: $NullAddress, message: "Install[nullAddress]"];
};
IF patch.IsNullPatch[] THEN {
ERROR Breakpoint.CantSet[code: $NullPatch, message: "Install[nullPatch]"];
};
IF breakProc.IsNullAddress[] THEN {
ERROR Breakpoint.CantSet[code: $NullAddress, message: "Install[nullBreakProc]"];
};
InstallClosureCaller[
address: address, 
patch: patch, 
breakProc: breakProc, 
breakData: breakData, 
damages: damages];
InstallManger[address: address, patch: patch];
};

InstallClosureCaller: PROCEDURE [
address: BreakWorldArchitecture.Address, 
patch: Shepherd.Patch,
breakProc: Breakpoint.BreakProc,
breakData: Breakpoint.BreakData, 
damages: TargetArchitecture.RegisterClass] 
RETURNS [] ~ {
IF address.IsNullAddress[] THEN {
ERROR Breakpoint.CantSet[
code: $NullAddress, message: "InstallClosureCaller[nullAddress]"];
};
IF breakProc.IsNullAddress[] THEN {
ERROR Breakpoint.CantSet[
code: $NullAddress, message: "InstallClosureCaller[nullBreakProc]"];
};
IF patch.IsNullPatch[] THEN {
ERROR Breakpoint.CantSet[
code: $NullPatch, message: "InstallClosureCaller[nullPatch]"];
};
{
instructionAddress: SPARCArchitecture.SPARCAddress ~
SPARCBreakWorldUtilities.SPARCAddressFromBreakWorldAddress[address: address];
patchAddress: BreakWorldArchitecture.Address ~ Shepherd.CodeAddressFromPatch[patch: patch];
patchSPARCAddress: SPARCArchitecture.SPARCAddress ~ 
SPARCBreakWorldUtilities.SPARCAddressFromBreakWorldAddress[address: patchAddress];
frameSize: INT ~ 
SPARCArchitecture.stackPointerOffset 
+ SPARCArchitecture.stackAllocationForCallee 
+ SPARCBreakpoint.registerSaveArea;
savedRegsStackOffset: INT ~ 
SPARCArchitecture.stackPointerOffset 
+ SPARCArchitecture.stackAllocationForCallee;
damagesRegisters: SPARCArchitecture.RegisterClass ~ 
SPARCArchitecture.SPARCRegisterClassFromTargetRegisterClass[registerClass: damages];
registerSaveName: Rope.ROPE ~ SELECT damagesRegisters FROM
none =>	"_save_regs_none",
globals =>	"_save_regs_globals",
globalsAndIns => "_save_regs_mini",
ENDCASE =>	"_save_regs";
registerRestoreName: Rope.ROPE ~ SELECT damagesRegisters FROM
none =>	"_restore_regs_none",
globals =>	"_restore_regs_globals",
globalsAndIns => "_restore_regs_mini",
ENDCASE =>	"_restore_regs";

closureCaller: SPARCBreakpoint.ClosureCaller;

errorCode: Breakpoint.ErrorCode _ Breakpoint.nullErrorCode;
errorMessage: Breakpoint.ErrorMessage _ Breakpoint.nullErrorMessage;
{
{ENABLE {
SPARCArchitecture.CantRelocate => {
errorCode _ $CantSet;
errorMessage _ "Cannot relocate instruction (SPARCBreakpointImpl).";
GO TO Cannot;
};
SPARCArchitecture.CantReach => {
errorCode _ $CantSet;
errorMessage _ "pc-relative branch is out of range (SPARCBreakpointImpl).";
GO TO Cannot;
};
SPARCArchitecture.NullSPARCAddress => {
errorCode _ $CantSet;
errorMessage _ "A null address was supplied to breakpoint code generation (SPARCBreakpointImpl).";
GO TO Cannot;
};
SPARCArchitecture.NullSPARCInstruction => {
errorCode _ $CantSet;
errorMessage _ "A null instruction was encountered in breakpoint code generation (SPARCBreakpointImpl).";
GO TO Cannot;
};
};
{
closureCaller.save _ SPARCArchitecture.SaveConst[
source: SPARCArchitecture.stackPointer,
constant: -frameSize,
dest: SPARCArchitecture.stackPointer];
BreakWorldArchitecture.PokeInstruction[
pc: patchAddress, 
displacement: SaveOffset[], 
instruction: SPARCArchitecture.TargetInstructionFromSPARCInstruction[
instruction: closureCaller.save]];
};
{
callSaveRegsAddress: SPARCArchitecture.SPARCAddress ~ 
SPARCArchitecture.SPARCAddressFromDisplacement[
address: patchSPARCAddress, displacement: CallSaveRegsOffset[]];
saveRegsAddress: SPARCArchitecture.SPARCAddress ~ 
SPARCBreakWorldUtilities.SPARCAddressFromBreakWorldAddress[
address: BreakWorldArchitecture.GetProcAddress[
breakWorld: BreakWorldArchitecture.BreakWorldFromBreakWorldAddress[
address: address], 
procName: registerSaveName]];

IF saveRegsAddress.IsNullSPARCAddress[] THEN {
ERROR Breakpoint.CantSet[
code: $CantFindRegisterSaveProcedure, 
message: "Can't find the register save procedure"];
};
closureCaller.callSaveRegs _ SPARCArchitecture.Call[
pc: callSaveRegsAddress, to: saveRegsAddress];
BreakWorldArchitecture.PokeInstruction[
pc: patchAddress, 
displacement: CallSaveRegsOffset[], 
instruction: SPARCArchitecture.TargetInstructionFromSPARCInstruction[
instruction: closureCaller.callSaveRegs]];
};
{
closureCaller.argSaveAreaOnce _ SPARCArchitecture.AddConst[
source: SPARCArchitecture.stackPointer,
constant: savedRegsStackOffset,
dest: SPARCArchitecture.Register.out0];
BreakWorldArchitecture.PokeInstruction[
pc: patchAddress, 
displacement: ArgSaveAreaOnceOffset[], 
instruction: SPARCArchitecture.TargetInstructionFromSPARCInstruction[
instruction: closureCaller.argSaveAreaOnce]];
};
{
closureCaller.argHiClientData _ SPARCArchitecture.Sethi[
hi: SPARCArchitecture.Hi[value: breakData],
dest: SPARCArchitecture.Register.out0];
BreakWorldArchitecture.PokeInstruction[
pc: patchAddress, 
displacement: ArgHiClientDataOffset[], 
instruction: SPARCArchitecture.TargetInstructionFromSPARCInstruction[
instruction: closureCaller.argHiClientData]];
};
{
callClientProcAddress: SPARCArchitecture.SPARCAddress ~ 
SPARCArchitecture.SPARCAddressFromDisplacement[
address: patchSPARCAddress, displacement: CallClientProcOffset[]];
clientProcAddress: SPARCArchitecture.SPARCAddress ~ 
SPARCBreakWorldUtilities.SPARCAddressFromBreakWorldAddress[
address: breakProc];

closureCaller.callClientProc _ SPARCArchitecture.Call[
pc: callClientProcAddress, to: clientProcAddress];
BreakWorldArchitecture.PokeInstruction[
pc: patchAddress, 
displacement: CallClientProcOffset[], 
instruction: SPARCArchitecture.TargetInstructionFromSPARCInstruction[
instruction: closureCaller.callClientProc]];
};
{
closureCaller.argLoClientData _ SPARCArchitecture.OrConst[
source: SPARCArchitecture.Register.out0,
constant: SPARCArchitecture.Lo[value: breakData],
dest: SPARCArchitecture.Register.out0];
BreakWorldArchitecture.PokeInstruction[
pc: patchAddress, 
displacement: ArgLoClientDataOffset[], 
instruction: SPARCArchitecture.TargetInstructionFromSPARCInstruction[
instruction: closureCaller.argLoClientData]];
};
{
callRestoreRegsAddress: SPARCArchitecture.SPARCAddress ~ 
SPARCArchitecture.SPARCAddressFromDisplacement[
address: patchSPARCAddress, displacement: CallRestoreRegsOffset[]];
restoreRegsAddress: SPARCArchitecture.SPARCAddress ~ 
SPARCBreakWorldUtilities.SPARCAddressFromBreakWorldAddress[
address: BreakWorldArchitecture.GetProcAddress[
breakWorld: BreakWorldArchitecture.BreakWorldFromBreakWorldAddress[
address: address],
procName: registerRestoreName]];

IF restoreRegsAddress.IsNullSPARCAddress[] THEN {
ERROR Breakpoint.CantSet[
code: $CantFindRegisterRestoreProcedure, 
message: "Can't find the register restore procedure"];
};
closureCaller.callRestoreRegs _ SPARCArchitecture.Call[
pc: callRestoreRegsAddress, to: restoreRegsAddress];
BreakWorldArchitecture.PokeInstruction[
pc: patchAddress, 
displacement: CallRestoreRegsOffset[], 
instruction: SPARCArchitecture.TargetInstructionFromSPARCInstruction[
instruction: closureCaller.callRestoreRegs]];
};
{
closureCaller.argSaveAreaAgain _ SPARCArchitecture.AddConst[
source: SPARCArchitecture.stackPointer,
constant: savedRegsStackOffset,
dest: SPARCArchitecture.Register.out0];
BreakWorldArchitecture.PokeInstruction[
pc: patchAddress, 
displacement: ArgSaveAreaAgainOffset[], 
instruction: SPARCArchitecture.TargetInstructionFromSPARCInstruction[
instruction: closureCaller.argSaveAreaAgain]];
};
{
closureCaller.restore _ SPARCArchitecture.RestoreConst[
source: SPARCArchitecture.stackPointer,
constant: +frameSize,
dest: SPARCArchitecture.stackPointer];
BreakWorldArchitecture.PokeInstruction[
pc: patchAddress, 
displacement: RestoreOffset[], 
instruction: SPARCArchitecture.TargetInstructionFromSPARCInstruction[
instruction: closureCaller.restore]];
};
};
EXITS
Cannot => {
ERROR Breakpoint.CantSet[code: errorCode, message: errorMessage];
};
};
};
};

InstallManger: PROCEDURE [
address: BreakWorldArchitecture.Address, patch: Shepherd.Patch]
RETURNS [] ~ {
IF address.IsNullAddress[] THEN {
ERROR Breakpoint.CantSet[code: $NullAddress, message: "InstallManger[nullAddress]"];
};
IF patch.IsNullPatch[] THEN {
ERROR Breakpoint.CantSet[code: $NullPatch, message: "InstallManger[nullPatch]"];
};
{
patchCodeAddress: BreakWorldArchitecture.Address ~ Shepherd.CodeAddressFromPatch[
patch: patch];
mangerAddress: BreakWorldArchitecture.Address ~ BreakWorldArchitecture.AddressFromDisplacement[
address: patchCodeAddress, displacement: MangerOffset[]];
errorCode: SPARCManger.ErrorCode _ SPARCManger.nullErrorCode;
errorMessage: SPARCManger.ErrorMessage _ SPARCManger.nullErrorMessage;

{	--Extra scope to contain EXITS.
SPARCManger.Install[
address: address, manger: mangerAddress, patchCode: patchCodeAddress
! SPARCManger.CantInstall => {
errorCode _ code;
errorMessage _ message;
GO TO Cannot;
}];
EXITS
Cannot => {
ERROR Breakpoint.CantSet[code: errorCode, message: errorMessage];
};
};
};
};

ClearBreakpoint:  BreakpointPrivate.ClearBreakProcType ~ {
errorCode: Breakpoint.ErrorCode _ Breakpoint.nullErrorCode;
errorMessage: Breakpoint.ErrorMessage _ Breakpoint.nullErrorMessage;
IF Breakpoint.IsNullBreak[break: break] THEN {
ERROR Breakpoint.CantClear[code: $NullBreak, message: "Cannot clear null break"];
};
{	-- extra scope for EXITS
address: BreakWorldArchitecture.Address ~ Breakpoint.AddressFromBreak[break: break];
patch: Shepherd.Patch _ Breakpoint.PatchFromBreak[break: break];

Uninstall[patch: patch, address: address];
Shepherd.ReleasePatch[patch: patch
! Shepherd.NoMeadow => {
errorCode _ $NoMeadow;
errorMessage _ message;
GO TO Cannot;
};
  Shepherd.BusyMeadow => {
errorCode _ $BusyMeadow;
errorMessage _ message;
GO TO Cannot;
};];
Breakpoint.ForgetBreak[break: break
! Breakpoint.Cant => {
errorCode _ $CantForget;
errorMessage _ message;
GO TO Cannot;
}];
EXITS
Cannot => {
ERROR Breakpoint.CantClear[code: errorCode, message: errorMessage];
};
};
};

Uninstall: PROCEDURE [patch: Shepherd.Patch, address: BreakWorldArchitecture.Address] ~ {
IF patch.IsNullPatch[] THEN {
ERROR Breakpoint.CantSet[code: $NullPatch, message: "Uninstall[nullPatch]"];
};
IF address.IsNullAddress[] THEN {
ERROR Breakpoint.CantSet[code: $NullAddress, message: "Uninstall[nullAddress]"];
};
{
patchCodeAddress: BreakWorldArchitecture.Address ~ Shepherd.CodeAddressFromPatch[
patch: patch];
mangerAddress: BreakWorldArchitecture.Address ~ BreakWorldArchitecture.AddressFromDisplacement[
address: patchCodeAddress, displacement: MangerOffset[]];
errorCode: SPARCManger.ErrorCode _ SPARCManger.nullErrorCode;
errorMessage: SPARCManger.ErrorMessage _ SPARCManger.nullErrorMessage;

{	-- Extra scope for EXITS
SPARCManger.Uninstall[
address: address, manger: mangerAddress, patchCode: patchCodeAddress
! SPARCManger.CantUninstall => {
errorCode _ code;
errorMessage _ message;
GO TO Cannot;
}];
EXITS
Cannot => {
ERROR Breakpoint.CantClear[code: errorCode, message: errorMessage];
};
};
};
};

SaveOffset: PROCEDURE [] 
RETURNS [TargetArchitecture.Displacement] ~ TRUSTED {
patchStruct: SPARCBreakpoint.PatchStruct;
patchStructAddress: LONG POINTER TO SPARCBreakpoint.PatchStruct ~ 
@patchStruct;
patchStructCard: CARD32 ~ LOOPHOLE[patchStructAddress];
saveAddress: LONG POINTER TO SPARCArchitecture.SPARCInstruction ~ 
@patchStruct.closureCaller.save;
saveCard: CARD32 ~ LOOPHOLE[saveAddress];
offset: TargetArchitecture.Displacement ~
(saveCard - patchStructCard) * BYTES[UNIT];

RETURN [offset];
};
CallSaveRegsOffset: PROCEDURE [] 
RETURNS [TargetArchitecture.Displacement] ~ TRUSTED {
patchStruct: SPARCBreakpoint.PatchStruct;
patchStructAddress: LONG POINTER TO SPARCBreakpoint.PatchStruct ~ 
@patchStruct;
patchStructCard: CARD32 ~ LOOPHOLE[patchStructAddress];
callSaveRegsAddress: LONG POINTER TO SPARCArchitecture.SPARCInstruction ~ 
@patchStruct.closureCaller.callSaveRegs;
callSaveRegsCard: CARD32 ~ LOOPHOLE[callSaveRegsAddress];
offset: TargetArchitecture.Displacement ~
(callSaveRegsCard - patchStructCard) * BYTES[UNIT];

RETURN [offset];
};
ArgSaveAreaOnceOffset: PROCEDURE [] 
RETURNS [TargetArchitecture.Displacement] ~ TRUSTED {
patchStruct: SPARCBreakpoint.PatchStruct;
patchStructAddress: LONG POINTER TO SPARCBreakpoint.PatchStruct ~ 
@patchStruct;
patchStructCard: CARD32 ~ LOOPHOLE[patchStructAddress];
argSaveAreaOnceAddress: LONG POINTER TO SPARCArchitecture.SPARCInstruction ~ 
@patchStruct.closureCaller.argSaveAreaOnce;
argSaveAreaOnceCard: CARD32 ~ LOOPHOLE[argSaveAreaOnceAddress];
offset: TargetArchitecture.Displacement ~
(argSaveAreaOnceCard - patchStructCard) * BYTES[UNIT];

RETURN [offset];
};
ArgHiClientDataOffset: PROCEDURE [] 
RETURNS [TargetArchitecture.Displacement] ~ TRUSTED {
patchStruct: SPARCBreakpoint.PatchStruct;
patchStructAddress: LONG POINTER TO SPARCBreakpoint.PatchStruct ~ 
@patchStruct;
patchStructCard: CARD32 ~ LOOPHOLE[patchStructAddress];
argHiClientDataAddress: LONG POINTER TO SPARCArchitecture.SPARCInstruction ~ 
@patchStruct.closureCaller.argHiClientData;
argHiClientDataCard: CARD32 ~ LOOPHOLE[argHiClientDataAddress];
offset: TargetArchitecture.Displacement ~
(argHiClientDataCard - patchStructCard) * BYTES[UNIT];

RETURN [offset];
};
CallClientProcOffset: PROCEDURE [] 
RETURNS [TargetArchitecture.Displacement] ~ TRUSTED {
patchStruct: SPARCBreakpoint.PatchStruct;
patchStructAddress: LONG POINTER TO SPARCBreakpoint.PatchStruct ~ @patchStruct;
patchStructCard: CARD32 ~ LOOPHOLE[patchStructAddress];
callClientProcAddress: LONG POINTER TO SPARCArchitecture.SPARCInstruction ~ 
@patchStruct.closureCaller.callClientProc;
callClientProcCard: CARD32 ~ LOOPHOLE[callClientProcAddress];
offset: TargetArchitecture.Displacement ~
(callClientProcCard - patchStructCard) * BYTES[UNIT];

RETURN [offset];
};
ArgLoClientDataOffset: PROCEDURE [] 
RETURNS [TargetArchitecture.Displacement] ~ TRUSTED {
patchStruct: SPARCBreakpoint.PatchStruct;
patchStructAddress: LONG POINTER TO SPARCBreakpoint.PatchStruct ~ 
@patchStruct;
patchStructCard: CARD32 ~ LOOPHOLE[patchStructAddress];
argLoClientDataAddress: LONG POINTER TO SPARCArchitecture.SPARCInstruction ~ 
@patchStruct.closureCaller.argLoClientData;
argLoClientDataCard: CARD32 ~ LOOPHOLE[argLoClientDataAddress];
offset: TargetArchitecture.Displacement ~
(argLoClientDataCard - patchStructCard) * BYTES[UNIT];

RETURN [offset];
};
CallRestoreRegsOffset: PROCEDURE [] 
RETURNS [TargetArchitecture.Displacement] ~ TRUSTED {
patchStruct: SPARCBreakpoint.PatchStruct;
patchStructAddress: LONG POINTER TO SPARCBreakpoint.PatchStruct ~ 
@patchStruct;
patchStructCard: CARD32 ~ LOOPHOLE[patchStructAddress];
callRestoreRegsAddress: LONG POINTER TO SPARCArchitecture.SPARCInstruction ~ 
@patchStruct.closureCaller.callRestoreRegs;
callRestoreRegsCard: CARD32 ~ LOOPHOLE[callRestoreRegsAddress];
offset: TargetArchitecture.Displacement ~
(callRestoreRegsCard - patchStructCard) * BYTES[UNIT];

RETURN [offset];
};
ArgSaveAreaAgainOffset: PROCEDURE [] 
RETURNS [TargetArchitecture.Displacement] ~ TRUSTED {
patchStruct: SPARCBreakpoint.PatchStruct;
patchStructAddress: LONG POINTER TO SPARCBreakpoint.PatchStruct ~ 
@patchStruct;
patchStructCard: CARD32 ~ LOOPHOLE[patchStructAddress];
argSaveAreaAgainAddress: LONG POINTER TO SPARCArchitecture.SPARCInstruction ~ 
@patchStruct.closureCaller.argSaveAreaAgain;
argSaveAreaAgainCard: CARD32 ~ LOOPHOLE[argSaveAreaAgainAddress];
offset: TargetArchitecture.Displacement ~
(argSaveAreaAgainCard - patchStructCard) * BYTES[UNIT];

RETURN [offset];
};
RestoreOffset: PROCEDURE [] 
RETURNS [TargetArchitecture.Displacement] ~ TRUSTED {
patchStruct: SPARCBreakpoint.PatchStruct;
patchStructAddress: LONG POINTER TO SPARCBreakpoint.PatchStruct ~ 
@patchStruct;
patchStructCard: CARD32 ~ LOOPHOLE[patchStructAddress];
restoreAddress: LONG POINTER TO SPARCArchitecture.SPARCInstruction ~ 
@patchStruct.closureCaller.restore;
restoreCard: CARD32 ~ LOOPHOLE[restoreAddress];
offset: TargetArchitecture.Displacement ~
(restoreCard - patchStructCard) * BYTES[UNIT];

RETURN [offset];
};

MangerOffset: PROCEDURE [] 
RETURNS [TargetArchitecture.Displacement] ~ TRUSTED {
patchStruct: SPARCBreakpoint.PatchStruct;
patchStructAddress: LONG POINTER TO SPARCBreakpoint.PatchStruct ~ 
@patchStruct;
patchStructCard: CARD32 ~ LOOPHOLE[patchStructAddress];
mangerAddress: LONG POINTER TO SPARCManger.Manger ~ 
@patchStruct.manger;
mangerCard: CARD32 ~ LOOPHOLE[mangerAddress];
offset: TargetArchitecture.Displacement ~
(mangerCard - patchStructCard) * BYTES[UNIT];

RETURN [offset];
};

BreakpointPrivate.RegisterTargetBreaks[NEW[BreakpointPrivate.TargetBreaksBody _ [
"SPARC",
SetBreakpoint,
ClearBreakpoint]]];
}.

Ύ
SPARCBreakpointImpl.mesa
Copyright Σ 1989, 1990, 1991, 1992 by Xerox Corporation.  All rights reserved.
Peter B. Kessler, July 11, 1990 11:06 am PDT
Laurie Horton, February 26, 1993 12:12 pm PST
Katsuyuki Komatsu March 4, 1992 5:55 pm PST
SPARC target-dependent implementation of the functions from Breakpoint.


"Public" Procedures registered with Breakpoint.
PROCEDURE [
address: BreakWorldArchitecture.Address, 
dataSegment: BreakWorldArchitecture.Address,
clientData: Breakpoint.ClientData,
breakProc: Breakpoint.BreakProc,
breakData: Breakpoint.BreakData,
damages: TargetArchitecture.RegisterClass _ TargetArchitecture.RegisterClass.all] 
RETURNS [Breakpoint.Break]
-- Can't deallocate patches.
Well, I could just clear the size and address, but is that safe?
IF NOT patch.IsNullPatch[] THEN {
Shepherd.ReleasePatch[patch: patch];
};
Generate the code in the patch.
PROCEDURE [break: Break] RETURNS [];
PatchStruct offset procedures.
Main code

Κ@•NewlineDelimiter

–

"cedar" style™
unit™Icodešœ
Οr
œC™NLš
œ,™,L™-L™+—L˜™GL™—™š
Οk	˜	Lš
œ˜Lš
œ˜Lš
œ˜Lšœžœžœ˜Lš
œ	˜	Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜L˜——šΠlnœžœ
žœ
˜#šžœ
˜L–0 bp restIndentš
œ
˜
—L˜Lš
œ˜
head™/šΟn
œ(˜5Lšž	œ’žœ™΅Jš
œ/˜/Jš
œ+˜+L˜;Lš
œD˜Dš œž	œ,žœ˜U˜1Lš
œQ˜Q—˜5š
œ?˜?Lšœ!žœ&˜L——˜5š
œ?˜?Lšœ!žœ&˜L——šžœJžœ˜Ršžœ˜Lš
œG˜G—L˜—Lšžœ
˜L˜—L˜šžœžœ˜!šžœ˜Lš
œK˜K—L˜—šžœžœ˜#šžœ˜Lš
œ˜Lš
œJ˜J—L˜—˜
˜5L˜/—L˜šžœ(žœ˜0šžœ˜Lš
œ˜Lš
œK˜K—L˜—L˜—L˜$šœΟc˜!š
œ˜Jšœžœ˜9š
œ˜Jš
œ˜Jš
œ˜Jšžœ
žœ˜
Jš
œ˜—š
œ˜J˜Jš
œ˜Jšžœ
žœ˜
Jš
œ˜—š
œ˜Jš
œ˜Jš
œ˜Jšžœ
žœ˜
Jš
œ˜—š
œ˜Jš
œ˜Jš
œ˜Jšžœ
žœ˜
Jš
œ˜—š
œ˜Jš
œ˜Jš
œ˜Jšžœ
žœ˜
Jš
œ˜—Jš
œ˜—š
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜Jš
œ˜—Jš
œT˜T˜˜J˜J˜Jšžœ
žœ˜
J˜——š
ž˜˜™J™@—šžœ
žœžœ™!Jš
œ$™$J™—Lšžœ<˜AL˜——L˜—Lšžœ	˜Lš
œ˜L˜—š œž	œ³
žœ˜Σ
šžœžœ˜!LšžœI˜NL˜—šžœžœ˜LšžœE˜JL˜—šžœžœ˜#LšžœK˜PL˜—š
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜—Lš
œ.˜.L˜L˜—š œž	œ³
žœ˜ΰ
šžœžœ˜!šžœ˜Lš
œB˜B—L˜—šžœžœ˜#šžœ˜Lš
œD˜D—L˜—šžœžœ˜šžœ˜Lš
œ>˜>—L˜—˜
˜4Jš
œM˜M—Lš
œ[˜[˜4Jš
œR˜R—šœžœ˜Lš
œ%˜%Lš
œ-˜-Lš
œ#˜#—šœžœ˜Lš
œ%˜%Lš
œ-˜-—š
œ4˜4Lš
œT˜T—šœžœžœž˜:L•	CharPropsS	

PostfixXeroxCharCodes

PostfixXeroxCharCodes

PostfixXeroxCharCodesš
œ˜L–S

PostfixXeroxCharCodes

PostfixXeroxCharCodes

PostfixXeroxCharCodes	š
œ ˜ L–S

PostfixXeroxCharCodes

PostfixXeroxCharCodes

PostfixXeroxCharCodesš
œ#˜#L–8

PostfixXeroxCharCodes

PostfixXeroxCharCodesšžœ˜—šœžœžœž˜=L–S	

PostfixXeroxCharCodes

PostfixXeroxCharCodes

PostfixXeroxCharCodesš
œ˜L–S

PostfixXeroxCharCodes

PostfixXeroxCharCodes

PostfixXeroxCharCodes	š
œ#˜#L–S

PostfixXeroxCharCodes

PostfixXeroxCharCodes

PostfixXeroxCharCodesš
œ&˜&L–8

PostfixXeroxCharCodes

PostfixXeroxCharCodesšžœ˜—L˜L™Lš
œ-˜-L˜L˜;L˜D˜
šœ
ž˜	˜#L˜L˜DLšžœ
žœ˜
L˜—˜ L˜L˜KLšžœ
žœ˜
L˜—˜'L˜L˜bLšžœ
žœ˜
L˜—˜+L˜L˜iLšžœ
žœ˜
L˜—L˜——˜
š
œ1˜1Lš
œ'˜'Lš
œ˜Lš
œ&˜&—š
œ'˜'Lš
œ˜Lš
œ˜š
œE˜ELš
œ"˜"——L˜—˜
š
œ6˜6š
œ/˜/Lš
œ@˜@——š
œ2˜2š
œ;˜;š
œ/˜/š
œC˜CLš
œ˜—Lš
œ˜———L˜šžœ&žœ˜.šžœ˜Lš
œ&˜&Lš
œ3˜3—L˜—š
œ4˜4Lš
œ.˜.—š
œ'˜'Lš
œ˜Lš
œ$˜$š
œE˜ELš
œ*˜*——L˜—˜
š
œ;˜;Lš
œ'˜'Lš
œ˜Lš
œ'˜'—š
œ'˜'Lš
œ˜Lš
œ'˜'š
œE˜ELš
œ-˜-——L˜—˜
š
œ8˜8Lš
œ+˜+Lš
œ'˜'—š
œ'˜'Lš
œ˜Lš
œ'˜'š
œE˜ELš
œ-˜-——Lš
œ˜—˜
š
œ8˜8š
œ/˜/Lš
œB˜B——š
œ4˜4š
œ;˜;Jš
œ˜——L˜š
œ6˜6Lš
œ2˜2—š
œ'˜'Lš
œ˜Lš
œ&˜&š
œE˜ELš
œ,˜,——L˜—˜
š
œ:˜:Lš
œ(˜(Lš
œ1˜1Lš
œ'˜'—š
œ'˜'Lš
œ˜Lš
œ'˜'š
œE˜ELš
œ-˜-——L˜—˜
š
œ9˜9š
œ/˜/Lš
œC˜C——š
œ5˜5š
œ;˜;š
œ/˜/š
œC˜CLš
œ˜—Lš
œ ˜ ———L˜šžœ)žœ˜1šžœ˜Lš
œ)˜)Lš
œ6˜6—L˜—š
œ7˜7Lš
œ4˜4—š
œ'˜'Lš
œ˜Lš
œ'˜'š
œE˜ELš
œ-˜-——L˜—˜
š
œ<˜<Lš
œ'˜'Lš
œ˜Lš
œ'˜'—š
œ'˜'Lš
œ˜Lš
œ(˜(š
œE˜ELš
œ.˜.——L˜—˜
š
œ7˜7Lš
œ'˜'Lš
œ˜Lš
œ&˜&—š
œ'˜'Lš
œ˜Lš
œ˜š
œE˜ELš
œ%˜%——L˜—L˜—š
ž˜˜Lšžœ<˜AL˜—L˜—L˜—˜L˜—š 
œž	œCžœ˜išžœžœ˜!LšžœO˜TL˜—šžœžœ˜LšžœK˜PL˜—˜
š
œQ˜QLš
œ˜—š
œ_˜_Lš
œ9˜9—Lš
œ=˜=Lš
œF˜FL˜šœ‘˜!š
œ˜Lš
œD˜Dš
œ˜L˜L˜Lšžœ
žœ˜
Lš
œ˜——š
ž˜˜Lšžœ<˜AL˜——L˜—L˜—L˜L˜—š œ+˜:Jšž	œžœ™$Jš
œ;˜;Jš
œD˜Dšžœ&žœ˜.JšžœL˜QJ˜—šœ‘˜Jš
œT˜TJš
œ@˜@J˜Lš
œ*˜*š
œ"˜"˜L˜L˜Lšžœ
žœ˜
L˜—˜J˜L˜Lšžœ
žœ˜
L˜——š
œ#˜#š
œ˜L˜L˜Lšžœ
žœ˜
L˜——š
ž˜˜Lšžœ>˜CL˜——Jš
œ˜—Lš
œ˜L˜—š 	œž	œE˜Yšžœžœ˜LšžœG˜LL˜—šžœžœ˜!LšžœK˜PL˜—˜
š
œQ˜QLš
œ˜—š
œ_˜_Lš
œ9˜9—L˜=L˜FL˜šœ‘˜š
œ˜Lš
œD˜D˜ L˜L˜Lšžœ
žœ˜
L˜——š
ž˜š
œ˜Lšžœ>˜CLš
œ˜——L˜—L˜—L˜L˜——™š 
œž	œžœ%žœ˜OLš
œ)˜)šœžœ
žœ
žœ˜BLš
œ
˜
—Lšœžœžœ˜7šœ
žœ
žœ
žœ&˜BLš
œ ˜ —Lšœ
žœžœ˜)š
œ)˜)Lšœžœ
žœ˜+—L˜Lšžœ
˜Lš
œ˜—š œž	œžœ%žœ˜WLš
œ)˜)šœžœ
žœ
žœ˜BLš
œ
˜
—Lšœžœžœ˜7šœžœ
žœ
žœ&˜JLš
œ(˜(—Lšœžœžœ˜9š
œ)˜)Lšœ'žœ
žœ˜3—L˜Lšžœ
˜Lš
œ˜—š œž	œžœ%žœ˜ZLš
œ)˜)šœžœ
žœ
žœ˜BLš
œ
˜
—Lšœžœžœ˜7šœžœ
žœ
žœ&˜MLš
œ+˜+—Lšœžœžœ˜?š
œ)˜)Lšœ*žœ
žœ˜6—L˜Lšžœ
˜Lš
œ˜—š œž	œžœ%žœ˜ZLš
œ)˜)šœžœ
žœ
žœ˜BLš
œ
˜
—Lšœžœžœ˜7šœžœ
žœ
žœ&˜MLš
œ+˜+—Lšœžœžœ˜?š
œ)˜)Lšœ*žœ
žœ˜6—L˜Lšžœ
˜Lš
œ˜—š œž	œžœ%žœ˜YLš
œ)˜)Lšœžœ
žœ
žœ,˜OLšœžœžœ˜7šœžœ
žœ
žœ&˜LLš
œ*˜*—Lšœžœžœ˜=š
œ)˜)Lšœ)žœ
žœ˜5—L˜Lšžœ
˜Lš
œ˜—š œž	œžœ%žœ˜ZLš
œ)˜)šœžœ
žœ
žœ˜BLš
œ
˜
—Lšœžœžœ˜7šœžœ
žœ
žœ&˜MLš
œ+˜+—Lšœžœžœ˜?š
œ)˜)Lšœ*žœ
žœ˜6—L˜Lšžœ
˜Lš
œ˜—š œž	œžœ%žœ˜ZLš
œ)˜)šœžœ
žœ
žœ˜BLš
œ
˜
—Lšœžœžœ˜7šœžœ
žœ
žœ&˜MLš
œ+˜+—Lšœžœžœ˜?š
œ)˜)Lšœ*žœ
žœ˜6—L˜Lšžœ
˜Lš
œ˜—š œž	œžœ%žœ˜[Lš
œ)˜)šœžœ
žœ
žœ˜BLš
œ
˜
—Lšœžœžœ˜7šœžœ
žœ
žœ&˜NLš
œ,˜,—Lšœžœžœ˜Aš
œ)˜)Lšœ+žœ
žœ˜7—L˜Lšžœ
˜Lš
œ˜—š 
œž	œžœ%žœ˜RLš
œ)˜)šœžœ
žœ
žœ˜BLš
œ
˜
—Lšœžœžœ˜7šœžœ
žœ
žœ&˜ELš
œ#˜#—Lšœ
žœžœ˜/š
œ)˜)Lšœ"žœ
žœ˜.—L˜Lšžœ
˜Lš
œ˜L˜—š œž	œžœ%žœ˜QLš
œ)˜)šœžœ
žœ
žœ˜BLš
œ
˜
—Lšœžœžœ˜7šœžœ
žœ
žœ˜4Lš
œ˜—Lšœžœžœ˜-š
œ)˜)Lšœ!žœ
žœ˜-—L˜Lšžœ
˜Lš
œ˜L˜—L™	™šœ'žœ'˜QLš
œ˜Lš
œ˜Lš
œ˜———K˜—J˜—…—Ng