1 /* coff object file format
2 Copyright (C) 1989, 90, 91, 92, 93, 94, 95, 1996
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
25 #include "libiberty.h"
27 /* I think this is probably always correct. */
28 #ifndef KEEP_RELOC_INFO
29 #define KEEP_RELOC_INFO
32 const char *s_get_name
PARAMS ((symbolS
* s
));
33 static symbolS
*def_symbol_in_progress
;
39 unsigned long chunk_size
;
40 unsigned long element_size
;
43 unsigned long pointer
;
48 stack_init (chunk_size
, element_size
)
49 unsigned long chunk_size
;
50 unsigned long element_size
;
54 st
= (stack
*) malloc (sizeof (stack
));
57 st
->data
= malloc (chunk_size
);
64 st
->size
= chunk_size
;
65 st
->chunk_size
= chunk_size
;
66 st
->element_size
= element_size
;
71 /* Not currently used. */
82 stack_push (st
, element
)
86 if (st
->pointer
+ st
->element_size
>= st
->size
)
88 st
->size
+= st
->chunk_size
;
89 if ((st
->data
= xrealloc (st
->data
, st
->size
)) == (char *) 0)
92 memcpy (st
->data
+ st
->pointer
, element
, st
->element_size
);
93 st
->pointer
+= st
->element_size
;
94 return st
->data
+ st
->pointer
;
101 if (st
->pointer
< st
->element_size
)
106 st
->pointer
-= st
->element_size
;
107 return st
->data
+ st
->pointer
;
111 * Maintain a list of the tagnames of the structres.
114 static struct hash_control
*tag_hash
;
119 tag_hash
= hash_new ();
123 tag_insert (name
, symbolP
)
127 const char *error_string
;
129 if ((error_string
= hash_jam (tag_hash
, name
, (char *) symbolP
)))
131 as_fatal ("Inserting \"%s\" into structure table failed: %s",
140 #ifdef STRIP_UNDERSCORE
143 #endif /* STRIP_UNDERSCORE */
144 return (symbolS
*) hash_find (tag_hash
, name
);
148 tag_find_or_make (name
)
153 if ((symbolP
= tag_find (name
)) == NULL
)
155 symbolP
= symbol_new (name
, undefined_section
,
156 0, &zero_address_frag
);
158 tag_insert (S_GET_NAME (symbolP
), symbolP
);
160 symbol_table_insert (symbolP
);
171 static void SA_SET_SYM_TAGNDX
PARAMS ((symbolS
*, symbolS
*));
173 #define GET_FILENAME_STRING(X) \
174 ((char*)(&((X)->sy_symbol.ost_auxent->x_file.x_n.x_offset))[1])
178 fetch_coff_debug_section ()
180 static segT debug_section
;
184 s
= bfd_make_debug_symbol (stdoutput
, (char *) 0, 0);
186 debug_section
= s
->section
;
188 return debug_section
;
192 SA_SET_SYM_ENDNDX (sym
, val
)
196 combined_entry_type
*entry
, *p
;
198 entry
= &coffsymbol (sym
->bsym
)->native
[1];
199 p
= coffsymbol (val
->bsym
)->native
;
200 entry
->u
.auxent
.x_sym
.x_fcnary
.x_fcn
.x_endndx
.p
= p
;
205 SA_SET_SYM_TAGNDX (sym
, val
)
209 combined_entry_type
*entry
, *p
;
211 entry
= &coffsymbol (sym
->bsym
)->native
[1];
212 p
= coffsymbol (val
->bsym
)->native
;
213 entry
->u
.auxent
.x_sym
.x_tagndx
.p
= p
;
218 S_GET_DATA_TYPE (sym
)
221 return coffsymbol (sym
->bsym
)->native
->u
.syment
.n_type
;
225 S_SET_DATA_TYPE (sym
, val
)
229 coffsymbol (sym
->bsym
)->native
->u
.syment
.n_type
= val
;
234 S_GET_STORAGE_CLASS (sym
)
237 return coffsymbol (sym
->bsym
)->native
->u
.syment
.n_sclass
;
241 S_SET_STORAGE_CLASS (sym
, val
)
245 coffsymbol (sym
->bsym
)->native
->u
.syment
.n_sclass
= val
;
249 /* Merge a debug symbol containing debug information into a normal symbol. */
252 c_symbol_merge (debug
, normal
)
256 S_SET_DATA_TYPE (normal
, S_GET_DATA_TYPE (debug
));
257 S_SET_STORAGE_CLASS (normal
, S_GET_STORAGE_CLASS (debug
));
259 if (S_GET_NUMBER_AUXILIARY (debug
) > S_GET_NUMBER_AUXILIARY (normal
))
260 /* take the most we have */
261 S_SET_NUMBER_AUXILIARY (normal
, S_GET_NUMBER_AUXILIARY (debug
));
263 if (S_GET_NUMBER_AUXILIARY (debug
) > 0)
265 /* Move all the auxiliary information. */
266 /* @@ How many fields do we want to preserve? Would it make more
267 sense to pick and choose those we want to copy? Should look
268 into this further.... [raeburn:19920512.2209EST] */
270 linenos
= coffsymbol (normal
->bsym
)->lineno
;
271 memcpy ((char *) &coffsymbol (normal
->bsym
)->native
,
272 (char *) &coffsymbol (debug
->bsym
)->native
,
273 S_GET_NUMBER_AUXILIARY(debug
) * AUXESZ
);
274 coffsymbol (normal
->bsym
)->lineno
= linenos
;
277 /* Move the debug flags. */
278 SF_SET_DEBUG_FIELD (normal
, SF_GET_DEBUG_FIELD (debug
));
282 c_dot_file_symbol (filename
)
287 symbolP
= symbol_new (filename
, bfd_abs_section_ptr
, 0, &zero_address_frag
);
289 S_SET_STORAGE_CLASS (symbolP
, C_FILE
);
290 S_SET_NUMBER_AUXILIARY (symbolP
, 1);
292 symbolP
->bsym
->flags
= BSF_DEBUGGING
;
299 listing_source_file (filename
);
304 /* Make sure that the symbol is first on the symbol chain */
305 if (symbol_rootP
!= symbolP
)
307 symbol_remove (symbolP
, &symbol_rootP
, &symbol_lastP
);
308 symbol_insert (symbolP
, symbol_rootP
, &symbol_rootP
, &symbol_lastP
);
309 } /* if not first on the list */
312 /* Line number handling */
315 struct line_no
*next
;
322 /* Symbol of last function, which we should hang line#s off of. */
323 static symbolS
*line_fsym
;
325 #define in_function() (line_fsym != 0)
326 #define clear_function() (line_fsym = 0)
327 #define set_function(F) (line_fsym = (F), coff_add_linesym (F))
331 obj_symbol_new_hook (symbolP
)
334 char underscore
= 0; /* Symbol has leading _ */
337 long sz
= (OBJ_COFF_MAX_AUXENTRIES
+ 1) * sizeof (combined_entry_type
);
338 char *s
= (char *) bfd_alloc_by_size_t (stdoutput
, sz
);
340 coffsymbol (symbolP
->bsym
)->native
= (combined_entry_type
*) s
;
342 S_SET_DATA_TYPE (symbolP
, T_NULL
);
343 S_SET_STORAGE_CLASS (symbolP
, 0);
344 S_SET_NUMBER_AUXILIARY (symbolP
, 0);
346 if (S_IS_STRING (symbolP
))
347 SF_SET_STRING (symbolP
);
348 if (!underscore
&& S_IS_LOCAL (symbolP
))
349 SF_SET_LOCAL (symbolP
);
354 * Handle .ln directives.
357 static symbolS
*current_lineno_sym
;
358 static struct line_no
*line_nos
;
359 /* @@ Blindly assume all .ln directives will be in the .text section... */
363 add_lineno (frag
, offset
, num
)
368 struct line_no
*new_line
= (struct line_no
*) bfd_alloc_by_size_t (stdoutput
,
369 sizeof (struct line_no
));
370 if (!current_lineno_sym
)
374 new_line
->next
= line_nos
;
375 new_line
->frag
= frag
;
376 new_line
->l
.line_number
= num
;
377 new_line
->l
.u
.offset
= offset
;
383 coff_add_linesym (sym
)
388 coffsymbol (current_lineno_sym
->bsym
)->lineno
= (alent
*) line_nos
;
392 current_lineno_sym
= sym
;
396 obj_coff_ln (appline
)
401 if (! appline
&& def_symbol_in_progress
!= NULL
)
403 as_warn (".ln pseudo-op inside .def/.endef: ignored.");
404 demand_empty_rest_of_line ();
408 l
= get_absolute_expression ();
411 add_lineno (frag_now
, frag_now_fix (), l
);
421 l
+= coff_line_base
- 1;
422 listing_source_line (l
);
427 demand_empty_rest_of_line ();
433 * Handle .def directives.
435 * One might ask : why can't we symbol_new if the symbol does not
436 * already exist and fill it with debug information. Because of
437 * the C_EFCN special symbol. It would clobber the value of the
438 * function symbol before we have a chance to notice that it is
439 * a C_EFCN. And a second reason is that the code is more clear this
440 * way. (at least I think it is :-).
444 #define SKIP_SEMI_COLON() while (*input_line_pointer++ != ';')
445 #define SKIP_WHITESPACES() while (*input_line_pointer == ' ' || \
446 *input_line_pointer == '\t') \
447 input_line_pointer++;
453 char name_end
; /* Char after the end of name */
454 char *symbol_name
; /* Name of the debug symbol */
455 char *symbol_name_copy
; /* Temporary copy of the name */
456 unsigned int symbol_name_length
;
458 if (def_symbol_in_progress
!= NULL
)
460 as_warn (".def pseudo-op used inside of .def/.endef: ignored.");
461 demand_empty_rest_of_line ();
463 } /* if not inside .def/.endef */
467 symbol_name
= input_line_pointer
;
468 #ifdef STRIP_UNDERSCORE
469 if (symbol_name
[0] == '_' && symbol_name
[1] != 0)
471 #endif /* STRIP_UNDERSCORE */
473 name_end
= get_symbol_end ();
474 symbol_name_length
= strlen (symbol_name
);
475 symbol_name_copy
= xmalloc (symbol_name_length
+ 1);
476 strcpy (symbol_name_copy
, symbol_name
);
478 /* Initialize the new symbol */
479 def_symbol_in_progress
= symbol_make (symbol_name_copy
);
480 def_symbol_in_progress
->sy_frag
= &zero_address_frag
;
481 S_SET_VALUE (def_symbol_in_progress
, 0);
483 if (S_IS_STRING (def_symbol_in_progress
))
484 SF_SET_STRING (def_symbol_in_progress
);
486 *input_line_pointer
= name_end
;
488 demand_empty_rest_of_line ();
491 unsigned int dim_index
;
494 obj_coff_endef (ignore
)
498 /* DIM BUG FIX sac@cygnus.com */
500 if (def_symbol_in_progress
== NULL
)
502 as_warn (".endef pseudo-op used outside of .def/.endef: ignored.");
503 demand_empty_rest_of_line ();
505 } /* if not inside .def/.endef */
507 /* Set the section number according to storage class. */
508 switch (S_GET_STORAGE_CLASS (def_symbol_in_progress
))
513 SF_SET_TAG (def_symbol_in_progress
);
514 /* intentional fallthrough */
517 SF_SET_DEBUG (def_symbol_in_progress
);
518 S_SET_SEGMENT (def_symbol_in_progress
, fetch_coff_debug_section ());
522 SF_SET_LOCAL (def_symbol_in_progress
); /* Do not emit this symbol. */
523 /* intentional fallthrough */
525 SF_SET_PROCESS (def_symbol_in_progress
); /* Will need processing before writing */
526 /* intentional fallthrough */
530 S_SET_SEGMENT (def_symbol_in_progress
, text_section
);
532 name
= bfd_asymbol_name (def_symbol_in_progress
->bsym
);
533 if (name
[1] == 'b' && name
[2] == 'f')
535 if (! in_function ())
536 as_warn ("`%s' symbol without preceding function", name
);
537 /* SA_SET_SYM_LNNO (def_symbol_in_progress, 12345);*/
538 /* Will need relocating */
539 SF_SET_PROCESS (def_symbol_in_progress
);
547 #endif /* C_AUTOARG */
553 SF_SET_DEBUG (def_symbol_in_progress
);
554 S_SET_SEGMENT (def_symbol_in_progress
, absolute_section
);
561 S_SET_SEGMENT (def_symbol_in_progress
, absolute_section
);
567 /* Valid but set somewhere else (s_comm, s_lcomm, colon) */
573 as_warn ("unexpected storage class %d",
574 S_GET_STORAGE_CLASS (def_symbol_in_progress
));
576 } /* switch on storage class */
578 /* Now that we have built a debug symbol, try to find if we should
579 merge with an existing symbol or not. If a symbol is C_EFCN or
580 SEG_ABSOLUTE or untagged SEG_DEBUG it never merges. */
582 /* Two cases for functions. Either debug followed by definition or
583 definition followed by debug. For definition first, we will
584 merge the debug symbol into the definition. For debug first, the
585 lineno entry MUST point to the definition function or else it
586 will point off into space when obj_crawl_symbol_chain() merges
587 the debug symbol into the real symbol. Therefor, let's presume
588 the debug symbol is a real function reference. */
590 /* FIXME-SOON If for some reason the definition label/symbol is
591 never seen, this will probably leave an undefined symbol at link
594 if (S_GET_STORAGE_CLASS (def_symbol_in_progress
) == C_EFCN
595 || (!strcmp (bfd_get_section_name (stdoutput
,
596 S_GET_SEGMENT (def_symbol_in_progress
)),
598 && !SF_GET_TAG (def_symbol_in_progress
))
599 || S_GET_SEGMENT (def_symbol_in_progress
) == absolute_section
600 || (symbolP
= symbol_find_base (S_GET_NAME (def_symbol_in_progress
), DO_NOT_STRIP
)) == NULL
)
602 if (def_symbol_in_progress
!= symbol_lastP
)
603 symbol_append (def_symbol_in_progress
, symbol_lastP
, &symbol_rootP
,
608 /* This symbol already exists, merge the newly created symbol
609 into the old one. This is not mandatory. The linker can
610 handle duplicate symbols correctly. But I guess that it save
611 a *lot* of space if the assembly file defines a lot of
614 /* The debug entry (def_symbol_in_progress) is merged into the
615 previous definition. */
617 c_symbol_merge (def_symbol_in_progress
, symbolP
);
618 symbol_remove (def_symbol_in_progress
, &symbol_rootP
, &symbol_lastP
);
620 def_symbol_in_progress
= symbolP
;
622 if (SF_GET_FUNCTION (def_symbol_in_progress
)
623 || SF_GET_TAG (def_symbol_in_progress
)
624 || S_GET_STORAGE_CLASS (def_symbol_in_progress
) == C_STAT
)
626 /* For functions, and tags, and static symbols, the symbol
627 *must* be where the debug symbol appears. Move the
628 existing symbol to the current place. */
629 /* If it already is at the end of the symbol list, do nothing */
630 if (def_symbol_in_progress
!= symbol_lastP
)
632 symbol_remove (def_symbol_in_progress
, &symbol_rootP
, &symbol_lastP
);
633 symbol_append (def_symbol_in_progress
, symbol_lastP
, &symbol_rootP
, &symbol_lastP
);
638 if (SF_GET_TAG (def_symbol_in_progress
))
642 oldtag
= symbol_find_base (S_GET_NAME (def_symbol_in_progress
),
644 if (oldtag
== NULL
|| ! SF_GET_TAG (oldtag
))
645 tag_insert (S_GET_NAME (def_symbol_in_progress
),
646 def_symbol_in_progress
);
649 if (SF_GET_FUNCTION (def_symbol_in_progress
))
651 know (sizeof (def_symbol_in_progress
) <= sizeof (long));
652 set_function (def_symbol_in_progress
);
653 SF_SET_PROCESS (def_symbol_in_progress
);
657 /* That is, if this is the first time we've seen the
659 symbol_table_insert (def_symbol_in_progress
);
660 } /* definition follows debug */
661 } /* Create the line number entry pointing to the function being defined */
663 def_symbol_in_progress
= NULL
;
664 demand_empty_rest_of_line ();
668 obj_coff_dim (ignore
)
673 if (def_symbol_in_progress
== NULL
)
675 as_warn (".dim pseudo-op used outside of .def/.endef: ignored.");
676 demand_empty_rest_of_line ();
678 } /* if not inside .def/.endef */
680 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
682 for (dim_index
= 0; dim_index
< DIMNUM
; dim_index
++)
685 SA_SET_SYM_DIMEN (def_symbol_in_progress
, dim_index
,
686 get_absolute_expression ());
688 switch (*input_line_pointer
)
691 input_line_pointer
++;
695 as_warn ("badly formed .dim directive ignored");
696 /* intentional fallthrough */
704 demand_empty_rest_of_line ();
708 obj_coff_line (ignore
)
713 if (def_symbol_in_progress
== NULL
)
715 /* Probably stabs-style line? */
720 this_base
= get_absolute_expression ();
721 if (!strcmp (".bf", S_GET_NAME (def_symbol_in_progress
)))
722 coff_line_base
= this_base
;
724 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
725 SA_SET_SYM_LNNO (def_symbol_in_progress
, coff_line_base
);
727 demand_empty_rest_of_line ();
730 if (strcmp (".bf", S_GET_NAME (def_symbol_in_progress
)) == 0)
735 listing_source_line ((unsigned int) coff_line_base
);
741 obj_coff_size (ignore
)
744 if (def_symbol_in_progress
== NULL
)
746 as_warn (".size pseudo-op used outside of .def/.endef ignored.");
747 demand_empty_rest_of_line ();
749 } /* if not inside .def/.endef */
751 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
752 SA_SET_SYM_SIZE (def_symbol_in_progress
, get_absolute_expression ());
753 demand_empty_rest_of_line ();
757 obj_coff_scl (ignore
)
760 if (def_symbol_in_progress
== NULL
)
762 as_warn (".scl pseudo-op used outside of .def/.endef ignored.");
763 demand_empty_rest_of_line ();
765 } /* if not inside .def/.endef */
767 S_SET_STORAGE_CLASS (def_symbol_in_progress
, get_absolute_expression ());
768 demand_empty_rest_of_line ();
772 obj_coff_tag (ignore
)
778 if (def_symbol_in_progress
== NULL
)
780 as_warn (".tag pseudo-op used outside of .def/.endef ignored.");
781 demand_empty_rest_of_line ();
785 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
786 symbol_name
= input_line_pointer
;
787 name_end
= get_symbol_end ();
789 /* Assume that the symbol referred to by .tag is always defined.
790 This was a bad assumption. I've added find_or_make. xoxorich. */
791 SA_SET_SYM_TAGNDX (def_symbol_in_progress
,
792 tag_find_or_make (symbol_name
));
793 if (SA_GET_SYM_TAGNDX (def_symbol_in_progress
) == 0L)
795 as_warn ("tag not found for .tag %s", symbol_name
);
798 SF_SET_TAGGED (def_symbol_in_progress
);
799 *input_line_pointer
= name_end
;
801 demand_empty_rest_of_line ();
805 obj_coff_type (ignore
)
808 if (def_symbol_in_progress
== NULL
)
810 as_warn (".type pseudo-op used outside of .def/.endef ignored.");
811 demand_empty_rest_of_line ();
813 } /* if not inside .def/.endef */
815 S_SET_DATA_TYPE (def_symbol_in_progress
, get_absolute_expression ());
817 if (ISFCN (S_GET_DATA_TYPE (def_symbol_in_progress
)) &&
818 S_GET_STORAGE_CLASS (def_symbol_in_progress
) != C_TPDEF
)
820 SF_SET_FUNCTION (def_symbol_in_progress
);
821 } /* is a function */
823 demand_empty_rest_of_line ();
827 obj_coff_val (ignore
)
830 if (def_symbol_in_progress
== NULL
)
832 as_warn (".val pseudo-op used outside of .def/.endef ignored.");
833 demand_empty_rest_of_line ();
835 } /* if not inside .def/.endef */
837 if (is_name_beginner (*input_line_pointer
))
839 char *symbol_name
= input_line_pointer
;
840 char name_end
= get_symbol_end ();
842 if (!strcmp (symbol_name
, "."))
844 def_symbol_in_progress
->sy_frag
= frag_now
;
845 S_SET_VALUE (def_symbol_in_progress
, (valueT
) frag_now_fix ());
846 /* If the .val is != from the .def (e.g. statics) */
848 else if (strcmp (S_GET_NAME (def_symbol_in_progress
), symbol_name
))
850 def_symbol_in_progress
->sy_value
.X_op
= O_symbol
;
851 def_symbol_in_progress
->sy_value
.X_add_symbol
=
852 symbol_find_or_make (symbol_name
);
853 def_symbol_in_progress
->sy_value
.X_op_symbol
= NULL
;
854 def_symbol_in_progress
->sy_value
.X_add_number
= 0;
856 /* If the segment is undefined when the forward reference is
857 resolved, then copy the segment id from the forward
859 SF_SET_GET_SEGMENT (def_symbol_in_progress
);
861 /* Otherwise, it is the name of a non debug symbol and its value will be calculated later. */
862 *input_line_pointer
= name_end
;
866 S_SET_VALUE (def_symbol_in_progress
, get_absolute_expression ());
867 } /* if symbol based */
869 demand_empty_rest_of_line ();
873 obj_read_begin_hook ()
875 /* These had better be the same. Usually 18 bytes. */
877 know (sizeof (SYMENT
) == sizeof (AUXENT
));
878 know (SYMESZ
== AUXESZ
);
884 symbolS
*coff_last_function
;
885 static symbolS
*coff_last_bf
;
888 coff_frob_symbol (symp
, punt
)
892 static symbolS
*last_tagP
;
893 static stack
*block_stack
;
894 static symbolS
*set_end
;
895 symbolS
*next_set_end
= NULL
;
897 if (symp
== &abs_symbol
)
903 if (current_lineno_sym
)
904 coff_add_linesym ((symbolS
*) 0);
907 block_stack
= stack_init (512, sizeof (symbolS
*));
909 if (!S_IS_DEFINED (symp
) && S_GET_STORAGE_CLASS (symp
) != C_STAT
)
910 S_SET_STORAGE_CLASS (symp
, C_EXT
);
912 if (!SF_GET_DEBUG (symp
))
915 if (!SF_GET_LOCAL (symp
)
916 && !SF_GET_STATICS (symp
)
917 && (real
= symbol_find_base (S_GET_NAME (symp
), DO_NOT_STRIP
))
920 c_symbol_merge (symp
, real
);
923 if (!S_IS_DEFINED (symp
) && !SF_GET_LOCAL (symp
))
925 assert (S_GET_VALUE (symp
) == 0);
926 S_SET_EXTERNAL (symp
);
928 else if (S_GET_STORAGE_CLASS (symp
) == C_NULL
)
930 if (S_GET_SEGMENT (symp
) == text_section
931 && symp
!= seg_info (text_section
)->sym
)
932 S_SET_STORAGE_CLASS (symp
, C_LABEL
);
934 S_SET_STORAGE_CLASS (symp
, C_STAT
);
936 if (SF_GET_PROCESS (symp
))
938 if (S_GET_STORAGE_CLASS (symp
) == C_BLOCK
)
940 if (!strcmp (S_GET_NAME (symp
), ".bb"))
941 stack_push (block_stack
, (char *) &symp
);
945 begin
= *(symbolS
**) stack_pop (block_stack
);
947 as_warn ("mismatched .eb");
949 next_set_end
= begin
;
952 if (coff_last_function
== 0 && SF_GET_FUNCTION (symp
))
954 union internal_auxent
*auxp
;
955 coff_last_function
= symp
;
956 if (S_GET_NUMBER_AUXILIARY (symp
) < 1)
957 S_SET_NUMBER_AUXILIARY (symp
, 1);
958 auxp
= &coffsymbol (symp
->bsym
)->native
[1].u
.auxent
;
959 memset (auxp
->x_sym
.x_fcnary
.x_ary
.x_dimen
, 0,
960 sizeof (auxp
->x_sym
.x_fcnary
.x_ary
.x_dimen
));
962 if (S_GET_STORAGE_CLASS (symp
) == C_EFCN
)
964 if (coff_last_function
== 0)
965 as_fatal ("C_EFCN symbol out of scope");
966 SA_SET_SYM_FSIZE (coff_last_function
,
967 (long) (S_GET_VALUE (symp
)
968 - S_GET_VALUE (coff_last_function
)));
969 next_set_end
= coff_last_function
;
970 coff_last_function
= 0;
973 if (S_IS_EXTERNAL (symp
))
974 S_SET_STORAGE_CLASS (symp
, C_EXT
);
975 else if (SF_GET_LOCAL (symp
))
978 if (SF_GET_FUNCTION (symp
))
979 symp
->bsym
->flags
|= BSF_FUNCTION
;
984 if (SF_GET_TAG (symp
))
986 else if (S_GET_STORAGE_CLASS (symp
) == C_EOS
)
987 next_set_end
= last_tagP
;
990 /* This is pretty horrible, but we have to set *punt correctly in
991 order to call SA_SET_SYM_ENDNDX correctly. */
992 if (! symp
->sy_used_in_reloc
993 && ((symp
->bsym
->flags
& BSF_SECTION_SYM
) != 0
994 || (! S_IS_EXTERNAL (symp
)
995 && ! symp
->sy_tc
.output
996 && S_GET_STORAGE_CLASS (symp
) != C_FILE
)))
1000 if (set_end
!= (symbolS
*) NULL
1002 && ((symp
->bsym
->flags
& BSF_NOT_AT_END
) != 0
1003 || (S_IS_DEFINED (symp
)
1004 && ! S_IS_COMMON (symp
)
1005 && (! S_IS_EXTERNAL (symp
) || SF_GET_FUNCTION (symp
)))))
1007 SA_SET_SYM_ENDNDX (set_end
, symp
);
1011 if (next_set_end
!= NULL
1013 set_end
= next_set_end
;
1016 && S_GET_STORAGE_CLASS (symp
) == C_FCN
1017 && strcmp (S_GET_NAME (symp
), ".bf") == 0)
1019 if (coff_last_bf
!= NULL
)
1020 SA_SET_SYM_ENDNDX (coff_last_bf
, symp
);
1021 coff_last_bf
= symp
;
1024 if (coffsymbol (symp
->bsym
)->lineno
)
1027 struct line_no
*lptr
;
1030 lptr
= (struct line_no
*) coffsymbol (symp
->bsym
)->lineno
;
1031 for (i
= 0; lptr
; lptr
= lptr
->next
)
1033 lptr
= (struct line_no
*) coffsymbol (symp
->bsym
)->lineno
;
1035 /* We need i entries for line numbers, plus 1 for the first
1036 entry which BFD will override, plus 1 for the last zero
1037 entry (a marker for BFD). */
1038 l
= (alent
*) bfd_alloc_by_size_t (stdoutput
, (i
+ 2) * sizeof (alent
));
1039 coffsymbol (symp
->bsym
)->lineno
= l
;
1040 l
[i
+ 1].line_number
= 0;
1041 l
[i
+ 1].u
.sym
= NULL
;
1045 lptr
->l
.u
.offset
+= lptr
->frag
->fr_address
;
1053 coff_adjust_section_syms (abfd
, sec
, x
)
1059 segment_info_type
*seginfo
= seg_info (sec
);
1060 int nlnno
, nrelocs
= 0;
1062 /* RS/6000 gas creates a .debug section manually in ppc_frob_file in
1063 tc-ppc.c. Do not get confused by it. */
1064 if (seginfo
== NULL
)
1067 if (!strcmp (sec
->name
, ".text"))
1068 nlnno
= coff_n_line_nos
;
1072 /* @@ Hope that none of the fixups expand to more than one reloc
1074 fixS
*fixp
= seginfo
->fix_root
;
1077 fixp
= fixp
->fx_next
;
1081 if (bfd_get_section_size_before_reloc (sec
) == 0
1084 && sec
!= text_section
1085 && sec
!= data_section
1086 && sec
!= bss_section
)
1088 secsym
= section_symbol (sec
);
1089 SA_SET_SCN_NRELOC (secsym
, nrelocs
);
1090 SA_SET_SCN_NLINNO (secsym
, nlnno
);
1096 bfd_map_over_sections (stdoutput
, coff_adjust_section_syms
, (char*) 0);
1100 * implement the .section pseudo op:
1101 * .section name {, "flags"}
1103 * | +--- optional flags: 'b' for bss
1105 * +-- section name 'l' for lib
1109 * 'd' (apparently m88k for data)
1111 * But if the argument is not a quoted string, treat it as a
1112 * subsegment number.
1116 obj_coff_section (ignore
)
1119 /* Strip out the section name */
1135 section_name
= input_line_pointer
;
1136 c
= get_symbol_end ();
1138 name
= xmalloc (input_line_pointer
- section_name
+ 1);
1139 strcpy (name
, section_name
);
1141 *input_line_pointer
= c
;
1146 flags
= SEC_NO_FLAGS
;
1148 if (*input_line_pointer
== ',')
1150 ++input_line_pointer
;
1152 if (*input_line_pointer
!= '"')
1153 exp
= get_absolute_expression ();
1156 ++input_line_pointer
;
1157 while (*input_line_pointer
!= '"'
1158 && ! is_end_of_line
[(unsigned char) *input_line_pointer
])
1160 switch (*input_line_pointer
)
1162 case 'b': flags
|= SEC_ALLOC
; flags
&=~ SEC_LOAD
; break;
1163 case 'n': flags
&=~ SEC_LOAD
; break;
1165 case 'w': flags
&=~ SEC_READONLY
; break;
1166 case 'x': flags
|= SEC_CODE
; break;
1168 case 'i': /* STYP_INFO */
1169 case 'l': /* STYP_LIB */
1170 case 'o': /* STYP_OVER */
1171 as_warn ("unsupported section attribute '%c'",
1172 *input_line_pointer
);
1176 as_warn("unknown section attribute '%c'",
1177 *input_line_pointer
);
1180 ++input_line_pointer
;
1182 if (*input_line_pointer
== '"')
1183 ++input_line_pointer
;
1187 sec
= subseg_new (name
, (subsegT
) exp
);
1189 if (flags
!= SEC_NO_FLAGS
)
1191 if (! bfd_set_section_flags (stdoutput
, sec
, flags
))
1192 as_warn ("error setting flags for \"%s\": %s",
1193 bfd_section_name (stdoutput
, sec
),
1194 bfd_errmsg (bfd_get_error ()));
1197 demand_empty_rest_of_line ();
1201 coff_adjust_symtab ()
1203 if (symbol_rootP
== NULL
1204 || S_GET_STORAGE_CLASS (symbol_rootP
) != C_FILE
)
1205 c_dot_file_symbol ("fake");
1209 coff_frob_section (sec
)
1215 bfd_vma size
, n_entries
, mask
;
1217 /* The COFF back end in BFD requires that all section sizes be
1218 rounded up to multiples of the corresponding section alignments.
1219 Seems kinda silly to me, but that's the way it is. */
1220 size
= bfd_get_section_size_before_reloc (sec
);
1221 mask
= ((bfd_vma
) 1 << (bfd_vma
) sec
->alignment_power
) - 1;
1224 size
= (size
+ mask
) & ~mask
;
1225 bfd_set_section_size (stdoutput
, sec
, size
);
1228 /* If the section size is non-zero, the section symbol needs an aux
1229 entry associated with it, indicating the size. We don't know
1230 all the values yet; coff_frob_symbol will fill them in later. */
1232 || sec
== text_section
1233 || sec
== data_section
1234 || sec
== bss_section
)
1236 symbolS
*secsym
= section_symbol (sec
);
1238 S_SET_STORAGE_CLASS (secsym
, C_STAT
);
1239 S_SET_NUMBER_AUXILIARY (secsym
, 1);
1240 SF_SET_STATICS (secsym
);
1241 SA_SET_SCN_SCNLEN (secsym
, size
);
1244 /* @@ these should be in a "stabs.h" file, or maybe as.h */
1245 #ifndef STAB_SECTION_NAME
1246 #define STAB_SECTION_NAME ".stab"
1248 #ifndef STAB_STRING_SECTION_NAME
1249 #define STAB_STRING_SECTION_NAME ".stabstr"
1251 if (strcmp (STAB_STRING_SECTION_NAME
, sec
->name
))
1255 sec
= subseg_get (STAB_SECTION_NAME
, 0);
1256 /* size is already rounded up, since other section will be listed first */
1257 size
= bfd_get_section_size_before_reloc (strsec
);
1259 n_entries
= bfd_get_section_size_before_reloc (sec
) / 12 - 1;
1261 /* Find first non-empty frag. It should be large enough. */
1262 fragp
= seg_info (sec
)->frchainP
->frch_root
;
1263 while (fragp
&& fragp
->fr_fix
== 0)
1264 fragp
= fragp
->fr_next
;
1265 assert (fragp
!= 0 && fragp
->fr_fix
>= 12);
1267 /* Store the values. */
1268 p
= fragp
->fr_literal
;
1269 bfd_h_put_16 (stdoutput
, n_entries
, (bfd_byte
*) p
+ 6);
1270 bfd_h_put_32 (stdoutput
, size
, (bfd_byte
*) p
+ 8);
1274 obj_coff_init_stab_section (seg
)
1280 unsigned int stroff
;
1282 /* Make space for this first symbol. */
1286 as_where (&file
, (unsigned int *) NULL
);
1287 stabstr_name
= (char *) alloca (strlen (seg
->name
) + 4);
1288 strcpy (stabstr_name
, seg
->name
);
1289 strcat (stabstr_name
, "str");
1290 stroff
= get_stab_string_offset (file
, stabstr_name
);
1292 md_number_to_chars (p
, stroff
, 4);
1301 return ((s
== NULL
) ? "(NULL)" : S_GET_NAME (s
));
1309 for (symbolP
= symbol_rootP
; symbolP
; symbolP
= symbol_next (symbolP
))
1311 printf("0x%lx: \"%s\" type = %ld, class = %d, segment = %d\n",
1312 (unsigned long) symbolP
,
1313 S_GET_NAME(symbolP
),
1314 (long) S_GET_DATA_TYPE(symbolP
),
1315 S_GET_STORAGE_CLASS(symbolP
),
1316 (int) S_GET_SEGMENT(symbolP
));
1322 #else /* not BFD_ASSEMBLER */
1325 /* This is needed because we include internal bfd things. */
1329 #include "libcoff.h"
1332 #include "coff/pe.h"
1335 /* The NOP_OPCODE is for the alignment fill value. Fill with nop so
1336 that we can stick sections together without causing trouble. */
1338 #define NOP_OPCODE 0x00
1341 /* The zeroes if symbol name is longer than 8 chars */
1342 #define S_SET_ZEROES(s,v) ((s)->sy_symbol.ost_entry.n_zeroes = (v))
1344 #define MIN(a,b) ((a) < (b)? (a) : (b))
1345 /* This vector is used to turn an internal segment into a section #
1346 suitable for insertion into a coff symbol table
1349 const short seg_N_TYPE
[] =
1350 { /* in: segT out: N_TYPE bits */
1352 1, 2, 3, 4, 5, 6, 7, 8, 9, 10,
1353 11, 12, 13, 14, 15, 16, 17, 18, 19, 20,
1354 21, 22, 23, 24, 25, 26, 27, 28, 29, 30,
1355 31, 32, 33, 34, 35, 36, 37, 38, 39, 40,
1356 C_UNDEF_SECTION
, /* SEG_UNKNOWN */
1357 C_UNDEF_SECTION
, /* SEG_GOOF */
1358 C_UNDEF_SECTION
, /* SEG_EXPR */
1359 C_DEBUG_SECTION
, /* SEG_DEBUG */
1360 C_NTV_SECTION
, /* SEG_NTV */
1361 C_PTV_SECTION
, /* SEG_PTV */
1362 C_REGISTER_SECTION
, /* SEG_REGISTER */
1365 int function_lineoff
= -1; /* Offset in line#s where the last function
1366 started (the odd entry for line #0) */
1368 /* structure used to keep the filenames which
1369 are too long around so that we can stick them
1370 into the string table */
1371 struct filename_list
1374 struct filename_list
*next
;
1377 static struct filename_list
*filename_list_head
;
1378 static struct filename_list
*filename_list_tail
;
1380 static symbolS
*last_line_symbol
;
1382 /* Add 4 to the real value to get the index and compensate the
1383 negatives. This vector is used by S_GET_SEGMENT to turn a coff
1384 section number into a segment number
1386 static symbolS
*previous_file_symbol
;
1387 void c_symbol_merge ();
1388 static int line_base
;
1390 symbolS
*c_section_symbol ();
1393 static void fixup_segment
PARAMS ((segment_info_type
*segP
,
1394 segT this_segment_type
));
1397 static void fixup_mdeps
PARAMS ((fragS
*,
1402 static void fill_section
PARAMS ((bfd
* abfd
,
1407 static int c_line_new
PARAMS ((symbolS
* symbol
, long paddr
,
1412 static void w_symbols
PARAMS ((bfd
* abfd
, char *where
,
1413 symbolS
* symbol_rootP
));
1415 static void adjust_stab_section
PARAMS ((bfd
*abfd
, segT seg
));
1417 static void obj_coff_lcomm
PARAMS ((int));
1418 static void obj_coff_text
PARAMS ((int));
1419 static void obj_coff_data
PARAMS ((int));
1420 static void obj_coff_bss
PARAMS ((int));
1421 static void obj_coff_ident
PARAMS ((int));
1422 void obj_coff_section
PARAMS ((int));
1426 We allow more than just the standard 3 sections, infact, we allow
1427 40 sections, (though the usual three have to be there).
1429 This structure performs the mappings for us:
1439 static const seg_info_type seg_info_off_by_4
[] =
1446 {SEG_E0
}, {SEG_E1
}, {SEG_E2
}, {SEG_E3
}, {SEG_E4
},
1447 {SEG_E5
}, {SEG_E6
}, {SEG_E7
}, {SEG_E8
}, {SEG_E9
},
1448 {SEG_E10
},{SEG_E11
},{SEG_E12
},{SEG_E13
},{SEG_E14
},
1449 {SEG_E15
},{SEG_E16
},{SEG_E17
},{SEG_E18
},{SEG_E19
},
1450 {SEG_E20
},{SEG_E21
},{SEG_E22
},{SEG_E23
},{SEG_E24
},
1451 {SEG_E25
},{SEG_E26
},{SEG_E27
},{SEG_E28
},{SEG_E29
},
1452 {SEG_E30
},{SEG_E31
},{SEG_E32
},{SEG_E33
},{SEG_E34
},
1453 {SEG_E35
},{SEG_E36
},{SEG_E37
},{SEG_E38
},{SEG_E39
},
1468 #define SEG_INFO_FROM_SECTION_NUMBER(x) (seg_info_off_by_4[(x)+4])
1470 static relax_addressT
1471 relax_align (address
, alignment
)
1472 relax_addressT address
;
1475 relax_addressT mask
;
1476 relax_addressT new_address
;
1478 mask
= ~((~0) << alignment
);
1479 new_address
= (address
+ mask
) & (~mask
);
1480 return (new_address
- address
);
1488 return SEG_INFO_FROM_SECTION_NUMBER (x
->sy_symbol
.ost_entry
.n_scnum
).seg_t
;
1493 /* calculate the size of the frag chain and fill in the section header
1494 to contain all of it, also fill in the addr of the sections */
1496 size_section (abfd
, idx
)
1501 unsigned int size
= 0;
1502 fragS
*frag
= segment_info
[idx
].frchainP
->frch_root
;
1505 size
= frag
->fr_address
;
1506 if (frag
->fr_address
!= size
)
1508 fprintf (stderr
, "Out of step\n");
1509 size
= frag
->fr_address
;
1512 switch (frag
->fr_type
)
1514 #ifdef TC_COFF_SIZEMACHDEP
1515 case rs_machine_dependent
:
1516 size
+= TC_COFF_SIZEMACHDEP (frag
);
1520 assert (frag
->fr_symbol
== 0);
1523 size
+= frag
->fr_fix
;
1524 size
+= frag
->fr_offset
* frag
->fr_var
;
1528 size
+= frag
->fr_fix
;
1529 size
+= relax_align (size
, frag
->fr_offset
);
1532 BAD_CASE (frag
->fr_type
);
1535 frag
= frag
->fr_next
;
1537 segment_info
[idx
].scnhdr
.s_size
= size
;
1543 count_entries_in_chain (idx
)
1546 unsigned int nrelocs
;
1549 /* Count the relocations */
1550 fixup_ptr
= segment_info
[idx
].fix_root
;
1552 while (fixup_ptr
!= (fixS
*) NULL
)
1554 if (fixup_ptr
->fx_done
== 0 && TC_COUNT_RELOC (fixup_ptr
))
1557 if (fixup_ptr
->fx_r_type
== RELOC_CONSTH
)
1566 fixup_ptr
= fixup_ptr
->fx_next
;
1573 static int compare_external_relocs
PARAMS ((const PTR
, const PTR
));
1575 /* AUX's ld expects relocations to be sorted */
1577 compare_external_relocs (x
, y
)
1581 struct external_reloc
*a
= (struct external_reloc
*) x
;
1582 struct external_reloc
*b
= (struct external_reloc
*) y
;
1583 bfd_vma aadr
= bfd_getb32 (a
->r_vaddr
);
1584 bfd_vma badr
= bfd_getb32 (b
->r_vaddr
);
1585 return (aadr
< badr
? -1 : badr
< aadr
? 1 : 0);
1590 /* output all the relocations for a section */
1592 do_relocs_for (abfd
, h
, file_cursor
)
1595 unsigned long *file_cursor
;
1597 unsigned int nrelocs
;
1599 unsigned long reloc_start
= *file_cursor
;
1601 for (idx
= SEG_E0
; idx
< SEG_LAST
; idx
++)
1603 if (segment_info
[idx
].scnhdr
.s_name
[0])
1605 struct external_reloc
*ext_ptr
;
1606 struct external_reloc
*external_reloc_vec
;
1607 unsigned int external_reloc_size
;
1608 unsigned int base
= segment_info
[idx
].scnhdr
.s_paddr
;
1609 fixS
*fix_ptr
= segment_info
[idx
].fix_root
;
1610 nrelocs
= count_entries_in_chain (idx
);
1613 /* Bypass this stuff if no relocs. This also incidentally
1614 avoids a SCO bug, where free(malloc(0)) tends to crash. */
1616 external_reloc_size
= nrelocs
* RELSZ
;
1617 external_reloc_vec
=
1618 (struct external_reloc
*) malloc (external_reloc_size
);
1620 ext_ptr
= external_reloc_vec
;
1622 /* Fill in the internal coff style reloc struct from the
1623 internal fix list. */
1626 struct internal_reloc intr
;
1628 /* Only output some of the relocations */
1629 if (fix_ptr
->fx_done
== 0 && TC_COUNT_RELOC (fix_ptr
))
1631 #ifdef TC_RELOC_MANGLE
1632 TC_RELOC_MANGLE (&segment_info
[idx
], fix_ptr
, &intr
,
1637 symbolS
*symbol_ptr
= fix_ptr
->fx_addsy
;
1639 intr
.r_type
= TC_COFF_FIX2RTYPE (fix_ptr
);
1641 base
+ fix_ptr
->fx_frag
->fr_address
+ fix_ptr
->fx_where
;
1643 #ifdef TC_KEEP_FX_OFFSET
1644 intr
.r_offset
= fix_ptr
->fx_offset
;
1649 while (symbol_ptr
->sy_value
.X_op
== O_symbol
1650 && (! S_IS_DEFINED (symbol_ptr
)
1651 || S_IS_COMMON (symbol_ptr
)))
1652 symbol_ptr
= symbol_ptr
->sy_value
.X_add_symbol
;
1654 /* Turn the segment of the symbol into an offset. */
1657 if (! symbol_ptr
->sy_resolved
)
1662 if (expr_symbol_where (symbol_ptr
, &file
, &line
))
1663 as_bad_where (file
, line
,
1664 "unresolved relocation");
1666 as_bad ("bad relocation: symbol `%s' not in symbol table",
1667 S_GET_NAME (symbol_ptr
));
1669 dot
= segment_info
[S_GET_SEGMENT (symbol_ptr
)].dot
;
1672 intr
.r_symndx
= dot
->sy_number
;
1676 intr
.r_symndx
= symbol_ptr
->sy_number
;
1686 (void) bfd_coff_swap_reloc_out (abfd
, &intr
, ext_ptr
);
1689 #if defined(TC_A29K)
1691 /* The 29k has a special kludge for the high 16 bit
1692 reloc. Two relocations are emited, R_IHIHALF,
1693 and R_IHCONST. The second one doesn't contain a
1694 symbol, but uses the value for offset. */
1696 if (intr
.r_type
== R_IHIHALF
)
1698 /* now emit the second bit */
1699 intr
.r_type
= R_IHCONST
;
1700 intr
.r_symndx
= fix_ptr
->fx_addnumber
;
1701 (void) bfd_coff_swap_reloc_out (abfd
, &intr
, ext_ptr
);
1707 fix_ptr
= fix_ptr
->fx_next
;
1711 /* Sort the reloc table */
1712 qsort ((PTR
) external_reloc_vec
, nrelocs
,
1713 sizeof (struct external_reloc
), compare_external_relocs
);
1716 /* Write out the reloc table */
1717 bfd_write ((PTR
) external_reloc_vec
, 1, external_reloc_size
,
1719 free (external_reloc_vec
);
1721 /* Fill in section header info. */
1722 segment_info
[idx
].scnhdr
.s_relptr
= *file_cursor
;
1723 *file_cursor
+= external_reloc_size
;
1724 segment_info
[idx
].scnhdr
.s_nreloc
= nrelocs
;
1729 segment_info
[idx
].scnhdr
.s_relptr
= 0;
1733 /* Set relocation_size field in file headers */
1734 H_SET_RELOCATION_SIZE (h
, *file_cursor
- reloc_start
, 0);
1738 /* run through a frag chain and write out the data to go with it, fill
1739 in the scnhdrs with the info on the file postions
1742 fill_section (abfd
, h
, file_cursor
)
1745 unsigned long *file_cursor
;
1749 unsigned int paddr
= 0;
1751 for (i
= SEG_E0
; i
< SEG_UNKNOWN
; i
++)
1753 unsigned int offset
= 0;
1754 struct internal_scnhdr
*s
= &(segment_info
[i
].scnhdr
);
1760 fragS
*frag
= segment_info
[i
].frchainP
->frch_root
;
1767 buffer
= xmalloc (s
->s_size
);
1768 s
->s_scnptr
= *file_cursor
;
1770 know (s
->s_paddr
== paddr
);
1772 if (strcmp (s
->s_name
, ".text") == 0)
1773 s
->s_flags
|= STYP_TEXT
;
1774 else if (strcmp (s
->s_name
, ".data") == 0)
1775 s
->s_flags
|= STYP_DATA
;
1776 else if (strcmp (s
->s_name
, ".bss") == 0)
1779 s
->s_flags
|= STYP_BSS
;
1781 /* @@ Should make the i386 and a29k coff targets define
1782 COFF_NOLOAD_PROBLEM, and have only one test here. */
1785 #ifndef COFF_NOLOAD_PROBLEM
1786 /* Apparently the SVR3 linker (and exec syscall) and UDI
1787 mondfe progrem are confused by noload sections. */
1788 s
->s_flags
|= STYP_NOLOAD
;
1793 else if (strcmp (s
->s_name
, ".lit") == 0)
1794 s
->s_flags
= STYP_LIT
| STYP_TEXT
;
1795 else if (strcmp (s
->s_name
, ".init") == 0)
1796 s
->s_flags
|= STYP_TEXT
;
1797 else if (strcmp (s
->s_name
, ".fini") == 0)
1798 s
->s_flags
|= STYP_TEXT
;
1799 else if (strncmp (s
->s_name
, ".comment", 8) == 0)
1800 s
->s_flags
|= STYP_INFO
;
1804 unsigned int fill_size
;
1805 switch (frag
->fr_type
)
1807 case rs_machine_dependent
:
1810 memcpy (buffer
+ frag
->fr_address
,
1812 (unsigned int) frag
->fr_fix
);
1813 offset
+= frag
->fr_fix
;
1818 assert (frag
->fr_symbol
== 0);
1825 memcpy (buffer
+ frag
->fr_address
,
1827 (unsigned int) frag
->fr_fix
);
1828 offset
+= frag
->fr_fix
;
1831 fill_size
= frag
->fr_var
;
1832 if (fill_size
&& frag
->fr_offset
> 0)
1835 unsigned int off
= frag
->fr_fix
;
1836 for (count
= frag
->fr_offset
; count
; count
--)
1838 if (fill_size
+ frag
->fr_address
+ off
<= s
->s_size
)
1840 memcpy (buffer
+ frag
->fr_address
+ off
,
1841 frag
->fr_literal
+ frag
->fr_fix
,
1844 offset
+= fill_size
;
1849 case rs_broken_word
:
1854 frag
= frag
->fr_next
;
1859 if (s
->s_scnptr
!= 0)
1861 bfd_write (buffer
, s
->s_size
, 1, abfd
);
1862 *file_cursor
+= s
->s_size
;
1871 /* Coff file generation & utilities */
1874 coff_header_append (abfd
, h
)
1882 bfd_seek (abfd
, 0, 0);
1884 #ifndef OBJ_COFF_OMIT_OPTIONAL_HEADER
1885 H_SET_MAGIC_NUMBER (h
, COFF_MAGIC
);
1886 H_SET_VERSION_STAMP (h
, 0);
1887 H_SET_ENTRY_POINT (h
, 0);
1888 H_SET_TEXT_START (h
, segment_info
[SEG_E0
].frchainP
->frch_root
->fr_address
);
1889 H_SET_DATA_START (h
, segment_info
[SEG_E1
].frchainP
->frch_root
->fr_address
);
1890 H_SET_SIZEOF_OPTIONAL_HEADER (h
, bfd_coff_swap_aouthdr_out(abfd
, &h
->aouthdr
,
1892 #else /* defined (OBJ_COFF_OMIT_OPTIONAL_HEADER) */
1893 H_SET_SIZEOF_OPTIONAL_HEADER (h
, 0);
1894 #endif /* defined (OBJ_COFF_OMIT_OPTIONAL_HEADER) */
1896 i
= bfd_coff_swap_filehdr_out (abfd
, &h
->filehdr
, buffer
);
1898 bfd_write (buffer
, i
, 1, abfd
);
1899 bfd_write (buffero
, H_GET_SIZEOF_OPTIONAL_HEADER (h
), 1, abfd
);
1901 for (i
= SEG_E0
; i
< SEG_LAST
; i
++)
1903 #ifdef COFF_LONG_SECTION_NAMES
1904 unsigned long string_size
= 4;
1907 if (segment_info
[i
].scnhdr
.s_name
[0])
1911 #ifdef COFF_LONG_SECTION_NAMES
1912 /* Support long section names as found in PE. This code
1913 must coordinate with that in write_object_file and
1915 if (strlen (segment_info
[i
].name
) > SCNNMLEN
)
1917 memset (segment_info
[i
].scnhdr
.s_name
, 0, SCNNMLEN
);
1918 sprintf (segment_info
[i
].scnhdr
.s_name
, "/%lu", string_size
);
1919 string_size
+= strlen (segment_info
[i
].name
) + 1;
1923 size
= bfd_coff_swap_scnhdr_out (abfd
,
1924 &(segment_info
[i
].scnhdr
),
1927 as_bad ("bfd_coff_swap_scnhdr_out failed");
1928 bfd_write (buffer
, size
, 1, abfd
);
1935 symbol_to_chars (abfd
, where
, symbolP
)
1940 unsigned int numaux
= symbolP
->sy_symbol
.ost_entry
.n_numaux
;
1944 /* Turn any symbols with register attributes into abs symbols */
1945 if (S_GET_SEGMENT (symbolP
) == reg_section
)
1947 S_SET_SEGMENT (symbolP
, absolute_section
);
1949 /* At the same time, relocate all symbols to their output value */
1951 val
= (segment_info
[S_GET_SEGMENT (symbolP
)].scnhdr
.s_paddr
1952 + S_GET_VALUE (symbolP
));
1954 S_SET_VALUE (symbolP
, val
);
1956 symbolP
->sy_symbol
.ost_entry
.n_value
= val
;
1958 where
+= bfd_coff_swap_sym_out (abfd
, &symbolP
->sy_symbol
.ost_entry
,
1961 for (i
= 0; i
< numaux
; i
++)
1963 where
+= bfd_coff_swap_aux_out (abfd
,
1964 &symbolP
->sy_symbol
.ost_auxent
[i
],
1965 S_GET_DATA_TYPE (symbolP
),
1966 S_GET_STORAGE_CLASS (symbolP
),
1974 obj_symbol_new_hook (symbolP
)
1977 char underscore
= 0; /* Symbol has leading _ */
1979 /* Effective symbol */
1980 /* Store the pointer in the offset. */
1981 S_SET_ZEROES (symbolP
, 0L);
1982 S_SET_DATA_TYPE (symbolP
, T_NULL
);
1983 S_SET_STORAGE_CLASS (symbolP
, 0);
1984 S_SET_NUMBER_AUXILIARY (symbolP
, 0);
1985 /* Additional information */
1986 symbolP
->sy_symbol
.ost_flags
= 0;
1987 /* Auxiliary entries */
1988 memset ((char *) &symbolP
->sy_symbol
.ost_auxent
[0], 0, AUXESZ
);
1990 if (S_IS_STRING (symbolP
))
1991 SF_SET_STRING (symbolP
);
1992 if (!underscore
&& S_IS_LOCAL (symbolP
))
1993 SF_SET_LOCAL (symbolP
);
1997 * Handle .ln directives.
2001 obj_coff_ln (appline
)
2006 if (! appline
&& def_symbol_in_progress
!= NULL
)
2008 as_warn (".ln pseudo-op inside .def/.endef: ignored.");
2009 demand_empty_rest_of_line ();
2011 } /* wrong context */
2013 l
= get_absolute_expression ();
2014 c_line_new (0, frag_now_fix (), l
, frag_now
);
2023 listing_source_line ((unsigned int) l
);
2028 demand_empty_rest_of_line ();
2034 * Handle .def directives.
2036 * One might ask : why can't we symbol_new if the symbol does not
2037 * already exist and fill it with debug information. Because of
2038 * the C_EFCN special symbol. It would clobber the value of the
2039 * function symbol before we have a chance to notice that it is
2040 * a C_EFCN. And a second reason is that the code is more clear this
2041 * way. (at least I think it is :-).
2045 #define SKIP_SEMI_COLON() while (*input_line_pointer++ != ';')
2046 #define SKIP_WHITESPACES() while (*input_line_pointer == ' ' || \
2047 *input_line_pointer == '\t') \
2048 input_line_pointer++;
2054 char name_end
; /* Char after the end of name */
2055 char *symbol_name
; /* Name of the debug symbol */
2056 char *symbol_name_copy
; /* Temporary copy of the name */
2057 unsigned int symbol_name_length
;
2059 if (def_symbol_in_progress
!= NULL
)
2061 as_warn (".def pseudo-op used inside of .def/.endef: ignored.");
2062 demand_empty_rest_of_line ();
2064 } /* if not inside .def/.endef */
2066 SKIP_WHITESPACES ();
2068 def_symbol_in_progress
= (symbolS
*) obstack_alloc (¬es
, sizeof (*def_symbol_in_progress
));
2069 memset (def_symbol_in_progress
, 0, sizeof (*def_symbol_in_progress
));
2071 symbol_name
= input_line_pointer
;
2072 name_end
= get_symbol_end ();
2073 symbol_name_length
= strlen (symbol_name
);
2074 symbol_name_copy
= xmalloc (symbol_name_length
+ 1);
2075 strcpy (symbol_name_copy
, symbol_name
);
2077 /* Initialize the new symbol */
2078 #ifdef STRIP_UNDERSCORE
2079 S_SET_NAME (def_symbol_in_progress
, (*symbol_name_copy
== '_'
2080 ? symbol_name_copy
+ 1
2081 : symbol_name_copy
));
2082 #else /* STRIP_UNDERSCORE */
2083 S_SET_NAME (def_symbol_in_progress
, symbol_name_copy
);
2084 #endif /* STRIP_UNDERSCORE */
2085 /* free(symbol_name_copy); */
2086 def_symbol_in_progress
->sy_name_offset
= (unsigned long) ~0;
2087 def_symbol_in_progress
->sy_number
= ~0;
2088 def_symbol_in_progress
->sy_frag
= &zero_address_frag
;
2089 S_SET_VALUE (def_symbol_in_progress
, 0);
2091 if (S_IS_STRING (def_symbol_in_progress
))
2092 SF_SET_STRING (def_symbol_in_progress
);
2094 *input_line_pointer
= name_end
;
2096 demand_empty_rest_of_line ();
2099 unsigned int dim_index
;
2103 obj_coff_endef (ignore
)
2106 symbolS
*symbolP
= 0;
2107 /* DIM BUG FIX sac@cygnus.com */
2109 if (def_symbol_in_progress
== NULL
)
2111 as_warn (".endef pseudo-op used outside of .def/.endef: ignored.");
2112 demand_empty_rest_of_line ();
2114 } /* if not inside .def/.endef */
2116 /* Set the section number according to storage class. */
2117 switch (S_GET_STORAGE_CLASS (def_symbol_in_progress
))
2122 SF_SET_TAG (def_symbol_in_progress
);
2123 /* intentional fallthrough */
2126 SF_SET_DEBUG (def_symbol_in_progress
);
2127 S_SET_SEGMENT (def_symbol_in_progress
, SEG_DEBUG
);
2131 SF_SET_LOCAL (def_symbol_in_progress
); /* Do not emit this symbol. */
2132 /* intentional fallthrough */
2134 SF_SET_PROCESS (def_symbol_in_progress
); /* Will need processing before writing */
2135 /* intentional fallthrough */
2137 S_SET_SEGMENT (def_symbol_in_progress
, SEG_E0
);
2139 if (strcmp (S_GET_NAME (def_symbol_in_progress
), ".bf") == 0)
2141 if (function_lineoff
< 0)
2143 fprintf (stderr
, "`.bf' symbol without preceding function\n");
2144 } /* missing function symbol */
2145 SA_GET_SYM_LNNOPTR (last_line_symbol
) = function_lineoff
;
2147 SF_SET_PROCESS (last_line_symbol
);
2148 SF_SET_ADJ_LNNOPTR (last_line_symbol
);
2149 SF_SET_PROCESS (def_symbol_in_progress
);
2150 function_lineoff
= -1;
2152 /* Value is always set to . */
2153 def_symbol_in_progress
->sy_frag
= frag_now
;
2154 S_SET_VALUE (def_symbol_in_progress
, (valueT
) frag_now_fix ());
2159 #endif /* C_AUTOARG */
2169 SF_SET_DEBUG (def_symbol_in_progress
);
2170 S_SET_SEGMENT (def_symbol_in_progress
, absolute_section
);
2176 /* Valid but set somewhere else (s_comm, s_lcomm, colon) */
2182 as_warn ("unexpected storage class %d", S_GET_STORAGE_CLASS (def_symbol_in_progress
));
2184 } /* switch on storage class */
2186 /* Now that we have built a debug symbol, try to find if we should
2187 merge with an existing symbol or not. If a symbol is C_EFCN or
2188 absolute_section or untagged SEG_DEBUG it never merges. We also
2189 don't merge labels, which are in a different namespace, nor
2190 symbols which have not yet been defined since they are typically
2191 unique, nor do we merge tags with non-tags. */
2193 /* Two cases for functions. Either debug followed by definition or
2194 definition followed by debug. For definition first, we will
2195 merge the debug symbol into the definition. For debug first, the
2196 lineno entry MUST point to the definition function or else it
2197 will point off into space when crawl_symbols() merges the debug
2198 symbol into the real symbol. Therefor, let's presume the debug
2199 symbol is a real function reference. */
2201 /* FIXME-SOON If for some reason the definition label/symbol is
2202 never seen, this will probably leave an undefined symbol at link
2205 if (S_GET_STORAGE_CLASS (def_symbol_in_progress
) == C_EFCN
2206 || S_GET_STORAGE_CLASS (def_symbol_in_progress
) == C_LABEL
2207 || (S_GET_SEGMENT (def_symbol_in_progress
) == SEG_DEBUG
2208 && !SF_GET_TAG (def_symbol_in_progress
))
2209 || S_GET_SEGMENT (def_symbol_in_progress
) == absolute_section
2210 || def_symbol_in_progress
->sy_value
.X_op
!= O_constant
2211 || (symbolP
= symbol_find_base (S_GET_NAME (def_symbol_in_progress
), DO_NOT_STRIP
)) == NULL
2212 || (SF_GET_TAG (def_symbol_in_progress
) != SF_GET_TAG (symbolP
)))
2214 symbol_append (def_symbol_in_progress
, symbol_lastP
, &symbol_rootP
,
2219 /* This symbol already exists, merge the newly created symbol
2220 into the old one. This is not mandatory. The linker can
2221 handle duplicate symbols correctly. But I guess that it save
2222 a *lot* of space if the assembly file defines a lot of
2225 /* The debug entry (def_symbol_in_progress) is merged into the
2226 previous definition. */
2228 c_symbol_merge (def_symbol_in_progress
, symbolP
);
2229 /* FIXME-SOON Should *def_symbol_in_progress be free'd? xoxorich. */
2230 def_symbol_in_progress
= symbolP
;
2232 if (SF_GET_FUNCTION (def_symbol_in_progress
)
2233 || SF_GET_TAG (def_symbol_in_progress
)
2234 || S_GET_STORAGE_CLASS (def_symbol_in_progress
) == C_STAT
)
2236 /* For functions, and tags, and static symbols, the symbol
2237 *must* be where the debug symbol appears. Move the
2238 existing symbol to the current place. */
2239 /* If it already is at the end of the symbol list, do nothing */
2240 if (def_symbol_in_progress
!= symbol_lastP
)
2242 symbol_remove (def_symbol_in_progress
, &symbol_rootP
,
2244 symbol_append (def_symbol_in_progress
, symbol_lastP
,
2245 &symbol_rootP
, &symbol_lastP
);
2246 } /* if not already in place */
2248 } /* normal or mergable */
2250 if (SF_GET_TAG (def_symbol_in_progress
))
2254 oldtag
= symbol_find_base (S_GET_NAME (def_symbol_in_progress
),
2256 if (oldtag
== NULL
|| ! SF_GET_TAG (oldtag
))
2257 tag_insert (S_GET_NAME (def_symbol_in_progress
),
2258 def_symbol_in_progress
);
2261 if (SF_GET_FUNCTION (def_symbol_in_progress
))
2263 know (sizeof (def_symbol_in_progress
) <= sizeof (long));
2265 = c_line_new (def_symbol_in_progress
, 0, 0, &zero_address_frag
);
2267 SF_SET_PROCESS (def_symbol_in_progress
);
2269 if (symbolP
== NULL
)
2271 /* That is, if this is the first time we've seen the
2273 symbol_table_insert (def_symbol_in_progress
);
2274 } /* definition follows debug */
2275 } /* Create the line number entry pointing to the function being defined */
2277 def_symbol_in_progress
= NULL
;
2278 demand_empty_rest_of_line ();
2282 obj_coff_dim (ignore
)
2287 if (def_symbol_in_progress
== NULL
)
2289 as_warn (".dim pseudo-op used outside of .def/.endef: ignored.");
2290 demand_empty_rest_of_line ();
2292 } /* if not inside .def/.endef */
2294 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
2296 for (dim_index
= 0; dim_index
< DIMNUM
; dim_index
++)
2298 SKIP_WHITESPACES ();
2299 SA_SET_SYM_DIMEN (def_symbol_in_progress
, dim_index
,
2300 get_absolute_expression ());
2302 switch (*input_line_pointer
)
2305 input_line_pointer
++;
2309 as_warn ("badly formed .dim directive ignored");
2310 /* intentional fallthrough */
2318 demand_empty_rest_of_line ();
2322 obj_coff_line (ignore
)
2328 if (def_symbol_in_progress
== NULL
)
2334 name
= S_GET_NAME (def_symbol_in_progress
);
2335 this_base
= get_absolute_expression ();
2337 /* Only .bf symbols indicate the use of a new base line number; the
2338 line numbers associated with .ef, .bb, .eb are relative to the
2339 start of the containing function. */
2340 if (!strcmp (".bf", name
))
2342 #if 0 /* XXX Can we ever have line numbers going backwards? */
2343 if (this_base
> line_base
)
2346 line_base
= this_base
;
2354 listing_source_line ((unsigned int) line_base
);
2360 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
2361 SA_SET_SYM_LNNO (def_symbol_in_progress
, this_base
);
2363 demand_empty_rest_of_line ();
2367 obj_coff_size (ignore
)
2370 if (def_symbol_in_progress
== NULL
)
2372 as_warn (".size pseudo-op used outside of .def/.endef ignored.");
2373 demand_empty_rest_of_line ();
2375 } /* if not inside .def/.endef */
2377 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
2378 SA_SET_SYM_SIZE (def_symbol_in_progress
, get_absolute_expression ());
2379 demand_empty_rest_of_line ();
2383 obj_coff_scl (ignore
)
2386 if (def_symbol_in_progress
== NULL
)
2388 as_warn (".scl pseudo-op used outside of .def/.endef ignored.");
2389 demand_empty_rest_of_line ();
2391 } /* if not inside .def/.endef */
2393 S_SET_STORAGE_CLASS (def_symbol_in_progress
, get_absolute_expression ());
2394 demand_empty_rest_of_line ();
2398 obj_coff_tag (ignore
)
2404 if (def_symbol_in_progress
== NULL
)
2406 as_warn (".tag pseudo-op used outside of .def/.endef ignored.");
2407 demand_empty_rest_of_line ();
2411 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
2412 symbol_name
= input_line_pointer
;
2413 name_end
= get_symbol_end ();
2415 /* Assume that the symbol referred to by .tag is always defined.
2416 This was a bad assumption. I've added find_or_make. xoxorich. */
2417 SA_SET_SYM_TAGNDX (def_symbol_in_progress
,
2418 (long) tag_find_or_make (symbol_name
));
2419 if (SA_GET_SYM_TAGNDX (def_symbol_in_progress
) == 0L)
2421 as_warn ("tag not found for .tag %s", symbol_name
);
2424 SF_SET_TAGGED (def_symbol_in_progress
);
2425 *input_line_pointer
= name_end
;
2427 demand_empty_rest_of_line ();
2431 obj_coff_type (ignore
)
2434 if (def_symbol_in_progress
== NULL
)
2436 as_warn (".type pseudo-op used outside of .def/.endef ignored.");
2437 demand_empty_rest_of_line ();
2439 } /* if not inside .def/.endef */
2441 S_SET_DATA_TYPE (def_symbol_in_progress
, get_absolute_expression ());
2443 if (ISFCN (S_GET_DATA_TYPE (def_symbol_in_progress
)) &&
2444 S_GET_STORAGE_CLASS (def_symbol_in_progress
) != C_TPDEF
)
2446 SF_SET_FUNCTION (def_symbol_in_progress
);
2447 } /* is a function */
2449 demand_empty_rest_of_line ();
2453 obj_coff_val (ignore
)
2456 if (def_symbol_in_progress
== NULL
)
2458 as_warn (".val pseudo-op used outside of .def/.endef ignored.");
2459 demand_empty_rest_of_line ();
2461 } /* if not inside .def/.endef */
2463 if (is_name_beginner (*input_line_pointer
))
2465 char *symbol_name
= input_line_pointer
;
2466 char name_end
= get_symbol_end ();
2468 if (!strcmp (symbol_name
, "."))
2470 def_symbol_in_progress
->sy_frag
= frag_now
;
2471 S_SET_VALUE (def_symbol_in_progress
, (valueT
) frag_now_fix ());
2472 /* If the .val is != from the .def (e.g. statics) */
2474 else if (strcmp (S_GET_NAME (def_symbol_in_progress
), symbol_name
))
2476 def_symbol_in_progress
->sy_value
.X_op
= O_symbol
;
2477 def_symbol_in_progress
->sy_value
.X_add_symbol
=
2478 symbol_find_or_make (symbol_name
);
2479 def_symbol_in_progress
->sy_value
.X_op_symbol
= NULL
;
2480 def_symbol_in_progress
->sy_value
.X_add_number
= 0;
2482 /* If the segment is undefined when the forward reference is
2483 resolved, then copy the segment id from the forward
2485 SF_SET_GET_SEGMENT (def_symbol_in_progress
);
2487 /* FIXME: gcc can generate address expressions
2488 here in unusual cases (search for "obscure"
2489 in sdbout.c). We just ignore the offset
2490 here, thus generating incorrect debugging
2491 information. We ignore the rest of the
2494 /* Otherwise, it is the name of a non debug symbol and
2495 its value will be calculated later. */
2496 *input_line_pointer
= name_end
;
2498 /* FIXME: this is to avoid an error message in the
2499 FIXME case mentioned just above. */
2500 while (! is_end_of_line
[(unsigned char) *input_line_pointer
])
2501 ++input_line_pointer
;
2505 S_SET_VALUE (def_symbol_in_progress
,
2506 (valueT
) get_absolute_expression ());
2507 } /* if symbol based */
2509 demand_empty_rest_of_line ();
2514 /* Handle the .linkonce pseudo-op. This is parsed by s_linkonce in
2515 read.c, which then calls this object file format specific routine. */
2518 obj_coff_pe_handle_link_once (type
)
2519 enum linkonce_type type
;
2521 seg_info (now_seg
)->scnhdr
.s_flags
|= IMAGE_SCN_LNK_COMDAT
;
2523 /* We store the type in the seg_info structure, and use it to set up
2524 the auxiliary entry for the section symbol in c_section_symbol. */
2525 seg_info (now_seg
)->linkonce
= type
;
2531 obj_read_begin_hook ()
2533 /* These had better be the same. Usually 18 bytes. */
2535 know (sizeof (SYMENT
) == sizeof (AUXENT
));
2536 know (SYMESZ
== AUXESZ
);
2541 /* This function runs through the symbol table and puts all the
2542 externals onto another chain */
2544 /* The chain of globals. */
2545 symbolS
*symbol_globalP
;
2546 symbolS
*symbol_global_lastP
;
2548 /* The chain of externals */
2549 symbolS
*symbol_externP
;
2550 symbolS
*symbol_extern_lastP
;
2553 symbolS
*last_functionP
;
2554 static symbolS
*last_bfP
;
2561 unsigned int symbol_number
= 0;
2562 unsigned int last_file_symno
= 0;
2564 struct filename_list
*filename_list_scan
= filename_list_head
;
2566 for (symbolP
= symbol_rootP
;
2568 symbolP
= symbolP
? symbol_next (symbolP
) : symbol_rootP
)
2570 if (symbolP
->sy_mri_common
)
2572 if (S_GET_STORAGE_CLASS (symbolP
) == C_EXT
)
2573 as_bad ("%s: global symbols not supported in common sections",
2574 S_GET_NAME (symbolP
));
2575 symbol_remove (symbolP
, &symbol_rootP
, &symbol_lastP
);
2579 if (!SF_GET_DEBUG (symbolP
))
2581 /* Debug symbols do not need all this rubbish */
2582 symbolS
*real_symbolP
;
2584 /* L* and C_EFCN symbols never merge. */
2585 if (!SF_GET_LOCAL (symbolP
)
2586 && !SF_GET_STATICS (symbolP
)
2587 && S_GET_STORAGE_CLASS (symbolP
) != C_LABEL
2588 && symbolP
->sy_value
.X_op
== O_constant
2589 && (real_symbolP
= symbol_find_base (S_GET_NAME (symbolP
), DO_NOT_STRIP
))
2590 && real_symbolP
!= symbolP
)
2592 /* FIXME-SOON: where do dups come from?
2593 Maybe tag references before definitions? xoxorich. */
2594 /* Move the debug data from the debug symbol to the
2595 real symbol. Do NOT do the oposite (i.e. move from
2596 real symbol to debug symbol and remove real symbol from the
2597 list.) Because some pointers refer to the real symbol
2598 whereas no pointers refer to the debug symbol. */
2599 c_symbol_merge (symbolP
, real_symbolP
);
2600 /* Replace the current symbol by the real one */
2601 /* The symbols will never be the last or the first
2602 because : 1st symbol is .file and 3 last symbols are
2603 .text, .data, .bss */
2604 symbol_remove (real_symbolP
, &symbol_rootP
, &symbol_lastP
);
2605 symbol_insert (real_symbolP
, symbolP
, &symbol_rootP
, &symbol_lastP
);
2606 symbol_remove (symbolP
, &symbol_rootP
, &symbol_lastP
);
2607 symbolP
= real_symbolP
;
2608 } /* if not local but dup'd */
2610 if (flag_readonly_data_in_text
&& (S_GET_SEGMENT (symbolP
) == SEG_E1
))
2612 S_SET_SEGMENT (symbolP
, SEG_E0
);
2613 } /* push data into text */
2615 resolve_symbol_value (symbolP
);
2617 if (S_GET_STORAGE_CLASS (symbolP
) == C_NULL
)
2619 if (!S_IS_DEFINED (symbolP
) && !SF_GET_LOCAL (symbolP
))
2621 S_SET_EXTERNAL (symbolP
);
2623 else if (S_GET_SEGMENT (symbolP
) == SEG_E0
)
2625 S_SET_STORAGE_CLASS (symbolP
, C_LABEL
);
2629 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
2633 /* Mainly to speed up if not -g */
2634 if (SF_GET_PROCESS (symbolP
))
2636 /* Handle the nested blocks auxiliary info. */
2637 if (S_GET_STORAGE_CLASS (symbolP
) == C_BLOCK
)
2639 if (!strcmp (S_GET_NAME (symbolP
), ".bb"))
2640 stack_push (block_stack
, (char *) &symbolP
);
2643 register symbolS
*begin_symbolP
;
2644 begin_symbolP
= *(symbolS
**) stack_pop (block_stack
);
2645 if (begin_symbolP
== (symbolS
*) 0)
2646 as_warn ("mismatched .eb");
2648 SA_SET_SYM_ENDNDX (begin_symbolP
, symbol_number
+ 2);
2651 /* If we are able to identify the type of a function, and we
2652 are out of a function (last_functionP == 0) then, the
2653 function symbol will be associated with an auxiliary
2655 if (last_functionP
== (symbolS
*) 0 &&
2656 SF_GET_FUNCTION (symbolP
))
2658 last_functionP
= symbolP
;
2660 if (S_GET_NUMBER_AUXILIARY (symbolP
) < 1)
2662 S_SET_NUMBER_AUXILIARY (symbolP
, 1);
2663 } /* make it at least 1 */
2665 /* Clobber possible stale .dim information. */
2667 /* Iffed out by steve - this fries the lnnoptr info too */
2668 bzero (symbolP
->sy_symbol
.ost_auxent
[0].x_sym
.x_fcnary
.x_ary
.x_dimen
,
2669 sizeof (symbolP
->sy_symbol
.ost_auxent
[0].x_sym
.x_fcnary
.x_ary
.x_dimen
));
2672 if (S_GET_STORAGE_CLASS (symbolP
) == C_FCN
)
2674 if (strcmp (S_GET_NAME (symbolP
), ".bf") == 0)
2676 if (last_bfP
!= NULL
)
2677 SA_SET_SYM_ENDNDX (last_bfP
, symbol_number
);
2681 else if (S_GET_STORAGE_CLASS (symbolP
) == C_EFCN
)
2683 /* I don't even know if this is needed for sdb. But
2684 the standard assembler generates it, so... */
2685 if (last_functionP
== (symbolS
*) 0)
2686 as_fatal ("C_EFCN symbol out of scope");
2687 SA_SET_SYM_FSIZE (last_functionP
,
2688 (long) (S_GET_VALUE (symbolP
) -
2689 S_GET_VALUE (last_functionP
)));
2690 SA_SET_SYM_ENDNDX (last_functionP
, symbol_number
);
2691 last_functionP
= (symbolS
*) 0;
2695 else if (SF_GET_TAG (symbolP
))
2697 /* First descriptor of a structure must point to
2698 the first slot after the structure description. */
2699 last_tagP
= symbolP
;
2702 else if (S_GET_STORAGE_CLASS (symbolP
) == C_EOS
)
2704 /* +2 take in account the current symbol */
2705 SA_SET_SYM_ENDNDX (last_tagP
, symbol_number
+ 2);
2707 else if (S_GET_STORAGE_CLASS (symbolP
) == C_FILE
)
2709 /* If the filename was too long to fit in the
2710 auxent, put it in the string table */
2711 if (SA_GET_FILE_FNAME_ZEROS (symbolP
) == 0
2712 && SA_GET_FILE_FNAME_OFFSET (symbolP
) != 0)
2714 SA_SET_FILE_FNAME_OFFSET (symbolP
, string_byte_count
);
2715 string_byte_count
+= strlen (filename_list_scan
->filename
) + 1;
2716 filename_list_scan
= filename_list_scan
->next
;
2718 if (S_GET_VALUE (symbolP
))
2720 S_SET_VALUE (symbolP
, last_file_symno
);
2721 last_file_symno
= symbol_number
;
2722 } /* no one points at the first .file symbol */
2723 } /* if debug or tag or eos or file */
2725 /* We must put the external symbols apart. The loader
2726 does not bomb if we do not. But the references in
2727 the endndx field for a .bb symbol are not corrected
2728 if an external symbol is removed between .bb and .be.
2729 I.e in the following case :
2730 [20] .bb endndx = 22
2733 ld will move the symbol 21 to the end of the list but
2734 endndx will still be 22 instead of 21. */
2737 if (SF_GET_LOCAL (symbolP
))
2739 /* remove C_EFCN and LOCAL (L...) symbols */
2740 /* next pointer remains valid */
2741 symbol_remove (symbolP
, &symbol_rootP
, &symbol_lastP
);
2744 else if (symbolP
->sy_value
.X_op
== O_symbol
2745 && (! S_IS_DEFINED (symbolP
) || S_IS_COMMON (symbolP
)))
2747 /* Skip symbols which were equated to undefined or common
2749 symbol_remove (symbolP
, &symbol_rootP
, &symbol_lastP
);
2751 else if (!S_IS_DEFINED (symbolP
)
2752 && !S_IS_DEBUG (symbolP
)
2753 && !SF_GET_STATICS (symbolP
) &&
2754 S_GET_STORAGE_CLASS (symbolP
) == C_EXT
)
2755 { /* C_EXT && !SF_GET_FUNCTION(symbolP)) */
2756 /* if external, Remove from the list */
2757 symbolS
*hold
= symbol_previous (symbolP
);
2759 symbol_remove (symbolP
, &symbol_rootP
, &symbol_lastP
);
2760 symbol_clear_list_pointers (symbolP
);
2761 symbol_append (symbolP
, symbol_extern_lastP
, &symbol_externP
, &symbol_extern_lastP
);
2764 else if (! S_IS_DEBUG (symbolP
)
2765 && ! SF_GET_STATICS (symbolP
)
2766 && ! SF_GET_FUNCTION (symbolP
)
2767 && S_GET_STORAGE_CLASS (symbolP
) == C_EXT
)
2769 symbolS
*hold
= symbol_previous (symbolP
);
2771 /* The O'Reilly COFF book says that defined global symbols
2772 come at the end of the symbol table, just before
2773 undefined global symbols. */
2775 symbol_remove (symbolP
, &symbol_rootP
, &symbol_lastP
);
2776 symbol_clear_list_pointers (symbolP
);
2777 symbol_append (symbolP
, symbol_global_lastP
, &symbol_globalP
,
2778 &symbol_global_lastP
);
2783 if (SF_GET_STRING (symbolP
))
2785 symbolP
->sy_name_offset
= string_byte_count
;
2786 string_byte_count
+= strlen (S_GET_NAME (symbolP
)) + 1;
2790 symbolP
->sy_name_offset
= 0;
2791 } /* fix "long" names */
2793 symbolP
->sy_number
= symbol_number
;
2794 symbol_number
+= 1 + S_GET_NUMBER_AUXILIARY (symbolP
);
2795 } /* if local symbol */
2796 } /* traverse the symbol list */
2797 return symbol_number
;
2803 glue_symbols (head
, tail
)
2807 unsigned int symbol_number
= 0;
2810 for (symbolP
= *head
; *head
!= NULL
;)
2812 symbolS
*tmp
= *head
;
2815 symbol_remove (tmp
, head
, tail
);
2816 symbol_append (tmp
, symbol_lastP
, &symbol_rootP
, &symbol_lastP
);
2819 if (SF_GET_STRING (tmp
))
2821 tmp
->sy_name_offset
= string_byte_count
;
2822 string_byte_count
+= strlen (S_GET_NAME (tmp
)) + 1;
2826 tmp
->sy_name_offset
= 0;
2827 } /* fix "long" names */
2829 tmp
->sy_number
= symbol_number
;
2830 symbol_number
+= 1 + S_GET_NUMBER_AUXILIARY (tmp
);
2831 } /* append the entire extern chain */
2833 return symbol_number
;
2839 unsigned int symbol_number
= 0;
2842 for (symbolP
= symbol_rootP
; symbolP
; symbolP
=
2843 symbol_next (symbolP
))
2845 symbolP
->sy_number
= symbol_number
;
2849 if (SF_GET_TAGGED (symbolP
))
2853 ((symbolS
*) SA_GET_SYM_TAGNDX (symbolP
))->sy_number
);
2856 symbol_number
+= 1 + S_GET_NUMBER_AUXILIARY (symbolP
);
2858 return symbol_number
;
2863 crawl_symbols (h
, abfd
)
2869 /* Initialize the stack used to keep track of the matching .bb .be */
2871 block_stack
= stack_init (512, sizeof (symbolS
*));
2873 /* The symbol list should be ordered according to the following sequence
2876 * . debug entries for functions
2877 * . fake symbols for the sections, including.text .data and .bss
2879 * . undefined symbols
2880 * But this is not mandatory. The only important point is to put the
2881 * undefined symbols at the end of the list.
2884 if (symbol_rootP
== NULL
2885 || S_GET_STORAGE_CLASS (symbol_rootP
) != C_FILE
)
2887 c_dot_file_symbol ("fake");
2889 /* Is there a .file symbol ? If not insert one at the beginning. */
2892 * Build up static symbols for the sections, they are filled in later
2896 for (i
= SEG_E0
; i
< SEG_LAST
; i
++)
2897 if (segment_info
[i
].scnhdr
.s_name
[0])
2898 segment_info
[i
].dot
= c_section_symbol (segment_info
[i
].name
,
2901 /* Take all the externals out and put them into another chain */
2902 H_SET_SYMBOL_TABLE_SIZE (h
, yank_symbols ());
2903 /* Take the externals and glue them onto the end.*/
2904 H_SET_SYMBOL_TABLE_SIZE (h
,
2905 (H_GET_SYMBOL_COUNT (h
)
2906 + glue_symbols (&symbol_globalP
,
2907 &symbol_global_lastP
)
2908 + glue_symbols (&symbol_externP
,
2909 &symbol_extern_lastP
)));
2911 H_SET_SYMBOL_TABLE_SIZE (h
, tie_tags ());
2912 know (symbol_globalP
== NULL
);
2913 know (symbol_global_lastP
== NULL
);
2914 know (symbol_externP
== NULL
);
2915 know (symbol_extern_lastP
== NULL
);
2919 * Find strings by crawling along symbol table chain.
2927 struct filename_list
*filename_list_scan
= filename_list_head
;
2929 /* Gotta do md_ byte-ordering stuff for string_byte_count first - KWK */
2930 md_number_to_chars (where
, (valueT
) string_byte_count
, 4);
2933 #ifdef COFF_LONG_SECTION_NAMES
2934 /* Support long section names as found in PE. This code must
2935 coordinate with that in coff_header_append and write_object_file. */
2939 for (i
= SEG_E0
; i
< SEG_LAST
; i
++)
2941 if (segment_info
[i
].scnhdr
.s_name
[0]
2942 && strlen (segment_info
[i
].name
) > SCNNMLEN
)
2946 size
= strlen (segment_info
[i
].name
) + 1;
2947 memcpy (where
, segment_info
[i
].name
, size
);
2952 #endif /* COFF_LONG_SECTION_NAMES */
2954 for (symbolP
= symbol_rootP
;
2956 symbolP
= symbol_next (symbolP
))
2960 if (SF_GET_STRING (symbolP
))
2962 size
= strlen (S_GET_NAME (symbolP
)) + 1;
2963 memcpy (where
, S_GET_NAME (symbolP
), size
);
2966 if (S_GET_STORAGE_CLASS (symbolP
) == C_FILE
2967 && SA_GET_FILE_FNAME_ZEROS (symbolP
) == 0
2968 && SA_GET_FILE_FNAME_OFFSET (symbolP
) != 0)
2970 size
= strlen (filename_list_scan
->filename
) + 1;
2971 memcpy (where
, filename_list_scan
->filename
, size
);
2972 filename_list_scan
= filename_list_scan
->next
;
2979 do_linenos_for (abfd
, h
, file_cursor
)
2982 unsigned long *file_cursor
;
2985 unsigned long start
= *file_cursor
;
2987 for (idx
= SEG_E0
; idx
< SEG_LAST
; idx
++)
2989 segment_info_type
*s
= segment_info
+ idx
;
2992 if (s
->scnhdr
.s_nlnno
!= 0)
2994 struct lineno_list
*line_ptr
;
2996 struct external_lineno
*buffer
=
2997 (struct external_lineno
*) xmalloc (s
->scnhdr
.s_nlnno
* LINESZ
);
2999 struct external_lineno
*dst
= buffer
;
3001 /* Run through the table we've built and turn it into its external
3002 form, take this chance to remove duplicates */
3004 for (line_ptr
= s
->lineno_list_head
;
3005 line_ptr
!= (struct lineno_list
*) NULL
;
3006 line_ptr
= line_ptr
->next
)
3009 if (line_ptr
->line
.l_lnno
== 0)
3011 /* Turn a pointer to a symbol into the symbols' index */
3012 line_ptr
->line
.l_addr
.l_symndx
=
3013 ((symbolS
*) line_ptr
->line
.l_addr
.l_symndx
)->sy_number
;
3017 line_ptr
->line
.l_addr
.l_paddr
+= ((struct frag
*) (line_ptr
->frag
))->fr_address
;
3021 (void) bfd_coff_swap_lineno_out (abfd
, &(line_ptr
->line
), dst
);
3026 s
->scnhdr
.s_lnnoptr
= *file_cursor
;
3028 bfd_write (buffer
, 1, s
->scnhdr
.s_nlnno
* LINESZ
, abfd
);
3031 *file_cursor
+= s
->scnhdr
.s_nlnno
* LINESZ
;
3034 H_SET_LINENO_SIZE (h
, *file_cursor
- start
);
3038 /* Now we run through the list of frag chains in a segment and
3039 make all the subsegment frags appear at the end of the
3040 list, as if the seg 0 was extra long */
3047 for (i
= SEG_E0
; i
< SEG_UNKNOWN
; i
++)
3049 frchainS
*head
= segment_info
[i
].frchainP
;
3051 fragS
*prev_frag
= &dummy
;
3053 while (head
&& head
->frch_seg
== i
)
3055 prev_frag
->fr_next
= head
->frch_root
;
3056 prev_frag
= head
->frch_last
;
3057 head
= head
->frch_next
;
3059 prev_frag
->fr_next
= 0;
3063 unsigned long machine
;
3066 write_object_file ()
3070 struct frchain
*frchain_ptr
;
3072 object_headers headers
;
3073 unsigned long file_cursor
;
3076 abfd
= bfd_openw (out_file_name
, TARGET_FORMAT
);
3081 as_perror ("FATAL: Can't create %s", out_file_name
);
3082 exit (EXIT_FAILURE
);
3084 bfd_set_format (abfd
, bfd_object
);
3085 bfd_set_arch_mach (abfd
, BFD_ARCH
, machine
);
3087 string_byte_count
= 4;
3089 for (frchain_ptr
= frchain_root
;
3090 frchain_ptr
!= (struct frchain
*) NULL
;
3091 frchain_ptr
= frchain_ptr
->frch_next
)
3093 /* Run through all the sub-segments and align them up. Also
3094 close any open frags. We tack a .fill onto the end of the
3095 frag chain so that any .align's size can be worked by looking
3096 at the next frag. */
3098 subseg_set (frchain_ptr
->frch_seg
, frchain_ptr
->frch_subseg
);
3099 #ifndef SUB_SEGMENT_ALIGN
3100 #define SUB_SEGMENT_ALIGN(SEG) 1
3104 static char nop
= NOP_OPCODE
;
3105 md_do_align (SUB_SEGMENT_ALIGN (now_seg
), &nop
, 1, alignment_done
);
3108 frag_align (SUB_SEGMENT_ALIGN (now_seg
), NOP_OPCODE
);
3112 frag_wane (frag_now
);
3113 frag_now
->fr_fix
= 0;
3114 know (frag_now
->fr_next
== NULL
);
3121 for (i
= SEG_E0
; i
< SEG_UNKNOWN
; i
++)
3123 relax_segment (segment_info
[i
].frchainP
->frch_root
, i
);
3126 H_SET_NUMBER_OF_SECTIONS (&headers
, 0);
3128 /* Find out how big the sections are, and set the addresses. */
3130 for (i
= SEG_E0
; i
< SEG_UNKNOWN
; i
++)
3134 segment_info
[i
].scnhdr
.s_paddr
= addr
;
3135 segment_info
[i
].scnhdr
.s_vaddr
= addr
;
3137 if (segment_info
[i
].scnhdr
.s_name
[0])
3139 H_SET_NUMBER_OF_SECTIONS (&headers
,
3140 H_GET_NUMBER_OF_SECTIONS (&headers
) + 1);
3142 #ifdef COFF_LONG_SECTION_NAMES
3143 /* Support long section names as found in PE. This code
3144 must coordinate with that in coff_header_append and
3149 len
= strlen (segment_info
[i
].name
);
3151 string_byte_count
+= len
+ 1;
3153 #endif /* COFF_LONG_SECTION_NAMES */
3156 size
= size_section (abfd
, (unsigned int) i
);
3159 /* I think the section alignment is only used on the i960; the
3160 i960 needs it, and it should do no harm on other targets. */
3161 segment_info
[i
].scnhdr
.s_align
= 1 << section_alignment
[i
];
3164 H_SET_TEXT_SIZE (&headers
, size
);
3165 else if (i
== SEG_E1
)
3166 H_SET_DATA_SIZE (&headers
, size
);
3167 else if (i
== SEG_E2
)
3168 H_SET_BSS_SIZE (&headers
, size
);
3171 /* Turn the gas native symbol table shape into a coff symbol table */
3172 crawl_symbols (&headers
, abfd
);
3174 if (string_byte_count
== 4)
3175 string_byte_count
= 0;
3177 H_SET_STRING_SIZE (&headers
, string_byte_count
);
3183 for (i
= SEG_E0
; i
< SEG_UNKNOWN
; i
++)
3185 fixup_mdeps (segment_info
[i
].frchainP
->frch_root
, &headers
, i
);
3186 fixup_segment (&segment_info
[i
], i
);
3189 /* Look for ".stab" segments and fill in their initial symbols
3191 for (i
= SEG_E0
; i
< SEG_UNKNOWN
; i
++)
3193 name
= segment_info
[i
].name
;
3196 && strncmp (".stab", name
, 5) == 0
3197 && strncmp (".stabstr", name
, 8) != 0)
3198 adjust_stab_section (abfd
, i
);
3201 file_cursor
= H_GET_TEXT_FILE_OFFSET (&headers
);
3203 bfd_seek (abfd
, (file_ptr
) file_cursor
, 0);
3205 /* Plant the data */
3207 fill_section (abfd
, &headers
, &file_cursor
);
3209 do_relocs_for (abfd
, &headers
, &file_cursor
);
3211 do_linenos_for (abfd
, &headers
, &file_cursor
);
3213 H_SET_FILE_MAGIC_NUMBER (&headers
, COFF_MAGIC
);
3214 #ifndef OBJ_COFF_OMIT_TIMESTAMP
3215 H_SET_TIME_STAMP (&headers
, (long)time((time_t *)0));
3217 H_SET_TIME_STAMP (&headers
, 0);
3219 #ifdef TC_COFF_SET_MACHINE
3220 TC_COFF_SET_MACHINE (&headers
);
3224 #define COFF_FLAGS 0
3227 #ifdef KEEP_RELOC_INFO
3228 H_SET_FLAGS (&headers
, ((H_GET_LINENO_SIZE(&headers
) ? 0 : F_LNNO
) |
3229 COFF_FLAGS
| coff_flags
));
3231 H_SET_FLAGS (&headers
, ((H_GET_LINENO_SIZE(&headers
) ? 0 : F_LNNO
) |
3232 (H_GET_RELOCATION_SIZE(&headers
) ? 0 : F_RELFLG
) |
3233 COFF_FLAGS
| coff_flags
));
3237 unsigned int symtable_size
= H_GET_SYMBOL_TABLE_SIZE (&headers
);
3238 char *buffer1
= xmalloc (symtable_size
+ string_byte_count
+ 1);
3240 H_SET_SYMBOL_TABLE_POINTER (&headers
, bfd_tell (abfd
));
3241 w_symbols (abfd
, buffer1
, symbol_rootP
);
3242 if (string_byte_count
> 0)
3243 w_strings (buffer1
+ symtable_size
);
3244 bfd_write (buffer1
, 1, symtable_size
+ string_byte_count
, abfd
);
3248 coff_header_append (abfd
, &headers
);
3250 /* Recent changes to write need this, but where it should
3251 go is up to Ken.. */
3252 if (bfd_close_all_done (abfd
) == false)
3253 as_fatal ("Can't close %s: %s", out_file_name
,
3254 bfd_errmsg (bfd_get_error ()));
3257 extern bfd
*stdoutput
;
3264 /* Add a new segment. This is called from subseg_new via the
3265 obj_new_segment macro. */
3268 obj_coff_add_segment (name
)
3273 #ifndef COFF_LONG_SECTION_NAMES
3274 char buf
[SCNNMLEN
+ 1];
3276 strncpy (buf
, name
, SCNNMLEN
);
3277 buf
[SCNNMLEN
] = '\0';
3281 for (i
= SEG_E0
; i
< SEG_LAST
&& segment_info
[i
].scnhdr
.s_name
[0]; i
++)
3282 if (strcmp (name
, segment_info
[i
].name
) == 0)
3287 as_bad ("Too many new sections; can't add \"%s\"", name
);
3291 /* Add a new section. */
3292 strncpy (segment_info
[i
].scnhdr
.s_name
, name
,
3293 sizeof (segment_info
[i
].scnhdr
.s_name
));
3294 segment_info
[i
].scnhdr
.s_flags
= STYP_REG
;
3295 segment_info
[i
].name
= xstrdup (name
);
3301 * implement the .section pseudo op:
3302 * .section name {, "flags"}
3304 * | +--- optional flags: 'b' for bss
3306 * +-- section name 'l' for lib
3310 * 'd' (apparently m88k for data)
3312 * But if the argument is not a quoted string, treat it as a
3313 * subsegment number.
3317 obj_coff_section (ignore
)
3320 /* Strip out the section name */
3321 char *section_name
, *name
;
3334 else if (type
== 'D')
3336 segment_info
[now_seg
].scnhdr
.s_flags
|= flags
;
3341 section_name
= input_line_pointer
;
3342 c
= get_symbol_end ();
3344 name
= xmalloc (input_line_pointer
- section_name
+ 1);
3345 strcpy (name
, section_name
);
3347 *input_line_pointer
= c
;
3353 if (*input_line_pointer
== ',')
3355 ++input_line_pointer
;
3358 if (*input_line_pointer
!= '"')
3359 exp
= get_absolute_expression ();
3362 ++input_line_pointer
;
3363 while (*input_line_pointer
!= '"'
3364 && ! is_end_of_line
[(unsigned char) *input_line_pointer
])
3366 switch (*input_line_pointer
)
3368 case 'b': flags
|= STYP_BSS
; break;
3369 case 'i': flags
|= STYP_INFO
; break;
3370 case 'l': flags
|= STYP_LIB
; break;
3371 case 'n': flags
|= STYP_NOLOAD
; break;
3372 case 'o': flags
|= STYP_OVER
; break;
3374 case 'w': flags
|= STYP_DATA
; break;
3375 case 'x': flags
|= STYP_TEXT
; break;
3377 as_warn("unknown section attribute '%c'",
3378 *input_line_pointer
);
3381 ++input_line_pointer
;
3383 if (*input_line_pointer
== '"')
3384 ++input_line_pointer
;
3388 subseg_new (name
, (subsegT
) exp
);
3390 segment_info
[now_seg
].scnhdr
.s_flags
|= flags
;
3392 demand_empty_rest_of_line ();
3397 obj_coff_text (ignore
)
3400 subseg_new (".text", get_absolute_expression ());
3405 obj_coff_data (ignore
)
3408 if (flag_readonly_data_in_text
)
3409 subseg_new (".text", get_absolute_expression () + 1000);
3411 subseg_new (".data", get_absolute_expression ());
3415 obj_coff_bss (ignore
)
3418 if (*input_line_pointer
== '\n') /* .bss */
3419 subseg_new(".bss", get_absolute_expression());
3420 else /* .bss id,expr */
3425 obj_coff_ident (ignore
)
3428 segT current_seg
= now_seg
; /* save current seg */
3429 subsegT current_subseg
= now_subseg
;
3430 subseg_new (".comment", 0); /* .comment seg */
3431 stringer (1); /* read string */
3432 subseg_set (current_seg
, current_subseg
); /* restore current seg */
3436 c_symbol_merge (debug
, normal
)
3440 S_SET_DATA_TYPE (normal
, S_GET_DATA_TYPE (debug
));
3441 S_SET_STORAGE_CLASS (normal
, S_GET_STORAGE_CLASS (debug
));
3443 if (S_GET_NUMBER_AUXILIARY (debug
) > S_GET_NUMBER_AUXILIARY (normal
))
3445 S_SET_NUMBER_AUXILIARY (normal
, S_GET_NUMBER_AUXILIARY (debug
));
3446 } /* take the most we have */
3448 if (S_GET_NUMBER_AUXILIARY (debug
) > 0)
3450 memcpy ((char *) &normal
->sy_symbol
.ost_auxent
[0],
3451 (char *) &debug
->sy_symbol
.ost_auxent
[0],
3452 (unsigned int) (S_GET_NUMBER_AUXILIARY (debug
) * AUXESZ
));
3453 } /* Move all the auxiliary information */
3455 /* Move the debug flags. */
3456 SF_SET_DEBUG_FIELD (normal
, SF_GET_DEBUG_FIELD (debug
));
3457 } /* c_symbol_merge() */
3460 c_line_new (symbol
, paddr
, line_number
, frag
)
3466 struct lineno_list
*new_line
=
3467 (struct lineno_list
*) xmalloc (sizeof (struct lineno_list
));
3469 segment_info_type
*s
= segment_info
+ now_seg
;
3470 new_line
->line
.l_lnno
= line_number
;
3472 if (line_number
== 0)
3474 last_line_symbol
= symbol
;
3475 new_line
->line
.l_addr
.l_symndx
= (long) symbol
;
3479 new_line
->line
.l_addr
.l_paddr
= paddr
;
3482 new_line
->frag
= (char *) frag
;
3483 new_line
->next
= (struct lineno_list
*) NULL
;
3486 if (s
->lineno_list_head
== (struct lineno_list
*) NULL
)
3488 s
->lineno_list_head
= new_line
;
3492 s
->lineno_list_tail
->next
= new_line
;
3494 s
->lineno_list_tail
= new_line
;
3495 return LINESZ
* s
->scnhdr
.s_nlnno
++;
3499 c_dot_file_symbol (filename
)
3504 symbolP
= symbol_new (".file",
3507 &zero_address_frag
);
3509 S_SET_STORAGE_CLASS (symbolP
, C_FILE
);
3510 S_SET_NUMBER_AUXILIARY (symbolP
, 1);
3512 if (strlen (filename
) > FILNMLEN
)
3514 /* Filename is too long to fit into an auxent,
3515 we stick it into the string table instead. We keep
3516 a linked list of the filenames we find so we can emit
3518 struct filename_list
*f
= ((struct filename_list
*)
3519 xmalloc (sizeof (struct filename_list
)));
3521 f
->filename
= filename
;
3524 SA_SET_FILE_FNAME_ZEROS (symbolP
, 0);
3525 SA_SET_FILE_FNAME_OFFSET (symbolP
, 1);
3527 if (filename_list_tail
)
3528 filename_list_tail
->next
= f
;
3530 filename_list_head
= f
;
3531 filename_list_tail
= f
;
3535 SA_SET_FILE_FNAME (symbolP
, filename
);
3542 listing_source_file (filename
);
3548 SF_SET_DEBUG (symbolP
);
3549 S_SET_VALUE (symbolP
, (valueT
) previous_file_symbol
);
3551 previous_file_symbol
= symbolP
;
3553 /* Make sure that the symbol is first on the symbol chain */
3554 if (symbol_rootP
!= symbolP
)
3556 if (symbolP
== symbol_lastP
)
3558 symbol_lastP
= symbol_lastP
->sy_previous
;
3559 } /* if it was the last thing on the list */
3561 symbol_remove (symbolP
, &symbol_rootP
, &symbol_lastP
);
3562 symbol_insert (symbolP
, symbol_rootP
, &symbol_rootP
, &symbol_lastP
);
3563 symbol_rootP
= symbolP
;
3564 } /* if not first on the list */
3566 } /* c_dot_file_symbol() */
3569 * Build a 'section static' symbol.
3573 c_section_symbol (name
, idx
)
3579 symbolP
= symbol_new (name
, idx
,
3581 &zero_address_frag
);
3583 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
3584 S_SET_NUMBER_AUXILIARY (symbolP
, 1);
3586 SF_SET_STATICS (symbolP
);
3589 /* If the .linkonce pseudo-op was used for this section, we must
3590 store the information in the auxiliary entry for the section
3592 if (segment_info
[idx
].linkonce
!= LINKONCE_UNSET
)
3596 switch (segment_info
[idx
].linkonce
)
3600 case LINKONCE_DISCARD
:
3601 type
= IMAGE_COMDAT_SELECT_ANY
;
3603 case LINKONCE_ONE_ONLY
:
3604 type
= IMAGE_COMDAT_SELECT_NODUPLICATES
;
3606 case LINKONCE_SAME_SIZE
:
3607 type
= IMAGE_COMDAT_SELECT_SAME_SIZE
;
3609 case LINKONCE_SAME_CONTENTS
:
3610 type
= IMAGE_COMDAT_SELECT_EXACT_MATCH
;
3614 SYM_AUXENT (symbolP
)->x_scn
.x_comdat
= type
;
3619 } /* c_section_symbol() */
3622 w_symbols (abfd
, where
, symbol_rootP
)
3625 symbolS
* symbol_rootP
;
3630 /* First fill in those values we have only just worked out */
3631 for (i
= SEG_E0
; i
< SEG_LAST
; i
++)
3633 symbolP
= segment_info
[i
].dot
;
3636 SA_SET_SCN_SCNLEN (symbolP
, segment_info
[i
].scnhdr
.s_size
);
3637 SA_SET_SCN_NRELOC (symbolP
, segment_info
[i
].scnhdr
.s_nreloc
);
3638 SA_SET_SCN_NLINNO (symbolP
, segment_info
[i
].scnhdr
.s_nlnno
);
3643 * Emit all symbols left in the symbol chain.
3645 for (symbolP
= symbol_rootP
; symbolP
; symbolP
= symbol_next (symbolP
))
3647 /* Used to save the offset of the name. It is used to point
3648 to the string in memory but must be a file offset. */
3649 register char *temp
;
3651 /* We can't fix the lnnoptr field in yank_symbols with the other
3652 adjustments, because we have to wait until we know where they
3654 if (SF_GET_ADJ_LNNOPTR (symbolP
))
3656 SA_GET_SYM_LNNOPTR (symbolP
) +=
3657 segment_info
[S_GET_SEGMENT (symbolP
)].scnhdr
.s_lnnoptr
;
3660 tc_coff_symbol_emit_hook (symbolP
);
3662 temp
= S_GET_NAME (symbolP
);
3663 if (SF_GET_STRING (symbolP
))
3665 S_SET_OFFSET (symbolP
, symbolP
->sy_name_offset
);
3666 S_SET_ZEROES (symbolP
, 0);
3670 memset (symbolP
->sy_symbol
.ost_entry
.n_name
, 0, SYMNMLEN
);
3671 strncpy (symbolP
->sy_symbol
.ost_entry
.n_name
, temp
, SYMNMLEN
);
3673 where
= symbol_to_chars (abfd
, where
, symbolP
);
3674 S_SET_NAME (symbolP
, temp
);
3680 obj_coff_lcomm (ignore
)
3693 name
= input_line_pointer
;
3695 c
= get_symbol_end ();
3696 p
= input_line_pointer
;
3699 if (*input_line_pointer
!= ',')
3701 as_bad ("Expected comma after name");
3702 ignore_rest_of_line ();
3705 if (*input_line_pointer
== '\n')
3707 as_bad ("Missing size expression");
3710 input_line_pointer
++;
3711 if ((temp
= get_absolute_expression ()) < 0)
3713 as_warn ("lcomm length (%d.) <0! Ignored.", temp
);
3714 ignore_rest_of_line ();
3719 symbolP
= symbol_find_or_make(name
);
3721 if (S_GET_SEGMENT(symbolP
) == SEG_UNKNOWN
&&
3722 S_GET_VALUE(symbolP
) == 0)
3727 segT current_seg
= now_seg
; /* save current seg */
3728 subsegT current_subseg
= now_subseg
;
3730 subseg_set (SEG_E2
, 1);
3731 symbolP
->sy_frag
= frag_now
;
3732 p
= frag_var(rs_org
, 1, 1, (relax_substateT
)0, symbolP
,
3735 subseg_set (current_seg
, current_subseg
); /* restore current seg */
3736 S_SET_SEGMENT(symbolP
, SEG_E2
);
3737 S_SET_STORAGE_CLASS(symbolP
, C_STAT
);
3741 as_bad("Symbol %s already defined", name
);
3743 demand_empty_rest_of_line();
3748 fixup_mdeps (frags
, h
, this_segment
)
3753 subseg_change (this_segment
, 0);
3756 switch (frags
->fr_type
)
3762 HANDLE_ALIGN (frags
);
3764 frags
->fr_type
= rs_fill
;
3766 ((frags
->fr_next
->fr_address
- frags
->fr_address
- frags
->fr_fix
)
3769 case rs_machine_dependent
:
3770 md_convert_frag (h
, this_segment
, frags
);
3776 frags
= frags
->fr_next
;
3782 #ifndef TC_FORCE_RELOCATION
3783 #define TC_FORCE_RELOCATION(fix) 0
3787 fixup_segment (segP
, this_segment_type
)
3788 segment_info_type
* segP
;
3789 segT this_segment_type
;
3791 register fixS
* fixP
;
3792 register symbolS
*add_symbolP
;
3793 register symbolS
*sub_symbolP
;
3796 register char *place
;
3797 register long where
;
3798 register char pcrel
;
3799 register fragS
*fragP
;
3800 register segT add_symbol_segment
= absolute_section
;
3802 for (fixP
= segP
->fix_root
; fixP
; fixP
= fixP
->fx_next
)
3804 fragP
= fixP
->fx_frag
;
3806 where
= fixP
->fx_where
;
3807 place
= fragP
->fr_literal
+ where
;
3808 size
= fixP
->fx_size
;
3809 add_symbolP
= fixP
->fx_addsy
;
3810 sub_symbolP
= fixP
->fx_subsy
;
3811 add_number
= fixP
->fx_offset
;
3812 pcrel
= fixP
->fx_pcrel
;
3814 /* We want function-relative stabs to work on systems which
3815 may use a relaxing linker; thus we must handle the sym1-sym2
3816 fixups function-relative stabs generates.
3818 Of course, if you actually enable relaxing in the linker, the
3819 line and block scoping information is going to be incorrect
3820 in some cases. The only way to really fix this is to support
3821 a reloc involving the difference of two symbols. */
3823 && (!sub_symbolP
|| pcrel
))
3827 if (fixP
->fx_tcbit
&& SF_GET_CALLNAME (add_symbolP
))
3829 /* Relocation should be done via the associated 'bal' entry
3832 if (!SF_GET_BALNAME (tc_get_bal_of_call (add_symbolP
)))
3834 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
3835 "No 'bal' entry point for leafproc %s",
3836 S_GET_NAME (add_symbolP
));
3839 fixP
->fx_addsy
= add_symbolP
= tc_get_bal_of_call (add_symbolP
);
3843 if (add_symbolP
!= NULL
3844 && add_symbolP
->sy_mri_common
)
3846 know (add_symbolP
->sy_value
.X_op
== O_symbol
);
3847 add_number
+= S_GET_VALUE (add_symbolP
);
3848 fixP
->fx_offset
= add_number
;
3849 add_symbolP
= fixP
->fx_addsy
= add_symbolP
->sy_value
.X_add_symbol
;
3854 add_symbol_segment
= S_GET_SEGMENT (add_symbolP
);
3855 } /* if there is an addend */
3859 if (add_symbolP
== NULL
|| add_symbol_segment
== absolute_section
)
3861 if (add_symbolP
!= NULL
)
3863 add_number
+= S_GET_VALUE (add_symbolP
);
3865 fixP
->fx_addsy
= NULL
;
3868 /* It's just -sym. */
3869 if (S_GET_SEGMENT (sub_symbolP
) == absolute_section
)
3871 add_number
-= S_GET_VALUE (sub_symbolP
);
3878 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
3879 "Negative of non-absolute symbol %s",
3880 S_GET_NAME (sub_symbolP
));
3882 add_number
-= S_GET_VALUE (sub_symbolP
);
3883 } /* not absolute */
3885 /* if sub_symbol is in the same segment that add_symbol
3886 and add_symbol is either in DATA, TEXT, BSS or ABSOLUTE */
3888 else if (S_GET_SEGMENT (sub_symbolP
) == add_symbol_segment
3889 && SEG_NORMAL (add_symbol_segment
))
3891 /* Difference of 2 symbols from same segment. Can't
3892 make difference of 2 undefineds: 'value' means
3893 something different for N_UNDF. */
3895 /* Makes no sense to use the difference of 2 arbitrary symbols
3896 as the target of a call instruction. */
3899 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
3900 "callj to difference of 2 symbols");
3902 #endif /* TC_I960 */
3903 add_number
+= S_GET_VALUE (add_symbolP
) -
3904 S_GET_VALUE (sub_symbolP
);
3907 if (!TC_FORCE_RELOCATION (fixP
))
3909 fixP
->fx_addsy
= NULL
;
3910 fixP
->fx_subsy
= NULL
;
3912 #ifdef TC_M68K /* is this right? */
3920 /* Different segments in subtraction. */
3921 know (!(S_IS_EXTERNAL (sub_symbolP
) && (S_GET_SEGMENT (sub_symbolP
) == absolute_section
)));
3923 if ((S_GET_SEGMENT (sub_symbolP
) == absolute_section
))
3925 add_number
-= S_GET_VALUE (sub_symbolP
);
3928 else if (S_GET_SEGMENT (sub_symbolP
) == this_segment_type
3929 #if 0 /* Okay for 68k, at least... */
3934 /* Make it pc-relative. */
3935 add_number
+= (md_pcrel_from (fixP
)
3936 - S_GET_VALUE (sub_symbolP
));
3945 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
3946 "Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %ld.",
3947 segment_name (S_GET_SEGMENT (sub_symbolP
)),
3948 S_GET_NAME (sub_symbolP
),
3949 (long) (fragP
->fr_address
+ where
));
3952 } /* if sub_symbolP */
3956 if (add_symbol_segment
== this_segment_type
&& pcrel
)
3959 * This fixup was made when the symbol's segment was
3960 * SEG_UNKNOWN, but it is now in the local segment.
3961 * So we know how to do the address without relocation.
3964 /* reloc_callj() may replace a 'call' with a 'calls' or a 'bal',
3965 * in which cases it modifies *fixP as appropriate. In the case
3966 * of a 'calls', no further work is required, and *fixP has been
3967 * set up to make the rest of the code below a no-op.
3970 #endif /* TC_I960 */
3972 add_number
+= S_GET_VALUE (add_symbolP
);
3973 add_number
-= md_pcrel_from (fixP
);
3974 #if defined (TC_I386) || defined (TE_LYNX)
3975 /* On the 386 we must adjust by the segment vaddr as
3976 well. Ian Taylor. */
3977 add_number
-= segP
->scnhdr
.s_vaddr
;
3979 pcrel
= 0; /* Lie. Don't want further pcrel processing. */
3980 if (!TC_FORCE_RELOCATION (fixP
))
3982 fixP
->fx_addsy
= NULL
;
3988 switch (add_symbol_segment
)
3990 case absolute_section
:
3992 reloc_callj (fixP
); /* See comment about reloc_callj() above*/
3993 #endif /* TC_I960 */
3994 add_number
+= S_GET_VALUE (add_symbolP
);
3997 if (!TC_FORCE_RELOCATION (fixP
))
3999 fixP
->fx_addsy
= NULL
;
4006 #if defined(TC_A29K) || (defined(TE_PE) && defined(TC_I386)) || defined(TC_M88K)
4007 /* This really should be handled in the linker, but
4008 backward compatibility forbids. */
4009 add_number
+= S_GET_VALUE (add_symbolP
);
4011 add_number
+= S_GET_VALUE (add_symbolP
) +
4012 segment_info
[S_GET_SEGMENT (add_symbolP
)].scnhdr
.s_paddr
;
4018 if ((int) fixP
->fx_bit_fixP
== 13)
4020 /* This is a COBR instruction. They have only a
4021 * 13-bit displacement and are only to be used
4022 * for local branches: flag as error, don't generate
4025 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
4026 "can't use COBR format with external label");
4027 fixP
->fx_addsy
= NULL
;
4031 #endif /* TC_I960 */
4032 #if (defined (TC_I386) || defined (TE_LYNX) || defined (TE_AUX)) && !defined(TE_PE)
4033 /* 386 COFF uses a peculiar format in which the
4034 value of a common symbol is stored in the .text
4035 segment (I've checked this on SVR3.2 and SCO
4036 3.2.2) Ian Taylor <ian@cygnus.com>. */
4037 if (S_IS_COMMON (add_symbolP
))
4038 add_number
+= S_GET_VALUE (add_symbolP
);
4043 } /* switch on symbol seg */
4044 } /* if not in local seg */
4045 } /* if there was a + symbol */
4049 #if !defined(TC_M88K) && !(defined(TE_PE) && defined(TC_I386)) && !defined(TC_A29K)
4050 /* This adjustment is not correct on the m88k, for which the
4051 linker does all the computation. */
4052 add_number
-= md_pcrel_from (fixP
);
4054 if (add_symbolP
== 0)
4056 fixP
->fx_addsy
= &abs_symbol
;
4057 } /* if there's an add_symbol */
4058 #if defined (TC_I386) || defined (TE_LYNX) || defined (TC_I960) || defined (TC_M68K)
4059 /* On the 386 we must adjust by the segment vaddr as well.
4062 I changed the i960 to work this way as well. This is
4063 compatible with the current GNU linker behaviour. I do
4064 not know what other i960 COFF assemblers do. This is not
4065 a common case: normally, only assembler code will contain
4066 a PC relative reloc, and only branches which do not
4067 originate in the .text section will have a non-zero
4070 I changed the m68k to work this way as well. This will
4071 break existing PC relative relocs from sections which do
4072 not start at address 0, but it will make ld -r work.
4073 Ian Taylor, 4 Oct 96. */
4075 add_number
-= segP
->scnhdr
.s_vaddr
;
4079 if (!fixP
->fx_bit_fixP
)
4082 /* The m88k uses the offset field of the reloc to get around
4085 && (add_number
& ~0xFF)
4086 && ((add_number
& ~0xFF) != (-1 & ~0xFF)))
4088 && (add_number
& ~0xFFFF)
4089 && ((add_number
& ~0xFFFF) != (-1 & ~0xFFFF))))
4091 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
4092 "Value of %ld too large for field of %d bytes at 0x%lx",
4093 (long) add_number
, size
,
4094 (unsigned long) (fragP
->fr_address
+ where
));
4097 #ifdef WARN_SIGNED_OVERFLOW_WORD
4098 /* Warn if a .word value is too large when treated as a
4099 signed number. We already know it is not too negative.
4100 This is to catch over-large switches generated by gcc on
4102 if (!flag_signed_overflow_ok
4104 && add_number
> 0x7fff)
4105 as_bad_where (fixP
->fx_file
, fixP
->fx_line
,
4106 "Signed .word overflow; switch may be too large; %ld at 0x%lx",
4108 (unsigned long) (fragP
->fr_address
+ where
));
4110 } /* not a bit fix */
4111 /* Once this fix has been applied, we don't have to output
4112 anything nothing more need be done. */
4113 #ifdef MD_APPLY_FIX3
4114 md_apply_fix3 (fixP
, &add_number
, this_segment_type
);
4116 md_apply_fix (fixP
, add_number
);
4118 } /* For each fixS in this segment. */
4119 } /* fixup_segment() */
4123 /* The first entry in a .stab section is special. */
4126 obj_coff_init_stab_section (seg
)
4132 unsigned int stroff
;
4134 /* Make space for this first symbol. */
4138 as_where (&file
, (unsigned int *) NULL
);
4139 stabstr_name
= (char *) alloca (strlen (segment_info
[seg
].name
) + 4);
4140 strcpy (stabstr_name
, segment_info
[seg
].name
);
4141 strcat (stabstr_name
, "str");
4142 stroff
= get_stab_string_offset (file
, stabstr_name
);
4144 md_number_to_chars (p
, stroff
, 4);
4147 /* Fill in the counts in the first entry in a .stab section. */
4150 adjust_stab_section(abfd
, seg
)
4154 segT stabstrseg
= SEG_UNKNOWN
;
4155 const char *secname
, *name2
;
4158 int i
, strsz
= 0, nsyms
;
4159 fragS
*frag
= segment_info
[seg
].frchainP
->frch_root
;
4161 /* Look for the associated string table section. */
4163 secname
= segment_info
[seg
].name
;
4164 name
= (char *) alloca (strlen (secname
) + 4);
4165 strcpy (name
, secname
);
4166 strcat (name
, "str");
4168 for (i
= SEG_E0
; i
< SEG_UNKNOWN
; i
++)
4170 name2
= segment_info
[i
].name
;
4171 if (name2
!= NULL
&& strncmp(name2
, name
, 8) == 0)
4178 /* If we found the section, get its size. */
4179 if (stabstrseg
!= SEG_UNKNOWN
)
4180 strsz
= size_section (abfd
, stabstrseg
);
4182 nsyms
= size_section (abfd
, seg
) / 12 - 1;
4184 /* Look for the first frag of sufficient size for the initial stab
4185 symbol, and collect a pointer to it. */
4186 while (frag
&& frag
->fr_fix
< 12)
4187 frag
= frag
->fr_next
;
4189 p
= frag
->fr_literal
;
4192 /* Write in the number of stab symbols and the size of the string
4194 bfd_h_put_16 (abfd
, (bfd_vma
) nsyms
, (bfd_byte
*) p
+ 6);
4195 bfd_h_put_32 (abfd
, (bfd_vma
) strsz
, (bfd_byte
*) p
+ 8);
4198 #endif /* not BFD_ASSEMBLER */
4200 const pseudo_typeS obj_pseudo_table
[] =
4202 {"def", obj_coff_def
, 0},
4203 {"dim", obj_coff_dim
, 0},
4204 {"endef", obj_coff_endef
, 0},
4205 {"line", obj_coff_line
, 0},
4206 {"ln", obj_coff_ln
, 0},
4207 {"appline", obj_coff_ln
, 1},
4208 {"scl", obj_coff_scl
, 0},
4209 {"size", obj_coff_size
, 0},
4210 {"tag", obj_coff_tag
, 0},
4211 {"type", obj_coff_type
, 0},
4212 {"val", obj_coff_val
, 0},
4213 {"section", obj_coff_section
, 0},
4214 {"sect", obj_coff_section
, 0},
4215 /* FIXME: We ignore the MRI short attribute. */
4216 {"section.s", obj_coff_section
, 0},
4217 {"sect.s", obj_coff_section
, 0},
4218 #ifndef BFD_ASSEMBLER
4219 {"use", obj_coff_section
, 0},
4220 {"text", obj_coff_text
, 0},
4221 {"data", obj_coff_data
, 0},
4222 {"bss", obj_coff_bss
, 0},
4223 {"lcomm", obj_coff_lcomm
, 0},
4224 {"ident", obj_coff_ident
, 0},
4226 {"optim", s_ignore
, 0}, /* For sun386i cc (?) */
4227 {"ident", s_ignore
, 0}, /* we don't yet handle this. */
4229 {"ABORT", s_abort
, 0},
4231 /* The m88k uses sdef instead of def. */
4232 {"sdef", obj_coff_def
, 0},
4234 {NULL
} /* end sentinel */
4235 }; /* obj_pseudo_table */