URL
https://opencores.org/ocsvn/openrisc_2011-10-31/openrisc_2011-10-31/trunk
Subversion Repositories openrisc_2011-10-31
[/] [openrisc/] [trunk/] [gnu-src/] [binutils-2.20.1/] [gas/] [config/] [obj-coff-seh.c] - Rev 205
Compare with Previous | Blame | View Log
/* seh pdata/xdata coff object file format Copyright 2009 Free Software Foundation, Inc. This file is part of GAS. GAS is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 3, or (at your option) any later version. GAS is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with GAS; see the file COPYING. If not, write to the Free Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA 02110-1301, USA. */ #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 || 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 == NULL || 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; }