projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
* config/obj-coff.c (coff_header_append): Check return value of
[deliverable/binutils-gdb.git] / gas / config / obj-coff.c
1 /* coff object file format
2 Copyright (C) 1989, 1990, 1991, 1992, 1993, 1994
3 Free Software Foundation, Inc.
4
5 This file is part of GAS.
6
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
10 any later version.
11
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to
19 the Free Software Foundation, 675 Mass Ave, Cambridge, MA 02139, USA. */
20
21 #include "as.h"
22 #include "obstack.h"
23 #include "subsegs.h"
24
25 /* I think this is probably always correct. */
26 #ifndef KEEP_RELOC_INFO
27 #define KEEP_RELOC_INFO
28 #endif
29
30 const char *s_get_name PARAMS ((symbolS * s));
31 static symbolS *def_symbol_in_progress;
32
33 \f
34 /* stack stuff */
35 typedef struct
36 {
37 unsigned long chunk_size;
38 unsigned long element_size;
39 unsigned long size;
40 char *data;
41 unsigned long pointer;
42 }
43 stack;
44
45 static stack *
46 stack_init (chunk_size, element_size)
47 unsigned long chunk_size;
48 unsigned long element_size;
49 {
50 stack *st;
51
52 st = (stack *) malloc (sizeof (stack));
53 if (!st)
54 return 0;
55 st->data = malloc (chunk_size);
56 if (!st->data)
57 {
58 free (st);
59 return 0;
60 }
61 st->pointer = 0;
62 st->size = chunk_size;
63 st->chunk_size = chunk_size;
64 st->element_size = element_size;
65 return st;
66 }
67
68 #if 0
69 /* Not currently used. */
70 static void
71 stack_delete (st)
72 stack *st;
73 {
74 free (st->data);
75 free (st);
76 }
77 #endif
78
79 static char *
80 stack_push (st, element)
81 stack *st;
82 char *element;
83 {
84 if (st->pointer + st->element_size >= st->size)
85 {
86 st->size += st->chunk_size;
87 if ((st->data = xrealloc (st->data, st->size)) == (char *) 0)
88 return (char *) 0;
89 }
90 memcpy (st->data + st->pointer, element, st->element_size);
91 st->pointer += st->element_size;
92 return st->data + st->pointer;
93 }
94
95 static char *
96 stack_pop (st)
97 stack *st;
98 {
99 if (st->pointer < st->element_size)
100 {
101 st->pointer = 0;
102 return (char *) 0;
103 }
104 st->pointer -= st->element_size;
105 return st->data + st->pointer;
106 }
107 \f
108 /*
109 * Maintain a list of the tagnames of the structres.
110 */
111
112 static struct hash_control *tag_hash;
113
114 static void
115 tag_init ()
116 {
117 tag_hash = hash_new ();
118 }
119
120 static void
121 tag_insert (name, symbolP)
122 const char *name;
123 symbolS *symbolP;
124 {
125 const char *error_string;
126
127 if ((error_string = hash_jam (tag_hash, name, (char *) symbolP)))
128 {
129 as_fatal ("Inserting \"%s\" into structure table failed: %s",
130 name, error_string);
131 }
132 }
133
134 static symbolS *
135 tag_find (name)
136 char *name;
137 {
138 #ifdef STRIP_UNDERSCORE
139 if (*name == '_')
140 name++;
141 #endif /* STRIP_UNDERSCORE */
142 return (symbolS *) hash_find (tag_hash, name);
143 }
144
145 static symbolS *
146 tag_find_or_make (name)
147 char *name;
148 {
149 symbolS *symbolP;
150
151 if ((symbolP = tag_find (name)) == NULL)
152 {
153 symbolP = symbol_new (name, undefined_section,
154 0, &zero_address_frag);
155
156 tag_insert (S_GET_NAME (symbolP), symbolP);
157 #ifdef BFD_ASSEMBLER
158 symbol_table_insert (symbolP);
159 #endif
160 } /* not found */
161
162 return symbolP;
163 }
164
165
166
167 #ifdef BFD_ASSEMBLER
168
169 static void SA_SET_SYM_TAGNDX PARAMS ((symbolS *, symbolS *));
170
171 #define GET_FILENAME_STRING(X) \
172 ((char*)(&((X)->sy_symbol.ost_auxent->x_file.x_n.x_offset))[1])
173
174 /* @@ Ick. */
175 static segT
176 fetch_coff_debug_section ()
177 {
178 static segT debug_section;
179 if (!debug_section)
180 {
181 CONST asymbol *s;
182 s = bfd_make_debug_symbol (stdoutput, (char *) 0, 0);
183 assert (s != 0);
184 debug_section = s->section;
185 }
186 return debug_section;
187 }
188
189 void
190 SA_SET_SYM_ENDNDX (sym, val)
191 symbolS *sym;
192 symbolS *val;
193 {
194 combined_entry_type *entry, *p;
195
196 entry = &coffsymbol (sym->bsym)->native[1];
197 p = coffsymbol (val->bsym)->native;
198 entry->u.auxent.x_sym.x_fcnary.x_fcn.x_endndx.p = p;
199 entry->fix_end = 1;
200 }
201
202 static void
203 SA_SET_SYM_TAGNDX (sym, val)
204 symbolS *sym;
205 symbolS *val;
206 {
207 combined_entry_type *entry, *p;
208
209 entry = &coffsymbol (sym->bsym)->native[1];
210 p = coffsymbol (val->bsym)->native;
211 entry->u.auxent.x_sym.x_tagndx.p = p;
212 entry->fix_tag = 1;
213 }
214
215 static int
216 S_GET_DATA_TYPE (sym)
217 symbolS *sym;
218 {
219 return coffsymbol (sym->bsym)->native->u.syment.n_type;
220 }
221
222 int
223 S_SET_DATA_TYPE (sym, val)
224 symbolS *sym;
225 int val;
226 {
227 coffsymbol (sym->bsym)->native->u.syment.n_type = val;
228 return val;
229 }
230
231 int
232 S_GET_STORAGE_CLASS (sym)
233 symbolS *sym;
234 {
235 return coffsymbol (sym->bsym)->native->u.syment.n_sclass;
236 }
237
238 int
239 S_SET_STORAGE_CLASS (sym, val)
240 symbolS *sym;
241 int val;
242 {
243 coffsymbol (sym->bsym)->native->u.syment.n_sclass = val;
244 return val;
245 }
246
247 /* Merge a debug symbol containing debug information into a normal symbol. */
248
249 void
250 c_symbol_merge (debug, normal)
251 symbolS *debug;
252 symbolS *normal;
253 {
254 S_SET_DATA_TYPE (normal, S_GET_DATA_TYPE (debug));
255 S_SET_STORAGE_CLASS (normal, S_GET_STORAGE_CLASS (debug));
256
257 if (S_GET_NUMBER_AUXILIARY (debug) > S_GET_NUMBER_AUXILIARY (normal))
258 /* take the most we have */
259 S_SET_NUMBER_AUXILIARY (normal, S_GET_NUMBER_AUXILIARY (debug));
260
261 if (S_GET_NUMBER_AUXILIARY (debug) > 0)
262 {
263 /* Move all the auxiliary information. */
264 /* @@ How many fields do we want to preserve? Would it make more
265 sense to pick and choose those we want to copy? Should look
266 into this further.... [raeburn:19920512.2209EST] */
267 alent *linenos;
268 linenos = coffsymbol (normal->bsym)->lineno;
269 memcpy ((char *) &coffsymbol (normal->bsym)->native,
270 (char *) &coffsymbol (debug->bsym)->native,
271 S_GET_NUMBER_AUXILIARY(debug) * AUXESZ);
272 coffsymbol (normal->bsym)->lineno = linenos;
273 }
274
275 /* Move the debug flags. */
276 SF_SET_DEBUG_FIELD (normal, SF_GET_DEBUG_FIELD (debug));
277 }
278
279 static symbolS *previous_file_symbol;
280 void
281 c_dot_file_symbol (filename)
282 char *filename;
283 {
284 symbolS *symbolP;
285
286 symbolP = symbol_new (filename, bfd_abs_section_ptr, 0, &zero_address_frag);
287
288 S_SET_STORAGE_CLASS (symbolP, C_FILE);
289 S_SET_NUMBER_AUXILIARY (symbolP, 1);
290
291 symbolP->bsym->flags = BSF_DEBUGGING;
292
293 #ifndef NO_LISTING
294 {
295 extern int listing;
296 if (listing)
297 {
298 listing_source_file (filename);
299 }
300 }
301 #endif
302
303 S_SET_VALUE (symbolP, (long) previous_file_symbol);
304
305 previous_file_symbol = symbolP;
306
307 /* Make sure that the symbol is first on the symbol chain */
308 if (symbol_rootP != symbolP)
309 {
310 if (symbolP == symbol_lastP)
311 {
312 symbol_lastP = symbol_lastP->sy_previous;
313 } /* if it was the last thing on the list */
314
315 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
316 symbol_insert (symbolP, symbol_rootP, &symbol_rootP, &symbol_lastP);
317 symbol_rootP = symbolP;
318 } /* if not first on the list */
319 }
320
321 /*
322 * Build a 'section static' symbol.
323 */
324
325 char *
326 c_section_symbol (name, value, length, nreloc, nlnno)
327 char *name;
328 long value;
329 long length;
330 unsigned short nreloc;
331 unsigned short nlnno;
332 {
333 symbolS *symbolP;
334
335 symbolP = symbol_new (name,
336 (name[1] == 't'
337 ? text_section
338 : name[1] == 'd'
339 ? data_section
340 : bss_section),
341 value,
342 &zero_address_frag);
343
344 S_SET_STORAGE_CLASS (symbolP, C_STAT);
345 S_SET_NUMBER_AUXILIARY (symbolP, 1);
346
347 SA_SET_SCN_SCNLEN (symbolP, length);
348 SA_SET_SCN_NRELOC (symbolP, nreloc);
349 SA_SET_SCN_NLINNO (symbolP, nlnno);
350
351 SF_SET_STATICS (symbolP);
352
353 return (char *) symbolP;
354 }
355
356 /* Line number handling */
357
358 struct line_no {
359 struct line_no *next;
360 fragS *frag;
361 alent l;
362 };
363
364 int coff_line_base;
365
366 /* Symbol of last function, which we should hang line#s off of. */
367 static symbolS *line_fsym;
368
369 #define in_function() (line_fsym != 0)
370 #define clear_function() (line_fsym = 0)
371 #define set_function(F) (line_fsym = (F), coff_add_linesym (F))
372
373 \f
374 void
375 obj_symbol_new_hook (symbolP)
376 symbolS *symbolP;
377 {
378 char underscore = 0; /* Symbol has leading _ */
379
380 {
381 long sz = (OBJ_COFF_MAX_AUXENTRIES + 1) * sizeof (combined_entry_type);
382 char *s = (char *) bfd_alloc_by_size_t (stdoutput, sz);
383 memset (s, 0, sz);
384 coffsymbol (symbolP->bsym)->native = (combined_entry_type *) s;
385 }
386 S_SET_DATA_TYPE (symbolP, T_NULL);
387 S_SET_STORAGE_CLASS (symbolP, 0);
388 S_SET_NUMBER_AUXILIARY (symbolP, 0);
389
390 if (S_IS_STRING (symbolP))
391 SF_SET_STRING (symbolP);
392 if (!underscore && S_IS_LOCAL (symbolP))
393 SF_SET_LOCAL (symbolP);
394 }
395
396 \f
397 /*
398 * Handle .ln directives.
399 */
400
401 static symbolS *current_lineno_sym;
402 static struct line_no *line_nos;
403 /* @@ Blindly assume all .ln directives will be in the .text section... */
404 static int n_line_nos;
405
406 static void
407 add_lineno (frag, offset, num)
408 fragS *frag;
409 int offset;
410 int num;
411 {
412 struct line_no *new_line = (struct line_no *) bfd_alloc_by_size_t (stdoutput,
413 sizeof (struct line_no));
414 if (!current_lineno_sym)
415 {
416 abort ();
417 }
418 new_line->next = line_nos;
419 new_line->frag = frag;
420 new_line->l.line_number = num;
421 new_line->l.u.offset = offset;
422 line_nos = new_line;
423 n_line_nos++;
424 }
425
426 void
427 coff_add_linesym (sym)
428 symbolS *sym;
429 {
430 if (line_nos)
431 {
432 coffsymbol (current_lineno_sym->bsym)->lineno = (alent *) line_nos;
433 n_line_nos++;
434 line_nos = 0;
435 }
436 current_lineno_sym = sym;
437 }
438
439 static void
440 obj_coff_ln (appline)
441 int appline;
442 {
443 int l;
444
445 if (! appline && def_symbol_in_progress != NULL)
446 {
447 as_warn (".ln pseudo-op inside .def/.endef: ignored.");
448 demand_empty_rest_of_line ();
449 return;
450 }
451
452 l = get_absolute_expression ();
453 if (!appline)
454 {
455 add_lineno (frag_now, frag_now_fix (), l);
456 }
457
458 #ifndef NO_LISTING
459 {
460 extern int listing;
461
462 if (listing)
463 {
464 if (! appline)
465 l += coff_line_base - 1;
466 listing_source_line (l);
467 }
468 }
469 #endif
470
471 demand_empty_rest_of_line ();
472 }
473
474 /*
475 * def()
476 *
477 * Handle .def directives.
478 *
479 * One might ask : why can't we symbol_new if the symbol does not
480 * already exist and fill it with debug information. Because of
481 * the C_EFCN special symbol. It would clobber the value of the
482 * function symbol before we have a chance to notice that it is
483 * a C_EFCN. And a second reason is that the code is more clear this
484 * way. (at least I think it is :-).
485 *
486 */
487
488 #define SKIP_SEMI_COLON() while (*input_line_pointer++ != ';')
489 #define SKIP_WHITESPACES() while (*input_line_pointer == ' ' || \
490 *input_line_pointer == '\t') \
491 input_line_pointer++;
492
493 static void
494 obj_coff_def (what)
495 int what;
496 {
497 char name_end; /* Char after the end of name */
498 char *symbol_name; /* Name of the debug symbol */
499 char *symbol_name_copy; /* Temporary copy of the name */
500 unsigned int symbol_name_length;
501
502 if (def_symbol_in_progress != NULL)
503 {
504 as_warn (".def pseudo-op used inside of .def/.endef: ignored.");
505 demand_empty_rest_of_line ();
506 return;
507 } /* if not inside .def/.endef */
508
509 SKIP_WHITESPACES ();
510
511 symbol_name = input_line_pointer;
512 #ifdef STRIP_UNDERSCORE
513 if (symbol_name[0] == '_' && symbol_name[1] != 0)
514 symbol_name++;
515 #endif /* STRIP_UNDERSCORE */
516
517 name_end = get_symbol_end ();
518 symbol_name_length = strlen (symbol_name);
519 symbol_name_copy = xmalloc (symbol_name_length + 1);
520 strcpy (symbol_name_copy, symbol_name);
521
522 /* Initialize the new symbol */
523 def_symbol_in_progress = symbol_make (symbol_name_copy);
524 def_symbol_in_progress->sy_frag = &zero_address_frag;
525 S_SET_VALUE (def_symbol_in_progress, 0);
526
527 if (S_IS_STRING (def_symbol_in_progress))
528 SF_SET_STRING (def_symbol_in_progress);
529
530 *input_line_pointer = name_end;
531
532 demand_empty_rest_of_line ();
533 }
534
535 unsigned int dim_index;
536
537 static void
538 obj_coff_endef (ignore)
539 int ignore;
540 {
541 symbolS *symbolP;
542 /* DIM BUG FIX sac@cygnus.com */
543 dim_index = 0;
544 if (def_symbol_in_progress == NULL)
545 {
546 as_warn (".endef pseudo-op used outside of .def/.endef: ignored.");
547 demand_empty_rest_of_line ();
548 return;
549 } /* if not inside .def/.endef */
550
551 /* Set the section number according to storage class. */
552 switch (S_GET_STORAGE_CLASS (def_symbol_in_progress))
553 {
554 case C_STRTAG:
555 case C_ENTAG:
556 case C_UNTAG:
557 SF_SET_TAG (def_symbol_in_progress);
558 /* intentional fallthrough */
559 case C_FILE:
560 case C_TPDEF:
561 SF_SET_DEBUG (def_symbol_in_progress);
562 S_SET_SEGMENT (def_symbol_in_progress, fetch_coff_debug_section ());
563 break;
564
565 case C_EFCN:
566 SF_SET_LOCAL (def_symbol_in_progress); /* Do not emit this symbol. */
567 /* intentional fallthrough */
568 case C_BLOCK:
569 SF_SET_PROCESS (def_symbol_in_progress); /* Will need processing before writing */
570 /* intentional fallthrough */
571 case C_FCN:
572 {
573 CONST char *name;
574 S_SET_SEGMENT (def_symbol_in_progress, text_section);
575
576 name = bfd_asymbol_name (def_symbol_in_progress->bsym);
577 if (name[1] == 'b' && name[2] == 'f')
578 {
579 if (! in_function ())
580 as_warn ("`%s' symbol without preceding function", name);
581 /* SA_SET_SYM_LNNO (def_symbol_in_progress, 12345);*/
582 /* Will need relocating */
583 SF_SET_PROCESS (def_symbol_in_progress);
584 clear_function ();
585 }
586 }
587 break;
588
589 #ifdef C_AUTOARG
590 case C_AUTOARG:
591 #endif /* C_AUTOARG */
592 case C_AUTO:
593 case C_REG:
594 case C_MOS:
595 case C_MOE:
596 case C_MOU:
597 case C_ARG:
598 case C_REGPARM:
599 case C_FIELD:
600 case C_EOS:
601 SF_SET_DEBUG (def_symbol_in_progress);
602 S_SET_SEGMENT (def_symbol_in_progress, absolute_section);
603 break;
604
605 case C_EXT:
606 case C_STAT:
607 case C_LABEL:
608 /* Valid but set somewhere else (s_comm, s_lcomm, colon) */
609 break;
610
611 case C_USTATIC:
612 case C_EXTDEF:
613 case C_ULABEL:
614 as_warn ("unexpected storage class %d",
615 S_GET_STORAGE_CLASS (def_symbol_in_progress));
616 break;
617 } /* switch on storage class */
618
619 /* Now that we have built a debug symbol, try to find if we should
620 merge with an existing symbol or not. If a symbol is C_EFCN or
621 SEG_ABSOLUTE or untagged SEG_DEBUG it never merges. */
622
623 /* Two cases for functions. Either debug followed by definition or
624 definition followed by debug. For definition first, we will
625 merge the debug symbol into the definition. For debug first, the
626 lineno entry MUST point to the definition function or else it
627 will point off into space when obj_crawl_symbol_chain() merges
628 the debug symbol into the real symbol. Therefor, let's presume
629 the debug symbol is a real function reference. */
630
631 /* FIXME-SOON If for some reason the definition label/symbol is
632 never seen, this will probably leave an undefined symbol at link
633 time. */
634
635 if (S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_EFCN
636 || (!strcmp (bfd_get_section_name (stdoutput,
637 S_GET_SEGMENT (def_symbol_in_progress)),
638 "*DEBUG*")
639 && !SF_GET_TAG (def_symbol_in_progress))
640 || S_GET_SEGMENT (def_symbol_in_progress) == absolute_section
641 || (symbolP = symbol_find_base (S_GET_NAME (def_symbol_in_progress), DO_NOT_STRIP)) == NULL)
642 {
643 if (def_symbol_in_progress != symbol_lastP)
644 symbol_append (def_symbol_in_progress, symbol_lastP, &symbol_rootP,
645 &symbol_lastP);
646 }
647 else
648 {
649 /* This symbol already exists, merge the newly created symbol
650 into the old one. This is not mandatory. The linker can
651 handle duplicate symbols correctly. But I guess that it save
652 a *lot* of space if the assembly file defines a lot of
653 symbols. [loic] */
654
655 /* The debug entry (def_symbol_in_progress) is merged into the
656 previous definition. */
657
658 c_symbol_merge (def_symbol_in_progress, symbolP);
659 /* FIXME-SOON Should *def_symbol_in_progress be free'd? xoxorich. */
660 def_symbol_in_progress = symbolP;
661
662 if (SF_GET_FUNCTION (def_symbol_in_progress)
663 || SF_GET_TAG (def_symbol_in_progress))
664 {
665 /* For functions, and tags, the symbol *must* be where the
666 debug symbol appears. Move the existing symbol to the
667 current place. */
668 /* If it already is at the end of the symbol list, do nothing */
669 if (def_symbol_in_progress != symbol_lastP)
670 {
671 symbol_remove (def_symbol_in_progress, &symbol_rootP, &symbol_lastP);
672 symbol_append (def_symbol_in_progress, symbol_lastP, &symbol_rootP, &symbol_lastP);
673 }
674 }
675 }
676
677 if (SF_GET_TAG (def_symbol_in_progress)
678 && symbol_find_base (S_GET_NAME (def_symbol_in_progress), DO_NOT_STRIP) == NULL)
679 {
680 tag_insert (S_GET_NAME (def_symbol_in_progress), def_symbol_in_progress);
681 }
682
683 if (SF_GET_FUNCTION (def_symbol_in_progress))
684 {
685 know (sizeof (def_symbol_in_progress) <= sizeof (long));
686 set_function (def_symbol_in_progress);
687 SF_SET_PROCESS (def_symbol_in_progress);
688
689 if (symbolP == NULL)
690 {
691 /* That is, if this is the first time we've seen the
692 function... */
693 symbol_table_insert (def_symbol_in_progress);
694 } /* definition follows debug */
695 } /* Create the line number entry pointing to the function being defined */
696
697 def_symbol_in_progress = NULL;
698 demand_empty_rest_of_line ();
699 }
700
701 static void
702 obj_coff_dim (ignore)
703 int ignore;
704 {
705 int dim_index;
706
707 if (def_symbol_in_progress == NULL)
708 {
709 as_warn (".dim pseudo-op used outside of .def/.endef: ignored.");
710 demand_empty_rest_of_line ();
711 return;
712 } /* if not inside .def/.endef */
713
714 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
715
716 for (dim_index = 0; dim_index < DIMNUM; dim_index++)
717 {
718 SKIP_WHITESPACES ();
719 SA_SET_SYM_DIMEN (def_symbol_in_progress, dim_index,
720 get_absolute_expression ());
721
722 switch (*input_line_pointer)
723 {
724 case ',':
725 input_line_pointer++;
726 break;
727
728 default:
729 as_warn ("badly formed .dim directive ignored");
730 /* intentional fallthrough */
731 case '\n':
732 case ';':
733 dim_index = DIMNUM;
734 break;
735 }
736 }
737
738 demand_empty_rest_of_line ();
739 }
740
741 static void
742 obj_coff_line (ignore)
743 int ignore;
744 {
745 int this_base;
746
747 if (def_symbol_in_progress == NULL)
748 {
749 /* Probably stabs-style line? */
750 obj_coff_ln (0);
751 return;
752 }
753
754 this_base = get_absolute_expression ();
755 if (!strcmp (".bf", S_GET_NAME (def_symbol_in_progress)))
756 coff_line_base = this_base;
757
758 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
759 SA_SET_SYM_LNNO (def_symbol_in_progress, coff_line_base);
760
761 demand_empty_rest_of_line ();
762 }
763
764 static void
765 obj_coff_size (ignore)
766 int ignore;
767 {
768 if (def_symbol_in_progress == NULL)
769 {
770 as_warn (".size pseudo-op used outside of .def/.endef ignored.");
771 demand_empty_rest_of_line ();
772 return;
773 } /* if not inside .def/.endef */
774
775 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
776 SA_SET_SYM_SIZE (def_symbol_in_progress, get_absolute_expression ());
777 demand_empty_rest_of_line ();
778 }
779
780 static void
781 obj_coff_scl (ignore)
782 int ignore;
783 {
784 if (def_symbol_in_progress == NULL)
785 {
786 as_warn (".scl pseudo-op used outside of .def/.endef ignored.");
787 demand_empty_rest_of_line ();
788 return;
789 } /* if not inside .def/.endef */
790
791 S_SET_STORAGE_CLASS (def_symbol_in_progress, get_absolute_expression ());
792 demand_empty_rest_of_line ();
793 }
794
795 static void
796 obj_coff_tag (ignore)
797 int ignore;
798 {
799 char *symbol_name;
800 char name_end;
801
802 if (def_symbol_in_progress == NULL)
803 {
804 as_warn (".tag pseudo-op used outside of .def/.endef ignored.");
805 demand_empty_rest_of_line ();
806 return;
807 }
808
809 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
810 symbol_name = input_line_pointer;
811 name_end = get_symbol_end ();
812
813 /* Assume that the symbol referred to by .tag is always defined.
814 This was a bad assumption. I've added find_or_make. xoxorich. */
815 SA_SET_SYM_TAGNDX (def_symbol_in_progress,
816 tag_find_or_make (symbol_name));
817 if (SA_GET_SYM_TAGNDX (def_symbol_in_progress) == 0L)
818 {
819 as_warn ("tag not found for .tag %s", symbol_name);
820 } /* not defined */
821
822 SF_SET_TAGGED (def_symbol_in_progress);
823 *input_line_pointer = name_end;
824
825 demand_empty_rest_of_line ();
826 }
827
828 static void
829 obj_coff_type (ignore)
830 int ignore;
831 {
832 if (def_symbol_in_progress == NULL)
833 {
834 as_warn (".type pseudo-op used outside of .def/.endef ignored.");
835 demand_empty_rest_of_line ();
836 return;
837 } /* if not inside .def/.endef */
838
839 S_SET_DATA_TYPE (def_symbol_in_progress, get_absolute_expression ());
840
841 if (ISFCN (S_GET_DATA_TYPE (def_symbol_in_progress)) &&
842 S_GET_STORAGE_CLASS (def_symbol_in_progress) != C_TPDEF)
843 {
844 SF_SET_FUNCTION (def_symbol_in_progress);
845 } /* is a function */
846
847 demand_empty_rest_of_line ();
848 }
849
850 static void
851 obj_coff_val (ignore)
852 int ignore;
853 {
854 if (def_symbol_in_progress == NULL)
855 {
856 as_warn (".val pseudo-op used outside of .def/.endef ignored.");
857 demand_empty_rest_of_line ();
858 return;
859 } /* if not inside .def/.endef */
860
861 if (is_name_beginner (*input_line_pointer))
862 {
863 char *symbol_name = input_line_pointer;
864 char name_end = get_symbol_end ();
865
866 if (!strcmp (symbol_name, "."))
867 {
868 def_symbol_in_progress->sy_frag = frag_now;
869 S_SET_VALUE (def_symbol_in_progress, (valueT) frag_now_fix ());
870 /* If the .val is != from the .def (e.g. statics) */
871 }
872 else if (strcmp (S_GET_NAME (def_symbol_in_progress), symbol_name))
873 {
874 def_symbol_in_progress->sy_value.X_op = O_symbol;
875 def_symbol_in_progress->sy_value.X_add_symbol =
876 symbol_find_or_make (symbol_name);
877 def_symbol_in_progress->sy_value.X_op_symbol = NULL;
878 def_symbol_in_progress->sy_value.X_add_number = 0;
879
880 /* If the segment is undefined when the forward reference is
881 resolved, then copy the segment id from the forward
882 symbol. */
883 SF_SET_GET_SEGMENT (def_symbol_in_progress);
884 }
885 /* Otherwise, it is the name of a non debug symbol and its value will be calculated later. */
886 *input_line_pointer = name_end;
887 }
888 else
889 {
890 S_SET_VALUE (def_symbol_in_progress, get_absolute_expression ());
891 } /* if symbol based */
892
893 demand_empty_rest_of_line ();
894 }
895
896 void
897 obj_read_begin_hook ()
898 {
899 /* These had better be the same. Usually 18 bytes. */
900 #ifndef BFD_HEADERS
901 know (sizeof (SYMENT) == sizeof (AUXENT));
902 know (SYMESZ == AUXESZ);
903 #endif
904 tag_init ();
905 }
906
907
908 symbolS *coff_last_function;
909
910 void
911 coff_frob_symbol (symp, punt)
912 symbolS *symp;
913 int *punt;
914 {
915 static symbolS *last_tagP;
916 static stack *block_stack;
917 static symbolS *set_end;
918
919 if (symp == &abs_symbol)
920 {
921 *punt = 1;
922 return;
923 }
924
925 if (current_lineno_sym)
926 coff_add_linesym ((symbolS *) 0);
927
928 if (!block_stack)
929 block_stack = stack_init (512, sizeof (symbolS*));
930
931 if (!S_IS_DEFINED (symp) && S_GET_STORAGE_CLASS (symp) != C_STAT)
932 S_SET_STORAGE_CLASS (symp, C_EXT);
933
934 if (!SF_GET_DEBUG (symp))
935 {
936 symbolS *real;
937 if (!SF_GET_LOCAL (symp)
938 && (real = symbol_find_base (S_GET_NAME (symp), DO_NOT_STRIP))
939 && real != symp)
940 {
941 c_symbol_merge (symp, real);
942 *punt = 1;
943 }
944 if (!S_IS_DEFINED (symp) && !SF_GET_LOCAL (symp))
945 {
946 assert (S_GET_VALUE (symp) == 0);
947 S_SET_EXTERNAL (symp);
948 }
949 else if (S_GET_STORAGE_CLASS (symp) == C_NULL)
950 {
951 if (S_GET_SEGMENT (symp) == text_section
952 && symp != seg_info (text_section)->sym)
953 S_SET_STORAGE_CLASS (symp, C_LABEL);
954 else
955 S_SET_STORAGE_CLASS (symp, C_STAT);
956 }
957 if (SF_GET_PROCESS (symp))
958 {
959 if (S_GET_STORAGE_CLASS (symp) == C_BLOCK)
960 {
961 if (!strcmp (S_GET_NAME (symp), ".bb"))
962 stack_push (block_stack, (char *) &symp);
963 else
964 {
965 symbolS *begin;
966 begin = *(symbolS **) stack_pop (block_stack);
967 if (begin == 0)
968 as_warn ("mismatched .eb");
969 else
970 set_end = begin;
971 }
972 }
973 if (coff_last_function == 0 && SF_GET_FUNCTION (symp))
974 {
975 union internal_auxent *auxp;
976 coff_last_function = symp;
977 if (S_GET_NUMBER_AUXILIARY (symp) < 1)
978 S_SET_NUMBER_AUXILIARY (symp, 1);
979 auxp = &coffsymbol (symp->bsym)->native[1].u.auxent;
980 memset (auxp->x_sym.x_fcnary.x_ary.x_dimen, 0,
981 sizeof (auxp->x_sym.x_fcnary.x_ary.x_dimen));
982 }
983 if (S_GET_STORAGE_CLASS (symp) == C_EFCN)
984 {
985 if (coff_last_function == 0)
986 as_fatal ("C_EFCN symbol out of scope");
987 SA_SET_SYM_FSIZE (coff_last_function,
988 (long) (S_GET_VALUE (symp)
989 - S_GET_VALUE (coff_last_function)));
990 set_end = coff_last_function;
991 coff_last_function = 0;
992 }
993 }
994 else if (SF_GET_TAG (symp))
995 last_tagP = symp;
996 else if (S_GET_STORAGE_CLASS (symp) == C_EOS)
997 set_end = last_tagP;
998 else if (S_GET_STORAGE_CLASS (symp) == C_FILE)
999 {
1000 if (S_GET_VALUE (symp))
1001 {
1002 S_SET_VALUE ((symbolS *) S_GET_VALUE (symp), 0xdeadbeef);
1003 S_SET_VALUE (symp, 0);
1004 }
1005 }
1006 if (S_IS_EXTERNAL (symp))
1007 S_SET_STORAGE_CLASS (symp, C_EXT);
1008 else if (SF_GET_LOCAL (symp))
1009 *punt = 1;
1010 /* more ... */
1011 }
1012
1013 if (set_end != (symbolS *) NULL
1014 && ! *punt)
1015 {
1016 SA_SET_SYM_ENDNDX (set_end, symp);
1017 set_end = NULL;
1018 }
1019
1020 if (coffsymbol (symp->bsym)->lineno)
1021 {
1022 int i;
1023 struct line_no *lptr;
1024 alent *l;
1025
1026 lptr = (struct line_no *) coffsymbol (symp->bsym)->lineno;
1027 for (i = 0; lptr; lptr = lptr->next)
1028 i++;
1029 lptr = (struct line_no *) coffsymbol (symp->bsym)->lineno;
1030
1031 /* We need i entries for line numbers, plus 1 for the first
1032 entry which BFD will override, plus 1 for the last zero
1033 entry (a marker for BFD). */
1034 l = (alent *) bfd_alloc_by_size_t (stdoutput, (i + 2) * sizeof (alent));
1035 coffsymbol (symp->bsym)->lineno = l;
1036 l[i + 1].line_number = 0;
1037 l[i + 1].u.sym = NULL;
1038 for (; i > 0; i--)
1039 {
1040 if (lptr->frag)
1041 lptr->l.u.offset += lptr->frag->fr_address;
1042 l[i] = lptr->l;
1043 lptr = lptr->next;
1044 }
1045 }
1046 }
1047
1048 void
1049 coff_adjust_section_syms (abfd, sec, x)
1050 bfd *abfd;
1051 asection *sec;
1052 PTR x;
1053 {
1054 symbolS *secsym;
1055 segment_info_type *seginfo = seg_info (sec);
1056 int nlnno, nrelocs = 0;
1057
1058 /* RS/6000 gas creates a .debug section manually in ppc_frob_file in
1059 tc-ppc.c. Do not get confused by it. */
1060 if (seginfo == NULL)
1061 return;
1062
1063 if (!strcmp (sec->name, ".text"))
1064 nlnno = n_line_nos;
1065 else
1066 nlnno = 0;
1067 {
1068 /* @@ Hope that none of the fixups expand to more than one reloc
1069 entry... */
1070 fixS *fixp = seginfo->fix_root;
1071 while (fixp)
1072 {
1073 fixp = fixp->fx_next;
1074 nrelocs++;
1075 }
1076 }
1077 if (bfd_get_section_size_before_reloc (sec) == 0
1078 && nrelocs == 0 && nlnno == 0)
1079 return;
1080 secsym = section_symbol (sec);
1081 SA_SET_SCN_NRELOC (secsym, nrelocs);
1082 SA_SET_SCN_NLINNO (secsym, nlnno);
1083 }
1084
1085 void
1086 coff_frob_file ()
1087 {
1088 bfd_map_over_sections (stdoutput, coff_adjust_section_syms, (char*) 0);
1089 }
1090
1091 /*
1092 * implement the .section pseudo op:
1093 * .section name {, "flags"}
1094 * ^ ^
1095 * | +--- optional flags: 'b' for bss
1096 * | 'i' for info
1097 * +-- section name 'l' for lib
1098 * 'n' for noload
1099 * 'o' for over
1100 * 'w' for data
1101 * 'd' (apparently m88k for data)
1102 * 'x' for text
1103 * But if the argument is not a quoted string, treat it as a
1104 * subsegment number.
1105 */
1106
1107 void
1108 obj_coff_section (ignore)
1109 int ignore;
1110 {
1111 /* Strip out the section name */
1112 char *section_name;
1113 char c;
1114 char *name;
1115 unsigned int exp;
1116 flagword flags;
1117 asection *sec;
1118
1119 section_name = input_line_pointer;
1120 c = get_symbol_end ();
1121
1122 name = xmalloc (input_line_pointer - section_name + 1);
1123 strcpy (name, section_name);
1124
1125 *input_line_pointer = c;
1126
1127 SKIP_WHITESPACE ();
1128
1129 exp = 0;
1130 flags = SEC_NO_FLAGS;
1131
1132 if (*input_line_pointer == ',')
1133 {
1134 ++input_line_pointer;
1135 SKIP_WHITESPACE ();
1136 if (*input_line_pointer != '"')
1137 exp = get_absolute_expression ();
1138 else
1139 {
1140 ++input_line_pointer;
1141 while (*input_line_pointer != '"'
1142 && ! is_end_of_line[(unsigned char) *input_line_pointer])
1143 {
1144 switch (*input_line_pointer)
1145 {
1146 case 'b': flags |= SEC_ALLOC; flags &=~ SEC_LOAD; break;
1147 case 'n': flags &=~ SEC_LOAD; break;
1148 case 'd':
1149 case 'w': flags &=~ SEC_READONLY; break;
1150 case 'x': flags |= SEC_CODE; break;
1151
1152 case 'i': /* STYP_INFO */
1153 case 'l': /* STYP_LIB */
1154 case 'o': /* STYP_OVER */
1155 as_warn ("unsupported section attribute '%c'",
1156 *input_line_pointer);
1157 break;
1158
1159 default:
1160 as_warn("unknown section attribute '%c'",
1161 *input_line_pointer);
1162 break;
1163 }
1164 ++input_line_pointer;
1165 }
1166 if (*input_line_pointer == '"')
1167 ++input_line_pointer;
1168 }
1169 }
1170
1171 sec = subseg_new (name, (subsegT) exp);
1172
1173 if (flags != SEC_NO_FLAGS)
1174 {
1175 if (! bfd_set_section_flags (stdoutput, sec, flags))
1176 as_warn ("error setting flags for \"%s\": %s",
1177 bfd_section_name (stdoutput, sec),
1178 bfd_errmsg (bfd_get_error ()));
1179 }
1180 }
1181
1182 void
1183 coff_adjust_symtab ()
1184 {
1185 if (symbol_rootP == NULL
1186 || S_GET_STORAGE_CLASS (symbol_rootP) != C_FILE)
1187 {
1188 assert (previous_file_symbol == 0);
1189 c_dot_file_symbol ("fake");
1190 }
1191 }
1192
1193 void
1194 coff_frob_section (sec)
1195 segT sec;
1196 {
1197 segT strsec;
1198 char *strname, *p;
1199 fragS *fragp;
1200 bfd_vma size, n_entries, mask;
1201
1202 /* The COFF back end in BFD requires that all section sizes be
1203 rounded up to multiples of the corresponding section alignments.
1204 Seems kinda silly to me, but that's the way it is. */
1205 size = bfd_get_section_size_before_reloc (sec);
1206 mask = ((bfd_vma) 1 << (bfd_vma) sec->alignment_power) - 1;
1207 if (size & mask)
1208 {
1209 size = (size + mask) & ~mask;
1210 bfd_set_section_size (stdoutput, sec, size);
1211 }
1212
1213 /* If the section size is non-zero, the section symbol needs an aux
1214 entry associated with it, indicating the size. We don't know
1215 all the values yet; coff_frob_symbol will fill them in later. */
1216 if (size)
1217 {
1218 symbolS *secsym = section_symbol (sec);
1219
1220 S_SET_STORAGE_CLASS (secsym, C_STAT);
1221 S_SET_NUMBER_AUXILIARY (secsym, 1);
1222 SF_SET_STATICS (secsym);
1223 SA_SET_SCN_SCNLEN (secsym, size);
1224 }
1225
1226 /* @@ these should be in a "stabs.h" file, or maybe as.h */
1227 #ifndef STAB_SECTION_NAME
1228 #define STAB_SECTION_NAME ".stab"
1229 #endif
1230 #ifndef STAB_STRING_SECTION_NAME
1231 #define STAB_STRING_SECTION_NAME ".stabstr"
1232 #endif
1233 if (strcmp (STAB_STRING_SECTION_NAME, sec->name))
1234 return;
1235
1236 strsec = sec;
1237 sec = subseg_get (STAB_SECTION_NAME, 0);
1238 /* size is already rounded up, since other section will be listed first */
1239 size = bfd_get_section_size_before_reloc (strsec);
1240
1241 n_entries = bfd_get_section_size_before_reloc (sec) / 12 - 1;
1242
1243 /* Find first non-empty frag. It should be large enough. */
1244 fragp = seg_info (sec)->frchainP->frch_root;
1245 while (fragp && fragp->fr_fix == 0)
1246 fragp = fragp->fr_next;
1247 assert (fragp != 0 && fragp->fr_fix >= 12);
1248
1249 /* Store the values. */
1250 p = fragp->fr_literal;
1251 bfd_h_put_16 (stdoutput, n_entries, (bfd_byte *) p + 6);
1252 bfd_h_put_32 (stdoutput, size, (bfd_byte *) p + 8);
1253 }
1254
1255 void
1256 obj_coff_init_stab_section (seg)
1257 segT seg;
1258 {
1259 char *file;
1260 char *p;
1261 char *stabstr_name;
1262 unsigned int stroff;
1263
1264 /* Make space for this first symbol. */
1265 p = frag_more (12);
1266 /* Zero it out. */
1267 memset (p, 0, 12);
1268 as_where (&file, (unsigned int *) NULL);
1269 stabstr_name = (char *) alloca (strlen (seg->name) + 4);
1270 strcpy (stabstr_name, seg->name);
1271 strcat (stabstr_name, "str");
1272 stroff = get_stab_string_offset (file, stabstr_name);
1273 know (stroff == 1);
1274 md_number_to_chars (p, stroff, 4);
1275 }
1276
1277 #ifdef DEBUG
1278 /* for debugging */
1279 const char *
1280 s_get_name (s)
1281 symbolS *s;
1282 {
1283 return ((s == NULL) ? "(NULL)" : S_GET_NAME (s));
1284 }
1285
1286 void
1287 symbol_dump ()
1288 {
1289 symbolS *symbolP;
1290
1291 for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next (symbolP))
1292 {
1293 printf("0x%lx: \"%s\" type = %ld, class = %d, segment = %d\n",
1294 (unsigned long) symbolP,
1295 S_GET_NAME(symbolP),
1296 (long) S_GET_DATA_TYPE(symbolP),
1297 S_GET_STORAGE_CLASS(symbolP),
1298 (int) S_GET_SEGMENT(symbolP));
1299 }
1300 }
1301
1302 #endif /* DEBUG */
1303
1304 #else /* not BFD_ASSEMBLER */
1305
1306 #include "frags.h"
1307 /* This is needed because we include internal bfd things. */
1308 #include <time.h>
1309 #include "bfd/libbfd.h"
1310 #include "bfd/libcoff.h"
1311
1312 /* The NOP_OPCODE is for the alignment fill value. Fill with nop so
1313 that we can stick sections together without causing trouble. */
1314 #ifndef NOP_OPCODE
1315 #define NOP_OPCODE 0x00
1316 #endif
1317
1318 /* The zeroes if symbol name is longer than 8 chars */
1319 #define S_SET_ZEROES(s,v) ((s)->sy_symbol.ost_entry.n_zeroes = (v))
1320
1321 #define MIN(a,b) ((a) < (b)? (a) : (b))
1322 /* This vector is used to turn an internal segment into a section #
1323 suitable for insertion into a coff symbol table
1324 */
1325
1326 const short seg_N_TYPE[] =
1327 { /* in: segT out: N_TYPE bits */
1328 C_ABS_SECTION,
1329 1,
1330 2,
1331 3,
1332 4,
1333 5,
1334 6,
1335 7,
1336 8,
1337 9,
1338 10,
1339 C_UNDEF_SECTION, /* SEG_UNKNOWN */
1340 C_UNDEF_SECTION, /* SEG_GOOF */
1341 C_UNDEF_SECTION, /* SEG_EXPR */
1342 C_DEBUG_SECTION, /* SEG_DEBUG */
1343 C_NTV_SECTION, /* SEG_NTV */
1344 C_PTV_SECTION, /* SEG_PTV */
1345 C_REGISTER_SECTION, /* SEG_REGISTER */
1346 };
1347
1348 int function_lineoff = -1; /* Offset in line#s where the last function
1349 started (the odd entry for line #0) */
1350
1351 static symbolS *last_line_symbol;
1352
1353 /* Add 4 to the real value to get the index and compensate the
1354 negatives. This vector is used by S_GET_SEGMENT to turn a coff
1355 section number into a segment number
1356 */
1357 static symbolS *previous_file_symbol;
1358 void c_symbol_merge ();
1359 static int line_base;
1360
1361 symbolS *c_section_symbol ();
1362 bfd *abfd;
1363
1364 static void fixup_segment PARAMS ((segment_info_type *segP,
1365 segT this_segment_type));
1366
1367
1368 static void fixup_mdeps PARAMS ((fragS *,
1369 object_headers *,
1370 segT));
1371
1372
1373 static void fill_section PARAMS ((bfd * abfd,
1374 object_headers *,
1375 unsigned long *));
1376
1377
1378 static int c_line_new PARAMS ((symbolS * symbol, long paddr,
1379 int line_number,
1380 fragS * frag));
1381
1382
1383 static void w_symbols PARAMS ((bfd * abfd, char *where,
1384 symbolS * symbol_rootP));
1385
1386 static void adjust_stab_section PARAMS ((bfd *abfd, segT seg));
1387
1388 static void obj_coff_lcomm PARAMS ((int));
1389 static void obj_coff_text PARAMS ((int));
1390 static void obj_coff_data PARAMS ((int));
1391 static void obj_coff_bss PARAMS ((int));
1392 static void obj_coff_ident PARAMS ((int));
1393 void obj_coff_section PARAMS ((int));
1394
1395 /* Section stuff
1396
1397 We allow more than just the standard 3 sections, infact, we allow
1398 10 sections, (though the usual three have to be there).
1399
1400 This structure performs the mappings for us:
1401
1402 */
1403
1404 #define N_SEG 32
1405 typedef struct
1406 {
1407 segT seg_t;
1408 int i;
1409 } seg_info_type;
1410
1411 static const seg_info_type seg_info_off_by_4[N_SEG] =
1412 {
1413 {SEG_PTV, },
1414 {SEG_NTV, },
1415 {SEG_DEBUG, },
1416 {SEG_ABSOLUTE, },
1417 {SEG_UNKNOWN, },
1418 {SEG_E0},
1419 {SEG_E1},
1420 {SEG_E2},
1421 {SEG_E3},
1422 {SEG_E4},
1423 {SEG_E5},
1424 {SEG_E6},
1425 {SEG_E7},
1426 {SEG_E8},
1427 {SEG_E9},
1428 {(segT)15},
1429 {(segT)16},
1430 {(segT)17},
1431 {(segT)18},
1432 {(segT)19},
1433 {(segT)20},
1434 {(segT)0},
1435 {(segT)0},
1436 {(segT)0},
1437 {SEG_REGISTER}
1438 };
1439
1440
1441
1442 #define SEG_INFO_FROM_SECTION_NUMBER(x) (seg_info_off_by_4[(x)+4])
1443
1444 static relax_addressT
1445 relax_align (address, alignment)
1446 relax_addressT address;
1447 long alignment;
1448 {
1449 relax_addressT mask;
1450 relax_addressT new_address;
1451
1452 mask = ~((~0) << alignment);
1453 new_address = (address + mask) & (~mask);
1454 return (new_address - address);
1455 }
1456
1457
1458 segT
1459 s_get_segment (x)
1460 symbolS * x;
1461 {
1462 return SEG_INFO_FROM_SECTION_NUMBER (x->sy_symbol.ost_entry.n_scnum).seg_t;
1463 }
1464
1465
1466
1467 /* calculate the size of the frag chain and fill in the section header
1468 to contain all of it, also fill in the addr of the sections */
1469 static unsigned int
1470 size_section (abfd, idx)
1471 bfd * abfd;
1472 unsigned int idx;
1473 {
1474
1475 unsigned int size = 0;
1476 fragS *frag = segment_info[idx].frchainP->frch_root;
1477 while (frag)
1478 {
1479 size = frag->fr_address;
1480 if (frag->fr_address != size)
1481 {
1482 fprintf (stderr, "Out of step\n");
1483 size = frag->fr_address;
1484 }
1485
1486 switch (frag->fr_type)
1487 {
1488 #ifdef TC_COFF_SIZEMACHDEP
1489 case rs_machine_dependent:
1490 size += TC_COFF_SIZEMACHDEP (frag);
1491 break;
1492 #endif
1493 case rs_space:
1494 assert (frag->fr_symbol == 0);
1495 case rs_fill:
1496 case rs_org:
1497 size += frag->fr_fix;
1498 size += frag->fr_offset * frag->fr_var;
1499 break;
1500 case rs_align:
1501 size += frag->fr_fix;
1502 size += relax_align (size, frag->fr_offset);
1503 break;
1504 default:
1505 BAD_CASE (frag->fr_type);
1506 break;
1507 }
1508 frag = frag->fr_next;
1509 }
1510 segment_info[idx].scnhdr.s_size = size;
1511 return size;
1512 }
1513
1514
1515 static unsigned int
1516 count_entries_in_chain (idx)
1517 unsigned int idx;
1518 {
1519 unsigned int nrelocs;
1520 fixS *fixup_ptr;
1521
1522 /* Count the relocations */
1523 fixup_ptr = segment_info[idx].fix_root;
1524 nrelocs = 0;
1525 while (fixup_ptr != (fixS *) NULL)
1526 {
1527 if (TC_COUNT_RELOC (fixup_ptr))
1528 {
1529 #ifdef TC_A29K
1530 if (fixup_ptr->fx_r_type == RELOC_CONSTH)
1531 nrelocs += 2;
1532 else
1533 nrelocs++;
1534 #else
1535 nrelocs++;
1536 #endif
1537 }
1538
1539 fixup_ptr = fixup_ptr->fx_next;
1540 }
1541 return nrelocs;
1542 }
1543
1544 /* output all the relocations for a section */
1545 void
1546 do_relocs_for (abfd, h, file_cursor)
1547 bfd * abfd;
1548 object_headers * h;
1549 unsigned long *file_cursor;
1550 {
1551 unsigned int nrelocs;
1552 unsigned int idx;
1553 unsigned long reloc_start = *file_cursor;
1554
1555 for (idx = SEG_E0; idx < SEG_E9; idx++)
1556 {
1557 if (segment_info[idx].scnhdr.s_name[0])
1558 {
1559 struct external_reloc *ext_ptr;
1560 struct external_reloc *external_reloc_vec;
1561 unsigned int external_reloc_size;
1562 unsigned int base = segment_info[idx].scnhdr.s_paddr;
1563 fixS *fix_ptr = segment_info[idx].fix_root;
1564 nrelocs = count_entries_in_chain (idx);
1565
1566 if (nrelocs)
1567 /* Bypass this stuff if no relocs. This also incidentally
1568 avoids a SCO bug, where free(malloc(0)) tends to crash. */
1569 {
1570 external_reloc_size = nrelocs * RELSZ;
1571 external_reloc_vec =
1572 (struct external_reloc *) malloc (external_reloc_size);
1573
1574 ext_ptr = external_reloc_vec;
1575
1576 /* Fill in the internal coff style reloc struct from the
1577 internal fix list. */
1578 while (fix_ptr)
1579 {
1580 struct internal_reloc intr;
1581
1582 /* Only output some of the relocations */
1583 if (TC_COUNT_RELOC (fix_ptr))
1584 {
1585 #ifdef TC_RELOC_MANGLE
1586 TC_RELOC_MANGLE (fix_ptr, &intr, base);
1587
1588 #else
1589 symbolS *dot;
1590 symbolS *symbol_ptr = fix_ptr->fx_addsy;
1591
1592 intr.r_type = TC_COFF_FIX2RTYPE (fix_ptr);
1593 intr.r_vaddr =
1594 base + fix_ptr->fx_frag->fr_address + fix_ptr->fx_where;
1595
1596 #ifdef TC_KEEP_FX_OFFSET
1597 intr.r_offset = fix_ptr->fx_offset;
1598 #else
1599 intr.r_offset = 0;
1600 #endif
1601
1602 /* Turn the segment of the symbol into an offset. */
1603 if (symbol_ptr)
1604 {
1605 dot = segment_info[S_GET_SEGMENT (symbol_ptr)].dot;
1606 if (dot)
1607 {
1608 intr.r_symndx = dot->sy_number;
1609 }
1610 else
1611 {
1612 intr.r_symndx = symbol_ptr->sy_number;
1613 }
1614
1615 }
1616 else
1617 {
1618 intr.r_symndx = -1;
1619 }
1620 #endif
1621
1622 (void) bfd_coff_swap_reloc_out (abfd, &intr, ext_ptr);
1623 ext_ptr++;
1624
1625 #if defined(TC_A29K)
1626
1627 /* The 29k has a special kludge for the high 16 bit
1628 reloc. Two relocations are emited, R_IHIHALF,
1629 and R_IHCONST. The second one doesn't contain a
1630 symbol, but uses the value for offset. */
1631
1632 if (intr.r_type == R_IHIHALF)
1633 {
1634 /* now emit the second bit */
1635 intr.r_type = R_IHCONST;
1636 intr.r_symndx = fix_ptr->fx_addnumber;
1637 (void) bfd_coff_swap_reloc_out (abfd, &intr, ext_ptr);
1638 ext_ptr++;
1639 }
1640 #endif
1641 }
1642
1643 fix_ptr = fix_ptr->fx_next;
1644 }
1645
1646 /* Write out the reloc table */
1647 bfd_write ((PTR) external_reloc_vec, 1, external_reloc_size,
1648 abfd);
1649 free (external_reloc_vec);
1650
1651 /* Fill in section header info. */
1652 segment_info[idx].scnhdr.s_relptr = *file_cursor;
1653 *file_cursor += external_reloc_size;
1654 segment_info[idx].scnhdr.s_nreloc = nrelocs;
1655 }
1656 else
1657 {
1658 /* No relocs */
1659 segment_info[idx].scnhdr.s_relptr = 0;
1660 }
1661 }
1662 }
1663 /* Set relocation_size field in file headers */
1664 H_SET_RELOCATION_SIZE (h, *file_cursor - reloc_start, 0);
1665 }
1666
1667
1668 /* run through a frag chain and write out the data to go with it, fill
1669 in the scnhdrs with the info on the file postions
1670 */
1671 static void
1672 fill_section (abfd, h, file_cursor)
1673 bfd * abfd;
1674 object_headers *h;
1675 unsigned long *file_cursor;
1676 {
1677
1678 unsigned int i;
1679 unsigned int paddr = 0;
1680
1681 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
1682 {
1683 unsigned int offset = 0;
1684
1685 struct internal_scnhdr *s = &(segment_info[i].scnhdr);
1686
1687 if (s->s_name[0])
1688 {
1689 fragS *frag = segment_info[i].frchainP->frch_root;
1690 char *buffer;
1691
1692 if (s->s_size == 0)
1693 s->s_scnptr = 0;
1694 else
1695 {
1696 buffer = xmalloc (s->s_size);
1697 s->s_scnptr = *file_cursor;
1698 }
1699 know (s->s_paddr == paddr);
1700
1701 if (strcmp (s->s_name, ".text") == 0)
1702 s->s_flags |= STYP_TEXT;
1703 else if (strcmp (s->s_name, ".data") == 0)
1704 s->s_flags |= STYP_DATA;
1705 else if (strcmp (s->s_name, ".bss") == 0)
1706 {
1707 s->s_scnptr = 0;
1708 s->s_flags |= STYP_BSS;
1709
1710 /* @@ Should make the i386 and a29k coff targets define
1711 COFF_NOLOAD_PROBLEM, and have only one test here. */
1712 #ifndef TC_I386
1713 #ifndef TC_A29K
1714 #ifndef COFF_NOLOAD_PROBLEM
1715 /* Apparently the SVR3 linker (and exec syscall) and UDI
1716 mondfe progrem are confused by noload sections. */
1717 s->s_flags |= STYP_NOLOAD;
1718 #endif
1719 #endif
1720 #endif
1721 }
1722 else if (strcmp (s->s_name, ".lit") == 0)
1723 s->s_flags = STYP_LIT | STYP_TEXT;
1724 else if (strcmp (s->s_name, ".init") == 0)
1725 s->s_flags |= STYP_TEXT;
1726 else if (strcmp (s->s_name, ".fini") == 0)
1727 s->s_flags |= STYP_TEXT;
1728 else if (strncmp (s->s_name, ".comment", 8) == 0)
1729 s->s_flags |= STYP_INFO;
1730
1731 while (frag)
1732 {
1733 unsigned int fill_size;
1734 switch (frag->fr_type)
1735 {
1736 case rs_machine_dependent:
1737 if (frag->fr_fix)
1738 {
1739 memcpy (buffer + frag->fr_address,
1740 frag->fr_literal,
1741 (unsigned int) frag->fr_fix);
1742 offset += frag->fr_fix;
1743 }
1744
1745 break;
1746 case rs_space:
1747 assert (frag->fr_symbol == 0);
1748 case rs_fill:
1749 case rs_align:
1750 case rs_org:
1751 if (frag->fr_fix)
1752 {
1753 memcpy (buffer + frag->fr_address,
1754 frag->fr_literal,
1755 (unsigned int) frag->fr_fix);
1756 offset += frag->fr_fix;
1757 }
1758
1759 fill_size = frag->fr_var;
1760 if (fill_size && frag->fr_offset > 0)
1761 {
1762 unsigned int count;
1763 unsigned int off = frag->fr_fix;
1764 for (count = frag->fr_offset; count; count--)
1765 {
1766 if (fill_size + frag->fr_address + off <= s->s_size)
1767 {
1768 memcpy (buffer + frag->fr_address + off,
1769 frag->fr_literal + frag->fr_fix,
1770 fill_size);
1771 off += fill_size;
1772 offset += fill_size;
1773 }
1774 }
1775 }
1776 break;
1777 case rs_broken_word:
1778 break;
1779 default:
1780 abort ();
1781 }
1782 frag = frag->fr_next;
1783 }
1784
1785 if (s->s_size != 0)
1786 {
1787 if (s->s_scnptr != 0)
1788 {
1789 bfd_write (buffer, s->s_size, 1, abfd);
1790 *file_cursor += s->s_size;
1791 }
1792 free (buffer);
1793 }
1794 paddr += s->s_size;
1795 }
1796 }
1797 }
1798
1799 /* Coff file generation & utilities */
1800
1801 static void
1802 coff_header_append (abfd, h)
1803 bfd * abfd;
1804 object_headers * h;
1805 {
1806 unsigned int i;
1807 char buffer[1000];
1808 char buffero[1000];
1809
1810 bfd_seek (abfd, 0, 0);
1811
1812 #ifndef OBJ_COFF_OMIT_OPTIONAL_HEADER
1813 H_SET_MAGIC_NUMBER (h, COFF_MAGIC);
1814 H_SET_VERSION_STAMP (h, 0);
1815 H_SET_ENTRY_POINT (h, 0);
1816 H_SET_TEXT_START (h, segment_info[SEG_E0].frchainP->frch_root->fr_address);
1817 H_SET_DATA_START (h, segment_info[SEG_E1].frchainP->frch_root->fr_address);
1818 H_SET_SIZEOF_OPTIONAL_HEADER (h, bfd_coff_swap_aouthdr_out(abfd, &h->aouthdr,
1819 buffero));
1820 #else /* defined (OBJ_COFF_OMIT_OPTIONAL_HEADER) */
1821 H_SET_SIZEOF_OPTIONAL_HEADER (h, 0);
1822 #endif /* defined (OBJ_COFF_OMIT_OPTIONAL_HEADER) */
1823
1824 i = bfd_coff_swap_filehdr_out (abfd, &h->filehdr, buffer);
1825
1826 bfd_write (buffer, i, 1, abfd);
1827 bfd_write (buffero, H_GET_SIZEOF_OPTIONAL_HEADER (h), 1, abfd);
1828
1829 for (i = SEG_E0; i < SEG_E9; i++)
1830 {
1831 if (segment_info[i].scnhdr.s_name[0])
1832 {
1833 unsigned int size =
1834 bfd_coff_swap_scnhdr_out (abfd,
1835 &(segment_info[i].scnhdr),
1836 buffer);
1837 if (size == 0)
1838 as_bad ("bfd_coff_swap_scnhdr_out failed");
1839 bfd_write (buffer, size, 1, abfd);
1840 }
1841 }
1842 }
1843
1844
1845 char *
1846 symbol_to_chars (abfd, where, symbolP)
1847 bfd * abfd;
1848 char *where;
1849 symbolS * symbolP;
1850 {
1851 unsigned int numaux = symbolP->sy_symbol.ost_entry.n_numaux;
1852 unsigned int i;
1853 valueT val;
1854
1855 /* Turn any symbols with register attributes into abs symbols */
1856 if (S_GET_SEGMENT (symbolP) == reg_section)
1857 {
1858 S_SET_SEGMENT (symbolP, absolute_section);
1859 }
1860 /* At the same time, relocate all symbols to their output value */
1861
1862 val = (segment_info[S_GET_SEGMENT (symbolP)].scnhdr.s_paddr
1863 + S_GET_VALUE (symbolP));
1864
1865 S_SET_VALUE (symbolP, val);
1866
1867 symbolP->sy_symbol.ost_entry.n_value = val;
1868
1869 where += bfd_coff_swap_sym_out (abfd, &symbolP->sy_symbol.ost_entry,
1870 where);
1871
1872 for (i = 0; i < numaux; i++)
1873 {
1874 where += bfd_coff_swap_aux_out (abfd,
1875 &symbolP->sy_symbol.ost_auxent[i],
1876 S_GET_DATA_TYPE (symbolP),
1877 S_GET_STORAGE_CLASS (symbolP),
1878 i, numaux, where);
1879 }
1880 return where;
1881
1882 }
1883
1884 void
1885 obj_symbol_new_hook (symbolP)
1886 symbolS *symbolP;
1887 {
1888 char underscore = 0; /* Symbol has leading _ */
1889
1890 /* Effective symbol */
1891 /* Store the pointer in the offset. */
1892 S_SET_ZEROES (symbolP, 0L);
1893 S_SET_DATA_TYPE (symbolP, T_NULL);
1894 S_SET_STORAGE_CLASS (symbolP, 0);
1895 S_SET_NUMBER_AUXILIARY (symbolP, 0);
1896 /* Additional information */
1897 symbolP->sy_symbol.ost_flags = 0;
1898 /* Auxiliary entries */
1899 memset ((char *) &symbolP->sy_symbol.ost_auxent[0], 0, AUXESZ);
1900
1901 if (S_IS_STRING (symbolP))
1902 SF_SET_STRING (symbolP);
1903 if (!underscore && S_IS_LOCAL (symbolP))
1904 SF_SET_LOCAL (symbolP);
1905 }
1906
1907 /*
1908 * Handle .ln directives.
1909 */
1910
1911 static void
1912 obj_coff_ln (appline)
1913 int appline;
1914 {
1915 int l;
1916
1917 if (! appline && def_symbol_in_progress != NULL)
1918 {
1919 as_warn (".ln pseudo-op inside .def/.endef: ignored.");
1920 demand_empty_rest_of_line ();
1921 return;
1922 } /* wrong context */
1923
1924 l = get_absolute_expression ();
1925 c_line_new (0, frag_now_fix (), l, frag_now);
1926 #ifndef NO_LISTING
1927 {
1928 extern int listing;
1929
1930 if (listing)
1931 {
1932 if (! appline)
1933 l += line_base - 1;
1934 listing_source_line ((unsigned int) l);
1935 }
1936
1937 }
1938 #endif
1939 demand_empty_rest_of_line ();
1940 }
1941
1942 /*
1943 * def()
1944 *
1945 * Handle .def directives.
1946 *
1947 * One might ask : why can't we symbol_new if the symbol does not
1948 * already exist and fill it with debug information. Because of
1949 * the C_EFCN special symbol. It would clobber the value of the
1950 * function symbol before we have a chance to notice that it is
1951 * a C_EFCN. And a second reason is that the code is more clear this
1952 * way. (at least I think it is :-).
1953 *
1954 */
1955
1956 #define SKIP_SEMI_COLON() while (*input_line_pointer++ != ';')
1957 #define SKIP_WHITESPACES() while (*input_line_pointer == ' ' || \
1958 *input_line_pointer == '\t') \
1959 input_line_pointer++;
1960
1961 static void
1962 obj_coff_def (what)
1963 int what;
1964 {
1965 char name_end; /* Char after the end of name */
1966 char *symbol_name; /* Name of the debug symbol */
1967 char *symbol_name_copy; /* Temporary copy of the name */
1968 unsigned int symbol_name_length;
1969
1970 if (def_symbol_in_progress != NULL)
1971 {
1972 as_warn (".def pseudo-op used inside of .def/.endef: ignored.");
1973 demand_empty_rest_of_line ();
1974 return;
1975 } /* if not inside .def/.endef */
1976
1977 SKIP_WHITESPACES ();
1978
1979 def_symbol_in_progress = (symbolS *) obstack_alloc (&notes, sizeof (*def_symbol_in_progress));
1980 memset (def_symbol_in_progress, 0, sizeof (*def_symbol_in_progress));
1981
1982 symbol_name = input_line_pointer;
1983 name_end = get_symbol_end ();
1984 symbol_name_length = strlen (symbol_name);
1985 symbol_name_copy = xmalloc (symbol_name_length + 1);
1986 strcpy (symbol_name_copy, symbol_name);
1987
1988 /* Initialize the new symbol */
1989 #ifdef STRIP_UNDERSCORE
1990 S_SET_NAME (def_symbol_in_progress, (*symbol_name_copy == '_'
1991 ? symbol_name_copy + 1
1992 : symbol_name_copy));
1993 #else /* STRIP_UNDERSCORE */
1994 S_SET_NAME (def_symbol_in_progress, symbol_name_copy);
1995 #endif /* STRIP_UNDERSCORE */
1996 /* free(symbol_name_copy); */
1997 def_symbol_in_progress->sy_name_offset = (unsigned long) ~0;
1998 def_symbol_in_progress->sy_number = ~0;
1999 def_symbol_in_progress->sy_frag = &zero_address_frag;
2000 S_SET_VALUE (def_symbol_in_progress, 0);
2001
2002 if (S_IS_STRING (def_symbol_in_progress))
2003 SF_SET_STRING (def_symbol_in_progress);
2004
2005 *input_line_pointer = name_end;
2006
2007 demand_empty_rest_of_line ();
2008 }
2009
2010 unsigned int dim_index;
2011
2012
2013 static void
2014 obj_coff_endef (ignore)
2015 int ignore;
2016 {
2017 symbolS *symbolP = 0;
2018 /* DIM BUG FIX sac@cygnus.com */
2019 dim_index = 0;
2020 if (def_symbol_in_progress == NULL)
2021 {
2022 as_warn (".endef pseudo-op used outside of .def/.endef: ignored.");
2023 demand_empty_rest_of_line ();
2024 return;
2025 } /* if not inside .def/.endef */
2026
2027 /* Set the section number according to storage class. */
2028 switch (S_GET_STORAGE_CLASS (def_symbol_in_progress))
2029 {
2030 case C_STRTAG:
2031 case C_ENTAG:
2032 case C_UNTAG:
2033 SF_SET_TAG (def_symbol_in_progress);
2034 /* intentional fallthrough */
2035 case C_FILE:
2036 case C_TPDEF:
2037 SF_SET_DEBUG (def_symbol_in_progress);
2038 S_SET_SEGMENT (def_symbol_in_progress, SEG_DEBUG);
2039 break;
2040
2041 case C_EFCN:
2042 SF_SET_LOCAL (def_symbol_in_progress); /* Do not emit this symbol. */
2043 /* intentional fallthrough */
2044 case C_BLOCK:
2045 SF_SET_PROCESS (def_symbol_in_progress); /* Will need processing before writing */
2046 /* intentional fallthrough */
2047 case C_FCN:
2048 S_SET_SEGMENT (def_symbol_in_progress, SEG_E0);
2049
2050 if (strcmp (S_GET_NAME (def_symbol_in_progress), ".bf") == 0)
2051 { /* .bf */
2052 if (function_lineoff < 0)
2053 {
2054 fprintf (stderr, "`.bf' symbol without preceding function\n");
2055 } /* missing function symbol */
2056 SA_GET_SYM_LNNOPTR (last_line_symbol) = function_lineoff;
2057
2058 SF_SET_PROCESS (last_line_symbol);
2059 function_lineoff = -1;
2060 }
2061 /* Value is always set to . */
2062 def_symbol_in_progress->sy_frag = frag_now;
2063 S_SET_VALUE (def_symbol_in_progress, (valueT) frag_now_fix ());
2064 break;
2065
2066 #ifdef C_AUTOARG
2067 case C_AUTOARG:
2068 #endif /* C_AUTOARG */
2069 case C_AUTO:
2070 case C_REG:
2071 case C_MOS:
2072 case C_MOE:
2073 case C_MOU:
2074 case C_ARG:
2075 case C_REGPARM:
2076 case C_FIELD:
2077 case C_EOS:
2078 SF_SET_DEBUG (def_symbol_in_progress);
2079 S_SET_SEGMENT (def_symbol_in_progress, absolute_section);
2080 break;
2081
2082 case C_EXT:
2083 case C_STAT:
2084 case C_LABEL:
2085 /* Valid but set somewhere else (s_comm, s_lcomm, colon) */
2086 break;
2087
2088 case C_USTATIC:
2089 case C_EXTDEF:
2090 case C_ULABEL:
2091 as_warn ("unexpected storage class %d", S_GET_STORAGE_CLASS (def_symbol_in_progress));
2092 break;
2093 } /* switch on storage class */
2094
2095 /* Now that we have built a debug symbol, try to find if we should
2096 merge with an existing symbol or not. If a symbol is C_EFCN or
2097 absolute_section or untagged SEG_DEBUG it never merges. We also
2098 don't merge labels, which are in a different namespace, nor
2099 symbols which have not yet been defined since they are typically
2100 unique, nor do we merge tags with non-tags. */
2101
2102 /* Two cases for functions. Either debug followed by definition or
2103 definition followed by debug. For definition first, we will
2104 merge the debug symbol into the definition. For debug first, the
2105 lineno entry MUST point to the definition function or else it
2106 will point off into space when crawl_symbols() merges the debug
2107 symbol into the real symbol. Therefor, let's presume the debug
2108 symbol is a real function reference. */
2109
2110 /* FIXME-SOON If for some reason the definition label/symbol is
2111 never seen, this will probably leave an undefined symbol at link
2112 time. */
2113
2114 if (S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_EFCN
2115 || S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_LABEL
2116 || (S_GET_SEGMENT (def_symbol_in_progress) == SEG_DEBUG
2117 && !SF_GET_TAG (def_symbol_in_progress))
2118 || S_GET_SEGMENT (def_symbol_in_progress) == absolute_section
2119 || def_symbol_in_progress->sy_value.X_op != O_constant
2120 || (symbolP = symbol_find_base (S_GET_NAME (def_symbol_in_progress), DO_NOT_STRIP)) == NULL
2121 || (SF_GET_TAG (def_symbol_in_progress) != SF_GET_TAG (symbolP)))
2122 {
2123 symbol_append (def_symbol_in_progress, symbol_lastP, &symbol_rootP,
2124 &symbol_lastP);
2125 }
2126 else
2127 {
2128 /* This symbol already exists, merge the newly created symbol
2129 into the old one. This is not mandatory. The linker can
2130 handle duplicate symbols correctly. But I guess that it save
2131 a *lot* of space if the assembly file defines a lot of
2132 symbols. [loic] */
2133
2134 /* The debug entry (def_symbol_in_progress) is merged into the
2135 previous definition. */
2136
2137 c_symbol_merge (def_symbol_in_progress, symbolP);
2138 /* FIXME-SOON Should *def_symbol_in_progress be free'd? xoxorich. */
2139 def_symbol_in_progress = symbolP;
2140
2141 if (SF_GET_FUNCTION (def_symbol_in_progress)
2142 || SF_GET_TAG (def_symbol_in_progress))
2143 {
2144 /* For functions, and tags, the symbol *must* be where the
2145 debug symbol appears. Move the existing symbol to the
2146 current place. */
2147 /* If it already is at the end of the symbol list, do nothing */
2148 if (def_symbol_in_progress != symbol_lastP)
2149 {
2150 symbol_remove (def_symbol_in_progress, &symbol_rootP,
2151 &symbol_lastP);
2152 symbol_append (def_symbol_in_progress, symbol_lastP,
2153 &symbol_rootP, &symbol_lastP);
2154 } /* if not already in place */
2155 } /* if function */
2156 } /* normal or mergable */
2157
2158 if (SF_GET_TAG (def_symbol_in_progress)
2159 && symbol_find_base (S_GET_NAME (def_symbol_in_progress), DO_NOT_STRIP) == NULL)
2160 {
2161 tag_insert (S_GET_NAME (def_symbol_in_progress), def_symbol_in_progress);
2162 }
2163
2164 if (SF_GET_FUNCTION (def_symbol_in_progress))
2165 {
2166 know (sizeof (def_symbol_in_progress) <= sizeof (long));
2167 function_lineoff
2168 = c_line_new (def_symbol_in_progress, 0, 0, &zero_address_frag);
2169
2170 SF_SET_PROCESS (def_symbol_in_progress);
2171
2172 if (symbolP == NULL)
2173 {
2174 /* That is, if this is the first time we've seen the
2175 function... */
2176 symbol_table_insert (def_symbol_in_progress);
2177 } /* definition follows debug */
2178 } /* Create the line number entry pointing to the function being defined */
2179
2180 def_symbol_in_progress = NULL;
2181 demand_empty_rest_of_line ();
2182 }
2183
2184 static void
2185 obj_coff_dim (ignore)
2186 int ignore;
2187 {
2188 int dim_index;
2189
2190 if (def_symbol_in_progress == NULL)
2191 {
2192 as_warn (".dim pseudo-op used outside of .def/.endef: ignored.");
2193 demand_empty_rest_of_line ();
2194 return;
2195 } /* if not inside .def/.endef */
2196
2197 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
2198
2199 for (dim_index = 0; dim_index < DIMNUM; dim_index++)
2200 {
2201 SKIP_WHITESPACES ();
2202 SA_SET_SYM_DIMEN (def_symbol_in_progress, dim_index,
2203 get_absolute_expression ());
2204
2205 switch (*input_line_pointer)
2206 {
2207 case ',':
2208 input_line_pointer++;
2209 break;
2210
2211 default:
2212 as_warn ("badly formed .dim directive ignored");
2213 /* intentional fallthrough */
2214 case '\n':
2215 case ';':
2216 dim_index = DIMNUM;
2217 break;
2218 }
2219 }
2220
2221 demand_empty_rest_of_line ();
2222 }
2223
2224 static void
2225 obj_coff_line (ignore)
2226 int ignore;
2227 {
2228 int this_base;
2229 const char *name;
2230
2231 if (def_symbol_in_progress == NULL)
2232 {
2233 obj_coff_ln (0);
2234 return;
2235 }
2236
2237 name = S_GET_NAME (def_symbol_in_progress);
2238 this_base = get_absolute_expression ();
2239
2240 /* Only .bf symbols indicate the use of a new base line number; the
2241 line numbers associated with .ef, .bb, .eb are relative to the
2242 start of the containing function. */
2243 if (!strcmp (".bf", name))
2244 {
2245 #if 0 /* XXX Can we ever have line numbers going backwards? */
2246 if (this_base > line_base)
2247 #endif
2248 {
2249 line_base = this_base;
2250 }
2251
2252 #ifndef NO_LISTING
2253 {
2254 extern int listing;
2255 if (listing && 0)
2256 {
2257 listing_source_line ((unsigned int) line_base);
2258 }
2259 }
2260 #endif
2261 }
2262
2263 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
2264 SA_SET_SYM_LNNO (def_symbol_in_progress, this_base);
2265
2266 demand_empty_rest_of_line ();
2267 }
2268
2269 static void
2270 obj_coff_size (ignore)
2271 int ignore;
2272 {
2273 if (def_symbol_in_progress == NULL)
2274 {
2275 as_warn (".size pseudo-op used outside of .def/.endef ignored.");
2276 demand_empty_rest_of_line ();
2277 return;
2278 } /* if not inside .def/.endef */
2279
2280 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
2281 SA_SET_SYM_SIZE (def_symbol_in_progress, get_absolute_expression ());
2282 demand_empty_rest_of_line ();
2283 }
2284
2285 static void
2286 obj_coff_scl (ignore)
2287 int ignore;
2288 {
2289 if (def_symbol_in_progress == NULL)
2290 {
2291 as_warn (".scl pseudo-op used outside of .def/.endef ignored.");
2292 demand_empty_rest_of_line ();
2293 return;
2294 } /* if not inside .def/.endef */
2295
2296 S_SET_STORAGE_CLASS (def_symbol_in_progress, get_absolute_expression ());
2297 demand_empty_rest_of_line ();
2298 }
2299
2300 static void
2301 obj_coff_tag (ignore)
2302 int ignore;
2303 {
2304 char *symbol_name;
2305 char name_end;
2306
2307 if (def_symbol_in_progress == NULL)
2308 {
2309 as_warn (".tag pseudo-op used outside of .def/.endef ignored.");
2310 demand_empty_rest_of_line ();
2311 return;
2312 }
2313
2314 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
2315 symbol_name = input_line_pointer;
2316 name_end = get_symbol_end ();
2317
2318 /* Assume that the symbol referred to by .tag is always defined.
2319 This was a bad assumption. I've added find_or_make. xoxorich. */
2320 SA_SET_SYM_TAGNDX (def_symbol_in_progress,
2321 (long) tag_find_or_make (symbol_name));
2322 if (SA_GET_SYM_TAGNDX (def_symbol_in_progress) == 0L)
2323 {
2324 as_warn ("tag not found for .tag %s", symbol_name);
2325 } /* not defined */
2326
2327 SF_SET_TAGGED (def_symbol_in_progress);
2328 *input_line_pointer = name_end;
2329
2330 demand_empty_rest_of_line ();
2331 }
2332
2333 static void
2334 obj_coff_type (ignore)
2335 int ignore;
2336 {
2337 if (def_symbol_in_progress == NULL)
2338 {
2339 as_warn (".type pseudo-op used outside of .def/.endef ignored.");
2340 demand_empty_rest_of_line ();
2341 return;
2342 } /* if not inside .def/.endef */
2343
2344 S_SET_DATA_TYPE (def_symbol_in_progress, get_absolute_expression ());
2345
2346 if (ISFCN (S_GET_DATA_TYPE (def_symbol_in_progress)) &&
2347 S_GET_STORAGE_CLASS (def_symbol_in_progress) != C_TPDEF)
2348 {
2349 SF_SET_FUNCTION (def_symbol_in_progress);
2350 } /* is a function */
2351
2352 demand_empty_rest_of_line ();
2353 }
2354
2355 static void
2356 obj_coff_val (ignore)
2357 int ignore;
2358 {
2359 if (def_symbol_in_progress == NULL)
2360 {
2361 as_warn (".val pseudo-op used outside of .def/.endef ignored.");
2362 demand_empty_rest_of_line ();
2363 return;
2364 } /* if not inside .def/.endef */
2365
2366 if (is_name_beginner (*input_line_pointer))
2367 {
2368 char *symbol_name = input_line_pointer;
2369 char name_end = get_symbol_end ();
2370
2371 if (!strcmp (symbol_name, "."))
2372 {
2373 def_symbol_in_progress->sy_frag = frag_now;
2374 S_SET_VALUE (def_symbol_in_progress, (valueT) frag_now_fix ());
2375 /* If the .val is != from the .def (e.g. statics) */
2376 }
2377 else if (strcmp (S_GET_NAME (def_symbol_in_progress), symbol_name))
2378 {
2379 def_symbol_in_progress->sy_value.X_op = O_symbol;
2380 def_symbol_in_progress->sy_value.X_add_symbol =
2381 symbol_find_or_make (symbol_name);
2382 def_symbol_in_progress->sy_value.X_op_symbol = NULL;
2383 def_symbol_in_progress->sy_value.X_add_number = 0;
2384
2385 /* If the segment is undefined when the forward reference is
2386 resolved, then copy the segment id from the forward
2387 symbol. */
2388 SF_SET_GET_SEGMENT (def_symbol_in_progress);
2389
2390 /* FIXME: gcc can generate address expressions
2391 here in unusual cases (search for "obscure"
2392 in sdbout.c). We just ignore the offset
2393 here, thus generating incorrect debugging
2394 information. We ignore the rest of the
2395 line just below. */
2396 }
2397 /* Otherwise, it is the name of a non debug symbol and
2398 its value will be calculated later. */
2399 *input_line_pointer = name_end;
2400
2401 /* FIXME: this is to avoid an error message in the
2402 FIXME case mentioned just above. */
2403 while (! is_end_of_line[(unsigned char) *input_line_pointer])
2404 ++input_line_pointer;
2405 }
2406 else
2407 {
2408 S_SET_VALUE (def_symbol_in_progress,
2409 (valueT) get_absolute_expression ());
2410 } /* if symbol based */
2411
2412 demand_empty_rest_of_line ();
2413 }
2414
2415 void
2416 obj_read_begin_hook ()
2417 {
2418 /* These had better be the same. Usually 18 bytes. */
2419 #ifndef BFD_HEADERS
2420 know (sizeof (SYMENT) == sizeof (AUXENT));
2421 know (SYMESZ == AUXESZ);
2422 #endif
2423 tag_init ();
2424 }
2425
2426 /* This function runs through the symbol table and puts all the
2427 externals onto another chain */
2428
2429 /* The chain of externals */
2430 symbolS *symbol_externP;
2431 symbolS *symbol_extern_lastP;
2432
2433 stack *block_stack;
2434 symbolS *last_functionP;
2435 symbolS *last_tagP;
2436
2437 static unsigned int
2438 yank_symbols ()
2439 {
2440 symbolS *symbolP;
2441 unsigned int symbol_number = 0;
2442 unsigned int last_file_symno = 0;
2443
2444 for (symbolP = symbol_rootP;
2445 symbolP;
2446 symbolP = symbolP ? symbol_next (symbolP) : symbol_rootP)
2447 {
2448 if (!SF_GET_DEBUG (symbolP))
2449 {
2450 /* Debug symbols do not need all this rubbish */
2451 symbolS *real_symbolP;
2452
2453 /* L* and C_EFCN symbols never merge. */
2454 if (!SF_GET_LOCAL (symbolP)
2455 && S_GET_STORAGE_CLASS (symbolP) != C_LABEL
2456 && symbolP->sy_value.X_op == O_constant
2457 && (real_symbolP = symbol_find_base (S_GET_NAME (symbolP), DO_NOT_STRIP))
2458 && real_symbolP != symbolP)
2459 {
2460 /* FIXME-SOON: where do dups come from?
2461 Maybe tag references before definitions? xoxorich. */
2462 /* Move the debug data from the debug symbol to the
2463 real symbol. Do NOT do the oposite (i.e. move from
2464 real symbol to debug symbol and remove real symbol from the
2465 list.) Because some pointers refer to the real symbol
2466 whereas no pointers refer to the debug symbol. */
2467 c_symbol_merge (symbolP, real_symbolP);
2468 /* Replace the current symbol by the real one */
2469 /* The symbols will never be the last or the first
2470 because : 1st symbol is .file and 3 last symbols are
2471 .text, .data, .bss */
2472 symbol_remove (real_symbolP, &symbol_rootP, &symbol_lastP);
2473 symbol_insert (real_symbolP, symbolP, &symbol_rootP, &symbol_lastP);
2474 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
2475 symbolP = real_symbolP;
2476 } /* if not local but dup'd */
2477
2478 if (flag_readonly_data_in_text && (S_GET_SEGMENT (symbolP) == SEG_E1))
2479 {
2480 S_SET_SEGMENT (symbolP, SEG_E0);
2481 } /* push data into text */
2482
2483 resolve_symbol_value (symbolP);
2484
2485 if (S_GET_STORAGE_CLASS (symbolP) == C_NULL)
2486 {
2487 if (!S_IS_DEFINED (symbolP) && !SF_GET_LOCAL (symbolP))
2488 {
2489 S_SET_EXTERNAL (symbolP);
2490 }
2491 else if (S_GET_SEGMENT (symbolP) == SEG_E0)
2492 {
2493 S_SET_STORAGE_CLASS (symbolP, C_LABEL);
2494 }
2495 else
2496 {
2497 S_SET_STORAGE_CLASS (symbolP, C_STAT);
2498 }
2499 }
2500
2501 /* Mainly to speed up if not -g */
2502 if (SF_GET_PROCESS (symbolP))
2503 {
2504 /* Handle the nested blocks auxiliary info. */
2505 if (S_GET_STORAGE_CLASS (symbolP) == C_BLOCK)
2506 {
2507 if (!strcmp (S_GET_NAME (symbolP), ".bb"))
2508 stack_push (block_stack, (char *) &symbolP);
2509 else
2510 { /* .eb */
2511 register symbolS *begin_symbolP;
2512 begin_symbolP = *(symbolS **) stack_pop (block_stack);
2513 if (begin_symbolP == (symbolS *) 0)
2514 as_warn ("mismatched .eb");
2515 else
2516 SA_SET_SYM_ENDNDX (begin_symbolP, symbol_number + 2);
2517 }
2518 }
2519 /* If we are able to identify the type of a function, and we
2520 are out of a function (last_functionP == 0) then, the
2521 function symbol will be associated with an auxiliary
2522 entry. */
2523 if (last_functionP == (symbolS *) 0 &&
2524 SF_GET_FUNCTION (symbolP))
2525 {
2526 last_functionP = symbolP;
2527
2528 if (S_GET_NUMBER_AUXILIARY (symbolP) < 1)
2529 {
2530 S_SET_NUMBER_AUXILIARY (symbolP, 1);
2531 } /* make it at least 1 */
2532
2533 /* Clobber possible stale .dim information. */
2534 #if 0
2535 /* Iffed out by steve - this fries the lnnoptr info too */
2536 bzero (symbolP->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_ary.x_dimen,
2537 sizeof (symbolP->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_ary.x_dimen));
2538 #endif
2539 }
2540 /* The C_FCN doesn't need any additional information. I
2541 don't even know if this is needed for sdb. But the
2542 standard assembler generates it, so... */
2543 if (S_GET_STORAGE_CLASS (symbolP) == C_EFCN)
2544 {
2545 if (last_functionP == (symbolS *) 0)
2546 as_fatal ("C_EFCN symbol out of scope");
2547 SA_SET_SYM_FSIZE (last_functionP,
2548 (long) (S_GET_VALUE (symbolP) -
2549 S_GET_VALUE (last_functionP)));
2550 SA_SET_SYM_ENDNDX (last_functionP, symbol_number);
2551 last_functionP = (symbolS *) 0;
2552 }
2553 }
2554 }
2555 else if (SF_GET_TAG (symbolP))
2556 {
2557 /* First descriptor of a structure must point to
2558 the first slot after the structure description. */
2559 last_tagP = symbolP;
2560
2561 }
2562 else if (S_GET_STORAGE_CLASS (symbolP) == C_EOS)
2563 {
2564 /* +2 take in account the current symbol */
2565 SA_SET_SYM_ENDNDX (last_tagP, symbol_number + 2);
2566 }
2567 else if (S_GET_STORAGE_CLASS (symbolP) == C_FILE)
2568 {
2569 if (S_GET_VALUE (symbolP))
2570 {
2571 S_SET_VALUE (symbolP, last_file_symno);
2572 last_file_symno = symbol_number;
2573 } /* no one points at the first .file symbol */
2574 } /* if debug or tag or eos or file */
2575
2576 /* We must put the external symbols apart. The loader
2577 does not bomb if we do not. But the references in
2578 the endndx field for a .bb symbol are not corrected
2579 if an external symbol is removed between .bb and .be.
2580 I.e in the following case :
2581 [20] .bb endndx = 22
2582 [21] foo external
2583 [22] .be
2584 ld will move the symbol 21 to the end of the list but
2585 endndx will still be 22 instead of 21. */
2586
2587
2588 if (SF_GET_LOCAL (symbolP))
2589 {
2590 /* remove C_EFCN and LOCAL (L...) symbols */
2591 /* next pointer remains valid */
2592 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
2593
2594 }
2595 else if (!S_IS_DEFINED (symbolP)
2596 && !S_IS_DEBUG (symbolP)
2597 && !SF_GET_STATICS (symbolP) &&
2598 S_GET_STORAGE_CLASS (symbolP) == C_EXT)
2599 { /* C_EXT && !SF_GET_FUNCTION(symbolP)) */
2600 /* if external, Remove from the list */
2601 symbolS *hold = symbol_previous (symbolP);
2602
2603 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
2604 symbol_clear_list_pointers (symbolP);
2605 symbol_append (symbolP, symbol_extern_lastP, &symbol_externP, &symbol_extern_lastP);
2606 symbolP = hold;
2607 }
2608 else
2609 {
2610 if (SF_GET_STRING (symbolP))
2611 {
2612 symbolP->sy_name_offset = string_byte_count;
2613 string_byte_count += strlen (S_GET_NAME (symbolP)) + 1;
2614 }
2615 else
2616 {
2617 symbolP->sy_name_offset = 0;
2618 } /* fix "long" names */
2619
2620 symbolP->sy_number = symbol_number;
2621 symbol_number += 1 + S_GET_NUMBER_AUXILIARY (symbolP);
2622 } /* if local symbol */
2623 } /* traverse the symbol list */
2624 return symbol_number;
2625
2626 }
2627
2628
2629 static unsigned int
2630 glue_symbols ()
2631 {
2632 unsigned int symbol_number = 0;
2633 symbolS *symbolP;
2634 for (symbolP = symbol_externP; symbol_externP;)
2635 {
2636 symbolS *tmp = symbol_externP;
2637
2638 /* append */
2639 symbol_remove (tmp, &symbol_externP, &symbol_extern_lastP);
2640 symbol_append (tmp, symbol_lastP, &symbol_rootP, &symbol_lastP);
2641
2642 /* and process */
2643 if (SF_GET_STRING (tmp))
2644 {
2645 tmp->sy_name_offset = string_byte_count;
2646 string_byte_count += strlen (S_GET_NAME (tmp)) + 1;
2647 }
2648 else
2649 {
2650 tmp->sy_name_offset = 0;
2651 } /* fix "long" names */
2652
2653 tmp->sy_number = symbol_number;
2654 symbol_number += 1 + S_GET_NUMBER_AUXILIARY (tmp);
2655 } /* append the entire extern chain */
2656 return symbol_number;
2657
2658 }
2659
2660 static unsigned int
2661 tie_tags ()
2662 {
2663 unsigned int symbol_number = 0;
2664
2665 symbolS *symbolP;
2666 for (symbolP = symbol_rootP; symbolP; symbolP =
2667 symbol_next (symbolP))
2668 {
2669 symbolP->sy_number = symbol_number;
2670
2671
2672
2673 if (SF_GET_TAGGED (symbolP))
2674 {
2675 SA_SET_SYM_TAGNDX
2676 (symbolP,
2677 ((symbolS *) SA_GET_SYM_TAGNDX (symbolP))->sy_number);
2678 }
2679
2680 symbol_number += 1 + S_GET_NUMBER_AUXILIARY (symbolP);
2681 }
2682 return symbol_number;
2683
2684 }
2685
2686 static void
2687 crawl_symbols (h, abfd)
2688 object_headers *h;
2689 bfd * abfd;
2690 {
2691 unsigned int i;
2692
2693 /* Initialize the stack used to keep track of the matching .bb .be */
2694
2695 block_stack = stack_init (512, sizeof (symbolS *));
2696
2697 /* The symbol list should be ordered according to the following sequence
2698 * order :
2699 * . .file symbol
2700 * . debug entries for functions
2701 * . fake symbols for the sections, including.text .data and .bss
2702 * . defined symbols
2703 * . undefined symbols
2704 * But this is not mandatory. The only important point is to put the
2705 * undefined symbols at the end of the list.
2706 */
2707
2708 if (symbol_rootP == NULL
2709 || S_GET_STORAGE_CLASS (symbol_rootP) != C_FILE)
2710 {
2711 c_dot_file_symbol ("fake");
2712 }
2713 /* Is there a .file symbol ? If not insert one at the beginning. */
2714
2715 /*
2716 * Build up static symbols for the sections, they are filled in later
2717 */
2718
2719
2720 for (i = SEG_E0; i < SEG_E9; i++)
2721 {
2722 if (segment_info[i].scnhdr.s_name[0])
2723 {
2724 char name[9];
2725
2726 strncpy (name, segment_info[i].scnhdr.s_name, 8);
2727 name[8] = '\0';
2728 segment_info[i].dot = c_section_symbol (name, i - SEG_E0 + 1);
2729 }
2730 }
2731
2732
2733 /* Take all the externals out and put them into another chain */
2734 H_SET_SYMBOL_TABLE_SIZE (h, yank_symbols ());
2735 /* Take the externals and glue them onto the end.*/
2736 H_SET_SYMBOL_TABLE_SIZE (h, H_GET_SYMBOL_COUNT (h) + glue_symbols ());
2737
2738 H_SET_SYMBOL_TABLE_SIZE (h, tie_tags ());
2739 know (symbol_externP == NULL);
2740 know (symbol_extern_lastP == NULL);
2741 }
2742
2743 /*
2744 * Find strings by crawling along symbol table chain.
2745 */
2746
2747 void
2748 w_strings (where)
2749 char *where;
2750 {
2751 symbolS *symbolP;
2752
2753 /* Gotta do md_ byte-ordering stuff for string_byte_count first - KWK */
2754 md_number_to_chars (where, (valueT) string_byte_count, 4);
2755 where += 4;
2756 for (symbolP = symbol_rootP;
2757 symbolP;
2758 symbolP = symbol_next (symbolP))
2759 {
2760 unsigned int size;
2761
2762 if (SF_GET_STRING (symbolP))
2763 {
2764 size = strlen (S_GET_NAME (symbolP)) + 1;
2765
2766 memcpy (where, S_GET_NAME (symbolP), size);
2767 where += size;
2768
2769 }
2770 }
2771 }
2772
2773 static void
2774 do_linenos_for (abfd, h, file_cursor)
2775 bfd * abfd;
2776 object_headers * h;
2777 unsigned long *file_cursor;
2778 {
2779 unsigned int idx;
2780 unsigned long start = *file_cursor;
2781
2782 for (idx = SEG_E0; idx < SEG_E9; idx++)
2783 {
2784 segment_info_type *s = segment_info + idx;
2785
2786
2787 if (s->scnhdr.s_nlnno != 0)
2788 {
2789 struct lineno_list *line_ptr;
2790
2791 struct external_lineno *buffer =
2792 (struct external_lineno *) xmalloc (s->scnhdr.s_nlnno * LINESZ);
2793
2794 struct external_lineno *dst = buffer;
2795
2796 /* Run through the table we've built and turn it into its external
2797 form, take this chance to remove duplicates */
2798
2799 for (line_ptr = s->lineno_list_head;
2800 line_ptr != (struct lineno_list *) NULL;
2801 line_ptr = line_ptr->next)
2802 {
2803
2804 if (line_ptr->line.l_lnno == 0)
2805 {
2806 /* Turn a pointer to a symbol into the symbols' index */
2807 line_ptr->line.l_addr.l_symndx =
2808 ((symbolS *) line_ptr->line.l_addr.l_symndx)->sy_number;
2809 }
2810 else
2811 {
2812 line_ptr->line.l_addr.l_paddr += ((struct frag *) (line_ptr->frag))->fr_address;
2813 }
2814
2815
2816 (void) bfd_coff_swap_lineno_out (abfd, &(line_ptr->line), dst);
2817 dst++;
2818
2819 }
2820
2821 s->scnhdr.s_lnnoptr = *file_cursor;
2822
2823 bfd_write (buffer, 1, s->scnhdr.s_nlnno * LINESZ, abfd);
2824 free (buffer);
2825
2826 *file_cursor += s->scnhdr.s_nlnno * LINESZ;
2827 }
2828 }
2829 H_SET_LINENO_SIZE (h, *file_cursor - start);
2830 }
2831
2832
2833 /* Now we run through the list of frag chains in a segment and
2834 make all the subsegment frags appear at the end of the
2835 list, as if the seg 0 was extra long */
2836
2837 static void
2838 remove_subsegs ()
2839 {
2840 unsigned int i;
2841
2842 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
2843 {
2844 frchainS *head = segment_info[i].frchainP;
2845 fragS dummy;
2846 fragS *prev_frag = &dummy;
2847
2848 while (head && head->frch_seg == i)
2849 {
2850 prev_frag->fr_next = head->frch_root;
2851 prev_frag = head->frch_last;
2852 head = head->frch_next;
2853 }
2854 prev_frag->fr_next = 0;
2855 }
2856 }
2857
2858 unsigned long machine;
2859 int coff_flags;
2860 extern void
2861 write_object_file ()
2862 {
2863 int i;
2864 char *name;
2865 struct frchain *frchain_ptr;
2866
2867 object_headers headers;
2868 unsigned long file_cursor;
2869 bfd *abfd;
2870 unsigned int addr;
2871 abfd = bfd_openw (out_file_name, TARGET_FORMAT);
2872
2873
2874 if (abfd == 0)
2875 {
2876 as_perror ("FATAL: Can't create %s", out_file_name);
2877 exit (EXIT_FAILURE);
2878 }
2879 bfd_set_format (abfd, bfd_object);
2880 bfd_set_arch_mach (abfd, BFD_ARCH, machine);
2881
2882 string_byte_count = 4;
2883
2884 for (frchain_ptr = frchain_root;
2885 frchain_ptr != (struct frchain *) NULL;
2886 frchain_ptr = frchain_ptr->frch_next)
2887 {
2888 /* Run through all the sub-segments and align them up. Also
2889 close any open frags. We tack a .fill onto the end of the
2890 frag chain so that any .align's size can be worked by looking
2891 at the next frag. */
2892
2893 subseg_set (frchain_ptr->frch_seg, frchain_ptr->frch_subseg);
2894 #ifndef SUB_SEGMENT_ALIGN
2895 #define SUB_SEGMENT_ALIGN(SEG) 1
2896 #endif
2897 frag_align (SUB_SEGMENT_ALIGN (now_seg), NOP_OPCODE);
2898 frag_wane (frag_now);
2899 frag_now->fr_fix = 0;
2900 know (frag_now->fr_next == NULL);
2901 }
2902
2903
2904 remove_subsegs ();
2905
2906
2907 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
2908 {
2909 relax_segment (segment_info[i].frchainP->frch_root, i);
2910 }
2911
2912 H_SET_NUMBER_OF_SECTIONS (&headers, 0);
2913
2914 /* Find out how big the sections are, and set the addresses. */
2915 addr = 0;
2916 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
2917 {
2918 long size;
2919
2920 segment_info[i].scnhdr.s_paddr = addr;
2921 segment_info[i].scnhdr.s_vaddr = addr;
2922
2923 if (segment_info[i].scnhdr.s_name[0])
2924 {
2925 H_SET_NUMBER_OF_SECTIONS (&headers,
2926 H_GET_NUMBER_OF_SECTIONS (&headers) + 1);
2927 }
2928
2929 size = size_section (abfd, (unsigned int) i);
2930 addr += size;
2931
2932 /* I think the section alignment is only used on the i960; the
2933 i960 needs it, and it should do no harm on other targets. */
2934 segment_info[i].scnhdr.s_align = section_alignment[i];
2935
2936 if (i == SEG_E0)
2937 H_SET_TEXT_SIZE (&headers, size);
2938 else if (i == SEG_E1)
2939 H_SET_DATA_SIZE (&headers, size);
2940 else if (i == SEG_E2)
2941 H_SET_BSS_SIZE (&headers, size);
2942 }
2943
2944 /* Turn the gas native symbol table shape into a coff symbol table */
2945 crawl_symbols (&headers, abfd);
2946
2947 if (string_byte_count == 4)
2948 string_byte_count = 0;
2949
2950 H_SET_STRING_SIZE (&headers, string_byte_count);
2951
2952 #if !defined(TC_H8300) && !defined(TC_Z8K)
2953 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
2954 {
2955 fixup_mdeps (segment_info[i].frchainP->frch_root, &headers, i);
2956 fixup_segment (&segment_info[i], i);
2957 }
2958 #endif
2959
2960 /* Look for ".stab" segments and fill in their initial symbols
2961 correctly. */
2962 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
2963 {
2964 name = segment_info[i].scnhdr.s_name;
2965
2966 if (name != NULL
2967 && strncmp (".stab", name, 5) == 0
2968 && strncmp (".stabstr", name, 8) != 0)
2969 adjust_stab_section (abfd, i);
2970 }
2971
2972 file_cursor = H_GET_TEXT_FILE_OFFSET (&headers);
2973
2974 bfd_seek (abfd, (file_ptr) file_cursor, 0);
2975
2976 /* Plant the data */
2977
2978 fill_section (abfd, &headers, &file_cursor);
2979
2980 do_relocs_for (abfd, &headers, &file_cursor);
2981
2982 do_linenos_for (abfd, &headers, &file_cursor);
2983
2984 H_SET_FILE_MAGIC_NUMBER (&headers, COFF_MAGIC);
2985 #ifndef OBJ_COFF_OMIT_TIMESTAMP
2986 H_SET_TIME_STAMP (&headers, (long)time((long*)0));
2987 #else
2988 H_SET_TIME_STAMP (&headers, 0);
2989 #endif
2990 #ifdef TC_COFF_SET_MACHINE
2991 TC_COFF_SET_MACHINE (&headers);
2992 #endif
2993
2994 #ifndef COFF_FLAGS
2995 #define COFF_FLAGS 0
2996 #endif
2997
2998 #ifdef KEEP_RELOC_INFO
2999 H_SET_FLAGS (&headers, ((H_GET_LINENO_SIZE(&headers) ? 0 : F_LNNO) |
3000 COFF_FLAGS | coff_flags));
3001 #else
3002 H_SET_FLAGS (&headers, ((H_GET_LINENO_SIZE(&headers) ? 0 : F_LNNO) |
3003 (H_GET_RELOCATION_SIZE(&headers) ? 0 : F_RELFLG) |
3004 COFF_FLAGS | coff_flags));
3005 #endif
3006
3007 {
3008 unsigned int symtable_size = H_GET_SYMBOL_TABLE_SIZE (&headers);
3009 char *buffer1 = xmalloc (symtable_size + string_byte_count + 1);
3010
3011 H_SET_SYMBOL_TABLE_POINTER (&headers, bfd_tell (abfd));
3012 w_symbols (abfd, buffer1, symbol_rootP);
3013 if (string_byte_count > 0)
3014 w_strings (buffer1 + symtable_size);
3015 bfd_write (buffer1, 1, symtable_size + string_byte_count, abfd);
3016 free (buffer1);
3017 }
3018
3019 coff_header_append (abfd, &headers);
3020 #if 0
3021 /* Recent changes to write need this, but where it should
3022 go is up to Ken.. */
3023 if (bfd_close_all_done (abfd) == false)
3024 as_fatal ("Can't close %s: %s", out_file_name,
3025 bfd_errmsg (bfd_get_error ()));
3026 #else
3027 {
3028 extern bfd *stdoutput;
3029 stdoutput = abfd;
3030 }
3031 #endif
3032
3033 }
3034
3035 /* Add a new segment. This is called from subseg_new via the
3036 obj_new_segment macro. */
3037
3038 segT
3039 obj_coff_add_segment (name)
3040 const char *name;
3041 {
3042 unsigned int len;
3043 unsigned int i;
3044
3045 /* Find out if we've already got a section of this name. */
3046 len = strlen (name);
3047 if (len < sizeof (segment_info[i].scnhdr.s_name))
3048 ++len;
3049 else
3050 len = sizeof (segment_info[i].scnhdr.s_name);
3051 for (i = SEG_E0; i < SEG_E9 && segment_info[i].scnhdr.s_name[0]; i++)
3052 if (strncmp (segment_info[i].scnhdr.s_name, name, len) == 0
3053 && (len == sizeof (segment_info[i].scnhdr.s_name)
3054 || segment_info[i].scnhdr.s_name[len] == '\0'))
3055 return (segT) i;
3056
3057 if (i == SEG_E9)
3058 {
3059 as_bad ("Too many new sections; can't add \"%s\"", name);
3060 return now_seg;
3061 }
3062
3063 /* Add a new section. */
3064 strncpy (segment_info[i].scnhdr.s_name, name,
3065 sizeof (segment_info[i].scnhdr.s_name));
3066 segment_info[i].scnhdr.s_flags = STYP_REG;
3067
3068 return (segT) i;
3069 }
3070
3071 /*
3072 * implement the .section pseudo op:
3073 * .section name {, "flags"}
3074 * ^ ^
3075 * | +--- optional flags: 'b' for bss
3076 * | 'i' for info
3077 * +-- section name 'l' for lib
3078 * 'n' for noload
3079 * 'o' for over
3080 * 'w' for data
3081 * 'd' (apparently m88k for data)
3082 * 'x' for text
3083 * But if the argument is not a quoted string, treat it as a
3084 * subsegment number.
3085 */
3086
3087 void
3088 obj_coff_section (ignore)
3089 int ignore;
3090 {
3091 /* Strip out the section name */
3092 char *section_name;
3093 char *section_name_end;
3094 char c;
3095 int argp;
3096 unsigned int len;
3097 unsigned int exp;
3098 long flags;
3099
3100 section_name = input_line_pointer;
3101 c = get_symbol_end ();
3102 section_name_end = input_line_pointer;
3103
3104 len = section_name_end - section_name;
3105 input_line_pointer++;
3106 SKIP_WHITESPACE ();
3107
3108 argp = 0;
3109 if (c == ',')
3110 argp = 1;
3111 else if (*input_line_pointer == ',')
3112 {
3113 argp = 1;
3114 ++input_line_pointer;
3115 SKIP_WHITESPACE ();
3116 }
3117
3118 exp = 0;
3119 flags = 0;
3120 if (argp)
3121 {
3122 if (*input_line_pointer != '"')
3123 exp = get_absolute_expression ();
3124 else
3125 {
3126 ++input_line_pointer;
3127 while (*input_line_pointer != '"'
3128 && ! is_end_of_line[(unsigned char) *input_line_pointer])
3129 {
3130 switch (*input_line_pointer)
3131 {
3132 case 'b': flags |= STYP_BSS; break;
3133 case 'i': flags |= STYP_INFO; break;
3134 case 'l': flags |= STYP_LIB; break;
3135 case 'n': flags |= STYP_NOLOAD; break;
3136 case 'o': flags |= STYP_OVER; break;
3137 case 'd':
3138 case 'w': flags |= STYP_DATA; break;
3139 case 'x': flags |= STYP_TEXT; break;
3140 default:
3141 as_warn("unknown section attribute '%c'",
3142 *input_line_pointer);
3143 break;
3144 }
3145 ++input_line_pointer;
3146 }
3147 if (*input_line_pointer == '"')
3148 ++input_line_pointer;
3149 }
3150 }
3151
3152 subseg_new (section_name, (subsegT) exp);
3153
3154 segment_info[now_seg].scnhdr.s_flags |= flags;
3155
3156 *section_name_end = c;
3157 }
3158
3159
3160 static void
3161 obj_coff_text (ignore)
3162 int ignore;
3163 {
3164 subseg_new (".text", get_absolute_expression ());
3165 }
3166
3167
3168 static void
3169 obj_coff_data (ignore)
3170 int ignore;
3171 {
3172 if (flag_readonly_data_in_text)
3173 subseg_new (".text", get_absolute_expression () + 1000);
3174 else
3175 subseg_new (".data", get_absolute_expression ());
3176 }
3177
3178 static void
3179 obj_coff_bss (ignore)
3180 int ignore;
3181 {
3182 if (*input_line_pointer == '\n') /* .bss */
3183 subseg_new(".bss", get_absolute_expression());
3184 else /* .bss id,expr */
3185 obj_coff_lcomm(0);
3186 }
3187
3188 static void
3189 obj_coff_ident (ignore)
3190 int ignore;
3191 {
3192 segT current_seg = now_seg; /* save current seg */
3193 subsegT current_subseg = now_subseg;
3194 subseg_new (".comment", 0); /* .comment seg */
3195 stringer (1); /* read string */
3196 subseg_set (current_seg, current_subseg); /* restore current seg */
3197 }
3198
3199 void
3200 c_symbol_merge (debug, normal)
3201 symbolS *debug;
3202 symbolS *normal;
3203 {
3204 S_SET_DATA_TYPE (normal, S_GET_DATA_TYPE (debug));
3205 S_SET_STORAGE_CLASS (normal, S_GET_STORAGE_CLASS (debug));
3206
3207 if (S_GET_NUMBER_AUXILIARY (debug) > S_GET_NUMBER_AUXILIARY (normal))
3208 {
3209 S_SET_NUMBER_AUXILIARY (normal, S_GET_NUMBER_AUXILIARY (debug));
3210 } /* take the most we have */
3211
3212 if (S_GET_NUMBER_AUXILIARY (debug) > 0)
3213 {
3214 memcpy ((char *) &normal->sy_symbol.ost_auxent[0],
3215 (char *) &debug->sy_symbol.ost_auxent[0],
3216 (unsigned int) (S_GET_NUMBER_AUXILIARY (debug) * AUXESZ));
3217 } /* Move all the auxiliary information */
3218
3219 /* Move the debug flags. */
3220 SF_SET_DEBUG_FIELD (normal, SF_GET_DEBUG_FIELD (debug));
3221 } /* c_symbol_merge() */
3222
3223 static int
3224 c_line_new (symbol, paddr, line_number, frag)
3225 symbolS * symbol;
3226 long paddr;
3227 int line_number;
3228 fragS * frag;
3229 {
3230 struct lineno_list *new_line =
3231 (struct lineno_list *) xmalloc (sizeof (struct lineno_list));
3232
3233 segment_info_type *s = segment_info + now_seg;
3234 new_line->line.l_lnno = line_number;
3235
3236 if (line_number == 0)
3237 {
3238 last_line_symbol = symbol;
3239 new_line->line.l_addr.l_symndx = (long) symbol;
3240 }
3241 else
3242 {
3243 new_line->line.l_addr.l_paddr = paddr;
3244 }
3245
3246 new_line->frag = (char *) frag;
3247 new_line->next = (struct lineno_list *) NULL;
3248
3249
3250 if (s->lineno_list_head == (struct lineno_list *) NULL)
3251 {
3252 s->lineno_list_head = new_line;
3253 }
3254 else
3255 {
3256 s->lineno_list_tail->next = new_line;
3257 }
3258 s->lineno_list_tail = new_line;
3259 return LINESZ * s->scnhdr.s_nlnno++;
3260 }
3261
3262 void
3263 c_dot_file_symbol (filename)
3264 char *filename;
3265 {
3266 symbolS *symbolP;
3267
3268 symbolP = symbol_new (".file",
3269 SEG_DEBUG,
3270 0,
3271 &zero_address_frag);
3272
3273 S_SET_STORAGE_CLASS (symbolP, C_FILE);
3274 S_SET_NUMBER_AUXILIARY (symbolP, 1);
3275 SA_SET_FILE_FNAME (symbolP, filename);
3276 #ifndef NO_LISTING
3277 {
3278 extern int listing;
3279 if (listing)
3280 {
3281 listing_source_file (filename);
3282 }
3283
3284 }
3285
3286 #endif
3287 SF_SET_DEBUG (symbolP);
3288 S_SET_VALUE (symbolP, (valueT) previous_file_symbol);
3289
3290 previous_file_symbol = symbolP;
3291
3292 /* Make sure that the symbol is first on the symbol chain */
3293 if (symbol_rootP != symbolP)
3294 {
3295 if (symbolP == symbol_lastP)
3296 {
3297 symbol_lastP = symbol_lastP->sy_previous;
3298 } /* if it was the last thing on the list */
3299
3300 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
3301 symbol_insert (symbolP, symbol_rootP, &symbol_rootP, &symbol_lastP);
3302 symbol_rootP = symbolP;
3303 } /* if not first on the list */
3304
3305 } /* c_dot_file_symbol() */
3306
3307 /*
3308 * Build a 'section static' symbol.
3309 */
3310
3311 symbolS *
3312 c_section_symbol (name, idx)
3313 char *name;
3314 int idx;
3315 {
3316 symbolS *symbolP;
3317
3318 symbolP = symbol_new (name, idx,
3319 0,
3320 &zero_address_frag);
3321
3322 S_SET_STORAGE_CLASS (symbolP, C_STAT);
3323 S_SET_NUMBER_AUXILIARY (symbolP, 1);
3324
3325 SF_SET_STATICS (symbolP);
3326
3327 return symbolP;
3328 } /* c_section_symbol() */
3329
3330 static void
3331 w_symbols (abfd, where, symbol_rootP)
3332 bfd * abfd;
3333 char *where;
3334 symbolS * symbol_rootP;
3335 {
3336 symbolS *symbolP;
3337 unsigned int i;
3338
3339 /* First fill in those values we have only just worked out */
3340 for (i = SEG_E0; i < SEG_E9; i++)
3341 {
3342 symbolP = segment_info[i].dot;
3343 if (symbolP)
3344 {
3345 SA_SET_SCN_SCNLEN (symbolP, segment_info[i].scnhdr.s_size);
3346 SA_SET_SCN_NRELOC (symbolP, segment_info[i].scnhdr.s_nreloc);
3347 SA_SET_SCN_NLINNO (symbolP, segment_info[i].scnhdr.s_nlnno);
3348 }
3349 }
3350
3351 /*
3352 * Emit all symbols left in the symbol chain.
3353 */
3354 for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next (symbolP))
3355 {
3356 /* Used to save the offset of the name. It is used to point
3357 to the string in memory but must be a file offset. */
3358 register char *temp;
3359
3360 tc_coff_symbol_emit_hook (symbolP);
3361
3362 temp = S_GET_NAME (symbolP);
3363 if (SF_GET_STRING (symbolP))
3364 {
3365 S_SET_OFFSET (symbolP, symbolP->sy_name_offset);
3366 S_SET_ZEROES (symbolP, 0);
3367 }
3368 else
3369 {
3370 memset (symbolP->sy_symbol.ost_entry.n_name, 0, SYMNMLEN);
3371 strncpy (symbolP->sy_symbol.ost_entry.n_name, temp, SYMNMLEN);
3372 }
3373 where = symbol_to_chars (abfd, where, symbolP);
3374 S_SET_NAME (symbolP, temp);
3375 }
3376
3377 } /* w_symbols() */
3378
3379 static void
3380 obj_coff_lcomm (ignore)
3381 int ignore;
3382 {
3383 s_lcomm(0);
3384 return;
3385 #if 0
3386 char *name;
3387 char c;
3388 int temp;
3389 char *p;
3390
3391 symbolS *symbolP;
3392
3393 name = input_line_pointer;
3394
3395 c = get_symbol_end ();
3396 p = input_line_pointer;
3397 *p = c;
3398 SKIP_WHITESPACE ();
3399 if (*input_line_pointer != ',')
3400 {
3401 as_bad ("Expected comma after name");
3402 ignore_rest_of_line ();
3403 return;
3404 }
3405 if (*input_line_pointer == '\n')
3406 {
3407 as_bad ("Missing size expression");
3408 return;
3409 }
3410 input_line_pointer++;
3411 if ((temp = get_absolute_expression ()) < 0)
3412 {
3413 as_warn ("lcomm length (%d.) <0! Ignored.", temp);
3414 ignore_rest_of_line ();
3415 return;
3416 }
3417 *p = 0;
3418
3419 symbolP = symbol_find_or_make(name);
3420
3421 if (S_GET_SEGMENT(symbolP) == SEG_UNKNOWN &&
3422 S_GET_VALUE(symbolP) == 0)
3423 {
3424 if (! need_pass_2)
3425 {
3426 char *p;
3427 segT current_seg = now_seg; /* save current seg */
3428 subsegT current_subseg = now_subseg;
3429
3430 subseg_set (SEG_E2, 1);
3431 symbolP->sy_frag = frag_now;
3432 p = frag_var(rs_org, 1, 1, (relax_substateT)0, symbolP,
3433 temp, (char *)0);
3434 *p = 0;
3435 subseg_set (current_seg, current_subseg); /* restore current seg */
3436 S_SET_SEGMENT(symbolP, SEG_E2);
3437 S_SET_STORAGE_CLASS(symbolP, C_STAT);
3438 }
3439 }
3440 else
3441 as_bad("Symbol %s already defined", name);
3442
3443 demand_empty_rest_of_line();
3444 #endif
3445 }
3446
3447 static void
3448 fixup_mdeps (frags, h, this_segment)
3449 fragS * frags;
3450 object_headers * h;
3451 segT this_segment;
3452 {
3453 subseg_change (this_segment, 0);
3454 while (frags)
3455 {
3456 switch (frags->fr_type)
3457 {
3458 case rs_align:
3459 case rs_org:
3460 frags->fr_type = rs_fill;
3461 frags->fr_offset =
3462 (frags->fr_next->fr_address - frags->fr_address - frags->fr_fix);
3463 break;
3464 case rs_machine_dependent:
3465 md_convert_frag (h, frags);
3466 frag_wane (frags);
3467 break;
3468 default:
3469 ;
3470 }
3471 frags = frags->fr_next;
3472 }
3473 }
3474
3475 #if 1
3476 static void
3477 fixup_segment (segP, this_segment_type)
3478 segment_info_type * segP;
3479 segT this_segment_type;
3480 {
3481 register fixS * fixP;
3482 register symbolS *add_symbolP;
3483 register symbolS *sub_symbolP;
3484 register long add_number;
3485 register int size;
3486 register char *place;
3487 register long where;
3488 register char pcrel;
3489 register fragS *fragP;
3490 register segT add_symbol_segment = absolute_section;
3491
3492
3493 for (fixP = segP->fix_root; fixP; fixP = fixP->fx_next)
3494 {
3495 fragP = fixP->fx_frag;
3496 know (fragP);
3497 where = fixP->fx_where;
3498 place = fragP->fr_literal + where;
3499 size = fixP->fx_size;
3500 add_symbolP = fixP->fx_addsy;
3501 #ifdef TC_I960
3502 if (fixP->fx_tcbit && SF_GET_CALLNAME (add_symbolP))
3503 {
3504 /* Relocation should be done via the associated 'bal' entry
3505 point symbol. */
3506
3507 if (!SF_GET_BALNAME (tc_get_bal_of_call (add_symbolP)))
3508 {
3509 as_bad_where (fixP->fx_file, fixP->fx_line,
3510 "No 'bal' entry point for leafproc %s",
3511 S_GET_NAME (add_symbolP));
3512 continue;
3513 }
3514 fixP->fx_addsy = add_symbolP = tc_get_bal_of_call (add_symbolP);
3515 }
3516 #endif
3517 sub_symbolP = fixP->fx_subsy;
3518 add_number = fixP->fx_offset;
3519 pcrel = fixP->fx_pcrel;
3520
3521 if (add_symbolP)
3522 {
3523 add_symbol_segment = S_GET_SEGMENT (add_symbolP);
3524 } /* if there is an addend */
3525
3526 if (sub_symbolP)
3527 {
3528 if (!add_symbolP)
3529 {
3530 /* Its just -sym */
3531 if (S_GET_SEGMENT (sub_symbolP) != absolute_section)
3532 {
3533 as_bad_where (fixP->fx_file, fixP->fx_line,
3534 "Negative of non-absolute symbol %s",
3535 S_GET_NAME (sub_symbolP));
3536 } /* not absolute */
3537
3538 add_number -= S_GET_VALUE (sub_symbolP);
3539 fixP->fx_subsy = 0;
3540
3541 /* if sub_symbol is in the same segment that add_symbol
3542 and add_symbol is either in DATA, TEXT, BSS or ABSOLUTE */
3543 }
3544 else if ((S_GET_SEGMENT (sub_symbolP) == add_symbol_segment)
3545 && (SEG_NORMAL (add_symbol_segment)
3546 || (add_symbol_segment == absolute_section)))
3547 {
3548 /* Difference of 2 symbols from same segment. Can't
3549 make difference of 2 undefineds: 'value' means
3550 something different for N_UNDF. */
3551 #ifdef TC_I960
3552 /* Makes no sense to use the difference of 2 arbitrary symbols
3553 as the target of a call instruction. */
3554 if (fixP->fx_tcbit)
3555 {
3556 as_bad_where (fixP->fx_file, fixP->fx_line,
3557 "callj to difference of 2 symbols");
3558 }
3559 #endif /* TC_I960 */
3560 add_number += S_GET_VALUE (add_symbolP) -
3561 S_GET_VALUE (sub_symbolP);
3562
3563 add_symbolP = NULL;
3564 fixP->fx_addsy = NULL;
3565 fixP->fx_subsy = NULL;
3566 fixP->fx_done = 1;
3567 }
3568 else
3569 {
3570 /* Different segments in subtraction. */
3571 know (!(S_IS_EXTERNAL (sub_symbolP) && (S_GET_SEGMENT (sub_symbolP) == absolute_section)));
3572
3573 if ((S_GET_SEGMENT (sub_symbolP) == absolute_section))
3574 {
3575 add_number -= S_GET_VALUE (sub_symbolP);
3576 }
3577 #ifdef DIFF_EXPR_OK
3578 else if (S_GET_SEGMENT (sub_symbolP) == this_segment_type
3579 #if 0 /* Okay for 68k, at least... */
3580 && !pcrel
3581 #endif
3582 )
3583 {
3584 /* Make it pc-relative. */
3585 add_number += (md_pcrel_from (fixP)
3586 - S_GET_VALUE (sub_symbolP));
3587 pcrel = 1;
3588 fixP->fx_pcrel = 1;
3589 sub_symbolP = 0;
3590 fixP->fx_subsy = 0;
3591 }
3592 #endif
3593 else
3594 {
3595 as_bad_where (fixP->fx_file, fixP->fx_line,
3596 "Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %ld.",
3597 segment_name (S_GET_SEGMENT (sub_symbolP)),
3598 S_GET_NAME (sub_symbolP),
3599 (long) (fragP->fr_address + where));
3600 } /* if absolute */
3601 }
3602 } /* if sub_symbolP */
3603
3604 if (add_symbolP)
3605 {
3606 if (add_symbol_segment == this_segment_type && pcrel)
3607 {
3608 /*
3609 * This fixup was made when the symbol's segment was
3610 * SEG_UNKNOWN, but it is now in the local segment.
3611 * So we know how to do the address without relocation.
3612 */
3613 #ifdef TC_I960
3614 /* reloc_callj() may replace a 'call' with a 'calls' or a 'bal',
3615 * in which cases it modifies *fixP as appropriate. In the case
3616 * of a 'calls', no further work is required, and *fixP has been
3617 * set up to make the rest of the code below a no-op.
3618 */
3619 reloc_callj (fixP);
3620 #endif /* TC_I960 */
3621
3622 add_number += S_GET_VALUE (add_symbolP);
3623 add_number -= md_pcrel_from (fixP);
3624 #if defined (TC_I386) || defined (TE_LYNX)
3625 /* On the 386 we must adjust by the segment
3626 vaddr as well. Ian Taylor. */
3627 add_number -= segP->scnhdr.s_vaddr;
3628 #endif
3629 pcrel = 0; /* Lie. Don't want further pcrel processing. */
3630 fixP->fx_addsy = NULL;
3631 fixP->fx_done = 1;
3632 }
3633 else
3634 {
3635 switch (add_symbol_segment)
3636 {
3637 case absolute_section:
3638 #ifdef TC_I960
3639 reloc_callj (fixP); /* See comment about reloc_callj() above*/
3640 #endif /* TC_I960 */
3641 add_number += S_GET_VALUE (add_symbolP);
3642 fixP->fx_addsy = NULL;
3643 fixP->fx_done = 1;
3644 add_symbolP = NULL;
3645 break;
3646 default:
3647
3648 #ifdef TC_A29K
3649 /* This really should be handled in the linker, but
3650 backward compatibility forbids. */
3651 add_number += S_GET_VALUE (add_symbolP);
3652 #else
3653 add_number += S_GET_VALUE (add_symbolP) +
3654 segment_info[S_GET_SEGMENT (add_symbolP)].scnhdr.s_paddr;
3655 #endif
3656 break;
3657
3658 case SEG_UNKNOWN:
3659 #ifdef TC_I960
3660 if ((int) fixP->fx_bit_fixP == 13)
3661 {
3662 /* This is a COBR instruction. They have only a
3663 * 13-bit displacement and are only to be used
3664 * for local branches: flag as error, don't generate
3665 * relocation.
3666 */
3667 as_bad_where (fixP->fx_file, fixP->fx_line,
3668 "can't use COBR format with external label");
3669 fixP->fx_addsy = NULL;
3670 fixP->fx_done = 1;
3671 continue;
3672 } /* COBR */
3673 #endif /* TC_I960 */
3674 #if defined (TC_I386) || defined (TE_LYNX)
3675 /* 386 COFF uses a peculiar format in
3676 which the value of a common symbol is
3677 stored in the .text segment (I've
3678 checked this on SVR3.2 and SCO 3.2.2)
3679 Ian Taylor <ian@cygnus.com>. */
3680 if (S_IS_COMMON (add_symbolP))
3681 add_number += S_GET_VALUE (add_symbolP);
3682 #endif
3683 break;
3684
3685
3686 } /* switch on symbol seg */
3687 } /* if not in local seg */
3688 } /* if there was a + symbol */
3689
3690 if (pcrel)
3691 {
3692 #ifndef TC_M88K
3693 /* This adjustment is not correct on the m88k, for which the
3694 linker does all the computation. */
3695 add_number -= md_pcrel_from (fixP);
3696 #endif
3697 if (add_symbolP == 0)
3698 {
3699 fixP->fx_addsy = &abs_symbol;
3700 } /* if there's an add_symbol */
3701 #if defined (TC_I386) || defined (TE_LYNX)
3702 /* On the 386 we must adjust by the segment vaddr
3703 as well. Ian Taylor. */
3704 add_number -= segP->scnhdr.s_vaddr;
3705 #endif
3706 } /* if pcrel */
3707
3708 if (!fixP->fx_bit_fixP)
3709 {
3710 #ifndef TC_M88K
3711 /* The m88k uses the offset field of the reloc to get around
3712 this problem. */
3713 if ((size == 1
3714 && (add_number & ~0xFF)
3715 && ((add_number & ~0xFF) != (-1 & ~0xFF)))
3716 || (size == 2
3717 && (add_number & ~0xFFFF)
3718 && ((add_number & ~0xFFFF) != (-1 & ~0xFFFF))))
3719 {
3720 as_bad_where (fixP->fx_file, fixP->fx_line,
3721 "Value of %ld too large for field of %d bytes at 0x%lx",
3722 (long) add_number, size,
3723 (unsigned long) (fragP->fr_address + where));
3724 }
3725 #endif
3726 #ifdef WARN_SIGNED_OVERFLOW_WORD
3727 /* Warn if a .word value is too large when treated as
3728 a signed number. We already know it is not too
3729 negative. This is to catch over-large switches
3730 generated by gcc on the 68k. */
3731 if (!flag_signed_overflow_ok
3732 && size == 2
3733 && add_number > 0x7fff)
3734 as_bad_where (fixP->fx_file, fixP->fx_line,
3735 "Signed .word overflow; switch may be too large; %ld at 0x%lx",
3736 (long) add_number,
3737 (unsigned long) (fragP->fr_address + where));
3738 #endif
3739 } /* not a bit fix */
3740 /* once this fix has been applied, we don't have to output anything
3741 nothing more need be done -*/
3742 md_apply_fix (fixP, add_number);
3743 } /* For each fixS in this segment. */
3744 } /* fixup_segment() */
3745
3746 #endif
3747
3748 /* The first entry in a .stab section is special. */
3749
3750 void
3751 obj_coff_init_stab_section (seg)
3752 segT seg;
3753 {
3754 char *file;
3755 char *p;
3756 char *stabstr_name;
3757 unsigned int stroff;
3758
3759 /* Make space for this first symbol. */
3760 p = frag_more (12);
3761 /* Zero it out. */
3762 memset (p, 0, 12);
3763 as_where (&file, (unsigned int *) NULL);
3764 stabstr_name = (char *) alloca (strlen (segment_info[seg].scnhdr.s_name) + 4);
3765 strcpy (stabstr_name, segment_info[seg].scnhdr.s_name);
3766 strcat (stabstr_name, "str");
3767 stroff = get_stab_string_offset (file, stabstr_name);
3768 know (stroff == 1);
3769 md_number_to_chars (p, stroff, 4);
3770 }
3771
3772 /* Fill in the counts in the first entry in a .stab section. */
3773
3774 static void
3775 adjust_stab_section(abfd, seg)
3776 bfd *abfd;
3777 segT seg;
3778 {
3779 segT stabstrseg = SEG_UNKNOWN;
3780 char *secname, *name, *name2;
3781 char *p = NULL;
3782 int i, strsz = 0, nsyms;
3783 fragS *frag = segment_info[seg].frchainP->frch_root;
3784
3785 /* Look for the associated string table section. */
3786
3787 secname = segment_info[seg].scnhdr.s_name;
3788 name = (char *) alloca (strlen (secname) + 4);
3789 strcpy (name, secname);
3790 strcat (name, "str");
3791
3792 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
3793 {
3794 name2 = segment_info[i].scnhdr.s_name;
3795 if (name2 != NULL && strncmp(name2, name, 8) == 0)
3796 {
3797 stabstrseg = i;
3798 break;
3799 }
3800 }
3801
3802 /* If we found the section, get its size. */
3803 if (stabstrseg != SEG_UNKNOWN)
3804 strsz = size_section (abfd, stabstrseg);
3805
3806 nsyms = size_section (abfd, seg) / 12 - 1;
3807
3808 /* Look for the first frag of sufficient size for the initial stab
3809 symbol, and collect a pointer to it. */
3810 while (frag && frag->fr_fix < 12)
3811 frag = frag->fr_next;
3812 assert (frag != 0);
3813 p = frag->fr_literal;
3814 assert (p != 0);
3815
3816 /* Write in the number of stab symbols and the size of the string
3817 table. */
3818 bfd_h_put_16 (abfd, (bfd_vma) nsyms, (bfd_byte *) p + 6);
3819 bfd_h_put_32 (abfd, (bfd_vma) strsz, (bfd_byte *) p + 8);
3820 }
3821
3822 #endif /* not BFD_ASSEMBLER */
3823
3824 const pseudo_typeS obj_pseudo_table[] =
3825 {
3826 {"def", obj_coff_def, 0},
3827 {"dim", obj_coff_dim, 0},
3828 {"endef", obj_coff_endef, 0},
3829 {"line", obj_coff_line, 0},
3830 {"ln", obj_coff_ln, 0},
3831 {"appline", obj_coff_ln, 1},
3832 {"scl", obj_coff_scl, 0},
3833 {"size", obj_coff_size, 0},
3834 {"tag", obj_coff_tag, 0},
3835 {"type", obj_coff_type, 0},
3836 {"val", obj_coff_val, 0},
3837 {"section", obj_coff_section, 0},
3838 #ifndef BFD_ASSEMBLER
3839 {"use", obj_coff_section, 0},
3840 {"sect", obj_coff_section, 0},
3841 {"text", obj_coff_text, 0},
3842 {"data", obj_coff_data, 0},
3843 {"bss", obj_coff_bss, 0},
3844 {"lcomm", obj_coff_lcomm, 0},
3845 {"ident", obj_coff_ident, 0},
3846 #else
3847 {"optim", s_ignore, 0}, /* For sun386i cc (?) */
3848 {"ident", s_ignore, 0}, /* we don't yet handle this. */
3849 #endif
3850 {"ABORT", s_abort, 0},
3851 #ifdef TC_M88K
3852 /* The m88k uses sdef instead of def. */
3853 {"sdef", obj_coff_def, 0},
3854 #endif
3855 {NULL} /* end sentinel */
3856 }; /* obj_pseudo_table */
GDB Binutils - Deliverables
This page took 0.104205 seconds and 5 git commands to generate.