? t1
Index: Codex86.i3
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/m3back/src/Codex86.i3,v
retrieving revision 1.33
diff -u -r1.33 Codex86.i3
--- Codex86.i3	27 Feb 2010 12:35:17 -0000	1.33
+++ Codex86.i3	27 Feb 2010 13:52:47 -0000
@@ -8,7 +8,7 @@
 
 INTERFACE Codex86;
 
-IMPORT M3CG, M3ObjFile, TFloat, Target;
+IMPORT M3CG, M3ObjFile, TFloat, TIntN;
 FROM M3CG IMPORT MType, Label, ByteOffset;
 FROM M3CG_Ops IMPORT ErrorHandler;
 IMPORT M3x86Rep, Wrx86;
@@ -45,14 +45,14 @@
         fstack_swap ();
         fstack_discard ();
         f_loadlit (READONLY flarr: FloatBytes; type: MType);
-        immOp (op: Op; READONLY dest: Operand; READONLY imm: Target.IntN);
+        immOp (op: Op; READONLY dest: Operand; READONLY imm: TIntN.T);
         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: Target.IntN);
+        movImmT (READONLY dest: Operand; imm: TIntN.T);
         movImmI (READONLY dest: Operand; imm: INTEGER);
         MOVSWOp ();
         STOSWOp ();
Index: Codex86.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/m3back/src/Codex86.m3,v
retrieving revision 1.95
diff -u -r1.95 Codex86.m3
--- Codex86.m3	27 Feb 2010 12:35:17 -0000	1.95
+++ Codex86.m3	27 Feb 2010 13:52:47 -0000
@@ -379,7 +379,7 @@
     writecode(t, ins);
   END noargOp;
 
-PROCEDURE immOp1 (t: T; op: Op; READONLY dest: Operand; READONLY imm: Target.IntN) =
+PROCEDURE immOp1 (t: T; op: Op; READONLY dest: Operand; READONLY imm: TIntN.T) =
   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:" & TIntN.ToDiagnosticText(imm));
     END;
 
-    IF TIntN.GE(imm, Target.Int8.minN) AND TIntN.LE(imm, Target.Int8.maxN) THEN
+    IF TIntN.GE(imm, TIntN.Min8) AND TIntN.LE(imm, TIntN.Max8) THEN
       ins.imsize := 1;
     ELSE
       ins.imsize := 4;
@@ -437,13 +437,13 @@
     END
   END immOp1;
 
-PROCEDURE immOp (t: T; op: Op; READONLY dest: Operand; READONLY imm: Target.IntN) =
+PROCEDURE immOp (t: T; op: Op; READONLY dest: Operand; READONLY imm: TIntN.T) =
   VAR destA: ARRAY OperandPart OF Operand;
-      immA: ARRAY OperandPart OF Target.IntN;
+      immA: ARRAY OperandPart OF TIntN.T;
       immSize := SplitImm(dest.optype, imm, immA);
       destSize := SplitOperand(dest, destA);
       compare_label: Label;
-      immMinus32: Target.IntN;
+      immMinus32: TIntN.T;
       shiftCount := Operand{loc := OLoc.imm, imm := imm};
   BEGIN
 
@@ -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 (TIntN.GE(shiftCount.imm, Target.Int8.minN) AND TIntN.LE(shiftCount.imm, Target.Int8.maxN)) *>
+      <* ASSERT shiftCount.loc # OLoc.imm OR (TIntN.GE(shiftCount.imm, TIntN.Min8) AND TIntN.LE(shiftCount.imm, TIntN.Max8)) *>
 
       IF shiftCount.loc = OLoc.imm THEN
         IF NOT TIntN.ToHostInteger(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: Target.IntN) =
+PROCEDURE movImmT (t: T; READONLY dest: Operand; imm: TIntN.T) =
   VAR ins: Instruction;
   BEGIN
     IF NOT TIntN.ToHostInteger(imm, ins.imm) THEN
@@ -934,10 +934,10 @@
   END movImmT;
 
 PROCEDURE movImmI (t: T; READONLY dest: Operand; imm: INTEGER) =
-  VAR immT: Target.IntN;
+  VAR immT: TIntN.T;
   BEGIN
     IF NOT TIntN.FromHostInteger(imm, BYTESIZE(imm), immT) THEN
-      t.Err("movImmI: unable to convert INTEGER to Target.IntN");
+      t.Err("movImmI: unable to convert INTEGER to TIntN.T");
     END;
     t.movImmT(dest, immT);
   END movImmI;
@@ -951,6 +951,7 @@
         ins.opcode := 16_68;
         IF NOT TIntN.ToHostInteger(src.imm, ins.imm) THEN
           t.Err("pushOp: unable to convert immediate to INTEGER:" & TIntN.ToDiagnosticText(src.imm));
+          <* ASSERT FALSE *>
         END;
         ins.imsize := 4;
         writecode(t, ins);
@@ -2096,7 +2097,7 @@
     END;
   END MnProc;
 
-PROCEDURE MnImmTInt(t: T; READONLY imm: Target.IntN) =
+PROCEDURE MnImmTInt(t: T; READONLY imm: TIntN.T) =
   BEGIN
     IF t.debug THEN
       Mn(t, " $", TIntN.ToText (imm));
Index: M3x86.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/m3back/src/M3x86.m3,v
retrieving revision 1.148
diff -u -r1.148 M3x86.m3
--- M3x86.m3	27 Feb 2010 12:35:17 -0000	1.148
+++ M3x86.m3	27 Feb 2010 13:52:48 -0000
@@ -253,6 +253,7 @@
     IntType[Type. Int64] := Target.Int64;
     IntType[Type.Word32] := Target.Word32;
     IntType[Type.Word64] := Target.Word64;
+    TIntN.Init();
 
     IF logfile # NIL THEN
       u.debug := TRUE;
@@ -500,8 +501,8 @@
       u.wr.Cmd  ("declare_subrange");
       u.wr.Tipe (t);
       u.wr.Tipe (domain);
-      u.wr.TInt (TIntN.FromTargetInt(min, NUMBER(min)));
-      u.wr.TInt (TIntN.FromTargetInt(min, NUMBER(max)));
+      u.wr.TInt (TIntN.FromTargetInt(min, NUMBER(min))); (* What about s for size? *)
+      u.wr.TInt (TIntN.FromTargetInt(max, NUMBER(max))); (* What about s for size? *)
       u.wr.BInt (s);
       u.wr.NL   ();
     END
@@ -1362,7 +1363,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], Target.Word16.maxN);
+    u.cg.immOp(Op.oSUB, u.cg.reg[ESP], TWordN.Max16);
     u.procframe_ptr := u.obj.cursor(Seg.Text) - 4;
 
     u.cg.pushOp(u.cg.reg[EBX]);
