Index: m3back/src/Codex86.i3
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/m3back/src/Codex86.i3,v
retrieving revision 1.28
diff -u -r1.28 Codex86.i3
--- m3back/src/Codex86.i3	24 Feb 2010 12:28:00 -0000	1.28
+++ m3back/src/Codex86.i3	25 Feb 2010 13:03:46 -0000
@@ -8,10 +8,10 @@
 
 INTERFACE Codex86;
 
-IMPORT M3CG, M3ObjFile, TFloat;
+IMPORT M3CG, M3ObjFile, TFloat, Target;
 FROM M3CG IMPORT MType, Label, ByteOffset;
 FROM M3CG_Ops IMPORT ErrorHandler;
-IMPORT M3x86Rep, Wrx86, M3BackInt;
+IMPORT M3x86Rep, Wrx86;
 FROM M3x86Rep IMPORT Operand, NRegs, MVar, x86Var, x86Proc, Regno;
 
 TYPE T <: Public;
@@ -45,14 +45,14 @@
         fstack_swap ();
         fstack_discard ();
         f_loadlit (READONLY flarr: FloatBytes; type: MType);
-        immOp (op: Op; READONLY dest: Operand; READONLY imm: M3BackInt.Int);
+        immOp (op: Op; READONLY dest: Operand; READONLY imm: Target.Int);
         binOp (op: Op; READONLY dest, src: Operand);
         tableOp (op: Op; READONLY dest, index: Operand; scale: INTEGER;
                  table: MVar);
         swapOp (READONLY dest, src: Operand);
         movOp (READONLY dest, src: Operand);
         movDummyReloc (READONLY dest: Operand; sym: INTEGER);
-        movImmT (READONLY dest: Operand; imm: M3BackInt.Int);
+        movImmT (READONLY dest: Operand; imm: Target.Int);
         movImmI (READONLY dest: Operand; imm: INTEGER);
         MOVSWOp ();
         STOSWOp ();
Index: m3back/src/Codex86.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/m3back/src/Codex86.m3,v
retrieving revision 1.89
diff -u -r1.89 Codex86.m3
--- m3back/src/Codex86.m3	25 Feb 2010 10:56:05 -0000	1.89
+++ m3back/src/Codex86.m3	25 Feb 2010 13:03:47 -0000
@@ -379,7 +379,7 @@
     writecode(t, ins);
   END noargOp;
 
-PROCEDURE immOp1 (t: T; op: Op; READONLY dest: Operand; READONLY imm: M3BackInt.Int) =
+PROCEDURE immOp1 (t: T; op: Op; READONLY dest: Operand; READONLY imm: Target.Int) =
   VAR ins: Instruction;
   BEGIN
     <* ASSERT dest.loc = OLoc.register OR dest.loc = OLoc.mem *>
@@ -388,7 +388,7 @@
       t.Err("immOp1: unable to convert immediate to INTEGER:" & M3BackInt.ToDiagnosticText(imm));
     END;
 
-    IF M3BackInt.GE(imm, M3BackInt.Int8.min) AND M3BackInt.LE(imm, M3BackInt.Int8.max) THEN
+    IF TInt.GE(imm, Target.Int8.min) AND TInt.LE(imm, Target.Int8.max) THEN
       ins.imsize := 1;
     ELSE
       ins.imsize := 4;
@@ -416,7 +416,7 @@
         
           (* shifts by a constant 1 have a smaller encoding available *)
 
-          IF op IN SET OF Op{Op.oSHL, Op.oSHR} AND M3BackInt.EQ(imm, M3BackInt.One) THEN
+          IF op IN SET OF Op{Op.oSHL, Op.oSHR} AND TInt.EQ(imm, TInt.One) THEN
             INC(ins.opcode, 16_10);
             ins.imsize := 0;
           END;
@@ -437,13 +437,13 @@
     END
   END immOp1;
 
-PROCEDURE immOp (t: T; op: Op; READONLY dest: Operand; READONLY imm: M3BackInt.Int) =
+PROCEDURE immOp (t: T; op: Op; READONLY dest: Operand; READONLY imm: Target.Int) =
   VAR destA: ARRAY OperandPart OF Operand;
-      immA: ARRAY OperandPart OF M3BackInt.Int;
+      immA: ARRAY OperandPart OF Target.Int;
       immSize := SplitImm(dest.optype, imm, immA);
       destSize := SplitOperand(dest, destA);
       compare_label: Label;
-      immMinus32: M3BackInt.Int;
+      immMinus32: Target.Int;
       shiftCount := Operand{loc := OLoc.imm, imm := imm};
   BEGIN
 
@@ -467,9 +467,9 @@
             t.set_label(compare_label);
 
         | Op.oSHL =>
