1 files changed, 122 insertions, 1 deletions

diff --git a/tests/runner.py b/tests/runner.py
index 07d55650..5c2f5e13 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>
@@ -3804,6 +3854,35 @@ def process(filename):
           return 1;
         }
         ''', 'hello world', includes=[path_from_root('tests', 'libcxx', 'include')]);
+        
+    def test_static_variable(self):
+      src = '''
+        #include <stdio.h>
+
+        struct DATA
+        {
+            int value;
+    
+            DATA()
+            {
+                value = 0;
+            }
+        };
+
+        DATA & GetData()
+        {
+            static DATA data;
+    
+            return data;
+        }
+
+        int main()
+        {
+            GetData().value = 10;
+            printf( "value:%i", GetData().value );
+        }
+      '''
+      self.do_run(src, 'value:10')
 
     def test_cubescript(self):
       if self.emcc_args is not None and '-O2' in self.emcc_args:
@@ -5529,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>
@@ -5552,6 +5630,49 @@ elif 'benchmark' in str(sys.argv):
       '''
       self.do_benchmark(src, [], 'final: 720.')
 
+    def zzztest_copy(self):
+      src = r'''
+        #include<stdio.h>
+        struct vec {
+          int x, y, z;
+          int r, g, b;
+          vec(int x_, int y_, int z_, int r_, int g_, int b_) : x(x_), y(y_), z(z_), r(r_), g(g_), b(b_) {}
+          static vec add(vec a, vec b) {
+            return vec(a.x+b.x, a.y+b.y, a.z+b.z, a.r+b.r, a.g+b.g, a.b+b.b);
+          }
+          void norm() {
+            x %= 1024;
+            y %= 1024;
+            z %= 1024;
+            r %= 1024;
+            b %= 1024;
+            g %= 1024;
+          }
+          int sum() { return x + y + z + r + g + b; }
+        };
+        int main() {
+          int total = 0;
+          for (int i = 0; i < 2500; i++) {
+            for (int j = 0; j < 1000; j++) {
+              vec c(i, i+i%10, j*2, i%255, j%120, i%15);
+              vec d(j+i%10, j*2, j%255, i%120, j%15, j);
+              vec e = c;
+              c.norm();
+              d.norm();
+              vec f = vec::add(c, d);
+              f = vec::add(e, f);
+              f.norm();
+              f = vec::add(d, f);
+              total += f.sum() % 100;
+              total %= 10240;
+            }
+          }
+          printf("sum:%d\n", total);
+          return 1;
+        }      
+      '''
+      self.do_benchmark(src, [], 'sum:3588\n', emcc_args=['-s', 'QUANTUM_SIZE=4', '-s', 'USE_TYPED_ARRAYS=2'])
+
     def test_fannkuch(self):
       src = open(path_from_root('tests', 'fannkuch.cpp'), 'r').read()
       self.do_benchmark(src, ['10'], 'Pfannkuchen(10) = 38.')