/* Header file for BCPL code-generator for ARM.
   HCM	 07 Feb 86 12:03:29
*/

GET "Libhdr"

GET "b.Ops"

MANIFEST {
   VersionMark		= #x4e524556;

   CGMajorVersion = 2;
   CGMinorVersion = 18 }

MANIFEST {
   TargetWordSize = 32 }

MANIFEST {
   // Format 1 opcodes
   f.add = #x0800000; f.sub = #x0400000; f.rsb = #x0600000;
   f.adc = #x0a00000; f.sbc = #x0c00000; f.rsc = #x0e00000;
   f.and = #x0000000; f.eor = #x0200000; f.orr = #x1800000; f.bic = #x1c00000;
   f.cmp = #x1400000; f.cmn = #x1600000; f.teq = #x1200000; f.tst = #x1000000;
   f.subs= #x0500000;
   f.cmps= #x1500000; f.cmns= #x1700000; f.teqs= #x1300000; f.tsts= #x1100000;
   f.mov = #x1a00000; f.mvn = #x1e00000;
   f.movs= #x1b00000;
   f.cond= #x0100000;

   // Format 2
   f.ldr = #x04100000; f.str = #x04000000;
   f.ldrb= #x04500000; f.strb= #x04400000;
   f.ld  = #x00100000; f.st  = #x00000000;

   // Format 4
   f.ldm = #x08100000; f.stm = #x08000000;
   f.pc  = #x00400000;

   // The following are valid for both format 3 and 4
   f.pre = #x01000000; f.post = #x00000000; f.wb   = #x00200000;
   f.up  = #x00800000; f.down = #x00000000;

   f.preup   = f.pre+f.up;  f.postup   = f.post+f.up;
   f.predown = f.pre+f.down; f.postdown = f.post+f.down;

   // and this is valid for formats 1 and 2
   f.addrisr = #x02000000; f.addrisk = #x00000000;

   // Format 5
   f.b	 = #x0a000000; f.bl  = #x0b000000;

   // format 4 register combinations
   f4.pblpc = #x9500; f4.pbl14 = #x5500;
   f4.pl = #x1400; f4.pl14 = #x5400;
   f4.plpc = #x9400;

   f.mul = #x0000000; f.mla = #x0200000;

   f2.max.offset = #xfff }

MANIFEST {
   // Register values
   r.0	= 0;
   r.a1 = 1;  r.a2 = 2;  r.a3 = 3;  r.a4 = 4;
   r.w1 = 5;
   r.nilbase = 6; r.gb = 7;
   r.g = 9; r.p = 10; r.ts = 11;
   r.l = 12; r.b = 8;
   r.nil = 13;
   r.14 = 14;
   r.pc = 15 }

MANIFEST {
   // condition mask values
   m.eq     = #x00000000; m.ne	   = #x10000000;
   m.geu    = #x20000000; m.ltu    = #x30000000;
   m.mi     = #x40000000; m.pl	   = #x50000000;
   m.vs     = #x60000000; m.vc	   = #x70000000;
   m.gtu    = #x80000000; m.leu    = #x90000000;
   m.ge     = #xa0000000; m.lt	   = #xb0000000;
   m.gt     = #xc0000000; m.le	   = #xd0000000;
   m.always = #xe0000000; m.never  = #xf0000000 }

MANIFEST {
   // shift types
   sh.asl = #x00; sh.lsr = #x20; sh.asr = #x40; sh.ror = #x60;
   sh.lsl = #x00 }

MANIFEST {
   // library entry points (relative to r.gb)
   sr.multiply	 = #x04;
   sr.quotrem	 = #x34;
   sr.entrycount = #xa0;
   sr.count	 = #xbc;
   sr.exit	 = #xcc;
   sr.fin	 = #x00 }

MANIFEST {
   k4 = 4096;

   RegSize = 6;

   SSSize = 5; TempSize = 40*SSSize;

   Null = -1;

   k.number = 1;
   k.loc = 2; k.glob = 3; k.static = 4; k.lab = 5;
   k.lvloc = 6; k.lvglob = 7; k.lvstatic = 8; k.lvlab = 9;
   k.reg = 10; k.freg = 11;
   k.lvsloc = 12; k.lvsglob = 13; k.lvsstatic = 14; k.lvslab = 15;
   k.lvs = 6;
   k.ireg = 16;   // used only in pending loads/ stores
   k.shreg = 17;  // representation of pending shift

   rtype = 1; lockedrtype = 2;
   atype = 3;
   shiftedrtype = 4;
   ktype = 5;
   lvstype = 6;

   // selector classification
   ByteField = 0; LByteField = 1; GenField = 2;

   // used in marking deferred CAR/CDRs
   CarMark = #x4000; VACarMark = #x4001;

   // Label vector vector data
   LabelBlockSize = 128
   LabelBlockShift = 7
   LabelBlockMask = 127

   LabelBlockVSize = 128

   last.label.number =	(LabelBlockVSize * LabelBlockSize) / 2

   // Relocatable binary types

   t.hunk = 1000; t.end = 1002

   DataBlockSize = 16;
   NextBlock = 0; EndOfDataInBlock = 1; DataBlockItems = 2;

   // structure of label references
   NextRef = 0; RefType = 1; RefLoc = 2;
   RefSize = 3;

   sl.type = 1; sl.loc = 2;
   sl.size = 3;

   // Structure of pending store item
   ps.reg = 3; ps.istos = 5;
   pl.offset = 4;
   ps.size = 6;

   // flag bits in label entries
   lab.set	   = #x80000000;

   lab.defined	   = #x40000000;      // these bits for code labels
   lab.forwardjump = #x20000000;
   lab.onlyonejump = #x10000000;
   lab.frameneeded = #x08000000;      // marks procedures which need a
				      // stack frame (contain calls or
				      // reference statics).
   lab.prochascalls= #x04000000;
   lab.jumpedto    = #x02000000;
   lab.called	   = #x01000000;
   lab.endproclab  = #x00800000;
   lab.procstatics = #x00400000;
   lab.procorlabel = #x00200000;

   lab.lvtaken	   = #x00100000;      // and these for data labels
   lab.stored	   = #x00080000;
   lab.lvptaken    = #x00040000;      // marks procedures whose local
				      // variables may be destroyed by
				      // indirect assignment.

   lab.value	   = #x0003ffff;
   lab.area	   = #x00000003;

   // values for deadCode
   Alive = 0;
   Dead = 1;

   // Error action values
   HardError = FALSE;
   FatalError = TRUE;
   OnlyWarning = 1;

   // bits in CGDebugMode
   db.traceps = 1; db.tracescan = 2; db.tracepw = 4; db.srs = 8;
   db.tlabs = #x10; db.shuffle = #x20;
   db.cs = #x40;
   db.poc = #x80;
   db.regs =#x100;
   db.mult = #x200;
   db.mapstore = #x8000;

   // bits in CGOptMode
   op.shuffle = 1;
   op.strings = 2;

   s.itemx = 255 }

MANIFEST {  // stuff to do with AOF
   SADefined = #x01;
   SAGlobal = #x02;
   SAAbs = #x04;
   SACaseInsensitive = #x08;

   RelByte = #x00000;
   RelHalf = #x10000;
   RelWord = #x20000;
   RelPCRel = #x40000;
   RelSymbol = #x80000 };

MANIFEST {
   // Constants for compiled code organisation
   MaxStaticFrame = 10	  // excluding overhead
}

MANIFEST {
			// cgv 370
   cgm = cgv+100;	// 470
   cga = cgm+20;	// 490
   cgb = cga+15;	// 505
   cgc = cgb+15;	// 520
   cgd = cgc+25;	// 565
   cge = cgd+25;	// 570
   cgf = cge+40;	// 610
   cgg = cgf+30;	// 640
   cgh = cgg+20;	// 660
   cgi = cgh+65;	// 725
   cgj = cgi+20;	// 745
   cgk = cgj+40 	// 785
}

GLOBAL {
   HostProcessor: 2 }

GLOBAL {
   // variables
   lineCounts: cgv+0;

   reversedStack: cgv+6;
   upStack: cgv+7;  // LDM/STM argument
   nextStackWord: cgv+8  // 4 or -4, depending on stack direction

   tempv: cgv+10; tempt: cgv+11;
   arg1: cgv+12; arg2: cgv+13;
   ssp: cgv+14; TOSoffset: cgv+15;

   ps.tracedepth: cgv+16;

   staticOffset: cgv+19;
   linkageNotStored: cgv+20;
   staticDataSize: cgv+21;

   deadCode: cgv+22; locCtr: cgv+23;
   storeBlockV: cgv+24;
   labelblockV: cgv+25;
   maxGN: cgv+26;

   procLabel: cgv+27; blockLabel: cgv+28;
   pendingJump: cgv+30;
   sectionName: cgv+31;
   op: cgv+32;
   countFlag: cgv+34; countLabel: cgv+35;

   lineCount: cgv+37;
   base: cgv+38; baselab: cgv+39; baseaddr: cgv+40;
   namel: cgv+41; namet: cgv+42;

   SdataList: cgv+43; SdataP: cgv+44; SLab: cgv+45; SAddr: cgv+46;
   FdataList: cgv+47; FdataP: cgv+48; Flab: cgv+49; Faddr: cgv+50;
   DataList: cgv+51; DataP: cgv+52;

   endSectLabel: cgv+53;
   callLab: cgv+54; exitCallLab: cgv+55;

   pendingLab: cgv+57; pendingMask: cgv+58;

   pendingLoads: cgv+59; pendingStores: cgv+60;

   R0Offset: cgv+61;

   multLab: cgv+63; quotLab: cgv+64;

   staticLabels: cgv+69; dataLabel: cgv+70;

   savedStates: cgv+71;
   argumentNumber: cgv+72;

   transferLabs: cgv+73;
   ocptrw: cgv+75; ocodebufw: cgv+76;

   exitLab: cgv+77; staticDataLab: cgv+78;
   usesFrame: cgv+79; containsCalls: cgv+80; localsSafe: cgv+81;

   localConstants: cgv+82; localConstP: cgv+83;
   localConstLab: cgv+84; localFaddr: cgv+85;
   freeDataBlocks: cgv+86;
   dedicatedRegisters: cgv+87;

   usesRL: cgv+89; RLLoadList: cgv+90;

   xrefsyms: cgv+98;
   loadRegFromFRegOK: cgv+99 }

GLOBAL {
// CGM
   ReadOp: cgm+1; ReadN: cgm+2; ReadGN: cgm+3; ReadL: cgm+4;
   PeekN: cgm+8;
   NextLabel: cgm+5;
   CGError: cgm+6;
   WriteBytes: cgm+9;
   ReadString: cgm+19 }

GLOBAL {
// CGA
   Scan: cga+0;
   IgnoreNames: cga+1; DiscardN: cga+2
   LabelInStatic: cga+3; OffsetOfStatic: cga+4;
   GenStore: cga+5;
   CGDebug: cga+6;
   XSymInStatic: cga+7 }

GLOBAL {
// CGB
   CGSwitch: cgb+0;
   CGEntry: cgb+1; CGSave: cgb+2; CGApply: cgb+3;
   CheckRLLoaded: cgb+4 }

GLOBAL {
// CGC
   CGStCar: cgc+0;
   CGStind: cgc+1; CGAssOp: cgc+2;
   CGRelop: cgc+3; CGLogop: cgc+4; CGShift: cgc+5;
   CGSlctSt: cgc+6; CGByteAp: cgc+7;
   Condition: cgc+8; ComplementCondition: cgc+9 }

GLOBAL {
// CGD
   InitialiseDisassembler: cgd+0;
   TerminateDisassembler: cgd+1;
   RotateRight: cgd+2
   PrintInstruction: cgd+3;
   StartComment: cgd+4 }

GLOBAL {
// CGE
   F1Inst: cge+0; F2Inst: cge+1; F4Inst: cge+2; F5Inst: cge+3;
   GenF1K: cge+4; GenRR: cge+5; GenF2: cge+6;
   SetRtoRplusK: cge+7; SetRtoRplusLplusK: cge+8; SetRtoK: cge+9;
   EightBitsOrFewer: cge+10;
   ShiftRegister: cge+11; ShiftRegisterDS: cge+12;
   MaskOutTagBits: cge+13;
   Jump: cge+14; CondJump: cge+15; F5InstL: cge+16;
   CheckDelayedJump: cge+17;
   GenF: cge+18; GenFDS: cge+19;
   InsertCount: cge+20;
   LogBase2: cge+21;
   CallSub: cge+22;
   GlobalConstant: cge+23;
   PackUp: cge+24;
   FlushPendingInsts: cge+25;
   TransferredLabel: cge+26;
   InitPendingInsts: cge+27;
   SetRToRPlusKM: cge+29; GenF2M: cge+30;
   CompareAgainstK: cge+31;
   F5InstX: cge+32;
   MultiplyInst: cge+33 }

GLOBAL {
// CGF
   PutWord: cgf+0; PutString: cgf+1;
   AddRef: cgf+2; SetLabel: cgf+3; ValueOfLabel: cgf+4;
   AddressInCode: cgf+5;
   CGString: cgf+6;
   InitDataLists: cgf+7;
   data: cgf+8;
   sdata: cgf+9; fdata: cgf+10;
   OutputSection: cgf+11;
   CGGlobal: cgf+12; CGEnd: cgf+13;
   LabelWithValue: cgf+14; FindLabelEntry: cgf+15;
   LabelFlagged: cgf+16; FlagLabel: cgf+17;
   GenData: cgf+18;
   GetDataBlock: cgf+19;
   AddRelocatedLoc: cgf+20;
   RealSetLabel: cgf+21;
   AddXSymbol: cgf+22; AddXRelocatedLoc: cgf+23;
   InternString: cgf+24;
   PrintSizes: cgf+25;
   RelocationForLoc: cgf+26; SymbolOfReloc: cgf+27 }

GLOBAL {
// CGG
   FreeReg: cgg+0; MovetoR: cgg+1; MoveToRSomeTime: cgg+2
   CompileDS: cgg+4
   TypeOfField: cgg+5;
   GenOpToStore: cgg+6;
   CGVecap: cgg+7; CGVecSt: cgg+8;
   LoadArg3ToSomeCR: cgg+9 }

GLOBAL {
// CGH
   DiscardRegs: cgh+0; DiscardReg: cgh+1;
   DiscardNonConstRegs: cgh+2; DiscardNonLocalRegs: cgh+3;
   LoadAddress: cgh+4; LoadCarAdd: cgh+5;
   MoveStoR: cgh+6; MoveRtoR: cgh+7; StoreR: cgh+8;
   DiscardAddress: cgh+9;
   LookFor: cgh+10;
   NotAddr: cgh+11; ShiftedUp: cgh+12; IsaCar: cgh+13;
   Lock: cgh+14; Unlock: cgh+15; Locked: cgh+16;
   MoveToAnyR: cgh+17; MoveToAnyRSomeTime: cgh+18;
   MoveToAnyCR: cgh+19; MoveToAnyCRSomeTime: cgh+20;
   Using: cgh+21;
   NextR: cgh+22;
   Lose: cgh+23; InitStack: cgh+24; Load: cgh+25;
   Stack: cgh+26; Store: cgh+27; StoreT: cgh+28;
   Class: cgh+29;
   IsConst: cgh+30;
   PrintRegList: cgh+31; PrintSimulatedStack: cgh+32;
   IsSimpleStoreLoc: cgh+33;
   IsInaRegister: cgh+34;
   SaveRegisterState: cgh+35; RestoreRegisterState: cgh+36;
   IntersectionOfRegisterStates: cgh+37;
   FindSavedState: cgh+38; SaveStateForLab: cgh+39;
   PrintRegisterState: cgh+40;
   IsInTheStack: cgh+41;
   ArgumentRegister: cgh+42
   MoveToAnyCRForStoreTo: cgh+43; MoveToAnyCRSomeTimeForStoreTo: cgh+44;
   AddRegInfo: cgh+45;
   LookForSloc: cgh+46;
   LookForRegContainingType: cgh+47;
   LocInRegister: cgh+48;
   TurnIndIntoSLoc: cgh+49;
   SwapSS: cgh+50;
   RemoveFalseIndirection: cgh+51;
   LoseR: cgh+52;
   SSEntry: cgh+53;
   InitialiseRegisterSlave: cgh+54;
   LookForFR: cgh+55;
   HasSlavedLoc: cgh+56 }

GLOBAL {
// CGI
   CGMult: cgi+0; CGDiv: cgi+1; CGRem: cgi+2;
   CGMinus: cgi+3; CGPlus: cgi+4;
   FindSourceAndDestinationRegisters: cgi+5 }

GLOBAL {
// CGJ
   LastInList: cgj+0; ReverseInPlace: cgj+1; Assoc: cgj+2
   PrintList: cgj+3; Nth: cgj+4;
   DeleteFromList: cgj+5; LengthOfList: cgj+6
   CopyOfList: cgj+7;

   AddToPendingStores: cgj+8; FlushPendingStores: cgj+9;
   FlushPendingStoresUpTo: cgj+10; FlushPendingUsesOfReg: cgj+11;
   DelRegFromPendingList: cgj+12; DelSlocFromPendingList: cgj+13;
   RegInPendingList: cgj+14; SlocInList: cgj+15;
   PrintPendingList: cgj+16;
   DelLocsAbove: cgj+17; DelLocsExcept: cgj+18;

   AddToPendingLoads: cgj+20;
   FlushPendingLoadsForReg:cgj+21; FlushPendingLoadsForSloc: cgj+22;
   FlushPendingLoads: cgj+23; FlushPendingLoadsUpTo: cgj+24;

   DedicateRegisterToLoc: cgj+25; RegisterDedicatedToLoc: cgj+26;
   LocHeldInRegister: cgj+27; ClearAssignedRegisters: cgj+28;

   FlushPendingLoadsExceptLocals: cgj+29;
   FlushPendingStoresExceptLocals: cgj+30;
   FlushPendingStoresExceptLocalsAndIregs: cgj+31;
   FlushPendingStoresForSloc: cgj+32

   DeleteList: cgj+33; InsertInListBefore: cgj+34;
   OffsetInList: cgj+35 }

GLOBAL {
// CGK
   CGFloat: cgk+0; CGFix: cgk+1;
   CGFop: cgk+2; CGFUnop: cgk+3; CGFCompare: cgk+4;
   MoveToAnyFR: cgk+5;
   GenCPDT: cgk+6;

   MoveFRtoR: cgk+7; StoreFR: cgk+8;
   PackFPNum: cgk+9;
   NextFR: cgk+10;
   MoveRtoFR: cgk+11 }