@@ -2133,7 +2134,7 @@
          stack1 = u.vstack.pos(1, "set_singleton") DO
 
       (* Better would be:
-      IF u.vstack.loc(stack0) # OLoc.imm OR TWordN.GT(u.vstack.op(stack0).imm, Target.Word8.maxN) THEN
+      IF u.vstack.loc(stack0) # OLoc.imm OR TWordN.GT(u.vstack.op(stack0).imm, TWordN.Max8) THEN
         u.vstack.find(stack0, Force.anyreg);
       ELSE
         u.vstack.find(stack0, Force.any);
@@ -2254,7 +2255,7 @@
 
       <* ASSERT u.vstack.loc(stack0) # OLoc.imm *>
 
-      (*IF u.vstack.loc(stack0) # OLoc.imm OR TWordN.GT(u.vstack.op(stack0).imm, Target.Word8.maxN) THEN*)
+      (*IF u.vstack.loc(stack0) # OLoc.imm OR TWordN.GT(u.vstack.op(stack0).imm, TWordN.Max8) THEN*)
         u.vstack.find(stack0, Force.anyreg);
       (*ELSE*)
         (*u.vstack.find(stack0, Force.any);*)
@@ -2270,7 +2271,7 @@
 
 PROCEDURE not (u: U;  t: IType) =
   (* s0.t := Word.Not (s0.t) *)
-  VAR not: Target.IntN;
+  VAR not: TIntN.T;
   BEGIN
     IF u.debug THEN
       u.wr.Cmd   ("not");
@@ -2345,8 +2346,8 @@
 
 PROCEDURE shift_left   (u: U;  t: IType) =
   (* s1.t := Word.Shift  (s1.t, s0.t) ; pop *)
-  VAR shiftResult: Target.IntN;
-      and: Target.IntN;
+  VAR shiftResult: TIntN.T;
+      and: TIntN.T;
       shiftCount: INTEGER;
   BEGIN
     IF u.debug THEN
@@ -2407,8 +2408,8 @@
 PROCEDURE shift_right  (u: U;  t: IType) =
   (* s1.t := Word.Shift  (s1.t, -s0.t) ; pop *)
   VAR shiftCount: INTEGER;
-      shift: Target.IntN;
-      and: Target.IntN;
+      shift: TIntN.T;
+      and: TIntN.T;
   BEGIN
     IF u.debug THEN
       u.wr.Cmd   ("shift_right");
@@ -2485,8 +2486,8 @@
 PROCEDURE rotate_left  (u: U;  t: IType) =
   (* s1.t := Word.Rotate (s1.t, s0.t) ; pop *)
   VAR rotateCount: INTEGER;
-      rotate: Target.IntN;
-      and: Target.IntN;
+      rotate: TIntN.T;
+      and: TIntN.T;
   BEGIN
     IF u.debug THEN
       u.wr.Cmd   ("rotate_left");
@@ -2538,8 +2539,8 @@
 PROCEDURE rotate_right (u: U;  t: IType) =
   (* s1.t := Word.Rotate (s1.t, -s0.t) ; pop *)
   VAR rotateCount: INTEGER;
-      rotate: Target.IntN;
-      and: Target.IntN;
+      rotate: TIntN.T;
+      and: TIntN.T;
   BEGIN
     IF u.debug THEN
       u.wr.Cmd   ("rotate_right");
@@ -2773,7 +2774,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: Target.IntN;
+      shift: TIntN.T;
   BEGIN
     IF u.debug THEN
       u.wr.Cmd   ("copy_n");
@@ -2848,7 +2849,7 @@
   END inline_copy;
 
 PROCEDURE string_copy (u: U; n, size: INTEGER; forward: BOOLEAN) =
-  VAR tn, tNMinus1, tsize, tint: Target.IntN;
+  VAR tn, tNMinus1, tsize, tint: TIntN.T;
   BEGIN
     u.vstack.corrupt(ECX, operandPart := 0);
     u.cg.movImmI(u.cg.reg[ECX], n);
@@ -2964,7 +2965,7 @@
 PROCEDURE zero_n (u: U;  z: IType;  t: MType) =
   (* Mem[s1.A:s0.z] := 0; pop(2) *)
   VAR n: INTEGER;
-      shift: Target.IntN;
+      shift: TIntN.T;
   BEGIN
     IF u.debug THEN
       u.wr.Cmd   ("zero_n");
@@ -3298,7 +3299,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: Target.IntN;
+  VAR lo, hi: TIntN.T;
       safelab, outrange: Label;
       a := TIntN.FromTargetInt(xa, CG_Bytes[t]);
       b := TIntN.FromTargetInt(xb, CG_Bytes[t]);
@@ -3501,7 +3502,7 @@
 
 PROCEDURE add_offset (u: U; i: INTEGER) =
   (* s0.A := s0.A + i *)
-  VAR ti, imm_plus_i: Target.IntN;
+  VAR ti, imm_plus_i: TIntN.T;
   BEGIN
     IF u.debug THEN
       u.wr.Cmd   ("add_offset");
@@ -3722,7 +3723,7 @@
    * NOTE that we implement call by value, the struct is
    * copied to temporary space on the machine stack
    *)
-  VAR ts: Target.IntN;
+  VAR ts: TIntN.T;
   BEGIN
     IF u.debug THEN
       u.wr.Cmd   ("pop_struct");
@@ -3840,9 +3841,9 @@
     RETURN 2;
   END SplitMVar;
 
-PROCEDURE SplitImm(type: Type; READONLY imm: Target.IntN; VAR immA: ARRAY OperandPart OF Target.IntN): OperandSize =
+PROCEDURE SplitImm(type: Type; READONLY imm: TIntN.T; VAR immA: ARRAY OperandPart OF TIntN.T): OperandSize =
   BEGIN
-    TWordN.And(imm, Target.Word32.maxN, immA[0]);
+    TWordN.And(imm, TWordN.Max32, immA[0]);
     TWordN.RightShift(imm, 32, immA[1]);
     RETURN GetTypeSize(type);
   END SplitImm;
@@ -3861,7 +3862,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 Target.IntN;
+      immA: ARRAY OperandPart OF TIntN.T;
   BEGIN
     opA[0] := op;
 
@@ -3898,7 +3899,7 @@
 
 PROCEDURE call_direct (u: U; p: Proc;  t: Type) =
   VAR realproc := NARROW(p, x86Proc);
-      call_param_size: Target.IntN;
+      call_param_size: TIntN.T;
   (* call the procedure identified by block b.  The procedure
      returns a value of type t. *)
   BEGIN
@@ -3959,7 +3960,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: Target.IntN;
+  VAR call_param_size: TIntN.T;
   BEGIN
     IF u.debug THEN
       u.wr.Cmd   ("call_indirect");
@@ -4035,11 +4036,11 @@
         t := Type.Int32;
 
     | Type.Word8 => (* 8-bit unsigned integer *)
-        u.cg.immOp (Op.oAND, u.cg.reg[EAX], Target.Word8.maxN);  (* EAX &= 16_FF *)
+        u.cg.immOp (Op.oAND, u.cg.reg[EAX], TWordN.Max8);  (* EAX &= 16_FF *)
         t := Type.Word32;
 
     | Type.Word16 => (* 16-bit unsigned integer *)
-        u.cg.immOp (Op.oAND, u.cg.reg[EAX], Target.Word16.maxN);  (* EAX &= 16_FFFF *)
+        u.cg.immOp (Op.oAND, u.cg.reg[EAX], TWordN.Max16);  (* EAX &= 16_FFFF *)
         t := Type.Word32;
 
     ELSE (* value is ok *)
Index: M3x86Rep.i3
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/m3back/src/M3x86Rep.i3,v
retrieving revision 1.39
diff -u -r1.39 M3x86Rep.i3
--- M3x86Rep.i3	27 Feb 2010 12:35:17 -0000	1.39
+++ M3x86Rep.i3	27 Feb 2010 13:52:48 -0000
@@ -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 Target.IntN. *)
+    imm: INTEGER := 0;      (* This might change to TIntN.T. *)
     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: Target.IntN := TIntN.Zero;
+    imm: TIntN.T := TIntN.Zero;
     optype: Type := Type.Void;
     stackp: INTEGER := 0; (* seems like it should be -1 *)
     opcode := FALSE;
@@ -141,7 +141,7 @@
 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: Target.IntN; VAR immA: ARRAY OperandPart OF Target.IntN): OperandSize;
