1 /* seh pdata/xdata coff object file format
2 Copyright (C) 2009-2015 Free Software Foundation, Inc.
4 This file is part of GAS.
6 GAS is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 3, or (at your option)
11 GAS is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GAS; see the file COPYING. If not, write to the Free
18 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
21 #include "obj-coff-seh.h"
24 /* Private segment collection list. */
32 static seh_context *seh_ctx_cur = NULL;
34 static struct hash_control *seh_hash;
36 static struct seh_seg_list *x_segcur = NULL;
37 static struct seh_seg_list *p_segcur = NULL;
39 static void write_function_xdata (seh_context *);
40 static void write_function_pdata (seh_context *);
43 /* Build based on segment the derived .pdata/.xdata
44 segment name containing origin segment's postfix name part. */
46 get_pxdata_name (segT seg, const char *base_name)
48 const char *name,*dollar, *dot;
51 name = bfd_get_section_name (stdoutput, seg);
53 dollar = strchr (name, '$');
54 dot = strchr (name + 1, '.');
62 else if (dot < dollar)
67 sname = concat (base_name, name, NULL);
72 /* Allocate a seh_seg_list structure. */
73 static struct seh_seg_list *
74 alloc_pxdata_item (segT seg, int subseg, char *name)
76 struct seh_seg_list *r;
78 r = (struct seh_seg_list *)
79 xmalloc (sizeof (struct seh_seg_list) + strlen (name));
86 /* Generate pdata/xdata segment with same linkonce properties
89 make_pxdata_seg (segT cseg, char *name)
91 segT save_seg = now_seg;
92 int save_subseg = now_subseg;
96 r = subseg_new (name, 0);
97 /* Check if code segment is marked as linked once. */
98 flags = bfd_get_section_flags (stdoutput, cseg)
99 & (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD
100 | SEC_LINK_DUPLICATES_ONE_ONLY | SEC_LINK_DUPLICATES_SAME_SIZE
101 | SEC_LINK_DUPLICATES_SAME_CONTENTS);
103 /* Add standard section flags. */
104 flags |= SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA;
106 /* Apply possibly linked once flags to new generated segment, too. */
107 if (!bfd_set_section_flags (stdoutput, r, flags))
108 as_bad (_("bfd_set_section_flags: %s"),
109 bfd_errmsg (bfd_get_error ()));
111 /* Restore to previous segment. */
112 subseg_set (save_seg, save_subseg);
117 seh_hash_insert (const char *name, struct seh_seg_list *item)
119 const char *error_string;
121 if ((error_string = hash_jam (seh_hash, name, (char *) item)))
122 as_fatal (_("Inserting \"%s\" into structure table failed: %s"),
126 static struct seh_seg_list *
127 seh_hash_find (char *name)
129 return (struct seh_seg_list *) hash_find (seh_hash, name);
132 static struct seh_seg_list *
133 seh_hash_find_or_make (segT cseg, const char *base_name)
135 struct seh_seg_list *item;
138 /* Initialize seh_hash once. */
140 seh_hash = hash_new ();
142 name = get_pxdata_name (cseg, base_name);
144 item = seh_hash_find (name);
147 item = alloc_pxdata_item (make_pxdata_seg (cseg, name), 0, name);
149 seh_hash_insert (item->seg_name, item);
157 /* Check if current segment has same name. */
159 seh_validate_seg (const char *directive)
161 const char *cseg_name, *nseg_name;
162 if (seh_ctx_cur->code_seg == now_seg)
164 cseg_name = bfd_get_section_name (stdoutput, seh_ctx_cur->code_seg);
165 nseg_name = bfd_get_section_name (stdoutput, now_seg);
166 as_bad (_("%s used in segment '%s' instead of expected '%s'"),
167 directive, nseg_name, cseg_name);
168 ignore_rest_of_line ();
172 /* Switch back to the code section, whatever that may be. */
174 obj_coff_seh_code (int ignored ATTRIBUTE_UNUSED)
176 subseg_set (seh_ctx_cur->code_seg, 0);
180 switch_xdata (int subseg, segT code_seg)
182 x_segcur = seh_hash_find_or_make (code_seg, ".xdata");
184 subseg_set (x_segcur->seg, subseg);
188 switch_pdata (segT code_seg)
190 p_segcur = seh_hash_find_or_make (code_seg, ".pdata");
192 subseg_set (p_segcur->seg, p_segcur->subseg);
195 /* Parsing routines. */
197 /* Return the style of SEH unwind info to generate. */
200 seh_get_target_kind (void)
203 return seh_kind_unknown;
204 switch (bfd_get_arch (stdoutput))
207 case bfd_arch_powerpc:
211 switch (bfd_get_mach (stdoutput))
213 case bfd_mach_x86_64:
214 case bfd_mach_x86_64_intel_syntax:
221 return seh_kind_mips;
223 /* Should return seh_kind_x64. But not implemented yet. */
224 return seh_kind_unknown;
228 return seh_kind_unknown;
231 /* Verify that we're in the context of a seh_proc. */
234 verify_context (const char *directive)
236 if (seh_ctx_cur == NULL)
238 as_bad (_("%s used outside of .seh_proc block"), directive);
239 ignore_rest_of_line ();
245 /* Similar, except we also verify the appropriate target. */
248 verify_context_and_target (const char *directive, seh_kind target)
250 if (seh_get_target_kind () != target)
252 as_warn (_("%s ignored for this target"), directive);
253 ignore_rest_of_line ();
256 return verify_context (directive);
259 /* Skip whitespace and a comma. Error if the comma is not seen. */
262 skip_whitespace_and_comma (int required)
265 if (*input_line_pointer == ',')
267 input_line_pointer++;
273 as_bad (_("missing separator"));
274 ignore_rest_of_line ();
277 demand_empty_rest_of_line ();
281 /* Mark current context to use 32-bit instruction (arm). */
284 obj_coff_seh_32 (int what)
286 if (!verify_context_and_target ((what ? ".seh_32" : ".seh_no32"),
290 seh_ctx_cur->use_instruction_32 = (what ? 1 : 0);
291 demand_empty_rest_of_line ();
294 /* Set for current context the handler and optional data (arm). */
297 obj_coff_seh_eh (int what ATTRIBUTE_UNUSED)
299 if (!verify_context_and_target (".seh_eh", seh_kind_arm))
302 /* Write block to .text if exception handler is set. */
303 seh_ctx_cur->handler_written = 1;
304 emit_expr (&seh_ctx_cur->handler, 4);
305 emit_expr (&seh_ctx_cur->handler_data, 4);
307 demand_empty_rest_of_line ();
310 /* Set for current context the default handler (x64). */
313 obj_coff_seh_handler (int what ATTRIBUTE_UNUSED)
318 if (!verify_context (".seh_handler"))
321 if (*input_line_pointer == 0 || *input_line_pointer == '\n')
323 as_bad (_(".seh_handler requires a handler"));
324 demand_empty_rest_of_line ();
330 if (*input_line_pointer == '@')
332 name_end = get_symbol_name (&symbol_name);
334 seh_ctx_cur->handler.X_op = O_constant;
335 seh_ctx_cur->handler.X_add_number = 0;
337 if (strcasecmp (symbol_name, "@0") == 0
338 || strcasecmp (symbol_name, "@null") == 0)
340 else if (strcasecmp (symbol_name, "@1") == 0)
341 seh_ctx_cur->handler.X_add_number = 1;
343 as_bad (_("unknown constant value '%s' for handler"), symbol_name);
345 (void) restore_line_pointer (name_end);
348 expression (&seh_ctx_cur->handler);
350 seh_ctx_cur->handler_data.X_op = O_constant;
351 seh_ctx_cur->handler_data.X_add_number = 0;
352 seh_ctx_cur->handler_flags = 0;
354 if (!skip_whitespace_and_comma (0))
357 if (seh_get_target_kind () == seh_kind_x64)
361 name_end = get_symbol_name (&symbol_name);
363 if (strcasecmp (symbol_name, "@unwind") == 0)
364 seh_ctx_cur->handler_flags |= UNW_FLAG_UHANDLER;
365 else if (strcasecmp (symbol_name, "@except") == 0)
366 seh_ctx_cur->handler_flags |= UNW_FLAG_EHANDLER;
368 as_bad (_(".seh_handler constant '%s' unknown"), symbol_name);
370 (void) restore_line_pointer (name_end);
372 while (skip_whitespace_and_comma (0));
376 expression (&seh_ctx_cur->handler_data);
377 demand_empty_rest_of_line ();
379 if (seh_ctx_cur->handler_written)
380 as_warn (_(".seh_handler after .seh_eh is ignored"));
384 /* Switch to subsection for handler data for exception region (x64). */
387 obj_coff_seh_handlerdata (int what ATTRIBUTE_UNUSED)
389 if (!verify_context_and_target (".seh_handlerdata", seh_kind_x64))
391 demand_empty_rest_of_line ();
393 switch_xdata (seh_ctx_cur->subsection + 1, seh_ctx_cur->code_seg);
396 /* Mark end of current context. */
399 do_seh_endproc (void)
401 seh_ctx_cur->end_addr = symbol_temp_new_now ();
403 write_function_xdata (seh_ctx_cur);
404 write_function_pdata (seh_ctx_cur);
409 obj_coff_seh_endproc (int what ATTRIBUTE_UNUSED)
411 demand_empty_rest_of_line ();
412 if (seh_ctx_cur == NULL)
414 as_bad (_(".seh_endproc used without .seh_proc"));
417 seh_validate_seg (".seh_endproc");
421 /* Mark begin of new context. */
424 obj_coff_seh_proc (int what ATTRIBUTE_UNUSED)
429 if (seh_ctx_cur != NULL)
431 as_bad (_("previous SEH entry not closed (missing .seh_endproc)"));
435 if (*input_line_pointer == 0 || *input_line_pointer == '\n')
437 as_bad (_(".seh_proc requires function label name"));
438 demand_empty_rest_of_line ();
442 seh_ctx_cur = XCNEW (seh_context);
444 seh_ctx_cur->code_seg = now_seg;
446 if (seh_get_target_kind () == seh_kind_x64)
448 x_segcur = seh_hash_find_or_make (seh_ctx_cur->code_seg, ".xdata");
449 seh_ctx_cur->subsection = x_segcur->subseg;
450 x_segcur->subseg += 2;
455 name_end = get_symbol_name (&symbol_name);
456 seh_ctx_cur->func_name = xstrdup (symbol_name);
457 (void) restore_line_pointer (name_end);
459 demand_empty_rest_of_line ();
461 seh_ctx_cur->start_addr = symbol_temp_new_now ();
464 /* Mark end of prologue for current context. */
467 obj_coff_seh_endprologue (int what ATTRIBUTE_UNUSED)
469 if (!verify_context (".seh_endprologue")
470 || !seh_validate_seg (".seh_endprologue"))
472 demand_empty_rest_of_line ();
474 if (seh_ctx_cur->endprologue_addr != NULL)
475 as_warn (_("duplicate .seh_endprologue in .seh_proc block"));
477 seh_ctx_cur->endprologue_addr = symbol_temp_new_now ();
480 /* End-of-file hook. */
483 obj_coff_seh_do_final (void)
485 if (seh_ctx_cur != NULL)
487 as_bad (_("open SEH entry at end of file (missing .cfi_endproc)"));
492 /* Enter a prologue element into current context (x64). */
495 seh_x64_make_prologue_element (int code, int info, offsetT off)
497 seh_prologue_element *n;
499 if (seh_ctx_cur == NULL)
501 if (seh_ctx_cur->elems_count == seh_ctx_cur->elems_max)
503 seh_ctx_cur->elems_max += 8;
504 seh_ctx_cur->elems = XRESIZEVEC (seh_prologue_element,
506 seh_ctx_cur->elems_max);
509 n = &seh_ctx_cur->elems[seh_ctx_cur->elems_count++];
513 n->pc_addr = symbol_temp_new_now ();
516 /* Helper to read a register name from input stream (x64). */
519 seh_x64_read_reg (const char *directive, int kind)
521 static const char * const int_regs[16] =
522 { "rax", "rcx", "rdx", "rbx", "rsp", "rbp","rsi","rdi",
523 "r8","r9","r10","r11","r12","r13","r14","r15" };
524 static const char * const xmm_regs[16] =
525 { "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
526 "xmm8", "xmm9", "xmm10","xmm11","xmm12","xmm13","xmm14","xmm15" };
528 const char * const *regs = NULL;
530 char *symbol_name = NULL;
547 if (*input_line_pointer == '%')
548 ++input_line_pointer;
549 name_end = get_symbol_name (& symbol_name);
551 for (i = 0; i < 16; i++)
552 if (! strcasecmp (regs[i], symbol_name))
555 (void) restore_line_pointer (name_end);
557 /* Error if register not found, or EAX used as a frame pointer. */
558 if (i == 16 || (kind == 0 && i == 0))
560 as_bad (_("invalid register for %s"), directive);
567 /* Add a register push-unwind token to the current context. */
570 obj_coff_seh_pushreg (int what ATTRIBUTE_UNUSED)
574 if (!verify_context_and_target (".seh_pushreg", seh_kind_x64)
575 || !seh_validate_seg (".seh_pushreg"))
578 reg = seh_x64_read_reg (".seh_pushreg", 1);
579 demand_empty_rest_of_line ();
584 seh_x64_make_prologue_element (UWOP_PUSH_NONVOL, reg, 0);
587 /* Add a register frame-unwind token to the current context. */
590 obj_coff_seh_pushframe (int what ATTRIBUTE_UNUSED)
592 if (!verify_context_and_target (".seh_pushframe", seh_kind_x64)
593 || !seh_validate_seg (".seh_pushframe"))
595 demand_empty_rest_of_line ();
597 seh_x64_make_prologue_element (UWOP_PUSH_MACHFRAME, 0, 0);
600 /* Add a register save-unwind token to current context. */
603 obj_coff_seh_save (int what)
605 const char *directive = (what == 1 ? ".seh_savereg" : ".seh_savexmm");
606 int code, reg, scale;
609 if (!verify_context_and_target (directive, seh_kind_x64)
610 || !seh_validate_seg (directive))
613 reg = seh_x64_read_reg (directive, what);
615 if (!skip_whitespace_and_comma (1))
618 off = get_absolute_expression ();
619 demand_empty_rest_of_line ();
625 as_bad (_("%s offset is negative"), directive);
629 scale = (what == 1 ? 8 : 16);
631 if ((off & (scale - 1)) == 0 && off <= (offsetT) (0xffff * scale))
633 code = (what == 1 ? UWOP_SAVE_NONVOL : UWOP_SAVE_XMM128);
636 else if (off < (offsetT) 0xffffffff)
637 code = (what == 1 ? UWOP_SAVE_NONVOL_FAR : UWOP_SAVE_XMM128_FAR);
640 as_bad (_("%s offset out of range"), directive);
644 seh_x64_make_prologue_element (code, reg, off);
647 /* Add a stack-allocation token to current context. */
650 obj_coff_seh_stackalloc (int what ATTRIBUTE_UNUSED)
655 if (!verify_context_and_target (".seh_stackalloc", seh_kind_x64)
656 || !seh_validate_seg (".seh_stackalloc"))
659 off = get_absolute_expression ();
660 demand_empty_rest_of_line ();
666 as_bad (_(".seh_stackalloc offset is negative"));
670 if ((off & 7) == 0 && off <= 128)
671 code = UWOP_ALLOC_SMALL, info = (off - 8) >> 3, off = 0;
672 else if ((off & 7) == 0 && off <= (offsetT) (0xffff * 8))
673 code = UWOP_ALLOC_LARGE, info = 0, off >>= 3;
674 else if (off <= (offsetT) 0xffffffff)
675 code = UWOP_ALLOC_LARGE, info = 1;
678 as_bad (_(".seh_stackalloc offset out of range"));
682 seh_x64_make_prologue_element (code, info, off);
685 /* Add a frame-pointer token to current context. */
688 obj_coff_seh_setframe (int what ATTRIBUTE_UNUSED)
693 if (!verify_context_and_target (".seh_setframe", seh_kind_x64)
694 || !seh_validate_seg (".seh_setframe"))
697 reg = seh_x64_read_reg (".seh_setframe", 0);
699 if (!skip_whitespace_and_comma (1))
702 off = get_absolute_expression ();
703 demand_empty_rest_of_line ();
708 as_bad (_(".seh_setframe offset is negative"));
710 as_bad (_(".seh_setframe offset out of range"));
712 as_bad (_(".seh_setframe offset not a multiple of 16"));
713 else if (seh_ctx_cur->framereg != 0)
714 as_bad (_("duplicate .seh_setframe in current .seh_proc"));
717 seh_ctx_cur->framereg = reg;
718 seh_ctx_cur->frameoff = off;
719 seh_x64_make_prologue_element (UWOP_SET_FPREG, 0, 0);
723 /* Data writing routines. */
725 /* Output raw integers in 1, 2, or 4 bytes. */
730 FRAG_APPEND_1_CHAR (byte);
736 md_number_to_chars (frag_more (2), data, 2);
742 md_number_to_chars (frag_more (4), data, 4);
745 /* Write out prologue data for x64. */
748 seh_x64_write_prologue_data (const seh_context *c)
752 /* We have to store in reverse order. */
753 for (i = c->elems_count - 1; i >= 0; --i)
755 const seh_prologue_element *e = c->elems + i;
758 /* First comes byte offset in code. */
759 exp.X_op = O_subtract;
760 exp.X_add_symbol = e->pc_addr;
761 exp.X_op_symbol = c->start_addr;
762 exp.X_add_number = 0;
765 /* Second comes code+info packed into a byte. */
766 out_one ((e->info << 4) | e->code);
770 case UWOP_PUSH_NONVOL:
771 case UWOP_ALLOC_SMALL:
773 case UWOP_PUSH_MACHFRAME:
774 /* These have no extra data. */
777 case UWOP_ALLOC_LARGE:
780 case UWOP_SAVE_NONVOL_FAR:
781 case UWOP_SAVE_XMM128_FAR:
782 /* An unscaled 4 byte offset. */
788 case UWOP_SAVE_NONVOL:
789 case UWOP_SAVE_XMM128:
790 /* A scaled 2 byte offset. */
801 seh_x64_size_prologue_data (const seh_context *c)
805 for (i = c->elems_count - 1; i >= 0; --i)
806 switch (c->elems[i].code)
808 case UWOP_PUSH_NONVOL:
809 case UWOP_ALLOC_SMALL:
811 case UWOP_PUSH_MACHFRAME:
815 case UWOP_SAVE_NONVOL:
816 case UWOP_SAVE_XMM128:
820 case UWOP_SAVE_NONVOL_FAR:
821 case UWOP_SAVE_XMM128_FAR:
825 case UWOP_ALLOC_LARGE:
826 ret += (c->elems[i].info ? 3 : 2);
836 /* Write out the xdata information for one function (x64). */
839 seh_x64_write_function_xdata (seh_context *c)
841 int flags, count_unwind_codes;
844 /* Set 4-byte alignment. */
845 frag_align (2, 0, 0);
847 c->xdata_addr = symbol_temp_new_now ();
848 flags = c->handler_flags;
849 count_unwind_codes = seh_x64_size_prologue_data (c);
851 /* ubyte:3 version, ubyte:5 flags. */
852 out_one ((flags << 3) | 1);
854 /* Size of prologue. */
855 if (c->endprologue_addr)
857 exp.X_op = O_subtract;
858 exp.X_add_symbol = c->endprologue_addr;
859 exp.X_op_symbol = c->start_addr;
860 exp.X_add_number = 0;
866 /* Number of slots (i.e. shorts) in the unwind codes array. */
867 if (count_unwind_codes > 255)
868 as_fatal (_("too much unwind data in this .seh_proc"));
869 out_one (count_unwind_codes);
871 /* ubyte:4 frame-reg, ubyte:4 frame-reg-offset. */
872 /* Note that frameoff is already a multiple of 16, and therefore
873 the offset is already both scaled and shifted into place. */
874 out_one (c->frameoff | c->framereg);
876 seh_x64_write_prologue_data (c);
878 /* We need to align prologue data. */
879 if (count_unwind_codes & 1)
882 if (flags & (UNW_FLAG_EHANDLER | UNW_FLAG_UHANDLER))
884 /* Force the use of segment-relative relocations instead of absolute
885 valued expressions. Don't adjust for constants (e.g. NULL). */
886 if (c->handler.X_op == O_symbol)
887 c->handler.X_op = O_symbol_rva;
888 emit_expr (&c->handler, 4);
891 /* Handler data will be tacked in here by subsections. */
894 /* Write out xdata for one function. */
897 write_function_xdata (seh_context *c)
899 segT save_seg = now_seg;
900 int save_subseg = now_subseg;
902 /* MIPS, SH, ARM don't have xdata. */
903 if (seh_get_target_kind () != seh_kind_x64)
906 switch_xdata (c->subsection, c->code_seg);
908 seh_x64_write_function_xdata (c);
910 subseg_set (save_seg, save_subseg);
913 /* Write pdata section data for one function (arm). */
916 seh_arm_write_function_pdata (seh_context *c)
919 unsigned int prol_len = 0, func_len = 0;
922 /* Start address of the function. */
924 exp.X_add_symbol = c->start_addr;
925 exp.X_add_number = 0;
928 exp.X_op = O_subtract;
929 exp.X_add_symbol = c->end_addr;
930 exp.X_op_symbol = c->start_addr;
931 exp.X_add_number = 0;
932 if (resolve_expression (&exp) && exp.X_op == O_constant)
933 func_len = exp.X_add_number;
935 as_bad (_(".seh_endproc in a different section from .seh_proc"));
937 if (c->endprologue_addr)
939 exp.X_op = O_subtract;
940 exp.X_add_symbol = c->endprologue_addr;
941 exp.X_op_symbol = c->start_addr;
942 exp.X_add_number = 0;
944 if (resolve_expression (&exp) && exp.X_op == O_constant)
945 prol_len = exp.X_add_number;
947 as_bad (_(".seh_endprologue in a different section from .seh_proc"));
950 /* Both function and prologue are in units of instructions. */
951 func_len >>= (c->use_instruction_32 ? 2 : 1);
952 prol_len >>= (c->use_instruction_32 ? 2 : 1);
954 /* Assemble the second word of the pdata. */
955 val = prol_len & 0xff;
956 val |= (func_len & 0x3fffff) << 8;
957 if (c->use_instruction_32)
959 if (c->handler_written)
964 /* Write out pdata for one function. */
967 write_function_pdata (seh_context *c)
970 segT save_seg = now_seg;
971 int save_subseg = now_subseg;
972 memset (&exp, 0, sizeof (expressionS));
973 switch_pdata (c->code_seg);
975 switch (seh_get_target_kind ())
978 exp.X_op = O_symbol_rva;
979 exp.X_add_number = 0;
981 exp.X_add_symbol = c->start_addr;
983 exp.X_op = O_symbol_rva;
984 exp.X_add_number = 0;
985 exp.X_add_symbol = c->end_addr;
987 exp.X_op = O_symbol_rva;
988 exp.X_add_number = 0;
989 exp.X_add_symbol = c->xdata_addr;
995 exp.X_add_number = 0;
997 exp.X_add_symbol = c->start_addr;
999 exp.X_add_symbol = c->end_addr;
1000 emit_expr (&exp, 4);
1002 emit_expr (&c->handler, 4);
1003 emit_expr (&c->handler_data, 4);
1005 exp.X_add_symbol = (c->endprologue_addr
1006 ? c->endprologue_addr
1008 emit_expr (&exp, 4);
1012 seh_arm_write_function_pdata (c);
1019 subseg_set (save_seg, save_subseg);