DIRECTORY
TargetArchitecture,
SPARCArchitecture,
RuntimeError;

SPARCArchitectureImpl: CEDAR PROGRAM 
IMPORTS TargetArchitecture, SPARCArchitecture, RuntimeError
EXPORTS SPARCArchitecture
~ {
Noop: PUBLIC PROCEDURE [] 
RETURNS [SPARCArchitecture.SPARCInstruction] ~ {
format2Imm22: SPARCArchitecture.Format2Imm22 ~ [
op: SPARCArchitecture.Op.branch,
rd: SPARCArchitecture.Register.global0,
op2: SPARCArchitecture.Op2.sethi,
imm22MS: SPARCArchitecture.Imm22MS[0],
imm22LS: SPARCArchitecture.Imm22LS[0]
];
instruction: SPARCArchitecture.SPARCInstruction ~ LOOPHOLE[format2Imm22];

RETURN [instruction];
};

Ld: PUBLIC PROCEDURE [
base: SPARCArchitecture.Register, 
offset: SPARCArchitecture.Simm13, 
dest: SPARCArchitecture.Register]
RETURNS [SPARCArchitecture.SPARCInstruction] ~ {
format3simm13: SPARCArchitecture.Format3Simm13 ~ [
op: SPARCArchitecture.Op.other3,
rd: dest,
op3: SPARCArchitecture.Op3FromOp11Op3[op11Op3: SPARCArchitecture.Op11Op3.ld],
rs1MS: SPARCArchitecture.RegisterMSFromRegister[register: base],
rs1LS: SPARCArchitecture.RegisterLSFromRegister[register: base],
i: SPARCArchitecture.I.useSimm13,
simm13: SPARCArchitecture.Unbiased13FromSimm13[simm13: offset]];
instruction: SPARCArchitecture.SPARCInstruction ~ LOOPHOLE[format3simm13];

RETURN [instruction];
};

St: PUBLIC PROCEDURE [
source: SPARCArchitecture.Register, 
base: SPARCArchitecture.Register, 
offset: SPARCArchitecture.Simm13]
RETURNS [SPARCArchitecture.SPARCInstruction] ~ {
format3simm13: SPARCArchitecture.Format3Simm13 ~ [
op: SPARCArchitecture.Op.other3,
rd: source,
op3: SPARCArchitecture.Op3FromOp11Op3[op11Op3: SPARCArchitecture.Op11Op3.st],
rs1MS: SPARCArchitecture.RegisterMSFromRegister[register: base],
rs1LS: SPARCArchitecture.RegisterLSFromRegister[register: base],
i: SPARCArchitecture.I.useSimm13,
simm13: SPARCArchitecture.Unbiased13FromSimm13[simm13: offset]];
instruction: SPARCArchitecture.SPARCInstruction ~ LOOPHOLE[format3simm13];

RETURN [instruction];
};

Sethi: PUBLIC PROCEDURE [
hi: SPARCArchitecture.Imm22, dest: SPARCArchitecture.Register] 
RETURNS [SPARCArchitecture.SPARCInstruction] ~ {
format2Imm22: SPARCArchitecture.Format2Imm22 ~ [
op: SPARCArchitecture.Op.branch,
rd: dest,
op2: SPARCArchitecture.Op2.sethi,
imm22MS: SPARCArchitecture.Imm22MSFromImm22[hi],
imm22LS: SPARCArchitecture.Imm22LSFromImm22[hi]
];
instruction: SPARCArchitecture.SPARCInstruction ~ LOOPHOLE[format2Imm22];

RETURN [instruction];
};

BAa: PUBLIC PROCEDURE [
pc: SPARCArchitecture.SPARCAddress, to: SPARCArchitecture.SPARCAddress] 
RETURNS [SPARCArchitecture.SPARCInstruction] ~ {
displacement: TargetArchitecture.Displacement ~ 
SPARCArchitecture.DisplacementFromSPARCAddresses[here: pc, there: to];
instruction: SPARCArchitecture.SPARCInstruction ¬ 
SPARCArchitecture.nullSPARCInstruction;

IF pc.IsNullSPARCAddress[] THEN {
ERROR SPARCArchitecture.NullSPARCAddress;
};
IF to.IsNullSPARCAddress[] THEN {
ERROR SPARCArchitecture.NullSPARCAddress;
};
IF displacement NOT IN [SPARCArchitecture.firstDisp22 .. SPARCArchitecture.lastDisp22] THEN {
ERROR SPARCArchitecture.CantReach;
};
{
disp22: SPARCArchitecture.Disp22 ~ 
displacement / BYTES[SPARCArchitecture.SPARCInstruction];
format2Disp22: SPARCArchitecture.Format2Disp22 ~ [
op: SPARCArchitecture.Op.branch,
a: SPARCArchitecture.Annul.annul,
cond: SPARCArchitecture.Cond.always,
op2: SPARCArchitecture.Op2.bicc,
disp22MS: SPARCArchitecture.Unbiased22MSFromDisp22[disp22: disp22],
disp22LS: SPARCArchitecture.Unbiased22LSFromDisp22[disp22: disp22]
];

instruction ¬ LOOPHOLE[format2Disp22];
};
RETURN [instruction];
};

SaveConst: PUBLIC PROCEDURE [
source: SPARCArchitecture.Register, 
constant: SPARCArchitecture.Simm13, 
dest: SPARCArchitecture.Register]
RETURNS [SPARCArchitecture.SPARCInstruction] ~ {
format3simm13: SPARCArchitecture.Format3Simm13 ~ [
op: SPARCArchitecture.Op.other2,
rd: dest,
op3: SPARCArchitecture.Op3FromOp10Op3[op10Op3: SPARCArchitecture.Op10Op3.save],
rs1MS: SPARCArchitecture.RegisterMSFromRegister[register: source],
rs1LS: SPARCArchitecture.RegisterLSFromRegister[register: source],
i: SPARCArchitecture.I.useSimm13,
simm13: SPARCArchitecture.Unbiased13FromSimm13[simm13: constant]];
instruction: SPARCArchitecture.SPARCInstruction ~ LOOPHOLE[format3simm13];

RETURN [instruction];
};

RestoreConst: PUBLIC PROCEDURE [
source: SPARCArchitecture.Register, 
constant: SPARCArchitecture.Simm13, 
dest: SPARCArchitecture.Register]
RETURNS [SPARCArchitecture.SPARCInstruction] ~ {
format3simm13: SPARCArchitecture.Format3Simm13 ~ [
op: SPARCArchitecture.Op.other2,
rd: dest,
op3: SPARCArchitecture.Op3FromOp10Op3[op10Op3: SPARCArchitecture.Op10Op3.restore],
rs1MS: SPARCArchitecture.RegisterMSFromRegister[register: source],
rs1LS: SPARCArchitecture.RegisterLSFromRegister[register: source],
i: SPARCArchitecture.I.useSimm13,
simm13: SPARCArchitecture.Unbiased13FromSimm13[simm13: constant]];
instruction: SPARCArchitecture.SPARCInstruction ~ LOOPHOLE[format3simm13];

RETURN [instruction];
};

AddConst: PUBLIC PROCEDURE [
source: SPARCArchitecture.Register, 
constant: SPARCArchitecture.Simm13, 
dest: SPARCArchitecture.Register]
RETURNS [SPARCArchitecture.SPARCInstruction] ~ {
format3simm13: SPARCArchitecture.Format3Simm13 ~ [
op: SPARCArchitecture.Op.other2,
rd: dest,
op3: SPARCArchitecture.Op3FromOp10Op3[op10Op3: SPARCArchitecture.Op10Op3.add],
rs1MS: SPARCArchitecture.RegisterMSFromRegister[register: source],
rs1LS: SPARCArchitecture.RegisterLSFromRegister[register: source],
i: SPARCArchitecture.I.useSimm13,
simm13: SPARCArchitecture.Unbiased13FromSimm13[simm13: constant]];
instruction: SPARCArchitecture.SPARCInstruction ~ LOOPHOLE[format3simm13];

RETURN [instruction];
};

SubConst: PUBLIC PROCEDURE [
source: SPARCArchitecture.Register, 
constant: SPARCArchitecture.Simm13, 
dest: SPARCArchitecture.Register]
RETURNS [SPARCArchitecture.SPARCInstruction] ~ {
format3simm13: SPARCArchitecture.Format3Simm13 ~ [
op: SPARCArchitecture.Op.other2,
rd: dest,
op3: SPARCArchitecture.Op3FromOp10Op3[op10Op3: SPARCArchitecture.Op10Op3.sub],
rs1MS: SPARCArchitecture.RegisterMSFromRegister[register: source],
rs1LS: SPARCArchitecture.RegisterLSFromRegister[register: source],
i: SPARCArchitecture.I.useSimm13,
simm13: SPARCArchitecture.Unbiased13FromSimm13[simm13: constant]];
instruction: SPARCArchitecture.SPARCInstruction ~ LOOPHOLE[format3simm13];

RETURN [instruction];
};

OrConst: PUBLIC PROCEDURE [
source: SPARCArchitecture.Register, 
constant: SPARCArchitecture.Simm13, 
dest: SPARCArchitecture.Register]
RETURNS [SPARCArchitecture.SPARCInstruction] ~ {
format3simm13: SPARCArchitecture.Format3Simm13 ~ [
op: SPARCArchitecture.Op.other2,
rd: dest,
op3: SPARCArchitecture.Op3FromOp10Op3[op10Op3: SPARCArchitecture.Op10Op3.or],
rs1MS: SPARCArchitecture.RegisterMSFromRegister[register: source],
rs1LS: SPARCArchitecture.RegisterLSFromRegister[register: source],
i: SPARCArchitecture.I.useSimm13,
simm13: SPARCArchitecture.Unbiased13FromSimm13[simm13: constant]];
instruction: SPARCArchitecture.SPARCInstruction ~ LOOPHOLE[format3simm13];

RETURN [instruction];
};

Call: PUBLIC PROCEDURE [
pc: SPARCArchitecture.SPARCAddress, to: SPARCArchitecture.SPARCAddress] 
RETURNS [SPARCArchitecture.SPARCInstruction] ~ {
displacement: TargetArchitecture.Displacement ~ 
SPARCArchitecture.DisplacementFromSPARCAddresses[here: pc, there: to];
disp30: SPARCArchitecture.Disp30 ~ 
displacement / BYTES[SPARCArchitecture.SPARCInstruction];
format1: SPARCArchitecture.Format1 ~ [
op: SPARCArchitecture.Op.call, 
disp30MS: SPARCArchitecture.Unbiased30MSFromDisp30[disp30: disp30],
disp30LS: SPARCArchitecture.Unbiased30LSFromDisp30[disp30: disp30]];
instruction: SPARCArchitecture.SPARCInstruction ~ LOOPHOLE[format1];

IF pc.IsNullSPARCAddress[] THEN {
ERROR SPARCArchitecture.NullSPARCAddress;
};
IF to.IsNullSPARCAddress[] THEN {
ERROR SPARCArchitecture.NullSPARCAddress;
};
IF (displacement MOD BYTES[SPARCArchitecture.SPARCInstruction]) # 0 THEN {
ERROR RuntimeError.BoundsFault;
};
RETURN [instruction];
};

