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: Breakpoint.SetBreakProc ~ {
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;

{
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]];
};
};
};

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:  Breakpoint.ClearBreakProc ~ {
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 by Xerox Corporation.  All rights reserved.
Peter B. Kessler, July 11, 1990 11:06 am PDT
Laurie Horton, October 16, 1991 2:59 am PDT

SPARC target-dependent implementation of the functions from Breakpoint.


"Public" Procedures registered with Breakpoint.
PROCEDURE [
address: 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

–
(cedarcode) style™
unit™Icodešœ
Πer
œ=™HLš
œ,™,Lš
œ+™+L™L™GL™L™š
Οk	˜	Lš
œ˜Lš
œ˜Lš
œ˜Lšœžœžœ˜Lš
œ	˜	Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜L˜——šΠlnœžœ
žœ
˜#šžœ
˜L–0 bp restIndentš
œ
˜
—L˜Lš
œ˜
head™/šΟn
œ˜*Lšž	œε
žœ™ˆLš
œ/˜/Lš
œ+˜+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˜!š
œ˜Lšœžœ˜9š
œ˜Lš
œ˜Lš
œ˜Lšžœ
žœ˜
Lš
œ˜—š
œ˜L˜Lš
œ˜Lšžœ
žœ˜
Lš
œ˜—š
œ˜Lš
œ˜Lš
œ˜Lšžœ
žœ˜
Lš
œ˜—š
œ˜Lš
œ˜Lš
œ˜Lšžœ
žœ˜
Lš
œ˜—š
œ˜Lš
œ˜Lš
œ˜Lšžœ
žœ˜
Lš
œ˜—Lš
œ˜—š
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜Lš
œ˜—Lš
œT˜T˜˜L˜L˜Lšžœ
žœ˜
L˜——š
ž˜˜™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˜—˜
˜4Lš
œM˜M—Lš
œ[˜[˜4Lš
œ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˜˜
š
œ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š
œ;˜;Lš
œ˜——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˜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šž	œžœ™$Lš
œ;˜;Lš
œD˜Dšžœ&žœ˜.LšžœL˜QL˜—šœ‘˜Lš
œT˜TLš
œ@˜@L˜Lš
œ*˜*š
œ"˜"˜L˜L˜Lšžœ
žœ˜
L˜—˜L˜L˜Lšžœ
žœ˜
L˜——š
œ#˜#š
œ˜L˜L˜Lšžœ
žœ˜
L˜——š
ž˜˜Lšžœ>˜CL˜——Lš
œ˜—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˜—L˜—…—J~b‚