1 /* coff object file format with bfd
2 Copyright (C) 1989, 1990, 1991 Free Software Foundation, Inc.
4 This file is part of GAS.
6 GAS is free software; you can redistribute it and/or modify
7 it under the terms of the GNU General Public License as published by
8 the Free Software Foundation; either version 2, or (at your option)
11 GAS is distributed in the hope that it will be useful,
12 but WITHOUT ANY WARRANTY; without even the implied warranty of
13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
14 GNU General Public License for more details.
16 You should have received a copy of the GNU General Public License
17 along with GAS; see the file COPYING. If not, write to
18 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
22 How does this releate to the rest of GAS ?
24 Well, all the other files in gas are more or less a black box. It
25 takes care of opening files, parsing command lines, stripping blanks
26 etc etc. This module gets a chance to register what it wants to do by
27 saying that it is interested in various pseduo ops. The other big
28 change is write_object_file. This runs through all the data
29 structures that gas builds, and outputs the file in the format of our
32 Hacked for BFDness by steve chamberlain
34 This object module now supports the Hitachi H8/{3|5}00 and the AMD 29k
43 #include "../bfd/libbfd.h"
44 #include "../bfd/libcoff.h"
46 /* The NOP_OPCODE is for the alignment fill value. Fill with nop so
47 that we can stick sections together without causing trouble. */
49 #define NOP_OPCODE 0x00
52 #define MIN(a,b) ((a) < (b)? (a) : (b))
53 /* This vector is used to turn an internal segment into a section #
54 suitable for insertion into a coff symbol table
57 const short seg_N_TYPE
[] =
58 { /* in: segT out: N_TYPE bits */
70 C_UNDEF_SECTION
, /* SEG_UNKNOWN */
71 C_UNDEF_SECTION
, /* SEG_ABSENT */
72 C_UNDEF_SECTION
, /* SEG_PASS1 */
73 C_UNDEF_SECTION
, /* SEG_GOOF */
74 C_UNDEF_SECTION
, /* SEG_BIG */
75 C_UNDEF_SECTION
, /* SEG_DIFFERENCE */
76 C_DEBUG_SECTION
, /* SEG_DEBUG */
77 C_NTV_SECTION
, /* SEG_NTV */
78 C_PTV_SECTION
, /* SEG_PTV */
79 C_REGISTER_SECTION
, /* SEG_REGISTER */
83 int function_lineoff
= -1; /* Offset in line#s where the last function
84 started (the odd entry for line #0) */
87 static symbolS
*last_line_symbol
;
89 /* Add 4 to the real value to get the index and compensate the
90 negatives. This vector is used by S_GET_SEGMENT to turn a coff
91 section number into a segment number
93 static symbolS
*previous_file_symbol
= NULL
;
94 void c_symbol_merge ();
97 symbolS
*c_section_symbol ();
99 void EXFUN (bfd_as_write_hook
, (struct internal_filehdr
*,
102 static void EXFUN (fixup_segment
, (segment_info_type
*segP
,
103 segT this_segment_type
));
106 static void EXFUN (fixup_mdeps
, (fragS
*,
111 static void EXFUN (fill_section
, (bfd
* abfd
,
116 char *EXFUN (s_get_name
, (symbolS
* s
));
117 static symbolS
*EXFUN (tag_find_or_make
, (char *name
));
118 static symbolS
*EXFUN (tag_find
, (char *name
));
125 unsigned short line_number
,
129 static void EXFUN (w_symbols
,
132 symbolS
* symbol_rootP
));
136 static void EXFUN (obj_coff_def
, (int what
));
137 static void EXFUN (obj_coff_lcomm
, (void));
138 static void EXFUN (obj_coff_dim
, (void));
139 static void EXFUN (obj_coff_text
, (void));
140 static void EXFUN (obj_coff_data
, (void));
141 static void EXFUN( obj_coff_bss
,(void));
142 static void EXFUN( obj_coff_ident
,(void));
143 static void EXFUN (obj_coff_endef
, (void));
144 static void EXFUN (obj_coff_line
, (void));
145 static void EXFUN (obj_coff_ln
, (void));
146 static void EXFUN (obj_coff_scl
, (void));
147 static void EXFUN (obj_coff_size
, (void));
148 static void EXFUN (obj_coff_tag
, (void));
149 static void EXFUN (obj_coff_type
, (void));
150 static void EXFUN (obj_coff_val
, (void));
151 void EXFUN (obj_coff_section
, (void));
152 static void EXFUN (tag_init
, (void));
153 static void EXFUN (tag_insert
, (char *name
, symbolS
* symbolP
));
156 static struct hash_control
*tag_hash
;
157 static symbolS
*def_symbol_in_progress
= NULL
;
159 const pseudo_typeS obj_pseudo_table
[] =
161 {"def", obj_coff_def
, 0},
162 {"dim", obj_coff_dim
, 0},
163 {"endef", obj_coff_endef
, 0},
164 {"line", obj_coff_line
, 0},
165 {"ln", obj_coff_ln
, 0},
166 {"scl", obj_coff_scl
, 0},
167 {"size", obj_coff_size
, 0},
168 {"tag", obj_coff_tag
, 0},
169 {"type", obj_coff_type
, 0},
170 {"val", obj_coff_val
, 0},
171 {"section", obj_coff_section
, 0},
172 {"use", obj_coff_section
, 0},
173 {"sect", obj_coff_section
, 0},
174 {"text", obj_coff_text
, 0},
175 {"data", obj_coff_data
, 0},
176 {"bss", obj_coff_bss
, 0},
177 {"ident", obj_coff_ident
, 0},
178 {"ABORT", s_abort
, 0},
179 {"lcomm", obj_coff_lcomm
, 0},
180 {NULL
} /* end sentinel */
181 }; /* obj_pseudo_table */
187 We allow more than just the standard 3 sections, infact, we allow
188 10 sections, (though the usual three have to be there).
190 This structure performs the mappings for us:
195 static struct internal_scnhdr bss_section_header;
196 struct internal_scnhdr data_section_header;
197 struct internal_scnhdr text_section_header;
199 const segT N_TYPE_seg [32] =
213 seg_info_type seg_info_off_by_4
[N_SEG
] =
244 #define SEG_INFO_FROM_SECTION_NUMBER(x) (seg_info_off_by_4[(x)+4])
245 #define SEG_INFO_FROM_SEG_NUMBER(x) (seg_info_off_by_4[(x)])
249 DEFUN (relax_align
, (address
, alignment
),
250 register relax_addressT address AND
251 register long alignment
)
254 relax_addressT new_address
;
256 mask
= ~((~0) << alignment
);
257 new_address
= (address
+ mask
) & (~mask
);
258 return (new_address
- address
);
259 } /* relax_align() */
263 DEFUN (s_get_segment
, (x
),
266 return SEG_INFO_FROM_SECTION_NUMBER (x
->sy_symbol
.ost_entry
.n_scnum
).seg_t
;
271 /* calculate the size of the frag chain and fill in the section header
272 to contain all of it, also fill in the addr of the sections */
274 DEFUN (size_section
, (abfd
, idx
),
279 unsigned int size
= 0;
280 fragS
*frag
= segment_info
[idx
].frchainP
->frch_root
;
283 size
= frag
->fr_address
;
284 if (frag
->fr_address
!= size
)
286 printf ("Out of step\n");
287 size
= frag
->fr_address
;
290 switch (frag
->fr_type
)
292 #ifdef TC_COFF_SIZEMACHDEP
293 case rs_machine_dependent
:
294 size
+= TC_COFF_SIZEMACHDEP (frag
);
299 size
+= frag
->fr_fix
;
300 size
+= frag
->fr_offset
* frag
->fr_var
;
303 size
+= frag
->fr_fix
;
304 size
+= relax_align (size
, frag
->fr_offset
);
306 frag
= frag
->fr_next
;
308 segment_info
[idx
].scnhdr
.s_size
= size
;
314 DEFUN (count_entries_in_chain
, (idx
),
317 unsigned int nrelocs
;
320 /* Count the relocations */
321 fixup_ptr
= segment_info
[idx
].fix_root
;
323 while (fixup_ptr
!= (fixS
*) NULL
)
325 if (TC_COUNT_RELOC (fixup_ptr
))
330 if (fixup_ptr
->fx_r_type
== RELOC_CONSTH
)
339 fixup_ptr
= fixup_ptr
->fx_next
;
344 /* output all the relocations for a section */
346 DEFUN (do_relocs_for
, (abfd
, h
, file_cursor
),
348 object_headers
* h AND
349 unsigned long *file_cursor
)
351 unsigned int nrelocs
;
353 unsigned long reloc_start
= *file_cursor
;
355 for (idx
= SEG_E0
; idx
< SEG_E9
; idx
++)
357 if (segment_info
[idx
].scnhdr
.s_name
[0])
359 struct external_reloc
*ext_ptr
;
360 struct external_reloc
*external_reloc_vec
;
361 unsigned int external_reloc_size
;
362 unsigned int count
= 0;
363 unsigned int base
= segment_info
[idx
].scnhdr
.s_paddr
;
364 fixS
*fix_ptr
= segment_info
[idx
].fix_root
;
365 nrelocs
= count_entries_in_chain (idx
);
368 /* Bypass this stuff if no relocs. This also incidentally
369 avoids a SCO bug, where free(malloc(0)) tends to crash. */
371 external_reloc_size
= nrelocs
* RELSZ
;
373 (struct external_reloc
*) malloc (external_reloc_size
);
375 ext_ptr
= external_reloc_vec
;
377 /* Fill in the internal coff style reloc struct from the
378 internal fix list. */
382 struct internal_reloc intr
;
384 /* Only output some of the relocations */
385 if (TC_COUNT_RELOC (fix_ptr
))
387 #ifdef TC_RELOC_MANGLE
388 TC_RELOC_MANGLE (fix_ptr
, &intr
, base
);
392 symbol_ptr
= fix_ptr
->fx_addsy
;
394 intr
.r_type
= TC_COFF_FIX2RTYPE (fix_ptr
);
396 base
+ fix_ptr
->fx_frag
->fr_address
+ fix_ptr
->fx_where
;
398 intr
.r_offset
= fix_ptr
->fx_offset
;
402 /* Turn the segment of the symbol into an offset. */
405 dot
= segment_info
[S_GET_SEGMENT (symbol_ptr
)].dot
;
408 intr
.r_symndx
= dot
->sy_number
;
412 intr
.r_symndx
= symbol_ptr
->sy_number
;
422 (void) bfd_coff_swap_reloc_out (abfd
, &intr
, ext_ptr
);
427 /* The 29k has a special kludge for the high 16 bit
428 reloc. Two relocations are emited, R_IHIHALF,
429 and R_IHCONST. The second one doesn't contain a
430 symbol, but uses the value for offset. */
432 if (intr
.r_type
== R_IHIHALF
)
434 /* now emit the second bit */
435 intr
.r_type
= R_IHCONST
;
436 intr
.r_symndx
= fix_ptr
->fx_addnumber
;
437 (void) bfd_coff_swap_reloc_out (abfd
, &intr
, ext_ptr
);
443 fix_ptr
= fix_ptr
->fx_next
;
446 /* Write out the reloc table */
447 bfd_write ((PTR
) external_reloc_vec
, 1, external_reloc_size
,
449 free (external_reloc_vec
);
451 /* Fill in section header info. */
452 segment_info
[idx
].scnhdr
.s_relptr
= *file_cursor
;
453 *file_cursor
+= external_reloc_size
;
454 segment_info
[idx
].scnhdr
.s_nreloc
= nrelocs
;
459 segment_info
[idx
].scnhdr
.s_relptr
= 0;
463 /* Set relocation_size field in file headers */
464 H_SET_RELOCATION_SIZE (h
, *file_cursor
- reloc_start
, 0);
468 /* run through a frag chain and write out the data to go with it, fill
469 in the scnhdrs with the info on the file postions
472 DEFUN (fill_section
, (abfd
, h
, file_cursor
),
474 object_headers
*h AND
475 unsigned long *file_cursor
)
479 unsigned int paddr
= 0;
481 for (i
= SEG_E0
; i
< SEG_UNKNOWN
; i
++)
483 unsigned int offset
= 0;
485 struct internal_scnhdr
*s
= &(segment_info
[i
].scnhdr
);
489 fragS
*frag
= segment_info
[i
].frchainP
->frch_root
;
496 buffer
= xmalloc (s
->s_size
);
497 s
->s_scnptr
= *file_cursor
;
499 know (s
->s_paddr
== paddr
);
501 s
->s_flags
= STYP_REG
;
502 if (strcmp (s
->s_name
, ".text") == 0)
503 s
->s_flags
|= STYP_TEXT
;
504 else if (strcmp (s
->s_name
, ".data") == 0)
505 s
->s_flags
|= STYP_DATA
;
506 else if (strcmp (s
->s_name
, ".bss") == 0)
509 s
->s_flags
|= STYP_BSS
;
512 /* Apparently the SVR3 linker is confused by noload
513 sections. So is the UDI mondfe program. */
514 s
->s_flags
|= STYP_NOLOAD
;
518 else if (strcmp (s
->s_name
, ".lit") == 0)
519 s
->s_flags
= STYP_LIT
| STYP_TEXT
;
520 else if (strcmp (s
->s_name
, ".init") == 0)
521 s
->s_flags
|= STYP_TEXT
;
522 else if (strcmp (s
->s_name
, ".fini") == 0)
523 s
->s_flags
|= STYP_TEXT
;
524 else if (strncmp (s
->s_name
, ".comment", 8) == 0)
525 s
->s_flags
|= STYP_INFO
;
529 unsigned int fill_size
;
530 switch (frag
->fr_type
)
532 case rs_machine_dependent
:
535 memcpy (buffer
+ frag
->fr_address
,
538 offset
+= frag
->fr_fix
;
547 memcpy (buffer
+ frag
->fr_address
,
550 offset
+= frag
->fr_fix
;
553 fill_size
= frag
->fr_var
;
557 unsigned int off
= frag
->fr_fix
;
558 for (count
= frag
->fr_offset
; count
; count
--)
560 if (fill_size
< s
->s_size
)
562 memcpy (buffer
+ frag
->fr_address
+ off
,
563 frag
->fr_literal
+ frag
->fr_fix
,
576 frag
= frag
->fr_next
;
581 if (s
->s_scnptr
!= 0)
583 bfd_write (buffer
, s
->s_size
, 1, abfd
);
584 *file_cursor
+= s
->s_size
;
593 /* Coff file generation & utilities */
596 DEFUN (coff_header_append
, (abfd
, h
),
604 bfd_seek (abfd
, 0, 0);
606 #ifndef OBJ_COFF_OMIT_OPTIONAL_HEADER
607 H_SET_MAGIC_NUMBER (h
, COFF_MAGIC
);
608 H_SET_VERSION_STAMP (h
, 0);
609 H_SET_ENTRY_POINT (h
, 0);
610 H_SET_TEXT_START (h
, segment_info
[SEG_E0
].frchainP
->frch_root
->fr_address
);
611 H_SET_DATA_START (h
, segment_info
[SEG_E1
].frchainP
->frch_root
->fr_address
);
612 H_SET_SIZEOF_OPTIONAL_HEADER (h
, bfd_coff_swap_aouthdr_out(abfd
, &h
->aouthdr
,
614 #else /* defined (OBJ_COFF_OMIT_OPTIONAL_HEADER) */
615 H_SET_SIZEOF_OPTIONAL_HEADER (h
, 0);
616 #endif /* defined (OBJ_COFF_OMIT_OPTIONAL_HEADER) */
618 i
= bfd_coff_swap_filehdr_out (abfd
, &h
->filehdr
, buffer
);
620 bfd_write (buffer
, i
, 1, abfd
);
621 bfd_write (buffero
, H_GET_SIZEOF_OPTIONAL_HEADER (h
), 1, abfd
);
623 for (i
= SEG_E0
; i
< SEG_E9
; i
++)
625 if (segment_info
[i
].scnhdr
.s_name
[0])
628 bfd_coff_swap_scnhdr_out (abfd
,
629 &(segment_info
[i
].scnhdr
),
631 bfd_write (buffer
, size
, 1, abfd
);
638 DEFUN (symbol_to_chars
, (abfd
, where
, symbolP
),
643 unsigned int numaux
= symbolP
->sy_symbol
.ost_entry
.n_numaux
;
646 /* Turn any symbols with register attributes into abs symbols */
647 if (S_GET_SEGMENT (symbolP
) == SEG_REGISTER
)
649 S_SET_SEGMENT (symbolP
, SEG_ABSOLUTE
);
651 /* At the same time, relocate all symbols to their output value */
653 S_SET_VALUE (symbolP
,
654 segment_info
[S_GET_SEGMENT (symbolP
)].scnhdr
.s_paddr
655 + S_GET_VALUE (symbolP
));
657 where
+= bfd_coff_swap_sym_out (abfd
, &symbolP
->sy_symbol
.ost_entry
,
660 for (i
= 0; i
< numaux
; i
++)
662 where
+= bfd_coff_swap_aux_out (abfd
,
663 &symbolP
->sy_symbol
.ost_auxent
[i
],
664 S_GET_DATA_TYPE (symbolP
),
665 S_GET_STORAGE_CLASS (symbolP
),
676 obj_symbol_new_hook (symbolP
)
679 char underscore
= 0; /* Symbol has leading _ */
681 /* Effective symbol */
682 /* Store the pointer in the offset. */
683 S_SET_ZEROES (symbolP
, 0L);
684 S_SET_DATA_TYPE (symbolP
, T_NULL
);
685 S_SET_STORAGE_CLASS (symbolP
, 0);
686 S_SET_NUMBER_AUXILIARY (symbolP
, 0);
687 /* Additional information */
688 symbolP
->sy_symbol
.ost_flags
= 0;
689 /* Auxiliary entries */
690 bzero ((char *) &symbolP
->sy_symbol
.ost_auxent
[0], AUXESZ
);
692 #ifdef STRIP_UNDERSCORE
693 /* Remove leading underscore at the beginning of the symbol.
694 * This is to be compatible with the standard librairies.
696 if (*S_GET_NAME (symbolP
) == '_')
699 S_SET_NAME (symbolP
, S_GET_NAME (symbolP
) + 1);
700 } /* strip underscore */
701 #endif /* STRIP_UNDERSCORE */
703 if (S_IS_STRING (symbolP
))
704 SF_SET_STRING (symbolP
);
705 if (!underscore
&& S_IS_LOCAL (symbolP
))
706 SF_SET_LOCAL (symbolP
);
709 } /* obj_symbol_new_hook() */
713 stack_init (chunk_size
, element_size
)
714 unsigned long chunk_size
;
715 unsigned long element_size
;
719 if ((st
= (stack
*) malloc (sizeof (stack
))) == (stack
*) 0)
721 if ((st
->data
= malloc (chunk_size
)) == (char *) 0)
727 st
->size
= chunk_size
;
728 st
->chunk_size
= chunk_size
;
729 st
->element_size
= element_size
;
742 stack_push (st
, element
)
746 if (st
->pointer
+ st
->element_size
>= st
->size
)
748 st
->size
+= st
->chunk_size
;
749 if ((st
->data
= xrealloc (st
->data
, st
->size
)) == (char *) 0)
752 memcpy (st
->data
+ st
->pointer
, element
, st
->element_size
);
753 st
->pointer
+= st
->element_size
;
754 return st
->data
+ st
->pointer
;
761 if ((st
->pointer
-= st
->element_size
) < 0)
767 return st
->data
+ st
->pointer
;
774 return st
->data
+ st
->pointer
- st
->element_size
;
779 * Handle .ln directives.
787 if (def_symbol_in_progress
!= NULL
)
789 as_warn (".ln pseudo-op inside .def/.endef: ignored.");
790 demand_empty_rest_of_line ();
792 } /* wrong context */
795 obstack_next_free (&frags
) - frag_now
->fr_literal
,
796 l
= get_absolute_expression (),
804 listing_source_line (l
+ line_base
- 1);
809 demand_empty_rest_of_line ();
811 } /* obj_coff_line() */
816 * Handle .def directives.
818 * One might ask : why can't we symbol_new if the symbol does not
819 * already exist and fill it with debug information. Because of
820 * the C_EFCN special symbol. It would clobber the value of the
821 * function symbol before we have a chance to notice that it is
822 * a C_EFCN. And a second reason is that the code is more clear this
823 * way. (at least I think it is :-).
827 #define SKIP_SEMI_COLON() while (*input_line_pointer++ != ';')
828 #define SKIP_WHITESPACES() while (*input_line_pointer == ' ' || \
829 *input_line_pointer == '\t') \
830 input_line_pointer++;
833 DEFUN (obj_coff_def
, (what
),
836 char name_end
; /* Char after the end of name */
837 char *symbol_name
; /* Name of the debug symbol */
838 char *symbol_name_copy
; /* Temporary copy of the name */
839 unsigned int symbol_name_length
;
840 /*$char* directiveP;$ *//* Name of the pseudo opcode */
841 /*$char directive[MAX_DIRECTIVE];$ *//* Backup of the directive */
842 /*$char end = 0;$ *//* If 1, stop parsing */
844 if (def_symbol_in_progress
!= NULL
)
846 as_warn (".def pseudo-op used inside of .def/.endef: ignored.");
847 demand_empty_rest_of_line ();
849 } /* if not inside .def/.endef */
853 def_symbol_in_progress
= (symbolS
*) obstack_alloc (¬es
, sizeof (*def_symbol_in_progress
));
854 bzero (def_symbol_in_progress
, sizeof (*def_symbol_in_progress
));
856 symbol_name
= input_line_pointer
;
857 name_end
= get_symbol_end ();
858 symbol_name_length
= strlen (symbol_name
);
859 symbol_name_copy
= xmalloc (symbol_name_length
+ 1);
860 strcpy (symbol_name_copy
, symbol_name
);
862 /* Initialize the new symbol */
863 #ifdef STRIP_UNDERSCORE
864 S_SET_NAME (def_symbol_in_progress
, (*symbol_name_copy
== '_'
865 ? symbol_name_copy
+ 1
866 : symbol_name_copy
));
867 #else /* STRIP_UNDERSCORE */
868 S_SET_NAME (def_symbol_in_progress
, symbol_name_copy
);
869 #endif /* STRIP_UNDERSCORE */
870 /* free(symbol_name_copy); */
871 def_symbol_in_progress
->sy_name_offset
= ~0;
872 def_symbol_in_progress
->sy_number
= ~0;
873 def_symbol_in_progress
->sy_frag
= &zero_address_frag
;
875 if (S_IS_STRING (def_symbol_in_progress
))
877 SF_SET_STRING (def_symbol_in_progress
);
880 *input_line_pointer
= name_end
;
882 demand_empty_rest_of_line ();
884 } /* obj_coff_def() */
886 unsigned int dim_index
;
888 DEFUN_VOID (obj_coff_endef
)
890 symbolS
*symbolP
= 0;
891 /* DIM BUG FIX sac@cygnus.com */
893 if (def_symbol_in_progress
== NULL
)
895 as_warn (".endef pseudo-op used outside of .def/.endef: ignored.");
896 demand_empty_rest_of_line ();
898 } /* if not inside .def/.endef */
900 /* Set the section number according to storage class. */
901 switch (S_GET_STORAGE_CLASS (def_symbol_in_progress
))
906 SF_SET_TAG (def_symbol_in_progress
);
907 /* intentional fallthrough */
910 SF_SET_DEBUG (def_symbol_in_progress
);
911 S_SET_SEGMENT (def_symbol_in_progress
, SEG_DEBUG
);
915 SF_SET_LOCAL (def_symbol_in_progress
); /* Do not emit this symbol. */
916 /* intentional fallthrough */
918 SF_SET_PROCESS (def_symbol_in_progress
); /* Will need processing before writing */
919 /* intentional fallthrough */
921 S_SET_SEGMENT (def_symbol_in_progress
, SEG_E0
);
923 if (strcmp (S_GET_NAME (def_symbol_in_progress
), ".bf") == 0)
925 if (function_lineoff
< 0)
927 fprintf (stderr
, "`.bf' symbol without preceding function\n");
928 } /* missing function symbol */
929 SA_GET_SYM_LNNOPTR (last_line_symbol
) = function_lineoff
;
931 SF_SET_PROCESS (last_line_symbol
);
932 function_lineoff
= -1;
938 #endif /* C_AUTOARG */
948 SF_SET_DEBUG (def_symbol_in_progress
);
949 S_SET_SEGMENT (def_symbol_in_progress
, SEG_ABSOLUTE
);
955 /* Valid but set somewhere else (s_comm, s_lcomm, colon) */
961 as_warn ("unexpected storage class %d", S_GET_STORAGE_CLASS (def_symbol_in_progress
));
963 } /* switch on storage class */
965 /* Now that we have built a debug symbol, try to find if
966 we should merge with an existing symbol or not. If a
967 symbol is C_EFCN or SEG_ABSOLUTE or untagged
968 SEG_DEBUG it never merges. We also don't merge
969 labels, which are in a different namespace, nor
970 symbols which have not yet been defined since they
971 are typically unique, nor do we merge tags with
974 /* Two cases for functions. Either debug followed
975 by definition or definition followed by debug.
976 For definition first, we will merge the debug
977 symbol into the definition. For debug first, the
978 lineno entry MUST point to the definition
979 function or else it will point off into space
980 when crawl_symbols() merges the debug
981 symbol into the real symbol. Therefor, let's
982 presume the debug symbol is a real function
985 /* FIXME-SOON If for some reason the definition
986 label/symbol is never seen, this will probably
987 leave an undefined symbol at link time. */
989 if (S_GET_STORAGE_CLASS (def_symbol_in_progress
) == C_EFCN
990 || S_GET_STORAGE_CLASS (def_symbol_in_progress
) == C_LABEL
991 || (S_GET_SEGMENT (def_symbol_in_progress
) == SEG_DEBUG
992 && !SF_GET_TAG (def_symbol_in_progress
))
993 || S_GET_SEGMENT (def_symbol_in_progress
) == SEG_ABSOLUTE
994 || def_symbol_in_progress
->sy_forward
!= NULL
995 || (symbolP
= symbol_find_base (S_GET_NAME (def_symbol_in_progress
), DO_NOT_STRIP
)) == NULL
996 || (SF_GET_TAG (def_symbol_in_progress
) != SF_GET_TAG (symbolP
)))
999 symbol_append (def_symbol_in_progress
, symbol_lastP
, &symbol_rootP
, &symbol_lastP
);
1004 /* This symbol already exists, merge the
1005 newly created symbol into the old one.
1006 This is not mandatory. The linker can
1007 handle duplicate symbols correctly. But I
1008 guess that it save a *lot* of space if
1009 the assembly file defines a lot of
1012 /* The debug entry (def_symbol_in_progress)
1013 is merged into the previous definition. */
1015 c_symbol_merge (def_symbol_in_progress
, symbolP
);
1016 /* FIXME-SOON Should *def_symbol_in_progress be free'd? xoxorich. */
1017 def_symbol_in_progress
= symbolP
;
1019 if (SF_GET_FUNCTION (def_symbol_in_progress
)
1020 || SF_GET_TAG (def_symbol_in_progress
))
1022 /* For functions, and tags, the symbol *must* be where the debug symbol
1023 appears. Move the existing symbol to the current place. */
1024 /* If it already is at the end of the symbol list, do nothing */
1025 if (def_symbol_in_progress
!= symbol_lastP
)
1027 symbol_remove (def_symbol_in_progress
, &symbol_rootP
, &symbol_lastP
);
1028 symbol_append (def_symbol_in_progress
, symbol_lastP
, &symbol_rootP
, &symbol_lastP
);
1029 } /* if not already in place */
1031 } /* normal or mergable */
1033 if (SF_GET_TAG (def_symbol_in_progress
)
1034 && symbol_find_base (S_GET_NAME (def_symbol_in_progress
), DO_NOT_STRIP
) == NULL
)
1036 tag_insert (S_GET_NAME (def_symbol_in_progress
), def_symbol_in_progress
);
1037 } /* If symbol is a {structure,union} tag, associate symbol to its name. */
1039 if (SF_GET_FUNCTION (def_symbol_in_progress
))
1041 know (sizeof (def_symbol_in_progress
) <= sizeof (long));
1043 = c_line_new (def_symbol_in_progress
, 0, 0, &zero_address_frag
);
1047 SF_SET_PROCESS (def_symbol_in_progress
);
1049 if (symbolP
== NULL
)
1051 /* That is, if this is the first
1052 time we've seen the function... */
1053 symbol_table_insert (def_symbol_in_progress
);
1054 } /* definition follows debug */
1055 } /* Create the line number entry pointing to the function being defined */
1057 def_symbol_in_progress
= NULL
;
1058 demand_empty_rest_of_line ();
1060 } /* obj_coff_endef() */
1063 DEFUN_VOID (obj_coff_dim
)
1065 register int dim_index
;
1067 if (def_symbol_in_progress
== NULL
)
1069 as_warn (".dim pseudo-op used outside of .def/.endef: ignored.");
1070 demand_empty_rest_of_line ();
1072 } /* if not inside .def/.endef */
1074 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
1076 for (dim_index
= 0; dim_index
< DIMNUM
; dim_index
++)
1078 SKIP_WHITESPACES ();
1079 SA_SET_SYM_DIMEN (def_symbol_in_progress
, dim_index
, get_absolute_expression ());
1081 switch (*input_line_pointer
)
1085 input_line_pointer
++;
1089 as_warn ("badly formed .dim directive ignored");
1090 /* intentional fallthrough */
1095 } /* switch on following character */
1096 } /* for each dimension */
1098 demand_empty_rest_of_line ();
1100 } /* obj_coff_dim() */
1107 if (def_symbol_in_progress
== NULL
)
1111 } /* if it looks like a stabs style line */
1113 this_base
= get_absolute_expression ();
1114 if (this_base
> line_base
)
1116 line_base
= this_base
;
1125 listing_source_line (line_base
);
1129 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
1130 SA_SET_SYM_LNNO (def_symbol_in_progress
, line_base
);
1132 demand_empty_rest_of_line ();
1134 } /* obj_coff_line() */
1139 if (def_symbol_in_progress
== NULL
)
1141 as_warn (".size pseudo-op used outside of .def/.endef ignored.");
1142 demand_empty_rest_of_line ();
1144 } /* if not inside .def/.endef */
1146 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
1147 SA_SET_SYM_SIZE (def_symbol_in_progress
, get_absolute_expression ());
1148 demand_empty_rest_of_line ();
1150 } /* obj_coff_size() */
1155 if (def_symbol_in_progress
== NULL
)
1157 as_warn (".scl pseudo-op used outside of .def/.endef ignored.");
1158 demand_empty_rest_of_line ();
1160 } /* if not inside .def/.endef */
1162 S_SET_STORAGE_CLASS (def_symbol_in_progress
, get_absolute_expression ());
1163 demand_empty_rest_of_line ();
1165 } /* obj_coff_scl() */
1173 if (def_symbol_in_progress
== NULL
)
1175 as_warn (".tag pseudo-op used outside of .def/.endef ignored.");
1176 demand_empty_rest_of_line ();
1178 } /* if not inside .def/.endef */
1180 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
1181 symbol_name
= input_line_pointer
;
1182 name_end
= get_symbol_end ();
1184 /* Assume that the symbol referred to by .tag is always defined. */
1185 /* This was a bad assumption. I've added find_or_make. xoxorich. */
1186 SA_SET_SYM_TAGNDX (def_symbol_in_progress
, (long) tag_find_or_make (symbol_name
));
1187 if (SA_GET_SYM_TAGNDX (def_symbol_in_progress
) == 0L)
1189 as_warn ("tag not found for .tag %s", symbol_name
);
1192 SF_SET_TAGGED (def_symbol_in_progress
);
1193 *input_line_pointer
= name_end
;
1195 demand_empty_rest_of_line ();
1197 } /* obj_coff_tag() */
1202 if (def_symbol_in_progress
== NULL
)
1204 as_warn (".type pseudo-op used outside of .def/.endef ignored.");
1205 demand_empty_rest_of_line ();
1207 } /* if not inside .def/.endef */
1209 S_SET_DATA_TYPE (def_symbol_in_progress
, get_absolute_expression ());
1211 if (ISFCN (S_GET_DATA_TYPE (def_symbol_in_progress
)) &&
1212 S_GET_STORAGE_CLASS (def_symbol_in_progress
) != C_TPDEF
)
1214 SF_SET_FUNCTION (def_symbol_in_progress
);
1215 } /* is a function */
1217 demand_empty_rest_of_line ();
1219 } /* obj_coff_type() */
1224 if (def_symbol_in_progress
== NULL
)
1226 as_warn (".val pseudo-op used outside of .def/.endef ignored.");
1227 demand_empty_rest_of_line ();
1229 } /* if not inside .def/.endef */
1231 if (is_name_beginner (*input_line_pointer
))
1233 char *symbol_name
= input_line_pointer
;
1234 char name_end
= get_symbol_end ();
1236 if (!strcmp (symbol_name
, "."))
1238 def_symbol_in_progress
->sy_frag
= frag_now
;
1239 S_SET_VALUE (def_symbol_in_progress
, obstack_next_free (&frags
) - frag_now
->fr_literal
);
1240 /* If the .val is != from the .def (e.g. statics) */
1242 else if (strcmp (S_GET_NAME (def_symbol_in_progress
), symbol_name
))
1244 def_symbol_in_progress
->sy_forward
= symbol_find_or_make (symbol_name
);
1246 /* If the segment is undefined when the forward
1247 reference is solved, then copy the segment id
1248 from the forward symbol. */
1249 SF_SET_GET_SEGMENT (def_symbol_in_progress
);
1251 /* FIXME: gcc can generate address expressions
1252 here in unusual cases (search for "obscure"
1253 in sdbout.c). We just ignore the offset
1254 here, thus generating incorrect debugging
1255 information. We ignore the rest of the
1258 /* Otherwise, it is the name of a non debug symbol and
1259 its value will be calculated later. */
1260 *input_line_pointer
= name_end
;
1262 /* FIXME: this is to avoid an error message in the
1263 FIXME case mentioned just above. */
1264 while (! is_end_of_line
[*input_line_pointer
])
1265 ++input_line_pointer
;
1269 S_SET_VALUE (def_symbol_in_progress
, get_absolute_expression ());
1270 } /* if symbol based */
1272 demand_empty_rest_of_line ();
1274 } /* obj_coff_val() */
1277 * Maintain a list of the tagnames of the structres.
1283 tag_hash
= hash_new ();
1288 tag_insert (name
, symbolP
)
1292 register char *error_string
;
1294 if (*(error_string
= hash_jam (tag_hash
, name
, (char *) symbolP
)))
1296 as_fatal ("Inserting \"%s\" into structure table failed: %s",
1297 name
, error_string
);
1300 } /* tag_insert() */
1303 tag_find_or_make (name
)
1308 if ((symbolP
= tag_find (name
)) == NULL
)
1310 symbolP
= symbol_new (name
,
1313 &zero_address_frag
);
1315 tag_insert (S_GET_NAME (symbolP
), symbolP
);
1319 } /* tag_find_or_make() */
1325 #ifdef STRIP_UNDERSCORE
1328 #endif /* STRIP_UNDERSCORE */
1329 return ((symbolS
*) hash_find (tag_hash
, name
));
1333 obj_read_begin_hook ()
1335 /* These had better be the same. Usually 18 bytes. */
1337 know (sizeof (SYMENT
) == sizeof (AUXENT
));
1338 know (SYMESZ
== AUXESZ
);
1343 } /* obj_read_begin_hook() */
1345 /* This function runs through the symbol table and puts all the
1346 externals onto another chain */
1348 /* The chain of externals */
1349 symbolS
*symbol_externP
= NULL
;
1350 symbolS
*symbol_extern_lastP
= NULL
;
1353 symbolS
*last_functionP
= NULL
;
1358 DEFUN_VOID (yank_symbols
)
1361 unsigned int symbol_number
= 0;
1363 for (symbolP
= symbol_rootP
;
1365 symbolP
= symbolP
? symbol_next (symbolP
) : symbol_rootP
)
1367 if (!SF_GET_DEBUG (symbolP
))
1369 /* Debug symbols do not need all this rubbish */
1370 symbolS
*real_symbolP
;
1372 /* L* and C_EFCN symbols never merge. */
1373 if (!SF_GET_LOCAL (symbolP
)
1374 && S_GET_STORAGE_CLASS (symbolP
) != C_LABEL
1375 && (real_symbolP
= symbol_find_base (S_GET_NAME (symbolP
), DO_NOT_STRIP
))
1376 && real_symbolP
!= symbolP
)
1378 /* FIXME-SOON: where do dups come from?
1379 Maybe tag references before definitions? xoxorich. */
1380 /* Move the debug data from the debug symbol to the
1381 real symbol. Do NOT do the oposite (i.e. move from
1382 real symbol to debug symbol and remove real symbol from the
1383 list.) Because some pointers refer to the real symbol
1384 whereas no pointers refer to the debug symbol. */
1385 c_symbol_merge (symbolP
, real_symbolP
);
1386 /* Replace the current symbol by the real one */
1387 /* The symbols will never be the last or the first
1388 because : 1st symbol is .file and 3 last symbols are
1389 .text, .data, .bss */
1390 symbol_remove (real_symbolP
, &symbol_rootP
, &symbol_lastP
);
1391 symbol_insert (real_symbolP
, symbolP
, &symbol_rootP
, &symbol_lastP
);
1392 symbol_remove (symbolP
, &symbol_rootP
, &symbol_lastP
);
1393 symbolP
= real_symbolP
;
1394 } /* if not local but dup'd */
1396 if (flagseen
['R'] && (S_GET_SEGMENT (symbolP
) == SEG_E1
))
1398 S_SET_SEGMENT (symbolP
, SEG_E0
);
1399 } /* push data into text */
1401 S_SET_VALUE (symbolP
,
1402 S_GET_VALUE (symbolP
) + symbolP
->sy_frag
->fr_address
);
1404 if (!S_IS_DEFINED (symbolP
) && !SF_GET_LOCAL (symbolP
))
1406 S_SET_EXTERNAL (symbolP
);
1408 else if (S_GET_STORAGE_CLASS (symbolP
) == C_NULL
)
1410 if (S_GET_SEGMENT (symbolP
) == SEG_E0
)
1412 S_SET_STORAGE_CLASS (symbolP
, C_LABEL
);
1416 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
1420 /* Mainly to speed up if not -g */
1421 if (SF_GET_PROCESS (symbolP
))
1423 /* Handle the nested blocks auxiliary info. */
1424 if (S_GET_STORAGE_CLASS (symbolP
) == C_BLOCK
)
1426 if (!strcmp (S_GET_NAME (symbolP
), ".bb"))
1427 stack_push (block_stack
, (char *) &symbolP
);
1430 register symbolS
*begin_symbolP
;
1431 begin_symbolP
= *(symbolS
**) stack_pop (block_stack
);
1432 if (begin_symbolP
== (symbolS
*) 0)
1433 as_warn ("mismatched .eb");
1435 SA_SET_SYM_ENDNDX (begin_symbolP
, symbol_number
+ 2);
1438 /* If we are able to identify the type of a function, and we
1439 are out of a function (last_functionP == 0) then, the
1440 function symbol will be associated with an auxiliary
1442 if (last_functionP
== (symbolS
*) 0 &&
1443 SF_GET_FUNCTION (symbolP
))
1445 last_functionP
= symbolP
;
1447 if (S_GET_NUMBER_AUXILIARY (symbolP
) < 1)
1449 S_SET_NUMBER_AUXILIARY (symbolP
, 1);
1450 } /* make it at least 1 */
1452 /* Clobber possible stale .dim information. */
1454 /* Iffed out by steve - this fries the lnnoptr info too */
1455 bzero (symbolP
->sy_symbol
.ost_auxent
[0].x_sym
.x_fcnary
.x_ary
.x_dimen
,
1456 sizeof (symbolP
->sy_symbol
.ost_auxent
[0].x_sym
.x_fcnary
.x_ary
.x_dimen
));
1459 /* The C_FCN doesn't need any additional information.
1460 I don't even know if this is needed for sdb. But the
1461 standard assembler generates it, so...
1463 if (S_GET_STORAGE_CLASS (symbolP
) == C_EFCN
)
1465 if (last_functionP
== (symbolS
*) 0)
1466 as_fatal ("C_EFCN symbol out of scope");
1467 SA_SET_SYM_FSIZE (last_functionP
,
1468 (long) (S_GET_VALUE (symbolP
) -
1469 S_GET_VALUE (last_functionP
)));
1470 SA_SET_SYM_ENDNDX (last_functionP
, symbol_number
);
1471 last_functionP
= (symbolS
*) 0;
1475 else if (SF_GET_TAG (symbolP
))
1477 /* First descriptor of a structure must point to
1478 the first slot after the structure description. */
1479 last_tagP
= symbolP
;
1482 else if (S_GET_STORAGE_CLASS (symbolP
) == C_EOS
)
1484 /* +2 take in account the current symbol */
1485 SA_SET_SYM_ENDNDX (last_tagP
, symbol_number
+ 2);
1487 else if (S_GET_STORAGE_CLASS (symbolP
) == C_FILE
)
1489 if (S_GET_VALUE (symbolP
))
1491 S_SET_VALUE ((symbolS
*) S_GET_VALUE (symbolP
), symbol_number
);
1492 S_SET_VALUE (symbolP
, 0);
1493 } /* no one points at the first .file symbol */
1494 } /* if debug or tag or eos or file */
1496 /* We must put the external symbols apart. The loader
1497 does not bomb if we do not. But the references in
1498 the endndx field for a .bb symbol are not corrected
1499 if an external symbol is removed between .bb and .be.
1500 I.e in the following case :
1501 [20] .bb endndx = 22
1504 ld will move the symbol 21 to the end of the list but
1505 endndx will still be 22 instead of 21. */
1508 if (SF_GET_LOCAL (symbolP
))
1510 /* remove C_EFCN and LOCAL (L...) symbols */
1511 /* next pointer remains valid */
1512 symbol_remove (symbolP
, &symbol_rootP
, &symbol_lastP
);
1515 else if (!S_IS_DEFINED (symbolP
)
1516 && !S_IS_DEBUG (symbolP
)
1517 && !SF_GET_STATICS (symbolP
) &&
1518 S_GET_STORAGE_CLASS (symbolP
) == C_EXT
)
1519 { /* C_EXT && !SF_GET_FUNCTION(symbolP)) */
1520 /* if external, Remove from the list */
1521 symbolS
*hold
= symbol_previous (symbolP
);
1523 symbol_remove (symbolP
, &symbol_rootP
, &symbol_lastP
);
1524 symbol_clear_list_pointers (symbolP
);
1525 symbol_append (symbolP
, symbol_extern_lastP
, &symbol_externP
, &symbol_extern_lastP
);
1530 if (SF_GET_STRING (symbolP
))
1532 symbolP
->sy_name_offset
= string_byte_count
;
1533 string_byte_count
+= strlen (S_GET_NAME (symbolP
)) + 1;
1537 symbolP
->sy_name_offset
= 0;
1538 } /* fix "long" names */
1540 symbolP
->sy_number
= symbol_number
;
1541 symbol_number
+= 1 + S_GET_NUMBER_AUXILIARY (symbolP
);
1542 } /* if local symbol */
1543 } /* traverse the symbol list */
1544 return symbol_number
;
1550 DEFUN_VOID (glue_symbols
)
1552 unsigned int symbol_number
= 0;
1554 for (symbolP
= symbol_externP
; symbol_externP
;)
1556 symbolS
*tmp
= symbol_externP
;
1559 symbol_remove (tmp
, &symbol_externP
, &symbol_extern_lastP
);
1560 symbol_append (tmp
, symbol_lastP
, &symbol_rootP
, &symbol_lastP
);
1563 if (SF_GET_STRING (tmp
))
1565 tmp
->sy_name_offset
= string_byte_count
;
1566 string_byte_count
+= strlen (S_GET_NAME (tmp
)) + 1;
1570 tmp
->sy_name_offset
= 0;
1571 } /* fix "long" names */
1573 tmp
->sy_number
= symbol_number
;
1574 symbol_number
+= 1 + S_GET_NUMBER_AUXILIARY (tmp
);
1575 } /* append the entire extern chain */
1576 return symbol_number
;
1581 DEFUN_VOID (tie_tags
)
1583 unsigned int symbol_number
= 0;
1586 for (symbolP
= symbol_rootP
; symbolP
; symbolP
=
1587 symbol_next (symbolP
))
1589 symbolP
->sy_number
= symbol_number
;
1593 if (SF_GET_TAGGED (symbolP
))
1597 ((symbolS
*) SA_GET_SYM_TAGNDX (symbolP
))->sy_number
);
1600 symbol_number
+= 1 + S_GET_NUMBER_AUXILIARY (symbolP
);
1602 return symbol_number
;
1607 DEFUN (crawl_symbols
, (h
, abfd
),
1608 object_headers
*h AND
1613 unsigned int ptr
= 0;
1618 /* Initialize the stack used to keep track of the matching .bb .be */
1620 block_stack
= stack_init (512, sizeof (symbolS
*));
1621 /* JF deal with forward references first... */
1622 for (symbolP
= symbol_rootP
;
1624 symbolP
= symbol_next (symbolP
))
1627 if (symbolP
->sy_forward
)
1629 S_SET_VALUE (symbolP
, (S_GET_VALUE (symbolP
)
1630 + S_GET_VALUE (symbolP
->sy_forward
)
1631 + symbolP
->sy_forward
->sy_frag
->fr_address
));
1633 if (SF_GET_GET_SEGMENT (symbolP
))
1635 S_SET_SEGMENT (symbolP
, S_GET_SEGMENT (symbolP
->sy_forward
));
1636 } /* forward segment also */
1638 symbolP
->sy_forward
= 0;
1639 } /* if it has a forward reference */
1640 } /* walk the symbol chain */
1643 /* The symbol list should be ordered according to the following sequence
1646 * . debug entries for functions
1647 * . fake symbols for the sections, including.text .data and .bss
1649 * . undefined symbols
1650 * But this is not mandatory. The only important point is to put the
1651 * undefined symbols at the end of the list.
1654 if (symbol_rootP
== NULL
1655 || S_GET_STORAGE_CLASS (symbol_rootP
) != C_FILE
)
1657 c_dot_file_symbol ("fake");
1659 /* Is there a .file symbol ? If not insert one at the beginning. */
1662 * Build up static symbols for the sections, they are filled in later
1666 for (i
= SEG_E0
; i
< SEG_E9
; i
++)
1668 if (segment_info
[i
].scnhdr
.s_name
[0])
1672 strncpy (name
, segment_info
[i
].scnhdr
.s_name
, 8);
1674 segment_info
[i
].dot
= c_section_symbol (name
, i
- SEG_E0
+ 1);
1679 /* Take all the externals out and put them into another chain */
1680 H_SET_SYMBOL_TABLE_SIZE (h
, yank_symbols ());
1681 /* Take the externals and glue them onto the end.*/
1682 H_SET_SYMBOL_TABLE_SIZE (h
, H_GET_SYMBOL_COUNT (h
) + glue_symbols ());
1684 H_SET_SYMBOL_TABLE_SIZE (h
, tie_tags ());
1685 know (symbol_externP
== NULL
);
1686 know (symbol_extern_lastP
== NULL
);
1692 * Find strings by crawling along symbol table chain.
1696 DEFUN (w_strings
, (where
),
1701 /* Gotta do md_ byte-ordering stuff for string_byte_count first - KWK */
1702 md_number_to_chars (where
, string_byte_count
, sizeof (string_byte_count
));
1703 where
+= sizeof (string_byte_count
);
1704 for (symbolP
= symbol_rootP
;
1706 symbolP
= symbol_next (symbolP
))
1710 if (SF_GET_STRING (symbolP
))
1712 size
= strlen (S_GET_NAME (symbolP
)) + 1;
1714 memcpy (where
, S_GET_NAME (symbolP
), size
);
1723 DEFUN (do_linenos_for
, (abfd
, h
, file_cursor
),
1725 object_headers
* h AND
1726 unsigned long *file_cursor
)
1729 unsigned long start
= *file_cursor
;
1731 for (idx
= SEG_E0
; idx
< SEG_E9
; idx
++)
1733 segment_info_type
*s
= segment_info
+ idx
;
1736 if (s
->scnhdr
.s_nlnno
!= 0)
1738 struct lineno_list
*line_ptr
;
1740 struct external_lineno
*buffer
=
1741 (struct external_lineno
*) xmalloc (s
->scnhdr
.s_nlnno
* LINESZ
);
1743 struct external_lineno
*dst
= buffer
;
1745 /* Run through the table we've built and turn it into its external
1746 form, take this chance to remove duplicates */
1748 for (line_ptr
= s
->lineno_list_head
;
1749 line_ptr
!= (struct lineno_list
*) NULL
;
1750 line_ptr
= line_ptr
->next
)
1753 if (line_ptr
->line
.l_lnno
== 0)
1755 /* Turn a pointer to a symbol into the symbols' index */
1756 line_ptr
->line
.l_addr
.l_symndx
=
1757 ((symbolS
*) line_ptr
->line
.l_addr
.l_symndx
)->sy_number
;
1761 line_ptr
->line
.l_addr
.l_paddr
+= ((struct frag
*) (line_ptr
->frag
))->fr_address
;
1765 (void) bfd_coff_swap_lineno_out (abfd
, &(line_ptr
->line
), dst
);
1770 s
->scnhdr
.s_lnnoptr
= *file_cursor
;
1772 bfd_write (buffer
, 1, s
->scnhdr
.s_nlnno
* LINESZ
, abfd
);
1775 *file_cursor
+= s
->scnhdr
.s_nlnno
* LINESZ
;
1778 H_SET_LINENO_SIZE (h
, *file_cursor
- start
);
1782 /* Now we run through the list of frag chains in a segment and
1783 make all the subsegment frags appear at the end of the
1784 list, as if the seg 0 was extra long */
1787 DEFUN_VOID (remove_subsegs
)
1791 for (i
= SEG_E0
; i
< SEG_UNKNOWN
; i
++)
1793 frchainS
*head
= segment_info
[i
].frchainP
;
1795 fragS
*prev_frag
= &dummy
;
1797 while (head
&& head
->frch_seg
== i
)
1799 prev_frag
->fr_next
= head
->frch_root
;
1800 prev_frag
= head
->frch_last
;
1801 head
= head
->frch_next
;
1803 prev_frag
->fr_next
= 0;
1810 DEFUN_VOID (write_object_file
)
1813 struct frchain
*frchain_ptr
;
1815 object_headers headers
;
1816 unsigned long file_cursor
;
1819 abfd
= bfd_openw (out_file_name
, TARGET_FORMAT
);
1824 as_perror ("FATAL: Can't create %s", out_file_name
);
1827 bfd_set_format (abfd
, bfd_object
);
1828 bfd_set_arch_mach (abfd
, BFD_ARCH
, machine
);
1830 string_byte_count
= 4;
1832 for (frchain_ptr
= frchain_root
;
1833 frchain_ptr
!= (struct frchain
*) NULL
;
1834 frchain_ptr
= frchain_ptr
->frch_next
)
1836 /* Run through all the sub-segments and align them up. Also close any
1837 open frags. We tack a .fill onto the end of the frag chain so
1838 that any .align's size can be worked by looking at the next
1841 subseg_new (frchain_ptr
->frch_seg
, frchain_ptr
->frch_subseg
);
1842 #ifndef SUB_SEGMENT_ALIGN
1843 #define SUB_SEGMENT_ALIGN(SEG) 1
1845 frag_align (SUB_SEGMENT_ALIGN (now_seg
), NOP_OPCODE
);
1846 frag_wane (frag_now
);
1847 frag_now
->fr_fix
= 0;
1848 know (frag_now
->fr_next
== NULL
);
1855 for (i
= SEG_E0
; i
< SEG_UNKNOWN
; i
++)
1857 relax_segment (segment_info
[i
].frchainP
->frch_root
, i
);
1860 H_SET_NUMBER_OF_SECTIONS (&headers
, 0);
1862 /* Find out how big the sections are, and set the addresses. */
1864 for (i
= SEG_E0
; i
< SEG_UNKNOWN
; i
++)
1868 segment_info
[i
].scnhdr
.s_paddr
= addr
;
1869 segment_info
[i
].scnhdr
.s_vaddr
= addr
;
1871 if (segment_info
[i
].scnhdr
.s_name
[0])
1873 H_SET_NUMBER_OF_SECTIONS (&headers
,
1874 H_GET_NUMBER_OF_SECTIONS (&headers
) + 1);
1877 size
= size_section (abfd
, i
);
1881 H_SET_TEXT_SIZE (&headers
, size
);
1882 else if (i
== SEG_E1
)
1883 H_SET_DATA_SIZE (&headers
, size
);
1884 else if (i
== SEG_E2
)
1885 H_SET_BSS_SIZE (&headers
, size
);
1888 /* Turn the gas native symbol table shape into a coff symbol table */
1889 crawl_symbols (&headers
, abfd
);
1891 if (string_byte_count
== 4)
1892 string_byte_count
= 0;
1894 H_SET_STRING_SIZE (&headers
, string_byte_count
);
1896 #if !defined(TC_H8300) && !defined(TC_Z8K)
1897 for (i
= SEG_E0
; i
< SEG_UNKNOWN
; i
++)
1899 fixup_mdeps (segment_info
[i
].frchainP
->frch_root
, &headers
, i
);
1900 fixup_segment (&segment_info
[i
], i
);
1904 file_cursor
= H_GET_TEXT_FILE_OFFSET (&headers
);
1906 bfd_seek (abfd
, file_cursor
, 0);
1908 /* Plant the data */
1910 fill_section (abfd
, &headers
, &file_cursor
);
1912 do_relocs_for (abfd
, &headers
, &file_cursor
);
1914 do_linenos_for (abfd
, &headers
, &file_cursor
);
1916 H_SET_FILE_MAGIC_NUMBER (&headers
, COFF_MAGIC
);
1917 #ifndef OBJ_COFF_OMIT_TIMESTAMP
1918 H_SET_TIME_STAMP (&headers
, (long)time((long*)0));
1920 H_SET_TIME_STAMP (&headers
, 0);
1923 #ifdef KEEP_RELOC_INFO
1924 H_SET_FLAGS (&headers
, ((H_GET_LINENO_SIZE(&headers
) ? 0 : F_LNNO
) |
1925 COFF_FLAGS
| coff_flags
));
1927 H_SET_FLAGS (&headers
, ((H_GET_LINENO_SIZE(&headers
) ? 0 : F_LNNO
) |
1928 (H_GET_RELOCATION_SIZE(&headers
) ? 0 : F_RELFLG
) |
1929 COFF_FLAGS
| coff_flags
));
1933 unsigned int symtable_size
= H_GET_SYMBOL_TABLE_SIZE (&headers
);
1934 char *buffer1
= xmalloc (symtable_size
+ string_byte_count
+ 1);
1935 char *ptr
= buffer1
;
1936 H_SET_SYMBOL_TABLE_POINTER (&headers
, bfd_tell (abfd
));
1937 w_symbols (abfd
, buffer1
, symbol_rootP
);
1938 if (string_byte_count
> 0)
1939 w_strings (buffer1
+ symtable_size
);
1940 bfd_write (buffer1
, 1, symtable_size
+ string_byte_count
, abfd
);
1944 coff_header_append (abfd
, &headers
);
1946 if (bfd_close_all_done (abfd
) == false)
1947 as_fatal ("Can't close %s: %s", out_file_name
,
1948 bfd_errmsg (bfd_error
));
1953 DEFUN (change_to_section
, (name
, len
, exp
),
1955 unsigned int len AND
1959 /* Find out if we've already got a section of this name etc */
1960 for (i
= SEG_E0
; i
< SEG_E9
&& segment_info
[i
].scnhdr
.s_name
[0]; i
++)
1962 if (strncmp (segment_info
[i
].scnhdr
.s_name
, name
, len
) == 0)
1964 subseg_new (i
, exp
);
1969 /* No section, add one */
1970 strncpy (segment_info
[i
].scnhdr
.s_name
, name
, 8);
1971 subseg_new (i
, exp
);
1975 * implement the .section pseudo op:
1976 * .section name {, "flags"}
1978 * | +--- optional flags: 'b' for bss
1980 * +-- section name 'l' for lib
1985 * But if the argument is not a quoted string, treat it as a
1986 * subsegment number.
1990 DEFUN_VOID (obj_coff_section
)
1992 /* Strip out the section name */
1994 char *section_name_end
;
2001 section_name
= input_line_pointer
;
2002 c
= get_symbol_end ();
2003 section_name_end
= input_line_pointer
;
2005 len
= section_name_end
- section_name
;
2006 input_line_pointer
++;
2012 else if (*input_line_pointer
== ',')
2015 ++input_line_pointer
;
2023 if (*input_line_pointer
!= '"')
2024 exp
= get_absolute_expression ();
2027 ++input_line_pointer
;
2028 while (*input_line_pointer
!= '"'
2029 && ! is_end_of_line
[*input_line_pointer
])
2031 switch (*input_line_pointer
)
2033 case 'b': flags
|= STYP_BSS
; break;
2034 case 'i': flags
|= STYP_INFO
; break;
2035 case 'l': flags
|= STYP_LIB
; break;
2036 case 'n': flags
|= STYP_NOLOAD
; break;
2037 case 'o': flags
|= STYP_OVER
; break;
2038 case 'w': flags
|= STYP_DATA
; break;
2039 case 'x': flags
|= STYP_TEXT
; break;
2041 as_warn("unknown section attribute '%c'",
2042 *input_line_pointer
);
2045 ++input_line_pointer
;
2047 if (*input_line_pointer
== '"')
2048 ++input_line_pointer
;
2052 change_to_section (section_name
, len
, exp
);
2054 segment_info
[now_seg
].scnhdr
.s_flags
|= flags
;
2056 *section_name_end
= c
;
2063 change_to_section (".text", 5, get_absolute_expression ());
2070 change_to_section (".data", 5, get_absolute_expression ());
2076 if (*input_line_pointer
== '\n') /* .bss */
2077 change_to_section(".bss",4, get_absolute_expression());
2078 else /* .bss id,expr */
2085 segT current_seg
= now_seg
; /* save current seg */
2086 subsegT current_subseg
= now_subseg
;
2087 change_to_section (".comment", 8, 0); /* .comment seg */
2088 stringer (1); /* read string */
2089 subseg_new (current_seg
, current_subseg
); /* restore current seg */
2093 c_symbol_merge (debug
, normal
)
2097 S_SET_DATA_TYPE (normal
, S_GET_DATA_TYPE (debug
));
2098 S_SET_STORAGE_CLASS (normal
, S_GET_STORAGE_CLASS (debug
));
2100 if (S_GET_NUMBER_AUXILIARY (debug
) > S_GET_NUMBER_AUXILIARY (normal
))
2102 S_SET_NUMBER_AUXILIARY (normal
, S_GET_NUMBER_AUXILIARY (debug
));
2103 } /* take the most we have */
2105 if (S_GET_NUMBER_AUXILIARY (debug
) > 0)
2107 memcpy ((char *) &normal
->sy_symbol
.ost_auxent
[0], (char *) &debug
->sy_symbol
.ost_auxent
[0], S_GET_NUMBER_AUXILIARY (debug
) * AUXESZ
);
2108 } /* Move all the auxiliary information */
2110 /* Move the debug flags. */
2111 SF_SET_DEBUG_FIELD (normal
, SF_GET_DEBUG_FIELD (debug
));
2112 } /* c_symbol_merge() */
2115 DEFUN (c_line_new
, (symbol
, paddr
, line_number
, frag
),
2116 symbolS
* symbol AND
2118 unsigned short line_number AND
2121 struct lineno_list
*new_line
=
2122 (struct lineno_list
*) xmalloc (sizeof (struct lineno_list
));
2124 segment_info_type
*s
= segment_info
+ now_seg
;
2125 new_line
->line
.l_lnno
= line_number
;
2127 if (line_number
== 0)
2129 last_line_symbol
= symbol
;
2130 new_line
->line
.l_addr
.l_symndx
= (long) symbol
;
2134 new_line
->line
.l_addr
.l_paddr
= paddr
;
2137 new_line
->frag
= (char *) frag
;
2138 new_line
->next
= (struct lineno_list
*) NULL
;
2141 if (s
->lineno_list_head
== (struct lineno_list
*) NULL
)
2143 s
->lineno_list_head
= new_line
;
2147 s
->lineno_list_tail
->next
= new_line
;
2149 s
->lineno_list_tail
= new_line
;
2150 return LINESZ
* s
->scnhdr
.s_nlnno
++;
2154 c_dot_file_symbol (filename
)
2159 symbolP
= symbol_new (".file",
2162 &zero_address_frag
);
2164 S_SET_STORAGE_CLASS (symbolP
, C_FILE
);
2165 S_SET_NUMBER_AUXILIARY (symbolP
, 1);
2166 SA_SET_FILE_FNAME (symbolP
, filename
);
2172 listing_source_file (filename
);
2178 SF_SET_DEBUG (symbolP
);
2179 S_SET_VALUE (symbolP
, (long) previous_file_symbol
);
2181 previous_file_symbol
= symbolP
;
2183 /* Make sure that the symbol is first on the symbol chain */
2184 if (symbol_rootP
!= symbolP
)
2186 if (symbolP
== symbol_lastP
)
2188 symbol_lastP
= symbol_lastP
->sy_previous
;
2189 } /* if it was the last thing on the list */
2191 symbol_remove (symbolP
, &symbol_rootP
, &symbol_lastP
);
2192 symbol_insert (symbolP
, symbol_rootP
, &symbol_rootP
, &symbol_lastP
);
2193 symbol_rootP
= symbolP
;
2194 } /* if not first on the list */
2196 } /* c_dot_file_symbol() */
2199 * Build a 'section static' symbol.
2203 c_section_symbol (name
, idx
)
2209 symbolP
= symbol_new (name
, idx
,
2211 &zero_address_frag
);
2213 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
2214 S_SET_NUMBER_AUXILIARY (symbolP
, 1);
2216 SF_SET_STATICS (symbolP
);
2219 } /* c_section_symbol() */
2222 DEFUN (w_symbols
, (abfd
, where
, symbol_rootP
),
2225 symbolS
* symbol_rootP
)
2230 /* First fill in those values we have only just worked out */
2231 for (i
= SEG_E0
; i
< SEG_E9
; i
++)
2233 symbolP
= segment_info
[i
].dot
;
2237 SA_SET_SCN_SCNLEN (symbolP
, segment_info
[i
].scnhdr
.s_size
);
2238 SA_SET_SCN_NRELOC (symbolP
, segment_info
[i
].scnhdr
.s_nreloc
);
2239 SA_SET_SCN_NLINNO (symbolP
, segment_info
[i
].scnhdr
.s_nlnno
);
2245 * Emit all symbols left in the symbol chain.
2247 for (symbolP
= symbol_rootP
; symbolP
; symbolP
= symbol_next (symbolP
))
2249 /* Used to save the offset of the name. It is used to point
2250 to the string in memory but must be a file offset. */
2251 register char *temp
;
2253 tc_coff_symbol_emit_hook (symbolP
);
2255 temp
= S_GET_NAME (symbolP
);
2256 if (SF_GET_STRING (symbolP
))
2258 S_SET_OFFSET (symbolP
, symbolP
->sy_name_offset
);
2259 S_SET_ZEROES (symbolP
, 0);
2263 bzero (symbolP
->sy_symbol
.ost_entry
.n_name
, SYMNMLEN
);
2264 strncpy (symbolP
->sy_symbol
.ost_entry
.n_name
, temp
, SYMNMLEN
);
2266 where
= symbol_to_chars (abfd
, where
, symbolP
);
2267 S_SET_NAME (symbolP
, temp
);
2273 DEFUN_VOID (obj_coff_lcomm
)
2281 name
= input_line_pointer
;
2283 c
= get_symbol_end ();
2284 p
= input_line_pointer
;
2287 if (*input_line_pointer
!= ',')
2289 as_bad ("Expected comma after name");
2290 ignore_rest_of_line ();
2293 if (*input_line_pointer
== '\n')
2295 as_bad ("Missing size expression");
2298 input_line_pointer
++;
2299 if ((temp
= get_absolute_expression ()) < 0)
2301 as_warn ("lcomm length (%d.) <0! Ignored.", temp
);
2302 ignore_rest_of_line ();
2307 symbolP
= symbol_find_or_make(name
);
2309 if (S_GET_SEGMENT(symbolP
) == SEG_UNKNOWN
&&
2310 S_GET_VALUE(symbolP
) == 0)
2315 segT current_seg
= now_seg
; /* save current seg */
2316 subsegT current_subseg
= now_subseg
;
2318 subseg_new (SEG_E2
, 1);
2319 symbolP
->sy_frag
= frag_now
;
2320 p
= frag_var(rs_org
, 1, 1, (relax_substateT
)0, symbolP
,
2323 subseg_new (current_seg
, current_subseg
); /* restore current seg */
2324 S_SET_SEGMENT(symbolP
, SEG_E2
);
2325 S_SET_STORAGE_CLASS(symbolP
, C_STAT
);
2329 as_bad("Symbol %s already defined", name
);
2331 demand_empty_rest_of_line();
2335 DEFUN (fixup_mdeps
, (frags
, h
, this_segment
),
2337 object_headers
* h AND
2340 subseg_change (this_segment
, 0);
2343 switch (frags
->fr_type
)
2347 frags
->fr_type
= rs_fill
;
2349 (frags
->fr_next
->fr_address
- frags
->fr_address
- frags
->fr_fix
);
2351 case rs_machine_dependent
:
2352 md_convert_frag (h
, frags
);
2358 frags
= frags
->fr_next
;
2364 DEFUN (fixup_segment
, (segP
, this_segment_type
),
2365 segment_info_type
* segP AND
2366 segT this_segment_type
)
2368 register fixS
* fixP
;
2369 register symbolS
*add_symbolP
;
2370 register symbolS
*sub_symbolP
;
2371 register long add_number
;
2373 register char *place
;
2374 register long where
;
2375 register char pcrel
;
2376 register fragS
*fragP
;
2377 register segT add_symbol_segment
= SEG_ABSOLUTE
;
2380 for (fixP
= segP
->fix_root
; fixP
; fixP
= fixP
->fx_next
)
2382 fragP
= fixP
->fx_frag
;
2384 where
= fixP
->fx_where
;
2385 place
= fragP
->fr_literal
+ where
;
2386 size
= fixP
->fx_size
;
2387 add_symbolP
= fixP
->fx_addsy
;
2389 if (fixP
->fx_callj
&& TC_S_IS_CALLNAME (add_symbolP
))
2391 /* Relocation should be done via the
2392 associated 'bal' entry point
2395 if (!TC_S_IS_BALNAME (tc_get_bal_of_call (add_symbolP
)))
2397 as_bad ("No 'bal' entry point for leafproc %s",
2398 S_GET_NAME (add_symbolP
));
2401 fixP
->fx_addsy
= add_symbolP
= tc_get_bal_of_call (add_symbolP
);
2402 } /* callj relocation */
2404 sub_symbolP
= fixP
->fx_subsy
;
2405 add_number
= fixP
->fx_offset
;
2406 pcrel
= fixP
->fx_pcrel
;
2410 add_symbol_segment
= S_GET_SEGMENT (add_symbolP
);
2411 } /* if there is an addend */
2418 if (S_GET_SEGMENT (sub_symbolP
) != SEG_ABSOLUTE
)
2420 as_bad ("Negative of non-absolute symbol %s", S_GET_NAME (sub_symbolP
));
2421 } /* not absolute */
2423 add_number
-= S_GET_VALUE (sub_symbolP
);
2426 /* if sub_symbol is in the same segment that add_symbol
2427 and add_symbol is either in DATA, TEXT, BSS or ABSOLUTE */
2429 else if ((S_GET_SEGMENT (sub_symbolP
) == add_symbol_segment
)
2430 && (SEG_NORMAL (add_symbol_segment
)
2431 || (add_symbol_segment
== SEG_ABSOLUTE
)))
2433 /* Difference of 2 symbols from same segment. */
2434 /* Can't make difference of 2 undefineds: 'value' means */
2435 /* something different for N_UNDF. */
2437 /* Makes no sense to use the difference of 2 arbitrary symbols
2438 as the target of a call instruction. */
2441 as_bad ("callj to difference of 2 symbols");
2443 #endif /* TC_I960 */
2444 add_number
+= S_GET_VALUE (add_symbolP
) -
2445 S_GET_VALUE (sub_symbolP
);
2448 fixP
->fx_addsy
= NULL
;
2452 /* Different segments in subtraction. */
2453 know (!(S_IS_EXTERNAL (sub_symbolP
) && (S_GET_SEGMENT (sub_symbolP
) == SEG_ABSOLUTE
)));
2455 if ((S_GET_SEGMENT (sub_symbolP
) == SEG_ABSOLUTE
))
2457 add_number
-= S_GET_VALUE (sub_symbolP
);
2461 as_bad ("Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %d.",
2462 segment_name (S_GET_SEGMENT (sub_symbolP
)),
2463 S_GET_NAME (sub_symbolP
), fragP
->fr_address
+ where
);
2466 } /* if sub_symbolP */
2470 if (add_symbol_segment
== this_segment_type
&& pcrel
)
2473 * This fixup was made when the symbol's segment was
2474 * SEG_UNKNOWN, but it is now in the local segment.
2475 * So we know how to do the address without relocation.
2478 /* reloc_callj() may replace a 'call' with a 'calls' or a 'bal',
2479 * in which cases it modifies *fixP as appropriate. In the case
2480 * of a 'calls', no further work is required, and *fixP has been
2481 * set up to make the rest of the code below a no-op.
2484 #endif /* TC_I960 */
2486 add_number
+= S_GET_VALUE (add_symbolP
);
2487 add_number
-= md_pcrel_from (fixP
);
2489 /* On the 386 we must adjust by the segment
2490 vaddr as well. Ian Taylor. */
2491 add_number
-= segP
->scnhdr
.s_vaddr
;
2493 pcrel
= 0; /* Lie. Don't want further pcrel processing. */
2494 fixP
->fx_addsy
= NULL
; /* No relocations please. */
2498 switch (add_symbol_segment
)
2502 reloc_callj (fixP
); /* See comment about reloc_callj() above*/
2503 #endif /* TC_I960 */
2504 add_number
+= S_GET_VALUE (add_symbolP
);
2505 fixP
->fx_addsy
= NULL
;
2511 /* This really should be handled in the linker, but
2512 backward compatibility forbids. */
2513 add_number
+= S_GET_VALUE (add_symbolP
);
2515 add_number
+= S_GET_VALUE (add_symbolP
) +
2516 segment_info
[S_GET_SEGMENT (add_symbolP
)].scnhdr
.s_paddr
;
2522 if ((int) fixP
->fx_bit_fixP
== 13)
2524 /* This is a COBR instruction. They have only a
2525 * 13-bit displacement and are only to be used
2526 * for local branches: flag as error, don't generate
2529 as_bad ("can't use COBR format with external label");
2530 fixP
->fx_addsy
= NULL
; /* No relocations please. */
2533 #endif /* TC_I960 */
2535 /* 386 COFF uses a peculiar format in
2536 which the value of a common symbol is
2537 stored in the .text segment (I've
2538 checked this on SVR3.2 and SCO 3.2.2)
2539 Ian Taylor <ian@cygnus.com>. */
2540 if (S_IS_COMMON (add_symbolP
))
2541 add_number
+= S_GET_VALUE (add_symbolP
);
2546 } /* switch on symbol seg */
2547 } /* if not in local seg */
2548 } /* if there was a + symbol */
2552 add_number
-= md_pcrel_from (fixP
);
2553 if (add_symbolP
== 0)
2555 fixP
->fx_addsy
= &abs_symbol
;
2556 } /* if there's an add_symbol */
2558 /* On the 386 we must adjust by the segment vaddr
2559 as well. Ian Taylor. */
2560 add_number
-= segP
->scnhdr
.s_vaddr
;
2564 if (!fixP
->fx_bit_fixP
)
2567 (add_number
& ~0xFF) && ((add_number
& ~0xFF) != (-1 & ~0xFF))) ||
2569 (add_number
& ~0xFFFF) && ((add_number
& ~0xFFFF) != (-1 & ~0xFFFF))))
2571 as_bad ("Value of %d too large for field of %d bytes at 0x%x",
2572 add_number
, size
, fragP
->fr_address
+ where
);
2573 } /* generic error checking */
2574 #ifdef WARN_SIGNED_OVERFLOW_WORD
2575 /* Warn if a .word value is too large when treated as
2576 a signed number. We already know it is not too
2577 negative. This is to catch over-large switches
2578 generated by gcc on the 68k. */
2581 && add_number
> 0x7fff)
2582 as_bad ("Signed .word overflow; switch may be too large; %d at 0x%x",
2583 add_number
, fragP
->fr_address
+ where
);
2585 } /* not a bit fix */
2586 /* once this fix has been applied, we don't have to output anything
2587 nothing more need be done -*/
2588 md_apply_fix (fixP
, add_number
);
2589 } /* For each fixS in this segment. */
2590 } /* fixup_segment() */