fix i64 mode 1 bitshifts, and improve printing of i64 mode 1s

4 files changed, 97 insertions, 30 deletions

diff --git a/src/library.js b/src/library.js
index 5a429131..0e7b8b54 100644
--- a/src/library.js
+++ b/src/library.js
@@ -2260,7 +2260,6 @@ LibraryManager.library = {
       } else if (type == 'i64') {
         ret = [{{{ makeGetValue('varargs', 'argIndex', 'i32', undefined, undefined, true) }}},
                {{{ makeGetValue('varargs', 'argIndex+4', 'i32', undefined, undefined, true) }}}];
-        ret = unSign(ret[0], 32) + unSign(ret[1], 32)*Math.pow(2, 32); // Unsigned in this notation. Signed later if needed. // XXX - loss of precision
 #else
       } else if (type == 'i64') {
         ret = {{{ makeGetValue('varargs', 'argIndex', 'i64', undefined, undefined, true) }}};
@@ -2270,7 +2269,7 @@ LibraryManager.library = {
         ret = {{{ makeGetValue('varargs', 'argIndex', 'i32', undefined, undefined, true) }}};
       }
       argIndex += Runtime.getNativeFieldSize(type);
-      return Number(ret);
+      return ret;
     }
 
     var ret = [];
@@ -2392,6 +2391,12 @@ LibraryManager.library = {
           var signed = next == 'd'.charCodeAt(0) || next == 'i'.charCodeAt(0);
           argSize = argSize || 4;
           var currArg = getNextArg('i' + (argSize * 8));
+#if I64_MODE == 1
+          // Flatten i64-1 [low, high] into a (slightly rounded) double
+          if (argSize == 8) {
+            currArg = Runtime.makeBigInt(currArg[0], currArg[1], next == 'u'.charCodeAt(0));
+          }
+#endif
           // Truncate to requested size.
           if (argSize <= 4) {
             var limit = Math.pow(256, argSize) - 1;
diff --git a/src/parseTools.js b/src/parseTools.js
index b287b237..c3913298 100644
--- a/src/parseTools.js
+++ b/src/parseTools.js
@@ -558,22 +558,13 @@ function makeInlineCalculation(expression, value, tempVar) {
   return '(' + expression.replace(/VALUE/g, value) + ')';
 }
 
-// Given two 32-bit unsigned parts of an emulated 64-bit number, combine them into a JS number (double).
-// Rounding is inevitable if the number is large. This is a particular problem for small negative numbers
-// (-1 will be rounded!), so handle negatives separately and carefully
-function makeBigInt(low, high) {
-  // here VALUE will be the big part
-  return '(' + high + ' <= 2147483648 ? (' + makeSignOp(low, 'i32', 'un', 1, 1) + '+(' + makeSignOp(high, 'i32', 'un', 1, 1) + '*4294967296))' +
-                                    ' : (' + makeSignOp(low, 'i32', 're', 1, 1) + '+(1+' + makeSignOp(high, 'i32', 're', 1, 1) + ')*4294967296))';
-}
-
 // Makes a proper runtime value for a 64-bit value from low and high i32s. low and high are assumed to be unsigned.
 function makeI64(low, high) {
   high = high || '0';
   if (I64_MODE == 1) {
     return '[' + makeSignOp(low, 'i32', 'un', 1, 1) + ',' + makeSignOp(high, 'i32', 'un', 1, 1) + ']';
   } else {
-    if (high) return makeBigInt(low, high);
+    if (high) return RuntimeGenerator.makeBigInt(low, high);
     return low;
   }
 }
@@ -589,7 +580,7 @@ function splitI64(value) {
 }
 function mergeI64(value) {
   assert(I64_MODE == 1);
-  return makeInlineCalculation(makeBigInt('VALUE[0]', 'VALUE[1]'), value, 'tempI64');
+  return makeInlineCalculation(RuntimeGenerator.makeBigInt('VALUE[0]', 'VALUE[1]'), value, 'tempI64');
 }
 
 // Takes an i64 value and changes it into the [low, high] form used in i64 mode 1. In that
@@ -1600,17 +1591,43 @@ function processMathop(item) {
       case 'xor': {
         return '[' + ident1 + '[0] ^ ' + ident2 + '[0], ' + ident1 + '[1] ^ ' + ident2 + '[1]]';
       }
-      case 'shl': {
-        return '[' + ident1 + '[0] << ' + ident2 + ', ' +
-                 '('+ident1 + '[1] << ' + ident2 + ') | ((' + ident1 + '[0]&((Math.pow(2, ' + ident2 + ')-1)<<(32-' + ident2 + '))) >>> (32-' + ident2 + '))]';
-      }
-      case 'ashr': {
-        return '[('+ident1 + '[0] >>> ' + ident2 + ') | ((' + ident1 + '[1]&(Math.pow(2, ' + ident2 + ')-1))<<(32-' + ident2 + ')),' +
-                    ident1 + '[1] >>> ' + ident2 + ']';
-      }
+      case 'shl':
+      case 'ashr':
       case 'lshr': {
-        return '[('+ident1 + '[0] >>> ' + ident2 + ') | ((' + ident1 + '[1]&(Math.pow(2, ' + ident2 + ')-1))<<(32-' + ident2 + ')),' +
-                    ident1 + '[1] >>> ' + ident2 + ']';
+        assert(isNumber(ident2));
+        bits = parseInt(ident2);
+        var ander = Math.pow(2, bits)-1;
+        if (bits < 32) {
+          switch (op) {
+            case 'shl':
+              return '[' + ident1 + '[0] << ' + ident2 + ', ' +
+                       '('+ident1 + '[1] << ' + ident2 + ') | ((' + ident1 + '[0]&(' + ander + '<<' + (32 - bits) + ')) >>> (32-' + ident2 + '))]';
+            case 'ashr':
+              return '[((('+ident1 + '[0] >>> ' + ident2 + ') | ((' + ident1 + '[1]&' + ander + ')<<' + (32 - bits) + ')) >> 0) >>> 0,' +
+                          '(' + ident1 + '[1] >> ' + ident2 + ') >>> 0]';
+            case 'lshr':
+              return '[(('+ident1 + '[0] >>> ' + ident2 + ') | ((' + ident1 + '[1]&' + ander + ')<<' + (32 - bits) + ')) >>> 0,' +
+                          ident1 + '[1] >>> ' + ident2 + ']';
+          }
+        } else if (bits == 32) {
+          switch (op) {
+            case 'shl':
+              return '[0, ' + ident1 + '[0]]';
+            case 'ashr':
+              return '[' + ident1 + '[1], (' + ident1 + '[1]|0) < 0 ? ' + ander + ' : 0]';
+            case 'lshr':
+              return '[' + ident1 + '[1], 0]';
+          }
+        } else { // bits > 32
+          switch (op) {
+            case 'shl':
+              return '[0, ' + ident1 + '[0] << ' + (bits - 32) + ']';
+            case 'ashr':
+              return '[(' + ident1 + '[1] >> ' + (bits - 32) + ') >>> 0, (' + ident1 + '[1]|0) < 0 ? ' + ander + ' : 0]';
+            case 'lshr':
+              return '[' + ident1 + '[1] >>> ' + (bits - 32) + ', 0]';
+          }
+        }
       }
       case 'uitofp': case 'sitofp': return ident1 + '[0] + ' + ident1 + '[1]*4294967296';
       case 'fptoui': case 'fptosi': return splitI64(ident1);
diff --git a/src/runtime.js b/src/runtime.js
index 6439d0ed..495e72dd 100644
--- a/src/runtime.js
+++ b/src/runtime.js
@@ -73,6 +73,15 @@ var RuntimeGenerator = {
       quantum = '(quantum ? quantum : {{{ QUANTUM_SIZE }}})';
     }
     return target + ' = ' + Runtime.forceAlign(target, quantum);
+  },
+
+  // Given two 32-bit unsigned parts of an emulated 64-bit number, combine them into a JS number (double).
+  // Rounding is inevitable if the number is large. This is a particular problem for small negative numbers
+  // (-1 will be rounded!), so handle negatives separately and carefully
+  makeBigInt: function(low, high, unsigned) {
+    return '((' + unsigned + ' || (' + makeSignOp(high, 'i32', 're', 1, 1) + ' >= 0))' +
+           ' ? (' + makeSignOp(low, 'i32', 'un', 1, 1) + '+(' + makeSignOp(high, 'i32', 'un', 1, 1) + '*4294967296))' +
+           ' : (' + makeSignOp(low, 'i32', 're', 1, 1) + '+(1+' + makeSignOp(high, 'i32', 're', 1, 1) + ')*4294967296))';
   }
 };
 
@@ -260,6 +269,7 @@ var Runtime = {
 Runtime.stackAlloc = unInline('stackAlloc', ['size']);
 Runtime.staticAlloc = unInline('staticAlloc', ['size']);
 Runtime.alignMemory = unInline('alignMemory', ['size', 'quantum']);
+Runtime.makeBigInt = unInline('makeBigInt', ['low', 'high', 'unsigned']);
 
 function getRuntime() {
   var ret = 'var Runtime = {\n';
diff --git a/tests/runner.py b/tests/runner.py
index a09edd97..96142aa4 100755
--- a/tests/runner.py
+++ b/tests/runner.py
@@ -420,6 +420,17 @@ if 'benchmark' not in str(sys.argv) and 'sanity' not in str(sys.argv):
             #include <stdio.h>
             int main()
             {
+              long long a = 0x2b00505c10;
+              long long b = a >> 29;
+              long long c = a >> 32;
+              long long d = a >> 34;
+              printf("*%Ld,%Ld,%Ld,%Ld*\\n", a, b, c, d);
+              unsigned long long ua = 0x2b00505c10;
+              unsigned long long ub = ua >> 29;
+              unsigned long long uc = ua >> 32;
+              unsigned long long ud = ua >> 34;
+              printf("*%Ld,%Ld,%Ld,%Ld*\\n", ua, ub, uc, ud);
+
               long long x = 0x0000def123450789ULL; // any bigger than this, and we
               long long y = 0x00020ef123456089ULL; // start to run into the double precision limit!
               printf("*%Ld,%Ld,%Ld,%Ld,%Ld*\\n", x, y, x | y, x & y, x ^ y, x >> 2, y << 2);
@@ -436,7 +447,7 @@ if 'benchmark' not in str(sys.argv) and 'sanity' not in str(sys.argv):
               return 0;
             }
           '''
-          self.do_run(src, '*245127260211081,579378795077769,808077213656969,16428841631881,791648372025088*\n*13.00,6.00,3.00,*3*')
+          self.do_run(src, '*184688860176,344,43,10*\n*184688860176,344,43,10*\n*245127260211081,579378795077769,808077213656969,16428841631881,791648372025088*\n*13.00,6.00,3.00,*3*')
 
         if Settings.QUANTUM_SIZE == 1: return self.skip('TODO: i64 mode 1 for q1')
 
@@ -505,12 +516,26 @@ if 'benchmark' not in str(sys.argv) and 'sanity' not in str(sys.argv):
             // global structs with i64s
             printf("*%d,%Ld*\n*%d,%Ld*\n", iub[0].c, iub[0].d, iub[1].c, iub[1].d);
 
+            // Bitshifts
+            {
+              int64_t a = -1;
+              int64_t b = a >> 29;
+              int64_t c = a >> 32;
+              int64_t d = a >> 34;
+              printf("*%Ld,%Ld,%Ld,%Ld*\n", a, b, c, d);
+              uint64_t ua = -1;
+              int64_t ub = ua >> 29;
+              int64_t uc = ua >> 32;
+              int64_t ud = ua >> 34;
+              printf("*%Ld,%Ld,%Ld,%Ld*\n", ua, ub, uc, ud);
+            }
+
             // Math mixtures with doubles
             {
               uint64_t a = 5;
               double b = 6.8;
               uint64_t c = a * b;
-              printf("*prod:%llu*\n*%d,%d,%d*", c, (int)&a, (int)&b, (int)&c); // printing addresses prevents optimizations
+              printf("*prod:%llu*\n*%d,%d,%d*\n", c, (int)&a, (int)&b, (int)&c); // printing addresses prevents optimizations
             }
 
             // Basic (rounded, for now) math. Just check compilation.
@@ -523,11 +548,21 @@ if 'benchmark' not in str(sys.argv) and 'sanity' not in str(sys.argv):
             return 0;
           }
         '''
-        self.do_run(src, '*1311918518731868200\n0,0,0,1,1\n1,0,1,0,1*\n*245127260211081*\n*245127260209443*\n' +
-                         '*18446744073709552000*\n*576460752303423500*\n' +
-                         'm1: 127\n*123*\n*127*\n' +
-                         '*55,17179869201*\n*122,25769803837*\n' +
-                         '*prod:34*\n')
+        self.do_run(src, '*1311918518731868200\n' +
+                         '0,0,0,1,1\n' +
+                         '1,0,1,0,1*\n' +
+                         '*245127260211081*\n' +
+                         '*245127260209443*\n' +
+                         '*18446744073709552000*\n' +
+                         '*576460752303423500*\n' +
+                         'm1: 127\n' +
+                         '*123*\n' +
+                         '*127*\n' +
+                         '*55,17179869201*\n' +
+                         '*122,25769803837*\n' +
+                         '*-1,-1,-1,-1*\n' +
+                         '*-1,34359738367,4294967295,1073741823*\n' +
+                         '*prod:34*')
 
         Settings.CORRECT_SIGNS = 1