-            IF M3BackInt.GE(imm, M3BackInt.ThirtyTwo) THEN
-              IF M3BackInt.NE(imm, M3BackInt.ThirtyTwo) THEN
-                EVAL M3BackInt.Subtract(imm, M3BackInt.ThirtyTwo, immMinus32);
+            IF TInt.GE(imm, TInt.ThirtyTwo) THEN
+              IF TInt.NE(imm, TInt.ThirtyTwo) THEN
+                EVAL TInt.Subtract(imm, TInt.ThirtyTwo, immMinus32);
                 (* Ideally we'd do a virtual move in the register alloator. *)
                 movOp1(t, destA[1], destA[0]);
                 immOp1(t, op, destA[1], immMinus32);
@@ -484,9 +484,9 @@
             END
 
         | Op.oSHR =>
-            IF M3BackInt.GE(imm, M3BackInt.ThirtyTwo) THEN
-              IF M3BackInt.NE(imm, M3BackInt.ThirtyTwo) THEN
-                EVAL M3BackInt.Subtract(imm, M3BackInt.ThirtyTwo, immMinus32);
+            IF TInt.GE(imm, TInt.ThirtyTwo) THEN
+              IF TInt.NE(imm, TInt.ThirtyTwo) THEN
+                EVAL TInt.Subtract(imm, TInt.ThirtyTwo, immMinus32);
                 (* Ideally we'd do a virtual move in the register alloator. *)
                 movOp1(t, destA[0], destA[1]);
                 immOp1(t, op, destA[0], immMinus32);
@@ -551,7 +551,7 @@
       <* ASSERT src.loc = OLoc.register *>
       <* ASSERT shiftCount.loc = OLoc.register OR shiftCount.loc = OLoc.imm *>
       <* ASSERT shiftCount.loc # OLoc.register OR shiftCount.reg[0] = ECX *>
-      <* ASSERT shiftCount.loc # OLoc.imm OR (M3BackInt.GE(shiftCount.imm, M3BackInt.Int8.min) AND M3BackInt.LE(shiftCount.imm, M3BackInt.Int8.max)) *>
+      <* ASSERT shiftCount.loc # OLoc.imm OR (TInt.GE(shiftCount.imm, Target.Int8.min) AND TInt.LE(shiftCount.imm, Target.Int8.max)) *>
 
       IF shiftCount.loc = OLoc.imm THEN
         IF NOT M3BackInt.ToInt(shiftCount.imm, ins.imm) THEN
@@ -908,7 +908,7 @@
     t.obj.relocate(t.textsym, t.obj.cursor(Seg.Text) - 4, sym);
   END movDummyReloc;
 
-PROCEDURE movImmT (t: T; READONLY dest: Operand; imm: M3BackInt.Int) =
+PROCEDURE movImmT (t: T; READONLY dest: Operand; imm: Target.Int) =
   VAR ins: Instruction;
   BEGIN
     IF NOT M3BackInt.ToInt(imm, ins.imm) THEN
@@ -923,7 +923,7 @@
       ins.imsize := CG_Bytes[dest.mvar.mvar_type];
       writecode(t, ins);
       log_global_var(t, dest.mvar, -4 - CG_Bytes[dest.mvar.mvar_type]);
-    ELSIF M3BackInt.EQ(imm, TZero) THEN
+    ELSIF TInt.EQ(imm, TZero) THEN
       binOp(t, Op.oXOR, dest, dest);
     ELSE
       ins.opcode := 16_B8 + dest.reg[0];
@@ -934,10 +934,10 @@
   END movImmT;
 
 PROCEDURE movImmI (t: T; READONLY dest: Operand; imm: INTEGER) =
-  VAR immT: M3BackInt.Int;
+  VAR immT: Target.Int;
   BEGIN
     IF NOT M3BackInt.FromInt(imm, BYTESIZE(imm), immT) THEN
-      t.Err("movImmI: unable to convert INTEGER to M3BackInt.Int");
+      t.Err("movImmI: unable to convert INTEGER to Target.Int");
     END;
     t.movImmT(dest, immT);
   END movImmI;
@@ -2039,7 +2039,7 @@
       CASE op.loc OF
         OLoc.fstack   => Mn (t, " FST");
       | OLoc.register => Mn (t, " ", RegName[op.reg[0]]);
-      | OLoc.imm      => Mn (t, " $", M3BackInt.ToText (op.imm));
+      | OLoc.imm      => Mn (t, " $", TInt.ToText (op.imm));
       | OLoc.mem      => MnMVar (t, op.mvar);
       END
     END
@@ -2096,10 +2096,10 @@
     END;
   END MnProc;
 
-PROCEDURE MnImmTInt(t: T; READONLY imm: M3BackInt.Int) =
+PROCEDURE MnImmTInt(t: T; READONLY imm: Target.Int) =
   BEGIN
     IF t.debug THEN
-      Mn(t, " $", M3BackInt.ToText (imm));
+      Mn(t, " $", TInt.ToText (imm));
     END;
   END MnImmTInt;
 
Index: m3back/src/M3BackInt.i3
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/m3back/src/M3BackInt.i3,v
retrieving revision 1.13
diff -u -r1.13 M3BackInt.i3
--- m3back/src/M3BackInt.i3	25 Feb 2010 10:56:05 -0000	1.13
+++ m3back/src/M3BackInt.i3	25 Feb 2010 13:03:47 -0000
@@ -21,36 +21,7 @@
 IMPORT Target, TInt;
 
 TYPE
-  Int = (* OPAQUE *) RECORD
-    n: CARDINAL := NUMBER (IBytes); (* only bytes [0..n-1] contain valid bits *)
-    x := TInt.Zero;                 (* default is Zero *)
-  END;
-  IBytes = Target.Int;
-  IByte = Target.IByte;
-
-CONST
-  Zero      = Int{x := TInt.Zero};
-  One       = Int{x := TInt.One};
-  Two       = Int{x := IBytes{ 2,0,..}};
-  Three     = Int{x := IBytes{ 3,0,..}};
-  Four      = Int{x := IBytes{ 4,0,..}};
-  Eight     = Int{x := IBytes{ 8,0,..}};
-  Ten       = Int{x := IBytes{10,0,..}};
-  ThirtyOne = Int{x := IBytes{31,0,..}};
-  ThirtyTwo = Int{x := IBytes{32,0,..}};
-  SixtyThree= Int{x := IBytes{63,0,..}};
-  SixtyFour = Int{x := IBytes{64,0,..}};
-  F3FF      = Int{x := IBytes{16_FF,16_F3,0,..}};
-  x0400     = Int{x := IBytes{0,4,0,..}};
-  x0800     = Int{x := IBytes{0,8,0,..}};
-  x0F00     = Int{x := IBytes{0,16_F,0,..}};
-  MaxU8     = Int{x := IBytes{16_FF,0,..}};
-
-  (* 'M' for Minus (negative) *)
-
-  MOne       = Int{x := TInt.MOne};
-  MThirtyOne = Int{x := IBytes{16_E1,16_FF,..}};
-  MSixtyThree= Int{x := IBytes{16_C1,16_FF,..}};
+  Int = Target.Int;
 
 PROCEDURE FromInt (x: INTEGER;  n: CARDINAL;  VAR i: Int): BOOLEAN;
 (* converts a host integer 'x' to a target integer 'i' *)
@@ -58,75 +29,8 @@
 PROCEDURE ToInt (READONLY i: Int;  VAR x: INTEGER): BOOLEAN;
 (* converts a target integer 'i' to a host integer 'x' *)
 
-PROCEDURE Abs (READONLY a: Int;  VAR r: Int): BOOLEAN;
-(* returns a if a >= 0, -a if a < 0, or overflow *)
-
-PROCEDURE Add (READONLY a, b: Int;  VAR i: Int): BOOLEAN;
-(* returns 'a + b' unless there's an overflow *)
-
-PROCEDURE Subtract (READONLY a, b: Int;  VAR i: Int): BOOLEAN;
-(* returns 'a - b' unless there's an overflow *)
-
-PROCEDURE Negate (READONLY a: Int;  VAR r: Int): BOOLEAN;
-(* returns '-a' unless there's an overflow *)
-
-PROCEDURE Multiply (READONLY a, b: Int;  VAR i: Int): BOOLEAN;
-(* returns 'a * b' unless there's an overflow *)
-
-PROCEDURE Div (READONLY a, b: Int;  VAR i: Int): BOOLEAN;
-(* returns 'a DIV b' unless there's an overflow *)
-
-PROCEDURE Mod (READONLY a, b: Int;  VAR i: Int): BOOLEAN;
-(* returns 'a MOD b' unless there's an overflow *)
-
-PROCEDURE EQ (READONLY a, b: Int): BOOLEAN;
-(* returns 'a = b' *)
-
-PROCEDURE NE (READONLY a, b: Int): BOOLEAN;
-(* returns 'a # b' *)
-
-PROCEDURE LT (READONLY a, b: Int): BOOLEAN;
-(* returns 'a < b' *)
-
-PROCEDURE GT (READONLY a, b: Int): BOOLEAN;
-(* returns 'a > b' *)
-
-PROCEDURE LE (READONLY a, b: Int): BOOLEAN;
-(* returns 'a <= b' *)
-
-PROCEDURE GE (READONLY a, b: Int): BOOLEAN;
-(* returns 'a >= b' *)
-
-PROCEDURE ToText (READONLY i: Int): TEXT;
-(* converts 'i' to a printable string. *)
-
-PROCEDURE ToChars (READONLY i: Int;  VAR buf: ARRAY OF CHAR): INTEGER;
-(* converts 'i' to a printable string in 'buf'.  Returns the
-   number of characters in the string.  Returns -1 if 'buf' is too short. *)
-
 PROCEDURE FromTargetInt (READONLY i: Target.Int; byteSize: CARDINAL): Int;
 
-TYPE
-  Int_type = RECORD (* Like Target.Int_type *)
-    size    : CARDINAL;  (* bit size *)
-    bytes   : CARDINAL;  (* byte size *)
-    min     : Int;       (* minimum value of this type *)
-    max     : Int;       (* maximum value of this type *)
-  END;
-
-VAR (* CONST *)
-  Integer: Int_type;
-  Int8: Int_type;
-  Int16: Int_type;
-  Int32: Int_type;
-  Int64: Int_type;
-  Word8: Int_type;
-  Word16: Int_type;
-  Word32: Int_type;
-  Word64: Int_type;
-
-PROCEDURE Init();
-
 PROCEDURE ToDiagnosticText(a: Int): TEXT;
 
 END M3BackInt.
Index: m3back/src/M3BackInt.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/m3back/src/M3BackInt.m3,v
retrieving revision 1.15
diff -u -r1.15 M3BackInt.m3
--- m3back/src/M3BackInt.m3	25 Feb 2010 10:56:05 -0000	1.15
+++ m3back/src/M3BackInt.m3	25 Feb 2010 13:03:47 -0000
@@ -8,181 +8,35 @@
 
 MODULE M3BackInt; (* also known as TInt *)
 
-IMPORT Target, Word, Text, Fmt, TInt;
-
-CONST
-  Mask     = 16_FF;
-  SignMask = 16_80;
-
-PROCEDURE SignExtend(READONLY a: Int): Target.Int =
-(*
-    sign extend to the precision of Target.Int
-*)
-  VAR b: Target.Int;
-      extend := 0;
-  BEGIN
-
-    <* ASSERT LAST(a.x) = LAST(b) *>
-
-    FOR i := 0 TO a.n - 1 DO
-      b[i] := a.x[i];
-    END;
-    IF Word.And(a.x[a.n - 1], SignMask) # 0 THEN
-      extend := Mask;
-    END;
-    FOR i := a.n TO LAST(b) DO
-      b[i] := extend;
-    END;
-    RETURN b;
-  END SignExtend;
+IMPORT  Text, Fmt, TInt;
 
 PROCEDURE SignedTruncate(VAR a: Int; n: CARDINAL): BOOLEAN =
-(*
-    check that it fits, by seeing if the sign extension is correct
-*)
-  VAR extend := 0;
   BEGIN
-    <* ASSERT n # 0 *>
-    <* ASSERT n <= NUMBER(a.x) *>
-
-    IF Word.And(a.x[LAST(a.x)], SignMask) # 0 THEN
-      extend := Mask;
-    END;
-    FOR i := n TO LAST(a.x) DO
-      IF a.x[i] # extend THEN
-        RETURN FALSE;
-      END;
-    END;
-    a.n := n;
-
+    TInt.Chop(a, n);
     RETURN TRUE;
-
   END SignedTruncate;
 
 PROCEDURE FromInt (x: INTEGER;  n: CARDINAL;  VAR r: Int): BOOLEAN =
   BEGIN
-    RETURN TInt.FromInt(x, r.x) AND SignedTruncate(r, n);
+    RETURN TInt.FromInt(x, r) AND SignedTruncate(r, n);
   END FromInt;
 
 PROCEDURE ToInt (READONLY r: Int;  VAR x: INTEGER): BOOLEAN =
   VAR r4 := r;
   BEGIN
-    r4.n := 4;
-    RETURN TInt.ToInt(SignExtend(r4), x);
+    TInt.Chop(r4, 4);
+    RETURN TInt.ToInt(r4, x);
   END ToInt;
 
-PROCEDURE Add (READONLY a, b: Int;  VAR r: Int): BOOLEAN =
+PROCEDURE FromTargetInt (READONLY i: Int; byteSize: CARDINAL): Int =
+  VAR j: Int;
   BEGIN
-    RETURN TInt.Add(SignExtend(a), SignExtend(b), r.x) AND SignedTruncate(r, MIN(a.n, b.n));
-  END Add;
-
-PROCEDURE Subtract (READONLY a, b: Int;  VAR r: Int): BOOLEAN =
-  BEGIN
-    RETURN TInt.Subtract(SignExtend(a), SignExtend(b), r.x) AND SignedTruncate(r, MIN(a.n, b.n));
-  END Subtract;
-
-PROCEDURE Negate (READONLY a: Int;  VAR r: Int): BOOLEAN =
-  BEGIN
-    RETURN Subtract(Zero, a, r);
-  END Negate;
-  
-PROCEDURE Abs (READONLY a: Int;  VAR r: Int): BOOLEAN =
-  BEGIN
-    IF GE(a, Zero) THEN
-      r := a;
-      RETURN TRUE;
-    END;
-    RETURN Negate(a, r);
-  END Abs;
-
-PROCEDURE Multiply (READONLY a, b: Int;  VAR r: Int): BOOLEAN =
-  BEGIN
-    RETURN TInt.Multiply(SignExtend(a), SignExtend(b), r.x) AND SignedTruncate(r, MIN(a.n, b.n));
-  END Multiply;
-
-PROCEDURE Div (READONLY num, den: Int;  VAR q: Int): BOOLEAN =
-  BEGIN
-    RETURN TInt.Div(SignExtend(num), SignExtend(den), q.x) AND SignedTruncate(q, MIN(num.n, den.n));
-  END Div;
-
-PROCEDURE Mod (READONLY num, den: Int;  VAR r: Int): BOOLEAN =
-  BEGIN
-    RETURN TInt.Mod(SignExtend(num), SignExtend(den), r.x) AND SignedTruncate(r, MIN(num.n, den.n));
-  END Mod;
-
-PROCEDURE EQ (READONLY a, b: Int): BOOLEAN =
-  BEGIN
-    RETURN TInt.EQ(SignExtend(a), SignExtend(b));
-  END EQ;
-
-PROCEDURE LT (READONLY a, b: Int): BOOLEAN =
-  BEGIN
-    RETURN TInt.LT(SignExtend(a), SignExtend(b));
-  END LT;
-
-PROCEDURE LE (READONLY a, b: Int): BOOLEAN =
-  BEGIN
-    RETURN EQ (a, b) OR LT (a, b);
-  END LE;
-
-PROCEDURE NE (READONLY a, b: Int): BOOLEAN =
-  BEGIN
-    RETURN NOT EQ (a, b);
-  END NE;
-
-PROCEDURE GT (READONLY a, b: Int): BOOLEAN =
-  BEGIN
-    RETURN LT (b, a);
-  END GT;
-
-PROCEDURE GE (READONLY a, b: Int): BOOLEAN = 
-  BEGIN
-    RETURN LE(b, a);
-  END GE;
-
-PROCEDURE ToText (READONLY r: Int): TEXT =
-  VAR result  : ARRAY [0..BITSIZE (IByte) * NUMBER (IBytes)] OF CHAR;
-  BEGIN
-    RETURN Text.FromChars(SUBARRAY(result, 0, ToChars(r, result)));
-  END ToText;
-
-PROCEDURE ToChars (READONLY r: Int;  VAR buf: ARRAY OF CHAR): INTEGER =
-  BEGIN
-    RETURN TInt.ToChars(SignExtend(r), buf);
-  END ToChars;
-
-PROCEDURE FromTargetInt (READONLY i: Target.Int; byteSize: CARDINAL): Int =
-  BEGIN
-    RETURN Int{n := byteSize, x := i};
+    j := i;
+    TInt.Chop(j, byteSize);
+    RETURN j;
   END FromTargetInt;
 
-PROCEDURE InitInt(VAR a: Int_type; READONLY b: Target.Int_type) =
-  BEGIN
-    a.size := b.size;
-    a.bytes := b.bytes;
-    a.min := FromTargetInt(b.min, 8);
-    a.max := FromTargetInt(b.max, 8);
-  END InitInt;
-
-PROCEDURE Init() =
-  BEGIN
-    InitInt(Int8, Target.Int8);
-    InitInt(Int16, Target.Int16);
-    InitInt(Int32, Target.Int32);
-    InitInt(Int64, Target.Int64);
-    InitInt(Word8, Target.Word8);
-    InitInt(Word16, Target.Word16);
-    InitInt(Word32, Target.Word32);
-    InitInt(Word64, Target.Word64);
-    InitInt(Integer, Target.Integer);
-  END Init;
-
 PROCEDURE ToDiagnosticText(a: Int): TEXT =
-  BEGIN
-    RETURN "n:" & Fmt.Unsigned(a.n) & ",x:" & TargetIntToDiagnosticText(a.x);
-  END ToDiagnosticText;
-
-PROCEDURE TargetIntToDiagnosticText(a: Target.Int): TEXT =
   VAR t := "";
   BEGIN
     FOR i := FIRST(a) TO LAST(a) DO
@@ -192,7 +46,7 @@
       END;
     END;
     RETURN t;
-  END TargetIntToDiagnosticText;
+  END ToDiagnosticText;
 
 BEGIN
 END M3BackInt.
Index: m3back/src/M3x86.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/m3back/src/M3x86.m3,v
retrieving revision 1.140
diff -u -r1.140 M3x86.m3
--- m3back/src/M3x86.m3	25 Feb 2010 10:56:05 -0000	1.140
+++ m3back/src/M3x86.m3	25 Feb 2010 13:03:47 -0000
@@ -7,9 +7,9 @@
 
 MODULE M3x86 EXPORTS M3x86, M3x86Rep;
 
-IMPORT Wr, Text, Fmt, IntRefTbl, Word;
+IMPORT Wr, Text, Fmt, IntRefTbl, Word, TWord;
 IMPORT M3CG, M3ID, M3CG_Ops, Target, TFloat;
-IMPORT M3BackInt, M3BackWord;
+IMPORT M3BackInt, TInt;
 IMPORT M3ObjFile, TargetMap;
 
 FROM TargetMap IMPORT CG_Bytes;
@@ -249,11 +249,10 @@
                 runtime := NEW (IntRefTbl.Default).init (20));
   BEGIN
 
-    M3BackInt.Init();
-    IntType[Type. Int32] := M3BackInt.Int32;
-    IntType[Type. Int64] := M3BackInt.Int64;
-    IntType[Type.Word32] := M3BackInt.Word32;
-    IntType[Type.Word64] := M3BackInt.Word64;
+    IntType[Type. Int32] := Target.Int32;
+    IntType[Type. Int64] := Target.Int64;
+    IntType[Type.Word32] := Target.Word32;
+    IntType[Type.Word64] := Target.Word64;
 
     IF logfile # NIL THEN
       u.debug := TRUE;
@@ -494,10 +493,8 @@
   END declare_set;
 
 PROCEDURE declare_subrange (u: U; t, domain: TypeUID;
-                            READONLY xmin, xmax: Target.Int;
+                            READONLY min, max: Target.Int;
                             s: BitSize) =
-  VAR min := M3BackInt.FromTargetInt(xmin, NUMBER(xmin));
-      max := M3BackInt.FromTargetInt(xmax, NUMBER(xmax));
   BEGIN
     IF u.debug THEN
       u.wr.Cmd  ("declare_subrange");
@@ -1365,7 +1362,7 @@
     u.cg.pushOp(u.cg.reg[EBP]);
     u.cg.movOp(u.cg.reg[EBP], u.cg.reg[ESP]);
 
-    u.cg.immOp(Op.oSUB, u.cg.reg[ESP], M3BackInt.Word16.max);
+    u.cg.immOp(Op.oSUB, u.cg.reg[ESP], Target.Word16.max);
     u.procframe_ptr := u.obj.cursor(Seg.Text) - 4;
 
     u.cg.pushOp(u.cg.reg[EBX]);
@@ -2136,7 +2133,7 @@
          stack1 = u.vstack.pos(1, "set_singleton") DO
 
       (* Better would be:
-      IF u.vstack.loc(stack0) # OLoc.imm OR M3BackWord.GT(u.vstack.op(stack0).imm, M3BackInt.MaxU8) THEN
+      IF u.vstack.loc(stack0) # OLoc.imm OR TWord.GT(u.vstack.op(stack0).imm, Target.Word8.max) THEN
         u.vstack.find(stack0, Force.anyreg);
       ELSE
         u.vstack.find(stack0, Force.any);
@@ -2257,7 +2254,7 @@
 
       <* ASSERT u.vstack.loc(stack0) # OLoc.imm *>
 
-      (*IF u.vstack.loc(stack0) # OLoc.imm OR M3BackWord.GT(u.vstack.op(stack0).imm, M3BackInt.MaxU8) THEN*)
+      (*IF u.vstack.loc(stack0) # OLoc.imm OR TWord.GT(u.vstack.op(stack0).imm, Target.Word8.max) THEN*)
         u.vstack.find(stack0, Force.anyreg);
       (*ELSE*)
         (*u.vstack.find(stack0, Force.any);*)
@@ -2273,7 +2270,7 @@
 
 PROCEDURE not (u: U;  t: IType) =
   (* s0.t := Word.Not (s0.t) *)
-  VAR not: M3BackInt.Int;
+  VAR not: Target.Int;
   BEGIN
     IF u.debug THEN
       u.wr.Cmd   ("not");
@@ -2283,7 +2280,7 @@
 
     WITH stack0 = u.vstack.pos(0, "not") DO
       IF u.vstack.loc(stack0) = OLoc.imm THEN
-        M3BackWord.Not (u.vstack.op(stack0).imm, not);
+        TWord.Not (u.vstack.op(stack0).imm, not);
         u.vstack.set_imm(stack0, not);
       ELSE
         u.vstack.unlock();
@@ -2348,8 +2345,8 @@
 
 PROCEDURE shift_left   (u: U;  t: IType) =
   (* s1.t := Word.Shift  (s1.t, s0.t) ; pop *)
-  VAR shiftResult: M3BackInt.Int;
-      and: M3BackInt.Int;
+  VAR shiftResult: Target.Int;
+      and: Target.Int;
       shiftCount: INTEGER;
   BEGIN
     IF u.debug THEN
@@ -2369,21 +2366,21 @@
 
           (* shift constant by a constant *)
 
-          M3BackWord.Shift(u.vstack.op(stack1).imm, shiftCount, shiftResult);
+          TWord.Shift(u.vstack.op(stack1).imm, shiftCount, shiftResult);
           u.vstack.set_imm(stack1, shiftResult);
         ELSE
           (* shift non-constant by a constant *)
 
-          M3BackWord.And(u.vstack.op(stack0).imm, MaximumShift[t], and);
+          TWord.And(u.vstack.op(stack0).imm, MaximumShift[t], and);
           u.vstack.set_imm(stack0, and);
-          IF M3BackInt.NE(u.vstack.op(stack0).imm, TZero) THEN
+          IF TInt.NE(u.vstack.op(stack0).imm, TZero) THEN
             u.vstack.find(stack1, Force.anytemp);
             u.cg.immOp(Op.oSHL, u.vstack.op(stack1), u.vstack.op(stack0).imm);
             u.vstack.newdest(u.vstack.op(stack1));
           END
         END
       ELSE
-        IF (u.vstack.loc(stack1) # OLoc.imm) OR M3BackInt.NE(u.vstack.op(stack1).imm, TZero) THEN
+        IF (u.vstack.loc(stack1) # OLoc.imm) OR TInt.NE(u.vstack.op(stack1).imm, TZero) THEN
 
           (* shift non-constant *)
 
@@ -2410,8 +2407,8 @@
 PROCEDURE shift_right  (u: U;  t: IType) =
   (* s1.t := Word.Shift  (s1.t, -s0.t) ; pop *)
   VAR shiftCount: INTEGER;
-      shift: M3BackInt.Int;
-      and: M3BackInt.Int;
+      shift: Target.Int;
+      and: Target.Int;
   BEGIN
     IF u.debug THEN
       u.wr.Cmd   ("shift_right");
@@ -2430,15 +2427,15 @@
           IF NOT M3BackInt.ToInt(u.vstack.op(stack0).imm, shiftCount) THEN
             u.Err("unable to convert shift count to host integer");
           END;
-          M3BackWord.Shift(u.vstack.op(stack1).imm, -shiftCount, shift);
+          TWord.Shift(u.vstack.op(stack1).imm, -shiftCount, shift);
           u.vstack.set_imm(stack1, shift);
         ELSE
 
           (* shift a non-constant by a constant *)
 
-          M3BackWord.And(u.vstack.op(stack0).imm, MaximumShift[t], and);
+          TWord.And(u.vstack.op(stack0).imm, MaximumShift[t], and);
           u.vstack.set_imm(stack0, and);
-          IF M3BackInt.NE(u.vstack.op(stack0).imm, TZero) THEN
+          IF TInt.NE(u.vstack.op(stack0).imm, TZero) THEN
             u.vstack.find(stack1, Force.anytemp);
             u.cg.immOp(Op.oSHR, u.vstack.op(stack1), u.vstack.op(stack0).imm);
             u.vstack.newdest(u.vstack.op(stack1));
@@ -2448,7 +2445,7 @@
 
         (* shift a non-constant or non-zero *)
 
-        IF ((u.vstack.loc(stack1) # OLoc.imm) OR (M3BackInt.NE(u.vstack.op(stack1).imm, TZero))) THEN
+        IF ((u.vstack.loc(stack1) # OLoc.imm) OR (TInt.NE(u.vstack.op(stack1).imm, TZero))) THEN
           IF Is64(t) THEN
             do_custom_calling_convention_shift_64 (u, Builtin.shift_right_64);
             RETURN;
@@ -2488,8 +2485,8 @@
 PROCEDURE rotate_left  (u: U;  t: IType) =
   (* s1.t := Word.Rotate (s1.t, s0.t) ; pop *)
   VAR rotateCount: INTEGER;
-      rotate: M3BackInt.Int;
-      and: M3BackInt.Int;
+      rotate: Target.Int;
+      and: Target.Int;
   BEGIN
     IF u.debug THEN
       u.wr.Cmd   ("rotate_left");
@@ -2505,10 +2502,10 @@
           IF NOT M3BackInt.ToInt(u.vstack.op(stack0).imm, rotateCount) THEN
             u.Err("unable to convert rotate count to host integer");
           END;
-          M3BackWord.Rotate(u.vstack.op(stack1).imm, rotateCount, rotate);
+          TWord.Rotate(u.vstack.op(stack1).imm, rotateCount, GetTypeSize(u.vstack.op(stack1).optype) * 4, rotate);
           u.vstack.set_imm(stack1, rotate);
         ELSE
-          M3BackWord.And(u.vstack.op(stack0).imm, MaximumShift[t], and);
+          TWord.And(u.vstack.op(stack0).imm, MaximumShift[t], and);
           u.vstack.set_imm(stack0, and);
           IF Is64(t) THEN
             do_rotate_or_shift_64(u, Builtin.rotate_left64);
@@ -2541,8 +2538,8 @@
 PROCEDURE rotate_right (u: U;  t: IType) =
   (* s1.t := Word.Rotate (s1.t, -s0.t) ; pop *)
   VAR rotateCount: INTEGER;
-      rotate: M3BackInt.Int;
-      and: M3BackInt.Int;
+      rotate: Target.Int;
+      and: Target.Int;
   BEGIN
     IF u.debug THEN
       u.wr.Cmd   ("rotate_right");
@@ -2558,10 +2555,10 @@
           IF NOT M3BackInt.ToInt(u.vstack.op(stack0).imm, rotateCount) THEN
             u.Err("unable to convert rotate count to host integer");
           END;
-          M3BackWord.Rotate(u.vstack.op(stack1).imm, -rotateCount, rotate);
+          TWord.Rotate(u.vstack.op(stack1).imm, -rotateCount, GetTypeSize(u.vstack.op(stack1).optype) * 4, rotate);
           u.vstack.set_imm(stack1, rotate);
         ELSE
-          M3BackWord.And(u.vstack.op(stack0).imm, MaximumShift[t], and);
+          TWord.And(u.vstack.op(stack0).imm, MaximumShift[t], and);
           u.vstack.set_imm(stack0, and);
           IF Is64(t) THEN
             do_rotate_or_shift_64(u, Builtin.rotate_right64);
@@ -2776,7 +2773,7 @@
   (* Mem[s2.A:s0.z] := Mem[s1.A:s0.z]; pop(3)*)
   CONST Mover = ARRAY BOOLEAN OF Builtin { Builtin.memcpy, Builtin.memmove };
   VAR n: INTEGER;  mover := Mover [overlap];
-      shift: M3BackInt.Int;
+      shift: Target.Int;
   BEGIN
     IF u.debug THEN
       u.wr.Cmd   ("copy_n");
@@ -2802,9 +2799,9 @@
         u.vstack.unlock();
 
         CASE CG_Bytes[t] OF
-          2 => shift := M3BackInt.One;
-        | 4 => shift := M3BackInt.Two;
-        | 8 => shift := M3BackInt.Three;
+          2 => shift := TInt.One;
+        | 4 => shift := TInt.Two;
+        | 8 => shift := TInt.Three;
         ELSE
           u.Err("Unknown MType size in copy_n");
         END;
@@ -2851,7 +2848,7 @@
   END inline_copy;
 
 PROCEDURE string_copy (u: U; n, size: INTEGER; forward: BOOLEAN) =
-  VAR tn, tNMinus1, tsize, tint: M3BackInt.Int;
+  VAR tn, tNMinus1, tsize, tint: Target.Int;
   BEGIN
     u.vstack.corrupt(ECX, operandPart := 0);
     u.cg.movImmI(u.cg.reg[ECX], n);
@@ -2859,16 +2856,16 @@
     IF forward THEN
       u.cg.noargOp(Op.oCLD);
     ELSE
-      IF NOT M3BackInt.FromInt(n, M3BackInt.Integer.bytes, tn) THEN
+      IF NOT M3BackInt.FromInt(n, Target.Integer.bytes, tn) THEN
         u.Err("string_copy: unable to convert n to target int");
       END;
-      IF NOT M3BackInt.FromInt(size, M3BackInt.Integer.bytes, tsize) THEN
+      IF NOT M3BackInt.FromInt(size, Target.Integer.bytes, tsize) THEN
         u.Err("string_copy: unable to convert size to target int");
       END;
-      IF NOT M3BackInt.Subtract(tn, M3BackInt.One, tNMinus1) THEN
+      IF NOT TInt.Subtract(tn, TInt.One, tNMinus1) THEN
         u.Err("string_copy: Subtract overflowed");
       END;
-      IF NOT M3BackInt.Multiply(tNMinus1, tsize, tint) THEN
+      IF NOT TInt.Multiply(tNMinus1, tsize, tint) THEN
         u.Err("string_copy: Multiply overflowed");
       END;
       u.cg.immOp(Op.oADD, u.cg.reg[ESI], tint);
@@ -2967,7 +2964,7 @@
 PROCEDURE zero_n (u: U;  z: IType;  t: MType) =
   (* Mem[s1.A:s0.z] := 0; pop(2) *)
   VAR n: INTEGER;
-      shift: M3BackInt.Int;
+      shift: Target.Int;
   BEGIN
     IF u.debug THEN
       u.wr.Cmd   ("zero_n");
@@ -2993,9 +2990,9 @@
         u.vstack.find(stack0, Force.anyreg);
 
         CASE CG_Bytes[t] OF
-          2 => shift := M3BackInt.One;
-        | 4 => shift := M3BackInt.Two;
-        | 8 => shift := M3BackInt.Three;
+          2 => shift := TInt.One;
+        | 4 => shift := TInt.Two;
+        | 8 => shift := TInt.Three;
         ELSE
           u.Err("Unknown MType size in zero_n");
         END;
@@ -3206,7 +3203,7 @@
     u.vstack.unlock();
     WITH stack0 = u.vstack.pos(0, "check_nil") DO
       IF u.vstack.loc(stack0) = OLoc.imm THEN
-        IF M3BackInt.EQ(u.vstack.op(stack0).imm, TZero) THEN
+        IF TInt.EQ(u.vstack.op(stack0).imm, TZero) THEN
           reportfault(u, code);
         END
       ELSE
@@ -3241,14 +3238,14 @@
     u.vstack.unlock();
     WITH stack0 = u.vstack.pos(0, "check_lo") DO
       IF u.vstack.loc(stack0) = OLoc.imm THEN
-        IF M3BackInt.LT(u.vstack.op(stack0).imm, i) THEN
+        IF TInt.LT(u.vstack.op(stack0).imm, i) THEN
           reportfault(u, code);
         END
       ELSE
         u.vstack.find(stack0, Force.anyreg);
-        IF M3BackInt.GE(u.vstack.lower(u.vstack.reg(stack0)), i) THEN
+        IF TInt.GE(u.vstack.lower(u.vstack.reg(stack0)), i) THEN
           (* ok *)
-        ELSIF M3BackInt.LT(u.vstack.upper(u.vstack.reg(stack0)), i) THEN
+        ELSIF TInt.LT(u.vstack.upper(u.vstack.reg(stack0)), i) THEN
           reportfault(u, code);
         ELSE
           u.cg.immOp(Op.oCMP, u.vstack.op(stack0), i);
@@ -3278,14 +3275,14 @@
     u.vstack.unlock();
     WITH stack0 = u.vstack.pos(0, "check_hi") DO
       IF u.vstack.loc(stack0) = OLoc.imm THEN
-        IF M3BackInt.LT(i, u.vstack.op(stack0).imm) THEN
+        IF TInt.LT(i, u.vstack.op(stack0).imm) THEN
           reportfault(u, code);
         END
       ELSE
         u.vstack.find(stack0, Force.anyreg);
-        IF M3BackInt.LE(u.vstack.upper(u.vstack.reg(stack0)), i) THEN
+        IF TInt.LE(u.vstack.upper(u.vstack.reg(stack0)), i) THEN
           (* ok *)
-        ELSIF M3BackInt.GT(u.vstack.lower(u.vstack.reg(stack0)), i) THEN
+        ELSIF TInt.GT(u.vstack.lower(u.vstack.reg(stack0)), i) THEN
           reportfault(u, code);
         ELSE
           u.cg.immOp(Op.oCMP, u.vstack.op(stack0), i);
@@ -3301,7 +3298,7 @@
 
 PROCEDURE check_range (u: U;  t: IType;  READONLY xa, xb: Target.Int;  code: RuntimeError) =
   (* IF (s0.t < a) OR (b < s0.t) THEN abort(code) *)
-  VAR lo, hi: M3BackInt.Int;
+  VAR lo, hi: Target.Int;
       safelab, outrange: Label;
       a := M3BackInt.FromTargetInt(xa, CG_Bytes[t]);
       b := M3BackInt.FromTargetInt(xb, CG_Bytes[t]);
@@ -3318,7 +3315,7 @@
     WITH stack0 = u.vstack.pos(0, "check_range") DO
       IF u.vstack.loc(stack0) = OLoc.imm THEN
         lo := u.vstack.op(stack0).imm;
-        IF M3BackInt.LT(lo, a) OR M3BackInt.LT(b, lo) THEN
+        IF TInt.LT(lo, a) OR TInt.LT(b, lo) THEN
           reportfault(u, code);
         END;
         RETURN;
@@ -3328,15 +3325,15 @@
       WITH reg = u.vstack.reg(stack0) DO
         lo := u.vstack.lower(reg);
         hi := u.vstack.upper(reg);
-        IF M3BackInt.LE(a, lo) AND M3BackInt.LE(hi, b) THEN
+        IF TInt.LE(a, lo) AND TInt.LE(hi, b) THEN
           (* ok *)
-        ELSIF M3BackInt.LT(hi, a) OR M3BackInt.LT(b, lo) THEN
+        ELSIF TInt.LT(hi, a) OR TInt.LT(b, lo) THEN
           reportfault(u, code);
-        ELSIF M3BackInt.LE(hi, b) THEN
+        ELSIF TInt.LE(hi, b) THEN
           check_lo(u, t, xa, code);
-        ELSIF M3BackInt.GE(lo, a) THEN
+        ELSIF TInt.GE(lo, a) THEN
           check_hi(u, t, xb, code);
-        ELSIF M3BackInt.EQ(a, TZero) THEN
+        ELSIF TInt.EQ(a, TZero) THEN
           (* 0 <= x <= b  ==>   UNSIGNED(x) <= b *)
           safelab := u.cg.reserve_labels(1, TRUE);
           u.cg.immOp(Op.oCMP, u.vstack.op(stack0), b);
@@ -3383,7 +3380,7 @@
          stack1 = u.vstack.pos(1, "check_index") DO
       IF u.vstack.loc(stack0) = OLoc.imm AND
          u.vstack.loc(stack1) = OLoc.imm THEN
-        IF M3BackWord.LE(u.vstack.op(stack0).imm, u.vstack.op(stack1).imm) THEN
+        IF TWord.LE(u.vstack.op(stack0).imm, u.vstack.op(stack1).imm) THEN
           reportfault(u, code);
         END
       ELSE
@@ -3504,7 +3501,7 @@
 
 PROCEDURE add_offset (u: U; i: INTEGER) =
   (* s0.A := s0.A + i *)
-  VAR ti, imm_plus_i: M3BackInt.Int;
+  VAR ti, imm_plus_i: Target.Int;
   BEGIN
     IF u.debug THEN
       u.wr.Cmd   ("add_offset");
@@ -3512,14 +3509,14 @@
       u.wr.NL    ();
     END;
 
-    IF NOT M3BackInt.FromInt(i, M3BackInt.Integer.bytes, ti) THEN
+    IF NOT M3BackInt.FromInt(i, Target.Integer.bytes, ti) THEN
       u.Err("add_offset: failed to convert i to target integer");
     END;
 
     u.vstack.unlock();
     WITH stack0 = u.vstack.pos(0, "add_offset") DO
       IF u.vstack.loc(stack0) = OLoc.imm THEN
-        IF NOT M3BackInt.Add(u.vstack.op(stack0).imm, ti, imm_plus_i) THEN
+        IF NOT TInt.Add(u.vstack.op(stack0).imm, ti, imm_plus_i) THEN
           u.Err("add_offset: Add overflowed");
         END;
         u.vstack.set_imm(stack0, imm_plus_i);
@@ -3697,9 +3694,9 @@
       IF Target.FloatType [t] THEN
         <* ASSERT depth = 0 *>
         IF t = Type.Reel THEN
-          u.cg.immOp(Op.oSUB, u.cg.reg[ESP], M3BackInt.Four);
+          u.cg.immOp(Op.oSUB, u.cg.reg[ESP], TInt.Four);
         ELSE
-          u.cg.immOp(Op.oSUB, u.cg.reg[ESP], M3BackInt.Eight);
+          u.cg.immOp(Op.oSUB, u.cg.reg[ESP], TInt.Eight);
         END;
         u.cg.f_storeind(u.cg.reg[ESP], 0, t);
       ELSE
@@ -3725,7 +3722,7 @@
    * NOTE that we implement call by value, the struct is
    * copied to temporary space on the machine stack
    *)
-  VAR ts: M3BackInt.Int;
+  VAR ts: Target.Int;
   BEGIN
     IF u.debug THEN
       u.wr.Cmd   ("pop_struct");
@@ -3749,13 +3746,13 @@
 
     WITH stack0 = u.vstack.pos(0, "pop_struct") DO
 
-      IF NOT M3BackInt.FromInt(s, M3BackInt.Integer.bytes, ts) THEN
+      IF NOT M3BackInt.FromInt(s, Target.Integer.bytes, ts) THEN
         u.Err("pop_struct: unable to convert s to target int");
       END;
 
       (* if the struct is "large", use rep mov to copy it to the machine stack *)
 
-      IF M3BackInt.GT(ts, M3BackInt.ThirtyTwo) THEN
+      IF TInt.GT(ts, TInt.ThirtyTwo) THEN
         u.cg.immOp(Op.oSUB, u.cg.reg[ESP], ts);
 
         u.vstack.find(stack0, Force.regset, RegSet { ESI });
@@ -3843,10 +3840,10 @@
     RETURN 2;
   END SplitMVar;
 
-PROCEDURE SplitImm(type: Type; READONLY imm: M3BackInt.Int; VAR immA: ARRAY OperandPart OF M3BackInt.Int): OperandSize =
+PROCEDURE SplitImm(type: Type; READONLY imm: Target.Int; VAR immA: ARRAY OperandPart OF Target.Int): OperandSize =
   BEGIN
-    M3BackWord.And(imm, M3BackInt.Word32.max, immA[0]);
-    M3BackWord.RightShift(imm, 32, immA[1]);
+    TWord.And(imm, Target.Word32.max, immA[0]);
+    TWord.RightShift(imm, 32, immA[1]);
     RETURN GetTypeSize(type);
   END SplitImm;
 
@@ -3864,7 +3861,7 @@
 PROCEDURE SplitOperand(READONLY op: Operand; VAR opA: ARRAY OperandPart OF Operand): OperandSize =
   VAR type := op.optype;
       mvarA: ARRAY OperandPart OF MVar;
-      immA: ARRAY OperandPart OF M3BackInt.Int;
+      immA: ARRAY OperandPart OF Target.Int;
   BEGIN
     opA[0] := op;
 
@@ -3901,7 +3898,7 @@
 
 PROCEDURE call_direct (u: U; p: Proc;  t: Type) =
   VAR realproc := NARROW(p, x86Proc);
-      call_param_size: M3BackInt.Int;
+      call_param_size: Target.Int;
   (* call the procedure identified by block b.  The procedure
      returns a value of type t. *)
   BEGIN
@@ -3935,7 +3932,7 @@
     IF (NOT realproc.stdcall) (* => caller cleans *)
        AND u.call_param_size[u.in_proc_call - 1] > 0 THEN
 
-        IF NOT M3BackInt.FromInt(u.call_param_size[u.in_proc_call - 1], M3BackInt.Integer.bytes, call_param_size) THEN
+        IF NOT M3BackInt.FromInt(u.call_param_size[u.in_proc_call - 1], Target.Integer.bytes, call_param_size) THEN
           u.Err("call_direct: unable to convert param_size to target integer");
         END;
         u.cg.immOp(Op.oADD, u.cg.reg[ESP], call_param_size);
@@ -3962,7 +3959,7 @@
 PROCEDURE call_indirect (u: U; t: Type;  cc: CallingConvention) =
   (* call the procedure whose address is in s0.A and pop s0.  The
      procedure returns a value of type t. *)
-  VAR call_param_size: M3BackInt.Int;
+  VAR call_param_size: Target.Int;
   BEGIN
     IF u.debug THEN
       u.wr.Cmd   ("call_indirect");
@@ -3994,7 +3991,7 @@
 
       (* caller-cleans calling convention *)
 
-      IF NOT M3BackInt.FromInt(u.call_param_size[u.in_proc_call - 1], M3BackInt.Integer.bytes, call_param_size) THEN
+      IF NOT M3BackInt.FromInt(u.call_param_size[u.in_proc_call - 1], Target.Integer.bytes, call_param_size) THEN
         u.Err("call_indirect: unable to convert param_size to target integer");
       END;
 
@@ -4038,11 +4035,11 @@
         t := Type.Int32;
 
     | Type.Word8 => (* 8-bit unsigned integer *)
-        u.cg.immOp (Op.oAND, u.cg.reg[EAX], M3BackInt.Word8.max);  (* EAX &= 16_FF *)
+        u.cg.immOp (Op.oAND, u.cg.reg[EAX], Target.Word8.max);  (* EAX &= 16_FF *)
         t := Type.Word32;
 
     | Type.Word16 => (* 16-bit unsigned integer *)
-        u.cg.immOp (Op.oAND, u.cg.reg[EAX], M3BackInt.Word16.max);  (* EAX &= 16_FFFF *)
+        u.cg.immOp (Op.oAND, u.cg.reg[EAX], Target.Word16.max);  (* EAX &= 16_FFFF *)
         t := Type.Word32;
 
     ELSE (* value is ok *)
Index: m3back/src/M3x86Rep.i3
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/m3back/src/M3x86Rep.i3,v
retrieving revision 1.34
diff -u -r1.34 M3x86Rep.i3
--- m3back/src/M3x86Rep.i3	21 Feb 2010 13:56:24 -0000	1.34
+++ m3back/src/M3x86Rep.i3	25 Feb 2010 13:03:47 -0000
@@ -8,7 +8,7 @@
 
 INTERFACE M3x86Rep;
 
-IMPORT M3CG, M3ID, M3BackInt;
+IMPORT M3CG, M3ID, M3BackInt, Target, TInt;
 
 FROM M3CG IMPORT ByteOffset, ByteSize, Alignment;
 FROM M3CG IMPORT Var, Proc, Name;
@@ -99,7 +99,7 @@
     loc: OLoc;
     mvar: MVar := NoStore;
     reg : Regno := 0;       (* seems like it should be -1 *)
-    imm: INTEGER := 0;      (* This might change to M3BackInt.Int. *)
+    imm: INTEGER := 0;      (* This might change to Target.Int. *)
     stackp: INTEGER := 0;   (* this field might go away; seems like it should be -1 *)
     opcode := FALSE;
   END;
@@ -108,7 +108,7 @@
     loc: OLoc;
     mvar: MVar := NoStore;
     reg := ARRAY OperandPart OF Regno{0, ..}; (* seems like it should be -1 *)
-    imm: M3BackInt.Int := M3BackInt.Zero;
+    imm: Target.Int := TInt.Zero;
     optype: Type := Type.Void;
     stackp: INTEGER := 0; (* seems like it should be -1 *)
     opcode := FALSE;
@@ -141,24 +141,24 @@
 PROCEDURE IsInt (t: Type): BOOLEAN;  (* IsSigned *)
 PROCEDURE Is64 (t: Type): BOOLEAN;
 PROCEDURE SplitMVar(READONLY mvar: MVar; VAR mvarA: ARRAY OperandPart OF MVar): OperandSize;
-PROCEDURE SplitImm(type: Type; READONLY imm: M3BackInt.Int; VAR immA: ARRAY OperandPart OF M3BackInt.Int): OperandSize;
+PROCEDURE SplitImm(type: Type; READONLY imm: Target.Int; VAR immA: ARRAY OperandPart OF Target.Int): OperandSize;
 PROCEDURE SplitOperand(READONLY op: Operand; VAR opA: ARRAY OperandPart OF Operand): OperandSize;
 PROCEDURE GetOperandSize(READONLY op: Operand): OperandSize;
 PROCEDURE GetTypeSize(type: Type): OperandSize;
 
-CONST TZero = M3BackInt.Zero;
+CONST TZero = TInt.Zero;
 
 CONST UnsignedType = ARRAY IType OF IType { Type.Word32, Type.Word32,
                                             Type.Word64, Type.Word64 };
 
-CONST MaximumShift = ARRAY IType OF M3BackInt.Int { M3BackInt.ThirtyOne, M3BackInt.ThirtyOne,
-                                                 M3BackInt.SixtyThree, M3BackInt.SixtyThree };
+CONST MaximumShift = ARRAY IType OF Target.Int { TInt.ThirtyOne, TInt.ThirtyOne,
+                                                 TInt.SixtyThree, TInt.SixtyThree };
 
-CONST MinimumShift = ARRAY IType OF M3BackInt.Int { M3BackInt.MThirtyOne, M3BackInt.MThirtyOne,
-                                                 M3BackInt.MSixtyThree, M3BackInt.MSixtyThree };
+CONST MinimumShift = ARRAY IType OF Target.Int { TInt.MThirtyOne, TInt.MThirtyOne,
+                                                 TInt.MSixtyThree, TInt.MSixtyThree };
 
 CONST BitCountMask = MaximumShift;
  
-VAR(*CONST*) IntType: ARRAY IType OF M3BackInt.Int_type;
+VAR(*CONST*) IntType: ARRAY IType OF Target.Int_type;
 
 END M3x86Rep.
Index: m3back/src/Stackx86.i3
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/m3back/src/Stackx86.i3,v
retrieving revision 1.18
diff -u -r1.18 Stackx86.i3
--- m3back/src/Stackx86.i3	21 Feb 2010 13:56:24 -0000	1.18
+++ m3back/src/Stackx86.i3	25 Feb 2010 13:03:47 -0000
@@ -11,7 +11,7 @@
 FROM M3CG IMPORT Type, MType, ZType, IType, Sign, ByteOffset;
 FROM M3CG_Ops IMPORT ErrorHandler;
 
-IMPORT M3x86Rep, Codex86, Wrx86, M3BackInt;
+IMPORT M3x86Rep, Codex86, Wrx86, Target;
 FROM M3x86Rep IMPORT Operand, OLoc, MVar, Regno, Force, RegSet, FlToInt;
 FROM M3x86Rep IMPORT x86Proc, x86Var, OperandPart;
 
@@ -34,7 +34,7 @@
         corrupt (reg: Regno; operandPart: OperandPart);
         set_fstack (stackp: INTEGER);
         set_mvar (stackp: INTEGER; READONLY mvar: MVar);
-        set_imm (stackp: INTEGER; READONLY imm: M3BackInt.Int);
+        set_imm (stackp: INTEGER; READONLY imm: Target.Int);
         loc (stackp: INTEGER): OLoc;
         op (stackp: INTEGER): Operand;
         pos (depth: INTEGER; place: TEXT): INTEGER;
@@ -43,7 +43,7 @@
         push (READONLY mvar: MVar);
         pushnew (type: MType; force: Force; set := RegSet {});
         pushimmI (imm: INTEGER; type: Type);
-        pushimmT (imm: M3BackInt.Int; type: Type);
+        pushimmT (imm: Target.Int; type: Type);
         pop (READONLY mvar: MVar);
         doloadaddress (v: x86Var; o: ByteOffset);
         dobin (op: Op; symmetric, overwritesdest: BOOLEAN; type: Type): BOOLEAN;
@@ -70,16 +70,16 @@
         doindex_address (shift, size: INTEGER; neg: BOOLEAN);
         docopy (type: MType; overlap: BOOLEAN);
         docopy_n (n: INTEGER; type: MType; overlap: BOOLEAN);
-        doimm (op: Op; READONLY imm: M3BackInt.Int; overwritesdest: BOOLEAN);
+        doimm (op: Op; READONLY imm: Target.Int; overwritesdest: BOOLEAN);
         newdest (READONLY op: Operand);
         init ();
         end ();
         set_current_proc (p: x86Proc);
         reg (stackp: INTEGER): Regno;
-        lower (reg: Regno): M3BackInt.Int;
-        set_lower (reg: Regno; low: M3BackInt.Int);
-        upper (reg: Regno): M3BackInt.Int;
-        set_upper (reg: Regno; up: M3BackInt.Int);
+        lower (reg: Regno): Target.Int;
+        set_lower (reg: Regno; low: Target.Int);
+        upper (reg: Regno): Target.Int;
+        set_upper (reg: Regno; up: Target.Int);
         non_nil (reg: Regno): BOOLEAN;
         set_non_nil (reg: Regno);
       END;
Index: m3back/src/Stackx86.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/m3back/src/Stackx86.m3,v
retrieving revision 1.98
diff -u -r1.98 Stackx86.m3
--- m3back/src/Stackx86.m3	21 Feb 2010 13:56:24 -0000	1.98
+++ m3back/src/Stackx86.m3	25 Feb 2010 13:03:47 -0000
@@ -9,7 +9,7 @@
 
 IMPORT M3ID, M3CG, TargetMap, M3CG_Ops, M3x86Rep, Codex86, Wrx86;
 
-IMPORT M3BackInt, M3BackWord;
+IMPORT M3BackInt, TWord, TInt;
 IMPORT Target, Fmt;
 FROM Target IMPORT FloatType;
 FROM TargetMap IMPORT CG_Bytes, CG_Align_bytes;
@@ -33,7 +33,7 @@
         vstacklimit   := 0;
         reguse        : ARRAY [0 .. NRegs] OF Register;
         current_proc  : x86Proc;
-        rmode         : ARRAY FlToInt OF M3BackInt.Int;
+        rmode         : ARRAY FlToInt OF Target.Int;
         lowset_table  : x86Var;
         highset_table : x86Var;
       OVERRIDES
@@ -102,9 +102,9 @@
   Register = RECORD
     stackp     : INTEGER := -1;
     last_store : MVar    := NoStore;
-    last_imm   : M3BackInt.Int := TZero;
-    lowbound   : M3BackInt.Int;
-    upbound    : M3BackInt.Int;
+    last_imm   : Target.Int := TZero;
+    lowbound   : Target.Int;
+    upbound    : Target.Int;
     imm        : BOOLEAN := FALSE;
     locked     : BOOLEAN := FALSE;
     non_nil    : BOOLEAN := FALSE;
@@ -113,7 +113,7 @@
 
 PROCEDURE InitRegister(locked: BOOLEAN := FALSE):Register =
 BEGIN
-  RETURN Register { locked := locked, lowbound := M3BackInt.Integer.min, upbound := M3BackInt.Integer.max };
+  RETURN Register { locked := locked, lowbound := Target.Integer.min, upbound := Target.Integer.max };
 END InitRegister;
 
 (*-------------------------------------------- register handling routines ---*)
@@ -558,13 +558,13 @@
     RETURN bestreg;
   END inreg;
 
-PROCEDURE immreg (t: T; READONLY imm: M3BackInt.Int; set: RegSet:= RegSet {}): Regno =
+PROCEDURE immreg (t: T; READONLY imm: Target.Int; set: RegSet:= RegSet {}): Regno =
   VAR minprec := HighPrec * HighPrec;
       prec := 0;
       bestreg: Regno := -1;
   BEGIN
     FOR i := 0 TO NRegs DO
-      IF t.reguse[i].imm AND M3BackInt.EQ(imm, t.reguse[i].last_imm) THEN
+      IF t.reguse[i].imm AND TInt.EQ(imm, t.reguse[i].last_imm) THEN
         prec := precedence(t, i);
         IF (set # RegSet {}) AND (NOT i IN set) THEN
           prec := prec * HighPrec;
@@ -736,7 +736,7 @@
     t.vstack[stackp].mvar := mvar;
   END set_mvar;
 
-PROCEDURE set_imm (t: T; stackp: INTEGER; READONLY imm: M3BackInt.Int) =
+PROCEDURE set_imm (t: T; stackp: INTEGER; READONLY imm: Target.Int) =
   BEGIN
     t.vstack[stackp].loc := OLoc.imm;
     t.vstack[stackp].imm := imm;
@@ -764,7 +764,7 @@
     RETURN -1;
   END pos;
 
-PROCEDURE pushimmT (t: T; imm: M3BackInt.Int; type: Type) =
+PROCEDURE pushimmT (t: T; imm: Target.Int; type: Type) =
   BEGIN
     maybe_expand_stack(t);
 
@@ -779,9 +779,9 @@
   END pushimmT;
 
 PROCEDURE pushimmI (t: T; immI: INTEGER; type: Type) =
-  VAR immT: M3BackInt.Int;
+  VAR immT: Target.Int;
   BEGIN
-    IF NOT M3BackInt.FromInt(immI, M3BackInt.Integer.bytes, immT) THEN
+    IF NOT M3BackInt.FromInt(immI, Target.Integer.bytes, immT) THEN
       t.Err("pushimmI: unable to convert to target integer");
     END;
     t.pushimmT(immT, type);
@@ -967,7 +967,7 @@
   END pop;
 
 PROCEDURE doloadaddress (t: T; v: x86Var; o: ByteOffset) =
-  VAR to, tvoffset, ti: M3BackInt.Int;
+  VAR to, tvoffset, ti: Target.Int;
   BEGIN
     unlock(t);
     pushnew(t, Type.Addr, Force.anyreg);
@@ -975,13 +975,13 @@
     WITH stop0 = t.vstack[pos(t, 0, "doloadaddress")] DO
       IF v.loc = VLoc.temp AND v.parent # t.current_proc THEN
         t.cg.get_frame(stop0.reg[0], v.parent, t.current_proc);
-        IF NOT M3BackInt.FromInt(o, M3BackInt.Integer.bytes, to) THEN
+        IF NOT M3BackInt.FromInt(o, Target.Integer.bytes, to) THEN
           t.Err("doloadaddress: unable to convert o");
         END;
-        IF NOT M3BackInt.FromInt(v.offset, M3BackInt.Integer.bytes, tvoffset) THEN
+        IF NOT M3BackInt.FromInt(v.offset, Target.Integer.bytes, tvoffset) THEN
           t.Err("doloadaddress: unable to convert v.offset");
         END;
-        IF NOT M3BackInt.Add(to, tvoffset, ti) THEN
+        IF NOT TInt.Add(to, tvoffset, ti) THEN
           t.Err("dloadaddress: Add overflowed");
         END;
         t.cg.immOp(Op.oADD, t.cg.reg[stop0.reg[0]], ti);
@@ -1315,7 +1315,7 @@
     END
   END domod;
 
-PROCEDURE doimm (t: T; op: Op; READONLY imm: M3BackInt.Int; overwritesdest: BOOLEAN) =
+PROCEDURE doimm (t: T; op: Op; READONLY imm: Target.Int; overwritesdest: BOOLEAN) =
   BEGIN
     unlock(t);
 
@@ -1324,7 +1324,7 @@
       IF (stop0.loc = OLoc.mem AND
          ((overwritesdest AND NOT stop0.mvar.var.stack_temp) OR
           CG_Bytes[stop0.mvar.mvar_type] = 2 OR
-          (CG_Bytes[stop0.mvar.mvar_type] = 1 AND (M3BackInt.GT(imm, M3BackInt.Int8.max) OR M3BackInt.LT(imm, M3BackInt.Int8.min)))))
+          (CG_Bytes[stop0.mvar.mvar_type] = 1 AND (TInt.GT(imm, Target.Int8.max) OR TInt.LT(imm, Target.Int8.min)))))
          OR stop0.loc = OLoc.imm THEN
         find(t, stack0, Force.anyreg);
       ELSE
@@ -1342,13 +1342,13 @@
   END doimm;
 
 PROCEDURE doneg (t: T) =
-  VAR neg: M3BackInt.Int;
+  VAR neg: Target.Int;
   BEGIN
     unlock(t);
     WITH stack0 = pos(t, 0, "doneg"),
          stop0 = t.vstack[stack0] DO
       IF stop0.loc = OLoc.imm THEN
-        IF NOT M3BackInt.Negate(stop0.imm, neg) THEN
+        IF NOT TInt.Negate(stop0.imm, neg) THEN
           t.Err("doneg: Negate overflowed");
         END;
         stop0.imm := neg;
@@ -1368,7 +1368,7 @@
     WITH stack0 = pos(t, 0, "doabs"),
          stop0 = t.vstack[stack0] DO
       IF stop0.loc = OLoc.imm THEN
-        IF NOT M3BackInt.Abs(stop0.imm, stop0.imm) THEN
+        IF NOT TInt.Abs(stop0.imm, stop0.imm) THEN
           t.Err("doabs: Abs overflowed");
         END;
       ELSE
@@ -1401,8 +1401,8 @@
 
 PROCEDURE doshift (t: T; type: IType): BOOLEAN =
   VAR ovflshift, leftlab, endlab: Label;
-      tShiftCount: M3BackInt.Int;
-      shiftResult: M3BackInt.Int;
+      tShiftCount: Target.Int;
+      shiftResult: Target.Int;
       shiftCount: INTEGER;
       is64 := Is64(type);
   BEGIN
@@ -1421,33 +1421,33 @@
 
           (* shift constant by a constant *)
 
-          M3BackWord.Shift(stop1.imm, shiftCount, shiftResult);
+          TWord.Shift(stop1.imm, shiftCount, shiftResult);
           stop1.imm := shiftResult;
         ELSE
 
           (* shift non-constant by a constant *)
 
-          IF M3BackInt.NE(stop0.imm, TZero) THEN
+          IF TInt.NE(stop0.imm, TZero) THEN
 
             (* shift non-constant by a non-zero constant *)
 
             find(t, stack1, Force.anytemp);
 
-            IF     M3BackInt.GT(stop0.imm, MaximumShift[type])
-                OR M3BackInt.LT(stop0.imm, MinimumShift[type]) THEN
+            IF     TInt.GT(stop0.imm, MaximumShift[type])
+                OR TInt.LT(stop0.imm, MinimumShift[type]) THEN
 
               (* shifting "too far" just yields zero *)
 
               t.cg.binOp(Op.oXOR, stop1, stop1);
 
-            ELSIF M3BackInt.GT(stop0.imm, TZero) THEN
+            ELSIF TInt.GT(stop0.imm, TZero) THEN
 
               (* positive shift is left shift *)
 
               t.cg.immOp(Op.oSHL, stop1, stop0.imm);
 
             ELSE
-              IF NOT M3BackInt.Negate(stop0.imm, tShiftCount) THEN
+              IF NOT TInt.Negate(stop0.imm, tShiftCount) THEN
                 t.Err("doshift: Negate overflowed");
               END;
 
@@ -1462,7 +1462,7 @@
         END
       ELSE
 
-        IF ((stop1.loc # OLoc.imm) OR (M3BackInt.NE(stop1.imm, TZero))) THEN
+        IF ((stop1.loc # OLoc.imm) OR (TInt.NE(stop1.imm, TZero))) THEN
 
           (* shift by a non-constant *)
 
@@ -1485,7 +1485,7 @@
 
           t.cg.brOp(Cond.GE, leftlab);
           t.cg.unOp(Op.oNEG, stop0);
-          t.cg.immOp(Op.oCMP, stop0, M3BackInt.ThirtyTwo);
+          t.cg.immOp(Op.oCMP, stop0, TInt.ThirtyTwo);
           t.cg.brOp(Cond.GE, ovflshift);
           t.cg.unOp(Op.oSHR, stop1);
           t.cg.brOp(Cond.Always, endlab);
@@ -1495,7 +1495,7 @@
           t.cg.brOp(Cond.Always, endlab);
           t.cg.set_label(leftlab);
           (* .leftlab *)
-          t.cg.immOp(Op.oCMP, stop0, M3BackInt.ThirtyTwo);
+          t.cg.immOp(Op.oCMP, stop0, TInt.ThirtyTwo);
           t.cg.brOp(Cond.GE, ovflshift);
           t.cg.unOp(Op.oSHL, stop1);
           t.cg.set_label(endlab);
@@ -1529,9 +1529,9 @@
           IF NOT M3BackInt.ToInt(stop0.imm, rotateCount) THEN
             t.Err("dorotate: failed to convert rotateCount to host integer");
           END;
-          M3BackWord.Rotate(stop1.imm, rotateCount, stop1.imm);
+          TWord.Rotate(stop1.imm, rotateCount, GetTypeSize(stop1.optype) * 4, stop1.imm);
         ELSE
-          IF M3BackInt.NE(stop0.imm, TZero) THEN
+          IF TInt.NE(stop0.imm, TZero) THEN
 
             IF is64 THEN (* needs work *)
               RETURN FALSE;
@@ -1539,14 +1539,14 @@
 
             find(t, stack1, Force.anytemp);
 
-            IF M3BackInt.GT(stop0.imm, TZero) THEN
-              M3BackWord.And(stop0.imm, BitCountMask[type], stop0.imm);
+            IF TInt.GT(stop0.imm, TZero) THEN
+              TWord.And(stop0.imm, BitCountMask[type], stop0.imm);
               t.cg.immOp(Op.oROL, stop1, stop0.imm);
             ELSE
-              IF NOT M3BackInt.Negate(stop0.imm, stop0.imm) THEN
+              IF NOT TInt.Negate(stop0.imm, stop0.imm) THEN
                 t.Err("dorotate: negate overflowed");
               END;
-              M3BackWord.And(stop0.imm, BitCountMask[type], stop0.imm);
+              TWord.And(stop0.imm, BitCountMask[type], stop0.imm);
               t.cg.immOp(Op.oROR, stop1, stop0.imm);
             END;
 
@@ -1555,7 +1555,7 @@
         END
       ELSE
 
-        IF ((stop0.loc # OLoc.imm) OR (M3BackInt.NE(stop0.imm, TZero))) THEN
+        IF ((stop0.loc # OLoc.imm) OR (TInt.NE(stop0.imm, TZero))) THEN
 
           IF is64 THEN (* needs work *)
             RETURN FALSE;
@@ -1643,7 +1643,7 @@
 
       ELSE
         IF stop1.loc = OLoc.imm THEN
-          M3BackWord.And(stop1.imm, BitCountMask[type], stop1.imm);
+          TWord.And(stop1.imm, BitCountMask[type], stop1.imm);
         ELSE
           find(t, stack1, Force.regset, RegSet { ECX });
         END;
@@ -1672,7 +1672,7 @@
   END doextract;
 
 PROCEDURE doextract_n (t: T; type: IType; sign: BOOLEAN; n: INTEGER): BOOLEAN =
-  VAR tn, t32MinusN, andval: M3BackInt.Int;
+  VAR tn, t32MinusN, andval: Target.Int;
       int: INTEGER;
       uint_type := IntType[UnsignedType[type]];
       is64 := Is64(type);
@@ -1706,11 +1706,11 @@
           find(t, stack0, Force.anyreg);
         END;
 
-        IF NOT M3BackInt.FromInt(n, M3BackInt.Integer.bytes, tn) THEN
+        IF NOT M3BackInt.FromInt(n, Target.Integer.bytes, tn) THEN
           t.Err("doextract_n: failed to convert n to target integer");
         END;
 
-        IF NOT M3BackInt.Subtract(M3BackInt.ThirtyTwo, tn, t32MinusN) THEN
+        IF NOT TInt.Subtract(TInt.ThirtyTwo, tn, t32MinusN) THEN
           t.Err("doextract_n: Subtract overflowed");
         END;
 
@@ -1728,7 +1728,7 @@
         t.cg.unOp(Op.oSHR, stop1);
 
         IF n < uint_type.size THEN
-          M3BackWord.Shift(uint_type.max, n - uint_type.size, andval);
+          TWord.Shift(uint_type.max, n - uint_type.size, andval);
           t.cg.immOp(Op.oAND, stop1, andval);
         END
       END;
@@ -1741,7 +1741,7 @@
   END doextract_n;
 
 PROCEDURE doextract_mn (t: T; type: IType; sign: BOOLEAN; m, n: INTEGER): BOOLEAN =
-  VAR andval, tint: M3BackInt.Int;
+  VAR andval, tint: Target.Int;
       is64 := Is64(type);
   BEGIN
 
@@ -1754,15 +1754,15 @@
       END;
 
       IF stop0.loc = OLoc.imm THEN
-        M3BackWord.Shift(stop0.imm, -m, stop0.imm);
-        M3BackWord.Shift(M3BackInt.Word32.max, n - 32, tint);
-        M3BackWord.And(stop0.imm, tint, stop0.imm);
+        TWord.Shift(stop0.imm, -m, stop0.imm);
+        TWord.Shift(Target.Word32.max, n - 32, tint);
+        TWord.And(stop0.imm, tint, stop0.imm);
         IF sign THEN
-          M3BackWord.Shift(M3BackInt.One, n - 1, tint);
-          M3BackWord.And(stop0.imm, tint, tint);
-          IF M3BackInt.NE(tint, TZero) THEN
-            M3BackWord.Shift(M3BackInt.Word32.max, n, tint);
-            M3BackWord.Or(stop0.imm, tint, stop0.imm);
+          TWord.Shift(TInt.One, n - 1, tint);
+          TWord.And(stop0.imm, tint, tint);
+          IF TInt.NE(tint, TZero) THEN
+            TWord.Shift(Target.Word32.max, n, tint);
+            TWord.Or(stop0.imm, tint, stop0.imm);
           END;
         END;
         RETURN TRUE;
@@ -1771,14 +1771,14 @@
       IF sign THEN
         find(t, stack0, Force.anyreg);
         IF (m + n) < 32 THEN
-          IF NOT M3BackInt.FromInt(32 - (m + n), M3BackInt.Integer.bytes, tint) THEN
+          IF NOT M3BackInt.FromInt(32 - (m + n), Target.Integer.bytes, tint) THEN
             t.Err("doextract_mn: failed to convert 32 - (m + n) to target integer");
           END;
           t.cg.immOp(Op.oSHL, stop0, tint);
         END;
 
         IF n < 32 THEN
-          IF NOT M3BackInt.FromInt(32 - n, M3BackInt.Integer.bytes, tint) THEN
+          IF NOT M3BackInt.FromInt(32 - n, Target.Integer.bytes, tint) THEN
             t.Err("doextract_mn: failed to convert 32 - n to target integer");
           END;
           t.cg.immOp(Op.oSAR, stop0, tint);
@@ -1786,12 +1786,12 @@
       ELSE
         find(t, stack0, Force.anyreg);
         IF (m + n) < 32 THEN
-          M3BackWord.Shift(M3BackInt.Word32.max, m + n - 32, andval);
+          TWord.Shift(Target.Word32.max, m + n - 32, andval);
           t.cg.immOp(Op.oAND, stop0, andval);
         END;
 
         IF m > 0 THEN
-          IF NOT M3BackInt.FromInt(m, M3BackInt.Integer.bytes, tint) THEN
+          IF NOT M3BackInt.FromInt(m, Target.Integer.bytes, tint) THEN
             t.Err("doextract_mn: failed to m to target integer");
           END;
           t.cg.immOp(Op.oSHR, stop0, tint);
@@ -1807,7 +1807,7 @@
 PROCEDURE doinsert (t: T; type: IType): BOOLEAN =
   VAR maskreg: Regno;  tbl: MVar;
       int: INTEGER;
-      tint: M3BackInt.Int;
+      tint: Target.Int;
       is64 := Is64(type);
   BEGIN
 
@@ -1834,7 +1834,7 @@
       END;
 
       IF stop1.loc = OLoc.imm THEN
-        M3BackWord.And(stop1.imm, BitCountMask[type], stop1.imm);
+        TWord.And(stop1.imm, BitCountMask[type], stop1.imm);
       ELSE
         find(t, stack1, Force.regset, RegSet { ECX });
       END;
@@ -1859,7 +1859,7 @@
       t.cg.binOp(Op.oAND, stop2, t.cg.reg[maskreg]);
 
       IF stop1.loc = OLoc.imm THEN
-        IF M3BackInt.NE(stop1.imm, TZero) THEN
+        IF TInt.NE(stop1.imm, TZero) THEN
           t.cg.immOp(Op.oSHL, stop2, stop1.imm);
           t.cg.immOp(Op.oADD, stop0, stop1.imm);
         END
@@ -1875,7 +1875,7 @@
         IF NOT M3BackInt.ToInt(stop1.imm, int) THEN
           t.Err("failed to convert stop1.imm to host integer");
         END;
-        M3BackWord.Shift(M3BackInt.Word32.max, int, tint);
+        TWord.Shift(Target.Word32.max, int, tint);
         t.cg.immOp(Op.oXOR, t.cg.reg[maskreg], tint);
       ELSE
         ImportHighSet (t, tbl);
@@ -1897,7 +1897,7 @@
 PROCEDURE doinsert_n (t: T; type: IType; n: INTEGER): BOOLEAN =
   VAR tbl: MVar;  maskreg: Regno;
       m: INTEGER;
-      tint: M3BackInt.Int;
+      tint: Target.Int;
       is64 := Is64(type);
   BEGIN
 
@@ -1933,7 +1933,7 @@
       corrupt(t, maskreg, operandPart := 0);
 
       IF n # 32 THEN
-        M3BackWord.Shift(M3BackInt.Word32.max, n - 32, tint);
+        TWord.Shift(Target.Word32.max, n - 32, tint);
         t.cg.immOp(Op.oAND, stop1, tint);
       END;
 
@@ -1963,7 +1963,7 @@
   END doinsert_n;
   
 PROCEDURE doinsert_mn (t: T; type: IType; m, n: INTEGER): BOOLEAN =
-  VAR tint_m, mask_m, mask_m_n, mask: M3BackInt.Int;
+  VAR tint_m, mask_m, mask_m_n, mask: Target.Int;
       uint_type := IntType[UnsignedType[type]];
       is64 := Is64(type);
   BEGIN
@@ -1987,31 +1987,31 @@
         find(t, stack1, Force.anyreg);
       END;
 
-      M3BackWord.Shift(uint_type.max, n - uint_type.size, mask);
+      TWord.Shift(uint_type.max, n - uint_type.size, mask);
 
       IF stop0.loc = OLoc.imm THEN
-        M3BackWord.And(stop0.imm, mask, stop0.imm);
-        M3BackWord.Shift(stop0.imm, m, stop0.imm);
+        TWord.And(stop0.imm, mask, stop0.imm);
+        TWord.Shift(stop0.imm, m, stop0.imm);
       ELSE
         IF (n + m) < uint_type.size THEN
           t.cg.immOp(Op.oAND, stop0, mask);
         END;
 
         IF m # 0 THEN
-          IF NOT M3BackInt.FromInt(m, M3BackInt.Integer.bytes, tint_m) THEN
+          IF NOT M3BackInt.FromInt(m, Target.Integer.bytes, tint_m) THEN
             t.Err("doinsert_mn: unable to convert m to target integer");
           END;
           t.cg.immOp(Op.oSHL, stop0, tint_m);
         END
       END;
 
-      M3BackWord.Shift(uint_type.max, m, mask_m);
-      M3BackWord.Shift(uint_type.max, m + n - uint_type.size, mask_m_n);
-      M3BackWord.Xor(mask_m, mask_m_n, mask);
+      TWord.Shift(uint_type.max, m, mask_m);
+      TWord.Shift(uint_type.max, m + n - uint_type.size, mask_m_n);
+      TWord.Xor(mask_m, mask_m_n, mask);
 
-      IF M3BackWord.NE(mask, uint_type.max) THEN
+      IF TInt.NE(mask, uint_type.max) THEN
         IF stop1.loc = OLoc.imm THEN
-          M3BackWord.And(stop1.imm, mask, stop1.imm);
+          TWord.And(stop1.imm, mask, stop1.imm);
         ELSE
           t.cg.immOp(Op.oAND, stop1, mask);
         END
@@ -2019,15 +2019,15 @@
 
       IF stop1.loc = OLoc.imm THEN
         IF stop0.loc = OLoc.imm THEN
-          M3BackWord.Or(stop1.imm, stop0.imm, stop1.imm);
+          TWord.Or(stop1.imm, stop0.imm, stop1.imm);
         ELSE
           swap(t);
-          IF stop0.loc # OLoc.imm OR M3BackInt.NE(stop0.imm, TZero) THEN
+          IF stop0.loc # OLoc.imm OR TInt.NE(stop0.imm, TZero) THEN
             t.cg.binOp(Op.oOR, stop1, stop0);
           END
         END
       ELSE
-        IF stop0.loc # OLoc.imm OR M3BackInt.NE(stop0.imm, TZero) THEN
+        IF stop0.loc # OLoc.imm OR TInt.NE(stop0.imm, TZero) THEN
           t.cg.binOp(Op.oOR, stop1, stop0);
         END
       END;
@@ -2197,9 +2197,9 @@
 PROCEDURE doindex_address (t: T; shift, size: INTEGER; neg: BOOLEAN) =
   VAR imsize: INTEGER;
       muldest: Regno;
-      tsize: M3BackInt.Int;
-      tshift: M3BackInt.Int;
-      tint: M3BackInt.Int;
+      tsize: Target.Int;
+      tshift: Target.Int;
+      tint: Target.Int;
   BEGIN
     unlock(t);
     WITH stack0 = pos(t, 0, "doindex_address"),
@@ -2210,10 +2210,10 @@
       find(t, stack1, Force.anyreg, RegSet {}, TRUE);
 
       IF stop0.loc = OLoc.imm THEN
-        IF NOT M3BackInt.FromInt(size, M3BackInt.Integer.bytes, tsize) THEN
+        IF NOT M3BackInt.FromInt(size, Target.Integer.bytes, tsize) THEN
           t.Err("doindex_address: failed to convert size to target integer");
         END;
-        IF NOT M3BackInt.Multiply(stop0.imm, tsize, tint) THEN
+        IF NOT TInt.Multiply(stop0.imm, tsize, tint) THEN
           t.Err("doindex_address: multiply overflowed");
         END;
         stop0.imm := tint;
@@ -2245,7 +2245,7 @@
           END
 
         ELSIF shift > 0 THEN
-          IF NOT M3BackInt.FromInt(shift, M3BackInt.Integer.bytes, tshift) THEN
+          IF NOT M3BackInt.FromInt(shift, Target.Integer.bytes, tshift) THEN
             t.Err("doindex_address: failed to convert size to target integer");
           END;
           t.cg.immOp(Op.oSHL, stop0, tshift);
@@ -2384,9 +2384,9 @@
     t.cg.memFOp(FOp.fSTCW, statusop.mvar);
 
     t.cg.movOp(t.cg.reg[statreg], statusop);
-    t.cg.immOp(Op.oAND, t.cg.reg[statreg], M3BackInt.F3FF);
+    t.cg.immOp(Op.oAND, t.cg.reg[statreg], TInt.F3FF);
 
-    IF M3BackInt.NE(t.rmode[mode], TZero) THEN
+    IF TInt.NE(t.rmode[mode], TZero) THEN
       t.cg.immOp(Op.oOR, t.cg.reg[statreg], t.rmode[mode]);
     END;
 
@@ -2433,8 +2433,8 @@
       FOR i := 0 TO GetTypeSize(op.optype) - 1 DO
         WITH z = t.reguse[op.reg[i]] DO
           z.last_store := NoStore;
-          z.upbound    := M3BackInt.Integer.max;
-          z.lowbound   := M3BackInt.Integer.min;
+          z.upbound    := Target.Integer.max;
+          z.lowbound   := Target.Integer.min;
           z.imm        := FALSE;
           z.non_nil    := FALSE;
         END;
@@ -2488,22 +2488,22 @@
     RETURN t.vstack[stackp].reg[0];
   END reg;
 
-PROCEDURE lower (t: T; reg: Regno): M3BackInt.Int =
+PROCEDURE lower (t: T; reg: Regno): Target.Int =
   BEGIN
     RETURN t.reguse[reg].lowbound;
   END lower;
 
-PROCEDURE upper (t: T; reg: Regno): M3BackInt.Int =
+PROCEDURE upper (t: T; reg: Regno): Target.Int =
   BEGIN
     RETURN t.reguse[reg].upbound;
   END upper;
 
-PROCEDURE set_lower (t: T; reg: Regno; newlow: M3BackInt.Int) =
+PROCEDURE set_lower (t: T; reg: Regno; newlow: Target.Int) =
   BEGIN
     t.reguse[reg].lowbound := newlow;
   END set_lower;
 
-PROCEDURE set_upper (t: T; reg: Regno; newup: M3BackInt.Int) =
+PROCEDURE set_upper (t: T; reg: Regno; newup: Target.Int) =
   BEGIN
     t.reguse[reg].upbound := newup;
   END set_upper;
@@ -2532,16 +2532,16 @@
       WITH z = t.reguse[i] DO
         z.stackp     := -1;
         z.last_store := NoStore;
-        z.upbound    := M3BackInt.Integer.max;
-        z.lowbound   := M3BackInt.Integer.min;
+        z.upbound    := Target.Integer.max;
+        z.lowbound   := Target.Integer.min;
         z.imm        := FALSE;
         z.non_nil    := FALSE;
         z.locked     := FALSE;
       END;
     END;
 
-    t.rmode := ARRAY FlToInt OF M3BackInt.Int
-      { TZero, M3BackInt.x0400, M3BackInt.x0800, M3BackInt.x0F00 };
+    t.rmode := ARRAY FlToInt OF Target.Int
+      { TZero, TInt.x0400, TInt.x0800, TInt.x0F00 };
     t.lowset_table := NIL;
     t.highset_table := NIL;
   END init;
@@ -2621,7 +2621,7 @@
     wr.OutT (OLocName [op.loc]);
     wr.OutT ("  mvar: ");  DebugMVar (op.mvar, wr);
     wr.OutT ("  reg: "); wr.OutT (RegName [op.reg[0]]);
-    wr.OutT ("  imm: "); wr.OutT (M3BackInt.ToText (op.imm));
+    wr.OutT ("  imm: "); wr.OutT (TInt.ToText (op.imm));
     wr.OutT ("  stackp: ");  wr.OutI (op.stackp);
     IF (op.opcode) THEN wr.OutT ("  OPCODE"); END;
   END DebugOp;
@@ -2634,14 +2634,14 @@
     IF r.last_store # NoStore THEN
       wr.OutT ("  mvar: ");  DebugMVar (r.last_store, wr);
     END;
-    IF (NOT M3BackInt.EQ(r.last_imm, TZero)) THEN
-      wr.OutT ("  imm: ");  wr.OutT (M3BackInt.ToText (r.last_imm));
+    IF (NOT TInt.EQ(r.last_imm, TZero)) THEN
+      wr.OutT ("  imm: ");  wr.OutT (TInt.ToText (r.last_imm));
     END;
-    IF (NOT M3BackInt.EQ(r.lowbound, M3BackInt.Integer.min)) THEN
-      wr.OutT ("  lo: ");  wr.OutT (M3BackInt.ToText (r.lowbound));
+    IF (NOT TInt.EQ(r.lowbound, Target.Integer.min)) THEN
+      wr.OutT ("  lo: ");  wr.OutT (TInt.ToText (r.lowbound));
     END;
-    IF (NOT M3BackInt.EQ(r.upbound, M3BackInt.Integer.max)) THEN
-      wr.OutT ("  hi: ");  wr.OutT (M3BackInt.ToText (r.upbound));
+    IF (NOT TInt.EQ(r.upbound, Target.Integer.max)) THEN
+      wr.OutT ("  hi: ");  wr.OutT (TInt.ToText (r.upbound));
     END;
     IF (r.imm # FALSE) THEN
       wr.OutT ("  IMMED");
Index: m3back/src/Wrx86.i3
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/m3back/src/Wrx86.i3,v
retrieving revision 1.4
diff -u -r1.4 Wrx86.i3
--- m3back/src/Wrx86.i3	21 Feb 2010 13:56:24 -0000	1.4
+++ m3back/src/Wrx86.i3	25 Feb 2010 13:03:47 -0000
@@ -29,7 +29,7 @@
         Lab (i: Label);
         Tipe (t: TypeUID);
         Int (i: INTEGER);
-        TInt (READONLY i: M3BackInt.Int);
+        TInt (READONLY i: Target.Int);
         BInt (i: INTEGER);
         Txt (t: TEXT);
         OutC (c: CHAR);
Index: m3back/src/Wrx86.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/m3back/src/Wrx86.m3,v
retrieving revision 1.12
diff -u -r1.12 Wrx86.m3
--- m3back/src/Wrx86.m3	22 Feb 2010 21:21:02 -0000	1.12
+++ m3back/src/Wrx86.m3	25 Feb 2010 13:03:47 -0000
@@ -9,7 +9,7 @@
 MODULE Wrx86;
 
 IMPORT Wr, Thread, Text;
-IMPORT M3Buf, M3ID, M3CG, M3BackInt, Target, TFloat;
+IMPORT M3Buf, M3ID, M3CG, M3BackInt, TInt AS TargetInt, Target, TFloat;
 
 FROM M3CG IMPORT Name, TypeUID;
 FROM M3CG IMPORT Var, Proc, Label, No_label;
@@ -152,13 +152,12 @@
     OutI (t, i);
   END Int;
 
-PROCEDURE TInt (t: T;  READONLY i: M3BackInt.Int) =
+PROCEDURE TInt (t: T;  READONLY i: Target.Int) =
   VAR
-    buf : ARRAY [0..BITSIZE (M3BackInt.Integer)] OF CHAR;
-    len := M3BackInt.ToChars (i, buf);
+    buf : ARRAY [0..BITSIZE (Target.Int)] OF CHAR;
  BEGIN
     OutC (t, ' ');
-    OutS (t, SUBARRAY (buf, 0, len));
+    OutS (t, SUBARRAY (buf, 0, TargetInt.ToChars (i, buf)));
     OutC (t, ' ');
     OutT (t, M3BackInt.ToDiagnosticText(i));
   END TInt;
Index: m3back/src/m3makefile
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/m3back/src/m3makefile,v
retrieving revision 1.4
diff -u -r1.4 m3makefile
--- m3back/src/m3makefile	18 Feb 2010 13:05:00 -0000	1.4
+++ m3back/src/m3makefile	25 Feb 2010 13:03:47 -0000
@@ -12,7 +12,6 @@
 import ("m3objfile")
 
 module ("M3BackInt")
-module ("M3BackWord")
 Module    ("M3x86")
 interface ("M3x86Rep")
 module    ("Wrx86")
Index: m3middle/src/TInt.i3
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/m3middle/src/TInt.i3,v
retrieving revision 1.26
diff -u -r1.26 TInt.i3
--- m3middle/src/TInt.i3	18 Feb 2010 02:33:05 -0000	1.26
+++ m3middle/src/TInt.i3	25 Feb 2010 13:03:47 -0000
@@ -27,6 +27,23 @@
   One    = Int{ 1, 0,..};
   MOne   = Int{16_FF,..};
 
+  Two       = Int{ 2,0,..};
+  Three     = Int{ 3,0,..};
+  Four      = Int{ 4,0,..};
+  Eight     = Int{ 8,0,..};
+  ThirtyOne = Int{31,0,..};
+  ThirtyTwo = Int{32,0,..};
+  SixtyThree= Int{63,0,..};
+  F3FF      = Int{16_FF,16_F3,0,..};
+  x0400     = Int{0,4,0,..};
+  x0800     = Int{0,8,0,..};
+  x0F00     = Int{0,16_F,0,..};
+
+  (* 'M' for Minus (negative) *)
+
+  MThirtyOne = Int{16_E1,16_FF,..};
+  MSixtyThree= Int{16_C1,16_FF,..};
+
 PROCEDURE FromInt (x: INTEGER;  VAR i: Int): BOOLEAN;
 (* converts a host integer 'x' to a target integer 'i' *)
 
@@ -61,6 +78,21 @@
 PROCEDURE LE (READONLY a, b: Int): BOOLEAN;
 (* returns 'a <= b' *)
 
+PROCEDURE NE (READONLY a, b: Int): BOOLEAN;
+(* 'a # b' *)
+
+PROCEDURE GT (READONLY a, b: Int): BOOLEAN;
+(* 'a > b' *)
+
+PROCEDURE GE (READONLY a, b: Int): BOOLEAN;
+(* 'a >= b' *)
+
+PROCEDURE Abs (READONLY a: Int;  VAR r: Int): BOOLEAN;
+(* ABS(a) or FALSE if overflow *)
+
+PROCEDURE Negate (READONLY a: Int;  VAR r: Int): BOOLEAN;
+(* '-a' or FALSE if overflow *)
+
 PROCEDURE ToText (READONLY i: Int): TEXT;
 (* converts 'i' to a printable string. *)
 
Index: m3middle/src/TInt.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/m3middle/src/TInt.m3,v
retrieving revision 1.26
diff -u -r1.26 TInt.m3
--- m3middle/src/TInt.m3	25 Feb 2010 09:12:36 -0000	1.26
+++ m3middle/src/TInt.m3	25 Feb 2010 13:03:47 -0000
@@ -108,6 +108,20 @@
     RETURN (a_sign = b_sign) OR (a_sign = r_sign);
   END Subtract;
 
+PROCEDURE Negate (READONLY a: Int;  VAR r: Int): BOOLEAN =
+  BEGIN
+    RETURN Subtract(Zero, a, r);
+  END Negate;
+  
+PROCEDURE Abs (READONLY a: Int;  VAR r: Int): BOOLEAN =
+  BEGIN
+    IF GE(a, Zero) THEN
+      r := a;
+      RETURN TRUE;
+    END;
+    RETURN Negate(a, r);
+  END Abs;
+
 PROCEDURE Multiply (READONLY a, b: Int;  VAR r: Int): BOOLEAN =
   VAR
     k, carry: INTEGER;
@@ -229,10 +243,7 @@
 
 PROCEDURE EQ (READONLY a, b: Int): BOOLEAN =
   BEGIN
-    FOR i := 0 TO LAST(Int) DO
-      IF a[i] # b[i] THEN RETURN FALSE; END;
-    END;
-    RETURN TRUE;
+    RETURN (a = b);
   END EQ;
 
 PROCEDURE LT (READONLY a, b: Int): BOOLEAN =
@@ -255,6 +266,21 @@
     RETURN EQ (a, b) OR LT (a, b);
   END LE;
 
+PROCEDURE NE (READONLY a, b: Int): BOOLEAN =
+  BEGIN
+    RETURN (a # b);
+  END NE;
+
+PROCEDURE GT (READONLY a, b: Int): BOOLEAN =
+  BEGIN
+    RETURN LT (b, a);
+  END GT;
+
+PROCEDURE GE (READONLY a, b: Int): BOOLEAN = 
+  BEGIN
+    RETURN LE(b, a);
+  END GE;
+
 PROCEDURE ToText (READONLY r: Int): TEXT =
   VAR result: ARRAY [0..BITSIZE (Int)] OF CHAR;
   BEGIN
Index: m3middle/src/TWord.i3
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/m3middle/src/TWord.i3,v
retrieving revision 1.9
diff -u -r1.9 TWord.i3
--- m3middle/src/TWord.i3	18 Feb 2010 02:33:05 -0000	1.9
+++ m3middle/src/TWord.i3	25 Feb 2010 13:03:47 -0000
@@ -48,9 +48,15 @@
 PROCEDURE LT (READONLY a, b: Int): BOOLEAN;
 (* returns 'Word.LT (a, b)' *)
 
+PROCEDURE GT (READONLY a, b: Int): BOOLEAN;
+(* returns 'Word.GT (a, b)' *)
+
 PROCEDURE LE (READONLY a, b: Int): BOOLEAN;
 (* returns 'Word.LE (a, b)' *)
 
+PROCEDURE GE (READONLY a, b: Int): BOOLEAN;
+(* returns 'Word.GE (a, b)' *)
+
 PROCEDURE And (READONLY a, b: Int;  VAR i: Int);
 (* returns 'Word.And (a, b)' *)
 
Index: m3middle/src/TWord.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/m3middle/src/TWord.m3,v
retrieving revision 1.16
diff -u -r1.16 TWord.m3
--- m3middle/src/TWord.m3	18 Feb 2010 02:33:06 -0000	1.16
+++ m3middle/src/TWord.m3	25 Feb 2010 13:03:47 -0000
@@ -252,6 +252,16 @@
     RETURN TRUE;
   END LE;
 
+PROCEDURE GE (READONLY a, b: Int): BOOLEAN =
+  BEGIN
+    RETURN LE(b, a);
+  END GE;
+
+PROCEDURE GT (READONLY a, b: Int): BOOLEAN =
+  BEGIN
+    RETURN LT(b, a);
+  END GT;
+
 PROCEDURE And (READONLY a, b: Int;  VAR r: Int) =
   BEGIN
     FOR i := 0 TO LAST(Int) DO