JmplConst: PUBLIC PROCEDURE [
source: SPARCArchitecture.Register, 
constant: SPARCArchitecture.Simm13, 
dest: SPARCArchitecture.Register]
RETURNS [SPARCArchitecture.SPARCInstruction] ~ {
format3simm13: SPARCArchitecture.Format3Simm13 ~ [
op: SPARCArchitecture.Op.other2,
rd: dest,
op3: SPARCArchitecture.Op3FromOp10Op3[op10Op3: SPARCArchitecture.Op10Op3.jmpl],
rs1MS: SPARCArchitecture.RegisterMSFromRegister[register: source],
rs1LS: SPARCArchitecture.RegisterLSFromRegister[register: source],
i: SPARCArchitecture.I.useSimm13,
simm13: SPARCArchitecture.Unbiased13FromSimm13[simm13: constant]];
instruction: SPARCArchitecture.SPARCInstruction ~ LOOPHOLE[format3simm13];

RETURN [instruction];
};

Relocate: PUBLIC PROCEDURE [
instruction: SPARCArchitecture.SPARCInstruction, 
from: SPARCArchitecture.SPARCAddress, 
to: SPARCArchitecture.SPARCAddress] 
RETURNS [SPARCArchitecture.SPARCInstruction] ~ {
relocated: SPARCArchitecture.SPARCInstruction ¬ instruction;

IF instruction.IsNullSPARCInstruction[] THEN {
ERROR SPARCArchitecture.NullSPARCInstruction;
};
IF from.IsNullSPARCAddress[] THEN {
ERROR SPARCArchitecture.NullSPARCAddress;
};
IF to.IsNullSPARCAddress[] THEN {
ERROR SPARCArchitecture.NullSPARCAddress;
};
SELECT instruction.GetOp[] FROM
SPARCArchitecture.Op.branch => {
SELECT instruction.GetOp2[] FROM
SPARCArchitecture.Op2.bicc,
SPARCArchitecture.Op2.fbfcc,
SPARCArchitecture.Op2.cbccc => {
RelocateFormat2: PROCEDURE [ 
instruction: SPARCArchitecture.SPARCInstruction, 
from: SPARCArchitecture.SPARCAddress, 
to: SPARCArchitecture.SPARCAddress]
RETURNS [SPARCArchitecture.SPARCInstruction] ~ {
relocated: SPARCArchitecture.SPARCInstruction ¬ instruction;
instructionDisp22: SPARCArchitecture.Disp22 ~ instruction.GetDisp22[];
byteDisplacement: TargetArchitecture.Displacement ~ 
instructionDisp22 * BYTES[SPARCArchitecture.SPARCInstruction];
targetAddress: SPARCArchitecture.SPARCAddress ~ 
SPARCArchitecture.SPARCAddressFromDisplacement[
address: from, displacement: byteDisplacement];
relocationDisplacement: TargetArchitecture.Displacement ~ 
SPARCArchitecture.DisplacementFromSPARCAddresses
[here: to, there: targetAddress];
relocationDisp22: SPARCArchitecture.Disp22 ~ 
relocationDisplacement / BYTES[SPARCArchitecture.SPARCInstruction];

IF relocationDisp22 NOT IN
[SPARCArchitecture.firstDisp22..SPARCArchitecture.lastDisp22] THEN {
ERROR SPARCArchitecture.CantRelocate;
};
IF relocationDisplacement MOD BYTES[SPARCArchitecture.SPARCInstruction]
# 0 THEN {
ERROR SPARCArchitecture.CantRelocate;
};
relocated ¬ instruction.SetDisp22[disp22: relocationDisp22];
RETURN [relocated];
};

relocated ¬ RelocateFormat2[instruction: instruction, from: from, to: to];
};
ENDCASE => {
NULL;
};
};
SPARCArchitecture.Op.call => {
RelocateFormat1: PROCEDURE [ 
instruction: SPARCArchitecture.SPARCInstruction, 
from: SPARCArchitecture.SPARCAddress, 
to: SPARCArchitecture.SPARCAddress]
RETURNS [SPARCArchitecture.SPARCInstruction] ~ {
relocated: SPARCArchitecture.SPARCInstruction ¬ instruction;
instructionDisp30: SPARCArchitecture.Disp30 ~ instruction.GetDisp30[];
byteDisplacement: TargetArchitecture.Displacement ~ 
instructionDisp30 * BYTES[SPARCArchitecture.SPARCInstruction];
targetAddress: SPARCArchitecture.SPARCAddress ~ 
SPARCArchitecture.SPARCAddressFromDisplacement[
address: from, displacement: byteDisplacement];
relocationDisplacement: TargetArchitecture.Displacement ~ 
SPARCArchitecture.DisplacementFromSPARCAddresses
[here: to, there: targetAddress];
relocationDisp30: SPARCArchitecture.Disp30 ~ 
relocationDisplacement / BYTES[SPARCArchitecture.SPARCInstruction];

IF relocationDisp30 NOT IN
[SPARCArchitecture.firstDisp30..SPARCArchitecture.lastDisp30] THEN {
ERROR SPARCArchitecture.CantRelocate;
};
IF relocationDisplacement MOD BYTES[SPARCArchitecture.SPARCInstruction]
# 0 THEN {
ERROR SPARCArchitecture.CantRelocate;
};
relocated ¬ instruction.SetDisp30[disp30: relocationDisp30];
RETURN [relocated];
};

relocated ¬ RelocateFormat1[instruction: instruction, from: from, to: to];
};
SPARCArchitecture.Op.other2 => {
NULL;
};
SPARCArchitecture.Op.other3 => {
NULL;
};
ENDCASE => ERROR;
RETURN [relocated];
};

IsDelayedControlTransfer: PUBLIC PROCEDURE [
instruction: SPARCArchitecture.SPARCInstruction] 
RETURNS [BOOLEAN] ~ {
hasDelayInstruction: BOOLEAN ¬ FALSE;

IF instruction.IsNullSPARCInstruction[] THEN {
ERROR SPARCArchitecture.NullSPARCInstruction;
};
SELECT instruction.GetOp[] FROM
SPARCArchitecture.Op.branch => {
SELECT instruction.GetOp2[] FROM
SPARCArchitecture.Op2.bicc,
SPARCArchitecture.Op2.fbfcc,
SPARCArchitecture.Op2.cbccc => {
hasDelayInstruction ¬ TRUE;
};
ENDCASE => {
hasDelayInstruction ¬ FALSE;
};
};
SPARCArchitecture.Op.call => {
hasDelayInstruction ¬ TRUE;
};
SPARCArchitecture.Op.other2 => {
op3: SPARCArchitecture.Op3 ~ instruction.GetOp3[];

SELECT op3.Op10Op3FromOp3[] FROM
SPARCArchitecture.Op10Op3.jmpl,
SPARCArchitecture.Op10Op3.rett => {
hasDelayInstruction ¬ TRUE;
};
ENDCASE => {
hasDelayInstruction ¬ FALSE;
};
};
SPARCArchitecture.Op.other3 => {
hasDelayInstruction ¬ FALSE;
};
ENDCASE => ERROR;
RETURN [hasDelayInstruction];
};

noopInstruction: SPARCArchitecture.SPARCInstruction ~ SPARCArchitecture.Noop[];

IsNoopInstruction: PUBLIC PROCEDURE [instruction: SPARCArchitecture.SPARCInstruction] 
RETURNS [BOOLEAN] ~ {
isNoopInstruction: BOOLEAN ~ instruction = noopInstruction;

IF instruction.IsNullSPARCInstruction[] THEN {
ERROR SPARCArchitecture.NullSPARCInstruction;
};
RETURN [isNoopInstruction];
};
NeedsRelocation: PUBLIC PROCEDURE [instruction: SPARCArchitecture.SPARCInstruction] 
RETURNS [BOOLEAN] ~ {
needsRelocation: BOOLEAN ¬ FALSE;

IF instruction.IsNullSPARCInstruction[] THEN {
ERROR SPARCArchitecture.NullSPARCInstruction;
};
SELECT instruction.GetOp[] FROM
SPARCArchitecture.Op.branch => {
SELECT instruction.GetOp2[] FROM
SPARCArchitecture.Op2.bicc,
SPARCArchitecture.Op2.fbfcc,
SPARCArchitecture.Op2.cbccc => {
needsRelocation ¬ TRUE;
};
ENDCASE => {
needsRelocation ¬ FALSE;
};
};
SPARCArchitecture.Op.call => {
needsRelocation ¬ TRUE;
};
SPARCArchitecture.Op.other2 => {
needsRelocation ¬ FALSE;
};
SPARCArchitecture.Op.other3 => {
needsRelocation ¬ FALSE;
};
ENDCASE => ERROR;
RETURN [needsRelocation];
};

IsCallInstruction: PUBLIC PROCEDURE [instruction: SPARCArchitecture.SPARCInstruction] 
RETURNS [BOOLEAN] ~ {
isCallInstruction: BOOLEAN ¬ FALSE;

IF instruction.IsNullSPARCInstruction[] THEN {
ERROR SPARCArchitecture.NullSPARCInstruction;
};
SELECT instruction.GetOp[] FROM
SPARCArchitecture.Op.branch => {
isCallInstruction ¬ FALSE;
};
SPARCArchitecture.Op.call => {
isCallInstruction ¬ TRUE;
};
SPARCArchitecture.Op.other2 => {
isCallInstruction ¬ FALSE;
};
SPARCArchitecture.Op.other3 => {
isCallInstruction ¬ FALSE;
};
ENDCASE => ERROR;
RETURN [isCallInstruction];
};

IsDelayedBranchInstruction: PUBLIC PROCEDURE [
instruction: SPARCArchitecture.SPARCInstruction] 
RETURNS [BOOLEAN] ~ {
isDelayedBranchInstruction: BOOLEAN ¬ FALSE;

IF instruction.IsNullSPARCInstruction[] THEN {
ERROR SPARCArchitecture.NullSPARCInstruction;
};
SELECT instruction.GetOp[] FROM
SPARCArchitecture.Op.branch => {
SELECT instruction.GetOp2[] FROM
SPARCArchitecture.Op2.bicc,
SPARCArchitecture.Op2.fbfcc,
SPARCArchitecture.Op2.cbccc => {
isDelayedBranchInstruction ¬ TRUE;
};
ENDCASE => {
isDelayedBranchInstruction ¬ FALSE;
};
};
SPARCArchitecture.Op.call => {
isDelayedBranchInstruction ¬ FALSE;
};
SPARCArchitecture.Op.other2 => {
isDelayedBranchInstruction ¬ FALSE;
};
SPARCArchitecture.Op.other3 => {
isDelayedBranchInstruction ¬ FALSE;
};
ENDCASE => ERROR;
RETURN [isDelayedBranchInstruction];
};

IsJmplO7Instruction: PUBLIC PROCEDURE [instruction: SPARCArchitecture.SPARCInstruction] 
RETURNS [BOOLEAN] ~ {
isJmplO7Instruction: BOOLEAN ¬ FALSE;

IF instruction.IsNullSPARCInstruction[] THEN {
ERROR SPARCArchitecture.NullSPARCInstruction;
};
SELECT instruction.GetOp[] FROM
SPARCArchitecture.Op.branch => {
isJmplO7Instruction ¬ FALSE;
};
SPARCArchitecture.Op.call => {
isJmplO7Instruction ¬ FALSE;
};
SPARCArchitecture.Op.other2 => {
op3: SPARCArchitecture.Op3 ~ instruction.GetOp3[];

SELECT op3.Op10Op3FromOp3[] FROM
SPARCArchitecture.Op10Op3.jmpl => {
isJmplO7Instruction ¬ instruction.GetRd[] = SPARCArchitecture.Register.out7;
};
ENDCASE => {
isJmplO7Instruction ¬ FALSE;
};
};
SPARCArchitecture.Op.other3 => {
isJmplO7Instruction ¬ FALSE;
};
ENDCASE => ERROR;
RETURN [isJmplO7Instruction];
};

