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 symbol_name
= input_line_pointer
;
333 name_end
= get_symbol_end ();
335 seh_ctx_cur
->handler
.X_op
= O_constant
;
336 seh_ctx_cur
->handler
.X_add_number
= 0;
338 if (strcasecmp (symbol_name
, "@0") == 0
339 || strcasecmp (symbol_name
, "@null") == 0)
341 else if (strcasecmp (symbol_name
, "@1") == 0)
342 seh_ctx_cur
->handler
.X_add_number
= 1;
344 as_bad (_("unknown constant value '%s' for handler"), symbol_name
);
346 *input_line_pointer
= name_end
;
349 expression (&seh_ctx_cur
->handler
);
351 seh_ctx_cur
->handler_data
.X_op
= O_constant
;
352 seh_ctx_cur
->handler_data
.X_add_number
= 0;
353 seh_ctx_cur
->handler_flags
= 0;
355 if (!skip_whitespace_and_comma (0))
358 if (seh_get_target_kind () == seh_kind_x64
)
362 symbol_name
= input_line_pointer
;
363 name_end
= get_symbol_end ();
365 if (strcasecmp (symbol_name
, "@unwind") == 0)
366 seh_ctx_cur
->handler_flags
|= UNW_FLAG_UHANDLER
;
367 else if (strcasecmp (symbol_name
, "@except") == 0)
368 seh_ctx_cur
->handler_flags
|= UNW_FLAG_EHANDLER
;
370 as_bad (_(".seh_handler constant '%s' unknown"), symbol_name
);
372 *input_line_pointer
= name_end
;
374 while (skip_whitespace_and_comma (0));
378 expression (&seh_ctx_cur
->handler_data
);
379 demand_empty_rest_of_line ();
381 if (seh_ctx_cur
->handler_written
)
382 as_warn (_(".seh_handler after .seh_eh is ignored"));
386 /* Switch to subsection for handler data for exception region (x64). */
389 obj_coff_seh_handlerdata (int what ATTRIBUTE_UNUSED
)
391 if (!verify_context_and_target (".seh_handlerdata", seh_kind_x64
))
393 demand_empty_rest_of_line ();
395 switch_xdata (seh_ctx_cur
->subsection
+ 1, seh_ctx_cur
->code_seg
);
398 /* Mark end of current context. */
401 do_seh_endproc (void)
403 seh_ctx_cur
->end_addr
= symbol_temp_new_now ();
405 write_function_xdata (seh_ctx_cur
);
406 write_function_pdata (seh_ctx_cur
);
411 obj_coff_seh_endproc (int what ATTRIBUTE_UNUSED
)
413 demand_empty_rest_of_line ();
414 if (seh_ctx_cur
== NULL
)
416 as_bad (_(".seh_endproc used without .seh_proc"));
419 seh_validate_seg (".seh_endproc");
423 /* Mark begin of new context. */
426 obj_coff_seh_proc (int what ATTRIBUTE_UNUSED
)
431 if (seh_ctx_cur
!= NULL
)
433 as_bad (_("previous SEH entry not closed (missing .seh_endproc)"));
437 if (*input_line_pointer
== 0 || *input_line_pointer
== '\n')
439 as_bad (_(".seh_proc requires function label name"));
440 demand_empty_rest_of_line ();
444 seh_ctx_cur
= XCNEW (seh_context
);
446 seh_ctx_cur
->code_seg
= now_seg
;
448 if (seh_get_target_kind () == seh_kind_x64
)
450 x_segcur
= seh_hash_find_or_make (seh_ctx_cur
->code_seg
, ".xdata");
451 seh_ctx_cur
->subsection
= x_segcur
->subseg
;
452 x_segcur
->subseg
+= 2;
457 symbol_name
= input_line_pointer
;
458 name_end
= get_symbol_end ();
459 seh_ctx_cur
->func_name
= xstrdup (symbol_name
);
460 *input_line_pointer
= name_end
;
462 demand_empty_rest_of_line ();
464 seh_ctx_cur
->start_addr
= symbol_temp_new_now ();
467 /* Mark end of prologue for current context. */
470 obj_coff_seh_endprologue (int what ATTRIBUTE_UNUSED
)
472 if (!verify_context (".seh_endprologue")
473 || !seh_validate_seg (".seh_endprologue"))
475 demand_empty_rest_of_line ();
477 if (seh_ctx_cur
->endprologue_addr
!= NULL
)
478 as_warn (_("duplicate .seh_endprologue in .seh_proc block"));
480 seh_ctx_cur
->endprologue_addr
= symbol_temp_new_now ();
483 /* End-of-file hook. */
486 obj_coff_seh_do_final (void)
488 if (seh_ctx_cur
!= NULL
)
490 as_bad (_("open SEH entry at end of file (missing .cfi_endproc)"));
495 /* Enter a prologue element into current context (x64). */
498 seh_x64_make_prologue_element (int code
, int info
, offsetT off
)
500 seh_prologue_element
*n
;
502 if (seh_ctx_cur
== NULL
)
504 if (seh_ctx_cur
->elems_count
== seh_ctx_cur
->elems_max
)
506 seh_ctx_cur
->elems_max
+= 8;
507 seh_ctx_cur
->elems
= XRESIZEVEC (seh_prologue_element
,
509 seh_ctx_cur
->elems_max
);
512 n
= &seh_ctx_cur
->elems
[seh_ctx_cur
->elems_count
++];
516 n
->pc_addr
= symbol_temp_new_now ();
519 /* Helper to read a register name from input stream (x64). */
522 seh_x64_read_reg (const char *directive
, int kind
)
524 static const char * const int_regs
[16] =
525 { "rax", "rcx", "rdx", "rbx", "rsp", "rbp","rsi","rdi",
526 "r8","r9","r10","r11","r12","r13","r14","r15" };
527 static const char * const xmm_regs
[16] =
528 { "xmm0", "xmm1", "xmm2", "xmm3", "xmm4", "xmm5", "xmm6", "xmm7",
529 "xmm8", "xmm9", "xmm10","xmm11","xmm12","xmm13","xmm14","xmm15" };
531 const char * const *regs
= NULL
;
533 char *symbol_name
= NULL
;
550 if (*input_line_pointer
== '%')
551 ++input_line_pointer
;
552 symbol_name
= input_line_pointer
;
553 name_end
= get_symbol_end ();
555 for (i
= 0; i
< 16; i
++)
556 if (! strcasecmp (regs
[i
], symbol_name
))
559 *input_line_pointer
= name_end
;
561 /* Error if register not found, or EAX used as a frame pointer. */
562 if (i
== 16 || (kind
== 0 && i
== 0))
564 as_bad (_("invalid register for %s"), directive
);
571 /* Add a register push-unwind token to the current context. */
574 obj_coff_seh_pushreg (int what ATTRIBUTE_UNUSED
)
578 if (!verify_context_and_target (".seh_pushreg", seh_kind_x64
)
579 || !seh_validate_seg (".seh_pushreg"))
582 reg
= seh_x64_read_reg (".seh_pushreg", 1);
583 demand_empty_rest_of_line ();
588 seh_x64_make_prologue_element (UWOP_PUSH_NONVOL
, reg
, 0);
591 /* Add a register frame-unwind token to the current context. */
594 obj_coff_seh_pushframe (int what ATTRIBUTE_UNUSED
)
596 if (!verify_context_and_target (".seh_pushframe", seh_kind_x64
)
597 || !seh_validate_seg (".seh_pushframe"))
599 demand_empty_rest_of_line ();
601 seh_x64_make_prologue_element (UWOP_PUSH_MACHFRAME
, 0, 0);
604 /* Add a register save-unwind token to current context. */
607 obj_coff_seh_save (int what
)
609 const char *directive
= (what
== 1 ? ".seh_savereg" : ".seh_savexmm");
610 int code
, reg
, scale
;
613 if (!verify_context_and_target (directive
, seh_kind_x64
)
614 || !seh_validate_seg (directive
))
617 reg
= seh_x64_read_reg (directive
, what
);
619 if (!skip_whitespace_and_comma (1))
622 off
= get_absolute_expression ();
623 demand_empty_rest_of_line ();
629 as_bad (_("%s offset is negative"), directive
);
633 scale
= (what
== 1 ? 8 : 16);
635 if ((off
& (scale
- 1)) == 0 && off
<= (offsetT
) (0xffff * scale
))
637 code
= (what
== 1 ? UWOP_SAVE_NONVOL
: UWOP_SAVE_XMM128
);
640 else if (off
< (offsetT
) 0xffffffff)
641 code
= (what
== 1 ? UWOP_SAVE_NONVOL_FAR
: UWOP_SAVE_XMM128_FAR
);
644 as_bad (_("%s offset out of range"), directive
);
648 seh_x64_make_prologue_element (code
, reg
, off
);
651 /* Add a stack-allocation token to current context. */
654 obj_coff_seh_stackalloc (int what ATTRIBUTE_UNUSED
)
659 if (!verify_context_and_target (".seh_stackalloc", seh_kind_x64
)
660 || !seh_validate_seg (".seh_stackalloc"))
663 off
= get_absolute_expression ();
664 demand_empty_rest_of_line ();
670 as_bad (_(".seh_stackalloc offset is negative"));
674 if ((off
& 7) == 0 && off
<= 128)
675 code
= UWOP_ALLOC_SMALL
, info
= (off
- 8) >> 3, off
= 0;
676 else if ((off
& 7) == 0 && off
<= (offsetT
) (0xffff * 8))
677 code
= UWOP_ALLOC_LARGE
, info
= 0, off
>>= 3;
678 else if (off
<= (offsetT
) 0xffffffff)
679 code
= UWOP_ALLOC_LARGE
, info
= 1;
682 as_bad (_(".seh_stackalloc offset out of range"));
686 seh_x64_make_prologue_element (code
, info
, off
);
689 /* Add a frame-pointer token to current context. */
692 obj_coff_seh_setframe (int what ATTRIBUTE_UNUSED
)
697 if (!verify_context_and_target (".seh_setframe", seh_kind_x64
)
698 || !seh_validate_seg (".seh_setframe"))
701 reg
= seh_x64_read_reg (".seh_setframe", 0);
703 if (!skip_whitespace_and_comma (1))
706 off
= get_absolute_expression ();
707 demand_empty_rest_of_line ();
712 as_bad (_(".seh_setframe offset is negative"));
714 as_bad (_(".seh_setframe offset out of range"));
716 as_bad (_(".seh_setframe offset not a multiple of 16"));
717 else if (seh_ctx_cur
->framereg
!= 0)
718 as_bad (_("duplicate .seh_setframe in current .seh_proc"));
721 seh_ctx_cur
->framereg
= reg
;
722 seh_ctx_cur
->frameoff
= off
;
723 seh_x64_make_prologue_element (UWOP_SET_FPREG
, 0, 0);
727 /* Data writing routines. */
729 /* Output raw integers in 1, 2, or 4 bytes. */
734 FRAG_APPEND_1_CHAR (byte
);
740 md_number_to_chars (frag_more (2), data
, 2);
746 md_number_to_chars (frag_more (4), data
, 4);
749 /* Write out prologue data for x64. */
752 seh_x64_write_prologue_data (const seh_context
*c
)
756 /* We have to store in reverse order. */
757 for (i
= c
->elems_count
- 1; i
>= 0; --i
)
759 const seh_prologue_element
*e
= c
->elems
+ i
;
762 /* First comes byte offset in code. */
763 exp
.X_op
= O_subtract
;
764 exp
.X_add_symbol
= e
->pc_addr
;
765 exp
.X_op_symbol
= c
->start_addr
;
766 exp
.X_add_number
= 0;
769 /* Second comes code+info packed into a byte. */
770 out_one ((e
->info
<< 4) | e
->code
);
774 case UWOP_PUSH_NONVOL
:
775 case UWOP_ALLOC_SMALL
:
777 case UWOP_PUSH_MACHFRAME
:
778 /* These have no extra data. */
781 case UWOP_ALLOC_LARGE
:
784 case UWOP_SAVE_NONVOL_FAR
:
785 case UWOP_SAVE_XMM128_FAR
:
786 /* An unscaled 4 byte offset. */
792 case UWOP_SAVE_NONVOL
:
793 case UWOP_SAVE_XMM128
:
794 /* A scaled 2 byte offset. */
805 seh_x64_size_prologue_data (const seh_context
*c
)
809 for (i
= c
->elems_count
- 1; i
>= 0; --i
)
810 switch (c
->elems
[i
].code
)
812 case UWOP_PUSH_NONVOL
:
813 case UWOP_ALLOC_SMALL
:
815 case UWOP_PUSH_MACHFRAME
:
819 case UWOP_SAVE_NONVOL
:
820 case UWOP_SAVE_XMM128
:
824 case UWOP_SAVE_NONVOL_FAR
:
825 case UWOP_SAVE_XMM128_FAR
:
829 case UWOP_ALLOC_LARGE
:
830 ret
+= (c
->elems
[i
].info
? 3 : 2);
840 /* Write out the xdata information for one function (x64). */
843 seh_x64_write_function_xdata (seh_context
*c
)
845 int flags
, count_unwind_codes
;
848 /* Set 4-byte alignment. */
849 frag_align (2, 0, 0);
851 c
->xdata_addr
= symbol_temp_new_now ();
852 flags
= c
->handler_flags
;
853 count_unwind_codes
= seh_x64_size_prologue_data (c
);
855 /* ubyte:3 version, ubyte:5 flags. */
856 out_one ((flags
<< 3) | 1);
858 /* Size of prologue. */
859 if (c
->endprologue_addr
)
861 exp
.X_op
= O_subtract
;
862 exp
.X_add_symbol
= c
->endprologue_addr
;
863 exp
.X_op_symbol
= c
->start_addr
;
864 exp
.X_add_number
= 0;
870 /* Number of slots (i.e. shorts) in the unwind codes array. */
871 if (count_unwind_codes
> 255)
872 as_fatal (_("too much unwind data in this .seh_proc"));
873 out_one (count_unwind_codes
);
875 /* ubyte:4 frame-reg, ubyte:4 frame-reg-offset. */
876 /* Note that frameoff is already a multiple of 16, and therefore
877 the offset is already both scaled and shifted into place. */
878 out_one (c
->frameoff
| c
->framereg
);
880 seh_x64_write_prologue_data (c
);
882 /* We need to align prologue data. */
883 if (count_unwind_codes
& 1)
886 if (flags
& (UNW_FLAG_EHANDLER
| UNW_FLAG_UHANDLER
))
888 /* Force the use of segment-relative relocations instead of absolute
889 valued expressions. Don't adjust for constants (e.g. NULL). */
890 if (c
->handler
.X_op
== O_symbol
)
891 c
->handler
.X_op
= O_symbol_rva
;
892 emit_expr (&c
->handler
, 4);
895 /* Handler data will be tacked in here by subsections. */
898 /* Write out xdata for one function. */
901 write_function_xdata (seh_context
*c
)
903 segT save_seg
= now_seg
;
904 int save_subseg
= now_subseg
;
906 /* MIPS, SH, ARM don't have xdata. */
907 if (seh_get_target_kind () != seh_kind_x64
)
910 switch_xdata (c
->subsection
, c
->code_seg
);
912 seh_x64_write_function_xdata (c
);
914 subseg_set (save_seg
, save_subseg
);
917 /* Write pdata section data for one function (arm). */
920 seh_arm_write_function_pdata (seh_context
*c
)
923 unsigned int prol_len
= 0, func_len
= 0;
926 /* Start address of the function. */
928 exp
.X_add_symbol
= c
->start_addr
;
929 exp
.X_add_number
= 0;
932 exp
.X_op
= O_subtract
;
933 exp
.X_add_symbol
= c
->end_addr
;
934 exp
.X_op_symbol
= c
->start_addr
;
935 exp
.X_add_number
= 0;
936 if (resolve_expression (&exp
) && exp
.X_op
== O_constant
)
937 func_len
= exp
.X_add_number
;
939 as_bad (_(".seh_endproc in a different section from .seh_proc"));
941 if (c
->endprologue_addr
)
943 exp
.X_op
= O_subtract
;
944 exp
.X_add_symbol
= c
->endprologue_addr
;
945 exp
.X_op_symbol
= c
->start_addr
;
946 exp
.X_add_number
= 0;
948 if (resolve_expression (&exp
) && exp
.X_op
== O_constant
)
949 prol_len
= exp
.X_add_number
;
951 as_bad (_(".seh_endprologue in a different section from .seh_proc"));
954 /* Both function and prologue are in units of instructions. */
955 func_len
>>= (c
->use_instruction_32
? 2 : 1);
956 prol_len
>>= (c
->use_instruction_32
? 2 : 1);
958 /* Assemble the second word of the pdata. */
959 val
= prol_len
& 0xff;
960 val
|= (func_len
& 0x3fffff) << 8;
961 if (c
->use_instruction_32
)
963 if (c
->handler_written
)
968 /* Write out pdata for one function. */
971 write_function_pdata (seh_context
*c
)
974 segT save_seg
= now_seg
;
975 int save_subseg
= now_subseg
;
976 memset (&exp
, 0, sizeof (expressionS
));
977 switch_pdata (c
->code_seg
);
979 switch (seh_get_target_kind ())
982 exp
.X_op
= O_symbol_rva
;
983 exp
.X_add_number
= 0;
985 exp
.X_add_symbol
= c
->start_addr
;
987 exp
.X_op
= O_symbol_rva
;
988 exp
.X_add_number
= 0;
989 exp
.X_add_symbol
= c
->end_addr
;
991 exp
.X_op
= O_symbol_rva
;
992 exp
.X_add_number
= 0;
993 exp
.X_add_symbol
= c
->xdata_addr
;
999 exp
.X_add_number
= 0;
1001 exp
.X_add_symbol
= c
->start_addr
;
1002 emit_expr (&exp
, 4);
1003 exp
.X_add_symbol
= c
->end_addr
;
1004 emit_expr (&exp
, 4);
1006 emit_expr (&c
->handler
, 4);
1007 emit_expr (&c
->handler_data
, 4);
1009 exp
.X_add_symbol
= (c
->endprologue_addr
1010 ? c
->endprologue_addr
1012 emit_expr (&exp
, 4);
1016 seh_arm_write_function_pdata (c
);
1023 subseg_set (save_seg
, save_subseg
);