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