diff options
Diffstat (limited to 'gas')
| -rw-r--r-- | gas/config/obj-coff-seh.c | 1304 | ||||
| -rw-r--r-- | gas/config/obj-coff-seh.h | 161 |
2 files changed, 1465 insertions, 0 deletions
diff --git a/gas/config/obj-coff-seh.c b/gas/config/obj-coff-seh.c new file mode 100644 index 0000000..67a3bcb --- /dev/null +++ b/gas/config/obj-coff-seh.c @@ -0,0 +1,1304 @@ +#include "obj-coff-seh.h" + +/* Forward declarations. */ +static seh_kind seh_get_target_kind (void); +static int seh_symbol (bfd *, const char *, const char *, const char *, asection *, int, int); +static void seh_reloc (bfd *, bfd_size_type, int, int); +static void save_relocs (asection *sec); +static asection *quick_section (bfd *abfd, const char *name, int flags, int align); +static void seh_symbol_init (bfd *abfd, unsigned int added); +static void seh_emit_rva (const char *); +static void seh_emit_long (const char *); +static void seh_make_globl (char *); +static segT seh_make_section (void); +static segT seh_make_section2 (const char *section_name, unsigned flags); +static char *seh_make_xlbl_name (seh_context *); +static char *make_seh_text_label (seh_context *c, symbolS **addr); + +static void seh_write_text_eh_data (const char *hnd, const char *hnd_data); +static void seh_emit_rva (const char *name); +static int seh_needed_unwind_info (seh_context *); +static void seh_fill_pcsyms (const seh_context *c, char **, int *); +static size_t seh_getelm_data_size (const seh_context *, int, int); +static size_t seh_getsize_of_unwind_entry (seh_context *, int, int, int); +static void seh_make_unwind_entry (const seh_context *, char *, int, int, int, unsigned char *, size_t *, int); +static size_t seh_getsize_unwind_data (seh_context *); +static void seh_create_unwind_data (seh_context *, unsigned char *, size_t); +static void seh_make_function_entry_xdata (seh_context *, char *, char *, char *, unsigned char *, size_t *,int); +static seh_scope_elem *seh_x64_makescope_elem (seh_context *, const char *, const char *, const char *, const char *); + +/* Local data. */ +static asymbol **symtab; +static int symptr; +static arelent *reltab = 0; +static int relcount = 0, relsize = 0; + +static seh_context *seh_ctx_root = NULL; +static seh_context *seh_ctx = NULL; +static seh_context *seh_ctx_cur = NULL; + +/* Write xdata for arm, sh3, sh4, and ppc. */ +static void +seh_write_text_eh_data (const char *hnd, const char *hnd_data) +{ + if (!hnd || *hnd==0) + return; + if (hnd[0] == '@') + seh_emit_long ("0"); + else + seh_emit_long (hnd); + if (!hnd_data || hnd_data[0] == '@') + seh_emit_long ("0"); + else + seh_emit_long (hnd_data); +} + +/* Generate initial pdata for x64 and mips. */ +static void +make_function_entry_pdata (seh_context *c) +{ + segT sec = NULL; + segT current_seg = now_seg; + subsegT current_subseg = now_subseg; + + sec = seh_make_section (); + switch (seh_get_target_kind ()) + { + case seh_kind_x64: + subseg_set (sec, 0); + seh_emit_rva (c->func_name); + seh_emit_rva (c->end_symbol); + seh_emit_rva (c->xdata_first); + break; + case seh_kind_mips: + subseg_set (sec, 0); + seh_emit_long (c->func_name); + seh_emit_long (c->end_symbol); + if (c->handler_name == NULL) + seh_emit_long ("0"); + else if (c->handler_name[0] == '@') + { + if (strcasecmp (c->handler_name, "@1") == 0) + seh_emit_long ("1"); + else + seh_emit_long ("0"); + } + else + seh_emit_long (c->handler_name); + if (c->handler_data_name == NULL || c->handler_data_name[0] == '@') + seh_emit_long ("0"); + else + seh_emit_long (c->handler_data_name); + seh_emit_long (c->endprologue_symbol ? c->endprologue_symbol : c->func_name); + break; + default: + break; + } + subseg_set (current_seg, current_subseg); +} + +static void +seh_x64_write_xdata (void) +{ + seh_context *h; + size_t xdata_size = 0, count_syms = 0; + size_t xdata_offs = 0; + unsigned char *data; + segT seg_xdata; + bfd *abfd = stdoutput; + + h = seh_ctx_root; + if (h->done) + return; + while (h != NULL) + { + h->xdata_offset = xdata_size; + xdata_size += seh_getsize_unwind_data (h); + count_syms += h->count_syms; + h = h->next; + } + + if (xdata_size == 0) + return; + + seh_symbol_init (abfd, count_syms); + data = xmalloc (xdata_size); + seg_xdata = quick_section (abfd, ".xdata", SEC_HAS_CONTENTS, 3); + seg_xdata->contents = data; + memset (data, 0, xdata_size); + bfd_set_section_size (abfd, seg_xdata, xdata_size); + h = seh_ctx_root; + while (h != NULL) + { + xdata_offs = h->xdata_offset; + h->section = seg_xdata; + h->abfd = abfd; + if (h->done == 0) + { + h->done = 1; + seh_create_unwind_data (h, data, xdata_offs); + h->done = 1; + } + h = h->next; + } + save_relocs (seg_xdata); + bfd_set_symtab (abfd, symtab, symptr); + bfd_set_section_contents (abfd, seg_xdata, data, 0, xdata_size); +} + +static void +seh_arm_create_pdata (seh_context *c, unsigned char *data, size_t pdata_offs) +{ + int idx; + unsigned int val; + valueT func_len = 0; + valueT prolog_len = 0; + valueT start_len = 0; + func_len = resolve_symbol_value (c->end_addr); + start_len = resolve_symbol_value (c->start_addr); + if (c->endprologue_addr) + prolog_len = resolve_symbol_value (c->endprologue_addr); + else + prolog_len = start_len; + func_len -= start_len; + prolog_len -= start_len; + if (!c || !data) + return; + /* $$$$ */ + idx = seh_symbol (c->abfd, c->start_symbol, "", "", UNDSEC, BSF_GLOBAL, 0); + seh_reloc (c->abfd, pdata_offs, BFD_RELOC_32, idx); + val = (unsigned int) func_len; + val <<= 8; + val |= ((unsigned int) prolog_len & 0xffU); + if (c->use_instruction_32) + val |= 0x40000000U; + if (c->handler_written) + val |= 0x80000000U; + bfd_put_32 (c->abfd, (bfd_vma) val, data + pdata_offs + 4); +} + +static void +seh_arm_write_pdata (void) +{ + seh_context *h; + size_t pdata_size = 0, count_syms = 0; + size_t pdata_offs = 0; + unsigned char *data; + segT seg_pdata; + bfd *abfd = stdoutput; + + h = seh_ctx_root; + if (h->done) + return; + while (h != NULL) + { + h->xdata_offset = pdata_size; + pdata_size += 8; + count_syms += 1; + h = h->next; + } + + if (pdata_size == 0) + return; + + seh_symbol_init (abfd, count_syms); + data = xmalloc (pdata_size); + seg_pdata = quick_section (abfd, ".pdata", SEC_HAS_CONTENTS, 3); + seg_pdata->contents = data; + memset (data, 0, pdata_size); + bfd_set_section_size (abfd, seg_pdata, pdata_size); + h = seh_ctx_root; + while (h != NULL) + { + pdata_offs = h->xdata_offset; + h->section = seg_pdata; + h->abfd = abfd; + if (h->done != 0) + { + seh_arm_create_pdata (h, data, pdata_offs); + h->done = 1; + } + h = h->next; + } + save_relocs (seg_pdata); + bfd_set_symtab (abfd, symtab, symptr); + bfd_set_section_contents (abfd, seg_pdata, data, 0, pdata_size); +} + +void +obj_coff_seh_do_final (void) +{ + switch (seh_get_target_kind ()) + { + case seh_kind_mips: + default: + break; + case seh_kind_arm: + seh_arm_write_pdata (); + break; + case seh_kind_x64: + seh_x64_write_xdata (); + break; + } +} + +static void +seh_x64_make_prologue_element (int kind, int reg, bfd_vma off) +{ + seh_prologue_element *n; + if (seh_ctx_cur == NULL) + return; + if (seh_ctx_cur->elems_count == seh_ctx_cur->elems_max) + { + seh_ctx_cur->elems = (seh_prologue_element *) + xrealloc (seh_ctx_cur->elems, + ((seh_ctx_cur->elems_max + 8) * sizeof (seh_prologue_element))); + seh_ctx_cur->elems_max += 8; + } + n = &seh_ctx_cur->elems[seh_ctx_cur->elems_count]; + memset (n, 0, sizeof (seh_prologue_element)); + n->kind = kind; + n->reg = reg; + n->offset = off; + n->pc_symbol = make_seh_text_label (seh_ctx_cur, &(n->pc_addr)); + seh_ctx_cur->elems_count += 1; +} + +static int +seh_x64_read_reg (const char *tok, int kind, int *regno) +{ + static const char *frame_regs[16] = + { "cfa", "rcx", "rdx", "rbx", "rsp", "rbp","rsi","rdi", + "r8","r9","r10","r11","r12","r13","r14","r15" }; + static const char *int_regs[16] = + { "rax", "rcx", "rdx", "rbx", "rsp", "rbp","rsi","rdi", + "r8","r9","r10","r11","r12","r13","r14","r15" }; + static const char *xmm_regs[16] = + { "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7", + "xmm8", "xmm9", "xmm10","xmm11","xmm12","xmm13","xmm14","xmm15" }; + static const char *mm_regs[16] = + { "xmm0", "mm1", "mm2", "mm3", "mm4", "mm5", "mm6", "mm7", + "xmm8", "mm9", "mm10","mm11","mm12","mm13","mm14","mm15" }; + const char **p = NULL; + char name_end; + char *symbol_name = NULL; + int i; + + while (*input_line_pointer == ' ' || *input_line_pointer == '\t') + input_line_pointer++; + while (*input_line_pointer == ' ' || *input_line_pointer == '\t') + input_line_pointer++; + switch (kind) + { + case 0: + p = frame_regs; + break; + case 1: + p = int_regs; + break; + case 2: + p = mm_regs; + break; + case 3: + p = xmm_regs; + break; + default: + abort (); + } + if (*input_line_pointer == 0 || *input_line_pointer == '\n') + { + return 0; + } + if (*input_line_pointer == '%') + ++input_line_pointer; + symbol_name = input_line_pointer; + name_end = get_symbol_end (); + for (i = 0; i < 16; i++) + { + if (! strcasecmp (p[i], symbol_name)) + break; + } + if (i == 16) + { + as_warn (_("In %s we found the invalid register name %s.\n"), + tok, symbol_name); + } + *input_line_pointer = name_end; + while (*input_line_pointer == ' ' || *input_line_pointer == '\t') + input_line_pointer++; + if (*input_line_pointer == ',') + ++input_line_pointer; + while (*input_line_pointer == ' ' || *input_line_pointer == '\t') + input_line_pointer++; + *regno = i; + return i != 16; +} + +static int +seh_read_offset (const char *tok, bfd_vma *off) +{ + bfd_vma r, v = 0, base = 10; + int had_one = 0; + + while (*input_line_pointer == ' ' || *input_line_pointer == '\t') + input_line_pointer++; + if (*input_line_pointer == '0') + { + ++input_line_pointer; + had_one = 1; + base = 8; + switch ((*input_line_pointer)) + { + case 'x': + case 'X': + base = 16; + ++input_line_pointer; + break; + case 'd': + case 'D': + base = 10; + input_line_pointer++; + break; + case 'o': + case 'O': + base = 8; + input_line_pointer++; + break; + } + } + while (*input_line_pointer != 0) + { + if (input_line_pointer[0] >= '0' && input_line_pointer[0] <='9') + r = (bfd_vma) (input_line_pointer[0] - '0'); + else if (base == 16 && input_line_pointer[0] >= 'a' && input_line_pointer[0] <='f') + r = (bfd_vma) ((input_line_pointer[0] - 'a') + 10); + else if (base == 16 && input_line_pointer[0] >= 'A' && input_line_pointer[0] <='F') + r = (bfd_vma) ((input_line_pointer[0] - 'A') + 10); + else + break; + input_line_pointer++; + v *= base; + v += r; + had_one = 1; + } + *off = v; + if (had_one == 0) + { + as_warn (_("In %s we expect a number.\n"), + tok); + } + while (*input_line_pointer == ' ' || *input_line_pointer == '\t') + input_line_pointer++; + if (*input_line_pointer == ',') + ++input_line_pointer; + while (*input_line_pointer == ' ' || *input_line_pointer == '\t') + input_line_pointer++; + return had_one != 0; +} + +static void +obj_coff_seh_32 (int what) +{ + if (seh_ctx_cur == NULL) + { + as_fatal (_(".seh_eh requires to be in .seh_proc/.seh_endproc block.\n")); + demand_empty_rest_of_line (); + return; + } + seh_ctx_cur->use_instruction_32 = (what ? 1 : 0); + if (seh_get_target_kind () == seh_kind_arm) + as_warn (_(".seh_%s32 is ignored for this target."), (what ? "" : "no")); + demand_empty_rest_of_line (); +} + +static void +obj_coff_seh_eh (int what ATTRIBUTE_UNUSED) +{ + if (seh_ctx_cur == NULL) + { + as_fatal (_(".seh_eh requires to be in .seh_proc/.seh_endproc block.\n")); + demand_empty_rest_of_line (); + return; + } + if (seh_get_target_kind () == seh_kind_arm) + { + seh_ctx_cur->handler_written = 1; + /* write block to .text if exception handler is set. */ + seh_write_text_eh_data (seh_ctx_cur->handler_name, seh_ctx_cur->handler_data_name); + } + demand_empty_rest_of_line (); +} + +static void +obj_coff_seh_handler (int what ATTRIBUTE_UNUSED) +{ + char *symbol_name; + char name_end; + + if (seh_ctx_cur == NULL) + { + as_fatal (_(".seh_handler requires to be in .seh_proc/.seh_endproc block.\n")); + demand_empty_rest_of_line (); + return; + } + if (*input_line_pointer == 0 || *input_line_pointer == '\n') + { + as_fatal (_(".seh_handler requires a handler lable name.\n")); + demand_empty_rest_of_line (); + return; + } + + while (*input_line_pointer == ' ' || *input_line_pointer == '\t' || *input_line_pointer == ',') + input_line_pointer++; + symbol_name = input_line_pointer; + name_end = get_symbol_end (); + seh_ctx->handler_name = xstrdup (symbol_name); + if (symbol_name[0] == '@') + { + if (strcasecmp (symbol_name, "@0") != 0 && strcasecmp (symbol_name, "@1") != 0 + && strcasecmp (symbol_name, "@null") != 0) + as_warn (_("Unknown constant value ,%s' for handler."), symbol_name); + } + *input_line_pointer = name_end; + seh_ctx->handler_data_name = NULL; + while (*input_line_pointer == ' ' || *input_line_pointer == '\t' || *input_line_pointer == ',') + input_line_pointer++; + symbol_name = input_line_pointer; + if (*input_line_pointer != '\n' && *input_line_pointer != 0) + { + name_end = get_symbol_end (); + seh_ctx->handler_data_name = xstrdup (symbol_name); + if (symbol_name[0] == '@') + { + if (seh_get_target_kind () != seh_kind_x64) + as_fatal (_("For this target .seh_handler doesn't support constant user-data.")); + else if (strcasecmp (symbol_name, "@unwind") != 0 && + strcasecmp (symbol_name, "@except") != 0) + as_warn (_("For .seh_handler the constant ,%s' is ignored."), symbol_name); + } + *input_line_pointer = name_end; + } + if (seh_ctx_cur->handler_written) + as_warn (_(".seh_handler is ignored as .seh_eh was seen before.")); + demand_empty_rest_of_line (); +} + +static void +obj_coff_seh_scope (int what ATTRIBUTE_UNUSED) +{ + char *symbol_name,*beg = NULL,*end = NULL, *handl = NULL, *jmp = NULL; + char name_end; + + if (seh_ctx_cur == NULL) + { + as_fatal (_(".seh_scope requires to be in .seh_proc/.seh_endproc block.\n")); + demand_empty_rest_of_line (); + return; + } + + while (*input_line_pointer == ' ' || *input_line_pointer == '\t' || *input_line_pointer == ',') + input_line_pointer++; + if (*input_line_pointer == 0 || *input_line_pointer == '\n') + { + as_fatal (_(".seh_scope requires four symbol names.\n")); + demand_empty_rest_of_line (); + return; + } + symbol_name = input_line_pointer; + name_end = get_symbol_end (); + beg = xstrdup (symbol_name); + *input_line_pointer = name_end; + while (*input_line_pointer == ' ' || *input_line_pointer == '\t' || *input_line_pointer == ',') + input_line_pointer++; + if (*input_line_pointer == 0 || *input_line_pointer == '\n') + { + as_fatal (_(".seh_scope requires three more symbol names.\n")); + demand_empty_rest_of_line (); + return; + } + symbol_name = input_line_pointer; + name_end = get_symbol_end (); + end = xstrdup (symbol_name); + *input_line_pointer = name_end; + while (*input_line_pointer == ' ' || *input_line_pointer == '\t' || *input_line_pointer == ',') + input_line_pointer++; + if (*input_line_pointer == 0 || *input_line_pointer == '\n') + { + as_fatal (_(".seh_scope requires two more symbol names.\n")); + demand_empty_rest_of_line (); + return; + } + symbol_name = input_line_pointer; + name_end = get_symbol_end (); + handl = xstrdup (symbol_name); + *input_line_pointer = name_end; + if (*handl == '@') + { + if (strcasecmp (handl, "@0") != 0 && strcasecmp (handl, "@1") != 0 + && strcasecmp (handl, "@null") != 0) + as_warn (_("Unknown constant for handler ,%s'."), handl); + } + + while (*input_line_pointer == ' ' || *input_line_pointer == '\t' || *input_line_pointer == ',') + input_line_pointer++; + if (*input_line_pointer == 0 || *input_line_pointer == '\n') + { + as_fatal (_(".seh_scope requires one more symbol names.\n")); + demand_empty_rest_of_line (); + return; + } + symbol_name = input_line_pointer; + name_end = get_symbol_end (); + jmp = xstrdup (symbol_name); + *input_line_pointer = name_end; + if (*jmp == '@') + { + if (strcasecmp (jmp, "@0") != 0 && strcasecmp (handl, "@null") != 0) + as_warn (_("Unknown constant for jump ,%s'."), jmp); + } + + if (seh_get_target_kind () != seh_kind_x64) + as_warn (_(".seh_scope is ignored for this target.")); + else + seh_x64_makescope_elem (seh_ctx_cur, beg, end, handl, jmp); + if (beg) + free (beg); + if (end) + free (end); + if (handl) + free (handl); + if (jmp) + free (jmp); + demand_empty_rest_of_line (); +} + +static void +obj_coff_seh_proc (int what ATTRIBUTE_UNUSED) +{ + char *symbol_name; + char name_end; + + if (seh_ctx_cur != NULL) + { + as_warn (_(".seh_proc has to be closed by .seh_endprog\n")); + obj_coff_seh_endproc (0); + } + + if (*input_line_pointer == 0 || *input_line_pointer == '\n') + { + as_fatal (_(".seh_proc requires function lable name.\n")); + demand_empty_rest_of_line (); + return; + } + + while (*input_line_pointer == ' ' || *input_line_pointer == '\t' || *input_line_pointer == ',') + input_line_pointer++; + symbol_name = input_line_pointer; + name_end = get_symbol_end (); + + if (seh_ctx == NULL) + seh_ctx_root = seh_ctx = (seh_context *) xmalloc (sizeof (seh_context)); + else + { + seh_ctx->next = (seh_context *) xmalloc (sizeof (seh_context)); + seh_ctx = seh_ctx->next; + } + seh_ctx_cur = seh_ctx; + memset (seh_ctx, 0, sizeof (seh_context)); + + seh_ctx->func_name = xstrdup (symbol_name); + *input_line_pointer = name_end; + while (*input_line_pointer == ' ' || *input_line_pointer == '\t' || *input_line_pointer == ',') + input_line_pointer++; + seh_ctx->start_symbol = make_seh_text_label (seh_ctx_cur, &(seh_ctx_cur->start_addr)); + demand_empty_rest_of_line (); +} + +static void +obj_coff_seh_endproc (int what ATTRIBUTE_UNUSED) +{ + if (seh_ctx_cur == NULL) + { + as_warn (_(".seh_endprog without prior .seh_proc (ignored)\n")); + demand_empty_rest_of_line (); + return; + } + seh_ctx->end_symbol = make_seh_text_label (seh_ctx, &(seh_ctx->end_addr)); + seh_ctx->xdata_first = seh_make_xlbl_name (seh_ctx); + make_function_entry_pdata (seh_ctx); + seh_ctx_cur = NULL; + demand_empty_rest_of_line (); +} + +static void +obj_coff_seh_push (int what) +{ + int reg = 0; + int kind = -1; + if (seh_ctx_cur == NULL) + { + as_warn (_(".seh_push used outside of .seh_proc block.\n")); + demand_empty_rest_of_line (); + return; + } + /* what 0:reg, 1:pushframe. */ + switch (what) + { + case 0: + if (seh_x64_read_reg (".seh_push", 1, ®)) + kind = UWOP_PUSH_NONVOL; + else + as_warn (_(".seh_pushreg expects register argument.")); + break; + case 1: + kind = UWOP_PUSH_MACHFRAME; + break; + default: + abort (); + } + if (seh_get_target_kind () != seh_kind_x64) + as_warn (_(".seh_save... is ignored for this target.\n")); + else if (kind != -1) + seh_x64_make_prologue_element (kind, reg, 0); + demand_empty_rest_of_line (); +} + +static void +obj_coff_seh_save (int what) +{ + int reg; + bfd_vma off; + int kind; + int ok = 1; + + /* what 0:reg, 1:mm, 2:xmm. */ + switch (what) + { + case 0: + ok &= seh_x64_read_reg (".seh_savereg", 1, ®); + kind = UWOP_SAVE_NONVOL; + break; + case 1: + ok &= seh_x64_read_reg (".seh_savemm", 2, ®); + kind = UWOP_SAVE_XMM; + break; + case 2: + ok &= seh_x64_read_reg (".seh_savexmm", 3, ®); + kind = UWOP_SAVE_XMM128; + break; + default: + abort (); + } + ok &= seh_read_offset (".seh_save", &off); + if (seh_ctx_cur == NULL) + { + as_warn (_(".seh_save used outside of .seh_proc block.\n")); + demand_empty_rest_of_line (); + return; + } + if (seh_get_target_kind () != seh_kind_x64) + as_warn (_(".seh_save... is ignored for this target.\n")); + else + seh_x64_make_prologue_element (kind, reg, off); + demand_empty_rest_of_line (); +} + +static void +obj_coff_seh_endprologue (int what ATTRIBUTE_UNUSED) +{ + if (seh_ctx_cur == NULL) + { + as_warn (_(".seh_endprologue used outside of .seh_proc block.\n")); + demand_empty_rest_of_line (); + return; + } + if (seh_ctx_cur->endprologue_symbol != NULL) + as_warn (_(".seh_endprologue used more then once in .seh_proc block.\n")); + else + seh_ctx_cur->endprologue_symbol = make_seh_text_label (seh_ctx_cur, &seh_ctx_cur->endprologue_addr); +} + +static void +obj_coff_seh_stack_alloc (int what ATTRIBUTE_UNUSED) +{ + bfd_vma size; + if (seh_ctx_cur == NULL) + { + as_warn (_(".seh_stackalloc used outside of .seh_proc block.\n")); + demand_empty_rest_of_line (); + return; + } + if (seh_read_offset (".seh_stackalloc", &size)) + { + if (seh_get_target_kind () != seh_kind_x64) + as_warn (_(".seh_stackalloc is ignored for this target.\n")); + else + seh_x64_make_prologue_element (UWOP_ALLOC_LARGE, 0, size); + } +} + +static void +obj_coff_seh_setframe (int what ATTRIBUTE_UNUSED) +{ + int reg; + int ok = 1; + bfd_vma off; + + ok &= seh_x64_read_reg (".seh_setframe", 0, ®); + ok &= seh_read_offset (".seh_setframe", &off); + if (seh_ctx_cur == NULL) + { + as_warn (_(".seh_setframe used outside of .seh_proc block.\n")); + demand_empty_rest_of_line (); + return; + } + if (ok) + { + seh_ctx_cur->framereg = reg; + seh_ctx_cur->frameoff = off; + } + if (seh_get_target_kind () != seh_kind_x64) + as_warn (_(".seh_setframe is ignored for this target.\n")); + demand_empty_rest_of_line (); +} + +/* Misc function helpers. */ +static void +seh_reloc (bfd *abfd, bfd_size_type address, int which_howto, int symidx) +{ + if (relcount >= relsize - 1) + { + relsize += 10; + if (reltab) + reltab = xrealloc (reltab, relsize * sizeof (arelent)); + else + reltab = xmalloc (relsize * sizeof (arelent)); + } + reltab[relcount].address = address; + reltab[relcount].addend = 0; + reltab[relcount].howto = bfd_reloc_type_lookup (abfd, which_howto); + reltab[relcount].sym_ptr_ptr = symtab + symidx; + relcount++; +} + +static void +save_relocs (asection *sec) +{ + int i; + + sec->relocation = reltab; + sec->reloc_count = relcount; + sec->orelocation = xmalloc ((relcount + 1) * sizeof (arelent *)); + for (i = 0; i < relcount; i++) + sec->orelocation[i] = sec->relocation + i; + sec->orelocation[relcount] = 0; + sec->flags |= SEC_RELOC; + reltab = 0; + relcount = relsize = 0; +} + +static void +seh_symbol_init (bfd *abfd, unsigned int added) +{ + unsigned int oldcount; + oldcount = bfd_get_symcount (abfd); + symptr = oldcount; + symtab = xmalloc ((oldcount + added + 6) * sizeof (asymbol *)); + if (oldcount > 0) + memcpy (symtab, bfd_get_outsymbols (abfd), sizeof (asymbol *) * oldcount); +} + +static int +seh_symbol (bfd *abfd, const char *n1, const char *n2, const char *n3, + asection *sec, int flags, int addr) +{ + asymbol *sym; + char *name = xmalloc (strlen (n1) + strlen (n2) + strlen (n3) + 1); + int ret = symptr; + strcpy (name, n1); + strcat (name, n2); + strcat (name, n3); + sym = bfd_make_empty_symbol (abfd); + sym->name = name; + sym->section = sec; + sym->flags = flags; + sym->value = addr; + symtab[symptr++] = sym; + return ret; +} + +static asection * +quick_section (bfd *abfd, const char *name, int flags, int align) +{ + asection *sec; + asymbol *sym; + sec = seh_make_section2 (name, flags); + bfd_set_section_alignment (abfd, sec, align); + /* Remember to undo this before trying to link internally! */ + + sym = bfd_make_empty_symbol (abfd); + symtab[symptr++] = sym; + sym->name = sec->name; + sym->section = sec; + sym->flags = BSF_LOCAL; + sym->value = 0; + + return sec; +} + +static seh_kind +seh_get_target_kind (void) +{ + if (!stdoutput) + return seh_kind_unknown; + switch (bfd_get_arch (stdoutput)) + { + case bfd_arch_arm: + case bfd_arch_powerpc: + case bfd_arch_sh: + return seh_kind_arm; + case bfd_arch_i386: + switch (bfd_get_mach (stdoutput)) + { + case bfd_mach_x86_64: + case bfd_mach_x86_64_intel_syntax: + return seh_kind_x64; + default: + break; + } + /* FALL THROUGH. */ + case bfd_arch_mips: + return seh_kind_mips; + case bfd_arch_ia64: + /* Should return seh_kind_x64. But not implemented yet. */ + return seh_kind_unknown; + default: + break; + } + return seh_kind_unknown; +} + +static void +seh_emit_rva (const char *name) +{ + char *p = (char *) xmalloc (strlen (name) + 1); + char *s = input_line_pointer; + + strcpy (p, name); + input_line_pointer = p; + s_rva (4); + input_line_pointer = s; +} + +static void +seh_emit_long (const char *name) +{ + char *p = (char *) xmalloc (strlen (name) + 1); + char *s = input_line_pointer; + + strcpy (p, name); + input_line_pointer = p; + cons (4); + input_line_pointer = s; +} + +static void +seh_make_globl (char *sym_name) +{ + char *s = input_line_pointer; + + input_line_pointer = sym_name; + s_globl (4); + input_line_pointer = s; +} + +static segT +seh_make_section2 (const char *section_name, unsigned flags) +{ + char *name; + segT sec; + + name = xmalloc (strlen (section_name) + 1); + strcpy (name, section_name); + + sec = subseg_new (name, (subsegT) 0); + bfd_set_section_flags (stdoutput, sec, + ((SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA | flags) + & bfd_applicable_section_flags (stdoutput))); + + return sec; +} + +static segT +seh_make_section (void) +{ + static segT seg_pdata = NULL; + segT sec = NULL; + + if (!seg_pdata) + seg_pdata = seh_make_section2 (".pdata", 0); + sec = seg_pdata; + return sec; +} + +static char * +seh_make_xlbl_name (seh_context *c) +{ + size_t len = strlen (".seh_xlbl_") + strlen (c->func_name) + 9 + 1; + char *ret = (char*) xmalloc (len); + if (!ret) + as_fatal (_("Out of memory for xdata lable for %s"), c->func_name); + else + sprintf (ret, ".seh_xlbl_%s_%x", c->func_name, + c->xlbl_count); + c->xlbl_count += 1; + return ret; +} + +static char * +make_seh_text_label (seh_context *c, symbolS **addr) +{ + char *sym_name; + size_t len = strlen (".seh_tlbl_") + strlen (c->func_name) + 9 + 1; + sym_name = (char *) xmalloc (len); + if (!sym_name) + as_fatal (_("Allocating memory for SEH's text symbol for %s failed"), c->func_name); + sprintf (sym_name, ".seh_tlbl_%s_%x", c->func_name, c->tlbl_count); + c->tlbl_count += 1; + if (addr) + { + seh_make_globl (sym_name); + *addr = colon (sym_name); + } + return sym_name; +} + +/* x64 secific functions. */ + +static void +seh_fill_pcsyms (const seh_context *c, char **names, int *idx) +{ + size_t i; + int count = 1; + valueT start_off = resolve_symbol_value (c->start_addr); + valueT un_off; + seh_prologue_element *e = c->elems; + names[0] = c->start_symbol; + idx[0] = 0; + if (c->elems_count == 0) + return; + for (i = 0; i < c->elems_count; i++) + { + un_off = resolve_symbol_value (e[i].pc_addr); + if ((un_off - start_off) > 255) + { + names[count] = e[i].pc_symbol; + idx[count] = (int) i; + count++; + start_off = un_off; + } + } +} + +static int +seh_needed_unwind_info (seh_context *c) +{ + size_t i; + int count = 1; + valueT start_off = resolve_symbol_value (c->start_addr); + valueT un_off; + seh_prologue_element *e = c->elems; + if (c->elems_count == 0) + return count; + for (i = 0; i < c->elems_count; i++) + { + un_off = resolve_symbol_value (e[i].pc_addr); + if ((un_off - start_off) > 255) + { + count++; + start_off = un_off; + } + } + return count; +} + +static size_t +seh_getelm_data_size (const seh_context *c, int elm_start, int elm_end) +{ + size_t ret = PEX64_UWI_SIZEOF_UWCODE_ARRAY (elm_end - elm_start); + while (elm_start < elm_end) + { + switch (c->elems[elm_start].kind) + { + case UWOP_PUSH_NONVOL: + case UWOP_PUSH_MACHFRAME: + ret += 2; + break; + case UWOP_SAVE_NONVOL: + case UWOP_SAVE_XMM: + case UWOP_SAVE_XMM128: + if ((c->elems[elm_start].offset & 7) != 0 || + ((c->elems[elm_start].offset / 8) > 0xffff)) + ret += 6; + else + ret += 4; + break; + case UWOP_ALLOC_LARGE: + ret += 4; + break; + default: + break; + } + elm_start++; + } + return ret; +} + +static size_t +seh_getsize_of_unwind_entry (seh_context *c, int elm_start, int elm_end, int bechain) +{ + size_t ret = seh_getelm_data_size(c, elm_start, elm_end); + c->count_syms += 1; + if (bechain) + { + ret += 4 + 4; + c->count_syms += 1; + c->count_reloc += 1; + } + else + { + ret += 4; + if (c->handler_name != NULL) + { + if (c->handler_data_name != NULL + && c->handler_data_name[0] != '@') + { + ret += 4; + c->count_syms += 2; + c->count_reloc += 2; + } + else + { + ret += 8 + (c->scope_count * 4) * 4; + c->count_syms += (c->scope_count * 4) + 1; + c->count_reloc += (c->scope_count * 4) + 1; + } + } + } + return ret; +} + +static void +seh_make_unwind_entry (const seh_context *c, char *name, int elm_start, int elm_end, int bechain, + unsigned char *data, size_t *poffs, int no) +{ + size_t off = *poffs; + size_t it; + valueT start_off = resolve_symbol_value (c->start_addr); + valueT end_prologue; + size_t uwcodes = seh_getelm_data_size(c, elm_start, elm_end); + unsigned int flag = UNW_FLAG_NHANDLER; + int idx; + + if (c->handler_name != NULL) + { + flag = UNW_FLAG_EHANDLER; + if (c->handler_data_name != NULL && c->handler_data_name[0] != '@') + flag = UNW_FLAG_FHANDLER; + else if (c->handler_data_name != NULL && + strcasecmp (c->handler_data_name, "@unwind") == 0) + flag = UNW_FLAG_UHANDLER; + } + if (!c->endprologue_addr) + end_prologue = start_off; + else + end_prologue = resolve_symbol_value (c->endprologue_addr); + seh_symbol (c->abfd, name, "", "", c->section, BSF_GLOBAL, (int) off); + data[off++] = (1 | ((bechain ? UNW_FLAG_CHAININFO : flag) << 3)); + if (elm_start != 0) + start_off = (valueT) c->elems[elm_start].offset; + end_prologue -= start_off; + if (end_prologue > 255) + end_prologue = 255; + data[off++] = (unsigned char) end_prologue; + data[off++] = (unsigned char) (uwcodes / 2); + data[off] = (unsigned char) c->framereg; + data[off++] |= (unsigned char) ((c->frameoff / 16) << 4); + off += uwcodes; + if (bechain) + { + char n[100]; + sprintf (n,"%x", no); + idx = seh_symbol (c->abfd, ".xdata_fct", c->func_name, n, UNDSEC, BSF_GLOBAL, (int) off); + seh_reloc (c->abfd, off, BFD_RELOC_RVA, idx); + off += 4; + } + else if (c->handler_name != NULL) + { + if (flag == UNW_FLAG_FHANDLER) + { + if (strcasecmp (c->handler_name, "@1") == 0) + bfd_put_32 (c->abfd, (bfd_vma) 1, &data[off]); + else if (c->handler_name[0] != '@') + { + idx = seh_symbol (c->abfd, c->handler_name, "", "", UNDSEC, BSF_GLOBAL, 0); + seh_reloc (c->abfd, off, BFD_RELOC_RVA, idx); + } + off += 4; + idx = seh_symbol (c->abfd, c->handler_data_name, "", "", UNDSEC, BSF_GLOBAL, 0); + seh_reloc (c->abfd, off, BFD_RELOC_RVA, idx); + off += 4; + } + else if (flag == UNW_FLAG_UHANDLER || flag == UNW_FLAG_EHANDLER) + { + if (strcasecmp (c->handler_name, "@1") == 0) + bfd_put_32 (c->abfd, (bfd_vma) 1, &data[off]); + else if (c->handler_name[0] != '@') + { + idx = seh_symbol (c->abfd, c->handler_name, "", "", UNDSEC, BSF_GLOBAL, 0); + seh_reloc (c->abfd, off, BFD_RELOC_RVA, idx); + } + off += 4; + bfd_put_32 (c->abfd, (bfd_vma) c->scope_count, &data[off]); + off += 4; + for (it = 0; it < c->scope_count; it++) + { + idx = seh_symbol (c->abfd, c->scopes[it].begin_addr, "", "", UNDSEC, BSF_GLOBAL, 0); + seh_reloc (c->abfd, off, BFD_RELOC_RVA, idx); + off += 4; + idx = seh_symbol (c->abfd, c->scopes[it].end_addr, "", "", UNDSEC, BSF_GLOBAL, 0); + seh_reloc (c->abfd, off, BFD_RELOC_RVA, idx); + off += 4; + if (c->scopes[it].handler_addr[0] == '@') + { + if (strcasecmp (c->scopes[it].handler_addr, "@1") == 0) + bfd_put_32 (c->abfd, (bfd_vma) 1, &data[off]); + } + else + { + idx = seh_symbol (c->abfd, c->scopes[it].handler_addr, "", "", UNDSEC, BSF_GLOBAL, 0); + seh_reloc (c->abfd, off, BFD_RELOC_RVA, idx); + } + off += 4; + if (c->scopes[it].jump_addr[0] == '@') + { + if (strcasecmp (c->scopes[it].jump_addr, "@1") == 0) + bfd_put_32 (c->abfd, (bfd_vma) 1, &data[off]); + } + else + { + idx = seh_symbol (c->abfd, c->scopes[it].jump_addr, "", "", UNDSEC, BSF_GLOBAL, 0); + seh_reloc (c->abfd, off, BFD_RELOC_RVA, idx); + } + off += 4; + } + } + } + *poffs = off; +} + +static size_t +seh_getsize_unwind_data (seh_context *c) +{ + int need = seh_needed_unwind_info (c); + int i; + char **names = (char **) xmalloc (sizeof (char *) * need); + char **pc_syms = (char **) xmalloc (sizeof (char *) * need); + int *elm_start = (int *) xmalloc (sizeof (int) * (need + 1)); + size_t xdata_sz = 0; + + seh_fill_pcsyms (c, pc_syms, elm_start); + elm_start[need] = c->elems_count; + + xdata_sz += ((12 * (size_t) need)); + c->count_syms += 5 * need; + xdata_sz += (seh_getsize_of_unwind_entry (c, elm_start[0], elm_start[1], 1 != need) + 7) & ~7; + for (i = 1; i < need; i++) + { + xdata_sz += (seh_getsize_of_unwind_entry (c, elm_start[i], elm_start[i + 1], 1 != need) + 7) & ~7; + } + + /* Create lable names for .xdata unwind info. */ + names[0] = c->xdata_first; + for (i = 1; i < need; i++) + names[i] = seh_make_xlbl_name (c); + c->xdata_names = names; + c->xdata_pcsyms = pc_syms; + c->xdata_elm_start = elm_start; + c->xdata_sz = xdata_sz; + return xdata_sz; +} + +static void +seh_create_unwind_data (seh_context *c, unsigned char *data, size_t offs) +{ + int need = seh_needed_unwind_info (c); + int i; + char **names = c->xdata_names; + char **pc_syms = c->xdata_pcsyms; + int *elm_start = c->xdata_elm_start; + + for (i = 1; i < need; i++) + { + seh_make_function_entry_xdata (c, pc_syms[i], c->end_symbol, names[i], data, &offs, i); + } + /* Generate the function entry. Remark, that just + first is in .pdata section and already emitted. */ + seh_make_unwind_entry (c, c->xdata_first, elm_start[0], elm_start[1], 1 != need, data, &offs, 1); + for (i = 1; i < need; i++) + { + seh_make_unwind_entry (c, names[i], elm_start[i], elm_start[i + 1], (i + 1) != need, data, &offs, i + 1); + } + for (i = 1; i < need; i++) + free (names[i]); + free (names); + free (pc_syms); + free (elm_start); + c->xdata_names = NULL; + c->xdata_pcsyms = NULL; + c->xdata_elm_start = NULL; +} + +static void +seh_make_function_entry_xdata (seh_context *c, char *pc_start, char *pc_end, char *pc_xdata, unsigned char *data, size_t *poffs,int no) +{ + bfd_vma addr = (bfd_vma) *poffs; + int idx; + char s[100]; + if (!data) + return; + sprintf (s,"%x",no); + seh_symbol (c->abfd, ".xdata_fct",c->func_name, s, c->section, BSF_GLOBAL, (int) poffs[0]); + idx = seh_symbol (c->abfd, pc_start,"","", UNDSEC, BSF_GLOBAL,0); + seh_reloc (c->abfd, addr, BFD_RELOC_RVA, idx); + idx = seh_symbol (c->abfd, pc_end,"","", UNDSEC, BSF_GLOBAL,0); + seh_reloc (c->abfd, addr + 4, BFD_RELOC_RVA, idx); + idx = seh_symbol (c->abfd, pc_xdata,"","", UNDSEC, BSF_GLOBAL,0); + seh_reloc (c->abfd, addr + 8, BFD_RELOC_RVA, idx); + poffs[0] += 12; +} + +static seh_scope_elem * +seh_x64_makescope_elem (seh_context *c, const char *begin, const char *end, + const char *handler, const char *jmp) +{ + seh_scope_elem *r; + if (!end || !begin) + return NULL; + if (c->scope_count >= c->scope_max) + { + seh_scope_elem *h = (seh_scope_elem *) xmalloc (sizeof (seh_scope_elem) * (c->scope_max + 8)); + memset (h, 0, sizeof (seh_scope_elem) * (c->scope_max + 8)); + if (c->scopes != NULL) + memcpy (h, c->scopes, sizeof (seh_scope_elem) * c->scope_max); + if (c->scopes != NULL) + free (c->scopes); + c->scopes = h; + c->scope_max += 8; + } + r = &c->scopes[c->scope_count++]; + r->begin_addr = xstrdup (begin); + r->end_addr = xstrdup (end); + r->handler_addr = (!handler ? NULL : xstrdup (handler)); + r->jump_addr = (!jmp ? NULL : xstrdup (jmp)); + return r; +} diff --git a/gas/config/obj-coff-seh.h b/gas/config/obj-coff-seh.h new file mode 100644 index 0000000..42b00f5 --- /dev/null +++ b/gas/config/obj-coff-seh.h @@ -0,0 +1,161 @@ +/* Short overview: + There are at the moment three different function entry formats preset. + The first is the MIPS one. The second version + is for ARM, PPC, SH3, and SH4 mainly for Windows CE. + The third is the IA64 and x64 version. Note, the IA64 isn't implemented yet, + but to find information about it, please see specification about IA64 on + http://download.intel.com/design/Itanium/Downloads/245358.pdf file. + + The first version has just entries in the pdata section: BeginAddress, + EndAddress, ExceptionHandler, HandlerData, and PrologueEndAddress. Each + value is a pointer to the corresponding data and has size of 4 bytes. + + The second variant has the following entries in the pdata section. + BeginAddress, PrologueLength (8 bits), EndAddress (22 bits), + Use-32-bit-instruction (1 bit), and Exception-Handler-Exists (1 bit). + If the FunctionLength is zero, or the Exception-Handler-Exists bit + is true, a PDATA_EH block is placed directly before function entry. + + The third version has a function entry block of BeginAddress (RVA), + EndAddress (RVA), and UnwindData (RVA). The description of the + prologue, excepetion-handler, and additional SEH data is stored + within the UNWIND_DATA field in the xdata section. + + The pseudos: + .seh_proc <fct_name> + .seh_endprologue + .seh_handler <handler>[,<handler-data>]] + .seh_eh + .seh_32/.seh_no32 + .seh_endproc + .seh_setframe <reg>,<offset> + .seh_stackalloc + .seh_pushreg + .seh_savereg + .seh_savemm + .seh_savexmm + .seh_pushframe + .seh_scope + */ + +/* architecture specific pdata/xdata handling. */ +#define SEH_CMDS \ + {"seh_proc", obj_coff_seh_proc, 0}, \ + {"seh_endproc", obj_coff_seh_endproc, 0}, \ + {"seh_pushreg", obj_coff_seh_push, 0}, \ + {"seh_savereg", obj_coff_seh_save, 0}, \ + {"seh_savemm", obj_coff_seh_save, 1}, \ + {"seh_savexmm", obj_coff_seh_save, 2}, \ + {"seh_pushframe", obj_coff_seh_push, 1}, \ + {"seh_endprologue", obj_coff_seh_endprologue, 0}, \ + {"seh_setframe", obj_coff_seh_setframe, 0}, \ + {"seh_stackalloc", obj_coff_seh_stack_alloc, 0}, \ + {"seh_handler", obj_coff_seh_handler, 0}, \ + {"seh_eh", obj_coff_seh_eh, 0}, \ + {"seh_32", obj_coff_seh_32, 1}, \ + {"seh_no32", obj_coff_seh_32, 0}, \ + {"seh_scope", obj_coff_seh_scope, 0}, + +/* Type definitions. */ + +typedef struct seh_prologue_element +{ + symbolS *pc_addr; + char *pc_symbol; + int kind; + int reg; + bfd_vma offset; +} seh_prologue_element; + +typedef struct seh_scope_elem { + char *begin_addr; + char *end_addr; + char *handler_addr; + char *jump_addr; +} seh_scope_elem; + +typedef struct seh_context +{ + struct seh_context *next; + /* Was record alread processed. */ + int done; + /* Function name. */ + char *func_name; + /* BeginAddress. */ + char *start_symbol; + symbolS *start_addr; + bfd_vma start_offset; + /* EndAddress. */ + char *end_symbol; + symbolS *end_addr; + bfd_vma end_offset; + /* PrologueEnd. */ + char *endprologue_symbol; + symbolS *endprologue_addr; + bfd_vma endprologue_offset; + /* ExceptionHandler. */ + char *handler_name; + /* ExceptionHandlerData. */ + char *handler_data_name; + int handler_written; + /* WinCE specific data. */ + int use_instruction_32; + + /* the bfd to store data within. */ + bfd *abfd; + /* the current section to generate data within. */ + asection *section; + /* Relocations for section. */ + unsigned int count_reloc; + /* Symbols within section. */ + unsigned int count_syms; + /* Iterator for text lable generation. */ + unsigned int tlbl_count; + /* Iterator for xdata lable generation. */ + unsigned int xlbl_count; + /* The name of the first xdata label. */ + char *xdata_first; + /* FIelds used for x64 generation of chained information. */ + char **xdata_names; + char **xdata_pcsyms; + int *xdata_elm_start; + /* Size and offset within current generated xdata section. */ + size_t xdata_sz; + size_t xdata_offset; + /* x64 framereg and frame offset information. */ + int framereg; + bfd_vma frameoff; + /* Information about x64 specific unwind data fields. */ + size_t elems_count; + size_t elems_max; + seh_prologue_element *elems; + size_t scope_max; + size_t scope_count; + seh_scope_elem *scopes; +} seh_context; + +typedef enum seh_kind { + seh_kind_unknown = 0, + seh_kind_mips = 1, /* Used for MIPS and x86 pdata generation. */ + seh_kind_arm = 2, /* Used for ARM, PPC, SH3, and SH4 pdata (PDATA_EH) generation. */ + seh_kind_x64 = 3 /* Used for IA64 and x64 pdata/xdata generation. */ +} seh_kind; + +/* Forward declarations. */ +static void obj_coff_seh_stack_alloc (int); +static void obj_coff_seh_setframe (int); +static void obj_coff_seh_endprologue (int); +static void obj_coff_seh_save (int); +static void obj_coff_seh_push (int); +static void obj_coff_seh_endproc (int); +static void obj_coff_seh_eh (int); +static void obj_coff_seh_32 (int); +static void obj_coff_seh_proc (int); +static void obj_coff_seh_handler (int); +static void obj_coff_seh_scope (int); +static int seh_read_offset (const char *, bfd_vma *); +static int seh_x64_read_reg (const char *, int, int *); +static void seh_x64_make_prologue_element (int, int, bfd_vma); +static void make_function_entry_pdata (seh_context *c); + +#define UNDSEC (asection *) &bfd_und_section |