static int CHECK_PUT (void *, struct jcf_partial *, int);
static int
-CHECK_PUT (ptr, state, i)
- void *ptr;
- struct jcf_partial *state;
- int i;
+CHECK_PUT (void *ptr, struct jcf_partial *state, int i)
{
if ((unsigned char *) ptr < state->chunk->data
|| (unsigned char *) ptr + i > state->chunk->data + state->chunk->size)
However, if DATA is NULL and SIZE>0, allocate a buffer as well. */
static struct chunk *
-alloc_chunk (last, data, size, work)
- struct chunk *last;
- unsigned char *data;
- int size;
- struct obstack *work;
+alloc_chunk (struct chunk *last, unsigned char *data,
+ int size, struct obstack *work)
{
struct chunk *chunk = (struct chunk *)
obstack_alloc (work, sizeof(struct chunk));
static int CHECK_OP (struct jcf_partial *);
static int
-CHECK_OP (state)
- struct jcf_partial *state;
+CHECK_OP (struct jcf_partial *state)
{
if (state->bytecode.ptr > state->bytecode.limit)
abort ();
#endif
static unsigned char *
-append_chunk (data, size, state)
- unsigned char *data;
- int size;
- struct jcf_partial *state;
+append_chunk (unsigned char *data, int size, struct jcf_partial *state)
{
state->chunk = alloc_chunk (state->chunk, data, size, state->chunk_obstack);
if (state->first == NULL)
}
static void
-append_chunk_copy (data, size, state)
- unsigned char *data;
- int size;
- struct jcf_partial *state;
+append_chunk_copy (unsigned char *data, int size, struct jcf_partial *state)
{
unsigned char *ptr = append_chunk (NULL, size, state);
memcpy (ptr, data, size);
}
\f
static struct jcf_block *
-gen_jcf_label (state)
- struct jcf_partial *state;
+gen_jcf_label (struct jcf_partial *state)
{
struct jcf_block *block = (struct jcf_block *)
obstack_alloc (state->chunk_obstack, sizeof (struct jcf_block));
}
static void
-finish_jcf_block (state)
- struct jcf_partial *state;
+finish_jcf_block (struct jcf_partial *state)
{
struct jcf_block *block = state->last_block;
struct jcf_relocation *reloc;
}
static void
-define_jcf_label (label, state)
- struct jcf_block *label;
- struct jcf_partial *state;
+define_jcf_label (struct jcf_block *label, struct jcf_partial *state)
{
if (state->last_block != NULL)
finish_jcf_block (state);
}
static struct jcf_block *
-get_jcf_label_here (state)
- struct jcf_partial *state;
+get_jcf_label_here (struct jcf_partial *state)
{
if (state->last_block != NULL && BUFFER_LENGTH (&state->bytecode) == 0)
return state->last_block;
/* Note a line number entry for the current PC and given LINE. */
static void
-put_linenumber (line, state)
- int line;
- struct jcf_partial *state;
+put_linenumber (int line, struct jcf_partial *state)
{
struct jcf_block *label = get_jcf_label_here (state);
if (label->linenumber > 0)
in the range (START_LABEL, END_LABEL). */
static struct jcf_handler *
-alloc_handler (start_label, end_label, state)
- struct jcf_block *start_label;
- struct jcf_block *end_label;
- struct jcf_partial *state;
+alloc_handler (struct jcf_block *start_label, struct jcf_block *end_label,
+ struct jcf_partial *state)
{
struct jcf_handler *handler = (struct jcf_handler *)
obstack_alloc (state->chunk_obstack, sizeof (struct jcf_handler));
((struct localvar_info**) state->localvars.ptr - localvar_buffer)
static void
-localvar_alloc (decl, state)
- tree decl;
- struct jcf_partial *state;
+localvar_alloc (tree decl, struct jcf_partial *state)
{
struct jcf_block *start_label = get_jcf_label_here (state);
int wide = TYPE_IS_WIDE (TREE_TYPE (decl));
}
static void
-localvar_free (decl, state)
- tree decl;
- struct jcf_partial *state;
+localvar_free (tree decl, struct jcf_partial *state)
{
struct jcf_block *end_label = get_jcf_label_here (state);
int index = DECL_LOCAL_INDEX (decl);
a field (FIELD_DECL or VAR_DECL, if static), as encoded in a .class file. */
static int
-get_access_flags (decl)
- tree decl;
+get_access_flags (tree decl)
{
int flags = 0;
int isfield = TREE_CODE (decl) == FIELD_DECL || TREE_CODE (decl) == VAR_DECL;
/* Write the list of segments starting at CHUNKS to STREAM. */
static void
-write_chunks (stream, chunks)
- FILE* stream;
- struct chunk *chunks;
+write_chunks (FILE* stream, struct chunk *chunks)
{
for (; chunks != NULL; chunks = chunks->next)
fwrite (chunks->data, chunks->size, 1, stream);
(Caller is responsible for doing NOTE_PUSH.) */
static void
-push_constant1 (index, state)
- HOST_WIDE_INT index;
- struct jcf_partial *state;
+push_constant1 (HOST_WIDE_INT index, struct jcf_partial *state)
{
RESERVE (3);
if (index < 256)
(Caller is responsible for doing NOTE_PUSH.) */
static void
-push_constant2 (index, state)
- HOST_WIDE_INT index;
- struct jcf_partial *state;
+push_constant2 (HOST_WIDE_INT index, struct jcf_partial *state)
{
RESERVE (3);
OP1 (OPCODE_ldc2_w);
Caller is responsible for doing NOTE_PUSH. */
static void
-push_int_const (i, state)
- HOST_WIDE_INT i;
- struct jcf_partial *state;
+push_int_const (HOST_WIDE_INT i, struct jcf_partial *state)
{
RESERVE(3);
if (i >= -1 && i <= 5)
}
static int
-find_constant_wide (lo, hi, state)
- HOST_WIDE_INT lo, hi;
- struct jcf_partial *state;
+find_constant_wide (HOST_WIDE_INT lo, HOST_WIDE_INT hi,
+ struct jcf_partial *state)
{
HOST_WIDE_INT w1, w2;
lshift_double (lo, hi, -32, 64, &w1, &w2, 1);
Return the index in the constant pool. */
static int
-find_constant_index (value, state)
- tree value;
- struct jcf_partial *state;
+find_constant_index (tree value, struct jcf_partial *state)
{
if (TREE_CODE (value) == INTEGER_CST)
{
Caller is responsible for doing NOTE_PUSH. */
static void
-push_long_const (lo, hi, state)
- HOST_WIDE_INT lo, hi;
- struct jcf_partial *state;
+push_long_const (HOST_WIDE_INT lo, HOST_WIDE_INT hi, struct jcf_partial *state)
{
HOST_WIDE_INT highpart, dummy;
jint lowpart = WORD_TO_INT (lo);
}
static void
-field_op (field, opcode, state)
- tree field;
- int opcode;
- struct jcf_partial *state;
+field_op (tree field, int opcode, struct jcf_partial *state)
{
int index = find_fieldref_index (&state->cpool, field);
RESERVE (3);
opcodes typically depend on the operand type. */
static int
-adjust_typed_op (type, max)
- tree type;
- int max;
+adjust_typed_op (tree type, int max)
{
switch (TREE_CODE (type))
{
}
static void
-maybe_wide (opcode, index, state)
- int opcode, index;
- struct jcf_partial *state;
+maybe_wide (int opcode, int index, struct jcf_partial *state)
{
if (index >= 256)
{
(The new words get inserted at stack[SP-size-offset].) */
static void
-emit_dup (size, offset, state)
- int size, offset;
- struct jcf_partial *state;
+emit_dup (int size, int offset, struct jcf_partial *state)
{
int kind;
if (size == 0)
}
static void
-emit_pop (size, state)
- int size;
- struct jcf_partial *state;
+emit_pop (int size, struct jcf_partial *state)
{
RESERVE (1);
OP1 (OPCODE_pop - 1 + size);
}
static void
-emit_iinc (var, value, state)
- tree var;
- HOST_WIDE_INT value;
- struct jcf_partial *state;
+emit_iinc (tree var, HOST_WIDE_INT value, struct jcf_partial *state)
{
int slot = DECL_LOCAL_INDEX (var);
}
static void
-emit_load_or_store (var, opcode, state)
- tree var; /* Variable to load from or store into. */
- int opcode; /* Either OPCODE_iload or OPCODE_istore. */
- struct jcf_partial *state;
+emit_load_or_store (tree var, /* Variable to load from or store into. */
+ int opcode, /* Either OPCODE_iload or OPCODE_istore. */
+ struct jcf_partial *state)
{
tree type = TREE_TYPE (var);
int kind = adjust_typed_op (type, 4);
}
static void
-emit_load (var, state)
- tree var;
- struct jcf_partial *state;
+emit_load (tree var, struct jcf_partial *state)
{
emit_load_or_store (var, OPCODE_iload, state);
NOTE_PUSH (TYPE_IS_WIDE (TREE_TYPE (var)) ? 2 : 1);
}
static void
-emit_store (var, state)
- tree var;
- struct jcf_partial *state;
+emit_store (tree var, struct jcf_partial *state)
{
emit_load_or_store (var, OPCODE_istore, state);
NOTE_POP (TYPE_IS_WIDE (TREE_TYPE (var)) ? 2 : 1);
}
static void
-emit_unop (opcode, type, state)
- enum java_opcode opcode;
- tree type ATTRIBUTE_UNUSED;
- struct jcf_partial *state;
+emit_unop (enum java_opcode opcode, tree type ATTRIBUTE_UNUSED,
+ struct jcf_partial *state)
{
RESERVE(1);
OP1 (opcode);
}
static void
-emit_binop (opcode, type, state)
- enum java_opcode opcode;
- tree type;
- struct jcf_partial *state;
+emit_binop (enum java_opcode opcode, tree type, struct jcf_partial *state)
{
int size = TYPE_IS_WIDE (type) ? 2 : 1;
RESERVE(1);
}
static void
-emit_reloc (value, kind, target, state)
- HOST_WIDE_INT value;
- int kind;
- struct jcf_block *target;
- struct jcf_partial *state;
+emit_reloc (HOST_WIDE_INT value, int kind,
+ struct jcf_block *target, struct jcf_partial *state)
{
struct jcf_relocation *reloc = (struct jcf_relocation *)
obstack_alloc (state->chunk_obstack, sizeof (struct jcf_relocation));
}
static void
-emit_switch_reloc (label, state)
- struct jcf_block *label;
- struct jcf_partial *state;
+emit_switch_reloc (struct jcf_block *label, struct jcf_partial *state)
{
emit_reloc (RELOCATION_VALUE_0, BLOCK_START_RELOC, label, state);
}
but re-uses an existing case reloc. */
static void
-emit_case_reloc (reloc, state)
- struct jcf_relocation *reloc;
- struct jcf_partial *state;
+emit_case_reloc (struct jcf_relocation *reloc, struct jcf_partial *state)
{
struct jcf_block *block = state->last_block;
reloc->next = block->u.relocations;
The opcode is OPCODE, the inverted opcode is INV_OPCODE. */
static void
-emit_if (target, opcode, inv_opcode, state)
- struct jcf_block *target;
- int opcode, inv_opcode;
- struct jcf_partial *state;
+emit_if (struct jcf_block *target, int opcode, int inv_opcode,
+ struct jcf_partial *state)
{
RESERVE(3);
OP1 (opcode);
}
static void
-emit_goto (target, state)
- struct jcf_block *target;
- struct jcf_partial *state;
+emit_goto (struct jcf_block *target, struct jcf_partial *state)
{
RESERVE(3);
OP1 (OPCODE_goto);
}
static void
-emit_jsr (target, state)
- struct jcf_block *target;
- struct jcf_partial *state;
+emit_jsr (struct jcf_block *target, struct jcf_partial *state)
{
RESERVE(3);
OP1 (OPCODE_jsr);
may be able to optimize away GOTO TRUE_LABEL; TRUE_LABEL:) */
static void
-generate_bytecode_conditional (exp, true_label, false_label,
- true_branch_first, state)
- tree exp;
- struct jcf_block *true_label;
- struct jcf_block *false_label;
- int true_branch_first;
- struct jcf_partial *state;
+generate_bytecode_conditional (tree exp,
+ struct jcf_block *true_label,
+ struct jcf_block *false_label,
+ int true_branch_first,
+ struct jcf_partial *state)
{
tree exp0, exp1, type;
int save_SP = state->code_SP;
emit label that is LIMIT). */
static void
-call_cleanups (limit, state)
- struct jcf_block *limit;
- struct jcf_partial *state;
+call_cleanups (struct jcf_block *limit, struct jcf_partial *state)
{
struct jcf_block *block = state->labeled_blocks;
for (; block != limit; block = block->next)
}
static void
-generate_bytecode_return (exp, state)
- tree exp;
- struct jcf_partial *state;
+generate_bytecode_return (tree exp, struct jcf_partial *state)
{
tree return_type = TREE_TYPE (TREE_TYPE (state->current_method));
int returns_void = TREE_CODE (return_type) == VOID_TYPE;
TARGET is one of STACK_TARGET or IGNORE_TARGET. */
static void
-generate_bytecode_insns (exp, target, state)
- tree exp;
- int target;
- struct jcf_partial *state;
+generate_bytecode_insns (tree exp, int target, struct jcf_partial *state)
{
tree type, arg;
enum java_opcode jopcode;
}
static void
-perform_relocations (state)
- struct jcf_partial *state;
+perform_relocations (struct jcf_partial *state)
{
struct jcf_block *block;
struct jcf_relocation *reloc;
}
static void
-init_jcf_state (state, work)
- struct jcf_partial *state;
- struct obstack *work;
+init_jcf_state (struct jcf_partial *state, struct obstack *work)
{
state->chunk_obstack = work;
state->first = state->chunk = NULL;
}
static void
-init_jcf_method (state, method)
- struct jcf_partial *state;
- tree method;
+init_jcf_method (struct jcf_partial *state, tree method)
{
state->current_method = method;
state->blocks = state->last_block = NULL;
}
static void
-release_jcf_state (state)
- struct jcf_partial *state;
+release_jcf_state (struct jcf_partial *state)
{
CPOOL_FINISH (&state->cpool);
obstack_free (state->chunk_obstack, state->first);
static GTY(()) tree SourceFile_node;
static struct chunk *
-generate_classfile (clas, state)
- tree clas;
- struct jcf_partial *state;
+generate_classfile (tree clas, struct jcf_partial *state)
{
struct chunk *cpool_chunk;
const char *source_file, *s;
static GTY(()) tree Synthetic_node;
static unsigned char *
-append_synthetic_attribute (state)
- struct jcf_partial *state;
+append_synthetic_attribute (struct jcf_partial *state)
{
unsigned char *ptr = append_chunk (NULL, 6, state);
int i;
}
static void
-append_gcj_attribute (state, class)
- struct jcf_partial *state;
- tree class;
+append_gcj_attribute (struct jcf_partial *state, tree class)
{
unsigned char *ptr;
int i;
static tree InnerClasses_node;
static void
-append_innerclasses_attribute (state, class)
- struct jcf_partial *state;
- tree class;
+append_innerclasses_attribute (struct jcf_partial *state, tree class)
{
tree orig_decl = TYPE_NAME (class);
tree current, decl;
}
static void
-append_innerclasses_attribute_entry (state, decl, name)
- struct jcf_partial *state;
- tree decl, name;
+append_innerclasses_attribute_entry (struct jcf_partial *state,
+ tree decl, tree name)
{
int icii, icaf;
int ocii = 0, ini = 0;
}
static char *
-make_class_file_name (clas)
- tree clas;
+make_class_file_name (tree clas)
{
const char *dname, *cname, *slash;
char *r;
The output .class file name is make_class_file_name(CLAS). */
void
-write_classfile (clas)
- tree clas;
+write_classfile (tree clas)
{
struct obstack *work = &temporary_obstack;
struct jcf_partial state[1];
OSDN Git Service
