1 /* coff object file format
2 Copyright (C) 1989, 90, 91, 92, 93, 94, 95, 96, 97, 98, 99, 2000
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 /* The BFD_ASSEMBLER version of obj_coff_section will use this macro to set
34 a new section's attributes when a directive has no valid flags or the
35 "w" flag is used. This default should be appropriate for most. */
36 #ifndef TC_COFF_SECTION_DEFAULT_ATTRIBUTES
37 #define TC_COFF_SECTION_DEFAULT_ATTRIBUTES (SEC_LOAD | SEC_DATA)
40 static void obj_coff_bss
PARAMS ((int));
41 const char *s_get_name
PARAMS ((symbolS
* s
));
42 static void obj_coff_ln
PARAMS ((int));
43 static void obj_coff_def
PARAMS ((int));
44 static void obj_coff_endef
PARAMS ((int));
45 static void obj_coff_dim
PARAMS ((int));
46 static void obj_coff_line
PARAMS ((int));
47 static void obj_coff_size
PARAMS ((int));
48 static void obj_coff_scl
PARAMS ((int));
49 static void obj_coff_tag
PARAMS ((int));
50 static void obj_coff_val
PARAMS ((int));
51 static void obj_coff_type
PARAMS ((int));
52 static void obj_coff_ident
PARAMS ((int));
54 static void obj_coff_loc
PARAMS((int));
57 /* This is used to hold the symbol built by a sequence of pseudo-ops
58 from .def and .endef. */
59 static symbolS
*def_symbol_in_progress
;
64 unsigned long chunk_size
;
65 unsigned long element_size
;
68 unsigned long pointer
;
73 stack_init (chunk_size
, element_size
)
74 unsigned long chunk_size
;
75 unsigned long element_size
;
79 st
= (stack
*) malloc (sizeof (stack
));
82 st
->data
= malloc (chunk_size
);
89 st
->size
= chunk_size
;
90 st
->chunk_size
= chunk_size
;
91 st
->element_size
= element_size
;
96 /* Not currently used. */
107 stack_push (st
, element
)
111 if (st
->pointer
+ st
->element_size
>= st
->size
)
113 st
->size
+= st
->chunk_size
;
114 if ((st
->data
= xrealloc (st
->data
, st
->size
)) == (char *) 0)
117 memcpy (st
->data
+ st
->pointer
, element
, st
->element_size
);
118 st
->pointer
+= st
->element_size
;
119 return st
->data
+ st
->pointer
;
126 if (st
->pointer
< st
->element_size
)
131 st
->pointer
-= st
->element_size
;
132 return st
->data
+ st
->pointer
;
136 * Maintain a list of the tagnames of the structres.
139 static struct hash_control
*tag_hash
;
144 tag_hash
= hash_new ();
148 tag_insert (name
, symbolP
)
152 const char *error_string
;
154 if ((error_string
= hash_jam (tag_hash
, name
, (char *) symbolP
)))
156 as_fatal (_("Inserting \"%s\" into structure table failed: %s"),
165 #ifdef STRIP_UNDERSCORE
168 #endif /* STRIP_UNDERSCORE */
169 return (symbolS
*) hash_find (tag_hash
, name
);
173 tag_find_or_make (name
)
178 if ((symbolP
= tag_find (name
)) == NULL
)
180 symbolP
= symbol_new (name
, undefined_section
,
181 0, &zero_address_frag
);
183 tag_insert (S_GET_NAME (symbolP
), symbolP
);
185 symbol_table_insert (symbolP
);
192 /* We accept the .bss directive to set the section for backward
193 compatibility with earlier versions of gas. */
196 obj_coff_bss (ignore
)
197 int ignore ATTRIBUTE_UNUSED
;
199 if (*input_line_pointer
== '\n')
200 subseg_new (".bss", get_absolute_expression ());
205 /* Handle .weak. This is a GNU extension. */
208 obj_coff_weak (ignore
)
209 int ignore ATTRIBUTE_UNUSED
;
217 name
= input_line_pointer
;
218 c
= get_symbol_end ();
219 symbolP
= symbol_find_or_make (name
);
220 *input_line_pointer
= c
;
224 S_SET_WEAK (symbolP
);
228 S_SET_STORAGE_CLASS (symbolP
, C_NT_WEAK
);
230 S_SET_STORAGE_CLASS (symbolP
, C_WEAKEXT
);
235 input_line_pointer
++;
237 if (*input_line_pointer
== '\n')
243 demand_empty_rest_of_line ();
248 static void SA_SET_SYM_TAGNDX
PARAMS ((symbolS
*, symbolS
*));
250 #define GET_FILENAME_STRING(X) \
251 ((char*)(&((X)->sy_symbol.ost_auxent->x_file.x_n.x_offset))[1])
255 fetch_coff_debug_section ()
257 static segT debug_section
;
261 s
= bfd_make_debug_symbol (stdoutput
, (char *) 0, 0);
263 debug_section
= s
->section
;
265 return debug_section
;
269 SA_SET_SYM_ENDNDX (sym
, val
)
273 combined_entry_type
*entry
, *p
;
275 entry
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[1];
276 p
= coffsymbol (symbol_get_bfdsym (val
))->native
;
277 entry
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
= p
;
282 SA_SET_SYM_TAGNDX (sym
, val
)
286 combined_entry_type
*entry
, *p
;
288 entry
= &coffsymbol (symbol_get_bfdsym (sym
))->native
[1];
289 p
= coffsymbol (symbol_get_bfdsym (val
))->native
;
290 entry
->u
.auxent
.x_sym
.x_tagndx
.p
= p
;
295 S_GET_DATA_TYPE (sym
)
298 return coffsymbol (symbol_get_bfdsym (sym
))->native
->u
.syment
.n_type
;
302 S_SET_DATA_TYPE (sym
, val
)
306 coffsymbol (symbol_get_bfdsym (sym
))->native
->u
.syment
.n_type
= val
;
311 S_GET_STORAGE_CLASS (sym
)
314 return coffsymbol (symbol_get_bfdsym (sym
))->native
->u
.syment
.n_sclass
;
318 S_SET_STORAGE_CLASS (sym
, val
)
322 coffsymbol (symbol_get_bfdsym (sym
))->native
->u
.syment
.n_sclass
= val
;
326 /* Merge a debug symbol containing debug information into a normal symbol. */
329 c_symbol_merge (debug
, normal
)
333 S_SET_DATA_TYPE (normal
, S_GET_DATA_TYPE (debug
));
334 S_SET_STORAGE_CLASS (normal
, S_GET_STORAGE_CLASS (debug
));
336 if (S_GET_NUMBER_AUXILIARY (debug
) > S_GET_NUMBER_AUXILIARY (normal
))
338 /* take the most we have */
339 S_SET_NUMBER_AUXILIARY (normal
, S_GET_NUMBER_AUXILIARY (debug
));
342 if (S_GET_NUMBER_AUXILIARY (debug
) > 0)
344 /* Move all the auxiliary information. */
345 memcpy (SYM_AUXINFO (normal
), SYM_AUXINFO (debug
),
346 (S_GET_NUMBER_AUXILIARY (debug
)
347 * sizeof (*SYM_AUXINFO (debug
))));
350 /* Move the debug flags. */
351 SF_SET_DEBUG_FIELD (normal
, SF_GET_DEBUG_FIELD (debug
));
355 c_dot_file_symbol (filename
)
356 const char *filename
;
360 /* BFD converts filename to a .file symbol with an aux entry. It
361 also handles chaining. */
362 symbolP
= symbol_new (filename
, bfd_abs_section_ptr
, 0, &zero_address_frag
);
364 S_SET_STORAGE_CLASS (symbolP
, C_FILE
);
365 S_SET_NUMBER_AUXILIARY (symbolP
, 1);
367 symbol_get_bfdsym (symbolP
)->flags
= BSF_DEBUGGING
;
374 listing_source_file (filename
);
379 /* Make sure that the symbol is first on the symbol chain */
380 if (symbol_rootP
!= symbolP
)
382 symbol_remove (symbolP
, &symbol_rootP
, &symbol_lastP
);
383 symbol_insert (symbolP
, symbol_rootP
, &symbol_rootP
, &symbol_lastP
);
384 } /* if not first on the list */
387 /* Line number handling */
390 struct line_no
*next
;
397 /* Symbol of last function, which we should hang line#s off of. */
398 static symbolS
*line_fsym
;
400 #define in_function() (line_fsym != 0)
401 #define clear_function() (line_fsym = 0)
402 #define set_function(F) (line_fsym = (F), coff_add_linesym (F))
406 coff_obj_symbol_new_hook (symbolP
)
409 long sz
= (OBJ_COFF_MAX_AUXENTRIES
+ 1) * sizeof (combined_entry_type
);
410 char * s
= (char *) xmalloc (sz
);
413 coffsymbol (symbol_get_bfdsym (symbolP
))->native
= (combined_entry_type
*) s
;
415 S_SET_DATA_TYPE (symbolP
, T_NULL
);
416 S_SET_STORAGE_CLASS (symbolP
, 0);
417 S_SET_NUMBER_AUXILIARY (symbolP
, 0);
419 if (S_IS_STRING (symbolP
))
420 SF_SET_STRING (symbolP
);
422 if (S_IS_LOCAL (symbolP
))
423 SF_SET_LOCAL (symbolP
);
428 * Handle .ln directives.
431 static symbolS
*current_lineno_sym
;
432 static struct line_no
*line_nos
;
433 /* @@ Blindly assume all .ln directives will be in the .text section... */
437 add_lineno (frag
, offset
, num
)
442 struct line_no
*new_line
=
443 (struct line_no
*) xmalloc (sizeof (struct line_no
));
444 if (!current_lineno_sym
)
450 /* Zero is used as an end marker in the file. */
451 as_warn (_("Line numbers must be positive integers\n"));
454 new_line
->next
= line_nos
;
455 new_line
->frag
= frag
;
456 new_line
->l
.line_number
= num
;
457 new_line
->l
.u
.offset
= offset
;
463 coff_add_linesym (sym
)
468 coffsymbol (symbol_get_bfdsym (current_lineno_sym
))->lineno
=
473 current_lineno_sym
= sym
;
477 obj_coff_ln (appline
)
482 if (! appline
&& def_symbol_in_progress
!= NULL
)
484 as_warn (_(".ln pseudo-op inside .def/.endef: ignored."));
485 demand_empty_rest_of_line ();
489 l
= get_absolute_expression ();
492 add_lineno (frag_now
, frag_now_fix (), l
);
496 new_logical_line ((char *) NULL
, l
- 1);
505 l
+= coff_line_base
- 1;
506 listing_source_line (l
);
511 demand_empty_rest_of_line ();
514 /* .loc is essentially the same as .ln; parse it for assembler
518 obj_coff_loc (ignore
)
519 int ignore ATTRIBUTE_UNUSED
;
523 /* FIXME: Why do we need this check? We need it for ECOFF, but why
524 do we need it for COFF? */
525 if (now_seg
!= text_section
)
527 as_warn (_(".loc outside of .text"));
528 demand_empty_rest_of_line ();
532 if (def_symbol_in_progress
!= NULL
)
534 as_warn (_(".loc pseudo-op inside .def/.endef: ignored."));
535 demand_empty_rest_of_line ();
539 /* Skip the file number. */
541 get_absolute_expression ();
544 lineno
= get_absolute_expression ();
552 lineno
+= coff_line_base
- 1;
553 listing_source_line (lineno
);
558 demand_empty_rest_of_line ();
560 add_lineno (frag_now
, frag_now_fix (), lineno
);
563 /* Handle the .ident pseudo-op. */
566 obj_coff_ident (ignore
)
567 int ignore ATTRIBUTE_UNUSED
;
569 segT current_seg
= now_seg
;
570 subsegT current_subseg
= now_subseg
;
576 /* We could put it in .comment, but that creates an extra section
577 that shouldn't be loaded into memory, which requires linker
578 changes... For now, until proven otherwise, use .rdata. */
579 sec
= subseg_new (".rdata$zzz", 0);
580 bfd_set_section_flags (stdoutput
, sec
,
581 ((SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_DATA
)
582 & bfd_applicable_section_flags (stdoutput
)));
585 subseg_new (".comment", 0);
589 subseg_set (current_seg
, current_subseg
);
595 * Handle .def directives.
597 * One might ask : why can't we symbol_new if the symbol does not
598 * already exist and fill it with debug information. Because of
599 * the C_EFCN special symbol. It would clobber the value of the
600 * function symbol before we have a chance to notice that it is
601 * a C_EFCN. And a second reason is that the code is more clear this
602 * way. (at least I think it is :-).
606 #define SKIP_SEMI_COLON() while (*input_line_pointer++ != ';')
607 #define SKIP_WHITESPACES() while (*input_line_pointer == ' ' || \
608 *input_line_pointer == '\t') \
609 input_line_pointer++;
613 int what ATTRIBUTE_UNUSED
;
615 char name_end
; /* Char after the end of name */
616 char *symbol_name
; /* Name of the debug symbol */
617 char *symbol_name_copy
; /* Temporary copy of the name */
618 unsigned int symbol_name_length
;
620 if (def_symbol_in_progress
!= NULL
)
622 as_warn (_(".def pseudo-op used inside of .def/.endef: ignored."));
623 demand_empty_rest_of_line ();
625 } /* if not inside .def/.endef */
629 symbol_name
= input_line_pointer
;
630 #ifdef STRIP_UNDERSCORE
631 if (symbol_name
[0] == '_' && symbol_name
[1] != 0)
633 #endif /* STRIP_UNDERSCORE */
635 name_end
= get_symbol_end ();
636 symbol_name_length
= strlen (symbol_name
);
637 symbol_name_copy
= xmalloc (symbol_name_length
+ 1);
638 strcpy (symbol_name_copy
, symbol_name
);
639 #ifdef tc_canonicalize_symbol_name
640 symbol_name_copy
= tc_canonicalize_symbol_name (symbol_name_copy
);
643 /* Initialize the new symbol */
644 def_symbol_in_progress
= symbol_make (symbol_name_copy
);
645 symbol_set_frag (def_symbol_in_progress
, &zero_address_frag
);
646 S_SET_VALUE (def_symbol_in_progress
, 0);
648 if (S_IS_STRING (def_symbol_in_progress
))
649 SF_SET_STRING (def_symbol_in_progress
);
651 *input_line_pointer
= name_end
;
653 demand_empty_rest_of_line ();
656 unsigned int dim_index
;
659 obj_coff_endef (ignore
)
660 int ignore ATTRIBUTE_UNUSED
;
662 symbolS
*symbolP
= NULL
;
664 /* DIM BUG FIX sac@cygnus.com */
666 if (def_symbol_in_progress
== NULL
)
668 as_warn (_(".endef pseudo-op used outside of .def/.endef: ignored."));
669 demand_empty_rest_of_line ();
671 } /* if not inside .def/.endef */
673 /* Set the section number according to storage class. */
674 switch (S_GET_STORAGE_CLASS (def_symbol_in_progress
))
679 SF_SET_TAG (def_symbol_in_progress
);
680 /* intentional fallthrough */
683 SF_SET_DEBUG (def_symbol_in_progress
);
684 S_SET_SEGMENT (def_symbol_in_progress
, fetch_coff_debug_section ());
688 SF_SET_LOCAL (def_symbol_in_progress
); /* Do not emit this symbol. */
689 /* intentional fallthrough */
691 SF_SET_PROCESS (def_symbol_in_progress
); /* Will need processing before writing */
692 /* intentional fallthrough */
696 S_SET_SEGMENT (def_symbol_in_progress
, text_section
);
698 name
= S_GET_NAME (def_symbol_in_progress
);
699 if (name
[0] == '.' && name
[2] == 'f' && name
[3] == '\0')
705 if (! in_function ())
706 as_warn (_("`%s' symbol without preceding function"), name
);
707 /* Will need relocating. */
708 SF_SET_PROCESS (def_symbol_in_progress
);
714 /* The MS compilers output the actual endline, not the
715 function-relative one... we want to match without
716 changing the assembler input. */
717 SA_SET_SYM_LNNO (def_symbol_in_progress
,
718 (SA_GET_SYM_LNNO (def_symbol_in_progress
)
729 #endif /* C_AUTOARG */
736 /* According to the COFF documentation:
738 http://osr5doc.sco.com:1996/topics/COFF_SectNumFld.html
740 A special section number (-2) marks symbolic debugging symbols,
741 including structure/union/enumeration tag names, typedefs, and
742 the name of the file. A section number of -1 indicates that the
743 symbol has a value but is not relocatable. Examples of
744 absolute-valued symbols include automatic and register variables,
745 function arguments, and .eos symbols.
747 But from Ian Lance Taylor:
749 http://sources.redhat.com/ml/binutils/2000-08/msg00202.html
751 the actual tools all marked them as section -1. So the GNU COFF
752 assembler follows historical COFF assemblers.
754 However, it causes problems for djgpp
756 http://sources.redhat.com/ml/binutils/2000-08/msg00210.html
758 By defining STRICTCOFF, a COFF port can make the assembler to
759 follow the documented behavior. */
766 SF_SET_DEBUG (def_symbol_in_progress
);
767 S_SET_SEGMENT (def_symbol_in_progress
, absolute_section
);
775 S_SET_SEGMENT (def_symbol_in_progress
, absolute_section
);
786 /* Valid but set somewhere else (s_comm, s_lcomm, colon) */
793 as_warn (_("unexpected storage class %d"),
794 S_GET_STORAGE_CLASS (def_symbol_in_progress
));
796 } /* switch on storage class */
798 /* Now that we have built a debug symbol, try to find if we should
799 merge with an existing symbol or not. If a symbol is C_EFCN or
800 absolute_section or untagged SEG_DEBUG it never merges. We also
801 don't merge labels, which are in a different namespace, nor
802 symbols which have not yet been defined since they are typically
803 unique, nor do we merge tags with non-tags. */
805 /* Two cases for functions. Either debug followed by definition or
806 definition followed by debug. For definition first, we will
807 merge the debug symbol into the definition. For debug first, the
808 lineno entry MUST point to the definition function or else it
809 will point off into space when obj_crawl_symbol_chain() merges
810 the debug symbol into the real symbol. Therefor, let's presume
811 the debug symbol is a real function reference. */
813 /* FIXME-SOON If for some reason the definition label/symbol is
814 never seen, this will probably leave an undefined symbol at link
817 if (S_GET_STORAGE_CLASS (def_symbol_in_progress
) == C_EFCN
818 || S_GET_STORAGE_CLASS (def_symbol_in_progress
) == C_LABEL
819 || (!strcmp (bfd_get_section_name (stdoutput
,
820 S_GET_SEGMENT (def_symbol_in_progress
)),
822 && !SF_GET_TAG (def_symbol_in_progress
))
823 || S_GET_SEGMENT (def_symbol_in_progress
) == absolute_section
824 || ! symbol_constant_p (def_symbol_in_progress
)
825 || (symbolP
= symbol_find_base (S_GET_NAME (def_symbol_in_progress
),
826 DO_NOT_STRIP
)) == NULL
827 || SF_GET_TAG (def_symbol_in_progress
) != SF_GET_TAG (symbolP
))
829 /* If it already is at the end of the symbol list, do nothing */
830 if (def_symbol_in_progress
!= symbol_lastP
)
832 symbol_remove (def_symbol_in_progress
, &symbol_rootP
, &symbol_lastP
);
833 symbol_append (def_symbol_in_progress
, symbol_lastP
, &symbol_rootP
,
839 /* This symbol already exists, merge the newly created symbol
840 into the old one. This is not mandatory. The linker can
841 handle duplicate symbols correctly. But I guess that it save
842 a *lot* of space if the assembly file defines a lot of
845 /* The debug entry (def_symbol_in_progress) is merged into the
846 previous definition. */
848 c_symbol_merge (def_symbol_in_progress
, symbolP
);
849 symbol_remove (def_symbol_in_progress
, &symbol_rootP
, &symbol_lastP
);
851 def_symbol_in_progress
= symbolP
;
853 if (SF_GET_FUNCTION (def_symbol_in_progress
)
854 || SF_GET_TAG (def_symbol_in_progress
)
855 || S_GET_STORAGE_CLASS (def_symbol_in_progress
) == C_STAT
)
857 /* For functions, and tags, and static symbols, the symbol
858 *must* be where the debug symbol appears. Move the
859 existing symbol to the current place. */
860 /* If it already is at the end of the symbol list, do nothing */
861 if (def_symbol_in_progress
!= symbol_lastP
)
863 symbol_remove (def_symbol_in_progress
, &symbol_rootP
, &symbol_lastP
);
864 symbol_append (def_symbol_in_progress
, symbol_lastP
, &symbol_rootP
, &symbol_lastP
);
869 if (SF_GET_TAG (def_symbol_in_progress
))
873 oldtag
= symbol_find_base (S_GET_NAME (def_symbol_in_progress
),
875 if (oldtag
== NULL
|| ! SF_GET_TAG (oldtag
))
876 tag_insert (S_GET_NAME (def_symbol_in_progress
),
877 def_symbol_in_progress
);
880 if (SF_GET_FUNCTION (def_symbol_in_progress
))
882 know (sizeof (def_symbol_in_progress
) <= sizeof (long));
883 set_function (def_symbol_in_progress
);
884 SF_SET_PROCESS (def_symbol_in_progress
);
888 /* That is, if this is the first time we've seen the
890 symbol_table_insert (def_symbol_in_progress
);
891 } /* definition follows debug */
892 } /* Create the line number entry pointing to the function being defined */
894 def_symbol_in_progress
= NULL
;
895 demand_empty_rest_of_line ();
899 obj_coff_dim (ignore
)
900 int ignore ATTRIBUTE_UNUSED
;
904 if (def_symbol_in_progress
== NULL
)
906 as_warn (_(".dim pseudo-op used outside of .def/.endef: ignored."));
907 demand_empty_rest_of_line ();
909 } /* if not inside .def/.endef */
911 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
913 for (dim_index
= 0; dim_index
< DIMNUM
; dim_index
++)
916 SA_SET_SYM_DIMEN (def_symbol_in_progress
, dim_index
,
917 get_absolute_expression ());
919 switch (*input_line_pointer
)
922 input_line_pointer
++;
926 as_warn (_("badly formed .dim directive ignored"));
927 /* intentional fallthrough */
935 demand_empty_rest_of_line ();
939 obj_coff_line (ignore
)
940 int ignore ATTRIBUTE_UNUSED
;
944 if (def_symbol_in_progress
== NULL
)
946 /* Probably stabs-style line? */
951 this_base
= get_absolute_expression ();
952 if (!strcmp (".bf", S_GET_NAME (def_symbol_in_progress
)))
953 coff_line_base
= this_base
;
955 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
956 SA_SET_SYM_LNNO (def_symbol_in_progress
, this_base
);
958 demand_empty_rest_of_line ();
961 if (strcmp (".bf", S_GET_NAME (def_symbol_in_progress
)) == 0)
966 listing_source_line ((unsigned int) this_base
);
972 obj_coff_size (ignore
)
973 int ignore ATTRIBUTE_UNUSED
;
975 if (def_symbol_in_progress
== NULL
)
977 as_warn (_(".size pseudo-op used outside of .def/.endef ignored."));
978 demand_empty_rest_of_line ();
980 } /* if not inside .def/.endef */
982 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
983 SA_SET_SYM_SIZE (def_symbol_in_progress
, get_absolute_expression ());
984 demand_empty_rest_of_line ();
988 obj_coff_scl (ignore
)
989 int ignore ATTRIBUTE_UNUSED
;
991 if (def_symbol_in_progress
== NULL
)
993 as_warn (_(".scl pseudo-op used outside of .def/.endef ignored."));
994 demand_empty_rest_of_line ();
996 } /* if not inside .def/.endef */
998 S_SET_STORAGE_CLASS (def_symbol_in_progress
, get_absolute_expression ());
999 demand_empty_rest_of_line ();
1003 obj_coff_tag (ignore
)
1004 int ignore ATTRIBUTE_UNUSED
;
1009 if (def_symbol_in_progress
== NULL
)
1011 as_warn (_(".tag pseudo-op used outside of .def/.endef ignored."));
1012 demand_empty_rest_of_line ();
1016 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
1017 symbol_name
= input_line_pointer
;
1018 name_end
= get_symbol_end ();
1020 #ifdef tc_canonicalize_symbol_name
1021 symbol_name
= tc_canonicalize_symbol_name (symbol_name
);
1024 /* Assume that the symbol referred to by .tag is always defined.
1025 This was a bad assumption. I've added find_or_make. xoxorich. */
1026 SA_SET_SYM_TAGNDX (def_symbol_in_progress
,
1027 tag_find_or_make (symbol_name
));
1028 if (SA_GET_SYM_TAGNDX (def_symbol_in_progress
) == 0L)
1030 as_warn (_("tag not found for .tag %s"), symbol_name
);
1033 SF_SET_TAGGED (def_symbol_in_progress
);
1034 *input_line_pointer
= name_end
;
1036 demand_empty_rest_of_line ();
1040 obj_coff_type (ignore
)
1041 int ignore ATTRIBUTE_UNUSED
;
1043 if (def_symbol_in_progress
== NULL
)
1045 as_warn (_(".type pseudo-op used outside of .def/.endef ignored."));
1046 demand_empty_rest_of_line ();
1048 } /* if not inside .def/.endef */
1050 S_SET_DATA_TYPE (def_symbol_in_progress
, get_absolute_expression ());
1052 if (ISFCN (S_GET_DATA_TYPE (def_symbol_in_progress
)) &&
1053 S_GET_STORAGE_CLASS (def_symbol_in_progress
) != C_TPDEF
)
1055 SF_SET_FUNCTION (def_symbol_in_progress
);
1056 } /* is a function */
1058 demand_empty_rest_of_line ();
1062 obj_coff_val (ignore
)
1063 int ignore ATTRIBUTE_UNUSED
;
1065 if (def_symbol_in_progress
== NULL
)
1067 as_warn (_(".val pseudo-op used outside of .def/.endef ignored."));
1068 demand_empty_rest_of_line ();
1070 } /* if not inside .def/.endef */
1072 if (is_name_beginner (*input_line_pointer
))
1074 char *symbol_name
= input_line_pointer
;
1075 char name_end
= get_symbol_end ();
1077 #ifdef tc_canonicalize_symbol_name
1078 symbol_name
= tc_canonicalize_symbol_name (symbol_name
);
1080 if (!strcmp (symbol_name
, "."))
1082 symbol_set_frag (def_symbol_in_progress
, frag_now
);
1083 S_SET_VALUE (def_symbol_in_progress
, (valueT
) frag_now_fix ());
1084 /* If the .val is != from the .def (e.g. statics) */
1086 else if (strcmp (S_GET_NAME (def_symbol_in_progress
), symbol_name
))
1090 exp
.X_op
= O_symbol
;
1091 exp
.X_add_symbol
= symbol_find_or_make (symbol_name
);
1092 exp
.X_op_symbol
= NULL
;
1093 exp
.X_add_number
= 0;
1094 symbol_set_value_expression (def_symbol_in_progress
, &exp
);
1096 /* If the segment is undefined when the forward reference is
1097 resolved, then copy the segment id from the forward
1099 SF_SET_GET_SEGMENT (def_symbol_in_progress
);
1101 /* FIXME: gcc can generate address expressions here in
1102 unusual cases (search for "obscure" in sdbout.c). We
1103 just ignore the offset here, thus generating incorrect
1104 debugging information. We ignore the rest of the line
1107 /* Otherwise, it is the name of a non debug symbol and its value
1108 will be calculated later. */
1109 *input_line_pointer
= name_end
;
1113 S_SET_VALUE (def_symbol_in_progress
, get_absolute_expression ());
1114 } /* if symbol based */
1116 demand_empty_rest_of_line ();
1120 coff_obj_read_begin_hook ()
1122 /* These had better be the same. Usually 18 bytes. */
1124 know (sizeof (SYMENT
) == sizeof (AUXENT
));
1125 know (SYMESZ
== AUXESZ
);
1131 symbolS
*coff_last_function
;
1132 static symbolS
*coff_last_bf
;
1135 coff_frob_symbol (symp
, punt
)
1139 static symbolS
*last_tagP
;
1140 static stack
*block_stack
;
1141 static symbolS
*set_end
;
1142 symbolS
*next_set_end
= NULL
;
1144 if (symp
== &abs_symbol
)
1150 if (current_lineno_sym
)
1151 coff_add_linesym ((symbolS
*) 0);
1154 block_stack
= stack_init (512, sizeof (symbolS
*));
1156 if (S_IS_WEAK (symp
))
1159 S_SET_STORAGE_CLASS (symp
, C_NT_WEAK
);
1161 S_SET_STORAGE_CLASS (symp
, C_WEAKEXT
);
1165 if (!S_IS_DEFINED (symp
)
1166 && !S_IS_WEAK (symp
)
1167 && S_GET_STORAGE_CLASS (symp
) != C_STAT
)
1168 S_SET_STORAGE_CLASS (symp
, C_EXT
);
1170 if (!SF_GET_DEBUG (symp
))
1173 if (!SF_GET_LOCAL (symp
)
1174 && !SF_GET_STATICS (symp
)
1175 && S_GET_STORAGE_CLASS (symp
) != C_LABEL
1176 && symbol_constant_p(symp
)
1177 && (real
= symbol_find_base (S_GET_NAME (symp
), DO_NOT_STRIP
))
1180 c_symbol_merge (symp
, real
);
1184 if (!S_IS_DEFINED (symp
) && !SF_GET_LOCAL (symp
))
1186 assert (S_GET_VALUE (symp
) == 0);
1187 S_SET_EXTERNAL (symp
);
1189 else if (S_GET_STORAGE_CLASS (symp
) == C_NULL
)
1191 if (S_GET_SEGMENT (symp
) == text_section
1192 && symp
!= seg_info (text_section
)->sym
)
1193 S_SET_STORAGE_CLASS (symp
, C_LABEL
);
1195 S_SET_STORAGE_CLASS (symp
, C_STAT
);
1197 if (SF_GET_PROCESS (symp
))
1199 if (S_GET_STORAGE_CLASS (symp
) == C_BLOCK
)
1201 if (!strcmp (S_GET_NAME (symp
), ".bb"))
1202 stack_push (block_stack
, (char *) &symp
);
1206 begin
= *(symbolS
**) stack_pop (block_stack
);
1208 as_warn (_("mismatched .eb"));
1210 next_set_end
= begin
;
1213 if (coff_last_function
== 0 && SF_GET_FUNCTION (symp
))
1215 union internal_auxent
*auxp
;
1216 coff_last_function
= symp
;
1217 if (S_GET_NUMBER_AUXILIARY (symp
) < 1)
1218 S_SET_NUMBER_AUXILIARY (symp
, 1);
1219 auxp
= SYM_AUXENT (symp
);
1220 memset (auxp
->x_sym
.x_fcnary
.x_ary
.x_dimen
, 0,
1221 sizeof (auxp
->x_sym
.x_fcnary
.x_ary
.x_dimen
));
1223 if (S_GET_STORAGE_CLASS (symp
) == C_EFCN
)
1225 if (coff_last_function
== 0)
1226 as_fatal (_("C_EFCN symbol out of scope"));
1227 SA_SET_SYM_FSIZE (coff_last_function
,
1228 (long) (S_GET_VALUE (symp
)
1229 - S_GET_VALUE (coff_last_function
)));
1230 next_set_end
= coff_last_function
;
1231 coff_last_function
= 0;
1234 if (S_IS_EXTERNAL (symp
))
1235 S_SET_STORAGE_CLASS (symp
, C_EXT
);
1236 else if (SF_GET_LOCAL (symp
))
1239 if (SF_GET_FUNCTION (symp
))
1240 symbol_get_bfdsym (symp
)->flags
|= BSF_FUNCTION
;
1245 /* Double check weak symbols. */
1246 if (S_IS_WEAK (symp
) && S_IS_COMMON (symp
))
1247 as_bad (_("Symbol `%s' can not be both weak and common"),
1250 if (SF_GET_TAG (symp
))
1252 else if (S_GET_STORAGE_CLASS (symp
) == C_EOS
)
1253 next_set_end
= last_tagP
;
1256 /* This is pretty horrible, but we have to set *punt correctly in
1257 order to call SA_SET_SYM_ENDNDX correctly. */
1258 if (! symbol_used_in_reloc_p (symp
)
1259 && ((symbol_get_bfdsym (symp
)->flags
& BSF_SECTION_SYM
) != 0
1260 || (! S_IS_EXTERNAL (symp
)
1261 && ! symbol_get_tc (symp
)->output
1262 && S_GET_STORAGE_CLASS (symp
) != C_FILE
)))
1266 if (set_end
!= (symbolS
*) NULL
1268 && ((symbol_get_bfdsym (symp
)->flags
& BSF_NOT_AT_END
) != 0
1269 || (S_IS_DEFINED (symp
)
1270 && ! S_IS_COMMON (symp
)
1271 && (! S_IS_EXTERNAL (symp
) || SF_GET_FUNCTION (symp
)))))
1273 SA_SET_SYM_ENDNDX (set_end
, symp
);
1277 if (next_set_end
!= NULL
)
1279 if (set_end
!= NULL
)
1280 as_warn ("Warning: internal error: forgetting to set endndx of %s",
1281 S_GET_NAME (set_end
));
1282 set_end
= next_set_end
;
1286 && S_GET_STORAGE_CLASS (symp
) == C_FCN
1287 && strcmp (S_GET_NAME (symp
), ".bf") == 0)
1289 if (coff_last_bf
!= NULL
)
1290 SA_SET_SYM_ENDNDX (coff_last_bf
, symp
);
1291 coff_last_bf
= symp
;
1294 if (coffsymbol (symbol_get_bfdsym (symp
))->lineno
)
1297 struct line_no
*lptr
;
1300 lptr
= (struct line_no
*) coffsymbol (symbol_get_bfdsym (symp
))->lineno
;
1301 for (i
= 0; lptr
; lptr
= lptr
->next
)
1303 lptr
= (struct line_no
*) coffsymbol (symbol_get_bfdsym (symp
))->lineno
;
1305 /* We need i entries for line numbers, plus 1 for the first
1306 entry which BFD will override, plus 1 for the last zero
1307 entry (a marker for BFD). */
1308 l
= (alent
*) xmalloc ((i
+ 2) * sizeof (alent
));
1309 coffsymbol (symbol_get_bfdsym (symp
))->lineno
= l
;
1310 l
[i
+ 1].line_number
= 0;
1311 l
[i
+ 1].u
.sym
= NULL
;
1315 lptr
->l
.u
.offset
+= lptr
->frag
->fr_address
/ OCTETS_PER_BYTE
;
1323 coff_adjust_section_syms (abfd
, sec
, x
)
1324 bfd
*abfd ATTRIBUTE_UNUSED
;
1326 PTR x ATTRIBUTE_UNUSED
;
1329 segment_info_type
*seginfo
= seg_info (sec
);
1330 int nlnno
, nrelocs
= 0;
1332 /* RS/6000 gas creates a .debug section manually in ppc_frob_file in
1333 tc-ppc.c. Do not get confused by it. */
1334 if (seginfo
== NULL
)
1337 if (!strcmp (sec
->name
, ".text"))
1338 nlnno
= coff_n_line_nos
;
1342 /* @@ Hope that none of the fixups expand to more than one reloc
1344 fixS
*fixp
= seginfo
->fix_root
;
1347 if (! fixp
->fx_done
)
1349 fixp
= fixp
->fx_next
;
1352 if (bfd_get_section_size_before_reloc (sec
) == 0
1355 && sec
!= text_section
1356 && sec
!= data_section
1357 && sec
!= bss_section
)
1359 secsym
= section_symbol (sec
);
1360 /* This is an estimate; we'll plug in the real value using
1361 SET_SECTION_RELOCS later */
1362 SA_SET_SCN_NRELOC (secsym
, nrelocs
);
1363 SA_SET_SCN_NLINNO (secsym
, nlnno
);
1367 coff_frob_file_after_relocs ()
1369 bfd_map_over_sections (stdoutput
, coff_adjust_section_syms
, (char*) 0);
1373 * implement the .section pseudo op:
1374 * .section name {, "flags"}
1376 * | +--- optional flags: 'b' for bss
1378 * +-- section name 'l' for lib
1382 * 'd' (apparently m88k for data)
1384 * 'r' for read-only data
1385 * 's' for shared data (PE)
1386 * But if the argument is not a quoted string, treat it as a
1387 * subsegment number.
1391 obj_coff_section (ignore
)
1392 int ignore ATTRIBUTE_UNUSED
;
1394 /* Strip out the section name */
1399 flagword flags
, oldflags
;
1410 section_name
= input_line_pointer
;
1411 c
= get_symbol_end ();
1413 name
= xmalloc (input_line_pointer
- section_name
+ 1);
1414 strcpy (name
, section_name
);
1416 *input_line_pointer
= c
;
1421 flags
= SEC_NO_FLAGS
;
1423 if (*input_line_pointer
== ',')
1425 ++input_line_pointer
;
1427 if (*input_line_pointer
!= '"')
1428 exp
= get_absolute_expression ();
1431 ++input_line_pointer
;
1432 while (*input_line_pointer
!= '"'
1433 && ! is_end_of_line
[(unsigned char) *input_line_pointer
])
1435 switch (*input_line_pointer
)
1437 case 'b': flags
|= SEC_ALLOC
; flags
&=~ SEC_LOAD
; break;
1438 case 'n': flags
&=~ SEC_LOAD
; break;
1439 case 'd': flags
|= SEC_DATA
| SEC_LOAD
; /* fall through */
1440 case 'w': flags
&=~ SEC_READONLY
; break;
1441 case 'x': flags
|= SEC_CODE
| SEC_LOAD
; break;
1442 case 'r': flags
|= SEC_READONLY
; break;
1443 case 's': flags
|= SEC_SHARED
; break;
1445 case 'i': /* STYP_INFO */
1446 case 'l': /* STYP_LIB */
1447 case 'o': /* STYP_OVER */
1448 as_warn (_("unsupported section attribute '%c'"),
1449 *input_line_pointer
);
1453 as_warn(_("unknown section attribute '%c'"),
1454 *input_line_pointer
);
1457 ++input_line_pointer
;
1459 if (*input_line_pointer
== '"')
1460 ++input_line_pointer
;
1464 sec
= subseg_new (name
, (subsegT
) exp
);
1466 oldflags
= bfd_get_section_flags (stdoutput
, sec
);
1467 if (oldflags
== SEC_NO_FLAGS
)
1469 /* Set section flags for a new section just created by subseg_new.
1470 Provide a default if no flags were parsed. */
1471 if (flags
== SEC_NO_FLAGS
)
1472 flags
= TC_COFF_SECTION_DEFAULT_ATTRIBUTES
;
1474 #ifdef COFF_LONG_SECTION_NAMES
1475 /* Add SEC_LINK_ONCE and SEC_LINK_DUPLICATES_DISCARD to .gnu.linkonce
1476 sections so adjust_reloc_syms in write.c will correctly handle
1477 relocs which refer to non-local symbols in these sections. */
1478 if (strncmp (name
, ".gnu.linkonce", sizeof(".gnu.linkonce") - 1) == 0)
1479 flags
|= SEC_LINK_ONCE
| SEC_LINK_DUPLICATES_DISCARD
;
1482 if (! bfd_set_section_flags (stdoutput
, sec
, flags
))
1483 as_warn (_("error setting flags for \"%s\": %s"),
1484 bfd_section_name (stdoutput
, sec
),
1485 bfd_errmsg (bfd_get_error ()));
1487 else if (flags
!= SEC_NO_FLAGS
)
1489 /* This section's attributes have already been set. Warn if the
1490 attributes don't match. */
1491 flagword matchflags
= SEC_ALLOC
| SEC_LOAD
| SEC_READONLY
| SEC_CODE
1492 | SEC_DATA
| SEC_SHARED
;
1493 if ((flags
^ oldflags
) & matchflags
)
1494 as_warn (_("Ignoring changed section attributes for %s"), name
);
1497 demand_empty_rest_of_line ();
1501 coff_adjust_symtab ()
1503 if (symbol_rootP
== NULL
1504 || S_GET_STORAGE_CLASS (symbol_rootP
) != C_FILE
)
1505 c_dot_file_symbol ("fake");
1509 coff_frob_section (sec
)
1515 bfd_vma size
, n_entries
, mask
;
1516 bfd_vma align_power
= (bfd_vma
)sec
->alignment_power
+ OCTETS_PER_BYTE_POWER
;
1518 /* The COFF back end in BFD requires that all section sizes be
1519 rounded up to multiples of the corresponding section alignments,
1520 supposedly because standard COFF has no other way of encoding alignment
1521 for sections. If your COFF flavor has a different way of encoding
1522 section alignment, then skip this step, as TICOFF does. */
1523 size
= bfd_get_section_size_before_reloc (sec
);
1524 mask
= ((bfd_vma
) 1 << align_power
) - 1;
1525 #if !defined(TICOFF)
1531 new_size
= (size
+ mask
) & ~mask
;
1532 bfd_set_section_size (stdoutput
, sec
, new_size
);
1534 /* If the size had to be rounded up, add some padding in
1535 the last non-empty frag. */
1536 fragp
= seg_info (sec
)->frchainP
->frch_root
;
1537 last
= seg_info (sec
)->frchainP
->frch_last
;
1538 while (fragp
->fr_next
!= last
)
1539 fragp
= fragp
->fr_next
;
1540 last
->fr_address
= size
;
1541 fragp
->fr_offset
+= new_size
- size
;
1545 /* If the section size is non-zero, the section symbol needs an aux
1546 entry associated with it, indicating the size. We don't know
1547 all the values yet; coff_frob_symbol will fill them in later. */
1550 || sec
== text_section
1551 || sec
== data_section
1552 || sec
== bss_section
)
1555 symbolS
*secsym
= section_symbol (sec
);
1557 S_SET_STORAGE_CLASS (secsym
, C_STAT
);
1558 S_SET_NUMBER_AUXILIARY (secsym
, 1);
1559 SF_SET_STATICS (secsym
);
1560 SA_SET_SCN_SCNLEN (secsym
, size
);
1563 /* @@ these should be in a "stabs.h" file, or maybe as.h */
1564 #ifndef STAB_SECTION_NAME
1565 #define STAB_SECTION_NAME ".stab"
1567 #ifndef STAB_STRING_SECTION_NAME
1568 #define STAB_STRING_SECTION_NAME ".stabstr"
1570 if (strcmp (STAB_STRING_SECTION_NAME
, sec
->name
))
1574 sec
= subseg_get (STAB_SECTION_NAME
, 0);
1575 /* size is already rounded up, since other section will be listed first */
1576 size
= bfd_get_section_size_before_reloc (strsec
);
1578 n_entries
= bfd_get_section_size_before_reloc (sec
) / 12 - 1;
1580 /* Find first non-empty frag. It should be large enough. */
1581 fragp
= seg_info (sec
)->frchainP
->frch_root
;
1582 while (fragp
&& fragp
->fr_fix
== 0)
1583 fragp
= fragp
->fr_next
;
1584 assert (fragp
!= 0 && fragp
->fr_fix
>= 12);
1586 /* Store the values. */
1587 p
= fragp
->fr_literal
;
1588 bfd_h_put_16 (stdoutput
, n_entries
, (bfd_byte
*) p
+ 6);
1589 bfd_h_put_32 (stdoutput
, size
, (bfd_byte
*) p
+ 8);
1593 obj_coff_init_stab_section (seg
)
1599 unsigned int stroff
;
1601 /* Make space for this first symbol. */
1605 as_where (&file
, (unsigned int *) NULL
);
1606 stabstr_name
= (char *) alloca (strlen (seg
->name
) + 4);
1607 strcpy (stabstr_name
, seg
->name
);
1608 strcat (stabstr_name
, "str");
1609 stroff
= get_stab_string_offset (file
, stabstr_name
);
1611 md_number_to_chars (p
, stroff
, 4);
1620 return ((s
== NULL
) ? "(NULL)" : S_GET_NAME (s
));
1628 for (symbolP
= symbol_rootP
; symbolP
; symbolP
= symbol_next (symbolP
))
1630 printf(_("0x%lx: \"%s\" type = %ld, class = %d, segment = %d\n"),
1631 (unsigned long) symbolP
,
1632 S_GET_NAME(symbolP
),
1633 (long) S_GET_DATA_TYPE(symbolP
),
1634 S_GET_STORAGE_CLASS(symbolP
),
1635 (int) S_GET_SEGMENT(symbolP
));
1641 #else /* not BFD_ASSEMBLER */
1644 /* This is needed because we include internal bfd things. */
1648 #include "libcoff.h"
1651 #include "coff/pe.h"
1654 /* The NOP_OPCODE is for the alignment fill value. Fill with nop so
1655 that we can stick sections together without causing trouble. */
1657 #define NOP_OPCODE 0x00
1660 /* The zeroes if symbol name is longer than 8 chars */
1661 #define S_SET_ZEROES(s,v) ((s)->sy_symbol.ost_entry.n_zeroes = (v))
1663 #define MIN(a,b) ((a) < (b)? (a) : (b))
1665 /* This vector is used to turn a gas internal segment number into a
1666 section number suitable for insertion into a coff symbol table.
1667 This must correspond to seg_info_off_by_4. */
1669 const short seg_N_TYPE
[] =
1670 { /* in: segT out: N_TYPE bits */
1672 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
1673 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
1674 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
1675 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
1676 C_UNDEF_SECTION
, /* SEG_UNKNOWN */
1677 C_UNDEF_SECTION
, /* SEG_GOOF */
1678 C_UNDEF_SECTION
, /* SEG_EXPR */
1679 C_DEBUG_SECTION
, /* SEG_DEBUG */
1680 C_NTV_SECTION
, /* SEG_NTV */
1681 C_PTV_SECTION
, /* SEG_PTV */
1682 C_REGISTER_SECTION
, /* SEG_REGISTER */
1685 int function_lineoff
= -1; /* Offset in line#s where the last function
1686 started (the odd entry for line #0) */
1688 /* structure used to keep the filenames which
1689 are too long around so that we can stick them
1690 into the string table */
1691 struct filename_list
1694 struct filename_list
*next
;
1697 static struct filename_list
*filename_list_head
;
1698 static struct filename_list
*filename_list_tail
;
1700 static symbolS
*last_line_symbol
;
1702 /* Add 4 to the real value to get the index and compensate the
1703 negatives. This vector is used by S_GET_SEGMENT to turn a coff
1704 section number into a segment number
1706 static symbolS
*previous_file_symbol
;
1707 void c_symbol_merge ();
1708 static int line_base
;
1710 symbolS
*c_section_symbol ();
1713 static void fixup_segment
PARAMS ((segment_info_type
*segP
,
1714 segT this_segment_type
));
1717 static void fixup_mdeps
PARAMS ((fragS
*,
1722 static void fill_section
PARAMS ((bfd
* abfd
,
1727 static int c_line_new
PARAMS ((symbolS
* symbol
, long paddr
,
1732 static void w_symbols
PARAMS ((bfd
* abfd
, char *where
,
1733 symbolS
* symbol_rootP
));
1735 static void adjust_stab_section
PARAMS ((bfd
*abfd
, segT seg
));
1737 static void obj_coff_lcomm
PARAMS ((int));
1738 static void obj_coff_text
PARAMS ((int));
1739 static void obj_coff_data
PARAMS ((int));
1740 void obj_coff_section
PARAMS ((int));
1742 /* When not using BFD_ASSEMBLER, we permit up to 40 sections.
1744 This array maps a COFF section number into a gas section number.
1745 Because COFF uses negative section numbers, you must add 4 to the
1746 COFF section number when indexing into this array; this is done via
1747 the SEG_INFO_FROM_SECTION_NUMBER macro. This must correspond to
1750 static const segT seg_info_off_by_4
[] =
1757 SEG_E0
, SEG_E1
, SEG_E2
, SEG_E3
, SEG_E4
,
1758 SEG_E5
, SEG_E6
, SEG_E7
, SEG_E8
, SEG_E9
,
1759 SEG_E10
, SEG_E11
, SEG_E12
, SEG_E13
, SEG_E14
,
1760 SEG_E15
, SEG_E16
, SEG_E17
, SEG_E18
, SEG_E19
,
1761 SEG_E20
, SEG_E21
, SEG_E22
, SEG_E23
, SEG_E24
,
1762 SEG_E25
, SEG_E26
, SEG_E27
, SEG_E28
, SEG_E29
,
1763 SEG_E30
, SEG_E31
, SEG_E32
, SEG_E33
, SEG_E34
,
1764 SEG_E35
, SEG_E36
, SEG_E37
, SEG_E38
, SEG_E39
,
1777 #define SEG_INFO_FROM_SECTION_NUMBER(x) (seg_info_off_by_4[(x)+4])
1779 static relax_addressT
1780 relax_align (address
, alignment
)
1781 relax_addressT address
;
1784 relax_addressT mask
;
1785 relax_addressT new_address
;
1787 mask
= ~((~0) << alignment
);
1788 new_address
= (address
+ mask
) & (~mask
);
1789 return (new_address
- address
);
1797 return SEG_INFO_FROM_SECTION_NUMBER (x
->sy_symbol
.ost_entry
.n_scnum
);
1800 /* calculate the size of the frag chain and fill in the section header
1801 to contain all of it, also fill in the addr of the sections */
1803 size_section (abfd
, idx
)
1804 bfd
*abfd ATTRIBUTE_UNUSED
;
1808 unsigned int size
= 0;
1809 fragS
*frag
= segment_info
[idx
].frchainP
->frch_root
;
1812 size
= frag
->fr_address
;
1813 if (frag
->fr_address
!= size
)
1815 fprintf (stderr
, _("Out of step\n"));
1816 size
= frag
->fr_address
;
1819 switch (frag
->fr_type
)
1821 #ifdef TC_COFF_SIZEMACHDEP
1822 case rs_machine_dependent
:
1823 size
+= TC_COFF_SIZEMACHDEP (frag
);
1827 assert (frag
->fr_symbol
== 0);
1830 size
+= frag
->fr_fix
;
1831 size
+= frag
->fr_offset
* frag
->fr_var
;
1838 size
+= frag
->fr_fix
;
1839 off
= relax_align (size
, frag
->fr_offset
);
1840 if (frag
->fr_subtype
!= 0 && off
> frag
->fr_subtype
)
1846 BAD_CASE (frag
->fr_type
);
1849 frag
= frag
->fr_next
;
1851 segment_info
[idx
].scnhdr
.s_size
= size
;
1857 count_entries_in_chain (idx
)
1860 unsigned int nrelocs
;
1863 /* Count the relocations */
1864 fixup_ptr
= segment_info
[idx
].fix_root
;
1866 while (fixup_ptr
!= (fixS
*) NULL
)
1868 if (fixup_ptr
->fx_done
== 0 && TC_COUNT_RELOC (fixup_ptr
))
1871 if (fixup_ptr
->fx_r_type
== RELOC_CONSTH
)
1880 fixup_ptr
= fixup_ptr
->fx_next
;
1887 static int compare_external_relocs
PARAMS ((const PTR
, const PTR
));
1889 /* AUX's ld expects relocations to be sorted */
1891 compare_external_relocs (x
, y
)
1895 struct external_reloc
*a
= (struct external_reloc
*) x
;
1896 struct external_reloc
*b
= (struct external_reloc
*) y
;
1897 bfd_vma aadr
= bfd_getb32 (a
->r_vaddr
);
1898 bfd_vma badr
= bfd_getb32 (b
->r_vaddr
);
1899 return (aadr
< badr
? -1 : badr
< aadr
? 1 : 0);
1904 /* output all the relocations for a section */
1906 do_relocs_for (abfd
, h
, file_cursor
)
1909 unsigned long *file_cursor
;
1911 unsigned int nrelocs
;
1913 unsigned long reloc_start
= *file_cursor
;
1915 for (idx
= SEG_E0
; idx
< SEG_LAST
; idx
++)
1917 if (segment_info
[idx
].scnhdr
.s_name
[0])
1919 struct external_reloc
*ext_ptr
;
1920 struct external_reloc
*external_reloc_vec
;
1921 unsigned int external_reloc_size
;
1922 unsigned int base
= segment_info
[idx
].scnhdr
.s_paddr
;
1923 fixS
*fix_ptr
= segment_info
[idx
].fix_root
;
1924 nrelocs
= count_entries_in_chain (idx
);
1927 /* Bypass this stuff if no relocs. This also incidentally
1928 avoids a SCO bug, where free(malloc(0)) tends to crash. */
1930 external_reloc_size
= nrelocs
* RELSZ
;
1931 external_reloc_vec
=
1932 (struct external_reloc
*) malloc (external_reloc_size
);
1934 ext_ptr
= external_reloc_vec
;
1936 /* Fill in the internal coff style reloc struct from the
1937 internal fix list. */
1940 struct internal_reloc intr
;
1942 /* Only output some of the relocations */
1943 if (fix_ptr
->fx_done
== 0 && TC_COUNT_RELOC (fix_ptr
))
1945 #ifdef TC_RELOC_MANGLE
1946 TC_RELOC_MANGLE (&segment_info
[idx
], fix_ptr
, &intr
,
1951 symbolS
*symbol_ptr
= fix_ptr
->fx_addsy
;
1953 intr
.r_type
= TC_COFF_FIX2RTYPE (fix_ptr
);
1955 base
+ fix_ptr
->fx_frag
->fr_address
+ fix_ptr
->fx_where
;
1957 #ifdef TC_KEEP_FX_OFFSET
1958 intr
.r_offset
= fix_ptr
->fx_offset
;
1963 while (symbol_ptr
->sy_value
.X_op
== O_symbol
1964 && (! S_IS_DEFINED (symbol_ptr
)
1965 || S_IS_COMMON (symbol_ptr
)))
1969 /* We must avoid looping, as that can occur
1970 with a badly written program. */
1971 n
= symbol_ptr
->sy_value
.X_add_symbol
;
1972 if (n
== symbol_ptr
)
1977 /* Turn the segment of the symbol into an offset. */
1980 resolve_symbol_value (symbol_ptr
, 1);
1981 if (! symbol_ptr
->sy_resolved
)
1986 if (expr_symbol_where (symbol_ptr
, &file
, &line
))
1987 as_bad_where (file
, line
,
1988 _("unresolved relocation"));
1990 as_bad (_("bad relocation: symbol `%s' not in symbol table"),
1991 S_GET_NAME (symbol_ptr
));
1993 dot
= segment_info
[S_GET_SEGMENT (symbol_ptr
)].dot
;
1996 intr
.r_symndx
= dot
->sy_number
;
2000 intr
.r_symndx
= symbol_ptr
->sy_number
;
2010 (void) bfd_coff_swap_reloc_out (abfd
, &intr
, ext_ptr
);
2013 #if defined(TC_A29K)
2015 /* The 29k has a special kludge for the high 16 bit
2016 reloc. Two relocations are emited, R_IHIHALF,
2017 and R_IHCONST. The second one doesn't contain a
2018 symbol, but uses the value for offset. */
2020 if (intr
.r_type
== R_IHIHALF
)
2022 /* now emit the second bit */
2023 intr
.r_type
= R_IHCONST
;
2024 intr
.r_symndx
= fix_ptr
->fx_addnumber
;
2025 (void) bfd_coff_swap_reloc_out (abfd
, &intr
, ext_ptr
);
2031 fix_ptr
= fix_ptr
->fx_next
;
2035 /* Sort the reloc table */
2036 qsort ((PTR
) external_reloc_vec
, nrelocs
,
2037 sizeof (struct external_reloc
), compare_external_relocs
);
2040 /* Write out the reloc table */
2041 bfd_write ((PTR
) external_reloc_vec
, 1, external_reloc_size
,
2043 free (external_reloc_vec
);
2045 /* Fill in section header info. */
2046 segment_info
[idx
].scnhdr
.s_relptr
= *file_cursor
;
2047 *file_cursor
+= external_reloc_size
;
2048 segment_info
[idx
].scnhdr
.s_nreloc
= nrelocs
;
2053 segment_info
[idx
].scnhdr
.s_relptr
= 0;
2057 /* Set relocation_size field in file headers */
2058 H_SET_RELOCATION_SIZE (h
, *file_cursor
- reloc_start
, 0);
2062 /* run through a frag chain and write out the data to go with it, fill
2063 in the scnhdrs with the info on the file postions
2066 fill_section (abfd
, h
, file_cursor
)
2068 object_headers
*h ATTRIBUTE_UNUSED
;
2069 unsigned long *file_cursor
;
2073 unsigned int paddr
= 0;
2075 for (i
= SEG_E0
; i
< SEG_UNKNOWN
; i
++)
2077 unsigned int offset
= 0;
2078 struct internal_scnhdr
*s
= &(segment_info
[i
].scnhdr
);
2084 fragS
*frag
= segment_info
[i
].frchainP
->frch_root
;
2091 buffer
= xmalloc (s
->s_size
);
2092 s
->s_scnptr
= *file_cursor
;
2094 know (s
->s_paddr
== paddr
);
2096 if (strcmp (s
->s_name
, ".text") == 0)
2097 s
->s_flags
|= STYP_TEXT
;
2098 else if (strcmp (s
->s_name
, ".data") == 0)
2099 s
->s_flags
|= STYP_DATA
;
2100 else if (strcmp (s
->s_name
, ".bss") == 0)
2103 s
->s_flags
|= STYP_BSS
;
2105 /* @@ Should make the i386 and a29k coff targets define
2106 COFF_NOLOAD_PROBLEM, and have only one test here. */
2109 #ifndef COFF_NOLOAD_PROBLEM
2110 /* Apparently the SVR3 linker (and exec syscall) and UDI
2111 mondfe progrem are confused by noload sections. */
2112 s
->s_flags
|= STYP_NOLOAD
;
2117 else if (strcmp (s
->s_name
, ".lit") == 0)
2118 s
->s_flags
= STYP_LIT
| STYP_TEXT
;
2119 else if (strcmp (s
->s_name
, ".init") == 0)
2120 s
->s_flags
|= STYP_TEXT
;
2121 else if (strcmp (s
->s_name
, ".fini") == 0)
2122 s
->s_flags
|= STYP_TEXT
;
2123 else if (strncmp (s
->s_name
, ".comment", 8) == 0)
2124 s
->s_flags
|= STYP_INFO
;
2128 unsigned int fill_size
;
2129 switch (frag
->fr_type
)
2131 case rs_machine_dependent
:
2134 memcpy (buffer
+ frag
->fr_address
,
2136 (unsigned int) frag
->fr_fix
);
2137 offset
+= frag
->fr_fix
;
2142 assert (frag
->fr_symbol
== 0);
2149 memcpy (buffer
+ frag
->fr_address
,
2151 (unsigned int) frag
->fr_fix
);
2152 offset
+= frag
->fr_fix
;
2155 fill_size
= frag
->fr_var
;
2156 if (fill_size
&& frag
->fr_offset
> 0)
2159 unsigned int off
= frag
->fr_fix
;
2160 for (count
= frag
->fr_offset
; count
; count
--)
2162 if (fill_size
+ frag
->fr_address
+ off
<= s
->s_size
)
2164 memcpy (buffer
+ frag
->fr_address
+ off
,
2165 frag
->fr_literal
+ frag
->fr_fix
,
2168 offset
+= fill_size
;
2173 case rs_broken_word
:
2178 frag
= frag
->fr_next
;
2183 if (s
->s_scnptr
!= 0)
2185 bfd_write (buffer
, s
->s_size
, 1, abfd
);
2186 *file_cursor
+= s
->s_size
;
2195 /* Coff file generation & utilities */
2198 coff_header_append (abfd
, h
)
2205 #ifdef COFF_LONG_SECTION_NAMES
2206 unsigned long string_size
= 4;
2209 bfd_seek (abfd
, 0, 0);
2211 #ifndef OBJ_COFF_OMIT_OPTIONAL_HEADER
2212 H_SET_MAGIC_NUMBER (h
, COFF_MAGIC
);
2213 H_SET_VERSION_STAMP (h
, 0);
2214 H_SET_ENTRY_POINT (h
, 0);
2215 H_SET_TEXT_START (h
, segment_info
[SEG_E0
].frchainP
->frch_root
->fr_address
);
2216 H_SET_DATA_START (h
, segment_info
[SEG_E1
].frchainP
->frch_root
->fr_address
);
2217 H_SET_SIZEOF_OPTIONAL_HEADER (h
, bfd_coff_swap_aouthdr_out(abfd
, &h
->aouthdr
,
2219 #else /* defined (OBJ_COFF_OMIT_OPTIONAL_HEADER) */
2220 H_SET_SIZEOF_OPTIONAL_HEADER (h
, 0);
2221 #endif /* defined (OBJ_COFF_OMIT_OPTIONAL_HEADER) */
2223 i
= bfd_coff_swap_filehdr_out (abfd
, &h
->filehdr
, buffer
);
2225 bfd_write (buffer
, i
, 1, abfd
);
2226 bfd_write (buffero
, H_GET_SIZEOF_OPTIONAL_HEADER (h
), 1, abfd
);
2228 for (i
= SEG_E0
; i
< SEG_LAST
; i
++)
2230 if (segment_info
[i
].scnhdr
.s_name
[0])
2234 #ifdef COFF_LONG_SECTION_NAMES
2235 /* Support long section names as found in PE. This code
2236 must coordinate with that in write_object_file and
2238 if (strlen (segment_info
[i
].name
) > SCNNMLEN
)
2240 memset (segment_info
[i
].scnhdr
.s_name
, 0, SCNNMLEN
);
2241 sprintf (segment_info
[i
].scnhdr
.s_name
, "/%lu", string_size
);
2242 string_size
+= strlen (segment_info
[i
].name
) + 1;
2246 size
= bfd_coff_swap_scnhdr_out (abfd
,
2247 &(segment_info
[i
].scnhdr
),
2250 as_bad (_("bfd_coff_swap_scnhdr_out failed"));
2251 bfd_write (buffer
, size
, 1, abfd
);
2258 symbol_to_chars (abfd
, where
, symbolP
)
2263 unsigned int numaux
= symbolP
->sy_symbol
.ost_entry
.n_numaux
;
2267 /* Turn any symbols with register attributes into abs symbols */
2268 if (S_GET_SEGMENT (symbolP
) == reg_section
)
2270 S_SET_SEGMENT (symbolP
, absolute_section
);
2272 /* At the same time, relocate all symbols to their output value */
2275 val
= (segment_info
[S_GET_SEGMENT (symbolP
)].scnhdr
.s_paddr
2276 + S_GET_VALUE (symbolP
));
2278 val
= S_GET_VALUE (symbolP
);
2281 S_SET_VALUE (symbolP
, val
);
2283 symbolP
->sy_symbol
.ost_entry
.n_value
= val
;
2285 where
+= bfd_coff_swap_sym_out (abfd
, &symbolP
->sy_symbol
.ost_entry
,
2288 for (i
= 0; i
< numaux
; i
++)
2290 where
+= bfd_coff_swap_aux_out (abfd
,
2291 &symbolP
->sy_symbol
.ost_auxent
[i
],
2292 S_GET_DATA_TYPE (symbolP
),
2293 S_GET_STORAGE_CLASS (symbolP
),
2301 coff_obj_symbol_new_hook (symbolP
)
2304 char underscore
= 0; /* Symbol has leading _ */
2306 /* Effective symbol */
2307 /* Store the pointer in the offset. */
2308 S_SET_ZEROES (symbolP
, 0L);
2309 S_SET_DATA_TYPE (symbolP
, T_NULL
);
2310 S_SET_STORAGE_CLASS (symbolP
, 0);
2311 S_SET_NUMBER_AUXILIARY (symbolP
, 0);
2312 /* Additional information */
2313 symbolP
->sy_symbol
.ost_flags
= 0;
2314 /* Auxiliary entries */
2315 memset ((char *) &symbolP
->sy_symbol
.ost_auxent
[0], 0, AUXESZ
);
2317 if (S_IS_STRING (symbolP
))
2318 SF_SET_STRING (symbolP
);
2319 if (!underscore
&& S_IS_LOCAL (symbolP
))
2320 SF_SET_LOCAL (symbolP
);
2324 * Handle .ln directives.
2328 obj_coff_ln (appline
)
2333 if (! appline
&& def_symbol_in_progress
!= NULL
)
2335 as_warn (_(".ln pseudo-op inside .def/.endef: ignored."));
2336 demand_empty_rest_of_line ();
2338 } /* wrong context */
2340 l
= get_absolute_expression ();
2341 c_line_new (0, frag_now_fix (), l
, frag_now
);
2344 new_logical_line ((char *) NULL
, l
- 1);
2354 listing_source_line ((unsigned int) l
);
2359 demand_empty_rest_of_line ();
2365 * Handle .def directives.
2367 * One might ask : why can't we symbol_new if the symbol does not
2368 * already exist and fill it with debug information. Because of
2369 * the C_EFCN special symbol. It would clobber the value of the
2370 * function symbol before we have a chance to notice that it is
2371 * a C_EFCN. And a second reason is that the code is more clear this
2372 * way. (at least I think it is :-).
2376 #define SKIP_SEMI_COLON() while (*input_line_pointer++ != ';')
2377 #define SKIP_WHITESPACES() while (*input_line_pointer == ' ' || \
2378 *input_line_pointer == '\t') \
2379 input_line_pointer++;
2383 int what ATTRIBUTE_UNUSED
;
2385 char name_end
; /* Char after the end of name */
2386 char *symbol_name
; /* Name of the debug symbol */
2387 char *symbol_name_copy
; /* Temporary copy of the name */
2388 unsigned int symbol_name_length
;
2390 if (def_symbol_in_progress
!= NULL
)
2392 as_warn (_(".def pseudo-op used inside of .def/.endef: ignored."));
2393 demand_empty_rest_of_line ();
2395 } /* if not inside .def/.endef */
2397 SKIP_WHITESPACES ();
2399 def_symbol_in_progress
= (symbolS
*) obstack_alloc (¬es
, sizeof (*def_symbol_in_progress
));
2400 memset (def_symbol_in_progress
, 0, sizeof (*def_symbol_in_progress
));
2402 symbol_name
= input_line_pointer
;
2403 name_end
= get_symbol_end ();
2404 symbol_name_length
= strlen (symbol_name
);
2405 symbol_name_copy
= xmalloc (symbol_name_length
+ 1);
2406 strcpy (symbol_name_copy
, symbol_name
);
2407 #ifdef tc_canonicalize_symbol_name
2408 symbol_name_copy
= tc_canonicalize_symbol_name (symbol_name_copy
);
2411 /* Initialize the new symbol */
2412 #ifdef STRIP_UNDERSCORE
2413 S_SET_NAME (def_symbol_in_progress
, (*symbol_name_copy
== '_'
2414 ? symbol_name_copy
+ 1
2415 : symbol_name_copy
));
2416 #else /* STRIP_UNDERSCORE */
2417 S_SET_NAME (def_symbol_in_progress
, symbol_name_copy
);
2418 #endif /* STRIP_UNDERSCORE */
2419 /* free(symbol_name_copy); */
2420 def_symbol_in_progress
->sy_name_offset
= (unsigned long) ~0;
2421 def_symbol_in_progress
->sy_number
= ~0;
2422 def_symbol_in_progress
->sy_frag
= &zero_address_frag
;
2423 S_SET_VALUE (def_symbol_in_progress
, 0);
2425 if (S_IS_STRING (def_symbol_in_progress
))
2426 SF_SET_STRING (def_symbol_in_progress
);
2428 *input_line_pointer
= name_end
;
2430 demand_empty_rest_of_line ();
2433 unsigned int dim_index
;
2437 obj_coff_endef (ignore
)
2438 int ignore ATTRIBUTE_UNUSED
;
2440 symbolS
*symbolP
= 0;
2441 /* DIM BUG FIX sac@cygnus.com */
2443 if (def_symbol_in_progress
== NULL
)
2445 as_warn (_(".endef pseudo-op used outside of .def/.endef: ignored."));
2446 demand_empty_rest_of_line ();
2448 } /* if not inside .def/.endef */
2450 /* Set the section number according to storage class. */
2451 switch (S_GET_STORAGE_CLASS (def_symbol_in_progress
))
2456 SF_SET_TAG (def_symbol_in_progress
);
2457 /* intentional fallthrough */
2460 SF_SET_DEBUG (def_symbol_in_progress
);
2461 S_SET_SEGMENT (def_symbol_in_progress
, SEG_DEBUG
);
2465 SF_SET_LOCAL (def_symbol_in_progress
); /* Do not emit this symbol. */
2466 /* intentional fallthrough */
2468 SF_SET_PROCESS (def_symbol_in_progress
); /* Will need processing before writing */
2469 /* intentional fallthrough */
2471 S_SET_SEGMENT (def_symbol_in_progress
, SEG_E0
);
2473 if (strcmp (S_GET_NAME (def_symbol_in_progress
), ".bf") == 0)
2475 if (function_lineoff
< 0)
2477 fprintf (stderr
, _("`.bf' symbol without preceding function\n"));
2478 } /* missing function symbol */
2479 SA_GET_SYM_LNNOPTR (last_line_symbol
) = function_lineoff
;
2481 SF_SET_PROCESS (last_line_symbol
);
2482 SF_SET_ADJ_LNNOPTR (last_line_symbol
);
2483 SF_SET_PROCESS (def_symbol_in_progress
);
2484 function_lineoff
= -1;
2486 /* Value is always set to . */
2487 def_symbol_in_progress
->sy_frag
= frag_now
;
2488 S_SET_VALUE (def_symbol_in_progress
, (valueT
) frag_now_fix ());
2493 #endif /* C_AUTOARG */
2503 SF_SET_DEBUG (def_symbol_in_progress
);
2504 S_SET_SEGMENT (def_symbol_in_progress
, absolute_section
);
2514 /* Valid but set somewhere else (s_comm, s_lcomm, colon) */
2520 as_warn (_("unexpected storage class %d"), S_GET_STORAGE_CLASS (def_symbol_in_progress
));
2522 } /* switch on storage class */
2524 /* Now that we have built a debug symbol, try to find if we should
2525 merge with an existing symbol or not. If a symbol is C_EFCN or
2526 absolute_section or untagged SEG_DEBUG it never merges. We also
2527 don't merge labels, which are in a different namespace, nor
2528 symbols which have not yet been defined since they are typically
2529 unique, nor do we merge tags with non-tags. */
2531 /* Two cases for functions. Either debug followed by definition or
2532 definition followed by debug. For definition first, we will
2533 merge the debug symbol into the definition. For debug first, the
2534 lineno entry MUST point to the definition function or else it
2535 will point off into space when crawl_symbols() merges the debug
2536 symbol into the real symbol. Therefor, let's presume the debug
2537 symbol is a real function reference. */
2539 /* FIXME-SOON If for some reason the definition label/symbol is
2540 never seen, this will probably leave an undefined symbol at link
2543 if (S_GET_STORAGE_CLASS (def_symbol_in_progress
) == C_EFCN
2544 || S_GET_STORAGE_CLASS (def_symbol_in_progress
) == C_LABEL
2545 || (S_GET_SEGMENT (def_symbol_in_progress
) == SEG_DEBUG
2546 && !SF_GET_TAG (def_symbol_in_progress
))
2547 || S_GET_SEGMENT (def_symbol_in_progress
) == absolute_section
2548 || def_symbol_in_progress
->sy_value
.X_op
!= O_constant
2549 || (symbolP
= symbol_find_base (S_GET_NAME (def_symbol_in_progress
), DO_NOT_STRIP
)) == NULL
2550 || (SF_GET_TAG (def_symbol_in_progress
) != SF_GET_TAG (symbolP
)))
2552 symbol_append (def_symbol_in_progress
, symbol_lastP
, &symbol_rootP
,
2557 /* This symbol already exists, merge the newly created symbol
2558 into the old one. This is not mandatory. The linker can
2559 handle duplicate symbols correctly. But I guess that it save
2560 a *lot* of space if the assembly file defines a lot of
2563 /* The debug entry (def_symbol_in_progress) is merged into the
2564 previous definition. */
2566 c_symbol_merge (def_symbol_in_progress
, symbolP
);
2567 /* FIXME-SOON Should *def_symbol_in_progress be free'd? xoxorich. */
2568 def_symbol_in_progress
= symbolP
;
2570 if (SF_GET_FUNCTION (def_symbol_in_progress
)
2571 || SF_GET_TAG (def_symbol_in_progress
)
2572 || S_GET_STORAGE_CLASS (def_symbol_in_progress
) == C_STAT
)
2574 /* For functions, and tags, and static symbols, the symbol
2575 *must* be where the debug symbol appears. Move the
2576 existing symbol to the current place. */
2577 /* If it already is at the end of the symbol list, do nothing */
2578 if (def_symbol_in_progress
!= symbol_lastP
)
2580 symbol_remove (def_symbol_in_progress
, &symbol_rootP
,
2582 symbol_append (def_symbol_in_progress
, symbol_lastP
,
2583 &symbol_rootP
, &symbol_lastP
);
2584 } /* if not already in place */
2586 } /* normal or mergable */
2588 if (SF_GET_TAG (def_symbol_in_progress
))
2592 oldtag
= symbol_find_base (S_GET_NAME (def_symbol_in_progress
),
2594 if (oldtag
== NULL
|| ! SF_GET_TAG (oldtag
))
2595 tag_insert (S_GET_NAME (def_symbol_in_progress
),
2596 def_symbol_in_progress
);
2599 if (SF_GET_FUNCTION (def_symbol_in_progress
))
2601 know (sizeof (def_symbol_in_progress
) <= sizeof (long));
2603 = c_line_new (def_symbol_in_progress
, 0, 0, &zero_address_frag
);
2605 SF_SET_PROCESS (def_symbol_in_progress
);
2607 if (symbolP
== NULL
)
2609 /* That is, if this is the first time we've seen the
2611 symbol_table_insert (def_symbol_in_progress
);
2612 } /* definition follows debug */
2613 } /* Create the line number entry pointing to the function being defined */
2615 def_symbol_in_progress
= NULL
;
2616 demand_empty_rest_of_line ();
2620 obj_coff_dim (ignore
)
2621 int ignore ATTRIBUTE_UNUSED
;
2625 if (def_symbol_in_progress
== NULL
)
2627 as_warn (_(".dim pseudo-op used outside of .def/.endef: ignored."));
2628 demand_empty_rest_of_line ();
2630 } /* if not inside .def/.endef */
2632 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
2634 for (dim_index
= 0; dim_index
< DIMNUM
; dim_index
++)
2636 SKIP_WHITESPACES ();
2637 SA_SET_SYM_DIMEN (def_symbol_in_progress
, dim_index
,
2638 get_absolute_expression ());
2640 switch (*input_line_pointer
)
2643 input_line_pointer
++;
2647 as_warn (_("badly formed .dim directive ignored"));
2648 /* intentional fallthrough */
2656 demand_empty_rest_of_line ();
2660 obj_coff_line (ignore
)
2661 int ignore ATTRIBUTE_UNUSED
;
2666 if (def_symbol_in_progress
== NULL
)
2672 name
= S_GET_NAME (def_symbol_in_progress
);
2673 this_base
= get_absolute_expression ();
2675 /* Only .bf symbols indicate the use of a new base line number; the
2676 line numbers associated with .ef, .bb, .eb are relative to the
2677 start of the containing function. */
2678 if (!strcmp (".bf", name
))
2680 #if 0 /* XXX Can we ever have line numbers going backwards? */
2681 if (this_base
> line_base
)
2684 line_base
= this_base
;
2692 listing_source_line ((unsigned int) line_base
);
2698 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
2699 SA_SET_SYM_LNNO (def_symbol_in_progress
, this_base
);
2701 demand_empty_rest_of_line ();
2705 obj_coff_size (ignore
)
2706 int ignore ATTRIBUTE_UNUSED
;
2708 if (def_symbol_in_progress
== NULL
)
2710 as_warn (_(".size pseudo-op used outside of .def/.endef ignored."));
2711 demand_empty_rest_of_line ();
2713 } /* if not inside .def/.endef */
2715 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
2716 SA_SET_SYM_SIZE (def_symbol_in_progress
, get_absolute_expression ());
2717 demand_empty_rest_of_line ();
2721 obj_coff_scl (ignore
)
2722 int ignore ATTRIBUTE_UNUSED
;
2724 if (def_symbol_in_progress
== NULL
)
2726 as_warn (_(".scl pseudo-op used outside of .def/.endef ignored."));
2727 demand_empty_rest_of_line ();
2729 } /* if not inside .def/.endef */
2731 S_SET_STORAGE_CLASS (def_symbol_in_progress
, get_absolute_expression ());
2732 demand_empty_rest_of_line ();
2736 obj_coff_tag (ignore
)
2737 int ignore ATTRIBUTE_UNUSED
;
2742 if (def_symbol_in_progress
== NULL
)
2744 as_warn (_(".tag pseudo-op used outside of .def/.endef ignored."));
2745 demand_empty_rest_of_line ();
2749 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
2750 symbol_name
= input_line_pointer
;
2751 name_end
= get_symbol_end ();
2752 #ifdef tc_canonicalize_symbol_name
2753 symbol_name
= tc_canonicalize_symbol_name (symbol_name
);
2756 /* Assume that the symbol referred to by .tag is always defined.
2757 This was a bad assumption. I've added find_or_make. xoxorich. */
2758 SA_SET_SYM_TAGNDX (def_symbol_in_progress
,
2759 (long) tag_find_or_make (symbol_name
));
2760 if (SA_GET_SYM_TAGNDX (def_symbol_in_progress
) == 0L)
2762 as_warn (_("tag not found for .tag %s"), symbol_name
);
2765 SF_SET_TAGGED (def_symbol_in_progress
);
2766 *input_line_pointer
= name_end
;
2768 demand_empty_rest_of_line ();
2772 obj_coff_type (ignore
)
2773 int ignore ATTRIBUTE_UNUSED
;
2775 if (def_symbol_in_progress
== NULL
)
2777 as_warn (_(".type pseudo-op used outside of .def/.endef ignored."));
2778 demand_empty_rest_of_line ();
2780 } /* if not inside .def/.endef */
2782 S_SET_DATA_TYPE (def_symbol_in_progress
, get_absolute_expression ());
2784 if (ISFCN (S_GET_DATA_TYPE (def_symbol_in_progress
)) &&
2785 S_GET_STORAGE_CLASS (def_symbol_in_progress
) != C_TPDEF
)
2787 SF_SET_FUNCTION (def_symbol_in_progress
);
2788 } /* is a function */
2790 demand_empty_rest_of_line ();
2794 obj_coff_val (ignore
)
2795 int ignore ATTRIBUTE_UNUSED
;
2797 if (def_symbol_in_progress
== NULL
)
2799 as_warn (_(".val pseudo-op used outside of .def/.endef ignored."));
2800 demand_empty_rest_of_line ();
2802 } /* if not inside .def/.endef */
2804 if (is_name_beginner (*input_line_pointer
))
2806 char *symbol_name
= input_line_pointer
;
2807 char name_end
= get_symbol_end ();
2809 #ifdef tc_canonicalize_symbol_name
2810 symbol_name
= tc_canonicalize_symbol_name (symbol_name
);
2813 if (!strcmp (symbol_name
, "."))
2815 def_symbol_in_progress
->sy_frag
= frag_now
;
2816 S_SET_VALUE (def_symbol_in_progress
, (valueT
) frag_now_fix ());
2817 /* If the .val is != from the .def (e.g. statics) */
2819 else if (strcmp (S_GET_NAME (def_symbol_in_progress
), symbol_name
))
2821 def_symbol_in_progress
->sy_value
.X_op
= O_symbol
;
2822 def_symbol_in_progress
->sy_value
.X_add_symbol
=
2823 symbol_find_or_make (symbol_name
);
2824 def_symbol_in_progress
->sy_value
.X_op_symbol
= NULL
;
2825 def_symbol_in_progress
->sy_value
.X_add_number
= 0;
2827 /* If the segment is undefined when the forward reference is
2828 resolved, then copy the segment id from the forward
2830 SF_SET_GET_SEGMENT (def_symbol_in_progress
);
2832 /* FIXME: gcc can generate address expressions here in
2833 unusual cases (search for "obscure" in sdbout.c). We
2834 just ignore the offset here, thus generating incorrect
2835 debugging information. We ignore the rest of the line
2838 /* Otherwise, it is the name of a non debug symbol and
2839 its value will be calculated later. */
2840 *input_line_pointer
= name_end
;
2842 /* FIXME: this is to avoid an error message in the
2843 FIXME case mentioned just above. */
2844 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
2845 ++input_line_pointer
;
2849 S_SET_VALUE (def_symbol_in_progress
,
2850 (valueT
) get_absolute_expression ());
2851 } /* if symbol based */
2853 demand_empty_rest_of_line ();
2858 /* Handle the .linkonce pseudo-op. This is parsed by s_linkonce in
2859 read.c, which then calls this object file format specific routine. */
2862 obj_coff_pe_handle_link_once (type
)
2863 enum linkonce_type type
;
2865 seg_info (now_seg
)->scnhdr
.s_flags
|= IMAGE_SCN_LNK_COMDAT
;
2867 /* We store the type in the seg_info structure, and use it to set up
2868 the auxiliary entry for the section symbol in c_section_symbol. */
2869 seg_info (now_seg
)->linkonce
= type
;
2875 coff_obj_read_begin_hook ()
2877 /* These had better be the same. Usually 18 bytes. */
2879 know (sizeof (SYMENT
) == sizeof (AUXENT
));
2880 know (SYMESZ
== AUXESZ
);
2885 /* This function runs through the symbol table and puts all the
2886 externals onto another chain */
2888 /* The chain of globals. */
2889 symbolS
*symbol_globalP
;
2890 symbolS
*symbol_global_lastP
;
2892 /* The chain of externals */
2893 symbolS
*symbol_externP
;
2894 symbolS
*symbol_extern_lastP
;
2897 symbolS
*last_functionP
;
2898 static symbolS
*last_bfP
;
2905 unsigned int symbol_number
= 0;
2906 unsigned int last_file_symno
= 0;
2908 struct filename_list
*filename_list_scan
= filename_list_head
;
2910 for (symbolP
= symbol_rootP
;
2912 symbolP
= symbolP
? symbol_next (symbolP
) : symbol_rootP
)
2914 if (symbolP
->sy_mri_common
)
2916 if (S_GET_STORAGE_CLASS (symbolP
) == C_EXT
2918 || S_GET_STORAGE_CLASS (symbolP
) == C_NT_WEAK
2920 || S_GET_STORAGE_CLASS (symbolP
) == C_WEAKEXT
)
2921 as_bad (_("%s: global symbols not supported in common sections"),
2922 S_GET_NAME (symbolP
));
2923 symbol_remove (symbolP
, &symbol_rootP
, &symbol_lastP
);
2927 if (!SF_GET_DEBUG (symbolP
))
2929 /* Debug symbols do not need all this rubbish */
2930 symbolS
*real_symbolP
;
2932 /* L* and C_EFCN symbols never merge. */
2933 if (!SF_GET_LOCAL (symbolP
)
2934 && !SF_GET_STATICS (symbolP
)
2935 && S_GET_STORAGE_CLASS (symbolP
) != C_LABEL
2936 && symbolP
->sy_value
.X_op
== O_constant
2937 && (real_symbolP
= symbol_find_base (S_GET_NAME (symbolP
), DO_NOT_STRIP
))
2938 && real_symbolP
!= symbolP
)
2940 /* FIXME-SOON: where do dups come from?
2941 Maybe tag references before definitions? xoxorich. */
2942 /* Move the debug data from the debug symbol to the
2943 real symbol. Do NOT do the oposite (i.e. move from
2944 real symbol to debug symbol and remove real symbol from the
2945 list.) Because some pointers refer to the real symbol
2946 whereas no pointers refer to the debug symbol. */
2947 c_symbol_merge (symbolP
, real_symbolP
);
2948 /* Replace the current symbol by the real one */
2949 /* The symbols will never be the last or the first
2950 because : 1st symbol is .file and 3 last symbols are
2951 .text, .data, .bss */
2952 symbol_remove (real_symbolP
, &symbol_rootP
, &symbol_lastP
);
2953 symbol_insert (real_symbolP
, symbolP
, &symbol_rootP
, &symbol_lastP
);
2954 symbol_remove (symbolP
, &symbol_rootP
, &symbol_lastP
);
2955 symbolP
= real_symbolP
;
2956 } /* if not local but dup'd */
2958 if (flag_readonly_data_in_text
&& (S_GET_SEGMENT (symbolP
) == SEG_E1
))
2960 S_SET_SEGMENT (symbolP
, SEG_E0
);
2961 } /* push data into text */
2963 resolve_symbol_value (symbolP
, 1);
2965 if (S_GET_STORAGE_CLASS (symbolP
) == C_NULL
)
2967 if (!S_IS_DEFINED (symbolP
) && !SF_GET_LOCAL (symbolP
))
2969 S_SET_EXTERNAL (symbolP
);
2971 else if (S_GET_SEGMENT (symbolP
) == SEG_E0
)
2973 S_SET_STORAGE_CLASS (symbolP
, C_LABEL
);
2977 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
2981 /* Mainly to speed up if not -g */
2982 if (SF_GET_PROCESS (symbolP
))
2984 /* Handle the nested blocks auxiliary info. */
2985 if (S_GET_STORAGE_CLASS (symbolP
) == C_BLOCK
)
2987 if (!strcmp (S_GET_NAME (symbolP
), ".bb"))
2988 stack_push (block_stack
, (char *) &symbolP
);
2991 register symbolS
*begin_symbolP
;
2992 begin_symbolP
= *(symbolS
**) stack_pop (block_stack
);
2993 if (begin_symbolP
== (symbolS
*) 0)
2994 as_warn (_("mismatched .eb"));
2996 SA_SET_SYM_ENDNDX (begin_symbolP
, symbol_number
+ 2);
2999 /* If we are able to identify the type of a function, and we
3000 are out of a function (last_functionP == 0) then, the
3001 function symbol will be associated with an auxiliary
3003 if (last_functionP
== (symbolS
*) 0 &&
3004 SF_GET_FUNCTION (symbolP
))
3006 last_functionP
= symbolP
;
3008 if (S_GET_NUMBER_AUXILIARY (symbolP
) < 1)
3010 S_SET_NUMBER_AUXILIARY (symbolP
, 1);
3011 } /* make it at least 1 */
3013 /* Clobber possible stale .dim information. */
3015 /* Iffed out by steve - this fries the lnnoptr info too */
3016 bzero (symbolP
->sy_symbol
.ost_auxent
[0].x_sym
.x_fcnary
.x_ary
.x_dimen
,
3017 sizeof (symbolP
->sy_symbol
.ost_auxent
[0].x_sym
.x_fcnary
.x_ary
.x_dimen
));
3020 if (S_GET_STORAGE_CLASS (symbolP
) == C_FCN
)
3022 if (strcmp (S_GET_NAME (symbolP
), ".bf") == 0)
3024 if (last_bfP
!= NULL
)
3025 SA_SET_SYM_ENDNDX (last_bfP
, symbol_number
);
3029 else if (S_GET_STORAGE_CLASS (symbolP
) == C_EFCN
)
3031 /* I don't even know if this is needed for sdb. But
3032 the standard assembler generates it, so... */
3033 if (last_functionP
== (symbolS
*) 0)
3034 as_fatal (_("C_EFCN symbol out of scope"));
3035 SA_SET_SYM_FSIZE (last_functionP
,
3036 (long) (S_GET_VALUE (symbolP
) -
3037 S_GET_VALUE (last_functionP
)));
3038 SA_SET_SYM_ENDNDX (last_functionP
, symbol_number
);
3039 last_functionP
= (symbolS
*) 0;
3043 else if (SF_GET_TAG (symbolP
))
3045 /* First descriptor of a structure must point to
3046 the first slot after the structure description. */
3047 last_tagP
= symbolP
;
3050 else if (S_GET_STORAGE_CLASS (symbolP
) == C_EOS
)
3052 /* +2 take in account the current symbol */
3053 SA_SET_SYM_ENDNDX (last_tagP
, symbol_number
+ 2);
3055 else if (S_GET_STORAGE_CLASS (symbolP
) == C_FILE
)
3057 /* If the filename was too long to fit in the
3058 auxent, put it in the string table */
3059 if (SA_GET_FILE_FNAME_ZEROS (symbolP
) == 0
3060 && SA_GET_FILE_FNAME_OFFSET (symbolP
) != 0)
3062 SA_SET_FILE_FNAME_OFFSET (symbolP
, string_byte_count
);
3063 string_byte_count
+= strlen (filename_list_scan
->filename
) + 1;
3064 filename_list_scan
= filename_list_scan
->next
;
3066 if (S_GET_VALUE (symbolP
))
3068 S_SET_VALUE (symbolP
, last_file_symno
);
3069 last_file_symno
= symbol_number
;
3070 } /* no one points at the first .file symbol */
3071 } /* if debug or tag or eos or file */
3073 #ifdef tc_frob_coff_symbol
3074 tc_frob_coff_symbol (symbolP
);
3077 /* We must put the external symbols apart. The loader
3078 does not bomb if we do not. But the references in
3079 the endndx field for a .bb symbol are not corrected
3080 if an external symbol is removed between .bb and .be.
3081 I.e in the following case :
3082 [20] .bb endndx = 22
3085 ld will move the symbol 21 to the end of the list but
3086 endndx will still be 22 instead of 21. */
3089 if (SF_GET_LOCAL (symbolP
))
3091 /* remove C_EFCN and LOCAL (L...) symbols */
3092 /* next pointer remains valid */
3093 symbol_remove (symbolP
, &symbol_rootP
, &symbol_lastP
);
3096 else if (symbolP
->sy_value
.X_op
== O_symbol
3097 && (! S_IS_DEFINED (symbolP
) || S_IS_COMMON (symbolP
)))
3099 /* Skip symbols which were equated to undefined or common
3101 symbol_remove (symbolP
, &symbol_rootP
, &symbol_lastP
);
3103 else if (!S_IS_DEFINED (symbolP
)
3104 && !S_IS_DEBUG (symbolP
)
3105 && !SF_GET_STATICS (symbolP
)
3106 && (S_GET_STORAGE_CLASS (symbolP
) == C_EXT
3108 || S_GET_STORAGE_CLASS (symbolP
) == C_NT_WEAK
3110 || S_GET_STORAGE_CLASS (symbolP
) == C_WEAKEXT
))
3112 /* if external, Remove from the list */
3113 symbolS
*hold
= symbol_previous (symbolP
);
3115 symbol_remove (symbolP
, &symbol_rootP
, &symbol_lastP
);
3116 symbol_clear_list_pointers (symbolP
);
3117 symbol_append (symbolP
, symbol_extern_lastP
, &symbol_externP
, &symbol_extern_lastP
);
3120 else if (! S_IS_DEBUG (symbolP
)
3121 && ! SF_GET_STATICS (symbolP
)
3122 && ! SF_GET_FUNCTION (symbolP
)
3123 && (S_GET_STORAGE_CLASS (symbolP
) == C_EXT
3125 || S_GET_STORAGE_CLASS (symbolP
) == C_NT_WEAK
3127 || S_GET_STORAGE_CLASS (symbolP
) == C_NT_WEAK
))
3129 symbolS
*hold
= symbol_previous (symbolP
);
3131 /* The O'Reilly COFF book says that defined global symbols
3132 come at the end of the symbol table, just before
3133 undefined global symbols. */
3135 symbol_remove (symbolP
, &symbol_rootP
, &symbol_lastP
);
3136 symbol_clear_list_pointers (symbolP
);
3137 symbol_append (symbolP
, symbol_global_lastP
, &symbol_globalP
,
3138 &symbol_global_lastP
);
3143 if (SF_GET_STRING (symbolP
))
3145 symbolP
->sy_name_offset
= string_byte_count
;
3146 string_byte_count
+= strlen (S_GET_NAME (symbolP
)) + 1;
3150 symbolP
->sy_name_offset
= 0;
3151 } /* fix "long" names */
3153 symbolP
->sy_number
= symbol_number
;
3154 symbol_number
+= 1 + S_GET_NUMBER_AUXILIARY (symbolP
);
3155 } /* if local symbol */
3156 } /* traverse the symbol list */
3157 return symbol_number
;
3163 glue_symbols (head
, tail
)
3167 unsigned int symbol_number
= 0;
3169 while (*head
!= NULL
)
3171 symbolS
*tmp
= *head
;
3174 symbol_remove (tmp
, head
, tail
);
3175 symbol_append (tmp
, symbol_lastP
, &symbol_rootP
, &symbol_lastP
);
3178 if (SF_GET_STRING (tmp
))
3180 tmp
->sy_name_offset
= string_byte_count
;
3181 string_byte_count
+= strlen (S_GET_NAME (tmp
)) + 1;
3185 tmp
->sy_name_offset
= 0;
3186 } /* fix "long" names */
3188 tmp
->sy_number
= symbol_number
;
3189 symbol_number
+= 1 + S_GET_NUMBER_AUXILIARY (tmp
);
3190 } /* append the entire extern chain */
3192 return symbol_number
;
3198 unsigned int symbol_number
= 0;
3201 for (symbolP
= symbol_rootP
; symbolP
; symbolP
= symbol_next (symbolP
))
3203 symbolP
->sy_number
= symbol_number
;
3205 if (SF_GET_TAGGED (symbolP
))
3209 ((symbolS
*) SA_GET_SYM_TAGNDX (symbolP
))->sy_number
);
3212 symbol_number
+= 1 + S_GET_NUMBER_AUXILIARY (symbolP
);
3215 return symbol_number
;
3219 crawl_symbols (h
, abfd
)
3221 bfd
*abfd ATTRIBUTE_UNUSED
;
3225 /* Initialize the stack used to keep track of the matching .bb .be */
3227 block_stack
= stack_init (512, sizeof (symbolS
*));
3229 /* The symbol list should be ordered according to the following sequence
3232 * . debug entries for functions
3233 * . fake symbols for the sections, including .text .data and .bss
3235 * . undefined symbols
3236 * But this is not mandatory. The only important point is to put the
3237 * undefined symbols at the end of the list.
3240 /* Is there a .file symbol ? If not insert one at the beginning. */
3241 if (symbol_rootP
== NULL
3242 || S_GET_STORAGE_CLASS (symbol_rootP
) != C_FILE
)
3244 c_dot_file_symbol ("fake");
3248 * Build up static symbols for the sections, they are filled in later
3252 for (i
= SEG_E0
; i
< SEG_LAST
; i
++)
3253 if (segment_info
[i
].scnhdr
.s_name
[0])
3254 segment_info
[i
].dot
= c_section_symbol (segment_info
[i
].name
,
3257 /* Take all the externals out and put them into another chain */
3258 H_SET_SYMBOL_TABLE_SIZE (h
, yank_symbols ());
3259 /* Take the externals and glue them onto the end.*/
3260 H_SET_SYMBOL_TABLE_SIZE (h
,
3261 (H_GET_SYMBOL_COUNT (h
)
3262 + glue_symbols (&symbol_globalP
,
3263 &symbol_global_lastP
)
3264 + glue_symbols (&symbol_externP
,
3265 &symbol_extern_lastP
)));
3267 H_SET_SYMBOL_TABLE_SIZE (h
, tie_tags ());
3268 know (symbol_globalP
== NULL
);
3269 know (symbol_global_lastP
== NULL
);
3270 know (symbol_externP
== NULL
);
3271 know (symbol_extern_lastP
== NULL
);
3275 * Find strings by crawling along symbol table chain.
3283 struct filename_list
*filename_list_scan
= filename_list_head
;
3285 /* Gotta do md_ byte-ordering stuff for string_byte_count first - KWK */
3286 md_number_to_chars (where
, (valueT
) string_byte_count
, 4);
3289 #ifdef COFF_LONG_SECTION_NAMES
3290 /* Support long section names as found in PE. This code must
3291 coordinate with that in coff_header_append and write_object_file. */
3295 for (i
= SEG_E0
; i
< SEG_LAST
; i
++)
3297 if (segment_info
[i
].scnhdr
.s_name
[0]
3298 && strlen (segment_info
[i
].name
) > SCNNMLEN
)
3302 size
= strlen (segment_info
[i
].name
) + 1;
3303 memcpy (where
, segment_info
[i
].name
, size
);
3308 #endif /* COFF_LONG_SECTION_NAMES */
3310 for (symbolP
= symbol_rootP
;
3312 symbolP
= symbol_next (symbolP
))
3316 if (SF_GET_STRING (symbolP
))
3318 size
= strlen (S_GET_NAME (symbolP
)) + 1;
3319 memcpy (where
, S_GET_NAME (symbolP
), size
);
3322 if (S_GET_STORAGE_CLASS (symbolP
) == C_FILE
3323 && SA_GET_FILE_FNAME_ZEROS (symbolP
) == 0
3324 && SA_GET_FILE_FNAME_OFFSET (symbolP
) != 0)
3326 size
= strlen (filename_list_scan
->filename
) + 1;
3327 memcpy (where
, filename_list_scan
->filename
, size
);
3328 filename_list_scan
= filename_list_scan
->next
;
3335 do_linenos_for (abfd
, h
, file_cursor
)
3338 unsigned long *file_cursor
;
3341 unsigned long start
= *file_cursor
;
3343 for (idx
= SEG_E0
; idx
< SEG_LAST
; idx
++)
3345 segment_info_type
*s
= segment_info
+ idx
;
3348 if (s
->scnhdr
.s_nlnno
!= 0)
3350 struct lineno_list
*line_ptr
;
3352 struct external_lineno
*buffer
=
3353 (struct external_lineno
*) xmalloc (s
->scnhdr
.s_nlnno
* LINESZ
);
3355 struct external_lineno
*dst
= buffer
;
3357 /* Run through the table we've built and turn it into its external
3358 form, take this chance to remove duplicates */
3360 for (line_ptr
= s
->lineno_list_head
;
3361 line_ptr
!= (struct lineno_list
*) NULL
;
3362 line_ptr
= line_ptr
->next
)
3365 if (line_ptr
->line
.l_lnno
== 0)
3367 /* Turn a pointer to a symbol into the symbols' index */
3368 line_ptr
->line
.l_addr
.l_symndx
=
3369 ((symbolS
*) line_ptr
->line
.l_addr
.l_symndx
)->sy_number
;
3373 line_ptr
->line
.l_addr
.l_paddr
+= ((struct frag
*) (line_ptr
->frag
))->fr_address
;
3377 (void) bfd_coff_swap_lineno_out (abfd
, &(line_ptr
->line
), dst
);
3382 s
->scnhdr
.s_lnnoptr
= *file_cursor
;
3384 bfd_write (buffer
, 1, s
->scnhdr
.s_nlnno
* LINESZ
, abfd
);
3387 *file_cursor
+= s
->scnhdr
.s_nlnno
* LINESZ
;
3390 H_SET_LINENO_SIZE (h
, *file_cursor
- start
);
3394 /* Now we run through the list of frag chains in a segment and
3395 make all the subsegment frags appear at the end of the
3396 list, as if the seg 0 was extra long */
3403 for (i
= SEG_E0
; i
< SEG_UNKNOWN
; i
++)
3405 frchainS
*head
= segment_info
[i
].frchainP
;
3407 fragS
*prev_frag
= &dummy
;
3409 while (head
&& head
->frch_seg
== i
)
3411 prev_frag
->fr_next
= head
->frch_root
;
3412 prev_frag
= head
->frch_last
;
3413 head
= head
->frch_next
;
3415 prev_frag
->fr_next
= 0;
3419 unsigned long machine
;
3422 write_object_file ()
3426 struct frchain
*frchain_ptr
;
3428 object_headers headers
;
3429 unsigned long file_cursor
;
3432 abfd
= bfd_openw (out_file_name
, TARGET_FORMAT
);
3437 as_perror (_("FATAL: Can't create %s"), out_file_name
);
3438 exit (EXIT_FAILURE
);
3440 bfd_set_format (abfd
, bfd_object
);
3441 bfd_set_arch_mach (abfd
, BFD_ARCH
, machine
);
3443 string_byte_count
= 4;
3445 for (frchain_ptr
= frchain_root
;
3446 frchain_ptr
!= (struct frchain
*) NULL
;
3447 frchain_ptr
= frchain_ptr
->frch_next
)
3449 /* Run through all the sub-segments and align them up. Also
3450 close any open frags. We tack a .fill onto the end of the
3451 frag chain so that any .align's size can be worked by looking
3452 at the next frag. */
3454 subseg_set (frchain_ptr
->frch_seg
, frchain_ptr
->frch_subseg
);
3456 #ifndef SUB_SEGMENT_ALIGN
3457 #define SUB_SEGMENT_ALIGN(SEG) 1
3460 md_do_align (SUB_SEGMENT_ALIGN (now_seg
), (char *) NULL
, 0, 0,
3463 frag_align (SUB_SEGMENT_ALIGN (now_seg
),
3464 subseg_text_p (now_seg
) ? NOP_OPCODE
: 0,
3469 frag_wane (frag_now
);
3470 frag_now
->fr_fix
= 0;
3471 know (frag_now
->fr_next
== NULL
);
3478 for (i
= SEG_E0
; i
< SEG_UNKNOWN
; i
++)
3480 relax_segment (segment_info
[i
].frchainP
->frch_root
, i
);
3483 H_SET_NUMBER_OF_SECTIONS (&headers
, 0);
3485 /* Find out how big the sections are, and set the addresses. */
3487 for (i
= SEG_E0
; i
< SEG_UNKNOWN
; i
++)
3491 segment_info
[i
].scnhdr
.s_paddr
= addr
;
3492 segment_info
[i
].scnhdr
.s_vaddr
= addr
;
3494 if (segment_info
[i
].scnhdr
.s_name
[0])
3496 H_SET_NUMBER_OF_SECTIONS (&headers
,
3497 H_GET_NUMBER_OF_SECTIONS (&headers
) + 1);
3499 #ifdef COFF_LONG_SECTION_NAMES
3500 /* Support long section names as found in PE. This code
3501 must coordinate with that in coff_header_append and
3506 len
= strlen (segment_info
[i
].name
);
3508 string_byte_count
+= len
+ 1;
3510 #endif /* COFF_LONG_SECTION_NAMES */
3513 size
= size_section (abfd
, (unsigned int) i
);
3516 /* I think the section alignment is only used on the i960; the
3517 i960 needs it, and it should do no harm on other targets. */
3518 #ifdef ALIGNMENT_IN_S_FLAGS
3519 segment_info
[i
].scnhdr
.s_flags
|= (section_alignment
[i
] & 0xF) << 8;
3521 segment_info
[i
].scnhdr
.s_align
= 1 << section_alignment
[i
];
3525 H_SET_TEXT_SIZE (&headers
, size
);
3526 else if (i
== SEG_E1
)
3527 H_SET_DATA_SIZE (&headers
, size
);
3528 else if (i
== SEG_E2
)
3529 H_SET_BSS_SIZE (&headers
, size
);
3532 /* Turn the gas native symbol table shape into a coff symbol table */
3533 crawl_symbols (&headers
, abfd
);
3535 if (string_byte_count
== 4)
3536 string_byte_count
= 0;
3538 H_SET_STRING_SIZE (&headers
, string_byte_count
);
3544 for (i
= SEG_E0
; i
< SEG_UNKNOWN
; i
++)
3546 fixup_mdeps (segment_info
[i
].frchainP
->frch_root
, &headers
, i
);
3547 fixup_segment (&segment_info
[i
], i
);
3550 /* Look for ".stab" segments and fill in their initial symbols
3552 for (i
= SEG_E0
; i
< SEG_UNKNOWN
; i
++)
3554 name
= segment_info
[i
].name
;
3557 && strncmp (".stab", name
, 5) == 0
3558 && strncmp (".stabstr", name
, 8) != 0)
3559 adjust_stab_section (abfd
, i
);
3562 file_cursor
= H_GET_TEXT_FILE_OFFSET (&headers
);
3564 bfd_seek (abfd
, (file_ptr
) file_cursor
, 0);
3566 /* Plant the data */
3568 fill_section (abfd
, &headers
, &file_cursor
);
3570 do_relocs_for (abfd
, &headers
, &file_cursor
);
3572 do_linenos_for (abfd
, &headers
, &file_cursor
);
3574 H_SET_FILE_MAGIC_NUMBER (&headers
, COFF_MAGIC
);
3575 #ifndef OBJ_COFF_OMIT_TIMESTAMP
3576 H_SET_TIME_STAMP (&headers
, (long)time((time_t *)0));
3578 H_SET_TIME_STAMP (&headers
, 0);
3580 #ifdef TC_COFF_SET_MACHINE
3581 TC_COFF_SET_MACHINE (&headers
);
3585 #define COFF_FLAGS 0
3588 #ifdef KEEP_RELOC_INFO
3589 H_SET_FLAGS (&headers
, ((H_GET_LINENO_SIZE(&headers
) ? 0 : F_LNNO
) |
3590 COFF_FLAGS
| coff_flags
));
3592 H_SET_FLAGS (&headers
, ((H_GET_LINENO_SIZE(&headers
) ? 0 : F_LNNO
) |
3593 (H_GET_RELOCATION_SIZE(&headers
) ? 0 : F_RELFLG
) |
3594 COFF_FLAGS
| coff_flags
));
3598 unsigned int symtable_size
= H_GET_SYMBOL_TABLE_SIZE (&headers
);
3599 char *buffer1
= xmalloc (symtable_size
+ string_byte_count
+ 1);
3601 H_SET_SYMBOL_TABLE_POINTER (&headers
, bfd_tell (abfd
));
3602 w_symbols (abfd
, buffer1
, symbol_rootP
);
3603 if (string_byte_count
> 0)
3604 w_strings (buffer1
+ symtable_size
);
3605 bfd_write (buffer1
, 1, symtable_size
+ string_byte_count
, abfd
);
3609 coff_header_append (abfd
, &headers
);
3611 /* Recent changes to write need this, but where it should
3612 go is up to Ken.. */
3613 if (bfd_close_all_done (abfd
) == false)
3614 as_fatal (_("Can't close %s: %s"), out_file_name
,
3615 bfd_errmsg (bfd_get_error ()));
3618 extern bfd
*stdoutput
;
3625 /* Add a new segment. This is called from subseg_new via the
3626 obj_new_segment macro. */
3629 obj_coff_add_segment (name
)
3634 #ifndef COFF_LONG_SECTION_NAMES
3635 char buf
[SCNNMLEN
+ 1];
3637 strncpy (buf
, name
, SCNNMLEN
);
3638 buf
[SCNNMLEN
] = '\0';
3642 for (i
= SEG_E0
; i
< SEG_LAST
&& segment_info
[i
].scnhdr
.s_name
[0]; i
++)
3643 if (strcmp (name
, segment_info
[i
].name
) == 0)
3648 as_bad (_("Too many new sections; can't add \"%s\""), name
);
3652 /* Add a new section. */
3653 strncpy (segment_info
[i
].scnhdr
.s_name
, name
,
3654 sizeof (segment_info
[i
].scnhdr
.s_name
));
3655 segment_info
[i
].scnhdr
.s_flags
= STYP_REG
;
3656 segment_info
[i
].name
= xstrdup (name
);
3662 * implement the .section pseudo op:
3663 * .section name {, "flags"}
3665 * | +--- optional flags: 'b' for bss
3667 * +-- section name 'l' for lib
3671 * 'd' (apparently m88k for data)
3673 * 'r' for read-only data
3674 * But if the argument is not a quoted string, treat it as a
3675 * subsegment number.
3679 obj_coff_section (ignore
)
3680 int ignore ATTRIBUTE_UNUSED
;
3682 /* Strip out the section name */
3683 char *section_name
, *name
;
3696 else if (type
== 'D')
3698 segment_info
[now_seg
].scnhdr
.s_flags
|= flags
;
3703 section_name
= input_line_pointer
;
3704 c
= get_symbol_end ();
3706 name
= xmalloc (input_line_pointer
- section_name
+ 1);
3707 strcpy (name
, section_name
);
3709 *input_line_pointer
= c
;
3715 if (*input_line_pointer
== ',')
3717 ++input_line_pointer
;
3720 if (*input_line_pointer
!= '"')
3721 exp
= get_absolute_expression ();
3724 ++input_line_pointer
;
3725 while (*input_line_pointer
!= '"'
3726 && ! is_end_of_line
[(unsigned char) *input_line_pointer
])
3728 switch (*input_line_pointer
)
3730 case 'b': flags
|= STYP_BSS
; break;
3731 case 'i': flags
|= STYP_INFO
; break;
3732 case 'l': flags
|= STYP_LIB
; break;
3733 case 'n': flags
|= STYP_NOLOAD
; break;
3734 case 'o': flags
|= STYP_OVER
; break;
3736 case 'w': flags
|= STYP_DATA
; break;
3737 case 'x': flags
|= STYP_TEXT
; break;
3738 case 'r': flags
|= STYP_LIT
; break;
3740 as_warn(_("unknown section attribute '%c'"),
3741 *input_line_pointer
);
3744 ++input_line_pointer
;
3746 if (*input_line_pointer
== '"')
3747 ++input_line_pointer
;
3751 subseg_new (name
, (subsegT
) exp
);
3753 segment_info
[now_seg
].scnhdr
.s_flags
|= flags
;
3755 demand_empty_rest_of_line ();
3760 obj_coff_text (ignore
)
3761 int ignore ATTRIBUTE_UNUSED
;
3763 subseg_new (".text", get_absolute_expression ());
3768 obj_coff_data (ignore
)
3769 int ignore ATTRIBUTE_UNUSED
;
3771 if (flag_readonly_data_in_text
)
3772 subseg_new (".text", get_absolute_expression () + 1000);
3774 subseg_new (".data", get_absolute_expression ());
3778 obj_coff_ident (ignore
)
3779 int ignore ATTRIBUTE_UNUSED
;
3781 segT current_seg
= now_seg
; /* save current seg */
3782 subsegT current_subseg
= now_subseg
;
3783 subseg_new (".comment", 0); /* .comment seg */
3784 stringer (1); /* read string */
3785 subseg_set (current_seg
, current_subseg
); /* restore current seg */
3789 c_symbol_merge (debug
, normal
)
3793 S_SET_DATA_TYPE (normal
, S_GET_DATA_TYPE (debug
));
3794 S_SET_STORAGE_CLASS (normal
, S_GET_STORAGE_CLASS (debug
));
3796 if (S_GET_NUMBER_AUXILIARY (debug
) > S_GET_NUMBER_AUXILIARY (normal
))
3798 S_SET_NUMBER_AUXILIARY (normal
, S_GET_NUMBER_AUXILIARY (debug
));
3799 } /* take the most we have */
3801 if (S_GET_NUMBER_AUXILIARY (debug
) > 0)
3803 memcpy ((char *) &normal
->sy_symbol
.ost_auxent
[0],
3804 (char *) &debug
->sy_symbol
.ost_auxent
[0],
3805 (unsigned int) (S_GET_NUMBER_AUXILIARY (debug
) * AUXESZ
));
3806 } /* Move all the auxiliary information */
3808 /* Move the debug flags. */
3809 SF_SET_DEBUG_FIELD (normal
, SF_GET_DEBUG_FIELD (debug
));
3810 } /* c_symbol_merge() */
3813 c_line_new (symbol
, paddr
, line_number
, frag
)
3819 struct lineno_list
*new_line
=
3820 (struct lineno_list
*) xmalloc (sizeof (struct lineno_list
));
3822 segment_info_type
*s
= segment_info
+ now_seg
;
3823 new_line
->line
.l_lnno
= line_number
;
3825 if (line_number
== 0)
3827 last_line_symbol
= symbol
;
3828 new_line
->line
.l_addr
.l_symndx
= (long) symbol
;
3832 new_line
->line
.l_addr
.l_paddr
= paddr
;
3835 new_line
->frag
= (char *) frag
;
3836 new_line
->next
= (struct lineno_list
*) NULL
;
3839 if (s
->lineno_list_head
== (struct lineno_list
*) NULL
)
3841 s
->lineno_list_head
= new_line
;
3845 s
->lineno_list_tail
->next
= new_line
;
3847 s
->lineno_list_tail
= new_line
;
3848 return LINESZ
* s
->scnhdr
.s_nlnno
++;
3852 c_dot_file_symbol (filename
)
3857 symbolP
= symbol_new (".file",
3860 &zero_address_frag
);
3862 S_SET_STORAGE_CLASS (symbolP
, C_FILE
);
3863 S_SET_NUMBER_AUXILIARY (symbolP
, 1);
3865 if (strlen (filename
) > FILNMLEN
)
3867 /* Filename is too long to fit into an auxent,
3868 we stick it into the string table instead. We keep
3869 a linked list of the filenames we find so we can emit
3871 struct filename_list
*f
= ((struct filename_list
*)
3872 xmalloc (sizeof (struct filename_list
)));
3874 f
->filename
= filename
;
3877 SA_SET_FILE_FNAME_ZEROS (symbolP
, 0);
3878 SA_SET_FILE_FNAME_OFFSET (symbolP
, 1);
3880 if (filename_list_tail
)
3881 filename_list_tail
->next
= f
;
3883 filename_list_head
= f
;
3884 filename_list_tail
= f
;
3888 SA_SET_FILE_FNAME (symbolP
, filename
);
3895 listing_source_file (filename
);
3901 SF_SET_DEBUG (symbolP
);
3902 S_SET_VALUE (symbolP
, (valueT
) previous_file_symbol
);
3904 previous_file_symbol
= symbolP
;
3906 /* Make sure that the symbol is first on the symbol chain */
3907 if (symbol_rootP
!= symbolP
)
3909 symbol_remove (symbolP
, &symbol_rootP
, &symbol_lastP
);
3910 symbol_insert (symbolP
, symbol_rootP
, &symbol_rootP
, &symbol_lastP
);
3912 } /* c_dot_file_symbol() */
3915 * Build a 'section static' symbol.
3919 c_section_symbol (name
, idx
)
3925 symbolP
= symbol_find_base (name
, DO_NOT_STRIP
);
3926 if (symbolP
== NULL
)
3927 symbolP
= symbol_new (name
, idx
, 0, &zero_address_frag
);
3930 /* Mmmm. I just love violating interfaces. Makes me feel...dirty. */
3931 S_SET_SEGMENT (symbolP
, idx
);
3932 symbolP
->sy_frag
= &zero_address_frag
;
3935 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
3936 S_SET_NUMBER_AUXILIARY (symbolP
, 1);
3938 SF_SET_STATICS (symbolP
);
3941 /* manfred@s-direktnet.de: section symbols *must* have the LOCAL bit cleared,
3942 which is set by the new definition of LOCAL_LABEL in tc-m68k.h. */
3943 SF_CLEAR_LOCAL (symbolP
);
3946 /* If the .linkonce pseudo-op was used for this section, we must
3947 store the information in the auxiliary entry for the section
3949 if (segment_info
[idx
].linkonce
!= LINKONCE_UNSET
)
3953 switch (segment_info
[idx
].linkonce
)
3957 case LINKONCE_DISCARD
:
3958 type
= IMAGE_COMDAT_SELECT_ANY
;
3960 case LINKONCE_ONE_ONLY
:
3961 type
= IMAGE_COMDAT_SELECT_NODUPLICATES
;
3963 case LINKONCE_SAME_SIZE
:
3964 type
= IMAGE_COMDAT_SELECT_SAME_SIZE
;
3966 case LINKONCE_SAME_CONTENTS
:
3967 type
= IMAGE_COMDAT_SELECT_EXACT_MATCH
;
3971 SYM_AUXENT (symbolP
)->x_scn
.x_comdat
= type
;
3976 } /* c_section_symbol() */
3979 w_symbols (abfd
, where
, symbol_rootP
)
3982 symbolS
* symbol_rootP
;
3987 /* First fill in those values we have only just worked out */
3988 for (i
= SEG_E0
; i
< SEG_LAST
; i
++)
3990 symbolP
= segment_info
[i
].dot
;
3993 SA_SET_SCN_SCNLEN (symbolP
, segment_info
[i
].scnhdr
.s_size
);
3994 SA_SET_SCN_NRELOC (symbolP
, segment_info
[i
].scnhdr
.s_nreloc
);
3995 SA_SET_SCN_NLINNO (symbolP
, segment_info
[i
].scnhdr
.s_nlnno
);
4000 * Emit all symbols left in the symbol chain.
4002 for (symbolP
= symbol_rootP
; symbolP
; symbolP
= symbol_next (symbolP
))
4004 /* Used to save the offset of the name. It is used to point
4005 to the string in memory but must be a file offset. */
4006 register char *temp
;
4008 /* We can't fix the lnnoptr field in yank_symbols with the other
4009 adjustments, because we have to wait until we know where they
4011 if (SF_GET_ADJ_LNNOPTR (symbolP
))
4013 SA_GET_SYM_LNNOPTR (symbolP
) +=
4014 segment_info
[S_GET_SEGMENT (symbolP
)].scnhdr
.s_lnnoptr
;
4017 tc_coff_symbol_emit_hook (symbolP
);
4019 temp
= S_GET_NAME (symbolP
);
4020 if (SF_GET_STRING (symbolP
))
4022 S_SET_OFFSET (symbolP
, symbolP
->sy_name_offset
);
4023 S_SET_ZEROES (symbolP
, 0);
4027 memset (symbolP
->sy_symbol
.ost_entry
.n_name
, 0, SYMNMLEN
);
4028 strncpy (symbolP
->sy_symbol
.ost_entry
.n_name
, temp
, SYMNMLEN
);
4030 where
= symbol_to_chars (abfd
, where
, symbolP
);
4031 S_SET_NAME (symbolP
, temp
);
4037 obj_coff_lcomm (ignore
)
4038 int ignore ATTRIBUTE_UNUSED
;
4050 name
= input_line_pointer
;
4052 c
= get_symbol_end ();
4053 p
= input_line_pointer
;
4056 if (*input_line_pointer
!= ',')
4058 as_bad (_("Expected comma after name"));
4059 ignore_rest_of_line ();
4062 if (*input_line_pointer
== '\n')
4064 as_bad (_("Missing size expression"));
4067 input_line_pointer
++;
4068 if ((temp
= get_absolute_expression ()) < 0)
4070 as_warn (_("lcomm length (%d.) <0! Ignored."), temp
);
4071 ignore_rest_of_line ();
4076 symbolP
= symbol_find_or_make(name
);
4078 if (S_GET_SEGMENT(symbolP
) == SEG_UNKNOWN
&&
4079 S_GET_VALUE(symbolP
) == 0)
4084 segT current_seg
= now_seg
; /* save current seg */
4085 subsegT current_subseg
= now_subseg
;
4087 subseg_set (SEG_E2
, 1);
4088 symbolP
->sy_frag
= frag_now
;
4089 p
= frag_var(rs_org
, 1, 1, (relax_substateT
)0, symbolP
,
4090 (offsetT
) temp
, (char *) 0);
4092 subseg_set (current_seg
, current_subseg
); /* restore current seg */
4093 S_SET_SEGMENT(symbolP
, SEG_E2
);
4094 S_SET_STORAGE_CLASS(symbolP
, C_STAT
);
4098 as_bad(_("Symbol %s already defined"), name
);
4100 demand_empty_rest_of_line();
4105 fixup_mdeps (frags
, h
, this_segment
)
4110 subseg_change (this_segment
, 0);
4113 switch (frags
->fr_type
)
4119 HANDLE_ALIGN (frags
);
4121 frags
->fr_type
= rs_fill
;
4123 ((frags
->fr_next
->fr_address
- frags
->fr_address
- frags
->fr_fix
)
4126 case rs_machine_dependent
:
4127 md_convert_frag (h
, this_segment
, frags
);
4133 frags
= frags
->fr_next
;
4139 #ifndef TC_FORCE_RELOCATION
4140 #define TC_FORCE_RELOCATION(fix) 0
4144 fixup_segment (segP
, this_segment_type
)
4145 segment_info_type
* segP
;
4146 segT this_segment_type
;
4148 register fixS
* fixP
;
4149 register symbolS
*add_symbolP
;
4150 register symbolS
*sub_symbolP
;
4153 register char *place
;
4154 register long where
;
4155 register char pcrel
;
4156 register fragS
*fragP
;
4157 register segT add_symbol_segment
= absolute_section
;
4159 for (fixP
= segP
->fix_root
; fixP
; fixP
= fixP
->fx_next
)
4161 fragP
= fixP
->fx_frag
;
4163 where
= fixP
->fx_where
;
4164 place
= fragP
->fr_literal
+ where
;
4165 size
= fixP
->fx_size
;
4166 add_symbolP
= fixP
->fx_addsy
;
4167 sub_symbolP
= fixP
->fx_subsy
;
4168 add_number
= fixP
->fx_offset
;
4169 pcrel
= fixP
->fx_pcrel
;
4171 /* We want function-relative stabs to work on systems which
4172 may use a relaxing linker; thus we must handle the sym1-sym2
4173 fixups function-relative stabs generates.
4175 Of course, if you actually enable relaxing in the linker, the
4176 line and block scoping information is going to be incorrect
4177 in some cases. The only way to really fix this is to support
4178 a reloc involving the difference of two symbols. */
4180 && (!sub_symbolP
|| pcrel
))
4184 if (fixP
->fx_tcbit
&& SF_GET_CALLNAME (add_symbolP
))
4186 /* Relocation should be done via the associated 'bal' entry
4189 if (!SF_GET_BALNAME (tc_get_bal_of_call (add_symbolP
)))
4191 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
4192 _("No 'bal' entry point for leafproc %s"),
4193 S_GET_NAME (add_symbolP
));
4196 fixP
->fx_addsy
= add_symbolP
= tc_get_bal_of_call (add_symbolP
);
4200 /* Make sure the symbols have been resolved; this may not have
4201 happened if these are expression symbols. */
4202 if (add_symbolP
!= NULL
&& ! add_symbolP
->sy_resolved
)
4203 resolve_symbol_value (add_symbolP
, 1);
4205 if (add_symbolP
!= NULL
)
4207 /* If this fixup is against a symbol which has been equated
4208 to another symbol, convert it to the other symbol. */
4209 if (add_symbolP
->sy_value
.X_op
== O_symbol
4210 && (! S_IS_DEFINED (add_symbolP
)
4211 || S_IS_COMMON (add_symbolP
)))
4213 while (add_symbolP
->sy_value
.X_op
== O_symbol
4214 && (! S_IS_DEFINED (add_symbolP
)
4215 || S_IS_COMMON (add_symbolP
)))
4219 /* We must avoid looping, as that can occur with a
4220 badly written program. */
4221 n
= add_symbolP
->sy_value
.X_add_symbol
;
4222 if (n
== add_symbolP
)
4224 add_number
+= add_symbolP
->sy_value
.X_add_number
;
4227 fixP
->fx_addsy
= add_symbolP
;
4228 fixP
->fx_offset
= add_number
;
4232 if (sub_symbolP
!= NULL
&& ! sub_symbolP
->sy_resolved
)
4233 resolve_symbol_value (sub_symbolP
, 1);
4235 if (add_symbolP
!= NULL
4236 && add_symbolP
->sy_mri_common
)
4238 know (add_symbolP
->sy_value
.X_op
== O_symbol
);
4239 add_number
+= S_GET_VALUE (add_symbolP
);
4240 fixP
->fx_offset
= add_number
;
4241 add_symbolP
= fixP
->fx_addsy
= add_symbolP
->sy_value
.X_add_symbol
;
4246 add_symbol_segment
= S_GET_SEGMENT (add_symbolP
);
4247 } /* if there is an addend */
4251 if (add_symbolP
== NULL
|| add_symbol_segment
== absolute_section
)
4253 if (add_symbolP
!= NULL
)
4255 add_number
+= S_GET_VALUE (add_symbolP
);
4257 fixP
->fx_addsy
= NULL
;
4260 /* It's just -sym. */
4261 if (S_GET_SEGMENT (sub_symbolP
) == absolute_section
)
4263 add_number
-= S_GET_VALUE (sub_symbolP
);
4270 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
4271 _("Negative of non-absolute symbol %s"),
4272 S_GET_NAME (sub_symbolP
));
4274 add_number
-= S_GET_VALUE (sub_symbolP
);
4275 } /* not absolute */
4277 /* if sub_symbol is in the same segment that add_symbol
4278 and add_symbol is either in DATA, TEXT, BSS or ABSOLUTE */
4280 else if (S_GET_SEGMENT (sub_symbolP
) == add_symbol_segment
4281 && SEG_NORMAL (add_symbol_segment
))
4283 /* Difference of 2 symbols from same segment. Can't
4284 make difference of 2 undefineds: 'value' means
4285 something different for N_UNDF. */
4287 /* Makes no sense to use the difference of 2 arbitrary symbols
4288 as the target of a call instruction. */
4291 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
4292 _("callj to difference of 2 symbols"));
4294 #endif /* TC_I960 */
4295 add_number
+= S_GET_VALUE (add_symbolP
) -
4296 S_GET_VALUE (sub_symbolP
);
4299 if (!TC_FORCE_RELOCATION (fixP
))
4301 fixP
->fx_addsy
= NULL
;
4302 fixP
->fx_subsy
= NULL
;
4304 #ifdef TC_M68K /* is this right? */
4312 /* Different segments in subtraction. */
4313 know (!(S_IS_EXTERNAL (sub_symbolP
) && (S_GET_SEGMENT (sub_symbolP
) == absolute_section
)));
4315 if ((S_GET_SEGMENT (sub_symbolP
) == absolute_section
))
4317 add_number
-= S_GET_VALUE (sub_symbolP
);
4320 else if (S_GET_SEGMENT (sub_symbolP
) == this_segment_type
4321 #if 0 /* Okay for 68k, at least... */
4326 /* Make it pc-relative. */
4327 add_number
+= (md_pcrel_from (fixP
)
4328 - S_GET_VALUE (sub_symbolP
));
4337 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
4338 _("Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %ld."),
4339 segment_name (S_GET_SEGMENT (sub_symbolP
)),
4340 S_GET_NAME (sub_symbolP
),
4341 (long) (fragP
->fr_address
+ where
));
4344 } /* if sub_symbolP */
4348 if (add_symbol_segment
== this_segment_type
&& pcrel
)
4351 * This fixup was made when the symbol's segment was
4352 * SEG_UNKNOWN, but it is now in the local segment.
4353 * So we know how to do the address without relocation.
4356 /* reloc_callj() may replace a 'call' with a 'calls' or a 'bal',
4357 * in which cases it modifies *fixP as appropriate. In the case
4358 * of a 'calls', no further work is required, and *fixP has been
4359 * set up to make the rest of the code below a no-op.
4362 #endif /* TC_I960 */
4364 add_number
+= S_GET_VALUE (add_symbolP
);
4365 add_number
-= md_pcrel_from (fixP
);
4368 add_number -= segP->scnhdr.s_vaddr;
4369 if defined (TC_I386) || defined (TE_LYNX). I now
4370 think that was an error propagated from the case when
4371 we are going to emit the relocation. If we are not
4372 going to emit the relocation, then we just want to
4373 set add_number to the difference between the symbols.
4374 This is a case that would only arise when there is a
4375 PC relative reference from a section other than .text
4376 to a symbol defined in the same section, and the
4377 reference is not relaxed. Since jump instructions on
4378 the i386 are relaxed, this could only arise with a
4379 call instruction. */
4381 pcrel
= 0; /* Lie. Don't want further pcrel processing. */
4382 if (!TC_FORCE_RELOCATION (fixP
))
4384 fixP
->fx_addsy
= NULL
;
4390 switch (add_symbol_segment
)
4392 case absolute_section
:
4394 reloc_callj (fixP
); /* See comment about reloc_callj() above*/
4395 #endif /* TC_I960 */
4396 add_number
+= S_GET_VALUE (add_symbolP
);
4399 if (!TC_FORCE_RELOCATION (fixP
))
4401 fixP
->fx_addsy
= NULL
;
4408 #if defined(TC_A29K) || (defined(TE_PE) && defined(TC_I386)) || defined(TC_M88K)
4409 /* This really should be handled in the linker, but
4410 backward compatibility forbids. */
4411 add_number
+= S_GET_VALUE (add_symbolP
);
4413 add_number
+= S_GET_VALUE (add_symbolP
) +
4414 segment_info
[S_GET_SEGMENT (add_symbolP
)].scnhdr
.s_paddr
;
4420 if ((int) fixP
->fx_bit_fixP
== 13)
4422 /* This is a COBR instruction. They have only a
4423 * 13-bit displacement and are only to be used
4424 * for local branches: flag as error, don't generate
4427 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
4428 _("can't use COBR format with external label"));
4429 fixP
->fx_addsy
= NULL
;
4433 #endif /* TC_I960 */
4434 #if ((defined (TC_I386) || defined (TE_LYNX) || defined (TE_AUX)) && !defined(TE_PE)) || defined (COFF_COMMON_ADDEND)
4435 /* 386 COFF uses a peculiar format in which the
4436 value of a common symbol is stored in the .text
4437 segment (I've checked this on SVR3.2 and SCO
4438 3.2.2) Ian Taylor <ian@cygnus.com>. */
4439 /* This is also true for 68k COFF on sysv machines
4440 (Checked on Motorola sysv68 R3V6 and R3V7.1, and also on
4441 UNIX System V/M68000, Release 1.0 from ATT/Bell Labs)
4442 Philippe De Muyter <phdm@info.ucl.ac.be>. */
4443 if (S_IS_COMMON (add_symbolP
))
4444 add_number
+= S_GET_VALUE (add_symbolP
);
4449 } /* switch on symbol seg */
4450 } /* if not in local seg */
4451 } /* if there was a + symbol */
4455 #if !defined(TC_M88K) && !(defined(TE_PE) && defined(TC_I386)) && !defined(TC_A29K)
4456 /* This adjustment is not correct on the m88k, for which the
4457 linker does all the computation. */
4458 add_number
-= md_pcrel_from (fixP
);
4460 if (add_symbolP
== 0)
4462 fixP
->fx_addsy
= &abs_symbol
;
4463 } /* if there's an add_symbol */
4464 #if defined (TC_I386) || defined (TE_LYNX) || defined (TC_I960) || defined (TC_M68K)
4465 /* On the 386 we must adjust by the segment vaddr as well.
4468 I changed the i960 to work this way as well. This is
4469 compatible with the current GNU linker behaviour. I do
4470 not know what other i960 COFF assemblers do. This is not
4471 a common case: normally, only assembler code will contain
4472 a PC relative reloc, and only branches which do not
4473 originate in the .text section will have a non-zero
4476 I changed the m68k to work this way as well. This will
4477 break existing PC relative relocs from sections which do
4478 not start at address 0, but it will make ld -r work.
4479 Ian Taylor, 4 Oct 96. */
4481 add_number
-= segP
->scnhdr
.s_vaddr
;
4485 #ifdef MD_APPLY_FIX3
4486 md_apply_fix3 (fixP
, (valueT
*) &add_number
, this_segment_type
);
4488 md_apply_fix (fixP
, add_number
);
4491 if (!fixP
->fx_bit_fixP
&& ! fixP
->fx_no_overflow
)
4494 /* The m88k uses the offset field of the reloc to get around
4497 && ((add_number
& ~0xFF)
4498 || (fixP
->fx_signed
&& (add_number
& 0x80)))
4499 && ((add_number
& ~0xFF) != (-1 & ~0xFF)
4500 || (add_number
& 0x80) == 0))
4502 && ((add_number
& ~0xFFFF)
4503 || (fixP
->fx_signed
&& (add_number
& 0x8000)))
4504 && ((add_number
& ~0xFFFF) != (-1 & ~0xFFFF)
4505 || (add_number
& 0x8000) == 0)))
4507 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
4508 _("Value of %ld too large for field of %d bytes at 0x%lx"),
4509 (long) add_number
, size
,
4510 (unsigned long) (fragP
->fr_address
+ where
));
4513 #ifdef WARN_SIGNED_OVERFLOW_WORD
4514 /* Warn if a .word value is too large when treated as a
4515 signed number. We already know it is not too negative.
4516 This is to catch over-large switches generated by gcc on
4518 if (!flag_signed_overflow_ok
4520 && add_number
> 0x7fff)
4521 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
4522 _("Signed .word overflow; switch may be too large; %ld at 0x%lx"),
4524 (unsigned long) (fragP
->fr_address
+ where
));
4526 } /* not a bit fix */
4527 } /* For each fixS in this segment. */
4528 } /* fixup_segment() */
4532 /* The first entry in a .stab section is special. */
4535 obj_coff_init_stab_section (seg
)
4541 unsigned int stroff
;
4543 /* Make space for this first symbol. */
4547 as_where (&file
, (unsigned int *) NULL
);
4548 stabstr_name
= (char *) alloca (strlen (segment_info
[seg
].name
) + 4);
4549 strcpy (stabstr_name
, segment_info
[seg
].name
);
4550 strcat (stabstr_name
, "str");
4551 stroff
= get_stab_string_offset (file
, stabstr_name
);
4553 md_number_to_chars (p
, stroff
, 4);
4556 /* Fill in the counts in the first entry in a .stab section. */
4559 adjust_stab_section(abfd
, seg
)
4563 segT stabstrseg
= SEG_UNKNOWN
;
4564 const char *secname
, *name2
;
4567 int i
, strsz
= 0, nsyms
;
4568 fragS
*frag
= segment_info
[seg
].frchainP
->frch_root
;
4570 /* Look for the associated string table section. */
4572 secname
= segment_info
[seg
].name
;
4573 name
= (char *) alloca (strlen (secname
) + 4);
4574 strcpy (name
, secname
);
4575 strcat (name
, "str");
4577 for (i
= SEG_E0
; i
< SEG_UNKNOWN
; i
++)
4579 name2
= segment_info
[i
].name
;
4580 if (name2
!= NULL
&& strncmp(name2
, name
, 8) == 0)
4587 /* If we found the section, get its size. */
4588 if (stabstrseg
!= SEG_UNKNOWN
)
4589 strsz
= size_section (abfd
, stabstrseg
);
4591 nsyms
= size_section (abfd
, seg
) / 12 - 1;
4593 /* Look for the first frag of sufficient size for the initial stab
4594 symbol, and collect a pointer to it. */
4595 while (frag
&& frag
->fr_fix
< 12)
4596 frag
= frag
->fr_next
;
4598 p
= frag
->fr_literal
;
4601 /* Write in the number of stab symbols and the size of the string
4603 bfd_h_put_16 (abfd
, (bfd_vma
) nsyms
, (bfd_byte
*) p
+ 6);
4604 bfd_h_put_32 (abfd
, (bfd_vma
) strsz
, (bfd_byte
*) p
+ 8);
4607 #endif /* not BFD_ASSEMBLER */
4609 const pseudo_typeS coff_pseudo_table
[] =
4611 {"def", obj_coff_def
, 0},
4612 {"dim", obj_coff_dim
, 0},
4613 {"endef", obj_coff_endef
, 0},
4614 {"line", obj_coff_line
, 0},
4615 {"ln", obj_coff_ln
, 0},
4616 #ifdef BFD_ASSEMBLER
4617 {"loc", obj_coff_loc
, 0},
4619 {"appline", obj_coff_ln
, 1},
4620 {"scl", obj_coff_scl
, 0},
4621 {"size", obj_coff_size
, 0},
4622 {"tag", obj_coff_tag
, 0},
4623 {"type", obj_coff_type
, 0},
4624 {"val", obj_coff_val
, 0},
4625 {"section", obj_coff_section
, 0},
4626 {"sect", obj_coff_section
, 0},
4627 /* FIXME: We ignore the MRI short attribute. */
4628 {"section.s", obj_coff_section
, 0},
4629 {"sect.s", obj_coff_section
, 0},
4630 /* We accept the .bss directive for backward compatibility with
4631 earlier versions of gas. */
4632 {"bss", obj_coff_bss
, 0},
4633 {"weak", obj_coff_weak
, 0},
4634 {"ident", obj_coff_ident
, 0},
4635 #ifndef BFD_ASSEMBLER
4636 {"use", obj_coff_section
, 0},
4637 {"text", obj_coff_text
, 0},
4638 {"data", obj_coff_data
, 0},
4639 {"lcomm", obj_coff_lcomm
, 0},
4641 {"optim", s_ignore
, 0}, /* For sun386i cc (?) */
4643 {"version", s_ignore
, 0},
4644 {"ABORT", s_abort
, 0},
4646 /* The m88k uses sdef instead of def. */
4647 {"sdef", obj_coff_def
, 0},
4649 {NULL
, NULL
, 0} /* end sentinel */
4650 }; /* coff_pseudo_table */
4652 #ifdef BFD_ASSEMBLER
4654 /* Support for a COFF emulation. */
4656 static void coff_pop_insert
PARAMS ((void));
4657 static int coff_separate_stab_sections
PARAMS ((void));
4662 pop_insert (coff_pseudo_table
);
4666 coff_separate_stab_sections ()
4671 const struct format_ops coff_format_ops
=
4673 bfd_target_coff_flavour
,
4674 0, /* dfl_leading_underscore */
4675 1, /* emit_section_symbols */
4680 coff_frob_file_after_relocs
,
4683 0, /* s_get_align */
4684 0, /* s_set_align */
4685 0, /* s_get_other */
4686 0, /* s_set_other */
4691 0, /* copy_symbol_attributes */
4692 0, /* generate_asm_lineno */
4693 0, /* process_stab */
4694 coff_separate_stab_sections
,
4695 obj_coff_init_stab_section
,
4696 0, /* sec_sym_ok_for_reloc */
4698 0, /* ecoff_set_ext */
4699 coff_obj_read_begin_hook
,
4700 coff_obj_symbol_new_hook