+PROCEDURE SplitImm(type: Type; READONLY imm: TIntN.T; VAR immA: ARRAY OperandPart OF TIntN.T): OperandSize;
 PROCEDURE SplitOperand(READONLY op: Operand; VAR opA: ARRAY OperandPart OF Operand): OperandSize;
 PROCEDURE GetOperandSize(READONLY op: Operand): OperandSize;
 PROCEDURE GetTypeSize(type: Type): OperandSize;
@@ -151,11 +151,11 @@
 CONST UnsignedType = ARRAY IType OF IType { Type.Word32, Type.Word32,
                                             Type.Word64, Type.Word64 };
 
-CONST MaximumShift = ARRAY IType OF Target.IntN { TIntN.ThirtyOne, TIntN.ThirtyOne,
-                                                  TIntN.SixtyThree, TIntN.SixtyThree };
+CONST MaximumShift = ARRAY IType OF TIntN.T { TIntN.ThirtyOne, TIntN.ThirtyOne,
+                                              TIntN.SixtyThree, TIntN.SixtyThree };
 
-CONST MinimumShift = ARRAY IType OF Target.IntN { TIntN.MThirtyOne, TIntN.MThirtyOne,
-                                                  TIntN.MSixtyThree, TIntN.MSixtyThree };
+CONST MinimumShift = ARRAY IType OF TIntN.T { TIntN.MThirtyOne, TIntN.MThirtyOne,
+                                              TIntN.MSixtyThree, TIntN.MSixtyThree };
 
 CONST BitCountMask = MaximumShift;
  
Index: Stackx86.i3
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/m3back/src/Stackx86.i3,v
retrieving revision 1.23
diff -u -r1.23 Stackx86.i3
--- Stackx86.i3	27 Feb 2010 12:35:17 -0000	1.23
+++ Stackx86.i3	27 Feb 2010 13:52:48 -0000
@@ -11,7 +11,7 @@
 FROM M3CG IMPORT Type, MType, ZType, IType, Sign, ByteOffset;
 FROM M3CG_Ops IMPORT ErrorHandler;
 
-IMPORT M3x86Rep, Codex86, Wrx86, Target;
+IMPORT M3x86Rep, Codex86, Wrx86, TIntN;
 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: Target.IntN);
+        set_imm (stackp: INTEGER; READONLY imm: TIntN.T);
         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: Target.IntN; type: Type);
+        pushimmT (imm: TIntN.T; 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: Target.IntN; overwritesdest: BOOLEAN);
+        doimm (op: Op; READONLY imm: TIntN.T; overwritesdest: BOOLEAN);
         newdest (READONLY op: Operand);
         init ();
         end ();
         set_current_proc (p: x86Proc);
         reg (stackp: INTEGER): Regno;
-        lower (reg: Regno): Target.IntN;
-        set_lower (reg: Regno; low: Target.IntN);
-        upper (reg: Regno): Target.IntN;
-        set_upper (reg: Regno; up: Target.IntN);
+        lower (reg: Regno): TIntN.T;
+        set_lower (reg: Regno; low: TIntN.T);
+        upper (reg: Regno): TIntN.T;
+        set_upper (reg: Regno; up: TIntN.T);
         non_nil (reg: Regno): BOOLEAN;
         set_non_nil (reg: Regno);
       END;
Index: Stackx86.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/m3back/src/Stackx86.m3,v
retrieving revision 1.104
diff -u -r1.104 Stackx86.m3
--- Stackx86.m3	27 Feb 2010 12:35:17 -0000	1.104
+++ Stackx86.m3	27 Feb 2010 13:52:48 -0000
@@ -33,7 +33,7 @@
         vstacklimit   := 0;
         reguse        : ARRAY [0 .. NRegs] OF Register;
         current_proc  : x86Proc;
-        rmode         : ARRAY FlToInt OF Target.IntN;
+        rmode         : ARRAY FlToInt OF TIntN.T;
         lowset_table  : x86Var;
         highset_table : x86Var;
       OVERRIDES
@@ -102,9 +102,9 @@
   Register = RECORD
     stackp     : INTEGER := -1;
     last_store : MVar    := NoStore;
-    last_imm   : Target.IntN := TZero;
-    lowbound   : Target.IntN;
-    upbound    : Target.IntN;
+    last_imm   : TIntN.T := TZero;
+    lowbound   : TIntN.T;
+    upbound    : TIntN.T;
     imm        : BOOLEAN := FALSE;
     locked     : BOOLEAN := FALSE;
     non_nil    : BOOLEAN := FALSE;
@@ -113,7 +113,10 @@
 
 PROCEDURE InitRegister(locked: BOOLEAN := FALSE):Register =
 BEGIN