IsJmplG0Instruction: PUBLIC PROCEDURE [instruction: SPARCArchitecture.SPARCInstruction] 
RETURNS [BOOLEAN] ~ {
isJmplG0Instruction: BOOLEAN ¬ FALSE;

IF instruction.IsNullSPARCInstruction[] THEN {
ERROR SPARCArchitecture.NullSPARCInstruction;
};
SELECT instruction.GetOp[] FROM
SPARCArchitecture.Op.branch => {
isJmplG0Instruction ¬ FALSE;
};
SPARCArchitecture.Op.call => {
isJmplG0Instruction ¬ FALSE;
};
SPARCArchitecture.Op.other2 => {
op3: SPARCArchitecture.Op3 ~ instruction.GetOp3[];

SELECT op3.Op10Op3FromOp3[] FROM
SPARCArchitecture.Op10Op3.jmpl => {
isJmplG0Instruction ¬ instruction.GetRd[] = SPARCArchitecture.Register.global0;
};
ENDCASE => {
isJmplG0Instruction ¬ FALSE;
};
};
SPARCArchitecture.Op.other3 => {
isJmplG0Instruction ¬ FALSE;
};
ENDCASE => ERROR;
RETURN [isJmplG0Instruction];
};

GetFormat: PUBLIC PROCEDURE [instruction: SPARCArchitecture.SPARCInstruction] 
RETURNS [SPARCArchitecture.Format] ~ {
format: SPARCArchitecture.Format ~ 
SELECT instruction.GetOp[] FROM
SPARCArchitecture.Op.branch	=> SPARCArchitecture.Format.format2,
SPARCArchitecture.Op.call	=> SPARCArchitecture.Format.format1,
SPARCArchitecture.Op.other2	=> SPARCArchitecture.Format.format2,
SPARCArchitecture.Op.other3	=> SPARCArchitecture.Format.format3,
ENDCASE => ERROR;

IF instruction.IsNullSPARCInstruction[] THEN {
ERROR SPARCArchitecture.NullSPARCInstruction;
};
RETURN [format];
};

GetOp: PUBLIC PROCEDURE [instruction: SPARCArchitecture.SPARCInstruction] 
RETURNS [SPARCArchitecture.Op] ~ {
format1: SPARCArchitecture.Format1 ~ LOOPHOLE[instruction];
op: SPARCArchitecture.Op ~ format1.op;

IF instruction.IsNullSPARCInstruction[] THEN {
ERROR SPARCArchitecture.NullSPARCInstruction;
};
RETURN [op];
};

GetDisp30: PUBLIC PROCEDURE [instruction: SPARCArchitecture.SPARCInstruction] 
RETURNS [SPARCArchitecture.Disp30] ~ {
format1: SPARCArchitecture.Format1 ~ LOOPHOLE[instruction];
disp30: SPARCArchitecture.Disp30 ~ 
SPARCArchitecture.Disp30FromUnbiased30[
unbiased30MS: format1.disp30MS, unbiased30LS: format1.disp30LS];

IF instruction.IsNullSPARCInstruction[] THEN {
ERROR SPARCArchitecture.NullSPARCInstruction;
};
RETURN [disp30];
};

GetRd: PUBLIC PROCEDURE [instruction: SPARCArchitecture.SPARCInstruction] 
RETURNS [SPARCArchitecture.Register] ~ {
format2Imm22: SPARCArchitecture.Format2Imm22 ~ LOOPHOLE[instruction];
rd: SPARCArchitecture.Register ~ format2Imm22.rd;

IF instruction.IsNullSPARCInstruction[] THEN {
ERROR SPARCArchitecture.NullSPARCInstruction;
};
RETURN [rd];
};

GetOp2: PUBLIC PROCEDURE [instruction: SPARCArchitecture.SPARCInstruction] 
RETURNS [SPARCArchitecture.Op2] ~ {
format2Imm22: SPARCArchitecture.Format2Imm22 ~ LOOPHOLE[instruction];
op2: SPARCArchitecture.Op2 ~ format2Imm22.op2;

IF instruction.IsNullSPARCInstruction[] THEN {
ERROR SPARCArchitecture.NullSPARCInstruction;
};
RETURN [op2];
};

GetImm22: PUBLIC PROCEDURE [instruction: SPARCArchitecture.SPARCInstruction] 
RETURNS [SPARCArchitecture.Imm22] ~ {
format2Imm22: SPARCArchitecture.Format2Imm22 ~ LOOPHOLE[instruction];
imm22: SPARCArchitecture.Imm22 ~ SPARCArchitecture.Imm22FromImm22ML[
imm22MS: format2Imm22.imm22MS, imm22LS: format2Imm22.imm22LS];

IF instruction.IsNullSPARCInstruction[] THEN {
ERROR SPARCArchitecture.NullSPARCInstruction;
};
RETURN [imm22];
};

GetAnnul: PUBLIC PROCEDURE [instruction: SPARCArchitecture.SPARCInstruction] 
RETURNS [SPARCArchitecture.Annul] ~ {
format2Disp22: SPARCArchitecture.Format2Disp22 ~ LOOPHOLE[instruction];
annul: SPARCArchitecture.Annul ~ format2Disp22.a;

IF instruction.IsNullSPARCInstruction[] THEN {
ERROR SPARCArchitecture.NullSPARCInstruction;
};
RETURN [annul];
};

GetCond: PUBLIC PROCEDURE [instruction: SPARCArchitecture.SPARCInstruction] 
RETURNS [SPARCArchitecture.Cond] ~ {
format2Disp22: SPARCArchitecture.Format2Disp22 ~ LOOPHOLE[instruction];
cond: SPARCArchitecture.Cond ~ format2Disp22.cond;

IF instruction.IsNullSPARCInstruction[] THEN {
ERROR SPARCArchitecture.NullSPARCInstruction;
};
RETURN [cond];
};

GetDisp22: PUBLIC PROCEDURE [instruction: SPARCArchitecture.SPARCInstruction] 
RETURNS [SPARCArchitecture.Disp22] ~ {
format2Disp22: SPARCArchitecture.Format2Disp22 ~ LOOPHOLE[instruction];
disp22: SPARCArchitecture.Disp22 ~ 
SPARCArchitecture.Disp22FromUnbiased22[
unbiased22MS: format2Disp22.disp22MS, unbiased22LS: format2Disp22.disp22LS];

IF instruction.IsNullSPARCInstruction[] THEN {
ERROR SPARCArchitecture.NullSPARCInstruction;
};
RETURN [disp22];
};

GetRs1: PUBLIC PROCEDURE [instruction: SPARCArchitecture.SPARCInstruction] 
RETURNS [SPARCArchitecture.Register] ~ {
format3asi: SPARCArchitecture.Format3asi ~ LOOPHOLE[instruction];
rs1: SPARCArchitecture.Register ~ SPARCArchitecture.RegisterFromRegisterML[registerMS: format3asi.rs1MS, registerLS: format3asi.rs1LS];

IF instruction.IsNullSPARCInstruction[] THEN {
ERROR SPARCArchitecture.NullSPARCInstruction;
};
RETURN [rs1];
};

RegisterFromRegisterML: PUBLIC PROCEDURE [
registerMS: SPARCArchitecture.RegisterMS, 
registerLS: SPARCArchitecture.RegisterLS]
RETURNS [SPARCArchitecture.Register] ~ {
register: SPARCArchitecture.Register ~ VAL[
(registerMS * (LAST[SPARCArchitecture.RegisterLS] + 1)) + registerLS
];

RETURN [register];
};

GetI: PUBLIC PROCEDURE [instruction: SPARCArchitecture.SPARCInstruction] 
RETURNS [SPARCArchitecture.I] ~ {
format3asi: SPARCArchitecture.Format3asi ~ LOOPHOLE[instruction];
i: SPARCArchitecture.I ~ format3asi.i;

IF instruction.IsNullSPARCInstruction[] THEN {
ERROR SPARCArchitecture.NullSPARCInstruction;
};
RETURN [i];
};

GetASI: PUBLIC PROCEDURE [instruction: SPARCArchitecture.SPARCInstruction] 
RETURNS [SPARCArchitecture.ASI] ~ {
format3asi: SPARCArchitecture.Format3asi ~ LOOPHOLE[instruction];
asi: SPARCArchitecture.ASI ~ format3asi.asi;

IF instruction.IsNullSPARCInstruction[] THEN {
ERROR SPARCArchitecture.NullSPARCInstruction;
};
RETURN [asi];
};

GetRs2: PUBLIC PROCEDURE [instruction: SPARCArchitecture.SPARCInstruction] 
RETURNS [SPARCArchitecture.Register] ~ {
format3asi: SPARCArchitecture.Format3asi ~ LOOPHOLE[instruction];
rs2: SPARCArchitecture.Register ~ format3asi.rs2;

IF instruction.IsNullSPARCInstruction[] THEN {
ERROR SPARCArchitecture.NullSPARCInstruction;
};
RETURN [rs2];
};

GetSimm13: PUBLIC PROCEDURE [instruction: SPARCArchitecture.SPARCInstruction] 
RETURNS [SPARCArchitecture.Simm13] ~ {
format3Simm13: SPARCArchitecture.Format3Simm13 ~ LOOPHOLE[instruction];
simm13: SPARCArchitecture.Simm13 ~ 
SPARCArchitecture.Simm13FromUnbiased13[unbiased13: format3Simm13.simm13];

IF instruction.IsNullSPARCInstruction[] THEN {
ERROR SPARCArchitecture.NullSPARCInstruction;
};
RETURN [simm13];
};

GetOpF: PUBLIC PROCEDURE [instruction: SPARCArchitecture.SPARCInstruction] 
RETURNS [SPARCArchitecture.OpF] ~ {
format3OpF: SPARCArchitecture.Format3OpF ~ LOOPHOLE[instruction];
opf: SPARCArchitecture.OpF ~ format3OpF.opf;

IF instruction.IsNullSPARCInstruction[] THEN {
ERROR SPARCArchitecture.NullSPARCInstruction;
};
RETURN [opf];
};

GetOp3: PUBLIC PROCEDURE [instruction: SPARCArchitecture.SPARCInstruction] 
RETURNS [SPARCArchitecture.Op3] ~ {
format3TiccRs2: SPARCArchitecture.Format3TiccRs2 ~ LOOPHOLE[instruction];
op3: SPARCArchitecture.Op3 ~ format3TiccRs2.op3;

IF instruction.IsNullSPARCInstruction[] THEN {
ERROR SPARCArchitecture.NullSPARCInstruction;
};
RETURN [op3];
};

Op10Op3FromOp3: PUBLIC PROCEDURE [op3: SPARCArchitecture.Op3] 
RETURNS [SPARCArchitecture.Op10Op3] ~ {
op10Op3: SPARCArchitecture.Op10Op3 ~ VAL[ORD[op3]];
RETURN [op10Op3];
};
Op11Op3FromOp3: PUBLIC PROCEDURE [op3: SPARCArchitecture.Op3] 
RETURNS [SPARCArchitecture.Op11Op3] ~ {
op11Op3: SPARCArchitecture.Op11Op3 ~ VAL[ORD[op3]];
RETURN [op11Op3];
};

