Home » Archimedes archive » Zipped Apps » BCPL » BCPL/b/cgc

BCPL/b/cgc

This website contains an archive of files for the Acorn Electron, BBC Micro, Acorn Archimedes, Commodore 16 and Commodore 64 computers, which Dominic Ford has rescued from his private collection of floppy disks and cassettes.

Some of these files were originally commercial releases in the 1980s and 1990s, but they are now widely available online. I assume that copyright over them is no longer being asserted. If you own the copyright and would like files to be removed, please contact me.

Tape/disk: Home » Archimedes archive » Zipped Apps » BCPL
Filename: BCPL/b/cgc
Read OK: ✔
File size: 4514 bytes
Load address: 0000
Exec address: 0000
File contents
SECTION "CGC"

GET "b.CGheader"

STATIC {
   // Version of 14 Apr 86 14:00:11
   dummy = VersionMark;
   version = 1*256+19 };

/* 1.6	01 Nov 85 13:12:03
      Recognise that after  CMP .., #0; BNE .. a register contains 0
      Bug fix: x op:= .. must flush pending stores for x
   1.7	 04 Nov 85 15:24:43
      Load of register for indirect store may be deferred
   1.8	 14 Jan 86 15:56:12
      Bug fix: Lock base register in op:=
   1.9	 30 Jan 86 11:14:35
      Bug fix: CGRelopX not to leave a register marked as containing 0
      if it hasn't compiled a compare.
   1.10  06 Feb 86 17:10:10
      Incorporation of floating point (not in op:= though)
   1.11  18 Feb 86 11:19:54
      Byte selectors mended to get the right byte, not 3- it.
      Storing of non-constant to general field corrected.
   1.12  25 Feb 86 12:33:01
      Improvement of code for field update where there is no indirection
   1.13  26 Feb 86 11:41:46
      Improvement of code for stind & op:=
   1.14
      Bug fix: SlctSt did not check for indirection before considering
      the type of the selected thing.
   1.15  06 Mar 86 12:57:32
     CGSlctSt did not lock its base.
   1.16  07 Mar 86 21:30:10
     k.static
   1.17  16 Mar 86 22:36:16
     Improvements in coding of Condition (field : constant) and
     Field update (value also a field).
   1.18  21 Mar 86 11:08:57
     Deferred shifts
   1.19  14 Apr 86 13:59:28
     Stind with locals safe etc need not force the stored register to be
     loaded
*/

STATIC {
   regTestedAgainstZero = 0 }

MANIFEST {
   k.isafr = 256 };

LET CGStind() BE {
   LET r = h1!arg2=k.freg ->
	     MoveToAnyFR(arg2)+k.isafr,
	     MoveToAnyCRSomeTimeForStoreTo(arg2, ShiftedUp, arg1);
   StindOrAssOp(-1, r) }

AND CGAssOp() BE {
   LET r = -1;
   LET f = ?;
   op := ReadOp();
   f := VALOF SWITCHON op INTO {
      CASE s.plus:  RESULTIS CGPlus
      CASE s.minus: RESULTIS CGMinus
      CASE s.mult:  r := ArgumentRegister(1); RESULTIS CGMult
      CASE s.div:   r := ArgumentRegister(1); RESULTIS CGDiv
      CASE s.rem:   r := ArgumentRegister(1); RESULTIS CGRem
      CASE s.logand:
      CASE s.logor:
      CASE s.eqv:
      CASE s.neqv:  RESULTIS CGLogop
      CASE s.fplus:
      CASE s.fminus:
      CASE s.fmult:
      CASE s.fdiv:  RESULTIS CGFop };
   StindOrAssOp(f, r) }

AND StindOrAssOp(x, r) BE {
   LET s, m, a = 0, 0, 0;
   LET t, ind, n, k = h1!arg1, h2!arg1, h3!arg1, 4*h4!arg1;
   LET simpleSLoc = FALSE;
   LET ss = ssp-2;

   IF k.isafr>r>=0 THEN Lock(r, k.reg);

   TEST (k.lvloc<=t<=k.lvlab) & ind<0 THEN
      TEST t=k.lvlab THEN {
	 s := CheckRLLoaded()
	 m, a := n, k }
      ELSE {
	 t, n := t-k.lvloc+k.loc, n+k/4;
	 h1!arg1, h2!arg1, h3!arg1, h4!arg1 := t, -1, n, 0;
	 simpleSLoc := TRUE }

   ELSE TEST ind<0 & TurnIndIntoSLoc(arg1) THEN {
      t, n := h1!arg1, h3!arg1;
      simpleSLoc := TRUE }

   ELSE {
      TEST ind<0 & t~=k.shreg THEN {
	 a := k; h4!arg1 := 0 }
      ELSE
	 MoveToAnyR(arg1);
      s := LoadAddress(arg1);
      Lock(s, k.reg);
      TEST localsSafe THEN {
	 FlushPendingLoadsExceptLocals();
	 FlushPendingStoresExceptLocalsAndIregs() }
      ELSE {
	 FlushPendingLoads();
	 FlushPendingStores() } };

   TEST x>=0 THEN {
      IF ~simpleSLoc THEN
	 TEST x=CGFop THEN {
	    r := NextFR();
	    GenCPDT(f.ld, r, s, m, a);
	    Stack(ssp-1);
	    Load(k.freg, r) }
	 ELSE {
	    TEST r<0 THEN
	       r := NextR()
	    ELSE
	       FreeReg(r);
	    GenOpToStore(f.ldr, r, s, m, a);
	    FlushPendingLoadsForReg(r);
	    Stack(ssp-1);
	    Load(k.reg, r) };

      SwapSS(arg1, arg2);
      x(op, FALSE);
      r := h3!arg1 }

   ELSE Stack(ssp-1);

   TEST simpleSLoc THEN {
      LET rt = h1!arg1;
      GenStore(t, n);
      IF rt=k.reg & r<k.isafr THEN Unlock(r, k.reg) }
   ELSE TEST x=CGFop | r>=k.isafr THEN
      GenCPDT(f.st, r&15, s, m, a)
   ELSE TEST localsSafe & t=k.loc & ind<0 THEN {
      MoveToRSomeTime(r, arg1);
      AddToPendingStores(r, k.ireg, s, FALSE, a/4) }
   ELSE {
      MoveToR(r, arg1);
      GenF2(f.str, r, s, m, a) };

   Unlock(s, k.reg);
   IF ~simpleSLoc THEN {
      TEST LocalsSafe THEN
	 DiscardNonLocalRegs()
      ELSE
	 DiscardNonConstRegs();
      Stack(ss) } }

AND CgStcar(n, vacar) BE {
   LET ind, k = h2!arg1, h4!arg1;
   LET r = ?;
   LET s = 0;
   TEST h1!arg2=k.freg THEN
      r := MoveToAnyFR(arg2)+k.isafr
   ELSE {
      r := MoveToAnyCRSomeTime(arg2);
      Lock(r, k.reg) };
   TEST ind<0 & h1!arg1~=k.shreg THEN
      n, h4!arg1 := n+k, 0
   ELSE
      MoveToAnyR(arg1);

   s := (vacar -> MoveToAnyCR(arg1),
		  LoadCarAdd(arg1));
   TEST r>=k.isafr THEN {
      FlushPendingLoadsExceptLocals();
      FlushPendingStoresExceptLocalsAndIregs();
      GenCPDT(f.st, r&15, s, 0, n/BytesPerWord) }
   ELSE {
      AddToPendingStores(r, k.ireg, s, FALSE, n/BytesPerWord);
      UnLock(r, k.reg) };
   Stack(ssp-2) }

AND CGShift(sh) BE
   TEST h2!arg2<0 & (k.lvloc<=h1!arg2<=k.lvlab) &
	IsConst(arg1) & h3!arg1=2 & sh=sh.asl THEN {
      h1!arg2 := h1!arg2+k.lvs;
      h4!arg2 := (h4!arg2)<<2;
      Stack(ssp-1) }
   ELSE {
      LET s = ?;
      LET deferredShift = Null;
      LET r = FindSourceAndDestinationRegisters(@s, arg2, FALSE);
      TEST IsConst(arg1) THEN
	 TEST s=r THEN
	    deferredShift := sh*32+h3!arg1
	 ELSE
	    ShiftRegisterDS(r, s, sh, h3!arg1)
      ELSE
	 ShiftRegisterDS(r, s, sh, -MoveToAnyCR(arg1));

      Unlock(s, k.reg);
      LoseR(r, deferredShift) }

AND CGLogop(logop, readAhead) BE {
   LET x, y = arg1, arg2;
   IF Class(arg1, TRUE)<Class(arg2, TRUE) THEN x, y := arg2, arg1;
   {  LET s = IsInARegister(y);
      LET r = -1;
      LET nextOperand = ?;
      LET iscf, lnpending = FALSE, FALSE;
      LET f = VALOF SWITCHON logop INTO {
	 CASE s.logand: RESULTIS f.and
	 CASE s.logor:	RESULTIS f.orr
	 CASE s.eqv:
	 CASE s.neqv:	RESULTIS f.eor };

      IF readAhead THEN {
	 op := ReadOp();
	 TEST op=s.ln THEN {
	    lnpending := TRUE;
	    nextOperand := ReadN();
	    op := ReadOp();

	    IF nextOperand=0 &
	       (op=s.eq | op=s.ne) &
	       (logop=s.logand | logop=s.neqv)
	       THEN iscf := TRUE }

	 ELSE IF op=s.res | op=s.fnrn THEN
	    r := 1 };

      TEST s=Null |
	   (~Locked(s, k.reg) & [(h1!y=k.loc & h3!y>=ssp-2) |
			 /* an heuristic to avoid consuming registers
			    over-rapidly */
			  h1!y=k.reg]) THEN {
	 s := MoveToAnyR(y);
	 IF ~iscf & r<0 THEN r := s }
      ELSE {
	 FlushPendingLoadsForReg(s);
	 Lock(s, k.reg);
	 IF ~iscf & r<0 THEN r := NextR() };

      TEST iscf THEN {
	 TEST logop=s.logand THEN
	    f, r := f.tsts, 0
	 ELSE
	    f, r := f.teqs, 0
	 IF (pendingMask ~= m.always) THEN {
	    Store(0, ssp-4);
	    FlushPendingStores()
	 }
      } ELSE {
	 FlushPendingUsesOfReg(r);
	 IF f=f.and & IsConst(x) & EightBitsOrFewer(~h3!x) THEN {
	    f := f.bic; h3!x := ~h3!x } };

      GenFDS(f, r, s, x);
      IF logop=s.eqv THEN GenRR(f.mvn, r, 0, r)
      Unlock(s, k.reg);
      TEST r~=0 THEN
	 Lose(r, k.reg)
      ELSE
	 Stack(ssp-1);

      IF lnpending THEN Load(k.number, nextOperand);
      IF iscf THEN CGRelopX(op, ReadOp(), FALSE) } }

AND CGRelop(relop, nextop) BE
   CGRelopX(relop, nextop, TRUE)

AND CGRelopX(relop, nextop, compneeded) BE {
   op := nextop;
   TEST op=s.jt | op=s.jf THEN {
      LET c = ?;
      LET l = ReadL();
      LET x = TransferredLabel(l);

      TEST x~=0 THEN {
	 Store(0, ssp-3);
	 FlushPendingStores() }
      ELSE
	 FlushPendingStoresExceptLocals();

      c := ConditionX(relop, op=s.jt, compneeded);
      SaveStateForLab(l);
//    IF x~=0 THEN DelLocsAbove(0, FALSE);
      CondJump(c, l);
      IF regTestedAgainstZero~=Null & c=m.ne & compneeded THEN
	 AddRegInfo(k.reg, regTestedAgainstZero, k.number, 0);
      countFlag := counting;
      op := ReadOp() }
   ELSE {
      LET r = NextR();
      Lock(r, k.reg);
      IF pendingLab~=Null THEN
	 FlushPendingInsts(Null, FALSE);
      GenF1K(f.mov, r, 0, 0);
      F1Inst(f.mvn, r, 0, r, 0, Null, 0,
	     conditionX(relop, TRUE, compneeded));
      Load(k.reg, r);
      UnLock(r, k.reg) } }

AND Condition(relop, b) = ConditionX(relop, b, TRUE)

AND ConditionX(relop, b, compneeded) = VALOF {
   LET x, y = arg1, arg2;
   LET k, mergek = 0, FALSE;
   LET f = f.cmps;

   IF compneeded THEN {
      LET i1, i2 = h2!arg1, h2!arg2;
      IF i1<0 & h4!arg1~=0 & h1!arg1~=k.shreg &
	 i2<0 & h4!arg2~=0 & h1!arg2~=k.shreg THEN {
	 k := h4!arg1-h4!arg2;
	 h4!arg1, h4!arg2 := 0, 0;
	 mergek := TRUE };

      IF Class(arg1, TRUE)<Class(arg2, TRUE) THEN {
	 x, y := arg2, arg1;
	 relop := Reverse(relop);
	 k := -k };

   /* Now a bit of special case detection which says if both
      operands are in the stack and in adjacent locations,
      use a LDM to extract them.  This is worth doing even
      if there is deferment of register loading, because it
      can ensure that registers get allocated the right way
      round (and it will often be applicable to FOR loops)
   */
      IF IsInTheStack(x) & IsInTheStack(y) & usesFrame & relop<s.fadd THEN {
	 LET loc1, loc2 = h3!x, h3!y;
	 IF [loc1=(loc2+1) | loc2=(loc1+1)] &
	    LookFor(x, NotAddr)=Null &
	    LookFor(y, NotAddr)=Null THEN {
	    LET r, s = NextR(), ?;
	    LET b = r.0;
	    LET toploc = loc1>loc2 -> loc1+1, loc2+1;
	    LET wb = f.wb;

	    Lock(r, k.reg); s := NextR(); Unlock(r, k.reg);
	    IF (((r-s) NEQV (loc1-loc2)) NEQV nextStackWord)<0 THEN {
	    // the registers have been allocated the wrong
	    // way round - swap them
	       LET t = r; r := s; s := t };

	    TEST toploc=TOSOffset THEN
	       b, wb := r.ts, 0
	    ELSE {
	       IF toploc~=R0Offset THEN
		  SetRtoRplusK(r.0, r.p, nextStackWord*toploc);
	       R0Offset := toploc-2 };

	    F4Inst(f.ldm, b, (1<<r)+(1<<s), reversedStack -> f.preup+wb,
							     f.predown+wb);

	    MoveSToR(k.reg, r, k.loc, h3!x);
	    MoveSToR(k.reg, s, k.loc, h3!y);
	    h1!x, h3!x := k.reg, r;
	    h1!y, h3!y := k.reg, s } };

      IF mergek THEN h4!x := k;
      regTestedAgainstZero := Null;
      TEST relop>s.fadd THEN
	 CGFCompare(y, x)
      ELSE {
	 LET r = ?;
	 LET ind = h2!y;
	 IF 0<ind<CarMark & IsConst(x) &
	    (relop=s.eq | relop=s.ne) THEN {
	    LET size = ind/32;
	    LET shift = ind REM 32;
	    LET k = h3!x;
	    IF (size<=8 & k=0) | (size=1 & k=1) THEN {
	       h2!y := 0;
	       h3!x := [(-1)>>(32-size)]<<shift;
	       IF k=1 THEN b := ~b;
	       f := f.tsts } };

	 r := MoveToAnyCR(y);
	 IF IsConst(x) & f=f.cmps THEN {
	    LET k = h3!x;
	    LET m = MaskFor(relop, b);
	    IF k=0 THEN regTestedAgainstZero := r;
	    IF LookForSLoc(NotAddr, k.number, k)=Null THEN {
	       CompareAgainstK(r, k,  m);
	       Stack(ssp-2);
	       RESULTIS m } };
	 GenF(f, r, x) } };
   Stack(ssp-2);
   RESULTIS MaskFor(relop, b) }

AND MaskFor(relop, b) = VALOF SWITCHON relop INTO {
   CASE s.ne:
   CASE s.fne: b := ~b;
   CASE s.eq:
   CASE s.feq: RESULTIS b -> m.eq, m.ne

   CASE s.ls:
   CASE s.fls: b := ~b;
   CASE s.ge:
   CASE s.fge: RESULTIS b -> m.ge, m.lt

   CASE s.gr:
   CASE s.fgr: b := ~b;
   CASE s.le:
   CASE s.fle: RESULTIS b -> m.le, m.gt

   CASE s.lls: b := ~b;
   CASE s.lge: RESULTIS b -> m.geu, m.ltu

   CASE s.lgr: b := ~b;
   CASE s.lle: RESULTIS b -> m.leu, m.gtu }

AND Reverse(relop) = VALOF SWITCHON relop INTO {
   CASE s.ls:  RESULTIS s.gr
   CASE s.gr:  RESULTIS s.ls
   CASE s.le:  RESULTIS s.ge
   CASE s.ge:  RESULTIS s.le

   CASE s.lls: RESULTIS s.lgr
   CASE s.lgr: RESULTIS s.lls
   CASE s.lle: RESULTIS s.lge
   CASE s.lge: RESULTIS s.lle

   CASE s.fls: RESULTIS s.fgr
   CASE s.fgr: RESULTIS s.fls
   CASE s.fle: RESULTIS s.fge
   CASE s.fge: RESULTIS s.fle

   DEFAULT:    RESULTIS relop }

AND ComplementCondition(mask) = VALOF SWITCHON mask INTO {
   CASE m.eq:  RESULTIS m.ne
   CASE m.ne:  RESULTIS m.eq

   CASE m.lt:  RESULTIS m.ge
   CASE m.ge:  RESULTIS m.lt

   CASE m.gt:  RESULTIS m.le
   CASE m.le:  RESULTIS m.gt

   CASE m.ltu: RESULTIS m.geu
   CASE m.geu: RESULTIS m.ltu

   CASE m.gtu: RESULTIS m.leu
   CASE m.leu: RESULTIS m.gtu

   CASE m.always: RESULTIS m.never
   CASE m.never:
   CASE Null:  RESULTIS m.always }


AND CGSlctSt() BE {
   LET size = ReadN()
   LET shift = ReadN();
   LET offset = ReadN();
   LET simpleSLoc = FALSE;
   IF h2!arg1>=0 THEN MoveToAnyR(arg1);

   IF size=0 & h1!arg1~=k.shreg THEN {
      h4!arg1 := h4!arg1+offset;
      CGStind();
      RETURN };

   {  LET b, m = -1, 0;
      LET n, t, k = h3!arg1, h1!arg1, h4!arg1;
      LET classofsel = TypeOfField(size, shift);
      LET a = 4*offset;

      IF t~=k.shreg THEN a := a+4*k;
      SWITCHON t INTO {
	 CASE k.lvloc:
	 CASE k.lvglob:
	 CASE k.lvstatic:
	    t, n := t+k.loc-k.lvloc, a/4+n;
	    h1!arg1, h2!arg1, h3!arg1, h4!arg1 := t, -1, n, 0;
	    simpleSLoc := TRUE;
	    ENDCASE

	 CASE k.lvlab:
	    b, m := CheckRLLoaded(), n;
	    ENDCASE

	 DEFAULT:
	    FlushPendingStores();
	    h4!arg1 := 0;
	    b := LoadAddress(arg1);
	    Lock(b, k.reg);
	    TEST localsSafe THEN {
	       FlushPendingLoadsExceptLocals();
	       FlushPendingStoresExceptLocalsAndIregs() }
	    ELSE {
	       FlushPendingLoads();
	       FlushPendingStores() } };

      TEST classofsel=bytefield & ~simpleSLoc THEN
	 GenF2(f.strb, MoveToAnyCR(arg2), b, m, a+shift/8)

      ELSE TEST h1!arg2=k.number THEN {
	 LET mask = (-1>>(TargetWordSize-size))<<shift;
	 LET r, n1 = NextR(), (h3!arg2)<<shift;
	 LET s = r;
	 TEST simpleSLoc THEN {
	    s := IsInARegister(arg1);
	    IF s=Null THEN s := r;
	    MoveToR(s, arg1);
	    h3!arg1 := r;
	    DiscardReg(r, k.reg) }
	 ELSE
	    GenF2(f.ldr, r, b, m, a);
	 IF n1~=mask THEN {
	    TEST size<=16 THEN
	       GenF1K(f.bic, r, s, mask)
	    ELSE
	       GenF1K(f.and, r, s, ~mask);
	    s := r };
	 IF (n1&mask)~=0 THEN
	    GenF1K(f.orr, r, s, n1&mask);
	 TEST simpleSLoc THEN
	    GenStore(t, n)
	 ELSE
	    GenF2(f.str, r, b, m, a) }

      ELSE {
	 LET mask = (-1>>(TargetWordSize-size))<<shift;
	 LET r, s = Null, Null;
	 LET i2 = h2!arg2;
	 LET realshift = shift;
	 IF 0<i2<CarMark THEN {
	    LET size2, shift2 = i2/32, i2 REM 32;
	    IF size2>=size THEN {
	       h2!arg2 := 0;
	       shift := shift-shift2 } };
	 r := MoveToAnyR(arg2);
	 TEST simpleSLoc THEN {
	    s := IsInARegister(arg1);
	    TEST s=Null THEN
	       s := MoveToAnyCR(arg1)
	    ELSE
	       MoveToR(s, arg1);
	    h3!arg1 := r;
	    DiscardReg(r, k.reg) }
	 ELSE {
	    s := NextR();
	    GenF2(f.ldr, s, b, m, a) };

	 TEST (size+realshift)=32 THEN {
	    LET s1 = simpleSloc -> NextR(), s;
	    TEST shift=0 THEN {
	       ShiftRegisterDS(s1, s, sh.asl, size);
	       F1Inst(f.eor, r, r, s1, 0, sh.lsr, size, m.always) }
	    ELSE {
	       TEST size<=16 THEN
		  GenF1K(f.bic, s1, s, mask)
	       ELSE
		  GenF1K(f.and, s1, s, ~mask);
	       TEST shift>0 THEN
		  F1Inst(f.eor, r, s1, r, 0, sh.asl, shift, m.always)
	       ELSE
		  F1Inst(f.eor, r, s1, r, 0, sh.lsr, -shift, m.always) } }

	 ELSE {
	    TEST shift>0 THEN
	       F1Inst(f.eor, r, s, r, 0, sh.asl, shift, m.always)
	    ELSE TEST shift<0 THEN
	       F1Inst(f.eor, r, s, r, 0, sh.lsr, -shift, m.always)
	    ELSE
	       GenRR(f.eor, r, s, r);

	    TEST realshift=0 THEN {
	       ShiftRegister(r, sh.asl, 32-size);
	       F1Inst(f.eor, r, s, r, 0, sh.lsr, 32-size, m.always) }
	    ELSE {
	       TEST size>=16 THEN
		  GenF1K(f.bic, r, r, ~mask)
	       ELSE
		  GenF1K(f.and, r, r, mask);
	       GenRR(f.eor, r, s, r) } };
	 TEST simpleSLoc THEN
	    GenStore(t, n)
	 ELSE
	    GenF2(f.str, r, b, m, a) };
      TEST simpleSLoc THEN
	 Stack(ssp-1)
      ELSE {
	 DiscardRegs();
	 Stack(ssp-2) };

      IF b>=0 THEN Unlock(b, k.reg) } }