-  RETURN Register { locked := locked, lowbound := Target.Integer.minN, upbound := Target.Integer.maxN };
+  RETURN Register { locked := locked,
+                    (* BUG? Upbound/lowbound should adapt to the type? *)
+                    lowbound := TIntN.TargetIntegerMin,
+                     upbound := TIntN.TargetIntegerMax};
 END InitRegister;
 
 (*-------------------------------------------- register handling routines ---*)
@@ -558,7 +561,7 @@
     RETURN bestreg;
   END inreg;
 
-PROCEDURE immreg (t: T; READONLY imm: Target.IntN; set: RegSet:= RegSet {}): Regno =
+PROCEDURE immreg (t: T; READONLY imm: TIntN.T; set: RegSet:= RegSet {}): Regno =
   VAR minprec := HighPrec * HighPrec;
       prec := 0;
       bestreg: Regno := -1;
@@ -736,7 +739,7 @@
     t.vstack[stackp].mvar := mvar;
   END set_mvar;
 
-PROCEDURE set_imm (t: T; stackp: INTEGER; READONLY imm: Target.IntN) =
+PROCEDURE set_imm (t: T; stackp: INTEGER; READONLY imm: TIntN.T) =
   BEGIN
     t.vstack[stackp].loc := OLoc.imm;
     t.vstack[stackp].imm := imm;
@@ -764,7 +767,7 @@
     RETURN -1;
   END pos;
 
-PROCEDURE pushimmT (t: T; imm: Target.IntN; type: Type) =
+PROCEDURE pushimmT (t: T; imm: TIntN.T; type: Type) =
   BEGIN
     maybe_expand_stack(t);
 
@@ -779,7 +782,7 @@
   END pushimmT;
 
 PROCEDURE pushimmI (t: T; immI: INTEGER; type: Type) =
-  VAR immT: Target.IntN;
+  VAR immT: TIntN.T;
   BEGIN
     IF NOT TIntN.FromHostInteger(immI, Target.Integer.bytes, immT) THEN
       t.Err("pushimmI: unable to convert to target integer");
@@ -967,7 +970,7 @@
   END pop;
 
 PROCEDURE doloadaddress (t: T; v: x86Var; o: ByteOffset) =
-  VAR to, tvoffset, ti: Target.IntN;
+  VAR to, tvoffset, ti: TIntN.T;
   BEGIN
     unlock(t);
     pushnew(t, Type.Addr, Force.anyreg);
@@ -1315,7 +1318,7 @@
     END
   END domod;
 
-PROCEDURE doimm (t: T; op: Op; READONLY imm: Target.IntN; overwritesdest: BOOLEAN) =
+PROCEDURE doimm (t: T; op: Op; READONLY imm: TIntN.T; overwritesdest: BOOLEAN) =
   BEGIN
     unlock(t);
 
@@ -1324,7 +1327,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 (TIntN.GT(imm, Target.Int8.maxN) OR TIntN.LT(imm, Target.Int8.minN)))))
+          (CG_Bytes[stop0.mvar.mvar_type] = 1 AND (TIntN.GT(imm, TIntN.Max8) OR TIntN.LT(imm, TIntN.Min8)))))
          OR stop0.loc = OLoc.imm THEN
         find(t, stack0, Force.anyreg);
       ELSE
@@ -1342,7 +1345,7 @@
   END doimm;
 
 PROCEDURE doneg (t: T) =
-  VAR neg: Target.IntN;
+  VAR neg: TIntN.T;
   BEGIN
     unlock(t);
     WITH stack0 = pos(t, 0, "doneg"),
@@ -1401,8 +1404,8 @@
 
 PROCEDURE doshift (t: T; type: IType): BOOLEAN =
   VAR ovflshift, leftlab, endlab: Label;
-      tShiftCount: Target.IntN;
-      shiftResult: Target.IntN;
+      tShiftCount: TIntN.T;
+      shiftResult: TIntN.T;
       shiftCount: INTEGER;
       is64 := Is64(type);
   BEGIN
@@ -1672,10 +1675,11 @@
   END doextract;
 
 PROCEDURE doextract_n (t: T; type: IType; sign: BOOLEAN; n: INTEGER): BOOLEAN =
-  VAR tn, t32MinusN, andval: Target.IntN;
+  VAR tn, t32MinusN, andval: TIntN.T;
       int: INTEGER;
       uint_type := IntType[UnsignedType[type]];
       is64 := Is64(type);
+      max := TIntN.T{n := NUMBER(Target.Int), x := uint_type.max};
   BEGIN
 
     unlock(t);
@@ -1728,7 +1732,7 @@
         t.cg.unOp(Op.oSHR, stop1);
 
         IF n < uint_type.size THEN
-          TWordN.Shift(uint_type.maxN, n - uint_type.size, andval);
+          TWordN.Shift(max, n - uint_type.size, andval);
           t.cg.immOp(Op.oAND, stop1, andval);
         END
       END;
@@ -1741,7 +1745,7 @@
   END doextract_n;
 
 PROCEDURE doextract_mn (t: T; type: IType; sign: BOOLEAN; m, n: INTEGER): BOOLEAN =
-  VAR andval, tint: Target.IntN;
+  VAR andval, tint: TIntN.T;
       is64 := Is64(type);
   BEGIN
 
@@ -1755,13 +1759,13 @@
 
       IF stop0.loc = OLoc.imm THEN
         TWordN.Shift(stop0.imm, -m, stop0.imm);
-        TWordN.Shift(Target.Word32.maxN, n - 32, tint);
+        TWordN.Shift(TWordN.Max32, n - 32, tint);
         TWordN.And(stop0.imm, tint, stop0.imm);
         IF sign THEN
           TWordN.Shift(TIntN.One, n - 1, tint);
           TWordN.And(stop0.imm, tint, tint);
           IF TIntN.NE(tint, TZero) THEN
-            TWordN.Shift(Target.Word32.maxN, n, tint);
+            TWordN.Shift(TWordN.Max32, n, tint);
             TWordN.Or(stop0.imm, tint, stop0.imm);
           END;
         END;
@@ -1786,7 +1790,7 @@
       ELSE
         find(t, stack0, Force.anyreg);
         IF (m + n) < 32 THEN
-          TWordN.Shift(Target.Word32.maxN, m + n - 32, andval);
+          TWordN.Shift(TWordN.Max32, m + n - 32, andval);
           t.cg.immOp(Op.oAND, stop0, andval);
         END;
 
@@ -1807,7 +1811,7 @@
 PROCEDURE doinsert (t: T; type: IType): BOOLEAN =
   VAR maskreg: Regno;  tbl: MVar;
       int: INTEGER;
-      tint: Target.IntN;
+      tint: TIntN.T;
       is64 := Is64(type);
   BEGIN
 
