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