contour from before the beginning of the contour.
This is also done if STACK_LEVEL is nonzero. */
-void
+static void
fixup_gotos (thisblock, stack_level, cleanup_list, first_insn, dont_jump_in)
struct nesting *thisblock;
rtx stack_level;
if (output_bytecode)
{
- bc_fixup_gotos (thisblock, stack_level, cleanup_list, first_insn, dont_jump_in);
+ /* ??? The second arg is the bc stack level, which is not the same
+ as STACK_LEVEL. I have no idea what should go here, so I'll
+ just pass 0. */
+ bc_fixup_gotos (thisblock, 0, cleanup_list, first_insn, dont_jump_in);
return;
}
/* When exiting a binding contour, process all pending gotos requiring fixups.
Note: STACK_DEPTH is not altered.
- The arguments are currently not used in the bytecode compiler, but we may need
- them one day for languages other than C.
+ The arguments are currently not used in the bytecode compiler, but we may
+ need them one day for languages other than C.
THISBLOCK is the structure that describes the block being exited.
STACK_LEVEL is the rtx for the stack level to restore exiting this contour.
whose truth is to be tested; if EXITFLAG is nonzero this conditional
is to be visible to exit_something. It is assumed that the caller
has pushed the previous context on the cond stack. */
-void
+
+static void
bc_expand_start_cond (cond, exitflag)
tree cond;
int exitflag;
/* Generate the label for the end of an if with
no else- clause. */
-void
+
+static void
bc_expand_end_cond ()
{
struct nesting *thiscond = cond_stack;
/* Generate code for the start of the else- clause of
an if-then-else. */
-void
+
+static void
bc_expand_start_else ()
{
struct nesting *thiscond = cond_stack;
}
/* End a loop. */
+
static void
bc_expand_end_loop ()
{
bc_expand_expr (cond);
bc_expand_goto_internal (xjumpifnot,
BYTECODE_BC_LABEL (whichloop->exit_label),
- NULL_RTX);
+ NULL_TREE);
}
else
do_jump (cond, whichloop->data.loop.end_label, NULL_RTX);
DONT_JUMP_IN is nonzero if it is not valid to jump into this
contour. */
-void
+static void
bc_expand_end_bindings (vars, mark_ends, dont_jump_in)
tree vars;
int mark_ends;
compiler sometimes emits cleanups without variables and we will
have to deal with those too. */
-void
+static void
bc_expand_decl (decl, cleanup)
tree decl;
tree cleanup;
{
int was_used = TREE_USED (decl);
+ if (output_bytecode)
+ {
+ bc_expand_decl_init (decl);
+ return;
+ }
+
/* If this is a CONST_DECL, we don't have to generate any code, but
if DECL_INITIAL is a constant, call expand_expr to force TREE_CST_RTL
to be set while in the obstack containing the constant. If we don't
using newlocalSI and set local variable, which is a pointer to the
storage. */
+static void
bc_expand_variable_local_init (decl)
tree decl;
{
/* Emit code to initialize a declaration. */
-void
+
+static void
bc_expand_decl_init (decl)
tree decl;
{
/* Enter a case statement. It is assumed that the caller has pushed
the current context onto the case stack. */
-void
+
+static void
bc_expand_start_case (thiscase, expr, type, printname)
struct nesting *thiscase;
tree expr;
bytecode compiler, which was based on gcc 1.37. It should be
merged into pushcase. */
-int
+static int
bc_pushcase (value, label)
tree value;
tree label;
/* Check that all enumeration literals are covered by the case
expressions of a switch. Also warn if there are any cases
that are not elements of the enumerated type. */
-void
+
+static void
bc_check_for_full_enumeration_handling (type)
tree type;
{
/* Terminate a case statement. EXPR is the original index
expression. */
-void
+
+static void
bc_expand_end_case (expr)
tree expr;
{
/* Return unique bytecode ID. */
+
int
bc_new_uid ()
{