1 /* coff object file format
2 Copyright (C) 1989-2014 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 #define OBJ_HEADER "obj-coff.h"
24 #include "safe-ctype.h"
26 #include "struc-symbol.h"
33 #include "coff/xcoff.h"
36 #define streq(a,b) (strcmp ((a), (b)) == 0)
37 #define strneq(a,b,n) (strncmp ((a), (b), (n)) == 0)
39 /* I think this is probably always correct. */
40 #ifndef KEEP_RELOC_INFO
41 #define KEEP_RELOC_INFO
44 /* obj_coff_section will use this macro to set a new section's
45 attributes when a directive has no valid flags or the "w" flag is
46 used. This default should be appropriate for most. */
47 #ifndef TC_COFF_SECTION_DEFAULT_ATTRIBUTES
48 #define TC_COFF_SECTION_DEFAULT_ATTRIBUTES (SEC_LOAD | SEC_DATA)
51 /* This is used to hold the symbol built by a sequence of pseudo-ops
52 from .def and .endef. */
53 static symbolS
*def_symbol_in_progress
;
55 /* PE weak alternate symbols begin with this string. */
56 static const char weak_altprefix
[] = ".weak.";
59 #include "obj-coff-seh.c"
63 unsigned long chunk_size
;
64 unsigned long element_size
;
67 unsigned long pointer
;
75 stack_init (unsigned long chunk_size
,
76 unsigned long element_size
)
80 st
= malloc (sizeof (* st
));
83 st
->data
= malloc (chunk_size
);
90 st
->size
= chunk_size
;
91 st
->chunk_size
= chunk_size
;
92 st
->element_size
= element_size
;
97 stack_push (stack
*st
, char *element
)
99 if (st
->pointer
+ st
->element_size
>= st
->size
)
101 st
->size
+= st
->chunk_size
;
102 if ((st
->data
= xrealloc (st
->data
, st
->size
)) == NULL
)
105 memcpy (st
->data
+ st
->pointer
, element
, st
->element_size
);
106 st
->pointer
+= st
->element_size
;
107 return st
->data
+ st
->pointer
;
111 stack_pop (stack
*st
)
113 if (st
->pointer
< st
->element_size
)
118 st
->pointer
-= st
->element_size
;
119 return st
->data
+ st
->pointer
;
122 /* Maintain a list of the tagnames of the structures. */
124 static struct hash_control
*tag_hash
;
129 tag_hash
= hash_new ();
133 tag_insert (const char *name
, symbolS
*symbolP
)
135 const char *error_string
;
137 if ((error_string
= hash_jam (tag_hash
, name
, (char *) symbolP
)))
138 as_fatal (_("Inserting \"%s\" into structure table failed: %s"),
143 tag_find (char *name
)
145 return (symbolS
*) hash_find (tag_hash
, name
);
149 tag_find_or_make (char *name
)
153 if ((symbolP
= tag_find (name
)) == NULL
)
155 symbolP
= symbol_new (name
, undefined_section
,
156 0, &zero_address_frag
);
158 tag_insert (S_GET_NAME (symbolP
), symbolP
);
159 symbol_table_insert (symbolP
);
165 /* We accept the .bss directive to set the section for backward
166 compatibility with earlier versions of gas. */
169 obj_coff_bss (int ignore ATTRIBUTE_UNUSED
)
171 if (*input_line_pointer
== '\n')
172 subseg_new (".bss", get_absolute_expression ());
178 /* Called from read.c:s_comm after we've parsed .comm symbol, size.
179 Parse a possible alignment value. */
182 obj_coff_common_parse (int ignore ATTRIBUTE_UNUSED
, symbolS
*symbolP
, addressT size
)
186 if (*input_line_pointer
== ',')
188 align
= parse_align (0);
189 if (align
== (addressT
) -1)
193 S_SET_VALUE (symbolP
, size
);
194 S_SET_EXTERNAL (symbolP
);
195 S_SET_SEGMENT (symbolP
, bfd_com_section_ptr
);
197 symbol_get_bfdsym (symbolP
)->flags
|= BSF_OBJECT
;
199 /* There is no S_SET_ALIGN (symbolP, align) in COFF/PE.
200 Instead we must add a note to the .drectve section. */
203 segT current_seg
= now_seg
;
204 subsegT current_subseg
= now_subseg
;
207 size_t pfxlen
, numlen
;
211 sec
= subseg_new (".drectve", 0);
212 oldflags
= bfd_get_section_flags (stdoutput
, sec
);
213 if (oldflags
== SEC_NO_FLAGS
)
215 if (!bfd_set_section_flags (stdoutput
, sec
,
216 TC_COFF_SECTION_DEFAULT_ATTRIBUTES
))
217 as_warn (_("error setting flags for \"%s\": %s"),
218 bfd_section_name (stdoutput
, sec
),
219 bfd_errmsg (bfd_get_error ()));
222 /* Emit a string. Note no NUL-termination. */
223 pfxlen
= strlen (" -aligncomm:") + 2 + strlen (S_GET_NAME (symbolP
)) + 1;
224 numlen
= snprintf (numbuff
, sizeof (numbuff
), "%d", (int) align
);
225 frag
= frag_more (pfxlen
+ numlen
);
226 (void) sprintf (frag
, " -aligncomm:\"%s\",", S_GET_NAME (symbolP
));
227 memcpy (frag
+ pfxlen
, numbuff
, numlen
);
228 /* Restore original subseg. */
229 subseg_set (current_seg
, current_subseg
);
236 obj_coff_comm (int ignore ATTRIBUTE_UNUSED
)
238 s_comm_internal (ignore
, obj_coff_common_parse
);
242 #define GET_FILENAME_STRING(X) \
243 ((char *) (&((X)->sy_symbol.ost_auxent->x_file.x_n.x_offset))[1])
247 fetch_coff_debug_section (void)
249 static segT debug_section
;
255 s
= bfd_make_debug_symbol (stdoutput
, NULL
, 0);
257 debug_section
= s
->section
;
259 return debug_section
;
263 SA_SET_SYM_ENDNDX (symbolS
*sym
, symbolS
*val
)
265 combined_entry_type
*entry
, *p
;
267 entry
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[1];
268 p
= coffsymbol (symbol_get_bfdsym (val
))->native
;
269 entry
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
= p
;
274 SA_SET_SYM_TAGNDX (symbolS
*sym
, symbolS
*val
)
276 combined_entry_type
*entry
, *p
;
278 entry
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[1];
279 p
= coffsymbol (symbol_get_bfdsym (val
))->native
;
280 entry
->u
.auxent
.x_sym
.x_tagndx
.p
= p
;
285 S_GET_DATA_TYPE (symbolS
*sym
)
287 return coffsymbol (symbol_get_bfdsym (sym
))->native
->u
.syment
.n_type
;
291 S_SET_DATA_TYPE (symbolS
*sym
, int val
)
293 coffsymbol (symbol_get_bfdsym (sym
))->native
->u
.syment
.n_type
= val
;
298 S_GET_STORAGE_CLASS (symbolS
*sym
)
300 return coffsymbol (symbol_get_bfdsym (sym
))->native
->u
.syment
.n_sclass
;
304 S_SET_STORAGE_CLASS (symbolS
*sym
, int val
)
306 coffsymbol (symbol_get_bfdsym (sym
))->native
->u
.syment
.n_sclass
= val
;
310 /* Merge a debug symbol containing debug information into a normal symbol. */
313 c_symbol_merge (symbolS
*debug
, symbolS
*normal
)
315 S_SET_DATA_TYPE (normal
, S_GET_DATA_TYPE (debug
));
316 S_SET_STORAGE_CLASS (normal
, S_GET_STORAGE_CLASS (debug
));
318 if (S_GET_NUMBER_AUXILIARY (debug
) > S_GET_NUMBER_AUXILIARY (normal
))
319 /* Take the most we have. */
320 S_SET_NUMBER_AUXILIARY (normal
, S_GET_NUMBER_AUXILIARY (debug
));
322 if (S_GET_NUMBER_AUXILIARY (debug
) > 0)
323 /* Move all the auxiliary information. */
324 memcpy (SYM_AUXINFO (normal
), SYM_AUXINFO (debug
),
325 (S_GET_NUMBER_AUXILIARY (debug
)
326 * sizeof (*SYM_AUXINFO (debug
))));
328 /* Move the debug flags. */
329 SF_SET_DEBUG_FIELD (normal
, SF_GET_DEBUG_FIELD (debug
));
333 c_dot_file_symbol (const char *filename
, int appfile ATTRIBUTE_UNUSED
)
337 /* BFD converts filename to a .file symbol with an aux entry. It
338 also handles chaining. */
339 symbolP
= symbol_new (filename
, bfd_abs_section_ptr
, 0, &zero_address_frag
);
341 S_SET_STORAGE_CLASS (symbolP
, C_FILE
);
342 S_SET_NUMBER_AUXILIARY (symbolP
, 1);
344 symbol_get_bfdsym (symbolP
)->flags
= BSF_DEBUGGING
;
351 listing_source_file (filename
);
355 /* Make sure that the symbol is first on the symbol chain. */
356 if (symbol_rootP
!= symbolP
)
358 symbol_remove (symbolP
, &symbol_rootP
, &symbol_lastP
);
359 symbol_insert (symbolP
, symbol_rootP
, &symbol_rootP
, &symbol_lastP
);
363 /* Line number handling. */
367 struct line_no
*next
;
374 /* Symbol of last function, which we should hang line#s off of. */
375 static symbolS
*line_fsym
;
377 #define in_function() (line_fsym != 0)
378 #define clear_function() (line_fsym = 0)
379 #define set_function(F) (line_fsym = (F), coff_add_linesym (F))
383 coff_obj_symbol_new_hook (symbolS
*symbolP
)
385 long sz
= (OBJ_COFF_MAX_AUXENTRIES
+ 1) * sizeof (combined_entry_type
);
386 char * s
= xmalloc (sz
);
389 coffsymbol (symbol_get_bfdsym (symbolP
))->native
= (combined_entry_type
*) s
;
391 S_SET_DATA_TYPE (symbolP
, T_NULL
);
392 S_SET_STORAGE_CLASS (symbolP
, 0);
393 S_SET_NUMBER_AUXILIARY (symbolP
, 0);
395 if (S_IS_STRING (symbolP
))
396 SF_SET_STRING (symbolP
);
398 if (S_IS_LOCAL (symbolP
))
399 SF_SET_LOCAL (symbolP
);
403 coff_obj_symbol_clone_hook (symbolS
*newsymP
, symbolS
*orgsymP
)
405 long sz
= (OBJ_COFF_MAX_AUXENTRIES
+ 1) * sizeof (combined_entry_type
);
406 combined_entry_type
* s
= xmalloc (sz
);
408 memcpy (s
, coffsymbol (symbol_get_bfdsym (orgsymP
))->native
, sz
);
409 coffsymbol (symbol_get_bfdsym (newsymP
))->native
= s
;
411 SF_SET (newsymP
, SF_GET (orgsymP
));
415 /* Handle .ln directives. */
417 static symbolS
*current_lineno_sym
;
418 static struct line_no
*line_nos
;
419 /* FIXME: Blindly assume all .ln directives will be in the .text section. */
423 add_lineno (fragS
* frag
, addressT offset
, int num
)
425 struct line_no
* new_line
= xmalloc (sizeof (* new_line
));
427 if (!current_lineno_sym
)
431 /* The native aix assembler accepts negative line number. */
435 /* Zero is used as an end marker in the file. */
436 as_warn (_("Line numbers must be positive integers\n"));
439 #endif /* OBJ_XCOFF */
440 new_line
->next
= line_nos
;
441 new_line
->frag
= frag
;
442 new_line
->l
.line_number
= num
;
443 new_line
->l
.u
.offset
= offset
;
449 coff_add_linesym (symbolS
*sym
)
453 coffsymbol (symbol_get_bfdsym (current_lineno_sym
))->lineno
=
458 current_lineno_sym
= sym
;
462 obj_coff_ln (int appline
)
466 if (! appline
&& def_symbol_in_progress
!= NULL
)
468 as_warn (_(".ln pseudo-op inside .def/.endef: ignored."));
469 demand_empty_rest_of_line ();
473 l
= get_absolute_expression ();
475 /* If there is no lineno symbol, treat a .ln
476 directive as if it were a .appline directive. */
477 if (appline
|| current_lineno_sym
== NULL
)
478 new_logical_line ((char *) NULL
, l
- 1);
480 add_lineno (frag_now
, frag_now_fix (), l
);
489 l
+= coff_line_base
- 1;
490 listing_source_line (l
);
495 demand_empty_rest_of_line ();
498 /* .loc is essentially the same as .ln; parse it for assembler
502 obj_coff_loc (int ignore ATTRIBUTE_UNUSED
)
506 /* FIXME: Why do we need this check? We need it for ECOFF, but why
507 do we need it for COFF? */
508 if (now_seg
!= text_section
)
510 as_warn (_(".loc outside of .text"));
511 demand_empty_rest_of_line ();
515 if (def_symbol_in_progress
!= NULL
)
517 as_warn (_(".loc pseudo-op inside .def/.endef: ignored."));
518 demand_empty_rest_of_line ();
522 /* Skip the file number. */
524 get_absolute_expression ();
527 lineno
= get_absolute_expression ();
535 lineno
+= coff_line_base
- 1;
536 listing_source_line (lineno
);
541 demand_empty_rest_of_line ();
543 add_lineno (frag_now
, frag_now_fix (), lineno
);
546 /* Handle the .ident pseudo-op. */
549 obj_coff_ident (int ignore ATTRIBUTE_UNUSED
)
551 segT current_seg
= now_seg
;
552 subsegT current_subseg
= now_subseg
;
558 /* We could put it in .comment, but that creates an extra section
559 that shouldn't be loaded into memory, which requires linker
560 changes... For now, until proven otherwise, use .rdata. */
561 sec
= subseg_new (".rdata$zzz", 0);
562 bfd_set_section_flags (stdoutput
, sec
,
563 ((SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_DATA
)
564 & bfd_applicable_section_flags (stdoutput
)));
567 subseg_new (".comment", 0);
571 subseg_set (current_seg
, current_subseg
);
574 /* Handle .def directives.
576 One might ask : why can't we symbol_new if the symbol does not
577 already exist and fill it with debug information. Because of
578 the C_EFCN special symbol. It would clobber the value of the
579 function symbol before we have a chance to notice that it is
580 a C_EFCN. And a second reason is that the code is more clear this
581 way. (at least I think it is :-). */
583 #define SKIP_SEMI_COLON() while (*input_line_pointer++ != ';')
584 #define SKIP_WHITESPACES() while (*input_line_pointer == ' ' || \
585 *input_line_pointer == '\t') \
586 input_line_pointer++;
589 obj_coff_def (int what ATTRIBUTE_UNUSED
)
591 char name_end
; /* Char after the end of name. */
592 char *symbol_name
; /* Name of the debug symbol. */
593 char *symbol_name_copy
; /* Temporary copy of the name. */
594 unsigned int symbol_name_length
;
596 if (def_symbol_in_progress
!= NULL
)
598 as_warn (_(".def pseudo-op used inside of .def/.endef: ignored."));
599 demand_empty_rest_of_line ();
605 symbol_name
= input_line_pointer
;
606 name_end
= get_symbol_end ();
607 symbol_name_length
= strlen (symbol_name
);
608 symbol_name_copy
= xmalloc (symbol_name_length
+ 1);
609 strcpy (symbol_name_copy
, symbol_name
);
610 #ifdef tc_canonicalize_symbol_name
611 symbol_name_copy
= tc_canonicalize_symbol_name (symbol_name_copy
);
614 /* Initialize the new symbol. */
615 def_symbol_in_progress
= symbol_make (symbol_name_copy
);
616 symbol_set_frag (def_symbol_in_progress
, &zero_address_frag
);
617 S_SET_VALUE (def_symbol_in_progress
, 0);
619 if (S_IS_STRING (def_symbol_in_progress
))
620 SF_SET_STRING (def_symbol_in_progress
);
622 *input_line_pointer
= name_end
;
624 demand_empty_rest_of_line ();
628 obj_coff_endef (int ignore ATTRIBUTE_UNUSED
)
630 symbolS
*symbolP
= NULL
;
632 if (def_symbol_in_progress
== NULL
)
634 as_warn (_(".endef pseudo-op used outside of .def/.endef: ignored."));
635 demand_empty_rest_of_line ();
639 /* Set the section number according to storage class. */
640 switch (S_GET_STORAGE_CLASS (def_symbol_in_progress
))
645 SF_SET_TAG (def_symbol_in_progress
);
649 SF_SET_DEBUG (def_symbol_in_progress
);
650 S_SET_SEGMENT (def_symbol_in_progress
, fetch_coff_debug_section ());
654 SF_SET_LOCAL (def_symbol_in_progress
); /* Do not emit this symbol. */
657 SF_SET_PROCESS (def_symbol_in_progress
); /* Will need processing before writing. */
663 S_SET_SEGMENT (def_symbol_in_progress
, text_section
);
665 name
= S_GET_NAME (def_symbol_in_progress
);
666 if (name
[0] == '.' && name
[2] == 'f' && name
[3] == '\0')
672 if (! in_function ())
673 as_warn (_("`%s' symbol without preceding function"), name
);
674 /* Will need relocating. */
675 SF_SET_PROCESS (def_symbol_in_progress
);
681 /* The MS compilers output the actual endline, not the
682 function-relative one... we want to match without
683 changing the assembler input. */
684 SA_SET_SYM_LNNO (def_symbol_in_progress
,
685 (SA_GET_SYM_LNNO (def_symbol_in_progress
)
696 #endif /* C_AUTOARG */
703 /* According to the COFF documentation:
705 http://osr5doc.sco.com:1996/topics/COFF_SectNumFld.html
707 A special section number (-2) marks symbolic debugging symbols,
708 including structure/union/enumeration tag names, typedefs, and
709 the name of the file. A section number of -1 indicates that the
710 symbol has a value but is not relocatable. Examples of
711 absolute-valued symbols include automatic and register variables,
712 function arguments, and .eos symbols.
714 But from Ian Lance Taylor:
716 http://sources.redhat.com/ml/binutils/2000-08/msg00202.html
718 the actual tools all marked them as section -1. So the GNU COFF
719 assembler follows historical COFF assemblers.
721 However, it causes problems for djgpp
723 http://sources.redhat.com/ml/binutils/2000-08/msg00210.html
725 By defining STRICTCOFF, a COFF port can make the assembler to
726 follow the documented behavior. */
733 SF_SET_DEBUG (def_symbol_in_progress
);
734 S_SET_SEGMENT (def_symbol_in_progress
, absolute_section
);
742 S_SET_SEGMENT (def_symbol_in_progress
, absolute_section
);
753 /* Valid but set somewhere else (s_comm, s_lcomm, colon). */
760 as_warn (_("unexpected storage class %d"),
761 S_GET_STORAGE_CLASS (def_symbol_in_progress
));
765 /* Now that we have built a debug symbol, try to find if we should
766 merge with an existing symbol or not. If a symbol is C_EFCN or
767 absolute_section or untagged SEG_DEBUG it never merges. We also
768 don't merge labels, which are in a different namespace, nor
769 symbols which have not yet been defined since they are typically
770 unique, nor do we merge tags with non-tags. */
772 /* Two cases for functions. Either debug followed by definition or
773 definition followed by debug. For definition first, we will
774 merge the debug symbol into the definition. For debug first, the
775 lineno entry MUST point to the definition function or else it
776 will point off into space when obj_crawl_symbol_chain() merges
777 the debug symbol into the real symbol. Therefor, let's presume
778 the debug symbol is a real function reference. */
780 /* FIXME-SOON If for some reason the definition label/symbol is
781 never seen, this will probably leave an undefined symbol at link
784 if (S_GET_STORAGE_CLASS (def_symbol_in_progress
) == C_EFCN
785 || S_GET_STORAGE_CLASS (def_symbol_in_progress
) == C_LABEL
786 || (streq (bfd_get_section_name (stdoutput
,
787 S_GET_SEGMENT (def_symbol_in_progress
)),
789 && !SF_GET_TAG (def_symbol_in_progress
))
790 || S_GET_SEGMENT (def_symbol_in_progress
) == absolute_section
791 || ! symbol_constant_p (def_symbol_in_progress
)
792 || (symbolP
= symbol_find (S_GET_NAME (def_symbol_in_progress
))) == NULL
793 || SF_GET_TAG (def_symbol_in_progress
) != SF_GET_TAG (symbolP
))
795 /* If it already is at the end of the symbol list, do nothing */
796 if (def_symbol_in_progress
!= symbol_lastP
)
798 symbol_remove (def_symbol_in_progress
, &symbol_rootP
, &symbol_lastP
);
799 symbol_append (def_symbol_in_progress
, symbol_lastP
, &symbol_rootP
,
805 /* This symbol already exists, merge the newly created symbol
806 into the old one. This is not mandatory. The linker can
807 handle duplicate symbols correctly. But I guess that it save
808 a *lot* of space if the assembly file defines a lot of
811 /* The debug entry (def_symbol_in_progress) is merged into the
812 previous definition. */
814 c_symbol_merge (def_symbol_in_progress
, symbolP
);
815 symbol_remove (def_symbol_in_progress
, &symbol_rootP
, &symbol_lastP
);
817 def_symbol_in_progress
= symbolP
;
819 if (SF_GET_FUNCTION (def_symbol_in_progress
)
820 || SF_GET_TAG (def_symbol_in_progress
)
821 || S_GET_STORAGE_CLASS (def_symbol_in_progress
) == C_STAT
)
823 /* For functions, and tags, and static symbols, the symbol
824 *must* be where the debug symbol appears. Move the
825 existing symbol to the current place. */
826 /* If it already is at the end of the symbol list, do nothing. */
827 if (def_symbol_in_progress
!= symbol_lastP
)
829 symbol_remove (def_symbol_in_progress
, &symbol_rootP
, &symbol_lastP
);
830 symbol_append (def_symbol_in_progress
, symbol_lastP
, &symbol_rootP
, &symbol_lastP
);
835 if (SF_GET_TAG (def_symbol_in_progress
))
839 oldtag
= symbol_find (S_GET_NAME (def_symbol_in_progress
));
840 if (oldtag
== NULL
|| ! SF_GET_TAG (oldtag
))
841 tag_insert (S_GET_NAME (def_symbol_in_progress
),
842 def_symbol_in_progress
);
845 if (SF_GET_FUNCTION (def_symbol_in_progress
))
847 set_function (def_symbol_in_progress
);
848 SF_SET_PROCESS (def_symbol_in_progress
);
851 /* That is, if this is the first time we've seen the
853 symbol_table_insert (def_symbol_in_progress
);
857 def_symbol_in_progress
= NULL
;
858 demand_empty_rest_of_line ();
862 obj_coff_dim (int ignore ATTRIBUTE_UNUSED
)
866 if (def_symbol_in_progress
== NULL
)
868 as_warn (_(".dim pseudo-op used outside of .def/.endef: ignored."));
869 demand_empty_rest_of_line ();
873 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
875 for (d_index
= 0; d_index
< DIMNUM
; d_index
++)
878 SA_SET_SYM_DIMEN (def_symbol_in_progress
, d_index
,
879 get_absolute_expression ());
881 switch (*input_line_pointer
)
884 input_line_pointer
++;
888 as_warn (_("badly formed .dim directive ignored"));
897 demand_empty_rest_of_line ();
901 obj_coff_line (int ignore ATTRIBUTE_UNUSED
)
905 if (def_symbol_in_progress
== NULL
)
907 /* Probably stabs-style line? */
912 this_base
= get_absolute_expression ();
913 if (streq (".bf", S_GET_NAME (def_symbol_in_progress
)))
914 coff_line_base
= this_base
;
916 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
917 SA_SET_SYM_LNNO (def_symbol_in_progress
, this_base
);
919 demand_empty_rest_of_line ();
922 if (streq (".bf", S_GET_NAME (def_symbol_in_progress
)))
927 listing_source_line ((unsigned int) this_base
);
933 obj_coff_size (int ignore ATTRIBUTE_UNUSED
)
935 if (def_symbol_in_progress
== NULL
)
937 as_warn (_(".size pseudo-op used outside of .def/.endef ignored."));
938 demand_empty_rest_of_line ();
942 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
943 SA_SET_SYM_SIZE (def_symbol_in_progress
, get_absolute_expression ());
944 demand_empty_rest_of_line ();
948 obj_coff_scl (int ignore ATTRIBUTE_UNUSED
)
950 if (def_symbol_in_progress
== NULL
)
952 as_warn (_(".scl pseudo-op used outside of .def/.endef ignored."));
953 demand_empty_rest_of_line ();
957 S_SET_STORAGE_CLASS (def_symbol_in_progress
, get_absolute_expression ());
958 demand_empty_rest_of_line ();
962 obj_coff_tag (int ignore ATTRIBUTE_UNUSED
)
967 if (def_symbol_in_progress
== NULL
)
969 as_warn (_(".tag pseudo-op used outside of .def/.endef ignored."));
970 demand_empty_rest_of_line ();
974 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
975 symbol_name
= input_line_pointer
;
976 name_end
= get_symbol_end ();
978 #ifdef tc_canonicalize_symbol_name
979 symbol_name
= tc_canonicalize_symbol_name (symbol_name
);
982 /* Assume that the symbol referred to by .tag is always defined.
983 This was a bad assumption. I've added find_or_make. xoxorich. */
984 SA_SET_SYM_TAGNDX (def_symbol_in_progress
,
985 tag_find_or_make (symbol_name
));
986 if (SA_GET_SYM_TAGNDX (def_symbol_in_progress
) == 0L)
987 as_warn (_("tag not found for .tag %s"), symbol_name
);
989 SF_SET_TAGGED (def_symbol_in_progress
);
990 *input_line_pointer
= name_end
;
992 demand_empty_rest_of_line ();
996 obj_coff_type (int ignore ATTRIBUTE_UNUSED
)
998 if (def_symbol_in_progress
== NULL
)
1000 as_warn (_(".type pseudo-op used outside of .def/.endef ignored."));
1001 demand_empty_rest_of_line ();
1005 S_SET_DATA_TYPE (def_symbol_in_progress
, get_absolute_expression ());
1007 if (ISFCN (S_GET_DATA_TYPE (def_symbol_in_progress
)) &&
1008 S_GET_STORAGE_CLASS (def_symbol_in_progress
) != C_TPDEF
)
1009 SF_SET_FUNCTION (def_symbol_in_progress
);
1011 demand_empty_rest_of_line ();
1015 obj_coff_val (int ignore ATTRIBUTE_UNUSED
)
1017 if (def_symbol_in_progress
== NULL
)
1019 as_warn (_(".val pseudo-op used outside of .def/.endef ignored."));
1020 demand_empty_rest_of_line ();
1024 if (is_name_beginner (*input_line_pointer
))
1026 char *symbol_name
= input_line_pointer
;
1027 char name_end
= get_symbol_end ();
1029 #ifdef tc_canonicalize_symbol_name
1030 symbol_name
= tc_canonicalize_symbol_name (symbol_name
);
1032 if (streq (symbol_name
, "."))
1034 /* If the .val is != from the .def (e.g. statics). */
1035 symbol_set_frag (def_symbol_in_progress
, frag_now
);
1036 S_SET_VALUE (def_symbol_in_progress
, (valueT
) frag_now_fix ());
1038 else if (! streq (S_GET_NAME (def_symbol_in_progress
), symbol_name
))
1042 exp
.X_op
= O_symbol
;
1043 exp
.X_add_symbol
= symbol_find_or_make (symbol_name
);
1044 exp
.X_op_symbol
= NULL
;
1045 exp
.X_add_number
= 0;
1046 symbol_set_value_expression (def_symbol_in_progress
, &exp
);
1048 /* If the segment is undefined when the forward reference is
1049 resolved, then copy the segment id from the forward
1051 SF_SET_GET_SEGMENT (def_symbol_in_progress
);
1053 /* FIXME: gcc can generate address expressions here in
1054 unusual cases (search for "obscure" in sdbout.c). We
1055 just ignore the offset here, thus generating incorrect
1056 debugging information. We ignore the rest of the line
1059 /* Otherwise, it is the name of a non debug symbol and its value
1060 will be calculated later. */
1061 *input_line_pointer
= name_end
;
1065 S_SET_VALUE (def_symbol_in_progress
, get_absolute_expression ());
1068 demand_empty_rest_of_line ();
1073 /* Return nonzero if name begins with weak alternate symbol prefix. */
1076 weak_is_altname (const char * name
)
1078 return strneq (name
, weak_altprefix
, sizeof (weak_altprefix
) - 1);
1081 /* Return the name of the alternate symbol
1082 name corresponding to a weak symbol's name. */
1085 weak_name2altname (const char * name
)
1089 alt_name
= xmalloc (sizeof (weak_altprefix
) + strlen (name
));
1090 strcpy (alt_name
, weak_altprefix
);
1091 return strcat (alt_name
, name
);
1094 /* Return the name of the weak symbol corresponding to an
1095 alternate symbol. */
1098 weak_altname2name (const char * name
)
1100 gas_assert (weak_is_altname (name
));
1101 return xstrdup (name
+ 6);
1104 /* Make a weak symbol name unique by
1105 appending the name of an external symbol. */
1108 weak_uniquify (const char * name
)
1111 const char * unique
= "";
1114 if (an_external_name
!= NULL
)
1115 unique
= an_external_name
;
1117 gas_assert (weak_is_altname (name
));
1119 ret
= xmalloc (strlen (name
) + strlen (unique
) + 2);
1122 strcat (ret
, unique
);
1127 pecoff_obj_set_weak_hook (symbolS
*symbolP
)
1129 symbolS
*alternateP
;
1131 /* See _Microsoft Portable Executable and Common Object
1132 File Format Specification_, section 5.5.3.
1133 Create a symbol representing the alternate value.
1134 coff_frob_symbol will set the value of this symbol from
1135 the value of the weak symbol itself. */
1136 S_SET_STORAGE_CLASS (symbolP
, C_NT_WEAK
);
1137 S_SET_NUMBER_AUXILIARY (symbolP
, 1);
1138 SA_SET_SYM_FSIZE (symbolP
, IMAGE_WEAK_EXTERN_SEARCH_NOLIBRARY
);
1140 alternateP
= symbol_find_or_make (weak_name2altname (S_GET_NAME (symbolP
)));
1141 S_SET_EXTERNAL (alternateP
);
1142 S_SET_STORAGE_CLASS (alternateP
, C_NT_WEAK
);
1144 SA_SET_SYM_TAGNDX (symbolP
, alternateP
);
1148 pecoff_obj_clear_weak_hook (symbolS
*symbolP
)
1150 symbolS
*alternateP
;
1152 S_SET_STORAGE_CLASS (symbolP
, 0);
1153 SA_SET_SYM_FSIZE (symbolP
, 0);
1155 alternateP
= symbol_find (weak_name2altname (S_GET_NAME (symbolP
)));
1156 S_CLEAR_EXTERNAL (alternateP
);
1161 /* Handle .weak. This is a GNU extension in formats other than PE. */
1164 obj_coff_weak (int ignore ATTRIBUTE_UNUSED
)
1172 name
= input_line_pointer
;
1173 c
= get_symbol_end ();
1176 as_warn (_("badly formed .weak directive ignored"));
1177 ignore_rest_of_line ();
1181 symbolP
= symbol_find_or_make (name
);
1182 *input_line_pointer
= c
;
1184 S_SET_WEAK (symbolP
);
1188 input_line_pointer
++;
1190 if (*input_line_pointer
== '\n')
1197 demand_empty_rest_of_line ();
1201 coff_obj_read_begin_hook (void)
1203 /* These had better be the same. Usually 18 bytes. */
1204 know (sizeof (SYMENT
) == sizeof (AUXENT
));
1205 know (SYMESZ
== AUXESZ
);
1209 symbolS
*coff_last_function
;
1211 static symbolS
*coff_last_bf
;
1215 coff_frob_symbol (symbolS
*symp
, int *punt
)
1217 static symbolS
*last_tagP
;
1218 static stack
*block_stack
;
1219 static symbolS
*set_end
;
1220 symbolS
*next_set_end
= NULL
;
1222 if (symp
== &abs_symbol
)
1228 if (current_lineno_sym
)
1229 coff_add_linesym (NULL
);
1232 block_stack
= stack_init (512, sizeof (symbolS
*));
1235 if (S_GET_STORAGE_CLASS (symp
) == C_NT_WEAK
1236 && ! S_IS_WEAK (symp
)
1237 && weak_is_altname (S_GET_NAME (symp
)))
1239 /* This is a weak alternate symbol. All processing of
1240 PECOFFweak symbols is done here, through the alternate. */
1241 symbolS
*weakp
= symbol_find_noref (weak_altname2name
1242 (S_GET_NAME (symp
)), 1);
1245 gas_assert (S_GET_NUMBER_AUXILIARY (weakp
) == 1);
1247 if (! S_IS_WEAK (weakp
))
1249 /* The symbol was turned from weak to strong. Discard altname. */
1253 else if (symbol_equated_p (weakp
))
1255 /* The weak symbol has an alternate specified; symp is unneeded. */
1256 S_SET_STORAGE_CLASS (weakp
, C_NT_WEAK
);
1257 SA_SET_SYM_TAGNDX (weakp
,
1258 symbol_get_value_expression (weakp
)->X_add_symbol
);
1260 S_CLEAR_EXTERNAL (symp
);
1266 /* The weak symbol has been assigned an alternate value.
1267 Copy this value to symp, and set symp as weakp's alternate. */
1268 if (S_GET_STORAGE_CLASS (weakp
) != C_NT_WEAK
)
1270 S_SET_STORAGE_CLASS (symp
, S_GET_STORAGE_CLASS (weakp
));
1271 S_SET_STORAGE_CLASS (weakp
, C_NT_WEAK
);
1274 if (S_IS_DEFINED (weakp
))
1276 /* This is a defined weak symbol. Copy value information
1277 from the weak symbol itself to the alternate symbol. */
1278 symbol_set_value_expression (symp
,
1279 symbol_get_value_expression (weakp
));
1280 symbol_set_frag (symp
, symbol_get_frag (weakp
));
1281 S_SET_SEGMENT (symp
, S_GET_SEGMENT (weakp
));
1285 /* This is an undefined weak symbol.
1286 Define the alternate symbol to zero. */
1287 S_SET_VALUE (symp
, 0);
1288 S_SET_SEGMENT (symp
, absolute_section
);
1291 S_SET_NAME (symp
, weak_uniquify (S_GET_NAME (symp
)));
1292 S_SET_STORAGE_CLASS (symp
, C_EXT
);
1294 S_SET_VALUE (weakp
, 0);
1295 S_SET_SEGMENT (weakp
, undefined_section
);
1299 if (S_IS_WEAK (symp
))
1300 S_SET_STORAGE_CLASS (symp
, C_WEAKEXT
);
1303 if (!S_IS_DEFINED (symp
)
1304 && !S_IS_WEAK (symp
)
1305 && S_GET_STORAGE_CLASS (symp
) != C_STAT
)
1306 S_SET_STORAGE_CLASS (symp
, C_EXT
);
1308 if (!SF_GET_DEBUG (symp
))
1312 if (!SF_GET_LOCAL (symp
)
1313 && !SF_GET_STATICS (symp
)
1314 && S_GET_STORAGE_CLASS (symp
) != C_LABEL
1315 && symbol_constant_p (symp
)
1316 && (real
= symbol_find_noref (S_GET_NAME (symp
), 1))
1317 && S_GET_STORAGE_CLASS (real
) == C_NULL
1320 c_symbol_merge (symp
, real
);
1325 if (!S_IS_DEFINED (symp
) && !SF_GET_LOCAL (symp
))
1327 gas_assert (S_GET_VALUE (symp
) == 0);
1328 if (S_IS_WEAKREFD (symp
))
1331 S_SET_EXTERNAL (symp
);
1333 else if (S_GET_STORAGE_CLASS (symp
) == C_NULL
)
1335 if (S_GET_SEGMENT (symp
) == text_section
1336 && symp
!= seg_info (text_section
)->sym
)
1337 S_SET_STORAGE_CLASS (symp
, C_LABEL
);
1339 S_SET_STORAGE_CLASS (symp
, C_STAT
);
1342 if (SF_GET_PROCESS (symp
))
1344 if (S_GET_STORAGE_CLASS (symp
) == C_BLOCK
)
1346 if (streq (S_GET_NAME (symp
), ".bb"))
1347 stack_push (block_stack
, (char *) &symp
);
1352 begin
= *(symbolS
**) stack_pop (block_stack
);
1354 as_warn (_("mismatched .eb"));
1356 next_set_end
= begin
;
1360 if (coff_last_function
== 0 && SF_GET_FUNCTION (symp
)
1361 && S_IS_DEFINED (symp
))
1363 union internal_auxent
*auxp
;
1365 coff_last_function
= symp
;
1366 if (S_GET_NUMBER_AUXILIARY (symp
) < 1)
1367 S_SET_NUMBER_AUXILIARY (symp
, 1);
1368 auxp
= SYM_AUXENT (symp
);
1369 memset (auxp
->x_sym
.x_fcnary
.x_ary
.x_dimen
, 0,
1370 sizeof (auxp
->x_sym
.x_fcnary
.x_ary
.x_dimen
));
1373 if (S_GET_STORAGE_CLASS (symp
) == C_EFCN
1374 && S_IS_DEFINED (symp
))
1376 if (coff_last_function
== 0)
1377 as_fatal (_("C_EFCN symbol for %s out of scope"),
1379 SA_SET_SYM_FSIZE (coff_last_function
,
1380 (long) (S_GET_VALUE (symp
)
1381 - S_GET_VALUE (coff_last_function
)));
1382 next_set_end
= coff_last_function
;
1383 coff_last_function
= 0;
1387 if (S_IS_EXTERNAL (symp
))
1388 S_SET_STORAGE_CLASS (symp
, C_EXT
);
1389 else if (SF_GET_LOCAL (symp
))
1392 if (SF_GET_FUNCTION (symp
))
1393 symbol_get_bfdsym (symp
)->flags
|= BSF_FUNCTION
;
1396 /* Double check weak symbols. */
1397 if (S_IS_WEAK (symp
) && S_IS_COMMON (symp
))
1398 as_bad (_("Symbol `%s' can not be both weak and common"),
1401 if (SF_GET_TAG (symp
))
1403 else if (S_GET_STORAGE_CLASS (symp
) == C_EOS
)
1404 next_set_end
= last_tagP
;
1407 /* This is pretty horrible, but we have to set *punt correctly in
1408 order to call SA_SET_SYM_ENDNDX correctly. */
1409 if (! symbol_used_in_reloc_p (symp
)
1410 && ((symbol_get_bfdsym (symp
)->flags
& BSF_SECTION_SYM
) != 0
1411 || (! (S_IS_EXTERNAL (symp
) || S_IS_WEAK (symp
))
1412 && ! symbol_get_tc (symp
)->output
1413 && S_GET_STORAGE_CLASS (symp
) != C_FILE
)))
1417 if (set_end
!= (symbolS
*) NULL
1419 && ((symbol_get_bfdsym (symp
)->flags
& BSF_NOT_AT_END
) != 0
1420 || (S_IS_DEFINED (symp
)
1421 && ! S_IS_COMMON (symp
)
1422 && (! S_IS_EXTERNAL (symp
) || SF_GET_FUNCTION (symp
)))))
1424 SA_SET_SYM_ENDNDX (set_end
, symp
);
1428 if (next_set_end
!= NULL
)
1430 if (set_end
!= NULL
)
1431 as_warn (_("Warning: internal error: forgetting to set endndx of %s"),
1432 S_GET_NAME (set_end
));
1433 set_end
= next_set_end
;
1438 && S_GET_STORAGE_CLASS (symp
) == C_FCN
1439 && streq (S_GET_NAME (symp
), ".bf"))
1441 if (coff_last_bf
!= NULL
)
1442 SA_SET_SYM_ENDNDX (coff_last_bf
, symp
);
1443 coff_last_bf
= symp
;
1446 if (coffsymbol (symbol_get_bfdsym (symp
))->lineno
)
1449 struct line_no
*lptr
;
1452 lptr
= (struct line_no
*) coffsymbol (symbol_get_bfdsym (symp
))->lineno
;
1453 for (i
= 0; lptr
; lptr
= lptr
->next
)
1455 lptr
= (struct line_no
*) coffsymbol (symbol_get_bfdsym (symp
))->lineno
;
1457 /* We need i entries for line numbers, plus 1 for the first
1458 entry which BFD will override, plus 1 for the last zero
1459 entry (a marker for BFD). */
1460 l
= xmalloc ((i
+ 2) * sizeof (* l
));
1461 coffsymbol (symbol_get_bfdsym (symp
))->lineno
= l
;
1462 l
[i
+ 1].line_number
= 0;
1463 l
[i
+ 1].u
.sym
= NULL
;
1467 lptr
->l
.u
.offset
+= lptr
->frag
->fr_address
/ OCTETS_PER_BYTE
;
1475 coff_adjust_section_syms (bfd
*abfd ATTRIBUTE_UNUSED
,
1477 void * x ATTRIBUTE_UNUSED
)
1480 segment_info_type
*seginfo
= seg_info (sec
);
1481 int nlnno
, nrelocs
= 0;
1483 /* RS/6000 gas creates a .debug section manually in ppc_frob_file in
1484 tc-ppc.c. Do not get confused by it. */
1485 if (seginfo
== NULL
)
1488 if (streq (sec
->name
, ".text"))
1489 nlnno
= coff_n_line_nos
;
1493 /* @@ Hope that none of the fixups expand to more than one reloc
1495 fixS
*fixp
= seginfo
->fix_root
;
1498 if (! fixp
->fx_done
)
1500 fixp
= fixp
->fx_next
;
1503 if (bfd_get_section_size (sec
) == 0
1506 && sec
!= text_section
1507 && sec
!= data_section
1508 && sec
!= bss_section
)
1511 secsym
= section_symbol (sec
);
1512 /* This is an estimate; we'll plug in the real value using
1513 SET_SECTION_RELOCS later */
1514 SA_SET_SCN_NRELOC (secsym
, nrelocs
);
1515 SA_SET_SCN_NLINNO (secsym
, nlnno
);
1519 coff_frob_file_after_relocs (void)
1521 bfd_map_over_sections (stdoutput
, coff_adjust_section_syms
, NULL
);
1524 /* Implement the .section pseudo op:
1525 .section name {, "flags"}
1527 | +--- optional flags: 'b' for bss
1529 +-- section name 'l' for lib
1533 'd' (apparently m88k for data)
1536 'r' for read-only data
1537 's' for shared data (PE)
1539 '0' - '9' for power-of-two alignment (GNU extension).
1540 But if the argument is not a quoted string, treat it as a
1543 Note the 'a' flag is silently ignored. This allows the same
1544 .section directive to be parsed in both ELF and COFF formats. */
1547 obj_coff_section (int ignore ATTRIBUTE_UNUSED
)
1549 /* Strip out the section name. */
1555 flagword flags
, oldflags
;
1566 section_name
= input_line_pointer
;
1567 c
= get_symbol_end ();
1569 name
= xmalloc (input_line_pointer
- section_name
+ 1);
1570 strcpy (name
, section_name
);
1572 *input_line_pointer
= c
;
1577 flags
= SEC_NO_FLAGS
;
1579 if (*input_line_pointer
== ',')
1581 ++input_line_pointer
;
1583 if (*input_line_pointer
!= '"')
1584 exp
= get_absolute_expression ();
1588 int readonly_removed
= 0;
1589 int load_removed
= 0;
1591 while (attr
= *++input_line_pointer
,
1593 && ! is_end_of_line
[attr
])
1597 alignment
= attr
- '0';
1603 /* Exclude section from linking. */
1604 flags
|= SEC_EXCLUDE
;
1608 /* Uninitialised data section. */
1614 /* Section not loaded. */
1616 flags
|= SEC_NEVER_LOAD
;
1621 /* Shared section. */
1622 flags
|= SEC_COFF_SHARED
;
1629 flags
&=~ SEC_READONLY
;
1633 /* Writable section. */
1634 flags
&=~ SEC_READONLY
;
1635 readonly_removed
= 1;
1639 /* Ignore. Here for compatibility with ELF. */
1642 case 'r': /* Read-only section. Implies a data section. */
1643 readonly_removed
= 0;
1645 case 'x': /* Executable section. */
1646 /* If we are setting the 'x' attribute or if the 'r'
1647 attribute is being used to restore the readonly status
1648 of a code section (eg "wxr") then set the SEC_CODE flag,
1649 otherwise set the SEC_DATA flag. */
1650 flags
|= (attr
== 'x' || (flags
& SEC_CODE
) ? SEC_CODE
: SEC_DATA
);
1653 /* Note - the READONLY flag is set here, even for the 'x'
1654 attribute in order to be compatible with the MSVC
1656 if (! readonly_removed
)
1657 flags
|= SEC_READONLY
;
1661 flags
|= SEC_COFF_NOREAD
| SEC_READONLY
;
1664 case 'i': /* STYP_INFO */
1665 case 'l': /* STYP_LIB */
1666 case 'o': /* STYP_OVER */
1667 as_warn (_("unsupported section attribute '%c'"), attr
);
1671 as_warn (_("unknown section attribute '%c'"), attr
);
1676 ++input_line_pointer
;
1680 sec
= subseg_new (name
, (subsegT
) exp
);
1683 sec
->alignment_power
= alignment
;
1685 oldflags
= bfd_get_section_flags (stdoutput
, sec
);
1686 if (oldflags
== SEC_NO_FLAGS
)
1688 /* Set section flags for a new section just created by subseg_new.
1689 Provide a default if no flags were parsed. */
1690 if (flags
== SEC_NO_FLAGS
)
1691 flags
= TC_COFF_SECTION_DEFAULT_ATTRIBUTES
;
1693 #ifdef COFF_LONG_SECTION_NAMES
1694 /* Add SEC_LINK_ONCE and SEC_LINK_DUPLICATES_DISCARD to .gnu.linkonce
1695 sections so adjust_reloc_syms in write.c will correctly handle
1696 relocs which refer to non-local symbols in these sections. */
1697 if (strneq (name
, ".gnu.linkonce", sizeof (".gnu.linkonce") - 1))
1698 flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
1701 if (! bfd_set_section_flags (stdoutput
, sec
, flags
))
1702 as_warn (_("error setting flags for \"%s\": %s"),
1703 bfd_section_name (stdoutput
, sec
),
1704 bfd_errmsg (bfd_get_error ()));
1706 else if (flags
!= SEC_NO_FLAGS
)
1708 /* This section's attributes have already been set. Warn if the
1709 attributes don't match. */
1710 flagword matchflags
= (SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_CODE
1711 | SEC_DATA
| SEC_COFF_SHARED
| SEC_NEVER_LOAD
1713 if ((flags
^ oldflags
) & matchflags
)
1714 as_warn (_("Ignoring changed section attributes for %s"), name
);
1717 demand_empty_rest_of_line ();
1721 coff_adjust_symtab (void)
1723 if (symbol_rootP
== NULL
1724 || S_GET_STORAGE_CLASS (symbol_rootP
) != C_FILE
)
1725 c_dot_file_symbol ("fake", 0);
1729 coff_frob_section (segT sec
)
1736 /* The COFF back end in BFD requires that all section sizes be
1737 rounded up to multiples of the corresponding section alignments,
1738 supposedly because standard COFF has no other way of encoding alignment
1739 for sections. If your COFF flavor has a different way of encoding
1740 section alignment, then skip this step, as TICOFF does. */
1741 bfd_vma size
= bfd_get_section_size (sec
);
1742 #if !defined(TICOFF)
1743 bfd_vma align_power
= (bfd_vma
) sec
->alignment_power
+ OCTETS_PER_BYTE_POWER
;
1744 bfd_vma mask
= ((bfd_vma
) 1 << align_power
) - 1;
1751 new_size
= (size
+ mask
) & ~mask
;
1752 bfd_set_section_size (stdoutput
, sec
, new_size
);
1754 /* If the size had to be rounded up, add some padding in
1755 the last non-empty frag. */
1756 fragp
= seg_info (sec
)->frchainP
->frch_root
;
1757 last
= seg_info (sec
)->frchainP
->frch_last
;
1758 while (fragp
->fr_next
!= last
)
1759 fragp
= fragp
->fr_next
;
1760 last
->fr_address
= size
;
1761 fragp
->fr_offset
+= new_size
- size
;
1765 /* If the section size is non-zero, the section symbol needs an aux
1766 entry associated with it, indicating the size. We don't know
1767 all the values yet; coff_frob_symbol will fill them in later. */
1770 || sec
== text_section
1771 || sec
== data_section
1772 || sec
== bss_section
)
1775 symbolS
*secsym
= section_symbol (sec
);
1776 unsigned char sclass
= C_STAT
;
1779 if (bfd_get_section_flags (stdoutput
, sec
) & SEC_DEBUGGING
)
1782 S_SET_STORAGE_CLASS (secsym
, sclass
);
1783 S_SET_NUMBER_AUXILIARY (secsym
, 1);
1784 SF_SET_STATICS (secsym
);
1785 SA_SET_SCN_SCNLEN (secsym
, size
);
1787 /* FIXME: These should be in a "stabs.h" file, or maybe as.h. */
1788 #ifndef STAB_SECTION_NAME
1789 #define STAB_SECTION_NAME ".stab"
1791 #ifndef STAB_STRING_SECTION_NAME
1792 #define STAB_STRING_SECTION_NAME ".stabstr"
1794 if (! streq (STAB_STRING_SECTION_NAME
, sec
->name
))
1798 sec
= subseg_get (STAB_SECTION_NAME
, 0);
1799 /* size is already rounded up, since other section will be listed first */
1800 size
= bfd_get_section_size (strsec
);
1802 n_entries
= bfd_get_section_size (sec
) / 12 - 1;
1804 /* Find first non-empty frag. It should be large enough. */
1805 fragp
= seg_info (sec
)->frchainP
->frch_root
;
1806 while (fragp
&& fragp
->fr_fix
== 0)
1807 fragp
= fragp
->fr_next
;
1808 gas_assert (fragp
!= 0 && fragp
->fr_fix
>= 12);
1810 /* Store the values. */
1811 p
= fragp
->fr_literal
;
1812 bfd_h_put_16 (stdoutput
, n_entries
, (bfd_byte
*) p
+ 6);
1813 bfd_h_put_32 (stdoutput
, size
, (bfd_byte
*) p
+ 8);
1817 obj_coff_init_stab_section (segT seg
)
1822 unsigned int stroff
;
1824 /* Make space for this first symbol. */
1828 as_where (&file
, (unsigned int *) NULL
);
1829 stabstr_name
= xmalloc (strlen (seg
->name
) + 4);
1830 strcpy (stabstr_name
, seg
->name
);
1831 strcat (stabstr_name
, "str");
1832 stroff
= get_stab_string_offset (file
, stabstr_name
);
1834 md_number_to_chars (p
, stroff
, 4);
1838 const char * s_get_name (symbolS
*);
1841 s_get_name (symbolS
*s
)
1843 return ((s
== NULL
) ? "(NULL)" : S_GET_NAME (s
));
1846 void symbol_dump (void);
1853 for (symbolP
= symbol_rootP
; symbolP
; symbolP
= symbol_next (symbolP
))
1854 printf (_("0x%lx: \"%s\" type = %ld, class = %d, segment = %d\n"),
1855 (unsigned long) symbolP
,
1856 S_GET_NAME (symbolP
),
1857 (long) S_GET_DATA_TYPE (symbolP
),
1858 S_GET_STORAGE_CLASS (symbolP
),
1859 (int) S_GET_SEGMENT (symbolP
));
1864 const pseudo_typeS coff_pseudo_table
[] =
1866 {"ABORT", s_abort
, 0},
1867 {"appline", obj_coff_ln
, 1},
1868 /* We accept the .bss directive for backward compatibility with
1869 earlier versions of gas. */
1870 {"bss", obj_coff_bss
, 0},
1872 /* PE provides an enhanced version of .comm with alignment. */
1873 {"comm", obj_coff_comm
, 0},
1875 {"def", obj_coff_def
, 0},
1876 {"dim", obj_coff_dim
, 0},
1877 {"endef", obj_coff_endef
, 0},
1878 {"ident", obj_coff_ident
, 0},
1879 {"line", obj_coff_line
, 0},
1880 {"ln", obj_coff_ln
, 0},
1881 {"scl", obj_coff_scl
, 0},
1882 {"sect", obj_coff_section
, 0},
1883 {"sect.s", obj_coff_section
, 0},
1884 {"section", obj_coff_section
, 0},
1885 {"section.s", obj_coff_section
, 0},
1886 /* FIXME: We ignore the MRI short attribute. */
1887 {"size", obj_coff_size
, 0},
1888 {"tag", obj_coff_tag
, 0},
1889 {"type", obj_coff_type
, 0},
1890 {"val", obj_coff_val
, 0},
1891 {"version", s_ignore
, 0},
1892 {"loc", obj_coff_loc
, 0},
1893 {"optim", s_ignore
, 0}, /* For sun386i cc (?) */
1894 {"weak", obj_coff_weak
, 0},
1895 #if defined TC_TIC4X
1896 /* The tic4x uses sdef instead of def. */
1897 {"sdef", obj_coff_def
, 0},
1899 #if defined(SEH_CMDS)
1906 /* Support for a COFF emulation. */
1909 coff_pop_insert (void)
1911 pop_insert (coff_pseudo_table
);
1915 coff_separate_stab_sections (void)
1920 const struct format_ops coff_format_ops
=
1922 bfd_target_coff_flavour
,
1923 0, /* dfl_leading_underscore */
1924 1, /* emit_section_symbols */
1929 0, /* frob_file_before_adjust */
1930 0, /* frob_file_before_fix */
1931 coff_frob_file_after_relocs
,
1934 0, /* s_get_align */
1935 0, /* s_set_align */
1936 0, /* s_get_other */
1937 0, /* s_set_other */
1942 0, /* copy_symbol_attributes */
1943 0, /* generate_asm_lineno */
1944 0, /* process_stab */
1945 coff_separate_stab_sections
,
1946 obj_coff_init_stab_section
,
1947 0, /* sec_sym_ok_for_reloc */
1949 0, /* ecoff_set_ext */
1950 coff_obj_read_begin_hook
,
1951 coff_obj_symbol_new_hook
,
1952 coff_obj_symbol_clone_hook
,