Disp30FromUnbiased30: PUBLIC PROCEDURE [
unbiased30MS: SPARCArchitecture.Unbiased30MS, 
unbiased30LS: SPARCArchitecture.Unbiased30LS] 
RETURNS [SPARCArchitecture.Disp30] ~ {
unbiased30: SPARCArchitecture.Unbiased30 ~ 
(unbiased30MS * (CARD32[LAST[SPARCArchitecture.Unbiased30LS]] + 1)) 
+ unbiased30LS;
disp30: SPARCArchitecture.Disp30 ~ 
IF unbiased30 <= SPARCArchitecture.Unbiased30[SPARCArchitecture.lastDisp30]
THEN unbiased30
ELSE -(SPARCArchitecture.lastUnbiased30 + 1 - unbiased30);

IF unbiased30 NOT IN 
[SPARCArchitecture.firstUnbiased30 .. SPARCArchitecture.lastUnbiased30] THEN {
ERROR RuntimeError.BoundsFault
};
RETURN [disp30];
};

Disp22FromUnbiased22: PUBLIC PROCEDURE [
unbiased22MS: SPARCArchitecture.Unbiased22MS,
unbiased22LS: SPARCArchitecture.Unbiased22LS] 
RETURNS [SPARCArchitecture.Disp22] ~ {
unbiased22: SPARCArchitecture.Unbiased22 ~ 
(unbiased22MS * (CARD32[LAST[SPARCArchitecture.Unbiased22LS]] + 1)) 
+ unbiased22LS;
disp22: SPARCArchitecture.Disp22 ~ 
IF unbiased22 <= SPARCArchitecture.Unbiased22[SPARCArchitecture.lastDisp22]
THEN unbiased22
ELSE -(SPARCArchitecture.lastUnbiased22 + 1 - unbiased22);

IF unbiased22 NOT IN 
[SPARCArchitecture.firstUnbiased22 .. SPARCArchitecture.lastUnbiased22] THEN {
ERROR RuntimeError.BoundsFault
};
RETURN [disp22];
};

Imm22FromImm22ML: PUBLIC PROCEDURE [
imm22MS: SPARCArchitecture.Imm22MS, 
imm22LS: SPARCArchitecture.Imm22LS] 
RETURNS [SPARCArchitecture.Imm22] ~ {
imm22: SPARCArchitecture.Imm22 ~ 
(imm22MS * (CARD32[LAST[SPARCArchitecture.Imm22LS]] + 1)) + imm22LS;

IF NOT imm22 IN [SPARCArchitecture.firstImm22 .. SPARCArchitecture.lastImm22] THEN {
ERROR RuntimeError.BoundsFault;
};
RETURN [imm22];
};

Imm22MSFromImm22: PUBLIC PROCEDURE [imm22: SPARCArchitecture.Imm22] 
RETURNS [SPARCArchitecture.Imm22MS] ~ {
imm22MS: SPARCArchitecture.Imm22MS ~ 
imm22 / (CARD32[LAST[SPARCArchitecture.Imm22LS]] + 1);

IF NOT imm22 IN [SPARCArchitecture.firstImm22 .. SPARCArchitecture.lastImm22] THEN {
ERROR RuntimeError.BoundsFault;
};
RETURN [imm22MS];
};

Imm22LSFromImm22: PUBLIC PROCEDURE [imm22: SPARCArchitecture.Imm22] 
RETURNS [SPARCArchitecture.Imm22LS] ~ {
imm22LS: SPARCArchitecture.Imm22LS ~ 
imm22 MOD (CARD32[LAST[SPARCArchitecture.Imm22LS]] + 1);

IF NOT imm22 IN [SPARCArchitecture.firstImm22 .. SPARCArchitecture.lastImm22] THEN {
ERROR RuntimeError.BoundsFault;
};
RETURN [imm22LS];
};

Simm13FromUnbiased13: PUBLIC PROCEDURE [unbiased13: SPARCArchitecture.Unbiased13] 
RETURNS [SPARCArchitecture.Simm13] ~ {
biased: INT32 ~ IF unbiased13 <= SPARCArchitecture.lastSimm13
THEN unbiased13
ELSE -(SPARCArchitecture.lastUnbiased13 + 1 - unbiased13);
simm13: SPARCArchitecture.Simm13 ~ biased;

RETURN [simm13];
};

Hi: PUBLIC PROCEDURE [value: CARD32] RETURNS [SPARCArchitecture.Imm22] ~ {
hi: SPARCArchitecture.Imm22 ~ value / (CARD32[SPARCArchitecture.lastImm10] + 1);

RETURN [hi];
};

Lo: PUBLIC PROCEDURE [value: CARD32] RETURNS [SPARCArchitecture.Imm10] ~ {
lo: SPARCArchitecture.Imm10 ~ value MOD (CARD32[SPARCArchitecture.lastImm10] + 1);

RETURN [lo];
};

HiLo: PUBLIC PROCEDURE[hi: SPARCArchitecture.Imm22, lo: SPARCArchitecture.Imm10] 
RETURNS [CARD32] ~ {
hiLo: CARD32 ~ (hi * (CARD32[SPARCArchitecture.lastImm10] + 1)) + lo;

IF hi NOT IN [SPARCArchitecture.firstImm22 .. SPARCArchitecture.lastImm22] THEN {
ERROR RuntimeError.BoundsFault;
};
IF lo NOT IN [SPARCArchitecture.firstImm22 .. SPARCArchitecture.lastImm22] THEN {
ERROR RuntimeError.BoundsFault;
};
RETURN [hiLo];
};

SetOp: PUBLIC PROCEDURE [
instruction: SPARCArchitecture.SPARCInstruction, op: SPARCArchitecture.Op] 
RETURNS [SPARCArchitecture.SPARCInstruction] ~ {
format1: SPARCArchitecture.Format1 ¬ LOOPHOLE[instruction];

IF instruction.IsNullSPARCInstruction[] THEN {
ERROR SPARCArchitecture.NullSPARCInstruction;
};
format1.op ¬ op;
RETURN [LOOPHOLE[format1]];
};

SetDisp30: PUBLIC PROCEDURE [
instruction: SPARCArchitecture.SPARCInstruction, disp30: SPARCArchitecture.Disp30] 
RETURNS [SPARCArchitecture.SPARCInstruction] ~ {
format1: SPARCArchitecture.Format1 ¬ LOOPHOLE[instruction];

IF instruction.IsNullSPARCInstruction[] THEN {
ERROR SPARCArchitecture.NullSPARCInstruction;
};
IF disp30 NOT IN [SPARCArchitecture.firstDisp30 ..SPARCArchitecture.lastDisp30] THEN {
ERROR RuntimeError.BoundsFault;
};
format1.disp30MS ¬ SPARCArchitecture.Unbiased30MSFromDisp30[disp30: disp30];
format1.disp30LS ¬ SPARCArchitecture.Unbiased30LSFromDisp30[disp30: disp30];
RETURN [LOOPHOLE[format1]];
};

SetRd: PUBLIC PROCEDURE [
instruction: SPARCArchitecture.SPARCInstruction, rd: SPARCArchitecture.Register] 
RETURNS [SPARCArchitecture.SPARCInstruction] ~ {
format2Imm22: SPARCArchitecture.Format2Imm22 ¬ LOOPHOLE[instruction];

IF instruction.IsNullSPARCInstruction[] THEN {
ERROR SPARCArchitecture.NullSPARCInstruction;
};
format2Imm22.rd ¬ rd;
RETURN [LOOPHOLE[format2Imm22]];
};

SetOp2: PUBLIC PROCEDURE [
instruction: SPARCArchitecture.SPARCInstruction, op2: SPARCArchitecture.Op2] 
RETURNS [SPARCArchitecture.SPARCInstruction] ~ {
format2Imm22: SPARCArchitecture.Format2Imm22 ¬ LOOPHOLE[instruction];

IF instruction.IsNullSPARCInstruction[] THEN {
ERROR SPARCArchitecture.NullSPARCInstruction;
};
format2Imm22.op2 ¬ op2;
RETURN [LOOPHOLE[format2Imm22]];
};

SetImm22: PUBLIC PROCEDURE [
instruction: SPARCArchitecture.SPARCInstruction, imm22: SPARCArchitecture.Imm22] 
RETURNS [SPARCArchitecture.SPARCInstruction] ~ {
format2Imm22: SPARCArchitecture.Format2Imm22 ¬ LOOPHOLE[instruction];

IF instruction.IsNullSPARCInstruction[] THEN {
ERROR SPARCArchitecture.NullSPARCInstruction;
};
IF imm22 NOT IN [SPARCArchitecture.firstImm22 .. SPARCArchitecture.lastImm22] THEN {
ERROR RuntimeError.BoundsFault;
};
format2Imm22.imm22MS ¬ SPARCArchitecture.Unbiased22MSFromImm22[imm22: imm22];
format2Imm22.imm22LS ¬ SPARCArchitecture.Unbiased22LSFromImm22[imm22: imm22];
RETURN [LOOPHOLE[format2Imm22]];
};

SetAnnul: PUBLIC PROCEDURE [
instruction: SPARCArchitecture.SPARCInstruction, annul: SPARCArchitecture.Annul] 
RETURNS [SPARCArchitecture.SPARCInstruction] ~ {
format2Disp22: SPARCArchitecture.Format2Disp22 ¬ LOOPHOLE[instruction];

IF instruction.IsNullSPARCInstruction[] THEN {
ERROR SPARCArchitecture.NullSPARCInstruction;
};
format2Disp22.a ¬ annul;
RETURN [LOOPHOLE[format2Disp22]];
};

SetCond: PUBLIC PROCEDURE [
instruction: SPARCArchitecture.SPARCInstruction, cond: SPARCArchitecture.Cond] 
RETURNS [SPARCArchitecture.SPARCInstruction] ~ {
format2Disp22: SPARCArchitecture.Format2Disp22 ¬ LOOPHOLE[instruction];

IF instruction.IsNullSPARCInstruction[] THEN {
ERROR SPARCArchitecture.NullSPARCInstruction;
};
format2Disp22.cond ¬ cond;
RETURN [LOOPHOLE[format2Disp22]];
};

SetDisp22: PUBLIC PROCEDURE [
instruction: SPARCArchitecture.SPARCInstruction, disp22: SPARCArchitecture.Disp22] 
RETURNS [SPARCArchitecture.SPARCInstruction] ~ {
format2Disp22: SPARCArchitecture.Format2Disp22 ¬ LOOPHOLE[instruction];

IF instruction.IsNullSPARCInstruction[] THEN {
ERROR SPARCArchitecture.NullSPARCInstruction;
};
IF disp22 NOT IN [SPARCArchitecture.firstDisp22 .. SPARCArchitecture.lastDisp22] THEN {
ERROR RuntimeError.BoundsFault;
};
format2Disp22.disp22MS ¬ SPARCArchitecture.Unbiased22MSFromDisp22[disp22: disp22];
format2Disp22.disp22LS ¬ SPARCArchitecture.Unbiased22LSFromDisp22[disp22: disp22];
RETURN [LOOPHOLE[format2Disp22]];
};

SetRs1: PUBLIC PROCEDURE [
instruction: SPARCArchitecture.SPARCInstruction, rs1: SPARCArchitecture.Register] 
RETURNS [SPARCArchitecture.SPARCInstruction] ~ {
format3asi: SPARCArchitecture.Format3asi ¬ LOOPHOLE[instruction];

IF instruction.IsNullSPARCInstruction[] THEN {
ERROR SPARCArchitecture.NullSPARCInstruction;
};
format3asi.rs1MS ¬ SPARCArchitecture.RegisterMSFromRegister[register: rs1];
format3asi.rs1LS ¬ SPARCArchitecture.RegisterLSFromRegister[register: rs1];
RETURN [LOOPHOLE[format3asi]];
};

