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