1 /* coff object file format
2 Copyright (C) 1989, 90, 91, 92, 93, 94, 95, 96, 97, 98, 1999
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 2, 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, 59 Temple Place - Suite 330, Boston, MA
22 #define OBJ_HEADER "obj-coff.h"
28 /* I think this is probably always correct. */
29 #ifndef KEEP_RELOC_INFO
30 #define KEEP_RELOC_INFO
33 static void obj_coff_bss
PARAMS ((int));
34 const char *s_get_name
PARAMS ((symbolS
* s
));
35 static symbolS
*def_symbol_in_progress
;
41 unsigned long chunk_size
;
42 unsigned long element_size
;
45 unsigned long pointer
;
50 stack_init (chunk_size
, element_size
)
51 unsigned long chunk_size
;
52 unsigned long element_size
;
56 st
= (stack
*) malloc (sizeof (stack
));
59 st
->data
= malloc (chunk_size
);
66 st
->size
= chunk_size
;
67 st
->chunk_size
= chunk_size
;
68 st
->element_size
= element_size
;
73 /* Not currently used. */
84 stack_push (st
, element
)
88 if (st
->pointer
+ st
->element_size
>= st
->size
)
90 st
->size
+= st
->chunk_size
;
91 if ((st
->data
= xrealloc (st
->data
, st
->size
)) == (char *) 0)
94 memcpy (st
->data
+ st
->pointer
, element
, st
->element_size
);
95 st
->pointer
+= st
->element_size
;
96 return st
->data
+ st
->pointer
;
103 if (st
->pointer
< st
->element_size
)
108 st
->pointer
-= st
->element_size
;
109 return st
->data
+ st
->pointer
;
113 * Maintain a list of the tagnames of the structres.
116 static struct hash_control
*tag_hash
;
121 tag_hash
= hash_new ();
125 tag_insert (name
, symbolP
)
129 const char *error_string
;
131 if ((error_string
= hash_jam (tag_hash
, name
, (char *) symbolP
)))
133 as_fatal (_("Inserting \"%s\" into structure table failed: %s"),
142 #ifdef STRIP_UNDERSCORE
145 #endif /* STRIP_UNDERSCORE */
146 return (symbolS
*) hash_find (tag_hash
, name
);
150 tag_find_or_make (name
)
155 if ((symbolP
= tag_find (name
)) == NULL
)
157 symbolP
= symbol_new (name
, undefined_section
,
158 0, &zero_address_frag
);
160 tag_insert (S_GET_NAME (symbolP
), symbolP
);
162 symbol_table_insert (symbolP
);
169 /* We accept the .bss directive to set the section for backward
170 compatibility with earlier versions of gas. */
173 obj_coff_bss (ignore
)
174 int ignore ATTRIBUTE_UNUSED
;
176 if (*input_line_pointer
== '\n')
177 subseg_new (".bss", get_absolute_expression ());
182 /* Handle .weak. This is a GNU extension. */
185 obj_coff_weak (ignore
)
186 int ignore ATTRIBUTE_UNUSED
;
194 name
= input_line_pointer
;
195 c
= get_symbol_end ();
196 symbolP
= symbol_find_or_make (name
);
197 *input_line_pointer
= c
;
201 S_SET_WEAK (symbolP
);
205 S_SET_STORAGE_CLASS (symbolP
, C_NT_WEAK
);
207 S_SET_STORAGE_CLASS (symbolP
, C_WEAKEXT
);
212 input_line_pointer
++;
214 if (*input_line_pointer
== '\n')
220 demand_empty_rest_of_line ();
225 static void SA_SET_SYM_TAGNDX
PARAMS ((symbolS
*, symbolS
*));
227 #define GET_FILENAME_STRING(X) \
228 ((char*)(&((X)->sy_symbol.ost_auxent->x_file.x_n.x_offset))[1])
232 fetch_coff_debug_section ()
234 static segT debug_section
;
238 s
= bfd_make_debug_symbol (stdoutput
, (char *) 0, 0);
240 debug_section
= s
->section
;
242 return debug_section
;
246 SA_SET_SYM_ENDNDX (sym
, val
)
250 combined_entry_type
*entry
, *p
;
252 entry
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[1];
253 p
= coffsymbol (symbol_get_bfdsym (val
))->native
;
254 entry
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
= p
;
259 SA_SET_SYM_TAGNDX (sym
, val
)
263 combined_entry_type
*entry
, *p
;
265 entry
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[1];
266 p
= coffsymbol (symbol_get_bfdsym (val
))->native
;
267 entry
->u
.auxent
.x_sym
.x_tagndx
.p
= p
;
272 S_GET_DATA_TYPE (sym
)
275 return coffsymbol (symbol_get_bfdsym (sym
))->native
->u
.syment
.n_type
;
279 S_SET_DATA_TYPE (sym
, val
)
283 coffsymbol (symbol_get_bfdsym (sym
))->native
->u
.syment
.n_type
= val
;
288 S_GET_STORAGE_CLASS (sym
)
291 return coffsymbol (symbol_get_bfdsym (sym
))->native
->u
.syment
.n_sclass
;
295 S_SET_STORAGE_CLASS (sym
, val
)
299 coffsymbol (symbol_get_bfdsym (sym
))->native
->u
.syment
.n_sclass
= val
;
303 /* Merge a debug symbol containing debug information into a normal symbol. */
306 c_symbol_merge (debug
, normal
)
310 S_SET_DATA_TYPE (normal
, S_GET_DATA_TYPE (debug
));
311 S_SET_STORAGE_CLASS (normal
, S_GET_STORAGE_CLASS (debug
));
313 if (S_GET_NUMBER_AUXILIARY (debug
) > S_GET_NUMBER_AUXILIARY (normal
))
315 /* take the most we have */
316 S_SET_NUMBER_AUXILIARY (normal
, S_GET_NUMBER_AUXILIARY (debug
));
319 if (S_GET_NUMBER_AUXILIARY (debug
) > 0)
321 /* Move all the auxiliary information. */
322 memcpy (SYM_AUXINFO (normal
), SYM_AUXINFO (debug
),
323 (S_GET_NUMBER_AUXILIARY (debug
)
324 * sizeof (*SYM_AUXINFO (debug
))));
327 /* Move the debug flags. */
328 SF_SET_DEBUG_FIELD (normal
, SF_GET_DEBUG_FIELD (debug
));
332 c_dot_file_symbol (filename
)
337 symbolP
= symbol_new (filename
, bfd_abs_section_ptr
, 0, &zero_address_frag
);
339 S_SET_STORAGE_CLASS (symbolP
, C_FILE
);
340 S_SET_NUMBER_AUXILIARY (symbolP
, 1);
342 symbol_get_bfdsym (symbolP
)->flags
= BSF_DEBUGGING
;
349 listing_source_file (filename
);
354 /* Make sure that the symbol is first on the symbol chain */
355 if (symbol_rootP
!= symbolP
)
357 symbol_remove (symbolP
, &symbol_rootP
, &symbol_lastP
);
358 symbol_insert (symbolP
, symbol_rootP
, &symbol_rootP
, &symbol_lastP
);
359 } /* if not first on the list */
362 /* Line number handling */
365 struct line_no
*next
;
372 /* Symbol of last function, which we should hang line#s off of. */
373 static symbolS
*line_fsym
;
375 #define in_function() (line_fsym != 0)
376 #define clear_function() (line_fsym = 0)
377 #define set_function(F) (line_fsym = (F), coff_add_linesym (F))
381 coff_obj_symbol_new_hook (symbolP
)
384 long sz
= (OBJ_COFF_MAX_AUXENTRIES
+ 1) * sizeof (combined_entry_type
);
385 char * s
= (char *) xmalloc (sz
);
388 coffsymbol (symbol_get_bfdsym (symbolP
))->native
= (combined_entry_type
*) s
;
390 S_SET_DATA_TYPE (symbolP
, T_NULL
);
391 S_SET_STORAGE_CLASS (symbolP
, 0);
392 S_SET_NUMBER_AUXILIARY (symbolP
, 0);
394 if (S_IS_STRING (symbolP
))
395 SF_SET_STRING (symbolP
);
397 if (S_IS_LOCAL (symbolP
))
398 SF_SET_LOCAL (symbolP
);
403 * Handle .ln directives.
406 static symbolS
*current_lineno_sym
;
407 static struct line_no
*line_nos
;
408 /* @@ Blindly assume all .ln directives will be in the .text section... */
412 add_lineno (frag
, offset
, num
)
417 struct line_no
*new_line
=
418 (struct line_no
*) xmalloc (sizeof (struct line_no
));
419 if (!current_lineno_sym
)
423 new_line
->next
= line_nos
;
424 new_line
->frag
= frag
;
425 new_line
->l
.line_number
= num
;
426 new_line
->l
.u
.offset
= offset
;
432 coff_add_linesym (sym
)
437 coffsymbol (symbol_get_bfdsym (current_lineno_sym
))->lineno
=
442 current_lineno_sym
= sym
;
446 obj_coff_ln (appline
)
451 if (! appline
&& def_symbol_in_progress
!= NULL
)
453 as_warn (_(".ln pseudo-op inside .def/.endef: ignored."));
454 demand_empty_rest_of_line ();
458 l
= get_absolute_expression ();
461 add_lineno (frag_now
, frag_now_fix (), l
);
465 new_logical_line ((char *) NULL
, l
- 1);
474 l
+= coff_line_base
- 1;
475 listing_source_line (l
);
480 demand_empty_rest_of_line ();
486 * Handle .def directives.
488 * One might ask : why can't we symbol_new if the symbol does not
489 * already exist and fill it with debug information. Because of
490 * the C_EFCN special symbol. It would clobber the value of the
491 * function symbol before we have a chance to notice that it is
492 * a C_EFCN. And a second reason is that the code is more clear this
493 * way. (at least I think it is :-).
497 #define SKIP_SEMI_COLON() while (*input_line_pointer++ != ';')
498 #define SKIP_WHITESPACES() while (*input_line_pointer == ' ' || \
499 *input_line_pointer == '\t') \
500 input_line_pointer++;
504 int what ATTRIBUTE_UNUSED
;
506 char name_end
; /* Char after the end of name */
507 char *symbol_name
; /* Name of the debug symbol */
508 char *symbol_name_copy
; /* Temporary copy of the name */
509 unsigned int symbol_name_length
;
511 if (def_symbol_in_progress
!= NULL
)
513 as_warn (_(".def pseudo-op used inside of .def/.endef: ignored."));
514 demand_empty_rest_of_line ();
516 } /* if not inside .def/.endef */
520 symbol_name
= input_line_pointer
;
521 #ifdef STRIP_UNDERSCORE
522 if (symbol_name
[0] == '_' && symbol_name
[1] != 0)
524 #endif /* STRIP_UNDERSCORE */
526 name_end
= get_symbol_end ();
527 symbol_name_length
= strlen (symbol_name
);
528 symbol_name_copy
= xmalloc (symbol_name_length
+ 1);
529 strcpy (symbol_name_copy
, symbol_name
);
530 #ifdef tc_canonicalize_symbol_name
531 symbol_name_copy
= tc_canonicalize_symbol_name (symbol_name_copy
);
534 /* Initialize the new symbol */
535 def_symbol_in_progress
= symbol_make (symbol_name_copy
);
536 symbol_set_frag (def_symbol_in_progress
, &zero_address_frag
);
537 S_SET_VALUE (def_symbol_in_progress
, 0);
539 if (S_IS_STRING (def_symbol_in_progress
))
540 SF_SET_STRING (def_symbol_in_progress
);
542 *input_line_pointer
= name_end
;
544 demand_empty_rest_of_line ();
547 unsigned int dim_index
;
550 obj_coff_endef (ignore
)
551 int ignore ATTRIBUTE_UNUSED
;
555 /* DIM BUG FIX sac@cygnus.com */
557 if (def_symbol_in_progress
== NULL
)
559 as_warn (_(".endef pseudo-op used outside of .def/.endef: ignored."));
560 demand_empty_rest_of_line ();
562 } /* if not inside .def/.endef */
564 /* Set the section number according to storage class. */
565 switch (S_GET_STORAGE_CLASS (def_symbol_in_progress
))
570 SF_SET_TAG (def_symbol_in_progress
);
571 /* intentional fallthrough */
574 SF_SET_DEBUG (def_symbol_in_progress
);
575 S_SET_SEGMENT (def_symbol_in_progress
, fetch_coff_debug_section ());
579 SF_SET_LOCAL (def_symbol_in_progress
); /* Do not emit this symbol. */
580 /* intentional fallthrough */
582 SF_SET_PROCESS (def_symbol_in_progress
); /* Will need processing before writing */
583 /* intentional fallthrough */
587 S_SET_SEGMENT (def_symbol_in_progress
, text_section
);
589 name
= S_GET_NAME (def_symbol_in_progress
);
590 if (name
[1] == 'b' && name
[2] == 'f')
592 if (! in_function ())
593 as_warn (_("`%s' symbol without preceding function"), name
);
594 /* SA_SET_SYM_LNNO (def_symbol_in_progress, 12345);*/
595 /* Will need relocating */
596 SF_SET_PROCESS (def_symbol_in_progress
);
604 #endif /* C_AUTOARG */
610 SF_SET_DEBUG (def_symbol_in_progress
);
611 S_SET_SEGMENT (def_symbol_in_progress
, absolute_section
);
618 S_SET_SEGMENT (def_symbol_in_progress
, absolute_section
);
628 /* Valid but set somewhere else (s_comm, s_lcomm, colon) */
635 as_warn (_("unexpected storage class %d"),
636 S_GET_STORAGE_CLASS (def_symbol_in_progress
));
638 } /* switch on storage class */
640 /* Now that we have built a debug symbol, try to find if we should
641 merge with an existing symbol or not. If a symbol is C_EFCN or
642 SEG_ABSOLUTE or untagged SEG_DEBUG it never merges. */
644 /* Two cases for functions. Either debug followed by definition or
645 definition followed by debug. For definition first, we will
646 merge the debug symbol into the definition. For debug first, the
647 lineno entry MUST point to the definition function or else it
648 will point off into space when obj_crawl_symbol_chain() merges
649 the debug symbol into the real symbol. Therefor, let's presume
650 the debug symbol is a real function reference. */
652 /* FIXME-SOON If for some reason the definition label/symbol is
653 never seen, this will probably leave an undefined symbol at link
656 if (S_GET_STORAGE_CLASS (def_symbol_in_progress
) == C_EFCN
657 || (!strcmp (bfd_get_section_name (stdoutput
,
658 S_GET_SEGMENT (def_symbol_in_progress
)),
660 && !SF_GET_TAG (def_symbol_in_progress
))
661 || S_GET_SEGMENT (def_symbol_in_progress
) == absolute_section
662 || (symbolP
= symbol_find_base (S_GET_NAME (def_symbol_in_progress
), DO_NOT_STRIP
)) == NULL
)
664 if (def_symbol_in_progress
!= symbol_lastP
)
665 symbol_append (def_symbol_in_progress
, symbol_lastP
, &symbol_rootP
,
670 /* This symbol already exists, merge the newly created symbol
671 into the old one. This is not mandatory. The linker can
672 handle duplicate symbols correctly. But I guess that it save
673 a *lot* of space if the assembly file defines a lot of
676 /* The debug entry (def_symbol_in_progress) is merged into the
677 previous definition. */
679 c_symbol_merge (def_symbol_in_progress
, symbolP
);
680 symbol_remove (def_symbol_in_progress
, &symbol_rootP
, &symbol_lastP
);
682 def_symbol_in_progress
= symbolP
;
684 if (SF_GET_FUNCTION (def_symbol_in_progress
)
685 || SF_GET_TAG (def_symbol_in_progress
)
686 || S_GET_STORAGE_CLASS (def_symbol_in_progress
) == C_STAT
)
688 /* For functions, and tags, and static symbols, the symbol
689 *must* be where the debug symbol appears. Move the
690 existing symbol to the current place. */
691 /* If it already is at the end of the symbol list, do nothing */
692 if (def_symbol_in_progress
!= symbol_lastP
)
694 symbol_remove (def_symbol_in_progress
, &symbol_rootP
, &symbol_lastP
);
695 symbol_append (def_symbol_in_progress
, symbol_lastP
, &symbol_rootP
, &symbol_lastP
);
700 if (SF_GET_TAG (def_symbol_in_progress
))
704 oldtag
= symbol_find_base (S_GET_NAME (def_symbol_in_progress
),
706 if (oldtag
== NULL
|| ! SF_GET_TAG (oldtag
))
707 tag_insert (S_GET_NAME (def_symbol_in_progress
),
708 def_symbol_in_progress
);
711 if (SF_GET_FUNCTION (def_symbol_in_progress
))
713 know (sizeof (def_symbol_in_progress
) <= sizeof (long));
714 set_function (def_symbol_in_progress
);
715 SF_SET_PROCESS (def_symbol_in_progress
);
719 /* That is, if this is the first time we've seen the
721 symbol_table_insert (def_symbol_in_progress
);
722 } /* definition follows debug */
723 } /* Create the line number entry pointing to the function being defined */
725 def_symbol_in_progress
= NULL
;
726 demand_empty_rest_of_line ();
730 obj_coff_dim (ignore
)
731 int ignore ATTRIBUTE_UNUSED
;
735 if (def_symbol_in_progress
== NULL
)
737 as_warn (_(".dim pseudo-op used outside of .def/.endef: ignored."));
738 demand_empty_rest_of_line ();
740 } /* if not inside .def/.endef */
742 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
744 for (dim_index
= 0; dim_index
< DIMNUM
; dim_index
++)
747 SA_SET_SYM_DIMEN (def_symbol_in_progress
, dim_index
,
748 get_absolute_expression ());
750 switch (*input_line_pointer
)
753 input_line_pointer
++;
757 as_warn (_("badly formed .dim directive ignored"));
758 /* intentional fallthrough */
766 demand_empty_rest_of_line ();
770 obj_coff_line (ignore
)
771 int ignore ATTRIBUTE_UNUSED
;
775 if (def_symbol_in_progress
== NULL
)
777 /* Probably stabs-style line? */
782 this_base
= get_absolute_expression ();
783 if (!strcmp (".bf", S_GET_NAME (def_symbol_in_progress
)))
784 coff_line_base
= this_base
;
786 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
787 SA_SET_SYM_LNNO (def_symbol_in_progress
, coff_line_base
);
789 demand_empty_rest_of_line ();
792 if (strcmp (".bf", S_GET_NAME (def_symbol_in_progress
)) == 0)
797 listing_source_line ((unsigned int) coff_line_base
);
803 obj_coff_size (ignore
)
804 int ignore ATTRIBUTE_UNUSED
;
806 if (def_symbol_in_progress
== NULL
)
808 as_warn (_(".size pseudo-op used outside of .def/.endef ignored."));
809 demand_empty_rest_of_line ();
811 } /* if not inside .def/.endef */
813 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
814 SA_SET_SYM_SIZE (def_symbol_in_progress
, get_absolute_expression ());
815 demand_empty_rest_of_line ();
819 obj_coff_scl (ignore
)
820 int ignore ATTRIBUTE_UNUSED
;
822 if (def_symbol_in_progress
== NULL
)
824 as_warn (_(".scl pseudo-op used outside of .def/.endef ignored."));
825 demand_empty_rest_of_line ();
827 } /* if not inside .def/.endef */
829 S_SET_STORAGE_CLASS (def_symbol_in_progress
, get_absolute_expression ());
830 demand_empty_rest_of_line ();
834 obj_coff_tag (ignore
)
835 int ignore ATTRIBUTE_UNUSED
;
840 if (def_symbol_in_progress
== NULL
)
842 as_warn (_(".tag pseudo-op used outside of .def/.endef ignored."));
843 demand_empty_rest_of_line ();
847 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
848 symbol_name
= input_line_pointer
;
849 name_end
= get_symbol_end ();
851 #ifdef tc_canonicalize_symbol_name
852 symbol_name
= tc_canonicalize_symbol_name (symbol_name
);
855 /* Assume that the symbol referred to by .tag is always defined.
856 This was a bad assumption. I've added find_or_make. xoxorich. */
857 SA_SET_SYM_TAGNDX (def_symbol_in_progress
,
858 tag_find_or_make (symbol_name
));
859 if (SA_GET_SYM_TAGNDX (def_symbol_in_progress
) == 0L)
861 as_warn (_("tag not found for .tag %s"), symbol_name
);
864 SF_SET_TAGGED (def_symbol_in_progress
);
865 *input_line_pointer
= name_end
;
867 demand_empty_rest_of_line ();
871 obj_coff_type (ignore
)
872 int ignore ATTRIBUTE_UNUSED
;
874 if (def_symbol_in_progress
== NULL
)
876 as_warn (_(".type pseudo-op used outside of .def/.endef ignored."));
877 demand_empty_rest_of_line ();
879 } /* if not inside .def/.endef */
881 S_SET_DATA_TYPE (def_symbol_in_progress
, get_absolute_expression ());
883 if (ISFCN (S_GET_DATA_TYPE (def_symbol_in_progress
)) &&
884 S_GET_STORAGE_CLASS (def_symbol_in_progress
) != C_TPDEF
)
886 SF_SET_FUNCTION (def_symbol_in_progress
);
887 } /* is a function */
889 demand_empty_rest_of_line ();
893 obj_coff_val (ignore
)
894 int ignore ATTRIBUTE_UNUSED
;
896 if (def_symbol_in_progress
== NULL
)
898 as_warn (_(".val pseudo-op used outside of .def/.endef ignored."));
899 demand_empty_rest_of_line ();
901 } /* if not inside .def/.endef */
903 if (is_name_beginner (*input_line_pointer
))
905 char *symbol_name
= input_line_pointer
;
906 char name_end
= get_symbol_end ();
908 #ifdef tc_canonicalize_symbol_name
909 symbol_name
= tc_canonicalize_symbol_name (symbol_name
);
911 if (!strcmp (symbol_name
, "."))
913 symbol_set_frag (def_symbol_in_progress
, frag_now
);
914 S_SET_VALUE (def_symbol_in_progress
, (valueT
) frag_now_fix ());
915 /* If the .val is != from the .def (e.g. statics) */
917 else if (strcmp (S_GET_NAME (def_symbol_in_progress
), symbol_name
))
922 exp
.X_add_symbol
= symbol_find_or_make (symbol_name
);
923 exp
.X_op_symbol
= NULL
;
924 exp
.X_add_number
= 0;
925 symbol_set_value_expression (def_symbol_in_progress
, &exp
);
927 /* If the segment is undefined when the forward reference is
928 resolved, then copy the segment id from the forward
930 SF_SET_GET_SEGMENT (def_symbol_in_progress
);
932 /* Otherwise, it is the name of a non debug symbol and its value will be calculated later. */
933 *input_line_pointer
= name_end
;
937 S_SET_VALUE (def_symbol_in_progress
, get_absolute_expression ());
938 } /* if symbol based */
940 demand_empty_rest_of_line ();
944 coff_obj_read_begin_hook ()
946 /* These had better be the same. Usually 18 bytes. */
948 know (sizeof (SYMENT
) == sizeof (AUXENT
));
949 know (SYMESZ
== AUXESZ
);
955 symbolS
*coff_last_function
;
956 static symbolS
*coff_last_bf
;
959 coff_frob_symbol (symp
, punt
)
963 static symbolS
*last_tagP
;
964 static stack
*block_stack
;
965 static symbolS
*set_end
;
966 symbolS
*next_set_end
= NULL
;
968 if (symp
== &abs_symbol
)
974 if (current_lineno_sym
)
975 coff_add_linesym ((symbolS
*) 0);
978 block_stack
= stack_init (512, sizeof (symbolS
*));
980 if (S_IS_WEAK (symp
))
983 S_SET_STORAGE_CLASS (symp
, C_NT_WEAK
);
985 S_SET_STORAGE_CLASS (symp
, C_WEAKEXT
);
989 if (!S_IS_DEFINED (symp
)
991 && S_GET_STORAGE_CLASS (symp
) != C_STAT
)
992 S_SET_STORAGE_CLASS (symp
, C_EXT
);
994 if (!SF_GET_DEBUG (symp
))
997 if (!SF_GET_LOCAL (symp
)
998 && !SF_GET_STATICS (symp
)
999 && (real
= symbol_find_base (S_GET_NAME (symp
), DO_NOT_STRIP
))
1002 c_symbol_merge (symp
, real
);
1005 if (!S_IS_DEFINED (symp
) && !SF_GET_LOCAL (symp
))
1007 assert (S_GET_VALUE (symp
) == 0);
1008 S_SET_EXTERNAL (symp
);
1010 else if (S_GET_STORAGE_CLASS (symp
) == C_NULL
)
1012 if (S_GET_SEGMENT (symp
) == text_section
1013 && symp
!= seg_info (text_section
)->sym
)
1014 S_SET_STORAGE_CLASS (symp
, C_LABEL
);
1016 S_SET_STORAGE_CLASS (symp
, C_STAT
);
1018 if (SF_GET_PROCESS (symp
))
1020 if (S_GET_STORAGE_CLASS (symp
) == C_BLOCK
)
1022 if (!strcmp (S_GET_NAME (symp
), ".bb"))
1023 stack_push (block_stack
, (char *) &symp
);
1027 begin
= *(symbolS
**) stack_pop (block_stack
);
1029 as_warn (_("mismatched .eb"));
1031 next_set_end
= begin
;
1034 if (coff_last_function
== 0 && SF_GET_FUNCTION (symp
))
1036 union internal_auxent
*auxp
;
1037 coff_last_function
= symp
;
1038 if (S_GET_NUMBER_AUXILIARY (symp
) < 1)
1039 S_SET_NUMBER_AUXILIARY (symp
, 1);
1041 &coffsymbol (symbol_get_bfdsym (symp
))->native
[1].u
.auxent
;
1042 memset (auxp
->x_sym
.x_fcnary
.x_ary
.x_dimen
, 0,
1043 sizeof (auxp
->x_sym
.x_fcnary
.x_ary
.x_dimen
));
1045 if (S_GET_STORAGE_CLASS (symp
) == C_EFCN
)
1047 if (coff_last_function
== 0)
1048 as_fatal (_("C_EFCN symbol out of scope"));
1049 SA_SET_SYM_FSIZE (coff_last_function
,
1050 (long) (S_GET_VALUE (symp
)
1051 - S_GET_VALUE (coff_last_function
)));
1052 next_set_end
= coff_last_function
;
1053 coff_last_function
= 0;
1056 if (S_IS_EXTERNAL (symp
))
1057 S_SET_STORAGE_CLASS (symp
, C_EXT
);
1058 else if (SF_GET_LOCAL (symp
))
1061 if (SF_GET_FUNCTION (symp
))
1062 symbol_get_bfdsym (symp
)->flags
|= BSF_FUNCTION
;
1067 if (SF_GET_TAG (symp
))
1069 else if (S_GET_STORAGE_CLASS (symp
) == C_EOS
)
1070 next_set_end
= last_tagP
;
1073 /* This is pretty horrible, but we have to set *punt correctly in
1074 order to call SA_SET_SYM_ENDNDX correctly. */
1075 if (! symbol_used_in_reloc_p (symp
)
1076 && ((symbol_get_bfdsym (symp
)->flags
& BSF_SECTION_SYM
) != 0
1077 || (! S_IS_EXTERNAL (symp
)
1078 && ! symbol_get_tc (symp
)->output
1079 && S_GET_STORAGE_CLASS (symp
) != C_FILE
)))
1083 if (set_end
!= (symbolS
*) NULL
1085 && ((symbol_get_bfdsym (symp
)->flags
& BSF_NOT_AT_END
) != 0
1086 || (S_IS_DEFINED (symp
)
1087 && ! S_IS_COMMON (symp
)
1088 && (! S_IS_EXTERNAL (symp
) || SF_GET_FUNCTION (symp
)))))
1090 SA_SET_SYM_ENDNDX (set_end
, symp
);
1094 if (next_set_end
!= NULL
)
1096 if (set_end
!= NULL
)
1097 as_warn ("Warning: internal error: forgetting to set endndx of %s",
1098 S_GET_NAME (set_end
));
1099 set_end
= next_set_end
;
1103 && S_GET_STORAGE_CLASS (symp
) == C_FCN
1104 && strcmp (S_GET_NAME (symp
), ".bf") == 0)
1106 if (coff_last_bf
!= NULL
)
1107 SA_SET_SYM_ENDNDX (coff_last_bf
, symp
);
1108 coff_last_bf
= symp
;
1111 if (coffsymbol (symbol_get_bfdsym (symp
))->lineno
)
1114 struct line_no
*lptr
;
1117 lptr
= (struct line_no
*) coffsymbol (symbol_get_bfdsym (symp
))->lineno
;
1118 for (i
= 0; lptr
; lptr
= lptr
->next
)
1120 lptr
= (struct line_no
*) coffsymbol (symbol_get_bfdsym (symp
))->lineno
;
1122 /* We need i entries for line numbers, plus 1 for the first
1123 entry which BFD will override, plus 1 for the last zero
1124 entry (a marker for BFD). */
1125 l
= (alent
*) xmalloc ((i
+ 2) * sizeof (alent
));
1126 coffsymbol (symbol_get_bfdsym (symp
))->lineno
= l
;
1127 l
[i
+ 1].line_number
= 0;
1128 l
[i
+ 1].u
.sym
= NULL
;
1132 lptr
->l
.u
.offset
+= lptr
->frag
->fr_address
;
1140 coff_adjust_section_syms (abfd
, sec
, x
)
1141 bfd
*abfd ATTRIBUTE_UNUSED
;
1143 PTR x ATTRIBUTE_UNUSED
;
1146 segment_info_type
*seginfo
= seg_info (sec
);
1147 int nlnno
, nrelocs
= 0;
1149 /* RS/6000 gas creates a .debug section manually in ppc_frob_file in
1150 tc-ppc.c. Do not get confused by it. */
1151 if (seginfo
== NULL
)
1154 if (!strcmp (sec
->name
, ".text"))
1155 nlnno
= coff_n_line_nos
;
1159 /* @@ Hope that none of the fixups expand to more than one reloc
1161 fixS
*fixp
= seginfo
->fix_root
;
1164 if (! fixp
->fx_done
)
1166 fixp
= fixp
->fx_next
;
1169 if (bfd_get_section_size_before_reloc (sec
) == 0
1172 && sec
!= text_section
1173 && sec
!= data_section
1174 && sec
!= bss_section
)
1176 secsym
= section_symbol (sec
);
1177 SA_SET_SCN_NRELOC (secsym
, nrelocs
);
1178 SA_SET_SCN_NLINNO (secsym
, nlnno
);
1182 coff_frob_file_after_relocs ()
1184 bfd_map_over_sections (stdoutput
, coff_adjust_section_syms
, (char*) 0);
1188 * implement the .section pseudo op:
1189 * .section name {, "flags"}
1191 * | +--- optional flags: 'b' for bss
1193 * +-- section name 'l' for lib
1197 * 'd' (apparently m88k for data)
1199 * 'r' for read-only data
1200 * 's' for shared data (PE)
1201 * But if the argument is not a quoted string, treat it as a
1202 * subsegment number.
1206 obj_coff_section (ignore
)
1207 int ignore ATTRIBUTE_UNUSED
;
1209 /* Strip out the section name */
1225 section_name
= input_line_pointer
;
1226 c
= get_symbol_end ();
1228 name
= xmalloc (input_line_pointer
- section_name
+ 1);
1229 strcpy (name
, section_name
);
1231 *input_line_pointer
= c
;
1236 flags
= SEC_NO_FLAGS
;
1238 if (*input_line_pointer
== ',')
1240 ++input_line_pointer
;
1242 if (*input_line_pointer
!= '"')
1243 exp
= get_absolute_expression ();
1246 ++input_line_pointer
;
1247 while (*input_line_pointer
!= '"'
1248 && ! is_end_of_line
[(unsigned char) *input_line_pointer
])
1250 switch (*input_line_pointer
)
1252 case 'b': flags
|= SEC_ALLOC
; flags
&=~ SEC_LOAD
; break;
1253 case 'n': flags
&=~ SEC_LOAD
; break;
1255 case 'w': flags
|= SEC_DATA
; flags
&=~ SEC_READONLY
; break;
1256 case 'x': flags
|= SEC_CODE
; break;
1257 case 'r': flags
|= SEC_READONLY
; break;
1258 case 's': flags
|= SEC_SHARED
; break;
1260 case 'i': /* STYP_INFO */
1261 case 'l': /* STYP_LIB */
1262 case 'o': /* STYP_OVER */
1263 as_warn (_("unsupported section attribute '%c'"),
1264 *input_line_pointer
);
1268 as_warn(_("unknown section attribute '%c'"),
1269 *input_line_pointer
);
1272 ++input_line_pointer
;
1274 if (*input_line_pointer
== '"')
1275 ++input_line_pointer
;
1279 sec
= subseg_new (name
, (subsegT
) exp
);
1281 if (flags
!= SEC_NO_FLAGS
)
1285 oldflags
= bfd_get_section_flags (stdoutput
, sec
);
1286 oldflags
&= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES
;
1289 if (! bfd_set_section_flags (stdoutput
, sec
, flags
))
1290 as_warn (_("error setting flags for \"%s\": %s"),
1291 bfd_section_name (stdoutput
, sec
),
1292 bfd_errmsg (bfd_get_error ()));
1295 demand_empty_rest_of_line ();
1299 coff_adjust_symtab ()
1301 if (symbol_rootP
== NULL
1302 || S_GET_STORAGE_CLASS (symbol_rootP
) != C_FILE
)
1303 c_dot_file_symbol ("fake");
1307 coff_frob_section (sec
)
1313 bfd_vma size
, n_entries
, mask
;
1315 /* The COFF back end in BFD requires that all section sizes be
1316 rounded up to multiples of the corresponding section alignments.
1317 Seems kinda silly to me, but that's the way it is. */
1318 size
= bfd_get_section_size_before_reloc (sec
);
1319 mask
= ((bfd_vma
) 1 << (bfd_vma
) sec
->alignment_power
) - 1;
1322 size
= (size
+ mask
) & ~mask
;
1323 bfd_set_section_size (stdoutput
, sec
, size
);
1326 /* If the section size is non-zero, the section symbol needs an aux
1327 entry associated with it, indicating the size. We don't know
1328 all the values yet; coff_frob_symbol will fill them in later. */
1330 || sec
== text_section
1331 || sec
== data_section
1332 || sec
== bss_section
)
1334 symbolS
*secsym
= section_symbol (sec
);
1336 S_SET_STORAGE_CLASS (secsym
, C_STAT
);
1337 S_SET_NUMBER_AUXILIARY (secsym
, 1);
1338 SF_SET_STATICS (secsym
);
1339 SA_SET_SCN_SCNLEN (secsym
, size
);
1342 /* @@ these should be in a "stabs.h" file, or maybe as.h */
1343 #ifndef STAB_SECTION_NAME
1344 #define STAB_SECTION_NAME ".stab"
1346 #ifndef STAB_STRING_SECTION_NAME
1347 #define STAB_STRING_SECTION_NAME ".stabstr"
1349 if (strcmp (STAB_STRING_SECTION_NAME
, sec
->name
))
1353 sec
= subseg_get (STAB_SECTION_NAME
, 0);
1354 /* size is already rounded up, since other section will be listed first */
1355 size
= bfd_get_section_size_before_reloc (strsec
);
1357 n_entries
= bfd_get_section_size_before_reloc (sec
) / 12 - 1;
1359 /* Find first non-empty frag. It should be large enough. */
1360 fragp
= seg_info (sec
)->frchainP
->frch_root
;
1361 while (fragp
&& fragp
->fr_fix
== 0)
1362 fragp
= fragp
->fr_next
;
1363 assert (fragp
!= 0 && fragp
->fr_fix
>= 12);
1365 /* Store the values. */
1366 p
= fragp
->fr_literal
;
1367 bfd_h_put_16 (stdoutput
, n_entries
, (bfd_byte
*) p
+ 6);
1368 bfd_h_put_32 (stdoutput
, size
, (bfd_byte
*) p
+ 8);
1372 obj_coff_init_stab_section (seg
)
1378 unsigned int stroff
;
1380 /* Make space for this first symbol. */
1384 as_where (&file
, (unsigned int *) NULL
);
1385 stabstr_name
= (char *) alloca (strlen (seg
->name
) + 4);
1386 strcpy (stabstr_name
, seg
->name
);
1387 strcat (stabstr_name
, "str");
1388 stroff
= get_stab_string_offset (file
, stabstr_name
);
1390 md_number_to_chars (p
, stroff
, 4);
1399 return ((s
== NULL
) ? "(NULL)" : S_GET_NAME (s
));
1407 for (symbolP
= symbol_rootP
; symbolP
; symbolP
= symbol_next (symbolP
))
1409 printf(_("0x%lx: \"%s\" type = %ld, class = %d, segment = %d\n"),
1410 (unsigned long) symbolP
,
1411 S_GET_NAME(symbolP
),
1412 (long) S_GET_DATA_TYPE(symbolP
),
1413 S_GET_STORAGE_CLASS(symbolP
),
1414 (int) S_GET_SEGMENT(symbolP
));
1420 #else /* not BFD_ASSEMBLER */
1423 /* This is needed because we include internal bfd things. */
1427 #include "libcoff.h"
1430 #include "coff/pe.h"
1433 /* The NOP_OPCODE is for the alignment fill value. Fill with nop so
1434 that we can stick sections together without causing trouble. */
1436 #define NOP_OPCODE 0x00
1439 /* The zeroes if symbol name is longer than 8 chars */
1440 #define S_SET_ZEROES(s,v) ((s)->sy_symbol.ost_entry.n_zeroes = (v))
1442 #define MIN(a,b) ((a) < (b)? (a) : (b))
1444 /* This vector is used to turn a gas internal segment number into a
1445 section number suitable for insertion into a coff symbol table.
1446 This must correspond to seg_info_off_by_4. */
1448 const short seg_N_TYPE
[] =
1449 { /* in: segT out: N_TYPE bits */
1451 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
1452 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
1453 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
1454 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
1455 C_UNDEF_SECTION
, /* SEG_UNKNOWN */
1456 C_UNDEF_SECTION
, /* SEG_GOOF */
1457 C_UNDEF_SECTION
, /* SEG_EXPR */
1458 C_DEBUG_SECTION
, /* SEG_DEBUG */
1459 C_NTV_SECTION
, /* SEG_NTV */
1460 C_PTV_SECTION
, /* SEG_PTV */
1461 C_REGISTER_SECTION
, /* SEG_REGISTER */
1464 int function_lineoff
= -1; /* Offset in line#s where the last function
1465 started (the odd entry for line #0) */
1467 /* structure used to keep the filenames which
1468 are too long around so that we can stick them
1469 into the string table */
1470 struct filename_list
1473 struct filename_list
*next
;
1476 static struct filename_list
*filename_list_head
;
1477 static struct filename_list
*filename_list_tail
;
1479 static symbolS
*last_line_symbol
;
1481 /* Add 4 to the real value to get the index and compensate the
1482 negatives. This vector is used by S_GET_SEGMENT to turn a coff
1483 section number into a segment number
1485 static symbolS
*previous_file_symbol
;
1486 void c_symbol_merge ();
1487 static int line_base
;
1489 symbolS
*c_section_symbol ();
1492 static void fixup_segment
PARAMS ((segment_info_type
*segP
,
1493 segT this_segment_type
));
1496 static void fixup_mdeps
PARAMS ((fragS
*,
1501 static void fill_section
PARAMS ((bfd
* abfd
,
1506 static int c_line_new
PARAMS ((symbolS
* symbol
, long paddr
,
1511 static void w_symbols
PARAMS ((bfd
* abfd
, char *where
,
1512 symbolS
* symbol_rootP
));
1514 static void adjust_stab_section
PARAMS ((bfd
*abfd
, segT seg
));
1516 static void obj_coff_lcomm
PARAMS ((int));
1517 static void obj_coff_text
PARAMS ((int));
1518 static void obj_coff_data
PARAMS ((int));
1519 static void obj_coff_ident
PARAMS ((int));
1520 void obj_coff_section
PARAMS ((int));
1522 /* When not using BFD_ASSEMBLER, we permit up to 40 sections.
1524 This array maps a COFF section number into a gas section number.
1525 Because COFF uses negative section numbers, you must add 4 to the
1526 COFF section number when indexing into this array; this is done via
1527 the SEG_INFO_FROM_SECTION_NUMBER macro. This must correspond to
1530 static const segT seg_info_off_by_4
[] =
1537 SEG_E0
, SEG_E1
, SEG_E2
, SEG_E3
, SEG_E4
,
1538 SEG_E5
, SEG_E6
, SEG_E7
, SEG_E8
, SEG_E9
,
1539 SEG_E10
, SEG_E11
, SEG_E12
, SEG_E13
, SEG_E14
,
1540 SEG_E15
, SEG_E16
, SEG_E17
, SEG_E18
, SEG_E19
,
1541 SEG_E20
, SEG_E21
, SEG_E22
, SEG_E23
, SEG_E24
,
1542 SEG_E25
, SEG_E26
, SEG_E27
, SEG_E28
, SEG_E29
,
1543 SEG_E30
, SEG_E31
, SEG_E32
, SEG_E33
, SEG_E34
,
1544 SEG_E35
, SEG_E36
, SEG_E37
, SEG_E38
, SEG_E39
,
1557 #define SEG_INFO_FROM_SECTION_NUMBER(x) (seg_info_off_by_4[(x)+4])
1559 static relax_addressT
1560 relax_align (address
, alignment
)
1561 relax_addressT address
;
1564 relax_addressT mask
;
1565 relax_addressT new_address
;
1567 mask
= ~((~0) << alignment
);
1568 new_address
= (address
+ mask
) & (~mask
);
1569 return (new_address
- address
);
1577 return SEG_INFO_FROM_SECTION_NUMBER (x
->sy_symbol
.ost_entry
.n_scnum
);
1580 /* calculate the size of the frag chain and fill in the section header
1581 to contain all of it, also fill in the addr of the sections */
1583 size_section (abfd
, idx
)
1584 bfd
*abfd ATTRIBUTE_UNUSED
;
1588 unsigned int size
= 0;
1589 fragS
*frag
= segment_info
[idx
].frchainP
->frch_root
;
1592 size
= frag
->fr_address
;
1593 if (frag
->fr_address
!= size
)
1595 fprintf (stderr
, _("Out of step\n"));
1596 size
= frag
->fr_address
;
1599 switch (frag
->fr_type
)
1601 #ifdef TC_COFF_SIZEMACHDEP
1602 case rs_machine_dependent
:
1603 size
+= TC_COFF_SIZEMACHDEP (frag
);
1607 assert (frag
->fr_symbol
== 0);
1610 size
+= frag
->fr_fix
;
1611 size
+= frag
->fr_offset
* frag
->fr_var
;
1618 size
+= frag
->fr_fix
;
1619 off
= relax_align (size
, frag
->fr_offset
);
1620 if (frag
->fr_subtype
!= 0 && off
> frag
->fr_subtype
)
1626 BAD_CASE (frag
->fr_type
);
1629 frag
= frag
->fr_next
;
1631 segment_info
[idx
].scnhdr
.s_size
= size
;
1637 count_entries_in_chain (idx
)
1640 unsigned int nrelocs
;
1643 /* Count the relocations */
1644 fixup_ptr
= segment_info
[idx
].fix_root
;
1646 while (fixup_ptr
!= (fixS
*) NULL
)
1648 if (fixup_ptr
->fx_done
== 0 && TC_COUNT_RELOC (fixup_ptr
))
1651 if (fixup_ptr
->fx_r_type
== RELOC_CONSTH
)
1660 fixup_ptr
= fixup_ptr
->fx_next
;
1667 static int compare_external_relocs
PARAMS ((const PTR
, const PTR
));
1669 /* AUX's ld expects relocations to be sorted */
1671 compare_external_relocs (x
, y
)
1675 struct external_reloc
*a
= (struct external_reloc
*) x
;
1676 struct external_reloc
*b
= (struct external_reloc
*) y
;
1677 bfd_vma aadr
= bfd_getb32 (a
->r_vaddr
);
1678 bfd_vma badr
= bfd_getb32 (b
->r_vaddr
);
1679 return (aadr
< badr
? -1 : badr
< aadr
? 1 : 0);
1684 /* output all the relocations for a section */
1686 do_relocs_for (abfd
, h
, file_cursor
)
1689 unsigned long *file_cursor
;
1691 unsigned int nrelocs
;
1693 unsigned long reloc_start
= *file_cursor
;
1695 for (idx
= SEG_E0
; idx
< SEG_LAST
; idx
++)
1697 if (segment_info
[idx
].scnhdr
.s_name
[0])
1699 struct external_reloc
*ext_ptr
;
1700 struct external_reloc
*external_reloc_vec
;
1701 unsigned int external_reloc_size
;
1702 unsigned int base
= segment_info
[idx
].scnhdr
.s_paddr
;
1703 fixS
*fix_ptr
= segment_info
[idx
].fix_root
;
1704 nrelocs
= count_entries_in_chain (idx
);
1707 /* Bypass this stuff if no relocs. This also incidentally
1708 avoids a SCO bug, where free(malloc(0)) tends to crash. */
1710 external_reloc_size
= nrelocs
* RELSZ
;
1711 external_reloc_vec
=
1712 (struct external_reloc
*) malloc (external_reloc_size
);
1714 ext_ptr
= external_reloc_vec
;
1716 /* Fill in the internal coff style reloc struct from the
1717 internal fix list. */
1720 struct internal_reloc intr
;
1722 /* Only output some of the relocations */
1723 if (fix_ptr
->fx_done
== 0 && TC_COUNT_RELOC (fix_ptr
))
1725 #ifdef TC_RELOC_MANGLE
1726 TC_RELOC_MANGLE (&segment_info
[idx
], fix_ptr
, &intr
,
1731 symbolS
*symbol_ptr
= fix_ptr
->fx_addsy
;
1733 intr
.r_type
= TC_COFF_FIX2RTYPE (fix_ptr
);
1735 base
+ fix_ptr
->fx_frag
->fr_address
+ fix_ptr
->fx_where
;
1737 #ifdef TC_KEEP_FX_OFFSET
1738 intr
.r_offset
= fix_ptr
->fx_offset
;
1743 while (symbol_ptr
->sy_value
.X_op
== O_symbol
1744 && (! S_IS_DEFINED (symbol_ptr
)
1745 || S_IS_COMMON (symbol_ptr
)))
1749 /* We must avoid looping, as that can occur
1750 with a badly written program. */
1751 n
= symbol_ptr
->sy_value
.X_add_symbol
;
1752 if (n
== symbol_ptr
)
1757 /* Turn the segment of the symbol into an offset. */
1760 resolve_symbol_value (symbol_ptr
, 1);
1761 if (! symbol_ptr
->sy_resolved
)
1766 if (expr_symbol_where (symbol_ptr
, &file
, &line
))
1767 as_bad_where (file
, line
,
1768 _("unresolved relocation"));
1770 as_bad (_("bad relocation: symbol `%s' not in symbol table"),
1771 S_GET_NAME (symbol_ptr
));
1773 dot
= segment_info
[S_GET_SEGMENT (symbol_ptr
)].dot
;
1776 intr
.r_symndx
= dot
->sy_number
;
1780 intr
.r_symndx
= symbol_ptr
->sy_number
;
1790 (void) bfd_coff_swap_reloc_out (abfd
, &intr
, ext_ptr
);
1793 #if defined(TC_A29K)
1795 /* The 29k has a special kludge for the high 16 bit
1796 reloc. Two relocations are emited, R_IHIHALF,
1797 and R_IHCONST. The second one doesn't contain a
1798 symbol, but uses the value for offset. */
1800 if (intr
.r_type
== R_IHIHALF
)
1802 /* now emit the second bit */
1803 intr
.r_type
= R_IHCONST
;
1804 intr
.r_symndx
= fix_ptr
->fx_addnumber
;
1805 (void) bfd_coff_swap_reloc_out (abfd
, &intr
, ext_ptr
);
1811 fix_ptr
= fix_ptr
->fx_next
;
1815 /* Sort the reloc table */
1816 qsort ((PTR
) external_reloc_vec
, nrelocs
,
1817 sizeof (struct external_reloc
), compare_external_relocs
);
1820 /* Write out the reloc table */
1821 bfd_write ((PTR
) external_reloc_vec
, 1, external_reloc_size
,
1823 free (external_reloc_vec
);
1825 /* Fill in section header info. */
1826 segment_info
[idx
].scnhdr
.s_relptr
= *file_cursor
;
1827 *file_cursor
+= external_reloc_size
;
1828 segment_info
[idx
].scnhdr
.s_nreloc
= nrelocs
;
1833 segment_info
[idx
].scnhdr
.s_relptr
= 0;
1837 /* Set relocation_size field in file headers */
1838 H_SET_RELOCATION_SIZE (h
, *file_cursor
- reloc_start
, 0);
1842 /* run through a frag chain and write out the data to go with it, fill
1843 in the scnhdrs with the info on the file postions
1846 fill_section (abfd
, h
, file_cursor
)
1848 object_headers
*h ATTRIBUTE_UNUSED
;
1849 unsigned long *file_cursor
;
1853 unsigned int paddr
= 0;
1855 for (i
= SEG_E0
; i
< SEG_UNKNOWN
; i
++)
1857 unsigned int offset
= 0;
1858 struct internal_scnhdr
*s
= &(segment_info
[i
].scnhdr
);
1864 fragS
*frag
= segment_info
[i
].frchainP
->frch_root
;
1871 buffer
= xmalloc (s
->s_size
);
1872 s
->s_scnptr
= *file_cursor
;
1874 know (s
->s_paddr
== paddr
);
1876 if (strcmp (s
->s_name
, ".text") == 0)
1877 s
->s_flags
|= STYP_TEXT
;
1878 else if (strcmp (s
->s_name
, ".data") == 0)
1879 s
->s_flags
|= STYP_DATA
;
1880 else if (strcmp (s
->s_name
, ".bss") == 0)
1883 s
->s_flags
|= STYP_BSS
;
1885 /* @@ Should make the i386 and a29k coff targets define
1886 COFF_NOLOAD_PROBLEM, and have only one test here. */
1889 #ifndef COFF_NOLOAD_PROBLEM
1890 /* Apparently the SVR3 linker (and exec syscall) and UDI
1891 mondfe progrem are confused by noload sections. */
1892 s
->s_flags
|= STYP_NOLOAD
;
1897 else if (strcmp (s
->s_name
, ".lit") == 0)
1898 s
->s_flags
= STYP_LIT
| STYP_TEXT
;
1899 else if (strcmp (s
->s_name
, ".init") == 0)
1900 s
->s_flags
|= STYP_TEXT
;
1901 else if (strcmp (s
->s_name
, ".fini") == 0)
1902 s
->s_flags
|= STYP_TEXT
;
1903 else if (strncmp (s
->s_name
, ".comment", 8) == 0)
1904 s
->s_flags
|= STYP_INFO
;
1908 unsigned int fill_size
;
1909 switch (frag
->fr_type
)
1911 case rs_machine_dependent
:
1914 memcpy (buffer
+ frag
->fr_address
,
1916 (unsigned int) frag
->fr_fix
);
1917 offset
+= frag
->fr_fix
;
1922 assert (frag
->fr_symbol
== 0);
1929 memcpy (buffer
+ frag
->fr_address
,
1931 (unsigned int) frag
->fr_fix
);
1932 offset
+= frag
->fr_fix
;
1935 fill_size
= frag
->fr_var
;
1936 if (fill_size
&& frag
->fr_offset
> 0)
1939 unsigned int off
= frag
->fr_fix
;
1940 for (count
= frag
->fr_offset
; count
; count
--)
1942 if (fill_size
+ frag
->fr_address
+ off
<= s
->s_size
)
1944 memcpy (buffer
+ frag
->fr_address
+ off
,
1945 frag
->fr_literal
+ frag
->fr_fix
,
1948 offset
+= fill_size
;
1953 case rs_broken_word
:
1958 frag
= frag
->fr_next
;
1963 if (s
->s_scnptr
!= 0)
1965 bfd_write (buffer
, s
->s_size
, 1, abfd
);
1966 *file_cursor
+= s
->s_size
;
1975 /* Coff file generation & utilities */
1978 coff_header_append (abfd
, h
)
1985 #ifdef COFF_LONG_SECTION_NAMES
1986 unsigned long string_size
= 4;
1989 bfd_seek (abfd
, 0, 0);
1991 #ifndef OBJ_COFF_OMIT_OPTIONAL_HEADER
1992 H_SET_MAGIC_NUMBER (h
, COFF_MAGIC
);
1993 H_SET_VERSION_STAMP (h
, 0);
1994 H_SET_ENTRY_POINT (h
, 0);
1995 H_SET_TEXT_START (h
, segment_info
[SEG_E0
].frchainP
->frch_root
->fr_address
);
1996 H_SET_DATA_START (h
, segment_info
[SEG_E1
].frchainP
->frch_root
->fr_address
);
1997 H_SET_SIZEOF_OPTIONAL_HEADER (h
, bfd_coff_swap_aouthdr_out(abfd
, &h
->aouthdr
,
1999 #else /* defined (OBJ_COFF_OMIT_OPTIONAL_HEADER) */
2000 H_SET_SIZEOF_OPTIONAL_HEADER (h
, 0);
2001 #endif /* defined (OBJ_COFF_OMIT_OPTIONAL_HEADER) */
2003 i
= bfd_coff_swap_filehdr_out (abfd
, &h
->filehdr
, buffer
);
2005 bfd_write (buffer
, i
, 1, abfd
);
2006 bfd_write (buffero
, H_GET_SIZEOF_OPTIONAL_HEADER (h
), 1, abfd
);
2008 for (i
= SEG_E0
; i
< SEG_LAST
; i
++)
2010 if (segment_info
[i
].scnhdr
.s_name
[0])
2014 #ifdef COFF_LONG_SECTION_NAMES
2015 /* Support long section names as found in PE. This code
2016 must coordinate with that in write_object_file and
2018 if (strlen (segment_info
[i
].name
) > SCNNMLEN
)
2020 memset (segment_info
[i
].scnhdr
.s_name
, 0, SCNNMLEN
);
2021 sprintf (segment_info
[i
].scnhdr
.s_name
, "/%lu", string_size
);
2022 string_size
+= strlen (segment_info
[i
].name
) + 1;
2026 size
= bfd_coff_swap_scnhdr_out (abfd
,
2027 &(segment_info
[i
].scnhdr
),
2030 as_bad (_("bfd_coff_swap_scnhdr_out failed"));
2031 bfd_write (buffer
, size
, 1, abfd
);
2038 symbol_to_chars (abfd
, where
, symbolP
)
2043 unsigned int numaux
= symbolP
->sy_symbol
.ost_entry
.n_numaux
;
2047 /* Turn any symbols with register attributes into abs symbols */
2048 if (S_GET_SEGMENT (symbolP
) == reg_section
)
2050 S_SET_SEGMENT (symbolP
, absolute_section
);
2052 /* At the same time, relocate all symbols to their output value */
2055 val
= (segment_info
[S_GET_SEGMENT (symbolP
)].scnhdr
.s_paddr
2056 + S_GET_VALUE (symbolP
));
2058 val
= S_GET_VALUE (symbolP
);
2061 S_SET_VALUE (symbolP
, val
);
2063 symbolP
->sy_symbol
.ost_entry
.n_value
= val
;
2065 where
+= bfd_coff_swap_sym_out (abfd
, &symbolP
->sy_symbol
.ost_entry
,
2068 for (i
= 0; i
< numaux
; i
++)
2070 where
+= bfd_coff_swap_aux_out (abfd
,
2071 &symbolP
->sy_symbol
.ost_auxent
[i
],
2072 S_GET_DATA_TYPE (symbolP
),
2073 S_GET_STORAGE_CLASS (symbolP
),
2081 coff_obj_symbol_new_hook (symbolP
)
2084 char underscore
= 0; /* Symbol has leading _ */
2086 /* Effective symbol */
2087 /* Store the pointer in the offset. */
2088 S_SET_ZEROES (symbolP
, 0L);
2089 S_SET_DATA_TYPE (symbolP
, T_NULL
);
2090 S_SET_STORAGE_CLASS (symbolP
, 0);
2091 S_SET_NUMBER_AUXILIARY (symbolP
, 0);
2092 /* Additional information */
2093 symbolP
->sy_symbol
.ost_flags
= 0;
2094 /* Auxiliary entries */
2095 memset ((char *) &symbolP
->sy_symbol
.ost_auxent
[0], 0, AUXESZ
);
2097 if (S_IS_STRING (symbolP
))
2098 SF_SET_STRING (symbolP
);
2099 if (!underscore
&& S_IS_LOCAL (symbolP
))
2100 SF_SET_LOCAL (symbolP
);
2104 * Handle .ln directives.
2108 obj_coff_ln (appline
)
2113 if (! appline
&& def_symbol_in_progress
!= NULL
)
2115 as_warn (_(".ln pseudo-op inside .def/.endef: ignored."));
2116 demand_empty_rest_of_line ();
2118 } /* wrong context */
2120 l
= get_absolute_expression ();
2121 c_line_new (0, frag_now_fix (), l
, frag_now
);
2124 new_logical_line ((char *) NULL
, l
- 1);
2134 listing_source_line ((unsigned int) l
);
2139 demand_empty_rest_of_line ();
2145 * Handle .def directives.
2147 * One might ask : why can't we symbol_new if the symbol does not
2148 * already exist and fill it with debug information. Because of
2149 * the C_EFCN special symbol. It would clobber the value of the
2150 * function symbol before we have a chance to notice that it is
2151 * a C_EFCN. And a second reason is that the code is more clear this
2152 * way. (at least I think it is :-).
2156 #define SKIP_SEMI_COLON() while (*input_line_pointer++ != ';')
2157 #define SKIP_WHITESPACES() while (*input_line_pointer == ' ' || \
2158 *input_line_pointer == '\t') \
2159 input_line_pointer++;
2163 int what ATTRIBUTE_UNUSED
;
2165 char name_end
; /* Char after the end of name */
2166 char *symbol_name
; /* Name of the debug symbol */
2167 char *symbol_name_copy
; /* Temporary copy of the name */
2168 unsigned int symbol_name_length
;
2170 if (def_symbol_in_progress
!= NULL
)
2172 as_warn (_(".def pseudo-op used inside of .def/.endef: ignored."));
2173 demand_empty_rest_of_line ();
2175 } /* if not inside .def/.endef */
2177 SKIP_WHITESPACES ();
2179 def_symbol_in_progress
= (symbolS
*) obstack_alloc (¬es
, sizeof (*def_symbol_in_progress
));
2180 memset (def_symbol_in_progress
, 0, sizeof (*def_symbol_in_progress
));
2182 symbol_name
= input_line_pointer
;
2183 name_end
= get_symbol_end ();
2184 symbol_name_length
= strlen (symbol_name
);
2185 symbol_name_copy
= xmalloc (symbol_name_length
+ 1);
2186 strcpy (symbol_name_copy
, symbol_name
);
2187 #ifdef tc_canonicalize_symbol_name
2188 symbol_name_copy
= tc_canonicalize_symbol_name (symbol_name_copy
);
2191 /* Initialize the new symbol */
2192 #ifdef STRIP_UNDERSCORE
2193 S_SET_NAME (def_symbol_in_progress
, (*symbol_name_copy
== '_'
2194 ? symbol_name_copy
+ 1
2195 : symbol_name_copy
));
2196 #else /* STRIP_UNDERSCORE */
2197 S_SET_NAME (def_symbol_in_progress
, symbol_name_copy
);
2198 #endif /* STRIP_UNDERSCORE */
2199 /* free(symbol_name_copy); */
2200 def_symbol_in_progress
->sy_name_offset
= (unsigned long) ~0;
2201 def_symbol_in_progress
->sy_number
= ~0;
2202 def_symbol_in_progress
->sy_frag
= &zero_address_frag
;
2203 S_SET_VALUE (def_symbol_in_progress
, 0);
2205 if (S_IS_STRING (def_symbol_in_progress
))
2206 SF_SET_STRING (def_symbol_in_progress
);
2208 *input_line_pointer
= name_end
;
2210 demand_empty_rest_of_line ();
2213 unsigned int dim_index
;
2217 obj_coff_endef (ignore
)
2218 int ignore ATTRIBUTE_UNUSED
;
2220 symbolS
*symbolP
= 0;
2221 /* DIM BUG FIX sac@cygnus.com */
2223 if (def_symbol_in_progress
== NULL
)
2225 as_warn (_(".endef pseudo-op used outside of .def/.endef: ignored."));
2226 demand_empty_rest_of_line ();
2228 } /* if not inside .def/.endef */
2230 /* Set the section number according to storage class. */
2231 switch (S_GET_STORAGE_CLASS (def_symbol_in_progress
))
2236 SF_SET_TAG (def_symbol_in_progress
);
2237 /* intentional fallthrough */
2240 SF_SET_DEBUG (def_symbol_in_progress
);
2241 S_SET_SEGMENT (def_symbol_in_progress
, SEG_DEBUG
);
2245 SF_SET_LOCAL (def_symbol_in_progress
); /* Do not emit this symbol. */
2246 /* intentional fallthrough */
2248 SF_SET_PROCESS (def_symbol_in_progress
); /* Will need processing before writing */
2249 /* intentional fallthrough */
2251 S_SET_SEGMENT (def_symbol_in_progress
, SEG_E0
);
2253 if (strcmp (S_GET_NAME (def_symbol_in_progress
), ".bf") == 0)
2255 if (function_lineoff
< 0)
2257 fprintf (stderr
, _("`.bf' symbol without preceding function\n"));
2258 } /* missing function symbol */
2259 SA_GET_SYM_LNNOPTR (last_line_symbol
) = function_lineoff
;
2261 SF_SET_PROCESS (last_line_symbol
);
2262 SF_SET_ADJ_LNNOPTR (last_line_symbol
);
2263 SF_SET_PROCESS (def_symbol_in_progress
);
2264 function_lineoff
= -1;
2266 /* Value is always set to . */
2267 def_symbol_in_progress
->sy_frag
= frag_now
;
2268 S_SET_VALUE (def_symbol_in_progress
, (valueT
) frag_now_fix ());
2273 #endif /* C_AUTOARG */
2283 SF_SET_DEBUG (def_symbol_in_progress
);
2284 S_SET_SEGMENT (def_symbol_in_progress
, absolute_section
);
2294 /* Valid but set somewhere else (s_comm, s_lcomm, colon) */
2300 as_warn (_("unexpected storage class %d"), S_GET_STORAGE_CLASS (def_symbol_in_progress
));
2302 } /* switch on storage class */
2304 /* Now that we have built a debug symbol, try to find if we should
2305 merge with an existing symbol or not. If a symbol is C_EFCN or
2306 absolute_section or untagged SEG_DEBUG it never merges. We also
2307 don't merge labels, which are in a different namespace, nor
2308 symbols which have not yet been defined since they are typically
2309 unique, nor do we merge tags with non-tags. */
2311 /* Two cases for functions. Either debug followed by definition or
2312 definition followed by debug. For definition first, we will
2313 merge the debug symbol into the definition. For debug first, the
2314 lineno entry MUST point to the definition function or else it
2315 will point off into space when crawl_symbols() merges the debug
2316 symbol into the real symbol. Therefor, let's presume the debug
2317 symbol is a real function reference. */
2319 /* FIXME-SOON If for some reason the definition label/symbol is
2320 never seen, this will probably leave an undefined symbol at link
2323 if (S_GET_STORAGE_CLASS (def_symbol_in_progress
) == C_EFCN
2324 || S_GET_STORAGE_CLASS (def_symbol_in_progress
) == C_LABEL
2325 || (S_GET_SEGMENT (def_symbol_in_progress
) == SEG_DEBUG
2326 && !SF_GET_TAG (def_symbol_in_progress
))
2327 || S_GET_SEGMENT (def_symbol_in_progress
) == absolute_section
2328 || def_symbol_in_progress
->sy_value
.X_op
!= O_constant
2329 || (symbolP
= symbol_find_base (S_GET_NAME (def_symbol_in_progress
), DO_NOT_STRIP
)) == NULL
2330 || (SF_GET_TAG (def_symbol_in_progress
) != SF_GET_TAG (symbolP
)))
2332 symbol_append (def_symbol_in_progress
, symbol_lastP
, &symbol_rootP
,
2337 /* This symbol already exists, merge the newly created symbol
2338 into the old one. This is not mandatory. The linker can
2339 handle duplicate symbols correctly. But I guess that it save
2340 a *lot* of space if the assembly file defines a lot of
2343 /* The debug entry (def_symbol_in_progress) is merged into the
2344 previous definition. */
2346 c_symbol_merge (def_symbol_in_progress
, symbolP
);
2347 /* FIXME-SOON Should *def_symbol_in_progress be free'd? xoxorich. */
2348 def_symbol_in_progress
= symbolP
;
2350 if (SF_GET_FUNCTION (def_symbol_in_progress
)
2351 || SF_GET_TAG (def_symbol_in_progress
)
2352 || S_GET_STORAGE_CLASS (def_symbol_in_progress
) == C_STAT
)
2354 /* For functions, and tags, and static symbols, the symbol
2355 *must* be where the debug symbol appears. Move the
2356 existing symbol to the current place. */
2357 /* If it already is at the end of the symbol list, do nothing */
2358 if (def_symbol_in_progress
!= symbol_lastP
)
2360 symbol_remove (def_symbol_in_progress
, &symbol_rootP
,
2362 symbol_append (def_symbol_in_progress
, symbol_lastP
,
2363 &symbol_rootP
, &symbol_lastP
);
2364 } /* if not already in place */
2366 } /* normal or mergable */
2368 if (SF_GET_TAG (def_symbol_in_progress
))
2372 oldtag
= symbol_find_base (S_GET_NAME (def_symbol_in_progress
),
2374 if (oldtag
== NULL
|| ! SF_GET_TAG (oldtag
))
2375 tag_insert (S_GET_NAME (def_symbol_in_progress
),
2376 def_symbol_in_progress
);
2379 if (SF_GET_FUNCTION (def_symbol_in_progress
))
2381 know (sizeof (def_symbol_in_progress
) <= sizeof (long));
2383 = c_line_new (def_symbol_in_progress
, 0, 0, &zero_address_frag
);
2385 SF_SET_PROCESS (def_symbol_in_progress
);
2387 if (symbolP
== NULL
)
2389 /* That is, if this is the first time we've seen the
2391 symbol_table_insert (def_symbol_in_progress
);
2392 } /* definition follows debug */
2393 } /* Create the line number entry pointing to the function being defined */
2395 def_symbol_in_progress
= NULL
;
2396 demand_empty_rest_of_line ();
2400 obj_coff_dim (ignore
)
2401 int ignore ATTRIBUTE_UNUSED
;
2405 if (def_symbol_in_progress
== NULL
)
2407 as_warn (_(".dim pseudo-op used outside of .def/.endef: ignored."));
2408 demand_empty_rest_of_line ();
2410 } /* if not inside .def/.endef */
2412 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
2414 for (dim_index
= 0; dim_index
< DIMNUM
; dim_index
++)
2416 SKIP_WHITESPACES ();
2417 SA_SET_SYM_DIMEN (def_symbol_in_progress
, dim_index
,
2418 get_absolute_expression ());
2420 switch (*input_line_pointer
)
2423 input_line_pointer
++;
2427 as_warn (_("badly formed .dim directive ignored"));
2428 /* intentional fallthrough */
2436 demand_empty_rest_of_line ();
2440 obj_coff_line (ignore
)
2441 int ignore ATTRIBUTE_UNUSED
;
2446 if (def_symbol_in_progress
== NULL
)
2452 name
= S_GET_NAME (def_symbol_in_progress
);
2453 this_base
= get_absolute_expression ();
2455 /* Only .bf symbols indicate the use of a new base line number; the
2456 line numbers associated with .ef, .bb, .eb are relative to the
2457 start of the containing function. */
2458 if (!strcmp (".bf", name
))
2460 #if 0 /* XXX Can we ever have line numbers going backwards? */
2461 if (this_base
> line_base
)
2464 line_base
= this_base
;
2472 listing_source_line ((unsigned int) line_base
);
2478 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
2479 SA_SET_SYM_LNNO (def_symbol_in_progress
, this_base
);
2481 demand_empty_rest_of_line ();
2485 obj_coff_size (ignore
)
2486 int ignore ATTRIBUTE_UNUSED
;
2488 if (def_symbol_in_progress
== NULL
)
2490 as_warn (_(".size pseudo-op used outside of .def/.endef ignored."));
2491 demand_empty_rest_of_line ();
2493 } /* if not inside .def/.endef */
2495 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
2496 SA_SET_SYM_SIZE (def_symbol_in_progress
, get_absolute_expression ());
2497 demand_empty_rest_of_line ();
2501 obj_coff_scl (ignore
)
2502 int ignore ATTRIBUTE_UNUSED
;
2504 if (def_symbol_in_progress
== NULL
)
2506 as_warn (_(".scl pseudo-op used outside of .def/.endef ignored."));
2507 demand_empty_rest_of_line ();
2509 } /* if not inside .def/.endef */
2511 S_SET_STORAGE_CLASS (def_symbol_in_progress
, get_absolute_expression ());
2512 demand_empty_rest_of_line ();
2516 obj_coff_tag (ignore
)
2517 int ignore ATTRIBUTE_UNUSED
;
2522 if (def_symbol_in_progress
== NULL
)
2524 as_warn (_(".tag pseudo-op used outside of .def/.endef ignored."));
2525 demand_empty_rest_of_line ();
2529 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
2530 symbol_name
= input_line_pointer
;
2531 name_end
= get_symbol_end ();
2532 #ifdef tc_canonicalize_symbol_name
2533 symbol_name
= tc_canonicalize_symbol_name (symbol_name
);
2536 /* Assume that the symbol referred to by .tag is always defined.
2537 This was a bad assumption. I've added find_or_make. xoxorich. */
2538 SA_SET_SYM_TAGNDX (def_symbol_in_progress
,
2539 (long) tag_find_or_make (symbol_name
));
2540 if (SA_GET_SYM_TAGNDX (def_symbol_in_progress
) == 0L)
2542 as_warn (_("tag not found for .tag %s"), symbol_name
);
2545 SF_SET_TAGGED (def_symbol_in_progress
);
2546 *input_line_pointer
= name_end
;
2548 demand_empty_rest_of_line ();
2552 obj_coff_type (ignore
)
2553 int ignore ATTRIBUTE_UNUSED
;
2555 if (def_symbol_in_progress
== NULL
)
2557 as_warn (_(".type pseudo-op used outside of .def/.endef ignored."));
2558 demand_empty_rest_of_line ();
2560 } /* if not inside .def/.endef */
2562 S_SET_DATA_TYPE (def_symbol_in_progress
, get_absolute_expression ());
2564 if (ISFCN (S_GET_DATA_TYPE (def_symbol_in_progress
)) &&
2565 S_GET_STORAGE_CLASS (def_symbol_in_progress
) != C_TPDEF
)
2567 SF_SET_FUNCTION (def_symbol_in_progress
);
2568 } /* is a function */
2570 demand_empty_rest_of_line ();
2574 obj_coff_val (ignore
)
2575 int ignore ATTRIBUTE_UNUSED
;
2577 if (def_symbol_in_progress
== NULL
)
2579 as_warn (_(".val pseudo-op used outside of .def/.endef ignored."));
2580 demand_empty_rest_of_line ();
2582 } /* if not inside .def/.endef */
2584 if (is_name_beginner (*input_line_pointer
))
2586 char *symbol_name
= input_line_pointer
;
2587 char name_end
= get_symbol_end ();
2589 #ifdef tc_canonicalize_symbol_name
2590 symbol_name
= tc_canonicalize_symbol_name (symbol_name
);
2593 if (!strcmp (symbol_name
, "."))
2595 def_symbol_in_progress
->sy_frag
= frag_now
;
2596 S_SET_VALUE (def_symbol_in_progress
, (valueT
) frag_now_fix ());
2597 /* If the .val is != from the .def (e.g. statics) */
2599 else if (strcmp (S_GET_NAME (def_symbol_in_progress
), symbol_name
))
2601 def_symbol_in_progress
->sy_value
.X_op
= O_symbol
;
2602 def_symbol_in_progress
->sy_value
.X_add_symbol
=
2603 symbol_find_or_make (symbol_name
);
2604 def_symbol_in_progress
->sy_value
.X_op_symbol
= NULL
;
2605 def_symbol_in_progress
->sy_value
.X_add_number
= 0;
2607 /* If the segment is undefined when the forward reference is
2608 resolved, then copy the segment id from the forward
2610 SF_SET_GET_SEGMENT (def_symbol_in_progress
);
2612 /* FIXME: gcc can generate address expressions
2613 here in unusual cases (search for "obscure"
2614 in sdbout.c). We just ignore the offset
2615 here, thus generating incorrect debugging
2616 information. We ignore the rest of the
2619 /* Otherwise, it is the name of a non debug symbol and
2620 its value will be calculated later. */
2621 *input_line_pointer
= name_end
;
2623 /* FIXME: this is to avoid an error message in the
2624 FIXME case mentioned just above. */
2625 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
2626 ++input_line_pointer
;
2630 S_SET_VALUE (def_symbol_in_progress
,
2631 (valueT
) get_absolute_expression ());
2632 } /* if symbol based */
2634 demand_empty_rest_of_line ();
2639 /* Handle the .linkonce pseudo-op. This is parsed by s_linkonce in
2640 read.c, which then calls this object file format specific routine. */
2643 obj_coff_pe_handle_link_once (type
)
2644 enum linkonce_type type
;
2646 seg_info (now_seg
)->scnhdr
.s_flags
|= IMAGE_SCN_LNK_COMDAT
;
2648 /* We store the type in the seg_info structure, and use it to set up
2649 the auxiliary entry for the section symbol in c_section_symbol. */
2650 seg_info (now_seg
)->linkonce
= type
;
2656 coff_obj_read_begin_hook ()
2658 /* These had better be the same. Usually 18 bytes. */
2660 know (sizeof (SYMENT
) == sizeof (AUXENT
));
2661 know (SYMESZ
== AUXESZ
);
2666 /* This function runs through the symbol table and puts all the
2667 externals onto another chain */
2669 /* The chain of globals. */
2670 symbolS
*symbol_globalP
;
2671 symbolS
*symbol_global_lastP
;
2673 /* The chain of externals */
2674 symbolS
*symbol_externP
;
2675 symbolS
*symbol_extern_lastP
;
2678 symbolS
*last_functionP
;
2679 static symbolS
*last_bfP
;
2686 unsigned int symbol_number
= 0;
2687 unsigned int last_file_symno
= 0;
2689 struct filename_list
*filename_list_scan
= filename_list_head
;
2691 for (symbolP
= symbol_rootP
;
2693 symbolP
= symbolP
? symbol_next (symbolP
) : symbol_rootP
)
2695 if (symbolP
->sy_mri_common
)
2697 if (S_GET_STORAGE_CLASS (symbolP
) == C_EXT
2699 || S_GET_STORAGE_CLASS (symbolP
) == C_NT_WEAK
2701 || S_GET_STORAGE_CLASS (symbolP
) == C_WEAKEXT
)
2702 as_bad (_("%s: global symbols not supported in common sections"),
2703 S_GET_NAME (symbolP
));
2704 symbol_remove (symbolP
, &symbol_rootP
, &symbol_lastP
);
2708 if (!SF_GET_DEBUG (symbolP
))
2710 /* Debug symbols do not need all this rubbish */
2711 symbolS
*real_symbolP
;
2713 /* L* and C_EFCN symbols never merge. */
2714 if (!SF_GET_LOCAL (symbolP
)
2715 && !SF_GET_STATICS (symbolP
)
2716 && S_GET_STORAGE_CLASS (symbolP
) != C_LABEL
2717 && symbolP
->sy_value
.X_op
== O_constant
2718 && (real_symbolP
= symbol_find_base (S_GET_NAME (symbolP
), DO_NOT_STRIP
))
2719 && real_symbolP
!= symbolP
)
2721 /* FIXME-SOON: where do dups come from?
2722 Maybe tag references before definitions? xoxorich. */
2723 /* Move the debug data from the debug symbol to the
2724 real symbol. Do NOT do the oposite (i.e. move from
2725 real symbol to debug symbol and remove real symbol from the
2726 list.) Because some pointers refer to the real symbol
2727 whereas no pointers refer to the debug symbol. */
2728 c_symbol_merge (symbolP
, real_symbolP
);
2729 /* Replace the current symbol by the real one */
2730 /* The symbols will never be the last or the first
2731 because : 1st symbol is .file and 3 last symbols are
2732 .text, .data, .bss */
2733 symbol_remove (real_symbolP
, &symbol_rootP
, &symbol_lastP
);
2734 symbol_insert (real_symbolP
, symbolP
, &symbol_rootP
, &symbol_lastP
);
2735 symbol_remove (symbolP
, &symbol_rootP
, &symbol_lastP
);
2736 symbolP
= real_symbolP
;
2737 } /* if not local but dup'd */
2739 if (flag_readonly_data_in_text
&& (S_GET_SEGMENT (symbolP
) == SEG_E1
))
2741 S_SET_SEGMENT (symbolP
, SEG_E0
);
2742 } /* push data into text */
2744 resolve_symbol_value (symbolP
, 1);
2746 if (S_GET_STORAGE_CLASS (symbolP
) == C_NULL
)
2748 if (!S_IS_DEFINED (symbolP
) && !SF_GET_LOCAL (symbolP
))
2750 S_SET_EXTERNAL (symbolP
);
2752 else if (S_GET_SEGMENT (symbolP
) == SEG_E0
)
2754 S_SET_STORAGE_CLASS (symbolP
, C_LABEL
);
2758 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
2762 /* Mainly to speed up if not -g */
2763 if (SF_GET_PROCESS (symbolP
))
2765 /* Handle the nested blocks auxiliary info. */
2766 if (S_GET_STORAGE_CLASS (symbolP
) == C_BLOCK
)
2768 if (!strcmp (S_GET_NAME (symbolP
), ".bb"))
2769 stack_push (block_stack
, (char *) &symbolP
);
2772 register symbolS
*begin_symbolP
;
2773 begin_symbolP
= *(symbolS
**) stack_pop (block_stack
);
2774 if (begin_symbolP
== (symbolS
*) 0)
2775 as_warn (_("mismatched .eb"));
2777 SA_SET_SYM_ENDNDX (begin_symbolP
, symbol_number
+ 2);
2780 /* If we are able to identify the type of a function, and we
2781 are out of a function (last_functionP == 0) then, the
2782 function symbol will be associated with an auxiliary
2784 if (last_functionP
== (symbolS
*) 0 &&
2785 SF_GET_FUNCTION (symbolP
))
2787 last_functionP
= symbolP
;
2789 if (S_GET_NUMBER_AUXILIARY (symbolP
) < 1)
2791 S_SET_NUMBER_AUXILIARY (symbolP
, 1);
2792 } /* make it at least 1 */
2794 /* Clobber possible stale .dim information. */
2796 /* Iffed out by steve - this fries the lnnoptr info too */
2797 bzero (symbolP
->sy_symbol
.ost_auxent
[0].x_sym
.x_fcnary
.x_ary
.x_dimen
,
2798 sizeof (symbolP
->sy_symbol
.ost_auxent
[0].x_sym
.x_fcnary
.x_ary
.x_dimen
));
2801 if (S_GET_STORAGE_CLASS (symbolP
) == C_FCN
)
2803 if (strcmp (S_GET_NAME (symbolP
), ".bf") == 0)
2805 if (last_bfP
!= NULL
)
2806 SA_SET_SYM_ENDNDX (last_bfP
, symbol_number
);
2810 else if (S_GET_STORAGE_CLASS (symbolP
) == C_EFCN
)
2812 /* I don't even know if this is needed for sdb. But
2813 the standard assembler generates it, so... */
2814 if (last_functionP
== (symbolS
*) 0)
2815 as_fatal (_("C_EFCN symbol out of scope"));
2816 SA_SET_SYM_FSIZE (last_functionP
,
2817 (long) (S_GET_VALUE (symbolP
) -
2818 S_GET_VALUE (last_functionP
)));
2819 SA_SET_SYM_ENDNDX (last_functionP
, symbol_number
);
2820 last_functionP
= (symbolS
*) 0;
2824 else if (SF_GET_TAG (symbolP
))
2826 /* First descriptor of a structure must point to
2827 the first slot after the structure description. */
2828 last_tagP
= symbolP
;
2831 else if (S_GET_STORAGE_CLASS (symbolP
) == C_EOS
)
2833 /* +2 take in account the current symbol */
2834 SA_SET_SYM_ENDNDX (last_tagP
, symbol_number
+ 2);
2836 else if (S_GET_STORAGE_CLASS (symbolP
) == C_FILE
)
2838 /* If the filename was too long to fit in the
2839 auxent, put it in the string table */
2840 if (SA_GET_FILE_FNAME_ZEROS (symbolP
) == 0
2841 && SA_GET_FILE_FNAME_OFFSET (symbolP
) != 0)
2843 SA_SET_FILE_FNAME_OFFSET (symbolP
, string_byte_count
);
2844 string_byte_count
+= strlen (filename_list_scan
->filename
) + 1;
2845 filename_list_scan
= filename_list_scan
->next
;
2847 if (S_GET_VALUE (symbolP
))
2849 S_SET_VALUE (symbolP
, last_file_symno
);
2850 last_file_symno
= symbol_number
;
2851 } /* no one points at the first .file symbol */
2852 } /* if debug or tag or eos or file */
2854 #ifdef tc_frob_coff_symbol
2855 tc_frob_coff_symbol (symbolP
);
2858 /* We must put the external symbols apart. The loader
2859 does not bomb if we do not. But the references in
2860 the endndx field for a .bb symbol are not corrected
2861 if an external symbol is removed between .bb and .be.
2862 I.e in the following case :
2863 [20] .bb endndx = 22
2866 ld will move the symbol 21 to the end of the list but
2867 endndx will still be 22 instead of 21. */
2870 if (SF_GET_LOCAL (symbolP
))
2872 /* remove C_EFCN and LOCAL (L...) symbols */
2873 /* next pointer remains valid */
2874 symbol_remove (symbolP
, &symbol_rootP
, &symbol_lastP
);
2877 else if (symbolP
->sy_value
.X_op
== O_symbol
2878 && (! S_IS_DEFINED (symbolP
) || S_IS_COMMON (symbolP
)))
2880 /* Skip symbols which were equated to undefined or common
2882 symbol_remove (symbolP
, &symbol_rootP
, &symbol_lastP
);
2884 else if (!S_IS_DEFINED (symbolP
)
2885 && !S_IS_DEBUG (symbolP
)
2886 && !SF_GET_STATICS (symbolP
)
2887 && (S_GET_STORAGE_CLASS (symbolP
) == C_EXT
2889 || S_GET_STORAGE_CLASS (symbolP
) == C_NT_WEAK
2891 || S_GET_STORAGE_CLASS (symbolP
) == C_WEAKEXT
))
2893 /* if external, Remove from the list */
2894 symbolS
*hold
= symbol_previous (symbolP
);
2896 symbol_remove (symbolP
, &symbol_rootP
, &symbol_lastP
);
2897 symbol_clear_list_pointers (symbolP
);
2898 symbol_append (symbolP
, symbol_extern_lastP
, &symbol_externP
, &symbol_extern_lastP
);
2901 else if (! S_IS_DEBUG (symbolP
)
2902 && ! SF_GET_STATICS (symbolP
)
2903 && ! SF_GET_FUNCTION (symbolP
)
2904 && (S_GET_STORAGE_CLASS (symbolP
) == C_EXT
2906 || S_GET_STORAGE_CLASS (symbolP
) == C_NT_WEAK
2908 || S_GET_STORAGE_CLASS (symbolP
) == C_NT_WEAK
))
2910 symbolS
*hold
= symbol_previous (symbolP
);
2912 /* The O'Reilly COFF book says that defined global symbols
2913 come at the end of the symbol table, just before
2914 undefined global symbols. */
2916 symbol_remove (symbolP
, &symbol_rootP
, &symbol_lastP
);
2917 symbol_clear_list_pointers (symbolP
);
2918 symbol_append (symbolP
, symbol_global_lastP
, &symbol_globalP
,
2919 &symbol_global_lastP
);
2924 if (SF_GET_STRING (symbolP
))
2926 symbolP
->sy_name_offset
= string_byte_count
;
2927 string_byte_count
+= strlen (S_GET_NAME (symbolP
)) + 1;
2931 symbolP
->sy_name_offset
= 0;
2932 } /* fix "long" names */
2934 symbolP
->sy_number
= symbol_number
;
2935 symbol_number
+= 1 + S_GET_NUMBER_AUXILIARY (symbolP
);
2936 } /* if local symbol */
2937 } /* traverse the symbol list */
2938 return symbol_number
;
2944 glue_symbols (head
, tail
)
2948 unsigned int symbol_number
= 0;
2950 while (*head
!= NULL
)
2952 symbolS
*tmp
= *head
;
2955 symbol_remove (tmp
, head
, tail
);
2956 symbol_append (tmp
, symbol_lastP
, &symbol_rootP
, &symbol_lastP
);
2959 if (SF_GET_STRING (tmp
))
2961 tmp
->sy_name_offset
= string_byte_count
;
2962 string_byte_count
+= strlen (S_GET_NAME (tmp
)) + 1;
2966 tmp
->sy_name_offset
= 0;
2967 } /* fix "long" names */
2969 tmp
->sy_number
= symbol_number
;
2970 symbol_number
+= 1 + S_GET_NUMBER_AUXILIARY (tmp
);
2971 } /* append the entire extern chain */
2973 return symbol_number
;
2979 unsigned int symbol_number
= 0;
2982 for (symbolP
= symbol_rootP
; symbolP
; symbolP
= symbol_next (symbolP
))
2984 symbolP
->sy_number
= symbol_number
;
2986 if (SF_GET_TAGGED (symbolP
))
2990 ((symbolS
*) SA_GET_SYM_TAGNDX (symbolP
))->sy_number
);
2993 symbol_number
+= 1 + S_GET_NUMBER_AUXILIARY (symbolP
);
2996 return symbol_number
;
3000 crawl_symbols (h
, abfd
)
3002 bfd
*abfd ATTRIBUTE_UNUSED
;
3006 /* Initialize the stack used to keep track of the matching .bb .be */
3008 block_stack
= stack_init (512, sizeof (symbolS
*));
3010 /* The symbol list should be ordered according to the following sequence
3013 * . debug entries for functions
3014 * . fake symbols for the sections, including .text .data and .bss
3016 * . undefined symbols
3017 * But this is not mandatory. The only important point is to put the
3018 * undefined symbols at the end of the list.
3021 /* Is there a .file symbol ? If not insert one at the beginning. */
3022 if (symbol_rootP
== NULL
3023 || S_GET_STORAGE_CLASS (symbol_rootP
) != C_FILE
)
3025 c_dot_file_symbol ("fake");
3029 * Build up static symbols for the sections, they are filled in later
3033 for (i
= SEG_E0
; i
< SEG_LAST
; i
++)
3034 if (segment_info
[i
].scnhdr
.s_name
[0])
3035 segment_info
[i
].dot
= c_section_symbol (segment_info
[i
].name
,
3038 /* Take all the externals out and put them into another chain */
3039 H_SET_SYMBOL_TABLE_SIZE (h
, yank_symbols ());
3040 /* Take the externals and glue them onto the end.*/
3041 H_SET_SYMBOL_TABLE_SIZE (h
,
3042 (H_GET_SYMBOL_COUNT (h
)
3043 + glue_symbols (&symbol_globalP
,
3044 &symbol_global_lastP
)
3045 + glue_symbols (&symbol_externP
,
3046 &symbol_extern_lastP
)));
3048 H_SET_SYMBOL_TABLE_SIZE (h
, tie_tags ());
3049 know (symbol_globalP
== NULL
);
3050 know (symbol_global_lastP
== NULL
);
3051 know (symbol_externP
== NULL
);
3052 know (symbol_extern_lastP
== NULL
);
3056 * Find strings by crawling along symbol table chain.
3064 struct filename_list
*filename_list_scan
= filename_list_head
;
3066 /* Gotta do md_ byte-ordering stuff for string_byte_count first - KWK */
3067 md_number_to_chars (where
, (valueT
) string_byte_count
, 4);
3070 #ifdef COFF_LONG_SECTION_NAMES
3071 /* Support long section names as found in PE. This code must
3072 coordinate with that in coff_header_append and write_object_file. */
3076 for (i
= SEG_E0
; i
< SEG_LAST
; i
++)
3078 if (segment_info
[i
].scnhdr
.s_name
[0]
3079 && strlen (segment_info
[i
].name
) > SCNNMLEN
)
3083 size
= strlen (segment_info
[i
].name
) + 1;
3084 memcpy (where
, segment_info
[i
].name
, size
);
3089 #endif /* COFF_LONG_SECTION_NAMES */
3091 for (symbolP
= symbol_rootP
;
3093 symbolP
= symbol_next (symbolP
))
3097 if (SF_GET_STRING (symbolP
))
3099 size
= strlen (S_GET_NAME (symbolP
)) + 1;
3100 memcpy (where
, S_GET_NAME (symbolP
), size
);
3103 if (S_GET_STORAGE_CLASS (symbolP
) == C_FILE
3104 && SA_GET_FILE_FNAME_ZEROS (symbolP
) == 0
3105 && SA_GET_FILE_FNAME_OFFSET (symbolP
) != 0)
3107 size
= strlen (filename_list_scan
->filename
) + 1;
3108 memcpy (where
, filename_list_scan
->filename
, size
);
3109 filename_list_scan
= filename_list_scan
->next
;
3116 do_linenos_for (abfd
, h
, file_cursor
)
3119 unsigned long *file_cursor
;
3122 unsigned long start
= *file_cursor
;
3124 for (idx
= SEG_E0
; idx
< SEG_LAST
; idx
++)
3126 segment_info_type
*s
= segment_info
+ idx
;
3129 if (s
->scnhdr
.s_nlnno
!= 0)
3131 struct lineno_list
*line_ptr
;
3133 struct external_lineno
*buffer
=
3134 (struct external_lineno
*) xmalloc (s
->scnhdr
.s_nlnno
* LINESZ
);
3136 struct external_lineno
*dst
= buffer
;
3138 /* Run through the table we've built and turn it into its external
3139 form, take this chance to remove duplicates */
3141 for (line_ptr
= s
->lineno_list_head
;
3142 line_ptr
!= (struct lineno_list
*) NULL
;
3143 line_ptr
= line_ptr
->next
)
3146 if (line_ptr
->line
.l_lnno
== 0)
3148 /* Turn a pointer to a symbol into the symbols' index */
3149 line_ptr
->line
.l_addr
.l_symndx
=
3150 ((symbolS
*) line_ptr
->line
.l_addr
.l_symndx
)->sy_number
;
3154 line_ptr
->line
.l_addr
.l_paddr
+= ((struct frag
*) (line_ptr
->frag
))->fr_address
;
3158 (void) bfd_coff_swap_lineno_out (abfd
, &(line_ptr
->line
), dst
);
3163 s
->scnhdr
.s_lnnoptr
= *file_cursor
;
3165 bfd_write (buffer
, 1, s
->scnhdr
.s_nlnno
* LINESZ
, abfd
);
3168 *file_cursor
+= s
->scnhdr
.s_nlnno
* LINESZ
;
3171 H_SET_LINENO_SIZE (h
, *file_cursor
- start
);
3175 /* Now we run through the list of frag chains in a segment and
3176 make all the subsegment frags appear at the end of the
3177 list, as if the seg 0 was extra long */
3184 for (i
= SEG_E0
; i
< SEG_UNKNOWN
; i
++)
3186 frchainS
*head
= segment_info
[i
].frchainP
;
3188 fragS
*prev_frag
= &dummy
;
3190 while (head
&& head
->frch_seg
== i
)
3192 prev_frag
->fr_next
= head
->frch_root
;
3193 prev_frag
= head
->frch_last
;
3194 head
= head
->frch_next
;
3196 prev_frag
->fr_next
= 0;
3200 unsigned long machine
;
3203 write_object_file ()
3207 struct frchain
*frchain_ptr
;
3209 object_headers headers
;
3210 unsigned long file_cursor
;
3213 abfd
= bfd_openw (out_file_name
, TARGET_FORMAT
);
3218 as_perror (_("FATAL: Can't create %s"), out_file_name
);
3219 exit (EXIT_FAILURE
);
3221 bfd_set_format (abfd
, bfd_object
);
3222 bfd_set_arch_mach (abfd
, BFD_ARCH
, machine
);
3224 string_byte_count
= 4;
3226 for (frchain_ptr
= frchain_root
;
3227 frchain_ptr
!= (struct frchain
*) NULL
;
3228 frchain_ptr
= frchain_ptr
->frch_next
)
3230 /* Run through all the sub-segments and align them up. Also
3231 close any open frags. We tack a .fill onto the end of the
3232 frag chain so that any .align's size can be worked by looking
3233 at the next frag. */
3235 subseg_set (frchain_ptr
->frch_seg
, frchain_ptr
->frch_subseg
);
3237 #ifndef SUB_SEGMENT_ALIGN
3238 #define SUB_SEGMENT_ALIGN(SEG) 1
3241 md_do_align (SUB_SEGMENT_ALIGN (now_seg
), (char *) NULL
, 0, 0,
3244 frag_align (SUB_SEGMENT_ALIGN (now_seg
),
3245 subseg_text_p (now_seg
) ? NOP_OPCODE
: 0,
3250 frag_wane (frag_now
);
3251 frag_now
->fr_fix
= 0;
3252 know (frag_now
->fr_next
== NULL
);
3259 for (i
= SEG_E0
; i
< SEG_UNKNOWN
; i
++)
3261 relax_segment (segment_info
[i
].frchainP
->frch_root
, i
);
3264 H_SET_NUMBER_OF_SECTIONS (&headers
, 0);
3266 /* Find out how big the sections are, and set the addresses. */
3268 for (i
= SEG_E0
; i
< SEG_UNKNOWN
; i
++)
3272 segment_info
[i
].scnhdr
.s_paddr
= addr
;
3273 segment_info
[i
].scnhdr
.s_vaddr
= addr
;
3275 if (segment_info
[i
].scnhdr
.s_name
[0])
3277 H_SET_NUMBER_OF_SECTIONS (&headers
,
3278 H_GET_NUMBER_OF_SECTIONS (&headers
) + 1);
3280 #ifdef COFF_LONG_SECTION_NAMES
3281 /* Support long section names as found in PE. This code
3282 must coordinate with that in coff_header_append and
3287 len
= strlen (segment_info
[i
].name
);
3289 string_byte_count
+= len
+ 1;
3291 #endif /* COFF_LONG_SECTION_NAMES */
3294 size
= size_section (abfd
, (unsigned int) i
);
3297 /* I think the section alignment is only used on the i960; the
3298 i960 needs it, and it should do no harm on other targets. */
3299 #ifdef ALIGNMENT_IN_S_FLAGS
3300 segment_info
[i
].scnhdr
.s_flags
|= (section_alignment
[i
] & 0xF) << 8;
3302 segment_info
[i
].scnhdr
.s_align
= 1 << section_alignment
[i
];
3306 H_SET_TEXT_SIZE (&headers
, size
);
3307 else if (i
== SEG_E1
)
3308 H_SET_DATA_SIZE (&headers
, size
);
3309 else if (i
== SEG_E2
)
3310 H_SET_BSS_SIZE (&headers
, size
);
3313 /* Turn the gas native symbol table shape into a coff symbol table */
3314 crawl_symbols (&headers
, abfd
);
3316 if (string_byte_count
== 4)
3317 string_byte_count
= 0;
3319 H_SET_STRING_SIZE (&headers
, string_byte_count
);
3325 for (i
= SEG_E0
; i
< SEG_UNKNOWN
; i
++)
3327 fixup_mdeps (segment_info
[i
].frchainP
->frch_root
, &headers
, i
);
3328 fixup_segment (&segment_info
[i
], i
);
3331 /* Look for ".stab" segments and fill in their initial symbols
3333 for (i
= SEG_E0
; i
< SEG_UNKNOWN
; i
++)
3335 name
= segment_info
[i
].name
;
3338 && strncmp (".stab", name
, 5) == 0
3339 && strncmp (".stabstr", name
, 8) != 0)
3340 adjust_stab_section (abfd
, i
);
3343 file_cursor
= H_GET_TEXT_FILE_OFFSET (&headers
);
3345 bfd_seek (abfd
, (file_ptr
) file_cursor
, 0);
3347 /* Plant the data */
3349 fill_section (abfd
, &headers
, &file_cursor
);
3351 do_relocs_for (abfd
, &headers
, &file_cursor
);
3353 do_linenos_for (abfd
, &headers
, &file_cursor
);
3355 H_SET_FILE_MAGIC_NUMBER (&headers
, COFF_MAGIC
);
3356 #ifndef OBJ_COFF_OMIT_TIMESTAMP
3357 H_SET_TIME_STAMP (&headers
, (long)time((time_t *)0));
3359 H_SET_TIME_STAMP (&headers
, 0);
3361 #ifdef TC_COFF_SET_MACHINE
3362 TC_COFF_SET_MACHINE (&headers
);
3366 #define COFF_FLAGS 0
3369 #ifdef KEEP_RELOC_INFO
3370 H_SET_FLAGS (&headers
, ((H_GET_LINENO_SIZE(&headers
) ? 0 : F_LNNO
) |
3371 COFF_FLAGS
| coff_flags
));
3373 H_SET_FLAGS (&headers
, ((H_GET_LINENO_SIZE(&headers
) ? 0 : F_LNNO
) |
3374 (H_GET_RELOCATION_SIZE(&headers
) ? 0 : F_RELFLG
) |
3375 COFF_FLAGS
| coff_flags
));
3379 unsigned int symtable_size
= H_GET_SYMBOL_TABLE_SIZE (&headers
);
3380 char *buffer1
= xmalloc (symtable_size
+ string_byte_count
+ 1);
3382 H_SET_SYMBOL_TABLE_POINTER (&headers
, bfd_tell (abfd
));
3383 w_symbols (abfd
, buffer1
, symbol_rootP
);
3384 if (string_byte_count
> 0)
3385 w_strings (buffer1
+ symtable_size
);
3386 bfd_write (buffer1
, 1, symtable_size
+ string_byte_count
, abfd
);
3390 coff_header_append (abfd
, &headers
);
3392 /* Recent changes to write need this, but where it should
3393 go is up to Ken.. */
3394 if (bfd_close_all_done (abfd
) == false)
3395 as_fatal (_("Can't close %s: %s"), out_file_name
,
3396 bfd_errmsg (bfd_get_error ()));
3399 extern bfd
*stdoutput
;
3406 /* Add a new segment. This is called from subseg_new via the
3407 obj_new_segment macro. */
3410 obj_coff_add_segment (name
)
3415 #ifndef COFF_LONG_SECTION_NAMES
3416 char buf
[SCNNMLEN
+ 1];
3418 strncpy (buf
, name
, SCNNMLEN
);
3419 buf
[SCNNMLEN
] = '\0';
3423 for (i
= SEG_E0
; i
< SEG_LAST
&& segment_info
[i
].scnhdr
.s_name
[0]; i
++)
3424 if (strcmp (name
, segment_info
[i
].name
) == 0)
3429 as_bad (_("Too many new sections; can't add \"%s\""), name
);
3433 /* Add a new section. */
3434 strncpy (segment_info
[i
].scnhdr
.s_name
, name
,
3435 sizeof (segment_info
[i
].scnhdr
.s_name
));
3436 segment_info
[i
].scnhdr
.s_flags
= STYP_REG
;
3437 segment_info
[i
].name
= xstrdup (name
);
3443 * implement the .section pseudo op:
3444 * .section name {, "flags"}
3446 * | +--- optional flags: 'b' for bss
3448 * +-- section name 'l' for lib
3452 * 'd' (apparently m88k for data)
3454 * 'r' for read-only data
3455 * But if the argument is not a quoted string, treat it as a
3456 * subsegment number.
3460 obj_coff_section (ignore
)
3461 int ignore ATTRIBUTE_UNUSED
;
3463 /* Strip out the section name */
3464 char *section_name
, *name
;
3477 else if (type
== 'D')
3479 segment_info
[now_seg
].scnhdr
.s_flags
|= flags
;
3484 section_name
= input_line_pointer
;
3485 c
= get_symbol_end ();
3487 name
= xmalloc (input_line_pointer
- section_name
+ 1);
3488 strcpy (name
, section_name
);
3490 *input_line_pointer
= c
;
3496 if (*input_line_pointer
== ',')
3498 ++input_line_pointer
;
3501 if (*input_line_pointer
!= '"')
3502 exp
= get_absolute_expression ();
3505 ++input_line_pointer
;
3506 while (*input_line_pointer
!= '"'
3507 && ! is_end_of_line
[(unsigned char) *input_line_pointer
])
3509 switch (*input_line_pointer
)
3511 case 'b': flags
|= STYP_BSS
; break;
3512 case 'i': flags
|= STYP_INFO
; break;
3513 case 'l': flags
|= STYP_LIB
; break;
3514 case 'n': flags
|= STYP_NOLOAD
; break;
3515 case 'o': flags
|= STYP_OVER
; break;
3517 case 'w': flags
|= STYP_DATA
; break;
3518 case 'x': flags
|= STYP_TEXT
; break;
3519 case 'r': flags
|= STYP_LIT
; break;
3521 as_warn(_("unknown section attribute '%c'"),
3522 *input_line_pointer
);
3525 ++input_line_pointer
;
3527 if (*input_line_pointer
== '"')
3528 ++input_line_pointer
;
3532 subseg_new (name
, (subsegT
) exp
);
3534 segment_info
[now_seg
].scnhdr
.s_flags
|= flags
;
3536 demand_empty_rest_of_line ();
3541 obj_coff_text (ignore
)
3542 int ignore ATTRIBUTE_UNUSED
;
3544 subseg_new (".text", get_absolute_expression ());
3549 obj_coff_data (ignore
)
3550 int ignore ATTRIBUTE_UNUSED
;
3552 if (flag_readonly_data_in_text
)
3553 subseg_new (".text", get_absolute_expression () + 1000);
3555 subseg_new (".data", get_absolute_expression ());
3559 obj_coff_ident (ignore
)
3560 int ignore ATTRIBUTE_UNUSED
;
3562 segT current_seg
= now_seg
; /* save current seg */
3563 subsegT current_subseg
= now_subseg
;
3564 subseg_new (".comment", 0); /* .comment seg */
3565 stringer (1); /* read string */
3566 subseg_set (current_seg
, current_subseg
); /* restore current seg */
3570 c_symbol_merge (debug
, normal
)
3574 S_SET_DATA_TYPE (normal
, S_GET_DATA_TYPE (debug
));
3575 S_SET_STORAGE_CLASS (normal
, S_GET_STORAGE_CLASS (debug
));
3577 if (S_GET_NUMBER_AUXILIARY (debug
) > S_GET_NUMBER_AUXILIARY (normal
))
3579 S_SET_NUMBER_AUXILIARY (normal
, S_GET_NUMBER_AUXILIARY (debug
));
3580 } /* take the most we have */
3582 if (S_GET_NUMBER_AUXILIARY (debug
) > 0)
3584 memcpy ((char *) &normal
->sy_symbol
.ost_auxent
[0],
3585 (char *) &debug
->sy_symbol
.ost_auxent
[0],
3586 (unsigned int) (S_GET_NUMBER_AUXILIARY (debug
) * AUXESZ
));
3587 } /* Move all the auxiliary information */
3589 /* Move the debug flags. */
3590 SF_SET_DEBUG_FIELD (normal
, SF_GET_DEBUG_FIELD (debug
));
3591 } /* c_symbol_merge() */
3594 c_line_new (symbol
, paddr
, line_number
, frag
)
3600 struct lineno_list
*new_line
=
3601 (struct lineno_list
*) xmalloc (sizeof (struct lineno_list
));
3603 segment_info_type
*s
= segment_info
+ now_seg
;
3604 new_line
->line
.l_lnno
= line_number
;
3606 if (line_number
== 0)
3608 last_line_symbol
= symbol
;
3609 new_line
->line
.l_addr
.l_symndx
= (long) symbol
;
3613 new_line
->line
.l_addr
.l_paddr
= paddr
;
3616 new_line
->frag
= (char *) frag
;
3617 new_line
->next
= (struct lineno_list
*) NULL
;
3620 if (s
->lineno_list_head
== (struct lineno_list
*) NULL
)
3622 s
->lineno_list_head
= new_line
;
3626 s
->lineno_list_tail
->next
= new_line
;
3628 s
->lineno_list_tail
= new_line
;
3629 return LINESZ
* s
->scnhdr
.s_nlnno
++;
3633 c_dot_file_symbol (filename
)
3638 symbolP
= symbol_new (".file",
3641 &zero_address_frag
);
3643 S_SET_STORAGE_CLASS (symbolP
, C_FILE
);
3644 S_SET_NUMBER_AUXILIARY (symbolP
, 1);
3646 if (strlen (filename
) > FILNMLEN
)
3648 /* Filename is too long to fit into an auxent,
3649 we stick it into the string table instead. We keep
3650 a linked list of the filenames we find so we can emit
3652 struct filename_list
*f
= ((struct filename_list
*)
3653 xmalloc (sizeof (struct filename_list
)));
3655 f
->filename
= filename
;
3658 SA_SET_FILE_FNAME_ZEROS (symbolP
, 0);
3659 SA_SET_FILE_FNAME_OFFSET (symbolP
, 1);
3661 if (filename_list_tail
)
3662 filename_list_tail
->next
= f
;
3664 filename_list_head
= f
;
3665 filename_list_tail
= f
;
3669 SA_SET_FILE_FNAME (symbolP
, filename
);
3676 listing_source_file (filename
);
3682 SF_SET_DEBUG (symbolP
);
3683 S_SET_VALUE (symbolP
, (valueT
) previous_file_symbol
);
3685 previous_file_symbol
= symbolP
;
3687 /* Make sure that the symbol is first on the symbol chain */
3688 if (symbol_rootP
!= symbolP
)
3690 symbol_remove (symbolP
, &symbol_rootP
, &symbol_lastP
);
3691 symbol_insert (symbolP
, symbol_rootP
, &symbol_rootP
, &symbol_lastP
);
3693 } /* c_dot_file_symbol() */
3696 * Build a 'section static' symbol.
3700 c_section_symbol (name
, idx
)
3706 symbolP
= symbol_find_base (name
, DO_NOT_STRIP
);
3707 if (symbolP
== NULL
)
3708 symbolP
= symbol_new (name
, idx
, 0, &zero_address_frag
);
3711 /* Mmmm. I just love violating interfaces. Makes me feel...dirty. */
3712 S_SET_SEGMENT (symbolP
, idx
);
3713 symbolP
->sy_frag
= &zero_address_frag
;
3716 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
3717 S_SET_NUMBER_AUXILIARY (symbolP
, 1);
3719 SF_SET_STATICS (symbolP
);
3722 /* manfred@s-direktnet.de: section symbols *must* have the LOCAL bit cleared,
3723 which is set by the new definition of LOCAL_LABEL in tc-m68k.h. */
3724 SF_CLEAR_LOCAL (symbolP
);
3727 /* If the .linkonce pseudo-op was used for this section, we must
3728 store the information in the auxiliary entry for the section
3730 if (segment_info
[idx
].linkonce
!= LINKONCE_UNSET
)
3734 switch (segment_info
[idx
].linkonce
)
3738 case LINKONCE_DISCARD
:
3739 type
= IMAGE_COMDAT_SELECT_ANY
;
3741 case LINKONCE_ONE_ONLY
:
3742 type
= IMAGE_COMDAT_SELECT_NODUPLICATES
;
3744 case LINKONCE_SAME_SIZE
:
3745 type
= IMAGE_COMDAT_SELECT_SAME_SIZE
;
3747 case LINKONCE_SAME_CONTENTS
:
3748 type
= IMAGE_COMDAT_SELECT_EXACT_MATCH
;
3752 SYM_AUXENT (symbolP
)->x_scn
.x_comdat
= type
;
3757 } /* c_section_symbol() */
3760 w_symbols (abfd
, where
, symbol_rootP
)
3763 symbolS
* symbol_rootP
;
3768 /* First fill in those values we have only just worked out */
3769 for (i
= SEG_E0
; i
< SEG_LAST
; i
++)
3771 symbolP
= segment_info
[i
].dot
;
3774 SA_SET_SCN_SCNLEN (symbolP
, segment_info
[i
].scnhdr
.s_size
);
3775 SA_SET_SCN_NRELOC (symbolP
, segment_info
[i
].scnhdr
.s_nreloc
);
3776 SA_SET_SCN_NLINNO (symbolP
, segment_info
[i
].scnhdr
.s_nlnno
);
3781 * Emit all symbols left in the symbol chain.
3783 for (symbolP
= symbol_rootP
; symbolP
; symbolP
= symbol_next (symbolP
))
3785 /* Used to save the offset of the name. It is used to point
3786 to the string in memory but must be a file offset. */
3787 register char *temp
;
3789 /* We can't fix the lnnoptr field in yank_symbols with the other
3790 adjustments, because we have to wait until we know where they
3792 if (SF_GET_ADJ_LNNOPTR (symbolP
))
3794 SA_GET_SYM_LNNOPTR (symbolP
) +=
3795 segment_info
[S_GET_SEGMENT (symbolP
)].scnhdr
.s_lnnoptr
;
3798 tc_coff_symbol_emit_hook (symbolP
);
3800 temp
= S_GET_NAME (symbolP
);
3801 if (SF_GET_STRING (symbolP
))
3803 S_SET_OFFSET (symbolP
, symbolP
->sy_name_offset
);
3804 S_SET_ZEROES (symbolP
, 0);
3808 memset (symbolP
->sy_symbol
.ost_entry
.n_name
, 0, SYMNMLEN
);
3809 strncpy (symbolP
->sy_symbol
.ost_entry
.n_name
, temp
, SYMNMLEN
);
3811 where
= symbol_to_chars (abfd
, where
, symbolP
);
3812 S_SET_NAME (symbolP
, temp
);
3818 obj_coff_lcomm (ignore
)
3819 int ignore ATTRIBUTE_UNUSED
;
3831 name
= input_line_pointer
;
3833 c
= get_symbol_end ();
3834 p
= input_line_pointer
;
3837 if (*input_line_pointer
!= ',')
3839 as_bad (_("Expected comma after name"));
3840 ignore_rest_of_line ();
3843 if (*input_line_pointer
== '\n')
3845 as_bad (_("Missing size expression"));
3848 input_line_pointer
++;
3849 if ((temp
= get_absolute_expression ()) < 0)
3851 as_warn (_("lcomm length (%d.) <0! Ignored."), temp
);
3852 ignore_rest_of_line ();
3857 symbolP
= symbol_find_or_make(name
);
3859 if (S_GET_SEGMENT(symbolP
) == SEG_UNKNOWN
&&
3860 S_GET_VALUE(symbolP
) == 0)
3865 segT current_seg
= now_seg
; /* save current seg */
3866 subsegT current_subseg
= now_subseg
;
3868 subseg_set (SEG_E2
, 1);
3869 symbolP
->sy_frag
= frag_now
;
3870 p
= frag_var(rs_org
, 1, 1, (relax_substateT
)0, symbolP
,
3871 (offsetT
) temp
, (char *) 0);
3873 subseg_set (current_seg
, current_subseg
); /* restore current seg */
3874 S_SET_SEGMENT(symbolP
, SEG_E2
);
3875 S_SET_STORAGE_CLASS(symbolP
, C_STAT
);
3879 as_bad(_("Symbol %s already defined"), name
);
3881 demand_empty_rest_of_line();
3886 fixup_mdeps (frags
, h
, this_segment
)
3891 subseg_change (this_segment
, 0);
3894 switch (frags
->fr_type
)
3900 HANDLE_ALIGN (frags
);
3902 frags
->fr_type
= rs_fill
;
3904 ((frags
->fr_next
->fr_address
- frags
->fr_address
- frags
->fr_fix
)
3907 case rs_machine_dependent
:
3908 md_convert_frag (h
, this_segment
, frags
);
3914 frags
= frags
->fr_next
;
3920 #ifndef TC_FORCE_RELOCATION
3921 #define TC_FORCE_RELOCATION(fix) 0
3925 fixup_segment (segP
, this_segment_type
)
3926 segment_info_type
* segP
;
3927 segT this_segment_type
;
3929 register fixS
* fixP
;
3930 register symbolS
*add_symbolP
;
3931 register symbolS
*sub_symbolP
;
3934 register char *place
;
3935 register long where
;
3936 register char pcrel
;
3937 register fragS
*fragP
;
3938 register segT add_symbol_segment
= absolute_section
;
3940 for (fixP
= segP
->fix_root
; fixP
; fixP
= fixP
->fx_next
)
3942 fragP
= fixP
->fx_frag
;
3944 where
= fixP
->fx_where
;
3945 place
= fragP
->fr_literal
+ where
;
3946 size
= fixP
->fx_size
;
3947 add_symbolP
= fixP
->fx_addsy
;
3948 sub_symbolP
= fixP
->fx_subsy
;
3949 add_number
= fixP
->fx_offset
;
3950 pcrel
= fixP
->fx_pcrel
;
3952 /* We want function-relative stabs to work on systems which
3953 may use a relaxing linker; thus we must handle the sym1-sym2
3954 fixups function-relative stabs generates.
3956 Of course, if you actually enable relaxing in the linker, the
3957 line and block scoping information is going to be incorrect
3958 in some cases. The only way to really fix this is to support
3959 a reloc involving the difference of two symbols. */
3961 && (!sub_symbolP
|| pcrel
))
3965 if (fixP
->fx_tcbit
&& SF_GET_CALLNAME (add_symbolP
))
3967 /* Relocation should be done via the associated 'bal' entry
3970 if (!SF_GET_BALNAME (tc_get_bal_of_call (add_symbolP
)))
3972 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
3973 _("No 'bal' entry point for leafproc %s"),
3974 S_GET_NAME (add_symbolP
));
3977 fixP
->fx_addsy
= add_symbolP
= tc_get_bal_of_call (add_symbolP
);
3981 /* Make sure the symbols have been resolved; this may not have
3982 happened if these are expression symbols. */
3983 if (add_symbolP
!= NULL
&& ! add_symbolP
->sy_resolved
)
3984 resolve_symbol_value (add_symbolP
, 1);
3986 if (add_symbolP
!= NULL
)
3988 /* If this fixup is against a symbol which has been equated
3989 to another symbol, convert it to the other symbol. */
3990 if (add_symbolP
->sy_value
.X_op
== O_symbol
3991 && (! S_IS_DEFINED (add_symbolP
)
3992 || S_IS_COMMON (add_symbolP
)))
3994 while (add_symbolP
->sy_value
.X_op
== O_symbol
3995 && (! S_IS_DEFINED (add_symbolP
)
3996 || S_IS_COMMON (add_symbolP
)))
4000 /* We must avoid looping, as that can occur with a
4001 badly written program. */
4002 n
= add_symbolP
->sy_value
.X_add_symbol
;
4003 if (n
== add_symbolP
)
4005 add_number
+= add_symbolP
->sy_value
.X_add_number
;
4008 fixP
->fx_addsy
= add_symbolP
;
4009 fixP
->fx_offset
= add_number
;
4013 if (sub_symbolP
!= NULL
&& ! sub_symbolP
->sy_resolved
)
4014 resolve_symbol_value (sub_symbolP
, 1);
4016 if (add_symbolP
!= NULL
4017 && add_symbolP
->sy_mri_common
)
4019 know (add_symbolP
->sy_value
.X_op
== O_symbol
);
4020 add_number
+= S_GET_VALUE (add_symbolP
);
4021 fixP
->fx_offset
= add_number
;
4022 add_symbolP
= fixP
->fx_addsy
= add_symbolP
->sy_value
.X_add_symbol
;
4027 add_symbol_segment
= S_GET_SEGMENT (add_symbolP
);
4028 } /* if there is an addend */
4032 if (add_symbolP
== NULL
|| add_symbol_segment
== absolute_section
)
4034 if (add_symbolP
!= NULL
)
4036 add_number
+= S_GET_VALUE (add_symbolP
);
4038 fixP
->fx_addsy
= NULL
;
4041 /* It's just -sym. */
4042 if (S_GET_SEGMENT (sub_symbolP
) == absolute_section
)
4044 add_number
-= S_GET_VALUE (sub_symbolP
);
4051 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
4052 _("Negative of non-absolute symbol %s"),
4053 S_GET_NAME (sub_symbolP
));
4055 add_number
-= S_GET_VALUE (sub_symbolP
);
4056 } /* not absolute */
4058 /* if sub_symbol is in the same segment that add_symbol
4059 and add_symbol is either in DATA, TEXT, BSS or ABSOLUTE */
4061 else if (S_GET_SEGMENT (sub_symbolP
) == add_symbol_segment
4062 && SEG_NORMAL (add_symbol_segment
))
4064 /* Difference of 2 symbols from same segment. Can't
4065 make difference of 2 undefineds: 'value' means
4066 something different for N_UNDF. */
4068 /* Makes no sense to use the difference of 2 arbitrary symbols
4069 as the target of a call instruction. */
4072 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
4073 _("callj to difference of 2 symbols"));
4075 #endif /* TC_I960 */
4076 add_number
+= S_GET_VALUE (add_symbolP
) -
4077 S_GET_VALUE (sub_symbolP
);
4080 if (!TC_FORCE_RELOCATION (fixP
))
4082 fixP
->fx_addsy
= NULL
;
4083 fixP
->fx_subsy
= NULL
;
4085 #ifdef TC_M68K /* is this right? */
4093 /* Different segments in subtraction. */
4094 know (!(S_IS_EXTERNAL (sub_symbolP
) && (S_GET_SEGMENT (sub_symbolP
) == absolute_section
)));
4096 if ((S_GET_SEGMENT (sub_symbolP
) == absolute_section
))
4098 add_number
-= S_GET_VALUE (sub_symbolP
);
4101 else if (S_GET_SEGMENT (sub_symbolP
) == this_segment_type
4102 #if 0 /* Okay for 68k, at least... */
4107 /* Make it pc-relative. */
4108 add_number
+= (md_pcrel_from (fixP
)
4109 - S_GET_VALUE (sub_symbolP
));
4118 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
4119 _("Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %ld."),
4120 segment_name (S_GET_SEGMENT (sub_symbolP
)),
4121 S_GET_NAME (sub_symbolP
),
4122 (long) (fragP
->fr_address
+ where
));
4125 } /* if sub_symbolP */
4129 if (add_symbol_segment
== this_segment_type
&& pcrel
)
4132 * This fixup was made when the symbol's segment was
4133 * SEG_UNKNOWN, but it is now in the local segment.
4134 * So we know how to do the address without relocation.
4137 /* reloc_callj() may replace a 'call' with a 'calls' or a 'bal',
4138 * in which cases it modifies *fixP as appropriate. In the case
4139 * of a 'calls', no further work is required, and *fixP has been
4140 * set up to make the rest of the code below a no-op.
4143 #endif /* TC_I960 */
4145 add_number
+= S_GET_VALUE (add_symbolP
);
4146 add_number
-= md_pcrel_from (fixP
);
4149 add_number -= segP->scnhdr.s_vaddr;
4150 if defined (TC_I386) || defined (TE_LYNX). I now
4151 think that was an error propagated from the case when
4152 we are going to emit the relocation. If we are not
4153 going to emit the relocation, then we just want to
4154 set add_number to the difference between the symbols.
4155 This is a case that would only arise when there is a
4156 PC relative reference from a section other than .text
4157 to a symbol defined in the same section, and the
4158 reference is not relaxed. Since jump instructions on
4159 the i386 are relaxed, this could only arise with a
4160 call instruction. */
4162 pcrel
= 0; /* Lie. Don't want further pcrel processing. */
4163 if (!TC_FORCE_RELOCATION (fixP
))
4165 fixP
->fx_addsy
= NULL
;
4171 switch (add_symbol_segment
)
4173 case absolute_section
:
4175 reloc_callj (fixP
); /* See comment about reloc_callj() above*/
4176 #endif /* TC_I960 */
4177 add_number
+= S_GET_VALUE (add_symbolP
);
4180 if (!TC_FORCE_RELOCATION (fixP
))
4182 fixP
->fx_addsy
= NULL
;
4189 #if defined(TC_A29K) || (defined(TE_PE) && defined(TC_I386)) || defined(TC_M88K)
4190 /* This really should be handled in the linker, but
4191 backward compatibility forbids. */
4192 add_number
+= S_GET_VALUE (add_symbolP
);
4194 add_number
+= S_GET_VALUE (add_symbolP
) +
4195 segment_info
[S_GET_SEGMENT (add_symbolP
)].scnhdr
.s_paddr
;
4201 if ((int) fixP
->fx_bit_fixP
== 13)
4203 /* This is a COBR instruction. They have only a
4204 * 13-bit displacement and are only to be used
4205 * for local branches: flag as error, don't generate
4208 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
4209 _("can't use COBR format with external label"));
4210 fixP
->fx_addsy
= NULL
;
4214 #endif /* TC_I960 */
4215 #if ((defined (TC_I386) || defined (TE_LYNX) || defined (TE_AUX)) && !defined(TE_PE)) || defined (COFF_COMMON_ADDEND)
4216 /* 386 COFF uses a peculiar format in which the
4217 value of a common symbol is stored in the .text
4218 segment (I've checked this on SVR3.2 and SCO
4219 3.2.2) Ian Taylor <ian@cygnus.com>. */
4220 /* This is also true for 68k COFF on sysv machines
4221 (Checked on Motorola sysv68 R3V6 and R3V7.1, and also on
4222 UNIX System V/M68000, Release 1.0 from ATT/Bell Labs)
4223 Philippe De Muyter <phdm@info.ucl.ac.be>. */
4224 if (S_IS_COMMON (add_symbolP
))
4225 add_number
+= S_GET_VALUE (add_symbolP
);
4230 } /* switch on symbol seg */
4231 } /* if not in local seg */
4232 } /* if there was a + symbol */
4236 #if !defined(TC_M88K) && !(defined(TE_PE) && defined(TC_I386)) && !defined(TC_A29K)
4237 /* This adjustment is not correct on the m88k, for which the
4238 linker does all the computation. */
4239 add_number
-= md_pcrel_from (fixP
);
4241 if (add_symbolP
== 0)
4243 fixP
->fx_addsy
= &abs_symbol
;
4244 } /* if there's an add_symbol */
4245 #if defined (TC_I386) || defined (TE_LYNX) || defined (TC_I960) || defined (TC_M68K)
4246 /* On the 386 we must adjust by the segment vaddr as well.
4249 I changed the i960 to work this way as well. This is
4250 compatible with the current GNU linker behaviour. I do
4251 not know what other i960 COFF assemblers do. This is not
4252 a common case: normally, only assembler code will contain
4253 a PC relative reloc, and only branches which do not
4254 originate in the .text section will have a non-zero
4257 I changed the m68k to work this way as well. This will
4258 break existing PC relative relocs from sections which do
4259 not start at address 0, but it will make ld -r work.
4260 Ian Taylor, 4 Oct 96. */
4262 add_number
-= segP
->scnhdr
.s_vaddr
;
4266 #ifdef MD_APPLY_FIX3
4267 md_apply_fix3 (fixP
, (valueT
*) &add_number
, this_segment_type
);
4269 md_apply_fix (fixP
, add_number
);
4272 if (!fixP
->fx_bit_fixP
&& ! fixP
->fx_no_overflow
)
4275 /* The m88k uses the offset field of the reloc to get around
4278 && ((add_number
& ~0xFF)
4279 || (fixP
->fx_signed
&& (add_number
& 0x80)))
4280 && ((add_number
& ~0xFF) != (-1 & ~0xFF)
4281 || (add_number
& 0x80) == 0))
4283 && ((add_number
& ~0xFFFF)
4284 || (fixP
->fx_signed
&& (add_number
& 0x8000)))
4285 && ((add_number
& ~0xFFFF) != (-1 & ~0xFFFF)
4286 || (add_number
& 0x8000) == 0)))
4288 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
4289 _("Value of %ld too large for field of %d bytes at 0x%lx"),
4290 (long) add_number
, size
,
4291 (unsigned long) (fragP
->fr_address
+ where
));
4294 #ifdef WARN_SIGNED_OVERFLOW_WORD
4295 /* Warn if a .word value is too large when treated as a
4296 signed number. We already know it is not too negative.
4297 This is to catch over-large switches generated by gcc on
4299 if (!flag_signed_overflow_ok
4301 && add_number
> 0x7fff)
4302 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
4303 _("Signed .word overflow; switch may be too large; %ld at 0x%lx"),
4305 (unsigned long) (fragP
->fr_address
+ where
));
4307 } /* not a bit fix */
4308 } /* For each fixS in this segment. */
4309 } /* fixup_segment() */
4313 /* The first entry in a .stab section is special. */
4316 obj_coff_init_stab_section (seg
)
4322 unsigned int stroff
;
4324 /* Make space for this first symbol. */
4328 as_where (&file
, (unsigned int *) NULL
);
4329 stabstr_name
= (char *) alloca (strlen (segment_info
[seg
].name
) + 4);
4330 strcpy (stabstr_name
, segment_info
[seg
].name
);
4331 strcat (stabstr_name
, "str");
4332 stroff
= get_stab_string_offset (file
, stabstr_name
);
4334 md_number_to_chars (p
, stroff
, 4);
4337 /* Fill in the counts in the first entry in a .stab section. */
4340 adjust_stab_section(abfd
, seg
)
4344 segT stabstrseg
= SEG_UNKNOWN
;
4345 const char *secname
, *name2
;
4348 int i
, strsz
= 0, nsyms
;
4349 fragS
*frag
= segment_info
[seg
].frchainP
->frch_root
;
4351 /* Look for the associated string table section. */
4353 secname
= segment_info
[seg
].name
;
4354 name
= (char *) alloca (strlen (secname
) + 4);
4355 strcpy (name
, secname
);
4356 strcat (name
, "str");
4358 for (i
= SEG_E0
; i
< SEG_UNKNOWN
; i
++)
4360 name2
= segment_info
[i
].name
;
4361 if (name2
!= NULL
&& strncmp(name2
, name
, 8) == 0)
4368 /* If we found the section, get its size. */
4369 if (stabstrseg
!= SEG_UNKNOWN
)
4370 strsz
= size_section (abfd
, stabstrseg
);
4372 nsyms
= size_section (abfd
, seg
) / 12 - 1;
4374 /* Look for the first frag of sufficient size for the initial stab
4375 symbol, and collect a pointer to it. */
4376 while (frag
&& frag
->fr_fix
< 12)
4377 frag
= frag
->fr_next
;
4379 p
= frag
->fr_literal
;
4382 /* Write in the number of stab symbols and the size of the string
4384 bfd_h_put_16 (abfd
, (bfd_vma
) nsyms
, (bfd_byte
*) p
+ 6);
4385 bfd_h_put_32 (abfd
, (bfd_vma
) strsz
, (bfd_byte
*) p
+ 8);
4388 #endif /* not BFD_ASSEMBLER */
4390 const pseudo_typeS obj_pseudo_table
[] =
4392 {"def", obj_coff_def
, 0},
4393 {"dim", obj_coff_dim
, 0},
4394 {"endef", obj_coff_endef
, 0},
4395 {"line", obj_coff_line
, 0},
4396 {"ln", obj_coff_ln
, 0},
4397 {"appline", obj_coff_ln
, 1},
4398 {"scl", obj_coff_scl
, 0},
4399 {"size", obj_coff_size
, 0},
4400 {"tag", obj_coff_tag
, 0},
4401 {"type", obj_coff_type
, 0},
4402 {"val", obj_coff_val
, 0},
4403 {"section", obj_coff_section
, 0},
4404 {"sect", obj_coff_section
, 0},
4405 /* FIXME: We ignore the MRI short attribute. */
4406 {"section.s", obj_coff_section
, 0},
4407 {"sect.s", obj_coff_section
, 0},
4408 /* We accept the .bss directive for backward compatibility with
4409 earlier versions of gas. */
4410 {"bss", obj_coff_bss
, 0},
4411 {"weak", obj_coff_weak
, 0},
4412 #ifndef BFD_ASSEMBLER
4413 {"use", obj_coff_section
, 0},
4414 {"text", obj_coff_text
, 0},
4415 {"data", obj_coff_data
, 0},
4416 {"lcomm", obj_coff_lcomm
, 0},
4417 {"ident", obj_coff_ident
, 0},
4419 {"optim", s_ignore
, 0}, /* For sun386i cc (?) */
4420 {"ident", s_ignore
, 0}, /* we don't yet handle this. */
4422 {"version", s_ignore
, 0},
4423 {"ABORT", s_abort
, 0},
4425 /* The m88k uses sdef instead of def. */
4426 {"sdef", obj_coff_def
, 0},
4428 {NULL
, NULL
, 0} /* end sentinel */
4429 }; /* obj_pseudo_table */
4431 #ifdef BFD_ASSEMBLER
4433 /* Support for a COFF emulation. */
4438 pop_insert (obj_pseudo_table
);
4442 coff_sec_sym_ok_for_reloc (sec
)
4443 asection
*sec ATTRIBUTE_UNUSED
;
4448 const struct format_ops coff_format_ops
=
4450 bfd_target_coff_flavour
,
4455 coff_frob_file_after_relocs
,
4460 obj_generate_asm_lineno
,
4469 coff_sec_sym_ok_for_reloc
,
4476 coff_obj_read_begin_hook
,
4477 coff_obj_symbol_new_hook
,