AND CGByteAp(op) BE {
   LET a, r, x = ?, ?, Null;
   LET sh, m = sh.asl, 0;
   LET b = ?;

   TEST IsConst(arg1) & (-k4<=h3!arg1<=k4) & h2!arg2<0
      THEN SWITCHON h1!arg2 INTO {
	 CASE k.lvloc:
	    a := h3!arg1+4*h4!arg2;
	    b := linkageNotStored -> r.ts, r.p;
	    IF ~usesFrame THEN b, a := r.ts, a-4*saveSpaceSize;
	    a := a+nextStackWord*h3!arg2;
	    ENDCASE

	 CASE k.lvstatic:
	    a, b := h3!arg1+4*(h4!arg2+h3!arg2), CheckRLLoaded();
	    ENDCASE

	 CASE k.lvglob:
	    a, b := h3!arg1+4*(h4!arg2+h3!arg2), r.g;
	    ENDCASE

	 CASE k.lvlab:
	    a, m := h3!arg1+4*h4!arg2, h3!arg2;
	    b := CheckRLLoaded();
	    ENDCASE;

	 DEFAULT:
	    IF h1!arg2~=k.shreg THEN {
	       a := h3!arg1+nextStackWord*h4!arg2;
	       h4!arg2 := 0 };
	    b := LoadAddress(arg2) }

   ELSE TEST IsConst(arg2) & h3!arg2=0 THEN {
       // special case of 0%something.
       // because this is a construct much used in Lisp,
       // where the something is a tagged pointer, I mask
       // out potential tag bits
      TEST h2!arg1<0 & h4!arg1~=0 THEN {
	 a := h4!arg1;
	 h4!arg1 := 0 }
      ELSE
	 a := 0;
      b := LoadCarAdd(arg1) }

   ELSE {
      x := MoveToAnyCR(arg1); Lock(x, k.reg);
      TEST h2!arg2<0 THEN {
	 IF k.lvloc<=h1!arg2<=k.lvlab THEN {
	    h1!arg2, sh := h1!arg2+k.lvs, Null;
	    h4!arg2 := h4!arg2*4 };
	 b := LookFor(arg2, ShiftedUp);
	 TEST b>=0 & h4!arg2=0 THEN
	    sh := Null
	 ELSE
	    b := MoveToAnyCR(arg2) }
      ELSE
	 b := MoveToAnyCR(arg2) };

   FlushPendingLoads();
   FlushPendingStores();
   Lock(b, k.reg);
   TEST op=s.putbyte THEN {
      r := LoadArg3ToSomeCR();
      TEST x=Null THEN
	 GenF2(f.strb, r, b, m, a)
      ELSE
	 F2Inst(f.strb, r, x, 0, b, f.preup, sh, 2, m.always);
      TEST LocalsSafe THEN
	 DiscardNonLocalRegs()
      ELSE
	 DiscardNonConstRegs();
      Stack(ssp-3) }

   ELSE {
      r := NextR();
      TEST x=Null THEN
	 GenF2(f.ldrb, r, b, m, a)
      ELSE
	 F2Inst(f.ldrb, r, x, 0, b, f.preup, sh, 2, m.always);
      DiscardReg(r, k.reg);
      Lose(r, k.reg);
      UnLock(b, k.reg);
      IF x~=Null THEN UnLock(x, k.reg) } }

