1 /* coff object file format
2 Copyright (C) 1989, 1990, 1991, 1992, 1993, 1994
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
19 the Free Software Foundation, 59 Temple Place - Suite 330, Boston, MA 02111-1307, USA. */
25 /* I think this is probably always correct. */
26 #ifndef KEEP_RELOC_INFO
27 #define KEEP_RELOC_INFO
31 /* structure used to keep the filenames which
32 are too long around so that we can stick them
33 into the string table */
37 struct filename_list
*next
;
40 static struct filename_list
*filename_list_head
;
41 static struct filename_list
*filename_list_tail
;
43 const char *s_get_name
PARAMS ((symbolS
* s
));
44 static symbolS
*def_symbol_in_progress
;
50 unsigned long chunk_size
;
51 unsigned long element_size
;
54 unsigned long pointer
;
59 stack_init (chunk_size
, element_size
)
60 unsigned long chunk_size
;
61 unsigned long element_size
;
65 st
= (stack
*) malloc (sizeof (stack
));
68 st
->data
= malloc (chunk_size
);
75 st
->size
= chunk_size
;
76 st
->chunk_size
= chunk_size
;
77 st
->element_size
= element_size
;
82 /* Not currently used. */
93 stack_push (st
, element
)
97 if (st
->pointer
+ st
->element_size
>= st
->size
)
99 st
->size
+= st
->chunk_size
;
100 if ((st
->data
= xrealloc (st
->data
, st
->size
)) == (char *) 0)
103 memcpy (st
->data
+ st
->pointer
, element
, st
->element_size
);
104 st
->pointer
+= st
->element_size
;
105 return st
->data
+ st
->pointer
;
112 if (st
->pointer
< st
->element_size
)
117 st
->pointer
-= st
->element_size
;
118 return st
->data
+ st
->pointer
;
122 * Maintain a list of the tagnames of the structres.
125 static struct hash_control
*tag_hash
;
130 tag_hash
= hash_new ();
134 tag_insert (name
, symbolP
)
138 const char *error_string
;
140 if ((error_string
= hash_jam (tag_hash
, name
, (char *) symbolP
)))
142 as_fatal ("Inserting \"%s\" into structure table failed: %s",
151 #ifdef STRIP_UNDERSCORE
154 #endif /* STRIP_UNDERSCORE */
155 return (symbolS
*) hash_find (tag_hash
, name
);
159 tag_find_or_make (name
)
164 if ((symbolP
= tag_find (name
)) == NULL
)
166 symbolP
= symbol_new (name
, undefined_section
,
167 0, &zero_address_frag
);
169 tag_insert (S_GET_NAME (symbolP
), symbolP
);
171 symbol_table_insert (symbolP
);
182 static void SA_SET_SYM_TAGNDX
PARAMS ((symbolS
*, symbolS
*));
184 #define GET_FILENAME_STRING(X) \
185 ((char*)(&((X)->sy_symbol.ost_auxent->x_file.x_n.x_offset))[1])
189 fetch_coff_debug_section ()
191 static segT debug_section
;
195 s
= bfd_make_debug_symbol (stdoutput
, (char *) 0, 0);
197 debug_section
= s
->section
;
199 return debug_section
;
203 SA_SET_SYM_ENDNDX (sym
, val
)
207 combined_entry_type
*entry
, *p
;
209 entry
= &coffsymbol (sym
->bsym
)->native
[1];
210 p
= coffsymbol (val
->bsym
)->native
;
211 entry
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
= p
;
216 SA_SET_SYM_TAGNDX (sym
, val
)
220 combined_entry_type
*entry
, *p
;
222 entry
= &coffsymbol (sym
->bsym
)->native
[1];
223 p
= coffsymbol (val
->bsym
)->native
;
224 entry
->u
.auxent
.x_sym
.x_tagndx
.p
= p
;
229 S_GET_DATA_TYPE (sym
)
232 return coffsymbol (sym
->bsym
)->native
->u
.syment
.n_type
;
236 S_SET_DATA_TYPE (sym
, val
)
240 coffsymbol (sym
->bsym
)->native
->u
.syment
.n_type
= val
;
245 S_GET_STORAGE_CLASS (sym
)
248 return coffsymbol (sym
->bsym
)->native
->u
.syment
.n_sclass
;
252 S_SET_STORAGE_CLASS (sym
, val
)
256 coffsymbol (sym
->bsym
)->native
->u
.syment
.n_sclass
= val
;
260 /* Merge a debug symbol containing debug information into a normal symbol. */
263 c_symbol_merge (debug
, normal
)
267 S_SET_DATA_TYPE (normal
, S_GET_DATA_TYPE (debug
));
268 S_SET_STORAGE_CLASS (normal
, S_GET_STORAGE_CLASS (debug
));
270 if (S_GET_NUMBER_AUXILIARY (debug
) > S_GET_NUMBER_AUXILIARY (normal
))
271 /* take the most we have */
272 S_SET_NUMBER_AUXILIARY (normal
, S_GET_NUMBER_AUXILIARY (debug
));
274 if (S_GET_NUMBER_AUXILIARY (debug
) > 0)
276 /* Move all the auxiliary information. */
277 /* @@ How many fields do we want to preserve? Would it make more
278 sense to pick and choose those we want to copy? Should look
279 into this further.... [raeburn:19920512.2209EST] */
281 linenos
= coffsymbol (normal
->bsym
)->lineno
;
282 memcpy ((char *) &coffsymbol (normal
->bsym
)->native
,
283 (char *) &coffsymbol (debug
->bsym
)->native
,
284 S_GET_NUMBER_AUXILIARY(debug
) * AUXESZ
);
285 coffsymbol (normal
->bsym
)->lineno
= linenos
;
288 /* Move the debug flags. */
289 SF_SET_DEBUG_FIELD (normal
, SF_GET_DEBUG_FIELD (debug
));
292 static symbolS
*previous_file_symbol
;
294 c_dot_file_symbol (filename
)
299 symbolP
= symbol_new (filename
, bfd_abs_section_ptr
, 0, &zero_address_frag
);
301 S_SET_STORAGE_CLASS (symbolP
, C_FILE
);
302 S_SET_NUMBER_AUXILIARY (symbolP
, 1);
304 symbolP
->bsym
->flags
= BSF_DEBUGGING
;
311 listing_source_file (filename
);
316 S_SET_VALUE (symbolP
, (long) previous_file_symbol
);
318 previous_file_symbol
= symbolP
;
320 /* Make sure that the symbol is first on the symbol chain */
321 if (symbol_rootP
!= symbolP
)
323 if (symbolP
== symbol_lastP
)
325 symbol_lastP
= symbol_lastP
->sy_previous
;
326 } /* if it was the last thing on the list */
328 symbol_remove (symbolP
, &symbol_rootP
, &symbol_lastP
);
329 symbol_insert (symbolP
, symbol_rootP
, &symbol_rootP
, &symbol_lastP
);
330 symbol_rootP
= symbolP
;
331 } /* if not first on the list */
335 * Build a 'section static' symbol.
339 c_section_symbol (name
, value
, length
, nreloc
, nlnno
)
343 unsigned short nreloc
;
344 unsigned short nlnno
;
348 symbolP
= symbol_new (name
,
357 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
358 S_SET_NUMBER_AUXILIARY (symbolP
, 1);
360 SA_SET_SCN_SCNLEN (symbolP
, length
);
361 SA_SET_SCN_NRELOC (symbolP
, nreloc
);
362 SA_SET_SCN_NLINNO (symbolP
, nlnno
);
364 SF_SET_STATICS (symbolP
);
366 return (char *) symbolP
;
369 /* Line number handling */
372 struct line_no
*next
;
379 /* Symbol of last function, which we should hang line#s off of. */
380 static symbolS
*line_fsym
;
382 #define in_function() (line_fsym != 0)
383 #define clear_function() (line_fsym = 0)
384 #define set_function(F) (line_fsym = (F), coff_add_linesym (F))
388 obj_symbol_new_hook (symbolP
)
391 char underscore
= 0; /* Symbol has leading _ */
394 long sz
= (OBJ_COFF_MAX_AUXENTRIES
+ 1) * sizeof (combined_entry_type
);
395 char *s
= (char *) bfd_alloc_by_size_t (stdoutput
, sz
);
397 coffsymbol (symbolP
->bsym
)->native
= (combined_entry_type
*) s
;
399 S_SET_DATA_TYPE (symbolP
, T_NULL
);
400 S_SET_STORAGE_CLASS (symbolP
, 0);
401 S_SET_NUMBER_AUXILIARY (symbolP
, 0);
403 if (S_IS_STRING (symbolP
))
404 SF_SET_STRING (symbolP
);
405 if (!underscore
&& S_IS_LOCAL (symbolP
))
406 SF_SET_LOCAL (symbolP
);
411 * Handle .ln directives.
414 static symbolS
*current_lineno_sym
;
415 static struct line_no
*line_nos
;
416 /* @@ Blindly assume all .ln directives will be in the .text section... */
420 add_lineno (frag
, offset
, num
)
425 struct line_no
*new_line
= (struct line_no
*) bfd_alloc_by_size_t (stdoutput
,
426 sizeof (struct line_no
));
427 if (!current_lineno_sym
)
431 new_line
->next
= line_nos
;
432 new_line
->frag
= frag
;
433 new_line
->l
.line_number
= num
;
434 new_line
->l
.u
.offset
= offset
;
440 coff_add_linesym (sym
)
445 coffsymbol (current_lineno_sym
->bsym
)->lineno
= (alent
*) line_nos
;
449 current_lineno_sym
= sym
;
453 obj_coff_ln (appline
)
458 if (! appline
&& def_symbol_in_progress
!= NULL
)
460 as_warn (".ln pseudo-op inside .def/.endef: ignored.");
461 demand_empty_rest_of_line ();
465 l
= get_absolute_expression ();
468 add_lineno (frag_now
, frag_now_fix (), l
);
478 l
+= coff_line_base
- 1;
479 listing_source_line (l
);
484 demand_empty_rest_of_line ();
490 * Handle .def directives.
492 * One might ask : why can't we symbol_new if the symbol does not
493 * already exist and fill it with debug information. Because of
494 * the C_EFCN special symbol. It would clobber the value of the
495 * function symbol before we have a chance to notice that it is
496 * a C_EFCN. And a second reason is that the code is more clear this
497 * way. (at least I think it is :-).
501 #define SKIP_SEMI_COLON() while (*input_line_pointer++ != ';')
502 #define SKIP_WHITESPACES() while (*input_line_pointer == ' ' || \
503 *input_line_pointer == '\t') \
504 input_line_pointer++;
510 char name_end
; /* Char after the end of name */
511 char *symbol_name
; /* Name of the debug symbol */
512 char *symbol_name_copy
; /* Temporary copy of the name */
513 unsigned int symbol_name_length
;
515 if (def_symbol_in_progress
!= NULL
)
517 as_warn (".def pseudo-op used inside of .def/.endef: ignored.");
518 demand_empty_rest_of_line ();
520 } /* if not inside .def/.endef */
524 symbol_name
= input_line_pointer
;
525 #ifdef STRIP_UNDERSCORE
526 if (symbol_name
[0] == '_' && symbol_name
[1] != 0)
528 #endif /* STRIP_UNDERSCORE */
530 name_end
= get_symbol_end ();
531 symbol_name_length
= strlen (symbol_name
);
532 symbol_name_copy
= xmalloc (symbol_name_length
+ 1);
533 strcpy (symbol_name_copy
, symbol_name
);
535 /* Initialize the new symbol */
536 def_symbol_in_progress
= symbol_make (symbol_name_copy
);
537 def_symbol_in_progress
->sy_frag
= &zero_address_frag
;
538 S_SET_VALUE (def_symbol_in_progress
, 0);
540 if (S_IS_STRING (def_symbol_in_progress
))
541 SF_SET_STRING (def_symbol_in_progress
);
543 *input_line_pointer
= name_end
;
545 demand_empty_rest_of_line ();
548 unsigned int dim_index
;
551 obj_coff_endef (ignore
)
555 /* DIM BUG FIX sac@cygnus.com */
557 if (def_symbol_in_progress
== NULL
)
559 as_warn (".endef pseudo-op used outside of .def/.endef: ignored.");
560 demand_empty_rest_of_line ();
562 } /* if not inside .def/.endef */
564 /* Set the section number according to storage class. */
565 switch (S_GET_STORAGE_CLASS (def_symbol_in_progress
))
570 SF_SET_TAG (def_symbol_in_progress
);
571 /* intentional fallthrough */
574 SF_SET_DEBUG (def_symbol_in_progress
);
575 S_SET_SEGMENT (def_symbol_in_progress
, fetch_coff_debug_section ());
579 SF_SET_LOCAL (def_symbol_in_progress
); /* Do not emit this symbol. */
580 /* intentional fallthrough */
582 SF_SET_PROCESS (def_symbol_in_progress
); /* Will need processing before writing */
583 /* intentional fallthrough */
587 S_SET_SEGMENT (def_symbol_in_progress
, text_section
);
589 name
= bfd_asymbol_name (def_symbol_in_progress
->bsym
);
590 if (name
[1] == 'b' && name
[2] == 'f')
592 if (! in_function ())
593 as_warn ("`%s' symbol without preceding function", name
);
594 /* SA_SET_SYM_LNNO (def_symbol_in_progress, 12345);*/
595 /* Will need relocating */
596 SF_SET_PROCESS (def_symbol_in_progress
);
604 #endif /* C_AUTOARG */
614 SF_SET_DEBUG (def_symbol_in_progress
);
615 S_SET_SEGMENT (def_symbol_in_progress
, absolute_section
);
621 /* Valid but set somewhere else (s_comm, s_lcomm, colon) */
627 as_warn ("unexpected storage class %d",
628 S_GET_STORAGE_CLASS (def_symbol_in_progress
));
630 } /* switch on storage class */
632 /* Now that we have built a debug symbol, try to find if we should
633 merge with an existing symbol or not. If a symbol is C_EFCN or
634 SEG_ABSOLUTE or untagged SEG_DEBUG it never merges. */
636 /* Two cases for functions. Either debug followed by definition or
637 definition followed by debug. For definition first, we will
638 merge the debug symbol into the definition. For debug first, the
639 lineno entry MUST point to the definition function or else it
640 will point off into space when obj_crawl_symbol_chain() merges
641 the debug symbol into the real symbol. Therefor, let's presume
642 the debug symbol is a real function reference. */
644 /* FIXME-SOON If for some reason the definition label/symbol is
645 never seen, this will probably leave an undefined symbol at link
648 if (S_GET_STORAGE_CLASS (def_symbol_in_progress
) == C_EFCN
649 || (!strcmp (bfd_get_section_name (stdoutput
,
650 S_GET_SEGMENT (def_symbol_in_progress
)),
652 && !SF_GET_TAG (def_symbol_in_progress
))
653 || S_GET_SEGMENT (def_symbol_in_progress
) == absolute_section
654 || (symbolP
= symbol_find_base (S_GET_NAME (def_symbol_in_progress
), DO_NOT_STRIP
)) == NULL
)
656 if (def_symbol_in_progress
!= symbol_lastP
)
657 symbol_append (def_symbol_in_progress
, symbol_lastP
, &symbol_rootP
,
662 /* This symbol already exists, merge the newly created symbol
663 into the old one. This is not mandatory. The linker can
664 handle duplicate symbols correctly. But I guess that it save
665 a *lot* of space if the assembly file defines a lot of
668 /* The debug entry (def_symbol_in_progress) is merged into the
669 previous definition. */
671 c_symbol_merge (def_symbol_in_progress
, symbolP
);
672 /* FIXME-SOON Should *def_symbol_in_progress be free'd? xoxorich. */
673 def_symbol_in_progress
= symbolP
;
675 if (SF_GET_FUNCTION (def_symbol_in_progress
)
676 || SF_GET_TAG (def_symbol_in_progress
))
678 /* For functions, and tags, the symbol *must* be where the
679 debug symbol appears. Move the existing symbol to the
681 /* If it already is at the end of the symbol list, do nothing */
682 if (def_symbol_in_progress
!= symbol_lastP
)
684 symbol_remove (def_symbol_in_progress
, &symbol_rootP
, &symbol_lastP
);
685 symbol_append (def_symbol_in_progress
, symbol_lastP
, &symbol_rootP
, &symbol_lastP
);
690 if (SF_GET_TAG (def_symbol_in_progress
)
691 && symbol_find_base (S_GET_NAME (def_symbol_in_progress
), DO_NOT_STRIP
) == NULL
)
693 tag_insert (S_GET_NAME (def_symbol_in_progress
), def_symbol_in_progress
);
696 if (SF_GET_FUNCTION (def_symbol_in_progress
))
698 know (sizeof (def_symbol_in_progress
) <= sizeof (long));
699 set_function (def_symbol_in_progress
);
700 SF_SET_PROCESS (def_symbol_in_progress
);
704 /* That is, if this is the first time we've seen the
706 symbol_table_insert (def_symbol_in_progress
);
707 } /* definition follows debug */
708 } /* Create the line number entry pointing to the function being defined */
710 def_symbol_in_progress
= NULL
;
711 demand_empty_rest_of_line ();
715 obj_coff_dim (ignore
)
720 if (def_symbol_in_progress
== NULL
)
722 as_warn (".dim pseudo-op used outside of .def/.endef: ignored.");
723 demand_empty_rest_of_line ();
725 } /* if not inside .def/.endef */
727 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
729 for (dim_index
= 0; dim_index
< DIMNUM
; dim_index
++)
732 SA_SET_SYM_DIMEN (def_symbol_in_progress
, dim_index
,
733 get_absolute_expression ());
735 switch (*input_line_pointer
)
738 input_line_pointer
++;
742 as_warn ("badly formed .dim directive ignored");
743 /* intentional fallthrough */
751 demand_empty_rest_of_line ();
755 obj_coff_line (ignore
)
760 if (def_symbol_in_progress
== NULL
)
762 /* Probably stabs-style line? */
767 this_base
= get_absolute_expression ();
768 if (!strcmp (".bf", S_GET_NAME (def_symbol_in_progress
)))
769 coff_line_base
= this_base
;
771 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
772 SA_SET_SYM_LNNO (def_symbol_in_progress
, coff_line_base
);
774 demand_empty_rest_of_line ();
777 if (strcmp (".bf", S_GET_NAME (def_symbol_in_progress
)) == 0)
782 listing_source_line ((unsigned int) coff_line_base
);
788 obj_coff_size (ignore
)
791 if (def_symbol_in_progress
== NULL
)
793 as_warn (".size pseudo-op used outside of .def/.endef ignored.");
794 demand_empty_rest_of_line ();
796 } /* if not inside .def/.endef */
798 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
799 SA_SET_SYM_SIZE (def_symbol_in_progress
, get_absolute_expression ());
800 demand_empty_rest_of_line ();
804 obj_coff_scl (ignore
)
807 if (def_symbol_in_progress
== NULL
)
809 as_warn (".scl pseudo-op used outside of .def/.endef ignored.");
810 demand_empty_rest_of_line ();
812 } /* if not inside .def/.endef */
814 S_SET_STORAGE_CLASS (def_symbol_in_progress
, get_absolute_expression ());
815 demand_empty_rest_of_line ();
819 obj_coff_tag (ignore
)
825 if (def_symbol_in_progress
== NULL
)
827 as_warn (".tag pseudo-op used outside of .def/.endef ignored.");
828 demand_empty_rest_of_line ();
832 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
833 symbol_name
= input_line_pointer
;
834 name_end
= get_symbol_end ();
836 /* Assume that the symbol referred to by .tag is always defined.
837 This was a bad assumption. I've added find_or_make. xoxorich. */
838 SA_SET_SYM_TAGNDX (def_symbol_in_progress
,
839 tag_find_or_make (symbol_name
));
840 if (SA_GET_SYM_TAGNDX (def_symbol_in_progress
) == 0L)
842 as_warn ("tag not found for .tag %s", symbol_name
);
845 SF_SET_TAGGED (def_symbol_in_progress
);
846 *input_line_pointer
= name_end
;
848 demand_empty_rest_of_line ();
852 obj_coff_type (ignore
)
855 if (def_symbol_in_progress
== NULL
)
857 as_warn (".type pseudo-op used outside of .def/.endef ignored.");
858 demand_empty_rest_of_line ();
860 } /* if not inside .def/.endef */
862 S_SET_DATA_TYPE (def_symbol_in_progress
, get_absolute_expression ());
864 if (ISFCN (S_GET_DATA_TYPE (def_symbol_in_progress
)) &&
865 S_GET_STORAGE_CLASS (def_symbol_in_progress
) != C_TPDEF
)
867 SF_SET_FUNCTION (def_symbol_in_progress
);
868 } /* is a function */
870 demand_empty_rest_of_line ();
874 obj_coff_val (ignore
)
877 if (def_symbol_in_progress
== NULL
)
879 as_warn (".val pseudo-op used outside of .def/.endef ignored.");
880 demand_empty_rest_of_line ();
882 } /* if not inside .def/.endef */
884 if (is_name_beginner (*input_line_pointer
))
886 char *symbol_name
= input_line_pointer
;
887 char name_end
= get_symbol_end ();
889 if (!strcmp (symbol_name
, "."))
891 def_symbol_in_progress
->sy_frag
= frag_now
;
892 S_SET_VALUE (def_symbol_in_progress
, (valueT
) frag_now_fix ());
893 /* If the .val is != from the .def (e.g. statics) */
895 else if (strcmp (S_GET_NAME (def_symbol_in_progress
), symbol_name
))
897 def_symbol_in_progress
->sy_value
.X_op
= O_symbol
;
898 def_symbol_in_progress
->sy_value
.X_add_symbol
=
899 symbol_find_or_make (symbol_name
);
900 def_symbol_in_progress
->sy_value
.X_op_symbol
= NULL
;
901 def_symbol_in_progress
->sy_value
.X_add_number
= 0;
903 /* If the segment is undefined when the forward reference is
904 resolved, then copy the segment id from the forward
906 SF_SET_GET_SEGMENT (def_symbol_in_progress
);
908 /* Otherwise, it is the name of a non debug symbol and its value will be calculated later. */
909 *input_line_pointer
= name_end
;
913 S_SET_VALUE (def_symbol_in_progress
, get_absolute_expression ());
914 } /* if symbol based */
916 demand_empty_rest_of_line ();
920 obj_read_begin_hook ()
922 /* These had better be the same. Usually 18 bytes. */
924 know (sizeof (SYMENT
) == sizeof (AUXENT
));
925 know (SYMESZ
== AUXESZ
);
931 symbolS
*coff_last_function
;
934 coff_frob_symbol (symp
, punt
)
938 static symbolS
*last_tagP
;
939 static stack
*block_stack
;
940 static symbolS
*set_end
;
941 symbolS
*next_set_end
= NULL
;
943 if (symp
== &abs_symbol
)
949 if (current_lineno_sym
)
950 coff_add_linesym ((symbolS
*) 0);
953 block_stack
= stack_init (512, sizeof (symbolS
*));
955 if (!S_IS_DEFINED (symp
) && S_GET_STORAGE_CLASS (symp
) != C_STAT
)
956 S_SET_STORAGE_CLASS (symp
, C_EXT
);
958 if (!SF_GET_DEBUG (symp
))
961 if (!SF_GET_LOCAL (symp
)
962 && (real
= symbol_find_base (S_GET_NAME (symp
), DO_NOT_STRIP
))
965 c_symbol_merge (symp
, real
);
968 if (!S_IS_DEFINED (symp
) && !SF_GET_LOCAL (symp
))
970 assert (S_GET_VALUE (symp
) == 0);
971 S_SET_EXTERNAL (symp
);
973 else if (S_GET_STORAGE_CLASS (symp
) == C_NULL
)
975 if (S_GET_SEGMENT (symp
) == text_section
976 && symp
!= seg_info (text_section
)->sym
)
977 S_SET_STORAGE_CLASS (symp
, C_LABEL
);
979 S_SET_STORAGE_CLASS (symp
, C_STAT
);
981 if (SF_GET_PROCESS (symp
))
983 if (S_GET_STORAGE_CLASS (symp
) == C_BLOCK
)
985 if (!strcmp (S_GET_NAME (symp
), ".bb"))
986 stack_push (block_stack
, (char *) &symp
);
990 begin
= *(symbolS
**) stack_pop (block_stack
);
992 as_warn ("mismatched .eb");
994 next_set_end
= begin
;
997 if (coff_last_function
== 0 && SF_GET_FUNCTION (symp
))
999 union internal_auxent
*auxp
;
1000 coff_last_function
= symp
;
1001 if (S_GET_NUMBER_AUXILIARY (symp
) < 1)
1002 S_SET_NUMBER_AUXILIARY (symp
, 1);
1003 auxp
= &coffsymbol (symp
->bsym
)->native
[1].u
.auxent
;
1004 memset (auxp
->x_sym
.x_fcnary
.x_ary
.x_dimen
, 0,
1005 sizeof (auxp
->x_sym
.x_fcnary
.x_ary
.x_dimen
));
1007 if (S_GET_STORAGE_CLASS (symp
) == C_EFCN
)
1009 if (coff_last_function
== 0)
1010 as_fatal ("C_EFCN symbol out of scope");
1011 SA_SET_SYM_FSIZE (coff_last_function
,
1012 (long) (S_GET_VALUE (symp
)
1013 - S_GET_VALUE (coff_last_function
)));
1014 next_set_end
= coff_last_function
;
1015 coff_last_function
= 0;
1018 else if (SF_GET_TAG (symp
))
1020 else if (S_GET_STORAGE_CLASS (symp
) == C_EOS
)
1021 next_set_end
= last_tagP
;
1022 else if (S_GET_STORAGE_CLASS (symp
) == C_FILE
)
1024 if (S_GET_VALUE (symp
))
1026 S_SET_VALUE ((symbolS
*) S_GET_VALUE (symp
), 0xdeadbeef);
1027 S_SET_VALUE (symp
, 0);
1030 if (S_IS_EXTERNAL (symp
))
1031 S_SET_STORAGE_CLASS (symp
, C_EXT
);
1032 else if (SF_GET_LOCAL (symp
))
1035 if (SF_GET_FUNCTION (symp
))
1036 symp
->bsym
->flags
|= BSF_FUNCTION
;
1042 /* This is pretty horrible, but we have to set *punt correctly in
1043 order to call SA_SET_SYM_ENDNDX correctly. */
1044 if (! symp
->sy_used_in_reloc
1045 && ((symp
->bsym
->flags
& BSF_SECTION_SYM
) != 0
1046 || (! S_IS_EXTERNAL (symp
)
1047 && ! symp
->sy_tc
.output
1048 && S_GET_STORAGE_CLASS (symp
) != C_FILE
)))
1052 if (set_end
!= (symbolS
*) NULL
1055 SA_SET_SYM_ENDNDX (set_end
, symp
);
1059 if (next_set_end
!= NULL
1061 set_end
= next_set_end
;
1063 if (coffsymbol (symp
->bsym
)->lineno
)
1066 struct line_no
*lptr
;
1069 lptr
= (struct line_no
*) coffsymbol (symp
->bsym
)->lineno
;
1070 for (i
= 0; lptr
; lptr
= lptr
->next
)
1072 lptr
= (struct line_no
*) coffsymbol (symp
->bsym
)->lineno
;
1074 /* We need i entries for line numbers, plus 1 for the first
1075 entry which BFD will override, plus 1 for the last zero
1076 entry (a marker for BFD). */
1077 l
= (alent
*) bfd_alloc_by_size_t (stdoutput
, (i
+ 2) * sizeof (alent
));
1078 coffsymbol (symp
->bsym
)->lineno
= l
;
1079 l
[i
+ 1].line_number
= 0;
1080 l
[i
+ 1].u
.sym
= NULL
;
1084 lptr
->l
.u
.offset
+= lptr
->frag
->fr_address
;
1092 coff_adjust_section_syms (abfd
, sec
, x
)
1098 segment_info_type
*seginfo
= seg_info (sec
);
1099 int nlnno
, nrelocs
= 0;
1101 /* RS/6000 gas creates a .debug section manually in ppc_frob_file in
1102 tc-ppc.c. Do not get confused by it. */
1103 if (seginfo
== NULL
)
1106 if (!strcmp (sec
->name
, ".text"))
1107 nlnno
= coff_n_line_nos
;
1111 /* @@ Hope that none of the fixups expand to more than one reloc
1113 fixS
*fixp
= seginfo
->fix_root
;
1116 fixp
= fixp
->fx_next
;
1120 if (bfd_get_section_size_before_reloc (sec
) == 0
1121 && nrelocs
== 0 && nlnno
== 0)
1123 secsym
= section_symbol (sec
);
1124 SA_SET_SCN_NRELOC (secsym
, nrelocs
);
1125 SA_SET_SCN_NLINNO (secsym
, nlnno
);
1131 bfd_map_over_sections (stdoutput
, coff_adjust_section_syms
, (char*) 0);
1135 * implement the .section pseudo op:
1136 * .section name {, "flags"}
1138 * | +--- optional flags: 'b' for bss
1140 * +-- section name 'l' for lib
1144 * 'd' (apparently m88k for data)
1146 * But if the argument is not a quoted string, treat it as a
1147 * subsegment number.
1151 obj_coff_section (ignore
)
1154 /* Strip out the section name */
1170 section_name
= input_line_pointer
;
1171 c
= get_symbol_end ();
1173 name
= xmalloc (input_line_pointer
- section_name
+ 1);
1174 strcpy (name
, section_name
);
1176 *input_line_pointer
= c
;
1181 flags
= SEC_NO_FLAGS
;
1183 if (*input_line_pointer
== ',')
1185 ++input_line_pointer
;
1187 if (*input_line_pointer
!= '"')
1188 exp
= get_absolute_expression ();
1191 ++input_line_pointer
;
1192 while (*input_line_pointer
!= '"'
1193 && ! is_end_of_line
[(unsigned char) *input_line_pointer
])
1195 switch (*input_line_pointer
)
1197 case 'b': flags
|= SEC_ALLOC
; flags
&=~ SEC_LOAD
; break;
1198 case 'n': flags
&=~ SEC_LOAD
; break;
1200 case 'w': flags
&=~ SEC_READONLY
; break;
1201 case 'x': flags
|= SEC_CODE
; break;
1203 case 'i': /* STYP_INFO */
1204 case 'l': /* STYP_LIB */
1205 case 'o': /* STYP_OVER */
1206 as_warn ("unsupported section attribute '%c'",
1207 *input_line_pointer
);
1211 as_warn("unknown section attribute '%c'",
1212 *input_line_pointer
);
1215 ++input_line_pointer
;
1217 if (*input_line_pointer
== '"')
1218 ++input_line_pointer
;
1222 sec
= subseg_new (name
, (subsegT
) exp
);
1224 if (flags
!= SEC_NO_FLAGS
)
1226 if (! bfd_set_section_flags (stdoutput
, sec
, flags
))
1227 as_warn ("error setting flags for \"%s\": %s",
1228 bfd_section_name (stdoutput
, sec
),
1229 bfd_errmsg (bfd_get_error ()));
1234 coff_adjust_symtab ()
1236 if (symbol_rootP
== NULL
1237 || S_GET_STORAGE_CLASS (symbol_rootP
) != C_FILE
)
1239 assert (previous_file_symbol
== 0);
1240 c_dot_file_symbol ("fake");
1245 coff_frob_section (sec
)
1251 bfd_vma size
, n_entries
, mask
;
1253 /* The COFF back end in BFD requires that all section sizes be
1254 rounded up to multiples of the corresponding section alignments.
1255 Seems kinda silly to me, but that's the way it is. */
1256 size
= bfd_get_section_size_before_reloc (sec
);
1257 mask
= ((bfd_vma
) 1 << (bfd_vma
) sec
->alignment_power
) - 1;
1260 size
= (size
+ mask
) & ~mask
;
1261 bfd_set_section_size (stdoutput
, sec
, size
);
1264 /* If the section size is non-zero, the section symbol needs an aux
1265 entry associated with it, indicating the size. We don't know
1266 all the values yet; coff_frob_symbol will fill them in later. */
1269 symbolS
*secsym
= section_symbol (sec
);
1271 S_SET_STORAGE_CLASS (secsym
, C_STAT
);
1272 S_SET_NUMBER_AUXILIARY (secsym
, 1);
1273 SF_SET_STATICS (secsym
);
1274 SA_SET_SCN_SCNLEN (secsym
, size
);
1277 /* @@ these should be in a "stabs.h" file, or maybe as.h */
1278 #ifndef STAB_SECTION_NAME
1279 #define STAB_SECTION_NAME ".stab"
1281 #ifndef STAB_STRING_SECTION_NAME
1282 #define STAB_STRING_SECTION_NAME ".stabstr"
1284 if (strcmp (STAB_STRING_SECTION_NAME
, sec
->name
))
1288 sec
= subseg_get (STAB_SECTION_NAME
, 0);
1289 /* size is already rounded up, since other section will be listed first */
1290 size
= bfd_get_section_size_before_reloc (strsec
);
1292 n_entries
= bfd_get_section_size_before_reloc (sec
) / 12 - 1;
1294 /* Find first non-empty frag. It should be large enough. */
1295 fragp
= seg_info (sec
)->frchainP
->frch_root
;
1296 while (fragp
&& fragp
->fr_fix
== 0)
1297 fragp
= fragp
->fr_next
;
1298 assert (fragp
!= 0 && fragp
->fr_fix
>= 12);
1300 /* Store the values. */
1301 p
= fragp
->fr_literal
;
1302 bfd_h_put_16 (stdoutput
, n_entries
, (bfd_byte
*) p
+ 6);
1303 bfd_h_put_32 (stdoutput
, size
, (bfd_byte
*) p
+ 8);
1307 obj_coff_init_stab_section (seg
)
1313 unsigned int stroff
;
1315 /* Make space for this first symbol. */
1319 as_where (&file
, (unsigned int *) NULL
);
1320 stabstr_name
= (char *) alloca (strlen (seg
->name
) + 4);
1321 strcpy (stabstr_name
, seg
->name
);
1322 strcat (stabstr_name
, "str");
1323 stroff
= get_stab_string_offset (file
, stabstr_name
);
1325 md_number_to_chars (p
, stroff
, 4);
1334 return ((s
== NULL
) ? "(NULL)" : S_GET_NAME (s
));
1342 for (symbolP
= symbol_rootP
; symbolP
; symbolP
= symbol_next (symbolP
))
1344 printf("0x%lx: \"%s\" type = %ld, class = %d, segment = %d\n",
1345 (unsigned long) symbolP
,
1346 S_GET_NAME(symbolP
),
1347 (long) S_GET_DATA_TYPE(symbolP
),
1348 S_GET_STORAGE_CLASS(symbolP
),
1349 (int) S_GET_SEGMENT(symbolP
));
1355 #else /* not BFD_ASSEMBLER */
1358 /* This is needed because we include internal bfd things. */
1362 #include "libcoff.h"
1364 /* The NOP_OPCODE is for the alignment fill value. Fill with nop so
1365 that we can stick sections together without causing trouble. */
1367 #define NOP_OPCODE 0x00
1370 /* The zeroes if symbol name is longer than 8 chars */
1371 #define S_SET_ZEROES(s,v) ((s)->sy_symbol.ost_entry.n_zeroes = (v))
1373 #define MIN(a,b) ((a) < (b)? (a) : (b))
1374 /* This vector is used to turn an internal segment into a section #
1375 suitable for insertion into a coff symbol table
1378 const short seg_N_TYPE
[] =
1379 { /* in: segT out: N_TYPE bits */
1391 C_UNDEF_SECTION
, /* SEG_UNKNOWN */
1392 C_UNDEF_SECTION
, /* SEG_GOOF */
1393 C_UNDEF_SECTION
, /* SEG_EXPR */
1394 C_DEBUG_SECTION
, /* SEG_DEBUG */
1395 C_NTV_SECTION
, /* SEG_NTV */
1396 C_PTV_SECTION
, /* SEG_PTV */
1397 C_REGISTER_SECTION
, /* SEG_REGISTER */
1400 int function_lineoff
= -1; /* Offset in line#s where the last function
1401 started (the odd entry for line #0) */
1403 static symbolS
*last_line_symbol
;
1405 /* Add 4 to the real value to get the index and compensate the
1406 negatives. This vector is used by S_GET_SEGMENT to turn a coff
1407 section number into a segment number
1409 static symbolS
*previous_file_symbol
;
1410 void c_symbol_merge ();
1411 static int line_base
;
1413 symbolS
*c_section_symbol ();
1416 static void fixup_segment
PARAMS ((segment_info_type
*segP
,
1417 segT this_segment_type
));
1420 static void fixup_mdeps
PARAMS ((fragS
*,
1425 static void fill_section
PARAMS ((bfd
* abfd
,
1430 static int c_line_new
PARAMS ((symbolS
* symbol
, long paddr
,
1435 static void w_symbols
PARAMS ((bfd
* abfd
, char *where
,
1436 symbolS
* symbol_rootP
));
1438 static void adjust_stab_section
PARAMS ((bfd
*abfd
, segT seg
));
1440 static void obj_coff_lcomm
PARAMS ((int));
1441 static void obj_coff_text
PARAMS ((int));
1442 static void obj_coff_data
PARAMS ((int));
1443 static void obj_coff_bss
PARAMS ((int));
1444 static void obj_coff_ident
PARAMS ((int));
1445 void obj_coff_section
PARAMS ((int));
1449 We allow more than just the standard 3 sections, infact, we allow
1450 10 sections, (though the usual three have to be there).
1452 This structure performs the mappings for us:
1463 static const seg_info_type seg_info_off_by_4
[N_SEG
] =
1494 #define SEG_INFO_FROM_SECTION_NUMBER(x) (seg_info_off_by_4[(x)+4])
1496 static relax_addressT
1497 relax_align (address
, alignment
)
1498 relax_addressT address
;
1501 relax_addressT mask
;
1502 relax_addressT new_address
;
1504 mask
= ~((~0) << alignment
);
1505 new_address
= (address
+ mask
) & (~mask
);
1506 return (new_address
- address
);
1514 return SEG_INFO_FROM_SECTION_NUMBER (x
->sy_symbol
.ost_entry
.n_scnum
).seg_t
;
1519 /* calculate the size of the frag chain and fill in the section header
1520 to contain all of it, also fill in the addr of the sections */
1522 size_section (abfd
, idx
)
1527 unsigned int size
= 0;
1528 fragS
*frag
= segment_info
[idx
].frchainP
->frch_root
;
1531 size
= frag
->fr_address
;
1532 if (frag
->fr_address
!= size
)
1534 fprintf (stderr
, "Out of step\n");
1535 size
= frag
->fr_address
;
1538 switch (frag
->fr_type
)
1540 #ifdef TC_COFF_SIZEMACHDEP
1541 case rs_machine_dependent
:
1542 size
+= TC_COFF_SIZEMACHDEP (frag
);
1546 assert (frag
->fr_symbol
== 0);
1549 size
+= frag
->fr_fix
;
1550 size
+= frag
->fr_offset
* frag
->fr_var
;
1553 size
+= frag
->fr_fix
;
1554 size
+= relax_align (size
, frag
->fr_offset
);
1557 BAD_CASE (frag
->fr_type
);
1560 frag
= frag
->fr_next
;
1562 segment_info
[idx
].scnhdr
.s_size
= size
;
1568 count_entries_in_chain (idx
)
1571 unsigned int nrelocs
;
1574 /* Count the relocations */
1575 fixup_ptr
= segment_info
[idx
].fix_root
;
1577 while (fixup_ptr
!= (fixS
*) NULL
)
1579 if (TC_COUNT_RELOC (fixup_ptr
))
1582 if (fixup_ptr
->fx_r_type
== RELOC_CONSTH
)
1591 fixup_ptr
= fixup_ptr
->fx_next
;
1596 /* output all the relocations for a section */
1598 do_relocs_for (abfd
, h
, file_cursor
)
1601 unsigned long *file_cursor
;
1603 unsigned int nrelocs
;
1605 unsigned long reloc_start
= *file_cursor
;
1607 for (idx
= SEG_E0
; idx
< SEG_E9
; idx
++)
1609 if (segment_info
[idx
].scnhdr
.s_name
[0])
1611 struct external_reloc
*ext_ptr
;
1612 struct external_reloc
*external_reloc_vec
;
1613 unsigned int external_reloc_size
;
1614 unsigned int base
= segment_info
[idx
].scnhdr
.s_paddr
;
1615 fixS
*fix_ptr
= segment_info
[idx
].fix_root
;
1616 nrelocs
= count_entries_in_chain (idx
);
1619 /* Bypass this stuff if no relocs. This also incidentally
1620 avoids a SCO bug, where free(malloc(0)) tends to crash. */
1622 external_reloc_size
= nrelocs
* RELSZ
;
1623 external_reloc_vec
=
1624 (struct external_reloc
*) malloc (external_reloc_size
);
1626 ext_ptr
= external_reloc_vec
;
1628 /* Fill in the internal coff style reloc struct from the
1629 internal fix list. */
1632 struct internal_reloc intr
;
1634 /* Only output some of the relocations */
1635 if (TC_COUNT_RELOC (fix_ptr
))
1637 #ifdef TC_RELOC_MANGLE
1638 TC_RELOC_MANGLE (&segment_info
[idx
], fix_ptr
, &intr
,
1643 symbolS
*symbol_ptr
= fix_ptr
->fx_addsy
;
1645 intr
.r_type
= TC_COFF_FIX2RTYPE (fix_ptr
);
1647 base
+ fix_ptr
->fx_frag
->fr_address
+ fix_ptr
->fx_where
;
1649 #ifdef TC_KEEP_FX_OFFSET
1650 intr
.r_offset
= fix_ptr
->fx_offset
;
1655 /* Turn the segment of the symbol into an offset. */
1658 dot
= segment_info
[S_GET_SEGMENT (symbol_ptr
)].dot
;
1661 intr
.r_symndx
= dot
->sy_number
;
1665 intr
.r_symndx
= symbol_ptr
->sy_number
;
1675 (void) bfd_coff_swap_reloc_out (abfd
, &intr
, ext_ptr
);
1678 #if defined(TC_A29K)
1680 /* The 29k has a special kludge for the high 16 bit
1681 reloc. Two relocations are emited, R_IHIHALF,
1682 and R_IHCONST. The second one doesn't contain a
1683 symbol, but uses the value for offset. */
1685 if (intr
.r_type
== R_IHIHALF
)
1687 /* now emit the second bit */
1688 intr
.r_type
= R_IHCONST
;
1689 intr
.r_symndx
= fix_ptr
->fx_addnumber
;
1690 (void) bfd_coff_swap_reloc_out (abfd
, &intr
, ext_ptr
);
1696 fix_ptr
= fix_ptr
->fx_next
;
1699 /* Write out the reloc table */
1700 bfd_write ((PTR
) external_reloc_vec
, 1, external_reloc_size
,
1702 free (external_reloc_vec
);
1704 /* Fill in section header info. */
1705 segment_info
[idx
].scnhdr
.s_relptr
= *file_cursor
;
1706 *file_cursor
+= external_reloc_size
;
1707 segment_info
[idx
].scnhdr
.s_nreloc
= nrelocs
;
1712 segment_info
[idx
].scnhdr
.s_relptr
= 0;
1716 /* Set relocation_size field in file headers */
1717 H_SET_RELOCATION_SIZE (h
, *file_cursor
- reloc_start
, 0);
1721 /* run through a frag chain and write out the data to go with it, fill
1722 in the scnhdrs with the info on the file postions
1725 fill_section (abfd
, h
, file_cursor
)
1728 unsigned long *file_cursor
;
1732 unsigned int paddr
= 0;
1734 for (i
= SEG_E0
; i
< SEG_UNKNOWN
; i
++)
1736 unsigned int offset
= 0;
1737 struct internal_scnhdr
*s
= &(segment_info
[i
].scnhdr
);
1743 fragS
*frag
= segment_info
[i
].frchainP
->frch_root
;
1750 buffer
= xmalloc (s
->s_size
);
1751 s
->s_scnptr
= *file_cursor
;
1753 know (s
->s_paddr
== paddr
);
1755 if (strcmp (s
->s_name
, ".text") == 0)
1756 s
->s_flags
|= STYP_TEXT
;
1757 else if (strcmp (s
->s_name
, ".data") == 0)
1758 s
->s_flags
|= STYP_DATA
;
1759 else if (strcmp (s
->s_name
, ".bss") == 0)
1762 s
->s_flags
|= STYP_BSS
;
1764 /* @@ Should make the i386 and a29k coff targets define
1765 COFF_NOLOAD_PROBLEM, and have only one test here. */
1768 #ifndef COFF_NOLOAD_PROBLEM
1769 /* Apparently the SVR3 linker (and exec syscall) and UDI
1770 mondfe progrem are confused by noload sections. */
1771 s
->s_flags
|= STYP_NOLOAD
;
1776 else if (strcmp (s
->s_name
, ".lit") == 0)
1777 s
->s_flags
= STYP_LIT
| STYP_TEXT
;
1778 else if (strcmp (s
->s_name
, ".init") == 0)
1779 s
->s_flags
|= STYP_TEXT
;
1780 else if (strcmp (s
->s_name
, ".fini") == 0)
1781 s
->s_flags
|= STYP_TEXT
;
1782 else if (strncmp (s
->s_name
, ".comment", 8) == 0)
1783 s
->s_flags
|= STYP_INFO
;
1787 unsigned int fill_size
;
1788 switch (frag
->fr_type
)
1790 case rs_machine_dependent
:
1793 memcpy (buffer
+ frag
->fr_address
,
1795 (unsigned int) frag
->fr_fix
);
1796 offset
+= frag
->fr_fix
;
1801 assert (frag
->fr_symbol
== 0);
1807 memcpy (buffer
+ frag
->fr_address
,
1809 (unsigned int) frag
->fr_fix
);
1810 offset
+= frag
->fr_fix
;
1813 fill_size
= frag
->fr_var
;
1814 if (fill_size
&& frag
->fr_offset
> 0)
1817 unsigned int off
= frag
->fr_fix
;
1818 for (count
= frag
->fr_offset
; count
; count
--)
1820 if (fill_size
+ frag
->fr_address
+ off
<= s
->s_size
)
1822 memcpy (buffer
+ frag
->fr_address
+ off
,
1823 frag
->fr_literal
+ frag
->fr_fix
,
1826 offset
+= fill_size
;
1831 case rs_broken_word
:
1836 frag
= frag
->fr_next
;
1841 if (s
->s_scnptr
!= 0)
1843 bfd_write (buffer
, s
->s_size
, 1, abfd
);
1844 *file_cursor
+= s
->s_size
;
1853 /* Coff file generation & utilities */
1856 coff_header_append (abfd
, h
)
1864 bfd_seek (abfd
, 0, 0);
1866 #ifndef OBJ_COFF_OMIT_OPTIONAL_HEADER
1867 H_SET_MAGIC_NUMBER (h
, COFF_MAGIC
);
1868 H_SET_VERSION_STAMP (h
, 0);
1869 H_SET_ENTRY_POINT (h
, 0);
1870 H_SET_TEXT_START (h
, segment_info
[SEG_E0
].frchainP
->frch_root
->fr_address
);
1871 H_SET_DATA_START (h
, segment_info
[SEG_E1
].frchainP
->frch_root
->fr_address
);
1872 H_SET_SIZEOF_OPTIONAL_HEADER (h
, bfd_coff_swap_aouthdr_out(abfd
, &h
->aouthdr
,
1874 #else /* defined (OBJ_COFF_OMIT_OPTIONAL_HEADER) */
1875 H_SET_SIZEOF_OPTIONAL_HEADER (h
, 0);
1876 #endif /* defined (OBJ_COFF_OMIT_OPTIONAL_HEADER) */
1878 i
= bfd_coff_swap_filehdr_out (abfd
, &h
->filehdr
, buffer
);
1880 bfd_write (buffer
, i
, 1, abfd
);
1881 bfd_write (buffero
, H_GET_SIZEOF_OPTIONAL_HEADER (h
), 1, abfd
);
1883 for (i
= SEG_E0
; i
< SEG_E9
; i
++)
1885 if (segment_info
[i
].scnhdr
.s_name
[0])
1888 bfd_coff_swap_scnhdr_out (abfd
,
1889 &(segment_info
[i
].scnhdr
),
1892 as_bad ("bfd_coff_swap_scnhdr_out failed");
1893 bfd_write (buffer
, size
, 1, abfd
);
1900 symbol_to_chars (abfd
, where
, symbolP
)
1905 unsigned int numaux
= symbolP
->sy_symbol
.ost_entry
.n_numaux
;
1909 /* Turn any symbols with register attributes into abs symbols */
1910 if (S_GET_SEGMENT (symbolP
) == reg_section
)
1912 S_SET_SEGMENT (symbolP
, absolute_section
);
1914 /* At the same time, relocate all symbols to their output value */
1916 val
= (segment_info
[S_GET_SEGMENT (symbolP
)].scnhdr
.s_paddr
1917 + S_GET_VALUE (symbolP
));
1919 S_SET_VALUE (symbolP
, val
);
1921 symbolP
->sy_symbol
.ost_entry
.n_value
= val
;
1923 where
+= bfd_coff_swap_sym_out (abfd
, &symbolP
->sy_symbol
.ost_entry
,
1926 for (i
= 0; i
< numaux
; i
++)
1928 where
+= bfd_coff_swap_aux_out (abfd
,
1929 &symbolP
->sy_symbol
.ost_auxent
[i
],
1930 S_GET_DATA_TYPE (symbolP
),
1931 S_GET_STORAGE_CLASS (symbolP
),
1939 obj_symbol_new_hook (symbolP
)
1942 char underscore
= 0; /* Symbol has leading _ */
1944 /* Effective symbol */
1945 /* Store the pointer in the offset. */
1946 S_SET_ZEROES (symbolP
, 0L);
1947 S_SET_DATA_TYPE (symbolP
, T_NULL
);
1948 S_SET_STORAGE_CLASS (symbolP
, 0);
1949 S_SET_NUMBER_AUXILIARY (symbolP
, 0);
1950 /* Additional information */
1951 symbolP
->sy_symbol
.ost_flags
= 0;
1952 /* Auxiliary entries */
1953 memset ((char *) &symbolP
->sy_symbol
.ost_auxent
[0], 0, AUXESZ
);
1955 if (S_IS_STRING (symbolP
))
1956 SF_SET_STRING (symbolP
);
1957 if (!underscore
&& S_IS_LOCAL (symbolP
))
1958 SF_SET_LOCAL (symbolP
);
1962 * Handle .ln directives.
1966 obj_coff_ln (appline
)
1971 if (! appline
&& def_symbol_in_progress
!= NULL
)
1973 as_warn (".ln pseudo-op inside .def/.endef: ignored.");
1974 demand_empty_rest_of_line ();
1976 } /* wrong context */
1978 l
= get_absolute_expression ();
1979 c_line_new (0, frag_now_fix (), l
, frag_now
);
1988 listing_source_line ((unsigned int) l
);
1993 demand_empty_rest_of_line ();
1999 * Handle .def directives.
2001 * One might ask : why can't we symbol_new if the symbol does not
2002 * already exist and fill it with debug information. Because of
2003 * the C_EFCN special symbol. It would clobber the value of the
2004 * function symbol before we have a chance to notice that it is
2005 * a C_EFCN. And a second reason is that the code is more clear this
2006 * way. (at least I think it is :-).
2010 #define SKIP_SEMI_COLON() while (*input_line_pointer++ != ';')
2011 #define SKIP_WHITESPACES() while (*input_line_pointer == ' ' || \
2012 *input_line_pointer == '\t') \
2013 input_line_pointer++;
2019 char name_end
; /* Char after the end of name */
2020 char *symbol_name
; /* Name of the debug symbol */
2021 char *symbol_name_copy
; /* Temporary copy of the name */
2022 unsigned int symbol_name_length
;
2024 if (def_symbol_in_progress
!= NULL
)
2026 as_warn (".def pseudo-op used inside of .def/.endef: ignored.");
2027 demand_empty_rest_of_line ();
2029 } /* if not inside .def/.endef */
2031 SKIP_WHITESPACES ();
2033 def_symbol_in_progress
= (symbolS
*) obstack_alloc (¬es
, sizeof (*def_symbol_in_progress
));
2034 memset (def_symbol_in_progress
, 0, sizeof (*def_symbol_in_progress
));
2036 symbol_name
= input_line_pointer
;
2037 name_end
= get_symbol_end ();
2038 symbol_name_length
= strlen (symbol_name
);
2039 symbol_name_copy
= xmalloc (symbol_name_length
+ 1);
2040 strcpy (symbol_name_copy
, symbol_name
);
2042 /* Initialize the new symbol */
2043 #ifdef STRIP_UNDERSCORE
2044 S_SET_NAME (def_symbol_in_progress
, (*symbol_name_copy
== '_'
2045 ? symbol_name_copy
+ 1
2046 : symbol_name_copy
));
2047 #else /* STRIP_UNDERSCORE */
2048 S_SET_NAME (def_symbol_in_progress
, symbol_name_copy
);
2049 #endif /* STRIP_UNDERSCORE */
2050 /* free(symbol_name_copy); */
2051 def_symbol_in_progress
->sy_name_offset
= (unsigned long) ~0;
2052 def_symbol_in_progress
->sy_number
= ~0;
2053 def_symbol_in_progress
->sy_frag
= &zero_address_frag
;
2054 S_SET_VALUE (def_symbol_in_progress
, 0);
2056 if (S_IS_STRING (def_symbol_in_progress
))
2057 SF_SET_STRING (def_symbol_in_progress
);
2059 *input_line_pointer
= name_end
;
2061 demand_empty_rest_of_line ();
2064 unsigned int dim_index
;
2068 obj_coff_endef (ignore
)
2071 symbolS
*symbolP
= 0;
2072 /* DIM BUG FIX sac@cygnus.com */
2074 if (def_symbol_in_progress
== NULL
)
2076 as_warn (".endef pseudo-op used outside of .def/.endef: ignored.");
2077 demand_empty_rest_of_line ();
2079 } /* if not inside .def/.endef */
2081 /* Set the section number according to storage class. */
2082 switch (S_GET_STORAGE_CLASS (def_symbol_in_progress
))
2087 SF_SET_TAG (def_symbol_in_progress
);
2088 /* intentional fallthrough */
2091 SF_SET_DEBUG (def_symbol_in_progress
);
2092 S_SET_SEGMENT (def_symbol_in_progress
, SEG_DEBUG
);
2096 SF_SET_LOCAL (def_symbol_in_progress
); /* Do not emit this symbol. */
2097 /* intentional fallthrough */
2099 SF_SET_PROCESS (def_symbol_in_progress
); /* Will need processing before writing */
2100 /* intentional fallthrough */
2102 S_SET_SEGMENT (def_symbol_in_progress
, SEG_E0
);
2104 if (strcmp (S_GET_NAME (def_symbol_in_progress
), ".bf") == 0)
2106 if (function_lineoff
< 0)
2108 fprintf (stderr
, "`.bf' symbol without preceding function\n");
2109 } /* missing function symbol */
2110 SA_GET_SYM_LNNOPTR (last_line_symbol
) = function_lineoff
;
2112 SF_SET_PROCESS (last_line_symbol
);
2113 function_lineoff
= -1;
2115 /* Value is always set to . */
2116 def_symbol_in_progress
->sy_frag
= frag_now
;
2117 S_SET_VALUE (def_symbol_in_progress
, (valueT
) frag_now_fix ());
2122 #endif /* C_AUTOARG */
2132 SF_SET_DEBUG (def_symbol_in_progress
);
2133 S_SET_SEGMENT (def_symbol_in_progress
, absolute_section
);
2139 /* Valid but set somewhere else (s_comm, s_lcomm, colon) */
2145 as_warn ("unexpected storage class %d", S_GET_STORAGE_CLASS (def_symbol_in_progress
));
2147 } /* switch on storage class */
2149 /* Now that we have built a debug symbol, try to find if we should
2150 merge with an existing symbol or not. If a symbol is C_EFCN or
2151 absolute_section or untagged SEG_DEBUG it never merges. We also
2152 don't merge labels, which are in a different namespace, nor
2153 symbols which have not yet been defined since they are typically
2154 unique, nor do we merge tags with non-tags. */
2156 /* Two cases for functions. Either debug followed by definition or
2157 definition followed by debug. For definition first, we will
2158 merge the debug symbol into the definition. For debug first, the
2159 lineno entry MUST point to the definition function or else it
2160 will point off into space when crawl_symbols() merges the debug
2161 symbol into the real symbol. Therefor, let's presume the debug
2162 symbol is a real function reference. */
2164 /* FIXME-SOON If for some reason the definition label/symbol is
2165 never seen, this will probably leave an undefined symbol at link
2168 if (S_GET_STORAGE_CLASS (def_symbol_in_progress
) == C_EFCN
2169 || S_GET_STORAGE_CLASS (def_symbol_in_progress
) == C_LABEL
2170 || (S_GET_SEGMENT (def_symbol_in_progress
) == SEG_DEBUG
2171 && !SF_GET_TAG (def_symbol_in_progress
))
2172 || S_GET_SEGMENT (def_symbol_in_progress
) == absolute_section
2173 || def_symbol_in_progress
->sy_value
.X_op
!= O_constant
2174 || (symbolP
= symbol_find_base (S_GET_NAME (def_symbol_in_progress
), DO_NOT_STRIP
)) == NULL
2175 || (SF_GET_TAG (def_symbol_in_progress
) != SF_GET_TAG (symbolP
)))
2177 symbol_append (def_symbol_in_progress
, symbol_lastP
, &symbol_rootP
,
2182 /* This symbol already exists, merge the newly created symbol
2183 into the old one. This is not mandatory. The linker can
2184 handle duplicate symbols correctly. But I guess that it save
2185 a *lot* of space if the assembly file defines a lot of
2188 /* The debug entry (def_symbol_in_progress) is merged into the
2189 previous definition. */
2191 c_symbol_merge (def_symbol_in_progress
, symbolP
);
2192 /* FIXME-SOON Should *def_symbol_in_progress be free'd? xoxorich. */
2193 def_symbol_in_progress
= symbolP
;
2195 if (SF_GET_FUNCTION (def_symbol_in_progress
)
2196 || SF_GET_TAG (def_symbol_in_progress
))
2198 /* For functions, and tags, the symbol *must* be where the
2199 debug symbol appears. Move the existing symbol to the
2201 /* If it already is at the end of the symbol list, do nothing */
2202 if (def_symbol_in_progress
!= symbol_lastP
)
2204 symbol_remove (def_symbol_in_progress
, &symbol_rootP
,
2206 symbol_append (def_symbol_in_progress
, symbol_lastP
,
2207 &symbol_rootP
, &symbol_lastP
);
2208 } /* if not already in place */
2210 } /* normal or mergable */
2212 if (SF_GET_TAG (def_symbol_in_progress
)
2213 && symbol_find_base (S_GET_NAME (def_symbol_in_progress
), DO_NOT_STRIP
) == NULL
)
2215 tag_insert (S_GET_NAME (def_symbol_in_progress
), def_symbol_in_progress
);
2218 if (SF_GET_FUNCTION (def_symbol_in_progress
))
2220 know (sizeof (def_symbol_in_progress
) <= sizeof (long));
2222 = c_line_new (def_symbol_in_progress
, 0, 0, &zero_address_frag
);
2224 SF_SET_PROCESS (def_symbol_in_progress
);
2226 if (symbolP
== NULL
)
2228 /* That is, if this is the first time we've seen the
2230 symbol_table_insert (def_symbol_in_progress
);
2231 } /* definition follows debug */
2232 } /* Create the line number entry pointing to the function being defined */
2234 def_symbol_in_progress
= NULL
;
2235 demand_empty_rest_of_line ();
2239 obj_coff_dim (ignore
)
2244 if (def_symbol_in_progress
== NULL
)
2246 as_warn (".dim pseudo-op used outside of .def/.endef: ignored.");
2247 demand_empty_rest_of_line ();
2249 } /* if not inside .def/.endef */
2251 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
2253 for (dim_index
= 0; dim_index
< DIMNUM
; dim_index
++)
2255 SKIP_WHITESPACES ();
2256 SA_SET_SYM_DIMEN (def_symbol_in_progress
, dim_index
,
2257 get_absolute_expression ());
2259 switch (*input_line_pointer
)
2262 input_line_pointer
++;
2266 as_warn ("badly formed .dim directive ignored");
2267 /* intentional fallthrough */
2275 demand_empty_rest_of_line ();
2279 obj_coff_line (ignore
)
2285 if (def_symbol_in_progress
== NULL
)
2291 name
= S_GET_NAME (def_symbol_in_progress
);
2292 this_base
= get_absolute_expression ();
2294 /* Only .bf symbols indicate the use of a new base line number; the
2295 line numbers associated with .ef, .bb, .eb are relative to the
2296 start of the containing function. */
2297 if (!strcmp (".bf", name
))
2299 #if 0 /* XXX Can we ever have line numbers going backwards? */
2300 if (this_base
> line_base
)
2303 line_base
= this_base
;
2311 listing_source_line ((unsigned int) line_base
);
2317 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
2318 SA_SET_SYM_LNNO (def_symbol_in_progress
, this_base
);
2320 demand_empty_rest_of_line ();
2324 obj_coff_size (ignore
)
2327 if (def_symbol_in_progress
== NULL
)
2329 as_warn (".size pseudo-op used outside of .def/.endef ignored.");
2330 demand_empty_rest_of_line ();
2332 } /* if not inside .def/.endef */
2334 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
2335 SA_SET_SYM_SIZE (def_symbol_in_progress
, get_absolute_expression ());
2336 demand_empty_rest_of_line ();
2340 obj_coff_scl (ignore
)
2343 if (def_symbol_in_progress
== NULL
)
2345 as_warn (".scl pseudo-op used outside of .def/.endef ignored.");
2346 demand_empty_rest_of_line ();
2348 } /* if not inside .def/.endef */
2350 S_SET_STORAGE_CLASS (def_symbol_in_progress
, get_absolute_expression ());
2351 demand_empty_rest_of_line ();
2355 obj_coff_tag (ignore
)
2361 if (def_symbol_in_progress
== NULL
)
2363 as_warn (".tag pseudo-op used outside of .def/.endef ignored.");
2364 demand_empty_rest_of_line ();
2368 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
2369 symbol_name
= input_line_pointer
;
2370 name_end
= get_symbol_end ();
2372 /* Assume that the symbol referred to by .tag is always defined.
2373 This was a bad assumption. I've added find_or_make. xoxorich. */
2374 SA_SET_SYM_TAGNDX (def_symbol_in_progress
,
2375 (long) tag_find_or_make (symbol_name
));
2376 if (SA_GET_SYM_TAGNDX (def_symbol_in_progress
) == 0L)
2378 as_warn ("tag not found for .tag %s", symbol_name
);
2381 SF_SET_TAGGED (def_symbol_in_progress
);
2382 *input_line_pointer
= name_end
;
2384 demand_empty_rest_of_line ();
2388 obj_coff_type (ignore
)
2391 if (def_symbol_in_progress
== NULL
)
2393 as_warn (".type pseudo-op used outside of .def/.endef ignored.");
2394 demand_empty_rest_of_line ();
2396 } /* if not inside .def/.endef */
2398 S_SET_DATA_TYPE (def_symbol_in_progress
, get_absolute_expression ());
2400 if (ISFCN (S_GET_DATA_TYPE (def_symbol_in_progress
)) &&
2401 S_GET_STORAGE_CLASS (def_symbol_in_progress
) != C_TPDEF
)
2403 SF_SET_FUNCTION (def_symbol_in_progress
);
2404 } /* is a function */
2406 demand_empty_rest_of_line ();
2410 obj_coff_val (ignore
)
2413 if (def_symbol_in_progress
== NULL
)
2415 as_warn (".val pseudo-op used outside of .def/.endef ignored.");
2416 demand_empty_rest_of_line ();
2418 } /* if not inside .def/.endef */
2420 if (is_name_beginner (*input_line_pointer
))
2422 char *symbol_name
= input_line_pointer
;
2423 char name_end
= get_symbol_end ();
2425 if (!strcmp (symbol_name
, "."))
2427 def_symbol_in_progress
->sy_frag
= frag_now
;
2428 S_SET_VALUE (def_symbol_in_progress
, (valueT
) frag_now_fix ());
2429 /* If the .val is != from the .def (e.g. statics) */
2431 else if (strcmp (S_GET_NAME (def_symbol_in_progress
), symbol_name
))
2433 def_symbol_in_progress
->sy_value
.X_op
= O_symbol
;
2434 def_symbol_in_progress
->sy_value
.X_add_symbol
=
2435 symbol_find_or_make (symbol_name
);
2436 def_symbol_in_progress
->sy_value
.X_op_symbol
= NULL
;
2437 def_symbol_in_progress
->sy_value
.X_add_number
= 0;
2439 /* If the segment is undefined when the forward reference is
2440 resolved, then copy the segment id from the forward
2442 SF_SET_GET_SEGMENT (def_symbol_in_progress
);
2444 /* FIXME: gcc can generate address expressions
2445 here in unusual cases (search for "obscure"
2446 in sdbout.c). We just ignore the offset
2447 here, thus generating incorrect debugging
2448 information. We ignore the rest of the
2451 /* Otherwise, it is the name of a non debug symbol and
2452 its value will be calculated later. */
2453 *input_line_pointer
= name_end
;
2455 /* FIXME: this is to avoid an error message in the
2456 FIXME case mentioned just above. */
2457 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
2458 ++input_line_pointer
;
2462 S_SET_VALUE (def_symbol_in_progress
,
2463 (valueT
) get_absolute_expression ());
2464 } /* if symbol based */
2466 demand_empty_rest_of_line ();
2470 obj_read_begin_hook ()
2472 /* These had better be the same. Usually 18 bytes. */
2474 know (sizeof (SYMENT
) == sizeof (AUXENT
));
2475 know (SYMESZ
== AUXESZ
);
2480 /* This function runs through the symbol table and puts all the
2481 externals onto another chain */
2483 /* The chain of globals. */
2484 symbolS
*symbol_globalP
;
2485 symbolS
*symbol_global_lastP
;
2487 /* The chain of externals */
2488 symbolS
*symbol_externP
;
2489 symbolS
*symbol_extern_lastP
;
2492 symbolS
*last_functionP
;
2499 unsigned int symbol_number
= 0;
2500 unsigned int last_file_symno
= 0;
2502 struct filename_list
*filename_list_scan
= filename_list_head
;
2504 for (symbolP
= symbol_rootP
;
2506 symbolP
= symbolP
? symbol_next (symbolP
) : symbol_rootP
)
2508 if (symbolP
->sy_mri_common
)
2510 if (S_GET_STORAGE_CLASS (symbolP
) == C_EXT
)
2511 as_bad ("%s: global symbols not supported in common sections",
2512 S_GET_NAME (symbolP
));
2513 symbol_remove (symbolP
, &symbol_rootP
, &symbol_lastP
);
2517 if (!SF_GET_DEBUG (symbolP
))
2519 /* Debug symbols do not need all this rubbish */
2520 symbolS
*real_symbolP
;
2522 /* L* and C_EFCN symbols never merge. */
2523 if (!SF_GET_LOCAL (symbolP
)
2524 && S_GET_STORAGE_CLASS (symbolP
) != C_LABEL
2525 && symbolP
->sy_value
.X_op
== O_constant
2526 && (real_symbolP
= symbol_find_base (S_GET_NAME (symbolP
), DO_NOT_STRIP
))
2527 && real_symbolP
!= symbolP
)
2529 /* FIXME-SOON: where do dups come from?
2530 Maybe tag references before definitions? xoxorich. */
2531 /* Move the debug data from the debug symbol to the
2532 real symbol. Do NOT do the oposite (i.e. move from
2533 real symbol to debug symbol and remove real symbol from the
2534 list.) Because some pointers refer to the real symbol
2535 whereas no pointers refer to the debug symbol. */
2536 c_symbol_merge (symbolP
, real_symbolP
);
2537 /* Replace the current symbol by the real one */
2538 /* The symbols will never be the last or the first
2539 because : 1st symbol is .file and 3 last symbols are
2540 .text, .data, .bss */
2541 symbol_remove (real_symbolP
, &symbol_rootP
, &symbol_lastP
);
2542 symbol_insert (real_symbolP
, symbolP
, &symbol_rootP
, &symbol_lastP
);
2543 symbol_remove (symbolP
, &symbol_rootP
, &symbol_lastP
);
2544 symbolP
= real_symbolP
;
2545 } /* if not local but dup'd */
2547 if (flag_readonly_data_in_text
&& (S_GET_SEGMENT (symbolP
) == SEG_E1
))
2549 S_SET_SEGMENT (symbolP
, SEG_E0
);
2550 } /* push data into text */
2552 resolve_symbol_value (symbolP
);
2554 if (S_GET_STORAGE_CLASS (symbolP
) == C_NULL
)
2556 if (!S_IS_DEFINED (symbolP
) && !SF_GET_LOCAL (symbolP
))
2558 S_SET_EXTERNAL (symbolP
);
2560 else if (S_GET_SEGMENT (symbolP
) == SEG_E0
)
2562 S_SET_STORAGE_CLASS (symbolP
, C_LABEL
);
2566 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
2570 /* Mainly to speed up if not -g */
2571 if (SF_GET_PROCESS (symbolP
))
2573 /* Handle the nested blocks auxiliary info. */
2574 if (S_GET_STORAGE_CLASS (symbolP
) == C_BLOCK
)
2576 if (!strcmp (S_GET_NAME (symbolP
), ".bb"))
2577 stack_push (block_stack
, (char *) &symbolP
);
2580 register symbolS
*begin_symbolP
;
2581 begin_symbolP
= *(symbolS
**) stack_pop (block_stack
);
2582 if (begin_symbolP
== (symbolS
*) 0)
2583 as_warn ("mismatched .eb");
2585 SA_SET_SYM_ENDNDX (begin_symbolP
, symbol_number
+ 2);
2588 /* If we are able to identify the type of a function, and we
2589 are out of a function (last_functionP == 0) then, the
2590 function symbol will be associated with an auxiliary
2592 if (last_functionP
== (symbolS
*) 0 &&
2593 SF_GET_FUNCTION (symbolP
))
2595 last_functionP
= symbolP
;
2597 if (S_GET_NUMBER_AUXILIARY (symbolP
) < 1)
2599 S_SET_NUMBER_AUXILIARY (symbolP
, 1);
2600 } /* make it at least 1 */
2602 /* Clobber possible stale .dim information. */
2604 /* Iffed out by steve - this fries the lnnoptr info too */
2605 bzero (symbolP
->sy_symbol
.ost_auxent
[0].x_sym
.x_fcnary
.x_ary
.x_dimen
,
2606 sizeof (symbolP
->sy_symbol
.ost_auxent
[0].x_sym
.x_fcnary
.x_ary
.x_dimen
));
2609 /* The C_FCN doesn't need any additional information. I
2610 don't even know if this is needed for sdb. But the
2611 standard assembler generates it, so... */
2612 if (S_GET_STORAGE_CLASS (symbolP
) == C_EFCN
)
2614 if (last_functionP
== (symbolS
*) 0)
2615 as_fatal ("C_EFCN symbol out of scope");
2616 SA_SET_SYM_FSIZE (last_functionP
,
2617 (long) (S_GET_VALUE (symbolP
) -
2618 S_GET_VALUE (last_functionP
)));
2619 SA_SET_SYM_ENDNDX (last_functionP
, symbol_number
);
2620 last_functionP
= (symbolS
*) 0;
2624 else if (SF_GET_TAG (symbolP
))
2626 /* First descriptor of a structure must point to
2627 the first slot after the structure description. */
2628 last_tagP
= symbolP
;
2631 else if (S_GET_STORAGE_CLASS (symbolP
) == C_EOS
)
2633 /* +2 take in account the current symbol */
2634 SA_SET_SYM_ENDNDX (last_tagP
, symbol_number
+ 2);
2636 else if (S_GET_STORAGE_CLASS (symbolP
) == C_FILE
)
2638 /* If the filename was too long to fit in the
2639 auxent, put it in the string table */
2640 if (SA_GET_FILE_FNAME_ZEROS (symbolP
) == 0)
2642 SA_SET_FILE_FNAME_OFFSET (symbolP
, string_byte_count
);
2643 string_byte_count
+= strlen (filename_list_scan
->filename
) + 1;
2644 filename_list_scan
= filename_list_scan
->next
;
2646 if (S_GET_VALUE (symbolP
))
2648 S_SET_VALUE (symbolP
, last_file_symno
);
2649 last_file_symno
= symbol_number
;
2650 } /* no one points at the first .file symbol */
2651 } /* if debug or tag or eos or file */
2653 /* We must put the external symbols apart. The loader
2654 does not bomb if we do not. But the references in
2655 the endndx field for a .bb symbol are not corrected
2656 if an external symbol is removed between .bb and .be.
2657 I.e in the following case :
2658 [20] .bb endndx = 22
2661 ld will move the symbol 21 to the end of the list but
2662 endndx will still be 22 instead of 21. */
2665 if (SF_GET_LOCAL (symbolP
))
2667 /* remove C_EFCN and LOCAL (L...) symbols */
2668 /* next pointer remains valid */
2669 symbol_remove (symbolP
, &symbol_rootP
, &symbol_lastP
);
2672 else if (!S_IS_DEFINED (symbolP
)
2673 && !S_IS_DEBUG (symbolP
)
2674 && !SF_GET_STATICS (symbolP
) &&
2675 S_GET_STORAGE_CLASS (symbolP
) == C_EXT
)
2676 { /* C_EXT && !SF_GET_FUNCTION(symbolP)) */
2677 /* if external, Remove from the list */
2678 symbolS
*hold
= symbol_previous (symbolP
);
2680 symbol_remove (symbolP
, &symbol_rootP
, &symbol_lastP
);
2681 symbol_clear_list_pointers (symbolP
);
2682 symbol_append (symbolP
, symbol_extern_lastP
, &symbol_externP
, &symbol_extern_lastP
);
2685 else if (! S_IS_DEBUG (symbolP
)
2686 && ! SF_GET_STATICS (symbolP
)
2687 && ! SF_GET_FUNCTION (symbolP
)
2688 && S_GET_STORAGE_CLASS (symbolP
) == C_EXT
)
2690 symbolS
*hold
= symbol_previous (symbolP
);
2692 /* The O'Reilly COFF book says that defined global symbols
2693 come at the end of the symbol table, just before
2694 undefined global symbols. */
2696 symbol_remove (symbolP
, &symbol_rootP
, &symbol_lastP
);
2697 symbol_clear_list_pointers (symbolP
);
2698 symbol_append (symbolP
, symbol_global_lastP
, &symbol_globalP
,
2699 &symbol_global_lastP
);
2704 if (SF_GET_STRING (symbolP
))
2706 symbolP
->sy_name_offset
= string_byte_count
;
2707 string_byte_count
+= strlen (S_GET_NAME (symbolP
)) + 1;
2711 symbolP
->sy_name_offset
= 0;
2712 } /* fix "long" names */
2714 symbolP
->sy_number
= symbol_number
;
2715 symbol_number
+= 1 + S_GET_NUMBER_AUXILIARY (symbolP
);
2716 } /* if local symbol */
2717 } /* traverse the symbol list */
2718 return symbol_number
;
2724 glue_symbols (head
, tail
)
2728 unsigned int symbol_number
= 0;
2731 for (symbolP
= *head
; *head
!= NULL
;)
2733 symbolS
*tmp
= *head
;
2736 symbol_remove (tmp
, head
, tail
);
2737 symbol_append (tmp
, symbol_lastP
, &symbol_rootP
, &symbol_lastP
);
2740 if (SF_GET_STRING (tmp
))
2742 tmp
->sy_name_offset
= string_byte_count
;
2743 string_byte_count
+= strlen (S_GET_NAME (tmp
)) + 1;
2747 tmp
->sy_name_offset
= 0;
2748 } /* fix "long" names */
2750 tmp
->sy_number
= symbol_number
;
2751 symbol_number
+= 1 + S_GET_NUMBER_AUXILIARY (tmp
);
2752 } /* append the entire extern chain */
2754 return symbol_number
;
2760 unsigned int symbol_number
= 0;
2763 for (symbolP
= symbol_rootP
; symbolP
; symbolP
=
2764 symbol_next (symbolP
))
2766 symbolP
->sy_number
= symbol_number
;
2770 if (SF_GET_TAGGED (symbolP
))
2774 ((symbolS
*) SA_GET_SYM_TAGNDX (symbolP
))->sy_number
);
2777 symbol_number
+= 1 + S_GET_NUMBER_AUXILIARY (symbolP
);
2779 return symbol_number
;
2784 crawl_symbols (h
, abfd
)
2790 /* Initialize the stack used to keep track of the matching .bb .be */
2792 block_stack
= stack_init (512, sizeof (symbolS
*));
2794 /* The symbol list should be ordered according to the following sequence
2797 * . debug entries for functions
2798 * . fake symbols for the sections, including.text .data and .bss
2800 * . undefined symbols
2801 * But this is not mandatory. The only important point is to put the
2802 * undefined symbols at the end of the list.
2805 if (symbol_rootP
== NULL
2806 || S_GET_STORAGE_CLASS (symbol_rootP
) != C_FILE
)
2808 c_dot_file_symbol ("fake");
2810 /* Is there a .file symbol ? If not insert one at the beginning. */
2813 * Build up static symbols for the sections, they are filled in later
2817 for (i
= SEG_E0
; i
< SEG_E9
; i
++)
2819 if (segment_info
[i
].scnhdr
.s_name
[0])
2823 strncpy (name
, segment_info
[i
].scnhdr
.s_name
, 8);
2825 segment_info
[i
].dot
= c_section_symbol (name
, i
- SEG_E0
+ 1);
2830 /* Take all the externals out and put them into another chain */
2831 H_SET_SYMBOL_TABLE_SIZE (h
, yank_symbols ());
2832 /* Take the externals and glue them onto the end.*/
2833 H_SET_SYMBOL_TABLE_SIZE (h
,
2834 (H_GET_SYMBOL_COUNT (h
)
2835 + glue_symbols (&symbol_globalP
,
2836 &symbol_global_lastP
)
2837 + glue_symbols (&symbol_externP
,
2838 &symbol_extern_lastP
)));
2840 H_SET_SYMBOL_TABLE_SIZE (h
, tie_tags ());
2841 know (symbol_globalP
== NULL
);
2842 know (symbol_global_lastP
== NULL
);
2843 know (symbol_externP
== NULL
);
2844 know (symbol_extern_lastP
== NULL
);
2848 * Find strings by crawling along symbol table chain.
2856 struct filename_list
*filename_list_scan
= filename_list_head
;
2858 /* Gotta do md_ byte-ordering stuff for string_byte_count first - KWK */
2859 md_number_to_chars (where
, (valueT
) string_byte_count
, 4);
2861 for (symbolP
= symbol_rootP
;
2863 symbolP
= symbol_next (symbolP
))
2867 if (SF_GET_STRING (symbolP
))
2869 size
= strlen (S_GET_NAME (symbolP
)) + 1;
2870 memcpy (where
, S_GET_NAME (symbolP
), size
);
2873 if (S_GET_STORAGE_CLASS (symbolP
) == C_FILE
2874 && SA_GET_FILE_FNAME_ZEROS (symbolP
) == 0)
2876 size
= strlen (filename_list_scan
->filename
) + 1;
2877 memcpy (where
, filename_list_scan
->filename
, size
);
2878 filename_list_scan
= filename_list_scan
->next
;
2885 do_linenos_for (abfd
, h
, file_cursor
)
2888 unsigned long *file_cursor
;
2891 unsigned long start
= *file_cursor
;
2893 for (idx
= SEG_E0
; idx
< SEG_E9
; idx
++)
2895 segment_info_type
*s
= segment_info
+ idx
;
2898 if (s
->scnhdr
.s_nlnno
!= 0)
2900 struct lineno_list
*line_ptr
;
2902 struct external_lineno
*buffer
=
2903 (struct external_lineno
*) xmalloc (s
->scnhdr
.s_nlnno
* LINESZ
);
2905 struct external_lineno
*dst
= buffer
;
2907 /* Run through the table we've built and turn it into its external
2908 form, take this chance to remove duplicates */
2910 for (line_ptr
= s
->lineno_list_head
;
2911 line_ptr
!= (struct lineno_list
*) NULL
;
2912 line_ptr
= line_ptr
->next
)
2915 if (line_ptr
->line
.l_lnno
== 0)
2917 /* Turn a pointer to a symbol into the symbols' index */
2918 line_ptr
->line
.l_addr
.l_symndx
=
2919 ((symbolS
*) line_ptr
->line
.l_addr
.l_symndx
)->sy_number
;
2923 line_ptr
->line
.l_addr
.l_paddr
+= ((struct frag
*) (line_ptr
->frag
))->fr_address
;
2927 (void) bfd_coff_swap_lineno_out (abfd
, &(line_ptr
->line
), dst
);
2932 s
->scnhdr
.s_lnnoptr
= *file_cursor
;
2934 bfd_write (buffer
, 1, s
->scnhdr
.s_nlnno
* LINESZ
, abfd
);
2937 *file_cursor
+= s
->scnhdr
.s_nlnno
* LINESZ
;
2940 H_SET_LINENO_SIZE (h
, *file_cursor
- start
);
2944 /* Now we run through the list of frag chains in a segment and
2945 make all the subsegment frags appear at the end of the
2946 list, as if the seg 0 was extra long */
2953 for (i
= SEG_E0
; i
< SEG_UNKNOWN
; i
++)
2955 frchainS
*head
= segment_info
[i
].frchainP
;
2957 fragS
*prev_frag
= &dummy
;
2959 while (head
&& head
->frch_seg
== i
)
2961 prev_frag
->fr_next
= head
->frch_root
;
2962 prev_frag
= head
->frch_last
;
2963 head
= head
->frch_next
;
2965 prev_frag
->fr_next
= 0;
2969 unsigned long machine
;
2972 write_object_file ()
2976 struct frchain
*frchain_ptr
;
2978 object_headers headers
;
2979 unsigned long file_cursor
;
2982 abfd
= bfd_openw (out_file_name
, TARGET_FORMAT
);
2987 as_perror ("FATAL: Can't create %s", out_file_name
);
2988 exit (EXIT_FAILURE
);
2990 bfd_set_format (abfd
, bfd_object
);
2991 bfd_set_arch_mach (abfd
, BFD_ARCH
, machine
);
2993 string_byte_count
= 4;
2995 for (frchain_ptr
= frchain_root
;
2996 frchain_ptr
!= (struct frchain
*) NULL
;
2997 frchain_ptr
= frchain_ptr
->frch_next
)
2999 /* Run through all the sub-segments and align them up. Also
3000 close any open frags. We tack a .fill onto the end of the
3001 frag chain so that any .align's size can be worked by looking
3002 at the next frag. */
3004 subseg_set (frchain_ptr
->frch_seg
, frchain_ptr
->frch_subseg
);
3005 #ifndef SUB_SEGMENT_ALIGN
3006 #define SUB_SEGMENT_ALIGN(SEG) 1
3010 static char nop
= NOP_OPCODE
;
3011 md_do_align (SUB_SEGMENT_ALIGN (now_seg
), &nop
, alignment_done
);
3014 frag_align (SUB_SEGMENT_ALIGN (now_seg
), NOP_OPCODE
);
3018 frag_wane (frag_now
);
3019 frag_now
->fr_fix
= 0;
3020 know (frag_now
->fr_next
== NULL
);
3027 for (i
= SEG_E0
; i
< SEG_UNKNOWN
; i
++)
3029 relax_segment (segment_info
[i
].frchainP
->frch_root
, i
);
3032 H_SET_NUMBER_OF_SECTIONS (&headers
, 0);
3034 /* Find out how big the sections are, and set the addresses. */
3036 for (i
= SEG_E0
; i
< SEG_UNKNOWN
; i
++)
3040 segment_info
[i
].scnhdr
.s_paddr
= addr
;
3041 segment_info
[i
].scnhdr
.s_vaddr
= addr
;
3043 if (segment_info
[i
].scnhdr
.s_name
[0])
3045 H_SET_NUMBER_OF_SECTIONS (&headers
,
3046 H_GET_NUMBER_OF_SECTIONS (&headers
) + 1);
3049 size
= size_section (abfd
, (unsigned int) i
);
3052 /* I think the section alignment is only used on the i960; the
3053 i960 needs it, and it should do no harm on other targets. */
3054 segment_info
[i
].scnhdr
.s_align
= section_alignment
[i
];
3057 H_SET_TEXT_SIZE (&headers
, size
);
3058 else if (i
== SEG_E1
)
3059 H_SET_DATA_SIZE (&headers
, size
);
3060 else if (i
== SEG_E2
)
3061 H_SET_BSS_SIZE (&headers
, size
);
3064 /* Turn the gas native symbol table shape into a coff symbol table */
3065 crawl_symbols (&headers
, abfd
);
3067 if (string_byte_count
== 4)
3068 string_byte_count
= 0;
3070 H_SET_STRING_SIZE (&headers
, string_byte_count
);
3076 for (i
= SEG_E0
; i
< SEG_UNKNOWN
; i
++)
3078 fixup_mdeps (segment_info
[i
].frchainP
->frch_root
, &headers
, i
);
3079 fixup_segment (&segment_info
[i
], i
);
3082 /* Look for ".stab" segments and fill in their initial symbols
3084 for (i
= SEG_E0
; i
< SEG_UNKNOWN
; i
++)
3086 name
= segment_info
[i
].scnhdr
.s_name
;
3089 && strncmp (".stab", name
, 5) == 0
3090 && strncmp (".stabstr", name
, 8) != 0)
3091 adjust_stab_section (abfd
, i
);
3094 file_cursor
= H_GET_TEXT_FILE_OFFSET (&headers
);
3096 bfd_seek (abfd
, (file_ptr
) file_cursor
, 0);
3098 /* Plant the data */
3100 fill_section (abfd
, &headers
, &file_cursor
);
3102 do_relocs_for (abfd
, &headers
, &file_cursor
);
3104 do_linenos_for (abfd
, &headers
, &file_cursor
);
3106 H_SET_FILE_MAGIC_NUMBER (&headers
, COFF_MAGIC
);
3107 #ifndef OBJ_COFF_OMIT_TIMESTAMP
3108 H_SET_TIME_STAMP (&headers
, (long)time((time_t *)0));
3110 H_SET_TIME_STAMP (&headers
, 0);
3112 #ifdef TC_COFF_SET_MACHINE
3113 TC_COFF_SET_MACHINE (&headers
);
3117 #define COFF_FLAGS 0
3120 #ifdef KEEP_RELOC_INFO
3121 H_SET_FLAGS (&headers
, ((H_GET_LINENO_SIZE(&headers
) ? 0 : F_LNNO
) |
3122 COFF_FLAGS
| coff_flags
));
3124 H_SET_FLAGS (&headers
, ((H_GET_LINENO_SIZE(&headers
) ? 0 : F_LNNO
) |
3125 (H_GET_RELOCATION_SIZE(&headers
) ? 0 : F_RELFLG
) |
3126 COFF_FLAGS
| coff_flags
));
3130 unsigned int symtable_size
= H_GET_SYMBOL_TABLE_SIZE (&headers
);
3131 char *buffer1
= xmalloc (symtable_size
+ string_byte_count
+ 1);
3133 H_SET_SYMBOL_TABLE_POINTER (&headers
, bfd_tell (abfd
));
3134 w_symbols (abfd
, buffer1
, symbol_rootP
);
3135 if (string_byte_count
> 0)
3136 w_strings (buffer1
+ symtable_size
);
3137 bfd_write (buffer1
, 1, symtable_size
+ string_byte_count
, abfd
);
3141 coff_header_append (abfd
, &headers
);
3143 /* Recent changes to write need this, but where it should
3144 go is up to Ken.. */
3145 if (bfd_close_all_done (abfd
) == false)
3146 as_fatal ("Can't close %s: %s", out_file_name
,
3147 bfd_errmsg (bfd_get_error ()));
3150 extern bfd
*stdoutput
;
3157 /* Add a new segment. This is called from subseg_new via the
3158 obj_new_segment macro. */
3161 obj_coff_add_segment (name
)
3167 /* Find out if we've already got a section of this name. */
3168 len
= strlen (name
);
3169 if (len
< sizeof (segment_info
[i
].scnhdr
.s_name
))
3172 len
= sizeof (segment_info
[i
].scnhdr
.s_name
);
3173 for (i
= SEG_E0
; i
< SEG_E9
&& segment_info
[i
].scnhdr
.s_name
[0]; i
++)
3174 if (strncmp (segment_info
[i
].scnhdr
.s_name
, name
, len
) == 0
3175 && (len
== sizeof (segment_info
[i
].scnhdr
.s_name
)
3176 || segment_info
[i
].scnhdr
.s_name
[len
] == '\0'))
3181 as_bad ("Too many new sections; can't add \"%s\"", name
);
3185 /* Add a new section. */
3186 strncpy (segment_info
[i
].scnhdr
.s_name
, name
,
3187 sizeof (segment_info
[i
].scnhdr
.s_name
));
3188 segment_info
[i
].scnhdr
.s_flags
= STYP_REG
;
3194 * implement the .section pseudo op:
3195 * .section name {, "flags"}
3197 * | +--- optional flags: 'b' for bss
3199 * +-- section name 'l' for lib
3203 * 'd' (apparently m88k for data)
3205 * But if the argument is not a quoted string, treat it as a
3206 * subsegment number.
3210 obj_coff_section (ignore
)
3213 /* Strip out the section name */
3215 char *section_name_end
;
3230 else if (type
== 'D')
3232 segment_info
[now_seg
].scnhdr
.s_flags
|= flags
;
3237 section_name
= input_line_pointer
;
3238 c
= get_symbol_end ();
3239 section_name_end
= input_line_pointer
;
3241 len
= section_name_end
- section_name
;
3242 input_line_pointer
++;
3248 else if (*input_line_pointer
== ',')
3251 ++input_line_pointer
;
3259 if (*input_line_pointer
!= '"')
3260 exp
= get_absolute_expression ();
3263 ++input_line_pointer
;
3264 while (*input_line_pointer
!= '"'
3265 && ! is_end_of_line
[(unsigned char) *input_line_pointer
])
3267 switch (*input_line_pointer
)
3269 case 'b': flags
|= STYP_BSS
; break;
3270 case 'i': flags
|= STYP_INFO
; break;
3271 case 'l': flags
|= STYP_LIB
; break;
3272 case 'n': flags
|= STYP_NOLOAD
; break;
3273 case 'o': flags
|= STYP_OVER
; break;
3275 case 'w': flags
|= STYP_DATA
; break;
3276 case 'x': flags
|= STYP_TEXT
; break;
3278 as_warn("unknown section attribute '%c'",
3279 *input_line_pointer
);
3282 ++input_line_pointer
;
3284 if (*input_line_pointer
== '"')
3285 ++input_line_pointer
;
3289 subseg_new (section_name
, (subsegT
) exp
);
3291 segment_info
[now_seg
].scnhdr
.s_flags
|= flags
;
3293 *section_name_end
= c
;
3298 obj_coff_text (ignore
)
3301 subseg_new (".text", get_absolute_expression ());
3306 obj_coff_data (ignore
)
3309 if (flag_readonly_data_in_text
)
3310 subseg_new (".text", get_absolute_expression () + 1000);
3312 subseg_new (".data", get_absolute_expression ());
3316 obj_coff_bss (ignore
)
3319 if (*input_line_pointer
== '\n') /* .bss */
3320 subseg_new(".bss", get_absolute_expression());
3321 else /* .bss id,expr */
3326 obj_coff_ident (ignore
)
3329 segT current_seg
= now_seg
; /* save current seg */
3330 subsegT current_subseg
= now_subseg
;
3331 subseg_new (".comment", 0); /* .comment seg */
3332 stringer (1); /* read string */
3333 subseg_set (current_seg
, current_subseg
); /* restore current seg */
3337 c_symbol_merge (debug
, normal
)
3341 S_SET_DATA_TYPE (normal
, S_GET_DATA_TYPE (debug
));
3342 S_SET_STORAGE_CLASS (normal
, S_GET_STORAGE_CLASS (debug
));
3344 if (S_GET_NUMBER_AUXILIARY (debug
) > S_GET_NUMBER_AUXILIARY (normal
))
3346 S_SET_NUMBER_AUXILIARY (normal
, S_GET_NUMBER_AUXILIARY (debug
));
3347 } /* take the most we have */
3349 if (S_GET_NUMBER_AUXILIARY (debug
) > 0)
3351 memcpy ((char *) &normal
->sy_symbol
.ost_auxent
[0],
3352 (char *) &debug
->sy_symbol
.ost_auxent
[0],
3353 (unsigned int) (S_GET_NUMBER_AUXILIARY (debug
) * AUXESZ
));
3354 } /* Move all the auxiliary information */
3356 /* Move the debug flags. */
3357 SF_SET_DEBUG_FIELD (normal
, SF_GET_DEBUG_FIELD (debug
));
3358 } /* c_symbol_merge() */
3361 c_line_new (symbol
, paddr
, line_number
, frag
)
3367 struct lineno_list
*new_line
=
3368 (struct lineno_list
*) xmalloc (sizeof (struct lineno_list
));
3370 segment_info_type
*s
= segment_info
+ now_seg
;
3371 new_line
->line
.l_lnno
= line_number
;
3373 if (line_number
== 0)
3375 last_line_symbol
= symbol
;
3376 new_line
->line
.l_addr
.l_symndx
= (long) symbol
;
3380 new_line
->line
.l_addr
.l_paddr
= paddr
;
3383 new_line
->frag
= (char *) frag
;
3384 new_line
->next
= (struct lineno_list
*) NULL
;
3387 if (s
->lineno_list_head
== (struct lineno_list
*) NULL
)
3389 s
->lineno_list_head
= new_line
;
3393 s
->lineno_list_tail
->next
= new_line
;
3395 s
->lineno_list_tail
= new_line
;
3396 return LINESZ
* s
->scnhdr
.s_nlnno
++;
3400 c_dot_file_symbol (filename
)
3405 symbolP
= symbol_new (".file",
3408 &zero_address_frag
);
3410 S_SET_STORAGE_CLASS (symbolP
, C_FILE
);
3411 S_SET_NUMBER_AUXILIARY (symbolP
, 1);
3413 if (strlen (filename
) > FILNMLEN
)
3415 /* Filename is too long to fit into an auxent,
3416 we stick it into the string table instead. We keep
3417 a linked list of the filenames we find so we can emit
3419 struct filename_list
*f
= ((struct filename_list
*)
3420 xmalloc (sizeof (struct filename_list
)));
3422 f
->filename
= filename
;
3425 SA_SET_FILE_FNAME_ZEROS (symbolP
, 0);
3426 SA_SET_FILE_FNAME_OFFSET (symbolP
, 0);
3428 if (filename_list_tail
)
3429 filename_list_tail
->next
= f
;
3431 filename_list_head
= f
;
3432 filename_list_tail
= f
;
3436 SA_SET_FILE_FNAME (symbolP
, filename
);
3443 listing_source_file (filename
);
3449 SF_SET_DEBUG (symbolP
);
3450 S_SET_VALUE (symbolP
, (valueT
) previous_file_symbol
);
3452 previous_file_symbol
= symbolP
;
3454 /* Make sure that the symbol is first on the symbol chain */
3455 if (symbol_rootP
!= symbolP
)
3457 if (symbolP
== symbol_lastP
)
3459 symbol_lastP
= symbol_lastP
->sy_previous
;
3460 } /* if it was the last thing on the list */
3462 symbol_remove (symbolP
, &symbol_rootP
, &symbol_lastP
);
3463 symbol_insert (symbolP
, symbol_rootP
, &symbol_rootP
, &symbol_lastP
);
3464 symbol_rootP
= symbolP
;
3465 } /* if not first on the list */
3467 } /* c_dot_file_symbol() */
3470 * Build a 'section static' symbol.
3474 c_section_symbol (name
, idx
)
3480 symbolP
= symbol_new (name
, idx
,
3482 &zero_address_frag
);
3484 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
3485 S_SET_NUMBER_AUXILIARY (symbolP
, 1);
3487 SF_SET_STATICS (symbolP
);
3490 } /* c_section_symbol() */
3493 w_symbols (abfd
, where
, symbol_rootP
)
3496 symbolS
* symbol_rootP
;
3501 /* First fill in those values we have only just worked out */
3502 for (i
= SEG_E0
; i
< SEG_E9
; i
++)
3504 symbolP
= segment_info
[i
].dot
;
3507 SA_SET_SCN_SCNLEN (symbolP
, segment_info
[i
].scnhdr
.s_size
);
3508 SA_SET_SCN_NRELOC (symbolP
, segment_info
[i
].scnhdr
.s_nreloc
);
3509 SA_SET_SCN_NLINNO (symbolP
, segment_info
[i
].scnhdr
.s_nlnno
);
3514 * Emit all symbols left in the symbol chain.
3516 for (symbolP
= symbol_rootP
; symbolP
; symbolP
= symbol_next (symbolP
))
3518 /* Used to save the offset of the name. It is used to point
3519 to the string in memory but must be a file offset. */
3520 register char *temp
;
3522 tc_coff_symbol_emit_hook (symbolP
);
3524 temp
= S_GET_NAME (symbolP
);
3525 if (SF_GET_STRING (symbolP
))
3527 S_SET_OFFSET (symbolP
, symbolP
->sy_name_offset
);
3528 S_SET_ZEROES (symbolP
, 0);
3532 memset (symbolP
->sy_symbol
.ost_entry
.n_name
, 0, SYMNMLEN
);
3533 strncpy (symbolP
->sy_symbol
.ost_entry
.n_name
, temp
, SYMNMLEN
);
3535 where
= symbol_to_chars (abfd
, where
, symbolP
);
3536 S_SET_NAME (symbolP
, temp
);
3542 obj_coff_lcomm (ignore
)
3555 name
= input_line_pointer
;
3557 c
= get_symbol_end ();
3558 p
= input_line_pointer
;
3561 if (*input_line_pointer
!= ',')
3563 as_bad ("Expected comma after name");
3564 ignore_rest_of_line ();
3567 if (*input_line_pointer
== '\n')
3569 as_bad ("Missing size expression");
3572 input_line_pointer
++;
3573 if ((temp
= get_absolute_expression ()) < 0)
3575 as_warn ("lcomm length (%d.) <0! Ignored.", temp
);
3576 ignore_rest_of_line ();
3581 symbolP
= symbol_find_or_make(name
);
3583 if (S_GET_SEGMENT(symbolP
) == SEG_UNKNOWN
&&
3584 S_GET_VALUE(symbolP
) == 0)
3589 segT current_seg
= now_seg
; /* save current seg */
3590 subsegT current_subseg
= now_subseg
;
3592 subseg_set (SEG_E2
, 1);
3593 symbolP
->sy_frag
= frag_now
;
3594 p
= frag_var(rs_org
, 1, 1, (relax_substateT
)0, symbolP
,
3597 subseg_set (current_seg
, current_subseg
); /* restore current seg */
3598 S_SET_SEGMENT(symbolP
, SEG_E2
);
3599 S_SET_STORAGE_CLASS(symbolP
, C_STAT
);
3603 as_bad("Symbol %s already defined", name
);
3605 demand_empty_rest_of_line();
3610 fixup_mdeps (frags
, h
, this_segment
)
3615 subseg_change (this_segment
, 0);
3618 switch (frags
->fr_type
)
3623 HANDLE_ALIGN (frags
);
3625 frags
->fr_type
= rs_fill
;
3627 (frags
->fr_next
->fr_address
- frags
->fr_address
- frags
->fr_fix
);
3629 case rs_machine_dependent
:
3630 md_convert_frag (h
, this_segment
, frags
);
3636 frags
= frags
->fr_next
;
3642 #ifndef TC_FORCE_RELOCATION
3643 #define TC_FORCE_RELOCATION(fix) 0
3647 fixup_segment (segP
, this_segment_type
)
3648 segment_info_type
* segP
;
3649 segT this_segment_type
;
3651 register fixS
* fixP
;
3652 register symbolS
*add_symbolP
;
3653 register symbolS
*sub_symbolP
;
3656 register char *place
;
3657 register long where
;
3658 register char pcrel
;
3659 register fragS
*fragP
;
3660 register segT add_symbol_segment
= absolute_section
;
3665 for (fixP
= segP
->fix_root
; fixP
; fixP
= fixP
->fx_next
)
3667 fragP
= fixP
->fx_frag
;
3669 where
= fixP
->fx_where
;
3670 place
= fragP
->fr_literal
+ where
;
3671 size
= fixP
->fx_size
;
3672 add_symbolP
= fixP
->fx_addsy
;
3674 if (fixP
->fx_tcbit
&& SF_GET_CALLNAME (add_symbolP
))
3676 /* Relocation should be done via the associated 'bal' entry
3679 if (!SF_GET_BALNAME (tc_get_bal_of_call (add_symbolP
)))
3681 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
3682 "No 'bal' entry point for leafproc %s",
3683 S_GET_NAME (add_symbolP
));
3686 fixP
->fx_addsy
= add_symbolP
= tc_get_bal_of_call (add_symbolP
);
3689 sub_symbolP
= fixP
->fx_subsy
;
3690 add_number
= fixP
->fx_offset
;
3691 pcrel
= fixP
->fx_pcrel
;
3693 if (add_symbolP
!= NULL
3694 && add_symbolP
->sy_mri_common
)
3696 know (add_symbolP
->sy_value
.X_op
== O_symbol
);
3697 add_number
+= S_GET_VALUE (add_symbolP
);
3698 fixP
->fx_offset
= add_number
;
3699 add_symbolP
= fixP
->fx_addsy
= add_symbolP
->sy_value
.X_add_symbol
;
3704 add_symbol_segment
= S_GET_SEGMENT (add_symbolP
);
3705 } /* if there is an addend */
3709 if (add_symbolP
== NULL
|| add_symbol_segment
== absolute_section
)
3711 if (add_symbolP
!= NULL
)
3713 add_number
+= S_GET_VALUE (add_symbolP
);
3715 fixP
->fx_addsy
= NULL
;
3718 /* It's just -sym. */
3719 if (S_GET_SEGMENT (sub_symbolP
) == absolute_section
)
3721 add_number
-= S_GET_VALUE (sub_symbolP
);
3728 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
3729 "Negative of non-absolute symbol %s",
3730 S_GET_NAME (sub_symbolP
));
3732 add_number
-= S_GET_VALUE (sub_symbolP
);
3733 } /* not absolute */
3735 /* if sub_symbol is in the same segment that add_symbol
3736 and add_symbol is either in DATA, TEXT, BSS or ABSOLUTE */
3738 else if (S_GET_SEGMENT (sub_symbolP
) == add_symbol_segment
3739 && SEG_NORMAL (add_symbol_segment
))
3741 /* Difference of 2 symbols from same segment. Can't
3742 make difference of 2 undefineds: 'value' means
3743 something different for N_UNDF. */
3745 /* Makes no sense to use the difference of 2 arbitrary symbols
3746 as the target of a call instruction. */
3749 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
3750 "callj to difference of 2 symbols");
3752 #endif /* TC_I960 */
3753 add_number
+= S_GET_VALUE (add_symbolP
) -
3754 S_GET_VALUE (sub_symbolP
);
3757 if (!TC_FORCE_RELOCATION (fixP
))
3759 fixP
->fx_addsy
= NULL
;
3760 fixP
->fx_subsy
= NULL
;
3762 #ifdef TC_M68K /* is this right? */
3770 /* Different segments in subtraction. */
3771 know (!(S_IS_EXTERNAL (sub_symbolP
) && (S_GET_SEGMENT (sub_symbolP
) == absolute_section
)));
3773 if ((S_GET_SEGMENT (sub_symbolP
) == absolute_section
))
3775 add_number
-= S_GET_VALUE (sub_symbolP
);
3778 else if (S_GET_SEGMENT (sub_symbolP
) == this_segment_type
3779 #if 0 /* Okay for 68k, at least... */
3784 /* Make it pc-relative. */
3785 add_number
+= (md_pcrel_from (fixP
)
3786 - S_GET_VALUE (sub_symbolP
));
3795 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
3796 "Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %ld.",
3797 segment_name (S_GET_SEGMENT (sub_symbolP
)),
3798 S_GET_NAME (sub_symbolP
),
3799 (long) (fragP
->fr_address
+ where
));
3802 } /* if sub_symbolP */
3806 if (add_symbol_segment
== this_segment_type
&& pcrel
)
3809 * This fixup was made when the symbol's segment was
3810 * SEG_UNKNOWN, but it is now in the local segment.
3811 * So we know how to do the address without relocation.
3814 /* reloc_callj() may replace a 'call' with a 'calls' or a 'bal',
3815 * in which cases it modifies *fixP as appropriate. In the case
3816 * of a 'calls', no further work is required, and *fixP has been
3817 * set up to make the rest of the code below a no-op.
3820 #endif /* TC_I960 */
3822 add_number
+= S_GET_VALUE (add_symbolP
);
3823 add_number
-= md_pcrel_from (fixP
);
3824 #if defined (TC_I386) || defined (TE_LYNX)
3825 /* On the 386 we must adjust by the segment
3826 vaddr as well. Ian Taylor. */
3827 add_number
-= segP
->scnhdr
.s_vaddr
;
3829 pcrel
= 0; /* Lie. Don't want further pcrel processing. */
3830 if (!TC_FORCE_RELOCATION (fixP
))
3832 fixP
->fx_addsy
= NULL
;
3838 switch (add_symbol_segment
)
3840 case absolute_section
:
3842 reloc_callj (fixP
); /* See comment about reloc_callj() above*/
3843 #endif /* TC_I960 */
3844 add_number
+= S_GET_VALUE (add_symbolP
);
3847 if (!TC_FORCE_RELOCATION (fixP
))
3849 fixP
->fx_addsy
= NULL
;
3856 #if defined(TC_A29K) || (defined(TE_PE) && defined(TC_I386)) || defined(TC_M88K)
3857 /* This really should be handled in the linker, but
3858 backward compatibility forbids. */
3859 add_number
+= S_GET_VALUE (add_symbolP
);
3861 add_number
+= S_GET_VALUE (add_symbolP
) +
3862 segment_info
[S_GET_SEGMENT (add_symbolP
)].scnhdr
.s_paddr
;
3868 if ((int) fixP
->fx_bit_fixP
== 13)
3870 /* This is a COBR instruction. They have only a
3871 * 13-bit displacement and are only to be used
3872 * for local branches: flag as error, don't generate
3875 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
3876 "can't use COBR format with external label");
3877 fixP
->fx_addsy
= NULL
;
3881 #endif /* TC_I960 */
3882 #if (defined (TC_I386) || defined (TE_LYNX)) && !defined(TE_PE)
3883 /* 386 COFF uses a peculiar format in which the
3884 value of a common symbol is stored in the .text
3885 segment (I've checked this on SVR3.2 and SCO
3886 3.2.2) Ian Taylor <ian@cygnus.com>. */
3887 if (S_IS_COMMON (add_symbolP
))
3888 add_number
+= S_GET_VALUE (add_symbolP
);
3893 } /* switch on symbol seg */
3894 } /* if not in local seg */
3895 } /* if there was a + symbol */
3899 #if !defined(TC_M88K) && !(defined(TE_PE) && defined(TC_I386)) && !defined(TC_A29K)
3900 /* This adjustment is not correct on the m88k, for which the
3901 linker does all the computation. */
3902 add_number
-= md_pcrel_from (fixP
);
3904 if (add_symbolP
== 0)
3906 fixP
->fx_addsy
= &abs_symbol
;
3907 } /* if there's an add_symbol */
3908 #if defined (TC_I386) || defined (TE_LYNX)
3909 /* On the 386 we must adjust by the segment vaddr
3910 as well. Ian Taylor. */
3911 add_number
-= segP
->scnhdr
.s_vaddr
;
3915 if (!fixP
->fx_bit_fixP
)
3918 /* The m88k uses the offset field of the reloc to get around
3921 && (add_number
& ~0xFF)
3922 && ((add_number
& ~0xFF) != (-1 & ~0xFF)))
3924 && (add_number
& ~0xFFFF)
3925 && ((add_number
& ~0xFFFF) != (-1 & ~0xFFFF))))
3927 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
3928 "Value of %ld too large for field of %d bytes at 0x%lx",
3929 (long) add_number
, size
,
3930 (unsigned long) (fragP
->fr_address
+ where
));
3933 #ifdef WARN_SIGNED_OVERFLOW_WORD
3934 /* Warn if a .word value is too large when treated as a
3935 signed number. We already know it is not too negative.
3936 This is to catch over-large switches generated by gcc on
3938 if (!flag_signed_overflow_ok
3940 && add_number
> 0x7fff)
3941 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
3942 "Signed .word overflow; switch may be too large; %ld at 0x%lx",
3944 (unsigned long) (fragP
->fr_address
+ where
));
3946 } /* not a bit fix */
3947 /* Once this fix has been applied, we don't have to output
3948 anything nothing more need be done. */
3949 #ifdef MD_APPLY_FIX3
3950 md_apply_fix3 (fixP
, &add_number
, this_segment_type
);
3952 md_apply_fix (fixP
, add_number
);
3954 } /* For each fixS in this segment. */
3955 } /* fixup_segment() */
3959 /* The first entry in a .stab section is special. */
3962 obj_coff_init_stab_section (seg
)
3968 unsigned int stroff
;
3970 /* Make space for this first symbol. */
3974 as_where (&file
, (unsigned int *) NULL
);
3975 stabstr_name
= (char *) alloca (strlen (segment_info
[seg
].scnhdr
.s_name
) + 4);
3976 strcpy (stabstr_name
, segment_info
[seg
].scnhdr
.s_name
);
3977 strcat (stabstr_name
, "str");
3978 stroff
= get_stab_string_offset (file
, stabstr_name
);
3980 md_number_to_chars (p
, stroff
, 4);
3983 /* Fill in the counts in the first entry in a .stab section. */
3986 adjust_stab_section(abfd
, seg
)
3990 segT stabstrseg
= SEG_UNKNOWN
;
3991 char *secname
, *name
, *name2
;
3993 int i
, strsz
= 0, nsyms
;
3994 fragS
*frag
= segment_info
[seg
].frchainP
->frch_root
;
3996 /* Look for the associated string table section. */
3998 secname
= segment_info
[seg
].scnhdr
.s_name
;
3999 name
= (char *) alloca (strlen (secname
) + 4);
4000 strcpy (name
, secname
);
4001 strcat (name
, "str");
4003 for (i
= SEG_E0
; i
< SEG_UNKNOWN
; i
++)
4005 name2
= segment_info
[i
].scnhdr
.s_name
;
4006 if (name2
!= NULL
&& strncmp(name2
, name
, 8) == 0)
4013 /* If we found the section, get its size. */
4014 if (stabstrseg
!= SEG_UNKNOWN
)
4015 strsz
= size_section (abfd
, stabstrseg
);
4017 nsyms
= size_section (abfd
, seg
) / 12 - 1;
4019 /* Look for the first frag of sufficient size for the initial stab
4020 symbol, and collect a pointer to it. */
4021 while (frag
&& frag
->fr_fix
< 12)
4022 frag
= frag
->fr_next
;
4024 p
= frag
->fr_literal
;
4027 /* Write in the number of stab symbols and the size of the string
4029 bfd_h_put_16 (abfd
, (bfd_vma
) nsyms
, (bfd_byte
*) p
+ 6);
4030 bfd_h_put_32 (abfd
, (bfd_vma
) strsz
, (bfd_byte
*) p
+ 8);
4033 #endif /* not BFD_ASSEMBLER */
4035 const pseudo_typeS obj_pseudo_table
[] =
4037 {"def", obj_coff_def
, 0},
4038 {"dim", obj_coff_dim
, 0},
4039 {"endef", obj_coff_endef
, 0},
4040 {"line", obj_coff_line
, 0},
4041 {"ln", obj_coff_ln
, 0},
4042 {"appline", obj_coff_ln
, 1},
4043 {"scl", obj_coff_scl
, 0},
4044 {"size", obj_coff_size
, 0},
4045 {"tag", obj_coff_tag
, 0},
4046 {"type", obj_coff_type
, 0},
4047 {"val", obj_coff_val
, 0},
4048 {"section", obj_coff_section
, 0},
4049 {"sect", obj_coff_section
, 0},
4050 /* FIXME: We ignore the MRI short attribute. */
4051 {"section.s", obj_coff_section
, 0},
4052 {"sect.s", obj_coff_section
, 0},
4053 #ifndef BFD_ASSEMBLER
4054 {"use", obj_coff_section
, 0},
4055 {"text", obj_coff_text
, 0},
4056 {"data", obj_coff_data
, 0},
4057 {"bss", obj_coff_bss
, 0},
4058 {"lcomm", obj_coff_lcomm
, 0},
4059 {"ident", obj_coff_ident
, 0},
4061 {"optim", s_ignore
, 0}, /* For sun386i cc (?) */
4062 {"ident", s_ignore
, 0}, /* we don't yet handle this. */
4064 {"ABORT", s_abort
, 0},
4066 /* The m88k uses sdef instead of def. */
4067 {"sdef", obj_coff_def
, 0},
4069 {NULL
} /* end sentinel */
4070 }; /* obj_pseudo_table */