1 /* seh pdata/xdata coff object file format
3 Free Software Foundation, Inc.
5 This file is part of GAS.
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 3, or (at your option)
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to the Free
19 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
22 #include "obj-coff-seh.h"
25 /* Private segment collection list. */
33 static seh_context *seh_ctx_cur = NULL;
35 static struct hash_control *seh_hash;
37 static struct seh_seg_list *x_segcur = NULL;
38 static struct seh_seg_list *p_segcur = NULL;
40 static void write_function_xdata (seh_context *);
41 static void write_function_pdata (seh_context *);
44 /* Build based on segment the derived .pdata/.xdata
45 segment name containing origin segment's postfix name part. */
47 get_pxdata_name (segT seg, const char *base_name)
49 const char *name,*dollar, *dot;
52 name = bfd_get_section_name (stdoutput, seg);
54 dollar = strchr (name, '$');
55 dot = strchr (name + 1, '.');
63 else if (dot < dollar)
68 sname = concat (base_name, name, NULL);
73 /* Allocate a seh_seg_list structure. */
74 static struct seh_seg_list *
75 alloc_pxdata_item (segT seg, int subseg, char *name)
77 struct seh_seg_list *r;
79 r = (struct seh_seg_list *)
80 xmalloc (sizeof (struct seh_seg_list) + strlen (name));
87 /* Generate pdata/xdata segment with same linkonce properties
90 make_pxdata_seg (segT cseg, char *name)
92 segT save_seg = now_seg;
93 int save_subseg = now_subseg;
97 r = subseg_new (name, 0);
98 /* Check if code segment is marked as linked once. */
99 flags = bfd_get_section_flags (stdoutput, cseg)
100 & (SEC_LINK_ONCE | SEC_LINK_DUPLICATES_DISCARD
101 | SEC_LINK_DUPLICATES_ONE_ONLY | SEC_LINK_DUPLICATES_SAME_SIZE
102 | SEC_LINK_DUPLICATES_SAME_CONTENTS);
104 /* Add standard section flags. */
105 flags |= SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_DATA;
107 /* Apply possibly linked once flags to new generated segment, too. */
108 if (!bfd_set_section_flags (stdoutput, r, flags))
109 as_bad (_("bfd_set_section_flags: %s"),
110 bfd_errmsg (bfd_get_error ()));
112 /* Restore to previous segment. */
113 subseg_set (save_seg, save_subseg);
118 seh_hash_insert (const char *name, struct seh_seg_list *item)
120 const char *error_string;
122 if ((error_string = hash_jam (seh_hash, name, (char *) item)))
123 as_fatal (_("Inserting \"%s\" into structure table failed: %s"),
127 static struct seh_seg_list *
128 seh_hash_find (char *name)
130 return (struct seh_seg_list *) hash_find (seh_hash, name);
133 static struct seh_seg_list *
134 seh_hash_find_or_make (segT cseg, const char *base_name)
136 struct seh_seg_list *item;
139 /* Initialize seh_hash once. */
141 seh_hash = hash_new ();
143 name = get_pxdata_name (cseg, base_name);
145 item = seh_hash_find (name);
148 item = alloc_pxdata_item (make_pxdata_seg (cseg, name), 0, name);
150 seh_hash_insert (item->seg_name, item);
158 /* Check if current segment has same name. */
160 seh_validate_seg (const char *directive)
162 const char *cseg_name, *nseg_name;
163 if (seh_ctx_cur->code_seg == now_seg)
165 cseg_name = bfd_get_section_name (stdoutput, seh_ctx_cur->code_seg);
166 nseg_name = bfd_get_section_name (stdoutput, now_seg);
167 as_bad (_("%s used in segment '%s' instead of expected '%s'"),
168 directive, nseg_name, cseg_name);
169 ignore_rest_of_line ();
174 switch_xdata (int subseg, segT code_seg)
176 x_segcur = seh_hash_find_or_make (code_seg, ".xdata");
178 subseg_set (x_segcur->seg, subseg);
182 switch_pdata (segT code_seg)
184 p_segcur = seh_hash_find_or_make (code_seg, ".pdata");
186 subseg_set (p_segcur->seg, p_segcur->subseg);
189 /* Parsing routines. */
191 /* Return the style of SEH unwind info to generate. */
194 seh_get_target_kind (void)
197 return seh_kind_unknown;
198 switch (bfd_get_arch (stdoutput))
201 case bfd_arch_powerpc:
205 switch (bfd_get_mach (stdoutput))
207 case bfd_mach_x86_64:
208 case bfd_mach_x86_64_intel_syntax:
215 return seh_kind_mips;
217 /* Should return seh_kind_x64. But not implemented yet. */
218 return seh_kind_unknown;
222 return seh_kind_unknown;
225 /* Verify that we're in the context of a seh_proc. */
228 verify_context (const char *directive)
230 if (seh_ctx_cur == NULL)
232 as_bad (_("%s used outside of .seh_proc block"), directive);
233 ignore_rest_of_line ();
239 /* Similar, except we also verify the appropriate target. */
242 verify_context_and_target (const char *directive, seh_kind target)
244 if (seh_get_target_kind () != target)
246 as_warn (_("%s ignored for this target"), directive);
247 ignore_rest_of_line ();
250 return verify_context (directive);
253 /* Skip whitespace and a comma. Error if the comma is not seen. */
256 skip_whitespace_and_comma (int required)
259 if (*input_line_pointer == ',')
261 input_line_pointer++;
267 as_bad (_("missing separator"));
268 ignore_rest_of_line ();
271 demand_empty_rest_of_line ();
275 /* Mark current context to use 32-bit instruction (arm). */
278 obj_coff_seh_32 (int what)
280 if (!verify_context_and_target ((what ? ".seh_32" : ".seh_no32"),
284 seh_ctx_cur->use_instruction_32 = (what ? 1 : 0);
285 demand_empty_rest_of_line ();
288 /* Set for current context the handler and optional data (arm). */
291 obj_coff_seh_eh (int what ATTRIBUTE_UNUSED)
293 if (!verify_context_and_target (".seh_eh", seh_kind_arm))
296 /* Write block to .text if exception handler is set. */
297 seh_ctx_cur->handler_written = 1;
298 emit_expr (&seh_ctx_cur->handler, 4);
299 emit_expr (&seh_ctx_cur->handler_data, 4);
301 demand_empty_rest_of_line ();
304 /* Set for current context the default handler (x64). */
307 obj_coff_seh_handler (int what ATTRIBUTE_UNUSED)
312 if (!verify_context (".seh_handler"))
315 if (*input_line_pointer == 0 || *input_line_pointer == '\n')
317 as_bad (_(".seh_handler requires a handler"));
318 demand_empty_rest_of_line ();
324 if (*input_line_pointer == '@')
326 symbol_name = input_line_pointer;
327 name_end = get_symbol_end ();
329 seh_ctx_cur->handler.X_op = O_constant;
330 seh_ctx_cur->handler.X_add_number = 0;
332 if (strcasecmp (symbol_name, "@0") == 0
333 || strcasecmp (symbol_name, "@null") == 0)
335 else if (strcasecmp (symbol_name, "@1") == 0)
336 seh_ctx_cur->handler.X_add_number = 1;
338 as_bad (_("unknown constant value '%s' for handler"), symbol_name);
340 *input_line_pointer = name_end;
343 expression (&seh_ctx_cur->handler);
345 seh_ctx_cur->handler_data.X_op = O_constant;
346 seh_ctx_cur->handler_data.X_add_number = 0;
347 seh_ctx_cur->handler_flags = 0;
349 if (!skip_whitespace_and_comma (0))
352 if (seh_get_target_kind () == seh_kind_x64)
356 symbol_name = input_line_pointer;
357 name_end = get_symbol_end ();
359 if (strcasecmp (symbol_name, "@unwind") == 0)
360 seh_ctx_cur->handler_flags |= UNW_FLAG_UHANDLER;
361 else if (strcasecmp (symbol_name, "@except") == 0)
362 seh_ctx_cur->handler_flags |= UNW_FLAG_EHANDLER;
364 as_bad (_(".seh_handler constant '%s' unknown"), symbol_name);
366 *input_line_pointer = name_end;
368 while (skip_whitespace_and_comma (0));
372 expression (&seh_ctx_cur->handler_data);
373 demand_empty_rest_of_line ();
375 if (seh_ctx_cur->handler_written)
376 as_warn (_(".seh_handler after .seh_eh is ignored"));
380 /* Switch to subsection for handler data for exception region (x64). */
383 obj_coff_seh_handlerdata (int what ATTRIBUTE_UNUSED)
385 if (!verify_context_and_target (".seh_handlerdata", seh_kind_x64))
387 demand_empty_rest_of_line ();
389 switch_xdata (seh_ctx_cur->subsection + 1, seh_ctx_cur->code_seg);
392 /* Mark end of current context. */
395 do_seh_endproc (void)
397 seh_ctx_cur->end_addr = symbol_temp_new_now ();
399 write_function_xdata (seh_ctx_cur);
400 write_function_pdata (seh_ctx_cur);
405 obj_coff_seh_endproc (int what ATTRIBUTE_UNUSED)
407 demand_empty_rest_of_line ();
408 if (seh_ctx_cur == NULL)
410 as_bad (_(".seh_endproc used without .seh_proc"));
413 seh_validate_seg (".seh_endproc");
417 /* Mark begin of new context. */
420 obj_coff_seh_proc (int what ATTRIBUTE_UNUSED)
425 if (seh_ctx_cur != NULL)
427 as_bad (_("previous SEH entry not closed (missing .seh_endproc)"));
431 if (*input_line_pointer == 0 || *input_line_pointer == '\n')
433 as_bad (_(".seh_proc requires function label name"));
434 demand_empty_rest_of_line ();
438 seh_ctx_cur = XCNEW (seh_context);
440 seh_ctx_cur->code_seg = now_seg;
442 if (seh_get_target_kind () == seh_kind_x64)
444 x_segcur = seh_hash_find_or_make (seh_ctx_cur->code_seg, ".xdata");
445 seh_ctx_cur->subsection = x_segcur->subseg;
446 x_segcur->subseg += 2;
451 symbol_name = input_line_pointer;
452 name_end = get_symbol_end ();
453 seh_ctx_cur->func_name = xstrdup (symbol_name);
454 *input_line_pointer = name_end;
456 demand_empty_rest_of_line ();
458 seh_ctx_cur->start_addr = symbol_temp_new_now ();
461 /* Mark end of prologue for current context. */
464 obj_coff_seh_endprologue (int what ATTRIBUTE_UNUSED)
466 if (!verify_context (".seh_endprologue")
467 || !seh_validate_seg (".seh_endprologue"))
469 demand_empty_rest_of_line ();
471 if (seh_ctx_cur->endprologue_addr != NULL)
472 as_warn (_("duplicate .seh_endprologue in .seh_proc block"));
474 seh_ctx_cur->endprologue_addr = symbol_temp_new_now ();
477 /* End-of-file hook. */
480 obj_coff_seh_do_final (void)
482 if (seh_ctx_cur != NULL)
484 as_bad (_("open SEH entry at end of file (missing .cfi_endproc)"));
489 /* Enter a prologue element into current context (x64). */
492 seh_x64_make_prologue_element (int code, int info, offsetT off)
494 seh_prologue_element *n;
496 if (seh_ctx_cur == NULL)
498 if (seh_ctx_cur->elems_count == seh_ctx_cur->elems_max)
500 seh_ctx_cur->elems_max += 8;
501 seh_ctx_cur->elems = XRESIZEVEC (seh_prologue_element,
503 seh_ctx_cur->elems_max);
506 n = &seh_ctx_cur->elems[seh_ctx_cur->elems_count++];
510 n->pc_addr = symbol_temp_new_now ();
513 /* Helper to read a register name from input stream (x64). */
516 seh_x64_read_reg (const char *directive, int kind)
518 static const char * const int_regs[16] =
519 { "rax", "rcx", "rdx", "rbx", "rsp", "rbp","rsi","rdi",
520 "r8","r9","r10","r11","r12","r13","r14","r15" };
521 static const char * const xmm_regs[16] =
522 { "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
523 "xmm8", "xmm9", "xmm10","xmm11","xmm12","xmm13","xmm14","xmm15" };
525 const char * const *regs = NULL;
527 char *symbol_name = NULL;
544 if (*input_line_pointer == '%')
545 ++input_line_pointer;
546 symbol_name = input_line_pointer;
547 name_end = get_symbol_end ();
549 for (i = 0; i < 16; i++)
550 if (! strcasecmp (regs[i], symbol_name))
553 *input_line_pointer = name_end;
555 /* Error if register not found, or EAX used as a frame pointer. */
556 if (i == 16 || (kind == 0 && i == 0))
558 as_bad (_("invalid register for %s"), directive);
565 /* Add a register push-unwind token to the current context. */
568 obj_coff_seh_pushreg (int what ATTRIBUTE_UNUSED)
572 if (!verify_context_and_target (".seh_pushreg", seh_kind_x64)
573 || !seh_validate_seg (".seh_pushreg"))
576 reg = seh_x64_read_reg (".seh_pushreg", 1);
577 demand_empty_rest_of_line ();
582 seh_x64_make_prologue_element (UWOP_PUSH_NONVOL, reg, 0);
585 /* Add a register frame-unwind token to the current context. */
588 obj_coff_seh_pushframe (int what ATTRIBUTE_UNUSED)
590 if (!verify_context_and_target (".seh_pushframe", seh_kind_x64)
591 || !seh_validate_seg (".seh_pushframe"))
593 demand_empty_rest_of_line ();
595 seh_x64_make_prologue_element (UWOP_PUSH_MACHFRAME, 0, 0);
598 /* Add a register save-unwind token to current context. */
601 obj_coff_seh_save (int what)
603 const char *directive = (what == 1 ? ".seh_savereg" : ".seh_savexmm");
604 int code, reg, scale;
607 if (!verify_context_and_target (directive, seh_kind_x64)
608 || !seh_validate_seg (directive))
611 reg = seh_x64_read_reg (directive, what);
613 if (!skip_whitespace_and_comma (1))
616 off = get_absolute_expression ();
617 demand_empty_rest_of_line ();
623 as_bad (_("%s offset is negative"), directive);
627 scale = (what == 1 ? 8 : 16);
629 if ((off & (scale - 1)) == 0 && off <= (offsetT) (0xffff * scale))
631 code = (what == 1 ? UWOP_SAVE_NONVOL : UWOP_SAVE_XMM128);
634 else if (off < (offsetT) 0xffffffff)
635 code = (what == 1 ? UWOP_SAVE_NONVOL_FAR : UWOP_SAVE_XMM128_FAR);
638 as_bad (_("%s offset out of range"), directive);
642 seh_x64_make_prologue_element (code, reg, off);
645 /* Add a stack-allocation token to current context. */
648 obj_coff_seh_stackalloc (int what ATTRIBUTE_UNUSED)
653 if (!verify_context_and_target (".seh_stackalloc", seh_kind_x64)
654 || !seh_validate_seg (".seh_stackalloc"))
657 off = get_absolute_expression ();
658 demand_empty_rest_of_line ();
664 as_bad (_(".seh_stackalloc offset is negative"));
668 if ((off & 7) == 0 && off <= 128)
669 code = UWOP_ALLOC_SMALL, info = (off - 8) >> 3, off = 0;
670 else if ((off & 7) == 0 && off <= (offsetT) (0xffff * 8))
671 code = UWOP_ALLOC_LARGE, info = 0, off >>= 3;
672 else if (off <= (offsetT) 0xffffffff)
673 code = UWOP_ALLOC_LARGE, info = 1;
676 as_bad (_(".seh_stackalloc offset out of range"));
680 seh_x64_make_prologue_element (code, info, off);
683 /* Add a frame-pointer token to current context. */
686 obj_coff_seh_setframe (int what ATTRIBUTE_UNUSED)
691 if (!verify_context_and_target (".seh_setframe", seh_kind_x64)
692 || !seh_validate_seg (".seh_setframe"))
695 reg = seh_x64_read_reg (".seh_setframe", 0);
697 if (!skip_whitespace_and_comma (1))
700 off = get_absolute_expression ();
701 demand_empty_rest_of_line ();
706 as_bad (_(".seh_setframe offset is negative"));
708 as_bad (_(".seh_setframe offset out of range"));
710 as_bad (_(".seh_setframe offset not a multiple of 16"));
711 else if (seh_ctx_cur->framereg != 0)
712 as_bad (_("duplicate .seh_setframe in current .seh_proc"));
715 seh_ctx_cur->framereg = reg;
716 seh_ctx_cur->frameoff = off;
717 seh_x64_make_prologue_element (UWOP_SET_FPREG, 0, 0);
721 /* Data writing routines. */
723 /* Output raw integers in 1, 2, or 4 bytes. */
728 FRAG_APPEND_1_CHAR (byte);
734 md_number_to_chars (frag_more (2), data, 2);
740 md_number_to_chars (frag_more (4), data, 4);
743 /* Write out prologue data for x64. */
746 seh_x64_write_prologue_data (const seh_context *c)
750 /* We have to store in reverse order. */
751 for (i = c->elems_count - 1; i >= 0; --i)
753 const seh_prologue_element *e = c->elems + i;
756 /* First comes byte offset in code. */
757 exp.X_op = O_subtract;
758 exp.X_add_symbol = e->pc_addr;
759 exp.X_op_symbol = c->start_addr;
760 exp.X_add_number = 0;
763 /* Second comes code+info packed into a byte. */
764 out_one ((e->info << 4) | e->code);
768 case UWOP_PUSH_NONVOL:
769 case UWOP_ALLOC_SMALL:
771 case UWOP_PUSH_MACHFRAME:
772 /* These have no extra data. */
775 case UWOP_ALLOC_LARGE:
778 case UWOP_SAVE_NONVOL_FAR:
779 case UWOP_SAVE_XMM128_FAR:
780 /* An unscaled 4 byte offset. */
786 case UWOP_SAVE_NONVOL:
787 case UWOP_SAVE_XMM128:
788 /* A scaled 2 byte offset. */
799 seh_x64_size_prologue_data (const seh_context *c)
803 for (i = c->elems_count - 1; i >= 0; --i)
804 switch (c->elems[i].code)
806 case UWOP_PUSH_NONVOL:
807 case UWOP_ALLOC_SMALL:
809 case UWOP_PUSH_MACHFRAME:
813 case UWOP_SAVE_NONVOL:
814 case UWOP_SAVE_XMM128:
818 case UWOP_SAVE_NONVOL_FAR:
819 case UWOP_SAVE_XMM128_FAR:
823 case UWOP_ALLOC_LARGE:
824 ret += (c->elems[i].info ? 3 : 2);
834 /* Write out the xdata information for one function (x64). */
837 seh_x64_write_function_xdata (seh_context *c)
839 int flags, count_unwind_codes;
842 /* Set 4-byte alignment. */
843 frag_align (2, 0, 0);
845 c->xdata_addr = symbol_temp_new_now ();
846 flags = c->handler_flags;
847 count_unwind_codes = seh_x64_size_prologue_data (c);
849 /* ubyte:3 version, ubyte:5 flags. */
850 out_one ((flags << 3) | 1);
852 /* Size of prologue. */
853 if (c->endprologue_addr)
855 exp.X_op = O_subtract;
856 exp.X_add_symbol = c->endprologue_addr;
857 exp.X_op_symbol = c->start_addr;
858 exp.X_add_number = 0;
864 /* Number of slots (i.e. shorts) in the unwind codes array. */
865 if (count_unwind_codes > 255)
866 as_fatal (_("too much unwind data in this .seh_proc"));
867 out_one (count_unwind_codes);
869 /* ubyte:4 frame-reg, ubyte:4 frame-reg-offset. */
870 /* Note that frameoff is already a multiple of 16, and therefore
871 the offset is already both scaled and shifted into place. */
872 out_one (c->frameoff | c->framereg);
874 seh_x64_write_prologue_data (c);
876 /* We need to align prologue data. */
877 if (count_unwind_codes & 1)
880 if (flags & (UNW_FLAG_EHANDLER | UNW_FLAG_UHANDLER))
882 /* Force the use of segment-relative relocations instead of absolute
883 valued expressions. Don't adjust for constants (e.g. NULL). */
884 if (c->handler.X_op == O_symbol)
885 c->handler.X_op = O_symbol_rva;
886 emit_expr (&c->handler, 4);
889 /* Handler data will be tacked in here by subsections. */
892 /* Write out xdata for one function. */
895 write_function_xdata (seh_context *c)
897 segT save_seg = now_seg;
898 int save_subseg = now_subseg;
900 /* MIPS, SH, ARM don't have xdata. */
901 if (seh_get_target_kind () != seh_kind_x64)
904 switch_xdata (c->subsection, c->code_seg);
906 seh_x64_write_function_xdata (c);
908 subseg_set (save_seg, save_subseg);
911 /* Write pdata section data for one function (arm). */
914 seh_arm_write_function_pdata (seh_context *c)
917 unsigned int prol_len = 0, func_len = 0;
920 /* Start address of the function. */
922 exp.X_add_symbol = c->start_addr;
923 exp.X_add_number = 0;
926 exp.X_op = O_subtract;
927 exp.X_add_symbol = c->end_addr;
928 exp.X_op_symbol = c->start_addr;
929 exp.X_add_number = 0;
930 if (resolve_expression (&exp) && exp.X_op == O_constant)
931 func_len = exp.X_add_number;
933 as_bad (_(".seh_endproc in a different section from .seh_proc"));
935 if (c->endprologue_addr)
937 exp.X_op = O_subtract;
938 exp.X_add_symbol = c->endprologue_addr;
939 exp.X_op_symbol = c->start_addr;
940 exp.X_add_number = 0;
942 if (resolve_expression (&exp) && exp.X_op == O_constant)
943 prol_len = exp.X_add_number;
945 as_bad (_(".seh_endprologue in a different section from .seh_proc"));
948 /* Both function and prologue are in units of instructions. */
949 func_len >>= (c->use_instruction_32 ? 2 : 1);
950 prol_len >>= (c->use_instruction_32 ? 2 : 1);
952 /* Assemble the second word of the pdata. */
953 val = prol_len & 0xff;
954 val |= (func_len & 0x3fffff) << 8;
955 if (c->use_instruction_32)
957 if (c->handler_written)
962 /* Write out pdata for one function. */
965 write_function_pdata (seh_context *c)
968 segT save_seg = now_seg;
969 int save_subseg = now_subseg;
970 memset (&exp, 0, sizeof (expressionS));
971 switch_pdata (c->code_seg);
973 switch (seh_get_target_kind ())
976 exp.X_op = O_symbol_rva;
977 exp.X_add_number = 0;
979 exp.X_add_symbol = c->start_addr;
981 exp.X_op = O_symbol_rva;
982 exp.X_add_number = 0;
983 exp.X_add_symbol = c->end_addr;
985 exp.X_op = O_symbol_rva;
986 exp.X_add_number = 0;
987 exp.X_add_symbol = c->xdata_addr;
993 exp.X_add_number = 0;
995 exp.X_add_symbol = c->start_addr;
997 exp.X_add_symbol = c->end_addr;
1000 emit_expr (&c->handler, 4);
1001 emit_expr (&c->handler_data, 4);
1003 exp.X_add_symbol = (c->endprologue_addr
1004 ? c->endprologue_addr
1006 emit_expr (&exp, 4);
1010 seh_arm_write_function_pdata (c);
1017 subseg_set (save_seg, save_subseg);