projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
Wed Jan 31 14:03:17 1996 Richard Henderson <rth@tamu.edu>
[deliverable/binutils-gdb.git] / gas / config / obj-coff.c
1 /* coff object file format
2 Copyright (C) 1989, 90, 91, 92, 93, 94, 95, 1996
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 case rs_align_code:
1554 size += frag->fr_fix;
1555 size += relax_align (size, frag->fr_offset);
1556 break;
1557 default:
1558 BAD_CASE (frag->fr_type);
1559 break;
1560 }
1561 frag = frag->fr_next;
1562 }
1563 segment_info[idx].scnhdr.s_size = size;
1564 return size;
1565 }
1566
1567
1568 static unsigned int
1569 count_entries_in_chain (idx)
1570 unsigned int idx;
1571 {
1572 unsigned int nrelocs;
1573 fixS *fixup_ptr;
1574
1575 /* Count the relocations */
1576 fixup_ptr = segment_info[idx].fix_root;
1577 nrelocs = 0;
1578 while (fixup_ptr != (fixS *) NULL)
1579 {
1580 if (TC_COUNT_RELOC (fixup_ptr))
1581 {
1582 #ifdef TC_A29K
1583 if (fixup_ptr->fx_r_type == RELOC_CONSTH)
1584 nrelocs += 2;
1585 else
1586 nrelocs++;
1587 #else
1588 nrelocs++;
1589 #endif
1590 }
1591
1592 fixup_ptr = fixup_ptr->fx_next;
1593 }
1594 return nrelocs;
1595 }
1596
1597 #ifdef TE_AUX
1598
1599 static int compare_external_relocs PARAMS ((const PTR, const PTR));
1600
1601 /* AUX's ld expects relocations to be sorted */
1602 static int
1603 compare_external_relocs (x, y)
1604 const PTR x;
1605 const PTR y;
1606 {
1607 struct external_reloc *a = (struct external_reloc *) x;
1608 struct external_reloc *b = (struct external_reloc *) y;
1609 bfd_vma aadr = bfd_getb32 (a->r_vaddr);
1610 bfd_vma badr = bfd_getb32 (b->r_vaddr);
1611 return (aadr < badr ? -1 : badr < aadr ? 1 : 0);
1612 }
1613
1614 #endif
1615
1616 /* output all the relocations for a section */
1617 void
1618 do_relocs_for (abfd, h, file_cursor)
1619 bfd * abfd;
1620 object_headers * h;
1621 unsigned long *file_cursor;
1622 {
1623 unsigned int nrelocs;
1624 unsigned int idx;
1625 unsigned long reloc_start = *file_cursor;
1626
1627 for (idx = SEG_E0; idx < SEG_E9; idx++)
1628 {
1629 if (segment_info[idx].scnhdr.s_name[0])
1630 {
1631 struct external_reloc *ext_ptr;
1632 struct external_reloc *external_reloc_vec;
1633 unsigned int external_reloc_size;
1634 unsigned int base = segment_info[idx].scnhdr.s_paddr;
1635 fixS *fix_ptr = segment_info[idx].fix_root;
1636 nrelocs = count_entries_in_chain (idx);
1637
1638 if (nrelocs)
1639 /* Bypass this stuff if no relocs. This also incidentally
1640 avoids a SCO bug, where free(malloc(0)) tends to crash. */
1641 {
1642 external_reloc_size = nrelocs * RELSZ;
1643 external_reloc_vec =
1644 (struct external_reloc *) malloc (external_reloc_size);
1645
1646 ext_ptr = external_reloc_vec;
1647
1648 /* Fill in the internal coff style reloc struct from the
1649 internal fix list. */
1650 while (fix_ptr)
1651 {
1652 struct internal_reloc intr;
1653
1654 /* Only output some of the relocations */
1655 if (TC_COUNT_RELOC (fix_ptr))
1656 {
1657 #ifdef TC_RELOC_MANGLE
1658 TC_RELOC_MANGLE (&segment_info[idx], fix_ptr, &intr,
1659 base);
1660
1661 #else
1662 symbolS *dot;
1663 symbolS *symbol_ptr = fix_ptr->fx_addsy;
1664
1665 intr.r_type = TC_COFF_FIX2RTYPE (fix_ptr);
1666 intr.r_vaddr =
1667 base + fix_ptr->fx_frag->fr_address + fix_ptr->fx_where;
1668
1669 #ifdef TC_KEEP_FX_OFFSET
1670 intr.r_offset = fix_ptr->fx_offset;
1671 #else
1672 intr.r_offset = 0;
1673 #endif
1674
1675 while (S_GET_SEGMENT (symbol_ptr) == undefined_section
1676 && symbol_ptr->sy_value.X_op == O_symbol)
1677 symbol_ptr = symbol_ptr->sy_value.X_add_symbol;
1678
1679 /* Turn the segment of the symbol into an offset. */
1680 if (symbol_ptr)
1681 {
1682 dot = segment_info[S_GET_SEGMENT (symbol_ptr)].dot;
1683 if (dot)
1684 {
1685 intr.r_symndx = dot->sy_number;
1686 }
1687 else
1688 {
1689 intr.r_symndx = symbol_ptr->sy_number;
1690 }
1691
1692 }
1693 else
1694 {
1695 intr.r_symndx = -1;
1696 }
1697 #endif
1698
1699 (void) bfd_coff_swap_reloc_out (abfd, &intr, ext_ptr);
1700 ext_ptr++;
1701
1702 #if defined(TC_A29K)
1703
1704 /* The 29k has a special kludge for the high 16 bit
1705 reloc. Two relocations are emited, R_IHIHALF,
1706 and R_IHCONST. The second one doesn't contain a
1707 symbol, but uses the value for offset. */
1708
1709 if (intr.r_type == R_IHIHALF)
1710 {
1711 /* now emit the second bit */
1712 intr.r_type = R_IHCONST;
1713 intr.r_symndx = fix_ptr->fx_addnumber;
1714 (void) bfd_coff_swap_reloc_out (abfd, &intr, ext_ptr);
1715 ext_ptr++;
1716 }
1717 #endif
1718 }
1719
1720 fix_ptr = fix_ptr->fx_next;
1721 }
1722
1723 #ifdef TE_AUX
1724 /* Sort the reloc table */
1725 qsort ((PTR) external_reloc_vec, nrelocs,
1726 sizeof (struct external_reloc), compare_external_relocs);
1727 #endif
1728
1729 /* Write out the reloc table */
1730 bfd_write ((PTR) external_reloc_vec, 1, external_reloc_size,
1731 abfd);
1732 free (external_reloc_vec);
1733
1734 /* Fill in section header info. */
1735 segment_info[idx].scnhdr.s_relptr = *file_cursor;
1736 *file_cursor += external_reloc_size;
1737 segment_info[idx].scnhdr.s_nreloc = nrelocs;
1738 }
1739 else
1740 {
1741 /* No relocs */
1742 segment_info[idx].scnhdr.s_relptr = 0;
1743 }
1744 }
1745 }
1746 /* Set relocation_size field in file headers */
1747 H_SET_RELOCATION_SIZE (h, *file_cursor - reloc_start, 0);
1748 }
1749
1750
1751 /* run through a frag chain and write out the data to go with it, fill
1752 in the scnhdrs with the info on the file postions
1753 */
1754 static void
1755 fill_section (abfd, h, file_cursor)
1756 bfd * abfd;
1757 object_headers *h;
1758 unsigned long *file_cursor;
1759 {
1760
1761 unsigned int i;
1762 unsigned int paddr = 0;
1763
1764 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
1765 {
1766 unsigned int offset = 0;
1767 struct internal_scnhdr *s = &(segment_info[i].scnhdr);
1768
1769 PROGRESS (1);
1770
1771 if (s->s_name[0])
1772 {
1773 fragS *frag = segment_info[i].frchainP->frch_root;
1774 char *buffer;
1775
1776 if (s->s_size == 0)
1777 s->s_scnptr = 0;
1778 else
1779 {
1780 buffer = xmalloc (s->s_size);
1781 s->s_scnptr = *file_cursor;
1782 }
1783 know (s->s_paddr == paddr);
1784
1785 if (strcmp (s->s_name, ".text") == 0)
1786 s->s_flags |= STYP_TEXT;
1787 else if (strcmp (s->s_name, ".data") == 0)
1788 s->s_flags |= STYP_DATA;
1789 else if (strcmp (s->s_name, ".bss") == 0)
1790 {
1791 s->s_scnptr = 0;
1792 s->s_flags |= STYP_BSS;
1793
1794 /* @@ Should make the i386 and a29k coff targets define
1795 COFF_NOLOAD_PROBLEM, and have only one test here. */
1796 #ifndef TC_I386
1797 #ifndef TC_A29K
1798 #ifndef COFF_NOLOAD_PROBLEM
1799 /* Apparently the SVR3 linker (and exec syscall) and UDI
1800 mondfe progrem are confused by noload sections. */
1801 s->s_flags |= STYP_NOLOAD;
1802 #endif
1803 #endif
1804 #endif
1805 }
1806 else if (strcmp (s->s_name, ".lit") == 0)
1807 s->s_flags = STYP_LIT | STYP_TEXT;
1808 else if (strcmp (s->s_name, ".init") == 0)
1809 s->s_flags |= STYP_TEXT;
1810 else if (strcmp (s->s_name, ".fini") == 0)
1811 s->s_flags |= STYP_TEXT;
1812 else if (strncmp (s->s_name, ".comment", 8) == 0)
1813 s->s_flags |= STYP_INFO;
1814
1815 while (frag)
1816 {
1817 unsigned int fill_size;
1818 switch (frag->fr_type)
1819 {
1820 case rs_machine_dependent:
1821 if (frag->fr_fix)
1822 {
1823 memcpy (buffer + frag->fr_address,
1824 frag->fr_literal,
1825 (unsigned int) frag->fr_fix);
1826 offset += frag->fr_fix;
1827 }
1828
1829 break;
1830 case rs_space:
1831 assert (frag->fr_symbol == 0);
1832 case rs_fill:
1833 case rs_align:
1834 case rs_align_code:
1835 case rs_org:
1836 if (frag->fr_fix)
1837 {
1838 memcpy (buffer + frag->fr_address,
1839 frag->fr_literal,
1840 (unsigned int) frag->fr_fix);
1841 offset += frag->fr_fix;
1842 }
1843
1844 fill_size = frag->fr_var;
1845 if (fill_size && frag->fr_offset > 0)
1846 {
1847 unsigned int count;
1848 unsigned int off = frag->fr_fix;
1849 for (count = frag->fr_offset; count; count--)
1850 {
1851 if (fill_size + frag->fr_address + off <= s->s_size)
1852 {
1853 memcpy (buffer + frag->fr_address + off,
1854 frag->fr_literal + frag->fr_fix,
1855 fill_size);
1856 off += fill_size;
1857 offset += fill_size;
1858 }
1859 }
1860 }
1861 break;
1862 case rs_broken_word:
1863 break;
1864 default:
1865 abort ();
1866 }
1867 frag = frag->fr_next;
1868 }
1869
1870 if (s->s_size != 0)
1871 {
1872 if (s->s_scnptr != 0)
1873 {
1874 bfd_write (buffer, s->s_size, 1, abfd);
1875 *file_cursor += s->s_size;
1876 }
1877 free (buffer);
1878 }
1879 paddr += s->s_size;
1880 }
1881 }
1882 }
1883
1884 /* Coff file generation & utilities */
1885
1886 static void
1887 coff_header_append (abfd, h)
1888 bfd * abfd;
1889 object_headers * h;
1890 {
1891 unsigned int i;
1892 char buffer[1000];
1893 char buffero[1000];
1894
1895 bfd_seek (abfd, 0, 0);
1896
1897 #ifndef OBJ_COFF_OMIT_OPTIONAL_HEADER
1898 H_SET_MAGIC_NUMBER (h, COFF_MAGIC);
1899 H_SET_VERSION_STAMP (h, 0);
1900 H_SET_ENTRY_POINT (h, 0);
1901 H_SET_TEXT_START (h, segment_info[SEG_E0].frchainP->frch_root->fr_address);
1902 H_SET_DATA_START (h, segment_info[SEG_E1].frchainP->frch_root->fr_address);
1903 H_SET_SIZEOF_OPTIONAL_HEADER (h, bfd_coff_swap_aouthdr_out(abfd, &h->aouthdr,
1904 buffero));
1905 #else /* defined (OBJ_COFF_OMIT_OPTIONAL_HEADER) */
1906 H_SET_SIZEOF_OPTIONAL_HEADER (h, 0);
1907 #endif /* defined (OBJ_COFF_OMIT_OPTIONAL_HEADER) */
1908
1909 i = bfd_coff_swap_filehdr_out (abfd, &h->filehdr, buffer);
1910
1911 bfd_write (buffer, i, 1, abfd);
1912 bfd_write (buffero, H_GET_SIZEOF_OPTIONAL_HEADER (h), 1, abfd);
1913
1914 for (i = SEG_E0; i < SEG_E9; i++)
1915 {
1916 if (segment_info[i].scnhdr.s_name[0])
1917 {
1918 unsigned int size =
1919 bfd_coff_swap_scnhdr_out (abfd,
1920 &(segment_info[i].scnhdr),
1921 buffer);
1922 if (size == 0)
1923 as_bad ("bfd_coff_swap_scnhdr_out failed");
1924 bfd_write (buffer, size, 1, abfd);
1925 }
1926 }
1927 }
1928
1929
1930 char *
1931 symbol_to_chars (abfd, where, symbolP)
1932 bfd * abfd;
1933 char *where;
1934 symbolS * symbolP;
1935 {
1936 unsigned int numaux = symbolP->sy_symbol.ost_entry.n_numaux;
1937 unsigned int i;
1938 valueT val;
1939
1940 /* Turn any symbols with register attributes into abs symbols */
1941 if (S_GET_SEGMENT (symbolP) == reg_section)
1942 {
1943 S_SET_SEGMENT (symbolP, absolute_section);
1944 }
1945 /* At the same time, relocate all symbols to their output value */
1946
1947 val = (segment_info[S_GET_SEGMENT (symbolP)].scnhdr.s_paddr
1948 + S_GET_VALUE (symbolP));
1949
1950 S_SET_VALUE (symbolP, val);
1951
1952 symbolP->sy_symbol.ost_entry.n_value = val;
1953
1954 where += bfd_coff_swap_sym_out (abfd, &symbolP->sy_symbol.ost_entry,
1955 where);
1956
1957 for (i = 0; i < numaux; i++)
1958 {
1959 where += bfd_coff_swap_aux_out (abfd,
1960 &symbolP->sy_symbol.ost_auxent[i],
1961 S_GET_DATA_TYPE (symbolP),
1962 S_GET_STORAGE_CLASS (symbolP),
1963 i, numaux, where);
1964 }
1965 return where;
1966
1967 }
1968
1969 void
1970 obj_symbol_new_hook (symbolP)
1971 symbolS *symbolP;
1972 {
1973 char underscore = 0; /* Symbol has leading _ */
1974
1975 /* Effective symbol */
1976 /* Store the pointer in the offset. */
1977 S_SET_ZEROES (symbolP, 0L);
1978 S_SET_DATA_TYPE (symbolP, T_NULL);
1979 S_SET_STORAGE_CLASS (symbolP, 0);
1980 S_SET_NUMBER_AUXILIARY (symbolP, 0);
1981 /* Additional information */
1982 symbolP->sy_symbol.ost_flags = 0;
1983 /* Auxiliary entries */
1984 memset ((char *) &symbolP->sy_symbol.ost_auxent[0], 0, AUXESZ);
1985
1986 if (S_IS_STRING (symbolP))
1987 SF_SET_STRING (symbolP);
1988 if (!underscore && S_IS_LOCAL (symbolP))
1989 SF_SET_LOCAL (symbolP);
1990 }
1991
1992 /*
1993 * Handle .ln directives.
1994 */
1995
1996 static void
1997 obj_coff_ln (appline)
1998 int appline;
1999 {
2000 int l;
2001
2002 if (! appline && def_symbol_in_progress != NULL)
2003 {
2004 as_warn (".ln pseudo-op inside .def/.endef: ignored.");
2005 demand_empty_rest_of_line ();
2006 return;
2007 } /* wrong context */
2008
2009 l = get_absolute_expression ();
2010 c_line_new (0, frag_now_fix (), l, frag_now);
2011 #ifndef NO_LISTING
2012 {
2013 extern int listing;
2014
2015 if (listing)
2016 {
2017 if (! appline)
2018 l += line_base - 1;
2019 listing_source_line ((unsigned int) l);
2020 }
2021
2022 }
2023 #endif
2024 demand_empty_rest_of_line ();
2025 }
2026
2027 /*
2028 * def()
2029 *
2030 * Handle .def directives.
2031 *
2032 * One might ask : why can't we symbol_new if the symbol does not
2033 * already exist and fill it with debug information. Because of
2034 * the C_EFCN special symbol. It would clobber the value of the
2035 * function symbol before we have a chance to notice that it is
2036 * a C_EFCN. And a second reason is that the code is more clear this
2037 * way. (at least I think it is :-).
2038 *
2039 */
2040
2041 #define SKIP_SEMI_COLON() while (*input_line_pointer++ != ';')
2042 #define SKIP_WHITESPACES() while (*input_line_pointer == ' ' || \
2043 *input_line_pointer == '\t') \
2044 input_line_pointer++;
2045
2046 static void
2047 obj_coff_def (what)
2048 int what;
2049 {
2050 char name_end; /* Char after the end of name */
2051 char *symbol_name; /* Name of the debug symbol */
2052 char *symbol_name_copy; /* Temporary copy of the name */
2053 unsigned int symbol_name_length;
2054
2055 if (def_symbol_in_progress != NULL)
2056 {
2057 as_warn (".def pseudo-op used inside of .def/.endef: ignored.");
2058 demand_empty_rest_of_line ();
2059 return;
2060 } /* if not inside .def/.endef */
2061
2062 SKIP_WHITESPACES ();
2063
2064 def_symbol_in_progress = (symbolS *) obstack_alloc (&notes, sizeof (*def_symbol_in_progress));
2065 memset (def_symbol_in_progress, 0, sizeof (*def_symbol_in_progress));
2066
2067 symbol_name = input_line_pointer;
2068 name_end = get_symbol_end ();
2069 symbol_name_length = strlen (symbol_name);
2070 symbol_name_copy = xmalloc (symbol_name_length + 1);
2071 strcpy (symbol_name_copy, symbol_name);
2072
2073 /* Initialize the new symbol */
2074 #ifdef STRIP_UNDERSCORE
2075 S_SET_NAME (def_symbol_in_progress, (*symbol_name_copy == '_'
2076 ? symbol_name_copy + 1
2077 : symbol_name_copy));
2078 #else /* STRIP_UNDERSCORE */
2079 S_SET_NAME (def_symbol_in_progress, symbol_name_copy);
2080 #endif /* STRIP_UNDERSCORE */
2081 /* free(symbol_name_copy); */
2082 def_symbol_in_progress->sy_name_offset = (unsigned long) ~0;
2083 def_symbol_in_progress->sy_number = ~0;
2084 def_symbol_in_progress->sy_frag = &zero_address_frag;
2085 S_SET_VALUE (def_symbol_in_progress, 0);
2086
2087 if (S_IS_STRING (def_symbol_in_progress))
2088 SF_SET_STRING (def_symbol_in_progress);
2089
2090 *input_line_pointer = name_end;
2091
2092 demand_empty_rest_of_line ();
2093 }
2094
2095 unsigned int dim_index;
2096
2097
2098 static void
2099 obj_coff_endef (ignore)
2100 int ignore;
2101 {
2102 symbolS *symbolP = 0;
2103 /* DIM BUG FIX sac@cygnus.com */
2104 dim_index = 0;
2105 if (def_symbol_in_progress == NULL)
2106 {
2107 as_warn (".endef pseudo-op used outside of .def/.endef: ignored.");
2108 demand_empty_rest_of_line ();
2109 return;
2110 } /* if not inside .def/.endef */
2111
2112 /* Set the section number according to storage class. */
2113 switch (S_GET_STORAGE_CLASS (def_symbol_in_progress))
2114 {
2115 case C_STRTAG:
2116 case C_ENTAG:
2117 case C_UNTAG:
2118 SF_SET_TAG (def_symbol_in_progress);
2119 /* intentional fallthrough */
2120 case C_FILE:
2121 case C_TPDEF:
2122 SF_SET_DEBUG (def_symbol_in_progress);
2123 S_SET_SEGMENT (def_symbol_in_progress, SEG_DEBUG);
2124 break;
2125
2126 case C_EFCN:
2127 SF_SET_LOCAL (def_symbol_in_progress); /* Do not emit this symbol. */
2128 /* intentional fallthrough */
2129 case C_BLOCK:
2130 SF_SET_PROCESS (def_symbol_in_progress); /* Will need processing before writing */
2131 /* intentional fallthrough */
2132 case C_FCN:
2133 S_SET_SEGMENT (def_symbol_in_progress, SEG_E0);
2134
2135 if (strcmp (S_GET_NAME (def_symbol_in_progress), ".bf") == 0)
2136 { /* .bf */
2137 if (function_lineoff < 0)
2138 {
2139 fprintf (stderr, "`.bf' symbol without preceding function\n");
2140 } /* missing function symbol */
2141 SA_GET_SYM_LNNOPTR (last_line_symbol) = function_lineoff;
2142
2143 SF_SET_PROCESS (last_line_symbol);
2144 function_lineoff = -1;
2145 }
2146 /* Value is always set to . */
2147 def_symbol_in_progress->sy_frag = frag_now;
2148 S_SET_VALUE (def_symbol_in_progress, (valueT) frag_now_fix ());
2149 break;
2150
2151 #ifdef C_AUTOARG
2152 case C_AUTOARG:
2153 #endif /* C_AUTOARG */
2154 case C_AUTO:
2155 case C_REG:
2156 case C_MOS:
2157 case C_MOE:
2158 case C_MOU:
2159 case C_ARG:
2160 case C_REGPARM:
2161 case C_FIELD:
2162 case C_EOS:
2163 SF_SET_DEBUG (def_symbol_in_progress);
2164 S_SET_SEGMENT (def_symbol_in_progress, absolute_section);
2165 break;
2166
2167 case C_EXT:
2168 case C_STAT:
2169 case C_LABEL:
2170 /* Valid but set somewhere else (s_comm, s_lcomm, colon) */
2171 break;
2172
2173 case C_USTATIC:
2174 case C_EXTDEF:
2175 case C_ULABEL:
2176 as_warn ("unexpected storage class %d", S_GET_STORAGE_CLASS (def_symbol_in_progress));
2177 break;
2178 } /* switch on storage class */
2179
2180 /* Now that we have built a debug symbol, try to find if we should
2181 merge with an existing symbol or not. If a symbol is C_EFCN or
2182 absolute_section or untagged SEG_DEBUG it never merges. We also
2183 don't merge labels, which are in a different namespace, nor
2184 symbols which have not yet been defined since they are typically
2185 unique, nor do we merge tags with non-tags. */
2186
2187 /* Two cases for functions. Either debug followed by definition or
2188 definition followed by debug. For definition first, we will
2189 merge the debug symbol into the definition. For debug first, the
2190 lineno entry MUST point to the definition function or else it
2191 will point off into space when crawl_symbols() merges the debug
2192 symbol into the real symbol. Therefor, let's presume the debug
2193 symbol is a real function reference. */
2194
2195 /* FIXME-SOON If for some reason the definition label/symbol is
2196 never seen, this will probably leave an undefined symbol at link
2197 time. */
2198
2199 if (S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_EFCN
2200 || S_GET_STORAGE_CLASS (def_symbol_in_progress) == C_LABEL
2201 || (S_GET_SEGMENT (def_symbol_in_progress) == SEG_DEBUG
2202 && !SF_GET_TAG (def_symbol_in_progress))
2203 || S_GET_SEGMENT (def_symbol_in_progress) == absolute_section
2204 || def_symbol_in_progress->sy_value.X_op != O_constant
2205 || (symbolP = symbol_find_base (S_GET_NAME (def_symbol_in_progress), DO_NOT_STRIP)) == NULL
2206 || (SF_GET_TAG (def_symbol_in_progress) != SF_GET_TAG (symbolP)))
2207 {
2208 symbol_append (def_symbol_in_progress, symbol_lastP, &symbol_rootP,
2209 &symbol_lastP);
2210 }
2211 else
2212 {
2213 /* This symbol already exists, merge the newly created symbol
2214 into the old one. This is not mandatory. The linker can
2215 handle duplicate symbols correctly. But I guess that it save
2216 a *lot* of space if the assembly file defines a lot of
2217 symbols. [loic] */
2218
2219 /* The debug entry (def_symbol_in_progress) is merged into the
2220 previous definition. */
2221
2222 c_symbol_merge (def_symbol_in_progress, symbolP);
2223 /* FIXME-SOON Should *def_symbol_in_progress be free'd? xoxorich. */
2224 def_symbol_in_progress = symbolP;
2225
2226 if (SF_GET_FUNCTION (def_symbol_in_progress)
2227 || SF_GET_TAG (def_symbol_in_progress))
2228 {
2229 /* For functions, and tags, the symbol *must* be where the
2230 debug symbol appears. Move the existing symbol to the
2231 current place. */
2232 /* If it already is at the end of the symbol list, do nothing */
2233 if (def_symbol_in_progress != symbol_lastP)
2234 {
2235 symbol_remove (def_symbol_in_progress, &symbol_rootP,
2236 &symbol_lastP);
2237 symbol_append (def_symbol_in_progress, symbol_lastP,
2238 &symbol_rootP, &symbol_lastP);
2239 } /* if not already in place */
2240 } /* if function */
2241 } /* normal or mergable */
2242
2243 if (SF_GET_TAG (def_symbol_in_progress)
2244 && symbol_find_base (S_GET_NAME (def_symbol_in_progress), DO_NOT_STRIP) == NULL)
2245 {
2246 tag_insert (S_GET_NAME (def_symbol_in_progress), def_symbol_in_progress);
2247 }
2248
2249 if (SF_GET_FUNCTION (def_symbol_in_progress))
2250 {
2251 know (sizeof (def_symbol_in_progress) <= sizeof (long));
2252 function_lineoff
2253 = c_line_new (def_symbol_in_progress, 0, 0, &zero_address_frag);
2254
2255 SF_SET_PROCESS (def_symbol_in_progress);
2256
2257 if (symbolP == NULL)
2258 {
2259 /* That is, if this is the first time we've seen the
2260 function... */
2261 symbol_table_insert (def_symbol_in_progress);
2262 } /* definition follows debug */
2263 } /* Create the line number entry pointing to the function being defined */
2264
2265 def_symbol_in_progress = NULL;
2266 demand_empty_rest_of_line ();
2267 }
2268
2269 static void
2270 obj_coff_dim (ignore)
2271 int ignore;
2272 {
2273 int dim_index;
2274
2275 if (def_symbol_in_progress == NULL)
2276 {
2277 as_warn (".dim pseudo-op used outside of .def/.endef: ignored.");
2278 demand_empty_rest_of_line ();
2279 return;
2280 } /* if not inside .def/.endef */
2281
2282 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
2283
2284 for (dim_index = 0; dim_index < DIMNUM; dim_index++)
2285 {
2286 SKIP_WHITESPACES ();
2287 SA_SET_SYM_DIMEN (def_symbol_in_progress, dim_index,
2288 get_absolute_expression ());
2289
2290 switch (*input_line_pointer)
2291 {
2292 case ',':
2293 input_line_pointer++;
2294 break;
2295
2296 default:
2297 as_warn ("badly formed .dim directive ignored");
2298 /* intentional fallthrough */
2299 case '\n':
2300 case ';':
2301 dim_index = DIMNUM;
2302 break;
2303 }
2304 }
2305
2306 demand_empty_rest_of_line ();
2307 }
2308
2309 static void
2310 obj_coff_line (ignore)
2311 int ignore;
2312 {
2313 int this_base;
2314 const char *name;
2315
2316 if (def_symbol_in_progress == NULL)
2317 {
2318 obj_coff_ln (0);
2319 return;
2320 }
2321
2322 name = S_GET_NAME (def_symbol_in_progress);
2323 this_base = get_absolute_expression ();
2324
2325 /* Only .bf symbols indicate the use of a new base line number; the
2326 line numbers associated with .ef, .bb, .eb are relative to the
2327 start of the containing function. */
2328 if (!strcmp (".bf", name))
2329 {
2330 #if 0 /* XXX Can we ever have line numbers going backwards? */
2331 if (this_base > line_base)
2332 #endif
2333 {
2334 line_base = this_base;
2335 }
2336
2337 #ifndef NO_LISTING
2338 {
2339 extern int listing;
2340 if (listing)
2341 {
2342 listing_source_line ((unsigned int) line_base);
2343 }
2344 }
2345 #endif
2346 }
2347
2348 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
2349 SA_SET_SYM_LNNO (def_symbol_in_progress, this_base);
2350
2351 demand_empty_rest_of_line ();
2352 }
2353
2354 static void
2355 obj_coff_size (ignore)
2356 int ignore;
2357 {
2358 if (def_symbol_in_progress == NULL)
2359 {
2360 as_warn (".size pseudo-op used outside of .def/.endef ignored.");
2361 demand_empty_rest_of_line ();
2362 return;
2363 } /* if not inside .def/.endef */
2364
2365 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
2366 SA_SET_SYM_SIZE (def_symbol_in_progress, get_absolute_expression ());
2367 demand_empty_rest_of_line ();
2368 }
2369
2370 static void
2371 obj_coff_scl (ignore)
2372 int ignore;
2373 {
2374 if (def_symbol_in_progress == NULL)
2375 {
2376 as_warn (".scl pseudo-op used outside of .def/.endef ignored.");
2377 demand_empty_rest_of_line ();
2378 return;
2379 } /* if not inside .def/.endef */
2380
2381 S_SET_STORAGE_CLASS (def_symbol_in_progress, get_absolute_expression ());
2382 demand_empty_rest_of_line ();
2383 }
2384
2385 static void
2386 obj_coff_tag (ignore)
2387 int ignore;
2388 {
2389 char *symbol_name;
2390 char name_end;
2391
2392 if (def_symbol_in_progress == NULL)
2393 {
2394 as_warn (".tag pseudo-op used outside of .def/.endef ignored.");
2395 demand_empty_rest_of_line ();
2396 return;
2397 }
2398
2399 S_SET_NUMBER_AUXILIARY (def_symbol_in_progress, 1);
2400 symbol_name = input_line_pointer;
2401 name_end = get_symbol_end ();
2402
2403 /* Assume that the symbol referred to by .tag is always defined.
2404 This was a bad assumption. I've added find_or_make. xoxorich. */
2405 SA_SET_SYM_TAGNDX (def_symbol_in_progress,
2406 (long) tag_find_or_make (symbol_name));
2407 if (SA_GET_SYM_TAGNDX (def_symbol_in_progress) == 0L)
2408 {
2409 as_warn ("tag not found for .tag %s", symbol_name);
2410 } /* not defined */
2411
2412 SF_SET_TAGGED (def_symbol_in_progress);
2413 *input_line_pointer = name_end;
2414
2415 demand_empty_rest_of_line ();
2416 }
2417
2418 static void
2419 obj_coff_type (ignore)
2420 int ignore;
2421 {
2422 if (def_symbol_in_progress == NULL)
2423 {
2424 as_warn (".type pseudo-op used outside of .def/.endef ignored.");
2425 demand_empty_rest_of_line ();
2426 return;
2427 } /* if not inside .def/.endef */
2428
2429 S_SET_DATA_TYPE (def_symbol_in_progress, get_absolute_expression ());
2430
2431 if (ISFCN (S_GET_DATA_TYPE (def_symbol_in_progress)) &&
2432 S_GET_STORAGE_CLASS (def_symbol_in_progress) != C_TPDEF)
2433 {
2434 SF_SET_FUNCTION (def_symbol_in_progress);
2435 } /* is a function */
2436
2437 demand_empty_rest_of_line ();
2438 }
2439
2440 static void
2441 obj_coff_val (ignore)
2442 int ignore;
2443 {
2444 if (def_symbol_in_progress == NULL)
2445 {
2446 as_warn (".val pseudo-op used outside of .def/.endef ignored.");
2447 demand_empty_rest_of_line ();
2448 return;
2449 } /* if not inside .def/.endef */
2450
2451 if (is_name_beginner (*input_line_pointer))
2452 {
2453 char *symbol_name = input_line_pointer;
2454 char name_end = get_symbol_end ();
2455
2456 if (!strcmp (symbol_name, "."))
2457 {
2458 def_symbol_in_progress->sy_frag = frag_now;
2459 S_SET_VALUE (def_symbol_in_progress, (valueT) frag_now_fix ());
2460 /* If the .val is != from the .def (e.g. statics) */
2461 }
2462 else if (strcmp (S_GET_NAME (def_symbol_in_progress), symbol_name))
2463 {
2464 def_symbol_in_progress->sy_value.X_op = O_symbol;
2465 def_symbol_in_progress->sy_value.X_add_symbol =
2466 symbol_find_or_make (symbol_name);
2467 def_symbol_in_progress->sy_value.X_op_symbol = NULL;
2468 def_symbol_in_progress->sy_value.X_add_number = 0;
2469
2470 /* If the segment is undefined when the forward reference is
2471 resolved, then copy the segment id from the forward
2472 symbol. */
2473 SF_SET_GET_SEGMENT (def_symbol_in_progress);
2474
2475 /* FIXME: gcc can generate address expressions
2476 here in unusual cases (search for "obscure"
2477 in sdbout.c). We just ignore the offset
2478 here, thus generating incorrect debugging
2479 information. We ignore the rest of the
2480 line just below. */
2481 }
2482 /* Otherwise, it is the name of a non debug symbol and
2483 its value will be calculated later. */
2484 *input_line_pointer = name_end;
2485
2486 /* FIXME: this is to avoid an error message in the
2487 FIXME case mentioned just above. */
2488 while (! is_end_of_line[(unsigned char) *input_line_pointer])
2489 ++input_line_pointer;
2490 }
2491 else
2492 {
2493 S_SET_VALUE (def_symbol_in_progress,
2494 (valueT) get_absolute_expression ());
2495 } /* if symbol based */
2496
2497 demand_empty_rest_of_line ();
2498 }
2499
2500 void
2501 obj_read_begin_hook ()
2502 {
2503 /* These had better be the same. Usually 18 bytes. */
2504 #ifndef BFD_HEADERS
2505 know (sizeof (SYMENT) == sizeof (AUXENT));
2506 know (SYMESZ == AUXESZ);
2507 #endif
2508 tag_init ();
2509 }
2510
2511 /* This function runs through the symbol table and puts all the
2512 externals onto another chain */
2513
2514 /* The chain of globals. */
2515 symbolS *symbol_globalP;
2516 symbolS *symbol_global_lastP;
2517
2518 /* The chain of externals */
2519 symbolS *symbol_externP;
2520 symbolS *symbol_extern_lastP;
2521
2522 stack *block_stack;
2523 symbolS *last_functionP;
2524 symbolS *last_tagP;
2525
2526 static unsigned int
2527 yank_symbols ()
2528 {
2529 symbolS *symbolP;
2530 unsigned int symbol_number = 0;
2531 unsigned int last_file_symno = 0;
2532
2533 struct filename_list *filename_list_scan = filename_list_head;
2534
2535 for (symbolP = symbol_rootP;
2536 symbolP;
2537 symbolP = symbolP ? symbol_next (symbolP) : symbol_rootP)
2538 {
2539 if (symbolP->sy_mri_common)
2540 {
2541 if (S_GET_STORAGE_CLASS (symbolP) == C_EXT)
2542 as_bad ("%s: global symbols not supported in common sections",
2543 S_GET_NAME (symbolP));
2544 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
2545 continue;
2546 }
2547
2548 if (!SF_GET_DEBUG (symbolP))
2549 {
2550 /* Debug symbols do not need all this rubbish */
2551 symbolS *real_symbolP;
2552
2553 /* L* and C_EFCN symbols never merge. */
2554 if (!SF_GET_LOCAL (symbolP)
2555 && S_GET_STORAGE_CLASS (symbolP) != C_LABEL
2556 && symbolP->sy_value.X_op == O_constant
2557 && (real_symbolP = symbol_find_base (S_GET_NAME (symbolP), DO_NOT_STRIP))
2558 && real_symbolP != symbolP)
2559 {
2560 /* FIXME-SOON: where do dups come from?
2561 Maybe tag references before definitions? xoxorich. */
2562 /* Move the debug data from the debug symbol to the
2563 real symbol. Do NOT do the oposite (i.e. move from
2564 real symbol to debug symbol and remove real symbol from the
2565 list.) Because some pointers refer to the real symbol
2566 whereas no pointers refer to the debug symbol. */
2567 c_symbol_merge (symbolP, real_symbolP);
2568 /* Replace the current symbol by the real one */
2569 /* The symbols will never be the last or the first
2570 because : 1st symbol is .file and 3 last symbols are
2571 .text, .data, .bss */
2572 symbol_remove (real_symbolP, &symbol_rootP, &symbol_lastP);
2573 symbol_insert (real_symbolP, symbolP, &symbol_rootP, &symbol_lastP);
2574 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
2575 symbolP = real_symbolP;
2576 } /* if not local but dup'd */
2577
2578 if (flag_readonly_data_in_text && (S_GET_SEGMENT (symbolP) == SEG_E1))
2579 {
2580 S_SET_SEGMENT (symbolP, SEG_E0);
2581 } /* push data into text */
2582
2583 resolve_symbol_value (symbolP);
2584
2585 if (S_GET_STORAGE_CLASS (symbolP) == C_NULL)
2586 {
2587 if (!S_IS_DEFINED (symbolP) && !SF_GET_LOCAL (symbolP))
2588 {
2589 S_SET_EXTERNAL (symbolP);
2590 }
2591 else if (S_GET_SEGMENT (symbolP) == SEG_E0)
2592 {
2593 S_SET_STORAGE_CLASS (symbolP, C_LABEL);
2594 }
2595 else
2596 {
2597 S_SET_STORAGE_CLASS (symbolP, C_STAT);
2598 }
2599 }
2600
2601 /* Mainly to speed up if not -g */
2602 if (SF_GET_PROCESS (symbolP))
2603 {
2604 /* Handle the nested blocks auxiliary info. */
2605 if (S_GET_STORAGE_CLASS (symbolP) == C_BLOCK)
2606 {
2607 if (!strcmp (S_GET_NAME (symbolP), ".bb"))
2608 stack_push (block_stack, (char *) &symbolP);
2609 else
2610 { /* .eb */
2611 register symbolS *begin_symbolP;
2612 begin_symbolP = *(symbolS **) stack_pop (block_stack);
2613 if (begin_symbolP == (symbolS *) 0)
2614 as_warn ("mismatched .eb");
2615 else
2616 SA_SET_SYM_ENDNDX (begin_symbolP, symbol_number + 2);
2617 }
2618 }
2619 /* If we are able to identify the type of a function, and we
2620 are out of a function (last_functionP == 0) then, the
2621 function symbol will be associated with an auxiliary
2622 entry. */
2623 if (last_functionP == (symbolS *) 0 &&
2624 SF_GET_FUNCTION (symbolP))
2625 {
2626 last_functionP = symbolP;
2627
2628 if (S_GET_NUMBER_AUXILIARY (symbolP) < 1)
2629 {
2630 S_SET_NUMBER_AUXILIARY (symbolP, 1);
2631 } /* make it at least 1 */
2632
2633 /* Clobber possible stale .dim information. */
2634 #if 0
2635 /* Iffed out by steve - this fries the lnnoptr info too */
2636 bzero (symbolP->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_ary.x_dimen,
2637 sizeof (symbolP->sy_symbol.ost_auxent[0].x_sym.x_fcnary.x_ary.x_dimen));
2638 #endif
2639 }
2640 /* The C_FCN doesn't need any additional information. I
2641 don't even know if this is needed for sdb. But the
2642 standard assembler generates it, so... */
2643 if (S_GET_STORAGE_CLASS (symbolP) == C_EFCN)
2644 {
2645 if (last_functionP == (symbolS *) 0)
2646 as_fatal ("C_EFCN symbol out of scope");
2647 SA_SET_SYM_FSIZE (last_functionP,
2648 (long) (S_GET_VALUE (symbolP) -
2649 S_GET_VALUE (last_functionP)));
2650 SA_SET_SYM_ENDNDX (last_functionP, symbol_number);
2651 last_functionP = (symbolS *) 0;
2652 }
2653 }
2654 }
2655 else if (SF_GET_TAG (symbolP))
2656 {
2657 /* First descriptor of a structure must point to
2658 the first slot after the structure description. */
2659 last_tagP = symbolP;
2660
2661 }
2662 else if (S_GET_STORAGE_CLASS (symbolP) == C_EOS)
2663 {
2664 /* +2 take in account the current symbol */
2665 SA_SET_SYM_ENDNDX (last_tagP, symbol_number + 2);
2666 }
2667 else if (S_GET_STORAGE_CLASS (symbolP) == C_FILE)
2668 {
2669 /* If the filename was too long to fit in the
2670 auxent, put it in the string table */
2671 if (SA_GET_FILE_FNAME_ZEROS (symbolP) == 0)
2672 {
2673 SA_SET_FILE_FNAME_OFFSET (symbolP, string_byte_count);
2674 string_byte_count += strlen (filename_list_scan->filename) + 1;
2675 filename_list_scan = filename_list_scan->next;
2676 }
2677 if (S_GET_VALUE (symbolP))
2678 {
2679 S_SET_VALUE (symbolP, last_file_symno);
2680 last_file_symno = symbol_number;
2681 } /* no one points at the first .file symbol */
2682 } /* if debug or tag or eos or file */
2683
2684 /* We must put the external symbols apart. The loader
2685 does not bomb if we do not. But the references in
2686 the endndx field for a .bb symbol are not corrected
2687 if an external symbol is removed between .bb and .be.
2688 I.e in the following case :
2689 [20] .bb endndx = 22
2690 [21] foo external
2691 [22] .be
2692 ld will move the symbol 21 to the end of the list but
2693 endndx will still be 22 instead of 21. */
2694
2695
2696 if (SF_GET_LOCAL (symbolP))
2697 {
2698 /* remove C_EFCN and LOCAL (L...) symbols */
2699 /* next pointer remains valid */
2700 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
2701
2702 }
2703 else if (!S_IS_DEFINED (symbolP)
2704 && !S_IS_DEBUG (symbolP)
2705 && !SF_GET_STATICS (symbolP) &&
2706 S_GET_STORAGE_CLASS (symbolP) == C_EXT)
2707 { /* C_EXT && !SF_GET_FUNCTION(symbolP)) */
2708 /* if external, Remove from the list */
2709 symbolS *hold = symbol_previous (symbolP);
2710
2711 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
2712 symbol_clear_list_pointers (symbolP);
2713 symbol_append (symbolP, symbol_extern_lastP, &symbol_externP, &symbol_extern_lastP);
2714 symbolP = hold;
2715 }
2716 else if (! S_IS_DEBUG (symbolP)
2717 && ! SF_GET_STATICS (symbolP)
2718 && ! SF_GET_FUNCTION (symbolP)
2719 && S_GET_STORAGE_CLASS (symbolP) == C_EXT)
2720 {
2721 symbolS *hold = symbol_previous (symbolP);
2722
2723 /* The O'Reilly COFF book says that defined global symbols
2724 come at the end of the symbol table, just before
2725 undefined global symbols. */
2726
2727 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
2728 symbol_clear_list_pointers (symbolP);
2729 symbol_append (symbolP, symbol_global_lastP, &symbol_globalP,
2730 &symbol_global_lastP);
2731 symbolP = hold;
2732 }
2733 else
2734 {
2735 if (SF_GET_STRING (symbolP))
2736 {
2737 symbolP->sy_name_offset = string_byte_count;
2738 string_byte_count += strlen (S_GET_NAME (symbolP)) + 1;
2739 }
2740 else
2741 {
2742 symbolP->sy_name_offset = 0;
2743 } /* fix "long" names */
2744
2745 symbolP->sy_number = symbol_number;
2746 symbol_number += 1 + S_GET_NUMBER_AUXILIARY (symbolP);
2747 } /* if local symbol */
2748 } /* traverse the symbol list */
2749 return symbol_number;
2750
2751 }
2752
2753
2754 static unsigned int
2755 glue_symbols (head, tail)
2756 symbolS **head;
2757 symbolS **tail;
2758 {
2759 unsigned int symbol_number = 0;
2760 symbolS *symbolP;
2761
2762 for (symbolP = *head; *head != NULL;)
2763 {
2764 symbolS *tmp = *head;
2765
2766 /* append */
2767 symbol_remove (tmp, head, tail);
2768 symbol_append (tmp, symbol_lastP, &symbol_rootP, &symbol_lastP);
2769
2770 /* and process */
2771 if (SF_GET_STRING (tmp))
2772 {
2773 tmp->sy_name_offset = string_byte_count;
2774 string_byte_count += strlen (S_GET_NAME (tmp)) + 1;
2775 }
2776 else
2777 {
2778 tmp->sy_name_offset = 0;
2779 } /* fix "long" names */
2780
2781 tmp->sy_number = symbol_number;
2782 symbol_number += 1 + S_GET_NUMBER_AUXILIARY (tmp);
2783 } /* append the entire extern chain */
2784
2785 return symbol_number;
2786 }
2787
2788 static unsigned int
2789 tie_tags ()
2790 {
2791 unsigned int symbol_number = 0;
2792
2793 symbolS *symbolP;
2794 for (symbolP = symbol_rootP; symbolP; symbolP =
2795 symbol_next (symbolP))
2796 {
2797 symbolP->sy_number = symbol_number;
2798
2799
2800
2801 if (SF_GET_TAGGED (symbolP))
2802 {
2803 SA_SET_SYM_TAGNDX
2804 (symbolP,
2805 ((symbolS *) SA_GET_SYM_TAGNDX (symbolP))->sy_number);
2806 }
2807
2808 symbol_number += 1 + S_GET_NUMBER_AUXILIARY (symbolP);
2809 }
2810 return symbol_number;
2811
2812 }
2813
2814 static void
2815 crawl_symbols (h, abfd)
2816 object_headers *h;
2817 bfd * abfd;
2818 {
2819 unsigned int i;
2820
2821 /* Initialize the stack used to keep track of the matching .bb .be */
2822
2823 block_stack = stack_init (512, sizeof (symbolS *));
2824
2825 /* The symbol list should be ordered according to the following sequence
2826 * order :
2827 * . .file symbol
2828 * . debug entries for functions
2829 * . fake symbols for the sections, including.text .data and .bss
2830 * . defined symbols
2831 * . undefined symbols
2832 * But this is not mandatory. The only important point is to put the
2833 * undefined symbols at the end of the list.
2834 */
2835
2836 if (symbol_rootP == NULL
2837 || S_GET_STORAGE_CLASS (symbol_rootP) != C_FILE)
2838 {
2839 c_dot_file_symbol ("fake");
2840 }
2841 /* Is there a .file symbol ? If not insert one at the beginning. */
2842
2843 /*
2844 * Build up static symbols for the sections, they are filled in later
2845 */
2846
2847
2848 for (i = SEG_E0; i < SEG_E9; i++)
2849 {
2850 if (segment_info[i].scnhdr.s_name[0])
2851 {
2852 char name[9];
2853
2854 strncpy (name, segment_info[i].scnhdr.s_name, 8);
2855 name[8] = '\0';
2856 segment_info[i].dot = c_section_symbol (name, i - SEG_E0 + 1);
2857 }
2858 }
2859
2860
2861 /* Take all the externals out and put them into another chain */
2862 H_SET_SYMBOL_TABLE_SIZE (h, yank_symbols ());
2863 /* Take the externals and glue them onto the end.*/
2864 H_SET_SYMBOL_TABLE_SIZE (h,
2865 (H_GET_SYMBOL_COUNT (h)
2866 + glue_symbols (&symbol_globalP,
2867 &symbol_global_lastP)
2868 + glue_symbols (&symbol_externP,
2869 &symbol_extern_lastP)));
2870
2871 H_SET_SYMBOL_TABLE_SIZE (h, tie_tags ());
2872 know (symbol_globalP == NULL);
2873 know (symbol_global_lastP == NULL);
2874 know (symbol_externP == NULL);
2875 know (symbol_extern_lastP == NULL);
2876 }
2877
2878 /*
2879 * Find strings by crawling along symbol table chain.
2880 */
2881
2882 void
2883 w_strings (where)
2884 char *where;
2885 {
2886 symbolS *symbolP;
2887 struct filename_list *filename_list_scan = filename_list_head;
2888
2889 /* Gotta do md_ byte-ordering stuff for string_byte_count first - KWK */
2890 md_number_to_chars (where, (valueT) string_byte_count, 4);
2891 where += 4;
2892 for (symbolP = symbol_rootP;
2893 symbolP;
2894 symbolP = symbol_next (symbolP))
2895 {
2896 unsigned int size;
2897
2898 if (SF_GET_STRING (symbolP))
2899 {
2900 size = strlen (S_GET_NAME (symbolP)) + 1;
2901 memcpy (where, S_GET_NAME (symbolP), size);
2902 where += size;
2903 }
2904 if (S_GET_STORAGE_CLASS (symbolP) == C_FILE
2905 && SA_GET_FILE_FNAME_ZEROS (symbolP) == 0)
2906 {
2907 size = strlen (filename_list_scan->filename) + 1;
2908 memcpy (where, filename_list_scan->filename, size);
2909 filename_list_scan = filename_list_scan ->next;
2910 where += size;
2911 }
2912 }
2913 }
2914
2915 static void
2916 do_linenos_for (abfd, h, file_cursor)
2917 bfd * abfd;
2918 object_headers * h;
2919 unsigned long *file_cursor;
2920 {
2921 unsigned int idx;
2922 unsigned long start = *file_cursor;
2923
2924 for (idx = SEG_E0; idx < SEG_E9; idx++)
2925 {
2926 segment_info_type *s = segment_info + idx;
2927
2928
2929 if (s->scnhdr.s_nlnno != 0)
2930 {
2931 struct lineno_list *line_ptr;
2932
2933 struct external_lineno *buffer =
2934 (struct external_lineno *) xmalloc (s->scnhdr.s_nlnno * LINESZ);
2935
2936 struct external_lineno *dst = buffer;
2937
2938 /* Run through the table we've built and turn it into its external
2939 form, take this chance to remove duplicates */
2940
2941 for (line_ptr = s->lineno_list_head;
2942 line_ptr != (struct lineno_list *) NULL;
2943 line_ptr = line_ptr->next)
2944 {
2945
2946 if (line_ptr->line.l_lnno == 0)
2947 {
2948 /* Turn a pointer to a symbol into the symbols' index */
2949 line_ptr->line.l_addr.l_symndx =
2950 ((symbolS *) line_ptr->line.l_addr.l_symndx)->sy_number;
2951 }
2952 else
2953 {
2954 line_ptr->line.l_addr.l_paddr += ((struct frag *) (line_ptr->frag))->fr_address;
2955 }
2956
2957
2958 (void) bfd_coff_swap_lineno_out (abfd, &(line_ptr->line), dst);
2959 dst++;
2960
2961 }
2962
2963 s->scnhdr.s_lnnoptr = *file_cursor;
2964
2965 bfd_write (buffer, 1, s->scnhdr.s_nlnno * LINESZ, abfd);
2966 free (buffer);
2967
2968 *file_cursor += s->scnhdr.s_nlnno * LINESZ;
2969 }
2970 }
2971 H_SET_LINENO_SIZE (h, *file_cursor - start);
2972 }
2973
2974
2975 /* Now we run through the list of frag chains in a segment and
2976 make all the subsegment frags appear at the end of the
2977 list, as if the seg 0 was extra long */
2978
2979 static void
2980 remove_subsegs ()
2981 {
2982 unsigned int i;
2983
2984 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
2985 {
2986 frchainS *head = segment_info[i].frchainP;
2987 fragS dummy;
2988 fragS *prev_frag = &dummy;
2989
2990 while (head && head->frch_seg == i)
2991 {
2992 prev_frag->fr_next = head->frch_root;
2993 prev_frag = head->frch_last;
2994 head = head->frch_next;
2995 }
2996 prev_frag->fr_next = 0;
2997 }
2998 }
2999
3000 unsigned long machine;
3001 int coff_flags;
3002 extern void
3003 write_object_file ()
3004 {
3005 int i;
3006 char *name;
3007 struct frchain *frchain_ptr;
3008
3009 object_headers headers;
3010 unsigned long file_cursor;
3011 bfd *abfd;
3012 unsigned int addr;
3013 abfd = bfd_openw (out_file_name, TARGET_FORMAT);
3014
3015
3016 if (abfd == 0)
3017 {
3018 as_perror ("FATAL: Can't create %s", out_file_name);
3019 exit (EXIT_FAILURE);
3020 }
3021 bfd_set_format (abfd, bfd_object);
3022 bfd_set_arch_mach (abfd, BFD_ARCH, machine);
3023
3024 string_byte_count = 4;
3025
3026 for (frchain_ptr = frchain_root;
3027 frchain_ptr != (struct frchain *) NULL;
3028 frchain_ptr = frchain_ptr->frch_next)
3029 {
3030 /* Run through all the sub-segments and align them up. Also
3031 close any open frags. We tack a .fill onto the end of the
3032 frag chain so that any .align's size can be worked by looking
3033 at the next frag. */
3034
3035 subseg_set (frchain_ptr->frch_seg, frchain_ptr->frch_subseg);
3036 #ifndef SUB_SEGMENT_ALIGN
3037 #define SUB_SEGMENT_ALIGN(SEG) 1
3038 #endif
3039 #ifdef md_do_align
3040 {
3041 static char nop = NOP_OPCODE;
3042 md_do_align (SUB_SEGMENT_ALIGN (now_seg), &nop, alignment_done);
3043 }
3044 #endif
3045 frag_align (SUB_SEGMENT_ALIGN (now_seg), NOP_OPCODE);
3046 #ifdef md_do_align
3047 alignment_done:
3048 #endif
3049 frag_wane (frag_now);
3050 frag_now->fr_fix = 0;
3051 know (frag_now->fr_next == NULL);
3052 }
3053
3054
3055 remove_subsegs ();
3056
3057
3058 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
3059 {
3060 relax_segment (segment_info[i].frchainP->frch_root, i);
3061 }
3062
3063 H_SET_NUMBER_OF_SECTIONS (&headers, 0);
3064
3065 /* Find out how big the sections are, and set the addresses. */
3066 addr = 0;
3067 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
3068 {
3069 long size;
3070
3071 segment_info[i].scnhdr.s_paddr = addr;
3072 segment_info[i].scnhdr.s_vaddr = addr;
3073
3074 if (segment_info[i].scnhdr.s_name[0])
3075 {
3076 H_SET_NUMBER_OF_SECTIONS (&headers,
3077 H_GET_NUMBER_OF_SECTIONS (&headers) + 1);
3078 }
3079
3080 size = size_section (abfd, (unsigned int) i);
3081 addr += size;
3082
3083 /* I think the section alignment is only used on the i960; the
3084 i960 needs it, and it should do no harm on other targets. */
3085 segment_info[i].scnhdr.s_align = 1 << section_alignment[i];
3086
3087 if (i == SEG_E0)
3088 H_SET_TEXT_SIZE (&headers, size);
3089 else if (i == SEG_E1)
3090 H_SET_DATA_SIZE (&headers, size);
3091 else if (i == SEG_E2)
3092 H_SET_BSS_SIZE (&headers, size);
3093 }
3094
3095 /* Turn the gas native symbol table shape into a coff symbol table */
3096 crawl_symbols (&headers, abfd);
3097
3098 if (string_byte_count == 4)
3099 string_byte_count = 0;
3100
3101 H_SET_STRING_SIZE (&headers, string_byte_count);
3102
3103 #ifdef tc_frob_file
3104 tc_frob_file ();
3105 #endif
3106
3107 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
3108 {
3109 fixup_mdeps (segment_info[i].frchainP->frch_root, &headers, i);
3110 fixup_segment (&segment_info[i], i);
3111 }
3112
3113 /* Look for ".stab" segments and fill in their initial symbols
3114 correctly. */
3115 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
3116 {
3117 name = segment_info[i].scnhdr.s_name;
3118
3119 if (name != NULL
3120 && strncmp (".stab", name, 5) == 0
3121 && strncmp (".stabstr", name, 8) != 0)
3122 adjust_stab_section (abfd, i);
3123 }
3124
3125 file_cursor = H_GET_TEXT_FILE_OFFSET (&headers);
3126
3127 bfd_seek (abfd, (file_ptr) file_cursor, 0);
3128
3129 /* Plant the data */
3130
3131 fill_section (abfd, &headers, &file_cursor);
3132
3133 do_relocs_for (abfd, &headers, &file_cursor);
3134
3135 do_linenos_for (abfd, &headers, &file_cursor);
3136
3137 H_SET_FILE_MAGIC_NUMBER (&headers, COFF_MAGIC);
3138 #ifndef OBJ_COFF_OMIT_TIMESTAMP
3139 H_SET_TIME_STAMP (&headers, (long)time((time_t *)0));
3140 #else
3141 H_SET_TIME_STAMP (&headers, 0);
3142 #endif
3143 #ifdef TC_COFF_SET_MACHINE
3144 TC_COFF_SET_MACHINE (&headers);
3145 #endif
3146
3147 #ifndef COFF_FLAGS
3148 #define COFF_FLAGS 0
3149 #endif
3150
3151 #ifdef KEEP_RELOC_INFO
3152 H_SET_FLAGS (&headers, ((H_GET_LINENO_SIZE(&headers) ? 0 : F_LNNO) |
3153 COFF_FLAGS | coff_flags));
3154 #else
3155 H_SET_FLAGS (&headers, ((H_GET_LINENO_SIZE(&headers) ? 0 : F_LNNO) |
3156 (H_GET_RELOCATION_SIZE(&headers) ? 0 : F_RELFLG) |
3157 COFF_FLAGS | coff_flags));
3158 #endif
3159
3160 {
3161 unsigned int symtable_size = H_GET_SYMBOL_TABLE_SIZE (&headers);
3162 char *buffer1 = xmalloc (symtable_size + string_byte_count + 1);
3163
3164 H_SET_SYMBOL_TABLE_POINTER (&headers, bfd_tell (abfd));
3165 w_symbols (abfd, buffer1, symbol_rootP);
3166 if (string_byte_count > 0)
3167 w_strings (buffer1 + symtable_size);
3168 bfd_write (buffer1, 1, symtable_size + string_byte_count, abfd);
3169 free (buffer1);
3170 }
3171
3172 coff_header_append (abfd, &headers);
3173 #if 0
3174 /* Recent changes to write need this, but where it should
3175 go is up to Ken.. */
3176 if (bfd_close_all_done (abfd) == false)
3177 as_fatal ("Can't close %s: %s", out_file_name,
3178 bfd_errmsg (bfd_get_error ()));
3179 #else
3180 {
3181 extern bfd *stdoutput;
3182 stdoutput = abfd;
3183 }
3184 #endif
3185
3186 }
3187
3188 /* Add a new segment. This is called from subseg_new via the
3189 obj_new_segment macro. */
3190
3191 segT
3192 obj_coff_add_segment (name)
3193 const char *name;
3194 {
3195 unsigned int len;
3196 unsigned int i;
3197
3198 /* Find out if we've already got a section of this name. */
3199 len = strlen (name);
3200 if (len < sizeof (segment_info[i].scnhdr.s_name))
3201 ++len;
3202 else
3203 len = sizeof (segment_info[i].scnhdr.s_name);
3204 for (i = SEG_E0; i < SEG_E9 && segment_info[i].scnhdr.s_name[0]; i++)
3205 if (strncmp (segment_info[i].scnhdr.s_name, name, len) == 0
3206 && (len == sizeof (segment_info[i].scnhdr.s_name)
3207 || segment_info[i].scnhdr.s_name[len] == '\0'))
3208 return (segT) i;
3209
3210 if (i == SEG_E9)
3211 {
3212 as_bad ("Too many new sections; can't add \"%s\"", name);
3213 return now_seg;
3214 }
3215
3216 /* Add a new section. */
3217 strncpy (segment_info[i].scnhdr.s_name, name,
3218 sizeof (segment_info[i].scnhdr.s_name));
3219 segment_info[i].scnhdr.s_flags = STYP_REG;
3220
3221 return (segT) i;
3222 }
3223
3224 /*
3225 * implement the .section pseudo op:
3226 * .section name {, "flags"}
3227 * ^ ^
3228 * | +--- optional flags: 'b' for bss
3229 * | 'i' for info
3230 * +-- section name 'l' for lib
3231 * 'n' for noload
3232 * 'o' for over
3233 * 'w' for data
3234 * 'd' (apparently m88k for data)
3235 * 'x' for text
3236 * But if the argument is not a quoted string, treat it as a
3237 * subsegment number.
3238 */
3239
3240 void
3241 obj_coff_section (ignore)
3242 int ignore;
3243 {
3244 /* Strip out the section name */
3245 char *section_name;
3246 char *section_name_end;
3247 char c;
3248 int argp;
3249 unsigned int len;
3250 unsigned int exp;
3251 long flags;
3252
3253 if (flag_mri)
3254 {
3255 char type;
3256
3257 s_mri_sect (&type);
3258 flags = 0;
3259 if (type == 'C')
3260 flags = STYP_TEXT;
3261 else if (type == 'D')
3262 flags = STYP_DATA;
3263 segment_info[now_seg].scnhdr.s_flags |= flags;
3264
3265 return;
3266 }
3267
3268 section_name = input_line_pointer;
3269 c = get_symbol_end ();
3270 section_name_end = input_line_pointer;
3271
3272 len = section_name_end - section_name;
3273 input_line_pointer++;
3274 SKIP_WHITESPACE ();
3275
3276 argp = 0;
3277 if (c == ',')
3278 argp = 1;
3279 else if (*input_line_pointer == ',')
3280 {
3281 argp = 1;
3282 ++input_line_pointer;
3283 SKIP_WHITESPACE ();
3284 }
3285
3286 exp = 0;
3287 flags = 0;
3288 if (argp)
3289 {
3290 if (*input_line_pointer != '"')
3291 exp = get_absolute_expression ();
3292 else
3293 {
3294 ++input_line_pointer;
3295 while (*input_line_pointer != '"'
3296 && ! is_end_of_line[(unsigned char) *input_line_pointer])
3297 {
3298 switch (*input_line_pointer)
3299 {
3300 case 'b': flags |= STYP_BSS; break;
3301 case 'i': flags |= STYP_INFO; break;
3302 case 'l': flags |= STYP_LIB; break;
3303 case 'n': flags |= STYP_NOLOAD; break;
3304 case 'o': flags |= STYP_OVER; break;
3305 case 'd':
3306 case 'w': flags |= STYP_DATA; break;
3307 case 'x': flags |= STYP_TEXT; break;
3308 default:
3309 as_warn("unknown section attribute '%c'",
3310 *input_line_pointer);
3311 break;
3312 }
3313 ++input_line_pointer;
3314 }
3315 if (*input_line_pointer == '"')
3316 ++input_line_pointer;
3317 }
3318 }
3319
3320 subseg_new (section_name, (subsegT) exp);
3321
3322 segment_info[now_seg].scnhdr.s_flags |= flags;
3323
3324 *section_name_end = c;
3325 }
3326
3327
3328 static void
3329 obj_coff_text (ignore)
3330 int ignore;
3331 {
3332 subseg_new (".text", get_absolute_expression ());
3333 }
3334
3335
3336 static void
3337 obj_coff_data (ignore)
3338 int ignore;
3339 {
3340 if (flag_readonly_data_in_text)
3341 subseg_new (".text", get_absolute_expression () + 1000);
3342 else
3343 subseg_new (".data", get_absolute_expression ());
3344 }
3345
3346 static void
3347 obj_coff_bss (ignore)
3348 int ignore;
3349 {
3350 if (*input_line_pointer == '\n') /* .bss */
3351 subseg_new(".bss", get_absolute_expression());
3352 else /* .bss id,expr */
3353 obj_coff_lcomm(0);
3354 }
3355
3356 static void
3357 obj_coff_ident (ignore)
3358 int ignore;
3359 {
3360 segT current_seg = now_seg; /* save current seg */
3361 subsegT current_subseg = now_subseg;
3362 subseg_new (".comment", 0); /* .comment seg */
3363 stringer (1); /* read string */
3364 subseg_set (current_seg, current_subseg); /* restore current seg */
3365 }
3366
3367 void
3368 c_symbol_merge (debug, normal)
3369 symbolS *debug;
3370 symbolS *normal;
3371 {
3372 S_SET_DATA_TYPE (normal, S_GET_DATA_TYPE (debug));
3373 S_SET_STORAGE_CLASS (normal, S_GET_STORAGE_CLASS (debug));
3374
3375 if (S_GET_NUMBER_AUXILIARY (debug) > S_GET_NUMBER_AUXILIARY (normal))
3376 {
3377 S_SET_NUMBER_AUXILIARY (normal, S_GET_NUMBER_AUXILIARY (debug));
3378 } /* take the most we have */
3379
3380 if (S_GET_NUMBER_AUXILIARY (debug) > 0)
3381 {
3382 memcpy ((char *) &normal->sy_symbol.ost_auxent[0],
3383 (char *) &debug->sy_symbol.ost_auxent[0],
3384 (unsigned int) (S_GET_NUMBER_AUXILIARY (debug) * AUXESZ));
3385 } /* Move all the auxiliary information */
3386
3387 /* Move the debug flags. */
3388 SF_SET_DEBUG_FIELD (normal, SF_GET_DEBUG_FIELD (debug));
3389 } /* c_symbol_merge() */
3390
3391 static int
3392 c_line_new (symbol, paddr, line_number, frag)
3393 symbolS * symbol;
3394 long paddr;
3395 int line_number;
3396 fragS * frag;
3397 {
3398 struct lineno_list *new_line =
3399 (struct lineno_list *) xmalloc (sizeof (struct lineno_list));
3400
3401 segment_info_type *s = segment_info + now_seg;
3402 new_line->line.l_lnno = line_number;
3403
3404 if (line_number == 0)
3405 {
3406 last_line_symbol = symbol;
3407 new_line->line.l_addr.l_symndx = (long) symbol;
3408 }
3409 else
3410 {
3411 new_line->line.l_addr.l_paddr = paddr;
3412 }
3413
3414 new_line->frag = (char *) frag;
3415 new_line->next = (struct lineno_list *) NULL;
3416
3417
3418 if (s->lineno_list_head == (struct lineno_list *) NULL)
3419 {
3420 s->lineno_list_head = new_line;
3421 }
3422 else
3423 {
3424 s->lineno_list_tail->next = new_line;
3425 }
3426 s->lineno_list_tail = new_line;
3427 return LINESZ * s->scnhdr.s_nlnno++;
3428 }
3429
3430 void
3431 c_dot_file_symbol (filename)
3432 char *filename;
3433 {
3434 symbolS *symbolP;
3435
3436 symbolP = symbol_new (".file",
3437 SEG_DEBUG,
3438 0,
3439 &zero_address_frag);
3440
3441 S_SET_STORAGE_CLASS (symbolP, C_FILE);
3442 S_SET_NUMBER_AUXILIARY (symbolP, 1);
3443
3444 if (strlen (filename) > FILNMLEN)
3445 {
3446 /* Filename is too long to fit into an auxent,
3447 we stick it into the string table instead. We keep
3448 a linked list of the filenames we find so we can emit
3449 them later.*/
3450 struct filename_list *f = ((struct filename_list *)
3451 xmalloc (sizeof (struct filename_list)));
3452
3453 f->filename = filename;
3454 f->next = 0;
3455
3456 SA_SET_FILE_FNAME_ZEROS (symbolP, 0);
3457 SA_SET_FILE_FNAME_OFFSET (symbolP, 0);
3458
3459 if (filename_list_tail)
3460 filename_list_tail->next = f;
3461 else
3462 filename_list_head = f;
3463 filename_list_tail = f;
3464 }
3465 else
3466 {
3467 SA_SET_FILE_FNAME (symbolP, filename);
3468 }
3469 #ifndef NO_LISTING
3470 {
3471 extern int listing;
3472 if (listing)
3473 {
3474 listing_source_file (filename);
3475 }
3476
3477 }
3478
3479 #endif
3480 SF_SET_DEBUG (symbolP);
3481 S_SET_VALUE (symbolP, (valueT) previous_file_symbol);
3482
3483 previous_file_symbol = symbolP;
3484
3485 /* Make sure that the symbol is first on the symbol chain */
3486 if (symbol_rootP != symbolP)
3487 {
3488 if (symbolP == symbol_lastP)
3489 {
3490 symbol_lastP = symbol_lastP->sy_previous;
3491 } /* if it was the last thing on the list */
3492
3493 symbol_remove (symbolP, &symbol_rootP, &symbol_lastP);
3494 symbol_insert (symbolP, symbol_rootP, &symbol_rootP, &symbol_lastP);
3495 symbol_rootP = symbolP;
3496 } /* if not first on the list */
3497
3498 } /* c_dot_file_symbol() */
3499
3500 /*
3501 * Build a 'section static' symbol.
3502 */
3503
3504 symbolS *
3505 c_section_symbol (name, idx)
3506 char *name;
3507 int idx;
3508 {
3509 symbolS *symbolP;
3510
3511 symbolP = symbol_new (name, idx,
3512 0,
3513 &zero_address_frag);
3514
3515 S_SET_STORAGE_CLASS (symbolP, C_STAT);
3516 S_SET_NUMBER_AUXILIARY (symbolP, 1);
3517
3518 SF_SET_STATICS (symbolP);
3519
3520 return symbolP;
3521 } /* c_section_symbol() */
3522
3523 static void
3524 w_symbols (abfd, where, symbol_rootP)
3525 bfd * abfd;
3526 char *where;
3527 symbolS * symbol_rootP;
3528 {
3529 symbolS *symbolP;
3530 unsigned int i;
3531
3532 /* First fill in those values we have only just worked out */
3533 for (i = SEG_E0; i < SEG_E9; i++)
3534 {
3535 symbolP = segment_info[i].dot;
3536 if (symbolP)
3537 {
3538 SA_SET_SCN_SCNLEN (symbolP, segment_info[i].scnhdr.s_size);
3539 SA_SET_SCN_NRELOC (symbolP, segment_info[i].scnhdr.s_nreloc);
3540 SA_SET_SCN_NLINNO (symbolP, segment_info[i].scnhdr.s_nlnno);
3541 }
3542 }
3543
3544 /*
3545 * Emit all symbols left in the symbol chain.
3546 */
3547 for (symbolP = symbol_rootP; symbolP; symbolP = symbol_next (symbolP))
3548 {
3549 /* Used to save the offset of the name. It is used to point
3550 to the string in memory but must be a file offset. */
3551 register char *temp;
3552
3553 tc_coff_symbol_emit_hook (symbolP);
3554
3555 temp = S_GET_NAME (symbolP);
3556 if (SF_GET_STRING (symbolP))
3557 {
3558 S_SET_OFFSET (symbolP, symbolP->sy_name_offset);
3559 S_SET_ZEROES (symbolP, 0);
3560 }
3561 else
3562 {
3563 memset (symbolP->sy_symbol.ost_entry.n_name, 0, SYMNMLEN);
3564 strncpy (symbolP->sy_symbol.ost_entry.n_name, temp, SYMNMLEN);
3565 }
3566 where = symbol_to_chars (abfd, where, symbolP);
3567 S_SET_NAME (symbolP, temp);
3568 }
3569
3570 } /* w_symbols() */
3571
3572 static void
3573 obj_coff_lcomm (ignore)
3574 int ignore;
3575 {
3576 s_lcomm(0);
3577 return;
3578 #if 0
3579 char *name;
3580 char c;
3581 int temp;
3582 char *p;
3583
3584 symbolS *symbolP;
3585
3586 name = input_line_pointer;
3587
3588 c = get_symbol_end ();
3589 p = input_line_pointer;
3590 *p = c;
3591 SKIP_WHITESPACE ();
3592 if (*input_line_pointer != ',')
3593 {
3594 as_bad ("Expected comma after name");
3595 ignore_rest_of_line ();
3596 return;
3597 }
3598 if (*input_line_pointer == '\n')
3599 {
3600 as_bad ("Missing size expression");
3601 return;
3602 }
3603 input_line_pointer++;
3604 if ((temp = get_absolute_expression ()) < 0)
3605 {
3606 as_warn ("lcomm length (%d.) <0! Ignored.", temp);
3607 ignore_rest_of_line ();
3608 return;
3609 }
3610 *p = 0;
3611
3612 symbolP = symbol_find_or_make(name);
3613
3614 if (S_GET_SEGMENT(symbolP) == SEG_UNKNOWN &&
3615 S_GET_VALUE(symbolP) == 0)
3616 {
3617 if (! need_pass_2)
3618 {
3619 char *p;
3620 segT current_seg = now_seg; /* save current seg */
3621 subsegT current_subseg = now_subseg;
3622
3623 subseg_set (SEG_E2, 1);
3624 symbolP->sy_frag = frag_now;
3625 p = frag_var(rs_org, 1, 1, (relax_substateT)0, symbolP,
3626 temp, (char *)0);
3627 *p = 0;
3628 subseg_set (current_seg, current_subseg); /* restore current seg */
3629 S_SET_SEGMENT(symbolP, SEG_E2);
3630 S_SET_STORAGE_CLASS(symbolP, C_STAT);
3631 }
3632 }
3633 else
3634 as_bad("Symbol %s already defined", name);
3635
3636 demand_empty_rest_of_line();
3637 #endif
3638 }
3639
3640 static void
3641 fixup_mdeps (frags, h, this_segment)
3642 fragS * frags;
3643 object_headers * h;
3644 segT this_segment;
3645 {
3646 subseg_change (this_segment, 0);
3647 while (frags)
3648 {
3649 switch (frags->fr_type)
3650 {
3651 case rs_align:
3652 case rs_align_code:
3653 case rs_org:
3654 #ifdef HANDLE_ALIGN
3655 HANDLE_ALIGN (frags);
3656 #endif
3657 frags->fr_type = rs_fill;
3658 frags->fr_offset =
3659 (frags->fr_next->fr_address - frags->fr_address - frags->fr_fix);
3660 break;
3661 case rs_machine_dependent:
3662 md_convert_frag (h, this_segment, frags);
3663 frag_wane (frags);
3664 break;
3665 default:
3666 ;
3667 }
3668 frags = frags->fr_next;
3669 }
3670 }
3671
3672 #if 1
3673
3674 #ifndef TC_FORCE_RELOCATION
3675 #define TC_FORCE_RELOCATION(fix) 0
3676 #endif
3677
3678 static void
3679 fixup_segment (segP, this_segment_type)
3680 segment_info_type * segP;
3681 segT this_segment_type;
3682 {
3683 register fixS * fixP;
3684 register symbolS *add_symbolP;
3685 register symbolS *sub_symbolP;
3686 long add_number;
3687 register int size;
3688 register char *place;
3689 register long where;
3690 register char pcrel;
3691 register fragS *fragP;
3692 register segT add_symbol_segment = absolute_section;
3693
3694 if (linkrelax)
3695 return;
3696
3697 for (fixP = segP->fix_root; fixP; fixP = fixP->fx_next)
3698 {
3699 fragP = fixP->fx_frag;
3700 know (fragP);
3701 where = fixP->fx_where;
3702 place = fragP->fr_literal + where;
3703 size = fixP->fx_size;
3704 add_symbolP = fixP->fx_addsy;
3705 #ifdef TC_I960
3706 if (fixP->fx_tcbit && SF_GET_CALLNAME (add_symbolP))
3707 {
3708 /* Relocation should be done via the associated 'bal' entry
3709 point symbol. */
3710
3711 if (!SF_GET_BALNAME (tc_get_bal_of_call (add_symbolP)))
3712 {
3713 as_bad_where (fixP->fx_file, fixP->fx_line,
3714 "No 'bal' entry point for leafproc %s",
3715 S_GET_NAME (add_symbolP));
3716 continue;
3717 }
3718 fixP->fx_addsy = add_symbolP = tc_get_bal_of_call (add_symbolP);
3719 }
3720 #endif
3721 sub_symbolP = fixP->fx_subsy;
3722 add_number = fixP->fx_offset;
3723 pcrel = fixP->fx_pcrel;
3724
3725 if (add_symbolP != NULL
3726 && add_symbolP->sy_mri_common)
3727 {
3728 know (add_symbolP->sy_value.X_op == O_symbol);
3729 add_number += S_GET_VALUE (add_symbolP);
3730 fixP->fx_offset = add_number;
3731 add_symbolP = fixP->fx_addsy = add_symbolP->sy_value.X_add_symbol;
3732 }
3733
3734 if (add_symbolP)
3735 {
3736 add_symbol_segment = S_GET_SEGMENT (add_symbolP);
3737 } /* if there is an addend */
3738
3739 if (sub_symbolP)
3740 {
3741 if (add_symbolP == NULL || add_symbol_segment == absolute_section)
3742 {
3743 if (add_symbolP != NULL)
3744 {
3745 add_number += S_GET_VALUE (add_symbolP);
3746 add_symbolP = NULL;
3747 fixP->fx_addsy = NULL;
3748 }
3749
3750 /* It's just -sym. */
3751 if (S_GET_SEGMENT (sub_symbolP) == absolute_section)
3752 {
3753 add_number -= S_GET_VALUE (sub_symbolP);
3754 fixP->fx_subsy = 0;
3755 fixP->fx_done = 1;
3756 }
3757 else
3758 {
3759 #ifndef TC_M68K
3760 as_bad_where (fixP->fx_file, fixP->fx_line,
3761 "Negative of non-absolute symbol %s",
3762 S_GET_NAME (sub_symbolP));
3763 #endif
3764 add_number -= S_GET_VALUE (sub_symbolP);
3765 } /* not absolute */
3766
3767 /* if sub_symbol is in the same segment that add_symbol
3768 and add_symbol is either in DATA, TEXT, BSS or ABSOLUTE */
3769 }
3770 else if (S_GET_SEGMENT (sub_symbolP) == add_symbol_segment
3771 && SEG_NORMAL (add_symbol_segment))
3772 {
3773 /* Difference of 2 symbols from same segment. Can't
3774 make difference of 2 undefineds: 'value' means
3775 something different for N_UNDF. */
3776 #ifdef TC_I960
3777 /* Makes no sense to use the difference of 2 arbitrary symbols
3778 as the target of a call instruction. */
3779 if (fixP->fx_tcbit)
3780 {
3781 as_bad_where (fixP->fx_file, fixP->fx_line,
3782 "callj to difference of 2 symbols");
3783 }
3784 #endif /* TC_I960 */
3785 add_number += S_GET_VALUE (add_symbolP) -
3786 S_GET_VALUE (sub_symbolP);
3787 add_symbolP = NULL;
3788
3789 if (!TC_FORCE_RELOCATION (fixP))
3790 {
3791 fixP->fx_addsy = NULL;
3792 fixP->fx_subsy = NULL;
3793 fixP->fx_done = 1;
3794 #ifdef TC_M68K /* is this right? */
3795 pcrel = 0;
3796 fixP->fx_pcrel = 0;
3797 #endif
3798 }
3799 }
3800 else
3801 {
3802 /* Different segments in subtraction. */
3803 know (!(S_IS_EXTERNAL (sub_symbolP) && (S_GET_SEGMENT (sub_symbolP) == absolute_section)));
3804
3805 if ((S_GET_SEGMENT (sub_symbolP) == absolute_section))
3806 {
3807 add_number -= S_GET_VALUE (sub_symbolP);
3808 }
3809 #ifdef DIFF_EXPR_OK
3810 else if (S_GET_SEGMENT (sub_symbolP) == this_segment_type
3811 #if 0 /* Okay for 68k, at least... */
3812 && !pcrel
3813 #endif
3814 )
3815 {
3816 /* Make it pc-relative. */
3817 add_number += (md_pcrel_from (fixP)
3818 - S_GET_VALUE (sub_symbolP));
3819 pcrel = 1;
3820 fixP->fx_pcrel = 1;
3821 sub_symbolP = 0;
3822 fixP->fx_subsy = 0;
3823 }
3824 #endif
3825 else
3826 {
3827 as_bad_where (fixP->fx_file, fixP->fx_line,
3828 "Can't emit reloc {- %s-seg symbol \"%s\"} @ file address %ld.",
3829 segment_name (S_GET_SEGMENT (sub_symbolP)),
3830 S_GET_NAME (sub_symbolP),
3831 (long) (fragP->fr_address + where));
3832 } /* if absolute */
3833 }
3834 } /* if sub_symbolP */
3835
3836 if (add_symbolP)
3837 {
3838 if (add_symbol_segment == this_segment_type && pcrel)
3839 {
3840 /*
3841 * This fixup was made when the symbol's segment was
3842 * SEG_UNKNOWN, but it is now in the local segment.
3843 * So we know how to do the address without relocation.
3844 */
3845 #ifdef TC_I960
3846 /* reloc_callj() may replace a 'call' with a 'calls' or a 'bal',
3847 * in which cases it modifies *fixP as appropriate. In the case
3848 * of a 'calls', no further work is required, and *fixP has been
3849 * set up to make the rest of the code below a no-op.
3850 */
3851 reloc_callj (fixP);
3852 #endif /* TC_I960 */
3853
3854 add_number += S_GET_VALUE (add_symbolP);
3855 add_number -= md_pcrel_from (fixP);
3856 #if defined (TC_I386) || defined (TE_LYNX)
3857 /* On the 386 we must adjust by the segment
3858 vaddr as well. Ian Taylor. */
3859 add_number -= segP->scnhdr.s_vaddr;
3860 #endif
3861 pcrel = 0; /* Lie. Don't want further pcrel processing. */
3862 if (!TC_FORCE_RELOCATION (fixP))
3863 {
3864 fixP->fx_addsy = NULL;
3865 fixP->fx_done = 1;
3866 }
3867 }
3868 else
3869 {
3870 switch (add_symbol_segment)
3871 {
3872 case absolute_section:
3873 #ifdef TC_I960
3874 reloc_callj (fixP); /* See comment about reloc_callj() above*/
3875 #endif /* TC_I960 */
3876 add_number += S_GET_VALUE (add_symbolP);
3877 add_symbolP = NULL;
3878
3879 if (!TC_FORCE_RELOCATION (fixP))
3880 {
3881 fixP->fx_addsy = NULL;
3882 fixP->fx_done = 1;
3883 }
3884 break;
3885 default:
3886
3887
3888 #if defined(TC_A29K) || (defined(TE_PE) && defined(TC_I386)) || defined(TC_M88K)
3889 /* This really should be handled in the linker, but
3890 backward compatibility forbids. */
3891 add_number += S_GET_VALUE (add_symbolP);
3892 #else
3893 add_number += S_GET_VALUE (add_symbolP) +
3894 segment_info[S_GET_SEGMENT (add_symbolP)].scnhdr.s_paddr;
3895 #endif
3896 break;
3897
3898 case SEG_UNKNOWN:
3899 #ifdef TC_I960
3900 if ((int) fixP->fx_bit_fixP == 13)
3901 {
3902 /* This is a COBR instruction. They have only a
3903 * 13-bit displacement and are only to be used
3904 * for local branches: flag as error, don't generate
3905 * relocation.
3906 */
3907 as_bad_where (fixP->fx_file, fixP->fx_line,
3908 "can't use COBR format with external label");
3909 fixP->fx_addsy = NULL;
3910 fixP->fx_done = 1;
3911 continue;
3912 } /* COBR */
3913 #endif /* TC_I960 */
3914 #if (defined (TC_I386) || defined (TE_LYNX) || defined (TE_AUX)) && !defined(TE_PE)
3915 /* 386 COFF uses a peculiar format in which the
3916 value of a common symbol is stored in the .text
3917 segment (I've checked this on SVR3.2 and SCO
3918 3.2.2) Ian Taylor <ian@cygnus.com>. */
3919 if (S_IS_COMMON (add_symbolP))
3920 add_number += S_GET_VALUE (add_symbolP);
3921 #endif
3922 break;
3923
3924
3925 } /* switch on symbol seg */
3926 } /* if not in local seg */
3927 } /* if there was a + symbol */
3928
3929 if (pcrel)
3930 {
3931 #if !defined(TC_M88K) && !(defined(TE_PE) && defined(TC_I386)) && !defined(TC_A29K)
3932 /* This adjustment is not correct on the m88k, for which the
3933 linker does all the computation. */
3934 add_number -= md_pcrel_from (fixP);
3935 #endif
3936 if (add_symbolP == 0)
3937 {
3938 fixP->fx_addsy = &abs_symbol;
3939 } /* if there's an add_symbol */
3940 #if defined (TC_I386) || defined (TE_LYNX)
3941 /* On the 386 we must adjust by the segment vaddr
3942 as well. Ian Taylor. */
3943 add_number -= segP->scnhdr.s_vaddr;
3944 #endif
3945 } /* if pcrel */
3946
3947 if (!fixP->fx_bit_fixP)
3948 {
3949 #ifndef TC_M88K
3950 /* The m88k uses the offset field of the reloc to get around
3951 this problem. */
3952 if ((size == 1
3953 && (add_number & ~0xFF)
3954 && ((add_number & ~0xFF) != (-1 & ~0xFF)))
3955 || (size == 2
3956 && (add_number & ~0xFFFF)
3957 && ((add_number & ~0xFFFF) != (-1 & ~0xFFFF))))
3958 {
3959 as_bad_where (fixP->fx_file, fixP->fx_line,
3960 "Value of %ld too large for field of %d bytes at 0x%lx",
3961 (long) add_number, size,
3962 (unsigned long) (fragP->fr_address + where));
3963 }
3964 #endif
3965 #ifdef WARN_SIGNED_OVERFLOW_WORD
3966 /* Warn if a .word value is too large when treated as a
3967 signed number. We already know it is not too negative.
3968 This is to catch over-large switches generated by gcc on
3969 the 68k. */
3970 if (!flag_signed_overflow_ok
3971 && size == 2
3972 && add_number > 0x7fff)
3973 as_bad_where (fixP->fx_file, fixP->fx_line,
3974 "Signed .word overflow; switch may be too large; %ld at 0x%lx",
3975 (long) add_number,
3976 (unsigned long) (fragP->fr_address + where));
3977 #endif
3978 } /* not a bit fix */
3979 /* Once this fix has been applied, we don't have to output
3980 anything nothing more need be done. */
3981 #ifdef MD_APPLY_FIX3
3982 md_apply_fix3 (fixP, &add_number, this_segment_type);
3983 #else
3984 md_apply_fix (fixP, add_number);
3985 #endif
3986 } /* For each fixS in this segment. */
3987 } /* fixup_segment() */
3988
3989 #endif
3990
3991 /* The first entry in a .stab section is special. */
3992
3993 void
3994 obj_coff_init_stab_section (seg)
3995 segT seg;
3996 {
3997 char *file;
3998 char *p;
3999 char *stabstr_name;
4000 unsigned int stroff;
4001
4002 /* Make space for this first symbol. */
4003 p = frag_more (12);
4004 /* Zero it out. */
4005 memset (p, 0, 12);
4006 as_where (&file, (unsigned int *) NULL);
4007 stabstr_name = (char *) alloca (strlen (segment_info[seg].scnhdr.s_name) + 4);
4008 strcpy (stabstr_name, segment_info[seg].scnhdr.s_name);
4009 strcat (stabstr_name, "str");
4010 stroff = get_stab_string_offset (file, stabstr_name);
4011 know (stroff == 1);
4012 md_number_to_chars (p, stroff, 4);
4013 }
4014
4015 /* Fill in the counts in the first entry in a .stab section. */
4016
4017 static void
4018 adjust_stab_section(abfd, seg)
4019 bfd *abfd;
4020 segT seg;
4021 {
4022 segT stabstrseg = SEG_UNKNOWN;
4023 char *secname, *name, *name2;
4024 char *p = NULL;
4025 int i, strsz = 0, nsyms;
4026 fragS *frag = segment_info[seg].frchainP->frch_root;
4027
4028 /* Look for the associated string table section. */
4029
4030 secname = segment_info[seg].scnhdr.s_name;
4031 name = (char *) alloca (strlen (secname) + 4);
4032 strcpy (name, secname);
4033 strcat (name, "str");
4034
4035 for (i = SEG_E0; i < SEG_UNKNOWN; i++)
4036 {
4037 name2 = segment_info[i].scnhdr.s_name;
4038 if (name2 != NULL && strncmp(name2, name, 8) == 0)
4039 {
4040 stabstrseg = i;
4041 break;
4042 }
4043 }
4044
4045 /* If we found the section, get its size. */
4046 if (stabstrseg != SEG_UNKNOWN)
4047 strsz = size_section (abfd, stabstrseg);
4048
4049 nsyms = size_section (abfd, seg) / 12 - 1;
4050
4051 /* Look for the first frag of sufficient size for the initial stab
4052 symbol, and collect a pointer to it. */
4053 while (frag && frag->fr_fix < 12)
4054 frag = frag->fr_next;
4055 assert (frag != 0);
4056 p = frag->fr_literal;
4057 assert (p != 0);
4058
4059 /* Write in the number of stab symbols and the size of the string
4060 table. */
4061 bfd_h_put_16 (abfd, (bfd_vma) nsyms, (bfd_byte *) p + 6);
4062 bfd_h_put_32 (abfd, (bfd_vma) strsz, (bfd_byte *) p + 8);
4063 }
4064
4065 #endif /* not BFD_ASSEMBLER */
4066
4067 const pseudo_typeS obj_pseudo_table[] =
4068 {
4069 {"def", obj_coff_def, 0},
4070 {"dim", obj_coff_dim, 0},
4071 {"endef", obj_coff_endef, 0},
4072 {"line", obj_coff_line, 0},
4073 {"ln", obj_coff_ln, 0},
4074 {"appline", obj_coff_ln, 1},
4075 {"scl", obj_coff_scl, 0},
4076 {"size", obj_coff_size, 0},
4077 {"tag", obj_coff_tag, 0},
4078 {"type", obj_coff_type, 0},
4079 {"val", obj_coff_val, 0},
4080 {"section", obj_coff_section, 0},
4081 {"sect", obj_coff_section, 0},
4082 /* FIXME: We ignore the MRI short attribute. */
4083 {"section.s", obj_coff_section, 0},
4084 {"sect.s", obj_coff_section, 0},
4085 #ifndef BFD_ASSEMBLER
4086 {"use", obj_coff_section, 0},
4087 {"text", obj_coff_text, 0},
4088 {"data", obj_coff_data, 0},
4089 {"bss", obj_coff_bss, 0},
4090 {"lcomm", obj_coff_lcomm, 0},
4091 {"ident", obj_coff_ident, 0},
4092 #else
4093 {"optim", s_ignore, 0}, /* For sun386i cc (?) */
4094 {"ident", s_ignore, 0}, /* we don't yet handle this. */
4095 #endif
4096 {"ABORT", s_abort, 0},
4097 #ifdef TC_M88K
4098 /* The m88k uses sdef instead of def. */
4099 {"sdef", obj_coff_def, 0},
4100 #endif
4101 {NULL} /* end sentinel */
4102 }; /* obj_pseudo_table */
GDB Binutils - Deliverables
This page took 0.134895 seconds and 5 git commands to generate.