@@ -1875,7 +1879,7 @@
         IF NOT TIntN.ToHostInteger(stop1.imm, int) THEN
           t.Err("failed to convert stop1.imm to host integer");
         END;
-        TWordN.Shift(Target.Word32.maxN, int, tint);
+        TWordN.Shift(TWordN.Max32, int, tint);
         t.cg.immOp(Op.oXOR, t.cg.reg[maskreg], tint);
       ELSE
         ImportHighSet (t, tbl);
@@ -1897,7 +1901,7 @@
 PROCEDURE doinsert_n (t: T; type: IType; n: INTEGER): BOOLEAN =
   VAR tbl: MVar;  maskreg: Regno;
       m: INTEGER;
-      tint: Target.IntN;
+      tint: TIntN.T;
       is64 := Is64(type);
   BEGIN
 
@@ -1933,7 +1937,7 @@
       corrupt(t, maskreg, operandPart := 0);
 
       IF n # 32 THEN
-        TWordN.Shift(Target.Word32.maxN, n - 32, tint);
+        TWordN.Shift(TWordN.Max32, n - 32, tint);
         t.cg.immOp(Op.oAND, stop1, tint);
       END;
 
@@ -1963,9 +1967,10 @@
   END doinsert_n;
   
 PROCEDURE doinsert_mn (t: T; type: IType; m, n: INTEGER): BOOLEAN =
-  VAR tint_m, mask_m, mask_m_n, mask: Target.IntN;
+  VAR tint_m, mask_m, mask_m_n, mask: TIntN.T;
       uint_type := IntType[UnsignedType[type]];
       is64 := Is64(type);
+      max := TIntN.T{n := NUMBER(Target.Int), x := uint_type.max};
   BEGIN
 
     unlock(t);
@@ -1987,7 +1992,7 @@
         find(t, stack1, Force.anyreg);
       END;
 
-      TWordN.Shift(uint_type.maxN, n - uint_type.size, mask);
+      TWordN.Shift(max, n - uint_type.size, mask);
 
       IF stop0.loc = OLoc.imm THEN
         TWordN.And(stop0.imm, mask, stop0.imm);
@@ -2005,11 +2010,11 @@
         END
       END;
 
-      TWordN.Shift(uint_type.maxN, m, mask_m);
-      TWordN.Shift(uint_type.maxN, m + n - uint_type.size, mask_m_n);
+      TWordN.Shift(max, m, mask_m);
+      TWordN.Shift(max, m + n - uint_type.size, mask_m_n);
       TWordN.Xor(mask_m, mask_m_n, mask);
 
-      IF TWordN.NE(mask, uint_type.maxN) THEN
+      IF TWordN.NE(mask, max) THEN
         IF stop1.loc = OLoc.imm THEN
           TWordN.And(stop1.imm, mask, stop1.imm);
         ELSE
@@ -2197,9 +2202,9 @@
 PROCEDURE doindex_address (t: T; shift, size: INTEGER; neg: BOOLEAN) =
   VAR imsize: INTEGER;
       muldest: Regno;
-      tsize: Target.IntN;
-      tshift: Target.IntN;
-      tint: Target.IntN;
+      tsize: TIntN.T;
+      tshift: TIntN.T;
+      tint: TIntN.T;
   BEGIN
     unlock(t);
     WITH stack0 = pos(t, 0, "doindex_address"),
@@ -2433,8 +2438,9 @@
       FOR i := 0 TO GetTypeSize(op.optype) - 1 DO
         WITH z = t.reguse[op.reg[i]] DO
           z.last_store := NoStore;
-          z.upbound    := Target.Integer.maxN;
-          z.lowbound   := Target.Integer.minN;
+          (* BUG? Upbound/lowbound should adapt to the type? *)
+          z.upbound    := TIntN.TargetIntegerMax;
+          z.lowbound   := TIntN.TargetIntegerMin;
           z.imm        := FALSE;
           z.non_nil    := FALSE;
         END;
@@ -2488,22 +2494,22 @@
     RETURN t.vstack[stackp].reg[0];
   END reg;
 
-PROCEDURE lower (t: T; reg: Regno): Target.IntN =
+PROCEDURE lower (t: T; reg: Regno): TIntN.T =
   BEGIN
     RETURN t.reguse[reg].lowbound;
   END lower;
 
-PROCEDURE upper (t: T; reg: Regno): Target.IntN =
+PROCEDURE upper (t: T; reg: Regno): TIntN.T =
   BEGIN
     RETURN t.reguse[reg].upbound;
   END upper;
 
-PROCEDURE set_lower (t: T; reg: Regno; newlow: Target.IntN) =
+PROCEDURE set_lower (t: T; reg: Regno; newlow: TIntN.T) =
   BEGIN
     t.reguse[reg].lowbound := newlow;
   END set_lower;
 
-PROCEDURE set_upper (t: T; reg: Regno; newup: Target.IntN) =
+PROCEDURE set_upper (t: T; reg: Regno; newup: TIntN.T) =
   BEGIN
     t.reguse[reg].upbound := newup;
   END set_upper;
@@ -2532,15 +2538,16 @@
       WITH z = t.reguse[i] DO
         z.stackp     := -1;
         z.last_store := NoStore;
-        z.upbound    := Target.Integer.maxN;
-        z.lowbound   := Target.Integer.minN;
+        (* BUG? Upbound/lowbound should adapt to the type? *)
+        z.upbound    := TIntN.TargetIntegerMax;
+        z.lowbound   := TIntN.TargetIntegerMin;
         z.imm        := FALSE;
         z.non_nil    := FALSE;
         z.locked     := FALSE;
       END;
     END;
 
-    t.rmode := ARRAY FlToInt OF Target.IntN
+    t.rmode := ARRAY FlToInt OF TIntN.T
       { TZero, TIntN.x0400, TIntN.x0800, TIntN.x0F00 };
     t.lowset_table := NIL;
     t.highset_table := NIL;
@@ -2637,10 +2644,10 @@
     IF (NOT TIntN.EQ(r.last_imm, TZero)) THEN
       wr.OutT ("  imm: ");  wr.OutT (TIntN.ToText (r.last_imm));
     END;
-    IF (NOT TIntN.EQ(r.lowbound, Target.Integer.minN)) THEN
+    IF (NOT TIntN.EQ(r.lowbound, TIntN.TargetIntegerMin)) THEN
       wr.OutT ("  lo: ");  wr.OutT (TIntN.ToText (r.lowbound));
     END;