00000000  53 45 43 54 49 4f 4e 20  22 43 47 43 22 0a 0a 47  |SECTION "CGC"..G|
00000010  45 54 20 22 62 2e 43 47  68 65 61 64 65 72 22 0a  |ET "b.CGheader".|
00000020  0a 53 54 41 54 49 43 20  7b 0a 20 20 20 2f 2f 20  |.STATIC {.   // |
00000030  56 65 72 73 69 6f 6e 20  6f 66 20 31 34 20 41 70  |Version of 14 Ap|
00000040  72 20 38 36 20 31 34 3a  30 30 3a 31 31 0a 20 20  |r 86 14:00:11.  |
00000050  20 64 75 6d 6d 79 20 3d  20 56 65 72 73 69 6f 6e  | dummy = Version|
00000060  4d 61 72 6b 3b 0a 20 20  20 76 65 72 73 69 6f 6e  |Mark;.   version|
00000070  20 3d 20 31 2a 32 35 36  2b 31 39 20 7d 3b 0a 0a  | = 1*256+19 };..|
00000080  2f 2a 20 31 2e 36 09 30  31 20 4e 6f 76 20 38 35  |/* 1.6.01 Nov 85|
00000090  20 31 33 3a 31 32 3a 30  33 0a 20 20 20 20 20 20  | 13:12:03.      |
000000a0  52 65 63 6f 67 6e 69 73  65 20 74 68 61 74 20 61  |Recognise that a|
000000b0  66 74 65 72 20 20 43 4d  50 20 2e 2e 2c 20 23 30  |fter  CMP .., #0|
000000c0  3b 20 42 4e 45 20 2e 2e  20 61 20 72 65 67 69 73  |; BNE .. a regis|
000000d0  74 65 72 20 63 6f 6e 74  61 69 6e 73 20 30 0a 20  |ter contains 0. |
000000e0  20 20 20 20 20 42 75 67  20 66 69 78 3a 20 78 20  |     Bug fix: x |
000000f0  6f 70 3a 3d 20 2e 2e 20  6d 75 73 74 20 66 6c 75  |op:= .. must flu|
00000100  73 68 20 70 65 6e 64 69  6e 67 20 73 74 6f 72 65  |sh pending store|
00000110  73 20 66 6f 72 20 78 0a  20 20 20 31 2e 37 09 20  |s for x.   1.7. |
00000120  30 34 20 4e 6f 76 20 38  35 20 31 35 3a 32 34 3a  |04 Nov 85 15:24:|
00000130  34 33 0a 20 20 20 20 20  20 4c 6f 61 64 20 6f 66  |43.      Load of|
00000140  20 72 65 67 69 73 74 65  72 20 66 6f 72 20 69 6e  | register for in|
00000150  64 69 72 65 63 74 20 73  74 6f 72 65 20 6d 61 79  |direct store may|
00000160  20 62 65 20 64 65 66 65  72 72 65 64 0a 20 20 20  | be deferred.   |
00000170  31 2e 38 09 20 31 34 20  4a 61 6e 20 38 36 20 31  |1.8. 14 Jan 86 1|
00000180  35 3a 35 36 3a 31 32 0a  20 20 20 20 20 20 42 75  |5:56:12.      Bu|
00000190  67 20 66 69 78 3a 20 4c  6f 63 6b 20 62 61 73 65  |g fix: Lock base|
000001a0  20 72 65 67 69 73 74 65  72 20 69 6e 20 6f 70 3a  | register in op:|
000001b0  3d 0a 20 20 20 31 2e 39  09 20 33 30 20 4a 61 6e  |=.   1.9. 30 Jan|
000001c0  20 38 36 20 31 31 3a 31  34 3a 33 35 0a 20 20 20  | 86 11:14:35.   |
000001d0  20 20 20 42 75 67 20 66  69 78 3a 20 43 47 52 65  |   Bug fix: CGRe|
000001e0  6c 6f 70 58 20 6e 6f 74  20 74 6f 20 6c 65 61 76  |lopX not to leav|
000001f0  65 20 61 20 72 65 67 69  73 74 65 72 20 6d 61 72  |e a register mar|
00000200  6b 65 64 20 61 73 20 63  6f 6e 74 61 69 6e 69 6e  |ked as containin|
00000210  67 20 30 0a 20 20 20 20  20 20 69 66 20 69 74 20  |g 0.      if it |
00000220  68 61 73 6e 27 74 20 63  6f 6d 70 69 6c 65 64 20  |hasn't compiled |
00000230  61 20 63 6f 6d 70 61 72  65 2e 0a 20 20 20 31 2e  |a compare..   1.|
00000240  31 30 20 20 30 36 20 46  65 62 20 38 36 20 31 37  |10  06 Feb 86 17|
00000250  3a 31 30 3a 31 30 0a 20  20 20 20 20 20 49 6e 63  |:10:10.      Inc|
00000260  6f 72 70 6f 72 61 74 69  6f 6e 20 6f 66 20 66 6c  |orporation of fl|
00000270  6f 61 74 69 6e 67 20 70  6f 69 6e 74 20 28 6e 6f  |oating point (no|
00000280  74 20 69 6e 20 6f 70 3a  3d 20 74 68 6f 75 67 68  |t in op:= though|
00000290  29 0a 20 20 20 31 2e 31  31 20 20 31 38 20 46 65  |).   1.11  18 Fe|
000002a0  62 20 38 36 20 31 31 3a  31 39 3a 35 34 0a 20 20  |b 86 11:19:54.  |
000002b0  20 20 20 20 42 79 74 65  20 73 65 6c 65 63 74 6f  |    Byte selecto|
000002c0  72 73 20 6d 65 6e 64 65  64 20 74 6f 20 67 65 74  |rs mended to get|
000002d0  20 74 68 65 20 72 69 67  68 74 20 62 79 74 65 2c  | the right byte,|
000002e0  20 6e 6f 74 20 33 2d 20  69 74 2e 0a 20 20 20 20  | not 3- it..    |
000002f0  20 20 53 74 6f 72 69 6e  67 20 6f 66 20 6e 6f 6e  |  Storing of non|
00000300  2d 63 6f 6e 73 74 61 6e  74 20 74 6f 20 67 65 6e  |-constant to gen|
00000310  65 72 61 6c 20 66 69 65  6c 64 20 63 6f 72 72 65  |eral field corre|
00000320  63 74 65 64 2e 0a 20 20  20 31 2e 31 32 20 20 32  |cted..   1.12  2|
00000330  35 20 46 65 62 20 38 36  20 31 32 3a 33 33 3a 30  |5 Feb 86 12:33:0|
00000340  31 0a 20 20 20 20 20 20  49 6d 70 72 6f 76 65 6d  |1.      Improvem|
00000350  65 6e 74 20 6f 66 20 63  6f 64 65 20 66 6f 72 20  |ent of code for |
00000360  66 69 65 6c 64 20 75 70  64 61 74 65 20 77 68 65  |field update whe|
00000370  72 65 20 74 68 65 72 65  20 69 73 20 6e 6f 20 69  |re there is no i|
00000380  6e 64 69 72 65 63 74 69  6f 6e 0a 20 20 20 31 2e  |ndirection.   1.|
00000390  31 33 20 20 32 36 20 46  65 62 20 38 36 20 31 31  |13  26 Feb 86 11|
000003a0  3a 34 31 3a 34 36 0a 20  20 20 20 20 20 49 6d 70  |:41:46.      Imp|
000003b0  72 6f 76 65 6d 65 6e 74  20 6f 66 20 63 6f 64 65  |rovement of code|
000003c0  20 66 6f 72 20 73 74 69  6e 64 20 26 20 6f 70 3a  | for stind & op:|
000003d0  3d 0a 20 20 20 31 2e 31  34 0a 20 20 20 20 20 20  |=.   1.14.      |
000003e0  42 75 67 20 66 69 78 3a  20 53 6c 63 74 53 74 20  |Bug fix: SlctSt |
000003f0  64 69 64 20 6e 6f 74 20  63 68 65 63 6b 20 66 6f  |did not check fo|
00000400  72 20 69 6e 64 69 72 65  63 74 69 6f 6e 20 62 65  |r indirection be|
00000410  66 6f 72 65 20 63 6f 6e  73 69 64 65 72 69 6e 67  |fore considering|
00000420  0a 20 20 20 20 20 20 74  68 65 20 74 79 70 65 20  |.      the type |
00000430  6f 66 20 74 68 65 20 73  65 6c 65 63 74 65 64 20  |of the selected |
00000440  74 68 69 6e 67 2e 0a 20  20 20 31 2e 31 35 20 20  |thing..   1.15  |
00000450  30 36 20 4d 61 72 20 38  36 20 31 32 3a 35 37 3a  |06 Mar 86 12:57:|
00000460  33 32 0a 20 20 20 20 20  43 47 53 6c 63 74 53 74  |32.     CGSlctSt|
00000470  20 64 69 64 20 6e 6f 74  20 6c 6f 63 6b 20 69 74  | did not lock it|
00000480  73 20 62 61 73 65 2e 0a  20 20 20 31 2e 31 36 20  |s base..   1.16 |
00000490  20 30 37 20 4d 61 72 20  38 36 20 32 31 3a 33 30  | 07 Mar 86 21:30|
000004a0  3a 31 30 0a 20 20 20 20  20 6b 2e 73 74 61 74 69  |:10.     k.stati|
000004b0  63 0a 20 20 20 31 2e 31  37 20 20 31 36 20 4d 61  |c.   1.17  16 Ma|
000004c0  72 20 38 36 20 32 32 3a  33 36 3a 31 36 0a 20 20  |r 86 22:36:16.  |
000004d0  20 20 20 49 6d 70 72 6f  76 65 6d 65 6e 74 73 20  |   Improvements |
000004e0  69 6e 20 63 6f 64 69 6e  67 20 6f 66 20 43 6f 6e  |in coding of Con|
000004f0  64 69 74 69 6f 6e 20 28  66 69 65 6c 64 20 3a 20  |dition (field : |
00000500  63 6f 6e 73 74 61 6e 74  29 20 61 6e 64 0a 20 20  |constant) and.  |
00000510  20 20 20 46 69 65 6c 64  20 75 70 64 61 74 65 20  |   Field update |
00000520  28 76 61 6c 75 65 20 61  6c 73 6f 20 61 20 66 69  |(value also a fi|
00000530  65 6c 64 29 2e 0a 20 20  20 31 2e 31 38 20 20 32  |eld)..   1.18  2|
00000540  31 20 4d 61 72 20 38 36  20 31 31 3a 30 38 3a 35  |1 Mar 86 11:08:5|
00000550  37 0a 20 20 20 20 20 44  65 66 65 72 72 65 64 20  |7.     Deferred |
00000560  73 68 69 66 74 73 0a 20  20 20 31 2e 31 39 20 20  |shifts.   1.19  |
00000570  31 34 20 41 70 72 20 38  36 20 31 33 3a 35 39 3a  |14 Apr 86 13:59:|
00000580  32 38 0a 20 20 20 20 20  53 74 69 6e 64 20 77 69  |28.     Stind wi|
00000590  74 68 20 6c 6f 63 61 6c  73 20 73 61 66 65 20 65  |th locals safe e|
000005a0  74 63 20 6e 65 65 64 20  6e 6f 74 20 66 6f 72 63  |tc need not forc|
000005b0  65 20 74 68 65 20 73 74  6f 72 65 64 20 72 65 67  |e the stored reg|
000005c0  69 73 74 65 72 20 74 6f  20 62 65 0a 20 20 20 20  |ister to be.    |
000005d0  20 6c 6f 61 64 65 64 0a  2a 2f 0a 0a 53 54 41 54  | loaded.*/..STAT|
000005e0  49 43 20 7b 0a 20 20 20  72 65 67 54 65 73 74 65  |IC {.   regTeste|
000005f0  64 41 67 61 69 6e 73 74  5a 65 72 6f 20 3d 20 30  |dAgainstZero = 0|
00000600  20 7d 0a 0a 4d 41 4e 49  46 45 53 54 20 7b 0a 20  | }..MANIFEST {. |
00000610  20 20 6b 2e 69 73 61 66  72 20 3d 20 32 35 36 20  |  k.isafr = 256 |
00000620  7d 3b 0a 0a 4c 45 54 20  43 47 53 74 69 6e 64 28  |};..LET CGStind(|
00000630  29 20 42 45 20 7b 0a 20  20 20 4c 45 54 20 72 20  |) BE {.   LET r |
00000640  3d 20 68 31 21 61 72 67  32 3d 6b 2e 66 72 65 67  |= h1!arg2=k.freg|
00000650  20 2d 3e 0a 09 20 20 20  20 20 4d 6f 76 65 54 6f  | ->..     MoveTo|
00000660  41 6e 79 46 52 28 61 72  67 32 29 2b 6b 2e 69 73  |AnyFR(arg2)+k.is|
00000670  61 66 72 2c 0a 09 20 20  20 20 20 4d 6f 76 65 54  |afr,..     MoveT|
00000680  6f 41 6e 79 43 52 53 6f  6d 65 54 69 6d 65 46 6f  |oAnyCRSomeTimeFo|
00000690  72 53 74 6f 72 65 54 6f  28 61 72 67 32 2c 20 53  |rStoreTo(arg2, S|
000006a0  68 69 66 74 65 64 55 70  2c 20 61 72 67 31 29 3b  |hiftedUp, arg1);|
000006b0  0a 20 20 20 53 74 69 6e  64 4f 72 41 73 73 4f 70  |.   StindOrAssOp|
000006c0  28 2d 31 2c 20 72 29 20  7d 0a 0a 41 4e 44 20 43  |(-1, r) }..AND C|
000006d0  47 41 73 73 4f 70 28 29  20 42 45 20 7b 0a 20 20  |GAssOp() BE {.  |
000006e0  20 4c 45 54 20 72 20 3d  20 2d 31 3b 0a 20 20 20  | LET r = -1;.   |
000006f0  4c 45 54 20 66 20 3d 20  3f 3b 0a 20 20 20 6f 70  |LET f = ?;.   op|
00000700  20 3a 3d 20 52 65 61 64  4f 70 28 29 3b 0a 20 20  | := ReadOp();.  |
00000710  20 66 20 3a 3d 20 56 41  4c 4f 46 20 53 57 49 54  | f := VALOF SWIT|
00000720  43 48 4f 4e 20 6f 70 20  49 4e 54 4f 20 7b 0a 20  |CHON op INTO {. |
00000730  20 20 20 20 20 43 41 53  45 20 73 2e 70 6c 75 73  |     CASE s.plus|
00000740  3a 20 20 52 45 53 55 4c  54 49 53 20 43 47 50 6c  |:  RESULTIS CGPl|
00000750  75 73 0a 20 20 20 20 20  20 43 41 53 45 20 73 2e  |us.      CASE s.|
00000760  6d 69 6e 75 73 3a 20 52  45 53 55 4c 54 49 53 20  |minus: RESULTIS |
00000770  43 47 4d 69 6e 75 73 0a  20 20 20 20 20 20 43 41  |CGMinus.      CA|
00000780  53 45 20 73 2e 6d 75 6c  74 3a 20 20 72 20 3a 3d  |SE s.mult:  r :=|
00000790  20 41 72 67 75 6d 65 6e  74 52 65 67 69 73 74 65  | ArgumentRegiste|
000007a0  72 28 31 29 3b 20 52 45  53 55 4c 54 49 53 20 43  |r(1); RESULTIS C|
000007b0  47 4d 75 6c 74 0a 20 20  20 20 20 20 43 41 53 45  |GMult.      CASE|
000007c0  20 73 2e 64 69 76 3a 20  20 20 72 20 3a 3d 20 41  | s.div:   r := A|
000007d0  72 67 75 6d 65 6e 74 52  65 67 69 73 74 65 72 28  |rgumentRegister(|
000007e0  31 29 3b 20 52 45 53 55  4c 54 49 53 20 43 47 44  |1); RESULTIS CGD|
000007f0  69 76 0a 20 20 20 20 20  20 43 41 53 45 20 73 2e  |iv.      CASE s.|
00000800  72 65 6d 3a 20 20 20 72  20 3a 3d 20 41 72 67 75  |rem:   r := Argu|
00000810  6d 65 6e 74 52 65 67 69  73 74 65 72 28 31 29 3b  |mentRegister(1);|
00000820  20 52 45 53 55 4c 54 49  53 20 43 47 52 65 6d 0a  | RESULTIS CGRem.|
00000830  20 20 20 20 20 20 43 41  53 45 20 73 2e 6c 6f 67  |      CASE s.log|
00000840  61 6e 64 3a 0a 20 20 20  20 20 20 43 41 53 45 20  |and:.      CASE |
00000850  73 2e 6c 6f 67 6f 72 3a  0a 20 20 20 20 20 20 43  |s.logor:.      C|
00000860  41 53 45 20 73 2e 65 71  76 3a 0a 20 20 20 20 20  |ASE s.eqv:.     |
00000870  20 43 41 53 45 20 73 2e  6e 65 71 76 3a 20 20 52  | CASE s.neqv:  R|
00000880  45 53 55 4c 54 49 53 20  43 47 4c 6f 67 6f 70 0a  |ESULTIS CGLogop.|
00000890  20 20 20 20 20 20 43 41  53 45 20 73 2e 66 70 6c  |      CASE s.fpl|
000008a0  75 73 3a 0a 20 20 20 20  20 20 43 41 53 45 20 73  |us:.      CASE s|
000008b0  2e 66 6d 69 6e 75 73 3a  0a 20 20 20 20 20 20 43  |.fminus:.      C|
000008c0  41 53 45 20 73 2e 66 6d  75 6c 74 3a 0a 20 20 20  |ASE s.fmult:.   |
000008d0  20 20 20 43 41 53 45 20  73 2e 66 64 69 76 3a 20  |   CASE s.fdiv: |
000008e0  20 52 45 53 55 4c 54 49  53 20 43 47 46 6f 70 20  | RESULTIS CGFop |
000008f0  7d 3b 0a 20 20 20 53 74  69 6e 64 4f 72 41 73 73  |};.   StindOrAss|
00000900  4f 70 28 66 2c 20 72 29  20 7d 0a 0a 41 4e 44 20  |Op(f, r) }..AND |
00000910  53 74 69 6e 64 4f 72 41  73 73 4f 70 28 78 2c 20  |StindOrAssOp(x, |
00000920  72 29 20 42 45 20 7b 0a  20 20 20 4c 45 54 20 73  |r) BE {.   LET s|
00000930  2c 20 6d 2c 20 61 20 3d  20 30 2c 20 30 2c 20 30  |, m, a = 0, 0, 0|
00000940  3b 0a 20 20 20 4c 45 54  20 74 2c 20 69 6e 64 2c  |;.   LET t, ind,|
00000950  20 6e 2c 20 6b 20 3d 20  68 31 21 61 72 67 31 2c  | n, k = h1!arg1,|
00000960  20 68 32 21 61 72 67 31  2c 20 68 33 21 61 72 67  | h2!arg1, h3!arg|
00000970  31 2c 20 34 2a 68 34 21  61 72 67 31 3b 0a 20 20  |1, 4*h4!arg1;.  |
00000980  20 4c 45 54 20 73 69 6d  70 6c 65 53 4c 6f 63 20  | LET simpleSLoc |
00000990  3d 20 46 41 4c 53 45 3b  0a 20 20 20 4c 45 54 20  |= FALSE;.   LET |
000009a0  73 73 20 3d 20 73 73 70  2d 32 3b 0a 0a 20 20 20  |ss = ssp-2;..   |
000009b0  49 46 20 6b 2e 69 73 61  66 72 3e 72 3e 3d 30 20  |IF k.isafr>r>=0 |
000009c0  54 48 45 4e 20 4c 6f 63  6b 28 72 2c 20 6b 2e 72  |THEN Lock(r, k.r|
000009d0  65 67 29 3b 0a 0a 20 20  20 54 45 53 54 20 28 6b  |eg);..   TEST (k|
000009e0  2e 6c 76 6c 6f 63 3c 3d  74 3c 3d 6b 2e 6c 76 6c  |.lvloc<=t<=k.lvl|
000009f0  61 62 29 20 26 20 69 6e  64 3c 30 20 54 48 45 4e  |ab) & ind<0 THEN|
00000a00  0a 20 20 20 20 20 20 54  45 53 54 20 74 3d 6b 2e  |.      TEST t=k.|
00000a10  6c 76 6c 61 62 20 54 48  45 4e 20 7b 0a 09 20 73  |lvlab THEN {.. s|
00000a20  20 3a 3d 20 43 68 65 63  6b 52 4c 4c 6f 61 64 65  | := CheckRLLoade|
00000a30  64 28 29 0a 09 20 6d 2c  20 61 20 3a 3d 20 6e 2c  |d().. m, a := n,|
00000a40  20 6b 20 7d 0a 20 20 20  20 20 20 45 4c 53 45 20  | k }.      ELSE |
00000a50  7b 0a 09 20 74 2c 20 6e  20 3a 3d 20 74 2d 6b 2e  |{.. t, n := t-k.|
00000a60  6c 76 6c 6f 63 2b 6b 2e  6c 6f 63 2c 20 6e 2b 6b  |lvloc+k.loc, n+k|
00000a70  2f 34 3b 0a 09 20 68 31  21 61 72 67 31 2c 20 68  |/4;.. h1!arg1, h|
00000a80  32 21 61 72 67 31 2c 20  68 33 21 61 72 67 31 2c  |2!arg1, h3!arg1,|
00000a90  20 68 34 21 61 72 67 31  20 3a 3d 20 74 2c 20 2d  | h4!arg1 := t, -|
00000aa0  31 2c 20 6e 2c 20 30 3b  0a 09 20 73 69 6d 70 6c  |1, n, 0;.. simpl|
00000ab0  65 53 4c 6f 63 20 3a 3d  20 54 52 55 45 20 7d 0a  |eSLoc := TRUE }.|
00000ac0  0a 20 20 20 45 4c 53 45  20 54 45 53 54 20 69 6e  |.   ELSE TEST in|
00000ad0  64 3c 30 20 26 20 54 75  72 6e 49 6e 64 49 6e 74  |d<0 & TurnIndInt|
00000ae0  6f 53 4c 6f 63 28 61 72  67 31 29 20 54 48 45 4e  |oSLoc(arg1) THEN|
00000af0  20 7b 0a 20 20 20 20 20  20 74 2c 20 6e 20 3a 3d  | {.      t, n :=|
00000b00  20 68 31 21 61 72 67 31  2c 20 68 33 21 61 72 67  | h1!arg1, h3!arg|
00000b10  31 3b 0a 20 20 20 20 20  20 73 69 6d 70 6c 65 53  |1;.      simpleS|
00000b20  4c 6f 63 20 3a 3d 20 54  52 55 45 20 7d 0a 0a 20  |Loc := TRUE }.. |
00000b30  20 20 45 4c 53 45 20 7b  0a 20 20 20 20 20 20 54  |  ELSE {.      T|
00000b40  45 53 54 20 69 6e 64 3c  30 20 26 20 74 7e 3d 6b  |EST ind<0 & t~=k|
00000b50  2e 73 68 72 65 67 20 54  48 45 4e 20 7b 0a 09 20  |.shreg THEN {.. |
00000b60  61 20 3a 3d 20 6b 3b 20  68 34 21 61 72 67 31 20  |a := k; h4!arg1 |
00000b70  3a 3d 20 30 20 7d 0a 20  20 20 20 20 20 45 4c 53  |:= 0 }.      ELS|
00000b80  45 0a 09 20 4d 6f 76 65  54 6f 41 6e 79 52 28 61  |E.. MoveToAnyR(a|
00000b90  72 67 31 29 3b 0a 20 20  20 20 20 20 73 20 3a 3d  |rg1);.      s :=|
00000ba0  20 4c 6f 61 64 41 64 64  72 65 73 73 28 61 72 67  | LoadAddress(arg|
00000bb0  31 29 3b 0a 20 20 20 20  20 20 4c 6f 63 6b 28 73  |1);.      Lock(s|
00000bc0  2c 20 6b 2e 72 65 67 29  3b 0a 20 20 20 20 20 20  |, k.reg);.      |
00000bd0  54 45 53 54 20 6c 6f 63  61 6c 73 53 61 66 65 20  |TEST localsSafe |
00000be0  54 48 45 4e 20 7b 0a 09  20 46 6c 75 73 68 50 65  |THEN {.. FlushPe|
00000bf0  6e 64 69 6e 67 4c 6f 61  64 73 45 78 63 65 70 74  |ndingLoadsExcept|
00000c00  4c 6f 63 61 6c 73 28 29  3b 0a 09 20 46 6c 75 73  |Locals();.. Flus|
00000c10  68 50 65 6e 64 69 6e 67  53 74 6f 72 65 73 45 78  |hPendingStoresEx|
00000c20  63 65 70 74 4c 6f 63 61  6c 73 41 6e 64 49 72 65  |ceptLocalsAndIre|
00000c30  67 73 28 29 20 7d 0a 20  20 20 20 20 20 45 4c 53  |gs() }.      ELS|
00000c40  45 20 7b 0a 09 20 46 6c  75 73 68 50 65 6e 64 69  |E {.. FlushPendi|
00000c50  6e 67 4c 6f 61 64 73 28  29 3b 0a 09 20 46 6c 75  |ngLoads();.. Flu|
00000c60  73 68 50 65 6e 64 69 6e  67 53 74 6f 72 65 73 28  |shPendingStores(|
00000c70  29 20 7d 20 7d 3b 0a 0a  20 20 20 54 45 53 54 20  |) } };..   TEST |
00000c80  78 3e 3d 30 20 54 48 45  4e 20 7b 0a 20 20 20 20  |x>=0 THEN {.    |
00000c90  20 20 49 46 20 7e 73 69  6d 70 6c 65 53 4c 6f 63  |  IF ~simpleSLoc|
00000ca0  20 54 48 45 4e 0a 09 20  54 45 53 54 20 78 3d 43  | THEN.. TEST x=C|
00000cb0  47 46 6f 70 20 54 48 45  4e 20 7b 0a 09 20 20 20  |GFop THEN {..   |
00000cc0  20 72 20 3a 3d 20 4e 65  78 74 46 52 28 29 3b 0a  | r := NextFR();.|
00000cd0  09 20 20 20 20 47 65 6e  43 50 44 54 28 66 2e 6c  |.    GenCPDT(f.l|
00000ce0  64 2c 20 72 2c 20 73 2c  20 6d 2c 20 61 29 3b 0a  |d, r, s, m, a);.|
00000cf0  09 20 20 20 20 53 74 61  63 6b 28 73 73 70 2d 31  |.    Stack(ssp-1|
00000d00  29 3b 0a 09 20 20 20 20  4c 6f 61 64 28 6b 2e 66  |);..    Load(k.f|
00000d10  72 65 67 2c 20 72 29 20  7d 0a 09 20 45 4c 53 45  |reg, r) }.. ELSE|
00000d20  20 7b 0a 09 20 20 20 20  54 45 53 54 20 72 3c 30  | {..    TEST r<0|
00000d30  20 54 48 45 4e 0a 09 20  20 20 20 20 20 20 72 20  | THEN..       r |
00000d40  3a 3d 20 4e 65 78 74 52  28 29 0a 09 20 20 20 20  |:= NextR()..    |
00000d50  45 4c 53 45 0a 09 20 20  20 20 20 20 20 46 72 65  |ELSE..       Fre|
00000d60  65 52 65 67 28 72 29 3b  0a 09 20 20 20 20 47 65  |eReg(r);..    Ge|
00000d70  6e 4f 70 54 6f 53 74 6f  72 65 28 66 2e 6c 64 72  |nOpToStore(f.ldr|
00000d80  2c 20 72 2c 20 73 2c 20  6d 2c 20 61 29 3b 0a 09  |, r, s, m, a);..|
00000d90  20 20 20 20 46 6c 75 73  68 50 65 6e 64 69 6e 67  |    FlushPending|
00000da0  4c 6f 61 64 73 46 6f 72  52 65 67 28 72 29 3b 0a  |LoadsForReg(r);.|
00000db0  09 20 20 20 20 53 74 61  63 6b 28 73 73 70 2d 31  |.    Stack(ssp-1|
00000dc0  29 3b 0a 09 20 20 20 20  4c 6f 61 64 28 6b 2e 72  |);..    Load(k.r|
00000dd0  65 67 2c 20 72 29 20 7d  3b 0a 0a 20 20 20 20 20  |eg, r) };..     |
00000de0  20 53 77 61 70 53 53 28  61 72 67 31 2c 20 61 72  | SwapSS(arg1, ar|
00000df0  67 32 29 3b 0a 20 20 20  20 20 20 78 28 6f 70 2c  |g2);.      x(op,|
00000e00  20 46 41 4c 53 45 29 3b  0a 20 20 20 20 20 20 72  | FALSE);.      r|
00000e10  20 3a 3d 20 68 33 21 61  72 67 31 20 7d 0a 0a 20  | := h3!arg1 }.. |
00000e20  20 20 45 4c 53 45 20 53  74 61 63 6b 28 73 73 70  |  ELSE Stack(ssp|
00000e30  2d 31 29 3b 0a 0a 20 20  20 54 45 53 54 20 73 69  |-1);..   TEST si|
00000e40  6d 70 6c 65 53 4c 6f 63  20 54 48 45 4e 20 7b 0a  |mpleSLoc THEN {.|
00000e50  20 20 20 20 20 20 4c 45  54 20 72 74 20 3d 20 68  |      LET rt = h|
00000e60  31 21 61 72 67 31 3b 0a  20 20 20 20 20 20 47 65  |1!arg1;.      Ge|
00000e70  6e 53 74 6f 72 65 28 74  2c 20 6e 29 3b 0a 20 20  |nStore(t, n);.  |
00000e80  20 20 20 20 49 46 20 72  74 3d 6b 2e 72 65 67 20  |    IF rt=k.reg |
00000e90  26 20 72 3c 6b 2e 69 73  61 66 72 20 54 48 45 4e  |& r<k.isafr THEN|
00000ea0  20 55 6e 6c 6f 63 6b 28  72 2c 20 6b 2e 72 65 67  | Unlock(r, k.reg|
00000eb0  29 20 7d 0a 20 20 20 45  4c 53 45 20 54 45 53 54  |) }.   ELSE TEST|
00000ec0  20 78 3d 43 47 46 6f 70  20 7c 20 72 3e 3d 6b 2e  | x=CGFop | r>=k.|
00000ed0  69 73 61 66 72 20 54 48  45 4e 0a 20 20 20 20 20  |isafr THEN.     |
00000ee0  20 47 65 6e 43 50 44 54  28 66 2e 73 74 2c 20 72  | GenCPDT(f.st, r|
00000ef0  26 31 35 2c 20 73 2c 20  6d 2c 20 61 29 0a 20 20  |&15, s, m, a).  |
00000f00  20 45 4c 53 45 20 54 45  53 54 20 6c 6f 63 61 6c  | ELSE TEST local|
00000f10  73 53 61 66 65 20 26 20  74 3d 6b 2e 6c 6f 63 20  |sSafe & t=k.loc |
00000f20  26 20 69 6e 64 3c 30 20  54 48 45 4e 20 7b 0a 20  |& ind<0 THEN {. |
00000f30  20 20 20 20 20 4d 6f 76  65 54 6f 52 53 6f 6d 65  |     MoveToRSome|
00000f40  54 69 6d 65 28 72 2c 20  61 72 67 31 29 3b 0a 20  |Time(r, arg1);. |
00000f50  20 20 20 20 20 41 64 64  54 6f 50 65 6e 64 69 6e  |     AddToPendin|
00000f60  67 53 74 6f 72 65 73 28  72 2c 20 6b 2e 69 72 65  |gStores(r, k.ire|
00000f70  67 2c 20 73 2c 20 46 41  4c 53 45 2c 20 61 2f 34  |g, s, FALSE, a/4|
00000f80  29 20 7d 0a 20 20 20 45  4c 53 45 20 7b 0a 20 20  |) }.   ELSE {.  |
00000f90  20 20 20 20 4d 6f 76 65  54 6f 52 28 72 2c 20 61  |    MoveToR(r, a|
00000fa0  72 67 31 29 3b 0a 20 20  20 20 20 20 47 65 6e 46  |rg1);.      GenF|
00000fb0  32 28 66 2e 73 74 72 2c  20 72 2c 20 73 2c 20 6d  |2(f.str, r, s, m|
00000fc0  2c 20 61 29 20 7d 3b 0a  0a 20 20 20 55 6e 6c 6f  |, a) };..   Unlo|
00000fd0  63 6b 28 73 2c 20 6b 2e  72 65 67 29 3b 0a 20 20  |ck(s, k.reg);.  |
00000fe0  20 49 46 20 7e 73 69 6d  70 6c 65 53 4c 6f 63 20  | IF ~simpleSLoc |
00000ff0  54 48 45 4e 20 7b 0a 20  20 20 20 20 20 54 45 53  |THEN {.      TES|
00001000  54 20 4c 6f 63 61 6c 73  53 61 66 65 20 54 48 45  |T LocalsSafe THE|
00001010  4e 0a 09 20 44 69 73 63  61 72 64 4e 6f 6e 4c 6f  |N.. DiscardNonLo|
00001020  63 61 6c 52 65 67 73 28  29 0a 20 20 20 20 20 20  |calRegs().      |
00001030  45 4c 53 45 0a 09 20 44  69 73 63 61 72 64 4e 6f  |ELSE.. DiscardNo|
00001040  6e 43 6f 6e 73 74 52 65  67 73 28 29 3b 0a 20 20  |nConstRegs();.  |
00001050  20 20 20 20 53 74 61 63  6b 28 73 73 29 20 7d 20  |    Stack(ss) } |
00001060  7d 0a 0a 41 4e 44 20 43  67 53 74 63 61 72 28 6e  |}..AND CgStcar(n|
00001070  2c 20 76 61 63 61 72 29  20 42 45 20 7b 0a 20 20  |, vacar) BE {.  |
00001080  20 4c 45 54 20 69 6e 64  2c 20 6b 20 3d 20 68 32  | LET ind, k = h2|
00001090  21 61 72 67 31 2c 20 68  34 21 61 72 67 31 3b 0a  |!arg1, h4!arg1;.|
000010a0  20 20 20 4c 45 54 20 72  20 3d 20 3f 3b 0a 20 20  |   LET r = ?;.  |
000010b0  20 4c 45 54 20 73 20 3d  20 30 3b 0a 20 20 20 54  | LET s = 0;.   T|
000010c0  45 53 54 20 68 31 21 61  72 67 32 3d 6b 2e 66 72  |EST h1!arg2=k.fr|
000010d0  65 67 20 54 48 45 4e 0a  20 20 20 20 20 20 72 20  |eg THEN.      r |
000010e0  3a 3d 20 4d 6f 76 65 54  6f 41 6e 79 46 52 28 61  |:= MoveToAnyFR(a|
000010f0  72 67 32 29 2b 6b 2e 69  73 61 66 72 0a 20 20 20  |rg2)+k.isafr.   |
00001100  45 4c 53 45 20 7b 0a 20  20 20 20 20 20 72 20 3a  |ELSE {.      r :|
00001110  3d 20 4d 6f 76 65 54 6f  41 6e 79 43 52 53 6f 6d  |= MoveToAnyCRSom|
00001120  65 54 69 6d 65 28 61 72  67 32 29 3b 0a 20 20 20  |eTime(arg2);.   |
00001130  20 20 20 4c 6f 63 6b 28  72 2c 20 6b 2e 72 65 67  |   Lock(r, k.reg|
00001140  29 20 7d 3b 0a 20 20 20  54 45 53 54 20 69 6e 64  |) };.   TEST ind|
00001150  3c 30 20 26 20 68 31 21  61 72 67 31 7e 3d 6b 2e  |<0 & h1!arg1~=k.|
00001160  73 68 72 65 67 20 54 48  45 4e 0a 20 20 20 20 20  |shreg THEN.     |
00001170  20 6e 2c 20 68 34 21 61  72 67 31 20 3a 3d 20 6e  | n, h4!arg1 := n|
00001180  2b 6b 2c 20 30 0a 20 20  20 45 4c 53 45 0a 20 20  |+k, 0.   ELSE.  |
00001190  20 20 20 20 4d 6f 76 65  54 6f 41 6e 79 52 28 61  |    MoveToAnyR(a|
000011a0  72 67 31 29 3b 0a 0a 20  20 20 73 20 3a 3d 20 28  |rg1);..   s := (|
000011b0  76 61 63 61 72 20 2d 3e  20 4d 6f 76 65 54 6f 41  |vacar -> MoveToA|
000011c0  6e 79 43 52 28 61 72 67  31 29 2c 0a 09 09 20 20  |nyCR(arg1),...  |
000011d0  4c 6f 61 64 43 61 72 41  64 64 28 61 72 67 31 29  |LoadCarAdd(arg1)|
000011e0  29 3b 0a 20 20 20 54 45  53 54 20 72 3e 3d 6b 2e  |);.   TEST r>=k.|
000011f0  69 73 61 66 72 20 54 48  45 4e 20 7b 0a 20 20 20  |isafr THEN {.   |
00001200  20 20 20 46 6c 75 73 68  50 65 6e 64 69 6e 67 4c  |   FlushPendingL|
00001210  6f 61 64 73 45 78 63 65  70 74 4c 6f 63 61 6c 73  |oadsExceptLocals|
00001220  28 29 3b 0a 20 20 20 20  20 20 46 6c 75 73 68 50  |();.      FlushP|
00001230  65 6e 64 69 6e 67 53 74  6f 72 65 73 45 78 63 65  |endingStoresExce|
00001240  70 74 4c 6f 63 61 6c 73  41 6e 64 49 72 65 67 73  |ptLocalsAndIregs|
00001250  28 29 3b 0a 20 20 20 20  20 20 47 65 6e 43 50 44  |();.      GenCPD|
00001260  54 28 66 2e 73 74 2c 20  72 26 31 35 2c 20 73 2c  |T(f.st, r&15, s,|
00001270  20 30 2c 20 6e 2f 42 79  74 65 73 50 65 72 57 6f  | 0, n/BytesPerWo|
00001280  72 64 29 20 7d 0a 20 20  20 45 4c 53 45 20 7b 0a  |rd) }.   ELSE {.|
00001290  20 20 20 20 20 20 41 64  64 54 6f 50 65 6e 64 69  |      AddToPendi|
000012a0  6e 67 53 74 6f 72 65 73  28 72 2c 20 6b 2e 69 72  |ngStores(r, k.ir|
000012b0  65 67 2c 20 73 2c 20 46  41 4c 53 45 2c 20 6e 2f  |eg, s, FALSE, n/|
000012c0  42 79 74 65 73 50 65 72  57 6f 72 64 29 3b 0a 20  |BytesPerWord);. |
000012d0  20 20 20 20 20 55 6e 4c  6f 63 6b 28 72 2c 20 6b  |     UnLock(r, k|
000012e0  2e 72 65 67 29 20 7d 3b  0a 20 20 20 53 74 61 63  |.reg) };.   Stac|
000012f0  6b 28 73 73 70 2d 32 29  20 7d 0a 0a 41 4e 44 20  |k(ssp-2) }..AND |
00001300  43 47 53 68 69 66 74 28  73 68 29 20 42 45 0a 20  |CGShift(sh) BE. |
00001310  20 20 54 45 53 54 20 68  32 21 61 72 67 32 3c 30  |  TEST h2!arg2<0|
00001320  20 26 20 28 6b 2e 6c 76  6c 6f 63 3c 3d 68 31 21  | & (k.lvloc<=h1!|
00001330  61 72 67 32 3c 3d 6b 2e  6c 76 6c 61 62 29 20 26  |arg2<=k.lvlab) &|
00001340  0a 09 49 73 43 6f 6e 73  74 28 61 72 67 31 29 20  |..IsConst(arg1) |
00001350  26 20 68 33 21 61 72 67  31 3d 32 20 26 20 73 68  |& h3!arg1=2 & sh|
00001360  3d 73 68 2e 61 73 6c 20  54 48 45 4e 20 7b 0a 20  |=sh.asl THEN {. |
00001370  20 20 20 20 20 68 31 21  61 72 67 32 20 3a 3d 20  |     h1!arg2 := |
00001380  68 31 21 61 72 67 32 2b  6b 2e 6c 76 73 3b 0a 20  |h1!arg2+k.lvs;. |
00001390  20 20 20 20 20 68 34 21  61 72 67 32 20 3a 3d 20  |     h4!arg2 := |
000013a0  28 68 34 21 61 72 67 32  29 3c 3c 32 3b 0a 20 20  |(h4!arg2)<<2;.  |
000013b0  20 20 20 20 53 74 61 63  6b 28 73 73 70 2d 31 29  |    Stack(ssp-1)|
000013c0  20 7d 0a 20 20 20 45 4c  53 45 20 7b 0a 20 20 20  | }.   ELSE {.   |
000013d0  20 20 20 4c 45 54 20 73  20 3d 20 3f 3b 0a 20 20  |   LET s = ?;.  |
000013e0  20 20 20 20 4c 45 54 20  64 65 66 65 72 72 65 64  |    LET deferred|
000013f0  53 68 69 66 74 20 3d 20  4e 75 6c 6c 3b 0a 20 20  |Shift = Null;.  |
00001400  20 20 20 20 4c 45 54 20  72 20 3d 20 46 69 6e 64  |    LET r = Find|
00001410  53 6f 75 72 63 65 41 6e  64 44 65 73 74 69 6e 61  |SourceAndDestina|
00001420  74 69 6f 6e 52 65 67 69  73 74 65 72 73 28 40 73  |tionRegisters(@s|
00001430  2c 20 61 72 67 32 2c 20  46 41 4c 53 45 29 3b 0a  |, arg2, FALSE);.|
00001440  20 20 20 20 20 20 54 45  53 54 20 49 73 43 6f 6e  |      TEST IsCon|
00001450  73 74 28 61 72 67 31 29  20 54 48 45 4e 0a 09 20  |st(arg1) THEN.. |
00001460  54 45 53 54 20 73 3d 72  20 54 48 45 4e 0a 09 20  |TEST s=r THEN.. |
00001470  20 20 20 64 65 66 65 72  72 65 64 53 68 69 66 74  |   deferredShift|
00001480  20 3a 3d 20 73 68 2a 33  32 2b 68 33 21 61 72 67  | := sh*32+h3!arg|
00001490  31 0a 09 20 45 4c 53 45  0a 09 20 20 20 20 53 68  |1.. ELSE..    Sh|
000014a0  69 66 74 52 65 67 69 73  74 65 72 44 53 28 72 2c  |iftRegisterDS(r,|
000014b0  20 73 2c 20 73 68 2c 20  68 33 21 61 72 67 31 29  | s, sh, h3!arg1)|
000014c0  0a 20 20 20 20 20 20 45  4c 53 45 0a 09 20 53 68  |.      ELSE.. Sh|
000014d0  69 66 74 52 65 67 69 73  74 65 72 44 53 28 72 2c  |iftRegisterDS(r,|
000014e0  20 73 2c 20 73 68 2c 20  2d 4d 6f 76 65 54 6f 41  | s, sh, -MoveToA|
000014f0  6e 79 43 52 28 61 72 67  31 29 29 3b 0a 0a 20 20  |nyCR(arg1));..  |
00001500  20 20 20 20 55 6e 6c 6f  63 6b 28 73 2c 20 6b 2e  |    Unlock(s, k.|
00001510  72 65 67 29 3b 0a 20 20  20 20 20 20 4c 6f 73 65  |reg);.      Lose|
00001520  52 28 72 2c 20 64 65 66  65 72 72 65 64 53 68 69  |R(r, deferredShi|
00001530  66 74 29 20 7d 0a 0a 41  4e 44 20 43 47 4c 6f 67  |ft) }..AND CGLog|
00001540  6f 70 28 6c 6f 67 6f 70  2c 20 72 65 61 64 41 68  |op(logop, readAh|
00001550  65 61 64 29 20 42 45 20  7b 0a 20 20 20 4c 45 54  |ead) BE {.   LET|
00001560  20 78 2c 20 79 20 3d 20  61 72 67 31 2c 20 61 72  | x, y = arg1, ar|
00001570  67 32 3b 0a 20 20 20 49  46 20 43 6c 61 73 73 28  |g2;.   IF Class(|
00001580  61 72 67 31 2c 20 54 52  55 45 29 3c 43 6c 61 73  |arg1, TRUE)<Clas|
00001590  73 28 61 72 67 32 2c 20  54 52 55 45 29 20 54 48  |s(arg2, TRUE) TH|
000015a0  45 4e 20 78 2c 20 79 20  3a 3d 20 61 72 67 32 2c  |EN x, y := arg2,|
000015b0  20 61 72 67 31 3b 0a 20  20 20 7b 20 20 4c 45 54  | arg1;.   {  LET|
000015c0  20 73 20 3d 20 49 73 49  6e 41 52 65 67 69 73 74  | s = IsInARegist|
000015d0  65 72 28 79 29 3b 0a 20  20 20 20 20 20 4c 45 54  |er(y);.      LET|
000015e0  20 72 20 3d 20 2d 31 3b  0a 20 20 20 20 20 20 4c  | r = -1;.      L|
000015f0  45 54 20 6e 65 78 74 4f  70 65 72 61 6e 64 20 3d  |ET nextOperand =|
00001600  20 3f 3b 0a 20 20 20 20  20 20 4c 45 54 20 69 73  | ?;.      LET is|
00001610  63 66 2c 20 6c 6e 70 65  6e 64 69 6e 67 20 3d 20  |cf, lnpending = |
00001620  46 41 4c 53 45 2c 20 46  41 4c 53 45 3b 0a 20 20  |FALSE, FALSE;.  |
00001630  20 20 20 20 4c 45 54 20  66 20 3d 20 56 41 4c 4f  |    LET f = VALO|
00001640  46 20 53 57 49 54 43 48  4f 4e 20 6c 6f 67 6f 70  |F SWITCHON logop|
00001650  20 49 4e 54 4f 20 7b 0a  09 20 43 41 53 45 20 73  | INTO {.. CASE s|
00001660  2e 6c 6f 67 61 6e 64 3a  20 52 45 53 55 4c 54 49  |.logand: RESULTI|
00001670  53 20 66 2e 61 6e 64 0a  09 20 43 41 53 45 20 73  |S f.and.. CASE s|
00001680  2e 6c 6f 67 6f 72 3a 09  52 45 53 55 4c 54 49 53  |.logor:.RESULTIS|
00001690  20 66 2e 6f 72 72 0a 09  20 43 41 53 45 20 73 2e  | f.orr.. CASE s.|
000016a0  65 71 76 3a 0a 09 20 43  41 53 45 20 73 2e 6e 65  |eqv:.. CASE s.ne|
000016b0  71 76 3a 09 52 45 53 55  4c 54 49 53 20 66 2e 65  |qv:.RESULTIS f.e|
000016c0  6f 72 20 7d 3b 0a 0a 20  20 20 20 20 20 49 46 20  |or };..      IF |
000016d0  72 65 61 64 41 68 65 61  64 20 54 48 45 4e 20 7b  |readAhead THEN {|
000016e0  0a 09 20 6f 70 20 3a 3d  20 52 65 61 64 4f 70 28  |.. op := ReadOp(|
000016f0  29 3b 0a 09 20 54 45 53  54 20 6f 70 3d 73 2e 6c  |);.. TEST op=s.l|
00001700  6e 20 54 48 45 4e 20 7b  0a 09 20 20 20 20 6c 6e  |n THEN {..    ln|
00001710  70 65 6e 64 69 6e 67 20  3a 3d 20 54 52 55 45 3b  |pending := TRUE;|
00001720  0a 09 20 20 20 20 6e 65  78 74 4f 70 65 72 61 6e  |..    nextOperan|
00001730  64 20 3a 3d 20 52 65 61  64 4e 28 29 3b 0a 09 20  |d := ReadN();.. |
00001740  20 20 20 6f 70 20 3a 3d  20 52 65 61 64 4f 70 28  |   op := ReadOp(|
00001750  29 3b 0a 0a 09 20 20 20  20 49 46 20 6e 65 78 74  |);...    IF next|
00001760  4f 70 65 72 61 6e 64 3d  30 20 26 0a 09 20 20 20  |Operand=0 &..   |
00001770  20 20 20 20 28 6f 70 3d  73 2e 65 71 20 7c 20 6f  |    (op=s.eq | o|
00001780  70 3d 73 2e 6e 65 29 20  26 0a 09 20 20 20 20 20  |p=s.ne) &..     |
00001790  20 20 28 6c 6f 67 6f 70  3d 73 2e 6c 6f 67 61 6e  |  (logop=s.logan|
000017a0  64 20 7c 20 6c 6f 67 6f  70 3d 73 2e 6e 65 71 76  |d | logop=s.neqv|
000017b0  29 0a 09 20 20 20 20 20  20 20 54 48 45 4e 20 69  |)..       THEN i|
000017c0  73 63 66 20 3a 3d 20 54  52 55 45 20 7d 0a 0a 09  |scf := TRUE }...|
000017d0  20 45 4c 53 45 20 49 46  20 6f 70 3d 73 2e 72 65  | ELSE IF op=s.re|
000017e0  73 20 7c 20 6f 70 3d 73  2e 66 6e 72 6e 20 54 48  |s | op=s.fnrn TH|
000017f0  45 4e 0a 09 20 20 20 20  72 20 3a 3d 20 31 20 7d  |EN..    r := 1 }|
00001800  3b 0a 0a 20 20 20 20 20  20 54 45 53 54 20 73 3d  |;..      TEST s=|
00001810  4e 75 6c 6c 20 7c 0a 09  20 20 20 28 7e 4c 6f 63  |Null |..   (~Loc|
00001820  6b 65 64 28 73 2c 20 6b  2e 72 65 67 29 20 26 20  |ked(s, k.reg) & |
00001830  5b 28 68 31 21 79 3d 6b  2e 6c 6f 63 20 26 20 68  |[(h1!y=k.loc & h|
00001840  33 21 79 3e 3d 73 73 70  2d 32 29 20 7c 0a 09 09  |3!y>=ssp-2) |...|
00001850  09 20 2f 2a 20 61 6e 20  68 65 75 72 69 73 74 69  |. /* an heuristi|
00001860  63 20 74 6f 20 61 76 6f  69 64 20 63 6f 6e 73 75  |c to avoid consu|
00001870  6d 69 6e 67 20 72 65 67  69 73 74 65 72 73 0a 09  |ming registers..|
00001880  09 09 20 20 20 20 6f 76  65 72 2d 72 61 70 69 64  |..    over-rapid|
00001890  6c 79 20 2a 2f 0a 09 09  09 20 20 68 31 21 79 3d  |ly */....  h1!y=|
000018a0  6b 2e 72 65 67 5d 29 20  54 48 45 4e 20 7b 0a 09  |k.reg]) THEN {..|
000018b0  20 73 20 3a 3d 20 4d 6f  76 65 54 6f 41 6e 79 52  | s := MoveToAnyR|
000018c0  28 79 29 3b 0a 09 20 49  46 20 7e 69 73 63 66 20  |(y);.. IF ~iscf |
000018d0  26 20 72 3c 30 20 54 48  45 4e 20 72 20 3a 3d 20  |& r<0 THEN r := |
000018e0  73 20 7d 0a 20 20 20 20  20 20 45 4c 53 45 20 7b  |s }.      ELSE {|
000018f0  0a 09 20 46 6c 75 73 68  50 65 6e 64 69 6e 67 4c  |.. FlushPendingL|
00001900  6f 61 64 73 46 6f 72 52  65 67 28 73 29 3b 0a 09  |oadsForReg(s);..|
00001910  20 4c 6f 63 6b 28 73 2c  20 6b 2e 72 65 67 29 3b  | Lock(s, k.reg);|
00001920  0a 09 20 49 46 20 7e 69  73 63 66 20 26 20 72 3c  |.. IF ~iscf & r<|
00001930  30 20 54 48 45 4e 20 72  20 3a 3d 20 4e 65 78 74  |0 THEN r := Next|
00001940  52 28 29 20 7d 3b 0a 0a  20 20 20 20 20 20 54 45  |R() };..      TE|
00001950  53 54 20 69 73 63 66 20  54 48 45 4e 20 7b 0a 09  |ST iscf THEN {..|
00001960  20 54 45 53 54 20 6c 6f  67 6f 70 3d 73 2e 6c 6f  | TEST logop=s.lo|
00001970  67 61 6e 64 20 54 48 45  4e 0a 09 20 20 20 20 66  |gand THEN..    f|
00001980  2c 20 72 20 3a 3d 20 66  2e 74 73 74 73 2c 20 30  |, r := f.tsts, 0|
00001990  0a 09 20 45 4c 53 45 0a  09 20 20 20 20 66 2c 20  |.. ELSE..    f, |
000019a0  72 20 3a 3d 20 66 2e 74  65 71 73 2c 20 30 0a 09  |r := f.teqs, 0..|
000019b0  20 49 46 20 28 70 65 6e  64 69 6e 67 4d 61 73 6b  | IF (pendingMask|
000019c0  20 7e 3d 20 6d 2e 61 6c  77 61 79 73 29 20 54 48  | ~= m.always) TH|
000019d0  45 4e 20 7b 0a 09 20 20  20 20 53 74 6f 72 65 28  |EN {..    Store(|
000019e0  30 2c 20 73 73 70 2d 34  29 3b 0a 09 20 20 20 20  |0, ssp-4);..    |
000019f0  46 6c 75 73 68 50 65 6e  64 69 6e 67 53 74 6f 72  |FlushPendingStor|
00001a00  65 73 28 29 0a 09 20 7d  0a 20 20 20 20 20 20 7d  |es().. }.      }|
00001a10  20 45 4c 53 45 20 7b 0a  09 20 46 6c 75 73 68 50  | ELSE {.. FlushP|
00001a20  65 6e 64 69 6e 67 55 73  65 73 4f 66 52 65 67 28  |endingUsesOfReg(|
00001a30  72 29 3b 0a 09 20 49 46  20 66 3d 66 2e 61 6e 64  |r);.. IF f=f.and|
00001a40  20 26 20 49 73 43 6f 6e  73 74 28 78 29 20 26 20  | & IsConst(x) & |
00001a50  45 69 67 68 74 42 69 74  73 4f 72 46 65 77 65 72  |EightBitsOrFewer|
00001a60  28 7e 68 33 21 78 29 20  54 48 45 4e 20 7b 0a 09  |(~h3!x) THEN {..|
00001a70  20 20 20 20 66 20 3a 3d  20 66 2e 62 69 63 3b 20  |    f := f.bic; |
00001a80  68 33 21 78 20 3a 3d 20  7e 68 33 21 78 20 7d 20  |h3!x := ~h3!x } |
00001a90  7d 3b 0a 0a 20 20 20 20  20 20 47 65 6e 46 44 53  |};..      GenFDS|
00001aa0  28 66 2c 20 72 2c 20 73  2c 20 78 29 3b 0a 20 20  |(f, r, s, x);.  |
00001ab0  20 20 20 20 49 46 20 6c  6f 67 6f 70 3d 73 2e 65  |    IF logop=s.e|
00001ac0  71 76 20 54 48 45 4e 20  47 65 6e 52 52 28 66 2e  |qv THEN GenRR(f.|
00001ad0  6d 76 6e 2c 20 72 2c 20  30 2c 20 72 29 0a 20 20  |mvn, r, 0, r).  |
00001ae0  20 20 20 20 55 6e 6c 6f  63 6b 28 73 2c 20 6b 2e  |    Unlock(s, k.|
00001af0  72 65 67 29 3b 0a 20 20  20 20 20 20 54 45 53 54  |reg);.      TEST|
00001b00  20 72 7e 3d 30 20 54 48  45 4e 0a 09 20 4c 6f 73  | r~=0 THEN.. Los|
00001b10  65 28 72 2c 20 6b 2e 72  65 67 29 0a 20 20 20 20  |e(r, k.reg).    |
00001b20  20 20 45 4c 53 45 0a 09  20 53 74 61 63 6b 28 73  |  ELSE.. Stack(s|
00001b30  73 70 2d 31 29 3b 0a 0a  20 20 20 20 20 20 49 46  |sp-1);..      IF|
00001b40  20 6c 6e 70 65 6e 64 69  6e 67 20 54 48 45 4e 20  | lnpending THEN |
00001b50  4c 6f 61 64 28 6b 2e 6e  75 6d 62 65 72 2c 20 6e  |Load(k.number, n|
00001b60  65 78 74 4f 70 65 72 61  6e 64 29 3b 0a 20 20 20  |extOperand);.   |
00001b70  20 20 20 49 46 20 69 73  63 66 20 54 48 45 4e 20  |   IF iscf THEN |
00001b80  43 47 52 65 6c 6f 70 58  28 6f 70 2c 20 52 65 61  |CGRelopX(op, Rea|
00001b90  64 4f 70 28 29 2c 20 46  41 4c 53 45 29 20 7d 20  |dOp(), FALSE) } |
00001ba0  7d 0a 0a 41 4e 44 20 43  47 52 65 6c 6f 70 28 72  |}..AND CGRelop(r|
00001bb0  65 6c 6f 70 2c 20 6e 65  78 74 6f 70 29 20 42 45  |elop, nextop) BE|
00001bc0  0a 20 20 20 43 47 52 65  6c 6f 70 58 28 72 65 6c  |.   CGRelopX(rel|
00001bd0  6f 70 2c 20 6e 65 78 74  6f 70 2c 20 54 52 55 45  |op, nextop, TRUE|
00001be0  29 0a 0a 41 4e 44 20 43  47 52 65 6c 6f 70 58 28  |)..AND CGRelopX(|
00001bf0  72 65 6c 6f 70 2c 20 6e  65 78 74 6f 70 2c 20 63  |relop, nextop, c|
00001c00  6f 6d 70 6e 65 65 64 65  64 29 20 42 45 20 7b 0a  |ompneeded) BE {.|
00001c10  20 20 20 6f 70 20 3a 3d  20 6e 65 78 74 6f 70 3b  |   op := nextop;|
00001c20  0a 20 20 20 54 45 53 54  20 6f 70 3d 73 2e 6a 74  |.   TEST op=s.jt|
00001c30  20 7c 20 6f 70 3d 73 2e  6a 66 20 54 48 45 4e 20  | | op=s.jf THEN |
00001c40  7b 0a 20 20 20 20 20 20  4c 45 54 20 63 20 3d 20  |{.      LET c = |
00001c50  3f 3b 0a 20 20 20 20 20  20 4c 45 54 20 6c 20 3d  |?;.      LET l =|
00001c60  20 52 65 61 64 4c 28 29  3b 0a 20 20 20 20 20 20  | ReadL();.      |
00001c70  4c 45 54 20 78 20 3d 20  54 72 61 6e 73 66 65 72  |LET x = Transfer|
00001c80  72 65 64 4c 61 62 65 6c  28 6c 29 3b 0a 0a 20 20  |redLabel(l);..  |
00001c90  20 20 20 20 54 45 53 54  20 78 7e 3d 30 20 54 48  |    TEST x~=0 TH|
00001ca0  45 4e 20 7b 0a 09 20 53  74 6f 72 65 28 30 2c 20  |EN {.. Store(0, |
00001cb0  73 73 70 2d 33 29 3b 0a  09 20 46 6c 75 73 68 50  |ssp-3);.. FlushP|
00001cc0  65 6e 64 69 6e 67 53 74  6f 72 65 73 28 29 20 7d  |endingStores() }|
00001cd0  0a 20 20 20 20 20 20 45  4c 53 45 0a 09 20 46 6c  |.      ELSE.. Fl|
00001ce0  75 73 68 50 65 6e 64 69  6e 67 53 74 6f 72 65 73  |ushPendingStores|
00001cf0  45 78 63 65 70 74 4c 6f  63 61 6c 73 28 29 3b 0a  |ExceptLocals();.|
00001d00  0a 20 20 20 20 20 20 63  20 3a 3d 20 43 6f 6e 64  |.      c := Cond|
00001d10  69 74 69 6f 6e 58 28 72  65 6c 6f 70 2c 20 6f 70  |itionX(relop, op|
00001d20  3d 73 2e 6a 74 2c 20 63  6f 6d 70 6e 65 65 64 65  |=s.jt, compneede|
00001d30  64 29 3b 0a 20 20 20 20  20 20 53 61 76 65 53 74  |d);.      SaveSt|
00001d40  61 74 65 46 6f 72 4c 61  62 28 6c 29 3b 0a 2f 2f  |ateForLab(l);.//|
00001d50  20 20 20 20 49 46 20 78  7e 3d 30 20 54 48 45 4e  |    IF x~=0 THEN|
00001d60  20 44 65 6c 4c 6f 63 73  41 62 6f 76 65 28 30 2c  | DelLocsAbove(0,|
00001d70  20 46 41 4c 53 45 29 3b  0a 20 20 20 20 20 20 43  | FALSE);.      C|
00001d80  6f 6e 64 4a 75 6d 70 28  63 2c 20 6c 29 3b 0a 20  |ondJump(c, l);. |
00001d90  20 20 20 20 20 49 46 20  72 65 67 54 65 73 74 65  |     IF regTeste|
00001da0  64 41 67 61 69 6e 73 74  5a 65 72 6f 7e 3d 4e 75  |dAgainstZero~=Nu|
00001db0  6c 6c 20 26 20 63 3d 6d  2e 6e 65 20 26 20 63 6f  |ll & c=m.ne & co|
00001dc0  6d 70 6e 65 65 64 65 64  20 54 48 45 4e 0a 09 20  |mpneeded THEN.. |
00001dd0  41 64 64 52 65 67 49 6e  66 6f 28 6b 2e 72 65 67  |AddRegInfo(k.reg|
00001de0  2c 20 72 65 67 54 65 73  74 65 64 41 67 61 69 6e  |, regTestedAgain|
00001df0  73 74 5a 65 72 6f 2c 20  6b 2e 6e 75 6d 62 65 72  |stZero, k.number|
00001e00  2c 20 30 29 3b 0a 20 20  20 20 20 20 63 6f 75 6e  |, 0);.      coun|
00001e10  74 46 6c 61 67 20 3a 3d  20 63 6f 75 6e 74 69 6e  |tFlag := countin|
00001e20  67 3b 0a 20 20 20 20 20  20 6f 70 20 3a 3d 20 52  |g;.      op := R|
00001e30  65 61 64 4f 70 28 29 20  7d 0a 20 20 20 45 4c 53  |eadOp() }.   ELS|
00001e40  45 20 7b 0a 20 20 20 20  20 20 4c 45 54 20 72 20  |E {.      LET r |
00001e50  3d 20 4e 65 78 74 52 28  29 3b 0a 20 20 20 20 20  |= NextR();.     |
00001e60  20 4c 6f 63 6b 28 72 2c  20 6b 2e 72 65 67 29 3b  | Lock(r, k.reg);|
00001e70  0a 20 20 20 20 20 20 49  46 20 70 65 6e 64 69 6e  |.      IF pendin|
00001e80  67 4c 61 62 7e 3d 4e 75  6c 6c 20 54 48 45 4e 0a  |gLab~=Null THEN.|
00001e90  09 20 46 6c 75 73 68 50  65 6e 64 69 6e 67 49 6e  |. FlushPendingIn|
00001ea0  73 74 73 28 4e 75 6c 6c  2c 20 46 41 4c 53 45 29  |sts(Null, FALSE)|
00001eb0  3b 0a 20 20 20 20 20 20  47 65 6e 46 31 4b 28 66  |;.      GenF1K(f|
00001ec0  2e 6d 6f 76 2c 20 72 2c  20 30 2c 20 30 29 3b 0a  |.mov, r, 0, 0);.|
00001ed0  20 20 20 20 20 20 46 31  49 6e 73 74 28 66 2e 6d  |      F1Inst(f.m|
00001ee0  76 6e 2c 20 72 2c 20 30  2c 20 72 2c 20 30 2c 20  |vn, r, 0, r, 0, |
00001ef0  4e 75 6c 6c 2c 20 30 2c  0a 09 20 20 20 20 20 63  |Null, 0,..     c|
00001f00  6f 6e 64 69 74 69 6f 6e  58 28 72 65 6c 6f 70 2c  |onditionX(relop,|
00001f10  20 54 52 55 45 2c 20 63  6f 6d 70 6e 65 65 64 65  | TRUE, compneede|
00001f20  64 29 29 3b 0a 20 20 20  20 20 20 4c 6f 61 64 28  |d));.      Load(|
00001f30  6b 2e 72 65 67 2c 20 72  29 3b 0a 20 20 20 20 20  |k.reg, r);.     |
00001f40  20 55 6e 4c 6f 63 6b 28  72 2c 20 6b 2e 72 65 67  | UnLock(r, k.reg|
00001f50  29 20 7d 20 7d 0a 0a 41  4e 44 20 43 6f 6e 64 69  |) } }..AND Condi|
00001f60  74 69 6f 6e 28 72 65 6c  6f 70 2c 20 62 29 20 3d  |tion(relop, b) =|
00001f70  20 43 6f 6e 64 69 74 69  6f 6e 58 28 72 65 6c 6f  | ConditionX(relo|
00001f80  70 2c 20 62 2c 20 54 52  55 45 29 0a 0a 41 4e 44  |p, b, TRUE)..AND|
00001f90  20 43 6f 6e 64 69 74 69  6f 6e 58 28 72 65 6c 6f  | ConditionX(relo|
00001fa0  70 2c 20 62 2c 20 63 6f  6d 70 6e 65 65 64 65 64  |p, b, compneeded|
00001fb0  29 20 3d 20 56 41 4c 4f  46 20 7b 0a 20 20 20 4c  |) = VALOF {.   L|
00001fc0  45 54 20 78 2c 20 79 20  3d 20 61 72 67 31 2c 20  |ET x, y = arg1, |
00001fd0  61 72 67 32 3b 0a 20 20  20 4c 45 54 20 6b 2c 20  |arg2;.   LET k, |
00001fe0  6d 65 72 67 65 6b 20 3d  20 30 2c 20 46 41 4c 53  |mergek = 0, FALS|
00001ff0  45 3b 0a 20 20 20 4c 45  54 20 66 20 3d 20 66 2e  |E;.   LET f = f.|
00002000  63 6d 70 73 3b 0a 0a 20  20 20 49 46 20 63 6f 6d  |cmps;..   IF com|
00002010  70 6e 65 65 64 65 64 20  54 48 45 4e 20 7b 0a 20  |pneeded THEN {. |
00002020  20 20 20 20 20 4c 45 54  20 69 31 2c 20 69 32 20  |     LET i1, i2 |
00002030  3d 20 68 32 21 61 72 67  31 2c 20 68 32 21 61 72  |= h2!arg1, h2!ar|
00002040  67 32 3b 0a 20 20 20 20  20 20 49 46 20 69 31 3c  |g2;.      IF i1<|
00002050  30 20 26 20 68 34 21 61  72 67 31 7e 3d 30 20 26  |0 & h4!arg1~=0 &|
00002060  20 68 31 21 61 72 67 31  7e 3d 6b 2e 73 68 72 65  | h1!arg1~=k.shre|
00002070  67 20 26 0a 09 20 69 32  3c 30 20 26 20 68 34 21  |g &.. i2<0 & h4!|
00002080  61 72 67 32 7e 3d 30 20  26 20 68 31 21 61 72 67  |arg2~=0 & h1!arg|
00002090  32 7e 3d 6b 2e 73 68 72  65 67 20 54 48 45 4e 20  |2~=k.shreg THEN |
000020a0  7b 0a 09 20 6b 20 3a 3d  20 68 34 21 61 72 67 31  |{.. k := h4!arg1|
000020b0  2d 68 34 21 61 72 67 32  3b 0a 09 20 68 34 21 61  |-h4!arg2;.. h4!a|
000020c0  72 67 31 2c 20 68 34 21  61 72 67 32 20 3a 3d 20  |rg1, h4!arg2 := |
000020d0  30 2c 20 30 3b 0a 09 20  6d 65 72 67 65 6b 20 3a  |0, 0;.. mergek :|
000020e0  3d 20 54 52 55 45 20 7d  3b 0a 0a 20 20 20 20 20  |= TRUE };..     |
000020f0  20 49 46 20 43 6c 61 73  73 28 61 72 67 31 2c 20  | IF Class(arg1, |
00002100  54 52 55 45 29 3c 43 6c  61 73 73 28 61 72 67 32  |TRUE)<Class(arg2|
00002110  2c 20 54 52 55 45 29 20  54 48 45 4e 20 7b 0a 09  |, TRUE) THEN {..|
00002120  20 78 2c 20 79 20 3a 3d  20 61 72 67 32 2c 20 61  | x, y := arg2, a|
00002130  72 67 31 3b 0a 09 20 72  65 6c 6f 70 20 3a 3d 20  |rg1;.. relop := |
00002140  52 65 76 65 72 73 65 28  72 65 6c 6f 70 29 3b 0a  |Reverse(relop);.|
00002150  09 20 6b 20 3a 3d 20 2d  6b 20 7d 3b 0a 0a 20 20  |. k := -k };..  |
00002160  20 2f 2a 20 4e 6f 77 20  61 20 62 69 74 20 6f 66  | /* Now a bit of|
00002170  20 73 70 65 63 69 61 6c  20 63 61 73 65 20 64 65  | special case de|
00002180  74 65 63 74 69 6f 6e 20  77 68 69 63 68 20 73 61  |tection which sa|
00002190  79 73 20 69 66 20 62 6f  74 68 0a 20 20 20 20 20  |ys if both.     |
000021a0  20 6f 70 65 72 61 6e 64  73 20 61 72 65 20 69 6e  | operands are in|
000021b0  20 74 68 65 20 73 74 61  63 6b 20 61 6e 64 20 69  | the stack and i|
000021c0  6e 20 61 64 6a 61 63 65  6e 74 20 6c 6f 63 61 74  |n adjacent locat|
000021d0  69 6f 6e 73 2c 0a 20 20  20 20 20 20 75 73 65 20  |ions,.      use |
000021e0  61 20 4c 44 4d 20 74 6f  20 65 78 74 72 61 63 74  |a LDM to extract|
000021f0  20 74 68 65 6d 2e 20 20  54 68 69 73 20 69 73 20  | them.  This is |
00002200  77 6f 72 74 68 20 64 6f  69 6e 67 20 65 76 65 6e  |worth doing even|
00002210  0a 20 20 20 20 20 20 69  66 20 74 68 65 72 65 20  |.      if there |
00002220  69 73 20 64 65 66 65 72  6d 65 6e 74 20 6f 66 20  |is deferment of |
00002230  72 65 67 69 73 74 65 72  20 6c 6f 61 64 69 6e 67  |register loading|
00002240  2c 20 62 65 63 61 75 73  65 20 69 74 0a 20 20 20  |, because it.   |
00002250  20 20 20 63 61 6e 20 65  6e 73 75 72 65 20 74 68  |   can ensure th|
00002260  61 74 20 72 65 67 69 73  74 65 72 73 20 67 65 74  |at registers get|
00002270  20 61 6c 6c 6f 63 61 74  65 64 20 74 68 65 20 72  | allocated the r|
00002280  69 67 68 74 20 77 61 79  0a 20 20 20 20 20 20 72  |ight way.      r|
00002290  6f 75 6e 64 20 28 61 6e  64 20 69 74 20 77 69 6c  |ound (and it wil|
000022a0  6c 20 6f 66 74 65 6e 20  62 65 20 61 70 70 6c 69  |l often be appli|
000022b0  63 61 62 6c 65 20 74 6f  20 46 4f 52 20 6c 6f 6f  |cable to FOR loo|
000022c0  70 73 29 0a 20 20 20 2a  2f 0a 20 20 20 20 20 20  |ps).   */.      |
000022d0  49 46 20 49 73 49 6e 54  68 65 53 74 61 63 6b 28  |IF IsInTheStack(|
000022e0  78 29 20 26 20 49 73 49  6e 54 68 65 53 74 61 63  |x) & IsInTheStac|
000022f0  6b 28 79 29 20 26 20 75  73 65 73 46 72 61 6d 65  |k(y) & usesFrame|
00002300  20 26 20 72 65 6c 6f 70  3c 73 2e 66 61 64 64 20  | & relop<s.fadd |
00002310  54 48 45 4e 20 7b 0a 09  20 4c 45 54 20 6c 6f 63  |THEN {.. LET loc|
00002320  31 2c 20 6c 6f 63 32 20  3d 20 68 33 21 78 2c 20  |1, loc2 = h3!x, |
00002330  68 33 21 79 3b 0a 09 20  49 46 20 5b 6c 6f 63 31  |h3!y;.. IF [loc1|
00002340  3d 28 6c 6f 63 32 2b 31  29 20 7c 20 6c 6f 63 32  |=(loc2+1) | loc2|
00002350  3d 28 6c 6f 63 31 2b 31  29 5d 20 26 0a 09 20 20  |=(loc1+1)] &..  |
00002360  20 20 4c 6f 6f 6b 46 6f  72 28 78 2c 20 4e 6f 74  |  LookFor(x, Not|
00002370  41 64 64 72 29 3d 4e 75  6c 6c 20 26 0a 09 20 20  |Addr)=Null &..  |
00002380  20 20 4c 6f 6f 6b 46 6f  72 28 79 2c 20 4e 6f 74  |  LookFor(y, Not|
00002390  41 64 64 72 29 3d 4e 75  6c 6c 20 54 48 45 4e 20  |Addr)=Null THEN |
000023a0  7b 0a 09 20 20 20 20 4c  45 54 20 72 2c 20 73 20  |{..    LET r, s |
000023b0  3d 20 4e 65 78 74 52 28  29 2c 20 3f 3b 0a 09 20  |= NextR(), ?;.. |
000023c0  20 20 20 4c 45 54 20 62  20 3d 20 72 2e 30 3b 0a  |   LET b = r.0;.|
000023d0  09 20 20 20 20 4c 45 54  20 74 6f 70 6c 6f 63 20  |.    LET toploc |
000023e0  3d 20 6c 6f 63 31 3e 6c  6f 63 32 20 2d 3e 20 6c  |= loc1>loc2 -> l|
000023f0  6f 63 31 2b 31 2c 20 6c  6f 63 32 2b 31 3b 0a 09  |oc1+1, loc2+1;..|
00002400  20 20 20 20 4c 45 54 20  77 62 20 3d 20 66 2e 77  |    LET wb = f.w|
00002410  62 3b 0a 0a 09 20 20 20  20 4c 6f 63 6b 28 72 2c  |b;...    Lock(r,|
00002420  20 6b 2e 72 65 67 29 3b  20 73 20 3a 3d 20 4e 65  | k.reg); s := Ne|
00002430  78 74 52 28 29 3b 20 55  6e 6c 6f 63 6b 28 72 2c  |xtR(); Unlock(r,|
00002440  20 6b 2e 72 65 67 29 3b  0a 09 20 20 20 20 49 46  | k.reg);..    IF|
00002450  20 28 28 28 72 2d 73 29  20 4e 45 51 56 20 28 6c  | (((r-s) NEQV (l|
00002460  6f 63 31 2d 6c 6f 63 32  29 29 20 4e 45 51 56 20  |oc1-loc2)) NEQV |
00002470  6e 65 78 74 53 74 61 63  6b 57 6f 72 64 29 3c 30  |nextStackWord)<0|
00002480  20 54 48 45 4e 20 7b 0a  09 20 20 20 20 2f 2f 20  | THEN {..    // |
00002490  74 68 65 20 72 65 67 69  73 74 65 72 73 20 68 61  |the registers ha|
000024a0  76 65 20 62 65 65 6e 20  61 6c 6c 6f 63 61 74 65  |ve been allocate|
000024b0  64 20 74 68 65 20 77 72  6f 6e 67 0a 09 20 20 20  |d the wrong..   |
000024c0  20 2f 2f 20 77 61 79 20  72 6f 75 6e 64 20 2d 20  | // way round - |
000024d0  73 77 61 70 20 74 68 65  6d 0a 09 20 20 20 20 20  |swap them..     |
000024e0  20 20 4c 45 54 20 74 20  3d 20 72 3b 20 72 20 3a  |  LET t = r; r :|
000024f0  3d 20 73 3b 20 73 20 3a  3d 20 74 20 7d 3b 0a 0a  |= s; s := t };..|
00002500  09 20 20 20 20 54 45 53  54 20 74 6f 70 6c 6f 63  |.    TEST toploc|
00002510  3d 54 4f 53 4f 66 66 73  65 74 20 54 48 45 4e 0a  |=TOSOffset THEN.|
00002520  09 20 20 20 20 20 20 20  62 2c 20 77 62 20 3a 3d  |.       b, wb :=|
00002530  20 72 2e 74 73 2c 20 30  0a 09 20 20 20 20 45 4c  | r.ts, 0..    EL|
00002540  53 45 20 7b 0a 09 20 20  20 20 20 20 20 49 46 20  |SE {..       IF |
00002550  74 6f 70 6c 6f 63 7e 3d  52 30 4f 66 66 73 65 74  |toploc~=R0Offset|
00002560  20 54 48 45 4e 0a 09 09  20 20 53 65 74 52 74 6f  | THEN...  SetRto|
00002570  52 70 6c 75 73 4b 28 72  2e 30 2c 20 72 2e 70 2c  |RplusK(r.0, r.p,|
00002580  20 6e 65 78 74 53 74 61  63 6b 57 6f 72 64 2a 74  | nextStackWord*t|
00002590  6f 70 6c 6f 63 29 3b 0a  09 20 20 20 20 20 20 20  |oploc);..       |
000025a0  52 30 4f 66 66 73 65 74  20 3a 3d 20 74 6f 70 6c  |R0Offset := topl|
000025b0  6f 63 2d 32 20 7d 3b 0a  0a 09 20 20 20 20 46 34  |oc-2 };...    F4|
000025c0  49 6e 73 74 28 66 2e 6c  64 6d 2c 20 62 2c 20 28  |Inst(f.ldm, b, (|
000025d0  31 3c 3c 72 29 2b 28 31  3c 3c 73 29 2c 20 72 65  |1<<r)+(1<<s), re|
000025e0  76 65 72 73 65 64 53 74  61 63 6b 20 2d 3e 20 66  |versedStack -> f|
000025f0  2e 70 72 65 75 70 2b 77  62 2c 0a 09 09 09 09 09  |.preup+wb,......|
00002600  09 09 20 20 20 20 20 66  2e 70 72 65 64 6f 77 6e  |..     f.predown|
00002610  2b 77 62 29 3b 0a 0a 09  20 20 20 20 4d 6f 76 65  |+wb);...    Move|
00002620  53 54 6f 52 28 6b 2e 72  65 67 2c 20 72 2c 20 6b  |SToR(k.reg, r, k|
00002630  2e 6c 6f 63 2c 20 68 33  21 78 29 3b 0a 09 20 20  |.loc, h3!x);..  |
00002640  20 20 4d 6f 76 65 53 54  6f 52 28 6b 2e 72 65 67  |  MoveSToR(k.reg|
00002650  2c 20 73 2c 20 6b 2e 6c  6f 63 2c 20 68 33 21 79  |, s, k.loc, h3!y|
00002660  29 3b 0a 09 20 20 20 20  68 31 21 78 2c 20 68 33  |);..    h1!x, h3|
00002670  21 78 20 3a 3d 20 6b 2e  72 65 67 2c 20 72 3b 0a  |!x := k.reg, r;.|
00002680  09 20 20 20 20 68 31 21  79 2c 20 68 33 21 79 20  |.    h1!y, h3!y |
00002690  3a 3d 20 6b 2e 72 65 67  2c 20 73 20 7d 20 7d 3b  |:= k.reg, s } };|
000026a0  0a 0a 20 20 20 20 20 20  49 46 20 6d 65 72 67 65  |..      IF merge|
000026b0  6b 20 54 48 45 4e 20 68  34 21 78 20 3a 3d 20 6b  |k THEN h4!x := k|
000026c0  3b 0a 20 20 20 20 20 20  72 65 67 54 65 73 74 65  |;.      regTeste|
000026d0  64 41 67 61 69 6e 73 74  5a 65 72 6f 20 3a 3d 20  |dAgainstZero := |
000026e0  4e 75 6c 6c 3b 0a 20 20  20 20 20 20 54 45 53 54  |Null;.      TEST|
000026f0  20 72 65 6c 6f 70 3e 73  2e 66 61 64 64 20 54 48  | relop>s.fadd TH|
00002700  45 4e 0a 09 20 43 47 46  43 6f 6d 70 61 72 65 28  |EN.. CGFCompare(|
00002710  79 2c 20 78 29 0a 20 20  20 20 20 20 45 4c 53 45  |y, x).      ELSE|
00002720  20 7b 0a 09 20 4c 45 54  20 72 20 3d 20 3f 3b 0a  | {.. LET r = ?;.|
00002730  09 20 4c 45 54 20 69 6e  64 20 3d 20 68 32 21 79  |. LET ind = h2!y|
00002740  3b 0a 09 20 49 46 20 30  3c 69 6e 64 3c 43 61 72  |;.. IF 0<ind<Car|
00002750  4d 61 72 6b 20 26 20 49  73 43 6f 6e 73 74 28 78  |Mark & IsConst(x|
00002760  29 20 26 0a 09 20 20 20  20 28 72 65 6c 6f 70 3d  |) &..    (relop=|
00002770  73 2e 65 71 20 7c 20 72  65 6c 6f 70 3d 73 2e 6e  |s.eq | relop=s.n|
00002780  65 29 20 54 48 45 4e 20  7b 0a 09 20 20 20 20 4c  |e) THEN {..    L|
00002790  45 54 20 73 69 7a 65 20  3d 20 69 6e 64 2f 33 32  |ET size = ind/32|
000027a0  3b 0a 09 20 20 20 20 4c  45 54 20 73 68 69 66 74  |;..    LET shift|
000027b0  20 3d 20 69 6e 64 20 52  45 4d 20 33 32 3b 0a 09  | = ind REM 32;..|
000027c0  20 20 20 20 4c 45 54 20  6b 20 3d 20 68 33 21 78  |    LET k = h3!x|
000027d0  3b 0a 09 20 20 20 20 49  46 20 28 73 69 7a 65 3c  |;..    IF (size<|
000027e0  3d 38 20 26 20 6b 3d 30  29 20 7c 20 28 73 69 7a  |=8 & k=0) | (siz|
000027f0  65 3d 31 20 26 20 6b 3d  31 29 20 54 48 45 4e 20  |e=1 & k=1) THEN |
00002800  7b 0a 09 20 20 20 20 20  20 20 68 32 21 79 20 3a  |{..       h2!y :|
00002810  3d 20 30 3b 0a 09 20 20  20 20 20 20 20 68 33 21  |= 0;..       h3!|
00002820  78 20 3a 3d 20 5b 28 2d  31 29 3e 3e 28 33 32 2d  |x := [(-1)>>(32-|
00002830  73 69 7a 65 29 5d 3c 3c  73 68 69 66 74 3b 0a 09  |size)]<<shift;..|
00002840  20 20 20 20 20 20 20 49  46 20 6b 3d 31 20 54 48  |       IF k=1 TH|
00002850  45 4e 20 62 20 3a 3d 20  7e 62 3b 0a 09 20 20 20  |EN b := ~b;..   |
00002860  20 20 20 20 66 20 3a 3d  20 66 2e 74 73 74 73 20  |    f := f.tsts |
00002870  7d 20 7d 3b 0a 0a 09 20  72 20 3a 3d 20 4d 6f 76  |} };... r := Mov|
00002880  65 54 6f 41 6e 79 43 52  28 79 29 3b 0a 09 20 49  |eToAnyCR(y);.. I|
00002890  46 20 49 73 43 6f 6e 73  74 28 78 29 20 26 20 66  |F IsConst(x) & f|
000028a0  3d 66 2e 63 6d 70 73 20  54 48 45 4e 20 7b 0a 09  |=f.cmps THEN {..|
000028b0  20 20 20 20 4c 45 54 20  6b 20 3d 20 68 33 21 78  |    LET k = h3!x|
000028c0  3b 0a 09 20 20 20 20 4c  45 54 20 6d 20 3d 20 4d  |;..    LET m = M|
000028d0  61 73 6b 46 6f 72 28 72  65 6c 6f 70 2c 20 62 29  |askFor(relop, b)|
000028e0  3b 0a 09 20 20 20 20 49  46 20 6b 3d 30 20 54 48  |;..    IF k=0 TH|
000028f0  45 4e 20 72 65 67 54 65  73 74 65 64 41 67 61 69  |EN regTestedAgai|
00002900  6e 73 74 5a 65 72 6f 20  3a 3d 20 72 3b 0a 09 20  |nstZero := r;.. |
00002910  20 20 20 49 46 20 4c 6f  6f 6b 46 6f 72 53 4c 6f  |   IF LookForSLo|
00002920  63 28 4e 6f 74 41 64 64  72 2c 20 6b 2e 6e 75 6d  |c(NotAddr, k.num|
00002930  62 65 72 2c 20 6b 29 3d  4e 75 6c 6c 20 54 48 45  |ber, k)=Null THE|
00002940  4e 20 7b 0a 09 20 20 20  20 20 20 20 43 6f 6d 70  |N {..       Comp|
00002950  61 72 65 41 67 61 69 6e  73 74 4b 28 72 2c 20 6b  |areAgainstK(r, k|
00002960  2c 20 20 6d 29 3b 0a 09  20 20 20 20 20 20 20 53  |,  m);..       S|
00002970  74 61 63 6b 28 73 73 70  2d 32 29 3b 0a 09 20 20  |tack(ssp-2);..  |
00002980  20 20 20 20 20 52 45 53  55 4c 54 49 53 20 6d 20  |     RESULTIS m |
00002990  7d 20 7d 3b 0a 09 20 47  65 6e 46 28 66 2c 20 72  |} };.. GenF(f, r|
000029a0  2c 20 78 29 20 7d 20 7d  3b 0a 20 20 20 53 74 61  |, x) } };.   Sta|
000029b0  63 6b 28 73 73 70 2d 32  29 3b 0a 20 20 20 52 45  |ck(ssp-2);.   RE|
000029c0  53 55 4c 54 49 53 20 4d  61 73 6b 46 6f 72 28 72  |SULTIS MaskFor(r|
000029d0  65 6c 6f 70 2c 20 62 29  20 7d 0a 0a 41 4e 44 20  |elop, b) }..AND |
000029e0  4d 61 73 6b 46 6f 72 28  72 65 6c 6f 70 2c 20 62  |MaskFor(relop, b|
000029f0  29 20 3d 20 56 41 4c 4f  46 20 53 57 49 54 43 48  |) = VALOF SWITCH|
00002a00  4f 4e 20 72 65 6c 6f 70  20 49 4e 54 4f 20 7b 0a  |ON relop INTO {.|
00002a10  20 20 20 43 41 53 45 20  73 2e 6e 65 3a 0a 20 20  |   CASE s.ne:.  |
00002a20  20 43 41 53 45 20 73 2e  66 6e 65 3a 20 62 20 3a  | CASE s.fne: b :|
00002a30  3d 20 7e 62 3b 0a 20 20  20 43 41 53 45 20 73 2e  |= ~b;.   CASE s.|
00002a40  65 71 3a 0a 20 20 20 43  41 53 45 20 73 2e 66 65  |eq:.   CASE s.fe|
00002a50  71 3a 20 52 45 53 55 4c  54 49 53 20 62 20 2d 3e  |q: RESULTIS b ->|
00002a60  20 6d 2e 65 71 2c 20 6d  2e 6e 65 0a 0a 20 20 20  | m.eq, m.ne..   |
00002a70  43 41 53 45 20 73 2e 6c  73 3a 0a 20 20 20 43 41  |CASE s.ls:.   CA|
00002a80  53 45 20 73 2e 66 6c 73  3a 20 62 20 3a 3d 20 7e  |SE s.fls: b := ~|
00002a90  62 3b 0a 20 20 20 43 41  53 45 20 73 2e 67 65 3a  |b;.   CASE s.ge:|
00002aa0  0a 20 20 20 43 41 53 45  20 73 2e 66 67 65 3a 20  |.   CASE s.fge: |
00002ab0  52 45 53 55 4c 54 49 53  20 62 20 2d 3e 20 6d 2e  |RESULTIS b -> m.|
00002ac0  67 65 2c 20 6d 2e 6c 74  0a 0a 20 20 20 43 41 53  |ge, m.lt..   CAS|
00002ad0  45 20 73 2e 67 72 3a 0a  20 20 20 43 41 53 45 20  |E s.gr:.   CASE |
00002ae0  73 2e 66 67 72 3a 20 62  20 3a 3d 20 7e 62 3b 0a  |s.fgr: b := ~b;.|
00002af0  20 20 20 43 41 53 45 20  73 2e 6c 65 3a 0a 20 20  |   CASE s.le:.  |
00002b00  20 43 41 53 45 20 73 2e  66 6c 65 3a 20 52 45 53  | CASE s.fle: RES|
00002b10  55 4c 54 49 53 20 62 20  2d 3e 20 6d 2e 6c 65 2c  |ULTIS b -> m.le,|
00002b20  20 6d 2e 67 74 0a 0a 20  20 20 43 41 53 45 20 73  | m.gt..   CASE s|
00002b30  2e 6c 6c 73 3a 20 62 20  3a 3d 20 7e 62 3b 0a 20  |.lls: b := ~b;. |
00002b40  20 20 43 41 53 45 20 73  2e 6c 67 65 3a 20 52 45  |  CASE s.lge: RE|
00002b50  53 55 4c 54 49 53 20 62  20 2d 3e 20 6d 2e 67 65  |SULTIS b -> m.ge|
00002b60  75 2c 20 6d 2e 6c 74 75  0a 0a 20 20 20 43 41 53  |u, m.ltu..   CAS|
00002b70  45 20 73 2e 6c 67 72 3a  20 62 20 3a 3d 20 7e 62  |E s.lgr: b := ~b|
00002b80  3b 0a 20 20 20 43 41 53  45 20 73 2e 6c 6c 65 3a  |;.   CASE s.lle:|
00002b90  20 52 45 53 55 4c 54 49  53 20 62 20 2d 3e 20 6d  | RESULTIS b -> m|
00002ba0  2e 6c 65 75 2c 20 6d 2e  67 74 75 20 7d 0a 0a 41  |.leu, m.gtu }..A|
00002bb0  4e 44 20 52 65 76 65 72  73 65 28 72 65 6c 6f 70  |ND Reverse(relop|
00002bc0  29 20 3d 20 56 41 4c 4f  46 20 53 57 49 54 43 48  |) = VALOF SWITCH|
00002bd0  4f 4e 20 72 65 6c 6f 70  20 49 4e 54 4f 20 7b 0a  |ON relop INTO {.|
00002be0  20 20 20 43 41 53 45 20  73 2e 6c 73 3a 20 20 52  |   CASE s.ls:  R|
00002bf0  45 53 55 4c 54 49 53 20  73 2e 67 72 0a 20 20 20  |ESULTIS s.gr.   |
00002c00  43 41 53 45 20 73 2e 67  72 3a 20 20 52 45 53 55  |CASE s.gr:  RESU|
00002c10  4c 54 49 53 20 73 2e 6c  73 0a 20 20 20 43 41 53  |LTIS s.ls.   CAS|
00002c20  45 20 73 2e 6c 65 3a 20  20 52 45 53 55 4c 54 49  |E s.le:  RESULTI|
00002c30  53 20 73 2e 67 65 0a 20  20 20 43 41 53 45 20 73  |S s.ge.   CASE s|
00002c40  2e 67 65 3a 20 20 52 45  53 55 4c 54 49 53 20 73  |.ge:  RESULTIS s|
00002c50  2e 6c 65 0a 0a 20 20 20  43 41 53 45 20 73 2e 6c  |.le..   CASE s.l|
00002c60  6c 73 3a 20 52 45 53 55  4c 54 49 53 20 73 2e 6c  |ls: RESULTIS s.l|
00002c70  67 72 0a 20 20 20 43 41  53 45 20 73 2e 6c 67 72  |gr.   CASE s.lgr|
00002c80  3a 20 52 45 53 55 4c 54  49 53 20 73 2e 6c 6c 73  |: RESULTIS s.lls|
00002c90  0a 20 20 20 43 41 53 45  20 73 2e 6c 6c 65 3a 20  |.   CASE s.lle: |
00002ca0  52 45 53 55 4c 54 49 53  20 73 2e 6c 67 65 0a 20  |RESULTIS s.lge. |
00002cb0  20 20 43 41 53 45 20 73  2e 6c 67 65 3a 20 52 45  |  CASE s.lge: RE|
00002cc0  53 55 4c 54 49 53 20 73  2e 6c 6c 65 0a 0a 20 20  |SULTIS s.lle..  |
00002cd0  20 43 41 53 45 20 73 2e  66 6c 73 3a 20 52 45 53  | CASE s.fls: RES|
00002ce0  55 4c 54 49 53 20 73 2e  66 67 72 0a 20 20 20 43  |ULTIS s.fgr.   C|
00002cf0  41 53 45 20 73 2e 66 67  72 3a 20 52 45 53 55 4c  |ASE s.fgr: RESUL|
00002d00  54 49 53 20 73 2e 66 6c  73 0a 20 20 20 43 41 53  |TIS s.fls.   CAS|
00002d10  45 20 73 2e 66 6c 65 3a  20 52 45 53 55 4c 54 49  |E s.fle: RESULTI|
00002d20  53 20 73 2e 66 67 65 0a  20 20 20 43 41 53 45 20  |S s.fge.   CASE |
00002d30  73 2e 66 67 65 3a 20 52  45 53 55 4c 54 49 53 20  |s.fge: RESULTIS |
00002d40  73 2e 66 6c 65 0a 0a 20  20 20 44 45 46 41 55 4c  |s.fle..   DEFAUL|
00002d50  54 3a 20 20 20 20 52 45  53 55 4c 54 49 53 20 72  |T:    RESULTIS r|
00002d60  65 6c 6f 70 20 7d 0a 0a  41 4e 44 20 43 6f 6d 70  |elop }..AND Comp|
00002d70  6c 65 6d 65 6e 74 43 6f  6e 64 69 74 69 6f 6e 28  |lementCondition(|
00002d80  6d 61 73 6b 29 20 3d 20  56 41 4c 4f 46 20 53 57  |mask) = VALOF SW|
00002d90  49 54 43 48 4f 4e 20 6d  61 73 6b 20 49 4e 54 4f  |ITCHON mask INTO|
00002da0  20 7b 0a 20 20 20 43 41  53 45 20 6d 2e 65 71 3a  | {.   CASE m.eq:|
00002db0  20 20 52 45 53 55 4c 54  49 53 20 6d 2e 6e 65 0a  |  RESULTIS m.ne.|
00002dc0  20 20 20 43 41 53 45 20  6d 2e 6e 65 3a 20 20 52  |   CASE m.ne:  R|
00002dd0  45 53 55 4c 54 49 53 20  6d 2e 65 71 0a 0a 20 20  |ESULTIS m.eq..  |
00002de0  20 43 41 53 45 20 6d 2e  6c 74 3a 20 20 52 45 53  | CASE m.lt:  RES|
00002df0  55 4c 54 49 53 20 6d 2e  67 65 0a 20 20 20 43 41  |ULTIS m.ge.   CA|
00002e00  53 45 20 6d 2e 67 65 3a  20 20 52 45 53 55 4c 54  |SE m.ge:  RESULT|
00002e10  49 53 20 6d 2e 6c 74 0a  0a 20 20 20 43 41 53 45  |IS m.lt..   CASE|
00002e20  20 6d 2e 67 74 3a 20 20  52 45 53 55 4c 54 49 53  | m.gt:  RESULTIS|
00002e30  20 6d 2e 6c 65 0a 20 20  20 43 41 53 45 20 6d 2e  | m.le.   CASE m.|
00002e40  6c 65 3a 20 20 52 45 53  55 4c 54 49 53 20 6d 2e  |le:  RESULTIS m.|
00002e50  67 74 0a 0a 20 20 20 43  41 53 45 20 6d 2e 6c 74  |gt..   CASE m.lt|
00002e60  75 3a 20 52 45 53 55 4c  54 49 53 20 6d 2e 67 65  |u: RESULTIS m.ge|
00002e70  75 0a 20 20 20 43 41 53  45 20 6d 2e 67 65 75 3a  |u.   CASE m.geu:|
00002e80  20 52 45 53 55 4c 54 49  53 20 6d 2e 6c 74 75 0a  | RESULTIS m.ltu.|
00002e90  0a 20 20 20 43 41 53 45  20 6d 2e 67 74 75 3a 20  |.   CASE m.gtu: |
00002ea0  52 45 53 55 4c 54 49 53  20 6d 2e 6c 65 75 0a 20  |RESULTIS m.leu. |
00002eb0  20 20 43 41 53 45 20 6d  2e 6c 65 75 3a 20 52 45  |  CASE m.leu: RE|
00002ec0  53 55 4c 54 49 53 20 6d  2e 67 74 75 0a 0a 20 20  |SULTIS m.gtu..  |
00002ed0  20 43 41 53 45 20 6d 2e  61 6c 77 61 79 73 3a 20  | CASE m.always: |
00002ee0  52 45 53 55 4c 54 49 53  20 6d 2e 6e 65 76 65 72  |RESULTIS m.never|
00002ef0  0a 20 20 20 43 41 53 45  20 6d 2e 6e 65 76 65 72  |.   CASE m.never|
00002f00  3a 0a 20 20 20 43 41 53  45 20 4e 75 6c 6c 3a 20  |:.   CASE Null: |
00002f10  20 52 45 53 55 4c 54 49  53 20 6d 2e 61 6c 77 61  | RESULTIS m.alwa|
00002f20  79 73 20 7d 0a 0a 0a 41  4e 44 20 43 47 53 6c 63  |ys }...AND CGSlc|
00002f30  74 53 74 28 29 20 42 45  20 7b 0a 20 20 20 4c 45  |tSt() BE {.   LE|
00002f40  54 20 73 69 7a 65 20 3d  20 52 65 61 64 4e 28 29  |T size = ReadN()|
00002f50  0a 20 20 20 4c 45 54 20  73 68 69 66 74 20 3d 20  |.   LET shift = |
00002f60  52 65 61 64 4e 28 29 3b  0a 20 20 20 4c 45 54 20  |ReadN();.   LET |
00002f70  6f 66 66 73 65 74 20 3d  20 52 65 61 64 4e 28 29  |offset = ReadN()|
00002f80  3b 0a 20 20 20 4c 45 54  20 73 69 6d 70 6c 65 53  |;.   LET simpleS|
00002f90  4c 6f 63 20 3d 20 46 41  4c 53 45 3b 0a 20 20 20  |Loc = FALSE;.   |
00002fa0  49 46 20 68 32 21 61 72  67 31 3e 3d 30 20 54 48  |IF h2!arg1>=0 TH|
00002fb0  45 4e 20 4d 6f 76 65 54  6f 41 6e 79 52 28 61 72  |EN MoveToAnyR(ar|
00002fc0  67 31 29 3b 0a 0a 20 20  20 49 46 20 73 69 7a 65  |g1);..   IF size|
00002fd0  3d 30 20 26 20 68 31 21  61 72 67 31 7e 3d 6b 2e  |=0 & h1!arg1~=k.|
00002fe0  73 68 72 65 67 20 54 48  45 4e 20 7b 0a 20 20 20  |shreg THEN {.   |
00002ff0  20 20 20 68 34 21 61 72  67 31 20 3a 3d 20 68 34  |   h4!arg1 := h4|
00003000  21 61 72 67 31 2b 6f 66  66 73 65 74 3b 0a 20 20  |!arg1+offset;.  |
00003010  20 20 20 20 43 47 53 74  69 6e 64 28 29 3b 0a 20  |    CGStind();. |
00003020  20 20 20 20 20 52 45 54  55 52 4e 20 7d 3b 0a 0a  |     RETURN };..|
00003030  20 20 20 7b 20 20 4c 45  54 20 62 2c 20 6d 20 3d  |   {  LET b, m =|
00003040  20 2d 31 2c 20 30 3b 0a  20 20 20 20 20 20 4c 45  | -1, 0;.      LE|
00003050  54 20 6e 2c 20 74 2c 20  6b 20 3d 20 68 33 21 61  |T n, t, k = h3!a|
00003060  72 67 31 2c 20 68 31 21  61 72 67 31 2c 20 68 34  |rg1, h1!arg1, h4|
00003070  21 61 72 67 31 3b 0a 20  20 20 20 20 20 4c 45 54  |!arg1;.      LET|
00003080  20 63 6c 61 73 73 6f 66  73 65 6c 20 3d 20 54 79  | classofsel = Ty|
00003090  70 65 4f 66 46 69 65 6c  64 28 73 69 7a 65 2c 20  |peOfField(size, |
000030a0  73 68 69 66 74 29 3b 0a  20 20 20 20 20 20 4c 45  |shift);.      LE|
000030b0  54 20 61 20 3d 20 34 2a  6f 66 66 73 65 74 3b 0a  |T a = 4*offset;.|
000030c0  0a 20 20 20 20 20 20 49  46 20 74 7e 3d 6b 2e 73  |.      IF t~=k.s|
000030d0  68 72 65 67 20 54 48 45  4e 20 61 20 3a 3d 20 61  |hreg THEN a := a|
000030e0  2b 34 2a 6b 3b 0a 20 20  20 20 20 20 53 57 49 54  |+4*k;.      SWIT|
000030f0  43 48 4f 4e 20 74 20 49  4e 54 4f 20 7b 0a 09 20  |CHON t INTO {.. |
00003100  43 41 53 45 20 6b 2e 6c  76 6c 6f 63 3a 0a 09 20  |CASE k.lvloc:.. |
00003110  43 41 53 45 20 6b 2e 6c  76 67 6c 6f 62 3a 0a 09  |CASE k.lvglob:..|
00003120  20 43 41 53 45 20 6b 2e  6c 76 73 74 61 74 69 63  | CASE k.lvstatic|
00003130  3a 0a 09 20 20 20 20 74  2c 20 6e 20 3a 3d 20 74  |:..    t, n := t|
00003140  2b 6b 2e 6c 6f 63 2d 6b  2e 6c 76 6c 6f 63 2c 20  |+k.loc-k.lvloc, |
00003150  61 2f 34 2b 6e 3b 0a 09  20 20 20 20 68 31 21 61  |a/4+n;..    h1!a|
00003160  72 67 31 2c 20 68 32 21  61 72 67 31 2c 20 68 33  |rg1, h2!arg1, h3|
00003170  21 61 72 67 31 2c 20 68  34 21 61 72 67 31 20 3a  |!arg1, h4!arg1 :|
00003180  3d 20 74 2c 20 2d 31 2c  20 6e 2c 20 30 3b 0a 09  |= t, -1, n, 0;..|
00003190  20 20 20 20 73 69 6d 70  6c 65 53 4c 6f 63 20 3a  |    simpleSLoc :|
000031a0  3d 20 54 52 55 45 3b 0a  09 20 20 20 20 45 4e 44  |= TRUE;..    END|
000031b0  43 41 53 45 0a 0a 09 20  43 41 53 45 20 6b 2e 6c  |CASE... CASE k.l|
000031c0  76 6c 61 62 3a 0a 09 20  20 20 20 62 2c 20 6d 20  |vlab:..    b, m |
000031d0  3a 3d 20 43 68 65 63 6b  52 4c 4c 6f 61 64 65 64  |:= CheckRLLoaded|
000031e0  28 29 2c 20 6e 3b 0a 09  20 20 20 20 45 4e 44 43  |(), n;..    ENDC|
000031f0  41 53 45 0a 0a 09 20 44  45 46 41 55 4c 54 3a 0a  |ASE... DEFAULT:.|
00003200  09 20 20 20 20 46 6c 75  73 68 50 65 6e 64 69 6e  |.    FlushPendin|
00003210  67 53 74 6f 72 65 73 28  29 3b 0a 09 20 20 20 20  |gStores();..    |
00003220  68 34 21 61 72 67 31 20  3a 3d 20 30 3b 0a 09 20  |h4!arg1 := 0;.. |
00003230  20 20 20 62 20 3a 3d 20  4c 6f 61 64 41 64 64 72  |   b := LoadAddr|
00003240  65 73 73 28 61 72 67 31  29 3b 0a 09 20 20 20 20  |ess(arg1);..    |
00003250  4c 6f 63 6b 28 62 2c 20  6b 2e 72 65 67 29 3b 0a  |Lock(b, k.reg);.|
00003260  09 20 20 20 20 54 45 53  54 20 6c 6f 63 61 6c 73  |.    TEST locals|
00003270  53 61 66 65 20 54 48 45  4e 20 7b 0a 09 20 20 20  |Safe THEN {..   |
00003280  20 20 20 20 46 6c 75 73  68 50 65 6e 64 69 6e 67  |    FlushPending|
00003290  4c 6f 61 64 73 45 78 63  65 70 74 4c 6f 63 61 6c  |LoadsExceptLocal|
000032a0  73 28 29 3b 0a 09 20 20  20 20 20 20 20 46 6c 75  |s();..       Flu|
000032b0  73 68 50 65 6e 64 69 6e  67 53 74 6f 72 65 73 45  |shPendingStoresE|
000032c0  78 63 65 70 74 4c 6f 63  61 6c 73 41 6e 64 49 72  |xceptLocalsAndIr|
000032d0  65 67 73 28 29 20 7d 0a  09 20 20 20 20 45 4c 53  |egs() }..    ELS|
000032e0  45 20 7b 0a 09 20 20 20  20 20 20 20 46 6c 75 73  |E {..       Flus|
000032f0  68 50 65 6e 64 69 6e 67  4c 6f 61 64 73 28 29 3b  |hPendingLoads();|
00003300  0a 09 20 20 20 20 20 20  20 46 6c 75 73 68 50 65  |..       FlushPe|
00003310  6e 64 69 6e 67 53 74 6f  72 65 73 28 29 20 7d 20  |ndingStores() } |
00003320  7d 3b 0a 0a 20 20 20 20  20 20 54 45 53 54 20 63  |};..      TEST c|
00003330  6c 61 73 73 6f 66 73 65  6c 3d 62 79 74 65 66 69  |lassofsel=bytefi|
00003340  65 6c 64 20 26 20 7e 73  69 6d 70 6c 65 53 4c 6f  |eld & ~simpleSLo|
00003350  63 20 54 48 45 4e 0a 09  20 47 65 6e 46 32 28 66  |c THEN.. GenF2(f|
00003360  2e 73 74 72 62 2c 20 4d  6f 76 65 54 6f 41 6e 79  |.strb, MoveToAny|
00003370  43 52 28 61 72 67 32 29  2c 20 62 2c 20 6d 2c 20  |CR(arg2), b, m, |
00003380  61 2b 73 68 69 66 74 2f  38 29 0a 0a 20 20 20 20  |a+shift/8)..    |
00003390  20 20 45 4c 53 45 20 54  45 53 54 20 68 31 21 61  |  ELSE TEST h1!a|
000033a0  72 67 32 3d 6b 2e 6e 75  6d 62 65 72 20 54 48 45  |rg2=k.number THE|
000033b0  4e 20 7b 0a 09 20 4c 45  54 20 6d 61 73 6b 20 3d  |N {.. LET mask =|
000033c0  20 28 2d 31 3e 3e 28 54  61 72 67 65 74 57 6f 72  | (-1>>(TargetWor|
000033d0  64 53 69 7a 65 2d 73 69  7a 65 29 29 3c 3c 73 68  |dSize-size))<<sh|
000033e0  69 66 74 3b 0a 09 20 4c  45 54 20 72 2c 20 6e 31  |ift;.. LET r, n1|
000033f0  20 3d 20 4e 65 78 74 52  28 29 2c 20 28 68 33 21  | = NextR(), (h3!|
00003400  61 72 67 32 29 3c 3c 73  68 69 66 74 3b 0a 09 20  |arg2)<<shift;.. |
00003410  4c 45 54 20 73 20 3d 20  72 3b 0a 09 20 54 45 53  |LET s = r;.. TES|
00003420  54 20 73 69 6d 70 6c 65  53 4c 6f 63 20 54 48 45  |T simpleSLoc THE|
00003430  4e 20 7b 0a 09 20 20 20  20 73 20 3a 3d 20 49 73  |N {..    s := Is|
00003440  49 6e 41 52 65 67 69 73  74 65 72 28 61 72 67 31  |InARegister(arg1|
00003450  29 3b 0a 09 20 20 20 20  49 46 20 73 3d 4e 75 6c  |);..    IF s=Nul|
00003460  6c 20 54 48 45 4e 20 73  20 3a 3d 20 72 3b 0a 09  |l THEN s := r;..|
00003470  20 20 20 20 4d 6f 76 65  54 6f 52 28 73 2c 20 61  |    MoveToR(s, a|
00003480  72 67 31 29 3b 0a 09 20  20 20 20 68 33 21 61 72  |rg1);..    h3!ar|
00003490  67 31 20 3a 3d 20 72 3b  0a 09 20 20 20 20 44 69  |g1 := r;..    Di|
000034a0  73 63 61 72 64 52 65 67  28 72 2c 20 6b 2e 72 65  |scardReg(r, k.re|
000034b0  67 29 20 7d 0a 09 20 45  4c 53 45 0a 09 20 20 20  |g) }.. ELSE..   |
000034c0  20 47 65 6e 46 32 28 66  2e 6c 64 72 2c 20 72 2c  | GenF2(f.ldr, r,|
000034d0  20 62 2c 20 6d 2c 20 61  29 3b 0a 09 20 49 46 20  | b, m, a);.. IF |
000034e0  6e 31 7e 3d 6d 61 73 6b  20 54 48 45 4e 20 7b 0a  |n1~=mask THEN {.|
000034f0  09 20 20 20 20 54 45 53  54 20 73 69 7a 65 3c 3d  |.    TEST size<=|
00003500  31 36 20 54 48 45 4e 0a  09 20 20 20 20 20 20 20  |16 THEN..       |
00003510  47 65 6e 46 31 4b 28 66  2e 62 69 63 2c 20 72 2c  |GenF1K(f.bic, r,|
00003520  20 73 2c 20 6d 61 73 6b  29 0a 09 20 20 20 20 45  | s, mask)..    E|
00003530  4c 53 45 0a 09 20 20 20  20 20 20 20 47 65 6e 46  |LSE..       GenF|
00003540  31 4b 28 66 2e 61 6e 64  2c 20 72 2c 20 73 2c 20  |1K(f.and, r, s, |
00003550  7e 6d 61 73 6b 29 3b 0a  09 20 20 20 20 73 20 3a  |~mask);..    s :|
00003560  3d 20 72 20 7d 3b 0a 09  20 49 46 20 28 6e 31 26  |= r };.. IF (n1&|
00003570  6d 61 73 6b 29 7e 3d 30  20 54 48 45 4e 0a 09 20  |mask)~=0 THEN.. |
00003580  20 20 20 47 65 6e 46 31  4b 28 66 2e 6f 72 72 2c  |   GenF1K(f.orr,|
00003590  20 72 2c 20 73 2c 20 6e  31 26 6d 61 73 6b 29 3b  | r, s, n1&mask);|
000035a0  0a 09 20 54 45 53 54 20  73 69 6d 70 6c 65 53 4c  |.. TEST simpleSL|
000035b0  6f 63 20 54 48 45 4e 0a  09 20 20 20 20 47 65 6e  |oc THEN..    Gen|
000035c0  53 74 6f 72 65 28 74 2c  20 6e 29 0a 09 20 45 4c  |Store(t, n).. EL|
000035d0  53 45 0a 09 20 20 20 20  47 65 6e 46 32 28 66 2e  |SE..    GenF2(f.|
000035e0  73 74 72 2c 20 72 2c 20  62 2c 20 6d 2c 20 61 29  |str, r, b, m, a)|
000035f0  20 7d 0a 0a 20 20 20 20  20 20 45 4c 53 45 20 7b  | }..      ELSE {|
00003600  0a 09 20 4c 45 54 20 6d  61 73 6b 20 3d 20 28 2d  |.. LET mask = (-|
00003610  31 3e 3e 28 54 61 72 67  65 74 57 6f 72 64 53 69  |1>>(TargetWordSi|
00003620  7a 65 2d 73 69 7a 65 29  29 3c 3c 73 68 69 66 74  |ze-size))<<shift|
00003630  3b 0a 09 20 4c 45 54 20  72 2c 20 73 20 3d 20 4e  |;.. LET r, s = N|
00003640  75 6c 6c 2c 20 4e 75 6c  6c 3b 0a 09 20 4c 45 54  |ull, Null;.. LET|
00003650  20 69 32 20 3d 20 68 32  21 61 72 67 32 3b 0a 09  | i2 = h2!arg2;..|
00003660  20 4c 45 54 20 72 65 61  6c 73 68 69 66 74 20 3d  | LET realshift =|
00003670  20 73 68 69 66 74 3b 0a  09 20 49 46 20 30 3c 69  | shift;.. IF 0<i|
00003680  32 3c 43 61 72 4d 61 72  6b 20 54 48 45 4e 20 7b  |2<CarMark THEN {|
00003690  0a 09 20 20 20 20 4c 45  54 20 73 69 7a 65 32 2c  |..    LET size2,|
000036a0  20 73 68 69 66 74 32 20  3d 20 69 32 2f 33 32 2c  | shift2 = i2/32,|
000036b0  20 69 32 20 52 45 4d 20  33 32 3b 0a 09 20 20 20  | i2 REM 32;..   |
000036c0  20 49 46 20 73 69 7a 65  32 3e 3d 73 69 7a 65 20  | IF size2>=size |
000036d0  54 48 45 4e 20 7b 0a 09  20 20 20 20 20 20 20 68  |THEN {..       h|
000036e0  32 21 61 72 67 32 20 3a  3d 20 30 3b 0a 09 20 20  |2!arg2 := 0;..  |
000036f0  20 20 20 20 20 73 68 69  66 74 20 3a 3d 20 73 68  |     shift := sh|
00003700  69 66 74 2d 73 68 69 66  74 32 20 7d 20 7d 3b 0a  |ift-shift2 } };.|
00003710  09 20 72 20 3a 3d 20 4d  6f 76 65 54 6f 41 6e 79  |. r := MoveToAny|
00003720  52 28 61 72 67 32 29 3b  0a 09 20 54 45 53 54 20  |R(arg2);.. TEST |
00003730  73 69 6d 70 6c 65 53 4c  6f 63 20 54 48 45 4e 20  |simpleSLoc THEN |
00003740  7b 0a 09 20 20 20 20 73  20 3a 3d 20 49 73 49 6e  |{..    s := IsIn|
00003750  41 52 65 67 69 73 74 65  72 28 61 72 67 31 29 3b  |ARegister(arg1);|
00003760  0a 09 20 20 20 20 54 45  53 54 20 73 3d 4e 75 6c  |..    TEST s=Nul|
00003770  6c 20 54 48 45 4e 0a 09  20 20 20 20 20 20 20 73  |l THEN..       s|
00003780  20 3a 3d 20 4d 6f 76 65  54 6f 41 6e 79 43 52 28  | := MoveToAnyCR(|
00003790  61 72 67 31 29 0a 09 20  20 20 20 45 4c 53 45 0a  |arg1)..    ELSE.|
000037a0  09 20 20 20 20 20 20 20  4d 6f 76 65 54 6f 52 28  |.       MoveToR(|
000037b0  73 2c 20 61 72 67 31 29  3b 0a 09 20 20 20 20 68  |s, arg1);..    h|
000037c0  33 21 61 72 67 31 20 3a  3d 20 72 3b 0a 09 20 20  |3!arg1 := r;..  |
000037d0  20 20 44 69 73 63 61 72  64 52 65 67 28 72 2c 20  |  DiscardReg(r, |
000037e0  6b 2e 72 65 67 29 20 7d  0a 09 20 45 4c 53 45 20  |k.reg) }.. ELSE |
000037f0  7b 0a 09 20 20 20 20 73  20 3a 3d 20 4e 65 78 74  |{..    s := Next|
00003800  52 28 29 3b 0a 09 20 20  20 20 47 65 6e 46 32 28  |R();..    GenF2(|
00003810  66 2e 6c 64 72 2c 20 73  2c 20 62 2c 20 6d 2c 20  |f.ldr, s, b, m, |
00003820  61 29 20 7d 3b 0a 0a 09  20 54 45 53 54 20 28 73  |a) };... TEST (s|
00003830  69 7a 65 2b 72 65 61 6c  73 68 69 66 74 29 3d 33  |ize+realshift)=3|
00003840  32 20 54 48 45 4e 20 7b  0a 09 20 20 20 20 4c 45  |2 THEN {..    LE|
00003850  54 20 73 31 20 3d 20 73  69 6d 70 6c 65 53 6c 6f  |T s1 = simpleSlo|
00003860  63 20 2d 3e 20 4e 65 78  74 52 28 29 2c 20 73 3b  |c -> NextR(), s;|
00003870  0a 09 20 20 20 20 54 45  53 54 20 73 68 69 66 74  |..    TEST shift|
00003880  3d 30 20 54 48 45 4e 20  7b 0a 09 20 20 20 20 20  |=0 THEN {..     |
00003890  20 20 53 68 69 66 74 52  65 67 69 73 74 65 72 44  |  ShiftRegisterD|
000038a0  53 28 73 31 2c 20 73 2c  20 73 68 2e 61 73 6c 2c  |S(s1, s, sh.asl,|
000038b0  20 73 69 7a 65 29 3b 0a  09 20 20 20 20 20 20 20  | size);..       |
000038c0  46 31 49 6e 73 74 28 66  2e 65 6f 72 2c 20 72 2c  |F1Inst(f.eor, r,|
000038d0  20 72 2c 20 73 31 2c 20  30 2c 20 73 68 2e 6c 73  | r, s1, 0, sh.ls|
000038e0  72 2c 20 73 69 7a 65 2c  20 6d 2e 61 6c 77 61 79  |r, size, m.alway|
000038f0  73 29 20 7d 0a 09 20 20  20 20 45 4c 53 45 20 7b  |s) }..    ELSE {|
00003900  0a 09 20 20 20 20 20 20  20 54 45 53 54 20 73 69  |..       TEST si|
00003910  7a 65 3c 3d 31 36 20 54  48 45 4e 0a 09 09 20 20  |ze<=16 THEN...  |
00003920  47 65 6e 46 31 4b 28 66  2e 62 69 63 2c 20 73 31  |GenF1K(f.bic, s1|
00003930  2c 20 73 2c 20 6d 61 73  6b 29 0a 09 20 20 20 20  |, s, mask)..    |
00003940  20 20 20 45 4c 53 45 0a  09 09 20 20 47 65 6e 46  |   ELSE...  GenF|
00003950  31 4b 28 66 2e 61 6e 64  2c 20 73 31 2c 20 73 2c  |1K(f.and, s1, s,|
00003960  20 7e 6d 61 73 6b 29 3b  0a 09 20 20 20 20 20 20  | ~mask);..      |
00003970  20 54 45 53 54 20 73 68  69 66 74 3e 30 20 54 48  | TEST shift>0 TH|
00003980  45 4e 0a 09 09 20 20 46  31 49 6e 73 74 28 66 2e  |EN...  F1Inst(f.|
00003990  65 6f 72 2c 20 72 2c 20  73 31 2c 20 72 2c 20 30  |eor, r, s1, r, 0|
000039a0  2c 20 73 68 2e 61 73 6c  2c 20 73 68 69 66 74 2c  |, sh.asl, shift,|
000039b0  20 6d 2e 61 6c 77 61 79  73 29 0a 09 20 20 20 20  | m.always)..    |
000039c0  20 20 20 45 4c 53 45 0a  09 09 20 20 46 31 49 6e  |   ELSE...  F1In|
000039d0  73 74 28 66 2e 65 6f 72  2c 20 72 2c 20 73 31 2c  |st(f.eor, r, s1,|
000039e0  20 72 2c 20 30 2c 20 73  68 2e 6c 73 72 2c 20 2d  | r, 0, sh.lsr, -|
000039f0  73 68 69 66 74 2c 20 6d  2e 61 6c 77 61 79 73 29  |shift, m.always)|
00003a00  20 7d 20 7d 0a 0a 09 20  45 4c 53 45 20 7b 0a 09  | } }... ELSE {..|
00003a10  20 20 20 20 54 45 53 54  20 73 68 69 66 74 3e 30  |    TEST shift>0|
00003a20  20 54 48 45 4e 0a 09 20  20 20 20 20 20 20 46 31  | THEN..       F1|
00003a30  49 6e 73 74 28 66 2e 65  6f 72 2c 20 72 2c 20 73  |Inst(f.eor, r, s|
00003a40  2c 20 72 2c 20 30 2c 20  73 68 2e 61 73 6c 2c 20  |, r, 0, sh.asl, |
00003a50  73 68 69 66 74 2c 20 6d  2e 61 6c 77 61 79 73 29  |shift, m.always)|
00003a60  0a 09 20 20 20 20 45 4c  53 45 20 54 45 53 54 20  |..    ELSE TEST |
00003a70  73 68 69 66 74 3c 30 20  54 48 45 4e 0a 09 20 20  |shift<0 THEN..  |
00003a80  20 20 20 20 20 46 31 49  6e 73 74 28 66 2e 65 6f  |     F1Inst(f.eo|
00003a90  72 2c 20 72 2c 20 73 2c  20 72 2c 20 30 2c 20 73  |r, r, s, r, 0, s|
00003aa0  68 2e 6c 73 72 2c 20 2d  73 68 69 66 74 2c 20 6d  |h.lsr, -shift, m|
00003ab0  2e 61 6c 77 61 79 73 29  0a 09 20 20 20 20 45 4c  |.always)..    EL|
00003ac0  53 45 0a 09 20 20 20 20  20 20 20 47 65 6e 52 52  |SE..       GenRR|
00003ad0  28 66 2e 65 6f 72 2c 20  72 2c 20 73 2c 20 72 29  |(f.eor, r, s, r)|
00003ae0  3b 0a 0a 09 20 20 20 20  54 45 53 54 20 72 65 61  |;...    TEST rea|
00003af0  6c 73 68 69 66 74 3d 30  20 54 48 45 4e 20 7b 0a  |lshift=0 THEN {.|
00003b00  09 20 20 20 20 20 20 20  53 68 69 66 74 52 65 67  |.       ShiftReg|
00003b10  69 73 74 65 72 28 72 2c  20 73 68 2e 61 73 6c 2c  |ister(r, sh.asl,|
00003b20  20 33 32 2d 73 69 7a 65  29 3b 0a 09 20 20 20 20  | 32-size);..    |
00003b30  20 20 20 46 31 49 6e 73  74 28 66 2e 65 6f 72 2c  |   F1Inst(f.eor,|
00003b40  20 72 2c 20 73 2c 20 72  2c 20 30 2c 20 73 68 2e  | r, s, r, 0, sh.|
00003b50  6c 73 72 2c 20 33 32 2d  73 69 7a 65 2c 20 6d 2e  |lsr, 32-size, m.|
00003b60  61 6c 77 61 79 73 29 20  7d 0a 09 20 20 20 20 45  |always) }..    E|
00003b70  4c 53 45 20 7b 0a 09 20  20 20 20 20 20 20 54 45  |LSE {..       TE|
00003b80  53 54 20 73 69 7a 65 3e  3d 31 36 20 54 48 45 4e  |ST size>=16 THEN|
00003b90  0a 09 09 20 20 47 65 6e  46 31 4b 28 66 2e 62 69  |...  GenF1K(f.bi|
00003ba0  63 2c 20 72 2c 20 72 2c  20 7e 6d 61 73 6b 29 0a  |c, r, r, ~mask).|
00003bb0  09 20 20 20 20 20 20 20  45 4c 53 45 0a 09 09 20  |.       ELSE... |
00003bc0  20 47 65 6e 46 31 4b 28  66 2e 61 6e 64 2c 20 72  | GenF1K(f.and, r|
00003bd0  2c 20 72 2c 20 6d 61 73  6b 29 3b 0a 09 20 20 20  |, r, mask);..   |
00003be0  20 20 20 20 47 65 6e 52  52 28 66 2e 65 6f 72 2c  |    GenRR(f.eor,|
00003bf0  20 72 2c 20 73 2c 20 72  29 20 7d 20 7d 3b 0a 09  | r, s, r) } };..|
00003c00  20 54 45 53 54 20 73 69  6d 70 6c 65 53 4c 6f 63  | TEST simpleSLoc|
00003c10  20 54 48 45 4e 0a 09 20  20 20 20 47 65 6e 53 74  | THEN..    GenSt|
00003c20  6f 72 65 28 74 2c 20 6e  29 0a 09 20 45 4c 53 45  |ore(t, n).. ELSE|
00003c30  0a 09 20 20 20 20 47 65  6e 46 32 28 66 2e 73 74  |..    GenF2(f.st|
00003c40  72 2c 20 72 2c 20 62 2c  20 6d 2c 20 61 29 20 7d  |r, r, b, m, a) }|
00003c50  3b 0a 20 20 20 20 20 20  54 45 53 54 20 73 69 6d  |;.      TEST sim|
00003c60  70 6c 65 53 4c 6f 63 20  54 48 45 4e 0a 09 20 53  |pleSLoc THEN.. S|
00003c70  74 61 63 6b 28 73 73 70  2d 31 29 0a 20 20 20 20  |tack(ssp-1).    |
00003c80  20 20 45 4c 53 45 20 7b  0a 09 20 44 69 73 63 61  |  ELSE {.. Disca|
00003c90  72 64 52 65 67 73 28 29  3b 0a 09 20 53 74 61 63  |rdRegs();.. Stac|
00003ca0  6b 28 73 73 70 2d 32 29  20 7d 3b 0a 0a 20 20 20  |k(ssp-2) };..   |
00003cb0  20 20 20 49 46 20 62 3e  3d 30 20 54 48 45 4e 20  |   IF b>=0 THEN |
00003cc0  55 6e 6c 6f 63 6b 28 62  2c 20 6b 2e 72 65 67 29  |Unlock(b, k.reg)|
00003cd0  20 7d 20 7d 0a 0a 41 4e  44 20 43 47 42 79 74 65  | } }..AND CGByte|
00003ce0  41 70 28 6f 70 29 20 42  45 20 7b 0a 20 20 20 4c  |Ap(op) BE {.   L|
00003cf0  45 54 20 61 2c 20 72 2c  20 78 20 3d 20 3f 2c 20  |ET a, r, x = ?, |
00003d00  3f 2c 20 4e 75 6c 6c 3b  0a 20 20 20 4c 45 54 20  |?, Null;.   LET |
00003d10  73 68 2c 20 6d 20 3d 20  73 68 2e 61 73 6c 2c 20  |sh, m = sh.asl, |
00003d20  30 3b 0a 20 20 20 4c 45  54 20 62 20 3d 20 3f 3b  |0;.   LET b = ?;|
00003d30  0a 0a 20 20 20 54 45 53  54 20 49 73 43 6f 6e 73  |..   TEST IsCons|
00003d40  74 28 61 72 67 31 29 20  26 20 28 2d 6b 34 3c 3d  |t(arg1) & (-k4<=|
00003d50  68 33 21 61 72 67 31 3c  3d 6b 34 29 20 26 20 68  |h3!arg1<=k4) & h|
00003d60  32 21 61 72 67 32 3c 30  0a 20 20 20 20 20 20 54  |2!arg2<0.      T|
00003d70  48 45 4e 20 53 57 49 54  43 48 4f 4e 20 68 31 21  |HEN SWITCHON h1!|
00003d80  61 72 67 32 20 49 4e 54  4f 20 7b 0a 09 20 43 41  |arg2 INTO {.. CA|
00003d90  53 45 20 6b 2e 6c 76 6c  6f 63 3a 0a 09 20 20 20  |SE k.lvloc:..   |
00003da0  20 61 20 3a 3d 20 68 33  21 61 72 67 31 2b 34 2a  | a := h3!arg1+4*|
00003db0  68 34 21 61 72 67 32 3b  0a 09 20 20 20 20 62 20  |h4!arg2;..    b |
00003dc0  3a 3d 20 6c 69 6e 6b 61  67 65 4e 6f 74 53 74 6f  |:= linkageNotSto|
00003dd0  72 65 64 20 2d 3e 20 72  2e 74 73 2c 20 72 2e 70  |red -> r.ts, r.p|
00003de0  3b 0a 09 20 20 20 20 49  46 20 7e 75 73 65 73 46  |;..    IF ~usesF|
00003df0  72 61 6d 65 20 54 48 45  4e 20 62 2c 20 61 20 3a  |rame THEN b, a :|
00003e00  3d 20 72 2e 74 73 2c 20  61 2d 34 2a 73 61 76 65  |= r.ts, a-4*save|
00003e10  53 70 61 63 65 53 69 7a  65 3b 0a 09 20 20 20 20  |SpaceSize;..    |
00003e20  61 20 3a 3d 20 61 2b 6e  65 78 74 53 74 61 63 6b  |a := a+nextStack|
00003e30  57 6f 72 64 2a 68 33 21  61 72 67 32 3b 0a 09 20  |Word*h3!arg2;.. |
00003e40  20 20 20 45 4e 44 43 41  53 45 0a 0a 09 20 43 41  |   ENDCASE... CA|
00003e50  53 45 20 6b 2e 6c 76 73  74 61 74 69 63 3a 0a 09  |SE k.lvstatic:..|
00003e60  20 20 20 20 61 2c 20 62  20 3a 3d 20 68 33 21 61  |    a, b := h3!a|
00003e70  72 67 31 2b 34 2a 28 68  34 21 61 72 67 32 2b 68  |rg1+4*(h4!arg2+h|
00003e80  33 21 61 72 67 32 29 2c  20 43 68 65 63 6b 52 4c  |3!arg2), CheckRL|
00003e90  4c 6f 61 64 65 64 28 29  3b 0a 09 20 20 20 20 45  |Loaded();..    E|
00003ea0  4e 44 43 41 53 45 0a 0a  09 20 43 41 53 45 20 6b  |NDCASE... CASE k|
00003eb0  2e 6c 76 67 6c 6f 62 3a  0a 09 20 20 20 20 61 2c  |.lvglob:..    a,|
00003ec0  20 62 20 3a 3d 20 68 33  21 61 72 67 31 2b 34 2a  | b := h3!arg1+4*|
00003ed0  28 68 34 21 61 72 67 32  2b 68 33 21 61 72 67 32  |(h4!arg2+h3!arg2|
00003ee0  29 2c 20 72 2e 67 3b 0a  09 20 20 20 20 45 4e 44  |), r.g;..    END|
00003ef0  43 41 53 45 0a 0a 09 20  43 41 53 45 20 6b 2e 6c  |CASE... CASE k.l|
00003f00  76 6c 61 62 3a 0a 09 20  20 20 20 61 2c 20 6d 20  |vlab:..    a, m |
00003f10  3a 3d 20 68 33 21 61 72  67 31 2b 34 2a 68 34 21  |:= h3!arg1+4*h4!|
00003f20  61 72 67 32 2c 20 68 33  21 61 72 67 32 3b 0a 09  |arg2, h3!arg2;..|
00003f30  20 20 20 20 62 20 3a 3d  20 43 68 65 63 6b 52 4c  |    b := CheckRL|
00003f40  4c 6f 61 64 65 64 28 29  3b 0a 09 20 20 20 20 45  |Loaded();..    E|
00003f50  4e 44 43 41 53 45 3b 0a  0a 09 20 44 45 46 41 55  |NDCASE;... DEFAU|
00003f60  4c 54 3a 0a 09 20 20 20  20 49 46 20 68 31 21 61  |LT:..    IF h1!a|
00003f70  72 67 32 7e 3d 6b 2e 73  68 72 65 67 20 54 48 45  |rg2~=k.shreg THE|
00003f80  4e 20 7b 0a 09 20 20 20  20 20 20 20 61 20 3a 3d  |N {..       a :=|
00003f90  20 68 33 21 61 72 67 31  2b 6e 65 78 74 53 74 61  | h3!arg1+nextSta|
00003fa0  63 6b 57 6f 72 64 2a 68  34 21 61 72 67 32 3b 0a  |ckWord*h4!arg2;.|
00003fb0  09 20 20 20 20 20 20 20  68 34 21 61 72 67 32 20  |.       h4!arg2 |
00003fc0  3a 3d 20 30 20 7d 3b 0a  09 20 20 20 20 62 20 3a  |:= 0 };..    b :|
00003fd0  3d 20 4c 6f 61 64 41 64  64 72 65 73 73 28 61 72  |= LoadAddress(ar|
00003fe0  67 32 29 20 7d 0a 0a 20  20 20 45 4c 53 45 20 54  |g2) }..   ELSE T|
00003ff0  45 53 54 20 49 73 43 6f  6e 73 74 28 61 72 67 32  |EST IsConst(arg2|
00004000  29 20 26 20 68 33 21 61  72 67 32 3d 30 20 54 48  |) & h3!arg2=0 TH|
00004010  45 4e 20 7b 0a 20 20 20  20 20 20 20 2f 2f 20 73  |EN {.       // s|
00004020  70 65 63 69 61 6c 20 63  61 73 65 20 6f 66 20 30  |pecial case of 0|
00004030  25 73 6f 6d 65 74 68 69  6e 67 2e 0a 20 20 20 20  |%something..    |
00004040  20 20 20 2f 2f 20 62 65  63 61 75 73 65 20 74 68  |   // because th|
00004050  69 73 20 69 73 20 61 20  63 6f 6e 73 74 72 75 63  |is is a construc|
00004060  74 20 6d 75 63 68 20 75  73 65 64 20 69 6e 20 4c  |t much used in L|
00004070  69 73 70 2c 0a 20 20 20  20 20 20 20 2f 2f 20 77  |isp,.       // w|
00004080  68 65 72 65 20 74 68 65  20 73 6f 6d 65 74 68 69  |here the somethi|
00004090  6e 67 20 69 73 20 61 20  74 61 67 67 65 64 20 70  |ng is a tagged p|
000040a0  6f 69 6e 74 65 72 2c 20  49 20 6d 61 73 6b 0a 20  |ointer, I mask. |
000040b0  20 20 20 20 20 20 2f 2f  20 6f 75 74 20 70 6f 74  |      // out pot|
000040c0  65 6e 74 69 61 6c 20 74  61 67 20 62 69 74 73 0a  |ential tag bits.|
000040d0  20 20 20 20 20 20 54 45  53 54 20 68 32 21 61 72  |      TEST h2!ar|
000040e0  67 31 3c 30 20 26 20 68  34 21 61 72 67 31 7e 3d  |g1<0 & h4!arg1~=|
000040f0  30 20 54 48 45 4e 20 7b  0a 09 20 61 20 3a 3d 20  |0 THEN {.. a := |
00004100  68 34 21 61 72 67 31 3b  0a 09 20 68 34 21 61 72  |h4!arg1;.. h4!ar|
00004110  67 31 20 3a 3d 20 30 20  7d 0a 20 20 20 20 20 20  |g1 := 0 }.      |
00004120  45 4c 53 45 0a 09 20 61  20 3a 3d 20 30 3b 0a 20  |ELSE.. a := 0;. |
00004130  20 20 20 20 20 62 20 3a  3d 20 4c 6f 61 64 43 61  |     b := LoadCa|
00004140  72 41 64 64 28 61 72 67  31 29 20 7d 0a 0a 20 20  |rAdd(arg1) }..  |
00004150  20 45 4c 53 45 20 7b 0a  20 20 20 20 20 20 78 20  | ELSE {.      x |
00004160  3a 3d 20 4d 6f 76 65 54  6f 41 6e 79 43 52 28 61  |:= MoveToAnyCR(a|
00004170  72 67 31 29 3b 20 4c 6f  63 6b 28 78 2c 20 6b 2e  |rg1); Lock(x, k.|
00004180  72 65 67 29 3b 0a 20 20  20 20 20 20 54 45 53 54  |reg);.      TEST|
00004190  20 68 32 21 61 72 67 32  3c 30 20 54 48 45 4e 20  | h2!arg2<0 THEN |
000041a0  7b 0a 09 20 49 46 20 6b  2e 6c 76 6c 6f 63 3c 3d  |{.. IF k.lvloc<=|
000041b0  68 31 21 61 72 67 32 3c  3d 6b 2e 6c 76 6c 61 62  |h1!arg2<=k.lvlab|
000041c0  20 54 48 45 4e 20 7b 0a  09 20 20 20 20 68 31 21  | THEN {..    h1!|
000041d0  61 72 67 32 2c 20 73 68  20 3a 3d 20 68 31 21 61  |arg2, sh := h1!a|
000041e0  72 67 32 2b 6b 2e 6c 76  73 2c 20 4e 75 6c 6c 3b  |rg2+k.lvs, Null;|
000041f0  0a 09 20 20 20 20 68 34  21 61 72 67 32 20 3a 3d  |..    h4!arg2 :=|
00004200  20 68 34 21 61 72 67 32  2a 34 20 7d 3b 0a 09 20  | h4!arg2*4 };.. |
00004210  62 20 3a 3d 20 4c 6f 6f  6b 46 6f 72 28 61 72 67  |b := LookFor(arg|
00004220  32 2c 20 53 68 69 66 74  65 64 55 70 29 3b 0a 09  |2, ShiftedUp);..|
00004230  20 54 45 53 54 20 62 3e  3d 30 20 26 20 68 34 21  | TEST b>=0 & h4!|
00004240  61 72 67 32 3d 30 20 54  48 45 4e 0a 09 20 20 20  |arg2=0 THEN..   |
00004250  20 73 68 20 3a 3d 20 4e  75 6c 6c 0a 09 20 45 4c  | sh := Null.. EL|
00004260  53 45 0a 09 20 20 20 20  62 20 3a 3d 20 4d 6f 76  |SE..    b := Mov|
00004270  65 54 6f 41 6e 79 43 52  28 61 72 67 32 29 20 7d  |eToAnyCR(arg2) }|
00004280  0a 20 20 20 20 20 20 45  4c 53 45 0a 09 20 62 20  |.      ELSE.. b |
00004290  3a 3d 20 4d 6f 76 65 54  6f 41 6e 79 43 52 28 61  |:= MoveToAnyCR(a|
000042a0  72 67 32 29 20 7d 3b 0a  0a 20 20 20 46 6c 75 73  |rg2) };..   Flus|
000042b0  68 50 65 6e 64 69 6e 67  4c 6f 61 64 73 28 29 3b  |hPendingLoads();|
000042c0  0a 20 20 20 46 6c 75 73  68 50 65 6e 64 69 6e 67  |.   FlushPending|
000042d0  53 74 6f 72 65 73 28 29  3b 0a 20 20 20 4c 6f 63  |Stores();.   Loc|
000042e0  6b 28 62 2c 20 6b 2e 72  65 67 29 3b 0a 20 20 20  |k(b, k.reg);.   |
000042f0  54 45 53 54 20 6f 70 3d  73 2e 70 75 74 62 79 74  |TEST op=s.putbyt|
00004300  65 20 54 48 45 4e 20 7b  0a 20 20 20 20 20 20 72  |e THEN {.      r|
00004310  20 3a 3d 20 4c 6f 61 64  41 72 67 33 54 6f 53 6f  | := LoadArg3ToSo|
00004320  6d 65 43 52 28 29 3b 0a  20 20 20 20 20 20 54 45  |meCR();.      TE|
00004330  53 54 20 78 3d 4e 75 6c  6c 20 54 48 45 4e 0a 09  |ST x=Null THEN..|
00004340  20 47 65 6e 46 32 28 66  2e 73 74 72 62 2c 20 72  | GenF2(f.strb, r|
00004350  2c 20 62 2c 20 6d 2c 20  61 29 0a 20 20 20 20 20  |, b, m, a).     |
00004360  20 45 4c 53 45 0a 09 20  46 32 49 6e 73 74 28 66  | ELSE.. F2Inst(f|
00004370  2e 73 74 72 62 2c 20 72  2c 20 78 2c 20 30 2c 20  |.strb, r, x, 0, |
00004380  62 2c 20 66 2e 70 72 65  75 70 2c 20 73 68 2c 20  |b, f.preup, sh, |
00004390  32 2c 20 6d 2e 61 6c 77  61 79 73 29 3b 0a 20 20  |2, m.always);.  |
000043a0  20 20 20 20 54 45 53 54  20 4c 6f 63 61 6c 73 53  |    TEST LocalsS|
000043b0  61 66 65 20 54 48 45 4e  0a 09 20 44 69 73 63 61  |afe THEN.. Disca|
000043c0  72 64 4e 6f 6e 4c 6f 63  61 6c 52 65 67 73 28 29  |rdNonLocalRegs()|
000043d0  0a 20 20 20 20 20 20 45  4c 53 45 0a 09 20 44 69  |.      ELSE.. Di|
000043e0  73 63 61 72 64 4e 6f 6e  43 6f 6e 73 74 52 65 67  |scardNonConstReg|
000043f0  73 28 29 3b 0a 20 20 20  20 20 20 53 74 61 63 6b  |s();.      Stack|
00004400  28 73 73 70 2d 33 29 20  7d 0a 0a 20 20 20 45 4c  |(ssp-3) }..   EL|
00004410  53 45 20 7b 0a 20 20 20  20 20 20 72 20 3a 3d 20  |SE {.      r := |
00004420  4e 65 78 74 52 28 29 3b  0a 20 20 20 20 20 20 54  |NextR();.      T|
00004430  45 53 54 20 78 3d 4e 75  6c 6c 20 54 48 45 4e 0a  |EST x=Null THEN.|
00004440  09 20 47 65 6e 46 32 28  66 2e 6c 64 72 62 2c 20  |. GenF2(f.ldrb, |
00004450  72 2c 20 62 2c 20 6d 2c  20 61 29 0a 20 20 20 20  |r, b, m, a).    |
00004460  20 20 45 4c 53 45 0a 09  20 46 32 49 6e 73 74 28  |  ELSE.. F2Inst(|
00004470  66 2e 6c 64 72 62 2c 20  72 2c 20 78 2c 20 30 2c  |f.ldrb, r, x, 0,|
00004480  20 62 2c 20 66 2e 70 72  65 75 70 2c 20 73 68 2c  | b, f.preup, sh,|
00004490  20 32 2c 20 6d 2e 61 6c  77 61 79 73 29 3b 0a 20  | 2, m.always);. |
000044a0  20 20 20 20 20 44 69 73  63 61 72 64 52 65 67 28  |     DiscardReg(|
000044b0  72 2c 20 6b 2e 72 65 67  29 3b 0a 20 20 20 20 20  |r, k.reg);.     |
000044c0  20 4c 6f 73 65 28 72 2c  20 6b 2e 72 65 67 29 3b  | Lose(r, k.reg);|
000044d0  0a 20 20 20 20 20 20 55  6e 4c 6f 63 6b 28 62 2c  |.      UnLock(b,|
000044e0  20 6b 2e 72 65 67 29 3b  0a 20 20 20 20 20 20 49  | k.reg);.      I|
000044f0  46 20 78 7e 3d 4e 75 6c  6c 20 54 48 45 4e 20 55  |F x~=Null THEN U|
00004500  6e 4c 6f 63 6b 28 78 2c  20 6b 2e 72 65 67 29 20  |nLock(x, k.reg) |
00004510  7d 20 7d 0a                                       |} }.|
00004514

© Dominic Ford 2021–2025.

Our privacy policy is here.
Last updated: 01 May 2025, 21:49 UTC
Website designed by .