RegisterMSFromRegister: PUBLIC PROCEDURE [register: SPARCArchitecture.Register]
RETURNS [SPARCArchitecture.RegisterMS] ~ {
registerMS: SPARCArchitecture.RegisterMS ~ 
ORD[register] / (LAST[SPARCArchitecture.RegisterLS] + 1);

RETURN [registerMS];
};

RegisterLSFromRegister: PUBLIC PROCEDURE [register: SPARCArchitecture.Register]
RETURNS [SPARCArchitecture.RegisterLS]~ {
registerLS: SPARCArchitecture.RegisterLS ~ 
ORD[register] MOD (LAST[SPARCArchitecture.RegisterLS] + 1);

RETURN [registerLS];
};

SetI: PUBLIC PROCEDURE [
instruction: SPARCArchitecture.SPARCInstruction, i: SPARCArchitecture.I] 
RETURNS [SPARCArchitecture.SPARCInstruction] ~ {
format3asi: SPARCArchitecture.Format3asi ¬ LOOPHOLE[instruction];

IF instruction.IsNullSPARCInstruction[] THEN {
ERROR SPARCArchitecture.NullSPARCInstruction;
};
format3asi.i ¬ i;
RETURN [LOOPHOLE[format3asi]];
};

SetASI: PUBLIC PROCEDURE [
instruction: SPARCArchitecture.SPARCInstruction, asi: SPARCArchitecture.ASI] 
RETURNS [SPARCArchitecture.SPARCInstruction] ~ {
format3asi: SPARCArchitecture.Format3asi ¬ LOOPHOLE[instruction];

IF instruction.IsNullSPARCInstruction[] THEN {
ERROR SPARCArchitecture.NullSPARCInstruction;
};
format3asi.asi ¬ asi;
RETURN [LOOPHOLE[format3asi]];
};

SetRs2: PUBLIC PROCEDURE [
instruction: SPARCArchitecture.SPARCInstruction, rs2: SPARCArchitecture.Register] 
RETURNS [SPARCArchitecture.SPARCInstruction] ~ {
format3asi: SPARCArchitecture.Format3asi ¬ LOOPHOLE[instruction];

IF instruction.IsNullSPARCInstruction[] THEN {
ERROR SPARCArchitecture.NullSPARCInstruction;
};
format3asi.rs2 ¬ rs2;
RETURN [LOOPHOLE[format3asi]];
};

SetSimm13: PUBLIC PROCEDURE [
instruction: SPARCArchitecture.SPARCInstruction, simm13: SPARCArchitecture.Simm13] 
RETURNS [SPARCArchitecture.SPARCInstruction] ~ {
format3Simm13: SPARCArchitecture.Format3Simm13 ¬ LOOPHOLE[instruction];

IF instruction.IsNullSPARCInstruction[] THEN {
ERROR SPARCArchitecture.NullSPARCInstruction;
};
format3Simm13.simm13 ¬ SPARCArchitecture.Unbiased13FromSimm13[simm13: simm13];
RETURN [LOOPHOLE[format3Simm13]];
};

SetOpF: PUBLIC PROCEDURE [
instruction: SPARCArchitecture.SPARCInstruction, opf: SPARCArchitecture.OpF] 
RETURNS [SPARCArchitecture.SPARCInstruction] ~ {
format3OpF: SPARCArchitecture.Format3OpF ¬ LOOPHOLE[instruction];

IF instruction.IsNullSPARCInstruction[] THEN {
ERROR SPARCArchitecture.NullSPARCInstruction;
};
format3OpF.opf ¬ opf;
RETURN [LOOPHOLE[format3OpF]];
};

SetOp3: PUBLIC PROCEDURE [
instruction: SPARCArchitecture.SPARCInstruction, op3: SPARCArchitecture.Op3] 
RETURNS [SPARCArchitecture.SPARCInstruction] ~ {
format3TiccRs2: SPARCArchitecture.Format3TiccRs2 ¬ LOOPHOLE[instruction];

IF instruction.IsNullSPARCInstruction[] THEN {
ERROR SPARCArchitecture.NullSPARCInstruction;
};
format3TiccRs2.op3 ¬ op3;
RETURN [LOOPHOLE[format3TiccRs2]];
};

Op3FromOp10Op3: PUBLIC PROCEDURE [op10Op3: SPARCArchitecture.Op10Op3] 
RETURNS [SPARCArchitecture.Op3] ~ {
op3: SPARCArchitecture.Op3 ~ VAL[ORD[op10Op3]];
RETURN [op3];
};
Op3FromOp11Op3: PUBLIC PROCEDURE [op11Op3: SPARCArchitecture.Op11Op3] 
RETURNS [SPARCArchitecture.Op3] ~ {
op3: SPARCArchitecture.Op3 ~ VAL[ORD[op11Op3]];
RETURN [op3];
};

Unbiased30FromDisp30: PUBLIC PROCEDURE [disp30: SPARCArchitecture.Disp30] 
RETURNS [SPARCArchitecture.Unbiased30] ~ {
unbiased: CARD32 ~ LOOPHOLE[disp30];
unbiased30: SPARCArchitecture.Unbiased30 ~ 
unbiased MOD (SPARCArchitecture.lastUnbiased30 + 1);

IF disp30 NOT IN [SPARCArchitecture.firstDisp30 .. SPARCArchitecture.lastDisp30] THEN {
ERROR RuntimeError.BoundsFault;
};
RETURN [unbiased30];
};

Unbiased30MSFromDisp30: PUBLIC PROCEDURE [disp30: SPARCArchitecture.Disp30]
RETURNS [SPARCArchitecture.Unbiased30MS] ~ {
unbiased30: SPARCArchitecture.Unbiased30 ~ 
SPARCArchitecture.Unbiased30FromDisp30[disp30: disp30];
unbiased30MS: SPARCArchitecture.Unbiased30MS ~ 
unbiased30 / (CARD32[LAST[SPARCArchitecture.Unbiased30LS]] + 1);

IF disp30 NOT IN [SPARCArchitecture.firstDisp30 .. SPARCArchitecture.lastDisp30] THEN {
ERROR RuntimeError.BoundsFault;
};
RETURN [unbiased30MS];
};

Unbiased30LSFromDisp30: PUBLIC PROCEDURE [disp30: SPARCArchitecture.Disp30]
RETURNS [SPARCArchitecture.Unbiased30LS] ~ {
unbiased30: SPARCArchitecture.Unbiased30 ~ 
SPARCArchitecture.Unbiased30FromDisp30[disp30: disp30];
unbiased30LS: SPARCArchitecture.Unbiased30LS ~ 
unbiased30 MOD (CARD32[LAST[SPARCArchitecture.Unbiased30LS]] + 1);

RETURN [unbiased30LS];
};

Unbiased22FromDisp22: PUBLIC PROCEDURE [disp22: SPARCArchitecture.Disp22] 
RETURNS [SPARCArchitecture.Unbiased22] ~ {
unbiased: CARD32 ~ LOOPHOLE[disp22];
unbiased22: SPARCArchitecture.Unbiased22 ~ 
unbiased MOD (SPARCArchitecture.lastUnbiased22 + 1);

IF disp22 NOT IN [SPARCArchitecture.firstDisp22 .. SPARCArchitecture.lastDisp22] THEN {
ERROR RuntimeError.BoundsFault;
};
RETURN [unbiased22];
};

Unbiased22MSFromDisp22: PUBLIC PROCEDURE [disp22: SPARCArchitecture.Disp22]
RETURNS [SPARCArchitecture.Unbiased22MS] ~ {
unbiased22: SPARCArchitecture.Unbiased22 ~ 
SPARCArchitecture.Unbiased22FromDisp22[disp22: disp22];
unbiased22MS: SPARCArchitecture.Unbiased22MS ~ 
unbiased22 / (CARD32[LAST[SPARCArchitecture.Unbiased22LS]] + 1);

RETURN [unbiased22MS];
};

Unbiased22LSFromDisp22: PUBLIC PROCEDURE [disp22: SPARCArchitecture.Disp22]
RETURNS [SPARCArchitecture.Unbiased22LS] ~ {
unbiased22: SPARCArchitecture.Unbiased22 ~ 
SPARCArchitecture.Unbiased22FromDisp22[disp22: disp22];
unbiased22LS: SPARCArchitecture.Unbiased22LS ~ 
unbiased22 MOD (CARD32[LAST[SPARCArchitecture.Unbiased22LS]] + 1);

RETURN [unbiased22LS];
};

Unbiased22MSFromImm22: PUBLIC PROCEDURE [imm22: SPARCArchitecture.Imm22]
RETURNS [SPARCArchitecture.Unbiased22MS] ~ {
unbiased22MS: SPARCArchitecture.Unbiased22MS ~ 
imm22 / (CARD32[LAST[SPARCArchitecture.Unbiased22LS]] + 1);

RETURN [unbiased22MS];
};

Unbiased22LSFromImm22: PUBLIC PROCEDURE [imm22: SPARCArchitecture.Imm22]
RETURNS [SPARCArchitecture.Unbiased22LS] ~ {
unbiased22LS: SPARCArchitecture.Unbiased22LS ~ 
imm22 MOD (CARD32[LAST[SPARCArchitecture.Unbiased22LS]] + 1);

RETURN [unbiased22LS];
};

Unbiased13FromSimm13: PUBLIC PROCEDURE [simm13: SPARCArchitecture.Simm13] 
RETURNS [SPARCArchitecture.Unbiased13] ~ {
biased: INT32 ~ simm13;
unbiased13: SPARCArchitecture.Unbiased13 ~ 
IF biased >= 0
THEN biased
ELSE SPARCArchitecture.lastUnbiased13 + 1 + biased;

RETURN [unbiased13];
};

IsNullSPARCAddress: PUBLIC PROCEDURE [address: SPARCArchitecture.SPARCAddress] 
RETURNS [BOOLEAN] ~ {
isNullSPARCAddress: BOOLEAN ~ address = SPARCArchitecture.nullSPARCAddress;

RETURN [isNullSPARCAddress];
};
SPARCAddressFromDisplacement: PUBLIC PROCEDURE [
address: SPARCArchitecture.SPARCAddress, 
displacement: TargetArchitecture.Displacement]
RETURNS [SPARCArchitecture.SPARCAddress] ~ {
targetAddress: TargetArchitecture.Address ~ 
SPARCArchitecture.TargetAddressFromSPARCAddress[sparcAddress: address];
displaced: TargetArchitecture.Address ~ 
TargetArchitecture.AddressFromDisplacement[
address: targetAddress, displacement: displacement];
sparcDisplaced: SPARCArchitecture.SPARCAddress ~ SPARCArchitecture.SPARCAddressFromTargetAddress[address: displaced];

IF address.IsNullSPARCAddress[] THEN {
ERROR SPARCArchitecture.NullSPARCAddress;
};
RETURN [sparcDisplaced];
};

