diff --git a/racket/src/racket/include/scheme.h b/racket/src/racket/include/scheme.h index c2fc8206c1..9db0aec8cf 100644 --- a/racket/src/racket/include/scheme.h +++ b/racket/src/racket/include/scheme.h @@ -883,7 +883,7 @@ typedef struct { /* ------------------------------------------------- */ #define SCHEME_PROCP(obj) (!SCHEME_INTP(obj) && ((_SCHEME_TYPE(obj) >= scheme_prim_type) && (_SCHEME_TYPE(obj) <= scheme_proc_chaperone_type))) -#define SCHEME_SYNTAXP(obj) SAME_TYPE(SCHEME_TYPE(obj), scheme_syntax_compiler_type) +#define SCHEME_SYNTAXP(obj) SAME_TYPE(SCHEME_TYPE(obj), scheme_primitive_syntax_type) #define SCHEME_PRIMP(obj) SAME_TYPE(SCHEME_TYPE(obj), scheme_prim_type) #define SCHEME_CLSD_PRIMP(obj) SAME_TYPE(SCHEME_TYPE(obj), scheme_closed_prim_type) #define SCHEME_CONTP(obj) SAME_TYPE(SCHEME_TYPE(obj), scheme_cont_type) @@ -895,8 +895,8 @@ typedef struct { #define SCHEME_PRIM(obj) (((Scheme_Primitive_Proc *)(obj))->prim_val) #define SCHEME_CLSD_PRIM(obj) (((Scheme_Closed_Primitive_Proc *)(obj))->prim_val) #define SCHEME_CLSD_PRIM_DATA(obj) (((Scheme_Closed_Primitive_Proc *)(obj))->data) -#define SCHEME_CLOS_FUNC(obj) ((Scheme_Closure_Func)SCHEME_CAR(obj)) -#define SCHEME_CLOS_DATA(obj) SCHEME_CDR(obj) +#define SCHEME_RAW_CLOS_FUNC(obj) ((Scheme_Closure_Func)SCHEME_CAR(obj)) +#define SCHEME_RAW_CLOS_DATA(obj) SCHEME_CDR(obj) /*========================================================================*/ /* hash tables and environments */ diff --git a/racket/src/racket/src/bool.c b/racket/src/racket/src/bool.c index 4be93d6a68..a1ea1e22dd 100644 --- a/racket/src/racket/src/bool.c +++ b/racket/src/racket/src/bool.c @@ -34,10 +34,10 @@ READ_ONLY Scheme_Object scheme_true[1]; READ_ONLY Scheme_Object scheme_false[1]; -READ_ONLY Scheme_Object *scheme_not_prim; -READ_ONLY Scheme_Object *scheme_eq_prim; -READ_ONLY Scheme_Object *scheme_eqv_prim; -READ_ONLY Scheme_Object *scheme_equal_prim; +READ_ONLY Scheme_Object *scheme_not_proc; +READ_ONLY Scheme_Object *scheme_eq_proc; +READ_ONLY Scheme_Object *scheme_eqv_proc; +READ_ONLY Scheme_Object *scheme_equal_proc; /* locals */ static Scheme_Object *not_prim (int argc, Scheme_Object *argv[]); @@ -82,13 +82,13 @@ void scheme_init_bool (Scheme_Env *env) { Scheme_Object *p; - REGISTER_SO(scheme_not_prim); - REGISTER_SO(scheme_eq_prim); - REGISTER_SO(scheme_eqv_prim); - REGISTER_SO(scheme_equal_prim); + REGISTER_SO(scheme_not_proc); + REGISTER_SO(scheme_eq_proc); + REGISTER_SO(scheme_eqv_proc); + REGISTER_SO(scheme_equal_proc); p = scheme_make_folding_prim(not_prim, "not", 1, 1, 1); - scheme_not_prim = p; + scheme_not_proc = p; SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_UNARY_INLINED | SCHEME_PRIM_IS_OMITABLE); scheme_add_global_constant("not", p, env); @@ -101,19 +101,19 @@ void scheme_init_bool (Scheme_Env *env) p = scheme_make_folding_prim(eq_prim, "eq?", 2, 2, 1); SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_BINARY_INLINED | SCHEME_PRIM_IS_OMITABLE); - scheme_eq_prim = p; + scheme_eq_proc = p; scheme_add_global_constant("eq?", p, env); p = scheme_make_folding_prim(eqv_prim, "eqv?", 2, 2, 1); SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_BINARY_INLINED | SCHEME_PRIM_IS_OMITABLE); - scheme_eqv_prim = p; - scheme_add_global_constant("eqv?", scheme_eqv_prim, env); + scheme_eqv_proc = p; + scheme_add_global_constant("eqv?", scheme_eqv_proc, env); p = scheme_make_prim_w_arity(equal_prim, "equal?", 2, 2); SCHEME_PRIM_PROC_FLAGS(p) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_BINARY_INLINED); - scheme_equal_prim = p; - scheme_add_global_constant("equal?", scheme_equal_prim, env); + scheme_equal_proc = p; + scheme_add_global_constant("equal?", scheme_equal_proc, env); scheme_add_global_constant("equal?/recur", scheme_make_prim_w_arity(equalish_prim, "equal?/recur", 3, 3), diff --git a/racket/src/racket/src/compenv.c b/racket/src/racket/src/compenv.c index 9402994feb..b1a166dc0d 100644 --- a/racket/src/racket/src/compenv.c +++ b/racket/src/racket/src/compenv.c @@ -602,7 +602,7 @@ Scheme_Object *scheme_make_toplevel(mzshort depth, int position, int resolved, i pr = NULL; tl = (Scheme_Toplevel *)scheme_malloc_atomic_tagged(sizeof(Scheme_Toplevel)); - tl->iso.so.type = (resolved ? scheme_toplevel_type : scheme_compiled_toplevel_type); + tl->iso.so.type = (resolved ? scheme_toplevel_type : scheme_ir_toplevel_type); tl->depth = depth; tl->position = position; SCHEME_TOPLEVEL_FLAGS(tl) = flags | HIGH_BIT_TO_DISABLE_HASHING; @@ -712,7 +712,7 @@ Scheme_Object *scheme_register_stx_in_comp_prefix(Scheme_Object *var, Comp_Prefi pos = cp->num_stxes; l = (Scheme_Local *)scheme_malloc_atomic_tagged(sizeof(Scheme_Local)); - l->iso.so.type = scheme_compiled_quote_syntax_type; + l->iso.so.type = scheme_ir_quote_syntax_type; l->position = pos; cp->num_stxes++; @@ -732,7 +732,7 @@ Scheme_Object *scheme_register_stx_in_prefix(Scheme_Object *var, Scheme_Comp_Env if (rec && rec[drec].dont_mark_local_use) { /* Make up anything; it's going to be ignored. */ l = (Scheme_Local *)scheme_malloc_atomic_tagged(sizeof(Scheme_Local)); - l->iso.so.type = scheme_compiled_quote_syntax_type; + l->iso.so.type = scheme_ir_quote_syntax_type; l->position = 0; return (Scheme_Object *)l; @@ -887,12 +887,12 @@ static Scheme_Object *get_local_name(Scheme_Object *id) return SCHEME_STX_VAL(id); } -static Scheme_Compiled_Local *make_variable(Scheme_Object *id) +static Scheme_IR_Local *make_variable(Scheme_Object *id) { - Scheme_Compiled_Local *var; + Scheme_IR_Local *var; - var = MALLOC_ONE_TAGGED(Scheme_Compiled_Local); - var->so.type = scheme_compiled_local_type; + var = MALLOC_ONE_TAGGED(Scheme_IR_Local); + var->so.type = scheme_ir_local_type; if (id) { id = get_local_name(id); var->name = id; @@ -901,19 +901,19 @@ static Scheme_Compiled_Local *make_variable(Scheme_Object *id) return var; } -static Scheme_Compiled_Local *get_frame_loc(Scheme_Comp_Env *frame, - int i, int j, int p, int flags) -/* Generates a Scheme_Compiled_Local record as needed, and also +static Scheme_IR_Local *get_frame_loc(Scheme_Comp_Env *frame, + int i, int j, int p, int flags) +/* Generates a Scheme_IR_Local record as needed, and also marks the variable as used for closures. */ { if (!frame->vars) { - Scheme_Compiled_Local **vars; - vars = MALLOC_N(Scheme_Compiled_Local*, frame->num_bindings); + Scheme_IR_Local **vars; + vars = MALLOC_N(Scheme_IR_Local*, frame->num_bindings); frame->vars = vars; } if (!frame->vars[i]) { - Scheme_Compiled_Local *var; + Scheme_IR_Local *var; var = make_variable(frame->binders ? frame->binders[i] : NULL); frame->vars[i] = var; } @@ -935,14 +935,14 @@ static Scheme_Compiled_Local *get_frame_loc(Scheme_Comp_Env *frame, void scheme_env_make_variables(Scheme_Comp_Env *frame) { - Scheme_Compiled_Local *var, **vars; + Scheme_IR_Local *var, **vars; int i; if (!frame->num_bindings) return; if (!frame->vars) { - vars = MALLOC_N(Scheme_Compiled_Local*, frame->num_bindings); + vars = MALLOC_N(Scheme_IR_Local*, frame->num_bindings); frame->vars = vars; } @@ -954,7 +954,7 @@ void scheme_env_make_variables(Scheme_Comp_Env *frame) } } -void scheme_set_compilation_variables(Scheme_Comp_Env *frame, Scheme_Compiled_Local **vars, +void scheme_set_compilation_variables(Scheme_Comp_Env *frame, Scheme_IR_Local **vars, int pos, int count) { int i; @@ -962,8 +962,8 @@ void scheme_set_compilation_variables(Scheme_Comp_Env *frame, Scheme_Compiled_Lo MZ_ASSERT((pos + count) <= frame->num_bindings); if (!frame->vars) { - Scheme_Compiled_Local **fvars; - fvars = MALLOC_N(Scheme_Compiled_Local*, frame->num_bindings); + Scheme_IR_Local **fvars; + fvars = MALLOC_N(Scheme_IR_Local*, frame->num_bindings); frame->vars = fvars; } @@ -1195,7 +1195,7 @@ static void set_binder(Scheme_Object **_binder, Scheme_Object *ref, Scheme_Objec scheme_macro_id_type (id was bound to a rename-transformer), - scheme_compiled_local_type (id was lexical), + scheme_ir_local_type (id was lexical), scheme_variable_type (id is a global or module-bound variable), or diff --git a/racket/src/racket/src/compile.c b/racket/src/racket/src/compile.c index 80b65dd3e3..f2f73d74d5 100644 --- a/racket/src/racket/src/compile.c +++ b/racket/src/racket/src/compile.c @@ -38,7 +38,6 @@ READ_ONLY Scheme_Object *scheme_define_syntaxes_syntax; READ_ONLY Scheme_Object *scheme_ref_syntax; READ_ONLY Scheme_Object *scheme_begin_syntax; READ_ONLY Scheme_Object *scheme_lambda_syntax; -READ_ONLY Scheme_Object *scheme_compiled_void_code; READ_ONLY Scheme_Object scheme_undefined[1]; /* read-only globals */ @@ -74,55 +73,55 @@ THREAD_LOCAL_DECL(struct Scheme_Object *cwv_stx); THREAD_LOCAL_DECL(int cwv_stx_phase); /* locals */ -static Scheme_Object *lambda_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); +static Scheme_Object *lambda_compile(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); static Scheme_Object *lambda_expand(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Expand_Info *erec, int drec); -static Scheme_Object *define_values_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); +static Scheme_Object *define_values_compile(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); static Scheme_Object *define_values_expand(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Expand_Info *erec, int drec); -static Scheme_Object *ref_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); +static Scheme_Object *ref_compile(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); static Scheme_Object *ref_expand(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Expand_Info *erec, int drec); -static Scheme_Object *quote_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); +static Scheme_Object *quote_compile(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); static Scheme_Object *quote_expand(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Expand_Info *erec, int drec); -static Scheme_Object *if_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); +static Scheme_Object *if_compile(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); static Scheme_Object *if_expand(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Expand_Info *erec, int drec); static Scheme_Object *set_expand(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Expand_Info *erec, int drec); -static Scheme_Object *set_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); -static Scheme_Object *case_lambda_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); +static Scheme_Object *set_compile(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); +static Scheme_Object *case_lambda_compile(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); static Scheme_Object *case_lambda_expand(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Expand_Info *erec, int drec); static Scheme_Object *let_values_expand(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Expand_Info *erec, int drec); -static Scheme_Object *let_values_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); +static Scheme_Object *let_values_compile(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); static Scheme_Object *letrec_values_expand(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Expand_Info *erec, int drec); -static Scheme_Object *letrec_values_syntax (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); -static Scheme_Object *begin_syntax (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); +static Scheme_Object *letrec_values_compile (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); +static Scheme_Object *begin_compile (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); static Scheme_Object *begin_expand (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Expand_Info *erec, int drec); -static Scheme_Object *begin0_syntax (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); +static Scheme_Object *begin0_compile (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); static Scheme_Object *begin0_expand (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Expand_Info *erec, int drec); -static Scheme_Object *stratified_body_syntax (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); +static Scheme_Object *stratified_body_compile (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); static Scheme_Object *stratified_body_expand (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Expand_Info *erec, int drec); -static Scheme_Object *expression_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); +static Scheme_Object *expression_compile(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); static Scheme_Object *expression_expand(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Expand_Info *erec, int drec); -static Scheme_Object *unquote_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); +static Scheme_Object *unquote_compile(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); static Scheme_Object *unquote_expand(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Expand_Info *erec, int drec); -static Scheme_Object *with_cont_mark_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); +static Scheme_Object *with_cont_mark_compile(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); static Scheme_Object *with_cont_mark_expand(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Expand_Info *erec, int drec); -static Scheme_Object *quote_syntax_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); +static Scheme_Object *quote_syntax_compile(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); static Scheme_Object *quote_syntax_expand(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Expand_Info *erec, int drec); -static Scheme_Object *define_syntaxes_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); +static Scheme_Object *define_syntaxes_compile(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); static Scheme_Object *define_syntaxes_expand(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Expand_Info *erec, int drec); -static Scheme_Object *begin_for_syntax_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); +static Scheme_Object *begin_for_syntax_compile(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); static Scheme_Object *begin_for_syntax_expand(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Expand_Info *erec, int drec); -static Scheme_Object *letrec_syntaxes_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); +static Scheme_Object *letrec_syntaxes_compile(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); static Scheme_Object *letrec_syntaxes_expand(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Expand_Info *erec, int drec); -static Scheme_Object *app_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); +static Scheme_Object *app_compile(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); static Scheme_Object *app_expand(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Expand_Info *erec, int drec); -static Scheme_Object *datum_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); +static Scheme_Object *datum_compile(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); static Scheme_Object *datum_expand(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Expand_Info *erec, int drec); -static Scheme_Object *top_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); +static Scheme_Object *top_compile(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); static Scheme_Object *top_expand(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Expand_Info *erec, int drec); -static Scheme_Object *stop_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); +static Scheme_Object *stop_compile(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); static Scheme_Object *stop_expand(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Expand_Info *erec, int drec); static Scheme_Object *expand_lam(int argc, Scheme_Object **argv); @@ -168,7 +167,6 @@ void scheme_init_compile (Scheme_Env *env) REGISTER_SO(scheme_define_syntaxes_syntax); REGISTER_SO(scheme_lambda_syntax); REGISTER_SO(scheme_begin_syntax); - REGISTER_SO(scheme_compiled_void_code); REGISTER_SO(lambda_symbol); REGISTER_SO(letrec_values_symbol); @@ -202,14 +200,14 @@ void scheme_init_compile (Scheme_Env *env) existing_variables_symbol = scheme_make_symbol("existing-variables"); - scheme_define_values_syntax = scheme_make_compiled_syntax(define_values_syntax, - define_values_expand); - scheme_define_syntaxes_syntax = scheme_make_compiled_syntax(define_syntaxes_syntax, - define_syntaxes_expand); - scheme_lambda_syntax = scheme_make_compiled_syntax(lambda_syntax, - lambda_expand); - scheme_begin_syntax = scheme_make_compiled_syntax(begin_syntax, - begin_expand); + scheme_define_values_syntax = scheme_make_primitive_syntax(define_values_compile, + define_values_expand); + scheme_define_syntaxes_syntax = scheme_make_primitive_syntax(define_syntaxes_compile, + define_syntaxes_expand); + scheme_lambda_syntax = scheme_make_primitive_syntax(lambda_compile, + lambda_expand); + scheme_begin_syntax = scheme_make_primitive_syntax(begin_compile, + begin_expand); scheme_add_global_keyword("lambda", scheme_lambda_syntax, @@ -227,80 +225,80 @@ void scheme_init_compile (Scheme_Env *env) } scheme_add_global_keyword("define-values", scheme_define_values_syntax, env); scheme_add_global_keyword("quote", - scheme_make_compiled_syntax(quote_syntax, - quote_expand), + scheme_make_primitive_syntax(quote_compile, + quote_expand), env); scheme_add_global_keyword("if", - scheme_make_compiled_syntax(if_syntax, - if_expand), + scheme_make_primitive_syntax(if_compile, + if_expand), env); scheme_add_global_keyword("set!", - scheme_make_compiled_syntax(set_syntax, - set_expand), + scheme_make_primitive_syntax(set_compile, + set_expand), env); scheme_add_global_keyword("#%variable-reference", - scheme_make_compiled_syntax(ref_syntax, - ref_expand), + scheme_make_primitive_syntax(ref_compile, + ref_expand), env); scheme_add_global_keyword("#%expression", - scheme_make_compiled_syntax(expression_syntax, - expression_expand), + scheme_make_primitive_syntax(expression_compile, + expression_expand), env); scheme_add_global_keyword("case-lambda", - scheme_make_compiled_syntax(case_lambda_syntax, - case_lambda_expand), + scheme_make_primitive_syntax(case_lambda_compile, + case_lambda_expand), env); scheme_add_global_keyword("let-values", - scheme_make_compiled_syntax(let_values_syntax, - let_values_expand), + scheme_make_primitive_syntax(let_values_compile, + let_values_expand), env); scheme_add_global_keyword("letrec-values", - scheme_make_compiled_syntax(letrec_values_syntax, - letrec_values_expand), + scheme_make_primitive_syntax(letrec_values_compile, + letrec_values_expand), env); scheme_add_global_keyword("begin", scheme_begin_syntax, env); scheme_add_global_keyword("#%stratified-body", - scheme_make_compiled_syntax(stratified_body_syntax, - stratified_body_expand), + scheme_make_primitive_syntax(stratified_body_compile, + stratified_body_expand), env); scheme_add_global_keyword("begin0", - scheme_make_compiled_syntax(begin0_syntax, - begin0_expand), + scheme_make_primitive_syntax(begin0_compile, + begin0_expand), env); scheme_add_global_keyword("unquote", - scheme_make_compiled_syntax(unquote_syntax, - unquote_expand), + scheme_make_primitive_syntax(unquote_compile, + unquote_expand), env); scheme_add_global_keyword("unquote-splicing", - scheme_make_compiled_syntax(unquote_syntax, - unquote_expand), + scheme_make_primitive_syntax(unquote_compile, + unquote_expand), env); scheme_add_global_keyword("with-continuation-mark", - scheme_make_compiled_syntax(with_cont_mark_syntax, - with_cont_mark_expand), + scheme_make_primitive_syntax(with_cont_mark_compile, + with_cont_mark_expand), env); scheme_add_global_keyword("quote-syntax", - scheme_make_compiled_syntax(quote_syntax_syntax, - quote_syntax_expand), + scheme_make_primitive_syntax(quote_syntax_compile, + quote_syntax_expand), env); scheme_add_global_keyword("define-syntaxes", scheme_define_syntaxes_syntax, env); scheme_add_global_keyword("begin-for-syntax", - scheme_make_compiled_syntax(begin_for_syntax_syntax, - begin_for_syntax_expand), + scheme_make_primitive_syntax(begin_for_syntax_compile, + begin_for_syntax_expand), env); scheme_add_global_keyword("letrec-syntaxes+values", - scheme_make_compiled_syntax(letrec_syntaxes_syntax, - letrec_syntaxes_expand), + scheme_make_primitive_syntax(letrec_syntaxes_compile, + letrec_syntaxes_expand), env); REGISTER_SO(app_symbol); @@ -328,10 +326,10 @@ void scheme_init_compile (Scheme_Env *env) REGISTER_SO(top_expander); REGISTER_SO(stop_expander); - app_expander = scheme_make_compiled_syntax(app_syntax, app_expand); - datum_expander = scheme_make_compiled_syntax(datum_syntax, datum_expand); - top_expander = scheme_make_compiled_syntax(top_syntax, top_expand); - stop_expander = scheme_make_compiled_syntax(stop_syntax, stop_expand); + app_expander = scheme_make_primitive_syntax(app_compile, app_expand); + datum_expander = scheme_make_primitive_syntax(datum_compile, datum_expand); + top_expander = scheme_make_primitive_syntax(top_compile, top_expand); + stop_expander = scheme_make_primitive_syntax(stop_compile, stop_expand); scheme_add_global_keyword("#%app", app_expander, env); scheme_add_global_keyword("#%datum", datum_expander, env); scheme_add_global_keyword("#%top", top_expander, env); @@ -346,13 +344,13 @@ void scheme_init_compile_places() } Scheme_Object * -scheme_make_compiled_syntax(Scheme_Syntax *proc, - Scheme_Syntax_Expander *eproc) +scheme_make_primitive_syntax(Scheme_Syntax *proc, + Scheme_Syntax_Expander *eproc) { Scheme_Object *syntax; syntax = scheme_alloc_eternal_object(); - syntax->type = scheme_syntax_compiler_type; + syntax->type = scheme_primitive_syntax_type; SCHEME_SYNTAX(syntax) = (Scheme_Object *)proc; SCHEME_SYNTAX_EXP(syntax) = (Scheme_Object *)eproc; @@ -601,21 +599,21 @@ Scheme_Object *scheme_build_closure_name(Scheme_Object *code, Scheme_Comp_Env *e } static Scheme_Object * -make_closure_compilation(Scheme_Comp_Env *env, Scheme_Object *code, - Scheme_Compile_Info *rec, int drec) +make_lambda(Scheme_Comp_Env *env, Scheme_Object *code, + Scheme_Compile_Info *rec, int drec) /* Compiles a `lambda' expression */ { Scheme_Object *allparams, *params, *forms, *param, *name, *scope; - Scheme_Closure_Data *data; - Scheme_Compile_Info lam; + Scheme_Lambda *lam; + Scheme_Compile_Info lrec; Scheme_Comp_Env *frame; int i; intptr_t num_params; - Closure_Info *cl; + Scheme_IR_Lambda_Info *cl; - data = MALLOC_ONE_TAGGED(Scheme_Closure_Data); + lam = MALLOC_ONE_TAGGED(Scheme_Lambda); - data->iso.so.type = scheme_compiled_unclosed_procedure_type; + lam->iso.so.type = scheme_ir_lambda_type; params = SCHEME_STX_CDR(code); params = SCHEME_STX_CAR(params); @@ -625,23 +623,23 @@ make_closure_compilation(Scheme_Comp_Env *env, Scheme_Object *code, for (; SCHEME_STX_PAIRP(params); params = SCHEME_STX_CDR(params)) { num_params++; } - SCHEME_CLOSURE_DATA_FLAGS(data) = 0; + SCHEME_LAMBDA_FLAGS(lam) = 0; if (!SCHEME_STX_NULLP(params)) { - SCHEME_CLOSURE_DATA_FLAGS(data) |= CLOS_HAS_REST; + SCHEME_LAMBDA_FLAGS(lam) |= LAMBDA_HAS_REST; num_params++; } - data->num_params = num_params; - if ((data->num_params > 0) && scheme_has_method_property(code)) - SCHEME_CLOSURE_DATA_FLAGS(data) |= CLOS_IS_METHOD; + lam->num_params = num_params; + if ((lam->num_params > 0) && scheme_has_method_property(code)) + SCHEME_LAMBDA_FLAGS(lam) |= LAMBDA_IS_METHOD; forms = SCHEME_STX_CDR(code); forms = SCHEME_STX_CDR(forms); scope = scheme_new_scope(SCHEME_STX_LOCAL_BIND_SCOPE); - frame = scheme_new_compilation_frame(data->num_params, SCHEME_LAMBDA_FRAME, scope, env); + frame = scheme_new_compilation_frame(lam->num_params, SCHEME_LAMBDA_FRAME, scope, env); params = allparams; - for (i = 0; i < data->num_params; i++) { + for (i = 0; i < lam->num_params; i++) { if (!SCHEME_STX_PAIRP(params)) param = params; else @@ -660,33 +658,33 @@ make_closure_compilation(Scheme_Comp_Env *env, Scheme_Object *code, forms = scheme_stx_add_scope(forms, scope, scheme_env_phase(env->genv)); name = scheme_build_closure_name(code, env); - data->name = name; + lam->name = name; scheme_compile_rec_done_local(rec, drec); - scheme_init_lambda_rec(rec, drec, &lam, 0); + scheme_init_lambda_rec(rec, drec, &lrec, 0); { - Scheme_Object *datacode; - datacode = compile_sequence(forms, - scheme_no_defines(frame), - &lam, 0, - 1); - data->code = datacode; + Scheme_Object *body; + body = compile_sequence(forms, + scheme_no_defines(frame), + &lrec, 0, + 1); + lam->body = body; } - scheme_merge_lambda_rec(rec, drec, &lam, 0); + scheme_merge_lambda_rec(rec, drec, &lrec, 0); - cl = MALLOC_ONE_RT(Closure_Info); - SET_REQUIRED_TAG(cl->type = scheme_rt_closure_info); + cl = MALLOC_ONE_RT(Scheme_IR_Lambda_Info); + SET_REQUIRED_TAG(cl->type = scheme_rt_ir_lambda_info); cl->vars = frame->vars; - data->closure_map = (mzshort *)cl; + lam->ir_info = cl; - return (Scheme_Object *)data; + return (Scheme_Object *)lam; } static Scheme_Object * -lambda_syntax (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) +lambda_compile (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) { Scheme_Object *args; @@ -696,7 +694,7 @@ lambda_syntax (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *r args = SCHEME_STX_CAR(args); lambda_check_args(args, form, env); - return make_closure_compilation(env, form, rec, drec); + return make_lambda(env, form, rec, drec); } static Scheme_Object * @@ -763,19 +761,19 @@ static Scheme_Object *expand_lam(int argc, Scheme_Object **argv) return scheme_datum_to_syntax(cons(fn, args), form, form, 0, 2); } -Scheme_Object *scheme_clone_vector(Scheme_Object *data, int skip, int set_type) +Scheme_Object *scheme_clone_vector(Scheme_Object *lam, int skip, int set_type) { Scheme_Object *naya; int i, size; - size = SCHEME_VEC_SIZE(data); + size = SCHEME_VEC_SIZE(lam); naya = scheme_make_vector(size - skip, NULL); for (i = skip; i < size; i++) { - SCHEME_VEC_ELS(naya)[i - skip] = SCHEME_VEC_ELS(data)[i]; + SCHEME_VEC_ELS(naya)[i - skip] = SCHEME_VEC_ELS(lam)[i]; } if (set_type) - naya->type = data->type; + naya->type = lam->type; return naya; } @@ -869,7 +867,7 @@ static Scheme_Object *global_binding(Scheme_Object *id, Scheme_Comp_Env *env) } static Scheme_Object * -defn_targets_syntax (Scheme_Object *var, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) +defn_targets_compile (Scheme_Object *var, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) { Scheme_Object *first = scheme_null, *last = NULL; @@ -905,14 +903,14 @@ defn_targets_syntax (Scheme_Object *var, Scheme_Comp_Env *env, Scheme_Compile_In } static Scheme_Object * -define_values_syntax (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) +define_values_compile (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) { Scheme_Object *var, *val, *targets, *variables, *vec, *value_name; scheme_define_parse(form, &var, &val, 0, env, 0); variables = var; - targets = defn_targets_syntax(var, env, rec, drec); + targets = defn_targets_compile(var, env, rec, drec); scheme_compile_rec_done_local(rec, drec); if (SCHEME_STX_PAIRP(targets) && SCHEME_STX_NULLP(SCHEME_STX_CDR(targets))) { @@ -985,7 +983,7 @@ define_values_expand(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Expand_In /**********************************************************************/ static Scheme_Object * -quote_syntax (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) +quote_compile (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) { Scheme_Object *v, *rest; @@ -1041,7 +1039,7 @@ scheme_make_branch(Scheme_Object *test, Scheme_Object *thenp, { Scheme_Branch_Rec *b; - if (SCHEME_TYPE(test) > _scheme_compiled_values_types_) { + if (SCHEME_TYPE(test) > _scheme_ir_values_types_) { if (SCHEME_FALSEP(test)) return elsep; else @@ -1059,7 +1057,7 @@ scheme_make_branch(Scheme_Object *test, Scheme_Object *thenp, } static Scheme_Object * -if_syntax (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) +if_compile (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) { int len, opt; Scheme_Object *test, *thenp, *elsep, *name, *rest; @@ -1092,7 +1090,7 @@ if_syntax (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, test = scheme_compile_expr(test, env, recs, 0); - if (SCHEME_TYPE(test) > _scheme_compiled_values_types_) { + if (SCHEME_TYPE(test) > _scheme_ir_values_types_) { opt = 1; if (SCHEME_FALSEP(test)) { @@ -1195,7 +1193,7 @@ if_expand(Scheme_Object *orig_form, Scheme_Comp_Env *env, Scheme_Expand_Info *er /**********************************************************************/ static Scheme_Object * -with_cont_mark_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) +with_cont_mark_compile(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) { Scheme_Object *key, *val, *expr, *value_name; Scheme_Compile_Info recs[3]; @@ -1293,7 +1291,7 @@ with_cont_mark_expand(Scheme_Object *orig_form, Scheme_Comp_Env *env, Scheme_Exp /**********************************************************************/ static Scheme_Object * -set_syntax (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) +set_compile (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) { Scheme_Set_Bang *sb; Scheme_Env *menv = NULL; @@ -1347,7 +1345,7 @@ set_syntax (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, } if (SAME_TYPE(SCHEME_TYPE(var), scheme_macro_type) - || SAME_TYPE(SCHEME_TYPE(var), scheme_syntax_compiler_type)) { + || SAME_TYPE(SCHEME_TYPE(var), scheme_primitive_syntax_type)) { scheme_wrong_syntax(NULL, name, form, "cannot mutate syntax identifier"); return NULL; } @@ -1447,7 +1445,7 @@ set_expand(Scheme_Object *orig_form, Scheme_Comp_Env *env, Scheme_Expand_Info *e } if (SAME_TYPE(SCHEME_TYPE(var), scheme_macro_type) - || SAME_TYPE(SCHEME_TYPE(var), scheme_syntax_compiler_type)) { + || SAME_TYPE(SCHEME_TYPE(var), scheme_primitive_syntax_type)) { scheme_wrong_syntax(NULL, name, form, "cannot mutate syntax identifier"); } @@ -1480,7 +1478,7 @@ set_expand(Scheme_Object *orig_form, Scheme_Comp_Env *env, Scheme_Expand_Info *e /**********************************************************************/ static Scheme_Object * -ref_syntax (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) +ref_compile (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) { Scheme_Env *menv = NULL; Scheme_Object *var, *name, *rest, *dummy, *bind_id; @@ -1566,7 +1564,7 @@ ref_syntax (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, if (!imported && env->genv->module && !rec[drec].testing_constantness) SCHEME_TOPLEVEL_FLAGS(var) |= SCHEME_TOPLEVEL_MUTATED; } - } else if (SAME_TYPE(SCHEME_TYPE(var), scheme_compiled_local_type)) { + } else if (SAME_TYPE(SCHEME_TYPE(var), scheme_ir_local_type)) { /* ok */ } else { scheme_wrong_syntax(NULL, name, form, "identifier does not refer to a variable"); @@ -1602,7 +1600,7 @@ ref_expand(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Expand_Info *erec, SCHEME_EXPAND_OBSERVE_PRIM_VARREF(env->observer); /* Error checking, and lexical variable update: */ - naya = ref_syntax(form, env, erec, drec); + naya = ref_compile(form, env, erec, drec); if (!naya) /* No change: */ @@ -1677,7 +1675,7 @@ static void case_lambda_check_line(Scheme_Object *line, Scheme_Object *form, Sch } static Scheme_Object * -case_lambda_syntax (Scheme_Object *form, Scheme_Comp_Env *env, +case_lambda_compile (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) { Scheme_Object *list, *last, *c, *orig_form = form, *name; @@ -1725,7 +1723,7 @@ case_lambda_syntax (Scheme_Object *form, Scheme_Comp_Env *env, c); c = scheme_datum_to_syntax(c, orig_form, orig_form, 0, 2); - return lambda_syntax(c, env, rec, drec); + return lambda_compile(c, env, rec, drec); } scheme_compile_rec_done_local(rec, drec); @@ -1780,16 +1778,16 @@ case_lambda_syntax (Scheme_Object *form, Scheme_Comp_Env *env, scheme_merge_compile_recs(rec, drec, recs, count); if (scheme_has_method_property(orig_form)) { - Scheme_Closure_Data *data; + Scheme_Lambda *lam; /* Make sure no branch has 0 arguments: */ for (i = 0; i < count; i++) { - data = (Scheme_Closure_Data *)cl->array[i]; - if (!data->num_params) + lam = (Scheme_Lambda *)cl->array[i]; + if (!lam->num_params) break; } if (i >= count) { - data = (Scheme_Closure_Data *)cl->array[0]; - SCHEME_CLOSURE_DATA_FLAGS(data) |= CLOS_IS_METHOD; + lam = (Scheme_Lambda *)cl->array[0]; + SCHEME_LAMBDA_FLAGS(lam) |= LAMBDA_IS_METHOD; } } @@ -1859,13 +1857,13 @@ case_lambda_expand(Scheme_Object *orig_form, Scheme_Comp_Env *env, Scheme_Expand /* let, let-values, letrec, etc. */ /**********************************************************************/ -static Scheme_Let_Header *make_header(Scheme_Object *first, int num_bindings, int num_clauses, - int flags) +static Scheme_IR_Let_Header *make_header(Scheme_Object *first, int num_bindings, int num_clauses, + int flags) { - Scheme_Let_Header *head; + Scheme_IR_Let_Header *head; - head = MALLOC_ONE_TAGGED(Scheme_Let_Header); - head->iso.so.type = scheme_compiled_let_void_type; + head = MALLOC_ONE_TAGGED(Scheme_IR_Let_Header); + head->iso.so.type = scheme_ir_let_void_type; head->body = first; head->count = num_bindings; head->num_clauses = num_clauses; @@ -2012,7 +2010,7 @@ static Scheme_Object *detect_traditional_letrec(Scheme_Object *form, Scheme_Comp } static Scheme_Object * -gen_let_syntax (Scheme_Object *form, Scheme_Comp_Env *origenv, char *formname, +do_let_compile (Scheme_Object *form, Scheme_Comp_Env *origenv, char *formname, int recursive, int multi, Scheme_Compile_Info *rec, int drec, Scheme_Comp_Env *frame_already) { @@ -2021,10 +2019,10 @@ gen_let_syntax (Scheme_Object *form, Scheme_Comp_Env *origenv, char *formname, Scheme_Comp_Env *frame, *env, *rhs_env; Scheme_Compile_Info *recs; Scheme_Object *first = NULL, *existing_vars; - Scheme_Compiled_Let_Value *last = NULL, *lv; + Scheme_IR_Let_Value *last = NULL, *lv; DupCheckRecord r; int rec_env_already = rec[drec].env_already, body_block; - Scheme_Let_Header *head; + Scheme_IR_Let_Header *head; form = scheme_stx_taint_disarm(form, NULL); @@ -2192,8 +2190,8 @@ gen_let_syntax (Scheme_Object *form, Scheme_Comp_Env *origenv, char *formname, } } - lv = MALLOC_ONE_TAGGED(Scheme_Compiled_Let_Value); - lv->iso.so.type = scheme_compiled_let_value_type; + lv = MALLOC_ONE_TAGGED(Scheme_IR_Let_Value); + lv->iso.so.type = scheme_ir_let_value_type; if (!last) first = (Scheme_Object *)lv; else @@ -2227,7 +2225,7 @@ gen_let_syntax (Scheme_Object *form, Scheme_Comp_Env *origenv, char *formname, if (SCHEME_TRUEP(existing_vars)) { /* Install variables already generated by a lift: */ - scheme_set_compilation_variables(frame, (Scheme_Compiled_Local **)SCHEME_CDR(existing_vars), + scheme_set_compilation_variables(frame, (Scheme_IR_Local **)SCHEME_CDR(existing_vars), pre_k, k - pre_k); } @@ -2243,18 +2241,18 @@ gen_let_syntax (Scheme_Object *form, Scheme_Comp_Env *origenv, char *formname, scheme_env_make_variables(env); k = 0; - lv = (Scheme_Compiled_Let_Value *)first; + lv = (Scheme_IR_Let_Value *)first; for (i = 0; i < num_clauses; i++) { - Scheme_Compiled_Local **vars; + Scheme_IR_Local **vars; - vars = MALLOC_N(Scheme_Compiled_Local*, lv->count); + vars = MALLOC_N(Scheme_IR_Local*, lv->count); lv->vars = vars; for (j = lv->count; j--; ) { vars[j] = env->vars[k+j]; } k += lv->count; - lv = (Scheme_Compiled_Let_Value *)lv->body; + lv = (Scheme_IR_Let_Value *)lv->body; } head = make_header(first, num_bindings, num_clauses, @@ -2265,8 +2263,8 @@ gen_let_syntax (Scheme_Object *form, Scheme_Comp_Env *origenv, char *formname, int group_clauses = 0; k = 0; - lv = (Scheme_Compiled_Let_Value *)first; - for (i = 0; i < num_clauses; i++, lv = (Scheme_Compiled_Let_Value *)lv->body) { + lv = (Scheme_IR_Let_Value *)first; + for (i = 0; i < num_clauses; i++, lv = (Scheme_IR_Let_Value *)lv->body) { Scheme_Object *ce, *rhs; rhs = lv->value; if (scope) @@ -2284,7 +2282,7 @@ gen_let_syntax (Scheme_Object *form, Scheme_Comp_Env *origenv, char *formname, always break bindings into smaller sets based on this information; otherwise, we have to be more conservative as reflected by scheme_might_invoke_call_cc(), so record with - SCHEME_CLV_NO_GROUP_LATER_USES and check again at the end. */ + SCHEME_IRLV_NO_GROUP_LATER_USES and check again at the end. */ if ((rec_env_already == 2) /* int def: semantics is `let' */ || (!prev_might_invoke && !scheme_might_invoke_call_cc(ce))) { @@ -2292,11 +2290,11 @@ gen_let_syntax (Scheme_Object *form, Scheme_Comp_Env *origenv, char *formname, if ((group_clauses == 1) && !scheme_env_max_use_above(env, k)) { /* A clause that should be in its own `let' */ - SCHEME_CLV_FLAGS(lv) |= SCHEME_CLV_NO_GROUP_USES; + SCHEME_IRLV_FLAGS(lv) |= SCHEME_IRLV_NO_GROUP_USES; group_clauses = 0; } else if (!scheme_env_max_use_above(env, k + lv->count)) { /* End a recursive `letrec' group */ - SCHEME_CLV_FLAGS(lv) |= SCHEME_CLV_NO_GROUP_LATER_USES; + SCHEME_IRLV_FLAGS(lv) |= SCHEME_IRLV_NO_GROUP_LATER_USES; group_clauses = 0; } } else @@ -2306,20 +2304,20 @@ gen_let_syntax (Scheme_Object *form, Scheme_Comp_Env *origenv, char *formname, } if (!prev_might_invoke) { - Scheme_Let_Header *current_head = head; - Scheme_Compiled_Let_Value *next = NULL; + Scheme_IR_Let_Header *current_head = head; + Scheme_IR_Let_Value *next = NULL; int group_count = 0; - lv = (Scheme_Compiled_Let_Value *)first; + lv = (Scheme_IR_Let_Value *)first; group_clauses = 0; for (i = 0; i < num_clauses; i++, lv = next) { - next = (Scheme_Compiled_Let_Value *)lv->body; + next = (Scheme_IR_Let_Value *)lv->body; group_clauses++; group_count += lv->count; - if (SCHEME_CLV_FLAGS(lv) & (SCHEME_CLV_NO_GROUP_USES - | SCHEME_CLV_NO_GROUP_LATER_USES)) { + if (SCHEME_IRLV_FLAGS(lv) & (SCHEME_IRLV_NO_GROUP_USES + | SCHEME_IRLV_NO_GROUP_LATER_USES)) { /* A clause that should be in its own `let' */ - Scheme_Let_Header *next_head; - int single = (SCHEME_CLV_FLAGS(lv) & SCHEME_CLV_NO_GROUP_USES); + Scheme_IR_Let_Header *next_head; + int single = (SCHEME_IRLV_FLAGS(lv) & SCHEME_IRLV_NO_GROUP_USES); MZ_ASSERT(!single || (group_clauses == 1)); if (current_head->num_clauses - group_clauses) { next_head = make_header(lv->body, @@ -2631,16 +2629,16 @@ letrec_values_expand(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Expand_In static Scheme_Object * -let_values_syntax (Scheme_Object *form, Scheme_Comp_Env *env, +let_values_compile (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) { - return gen_let_syntax(form, env, "let-values", 0, 1, rec, drec, NULL); + return do_let_compile(form, env, "let-values", 0, 1, rec, drec, NULL); } static Scheme_Object * -letrec_values_syntax (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) +letrec_values_compile (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) { - return gen_let_syntax(form, env, "letrec-values", 1, 1, rec, drec, NULL); + return do_let_compile(form, env, "letrec-values", 1, 1, rec, drec, NULL); } /**********************************************************************/ @@ -2673,7 +2671,7 @@ Scheme_Object *scheme_compiled_void() } static Scheme_Object * -do_begin_syntax(char *name, +do_begin_compile(char *name, Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec, int zero) { @@ -2756,15 +2754,15 @@ do_begin_syntax(char *name, } static Scheme_Object * -begin_syntax (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) +begin_compile (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) { - return do_begin_syntax("begin", form, env, rec, drec, 0); + return do_begin_compile("begin", form, env, rec, drec, 0); } static Scheme_Object * -begin0_syntax (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) +begin0_compile (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) { - return do_begin_syntax("begin0", form, env, rec, drec, 1); + return do_begin_compile("begin0", form, env, rec, drec, 1); } Scheme_Sequence *scheme_malloc_sequence(int count) @@ -2875,7 +2873,7 @@ Scheme_Object *scheme_make_sequence_compilation(Scheme_Object *seq, int opt, int } static Scheme_Object * -stratified_body_syntax (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) +stratified_body_compile (Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) { Scheme_Object *body; @@ -3033,7 +3031,7 @@ static Scheme_Object *check_single(Scheme_Object *form, Scheme_Comp_Env *top_onl } static Scheme_Object * -single_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec, int top_only) +single_compile(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec, int top_only) { return scheme_compile_expr(check_single(form, top_only ? env: NULL), env, rec, drec); } @@ -3062,9 +3060,9 @@ single_expand(Scheme_Object *orig_form, Scheme_Comp_Env *env, Scheme_Expand_Info 0, 2); } -static Scheme_Object *expression_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) +static Scheme_Object *expression_compile(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) { - return single_syntax(form, scheme_no_defines(env), rec, drec, 0); + return single_compile(form, scheme_no_defines(env), rec, drec, 0); } static Scheme_Object *expression_expand(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Expand_Info *erec, int drec) @@ -3080,7 +3078,7 @@ static Scheme_Object *expression_expand(Scheme_Object *form, Scheme_Comp_Env *en /**********************************************************************/ static Scheme_Object * -unquote_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) +unquote_compile(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) { int len; @@ -3098,7 +3096,7 @@ unquote_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *r static Scheme_Object * unquote_expand(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Expand_Info *erec, int drec) { - return unquote_syntax(form, env, erec, drec); + return unquote_compile(form, env, erec, drec); } /**********************************************************************/ @@ -3106,7 +3104,7 @@ unquote_expand(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Expand_Info *er /**********************************************************************/ static Scheme_Object * -quote_syntax_syntax(Scheme_Object *orig_form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) +quote_syntax_compile(Scheme_Object *orig_form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) { int len, local; Scheme_Object *stx, *form; @@ -3174,7 +3172,7 @@ static Scheme_Object * quote_syntax_expand(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Expand_Info *erec, int drec) { SCHEME_EXPAND_OBSERVE_PRIM_QUOTE_SYNTAX(env->observer); - return quote_syntax_syntax(form, env, erec, drec); + return quote_syntax_compile(form, env, erec, drec); } @@ -3200,7 +3198,7 @@ static Scheme_Object *stx_val(Scheme_Object *name, Scheme_Object *_env) } static Scheme_Object * -do_define_syntaxes_syntax(Scheme_Object *form, Scheme_Comp_Env *env, +do_define_syntaxes_compile(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) { Scheme_Object *names, *code, *dummy; @@ -3244,10 +3242,10 @@ do_define_syntaxes_syntax(Scheme_Object *form, Scheme_Comp_Env *env, } static Scheme_Object * -define_syntaxes_syntax(Scheme_Object *form, Scheme_Comp_Env *env, +define_syntaxes_compile(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) { - return do_define_syntaxes_syntax(form, env, rec, drec); + return do_define_syntaxes_compile(form, env, rec, drec); } static Scheme_Object * @@ -3372,7 +3370,7 @@ begin_for_syntax_expand(Scheme_Object *orig_form, Scheme_Comp_Env *in_env, Schem } static Scheme_Object * -begin_for_syntax_syntax(Scheme_Object *form, Scheme_Comp_Env *env, +begin_for_syntax_compile(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) { return begin_for_syntax_expand(form, env, rec, drec); @@ -3890,7 +3888,7 @@ do_letrec_syntaxes(const char *where, } if (rec[drec].comp) { - v = gen_let_syntax(v, stx_env, "letrec-values", 1, 1, rec, drec, var_env); + v = do_let_compile(v, stx_env, "letrec-values", 1, 1, rec, drec, var_env); } else { if (restore && (rec[drec].env_already == 2)) { /* don't sort out after all, because we're keeping `letrec-values+syntaxes' */ @@ -3922,7 +3920,7 @@ do_letrec_syntaxes(const char *where, } static Scheme_Object * -letrec_syntaxes_syntax(Scheme_Object *form, Scheme_Comp_Env *env, +letrec_syntaxes_compile(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) { return do_letrec_syntaxes("letrec-syntaxes+values", form, env, rec, drec); @@ -3949,7 +3947,7 @@ int scheme_get_eval_type(Scheme_Object *obj) if (type > _scheme_values_types_) return SCHEME_EVAL_CONSTANT; - else if (SAME_TYPE(type, scheme_compiled_local_type) + else if (SAME_TYPE(type, scheme_ir_local_type) || SAME_TYPE(type, scheme_local_type)) return SCHEME_EVAL_LOCAL; else if (SAME_TYPE(type, scheme_local_unbox_type)) @@ -3995,13 +3993,13 @@ Scheme_Object *scheme_try_apply(Scheme_Object *f, Scheme_Object *args, Optimize_ static int foldable_body(Scheme_Object *f) { - Scheme_Closure_Data *d; + Scheme_Lambda *d; - d = SCHEME_COMPILED_CLOS_CODE(f); + d = SCHEME_CLOSURE_CODE(f); scheme_delay_load_closure(d); - return (SCHEME_TYPE(d->code) > _scheme_values_types_); + return (SCHEME_TYPE(d->body) > _scheme_values_types_); } int scheme_is_foldable_prim(Scheme_Object *f) @@ -4033,7 +4031,7 @@ Scheme_Object *scheme_make_application(Scheme_Object *v, Optimize_Info *info) n++; type = SCHEME_TYPE(SCHEME_CAR(o)); - if (type < _scheme_compiled_values_types_) + if (type < _scheme_ir_values_types_) nv = 1; o = SCHEME_CDR(o); } @@ -4573,7 +4571,7 @@ compile_expand_expr(Scheme_Object *form, Scheme_Comp_Env *env, has_orig_unbound = 1; form = find_name; /* in case it was re-mapped */ } else { - if (SAME_TYPE(SCHEME_TYPE(var), scheme_syntax_compiler_type)) { + if (SAME_TYPE(SCHEME_TYPE(var), scheme_primitive_syntax_type)) { if (var == stop_expander) { if (!rec[drec].comp) { SCHEME_EXPAND_OBSERVE_ENTER_PRIM(env->observer,form); @@ -4696,12 +4694,12 @@ compile_expand_expr(Scheme_Object *form, Scheme_Comp_Env *env, /* apply to global variable: compile it normally */ orig_unbound_name = find_name; has_orig_unbound = 1; - } else if (SAME_TYPE(SCHEME_TYPE(var), scheme_compiled_local_type)) { + } else if (SAME_TYPE(SCHEME_TYPE(var), scheme_ir_local_type)) { /* apply to local variable: compile it normally */ } else { if (SAME_TYPE(SCHEME_TYPE(var), scheme_macro_type)) { goto macro; - } else if (SAME_TYPE(SCHEME_TYPE(var), scheme_syntax_compiler_type)) { + } else if (SAME_TYPE(SCHEME_TYPE(var), scheme_primitive_syntax_type)) { if (rec[drec].comp) { Scheme_Syntax *f; f = (Scheme_Syntax *)SCHEME_SYNTAX(var); @@ -4798,7 +4796,7 @@ compile_expand_expr(Scheme_Object *form, Scheme_Comp_Env *env, } if (var && (SAME_TYPE(SCHEME_TYPE(var), scheme_macro_type) - || SAME_TYPE(SCHEME_TYPE(var), scheme_syntax_compiler_type))) { + || SAME_TYPE(SCHEME_TYPE(var), scheme_primitive_syntax_type))) { if (SAME_OBJ(var, stop_expander)) { /* Return original: */ if (!rec[drec].comp) { @@ -4832,7 +4830,7 @@ compile_expand_expr(Scheme_Object *form, Scheme_Comp_Env *env, } } - if (SAME_TYPE(SCHEME_TYPE(var), scheme_syntax_compiler_type)) { + if (SAME_TYPE(SCHEME_TYPE(var), scheme_primitive_syntax_type)) { if (rec[drec].comp) { Scheme_Syntax *f; f = (Scheme_Syntax *)SCHEME_SYNTAX(var); @@ -5195,7 +5193,7 @@ compile_expand_app(Scheme_Object *orig_form, Scheme_Comp_Env *env, } static Scheme_Object * -app_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) +app_compile(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) { return compile_expand_app(form, env, rec, drec); } @@ -5208,7 +5206,7 @@ app_expand(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Expand_Info *erec, } static Scheme_Object * -datum_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) +datum_compile(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) { Scheme_Object *c, *v; @@ -5341,7 +5339,7 @@ static Scheme_Object *check_top(Scheme_Object *orig_form, } static Scheme_Object * -top_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) +top_compile(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) { Scheme_Object *c, *b; int need_bound_check = 0; @@ -6165,8 +6163,8 @@ scheme_flatten_begin(Scheme_Object *expr, Scheme_Object *append_onto) /* stop expander */ /**********************************************************************/ -static Scheme_Object *stop_syntax(Scheme_Object *form, Scheme_Comp_Env *env, - Scheme_Compile_Info *rec, int drec) +static Scheme_Object *stop_compile(Scheme_Object *form, Scheme_Comp_Env *env, + Scheme_Compile_Info *rec, int drec) { scheme_signal_error("internal error: shouldn't get to stop syntax"); return NULL; @@ -6202,6 +6200,7 @@ START_XFORM_SKIP; static void register_traversers(void) { + GC_REG_TRAV(scheme_rt_ir_lambda_info, mark_ir_lambda_info); } END_XFORM_SKIP; diff --git a/racket/src/racket/src/error.c b/racket/src/racket/src/error.c index 21f7ddbca1..7549a65653 100644 --- a/racket/src/racket/src/error.c +++ b/racket/src/racket/src/error.c @@ -1375,12 +1375,12 @@ void scheme_wrong_count_m(const char *name, int minc, int maxc, if (minc == -1) { /* Extract arity, check for is_method in case-lambda, etc. */ if (SAME_TYPE(SCHEME_TYPE((Scheme_Object *)name), scheme_closure_type)) { - Scheme_Closure_Data *data; - data = SCHEME_COMPILED_CLOS_CODE((Scheme_Object *)name); + Scheme_Lambda *data; + data = SCHEME_CLOSURE_CODE((Scheme_Object *)name); name = scheme_get_proc_name((Scheme_Object *)name, NULL, 1); minc = data->num_params; - if (SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_HAS_REST) { + if (SCHEME_LAMBDA_FLAGS(data) & LAMBDA_HAS_REST) { minc -= 1; maxc = -1; } else @@ -1388,9 +1388,9 @@ void scheme_wrong_count_m(const char *name, int minc, int maxc, } else if (SAME_TYPE(SCHEME_TYPE((Scheme_Object *)name), scheme_case_closure_type)) { Scheme_Case_Lambda *cl = (Scheme_Case_Lambda *)name; if (cl->count) { - Scheme_Closure_Data *data; - data = (Scheme_Closure_Data *)SCHEME_COMPILED_CLOS_CODE(cl->array[0]); - if (SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_IS_METHOD) + Scheme_Lambda *data; + data = (Scheme_Lambda *)SCHEME_CLOSURE_CODE(cl->array[0]); + if (SCHEME_LAMBDA_FLAGS(data) & LAMBDA_IS_METHOD) is_method = 1; } else if (cl->name && SCHEME_BOXP(cl->name)) { /* See note in schpriv.h about the IS_METHOD hack */ @@ -1527,11 +1527,11 @@ char *scheme_make_arity_expect_string(const char *map_name, mina = -1; maxa = 0; } else { - Scheme_Closure_Data *data; + Scheme_Lambda *data; - data = (Scheme_Closure_Data *)SCHEME_COMPILED_CLOS_CODE(proc); + data = (Scheme_Lambda *)SCHEME_CLOSURE_CODE(proc); mina = maxa = data->num_params; - if (SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_HAS_REST) { + if (SCHEME_LAMBDA_FLAGS(data) & LAMBDA_HAS_REST) { --mina; maxa = -1; } diff --git a/racket/src/racket/src/eval.c b/racket/src/racket/src/eval.c index 857b30609f..eb8a6b49f8 100644 --- a/racket/src/racket/src/eval.c +++ b/racket/src/racket/src/eval.c @@ -87,10 +87,10 @@ tracks variable usage (including whether a variable is mutated or not). See "compile.c" along with "compenv.c". - The second pass, called "letrec_rec", determines which references + The second pass, called "letrec_check", determines which references to `letrec'-bound variables need to be guarded with a run-time check to prevent use before definition. The analysis result is - reflected by the insertion of `check-notunsafe-undefined` + reflected by the insertion of `check-not-unsafe-undefined` calls. This this pass mutates records produced by the "compile" pass. @@ -134,7 +134,7 @@ forms are converted to native-code generators, instead of bytecode variants. The code is not actually JITted until it is called; this preparation step merely sets up a JIT hook for each function. The - preparation pass is a shallow, function (i.e., it doesn't mutate + preparation pass is a shallow, functional (i.e., it doesn't mutate the original bytecode) pass; the body of a function is prepared for JITting lazily. See "jitprep.c". @@ -2085,7 +2085,7 @@ define_execute_with_dynamic_state(Scheme_Object *vec, int delta, int defmacro, if (SCHEME_TOPLEVEL_FLAGS(var) & SCHEME_TOPLEVEL_SEAL) { int flags = GLOB_IS_IMMUTATED; if (SCHEME_PROCP(vals_expr) - || SAME_TYPE(SCHEME_TYPE(vals_expr), scheme_unclosed_procedure_type) + || SAME_TYPE(SCHEME_TYPE(vals_expr), scheme_lambda_type) || SAME_TYPE(SCHEME_TYPE(vals_expr), scheme_case_lambda_sequence_type) || SAME_TYPE(SCHEME_TYPE(vals_expr), scheme_inline_variant_type)) flags |= GLOB_IS_CONSISTENT; @@ -2243,9 +2243,9 @@ scheme_case_lambda_execute(Scheme_Object *expr) #ifdef MZ_USE_JIT if (seqin->native_code) { - Scheme_Native_Closure_Data *ndata; + Scheme_Native_Lambda *ndata; Scheme_Native_Closure *nc, *na; - Scheme_Closure_Data *data; + Scheme_Lambda *data; Scheme_Object *val; GC_CAN_IGNORE Scheme_Object **runstack; GC_CAN_IGNORE mzshort *map; @@ -2258,7 +2258,7 @@ scheme_case_lambda_execute(Scheme_Object *expr) for (i = 0; i < cnt; i++) { val = seqin->array[i]; if (!SCHEME_PROCP(val)) { - data = (Scheme_Closure_Data *)val; + data = (Scheme_Lambda *)val; na = (Scheme_Native_Closure *)scheme_make_native_closure(data->u.native_code); runstack = MZ_RUNSTACK; jcnt = data->closure_size; @@ -2483,21 +2483,21 @@ scheme_make_closure(Scheme_Thread *p, Scheme_Object *code, int close) time; note that the byte-code marshaller in print.c can handle empty closures for that reason). */ { - Scheme_Closure_Data *data; + Scheme_Lambda *data; Scheme_Closure *closure; GC_CAN_IGNORE Scheme_Object **runstack; GC_CAN_IGNORE Scheme_Object **dest; GC_CAN_IGNORE mzshort *map; int i; - data = (Scheme_Closure_Data *)code; + data = (Scheme_Lambda *)code; #ifdef MZ_USE_JIT if (data->u.native_code - /* If the union points to a another Scheme_Closure_Data*, then it's not actually + /* If the union points to a another Scheme_Lambda*, then it's not actually a pointer to native code. We must have a closure referenced frmo non-JITted code where the closure is also referenced by JITted code. */ - && !SAME_TYPE(SCHEME_TYPE(data->u.native_code), scheme_unclosed_procedure_type)) { + && !SAME_TYPE(SCHEME_TYPE(data->u.native_code), scheme_lambda_type)) { Scheme_Object *nc; nc = scheme_make_native_closure(data->u.native_code); @@ -2525,7 +2525,7 @@ scheme_make_closure(Scheme_Thread *p, Scheme_Object *code, int close) + (i - mzFLEX_DELTA) * sizeof(Scheme_Object *)); closure->so.type = scheme_closure_type; - SCHEME_COMPILED_CLOS_CODE(closure) = data; + SCHEME_CLOSURE_CODE(closure) = data; if (!close || !i) return (Scheme_Object *)closure; @@ -2552,20 +2552,20 @@ Scheme_Closure *scheme_malloc_empty_closure() return cl; } -void scheme_delay_load_closure(Scheme_Closure_Data *data) +void scheme_delay_load_closure(Scheme_Lambda *data) { - if (SCHEME_RPAIRP(data->code)) { + if (SCHEME_RPAIRP(data->body)) { Scheme_Object *v, *vinfo = NULL; - v = SCHEME_CAR(data->code); + v = SCHEME_CAR(data->body); if (SCHEME_VECTORP(v)) { /* Has info for delayed validation */ vinfo = v; v = SCHEME_VEC_ELS(vinfo)[0]; } v = scheme_load_delayed_code(SCHEME_INT_VAL(v), - (struct Scheme_Load_Delay *)SCHEME_CDR(data->code)); - data->code = v; + (struct Scheme_Load_Delay *)SCHEME_CDR(data->body)); + data->body = v; if (vinfo) { scheme_validate_closure(NULL, @@ -2779,13 +2779,13 @@ scheme_do_eval(Scheme_Object *obj, int num_rands, Scheme_Object **rands, DEBUG_CHECK_TYPE(v); } else if (type == scheme_closure_type) { - Scheme_Closure_Data *data; + Scheme_Lambda *data; GC_CAN_IGNORE Scheme_Object **stack, **src; int i, has_rest, num_params; DO_CHECK_FOR_BREAK(p, UPDATE_THREAD_RSPTR_FOR_GC(); if (rands == p->tail_buffer) make_tail_buffer_safe();); - data = SCHEME_COMPILED_CLOS_CODE(obj); + data = SCHEME_CLOSURE_CODE(obj); if ((RUNSTACK - RUNSTACK_START) < data->max_let_depth) { rands = evacuate_runstack(num_rands, rands, RUNSTACK); @@ -2808,7 +2808,7 @@ scheme_do_eval(Scheme_Object *obj, int num_rands, Scheme_Object **rands, } num_params = data->num_params; - has_rest = SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_HAS_REST; + has_rest = SCHEME_LAMBDA_FLAGS(data) & LAMBDA_HAS_REST; if (num_params) { if (has_rest) { @@ -2820,7 +2820,7 @@ scheme_do_eval(Scheme_Object *obj, int num_rands, Scheme_Object **rands, scheme_wrong_count_m((const char *)obj, -1, -1, num_rands, rands, - SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_IS_METHOD); + SCHEME_LAMBDA_FLAGS(data) & LAMBDA_IS_METHOD); return NULL; /* Doesn't get here */ } @@ -2883,7 +2883,7 @@ scheme_do_eval(Scheme_Object *obj, int num_rands, Scheme_Object **rands, scheme_wrong_count_m((const char *)obj, -1, -1, num_rands, rands, - SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_IS_METHOD); + SCHEME_LAMBDA_FLAGS(data) & LAMBDA_IS_METHOD); return NULL; /* Doesn't get here */ } @@ -2919,7 +2919,7 @@ scheme_do_eval(Scheme_Object *obj, int num_rands, Scheme_Object **rands, int n = data->closure_size; if (n) { - src = SCHEME_COMPILED_CLOS_ENV(obj); + src = SCHEME_CLOSURE_ENV(obj); stack = PUSH_RUNSTACK(p, RUNSTACK, n); RUNSTACK_CHANGED(); @@ -2929,13 +2929,13 @@ scheme_do_eval(Scheme_Object *obj, int num_rands, Scheme_Object **rands, } } - obj = data->code; + obj = data->body; if (SCHEME_RPAIRP(obj)) { UPDATE_THREAD_RSPTR_FOR_GC(); make_tail_buffer_safe(); scheme_delay_load_closure(data); - obj = data->code; + obj = data->body; } if (pmstack >= 0) { @@ -2979,16 +2979,16 @@ scheme_do_eval(Scheme_Object *obj, int num_rands, Scheme_Object **rands, goto eval_top; } else if (type == scheme_case_closure_type) { Scheme_Case_Lambda *seq; - Scheme_Closure_Data *data; + Scheme_Lambda *data; int i; seq = (Scheme_Case_Lambda *)obj; for (i = 0; i < seq->count; i++) { - data = SCHEME_COMPILED_CLOS_CODE(seq->array[i]); - if ((!(SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_HAS_REST) + data = SCHEME_CLOSURE_CODE(seq->array[i]); + if ((!(SCHEME_LAMBDA_FLAGS(data) & LAMBDA_HAS_REST) && (data->num_params == num_rands)) - || ((SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_HAS_REST) + || ((SCHEME_LAMBDA_FLAGS(data) & LAMBDA_HAS_REST) && (data->num_params - 1 <= num_rands))) { obj = seq->array[i]; goto apply_top; @@ -3002,7 +3002,7 @@ scheme_do_eval(Scheme_Object *obj, int num_rands, Scheme_Object **rands, return NULL; /* Doesn't get here. */ #ifdef MZ_USE_JIT } else if (type == scheme_native_closure_type) { - GC_CAN_IGNORE Scheme_Native_Closure_Data *data; + GC_CAN_IGNORE Scheme_Native_Lambda *data; VACATE_TAIL_BUFFER_USE_RUNSTACK(); @@ -3552,7 +3552,7 @@ scheme_do_eval(Scheme_Object *obj, int num_rands, Scheme_Object **rands, goto eval_top; } - case scheme_unclosed_procedure_type: + case scheme_lambda_type: UPDATE_THREAD_RSPTR(); v = scheme_make_closure(p, obj, 1); goto returnv_never_multi; @@ -3672,7 +3672,7 @@ scheme_do_eval(Scheme_Object *obj, int num_rands, Scheme_Object **rands, GC_CAN_IGNORE Scheme_Object *clos; GC_CAN_IGNORE Scheme_Object **dest; GC_CAN_IGNORE mzshort *map; - GC_CAN_IGNORE Scheme_Closure_Data *data; + GC_CAN_IGNORE Scheme_Lambda *data; int j; clos = stack[i]; @@ -3687,7 +3687,7 @@ scheme_do_eval(Scheme_Object *obj, int num_rands, Scheme_Object **rands, dest = ((Scheme_Closure *)clos)->vals; #endif - data = (Scheme_Closure_Data *)a[i]; + data = (Scheme_Lambda *)a[i]; map = data->closure_map; j = data->closure_size; @@ -4454,7 +4454,7 @@ static void *eval_k(void) if (as_tail) { /* Cons up a closure to capture the prefix */ - Scheme_Closure_Data *data; + Scheme_Lambda *data; mzshort *map; int i, sz; @@ -4464,13 +4464,13 @@ static void *eval_k(void) map[i] = i; } - data = MALLOC_ONE_TAGGED(Scheme_Closure_Data); - data->iso.so.type = scheme_compiled_unclosed_procedure_type; + data = MALLOC_ONE_TAGGED(Scheme_Lambda); + data->iso.so.type = scheme_ir_lambda_type; data->num_params = 0; data->max_let_depth = top->max_let_depth + sz; data->closure_size = sz; data->closure_map = map; - data->code = v; + data->body = v; v = scheme_make_closure(p, (Scheme_Object *)data, 1); @@ -6159,12 +6159,12 @@ static void mark_pruned_prefixes(struct NewGC *gc) XFORM_SKIP_PROC Scheme_Object *next; if (SCHEME_TYPE(clo) == scheme_closure_type) { Scheme_Closure *cl = (Scheme_Closure *)clo; - int closure_size = ((Scheme_Closure_Data *)GC_resolve2(cl->code, gc))->closure_size; + int closure_size = ((Scheme_Lambda *)GC_resolve2(cl->code, gc))->closure_size; next = cl->vals[closure_size - 1]; cl->vals[closure_size-1] = (Scheme_Object *)pf; } else if (SCHEME_TYPE(clo) == scheme_native_closure_type) { Scheme_Native_Closure *cl = (Scheme_Native_Closure *)clo; - int closure_size = ((Scheme_Native_Closure_Data *)GC_resolve2(cl->code, gc))->closure_size; + int closure_size = ((Scheme_Native_Lambda *)GC_resolve2(cl->code, gc))->closure_size; next = cl->vals[closure_size - 1]; cl->vals[closure_size-1] = (Scheme_Object *)pf; } else { diff --git a/racket/src/racket/src/fun.c b/racket/src/racket/src/fun.c index 5db28692e4..89851494d4 100644 --- a/racket/src/racket/src/fun.c +++ b/racket/src/racket/src/fun.c @@ -76,7 +76,7 @@ SHARED_OK int scheme_defining_primitives; /* set to 1 during start-up */ SHARED_OK int scheme_prim_opt_flags[(1 << SCHEME_PRIM_OPT_INDEX_SIZE)]; READ_ONLY Scheme_Object scheme_void[1]; /* the void constant */ -READ_ONLY Scheme_Object *scheme_values_func; /* the function bound to `values' */ +READ_ONLY Scheme_Object *scheme_values_proc; /* the function bound to `values' */ READ_ONLY Scheme_Object *scheme_procedure_p_proc; READ_ONLY Scheme_Object *scheme_procedure_arity_includes_proc; READ_ONLY Scheme_Object *scheme_procedure_specialize_proc; @@ -309,17 +309,17 @@ scheme_init_fun (Scheme_Env *env) scheme_call_with_values_proc, env); - REGISTER_SO(scheme_values_func); - scheme_values_func = scheme_make_prim_w_arity2(scheme_values, + REGISTER_SO(scheme_values_proc); + scheme_values_proc = scheme_make_prim_w_arity2(scheme_values, "values", 0, -1, 0, -1); - SCHEME_PRIM_PROC_FLAGS(scheme_values_func) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_UNARY_INLINED + SCHEME_PRIM_PROC_FLAGS(scheme_values_proc) |= scheme_intern_prim_opt_flags(SCHEME_PRIM_IS_UNARY_INLINED | SCHEME_PRIM_IS_BINARY_INLINED | SCHEME_PRIM_IS_NARY_INLINED | SCHEME_PRIM_IS_OMITABLE); scheme_add_global_constant("values", - scheme_values_func, + scheme_values_proc, env); o = scheme_make_prim_w_arity2(scheme_call_ec, @@ -2168,7 +2168,7 @@ static Scheme_Object *get_or_check_arity(Scheme_Object *p, intptr_t a, Scheme_Ob } else if ((type == scheme_case_closure_type) || (type == scheme_case_lambda_sequence_type)) { Scheme_Case_Lambda *seq; - Scheme_Closure_Data *data; + Scheme_Lambda *data; int i; Scheme_Object *first, *last = NULL, *v; @@ -2180,12 +2180,12 @@ static Scheme_Object *get_or_check_arity(Scheme_Object *p, intptr_t a, Scheme_Ob seq = (Scheme_Case_Lambda *)p; for (i = 0; i < seq->count; i++) { v = seq->array[i]; - if (SAME_TYPE(SCHEME_TYPE(v), scheme_unclosed_procedure_type)) - data = (Scheme_Closure_Data *)v; + if (SAME_TYPE(SCHEME_TYPE(v), scheme_lambda_type)) + data = (Scheme_Lambda *)v; else - data = SCHEME_COMPILED_CLOS_CODE(v); + data = SCHEME_CLOSURE_CODE(v); mina = maxa = data->num_params; - if (SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_HAS_REST) { + if (SCHEME_LAMBDA_FLAGS(data) & LAMBDA_HAS_REST) { if (mina) --mina; maxa = -1; @@ -2376,15 +2376,15 @@ static Scheme_Object *get_or_check_arity(Scheme_Object *p, intptr_t a, Scheme_Ob SCHEME_USE_FUEL(1); goto top; } else { - Scheme_Closure_Data *data; + Scheme_Lambda *data; - if (type == scheme_unclosed_procedure_type) - data = (Scheme_Closure_Data *)p; + if (type == scheme_lambda_type) + data = (Scheme_Lambda *)p; else - data = SCHEME_COMPILED_CLOS_CODE(p); + data = SCHEME_CLOSURE_CODE(p); mina = maxa = data->num_params; - if (SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_HAS_REST) { + if (SCHEME_LAMBDA_FLAGS(data) & LAMBDA_HAS_REST) { if (mina) --mina; maxa = -1; @@ -2544,7 +2544,7 @@ int scheme_check_proc_arity(const char *where, int a, int scheme_closure_preserves_marks(Scheme_Object *p) { Scheme_Type type = SCHEME_TYPE(p); - Scheme_Closure_Data *data; + Scheme_Lambda *data; #ifdef MZ_USE_JIT if (type == scheme_native_closure_type) @@ -2552,13 +2552,13 @@ int scheme_closure_preserves_marks(Scheme_Object *p) #endif if (type == scheme_closure_type) { - data = SCHEME_COMPILED_CLOS_CODE(p); - } else if (type == scheme_unclosed_procedure_type) { - data = (Scheme_Closure_Data *)p; + data = SCHEME_CLOSURE_CODE(p); + } else if (type == scheme_lambda_type) { + data = (Scheme_Lambda *)p; } else return 0; - if (SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_PRESERVES_MARKS) + if (SCHEME_LAMBDA_FLAGS(data) & LAMBDA_PRESERVES_MARKS) return 1; return 0; @@ -2826,23 +2826,23 @@ const char *scheme_get_proc_name(Scheme_Object *p, int *len, int for_error) } else { Scheme_Object *name; - if (type == scheme_compiled_unclosed_procedure_type) { - name = ((Scheme_Closure_Data *)p)->name; + if (type == scheme_ir_lambda_type) { + name = ((Scheme_Lambda *)p)->name; } else if (type == scheme_closure_type) { - name = SCHEME_COMPILED_CLOS_CODE(p)->name; + name = SCHEME_CLOSURE_CODE(p)->name; } else if (type == scheme_case_lambda_sequence_type) { Scheme_Case_Lambda *cl = (Scheme_Case_Lambda *)p; if (!cl->count) name = NULL; else - name = ((Scheme_Closure_Data *)cl->array[0])->name; + name = ((Scheme_Lambda *)cl->array[0])->name; } else { /* Native closure: */ name = ((Scheme_Native_Closure *)p)->code->u2.name; - if (name && SAME_TYPE(SCHEME_TYPE(name), scheme_unclosed_procedure_type)) { + if (name && SAME_TYPE(SCHEME_TYPE(name), scheme_lambda_type)) { /* Not yet jitted. Use `name' as the other alternaive of the union: */ - name = ((Scheme_Closure_Data *)name)->name; + name = ((Scheme_Lambda *)name)->name; } } @@ -2916,7 +2916,7 @@ static Scheme_Object *procedure_result_arity(int argc, Scheme_Object *argv[]) } if (SAME_TYPE(SCHEME_TYPE(o), scheme_closure_type)) { - if ((SCHEME_CLOSURE_DATA_FLAGS(SCHEME_COMPILED_CLOS_CODE(o)) & CLOS_SINGLE_RESULT)) { + if ((SCHEME_LAMBDA_FLAGS(SCHEME_CLOSURE_CODE(o)) & LAMBDA_SINGLE_RESULT)) { return scheme_make_integer(1); } #ifdef MZ_USE_JIT @@ -2929,7 +2929,7 @@ static Scheme_Object *procedure_result_arity(int argc, Scheme_Object *argv[]) int i; for (i = cl->count; i--; ) { - if (!(SCHEME_CLOSURE_DATA_FLAGS(SCHEME_COMPILED_CLOS_CODE(cl->array[i])) & CLOS_SINGLE_RESULT)) + if (!(SCHEME_LAMBDA_FLAGS(SCHEME_CLOSURE_CODE(cl->array[i])) & LAMBDA_SINGLE_RESULT)) break; } @@ -3313,7 +3313,7 @@ static int proc_is_method(Scheme_Object *proc) } if (SAME_TYPE(SCHEME_TYPE(proc), scheme_closure_type)) { - return ((SCHEME_CLOSURE_DATA_FLAGS(SCHEME_COMPILED_CLOS_CODE(proc)) & CLOS_IS_METHOD) + return ((SCHEME_LAMBDA_FLAGS(SCHEME_CLOSURE_CODE(proc)) & LAMBDA_IS_METHOD) ? 1 : 0); } @@ -3513,16 +3513,16 @@ static Scheme_Object *procedure_specialize(int argc, Scheme_Object *argv[]) if (SAME_TYPE(SCHEME_TYPE(argv[0]), scheme_native_closure_type)) { Scheme_Native_Closure *nc = (Scheme_Native_Closure *)argv[0]; if ((nc->code->start_code == scheme_on_demand_jit_code) - && !(SCHEME_NATIVE_CLOSURE_DATA_FLAGS(nc->code) & NATIVE_SPECIALIZED)) { - Scheme_Native_Closure_Data *data; + && !(SCHEME_NATIVE_LAMBDA_FLAGS(nc->code) & NATIVE_SPECIALIZED)) { + Scheme_Native_Lambda *data; if (!nc->code->eq_key) { void *p; p = scheme_malloc_atomic(sizeof(int)); nc->code->eq_key = p; } - data = MALLOC_ONE_TAGGED(Scheme_Native_Closure_Data); - memcpy(data, nc->code, sizeof(Scheme_Native_Closure_Data)); - SCHEME_NATIVE_CLOSURE_DATA_FLAGS(data) |= NATIVE_SPECIALIZED; + data = MALLOC_ONE_TAGGED(Scheme_Native_Lambda); + memcpy(data, nc->code, sizeof(Scheme_Native_Lambda)); + SCHEME_NATIVE_LAMBDA_FLAGS(data) |= NATIVE_SPECIALIZED; nc->code = data; } } @@ -3714,7 +3714,7 @@ static Scheme_Object *do_apply_chaperone(Scheme_Object *o, int argc, Scheme_Obje static Scheme_Object *_apply_native(Scheme_Object *obj, int num_rands, Scheme_Object **rands) { - Scheme_Native_Closure_Data *data; + Scheme_Native_Lambda *data; GC_MAYBE_IGNORE_INTERIOR MZ_MARK_STACK_TYPE old_cont_mark_stack; GC_MAYBE_IGNORE_INTERIOR Scheme_Object **rs; @@ -6335,7 +6335,7 @@ internal_call_cc (int argc, Scheme_Object *argv[]) cc_guard = get_set_cont_mark_by_pos(prompt_cc_guard_key, p, mc, pos, NULL); if (SCHEME_FALSEP(cc_guard)) - cc_guard = scheme_values_func; + cc_guard = scheme_values_proc; if (SCHEME_NP_CHAPERONEP(cont->prompt_tag)) cc_guard = chaperone_wrap_cc_guard(cont->prompt_tag, cc_guard); @@ -6968,7 +6968,7 @@ static Scheme_Object **chaperone_do_control(const char *name, int mode, if (init_guard || !SCHEME_PROMPT_TAGP(obj)) { if (init_guard) { proc = init_guard; - if (SAME_OBJ(NULL, scheme_values_func)) + if (SAME_OBJ(NULL, scheme_values_proc)) proc = NULL; px = NULL; } else { @@ -7333,7 +7333,7 @@ static Scheme_Object *call_with_prompt (int in_argc, Scheme_Object *in_argv[]) argv = chaperone_do_prompt_handler(chaperone, argc, argv); } - if (SAME_OBJ(handler, scheme_values_func)) { + if (SAME_OBJ(handler, scheme_values_proc)) { v = scheme_values(argc, argv); if (v == SCHEME_MULTIPLE_VALUES) { if (SAME_OBJ(p->ku.multiple.array, p->values_buffer)) @@ -7412,7 +7412,7 @@ static Scheme_Object *call_with_prompt (int in_argc, Scheme_Object *in_argv[]) if (handler) { return _scheme_tail_apply(handler, argc, argv); } else if (cc_guard) { - if (SAME_OBJ(cc_guard, scheme_values_func)) + if (SAME_OBJ(cc_guard, scheme_values_proc)) cc_guard = NULL; if (cc_guard || chaperone) return do_cc_guard(v, cc_guard, chaperone); @@ -10416,7 +10416,6 @@ START_XFORM_SKIP; static void register_traversers(void) { - GC_REG_TRAV(scheme_rt_closure_info, mark_closure_info); GC_REG_TRAV(scheme_rt_dyn_wind_cell, mark_dyn_wind_cell); GC_REG_TRAV(scheme_rt_dyn_wind_info, mark_dyn_wind_info); GC_REG_TRAV(scheme_cont_mark_chain_type, mark_cont_mark_chain); diff --git a/racket/src/racket/src/future.c b/racket/src/racket/src/future.c index 46342ecfb1..89fa774d82 100644 --- a/racket/src/racket/src/future.c +++ b/racket/src/racket/src/future.c @@ -1291,7 +1291,7 @@ static Scheme_Object *make_future(Scheme_Object *lambda, int enqueue, future_t * int futureid; future_t *ft; Scheme_Native_Closure *nc; - Scheme_Native_Closure_Data *ncd; + Scheme_Native_Lambda *ncd; Scheme_Custodian *c; if (SAME_TYPE(SCHEME_TYPE(lambda), scheme_native_closure_type)) { diff --git a/racket/src/racket/src/future.h b/racket/src/racket/src/future.h index 16d4ff3015..0e78d93fd0 100644 --- a/racket/src/racket/src/future.h +++ b/racket/src/racket/src/future.h @@ -155,7 +155,7 @@ typedef struct future_t { int arg_i0; intptr_t arg_l0; size_t arg_z0; - Scheme_Native_Closure_Data *arg_n0; + Scheme_Native_Lambda *arg_n0; Scheme_Object *arg_s1; const Scheme_Object *arg_t1; Scheme_Object **arg_S1; diff --git a/racket/src/racket/src/gen-jit-ts.rkt b/racket/src/racket/src/gen-jit-ts.rkt index f6cb5f6174..36bd02ef25 100644 --- a/racket/src/racket/src/gen-jit-ts.rkt +++ b/racket/src/racket/src/gen-jit-ts.rkt @@ -7,7 +7,7 @@ [(#\t) "const Scheme_Object*"] [(#\S) "Scheme_Object**"] [(#\b) "Scheme_Bucket*"] - [(#\n) "Scheme_Native_Closure_Data*"] + [(#\n) "Scheme_Native_Lambda*"] [(#\m) "MZ_MARK_STACK_TYPE"] [(#\p) "void*"] [(#\i) "int"] diff --git a/racket/src/racket/src/jit.c b/racket/src/racket/src/jit.c index bfae0ff5ce..04569951ef 100644 --- a/racket/src/racket/src/jit.c +++ b/racket/src/racket/src/jit.c @@ -32,19 +32,19 @@ static void register_traversers(void); #endif -static void generate_case_lambda(Scheme_Case_Lambda *c, Scheme_Native_Closure_Data *ndata, int is_method); +static void generate_case_lambda(Scheme_Case_Lambda *c, Scheme_Native_Lambda *nlam, int is_method); static void *generate_lambda_simple_arity_check(int num_params, int has_rest, int is_method, int permanent); int scheme_generate_non_tail_mark_pos_prefix(mz_jit_state *jitter); void scheme_generate_non_tail_mark_pos_suffix(mz_jit_state *jitter); -static int lambda_has_been_jitted(Scheme_Native_Closure_Data *ndata); +static int lambda_has_been_jitted(Scheme_Native_Lambda *nlam); void scheme_jit_fill_threadlocal_table(); typedef struct { - Scheme_Native_Closure_Data nc; - Scheme_Native_Closure_Data *case_lam; -} Scheme_Native_Closure_Data_Plus_Case; + Scheme_Native_Lambda nc; + Scheme_Native_Lambda *case_lam; +} Scheme_Native_Lambda_Plus_Case; static Scheme_Object *make_global_ref(Scheme_Object *var, Scheme_Object *dummy) { @@ -72,7 +72,7 @@ static Scheme_Object *make_global_const_ref(Scheme_Object *var, Scheme_Object *d /* run time */ /*========================================================================*/ -static MZ_INLINE Scheme_Object *do_make_native_closure(Scheme_Native_Closure_Data *code, int size) +static MZ_INLINE Scheme_Object *do_make_native_closure(Scheme_Native_Lambda *code, int size) { Scheme_Native_Closure *o; @@ -84,12 +84,12 @@ static MZ_INLINE Scheme_Object *do_make_native_closure(Scheme_Native_Closure_Dat return (Scheme_Object *)o; } -Scheme_Object *scheme_make_native_closure(Scheme_Native_Closure_Data *code) +Scheme_Object *scheme_make_native_closure(Scheme_Native_Lambda *code) { return do_make_native_closure(code, code->closure_size); } -Scheme_Object *scheme_make_native_case_closure(Scheme_Native_Closure_Data *code) +Scheme_Object *scheme_make_native_case_closure(Scheme_Native_Lambda *code) { return do_make_native_closure(code, -(code->closure_size + 1)); } @@ -333,23 +333,23 @@ Scheme_Object *scheme_apply_lightweight_continuation_stack(Scheme_Current_LWC *l /*========================================================================*/ #ifdef USE_FLONUM_UNBOXING -int scheme_jit_check_closure_flonum_bit(Scheme_Closure_Data *data, int pos, int delta) +int scheme_jit_check_closure_flonum_bit(Scheme_Lambda *lam, int pos, int delta) { int ct; pos += delta; - ct = scheme_boxmap_get(data->closure_map, pos, data->closure_size); - if (ct == (CLOS_TYPE_TYPE_OFFSET + SCHEME_LOCAL_TYPE_FLONUM)) + ct = scheme_boxmap_get(lam->closure_map, pos, lam->closure_size); + if (ct == (LAMBDA_TYPE_TYPE_OFFSET + SCHEME_LOCAL_TYPE_FLONUM)) return 1; else return 0; } -int scheme_jit_check_closure_extflonum_bit(Scheme_Closure_Data *data, int pos, int delta) +int scheme_jit_check_closure_extflonum_bit(Scheme_Lambda *lam, int pos, int delta) { #ifdef MZ_LONG_DOUBLE int ct; pos += delta; - ct = scheme_boxmap_get(data->closure_map, pos, data->closure_size); - if (ct == (CLOS_TYPE_TYPE_OFFSET + SCHEME_LOCAL_TYPE_EXTFLONUM)) + ct = scheme_boxmap_get(lam->closure_map, pos, lam->closure_size); + if (ct == (LAMBDA_TYPE_TYPE_OFFSET + SCHEME_LOCAL_TYPE_EXTFLONUM)) return 1; else return 0; @@ -423,7 +423,7 @@ static int is_short(Scheme_Object *obj, int fuel) case scheme_quote_syntax_type: case scheme_local_type: case scheme_local_unbox_type: - case scheme_unclosed_procedure_type: + case scheme_lambda_type: return fuel - 1; default: if (t > _scheme_values_types_) @@ -485,7 +485,7 @@ static Scheme_Object *extract_closure_local(int pos, mz_jit_state *jitter, int g if (pos < jitter->nc->code->u2.orig_code->closure_size) { /* in the closure */ if (!get_constant - || (SCHEME_NATIVE_CLOSURE_DATA_FLAGS(jitter->nc->code) & NATIVE_SPECIALIZED)) + || (SCHEME_NATIVE_LAMBDA_FLAGS(jitter->nc->code) & NATIVE_SPECIALIZED)) return jitter->nc->vals[pos]; } else if (!get_constant) { /* maybe an example argument... which is useful when @@ -517,7 +517,7 @@ Scheme_Object *scheme_specialize_to_constant(Scheme_Object *obj, mz_jit_state *j if (PAST_LIMIT()) return obj; - if (SCHEME_NATIVE_CLOSURE_DATA_FLAGS(jitter->nc->code) & NATIVE_SPECIALIZED) { + if (SCHEME_NATIVE_LAMBDA_FLAGS(jitter->nc->code) & NATIVE_SPECIALIZED) { if (SAME_TYPE(SCHEME_TYPE(obj), scheme_local_type)) { c = scheme_extract_closure_local(obj, jitter, extra_push, 1); if (c) { @@ -541,14 +541,14 @@ Scheme_Object *scheme_specialize_to_constant(Scheme_Object *obj, mz_jit_state *j int scheme_native_closure_preserves_marks(Scheme_Object *p) { - Scheme_Native_Closure_Data *ndata = ((Scheme_Native_Closure *)p)->code; + Scheme_Native_Lambda *nlam = ((Scheme_Native_Closure *)p)->code; - if (ndata->closure_size >= 0) { /* not case-lambda */ - if (lambda_has_been_jitted(ndata)) { - if (SCHEME_NATIVE_CLOSURE_DATA_FLAGS(ndata) & NATIVE_PRESERVES_MARKS) + if (nlam->closure_size >= 0) { /* not case-lambda */ + if (lambda_has_been_jitted(nlam)) { + if (SCHEME_NATIVE_LAMBDA_FLAGS(nlam) & NATIVE_PRESERVES_MARKS) return 1; } else { - if (SCHEME_CLOSURE_DATA_FLAGS(ndata->u2.orig_code) & CLOS_PRESERVES_MARKS) + if (SCHEME_LAMBDA_FLAGS(nlam->u2.orig_code) & LAMBDA_PRESERVES_MARKS) return 1; } } @@ -598,10 +598,10 @@ int scheme_is_noncm(Scheme_Object *a, mz_jit_state *jitter, int depth, int stack } if (depth && SAME_TYPE(SCHEME_TYPE(a), scheme_closure_type)) { - Scheme_Closure_Data *data; + Scheme_Lambda *lam; - data = ((Scheme_Closure *)a)->code; - if (SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_PRESERVES_MARKS) + lam = ((Scheme_Closure *)a)->code; + if (SCHEME_LAMBDA_FLAGS(lam) & LAMBDA_PRESERVES_MARKS) return 1; } @@ -670,7 +670,7 @@ int scheme_is_simple(Scheme_Object *obj, int depth, int just_markless, mz_jit_st rator = scheme_specialize_to_constant(((Scheme_App_Rec *)obj)->args[0], jitter, stack_start + ((Scheme_App_Rec *)obj)->num_args); if (scheme_inlined_nary_prim(rator, obj, jitter) - && !SAME_OBJ(rator, scheme_values_func)) + && !SAME_OBJ(rator, scheme_values_proc)) return 1; if (just_markless) { return scheme_is_noncm(rator, jitter, depth, @@ -694,7 +694,7 @@ int scheme_is_simple(Scheme_Object *obj, int depth, int just_markless, mz_jit_st Scheme_Object *rator; rator = scheme_specialize_to_constant(((Scheme_App3_Rec *)obj)->rator, jitter, stack_start + 2); if (scheme_inlined_binary_prim(rator, obj, jitter) - && !SAME_OBJ(rator, scheme_values_func)) + && !SAME_OBJ(rator, scheme_values_proc)) return 1; else if (just_markless) { return scheme_is_noncm(rator, jitter, depth, stack_start + 2); @@ -706,7 +706,7 @@ int scheme_is_simple(Scheme_Object *obj, int depth, int just_markless, mz_jit_st case scheme_quote_syntax_type: case scheme_local_type: case scheme_local_unbox_type: - case scheme_unclosed_procedure_type: + case scheme_lambda_type: return 1; break; } @@ -765,7 +765,7 @@ int scheme_is_non_gc(Scheme_Object *obj, int depth) case scheme_toplevel_type: break; - case scheme_unclosed_procedure_type: + case scheme_lambda_type: break; case scheme_local_type: @@ -792,7 +792,7 @@ static int is_a_procedure(Scheme_Object *v, mz_jit_state *jitter) t = SCHEME_TYPE(v); if (SAME_TYPE(t, scheme_closure_type) - || SAME_TYPE(t, scheme_unclosed_procedure_type)) + || SAME_TYPE(t, scheme_lambda_type)) return 1; else if (SAME_TYPE(t, scheme_case_lambda_sequence_type)) { return 1; @@ -846,7 +846,7 @@ int scheme_can_delay_and_avoids_r1_r2(Scheme_Object *obj) if (SAME_TYPE(t, scheme_local_type) && scheme_ok_to_delay_local(obj)) { return 1; } else - return (t >= _scheme_compiled_values_types_); + return (t >= _scheme_ir_values_types_); } int scheme_can_delay_and_avoids_r1(Scheme_Object *obj) @@ -872,7 +872,7 @@ int scheme_is_constant_and_avoids_r1(Scheme_Object *obj) } else if (SAME_TYPE(t, scheme_local_type) && scheme_ok_to_move_local(obj)) { return 1; } else - return (t >= _scheme_compiled_values_types_); + return (t >= _scheme_ir_values_types_); } static int expression_avoids_clearing_local(Scheme_Object *wrt, int pos, int fuel) @@ -952,16 +952,16 @@ int scheme_needs_only_target_register(Scheme_Object *obj, int and_can_reorder) return 0; return 1; } else - return (t >= _scheme_compiled_values_types_); + return (t >= _scheme_ir_values_types_); } int scheme_native_closure_is_single_result(Scheme_Object *rator) { Scheme_Native_Closure *nc = (Scheme_Native_Closure *)rator; if (nc->code->start_code == scheme_on_demand_jit_code) - return (SCHEME_CLOSURE_DATA_FLAGS(nc->code->u2.orig_code) & CLOS_SINGLE_RESULT); + return (SCHEME_LAMBDA_FLAGS(nc->code->u2.orig_code) & LAMBDA_SINGLE_RESULT); else - return (SCHEME_NATIVE_CLOSURE_DATA_FLAGS(nc->code) & NATIVE_IS_SINGLE_RESULT); + return (SCHEME_NATIVE_LAMBDA_FLAGS(nc->code) & NATIVE_IS_SINGLE_RESULT); } static int produces_single_value(Scheme_Object *rator, int num_args, mz_jit_state *jitter) @@ -978,7 +978,7 @@ static int produces_single_value(Scheme_Object *rator, int num_args, mz_jit_stat return 1; /* special case: (values ) */ - if (SAME_OBJ(rator, scheme_values_func) && (num_args == 1)) + if (SAME_OBJ(rator, scheme_values_proc) && (num_args == 1)) return 1; } @@ -1251,34 +1251,34 @@ int scheme_generate_flonum_local_unboxing(mz_jit_state *jitter, int push, int no static Scheme_Object example_so = { scheme_native_closure_type, 0 }; #endif -static Scheme_Native_Closure_Data *create_native_lambda(Scheme_Closure_Data *data, int clear_code_after_jit, - Scheme_Native_Closure_Data *case_lam); +static Scheme_Native_Lambda *create_native_lambda(Scheme_Lambda *lam, int clear_code_after_jit, + Scheme_Native_Lambda *case_lam); -static void ensure_closure_native(Scheme_Closure_Data *data, - Scheme_Native_Closure_Data *case_lam) +static void ensure_closure_native(Scheme_Lambda *lam, + Scheme_Native_Lambda *case_lam) { - if (!data->u.native_code || SCHEME_FALSEP((Scheme_Object *)data->u.native_code)) { - Scheme_Native_Closure_Data *code; - code = create_native_lambda(data, 0, case_lam); - data->u.native_code = code; + if (!lam->u.native_code || SCHEME_FALSEP((Scheme_Object *)lam->u.native_code)) { + Scheme_Native_Lambda *code; + code = create_native_lambda(lam, 0, case_lam); + lam->u.native_code = code; } } -static int generate_closure(Scheme_Closure_Data *data, +static int generate_closure(Scheme_Lambda *lam, mz_jit_state *jitter, int immediately_filled) { - Scheme_Native_Closure_Data *code; + Scheme_Native_Lambda *code; - ensure_closure_native(data, NULL); - code = data->u.native_code; + ensure_closure_native(lam, NULL); + code = lam->u.native_code; #ifdef JIT_PRECISE_GC - if (data->closure_size < 100) { + if (lam->closure_size < 100) { int sz; intptr_t init_word; sz = (sizeof(Scheme_Native_Closure) - + ((data->closure_size - mzFLEX_DELTA) * sizeof(Scheme_Object *))); + + ((lam->closure_size - mzFLEX_DELTA) * sizeof(Scheme_Object *))); # ifdef CAN_INLINE_ALLOC if (immediately_filled) { /* Inlined alloc */ @@ -1327,20 +1327,20 @@ static int generate_closure(Scheme_Closure_Data *data, return 1; } -static int generate_closure_fill(Scheme_Closure_Data *data, +static int generate_closure_fill(Scheme_Lambda *lam, mz_jit_state *jitter) { /* Fill in closure */ int j, size, pos; mzshort *map; Scheme_Object *v; - size = data->closure_size; - map = data->closure_map; + size = lam->closure_size; + map = lam->closure_map; jit_addi_p(JIT_R2, JIT_R0, &((Scheme_Native_Closure *)0x0)->vals); for (j = 0; j < size; j++) { CHECK_LIMIT(); - if (SCHEME_NATIVE_CLOSURE_DATA_FLAGS(jitter->nc->code) & NATIVE_SPECIALIZED) + if (SCHEME_NATIVE_LAMBDA_FLAGS(jitter->nc->code) & NATIVE_SPECIALIZED) v = extract_closure_local(map[j], jitter, 1); else v = NULL; @@ -1357,7 +1357,7 @@ static int generate_closure_fill(Scheme_Closure_Data *data, return 1; } -static int generate_closure_prep(Scheme_Closure_Data *data, mz_jit_state *jitter) +static int generate_closure_prep(Scheme_Lambda *lam, mz_jit_state *jitter) { int retval = 0; #ifdef USE_FLONUM_UNBOXING @@ -1365,14 +1365,14 @@ static int generate_closure_prep(Scheme_Closure_Data *data, mz_jit_state *jitter int j, size, pos; mzshort *map; - if (SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_HAS_TYPED_ARGS) { - size = data->closure_size; - map = data->closure_map; + if (SCHEME_LAMBDA_FLAGS(lam) & LAMBDA_HAS_TYPED_ARGS) { + size = lam->closure_size; + map = lam->closure_map; for (j = 0; j < size; j++) { - if (CLOSURE_CONTENT_IS_FLONUM(data, j) - || CLOSURE_CONTENT_IS_EXTFLONUM(data, j)) { + if (CLOSURE_CONTENT_IS_FLONUM(lam, j) + || CLOSURE_CONTENT_IS_EXTFLONUM(lam, j)) { int extfl; - extfl = CLOSURE_CONTENT_IS_EXTFLONUM(data, j); + extfl = CLOSURE_CONTENT_IS_EXTFLONUM(lam, j); pos = mz_remap(map[j]); jit_ldxi_p(JIT_R1, JIT_RUNSTACK, WORDS_TO_BYTES(pos)); generate_flonum_local_boxing(jitter, pos, map[j], JIT_R1, extfl); @@ -1386,66 +1386,66 @@ static int generate_closure_prep(Scheme_Closure_Data *data, mz_jit_state *jitter return retval; } -static Scheme_Native_Closure_Data *create_native_case_lambda(Scheme_Case_Lambda *c) +static Scheme_Native_Lambda *create_native_case_lambda(Scheme_Case_Lambda *c) { - Scheme_Closure_Data *data; - Scheme_Native_Closure_Data *ndata; + Scheme_Lambda *lam; + Scheme_Native_Lambda *nlam; Scheme_Object *name, *o; int max_let_depth = 0, i, count, is_method = 0; - ndata = MALLOC_ONE_RT(Scheme_Native_Closure_Data); + nlam = MALLOC_ONE_RT(Scheme_Native_Lambda); #ifdef MZTAG_REQUIRED - ndata->iso.so.type = scheme_rt_native_code; + nlam->iso.so.type = scheme_rt_native_code; #endif name = c->name; if (name && SCHEME_BOXP(name)) { name = SCHEME_BOX_VAL(name); is_method = 1; } - ndata->u2.name = name; + nlam->u2.name = name; count = c->count; for (i = 0; i < count; i++) { o = c->array[i]; if (SCHEME_PROCP(o)) o = (Scheme_Object *)((Scheme_Closure *)o)->code; - data = MALLOC_ONE_TAGGED(Scheme_Closure_Data); - memcpy(data, o, sizeof(Scheme_Closure_Data)); - ensure_closure_native(data, ndata); - if (data->u.native_code->max_let_depth > max_let_depth) - max_let_depth = data->u.native_code->max_let_depth; - c->array[i] = (Scheme_Object *)data; + lam = MALLOC_ONE_TAGGED(Scheme_Lambda); + memcpy(lam, o, sizeof(Scheme_Lambda)); + ensure_closure_native(lam, nlam); + if (lam->u.native_code->max_let_depth > max_let_depth) + max_let_depth = lam->u.native_code->max_let_depth; + c->array[i] = (Scheme_Object *)lam; } - ndata->max_let_depth = max_let_depth; - ndata->closure_size = -(count + 1); /* Indicates case-lambda */ + nlam->max_let_depth = max_let_depth; + nlam->closure_size = -(count + 1); /* Indicates case-lambda */ if (count) { o = c->array[0]; if (SCHEME_PROCP(o)) o = (Scheme_Object *)((Scheme_Closure *)o)->code; - data = (Scheme_Closure_Data *)o; - is_method = ((SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_IS_METHOD) ? 1 : 0); + lam = (Scheme_Lambda *)o; + is_method = ((SCHEME_LAMBDA_FLAGS(lam) & LAMBDA_IS_METHOD) ? 1 : 0); } - generate_case_lambda(c, ndata, is_method); + generate_case_lambda(c, nlam, is_method); - return ndata; + return nlam; } -Scheme_Native_Closure_Data *scheme_generate_case_lambda(Scheme_Case_Lambda *c) +Scheme_Native_Lambda *scheme_generate_case_lambda(Scheme_Case_Lambda *c) { - Scheme_Native_Closure_Data *ndata; + Scheme_Native_Lambda *nlam; - ndata = create_native_case_lambda(c); + nlam = create_native_case_lambda(c); - return ndata; + return nlam; } static void ensure_case_closure_native(Scheme_Case_Lambda *c) { if (!c->native_code || SCHEME_FALSEP((Scheme_Object *)c->native_code)) { - Scheme_Native_Closure_Data *ndata; - ndata = create_native_case_lambda(c); - c->native_code = ndata; + Scheme_Native_Lambda *nlam; + nlam = create_native_case_lambda(c); + c->native_code = nlam; } } @@ -1453,13 +1453,13 @@ static int generate_case_closure(Scheme_Object *obj, mz_jit_state *jitter, int t /* de-sync's */ { Scheme_Case_Lambda *c = (Scheme_Case_Lambda *)obj; - Scheme_Native_Closure_Data *ndata; - Scheme_Closure_Data *data; + Scheme_Native_Lambda *nlam; + Scheme_Lambda *lam; Scheme_Object *o; int i, offset, count; ensure_case_closure_native(c); - ndata = c->native_code; + nlam = c->native_code; count = c->count; @@ -1467,10 +1467,10 @@ static int generate_case_closure(Scheme_Object *obj, mz_jit_state *jitter, int t o = c->array[i]; if (SCHEME_PROCP(o)) o = (Scheme_Object *)((Scheme_Closure *)o)->code; - data = (Scheme_Closure_Data *)o; + lam = (Scheme_Lambda *)o; mz_rs_sync(); CHECK_LIMIT(); - generate_closure_prep(data, jitter); + generate_closure_prep(lam, jitter); CHECK_LIMIT(); } @@ -1478,7 +1478,7 @@ static int generate_case_closure(Scheme_Object *obj, mz_jit_state *jitter, int t JIT_UPDATE_THREAD_RSPTR_IF_NEEDED(); mz_prepare(1); - scheme_mz_load_retained(jitter, JIT_R0, ndata); + scheme_mz_load_retained(jitter, JIT_R0, nlam); jit_pusharg_p(JIT_R0); { GC_CAN_IGNORE jit_insn *refr USED_ONLY_FOR_FUTURES; @@ -1491,12 +1491,12 @@ static int generate_case_closure(Scheme_Object *obj, mz_jit_state *jitter, int t o = c->array[i]; if (SCHEME_PROCP(o)) o = (Scheme_Object *)((Scheme_Closure *)o)->code; - data = (Scheme_Closure_Data *)o; + lam = (Scheme_Lambda *)o; mz_pushr_p(JIT_R1); mz_rs_sync(); - generate_closure(data, jitter, 1); + generate_closure(lam, jitter, 1); CHECK_LIMIT(); - generate_closure_fill(data, jitter); + generate_closure_fill(lam, jitter); CHECK_LIMIT(); mz_popr_p(JIT_R1); offset = WORDS_TO_BYTES(i) + (uintptr_t)&((Scheme_Native_Closure *)0x0)->vals; @@ -1793,8 +1793,8 @@ static int generate_branch(Scheme_Object *obj, mz_jit_state *jitter, int is_tail can_chain_branch = 1; else can_chain_branch = 0; - chain_true = (SCHEME_TYPE(branch->tbranch) > _scheme_compiled_values_types_); - chain_false = (SCHEME_TYPE(branch->fbranch) > _scheme_compiled_values_types_); + chain_true = (SCHEME_TYPE(branch->tbranch) > _scheme_ir_values_types_); + chain_false = (SCHEME_TYPE(branch->fbranch) > _scheme_ir_values_types_); if (can_chain_branch && chain_true) for_this_branch.true_needs_jump = 1; @@ -1808,7 +1808,7 @@ static int generate_branch(Scheme_Object *obj, mz_jit_state *jitter, int is_tail LOG_IT(("if...\n")); if (result_ignored - && (SCHEME_TYPE(branch->fbranch) > _scheme_compiled_values_types_)) + && (SCHEME_TYPE(branch->fbranch) > _scheme_ir_values_types_)) else_is_empty = 1; else if (can_chain_branch && chain_false) else_is_empty = 1; @@ -2094,7 +2094,7 @@ int scheme_generate(Scheme_Object *obj, mz_jit_state *jitter, int is_tail, int w START_JIT_DATA(); LOG_IT(("top-level\n")); mz_rs_sync_fail_branch(); - if (SCHEME_NATIVE_CLOSURE_DATA_FLAGS(jitter->nc->code) & NATIVE_SPECIALIZED) { + if (SCHEME_NATIVE_LAMBDA_FLAGS(jitter->nc->code) & NATIVE_SPECIALIZED) { /* Must be a top-level that is not yet defined. */ Scheme_Object *b; mz_rs_sync_fail_branch(); @@ -2212,7 +2212,7 @@ int scheme_generate(Scheme_Object *obj, mz_jit_state *jitter, int is_tail, int w START_JIT_DATA(); LOG_IT(("unbox local\n")); - if (SCHEME_NATIVE_CLOSURE_DATA_FLAGS(jitter->nc->code) & NATIVE_SPECIALIZED) + if (SCHEME_NATIVE_LAMBDA_FLAGS(jitter->nc->code) & NATIVE_SPECIALIZED) specialized = scheme_extract_closure_local(obj, jitter, 0, 1); pos = mz_remap(SCHEME_LOCAL_POS(obj)); @@ -2731,7 +2731,7 @@ int scheme_generate(Scheme_Object *obj, mz_jit_state *jitter, int is_tail, int w LOG_IT(("app %d\n", app->num_args)); if (for_values - && SAME_OBJ(app->args[0], scheme_values_func) + && SAME_OBJ(app->args[0], scheme_values_proc) && (app->num_args == for_values->count)) { int i, pos; @@ -2800,7 +2800,7 @@ int scheme_generate(Scheme_Object *obj, mz_jit_state *jitter, int is_tail, int w int r; if (for_values - && SAME_OBJ(app->rator, scheme_values_func) + && SAME_OBJ(app->rator, scheme_values_proc) && (for_values->count == 2)) { int pos; @@ -2871,9 +2871,9 @@ int scheme_generate(Scheme_Object *obj, mz_jit_state *jitter, int is_tail, int w { return generate_branch(obj, jitter, is_tail, wcm_may_replace, multi_ok, orig_target, result_ignored, for_branch); } - case scheme_unclosed_procedure_type: + case scheme_lambda_type: { - Scheme_Closure_Data *data = (Scheme_Closure_Data *)obj; + Scheme_Lambda *lam = (Scheme_Lambda *)obj; START_JIT_DATA(); LOG_IT(("lambda\n")); @@ -2883,14 +2883,14 @@ int scheme_generate(Scheme_Object *obj, mz_jit_state *jitter, int is_tail, int w else { mz_rs_sync(); - generate_closure_prep(data, jitter); + generate_closure_prep(lam, jitter); CHECK_LIMIT(); /* Allocate closure */ - generate_closure(data, jitter, 1); + generate_closure(lam, jitter, 1); CHECK_LIMIT(); - generate_closure_fill(data, jitter); + generate_closure_fill(lam, jitter); CHECK_LIMIT(); if (target != JIT_R0) @@ -2915,7 +2915,7 @@ int scheme_generate(Scheme_Object *obj, mz_jit_state *jitter, int is_tail, int w if (lv->count == 1) { /* Expect one result: */ Scheme_Object *specialized = NULL; - if (SCHEME_NATIVE_CLOSURE_DATA_FLAGS(jitter->nc->code) & NATIVE_SPECIALIZED) + if (SCHEME_NATIVE_LAMBDA_FLAGS(jitter->nc->code) & NATIVE_SPECIALIZED) specialized = extract_closure_local(lv->position, jitter, 1); scheme_generate_non_tail(lv->value, jitter, 0, 1, 0); /* no sync */ CHECK_LIMIT(); @@ -3084,15 +3084,15 @@ int scheme_generate(Scheme_Object *obj, mz_jit_state *jitter, int is_tail, int w /* Box any unboxed values that will go into a closure */ for (i = 0; i < l->count; i++) { - if (generate_closure_prep((Scheme_Closure_Data *)l->procs[i], jitter)) + if (generate_closure_prep((Scheme_Lambda *)l->procs[i], jitter)) prepped = 1; CHECK_LIMIT(); } /* Create unfinished closures */ for (i = 0; i < l->count; i++) { - ((Scheme_Closure_Data *)l->procs[i])->context = (Scheme_Object *)l; - generate_closure((Scheme_Closure_Data *)l->procs[i], jitter, i + 1 == l->count); + ((Scheme_Lambda *)l->procs[i])->context = (Scheme_Object *)l; + generate_closure((Scheme_Lambda *)l->procs[i], jitter, i + 1 == l->count); CHECK_LIMIT(); jit_stxi_p(WORDS_TO_BYTES(i), JIT_RUNSTACK, JIT_R0); } @@ -3106,7 +3106,7 @@ int scheme_generate(Scheme_Object *obj, mz_jit_state *jitter, int is_tail, int w if (prepped || (i != l->count - 1)) { jit_ldxi_p(JIT_R0, JIT_RUNSTACK, WORDS_TO_BYTES(i)); } - generate_closure_fill((Scheme_Closure_Data *)l->procs[i], jitter); + generate_closure_fill((Scheme_Lambda *)l->procs[i], jitter); CHECK_LIMIT(); } @@ -3119,16 +3119,16 @@ int scheme_generate(Scheme_Object *obj, mz_jit_state *jitter, int is_tail, int w if (mz_try_runstack_pop(jitter, l->count)) { int i; for (i = l->count; i--; ) { - Scheme_Closure_Data *data2 = (Scheme_Closure_Data *)l->procs[i]; + Scheme_Lambda *lam2 = (Scheme_Lambda *)l->procs[i]; mz_runstack_closure_pushed(jitter, - (data2->num_params - - ((SCHEME_CLOSURE_DATA_FLAGS(data2) & CLOS_HAS_REST) + (lam2->num_params + - ((SCHEME_LAMBDA_FLAGS(lam2) & LAMBDA_HAS_REST) ? 1 : 0)), - (((SCHEME_CLOSURE_DATA_FLAGS(data2) & CLOS_PRESERVES_MARKS) + (((SCHEME_LAMBDA_FLAGS(lam2) & LAMBDA_PRESERVES_MARKS) ? NATIVE_PRESERVES_MARKS : 0) - | ((SCHEME_CLOSURE_DATA_FLAGS(data2) & CLOS_SINGLE_RESULT) + | ((SCHEME_LAMBDA_FLAGS(lam2) & LAMBDA_SINGLE_RESULT) ? NATIVE_IS_SINGLE_RESULT : 0))); } @@ -3304,7 +3304,7 @@ int scheme_generate(Scheme_Object *obj, mz_jit_state *jitter, int is_tail, int w mz_rs_sync(); - if (SCHEME_NATIVE_CLOSURE_DATA_FLAGS(jitter->nc->code) & NATIVE_SPECIALIZED) { + if (SCHEME_NATIVE_LAMBDA_FLAGS(jitter->nc->code) & NATIVE_SPECIALIZED) { Scheme_Object *stx; stx = extract_syntax(qs, jitter->nc); scheme_mz_load_retained(jitter, target, stx); @@ -3396,7 +3396,7 @@ int scheme_generate(Scheme_Object *obj, mz_jit_state *jitter, int is_tail, int w into an expression: */ int i; obj = scheme_jit_closure((Scheme_Object *)c->code, NULL); - obj = scheme_make_native_closure(((Scheme_Closure_Data *)obj)->u.native_code); + obj = scheme_make_native_closure(((Scheme_Lambda *)obj)->u.native_code); for (i = c->code->closure_size; i--; ) { ((Scheme_Native_Closure *)obj)->vals[i] = c->vals[i]; } @@ -3528,7 +3528,7 @@ static int generate_function_getarg(mz_jit_state *jitter, int has_rest, int num_ } typedef struct { - Scheme_Closure_Data *data; + Scheme_Lambda *lam; void *arity_code, *start_code, *tail_code, *code_end, **patch_depth; int max_extra, max_depth, max_tail_depth; Scheme_Native_Closure *nc; @@ -3537,12 +3537,12 @@ typedef struct { #ifdef NEED_RETAIN_CODE_POINTERS void *retain_code; #endif -} Generate_Closure_Data; +} Generate_Lambda; static int do_generate_closure(mz_jit_state *jitter, void *_data) { - Generate_Closure_Data *gdata = (Generate_Closure_Data *)_data; - Scheme_Closure_Data *data = gdata->data; + Generate_Lambda *gdata = (Generate_Lambda *)_data; + Scheme_Lambda *lam = gdata->lam; void *start_code, *tail_code, *code_end, *arity_code, *do_arity_code; #ifdef NEED_RETAIN_CODE_POINTERS void *retain_code = NULL; @@ -3563,8 +3563,8 @@ static int do_generate_closure(mz_jit_state *jitter, void *_data) CHECK_LIMIT(); cnt = generate_function_getarg(jitter, - (SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_HAS_REST), - data->num_params); + (SCHEME_LAMBDA_FLAGS(lam) & LAMBDA_HAS_REST), + lam->num_params); /* At this point, all non-rest arguments are now at the runstack */ CHECK_LIMIT(); @@ -3572,9 +3572,9 @@ static int do_generate_closure(mz_jit_state *jitter, void *_data) (This is a little reundant checking when `start_code' is the entry point, but that's the slow path anyway.) */ - has_rest = ((SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_HAS_REST) ? 1 : 0); - is_method = ((SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_IS_METHOD) ? 1 : 0); - num_params = data->num_params; + has_rest = ((SCHEME_LAMBDA_FLAGS(lam) & LAMBDA_HAS_REST) ? 1 : 0); + is_method = ((SCHEME_LAMBDA_FLAGS(lam) & LAMBDA_IS_METHOD) ? 1 : 0); + num_params = lam->num_params; if (num_params && has_rest) --num_params; @@ -3619,7 +3619,7 @@ static int do_generate_closure(mz_jit_state *jitter, void *_data) so accept any number of arguments and just clear them (for space safety). */ - if (has_rest && data->num_params) { + if (has_rest && lam->num_params) { /* If runstack == argv and argc == cnt, then we didn't copy args down, and we need to make room for scheme_null. */ GC_CAN_IGNORE jit_insn *ref, *ref2, *ref3; @@ -3653,7 +3653,7 @@ static int do_generate_closure(mz_jit_state *jitter, void *_data) jit_movi_i(JIT_V1, cnt); mz_set_local_p(JIT_V1, JIT_LOCAL3); mz_rs_sync(); - if ((SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_NEED_REST_CLEAR)) + if ((SCHEME_LAMBDA_FLAGS(lam) & LAMBDA_NEED_REST_CLEAR)) (void)jit_calli(sjc.make_rest_list_clear_code); else (void)jit_calli(sjc.make_rest_list_code); @@ -3664,12 +3664,12 @@ static int do_generate_closure(mz_jit_state *jitter, void *_data) __END_SHORT_JUMPS__(cnt < 100); has_rest = 1; - if (argc < (data->num_params - 1)) { + if (argc < (lam->num_params - 1)) { argv = NULL; argc = 0; } } else { - if (has_rest && (SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_NEED_REST_CLEAR)) { + if (has_rest && (SCHEME_LAMBDA_FLAGS(lam) & LAMBDA_NEED_REST_CLEAR)) { /* if we get here, the rest argument isn't used */ GC_CAN_IGNORE jit_insn *ref; __START_TINY_JUMPS__(1); @@ -3693,7 +3693,7 @@ static int do_generate_closure(mz_jit_state *jitter, void *_data) __END_TINY_JUMPS__(1); } has_rest = 0; - if (argc != data->num_params) { + if (argc != lam->num_params) { argv = NULL; argc = 0; } @@ -3701,7 +3701,7 @@ static int do_generate_closure(mz_jit_state *jitter, void *_data) #ifdef USE_FLONUM_UNBOXING /* Unpack flonum arguments */ - if (SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_HAS_TYPED_ARGS) { + if (SCHEME_LAMBDA_FLAGS(lam) & LAMBDA_HAS_TYPED_ARGS) { GC_CAN_IGNORE jit_insn *zref; int f_offset; @@ -3712,11 +3712,11 @@ static int do_generate_closure(mz_jit_state *jitter, void *_data) jit_subr_p(JIT_R1, JIT_SP, JIT_FP); zref = jit_bnei_l(jit_forward(), JIT_R1, f_offset); - for (i = data->num_params; i--; ) { - if (CLOSURE_ARGUMENT_IS_FLONUM(data, i) - || CLOSURE_ARGUMENT_IS_EXTFLONUM(data, i)) { + for (i = lam->num_params; i--; ) { + if (CLOSURE_ARGUMENT_IS_FLONUM(lam, i) + || CLOSURE_ARGUMENT_IS_EXTFLONUM(lam, i)) { int extfl; - extfl = CLOSURE_ARGUMENT_IS_EXTFLONUM(data, i); + extfl = CLOSURE_ARGUMENT_IS_EXTFLONUM(lam, i); mz_rs_ldxi(JIT_R1, i); MZ_FPUSEL_STMT(extfl, jit_fpu_ldxi_ld_fppush(JIT_FPU_FPR0, JIT_R1, &((Scheme_Long_Double *)0x0)->long_double_val), @@ -3739,7 +3739,7 @@ static int do_generate_closure(mz_jit_state *jitter, void *_data) that the code won't be GCed while we're running it. If the closure is empty, it's ok, faster, and useful to keep it, otherwise keep just the code pointer for space safety. */ - if (!data->closure_size) { + if (!lam->closure_size) { jitter->closure_self_on_runstack = 1; mz_pushr_p(JIT_R0); /* no sync */ } else { @@ -3751,10 +3751,10 @@ static int do_generate_closure(mz_jit_state *jitter, void *_data) to_args = 0; #endif - specialized = SCHEME_NATIVE_CLOSURE_DATA_FLAGS(jitter->nc->code) & NATIVE_SPECIALIZED; + specialized = SCHEME_NATIVE_LAMBDA_FLAGS(jitter->nc->code) & NATIVE_SPECIALIZED; /* Extract closure to runstack: */ - cnt = data->closure_size; + cnt = lam->closure_size; to_args += cnt; if (cnt) { if (specialized) { @@ -3776,34 +3776,34 @@ static int do_generate_closure(mz_jit_state *jitter, void *_data) mz_rs_sync(); /* If we have a letrec context, record arities */ - if (data->context && SAME_TYPE(SCHEME_TYPE(data->context), scheme_letrec_type) && !specialized) { - Scheme_Letrec *lr = (Scheme_Letrec *)data->context; + if (lam->context && SAME_TYPE(SCHEME_TYPE(lam->context), scheme_letrec_type) && !specialized) { + Scheme_Letrec *lr = (Scheme_Letrec *)lam->context; int pos, self_pos = -1; - for (i = data->closure_size; i--; ) { - pos = data->closure_map[i]; + for (i = lam->closure_size; i--; ) { + pos = lam->closure_map[i]; if (pos < lr->count) { - Scheme_Closure_Data *data2 = (Scheme_Closure_Data *)lr->procs[pos]; + Scheme_Lambda *lam2 = (Scheme_Lambda *)lr->procs[pos]; mz_runstack_closure_pushed(jitter, - (data2->num_params - - ((SCHEME_CLOSURE_DATA_FLAGS(data2) & CLOS_HAS_REST) + (lam2->num_params + - ((SCHEME_LAMBDA_FLAGS(lam2) & LAMBDA_HAS_REST) ? 1 : 0)), - (((SCHEME_CLOSURE_DATA_FLAGS(data2) & CLOS_PRESERVES_MARKS) + (((SCHEME_LAMBDA_FLAGS(lam2) & LAMBDA_PRESERVES_MARKS) ? NATIVE_PRESERVES_MARKS : 0) - | ((SCHEME_CLOSURE_DATA_FLAGS(data2) & CLOS_SINGLE_RESULT) + | ((SCHEME_LAMBDA_FLAGS(lam2) & LAMBDA_SINGLE_RESULT) ? NATIVE_IS_SINGLE_RESULT : 0))); - if (SAME_OBJ(lr->procs[pos], (Scheme_Object *)data)) { + if (SAME_OBJ(lr->procs[pos], (Scheme_Object *)lam)) { self_pos = i; } } else { #ifdef USE_FLONUM_UNBOXING - if ((SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_HAS_TYPED_ARGS) - && (CLOSURE_CONTENT_IS_FLONUM(data, i) - || CLOSURE_CONTENT_IS_EXTFLONUM(data, i))) { + if ((SCHEME_LAMBDA_FLAGS(lam) & LAMBDA_HAS_TYPED_ARGS) + && (CLOSURE_CONTENT_IS_FLONUM(lam, i) + || CLOSURE_CONTENT_IS_EXTFLONUM(lam, i))) { int extfl; - extfl = CLOSURE_CONTENT_IS_EXTFLONUM(data, i); + extfl = CLOSURE_CONTENT_IS_EXTFLONUM(lam, i); mz_rs_ldxi(JIT_R1, i); MZ_FPUSEL_STMT(extfl, jit_fpu_ldxi_ld_fppush(JIT_FPU_FPR0, JIT_R1, &((Scheme_Long_Double *)0x0)->long_double_val), @@ -3817,17 +3817,17 @@ static int do_generate_closure(mz_jit_state *jitter, void *_data) } if ((self_pos >= 0) && !has_rest) { jitter->self_pos = self_pos; - jitter->self_closure_size = data->closure_size; + jitter->self_closure_size = lam->closure_size; } } else { #ifdef USE_FLONUM_UNBOXING /* Unpack flonum closure data */ - if ((SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_HAS_TYPED_ARGS) && !specialized) { - for (i = data->closure_size; i--; ) { - if (CLOSURE_CONTENT_IS_FLONUM(data, i) - || CLOSURE_CONTENT_IS_EXTFLONUM(data, i)) { + if ((SCHEME_LAMBDA_FLAGS(lam) & LAMBDA_HAS_TYPED_ARGS) && !specialized) { + for (i = lam->closure_size; i--; ) { + if (CLOSURE_CONTENT_IS_FLONUM(lam, i) + || CLOSURE_CONTENT_IS_EXTFLONUM(lam, i)) { int extfl; - extfl = CLOSURE_CONTENT_IS_EXTFLONUM(data, i); + extfl = CLOSURE_CONTENT_IS_EXTFLONUM(lam, i); mz_rs_ldxi(JIT_R1, i); MZ_FPUSEL_STMT(extfl, jit_fpu_ldxi_ld_fppush(JIT_FPU_FPR0, JIT_R1, &((Scheme_Long_Double *)0x0)->long_double_val), @@ -3848,25 +3848,25 @@ static int do_generate_closure(mz_jit_state *jitter, void *_data) } /* A define-values context? */ - if (data->context && SAME_TYPE(SCHEME_TYPE(data->context), scheme_toplevel_type)) { - jitter->self_toplevel_pos = SCHEME_TOPLEVEL_POS(data->context); - jitter->self_closure_size = data->closure_size; + if (lam->context && SAME_TYPE(SCHEME_TYPE(lam->context), scheme_toplevel_type)) { + jitter->self_toplevel_pos = SCHEME_TOPLEVEL_POS(lam->context); + jitter->self_closure_size = lam->closure_size; } } FOR_LOG({ char *log_name; Scheme_Object *a[1]; - a[0] = data->name; - log_name = (data->name ? scheme_format_utf8("~s", 2, 1, a, NULL) : "???"); + a[0] = lam->name; + log_name = (lam->name ? scheme_format_utf8("~s", 2, 1, a, NULL) : "???"); LOG_IT(("PROC: %s, %d args, flags: %x\n", log_name, - data->num_params, - SCHEME_CLOSURE_DATA_FLAGS(data))); + lam->num_params, + SCHEME_LAMBDA_FLAGS(lam))); jitter->log_depth++; }); - jitter->self_data = data; + jitter->self_lam = lam; jitter->self_restart_code = jit_get_ip(); jitter->self_restart_space = jitter->flostack_space; @@ -3882,7 +3882,7 @@ static int do_generate_closure(mz_jit_state *jitter, void *_data) /* Generate code for the body: */ jitter->need_set_rs = 1; - r = scheme_generate(data->code, jitter, 1, 1, 1, JIT_R0, NULL, NULL); /* no need for sync */ + r = scheme_generate(lam->body, jitter, 1, 1, 1, JIT_R0, NULL, NULL); /* no need for sync */ /* Result is in JIT_R0 */ CHECK_LIMIT(); @@ -3921,52 +3921,52 @@ static int do_generate_closure(mz_jit_state *jitter, void *_data) static void on_demand_generate_lambda(Scheme_Native_Closure *nc, int argc, Scheme_Object **argv, int argv_delta) { - Scheme_Native_Closure_Data *ndata = nc->code; - Scheme_Closure_Data *data; - Generate_Closure_Data gdata; + Scheme_Native_Lambda *nlam = nc->code; + Scheme_Lambda *lam; + Generate_Lambda gdata; void *start_code, *tail_code, *arity_code; int max_depth; - data = ndata->u2.orig_code; + lam = nlam->u2.orig_code; - gdata.data = data; + gdata.lam = lam; gdata.nc = nc; gdata.argc = argc; gdata.argv = argv; gdata.argv_delta = argv_delta; /* This action is not atomic: */ - scheme_delay_load_closure(data); + scheme_delay_load_closure(lam); /* So, check again whether we still need to generate: */ - if (ndata->start_code != scheme_on_demand_jit_code) + if (nlam->start_code != scheme_on_demand_jit_code) return; - ndata->arity_code = sjc.in_progress_on_demand_jit_arity_code; /* => in progress */ + nlam->arity_code = sjc.in_progress_on_demand_jit_arity_code; /* => in progress */ - scheme_generate_one(NULL, do_generate_closure, &gdata, 1, data->name, ndata); + scheme_generate_one(NULL, do_generate_closure, &gdata, 1, lam->name, nlam); - if (gdata.max_depth > data->max_let_depth) { - scheme_console_printf("Bad max depth! Given %d, counted %d.\n", data->max_let_depth, gdata.max_depth); + if (gdata.max_depth > lam->max_let_depth) { + scheme_console_printf("Bad max depth! Given %d, counted %d.\n", lam->max_let_depth, gdata.max_depth); abort(); } - if (SCHEME_NATIVE_CLOSURE_DATA_FLAGS(ndata) & NATIVE_SPECIALIZED) - SCHEME_NATIVE_CLOSURE_DATA_FLAGS(ndata) -= NATIVE_SPECIALIZED; + if (SCHEME_NATIVE_LAMBDA_FLAGS(nlam) & NATIVE_SPECIALIZED) + SCHEME_NATIVE_LAMBDA_FLAGS(nlam) -= NATIVE_SPECIALIZED; - if (SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_PRESERVES_MARKS) - SCHEME_NATIVE_CLOSURE_DATA_FLAGS(ndata) |= NATIVE_PRESERVES_MARKS; - if (SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_SINGLE_RESULT) - SCHEME_NATIVE_CLOSURE_DATA_FLAGS(ndata) |= NATIVE_IS_SINGLE_RESULT; + if (SCHEME_LAMBDA_FLAGS(lam) & LAMBDA_PRESERVES_MARKS) + SCHEME_NATIVE_LAMBDA_FLAGS(nlam) |= NATIVE_PRESERVES_MARKS; + if (SCHEME_LAMBDA_FLAGS(lam) & LAMBDA_SINGLE_RESULT) + SCHEME_NATIVE_LAMBDA_FLAGS(nlam) |= NATIVE_IS_SINGLE_RESULT; arity_code = gdata.arity_code; start_code = gdata.start_code; tail_code = gdata.tail_code; - if (data->name) { + if (lam->name) { scheme_jit_add_symbol((uintptr_t)jit_unadjust_ip(start_code), (uintptr_t)jit_unadjust_ip(gdata.code_end) - 1, - data->name, 1); + lam->name, 1); } else { #ifdef MZ_USE_DWARF_LIBUNWIND scheme_jit_add_symbol((uintptr_t)jit_unadjust_ip(start_code), @@ -3978,18 +3978,18 @@ static void on_demand_generate_lambda(Scheme_Native_Closure *nc, int argc, Schem /* Add a couple of extra slots to computed let-depth, as needed by various inlined operations. */ # define JIT_RUNSTACK_RESERVE 4 - max_depth = WORDS_TO_BYTES(data->max_let_depth + gdata.max_extra + JIT_RUNSTACK_RESERVE); + max_depth = WORDS_TO_BYTES(lam->max_let_depth + gdata.max_extra + JIT_RUNSTACK_RESERVE); if (gdata.max_tail_depth > max_depth) max_depth = gdata.max_tail_depth; /* max_let_depth is used for flags by generate_lambda: */ - if (ndata->max_let_depth & 0x1) { - data->code = NULL; + if (nlam->max_let_depth & 0x1) { + lam->body = NULL; } - data->context = NULL; - if (ndata->max_let_depth & 0x2) { - Scheme_Native_Closure_Data *case_lam; - case_lam = ((Scheme_Native_Closure_Data_Plus_Case *)ndata)->case_lam; + lam->context = NULL; + if (nlam->max_let_depth & 0x2) { + Scheme_Native_Lambda *case_lam; + case_lam = ((Scheme_Native_Lambda_Plus_Case *)nlam)->case_lam; if (case_lam->max_let_depth < max_depth) case_lam->max_let_depth = max_depth; } @@ -4001,14 +4001,14 @@ static void on_demand_generate_lambda(Scheme_Native_Closure *nc, int argc, Schem jit_patch_movi(((jit_insn *)(*pd)), (void *)(intptr_t)max_depth); } - ndata->start_code = start_code; - ndata->u.tail_code = tail_code; - ndata->arity_code = arity_code; - ndata->u2.name = data->name; + nlam->start_code = start_code; + nlam->u.tail_code = tail_code; + nlam->arity_code = arity_code; + nlam->u2.name = lam->name; /* Let-depth is in bytes instead of words: */ - ndata->max_let_depth = max_depth; + nlam->max_let_depth = max_depth; #ifdef NEED_RETAIN_CODE_POINTERS - ndata->retain_code = gdata.retain_code; + nlam->retain_code = gdata.retain_code; #endif } @@ -4036,10 +4036,10 @@ Scheme_Object **scheme_on_demand(Scheme_Object **rs) return scheme_on_demand_with_args(MZ_RUNSTACK, rs, 0); } -static Scheme_Native_Closure_Data *create_native_lambda(Scheme_Closure_Data *data, int clear_code_after_jit, - Scheme_Native_Closure_Data *case_lam) +static Scheme_Native_Lambda *create_native_lambda(Scheme_Lambda *lam, int clear_code_after_jit, + Scheme_Native_Lambda *case_lam) { - Scheme_Native_Closure_Data *ndata; + Scheme_Native_Lambda *nlam; if (!sjc.check_arity_code) { /* Create shared code used for stack-overflow handling, etc.: */ @@ -4049,43 +4049,43 @@ static Scheme_Native_Closure_Data *create_native_lambda(Scheme_Closure_Data *dat } if (!case_lam) { - ndata = MALLOC_ONE_RT(Scheme_Native_Closure_Data); + nlam = MALLOC_ONE_RT(Scheme_Native_Lambda); #ifdef MZTAG_REQUIRED - ndata->iso.so.type = scheme_rt_native_code; + nlam->iso.so.type = scheme_rt_native_code; #endif } else { - Scheme_Native_Closure_Data_Plus_Case *ndatap; - ndatap = MALLOC_ONE_RT(Scheme_Native_Closure_Data_Plus_Case); - ndatap->case_lam = case_lam; - ndata = (Scheme_Native_Closure_Data *)ndatap; + Scheme_Native_Lambda_Plus_Case *nlamp; + nlamp = MALLOC_ONE_RT(Scheme_Native_Lambda_Plus_Case); + nlamp->case_lam = case_lam; + nlam = (Scheme_Native_Lambda *)nlamp; #ifdef MZTAG_REQUIRED - ndata->iso.so.type = scheme_rt_native_code_plus_case; + nlam->iso.so.type = scheme_rt_native_code_plus_case; #endif } - ndata->start_code = scheme_on_demand_jit_code; - ndata->u.tail_code = sjc.on_demand_jit_arity_code; - ndata->arity_code = sjc.on_demand_jit_arity_code; - ndata->u2.orig_code = data; - ndata->closure_size = data->closure_size; - ndata->max_let_depth = (JIT_RUNSTACK_RESERVE * sizeof(void*)) | (case_lam ? 0x2 : 0) | (clear_code_after_jit ? 0x1 : 0); - ndata->tl_map = data->tl_map; + nlam->start_code = scheme_on_demand_jit_code; + nlam->u.tail_code = sjc.on_demand_jit_arity_code; + nlam->arity_code = sjc.on_demand_jit_arity_code; + nlam->u2.orig_code = lam; + nlam->closure_size = lam->closure_size; + nlam->max_let_depth = (JIT_RUNSTACK_RESERVE * sizeof(void*)) | (case_lam ? 0x2 : 0) | (clear_code_after_jit ? 0x1 : 0); + nlam->tl_map = lam->tl_map; #if 0 /* Compile immediately: */ - on_demand_generate_lambda(ndata); + on_demand_generate_lambda(nlam); #endif - return ndata; + return nlam; } -Scheme_Native_Closure_Data *scheme_generate_lambda(Scheme_Closure_Data *data, int clear_code_after_jit, - Scheme_Native_Closure_Data *case_lam) +Scheme_Native_Lambda *scheme_generate_lambda(Scheme_Lambda *lam, int clear_code_after_jit, + Scheme_Native_Lambda *case_lam) { - Scheme_Native_Closure_Data *ndata; + Scheme_Native_Lambda *nlam; - ndata = create_native_lambda(data, clear_code_after_jit, case_lam); + nlam = create_native_lambda(lam, clear_code_after_jit, case_lam); - return ndata; + return nlam; } static int generate_simple_arity_check(mz_jit_state *jitter, int num_params, int has_rest, int is_method) @@ -4110,7 +4110,7 @@ static int generate_simple_arity_check(mz_jit_state *jitter, int num_params, int ref = jit_blti_i(jit_forward(), JIT_R1, num_params); jit_ldxi_p(JIT_V1, JIT_R0, &((Scheme_Native_Closure *)0x0)->code); - jit_ldxi_p(JIT_V1, JIT_V1, &((Scheme_Native_Closure_Data *)0x0)->u.tail_code); + jit_ldxi_p(JIT_V1, JIT_V1, &((Scheme_Native_Lambda *)0x0)->u.tail_code); jit_jmpr(JIT_V1); CHECK_LIMIT(); @@ -4215,11 +4215,11 @@ static void *generate_lambda_simple_arity_check(int num_params, int has_rest, in return scheme_generate_one(NULL, do_generate_lambda_simple_arity_check, &data, !permanent, NULL, NULL); } -static int generate_case_lambda_dispatch(mz_jit_state *jitter, Scheme_Case_Lambda *c, Scheme_Native_Closure_Data *ndata, +static int generate_case_lambda_dispatch(mz_jit_state *jitter, Scheme_Case_Lambda *c, Scheme_Native_Lambda *nlam, int do_getarg) { /* See top of generate_simple_arity_check for register and other context info. */ - Scheme_Closure_Data *data; + Scheme_Lambda *lam; Scheme_Object *o; int i, cnt, has_rest, offset, num_params; GC_CAN_IGNORE jit_insn *ref = NULL; @@ -4231,10 +4231,10 @@ static int generate_case_lambda_dispatch(mz_jit_state *jitter, Scheme_Case_Lambd o = c->array[i]; if (SCHEME_PROCP(o)) o = (Scheme_Object *)((Scheme_Closure *)o)->code; - data = (Scheme_Closure_Data *)o; + lam = (Scheme_Lambda *)o; - num_params = data->num_params; - has_rest = ((SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_HAS_REST) ? 1 : 0); + num_params = lam->num_params; + has_rest = ((SCHEME_LAMBDA_FLAGS(lam) & LAMBDA_HAS_REST) ? 1 : 0); if (has_rest && num_params) --num_params; @@ -4254,7 +4254,7 @@ static int generate_case_lambda_dispatch(mz_jit_state *jitter, Scheme_Case_Lambd offset = WORDS_TO_BYTES(i) + (uintptr_t)&((Scheme_Native_Closure *)0x0)->vals; jit_ldxi_p(JIT_R0, JIT_R0, offset); jit_ldxi_p(JIT_V1, JIT_R0, &((Scheme_Native_Closure *)0x0)->code); - jit_ldxi_p(JIT_V1, JIT_V1, &((Scheme_Native_Closure_Data *)0x0)->u.tail_code); + jit_ldxi_p(JIT_V1, JIT_V1, &((Scheme_Native_Lambda *)0x0)->u.tail_code); jit_jmpr(JIT_V1); CHECK_LIMIT(); @@ -4279,7 +4279,7 @@ static int generate_case_lambda_dispatch(mz_jit_state *jitter, Scheme_Case_Lambd typedef struct { Scheme_Case_Lambda *c; - Scheme_Native_Closure_Data *ndata; + Scheme_Native_Lambda *nlam; int is_method; } Generate_Case_Dispatch_Data; @@ -4293,13 +4293,13 @@ static int do_generate_case_lambda_dispatch(mz_jit_state *jitter, void *_data) scheme_generate_function_prolog(jitter); CHECK_LIMIT(); - if (generate_case_lambda_dispatch(jitter, data->c, data->ndata, 1)) { + if (generate_case_lambda_dispatch(jitter, data->c, data->nlam, 1)) { arity_code = jit_get_ip(); - if (generate_case_lambda_dispatch(jitter, data->c, data->ndata, 0)) { - data->ndata->start_code = start_code; - data->ndata->arity_code = arity_code; + if (generate_case_lambda_dispatch(jitter, data->c, data->nlam, 0)) { + data->nlam->start_code = start_code; + data->nlam->arity_code = arity_code; #ifdef NEED_RETAIN_CODE_POINTERS - data->ndata->retain_code = jit_unadjust_ip(start_code); + data->nlam->retain_code = jit_unadjust_ip(start_code); #endif scheme_jit_register_helper_func(jitter, start_code, 1); @@ -4311,19 +4311,19 @@ static int do_generate_case_lambda_dispatch(mz_jit_state *jitter, void *_data) return 0; } -static void generate_case_lambda(Scheme_Case_Lambda *c, Scheme_Native_Closure_Data *ndata, int is_method) +static void generate_case_lambda(Scheme_Case_Lambda *c, Scheme_Native_Lambda *nlam, int is_method) { Generate_Case_Dispatch_Data gdata; - Scheme_Closure_Data *data; + Scheme_Lambda *lam; Scheme_Object *o; int i, cnt, num_params, has_rest, single_result = 1; mzshort *arities; gdata.c = c; - gdata.ndata = ndata; + gdata.nlam = nlam; gdata.is_method = is_method; - scheme_generate_one(NULL, do_generate_case_lambda_dispatch, &gdata, 1, NULL, ndata); + scheme_generate_one(NULL, do_generate_case_lambda_dispatch, &gdata, 1, NULL, nlam); /* Generate arity table used by scheme_native_arity_check and scheme_get_native_arity: */ @@ -4335,12 +4335,12 @@ static void generate_case_lambda(Scheme_Case_Lambda *c, Scheme_Native_Closure_Da o = c->array[i]; if (SCHEME_PROCP(o)) o = (Scheme_Object *)((Scheme_Closure *)o)->code; - data = (Scheme_Closure_Data *)o; - num_params = data->num_params; - has_rest = ((SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_HAS_REST) ? 1 : 0); + lam = (Scheme_Lambda *)o; + num_params = lam->num_params; + has_rest = ((SCHEME_LAMBDA_FLAGS(lam) & LAMBDA_HAS_REST) ? 1 : 0); if (has_rest && num_params) --num_params; - if (!(SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_SINGLE_RESULT)) + if (!(SCHEME_LAMBDA_FLAGS(lam) & LAMBDA_SINGLE_RESULT)) single_result = 0; if (!has_rest) @@ -4348,20 +4348,20 @@ static void generate_case_lambda(Scheme_Case_Lambda *c, Scheme_Native_Closure_Da else arities[i] = -(num_params+1); } - ndata->u.arities = arities; + nlam->u.arities = arities; if (single_result) - SCHEME_NATIVE_CLOSURE_DATA_FLAGS(ndata) |= NATIVE_IS_SINGLE_RESULT; + SCHEME_NATIVE_LAMBDA_FLAGS(nlam) |= NATIVE_IS_SINGLE_RESULT; } /*========================================================================*/ /* native arity queries */ /*========================================================================*/ -XFORM_NONGCING static int lambda_has_been_jitted(Scheme_Native_Closure_Data *ndata) +XFORM_NONGCING static int lambda_has_been_jitted(Scheme_Native_Lambda *nlam) /* called by scheme_native_arity_check(), which is not XFORMed */ { - return (ndata->start_code != scheme_on_demand_jit_code); + return (nlam->start_code != scheme_on_demand_jit_code); } int scheme_native_arity_check(Scheme_Object *closure, int argc) @@ -4390,10 +4390,10 @@ int scheme_native_arity_check(Scheme_Object *closure, int argc) } if (!lambda_has_been_jitted(((Scheme_Native_Closure *)closure)->code)) { - Scheme_Closure_Data *data = ((Scheme_Native_Closure *)closure)->code->u2.orig_code; + Scheme_Lambda *lam = ((Scheme_Native_Closure *)closure)->code->u2.orig_code; int mina, maxa; - mina = maxa = data->num_params; - if (SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_HAS_REST) { + mina = maxa = lam->num_params; + if (SCHEME_LAMBDA_FLAGS(lam) & LAMBDA_HAS_REST) { if (mina) --mina; maxa = -1; @@ -4447,7 +4447,7 @@ Scheme_Object *scheme_get_native_arity(Scheme_Object *closure, int mode) c.so.type = scheme_closure_type; c.code = ((Scheme_Native_Closure *)closure)->code->u2.orig_code; a = scheme_get_or_check_arity((Scheme_Object *)&c, -1); - if (SCHEME_CLOSURE_DATA_FLAGS(c.code) & CLOS_IS_METHOD) + if (SCHEME_LAMBDA_FLAGS(c.code) & LAMBDA_IS_METHOD) a = scheme_box(a); return a; } diff --git a/racket/src/racket/src/jit.h b/racket/src/racket/src/jit.h index 27f44cb196..0905a52760 100644 --- a/racket/src/racket/src/jit.h +++ b/racket/src/racket/src/jit.h @@ -413,7 +413,7 @@ typedef struct mz_jit_state { int need_set_rs; void **retain_start; double *retain_double_start; - Scheme_Native_Closure_Data *retaining_data; /* poke when setting retain_start for generational GC */ + Scheme_Native_Lambda *retaining_data; /* poke when setting retain_start for generational GC */ int local1_busy, pushed_marks; int log_depth; int self_pos, self_closure_size, self_toplevel_pos; @@ -424,7 +424,7 @@ typedef struct mz_jit_state { void *self_restart_code; void *self_nontail_code; Scheme_Native_Closure *nc; /* for extract_globals and extract_closure_local, only */ - Scheme_Closure_Data *self_data; + Scheme_Lambda *self_lam; void *status_at_ptr; int r0_status, r1_status; void *patch_depth; @@ -1344,7 +1344,7 @@ void *scheme_generate_one(mz_jit_state *old_jitter, void *data, int gcable, void *save_ptr, - Scheme_Native_Closure_Data *ndata); + Scheme_Native_Lambda *ndata); int scheme_mz_is_closure(mz_jit_state *jitter, int i, int arity, int *_flags); void scheme_mz_runstack_saved(mz_jit_state *jitter); int scheme_mz_runstack_restored(mz_jit_state *jitter); @@ -1482,7 +1482,7 @@ int scheme_generate_app(Scheme_App_Rec *app, Scheme_Object **alt_rands, int num_ int no_call); int scheme_generate_tail_call(mz_jit_state *jitter, int num_rands, int direct_native, int need_set_rs, int is_inline, Scheme_Native_Closure *direct_to_code, jit_direct_arg *direct_arg, - Scheme_Closure_Data *direct_data); + Scheme_Lambda *direct_data); int scheme_generate_non_tail_call(mz_jit_state *jitter, int num_rands, int direct_native, int need_set_rs, int multi_ok, int result_ignored, int nontail_self, int pop_and_jump, int is_inlined, int unboxed_args, jit_insn *reftop); @@ -1577,10 +1577,10 @@ int scheme_is_simple(Scheme_Object *obj, int depth, int just_markless, mz_jit_st int scheme_is_non_gc(Scheme_Object *obj, int depth); #ifdef USE_FLONUM_UNBOXING -int scheme_jit_check_closure_flonum_bit(Scheme_Closure_Data *data, int pos, int delta); +int scheme_jit_check_closure_flonum_bit(Scheme_Lambda *data, int pos, int delta); # define CLOSURE_ARGUMENT_IS_FLONUM(data, pos) scheme_jit_check_closure_flonum_bit(data, pos, 0) # define CLOSURE_CONTENT_IS_FLONUM(data, pos) scheme_jit_check_closure_flonum_bit(data, pos, data->num_params) -int scheme_jit_check_closure_extflonum_bit(Scheme_Closure_Data *data, int pos, int delta); +int scheme_jit_check_closure_extflonum_bit(Scheme_Lambda *data, int pos, int delta); # define CLOSURE_ARGUMENT_IS_EXTFLONUM(data, pos) scheme_jit_check_closure_extflonum_bit(data, pos, 0) # define CLOSURE_CONTENT_IS_EXTFLONUM(data, pos) scheme_jit_check_closure_extflonum_bit(data, pos, data->num_params) #endif diff --git a/racket/src/racket/src/jit_ts.c b/racket/src/racket/src/jit_ts.c index 392154a53d..de06970519 100644 --- a/racket/src/racket/src/jit_ts.c +++ b/racket/src/racket/src/jit_ts.c @@ -9,7 +9,7 @@ S = Scheme_Object** v = void b = Scheme_Bucket* - n = Scheme_Native_Closure_Data* + n = Scheme_Native_Lambda* p = void*, CGC only z = size_t m = MZ_MARK_STACK_TYPE */ diff --git a/racket/src/racket/src/jit_ts_def.c b/racket/src/racket/src/jit_ts_def.c index bc7c1dc009..1ea6b65b66 100644 --- a/racket/src/racket/src/jit_ts_def.c +++ b/racket/src/racket/src/jit_ts_def.c @@ -1,38 +1,38 @@ #define define_ts_siS_s(id, src_type) \ -static Scheme_Object* ts_ ## id(Scheme_Object* g12, int g13, Scheme_Object** g14) \ +static Scheme_Object* ts_ ## id(Scheme_Object* g178, int g179, Scheme_Object** g180) \ XFORM_SKIP_PROC \ { \ if (scheme_use_rtcall) \ - return scheme_rtcall_siS_s("[" #id "]", src_type, id, g12, g13, g14); \ + return scheme_rtcall_siS_s("[" #id "]", src_type, id, g178, g179, g180); \ else \ - return id(g12, g13, g14); \ + return id(g178, g179, g180); \ } #define define_ts_iSs_s(id, src_type) \ -static Scheme_Object* ts_ ## id(int g15, Scheme_Object** g16, Scheme_Object* g17) \ +static Scheme_Object* ts_ ## id(int g181, Scheme_Object** g182, Scheme_Object* g183) \ XFORM_SKIP_PROC \ { \ if (scheme_use_rtcall) \ - return scheme_rtcall_iSs_s("[" #id "]", src_type, id, g15, g16, g17); \ + return scheme_rtcall_iSs_s("[" #id "]", src_type, id, g181, g182, g183); \ else \ - return id(g15, g16, g17); \ + return id(g181, g182, g183); \ } #define define_ts_s_s(id, src_type) \ -static Scheme_Object* ts_ ## id(Scheme_Object* g18) \ +static Scheme_Object* ts_ ## id(Scheme_Object* g184) \ XFORM_SKIP_PROC \ { \ if (scheme_use_rtcall) \ - return scheme_rtcall_s_s("[" #id "]", src_type, id, g18); \ + return scheme_rtcall_s_s("[" #id "]", src_type, id, g184); \ else \ - return id(g18); \ + return id(g184); \ } #define define_ts_n_s(id, src_type) \ -static Scheme_Object* ts_ ## id(Scheme_Native_Closure_Data* g19) \ +static Scheme_Object* ts_ ## id(Scheme_Native_Lambda* g185) \ XFORM_SKIP_PROC \ { \ if (scheme_use_rtcall) \ - return scheme_rtcall_n_s("[" #id "]", src_type, id, g19); \ + return scheme_rtcall_n_s("[" #id "]", src_type, id, g185); \ else \ - return id(g19); \ + return id(g185); \ } #define define_ts__s(id, src_type) \ static Scheme_Object* ts_ ## id() \ @@ -44,202 +44,202 @@ static Scheme_Object* ts_ ## id() \ return id(); \ } #define define_ts_ss_s(id, src_type) \ -static Scheme_Object* ts_ ## id(Scheme_Object* g20, Scheme_Object* g21) \ +static Scheme_Object* ts_ ## id(Scheme_Object* g186, Scheme_Object* g187) \ XFORM_SKIP_PROC \ { \ if (scheme_use_rtcall) \ - return scheme_rtcall_ss_s("[" #id "]", src_type, id, g20, g21); \ + return scheme_rtcall_ss_s("[" #id "]", src_type, id, g186, g187); \ else \ - return id(g20, g21); \ + return id(g186, g187); \ } #define define_ts_ssi_s(id, src_type) \ -static Scheme_Object* ts_ ## id(Scheme_Object* g22, Scheme_Object* g23, int g24) \ +static Scheme_Object* ts_ ## id(Scheme_Object* g188, Scheme_Object* g189, int g190) \ XFORM_SKIP_PROC \ { \ if (scheme_use_rtcall) \ - return scheme_rtcall_ssi_s("[" #id "]", src_type, id, g22, g23, g24); \ + return scheme_rtcall_ssi_s("[" #id "]", src_type, id, g188, g189, g190); \ else \ - return id(g22, g23, g24); \ + return id(g188, g189, g190); \ } #define define_ts_tt_s(id, src_type) \ -static Scheme_Object* ts_ ## id(const Scheme_Object* g25, const Scheme_Object* g26) \ +static Scheme_Object* ts_ ## id(const Scheme_Object* g191, const Scheme_Object* g192) \ XFORM_SKIP_PROC \ { \ if (scheme_use_rtcall) \ - return scheme_rtcall_tt_s("[" #id "]", src_type, id, g25, g26); \ + return scheme_rtcall_tt_s("[" #id "]", src_type, id, g191, g192); \ else \ - return id(g25, g26); \ + return id(g191, g192); \ } #define define_ts_ss_m(id, src_type) \ -static MZ_MARK_STACK_TYPE ts_ ## id(Scheme_Object* g27, Scheme_Object* g28) \ +static MZ_MARK_STACK_TYPE ts_ ## id(Scheme_Object* g193, Scheme_Object* g194) \ XFORM_SKIP_PROC \ { \ if (scheme_use_rtcall) \ - return scheme_rtcall_ss_m("[" #id "]", src_type, id, g27, g28); \ + return scheme_rtcall_ss_m("[" #id "]", src_type, id, g193, g194); \ else \ - return id(g27, g28); \ + return id(g193, g194); \ } #define define_ts_Sl_s(id, src_type) \ -static Scheme_Object* ts_ ## id(Scheme_Object** g29, intptr_t g30) \ +static Scheme_Object* ts_ ## id(Scheme_Object** g195, intptr_t g196) \ XFORM_SKIP_PROC \ { \ if (scheme_use_rtcall) \ - return scheme_rtcall_Sl_s("[" #id "]", src_type, id, g29, g30); \ + return scheme_rtcall_Sl_s("[" #id "]", src_type, id, g195, g196); \ else \ - return id(g29, g30); \ + return id(g195, g196); \ } #define define_ts_l_s(id, src_type) \ -static Scheme_Object* ts_ ## id(intptr_t g31) \ +static Scheme_Object* ts_ ## id(intptr_t g197) \ XFORM_SKIP_PROC \ { \ if (scheme_use_rtcall) \ - return scheme_rtcall_l_s("[" #id "]", src_type, id, g31); \ + return scheme_rtcall_l_s("[" #id "]", src_type, id, g197); \ else \ - return id(g31); \ + return id(g197); \ } #define define_ts_bsi_v(id, src_type) \ -static void ts_ ## id(Scheme_Bucket* g32, Scheme_Object* g33, int g34) \ +static void ts_ ## id(Scheme_Bucket* g198, Scheme_Object* g199, int g200) \ XFORM_SKIP_PROC \ { \ if (scheme_use_rtcall) \ - scheme_rtcall_bsi_v("[" #id "]", src_type, id, g32, g33, g34); \ + scheme_rtcall_bsi_v("[" #id "]", src_type, id, g198, g199, g200); \ else \ - id(g32, g33, g34); \ + id(g198, g199, g200); \ } #define define_ts_iiS_v(id, src_type) \ -static void ts_ ## id(int g35, int g36, Scheme_Object** g37) \ +static void ts_ ## id(int g201, int g202, Scheme_Object** g203) \ XFORM_SKIP_PROC \ { \ if (scheme_use_rtcall) \ - scheme_rtcall_iiS_v("[" #id "]", src_type, id, g35, g36, g37); \ + scheme_rtcall_iiS_v("[" #id "]", src_type, id, g201, g202, g203); \ else \ - id(g35, g36, g37); \ + id(g201, g202, g203); \ } #define define_ts_ss_v(id, src_type) \ -static void ts_ ## id(Scheme_Object* g38, Scheme_Object* g39) \ +static void ts_ ## id(Scheme_Object* g204, Scheme_Object* g205) \ XFORM_SKIP_PROC \ { \ if (scheme_use_rtcall) \ - scheme_rtcall_ss_v("[" #id "]", src_type, id, g38, g39); \ + scheme_rtcall_ss_v("[" #id "]", src_type, id, g204, g205); \ else \ - id(g38, g39); \ + id(g204, g205); \ } #define define_ts_b_v(id, src_type) \ -static void ts_ ## id(Scheme_Bucket* g40) \ +static void ts_ ## id(Scheme_Bucket* g206) \ XFORM_SKIP_PROC \ { \ if (scheme_use_rtcall) \ - scheme_rtcall_b_v("[" #id "]", src_type, id, g40); \ + scheme_rtcall_b_v("[" #id "]", src_type, id, g206); \ else \ - id(g40); \ + id(g206); \ } #define define_ts_sl_s(id, src_type) \ -static Scheme_Object* ts_ ## id(Scheme_Object* g41, intptr_t g42) \ +static Scheme_Object* ts_ ## id(Scheme_Object* g207, intptr_t g208) \ XFORM_SKIP_PROC \ { \ if (scheme_use_rtcall) \ - return scheme_rtcall_sl_s("[" #id "]", src_type, id, g41, g42); \ + return scheme_rtcall_sl_s("[" #id "]", src_type, id, g207, g208); \ else \ - return id(g41, g42); \ + return id(g207, g208); \ } #define define_ts_iS_s(id, src_type) \ -static Scheme_Object* ts_ ## id(int g43, Scheme_Object** g44) \ +static Scheme_Object* ts_ ## id(int g209, Scheme_Object** g210) \ XFORM_SKIP_PROC \ { \ if (scheme_use_rtcall) \ - return scheme_rtcall_iS_s("[" #id "]", src_type, id, g43, g44); \ + return scheme_rtcall_iS_s("[" #id "]", src_type, id, g209, g210); \ else \ - return id(g43, g44); \ + return id(g209, g210); \ } #define define_ts_S_s(id, src_type) \ -static Scheme_Object* ts_ ## id(Scheme_Object** g45) \ +static Scheme_Object* ts_ ## id(Scheme_Object** g211) \ XFORM_SKIP_PROC \ { \ if (scheme_use_rtcall) \ - return scheme_rtcall_S_s("[" #id "]", src_type, id, g45); \ + return scheme_rtcall_S_s("[" #id "]", src_type, id, g211); \ else \ - return id(g45); \ + return id(g211); \ } #define define_ts_s_v(id, src_type) \ -static void ts_ ## id(Scheme_Object* g46) \ +static void ts_ ## id(Scheme_Object* g212) \ XFORM_SKIP_PROC \ { \ if (scheme_use_rtcall) \ - scheme_rtcall_s_v("[" #id "]", src_type, id, g46); \ + scheme_rtcall_s_v("[" #id "]", src_type, id, g212); \ else \ - id(g46); \ + id(g212); \ } #define define_ts_iSi_s(id, src_type) \ -static Scheme_Object* ts_ ## id(int g47, Scheme_Object** g48, int g49) \ +static Scheme_Object* ts_ ## id(int g213, Scheme_Object** g214, int g215) \ XFORM_SKIP_PROC \ { \ if (scheme_use_rtcall) \ - return scheme_rtcall_iSi_s("[" #id "]", src_type, id, g47, g48, g49); \ + return scheme_rtcall_iSi_s("[" #id "]", src_type, id, g213, g214, g215); \ else \ - return id(g47, g48, g49); \ + return id(g213, g214, g215); \ } #define define_ts_siS_v(id, src_type) \ -static void ts_ ## id(Scheme_Object* g50, int g51, Scheme_Object** g52) \ +static void ts_ ## id(Scheme_Object* g216, int g217, Scheme_Object** g218) \ XFORM_SKIP_PROC \ { \ if (scheme_use_rtcall) \ - scheme_rtcall_siS_v("[" #id "]", src_type, id, g50, g51, g52); \ + scheme_rtcall_siS_v("[" #id "]", src_type, id, g216, g217, g218); \ else \ - id(g50, g51, g52); \ + id(g216, g217, g218); \ } #define define_ts_z_p(id, src_type) \ -static void* ts_ ## id(size_t g53) \ +static void* ts_ ## id(size_t g219) \ XFORM_SKIP_PROC \ { \ if (scheme_use_rtcall) \ - return scheme_rtcall_z_p("[" #id "]", src_type, id, g53); \ + return scheme_rtcall_z_p("[" #id "]", src_type, id, g219); \ else \ - return id(g53); \ + return id(g219); \ } #define define_ts_si_s(id, src_type) \ -static Scheme_Object* ts_ ## id(Scheme_Object* g54, int g55) \ +static Scheme_Object* ts_ ## id(Scheme_Object* g220, int g221) \ XFORM_SKIP_PROC \ { \ if (scheme_use_rtcall) \ - return scheme_rtcall_si_s("[" #id "]", src_type, id, g54, g55); \ + return scheme_rtcall_si_s("[" #id "]", src_type, id, g220, g221); \ else \ - return id(g54, g55); \ + return id(g220, g221); \ } #define define_ts_sis_v(id, src_type) \ -static void ts_ ## id(Scheme_Object* g56, int g57, Scheme_Object* g58) \ +static void ts_ ## id(Scheme_Object* g222, int g223, Scheme_Object* g224) \ XFORM_SKIP_PROC \ { \ if (scheme_use_rtcall) \ - scheme_rtcall_sis_v("[" #id "]", src_type, id, g56, g57, g58); \ + scheme_rtcall_sis_v("[" #id "]", src_type, id, g222, g223, g224); \ else \ - id(g56, g57, g58); \ + id(g222, g223, g224); \ } #define define_ts_ss_i(id, src_type) \ -static int ts_ ## id(Scheme_Object* g59, Scheme_Object* g60) \ +static int ts_ ## id(Scheme_Object* g225, Scheme_Object* g226) \ XFORM_SKIP_PROC \ { \ if (scheme_use_rtcall) \ - return scheme_rtcall_ss_i("[" #id "]", src_type, id, g59, g60); \ + return scheme_rtcall_ss_i("[" #id "]", src_type, id, g225, g226); \ else \ - return id(g59, g60); \ + return id(g225, g226); \ } #define define_ts_iSp_v(id, src_type) \ -static void ts_ ## id(int g61, Scheme_Object** g62, void* g63) \ +static void ts_ ## id(int g227, Scheme_Object** g228, void* g229) \ XFORM_SKIP_PROC \ { \ if (scheme_use_rtcall) \ - scheme_rtcall_iSp_v("[" #id "]", src_type, id, g61, g62, g63); \ + scheme_rtcall_iSp_v("[" #id "]", src_type, id, g227, g228, g229); \ else \ - id(g61, g62, g63); \ + id(g227, g228, g229); \ } #define define_ts_sss_s(id, src_type) \ -static Scheme_Object* ts_ ## id(Scheme_Object* g64, Scheme_Object* g65, Scheme_Object* g66) \ +static Scheme_Object* ts_ ## id(Scheme_Object* g230, Scheme_Object* g231, Scheme_Object* g232) \ XFORM_SKIP_PROC \ { \ if (scheme_use_rtcall) \ - return scheme_rtcall_sss_s("[" #id "]", src_type, id, g64, g65, g66); \ + return scheme_rtcall_sss_s("[" #id "]", src_type, id, g230, g231, g232); \ else \ - return id(g64, g65, g66); \ + return id(g230, g231, g232); \ } #define define_ts__v(id, src_type) \ static void ts_ ## id() \ @@ -251,11 +251,11 @@ static void ts_ ## id() \ id(); \ } #define define_ts_iS_v(id, src_type) \ -static void ts_ ## id(int g67, Scheme_Object** g68) \ +static void ts_ ## id(int g233, Scheme_Object** g234) \ XFORM_SKIP_PROC \ { \ if (scheme_use_rtcall) \ - scheme_rtcall_iS_v("[" #id "]", src_type, id, g67, g68); \ + scheme_rtcall_iS_v("[" #id "]", src_type, id, g233, g234); \ else \ - id(g67, g68); \ + id(g233, g234); \ } diff --git a/racket/src/racket/src/jit_ts_future_glue.c b/racket/src/racket/src/jit_ts_future_glue.c index dce1f3e0ae..29998b59d7 100644 --- a/racket/src/racket/src/jit_ts_future_glue.c +++ b/racket/src/racket/src/jit_ts_future_glue.c @@ -1,4 +1,4 @@ - Scheme_Object* scheme_rtcall_siS_s(const char *who, int src_type, prim_siS_s f, Scheme_Object* g69, int g70, Scheme_Object** g71) + Scheme_Object* scheme_rtcall_siS_s(const char *who, int src_type, prim_siS_s f, Scheme_Object* g235, int g236, Scheme_Object** g237) XFORM_SKIP_PROC { Scheme_Future_Thread_State *fts = scheme_future_thread_state; @@ -13,9 +13,9 @@ future->time_of_request = tm; future->source_of_request = who; future->source_type = src_type; - future->arg_s0 = g69; - future->arg_i1 = g70; - future->arg_S2 = g71; + future->arg_s0 = g235; + future->arg_i1 = g236; + future->arg_S2 = g237; future_do_runtimecall(fts, (void*)f, 0, 1, 0); fts->thread = scheme_current_thread; @@ -25,7 +25,7 @@ receive_special_result(future, retval, 1); return retval; } - Scheme_Object* scheme_rtcall_iSs_s(const char *who, int src_type, prim_iSs_s f, int g72, Scheme_Object** g73, Scheme_Object* g74) + Scheme_Object* scheme_rtcall_iSs_s(const char *who, int src_type, prim_iSs_s f, int g238, Scheme_Object** g239, Scheme_Object* g240) XFORM_SKIP_PROC { Scheme_Future_Thread_State *fts = scheme_future_thread_state; @@ -40,9 +40,9 @@ future->time_of_request = tm; future->source_of_request = who; future->source_type = src_type; - future->arg_i0 = g72; - future->arg_S1 = g73; - future->arg_s2 = g74; + future->arg_i0 = g238; + future->arg_S1 = g239; + future->arg_s2 = g240; future_do_runtimecall(fts, (void*)f, 0, 1, 0); fts->thread = scheme_current_thread; @@ -52,7 +52,7 @@ receive_special_result(future, retval, 1); return retval; } - Scheme_Object* scheme_rtcall_s_s(const char *who, int src_type, prim_s_s f, Scheme_Object* g75) + Scheme_Object* scheme_rtcall_s_s(const char *who, int src_type, prim_s_s f, Scheme_Object* g241) XFORM_SKIP_PROC { Scheme_Future_Thread_State *fts = scheme_future_thread_state; @@ -67,8 +67,8 @@ future->time_of_request = tm; future->source_of_request = who; future->source_type = src_type; - future->arg_s0 = g75; - send_special_result(future, g75); + future->arg_s0 = g241; + send_special_result(future, g241); future_do_runtimecall(fts, (void*)f, 0, 1, 0); fts->thread = scheme_current_thread; future = fts->thread->current_ft; @@ -77,7 +77,7 @@ receive_special_result(future, retval, 1); return retval; } - Scheme_Object* scheme_rtcall_n_s(const char *who, int src_type, prim_n_s f, Scheme_Native_Closure_Data* g76) + Scheme_Object* scheme_rtcall_n_s(const char *who, int src_type, prim_n_s f, Scheme_Native_Lambda* g242) XFORM_SKIP_PROC { Scheme_Future_Thread_State *fts = scheme_future_thread_state; @@ -92,7 +92,7 @@ future->time_of_request = tm; future->source_of_request = who; future->source_type = src_type; - future->arg_n0 = g76; + future->arg_n0 = g242; future_do_runtimecall(fts, (void*)f, 0, 1, 0); fts->thread = scheme_current_thread; @@ -127,7 +127,7 @@ receive_special_result(future, retval, 1); return retval; } - Scheme_Object* scheme_rtcall_ss_s(const char *who, int src_type, prim_ss_s f, Scheme_Object* g77, Scheme_Object* g78) + Scheme_Object* scheme_rtcall_ss_s(const char *who, int src_type, prim_ss_s f, Scheme_Object* g243, Scheme_Object* g244) XFORM_SKIP_PROC { Scheme_Future_Thread_State *fts = scheme_future_thread_state; @@ -142,8 +142,8 @@ future->time_of_request = tm; future->source_of_request = who; future->source_type = src_type; - future->arg_s0 = g77; - future->arg_s1 = g78; + future->arg_s0 = g243; + future->arg_s1 = g244; future_do_runtimecall(fts, (void*)f, 0, 1, 0); fts->thread = scheme_current_thread; @@ -153,7 +153,7 @@ receive_special_result(future, retval, 1); return retval; } - Scheme_Object* scheme_rtcall_ssi_s(const char *who, int src_type, prim_ssi_s f, Scheme_Object* g79, Scheme_Object* g80, int g81) + Scheme_Object* scheme_rtcall_ssi_s(const char *who, int src_type, prim_ssi_s f, Scheme_Object* g245, Scheme_Object* g246, int g247) XFORM_SKIP_PROC { Scheme_Future_Thread_State *fts = scheme_future_thread_state; @@ -168,9 +168,9 @@ future->time_of_request = tm; future->source_of_request = who; future->source_type = src_type; - future->arg_s0 = g79; - future->arg_s1 = g80; - future->arg_i2 = g81; + future->arg_s0 = g245; + future->arg_s1 = g246; + future->arg_i2 = g247; future_do_runtimecall(fts, (void*)f, 0, 1, 0); fts->thread = scheme_current_thread; @@ -180,7 +180,7 @@ receive_special_result(future, retval, 1); return retval; } - Scheme_Object* scheme_rtcall_tt_s(const char *who, int src_type, prim_tt_s f, const Scheme_Object* g82, const Scheme_Object* g83) + Scheme_Object* scheme_rtcall_tt_s(const char *who, int src_type, prim_tt_s f, const Scheme_Object* g248, const Scheme_Object* g249) XFORM_SKIP_PROC { Scheme_Future_Thread_State *fts = scheme_future_thread_state; @@ -195,8 +195,8 @@ future->time_of_request = tm; future->source_of_request = who; future->source_type = src_type; - future->arg_t0 = g82; - future->arg_t1 = g83; + future->arg_t0 = g248; + future->arg_t1 = g249; future_do_runtimecall(fts, (void*)f, 0, 1, 0); fts->thread = scheme_current_thread; @@ -206,7 +206,7 @@ receive_special_result(future, retval, 1); return retval; } - MZ_MARK_STACK_TYPE scheme_rtcall_ss_m(const char *who, int src_type, prim_ss_m f, Scheme_Object* g84, Scheme_Object* g85) + MZ_MARK_STACK_TYPE scheme_rtcall_ss_m(const char *who, int src_type, prim_ss_m f, Scheme_Object* g250, Scheme_Object* g251) XFORM_SKIP_PROC { Scheme_Future_Thread_State *fts = scheme_future_thread_state; @@ -221,8 +221,8 @@ future->time_of_request = tm; future->source_of_request = who; future->source_type = src_type; - future->arg_s0 = g84; - future->arg_s1 = g85; + future->arg_s0 = g250; + future->arg_s1 = g251; future_do_runtimecall(fts, (void*)f, 0, 1, 0); fts->thread = scheme_current_thread; @@ -232,7 +232,7 @@ return retval; } - Scheme_Object* scheme_rtcall_Sl_s(const char *who, int src_type, prim_Sl_s f, Scheme_Object** g86, intptr_t g87) + Scheme_Object* scheme_rtcall_Sl_s(const char *who, int src_type, prim_Sl_s f, Scheme_Object** g252, intptr_t g253) XFORM_SKIP_PROC { Scheme_Future_Thread_State *fts = scheme_future_thread_state; @@ -247,8 +247,8 @@ future->time_of_request = tm; future->source_of_request = who; future->source_type = src_type; - future->arg_S0 = g86; - future->arg_l1 = g87; + future->arg_S0 = g252; + future->arg_l1 = g253; future_do_runtimecall(fts, (void*)f, 0, 1, 0); fts->thread = scheme_current_thread; @@ -258,7 +258,7 @@ receive_special_result(future, retval, 1); return retval; } - Scheme_Object* scheme_rtcall_l_s(const char *who, int src_type, prim_l_s f, intptr_t g88) + Scheme_Object* scheme_rtcall_l_s(const char *who, int src_type, prim_l_s f, intptr_t g254) XFORM_SKIP_PROC { Scheme_Future_Thread_State *fts = scheme_future_thread_state; @@ -273,7 +273,7 @@ future->time_of_request = tm; future->source_of_request = who; future->source_type = src_type; - future->arg_l0 = g88; + future->arg_l0 = g254; future_do_runtimecall(fts, (void*)f, 0, 1, 0); fts->thread = scheme_current_thread; @@ -283,7 +283,7 @@ receive_special_result(future, retval, 1); return retval; } - void scheme_rtcall_bsi_v(const char *who, int src_type, prim_bsi_v f, Scheme_Bucket* g89, Scheme_Object* g90, int g91) + void scheme_rtcall_bsi_v(const char *who, int src_type, prim_bsi_v f, Scheme_Bucket* g255, Scheme_Object* g256, int g257) XFORM_SKIP_PROC { Scheme_Future_Thread_State *fts = scheme_future_thread_state; @@ -298,9 +298,9 @@ future->time_of_request = tm; future->source_of_request = who; future->source_type = src_type; - future->arg_b0 = g89; - future->arg_s1 = g90; - future->arg_i2 = g91; + future->arg_b0 = g255; + future->arg_s1 = g256; + future->arg_i2 = g257; future_do_runtimecall(fts, (void*)f, 0, 1, 0); fts->thread = scheme_current_thread; @@ -310,7 +310,7 @@ } - void scheme_rtcall_iiS_v(const char *who, int src_type, prim_iiS_v f, int g92, int g93, Scheme_Object** g94) + void scheme_rtcall_iiS_v(const char *who, int src_type, prim_iiS_v f, int g258, int g259, Scheme_Object** g260) XFORM_SKIP_PROC { Scheme_Future_Thread_State *fts = scheme_future_thread_state; @@ -325,9 +325,9 @@ future->time_of_request = tm; future->source_of_request = who; future->source_type = src_type; - future->arg_i0 = g92; - future->arg_i1 = g93; - future->arg_S2 = g94; + future->arg_i0 = g258; + future->arg_i1 = g259; + future->arg_S2 = g260; future_do_runtimecall(fts, (void*)f, 0, 1, 0); fts->thread = scheme_current_thread; @@ -337,7 +337,7 @@ } - void scheme_rtcall_ss_v(const char *who, int src_type, prim_ss_v f, Scheme_Object* g95, Scheme_Object* g96) + void scheme_rtcall_ss_v(const char *who, int src_type, prim_ss_v f, Scheme_Object* g261, Scheme_Object* g262) XFORM_SKIP_PROC { Scheme_Future_Thread_State *fts = scheme_future_thread_state; @@ -352,8 +352,8 @@ future->time_of_request = tm; future->source_of_request = who; future->source_type = src_type; - future->arg_s0 = g95; - future->arg_s1 = g96; + future->arg_s0 = g261; + future->arg_s1 = g262; future_do_runtimecall(fts, (void*)f, 0, 1, 0); fts->thread = scheme_current_thread; @@ -363,7 +363,7 @@ } - void scheme_rtcall_b_v(const char *who, int src_type, prim_b_v f, Scheme_Bucket* g97) + void scheme_rtcall_b_v(const char *who, int src_type, prim_b_v f, Scheme_Bucket* g263) XFORM_SKIP_PROC { Scheme_Future_Thread_State *fts = scheme_future_thread_state; @@ -378,7 +378,7 @@ future->time_of_request = tm; future->source_of_request = who; future->source_type = src_type; - future->arg_b0 = g97; + future->arg_b0 = g263; future_do_runtimecall(fts, (void*)f, 0, 1, 0); fts->thread = scheme_current_thread; @@ -388,7 +388,7 @@ } - Scheme_Object* scheme_rtcall_sl_s(const char *who, int src_type, prim_sl_s f, Scheme_Object* g98, intptr_t g99) + Scheme_Object* scheme_rtcall_sl_s(const char *who, int src_type, prim_sl_s f, Scheme_Object* g264, intptr_t g265) XFORM_SKIP_PROC { Scheme_Future_Thread_State *fts = scheme_future_thread_state; @@ -403,8 +403,8 @@ future->time_of_request = tm; future->source_of_request = who; future->source_type = src_type; - future->arg_s0 = g98; - future->arg_l1 = g99; + future->arg_s0 = g264; + future->arg_l1 = g265; future_do_runtimecall(fts, (void*)f, 0, 1, 0); fts->thread = scheme_current_thread; @@ -414,7 +414,7 @@ receive_special_result(future, retval, 1); return retval; } - Scheme_Object* scheme_rtcall_iS_s(const char *who, int src_type, prim_iS_s f, int g100, Scheme_Object** g101) + Scheme_Object* scheme_rtcall_iS_s(const char *who, int src_type, prim_iS_s f, int g266, Scheme_Object** g267) XFORM_SKIP_PROC { Scheme_Future_Thread_State *fts = scheme_future_thread_state; @@ -429,8 +429,8 @@ future->time_of_request = tm; future->source_of_request = who; future->source_type = src_type; - future->arg_i0 = g100; - future->arg_S1 = g101; + future->arg_i0 = g266; + future->arg_S1 = g267; future_do_runtimecall(fts, (void*)f, 0, 1, 0); fts->thread = scheme_current_thread; @@ -440,7 +440,7 @@ receive_special_result(future, retval, 1); return retval; } - Scheme_Object* scheme_rtcall_S_s(const char *who, int src_type, prim_S_s f, Scheme_Object** g102) + Scheme_Object* scheme_rtcall_S_s(const char *who, int src_type, prim_S_s f, Scheme_Object** g268) XFORM_SKIP_PROC { Scheme_Future_Thread_State *fts = scheme_future_thread_state; @@ -455,7 +455,7 @@ future->time_of_request = tm; future->source_of_request = who; future->source_type = src_type; - future->arg_S0 = g102; + future->arg_S0 = g268; future_do_runtimecall(fts, (void*)f, 0, 1, 0); fts->thread = scheme_current_thread; @@ -465,7 +465,7 @@ receive_special_result(future, retval, 1); return retval; } - void scheme_rtcall_s_v(const char *who, int src_type, prim_s_v f, Scheme_Object* g103) + void scheme_rtcall_s_v(const char *who, int src_type, prim_s_v f, Scheme_Object* g269) XFORM_SKIP_PROC { Scheme_Future_Thread_State *fts = scheme_future_thread_state; @@ -480,8 +480,8 @@ future->time_of_request = tm; future->source_of_request = who; future->source_type = src_type; - future->arg_s0 = g103; - send_special_result(future, g103); + future->arg_s0 = g269; + send_special_result(future, g269); future_do_runtimecall(fts, (void*)f, 0, 1, 0); fts->thread = scheme_current_thread; future = fts->thread->current_ft; @@ -490,7 +490,7 @@ } - Scheme_Object* scheme_rtcall_iSi_s(const char *who, int src_type, prim_iSi_s f, int g104, Scheme_Object** g105, int g106) + Scheme_Object* scheme_rtcall_iSi_s(const char *who, int src_type, prim_iSi_s f, int g270, Scheme_Object** g271, int g272) XFORM_SKIP_PROC { Scheme_Future_Thread_State *fts = scheme_future_thread_state; @@ -505,9 +505,9 @@ future->time_of_request = tm; future->source_of_request = who; future->source_type = src_type; - future->arg_i0 = g104; - future->arg_S1 = g105; - future->arg_i2 = g106; + future->arg_i0 = g270; + future->arg_S1 = g271; + future->arg_i2 = g272; future_do_runtimecall(fts, (void*)f, 0, 1, 0); fts->thread = scheme_current_thread; @@ -517,7 +517,7 @@ receive_special_result(future, retval, 1); return retval; } - void scheme_rtcall_siS_v(const char *who, int src_type, prim_siS_v f, Scheme_Object* g107, int g108, Scheme_Object** g109) + void scheme_rtcall_siS_v(const char *who, int src_type, prim_siS_v f, Scheme_Object* g273, int g274, Scheme_Object** g275) XFORM_SKIP_PROC { Scheme_Future_Thread_State *fts = scheme_future_thread_state; @@ -532,9 +532,9 @@ future->time_of_request = tm; future->source_of_request = who; future->source_type = src_type; - future->arg_s0 = g107; - future->arg_i1 = g108; - future->arg_S2 = g109; + future->arg_s0 = g273; + future->arg_i1 = g274; + future->arg_S2 = g275; future_do_runtimecall(fts, (void*)f, 0, 1, 0); fts->thread = scheme_current_thread; @@ -544,7 +544,7 @@ } - void* scheme_rtcall_z_p(const char *who, int src_type, prim_z_p f, size_t g110) + void* scheme_rtcall_z_p(const char *who, int src_type, prim_z_p f, size_t g276) XFORM_SKIP_PROC { Scheme_Future_Thread_State *fts = scheme_future_thread_state; @@ -559,7 +559,7 @@ future->time_of_request = tm; future->source_of_request = who; future->source_type = src_type; - future->arg_z0 = g110; + future->arg_z0 = g276; future_do_runtimecall(fts, (void*)f, 0, 1, 0); fts->thread = scheme_current_thread; @@ -569,7 +569,7 @@ return retval; } - Scheme_Object* scheme_rtcall_si_s(const char *who, int src_type, prim_si_s f, Scheme_Object* g111, int g112) + Scheme_Object* scheme_rtcall_si_s(const char *who, int src_type, prim_si_s f, Scheme_Object* g277, int g278) XFORM_SKIP_PROC { Scheme_Future_Thread_State *fts = scheme_future_thread_state; @@ -584,8 +584,8 @@ future->time_of_request = tm; future->source_of_request = who; future->source_type = src_type; - future->arg_s0 = g111; - future->arg_i1 = g112; + future->arg_s0 = g277; + future->arg_i1 = g278; future_do_runtimecall(fts, (void*)f, 0, 1, 0); fts->thread = scheme_current_thread; @@ -595,7 +595,7 @@ receive_special_result(future, retval, 1); return retval; } - void scheme_rtcall_sis_v(const char *who, int src_type, prim_sis_v f, Scheme_Object* g113, int g114, Scheme_Object* g115) + void scheme_rtcall_sis_v(const char *who, int src_type, prim_sis_v f, Scheme_Object* g279, int g280, Scheme_Object* g281) XFORM_SKIP_PROC { Scheme_Future_Thread_State *fts = scheme_future_thread_state; @@ -610,9 +610,9 @@ future->time_of_request = tm; future->source_of_request = who; future->source_type = src_type; - future->arg_s0 = g113; - future->arg_i1 = g114; - future->arg_s2 = g115; + future->arg_s0 = g279; + future->arg_i1 = g280; + future->arg_s2 = g281; future_do_runtimecall(fts, (void*)f, 0, 1, 0); fts->thread = scheme_current_thread; @@ -622,7 +622,7 @@ } - int scheme_rtcall_ss_i(const char *who, int src_type, prim_ss_i f, Scheme_Object* g116, Scheme_Object* g117) + int scheme_rtcall_ss_i(const char *who, int src_type, prim_ss_i f, Scheme_Object* g282, Scheme_Object* g283) XFORM_SKIP_PROC { Scheme_Future_Thread_State *fts = scheme_future_thread_state; @@ -637,8 +637,8 @@ future->time_of_request = tm; future->source_of_request = who; future->source_type = src_type; - future->arg_s0 = g116; - future->arg_s1 = g117; + future->arg_s0 = g282; + future->arg_s1 = g283; future_do_runtimecall(fts, (void*)f, 0, 1, 0); fts->thread = scheme_current_thread; @@ -648,7 +648,7 @@ return retval; } - void scheme_rtcall_iSp_v(const char *who, int src_type, prim_iSp_v f, int g118, Scheme_Object** g119, void* g120) + void scheme_rtcall_iSp_v(const char *who, int src_type, prim_iSp_v f, int g284, Scheme_Object** g285, void* g286) XFORM_SKIP_PROC { Scheme_Future_Thread_State *fts = scheme_future_thread_state; @@ -663,9 +663,9 @@ future->time_of_request = tm; future->source_of_request = who; future->source_type = src_type; - future->arg_i0 = g118; - future->arg_S1 = g119; - future->arg_p2 = g120; + future->arg_i0 = g284; + future->arg_S1 = g285; + future->arg_p2 = g286; future_do_runtimecall(fts, (void*)f, 0, 1, 0); fts->thread = scheme_current_thread; @@ -675,7 +675,7 @@ } - Scheme_Object* scheme_rtcall_sss_s(const char *who, int src_type, prim_sss_s f, Scheme_Object* g121, Scheme_Object* g122, Scheme_Object* g123) + Scheme_Object* scheme_rtcall_sss_s(const char *who, int src_type, prim_sss_s f, Scheme_Object* g287, Scheme_Object* g288, Scheme_Object* g289) XFORM_SKIP_PROC { Scheme_Future_Thread_State *fts = scheme_future_thread_state; @@ -690,9 +690,9 @@ future->time_of_request = tm; future->source_of_request = who; future->source_type = src_type; - future->arg_s0 = g121; - future->arg_s1 = g122; - future->arg_s2 = g123; + future->arg_s0 = g287; + future->arg_s1 = g288; + future->arg_s2 = g289; future_do_runtimecall(fts, (void*)f, 0, 1, 0); fts->thread = scheme_current_thread; @@ -727,7 +727,7 @@ } - void scheme_rtcall_iS_v(const char *who, int src_type, prim_iS_v f, int g124, Scheme_Object** g125) + void scheme_rtcall_iS_v(const char *who, int src_type, prim_iS_v f, int g290, Scheme_Object** g291) XFORM_SKIP_PROC { Scheme_Future_Thread_State *fts = scheme_future_thread_state; @@ -742,8 +742,8 @@ future->time_of_request = tm; future->source_of_request = who; future->source_type = src_type; - future->arg_i0 = g124; - future->arg_S1 = g125; + future->arg_i0 = g290; + future->arg_S1 = g291; future_do_runtimecall(fts, (void*)f, 0, 1, 0); fts->thread = scheme_current_thread; diff --git a/racket/src/racket/src/jit_ts_protos.h b/racket/src/racket/src/jit_ts_protos.h index 9bccc71519..1078efb1f0 100644 --- a/racket/src/racket/src/jit_ts_protos.h +++ b/racket/src/racket/src/jit_ts_protos.h @@ -1,87 +1,87 @@ #define SIG_siS_s 11 typedef Scheme_Object* (*prim_siS_s)(Scheme_Object*, int, Scheme_Object**); -Scheme_Object* scheme_rtcall_siS_s(const char *who, int src_type, prim_siS_s f, Scheme_Object* g183, int g184, Scheme_Object** g185); +Scheme_Object* scheme_rtcall_siS_s(const char *who, int src_type, prim_siS_s f, Scheme_Object* g349, int g350, Scheme_Object** g351); #define SIG_iSs_s 12 typedef Scheme_Object* (*prim_iSs_s)(int, Scheme_Object**, Scheme_Object*); -Scheme_Object* scheme_rtcall_iSs_s(const char *who, int src_type, prim_iSs_s f, int g186, Scheme_Object** g187, Scheme_Object* g188); +Scheme_Object* scheme_rtcall_iSs_s(const char *who, int src_type, prim_iSs_s f, int g352, Scheme_Object** g353, Scheme_Object* g354); #define SIG_s_s 13 typedef Scheme_Object* (*prim_s_s)(Scheme_Object*); -Scheme_Object* scheme_rtcall_s_s(const char *who, int src_type, prim_s_s f, Scheme_Object* g189); +Scheme_Object* scheme_rtcall_s_s(const char *who, int src_type, prim_s_s f, Scheme_Object* g355); #define SIG_n_s 14 -typedef Scheme_Object* (*prim_n_s)(Scheme_Native_Closure_Data*); -Scheme_Object* scheme_rtcall_n_s(const char *who, int src_type, prim_n_s f, Scheme_Native_Closure_Data* g190); +typedef Scheme_Object* (*prim_n_s)(Scheme_Native_Lambda*); +Scheme_Object* scheme_rtcall_n_s(const char *who, int src_type, prim_n_s f, Scheme_Native_Lambda* g356); #define SIG__s 15 typedef Scheme_Object* (*prim__s)(); Scheme_Object* scheme_rtcall__s(const char *who, int src_type, prim__s f ); #define SIG_ss_s 16 typedef Scheme_Object* (*prim_ss_s)(Scheme_Object*, Scheme_Object*); -Scheme_Object* scheme_rtcall_ss_s(const char *who, int src_type, prim_ss_s f, Scheme_Object* g191, Scheme_Object* g192); +Scheme_Object* scheme_rtcall_ss_s(const char *who, int src_type, prim_ss_s f, Scheme_Object* g357, Scheme_Object* g358); #define SIG_ssi_s 17 typedef Scheme_Object* (*prim_ssi_s)(Scheme_Object*, Scheme_Object*, int); -Scheme_Object* scheme_rtcall_ssi_s(const char *who, int src_type, prim_ssi_s f, Scheme_Object* g193, Scheme_Object* g194, int g195); +Scheme_Object* scheme_rtcall_ssi_s(const char *who, int src_type, prim_ssi_s f, Scheme_Object* g359, Scheme_Object* g360, int g361); #define SIG_tt_s 18 typedef Scheme_Object* (*prim_tt_s)(const Scheme_Object*, const Scheme_Object*); -Scheme_Object* scheme_rtcall_tt_s(const char *who, int src_type, prim_tt_s f, const Scheme_Object* g196, const Scheme_Object* g197); +Scheme_Object* scheme_rtcall_tt_s(const char *who, int src_type, prim_tt_s f, const Scheme_Object* g362, const Scheme_Object* g363); #define SIG_ss_m 19 typedef MZ_MARK_STACK_TYPE (*prim_ss_m)(Scheme_Object*, Scheme_Object*); -MZ_MARK_STACK_TYPE scheme_rtcall_ss_m(const char *who, int src_type, prim_ss_m f, Scheme_Object* g198, Scheme_Object* g199); +MZ_MARK_STACK_TYPE scheme_rtcall_ss_m(const char *who, int src_type, prim_ss_m f, Scheme_Object* g364, Scheme_Object* g365); #define SIG_Sl_s 20 typedef Scheme_Object* (*prim_Sl_s)(Scheme_Object**, intptr_t); -Scheme_Object* scheme_rtcall_Sl_s(const char *who, int src_type, prim_Sl_s f, Scheme_Object** g200, intptr_t g201); +Scheme_Object* scheme_rtcall_Sl_s(const char *who, int src_type, prim_Sl_s f, Scheme_Object** g366, intptr_t g367); #define SIG_l_s 21 typedef Scheme_Object* (*prim_l_s)(intptr_t); -Scheme_Object* scheme_rtcall_l_s(const char *who, int src_type, prim_l_s f, intptr_t g202); +Scheme_Object* scheme_rtcall_l_s(const char *who, int src_type, prim_l_s f, intptr_t g368); #define SIG_bsi_v 22 typedef void (*prim_bsi_v)(Scheme_Bucket*, Scheme_Object*, int); -void scheme_rtcall_bsi_v(const char *who, int src_type, prim_bsi_v f, Scheme_Bucket* g203, Scheme_Object* g204, int g205); +void scheme_rtcall_bsi_v(const char *who, int src_type, prim_bsi_v f, Scheme_Bucket* g369, Scheme_Object* g370, int g371); #define SIG_iiS_v 23 typedef void (*prim_iiS_v)(int, int, Scheme_Object**); -void scheme_rtcall_iiS_v(const char *who, int src_type, prim_iiS_v f, int g206, int g207, Scheme_Object** g208); +void scheme_rtcall_iiS_v(const char *who, int src_type, prim_iiS_v f, int g372, int g373, Scheme_Object** g374); #define SIG_ss_v 24 typedef void (*prim_ss_v)(Scheme_Object*, Scheme_Object*); -void scheme_rtcall_ss_v(const char *who, int src_type, prim_ss_v f, Scheme_Object* g209, Scheme_Object* g210); +void scheme_rtcall_ss_v(const char *who, int src_type, prim_ss_v f, Scheme_Object* g375, Scheme_Object* g376); #define SIG_b_v 25 typedef void (*prim_b_v)(Scheme_Bucket*); -void scheme_rtcall_b_v(const char *who, int src_type, prim_b_v f, Scheme_Bucket* g211); +void scheme_rtcall_b_v(const char *who, int src_type, prim_b_v f, Scheme_Bucket* g377); #define SIG_sl_s 26 typedef Scheme_Object* (*prim_sl_s)(Scheme_Object*, intptr_t); -Scheme_Object* scheme_rtcall_sl_s(const char *who, int src_type, prim_sl_s f, Scheme_Object* g212, intptr_t g213); +Scheme_Object* scheme_rtcall_sl_s(const char *who, int src_type, prim_sl_s f, Scheme_Object* g378, intptr_t g379); #define SIG_iS_s 27 typedef Scheme_Object* (*prim_iS_s)(int, Scheme_Object**); -Scheme_Object* scheme_rtcall_iS_s(const char *who, int src_type, prim_iS_s f, int g214, Scheme_Object** g215); +Scheme_Object* scheme_rtcall_iS_s(const char *who, int src_type, prim_iS_s f, int g380, Scheme_Object** g381); #define SIG_S_s 28 typedef Scheme_Object* (*prim_S_s)(Scheme_Object**); -Scheme_Object* scheme_rtcall_S_s(const char *who, int src_type, prim_S_s f, Scheme_Object** g216); +Scheme_Object* scheme_rtcall_S_s(const char *who, int src_type, prim_S_s f, Scheme_Object** g382); #define SIG_s_v 29 typedef void (*prim_s_v)(Scheme_Object*); -void scheme_rtcall_s_v(const char *who, int src_type, prim_s_v f, Scheme_Object* g217); +void scheme_rtcall_s_v(const char *who, int src_type, prim_s_v f, Scheme_Object* g383); #define SIG_iSi_s 30 typedef Scheme_Object* (*prim_iSi_s)(int, Scheme_Object**, int); -Scheme_Object* scheme_rtcall_iSi_s(const char *who, int src_type, prim_iSi_s f, int g218, Scheme_Object** g219, int g220); +Scheme_Object* scheme_rtcall_iSi_s(const char *who, int src_type, prim_iSi_s f, int g384, Scheme_Object** g385, int g386); #define SIG_siS_v 31 typedef void (*prim_siS_v)(Scheme_Object*, int, Scheme_Object**); -void scheme_rtcall_siS_v(const char *who, int src_type, prim_siS_v f, Scheme_Object* g221, int g222, Scheme_Object** g223); +void scheme_rtcall_siS_v(const char *who, int src_type, prim_siS_v f, Scheme_Object* g387, int g388, Scheme_Object** g389); #define SIG_z_p 32 typedef void* (*prim_z_p)(size_t); -void* scheme_rtcall_z_p(const char *who, int src_type, prim_z_p f, size_t g224); +void* scheme_rtcall_z_p(const char *who, int src_type, prim_z_p f, size_t g390); #define SIG_si_s 33 typedef Scheme_Object* (*prim_si_s)(Scheme_Object*, int); -Scheme_Object* scheme_rtcall_si_s(const char *who, int src_type, prim_si_s f, Scheme_Object* g225, int g226); +Scheme_Object* scheme_rtcall_si_s(const char *who, int src_type, prim_si_s f, Scheme_Object* g391, int g392); #define SIG_sis_v 34 typedef void (*prim_sis_v)(Scheme_Object*, int, Scheme_Object*); -void scheme_rtcall_sis_v(const char *who, int src_type, prim_sis_v f, Scheme_Object* g227, int g228, Scheme_Object* g229); +void scheme_rtcall_sis_v(const char *who, int src_type, prim_sis_v f, Scheme_Object* g393, int g394, Scheme_Object* g395); #define SIG_ss_i 35 typedef int (*prim_ss_i)(Scheme_Object*, Scheme_Object*); -int scheme_rtcall_ss_i(const char *who, int src_type, prim_ss_i f, Scheme_Object* g230, Scheme_Object* g231); +int scheme_rtcall_ss_i(const char *who, int src_type, prim_ss_i f, Scheme_Object* g396, Scheme_Object* g397); #define SIG_iSp_v 36 typedef void (*prim_iSp_v)(int, Scheme_Object**, void*); -void scheme_rtcall_iSp_v(const char *who, int src_type, prim_iSp_v f, int g232, Scheme_Object** g233, void* g234); +void scheme_rtcall_iSp_v(const char *who, int src_type, prim_iSp_v f, int g398, Scheme_Object** g399, void* g400); #define SIG_sss_s 37 typedef Scheme_Object* (*prim_sss_s)(Scheme_Object*, Scheme_Object*, Scheme_Object*); -Scheme_Object* scheme_rtcall_sss_s(const char *who, int src_type, prim_sss_s f, Scheme_Object* g235, Scheme_Object* g236, Scheme_Object* g237); +Scheme_Object* scheme_rtcall_sss_s(const char *who, int src_type, prim_sss_s f, Scheme_Object* g401, Scheme_Object* g402, Scheme_Object* g403); #define SIG__v 38 typedef void (*prim__v)(); void scheme_rtcall__v(const char *who, int src_type, prim__v f ); #define SIG_iS_v 39 typedef void (*prim_iS_v)(int, Scheme_Object**); -void scheme_rtcall_iS_v(const char *who, int src_type, prim_iS_v f, int g238, Scheme_Object** g239); +void scheme_rtcall_iS_v(const char *who, int src_type, prim_iS_v f, int g404, Scheme_Object** g405); diff --git a/racket/src/racket/src/jit_ts_runtime_glue.c b/racket/src/racket/src/jit_ts_runtime_glue.c index bdfd8ad467..3f826b8039 100644 --- a/racket/src/racket/src/jit_ts_runtime_glue.c +++ b/racket/src/racket/src/jit_ts_runtime_glue.c @@ -44,7 +44,7 @@ case SIG_n_s: { prim_n_s f = (prim_n_s)future->prim_func; GC_CAN_IGNORE Scheme_Object* retval; - JIT_TS_LOCALIZE(Scheme_Native_Closure_Data*, arg_n0); + JIT_TS_LOCALIZE(Scheme_Native_Lambda*, arg_n0); future->arg_n0 = NULL; diff --git a/racket/src/racket/src/jitarith.c b/racket/src/racket/src/jitarith.c index fcd92f139b..1df29a2c27 100644 --- a/racket/src/racket/src/jitarith.c +++ b/racket/src/racket/src/jitarith.c @@ -2224,7 +2224,7 @@ int scheme_generate_nary_arith(mz_jit_state *jitter, Scheme_App_Rec *app, use_fx = 0; if (trigger_arg == i) trigger_arg++; - } else if (SCHEME_TYPE(v) >= _scheme_compiled_values_types_) { + } else if (SCHEME_TYPE(v) >= _scheme_ir_values_types_) { use_fx = 0; mzSET_USE_FL(use_fl = 0); } diff --git a/racket/src/racket/src/jitcall.c b/racket/src/racket/src/jitcall.c index 66fcd11fe2..39d0c90fc6 100644 --- a/racket/src/racket/src/jitcall.c +++ b/racket/src/racket/src/jitcall.c @@ -28,7 +28,7 @@ #include "jit.h" #ifdef USE_FLONUM_UNBOXING -static int generate_argument_boxing(mz_jit_state *jitter, Scheme_Closure_Data *data, +static int generate_argument_boxing(mz_jit_state *jitter, Scheme_Lambda *lam, int num_rands, int args_already_in_place, int offset, int direct_flostack_offset, int save_reg, @@ -393,13 +393,13 @@ static const int direct_arg_regs[] = { JIT_V1, JIT_R1, JIT_R0 }; int scheme_generate_tail_call(mz_jit_state *jitter, int num_rands, int direct_native, int need_set_rs, int is_inline, Scheme_Native_Closure *direct_to_code, jit_direct_arg *direct_args, - Scheme_Closure_Data *direct_data) + Scheme_Lambda *direct_lam) /* Proc is in V1 unless direct_to_code, args are at RUNSTACK. If num_rands < 0, then argc is in LOCAL2 and arguments are already below RUNSTACK_BASE. If direct_native == 2, then some arguments are already in place (shallower in the runstack than the arguments to move). If direct_args, then R0, R1, V1 hold arguments. - If direct data in unboxing mode, slow path needs to box flonum arguments; num_rands + If direct lam in unboxing mode, slow path needs to box flonum arguments; num_rands must be >= 0 */ { int i, r2_has_runstack = 0; @@ -425,7 +425,7 @@ int scheme_generate_tail_call(mz_jit_state *jitter, int num_rands, int direct_na /* Right kind of function. Extract data and check stack depth: */ if (!direct_to_code) { jit_ldxi_p(JIT_R0, JIT_V1, &((Scheme_Native_Closure *)0x0)->code); - jit_ldxi_i(JIT_R2, JIT_R0, &((Scheme_Native_Closure_Data *)0x0)->max_let_depth); + jit_ldxi_i(JIT_R2, JIT_R0, &((Scheme_Native_Lambda *)0x0)->max_let_depth); mz_tl_ldi_p(JIT_R1, tl_MZ_RUNSTACK_START); jit_subr_ul(JIT_R1, JIT_RUNSTACK, JIT_R1); ref4 = jit_bltr_ul(jit_forward(), JIT_R1, JIT_R2); @@ -492,9 +492,9 @@ int scheme_generate_tail_call(mz_jit_state *jitter, int num_rands, int direct_na jit_movr_p(JIT_R2, JIT_V1); r2_has_runstack = 0; if (direct_native) { - jit_ldxi_p(JIT_V1, JIT_R0, &((Scheme_Native_Closure_Data *)0x0)->u.tail_code); + jit_ldxi_p(JIT_V1, JIT_R0, &((Scheme_Native_Lambda *)0x0)->u.tail_code); } else { - jit_ldxi_p(JIT_V1, JIT_R0, &((Scheme_Native_Closure_Data *)0x0)->arity_code); + jit_ldxi_p(JIT_V1, JIT_R0, &((Scheme_Native_Lambda *)0x0)->arity_code); } jit_movr_p(JIT_R0, JIT_R2); } @@ -553,12 +553,12 @@ int scheme_generate_tail_call(mz_jit_state *jitter, int num_rands, int direct_na mz_patch_branch(ref4); CHECK_LIMIT(); #ifdef USE_FLONUM_UNBOXING - if (direct_data) { - if (SCHEME_CLOSURE_DATA_FLAGS(direct_data) & CLOS_HAS_TYPED_ARGS) { + if (direct_lam) { + if (SCHEME_LAMBDA_FLAGS(direct_lam) & LAMBDA_HAS_TYPED_ARGS) { /* Need to box flonum arguments. Flonums are currently in the place where the target function expects them unpacked from arguments. We need to save JIT_V1. */ - generate_argument_boxing(jitter, direct_data, + generate_argument_boxing(jitter, direct_lam, num_rands, 0, 0, 0, JIT_V1, @@ -861,7 +861,7 @@ int scheme_generate_non_tail_call(mz_jit_state *jitter, int num_rands, int direc /* Before inlined native, check max let depth */ if (!nontail_self) { jit_ldxi_p(JIT_R2, JIT_V1, &((Scheme_Native_Closure *)0x0)->code); - jit_ldxi_i(JIT_R2, JIT_R2, &((Scheme_Native_Closure_Data *)0x0)->max_let_depth); + jit_ldxi_i(JIT_R2, JIT_R2, &((Scheme_Native_Lambda *)0x0)->max_let_depth); } mz_tl_ldi_p(JIT_R1, tl_MZ_RUNSTACK_START); jit_subr_ul(JIT_R1, JIT_RUNSTACK, JIT_R1); @@ -947,9 +947,9 @@ int scheme_generate_non_tail_call(mz_jit_state *jitter, int num_rands, int direc if (!nontail_self) { jit_ldxi_p(JIT_V1, JIT_R0, &((Scheme_Native_Closure *)0x0)->code); if (direct_native) { - jit_ldxi_p(JIT_V1, JIT_V1, &((Scheme_Native_Closure_Data *)0x0)->u.tail_code); + jit_ldxi_p(JIT_V1, JIT_V1, &((Scheme_Native_Lambda *)0x0)->u.tail_code); } else { - jit_ldxi_p(JIT_V1, JIT_V1, &((Scheme_Native_Closure_Data *)0x0)->arity_code); + jit_ldxi_p(JIT_V1, JIT_V1, &((Scheme_Native_Lambda *)0x0)->arity_code); if (need_set_rs) { /* In case arity check fails, need to update runstack now: */ JIT_UPDATE_THREAD_RSPTR(); @@ -1174,7 +1174,7 @@ int scheme_generate_non_tail_call(mz_jit_state *jitter, int num_rands, int direc } #ifdef USE_FLONUM_UNBOXING -static int generate_argument_boxing(mz_jit_state *jitter, Scheme_Closure_Data *data, +static int generate_argument_boxing(mz_jit_state *jitter, Scheme_Lambda *lam, int num_rands, int args_already_in_place, int offset, int direct_flostack_offset, int save_reg, @@ -1187,8 +1187,8 @@ static int generate_argument_boxing(mz_jit_state *jitter, Scheme_Closure_Data *d arg_tmp_offset = offset - direct_flostack_offset; for (i = num_rands; i--; ) { int extfl; - extfl = CLOSURE_ARGUMENT_IS_EXTFLONUM(data, i + args_already_in_place); - if (extfl || CLOSURE_ARGUMENT_IS_FLONUM(data, i + args_already_in_place)) { + extfl = CLOSURE_ARGUMENT_IS_EXTFLONUM(lam, i + args_already_in_place); + if (extfl || CLOSURE_ARGUMENT_IS_FLONUM(lam, i + args_already_in_place)) { rand = (alt_rands ? alt_rands[i+1+args_already_in_place] : (app @@ -1299,11 +1299,11 @@ static int generate_self_tail_call(Scheme_Object *rator, mz_jit_state *jitter, i int already_loaded = (i == num_rands - 1); #ifdef USE_FLONUM_UNBOXING int is_flonum, already_unboxed = 0, extfl = 0; - if ((SCHEME_CLOSURE_DATA_FLAGS(jitter->self_data) & CLOS_HAS_TYPED_ARGS) - && (CLOSURE_ARGUMENT_IS_FLONUM(jitter->self_data, i + args_already_in_place) - || CLOSURE_ARGUMENT_IS_EXTFLONUM(jitter->self_data, i + args_already_in_place))) { + if ((SCHEME_LAMBDA_FLAGS(jitter->self_lam) & LAMBDA_HAS_TYPED_ARGS) + && (CLOSURE_ARGUMENT_IS_FLONUM(jitter->self_lam, i + args_already_in_place) + || CLOSURE_ARGUMENT_IS_EXTFLONUM(jitter->self_lam, i + args_already_in_place))) { is_flonum = 1; - extfl = CLOSURE_ARGUMENT_IS_EXTFLONUM(jitter->self_data, i + args_already_in_place); + extfl = CLOSURE_ARGUMENT_IS_EXTFLONUM(jitter->self_lam, i + args_already_in_place); rand = (alt_rands ? alt_rands[i+1+args_already_in_place] : app->args[i+1+args_already_in_place]); @@ -1357,8 +1357,8 @@ static int generate_self_tail_call(Scheme_Object *rator, mz_jit_state *jitter, i #ifdef USE_FLONUM_UNBOXING /* Need to box any arguments that we have only in flonum form */ - if (SCHEME_CLOSURE_DATA_FLAGS(jitter->self_data) & CLOS_HAS_TYPED_ARGS) { - generate_argument_boxing(jitter, jitter->self_data, + if (SCHEME_LAMBDA_FLAGS(jitter->self_lam) & LAMBDA_HAS_TYPED_ARGS) { + generate_argument_boxing(jitter, jitter->self_lam, num_rands, args_already_in_place, offset, direct_flostack_offset, JIT_R0, @@ -1367,21 +1367,21 @@ static int generate_self_tail_call(Scheme_Object *rator, mz_jit_state *jitter, i /* Arguments already in place may also need to be boxed. */ arg_tmp_offset = jitter->self_restart_offset; - for (i = jitter->self_data->closure_size; i--; ) { + for (i = jitter->self_lam->closure_size; i--; ) { /* Skip over flonums unpacked from the closure. I think this never happens, because I think that a self-call with already-in-place flonum arguments will only happen when the closure is empty. */ - if (CLOSURE_CONTENT_IS_FLONUM(jitter->self_data, i)) + if (CLOSURE_CONTENT_IS_FLONUM(jitter->self_lam, i)) arg_tmp_offset -= sizeof(double); - else if (CLOSURE_CONTENT_IS_EXTFLONUM(jitter->self_data, i)) + else if (CLOSURE_CONTENT_IS_EXTFLONUM(jitter->self_lam, i)) arg_tmp_offset -= 2*sizeof(double); } for (i = 0; i < args_already_in_place; i++) { - if (CLOSURE_ARGUMENT_IS_FLONUM(jitter->self_data, i) - || CLOSURE_ARGUMENT_IS_EXTFLONUM(jitter->self_data, i)) { + if (CLOSURE_ARGUMENT_IS_FLONUM(jitter->self_lam, i) + || CLOSURE_ARGUMENT_IS_EXTFLONUM(jitter->self_lam, i)) { GC_CAN_IGNORE jit_insn *iref; int extfl USED_ONLY_IF_LONG_DOUBLE; - extfl = CLOSURE_ARGUMENT_IS_EXTFLONUM(jitter->self_data, i); + extfl = CLOSURE_ARGUMENT_IS_EXTFLONUM(jitter->self_lam, i); mz_pushr_p(JIT_R0); mz_ld_runstack_base_alt(JIT_R2); jit_subi_p(JIT_R2, JIT_RUNSTACK_BASE_OR_ALT(JIT_R2), WORDS_TO_BYTES(num_rands + args_already_in_place)); @@ -1717,7 +1717,7 @@ static int generate_fp_argument_shift(int direct_flostack_offset, mz_jit_state * static int generate_call_path_with_unboxes(mz_jit_state *jitter, int direct_flostack_offset, void *unboxed_code, GC_CAN_IGNORE jit_insn **_refdone, - int num_rands, Scheme_Closure_Data *direct_data, Scheme_Object *rator) + int num_rands, Scheme_Lambda *direct_lam, Scheme_Object *rator) { GC_CAN_IGNORE jit_insn *refdone, *refgo, *refcopy; int i, k, offset; @@ -1753,11 +1753,11 @@ static int generate_call_path_with_unboxes(mz_jit_state *jitter, int direct_flos /* box arguments for slow path */ for (i = 0, k = 0; i < num_rands; i++) { - if ((SCHEME_CLOSURE_DATA_FLAGS(direct_data) & CLOS_HAS_TYPED_ARGS) - && (CLOSURE_ARGUMENT_IS_FLONUM(direct_data, i) - || CLOSURE_ARGUMENT_IS_EXTFLONUM(direct_data, i))) { + if ((SCHEME_LAMBDA_FLAGS(direct_lam) & LAMBDA_HAS_TYPED_ARGS) + && (CLOSURE_ARGUMENT_IS_FLONUM(direct_lam, i) + || CLOSURE_ARGUMENT_IS_EXTFLONUM(direct_lam, i))) { int extfl; - extfl = CLOSURE_ARGUMENT_IS_EXTFLONUM(direct_data, i); + extfl = CLOSURE_ARGUMENT_IS_EXTFLONUM(direct_lam, i); offset = jitter->flostack_offset - k; offset = JIT_FRAME_FLOSTACK_OFFSET - offset; @@ -1788,7 +1788,7 @@ int scheme_generate_app(Scheme_App_Rec *app, Scheme_Object **alt_rands, int num_ Scheme_Native_Closure *inline_direct_native = NULL; int almost_inline_direct_native = 0; #ifdef USE_FLONUM_UNBOXING - Scheme_Closure_Data *direct_data = NULL; + Scheme_Lambda *direct_lam = NULL; #endif int direct_flostack_offset = 0, unboxed_non_tail_args = 0; jit_direct_arg *inline_direct_args = NULL; @@ -1812,7 +1812,7 @@ int scheme_generate_app(Scheme_App_Rec *app, Scheme_Object **alt_rands, int num_ && (scheme_is_noncm(rator, jitter, 0, 0) || is_noncm_hash_ref(rator, num_rands, app) /* It's also ok to directly call `values' if multiple values are ok: */ - || (multi_ok && SAME_OBJ(rator, scheme_values_func)))) + || (multi_ok && SAME_OBJ(rator, scheme_values_proc)))) direct_prim = 1; else { reorder_ok = 1; @@ -1880,13 +1880,13 @@ int scheme_generate_app(Scheme_App_Rec *app, Scheme_Object **alt_rands, int num_ direct_native = can_direct_native(rator, num_rands, &extract_case); reorder_ok = 1; } else if (SAME_TYPE(t, scheme_closure_type)) { - Scheme_Closure_Data *data; - data = ((Scheme_Closure *)rator)->code; - if ((data->num_params == num_rands) - && !(SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_HAS_REST)) { + Scheme_Lambda *lam; + lam = ((Scheme_Closure *)rator)->code; + if ((lam->num_params == num_rands) + && !(SCHEME_LAMBDA_FLAGS(lam) & LAMBDA_HAS_REST)) { direct_native = 1; - if (SAME_OBJ(data->u.jit_clone, jitter->self_data) + if (SAME_OBJ(lam->u.jit_clone, jitter->self_lam) && (num_rands < MAX_SHARED_CALL_RANDS)) { if (is_tail) direct_self = 1; @@ -1903,7 +1903,7 @@ int scheme_generate_app(Scheme_App_Rec *app, Scheme_Object **alt_rands, int num_ for this function --- only works if we can JIT the target of the call. */ Scheme_Native_Closure *nc; - nc = (Scheme_Native_Closure *)scheme_jit_closure((Scheme_Object *)data, NULL); + nc = (Scheme_Native_Closure *)scheme_jit_closure((Scheme_Object *)lam, NULL); if (nc->code->start_code == scheme_on_demand_jit_code) { if (nc->code->arity_code != sjc.in_progress_on_demand_jit_arity_code) { scheme_on_demand_generate_lambda(nc, 0, NULL, 0); @@ -1916,12 +1916,12 @@ int scheme_generate_app(Scheme_App_Rec *app, Scheme_Object **alt_rands, int num_ jitter->max_tail_depth = nc->code->max_let_depth; inline_direct_native = nc; #ifdef USE_FLONUM_UNBOXING - direct_data = data; + direct_lam = lam; #endif } else { if (num_rands < MAX_SHARED_CALL_RANDS) { #ifdef USE_FLONUM_UNBOXING - direct_data = data; + direct_lam = lam; #endif unboxed_non_tail_args = 1; } @@ -1932,7 +1932,7 @@ int scheme_generate_app(Scheme_App_Rec *app, Scheme_Object **alt_rands, int num_ and a runstack-space check, but we can still handle unboxed arguments. */ #ifdef USE_FLONUM_UNBOXING - direct_data = data; + direct_lam = lam; #endif almost_inline_direct_native = 1; } @@ -1962,8 +1962,8 @@ int scheme_generate_app(Scheme_App_Rec *app, Scheme_Object **alt_rands, int num_ /* Direct native tail with same number of args as just received? */ if (direct_native && is_tail && num_rands && !almost_inline_direct_native - && (num_rands == jitter->self_data->num_params) - && !(SCHEME_CLOSURE_DATA_FLAGS(jitter->self_data) & CLOS_HAS_REST)) { + && (num_rands == jitter->self_lam->num_params) + && !(SCHEME_LAMBDA_FLAGS(jitter->self_lam) & LAMBDA_HAS_REST)) { /* Check whether the actual arguments refer to Scheme-stack locations that will be filled with argument values; that is, check how many arguments are already in place for @@ -2078,22 +2078,22 @@ int scheme_generate_app(Scheme_App_Rec *app, Scheme_Object **alt_rands, int num_ #ifdef USE_FLONUM_UNBOXING if (direct_self && is_tail) - direct_data = jitter->self_data; + direct_lam = jitter->self_lam; #endif #ifdef JIT_PRECISE_GC - FOR_LOG(if (direct_data) { LOG_IT((" [typed]\n")); } ) + FOR_LOG(if (direct_lam) { LOG_IT((" [typed]\n")); } ) #endif #ifdef USE_FLONUM_UNBOXING /* we want to push flonums into local storage in reverse order of evaluation, so make a pass to create space: */ - if (direct_data - && (SCHEME_CLOSURE_DATA_FLAGS(direct_data) & CLOS_HAS_TYPED_ARGS)) { + if (direct_lam + && (SCHEME_LAMBDA_FLAGS(direct_lam) & LAMBDA_HAS_TYPED_ARGS)) { for (i = num_rands; i--; ) { int extfl; - extfl = CLOSURE_ARGUMENT_IS_EXTFLONUM(direct_data, i+args_already_in_place); - if (extfl || CLOSURE_ARGUMENT_IS_FLONUM(direct_data, i+args_already_in_place)) { + extfl = CLOSURE_ARGUMENT_IS_EXTFLONUM(direct_lam, i+args_already_in_place); + if (extfl || CLOSURE_ARGUMENT_IS_FLONUM(direct_lam, i+args_already_in_place)) { /* make space: */ scheme_generate_flonum_local_unboxing(jitter, 0, 1, extfl); CHECK_LIMIT(); @@ -2113,13 +2113,13 @@ int scheme_generate_app(Scheme_App_Rec *app, Scheme_Object **alt_rands, int num_ need_safety = 0; } #ifdef USE_FLONUM_UNBOXING - if (direct_data - && (SCHEME_CLOSURE_DATA_FLAGS(direct_data) & CLOS_HAS_TYPED_ARGS) - && (CLOSURE_ARGUMENT_IS_FLONUM(direct_data, i+args_already_in_place) - || CLOSURE_ARGUMENT_IS_EXTFLONUM(direct_data, i+args_already_in_place))) { + if (direct_lam + && (SCHEME_LAMBDA_FLAGS(direct_lam) & LAMBDA_HAS_TYPED_ARGS) + && (CLOSURE_ARGUMENT_IS_FLONUM(direct_lam, i+args_already_in_place) + || CLOSURE_ARGUMENT_IS_EXTFLONUM(direct_lam, i+args_already_in_place))) { int directly; int extfl; - extfl = CLOSURE_ARGUMENT_IS_EXTFLONUM(direct_data, i+args_already_in_place); + extfl = CLOSURE_ARGUMENT_IS_EXTFLONUM(direct_lam, i+args_already_in_place); jitter->unbox++; MZ_FPUSEL_STMT_ONLY(extfl, jitter->unbox_extflonum++); if (scheme_can_unbox_inline(arg, 5, JIT_FPUSEL_FPR_NUM(extfl)-1, 0, extfl)) @@ -2284,7 +2284,7 @@ int scheme_generate_app(Scheme_App_Rec *app, Scheme_Object **alt_rands, int num_ scheme_generate_tail_call(jitter, num_rands, direct_native, jitter->need_set_rs, 1, inline_direct_native, inline_direct_args, #ifdef USE_FLONUM_UNBOXING - almost_inline_direct_native ? direct_data : NULL + almost_inline_direct_native ? direct_lam : NULL #else NULL #endif @@ -2355,7 +2355,7 @@ int scheme_generate_app(Scheme_App_Rec *app, Scheme_Object **alt_rands, int num_ #ifdef USE_FLONUM_UNBOXING if (unboxed_code) { generate_call_path_with_unboxes(jitter, direct_flostack_offset, unboxed_code, &refdone, - num_rands, direct_data, rator); + num_rands, direct_lam, rator); CHECK_LIMIT(); } #endif diff --git a/racket/src/racket/src/jitcommon.c b/racket/src/racket/src/jitcommon.c index 98d34274e1..11ca5ba8e8 100644 --- a/racket/src/racket/src/jitcommon.c +++ b/racket/src/racket/src/jitcommon.c @@ -218,7 +218,7 @@ static int common0(mz_jit_state *jitter, void *_data) mz_push_threadlocal(in); jit_movi_i(JIT_R1, -1); jit_ldxi_p(JIT_V1, JIT_R0, &((Scheme_Native_Closure *)0x0)->code); - jit_ldxi_p(JIT_V1, JIT_V1, &((Scheme_Native_Closure_Data *)0x0)->arity_code); + jit_ldxi_p(JIT_V1, JIT_V1, &((Scheme_Native_Lambda *)0x0)->arity_code); jit_jmpr(JIT_V1); /* leads to a jit_ret() that assumes NATIVE_ARG_COUNT arguments */ CHECK_LIMIT(); @@ -238,7 +238,7 @@ static int common0(mz_jit_state *jitter, void *_data) jit_movi_i(JIT_R1, -1); (void)jit_movi_p(JIT_R2, 0x0); jit_ldxi_p(JIT_V1, JIT_R0, &((Scheme_Native_Closure *)0x0)->code); - jit_ldxi_p(JIT_V1, JIT_V1, &((Scheme_Native_Closure_Data *)0x0)->arity_code); + jit_ldxi_p(JIT_V1, JIT_V1, &((Scheme_Native_Lambda *)0x0)->arity_code); jit_jmpr(JIT_V1); /* leads to a jit_ret() that assumes NATIVE_ARG_COUNT arguments */ CHECK_LIMIT(); @@ -806,7 +806,7 @@ static int common2(mz_jit_state *jitter, void *_data) /* Also, check that the runstack is big enough with the revised max_let_depth. */ jit_ldxi_p(JIT_V1, JIT_R0, &((Scheme_Native_Closure *)0x0)->code); - jit_ldxi_i(JIT_V1, JIT_V1, &((Scheme_Native_Closure_Data *)0x0)->max_let_depth); + jit_ldxi_i(JIT_V1, JIT_V1, &((Scheme_Native_Lambda *)0x0)->max_let_depth); mz_set_local_p(JIT_R2, JIT_LOCAL2); mz_tl_ldi_p(JIT_R2, tl_MZ_RUNSTACK_START); jit_subr_ul(JIT_R2, JIT_RUNSTACK, JIT_R2); @@ -822,7 +822,7 @@ static int common2(mz_jit_state *jitter, void *_data) mz_st_runstack_base_alt(JIT_V1); /* Extract function and jump: */ jit_ldxi_p(JIT_V1, JIT_R0, &((Scheme_Native_Closure *)0x0)->code); - jit_ldxi_p(JIT_V1, JIT_V1, &((Scheme_Native_Closure_Data *)0x0)->arity_code); + jit_ldxi_p(JIT_V1, JIT_V1, &((Scheme_Native_Lambda *)0x0)->arity_code); jit_jmpr(JIT_V1); CHECK_LIMIT(); /* Slower path (non-tail) when argv != runstack. */ @@ -3173,9 +3173,9 @@ static int common10(mz_jit_state *jitter, void *_data) /* native: */ mz_patch_branch(ref_nc); jit_ldxi_p(JIT_V1, JIT_R0, &((Scheme_Native_Closure *)0x0)->code); - jit_ldxi_i(JIT_R2, JIT_V1, &((Scheme_Native_Closure_Data *)0x0)->closure_size); + jit_ldxi_i(JIT_R2, JIT_V1, &((Scheme_Native_Lambda *)0x0)->closure_size); (void)jit_blti_i(refslow, JIT_R2, 0); /* case lambda */ - jit_ldxi_p(JIT_R2, JIT_V1, &((Scheme_Native_Closure_Data *)0x0)->start_code); + jit_ldxi_p(JIT_R2, JIT_V1, &((Scheme_Native_Lambda *)0x0)->start_code); /* patchable_movi_p doesn't depend on actual address, which might change size: */ (void)jit_patchable_movi_p(JIT_V1, scheme_on_demand_jit_code); ref_nc = jit_beqr_p(jit_forward(), JIT_R2, JIT_V1); /* not yet JITted? */ @@ -3196,11 +3196,11 @@ static int common10(mz_jit_state *jitter, void *_data) /* not-yet-JITted native: */ mz_patch_branch(ref_nc); jit_ldxi_p(JIT_V1, JIT_R0, &((Scheme_Native_Closure *)0x0)->code); - jit_ldxi_p(JIT_R0, JIT_V1, &((Scheme_Native_Closure_Data *)0x0)->u2.orig_code); + jit_ldxi_p(JIT_R0, JIT_V1, &((Scheme_Native_Lambda *)0x0)->u2.orig_code); jit_rshi_l(JIT_V1, JIT_R1, 1); - jit_ldxi_i(JIT_R2, JIT_R0, &((Scheme_Closure_Data *)0x0)->num_params); - jit_ldxi_s(JIT_R0, JIT_R0, &SCHEME_CLOSURE_DATA_FLAGS(((Scheme_Closure_Data *)0x0))); - ref_nc = jit_bmsi_i(jit_forward(), JIT_R0, CLOS_HAS_REST); + jit_ldxi_i(JIT_R2, JIT_R0, &((Scheme_Lambda *)0x0)->num_params); + jit_ldxi_s(JIT_R0, JIT_R0, &SCHEME_LAMBDA_FLAGS(((Scheme_Lambda *)0x0))); + ref_nc = jit_bmsi_i(jit_forward(), JIT_R0, LAMBDA_HAS_REST); (void)jit_bner_i(refno, JIT_V1, JIT_R2); (void)jit_movi_p(JIT_R0, scheme_true); mz_epilog(JIT_R2); diff --git a/racket/src/racket/src/jitprep.c b/racket/src/racket/src/jitprep.c index 3b8978f81c..3ab7064753 100644 --- a/racket/src/racket/src/jitprep.c +++ b/racket/src/racket/src/jitprep.c @@ -302,11 +302,11 @@ static Scheme_Object *define_values_jit(Scheme_Object *data) { Scheme_Object *orig = SCHEME_VEC_ELS(data)[0], *naya; - if (SAME_TYPE(SCHEME_TYPE(orig), scheme_unclosed_procedure_type) + if (SAME_TYPE(SCHEME_TYPE(orig), scheme_lambda_type) && (SCHEME_VEC_SIZE(data) == 2)) naya = scheme_jit_closure(orig, SCHEME_VEC_ELS(data)[1]); else if (SAME_TYPE(SCHEME_TYPE(orig), scheme_inline_variant_type) - && SAME_TYPE(SCHEME_TYPE(SCHEME_VEC_ELS(orig)[0]), scheme_unclosed_procedure_type) + && SAME_TYPE(SCHEME_TYPE(SCHEME_VEC_ELS(orig)[0]), scheme_lambda_type) && (SCHEME_VEC_SIZE(data) == 2)) { naya = scheme_jit_closure(SCHEME_VEC_ELS(orig)[0], SCHEME_VEC_ELS(data)[1]); if (!SAME_OBJ(naya, SCHEME_VEC_ELS(orig)[0])) @@ -409,7 +409,7 @@ Scheme_Object *scheme_case_lambda_jit(Scheme_Object *expr) if (!seqin->native_code) { Scheme_Case_Lambda *seqout; - Scheme_Native_Closure_Data *ndata; + Scheme_Native_Lambda *ndata; Scheme_Object *val, *name; int i, cnt, size, all_closed = 1; @@ -431,8 +431,8 @@ Scheme_Object *scheme_case_lambda_jit(Scheme_Object *expr) val = (Scheme_Object *)((Scheme_Closure *)val)->code; seqout->array[i] = val; } - ((Scheme_Closure_Data *)val)->name = name; - if (((Scheme_Closure_Data *)val)->closure_size) + ((Scheme_Lambda *)val)->name = name; + if (((Scheme_Lambda *)val)->closure_size) all_closed = 0; } @@ -448,7 +448,7 @@ Scheme_Object *scheme_case_lambda_jit(Scheme_Object *expr) for (i = 0; i < cnt; i++) { val = seqout->array[i]; if (!SCHEME_PROCP(val)) { - val = scheme_make_native_closure(((Scheme_Closure_Data *)val)->u.native_code); + val = scheme_make_native_closure(((Scheme_Lambda *)val)->u.native_code); } nc->vals[i] = val; } @@ -461,10 +461,10 @@ Scheme_Object *scheme_case_lambda_jit(Scheme_Object *expr) for (i = 0; i < cnt; i++) { val = seqout->array[i]; if (!SCHEME_PROCP(val)) { - Scheme_Closure_Data *data; - data = MALLOC_ONE_TAGGED(Scheme_Closure_Data); - memcpy(data, val, sizeof(Scheme_Closure_Data)); - data->code = NULL; + Scheme_Lambda *data; + data = MALLOC_ONE_TAGGED(Scheme_Lambda); + memcpy(data, val, sizeof(Scheme_Lambda)); + data->body = NULL; seqout->array[i] = (Scheme_Object *)data; } } @@ -548,7 +548,7 @@ Scheme_Object *scheme_jit_closure(Scheme_Object *code, Scheme_Object *context) for JIT compilation. */ { #ifdef MZ_USE_JIT - Scheme_Closure_Data *data = (Scheme_Closure_Data *)code, *data2; + Scheme_Lambda *data = (Scheme_Lambda *)code, *data2; /* We need to cache clones to support multiple references to a zero-sized closure in bytecode. We need either a clone @@ -561,10 +561,10 @@ Scheme_Object *scheme_jit_closure(Scheme_Object *code, Scheme_Object *context) data2 = NULL; if (!data2) { - Scheme_Native_Closure_Data *ndata; + Scheme_Native_Lambda *ndata; - data2 = MALLOC_ONE_TAGGED(Scheme_Closure_Data); - memcpy(data2, code, sizeof(Scheme_Closure_Data)); + data2 = MALLOC_ONE_TAGGED(Scheme_Lambda); + memcpy(data2, code, sizeof(Scheme_Lambda)); data2->context = context; @@ -607,7 +607,7 @@ Scheme_Object *scheme_jit_expr(Scheme_Object *expr) return jit_branch(expr); case scheme_with_cont_mark_type: return jit_wcm(expr); - case scheme_unclosed_procedure_type: + case scheme_lambda_type: return scheme_jit_closure(expr, NULL); case scheme_let_value_type: return jit_let_value(expr); diff --git a/racket/src/racket/src/jitstack.c b/racket/src/racket/src/jitstack.c index 3663ac665d..1ab8297151 100644 --- a/racket/src/racket/src/jitstack.c +++ b/racket/src/racket/src/jitstack.c @@ -676,7 +676,7 @@ void scheme_jit_now(Scheme_Object *f) { if (SAME_TYPE(SCHEME_TYPE(f), scheme_native_closure_type)) { Scheme_Native_Closure *nc; - Scheme_Native_Closure_Data *ncd; + Scheme_Native_Lambda *ncd; nc = (Scheme_Native_Closure*)f; ncd = nc->code; diff --git a/racket/src/racket/src/jitstate.c b/racket/src/racket/src/jitstate.c index 863f9c9ade..2a2c382585 100644 --- a/racket/src/racket/src/jitstate.c +++ b/racket/src/racket/src/jitstate.c @@ -58,7 +58,7 @@ int scheme_mz_retain_it(mz_jit_state *jitter, void *v) jitter->retain_start[jitter->retained] = v; #ifdef JIT_PRECISE_GC /* We just change an array that is marked indirectly for GC - via a Scheme_Native_Closure_Data. Write to that record + via a Scheme_Native_Lambda. Write to that record so that a minor GC will trace it and therefore trace the reatined array: */ if (jitter->retaining_data) { @@ -180,7 +180,7 @@ void *scheme_generate_one(mz_jit_state *old_jitter, void *data, int gcable, void *save_ptr, - Scheme_Native_Closure_Data *ndata) + Scheme_Native_Lambda *ndata) /* The given generate() function is called at least twice: once to gather the size of the generated code (at a temporary location), and again to generate the final code at its final location. The size of the diff --git a/racket/src/racket/src/letrec_check.c b/racket/src/racket/src/letrec_check.c index c447f33a9c..90c55b9cca 100644 --- a/racket/src/racket/src/letrec_check.c +++ b/racket/src/racket/src/letrec_check.c @@ -158,7 +158,7 @@ typedef struct Scheme_Deferred_Expr { int done; /* the expression that has been deferred */ - Scheme_Closure_Data *expr; + Scheme_Lambda *expr; /* the frame that existed when the expr was deferred */ Letrec_Check_Frame *frame; @@ -175,8 +175,8 @@ static Letrec_Check_Frame *init_letrec_check_frame(int frame_type, int subexpr, mzshort count, Letrec_Check_Frame *prev, Letrec_Check_Frame *share_with, - Scheme_Let_Header *head, - Scheme_Closure_Data *data) + Scheme_IR_Let_Header *head, + Scheme_Lambda *lam) { Scheme_Deferred_Expr **chain; Letrec_Check_Frame *frame; @@ -194,20 +194,20 @@ static Letrec_Check_Frame *init_letrec_check_frame(int frame_type, int subexpr, frame->next = prev; if (head) { - Scheme_Compiled_Let_Value *clv = (Scheme_Compiled_Let_Value *)head->body; + Scheme_IR_Let_Value *irlv = (Scheme_IR_Let_Value *)head->body; pos = 0; - for (i = head->num_clauses; i--; clv = (Scheme_Compiled_Let_Value *)clv->body) { - for (j = 0; j < clv->count; j++) { - clv->vars[j]->mode = SCHEME_VAR_MODE_LETREC_CHECK; - clv->vars[j]->letrec_check.frame = frame; - clv->vars[j]->letrec_check.frame_pos = pos++; + for (i = head->num_clauses; i--; irlv = (Scheme_IR_Let_Value *)irlv->body) { + for (j = 0; j < irlv->count; j++) { + irlv->vars[j]->mode = SCHEME_VAR_MODE_LETREC_CHECK; + irlv->vars[j]->letrec_check.frame = frame; + irlv->vars[j]->letrec_check.frame_pos = pos++; } } - } else if (data) { - for (j = data->num_params; j--; ) { - ((Closure_Info *)data->closure_map)->vars[j]->mode = SCHEME_VAR_MODE_LETREC_CHECK; - ((Closure_Info *)data->closure_map)->vars[j]->letrec_check.frame = frame; - ((Closure_Info *)data->closure_map)->vars[j]->letrec_check.frame_pos = j; + } else if (lam) { + for (j = lam->num_params; j--; ) { + lam->ir_info->vars[j]->mode = SCHEME_VAR_MODE_LETREC_CHECK; + lam->ir_info->vars[j]->letrec_check.frame = frame; + lam->ir_info->vars[j]->letrec_check.frame_pos = j; } } @@ -270,7 +270,7 @@ static Letrec_Check_Frame *get_nearest_rhs(Letrec_Check_Frame *frame) /* returns the frame that was created when pos was created, and changes pos to be relative to that frame */ -static Letrec_Check_Frame *get_relative_frame(int *pos, Scheme_Compiled_Local *var) +static Letrec_Check_Frame *get_relative_frame(int *pos, Scheme_IR_Local *var) { *pos = var->letrec_check.frame_pos; return var->letrec_check.frame; @@ -294,7 +294,7 @@ static void update_frame(Letrec_Check_Frame *outer, Letrec_Check_Frame *inner, } /* creates a deferred expression "closure" by closing over the frame */ -static Scheme_Deferred_Expr *make_deferred_expr_closure(Scheme_Closure_Data *expr, Letrec_Check_Frame *frame) +static Scheme_Deferred_Expr *make_deferred_expr_closure(Scheme_Lambda *expr, Letrec_Check_Frame *frame) { Scheme_Deferred_Expr *clos; @@ -312,9 +312,9 @@ static Scheme_Deferred_Expr *make_deferred_expr_closure(Scheme_Closure_Data *exp static Scheme_Object *letrec_check_expr(Scheme_Object *, Letrec_Check_Frame *, Scheme_Object *); -static void letrec_check_lets_resume(Letrec_Check_Frame *frame, Scheme_Let_Header *head) +static void letrec_check_lets_resume(Letrec_Check_Frame *frame, Scheme_IR_Let_Header *head) { - Scheme_Compiled_Let_Value *clv; + Scheme_IR_Let_Value *irlv; Scheme_Object *body; int i, j, k; int was_checked; @@ -327,20 +327,20 @@ static void letrec_check_lets_resume(Letrec_Check_Frame *frame, Scheme_Let_Heade variable is not used in application position */ k = head->count; for (i = head->num_clauses; i--;) { - clv = (Scheme_Compiled_Let_Value *) body; - k -= clv->count; - for (j = 0; j < clv->count; j++) { + irlv = (Scheme_IR_Let_Value *) body; + k -= irlv->count; + for (j = 0; j < irlv->count; j++) { was_checked = (frame->ref[k + j] & LET_CHECKED); if (was_checked) - clv->vars[j]->non_app_count = clv->vars[j]->use_count; + irlv->vars[j]->non_app_count = irlv->vars[j]->use_count; } - body = clv->body; + body = irlv->body; } } } /* records that we have seen a reference to loc */ -static Scheme_Object *record_checked(Scheme_Compiled_Local *loc, Letrec_Check_Frame *frame) +static Scheme_Object *record_checked(Scheme_IR_Local *loc, Letrec_Check_Frame *frame) { int position; @@ -354,7 +354,7 @@ static Scheme_Object *letrec_check_local(Scheme_Object *o, Letrec_Check_Frame *f Scheme_Object *pos) { Letrec_Check_Frame *in_frame; - Scheme_Compiled_Local *loc = (Scheme_Compiled_Local *)o; + Scheme_IR_Local *loc = (Scheme_IR_Local *)o; int in_position; in_frame = get_relative_frame(&in_position, loc); @@ -555,26 +555,26 @@ static Scheme_Object *letrec_check_wcm(Scheme_Object *o, Letrec_Check_Frame *fra return o; } -static Scheme_Object *letrec_check_closure_compilation(Scheme_Object *o, Letrec_Check_Frame *frame, Scheme_Object *pos) +static Scheme_Object *letrec_check_lambda(Scheme_Object *o, Letrec_Check_Frame *frame, Scheme_Object *pos) { - Scheme_Closure_Data *data; + Scheme_Lambda *lam; Letrec_Check_Frame *new_frame; Scheme_Object *val; int num_params; - data = (Scheme_Closure_Data *)o; + lam = (Scheme_Lambda *)o; /* if we have not entered a letrec, pos will be false */ if (SCHEME_FALSEP(pos)) { - num_params = data->num_params; + num_params = lam->num_params; new_frame = init_letrec_check_frame(FRAME_TYPE_CLOSURE, LET_BODY_EXPR, num_params, frame, NULL, - NULL, data); + NULL, lam); SCHEME_ASSERT(num_params >= 0, "lambda has negative arguments what do"); - val = letrec_check_expr(data->code, new_frame, pos); - data->code = val; + val = letrec_check_expr(lam->body, new_frame, pos); + lam->body = val; } else { /* we can defer this lambda because it is not inside an application! hurray! */ @@ -588,7 +588,7 @@ static Scheme_Object *letrec_check_closure_compilation(Scheme_Object *o, Letrec_ appeared in, and update the frame where the binding lives (which may be an enclosing frame) */ outer_frame = get_nearest_rhs(frame); - clos = make_deferred_expr_closure(data, frame); + clos = make_deferred_expr_closure(lam, frame); while (SCHEME_INTP(pos) || SCHEME_PAIRP(pos)) { int position; @@ -614,12 +614,12 @@ static Scheme_Object *letrec_check_closure_compilation(Scheme_Object *o, Letrec_ static void letrec_check_deferred_expr(Scheme_Object *o) { Scheme_Deferred_Expr *clos; - Scheme_Closure_Data *data; + Scheme_Lambda *lam; Letrec_Check_Frame *inner, *new_frame; Scheme_Object *val; int num_params; - /* gets the closed over data from clos, which will always be a + /* gets the closed over lam from clos, which will always be a deferred expression that contains a closure */ clos = (Scheme_Deferred_Expr *)o; @@ -630,25 +630,25 @@ static void letrec_check_deferred_expr(Scheme_Object *o) SCHEME_ASSERT(SAME_TYPE(SCHEME_TYPE(clos), scheme_deferred_expr_type), "letrec_check_deferred_expr: clos is not a scheme_deferred_expr"); - data = (Scheme_Closure_Data *)clos->expr; - SCHEME_ASSERT(SAME_TYPE(SCHEME_TYPE(data), scheme_compiled_unclosed_procedure_type), + lam = (Scheme_Lambda *)clos->expr; + SCHEME_ASSERT(SAME_TYPE(SCHEME_TYPE(lam), scheme_ir_lambda_type), "deferred expression does not contain a lambda"); inner = clos->frame; - num_params = data->num_params; + num_params = lam->num_params; new_frame = init_letrec_check_frame(FRAME_TYPE_CLOSURE, LET_BODY_EXPR, num_params, inner, NULL, - NULL, data); + NULL, lam); - val = letrec_check_expr(data->code, new_frame, scheme_false); - data->code = val; + val = letrec_check_expr(lam->body, new_frame, scheme_false); + lam->body = val; } static void clean_dead_deferred_expr(Scheme_Deferred_Expr *clos) { - Scheme_Closure_Data *data; + Scheme_Lambda *lam; /* We keep a global chain of all deferred expression. A deferred expression that is never forced is a function that is never @@ -660,12 +660,12 @@ static void clean_dead_deferred_expr(Scheme_Deferred_Expr *clos) "letrec_check_deferred_expr: clos is not a scheme_deferred_expr"); if (!clos->done) { - data = (Scheme_Closure_Data *)clos->expr; - SCHEME_ASSERT(SAME_TYPE(SCHEME_TYPE(data), scheme_compiled_unclosed_procedure_type), + lam = (Scheme_Lambda *)clos->expr; + SCHEME_ASSERT(SAME_TYPE(SCHEME_TYPE(lam), scheme_ir_lambda_type), "deferred expression does not contain a lambda"); /* Since this deferral was never done, it's dead code. */ - data->code = scheme_void; + lam->body = scheme_void; clos->done = 1; } @@ -692,14 +692,14 @@ static void process_deferred_bindings(Letrec_Check_Frame *frame, int position) static Scheme_Object *letrec_check_lets(Scheme_Object *o, Letrec_Check_Frame *old_frame, Scheme_Object *pos) { Letrec_Check_Frame *frame, *body_frame; - Scheme_Compiled_Let_Value *clv; + Scheme_IR_Let_Value *irlv; Scheme_Object *body, *val; int i, j, k; /* gets the information out of our header about the number of total clauses, the number of total bindings, and whether or not this let is recursive */ - Scheme_Let_Header *head = (Scheme_Let_Header *)o; + Scheme_IR_Let_Header *head = (Scheme_IR_Let_Header *)o; /* number of clauses in the let */ int num_clauses = head->num_clauses; @@ -731,12 +731,12 @@ static Scheme_Object *letrec_check_lets(Scheme_Object *o, Letrec_Check_Frame *ol k = 0; /* loops through every right hand side */ - clv = NULL; + irlv = NULL; for (i = num_clauses; i--;) { - clv = (Scheme_Compiled_Let_Value *)body; + irlv = (Scheme_IR_Let_Value *)body; - if (clv->count == 0) { - val = letrec_check_expr(clv->value, frame, + if (irlv->count == 0) { + val = letrec_check_expr(irlv->value, frame, /* deferred closures get attached to no variables, which is sensible because the closure will not be reachable: */ @@ -744,7 +744,7 @@ static Scheme_Object *letrec_check_lets(Scheme_Object *o, Letrec_Check_Frame *ol } else { Scheme_Object *new_pos; - if (clv->count == 1) { + if (irlv->count == 1) { /* any deferred closure on the right-hand side gets attached to the variable on the left-hand side: */ new_pos = scheme_make_integer(k); @@ -755,25 +755,25 @@ static Scheme_Object *letrec_check_lets(Scheme_Object *o, Letrec_Check_Frame *ol variables in that case */ int sub; new_pos = scheme_null; - for (sub = clv->count; sub--; ) { + for (sub = irlv->count; sub--; ) { new_pos = scheme_make_pair(scheme_make_integer(k+sub), new_pos); } } - val = letrec_check_expr(clv->value, frame, new_pos); + val = letrec_check_expr(irlv->value, frame, new_pos); } if (frame_type == FRAME_TYPE_LETREC) { - for (j = 0; j < clv->count; j++) { + for (j = 0; j < irlv->count; j++) { frame->ref[j + k] |= LET_READY; } } - k += clv->count; + k += irlv->count; - clv->value = val; + irlv->value = val; - body = clv->body; + body = irlv->body; } /* the body variant of the frame shares the `ref`, etc., arrays with @@ -790,7 +790,7 @@ static Scheme_Object *letrec_check_lets(Scheme_Object *o, Letrec_Check_Frame *ol let had bindings, otherwise, the let header should point to the new body */ if (num_clauses > 0) - clv->body = val; + irlv->body = val; else head->body = val; @@ -801,27 +801,27 @@ static Scheme_Object *letrec_check_lets(Scheme_Object *o, Letrec_Check_Frame *ol /* note to future self: the length of define_values is sometimes 1, and you definitely don't want to look inside if that's the case */ -static Scheme_Object *letrec_check_define_values(Scheme_Object *data, Letrec_Check_Frame *frame, Scheme_Object *pos) +static Scheme_Object *letrec_check_define_values(Scheme_Object *lam, Letrec_Check_Frame *frame, Scheme_Object *pos) { - if (SCHEME_VEC_SIZE(data) <= 1) - return data; + if (SCHEME_VEC_SIZE(lam) <= 1) + return lam; else { - Scheme_Object *vars = SCHEME_VEC_ELS(data)[0]; - Scheme_Object *val = SCHEME_VEC_ELS(data)[1]; + Scheme_Object *vars = SCHEME_VEC_ELS(lam)[0]; + Scheme_Object *val = SCHEME_VEC_ELS(lam)[1]; SCHEME_ASSERT(SCHEME_PAIRP(vars) || SCHEME_NULLP(vars), "letrec_check_define_values: processing resolved code"); val = letrec_check_expr(val, frame, pos); - SCHEME_VEC_ELS(data)[1] = val; + SCHEME_VEC_ELS(lam)[1] = val; } - return data; + return lam; } -static Scheme_Object *letrec_check_ref(Scheme_Object *data, Letrec_Check_Frame *frame, Wrapped_Lhs *lhs) +static Scheme_Object *letrec_check_ref(Scheme_Object *lam, Letrec_Check_Frame *frame, Wrapped_Lhs *lhs) { - return data; + return lam; } static Scheme_Object *letrec_check_set(Scheme_Object *o, Letrec_Check_Frame *frame, Scheme_Object *pos) @@ -839,12 +839,12 @@ static Scheme_Object *letrec_check_set(Scheme_Object *o, Letrec_Check_Frame *fra val = letrec_check_expr(val, frame, rhs_pos); sb->val = val; - if (SAME_TYPE(SCHEME_TYPE(sb->var), scheme_compiled_local_type)) { + if (SAME_TYPE(SCHEME_TYPE(sb->var), scheme_ir_local_type)) { /* We may need to insert a definedness check before the assignment */ Letrec_Check_Frame *in_frame; int position; - in_frame = get_relative_frame(&position, (Scheme_Compiled_Local *)sb->var); + in_frame = get_relative_frame(&position, (Scheme_IR_Local *)sb->var); if (in_frame->ref && !(in_frame->ref[position] & LET_READY)) { @@ -853,7 +853,7 @@ static Scheme_Object *letrec_check_set(Scheme_Object *o, Letrec_Check_Frame *fra Scheme_Object *name; Scheme_Sequence *seq; - name = record_checked((Scheme_Compiled_Local *)sb->var, frame); + name = record_checked((Scheme_IR_Local *)sb->var, frame); app3 = MALLOC_ONE_TAGGED(Scheme_App3_Rec); app3->iso.so.type = scheme_application3_type; @@ -874,22 +874,22 @@ static Scheme_Object *letrec_check_set(Scheme_Object *o, Letrec_Check_Frame *fra return o; } -static Scheme_Object *letrec_check_define_syntaxes(Scheme_Object *data, Letrec_Check_Frame *frame, Scheme_Object *pos) +static Scheme_Object *letrec_check_define_syntaxes(Scheme_Object *lam, Letrec_Check_Frame *frame, Scheme_Object *pos) { Scheme_Object *val; - val = SCHEME_VEC_ELS(data)[3]; + val = SCHEME_VEC_ELS(lam)[3]; val = letrec_check_expr(val, frame, pos); - SCHEME_VEC_ELS(data)[3] = val; + SCHEME_VEC_ELS(lam)[3] = val; - return data; + return lam; } -static Scheme_Object *letrec_check_begin_for_syntax(Scheme_Object *data, Letrec_Check_Frame *frame, Scheme_Object *pos) +static Scheme_Object *letrec_check_begin_for_syntax(Scheme_Object *lam, Letrec_Check_Frame *frame, Scheme_Object *pos) { Scheme_Object *l, *a, *val; - l = SCHEME_VEC_ELS(data)[2]; + l = SCHEME_VEC_ELS(lam)[2]; while (!SCHEME_NULLP(l)) { a = SCHEME_CAR(l); @@ -898,7 +898,7 @@ static Scheme_Object *letrec_check_begin_for_syntax(Scheme_Object *data, Letrec_ l = SCHEME_CDR(l); } - return data; + return lam; } static Scheme_Object *letrec_check_case_lambda(Scheme_Object *o, Letrec_Check_Frame *frame, Scheme_Object *pos) @@ -935,20 +935,20 @@ static Scheme_Object *letrec_check_begin0(Scheme_Object *o, Letrec_Check_Frame * return o; } -static Scheme_Object *letrec_check_apply_values(Scheme_Object *data, Letrec_Check_Frame *frame, Scheme_Object *pos) +static Scheme_Object *letrec_check_apply_values(Scheme_Object *lam, Letrec_Check_Frame *frame, Scheme_Object *pos) { Scheme_Object *f, *e; - f = SCHEME_PTR1_VAL(data); - e = SCHEME_PTR2_VAL(data); + f = SCHEME_PTR1_VAL(lam); + e = SCHEME_PTR2_VAL(lam); f = letrec_check_expr(f, frame, pos); e = letrec_check_expr(e, frame, pos); - SCHEME_PTR1_VAL(data) = f; - SCHEME_PTR2_VAL(data) = e; + SCHEME_PTR1_VAL(lam) = f; + SCHEME_PTR2_VAL(lam) = e; - return data; + return lam; } static Scheme_Object *letrec_check_module(Scheme_Object *o, Letrec_Check_Frame *frame, Scheme_Object *pos) @@ -1024,7 +1024,7 @@ static Scheme_Object *letrec_check_expr(Scheme_Object *expr, Letrec_Check_Frame SCHEME_USE_FUEL(1); switch (type) { - case scheme_compiled_local_type: + case scheme_ir_local_type: return letrec_check_local(expr, frame, pos); case scheme_application_type: return letrec_check_application(expr, frame, pos); @@ -1039,13 +1039,13 @@ static Scheme_Object *letrec_check_expr(Scheme_Object *expr, Letrec_Check_Frame return letrec_check_branch(expr, frame, pos); case scheme_with_cont_mark_type: return letrec_check_wcm(expr, frame, pos); - case scheme_compiled_unclosed_procedure_type: - return letrec_check_closure_compilation(expr, frame, pos); - case scheme_compiled_let_void_type: + case scheme_ir_lambda_type: + return letrec_check_lambda(expr, frame, pos); + case scheme_ir_let_void_type: return letrec_check_lets(expr, frame, pos); - case scheme_compiled_toplevel_type: /* var ref to a top level */ + case scheme_ir_toplevel_type: /* var ref to a top level */ return expr; - case scheme_compiled_quote_syntax_type: + case scheme_ir_quote_syntax_type: return expr; case scheme_variable_type: case scheme_module_variable_type: diff --git a/racket/src/racket/src/marshal.c b/racket/src/racket/src/marshal.c index fbf5660d98..09c67b2fd1 100644 --- a/racket/src/racket/src/marshal.c +++ b/racket/src/racket/src/marshal.c @@ -85,8 +85,8 @@ static Scheme_Object *read_local_unbox(Scheme_Object *obj); static Scheme_Object *write_resolve_prefix(Scheme_Object *obj); static Scheme_Object *read_resolve_prefix(Scheme_Object *obj); -static Scheme_Object *write_compiled_closure(Scheme_Object *obj); -static Scheme_Object *read_compiled_closure(Scheme_Object *obj); +static Scheme_Object *write_lambda(Scheme_Object *obj); +static Scheme_Object *read_lambda(Scheme_Object *obj); static Scheme_Object *write_module(Scheme_Object *obj); static Scheme_Object *read_module(Scheme_Object *obj); @@ -150,10 +150,8 @@ void scheme_init_marshal(Scheme_Env *env) scheme_install_type_writer(scheme_compilation_top_type, write_top); scheme_install_type_reader(scheme_compilation_top_type, read_top); - scheme_install_type_writer(scheme_unclosed_procedure_type, - write_compiled_closure); - scheme_install_type_reader(scheme_unclosed_procedure_type, - read_compiled_closure); + scheme_install_type_writer(scheme_lambda_type, write_lambda); + scheme_install_type_reader(scheme_lambda_type, read_lambda); scheme_install_type_writer(scheme_toplevel_type, write_toplevel); scheme_install_type_reader(scheme_toplevel_type, read_toplevel); @@ -397,7 +395,7 @@ static Scheme_Object *read_case_lambda(Scheme_Object *obj) a = SCHEME_CAR(s); cl->array[i] = a; if (!SCHEME_PROCP(a)) { - if (!SAME_TYPE(SCHEME_TYPE(a), scheme_unclosed_procedure_type)) + if (!SAME_TYPE(SCHEME_TYPE(a), scheme_lambda_type)) return NULL; all_closed = 0; } @@ -785,31 +783,31 @@ static Scheme_Object *closure_marshal_name(Scheme_Object *name) return name; } -static Scheme_Object *write_compiled_closure(Scheme_Object *obj) +static Scheme_Object *write_lambda(Scheme_Object *obj) { - Scheme_Closure_Data *data; + Scheme_Lambda *data; Scheme_Object *name, *l, *code, *ds, *tl_map; int svec_size, pos; Scheme_Marshal_Tables *mt; - data = (Scheme_Closure_Data *)obj; + data = (Scheme_Lambda *)obj; name = closure_marshal_name(data->name); svec_size = data->closure_size; - if (SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_HAS_TYPED_ARGS) { + if (SCHEME_LAMBDA_FLAGS(data) & LAMBDA_HAS_TYPED_ARGS) { svec_size += scheme_boxmap_size(data->num_params + data->closure_size); { int k, mv; for (k = data->num_params + data->closure_size; --k; ) { mv = scheme_boxmap_get(data->closure_map, k, data->closure_size); - if (mv > (CLOS_TYPE_TYPE_OFFSET + SCHEME_MAX_LOCAL_TYPE)) + if (mv > (LAMBDA_TYPE_TYPE_OFFSET + SCHEME_MAX_LOCAL_TYPE)) scheme_signal_error("internal error: inconsistent closure/argument type"); } } } - if (SCHEME_RPAIRP(data->code)) { + if (SCHEME_RPAIRP(data->body)) { /* This can happen if loaded bytecode is printed out and the procedure body has never been needed before. It's also possible in non-JIT mode if an empty closure is embedded @@ -820,7 +818,7 @@ static Scheme_Object *write_compiled_closure(Scheme_Object *obj) /* If the body is simple enough, write it directly. Otherwise, create a delay indirection so that the body is loaded on demand. */ - code = data->code; + code = data->body; switch (SCHEME_TYPE(code)) { case scheme_toplevel_type: case scheme_local_type: @@ -868,10 +866,10 @@ static Scheme_Object *write_compiled_closure(Scheme_Object *obj) ds = mt->cdata_map[pos]; if (ds) { ds = SCHEME_PTR_VAL(ds); - if (SAME_OBJ(data->code, ds)) + if (SAME_OBJ(data->body, ds)) break; if (SAME_TYPE(scheme_quote_compilation_type, SCHEME_TYPE(ds))) - if (SAME_OBJ(data->code, SCHEME_PTR_VAL(ds))) + if (SAME_OBJ(data->body, SCHEME_PTR_VAL(ds))) break; } pos += 256; @@ -886,7 +884,7 @@ static Scheme_Object *write_compiled_closure(Scheme_Object *obj) if (mt->pass) scheme_signal_error("broken closure-data table\n"); - code = scheme_protect_quote(data->code); + code = scheme_protect_quote(data->body); ds = scheme_alloc_small_object(); ds->type = scheme_delay_syntax_type; @@ -927,11 +925,11 @@ static Scheme_Object *write_compiled_closure(Scheme_Object *obj) data->closure_map), ds); - if (SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_HAS_TYPED_ARGS) + if (SCHEME_LAMBDA_FLAGS(data) & LAMBDA_HAS_TYPED_ARGS) l = CONS(scheme_make_integer(data->closure_size), l); - return CONS(scheme_make_integer(SCHEME_CLOSURE_DATA_FLAGS(data) & 0x7F), + return CONS(scheme_make_integer(SCHEME_LAMBDA_FLAGS(data) & 0x7F), CONS(scheme_make_integer(data->num_params), CONS(scheme_make_integer(data->max_let_depth), CONS(tl_map, @@ -939,22 +937,22 @@ static Scheme_Object *write_compiled_closure(Scheme_Object *obj) l))))); } -static Scheme_Object *read_compiled_closure(Scheme_Object *obj) +static Scheme_Object *read_lambda(Scheme_Object *obj) { - Scheme_Closure_Data *data; + Scheme_Lambda *data; Scheme_Object *v, *tl_map; #define BAD_CC "bad compiled closure" #define X_SCHEME_ASSERT(x, y) - data = (Scheme_Closure_Data *)scheme_malloc_tagged(sizeof(Scheme_Closure_Data)); + data = (Scheme_Lambda *)scheme_malloc_tagged(sizeof(Scheme_Lambda)); - data->iso.so.type = scheme_unclosed_procedure_type; + data->iso.so.type = scheme_lambda_type; if (!SCHEME_PAIRP(obj)) return NULL; v = SCHEME_CAR(obj); obj = SCHEME_CDR(obj); - SCHEME_CLOSURE_DATA_FLAGS(data) = (short)(SCHEME_INT_VAL(v)); + SCHEME_LAMBDA_FLAGS(data) = (short)(SCHEME_INT_VAL(v)); if (!SCHEME_PAIRP(obj)) return NULL; v = SCHEME_CAR(obj); @@ -1005,7 +1003,7 @@ static Scheme_Object *read_compiled_closure(Scheme_Object *obj) obj = SCHEME_CDR(obj); /* v is an svector or an integer... */ - if (SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_HAS_TYPED_ARGS) { + if (SCHEME_LAMBDA_FLAGS(data) & LAMBDA_HAS_TYPED_ARGS) { if (!SCHEME_INTP(v)) return NULL; data->closure_size = SCHEME_INT_VAL(v); @@ -1014,14 +1012,14 @@ static Scheme_Object *read_compiled_closure(Scheme_Object *obj) obj = SCHEME_CDR(obj); } - data->code = obj; + data->body = obj; if (!SAME_TYPE(scheme_svector_type, SCHEME_TYPE(v))) return NULL; - if (!(SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_HAS_TYPED_ARGS)) + if (!(SCHEME_LAMBDA_FLAGS(data) & LAMBDA_HAS_TYPED_ARGS)) data->closure_size = SCHEME_SVEC_LEN(v); - if ((SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_HAS_TYPED_ARGS)) + if ((SCHEME_LAMBDA_FLAGS(data) & LAMBDA_HAS_TYPED_ARGS)) if (data->closure_size + scheme_boxmap_size(data->closure_size + data->num_params) != SCHEME_SVEC_LEN(v)) return NULL; diff --git a/racket/src/racket/src/module.c b/racket/src/racket/src/module.c index 7efde80dbc..36953cd93d 100644 --- a/racket/src/racket/src/module.c +++ b/racket/src/racket/src/module.c @@ -84,17 +84,17 @@ static Scheme_Object *resolved_module_path_name(int argc, Scheme_Object *argv[]) static Scheme_Object *module_export_protected_p(int argc, Scheme_Object **argv); /* syntax */ -static Scheme_Object *module_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); +static Scheme_Object *module_compile(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); static Scheme_Object *module_expand(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Expand_Info *erec, int drec); -static Scheme_Object *modulestar_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); +static Scheme_Object *modulestar_compile(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); static Scheme_Object *modulestar_expand(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Expand_Info *erec, int drec); -static Scheme_Object *module_begin_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); +static Scheme_Object *module_begin_compile(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); static Scheme_Object *module_begin_expand(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Expand_Info *erec, int drec); -static Scheme_Object *declare_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); +static Scheme_Object *declare_compile(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); static Scheme_Object *declare_expand(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Expand_Info *erec, int drec); -static Scheme_Object *require_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); +static Scheme_Object *require_compile(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); static Scheme_Object *require_expand(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Expand_Info *erec, int drec); -static Scheme_Object *provide_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); +static Scheme_Object *provide_compile(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); static Scheme_Object *provide_expand(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Expand_Info *erec, int drec); static Scheme_Module *module_load(Scheme_Object *modname, Scheme_Env *env, const char *who); @@ -378,34 +378,34 @@ static void qsort_provides(Scheme_Object **exs, Scheme_Object **exsns, Scheme_Ob void scheme_init_module(Scheme_Env *env) { scheme_add_global_keyword("module", - scheme_make_compiled_syntax(module_syntax, - module_expand), + scheme_make_primitive_syntax(module_compile, + module_expand), env); scheme_add_global_keyword("module*", - scheme_make_compiled_syntax(modulestar_syntax, - modulestar_expand), + scheme_make_primitive_syntax(modulestar_compile, + modulestar_expand), env); REGISTER_SO(modbeg_syntax); - modbeg_syntax = scheme_make_compiled_syntax(module_begin_syntax, - module_begin_expand); + modbeg_syntax = scheme_make_primitive_syntax(module_begin_compile, + module_begin_expand); scheme_add_global_keyword("#%module-begin", modbeg_syntax, env); scheme_add_global_keyword("#%declare", - scheme_make_compiled_syntax(declare_syntax, - declare_expand), + scheme_make_primitive_syntax(declare_compile, + declare_expand), env); scheme_add_global_keyword("#%require", - scheme_make_compiled_syntax(require_syntax, - require_expand), + scheme_make_primitive_syntax(require_compile, + require_expand), env); scheme_add_global_keyword("#%provide", - scheme_make_compiled_syntax(provide_syntax, - provide_expand), + scheme_make_primitive_syntax(provide_compile, + provide_expand), env); #ifdef MZ_USE_PLACES @@ -4347,7 +4347,7 @@ static int is_procedure_expression(Scheme_Object *e) t = SCHEME_TYPE(e); - return ((t == scheme_unclosed_procedure_type) + return ((t == scheme_lambda_type) || (t == scheme_case_lambda_sequence_type)); } @@ -4432,7 +4432,7 @@ static void setup_accessible_table(Scheme_Module *m) might leave bindings out of the `toplevels' table. */ } else { if (SCHEME_VEC_SIZE(form) == 2) { - if (scheme_compiled_duplicate_ok(SCHEME_VEC_ELS(form)[0], 1)) { + if (scheme_ir_duplicate_ok(SCHEME_VEC_ELS(form)[0], 1)) { /* record simple constant from cross-module propagation: */ v = scheme_make_pair(v, SCHEME_VEC_ELS(form)[0]); } else if (SAME_TYPE(SCHEME_TYPE(SCHEME_VEC_ELS(form)[0]), scheme_inline_variant_type)) { @@ -5892,7 +5892,7 @@ static int needs_prompt(Scheme_Object *e) return 0; switch (t) { - case scheme_unclosed_procedure_type: + case scheme_lambda_type: case scheme_toplevel_type: case scheme_local_type: case scheme_local_unbox_type: @@ -6364,7 +6364,7 @@ static int is_simple_expr(Scheme_Object *v) Scheme_Type t; t = SCHEME_TYPE(v); - if (SAME_TYPE(t, scheme_unclosed_procedure_type)) + if (SAME_TYPE(t, scheme_lambda_type)) return 1; return 0; @@ -7538,7 +7538,7 @@ static Scheme_Object *do_module(Scheme_Object *form, Scheme_Comp_Env *env, } static Scheme_Object * -module_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) +module_compile(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) { return do_module(form, env, rec, drec, scheme_null, scheme_null, 0, NULL, scheme_make_integer(0)); @@ -7552,7 +7552,7 @@ module_expand(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Expand_Info *ere } static Scheme_Object * -modulestar_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) +modulestar_compile(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) { scheme_wrong_syntax(NULL, NULL, form, "illegal use (not in a module top-level)"); return NULL; @@ -7561,7 +7561,7 @@ modulestar_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info static Scheme_Object * modulestar_expand(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Expand_Info *erec, int drec) { - return modulestar_syntax(form, env, erec, drec); + return modulestar_compile(form, env, erec, drec); } /* For mzc: */ @@ -10088,7 +10088,7 @@ static void install_stops(Scheme_Comp_Env *xenv, int phase, Scheme_Object **_beg } static Scheme_Object * -module_begin_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) +module_begin_compile(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) { return do_module_begin(form, env, rec, drec); } @@ -12726,7 +12726,7 @@ static Scheme_Object *do_require(Scheme_Object *form, Scheme_Comp_Env *env, } static Scheme_Object * -require_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) +require_compile(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) { return do_require(form, env, rec, drec); } @@ -12759,7 +12759,7 @@ Scheme_Object *scheme_toplevel_require_for_expand(Scheme_Object *module_path, /**********************************************************************/ static Scheme_Object * -provide_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) +provide_compile(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) { scheme_wrong_syntax(NULL, NULL, form, "not in module body"); return NULL; @@ -12774,7 +12774,7 @@ provide_expand(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Expand_Info *er } static Scheme_Object * -declare_syntax(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) +declare_compile(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec) { scheme_wrong_syntax(NULL, NULL, form, "not in module body"); return NULL; diff --git a/racket/src/racket/src/mzmark_compile.inc b/racket/src/racket/src/mzmark_compile.inc index c8606068dc..ede28a1894 100644 --- a/racket/src/racket/src/mzmark_compile.inc +++ b/racket/src/racket/src/mzmark_compile.inc @@ -1,2 +1,48 @@ /* >>>> Generated by mkmark.rkt from mzmarksrc.c <<<< */ +static int mark_ir_lambda_info_SIZE(void *p, struct NewGC *gc) { +#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS + gcBYTES_TO_WORDS(sizeof(Scheme_IR_Lambda_Info)); +#else + return 0; +#endif +} + +static int mark_ir_lambda_info_MARK(void *p, struct NewGC *gc) { +#ifndef GC_NO_MARK_PROCEDURE_NEEDED + Scheme_IR_Lambda_Info *i = (Scheme_IR_Lambda_Info *)p; + + gcMARK2(i->base_closure, gc); + gcMARK2(i->vars, gc); + gcMARK2(i->local_type_map, gc); + +# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS + return 0; +# else + return + gcBYTES_TO_WORDS(sizeof(Scheme_IR_Lambda_Info)); +# endif +#endif +} + +static int mark_ir_lambda_info_FIXUP(void *p, struct NewGC *gc) { +#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED + Scheme_IR_Lambda_Info *i = (Scheme_IR_Lambda_Info *)p; + + gcFIXUP2(i->base_closure, gc); + gcFIXUP2(i->vars, gc); + gcFIXUP2(i->local_type_map, gc); + +# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS + return 0; +# else + return + gcBYTES_TO_WORDS(sizeof(Scheme_IR_Lambda_Info)); +# endif +#endif +} + +#define mark_ir_lambda_info_IS_ATOMIC 0 +#define mark_ir_lambda_info_IS_CONST_SIZE 1 + + diff --git a/racket/src/racket/src/mzmark_fun.inc b/racket/src/racket/src/mzmark_fun.inc index 08bad2932f..6a3c5f2aea 100644 --- a/racket/src/racket/src/mzmark_fun.inc +++ b/racket/src/racket/src/mzmark_fun.inc @@ -1,51 +1,5 @@ /* >>>> Generated by mkmark.rkt from mzmarksrc.c <<<< */ -static int mark_closure_info_SIZE(void *p, struct NewGC *gc) { -#ifndef GC_NO_SIZE_NEEDED_FROM_PROCS - gcBYTES_TO_WORDS(sizeof(Closure_Info)); -#else - return 0; -#endif -} - -static int mark_closure_info_MARK(void *p, struct NewGC *gc) { -#ifndef GC_NO_MARK_PROCEDURE_NEEDED - Closure_Info *i = (Closure_Info *)p; - - gcMARK2(i->base_closure, gc); - gcMARK2(i->vars, gc); - gcMARK2(i->local_type_map, gc); - -# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS - return 0; -# else - return - gcBYTES_TO_WORDS(sizeof(Closure_Info)); -# endif -#endif -} - -static int mark_closure_info_FIXUP(void *p, struct NewGC *gc) { -#ifndef GC_NO_FIXUP_PROCEDURE_NEEDED - Closure_Info *i = (Closure_Info *)p; - - gcFIXUP2(i->base_closure, gc); - gcFIXUP2(i->vars, gc); - gcFIXUP2(i->local_type_map, gc); - -# ifdef GC_NO_SIZE_NEEDED_FROM_PROCS - return 0; -# else - return - gcBYTES_TO_WORDS(sizeof(Closure_Info)); -# endif -#endif -} - -#define mark_closure_info_IS_ATOMIC 0 -#define mark_closure_info_IS_CONST_SIZE 1 - - static int mark_dyn_wind_cell_SIZE(void *p, struct NewGC *gc) { #ifndef GC_NO_SIZE_NEEDED_FROM_PROCS gcBYTES_TO_WORDS(sizeof(Scheme_Dynamic_Wind_List)); diff --git a/racket/src/racket/src/mzmark_jit.inc b/racket/src/racket/src/mzmark_jit.inc index aeb5be06da..842d4bc4dd 100644 --- a/racket/src/racket/src/mzmark_jit.inc +++ b/racket/src/racket/src/mzmark_jit.inc @@ -3,7 +3,7 @@ static int native_closure_SIZE(void *p, struct NewGC *gc) { #ifndef GC_NO_SIZE_NEEDED_FROM_PROCS Scheme_Native_Closure *c = (Scheme_Native_Closure *)p; - int closure_size = ((Scheme_Native_Closure_Data *)GC_resolve2(c->code, gc))->closure_size; + int closure_size = ((Scheme_Native_Lambda *)GC_resolve2(c->code, gc))->closure_size; if (closure_size < 0) { closure_size = -(closure_size + 1); @@ -19,7 +19,7 @@ static int native_closure_SIZE(void *p, struct NewGC *gc) { static int native_closure_MARK(void *p, struct NewGC *gc) { #ifndef GC_NO_MARK_PROCEDURE_NEEDED Scheme_Native_Closure *c = (Scheme_Native_Closure *)p; - int closure_size = ((Scheme_Native_Closure_Data *)GC_resolve2(c->code, gc))->closure_size; + int closure_size = ((Scheme_Native_Lambda *)GC_resolve2(c->code, gc))->closure_size; if (closure_size < 0) { closure_size = -(closure_size + 1); @@ -27,7 +27,7 @@ static int native_closure_MARK(void *p, struct NewGC *gc) { { int i = closure_size; -# define CLOSURE_DATA_TYPE Scheme_Native_Closure_Data +# define CLOSURE_DATA_TYPE Scheme_Native_Lambda # include "mzclpf_decl.inc" gcMARK2(c->code, gc); @@ -54,7 +54,7 @@ static int native_closure_MARK(void *p, struct NewGC *gc) { static int native_closure_FIXUP(void *p, struct NewGC *gc) { #ifndef GC_NO_FIXUP_PROCEDURE_NEEDED Scheme_Native_Closure *c = (Scheme_Native_Closure *)p; - int closure_size = ((Scheme_Native_Closure_Data *)GC_resolve2(c->code, gc))->closure_size; + int closure_size = ((Scheme_Native_Lambda *)GC_resolve2(c->code, gc))->closure_size; if (closure_size < 0) { closure_size = -(closure_size + 1); @@ -97,7 +97,7 @@ static int mark_jit_state_MARK(void *p, struct NewGC *gc) { #ifndef GC_NO_MARK_PROCEDURE_NEEDED mz_jit_state *j = (mz_jit_state *)p; gcMARK2(j->mappings, gc); - gcMARK2(j->self_data, gc); + gcMARK2(j->self_lam, gc); gcMARK2(j->example_argv, gc); gcMARK2(j->nc, gc); gcMARK2(j->retaining_data, gc); @@ -116,7 +116,7 @@ static int mark_jit_state_FIXUP(void *p, struct NewGC *gc) { #ifndef GC_NO_FIXUP_PROCEDURE_NEEDED mz_jit_state *j = (mz_jit_state *)p; gcFIXUP2(j->mappings, gc); - gcFIXUP2(j->self_data, gc); + gcFIXUP2(j->self_lam, gc); gcFIXUP2(j->example_argv, gc); gcFIXUP2(j->nc, gc); gcFIXUP2(j->retaining_data, gc); @@ -137,7 +137,7 @@ static int mark_jit_state_FIXUP(void *p, struct NewGC *gc) { static int native_unclosed_proc_SIZE(void *p, struct NewGC *gc) { #ifndef GC_NO_SIZE_NEEDED_FROM_PROCS - gcBYTES_TO_WORDS(sizeof(Scheme_Native_Closure_Data)); + gcBYTES_TO_WORDS(sizeof(Scheme_Native_Lambda)); #else return 0; #endif @@ -145,7 +145,7 @@ static int native_unclosed_proc_SIZE(void *p, struct NewGC *gc) { static int native_unclosed_proc_MARK(void *p, struct NewGC *gc) { #ifndef GC_NO_MARK_PROCEDURE_NEEDED - Scheme_Native_Closure_Data *d = (Scheme_Native_Closure_Data *)p; + Scheme_Native_Lambda *d = (Scheme_Native_Lambda *)p; int i; gcMARK2(d->u2.name, gc); @@ -164,14 +164,14 @@ static int native_unclosed_proc_MARK(void *p, struct NewGC *gc) { return 0; # else return - gcBYTES_TO_WORDS(sizeof(Scheme_Native_Closure_Data)); + gcBYTES_TO_WORDS(sizeof(Scheme_Native_Lambda)); # endif #endif } static int native_unclosed_proc_FIXUP(void *p, struct NewGC *gc) { #ifndef GC_NO_FIXUP_PROCEDURE_NEEDED - Scheme_Native_Closure_Data *d = (Scheme_Native_Closure_Data *)p; + Scheme_Native_Lambda *d = (Scheme_Native_Lambda *)p; int i; gcFIXUP2(d->u2.name, gc); @@ -190,7 +190,7 @@ static int native_unclosed_proc_FIXUP(void *p, struct NewGC *gc) { return 0; # else return - gcBYTES_TO_WORDS(sizeof(Scheme_Native_Closure_Data)); + gcBYTES_TO_WORDS(sizeof(Scheme_Native_Lambda)); # endif #endif } @@ -201,7 +201,7 @@ static int native_unclosed_proc_FIXUP(void *p, struct NewGC *gc) { static int native_unclosed_proc_plus_case_SIZE(void *p, struct NewGC *gc) { #ifndef GC_NO_SIZE_NEEDED_FROM_PROCS - gcBYTES_TO_WORDS(sizeof(Scheme_Native_Closure_Data_Plus_Case)); + gcBYTES_TO_WORDS(sizeof(Scheme_Native_Lambda_Plus_Case)); #else return 0; #endif @@ -209,7 +209,7 @@ static int native_unclosed_proc_plus_case_SIZE(void *p, struct NewGC *gc) { static int native_unclosed_proc_plus_case_MARK(void *p, struct NewGC *gc) { #ifndef GC_NO_MARK_PROCEDURE_NEEDED - Scheme_Native_Closure_Data_Plus_Case *d = (Scheme_Native_Closure_Data_Plus_Case *)p; + Scheme_Native_Lambda_Plus_Case *d = (Scheme_Native_Lambda_Plus_Case *)p; native_unclosed_proc_MARK(p, gc); gcMARK2(d->case_lam, gc); @@ -218,14 +218,14 @@ static int native_unclosed_proc_plus_case_MARK(void *p, struct NewGC *gc) { return 0; # else return - gcBYTES_TO_WORDS(sizeof(Scheme_Native_Closure_Data_Plus_Case)); + gcBYTES_TO_WORDS(sizeof(Scheme_Native_Lambda_Plus_Case)); # endif #endif } static int native_unclosed_proc_plus_case_FIXUP(void *p, struct NewGC *gc) { #ifndef GC_NO_FIXUP_PROCEDURE_NEEDED - Scheme_Native_Closure_Data_Plus_Case *d = (Scheme_Native_Closure_Data_Plus_Case *)p; + Scheme_Native_Lambda_Plus_Case *d = (Scheme_Native_Lambda_Plus_Case *)p; native_unclosed_proc_FIXUP(p, gc); gcFIXUP2(d->case_lam, gc); @@ -234,7 +234,7 @@ static int native_unclosed_proc_plus_case_FIXUP(void *p, struct NewGC *gc) { return 0; # else return - gcBYTES_TO_WORDS(sizeof(Scheme_Native_Closure_Data_Plus_Case)); + gcBYTES_TO_WORDS(sizeof(Scheme_Native_Lambda_Plus_Case)); # endif #endif } diff --git a/racket/src/racket/src/mzmark_type.inc b/racket/src/racket/src/mzmark_type.inc index e42c50c9ac..d892e34d80 100644 --- a/racket/src/racket/src/mzmark_type.inc +++ b/racket/src/racket/src/mzmark_type.inc @@ -673,7 +673,7 @@ static int branch_rec_FIXUP(void *p, struct NewGC *gc) { static int unclosed_proc_SIZE(void *p, struct NewGC *gc) { #ifndef GC_NO_SIZE_NEEDED_FROM_PROCS - gcBYTES_TO_WORDS(sizeof(Scheme_Closure_Data)); + gcBYTES_TO_WORDS(sizeof(Scheme_Lambda)); #else return 0; #endif @@ -681,11 +681,11 @@ static int unclosed_proc_SIZE(void *p, struct NewGC *gc) { static int unclosed_proc_MARK(void *p, struct NewGC *gc) { #ifndef GC_NO_MARK_PROCEDURE_NEEDED - Scheme_Closure_Data *d = (Scheme_Closure_Data *)p; + Scheme_Lambda *d = (Scheme_Lambda *)p; gcMARK2(d->name, gc); - gcMARK2(d->code, gc); - gcMARK2(d->closure_map, gc); + gcMARK2(d->body, gc); + gcMARK2(d->closure_map, gc); /* covers `ir_info` */ gcMARK2(d->tl_map, gc); #ifdef MZ_USE_JIT gcMARK2(d->u.native_code, gc); @@ -696,18 +696,18 @@ static int unclosed_proc_MARK(void *p, struct NewGC *gc) { return 0; # else return - gcBYTES_TO_WORDS(sizeof(Scheme_Closure_Data)); + gcBYTES_TO_WORDS(sizeof(Scheme_Lambda)); # endif #endif } static int unclosed_proc_FIXUP(void *p, struct NewGC *gc) { #ifndef GC_NO_FIXUP_PROCEDURE_NEEDED - Scheme_Closure_Data *d = (Scheme_Closure_Data *)p; + Scheme_Lambda *d = (Scheme_Lambda *)p; gcFIXUP2(d->name, gc); - gcFIXUP2(d->code, gc); - gcFIXUP2(d->closure_map, gc); + gcFIXUP2(d->body, gc); + gcFIXUP2(d->closure_map, gc); /* covers `ir_info` */ gcFIXUP2(d->tl_map, gc); #ifdef MZ_USE_JIT gcFIXUP2(d->u.native_code, gc); @@ -718,7 +718,7 @@ static int unclosed_proc_FIXUP(void *p, struct NewGC *gc) { return 0; # else return - gcBYTES_TO_WORDS(sizeof(Scheme_Closure_Data)); + gcBYTES_TO_WORDS(sizeof(Scheme_Lambda)); # endif #endif } @@ -947,17 +947,17 @@ static int with_cont_mark_FIXUP(void *p, struct NewGC *gc) { #define with_cont_mark_IS_CONST_SIZE 1 -static int comp_local_SIZE(void *p, struct NewGC *gc) { +static int ir_local_SIZE(void *p, struct NewGC *gc) { #ifndef GC_NO_SIZE_NEEDED_FROM_PROCS - gcBYTES_TO_WORDS(sizeof(Scheme_Compiled_Local)); + gcBYTES_TO_WORDS(sizeof(Scheme_IR_Local)); #else return 0; #endif } -static int comp_local_MARK(void *p, struct NewGC *gc) { +static int ir_local_MARK(void *p, struct NewGC *gc) { #ifndef GC_NO_MARK_PROCEDURE_NEEDED - Scheme_Compiled_Local *var = (Scheme_Compiled_Local *)p; + Scheme_IR_Local *var = (Scheme_IR_Local *)p; gcMARK2(var->name, gc); switch (var->mode) { @@ -979,14 +979,14 @@ static int comp_local_MARK(void *p, struct NewGC *gc) { return 0; # else return - gcBYTES_TO_WORDS(sizeof(Scheme_Compiled_Local)); + gcBYTES_TO_WORDS(sizeof(Scheme_IR_Local)); # endif #endif } -static int comp_local_FIXUP(void *p, struct NewGC *gc) { +static int ir_local_FIXUP(void *p, struct NewGC *gc) { #ifndef GC_NO_FIXUP_PROCEDURE_NEEDED - Scheme_Compiled_Local *var = (Scheme_Compiled_Local *)p; + Scheme_IR_Local *var = (Scheme_IR_Local *)p; gcFIXUP2(var->name, gc); switch (var->mode) { @@ -1008,26 +1008,26 @@ static int comp_local_FIXUP(void *p, struct NewGC *gc) { return 0; # else return - gcBYTES_TO_WORDS(sizeof(Scheme_Compiled_Local)); + gcBYTES_TO_WORDS(sizeof(Scheme_IR_Local)); # endif #endif } -#define comp_local_IS_ATOMIC 0 -#define comp_local_IS_CONST_SIZE 1 +#define ir_local_IS_ATOMIC 0 +#define ir_local_IS_CONST_SIZE 1 -static int comp_let_value_SIZE(void *p, struct NewGC *gc) { +static int ir_let_value_SIZE(void *p, struct NewGC *gc) { #ifndef GC_NO_SIZE_NEEDED_FROM_PROCS - gcBYTES_TO_WORDS(sizeof(Scheme_Compiled_Let_Value)); + gcBYTES_TO_WORDS(sizeof(Scheme_IR_Let_Value)); #else return 0; #endif } -static int comp_let_value_MARK(void *p, struct NewGC *gc) { +static int ir_let_value_MARK(void *p, struct NewGC *gc) { #ifndef GC_NO_MARK_PROCEDURE_NEEDED - Scheme_Compiled_Let_Value *c = (Scheme_Compiled_Let_Value *)p; + Scheme_IR_Let_Value *c = (Scheme_IR_Let_Value *)p; gcMARK2(c->value, gc); gcMARK2(c->body, gc); @@ -1037,14 +1037,14 @@ static int comp_let_value_MARK(void *p, struct NewGC *gc) { return 0; # else return - gcBYTES_TO_WORDS(sizeof(Scheme_Compiled_Let_Value)); + gcBYTES_TO_WORDS(sizeof(Scheme_IR_Let_Value)); # endif #endif } -static int comp_let_value_FIXUP(void *p, struct NewGC *gc) { +static int ir_let_value_FIXUP(void *p, struct NewGC *gc) { #ifndef GC_NO_FIXUP_PROCEDURE_NEEDED - Scheme_Compiled_Let_Value *c = (Scheme_Compiled_Let_Value *)p; + Scheme_IR_Let_Value *c = (Scheme_IR_Let_Value *)p; gcFIXUP2(c->value, gc); gcFIXUP2(c->body, gc); @@ -1054,18 +1054,18 @@ static int comp_let_value_FIXUP(void *p, struct NewGC *gc) { return 0; # else return - gcBYTES_TO_WORDS(sizeof(Scheme_Compiled_Let_Value)); + gcBYTES_TO_WORDS(sizeof(Scheme_IR_Let_Value)); # endif #endif } -#define comp_let_value_IS_ATOMIC 0 -#define comp_let_value_IS_CONST_SIZE 1 +#define ir_let_value_IS_ATOMIC 0 +#define ir_let_value_IS_CONST_SIZE 1 static int let_header_SIZE(void *p, struct NewGC *gc) { #ifndef GC_NO_SIZE_NEEDED_FROM_PROCS - gcBYTES_TO_WORDS(sizeof(Scheme_Let_Header)); + gcBYTES_TO_WORDS(sizeof(Scheme_IR_Let_Header)); #else return 0; #endif @@ -1073,7 +1073,7 @@ static int let_header_SIZE(void *p, struct NewGC *gc) { static int let_header_MARK(void *p, struct NewGC *gc) { #ifndef GC_NO_MARK_PROCEDURE_NEEDED - Scheme_Let_Header *h = (Scheme_Let_Header *)p; + Scheme_IR_Let_Header *h = (Scheme_IR_Let_Header *)p; gcMARK2(h->body, gc); @@ -1081,14 +1081,14 @@ static int let_header_MARK(void *p, struct NewGC *gc) { return 0; # else return - gcBYTES_TO_WORDS(sizeof(Scheme_Let_Header)); + gcBYTES_TO_WORDS(sizeof(Scheme_IR_Let_Header)); # endif #endif } static int let_header_FIXUP(void *p, struct NewGC *gc) { #ifndef GC_NO_FIXUP_PROCEDURE_NEEDED - Scheme_Let_Header *h = (Scheme_Let_Header *)p; + Scheme_IR_Let_Header *h = (Scheme_IR_Let_Header *)p; gcFIXUP2(h->body, gc); @@ -1096,7 +1096,7 @@ static int let_header_FIXUP(void *p, struct NewGC *gc) { return 0; # else return - gcBYTES_TO_WORDS(sizeof(Scheme_Let_Header)); + gcBYTES_TO_WORDS(sizeof(Scheme_IR_Let_Header)); # endif #endif } @@ -1296,7 +1296,7 @@ static int scm_closure_SIZE(void *p, struct NewGC *gc) { #ifndef GC_NO_SIZE_NEEDED_FROM_PROCS Scheme_Closure *c = (Scheme_Closure *)p; int closure_size = (c->code - ? ((Scheme_Closure_Data *)GC_resolve2(c->code, gc))->closure_size + ? ((Scheme_Lambda *)GC_resolve2(c->code, gc))->closure_size : 0); gcBYTES_TO_WORDS((sizeof(Scheme_Closure) @@ -1310,12 +1310,12 @@ static int scm_closure_MARK(void *p, struct NewGC *gc) { #ifndef GC_NO_MARK_PROCEDURE_NEEDED Scheme_Closure *c = (Scheme_Closure *)p; int closure_size = (c->code - ? ((Scheme_Closure_Data *)GC_resolve2(c->code, gc))->closure_size + ? ((Scheme_Lambda *)GC_resolve2(c->code, gc))->closure_size : 0); int i = closure_size; -# define CLOSURE_DATA_TYPE Scheme_Closure_Data +# define CLOSURE_DATA_TYPE Scheme_Lambda # include "mzclpf_decl.inc" gcMARK2(c->code, gc); @@ -1342,7 +1342,7 @@ static int scm_closure_FIXUP(void *p, struct NewGC *gc) { #ifndef GC_NO_FIXUP_PROCEDURE_NEEDED Scheme_Closure *c = (Scheme_Closure *)p; int closure_size = (c->code - ? ((Scheme_Closure_Data *)GC_resolve2(c->code, gc))->closure_size + ? ((Scheme_Lambda *)GC_resolve2(c->code, gc))->closure_size : 0); diff --git a/racket/src/racket/src/mzmarksrc.c b/racket/src/racket/src/mzmarksrc.c index a9faaadf9e..42a5c2160b 100644 --- a/racket/src/racket/src/mzmarksrc.c +++ b/racket/src/racket/src/mzmarksrc.c @@ -158,11 +158,11 @@ branch_rec { unclosed_proc { mark: - Scheme_Closure_Data *d = (Scheme_Closure_Data *)p; + Scheme_Lambda *d = (Scheme_Lambda *)p; gcMARK2(d->name, gc); - gcMARK2(d->code, gc); - gcMARK2(d->closure_map, gc); + gcMARK2(d->body, gc); + gcMARK2(d->closure_map, gc); /* covers `ir_info` */ gcMARK2(d->tl_map, gc); #ifdef MZ_USE_JIT gcMARK2(d->u.native_code, gc); @@ -170,7 +170,7 @@ unclosed_proc { #endif size: - gcBYTES_TO_WORDS(sizeof(Scheme_Closure_Data)); + gcBYTES_TO_WORDS(sizeof(Scheme_Lambda)); } let_value { @@ -228,9 +228,9 @@ with_cont_mark { gcBYTES_TO_WORDS(sizeof(Scheme_With_Continuation_Mark)); } -comp_local { +ir_local { mark: - Scheme_Compiled_Local *var = (Scheme_Compiled_Local *)p; + Scheme_IR_Local *var = (Scheme_IR_Local *)p; gcMARK2(var->name, gc); switch (var->mode) { @@ -249,29 +249,29 @@ comp_local { } size: - gcBYTES_TO_WORDS(sizeof(Scheme_Compiled_Local)); + gcBYTES_TO_WORDS(sizeof(Scheme_IR_Local)); } -comp_let_value { +ir_let_value { mark: - Scheme_Compiled_Let_Value *c = (Scheme_Compiled_Let_Value *)p; + Scheme_IR_Let_Value *c = (Scheme_IR_Let_Value *)p; gcMARK2(c->value, gc); gcMARK2(c->body, gc); gcMARK2(c->vars, gc); size: - gcBYTES_TO_WORDS(sizeof(Scheme_Compiled_Let_Value)); + gcBYTES_TO_WORDS(sizeof(Scheme_IR_Let_Value)); } let_header { mark: - Scheme_Let_Header *h = (Scheme_Let_Header *)p; + Scheme_IR_Let_Header *h = (Scheme_IR_Let_Header *)p; gcMARK2(h->body, gc); size: - gcBYTES_TO_WORDS(sizeof(Scheme_Let_Header)); + gcBYTES_TO_WORDS(sizeof(Scheme_IR_Let_Header)); } set_bang { @@ -331,14 +331,14 @@ closed_prim_proc { scm_closure { Scheme_Closure *c = (Scheme_Closure *)p; int closure_size = (c->code - ? ((Scheme_Closure_Data *)GC_resolve2(c->code, gc))->closure_size + ? ((Scheme_Lambda *)GC_resolve2(c->code, gc))->closure_size : 0); mark: int i = closure_size; START_MARK_ONLY; -# define CLOSURE_DATA_TYPE Scheme_Closure_Data +# define CLOSURE_DATA_TYPE Scheme_Lambda # include "mzclpf_decl.inc" END_MARK_ONLY; @@ -1471,18 +1471,6 @@ END validate; START fun; -mark_closure_info { - mark: - Closure_Info *i = (Closure_Info *)p; - - gcMARK2(i->base_closure, gc); - gcMARK2(i->vars, gc); - gcMARK2(i->local_type_map, gc); - - size: - gcBYTES_TO_WORDS(sizeof(Closure_Info)); -} - mark_dyn_wind_cell { mark: Scheme_Dynamic_Wind_List *l = (Scheme_Dynamic_Wind_List *)p; @@ -2268,6 +2256,18 @@ END struct; START compile; +mark_ir_lambda_info { + mark: + Scheme_IR_Lambda_Info *i = (Scheme_IR_Lambda_Info *)p; + + gcMARK2(i->base_closure, gc); + gcMARK2(i->vars, gc); + gcMARK2(i->local_type_map, gc); + + size: + gcBYTES_TO_WORDS(sizeof(Scheme_IR_Lambda_Info)); +} + END compile; /**********************************************************************/ @@ -2464,7 +2464,7 @@ START jit; native_closure { Scheme_Native_Closure *c = (Scheme_Native_Closure *)p; - int closure_size = ((Scheme_Native_Closure_Data *)GC_resolve2(c->code, gc))->closure_size; + int closure_size = ((Scheme_Native_Lambda *)GC_resolve2(c->code, gc))->closure_size; if (closure_size < 0) { closure_size = -(closure_size + 1); @@ -2474,7 +2474,7 @@ native_closure { { int i = closure_size; START_MARK_ONLY; -# define CLOSURE_DATA_TYPE Scheme_Native_Closure_Data +# define CLOSURE_DATA_TYPE Scheme_Native_Lambda # include "mzclpf_decl.inc" END_MARK_ONLY; @@ -2502,7 +2502,7 @@ mark_jit_state { mark: mz_jit_state *j = (mz_jit_state *)p; gcMARK2(j->mappings, gc); - gcMARK2(j->self_data, gc); + gcMARK2(j->self_lam, gc); gcMARK2(j->example_argv, gc); gcMARK2(j->nc, gc); gcMARK2(j->retaining_data, gc); @@ -2514,7 +2514,7 @@ mark_jit_state { native_unclosed_proc { mark: - Scheme_Native_Closure_Data *d = (Scheme_Native_Closure_Data *)p; + Scheme_Native_Lambda *d = (Scheme_Native_Lambda *)p; int i; gcMARK2(d->u2.name, gc); @@ -2530,18 +2530,18 @@ native_unclosed_proc { gcMARK2(d->eq_key, gc); size: - gcBYTES_TO_WORDS(sizeof(Scheme_Native_Closure_Data)); + gcBYTES_TO_WORDS(sizeof(Scheme_Native_Lambda)); } native_unclosed_proc_plus_case { mark: - Scheme_Native_Closure_Data_Plus_Case *d = (Scheme_Native_Closure_Data_Plus_Case *)p; + Scheme_Native_Lambda_Plus_Case *d = (Scheme_Native_Lambda_Plus_Case *)p; native_unclosed_proc_MARK(p, gc); gcMARK2(d->case_lam, gc); size: - gcBYTES_TO_WORDS(sizeof(Scheme_Native_Closure_Data_Plus_Case)); + gcBYTES_TO_WORDS(sizeof(Scheme_Native_Lambda_Plus_Case)); } END jit; diff --git a/racket/src/racket/src/optimize.c b/racket/src/racket/src/optimize.c index 776b96e471..8a4e72ef61 100644 --- a/racket/src/racket/src/optimize.c +++ b/racket/src/racket/src/optimize.c @@ -88,7 +88,7 @@ struct Optimize_Info int lambda_depth; int used_toplevel; - Scheme_Compiled_Local *transitive_use_var; /* set when optimizing a letrec-bound procedure */ + Scheme_IR_Local *transitive_use_var; /* set when optimizing a letrec-bound procedure */ struct Optimize_Info *transitive_uses_to; Scheme_Object *context; /* for logging */ @@ -103,12 +103,12 @@ typedef struct Optimize_Info_Sequence { int init_flatten_fuel, min_flatten_fuel; } Optimize_Info_Sequence; -static char *get_closure_local_type_map(Scheme_Closure_Data *data, int arg_n, int *ok); -static void set_closure_local_type_map(Scheme_Closure_Data *data, char *local_type_map); -static void merge_closure_local_type_map(Scheme_Closure_Data *data1, Scheme_Closure_Data *data2); -static int closure_body_size(Scheme_Closure_Data *data, int check_assign, +static char *get_closure_local_type_map(Scheme_Lambda *lam, int arg_n, int *ok); +static void set_closure_local_type_map(Scheme_Lambda *lam, char *local_type_map); +static void merge_closure_local_type_map(Scheme_Lambda *lam1, Scheme_Lambda *lam2); +static int closure_body_size(Scheme_Lambda *lam, int check_assign, Optimize_Info *info, int *is_leaf); -static int closure_has_top_level(Scheme_Closure_Data *data); +static int closure_has_top_level(Scheme_Lambda *lam); static int wants_local_type_arguments(Scheme_Object *rator, int argpos); @@ -127,11 +127,11 @@ static int predicate_to_local_type(Scheme_Object *pred); static Scheme_Object *expr_implies_predicate(Scheme_Object *expr, Optimize_Info *info, int *_involves_k_cross, int fuel); static int produces_local_type(Scheme_Object *rator, int argc); -static int optimize_any_uses(Optimize_Info *info, Scheme_Compiled_Let_Value *at_clv, int n); +static int optimize_any_uses(Optimize_Info *info, Scheme_IR_Let_Value *at_irlv, int n); static void propagate_used_variables(Optimize_Info *info); static int env_uses_toplevel(Optimize_Info *frame); -static Scheme_Compiled_Local *clone_variable(Scheme_Compiled_Local *var); -static void increment_use_count(Scheme_Compiled_Local *var, int as_rator); +static Scheme_IR_Local *clone_variable(Scheme_IR_Local *var); +static void increment_use_count(Scheme_IR_Local *var, int as_rator); static Optimize_Info *optimize_info_add_frame(Optimize_Info *info, int orig, int current, int flags); static void optimize_info_done(Optimize_Info *info, Optimize_Info *parent); @@ -154,19 +154,15 @@ static int movable_expression(Scheme_Object *expr, Optimize_Info *info, int cross_lambda, int cross_k, int cross_s, int check_space, int fuel); -#define ID_OMIT 0 -#define NO_ID_OMIT 1 -#define NO_MUTABLE_ID_OMIT -1 +#define SCHEME_LAMBDAP(vals_expr) (SAME_TYPE(SCHEME_TYPE(vals_expr), scheme_ir_lambda_type) \ + || SAME_TYPE(SCHEME_TYPE(vals_expr), scheme_case_lambda_sequence_type)) -#define IS_COMPILED_PROC(vals_expr) (SAME_TYPE(SCHEME_TYPE(vals_expr), scheme_compiled_unclosed_procedure_type) \ - || SAME_TYPE(SCHEME_TYPE(vals_expr), scheme_case_lambda_sequence_type)) - -static int compiled_proc_body_size(Scheme_Object *o, int less_args); +static int lambda_body_size(Scheme_Object *o, int less_args); typedef struct Scheme_Once_Used { Scheme_Object so; Scheme_Object *expr; - Scheme_Compiled_Local *var; + Scheme_IR_Local *var; int vclock; int aclock; int kclock; @@ -175,7 +171,7 @@ typedef struct Scheme_Once_Used { int moved; } Scheme_Once_Used; -static Scheme_Once_Used *make_once_used(Scheme_Object *val, Scheme_Compiled_Local *var, +static Scheme_Once_Used *make_once_used(Scheme_Object *val, Scheme_IR_Local *var, int vclock, int aclock, int kclock, int sclock, int spans_k); #ifdef MZ_PRECISE_GC @@ -196,9 +192,9 @@ void scheme_init_optimize() /* utils */ /*========================================================================*/ -static void set_optimize_mode(Scheme_Compiled_Local *var) +static void set_optimize_mode(Scheme_IR_Local *var) { - MZ_ASSERT(SAME_TYPE(var->so.type, scheme_compiled_local_type)); + MZ_ASSERT(SAME_TYPE(var->so.type, scheme_ir_local_type)); memset(&var->optimize, 0, sizeof(var->optimize)); var->mode = SCHEME_VAR_MODE_OPTIMIZE; } @@ -212,9 +208,9 @@ int scheme_is_functional_nonfailing_primitive(Scheme_Object *rator, int num_args && (num_args <= ((Scheme_Primitive_Proc *)rator)->mu.maxa) && ((expected_vals < 0) || ((expected_vals == 1) && !(SCHEME_PRIM_PROC_FLAGS(rator) & SCHEME_PRIM_IS_MULTI_RESULT)) - || (SAME_OBJ(scheme_values_func, rator) + || (SAME_OBJ(scheme_values_proc, rator) && (expected_vals == num_args)))) { - if (SAME_OBJ(scheme_values_func, rator)) + if (SAME_OBJ(scheme_values_proc, rator)) return 2; return 1; } else @@ -227,7 +223,7 @@ static Scheme_Object *get_struct_proc_shape(Scheme_Object *rator, Optimize_Info if (info && (info->top_level_consts || info->cp->inline_variants) - && SAME_TYPE(SCHEME_TYPE(rator), scheme_compiled_toplevel_type)) { + && SAME_TYPE(SCHEME_TYPE(rator), scheme_ir_toplevel_type)) { int pos; pos = SCHEME_TOPLEVEL_POS(rator); c = NULL; @@ -282,7 +278,7 @@ static Scheme_Object *extract_specialized_proc(Scheme_Object *le, Scheme_Object if (SAME_TYPE(SCHEME_TYPE(le), scheme_application2_type)) { Scheme_App2_Rec *app = (Scheme_App2_Rec *)le; if (SAME_OBJ(app->rator, scheme_procedure_specialize_proc)) { - if (SCHEME_PROCP(app->rand) || IS_COMPILED_PROC(app->rand)) + if (SCHEME_PROCP(app->rand) || SCHEME_LAMBDAP(app->rand)) return app->rand; } } @@ -316,8 +312,8 @@ int scheme_omittable_expr(Scheme_Object *o, int vals, int fuel, int flags, vtype = SCHEME_TYPE(o); - if ((vtype > _scheme_compiled_values_types_) - || ((vtype == scheme_compiled_local_type) + if ((vtype > _scheme_ir_values_types_) + || ((vtype == scheme_ir_local_type) && !(flags & OMITTABLE_KEEP_VARS) && (!(flags & OMITTABLE_KEEP_MUTABLE_VARS) || !SCHEME_VAR(o)->mutated)) @@ -327,13 +323,13 @@ int scheme_omittable_expr(Scheme_Object *o, int vals, int fuel, int flags, || ((vtype == scheme_local_unbox_type) && !(flags & (OMITTABLE_KEEP_VARS | OMITTABLE_KEEP_MUTABLE_VARS)) && !(SCHEME_GET_LOCAL_FLAGS(o) == SCHEME_LOCAL_CLEAR_ON_READ)) - || (vtype == scheme_unclosed_procedure_type) - || (vtype == scheme_compiled_unclosed_procedure_type) + || (vtype == scheme_lambda_type) + || (vtype == scheme_ir_lambda_type) || (vtype == scheme_inline_variant_type) || (vtype == scheme_case_lambda_sequence_type) || (vtype == scheme_quote_syntax_type) || (vtype == scheme_varref_form_type) - || (vtype == scheme_compiled_quote_syntax_type)) { + || (vtype == scheme_ir_quote_syntax_type)) { note_match(1, vals, warn_info); return ((vals == 1) || (vals < 0)); } @@ -348,7 +344,7 @@ int scheme_omittable_expr(Scheme_Object *o, int vals, int fuel, int flags, } } - if (vtype == scheme_compiled_toplevel_type) { + if (vtype == scheme_ir_toplevel_type) { note_match(1, vals, warn_info); if ((vals == 1) || (vals < 0)) { if (!(flags & OMITTABLE_KEEP_VARS) @@ -392,14 +388,14 @@ int scheme_omittable_expr(Scheme_Object *o, int vals, int fuel, int flags, goto try_again; } - if (vtype == scheme_compiled_let_void_type) { + if (vtype == scheme_ir_let_void_type) { /* recognize another (let ([x ]) ...) pattern: */ - Scheme_Let_Header *lh = (Scheme_Let_Header *)o; + Scheme_IR_Let_Header *lh = (Scheme_IR_Let_Header *)o; int i; MZ_ASSERT(!(flags & OMITTABLE_RESOLVED)); o = lh->body; for (i = 0; i < lh->num_clauses; i++) { - Scheme_Compiled_Let_Value *lv = (Scheme_Compiled_Let_Value *)o; + Scheme_IR_Let_Value *lv = (Scheme_IR_Let_Value *)o; if (!scheme_omittable_expr(lv->value, lv->count, fuel - 1, flags, opt_info, warn_info)) return 0; o = lv->body; @@ -432,7 +428,7 @@ int scheme_omittable_expr(Scheme_Object *o, int vals, int fuel, int flags, } else if (SCHEME_PRIMP(app->args[0])) { if (!(SCHEME_PRIM_PROC_FLAGS(app->args[0]) & SCHEME_PRIM_IS_MULTI_RESULT)) { note_match(1, vals, warn_info); - } else if (SAME_OBJ(scheme_values_func, app->args[0])) { + } else if (SAME_OBJ(scheme_values_proc, app->args[0])) { note_match(app->num_args, vals, warn_info); } } @@ -457,7 +453,7 @@ int scheme_omittable_expr(Scheme_Object *o, int vals, int fuel, int flags, return 1; } else if (SCHEME_PRIMP(app->rator)) { if (!(SCHEME_PRIM_PROC_FLAGS(app->rator) & SCHEME_PRIM_IS_MULTI_RESULT) - || SAME_OBJ(scheme_values_func, app->rator)) { + || SAME_OBJ(scheme_values_proc, app->rator)) { note_match(1, vals, warn_info); } } @@ -481,7 +477,7 @@ int scheme_omittable_expr(Scheme_Object *o, int vals, int fuel, int flags, } else if (SCHEME_PRIMP(app->rator)) { if (!(SCHEME_PRIM_PROC_FLAGS(app->rator) & SCHEME_PRIM_IS_MULTI_RESULT)) { note_match(1, vals, warn_info); - } else if (SAME_OBJ(scheme_values_func, app->rator)) { + } else if (SAME_OBJ(scheme_values_proc, app->rator)) { note_match(2, vals, warn_info); } } @@ -495,7 +491,7 @@ int scheme_omittable_expr(Scheme_Object *o, int vals, int fuel, int flags, && SAME_TYPE(scheme_local_type, SCHEME_TYPE(sb->val)) && (SCHEME_LOCAL_POS(sb->var) == SCHEME_LOCAL_POS(sb->val))) return 1; - else if (SAME_TYPE(scheme_compiled_local_type, SCHEME_TYPE(sb->var)) + else if (SAME_TYPE(scheme_ir_local_type, SCHEME_TYPE(sb->var)) && SAME_OBJ(sb->var, sb->val)) return 1; } @@ -524,7 +520,7 @@ static Scheme_Object *ensure_single_value(Scheme_Object *e) app2 = MALLOC_ONE_TAGGED(Scheme_App2_Rec); app2->iso.so.type = scheme_application2_type; - app2->rator = scheme_values_func; + app2->rator = scheme_values_proc; app2->rand = e; SCHEME_APPN_FLAGS(app2) |= (APPN_FLAG_IMMED | APPN_FLAG_SFS_TAIL); @@ -647,7 +643,7 @@ static Scheme_Object *optimize_ignored(Scheme_Object *e, Optimize_Info *info, { Scheme_App2_Rec *app = (Scheme_App2_Rec *)e; - if (!SAME_OBJ(app->rator, scheme_values_func)) /* `values` is probably here to ensure a single result */ + if (!SAME_OBJ(app->rator, scheme_values_proc)) /* `values` is probably here to ensure a single result */ if (scheme_is_functional_nonfailing_primitive(app->rator, 1, expected_vals)) return do_make_discarding_sequence(app->rand, scheme_void, info, 1, 0); @@ -738,11 +734,11 @@ static Scheme_Object *replace_tail_inside(Scheme_Object *alt, Scheme_Object *ins else scheme_signal_error("internal error: strange inside replacement"); break; - case scheme_compiled_let_void_type: - ((Scheme_Let_Header *)inside)->body = alt; + case scheme_ir_let_void_type: + ((Scheme_IR_Let_Header *)inside)->body = alt; break; - case scheme_compiled_let_value_type: - ((Scheme_Compiled_Let_Value *)inside)->body = alt; + case scheme_ir_let_value_type: + ((Scheme_IR_Let_Value *)inside)->body = alt; break; default: scheme_signal_error("internal error: strange inside replacement"); @@ -757,14 +753,14 @@ static void extract_tail_inside(Scheme_Object **_t2, Scheme_Object **_inside) /* replace_tail_inside() needs to be consistent with this function */ while (1) { - if (SAME_TYPE(SCHEME_TYPE(*_t2), scheme_compiled_let_void_type)) { - Scheme_Let_Header *head = (Scheme_Let_Header *)*_t2; + if (SAME_TYPE(SCHEME_TYPE(*_t2), scheme_ir_let_void_type)) { + Scheme_IR_Let_Header *head = (Scheme_IR_Let_Header *)*_t2; int i; *_inside = *_t2; *_t2 = head->body; for (i = head->num_clauses; i--; ) { *_inside = *_t2; - *_t2 = ((Scheme_Compiled_Let_Value *)*_t2)->body; + *_t2 = ((Scheme_IR_Let_Value *)*_t2)->body; } } else if (SAME_TYPE(SCHEME_TYPE(*_t2), scheme_sequence_type)) { Scheme_Sequence *seq = (Scheme_Sequence *)*_t2; @@ -810,21 +806,21 @@ static int is_proc_spec_proc(Scheme_Object *p) vtype = SCHEME_TYPE(p); - if (vtype == scheme_unclosed_procedure_type) { - if (((Scheme_Closure_Data *)p)->num_params >= 1) + if (vtype == scheme_lambda_type) { + if (((Scheme_Lambda *)p)->num_params >= 1) return 1; } return 0; } -static int is_local_ref(Scheme_Object *e, int p, int r, Scheme_Compiled_Local **vars) +static int is_local_ref(Scheme_Object *e, int p, int r, Scheme_IR_Local **vars) { if (!vars && SAME_TYPE(SCHEME_TYPE(e), scheme_local_type)) { if ((SCHEME_LOCAL_POS(e) >= p) && (SCHEME_LOCAL_POS(e) < (p + r))) return 1; - } else if (vars && SAME_TYPE(SCHEME_TYPE(e), scheme_compiled_local_type)) { + } else if (vars && SAME_TYPE(SCHEME_TYPE(e), scheme_ir_local_type)) { int i; for (i = p; i < p + r; i++) { if (SAME_OBJ(e, (Scheme_Object *)vars[i])) @@ -861,7 +857,7 @@ static int is_int_list(Scheme_Object *o, int up_to) } static int ok_proc_creator_args(Scheme_Object *rator, Scheme_Object *rand1, Scheme_Object *rand2, Scheme_Object *rand3, - int delta2, int field_count, Scheme_Compiled_Local **vars) + int delta2, int field_count, Scheme_IR_Local **vars) { if ((SAME_OBJ(rator, scheme_make_struct_field_accessor_proc) && is_local_ref(rand1, delta2+3, 1, vars)) @@ -880,12 +876,12 @@ static int ok_proc_creator_args(Scheme_Object *rator, Scheme_Object *rand1, Sche static int is_values_with_accessors_and_mutators(Scheme_Object *e, int vals, int resolved, Simple_Stuct_Type_Info *_stinfo, - Scheme_Compiled_Local **vars) + Scheme_IR_Local **vars) { if (SAME_TYPE(SCHEME_TYPE(e), scheme_application_type)) { Scheme_App_Rec *app = (Scheme_App_Rec *)e; int delta = (resolved ? app->num_args : 0); - if (SAME_OBJ(app->args[0], scheme_values_func) + if (SAME_OBJ(app->args[0], scheme_values_proc) && (app->num_args == vals) && (app->num_args >= 3) && is_local_ref(app->args[1], delta, 1, vars) @@ -962,7 +958,7 @@ static int is_constant_super(Scheme_Object *arg, int pos; Scheme_Object *v; - if (SAME_TYPE(SCHEME_TYPE(arg), scheme_compiled_toplevel_type)) { + if (SAME_TYPE(SCHEME_TYPE(arg), scheme_ir_toplevel_type)) { pos = SCHEME_TOPLEVEL_POS(arg); if (top_level_consts) { /* This is optimize mode */ @@ -1122,13 +1118,13 @@ Scheme_Object *scheme_is_simple_make_struct_type(Scheme_Object *e, int vals, int } } - if (SAME_TYPE(SCHEME_TYPE(e), scheme_compiled_let_void_type)) { + if (SAME_TYPE(SCHEME_TYPE(e), scheme_ir_let_void_type)) { /* check for (let-values ([(: mk ? ref- set-!) (make-struct-type ...)]) (values ...)) as generated by the expansion of `struct' */ - Scheme_Let_Header *lh = (Scheme_Let_Header *)e; + Scheme_IR_Let_Header *lh = (Scheme_IR_Let_Header *)e; if ((lh->count == 5) && (lh->num_clauses == 1)) { - if (SAME_TYPE(SCHEME_TYPE(lh->body), scheme_compiled_let_value_type)) { - Scheme_Compiled_Let_Value *lv = (Scheme_Compiled_Let_Value *)lh->body; + if (SAME_TYPE(SCHEME_TYPE(lh->body), scheme_ir_let_value_type)) { + Scheme_IR_Let_Value *lv = (Scheme_IR_Let_Value *)lh->body; if (SAME_TYPE(SCHEME_TYPE(lv->value), scheme_application_type)) { Scheme_Object *auto_e; Simple_Stuct_Type_Info stinfo; @@ -1234,13 +1230,13 @@ static int single_valued_noncm_expression(Scheme_Object *expr, int fuel) int num_args = 0; switch (SCHEME_TYPE(expr)) { - case scheme_compiled_local_type: + case scheme_ir_local_type: return 1; case scheme_local_type: return 1; case scheme_local_unbox_type: return 1; - case scheme_compiled_toplevel_type: + case scheme_ir_toplevel_type: return 1; case scheme_application_type: rator = ((Scheme_App_Rec *)expr)->args[0]; @@ -1267,15 +1263,15 @@ static int single_valued_noncm_expression(Scheme_Object *expr, int fuel) return single_valued_noncm_expression(seq->array[0], fuel - 1); } break; - case scheme_compiled_unclosed_procedure_type: + case scheme_ir_lambda_type: case scheme_case_lambda_sequence_type: case scheme_set_bang_type: return 1; default: - if (SCHEME_TYPE(expr) > _scheme_compiled_values_types_) + if (SCHEME_TYPE(expr) > _scheme_ir_values_types_) return 1; - /* for scheme_compiled_let_void_type + /* for scheme_ir_let_void_type and scheme_begin_sequence_type */ if (fuel > 0) { Scheme_Object *tail = expr, *inside = NULL; @@ -1294,7 +1290,7 @@ static int single_valued_noncm_expression(Scheme_Object *expr, int fuel) return 1; /* special case: (values ) */ - if (SAME_OBJ(rator, scheme_values_func) && (num_args == 1)) + if (SAME_OBJ(rator, scheme_values_proc) && (num_args == 1)) return 1; } @@ -1356,9 +1352,9 @@ static int movable_expression(Scheme_Object *expr, Optimize_Info *info, switch (SCHEME_TYPE(expr)) { case scheme_toplevel_type: return ((SCHEME_TOPLEVEL_FLAGS(expr) & SCHEME_TOPLEVEL_FLAGS_MASK) >= SCHEME_TOPLEVEL_FIXED); - case scheme_compiled_quote_syntax_type: + case scheme_ir_quote_syntax_type: return 1; - case scheme_compiled_local_type: + case scheme_ir_local_type: { /* Ok if not mutable */ if (!SCHEME_VAR(expr)->mutated) { @@ -1417,30 +1413,30 @@ static int movable_expression(Scheme_Object *expr, Optimize_Info *info, return 1; } break; - case scheme_compiled_unclosed_procedure_type: + case scheme_ir_lambda_type: case scheme_case_lambda_sequence_type: /* Can't move across lambda or continuation if not closed, since that changes allocation of a closure. */ return !cross_lambda && !cross_k; default: - if (SCHEME_TYPE(expr) > _scheme_compiled_values_types_) + if (SCHEME_TYPE(expr) > _scheme_ir_values_types_) return 1; } return 0; } -int scheme_is_compiled_procedure(Scheme_Object *o, int can_be_closed, int can_be_liftable) +int scheme_is_ir_lambda(Scheme_Object *o, int can_be_closed, int can_be_liftable) { - if (SAME_TYPE(SCHEME_TYPE(o), scheme_compiled_unclosed_procedure_type)) { + if (SAME_TYPE(SCHEME_TYPE(o), scheme_ir_lambda_type)) { if (!can_be_closed || !can_be_liftable) { - Scheme_Closure_Data *data; - data = (Scheme_Closure_Data *)o; + Scheme_Lambda *lam; + lam = (Scheme_Lambda *)o; /* Because == 0 is like a constant */ - if (!can_be_closed && !data->closure_size) + if (!can_be_closed && !lam->closure_size) return 0; /* Because procs that reference only globals are lifted: */ - if (!can_be_liftable && (data->closure_size == 1) && closure_has_top_level(data)) + if (!can_be_liftable && (lam->closure_size == 1) && closure_has_top_level(lam)) return 0; } return 1; @@ -1510,7 +1506,7 @@ static int estimate_expr_size(Scheme_Object *expr, int sz, int fuel) t = SCHEME_TYPE(expr); switch(t) { - case scheme_compiled_local_type: + case scheme_ir_local_type: { sz += 1; break; @@ -1560,16 +1556,16 @@ static int estimate_expr_size(Scheme_Object *expr, int sz, int fuel) break; } - case scheme_compiled_let_void_type: + case scheme_ir_let_void_type: { - Scheme_Let_Header *head = (Scheme_Let_Header *)expr; + Scheme_IR_Let_Header *head = (Scheme_IR_Let_Header *)expr; Scheme_Object *body; - Scheme_Compiled_Let_Value *lv; + Scheme_IR_Let_Value *lv; int i; body = head->body; for (i = head->num_clauses; i--; ) { - lv = (Scheme_Compiled_Let_Value *)body; + lv = (Scheme_IR_Let_Value *)body; sz = estimate_expr_size(lv->value, sz, fuel - 1); body = lv->body; sz++; @@ -1598,14 +1594,14 @@ static int estimate_expr_size(Scheme_Object *expr, int sz, int fuel) sz = estimate_expr_size(b->fbranch, sz, fuel - 1); break; } - case scheme_compiled_unclosed_procedure_type: + case scheme_ir_lambda_type: { - sz = estimate_expr_size(((Scheme_Closure_Data *)expr)->code, sz, fuel - 1); + sz = estimate_expr_size(((Scheme_Lambda *)expr)->body, sz, fuel - 1); sz++; break; } - case scheme_compiled_toplevel_type: - case scheme_compiled_quote_syntax_type: + case scheme_ir_toplevel_type: + case scheme_ir_quote_syntax_type: /* FIXME: other syntax types not covered */ default: sz += 1; @@ -1634,17 +1630,17 @@ static Scheme_Object *apply_inlined(Scheme_Object *p, Optimize_Info *info, int argc, Scheme_App_Rec *app, Scheme_App2_Rec *app2, Scheme_App3_Rec *app3, int context, Scheme_Object *orig, Scheme_Object *le_prev) { - Scheme_Let_Header *lh; - Scheme_Compiled_Let_Value *lv, *prev = NULL; + Scheme_IR_Let_Header *lh; + Scheme_IR_Let_Value *lv, *prev = NULL; Scheme_Object *val; int i, expected; Optimize_Info *sub_info; - Scheme_Compiled_Local **vars; - Scheme_Closure_Data *data = (Scheme_Closure_Data *)p; + Scheme_IR_Local **vars; + Scheme_Lambda *lam = (Scheme_Lambda *)p; - p = data->code; + p = lam->body; - expected = data->num_params; + expected = lam->num_params; if (!expected) { sub_info = optimize_info_add_frame(info, 0, 0, 0); @@ -1658,22 +1654,22 @@ static Scheme_Object *apply_inlined(Scheme_Object *p, Optimize_Info *info, return replace_tail_inside(p, le_prev, orig); } - lh = MALLOC_ONE_TAGGED(Scheme_Let_Header); - lh->iso.so.type = scheme_compiled_let_void_type; + lh = MALLOC_ONE_TAGGED(Scheme_IR_Let_Header); + lh->iso.so.type = scheme_ir_let_void_type; lh->count = expected; lh->num_clauses = expected; for (i = 0; i < expected; i++) { - lv = MALLOC_ONE_TAGGED(Scheme_Compiled_Let_Value); - lv->iso.so.type = scheme_compiled_let_value_type; + lv = MALLOC_ONE_TAGGED(Scheme_IR_Let_Value); + lv->iso.so.type = scheme_ir_let_value_type; lv->count = 1; - vars = MALLOC_N(Scheme_Compiled_Local*, 1); - vars[0] = ((Closure_Info *)data->closure_map)->vars[i]; + vars = MALLOC_N(Scheme_IR_Local*, 1); + vars[0] = lam->ir_info->vars[i]; lv->vars = vars; if ((i == expected - 1) - && (SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_HAS_REST)) { + && (SCHEME_LAMBDA_FLAGS(lam) & LAMBDA_HAS_REST)) { int j; Scheme_Object *l = scheme_null; @@ -1732,7 +1728,7 @@ int scheme_check_leaf_rator(Scheme_Object *le, int *_flags) opt = ((Scheme_Prim_Proc_Header *)le)->flags & SCHEME_PRIM_OPT_MASK; if (opt >= SCHEME_PRIM_OPT_NONCM) { if (_flags) - *_flags = (CLOS_PRESERVES_MARKS | CLOS_SINGLE_RESULT); + *_flags = (LAMBDA_PRESERVES_MARKS | LAMBDA_SINGLE_RESULT); if (opt >= SCHEME_PRIM_OPT_IMMEDIATE) { return 1; } @@ -1773,19 +1769,19 @@ Scheme_Object *optimize_for_inline(Optimize_Info *info, Scheme_Object *le, int a le = extract_specialized_proc(le, le); - if (SAME_TYPE(SCHEME_TYPE(le), scheme_compiled_unclosed_procedure_type)) { + if (SAME_TYPE(SCHEME_TYPE(le), scheme_ir_lambda_type)) { /* Found a `((lambda' */ single_use = 1; } - if (SAME_TYPE(SCHEME_TYPE(le), scheme_compiled_local_type)) { + if (SAME_TYPE(SCHEME_TYPE(le), scheme_ir_local_type)) { /* Check for inlining: */ le = optimize_info_lookup(info, le, 1, &single_use, 0, 0, &psize, NULL); already_opt = 1; } if (le) { - while (SAME_TYPE(SCHEME_TYPE(le), scheme_compiled_toplevel_type)) { + while (SAME_TYPE(SCHEME_TYPE(le), scheme_ir_toplevel_type)) { int pos; pos = SCHEME_TOPLEVEL_POS(le); single_use = 0; @@ -1820,7 +1816,7 @@ Scheme_Object *optimize_for_inline(Optimize_Info *info, Scheme_Object *le, int a } } } - if (SAME_TYPE(SCHEME_TYPE(le), scheme_compiled_toplevel_type) && info->top_level_consts) { + if (SAME_TYPE(SCHEME_TYPE(le), scheme_ir_toplevel_type) && info->top_level_consts) { le = scheme_hash_get(info->top_level_consts, scheme_make_integer(pos)); if (le && SCHEME_BOXP(le)) { psize = SCHEME_INT_VAL(SCHEME_BOX_VAL(le)); @@ -1845,11 +1841,11 @@ Scheme_Object *optimize_for_inline(Optimize_Info *info, Scheme_Object *le, int a count = cl->count; for (i = 0; i < count; i++) { cp = cl->array[i]; - if (SAME_TYPE(SCHEME_TYPE(cp), scheme_compiled_unclosed_procedure_type)) { - Scheme_Closure_Data *data = (Scheme_Closure_Data *)cp; - if ((data->num_params == argc) - || ((SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_HAS_REST) - && (argc + 1 >= data->num_params))) { + if (SAME_TYPE(SCHEME_TYPE(cp), scheme_ir_lambda_type)) { + Scheme_Lambda *lam = (Scheme_Lambda *)cp; + if ((lam->num_params == argc) + || ((SCHEME_LAMBDA_FLAGS(lam) & LAMBDA_HAS_REST) + && (argc + 1 >= lam->num_params))) { le = cp; break; } @@ -1863,18 +1859,18 @@ Scheme_Object *optimize_for_inline(Optimize_Info *info, Scheme_Object *le, int a nonleaf = 1; - if (le && SAME_TYPE(SCHEME_TYPE(le), scheme_compiled_unclosed_procedure_type) && (info->inline_fuel >= 0)) { - Scheme_Closure_Data *data = (Scheme_Closure_Data *)le; + if (le && SAME_TYPE(SCHEME_TYPE(le), scheme_ir_lambda_type) && (info->inline_fuel >= 0)) { + Scheme_Lambda *lam = (Scheme_Lambda *)le; int sz; if (noapp) return le; - *_flags = SCHEME_CLOSURE_DATA_FLAGS(data); + *_flags = SCHEME_LAMBDA_FLAGS(lam); - if ((data->num_params == argc) - || ((SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_HAS_REST) - && (argc + 1 >= data->num_params))) { + if ((lam->num_params == argc) + || ((SCHEME_LAMBDA_FLAGS(lam) & LAMBDA_HAS_REST) + && (argc + 1 >= lam->num_params))) { int threshold, is_leaf = 0; if (!already_opt) { @@ -1883,7 +1879,7 @@ Scheme_Object *optimize_for_inline(Optimize_Info *info, Scheme_Object *le, int a return NULL; } - sz = closure_body_size(data, 1, info, &is_leaf); + sz = closure_body_size(lam, 1, info, &is_leaf); if (is_leaf) { /* encourage inlining of leaves: */ sz >>= 2; @@ -1896,16 +1892,16 @@ Scheme_Object *optimize_for_inline(Optimize_Info *info, Scheme_Object *le, int a sub_info = info; /* If optimize_clone succeeds, inlining succeeds. */ - le = optimize_clone(single_use, (Scheme_Object *)data, sub_info, empty_eq_hash_tree, 0); + le = optimize_clone(single_use, (Scheme_Object *)lam, sub_info, empty_eq_hash_tree, 0); if (le) { LOG_INLINE(fprintf(stderr, "Inline %d[%d]<=%d@%d %d %s\n", sz, is_leaf, threshold, info->inline_fuel, - single_use, scheme_write_to_string(data->name ? data->name : scheme_false, NULL))); + single_use, scheme_write_to_string(lam->name ? lam->name : scheme_false, NULL))); scheme_log(info->logger, SCHEME_LOG_DEBUG, 0, "inlining %s size: %d threshold: %d#%s", - scheme_write_to_string(data->name ? data->name : scheme_false, NULL), + scheme_write_to_string(lam->name ? lam->name : scheme_false, NULL), sz, threshold, scheme_optimize_context_to_string(info->context)); @@ -1913,32 +1909,32 @@ Scheme_Object *optimize_for_inline(Optimize_Info *info, Scheme_Object *le, int a orig_le, prev); return le; } else { - LOG_INLINE(fprintf(stderr, "No inline %s\n", scheme_write_to_string(data->name ? data->name : scheme_false, NULL))); + LOG_INLINE(fprintf(stderr, "No inline %s\n", scheme_write_to_string(lam->name ? lam->name : scheme_false, NULL))); scheme_log(info->logger, SCHEME_LOG_DEBUG, 0, "no-inlining %s size: %d threshold: %d#%s", - scheme_write_to_string(data->name ? data->name : scheme_false, NULL), + scheme_write_to_string(lam->name ? lam->name : scheme_false, NULL), sz, threshold, scheme_optimize_context_to_string(info->context)); } } else { - LOG_INLINE(fprintf(stderr, "No fuel %s %d[%d]>%d@%d %d\n", scheme_write_to_string(data->name ? data->name : scheme_false, NULL), + LOG_INLINE(fprintf(stderr, "No fuel %s %d[%d]>%d@%d %d\n", scheme_write_to_string(lam->name ? lam->name : scheme_false, NULL), sz, is_leaf, threshold, info->inline_fuel, info->use_psize)); scheme_log(info->logger, SCHEME_LOG_DEBUG, 0, "out-of-fuel %s size: %d threshold: %d#%s", - scheme_write_to_string(data->name ? data->name : scheme_false, NULL), + scheme_write_to_string(lam->name ? lam->name : scheme_false, NULL), sz, threshold, scheme_optimize_context_to_string(info->context)); } } else { /* Issue warning below */ - bad_app = (Scheme_Object *)data; + bad_app = (Scheme_Object *)lam; nonleaf = 0; } } @@ -2011,15 +2007,15 @@ static void register_local_argument_types(Scheme_App_Rec *app, Scheme_App2_Rec * n = 2; } - if (SAME_TYPE(SCHEME_TYPE(rator), scheme_compiled_local_type)) { + if (SAME_TYPE(SCHEME_TYPE(rator), scheme_ir_local_type)) { { le = optimize_info_lookup(info, rator, 1, NULL, 0, 0, NULL, NULL); - if (le && SAME_TYPE(SCHEME_TYPE(le), scheme_compiled_unclosed_procedure_type)) { - Scheme_Closure_Data *data = (Scheme_Closure_Data *)le; + if (le && SAME_TYPE(SCHEME_TYPE(le), scheme_ir_lambda_type)) { + Scheme_Lambda *lam = (Scheme_Lambda *)le; char *map; int ok; - map = get_closure_local_type_map(data, n, &ok); + map = get_closure_local_type_map(lam, n, &ok); if (ok) { for (i = 0; i < n; i++) { @@ -2048,7 +2044,7 @@ static void register_local_argument_types(Scheme_App_Rec *app, Scheme_App2_Rec * map[i] = ct; } - set_closure_local_type_map(data, map); + set_closure_local_type_map(lam, map); } } } @@ -2074,10 +2070,10 @@ char *scheme_optimize_context_to_string(Scheme_Object *context) mod = scheme_false; } - if (SAME_TYPE(SCHEME_TYPE(func), scheme_compiled_unclosed_procedure_type)) { + if (SAME_TYPE(SCHEME_TYPE(func), scheme_ir_lambda_type)) { Scheme_Object *name; - name = ((Scheme_Closure_Data *)func)->name; + name = ((Scheme_Lambda *)func)->name; if (name) { if (SCHEME_VECTORP(name)) { Scheme_Object *port; @@ -2174,8 +2170,8 @@ static Scheme_Object *check_app_let_rator(Scheme_Object *app, Scheme_Object *rat return NULL; /* Moving a variable into application position: */ - if (SAME_TYPE(SCHEME_TYPE(rator), scheme_compiled_local_type)) { - Scheme_Compiled_Local *var = SCHEME_VAR(rator); + if (SAME_TYPE(SCHEME_TYPE(rator), scheme_ir_local_type)) { + Scheme_IR_Local *var = SCHEME_VAR(rator); if (var->non_app_count < SCHEME_USE_COUNT_INF) --var->non_app_count; } @@ -2376,7 +2372,7 @@ static Scheme_Object *expr_implies_predicate(Scheme_Object *expr, Optimize_Info return NULL; switch (SCHEME_TYPE(expr)) { - case scheme_compiled_local_type: + case scheme_ir_local_type: { if (!SCHEME_VAR(expr)->mutated) { Scheme_Object *p; @@ -2429,13 +2425,13 @@ static Scheme_Object *expr_implies_predicate(Scheme_Object *expr, Optimize_Info return rator_implies_predicate(app->args[0], app->num_args); } break; - case scheme_compiled_unclosed_procedure_type: + case scheme_ir_lambda_type: return scheme_procedure_p_proc; break; case scheme_case_lambda_sequence_type: return scheme_procedure_p_proc; break; - case scheme_compiled_quote_syntax_type: + case scheme_ir_quote_syntax_type: return scheme_syntax_p_proc; break; case scheme_branch_type: @@ -2456,13 +2452,13 @@ static Scheme_Object *expr_implies_predicate(Scheme_Object *expr, Optimize_Info return expr_implies_predicate(seq->array[seq->count-1], info, _involves_k_cross, fuel-1); } - case scheme_compiled_let_void_type: + case scheme_ir_let_void_type: { - Scheme_Let_Header *lh = (Scheme_Let_Header *)expr; + Scheme_IR_Let_Header *lh = (Scheme_IR_Let_Header *)expr; int i; expr = lh->body; for (i = 0; i < lh->num_clauses; i++) { - expr = ((Scheme_Compiled_Let_Value *)expr)->body; + expr = ((Scheme_IR_Let_Value *)expr)->body; } return expr_implies_predicate(expr, info, _involves_k_cross, fuel-1); } @@ -2506,7 +2502,7 @@ static Scheme_Object *expr_implies_predicate(Scheme_Object *expr, Optimize_Info return scheme_eof_object_p_proc; if (SCHEME_FALSEP(expr)) - return scheme_not_prim; + return scheme_not_proc; } { @@ -2618,9 +2614,9 @@ static Scheme_Object *call_with_immed_mark(Scheme_Object *rator, Optimize_Info *info) { if (SAME_OBJ(rator, scheme_call_with_immed_mark_proc) - && SAME_TYPE(SCHEME_TYPE(rand2), scheme_compiled_unclosed_procedure_type) - && (((Scheme_Closure_Data *)rand2)->num_params == 1) - && !(SCHEME_CLOSURE_DATA_FLAGS(((Scheme_Closure_Data *)rand2)) & CLOS_HAS_REST)) { + && SAME_TYPE(SCHEME_TYPE(rand2), scheme_ir_lambda_type) + && (((Scheme_Lambda *)rand2)->num_params == 1) + && !(SCHEME_LAMBDA_FLAGS(((Scheme_Lambda *)rand2)) & LAMBDA_HAS_REST)) { Scheme_With_Continuation_Mark *wcm; Scheme_Object *e; @@ -2630,8 +2626,8 @@ static Scheme_Object *call_with_immed_mark(Scheme_Object *rator, wcm->key = rand1; wcm->val = (rand3 ? rand3 : scheme_false); - e = (Scheme_Object *)((Closure_Info *)((Scheme_Closure_Data *)rand2)->closure_map)->vars[0]; - e = scheme_make_mutable_pair(e, ((Scheme_Closure_Data *)rand2)->code); + e = (Scheme_Object *)((Scheme_Lambda *)rand2)->ir_info->vars[0]; + e = scheme_make_mutable_pair(e, ((Scheme_Lambda *)rand2)->body); wcm->body = e; return (Scheme_Object *)wcm; @@ -2710,7 +2706,7 @@ static Scheme_Object *optimize_application(Scheme_Object *o, Optimize_Info *info le = optimize_for_inline(info, app->args[i], n - 1, app, NULL, NULL, &rator_flags, context, 1); if (le) return le; - if (SAME_OBJ(app->args[0], scheme_values_func) + if (SAME_OBJ(app->args[0], scheme_values_proc) || SAME_OBJ(app->args[0], scheme_apply_proc)) info->maybe_values_argument = 1; rator_apply_escapes = info->escapes; @@ -2728,10 +2724,10 @@ static Scheme_Object *optimize_application(Scheme_Object *o, Optimize_Info *info if ((app->num_args == 3) && SAME_OBJ(scheme_hash_ref_proc, app->args[0]) && SCHEME_HASHTRP(app->args[1]) - && SAME_TYPE(scheme_compiled_unclosed_procedure_type, SCHEME_TYPE(app->args[3])) - && (SCHEME_TYPE(((Scheme_Closure_Data *)app->args[3])->code) > _scheme_compiled_values_types_) - && !SCHEME_PROCP(((Scheme_Closure_Data *)app->args[3])->code)) { - app->args[3] = ((Scheme_Closure_Data *)app->args[3])->code; + && SAME_TYPE(scheme_ir_lambda_type, SCHEME_TYPE(app->args[3])) + && (SCHEME_TYPE(((Scheme_Lambda *)app->args[3])->body) > _scheme_ir_values_types_) + && !SCHEME_PROCP(((Scheme_Lambda *)app->args[3])->body)) { + app->args[3] = ((Scheme_Lambda *)app->args[3])->body; } if (rator_apply_escapes) { @@ -2744,7 +2740,7 @@ static Scheme_Object *optimize_application(Scheme_Object *o, Optimize_Info *info static int appn_flags(Scheme_Object *rator, Optimize_Info *info) { - if (SAME_TYPE(SCHEME_TYPE(rator), scheme_compiled_toplevel_type)) { + if (SAME_TYPE(SCHEME_TYPE(rator), scheme_ir_toplevel_type)) { if (info->top_level_consts) { int pos; pos = SCHEME_TOPLEVEL_POS(rator); @@ -2771,7 +2767,7 @@ static int appn_flags(Scheme_Object *rator, Optimize_Info *info) return 0; } - if (SAME_TYPE(scheme_compiled_unclosed_procedure_type, SCHEME_TYPE(rator)) + if (SAME_TYPE(scheme_ir_lambda_type, SCHEME_TYPE(rator)) || SAME_TYPE(scheme_case_lambda_sequence_type, SCHEME_TYPE(rator)) || SAME_TYPE(scheme_noninline_proc_type, SCHEME_TYPE(rator))) return APPN_FLAG_SFS_TAIL; @@ -2799,7 +2795,7 @@ static void check_known(Optimize_Info *info, Scheme_Object *app, info->escapes = 1; } } else { - if (SAME_TYPE(SCHEME_TYPE(rand), scheme_compiled_local_type)) { + if (SAME_TYPE(SCHEME_TYPE(rand), scheme_ir_local_type)) { if (!SCHEME_VAR(rand)->mutated) add_type(info, rand, expect_pred); } @@ -2817,7 +2813,7 @@ static void check_known_rator(Optimize_Info *info, Scheme_Object *rator) if (!SAME_OBJ(pred, scheme_procedure_p_proc)) info->escapes = 1; } else { - if (SAME_TYPE(SCHEME_TYPE(rator), scheme_compiled_local_type)) { + if (SAME_TYPE(SCHEME_TYPE(rator), scheme_ir_local_type)) { if (!SCHEME_VAR(rator)->mutated) add_type(info, rator, scheme_procedure_p_proc); } @@ -2865,7 +2861,7 @@ static Scheme_Object *finish_optimize_any_application(Scheme_Object *app, Scheme if ((context & OPT_CONTEXT_BOOLEAN) && !info->escapes) if (rator_implies_predicate(rator, argc)){ - Scheme_Object *val = SAME_OBJ(rator, scheme_not_prim) ? scheme_false : scheme_true; + Scheme_Object *val = SAME_OBJ(rator, scheme_not_proc) ? scheme_false : scheme_true; return make_discarding_sequence(app, val, info); } @@ -2923,7 +2919,7 @@ static Scheme_Object *finish_optimize_application(Scheme_App_Rec *app, Optimize_ int all_vals = 1, i, flags; for (i = app->num_args; i--; ) { - if (SCHEME_TYPE(app->args[i+1]) < _scheme_compiled_values_types_) + if (SCHEME_TYPE(app->args[i+1]) < _scheme_ir_values_types_) all_vals = 0; } @@ -2936,9 +2932,9 @@ static Scheme_Object *finish_optimize_application(Scheme_App_Rec *app, Optimize_ return le; } - info->preserves_marks = !!(rator_flags & CLOS_PRESERVES_MARKS); - info->single_result = !!(rator_flags & CLOS_SINGLE_RESULT); - if (rator_flags & CLOS_RESULT_TENTATIVE) { + info->preserves_marks = !!(rator_flags & LAMBDA_PRESERVES_MARKS); + info->single_result = !!(rator_flags & LAMBDA_SINGLE_RESULT); + if (rator_flags & LAMBDA_RESULT_TENTATIVE) { info->preserves_marks = -info->preserves_marks; info->single_result = -info->single_result; } @@ -2976,11 +2972,11 @@ static Scheme_Object *lookup_constant_proc(Optimize_Info *info, Scheme_Object *r { Scheme_Object *c = NULL; - if (SAME_TYPE(scheme_compiled_unclosed_procedure_type, SCHEME_TYPE(rand))) + if (SAME_TYPE(scheme_ir_lambda_type, SCHEME_TYPE(rand))) c = rand; - else if (SAME_TYPE(SCHEME_TYPE(rand), scheme_compiled_local_type)) + else if (SAME_TYPE(SCHEME_TYPE(rand), scheme_ir_local_type)) c = optimize_info_lookup(info, rand, 1, NULL, 0, 0, NULL, NULL); - else if (SAME_TYPE(SCHEME_TYPE(rand), scheme_compiled_toplevel_type)) { + else if (SAME_TYPE(SCHEME_TYPE(rand), scheme_ir_toplevel_type)) { if (info->top_level_consts) { int pos; @@ -2988,7 +2984,7 @@ static Scheme_Object *lookup_constant_proc(Optimize_Info *info, Scheme_Object *r pos = SCHEME_TOPLEVEL_POS(rand); c = scheme_hash_get(info->top_level_consts, scheme_make_integer(pos)); c = no_potential_size(c); - if (c && SAME_TYPE(SCHEME_TYPE(c), scheme_compiled_toplevel_type)) + if (c && SAME_TYPE(SCHEME_TYPE(c), scheme_ir_toplevel_type)) rand = c; else break; @@ -3000,7 +2996,7 @@ static Scheme_Object *lookup_constant_proc(Optimize_Info *info, Scheme_Object *r c = SCHEME_BOX_VAL(c); } - if (c && (SAME_TYPE(scheme_compiled_unclosed_procedure_type, SCHEME_TYPE(c)) + if (c && (SAME_TYPE(scheme_ir_lambda_type, SCHEME_TYPE(c)) || SAME_TYPE(scheme_case_lambda_sequence_type, SCHEME_TYPE(c)))) return c; @@ -3053,10 +3049,10 @@ static Scheme_Object *check_ignored_call_cc(Scheme_Object *rator, Scheme_Object if (!proc) proc = optimize_for_inline(info, rand, 1, NULL, NULL, NULL, &rand_flags, context, 0); - if (proc && SAME_TYPE(SCHEME_TYPE(proc), scheme_compiled_unclosed_procedure_type)) { - Scheme_Closure_Data *data = (Scheme_Closure_Data *)proc; - if (data->num_params == 1) { - Closure_Info *cl = (Closure_Info *)data->closure_map; + if (proc && SAME_TYPE(SCHEME_TYPE(proc), scheme_ir_lambda_type)) { + Scheme_Lambda *lam = (Scheme_Lambda *)proc; + if (lam->num_params == 1) { + Scheme_IR_Lambda_Info *cl = lam->ir_info; if (!cl->vars[0]->use_count) { Scheme_Object *expr; info->vclock++; @@ -3135,7 +3131,7 @@ static Scheme_Object *optimize_application2(Scheme_Object *o, Optimize_Info *inf rator_apply_escapes = info->escapes; } - if (SAME_PTR(scheme_not_prim, app->rator)){ + if (SAME_PTR(scheme_not_proc, app->rator)){ sub_context |= OPT_CONTEXT_BOOLEAN; } else { ty = wants_local_type_arguments(app->rator, 0); @@ -3170,7 +3166,7 @@ static Scheme_Object *finish_optimize_application2(Scheme_App2_Rec *app, Optimiz info->size += 1; /* Path for direct constant folding */ - if (SCHEME_TYPE(app->rand) > _scheme_compiled_values_types_) { + if (SCHEME_TYPE(app->rand) > _scheme_ir_values_types_) { Scheme_Object *le; le = try_optimize_fold(rator, NULL, (Scheme_Object *)app, info); if (le) @@ -3183,7 +3179,7 @@ static Scheme_Object *finish_optimize_application2(Scheme_App2_Rec *app, Optimiz the argument was a function call that has been inlined. */ extract_tail_inside(&rand, &inside); - if (SCHEME_TYPE(rand) > _scheme_compiled_values_types_) { + if (SCHEME_TYPE(rand) > _scheme_ir_values_types_) { Scheme_Object *le; le = try_optimize_fold(rator, scheme_make_pair(rand, scheme_null), NULL, info); if (le) @@ -3192,14 +3188,14 @@ static Scheme_Object *finish_optimize_application2(Scheme_App2_Rec *app, Optimiz increment_clocks_for_application(info, rator, 1); - info->preserves_marks = !!(rator_flags & CLOS_PRESERVES_MARKS); - info->single_result = !!(rator_flags & CLOS_SINGLE_RESULT); - if (rator_flags & CLOS_RESULT_TENTATIVE) { + info->preserves_marks = !!(rator_flags & LAMBDA_PRESERVES_MARKS); + info->single_result = !!(rator_flags & LAMBDA_SINGLE_RESULT); + if (rator_flags & LAMBDA_RESULT_TENTATIVE) { info->preserves_marks = -info->preserves_marks; info->single_result = -info->single_result; } - if ((SAME_OBJ(scheme_values_func, rator) + if ((SAME_OBJ(scheme_values_proc, rator) || SAME_OBJ(scheme_list_star_proc, rator)) && ((context & OPT_CONTEXT_SINGLED) || scheme_omittable_expr(rand, 1, -1, 0, info, info) @@ -3323,7 +3319,7 @@ static Scheme_Object *finish_optimize_application2(Scheme_App2_Rec *app, Optimiz info->single_result = 1; return replace_tail_inside(scheme_false, inside, app->rand); } else { - if (var && scheme_compiled_propagate_ok(var, info)) { + if (var && scheme_ir_propagate_ok(var, info)) { /* can propagate => is a constant */ info->preserves_marks = 1; info->single_result = 1; @@ -3464,7 +3460,7 @@ static Scheme_Object *optimize_application3(Scheme_Object *o, Optimize_Info *inf rator_apply_escapes = info->escapes; } - if (SAME_OBJ(app->rator, scheme_values_func) + if (SAME_OBJ(app->rator, scheme_values_proc) || SAME_OBJ(app->rator, scheme_apply_proc)) info->maybe_values_argument = 1; @@ -3527,9 +3523,9 @@ static Scheme_Object *finish_optimize_application3(Scheme_App3_Rec *app, Optimiz info->size += 1; - if (SCHEME_TYPE(app->rand1) < _scheme_compiled_values_types_) + if (SCHEME_TYPE(app->rand1) < _scheme_ir_values_types_) all_vals = 0; - if (SCHEME_TYPE(app->rand2) < _scheme_compiled_values_types_) + if (SCHEME_TYPE(app->rand2) < _scheme_ir_values_types_) all_vals = 0; @@ -3543,14 +3539,14 @@ static Scheme_Object *finish_optimize_application3(Scheme_App3_Rec *app, Optimiz /* Check for (call-with-values (lambda () M) N): */ if (SAME_OBJ(app->rator, scheme_call_with_values_proc)) { - if (SAME_TYPE(SCHEME_TYPE(app->rand1), scheme_compiled_unclosed_procedure_type)) { - Scheme_Closure_Data *data = (Scheme_Closure_Data *)app->rand1; + if (SAME_TYPE(SCHEME_TYPE(app->rand1), scheme_ir_lambda_type)) { + Scheme_Lambda *lam = (Scheme_Lambda *)app->rand1; - if (!data->num_params) { + if (!lam->num_params) { /* Convert to apply-values form: */ - return scheme_optimize_apply_values(app->rand2, data->code, info, - ((SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_SINGLE_RESULT) - ? ((SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_RESULT_TENTATIVE) + return scheme_optimize_apply_values(app->rand2, lam->body, info, + ((SCHEME_LAMBDA_FLAGS(lam) & LAMBDA_SINGLE_RESULT) + ? ((SCHEME_LAMBDA_FLAGS(lam) & LAMBDA_RESULT_TENTATIVE) ? -1 : 1) : 0), @@ -3567,7 +3563,7 @@ static Scheme_Object *finish_optimize_application3(Scheme_App3_Rec *app, Optimiz proc = lookup_constant_proc(info, app->rand1); if (proc) { - if (SAME_TYPE(SCHEME_TYPE(proc), scheme_compiled_unclosed_procedure_type)) { + if (SAME_TYPE(SCHEME_TYPE(proc), scheme_ir_lambda_type)) { cnt = 1; cl = NULL; } else { @@ -3578,13 +3574,13 @@ static Scheme_Object *finish_optimize_application3(Scheme_App3_Rec *app, Optimiz for (i = 0; i < cnt; i++) { if (cl) proc = cl->array[i]; - if (SAME_TYPE(SCHEME_TYPE(proc), scheme_compiled_unclosed_procedure_type)) { - Scheme_Closure_Data *data = (Scheme_Closure_Data *)proc; + if (SAME_TYPE(SCHEME_TYPE(proc), scheme_ir_lambda_type)) { + Scheme_Lambda *lam = (Scheme_Lambda *)proc; int n = SCHEME_INT_VAL(app->rand2), ok; - if (SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_HAS_REST) { - ok = ((data->num_params - 1) <= n); + if (SCHEME_LAMBDA_FLAGS(lam) & LAMBDA_HAS_REST) { + ok = ((lam->num_params - 1) <= n); } else { - ok = (data->num_params == n); + ok = (lam->num_params == n); } if (ok) { info->preserves_marks = 1; @@ -3607,13 +3603,13 @@ static Scheme_Object *finish_optimize_application3(Scheme_App3_Rec *app, Optimiz /* Optimize `equal?' or `eqv?' test on certain types to `eq?'. This is especially helpful for the JIT. */ - if ((SAME_OBJ(app->rator, scheme_equal_prim) - || SAME_OBJ(app->rator, scheme_eqv_prim)) + if ((SAME_OBJ(app->rator, scheme_equal_proc) + || SAME_OBJ(app->rator, scheme_eqv_proc)) && (scheme_eq_testable_constant(app->rand1) || scheme_eq_testable_constant(app->rand2))) { - app->rator = scheme_eq_prim; + app->rator = scheme_eq_proc; SCHEME_APPN_FLAGS(app) |= (APPN_FLAG_IMMED | APPN_FLAG_SFS_TAIL); - scheme_check_leaf_rator(scheme_eq_prim, &rator_flags); + scheme_check_leaf_rator(scheme_eq_proc, &rator_flags); /* eq? is foldable */ if (all_vals) { @@ -3623,7 +3619,7 @@ static Scheme_Object *finish_optimize_application3(Scheme_App3_Rec *app, Optimiz } } - if (SAME_OBJ(app->rator, scheme_eq_prim)) { + if (SAME_OBJ(app->rator, scheme_eq_proc)) { Scheme_Object *pred1, *pred2; pred1 = expr_implies_predicate(app->rand1, info, NULL, 5); if (pred1) { @@ -3644,9 +3640,9 @@ static Scheme_Object *finish_optimize_application3(Scheme_App3_Rec *app, Optimiz } } - info->preserves_marks = !!(rator_flags & CLOS_PRESERVES_MARKS); - info->single_result = !!(rator_flags & CLOS_SINGLE_RESULT); - if (rator_flags & CLOS_RESULT_TENTATIVE) { + info->preserves_marks = !!(rator_flags & LAMBDA_PRESERVES_MARKS); + info->single_result = !!(rator_flags & LAMBDA_SINGLE_RESULT); + if (rator_flags & LAMBDA_RESULT_TENTATIVE) { info->preserves_marks = -info->preserves_marks; info->single_result = -info->single_result; } @@ -3745,14 +3741,14 @@ static Scheme_Object *finish_optimize_application3(Scheme_App3_Rec *app, Optimiz app->rator = scheme_unsafe_fxrshift_proc; app->rand2 = scheme_make_integer(-(SCHEME_INT_VAL(app->rand2))); } - } else if (SAME_OBJ(app->rator, scheme_eq_prim)) { + } else if (SAME_OBJ(app->rator, scheme_eq_proc)) { /* Try optimize: (eq? x #f) => (not x) and (eq? x '()) => (null? x) */ if (SCHEME_FALSEP(app->rand1)) { info->size -= 1; - return make_optimize_prim_application2(scheme_not_prim, app->rand2, info, context); + return make_optimize_prim_application2(scheme_not_proc, app->rand2, info, context); } else if (SCHEME_FALSEP(app->rand2)) { info->size -= 1; - return make_optimize_prim_application2(scheme_not_prim, app->rand1, info, context); + return make_optimize_prim_application2(scheme_not_proc, app->rand1, info, context); } if (SCHEME_NULLP(app->rand1)) { info->size -= 1; @@ -3836,12 +3832,12 @@ Scheme_Object *scheme_optimize_apply_values(Scheme_Object *f, Scheme_Object *e, if (o_f) { f_is_proc = rev; - if (SAME_TYPE(SCHEME_TYPE(o_f), scheme_compiled_unclosed_procedure_type)) { - Scheme_Closure_Data *data2 = (Scheme_Closure_Data *)o_f; - int flags = SCHEME_CLOSURE_DATA_FLAGS(data2); - info->preserves_marks = !!(flags & CLOS_PRESERVES_MARKS); - info->single_result = !!(flags & CLOS_SINGLE_RESULT); - if (flags & CLOS_RESULT_TENTATIVE) { + if (SAME_TYPE(SCHEME_TYPE(o_f), scheme_ir_lambda_type)) { + Scheme_Lambda *lam2 = (Scheme_Lambda *)o_f; + int flags = SCHEME_LAMBDA_FLAGS(lam2); + info->preserves_marks = !!(flags & LAMBDA_PRESERVES_MARKS); + info->single_result = !!(flags & LAMBDA_SINGLE_RESULT); + if (flags & LAMBDA_RESULT_TENTATIVE) { info->preserves_marks = -info->preserves_marks; info->single_result = -info->single_result; } @@ -3862,7 +3858,7 @@ Scheme_Object *scheme_optimize_apply_values(Scheme_Object *f, Scheme_Object *e, cloned = optimize_clone(1, e, info, empty_eq_hash_tree, 0); if (cloned) { - if (SAME_TYPE(SCHEME_TYPE(f_is_proc), scheme_compiled_unclosed_procedure_type)) + if (SAME_TYPE(SCHEME_TYPE(f_is_proc), scheme_ir_lambda_type)) f_cloned = optimize_clone(1, f_is_proc, info, empty_eq_hash_tree, 0); else { /* Otherwise, no clone is needed. */ @@ -3917,7 +3913,7 @@ static Scheme_Object *flatten_sequence(Scheme_Object *o, Optimize_Info *info, in s3 = (Scheme_Sequence *)o3; extra += s3->count; split++; - } else if (SAME_TYPE(SCHEME_TYPE(o3), scheme_compiled_let_void_type) && !(!i && b0)) { + } else if (SAME_TYPE(SCHEME_TYPE(o3), scheme_ir_let_void_type) && !(!i && b0)) { move_to_let = count - i - 1; break; } @@ -3947,10 +3943,10 @@ static Scheme_Object *flatten_sequence(Scheme_Object *o, Optimize_Info *info, in for (j = 0; j < s3->count; j++) { s2->array[k++] = s3->array[j]; } - } else if (SAME_TYPE(SCHEME_TYPE(o3), scheme_compiled_let_void_type) && !(!i && b0)) { + } else if (SAME_TYPE(SCHEME_TYPE(o3), scheme_ir_let_void_type) && !(!i && b0)) { /* move rest under `let`: */ - Scheme_Let_Header *head = (Scheme_Let_Header *)o3; - Scheme_Compiled_Let_Value *clv; + Scheme_IR_Let_Header *head = (Scheme_IR_Let_Header *)o3; + Scheme_IR_Let_Value *irlv; if (s2) s2->array[k++] = o3; @@ -3963,15 +3959,15 @@ static Scheme_Object *flatten_sequence(Scheme_Object *o, Optimize_Info *info, in s3->array[1 + j] = s->array[i + 1 + j]; } - clv = (Scheme_Compiled_Let_Value *)head->body; + irlv = (Scheme_IR_Let_Value *)head->body; for (j = 1; j < head->num_clauses; j++) { - clv = (Scheme_Compiled_Let_Value *)clv->body; + irlv = (Scheme_IR_Let_Value *)irlv->body; } - s3->array[0] = clv->body; + s3->array[0] = irlv->body; o3 = flatten_sequence((Scheme_Object *)s3, info, context); - clv->body = (Scheme_Object *)o3; + irlv->body = (Scheme_Object *)o3; return ((s2 && (s2->count > 1)) ? (Scheme_Object *)s2 @@ -4098,7 +4094,7 @@ XFORM_NONGCING static int small_inline_number(Scheme_Object *o) #define STR_INLINE_LIMIT 256 -int scheme_compiled_duplicate_ok(Scheme_Object *fb, int cross_module) +int scheme_ir_duplicate_ok(Scheme_Object *fb, int cross_module) { return (SCHEME_VOIDP(fb) || SAME_OBJ(fb, scheme_true) @@ -4111,7 +4107,7 @@ int scheme_compiled_duplicate_ok(Scheme_Object *fb, int cross_module) || SCHEME_EOFP(fb) || SCHEME_INTP(fb) || SCHEME_NULLP(fb) - || (!cross_module && SAME_TYPE(SCHEME_TYPE(fb), scheme_compiled_local_type)) + || (!cross_module && SAME_TYPE(SCHEME_TYPE(fb), scheme_ir_local_type)) || SCHEME_PRIMP(fb) /* Values that are hashed by the printer and/or interned on read to avoid duplication: */ @@ -4134,7 +4130,7 @@ static Scheme_Object *collapse_local(Scheme_Object *var, Optimize_Info *info, in pred = optimize_get_predicate(info, var); if (pred) { - if (SAME_OBJ(pred, scheme_not_prim)) + if (SAME_OBJ(pred, scheme_not_proc)) return scheme_false; if (context & OPT_CONTEXT_BOOLEAN) { @@ -4160,8 +4156,8 @@ static Scheme_Object *equivalent_exprs(Scheme_Object *a, Scheme_Object *b, return a; if (b_info - && SAME_TYPE(SCHEME_TYPE(a), scheme_compiled_local_type) - && (SCHEME_TYPE(b) > _scheme_compiled_values_types_)) { + && SAME_TYPE(SCHEME_TYPE(a), scheme_ir_local_type) + && (SCHEME_TYPE(b) > _scheme_ir_values_types_)) { Scheme_Object *n; n = collapse_local(a, b_info, context); if (n && SAME_OBJ(n, b)) @@ -4169,8 +4165,8 @@ static Scheme_Object *equivalent_exprs(Scheme_Object *a, Scheme_Object *b, } if (a_info - && SAME_TYPE(SCHEME_TYPE(b), scheme_compiled_local_type) - && (SCHEME_TYPE(a) > _scheme_compiled_values_types_)) { + && SAME_TYPE(SCHEME_TYPE(b), scheme_ir_local_type) + && (SCHEME_TYPE(a) > _scheme_ir_values_types_)) { Scheme_Object *n; n = collapse_local(b, a_info, context); if (n && SAME_OBJ(n, a)) @@ -4263,7 +4259,7 @@ static int relevant_predicate(Scheme_Object *pred) || SAME_OBJ(pred, scheme_extflonum_p_proc) || SAME_OBJ(pred, scheme_void_p_proc) || SAME_OBJ(pred, scheme_eof_object_p_proc) - || SAME_OBJ(pred, scheme_not_prim) + || SAME_OBJ(pred, scheme_not_proc) ); } @@ -4275,7 +4271,7 @@ static void add_types_for_t_branch(Scheme_Object *t, Optimize_Info *info, int fu if (SAME_TYPE(SCHEME_TYPE(t), scheme_application2_type)) { Scheme_App2_Rec *app = (Scheme_App2_Rec *)t; if (SCHEME_PRIMP(app->rator) - && SAME_TYPE(SCHEME_TYPE(app->rand), scheme_compiled_local_type) + && SAME_TYPE(SCHEME_TYPE(app->rand), scheme_ir_local_type) && !SCHEME_VAR(app->rand)->mutated && relevant_predicate(app->rator)) { /* Looks like a predicate on a local variable. Record that the @@ -4287,8 +4283,8 @@ static void add_types_for_t_branch(Scheme_Object *t, Optimize_Info *info, int fu } else if (SAME_TYPE(SCHEME_TYPE(t), scheme_application3_type)) { Scheme_App3_Rec *app = (Scheme_App3_Rec *)t; Scheme_Object *pred1, *pred2; - if (SAME_OBJ(app->rator, scheme_eq_prim)) { - if (SAME_TYPE(SCHEME_TYPE(app->rand1), scheme_compiled_local_type) + if (SAME_OBJ(app->rator, scheme_eq_proc)) { + if (SAME_TYPE(SCHEME_TYPE(app->rand1), scheme_ir_local_type) && !SCHEME_VAR(app->rand1)->mutated) { pred1 = optimize_get_predicate(info, app->rand1); if (!pred1) { @@ -4297,7 +4293,7 @@ static void add_types_for_t_branch(Scheme_Object *t, Optimize_Info *info, int fu add_type(info, app->rand1, pred2); } } - if (SAME_TYPE(SCHEME_TYPE(app->rand2), scheme_compiled_local_type) + if (SAME_TYPE(SCHEME_TYPE(app->rand2), scheme_ir_local_type) && !SCHEME_VAR(app->rand2)->mutated) { pred2 = optimize_get_predicate(info, app->rand2); if (!pred2) { @@ -4326,8 +4322,8 @@ static void add_types_for_f_branch(Scheme_Object *t, Optimize_Info *info, int fu if (fuel < 0) return; - if (SAME_TYPE(SCHEME_TYPE(t), scheme_compiled_local_type)) { - add_type(info, t, scheme_not_prim); + if (SAME_TYPE(SCHEME_TYPE(t), scheme_ir_local_type)) { + add_type(info, t, scheme_not_proc); } else if (SAME_TYPE(SCHEME_TYPE(t), scheme_branch_type)) { Scheme_Branch_Rec *b = (Scheme_Branch_Rec *)t; @@ -4371,14 +4367,14 @@ static Scheme_Object *optimize_branch(Scheme_Object *o, Optimize_Info *info, int fb = b->fbranch; /* Convert (if expr ) to (if expr #f) */ - if (SAME_TYPE(SCHEME_TYPE(t), scheme_compiled_local_type) + if (SAME_TYPE(SCHEME_TYPE(t), scheme_ir_local_type) && SAME_OBJ(t, fb)) { fb = scheme_false; } if (context & OPT_CONTEXT_BOOLEAN) { /* For test position, convert (if expr) to (if #t expr) */ - if (SAME_TYPE(SCHEME_TYPE(t), scheme_compiled_local_type) + if (SAME_TYPE(SCHEME_TYPE(t), scheme_ir_local_type) && SAME_OBJ(t, tb)) { tb = scheme_true; } @@ -4408,7 +4404,7 @@ static Scheme_Object *optimize_branch(Scheme_Object *o, Optimize_Info *info, int if (SAME_TYPE(SCHEME_TYPE(t2), scheme_application2_type)) { Scheme_App2_Rec *app = (Scheme_App2_Rec *)t2; - if (SAME_PTR(scheme_not_prim, app->rator)) { + if (SAME_PTR(scheme_not_proc, app->rator)) { t2 = tb; tb = fb; fb = t2; @@ -4424,7 +4420,7 @@ static Scheme_Object *optimize_branch(Scheme_Object *o, Optimize_Info *info, int pred = expr_implies_predicate(t2, info, NULL, 5); if (pred) { /* (if (let () (cons x y)) a b) => (if (begin (let () (begin x y #)) #t/#f) a b) */ - Scheme_Object *test_val = SAME_OBJ(pred, scheme_not_prim) ? scheme_false : scheme_true; + Scheme_Object *test_val = SAME_OBJ(pred, scheme_not_proc) ? scheme_false : scheme_true; t2 = optimize_ignored(t2, info, 1, 0, 5); t = replace_tail_inside(t2, inside, t); @@ -4439,7 +4435,7 @@ static Scheme_Object *optimize_branch(Scheme_Object *o, Optimize_Info *info, int } } - if (SCHEME_TYPE(t2) > _scheme_compiled_values_types_) { + if (SCHEME_TYPE(t2) > _scheme_ir_values_types_) { /* Branch is statically known */ Scheme_Object *xb; @@ -4532,7 +4528,7 @@ static Scheme_Object *optimize_branch(Scheme_Object *o, Optimize_Info *info, int if (SCHEME_FALSEP(tb) && SAME_OBJ(fb, scheme_true)) { info->size -= 2; - return make_optimize_prim_application2(scheme_not_prim, t, info, context); + return make_optimize_prim_application2(scheme_not_proc, t, info, context); } /* Try optimize: (if v v) => v */ @@ -4549,7 +4545,7 @@ static Scheme_Object *optimize_branch(Scheme_Object *o, Optimize_Info *info, int /* Try optimize: (if x x #f) => x This pattern is included in the previous reduction, but this is still useful if x is mutable */ - if (SAME_TYPE(SCHEME_TYPE(t), scheme_compiled_local_type) + if (SAME_TYPE(SCHEME_TYPE(t), scheme_ir_local_type) && SAME_OBJ(t, tb) && SCHEME_FALSEP(fb)) { info->size -= 2; @@ -4560,7 +4556,7 @@ static Scheme_Object *optimize_branch(Scheme_Object *o, Optimize_Info *info, int for simple constants K. This is useful to expose simple tests to the JIT. */ if (SAME_TYPE(SCHEME_TYPE(t), scheme_branch_type) - && scheme_compiled_duplicate_ok(fb, 0)) { + && scheme_ir_duplicate_ok(fb, 0)) { Scheme_Branch_Rec *b2 = (Scheme_Branch_Rec *)t; if (SCHEME_FALSEP(b2->fbranch)) { Scheme_Branch_Rec *b3; @@ -4690,7 +4686,7 @@ set_optimize(Scheme_Object *data, Optimize_Info *info, int context) info->preserves_marks = 1; info->single_result = 1; - if (SAME_TYPE(SCHEME_TYPE(var), scheme_compiled_local_type)) { + if (SAME_TYPE(SCHEME_TYPE(var), scheme_ir_local_type)) { /* Register that we use this variable: */ optimize_info_lookup(info, var, 0, NULL, 0, 0, NULL, NULL); } else { @@ -4719,7 +4715,7 @@ set_clone(int single_use, Scheme_Object *data, Optimize_Info *info, Scheme_Hash_ val = optimize_clone(single_use, val, info, var_map, 0); if (!val) return NULL; - if (SAME_TYPE(SCHEME_TYPE(var), scheme_compiled_local_type)) { + if (SAME_TYPE(SCHEME_TYPE(var), scheme_ir_local_type)) { var = optimize_clone(single_use, var, info, var_map, 0); if (!var) return NULL; } @@ -4738,9 +4734,9 @@ ref_optimize(Scheme_Object *data, Optimize_Info *info, int context) optimize_info_used_top(info); v = SCHEME_PTR1_VAL(data); - if (SAME_TYPE(SCHEME_TYPE(v), scheme_compiled_local_type)) { + if (SAME_TYPE(SCHEME_TYPE(v), scheme_ir_local_type)) { SCHEME_PTR1_VAL(data) = (SCHEME_VAR(v)->mutated ? scheme_false : scheme_true); - } else if (SAME_TYPE(SCHEME_TYPE(v), scheme_compiled_toplevel_type)) { + } else if (SAME_TYPE(SCHEME_TYPE(v), scheme_ir_toplevel_type)) { /* Knowing whether a top-level variable is fixed lets up optimize uses of `variable-reference-constant?` */ if (info->top_level_consts) { @@ -4858,7 +4854,7 @@ with_immed_mark_optimize(Scheme_Object *data, Optimize_Info *info, int context) Scheme_Object *key, *val, *body; Optimize_Info_Sequence info_seq; Optimize_Info *body_info; - Scheme_Compiled_Local *var; + Scheme_IR_Local *var; optimize_info_seq_init(info, &info_seq); @@ -4902,7 +4898,7 @@ with_immed_mark_clone(int single_use, Scheme_Object *data, Optimize_Info *info, Scheme_With_Continuation_Mark *wcm = (Scheme_With_Continuation_Mark *)data; Scheme_With_Continuation_Mark *wcm2; Scheme_Object *e; - Scheme_Compiled_Local *var; + Scheme_IR_Local *var; wcm2 = MALLOC_ONE_TAGGED(Scheme_With_Continuation_Mark); wcm2->so.type = scheme_with_immed_mark_type; @@ -5186,7 +5182,7 @@ static int is_liftable_prim(Scheme_Object *v, int or_escape) } } - if (SAME_OBJ(v, scheme_values_func)) + if (SAME_OBJ(v, scheme_values_proc)) return 1; return 0; @@ -5199,13 +5195,13 @@ int scheme_is_liftable(Scheme_Object *o, Scheme_Hash_Tree *exclude_vars, int fue if (!fuel) return 0; switch (t) { - case scheme_compiled_unclosed_procedure_type: + case scheme_ir_lambda_type: return !as_rator; case scheme_case_lambda_sequence_type: return !as_rator; - case scheme_compiled_toplevel_type: + case scheme_ir_toplevel_type: return 1; - case scheme_compiled_local_type: + case scheme_ir_local_type: if (!scheme_hash_tree_get(exclude_vars, o)) return 1; break; @@ -5252,48 +5248,48 @@ int scheme_is_liftable(Scheme_Object *o, Scheme_Hash_Tree *exclude_vars, int fue return 1; } break; - case scheme_compiled_let_void_type: + case scheme_ir_let_void_type: { - Scheme_Let_Header *lh = (Scheme_Let_Header *)o; + Scheme_IR_Let_Header *lh = (Scheme_IR_Let_Header *)o; int i; o = lh->body; for (i = lh->num_clauses; i--; ) { - if (!scheme_is_liftable(((Scheme_Compiled_Let_Value *)o)->value, exclude_vars, fuel - 1, as_rator, or_escape)) + if (!scheme_is_liftable(((Scheme_IR_Let_Value *)o)->value, exclude_vars, fuel - 1, as_rator, or_escape)) return 0; - o = ((Scheme_Compiled_Let_Value *)o)->body; + o = ((Scheme_IR_Let_Value *)o)->body; } if (scheme_is_liftable(o, exclude_vars, fuel - 1, as_rator, or_escape)) return 1; break; } default: - if (t > _scheme_compiled_values_types_) + if (t > _scheme_ir_values_types_) return 1; } return 0; } -int scheme_compiled_propagate_ok(Scheme_Object *value, Optimize_Info *info) +int scheme_ir_propagate_ok(Scheme_Object *value, Optimize_Info *info) { - if (scheme_compiled_duplicate_ok(value, 0)) + if (scheme_ir_duplicate_ok(value, 0)) return 1; - if (SAME_TYPE(SCHEME_TYPE(value), scheme_compiled_unclosed_procedure_type)) { + if (SAME_TYPE(SCHEME_TYPE(value), scheme_ir_lambda_type)) { int sz; - sz = closure_body_size((Scheme_Closure_Data *)value, 1, info, NULL); + sz = closure_body_size((Scheme_Lambda *)value, 1, info, NULL); if ((sz >= 0) && (sz <= MAX_PROC_INLINE_SIZE)) return 1; else { - Scheme_Closure_Data *data = (Scheme_Closure_Data *)value; + Scheme_Lambda *lam = (Scheme_Lambda *)value; if (sz < 0) scheme_log(info->logger, SCHEME_LOG_DEBUG, 0, /* contains non-copyable body elements that prevent inlining */ "non-copyable %s size: %d threshold: %d#%s", - scheme_write_to_string(data->name ? data->name : scheme_false, NULL), + scheme_write_to_string(lam->name ? lam->name : scheme_false, NULL), sz, 0, /* no sensible threshold here */ scheme_optimize_context_to_string(info->context)); @@ -5303,7 +5299,7 @@ int scheme_compiled_propagate_ok(Scheme_Object *value, Optimize_Info *info) 0, /* too large to be an inlining candidate */ "too-large %s size: %d threshold: %d#%s", - scheme_write_to_string(data->name ? data->name : scheme_false, NULL), + scheme_write_to_string(lam->name ? lam->name : scheme_false, NULL), sz, 0, /* no sensible threshold here */ scheme_optimize_context_to_string(info->context)); @@ -5316,13 +5312,13 @@ int scheme_compiled_propagate_ok(Scheme_Object *value, Optimize_Info *info) Scheme_Case_Lambda *cl = (Scheme_Case_Lambda *)value; int i; for (i = cl->count; i--; ) { - if (!scheme_compiled_propagate_ok(cl->array[i], info)) + if (!scheme_ir_propagate_ok(cl->array[i], info)) return 0; } return 1; } - if (SAME_TYPE(SCHEME_TYPE(value), scheme_compiled_toplevel_type)) { + if (SAME_TYPE(SCHEME_TYPE(value), scheme_ir_toplevel_type)) { if ((SCHEME_TOPLEVEL_FLAGS(value) & SCHEME_TOPLEVEL_FLAGS_MASK) >= SCHEME_TOPLEVEL_FIXED) return 1; if (info->top_level_consts) { @@ -5344,15 +5340,15 @@ int scheme_compiled_propagate_ok(Scheme_Object *value, Optimize_Info *info) int scheme_is_statically_proc(Scheme_Object *value, Optimize_Info *info) { while (1) { - if (SAME_TYPE(SCHEME_TYPE(value), scheme_compiled_unclosed_procedure_type)) + if (SAME_TYPE(SCHEME_TYPE(value), scheme_ir_lambda_type)) return 1; else if (SAME_TYPE(SCHEME_TYPE(value), scheme_case_lambda_sequence_type)) { return 1; - } else if (SAME_TYPE(SCHEME_TYPE(value), scheme_compiled_let_void_type)) { + } else if (SAME_TYPE(SCHEME_TYPE(value), scheme_ir_let_void_type)) { /* Look for (let ([x ]) ), which is generated for optional arguments. */ - Scheme_Let_Header *lh = (Scheme_Let_Header *)value; + Scheme_IR_Let_Header *lh = (Scheme_IR_Let_Header *)value; if (lh->num_clauses == 1) { - Scheme_Compiled_Let_Value *lv = (Scheme_Compiled_Let_Value *)lh->body; + Scheme_IR_Let_Value *lv = (Scheme_IR_Let_Value *)lh->body; if (scheme_omittable_expr(lv->value, lv->count, 20, 0, info, NULL)) { value = lv->body; info = NULL; @@ -5371,10 +5367,10 @@ Scheme_Object *scheme_make_noninline_proc(Scheme_Object *e) { Scheme_Object *ni; - while (SAME_TYPE(SCHEME_TYPE(e), scheme_compiled_let_void_type)) { + while (SAME_TYPE(SCHEME_TYPE(e), scheme_ir_let_void_type)) { /* This must be (let ([x ]) ); see scheme_is_statically_proc() */ - Scheme_Let_Header *lh = (Scheme_Let_Header *)e; - Scheme_Compiled_Let_Value *lv = (Scheme_Compiled_Let_Value *)lh->body; + Scheme_IR_Let_Header *lh = (Scheme_IR_Let_Header *)e; + Scheme_IR_Let_Value *lv = (Scheme_IR_Let_Value *)lh->body; MZ_ASSERT(lh->num_clauses == 1); e = lv->body; } @@ -5391,16 +5387,16 @@ static int is_values_apply(Scheme_Object *e, int n, Optimize_Info *info, Scheme_ if (SAME_TYPE(SCHEME_TYPE(e), scheme_application_type)) { Scheme_App_Rec *app = (Scheme_App_Rec *)e; if (n != app->num_args) return 0; - return SAME_OBJ(scheme_values_func, app->args[0]); + return SAME_OBJ(scheme_values_proc, app->args[0]); } else if ((n == 1) && SAME_TYPE(SCHEME_TYPE(e), scheme_application2_type)) { Scheme_App2_Rec *app = (Scheme_App2_Rec *)e; - return SAME_OBJ(scheme_values_func, app->rator); + return SAME_OBJ(scheme_values_proc, app->rator); } else if ((n == 2) && SAME_TYPE(SCHEME_TYPE(e), scheme_application3_type)) { Scheme_App3_Rec *app = (Scheme_App3_Rec *)e; - return SAME_OBJ(scheme_values_func, app->rator); + return SAME_OBJ(scheme_values_proc, app->rator); } else if (fuel && SAME_TYPE(SCHEME_TYPE(e), scheme_branch_type)) { Scheme_Branch_Rec *b = (Scheme_Branch_Rec *)e; - if (SAME_TYPE(SCHEME_TYPE(b->test), scheme_compiled_local_type) + if (SAME_TYPE(SCHEME_TYPE(b->test), scheme_ir_local_type) && !scheme_hash_tree_get(except_vars, b->test) && !SCHEME_VAR(b->test)->mutated) { return (is_values_apply(b->tbranch, n, info, except_vars, 0) @@ -5411,7 +5407,7 @@ static int is_values_apply(Scheme_Object *e, int n, Optimize_Info *info, Scheme_ return 0; } -static int no_mutable_bindings(Scheme_Compiled_Let_Value *pre_body) +static int no_mutable_bindings(Scheme_IR_Let_Value *pre_body) { int i; @@ -5423,8 +5419,8 @@ static int no_mutable_bindings(Scheme_Compiled_Let_Value *pre_body) return 1; } -static void update_rhs_value(Scheme_Compiled_Let_Value *naya, Scheme_Object *e, - Optimize_Info *info, Scheme_Compiled_Local *tst) +static void update_rhs_value(Scheme_IR_Let_Value *naya, Scheme_Object *e, + Optimize_Info *info, Scheme_IR_Local *tst) { if (tst) { Scheme_Object *n; @@ -5449,15 +5445,15 @@ static void update_rhs_value(Scheme_Compiled_Let_Value *naya, Scheme_Object *e, naya->value = e; } -static void unpack_values_application(Scheme_Object *e, Scheme_Compiled_Let_Value *naya, - Optimize_Info *info, Scheme_Compiled_Local *branch_test) +static void unpack_values_application(Scheme_Object *e, Scheme_IR_Let_Value *naya, + Optimize_Info *info, Scheme_IR_Local *branch_test) { if (SAME_TYPE(SCHEME_TYPE(e), scheme_application_type)) { Scheme_App_Rec *app = (Scheme_App_Rec *)e; int i; for (i = 0; i < app->num_args; i++) { update_rhs_value(naya, app->args[i + 1], info, branch_test); - naya = (Scheme_Compiled_Let_Value *)naya->body; + naya = (Scheme_IR_Let_Value *)naya->body; } } else if (SAME_TYPE(SCHEME_TYPE(e), scheme_application2_type)) { Scheme_App2_Rec *app = (Scheme_App2_Rec *)e; @@ -5465,30 +5461,30 @@ static void unpack_values_application(Scheme_Object *e, Scheme_Compiled_Let_Valu } else if (SAME_TYPE(SCHEME_TYPE(e), scheme_application3_type)) { Scheme_App3_Rec *app = (Scheme_App3_Rec *)e; update_rhs_value(naya, app->rand1, info, branch_test); - naya = (Scheme_Compiled_Let_Value *)naya->body; + naya = (Scheme_IR_Let_Value *)naya->body; update_rhs_value(naya, app->rand2, info, branch_test); } else if (SAME_TYPE(SCHEME_TYPE(e), scheme_branch_type)) { Scheme_Branch_Rec *b = (Scheme_Branch_Rec *)e; - MZ_ASSERT(SAME_TYPE(SCHEME_TYPE(b->test), scheme_compiled_local_type)); + MZ_ASSERT(SAME_TYPE(SCHEME_TYPE(b->test), scheme_ir_local_type)); unpack_values_application(b->tbranch, naya, info, NULL); unpack_values_application(b->fbranch, naya, info, SCHEME_VAR(b->test)); } } -static Scheme_Object *make_clones(Scheme_Compiled_Let_Value *retry_start, - Scheme_Compiled_Let_Value *pre_body, +static Scheme_Object *make_clones(Scheme_IR_Let_Value *retry_start, + Scheme_IR_Let_Value *pre_body, Optimize_Info *body_info) { - Scheme_Compiled_Let_Value *clv; + Scheme_IR_Let_Value *irlv; Scheme_Object *value, *clone, *pr; Scheme_Object *last = NULL, *first = NULL; - clv = retry_start; + irlv = retry_start; while (1) { - value = clv->value; - if (IS_COMPILED_PROC(value)) { + value = irlv->value; + if (SCHEME_LAMBDAP(value)) { clone = optimize_clone(1, value, body_info, empty_eq_hash_tree, 0); if (clone) { pr = scheme_make_raw_pair(scheme_make_raw_pair(value, clone), NULL); @@ -5500,9 +5496,9 @@ static Scheme_Object *make_clones(Scheme_Compiled_Let_Value *retry_start, first = pr; last = pr; } - if (clv == pre_body) + if (irlv == pre_body) break; - clv = (Scheme_Compiled_Let_Value *)clv->body; + irlv = (Scheme_IR_Let_Value *)irlv->body; } return first; @@ -5514,10 +5510,10 @@ static int set_one_code_flags(Scheme_Object *value, int flags, int merge_local_typed) { Scheme_Case_Lambda *cl, *cl2, *cl3; - Scheme_Closure_Data *data, *data2, *data3; + Scheme_Lambda *lam, *lam2, *lam3; int i, count; - if (SAME_TYPE(scheme_compiled_unclosed_procedure_type, SCHEME_TYPE(value))) { + if (SAME_TYPE(scheme_ir_lambda_type, SCHEME_TYPE(value))) { count = 1; cl = NULL; cl2 = NULL; @@ -5531,50 +5527,50 @@ static int set_one_code_flags(Scheme_Object *value, int flags, for (i = 0; i < count; i++) { if (cl) { - data = (Scheme_Closure_Data *)cl->array[i]; - data2 = (Scheme_Closure_Data *)cl2->array[i]; - data3 = (Scheme_Closure_Data *)cl3->array[i]; + lam = (Scheme_Lambda *)cl->array[i]; + lam2 = (Scheme_Lambda *)cl2->array[i]; + lam3 = (Scheme_Lambda *)cl3->array[i]; } else { - data = (Scheme_Closure_Data *)value; - data2 = (Scheme_Closure_Data *)first; - data3 = (Scheme_Closure_Data *)second; + lam = (Scheme_Lambda *)value; + lam2 = (Scheme_Lambda *)first; + lam3 = (Scheme_Lambda *)second; } if (merge_local_typed) { - merge_closure_local_type_map(data, data2); - merge_closure_local_type_map(data, data3); - merge_closure_local_type_map(data, data2); + merge_closure_local_type_map(lam, lam2); + merge_closure_local_type_map(lam, lam3); + merge_closure_local_type_map(lam, lam2); } - if (!just_tentative || (SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_RESULT_TENTATIVE)) { - flags = (flags & SCHEME_CLOSURE_DATA_FLAGS(data)); - SCHEME_CLOSURE_DATA_FLAGS(data2) = set_flags | (SCHEME_CLOSURE_DATA_FLAGS(data2) & mask_flags); - SCHEME_CLOSURE_DATA_FLAGS(data3) = set_flags | (SCHEME_CLOSURE_DATA_FLAGS(data3) & mask_flags); + if (!just_tentative || (SCHEME_LAMBDA_FLAGS(lam) & LAMBDA_RESULT_TENTATIVE)) { + flags = (flags & SCHEME_LAMBDA_FLAGS(lam)); + SCHEME_LAMBDA_FLAGS(lam2) = set_flags | (SCHEME_LAMBDA_FLAGS(lam2) & mask_flags); + SCHEME_LAMBDA_FLAGS(lam3) = set_flags | (SCHEME_LAMBDA_FLAGS(lam3) & mask_flags); } } return flags; } -static int set_code_flags(Scheme_Compiled_Let_Value *retry_start, - Scheme_Compiled_Let_Value *pre_body, +static int set_code_flags(Scheme_IR_Let_Value *retry_start, + Scheme_IR_Let_Value *pre_body, Scheme_Object *clones, int set_flags, int mask_flags, int just_tentative, int merge_local_typed) { - Scheme_Compiled_Let_Value *clv; + Scheme_IR_Let_Value *irlv; Scheme_Object *value, *first; - int flags = CLOS_SINGLE_RESULT | CLOS_PRESERVES_MARKS; + int flags = LAMBDA_SINGLE_RESULT | LAMBDA_PRESERVES_MARKS; /* The first in a clone pair is the one that is consulted for references. The second one is the clone, and it's the one whose flags are updated by optimization. So consult the clone, and set flags in both. */ - clv = retry_start; + irlv = retry_start; while (clones) { - value = clv->value; - if (IS_COMPILED_PROC(value)) { + value = irlv->value; + if (SCHEME_LAMBDAP(value)) { first = SCHEME_CAR(clones); if (first) @@ -5586,29 +5582,29 @@ static int set_code_flags(Scheme_Compiled_Let_Value *retry_start, clones = SCHEME_CDR(clones); } - if (clv == pre_body) + if (irlv == pre_body) break; - clv = (Scheme_Compiled_Let_Value *)clv->body; + irlv = (Scheme_IR_Let_Value *)irlv->body; } return flags; } -static int compiled_proc_body_size(Scheme_Object *o, int less_args) +static int lambda_body_size(Scheme_Object *o, int less_args) { int bsz; - if (SAME_TYPE(SCHEME_TYPE(o), scheme_compiled_unclosed_procedure_type)) { - bsz = closure_body_size((Scheme_Closure_Data *)o, 0, NULL, NULL); - if (less_args) bsz -= ((Scheme_Closure_Data *)o)->num_params; + if (SAME_TYPE(SCHEME_TYPE(o), scheme_ir_lambda_type)) { + bsz = closure_body_size((Scheme_Lambda *)o, 0, NULL, NULL); + if (less_args) bsz -= ((Scheme_Lambda *)o)->num_params; return bsz; } else if (SAME_TYPE(SCHEME_TYPE(o), scheme_case_lambda_sequence_type)) { Scheme_Case_Lambda *cl = (Scheme_Case_Lambda *)o; int i, sz = 0; for (i = cl->count; i--; ) { - bsz = closure_body_size((Scheme_Closure_Data *)cl->array[i], 0, NULL, NULL); + bsz = closure_body_size((Scheme_Lambda *)cl->array[i], 0, NULL, NULL); if (less_args) { - bsz -= ((Scheme_Closure_Data *)cl->array[i])->num_params; + bsz -= ((Scheme_Lambda *)cl->array[i])->num_params; if (bsz > sz) sz = bsz; } else sz += bsz; @@ -5620,7 +5616,7 @@ static int compiled_proc_body_size(Scheme_Object *o, int less_args) static int expr_size(Scheme_Object *o) { - return compiled_proc_body_size(o, 0) + 1; + return lambda_body_size(o, 0) + 1; } int scheme_might_invoke_call_cc(Scheme_Object *value) @@ -5700,19 +5696,19 @@ static int worth_lifting(Scheme_Object *v) { Scheme_Type lhs; lhs = SCHEME_TYPE(v); - if ((lhs == scheme_compiled_unclosed_procedure_type) + if ((lhs == scheme_ir_lambda_type) || (lhs == scheme_case_lambda_sequence_type) - || (lhs == scheme_compiled_local_type) - || (lhs == scheme_compiled_toplevel_type) - || (lhs == scheme_compiled_quote_syntax_type) - || (lhs > _scheme_compiled_values_types_)) + || (lhs == scheme_ir_local_type) + || (lhs == scheme_ir_toplevel_type) + || (lhs == scheme_ir_quote_syntax_type) + || (lhs > _scheme_ir_values_types_)) return 1; return 0; } static void flip_transitive(Scheme_Hash_Table *ht, int on) { - Scheme_Compiled_Local *tvar; + Scheme_IR_Local *tvar; int j; Scheme_Object *to_remove = scheme_null; @@ -5739,7 +5735,7 @@ static void flip_transitive(Scheme_Hash_Table *ht, int on) } } -static void start_transitive_use_record(Optimize_Info *to_info, Optimize_Info *info, Scheme_Compiled_Local *var) +static void start_transitive_use_record(Optimize_Info *to_info, Optimize_Info *info, Scheme_IR_Local *var) { if (var->optimize_used) return; @@ -5754,7 +5750,7 @@ static void start_transitive_use_record(Optimize_Info *to_info, Optimize_Info *i static void end_transitive_use_record(Optimize_Info *info) { - Scheme_Compiled_Local *var = info->transitive_use_var; + Scheme_IR_Local *var = info->transitive_use_var; if (var != info->next->transitive_use_var) { info->transitive_use_var = info->next->transitive_use_var; @@ -5770,8 +5766,8 @@ scheme_optimize_lets(Scheme_Object *form, Optimize_Info *info, int for_inline, i { Optimize_Info *body_info, *rhs_info; Optimize_Info_Sequence info_seq; - Scheme_Let_Header *head = (Scheme_Let_Header *)form; - Scheme_Compiled_Let_Value *clv, *pre_body, *retry_start, *prev_body; + Scheme_IR_Let_Header *head = (Scheme_IR_Let_Header *)form; + Scheme_IR_Let_Value *irlv, *pre_body, *retry_start, *prev_body; Scheme_Object *body, *value, *ready_pairs = NULL, *rp_last = NULL, *ready_pairs_start; Scheme_Once_Used *once_used; Scheme_Hash_Tree *merge_skip_vars; @@ -5785,17 +5781,17 @@ scheme_optimize_lets(Scheme_Object *form, Optimize_Info *info, int for_inline, i /* Special case: (let ([x M]) (if x x N)), where x is not in N, to (if M #t N), since we're in a test position. */ if (!(SCHEME_LET_FLAGS(head) & SCHEME_LET_RECURSIVE) && (head->count == 1) && (head->num_clauses == 1)) { - clv = (Scheme_Compiled_Let_Value *)head->body; - if (SAME_TYPE(SCHEME_TYPE(clv->body), scheme_branch_type) - && (clv->vars[0]->use_count == 2)) { - Scheme_Branch_Rec *b = (Scheme_Branch_Rec *)clv->body; - if (SAME_OBJ(b->test, (Scheme_Object *)clv->vars[0]) - && SAME_OBJ(b->tbranch, (Scheme_Object *)clv->vars[0])) { + irlv = (Scheme_IR_Let_Value *)head->body; + if (SAME_TYPE(SCHEME_TYPE(irlv->body), scheme_branch_type) + && (irlv->vars[0]->use_count == 2)) { + Scheme_Branch_Rec *b = (Scheme_Branch_Rec *)irlv->body; + if (SAME_OBJ(b->test, (Scheme_Object *)irlv->vars[0]) + && SAME_OBJ(b->tbranch, (Scheme_Object *)irlv->vars[0])) { Scheme_Branch_Rec *b3; b3 = MALLOC_ONE_TAGGED(Scheme_Branch_Rec); b3->so.type = scheme_branch_type; - b3->test = clv->value; + b3->test = irlv->value; b3->tbranch = scheme_true; b3->fbranch = b->fbranch; @@ -5811,11 +5807,11 @@ scheme_optimize_lets(Scheme_Object *form, Optimize_Info *info, int for_inline, i a constant. (If we allowed arbitrary E here, it would affect the tailness of E.) */ if (!(SCHEME_LET_FLAGS(head) & SCHEME_LET_RECURSIVE) && (head->count == 1) && (head->num_clauses == 1)) { - clv = (Scheme_Compiled_Let_Value *)head->body; - if (SAME_OBJ((Scheme_Object *)clv->vars[0], clv->body)) { - if (worth_lifting(clv->value)) { + irlv = (Scheme_IR_Let_Value *)head->body; + if (SAME_OBJ((Scheme_Object *)irlv->vars[0], irlv->body)) { + if (worth_lifting(irlv->value)) { /* Drop the let */ - return scheme_optimize_expr(clv->value, info, context); + return scheme_optimize_expr(irlv->value, info, context); } } } @@ -5829,30 +5825,30 @@ scheme_optimize_lets(Scheme_Object *form, Optimize_Info *info, int for_inline, i /* (let ([x (let~ ([y M]) N)]) P) => (let~ ([y M]) (let ([x N]) P)) or (let ([x (begin M ... N)]) P) => (begin M ... (let ([x N]) P)) */ if (head->num_clauses == 1) { - clv = (Scheme_Compiled_Let_Value *)head->body; /* ([x ...]) */ - if (SAME_TYPE(SCHEME_TYPE(clv->value), scheme_compiled_let_void_type)) { - Scheme_Let_Header *lh = (Scheme_Let_Header *)clv->value; /* (let~ ([y ...]) ...) */ + irlv = (Scheme_IR_Let_Value *)head->body; /* ([x ...]) */ + if (SAME_TYPE(SCHEME_TYPE(irlv->value), scheme_ir_let_void_type)) { + Scheme_IR_Let_Header *lh = (Scheme_IR_Let_Header *)irlv->value; /* (let~ ([y ...]) ...) */ if (!lh->num_clauses) { - clv->value = lh->body; + irlv->value = lh->body; lh->body = (Scheme_Object *)head; } else { body = lh->body; for (i = lh->num_clauses - 1; i--; ) { - body = ((Scheme_Compiled_Let_Value *)body)->body; + body = ((Scheme_IR_Let_Value *)body)->body; } - clv->value = ((Scheme_Compiled_Let_Value *)body)->body; /* N */ - ((Scheme_Compiled_Let_Value *)body)->body = (Scheme_Object *)head; + irlv->value = ((Scheme_IR_Let_Value *)body)->body; /* N */ + ((Scheme_IR_Let_Value *)body)->body = (Scheme_Object *)head; } head = lh; form = (Scheme_Object *)head; is_rec = (SCHEME_LET_FLAGS(head) & SCHEME_LET_RECURSIVE); try_again = !is_rec; - } else if (SAME_TYPE(SCHEME_TYPE(clv->value), scheme_sequence_type)) { - Scheme_Sequence *seq = (Scheme_Sequence *)clv->value; /* (begin M ... N) */ + } else if (SAME_TYPE(SCHEME_TYPE(irlv->value), scheme_sequence_type)) { + Scheme_Sequence *seq = (Scheme_Sequence *)irlv->value; /* (begin M ... N) */ - clv->value = seq->array[seq->count - 1]; + irlv->value = seq->array[seq->count - 1]; seq->array[seq->count - 1] = (Scheme_Object *)head; return scheme_optimize_expr((Scheme_Object *)seq, info, context); @@ -5867,7 +5863,7 @@ scheme_optimize_lets(Scheme_Object *form, Optimize_Info *info, int for_inline, i merge_skip_vars = scheme_make_hash_tree(0); body = head->body; for (i = head->num_clauses; i--; ) { - pre_body = (Scheme_Compiled_Let_Value *)body; + pre_body = (Scheme_IR_Let_Value *)body; for (j = pre_body->count; j--; ) { merge_skip_vars = scheme_hash_tree_set(merge_skip_vars, (Scheme_Object *)pre_body->vars[j], scheme_true); set_optimize_mode(pre_body->vars[j]); @@ -5897,10 +5893,10 @@ scheme_optimize_lets(Scheme_Object *form, Optimize_Info *info, int for_inline, i body = head->body; pre_body = NULL; for (i = head->num_clauses; i--; ) { - pre_body = (Scheme_Compiled_Let_Value *)body; + pre_body = (Scheme_IR_Let_Value *)body; if ((pre_body->count == 1) - && IS_COMPILED_PROC(pre_body->value) + && SCHEME_LAMBDAP(pre_body->value) && !pre_body->vars[0]->mutated) { Scheme_Object *sz; sz = estimate_closure_size(pre_body->value); @@ -5923,15 +5919,15 @@ scheme_optimize_lets(Scheme_Object *form, Optimize_Info *info, int for_inline, i did_set_value = 0; found_escapes = 0; for (i = head->num_clauses; i--; ) { - pre_body = (Scheme_Compiled_Let_Value *)body; + pre_body = (Scheme_IR_Let_Value *)body; if ((pre_body->count == 1) - && IS_COMPILED_PROC(pre_body->value) + && SCHEME_LAMBDAP(pre_body->value) && !pre_body->vars[0]->optimize_used) start_transitive_use_record(body_info, rhs_info, pre_body->vars[0]); if (is_rec && OPT_DISCOURAGE_EARLY_INLINE && !rhs_info->letrec_not_twice - && IS_COMPILED_PROC(pre_body->value)) { + && SCHEME_LAMBDAP(pre_body->value)) { inline_fuel = rhs_info->inline_fuel; if (inline_fuel > 2) rhs_info->inline_fuel = 2; @@ -6035,33 +6031,33 @@ scheme_optimize_lets(Scheme_Object *form, Optimize_Info *info, int for_inline, i remove it at the end. */ remove_last_one = 1; } else { - Scheme_Compiled_Let_Value *naya; + Scheme_IR_Let_Value *naya; Scheme_Object *rest = pre_body->body; int j; for (j = pre_body->count; j--; ) { - Scheme_Compiled_Local **new_vars; - naya = MALLOC_ONE_TAGGED(Scheme_Compiled_Let_Value); - naya->iso.so.type = scheme_compiled_let_value_type; + Scheme_IR_Local **new_vars; + naya = MALLOC_ONE_TAGGED(Scheme_IR_Let_Value); + naya->iso.so.type = scheme_ir_let_value_type; naya->body = rest; naya->count = 1; - new_vars = MALLOC_N(Scheme_Compiled_Local *, 1); + new_vars = MALLOC_N(Scheme_IR_Local *, 1); new_vars[0] = pre_body->vars[j]; naya->vars = new_vars; rest = (Scheme_Object *)naya; } - naya = (Scheme_Compiled_Let_Value *)rest; + naya = (Scheme_IR_Let_Value *)rest; if (!found_escapes) { unpack_values_application(value, naya, rhs_info, NULL); } else { - Scheme_Compiled_Let_Value *naya2 = naya; + Scheme_IR_Let_Value *naya2 = naya; for (j = 0; j < pre_body->count; j++) { if (!j) naya2->value = value; else naya2->value = scheme_false; - naya2 = (Scheme_Compiled_Let_Value *)naya2->body; + naya2 = (Scheme_IR_Let_Value *)naya2->body; } } @@ -6110,14 +6106,14 @@ scheme_optimize_lets(Scheme_Object *form, Optimize_Info *info, int for_inline, i Scheme_Sequence *seq = (Scheme_Sequence *)value; value = seq->array[seq->count - 1]; indirect++; - } else if (SAME_TYPE(SCHEME_TYPE(value), scheme_compiled_let_void_type)) { - Scheme_Let_Header *head2 = (Scheme_Let_Header *)value; + } else if (SAME_TYPE(SCHEME_TYPE(value), scheme_ir_let_void_type)) { + Scheme_IR_Let_Header *head2 = (Scheme_IR_Let_Header *)value; int i; if (head2->num_clauses < 10) { value = head2->body; for (i = head2->num_clauses; i--; ) { - value = ((Scheme_Compiled_Let_Value *)value)->body; + value = ((Scheme_IR_Let_Value *)value)->body; } } indirect++; @@ -6129,11 +6125,11 @@ scheme_optimize_lets(Scheme_Object *form, Optimize_Info *info, int for_inline, i if (indirect_binding) { /* only allow constants */ - if (SCHEME_TYPE(value) < _scheme_compiled_values_types_) + if (SCHEME_TYPE(value) < _scheme_ir_values_types_) value = NULL; } - if (value && SAME_TYPE(SCHEME_TYPE(value), scheme_compiled_local_type)) { + if (value && SAME_TYPE(SCHEME_TYPE(value), scheme_ir_local_type)) { /* Don't optimize reference to a local that's mutable; also, double-check that the value is ready, because we might be nested in the RHS of a `letrec': */ @@ -6144,7 +6140,7 @@ scheme_optimize_lets(Scheme_Object *form, Optimize_Info *info, int for_inline, i if (value) value = extract_specialized_proc(value, value); - if (value && (scheme_compiled_propagate_ok(value, body_info))) { + if (value && (scheme_ir_propagate_ok(value, body_info))) { pre_body->vars[0]->optimize.known_val = value; did_set_value = 1; } else if (value && !is_rec) { @@ -6165,8 +6161,8 @@ scheme_optimize_lets(Scheme_Object *form, Optimize_Info *info, int for_inline, i } } - if (SAME_TYPE(SCHEME_TYPE(value), scheme_compiled_local_type)) { - /* shouldn't get here, since scheme_compiled_propagate_ok() + if (SAME_TYPE(SCHEME_TYPE(value), scheme_ir_local_type)) { + /* shouldn't get here, since scheme_ir_propagate_ok() should have returned true, but just in case... local is in unoptimized coordinates */ pred = NULL; @@ -6198,14 +6194,14 @@ scheme_optimize_lets(Scheme_Object *form, Optimize_Info *info, int for_inline, i if (is_rec && !body_info->letrec_not_twice && ((i < 1) - || (!scheme_is_compiled_procedure(((Scheme_Compiled_Let_Value *)pre_body->body)->value, 1, 1) - && !scheme_is_liftable(((Scheme_Compiled_Let_Value *)pre_body->body)->value, merge_skip_vars, 5, 1, 0)))) { + || (!scheme_is_ir_lambda(((Scheme_IR_Let_Value *)pre_body->body)->value, 1, 1) + && !scheme_is_liftable(((Scheme_IR_Let_Value *)pre_body->body)->value, merge_skip_vars, 5, 1, 0)))) { Scheme_Object *prop_later = NULL; if (did_set_value) { /* Next RHS ends a reorderable sequence. Re-optimize from retry_start to pre_body, inclusive. - For procedures, assume CLOS_SINGLE_RESULT and CLOS_PRESERVES_MARKS for all, + For procedures, assume LAMBDA_SINGLE_RESULT and LAMBDA_PRESERVES_MARKS for all, but then assume not for all if any turn out not (i.e., approximate fix point). */ int flags; Scheme_Object *clones, *cl, *cl_first; @@ -6216,15 +6212,15 @@ scheme_optimize_lets(Scheme_Object *form, Optimize_Info *info, int for_inline, i /* Set-flags loop: */ clones = make_clones(retry_start, pre_body, rhs_info); (void)set_code_flags(retry_start, pre_body, clones, - CLOS_SINGLE_RESULT | CLOS_PRESERVES_MARKS | CLOS_RESULT_TENTATIVE, + LAMBDA_SINGLE_RESULT | LAMBDA_PRESERVES_MARKS | LAMBDA_RESULT_TENTATIVE, 0xFFFF, 0, 0); /* Re-optimize loop: */ - clv = retry_start; + irlv = retry_start; cl = clones; while (1) { - value = clv->value; + value = irlv->value; if (cl) { cl_first = SCHEME_CAR(cl); if (!cl_first) @@ -6237,15 +6233,15 @@ scheme_optimize_lets(Scheme_Object *form, Optimize_Info *info, int for_inline, i int sz; char use_psize; - if ((clv->count == 1) - && !clv->vars[0]->optimize_used) - start_transitive_use_record(body_info, rhs_info, clv->vars[0]); + if ((irlv->count == 1) + && !irlv->vars[0]->optimize_used) + start_transitive_use_record(body_info, rhs_info, irlv->vars[0]); cl = SCHEME_CDR(cl); self_value = SCHEME_CDR(cl_first); /* Drop old size, and remove old inline fuel: */ - sz = compiled_proc_body_size(value, 0); + sz = lambda_body_size(value, 0); rhs_info->size -= (sz + 1); /* Setting letrec_not_twice prevents inlinining @@ -6259,7 +6255,7 @@ scheme_optimize_lets(Scheme_Object *form, Optimize_Info *info, int for_inline, i optimize_info_seq_step(rhs_info, &info_seq); value = scheme_optimize_expr(self_value, rhs_info, - ((clv->count == 1) + ((irlv->count == 1) ? OPT_CONTEXT_SINGLED : 0)); @@ -6267,23 +6263,23 @@ scheme_optimize_lets(Scheme_Object *form, Optimize_Info *info, int for_inline, i --rhs_info->letrec_not_twice; rhs_info->use_psize = use_psize; - clv->value = value; + irlv->value = value; - if (!clv->vars[0]->mutated) { - if (scheme_compiled_propagate_ok(value, rhs_info)) { + if (!irlv->vars[0]->mutated) { + if (scheme_ir_propagate_ok(value, rhs_info)) { /* Register re-optimized as the value for the binding, but maybe only if it didn't grow too much: */ int new_sz; if (OPT_DELAY_GROUP_PROPAGATE || OPT_LIMIT_FUNCTION_RESIZE) - new_sz = compiled_proc_body_size(value, 0); + new_sz = lambda_body_size(value, 0); else new_sz = 0; if (new_sz <= sz) { - clv->vars[0]->optimize.known_val = value; + irlv->vars[0]->optimize.known_val = value; } else if (!OPT_LIMIT_FUNCTION_RESIZE || (new_sz < 4 * sz)) - prop_later = scheme_make_raw_pair(scheme_make_pair((Scheme_Object *)clv->vars[0], + prop_later = scheme_make_raw_pair(scheme_make_pair((Scheme_Object *)irlv->vars[0], value), prop_later); } @@ -6291,27 +6287,27 @@ scheme_optimize_lets(Scheme_Object *form, Optimize_Info *info, int for_inline, i end_transitive_use_record(rhs_info); } - if (clv == pre_body) + if (irlv == pre_body) break; { /* Since letrec is really letrec*, the variables for this binding are now ready: */ int i; - for (i = clv->count; i--; ) { - if (!clv->vars[i]->mutated) { + for (i = irlv->count; i--; ) { + if (!irlv->vars[i]->mutated) { SCHEME_VAR(SCHEME_CAR(ready_pairs_start))->optimize_unready = 0; ready_pairs_start = SCHEME_CDR(ready_pairs_start); } } } - clv = (Scheme_Compiled_Let_Value *)clv->body; + irlv = (Scheme_IR_Let_Value *)irlv->body; } /* Check flags loop: */ flags = set_code_flags(retry_start, pre_body, clones, 0, 0xFFFF, 0, 0); /* Reset-flags loop: */ (void)set_code_flags(retry_start, pre_body, clones, - (flags & (CLOS_SINGLE_RESULT | CLOS_PRESERVES_MARKS)), - ~(CLOS_SINGLE_RESULT | CLOS_PRESERVES_MARKS | CLOS_RESULT_TENTATIVE), + (flags & (LAMBDA_SINGLE_RESULT | LAMBDA_PRESERVES_MARKS)), + ~(LAMBDA_SINGLE_RESULT | LAMBDA_PRESERVES_MARKS | LAMBDA_RESULT_TENTATIVE), 1, 1); } @@ -6360,7 +6356,7 @@ scheme_optimize_lets(Scheme_Object *form, Optimize_Info *info, int for_inline, i /* All `let`-bound variables are now allocated: */ body = head->body; for (i = head->num_clauses; i--; ) { - pre_body = (Scheme_Compiled_Let_Value *)body; + pre_body = (Scheme_IR_Let_Value *)body; for (j = pre_body->count; j--; ) { pre_body->vars[j]->optimize.init_kclock = body_info->kclock; } @@ -6397,7 +6393,7 @@ scheme_optimize_lets(Scheme_Object *form, Optimize_Info *info, int for_inline, i for (i = head->num_clauses; i--; ) { int used = 0, j; - pre_body = (Scheme_Compiled_Let_Value *)body; + pre_body = (Scheme_IR_Let_Value *)body; for (j = pre_body->count; j--; ) { if (pre_body->vars[j]->optimize_used) { @@ -6487,10 +6483,10 @@ scheme_optimize_lets(Scheme_Object *form, Optimize_Info *info, int for_inline, i /* Check again for (let ([x ]) x). */ if (!is_rec && (head->count == 1) && (head->num_clauses == 1)) { - clv = (Scheme_Compiled_Let_Value *)head->body; - if (SAME_OBJ(clv->body, (Scheme_Object *)clv->vars[0])) { - if (worth_lifting(clv->value)) - return clv->value; + irlv = (Scheme_IR_Let_Value *)head->body; + if (SAME_OBJ(irlv->body, (Scheme_Object *)irlv->vars[0])) { + if (worth_lifting(irlv->value)) + return irlv->value; } } @@ -6500,7 +6496,7 @@ scheme_optimize_lets(Scheme_Object *form, Optimize_Info *info, int for_inline, i body = head->body; for (i = head->num_clauses; i--; ) { - pre_body = (Scheme_Compiled_Let_Value *)body; + pre_body = (Scheme_IR_Let_Value *)body; if ((pre_body->count == 1) && !pre_body->vars[0]->optimize_used) { Scheme_Sequence *seq; @@ -6548,20 +6544,20 @@ scheme_optimize_lets(Scheme_Object *form, Optimize_Info *info, int for_inline, i /*========================================================================*/ static Scheme_Object * -optimize_closure_compilation(Scheme_Object *_data, Optimize_Info *info, int context) +optimize_lambda(Scheme_Object *_lam, Optimize_Info *info, int context) { - Scheme_Closure_Data *data; + Scheme_Lambda *lam; Scheme_Object *code, *ctx; - Closure_Info *cl; + Scheme_IR_Lambda_Info *cl; int i, init_vclock, init_aclock, init_kclock, init_sclock; Scheme_Hash_Table *ht; - data = (Scheme_Closure_Data *)_data; + lam = (Scheme_Lambda *)_lam; info->single_result = 1; info->preserves_marks = 1; - info = optimize_info_add_frame(info, data->num_params, data->num_params, + info = optimize_info_add_frame(info, lam->num_params, lam->num_params, SCHEME_LAMBDA_FRAME); ht = scheme_make_hash_table(SCHEME_hash_ptr); @@ -6578,41 +6574,41 @@ optimize_closure_compilation(Scheme_Object *_data, Optimize_Info *info, int cont /* For reporting warnings: */ if (info->context && SCHEME_PAIRP(info->context)) - ctx = scheme_make_pair((Scheme_Object *)data, + ctx = scheme_make_pair((Scheme_Object *)lam, SCHEME_CDR(info->context)); else if (info->context) - ctx = scheme_make_pair((Scheme_Object *)data, info->context); + ctx = scheme_make_pair((Scheme_Object *)lam, info->context); else - ctx = (Scheme_Object *)data; + ctx = (Scheme_Object *)lam; info->context = ctx; - cl = (Closure_Info *)data->closure_map; - for (i = 0; i < data->num_params; i++) { + cl = lam->ir_info; + for (i = 0; i < lam->num_params; i++) { set_optimize_mode(cl->vars[i]); cl->vars[i]->optimize.lambda_depth = info->lambda_depth; cl->vars[i]->optimize_used = 0; cl->vars[i]->optimize.init_kclock = info->kclock; } - code = scheme_optimize_expr(data->code, info, 0); + code = scheme_optimize_expr(lam->body, info, 0); propagate_used_variables(info); if (info->single_result) - SCHEME_CLOSURE_DATA_FLAGS(data) |= CLOS_SINGLE_RESULT; - else if (SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_SINGLE_RESULT) - SCHEME_CLOSURE_DATA_FLAGS(data) -= CLOS_SINGLE_RESULT; + SCHEME_LAMBDA_FLAGS(lam) |= LAMBDA_SINGLE_RESULT; + else if (SCHEME_LAMBDA_FLAGS(lam) & LAMBDA_SINGLE_RESULT) + SCHEME_LAMBDA_FLAGS(lam) -= LAMBDA_SINGLE_RESULT; if (info->preserves_marks) - SCHEME_CLOSURE_DATA_FLAGS(data) |= CLOS_PRESERVES_MARKS; - else if (SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_PRESERVES_MARKS) - SCHEME_CLOSURE_DATA_FLAGS(data) -= CLOS_PRESERVES_MARKS; + SCHEME_LAMBDA_FLAGS(lam) |= LAMBDA_PRESERVES_MARKS; + else if (SCHEME_LAMBDA_FLAGS(lam) & LAMBDA_PRESERVES_MARKS) + SCHEME_LAMBDA_FLAGS(lam) -= LAMBDA_PRESERVES_MARKS; if ((info->single_result > 0) && (info->preserves_marks > 0) - && (SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_RESULT_TENTATIVE)) - SCHEME_CLOSURE_DATA_FLAGS(data) -= CLOS_RESULT_TENTATIVE; + && (SCHEME_LAMBDA_FLAGS(lam) & LAMBDA_RESULT_TENTATIVE)) + SCHEME_LAMBDA_FLAGS(lam) -= LAMBDA_RESULT_TENTATIVE; - data->code = code; + lam->body = code; /* Remembers positions of used vars (and unsets usage for this level) */ cl->base_closure = info->uses; @@ -6633,20 +6629,20 @@ optimize_closure_compilation(Scheme_Object *_data, Optimize_Info *info, int cont info->size++; - data->closure_size = (cl->base_closure->count - + (cl->has_tl ? 1 : 0)); + lam->closure_size = (cl->base_closure->count + + (cl->has_tl ? 1 : 0)); optimize_info_done(info, NULL); - return (Scheme_Object *)data; + return (Scheme_Object *)lam; } -static char *get_closure_local_type_map(Scheme_Closure_Data *data, int arg_n, int *ok) +static char *get_closure_local_type_map(Scheme_Lambda *lam, int arg_n, int *ok) { - Closure_Info *cl = (Closure_Info *)data->closure_map; + Scheme_IR_Lambda_Info *cl = lam->ir_info; - if ((SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_HAS_REST) - || (arg_n != data->num_params)) { + if ((SCHEME_LAMBDA_FLAGS(lam) & LAMBDA_HAS_REST) + || (arg_n != lam->num_params)) { *ok = 0; return NULL; } @@ -6660,9 +6656,9 @@ static char *get_closure_local_type_map(Scheme_Closure_Data *data, int arg_n, in return cl->local_type_map; } -static void set_closure_local_type_map(Scheme_Closure_Data *data, char *local_type_map) +static void set_closure_local_type_map(Scheme_Lambda *lam, char *local_type_map) { - Closure_Info *cl = (Closure_Info *)data->closure_map; + Scheme_IR_Lambda_Info *cl = lam->ir_info; int i; if (!cl->local_type_map) { @@ -6671,7 +6667,7 @@ static void set_closure_local_type_map(Scheme_Closure_Data *data, char *local_ty } if (local_type_map) { - for (i = data->num_params; i--; ) { + for (i = lam->num_params; i--; ) { if (local_type_map[i]) break; } @@ -6681,10 +6677,10 @@ static void set_closure_local_type_map(Scheme_Closure_Data *data, char *local_ty } } -static void merge_closure_local_type_map(Scheme_Closure_Data *data1, Scheme_Closure_Data *data2) +static void merge_closure_local_type_map(Scheme_Lambda *lam1, Scheme_Lambda *lam2) { - Closure_Info *cl1 = (Closure_Info *)data1->closure_map; - Closure_Info *cl2 = (Closure_Info *)data2->closure_map; + Scheme_IR_Lambda_Info *cl1 = lam1->ir_info; + Scheme_IR_Lambda_Info *cl2 = lam2->ir_info; if (cl1->has_tymap) { if (!cl1->local_type_map || !cl2->has_tymap) { @@ -6692,7 +6688,7 @@ static void merge_closure_local_type_map(Scheme_Closure_Data *data1, Scheme_Clos cl2->local_type_map = cl1->local_type_map; } else if (cl2->local_type_map) { int i, recheck = 0; - for (i = data1->num_params; i--; ) { + for (i = lam1->num_params; i--; ) { if (cl1->local_type_map[i] != cl2->local_type_map[i]) { cl1->local_type_map[i] = 0; cl2->local_type_map[i] = 0; @@ -6700,7 +6696,7 @@ static void merge_closure_local_type_map(Scheme_Closure_Data *data1, Scheme_Clos } } if (recheck) { - for (i = data1->num_params; i--; ) { + for (i = lam1->num_params; i--; ) { if (cl1->local_type_map[i]) break; } if (i < 0) { @@ -6717,24 +6713,24 @@ static void merge_closure_local_type_map(Scheme_Closure_Data *data1, Scheme_Clos } } -static Scheme_Compiled_Local *clone_variable(Scheme_Compiled_Local *var) +static Scheme_IR_Local *clone_variable(Scheme_IR_Local *var) { - Scheme_Compiled_Local *var2; - MZ_ASSERT(SAME_TYPE(var->so.type, scheme_compiled_local_type)); - var2 = MALLOC_ONE_TAGGED(Scheme_Compiled_Local); - memcpy(var2, var, sizeof(Scheme_Compiled_Local)); + Scheme_IR_Local *var2; + MZ_ASSERT(SAME_TYPE(var->so.type, scheme_ir_local_type)); + var2 = MALLOC_ONE_TAGGED(Scheme_IR_Local); + memcpy(var2, var, sizeof(Scheme_IR_Local)); return var2; } -static Scheme_Compiled_Local **clone_variable_array(Scheme_Compiled_Local **vars, - int sz, - Scheme_Hash_Tree **_var_map) +static Scheme_IR_Local **clone_variable_array(Scheme_IR_Local **vars, + int sz, + Scheme_Hash_Tree **_var_map) { - Scheme_Compiled_Local **new_vars, *var; + Scheme_IR_Local **new_vars, *var; Scheme_Hash_Tree *var_map = *_var_map; int j; - new_vars = MALLOC_N(Scheme_Compiled_Local*, sz); + new_vars = MALLOC_N(Scheme_IR_Local*, sz); for (j = sz; j--; ) { var = clone_variable(vars[j]); var->mode = SCHEME_VAR_MODE_NONE; @@ -6746,35 +6742,35 @@ static Scheme_Compiled_Local **clone_variable_array(Scheme_Compiled_Local **vars return new_vars; } -static Scheme_Object *clone_closure_compilation(int single_use, Scheme_Object *_data, Optimize_Info *info, Scheme_Hash_Tree *var_map) +static Scheme_Object *clone_lambda(int single_use, Scheme_Object *_lam, Optimize_Info *info, Scheme_Hash_Tree *var_map) { - Scheme_Closure_Data *data, *data2; + Scheme_Lambda *lam, *lam2; Scheme_Object *body, *var; Scheme_Hash_Table *ht; - Closure_Info *cl; - Scheme_Compiled_Local **vars; + Scheme_IR_Lambda_Info *cl; + Scheme_IR_Local **vars; int sz; char *local_type_map; - data = (Scheme_Closure_Data *)_data; + lam = (Scheme_Lambda *)_lam; - data2 = MALLOC_ONE_TAGGED(Scheme_Closure_Data); - memcpy(data2, data, sizeof(Scheme_Closure_Data)); + lam2 = MALLOC_ONE_TAGGED(Scheme_Lambda); + memcpy(lam2, lam, sizeof(Scheme_Lambda)); - cl = MALLOC_ONE_RT(Closure_Info); - memcpy(cl, data->closure_map, sizeof(Closure_Info)); - data2->closure_map = (mzshort *)cl; + cl = MALLOC_ONE_RT(Scheme_IR_Lambda_Info); + memcpy(cl, lam->ir_info, sizeof(Scheme_IR_Lambda_Info)); + lam2->ir_info = cl; - vars = clone_variable_array(cl->vars, data2->num_params, &var_map); + vars = clone_variable_array(cl->vars, lam2->num_params, &var_map); cl->vars = vars; - body = optimize_clone(single_use, data->code, info, var_map, 0); + body = optimize_clone(single_use, lam->body, info, var_map, 0); if (!body) return NULL; - data2->code = body; + lam2->body = body; if (cl->local_type_map) { - sz = data2->num_params; + sz = lam2->num_params; local_type_map = (char *)scheme_malloc_atomic(sz); memcpy(local_type_map, cl->local_type_map, sz); cl->local_type_map = local_type_map; @@ -6796,20 +6792,20 @@ static Scheme_Object *clone_closure_compilation(int single_use, Scheme_Object *_ cl->base_closure = ht; } - return (Scheme_Object *)data2; + return (Scheme_Object *)lam2; } -static int closure_body_size(Scheme_Closure_Data *data, int check_assign, +static int closure_body_size(Scheme_Lambda *lam, int check_assign, Optimize_Info *info, int *is_leaf) { int i; - Closure_Info *cl; + Scheme_IR_Lambda_Info *cl; - cl = (Closure_Info *)data->closure_map; + cl = lam->ir_info; if (check_assign) { /* Don't try to inline if any arguments are mutated: */ - for (i = data->num_params; i--; ) { + for (i = lam->num_params; i--; ) { if (cl->vars[i]->mutated) return -1; } @@ -6821,13 +6817,9 @@ static int closure_body_size(Scheme_Closure_Data *data, int check_assign, return cl->body_size + ((info && info->use_psize) ? cl->body_psize : 0); } -static int closure_has_top_level(Scheme_Closure_Data *data) +static int closure_has_top_level(Scheme_Lambda *lam) { - Closure_Info *cl; - - cl = (Closure_Info *)data->closure_map; - - return cl->has_tl; + return lam->ir_info->has_tl; } /*========================================================================*/ @@ -6839,7 +6831,7 @@ static int set_code_closure_flags(Scheme_Object *clones, int just_tentative) { Scheme_Object *clone, *orig, *first; - int flags = CLOS_SINGLE_RESULT | CLOS_PRESERVES_MARKS; + int flags = LAMBDA_SINGLE_RESULT | LAMBDA_PRESERVES_MARKS; /* The first in a clone pair is the one that is consulted for references. The second one is the original, and its the one whose @@ -6865,15 +6857,15 @@ static int set_code_closure_flags(Scheme_Object *clones, static Scheme_Object *is_cross_module_inline_candidiate(Scheme_Object *e, Optimize_Info *info, int size_override) { - if (IS_COMPILED_PROC(e)) { - if (size_override || (compiled_proc_body_size(e, 1) < CROSS_MODULE_INLINE_SIZE)) + if (SCHEME_LAMBDAP(e)) { + if (size_override || (lambda_body_size(e, 1) < CROSS_MODULE_INLINE_SIZE)) return optimize_clone(0, e, info, empty_eq_hash_tree, 0); } return NULL; } -static int is_general_compiled_proc(Scheme_Object *e, Optimize_Info *info) +static int is_general_lambda(Scheme_Object *e, Optimize_Info *info) { /* recognize (begin * ) */ if (SCHEME_TYPE(e) == scheme_sequence_type) { @@ -6889,19 +6881,19 @@ static int is_general_compiled_proc(Scheme_Object *e, Optimize_Info *info) } /* recognize (let ([x ]) x) */ - if (SCHEME_TYPE(e) == scheme_compiled_let_void_type) { - Scheme_Let_Header *lh = (Scheme_Let_Header *)e; + if (SCHEME_TYPE(e) == scheme_ir_let_void_type) { + Scheme_IR_Let_Header *lh = (Scheme_IR_Let_Header *)e; if (!(SCHEME_LET_FLAGS(lh) & SCHEME_LET_RECURSIVE) && (lh->count == 1) && (lh->num_clauses == 1) - && SAME_TYPE(SCHEME_TYPE(lh->body), scheme_compiled_let_value_type)) { - Scheme_Compiled_Let_Value *lv = (Scheme_Compiled_Let_Value *)lh->body; - if (IS_COMPILED_PROC(lv->value)) + && SAME_TYPE(SCHEME_TYPE(lh->body), scheme_ir_let_value_type)) { + Scheme_IR_Let_Value *lv = (Scheme_IR_Let_Value *)lh->body; + if (SCHEME_LAMBDAP(lv->value)) return SAME_OBJ(lv->body, (Scheme_Object *)lv->vars[0]); } } - if (IS_COMPILED_PROC(e)) + if (SCHEME_LAMBDAP(e)) return 1; return 0; @@ -6922,19 +6914,19 @@ void install_definition(Scheme_Object *vec, int pos, Scheme_Object *var, Scheme_ int split_define_values(Scheme_Object *e, int n, Scheme_Object *vars, Scheme_Object *vec, int offset) { - if (SAME_TYPE(SCHEME_TYPE(e), scheme_compiled_let_void_type)) { + if (SAME_TYPE(SCHEME_TYPE(e), scheme_ir_let_void_type)) { /* This is a tedious case to recognize the pattern (let ([x rhs] ...) (values x ...)) which might be the result of expansion that involved a local macro to define the `x's */ - Scheme_Let_Header *lh = (Scheme_Let_Header *)e; + Scheme_IR_Let_Header *lh = (Scheme_IR_Let_Header *)e; if ((lh->count == n) && (lh->num_clauses == n) && !(SCHEME_LET_FLAGS(lh) & SCHEME_LET_RECURSIVE)) { Scheme_Object *body = lh->body; int i; for (i = 0; i < n; i++) { - if (SAME_TYPE(SCHEME_TYPE(body), scheme_compiled_let_value_type)) { - Scheme_Compiled_Let_Value *lv = (Scheme_Compiled_Let_Value *)body; + if (SAME_TYPE(SCHEME_TYPE(body), scheme_ir_let_value_type)) { + Scheme_IR_Let_Value *lv = (Scheme_IR_Let_Value *)body; if (lv->count == 1) { if (!scheme_omittable_expr(lv->value, 1, 5, 0, NULL, NULL)) return 0; @@ -6946,14 +6938,14 @@ int split_define_values(Scheme_Object *e, int n, Scheme_Object *vars, Scheme_Obj } if ((n == 2) && SAME_TYPE(SCHEME_TYPE(body), scheme_application3_type)) { Scheme_App3_Rec *app = (Scheme_App3_Rec *)body; - Scheme_Compiled_Let_Value *lv = (Scheme_Compiled_Let_Value *)lh->body; - if (SAME_OBJ(app->rator, scheme_values_func) + Scheme_IR_Let_Value *lv = (Scheme_IR_Let_Value *)lh->body; + if (SAME_OBJ(app->rator, scheme_values_proc) && SAME_OBJ(app->rand1, (Scheme_Object *)lv->vars[0]) - && SAME_OBJ(app->rand2, (Scheme_Object *)((Scheme_Compiled_Let_Value *)lv->body)->vars[0])) { + && SAME_OBJ(app->rand2, (Scheme_Object *)((Scheme_IR_Let_Value *)lv->body)->vars[0])) { if (vars) { install_definition(vec, offset, SCHEME_CAR(vars), lv->value); vars = SCHEME_CDR(vars); - lv = (Scheme_Compiled_Let_Value *)lv->body; + lv = (Scheme_IR_Let_Value *)lv->body; install_definition(vec, offset+1, SCHEME_CAR(vars), lv->value); } return 1; @@ -6961,18 +6953,18 @@ int split_define_values(Scheme_Object *e, int n, Scheme_Object *vars, Scheme_Obj } else if (SAME_TYPE(SCHEME_TYPE(body), scheme_application_type) && ((Scheme_App_Rec *)body)->num_args == n) { Scheme_App_Rec *app = (Scheme_App_Rec *)body; - Scheme_Compiled_Let_Value *lv = (Scheme_Compiled_Let_Value *)lh->body; - if (SAME_OBJ(app->args[0], scheme_values_func)) { + Scheme_IR_Let_Value *lv = (Scheme_IR_Let_Value *)lh->body; + if (SAME_OBJ(app->args[0], scheme_values_proc)) { for (i = 0; i < n; i++) { - if (!SAME_TYPE(SCHEME_TYPE(app->args[i+1]), scheme_compiled_local_type) + if (!SAME_TYPE(SCHEME_TYPE(app->args[i+1]), scheme_ir_local_type) || !SAME_OBJ((Scheme_Object *)lv->vars[0], app->args[i+1])) return 0; - lv = (Scheme_Compiled_Let_Value *)lv->body; + lv = (Scheme_IR_Let_Value *)lv->body; } if (vars) { body = lh->body; for (i = 0; i < n; i++) { - Scheme_Compiled_Let_Value *lv2 = (Scheme_Compiled_Let_Value *)body; + Scheme_IR_Let_Value *lv2 = (Scheme_IR_Let_Value *)body; install_definition(vec, offset+i, SCHEME_CAR(vars), lv2->value); vars = SCHEME_CDR(vars); body = lv2->body; @@ -6984,7 +6976,7 @@ int split_define_values(Scheme_Object *e, int n, Scheme_Object *vars, Scheme_Obj } } else if ((n == 2) && SAME_TYPE(SCHEME_TYPE(e), scheme_application3_type)) { Scheme_App3_Rec *app = (Scheme_App3_Rec *)e; - if (SAME_OBJ(app->rator, scheme_values_func) + if (SAME_OBJ(app->rator, scheme_values_proc) && scheme_omittable_expr(app->rand1, 1, 5, 0, NULL, NULL) && scheme_omittable_expr(app->rand2, 1, 5, 0, NULL, NULL)) { if (vars) { @@ -6997,7 +6989,7 @@ int split_define_values(Scheme_Object *e, int n, Scheme_Object *vars, Scheme_Obj } else if (SAME_TYPE(SCHEME_TYPE(e), scheme_application_type) && ((Scheme_App_Rec *)e)->num_args == n) { Scheme_App_Rec *app = (Scheme_App_Rec *)e; - if (SAME_OBJ(app->args[0], scheme_values_func)) { + if (SAME_OBJ(app->args[0], scheme_values_proc)) { int i; for (i = 0; i < n; i++) { if (!scheme_omittable_expr(app->args[i+1], 1, 5, 0, NULL, NULL)) @@ -7109,7 +7101,7 @@ module_optimize(Scheme_Object *data, Optimize_Info *info, int context) e = SCHEME_VEC_ELS(e)[1]; n = scheme_list_length(vars); - if ((n == 1) && IS_COMPILED_PROC(e)) { + if ((n == 1) && SCHEME_LAMBDAP(e)) { Scheme_Toplevel *tl; tl = (Scheme_Toplevel *)SCHEME_CAR(vars); @@ -7143,7 +7135,7 @@ module_optimize(Scheme_Object *data, Optimize_Info *info, int context) if (SAME_TYPE(SCHEME_TYPE(e), scheme_define_values_type)) { Scheme_Object *e2; e2 = SCHEME_VEC_ELS(e)[1]; - if (is_general_compiled_proc(e2, info)) + if (is_general_lambda(e2, info)) is_proc_def = 1; } } @@ -7184,7 +7176,7 @@ module_optimize(Scheme_Object *data, Optimize_Info *info, int context) info); if (n == 1) { - if (scheme_compiled_propagate_ok(e, info)) + if (scheme_ir_propagate_ok(e, info)) cnst = 1; else if (scheme_is_statically_proc(e, info)) { cnst = 1; @@ -7213,7 +7205,7 @@ module_optimize(Scheme_Object *data, Optimize_Info *info, int context) e2 = scheme_make_struct_proc_shape(scheme_get_struct_proc_shape(i, &stinfo)); } else if (sproc) { e2 = scheme_make_noninline_proc(e); - } else if (IS_COMPILED_PROC(e)) { + } else if (SCHEME_LAMBDAP(e)) { e2 = optimize_clone(1, e, info, empty_eq_hash_tree, 0); if (e2) { Scheme_Object *pr; @@ -7240,7 +7232,7 @@ module_optimize(Scheme_Object *data, Optimize_Info *info, int context) } scheme_hash_set(consts, scheme_make_integer(pos), e2); - if (sstruct || (SCHEME_TYPE(e2) > _scheme_compiled_values_types_)) { + if (sstruct || (SCHEME_TYPE(e2) > _scheme_ir_values_types_)) { /* No use re-optimizing */ } else { if (!re_consts) @@ -7295,11 +7287,11 @@ module_optimize(Scheme_Object *data, Optimize_Info *info, int context) if (consts) { int flags; - /* Same as in letrec: assume CLOS_SINGLE_RESULT and - CLOS_PRESERVES_MARKS for all, but then assume not for all + /* Same as in letrec: assume LAMBDA_SINGLE_RESULT and + LAMBDA_PRESERVES_MARKS for all, but then assume not for all if any turn out not (i.e., approximate fix point). */ (void)set_code_closure_flags(cl_first, - CLOS_SINGLE_RESULT | CLOS_PRESERVES_MARKS | CLOS_RESULT_TENTATIVE, + LAMBDA_SINGLE_RESULT | LAMBDA_PRESERVES_MARKS | LAMBDA_RESULT_TENTATIVE, 0xFFFF, 0); @@ -7313,7 +7305,7 @@ module_optimize(Scheme_Object *data, Optimize_Info *info, int context) if (SAME_TYPE(SCHEME_TYPE(e), scheme_define_values_type)) { Scheme_Object *sub_e; sub_e = SCHEME_VEC_ELS(e)[1]; - old_sz = compiled_proc_body_size(sub_e, 0); + old_sz = lambda_body_size(sub_e, 0); } else old_sz = 0; } else @@ -7334,17 +7326,17 @@ module_optimize(Scheme_Object *data, Optimize_Info *info, int context) e = SCHEME_VEC_ELS(e)[1]; old_e = scheme_hash_get(info->top_level_consts, rpos); - if (old_e && IS_COMPILED_PROC(old_e)) { + if (old_e && SCHEME_LAMBDAP(old_e)) { if (!originals) originals = scheme_make_hash_table(SCHEME_hash_ptr); scheme_hash_set(originals, scheme_make_integer(start_simultaneous), old_e); } - if (!scheme_compiled_propagate_ok(e, info) + if (!scheme_ir_propagate_ok(e, info) && scheme_is_statically_proc(e, info)) { /* If we previously installed a procedure for inlining, don't replace that with a worse approximation. */ - if (IS_COMPILED_PROC(old_e)) + if (SCHEME_LAMBDAP(old_e)) e = NULL; else e = scheme_make_noninline_proc(e); @@ -7352,7 +7344,7 @@ module_optimize(Scheme_Object *data, Optimize_Info *info, int context) if (e) { if (OPT_DELAY_GROUP_PROPAGATE || OPT_LIMIT_FUNCTION_RESIZE) - new_sz = compiled_proc_body_size(e, 0); + new_sz = lambda_body_size(e, 0); else new_sz = 0; @@ -7374,8 +7366,8 @@ module_optimize(Scheme_Object *data, Optimize_Info *info, int context) flags = set_code_closure_flags(cl_first, 0, 0xFFFF, 0); (void)set_code_closure_flags(cl_first, - (flags & (CLOS_SINGLE_RESULT | CLOS_PRESERVES_MARKS)), - ~(CLOS_SINGLE_RESULT | CLOS_PRESERVES_MARKS | CLOS_RESULT_TENTATIVE), + (flags & (LAMBDA_SINGLE_RESULT | LAMBDA_PRESERVES_MARKS)), + ~(LAMBDA_SINGLE_RESULT | LAMBDA_PRESERVES_MARKS | LAMBDA_RESULT_TENTATIVE), 1); } @@ -7539,7 +7531,7 @@ Scheme_Object *scheme_optimize_expr(Scheme_Object *expr, Optimize_Info *info, in info->escapes = 0; switch (type) { - case scheme_compiled_local_type: + case scheme_ir_local_type: { Scheme_Object *val; int is_mutated = 0; @@ -7601,8 +7593,8 @@ Scheme_Object *scheme_optimize_expr(Scheme_Object *expr, Optimize_Info *info, in if (val) return val; } else { - if (SAME_TYPE(SCHEME_TYPE(val), scheme_compiled_toplevel_type) - || (SCHEME_TYPE(val) > _scheme_compiled_values_types_)) { + if (SAME_TYPE(SCHEME_TYPE(val), scheme_ir_toplevel_type) + || (SCHEME_TYPE(val) > _scheme_ir_values_types_)) { info->size -= 1; return scheme_optimize_expr(val, info, context); } @@ -7631,14 +7623,14 @@ Scheme_Object *scheme_optimize_expr(Scheme_Object *expr, Optimize_Info *info, in return optimize_branch(expr, info, context); case scheme_with_cont_mark_type: return optimize_wcm(expr, info, context); - case scheme_compiled_unclosed_procedure_type: + case scheme_ir_lambda_type: if (context & OPT_CONTEXT_BOOLEAN) return scheme_true; else - return optimize_closure_compilation(expr, info, context); - case scheme_compiled_let_void_type: + return optimize_lambda(expr, info, context); + case scheme_ir_let_void_type: return scheme_optimize_lets(expr, info, 0, context); - case scheme_compiled_toplevel_type: + case scheme_ir_toplevel_type: info->size += 1; if (info->top_level_consts) { int pos; @@ -7648,7 +7640,7 @@ Scheme_Object *scheme_optimize_expr(Scheme_Object *expr, Optimize_Info *info, in pos = SCHEME_TOPLEVEL_POS(expr); c = scheme_hash_get(info->top_level_consts, scheme_make_integer(pos)); c = no_potential_size(c); - if (c && SAME_TYPE(SCHEME_TYPE(c), scheme_compiled_toplevel_type)) + if (c && SAME_TYPE(SCHEME_TYPE(c), scheme_ir_toplevel_type)) expr = c; else break; @@ -7658,7 +7650,7 @@ Scheme_Object *scheme_optimize_expr(Scheme_Object *expr, Optimize_Info *info, in if (context & OPT_CONTEXT_BOOLEAN) return (SCHEME_FALSEP(c) ? scheme_false : scheme_true); - if (scheme_compiled_duplicate_ok(c, 0)) + if (scheme_ir_duplicate_ok(c, 0)) return c; /* We can't inline, but mark the top level as a constant, @@ -7684,7 +7676,7 @@ Scheme_Object *scheme_optimize_expr(Scheme_Object *expr, Optimize_Info *info, in } optimize_info_used_top(info); return expr; - case scheme_compiled_quote_syntax_type: + case scheme_ir_quote_syntax_type: if (context & OPT_CONTEXT_BOOLEAN) return scheme_true; else { @@ -7724,7 +7716,7 @@ Scheme_Object *scheme_optimize_expr(Scheme_Object *expr, Optimize_Info *info, in default: info->size += 1; if ((context & OPT_CONTEXT_BOOLEAN) - && (SCHEME_TYPE(expr) > _scheme_compiled_values_types_) + && (SCHEME_TYPE(expr) > _scheme_ir_values_types_) && SCHEME_TRUEP(expr)) return scheme_true; else @@ -7732,7 +7724,7 @@ Scheme_Object *scheme_optimize_expr(Scheme_Object *expr, Optimize_Info *info, in } } -static void increment_use_count(Scheme_Compiled_Local *var, int as_rator) +static void increment_use_count(Scheme_IR_Local *var, int as_rator) { if (var->use_count < SCHEME_USE_COUNT_INF) var->use_count++; @@ -7753,7 +7745,7 @@ Scheme_Object *optimize_clone(int single_use, Scheme_Object *expr, Optimize_Info t = SCHEME_TYPE(expr); switch(t) { - case scheme_compiled_local_type: + case scheme_ir_local_type: { Scheme_Object *v; v = scheme_hash_tree_get(var_map, expr); @@ -7822,16 +7814,16 @@ Scheme_Object *optimize_clone(int single_use, Scheme_Object *expr, Optimize_Info return (Scheme_Object *)app2; } - case scheme_compiled_let_void_type: + case scheme_ir_let_void_type: { - Scheme_Let_Header *head = (Scheme_Let_Header *)expr, *head2; + Scheme_IR_Let_Header *head = (Scheme_IR_Let_Header *)expr, *head2; Scheme_Object *body; - Scheme_Compiled_Let_Value *lv, *lv2, *prev = NULL; - Scheme_Compiled_Local **vars; + Scheme_IR_Let_Value *lv, *lv2, *prev = NULL; + Scheme_IR_Local **vars; int i; - head2 = MALLOC_ONE_TAGGED(Scheme_Let_Header); - head2->iso.so.type = scheme_compiled_let_void_type; + head2 = MALLOC_ONE_TAGGED(Scheme_IR_Let_Header); + head2->iso.so.type = scheme_ir_let_void_type; head2->count = head->count; head2->num_clauses = head->num_clauses; SCHEME_LET_FLAGS(head2) = SCHEME_LET_FLAGS(head); @@ -7839,13 +7831,13 @@ Scheme_Object *optimize_clone(int single_use, Scheme_Object *expr, Optimize_Info /* Build let-value change: */ body = head->body; for (i = head->num_clauses; i--; ) { - lv = (Scheme_Compiled_Let_Value *)body; + lv = (Scheme_IR_Let_Value *)body; vars = clone_variable_array(lv->vars, lv->count, &var_map); - lv2 = MALLOC_ONE_TAGGED(Scheme_Compiled_Let_Value); - SCHEME_CLV_FLAGS(lv2) |= (SCHEME_CLV_FLAGS(lv) & 0x1); - lv2->iso.so.type = scheme_compiled_let_value_type; + lv2 = MALLOC_ONE_TAGGED(Scheme_IR_Let_Value); + SCHEME_IRLV_FLAGS(lv2) |= (SCHEME_IRLV_FLAGS(lv) & 0x1); + lv2->iso.so.type = scheme_ir_let_value_type; lv2->count = lv->count; lv2->vars = vars; lv2->value = lv->value; @@ -7865,7 +7857,7 @@ Scheme_Object *optimize_clone(int single_use, Scheme_Object *expr, Optimize_Info body = head2->body; for (i = head->num_clauses; i--; ) { - lv2 = (Scheme_Compiled_Let_Value *)body; + lv2 = (Scheme_IR_Let_Value *)body; expr = optimize_clone(single_use, lv2->value, info, var_map, 0); if (!expr) return NULL; @@ -7945,10 +7937,10 @@ Scheme_Object *optimize_clone(int single_use, Scheme_Object *expr, Optimize_Info return (Scheme_Object *)wcm2; } - case scheme_compiled_unclosed_procedure_type: - return clone_closure_compilation(single_use, expr, info, var_map); - case scheme_compiled_toplevel_type: - case scheme_compiled_quote_syntax_type: + case scheme_ir_lambda_type: + return clone_lambda(single_use, expr, info, var_map); + case scheme_ir_toplevel_type: + case scheme_ir_quote_syntax_type: return expr; case scheme_define_values_type: case scheme_define_syntaxes_type: @@ -7970,8 +7962,8 @@ Scheme_Object *optimize_clone(int single_use, Scheme_Object *expr, Optimize_Info case scheme_module_type: return NULL; default: - if (t > _scheme_compiled_values_types_) { - if (single_use || scheme_compiled_duplicate_ok(expr, 0)) + if (t > _scheme_ir_values_types_) { + if (single_use || scheme_ir_duplicate_ok(expr, 0)) return expr; } } @@ -8039,13 +8031,13 @@ void scheme_optimize_info_never_inline(Optimize_Info *oi) oi->inline_fuel = -1; } -static void register_transitive(Scheme_Compiled_Local *var, Optimize_Info *info); -static void register_use_at(Scheme_Compiled_Local *var, Optimize_Info *info); +static void register_transitive(Scheme_IR_Local *var, Optimize_Info *info); +static void register_use_at(Scheme_IR_Local *var, Optimize_Info *info); static Scheme_Object *transitive_k(void) { Scheme_Thread *p = scheme_current_thread; - Scheme_Compiled_Local *var = SCHEME_VAR(p->ku.k.p1); + Scheme_IR_Local *var = SCHEME_VAR(p->ku.k.p1); Optimize_Info *info = (Optimize_Info *)p->ku.k.p2; p->ku.k.p1 = NULL; @@ -8056,10 +8048,10 @@ static Scheme_Object *transitive_k(void) return scheme_false; } -static void register_transitive(Scheme_Compiled_Local *var, Optimize_Info *info) +static void register_transitive(Scheme_IR_Local *var, Optimize_Info *info) { Scheme_Hash_Table *ht; - Scheme_Compiled_Local *tvar; + Scheme_IR_Local *tvar; int j; #ifdef DO_STACK_CHECK @@ -8089,7 +8081,7 @@ static void register_transitive(Scheme_Compiled_Local *var, Optimize_Info *info) static void propagate_used_variables(Optimize_Info *info) { Scheme_Hash_Table *ht; - Scheme_Compiled_Local *tvar; + Scheme_IR_Local *tvar; int j; if (info->next->uses) { @@ -8136,7 +8128,7 @@ static void optimize_info_used_top(Optimize_Info *info) } } -static Scheme_Once_Used *make_once_used(Scheme_Object *val, Scheme_Compiled_Local *var, +static Scheme_Once_Used *make_once_used(Scheme_Object *val, Scheme_IR_Local *var, int vclock, int aclock, int kclock, int sclock, int spans_k) { Scheme_Once_Used *o; @@ -8155,30 +8147,30 @@ static Scheme_Once_Used *make_once_used(Scheme_Object *val, Scheme_Compiled_Loca return o; } -static int optimize_any_uses(Optimize_Info *info, Scheme_Compiled_Let_Value *at_clv, int n) +static int optimize_any_uses(Optimize_Info *info, Scheme_IR_Let_Value *at_irlv, int n) { int i, j; - Scheme_Compiled_Let_Value *clv = at_clv; + Scheme_IR_Let_Value *irlv = at_irlv; while (n--) { - for (i = clv->count; i--; ) { - if (clv->vars[i]->optimize_used) + for (i = irlv->count; i--; ) { + if (irlv->vars[i]->optimize_used) return 1; - for (j = at_clv->count; j--; ) { - if (at_clv->vars[j]->optimize.transitive_uses) { - if (scheme_hash_get(at_clv->vars[j]->optimize.transitive_uses, - (Scheme_Object *)clv->vars[i])) + for (j = at_irlv->count; j--; ) { + if (at_irlv->vars[j]->optimize.transitive_uses) { + if (scheme_hash_get(at_irlv->vars[j]->optimize.transitive_uses, + (Scheme_Object *)irlv->vars[i])) return 1; } } } - clv = (Scheme_Compiled_Let_Value *)clv->body; + irlv = (Scheme_IR_Let_Value *)irlv->body; } return 0; } -static void register_use_at(Scheme_Compiled_Local *var, Optimize_Info *info) +static void register_use_at(Scheme_IR_Local *var, Optimize_Info *info) { if (var->optimize.lambda_depth < info->lambda_depth) scheme_hash_set(info->uses, (Scheme_Object *)var, scheme_true); @@ -8235,13 +8227,13 @@ static Scheme_Object *optimize_info_lookup(Optimize_Info *info, Scheme_Object *v if (potential_size) *potential_size = (int)SCHEME_INT_VAL(SCHEME_BOX_VAL(n)); } else { - if (SAME_TYPE(SCHEME_TYPE(n), scheme_compiled_unclosed_procedure_type)) { + if (SAME_TYPE(SCHEME_TYPE(n), scheme_ir_lambda_type)) { if (context & OPT_CONTEXT_BOOLEAN) return scheme_true; if (closure_ok) return n; } else if (SAME_TYPE(SCHEME_TYPE(n), scheme_case_lambda_sequence_type)) { if (context & OPT_CONTEXT_BOOLEAN) return scheme_true; if (closure_ok) return n; - } else if (SAME_TYPE(SCHEME_TYPE(n), scheme_compiled_toplevel_type)) { + } else if (SAME_TYPE(SCHEME_TYPE(n), scheme_ir_toplevel_type)) { return n; } else if (closure_ok) { /* Inlining can deal with procedures and top-levels, but not other things. */ @@ -8253,7 +8245,7 @@ static Scheme_Object *optimize_info_lookup(Optimize_Info *info, Scheme_Object *v SCHEME_VAR(var)->optimize_used = 0; return n; } - } else if (SAME_TYPE(SCHEME_TYPE(n), scheme_compiled_local_type)) { + } else if (SAME_TYPE(SCHEME_TYPE(n), scheme_ir_local_type)) { Scheme_Object *v2; int cnt = SCHEME_VAR(var)->use_count; diff --git a/racket/src/racket/src/print.c b/racket/src/racket/src/print.c index 35710c4532..4f55e24fff 100644 --- a/racket/src/racket/src/print.c +++ b/racket/src/racket/src/print.c @@ -2775,7 +2775,7 @@ print(Scheme_Object *obj, int notdisplay, int compact, Scheme_Hash_Table *ht, } else { print_compact(pp, CPT_CLOSURE); print_symtab_set(pp, mt, obj); - print((Scheme_Object *)SCHEME_COMPILED_CLOS_CODE(closure), notdisplay, compact, ht, mt, pp); + print((Scheme_Object *)SCHEME_CLOSURE_CODE(closure), notdisplay, compact, ht, mt, pp); } compact = 1; done = 1; diff --git a/racket/src/racket/src/resolve.c b/racket/src/racket/src/resolve.c index bfdfbd426e..c9b1ce392e 100644 --- a/racket/src/racket/src/resolve.c +++ b/racket/src/racket/src/resolve.c @@ -58,12 +58,12 @@ struct Resolve_Info #define cons(a,b) scheme_make_pair(a,b) static Scheme_Object * -resolve_closure_compilation(Scheme_Object *_data, Resolve_Info *info, - int can_lift, int convert, int just_compute_lift, - Scheme_Object *precomputed_lift); +resolve_lambda(Scheme_Object *_lam, Resolve_Info *info, + int can_lift, int convert, int just_compute_lift, + Scheme_Object *precomputed_lift); static Resolve_Info *resolve_info_extend(Resolve_Info *info, int size, int lambda); -static void resolve_info_add_mapping(Resolve_Info *info, Scheme_Compiled_Local *var, Scheme_Object *v); -static int resolve_info_lookup(Resolve_Info *resolve, Scheme_Compiled_Local *var, Scheme_Object **lifted, +static void resolve_info_add_mapping(Resolve_Info *info, Scheme_IR_Local *var, Scheme_Object *v); +static int resolve_info_lookup(Resolve_Info *resolve, Scheme_IR_Local *var, Scheme_Object **lifted, int convert_shift, int flags); static Scheme_Object *resolve_info_lift_added(Resolve_Info *resolve, Scheme_Object *var, int convert_shift); static void resolve_info_set_toplevel_pos(Resolve_Info *info, int pos); @@ -77,7 +77,7 @@ static Scheme_Object *resolve_invent_toplevel(Resolve_Info *info); static Scheme_Object *resolve_invented_toplevel_to_defn(Resolve_Info *info, Scheme_Object *tl); static Scheme_Object *shift_lifted_reference(Scheme_Object *tl, Resolve_Info *info, int delta); static Scheme_Object *shift_toplevel(Scheme_Object *expr, int delta); -static int is_nonconstant_procedure(Scheme_Object *data, Resolve_Info *info, Scheme_Hash_Tree *exclude_vars); +static int is_nonconstant_procedure(Scheme_Object *lam, Resolve_Info *info, Scheme_Hash_Tree *exclude_vars); static int resolve_is_inside_proc(Resolve_Info *info); static int resolve_has_toplevel(Resolve_Info *info); static void set_tl_pos_used(Resolve_Info *info, int pos); @@ -105,7 +105,7 @@ static Scheme_Object *check_converted_rator(Scheme_Object *rator, Resolve_Info * { Scheme_Object *lifted; - if (!SAME_TYPE(SCHEME_TYPE(rator), scheme_compiled_local_type)) + if (!SAME_TYPE(SCHEME_TYPE(rator), scheme_ir_local_type)) return NULL; (void)resolve_info_lookup(info, SCHEME_VAR(rator), &lifted, 0, 0); @@ -408,11 +408,11 @@ static Scheme_Object *resolve_application3(Scheme_Object *o, Resolve_Info *orig_ to `eq?'. This is especially helpful for the JIT. This transformation is also performed at the optimization layer, and we keep it just in case.*/ - if ((SAME_OBJ(app->rator, scheme_equal_prim) - || SAME_OBJ(app->rator, scheme_eqv_prim)) + if ((SAME_OBJ(app->rator, scheme_equal_proc) + || SAME_OBJ(app->rator, scheme_eqv_proc)) && (scheme_eq_testable_constant(app->rand1) || scheme_eq_testable_constant(app->rand2))) { - app->rator = scheme_eq_prim; + app->rator = scheme_eq_proc; } set_app3_eval_type(app); @@ -624,7 +624,7 @@ set_resolve(Scheme_Object *data, Resolve_Info *rslv) val = scheme_resolve_expr(val, rslv); - if (SAME_TYPE(SCHEME_TYPE(var), scheme_compiled_local_type)) { + if (SAME_TYPE(SCHEME_TYPE(var), scheme_ir_local_type)) { Scheme_Let_Value *lv; Scheme_Object *cv; int li; @@ -667,7 +667,7 @@ ref_resolve(Scheme_Object *data, Resolve_Info *rslv) if (SCHEME_TRUEP(v)) SCHEME_VARREF_FLAGS(data) |= 0x1; /* => constant */ v = SCHEME_PTR2_VAL(data); - } else if (SAME_TYPE(SCHEME_TYPE(v), scheme_compiled_local_type)) { + } else if (SAME_TYPE(SCHEME_TYPE(v), scheme_ir_local_type)) { v = scheme_resolve_expr(v, rslv); if (SAME_TYPE(SCHEME_TYPE(v), scheme_local_type)) SCHEME_VARREF_FLAGS(data) |= 0x1; /* because mutable would be unbox */ @@ -696,9 +696,9 @@ apply_values_resolve(Scheme_Object *data, Resolve_Info *rslv) return data; } -static void set_resolve_mode(Scheme_Compiled_Local *var) +static void set_resolve_mode(Scheme_IR_Local *var) { - MZ_ASSERT(SAME_TYPE(var->so.type, scheme_compiled_local_type)); + MZ_ASSERT(SAME_TYPE(var->so.type, scheme_ir_local_type)); memset(&var->resolve, 0, sizeof(var->resolve)); var->mode = SCHEME_VAR_MODE_RESOLVE; } @@ -708,7 +708,7 @@ with_immed_mark_resolve(Scheme_Object *data, Resolve_Info *orig_rslv) { Scheme_With_Continuation_Mark *wcm = (Scheme_With_Continuation_Mark *)data; Scheme_Object *e; - Scheme_Compiled_Local *var; + Scheme_IR_Local *var; Resolve_Info *rslv = orig_rslv; e = scheme_resolve_expr(wcm->key, rslv); @@ -741,7 +741,7 @@ case_lambda_resolve(Scheme_Object *expr, Resolve_Info *rslv) for (i = 0; i < seq->count; i++) { Scheme_Object *le; le = seq->array[i]; - le = resolve_closure_compilation(le, rslv, 0, 0, 0, NULL); + le = resolve_lambda(le, rslv, 0, 0, 0, NULL); seq->array[i] = le; if (!SCHEME_PROCP(le)) all_closed = 0; @@ -913,7 +913,7 @@ static Scheme_Object *drop_zero_value_return(Scheme_Object *expr) if (((Scheme_Sequence *)expr)->count == 2) { if (SAME_TYPE(SCHEME_TYPE(((Scheme_Sequence *)expr)->array[1]), scheme_application_type)) { if (((Scheme_App_Rec *)((Scheme_Sequence *)expr)->array[1])->num_args == 0) { - if (SAME_OBJ(scheme_values_func, ((Scheme_App_Rec *)((Scheme_Sequence *)expr)->array[1])->args[0])) { + if (SAME_OBJ(scheme_values_proc, ((Scheme_App_Rec *)((Scheme_Sequence *)expr)->array[1])->args[0])) { return ((Scheme_Sequence *)expr)->array[0]; } } @@ -930,8 +930,8 @@ Scheme_Object * scheme_resolve_lets(Scheme_Object *form, Resolve_Info *info) { Resolve_Info *linfo; - Scheme_Let_Header *head = (Scheme_Let_Header *)form; - Scheme_Compiled_Let_Value *clv, *pre_body; + Scheme_IR_Let_Header *head = (Scheme_IR_Let_Header *)form; + Scheme_IR_Let_Value *irlv, *pre_body; Scheme_Let_Value *lv, *last = NULL; Scheme_Object *first = NULL, *body, *last_body = NULL, *last_seq = NULL; Scheme_Letrec *letrec; @@ -946,7 +946,7 @@ scheme_resolve_lets(Scheme_Object *form, Resolve_Info *info) pre_body = NULL; lift_exclude_vars = scheme_make_hash_tree(0); for (i = head->num_clauses; i--; ) { - pre_body = (Scheme_Compiled_Let_Value *)body; + pre_body = (Scheme_IR_Let_Value *)body; for (j = 0; j < pre_body->count; j++) { lift_exclude_vars = scheme_hash_tree_set(lift_exclude_vars, (Scheme_Object *)pre_body->vars[j], scheme_true); } @@ -956,27 +956,27 @@ scheme_resolve_lets(Scheme_Object *form, Resolve_Info *info) recbox = 0; if (SCHEME_LET_FLAGS(head) & SCHEME_LET_RECURSIVE) { /* Do we need to box vars in a letrec? */ - clv = (Scheme_Compiled_Let_Value *)head->body; - for (i = head->num_clauses; i--; clv = (Scheme_Compiled_Let_Value *)clv->body) { + irlv = (Scheme_IR_Let_Value *)head->body; + for (i = head->num_clauses; i--; irlv = (Scheme_IR_Let_Value *)irlv->body) { int is_proc, is_lift; - if ((clv->count == 1) - && !clv->vars[0]->optimize_used - && scheme_omittable_expr(clv->value, clv->count, -1, 0, NULL, NULL)) { + if ((irlv->count == 1) + && !irlv->vars[0]->optimize_used + && scheme_omittable_expr(irlv->value, irlv->count, -1, 0, NULL, NULL)) { /* record omittable, so we don't have to keep checking: */ - clv->vars[0]->resolve_omittable = 1; + irlv->vars[0]->resolve_omittable = 1; } else { - if (clv->count == 1) - is_proc = scheme_is_compiled_procedure(clv->value, 1, 1); + if (irlv->count == 1) + is_proc = scheme_is_ir_lambda(irlv->value, 1, 1); else is_proc = 0; if (is_proc) is_lift = 0; - else if (SCHEME_CLV_FLAGS(clv) & SCHEME_CLV_NO_GROUP_USES) + else if (SCHEME_IRLV_FLAGS(irlv) & SCHEME_IRLV_NO_GROUP_USES) is_lift = 1; else - is_lift = scheme_is_liftable(clv->value, lift_exclude_vars, 5, 1, 0); + is_lift = scheme_is_liftable(irlv->value, lift_exclude_vars, 5, 1, 0); if (!is_proc && !is_lift) { recbox = 1; @@ -986,8 +986,8 @@ scheme_resolve_lets(Scheme_Object *form, Resolve_Info *info) /* is_proc must be true ... */ int j; - for (j = 0; j < clv->count; j++) { - if (clv->vars[j]->mutated) { + for (j = 0; j < irlv->count; j++) { + if (irlv->vars[j]->mutated) { recbox = 1; break; } @@ -995,9 +995,9 @@ scheme_resolve_lets(Scheme_Object *form, Resolve_Info *info) if (recbox) break; - if (is_nonconstant_procedure(clv->value, info, lift_exclude_vars)) { + if (is_nonconstant_procedure(irlv->value, info, lift_exclude_vars)) { num_rec_procs++; - if (clv->vars[0]->non_app_count) + if (irlv->vars[0]->non_app_count) rec_proc_nonapply = 1; } } @@ -1010,11 +1010,11 @@ scheme_resolve_lets(Scheme_Object *form, Resolve_Info *info) } else { /* Sequence of single-value, non-assigned lets? */ - clv = (Scheme_Compiled_Let_Value *)head->body; - for (i = head->num_clauses; i--; clv = (Scheme_Compiled_Let_Value *)clv->body) { - if (clv->count != 1) + irlv = (Scheme_IR_Let_Value *)head->body; + for (i = head->num_clauses; i--; irlv = (Scheme_IR_Let_Value *)irlv->body) { + if (irlv->count != 1) break; - if (clv->vars[0]->mutated) + if (irlv->vars[0]->mutated) break; } @@ -1024,45 +1024,45 @@ scheme_resolve_lets(Scheme_Object *form, Resolve_Info *info) j = head->num_clauses; - clv = (Scheme_Compiled_Let_Value *)head->body; - for (i = 0; i < j; i++, clv = (Scheme_Compiled_Let_Value *)clv->body) { - if (clv->vars[0]->optimize_used) { + irlv = (Scheme_IR_Let_Value *)head->body; + for (i = 0; i < j; i++, irlv = (Scheme_IR_Let_Value *)irlv->body) { + if (irlv->vars[0]->optimize_used) { int aty, pty, involes_k_cross; - aty = clv->vars[0]->arg_type; - pty = scheme_expr_produces_local_type(clv->value, &involes_k_cross); + aty = irlv->vars[0]->arg_type; + pty = scheme_expr_produces_local_type(irlv->value, &involes_k_cross); if (pty && !involes_k_cross && ((pty == aty) || ALWAYS_PREFER_UNBOX_TYPE(pty))) - clv->vars[0]->val_type = pty; + irlv->vars[0]->val_type = pty; else - clv->vars[0]->val_type = 0; + irlv->vars[0]->val_type = 0; } } - clv = (Scheme_Compiled_Let_Value *)head->body; + irlv = (Scheme_IR_Let_Value *)head->body; linfo = info; num_frames = 0; - for (i = 0; i < head->num_clauses; i++, clv = (Scheme_Compiled_Let_Value *)clv->body) { + for (i = 0; i < head->num_clauses; i++, irlv = (Scheme_IR_Let_Value *)irlv->body) { Scheme_Object *le; - if (!clv->vars[0]->optimize_used - && scheme_omittable_expr(clv->value, clv->count, -1, 0, NULL, NULL)) { + if (!irlv->vars[0]->optimize_used + && scheme_omittable_expr(irlv->value, irlv->count, -1, 0, NULL, NULL)) { /* unused and omittable; skip */ } else { linfo = resolve_info_extend(linfo, 1, 0); num_frames++; - set_resolve_mode(clv->vars[0]); - clv->vars[0]->resolve.co_depth = linfo->current_depth; - clv->vars[0]->resolve.lex_depth = linfo->current_lex_depth; + set_resolve_mode(irlv->vars[0]); + irlv->vars[0]->resolve.co_depth = linfo->current_depth; + irlv->vars[0]->resolve.lex_depth = linfo->current_lex_depth; if (!info->no_lift - && !clv->vars[0]->non_app_count - && SAME_TYPE(SCHEME_TYPE(clv->value), scheme_compiled_unclosed_procedure_type)) - le = resolve_closure_compilation(clv->value, linfo, 1, 1, 0, NULL); + && !irlv->vars[0]->non_app_count + && SAME_TYPE(SCHEME_TYPE(irlv->value), scheme_ir_lambda_type)) + le = resolve_lambda(irlv->value, linfo, 1, 1, 0, NULL); else - le = scheme_resolve_expr(clv->value, linfo); + le = scheme_resolve_expr(irlv->value, linfo); if (is_lifted_reference(le)) { MZ_ASSERT(!info->no_lift); - clv->vars[0]->resolve.lifted = le; + irlv->vars[0]->resolve.lifted = le; /* Use of binding will be replaced by lift, so drop binding. */ linfo = linfo->next; --num_frames; @@ -1070,7 +1070,7 @@ scheme_resolve_lets(Scheme_Object *form, Resolve_Info *info) Scheme_Let_One *lo; int et; - clv->vars[0]->resolve.lifted = NULL; + irlv->vars[0]->resolve.lifted = NULL; lo = MALLOC_ONE_TAGGED(Scheme_Let_One); lo->iso.so.type = scheme_let_one_type; @@ -1078,8 +1078,8 @@ scheme_resolve_lets(Scheme_Object *form, Resolve_Info *info) lo->value = le; et = scheme_get_eval_type(lo->value); - if (HAS_UNBOXABLE_TYPE(clv->vars[0])) - et |= (clv->vars[0]->val_type << LET_ONE_TYPE_SHIFT); + if (HAS_UNBOXABLE_TYPE(irlv->vars[0])) + et |= (irlv->vars[0]->val_type << LET_ONE_TYPE_SHIFT); SCHEME_LET_EVAL_TYPE(lo) = et; if (last) @@ -1109,32 +1109,32 @@ scheme_resolve_lets(Scheme_Object *form, Resolve_Info *info) code. */ int j, any_used = 0; - clv = (Scheme_Compiled_Let_Value *)head->body; - for (i = head->num_clauses; i--; clv = (Scheme_Compiled_Let_Value *)clv->body) { - for (j = clv->count; j--; ) { - if (clv->vars[j]->optimize_used) { + irlv = (Scheme_IR_Let_Value *)head->body; + for (i = head->num_clauses; i--; irlv = (Scheme_IR_Let_Value *)irlv->body) { + for (j = irlv->count; j--; ) { + if (irlv->vars[j]->optimize_used) { any_used = 1; break; } } - if (((clv->count == 1) || !any_used) - && scheme_omittable_expr(clv->value, clv->count, -1, 0, NULL, NULL)) { - if ((clv->count == 1) && !clv->vars[0]->optimize_used) - clv->vars[0]->resolve_omittable = 1; + if (((irlv->count == 1) || !any_used) + && scheme_omittable_expr(irlv->value, irlv->count, -1, 0, NULL, NULL)) { + if ((irlv->count == 1) && !irlv->vars[0]->optimize_used) + irlv->vars[0]->resolve_omittable = 1; } else any_used = 1; } if (!any_used) { /* All unused and omittable */ - return scheme_resolve_expr((Scheme_Object *)clv, info); + return scheme_resolve_expr((Scheme_Object *)irlv, info); } } } num_skips = 0; - clv = (Scheme_Compiled_Let_Value *)head->body; - for (i = head->num_clauses; i--; clv = (Scheme_Compiled_Let_Value *)clv->body) { - if ((clv->count == 1) && clv->vars[0]->resolve_omittable) { + irlv = (Scheme_IR_Let_Value *)head->body; + for (i = head->num_clauses; i--; irlv = (Scheme_IR_Let_Value *)irlv->body) { + if ((irlv->count == 1) && irlv->vars[0]->resolve_omittable) { num_skips++; } } @@ -1165,27 +1165,27 @@ scheme_resolve_lets(Scheme_Object *form, Resolve_Info *info) letrecs to fall together in the shallowest part. Also determine and initialize lifts for recursive procedures. Generating lift information requires an iteration. */ - clv = (Scheme_Compiled_Let_Value *)head->body; + irlv = (Scheme_IR_Let_Value *)head->body; pos = ((resolve_phase < 2) ? 0 : num_rec_procs); rpos = 0; - for (i = head->num_clauses; i--; clv = (Scheme_Compiled_Let_Value *)clv->body) { + for (i = head->num_clauses; i--; irlv = (Scheme_IR_Let_Value *)irlv->body) { int j; - if ((clv->count == 1) - && !clv->vars[0]->optimize_used - && clv->vars[0]->resolve_omittable) { + if ((irlv->count == 1) + && !irlv->vars[0]->optimize_used + && irlv->vars[0]->resolve_omittable) { /* skipped */ } else { - for (j = 0; j < clv->count; j++) { + for (j = 0; j < irlv->count; j++) { Scheme_Object *lift; - set_resolve_mode(clv->vars[j]); + set_resolve_mode(irlv->vars[j]); if (recbox) - clv->vars[j]->mutated = 1; + irlv->vars[j]->mutated = 1; if (num_rec_procs - && (clv->count == 1) - && is_nonconstant_procedure(clv->value, info, lift_exclude_vars)) { + && (irlv->count == 1) + && is_nonconstant_procedure(irlv->value, info, lift_exclude_vars)) { MZ_ASSERT(!recbox); if (resolve_phase == 0) lift = scheme_resolve_generate_stub_closure(); @@ -1194,17 +1194,17 @@ scheme_resolve_lets(Scheme_Object *form, Resolve_Info *info) else lift = NULL; MZ_ASSERT(!info->no_lift || !lift); - clv->vars[0]->resolve.lifted = lift; - clv->vars[0]->resolve.co_depth = linfo->current_depth - rpos; - clv->vars[0]->resolve.lex_depth = linfo->current_lex_depth - rpos; + irlv->vars[0]->resolve.lifted = lift; + irlv->vars[0]->resolve.co_depth = linfo->current_depth - rpos; + irlv->vars[0]->resolve.lex_depth = linfo->current_lex_depth - rpos; rpos++; } else { - clv->vars[j]->resolve.lifted = NULL; - clv->vars[j]->resolve.co_depth = linfo->current_depth - pos; - clv->vars[j]->resolve.lex_depth = linfo->current_lex_depth - pos; + irlv->vars[j]->resolve.lifted = NULL; + irlv->vars[j]->resolve.co_depth = linfo->current_depth - pos; + irlv->vars[j]->resolve.lex_depth = linfo->current_lex_depth - pos; /* Since Scheme_Let_Value doesn't record type info, we have to drop any unboxing type info recorded for the variable: */ - clv->vars[j]->val_type = 0; + irlv->vars[j]->val_type = 0; pos++; } } @@ -1219,31 +1219,31 @@ scheme_resolve_lets(Scheme_Object *form, Resolve_Info *info) always by adding more conversion arguments. */ int converted; do { - clv = (Scheme_Compiled_Let_Value *)head->body; + irlv = (Scheme_IR_Let_Value *)head->body; converted = 0; - for (i = head->num_clauses; i--; clv = (Scheme_Compiled_Let_Value *)clv->body) { - if ((clv->count == 1) - && !clv->vars[0]->optimize_used - && clv->vars[0]->resolve_omittable) { + for (i = head->num_clauses; i--; irlv = (Scheme_IR_Let_Value *)irlv->body) { + if ((irlv->count == 1) + && !irlv->vars[0]->optimize_used + && irlv->vars[0]->resolve_omittable) { /* skipped */ - } else if ((clv->count == 1) - && is_nonconstant_procedure(clv->value, info, lift_exclude_vars)) { + } else if ((irlv->count == 1) + && is_nonconstant_procedure(irlv->value, info, lift_exclude_vars)) { Scheme_Object *lift, *old_lift; int old_convert_count; Scheme_Object *old_convert_map, *convert_map; - old_lift = clv->vars[0]->resolve.lifted; + old_lift = irlv->vars[0]->resolve.lifted; old_convert_count = get_convert_arg_count(old_lift); old_convert_map = get_convert_arg_map(old_lift); - lift = resolve_closure_compilation(clv->value, linfo, 1, 1, 1, - (resolve_phase ? NULL : old_lift)); + lift = resolve_lambda(irlv->value, linfo, 1, 1, 1, + (resolve_phase ? NULL : old_lift)); if (!info->no_lift && (is_closed_reference(lift) || (is_lifted_reference(lift) && resolve_phase))) { if (!SAME_OBJ(old_lift, lift)) - clv->vars[0]->resolve.lifted = lift; + irlv->vars[0]->resolve.lifted = lift; if (get_convert_arg_count(lift) != old_convert_count) converted = 1; else if (old_convert_map) { @@ -1277,27 +1277,27 @@ scheme_resolve_lets(Scheme_Object *form, Resolve_Info *info) If we succeeded with resolve_phase == 1, then we need actual lift offsets before resolving procedure bodies. Also, we need to fix up the stub closures. */ - clv = (Scheme_Compiled_Let_Value *)head->body; - for (i = head->num_clauses; i--; clv = (Scheme_Compiled_Let_Value *)clv->body) { - if ((clv->count == 1) - && !clv->vars[0]->optimize_used - && clv->vars[0]->resolve_omittable) { + irlv = (Scheme_IR_Let_Value *)head->body; + for (i = head->num_clauses; i--; irlv = (Scheme_IR_Let_Value *)irlv->body) { + if ((irlv->count == 1) + && !irlv->vars[0]->optimize_used + && irlv->vars[0]->resolve_omittable) { /* skipped */ - } else if ((clv->count == 1) && is_nonconstant_procedure(clv->value, info, lift_exclude_vars)) { + } else if ((irlv->count == 1) && is_nonconstant_procedure(irlv->value, info, lift_exclude_vars)) { Scheme_Object *lift; - lift = clv->vars[0]->resolve.lifted; + lift = irlv->vars[0]->resolve.lifted; if (is_closed_reference(lift)) { - (void)resolve_closure_compilation(clv->value, linfo, 1, 1, 0, lift); + (void)resolve_lambda(irlv->value, linfo, 1, 1, 0, lift); /* lift is the final result; this result might be referenced in the body of closures already, or in not-yet-closed functions. If no one uses the result via linfo, then the code was dead and it will get GCed. */ - clv->value = NULL; /* indicates that there's nothing more to do with the expr */ + irlv->value = NULL; /* indicates that there's nothing more to do with the expr */ } else { - lift = resolve_closure_compilation(clv->value, linfo, 1, 1, 2, NULL); + lift = resolve_lambda(irlv->value, linfo, 1, 1, 2, NULL); /* need to resolve one more time for the body of the lifted function */ - clv->vars[0]->resolve.lifted = lift; + irlv->vars[0]->resolve.lifted = lift; } } } @@ -1326,41 +1326,41 @@ scheme_resolve_lets(Scheme_Object *form, Resolve_Info *info) /* Resolve values: */ boxes = scheme_null; - clv = (Scheme_Compiled_Let_Value *)head->body; + irlv = (Scheme_IR_Let_Value *)head->body; rpos = 0; - for (i = head->num_clauses; i--; clv = (Scheme_Compiled_Let_Value *)clv->body) { - if ((clv->count == 1) - && !clv->vars[0]->optimize_used - && clv->vars[0]->resolve_omittable) { + for (i = head->num_clauses; i--; irlv = (Scheme_IR_Let_Value *)irlv->body) { + if ((irlv->count == 1) + && !irlv->vars[0]->optimize_used + && irlv->vars[0]->resolve_omittable) { /* skipped */ } else { int isproc; Scheme_Object *expr; - if (!clv->value) + if (!irlv->value) isproc = 1; - else if (clv->count == 1) - isproc = is_nonconstant_procedure(clv->value, info, lift_exclude_vars); + else if (irlv->count == 1) + isproc = is_nonconstant_procedure(irlv->value, info, lift_exclude_vars); else isproc = 0; if (num_rec_procs && isproc) { if (!lifted_recs) { - expr = resolve_closure_compilation(clv->value, linfo, 0, 0, 0, NULL); - if (!SAME_TYPE(SCHEME_TYPE(expr), scheme_unclosed_procedure_type)) { + expr = resolve_lambda(irlv->value, linfo, 0, 0, 0, NULL); + if (!SAME_TYPE(SCHEME_TYPE(expr), scheme_lambda_type)) { scheme_signal_error("internal error: unexpected empty closure"); } letrec->procs[rpos++] = expr; } else { - if (!is_closed_reference(clv->vars[0]->resolve.lifted)) { + if (!is_closed_reference(irlv->vars[0]->resolve.lifted)) { /* Side-effect is to install lifted function: */ - (void)resolve_closure_compilation(clv->value, linfo, 1, 1, 0, clv->vars[0]->resolve.lifted); + (void)resolve_lambda(irlv->value, linfo, 1, 1, 0, irlv->vars[0]->resolve.lifted); } rpos++; } } else { int j; - if (!clv->count) - expr = drop_zero_value_return(clv->value); + if (!irlv->count) + expr = drop_zero_value_return(irlv->value); else expr = NULL; @@ -1387,7 +1387,7 @@ scheme_resolve_lets(Scheme_Object *form, Resolve_Info *info) last_body = NULL; last_seq = expr; } else { - expr = scheme_resolve_expr(clv->value, linfo); + expr = scheme_resolve_expr(irlv->value, linfo); lv = MALLOC_ONE_TAGGED(Scheme_Let_Value); if (last) @@ -1404,17 +1404,17 @@ scheme_resolve_lets(Scheme_Object *form, Resolve_Info *info) lv->iso.so.type = scheme_let_value_type; lv->value = expr; - if (clv->count) { + if (irlv->count) { int li; - li = resolve_info_lookup(linfo, clv->vars[0], NULL, 0, RESOLVE_UNUSED_OK); + li = resolve_info_lookup(linfo, irlv->vars[0], NULL, 0, RESOLVE_UNUSED_OK); lv->position = li; } else lv->position = 0; - lv->count = clv->count; + lv->count = irlv->count; SCHEME_LET_VALUE_AUTOBOX(lv) = recbox; for (j = lv->count; j--; ) { - if (!recbox && clv->vars[j]->mutated) { + if (!recbox && irlv->vars[j]->mutated) { GC_CAN_IGNORE Scheme_Object *pos; pos = scheme_make_integer(lv->position + j); if (SCHEME_LET_FLAGS(head) & SCHEME_LET_RECURSIVE) { @@ -1448,7 +1448,7 @@ scheme_resolve_lets(Scheme_Object *form, Resolve_Info *info) } /* Resolve body: */ - body = scheme_resolve_expr((Scheme_Object *)clv, linfo); + body = scheme_resolve_expr((Scheme_Object *)irlv, linfo); while (SCHEME_PAIRP(boxes)) { /* See bangboxenv... */ @@ -1526,42 +1526,42 @@ scheme_resolve_lets(Scheme_Object *form, Resolve_Info *info) XFORM_NONGCING int scheme_boxmap_size(int n) { - return ((CLOS_TYPE_BITS_PER_ARG * n) + (BITS_PER_MZSHORT - 1)) / BITS_PER_MZSHORT; + return ((LAMBDA_TYPE_BITS_PER_ARG * n) + (BITS_PER_MZSHORT - 1)) / BITS_PER_MZSHORT; } void scheme_boxmap_set(mzshort *boxmap, int j, int bit, int delta) /* assumes that existing bits are cleared */ { - j *= CLOS_TYPE_BITS_PER_ARG; + j *= LAMBDA_TYPE_BITS_PER_ARG; boxmap[delta + (j / BITS_PER_MZSHORT)] |= ((mzshort)bit << (j & (BITS_PER_MZSHORT - 1))); } int scheme_boxmap_get(mzshort *boxmap, int j, int delta) { - j *= CLOS_TYPE_BITS_PER_ARG; + j *= LAMBDA_TYPE_BITS_PER_ARG; return (boxmap[delta + (j / BITS_PER_MZSHORT)] >> (j & (BITS_PER_MZSHORT - 1)) - & ((1 << CLOS_TYPE_BITS_PER_ARG) - 1)); + & ((1 << LAMBDA_TYPE_BITS_PER_ARG) - 1)); } -static int is_nonconstant_procedure(Scheme_Object *_data, Resolve_Info *info, Scheme_Hash_Tree *exclude_vars) +static int is_nonconstant_procedure(Scheme_Object *_lam, Resolve_Info *info, Scheme_Hash_Tree *exclude_vars) { - /* check whether `data' --- which is in a `letrec' --- can be converted to + /* check whether `_lam' --- which is in a `letrec' --- can be converted to a constant independent of other bindings in the `letrec' */ - Scheme_Closure_Data *data; - Closure_Info *cl; + Scheme_Lambda *lam; + Scheme_IR_Lambda_Info *cl; Scheme_Object *lifted; int i; - if (SAME_TYPE(SCHEME_TYPE(_data), scheme_compiled_unclosed_procedure_type)) { - data = (Scheme_Closure_Data *)_data; + if (SAME_TYPE(SCHEME_TYPE(_lam), scheme_ir_lambda_type)) { + lam = (Scheme_Lambda *)_lam; - cl = (Closure_Info *)data->closure_map; + cl = lam->ir_info; if (cl->has_tl) return 1; for (i = 0; i < cl->base_closure->size; i++) { if (cl->base_closure->vals[i]) { - Scheme_Compiled_Local *var = (Scheme_Compiled_Local *)cl->base_closure->keys[i]; + Scheme_IR_Local *var = (Scheme_IR_Local *)cl->base_closure->keys[i]; if (scheme_hash_tree_get(exclude_vars, (Scheme_Object *)var)) return 1; @@ -1585,24 +1585,24 @@ static int is_nonconstant_procedure(Scheme_Object *_data, Resolve_Info *info, Sc } static Scheme_Object * -resolve_closure_compilation(Scheme_Object *_data, Resolve_Info *info, - int can_lift, int convert, int just_compute_lift, - Scheme_Object *precomputed_lift) +resolve_lambda(Scheme_Object *_lam, Resolve_Info *info, + int can_lift, int convert, int just_compute_lift, + Scheme_Object *precomputed_lift) { - Scheme_Closure_Data *data; + Scheme_Lambda *lam; int i, closure_size, new_params, num_params; int need_type_map = 0; int has_tl, need_lift, using_lifted = 0; mzshort *closure_map; - Closure_Info *cl; + Scheme_IR_Lambda_Info *cl; Resolve_Info *new_info; Scheme_Object *lifted, *result, *lifteds = NULL; Scheme_Hash_Table *captured = NULL; - data = (Scheme_Closure_Data *)_data; - cl = (Closure_Info *)data->closure_map; + lam = (Scheme_Lambda *)_lam; + cl = lam->ir_info; if (!just_compute_lift) - data->iso.so.type = scheme_unclosed_procedure_type; + lam->iso.so.type = scheme_lambda_type; if (convert || can_lift) { if (!convert && !resolve_is_inside_proc(info)) @@ -1619,10 +1619,10 @@ resolve_closure_compilation(Scheme_Object *_data, Resolve_Info *info, binding, which means that we can drop the binding from the closure. */ - closure_size = data->closure_size; + closure_size = lam->closure_size; if (cl->local_type_map) { int at_least_one = 0; - for (i = data->num_params; i--; ) { + for (i = lam->num_params; i--; ) { if (cl->local_type_map[i]) { if ((cl->vars[i]->arg_type == cl->local_type_map[i]) && (!cl->vars[i]->escapes_after_k_tick @@ -1648,7 +1648,7 @@ resolve_closure_compilation(Scheme_Object *_data, Resolve_Info *info, captured = scheme_make_hash_table(SCHEME_hash_ptr); for (i = 0; i < cl->base_closure->size; i++) { if (cl->base_closure->vals[i]) { - Scheme_Compiled_Local *var = SCHEME_VAR(cl->base_closure->keys[i]); + Scheme_IR_Local *var = SCHEME_VAR(cl->base_closure->keys[i]); if ((var->mode == SCHEME_VAR_MODE_OPTIMIZE) || !var->optimize_used) { @@ -1693,7 +1693,7 @@ resolve_closure_compilation(Scheme_Object *_data, Resolve_Info *info, cnt = SCHEME_VEC_SIZE(vec); --cnt; for (j = 0; j < cnt; j++) { - Scheme_Compiled_Local *var = (Scheme_Compiled_Local *)SCHEME_VEC_ELS(vec)[j+1]; + Scheme_IR_Local *var = (Scheme_IR_Local *)SCHEME_VEC_ELS(vec)[j+1]; if (!scheme_hash_get(captured, (Scheme_Object *)var)) { /* Need to capture an extra binding: */ scheme_hash_set(captured, (Scheme_Object *)var, scheme_make_integer(captured->count)); @@ -1708,15 +1708,15 @@ resolve_closure_compilation(Scheme_Object *_data, Resolve_Info *info, /* To make compilation deterministic, sort the captured variables */ if (closure_size) { - Scheme_Compiled_Local **c; + Scheme_IR_Local **c; int j = 0; - c = MALLOC_N(Scheme_Compiled_Local*, closure_size); + c = MALLOC_N(Scheme_IR_Local*, closure_size); for (i = 0; i < captured->size; i++) { if (captured->vals[i]) { c[j++] = SCHEME_VAR(captured->keys[i]); } } - scheme_sort_resolve_compiled_local_array(c, closure_size); + scheme_sort_resolve_ir_local_array(c, closure_size); for (i = 0; i < closure_size; i++) { scheme_hash_set(captured, (Scheme_Object *)c[i], scheme_make_integer(i)); } @@ -1740,13 +1740,13 @@ resolve_closure_compilation(Scheme_Object *_data, Resolve_Info *info, /* New arguments due to closure conversion will be added before the original arguments: */ - num_params = data->num_params + new_params; + num_params = lam->num_params + new_params; if ((num_params == 1) && !new_params - && (SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_HAS_REST) + && (SCHEME_LAMBDA_FLAGS(lam) & LAMBDA_HAS_REST) && !cl->vars[0]->optimize_used) { - /* We can claim 0 params plus CLOS_HAS_REST as an optimization */ + /* We can claim 0 params plus LAMBDA_HAS_REST as an optimization */ num_params = 0; } @@ -1756,7 +1756,7 @@ resolve_closure_compilation(Scheme_Object *_data, Resolve_Info *info, info, so double-check whether a type map is needed after all. */ for (i = 0; i < captured->size; i++) { if (captured->vals[i]) { - Scheme_Compiled_Local *var = SCHEME_VAR(captured->keys[i]); + Scheme_IR_Local *var = SCHEME_VAR(captured->keys[i]); if (var->mutated) { need_type_map = 1; break; @@ -1767,11 +1767,11 @@ resolve_closure_compilation(Scheme_Object *_data, Resolve_Info *info, new_info = resolve_info_extend(info, num_params + closure_size, 1); - data->closure_size = closure_size; + lam->closure_size = closure_size; if (need_type_map) - SCHEME_CLOSURE_DATA_FLAGS(data) |= CLOS_HAS_TYPED_ARGS; + SCHEME_LAMBDA_FLAGS(lam) |= LAMBDA_HAS_TYPED_ARGS; - MZ_ASSERT(need_type_map || !(SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_HAS_TYPED_ARGS)); + MZ_ASSERT(need_type_map || !(SCHEME_LAMBDA_FLAGS(lam) & LAMBDA_HAS_TYPED_ARGS)); /* Create the closure map, if needed */ if (closure_size || need_type_map) { @@ -1786,8 +1786,8 @@ resolve_closure_compilation(Scheme_Object *_data, Resolve_Info *info, } else closure_map = NULL; - data->closure_map = closure_map; - data->num_params = num_params; + lam->closure_map = closure_map; + lam->num_params = num_params; /* Register original argument names and types */ for (i = 0; i < num_params - new_params; i++) { @@ -1803,7 +1803,7 @@ resolve_closure_compilation(Scheme_Object *_data, Resolve_Info *info, if (need_type_map) { if (cl->local_type_map && cl->local_type_map[i]) scheme_boxmap_set(closure_map, i + new_params, - cl->local_type_map[i] + CLOS_TYPE_TYPE_OFFSET, + cl->local_type_map[i] + LAMBDA_TYPE_TYPE_OFFSET, closure_size); } } @@ -1813,7 +1813,7 @@ resolve_closure_compilation(Scheme_Object *_data, Resolve_Info *info, for (i = 0; i < captured->size; i++) { if (captured->vals[i]) { int pos = SCHEME_INT_VAL(captured->vals[i]); - Scheme_Compiled_Local *var = SCHEME_VAR(captured->keys[i]); + Scheme_IR_Local *var = SCHEME_VAR(captured->keys[i]); resolve_info_add_mapping(new_info, var, scheme_make_integer(new_info->current_depth - pos @@ -1824,10 +1824,10 @@ resolve_closure_compilation(Scheme_Object *_data, Resolve_Info *info, if (need_type_map) { scheme_boxmap_set(closure_map, (pos + (convert ? 0 : num_params)), ((HAS_UNBOXABLE_TYPE(var) - ? (var->val_type + CLOS_TYPE_TYPE_OFFSET) + ? (var->val_type + LAMBDA_TYPE_TYPE_OFFSET) : 0) | (convert - ? (var->mutated ? CLOS_TYPE_BOXED : 0) + ? (var->mutated ? LAMBDA_TYPE_BOXED : 0) : 0)), closure_size); } @@ -1853,18 +1853,18 @@ resolve_closure_compilation(Scheme_Object *_data, Resolve_Info *info, /* Resolve the closure body: */ { Scheme_Object *code; - code = scheme_resolve_expr(data->code, new_info); - data->code = code; + code = scheme_resolve_expr(lam->body, new_info); + lam->body = code; } - data->max_let_depth = (new_info->max_let_depth + lam->max_let_depth = (new_info->max_let_depth + SCHEME_TAIL_COPY_THRESHOLD); - data->tl_map = new_info->tl_map; - if (!data->tl_map && has_tl) { + lam->tl_map = new_info->tl_map; + if (!lam->tl_map && has_tl) { /* Our reason to refer to the top level has apparently gone away; record that we're not using anything */ - data->tl_map = (void *)0x1; + lam->tl_map = (void *)0x1; } /* Add code to box set!ed argument variables: */ @@ -1876,9 +1876,9 @@ resolve_closure_compilation(Scheme_Object *_data, Resolve_Info *info, bcode = scheme_alloc_object(); bcode->type = scheme_boxenv_type; SCHEME_PTR1_VAL(bcode) = scheme_make_integer(j); - SCHEME_PTR2_VAL(bcode) = data->code; + SCHEME_PTR2_VAL(bcode) = lam->body; - data->code = bcode; + lam->body = bcode; } } } else { @@ -1899,15 +1899,15 @@ resolve_closure_compilation(Scheme_Object *_data, Resolve_Info *info, if (precomputed_lift) { result = SCHEME_CAR(precomputed_lift); if (!just_compute_lift) - ((Scheme_Closure *)result)->code = data; + ((Scheme_Closure *)result)->code = lam; } else { if (just_compute_lift) result = (Scheme_Object *)scheme_malloc_empty_closure(); else - result = scheme_make_closure(NULL, (Scheme_Object *)data, 0); + result = scheme_make_closure(NULL, (Scheme_Object *)lam, 0); } } else - result = (Scheme_Object *)data; + result = (Scheme_Object *)lam; if (need_lift) { if (just_compute_lift) { @@ -1940,7 +1940,7 @@ resolve_closure_compilation(Scheme_Object *_data, Resolve_Info *info, (or would be captured if there's no lift conversion). */ Scheme_Object *ca, *arity; - if ((SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_HAS_REST)) + if ((SCHEME_LAMBDA_FLAGS(lam) & LAMBDA_HAS_REST)) arity = scheme_box(scheme_make_integer(num_params - new_params - 1)); else arity = scheme_make_integer(num_params - new_params); @@ -1950,7 +1950,7 @@ resolve_closure_compilation(Scheme_Object *_data, Resolve_Info *info, for (i = 0; i < captured->size; i++) { if (captured->vals[i]) { - MZ_ASSERT(SAME_TYPE(scheme_compiled_local_type, SCHEME_TYPE(captured->keys[i]))); + MZ_ASSERT(SAME_TYPE(scheme_ir_local_type, SCHEME_TYPE(captured->keys[i]))); SCHEME_VEC_ELS(ca)[1 + SCHEME_INT_VAL(captured->vals[i])] = captured->keys[i]; } } @@ -2153,10 +2153,10 @@ Scheme_Object *scheme_resolve_expr(Scheme_Object *expr, Resolve_Info *info) #endif switch (type) { - case scheme_compiled_local_type: + case scheme_ir_local_type: { int pos; - Scheme_Compiled_Local *var = SCHEME_VAR(expr); + Scheme_IR_Local *var = SCHEME_VAR(expr); Scheme_Object *lifted; pos = resolve_info_lookup(info, var, &lifted, 0, 0); @@ -2187,13 +2187,13 @@ Scheme_Object *scheme_resolve_expr(Scheme_Object *expr, Resolve_Info *info) return resolve_branch(expr, info); case scheme_with_cont_mark_type: return resolve_wcm(expr, info); - case scheme_compiled_unclosed_procedure_type: - return resolve_closure_compilation(expr, info, !info->no_lift, 0, 0, NULL); - case scheme_compiled_let_void_type: + case scheme_ir_lambda_type: + return resolve_lambda(expr, info, !info->no_lift, 0, 0, NULL); + case scheme_ir_let_void_type: return scheme_resolve_lets(expr, info); - case scheme_compiled_toplevel_type: + case scheme_ir_toplevel_type: return resolve_toplevel(info, expr, 1); - case scheme_compiled_quote_syntax_type: + case scheme_ir_quote_syntax_type: { Scheme_Quote_Syntax *qs; int i, c, p; @@ -2272,10 +2272,10 @@ static Scheme_Object *resolve_info_lift_added(Resolve_Info *resolve, Scheme_Obje { /* If a variable added as an argument for closure conversion is mutable, we need to generate a non-unboxing reference to the variable: */ - Scheme_Compiled_Local *var; + Scheme_IR_Local *var; int pos; - if (!SAME_TYPE(SCHEME_TYPE(v), scheme_compiled_local_type)) { + if (!SAME_TYPE(SCHEME_TYPE(v), scheme_ir_local_type)) { /* must be an argument to a generated "bad arity" call */ return v; } @@ -2615,7 +2615,7 @@ static void merge_resolve(Resolve_Info *info, Resolve_Info *new_info) } } -static void resolve_info_add_mapping(Resolve_Info *info, Scheme_Compiled_Local *var, Scheme_Object *v) +static void resolve_info_add_mapping(Resolve_Info *info, Scheme_IR_Local *var, Scheme_Object *v) { Scheme_Hash_Tree *ht; @@ -2633,7 +2633,7 @@ static void resolve_info_set_toplevel_pos(Resolve_Info *info, int pos) info->toplevel_pos = pos; } -static int resolve_info_lookup(Resolve_Info *info, Scheme_Compiled_Local *var, Scheme_Object **_lifted, +static int resolve_info_lookup(Resolve_Info *info, Scheme_IR_Local *var, Scheme_Object **_lifted, int convert_shift, int flags) { Scheme_Object *v; @@ -2785,7 +2785,7 @@ typedef struct Unresolve_Info { int stack_pos; /* stack in resolved coordinates */ int depth; /* stack in unresolved coordinates */ int stack_size; - Scheme_Compiled_Local **vars; + Scheme_IR_Local **vars; Scheme_Prefix *prefix; Scheme_Hash_Table *closures; /* handle cycles */ int has_non_leaf, has_tl, body_size; @@ -2806,7 +2806,7 @@ static Scheme_Sequence *unresolve_let_value(Scheme_Let_Value *lv, Unresolve_Info static Unresolve_Info *new_unresolve_info(Scheme_Prefix *prefix) { Unresolve_Info *ui; - Scheme_Compiled_Local **vars; + Scheme_IR_Local **vars; Scheme_Hash_Table *ht; ui = MALLOC_ONE_RT(Unresolve_Info); @@ -2814,7 +2814,7 @@ static Unresolve_Info *new_unresolve_info(Scheme_Prefix *prefix) ui->stack_pos = 0; ui->stack_size = 10; - vars = MALLOC_N(Scheme_Compiled_Local *, ui->stack_size); + vars = MALLOC_N(Scheme_IR_Local *, ui->stack_size); ui->vars = vars; ui->inlining = 1; @@ -2832,13 +2832,13 @@ static Unresolve_Info *new_unresolve_info(Scheme_Prefix *prefix) static int unresolve_stack_push(Unresolve_Info *ui, int n, int make_vars) { int pos, i; - Scheme_Compiled_Local **vars, *var; + Scheme_IR_Local **vars, *var; pos = ui->stack_pos; if (pos + n > ui->stack_size) { - vars = MALLOC_N(Scheme_Compiled_Local *, ((2 * ui->stack_size) + n)); - memcpy(vars, ui->vars, sizeof(Scheme_Compiled_Local *) * pos); + vars = MALLOC_N(Scheme_IR_Local *, ((2 * ui->stack_size) + n)); + memcpy(vars, ui->vars, sizeof(Scheme_IR_Local *) * pos); ui->vars = vars; @@ -2846,12 +2846,12 @@ static int unresolve_stack_push(Unresolve_Info *ui, int n, int make_vars) } if (make_vars) { for (i = 0; i < n; i++) { - var = MALLOC_ONE_TAGGED(Scheme_Compiled_Local); - var->so.type = scheme_compiled_local_type; + var = MALLOC_ONE_TAGGED(Scheme_IR_Local); + var->so.type = scheme_ir_local_type; ui->vars[pos + i] = var; } } else - memset(ui->vars + pos, 0, sizeof(Scheme_Compiled_Local *) * n); + memset(ui->vars + pos, 0, sizeof(Scheme_IR_Local *) * n); ui->stack_pos += n; @@ -2861,15 +2861,15 @@ static int unresolve_stack_push(Unresolve_Info *ui, int n, int make_vars) return pos; } -static Scheme_Compiled_Local **unresolve_stack_extract(Unresolve_Info *ui, int pos, int n) +static Scheme_IR_Local **unresolve_stack_extract(Unresolve_Info *ui, int pos, int n) { - Scheme_Compiled_Local **vars; + Scheme_IR_Local **vars; int i; if (!n) return NULL; - vars = MALLOC_N(Scheme_Compiled_Local *, n); + vars = MALLOC_N(Scheme_IR_Local *, n); for (i = 0; i < n; i++) { vars[i] = ui->vars[ui->stack_pos - pos - 1 - i]; } @@ -2877,9 +2877,9 @@ static Scheme_Compiled_Local **unresolve_stack_extract(Unresolve_Info *ui, int p return vars; } -static Scheme_Compiled_Local **unresolve_stack_pop(Unresolve_Info *ui, int pos, int n) +static Scheme_IR_Local **unresolve_stack_pop(Unresolve_Info *ui, int pos, int n) { - Scheme_Compiled_Local **vars; + Scheme_IR_Local **vars; MZ_ASSERT(!n || (ui->stack_pos == pos + n)); @@ -2890,9 +2890,9 @@ static Scheme_Compiled_Local **unresolve_stack_pop(Unresolve_Info *ui, int pos, return vars; } -static Scheme_Compiled_Local *unresolve_lookup(Unresolve_Info *ui, int pos, int as_rator) +static Scheme_IR_Local *unresolve_lookup(Unresolve_Info *ui, int pos, int as_rator) { - Scheme_Compiled_Local *var = ui->vars[ui->stack_pos - pos - 1]; + Scheme_IR_Local *var = ui->vars[ui->stack_pos - pos - 1]; if (var->use_count < SCHEME_USE_COUNT_INF) var->use_count++; @@ -2904,49 +2904,49 @@ static Scheme_Compiled_Local *unresolve_lookup(Unresolve_Info *ui, int pos, int return var; } -static Scheme_Object *unresolve_closure_data_2(Scheme_Closure_Data *rdata, Unresolve_Info *ui) +static Scheme_Object *unresolve_lambda_2(Scheme_Lambda *rlam, Unresolve_Info *ui) { - Scheme_Closure_Data *data; + Scheme_Lambda *lam; Scheme_Object *body; - Closure_Info *cl; - int i, pos, data_pos, init_size, has_non_leaf, has_tl; - Scheme_Compiled_Local **vars; + Scheme_IR_Lambda_Info *cl; + int i, pos, lam_pos, init_size, has_non_leaf, has_tl; + Scheme_IR_Local **vars; - scheme_delay_load_closure(rdata); + scheme_delay_load_closure(rlam); - data = MALLOC_ONE_TAGGED(Scheme_Closure_Data); - data->iso.so.type = scheme_compiled_unclosed_procedure_type; + lam = MALLOC_ONE_TAGGED(Scheme_Lambda); + lam->iso.so.type = scheme_ir_lambda_type; - SCHEME_CLOSURE_DATA_FLAGS(data) = (SCHEME_CLOSURE_DATA_FLAGS(rdata) - & (CLOS_HAS_REST | CLOS_IS_METHOD)); + SCHEME_LAMBDA_FLAGS(lam) = (SCHEME_LAMBDA_FLAGS(rlam) + & (LAMBDA_HAS_REST | LAMBDA_IS_METHOD)); - data->num_params = rdata->num_params; - data->name = rdata->name; + lam->num_params = rlam->num_params; + lam->name = rlam->name; - pos = unresolve_stack_push(ui, data->num_params, 1); - vars = unresolve_stack_extract(ui, 0, data->num_params); + pos = unresolve_stack_push(ui, lam->num_params, 1); + vars = unresolve_stack_extract(ui, 0, lam->num_params); - if (SCHEME_CLOSURE_DATA_FLAGS(rdata) & CLOS_HAS_TYPED_ARGS) { - for (i = 0; i < data->num_params; i++) { + if (SCHEME_LAMBDA_FLAGS(rlam) & LAMBDA_HAS_TYPED_ARGS) { + for (i = 0; i < lam->num_params; i++) { LOG_UNRESOLVE(printf("ref_args[%d] = %d\n", ui->stack_pos - i - 1, - scheme_boxmap_get(rdata->closure_map, i, rdata->closure_size))); - if (scheme_boxmap_get(rdata->closure_map, i, rdata->closure_size) == CLOS_TYPE_BOXED) { + scheme_boxmap_get(rlam->closure_map, i, rlam->closure_size))); + if (scheme_boxmap_get(rlam->closure_map, i, rlam->closure_size) == LAMBDA_TYPE_BOXED) { vars[i]->mutated = 1; vars[i]->is_ref_arg = 1; } } } - if (rdata->closure_size) { - data_pos = unresolve_stack_push(ui, rdata->closure_size, 0); - for (i = rdata->closure_size; i--; ) { - Scheme_Compiled_Local *mp; - mp = ui->vars[pos - rdata->closure_map[i] - 1]; + if (rlam->closure_size) { + lam_pos = unresolve_stack_push(ui, rlam->closure_size, 0); + for (i = rlam->closure_size; i--; ) { + Scheme_IR_Local *mp; + mp = ui->vars[pos - rlam->closure_map[i] - 1]; ui->vars[ui->stack_pos - i - 1] = mp; } } else - data_pos = 0; + lam_pos = 0; init_size = ui->body_size; has_non_leaf = ui->has_non_leaf; @@ -2954,14 +2954,14 @@ static Scheme_Object *unresolve_closure_data_2(Scheme_Closure_Data *rdata, Unres has_tl = ui->has_tl; ui->has_tl = 0; - body = unresolve_expr_2(rdata->code, ui, 0); + body = unresolve_expr_2(rlam->body, ui, 0); if (!body) return_NULL; - data->code = body; + lam->body = body; - cl = MALLOC_ONE_RT(Closure_Info); - SET_REQUIRED_TAG(cl->type = scheme_rt_closure_info); - data->closure_map = (mzshort *)cl; + cl = MALLOC_ONE_RT(Scheme_IR_Lambda_Info); + SET_REQUIRED_TAG(cl->type = scheme_rt_ir_lambda_info); + lam->ir_info = cl; cl->body_size = (ui->body_size - init_size); @@ -2971,8 +2971,8 @@ static Scheme_Object *unresolve_closure_data_2(Scheme_Closure_Data *rdata, Unres cl->has_tl = ui->has_tl; ui->has_tl = ui->has_tl || has_tl; - if (rdata->closure_size) - (void)unresolve_stack_pop(ui, data_pos, 0); + if (rlam->closure_size) + (void)unresolve_stack_pop(ui, lam_pos, 0); (void)unresolve_stack_pop(ui, pos, 0); cl->vars = vars; @@ -2980,7 +2980,7 @@ static Scheme_Object *unresolve_closure_data_2(Scheme_Closure_Data *rdata, Unres /* We don't need to set any more fields of cl, because optimize does that. */ - return (Scheme_Object *)data; + return (Scheme_Object *)lam; } static Scheme_Object *unresolve_expr_2_k(void) @@ -3061,9 +3061,9 @@ static Scheme_Object *unresolve_define_values(Scheme_Object *e, Unresolve_Info * if (SCHEME_VEC_SIZE(e) == 2) { int pos = SCHEME_TOPLEVEL_POS(SCHEME_VEC_ELS(e)[1]); if (pos >= ui->lift_offset) { - Scheme_Closure_Data *data = (Scheme_Closure_Data *)SCHEME_VEC_ELS(e)[0]; - if (SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_HAS_TYPED_ARGS) { - scheme_hash_set(ui->ref_lifts, scheme_make_integer(pos), (Scheme_Object *)data); + Scheme_Lambda *lam = (Scheme_Lambda *)SCHEME_VEC_ELS(e)[0]; + if (SCHEME_LAMBDA_FLAGS(lam) & LAMBDA_HAS_TYPED_ARGS) { + scheme_hash_set(ui->ref_lifts, scheme_make_integer(pos), (Scheme_Object *)lam); } } } @@ -3086,39 +3086,39 @@ static Scheme_Object *unresolve_define_values(Scheme_Object *e, Unresolve_Info * return vec; } -static Scheme_Let_Header *make_let_header(int count) { - Scheme_Let_Header *lh; - lh = MALLOC_ONE_TAGGED(Scheme_Let_Header); - lh->iso.so.type = scheme_compiled_let_void_type; +static Scheme_IR_Let_Header *make_let_header(int count) { + Scheme_IR_Let_Header *lh; + lh = MALLOC_ONE_TAGGED(Scheme_IR_Let_Header); + lh->iso.so.type = scheme_ir_let_void_type; lh->count = count; lh->num_clauses = 0; return lh; } -static Scheme_Compiled_Let_Value *make_compiled_let_value(int count) { - Scheme_Compiled_Let_Value *clv; - clv = MALLOC_ONE_TAGGED(Scheme_Compiled_Let_Value); - clv->iso.so.type = scheme_compiled_let_value_type; - clv->count = count; - return clv; +static Scheme_IR_Let_Value *make_ir_let_value(int count) { + Scheme_IR_Let_Value *irlv; + irlv = MALLOC_ONE_TAGGED(Scheme_IR_Let_Value); + irlv->iso.so.type = scheme_ir_let_value_type; + irlv->count = count; + return irlv; } typedef struct Unresolve_Let_Void_State { /* All pointers so we can use scheme_malloc */ - Scheme_Let_Header *prev_head; - Scheme_Compiled_Let_Value *prev_let; + Scheme_IR_Let_Header *prev_head; + Scheme_IR_Let_Value *prev_let; Scheme_Sequence *prev_seq; } Unresolve_Let_Void_State; -/* only one of lh, clv, seq, or body should be non-NULL */ -static void attach_lv(Scheme_Let_Header *lh, - Scheme_Compiled_Let_Value *clv, +/* only one of lh, irlv, seq, or body should be non-NULL */ +static void attach_lv(Scheme_IR_Let_Header *lh, + Scheme_IR_Let_Value *irlv, Scheme_Sequence *seq, Scheme_Object *body, Unresolve_Let_Void_State *state) { Scheme_Object *o; o = lh ? (Scheme_Object *)lh : - (clv ? (Scheme_Object *)clv : + (irlv ? (Scheme_Object *)irlv : (seq ? (Scheme_Object *)seq : body)); if (state->prev_head) { @@ -3130,15 +3130,15 @@ static void attach_lv(Scheme_Let_Header *lh, } state->prev_head = lh; - state->prev_let = clv; + state->prev_let = irlv; state->prev_seq = seq; } static Scheme_Object *unresolve_let_void(Scheme_Object *e, Unresolve_Info *ui) { Scheme_Let_Void *lv = (Scheme_Let_Void *)e; int i, pos, count; - Scheme_Compiled_Local **vars; - Scheme_Let_Header *lh; + Scheme_IR_Local **vars; + Scheme_IR_Let_Header *lh; Scheme_Object *o; Unresolve_Let_Void_State *state; @@ -3154,13 +3154,13 @@ static Scheme_Object *unresolve_let_void(Scheme_Object *e, Unresolve_Info *ui) { switch (SCHEME_TYPE(o)) { case scheme_let_value_type: { Scheme_Let_Value *lval = (Scheme_Let_Value *)o; - Scheme_Compiled_Let_Value *clv; + Scheme_IR_Let_Value *irlv; Scheme_Object *val; - clv = make_compiled_let_value(lval->count); + irlv = make_ir_let_value(lval->count); lh->num_clauses++; vars = unresolve_stack_extract(ui, lval->position, lv->count); - clv->vars = vars; + irlv->vars = vars; if (SCHEME_LET_VALUE_AUTOBOX(lval)) { SCHEME_LET_FLAGS(lh) = SCHEME_LET_RECURSIVE; @@ -3168,10 +3168,10 @@ static Scheme_Object *unresolve_let_void(Scheme_Object *e, Unresolve_Info *ui) { val = unresolve_expr_2(lval->value, ui, 0); if (!val) return_NULL; - clv->value = val; + irlv->value = val; o = lval->body; - attach_lv(NULL, clv, NULL, NULL, state); + attach_lv(NULL, irlv, NULL, NULL, state); i += lval->count; break; @@ -3185,17 +3185,17 @@ static Scheme_Object *unresolve_let_void(Scheme_Object *e, Unresolve_Info *ui) { int j; SCHEME_LET_FLAGS(lh) = SCHEME_LET_RECURSIVE; for (j = 0; j < lr->count; j++) { - Scheme_Compiled_Let_Value *clv; + Scheme_IR_Let_Value *irlv; Scheme_Object *val; - Scheme_Compiled_Local **vars; - clv = make_compiled_let_value(1); + Scheme_IR_Local **vars; + irlv = make_ir_let_value(1); lh->num_clauses++; vars = unresolve_stack_extract(ui, j, 1); val = unresolve_expr_2(lr->procs[j], ui, 0); if (!val) return_NULL; - clv->value = val; - clv->vars = vars; - attach_lv(NULL, clv, NULL, NULL, state); + irlv->value = val; + irlv->vars = vars; + attach_lv(NULL, irlv, NULL, NULL, state); i++; } o = lr->body; @@ -3249,11 +3249,11 @@ static Scheme_Object *unresolve_closure(Scheme_Object *e, Unresolve_Info *ui) { c = scheme_hash_get(ui->closures, e); - if (c && SAME_TYPE(SCHEME_TYPE(c), scheme_compiled_toplevel_type)) { + if (c && SAME_TYPE(SCHEME_TYPE(c), scheme_ir_toplevel_type)) { return c; } - r = unresolve_closure_data_2(SCHEME_COMPILED_CLOS_CODE(e), ui); + r = unresolve_lambda_2(SCHEME_CLOSURE_CODE(e), ui); return r; } @@ -3397,10 +3397,10 @@ void locate_cyclic_closures(Scheme_Object *e, Unresolve_Info *ui) { } } break; - case scheme_unclosed_procedure_type: + case scheme_lambda_type: { - Scheme_Closure_Data *cd = (Scheme_Closure_Data *)e; - locate_cyclic_closures(cd->code, ui); + Scheme_Lambda *cd = (Scheme_Lambda *)e; + locate_cyclic_closures(cd->body, ui); } break; case scheme_inline_variant_type: @@ -3481,13 +3481,13 @@ Scheme_Object *unresolve_module(Scheme_Object *e, Unresolve_Info *ui) len = 0; for (i = 0; i < ui->closures->size; i++) { if (ui->closures->vals[i] && - SAME_TYPE(SCHEME_TYPE(ui->closures->vals[i]), scheme_compiled_toplevel_type)) { + SAME_TYPE(SCHEME_TYPE(ui->closures->vals[i]), scheme_ir_toplevel_type)) { Scheme_Object *d, *vars, *val; len++; d = scheme_make_vector(2, NULL); d->type = scheme_define_values_type; vars = cons(ui->closures->vals[i], scheme_null); - val = unresolve_closure_data_2(SCHEME_COMPILED_CLOS_CODE(ui->closures->keys[i]), ui); + val = unresolve_lambda_2(SCHEME_CLOSURE_CODE(ui->closures->keys[i]), ui); SCHEME_VEC_ELS(d)[0] = vars; SCHEME_VEC_ELS(d)[1] = val; d = cons(d, ui->definitions); @@ -3568,7 +3568,7 @@ Scheme_Object *unresolve_module(Scheme_Object *e, Unresolve_Info *ui) static Scheme_Sequence *unresolve_let_value(Scheme_Let_Value *lv, Unresolve_Info *ui, Scheme_Object* val, Scheme_Object *body) { Scheme_Set_Bang *sb; - Scheme_Compiled_Local *var; + Scheme_IR_Local *var; Scheme_Sequence *seq; LOG_UNRESOLVE(printf("set! position: %d (stack pos %d)\n", lv->position, ui->stack_pos)); @@ -3606,19 +3606,19 @@ static Scheme_Sequence *unresolve_let_value(Scheme_Let_Value *lv, Unresolve_Info Scheme_App_Rec *maybe_unresolve_app_refs(Scheme_App_Rec *app, Unresolve_Info *ui) { Scheme_Object *rator; - Scheme_Closure_Data *data = NULL; + Scheme_Lambda *lam = NULL; rator = app->args[0]; if (SAME_TYPE(SCHEME_TYPE(rator), scheme_closure_type) && - (SCHEME_CLOSURE_DATA_FLAGS((SCHEME_COMPILED_CLOS_CODE(rator))) & CLOS_HAS_TYPED_ARGS)) { - data = SCHEME_COMPILED_CLOS_CODE(rator); + (SCHEME_LAMBDA_FLAGS((SCHEME_CLOSURE_CODE(rator))) & LAMBDA_HAS_TYPED_ARGS)) { + lam = SCHEME_CLOSURE_CODE(rator); } if (SAME_TYPE(SCHEME_TYPE(rator), scheme_toplevel_type)) { - data = (Scheme_Closure_Data *)scheme_hash_get(ui->ref_lifts, scheme_make_integer(SCHEME_TOPLEVEL_POS(rator))); + lam = (Scheme_Lambda *)scheme_hash_get(ui->ref_lifts, scheme_make_integer(SCHEME_TOPLEVEL_POS(rator))); } - if (data) { + if (lam) { Scheme_App_Rec *new_app; Scheme_Object *new_rator; int i; @@ -3626,20 +3626,20 @@ Scheme_App_Rec *maybe_unresolve_app_refs(Scheme_App_Rec *app, Unresolve_Info *ui new_app = scheme_malloc_application(app->num_args + 1); LOG_UNRESOLVE(printf("REF app\n")); - for(i = 0; i < data->num_params; i++) { - LOG_UNRESOLVE(printf("%d: %d\n", i, scheme_boxmap_get(data->closure_map, i, data->closure_size))); + for(i = 0; i < lam->num_params; i++) { + LOG_UNRESOLVE(printf("%d: %d\n", i, scheme_boxmap_get(lam->closure_map, i, lam->closure_size))); LOG_UNRESOLVE(printf("ui->stack_pos = %d, argpos = %d, i = %d\n", ui->stack_pos, SCHEME_LOCAL_POS(app->args[i + 1]), i)); - if ((scheme_boxmap_get(data->closure_map, i, data->closure_size) == CLOS_TYPE_BOXED) && + if ((scheme_boxmap_get(lam->closure_map, i, lam->closure_size) == LAMBDA_TYPE_BOXED) && SAME_TYPE(SCHEME_TYPE(app->args[i + 1]), scheme_local_type) && !ui->vars[ui->stack_pos - SCHEME_LOCAL_POS(app->args[i + 1]) - 1]->is_ref_arg) { Scheme_Case_Lambda *cl; - Scheme_Closure_Data *d0, *d1; + Scheme_Lambda *d0, *d1; Scheme_Set_Bang *sb; Scheme_Object *s; - Scheme_Compiled_Local *arg; + Scheme_IR_Local *arg; int pos; - Scheme_Compiled_Local **vars; - Closure_Info *ci; + Scheme_IR_Local **vars; + Scheme_IR_Lambda_Info *ci; LOG_UNRESOLVE(printf("This will be a case-lambda: %d\n", i)); @@ -3655,13 +3655,13 @@ Scheme_App_Rec *maybe_unresolve_app_refs(Scheme_App_Rec *app, Unresolve_Info *ui arg = unresolve_lookup(ui, SCHEME_LOCAL_POS(app->args[i + 1]), 0); arg->mutated = 1; - d0 = MALLOC_ONE_TAGGED(Scheme_Closure_Data); - d0->iso.so.type = scheme_compiled_unclosed_procedure_type; + d0 = MALLOC_ONE_TAGGED(Scheme_Lambda); + d0->iso.so.type = scheme_ir_lambda_type; d0->num_params = 0; - d0->code = (Scheme_Object *)arg; - ci = MALLOC_ONE_RT(Closure_Info); - SET_REQUIRED_TAG(ci->type = scheme_rt_closure_info); - d0->closure_map = (mzshort *)ci; + d0->body = (Scheme_Object *)arg; + ci = MALLOC_ONE_RT(Scheme_IR_Lambda_Info); + SET_REQUIRED_TAG(ci->type = scheme_rt_ir_lambda_info); + d0->ir_info = ci; s = scheme_make_symbol("d0"); s = scheme_gensym(s); d0->name = s; @@ -3670,21 +3670,21 @@ Scheme_App_Rec *maybe_unresolve_app_refs(Scheme_App_Rec *app, Unresolve_Info *ui pos = unresolve_stack_push(ui, 1, 1); vars = unresolve_stack_pop(ui, pos, 1); - d1 = MALLOC_ONE_TAGGED(Scheme_Closure_Data); - d1->iso.so.type = scheme_compiled_unclosed_procedure_type; + d1 = MALLOC_ONE_TAGGED(Scheme_Lambda); + d1->iso.so.type = scheme_ir_lambda_type; d1->num_params = 1; sb = MALLOC_ONE_TAGGED(Scheme_Set_Bang); sb->so.type = scheme_set_bang_type; sb->var = (Scheme_Object *)arg; sb->val = (Scheme_Object *)vars[0]; - d1->code = (Scheme_Object *)sb; - ci = MALLOC_ONE_RT(Closure_Info); - SET_REQUIRED_TAG(ci->type = scheme_rt_closure_info); + d1->body = (Scheme_Object *)sb; + ci = MALLOC_ONE_RT(Scheme_IR_Lambda_Info); + SET_REQUIRED_TAG(ci->type = scheme_rt_ir_lambda_info); ci->vars = vars; vars[0]->use_count = 1; vars[0]->non_app_count = 1; - d1->closure_map = (mzshort *)ci; + d1->ir_info = ci; s = scheme_make_symbol("d1"); @@ -3732,7 +3732,7 @@ static Scheme_Object *unresolve_expr_2(Scheme_Object *e, Unresolve_Info *ui, int return (Scheme_Object *)unresolve_lookup(ui, SCHEME_LOCAL_POS(e), as_rator); case scheme_local_unbox_type: { - Scheme_Compiled_Local *var; + Scheme_IR_Local *var; var = unresolve_lookup(ui, SCHEME_LOCAL_POS(e), as_rator); if (var->is_ref_arg) { Scheme_App_Rec *app; @@ -3888,7 +3888,7 @@ static Scheme_Object *unresolve_expr_2(Scheme_Object *e, Unresolve_Info *ui, int { Scheme_With_Continuation_Mark *wcm = (Scheme_With_Continuation_Mark *)e, *wcm2; Scheme_Object *k, *v, *b; - Scheme_Compiled_Local **vars; + Scheme_IR_Local **vars; int pos; k = unresolve_expr_2(wcm->key, ui, 0); @@ -3919,9 +3919,9 @@ static Scheme_Object *unresolve_expr_2(Scheme_Object *e, Unresolve_Info *ui, int { Scheme_Let_One *lo = (Scheme_Let_One *)e; Scheme_Object *rhs, *body; - Scheme_Let_Header *lh; - Scheme_Compiled_Let_Value *clv; - Scheme_Compiled_Local **vars; + Scheme_IR_Let_Header *lh; + Scheme_IR_Let_Value *irlv; + Scheme_IR_Local **vars; int pos; pos = unresolve_stack_push(ui, 1, 1); @@ -3933,19 +3933,19 @@ static Scheme_Object *unresolve_expr_2(Scheme_Object *e, Unresolve_Info *ui, int vars = unresolve_stack_pop(ui, pos, 1); - lh = MALLOC_ONE_TAGGED(Scheme_Let_Header); - lh->iso.so.type = scheme_compiled_let_void_type; + lh = MALLOC_ONE_TAGGED(Scheme_IR_Let_Header); + lh->iso.so.type = scheme_ir_let_void_type; lh->count = 1; lh->num_clauses = 1; - clv = MALLOC_ONE_TAGGED(Scheme_Compiled_Let_Value); - clv->iso.so.type = scheme_compiled_let_value_type; - clv->count = 1; - clv->value = rhs; - clv->vars = vars; - clv->body = body; + irlv = MALLOC_ONE_TAGGED(Scheme_IR_Let_Value); + irlv->iso.so.type = scheme_ir_let_value_type; + irlv->count = 1; + irlv->value = rhs; + irlv->vars = vars; + irlv->body = body; - lh->body = (Scheme_Object *)clv; + lh->body = (Scheme_Object *)irlv; return (Scheme_Object *)lh; } @@ -3953,9 +3953,9 @@ static Scheme_Object *unresolve_expr_2(Scheme_Object *e, Unresolve_Info *ui, int { return unresolve_closure(e, ui); } - case scheme_unclosed_procedure_type: + case scheme_lambda_type: { - return unresolve_closure_data_2((Scheme_Closure_Data *)e, ui); + return unresolve_lambda_2((Scheme_Lambda *)e, ui); } case scheme_inline_variant_type: { @@ -3979,7 +3979,7 @@ static Scheme_Object *unresolve_expr_2(Scheme_Object *e, Unresolve_Info *ui, int Scheme_Object *var, *val; var = unresolve_expr_2(sb->var, ui, 0); if (!var) return_NULL; - if (SAME_TYPE(SCHEME_TYPE(var), scheme_compiled_toplevel_type)) { + if (SAME_TYPE(SCHEME_TYPE(var), scheme_ir_toplevel_type)) { SCHEME_TOPLEVEL_FLAGS(var) |= SCHEME_TOPLEVEL_MUTATED; } val = unresolve_expr_2(sb->val, ui, 0); @@ -4001,7 +4001,7 @@ static Scheme_Object *unresolve_expr_2(Scheme_Object *e, Unresolve_Info *ui, int if (!a) return_NULL; LOG_UNRESOLVE(printf("unresolve_varref: (a) %d %d\n", e->type, a->type)); - if (SAME_TYPE(SCHEME_TYPE(a), scheme_compiled_toplevel_type)) { + if (SAME_TYPE(SCHEME_TYPE(a), scheme_ir_toplevel_type)) { SCHEME_TOPLEVEL_FLAGS(a) |= SCHEME_TOPLEVEL_MUTATED; } @@ -4044,14 +4044,14 @@ static Scheme_Object *unresolve_expr_2(Scheme_Object *e, Unresolve_Info *ui, int for (i = 0; i < cnt; i++) { Scheme_Object *le; - Scheme_Closure_Data *data; + Scheme_Lambda *lam; if (SAME_TYPE(SCHEME_TYPE(cl->array[i]), scheme_closure_type)) { - data = ((Scheme_Closure *)cl->array[i])->code; + lam = ((Scheme_Closure *)cl->array[i])->code; } else { - data = (Scheme_Closure_Data *)cl->array[i]; + lam = (Scheme_Lambda *)cl->array[i]; } - le = unresolve_closure_data_2(data, ui); + le = unresolve_lambda_2(lam, ui); if (!le) return_NULL; cl2->array[i] = le; @@ -4077,13 +4077,13 @@ static Scheme_Object *unresolve_expr_2(Scheme_Object *e, Unresolve_Info *ui, int Scheme_Local *cqs; cqs = (Scheme_Local *)scheme_malloc_atomic_tagged(sizeof(Scheme_Local)); - cqs->iso.so.type = scheme_compiled_quote_syntax_type; + cqs->iso.so.type = scheme_ir_quote_syntax_type; cqs->position = qs->position; return (Scheme_Object *)cqs; } default: if (SCHEME_TYPE(e) > _scheme_values_types_) { - if (scheme_compiled_duplicate_ok(e, 1) || !(ui->inlining)) + if (scheme_ir_duplicate_ok(e, 1) || !(ui->inlining)) return e; } @@ -4107,70 +4107,70 @@ Scheme_Object *scheme_unresolve_top(Scheme_Object* o, Comp_Prefix **cp) { return code; } -Scheme_Object *unresolve_closure_data(Scheme_Closure_Data *rdata, Unresolve_Info *ui) +Scheme_Object *unresolve_lambda(Scheme_Lambda *rlam, Unresolve_Info *ui) { - Scheme_Closure_Data *data; + Scheme_Lambda *lam; Scheme_Object *body; - Closure_Info *cl; - int i, pos, data_pos, init_size, has_non_leaf; - Scheme_Compiled_Local **vars; + Scheme_IR_Lambda_Info *cl; + int i, pos, lam_pos, init_size, has_non_leaf; + Scheme_IR_Local **vars; - scheme_delay_load_closure(rdata); + scheme_delay_load_closure(rlam); - if (rdata->closure_size) { - for (i = rdata->closure_size; i--; ) { - if (rdata->closure_map[i] > ui->stack_pos) + if (rlam->closure_size) { + for (i = rlam->closure_size; i--; ) { + if (rlam->closure_map[i] > ui->stack_pos) return_NULL; /* needs something (perhaps prefix) beyond known stack */ } } - data = MALLOC_ONE_TAGGED(Scheme_Closure_Data); - data->iso.so.type = scheme_compiled_unclosed_procedure_type; + lam = MALLOC_ONE_TAGGED(Scheme_Lambda); + lam->iso.so.type = scheme_ir_lambda_type; - SCHEME_CLOSURE_DATA_FLAGS(data) = (SCHEME_CLOSURE_DATA_FLAGS(rdata) - & (CLOS_HAS_REST | CLOS_IS_METHOD)); + SCHEME_LAMBDA_FLAGS(lam) = (SCHEME_LAMBDA_FLAGS(rlam) + & (LAMBDA_HAS_REST | LAMBDA_IS_METHOD)); - data->num_params = rdata->num_params; - data->name = rdata->name; + lam->num_params = rlam->num_params; + lam->name = rlam->name; - pos = unresolve_stack_push(ui, data->num_params, 1); + pos = unresolve_stack_push(ui, lam->num_params, 1); - if (rdata->closure_size) { - data_pos = unresolve_stack_push(ui, rdata->closure_size, 0); + if (rlam->closure_size) { + lam_pos = unresolve_stack_push(ui, rlam->closure_size, 0); /* remap closure slots: */ - for (i = rdata->closure_size; i--; ) { - Scheme_Compiled_Local *mp; - mp = ui->vars[pos - rdata->closure_map[i] - 1]; + for (i = rlam->closure_size; i--; ) { + Scheme_IR_Local *mp; + mp = ui->vars[pos - rlam->closure_map[i] - 1]; ui->vars[ui->stack_pos - i - 1] = mp; } } else - data_pos = 0; + lam_pos = 0; init_size = ui->body_size; has_non_leaf = ui->has_non_leaf; ui->has_non_leaf = 0; - body = unresolve_expr(rdata->code, ui, 0); + body = unresolve_expr(rlam->body, ui, 0); if (!body) return_NULL; - data->code = body; + lam->body = body; - cl = MALLOC_ONE_RT(Closure_Info); - SET_REQUIRED_TAG(cl->type = scheme_rt_closure_info); - data->closure_map = (mzshort *)cl; + cl = MALLOC_ONE_RT(Scheme_IR_Lambda_Info); + SET_REQUIRED_TAG(cl->type = scheme_rt_ir_lambda_info); + lam->ir_info = cl; cl->body_size = (ui->body_size - init_size); cl->has_nonleaf = ui->has_non_leaf; ui->has_non_leaf = has_non_leaf; - if (rdata->closure_size) - (void)unresolve_stack_pop(ui, data_pos, 0); + if (rlam->closure_size) + (void)unresolve_stack_pop(ui, lam_pos, 0); - vars = unresolve_stack_pop(ui, pos, data->num_params); + vars = unresolve_stack_pop(ui, pos, lam->num_params); cl->vars = vars; - return (Scheme_Object *)data; + return (Scheme_Object *)lam; } static Scheme_Object *unresolve_expr_k(void) @@ -4188,14 +4188,14 @@ static Scheme_Object *unresolve_expr_k(void) Scheme_Object *scheme_unresolve(Scheme_Object *iv, int argc, int *_has_cases) { Scheme_Object *o; - Scheme_Closure_Data *data = NULL; + Scheme_Lambda *lam = NULL; o = SCHEME_VEC_ELS(iv)[1]; if (SAME_TYPE(SCHEME_TYPE(o), scheme_closure_type)) - data = ((Scheme_Closure *)o)->code; - else if (SAME_TYPE(SCHEME_TYPE(o), scheme_unclosed_procedure_type)) - data = (Scheme_Closure_Data *)o; + lam = ((Scheme_Closure *)o)->code; + else if (SAME_TYPE(SCHEME_TYPE(o), scheme_lambda_type)) + lam = (Scheme_Lambda *)o; else if (SAME_TYPE(SCHEME_TYPE(o), scheme_case_lambda_sequence_type) || SAME_TYPE(SCHEME_TYPE(o), scheme_case_closure_type)) { Scheme_Case_Lambda *seqin = (Scheme_Case_Lambda *)o; @@ -4205,30 +4205,30 @@ Scheme_Object *scheme_unresolve(Scheme_Object *iv, int argc, int *_has_cases) for (i = 0; i < cnt; i++) { if (SAME_TYPE(SCHEME_TYPE(seqin->array[i]), scheme_closure_type)) { /* An empty closure, created at compile time */ - data = ((Scheme_Closure *)seqin->array[i])->code; + lam = ((Scheme_Closure *)seqin->array[i])->code; } else { - data = (Scheme_Closure_Data *)seqin->array[i]; + lam = (Scheme_Lambda *)seqin->array[i]; } - if ((!(SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_HAS_REST) - && (data->num_params == argc)) - || ((SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_HAS_REST) - && (data->num_params - 1 <= argc))) + if ((!(SCHEME_LAMBDA_FLAGS(lam) & LAMBDA_HAS_REST) + && (lam->num_params == argc)) + || ((SCHEME_LAMBDA_FLAGS(lam) & LAMBDA_HAS_REST) + && (lam->num_params - 1 <= argc))) break; else - data = NULL; + lam = NULL; } } else - data = NULL; + lam = NULL; - if (!data) + if (!lam) return_NULL; - if (data->closure_size) + if (lam->closure_size) return_NULL; /* convert an optimized & resolved closure back to compiled form: */ - return unresolve_closure_data(data, - new_unresolve_info((Scheme_Prefix *)SCHEME_VEC_ELS(iv)[2])); + return unresolve_lambda(lam, + new_unresolve_info((Scheme_Prefix *)SCHEME_VEC_ELS(iv)[2])); } @@ -4377,14 +4377,14 @@ static Scheme_Object *unresolve_expr(Scheme_Object *e, Unresolve_Info *ui, int a Scheme_Letrec *lr = (Scheme_Letrec *)lv->body; if (lv->count == lr->count) { - Scheme_Let_Header *lh; - Scheme_Compiled_Let_Value *clv, *prev = NULL; + Scheme_IR_Let_Header *lh; + Scheme_IR_Let_Value *irlv, *prev = NULL; Scheme_Object *rhs, *body; - Scheme_Compiled_Local **vars; + Scheme_IR_Local **vars; int i, pos; - lh = MALLOC_ONE_TAGGED(Scheme_Let_Header); - lh->iso.so.type = scheme_compiled_let_void_type; + lh = MALLOC_ONE_TAGGED(Scheme_IR_Let_Header); + lh->iso.so.type = scheme_ir_let_void_type; lh->count = lv->count; lh->num_clauses = lv->count; SCHEME_LET_FLAGS(lh) += SCHEME_LET_RECURSIVE; @@ -4395,19 +4395,19 @@ static Scheme_Object *unresolve_expr(Scheme_Object *e, Unresolve_Info *ui, int a rhs = unresolve_expr(lr->procs[i], ui, 0); if (!rhs) return_NULL; - clv = MALLOC_ONE_TAGGED(Scheme_Compiled_Let_Value); - clv->iso.so.type = scheme_compiled_let_value_type; - clv->count = 1; - clv->value = rhs; + irlv = MALLOC_ONE_TAGGED(Scheme_IR_Let_Value); + irlv->iso.so.type = scheme_ir_let_value_type; + irlv->count = 1; + irlv->value = rhs; vars = unresolve_stack_extract(ui, i, 1); - clv->vars = vars; + irlv->vars = vars; if (prev) - prev->body = (Scheme_Object *)clv; + prev->body = (Scheme_Object *)irlv; else - lh->body = (Scheme_Object *)clv; - prev = clv; + lh->body = (Scheme_Object *)irlv; + prev = irlv; } body = unresolve_expr(lr->body, ui, 0); @@ -4429,9 +4429,9 @@ static Scheme_Object *unresolve_expr(Scheme_Object *e, Unresolve_Info *ui, int a { Scheme_Let_One *lo = (Scheme_Let_One *)e; Scheme_Object *rhs, *body; - Scheme_Let_Header *lh; - Scheme_Compiled_Let_Value *clv; - Scheme_Compiled_Local **vars; + Scheme_IR_Let_Header *lh; + Scheme_IR_Let_Value *irlv; + Scheme_IR_Local **vars; int pos; pos = unresolve_stack_push(ui, 1, 1); @@ -4443,19 +4443,19 @@ static Scheme_Object *unresolve_expr(Scheme_Object *e, Unresolve_Info *ui, int a vars = unresolve_stack_pop(ui, pos, 1); - lh = MALLOC_ONE_TAGGED(Scheme_Let_Header); - lh->iso.so.type = scheme_compiled_let_void_type; + lh = MALLOC_ONE_TAGGED(Scheme_IR_Let_Header); + lh->iso.so.type = scheme_ir_let_void_type; lh->count = 1; lh->num_clauses = 1; - clv = MALLOC_ONE_TAGGED(Scheme_Compiled_Let_Value); - clv->iso.so.type = scheme_compiled_let_value_type; - clv->count = 1; - clv->value = rhs; - clv->vars = vars; - clv->body = body; + irlv = MALLOC_ONE_TAGGED(Scheme_IR_Let_Value); + irlv->iso.so.type = scheme_ir_let_value_type; + irlv->count = 1; + irlv->value = rhs; + irlv->vars = vars; + irlv->body = body; - lh->body = (Scheme_Object *)clv; + lh->body = (Scheme_Object *)irlv; return (Scheme_Object *)lh; } @@ -4473,19 +4473,19 @@ static Scheme_Object *unresolve_expr(Scheme_Object *e, Unresolve_Info *ui, int a scheme_hash_set(ui->closures, e, scheme_true); - r = unresolve_closure_data(SCHEME_COMPILED_CLOS_CODE(e), ui); + r = unresolve_lambda(SCHEME_CLOSURE_CODE(e), ui); scheme_hash_set(ui->closures, e, NULL); return r; } - case scheme_unclosed_procedure_type: + case scheme_lambda_type: { - return unresolve_closure_data((Scheme_Closure_Data *)e, ui); + return unresolve_lambda((Scheme_Lambda *)e, ui); } default: if (SCHEME_TYPE(e) > _scheme_values_types_) { - if (scheme_compiled_duplicate_ok(e, 1)) + if (scheme_ir_duplicate_ok(e, 1)) return e; } return_NULL; diff --git a/racket/src/racket/src/salloc.c b/racket/src/racket/src/salloc.c index df8d9fe91c..6bfdb73f53 100644 --- a/racket/src/racket/src/salloc.c +++ b/racket/src/racket/src/salloc.c @@ -2023,7 +2023,7 @@ static void print_tagged_value(const char *prefix, scheme_check_print_is_obj = check_home; { - if (SCHEME_TYPE(v) > _scheme_compiled_values_types_) { + if (SCHEME_TYPE(v) > _scheme_ir_values_types_) { sprintf(hashstr, "{%" PRIdPTR "}", scheme_hash_key(v)); hash_code = hashstr; } @@ -2913,13 +2913,13 @@ intptr_t scheme_count_memory(Scheme_Object *root, Scheme_Hash_Table *ht) #endif } break; - case scheme_unclosed_procedure_type: - case scheme_compiled_unclosed_procedure_type: + case scheme_lambda_type: + case scheme_ir_lambda_type: { - Scheme_Closure_Data *data = - (Scheme_Closure_Data *)root; + Scheme_Lambda *data = + (Scheme_Lambda *)root; - s = sizeof(Scheme_Closure_Data); + s = sizeof(Scheme_Lambda); s += data->closure_size * sizeof(mzshort); #if FORCE_KNOWN_SUBPARTS e = COUNT(data->code); @@ -2936,11 +2936,11 @@ intptr_t scheme_count_memory(Scheme_Object *root, Scheme_Hash_Table *ht) #endif } break; - case scheme_compiled_let_value_type: + case scheme_ir_let_value_type: { - Scheme_Compiled_Let_Value *let = (Scheme_Compiled_Let_Value *)root; + Scheme_IR_Let_Value *let = (Scheme_IR_Let_Value *)root; - s = sizeof(Scheme_Compiled_Let_Value); + s = sizeof(Scheme_IR_Let_Value); #if FORCE_KNOWN_SUBPARTS e = COUNT(let->value) + COUNT(let->body); #endif @@ -2956,7 +2956,7 @@ intptr_t scheme_count_memory(Scheme_Object *root, Scheme_Hash_Table *ht) #endif } break; - case scheme_compiled_let_void_type: + case scheme_ir_let_void_type: { Scheme_Let_Header *let = (Scheme_Let_Header *)root; @@ -3040,11 +3040,11 @@ intptr_t scheme_count_memory(Scheme_Object *root, Scheme_Hash_Table *ht) break; case scheme_closure_type: { - Scheme_Closure_Data *data; + Scheme_Lambda *data; Scheme_Object **vals; - data = SCHEME_COMPILED_CLOS_CODE(root); - vals = SCHEME_COMPILED_CLOS_ENV(root); + data = SCHEME_CLOSURE_CODE(root); + vals = SCHEME_CLOSURE_ENV(root); s += (data->closure_size * sizeof(Scheme_Object *)); #if FORCE_KNOWN_SUBPARTS diff --git a/racket/src/racket/src/schpriv.h b/racket/src/racket/src/schpriv.h index d93664b801..ed945bd9c2 100644 --- a/racket/src/racket/src/schpriv.h +++ b/racket/src/racket/src/schpriv.h @@ -453,7 +453,7 @@ extern Scheme_Object *scheme_fixnum_p_proc; extern Scheme_Object *scheme_flonum_p_proc; extern Scheme_Object *scheme_extflonum_p_proc; extern Scheme_Object *scheme_apply_proc; -extern Scheme_Object *scheme_values_func; +extern Scheme_Object *scheme_values_proc; extern Scheme_Object *scheme_procedure_p_proc; extern Scheme_Object *scheme_procedure_arity_includes_proc; extern Scheme_Object *scheme_procedure_specialize_proc; @@ -516,10 +516,10 @@ extern Scheme_Object *scheme_define_values_syntax, *scheme_define_syntaxes_synta extern Scheme_Object *scheme_lambda_syntax; extern Scheme_Object *scheme_begin_syntax; -extern Scheme_Object *scheme_not_prim; -extern Scheme_Object *scheme_eq_prim; -extern Scheme_Object *scheme_eqv_prim; -extern Scheme_Object *scheme_equal_prim; +extern Scheme_Object *scheme_not_proc; +extern Scheme_Object *scheme_eq_proc; +extern Scheme_Object *scheme_eqv_proc; +extern Scheme_Object *scheme_equal_proc; extern Scheme_Object *scheme_def_exit_proc; @@ -1459,12 +1459,12 @@ Scheme_Object *scheme_top_introduce(Scheme_Object *form, Scheme_Env *genv); /* syntax run-time structures */ /*========================================================================*/ -/* A Scheme_Compiled_Local record represents a local variable, +/* A Scheme_IR_Local record represents a local variable, both the binding and references to that binding. When inlining of other transformations duplicate a variable, a new instance is allocated to represent a separate variable. Different passes in the comiler store different information about the variable. */ -typedef struct Scheme_Compiled_Local +typedef struct Scheme_IR_Local { Scheme_Object so; @@ -1552,9 +1552,9 @@ typedef struct Scheme_Compiled_Local Scheme_Object *lifted; } resolve; }; -} Scheme_Compiled_Local; +} Scheme_IR_Local; -#define SCHEME_VAR(v) ((Scheme_Compiled_Local *)v) +#define SCHEME_VAR(v) ((Scheme_IR_Local *)v) #define SCHEME_USE_COUNT_INF 7 @@ -1620,34 +1620,34 @@ typedef struct { } Scheme_Compilation_Top; /* A `let' or `letrec' form is compiled to the intermediate - format (used during the optimization pass) as a Scheme_Let_Header - with a chain of Scheme_Compiled_Let_Value records as its body, - where there's one Scheme_Compiled_Let_Value for each binding + format (used during the optimization pass) as a Scheme_IR_Let_Header + with a chain of Scheme_IR_Let_Value records as its body, + where there's one Scheme_IR_Let_Value for each binding clause. The body of the `let...' form is the body of the innermost - Scheme_Compiled_Let_Value record. + Scheme_IR_Let_Value record. */ -typedef struct Scheme_Let_Header { +typedef struct Scheme_IR_Let_Header { Scheme_Inclhash_Object iso; /* keyex used for recursive */ mzshort count; /* total number of bindings */ mzshort num_clauses; /* number of binding clauses */ Scheme_Object *body; -} Scheme_Let_Header; +} Scheme_IR_Let_Header; #define SCHEME_LET_FLAGS(lh) MZ_OPT_HASH_KEY(&lh->iso) #define SCHEME_LET_RECURSIVE 0x1 -typedef struct Scheme_Compiled_Let_Value { +typedef struct Scheme_IR_Let_Value { Scheme_Inclhash_Object iso; /* keyex used for set-starting */ mzshort count; Scheme_Object *value; Scheme_Object *body; - Scheme_Compiled_Local **vars; -} Scheme_Compiled_Let_Value; + Scheme_IR_Local **vars; +} Scheme_IR_Let_Value; -#define SCHEME_CLV_FLAGS(clv) MZ_OPT_HASH_KEY(&(clv)->iso) -#define SCHEME_CLV_NO_GROUP_LATER_USES 0x1 -#define SCHEME_CLV_NO_GROUP_USES 0x2 +#define SCHEME_IRLV_FLAGS(irlv) MZ_OPT_HASH_KEY(&(irlv)->iso) +#define SCHEME_IRLV_NO_GROUP_LATER_USES 0x1 +#define SCHEME_IRLV_NO_GROUP_USES 0x2 typedef struct { Scheme_Object so; @@ -1770,11 +1770,11 @@ typedef struct { mzshort count; Scheme_Object *name; /* see note below */ #ifdef MZ_USE_JIT - struct Scheme_Native_Closure_Data *native_code; /* generated by lightning */ + struct Scheme_Native_Lambda *native_code; /* generated by lightning */ #endif Scheme_Object *array[mzFLEX_ARRAY_DECL]; } Scheme_Case_Lambda; -/* If count is not 0, then check array[0] for CLOS_IS_METHOD. +/* If count is not 0, then check array[0] for LAMBDA_IS_METHOD. Otherwise, name is a boxed symbol (or #f) to indicate a method. */ #define scheme_make_prim_w_arity2(f, n, mina, maxa, minr, maxr) \ @@ -2769,7 +2769,7 @@ typedef struct Scheme_Comp_Env Scheme_Object **bindings; /* symbols */ Scheme_Object **vals; /* compile-time values */ Scheme_Object **shadower_deltas; - Scheme_Compiled_Local **vars; + Scheme_IR_Local **vars; int *use; int max_use, any_use; @@ -2795,16 +2795,16 @@ typedef struct Scheme_Comp_Env struct Scheme_Comp_Env *next; } Scheme_Comp_Env; -#define CLOS_HAS_REST 1 -#define CLOS_HAS_TYPED_ARGS 2 -#define CLOS_PRESERVES_MARKS 4 -#define CLOS_NEED_REST_CLEAR 8 -#define CLOS_IS_METHOD 16 -#define CLOS_SINGLE_RESULT 32 -#define CLOS_RESULT_TENTATIVE 64 -#define CLOS_VALIDATED 128 -#define CLOS_SFS 256 -/* BITS 8-15 (overlaps CLOS_SFS) used by write_compiled_closure() */ +#define LAMBDA_HAS_REST 1 +#define LAMBDA_HAS_TYPED_ARGS 2 +#define LAMBDA_PRESERVES_MARKS 4 +#define LAMBDA_NEED_REST_CLEAR 8 +#define LAMBDA_IS_METHOD 16 +#define LAMBDA_SINGLE_RESULT 32 +#define LAMBDA_RESULT_TENTATIVE 64 +#define LAMBDA_VALIDATED 128 +#define LAMBDA_SFS 256 +/* BITS 8-15 (overlaps LAMBDA_SFS) used by write_lambda() */ typedef struct Scheme_Compile_Expand_Info { @@ -2843,16 +2843,16 @@ typedef struct Resolve_Prefix typedef struct Resolve_Info Resolve_Info; -/* Closure_Info is used to store extra closure information +/* Scheme_IR_Lambda_Info is used to store extra closure information before a closure mapping is resolved. */ typedef struct { MZTAG_IF_REQUIRED Scheme_Hash_Table *base_closure; - Scheme_Compiled_Local **vars; + Scheme_IR_Local **vars; char *local_type_map; /* determined by callers; NULL when has_tymap set => no local types */ char has_tl, has_tymap, has_nonleaf; int body_size, body_psize; -} Closure_Info; +} Scheme_IR_Lambda_Info; typedef struct Optimize_Info Optimize_Info; @@ -2866,36 +2866,39 @@ typedef struct Scheme_Object * typedef struct CPort Mz_CPort; -typedef struct Scheme_Closure_Data +typedef struct Scheme_Lambda { Scheme_Inclhash_Object iso; /* keyex used for flags */ mzshort num_params; /* includes collecting arg if has_rest */ mzshort max_let_depth; mzshort closure_size; /* the number of closed-over variables */ - mzshort *closure_map; /* actually a Closure_Info* until resolved; - contains closure_size elements mapping closed-over var to stack positions. + union { + Scheme_IR_Lambda_Info *ir_info; /* used until resolve pass */ + mzshort *closure_map; /* after resolve pass: + contains closure_size elements mapping closed-over var to stack positions. - If CLOS_HAS_TYPED_ARGS, that array is followed by bit array with - CLOS_TYPE_BITS_PER_ARG bits per args then per closed-over + If LAMBDA_HAS_TYPED_ARGS, that array is followed by bit array with + LAMBDA_TYPE_BITS_PER_ARG bits per args then per closed-over - total size = closure_size + (closure_size + num_params) * CLOS_TYPE_BITS_PER_ARG */ - Scheme_Object *code; + total size = closure_size + (closure_size + num_params) * LAMBDA_TYPE_BITS_PER_ARG */ + }; + Scheme_Object *body; Scheme_Object *name; /* name or (vector name src line col pos span generated?) */ void *tl_map; /* fixnum or bit array (as array of `int's) indicating which globals+lifts in prefix are used */ #ifdef MZ_USE_JIT union { - struct Scheme_Closure_Data *jit_clone; - struct Scheme_Native_Closure_Data *native_code; /* generated by lightning */ + struct Scheme_Lambda *jit_clone; + struct Scheme_Native_Lambda *native_code; /* generated by lightning */ } u; Scheme_Object *context; /* e.g., a letrec that binds the closure */ #endif -} Scheme_Closure_Data; +} Scheme_Lambda; -#define SCHEME_CLOSURE_DATA_FLAGS(obj) MZ_OPT_HASH_KEY(&(obj)->iso) +#define SCHEME_LAMBDA_FLAGS(obj) MZ_OPT_HASH_KEY(&(obj)->iso) -#define CLOS_TYPE_BITS_PER_ARG 4 -#define CLOS_TYPE_BOXED 1 -#define CLOS_TYPE_TYPE_OFFSET 1 +#define LAMBDA_TYPE_BITS_PER_ARG 4 +#define LAMBDA_TYPE_BOXED 1 +#define LAMBDA_TYPE_TYPE_OFFSET 1 XFORM_NONGCING void scheme_boxmap_set(mzshort *boxmap, int j, int bit, int delta); XFORM_NONGCING int scheme_boxmap_get(mzshort *boxmap, int j, int delta); @@ -2905,16 +2908,16 @@ int scheme_has_method_property(Scheme_Object *code); typedef struct Scheme_Closure { Scheme_Object so; - Scheme_Closure_Data *code; + Scheme_Lambda *code; Scheme_Object *vals[mzFLEX_ARRAY_DECL]; } Scheme_Closure; -#define SCHEME_COMPILED_CLOS_CODE(c) ((Scheme_Closure *)c)->code -#define SCHEME_COMPILED_CLOS_ENV(c) ((Scheme_Closure *)c)->vals +#define SCHEME_CLOSURE_CODE(c) ((Scheme_Closure *)c)->code +#define SCHEME_CLOSURE_ENV(c) ((Scheme_Closure *)c)->vals #define ZERO_SIZED_CLOSUREP(closure) !(closure->code->closure_size) -typedef struct Scheme_Native_Closure_Data { +typedef struct Scheme_Native_Lambda { Scheme_Inclhash_Object iso; /* type tag only set when needed, but flags always needed */ Scheme_Native_Proc *start_code; /* When not yet JITted, this is = to @@ -2929,7 +2932,7 @@ typedef struct Scheme_Native_Closure_Data { case-lambda, and the number of cases is (-closure-size)-1 */ union { - struct Scheme_Closure_Data *orig_code; /* For not-yet-JITted + struct Scheme_Lambda *orig_code; /* For not-yet-JITted non-case-lambda */ Scheme_Object *name; } u2; @@ -2943,9 +2946,9 @@ typedef struct Scheme_Native_Closure_Data { void *retain_code; #endif void *eq_key; /* for `procedure-closure-contents-eq?` */ -} Scheme_Native_Closure_Data; +} Scheme_Native_Lambda; -#define SCHEME_NATIVE_CLOSURE_DATA_FLAGS(obj) MZ_OPT_HASH_KEY(&(obj)->iso) +#define SCHEME_NATIVE_LAMBDA_FLAGS(obj) MZ_OPT_HASH_KEY(&(obj)->iso) /* This flag is set pre-JIT: */ #define NATIVE_SPECIALIZED 0x1 @@ -2953,12 +2956,12 @@ typedef struct Scheme_Native_Closure_Data { typedef struct { Scheme_Object so; - Scheme_Native_Closure_Data *code; + Scheme_Native_Lambda *code; Scheme_Object *vals[mzFLEX_ARRAY_DECL]; } Scheme_Native_Closure; -Scheme_Native_Closure_Data *scheme_generate_lambda(Scheme_Closure_Data *obj, int drop_code, - Scheme_Native_Closure_Data *case_lam); +Scheme_Native_Lambda *scheme_generate_lambda(Scheme_Lambda *obj, int drop_code, + Scheme_Native_Lambda *case_lam); typedef struct Scheme_Current_LWC { /* !! All of these fields are treated as atomic by the GC !! */ @@ -3136,15 +3139,15 @@ Scheme_Object *scheme_make_closure(Scheme_Thread *p, int close); Scheme_Closure *scheme_malloc_empty_closure(void); -Scheme_Object *scheme_make_native_closure(Scheme_Native_Closure_Data *code); -Scheme_Object *scheme_make_native_case_closure(Scheme_Native_Closure_Data *code); +Scheme_Object *scheme_make_native_closure(Scheme_Native_Lambda *code); +Scheme_Object *scheme_make_native_case_closure(Scheme_Native_Lambda *code); void scheme_reset_app2_eval_type(Scheme_App2_Rec *app); void scheme_reset_app3_eval_type(Scheme_App3_Rec *app); -Scheme_Native_Closure_Data *scheme_generate_case_lambda(Scheme_Case_Lambda *cl); +Scheme_Native_Lambda *scheme_generate_case_lambda(Scheme_Case_Lambda *cl); -void scheme_delay_load_closure(Scheme_Closure_Data *data); +void scheme_delay_load_closure(Scheme_Lambda *data); Scheme_Object *scheme_intdef_bind_identifiers(Scheme_Object *intdef); @@ -3233,8 +3236,8 @@ Scheme_Object *scheme_optimize_apply_values(Scheme_Object *f, Scheme_Object *e, int e_single_result, int context); -int scheme_compiled_duplicate_ok(Scheme_Object *o, int cross_mod); -int scheme_compiled_propagate_ok(Scheme_Object *o, Optimize_Info *info); +int scheme_ir_duplicate_ok(Scheme_Object *o, int cross_mod); +int scheme_ir_propagate_ok(Scheme_Object *o, Optimize_Info *info); int scheme_is_statically_proc(Scheme_Object *value, Optimize_Info *info); Scheme_Object *scheme_make_noninline_proc(Scheme_Object *e); @@ -3245,7 +3248,7 @@ Scheme_Object *scheme_unresolve_top(Scheme_Object *, Comp_Prefix **); int scheme_check_leaf_rator(Scheme_Object *le, int *_flags); -int scheme_is_compiled_procedure(Scheme_Object *o, int can_be_closed, int can_be_liftable); +int scheme_is_ir_lambda(Scheme_Object *o, int can_be_closed, int can_be_liftable); Scheme_Object *scheme_resolve_lets(Scheme_Object *form, Resolve_Info *info); @@ -3272,8 +3275,8 @@ Scheme_Object *scheme_toplevel_to_flagged_toplevel(Scheme_Object *tl, int flags) int scheme_expr_produces_local_type(Scheme_Object *expr, int *_involves_k_cross); -Scheme_Object *scheme_make_compiled_syntax(Scheme_Syntax *syntax, - Scheme_Syntax_Expander *exp); +Scheme_Object *scheme_make_primitive_syntax(Scheme_Syntax *syntax, + Scheme_Syntax_Expander *exp); Scheme_Object *scheme_compile_expr(Scheme_Object *form, Scheme_Comp_Env *env, Scheme_Compile_Info *rec, int drec); @@ -3340,7 +3343,7 @@ int scheme_env_check_reset_any_use(Scheme_Comp_Env *frame); int scheme_env_max_use_above(Scheme_Comp_Env *frame, int pos); void scheme_mark_all_use(Scheme_Comp_Env *frame); void scheme_env_make_variables(Scheme_Comp_Env *frame); -void scheme_set_compilation_variables(Scheme_Comp_Env *frame, Scheme_Compiled_Local **vars, +void scheme_set_compilation_variables(Scheme_Comp_Env *frame, Scheme_IR_Local **vars, int pos, int count); /* flags reported by scheme_resolve_info_flags */ @@ -4601,7 +4604,7 @@ void scheme_place_check_memory_use(); void scheme_clear_place_ifs_stack(); Scheme_Object **scheme_extract_sorted_keys(Scheme_Object *ht); -void scheme_sort_resolve_compiled_local_array(Scheme_Compiled_Local **a, intptr_t count); +void scheme_sort_resolve_ir_local_array(Scheme_IR_Local **a, intptr_t count); #ifdef MZ_USE_PLACES Scheme_Object *scheme_place_make_async_channel(); diff --git a/racket/src/racket/src/sfs.c b/racket/src/racket/src/sfs.c index cba3826d16..fd3642e80e 100644 --- a/racket/src/racket/src/sfs.c +++ b/racket/src/racket/src/sfs.c @@ -222,7 +222,7 @@ static void sfs_note_app(SFS_Info *info, Scheme_Object *rator, int flags) if (!info->tail_pos) { if (flags & APPN_FLAG_IMMED) return; - if (SAME_OBJ(scheme_values_func, rator)) + if (SAME_OBJ(scheme_values_proc, rator)) /* no need to clear for app of `values' */ return; if (SCHEME_PRIMP(rator)) { @@ -1013,7 +1013,7 @@ case_lambda_sfs(Scheme_Object *expr, SFS_Info *info) } le = cseq->array[0]; } - if (!SAME_TYPE(SCHEME_TYPE(le), scheme_unclosed_procedure_type) + if (!SAME_TYPE(SCHEME_TYPE(le), scheme_lambda_type) && !SAME_TYPE(SCHEME_TYPE(le), scheme_closure_type)) { scheme_signal_error("internal error: not a lambda for case-lambda: %d", SCHEME_TYPE(le)); @@ -1155,7 +1155,7 @@ static Scheme_Object *begin_for_syntax_sfs(Scheme_Object *data, SFS_Info *info) static Scheme_Object *sfs_closure(Scheme_Object *expr, SFS_Info *info, int self_pos) { - Scheme_Closure_Data *data = (Scheme_Closure_Data *)expr; + Scheme_Lambda *data = (Scheme_Lambda *)expr; Scheme_Object *code; int i, size, has_tl = 0; @@ -1195,8 +1195,8 @@ static Scheme_Object *sfs_closure(Scheme_Object *expr, SFS_Info *info, int self_ return scheme_sfs_add_clears(expr, clears, 0); } - if (!(SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_SFS)) { - SCHEME_CLOSURE_DATA_FLAGS(data) |= CLOS_SFS; + if (!(SCHEME_LAMBDA_FLAGS(data) & LAMBDA_SFS)) { + SCHEME_LAMBDA_FLAGS(data) |= LAMBDA_SFS; info = scheme_new_sfs_info(data->max_let_depth); scheme_sfs_push(info, data->closure_size + data->num_params, 1); @@ -1215,7 +1215,7 @@ static Scheme_Object *sfs_closure(Scheme_Object *expr, SFS_Info *info, int self_ } /* Never clear typed arguments or typed closure elements: */ - if (SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_HAS_TYPED_ARGS) { + if (SCHEME_LAMBDA_FLAGS(data) & LAMBDA_HAS_TYPED_ARGS) { int delta, size, ct, j, pos; mzshort *map; delta = data->closure_size; @@ -1223,7 +1223,7 @@ static Scheme_Object *sfs_closure(Scheme_Object *expr, SFS_Info *info, int self_ map = data->closure_map; for (j = 0; j < size; j++) { ct = scheme_boxmap_get(map, j, delta); - if (ct > CLOS_TYPE_TYPE_OFFSET) { + if (ct > LAMBDA_TYPE_TYPE_OFFSET) { if (j < data->num_params) pos = info->stackpos + delta + j; else @@ -1233,7 +1233,7 @@ static Scheme_Object *sfs_closure(Scheme_Object *expr, SFS_Info *info, int self_ } } - code = scheme_sfs(data->code, info, data->max_let_depth); + code = scheme_sfs(data->body, info, data->max_let_depth); /* If any arguments go unused, and if there's a non-tail, non-immediate call in the body, then we flush the @@ -1257,11 +1257,11 @@ static Scheme_Object *sfs_closure(Scheme_Object *expr, SFS_Info *info, int self_ if (SCHEME_PAIRP(clears)) code = scheme_sfs_add_clears(code, clears, 1); - if (SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_HAS_REST) - SCHEME_CLOSURE_DATA_FLAGS(data) |= CLOS_NEED_REST_CLEAR; + if (SCHEME_LAMBDA_FLAGS(data) & LAMBDA_HAS_REST) + SCHEME_LAMBDA_FLAGS(data) |= LAMBDA_NEED_REST_CLEAR; } - data->code = code; + data->body = code; } return expr; @@ -1388,7 +1388,7 @@ Scheme_Object *scheme_sfs_expr(Scheme_Object *expr, SFS_Info *info, int closure_ case scheme_with_cont_mark_type: expr = sfs_wcm(expr, info); break; - case scheme_unclosed_procedure_type: + case scheme_lambda_type: expr = sfs_closure(expr, info, closure_self_pos); break; case scheme_let_value_type: @@ -1411,11 +1411,11 @@ Scheme_Object *scheme_sfs_expr(Scheme_Object *expr, SFS_Info *info, int closure_ code = sfs_closure((Scheme_Object *)c->code, info, closure_self_pos); if (SAME_TYPE(SCHEME_TYPE(code), scheme_begin0_sequence_type)) { Scheme_Sequence *seq = (Scheme_Sequence *)code; - c->code = (Scheme_Closure_Data *)seq->array[0]; + c->code = (Scheme_Lambda *)seq->array[0]; seq->array[0] = expr; expr = code; } else { - c->code = (Scheme_Closure_Data *)code; + c->code = (Scheme_Lambda *)code; } } } diff --git a/racket/src/racket/src/stypes.h b/racket/src/racket/src/stypes.h index 8731df1029..68647ffc61 100644 --- a/racket/src/racket/src/stypes.h +++ b/racket/src/racket/src/stypes.h @@ -10,7 +10,7 @@ enum { scheme_application3_type, /* 5 */ scheme_sequence_type, /* 6 */ scheme_branch_type, /* 7 */ - scheme_unclosed_procedure_type, /* 8 */ + scheme_lambda_type, /* 8 */ scheme_let_value_type, /* 9 */ scheme_let_void_type, /* 10 */ scheme_letrec_type, /* 11 */ @@ -35,13 +35,13 @@ enum { _scheme_values_types_, /* All following types are values */ - /* intermediate compiled: */ - scheme_compiled_local_type, /* 30 */ - scheme_compiled_unclosed_procedure_type,/* 31 */ - scheme_compiled_let_value_type, /* 32 */ - scheme_compiled_let_void_type, /* 33 */ - scheme_compiled_toplevel_type, /* 34 */ - scheme_compiled_quote_syntax_type, /* 35 */ + /* intermediate compiled variants (as seen by optimizer): */ + scheme_ir_local_type, /* 30 */ + scheme_ir_lambda_type, /* 31 */ + scheme_ir_let_value_type, /* 32 */ + scheme_ir_let_void_type, /* 33 */ + scheme_ir_toplevel_type, /* 34 */ + scheme_ir_quote_syntax_type, /* 35 */ scheme_quote_compilation_type, /* used while writing, only */ @@ -49,7 +49,7 @@ enum { scheme_variable_type, /* 37 */ scheme_module_variable_type, /* link replaces with scheme_variable_type */ - _scheme_compiled_values_types_, /* 39 */ + _scheme_ir_values_types_, /* 39 */ /* procedure types */ scheme_prim_type, /* 40 */ @@ -97,7 +97,7 @@ enum { scheme_true_type, /* 73 */ scheme_false_type, /* 74 */ scheme_void_type, /* 75 */ - scheme_syntax_compiler_type, /* 76 */ + scheme_primitive_syntax_type, /* 76 */ scheme_macro_type, /* 77 */ scheme_box_type, /* 78 */ scheme_thread_type, /* 79 */ @@ -237,7 +237,7 @@ enum { scheme_rt_cont_mark, /* 209 */ scheme_rt_saved_stack, /* 210 */ scheme_rt_reply_item, /* 211 */ - scheme_rt_closure_info, /* 212 */ + scheme_rt_ir_lambda_info, /* 212 */ scheme_rt_overflow, /* 213 */ scheme_rt_overflow_jmp, /* 214 */ scheme_rt_meta_cont, /* 215 */ diff --git a/racket/src/racket/src/syntax.c b/racket/src/racket/src/syntax.c index 444267fe9d..9cd1303211 100644 --- a/racket/src/racket/src/syntax.c +++ b/racket/src/racket/src/syntax.c @@ -5860,14 +5860,14 @@ static void sort_number_array(Scheme_Object **a, intptr_t count) static int compare_vars_at_resolve(const void *_a, const void *_b) { - Scheme_Compiled_Local *a = *(Scheme_Compiled_Local **)_a; - Scheme_Compiled_Local *b = *(Scheme_Compiled_Local **)_b; + Scheme_IR_Local *a = *(Scheme_IR_Local **)_a; + Scheme_IR_Local *b = *(Scheme_IR_Local **)_b; return a->resolve.lex_depth - b->resolve.lex_depth; } -void scheme_sort_resolve_compiled_local_array(Scheme_Compiled_Local **a, intptr_t count) +void scheme_sort_resolve_ir_local_array(Scheme_IR_Local **a, intptr_t count) { - my_qsort(a, count, sizeof(Scheme_Compiled_Local *), compare_vars_at_resolve); + my_qsort(a, count, sizeof(Scheme_IR_Local *), compare_vars_at_resolve); } static Scheme_Object *drop_export_registries(Scheme_Object *shifts) diff --git a/racket/src/racket/src/thread.c b/racket/src/racket/src/thread.c index ae25c34dcb..18b1880e79 100644 --- a/racket/src/racket/src/thread.c +++ b/racket/src/racket/src/thread.c @@ -2720,8 +2720,8 @@ static void do_swap_thread() Scheme_Closure_Func f; for (l = thread_swap_callbacks; SCHEME_RPAIRP(l); l = SCHEME_CDR(l)) { o = SCHEME_CAR(l); - f = SCHEME_CLOS_FUNC(o); - o = SCHEME_CLOS_DATA(o); + f = SCHEME_RAW_CLOS_FUNC(o); + o = SCHEME_RAW_CLOS_DATA(o); f(o); } } @@ -2759,8 +2759,8 @@ static void do_swap_thread() Scheme_Closure_Func f; for (l = thread_swap_out_callbacks; SCHEME_RPAIRP(l); l = SCHEME_CDR(l)) { o = SCHEME_CAR(l); - f = SCHEME_CLOS_FUNC(o); - o = SCHEME_CLOS_DATA(o); + f = SCHEME_RAW_CLOS_FUNC(o); + o = SCHEME_RAW_CLOS_DATA(o); f(o); } } @@ -3056,8 +3056,8 @@ static void start_child(Scheme_Thread * volatile child, Scheme_Closure_Func f; for (l = thread_swap_callbacks; SCHEME_RPAIRP(l); l = SCHEME_CDR(l)) { o = SCHEME_CAR(l); - f = SCHEME_CLOS_FUNC(o); - o = SCHEME_CLOS_DATA(o); + f = SCHEME_RAW_CLOS_FUNC(o); + o = SCHEME_RAW_CLOS_DATA(o); f(o); } } diff --git a/racket/src/racket/src/type.c b/racket/src/racket/src/type.c index 4d1d4ccd59..b68b9df1f8 100644 --- a/racket/src/racket/src/type.c +++ b/racket/src/racket/src/type.c @@ -116,8 +116,8 @@ scheme_init_type () set_name(scheme_application_type, ""); set_name(scheme_application2_type, ""); set_name(scheme_application3_type, ""); - set_name(scheme_compiled_unclosed_procedure_type, ""); - set_name(scheme_unclosed_procedure_type, ""); + set_name(scheme_ir_lambda_type, ""); + set_name(scheme_lambda_type, ""); set_name(scheme_branch_type, ""); set_name(scheme_sequence_type, ""); set_name(scheme_with_cont_mark_type, ""); @@ -140,11 +140,11 @@ scheme_init_type () set_name(scheme_let_value_type, ""); set_name(scheme_let_void_type, ""); - set_name(scheme_compiled_local_type, ""); - set_name(scheme_compiled_let_value_type, ""); - set_name(scheme_compiled_let_void_type, ""); - set_name(scheme_compiled_toplevel_type, ""); - set_name(scheme_compiled_quote_syntax_type, ""); + set_name(scheme_ir_local_type, ""); + set_name(scheme_ir_let_value_type, ""); + set_name(scheme_ir_let_void_type, ""); + set_name(scheme_ir_toplevel_type, ""); + set_name(scheme_ir_quote_syntax_type, ""); set_name(scheme_letrec_type, ""); set_name(scheme_let_one_type, ""); set_name(scheme_quote_compilation_type, ""); @@ -187,7 +187,7 @@ scheme_init_type () #endif set_name(scheme_symbol_type, ""); set_name(scheme_keyword_type, ""); - set_name(scheme_syntax_compiler_type, ""); + set_name(scheme_primitive_syntax_type, ""); set_name(scheme_macro_type, ""); set_name(scheme_vector_type, ""); set_name(scheme_flvector_type, ""); @@ -314,7 +314,7 @@ scheme_init_type () set_name(scheme_fsemaphore_type, ""); set_name(_scheme_values_types_, ""); - set_name(_scheme_compiled_values_types_, ""); + set_name(_scheme_ir_values_types_, ""); set_name(scheme_place_type, ""); set_name(scheme_place_async_channel_type, ""); @@ -562,7 +562,7 @@ void scheme_register_traversers(void) GC_REG_TRAV(scheme_application3_type, app3_rec); GC_REG_TRAV(scheme_sequence_type, seq_rec); GC_REG_TRAV(scheme_branch_type, branch_rec); - GC_REG_TRAV(scheme_unclosed_procedure_type, unclosed_proc); + GC_REG_TRAV(scheme_lambda_type, unclosed_proc); GC_REG_TRAV(scheme_let_value_type, let_value); GC_REG_TRAV(scheme_let_void_type, let_void); GC_REG_TRAV(scheme_letrec_type, letrec); @@ -589,16 +589,16 @@ void scheme_register_traversers(void) GC_REG_TRAV(_scheme_values_types_, bad_trav); - GC_REG_TRAV(scheme_compiled_unclosed_procedure_type, unclosed_proc); - GC_REG_TRAV(scheme_compiled_local_type, comp_local); - GC_REG_TRAV(scheme_compiled_let_value_type, comp_let_value); - GC_REG_TRAV(scheme_compiled_let_void_type, let_header); - GC_REG_TRAV(scheme_compiled_toplevel_type, toplevel_obj); - GC_REG_TRAV(scheme_compiled_quote_syntax_type, local_obj); + GC_REG_TRAV(scheme_ir_lambda_type, unclosed_proc); + GC_REG_TRAV(scheme_ir_local_type, ir_local); + GC_REG_TRAV(scheme_ir_let_value_type, ir_let_value); + GC_REG_TRAV(scheme_ir_let_void_type, let_header); + GC_REG_TRAV(scheme_ir_toplevel_type, toplevel_obj); + GC_REG_TRAV(scheme_ir_quote_syntax_type, local_obj); GC_REG_TRAV(scheme_quote_compilation_type, small_object); - GC_REG_TRAV(_scheme_compiled_values_types_, bad_trav); + GC_REG_TRAV(_scheme_ir_values_types_, bad_trav); GC_REG_TRAV(scheme_prefix_type, prefix_val); GC_REG_TRAV(scheme_resolve_prefix_type, resolve_prefix_val); @@ -655,7 +655,7 @@ void scheme_register_traversers(void) GC_REG_TRAV(scheme_true_type, small_atomic_obj); GC_REG_TRAV(scheme_false_type, small_atomic_obj); GC_REG_TRAV(scheme_void_type, small_atomic_obj); - GC_REG_TRAV(scheme_syntax_compiler_type, syntax_compiler); + GC_REG_TRAV(scheme_primitive_syntax_type, syntax_compiler); GC_REG_TRAV(scheme_macro_type, small_object); GC_REG_TRAV(scheme_box_type, small_object); GC_REG_TRAV(scheme_thread_type, thread_val); diff --git a/racket/src/racket/src/validate.c b/racket/src/racket/src/validate.c index d914d5cd2d..60be18912b 100644 --- a/racket/src/racket/src/validate.c +++ b/racket/src/racket/src/validate.c @@ -31,8 +31,8 @@ where the abstract values are "not available", "value", "boxed value", "syntax object", or "global array". */ -/* FIXME: validation doesn't check CLOS_SINGLE_RESULT or - CLOS_PRESERVES_MARKS. (Maybe check them in the JIT pass?) */ +/* FIXME: validation doesn't check LAMBDA_SINGLE_RESULT or + LAMBDA_PRESERVES_MARKS. (Maybe check them in the JIT pass?) */ static int validate_expr(Mz_CPort *port, Scheme_Object *expr, char *stack, Validate_TLS tls, @@ -320,7 +320,7 @@ static int define_values_validate(Scheme_Object *data, Mz_CPort *port, /* It's a lift. Check whether it needs to take reference arguments and/or install reference info. */ Scheme_Object *app_rator; - Scheme_Closure_Data *data = NULL; + Scheme_Lambda *data = NULL; int tp = pos - (num_toplevels + num_stxes + (num_stxes ? 1 : 0)); mzshort *a, *new_a = NULL; @@ -333,10 +333,10 @@ static int define_values_validate(Scheme_Object *data, Mz_CPort *port, app_rator = val; while (1) { if (SAME_TYPE(SCHEME_TYPE(app_rator), scheme_closure_type)) { - data = SCHEME_COMPILED_CLOS_CODE(app_rator); + data = SCHEME_CLOSURE_CODE(app_rator); break; - } else if (SAME_TYPE(SCHEME_TYPE(app_rator), scheme_unclosed_procedure_type)) { - data = (Scheme_Closure_Data *)app_rator; + } else if (SAME_TYPE(SCHEME_TYPE(app_rator), scheme_lambda_type)) { + data = (Scheme_Lambda *)app_rator; break; } else if (SAME_TYPE(SCHEME_TYPE(app_rator), scheme_toplevel_type)) { /* Record an indirection */ @@ -353,16 +353,16 @@ static int define_values_validate(Scheme_Object *data, Mz_CPort *port, } } if (data) { - if (SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_HAS_TYPED_ARGS) { + if (SCHEME_LAMBDA_FLAGS(data) & LAMBDA_HAS_TYPED_ARGS) { int sz; sz = data->num_params; new_a = MALLOC_N_ATOMIC(mzshort, (sz + 2)); new_a[0] = -sz; - new_a[sz+1] = !!(SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_HAS_REST); + new_a[sz+1] = !!(SCHEME_LAMBDA_FLAGS(data) & LAMBDA_HAS_REST); for (i = 0; i < sz; i++) { int ct; ct = scheme_boxmap_get(data->closure_map, i, data->closure_size); - if (ct == CLOS_TYPE_BOXED) + if (ct == LAMBDA_TYPE_BOXED) new_a[i + 1] = 1; else new_a[i + 1] = 0; @@ -597,7 +597,7 @@ static void case_lambda_validate(Scheme_Object *data, Mz_CPort *port, char *stac for (i = 0; i < seq->count; i++) { e = seq->array[i]; - if (!SAME_TYPE(SCHEME_TYPE(e), scheme_unclosed_procedure_type) + if (!SAME_TYPE(SCHEME_TYPE(e), scheme_lambda_type) && !SAME_TYPE(SCHEME_TYPE(e), scheme_closure_type)) scheme_ill_formed_code(port); validate_expr(port, e, stack, tls, depth, letlimit, delta, @@ -799,16 +799,16 @@ int validate_rator_wants_box(Scheme_Object *app_rator, int pos, Validate_TLS tls, int num_toplevels, int num_stxes, int num_lifts, void *tl_use_map) { - Scheme_Closure_Data *data = NULL; + Scheme_Lambda *data = NULL; Scheme_Type ty; while (1) { ty = SCHEME_TYPE(app_rator); if (SAME_TYPE(ty, scheme_closure_type)) { - data = SCHEME_COMPILED_CLOS_CODE(app_rator); + data = SCHEME_CLOSURE_CODE(app_rator); break; - } else if (SAME_TYPE(ty, scheme_unclosed_procedure_type)) { - data = (Scheme_Closure_Data *)app_rator; + } else if (SAME_TYPE(ty, scheme_lambda_type)) { + data = (Scheme_Lambda *)app_rator; break; } else if (SAME_TYPE(ty, scheme_toplevel_type)) { int p; @@ -876,11 +876,11 @@ int validate_rator_wants_box(Scheme_Object *app_rator, int pos, return 0; } - if (SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_HAS_TYPED_ARGS) { + if (SCHEME_LAMBDA_FLAGS(data) & LAMBDA_HAS_TYPED_ARGS) { if (pos < data->num_params) { int ct; ct = scheme_boxmap_get(data->closure_map, pos, data->closure_size); - if (ct == CLOS_TYPE_BOXED) + if (ct == LAMBDA_TYPE_BOXED) return 1; } } @@ -903,7 +903,7 @@ void scheme_validate_closure(Mz_CPort *port, Scheme_Object *expr, mzshort *tl_state, mzshort tl_timestamp, int self_pos_in_closure, Scheme_Hash_Tree *procs) { - Scheme_Closure_Data *data = (Scheme_Closure_Data *)expr; + Scheme_Lambda *data = (Scheme_Lambda *)expr; int i, sz, cnt, base, base2; char *new_stack; struct Validate_Clearing *vc; @@ -918,7 +918,7 @@ void scheme_validate_closure(Mz_CPort *port, Scheme_Object *expr, cnt = data->num_params; base = sz - cnt; - if (SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_HAS_TYPED_ARGS) { + if (SCHEME_LAMBDA_FLAGS(data) & LAMBDA_HAS_TYPED_ARGS) { base2 = data->closure_size; for (i = 0; i < cnt; i++) { new_stack[base + i] = closure_stack[base2 + i]; @@ -973,7 +973,7 @@ void scheme_validate_closure(Mz_CPort *port, Scheme_Object *expr, tl_use_map = data->tl_map; } - validate_expr(port, data->code, new_stack, tls, sz, sz, base, + validate_expr(port, data->body, new_stack, tls, sz, sz, base, num_toplevels, num_stxes, num_lifts, tl_use_map, tl_state, tl_timestamp, NULL, 0, 0, vc, 1, 0, procs, -1, NULL); @@ -986,22 +986,22 @@ static Scheme_Hash_Tree *as_nonempty_procs(Scheme_Hash_Tree *procs) return procs; } -static void validate_unclosed_procedure(Mz_CPort *port, Scheme_Object *expr, - char *stack, Validate_TLS tls, - int depth, int delta, - int num_toplevels, int num_stxes, int num_lifts, void *tl_use_map, - mzshort *tl_state, mzshort tl_timestamp, - Scheme_Object *app_rator, int proc_with_refs_ok, - int self_pos, Scheme_Hash_Tree *procs) +static void validate_lambda(Mz_CPort *port, Scheme_Object *expr, + char *stack, Validate_TLS tls, + int depth, int delta, + int num_toplevels, int num_stxes, int num_lifts, void *tl_use_map, + mzshort *tl_state, mzshort tl_timestamp, + Scheme_Object *app_rator, int proc_with_refs_ok, + int self_pos, Scheme_Hash_Tree *procs) { - Scheme_Closure_Data *data = (Scheme_Closure_Data *)expr; + Scheme_Lambda *data = (Scheme_Lambda *)expr; int i, cnt, q, p, sz, base, stack_delta, vld, self_pos_in_closure = -1, typed_arg = 0; mzshort *map; char *closure_stack; Scheme_Object *proc; Scheme_Hash_Tree *new_procs = NULL; - if (SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_HAS_TYPED_ARGS) { + if (SCHEME_LAMBDA_FLAGS(data) & LAMBDA_HAS_TYPED_ARGS) { sz = data->closure_size + data->num_params; } else { sz = data->closure_size; @@ -1013,19 +1013,19 @@ static void validate_unclosed_procedure(Mz_CPort *port, Scheme_Object *expr, else closure_stack = NULL; - if (SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_HAS_TYPED_ARGS) { + if (SCHEME_LAMBDA_FLAGS(data) & LAMBDA_HAS_TYPED_ARGS) { cnt = data->num_params; base = sz - cnt; for (i = 0; i < cnt; i++) { int ct; ct = scheme_boxmap_get(map, i, data->closure_size); - if (ct == CLOS_TYPE_BOXED) { + if (ct == LAMBDA_TYPE_BOXED) { vld = VALID_BOX; typed_arg = 1; } else if (ct) { - if ((ct - CLOS_TYPE_TYPE_OFFSET) > SCHEME_MAX_LOCAL_TYPE) + if ((ct - LAMBDA_TYPE_TYPE_OFFSET) > SCHEME_MAX_LOCAL_TYPE) scheme_ill_formed_code(port); - vld = (VALID_TYPED + (ct - CLOS_TYPE_TYPE_OFFSET)); + vld = (VALID_TYPED + (ct - LAMBDA_TYPE_TYPE_OFFSET)); typed_arg = 1; } else vld = VALID_VAL; @@ -1052,14 +1052,14 @@ static void validate_unclosed_procedure(Mz_CPort *port, Scheme_Object *expr, else if (vld == VALID_BOX_NOCLEAR) vld = VALID_BOX; - if (SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_HAS_TYPED_ARGS) { + if (SCHEME_LAMBDA_FLAGS(data) & LAMBDA_HAS_TYPED_ARGS) { int pos = data->num_params + i; int ct; ct = scheme_boxmap_get(map, pos, data->closure_size); - if (ct == CLOS_TYPE_BOXED) + if (ct == LAMBDA_TYPE_BOXED) scheme_ill_formed_code(port); - if (ct > CLOS_TYPE_TYPE_OFFSET) { - if (vld != (VALID_TYPED + (ct - CLOS_TYPE_TYPE_OFFSET))) + if (ct > LAMBDA_TYPE_TYPE_OFFSET) { + if (vld != (VALID_TYPED + (ct - LAMBDA_TYPE_TYPE_OFFSET))) vld = VALID_NOT; } else if (vld > VALID_TYPED) vld = VALID_NOT; @@ -1085,11 +1085,11 @@ static void validate_unclosed_procedure(Mz_CPort *port, Scheme_Object *expr, tl_timestamp++; /* closure delays use; needed for self-use <= check */ - if (SCHEME_RPAIRP(data->code)) { + if (SCHEME_RPAIRP(data->body)) { /* Delay validation */ Scheme_Object *vec; vec = scheme_make_vector(11, NULL); - SCHEME_VEC_ELS(vec)[0] = SCHEME_CAR(data->code); + SCHEME_VEC_ELS(vec)[0] = SCHEME_CAR(data->body); SCHEME_VEC_ELS(vec)[1] = (Scheme_Object *)closure_stack; SCHEME_VEC_ELS(vec)[2] = (Scheme_Object *)tls; SCHEME_VEC_ELS(vec)[3] = scheme_make_integer(num_toplevels); @@ -1100,7 +1100,7 @@ static void validate_unclosed_procedure(Mz_CPort *port, Scheme_Object *expr, SCHEME_VEC_ELS(vec)[8] = tl_use_map ? tl_use_map : scheme_false; SCHEME_VEC_ELS(vec)[9] = tl_state ? (Scheme_Object *)tl_state : scheme_false; SCHEME_VEC_ELS(vec)[10] = scheme_make_integer(tl_timestamp); - SCHEME_CAR(data->code) = vec; + SCHEME_CAR(data->body) = vec; } else scheme_validate_closure(port, expr, closure_stack, tls, num_toplevels, num_stxes, num_lifts, tl_use_map, @@ -1771,10 +1771,10 @@ static int validate_expr(Mz_CPort *port, Scheme_Object *expr, result = validate_join_const(result, expected_results); } break; - case scheme_unclosed_procedure_type: + case scheme_lambda_type: { no_typed(need_local_type, port); - validate_unclosed_procedure(port, expr, stack, tls, depth, delta, + validate_lambda(port, expr, stack, tls, depth, delta, num_toplevels, num_stxes, num_lifts, tl_use_map, tl_state, tl_timestamp, app_rator, proc_with_refs_ok, -1, procs); @@ -1847,7 +1847,7 @@ static int validate_expr(Mz_CPort *port, Scheme_Object *expr, case scheme_letrec_type: { Scheme_Letrec *l = (Scheme_Letrec *)expr; - Scheme_Closure_Data *data; + Scheme_Lambda *data; int i, c; c = l->count; @@ -1856,7 +1856,7 @@ static int validate_expr(Mz_CPort *port, Scheme_Object *expr, scheme_ill_formed_code(port); for (i = 0; i < c; i++) { - if (!SAME_TYPE(SCHEME_TYPE(l->procs[i]), scheme_unclosed_procedure_type)) + if (!SAME_TYPE(SCHEME_TYPE(l->procs[i]), scheme_lambda_type)) scheme_ill_formed_code(port); } @@ -1866,8 +1866,8 @@ static int validate_expr(Mz_CPort *port, Scheme_Object *expr, scheme_ill_formed_code(port); #endif stack[delta + i] = VALID_VAL; - data = (Scheme_Closure_Data *)l->procs[i]; - if (SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_HAS_TYPED_ARGS) { + data = (Scheme_Lambda *)l->procs[i]; + if (SCHEME_LAMBDA_FLAGS(data) & LAMBDA_HAS_TYPED_ARGS) { /* If any arguments (as opposed to closure slots) are typed, then add the procedure to `procs': */ int j; @@ -1884,7 +1884,7 @@ static int validate_expr(Mz_CPort *port, Scheme_Object *expr, } for (i = 0; i < c; i++) { - validate_unclosed_procedure(port, l->procs[i], stack, tls, depth, delta, + validate_lambda(port, l->procs[i], stack, tls, depth, delta, num_toplevels, num_stxes, num_lifts, tl_use_map, tl_state, tl_timestamp, NULL, 1, i, procs); @@ -2053,7 +2053,7 @@ static int validate_expr(Mz_CPort *port, Scheme_Object *expr, result_ignored, vc, tailpos, procs); result = validate_join_const(result, expected_results); break; - case scheme_compiled_local_type: + case scheme_ir_local_type: { scheme_ill_formed_code(port); } @@ -2066,15 +2066,15 @@ static int validate_expr(Mz_CPort *port, Scheme_Object *expr, /* If the closure is not empty, then it must be from 3-D code (where PLT_VALIDATE_COMPILE is set), and validation is not our responsibility here: */ - && (SCHEME_COMPILED_CLOS_CODE(expr)->closure_size == 0)) { - Scheme_Closure_Data *data; + && (SCHEME_CLOSURE_CODE(expr)->closure_size == 0)) { + Scheme_Lambda *data; no_typed(need_local_type, port); - expr = (Scheme_Object *)SCHEME_COMPILED_CLOS_CODE(expr); - data = (Scheme_Closure_Data *)expr; - if (SCHEME_CLOSURE_DATA_FLAGS(data) & CLOS_VALIDATED) { + expr = (Scheme_Object *)SCHEME_CLOSURE_CODE(expr); + data = (Scheme_Lambda *)expr; + if (SCHEME_LAMBDA_FLAGS(data) & LAMBDA_VALIDATED) { /* Done with this one. */ } else { - SCHEME_CLOSURE_DATA_FLAGS(data) |= CLOS_VALIDATED; + SCHEME_LAMBDA_FLAGS(data) |= LAMBDA_VALIDATED; did_one = 0; goto top; }