static void before_call(int function_index, void* user_data) {
Context* ctx = user_data;
out_opcode(&ctx->buf, WASM_OPCODE_CALL);
/* defined functions are always after all imports */
out_leb128(&ctx->buf, ctx->module->imports.size + function_index,
"func index");
}
static WasmParserCookie before_invoke(WasmSourceLocation loc,
const char* invoke_name,
int invoke_function_index,
void* user_data) {
Context* ctx = user_data;
if (!ctx->in_assert) {
if (g_verbose)
printf("; before invoke_%d\n", ctx->invoke_count);
init_output_buffer(&ctx->buf, INITIAL_OUTPUT_BUFFER_CAPACITY);
}
out_opcode(&ctx->buf, WASM_OPCODE_CALL);
/* defined functions are always after all imports */
out_leb128(&ctx->buf, ctx->module->imports.size + invoke_function_index,
"invoke func index");
return (WasmParserCookie)invoke_function_index;
}
static void
process_entries (segT seg, struct line_entry *e)
{
unsigned filenum = 1;
unsigned line = 1;
unsigned column = 0;
unsigned isa = 0;
unsigned flags = DWARF2_LINE_DEFAULT_IS_STMT ? DWARF2_FLAG_IS_STMT : 0;
fragS *last_frag = NULL, *frag;
addressT last_frag_ofs = 0, frag_ofs;
symbolS *last_lab = NULL, *lab;
struct line_entry *next;
do
{
int line_delta;
if (filenum != e->loc.filenum)
{
filenum = e->loc.filenum;
out_opcode (DW_LNS_set_file);
out_uleb128 (filenum);
}
if (column != e->loc.column)
{
column = e->loc.column;
out_opcode (DW_LNS_set_column);
out_uleb128 (column);
}
if (e->loc.discriminator != 0)
{
out_opcode (DW_LNS_extended_op);
out_leb128 (1 + sizeof_leb128 (e->loc.discriminator, 0));
out_opcode (DW_LNE_set_discriminator);
out_uleb128 (e->loc.discriminator);
}
if (isa != e->loc.isa)
{
isa = e->loc.isa;
out_opcode (DW_LNS_set_isa);
out_uleb128 (isa);
}
if ((e->loc.flags ^ flags) & DWARF2_FLAG_IS_STMT)
{
flags = e->loc.flags;
out_opcode (DW_LNS_negate_stmt);
}
if (e->loc.flags & DWARF2_FLAG_BASIC_BLOCK)
out_opcode (DW_LNS_set_basic_block);
if (e->loc.flags & DWARF2_FLAG_PROLOGUE_END)
out_opcode (DW_LNS_set_prologue_end);
if (e->loc.flags & DWARF2_FLAG_EPILOGUE_BEGIN)
out_opcode (DW_LNS_set_epilogue_begin);
/* Don't try to optimize away redundant entries; gdb wants two
entries for a function where the code starts on the same line as
the {, and there's no way to identify that case here. Trust gcc
to optimize appropriately. */
line_delta = e->loc.line - line;
lab = e->label;
frag = symbol_get_frag (lab);
frag_ofs = S_GET_VALUE (lab);
if (last_frag == NULL)
{
out_set_addr (lab);
out_inc_line_addr (line_delta, 0);
}
else if (frag == last_frag && ! DWARF2_USE_FIXED_ADVANCE_PC)
out_inc_line_addr (line_delta, frag_ofs - last_frag_ofs);
else
relax_inc_line_addr (line_delta, lab, last_lab);
line = e->loc.line;
last_lab = lab;
last_frag = frag;
last_frag_ofs = frag_ofs;
next = e->next;
free (e);
e = next;
}
while (e);
/* Emit a DW_LNE_end_sequence for the end of the section. */
frag = last_frag_for_seg (seg);
frag_ofs = get_frag_fix (frag, seg);
if (frag == last_frag && ! DWARF2_USE_FIXED_ADVANCE_PC)
out_inc_line_addr (INT_MAX, frag_ofs - last_frag_ofs);
else
{
lab = symbol_temp_new (seg, frag_ofs, frag);
relax_inc_line_addr (INT_MAX, lab, last_lab);
}
}
static void before_store_global(int index, void* user_data) {
Context* ctx = user_data;
out_opcode(&ctx->buf, WASM_OPCODE_SET_GLOBAL);
out_leb128(&ctx->buf, index, "global index");
}
static void before_set_local(int index, void* user_data) {
Context* ctx = user_data;
out_opcode(&ctx->buf, WASM_OPCODE_SET_LOCAL);
out_leb128(&ctx->buf, ctx->remapped_locals[index], "remapped local index");
}
static void after_load_global(int index, void* user_data) {
Context* ctx = user_data;
out_opcode(&ctx->buf, WASM_OPCODE_GET_GLOBAL);
out_leb128(&ctx->buf, index, "global index");
}
static void before_call_import(int import_index, void* user_data) {
Context* ctx = user_data;
out_opcode(&ctx->buf, WASM_OPCODE_CALL);
out_leb128(&ctx->buf, import_index, "import index");
}