DisplacementFromSPARCAddresses: PUBLIC PROCEDURE [
here: SPARCArchitecture.SPARCAddress, there: SPARCArchitecture.SPARCAddress]
RETURNS [TargetArchitecture.Displacement] ~ {
hereTarget: TargetArchitecture.Address ~ 
SPARCArchitecture.TargetAddressFromSPARCAddress[sparcAddress: here];
thereTarget: TargetArchitecture.Address ~ 
SPARCArchitecture.TargetAddressFromSPARCAddress[sparcAddress: there];
displacement: TargetArchitecture.Displacement ~ 
TargetArchitecture.DisplacementFromAddresses[
here: hereTarget, there: thereTarget];

IF here.IsNullSPARCAddress[] THEN {
ERROR SPARCArchitecture.NullSPARCAddress;
};
IF there.IsNullSPARCAddress[] THEN {
ERROR SPARCArchitecture.NullSPARCAddress;
};
RETURN [displacement];
};

IsNullSPARCInstruction: PUBLIC PROCEDURE [
instruction: SPARCArchitecture.SPARCInstruction] 
RETURNS [BOOLEAN] ~ {
isNullSPARCInstruction: BOOLEAN ~ 
instruction = SPARCArchitecture.nullSPARCInstruction;

RETURN [isNullSPARCInstruction];
};
NextSPARCInstruction: PUBLIC PROCEDURE [pc: SPARCArchitecture.SPARCAddress] 
RETURNS [SPARCArchitecture.SPARCAddress] ~ TRUSTED {
targetPC: TargetArchitecture.Address ~ 
SPARCArchitecture.TargetAddressFromSPARCAddress[sparcAddress: pc];
nextInstruction: TargetArchitecture.Address ~ 
TargetArchitecture.NextInstruction[pc: targetPC];
nextSPARCInstruction: SPARCArchitecture.SPARCAddress ~ 
SPARCArchitecture.SPARCAddressFromTargetAddress[address: nextInstruction];

IF pc.IsNullSPARCAddress[] THEN {
ERROR SPARCArchitecture.NullSPARCAddress;
};
RETURN [nextSPARCInstruction];
};

PrevSPARCInstruction: PUBLIC PROCEDURE [pc: SPARCArchitecture.SPARCAddress] 
RETURNS [SPARCArchitecture.SPARCAddress] ~ {
targetPC: TargetArchitecture.Address ~ 
SPARCArchitecture.TargetAddressFromSPARCAddress[sparcAddress: pc];
prevInstruction: TargetArchitecture.Address ~ 
TargetArchitecture.PrevInstruction[pc: targetPC];
prevSPARCInstruction: SPARCArchitecture.SPARCAddress ~ 
SPARCArchitecture.SPARCAddressFromTargetAddress[address: prevInstruction];

IF pc.IsNullSPARCAddress[] THEN {
ERROR SPARCArchitecture.NullSPARCAddress;
};
RETURN [prevSPARCInstruction];
};

SPARCAddressFromTargetAddress: PUBLIC PROCEDURE [
address: TargetArchitecture.Address] 
RETURNS [SPARCArchitecture.SPARCAddress] ~ {
sparcAddress: SPARCArchitecture.SPARCAddress ~ LOOPHOLE[address];

IF sparcAddress.IsNullSPARCAddress[] THEN {
ERROR SPARCArchitecture.NullSPARCAddress;
};
RETURN [sparcAddress];
};

TargetAddressFromSPARCAddress: PUBLIC PROCEDURE [
sparcAddress: SPARCArchitecture.SPARCAddress] 
RETURNS [TargetArchitecture.Address] ~ {
address: TargetArchitecture.Address ~ LOOPHOLE[sparcAddress];

IF sparcAddress.IsNullSPARCAddress[] THEN {
ERROR SPARCArchitecture.NullSPARCAddress;
};
RETURN [address];
};

SPARCContentsFromTargetContents: PUBLIC PROCEDURE [
contents: TargetArchitecture.Contents]
RETURNS [SPARCArchitecture.SPARCContents] ~ {
sparcContents: SPARCArchitecture.SPARCContents ~ LOOPHOLE[contents];

RETURN [sparcContents];
};

TargetContentsFromSPARCContents: PUBLIC PROCEDURE [
contents: SPARCArchitecture.SPARCContents]
RETURNS [TargetArchitecture.Contents] ~ {
targetContents: TargetArchitecture.Contents ~ LOOPHOLE[contents];

RETURN [targetContents];
};

SPARCInstructionFromTargetInstruction: PUBLIC PROCEDURE [
instruction: TargetArchitecture.Instruction]
RETURNS [SPARCArchitecture.SPARCInstruction] ~ {
sparcInstruction: SPARCArchitecture.SPARCInstruction ~ LOOPHOLE[instruction];

IF sparcInstruction.IsNullSPARCInstruction[] THEN {
ERROR SPARCArchitecture.NullSPARCInstruction;
};
RETURN [sparcInstruction];
};

TargetInstructionFromSPARCInstruction: PUBLIC PROCEDURE [
instruction: SPARCArchitecture.SPARCInstruction]
RETURNS [TargetArchitecture.Instruction] ~ {
targetInstruction: TargetArchitecture.Instruction ~ LOOPHOLE[instruction];

IF instruction.IsNullSPARCInstruction[] THEN {
ERROR SPARCArchitecture.NullSPARCInstruction;
};
RETURN [targetInstruction];
};

SPARCRegisterClassFromTargetRegisterClass: PUBLIC PROCEDURE [
registerClass: TargetArchitecture.RegisterClass]
RETURNS [SPARCArchitecture.RegisterClass] ~ {
sparcRegisterClass: SPARCArchitecture.RegisterClass ~ LOOPHOLE[registerClass];

SELECT sparcRegisterClass FROM
none, 
globals, 
globalsAndIns, 
globalsInsAndFloats, 
globalsInsFloatsOutsAndLocals, 
all => {
NULL;
};
ENDCASE => {
ERROR RuntimeError.BoundsFault;
};
RETURN [sparcRegisterClass];
};

TargetRegisterClassFromSPARCRegisterClass: PUBLIC PROCEDURE [
registerClass: SPARCArchitecture.RegisterClass]
RETURNS [TargetArchitecture.RegisterClass] ~ {
targetRegisterClass: TargetArchitecture.RegisterClass ~ LOOPHOLE[registerClass];

SELECT registerClass FROM
none, 
globals, 
globalsAndIns, 
globalsInsAndFloats, 
globalsInsFloatsOutsAndLocals, 
all => {
NULL;
};
ENDCASE => {
ERROR RuntimeError.BoundsFault;
};
RETURN [targetRegisterClass];
};

CantRelocate: PUBLIC ERROR ~ CODE;
CantReach: PUBLIC ERROR ~ CODE;
NullSPARCAddress: PUBLIC ERROR ~ CODE;
NullSPARCInstruction: PUBLIC ERROR ~ CODE;
}.
ή
SPARCArchitectureImpl.mesa
Copyright Σ 1989, 1991 by Xerox Corporation.  All rights reserved.
Peter B. Kessler, April 9, 1990 3:31:21 pm PDT

Operations the debugger performs on the SPARC.

Code Assembly.
This is a ``SETHI 0, %g0'', the recommended noop, since is doesn't increase the execution time of a load if it follows one.
Relocates an instruction from the given address to another address.
Instruction Classification.
Checks whether the instruction at the given pc has a delay slot.
A sample noop instruction.
Checks whether the instruction at the given pc is a noop.

Checks whether the instruction at the given pc has pc-relative operands.
Checks whether the instruction is a call instruction.
Checks whether the instruction is a delayed branch instruction.
Checks whether the instruction is a jmpl with %o7 as the link register.
Checks whether the instruction is a jmpl with %g0 as the link register.
Field accessors for instructions.
Since SPARCArchitecture.Disp30 isn't a biased subrange any more, this can just sign-extend the unbiased the representation.
Since SPARCArchitecture.Disp22 isn't a biased subrange any more, this can just sign-extend the unbiased the representation.
Field assigners for instructions.
Since SPARCArchitecture.Disp30 isn't a biased subrange any more, all I have to do is pick off the right bits.
Since SPARCArchitecture.Disp22 isn't a biased subrange any more, all I have to do is pick off the right bits.
Miscellaneous.
Tests if its argument is the null SPARCAddress.

Tests if its argument is the null SPARCInstruction.

Returns the instruction address after the given one.
Returns a pointer to the previous instruction.
Yeah for being able to back up in instruction streams, boo for needing to.
Errors.
Given for attempts to relocate an instruction too far, etc.

Given for attempts to generate pc-relative instructions that don't reach.

Given during code generation when null addresses are supplied.

Given when supplied instruction is the null instruction.


Κ*$•NewlineDelimiter

–
(cedarcode) style™
code™Kšœ
Οe
œ7™BKš
œ.™.K™Kšœ(Οkœ
™.K™š
ž	˜	K˜K˜K˜
K˜——
unitšΠlnœžœ
žœ
˜%Kšžœ4˜;Kšžœ˜Kš
œ˜
head™šΟnœžœ
ž	œžœ)˜KKšœžœj™{š
œ0˜0Kš
œ ˜ Kš
œ'˜'Kš
œ!˜!Kš
œ&˜&Kš
œ%˜%K˜—Kšœ2žœ˜IK˜Kšžœ˜Kš
œ˜K˜—š œžœ
ž	œkžœ)˜―
˜2K˜ K˜	K˜MK˜@K˜@Kš
œ!˜!Kš
œ@˜@—Kšœ2žœ˜JK˜Kšžœ˜Kš
œ˜K˜—š œžœ
ž	œmžœ)˜±
˜2K˜ Kš
œ˜K˜MK˜@K˜@Kš
œ!˜!Kš
œ@˜@—Kšœ2žœ˜JK˜Kšžœ˜Kš
œ˜K˜—š œžœ
ž	œCžœ)˜Š
š
œ0˜0Kš
œ ˜ Kš
œ	˜	Kš
œ!˜!Kš
œ0˜0Kš
œ/˜/K˜—Kšœ2žœ˜IK˜Kšžœ˜Kš
œ˜K˜—š œžœ
ž	œLžœ)˜‘
š
œ0˜0Kš
œF˜F—š
œ2˜2Kš
œ'˜'—K˜šžœžœ˜!Kšžœ$˜)K˜—šžœžœ˜!Kšžœ$˜)K˜—šžœžœAžœ˜]Kšžœ˜"K˜—˜
š
œ#˜#Kšœžœ%˜9š
œ2˜2Kš
œ ˜ Kš
œ!˜!Kš
œ$˜$Kš
œ ˜ Kš
œC˜CKš
œB˜BKš
œ˜—K˜Kšœžœ˜&K˜——Kšžœ˜Kš
œ˜K˜—š 	œžœ
ž	œožœ)˜Ί
˜2K˜ Kš
œ	˜	K˜OKš
œB˜BKš
œB˜BKš
œ!˜!Kš
œB˜B—Kšœ2žœ˜JK˜Kšžœ˜Kš
œ˜K˜—š œžœ
ž	œožœ)˜½
˜2K˜ Kš
œ	˜	K˜RKš
œB˜BKš
œB˜BKš
œ!˜!Kš
œB˜B—Kšœ2žœ˜JK˜Kšžœ˜Kš
œ˜K˜—š œžœ
ž	œožœ)˜Ή
˜2K˜ Kš
œ	˜	K˜NKš
œB˜BKš
œB˜BKš
œ!˜!Kš
œB˜B—Kšœ2žœ˜JK˜Kšžœ˜Kš
œ˜K˜—š œžœ
ž	œožœ)˜Ή
˜2K˜ Kš
œ	˜	K˜NKš
œB˜BKš
œB˜BKš
œ!˜!Kš
œB˜B—Kšœ2žœ˜JK˜Kšžœ˜Kš
œ˜K˜—š œžœ
ž	œožœ)˜Έ
˜2K˜ Kš
œ	˜	K˜MKš
œB˜BKš
œB˜BKš
œ!˜!Kš
œB˜B—Kšœ2žœ˜JK˜Kšžœ˜Kš
œ˜K˜—š œžœ
ž	œLžœ)˜’
š
œ0˜0Kš
œF˜F—š
œ#˜#Kšœžœ%˜9—š
œ&˜&Kš
œ˜Kš
œC˜CKš
œD˜D—Kšœ2žœ
˜DK˜šžœžœ˜!Kšžœ$˜)K˜—šžœžœ˜!Kšžœ$˜)K˜—šžœžœ
žœ*žœ˜JKšžœ˜K˜—Kšžœ˜Kš
œ˜K˜—š 	œžœ
ž	œožœ)˜Ί
˜2K˜ Kš
œ	˜	K˜OKš
œB˜BKš
œB˜BKš
œ!˜!Kš
œB˜B—Kšœ2žœ˜JK˜Kšžœ˜Kš
œ˜K˜—š œžœ
ž	œ
žœ)˜Λ
K™CKš
œ<˜<K˜šžœ&žœ˜.Kšžœ(˜-K˜—šžœžœ˜#Kšžœ$˜)K˜—šžœžœ˜!Kšžœ$˜)K˜—šžœž˜š
œ ˜ šžœž˜ Kš
œ˜Kš
œ˜š
œ ˜ š œž	œ
žœ)˜Λ
Kš
œ<˜<Kš
œF˜Fš
œ4˜4Kšœžœ%˜>—š
œ0˜0š
œ/˜/Kš
œ/˜/——š
œ:˜:š
œ0˜0Kš
œ!˜!——š
œ-˜-Kšœžœ%˜C—K˜šžœžœ
žœ>žœ˜_Kšžœ ˜%K˜—šžœžœ
žœ)žœ˜RKšžœ ˜%K˜—Kš
œ<˜<Kšžœ
˜Kš
œ˜—K˜Kš
œJ˜JK˜—šžœ˜Kšžœ
˜K˜——K˜—š
œ˜š œž	œ
žœ)˜Λ
Kš
œ<˜<Kš
œF˜Fš
œ4˜4Kšœžœ%˜>—š
œ0˜0š
œ/˜/Kš
œ/˜/——š
œ:˜:š
œ0˜0Kš
œ!˜!——š
œ-˜-Kšœžœ%˜C—K˜šžœžœ
žœ>žœ˜_Kšžœ ˜%K˜—šžœžœ
žœ)žœ˜RKšžœ ˜%K˜—Kš
œ<˜<Kšžœ
˜Kš
œ˜—K˜Kš
œJ˜JK˜—š
œ ˜ Kšžœ
˜K˜—š
œ ˜ Kšžœ
˜K˜—Kšžœžœ
˜—Kšžœ
˜K˜K˜——™š
 œžœ
