got rid of some mAddU64 etc. magics

4 files changed, 12 insertions, 22 deletions

diff --git a/compiler/ast.nim b/compiler/ast.nim
index c28cb6e0b..c826dfad9 100755
--- a/compiler/ast.nim
+++ b/compiler/ast.nim
@@ -393,7 +393,7 @@ type
     mShrI, mShlI, mBitandI, mBitorI, mBitxorI, mMinI, mMaxI, 
     mShrI64, mShlI64, mBitandI64, mBitorI64, mBitxorI64, mMinI64, mMaxI64,
     mMinF64, mMaxF64, mAddU, mSubU, mMulU, 
-    mDivU, mModU, mAddU64, mSubU64, mMulU64, mDivU64, mModU64, mEqI, mLeI,
+    mDivU, mModU, mEqI, mLeI,
     mLtI, 
     mEqI64, mLeI64, mLtI64, mEqF64, mLeF64, mLtF64, 
     mLeU, mLtU, mLeU64, mLtU64, 
@@ -444,7 +444,7 @@ const
     mShrI, mShlI, mBitandI, mBitorI, mBitxorI, mMinI, mMaxI, 
     mShrI64, mShlI64, mBitandI64, mBitorI64, mBitxorI64, mMinI64, mMaxI64,
     mMinF64, mMaxF64, mAddU, mSubU, mMulU, 
-    mDivU, mModU, mAddU64, mSubU64, mMulU64, mDivU64, mModU64, mEqI, mLeI,
+    mDivU, mModU, mEqI, mLeI,
     mLtI, 
     mEqI64, mLeI64, mLtI64, mEqF64, mLeF64, mLtF64, 
     mLeU, mLtU, mLeU64, mLtU64, 
diff --git a/compiler/ccgexprs.nim b/compiler/ccgexprs.nim
index 78e9e5c31..37908f09c 100755
--- a/compiler/ccgexprs.nim
+++ b/compiler/ccgexprs.nim
@@ -430,11 +430,6 @@ proc binaryArith(p: BProc, e: PNode, d: var TLoc, op: TMagic) =
       "($4)((NU$3)($1) * (NU$3)($2))", # MulU
       "($4)((NU$3)($1) / (NU$3)($2))", # DivU
       "($4)((NU$3)($1) % (NU$3)($2))", # ModU
-      "($4)((NU64)($1) + (NU64)($2))", # AddU64
-      "($4)((NU64)($1) - (NU64)($2))", # SubU64
-      "($4)((NU64)($1) * (NU64)($2))", # MulU64
-      "($4)((NU64)($1) / (NU64)($2))", # DivU64
-      "($4)((NU64)($1) % (NU64)($2))", # ModU64
       "($1 == $2)",           # EqI
       "($1 <= $2)",           # LeI
       "($1 < $2)",            # LtI
diff --git a/compiler/ecmasgen.nim b/compiler/ecmasgen.nim
index 9b3601ae4..20a021669 100755
--- a/compiler/ecmasgen.nim
+++ b/compiler/ecmasgen.nim
@@ -351,11 +351,6 @@ const # magic checked op; magic unchecked op; checked op; unchecked op
     ["MulU", "MulU", "MulU($1, $2)", "MulU($1, $2)"], # MulU
     ["DivU", "DivU", "DivU($1, $2)", "DivU($1, $2)"], # DivU
     ["ModU", "ModU", "ModU($1, $2)", "ModU($1, $2)"], # ModU
-    ["AddU64", "AddU64", "AddU64($1, $2)", "AddU64($1, $2)"], # AddU64
-    ["SubU64", "SubU64", "SubU64($1, $2)", "SubU64($1, $2)"], # SubU64
-    ["MulU64", "MulU64", "MulU64($1, $2)", "MulU64($1, $2)"], # MulU64
-    ["DivU64", "DivU64", "DivU64($1, $2)", "DivU64($1, $2)"], # DivU64
-    ["ModU64", "ModU64", "ModU64($1, $2)", "ModU64($1, $2)"], # ModU64
     ["", "", "($1 == $2)", "($1 == $2)"], # EqI
     ["", "", "($1 <= $2)", "($1 <= $2)"], # LeI
     ["", "", "($1 < $2)", "($1 < $2)"], # LtI