-    IF (NOT TIntN.EQ(r.upbound, Target.Integer.maxN)) THEN
+    IF (NOT TIntN.EQ(r.upbound, TIntN.TargetIntegerMax)) THEN
       wr.OutT ("  hi: ");  wr.OutT (TIntN.ToText (r.upbound));
     END;
     IF (r.imm # FALSE) THEN
Index: TIntN.i3
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/m3back/src/TIntN.i3,v
retrieving revision 1.1
diff -u -r1.1 TIntN.i3
--- TIntN.i3	27 Feb 2010 00:49:45 -0000	1.1
+++ TIntN.i3	27 Feb 2010 13:52:48 -0000
@@ -1,4 +1,12 @@
-INTERFACE TIntN; (* also known as TInt *)
+(* Copyright (C) 1993, Digital Equipment Corporation           *)
+(* All rights reserved.                                        *)
+(* See the file COPYRIGHT for a full description.              *)
+(*                                                             *)
+(* File: TIntN.i3                                              *)
+(* Last Modified On Thu Mar 10 13:42:53 PST 1994 By kalsow     *)
+(*      Modified On Thu May 20 08:20:38 PDT 1993 By muller     *)
+
+INTERFACE TIntN;
 
 (*  Modula-3 target description
 
@@ -10,13 +18,15 @@
     otherwise they return FALSE.
 *)
 
-IMPORT Target, TInt;
+IMPORT TInt;
 FROM Target IMPORT Int;
 
-TYPE T = (* OPAQUE *) RECORD
-  n: CARDINAL := NUMBER (Int);    (* only bytes [0..n-1] contain valid bits *)
-  x: Int;                         (* default is Zero *)
-END;
+TYPE
+ (* Int but with user-specified precision *)
+  T = (* OPAQUE *) RECORD
+    n: CARDINAL := NUMBER (Int);    (* only bytes [0..n-1] contain valid bits *)
+    x: Int;                         (* default is Zero *)
+  END;
 
 CONST
   Zero      = T{x := TInt.Zero};
@@ -25,6 +35,8 @@
 
   Min8      = T{x := TInt.Min8};
   Max8      = T{x := TInt.Max8};
+  Min16     = T{x := TInt.Min16};
+  Max16     = T{x := TInt.Max16};
   Min32     = T{x := TInt.Min32};
   Max32     = T{x := TInt.Max32};
   Min64     = T{x := TInt.Min64};
@@ -45,16 +57,22 @@
   MThirtyOne = T{x := Int{16_E1,16_FF,..}};
   MSixtyThree= T{x := Int{16_C1,16_FF,..}};
 
-PROCEDURE FromTInt (READONLY x: Int;  n: CARDINAL;  VAR i: T): BOOLEAN;
-(* converts a host integer 'x' to a target integer 'i' *)
+PROCEDURE SignExtend(VAR a: Int; n: CARDINAL);
+(* sign extend from n to the precision of Int *)
 
-PROCEDURE ToTInt (READONLY i: T): Int;
-(* converts a target integer 'i' to a host integer 'x' *)
+PROCEDURE SignedTruncate(VAR a: Int; n: CARDINAL): BOOLEAN;
+(* truncate to n bytes; return FALSE if the value did not previously fit *)
+
+PROCEDURE ZeroExtend(VAR a: Int; n: CARDINAL);
+(* zero extend from n bytes to the precision of Int *)
 
-PROCEDURE FromInt (x: INTEGER;  n: CARDINAL;  VAR i: T): BOOLEAN;
+PROCEDURE UnsignedTruncate(VAR a: Int; n: CARDINAL): BOOLEAN;
+(* truncate to n bytes; return FALSE if the value did not previously fit *)
+
+PROCEDURE FromHostInteger (x: INTEGER;  n: CARDINAL;  VAR i: T): BOOLEAN;
 (* converts a host integer 'x' to a target integer 'i' *)
 
-PROCEDURE ToInt (READONLY i: T;  VAR x: INTEGER): BOOLEAN;
+PROCEDURE ToHostInteger (READONLY i: T;  VAR x: INTEGER): BOOLEAN;
 (* converts a target integer 'i' to a host integer 'x' *)
 
 PROCEDURE Abs (READONLY a: T;  VAR r: T): BOOLEAN;
@@ -103,6 +121,13 @@
 (* 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: Int; byteSize: CARDINAL): T;
+
 PROCEDURE ToDiagnosticText(a: T): TEXT;
 
+VAR (*CONST*) TargetIntegerMin: T;
+VAR (*CONST*) TargetIntegerMax: T;
+
+PROCEDURE Init();
+
 END TIntN.
Index: TIntN.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/m3back/src/TIntN.m3,v
retrieving revision 1.1
diff -u -r1.1 TIntN.m3
--- TIntN.m3	27 Feb 2010 00:49:45 -0000	1.1
+++ TIntN.m3	27 Feb 2010 13:52:48 -0000
@@ -1,42 +1,129 @@
+(* Copyright (C) 1993, Digital Equipment Corporation           *)
+(* All rights reserved.                                        *)
+(* See the file COPYRIGHT for a full description.              *)
+(*                                                             *)
+(* File: TIntN.m3                                              *)
+(* Last Modified On Tue Jul 12 08:31:56 PDT 1994 By kalsow     *)
+(*      Modified On Thu May 20 08:46:32 PDT 1993 By muller     *)
+
 MODULE TIntN; (* TInt but with specified precision, in bytes *)
 
-IMPORT Fmt, TInt;
+IMPORT Fmt, TInt, Word, Target;
 FROM Target IMPORT Int;
 
-PROCEDURE FromTInt (READONLY x: Int;  n: CARDINAL;  VAR r: T): BOOLEAN =
+CONST
+  Mask     = 16_FF;
+  SignMask = 16_80;
+
+PROCEDURE Init() =
   BEGIN
-    r.n := n;
-    RETURN TInt.Extend(x, n, r.x);
-  END FromTInt;
+    TargetIntegerMin := T{x := Target.Integer.min};
+    TargetIntegerMax := T{x := Target.Integer.max};
+  END Init;
 
-PROCEDURE ToTInt (READONLY r: T): Int =
-  VAR x: Int;
+PROCEDURE SignExtend(VAR a: Int; n: CARDINAL) =
+(*
+    sign extend from n to the precision of Int
+*)
+  VAR extend := 0;
   BEGIN
-    EVAL TInt.Extend(r.x, r.n, x);
-    RETURN x;
-  END ToTInt;
 
-PROCEDURE FromInt (a: INTEGER;  n: CARDINAL;  VAR r: T): BOOLEAN =
-  VAR x: Int;
+    IF Word.And(a[n - 1], SignMask) # 0 THEN
+      extend := Mask;
+    END;
+    FOR i := n TO LAST(a) DO
+      a[i] := extend;
+    END;
+  END SignExtend;
+
+PROCEDURE SignedTruncate(VAR a: Int; n: CARDINAL): BOOLEAN =
+(*
+    truncate to n bytes
+    return FALSE if the value did not previously fit
+*)
+  VAR result := TRUE;
+      extend := 0;
   BEGIN
-    RETURN TInt.FromInt(a, x) AND FromTInt(x, n, r);
-  END FromInt;
+    <* ASSERT n # 0 *>
+    <* ASSERT n <= NUMBER(a) *>
+
+    IF Word.And(a[LAST(a)], SignMask) # 0 THEN
+      extend := Mask;
+    END;
+    FOR i := n TO LAST(a) DO
+      IF a[i] # extend THEN
+        result := FALSE;
+        a[i] := extend;
+      END;
+    END;
+
+    RETURN result;
+  END SignedTruncate;
+
+PROCEDURE ZeroExtend(VAR a: Int; n: CARDINAL) =
+(*
+    zero extend from n bytes to the precision of Int
+*)
+  BEGIN
+    <*ASSERT n # 0*>
+    FOR i := n TO LAST(a) DO
+      a[i] := 0;
+    END;
+  END ZeroExtend;
 
-PROCEDURE ToInt (READONLY r: T;  VAR x: INTEGER): BOOLEAN =
+PROCEDURE UnsignedTruncate(VAR a: Int; n: CARDINAL): BOOLEAN =
+(*
+    truncate to n bytes
+    return FALSE if the value did not previously fit
+*)
+  VAR result := TRUE;
+  BEGIN
+    <*ASSERT n # 0*>
+    FOR i := n TO LAST(a) DO
+      IF a[i] # 0 THEN
+        result := FALSE;
+        a[i] := 0;
+      END;
+    END;
+    RETURN result;
+  END UnsignedTruncate;
+
+PROCEDURE ToInt(READONLY a: T): Int =
+  VAR b: Int;
   BEGIN
-    RETURN TInt.ToInt(ToTInt(r), x);
+    b := a.x;
+    SignExtend(b, a.n);
+    RETURN b;
   END ToInt;
 
+PROCEDURE FromInt(VAR a: T; n: CARDINAL): BOOLEAN =
+  BEGIN
+    <* ASSERT n # 0 *>
+    <* ASSERT n <= NUMBER(Int) *>
+    a.n := n;
+    RETURN SignedTruncate(a.x, n);
+  END FromInt;
+
+PROCEDURE FromHostInteger (x: INTEGER;  n: CARDINAL;  VAR r: T): BOOLEAN =
+  BEGIN
+    RETURN TInt.FromInt(x, r.x) AND FromInt(r, n);
+  END FromHostInteger;
+
+PROCEDURE ToHostInteger (READONLY r: T;  VAR x: INTEGER): BOOLEAN =
+  VAR i := r;
+  BEGIN
+    i.n := BYTESIZE(INTEGER);
+    RETURN TInt.ToInt(ToInt(i), x);
+  END ToHostInteger;
+
 PROCEDURE Add (READONLY a, b: T;  VAR r: T): BOOLEAN =
-  VAR x: Int;
   BEGIN
-    RETURN TInt.Add(ToTInt(a), ToTInt(b), x) AND FromTInt(x, MIN(a.n, b.n), r);
+    RETURN TInt.Add(ToInt(a), ToInt(b), r.x) AND FromInt(r, MIN(a.n, b.n));
   END Add;
 
 PROCEDURE Subtract (READONLY a, b: T;  VAR r: T): BOOLEAN =
-  VAR x: Int;
   BEGIN
-    RETURN TInt.Subtract(ToTInt(a), ToTInt(b), x) AND FromTInt(x, MIN(a.n, b.n), r);
+    RETURN TInt.Subtract(ToInt(a), ToInt(b), r.x) AND FromInt(r, MIN(a.n, b.n));
   END Subtract;
 
 PROCEDURE Negate (READONLY a: T;  VAR r: T): BOOLEAN =
@@ -54,63 +141,65 @@
   END Abs;
 
 PROCEDURE Multiply (READONLY a, b: T;  VAR r: T): BOOLEAN =
-  VAR x: Int;
   BEGIN
-    RETURN TInt.Multiply(ToTInt(a), ToTInt(b), x) AND FromTInt(x, MIN(a.n, b.n), r);
+    RETURN TInt.Multiply(ToInt(a), ToInt(b), r.x) AND FromInt(r, MIN(a.n, b.n));
   END Multiply;
 
 PROCEDURE Div (READONLY num, den: T;  VAR q: T): BOOLEAN =
-  VAR x: Int;
   BEGIN
-    RETURN TInt.Div(ToTInt(num), ToTInt(den), x) AND FromTInt(x, MIN(num.n, den.n), q);
+    RETURN TInt.Div(ToInt(num), ToInt(den), q.x) AND FromInt(q, MIN(num.n, den.n));
   END Div;
 
 PROCEDURE Mod (READONLY num, den: T;  VAR r: T): BOOLEAN =
-  VAR x: Int;
   BEGIN
-    RETURN TInt.Mod(ToTInt(num), ToTInt(den), x) AND FromTInt(x, MIN(num.n, den.n), r);
+    RETURN TInt.Mod(ToInt(num), ToInt(den), r.x) AND FromInt(r, MIN(num.n, den.n));
   END Mod;
 
 PROCEDURE EQ (READONLY a, b: T): BOOLEAN =
   BEGIN
-    RETURN TInt.EQ(ToTInt(a), ToTInt(b));
+    RETURN TInt.EQ(ToInt(a), ToInt(b));
   END EQ;
 
 PROCEDURE LT (READONLY a, b: T): BOOLEAN =
   BEGIN
-    RETURN TInt.LT(ToTInt(a), ToTInt(b));
+    RETURN TInt.LT(ToInt(a), ToInt(b));
   END LT;
 
 PROCEDURE LE (READONLY a, b: T): BOOLEAN =
   BEGIN
-    RETURN TInt.LE(ToTInt(a), ToTInt(b));
+    RETURN TInt.LE(ToInt(a), ToInt(b));
   END LE;
 
 PROCEDURE NE (READONLY a, b: T): BOOLEAN =
   BEGIN
-    RETURN TInt.NE(ToTInt(a), ToTInt(b));
+    RETURN TInt.NE(ToInt(a), ToInt(b));
   END NE;
 
 PROCEDURE GT (READONLY a, b: T): BOOLEAN =
   BEGIN
-    RETURN TInt.GT(ToTInt(a), ToTInt(b));
+    RETURN TInt.GT(ToInt(a), ToInt(b));
   END GT;
 
 PROCEDURE GE (READONLY a, b: T): BOOLEAN = 
   BEGIN
-    RETURN TInt.GE(ToTInt(a), ToTInt(b));
+    RETURN TInt.GE(ToInt(a), ToInt(b));
   END GE;
 
 PROCEDURE ToText (READONLY r: T): TEXT =
   BEGIN
-    RETURN TInt.ToText(ToTInt(r));
+    RETURN TInt.ToText(ToInt(r));
   END ToText;
 
 PROCEDURE ToChars (READONLY r: T;  VAR buf: ARRAY OF CHAR): INTEGER =
   BEGIN
-    RETURN TInt.ToChars(ToTInt(r), buf);
+    RETURN TInt.ToChars(ToInt(r), buf);
   END ToChars;
 
+PROCEDURE FromTargetInt (READONLY i: Int; byteSize: CARDINAL): T =
+  BEGIN
+    RETURN T{n := byteSize, x := i};
+  END FromTargetInt;
+
 PROCEDURE ToDiagnosticText(a: T): TEXT =
   BEGIN
     RETURN "n:" & Fmt.Unsigned(a.n) & ",x:" & TargetIntToDiagnosticText(a.x);
Index: TWordN.i3
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/m3back/src/TWordN.i3,v
retrieving revision 1.1
diff -u -r1.1 TWordN.i3
--- TWordN.i3	27 Feb 2010 00:49:46 -0000	1.1
+++ TWordN.i3	27 Feb 2010 13:52:48 -0000
@@ -1,4 +1,12 @@
-INTERFACE TWordN; (* also known as TWord *)
+(* Copyright (C) 1993, Digital Equipment Corporation           *)
+(* All rights reserved.                                        *)
+(* See the file COPYRIGHT for a full description.              *)
+(*                                                             *)
+(* File: TWordN.i3                                             *)
+(* Last Modified On Fri Nov 19 09:32:50 PST 1993 By kalsow     *)
+(*      Modified On Thu May 20 08:20:38 PDT 1993 By muller     *)
+
+INTERFACE TWordN;
 
 (*  Modula-3 target description
 
@@ -11,13 +19,13 @@
 *)
 
 IMPORT TIntN, TWord;
-TYPE T = TIntN.T;
+FROM TIntN IMPORT T;
 
 CONST
-  Max8  = T{1, TWord.Max8};
-  Max16 = T{2, TWord.Max16};
-  Max32 = T{4, TWord.Max32};
-  Max64 = T{8, TWord.Max64};
+  Max8  = T{x := TWord.Max8};
+  Max16 = T{x := TWord.Max16};
+  Max32 = T{x := TWord.Max32};
+  Max64 = T{x := TWord.Max64};
 
 PROCEDURE Add (READONLY a, b: T;  VAR i: T);
 (* returns 'Word.Plus (a, b)' *)
Index: TWordN.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/m3back/src/TWordN.m3,v
retrieving revision 1.1
diff -u -r1.1 TWordN.m3
--- TWordN.m3	27 Feb 2010 00:49:46 -0000	1.1
+++ TWordN.m3	27 Feb 2010 13:52:48 -0000
@@ -1,14 +1,24 @@
+(* Copyright (C) 1993, Digital Equipment Corporation           *)
+(* All rights reserved.                                        *)
+(* See the file COPYRIGHT for a full description.              *)
+(*                                                             *)
+(* File: TWordN.m3                                             *)
+(* Last Modified On Fri Nov 19 09:32:56 PST 1993 By kalsow     *)
+(*      Modified On Thu May 20 08:46:32 PDT 1993 By muller     *)
+
 MODULE TWordN; (* also known as TWord *)
 
-IMPORT TWord, TInt;
+IMPORT TWord, TInt, TIntN;
 FROM Target IMPORT Int;
+TYPE T = TIntN.T;
 
 (*------------------------------------------- unsigned integer operations ---*)
 
 PROCEDURE ToInt(READONLY a: T): Int =
   VAR b: Int;
   BEGIN
-   EVAL TWord.Truncate(a.x, a.n, b);
+   b:= a.x;
+   TIntN.ZeroExtend(b, a.n);
    RETURN b;
   END ToInt;
 
@@ -17,7 +27,7 @@
     <*ASSERT n # 0*>
     a.n := n;
     (* overflow always ignored *)
-    EVAL TWord.Truncate(a.x, n, a.x);
+    EVAL TIntN.UnsignedTruncate(a.x, n);
   END FromInt;
 
 PROCEDURE Add (READONLY a, b: T;  VAR r: T) =
Index: Wrx86.i3
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/m3back/src/Wrx86.i3,v
retrieving revision 1.9
diff -u -r1.9 Wrx86.i3
--- Wrx86.i3	27 Feb 2010 12:35:17 -0000	1.9
+++ Wrx86.i3	27 Feb 2010 13:52:48 -0000
@@ -8,7 +8,7 @@
 
 INTERFACE Wrx86;
 
-IMPORT Wr, Target;
+IMPORT Wr, Target, TIntN;
 
 FROM M3CG IMPORT Name, TypeUID;
 FROM M3CG IMPORT Var, Proc, Label;
@@ -29,7 +29,7 @@
         Lab (i: Label);
         Tipe (t: TypeUID);
         Int (i: INTEGER);
-        TInt (READONLY i: Target.IntN);
+        TInt (READONLY i: TIntN.T);
         BInt (i: INTEGER);
         Txt (t: TEXT);
         OutC (c: CHAR);
Index: Wrx86.m3
===================================================================
RCS file: /usr/cvs/cm3/m3-sys/m3back/src/Wrx86.m3,v
retrieving revision 1.17
diff -u -r1.17 Wrx86.m3
--- Wrx86.m3	27 Feb 2010 12:35:17 -0000	1.17
+++ Wrx86.m3	27 Feb 2010 13:52:48 -0000
@@ -152,13 +152,12 @@
     OutI (t, i);
   END Int;
 
-PROCEDURE TInt (t: T;  READONLY i: Target.IntN) =
+PROCEDURE TInt (t: T;  READONLY i: TIntN.T) =
   VAR
-    buf : ARRAY [0..BITSIZE (Target.IntN)] OF CHAR;
-    len := TIntN.ToChars (i, buf);
+    buf : ARRAY [0..BITSIZE (TIntN.T)] OF CHAR;
  BEGIN
     OutC (t, ' ');
-    OutS (t, SUBARRAY (buf, 0, len));
+    OutS (t, SUBARRAY (buf, 0, TIntN.ToChars (i, buf)));
     OutC (t, ' ');
     OutT (t, TIntN.ToDiagnosticText(i));
   END TInt;