ž	œ5žœžœ˜tK™@Kšœžœžœ
˜%K˜šžœ&žœ˜.Kšžœ(˜-K˜—šžœž˜š
œ ˜ šžœž˜ Kš
œ˜Kš
œ˜š
œ ˜ Kšœžœ
˜K˜—šžœ˜Kšœžœ
˜K˜——K˜—š
œ˜Kšœžœ
˜K˜—š
œ ˜ Kš
œ2˜2K˜šžœž˜ Kš
œ˜š
œ#˜#Kšœžœ
˜K˜—šžœ˜Kšœžœ
˜K˜——K˜—š
œ ˜ Kšœžœ
˜K˜—Kšžœžœ
˜—Kšžœ˜Kš
œ˜K˜—š
œO˜OK™K˜—š
 œžœ
ž	œ4žœžœ˜lJ™9Kšœžœ!˜;K˜šžœ&žœ˜.Kšžœ(˜-K˜—Kšžœ˜K˜J™—š
 œžœ
ž	œ4žœžœ˜jK™HKšœžœžœ
˜!K˜šžœ&žœ˜.Kšžœ(˜-K˜—šžœž˜š
œ ˜ šžœž˜ Kš
œ˜Kš
œ˜š
œ ˜ Kšœžœ
˜K˜—šžœ˜Kšœžœ
˜K˜——K˜—š
œ˜Kšœžœ
˜K˜—š
œ ˜ Kšœžœ
˜K˜—š
œ ˜ Kšœžœ
˜K˜—Kšžœžœ
˜—Kšžœ˜K˜K˜—š
 œžœ
ž	œ4žœžœ˜lK™5Kšœžœžœ
˜#K˜šžœ&žœ˜.Kšžœ(˜-K˜—šžœž˜š
œ ˜ Kšœžœ
˜K˜—š
œ˜Kšœžœ
˜K˜—š
œ ˜ Kšœžœ
˜K˜—š
œ ˜ Kšœžœ
˜K˜—Kšžœžœ
˜—Kšžœ˜K˜K˜—š
 œžœ
ž	œ5žœžœ˜vK™?Kšœžœžœ
˜,K˜šžœ&žœ˜.Kšžœ(˜-K˜—šžœž˜š
œ ˜ šžœž˜ Kš
œ˜Kš
œ˜š
œ ˜ Kšœžœ
˜"K˜—šžœ˜Kšœžœ
˜#K˜——K˜—š
œ˜Kšœžœ
˜#K˜—š
œ ˜ Kšœžœ
˜#K˜—š
œ ˜ Kšœžœ
˜#K˜—Kšžœžœ
˜—Kšžœ˜$K˜K˜—š
 œžœ
ž	œ4žœžœ˜nK™GKšœžœžœ
˜%K˜šžœ&žœ˜.Kšžœ(˜-K˜—šžœž˜š
œ ˜ Kšœžœ
˜K˜—š
œ˜Kšœžœ
˜K˜—š
œ ˜ Kš
œ2˜2K˜šžœž˜ š
œ#˜#Kš
œL˜LK˜—šžœ˜Kšœžœ
˜K˜——K˜—š
œ ˜ Kšœžœ
˜K˜—Kšžœžœ
˜—Kšžœ˜K˜K˜—š
 œžœ
ž	œ4žœžœ˜nK™GKšœžœžœ
˜%K˜šžœ&žœ˜.Kšžœ(˜-K˜—šžœž˜š
œ ˜ Kšœžœ
˜K˜—š
œ˜Kšœžœ
˜K˜—š
œ ˜ Kš
œ2˜2K˜šžœž˜ š
œ#˜#Kš
œO˜OK˜—šžœ˜Kšœžœ
˜K˜——K˜—š
œ ˜ Kšœžœ
˜K˜—Kšžœžœ
˜—Kšžœ˜K˜K˜——™!š 	œžœ
ž	œ4žœ˜uš
œ#˜#šžœž˜Kš
œ@˜@Kš
œ>˜>Kš
œ@˜@Kš
œ@˜@Kšžœžœ
˜——K˜šžœ&žœ˜.Kšžœ(˜-K˜—Kšžœ
˜Kš
œ˜K˜—š œžœ
ž	œ4žœ˜mKšœ%žœ˜;Kš
œ&˜&K˜šžœ&žœ˜.Kšžœ(˜-K˜—Kšžœ˜Kš
œ˜K˜—š 	œžœ
ž	œ4žœ˜uKšœ%žœ˜;š
œ#˜#š
œ'˜'Kš
œ@˜@——K˜šžœ&žœ˜.Kšžœ(˜-K˜—Kšžœ
˜Kš
œ˜K˜—š œžœ
ž	œ4žœ!˜sKšœ/žœ˜EKš
œ1˜1K˜šžœ&žœ˜.Kšžœ(˜-K˜—Kšžœ˜Kš
œ˜K˜—š œžœ
ž	œ4žœ˜oKšœ/žœ˜EKš
œ.˜.K˜šžœ&žœ˜.Kšžœ(˜-K˜—Kšžœ˜
Kš
œ˜K˜—š œžœ
ž	œ4žœ˜sKšœ/žœ˜Eš
œD˜DKš
œ>˜>—K˜šžœ&žœ˜.Kšžœ(˜-K˜—Kšžœ	˜Kš
œ˜K˜—š œžœ
ž	œ4žœ˜sKšœ1žœ˜GKš
œ1˜1K˜šžœ&žœ˜.Kšžœ(˜-K˜—Kšžœ	˜Kš
œ˜K˜—š œžœ
ž	œ4žœ˜qKšœ1žœ˜GKš
œ2˜2K˜šžœ&žœ˜.Kšžœ(˜-K˜—Kšžœ˜Kš
œ˜K˜—š 	œžœ
ž	œ4žœ˜uKšœ1žœ˜Gš
œ#˜#š
œ'˜'Kš
œL˜L——K˜šžœ&žœ˜.Kšžœ(˜-K˜—Kšžœ
˜Kš
œ˜K˜—š œžœ
ž	œ4žœ!˜tKšœ+žœ˜AKš
œ‡
˜‡
K˜šžœ&žœ˜.Kšžœ(˜-K˜—Kšžœ˜
Kš
œ˜K˜š œžœ
ž	œXžœ!˜¨
šœ'žœ
˜+Kšœžœ1˜DKš
œ˜K˜—Kšžœ˜Kš
œ˜—K˜—š œžœ
ž	œ4žœ˜kKšœ+žœ˜AKš
œ&˜&K˜šžœ&žœ˜.Kšžœ(˜-K˜—Kšžœ˜Kš
œ˜K˜—š
 œžœ
ž	œ4žœžœ˜oKšœ+žœ˜AKšœžœ˜,K˜šžœ&žœ˜.Kšžœ(˜-K˜—Kšžœ˜
Kš
œ˜K˜—š œžœ
ž	œ4žœ!˜tKšœ+žœ˜AKš
œ1˜1K˜šžœ&žœ˜.Kšžœ(˜-K˜—Kšžœ˜
Kš
œ˜K˜—š 	œžœ
ž	œ4žœ˜uKšœ1žœ˜Gš
œ#˜#Kš
œI˜I—K˜šžœ&žœ˜.Kšžœ(˜-K˜—Kšžœ
˜Kš
œ˜K˜—š œžœ
ž	œ4žœ˜oKšœ+žœ˜AKš
œ,˜,K˜šžœ&žœ˜.Kšžœ(˜-K˜—Kšžœ˜
Kš
œ˜K˜—š œžœ
ž	œ4žœ˜oKšœ3žœ˜IKš
œ0˜0K˜šžœ&žœ˜.Kšžœ(˜-K˜—Kšžœ˜
Kš
œ˜K˜š œžœ
ž	œžœ ˜fKšœ%žœ
žœ˜3Kšžœ˜K˜—š œžœ
ž	œžœ ˜fKšœ%žœ
žœ˜3Kšžœ˜K˜—K˜—š œžœ
ž	œažœ˜­
š
œ+˜+Kšœžœ
žœ(˜DKš
œ˜—š
œ#˜#šžœI˜KKšžœ˜Kšžœ6˜:Kš
œ{™{——K˜šžœžœ
žœJžœ˜dKšžœ˜Kš
œ˜—Kšžœ
˜Kš
œ˜K˜—š œžœ
ž	œ`žœ˜¬
š
œ+˜+Kšœžœ
žœ(˜DKš
œ˜—š
œ#˜#šžœI˜KKšžœ˜Kšžœ6˜:Kš
œ{™{——K˜šžœžœ
žœJžœ˜dKšžœ˜Kš
œ˜—Kšžœ
˜Kš
œ˜K˜—š œžœ
ž	œMžœ˜”
š
œ!˜!Kšœžœ
žœ-˜D—K˜šžœ
žœžœ?žœ˜TKšžœ˜K˜—Kšžœ	˜Kš
œ˜K˜—š œžœ
ž	œ#žœ ˜lš
œ%˜%Kšœ	žœ
žœ"˜6—K˜šžœ
žœžœ?žœ˜TKšžœ˜K˜—Kšžœ˜Kš
œ˜K˜—š œžœ
ž	œ#žœ ˜lš
œ%˜%Kšœžœžœ
žœ"˜8—K˜šžœ
žœžœ?žœ˜TKšžœ˜K˜—Kšžœ˜Kš
œ˜K˜—š œžœ
ž	œ-žœ˜yšœžœžœ+˜=Kšžœ˜Kšžœ6˜:—Kš
œ*˜*K˜Kšžœ
˜Kš
œ˜K˜—š
 œžœ
ž	œ	žœžœ˜JKšœ'žœ#˜PK˜Kšžœ˜Kš
œ˜K˜—š
 œžœ
ž	œ	žœžœ˜JKšœ$žœžœ#˜RK˜Kšžœ˜Kš
œ˜K˜—š
 œžœ
ž	œ<žœžœ˜fKšœžœ
žœ)˜EK˜šžœžœ
žœ?žœ˜QKšžœ˜K˜—šžœžœ
žœ?žœ˜QKšžœ˜K˜—Kšžœ˜K˜K˜——™!š œžœ
ž	œOžœ)˜–
Kšœ%žœ˜;K˜šžœ&žœ˜.Kšžœ(˜-K˜—Kš
œ˜Kšžœžœ˜Kš
œ˜K˜—š 	œžœ
ž	œWžœ)˜’
Kšœ%žœ˜;K˜šžœ&žœ˜.Kšžœ(˜-K˜—šžœžœ
žœ@žœ˜VKšžœ˜Kš
œ˜—Kš
œL˜LKš
œL˜LKšžœžœ˜Kš
œ˜K˜—š œžœ
ž	œUžœ)˜œ
Kšœ/žœ˜EK˜šžœ&žœ˜.Kšžœ(˜-K˜—Kš
œ˜Kšžœžœ˜ Kš
œ˜K˜—š œžœ
ž	œQžœ)˜™
Kšœ/žœ˜EK˜šžœ&žœ˜.Kšžœ(˜-K˜—Kš
œ˜Kšžœžœ˜ Kš
œ˜K˜—š œžœ
ž	œUžœ)˜Ÿ
Kšœ/žœ˜EK˜šžœ&žœ˜.Kšžœ(˜-K˜—šžœžœ
žœ?žœ˜TKšžœ˜Kš
œ˜—Kš
œM˜MKš
œM˜MKšžœžœ˜ Kš
œ˜K˜—š œžœ
ž	œUžœ)˜Ÿ
Kšœ1žœ˜GK˜šžœ&žœ˜.Kšžœ(˜-K˜—Kš
œ˜Kšžœžœ˜!Kš
œ˜K˜—š œžœ
ž	œSžœ)˜œ
Kšœ1žœ˜GK˜šžœ&žœ˜.Kšžœ(˜-K˜—Kš
œ˜Kšžœžœ˜!Kš
œ˜K˜—š 	œžœ
ž	œWžœ)˜’
Kšœ1žœ˜GK˜šžœ&žœ˜.Kšžœ(˜-K˜—šžœžœ
žœAžœ˜WKšžœ˜Kš
œ˜—Kš
œR˜RKš
œR˜RKšžœžœ˜!Kš
œ˜K˜—š œžœ
ž	œVžœ)˜ž
Kšœ+žœ˜AK˜šžœ&žœ˜.Kšžœ(˜-K˜—Kš
œK˜KKš
œK˜KKšžœžœ˜Kš
œ˜K˜š œžœ
ž	œ(žœ#˜zš
œ+˜+Kšžœžœ$˜9—K˜Kšžœ˜Kš
œ˜K˜—š œžœ
ž	œ(žœ"˜yš
œ+˜+Kšžœžœžœ$˜;—K˜Kšžœ˜Kš
œ˜—K˜—š œžœ
ž	œMžœ)˜“
Kšœ+žœ˜AK˜šžœ&žœ˜.Kšžœ(˜-K˜—Kš
œ˜Kšžœžœ˜Kš
œ˜K˜—š
 œžœ
ž	œKžœžœ)˜™
Kšœ+žœ˜AK˜šžœ&žœ˜.Kšžœ(˜-K˜—Kš
œ˜Kšžœžœ˜Kš
œ˜K˜—š œžœ
ž	œVžœ)˜ž
Kšœ+žœ˜AK˜šžœ&žœ˜.Kšžœ(˜-K˜—Kš
œ˜Kšžœžœ˜Kš
œ˜K˜—š 	œžœ
ž	œWžœ)˜’
Kšœ1žœ˜GK˜šžœ&žœ˜.Kšžœ(˜-K˜—Kš
œN˜NKšžœžœ˜!Kš
œ˜K˜—š œžœ
ž	œQžœ)˜™
Kšœ+žœ˜AK˜šžœ&žœ˜.Kšžœ(˜-K˜—Kš
œ˜Kšžœžœ˜Kš
œ˜K˜—š œžœ
ž	œQžœ)˜™
Kšœ3žœ˜IK˜šžœ&žœ˜.Kšžœ(˜-K˜—Kš
œ˜Kšžœžœ˜"Kš
œ˜K˜š œžœ
ž	œ'žœ˜jKšœžœ
žœ˜/Kšžœ˜
K˜—š œžœ
ž	œ'žœ˜jKšœžœ
žœ˜/Kšžœ˜
K˜K˜——š œžœ
ž	œ%žœ#˜uJš
œm™mKšœ
žœžœ	˜$š
œ+˜+Kšœ	žœ(˜4—K˜šžœžœ
žœAžœ˜WKšžœ˜K˜—Kšžœ˜K˜K˜š œžœ
ž	œ$žœ%˜xš
œ+˜+Kš
œ7˜7—š
œ/˜/Kšœžœ
žœ'˜@—K˜šžœžœ
žœAžœ˜WKšžœ˜K˜—Kšžœ˜Kš
œ˜K˜—š œžœ
ž	œ$žœ%˜xš
œ+˜+Kš
œ7˜7—š
œ/˜/Kšœžœžœ
žœ'˜B—K˜Kšžœ˜Kš
œ˜—K˜—š œžœ
ž	œ%žœ#˜uJš
œm™mKšœ
žœžœ	˜$š
œ+˜+Kšœ	žœ(˜4—K˜šžœžœ
žœAžœ˜WKšžœ˜K˜—Kšžœ˜K˜K˜š œžœ
ž	œ$žœ%˜xš
œ+˜+Kš
œ7˜7—š
œ/˜/Kšœžœ
žœ'˜@—K˜Kšžœ˜Kš
œ˜K˜—š œžœ
ž	œ$žœ%˜xš
œ+˜+Kš
œ7˜7—š
œ/˜/Kšœžœžœ
žœ'˜B—K˜Kšžœ˜Kš
œ˜K˜—š œžœ
ž	œ"žœ%˜uš
œ/˜/Kšœ	žœ
žœ'˜;—K˜Kšžœ˜Kš
œ˜K˜—š œžœ
ž	œ"žœ%˜uš
œ/˜/Kšœžœžœ
žœ'˜=—K˜Kšžœ˜Kš
œ˜—K˜—š œžœ
ž	œ%žœ#˜uKšœžœ
˜š
œ+˜+šžœ˜Kšžœ˜Kšžœ/˜3——K˜Kšžœ˜K˜K˜——™š
 œžœ
ž	œ,žœžœ˜eK™/Kšœžœ0˜KK˜Kšžœ˜Kš
œ˜K™—š œžœ
ž	œ\žœ%˜Ά
š
œ,˜,Kš
œG˜G—š
œ(˜(š
œ+˜+Kš
œ4˜4——Kš
œu˜uK˜šžœžœ˜&Kšžœ$˜)K˜—Kšžœ˜Kš
œ˜K˜—š œžœ
ž	œPžœ&˜­
š
œ)˜)Kš
œD˜D—š
œ*˜*Kš
œE˜E—š
œ0˜0š
œ-˜-Kš
œ&˜&——K˜šžœžœ˜#Kšžœ$˜)K˜—šžœžœ˜$Kšžœ$˜)K˜—Kšžœ˜Kš
œ˜K˜—š
 œžœ
ž	œ5žœžœ˜rK™3šœžœ˜"Kš
œ5˜5—K˜Kšžœ˜ Kš
œ˜K™—š
 œžœ
ž	œ'žœ$žœ˜
K™4š
œ'˜'Kš
œB˜B—š
œ.˜.Kš
œ1˜1—š
œ7˜7Kš
œJ˜J—K˜šžœžœ˜!Kšžœ$˜)K˜—Kšžœ˜Kš
œ˜K˜—š œžœ
ž	œ'žœ%˜y™.K™J—š
œ'˜'Kš
œB˜B—š
œ.˜.Kš
œ1˜1—š
œ7˜7Kš
œJ˜J—K˜šžœžœ˜!Kšžœ$˜)K˜—Kšžœ˜K˜K˜—š œžœ
ž	œ)žœ%˜„
Kšœ/žœ
˜AK˜šžœ#žœ˜+Kšžœ$˜)K˜—Kšžœ˜K˜K˜—š œžœ
ž	œ2žœ!˜‰
Kšœ&žœ˜=K˜šžœ#žœ˜+Kšžœ$˜)K˜—Kšžœ˜K˜K˜—š œžœ
ž	œ*žœ&˜ˆ
Kšœ1žœ˜DK˜Kšžœ˜Kš
œ˜K˜—š œžœ
ž	œ.žœ"˜ˆ
Kšœ.žœ˜AK˜Kšžœ˜Kš
œ˜K˜—š %œžœ
ž	œ0žœ)˜—
Kšœ7žœ˜MK˜šžœ+žœ˜3Kšžœ(˜-K˜—Kšžœ˜Kš
œ˜K˜—š %œžœ
ž	œ4žœ%˜—
Kšœ4žœ˜JK˜šžœ&žœ˜.Kšžœ(˜-K˜—Kšžœ˜Kš
œ˜K˜—š )œžœ
ž	œ4žœ&˜œ
Kšœ6žœ˜NK˜šžœž˜Kš
œ˜Kš
œ	˜	Kš
œ˜Kš
œ˜Kš
œ˜š
œ˜Kšžœ
˜Kš
œ˜—šžœ˜Kšžœ˜Kš
œ˜——Kšžœ˜Kš
œ˜K˜—š )œžœ
ž	œ3žœ'˜œ
Kšœ8žœ˜PK˜šžœž˜Kš
œ˜Kš
œ	˜	Kš
œ˜Kš
œ˜Kš
œ˜š
œ˜Kšžœ
˜Kš
œ˜—šžœ˜Kšžœ˜Kš
œ˜——Kšžœ˜Kš
œ˜K˜——™š œžœ
žœžœ
˜"K™;K™—š 	œžœ
žœžœ
˜K™IK™—š œžœ
žœžœ
˜&K™>K™—š œžœ
žœžœ
˜*K™8K™——L˜K™——…—¬HήJ