merge incoming

5 files changed, 176 insertions, 5 deletions

diff --git a/src/intertyper.js b/src/intertyper.js
index f63e0982..2de6c6b9 100644
--- a/src/intertyper.js
+++ b/src/intertyper.js
@@ -926,6 +926,7 @@ function intertyper(data, sidePass, baseLineNums) {
     processItem: function(item) {
       return [{
         intertype: 'resume',
+        ident: toNiceIdent(item.tokens[2].text),
         lineNum: item.lineNum
       }];
     }
diff --git a/src/jsifier.js b/src/jsifier.js
index a6a3fb28..0e8b825a 100644
--- a/src/jsifier.js
+++ b/src/jsifier.js
@@ -664,7 +664,7 @@ function JSify(data, functionsOnly, givenFunctions) {
             } // otherwise, should have been set before!
             if (func.setjmpTable) {
               var setjmpTable = {};
-              ret += indent + 'var setjmped = false;'; // set to true if we setjmp in this invocation
+              ret += indent + 'var mySetjmpIds = {};\n';
               ret += indent + 'var setjmpTable = {';
               func.setjmpTable.forEach(function(triple) { // original label, label we created for right after the setjmp, variable setjmp result goes into
                 ret += '"' + getLabelId(triple[0]) + '": ' + 'function(value) { label = ' + getLabelId(triple[1]) + '; ' + triple[2] + ' = value },';
@@ -683,7 +683,7 @@ function JSify(data, functionsOnly, givenFunctions) {
             }).join('\n');
             ret += '\n' + indent + '  default: assert(0, "bad label: " + label);\n' + indent + '}';
             if (func.setjmpTable) {
-              ret += ' } catch(e) { if (!setjmped) throw(e); if (!e.longjmp) throw(e); setjmpTable[e.label](e.value) }';
+              ret += ' } catch(e) { if (!e.longjmp || !(e.id in mySetjmpIds)) throw(e); setjmpTable[setjmpLabels[e.id]](e.value) }';
             }
           } else {
             ret += (SHOW_LABELS ? indent + '/* ' + block.entries[0] + ' */' : '') + '\n' + getLabelLines(block.labels[0], indent);
@@ -1081,8 +1081,10 @@ function JSify(data, functionsOnly, givenFunctions) {
     return ret + ';';
   });
   makeFuncLineActor('resume', function(item) {
+    // If there is no current exception, set this one as it (during a resume, the current exception can be wiped out)
     return (EXCEPTION_DEBUG ? 'Module.print("Resuming exception");' : '') + 
-    	'throw ' + makeGetValue('_llvm_eh_exception.buf', '0', 'void*') + ';';
+      'if (' + makeGetValue('_llvm_eh_exception.buf', 0, 'void*') + ' == 0) { ' + makeSetValue('_llvm_eh_exception.buf', 0, item.ident + '.f0', 'void*') + ' } ' + 
+      'throw ' + item.ident + '.f0;';
   });
   makeFuncLineActor('invoke', function(item) {
     // Wrapping in a function lets us easily return values if we are
diff --git a/src/library.js b/src/library.js
index f23e87f7..5834797f 100644
--- a/src/library.js
+++ b/src/library.js
@@ -5922,11 +5922,11 @@ LibraryManager.library = {
 
   setjmp__inline: function(env) {
     // Save the label
-    return '(setjmped = true, ' + makeSetValue(env, '0', 'label', 'i32') + ', 0)';
+    return '(tempInt = setjmpId++, mySetjmpIds[tempInt] = 1, setjmpLabels[tempInt] = label,' + makeSetValue(env, '0', 'tempInt', 'i32') + ', 0)';
   },
 
   longjmp: function(env, value) {
-    throw { longjmp: true, label: {{{ makeGetValue('env', '0', 'i32') }}}, value: value || 1 };
+    throw { longjmp: true, id: {{{ makeGetValue('env', '0', 'i32') }}}, value: value || 1 };
   },
 
   // ==========================================================================
diff --git a/src/preamble.js b/src/preamble.js
index ae264a90..b28dfc0d 100644
--- a/src/preamble.js
+++ b/src/preamble.js
@@ -276,6 +276,8 @@ Module['printProfiling'] = printProfiling;
 //========================================
 
 var __THREW__ = 0; // Used in checking for thrown exceptions.
+var setjmpId = 1; // Used in setjmp/longjmp
+var setjmpLabels = {};
 
 var ABORT = false;
 
diff --git a/tests/runner.py b/tests/runner.py
index 8bf71758..a231cb5c 100755
--- a/tests/runner.py
+++ b/tests/runner.py
@@ -2087,6 +2087,109 @@ Setjmp error execution path, level: 0
 Exiting stack_manipulate_func, level: 0
 ''')
 
+    def test_longjmp3(self):
+      src = r'''
+        #include <setjmp.h>
+        #include <stdio.h>
+
+        typedef struct {
+          jmp_buf* jmp;
+        } jmp_state;
+
+        void setjmp_func(jmp_state* s, int level) {
+          jmp_buf* prev_jmp = s->jmp;
+          jmp_buf c_jmp;
+
+          if (level == 2) {
+            printf("level is 2, perform longjmp!\n");
+            longjmp(*(s->jmp), 1);
+          }
+
+          if (setjmp(c_jmp) == 0) {
+            printf("setjmp normal execution path, level: %d\n", level);
+            s->jmp = &c_jmp;
+            setjmp_func(s, level + 1);
+          } else {
+            printf("setjmp exception execution path, level: %d\n", level);
+            if (prev_jmp) {
+              printf("prev_jmp is not empty, continue with longjmp!\n");
+              s->jmp = prev_jmp;
+              longjmp(*(s->jmp), 1);
+            }
+          }
+
+          printf("Exiting setjmp function, level: %d\n", level);
+        }
+
+        int main(int argc, char *argv[]) {
+          jmp_state s;
+          s.jmp = NULL;
+
+          setjmp_func(&s, 0);
+
+          return 0;
+        }
+        '''
+      self.do_run(src, '''setjmp normal execution path, level: 0
+setjmp normal execution path, level: 1
+level is 2, perform longjmp!
+setjmp exception execution path, level: 1
+prev_jmp is not empty, continue with longjmp!
+setjmp exception execution path, level: 0
+Exiting setjmp function, level: 0
+''')
+
+    def test_longjmp4(self):
+      src = r'''
+        #include <setjmp.h>
+        #include <stdio.h>
+
+        typedef struct {
+          jmp_buf* jmp;
+        } jmp_state;
+
+        void second_func(jmp_state* s);
+
+        void first_func(jmp_state* s) {
+          jmp_buf* prev_jmp = s->jmp;
+          jmp_buf c_jmp;
+          volatile int once = 0;
+
+          if (setjmp(c_jmp) == 0) {
+            printf("Normal execution path of first function!\n");
+
+            s->jmp = &c_jmp;
+            second_func(s);
+          } else {
+            printf("Exception execution path of first function! %d\n", once);
+
+            if (!once) {
+              printf("Calling longjmp the second time!\n");
+              once = 1;
+              longjmp(*(s->jmp), 1);
+            }
+          }
+        }
+
+        void second_func(jmp_state* s) {
+          longjmp(*(s->jmp), 1);
+        }
+
+        int main(int argc, char *argv[]) {
+          jmp_state s;
+          s.jmp = NULL;
+
+          first_func(&s);
+
+          return 0;
+        }
+        '''
+      self.do_run(src, '''Normal execution path of first function!
+Exception execution path of first function! 0
+Calling longjmp the second time!
+Exception execution path of first function! 1
+''')
+
     def test_exceptions(self):
         if Settings.QUANTUM_SIZE == 1: return self.skip("we don't support libcxx in q1")
 
@@ -2226,6 +2329,69 @@ Exiting stack_manipulate_func, level: 0
         expected = open(path_from_root('tests', 'exceptions', 'output.txt'), 'r').read()
         self.do_run(src, expected)
 
+    def test_multiexception(self):
+      Settings.DISABLE_EXCEPTION_CATCHING = 0
+      Settings.EXCEPTION_DEBUG = 0  # Messes up expected output.
+      src = r'''
+#include <stdio.h>
+
+static int current_exception_id = 0;
+
+typedef struct {
+  int jmp;
+} jmp_state;
+
+void setjmp_func(jmp_state* s, int level) {
+  int prev_jmp = s->jmp;
+  int c_jmp;
+
+  if (level == 2) {
+    printf("level is 2, perform longjmp!\n");
+    throw 1;
+  }
+
+  c_jmp = current_exception_id++;
+  try {
+    printf("setjmp normal execution path, level: %d, prev_jmp: %d\n", level, prev_jmp);
+    s->jmp = c_jmp;
+    setjmp_func(s, level + 1);
+  } catch (int catched_eid) {
+    printf("caught %d\n", catched_eid);
+    if (catched_eid == c_jmp) {
+      printf("setjmp exception execution path, level: %d, prev_jmp: %d\n", level, prev_jmp);
+      if (prev_jmp != -1) {
+        printf("prev_jmp is not empty, continue with longjmp!\n");
+        s->jmp = prev_jmp;
+        throw s->jmp;
+      }
+    } else {
+      throw;
+    }
+  }
+
+  printf("Exiting setjmp function, level: %d, prev_jmp: %d\n", level, prev_jmp);
+}
+
+int main(int argc, char *argv[]) {
+  jmp_state s;
+  s.jmp = -1;
+
+  setjmp_func(&s, 0);
+
+  return 0;
+}
+'''
+      self.do_run(src, '''setjmp normal execution path, level: 0, prev_jmp: -1
+setjmp normal execution path, level: 1, prev_jmp: 0
+level is 2, perform longjmp!
+caught 1
+setjmp exception execution path, level: 1, prev_jmp: 0
+prev_jmp is not empty, continue with longjmp!
+caught 0
+setjmp exception execution path, level: 0, prev_jmp: -1
+Exiting setjmp function, level: 0, prev_jmp: -1
+''')
+
     def test_class(self):
         src = '''
           #include <stdio.h>