diff --git a/compiler/semfold.nim b/compiler/semfold.nim
index 748a0a154..7c16da3ce 100755
--- a/compiler/semfold.nim
+++ b/compiler/semfold.nim
@@ -181,11 +181,11 @@ proc getIntervalType*(m: TMagic, n: PNode): PType =
     if isIntRange(a) and isIntLit(b):
       result = makeRange(a, pickMinInt(n.sons[1]) |-| pickMinInt(n.sons[2]),
                             pickMaxInt(n.sons[1]) |-| pickMaxInt(n.sons[2]))
-  of mAddI, mAddI64, mAddU, mAddU64:
+  of mAddI, mAddI64, mAddU:
     commutativeOp(`|+|`)
-  of mMulI, mMulI64, mMulU, mMulU64:
+  of mMulI, mMulI64, mMulU:
     commutativeOp(`|*|`)
-  of mSubI, mSubI64, mSubU, mSubU64:
+  of mSubI, mSubI64, mSubU:
     binaryOp(`|-|`)
   of mBitandI, mBitandI64:
     var a = n.sons[1]
@@ -196,7 +196,7 @@ proc getIntervalType*(m: TMagic, n: PNode): PType =
       let x = b.intVal|+|1
       if (x and -x) == x and x >= 0:
         result = makeRange(a.typ, 0, b.intVal)
-  of mModI, mModI64, mModU, mModU64:
+  of mModI, mModI64, mModU:
     # so ... if you ever wondered about modulo's signedness; this defines it:
     let a = n.sons[1]
     let b = n.sons[2]
@@ -205,7 +205,7 @@ proc getIntervalType*(m: TMagic, n: PNode): PType =
         result = makeRange(a.typ, 0, b.intVal-1)
       else:
         result = makeRange(a.typ, b.intVal+1, 0)
-  of mDivI, mDivI64, mDivU, mDivU64:
+  of mDivI, mDivI64, mDivU:
     binaryOp(`|div|`)
   of mMinI, mMinI64:
     commutativeOp(min)
@@ -311,11 +311,11 @@ proc evalOp(m: TMagic, n, a, b, c: PNode): PNode =
   of mBitandI, mBitandI64, mAnd: result = newIntNodeT(a.getInt and b.getInt, n)
   of mBitorI, mBitorI64, mOr: result = newIntNodeT(getInt(a) or getInt(b), n)
   of mBitxorI, mBitxorI64, mXor: result = newIntNodeT(a.getInt xor b.getInt, n)
-  of mAddU, mAddU64: result = newIntNodeT(`+%`(getInt(a), getInt(b)), n)
-  of mSubU, mSubU64: result = newIntNodeT(`-%`(getInt(a), getInt(b)), n)
-  of mMulU, mMulU64: result = newIntNodeT(`*%`(getInt(a), getInt(b)), n)
-  of mModU, mModU64: result = newIntNodeT(`%%`(getInt(a), getInt(b)), n)
-  of mDivU, mDivU64: result = newIntNodeT(`/%`(getInt(a), getInt(b)), n)
+  of mAddU: result = newIntNodeT(`+%`(getInt(a), getInt(b)), n)
+  of mSubU: result = newIntNodeT(`-%`(getInt(a), getInt(b)), n)
+  of mMulU: result = newIntNodeT(`*%`(getInt(a), getInt(b)), n)
+  of mModU: result = newIntNodeT(`%%`(getInt(a), getInt(b)), n)
+  of mDivU: result = newIntNodeT(`/%`(getInt(a), getInt(b)), n)
   of mLeSet: result = newIntNodeT(Ord(containsSets(a, b)), n)
   of mEqSet: result = newIntNodeT(Ord(equalSets(a, b)), n)
   of mLtSet: