
DIRECTORY Basics, CirioNubAccess, Rope;

CirioMemory: CEDAR DEFINITIONS
= BEGIN

ROPE: TYPE ~ Rope.ROPE;

BitAddr: TYPE ~ RECORD [aus: CARD, bits: INT];

zeroBA: BitAddr ~ [0, 0];
unspecdBA: BitAddr ~ [CARD.LAST, INT.LAST];
bitsPerAu: NAT ~ 8;
bitsPerPtr: NAT ~ 32;

BaCons: PROC [aus: CARD, bits: INT] RETURNS [BitAddr]
~ INLINE {IF bits/bitsPerAu >= 0 OR aus > ABS[bits/bitsPerAu] THEN 
RETURN[[aus+bits/bitsPerAu, bits MOD bitsPerAu]] ELSE
RETURN[[0, aus*bitsPerAu+bits]]};

BaAsAbs: PROC [ba: BitAddr] RETURNS [BitAddr];

BaAdd: PROC [a, b: BitAddr] RETURNS [BitAddr]
~ INLINE {RETURN BaCons[a.aus+b.aus, a.bits+b.bits]};

BaAddOffset: PROC [ba: BitAddr, bits: INT] RETURNS [BitAddr]
~ INLINE {RETURN BaCons[ba.aus, ba.bits+bits]};

BaSub: PROC [a, b: BitAddr] RETURNS [BitAddr]
~ INLINE {RETURN BaCons[a.aus-b.aus, a.bits-b.bits]};

BaMul: PROC [ba: BitAddr, by: CARD] RETURNS [BitAddr]
~ INLINE {RETURN BaCons[ba.aus*by, ba.bits*by]};

BaCompare: PROC [a, b: BitAddr] RETURNS [Basics.Comparison];

BitsToBa: PROC [bits: INT] RETURNS [BitAddr]
~ INLINE {RETURN BaCons[0, bits]};

BaToBits: PROC [ba: BitAddr] RETURNS [CARD]
~ INLINE {RETURN[ba.aus*bitsPerAu + ba.bits]};

AusToBa: PROC [aus: CARD] RETURNS [BitAddr]
~ INLINE {RETURN[[aus, 0]]};

BaToAus: PROC [ba: BitAddr] RETURNS [CARD]
~ INLINE {IF ba.bits#0 THEN ERROR; RETURN[ba.aus]};

PtrToBa: PROC [ptr: CARD] RETURNS [BitAddr]
~ INLINE {RETURN[[LOOPHOLE[ptr], 0]]};

BaToPtr: PROC [ba: BitAddr] RETURNS [CARD]
~ INLINE {IF ba.bits#0 THEN ERROR; RETURN[LOOPHOLE[ba.aus]]};

BitStretch: TYPE ~ RECORD [start, size: BitAddr];

unspecdBS: BitStretch ~ [unspecdBA, unspecdBA];

BsCompose: PROC [main, inner: BitStretch] RETURNS [within: BOOL, compd: BitStretch];

Mem: TYPE = RECORD[class: MemClass, data: REF ANY];
noMem: Mem = [NIL, NIL];

MemClass: TYPE ~ REF MemClassPrivate;
MemClassPrivate: TYPE ~ RECORD [
CreateSimple: PROC [data: REF ANY, stretch: BitStretch, keepFrame: BOOL] RETURNS [Mem],
Subfield: PROC [data: REF ANY, rel: BitStretch] RETURNS [Mem],
Shift: PROC [data: REF ANY, offset: BitAddr] RETURNS [Mem],
GetStretch: PROC [data: REF ANY] RETURNS [BitStretch],
Read: PROC [data: REF ANY, bitSize: CARD, offset: BitAddr] RETURNS [CARD],
Write: PROC [data: REF ANY, bits: CARD, bitSize: CARD, offset: BitAddr],
ReadPtrReg: PROC [data: REF ANY, ptrReg: PtrReg] RETURNS [BitStretch],
ReadSegmentReg: PROC [data: REF ANY, segName: ROPE, segNum: INT] RETURNS [BitStretch],
SetPtrReg: PROC [data: REF ANY, ptrReg: PtrReg, val: BitStretch]
];

PtrReg: TYPE ~ {
fp	--frame pointer--,
sp	--stack pointer--,
fe	--frame extension pointer--
};

Error: ERROR [msg: ROPE];

MemSubfield: PROC [mem: Mem, rel: BitStretch] RETURNS [Mem]
~ INLINE {RETURN mem.class.Subfield[mem.data, rel]};

MemShift: PROC [mem: Mem, offset: BitAddr] RETURNS [Mem]
~ INLINE {RETURN mem.class.Shift[mem.data, offset]};

MemIndirect: PROC [mem: Mem, size: BitAddr _ unspecdBA, offset: BitAddr _ zeroBA] RETURNS [Mem];

MemGetStretch: PROC [mem: Mem] RETURNS [BitStretch]
~ INLINE {RETURN mem.class.GetStretch[mem.data]};

MemGetSize: PROC [mem: Mem] RETURNS [BitAddr]
~ INLINE {RETURN [mem.class.GetStretch[mem.data].size]};

MemGetStart: PROC [mem: Mem] RETURNS [BitAddr]
~ INLINE {RETURN [mem.class.GetStretch[mem.data].start]};

MemRead: PROC [mem: Mem, bitSize: CARD, offset: BitAddr] RETURNS [CARD]
~ INLINE {RETURN mem.class.Read[mem.data, bitSize, offset]};

MemWrite: PROC [mem: Mem, bits: CARD, bitSize: CARD, offset: BitAddr]
~ INLINE {mem.class.Write[mem.data, bits, bitSize, offset]};

MemPtrRegIndirect: PROC [mem: Mem, ptrReg: PtrReg, size, offset: BitAddr, keepFrame: BOOL] RETURNS [Mem];

MemReadPtrReg: PROC [mem: Mem, ptrReg: PtrReg] RETURNS [BitStretch]
~ INLINE {RETURN mem.class.ReadPtrReg[mem.data, ptrReg]};

MemReadSegReg: PROC [mem: Mem, segName: ROPE, segNum: INT] RETURNS [BitStretch]
~ INLINE {RETURN mem.class.ReadSegmentReg[mem.data, segName, segNum]};

MemSelectSegment: PROC [mem: Mem, segName: ROPE, segNum: INT, keepFrame: BOOL] RETURNS [Mem];

CreateSimpleMem: PROC[addr: CirioNubAccess.RemoteAddress, size: BitAddr _ unspecdBA] RETURNS[Mem];

MakeDualMem: PROC [nub: CirioNubAccess.Handle, fp, sp: CARD _ invalidPtr, text, data, bss, fep, simple: BitStretch _ unspecdBS] RETURNS [mem: Mem];

invalidPtr: CARD = CARD.LAST;

END.
     
CirioMemory.mesa
Copyright ╙ 1991, 1992 by Xerox Corporation.  All rights reserved.
Laurie Horton, February 24, 1992 4:36 pm PST
Last tweaked by Mike Spreitzer September 19, 1991 9:38 am PDT
Philip James, February 25, 1992 9:24 am PST
BitAddr
A BitAddr represents a position in or length of memory.

The first part is in Addressing Units (ie, increments of debuggee pointers).  ABS[bits] < bitsPerAu.
ptrSize: BitAddr ~ [4, 0];
Result is equivalent to arg, and has non-negative bits.
Some BitStretchs may have size=unspecdBA, meaning the length is unknown.
inner is interpreted relative to main; compd tells whether all of compd lies within main.
Mem
Mems are Node time information.  They define a piece of memory with perhaps some structure.  At the moment, there are two aspects of Memness: Frame and Simple.  A Simple Mem represents a contiguous sequence of bits in memory; while the start of the sequence is always definite, the length may not be known (unspecdBA represents the unknown length).  A Frame Mem represents a stack frame of a procedure at some level of abstraction.  A Mem may be both Simple and Frame (this is needed for global vars, 'cause they are layed out simply, except for procedure constants).  When reading and writing less than a whole CARD, the least significant bitSize bits are the significant ones.

Every Mem can:
Create another one, at the given absolute address, with the given size.  If keepFrame, the result has the same Frameness as the argument; if NOT keepFrame, the result is purely simple.
A Simple Mem can:
Result has same Framness as arg; this is needed so that SelectVarLoc can return a Simple+Frame Mem for Cedar global variables.
Used for pointer addition; size and Frameness don't change.
A Frame Mem can:
Both procedures raise Error when the segment or pointer is undefined.
Since Mems are nominally immutable, this should only be called as part of constructing one.
Create a Simple Mem.
Create a Mem that is Frame and maybe Simple.  Caller can decline to define some registers by passing invalidPtr or unspecdBS.
 Э╩,  ХNewlineDelimiter
Щ codeЩKЩBKЩ,KЩ=KЩ+ЧKШ KЪ╧k	ЬШ'KШ KЪ╧nЬЭЬЭШKЪЬЭШKШ KЪЭЬЭЬЭЬШKШ ЩKЩ7KЩ Ъ	Ь	ЭЬЭЬЭЬЭЬШ.KЪЬNЭЬЩdЧKШ KШKЪ	ЬЭЬЭЬЭЬЭЬШ+KЩKЪЬЭЬШKЪЬЭЬШKШ Ъ
ЮЬЭЬЭЬЭЬЭЬ
Ш5ЪЬЭЬЭЬЭЬЭЬЭЬШCKЪЭЬЭЬЭШ5KЪЭЬШ!ЧЧKШ ЪЮЬЭЬЭЬШ.KЪЬ2╧eЬЩ7ЧKШ ЪЮЬЭЬЭЬ
Ш-KЪЬЭЬЭЬ%Ш5KШ ЧЪЮЬЭЬЭЬЭЬ
Ш<KЪЬЭЬЭЬШ/ЧKШ ЪЮЬЭЬЭЬ
Ш-KЪЬЭЬЭЬ%Ш5ЧKШ ЪЮЬЭЬЭЬЭЬ
Ш5KЪЬЭЬЭЬ Ш0ЧKШ KЪЮ	ЬЭЬЭЬШ<KШ ЪЮЬЭЬЭЬЭЬ
Ш,KЪЬЭЬЭЬШ"ЧKШ ЪЮЬЭЬЭЬЭЬШ+KЪЬЭЬЭЬШ.ЧKШ ЪЮЬЭЬЭЬЭЬ
Ш+KЪЬЭЬЭЬШЧKШ ЪЮЬЭЬЭЬЭЬШ*KЪЬЭЬЭЬЭЬЭЬЭЬ
Ш3ЧKШ ЪЮЬЭЬЭЬЭЬ
Ш+KЪЬЭЬЭЬЭЬШ&ЧKШ ЪЮЬЭЬЭЬЭЬШ*KЪЬЭЬЭЬЭЬЭЬЭЬЭЬШ=ЧKШ ЪЬЭЬЭЬШ1KЪЬHЩHЧKШ KШ/KШ ЪЮ	ЬЭЬЭЬ
ЭЬШTKЪ
ЯЬЯЬЯЬЯЬЯЬЩYЧKШ ЧЩKЪЬфЯЬЯЬЩжKЩ KЪ	ЬЭЬЭЬЭЬЭЬШ3KЪЬЭЬЭЬШKШ KЪЬ
ЭЬЭЬШ%ЪЬЭЬЭЬШ ЩЪЮЬЭЬЭЬЭЬ"ЭЬЭЬШWKЪЬ╕Щ╕ЧЧЩЪ
ЮЬЭЬЭЬЭЬЭЬШ>KЩ~ЧЪ
ЮЬЭЬЭЬЭЬЭЬШ;KЩ;ЧKЪ
Ю
ЬЭЬЭЬЭЬЭЬШ6KЪЮЬЭЬЭЬЭЬЭЬЭЬЭЬШJKЪЮЬЭЬЭЬЭЬЭЬЭЬШHЧЩKЪ
Ю
ЬЭЬЭЬЭЬЭЬШFЪЮЬЭЬЭЬЭЬЭЬ
ЭЬЭЬШVKЪЬEЩEЧЪЮ	ЬЭЬЭЬЭЬ"Ш@KЩ[ЧЧKШЧKШ ЪЬЭЬШKЪЬ╧cЬШKЪЬаЬШKЪЬаШKШЧKШ KЪЮЬЭЬЭЬШKШ ЪЮЬЭЬЭЬШ;KЪЬЭЬЭЬ$Ш4ЧKШ ЪЮЬЭЬЭЬШ8KЪЬЭЬЭЬ$Ш4ЧKШ KЪЮЬЭЬAЭЬШ`KШ ЪЮЬЭЬЭЬШ3KЪЬЭЬЭЬ!Ш1ЧKШ ЪЮ
ЬЭЬЭЬ
Ш-KЪЬЭЬЭЬ(Ш8ЧKШ ЪЮЬЭЬЭЬ
Ш.KЪЬЭЬЭЬ)Ш9ЧKШ Ъ
ЮЬЭЬЭЬЭЬЭЬШGKЪЬЭЬЭЬ,Ш<ЧKШ ЪЮЬЭЬЭЬЭЬШEKЪЬЭЬ4Ш<ЧKШ KЪЮЬЭЬ>ЭЬЭЬШiKШ ЪЮЬЭЬЭЬШCKЪЬЭЬЭЬ)Ш9ЧKШ Ъ
ЮЬЭЬЭЬ
ЭЬЭЬШOKЪЬЭЬЭЬ6ШFЧKШ KЪЮЬЭЬЭЬ
ЭЬЭЬЭЬШ]KШ ЪЮЬЭЬ@ЭЬШbKЩЧЧШ ЪЮЬЭЬ&ЭЬEЭЬШУKЪЬ}Щ}ЧЧKШ KЪЬЭЬЭЬЭЬШKШ KЪЭЬШЧ ЕЧ    ╥     