prevent stack from being exhausted due to allocas and byval arguments

4 files changed, 77 insertions, 7 deletions

diff --git a/src/analyzer.js b/src/analyzer.js
index 4ff5d2d9..7d99ab69 100644
--- a/src/analyzer.js
+++ b/src/analyzer.js
@@ -785,6 +785,26 @@ function analyzer(data, sidePass) {
           delete item.allocatedSize;
         }
         func.initialStack = index;
+        // We need to note if stack allocations other than initial allocs can happen here
+        // (for example, via alloca). If so, we need to rewind the stack when we leave.
+        func.otherStackAllocations = false;
+        var finishedInitial = false;
+        for (var i = 0; i < lines.length; i++) {
+          var item = lines[i].value;
+          if (!item || item.intertype != 'alloca') {
+            finishedInitial = true;
+            continue;
+          }
+          if (item.intertype == 'alloca' && finishedInitial) {
+            func.otherStackAllocations = true;
+          }
+        }
+        // by-value params are also causes of additional allocas (although we could in theory make them normal allocas too)
+        func.params.forEach(function(param) {
+          if (param.byVal) {
+            func.otherStackAllocations = true;
+          }
+        });
       });
       this.forwardItem(data, 'Relooper');
     }
diff --git a/src/jsifier.js b/src/jsifier.js
index a750f805..8a75e49f 100644
--- a/src/jsifier.js
+++ b/src/jsifier.js
@@ -505,7 +505,8 @@ function JSify(data, functionsOnly, givenFunctions) {
                 +    '}\n';
       }
 
-      func.JS += '  ' + RuntimeGenerator.stackEnter(func.initialStack) + ';\n';
+      // Prepare the stack, if we need one. If we have other stack allocations, force the stack to be set up.
+      func.JS += '  ' + RuntimeGenerator.stackEnter(func.initialStack, func.otherStackAllocations) + ';\n';
 
       // Make copies of by-value params
       // XXX It is not clear we actually need this. While without this we fail, it does look like
@@ -907,7 +908,7 @@ function JSify(data, functionsOnly, givenFunctions) {
     return ret;
   });
   makeFuncLineActor('return', function(item) {
-    var ret = RuntimeGenerator.stackExit(item.funcData.initialStack) + ';\n';
+    var ret = RuntimeGenerator.stackExit(item.funcData.initialStack, item.funcData.otherStackAllocations) + ';\n';
     if (PROFILE) {
       ret += 'if (PROFILING) { '
           +    'PROFILING_NODE.time += Date.now() - __profilingStartTime__; '
diff --git a/src/runtime.js b/src/runtime.js
index 76b01089..605de749 100644
--- a/src/runtime.js
+++ b/src/runtime.js
@@ -29,8 +29,8 @@ var RuntimeGenerator = {
     return ret;
   },
 
-  stackEnter: function(initial) {
-    if (initial === 0 && SKIP_STACK_IN_SMALL) return '';
+  stackEnter: function(initial, force) {
+    if (initial === 0 && SKIP_STACK_IN_SMALL && !force) return '';
     if (USE_TYPED_ARRAYS === 2) initial = Runtime.forceAlign(initial);
     var ret = 'var __stackBase__  = STACKTOP; STACKTOP += ' + initial;
     if (ASSERTIONS) {
@@ -42,8 +42,8 @@ var RuntimeGenerator = {
     return ret;
   },
 
-  stackExit: function(initial) {
-    if (initial === 0 && SKIP_STACK_IN_SMALL) return '';
+  stackExit: function(initial, force) {
+    if (initial === 0 && SKIP_STACK_IN_SMALL && !force) return '';
     var ret = '';
     if (SAFE_HEAP) {
       ret += 'for (var i = __stackBase__; i < STACKTOP; i++) SAFE_HEAP_CLEAR(i);';
diff --git a/tests/runner.py b/tests/runner.py
index 58e82c6b..336d9d9d 100644
--- a/tests/runner.py
+++ b/tests/runner.py
@@ -1409,6 +1409,56 @@ if 'benchmark' not in str(sys.argv) and 'sanity' not in str(sys.argv):
       '''
       self.do_run(src, 'z:1*', force_c=True)
 
+      if self.emcc_args is not None: # too slow in other modes
+        # We should not blow up the stack with numerous allocas
+
+        src = '''
+          #include <stdio.h>
+          #include <stdlib.h>
+
+          func(int i) {
+            char *pc = (char *)alloca(100);
+            *pc = i;
+            (*pc)++;
+            return (*pc) % 10;
+          }
+          int main() {
+            int total = 0;
+            for (int i = 0; i < 1024*1024; i++)
+              total += func(i);
+            printf("ok:%d*\\n", total);
+            return 0;
+          }
+        '''
+        self.do_run(src, 'ok:-32768*', force_c=True)
+
+        # We should also not blow up the stack with byval arguments
+        src = r'''
+          #include<stdio.h>
+          struct vec {
+            int x, y, z;
+            vec(int x_, int y_, int z_) : x(x_), y(y_), z(z_) {}
+            static vec add(vec a, vec b) {
+              return vec(a.x+b.x, a.y+b.y, a.z+b.z);
+            }
+          };
+          int main() {
+            int total = 0;
+            for (int i = 0; i < 1000; i++) {
+              for (int j = 0; j < 1000; j++) {
+                vec c(i+i%10, j*2, i%255);
+                vec d(j*2, j%255, i%120);
+                vec f = vec::add(c, d);
+                total += (f.x + f.y + f.z) % 100;
+                total %= 10240;
+              }
+            }
+            printf("sum:%d*\n", total);
+            return 1;
+          }
+        '''
+        self.do_run(src, 'sum:9780*')
+
     def test_array2(self):
         src = '''
           #include <stdio.h>
@@ -5558,7 +5608,6 @@ elif 'benchmark' in str(sys.argv):
       self.do_benchmark(src, [], 'lastprime: 1297001.')
 
     def test_memops(self):
-      # memcpy would also be interesting, however native code uses SSE/NEON/etc. and is much, much faster than JS can be
       src = '''
         #include<stdio.h>
         #include<string.h>