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/300 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])
360 struct external_reloc
*ext_ptr
;
361 struct external_reloc
*external_reloc_vec
;
362 unsigned int external_reloc_size
;
363 unsigned int count
= 0;
364 unsigned int base
= segment_info
[idx
].scnhdr
.s_paddr
;
365 fixS
*fix_ptr
= segment_info
[idx
].fix_root
;
366 nrelocs
= count_entries_in_chain (idx
);
368 external_reloc_size
= nrelocs
* RELSZ
;
370 (struct external_reloc
*) malloc (external_reloc_size
);
372 ext_ptr
= external_reloc_vec
;
374 /* Fill in the internal coff style reloc struct from the
379 struct internal_reloc intr
;
381 /* Only output some of the relocations */
382 if (TC_COUNT_RELOC (fix_ptr
))
384 #ifdef TC_RELOC_MANGLE
385 TC_RELOC_MANGLE (fix_ptr
, &intr
, base
);
389 symbol_ptr
= fix_ptr
->fx_addsy
;
391 intr
.r_type
= TC_COFF_FIX2RTYPE (fix_ptr
);
393 base
+ fix_ptr
->fx_frag
->fr_address
+ fix_ptr
->fx_where
;
395 intr
.r_offset
= fix_ptr
->fx_offset
;
399 /* Turn the segment of the symbol into an offset
403 dot
= segment_info
[S_GET_SEGMENT (symbol_ptr
)].dot
;
406 intr
.r_symndx
= dot
->sy_number
;
410 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
;
438 /* The offset to the segment holding the symbol
439 has already been counted in the R_IHIHALF.
440 We don't want to add it in again for the
444 segment_info
[S_GET_SEGMENT (symbol_ptr
)].scnhdr
.s_paddr
;
445 (void) bfd_coff_swap_reloc_out (abfd
, &intr
, ext_ptr
);
451 fix_ptr
= fix_ptr
->fx_next
;
454 /* Write out the reloc table */
455 segment_info
[idx
].scnhdr
.s_relptr
= nrelocs
? *file_cursor
: 0;
456 segment_info
[idx
].scnhdr
.s_nreloc
= nrelocs
;
457 bfd_write ((PTR
) external_reloc_vec
, 1, external_reloc_size
, abfd
);
458 *file_cursor
+= external_reloc_size
;
459 free (external_reloc_vec
);
462 /* Set relocation_size field in file headers */
463 H_SET_RELOCATION_SIZE (h
, *file_cursor
- reloc_start
, 0);
467 /* run through a frag chain and write out the data to go with it, fill
468 in the scnhdrs with the info on the file postions
471 DEFUN (fill_section
, (abfd
, h
, file_cursor
),
473 object_headers
*h AND
474 unsigned long *file_cursor
)
478 unsigned int paddr
= 0;
480 for (i
= SEG_E0
; i
< SEG_UNKNOWN
; i
++)
482 unsigned int offset
= 0;
484 struct internal_scnhdr
*s
= &(segment_info
[i
].scnhdr
);
488 fragS
*frag
= segment_info
[i
].frchainP
->frch_root
;
495 buffer
= xmalloc (s
->s_size
);
496 s
->s_scnptr
= *file_cursor
;
498 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
;
511 /* Apparently the SVR3 linker is confused by noload
513 s
->s_flags
|= STYP_NOLOAD
;
516 else if (strcmp (s
->s_name
, ".lit") == 0)
517 s
->s_flags
= STYP_LIT
| STYP_TEXT
;
518 else if (strcmp (s
->s_name
, ".init") == 0)
519 s
->s_flags
|= STYP_TEXT
;
520 else if (strcmp (s
->s_name
, ".fini") == 0)
521 s
->s_flags
|= STYP_TEXT
;
522 else if (strncmp (s
->s_name
, ".comment", 8) == 0)
523 s
->s_flags
|= STYP_INFO
;
527 unsigned int fill_size
;
528 switch (frag
->fr_type
)
530 case rs_machine_dependent
:
533 memcpy (buffer
+ frag
->fr_address
,
536 offset
+= frag
->fr_fix
;
545 memcpy (buffer
+ frag
->fr_address
,
548 offset
+= frag
->fr_fix
;
551 fill_size
= frag
->fr_var
;
555 unsigned int off
= frag
->fr_fix
;
556 for (count
= frag
->fr_offset
; count
; count
--)
558 if (fill_size
< s
->s_size
)
560 memcpy (buffer
+ frag
->fr_address
+ off
,
561 frag
->fr_literal
+ frag
->fr_fix
,
574 frag
= frag
->fr_next
;
579 if (s
->s_scnptr
!= 0)
581 bfd_write (buffer
, s
->s_size
, 1, abfd
);
582 *file_cursor
+= s
->s_size
;
591 /* Coff file generation & utilities */
594 DEFUN (coff_header_append
, (abfd
, h
),
602 bfd_seek (abfd
, 0, 0);
604 #ifndef OBJ_COFF_OMIT_OPTIONAL_HEADER
605 H_SET_MAGIC_NUMBER (h
, COFF_MAGIC
);
606 H_SET_VERSION_STAMP (h
, 0);
607 H_SET_ENTRY_POINT (h
, 0);
608 H_SET_TEXT_START (h
, segment_info
[SEG_E0
].frchainP
->frch_root
->fr_address
);
609 H_SET_DATA_START (h
, segment_info
[SEG_E1
].frchainP
->frch_root
->fr_address
);
610 H_SET_SIZEOF_OPTIONAL_HEADER (h
, bfd_coff_swap_aouthdr_out(abfd
, &h
->aouthdr
,
612 #else /* defined (OBJ_COFF_OMIT_OPTIONAL_HEADER) */
613 H_SET_SIZEOF_OPTIONAL_HEADER (h
, 0);
614 #endif /* defined (OBJ_COFF_OMIT_OPTIONAL_HEADER) */
616 i
= bfd_coff_swap_filehdr_out (abfd
, &h
->filehdr
, buffer
);
618 bfd_write (buffer
, i
, 1, abfd
);
619 bfd_write (buffero
, H_GET_SIZEOF_OPTIONAL_HEADER (h
), 1, abfd
);
621 for (i
= SEG_E0
; i
< SEG_E9
; i
++)
623 if (segment_info
[i
].scnhdr
.s_name
[0])
626 bfd_coff_swap_scnhdr_out (abfd
,
627 &(segment_info
[i
].scnhdr
),
629 bfd_write (buffer
, size
, 1, abfd
);
636 DEFUN (symbol_to_chars
, (abfd
, where
, symbolP
),
641 unsigned int numaux
= symbolP
->sy_symbol
.ost_entry
.n_numaux
;
644 /* Turn any symbols with register attributes into abs symbols */
645 if (S_GET_SEGMENT (symbolP
) == SEG_REGISTER
)
647 S_SET_SEGMENT (symbolP
, SEG_ABSOLUTE
);
649 /* At the same time, relocate all symbols to their output value */
651 S_SET_VALUE (symbolP
,
652 segment_info
[S_GET_SEGMENT (symbolP
)].scnhdr
.s_paddr
653 + S_GET_VALUE (symbolP
));
655 where
+= bfd_coff_swap_sym_out (abfd
, &symbolP
->sy_symbol
.ost_entry
,
658 for (i
= 0; i
< numaux
; i
++)
660 where
+= bfd_coff_swap_aux_out (abfd
,
661 &symbolP
->sy_symbol
.ost_auxent
[i
],
662 S_GET_DATA_TYPE (symbolP
),
663 S_GET_STORAGE_CLASS (symbolP
),
674 obj_symbol_new_hook (symbolP
)
677 char underscore
= 0; /* Symbol has leading _ */
679 /* Effective symbol */
680 /* Store the pointer in the offset. */
681 S_SET_ZEROES (symbolP
, 0L);
682 S_SET_DATA_TYPE (symbolP
, T_NULL
);
683 S_SET_STORAGE_CLASS (symbolP
, 0);
684 S_SET_NUMBER_AUXILIARY (symbolP
, 0);
685 /* Additional information */
686 symbolP
->sy_symbol
.ost_flags
= 0;
687 /* Auxiliary entries */
688 bzero ((char *) &symbolP
->sy_symbol
.ost_auxent
[0], AUXESZ
);
690 #ifdef STRIP_UNDERSCORE
691 /* Remove leading underscore at the beginning of the symbol.
692 * This is to be compatible with the standard librairies.
694 if (*S_GET_NAME (symbolP
) == '_')
697 S_SET_NAME (symbolP
, S_GET_NAME (symbolP
) + 1);
698 } /* strip underscore */
699 #endif /* STRIP_UNDERSCORE */
701 if (S_IS_STRING (symbolP
))
702 SF_SET_STRING (symbolP
);
703 if (!underscore
&& S_IS_LOCAL (symbolP
))
704 SF_SET_LOCAL (symbolP
);
707 } /* obj_symbol_new_hook() */
711 stack_init (chunk_size
, element_size
)
712 unsigned long chunk_size
;
713 unsigned long element_size
;
717 if ((st
= (stack
*) malloc (sizeof (stack
))) == (stack
*) 0)
719 if ((st
->data
= malloc (chunk_size
)) == (char *) 0)
725 st
->size
= chunk_size
;
726 st
->chunk_size
= chunk_size
;
727 st
->element_size
= element_size
;
740 stack_push (st
, element
)
744 if (st
->pointer
+ st
->element_size
>= st
->size
)
746 st
->size
+= st
->chunk_size
;
747 if ((st
->data
= xrealloc (st
->data
, st
->size
)) == (char *) 0)
750 memcpy (st
->data
+ st
->pointer
, element
, st
->element_size
);
751 st
->pointer
+= st
->element_size
;
752 return st
->data
+ st
->pointer
;
759 if ((st
->pointer
-= st
->element_size
) < 0)
765 return st
->data
+ st
->pointer
;
772 return st
->data
+ st
->pointer
- st
->element_size
;
777 * Handle .ln directives.
785 if (def_symbol_in_progress
!= NULL
)
787 as_warn (".ln pseudo-op inside .def/.endef: ignored.");
788 demand_empty_rest_of_line ();
790 } /* wrong context */
793 obstack_next_free (&frags
) - frag_now
->fr_literal
,
794 l
= get_absolute_expression (),
802 listing_source_line (l
+ line_base
- 1);
807 demand_empty_rest_of_line ();
809 } /* obj_coff_line() */
814 * Handle .def directives.
816 * One might ask : why can't we symbol_new if the symbol does not
817 * already exist and fill it with debug information. Because of
818 * the C_EFCN special symbol. It would clobber the value of the
819 * function symbol before we have a chance to notice that it is
820 * a C_EFCN. And a second reason is that the code is more clear this
821 * way. (at least I think it is :-).
825 #define SKIP_SEMI_COLON() while (*input_line_pointer++ != ';')
826 #define SKIP_WHITESPACES() while (*input_line_pointer == ' ' || \
827 *input_line_pointer == '\t') \
828 input_line_pointer++;
831 DEFUN (obj_coff_def
, (what
),
834 char name_end
; /* Char after the end of name */
835 char *symbol_name
; /* Name of the debug symbol */
836 char *symbol_name_copy
; /* Temporary copy of the name */
837 unsigned int symbol_name_length
;
838 /*$char* directiveP;$ *//* Name of the pseudo opcode */
839 /*$char directive[MAX_DIRECTIVE];$ *//* Backup of the directive */
840 /*$char end = 0;$ *//* If 1, stop parsing */
842 if (def_symbol_in_progress
!= NULL
)
844 as_warn (".def pseudo-op used inside of .def/.endef: ignored.");
845 demand_empty_rest_of_line ();
847 } /* if not inside .def/.endef */
851 def_symbol_in_progress
= (symbolS
*) obstack_alloc (¬es
, sizeof (*def_symbol_in_progress
));
852 bzero (def_symbol_in_progress
, sizeof (*def_symbol_in_progress
));
854 symbol_name
= input_line_pointer
;
855 name_end
= get_symbol_end ();
856 symbol_name_length
= strlen (symbol_name
);
857 symbol_name_copy
= xmalloc (symbol_name_length
+ 1);
858 strcpy (symbol_name_copy
, symbol_name
);
860 /* Initialize the new symbol */
861 #ifdef STRIP_UNDERSCORE
862 S_SET_NAME (def_symbol_in_progress
, (*symbol_name_copy
== '_'
863 ? symbol_name_copy
+ 1
864 : symbol_name_copy
));
865 #else /* STRIP_UNDERSCORE */
866 S_SET_NAME (def_symbol_in_progress
, symbol_name_copy
);
867 #endif /* STRIP_UNDERSCORE */
868 /* free(symbol_name_copy); */
869 def_symbol_in_progress
->sy_name_offset
= ~0;
870 def_symbol_in_progress
->sy_number
= ~0;
871 def_symbol_in_progress
->sy_frag
= &zero_address_frag
;
873 if (S_IS_STRING (def_symbol_in_progress
))
875 SF_SET_STRING (def_symbol_in_progress
);
878 *input_line_pointer
= name_end
;
880 demand_empty_rest_of_line ();
882 } /* obj_coff_def() */
884 unsigned int dim_index
;
886 DEFUN_VOID (obj_coff_endef
)
888 symbolS
*symbolP
= 0;
889 /* DIM BUG FIX sac@cygnus.com */
891 if (def_symbol_in_progress
== NULL
)
893 as_warn (".endef pseudo-op used outside of .def/.endef: ignored.");
894 demand_empty_rest_of_line ();
896 } /* if not inside .def/.endef */
898 /* Set the section number according to storage class. */
899 switch (S_GET_STORAGE_CLASS (def_symbol_in_progress
))
904 SF_SET_TAG (def_symbol_in_progress
);
905 /* intentional fallthrough */
908 SF_SET_DEBUG (def_symbol_in_progress
);
909 S_SET_SEGMENT (def_symbol_in_progress
, SEG_DEBUG
);
913 SF_SET_LOCAL (def_symbol_in_progress
); /* Do not emit this symbol. */
914 /* intentional fallthrough */
916 SF_SET_PROCESS (def_symbol_in_progress
); /* Will need processing before writing */
917 /* intentional fallthrough */
919 S_SET_SEGMENT (def_symbol_in_progress
, SEG_E0
);
921 if (strcmp (def_symbol_in_progress
->sy_symbol
.ost_entry
._n
._n_nptr
,
924 if (function_lineoff
< 0)
926 fprintf (stderr
, "`.bf' symbol without preceding function\n");
927 } /* missing function symbol */
928 SA_GET_SYM_LNNOPTR (last_line_symbol
) = function_lineoff
;
930 SF_SET_PROCESS (last_line_symbol
);
931 function_lineoff
= -1;
937 #endif /* C_AUTOARG */
947 SF_SET_DEBUG (def_symbol_in_progress
);
948 S_SET_SEGMENT (def_symbol_in_progress
, SEG_ABSOLUTE
);
954 /* Valid but set somewhere else (s_comm, s_lcomm, colon) */
960 as_warn ("unexpected storage class %d", S_GET_STORAGE_CLASS (def_symbol_in_progress
));
962 } /* switch on storage class */
964 /* Now that we have built a debug symbol, try to find if
965 we should merge with an existing symbol or not. If a
966 symbol is C_EFCN or SEG_ABSOLUTE or untagged
967 SEG_DEBUG it never merges. We also don't merge
968 labels, which are in a different namespace, nor
969 symbols which have not yet been defined since they
970 are typically unique, nor do we merge tags with
973 /* Two cases for functions. Either debug followed
974 by definition or definition followed by debug.
975 For definition first, we will merge the debug
976 symbol into the definition. For debug first, the
977 lineno entry MUST point to the definition
978 function or else it will point off into space
979 when crawl_symbols() merges the debug
980 symbol into the real symbol. Therefor, let's
981 presume the debug symbol is a real function
984 /* FIXME-SOON If for some reason the definition
985 label/symbol is never seen, this will probably
986 leave an undefined symbol at link time. */
988 if (S_GET_STORAGE_CLASS (def_symbol_in_progress
) == C_EFCN
989 || S_GET_STORAGE_CLASS (def_symbol_in_progress
) == C_LABEL
990 || (S_GET_SEGMENT (def_symbol_in_progress
) == SEG_DEBUG
991 && !SF_GET_TAG (def_symbol_in_progress
))
992 || S_GET_SEGMENT (def_symbol_in_progress
) == SEG_ABSOLUTE
993 || def_symbol_in_progress
->sy_forward
!= NULL
994 || (symbolP
= symbol_find_base (S_GET_NAME (def_symbol_in_progress
), DO_NOT_STRIP
)) == NULL
995 || (SF_GET_TAG (def_symbol_in_progress
) != SF_GET_TAG (symbolP
)))
998 symbol_append (def_symbol_in_progress
, symbol_lastP
, &symbol_rootP
, &symbol_lastP
);
1003 /* This symbol already exists, merge the
1004 newly created symbol into the old one.
1005 This is not mandatory. The linker can
1006 handle duplicate symbols correctly. But I
1007 guess that it save a *lot* of space if
1008 the assembly file defines a lot of
1011 /* The debug entry (def_symbol_in_progress)
1012 is merged into the previous definition. */
1014 c_symbol_merge (def_symbol_in_progress
, symbolP
);
1015 /* FIXME-SOON Should *def_symbol_in_progress be free'd? xoxorich. */
1016 def_symbol_in_progress
= symbolP
;
1018 if (SF_GET_FUNCTION (def_symbol_in_progress
)
1019 || SF_GET_TAG (def_symbol_in_progress
))
1021 /* For functions, and tags, the symbol *must* be where the debug symbol
1022 appears. Move the existing symbol to the current place. */
1023 /* If it already is at the end of the symbol list, do nothing */
1024 if (def_symbol_in_progress
!= symbol_lastP
)
1026 symbol_remove (def_symbol_in_progress
, &symbol_rootP
, &symbol_lastP
);
1027 symbol_append (def_symbol_in_progress
, symbol_lastP
, &symbol_rootP
, &symbol_lastP
);
1028 } /* if not already in place */
1030 } /* normal or mergable */
1032 if (SF_GET_TAG (def_symbol_in_progress
)
1033 && symbol_find_base (S_GET_NAME (def_symbol_in_progress
), DO_NOT_STRIP
) == NULL
)
1035 tag_insert (S_GET_NAME (def_symbol_in_progress
), def_symbol_in_progress
);
1036 } /* If symbol is a {structure,union} tag, associate symbol to its name. */
1038 if (SF_GET_FUNCTION (def_symbol_in_progress
))
1040 know (sizeof (def_symbol_in_progress
) <= sizeof (long));
1042 = c_line_new (def_symbol_in_progress
, 0, 0, &zero_address_frag
);
1046 SF_SET_PROCESS (def_symbol_in_progress
);
1048 if (symbolP
== NULL
)
1050 /* That is, if this is the first
1051 time we've seen the function... */
1052 symbol_table_insert (def_symbol_in_progress
);
1053 } /* definition follows debug */
1054 } /* Create the line number entry pointing to the function being defined */
1056 def_symbol_in_progress
= NULL
;
1057 demand_empty_rest_of_line ();
1059 } /* obj_coff_endef() */
1062 DEFUN_VOID (obj_coff_dim
)
1064 register int dim_index
;
1066 if (def_symbol_in_progress
== NULL
)
1068 as_warn (".dim pseudo-op used outside of .def/.endef: ignored.");
1069 demand_empty_rest_of_line ();
1071 } /* if not inside .def/.endef */
1073 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
1075 for (dim_index
= 0; dim_index
< DIMNUM
; dim_index
++)
1077 SKIP_WHITESPACES ();
1078 SA_SET_SYM_DIMEN (def_symbol_in_progress
, dim_index
, get_absolute_expression ());
1080 switch (*input_line_pointer
)
1084 input_line_pointer
++;
1088 as_warn ("badly formed .dim directive ignored");
1089 /* intentional fallthrough */
1094 } /* switch on following character */
1095 } /* for each dimension */
1097 demand_empty_rest_of_line ();
1099 } /* obj_coff_dim() */
1106 if (def_symbol_in_progress
== NULL
)
1110 } /* if it looks like a stabs style line */
1112 this_base
= get_absolute_expression ();
1113 if (this_base
> line_base
)
1115 line_base
= this_base
;
1124 listing_source_line (line_base
);
1128 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
1129 SA_SET_SYM_LNNO (def_symbol_in_progress
, line_base
);
1131 demand_empty_rest_of_line ();
1133 } /* obj_coff_line() */
1138 if (def_symbol_in_progress
== NULL
)
1140 as_warn (".size pseudo-op used outside of .def/.endef ignored.");
1141 demand_empty_rest_of_line ();
1143 } /* if not inside .def/.endef */
1145 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
1146 SA_SET_SYM_SIZE (def_symbol_in_progress
, get_absolute_expression ());
1147 demand_empty_rest_of_line ();
1149 } /* obj_coff_size() */
1154 if (def_symbol_in_progress
== NULL
)
1156 as_warn (".scl pseudo-op used outside of .def/.endef ignored.");
1157 demand_empty_rest_of_line ();
1159 } /* if not inside .def/.endef */
1161 S_SET_STORAGE_CLASS (def_symbol_in_progress
, get_absolute_expression ());
1162 demand_empty_rest_of_line ();
1164 } /* obj_coff_scl() */
1172 if (def_symbol_in_progress
== NULL
)
1174 as_warn (".tag pseudo-op used outside of .def/.endef ignored.");
1175 demand_empty_rest_of_line ();
1177 } /* if not inside .def/.endef */
1179 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress
, 1);
1180 symbol_name
= input_line_pointer
;
1181 name_end
= get_symbol_end ();
1183 /* Assume that the symbol referred to by .tag is always defined. */
1184 /* This was a bad assumption. I've added find_or_make. xoxorich. */
1185 SA_SET_SYM_TAGNDX (def_symbol_in_progress
, (long) tag_find_or_make (symbol_name
));
1186 if (SA_GET_SYM_TAGNDX (def_symbol_in_progress
) == 0L)
1188 as_warn ("tag not found for .tag %s", symbol_name
);
1191 SF_SET_TAGGED (def_symbol_in_progress
);
1192 *input_line_pointer
= name_end
;
1194 demand_empty_rest_of_line ();
1196 } /* obj_coff_tag() */
1201 if (def_symbol_in_progress
== NULL
)
1203 as_warn (".type pseudo-op used outside of .def/.endef ignored.");
1204 demand_empty_rest_of_line ();
1206 } /* if not inside .def/.endef */
1208 S_SET_DATA_TYPE (def_symbol_in_progress
, get_absolute_expression ());
1210 if (ISFCN (S_GET_DATA_TYPE (def_symbol_in_progress
)) &&
1211 S_GET_STORAGE_CLASS (def_symbol_in_progress
) != C_TPDEF
)
1213 SF_SET_FUNCTION (def_symbol_in_progress
);
1214 } /* is a function */
1216 demand_empty_rest_of_line ();
1218 } /* obj_coff_type() */
1223 if (def_symbol_in_progress
== NULL
)
1225 as_warn (".val pseudo-op used outside of .def/.endef ignored.");
1226 demand_empty_rest_of_line ();
1228 } /* if not inside .def/.endef */
1230 if (is_name_beginner (*input_line_pointer
))
1232 char *symbol_name
= input_line_pointer
;
1233 char name_end
= get_symbol_end ();
1235 if (!strcmp (symbol_name
, "."))
1237 def_symbol_in_progress
->sy_frag
= frag_now
;
1238 S_SET_VALUE (def_symbol_in_progress
, obstack_next_free (&frags
) - frag_now
->fr_literal
);
1239 /* If the .val is != from the .def (e.g. statics) */
1241 else if (strcmp (S_GET_NAME (def_symbol_in_progress
), symbol_name
))
1243 def_symbol_in_progress
->sy_forward
= symbol_find_or_make (symbol_name
);
1245 /* If the segment is undefined when the forward
1246 reference is solved, then copy the segment id
1247 from the forward symbol. */
1248 SF_SET_GET_SEGMENT (def_symbol_in_progress
);
1250 /* FIXME: gcc can generate address expressions
1251 here in unusual cases (search for "obscure"
1252 in sdbout.c). We just ignore the offset
1253 here, thus generating incorrect debugging
1254 information. We ignore the rest of the
1257 /* Otherwise, it is the name of a non debug symbol and
1258 its value will be calculated later. */
1259 *input_line_pointer
= name_end
;
1261 /* FIXME: this is to avoid an error message in the
1262 FIXME case mentioned just above. */
1263 while (! is_end_of_line
[*input_line_pointer
])
1264 ++input_line_pointer
;
1268 S_SET_VALUE (def_symbol_in_progress
, get_absolute_expression ());
1269 } /* if symbol based */
1271 demand_empty_rest_of_line ();
1273 } /* obj_coff_val() */
1276 * Maintain a list of the tagnames of the structres.
1282 tag_hash
= hash_new ();
1287 tag_insert (name
, symbolP
)
1291 register char *error_string
;
1293 if (*(error_string
= hash_jam (tag_hash
, name
, (char *) symbolP
)))
1295 as_fatal ("Inserting \"%s\" into structure table failed: %s",
1296 name
, error_string
);
1299 } /* tag_insert() */
1302 tag_find_or_make (name
)
1307 if ((symbolP
= tag_find (name
)) == NULL
)
1309 symbolP
= symbol_new (name
,
1312 &zero_address_frag
);
1314 tag_insert (S_GET_NAME (symbolP
), symbolP
);
1318 } /* tag_find_or_make() */
1324 #ifdef STRIP_UNDERSCORE
1327 #endif /* STRIP_UNDERSCORE */
1328 return ((symbolS
*) hash_find (tag_hash
, name
));
1332 obj_read_begin_hook ()
1334 /* These had better be the same. Usually 18 bytes. */
1336 know (sizeof (SYMENT
) == sizeof (AUXENT
));
1337 know (SYMESZ
== AUXESZ
);
1342 } /* obj_read_begin_hook() */
1344 /* This function runs through the symbol table and puts all the
1345 externals onto another chain */
1347 /* The chain of externals */
1348 symbolS
*symbol_externP
= NULL
;
1349 symbolS
*symbol_extern_lastP
= NULL
;
1352 symbolS
*last_functionP
= NULL
;
1357 DEFUN_VOID (yank_symbols
)
1360 unsigned int symbol_number
= 0;
1362 for (symbolP
= symbol_rootP
;
1364 symbolP
= symbolP
? symbol_next (symbolP
) : symbol_rootP
)
1366 if (!SF_GET_DEBUG (symbolP
))
1368 /* Debug symbols do not need all this rubbish */
1369 symbolS
*real_symbolP
;
1371 /* L* and C_EFCN symbols never merge. */
1372 if (!SF_GET_LOCAL (symbolP
)
1373 && S_GET_STORAGE_CLASS (symbolP
) != C_LABEL
1374 && (real_symbolP
= symbol_find_base (S_GET_NAME (symbolP
), DO_NOT_STRIP
))
1375 && real_symbolP
!= symbolP
)
1377 /* FIXME-SOON: where do dups come from?
1378 Maybe tag references before definitions? xoxorich. */
1379 /* Move the debug data from the debug symbol to the
1380 real symbol. Do NOT do the oposite (i.e. move from
1381 real symbol to debug symbol and remove real symbol from the
1382 list.) Because some pointers refer to the real symbol
1383 whereas no pointers refer to the debug symbol. */
1384 c_symbol_merge (symbolP
, real_symbolP
);
1385 /* Replace the current symbol by the real one */
1386 /* The symbols will never be the last or the first
1387 because : 1st symbol is .file and 3 last symbols are
1388 .text, .data, .bss */
1389 symbol_remove (real_symbolP
, &symbol_rootP
, &symbol_lastP
);
1390 symbol_insert (real_symbolP
, symbolP
, &symbol_rootP
, &symbol_lastP
);
1391 symbol_remove (symbolP
, &symbol_rootP
, &symbol_lastP
);
1392 symbolP
= real_symbolP
;
1393 } /* if not local but dup'd */
1395 if (flagseen
['R'] && (S_GET_SEGMENT (symbolP
) == SEG_E1
))
1397 S_SET_SEGMENT (symbolP
, SEG_E0
);
1398 } /* push data into text */
1400 S_SET_VALUE (symbolP
,
1401 S_GET_VALUE (symbolP
) + symbolP
->sy_frag
->fr_address
);
1403 if (!S_IS_DEFINED (symbolP
) && !SF_GET_LOCAL (symbolP
))
1405 S_SET_EXTERNAL (symbolP
);
1407 else if (S_GET_STORAGE_CLASS (symbolP
) == C_NULL
)
1409 if (S_GET_SEGMENT (symbolP
) == SEG_E0
)
1411 S_SET_STORAGE_CLASS (symbolP
, C_LABEL
);
1415 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
1419 /* Mainly to speed up if not -g */
1420 if (SF_GET_PROCESS (symbolP
))
1422 /* Handle the nested blocks auxiliary info. */
1423 if (S_GET_STORAGE_CLASS (symbolP
) == C_BLOCK
)
1425 if (!strcmp (S_GET_NAME (symbolP
), ".bb"))
1426 stack_push (block_stack
, (char *) &symbolP
);
1429 register symbolS
*begin_symbolP
;
1430 begin_symbolP
= *(symbolS
**) stack_pop (block_stack
);
1431 if (begin_symbolP
== (symbolS
*) 0)
1432 as_warn ("mismatched .eb");
1434 SA_SET_SYM_ENDNDX (begin_symbolP
, symbol_number
+ 2);
1437 /* If we are able to identify the type of a function, and we
1438 are out of a function (last_functionP == 0) then, the
1439 function symbol will be associated with an auxiliary
1441 if (last_functionP
== (symbolS
*) 0 &&
1442 SF_GET_FUNCTION (symbolP
))
1444 last_functionP
= symbolP
;
1446 if (S_GET_NUMBER_AUXILIARY (symbolP
) < 1)
1448 S_SET_NUMBER_AUXILIARY (symbolP
, 1);
1449 } /* make it at least 1 */
1451 /* Clobber possible stale .dim information. */
1453 /* Iffed out by steve - this fries the lnnoptr info too */
1454 bzero (symbolP
->sy_symbol
.ost_auxent
[0].x_sym
.x_fcnary
.x_ary
.x_dimen
,
1455 sizeof (symbolP
->sy_symbol
.ost_auxent
[0].x_sym
.x_fcnary
.x_ary
.x_dimen
));
1458 /* The C_FCN doesn't need any additional information.
1459 I don't even know if this is needed for sdb. But the
1460 standard assembler generates it, so...
1462 if (S_GET_STORAGE_CLASS (symbolP
) == C_EFCN
)
1464 if (last_functionP
== (symbolS
*) 0)
1465 as_fatal ("C_EFCN symbol out of scope");
1466 SA_SET_SYM_FSIZE (last_functionP
,
1467 (long) (S_GET_VALUE (symbolP
) -
1468 S_GET_VALUE (last_functionP
)));
1469 SA_SET_SYM_ENDNDX (last_functionP
, symbol_number
);
1470 last_functionP
= (symbolS
*) 0;
1474 else if (SF_GET_TAG (symbolP
))
1476 /* First descriptor of a structure must point to
1477 the first slot after the structure description. */
1478 last_tagP
= symbolP
;
1481 else if (S_GET_STORAGE_CLASS (symbolP
) == C_EOS
)
1483 /* +2 take in account the current symbol */
1484 SA_SET_SYM_ENDNDX (last_tagP
, symbol_number
+ 2);
1486 else if (S_GET_STORAGE_CLASS (symbolP
) == C_FILE
)
1488 if (S_GET_VALUE (symbolP
))
1490 S_SET_VALUE ((symbolS
*) S_GET_VALUE (symbolP
), symbol_number
);
1491 S_SET_VALUE (symbolP
, 0);
1492 } /* no one points at the first .file symbol */
1493 } /* if debug or tag or eos or file */
1495 /* We must put the external symbols apart. The loader
1496 does not bomb if we do not. But the references in
1497 the endndx field for a .bb symbol are not corrected
1498 if an external symbol is removed between .bb and .be.
1499 I.e in the following case :
1500 [20] .bb endndx = 22
1503 ld will move the symbol 21 to the end of the list but
1504 endndx will still be 22 instead of 21. */
1507 if (SF_GET_LOCAL (symbolP
))
1509 /* remove C_EFCN and LOCAL (L...) symbols */
1510 /* next pointer remains valid */
1511 symbol_remove (symbolP
, &symbol_rootP
, &symbol_lastP
);
1514 else if (!S_IS_DEFINED (symbolP
)
1515 && !S_IS_DEBUG (symbolP
)
1516 && !SF_GET_STATICS (symbolP
) &&
1517 S_GET_STORAGE_CLASS (symbolP
) == C_EXT
)
1518 { /* C_EXT && !SF_GET_FUNCTION(symbolP)) */
1519 /* if external, Remove from the list */
1520 symbolS
*hold
= symbol_previous (symbolP
);
1522 symbol_remove (symbolP
, &symbol_rootP
, &symbol_lastP
);
1523 symbol_clear_list_pointers (symbolP
);
1524 symbol_append (symbolP
, symbol_extern_lastP
, &symbol_externP
, &symbol_extern_lastP
);
1529 if (SF_GET_STRING (symbolP
))
1531 symbolP
->sy_name_offset
= string_byte_count
;
1532 string_byte_count
+= strlen (S_GET_NAME (symbolP
)) + 1;
1536 symbolP
->sy_name_offset
= 0;
1537 } /* fix "long" names */
1539 symbolP
->sy_number
= symbol_number
;
1540 symbol_number
+= 1 + S_GET_NUMBER_AUXILIARY (symbolP
);
1541 } /* if local symbol */
1542 } /* traverse the symbol list */
1543 return symbol_number
;
1549 DEFUN_VOID (glue_symbols
)
1551 unsigned int symbol_number
= 0;
1553 for (symbolP
= symbol_externP
; symbol_externP
;)
1555 symbolS
*tmp
= symbol_externP
;
1558 symbol_remove (tmp
, &symbol_externP
, &symbol_extern_lastP
);
1559 symbol_append (tmp
, symbol_lastP
, &symbol_rootP
, &symbol_lastP
);
1562 if (SF_GET_STRING (tmp
))
1564 tmp
->sy_name_offset
= string_byte_count
;
1565 string_byte_count
+= strlen (S_GET_NAME (tmp
)) + 1;
1569 tmp
->sy_name_offset
= 0;
1570 } /* fix "long" names */
1572 tmp
->sy_number
= symbol_number
;
1573 symbol_number
+= 1 + S_GET_NUMBER_AUXILIARY (tmp
);
1574 } /* append the entire extern chain */
1575 return symbol_number
;
1580 DEFUN_VOID (tie_tags
)
1582 unsigned int symbol_number
= 0;
1585 for (symbolP
= symbol_rootP
; symbolP
; symbolP
=
1586 symbol_next (symbolP
))
1588 symbolP
->sy_number
= symbol_number
;
1592 if (SF_GET_TAGGED (symbolP
))
1596 ((symbolS
*) SA_GET_SYM_TAGNDX (symbolP
))->sy_number
);
1599 symbol_number
+= 1 + S_GET_NUMBER_AUXILIARY (symbolP
);
1601 return symbol_number
;
1606 DEFUN (crawl_symbols
, (h
, abfd
),
1607 object_headers
*h AND
1612 unsigned int ptr
= 0;
1617 /* Initialize the stack used to keep track of the matching .bb .be */
1619 block_stack
= stack_init (512, sizeof (symbolS
*));
1620 /* JF deal with forward references first... */
1621 for (symbolP
= symbol_rootP
;
1623 symbolP
= symbol_next (symbolP
))
1626 if (symbolP
->sy_forward
)
1628 S_SET_VALUE (symbolP
, (S_GET_VALUE (symbolP
)
1629 + S_GET_VALUE (symbolP
->sy_forward
)
1630 + symbolP
->sy_forward
->sy_frag
->fr_address
));
1632 if (SF_GET_GET_SEGMENT (symbolP
))
1634 S_SET_SEGMENT (symbolP
, S_GET_SEGMENT (symbolP
->sy_forward
));
1635 } /* forward segment also */
1637 symbolP
->sy_forward
= 0;
1638 } /* if it has a forward reference */
1639 } /* walk the symbol chain */
1642 /* The symbol list should be ordered according to the following sequence
1645 * . debug entries for functions
1646 * . fake symbols for the sections, including.text .data and .bss
1648 * . undefined symbols
1649 * But this is not mandatory. The only important point is to put the
1650 * undefined symbols at the end of the list.
1653 if (symbol_rootP
== NULL
1654 || S_GET_STORAGE_CLASS (symbol_rootP
) != C_FILE
)
1656 c_dot_file_symbol ("fake");
1658 /* Is there a .file symbol ? If not insert one at the beginning. */
1661 * Build up static symbols for the sections, they are filled in later
1665 for (i
= SEG_E0
; i
< SEG_E9
; i
++)
1667 if (segment_info
[i
].scnhdr
.s_name
[0])
1671 strncpy (name
, segment_info
[i
].scnhdr
.s_name
, 8);
1673 segment_info
[i
].dot
= c_section_symbol (name
, i
- SEG_E0
+ 1);
1678 /* Take all the externals out and put them into another chain */
1679 H_SET_SYMBOL_TABLE_SIZE (h
, yank_symbols ());
1680 /* Take the externals and glue them onto the end.*/
1681 H_SET_SYMBOL_TABLE_SIZE (h
, H_GET_SYMBOL_COUNT (h
) + glue_symbols ());
1683 H_SET_SYMBOL_TABLE_SIZE (h
, tie_tags ());
1684 know (symbol_externP
== NULL
);
1685 know (symbol_extern_lastP
== NULL
);
1691 * Find strings by crawling along symbol table chain.
1695 DEFUN (w_strings
, (where
),
1700 /* Gotta do md_ byte-ordering stuff for string_byte_count first - KWK */
1701 md_number_to_chars (where
, string_byte_count
, sizeof (string_byte_count
));
1702 where
+= sizeof (string_byte_count
);
1703 for (symbolP
= symbol_rootP
;
1705 symbolP
= symbol_next (symbolP
))
1709 if (SF_GET_STRING (symbolP
))
1711 size
= strlen (S_GET_NAME (symbolP
)) + 1;
1713 memcpy (where
, S_GET_NAME (symbolP
), size
);
1722 DEFUN (do_linenos_for
, (abfd
, h
, file_cursor
),
1724 object_headers
* h AND
1725 unsigned long *file_cursor
)
1728 unsigned long start
= *file_cursor
;
1730 for (idx
= SEG_E0
; idx
< SEG_E9
; idx
++)
1732 segment_info_type
*s
= segment_info
+ idx
;
1735 if (s
->scnhdr
.s_nlnno
!= 0)
1737 struct lineno_list
*line_ptr
;
1739 struct external_lineno
*buffer
=
1740 (struct external_lineno
*) xmalloc (s
->scnhdr
.s_nlnno
* LINESZ
);
1742 struct external_lineno
*dst
= buffer
;
1744 /* Run through the table we've built and turn it into its external
1745 form, take this chance to remove duplicates */
1747 for (line_ptr
= s
->lineno_list_head
;
1748 line_ptr
!= (struct lineno_list
*) NULL
;
1749 line_ptr
= line_ptr
->next
)
1752 if (line_ptr
->line
.l_lnno
== 0)
1754 /* Turn a pointer to a symbol into the symbols' index */
1755 line_ptr
->line
.l_addr
.l_symndx
=
1756 ((symbolS
*) line_ptr
->line
.l_addr
.l_symndx
)->sy_number
;
1760 line_ptr
->line
.l_addr
.l_paddr
+= ((struct frag
*) (line_ptr
->frag
))->fr_address
;
1764 (void) bfd_coff_swap_lineno_out (abfd
, &(line_ptr
->line
), dst
);
1769 s
->scnhdr
.s_lnnoptr
= *file_cursor
;
1771 bfd_write (buffer
, 1, s
->scnhdr
.s_nlnno
* LINESZ
, abfd
);
1774 *file_cursor
+= s
->scnhdr
.s_nlnno
* LINESZ
;
1777 H_SET_LINENO_SIZE (h
, *file_cursor
- start
);
1781 /* Now we run through the list of frag chains in a segment and
1782 make all the subsegment frags appear at the end of the
1783 list, as if the seg 0 was extra long */
1786 DEFUN_VOID (remove_subsegs
)
1790 for (i
= SEG_E0
; i
< SEG_UNKNOWN
; i
++)
1792 frchainS
*head
= segment_info
[i
].frchainP
;
1794 fragS
*prev_frag
= &dummy
;
1796 while (head
&& head
->frch_seg
== i
)
1798 prev_frag
->fr_next
= head
->frch_root
;
1799 prev_frag
= head
->frch_last
;
1800 head
= head
->frch_next
;
1802 prev_frag
->fr_next
= 0;
1809 DEFUN_VOID (write_object_file
)
1812 struct frchain
*frchain_ptr
;
1814 object_headers headers
;
1815 unsigned long file_cursor
;
1818 abfd
= bfd_openw (out_file_name
, TARGET_FORMAT
);
1823 as_perror ("FATAL: Can't create %s", out_file_name
);
1826 bfd_set_format (abfd
, bfd_object
);
1827 bfd_set_arch_mach (abfd
, BFD_ARCH
, machine
);
1829 string_byte_count
= 4;
1831 for (frchain_ptr
= frchain_root
;
1832 frchain_ptr
!= (struct frchain
*) NULL
;
1833 frchain_ptr
= frchain_ptr
->frch_next
)
1835 /* Run through all the sub-segments and align them up. Also close any
1836 open frags. We tack a .fill onto the end of the frag chain so
1837 that any .align's size can be worked by looking at the next
1840 subseg_new (frchain_ptr
->frch_seg
, frchain_ptr
->frch_subseg
);
1841 #ifndef SUB_SEGMENT_ALIGN
1842 #define SUB_SEGMENT_ALIGN 1
1844 frag_align (SUB_SEGMENT_ALIGN
, NOP_OPCODE
);
1845 frag_wane (frag_now
);
1846 frag_now
->fr_fix
= 0;
1847 know (frag_now
->fr_next
== NULL
);
1854 for (i
= SEG_E0
; i
< SEG_UNKNOWN
; i
++)
1856 relax_segment (segment_info
[i
].frchainP
->frch_root
, i
);
1859 H_SET_NUMBER_OF_SECTIONS (&headers
, 0);
1861 /* Find out how big the sections are, and set the addresses. */
1863 for (i
= SEG_E0
; i
< SEG_UNKNOWN
; i
++)
1867 segment_info
[i
].scnhdr
.s_paddr
= addr
;
1869 if (segment_info
[i
].scnhdr
.s_name
[0])
1871 H_SET_NUMBER_OF_SECTIONS (&headers
,
1872 H_GET_NUMBER_OF_SECTIONS (&headers
) + 1);
1875 size
= size_section (abfd
, i
);
1879 H_SET_TEXT_SIZE (&headers
, size
);
1880 else if (i
== SEG_E1
)
1881 H_SET_DATA_SIZE (&headers
, size
);
1882 else if (i
== SEG_E2
)
1883 H_SET_BSS_SIZE (&headers
, size
);
1886 /* Turn the gas native symbol table shape into a coff symbol table */
1887 crawl_symbols (&headers
, abfd
);
1889 if (string_byte_count
== 4)
1890 string_byte_count
= 0;
1892 H_SET_STRING_SIZE (&headers
, string_byte_count
);
1894 #if !defined(TC_H8300) && !defined(TC_Z8K)
1895 for (i
= SEG_E0
; i
< SEG_UNKNOWN
; i
++)
1897 fixup_mdeps (segment_info
[i
].frchainP
->frch_root
, &headers
, i
);
1898 fixup_segment (&segment_info
[i
], i
);
1902 file_cursor
= H_GET_TEXT_FILE_OFFSET (&headers
);
1904 bfd_seek (abfd
, file_cursor
, 0);
1906 /* Plant the data */
1908 fill_section (abfd
, &headers
, &file_cursor
);
1910 do_relocs_for (abfd
, &headers
, &file_cursor
);
1912 do_linenos_for (abfd
, &headers
, &file_cursor
);
1914 H_SET_FILE_MAGIC_NUMBER (&headers
, COFF_MAGIC
);
1915 #ifndef OBJ_COFF_OMIT_TIMESTAMP
1916 H_SET_TIME_STAMP (&headers
, (long)time((long*)0));
1918 H_SET_TIME_STAMP (&headers
, 0);
1921 #ifdef KEEP_RELOC_INFO
1922 H_SET_FLAGS (&headers
, ((H_GET_LINENO_SIZE(&headers
) ? 0 : F_LNNO
) |
1923 COFF_FLAGS
| coff_flags
));
1925 H_SET_FLAGS (&headers
, ((H_GET_LINENO_SIZE(&headers
) ? 0 : F_LNNO
) |
1926 (H_GET_RELOCATION_SIZE(&headers
) ? 0 : F_RELFLG
) |
1927 COFF_FLAGS
| coff_flags
));
1931 unsigned int symtable_size
= H_GET_SYMBOL_TABLE_SIZE (&headers
);
1932 char *buffer1
= xmalloc (symtable_size
+ string_byte_count
+ 1);
1933 char *ptr
= buffer1
;
1934 H_SET_SYMBOL_TABLE_POINTER (&headers
, bfd_tell (abfd
));
1935 w_symbols (abfd
, buffer1
, symbol_rootP
);
1936 if (string_byte_count
> 0)
1937 w_strings (buffer1
+ symtable_size
);
1938 bfd_write (buffer1
, 1, symtable_size
+ string_byte_count
, abfd
);
1942 coff_header_append (abfd
, &headers
);
1944 if (bfd_close_all_done (abfd
) == false)
1945 as_fatal ("Can't close %s: %s", out_file_name
,
1946 bfd_errmsg (bfd_error
));
1951 DEFUN (change_to_section
, (name
, len
, exp
),
1953 unsigned int len AND
1957 /* Find out if we've already got a section of this name etc */
1958 for (i
= SEG_E0
; i
< SEG_E9
&& segment_info
[i
].scnhdr
.s_name
[0]; i
++)
1960 if (strncmp (segment_info
[i
].scnhdr
.s_name
, name
, len
) == 0)
1962 subseg_new (i
, exp
);
1967 /* No section, add one */
1968 strncpy (segment_info
[i
].scnhdr
.s_name
, name
, 8);
1969 subseg_new (i
, exp
);
1973 * implement the .section pseudo op:
1974 * .section name {, "flags"}
1976 * | +--- optional flags: 'b' for bss
1978 * +-- section name 'l' for lib
1983 * But if the argument is not a quoted string, treat it as a
1984 * subsegment number.
1988 DEFUN_VOID (obj_coff_section
)
1990 /* Strip out the section name */
1992 char *section_name_end
;
1999 section_name
= input_line_pointer
;
2000 c
= get_symbol_end ();
2001 section_name_end
= input_line_pointer
;
2003 len
= section_name_end
- section_name
;
2004 input_line_pointer
++;
2010 else if (*input_line_pointer
== ',')
2013 ++input_line_pointer
;
2021 if (*input_line_pointer
!= '"')
2022 exp
= get_absolute_expression ();
2025 ++input_line_pointer
;
2026 while (*input_line_pointer
!= '"'
2027 && ! is_end_of_line
[*input_line_pointer
])
2029 switch (*input_line_pointer
)
2031 case 'b': flags
|= STYP_BSS
; break;
2032 case 'i': flags
|= STYP_INFO
; break;
2033 case 'l': flags
|= STYP_LIB
; break;
2034 case 'n': flags
|= STYP_NOLOAD
; break;
2035 case 'o': flags
|= STYP_OVER
; break;
2036 case 'w': flags
|= STYP_DATA
; break;
2037 case 'x': flags
|= STYP_TEXT
; break;
2039 as_warn("unknown section attribute '%c'",
2040 *input_line_pointer
);
2043 ++input_line_pointer
;
2045 if (*input_line_pointer
== '"')
2046 ++input_line_pointer
;
2050 change_to_section (section_name
, len
, exp
);
2052 segment_info
[now_seg
].scnhdr
.s_flags
|= flags
;
2054 *section_name_end
= c
;
2061 change_to_section (".text", 5, get_absolute_expression ());
2068 change_to_section (".data", 5, get_absolute_expression ());
2074 if (*input_line_pointer
== '\n') /* .bss */
2075 change_to_section(".bss",4, get_absolute_expression());
2076 else /* .bss id,expr */
2083 segT current_seg
= now_seg
; /* save current seg */
2084 subsegT current_subseg
= now_subseg
;
2085 change_to_section (".comment", 8, 0); /* .comment seg */
2086 stringer (1); /* read string */
2087 subseg_new (current_seg
, current_subseg
); /* restore current seg */
2091 c_symbol_merge (debug
, normal
)
2095 S_SET_DATA_TYPE (normal
, S_GET_DATA_TYPE (debug
));
2096 S_SET_STORAGE_CLASS (normal
, S_GET_STORAGE_CLASS (debug
));
2098 if (S_GET_NUMBER_AUXILIARY (debug
) > S_GET_NUMBER_AUXILIARY (normal
))
2100 S_SET_NUMBER_AUXILIARY (normal
, S_GET_NUMBER_AUXILIARY (debug
));
2101 } /* take the most we have */
2103 if (S_GET_NUMBER_AUXILIARY (debug
) > 0)
2105 memcpy ((char *) &normal
->sy_symbol
.ost_auxent
[0], (char *) &debug
->sy_symbol
.ost_auxent
[0], S_GET_NUMBER_AUXILIARY (debug
) * AUXESZ
);
2106 } /* Move all the auxiliary information */
2108 /* Move the debug flags. */
2109 SF_SET_DEBUG_FIELD (normal
, SF_GET_DEBUG_FIELD (debug
));
2110 } /* c_symbol_merge() */
2113 DEFUN (c_line_new
, (symbol
, paddr
, line_number
, frag
),
2114 symbolS
* symbol AND
2116 unsigned short line_number AND
2119 struct lineno_list
*new_line
=
2120 (struct lineno_list
*) xmalloc (sizeof (struct lineno_list
));
2122 segment_info_type
*s
= segment_info
+ now_seg
;
2123 new_line
->line
.l_lnno
= line_number
;
2125 if (line_number
== 0)
2127 last_line_symbol
= symbol
;
2128 new_line
->line
.l_addr
.l_symndx
= (long) symbol
;
2132 new_line
->line
.l_addr
.l_paddr
= paddr
;
2135 new_line
->frag
= (char *) frag
;
2136 new_line
->next
= (struct lineno_list
*) NULL
;
2139 if (s
->lineno_list_head
== (struct lineno_list
*) NULL
)
2141 s
->lineno_list_head
= new_line
;
2145 s
->lineno_list_tail
->next
= new_line
;
2147 s
->lineno_list_tail
= new_line
;
2148 return LINESZ
* s
->scnhdr
.s_nlnno
++;
2152 c_dot_file_symbol (filename
)
2157 symbolP
= symbol_new (".file",
2160 &zero_address_frag
);
2162 S_SET_STORAGE_CLASS (symbolP
, C_FILE
);
2163 S_SET_NUMBER_AUXILIARY (symbolP
, 1);
2164 SA_SET_FILE_FNAME (symbolP
, filename
);
2170 listing_source_file (filename
);
2176 SF_SET_DEBUG (symbolP
);
2177 S_SET_VALUE (symbolP
, (long) previous_file_symbol
);
2179 previous_file_symbol
= symbolP
;
2181 /* Make sure that the symbol is first on the symbol chain */
2182 if (symbol_rootP
!= symbolP
)
2184 if (symbolP
== symbol_lastP
)
2186 symbol_lastP
= symbol_lastP
->sy_previous
;
2187 } /* if it was the last thing on the list */
2189 symbol_remove (symbolP
, &symbol_rootP
, &symbol_lastP
);
2190 symbol_insert (symbolP
, symbol_rootP
, &symbol_rootP
, &symbol_lastP
);
2191 symbol_rootP
= symbolP
;
2192 } /* if not first on the list */
2194 } /* c_dot_file_symbol() */
2197 * Build a 'section static' symbol.
2201 c_section_symbol (name
, idx
)
2207 symbolP
= symbol_new (name
, idx
,
2209 &zero_address_frag
);
2211 S_SET_STORAGE_CLASS (symbolP
, C_STAT
);
2212 S_SET_NUMBER_AUXILIARY (symbolP
, 1);
2214 SF_SET_STATICS (symbolP
);
2217 } /* c_section_symbol() */
2220 DEFUN (w_symbols
, (abfd
, where
, symbol_rootP
),
2223 symbolS
* symbol_rootP
)
2228 /* First fill in those values we have only just worked out */
2229 for (i
= SEG_E0
; i
< SEG_E9
; i
++)
2231 symbolP
= segment_info
[i
].dot
;
2235 SA_SET_SCN_SCNLEN (symbolP
, segment_info
[i
].scnhdr
.s_size
);
2236 SA_SET_SCN_NRELOC (symbolP
, segment_info
[i
].scnhdr
.s_nreloc
);
2237 SA_SET_SCN_NLINNO (symbolP
, segment_info
[i
].scnhdr
.s_nlnno
);
2243 * Emit all symbols left in the symbol chain.
2245 for (symbolP
= symbol_rootP
; symbolP
; symbolP
= symbol_next (symbolP
))
2247 /* Used to save the offset of the name. It is used to point
2248 to the string in memory but must be a file offset. */
2249 register char *temp
;
2251 tc_coff_symbol_emit_hook (symbolP
);
2253 temp
= S_GET_NAME (symbolP
);
2254 if (SF_GET_STRING (symbolP
))
2256 S_SET_OFFSET (symbolP
, symbolP
->sy_name_offset
);
2257 S_SET_ZEROES (symbolP
, 0);
2261 bzero (symbolP
->sy_symbol
.ost_entry
.n_name
, SYMNMLEN
);
2262 strncpy (symbolP
->sy_symbol
.ost_entry
.n_name
, temp
, SYMNMLEN
);
2264 where
= symbol_to_chars (abfd
, where
, symbolP
);
2265 S_SET_NAME (symbolP
, temp
);
2271 DEFUN_VOID (obj_coff_lcomm
)
2279 name
= input_line_pointer
;
2281 c
= get_symbol_end ();
2282 p
= input_line_pointer
;
2285 if (*input_line_pointer
!= ',')
2287 as_bad ("Expected comma after name");
2288 ignore_rest_of_line ();
2291 if (*input_line_pointer
== '\n')
2293 as_bad ("Missing size expression");
2296 input_line_pointer
++;
2297 if ((temp
= get_absolute_expression ()) < 0)
2299 as_warn ("lcomm length (%d.) <0! Ignored.", temp
);
2300 ignore_rest_of_line ();
2305 symbolP
= symbol_find_or_make(name
);
2307 if (S_GET_SEGMENT(symbolP
) == SEG_UNKNOWN
&&
2308 S_GET_VALUE(symbolP
) == 0)
2313 segT current_seg
= now_seg
; /* save current seg */
2314 subsegT current_subseg
= now_subseg
;
2316 subseg_new (SEG_E2
, 1);
2317 symbolP
->sy_frag
= frag_now
;
2318 p
= frag_var(rs_org
, 1, 1, (relax_substateT
)0, symbolP
,
2321 subseg_new (current_seg
, current_subseg
); /* restore current seg */
2322 S_SET_SEGMENT(symbolP
, SEG_E2
);
2323 S_SET_STORAGE_CLASS(symbolP
, C_STAT
);
2327 as_bad("Symbol %s already defined", name
);
2329 demand_empty_rest_of_line();
2333 DEFUN (fixup_mdeps
, (frags
, h
, this_segment
),
2335 object_headers
* h AND
2338 subseg_change (this_segment
, 0);
2341 switch (frags
->fr_type
)
2345 frags
->fr_type
= rs_fill
;
2347 (frags
->fr_next
->fr_address
- frags
->fr_address
- frags
->fr_fix
);
2349 case rs_machine_dependent
:
2350 md_convert_frag (h
, frags
);
2356 frags
= frags
->fr_next
;
2362 DEFUN (fixup_segment
, (segP
, this_segment_type
),
2363 segment_info_type
* segP AND
2364 segT this_segment_type
)
2366 register fixS
* fixP
;
2367 register symbolS
*add_symbolP
;
2368 register symbolS
*sub_symbolP
;
2369 register long add_number
;
2371 register char *place
;
2372 register long where
;
2373 register char pcrel
;
2374 register fragS
*fragP
;
2375 register segT add_symbol_segment
= SEG_ABSOLUTE
;
2378 for (fixP
= segP
->fix_root
; fixP
; fixP
= fixP
->fx_next
)
2380 fragP
= fixP
->fx_frag
;
2382 where
= fixP
->fx_where
;
2383 place
= fragP
->fr_literal
+ where
;
2384 size
= fixP
->fx_size
;
2385 add_symbolP
= fixP
->fx_addsy
;
2387 if (fixP
->fx_callj
&& TC_S_IS_CALLNAME (add_symbolP
))
2389 /* Relocation should be done via the
2390 associated 'bal' entry point
2393 if (!TC_S_IS_BALNAME (tc_get_bal_of_call (add_symbolP
)))
2395 as_bad ("No 'bal' entry point for leafproc %s",
2396 S_GET_NAME (add_symbolP
));
2399 fixP
->fx_addsy
= add_symbolP
= tc_get_bal_of_call (add_symbolP
);
2400 } /* callj relocation */
2402 sub_symbolP
= fixP
->fx_subsy
;
2403 add_number
= fixP
->fx_offset
;
2404 pcrel
= fixP
->fx_pcrel
;
2408 add_symbol_segment
= S_GET_SEGMENT (add_symbolP
);
2409 } /* if there is an addend */
2416 if (S_GET_SEGMENT (sub_symbolP
) != SEG_ABSOLUTE
)
2418 as_bad ("Negative of non-absolute symbol %s", S_GET_NAME (sub_symbolP
));
2419 } /* not absolute */
2421 add_number
-= S_GET_VALUE (sub_symbolP
);
2424 /* if sub_symbol is in the same segment that add_symbol
2425 and add_symbol is either in DATA, TEXT, BSS or ABSOLUTE */
2427 else if ((S_GET_SEGMENT (sub_symbolP
) == add_symbol_segment
)
2428 && (SEG_NORMAL (add_symbol_segment
)
2429 || (add_symbol_segment
== SEG_ABSOLUTE
)))
2431 /* Difference of 2 symbols from same segment. */
2432 /* Can't make difference of 2 undefineds: 'value' means */
2433 /* something different for N_UNDF. */
2435 /* Makes no sense to use the difference of 2 arbitrary symbols
2436 * as the target of a call instruction.
2440 as_bad ("callj to difference of 2 symbols");
2442 #endif /* TC_I960 */
2443 add_number
+= S_GET_VALUE (add_symbolP
) -
2444 S_GET_VALUE (sub_symbolP
);
2447 fixP
->fx_addsy
= NULL
;
2451 /* Different segments in subtraction. */
2452 know (!(S_IS_EXTERNAL (sub_symbolP
) && (S_GET_SEGMENT (sub_symbolP
) == SEG_ABSOLUTE
)));
2454 if ((S_GET_SEGMENT (sub_symbolP
) == SEG_ABSOLUTE
))
2456 add_number
-= S_GET_VALUE (sub_symbolP
);
2460 as_bad ("Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %d.",
2461 segment_name (S_GET_SEGMENT (sub_symbolP
)),
2462 S_GET_NAME (sub_symbolP
), fragP
->fr_address
+ where
);
2465 } /* if sub_symbolP */
2469 if (add_symbol_segment
== this_segment_type
&& pcrel
)
2472 * This fixup was made when the symbol's segment was
2473 * SEG_UNKNOWN, but it is now in the local segment.
2474 * So we know how to do the address without relocation.
2477 /* reloc_callj() may replace a 'call' with a 'calls' or a 'bal',
2478 * in which cases it modifies *fixP as appropriate. In the case
2479 * of a 'calls', no further work is required, and *fixP has been
2480 * set up to make the rest of the code below a no-op.
2483 #endif /* TC_I960 */
2485 add_number
+= S_GET_VALUE (add_symbolP
);
2486 add_number
-= md_pcrel_from (fixP
);
2488 /* On the 386 we must adjust by the segment
2489 vaddr as well. Ian Taylor. */
2490 add_number
-= segP
->scnhdr
.s_vaddr
;
2492 pcrel
= 0; /* Lie. Don't want further pcrel processing. */
2493 fixP
->fx_addsy
= NULL
; /* No relocations please. */
2497 switch (add_symbol_segment
)
2501 reloc_callj (fixP
); /* See comment about reloc_callj() above*/
2502 #endif /* TC_I960 */
2503 add_number
+= S_GET_VALUE (add_symbolP
);
2504 fixP
->fx_addsy
= NULL
;
2509 add_number
+= S_GET_VALUE (add_symbolP
) +
2510 segment_info
[S_GET_SEGMENT (add_symbolP
)].scnhdr
.s_paddr
;
2515 if ((int) fixP
->fx_bit_fixP
== 13)
2517 /* This is a COBR instruction. They have only a
2518 * 13-bit displacement and are only to be used
2519 * for local branches: flag as error, don't generate
2522 as_bad ("can't use COBR format with external label");
2523 fixP
->fx_addsy
= NULL
; /* No relocations please. */
2526 #endif /* TC_I960 */
2528 /* 386 COFF uses a peculiar format in
2529 which the value of a common symbol is
2530 stored in the .text segment (I've
2531 checked this on SVR3.2 and SCO 3.2.2)
2532 Ian Taylor <ian@cygnus.com>. */
2533 if (S_IS_COMMON (add_symbolP
))
2534 add_number
+= S_GET_VALUE (add_symbolP
);
2539 } /* switch on symbol seg */
2540 } /* if not in local seg */
2541 } /* if there was a + symbol */
2545 add_number
-= md_pcrel_from (fixP
);
2546 if (add_symbolP
== 0)
2548 fixP
->fx_addsy
= &abs_symbol
;
2549 } /* if there's an add_symbol */
2551 /* On the 386 we must adjust by the segment vaddr
2552 as well. Ian Taylor. */
2553 add_number
-= segP
->scnhdr
.s_vaddr
;
2557 if (!fixP
->fx_bit_fixP
)
2560 (add_number
& ~0xFF) && ((add_number
& ~0xFF) != (-1 & ~0xFF))) ||
2562 (add_number
& ~0xFFFF) && ((add_number
& ~0xFFFF) != (-1 & ~0xFFFF))))
2564 as_bad ("Value of %d too large for field of %d bytes at 0x%x",
2565 add_number
, size
, fragP
->fr_address
+ where
);
2566 } /* generic error checking */
2567 #ifdef WARN_SIGNED_OVERFLOW_WORD
2568 /* Warn if a .word value is too large when treated as
2569 a signed number. We already know it is not too
2570 negative. This is to catch over-large switches
2571 generated by gcc on the 68k. */
2574 && add_number
> 0x7fff)
2575 as_bad ("Signed .word overflow; switch may be too large; %d at 0x%x",
2576 add_number
, fragP
->fr_address
+ where
);
2578 } /* not a bit fix */
2579 /* once this fix has been applied, we don't have to output anything
2580 nothing more need be done -*/
2581 md_apply_fix (fixP
, add_number
);
2583 } /* For each fixS in this segment. */
2586 } /* fixup_segment() */