Merge branch 'incoming'

1 files changed, 123 insertions, 0 deletions

diff --git a/tests/runner.py b/tests/runner.py
index cef14e95..1480afe7 100755
--- a/tests/runner.py
+++ b/tests/runner.py
@@ -1083,6 +1083,32 @@ m_divisor is 1091269979
       '''
       self.do_run(src, '<=0')
 
+    def test_i64_qdouble(self):
+      if Settings.USE_TYPED_ARRAYS != 2: return self.skip('full i64 stuff only in ta2')
+
+      src = r'''
+        #include <stdio.h>
+        typedef long long qint64; /* 64 bit signed */
+        typedef double qreal;
+
+
+        int main(int argc, char **argv)
+        {
+          qreal c = 111;
+          qint64 d = -111 + (argc - 1);
+          c += d;
+          if (c < -1 || c > 1)
+          {
+                  printf("Failed!\n");
+          }
+          else
+          {
+                  printf("Succeeded!\n");
+          }
+        };
+      '''
+      self.do_run(src, 'Succeeded!')
+
     def test_i32_mul_precise(self):
       if self.emcc_args == None: return self.skip('needs ta2')
 
@@ -5779,6 +5805,39 @@ int main(int argc, char **argv) {
         ]:
           self.do_run(src.replace('{{{ NEW }}}', new).replace('{{{ DELETE }}}', delete), '*1,0*')
 
+    def test_dlmalloc_partial(self):
+      if self.emcc_args is None: return self.skip('only emcc will link in dlmalloc')
+      # present part of the symbols of dlmalloc, not all
+      src = open(path_from_root('tests', 'new.cpp')).read().replace('{{{ NEW }}}', 'new int').replace('{{{ DELETE }}}', 'delete') + '''    
+void *
+operator new(size_t size)
+{
+  printf("new %d!\\n", size);
+  return malloc(size);
+}
+'''
+      self.do_run(src, 'new 4!\n*1,0*')
+
+    def test_dlmalloc_partial_2(self):
+      if self.emcc_args is None or 'SAFE_HEAP' in str(self.emcc_args): return self.skip('only emcc will link in dlmalloc, and we do unsafe stuff')
+      # present part of the symbols of dlmalloc, not all. malloc is harder to link than new which is weak.
+      src = r'''
+        #include <stdio.h>
+        #include <stdlib.h>
+        void *malloc(size_t size)
+        {
+          return (void*)123;
+        }
+        int main() {
+          void *x = malloc(10);
+          printf("got %p\n", x);
+          free(x);
+          printf("freed the faker\n");
+          return 1;
+        }
+'''
+      self.do_run(src, 'got 0x7b\nfreed')
+
     def test_libcxx(self):
       self.do_run(open(path_from_root('tests', 'hashtest.cpp')).read(),
                    'june -> 30\nPrevious (in alphabetical order) is july\nNext (in alphabetical order) is march')
@@ -7850,6 +7909,70 @@ f.close()
       self.assertContained('hello from lib', run_js(os.path.join(self.get_dir(), 'a.out.js')))
       assert not os.path.exists('a.out') and not os.path.exists('a.exe'), 'Must not leave unneeded linker stubs'
 
+    def test_multiply_defined_libsymbols(self):
+      lib = "int mult() { return 1; }"
+      lib_name = os.path.join(self.get_dir(), 'libA.c')
+      open(lib_name, 'w').write(lib)
+      a2 = "void x() {}"
+      a2_name = os.path.join(self.get_dir(), 'a2.c')
+      open(a2_name, 'w').write(a2)
+      b2 = "void y() {}"
+      b2_name = os.path.join(self.get_dir(), 'b2.c')
+      open(b2_name, 'w').write(b2)
+      main = r'''
+        #include <stdio.h>
+        int mult();
+        int main() {
+          printf("result: %d\n", mult());
+          return 0;
+        }
+      '''
+      main_name = os.path.join(self.get_dir(), 'main.c')
+      open(main_name, 'w').write(main)
+
+      Building.emcc(lib_name, output_filename='libA.so')
+
+      Building.emcc(a2_name, ['-L.', '-lA'])
+      Building.emcc(b2_name, ['-L.', '-lA'])
+
+      Building.emcc(main_name, ['-L.', '-lA', a2_name+'.o', b2_name+'.o'], output_filename='a.out.js')
+
+      self.assertContained('result: 1', run_js(os.path.join(self.get_dir(), 'a.out.js')))
+
+    def test_multiply_defined_libsymbols_2(self):
+      a = "int x() { return 55; }"
+      a_name = os.path.join(self.get_dir(), 'a.c')
+      open(a_name, 'w').write(a)
+      b = "int y() { return 2; }"
+      b_name = os.path.join(self.get_dir(), 'b.c')
+      open(b_name, 'w').write(b)
+      c = "int z() { return 5; }"
+      c_name = os.path.join(self.get_dir(), 'c.c')
+      open(c_name, 'w').write(c)
+      main = r'''
+        #include <stdio.h>
+        int x();
+        int y();
+        int z();
+        int main() {
+          printf("result: %d\n", x() + y() + z());
+          return 0;
+        }
+      '''
+      main_name = os.path.join(self.get_dir(), 'main.c')
+      open(main_name, 'w').write(main)
+
+      Building.emcc(a_name) # a.c.o
+      Building.emcc(b_name) # b.c.o
+      Building.emcc(c_name) # c.c.o
+      lib_name = os.path.join(self.get_dir(), 'libLIB.a')
+      Building.emar('cr', lib_name, [a_name + '.o', b_name + '.o']) # libLIB.a with a and b
+
+      # a is in the lib AND in an .o, so should be ignored in the lib. We do still need b from the lib though
+      Building.emcc(main_name, ['-L.', '-lLIB', a_name+'.o', c_name + '.o'], output_filename='a.out.js')
+
+      self.assertContained('result: 62', run_js(os.path.join(self.get_dir(), 'a.out.js')))
+
     def test_abspaths(self):
       # Includes with absolute paths are generally dangerous, things like -I/usr/.. will get to system local headers, not our portable ones.