Enable some try catch analysis on analyzegc + fix found issues + fix static analyser on macos

gbaraldi · gbaraldi · commit 0903278753ab · 2024-02-29T12:14:43.000-03:00
diff --git a/Make.inc b/Make.inc
@@ -1487,7 +1487,7 @@ endif
 CLANGSA_FLAGS :=
 CLANGSA_CXXFLAGS :=
 ifeq ($(OS), Darwin) # on new XCode, the files are hidden
-CLANGSA_FLAGS += -isysroot $(shell xcode-select -p)/Platforms/MacOSX.platform/Developer/SDKs/MacOSX.sdk
+CLANGSA_FLAGS += -isysroot $(shell xcrun --show-sdk-path -sdk macosx)
 endif
 ifeq ($(USEGCC),1)
 # try to help clang find the c++ files for CC by guessing the value for --prefix
diff --git a/src/ast.c b/src/ast.c
@@ -1120,7 +1120,7 @@ static jl_value_t *jl_invoke_julia_macro(jl_array_t *args, jl_module_t *inmodule
     ct->world_age = jl_atomic_load_acquire(&jl_world_counter);
     if (ct->world_age > world)
         ct->world_age = world;
-    jl_value_t *result;
+    jl_value_t *result = NULL;
     JL_TRY {
         margs[0] = jl_toplevel_eval(*ctx, margs[0]);
         jl_method_instance_t *mfunc = jl_method_lookup(margs, nargs, ct->world_age);
@@ -1132,6 +1132,7 @@ static jl_value_t *jl_invoke_julia_macro(jl_array_t *args, jl_module_t *inmodule
         jl_timing_show_macro(mfunc, margs[1], inmodule, JL_TIMING_DEFAULT_BLOCK);
         *ctx = mfunc->def.method->module;
         result = jl_invoke(margs[0], &margs[1], nargs - 1, mfunc);
+        margs[2] = result;
     }
     JL_CATCH {
         if ((jl_loaderror_type == NULL) || !throw_load_error) {
diff --git a/src/builtins.c b/src/builtins.c
@@ -845,6 +845,7 @@ JL_CALLABLE(jl_f__apply_pure)
     jl_task_t *ct = jl_current_task;
     int last_in = ct->ptls->in_pure_callback;
     jl_value_t *ret = NULL;
+    JL_GC_PUSH1(&ret);
     JL_TRY {
         ct->ptls->in_pure_callback = 1;
         // because this function was declared pure,
@@ -862,6 +863,7 @@ JL_CALLABLE(jl_f__apply_pure)
         ct->ptls->in_pure_callback = last_in;
         jl_rethrow();
     }
+    JL_GC_POP();
     return ret;
 }
 
@@ -903,6 +905,7 @@ JL_CALLABLE(jl_f__call_in_world_total)
     jl_task_t *ct = jl_current_task;
     int last_in = ct->ptls->in_pure_callback;
     jl_value_t *ret = NULL;
+    JL_GC_PUSH1(&ret);
     size_t last_age = ct->world_age;
     JL_TRY {
         ct->ptls->in_pure_callback = 1;
@@ -918,6 +921,7 @@ JL_CALLABLE(jl_f__call_in_world_total)
         ct->ptls->in_pure_callback = last_in;
         jl_rethrow();
     }
+    JL_GC_POP();
     return ret;
 }
 
@@ -2137,6 +2141,7 @@ JL_CALLABLE(jl_f__typebody)
 {
     JL_NARGS(_typebody!, 1, 2);
     jl_datatype_t *dt = (jl_datatype_t*)jl_unwrap_unionall(args[0]);
+    JL_GC_PUSH1(&dt);
     JL_TYPECHK(_typebody!, datatype, (jl_value_t*)dt);
     if (nargs == 2) {
         jl_value_t *ft = args[1];
@@ -2186,6 +2191,7 @@ JL_CALLABLE(jl_f__typebody)
 
     if (jl_is_structtype(dt))
         jl_compute_field_offsets(dt);
+    JL_GC_POP();
     return jl_nothing;
 }
 
diff --git a/src/codegen.cpp b/src/codegen.cpp
@@ -2843,14 +2843,16 @@ static jl_value_t *static_apply_type(jl_codectx_t &ctx, ArrayRef<jl_cgval_t> arg
     size_t last_age = jl_current_task->world_age;
     // call apply_type, but ignore errors. we know that will work in world 1.
     jl_current_task->world_age = 1;
-    jl_value_t *result;
+    jl_value_t *result = NULL;
+    JL_GC_PUSH1(&result);
     JL_TRY {
         result = jl_apply(v.data(), nargs);
     }
     JL_CATCH {
         result = NULL;
     }
     jl_current_task->world_age = last_age;
+    JL_GC_POP();
     return result;
 }
 
@@ -2932,6 +2934,7 @@ static jl_value_t *static_eval(jl_codectx_t &ctx, jl_value_t *ex)
                     jl_value_t *result;
                     JL_TRY {
                         result = jl_apply(v, n+1);
+                        v[0] = f;
                     }
                     JL_CATCH {
                         result = NULL;
diff --git a/src/gf.c b/src/gf.c
@@ -391,6 +391,7 @@ jl_code_instance_t *jl_type_infer(jl_method_instance_t *mi, size_t world, int fo
     ct->reentrant_timing += 0b10;
     JL_TRY {
         ci = (jl_code_instance_t*)jl_apply(fargs, 4);
+        fargs[2] = (jl_value_t*)ci;
     }
     JL_CATCH {
         jl_value_t *e = jl_current_exception();
diff --git a/src/interpreter.c b/src/interpreter.c
@@ -540,7 +540,7 @@ static jl_value_t *eval_body(jl_array_t *stmts, interpreter_state *s, size_t ip,
                     jl_unreachable();
                 }
             }
-            jl_eh_restore_state(&__eh);
+            jl_eh_restore_state(&__eh, 1);
             if (s->continue_at) { // means we reached a :leave expression
                 ip = s->continue_at;
                 s->continue_at = 0;
diff --git a/src/jlapi.c b/src/jlapi.c
@@ -146,7 +146,8 @@ static void _jl_exception_clear(jl_task_t *ct) JL_NOTSAFEPOINT
  */
 JL_DLLEXPORT jl_value_t *jl_eval_string(const char *str)
 {
-    jl_value_t *r;
+    jl_value_t *r = NULL;
+    JL_GC_PUSH1(&r);
     jl_task_t *ct = jl_current_task;
     JL_TRY {
         const char filename[] = "none";
@@ -161,6 +162,7 @@ JL_DLLEXPORT jl_value_t *jl_eval_string(const char *str)
         ct->ptls->previous_exception = jl_current_exception();
         r = NULL;
     }
+    JL_GC_POP();
     return r;
 }
 
@@ -283,7 +285,8 @@ JL_DLLEXPORT const char *jl_string_ptr(jl_value_t *s)
  */
 JL_DLLEXPORT jl_value_t *jl_call(jl_function_t *f, jl_value_t **args, uint32_t nargs)
 {
-    jl_value_t *v;
+    jl_value_t *v = NULL;
+    JL_GC_PUSH1(&v);
     jl_task_t *ct = jl_current_task;
     nargs++; // add f to args
     JL_TRY {
@@ -303,6 +306,7 @@ JL_DLLEXPORT jl_value_t *jl_call(jl_function_t *f, jl_value_t **args, uint32_t n
         ct->ptls->previous_exception = jl_current_exception();
         v = NULL;
     }
+    JL_GC_POP();
     return v;
 }
 
@@ -316,7 +320,8 @@ JL_DLLEXPORT jl_value_t *jl_call(jl_function_t *f, jl_value_t **args, uint32_t n
  */
 JL_DLLEXPORT jl_value_t *jl_call0(jl_function_t *f)
 {
-    jl_value_t *v;
+    jl_value_t *v = NULL;
+    JL_GC_PUSH1(&v);
     jl_task_t *ct = jl_current_task;
     JL_TRY {
         JL_GC_PUSH1(&f);
@@ -331,6 +336,7 @@ JL_DLLEXPORT jl_value_t *jl_call0(jl_function_t *f)
         ct->ptls->previous_exception = jl_current_exception();
         v = NULL;
     }
+    JL_GC_POP();
     return v;
 }
 
@@ -345,7 +351,8 @@ JL_DLLEXPORT jl_value_t *jl_call0(jl_function_t *f)
  */
 JL_DLLEXPORT jl_value_t *jl_call1(jl_function_t *f, jl_value_t *a)
 {
-    jl_value_t *v;
+    jl_value_t *v = NULL;
+    JL_GC_PUSH1(&v);
     jl_task_t *ct = jl_current_task;
     JL_TRY {
         jl_value_t **argv;
@@ -363,6 +370,7 @@ JL_DLLEXPORT jl_value_t *jl_call1(jl_function_t *f, jl_value_t *a)
         ct->ptls->previous_exception = jl_current_exception();
         v = NULL;
     }
+    JL_GC_POP();
     return v;
 }
 
@@ -378,7 +386,8 @@ JL_DLLEXPORT jl_value_t *jl_call1(jl_function_t *f, jl_value_t *a)
  */
 JL_DLLEXPORT jl_value_t *jl_call2(jl_function_t *f, jl_value_t *a, jl_value_t *b)
 {
-    jl_value_t *v;
+    jl_value_t *v = NULL;
+    JL_GC_PUSH1(&v);
     jl_task_t *ct = jl_current_task;
     JL_TRY {
         jl_value_t **argv;
@@ -397,6 +406,7 @@ JL_DLLEXPORT jl_value_t *jl_call2(jl_function_t *f, jl_value_t *a, jl_value_t *b
         ct->ptls->previous_exception = jl_current_exception();
         v = NULL;
     }
+    JL_GC_POP();
     return v;
 }
 
@@ -414,7 +424,8 @@ JL_DLLEXPORT jl_value_t *jl_call2(jl_function_t *f, jl_value_t *a, jl_value_t *b
 JL_DLLEXPORT jl_value_t *jl_call3(jl_function_t *f, jl_value_t *a,
                                   jl_value_t *b, jl_value_t *c)
 {
-    jl_value_t *v;
+    jl_value_t *v = NULL;
+    JL_GC_PUSH1(&v);
     jl_task_t *ct = jl_current_task;
     JL_TRY {
         jl_value_t **argv;
@@ -434,6 +445,7 @@ JL_DLLEXPORT jl_value_t *jl_call3(jl_function_t *f, jl_value_t *a,
         ct->ptls->previous_exception = jl_current_exception();
         v = NULL;
     }
+    JL_GC_POP();
     return v;
 }
 
@@ -446,7 +458,8 @@ JL_DLLEXPORT jl_value_t *jl_call3(jl_function_t *f, jl_value_t *a,
  */
 JL_DLLEXPORT jl_value_t *jl_get_field(jl_value_t *o, const char *fld)
 {
-    jl_value_t *v;
+    jl_value_t *v = NULL;
+    JL_GC_PUSH1(&v);
     JL_TRY {
         jl_value_t *s = (jl_value_t*)jl_symbol(fld);
         int i = jl_field_index((jl_datatype_t*)jl_typeof(o), (jl_sym_t*)s, 1);
@@ -457,6 +470,7 @@ JL_DLLEXPORT jl_value_t *jl_get_field(jl_value_t *o, const char *fld)
         jl_current_task->ptls->previous_exception = jl_current_exception();
         v = NULL;
     }
+    JL_GC_POP();
     return v;
 }
 
diff --git a/src/jltypes.c b/src/jltypes.c
@@ -2473,6 +2473,7 @@ static jl_value_t *_jl_instantiate_type_in_env(jl_value_t *ty, jl_unionall_t *en
 JL_DLLEXPORT jl_value_t *jl_instantiate_type_in_env(jl_value_t *ty, jl_unionall_t *env, jl_value_t **vals)
 {
     jl_value_t *typ = ty;
+    JL_GC_PUSH1(&typ);
     if (jl_is_unionall(env)) {
         JL_TRY {
             typ = _jl_instantiate_type_in_env(ty, env, vals, NULL, NULL);
@@ -2481,6 +2482,7 @@ JL_DLLEXPORT jl_value_t *jl_instantiate_type_in_env(jl_value_t *ty, jl_unionall_
             typ = jl_bottom_type;
         }
     }
+    JL_GC_POP();
     return typ;
 }
 
diff --git a/src/julia.h b/src/julia.h
@@ -2282,8 +2282,8 @@ extern JL_DLLIMPORT int jl_task_ptls_offset;
 
 #include "julia_locks.h"   // requires jl_task_t definition
 
-JL_DLLEXPORT void jl_enter_handler(jl_handler_t *eh);
-JL_DLLEXPORT void jl_eh_restore_state(jl_handler_t *eh);
+JL_DLLEXPORT void jl_enter_handler(jl_handler_t *eh) JL_NOTSAFEPOINT ;
+JL_DLLEXPORT void jl_eh_restore_state(jl_handler_t *eh, int had_exception);
 JL_DLLEXPORT void jl_pop_handler(int n);
 JL_DLLEXPORT size_t jl_excstack_state(void) JL_NOTSAFEPOINT;
 JL_DLLEXPORT void jl_restore_excstack(size_t state) JL_NOTSAFEPOINT;
@@ -2337,24 +2337,32 @@ extern void (*real_siglongjmp)(jmp_buf _Buf, int _Value);
 
 #ifdef __clang_gcanalyzer__
 
+extern int had_exception;
 // This is hard. Ideally we'd teach the static analyzer about the extra control
 // flow edges. But for now, just hide this as best we can
-extern int had_exception;
-#define JL_TRY if (1)
-#define JL_CATCH if (had_exception)
+#define JL_TRY                                                    \
+    int i__try, i__catch; jl_handler_t __eh;                          \
+    size_t __excstack_state = jl_excstack_state();                \
+    jl_enter_handler(&__eh);                                      \
+    for (i__try=2; i__try; i__try--)                                 \
+        if (i__try==2)                                             \
+
+#define JL_CATCH                                                \
+    else                                                        \
+        for (i__catch=1, jl_eh_restore_state(&__eh, had_exception); i__catch && had_exception; i__catch=0, jl_restore_excstack(__excstack_state))
 
 #else
 
 #define JL_TRY                                                    \
-    int i__tr, i__ca; jl_handler_t __eh;                          \
+    int i__try, i__catch; jl_handler_t __eh;                          \
     size_t __excstack_state = jl_excstack_state();                \
     jl_enter_handler(&__eh);                                      \
     if (!jl_setjmp(__eh.eh_ctx,0))                                \
-        for (i__tr=1; i__tr; i__tr=0, jl_eh_restore_state(&__eh))
+        for (i__try=1; i__try; i__try=0, jl_eh_restore_state(&__eh, 0))
 
 #define JL_CATCH                                                \
     else                                                        \
-        for (i__ca=1, jl_eh_restore_state(&__eh); i__ca; i__ca=0, jl_restore_excstack(__excstack_state))
+        for (i__catch=1, jl_eh_restore_state(&__eh, 1); i__catch; i__catch=0, jl_restore_excstack(__excstack_state))
 
 #endif
 
diff --git a/src/method.c b/src/method.c
@@ -137,6 +137,7 @@ static jl_value_t *resolve_globals(jl_value_t *expr, jl_module_t *module, jl_sve
                 }
                 jl_value_t *rt = jl_exprarg(e, 2);
                 jl_value_t *at = jl_exprarg(e, 3);
+                JL_GC_PUSH2(&at, &rt);
                 if (!jl_is_type(rt)) {
                     JL_TRY {
                         rt = jl_interpret_toplevel_expr_in(module, rt, NULL, sparam_vals);
@@ -164,12 +165,14 @@ static jl_value_t *resolve_globals(jl_value_t *expr, jl_module_t *module, jl_sve
                 check_c_types("cfunction method definition", rt, at);
                 JL_TYPECHK(cfunction method definition, quotenode, jl_exprarg(e, 4));
                 JL_TYPECHK(cfunction method definition, symbol, *(jl_value_t**)jl_exprarg(e, 4));
+                JL_GC_POP();
                 return expr;
             }
             if (e->head == jl_foreigncall_sym) {
                 JL_NARGSV(ccall method definition, 5); // (fptr, rt, at, nreq, (cc, effects))
                 jl_value_t *rt = jl_exprarg(e, 1);
                 jl_value_t *at = jl_exprarg(e, 2);
+                JL_GC_PUSH2(&at, &rt);
                 if (!jl_is_type(rt)) {
                     JL_TRY {
                         rt = jl_interpret_toplevel_expr_in(module, rt, NULL, sparam_vals);
@@ -208,6 +211,7 @@ static jl_value_t *resolve_globals(jl_value_t *expr, jl_module_t *module, jl_sve
                 }
                 jl_exprargset(e, 0, resolve_globals(jl_exprarg(e, 0), module, sparam_vals, binding_effects, 1));
                 i++;
+                JL_GC_POP();
             }
             if (e->head == jl_method_sym || e->head == jl_module_sym) {
                 i++;
@@ -259,11 +263,13 @@ static jl_value_t *resolve_globals(jl_value_t *expr, jl_module_t *module, jl_sve
                         }
                         if (j == nargs) {
                             jl_value_t *val = NULL;
+                            JL_GC_PUSH1(&val);
                             JL_TRY {
                                 val = jl_interpret_toplevel_expr_in(module, (jl_value_t*)e, NULL, sparam_vals);
                             }
                             JL_CATCH {
                             }
+                            JL_GC_POP();
                             if (val)
                                 return val;
                         }
diff --git a/src/rtutils.c b/src/rtutils.c
@@ -260,9 +260,18 @@ JL_DLLEXPORT void jl_enter_handler(jl_handler_t *eh)
 // * We leave a try block through normal control flow
 // * An exception causes a nonlocal jump to the catch block. In this case
 //   there's additional cleanup required, eg pushing the exception stack.
-JL_DLLEXPORT void jl_eh_restore_state(jl_handler_t *eh)
+
+JL_DLLEXPORT void jl_eh_restore_state(jl_handler_t *eh, int had_exception)
 {
+    // It's always correct to pass 1 to had_exception, but it can be unnecessary if we know there was no exception.
     jl_task_t *ct = jl_current_task;
+    if (!had_exception) {
+        ct->eh = eh->prev;
+        ct->gcstack = eh->gcstack;
+        ct->world_age = eh->world_age;
+        ct->ptls->defer_signal = eh->defer_signal;
+        return;
+    }
 #ifdef _OS_WINDOWS_
     if (ct->ptls->needs_resetstkoflw) {
         _resetstkoflw();
@@ -305,7 +314,7 @@ JL_DLLEXPORT void jl_pop_handler(int n)
     jl_handler_t *eh = ct->eh;
     while (--n > 0)
         eh = eh->prev;
-    jl_eh_restore_state(eh);
+    jl_eh_restore_state(eh, 1);
 }
 
 JL_DLLEXPORT size_t jl_excstack_state(void) JL_NOTSAFEPOINT
diff --git a/src/runtime_ccall.cpp b/src/runtime_ccall.cpp
diff --git a/src/signals-mach.c b/src/signals-mach.c
diff --git a/src/subtype.c b/src/subtype.c
diff --git a/src/task.c b/src/task.c
diff --git a/src/toplevel.c b/src/toplevel.c

Original file line number	Diff line number	Diff line change
`@@ -2843,14 +2843,16 @@ static jl_value_t *static_apply_type(jl_codectx_t &ctx, ArrayRef<jl_cgval_t> arg`
`2843`	`2843`	`size_t last_age = jl_current_task->world_age;`
`2844`	`2844`	`// call apply_type, but ignore errors. we know that will work in world 1.`
`2845`	`2845`	`jl_current_task->world_age = 1;`
`2846`		`- jl_value_t *result;`
	`2846`	`+ jl_value_t *result = NULL;`
	`2847`	`+ JL_GC_PUSH1(&result);`
`2847`	`2848`	`JL_TRY {`
`2848`	`2849`	`result = jl_apply(v.data(), nargs);`
`2849`	`2850`	`}`
`2850`	`2851`	`JL_CATCH {`
`2851`	`2852`	`result = NULL;`
`2852`	`2853`	`}`
`2853`	`2854`	`jl_current_task->world_age = last_age;`
	`2855`	`+ JL_GC_POP();`
`2854`	`2856`	`return result;`
`2855`	`2857`	`}`
`2856`	`2858`
`@@ -2932,6 +2934,7 @@ static jl_value_t static_eval(jl_codectx_t &ctx, jl_value_t ex)`
`2932`	`2934`	`jl_value_t *result;`
`2933`	`2935`	`JL_TRY {`
`2934`	`2936`	`result = jl_apply(v, n+1);`
	`2937`	`+ v[0] = f;`
`2935`	`2938`	`}`
`2936`	`2939`	`JL_CATCH {`
`2937`	`2940`	`result = NULL;`
Original file line number	Diff line number	Diff line change
`@@ -391,6 +391,7 @@ jl_code_instance_t jl_type_infer(jl_method_instance_t mi, size_t world, int fo`
`391`	`391`	`ct->reentrant_timing += 0b10;`
`392`	`392`	`JL_TRY {`
`393`	`393`	`ci = (jl_code_instance_t*)jl_apply(fargs, 4);`
	`394`	`+ fargs[2] = (jl_value_t*)ci;`
`394`	`395`	`}`
`395`	`396`	`JL_CATCH {`
`396`	`397`	`jl_value_t *e = jl_current_exception();`
Original file line number	Diff line number	Diff line change
`@@ -540,7 +540,7 @@ static jl_value_t eval_body(jl_array_t stmts, interpreter_state *s, size_t ip,`
`540`	`540`	`jl_unreachable();`
`541`	`541`	`}`
`542`	`542`	`}`
`543`		`- jl_eh_restore_state(&__eh);`
	`543`	`+ jl_eh_restore_state(&__eh, 1);`
`544`	`544`	`if (s->continue_at) { // means we reached a :leave expression`
`545`	`545`	`ip = s->continue_at;`
`546`	`546`	`s->continue_at = 0;`
Original file line number	Diff line number	Diff line change
`@@ -146,7 +146,8 @@ static void _jl_exception_clear(jl_task_t *ct) JL_NOTSAFEPOINT`
`146`	`146`	`*/`
`147`	`147`	`JL_DLLEXPORT jl_value_t jl_eval_string(const char str)`
`148`	`148`	`{`
`149`		`- jl_value_t *r;`
	`149`	`+ jl_value_t *r = NULL;`
	`150`	`+ JL_GC_PUSH1(&r);`
`150`	`151`	`jl_task_t *ct = jl_current_task;`
`151`	`152`	`JL_TRY {`
`152`	`153`	`const char filename[] = "none";`
`@@ -161,6 +162,7 @@ JL_DLLEXPORT jl_value_t jl_eval_string(const char str)`
`161`	`162`	`ct->ptls->previous_exception = jl_current_exception();`
`162`	`163`	`r = NULL;`
`163`	`164`	`}`
	`165`	`+ JL_GC_POP();`
`164`	`166`	`return r;`
`165`	`167`	`}`
`166`	`168`
`@@ -283,7 +285,8 @@ JL_DLLEXPORT const char jl_string_ptr(jl_value_t s)`
`283`	`285`	`*/`
`284`	`286`	`JL_DLLEXPORT jl_value_t jl_call(jl_function_t f, jl_value_t **args, uint32_t nargs)`
`285`	`287`	`{`
`286`		`- jl_value_t *v;`
	`288`	`+ jl_value_t *v = NULL;`
	`289`	`+ JL_GC_PUSH1(&v);`
`287`	`290`	`jl_task_t *ct = jl_current_task;`
`288`	`291`	`nargs++; // add f to args`
`289`	`292`	`JL_TRY {`
`@@ -303,6 +306,7 @@ JL_DLLEXPORT jl_value_t jl_call(jl_function_t f, jl_value_t **args, uint32_t n`
`303`	`306`	`ct->ptls->previous_exception = jl_current_exception();`
`304`	`307`	`v = NULL;`
`305`	`308`	`}`
	`309`	`+ JL_GC_POP();`
`306`	`310`	`return v;`
`307`	`311`	`}`
`308`	`312`
`@@ -316,7 +320,8 @@ JL_DLLEXPORT jl_value_t jl_call(jl_function_t f, jl_value_t **args, uint32_t n`
`316`	`320`	`*/`
`317`	`321`	`JL_DLLEXPORT jl_value_t jl_call0(jl_function_t f)`
`318`	`322`	`{`
`319`		`- jl_value_t *v;`
	`323`	`+ jl_value_t *v = NULL;`
	`324`	`+ JL_GC_PUSH1(&v);`
`320`	`325`	`jl_task_t *ct = jl_current_task;`
`321`	`326`	`JL_TRY {`
`322`	`327`	`JL_GC_PUSH1(&f);`
`@@ -331,6 +336,7 @@ JL_DLLEXPORT jl_value_t jl_call0(jl_function_t f)`
`331`	`336`	`ct->ptls->previous_exception = jl_current_exception();`
`332`	`337`	`v = NULL;`
`333`	`338`	`}`
	`339`	`+ JL_GC_POP();`
`334`	`340`	`return v;`
`335`	`341`	`}`
`336`	`342`
`@@ -345,7 +351,8 @@ JL_DLLEXPORT jl_value_t jl_call0(jl_function_t f)`
`345`	`351`	`*/`
`346`	`352`	`JL_DLLEXPORT jl_value_t jl_call1(jl_function_t f, jl_value_t *a)`
`347`	`353`	`{`
`348`		`- jl_value_t *v;`
	`354`	`+ jl_value_t *v = NULL;`
	`355`	`+ JL_GC_PUSH1(&v);`
`349`	`356`	`jl_task_t *ct = jl_current_task;`
`350`	`357`	`JL_TRY {`
`351`	`358`	`jl_value_t **argv;`
`@@ -363,6 +370,7 @@ JL_DLLEXPORT jl_value_t jl_call1(jl_function_t f, jl_value_t *a)`
`363`	`370`	`ct->ptls->previous_exception = jl_current_exception();`
`364`	`371`	`v = NULL;`
`365`	`372`	`}`
	`373`	`+ JL_GC_POP();`
`366`	`374`	`return v;`
`367`	`375`	`}`
`368`	`376`
`@@ -378,7 +386,8 @@ JL_DLLEXPORT jl_value_t jl_call1(jl_function_t f, jl_value_t *a)`
`378`	`386`	`*/`
`379`	`387`	`JL_DLLEXPORT jl_value_t jl_call2(jl_function_t f, jl_value_t a, jl_value_t b)`
`380`	`388`	`{`
`381`		`- jl_value_t *v;`
	`389`	`+ jl_value_t *v = NULL;`
	`390`	`+ JL_GC_PUSH1(&v);`
`382`	`391`	`jl_task_t *ct = jl_current_task;`
`383`	`392`	`JL_TRY {`
`384`	`393`	`jl_value_t **argv;`
`@@ -397,6 +406,7 @@ JL_DLLEXPORT jl_value_t jl_call2(jl_function_t f, jl_value_t a, jl_value_t b`
`397`	`406`	`ct->ptls->previous_exception = jl_current_exception();`
`398`	`407`	`v = NULL;`
`399`	`408`	`}`
	`409`	`+ JL_GC_POP();`
`400`	`410`	`return v;`
`401`	`411`	`}`
`402`	`412`
`@@ -414,7 +424,8 @@ JL_DLLEXPORT jl_value_t jl_call2(jl_function_t f, jl_value_t a, jl_value_t b`
`414`	`424`	`JL_DLLEXPORT jl_value_t jl_call3(jl_function_t f, jl_value_t *a,`
`415`	`425`	`jl_value_t b, jl_value_t c)`
`416`	`426`	`{`
`417`		`- jl_value_t *v;`
	`427`	`+ jl_value_t *v = NULL;`
	`428`	`+ JL_GC_PUSH1(&v);`
`418`	`429`	`jl_task_t *ct = jl_current_task;`
`419`	`430`	`JL_TRY {`
`420`	`431`	`jl_value_t **argv;`
`@@ -434,6 +445,7 @@ JL_DLLEXPORT jl_value_t jl_call3(jl_function_t f, jl_value_t *a,`
`434`	`445`	`ct->ptls->previous_exception = jl_current_exception();`
`435`	`446`	`v = NULL;`
`436`	`447`	`}`
	`448`	`+ JL_GC_POP();`
`437`	`449`	`return v;`
`438`	`450`	`}`
`439`	`451`
`@@ -446,7 +458,8 @@ JL_DLLEXPORT jl_value_t jl_call3(jl_function_t f, jl_value_t *a,`
`446`	`458`	`*/`
`447`	`459`	`JL_DLLEXPORT jl_value_t jl_get_field(jl_value_t o, const char *fld)`
`448`	`460`	`{`
`449`		`- jl_value_t *v;`
	`461`	`+ jl_value_t *v = NULL;`
	`462`	`+ JL_GC_PUSH1(&v);`
`450`	`463`	`JL_TRY {`
`451`	`464`	`jl_value_t s = (jl_value_t)jl_symbol(fld);`
`452`	`465`	`int i = jl_field_index((jl_datatype_t)jl_typeof(o), (jl_sym_t)s, 1);`
`@@ -457,6 +470,7 @@ JL_DLLEXPORT jl_value_t jl_get_field(jl_value_t o, const char *fld)`
`457`	`470`	`jl_current_task->ptls->previous_exception = jl_current_exception();`
`458`	`471`	`v = NULL;`
`459`	`472`	`}`
	`473`	`+ JL_GC_POP();`
`460`	`474`	`return v;`
`461`	`475`	`}`
`462`	`476`
Original file line number	Diff line number	Diff line change
`@@ -2473,6 +2473,7 @@ static jl_value_t _jl_instantiate_type_in_env(jl_value_t ty, jl_unionall_t *en`
`2473`	`2473`	`JL_DLLEXPORT jl_value_t jl_instantiate_type_in_env(jl_value_t ty, jl_unionall_t env, jl_value_t *vals)`
`2474`	`2474`	`{`
`2475`	`2475`	`jl_value_t *typ = ty;`
	`2476`	`+ JL_GC_PUSH1(&typ);`
`2476`	`2477`	`if (jl_is_unionall(env)) {`
`2477`	`2478`	`JL_TRY {`
`2478`	`2479`	`typ = _jl_instantiate_type_in_env(ty, env, vals, NULL, NULL);`
`@@ -2481,6 +2482,7 @@ JL_DLLEXPORT jl_value_t jl_instantiate_type_in_env(jl_value_t ty, jl_unionall_`
`2481`	`2482`	`typ = jl_bottom_type;`
`2482`	`2483`	`}`
`2483`	`2484`	`}`
	`2485`	`+ JL_GC_POP();`
`2484`	`2486`	`return typ;`
`2485`	`2487`	`}`
`2486`	`2488`
Original file line number	Diff line number	Diff line change
`@@ -137,6 +137,7 @@ static jl_value_t resolve_globals(jl_value_t expr, jl_module_t *module, jl_sve`
`137`	`137`	`}`
`138`	`138`	`jl_value_t *rt = jl_exprarg(e, 2);`
`139`	`139`	`jl_value_t *at = jl_exprarg(e, 3);`
	`140`	`+ JL_GC_PUSH2(&at, &rt);`
`140`	`141`	`if (!jl_is_type(rt)) {`
`141`	`142`	`JL_TRY {`
`142`	`143`	`rt = jl_interpret_toplevel_expr_in(module, rt, NULL, sparam_vals);`
`@@ -164,12 +165,14 @@ static jl_value_t resolve_globals(jl_value_t expr, jl_module_t *module, jl_sve`
`164`	`165`	`check_c_types("cfunction method definition", rt, at);`
`165`	`166`	`JL_TYPECHK(cfunction method definition, quotenode, jl_exprarg(e, 4));`
`166`	`167`	`JL_TYPECHK(cfunction method definition, symbol, (jl_value_t*)jl_exprarg(e, 4));`
	`168`	`+ JL_GC_POP();`
`167`	`169`	`return expr;`
`168`	`170`	`}`
`169`	`171`	`if (e->head == jl_foreigncall_sym) {`
`170`	`172`	`JL_NARGSV(ccall method definition, 5); // (fptr, rt, at, nreq, (cc, effects))`
`171`	`173`	`jl_value_t *rt = jl_exprarg(e, 1);`
`172`	`174`	`jl_value_t *at = jl_exprarg(e, 2);`
	`175`	`+ JL_GC_PUSH2(&at, &rt);`
`173`	`176`	`if (!jl_is_type(rt)) {`
`174`	`177`	`JL_TRY {`
`175`	`178`	`rt = jl_interpret_toplevel_expr_in(module, rt, NULL, sparam_vals);`
`@@ -208,6 +211,7 @@ static jl_value_t resolve_globals(jl_value_t expr, jl_module_t *module, jl_sve`
`208`	`211`	`}`
`209`	`212`	`jl_exprargset(e, 0, resolve_globals(jl_exprarg(e, 0), module, sparam_vals, binding_effects, 1));`
`210`	`213`	`i++;`
	`214`	`+ JL_GC_POP();`
`211`	`215`	`}`
`212`	`216`	`if (e->head == jl_method_sym \|\| e->head == jl_module_sym) {`
`213`	`217`	`i++;`
`@@ -259,11 +263,13 @@ static jl_value_t resolve_globals(jl_value_t expr, jl_module_t *module, jl_sve`
`259`	`263`	`}`
`260`	`264`	`if (j == nargs) {`
`261`	`265`	`jl_value_t *val = NULL;`
	`266`	`+ JL_GC_PUSH1(&val);`
`262`	`267`	`JL_TRY {`
`263`	`268`	`val = jl_interpret_toplevel_expr_in(module, (jl_value_t*)e, NULL, sparam_vals);`
`264`	`269`	`}`
`265`	`270`	`JL_CATCH {`
`266`	`271`	`}`
	`272`	`+ JL_GC_POP();`
`267`	`273`	`if (val)`
`268`	`274`	`return val;`
`269`	`275`	`}`