projects / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
history | raw | HEAD
This commit was generated by cvs2svn to track changes on a CVS vendor
[binutils-gdb.git] / gas / config / tc-ppc.c
1 /* tc-ppc.c -- Assemble for the PowerPC or POWER (RS/6000)
2 Copyright (C) 1994, 95, 96, 97, 98, 1999 Free Software Foundation, Inc.
3 Written by Ian Lance Taylor, Cygnus Support.
4
5 This file is part of GAS, the GNU Assembler.
6
7 GAS is free software; you can redistribute it and/or modify
8 it under the terms of the GNU General Public License as published by
9 the Free Software Foundation; either version 2, or (at your option)
10 any later version.
11
12 GAS is distributed in the hope that it will be useful,
13 but WITHOUT ANY WARRANTY; without even the implied warranty of
14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15 GNU General Public License for more details.
16
17 You should have received a copy of the GNU General Public License
18 along with GAS; see the file COPYING. If not, write to the Free
19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
20 02111-1307, USA. */
21
22 #include <stdio.h>
23 #include <ctype.h>
24 #include "as.h"
25 #include "subsegs.h"
26
27 #include "opcode/ppc.h"
28
29 #ifdef OBJ_ELF
30 #include "elf/ppc.h"
31 #endif
32
33 #ifdef TE_PE
34 #include "coff/pe.h"
35 #endif
36
37 /* This is the assembler for the PowerPC or POWER (RS/6000) chips. */
38
39 /* Tell the main code what the endianness is. */
40 extern int target_big_endian;
41
42 /* Whether or not, we've set target_big_endian. */
43 static int set_target_endian = 0;
44
45 /* Whether to use user friendly register names. */
46 #ifndef TARGET_REG_NAMES_P
47 #ifdef TE_PE
48 #define TARGET_REG_NAMES_P true
49 #else
50 #define TARGET_REG_NAMES_P false
51 #endif
52 #endif
53
54 static boolean reg_names_p = TARGET_REG_NAMES_P;
55
56 static boolean register_name PARAMS ((expressionS *));
57 static void ppc_set_cpu PARAMS ((void));
58 static unsigned long ppc_insert_operand
59 PARAMS ((unsigned long insn, const struct powerpc_operand *operand,
60 offsetT val, char *file, unsigned int line));
61 static void ppc_macro PARAMS ((char *str, const struct powerpc_macro *macro));
62 static void ppc_byte PARAMS ((int));
63 static int ppc_is_toc_sym PARAMS ((symbolS *sym));
64 static void ppc_tc PARAMS ((int));
65
66 #ifdef OBJ_XCOFF
67 static void ppc_comm PARAMS ((int));
68 static void ppc_bb PARAMS ((int));
69 static void ppc_bc PARAMS ((int));
70 static void ppc_bf PARAMS ((int));
71 static void ppc_biei PARAMS ((int));
72 static void ppc_bs PARAMS ((int));
73 static void ppc_eb PARAMS ((int));
74 static void ppc_ec PARAMS ((int));
75 static void ppc_ef PARAMS ((int));
76 static void ppc_es PARAMS ((int));
77 static void ppc_csect PARAMS ((int));
78 static void ppc_change_csect PARAMS ((symbolS *));
79 static void ppc_function PARAMS ((int));
80 static void ppc_extern PARAMS ((int));
81 static void ppc_lglobl PARAMS ((int));
82 static void ppc_section PARAMS ((int));
83 static void ppc_named_section PARAMS ((int));
84 static void ppc_stabx PARAMS ((int));
85 static void ppc_rename PARAMS ((int));
86 static void ppc_toc PARAMS ((int));
87 static void ppc_xcoff_cons PARAMS ((int));
88 static void ppc_vbyte PARAMS ((int));
89 #endif
90
91 #ifdef OBJ_ELF
92 static bfd_reloc_code_real_type ppc_elf_suffix PARAMS ((char **, expressionS *));
93 static void ppc_elf_cons PARAMS ((int));
94 static void ppc_elf_rdata PARAMS ((int));
95 static void ppc_elf_lcomm PARAMS ((int));
96 static void ppc_elf_validate_fix PARAMS ((fixS *, segT));
97 #endif
98
99 #ifdef TE_PE
100 static void ppc_set_current_section PARAMS ((segT));
101 static void ppc_previous PARAMS ((int));
102 static void ppc_pdata PARAMS ((int));
103 static void ppc_ydata PARAMS ((int));
104 static void ppc_reldata PARAMS ((int));
105 static void ppc_rdata PARAMS ((int));
106 static void ppc_ualong PARAMS ((int));
107 static void ppc_znop PARAMS ((int));
108 static void ppc_pe_comm PARAMS ((int));
109 static void ppc_pe_section PARAMS ((int));
110 static void ppc_pe_function PARAMS ((int));
111 static void ppc_pe_tocd PARAMS ((int));
112 #endif
113 \f
114 /* Generic assembler global variables which must be defined by all
115 targets. */
116
117 #ifdef OBJ_ELF
118 /* This string holds the chars that always start a comment. If the
119 pre-processor is disabled, these aren't very useful. The macro
120 tc_comment_chars points to this. We use this, rather than the
121 usual comment_chars, so that we can switch for Solaris conventions. */
122 static const char ppc_solaris_comment_chars[] = "#!";
123 static const char ppc_eabi_comment_chars[] = "#";
124
125 #ifdef TARGET_SOLARIS_COMMENT
126 const char *ppc_comment_chars = ppc_solaris_comment_chars;
127 #else
128 const char *ppc_comment_chars = ppc_eabi_comment_chars;
129 #endif
130 #else
131 const char comment_chars[] = "#";
132 #endif
133
134 /* Characters which start a comment at the beginning of a line. */
135 const char line_comment_chars[] = "#";
136
137 /* Characters which may be used to separate multiple commands on a
138 single line. */
139 const char line_separator_chars[] = ";";
140
141 /* Characters which are used to indicate an exponent in a floating
142 point number. */
143 const char EXP_CHARS[] = "eE";
144
145 /* Characters which mean that a number is a floating point constant,
146 as in 0d1.0. */
147 const char FLT_CHARS[] = "dD";
148 \f
149 /* The target specific pseudo-ops which we support. */
150
151 const pseudo_typeS md_pseudo_table[] =
152 {
153 /* Pseudo-ops which must be overridden. */
154 { "byte", ppc_byte, 0 },
155
156 #ifdef OBJ_XCOFF
157 /* Pseudo-ops specific to the RS/6000 XCOFF format. Some of these
158 legitimately belong in the obj-*.c file. However, XCOFF is based
159 on COFF, and is only implemented for the RS/6000. We just use
160 obj-coff.c, and add what we need here. */
161 { "comm", ppc_comm, 0 },
162 { "lcomm", ppc_comm, 1 },
163 { "bb", ppc_bb, 0 },
164 { "bc", ppc_bc, 0 },
165 { "bf", ppc_bf, 0 },
166 { "bi", ppc_biei, 0 },
167 { "bs", ppc_bs, 0 },
168 { "csect", ppc_csect, 0 },
169 { "data", ppc_section, 'd' },
170 { "eb", ppc_eb, 0 },
171 { "ec", ppc_ec, 0 },
172 { "ef", ppc_ef, 0 },
173 { "ei", ppc_biei, 1 },
174 { "es", ppc_es, 0 },
175 { "extern", ppc_extern, 0 },
176 { "function", ppc_function, 0 },
177 { "lglobl", ppc_lglobl, 0 },
178 { "rename", ppc_rename, 0 },
179 { "section", ppc_named_section, 0 },
180 { "stabx", ppc_stabx, 0 },
181 { "text", ppc_section, 't' },
182 { "toc", ppc_toc, 0 },
183 { "long", ppc_xcoff_cons, 2 },
184 { "word", ppc_xcoff_cons, 1 },
185 { "short", ppc_xcoff_cons, 1 },
186 { "vbyte", ppc_vbyte, 0 },
187 #endif
188
189 #ifdef OBJ_ELF
190 { "long", ppc_elf_cons, 4 },
191 { "word", ppc_elf_cons, 2 },
192 { "short", ppc_elf_cons, 2 },
193 { "rdata", ppc_elf_rdata, 0 },
194 { "rodata", ppc_elf_rdata, 0 },
195 { "lcomm", ppc_elf_lcomm, 0 },
196 #endif
197
198 #ifdef TE_PE
199 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format */
200 { "previous", ppc_previous, 0 },
201 { "pdata", ppc_pdata, 0 },
202 { "ydata", ppc_ydata, 0 },
203 { "reldata", ppc_reldata, 0 },
204 { "rdata", ppc_rdata, 0 },
205 { "ualong", ppc_ualong, 0 },
206 { "znop", ppc_znop, 0 },
207 { "comm", ppc_pe_comm, 0 },
208 { "lcomm", ppc_pe_comm, 1 },
209 { "section", ppc_pe_section, 0 },
210 { "function", ppc_pe_function,0 },
211 { "tocd", ppc_pe_tocd, 0 },
212 #endif
213
214 /* This pseudo-op is used even when not generating XCOFF output. */
215 { "tc", ppc_tc, 0 },
216
217 { NULL, NULL, 0 }
218 };
219
220 \f
221 /* Predefined register names if -mregnames (or default for Windows NT). */
222 /* In general, there are lots of them, in an attempt to be compatible */
223 /* with a number of other Windows NT assemblers. */
224
225 /* Structure to hold information about predefined registers. */
226 struct pd_reg
227 {
228 char *name;
229 int value;
230 };
231
232 /* List of registers that are pre-defined:
233
234 Each general register has predefined names of the form:
235 1. r<reg_num> which has the value <reg_num>.
236 2. r.<reg_num> which has the value <reg_num>.
237
238
239 Each floating point register has predefined names of the form:
240 1. f<reg_num> which has the value <reg_num>.
241 2. f.<reg_num> which has the value <reg_num>.
242
243 Each condition register has predefined names of the form:
244 1. cr<reg_num> which has the value <reg_num>.
245 2. cr.<reg_num> which has the value <reg_num>.
246
247 There are individual registers as well:
248 sp or r.sp has the value 1
249 rtoc or r.toc has the value 2
250 fpscr has the value 0
251 xer has the value 1
252 lr has the value 8
253 ctr has the value 9
254 pmr has the value 0
255 dar has the value 19
256 dsisr has the value 18
257 dec has the value 22
258 sdr1 has the value 25
259 srr0 has the value 26
260 srr1 has the value 27
261
262 The table is sorted. Suitable for searching by a binary search. */
263
264 static const struct pd_reg pre_defined_registers[] =
265 {
266 { "cr.0", 0 }, /* Condition Registers */
267 { "cr.1", 1 },
268 { "cr.2", 2 },
269 { "cr.3", 3 },
270 { "cr.4", 4 },
271 { "cr.5", 5 },
272 { "cr.6", 6 },
273 { "cr.7", 7 },
274
275 { "cr0", 0 },
276 { "cr1", 1 },
277 { "cr2", 2 },
278 { "cr3", 3 },
279 { "cr4", 4 },
280 { "cr5", 5 },
281 { "cr6", 6 },
282 { "cr7", 7 },
283
284 { "ctr", 9 },
285
286 { "dar", 19 }, /* Data Access Register */
287 { "dec", 22 }, /* Decrementer */
288 { "dsisr", 18 }, /* Data Storage Interrupt Status Register */
289
290 { "f.0", 0 }, /* Floating point registers */
291 { "f.1", 1 },
292 { "f.10", 10 },
293 { "f.11", 11 },
294 { "f.12", 12 },
295 { "f.13", 13 },
296 { "f.14", 14 },
297 { "f.15", 15 },
298 { "f.16", 16 },
299 { "f.17", 17 },
300 { "f.18", 18 },
301 { "f.19", 19 },
302 { "f.2", 2 },
303 { "f.20", 20 },
304 { "f.21", 21 },
305 { "f.22", 22 },
306 { "f.23", 23 },
307 { "f.24", 24 },
308 { "f.25", 25 },
309 { "f.26", 26 },
310 { "f.27", 27 },
311 { "f.28", 28 },
312 { "f.29", 29 },
313 { "f.3", 3 },
314 { "f.30", 30 },
315 { "f.31", 31 },
316 { "f.4", 4 },
317 { "f.5", 5 },
318 { "f.6", 6 },
319 { "f.7", 7 },
320 { "f.8", 8 },
321 { "f.9", 9 },
322
323 { "f0", 0 },
324 { "f1", 1 },
325 { "f10", 10 },
326 { "f11", 11 },
327 { "f12", 12 },
328 { "f13", 13 },
329 { "f14", 14 },
330 { "f15", 15 },
331 { "f16", 16 },
332 { "f17", 17 },
333 { "f18", 18 },
334 { "f19", 19 },
335 { "f2", 2 },
336 { "f20", 20 },
337 { "f21", 21 },
338 { "f22", 22 },
339 { "f23", 23 },
340 { "f24", 24 },
341 { "f25", 25 },
342 { "f26", 26 },
343 { "f27", 27 },
344 { "f28", 28 },
345 { "f29", 29 },
346 { "f3", 3 },
347 { "f30", 30 },
348 { "f31", 31 },
349 { "f4", 4 },
350 { "f5", 5 },
351 { "f6", 6 },
352 { "f7", 7 },
353 { "f8", 8 },
354 { "f9", 9 },
355
356 { "fpscr", 0 },
357
358 { "lr", 8 }, /* Link Register */
359
360 { "pmr", 0 },
361
362 { "r.0", 0 }, /* General Purpose Registers */
363 { "r.1", 1 },
364 { "r.10", 10 },
365 { "r.11", 11 },
366 { "r.12", 12 },
367 { "r.13", 13 },
368 { "r.14", 14 },
369 { "r.15", 15 },
370 { "r.16", 16 },
371 { "r.17", 17 },
372 { "r.18", 18 },
373 { "r.19", 19 },
374 { "r.2", 2 },
375 { "r.20", 20 },
376 { "r.21", 21 },
377 { "r.22", 22 },
378 { "r.23", 23 },
379 { "r.24", 24 },
380 { "r.25", 25 },
381 { "r.26", 26 },
382 { "r.27", 27 },
383 { "r.28", 28 },
384 { "r.29", 29 },
385 { "r.3", 3 },
386 { "r.30", 30 },
387 { "r.31", 31 },
388 { "r.4", 4 },
389 { "r.5", 5 },
390 { "r.6", 6 },
391 { "r.7", 7 },
392 { "r.8", 8 },
393 { "r.9", 9 },
394
395 { "r.sp", 1 }, /* Stack Pointer */
396
397 { "r.toc", 2 }, /* Pointer to the table of contents */
398
399 { "r0", 0 }, /* More general purpose registers */
400 { "r1", 1 },
401 { "r10", 10 },
402 { "r11", 11 },
403 { "r12", 12 },
404 { "r13", 13 },
405 { "r14", 14 },
406 { "r15", 15 },
407 { "r16", 16 },
408 { "r17", 17 },
409 { "r18", 18 },
410 { "r19", 19 },
411 { "r2", 2 },
412 { "r20", 20 },
413 { "r21", 21 },
414 { "r22", 22 },
415 { "r23", 23 },
416 { "r24", 24 },
417 { "r25", 25 },
418 { "r26", 26 },
419 { "r27", 27 },
420 { "r28", 28 },
421 { "r29", 29 },
422 { "r3", 3 },
423 { "r30", 30 },
424 { "r31", 31 },
425 { "r4", 4 },
426 { "r5", 5 },
427 { "r6", 6 },
428 { "r7", 7 },
429 { "r8", 8 },
430 { "r9", 9 },
431
432 { "rtoc", 2 }, /* Table of contents */
433
434 { "sdr1", 25 }, /* Storage Description Register 1 */
435
436 { "sp", 1 },
437
438 { "srr0", 26 }, /* Machine Status Save/Restore Register 0 */
439 { "srr1", 27 }, /* Machine Status Save/Restore Register 1 */
440
441 { "xer", 1 },
442
443 };
444
445 #define REG_NAME_CNT (sizeof(pre_defined_registers) / sizeof(struct pd_reg))
446
447 /* Given NAME, find the register number associated with that name, return
448 the integer value associated with the given name or -1 on failure. */
449
450 static int reg_name_search
451 PARAMS ((const struct pd_reg *, int, const char * name));
452
453 static int
454 reg_name_search (regs, regcount, name)
455 const struct pd_reg *regs;
456 int regcount;
457 const char *name;
458 {
459 int middle, low, high;
460 int cmp;
461
462 low = 0;
463 high = regcount - 1;
464
465 do
466 {
467 middle = (low + high) / 2;
468 cmp = strcasecmp (name, regs[middle].name);
469 if (cmp < 0)
470 high = middle - 1;
471 else if (cmp > 0)
472 low = middle + 1;
473 else
474 return regs[middle].value;
475 }
476 while (low <= high);
477
478 return -1;
479 }
480
481 /*
482 * Summary of register_name().
483 *
484 * in: Input_line_pointer points to 1st char of operand.
485 *
486 * out: A expressionS.
487 * The operand may have been a register: in this case, X_op == O_register,
488 * X_add_number is set to the register number, and truth is returned.
489 * Input_line_pointer->(next non-blank) char after operand, or is in its
490 * original state.
491 */
492
493 static boolean
494 register_name (expressionP)
495 expressionS *expressionP;
496 {
497 int reg_number;
498 char *name;
499 char *start;
500 char c;
501
502 /* Find the spelling of the operand */
503 start = name = input_line_pointer;
504 if (name[0] == '%' && isalpha (name[1]))
505 name = ++input_line_pointer;
506
507 else if (!reg_names_p || !isalpha (name[0]))
508 return false;
509
510 c = get_symbol_end ();
511 reg_number = reg_name_search (pre_defined_registers, REG_NAME_CNT, name);
512
513 /* look to see if it's in the register table */
514 if (reg_number >= 0)
515 {
516 expressionP->X_op = O_register;
517 expressionP->X_add_number = reg_number;
518
519 /* make the rest nice */
520 expressionP->X_add_symbol = NULL;
521 expressionP->X_op_symbol = NULL;
522 *input_line_pointer = c; /* put back the delimiting char */
523 return true;
524 }
525 else
526 {
527 /* reset the line as if we had not done anything */
528 *input_line_pointer = c; /* put back the delimiting char */
529 input_line_pointer = start; /* reset input_line pointer */
530 return false;
531 }
532 }
533 \f
534 /* This function is called for each symbol seen in an expression. It
535 handles the special parsing which PowerPC assemblers are supposed
536 to use for condition codes. */
537
538 /* Whether to do the special parsing. */
539 static boolean cr_operand;
540
541 /* Names to recognize in a condition code. This table is sorted. */
542 static const struct pd_reg cr_names[] =
543 {
544 { "cr0", 0 },
545 { "cr1", 1 },
546 { "cr2", 2 },
547 { "cr3", 3 },
548 { "cr4", 4 },
549 { "cr5", 5 },
550 { "cr6", 6 },
551 { "cr7", 7 },
552 { "eq", 2 },
553 { "gt", 1 },
554 { "lt", 0 },
555 { "so", 3 },
556 { "un", 3 }
557 };
558
559 /* Parsing function. This returns non-zero if it recognized an
560 expression. */
561
562 int
563 ppc_parse_name (name, expr)
564 const char *name;
565 expressionS *expr;
566 {
567 int val;
568
569 if (! cr_operand)
570 return 0;
571
572 val = reg_name_search (cr_names, sizeof cr_names / sizeof cr_names[0],
573 name);
574 if (val < 0)
575 return 0;
576
577 expr->X_op = O_constant;
578 expr->X_add_number = val;
579
580 return 1;
581 }
582 \f
583 /* Local variables. */
584
585 /* The type of processor we are assembling for. This is one or more
586 of the PPC_OPCODE flags defined in opcode/ppc.h. */
587 static int ppc_cpu = 0;
588
589 /* The size of the processor we are assembling for. This is either
590 PPC_OPCODE_32 or PPC_OPCODE_64. */
591 static int ppc_size = PPC_OPCODE_32;
592
593 /* Opcode hash table. */
594 static struct hash_control *ppc_hash;
595
596 /* Macro hash table. */
597 static struct hash_control *ppc_macro_hash;
598
599 #ifdef OBJ_ELF
600 /* What type of shared library support to use */
601 static enum { SHLIB_NONE, SHLIB_PIC, SHILB_MRELOCATABLE } shlib = SHLIB_NONE;
602
603 /* Flags to set in the elf header */
604 static flagword ppc_flags = 0;
605
606 /* Whether this is Solaris or not. */
607 #ifdef TARGET_SOLARIS_COMMENT
608 #define SOLARIS_P true
609 #else
610 #define SOLARIS_P false
611 #endif
612
613 static boolean msolaris = SOLARIS_P;
614 #endif
615
616 #ifdef OBJ_XCOFF
617
618 /* The RS/6000 assembler uses the .csect pseudo-op to generate code
619 using a bunch of different sections. These assembler sections,
620 however, are all encompassed within the .text or .data sections of
621 the final output file. We handle this by using different
622 subsegments within these main segments. */
623
624 /* Next subsegment to allocate within the .text segment. */
625 static subsegT ppc_text_subsegment = 2;
626
627 /* Linked list of csects in the text section. */
628 static symbolS *ppc_text_csects;
629
630 /* Next subsegment to allocate within the .data segment. */
631 static subsegT ppc_data_subsegment = 2;
632
633 /* Linked list of csects in the data section. */
634 static symbolS *ppc_data_csects;
635
636 /* The current csect. */
637 static symbolS *ppc_current_csect;
638
639 /* The RS/6000 assembler uses a TOC which holds addresses of functions
640 and variables. Symbols are put in the TOC with the .tc pseudo-op.
641 A special relocation is used when accessing TOC entries. We handle
642 the TOC as a subsegment within the .data segment. We set it up if
643 we see a .toc pseudo-op, and save the csect symbol here. */
644 static symbolS *ppc_toc_csect;
645
646 /* The first frag in the TOC subsegment. */
647 static fragS *ppc_toc_frag;
648
649 /* The first frag in the first subsegment after the TOC in the .data
650 segment. NULL if there are no subsegments after the TOC. */
651 static fragS *ppc_after_toc_frag;
652
653 /* The current static block. */
654 static symbolS *ppc_current_block;
655
656 /* The COFF debugging section; set by md_begin. This is not the
657 .debug section, but is instead the secret BFD section which will
658 cause BFD to set the section number of a symbol to N_DEBUG. */
659 static asection *ppc_coff_debug_section;
660
661 #endif /* OBJ_XCOFF */
662
663 #ifdef TE_PE
664
665 /* Various sections that we need for PE coff support. */
666 static segT ydata_section;
667 static segT pdata_section;
668 static segT reldata_section;
669 static segT rdata_section;
670 static segT tocdata_section;
671
672 /* The current section and the previous section. See ppc_previous. */
673 static segT ppc_previous_section;
674 static segT ppc_current_section;
675
676 #endif /* TE_PE */
677
678 #ifdef OBJ_ELF
679 symbolS *GOT_symbol; /* Pre-defined "_GLOBAL_OFFSET_TABLE" */
680 #endif /* OBJ_ELF */
681 \f
682 #ifdef OBJ_ELF
683 CONST char *md_shortopts = "b:l:usm:K:VQ:";
684 #else
685 CONST char *md_shortopts = "um:";
686 #endif
687 struct option md_longopts[] = {
688 {NULL, no_argument, NULL, 0}
689 };
690 size_t md_longopts_size = sizeof(md_longopts);
691
692 int
693 md_parse_option (c, arg)
694 int c;
695 char *arg;
696 {
697 switch (c)
698 {
699 case 'u':
700 /* -u means that any undefined symbols should be treated as
701 external, which is the default for gas anyhow. */
702 break;
703
704 #ifdef OBJ_ELF
705 case 'l':
706 /* Solaris as takes -le (presumably for little endian). For completeness
707 sake, recognize -be also. */
708 if (strcmp (arg, "e") == 0)
709 {
710 target_big_endian = 0;
711 set_target_endian = 1;
712 }
713 else
714 return 0;
715
716 break;
717
718 case 'b':
719 if (strcmp (arg, "e") == 0)
720 {
721 target_big_endian = 1;
722 set_target_endian = 1;
723 }
724 else
725 return 0;
726
727 break;
728
729 case 'K':
730 /* Recognize -K PIC */
731 if (strcmp (arg, "PIC") == 0 || strcmp (arg, "pic") == 0)
732 {
733 shlib = SHLIB_PIC;
734 ppc_flags |= EF_PPC_RELOCATABLE_LIB;
735 }
736 else
737 return 0;
738
739 break;
740 #endif
741
742 case 'm':
743 /* -mpwrx and -mpwr2 mean to assemble for the IBM POWER/2
744 (RIOS2). */
745 if (strcmp (arg, "pwrx") == 0 || strcmp (arg, "pwr2") == 0)
746 ppc_cpu = PPC_OPCODE_POWER | PPC_OPCODE_POWER2;
747 /* -mpwr means to assemble for the IBM POWER (RIOS1). */
748 else if (strcmp (arg, "pwr") == 0)
749 ppc_cpu = PPC_OPCODE_POWER;
750 /* -m601 means to assemble for the Motorola PowerPC 601, which includes
751 instructions that are holdovers from the Power. */
752 else if (strcmp (arg, "601") == 0)
753 ppc_cpu = PPC_OPCODE_PPC | PPC_OPCODE_601;
754 /* -mppc, -mppc32, -m603, and -m604 mean to assemble for the
755 Motorola PowerPC 603/604. */
756 else if (strcmp (arg, "ppc") == 0
757 || strcmp (arg, "ppc32") == 0
758 || strcmp (arg, "403") == 0
759 || strcmp (arg, "603") == 0
760 || strcmp (arg, "604") == 0)
761 ppc_cpu = PPC_OPCODE_PPC;
762 /* -mppc64 and -m620 mean to assemble for the 64-bit PowerPC
763 620. */
764 else if (strcmp (arg, "ppc64") == 0 || strcmp (arg, "620") == 0)
765 {
766 ppc_cpu = PPC_OPCODE_PPC;
767 ppc_size = PPC_OPCODE_64;
768 }
769 else if (strcmp (arg, "ppc64bridge") == 0)
770 {
771 ppc_cpu = PPC_OPCODE_PPC | PPC_OPCODE_64_BRIDGE;
772 ppc_size = PPC_OPCODE_64;
773 }
774 /* -mcom means assemble for the common intersection between Power
775 and PowerPC. At present, we just allow the union, rather
776 than the intersection. */
777 else if (strcmp (arg, "com") == 0)
778 ppc_cpu = PPC_OPCODE_COMMON;
779 /* -many means to assemble for any architecture (PWR/PWRX/PPC). */
780 else if (strcmp (arg, "any") == 0)
781 ppc_cpu = PPC_OPCODE_ANY;
782
783 else if (strcmp (arg, "regnames") == 0)
784 reg_names_p = true;
785
786 else if (strcmp (arg, "no-regnames") == 0)
787 reg_names_p = false;
788
789 #ifdef OBJ_ELF
790 /* -mrelocatable/-mrelocatable-lib -- warn about initializations that require relocation */
791 else if (strcmp (arg, "relocatable") == 0)
792 {
793 shlib = SHILB_MRELOCATABLE;
794 ppc_flags |= EF_PPC_RELOCATABLE;
795 }
796
797 else if (strcmp (arg, "relocatable-lib") == 0)
798 {
799 shlib = SHILB_MRELOCATABLE;
800 ppc_flags |= EF_PPC_RELOCATABLE_LIB;
801 }
802
803 /* -memb, set embedded bit */
804 else if (strcmp (arg, "emb") == 0)
805 ppc_flags |= EF_PPC_EMB;
806
807 /* -mlittle/-mbig set the endianess */
808 else if (strcmp (arg, "little") == 0 || strcmp (arg, "little-endian") == 0)
809 {
810 target_big_endian = 0;
811 set_target_endian = 1;
812 }
813
814 else if (strcmp (arg, "big") == 0 || strcmp (arg, "big-endian") == 0)
815 {
816 target_big_endian = 1;
817 set_target_endian = 1;
818 }
819
820 else if (strcmp (arg, "solaris") == 0)
821 {
822 msolaris = true;
823 ppc_comment_chars = ppc_solaris_comment_chars;
824 }
825
826 else if (strcmp (arg, "no-solaris") == 0)
827 {
828 msolaris = false;
829 ppc_comment_chars = ppc_eabi_comment_chars;
830 }
831 #endif
832 else
833 {
834 as_bad (_("invalid switch -m%s"), arg);
835 return 0;
836 }
837 break;
838
839 #ifdef OBJ_ELF
840 /* -V: SVR4 argument to print version ID. */
841 case 'V':
842 print_version_id ();
843 break;
844
845 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
846 should be emitted or not. FIXME: Not implemented. */
847 case 'Q':
848 break;
849
850 /* Solaris takes -s to specify that .stabs go in a .stabs section,
851 rather than .stabs.excl, which is ignored by the linker.
852 FIXME: Not implemented. */
853 case 's':
854 if (arg)
855 return 0;
856
857 break;
858 #endif
859
860 default:
861 return 0;
862 }
863
864 return 1;
865 }
866
867 void
868 md_show_usage (stream)
869 FILE *stream;
870 {
871 fprintf(stream, _("\
872 PowerPC options:\n\
873 -u ignored\n\
874 -mpwrx, -mpwr2 generate code for IBM POWER/2 (RIOS2)\n\
875 -mpwr generate code for IBM POWER (RIOS1)\n\
876 -m601 generate code for Motorola PowerPC 601\n\
877 -mppc, -mppc32, -m403, -m603, -m604\n\
878 generate code for Motorola PowerPC 603/604\n\
879 -mppc64, -m620 generate code for Motorola PowerPC 620\n\
880 -mppc64bridge generate code for PowerPC 64, including bridge insns\n\
881 -mcom generate code Power/PowerPC common instructions\n\
882 -many generate code for any architecture (PWR/PWRX/PPC)\n\
883 -mregnames Allow symbolic names for registers\n\
884 -mno-regnames Do not allow symbolic names for registers\n"));
885 #ifdef OBJ_ELF
886 fprintf(stream, _("\
887 -mrelocatable support for GCC's -mrelocatble option\n\
888 -mrelocatable-lib support for GCC's -mrelocatble-lib option\n\
889 -memb set PPC_EMB bit in ELF flags\n\
890 -mlittle, -mlittle-endian\n\
891 generate code for a little endian machine\n\
892 -mbig, -mbig-endian generate code for a big endian machine\n\
893 -msolaris generate code for Solaris\n\
894 -mno-solaris do not generate code for Solaris\n\
895 -V print assembler version number\n\
896 -Qy, -Qn ignored\n"));
897 #endif
898 }
899 \f
900 /* Set ppc_cpu if it is not already set. */
901
902 static void
903 ppc_set_cpu ()
904 {
905 const char *default_os = TARGET_OS;
906 const char *default_cpu = TARGET_CPU;
907
908 if (ppc_cpu == 0)
909 {
910 if (strncmp (default_os, "aix", 3) == 0
911 && default_os[3] >= '4' && default_os[3] <= '9')
912 ppc_cpu = PPC_OPCODE_COMMON;
913 else if (strncmp (default_os, "aix3", 4) == 0)
914 ppc_cpu = PPC_OPCODE_POWER;
915 else if (strcmp (default_cpu, "rs6000") == 0)
916 ppc_cpu = PPC_OPCODE_POWER;
917 else if (strcmp (default_cpu, "powerpc") == 0
918 || strcmp (default_cpu, "powerpcle") == 0)
919 ppc_cpu = PPC_OPCODE_PPC;
920 else
921 as_fatal (_("Unknown default cpu = %s, os = %s"), default_cpu, default_os);
922 }
923 }
924
925 /* Figure out the BFD architecture to use. */
926
927 enum bfd_architecture
928 ppc_arch ()
929 {
930 const char *default_cpu = TARGET_CPU;
931 ppc_set_cpu ();
932
933 if ((ppc_cpu & PPC_OPCODE_PPC) != 0)
934 return bfd_arch_powerpc;
935 else if ((ppc_cpu & PPC_OPCODE_POWER) != 0)
936 return bfd_arch_rs6000;
937 else if ((ppc_cpu & (PPC_OPCODE_COMMON | PPC_OPCODE_ANY)) != 0)
938 {
939 if (strcmp (default_cpu, "rs6000") == 0)
940 return bfd_arch_rs6000;
941 else if (strcmp (default_cpu, "powerpc") == 0
942 || strcmp (default_cpu, "powerpcle") == 0)
943 return bfd_arch_powerpc;
944 }
945
946 as_fatal (_("Neither Power nor PowerPC opcodes were selected."));
947 return bfd_arch_unknown;
948 }
949
950 /* This function is called when the assembler starts up. It is called
951 after the options have been parsed and the output file has been
952 opened. */
953
954 void
955 md_begin ()
956 {
957 register const struct powerpc_opcode *op;
958 const struct powerpc_opcode *op_end;
959 const struct powerpc_macro *macro;
960 const struct powerpc_macro *macro_end;
961 boolean dup_insn = false;
962
963 ppc_set_cpu ();
964
965 #ifdef OBJ_ELF
966 /* Set the ELF flags if desired. */
967 if (ppc_flags && !msolaris)
968 bfd_set_private_flags (stdoutput, ppc_flags);
969 #endif
970
971 /* Insert the opcodes into a hash table. */
972 ppc_hash = hash_new ();
973
974 op_end = powerpc_opcodes + powerpc_num_opcodes;
975 for (op = powerpc_opcodes; op < op_end; op++)
976 {
977 know ((op->opcode & op->mask) == op->opcode);
978
979 if ((op->flags & ppc_cpu) != 0
980 && ((op->flags & (PPC_OPCODE_32 | PPC_OPCODE_64)) == 0
981 || (op->flags & (PPC_OPCODE_32 | PPC_OPCODE_64)) == ppc_size
982 || (ppc_cpu & PPC_OPCODE_64_BRIDGE) != 0))
983 {
984 const char *retval;
985
986 retval = hash_insert (ppc_hash, op->name, (PTR) op);
987 if (retval != (const char *) NULL)
988 {
989 /* Ignore Power duplicates for -m601 */
990 if ((ppc_cpu & PPC_OPCODE_601) != 0
991 && (op->flags & PPC_OPCODE_POWER) != 0)
992 continue;
993
994 as_bad (_("Internal assembler error for instruction %s"), op->name);
995 dup_insn = true;
996 }
997 }
998 }
999
1000 /* Insert the macros into a hash table. */
1001 ppc_macro_hash = hash_new ();
1002
1003 macro_end = powerpc_macros + powerpc_num_macros;
1004 for (macro = powerpc_macros; macro < macro_end; macro++)
1005 {
1006 if ((macro->flags & ppc_cpu) != 0)
1007 {
1008 const char *retval;
1009
1010 retval = hash_insert (ppc_macro_hash, macro->name, (PTR) macro);
1011 if (retval != (const char *) NULL)
1012 {
1013 as_bad (_("Internal assembler error for macro %s"), macro->name);
1014 dup_insn = true;
1015 }
1016 }
1017 }
1018
1019 if (dup_insn)
1020 abort ();
1021
1022 /* Tell the main code what the endianness is if it is not overidden by the user. */
1023 if (!set_target_endian)
1024 {
1025 set_target_endian = 1;
1026 target_big_endian = PPC_BIG_ENDIAN;
1027 }
1028
1029 #ifdef OBJ_XCOFF
1030 ppc_coff_debug_section = coff_section_from_bfd_index (stdoutput, N_DEBUG);
1031
1032 /* Create dummy symbols to serve as initial csects. This forces the
1033 text csects to precede the data csects. These symbols will not
1034 be output. */
1035 ppc_text_csects = symbol_make ("dummy\001");
1036 symbol_get_tc (ppc_text_csects)->within = ppc_text_csects;
1037 ppc_data_csects = symbol_make ("dummy\001");
1038 symbol_get_tc (ppc_data_csects)->within = ppc_data_csects;
1039 #endif
1040
1041 #ifdef TE_PE
1042
1043 ppc_current_section = text_section;
1044 ppc_previous_section = 0;
1045
1046 #endif
1047 }
1048
1049 /* Insert an operand value into an instruction. */
1050
1051 static unsigned long
1052 ppc_insert_operand (insn, operand, val, file, line)
1053 unsigned long insn;
1054 const struct powerpc_operand *operand;
1055 offsetT val;
1056 char *file;
1057 unsigned int line;
1058 {
1059 if (operand->bits != 32)
1060 {
1061 long min, max;
1062 offsetT test;
1063
1064 if ((operand->flags & PPC_OPERAND_SIGNED) != 0)
1065 {
1066 if ((operand->flags & PPC_OPERAND_SIGNOPT) != 0)
1067 max = (1 << operand->bits) - 1;
1068 else
1069 max = (1 << (operand->bits - 1)) - 1;
1070 min = - (1 << (operand->bits - 1));
1071
1072 if (ppc_size == PPC_OPCODE_32)
1073 {
1074 /* Some people write 32 bit hex constants with the sign
1075 extension done by hand. This shouldn't really be
1076 valid, but, to permit this code to assemble on a 64
1077 bit host, we sign extend the 32 bit value. */
1078 if (val > 0
1079 && (val & 0x80000000) != 0
1080 && (val & 0xffffffff) == val)
1081 {
1082 val -= 0x80000000;
1083 val -= 0x80000000;
1084 }
1085 }
1086 }
1087 else
1088 {
1089 max = (1 << operand->bits) - 1;
1090 min = 0;
1091 }
1092
1093 if ((operand->flags & PPC_OPERAND_NEGATIVE) != 0)
1094 test = - val;
1095 else
1096 test = val;
1097
1098 if (test < (offsetT) min || test > (offsetT) max)
1099 {
1100 const char *err =
1101 _("operand out of range (%s not between %ld and %ld)");
1102 char buf[100];
1103
1104 sprint_value (buf, test);
1105 if (file == (char *) NULL)
1106 as_bad (err, buf, min, max);
1107 else
1108 as_bad_where (file, line, err, buf, min, max);
1109 }
1110 }
1111
1112 if (operand->insert)
1113 {
1114 const char *errmsg;
1115
1116 errmsg = NULL;
1117 insn = (*operand->insert) (insn, (long) val, &errmsg);
1118 if (errmsg != (const char *) NULL)
1119 as_bad (errmsg);
1120 }
1121 else
1122 insn |= (((long) val & ((1 << operand->bits) - 1))
1123 << operand->shift);
1124
1125 return insn;
1126 }
1127
1128 \f
1129 #ifdef OBJ_ELF
1130 /* Parse @got, etc. and return the desired relocation. */
1131 static bfd_reloc_code_real_type
1132 ppc_elf_suffix (str_p, exp_p)
1133 char **str_p;
1134 expressionS *exp_p;
1135 {
1136 struct map_bfd {
1137 char *string;
1138 int length;
1139 bfd_reloc_code_real_type reloc;
1140 };
1141
1142 char ident[20];
1143 char *str = *str_p;
1144 char *str2;
1145 int ch;
1146 int len;
1147 struct map_bfd *ptr;
1148
1149 #define MAP(str,reloc) { str, sizeof(str)-1, reloc }
1150
1151 static struct map_bfd mapping[] = {
1152 MAP ("l", BFD_RELOC_LO16),
1153 MAP ("h", BFD_RELOC_HI16),
1154 MAP ("ha", BFD_RELOC_HI16_S),
1155 MAP ("brtaken", BFD_RELOC_PPC_B16_BRTAKEN),
1156 MAP ("brntaken", BFD_RELOC_PPC_B16_BRNTAKEN),
1157 MAP ("got", BFD_RELOC_16_GOTOFF),
1158 MAP ("got@l", BFD_RELOC_LO16_GOTOFF),
1159 MAP ("got@h", BFD_RELOC_HI16_GOTOFF),
1160 MAP ("got@ha", BFD_RELOC_HI16_S_GOTOFF),
1161 MAP ("fixup", BFD_RELOC_CTOR), /* warnings with -mrelocatable */
1162 MAP ("plt", BFD_RELOC_24_PLT_PCREL),
1163 MAP ("pltrel24", BFD_RELOC_24_PLT_PCREL),
1164 MAP ("copy", BFD_RELOC_PPC_COPY),
1165 MAP ("globdat", BFD_RELOC_PPC_GLOB_DAT),
1166 MAP ("local24pc", BFD_RELOC_PPC_LOCAL24PC),
1167 MAP ("local", BFD_RELOC_PPC_LOCAL24PC),
1168 MAP ("pltrel", BFD_RELOC_32_PLT_PCREL),
1169 MAP ("plt@l", BFD_RELOC_LO16_PLTOFF),
1170 MAP ("plt@h", BFD_RELOC_HI16_PLTOFF),
1171 MAP ("plt@ha", BFD_RELOC_HI16_S_PLTOFF),
1172 MAP ("sdarel", BFD_RELOC_GPREL16),
1173 MAP ("sectoff", BFD_RELOC_32_BASEREL),
1174 MAP ("sectoff@l", BFD_RELOC_LO16_BASEREL),
1175 MAP ("sectoff@h", BFD_RELOC_HI16_BASEREL),
1176 MAP ("sectoff@ha", BFD_RELOC_HI16_S_BASEREL),
1177 MAP ("naddr", BFD_RELOC_PPC_EMB_NADDR32),
1178 MAP ("naddr16", BFD_RELOC_PPC_EMB_NADDR16),
1179 MAP ("naddr@l", BFD_RELOC_PPC_EMB_NADDR16_LO),
1180 MAP ("naddr@h", BFD_RELOC_PPC_EMB_NADDR16_HI),
1181 MAP ("naddr@ha", BFD_RELOC_PPC_EMB_NADDR16_HA),
1182 MAP ("sdai16", BFD_RELOC_PPC_EMB_SDAI16),
1183 MAP ("sda2rel", BFD_RELOC_PPC_EMB_SDA2REL),
1184 MAP ("sda2i16", BFD_RELOC_PPC_EMB_SDA2I16),
1185 MAP ("sda21", BFD_RELOC_PPC_EMB_SDA21),
1186 MAP ("mrkref", BFD_RELOC_PPC_EMB_MRKREF),
1187 MAP ("relsect", BFD_RELOC_PPC_EMB_RELSEC16),
1188 MAP ("relsect@l", BFD_RELOC_PPC_EMB_RELST_LO),
1189 MAP ("relsect@h", BFD_RELOC_PPC_EMB_RELST_HI),
1190 MAP ("relsect@ha", BFD_RELOC_PPC_EMB_RELST_HA),
1191 MAP ("bitfld", BFD_RELOC_PPC_EMB_BIT_FLD),
1192 MAP ("relsda", BFD_RELOC_PPC_EMB_RELSDA),
1193 MAP ("xgot", BFD_RELOC_PPC_TOC16),
1194
1195 { (char *)0, 0, BFD_RELOC_UNUSED }
1196 };
1197
1198 if (*str++ != '@')
1199 return BFD_RELOC_UNUSED;
1200
1201 for (ch = *str, str2 = ident;
1202 (str2 < ident + sizeof (ident) - 1
1203 && (isalnum (ch) || ch == '@'));
1204 ch = *++str)
1205 {
1206 *str2++ = (islower (ch)) ? ch : tolower (ch);
1207 }
1208
1209 *str2 = '\0';
1210 len = str2 - ident;
1211
1212 ch = ident[0];
1213 for (ptr = &mapping[0]; ptr->length > 0; ptr++)
1214 if (ch == ptr->string[0]
1215 && len == ptr->length
1216 && memcmp (ident, ptr->string, ptr->length) == 0)
1217 {
1218 if (exp_p->X_add_number != 0
1219 && (ptr->reloc == BFD_RELOC_16_GOTOFF
1220 || ptr->reloc == BFD_RELOC_LO16_GOTOFF
1221 || ptr->reloc == BFD_RELOC_HI16_GOTOFF
1222 || ptr->reloc == BFD_RELOC_HI16_S_GOTOFF))
1223 as_warn (_("identifier+constant@got means identifier@got+constant"));
1224
1225 /* Now check for identifier@suffix+constant */
1226 if (*str == '-' || *str == '+')
1227 {
1228 char *orig_line = input_line_pointer;
1229 expressionS new_exp;
1230
1231 input_line_pointer = str;
1232 expression (&new_exp);
1233 if (new_exp.X_op == O_constant)
1234 {
1235 exp_p->X_add_number += new_exp.X_add_number;
1236 str = input_line_pointer;
1237 }
1238
1239 if (&input_line_pointer != str_p)
1240 input_line_pointer = orig_line;
1241 }
1242
1243 *str_p = str;
1244 return ptr->reloc;
1245 }
1246
1247 return BFD_RELOC_UNUSED;
1248 }
1249
1250 /* Like normal .long/.short/.word, except support @got, etc. */
1251 /* clobbers input_line_pointer, checks */
1252 /* end-of-line. */
1253 static void
1254 ppc_elf_cons (nbytes)
1255 register int nbytes; /* 1=.byte, 2=.word, 4=.long */
1256 {
1257 expressionS exp;
1258 bfd_reloc_code_real_type reloc;
1259
1260 if (is_it_end_of_statement ())
1261 {
1262 demand_empty_rest_of_line ();
1263 return;
1264 }
1265
1266 do
1267 {
1268 expression (&exp);
1269 if (exp.X_op == O_symbol
1270 && *input_line_pointer == '@'
1271 && (reloc = ppc_elf_suffix (&input_line_pointer, &exp)) != BFD_RELOC_UNUSED)
1272 {
1273 reloc_howto_type *reloc_howto = bfd_reloc_type_lookup (stdoutput, reloc);
1274 int size = bfd_get_reloc_size (reloc_howto);
1275
1276 if (size > nbytes)
1277 as_bad (_("%s relocations do not fit in %d bytes\n"), reloc_howto->name, nbytes);
1278
1279 else
1280 {
1281 register char *p = frag_more ((int) nbytes);
1282 int offset = nbytes - size;
1283
1284 fix_new_exp (frag_now, p - frag_now->fr_literal + offset, size, &exp, 0, reloc);
1285 }
1286 }
1287 else
1288 emit_expr (&exp, (unsigned int) nbytes);
1289 }
1290 while (*input_line_pointer++ == ',');
1291
1292 input_line_pointer--; /* Put terminator back into stream. */
1293 demand_empty_rest_of_line ();
1294 }
1295
1296 /* Solaris pseduo op to change to the .rodata section. */
1297 static void
1298 ppc_elf_rdata (xxx)
1299 int xxx;
1300 {
1301 char *save_line = input_line_pointer;
1302 static char section[] = ".rodata\n";
1303
1304 /* Just pretend this is .section .rodata */
1305 input_line_pointer = section;
1306 obj_elf_section (xxx);
1307
1308 input_line_pointer = save_line;
1309 }
1310
1311 /* Pseudo op to make file scope bss items */
1312 static void
1313 ppc_elf_lcomm(xxx)
1314 int xxx;
1315 {
1316 register char *name;
1317 register char c;
1318 register char *p;
1319 offsetT size;
1320 register symbolS *symbolP;
1321 offsetT align;
1322 segT old_sec;
1323 int old_subsec;
1324 char *pfrag;
1325 int align2;
1326
1327 name = input_line_pointer;
1328 c = get_symbol_end ();
1329
1330 /* just after name is now '\0' */
1331 p = input_line_pointer;
1332 *p = c;
1333 SKIP_WHITESPACE ();
1334 if (*input_line_pointer != ',')
1335 {
1336 as_bad (_("Expected comma after symbol-name: rest of line ignored."));
1337 ignore_rest_of_line ();
1338 return;
1339 }
1340
1341 input_line_pointer++; /* skip ',' */
1342 if ((size = get_absolute_expression ()) < 0)
1343 {
1344 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) size);
1345 ignore_rest_of_line ();
1346 return;
1347 }
1348
1349 /* The third argument to .lcomm is the alignment. */
1350 if (*input_line_pointer != ',')
1351 align = 8;
1352 else
1353 {
1354 ++input_line_pointer;
1355 align = get_absolute_expression ();
1356 if (align <= 0)
1357 {
1358 as_warn (_("ignoring bad alignment"));
1359 align = 8;
1360 }
1361 }
1362
1363 *p = 0;
1364 symbolP = symbol_find_or_make (name);
1365 *p = c;
1366
1367 if (S_IS_DEFINED (symbolP) && ! S_IS_COMMON (symbolP))
1368 {
1369 as_bad (_("Ignoring attempt to re-define symbol `%s'."),
1370 S_GET_NAME (symbolP));
1371 ignore_rest_of_line ();
1372 return;
1373 }
1374
1375 if (S_GET_VALUE (symbolP) && S_GET_VALUE (symbolP) != (valueT) size)
1376 {
1377 as_bad (_("Length of .lcomm \"%s\" is already %ld. Not changed to %ld."),
1378 S_GET_NAME (symbolP),
1379 (long) S_GET_VALUE (symbolP),
1380 (long) size);
1381
1382 ignore_rest_of_line ();
1383 return;
1384 }
1385
1386 /* allocate_bss: */
1387 old_sec = now_seg;
1388 old_subsec = now_subseg;
1389 if (align)
1390 {
1391 /* convert to a power of 2 alignment */
1392 for (align2 = 0; (align & 1) == 0; align >>= 1, ++align2);
1393 if (align != 1)
1394 {
1395 as_bad (_("Common alignment not a power of 2"));
1396 ignore_rest_of_line ();
1397 return;
1398 }
1399 }
1400 else
1401 align2 = 0;
1402
1403 record_alignment (bss_section, align2);
1404 subseg_set (bss_section, 0);
1405 if (align2)
1406 frag_align (align2, 0, 0);
1407 if (S_GET_SEGMENT (symbolP) == bss_section)
1408 symbol_get_frag (symbolP)->fr_symbol = 0;
1409 symbol_set_frag (symbolP, frag_now);
1410 pfrag = frag_var (rs_org, 1, 1, (relax_substateT) 0, symbolP, size,
1411 (char *) 0);
1412 *pfrag = 0;
1413 S_SET_SIZE (symbolP, size);
1414 S_SET_SEGMENT (symbolP, bss_section);
1415 subseg_set (old_sec, old_subsec);
1416 demand_empty_rest_of_line ();
1417 }
1418
1419 /* Validate any relocations emitted for -mrelocatable, possibly adding
1420 fixups for word relocations in writable segments, so we can adjust
1421 them at runtime. */
1422 static void
1423 ppc_elf_validate_fix (fixp, seg)
1424 fixS *fixp;
1425 segT seg;
1426 {
1427 if (fixp->fx_done || fixp->fx_pcrel)
1428 return;
1429
1430 switch (shlib)
1431 {
1432 case SHLIB_NONE:
1433 case SHLIB_PIC:
1434 return;
1435
1436 case SHILB_MRELOCATABLE:
1437 if (fixp->fx_r_type <= BFD_RELOC_UNUSED
1438 && fixp->fx_r_type != BFD_RELOC_16_GOTOFF
1439 && fixp->fx_r_type != BFD_RELOC_HI16_GOTOFF
1440 && fixp->fx_r_type != BFD_RELOC_LO16_GOTOFF
1441 && fixp->fx_r_type != BFD_RELOC_HI16_S_GOTOFF
1442 && fixp->fx_r_type != BFD_RELOC_32_BASEREL
1443 && fixp->fx_r_type != BFD_RELOC_LO16_BASEREL
1444 && fixp->fx_r_type != BFD_RELOC_HI16_BASEREL
1445 && fixp->fx_r_type != BFD_RELOC_HI16_S_BASEREL
1446 && strcmp (segment_name (seg), ".got2") != 0
1447 && strcmp (segment_name (seg), ".dtors") != 0
1448 && strcmp (segment_name (seg), ".ctors") != 0
1449 && strcmp (segment_name (seg), ".fixup") != 0
1450 && strcmp (segment_name (seg), ".stab") != 0
1451 && strcmp (segment_name (seg), ".gcc_except_table") != 0
1452 && strcmp (segment_name (seg), ".eh_frame") != 0
1453 && strcmp (segment_name (seg), ".ex_shared") != 0)
1454 {
1455 if ((seg->flags & (SEC_READONLY | SEC_CODE)) != 0
1456 || fixp->fx_r_type != BFD_RELOC_CTOR)
1457 {
1458 as_bad_where (fixp->fx_file, fixp->fx_line,
1459 _("Relocation cannot be done when using -mrelocatable"));
1460 }
1461 }
1462 return;
1463 }
1464 }
1465 #endif /* OBJ_ELF */
1466 \f
1467 #ifdef TE_PE
1468
1469 /*
1470 * Summary of parse_toc_entry().
1471 *
1472 * in: Input_line_pointer points to the '[' in one of:
1473 *
1474 * [toc] [tocv] [toc32] [toc64]
1475 *
1476 * Anything else is an error of one kind or another.
1477 *
1478 * out:
1479 * return value: success or failure
1480 * toc_kind: kind of toc reference
1481 * input_line_pointer:
1482 * success: first char after the ']'
1483 * failure: unchanged
1484 *
1485 * settings:
1486 *
1487 * [toc] - rv == success, toc_kind = default_toc
1488 * [tocv] - rv == success, toc_kind = data_in_toc
1489 * [toc32] - rv == success, toc_kind = must_be_32
1490 * [toc64] - rv == success, toc_kind = must_be_64
1491 *
1492 */
1493
1494 enum toc_size_qualifier
1495 {
1496 default_toc, /* The toc cell constructed should be the system default size */
1497 data_in_toc, /* This is a direct reference to a toc cell */
1498 must_be_32, /* The toc cell constructed must be 32 bits wide */
1499 must_be_64 /* The toc cell constructed must be 64 bits wide */
1500 };
1501
1502 static int
1503 parse_toc_entry(toc_kind)
1504 enum toc_size_qualifier *toc_kind;
1505 {
1506 char *start;
1507 char *toc_spec;
1508 char c;
1509 enum toc_size_qualifier t;
1510
1511 /* save the input_line_pointer */
1512 start = input_line_pointer;
1513
1514 /* skip over the '[' , and whitespace */
1515 ++input_line_pointer;
1516 SKIP_WHITESPACE ();
1517
1518 /* find the spelling of the operand */
1519 toc_spec = input_line_pointer;
1520 c = get_symbol_end ();
1521
1522 if (strcmp(toc_spec, "toc") == 0)
1523 {
1524 t = default_toc;
1525 }
1526 else if (strcmp(toc_spec, "tocv") == 0)
1527 {
1528 t = data_in_toc;
1529 }
1530 else if (strcmp(toc_spec, "toc32") == 0)
1531 {
1532 t = must_be_32;
1533 }
1534 else if (strcmp(toc_spec, "toc64") == 0)
1535 {
1536 t = must_be_64;
1537 }
1538 else
1539 {
1540 as_bad (_("syntax error: invalid toc specifier `%s'"), toc_spec);
1541 *input_line_pointer = c; /* put back the delimiting char */
1542 input_line_pointer = start; /* reset input_line pointer */
1543 return 0;
1544 }
1545
1546 /* now find the ']' */
1547 *input_line_pointer = c; /* put back the delimiting char */
1548
1549 SKIP_WHITESPACE (); /* leading whitespace could be there. */
1550 c = *input_line_pointer++; /* input_line_pointer->past char in c. */
1551
1552 if (c != ']')
1553 {
1554 as_bad (_("syntax error: expected `]', found `%c'"), c);
1555 input_line_pointer = start; /* reset input_line pointer */
1556 return 0;
1557 }
1558
1559 *toc_kind = t; /* set return value */
1560 return 1;
1561 }
1562 #endif
1563 \f
1564
1565 /* We need to keep a list of fixups. We can't simply generate them as
1566 we go, because that would require us to first create the frag, and
1567 that would screw up references to ``.''. */
1568
1569 struct ppc_fixup
1570 {
1571 expressionS exp;
1572 int opindex;
1573 bfd_reloc_code_real_type reloc;
1574 };
1575
1576 #define MAX_INSN_FIXUPS (5)
1577
1578 /* This routine is called for each instruction to be assembled. */
1579
1580 void
1581 md_assemble (str)
1582 char *str;
1583 {
1584 char *s;
1585 const struct powerpc_opcode *opcode;
1586 unsigned long insn;
1587 const unsigned char *opindex_ptr;
1588 int skip_optional;
1589 int need_paren;
1590 int next_opindex;
1591 struct ppc_fixup fixups[MAX_INSN_FIXUPS];
1592 int fc;
1593 char *f;
1594 int i;
1595 #ifdef OBJ_ELF
1596 bfd_reloc_code_real_type reloc;
1597 #endif
1598
1599 /* Get the opcode. */
1600 for (s = str; *s != '\0' && ! isspace (*s); s++)
1601 ;
1602 if (*s != '\0')
1603 *s++ = '\0';
1604
1605 /* Look up the opcode in the hash table. */
1606 opcode = (const struct powerpc_opcode *) hash_find (ppc_hash, str);
1607 if (opcode == (const struct powerpc_opcode *) NULL)
1608 {
1609 const struct powerpc_macro *macro;
1610
1611 macro = (const struct powerpc_macro *) hash_find (ppc_macro_hash, str);
1612 if (macro == (const struct powerpc_macro *) NULL)
1613 as_bad (_("Unrecognized opcode: `%s'"), str);
1614 else
1615 ppc_macro (s, macro);
1616
1617 return;
1618 }
1619
1620 insn = opcode->opcode;
1621
1622 str = s;
1623 while (isspace (*str))
1624 ++str;
1625
1626 /* PowerPC operands are just expressions. The only real issue is
1627 that a few operand types are optional. All cases which might use
1628 an optional operand separate the operands only with commas (in
1629 some cases parentheses are used, as in ``lwz 1,0(1)'' but such
1630 cases never have optional operands). There is never more than
1631 one optional operand for an instruction. So, before we start
1632 seriously parsing the operands, we check to see if we have an
1633 optional operand, and, if we do, we count the number of commas to
1634 see whether the operand should be omitted. */
1635 skip_optional = 0;
1636 for (opindex_ptr = opcode->operands; *opindex_ptr != 0; opindex_ptr++)
1637 {
1638 const struct powerpc_operand *operand;
1639
1640 operand = &powerpc_operands[*opindex_ptr];
1641 if ((operand->flags & PPC_OPERAND_OPTIONAL) != 0)
1642 {
1643 unsigned int opcount;
1644
1645 /* There is an optional operand. Count the number of
1646 commas in the input line. */
1647 if (*str == '\0')
1648 opcount = 0;
1649 else
1650 {
1651 opcount = 1;
1652 s = str;
1653 while ((s = strchr (s, ',')) != (char *) NULL)
1654 {
1655 ++opcount;
1656 ++s;
1657 }
1658 }
1659
1660 /* If there are fewer operands in the line then are called
1661 for by the instruction, we want to skip the optional
1662 operand. */
1663 if (opcount < strlen (opcode->operands))
1664 skip_optional = 1;
1665
1666 break;
1667 }
1668 }
1669
1670 /* Gather the operands. */
1671 need_paren = 0;
1672 next_opindex = 0;
1673 fc = 0;
1674 for (opindex_ptr = opcode->operands; *opindex_ptr != 0; opindex_ptr++)
1675 {
1676 const struct powerpc_operand *operand;
1677 const char *errmsg;
1678 char *hold;
1679 expressionS ex;
1680 char endc;
1681
1682 if (next_opindex == 0)
1683 operand = &powerpc_operands[*opindex_ptr];
1684 else
1685 {
1686 operand = &powerpc_operands[next_opindex];
1687 next_opindex = 0;
1688 }
1689
1690 errmsg = NULL;
1691
1692 /* If this is a fake operand, then we do not expect anything
1693 from the input. */
1694 if ((operand->flags & PPC_OPERAND_FAKE) != 0)
1695 {
1696 insn = (*operand->insert) (insn, 0L, &errmsg);
1697 if (errmsg != (const char *) NULL)
1698 as_bad (errmsg);
1699 continue;
1700 }
1701
1702 /* If this is an optional operand, and we are skipping it, just
1703 insert a zero. */
1704 if ((operand->flags & PPC_OPERAND_OPTIONAL) != 0
1705 && skip_optional)
1706 {
1707 if (operand->insert)
1708 {
1709 insn = (*operand->insert) (insn, 0L, &errmsg);
1710 if (errmsg != (const char *) NULL)
1711 as_bad (errmsg);
1712 }
1713 if ((operand->flags & PPC_OPERAND_NEXT) != 0)
1714 next_opindex = *opindex_ptr + 1;
1715 continue;
1716 }
1717
1718 /* Gather the operand. */
1719 hold = input_line_pointer;
1720 input_line_pointer = str;
1721
1722 #ifdef TE_PE
1723 if (*input_line_pointer == '[')
1724 {
1725 /* We are expecting something like the second argument here:
1726
1727 lwz r4,[toc].GS.0.static_int(rtoc)
1728 ^^^^^^^^^^^^^^^^^^^^^^^^^^^
1729 The argument following the `]' must be a symbol name, and the
1730 register must be the toc register: 'rtoc' or '2'
1731
1732 The effect is to 0 as the displacement field
1733 in the instruction, and issue an IMAGE_REL_PPC_TOCREL16 (or
1734 the appropriate variation) reloc against it based on the symbol.
1735 The linker will build the toc, and insert the resolved toc offset.
1736
1737 Note:
1738 o The size of the toc entry is currently assumed to be
1739 32 bits. This should not be assumed to be a hard coded
1740 number.
1741 o In an effort to cope with a change from 32 to 64 bits,
1742 there are also toc entries that are specified to be
1743 either 32 or 64 bits:
1744 lwz r4,[toc32].GS.0.static_int(rtoc)
1745 lwz r4,[toc64].GS.0.static_int(rtoc)
1746 These demand toc entries of the specified size, and the
1747 instruction probably requires it.
1748 */
1749
1750 int valid_toc;
1751 enum toc_size_qualifier toc_kind;
1752 bfd_reloc_code_real_type toc_reloc;
1753
1754 /* go parse off the [tocXX] part */
1755 valid_toc = parse_toc_entry(&toc_kind);
1756
1757 if (!valid_toc)
1758 {
1759 /* Note: message has already been issued. */
1760 /* FIXME: what sort of recovery should we do? */
1761 /* demand_rest_of_line(); return; ? */
1762 }
1763
1764 /* Now get the symbol following the ']' */
1765 expression(&ex);
1766
1767 switch (toc_kind)
1768 {
1769 case default_toc:
1770 /* In this case, we may not have seen the symbol yet, since */
1771 /* it is allowed to appear on a .extern or .globl or just be */
1772 /* a label in the .data section. */
1773 toc_reloc = BFD_RELOC_PPC_TOC16;
1774 break;
1775 case data_in_toc:
1776 /* 1. The symbol must be defined and either in the toc */
1777 /* section, or a global. */
1778 /* 2. The reloc generated must have the TOCDEFN flag set in */
1779 /* upper bit mess of the reloc type. */
1780 /* FIXME: It's a little confusing what the tocv qualifier can */
1781 /* be used for. At the very least, I've seen three */
1782 /* uses, only one of which I'm sure I can explain. */
1783 if (ex.X_op == O_symbol)
1784 {
1785 assert (ex.X_add_symbol != NULL);
1786 if (symbol_get_bfdsym (ex.X_add_symbol)->section
1787 != tocdata_section)
1788 {
1789 as_bad(_("[tocv] symbol is not a toc symbol"));
1790 }
1791 }
1792
1793 toc_reloc = BFD_RELOC_PPC_TOC16;
1794 break;
1795 case must_be_32:
1796 /* FIXME: these next two specifically specify 32/64 bit toc */
1797 /* entries. We don't support them today. Is this the */
1798 /* right way to say that? */
1799 toc_reloc = BFD_RELOC_UNUSED;
1800 as_bad (_("Unimplemented toc32 expression modifier"));
1801 break;
1802 case must_be_64:
1803 /* FIXME: see above */
1804 toc_reloc = BFD_RELOC_UNUSED;
1805 as_bad (_("Unimplemented toc64 expression modifier"));
1806 break;
1807 default:
1808 fprintf(stderr,
1809 _("Unexpected return value [%d] from parse_toc_entry!\n"),
1810 toc_kind);
1811 abort();
1812 break;
1813 }
1814
1815 /* We need to generate a fixup for this expression. */
1816 if (fc >= MAX_INSN_FIXUPS)
1817 as_fatal (_("too many fixups"));
1818
1819 fixups[fc].reloc = toc_reloc;
1820 fixups[fc].exp = ex;
1821 fixups[fc].opindex = *opindex_ptr;
1822 ++fc;
1823
1824 /* Ok. We've set up the fixup for the instruction. Now make it
1825 look like the constant 0 was found here */
1826 ex.X_unsigned = 1;
1827 ex.X_op = O_constant;
1828 ex.X_add_number = 0;
1829 ex.X_add_symbol = NULL;
1830 ex.X_op_symbol = NULL;
1831 }
1832
1833 else
1834 #endif /* TE_PE */
1835 {
1836 if (! register_name (&ex))
1837 {
1838 if ((operand->flags & PPC_OPERAND_CR) != 0)
1839 cr_operand = true;
1840 expression (&ex);
1841 cr_operand = false;
1842 }
1843 }
1844
1845 str = input_line_pointer;
1846 input_line_pointer = hold;
1847
1848 if (ex.X_op == O_illegal)
1849 as_bad (_("illegal operand"));
1850 else if (ex.X_op == O_absent)
1851 as_bad (_("missing operand"));
1852 else if (ex.X_op == O_register)
1853 {
1854 insn = ppc_insert_operand (insn, operand, ex.X_add_number,
1855 (char *) NULL, 0);
1856 }
1857 else if (ex.X_op == O_constant)
1858 {
1859 #ifdef OBJ_ELF
1860 /* Allow @HA, @L, @H on constants. */
1861 char *orig_str = str;
1862
1863 if ((reloc = ppc_elf_suffix (&str, &ex)) != BFD_RELOC_UNUSED)
1864 switch (reloc)
1865 {
1866 default:
1867 str = orig_str;
1868 break;
1869
1870 case BFD_RELOC_LO16:
1871 /* X_unsigned is the default, so if the user has done
1872 something which cleared it, we always produce a
1873 signed value. */
1874 if (ex.X_unsigned
1875 && (operand->flags & PPC_OPERAND_SIGNED) == 0)
1876 ex.X_add_number &= 0xffff;
1877 else
1878 ex.X_add_number = (((ex.X_add_number & 0xffff)
1879 ^ 0x8000)
1880 - 0x8000);
1881 break;
1882
1883 case BFD_RELOC_HI16:
1884 ex.X_add_number = (ex.X_add_number >> 16) & 0xffff;
1885 break;
1886
1887 case BFD_RELOC_HI16_S:
1888 ex.X_add_number = (((ex.X_add_number >> 16) & 0xffff)
1889 + ((ex.X_add_number >> 15) & 1));
1890 break;
1891 }
1892 #endif
1893 insn = ppc_insert_operand (insn, operand, ex.X_add_number,
1894 (char *) NULL, 0);
1895 }
1896 #ifdef OBJ_ELF
1897 else if ((reloc = ppc_elf_suffix (&str, &ex)) != BFD_RELOC_UNUSED)
1898 {
1899 /* For the absoulte forms of branchs, convert the PC relative form back into
1900 the absolute. */
1901 if ((operand->flags & PPC_OPERAND_ABSOLUTE) != 0)
1902 {
1903 switch (reloc)
1904 {
1905 case BFD_RELOC_PPC_B26:
1906 reloc = BFD_RELOC_PPC_BA26;
1907 break;
1908 case BFD_RELOC_PPC_B16:
1909 reloc = BFD_RELOC_PPC_BA16;
1910 break;
1911 case BFD_RELOC_PPC_B16_BRTAKEN:
1912 reloc = BFD_RELOC_PPC_BA16_BRTAKEN;
1913 break;
1914 case BFD_RELOC_PPC_B16_BRNTAKEN:
1915 reloc = BFD_RELOC_PPC_BA16_BRNTAKEN;
1916 break;
1917 default:
1918 break;
1919 }
1920 }
1921
1922 /* We need to generate a fixup for this expression. */
1923 if (fc >= MAX_INSN_FIXUPS)
1924 as_fatal (_("too many fixups"));
1925 fixups[fc].exp = ex;
1926 fixups[fc].opindex = 0;
1927 fixups[fc].reloc = reloc;
1928 ++fc;
1929 }
1930 #endif /* OBJ_ELF */
1931
1932 else
1933 {
1934 /* We need to generate a fixup for this expression. */
1935 if (fc >= MAX_INSN_FIXUPS)
1936 as_fatal (_("too many fixups"));
1937 fixups[fc].exp = ex;
1938 fixups[fc].opindex = *opindex_ptr;
1939 fixups[fc].reloc = BFD_RELOC_UNUSED;
1940 ++fc;
1941 }
1942
1943 if (need_paren)
1944 {
1945 endc = ')';
1946 need_paren = 0;
1947 }
1948 else if ((operand->flags & PPC_OPERAND_PARENS) != 0)
1949 {
1950 endc = '(';
1951 need_paren = 1;
1952 }
1953 else
1954 endc = ',';
1955
1956 /* The call to expression should have advanced str past any
1957 whitespace. */
1958 if (*str != endc
1959 && (endc != ',' || *str != '\0'))
1960 {
1961 as_bad (_("syntax error; found `%c' but expected `%c'"), *str, endc);
1962 break;
1963 }
1964
1965 if (*str != '\0')
1966 ++str;
1967 }
1968
1969 while (isspace (*str))
1970 ++str;
1971
1972 if (*str != '\0')
1973 as_bad (_("junk at end of line: `%s'"), str);
1974
1975 /* Write out the instruction. */
1976 f = frag_more (4);
1977 md_number_to_chars (f, insn, 4);
1978
1979 /* Create any fixups. At this point we do not use a
1980 bfd_reloc_code_real_type, but instead just use the
1981 BFD_RELOC_UNUSED plus the operand index. This lets us easily
1982 handle fixups for any operand type, although that is admittedly
1983 not a very exciting feature. We pick a BFD reloc type in
1984 md_apply_fix. */
1985 for (i = 0; i < fc; i++)
1986 {
1987 const struct powerpc_operand *operand;
1988
1989 operand = &powerpc_operands[fixups[i].opindex];
1990 if (fixups[i].reloc != BFD_RELOC_UNUSED)
1991 {
1992 reloc_howto_type *reloc_howto = bfd_reloc_type_lookup (stdoutput, fixups[i].reloc);
1993 int size;
1994 int offset;
1995 fixS *fixP;
1996
1997 if (!reloc_howto)
1998 abort ();
1999
2000 size = bfd_get_reloc_size (reloc_howto);
2001 offset = target_big_endian ? (4 - size) : 0;
2002
2003 if (size < 1 || size > 4)
2004 abort();
2005
2006 fixP = fix_new_exp (frag_now, f - frag_now->fr_literal + offset, size,
2007 &fixups[i].exp, reloc_howto->pc_relative,
2008 fixups[i].reloc);
2009
2010 /* Turn off complaints that the addend is too large for things like
2011 foo+100000@ha. */
2012 switch (fixups[i].reloc)
2013 {
2014 case BFD_RELOC_16_GOTOFF:
2015 case BFD_RELOC_PPC_TOC16:
2016 case BFD_RELOC_LO16:
2017 case BFD_RELOC_HI16:
2018 case BFD_RELOC_HI16_S:
2019 fixP->fx_no_overflow = 1;
2020 break;
2021 default:
2022 break;
2023 }
2024 }
2025 else
2026 fix_new_exp (frag_now, f - frag_now->fr_literal, 4,
2027 &fixups[i].exp,
2028 (operand->flags & PPC_OPERAND_RELATIVE) != 0,
2029 ((bfd_reloc_code_real_type)
2030 (fixups[i].opindex + (int) BFD_RELOC_UNUSED)));
2031 }
2032 }
2033
2034 /* Handle a macro. Gather all the operands, transform them as
2035 described by the macro, and call md_assemble recursively. All the
2036 operands are separated by commas; we don't accept parentheses
2037 around operands here. */
2038
2039 static void
2040 ppc_macro (str, macro)
2041 char *str;
2042 const struct powerpc_macro *macro;
2043 {
2044 char *operands[10];
2045 unsigned int count;
2046 char *s;
2047 unsigned int len;
2048 const char *format;
2049 int arg;
2050 char *send;
2051 char *complete;
2052
2053 /* Gather the users operands into the operands array. */
2054 count = 0;
2055 s = str;
2056 while (1)
2057 {
2058 if (count >= sizeof operands / sizeof operands[0])
2059 break;
2060 operands[count++] = s;
2061 s = strchr (s, ',');
2062 if (s == (char *) NULL)
2063 break;
2064 *s++ = '\0';
2065 }
2066
2067 if (count != macro->operands)
2068 {
2069 as_bad (_("wrong number of operands"));
2070 return;
2071 }
2072
2073 /* Work out how large the string must be (the size is unbounded
2074 because it includes user input). */
2075 len = 0;
2076 format = macro->format;
2077 while (*format != '\0')
2078 {
2079 if (*format != '%')
2080 {
2081 ++len;
2082 ++format;
2083 }
2084 else
2085 {
2086 arg = strtol (format + 1, &send, 10);
2087 know (send != format && arg >= 0 && arg < count);
2088 len += strlen (operands[arg]);
2089 format = send;
2090 }
2091 }
2092
2093 /* Put the string together. */
2094 complete = s = (char *) alloca (len + 1);
2095 format = macro->format;
2096 while (*format != '\0')
2097 {
2098 if (*format != '%')
2099 *s++ = *format++;
2100 else
2101 {
2102 arg = strtol (format + 1, &send, 10);
2103 strcpy (s, operands[arg]);
2104 s += strlen (s);
2105 format = send;
2106 }
2107 }
2108 *s = '\0';
2109
2110 /* Assemble the constructed instruction. */
2111 md_assemble (complete);
2112 }
2113 \f
2114 #ifdef OBJ_ELF
2115 /* For ELF, add support for SHF_EXCLUDE and SHT_ORDERED */
2116
2117 int
2118 ppc_section_letter (letter, ptr_msg)
2119 int letter;
2120 char **ptr_msg;
2121 {
2122 if (letter == 'e')
2123 return SHF_EXCLUDE;
2124
2125 *ptr_msg = _("Bad .section directive: want a,w,x,e in string");
2126 return 0;
2127 }
2128
2129 int
2130 ppc_section_word (str, len)
2131 char *str;
2132 size_t len;
2133 {
2134 if (len == 7 && strncmp (str, "exclude", 7) == 0)
2135 return SHF_EXCLUDE;
2136
2137 return -1;
2138 }
2139
2140 int
2141 ppc_section_type (str, len)
2142 char *str;
2143 size_t len;
2144 {
2145 if (len == 7 && strncmp (str, "ordered", 7) == 0)
2146 return SHT_ORDERED;
2147
2148 return -1;
2149 }
2150
2151 int
2152 ppc_section_flags (flags, attr, type)
2153 int flags;
2154 int attr;
2155 int type;
2156 {
2157 if (type == SHT_ORDERED)
2158 flags |= SEC_ALLOC | SEC_LOAD | SEC_SORT_ENTRIES;
2159
2160 if (attr & SHF_EXCLUDE)
2161 flags |= SEC_EXCLUDE;
2162
2163 return flags;
2164 }
2165 #endif /* OBJ_ELF */
2166
2167 \f
2168 /* Pseudo-op handling. */
2169
2170 /* The .byte pseudo-op. This is similar to the normal .byte
2171 pseudo-op, but it can also take a single ASCII string. */
2172
2173 static void
2174 ppc_byte (ignore)
2175 int ignore;
2176 {
2177 if (*input_line_pointer != '\"')
2178 {
2179 cons (1);
2180 return;
2181 }
2182
2183 /* Gather characters. A real double quote is doubled. Unusual
2184 characters are not permitted. */
2185 ++input_line_pointer;
2186 while (1)
2187 {
2188 char c;
2189
2190 c = *input_line_pointer++;
2191
2192 if (c == '\"')
2193 {
2194 if (*input_line_pointer != '\"')
2195 break;
2196 ++input_line_pointer;
2197 }
2198
2199 FRAG_APPEND_1_CHAR (c);
2200 }
2201
2202 demand_empty_rest_of_line ();
2203 }
2204 \f
2205 #ifdef OBJ_XCOFF
2206
2207 /* XCOFF specific pseudo-op handling. */
2208
2209 /* This is set if we are creating a .stabx symbol, since we don't want
2210 to handle symbol suffixes for such symbols. */
2211 static boolean ppc_stab_symbol;
2212
2213 /* The .comm and .lcomm pseudo-ops for XCOFF. XCOFF puts common
2214 symbols in the .bss segment as though they were local common
2215 symbols, and uses a different smclas. */
2216
2217 static void
2218 ppc_comm (lcomm)
2219 int lcomm;
2220 {
2221 asection *current_seg = now_seg;
2222 subsegT current_subseg = now_subseg;
2223 char *name;
2224 char endc;
2225 char *end_name;
2226 offsetT size;
2227 offsetT align;
2228 symbolS *lcomm_sym = NULL;
2229 symbolS *sym;
2230 char *pfrag;
2231
2232 name = input_line_pointer;
2233 endc = get_symbol_end ();
2234 end_name = input_line_pointer;
2235 *end_name = endc;
2236
2237 if (*input_line_pointer != ',')
2238 {
2239 as_bad (_("missing size"));
2240 ignore_rest_of_line ();
2241 return;
2242 }
2243 ++input_line_pointer;
2244
2245 size = get_absolute_expression ();
2246 if (size < 0)
2247 {
2248 as_bad (_("negative size"));
2249 ignore_rest_of_line ();
2250 return;
2251 }
2252
2253 if (! lcomm)
2254 {
2255 /* The third argument to .comm is the alignment. */
2256 if (*input_line_pointer != ',')
2257 align = 3;
2258 else
2259 {
2260 ++input_line_pointer;
2261 align = get_absolute_expression ();
2262 if (align <= 0)
2263 {
2264 as_warn (_("ignoring bad alignment"));
2265 align = 3;
2266 }
2267 }
2268 }
2269 else
2270 {
2271 char *lcomm_name;
2272 char lcomm_endc;
2273
2274 if (size <= 1)
2275 align = 0;
2276 else if (size <= 2)
2277 align = 1;
2278 else if (size <= 4)
2279 align = 2;
2280 else
2281 align = 3;
2282
2283 /* The third argument to .lcomm appears to be the real local
2284 common symbol to create. References to the symbol named in
2285 the first argument are turned into references to the third
2286 argument. */
2287 if (*input_line_pointer != ',')
2288 {
2289 as_bad (_("missing real symbol name"));
2290 ignore_rest_of_line ();
2291 return;
2292 }
2293 ++input_line_pointer;
2294
2295 lcomm_name = input_line_pointer;
2296 lcomm_endc = get_symbol_end ();
2297
2298 lcomm_sym = symbol_find_or_make (lcomm_name);
2299
2300 *input_line_pointer = lcomm_endc;
2301 }
2302
2303 *end_name = '\0';
2304 sym = symbol_find_or_make (name);
2305 *end_name = endc;
2306
2307 if (S_IS_DEFINED (sym)
2308 || S_GET_VALUE (sym) != 0)
2309 {
2310 as_bad (_("attempt to redefine symbol"));
2311 ignore_rest_of_line ();
2312 return;
2313 }
2314
2315 record_alignment (bss_section, align);
2316
2317 if (! lcomm
2318 || ! S_IS_DEFINED (lcomm_sym))
2319 {
2320 symbolS *def_sym;
2321 offsetT def_size;
2322
2323 if (! lcomm)
2324 {
2325 def_sym = sym;
2326 def_size = size;
2327 S_SET_EXTERNAL (sym);
2328 }
2329 else
2330 {
2331 symbol_get_tc (lcomm_sym)->output = 1;
2332 def_sym = lcomm_sym;
2333 def_size = 0;
2334 }
2335
2336 subseg_set (bss_section, 1);
2337 frag_align (align, 0, 0);
2338
2339 symbol_set_frag (def_sym, frag_now);
2340 pfrag = frag_var (rs_org, 1, 1, (relax_substateT) 0, def_sym,
2341 def_size, (char *) NULL);
2342 *pfrag = 0;
2343 S_SET_SEGMENT (def_sym, bss_section);
2344 symbol_get_tc (def_sym)->align = align;
2345 }
2346 else if (lcomm)
2347 {
2348 /* Align the size of lcomm_sym. */
2349 symbol_get_frag (lcomm_sym)->fr_offset =
2350 ((symbol_get_frag (lcomm_sym)->fr_offset + (1 << align) - 1)
2351 &~ ((1 << align) - 1));
2352 if (align > symbol_get_tc (lcomm_sym)->align)
2353 symbol_get_tc (lcomm_sym)->align = align;
2354 }
2355
2356 if (lcomm)
2357 {
2358 /* Make sym an offset from lcomm_sym. */
2359 S_SET_SEGMENT (sym, bss_section);
2360 symbol_set_frag (sym, symbol_get_frag (lcomm_sym));
2361 S_SET_VALUE (sym, symbol_get_frag (lcomm_sym)->fr_offset);
2362 symbol_get_frag (lcomm_sym)->fr_offset += size;
2363 }
2364
2365 subseg_set (current_seg, current_subseg);
2366
2367 demand_empty_rest_of_line ();
2368 }
2369
2370 /* The .csect pseudo-op. This switches us into a different
2371 subsegment. The first argument is a symbol whose value is the
2372 start of the .csect. In COFF, csect symbols get special aux
2373 entries defined by the x_csect field of union internal_auxent. The
2374 optional second argument is the alignment (the default is 2). */
2375
2376 static void
2377 ppc_csect (ignore)
2378 int ignore;
2379 {
2380 char *name;
2381 char endc;
2382 symbolS *sym;
2383
2384 name = input_line_pointer;
2385 endc = get_symbol_end ();
2386
2387 sym = symbol_find_or_make (name);
2388
2389 *input_line_pointer = endc;
2390
2391 if (S_GET_NAME (sym)[0] == '\0')
2392 {
2393 /* An unnamed csect is assumed to be [PR]. */
2394 symbol_get_tc (sym)->class = XMC_PR;
2395 }
2396
2397 ppc_change_csect (sym);
2398
2399 if (*input_line_pointer == ',')
2400 {
2401 ++input_line_pointer;
2402 symbol_get_tc (sym)->align = get_absolute_expression ();
2403 }
2404
2405 demand_empty_rest_of_line ();
2406 }
2407
2408 /* Change to a different csect. */
2409
2410 static void
2411 ppc_change_csect (sym)
2412 symbolS *sym;
2413 {
2414 if (S_IS_DEFINED (sym))
2415 subseg_set (S_GET_SEGMENT (sym), symbol_get_tc (sym)->subseg);
2416 else
2417 {
2418 symbolS **list_ptr;
2419 int after_toc;
2420 int hold_chunksize;
2421 symbolS *list;
2422
2423 /* This is a new csect. We need to look at the symbol class to
2424 figure out whether it should go in the text section or the
2425 data section. */
2426 after_toc = 0;
2427 switch (symbol_get_tc (sym)->class)
2428 {
2429 case XMC_PR:
2430 case XMC_RO:
2431 case XMC_DB:
2432 case XMC_GL:
2433 case XMC_XO:
2434 case XMC_SV:
2435 case XMC_TI:
2436 case XMC_TB:
2437 S_SET_SEGMENT (sym, text_section);
2438 symbol_get_tc (sym)->subseg = ppc_text_subsegment;
2439 ++ppc_text_subsegment;
2440 list_ptr = &ppc_text_csects;
2441 break;
2442 case XMC_RW:
2443 case XMC_TC0:
2444 case XMC_TC:
2445 case XMC_DS:
2446 case XMC_UA:
2447 case XMC_BS:
2448 case XMC_UC:
2449 if (ppc_toc_csect != NULL
2450 && (symbol_get_tc (ppc_toc_csect)->subseg + 1
2451 == ppc_data_subsegment))
2452 after_toc = 1;
2453 S_SET_SEGMENT (sym, data_section);
2454 symbol_get_tc (sym)->subseg = ppc_data_subsegment;
2455 ++ppc_data_subsegment;
2456 list_ptr = &ppc_data_csects;
2457 break;
2458 default:
2459 abort ();
2460 }
2461
2462 /* We set the obstack chunk size to a small value before
2463 changing subsegments, so that we don't use a lot of memory
2464 space for what may be a small section. */
2465 hold_chunksize = chunksize;
2466 chunksize = 64;
2467
2468 subseg_new (segment_name (S_GET_SEGMENT (sym)),
2469 symbol_get_tc (sym)->subseg);
2470
2471 chunksize = hold_chunksize;
2472
2473 if (after_toc)
2474 ppc_after_toc_frag = frag_now;
2475
2476 symbol_set_frag (sym, frag_now);
2477 S_SET_VALUE (sym, (valueT) frag_now_fix ());
2478
2479 symbol_get_tc (sym)->align = 2;
2480 symbol_get_tc (sym)->output = 1;
2481 symbol_get_tc (sym)->within = sym;
2482
2483 for (list = *list_ptr;
2484 symbol_get_tc (list)->next != (symbolS *) NULL;
2485 list = symbol_get_tc (list)->next)
2486 ;
2487 symbol_get_tc (list)->next = sym;
2488
2489 symbol_remove (sym, &symbol_rootP, &symbol_lastP);
2490 symbol_append (sym, symbol_get_tc (list)->within, &symbol_rootP,
2491 &symbol_lastP);
2492 }
2493
2494 ppc_current_csect = sym;
2495 }
2496
2497 /* This function handles the .text and .data pseudo-ops. These
2498 pseudo-ops aren't really used by XCOFF; we implement them for the
2499 convenience of people who aren't used to XCOFF. */
2500
2501 static void
2502 ppc_section (type)
2503 int type;
2504 {
2505 const char *name;
2506 symbolS *sym;
2507
2508 if (type == 't')
2509 name = ".text[PR]";
2510 else if (type == 'd')
2511 name = ".data[RW]";
2512 else
2513 abort ();
2514
2515 sym = symbol_find_or_make (name);
2516
2517 ppc_change_csect (sym);
2518
2519 demand_empty_rest_of_line ();
2520 }
2521
2522 /* This function handles the .section pseudo-op. This is mostly to
2523 give an error, since XCOFF only supports .text, .data and .bss, but
2524 we do permit the user to name the text or data section. */
2525
2526 static void
2527 ppc_named_section (ignore)
2528 int ignore;
2529 {
2530 char *user_name;
2531 const char *real_name;
2532 char c;
2533 symbolS *sym;
2534
2535 user_name = input_line_pointer;
2536 c = get_symbol_end ();
2537
2538 if (strcmp (user_name, ".text") == 0)
2539 real_name = ".text[PR]";
2540 else if (strcmp (user_name, ".data") == 0)
2541 real_name = ".data[RW]";
2542 else
2543 {
2544 as_bad (_("The XCOFF file format does not support arbitrary sections"));
2545 *input_line_pointer = c;
2546 ignore_rest_of_line ();
2547 return;
2548 }
2549
2550 *input_line_pointer = c;
2551
2552 sym = symbol_find_or_make (real_name);
2553
2554 ppc_change_csect (sym);
2555
2556 demand_empty_rest_of_line ();
2557 }
2558
2559 /* The .extern pseudo-op. We create an undefined symbol. */
2560
2561 static void
2562 ppc_extern (ignore)
2563 int ignore;
2564 {
2565 char *name;
2566 char endc;
2567
2568 name = input_line_pointer;
2569 endc = get_symbol_end ();
2570
2571 (void) symbol_find_or_make (name);
2572
2573 *input_line_pointer = endc;
2574
2575 demand_empty_rest_of_line ();
2576 }
2577
2578 /* The .lglobl pseudo-op. Keep the symbol in the symbol table. */
2579
2580 static void
2581 ppc_lglobl (ignore)
2582 int ignore;
2583 {
2584 char *name;
2585 char endc;
2586 symbolS *sym;
2587
2588 name = input_line_pointer;
2589 endc = get_symbol_end ();
2590
2591 sym = symbol_find_or_make (name);
2592
2593 *input_line_pointer = endc;
2594
2595 symbol_get_tc (sym)->output = 1;
2596
2597 demand_empty_rest_of_line ();
2598 }
2599
2600 /* The .rename pseudo-op. The RS/6000 assembler can rename symbols,
2601 although I don't know why it bothers. */
2602
2603 static void
2604 ppc_rename (ignore)
2605 int ignore;
2606 {
2607 char *name;
2608 char endc;
2609 symbolS *sym;
2610 int len;
2611
2612 name = input_line_pointer;
2613 endc = get_symbol_end ();
2614
2615 sym = symbol_find_or_make (name);
2616
2617 *input_line_pointer = endc;
2618
2619 if (*input_line_pointer != ',')
2620 {
2621 as_bad (_("missing rename string"));
2622 ignore_rest_of_line ();
2623 return;
2624 }
2625 ++input_line_pointer;
2626
2627 symbol_get_tc (sym)->real_name = demand_copy_C_string (&len);
2628
2629 demand_empty_rest_of_line ();
2630 }
2631
2632 /* The .stabx pseudo-op. This is similar to a normal .stabs
2633 pseudo-op, but slightly different. A sample is
2634 .stabx "main:F-1",.main,142,0
2635 The first argument is the symbol name to create. The second is the
2636 value, and the third is the storage class. The fourth seems to be
2637 always zero, and I am assuming it is the type. */
2638
2639 static void
2640 ppc_stabx (ignore)
2641 int ignore;
2642 {
2643 char *name;
2644 int len;
2645 symbolS *sym;
2646 expressionS exp;
2647
2648 name = demand_copy_C_string (&len);
2649
2650 if (*input_line_pointer != ',')
2651 {
2652 as_bad (_("missing value"));
2653 return;
2654 }
2655 ++input_line_pointer;
2656
2657 ppc_stab_symbol = true;
2658 sym = symbol_make (name);
2659 ppc_stab_symbol = false;
2660
2661 symbol_get_tc (sym)->real_name = name;
2662
2663 (void) expression (&exp);
2664
2665 switch (exp.X_op)
2666 {
2667 case O_illegal:
2668 case O_absent:
2669 case O_big:
2670 as_bad (_("illegal .stabx expression; zero assumed"));
2671 exp.X_add_number = 0;
2672 /* Fall through. */
2673 case O_constant:
2674 S_SET_VALUE (sym, (valueT) exp.X_add_number);
2675 symbol_set_frag (sym, &zero_address_frag);
2676 break;
2677
2678 case O_symbol:
2679 if (S_GET_SEGMENT (exp.X_add_symbol) == undefined_section)
2680 symbol_set_value_expression (sym, &exp);
2681 else
2682 {
2683 S_SET_VALUE (sym,
2684 exp.X_add_number + S_GET_VALUE (exp.X_add_symbol));
2685 symbol_set_frag (sym, symbol_get_frag (exp.X_add_symbol));
2686 }
2687 break;
2688
2689 default:
2690 /* The value is some complex expression. This will probably
2691 fail at some later point, but this is probably the right
2692 thing to do here. */
2693 symbol_set_value_expression (sym, &exp);
2694 break;
2695 }
2696
2697 S_SET_SEGMENT (sym, ppc_coff_debug_section);
2698 symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
2699
2700 if (*input_line_pointer != ',')
2701 {
2702 as_bad (_("missing class"));
2703 return;
2704 }
2705 ++input_line_pointer;
2706
2707 S_SET_STORAGE_CLASS (sym, get_absolute_expression ());
2708
2709 if (*input_line_pointer != ',')
2710 {
2711 as_bad (_("missing type"));
2712 return;
2713 }
2714 ++input_line_pointer;
2715
2716 S_SET_DATA_TYPE (sym, get_absolute_expression ());
2717
2718 symbol_get_tc (sym)->output = 1;
2719
2720 if (S_GET_STORAGE_CLASS (sym) == C_STSYM)
2721 symbol_get_tc (sym)->within = ppc_current_block;
2722
2723 if (exp.X_op != O_symbol
2724 || ! S_IS_EXTERNAL (exp.X_add_symbol)
2725 || S_GET_SEGMENT (exp.X_add_symbol) != bss_section)
2726 ppc_frob_label (sym);
2727 else
2728 {
2729 symbol_remove (sym, &symbol_rootP, &symbol_lastP);
2730 symbol_append (sym, exp.X_add_symbol, &symbol_rootP, &symbol_lastP);
2731 if (symbol_get_tc (ppc_current_csect)->within == exp.X_add_symbol)
2732 symbol_get_tc (ppc_current_csect)->within = sym;
2733 }
2734
2735 demand_empty_rest_of_line ();
2736 }
2737
2738 /* The .function pseudo-op. This takes several arguments. The first
2739 argument seems to be the external name of the symbol. The second
2740 argment seems to be the label for the start of the function. gcc
2741 uses the same name for both. I have no idea what the third and
2742 fourth arguments are meant to be. The optional fifth argument is
2743 an expression for the size of the function. In COFF this symbol
2744 gets an aux entry like that used for a csect. */
2745
2746 static void
2747 ppc_function (ignore)
2748 int ignore;
2749 {
2750 char *name;
2751 char endc;
2752 char *s;
2753 symbolS *ext_sym;
2754 symbolS *lab_sym;
2755
2756 name = input_line_pointer;
2757 endc = get_symbol_end ();
2758
2759 /* Ignore any [PR] suffix. */
2760 name = ppc_canonicalize_symbol_name (name);
2761 s = strchr (name, '[');
2762 if (s != (char *) NULL
2763 && strcmp (s + 1, "PR]") == 0)
2764 *s = '\0';
2765
2766 ext_sym = symbol_find_or_make (name);
2767
2768 *input_line_pointer = endc;
2769
2770 if (*input_line_pointer != ',')
2771 {
2772 as_bad (_("missing symbol name"));
2773 ignore_rest_of_line ();
2774 return;
2775 }
2776 ++input_line_pointer;
2777
2778 name = input_line_pointer;
2779 endc = get_symbol_end ();
2780
2781 lab_sym = symbol_find_or_make (name);
2782
2783 *input_line_pointer = endc;
2784
2785 if (ext_sym != lab_sym)
2786 {
2787 expressionS exp;
2788
2789 exp.X_op = O_symbol;
2790 exp.X_add_symbol = lab_sym;
2791 exp.X_op_symbol = NULL;
2792 exp.X_add_number = 0;
2793 exp.X_unsigned = 0;
2794 symbol_set_value_expression (ext_sym, &exp);
2795 }
2796
2797 if (symbol_get_tc (ext_sym)->class == -1)
2798 symbol_get_tc (ext_sym)->class = XMC_PR;
2799 symbol_get_tc (ext_sym)->output = 1;
2800
2801 if (*input_line_pointer == ',')
2802 {
2803 expressionS ignore;
2804
2805 /* Ignore the third argument. */
2806 ++input_line_pointer;
2807 expression (&ignore);
2808 if (*input_line_pointer == ',')
2809 {
2810 /* Ignore the fourth argument. */
2811 ++input_line_pointer;
2812 expression (&ignore);
2813 if (*input_line_pointer == ',')
2814 {
2815 /* The fifth argument is the function size. */
2816 ++input_line_pointer;
2817 symbol_get_tc (ext_sym)->size = symbol_new ("L0\001",
2818 absolute_section,
2819 (valueT) 0,
2820 &zero_address_frag);
2821 pseudo_set (symbol_get_tc (ext_sym)->size);
2822 }
2823 }
2824 }
2825
2826 S_SET_DATA_TYPE (ext_sym, DT_FCN << N_BTSHFT);
2827 SF_SET_FUNCTION (ext_sym);
2828 SF_SET_PROCESS (ext_sym);
2829 coff_add_linesym (ext_sym);
2830
2831 demand_empty_rest_of_line ();
2832 }
2833
2834 /* The .bf pseudo-op. This is just like a COFF C_FCN symbol named
2835 ".bf". */
2836
2837 static void
2838 ppc_bf (ignore)
2839 int ignore;
2840 {
2841 symbolS *sym;
2842
2843 sym = symbol_make (".bf");
2844 S_SET_SEGMENT (sym, text_section);
2845 symbol_set_frag (sym, frag_now);
2846 S_SET_VALUE (sym, frag_now_fix ());
2847 S_SET_STORAGE_CLASS (sym, C_FCN);
2848
2849 coff_line_base = get_absolute_expression ();
2850
2851 S_SET_NUMBER_AUXILIARY (sym, 1);
2852 SA_SET_SYM_LNNO (sym, coff_line_base);
2853
2854 symbol_get_tc (sym)->output = 1;
2855
2856 ppc_frob_label (sym);
2857
2858 demand_empty_rest_of_line ();
2859 }
2860
2861 /* The .ef pseudo-op. This is just like a COFF C_FCN symbol named
2862 ".ef", except that the line number is absolute, not relative to the
2863 most recent ".bf" symbol. */
2864
2865 static void
2866 ppc_ef (ignore)
2867 int ignore;
2868 {
2869 symbolS *sym;
2870
2871 sym = symbol_make (".ef");
2872 S_SET_SEGMENT (sym, text_section);
2873 symbol_set_frag (sym, frag_now);
2874 S_SET_VALUE (sym, frag_now_fix ());
2875 S_SET_STORAGE_CLASS (sym, C_FCN);
2876 S_SET_NUMBER_AUXILIARY (sym, 1);
2877 SA_SET_SYM_LNNO (sym, get_absolute_expression ());
2878 symbol_get_tc (sym)->output = 1;
2879
2880 ppc_frob_label (sym);
2881
2882 demand_empty_rest_of_line ();
2883 }
2884
2885 /* The .bi and .ei pseudo-ops. These take a string argument and
2886 generates a C_BINCL or C_EINCL symbol, which goes at the start of
2887 the symbol list. */
2888
2889 static void
2890 ppc_biei (ei)
2891 int ei;
2892 {
2893 static symbolS *last_biei;
2894
2895 char *name;
2896 int len;
2897 symbolS *sym;
2898 symbolS *look;
2899
2900 name = demand_copy_C_string (&len);
2901
2902 /* The value of these symbols is actually file offset. Here we set
2903 the value to the index into the line number entries. In
2904 ppc_frob_symbols we set the fix_line field, which will cause BFD
2905 to do the right thing. */
2906
2907 sym = symbol_make (name);
2908 /* obj-coff.c currently only handles line numbers correctly in the
2909 .text section. */
2910 S_SET_SEGMENT (sym, text_section);
2911 S_SET_VALUE (sym, coff_n_line_nos);
2912 symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
2913
2914 S_SET_STORAGE_CLASS (sym, ei ? C_EINCL : C_BINCL);
2915 symbol_get_tc (sym)->output = 1;
2916
2917 for (look = last_biei ? last_biei : symbol_rootP;
2918 (look != (symbolS *) NULL
2919 && (S_GET_STORAGE_CLASS (look) == C_FILE
2920 || S_GET_STORAGE_CLASS (look) == C_BINCL
2921 || S_GET_STORAGE_CLASS (look) == C_EINCL));
2922 look = symbol_next (look))
2923 ;
2924 if (look != (symbolS *) NULL)
2925 {
2926 symbol_remove (sym, &symbol_rootP, &symbol_lastP);
2927 symbol_insert (sym, look, &symbol_rootP, &symbol_lastP);
2928 last_biei = sym;
2929 }
2930
2931 demand_empty_rest_of_line ();
2932 }
2933
2934 /* The .bs pseudo-op. This generates a C_BSTAT symbol named ".bs".
2935 There is one argument, which is a csect symbol. The value of the
2936 .bs symbol is the index of this csect symbol. */
2937
2938 static void
2939 ppc_bs (ignore)
2940 int ignore;
2941 {
2942 char *name;
2943 char endc;
2944 symbolS *csect;
2945 symbolS *sym;
2946
2947 if (ppc_current_block != NULL)
2948 as_bad (_("nested .bs blocks"));
2949
2950 name = input_line_pointer;
2951 endc = get_symbol_end ();
2952
2953 csect = symbol_find_or_make (name);
2954
2955 *input_line_pointer = endc;
2956
2957 sym = symbol_make (".bs");
2958 S_SET_SEGMENT (sym, now_seg);
2959 S_SET_STORAGE_CLASS (sym, C_BSTAT);
2960 symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
2961 symbol_get_tc (sym)->output = 1;
2962
2963 symbol_get_tc (sym)->within = csect;
2964
2965 ppc_frob_label (sym);
2966
2967 ppc_current_block = sym;
2968
2969 demand_empty_rest_of_line ();
2970 }
2971
2972 /* The .es pseudo-op. Generate a C_ESTART symbol named .es. */
2973
2974 static void
2975 ppc_es (ignore)
2976 int ignore;
2977 {
2978 symbolS *sym;
2979
2980 if (ppc_current_block == NULL)
2981 as_bad (_(".es without preceding .bs"));
2982
2983 sym = symbol_make (".es");
2984 S_SET_SEGMENT (sym, now_seg);
2985 S_SET_STORAGE_CLASS (sym, C_ESTAT);
2986 symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
2987 symbol_get_tc (sym)->output = 1;
2988
2989 ppc_frob_label (sym);
2990
2991 ppc_current_block = NULL;
2992
2993 demand_empty_rest_of_line ();
2994 }
2995
2996 /* The .bb pseudo-op. Generate a C_BLOCK symbol named .bb, with a
2997 line number. */
2998
2999 static void
3000 ppc_bb (ignore)
3001 int ignore;
3002 {
3003 symbolS *sym;
3004
3005 sym = symbol_make (".bb");
3006 S_SET_SEGMENT (sym, text_section);
3007 symbol_set_frag (sym, frag_now);
3008 S_SET_VALUE (sym, frag_now_fix ());
3009 S_SET_STORAGE_CLASS (sym, C_BLOCK);
3010
3011 S_SET_NUMBER_AUXILIARY (sym, 1);
3012 SA_SET_SYM_LNNO (sym, get_absolute_expression ());
3013
3014 symbol_get_tc (sym)->output = 1;
3015
3016 SF_SET_PROCESS (sym);
3017
3018 ppc_frob_label (sym);
3019
3020 demand_empty_rest_of_line ();
3021 }
3022
3023 /* The .eb pseudo-op. Generate a C_BLOCK symbol named .eb, with a
3024 line number. */
3025
3026 static void
3027 ppc_eb (ignore)
3028 int ignore;
3029 {
3030 symbolS *sym;
3031
3032 sym = symbol_make (".eb");
3033 S_SET_SEGMENT (sym, text_section);
3034 symbol_set_frag (sym, frag_now);
3035 S_SET_VALUE (sym, frag_now_fix ());
3036 S_SET_STORAGE_CLASS (sym, C_BLOCK);
3037 S_SET_NUMBER_AUXILIARY (sym, 1);
3038 SA_SET_SYM_LNNO (sym, get_absolute_expression ());
3039 symbol_get_tc (sym)->output = 1;
3040
3041 SF_SET_PROCESS (sym);
3042
3043 ppc_frob_label (sym);
3044
3045 demand_empty_rest_of_line ();
3046 }
3047
3048 /* The .bc pseudo-op. This just creates a C_BCOMM symbol with a
3049 specified name. */
3050
3051 static void
3052 ppc_bc (ignore)
3053 int ignore;
3054 {
3055 char *name;
3056 int len;
3057 symbolS *sym;
3058
3059 name = demand_copy_C_string (&len);
3060 sym = symbol_make (name);
3061 S_SET_SEGMENT (sym, ppc_coff_debug_section);
3062 symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
3063 S_SET_STORAGE_CLASS (sym, C_BCOMM);
3064 S_SET_VALUE (sym, 0);
3065 symbol_get_tc (sym)->output = 1;
3066
3067 ppc_frob_label (sym);
3068
3069 demand_empty_rest_of_line ();
3070 }
3071
3072 /* The .ec pseudo-op. This just creates a C_ECOMM symbol. */
3073
3074 static void
3075 ppc_ec (ignore)
3076 int ignore;
3077 {
3078 symbolS *sym;
3079
3080 sym = symbol_make (".ec");
3081 S_SET_SEGMENT (sym, ppc_coff_debug_section);
3082 symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
3083 S_SET_STORAGE_CLASS (sym, C_ECOMM);
3084 S_SET_VALUE (sym, 0);
3085 symbol_get_tc (sym)->output = 1;
3086
3087 ppc_frob_label (sym);
3088
3089 demand_empty_rest_of_line ();
3090 }
3091
3092 /* The .toc pseudo-op. Switch to the .toc subsegment. */
3093
3094 static void
3095 ppc_toc (ignore)
3096 int ignore;
3097 {
3098 if (ppc_toc_csect != (symbolS *) NULL)
3099 subseg_set (data_section, symbol_get_tc (ppc_toc_csect)->subseg);
3100 else
3101 {
3102 subsegT subseg;
3103 symbolS *sym;
3104 symbolS *list;
3105
3106 subseg = ppc_data_subsegment;
3107 ++ppc_data_subsegment;
3108
3109 subseg_new (segment_name (data_section), subseg);
3110 ppc_toc_frag = frag_now;
3111
3112 sym = symbol_find_or_make ("TOC[TC0]");
3113 symbol_set_frag (sym, frag_now);
3114 S_SET_SEGMENT (sym, data_section);
3115 S_SET_VALUE (sym, (valueT) frag_now_fix ());
3116 symbol_get_tc (sym)->subseg = subseg;
3117 symbol_get_tc (sym)->output = 1;
3118 symbol_get_tc (sym)->within = sym;
3119
3120 ppc_toc_csect = sym;
3121
3122 for (list = ppc_data_csects;
3123 symbol_get_tc (list)->next != (symbolS *) NULL;
3124 list = symbol_get_tc (list)->next)
3125 ;
3126 symbol_get_tc (list)->next = sym;
3127
3128 symbol_remove (sym, &symbol_rootP, &symbol_lastP);
3129 symbol_append (sym, symbol_get_tc (list)->within, &symbol_rootP,
3130 &symbol_lastP);
3131 }
3132
3133 ppc_current_csect = ppc_toc_csect;
3134
3135 demand_empty_rest_of_line ();
3136 }
3137
3138 /* The AIX assembler automatically aligns the operands of a .long or
3139 .short pseudo-op, and we want to be compatible. */
3140
3141 static void
3142 ppc_xcoff_cons (log_size)
3143 int log_size;
3144 {
3145 frag_align (log_size, 0, 0);
3146 record_alignment (now_seg, log_size);
3147 cons (1 << log_size);
3148 }
3149
3150 static void
3151 ppc_vbyte (dummy)
3152 int dummy;
3153 {
3154 expressionS exp;
3155 int byte_count;
3156
3157 (void) expression (&exp);
3158
3159 if (exp.X_op != O_constant)
3160 {
3161 as_bad (_("non-constant byte count"));
3162 return;
3163 }
3164
3165 byte_count = exp.X_add_number;
3166
3167 if (*input_line_pointer != ',')
3168 {
3169 as_bad (_("missing value"));
3170 return;
3171 }
3172
3173 ++input_line_pointer;
3174 cons (byte_count);
3175 }
3176
3177 #endif /* OBJ_XCOFF */
3178 \f
3179 /* The .tc pseudo-op. This is used when generating either XCOFF or
3180 ELF. This takes two or more arguments.
3181
3182 When generating XCOFF output, the first argument is the name to
3183 give to this location in the toc; this will be a symbol with class
3184 TC. The rest of the arguments are 4 byte values to actually put at
3185 this location in the TOC; often there is just one more argument, a
3186 relocateable symbol reference.
3187
3188 When not generating XCOFF output, the arguments are the same, but
3189 the first argument is simply ignored. */
3190
3191 static void
3192 ppc_tc (ignore)
3193 int ignore;
3194 {
3195 #ifdef OBJ_XCOFF
3196
3197 /* Define the TOC symbol name. */
3198 {
3199 char *name;
3200 char endc;
3201 symbolS *sym;
3202
3203 if (ppc_toc_csect == (symbolS *) NULL
3204 || ppc_toc_csect != ppc_current_csect)
3205 {
3206 as_bad (_(".tc not in .toc section"));
3207 ignore_rest_of_line ();
3208 return;
3209 }
3210
3211 name = input_line_pointer;
3212 endc = get_symbol_end ();
3213
3214 sym = symbol_find_or_make (name);
3215
3216 *input_line_pointer = endc;
3217
3218 if (S_IS_DEFINED (sym))
3219 {
3220 symbolS *label;
3221
3222 label = symbol_get_tc (ppc_current_csect)->within;
3223 if (symbol_get_tc (label)->class != XMC_TC0)
3224 {
3225 as_bad (_(".tc with no label"));
3226 ignore_rest_of_line ();
3227 return;
3228 }
3229
3230 S_SET_SEGMENT (label, S_GET_SEGMENT (sym));
3231 symbol_set_frag (label, symbol_get_frag (sym));
3232 S_SET_VALUE (label, S_GET_VALUE (sym));
3233
3234 while (! is_end_of_line[(unsigned char) *input_line_pointer])
3235 ++input_line_pointer;
3236
3237 return;
3238 }
3239
3240 S_SET_SEGMENT (sym, now_seg);
3241 symbol_set_frag (sym, frag_now);
3242 S_SET_VALUE (sym, (valueT) frag_now_fix ());
3243 symbol_get_tc (sym)->class = XMC_TC;
3244 symbol_get_tc (sym)->output = 1;
3245
3246 ppc_frob_label (sym);
3247 }
3248
3249 #else /* ! defined (OBJ_XCOFF) */
3250
3251 /* Skip the TOC symbol name. */
3252 while (is_part_of_name (*input_line_pointer)
3253 || *input_line_pointer == '['
3254 || *input_line_pointer == ']'
3255 || *input_line_pointer == '{'
3256 || *input_line_pointer == '}')
3257 ++input_line_pointer;
3258
3259 /* Align to a four byte boundary. */
3260 frag_align (2, 0, 0);
3261 record_alignment (now_seg, 2);
3262
3263 #endif /* ! defined (OBJ_XCOFF) */
3264
3265 if (*input_line_pointer != ',')
3266 demand_empty_rest_of_line ();
3267 else
3268 {
3269 ++input_line_pointer;
3270 cons (4);
3271 }
3272 }
3273 \f
3274 #ifdef TE_PE
3275
3276 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format */
3277
3278 /* Set the current section. */
3279 static void
3280 ppc_set_current_section (new)
3281 segT new;
3282 {
3283 ppc_previous_section = ppc_current_section;
3284 ppc_current_section = new;
3285 }
3286
3287 /* pseudo-op: .previous
3288 behaviour: toggles the current section with the previous section.
3289 errors: None
3290 warnings: "No previous section"
3291 */
3292 static void
3293 ppc_previous(ignore)
3294 int ignore;
3295 {
3296 symbolS *tmp;
3297
3298 if (ppc_previous_section == NULL)
3299 {
3300 as_warn(_("No previous section to return to. Directive ignored."));
3301 return;
3302 }
3303
3304 subseg_set(ppc_previous_section, 0);
3305
3306 ppc_set_current_section(ppc_previous_section);
3307 }
3308
3309 /* pseudo-op: .pdata
3310 behaviour: predefined read only data section
3311 double word aligned
3312 errors: None
3313 warnings: None
3314 initial: .section .pdata "adr3"
3315 a - don't know -- maybe a misprint
3316 d - initialized data
3317 r - readable
3318 3 - double word aligned (that would be 4 byte boundary)
3319
3320 commentary:
3321 Tag index tables (also known as the function table) for exception
3322 handling, debugging, etc.
3323
3324 */
3325 static void
3326 ppc_pdata(ignore)
3327 int ignore;
3328 {
3329 if (pdata_section == 0)
3330 {
3331 pdata_section = subseg_new (".pdata", 0);
3332
3333 bfd_set_section_flags (stdoutput, pdata_section,
3334 (SEC_ALLOC | SEC_LOAD | SEC_RELOC
3335 | SEC_READONLY | SEC_DATA ));
3336
3337 bfd_set_section_alignment (stdoutput, pdata_section, 2);
3338 }
3339 else
3340 {
3341 pdata_section = subseg_new(".pdata", 0);
3342 }
3343 ppc_set_current_section(pdata_section);
3344 }
3345
3346 /* pseudo-op: .ydata
3347 behaviour: predefined read only data section
3348 double word aligned
3349 errors: None
3350 warnings: None
3351 initial: .section .ydata "drw3"
3352 a - don't know -- maybe a misprint
3353 d - initialized data
3354 r - readable
3355 3 - double word aligned (that would be 4 byte boundary)
3356 commentary:
3357 Tag tables (also known as the scope table) for exception handling,
3358 debugging, etc.
3359 */
3360 static void
3361 ppc_ydata(ignore)
3362 int ignore;
3363 {
3364 if (ydata_section == 0)
3365 {
3366 ydata_section = subseg_new (".ydata", 0);
3367 bfd_set_section_flags (stdoutput, ydata_section,
3368 (SEC_ALLOC | SEC_LOAD | SEC_RELOC
3369 | SEC_READONLY | SEC_DATA ));
3370
3371 bfd_set_section_alignment (stdoutput, ydata_section, 3);
3372 }
3373 else
3374 {
3375 ydata_section = subseg_new (".ydata", 0);
3376 }
3377 ppc_set_current_section(ydata_section);
3378 }
3379
3380 /* pseudo-op: .reldata
3381 behaviour: predefined read write data section
3382 double word aligned (4-byte)
3383 FIXME: relocation is applied to it
3384 FIXME: what's the difference between this and .data?
3385 errors: None
3386 warnings: None
3387 initial: .section .reldata "drw3"
3388 d - initialized data
3389 r - readable
3390 w - writeable
3391 3 - double word aligned (that would be 8 byte boundary)
3392
3393 commentary:
3394 Like .data, but intended to hold data subject to relocation, such as
3395 function descriptors, etc.
3396 */
3397 static void
3398 ppc_reldata(ignore)
3399 int ignore;
3400 {
3401 if (reldata_section == 0)
3402 {
3403 reldata_section = subseg_new (".reldata", 0);
3404
3405 bfd_set_section_flags (stdoutput, reldata_section,
3406 ( SEC_ALLOC | SEC_LOAD | SEC_RELOC
3407 | SEC_DATA ));
3408
3409 bfd_set_section_alignment (stdoutput, reldata_section, 2);
3410 }
3411 else
3412 {
3413 reldata_section = subseg_new (".reldata", 0);
3414 }
3415 ppc_set_current_section(reldata_section);
3416 }
3417
3418 /* pseudo-op: .rdata
3419 behaviour: predefined read only data section
3420 double word aligned
3421 errors: None
3422 warnings: None
3423 initial: .section .rdata "dr3"
3424 d - initialized data
3425 r - readable
3426 3 - double word aligned (that would be 4 byte boundary)
3427 */
3428 static void
3429 ppc_rdata(ignore)
3430 int ignore;
3431 {
3432 if (rdata_section == 0)
3433 {
3434 rdata_section = subseg_new (".rdata", 0);
3435 bfd_set_section_flags (stdoutput, rdata_section,
3436 (SEC_ALLOC | SEC_LOAD | SEC_RELOC
3437 | SEC_READONLY | SEC_DATA ));
3438
3439 bfd_set_section_alignment (stdoutput, rdata_section, 2);
3440 }
3441 else
3442 {
3443 rdata_section = subseg_new (".rdata", 0);
3444 }
3445 ppc_set_current_section(rdata_section);
3446 }
3447
3448 /* pseudo-op: .ualong
3449 behaviour: much like .int, with the exception that no alignment is
3450 performed.
3451 FIXME: test the alignment statement
3452 errors: None
3453 warnings: None
3454 */
3455 static void
3456 ppc_ualong(ignore)
3457 int ignore;
3458 {
3459 /* try for long */
3460 cons ( 4 );
3461 }
3462
3463 /* pseudo-op: .znop <symbol name>
3464 behaviour: Issue a nop instruction
3465 Issue a IMAGE_REL_PPC_IFGLUE relocation against it, using
3466 the supplied symbol name.
3467 errors: None
3468 warnings: Missing symbol name
3469 */
3470 static void
3471 ppc_znop(ignore)
3472 int ignore;
3473 {
3474 unsigned long insn;
3475 const struct powerpc_opcode *opcode;
3476 expressionS ex;
3477 char *f;
3478
3479 symbolS *sym;
3480
3481 /* Strip out the symbol name */
3482 char *symbol_name;
3483 char c;
3484 char *name;
3485 unsigned int exp;
3486 flagword flags;
3487 asection *sec;
3488
3489 symbol_name = input_line_pointer;
3490 c = get_symbol_end ();
3491
3492 name = xmalloc (input_line_pointer - symbol_name + 1);
3493 strcpy (name, symbol_name);
3494
3495 sym = symbol_find_or_make (name);
3496
3497 *input_line_pointer = c;
3498
3499 SKIP_WHITESPACE ();
3500
3501 /* Look up the opcode in the hash table. */
3502 opcode = (const struct powerpc_opcode *) hash_find (ppc_hash, "nop");
3503
3504 /* stick in the nop */
3505 insn = opcode->opcode;
3506
3507 /* Write out the instruction. */
3508 f = frag_more (4);
3509 md_number_to_chars (f, insn, 4);
3510 fix_new (frag_now,
3511 f - frag_now->fr_literal,
3512 4,
3513 sym,
3514 0,
3515 0,
3516 BFD_RELOC_16_GOT_PCREL);
3517
3518 }
3519
3520 /* pseudo-op:
3521 behaviour:
3522 errors:
3523 warnings:
3524 */
3525 static void
3526 ppc_pe_comm(lcomm)
3527 int lcomm;
3528 {
3529 register char *name;
3530 register char c;
3531 register char *p;
3532 offsetT temp;
3533 register symbolS *symbolP;
3534 offsetT align;
3535
3536 name = input_line_pointer;
3537 c = get_symbol_end ();
3538
3539 /* just after name is now '\0' */
3540 p = input_line_pointer;
3541 *p = c;
3542 SKIP_WHITESPACE ();
3543 if (*input_line_pointer != ',')
3544 {
3545 as_bad (_("Expected comma after symbol-name: rest of line ignored."));
3546 ignore_rest_of_line ();
3547 return;
3548 }
3549
3550 input_line_pointer++; /* skip ',' */
3551 if ((temp = get_absolute_expression ()) < 0)
3552 {
3553 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) temp);
3554 ignore_rest_of_line ();
3555 return;
3556 }
3557
3558 if (! lcomm)
3559 {
3560 /* The third argument to .comm is the alignment. */
3561 if (*input_line_pointer != ',')
3562 align = 3;
3563 else
3564 {
3565 ++input_line_pointer;
3566 align = get_absolute_expression ();
3567 if (align <= 0)
3568 {
3569 as_warn (_("ignoring bad alignment"));
3570 align = 3;
3571 }
3572 }
3573 }
3574
3575 *p = 0;
3576 symbolP = symbol_find_or_make (name);
3577
3578 *p = c;
3579 if (S_IS_DEFINED (symbolP) && ! S_IS_COMMON (symbolP))
3580 {
3581 as_bad (_("Ignoring attempt to re-define symbol `%s'."),
3582 S_GET_NAME (symbolP));
3583 ignore_rest_of_line ();
3584 return;
3585 }
3586
3587 if (S_GET_VALUE (symbolP))
3588 {
3589 if (S_GET_VALUE (symbolP) != (valueT) temp)
3590 as_bad (_("Length of .comm \"%s\" is already %ld. Not changed to %ld."),
3591 S_GET_NAME (symbolP),
3592 (long) S_GET_VALUE (symbolP),
3593 (long) temp);
3594 }
3595 else
3596 {
3597 S_SET_VALUE (symbolP, (valueT) temp);
3598 S_SET_EXTERNAL (symbolP);
3599 }
3600
3601 demand_empty_rest_of_line ();
3602 }
3603
3604 /*
3605 * implement the .section pseudo op:
3606 * .section name {, "flags"}
3607 * ^ ^
3608 * | +--- optional flags: 'b' for bss
3609 * | 'i' for info
3610 * +-- section name 'l' for lib
3611 * 'n' for noload
3612 * 'o' for over
3613 * 'w' for data
3614 * 'd' (apparently m88k for data)
3615 * 'x' for text
3616 * But if the argument is not a quoted string, treat it as a
3617 * subsegment number.
3618 *
3619 * FIXME: this is a copy of the section processing from obj-coff.c, with
3620 * additions/changes for the moto-pas assembler support. There are three
3621 * categories:
3622 *
3623 * FIXME: I just noticed this. This doesn't work at all really. It it
3624 * setting bits that bfd probably neither understands or uses. The
3625 * correct approach (?) will have to incorporate extra fields attached
3626 * to the section to hold the system specific stuff. (krk)
3627 *
3628 * Section Contents:
3629 * 'a' - unknown - referred to in documentation, but no definition supplied
3630 * 'c' - section has code
3631 * 'd' - section has initialized data
3632 * 'u' - section has uninitialized data
3633 * 'i' - section contains directives (info)
3634 * 'n' - section can be discarded
3635 * 'R' - remove section at link time
3636 *
3637 * Section Protection:
3638 * 'r' - section is readable
3639 * 'w' - section is writeable
3640 * 'x' - section is executable
3641 * 's' - section is sharable
3642 *
3643 * Section Alignment:
3644 * '0' - align to byte boundary
3645 * '1' - align to halfword undary
3646 * '2' - align to word boundary
3647 * '3' - align to doubleword boundary
3648 * '4' - align to quadword boundary
3649 * '5' - align to 32 byte boundary
3650 * '6' - align to 64 byte boundary
3651 *
3652 */
3653
3654 void
3655 ppc_pe_section (ignore)
3656 int ignore;
3657 {
3658 /* Strip out the section name */
3659 char *section_name;
3660 char c;
3661 char *name;
3662 unsigned int exp;
3663 flagword flags;
3664 segT sec;
3665 int align;
3666
3667 section_name = input_line_pointer;
3668 c = get_symbol_end ();
3669
3670 name = xmalloc (input_line_pointer - section_name + 1);
3671 strcpy (name, section_name);
3672
3673 *input_line_pointer = c;
3674
3675 SKIP_WHITESPACE ();
3676
3677 exp = 0;
3678 flags = SEC_NO_FLAGS;
3679
3680 if (strcmp (name, ".idata$2") == 0)
3681 {
3682 align = 0;
3683 }
3684 else if (strcmp (name, ".idata$3") == 0)
3685 {
3686 align = 0;
3687 }
3688 else if (strcmp (name, ".idata$4") == 0)
3689 {
3690 align = 2;
3691 }
3692 else if (strcmp (name, ".idata$5") == 0)
3693 {
3694 align = 2;
3695 }
3696 else if (strcmp (name, ".idata$6") == 0)
3697 {
3698 align = 1;
3699 }
3700 else
3701 align = 4; /* default alignment to 16 byte boundary */
3702
3703 if (*input_line_pointer == ',')
3704 {
3705 ++input_line_pointer;
3706 SKIP_WHITESPACE ();
3707 if (*input_line_pointer != '"')
3708 exp = get_absolute_expression ();
3709 else
3710 {
3711 ++input_line_pointer;
3712 while (*input_line_pointer != '"'
3713 && ! is_end_of_line[(unsigned char) *input_line_pointer])
3714 {
3715 switch (*input_line_pointer)
3716 {
3717 /* Section Contents */
3718 case 'a': /* unknown */
3719 as_bad (_("Unsupported section attribute -- 'a'"));
3720 break;
3721 case 'c': /* code section */
3722 flags |= SEC_CODE;
3723 break;
3724 case 'd': /* section has initialized data */
3725 flags |= SEC_DATA;
3726 break;
3727 case 'u': /* section has uninitialized data */
3728 /* FIXME: This is IMAGE_SCN_CNT_UNINITIALIZED_DATA
3729 in winnt.h */
3730 flags |= SEC_ROM;
3731 break;
3732 case 'i': /* section contains directives (info) */
3733 /* FIXME: This is IMAGE_SCN_LNK_INFO
3734 in winnt.h */
3735 flags |= SEC_HAS_CONTENTS;
3736 break;
3737 case 'n': /* section can be discarded */
3738 flags &=~ SEC_LOAD;
3739 break;
3740 case 'R': /* Remove section at link time */
3741 flags |= SEC_NEVER_LOAD;
3742 break;
3743
3744 /* Section Protection */
3745 case 'r': /* section is readable */
3746 flags |= IMAGE_SCN_MEM_READ;
3747 break;
3748 case 'w': /* section is writeable */
3749 flags |= IMAGE_SCN_MEM_WRITE;
3750 break;
3751 case 'x': /* section is executable */
3752 flags |= IMAGE_SCN_MEM_EXECUTE;
3753 break;
3754 case 's': /* section is sharable */
3755 flags |= IMAGE_SCN_MEM_SHARED;
3756 break;
3757
3758 /* Section Alignment */
3759 case '0': /* align to byte boundary */
3760 flags |= IMAGE_SCN_ALIGN_1BYTES;
3761 align = 0;
3762 break;
3763 case '1': /* align to halfword boundary */
3764 flags |= IMAGE_SCN_ALIGN_2BYTES;
3765 align = 1;
3766 break;
3767 case '2': /* align to word boundary */
3768 flags |= IMAGE_SCN_ALIGN_4BYTES;
3769 align = 2;
3770 break;
3771 case '3': /* align to doubleword boundary */
3772 flags |= IMAGE_SCN_ALIGN_8BYTES;
3773 align = 3;
3774 break;
3775 case '4': /* align to quadword boundary */
3776 flags |= IMAGE_SCN_ALIGN_16BYTES;
3777 align = 4;
3778 break;
3779 case '5': /* align to 32 byte boundary */
3780 flags |= IMAGE_SCN_ALIGN_32BYTES;
3781 align = 5;
3782 break;
3783 case '6': /* align to 64 byte boundary */
3784 flags |= IMAGE_SCN_ALIGN_64BYTES;
3785 align = 6;
3786 break;
3787
3788 default:
3789 as_bad(_("unknown section attribute '%c'"),
3790 *input_line_pointer);
3791 break;
3792 }
3793 ++input_line_pointer;
3794 }
3795 if (*input_line_pointer == '"')
3796 ++input_line_pointer;
3797 }
3798 }
3799
3800 sec = subseg_new (name, (subsegT) exp);
3801
3802 ppc_set_current_section(sec);
3803
3804 if (flags != SEC_NO_FLAGS)
3805 {
3806 if (! bfd_set_section_flags (stdoutput, sec, flags))
3807 as_bad (_("error setting flags for \"%s\": %s"),
3808 bfd_section_name (stdoutput, sec),
3809 bfd_errmsg (bfd_get_error ()));
3810 }
3811
3812 bfd_set_section_alignment(stdoutput, sec, align);
3813
3814 }
3815
3816 static void
3817 ppc_pe_function (ignore)
3818 int ignore;
3819 {
3820 char *name;
3821 char endc;
3822 symbolS *ext_sym;
3823
3824 name = input_line_pointer;
3825 endc = get_symbol_end ();
3826
3827 ext_sym = symbol_find_or_make (name);
3828
3829 *input_line_pointer = endc;
3830
3831 S_SET_DATA_TYPE (ext_sym, DT_FCN << N_BTSHFT);
3832 SF_SET_FUNCTION (ext_sym);
3833 SF_SET_PROCESS (ext_sym);
3834 coff_add_linesym (ext_sym);
3835
3836 demand_empty_rest_of_line ();
3837 }
3838
3839 static void
3840 ppc_pe_tocd (ignore)
3841 int ignore;
3842 {
3843 if (tocdata_section == 0)
3844 {
3845 tocdata_section = subseg_new (".tocd", 0);
3846 /* FIXME: section flags won't work */
3847 bfd_set_section_flags (stdoutput, tocdata_section,
3848 (SEC_ALLOC | SEC_LOAD | SEC_RELOC
3849 | SEC_READONLY | SEC_DATA ));
3850
3851 bfd_set_section_alignment (stdoutput, tocdata_section, 2);
3852 }
3853 else
3854 {
3855 rdata_section = subseg_new (".tocd", 0);
3856 }
3857
3858 ppc_set_current_section(tocdata_section);
3859
3860 demand_empty_rest_of_line ();
3861 }
3862
3863 /* Don't adjust TOC relocs to use the section symbol. */
3864
3865 int
3866 ppc_pe_fix_adjustable (fix)
3867 fixS *fix;
3868 {
3869 return fix->fx_r_type != BFD_RELOC_PPC_TOC16;
3870 }
3871
3872 #endif
3873 \f
3874 #ifdef OBJ_XCOFF
3875
3876 /* XCOFF specific symbol and file handling. */
3877
3878 /* Canonicalize the symbol name. We use the to force the suffix, if
3879 any, to use square brackets, and to be in upper case. */
3880
3881 char *
3882 ppc_canonicalize_symbol_name (name)
3883 char *name;
3884 {
3885 char *s;
3886
3887 if (ppc_stab_symbol)
3888 return name;
3889
3890 for (s = name; *s != '\0' && *s != '{' && *s != '['; s++)
3891 ;
3892 if (*s != '\0')
3893 {
3894 char brac;
3895
3896 if (*s == '[')
3897 brac = ']';
3898 else
3899 {
3900 *s = '[';
3901 brac = '}';
3902 }
3903
3904 for (s++; *s != '\0' && *s != brac; s++)
3905 if (islower (*s))
3906 *s = toupper (*s);
3907
3908 if (*s == '\0' || s[1] != '\0')
3909 as_bad (_("bad symbol suffix"));
3910
3911 *s = ']';
3912 }
3913
3914 return name;
3915 }
3916
3917 /* Set the class of a symbol based on the suffix, if any. This is
3918 called whenever a new symbol is created. */
3919
3920 void
3921 ppc_symbol_new_hook (sym)
3922 symbolS *sym;
3923 {
3924 struct ppc_tc_sy *tc;
3925 const char *s;
3926
3927 tc = symbol_get_tc (sym);
3928 tc->next = NULL;
3929 tc->output = 0;
3930 tc->class = -1;
3931 tc->real_name = NULL;
3932 tc->subseg = 0;
3933 tc->align = 0;
3934 tc->size = NULL;
3935 tc->within = NULL;
3936
3937 if (ppc_stab_symbol)
3938 return;
3939
3940 s = strchr (S_GET_NAME (sym), '[');
3941 if (s == (const char *) NULL)
3942 {
3943 /* There is no suffix. */
3944 return;
3945 }
3946
3947 ++s;
3948
3949 switch (s[0])
3950 {
3951 case 'B':
3952 if (strcmp (s, "BS]") == 0)
3953 tc->class = XMC_BS;
3954 break;
3955 case 'D':
3956 if (strcmp (s, "DB]") == 0)
3957 tc->class = XMC_DB;
3958 else if (strcmp (s, "DS]") == 0)
3959 tc->class = XMC_DS;
3960 break;
3961 case 'G':
3962 if (strcmp (s, "GL]") == 0)
3963 tc->class = XMC_GL;
3964 break;
3965 case 'P':
3966 if (strcmp (s, "PR]") == 0)
3967 tc->class = XMC_PR;
3968 break;
3969 case 'R':
3970 if (strcmp (s, "RO]") == 0)
3971 tc->class = XMC_RO;
3972 else if (strcmp (s, "RW]") == 0)
3973 tc->class = XMC_RW;
3974 break;
3975 case 'S':
3976 if (strcmp (s, "SV]") == 0)
3977 tc->class = XMC_SV;
3978 break;
3979 case 'T':
3980 if (strcmp (s, "TC]") == 0)
3981 tc->class = XMC_TC;
3982 else if (strcmp (s, "TI]") == 0)
3983 tc->class = XMC_TI;
3984 else if (strcmp (s, "TB]") == 0)
3985 tc->class = XMC_TB;
3986 else if (strcmp (s, "TC0]") == 0 || strcmp (s, "T0]") == 0)
3987 tc->class = XMC_TC0;
3988 break;
3989 case 'U':
3990 if (strcmp (s, "UA]") == 0)
3991 tc->class = XMC_UA;
3992 else if (strcmp (s, "UC]") == 0)
3993 tc->class = XMC_UC;
3994 break;
3995 case 'X':
3996 if (strcmp (s, "XO]") == 0)
3997 tc->class = XMC_XO;
3998 break;
3999 }
4000
4001 if (tc->class == -1)
4002 as_bad (_("Unrecognized symbol suffix"));
4003 }
4004
4005 /* Set the class of a label based on where it is defined. This
4006 handles symbols without suffixes. Also, move the symbol so that it
4007 follows the csect symbol. */
4008
4009 void
4010 ppc_frob_label (sym)
4011 symbolS *sym;
4012 {
4013 if (ppc_current_csect != (symbolS *) NULL)
4014 {
4015 if (symbol_get_tc (sym)->class == -1)
4016 symbol_get_tc (sym)->class = symbol_get_tc (ppc_current_csect)->class;
4017
4018 symbol_remove (sym, &symbol_rootP, &symbol_lastP);
4019 symbol_append (sym, symbol_get_tc (ppc_current_csect)->within,
4020 &symbol_rootP, &symbol_lastP);
4021 symbol_get_tc (ppc_current_csect)->within = sym;
4022 }
4023 }
4024
4025 /* This variable is set by ppc_frob_symbol if any absolute symbols are
4026 seen. It tells ppc_adjust_symtab whether it needs to look through
4027 the symbols. */
4028
4029 static boolean ppc_saw_abs;
4030
4031 /* Change the name of a symbol just before writing it out. Set the
4032 real name if the .rename pseudo-op was used. Otherwise, remove any
4033 class suffix. Return 1 if the symbol should not be included in the
4034 symbol table. */
4035
4036 int
4037 ppc_frob_symbol (sym)
4038 symbolS *sym;
4039 {
4040 static symbolS *ppc_last_function;
4041 static symbolS *set_end;
4042
4043 /* Discard symbols that should not be included in the output symbol
4044 table. */
4045 if (! symbol_used_in_reloc_p (sym)
4046 && ((symbol_get_bfdsym (sym)->flags & BSF_SECTION_SYM) != 0
4047 || (! S_IS_EXTERNAL (sym)
4048 && ! symbol_get_tc (sym)->output
4049 && S_GET_STORAGE_CLASS (sym) != C_FILE)))
4050 return 1;
4051
4052 if (symbol_get_tc (sym)->real_name != (char *) NULL)
4053 S_SET_NAME (sym, symbol_get_tc (sym)->real_name);
4054 else
4055 {
4056 const char *name;
4057 const char *s;
4058
4059 name = S_GET_NAME (sym);
4060 s = strchr (name, '[');
4061 if (s != (char *) NULL)
4062 {
4063 unsigned int len;
4064 char *snew;
4065
4066 len = s - name;
4067 snew = xmalloc (len + 1);
4068 memcpy (snew, name, len);
4069 snew[len] = '\0';
4070
4071 S_SET_NAME (sym, snew);
4072 }
4073 }
4074
4075 if (set_end != (symbolS *) NULL)
4076 {
4077 SA_SET_SYM_ENDNDX (set_end, sym);
4078 set_end = NULL;
4079 }
4080
4081 if (SF_GET_FUNCTION (sym))
4082 {
4083 if (ppc_last_function != (symbolS *) NULL)
4084 as_bad (_("two .function pseudo-ops with no intervening .ef"));
4085 ppc_last_function = sym;
4086 if (symbol_get_tc (sym)->size != (symbolS *) NULL)
4087 {
4088 resolve_symbol_value (symbol_get_tc (sym)->size, 1);
4089 SA_SET_SYM_FSIZE (sym,
4090 (long) S_GET_VALUE (symbol_get_tc (sym)->size));
4091 }
4092 }
4093 else if (S_GET_STORAGE_CLASS (sym) == C_FCN
4094 && strcmp (S_GET_NAME (sym), ".ef") == 0)
4095 {
4096 if (ppc_last_function == (symbolS *) NULL)
4097 as_bad (_(".ef with no preceding .function"));
4098 else
4099 {
4100 set_end = ppc_last_function;
4101 ppc_last_function = NULL;
4102
4103 /* We don't have a C_EFCN symbol, but we need to force the
4104 COFF backend to believe that it has seen one. */
4105 coff_last_function = NULL;
4106 }
4107 }
4108
4109 if (! S_IS_EXTERNAL (sym)
4110 && (symbol_get_bfdsym (sym)->flags & BSF_SECTION_SYM) == 0
4111 && S_GET_STORAGE_CLASS (sym) != C_FILE
4112 && S_GET_STORAGE_CLASS (sym) != C_FCN
4113 && S_GET_STORAGE_CLASS (sym) != C_BLOCK
4114 && S_GET_STORAGE_CLASS (sym) != C_BSTAT
4115 && S_GET_STORAGE_CLASS (sym) != C_ESTAT
4116 && S_GET_STORAGE_CLASS (sym) != C_BINCL
4117 && S_GET_STORAGE_CLASS (sym) != C_EINCL
4118 && S_GET_SEGMENT (sym) != ppc_coff_debug_section)
4119 S_SET_STORAGE_CLASS (sym, C_HIDEXT);
4120
4121 if (S_GET_STORAGE_CLASS (sym) == C_EXT
4122 || S_GET_STORAGE_CLASS (sym) == C_HIDEXT)
4123 {
4124 int i;
4125 union internal_auxent *a;
4126
4127 /* Create a csect aux. */
4128 i = S_GET_NUMBER_AUXILIARY (sym);
4129 S_SET_NUMBER_AUXILIARY (sym, i + 1);
4130 a = &coffsymbol (symbol_get_bfdsym (sym))->native[i + 1].u.auxent;
4131 if (symbol_get_tc (sym)->class == XMC_TC0)
4132 {
4133 /* This is the TOC table. */
4134 know (strcmp (S_GET_NAME (sym), "TOC") == 0);
4135 a->x_csect.x_scnlen.l = 0;
4136 a->x_csect.x_smtyp = (2 << 3) | XTY_SD;
4137 }
4138 else if (symbol_get_tc (sym)->subseg != 0)
4139 {
4140 /* This is a csect symbol. x_scnlen is the size of the
4141 csect. */
4142 if (symbol_get_tc (sym)->next == (symbolS *) NULL)
4143 a->x_csect.x_scnlen.l = (bfd_section_size (stdoutput,
4144 S_GET_SEGMENT (sym))
4145 - S_GET_VALUE (sym));
4146 else
4147 {
4148 resolve_symbol_value (symbol_get_tc (sym)->next, 1);
4149 a->x_csect.x_scnlen.l = (S_GET_VALUE (symbol_get_tc (sym)->next)
4150 - S_GET_VALUE (sym));
4151 }
4152 a->x_csect.x_smtyp = (symbol_get_tc (sym)->align << 3) | XTY_SD;
4153 }
4154 else if (S_GET_SEGMENT (sym) == bss_section)
4155 {
4156 /* This is a common symbol. */
4157 a->x_csect.x_scnlen.l = symbol_get_frag (sym)->fr_offset;
4158 a->x_csect.x_smtyp = (symbol_get_tc (sym)->align << 3) | XTY_CM;
4159 if (S_IS_EXTERNAL (sym))
4160 symbol_get_tc (sym)->class = XMC_RW;
4161 else
4162 symbol_get_tc (sym)->class = XMC_BS;
4163 }
4164 else if (S_GET_SEGMENT (sym) == absolute_section)
4165 {
4166 /* This is an absolute symbol. The csect will be created by
4167 ppc_adjust_symtab. */
4168 ppc_saw_abs = true;
4169 a->x_csect.x_smtyp = XTY_LD;
4170 if (symbol_get_tc (sym)->class == -1)
4171 symbol_get_tc (sym)->class = XMC_XO;
4172 }
4173 else if (! S_IS_DEFINED (sym))
4174 {
4175 /* This is an external symbol. */
4176 a->x_csect.x_scnlen.l = 0;
4177 a->x_csect.x_smtyp = XTY_ER;
4178 }
4179 else if (symbol_get_tc (sym)->class == XMC_TC)
4180 {
4181 symbolS *next;
4182
4183 /* This is a TOC definition. x_scnlen is the size of the
4184 TOC entry. */
4185 next = symbol_next (sym);
4186 while (symbol_get_tc (next)->class == XMC_TC0)
4187 next = symbol_next (next);
4188 if (next == (symbolS *) NULL
4189 || symbol_get_tc (next)->class != XMC_TC)
4190 {
4191 if (ppc_after_toc_frag == (fragS *) NULL)
4192 a->x_csect.x_scnlen.l = (bfd_section_size (stdoutput,
4193 data_section)
4194 - S_GET_VALUE (sym));
4195 else
4196 a->x_csect.x_scnlen.l = (ppc_after_toc_frag->fr_address
4197 - S_GET_VALUE (sym));
4198 }
4199 else
4200 {
4201 resolve_symbol_value (next, 1);
4202 a->x_csect.x_scnlen.l = (S_GET_VALUE (next)
4203 - S_GET_VALUE (sym));
4204 }
4205 a->x_csect.x_smtyp = (2 << 3) | XTY_SD;
4206 }
4207 else
4208 {
4209 symbolS *csect;
4210
4211 /* This is a normal symbol definition. x_scnlen is the
4212 symbol index of the containing csect. */
4213 if (S_GET_SEGMENT (sym) == text_section)
4214 csect = ppc_text_csects;
4215 else if (S_GET_SEGMENT (sym) == data_section)
4216 csect = ppc_data_csects;
4217 else
4218 abort ();
4219
4220 /* Skip the initial dummy symbol. */
4221 csect = symbol_get_tc (csect)->next;
4222
4223 if (csect == (symbolS *) NULL)
4224 {
4225 as_warn (_("warning: symbol %s has no csect"), S_GET_NAME (sym));
4226 a->x_csect.x_scnlen.l = 0;
4227 }
4228 else
4229 {
4230 while (symbol_get_tc (csect)->next != (symbolS *) NULL)
4231 {
4232 resolve_symbol_value (symbol_get_tc (csect)->next, 1);
4233 if (S_GET_VALUE (symbol_get_tc (csect)->next)
4234 > S_GET_VALUE (sym))
4235 break;
4236 csect = symbol_get_tc (csect)->next;
4237 }
4238
4239 a->x_csect.x_scnlen.p =
4240 coffsymbol (symbol_get_bfdsym (csect))->native;
4241 coffsymbol (symbol_get_bfdsym (sym))->native[i + 1].fix_scnlen =
4242 1;
4243 }
4244 a->x_csect.x_smtyp = XTY_LD;
4245 }
4246
4247 a->x_csect.x_parmhash = 0;
4248 a->x_csect.x_snhash = 0;
4249 if (symbol_get_tc (sym)->class == -1)
4250 a->x_csect.x_smclas = XMC_PR;
4251 else
4252 a->x_csect.x_smclas = symbol_get_tc (sym)->class;
4253 a->x_csect.x_stab = 0;
4254 a->x_csect.x_snstab = 0;
4255
4256 /* Don't let the COFF backend resort these symbols. */
4257 symbol_get_bfdsym (sym)->flags |= BSF_NOT_AT_END;
4258 }
4259 else if (S_GET_STORAGE_CLASS (sym) == C_BSTAT)
4260 {
4261 /* We want the value to be the symbol index of the referenced
4262 csect symbol. BFD will do that for us if we set the right
4263 flags. */
4264 S_SET_VALUE (sym,
4265 ((valueT)
4266 coffsymbol (symbol_get_bfdsym
4267 (symbol_get_tc (sym)->within))->native));
4268 coffsymbol (symbol_get_bfdsym (sym))->native->fix_value = 1;
4269 }
4270 else if (S_GET_STORAGE_CLASS (sym) == C_STSYM)
4271 {
4272 symbolS *block;
4273 symbolS *csect;
4274
4275 /* The value is the offset from the enclosing csect. */
4276 block = symbol_get_tc (sym)->within;
4277 csect = symbol_get_tc (block)->within;
4278 resolve_symbol_value (csect, 1);
4279 S_SET_VALUE (sym, S_GET_VALUE (sym) - S_GET_VALUE (csect));
4280 }
4281 else if (S_GET_STORAGE_CLASS (sym) == C_BINCL
4282 || S_GET_STORAGE_CLASS (sym) == C_EINCL)
4283 {
4284 /* We want the value to be a file offset into the line numbers.
4285 BFD will do that for us if we set the right flags. We have
4286 already set the value correctly. */
4287 coffsymbol (symbol_get_bfdsym (sym))->native->fix_line = 1;
4288 }
4289
4290 return 0;
4291 }
4292
4293 /* Adjust the symbol table. This creates csect symbols for all
4294 absolute symbols. */
4295
4296 void
4297 ppc_adjust_symtab ()
4298 {
4299 symbolS *sym;
4300
4301 if (! ppc_saw_abs)
4302 return;
4303
4304 for (sym = symbol_rootP; sym != NULL; sym = symbol_next (sym))
4305 {
4306 symbolS *csect;
4307 int i;
4308 union internal_auxent *a;
4309
4310 if (S_GET_SEGMENT (sym) != absolute_section)
4311 continue;
4312
4313 csect = symbol_create (".abs[XO]", absolute_section,
4314 S_GET_VALUE (sym), &zero_address_frag);
4315 symbol_get_bfdsym (csect)->value = S_GET_VALUE (sym);
4316 S_SET_STORAGE_CLASS (csect, C_HIDEXT);
4317 i = S_GET_NUMBER_AUXILIARY (csect);
4318 S_SET_NUMBER_AUXILIARY (csect, i + 1);
4319 a = &coffsymbol (symbol_get_bfdsym (csect))->native[i + 1].u.auxent;
4320 a->x_csect.x_scnlen.l = 0;
4321 a->x_csect.x_smtyp = XTY_SD;
4322 a->x_csect.x_parmhash = 0;
4323 a->x_csect.x_snhash = 0;
4324 a->x_csect.x_smclas = XMC_XO;
4325 a->x_csect.x_stab = 0;
4326 a->x_csect.x_snstab = 0;
4327
4328 symbol_insert (csect, sym, &symbol_rootP, &symbol_lastP);
4329
4330 i = S_GET_NUMBER_AUXILIARY (sym);
4331 a = &coffsymbol (symbol_get_bfdsym (sym))->native[i].u.auxent;
4332 a->x_csect.x_scnlen.p = coffsymbol (symbol_get_bfdsym (csect))->native;
4333 coffsymbol (symbol_get_bfdsym (sym))->native[i].fix_scnlen = 1;
4334 }
4335
4336 ppc_saw_abs = false;
4337 }
4338
4339 /* Set the VMA for a section. This is called on all the sections in
4340 turn. */
4341
4342 void
4343 ppc_frob_section (sec)
4344 asection *sec;
4345 {
4346 static bfd_size_type vma = 0;
4347
4348 bfd_set_section_vma (stdoutput, sec, vma);
4349 vma += bfd_section_size (stdoutput, sec);
4350 }
4351
4352 #endif /* OBJ_XCOFF */
4353 \f
4354 /* Turn a string in input_line_pointer into a floating point constant
4355 of type type, and store the appropriate bytes in *litp. The number
4356 of LITTLENUMS emitted is stored in *sizep . An error message is
4357 returned, or NULL on OK. */
4358
4359 char *
4360 md_atof (type, litp, sizep)
4361 int type;
4362 char *litp;
4363 int *sizep;
4364 {
4365 int prec;
4366 LITTLENUM_TYPE words[4];
4367 char *t;
4368 int i;
4369
4370 switch (type)
4371 {
4372 case 'f':
4373 prec = 2;
4374 break;
4375
4376 case 'd':
4377 prec = 4;
4378 break;
4379
4380 default:
4381 *sizep = 0;
4382 return _("bad call to md_atof");
4383 }
4384
4385 t = atof_ieee (input_line_pointer, type, words);
4386 if (t)
4387 input_line_pointer = t;
4388
4389 *sizep = prec * 2;
4390
4391 if (target_big_endian)
4392 {
4393 for (i = 0; i < prec; i++)
4394 {
4395 md_number_to_chars (litp, (valueT) words[i], 2);
4396 litp += 2;
4397 }
4398 }
4399 else
4400 {
4401 for (i = prec - 1; i >= 0; i--)
4402 {
4403 md_number_to_chars (litp, (valueT) words[i], 2);
4404 litp += 2;
4405 }
4406 }
4407
4408 return NULL;
4409 }
4410
4411 /* Write a value out to the object file, using the appropriate
4412 endianness. */
4413
4414 void
4415 md_number_to_chars (buf, val, n)
4416 char *buf;
4417 valueT val;
4418 int n;
4419 {
4420 if (target_big_endian)
4421 number_to_chars_bigendian (buf, val, n);
4422 else
4423 number_to_chars_littleendian (buf, val, n);
4424 }
4425
4426 /* Align a section (I don't know why this is machine dependent). */
4427
4428 valueT
4429 md_section_align (seg, addr)
4430 asection *seg;
4431 valueT addr;
4432 {
4433 int align = bfd_get_section_alignment (stdoutput, seg);
4434
4435 return ((addr + (1 << align) - 1) & (-1 << align));
4436 }
4437
4438 /* We don't have any form of relaxing. */
4439
4440 int
4441 md_estimate_size_before_relax (fragp, seg)
4442 fragS *fragp;
4443 asection *seg;
4444 {
4445 abort ();
4446 return 0;
4447 }
4448
4449 /* Convert a machine dependent frag. We never generate these. */
4450
4451 void
4452 md_convert_frag (abfd, sec, fragp)
4453 bfd *abfd;
4454 asection *sec;
4455 fragS *fragp;
4456 {
4457 abort ();
4458 }
4459
4460 /* We have no need to default values of symbols. */
4461
4462 /*ARGSUSED*/
4463 symbolS *
4464 md_undefined_symbol (name)
4465 char *name;
4466 {
4467 return 0;
4468 }
4469 \f
4470 /* Functions concerning relocs. */
4471
4472 /* The location from which a PC relative jump should be calculated,
4473 given a PC relative reloc. */
4474
4475 long
4476 md_pcrel_from_section (fixp, sec)
4477 fixS *fixp;
4478 segT sec;
4479 {
4480 return fixp->fx_frag->fr_address + fixp->fx_where;
4481 }
4482
4483 #ifdef OBJ_XCOFF
4484
4485 /* This is called to see whether a fixup should be adjusted to use a
4486 section symbol. We take the opportunity to change a fixup against
4487 a symbol in the TOC subsegment into a reloc against the
4488 corresponding .tc symbol. */
4489
4490 int
4491 ppc_fix_adjustable (fix)
4492 fixS *fix;
4493 {
4494 valueT val;
4495
4496 resolve_symbol_value (fix->fx_addsy, 1);
4497 val = S_GET_VALUE (fix->fx_addsy);
4498 if (ppc_toc_csect != (symbolS *) NULL
4499 && fix->fx_addsy != (symbolS *) NULL
4500 && fix->fx_addsy != ppc_toc_csect
4501 && S_GET_SEGMENT (fix->fx_addsy) == data_section
4502 && val >= ppc_toc_frag->fr_address
4503 && (ppc_after_toc_frag == (fragS *) NULL
4504 || val < ppc_after_toc_frag->fr_address))
4505 {
4506 symbolS *sy;
4507
4508 for (sy = symbol_next (ppc_toc_csect);
4509 sy != (symbolS *) NULL;
4510 sy = symbol_next (sy))
4511 {
4512 if (symbol_get_tc (sy)->class == XMC_TC0)
4513 continue;
4514 if (symbol_get_tc (sy)->class != XMC_TC)
4515 break;
4516 resolve_symbol_value (sy, 1);
4517 if (val == S_GET_VALUE (sy))
4518 {
4519 fix->fx_addsy = sy;
4520 fix->fx_addnumber = val - ppc_toc_frag->fr_address;
4521 return 0;
4522 }
4523 }
4524
4525 as_bad_where (fix->fx_file, fix->fx_line,
4526 _("symbol in .toc does not match any .tc"));
4527 }
4528
4529 /* Possibly adjust the reloc to be against the csect. */
4530 if (fix->fx_addsy != (symbolS *) NULL
4531 && symbol_get_tc (fix->fx_addsy)->subseg == 0
4532 && symbol_get_tc (fix->fx_addsy)->class != XMC_TC0
4533 && symbol_get_tc (fix->fx_addsy)->class != XMC_TC
4534 && S_GET_SEGMENT (fix->fx_addsy) != bss_section
4535 /* Don't adjust if this is a reloc in the toc section. */
4536 && (S_GET_SEGMENT (fix->fx_addsy) != data_section
4537 || ppc_toc_csect == NULL
4538 || val < ppc_toc_frag->fr_address
4539 || (ppc_after_toc_frag != NULL
4540 && val >= ppc_after_toc_frag->fr_address)))
4541 {
4542 symbolS *csect;
4543
4544 if (S_GET_SEGMENT (fix->fx_addsy) == text_section)
4545 csect = ppc_text_csects;
4546 else if (S_GET_SEGMENT (fix->fx_addsy) == data_section)
4547 csect = ppc_data_csects;
4548 else
4549 abort ();
4550
4551 /* Skip the initial dummy symbol. */
4552 csect = symbol_get_tc (csect)->next;
4553
4554 if (csect != (symbolS *) NULL)
4555 {
4556 while (symbol_get_tc (csect)->next != (symbolS *) NULL
4557 && (symbol_get_frag (symbol_get_tc (csect)->next)->fr_address
4558 <= symbol_get_frag (fix->fx_addsy)->fr_address))
4559 {
4560 /* If the csect address equals the symbol value, then we
4561 have to look through the full symbol table to see
4562 whether this is the csect we want. Note that we will
4563 only get here if the csect has zero length. */
4564 if ((symbol_get_frag (csect)->fr_address
4565 == symbol_get_frag (fix->fx_addsy)->fr_address)
4566 && S_GET_VALUE (csect) == S_GET_VALUE (fix->fx_addsy))
4567 {
4568 symbolS *scan;
4569
4570 for (scan = symbol_next (csect);
4571 scan != NULL;
4572 scan = symbol_next (scan))
4573 {
4574 if (symbol_get_tc (scan)->subseg != 0)
4575 break;
4576 if (scan == fix->fx_addsy)
4577 break;
4578 }
4579
4580 /* If we found the symbol before the next csect
4581 symbol, then this is the csect we want. */
4582 if (scan == fix->fx_addsy)
4583 break;
4584 }
4585
4586 csect = symbol_get_tc (csect)->next;
4587 }
4588
4589 fix->fx_offset += (S_GET_VALUE (fix->fx_addsy)
4590 - symbol_get_frag (csect)->fr_address);
4591 fix->fx_addsy = csect;
4592 }
4593 }
4594
4595 /* Adjust a reloc against a .lcomm symbol to be against the base
4596 .lcomm. */
4597 if (fix->fx_addsy != (symbolS *) NULL
4598 && S_GET_SEGMENT (fix->fx_addsy) == bss_section
4599 && ! S_IS_EXTERNAL (fix->fx_addsy))
4600 {
4601 resolve_symbol_value (symbol_get_frag (fix->fx_addsy)->fr_symbol, 1);
4602 fix->fx_offset +=
4603 (S_GET_VALUE (fix->fx_addsy)
4604 - S_GET_VALUE (symbol_get_frag (fix->fx_addsy)->fr_symbol));
4605 fix->fx_addsy = symbol_get_frag (fix->fx_addsy)->fr_symbol;
4606 }
4607
4608 return 0;
4609 }
4610
4611 /* A reloc from one csect to another must be kept. The assembler
4612 will, of course, keep relocs between sections, and it will keep
4613 absolute relocs, but we need to force it to keep PC relative relocs
4614 between two csects in the same section. */
4615
4616 int
4617 ppc_force_relocation (fix)
4618 fixS *fix;
4619 {
4620 /* At this point fix->fx_addsy should already have been converted to
4621 a csect symbol. If the csect does not include the fragment, then
4622 we need to force the relocation. */
4623 if (fix->fx_pcrel
4624 && fix->fx_addsy != NULL
4625 && symbol_get_tc (fix->fx_addsy)->subseg != 0
4626 && ((symbol_get_frag (fix->fx_addsy)->fr_address
4627 > fix->fx_frag->fr_address)
4628 || (symbol_get_tc (fix->fx_addsy)->next != NULL
4629 && (symbol_get_frag (symbol_get_tc (fix->fx_addsy)->next)->fr_address
4630 <= fix->fx_frag->fr_address))))
4631 return 1;
4632
4633 return 0;
4634 }
4635
4636 #endif /* OBJ_XCOFF */
4637
4638 /* See whether a symbol is in the TOC section. */
4639
4640 static int
4641 ppc_is_toc_sym (sym)
4642 symbolS *sym;
4643 {
4644 #ifdef OBJ_XCOFF
4645 return symbol_get_tc (sym)->class == XMC_TC;
4646 #else
4647 return strcmp (segment_name (S_GET_SEGMENT (sym)), ".got") == 0;
4648 #endif
4649 }
4650
4651 /* Apply a fixup to the object code. This is called for all the
4652 fixups we generated by the call to fix_new_exp, above. In the call
4653 above we used a reloc code which was the largest legal reloc code
4654 plus the operand index. Here we undo that to recover the operand
4655 index. At this point all symbol values should be fully resolved,
4656 and we attempt to completely resolve the reloc. If we can not do
4657 that, we determine the correct reloc code and put it back in the
4658 fixup. */
4659
4660 int
4661 md_apply_fix3 (fixp, valuep, seg)
4662 fixS *fixp;
4663 valueT *valuep;
4664 segT seg;
4665 {
4666 valueT value;
4667
4668 #ifdef OBJ_ELF
4669 value = *valuep;
4670 if (fixp->fx_addsy != NULL)
4671 {
4672 /* `*valuep' may contain the value of the symbol on which the reloc
4673 will be based; we have to remove it. */
4674 if (symbol_used_in_reloc_p (fixp->fx_addsy)
4675 && S_GET_SEGMENT (fixp->fx_addsy) != absolute_section
4676 && S_GET_SEGMENT (fixp->fx_addsy) != undefined_section
4677 && ! bfd_is_com_section (S_GET_SEGMENT (fixp->fx_addsy)))
4678 value -= S_GET_VALUE (fixp->fx_addsy);
4679
4680 /* FIXME: Why '+'? Better yet, what exactly is '*valuep'
4681 supposed to be? I think this is related to various similar
4682 FIXMEs in tc-i386.c and tc-sparc.c. */
4683 if (fixp->fx_pcrel)
4684 value += fixp->fx_frag->fr_address + fixp->fx_where;
4685 }
4686 else
4687 {
4688 fixp->fx_done = 1;
4689 }
4690 #else
4691 /* FIXME FIXME FIXME: The value we are passed in *valuep includes
4692 the symbol values. Since we are using BFD_ASSEMBLER, if we are
4693 doing this relocation the code in write.c is going to call
4694 bfd_install_relocation, which is also going to use the symbol
4695 value. That means that if the reloc is fully resolved we want to
4696 use *valuep since bfd_install_relocation is not being used.
4697 However, if the reloc is not fully resolved we do not want to use
4698 *valuep, and must use fx_offset instead. However, if the reloc
4699 is PC relative, we do want to use *valuep since it includes the
4700 result of md_pcrel_from. This is confusing. */
4701 if (fixp->fx_addsy == (symbolS *) NULL)
4702 {
4703 value = *valuep;
4704 fixp->fx_done = 1;
4705 }
4706 else if (fixp->fx_pcrel)
4707 value = *valuep;
4708 else
4709 {
4710 value = fixp->fx_offset;
4711 if (fixp->fx_subsy != (symbolS *) NULL)
4712 {
4713 if (S_GET_SEGMENT (fixp->fx_subsy) == absolute_section)
4714 value -= S_GET_VALUE (fixp->fx_subsy);
4715 else
4716 {
4717 /* We can't actually support subtracting a symbol. */
4718 as_bad_where (fixp->fx_file, fixp->fx_line,
4719 _("expression too complex"));
4720 }
4721 }
4722 }
4723 #endif
4724
4725 if ((int) fixp->fx_r_type >= (int) BFD_RELOC_UNUSED)
4726 {
4727 int opindex;
4728 const struct powerpc_operand *operand;
4729 char *where;
4730 unsigned long insn;
4731
4732 opindex = (int) fixp->fx_r_type - (int) BFD_RELOC_UNUSED;
4733
4734 operand = &powerpc_operands[opindex];
4735
4736 #ifdef OBJ_XCOFF
4737 /* It appears that an instruction like
4738 l 9,LC..1(30)
4739 when LC..1 is not a TOC symbol does not generate a reloc. It
4740 uses the offset of LC..1 within its csect. However, .long
4741 LC..1 will generate a reloc. I can't find any documentation
4742 on how these cases are to be distinguished, so this is a wild
4743 guess. These cases are generated by gcc -mminimal-toc. */
4744 if ((operand->flags & PPC_OPERAND_PARENS) != 0
4745 && operand->bits == 16
4746 && operand->shift == 0
4747 && operand->insert == NULL
4748 && fixp->fx_addsy != NULL
4749 && symbol_get_tc (fixp->fx_addsy)->subseg != 0
4750 && symbol_get_tc (fixp->fx_addsy)->class != XMC_TC
4751 && symbol_get_tc (fixp->fx_addsy)->class != XMC_TC0
4752 && S_GET_SEGMENT (fixp->fx_addsy) != bss_section)
4753 {
4754 value = fixp->fx_offset;
4755 fixp->fx_done = 1;
4756 }
4757 #endif
4758
4759 /* Fetch the instruction, insert the fully resolved operand
4760 value, and stuff the instruction back again. */
4761 where = fixp->fx_frag->fr_literal + fixp->fx_where;
4762 if (target_big_endian)
4763 insn = bfd_getb32 ((unsigned char *) where);
4764 else
4765 insn = bfd_getl32 ((unsigned char *) where);
4766 insn = ppc_insert_operand (insn, operand, (offsetT) value,
4767 fixp->fx_file, fixp->fx_line);
4768 if (target_big_endian)
4769 bfd_putb32 ((bfd_vma) insn, (unsigned char *) where);
4770 else
4771 bfd_putl32 ((bfd_vma) insn, (unsigned char *) where);
4772
4773 if (fixp->fx_done)
4774 {
4775 /* Nothing else to do here. */
4776 return 1;
4777 }
4778
4779 /* Determine a BFD reloc value based on the operand information.
4780 We are only prepared to turn a few of the operands into
4781 relocs.
4782 FIXME: We need to handle the DS field at the very least.
4783 FIXME: Selecting the reloc type is a bit haphazard; perhaps
4784 there should be a new field in the operand table. */
4785 if ((operand->flags & PPC_OPERAND_RELATIVE) != 0
4786 && operand->bits == 26
4787 && operand->shift == 0)
4788 fixp->fx_r_type = BFD_RELOC_PPC_B26;
4789 else if ((operand->flags & PPC_OPERAND_RELATIVE) != 0
4790 && operand->bits == 16
4791 && operand->shift == 0)
4792 fixp->fx_r_type = BFD_RELOC_PPC_B16;
4793 else if ((operand->flags & PPC_OPERAND_ABSOLUTE) != 0
4794 && operand->bits == 26
4795 && operand->shift == 0)
4796 fixp->fx_r_type = BFD_RELOC_PPC_BA26;
4797 else if ((operand->flags & PPC_OPERAND_ABSOLUTE) != 0
4798 && operand->bits == 16
4799 && operand->shift == 0)
4800 fixp->fx_r_type = BFD_RELOC_PPC_BA16;
4801 else if ((operand->flags & PPC_OPERAND_PARENS) != 0
4802 && operand->bits == 16
4803 && operand->shift == 0
4804 && operand->insert == NULL
4805 && fixp->fx_addsy != NULL
4806 && ppc_is_toc_sym (fixp->fx_addsy))
4807 {
4808 fixp->fx_size = 2;
4809 if (target_big_endian)
4810 fixp->fx_where += 2;
4811 fixp->fx_r_type = BFD_RELOC_PPC_TOC16;
4812 }
4813 else
4814 {
4815 char *sfile;
4816 unsigned int sline;
4817
4818 /* Use expr_symbol_where to see if this is an expression
4819 symbol. */
4820 if (expr_symbol_where (fixp->fx_addsy, &sfile, &sline))
4821 as_bad_where (fixp->fx_file, fixp->fx_line,
4822 _("unresolved expression that must be resolved"));
4823 else
4824 as_bad_where (fixp->fx_file, fixp->fx_line,
4825 _("unsupported relocation type"));
4826 fixp->fx_done = 1;
4827 return 1;
4828 }
4829 }
4830 else
4831 {
4832 #ifdef OBJ_ELF
4833 ppc_elf_validate_fix (fixp, seg);
4834 #endif
4835 switch (fixp->fx_r_type)
4836 {
4837 case BFD_RELOC_32:
4838 case BFD_RELOC_CTOR:
4839 if (fixp->fx_pcrel)
4840 fixp->fx_r_type = BFD_RELOC_32_PCREL;
4841 /* fall through */
4842
4843 case BFD_RELOC_RVA:
4844 case BFD_RELOC_32_PCREL:
4845 case BFD_RELOC_32_BASEREL:
4846 case BFD_RELOC_PPC_EMB_NADDR32:
4847 md_number_to_chars (fixp->fx_frag->fr_literal + fixp->fx_where,
4848 value, 4);
4849 break;
4850
4851 case BFD_RELOC_LO16:
4852 case BFD_RELOC_16:
4853 case BFD_RELOC_GPREL16:
4854 case BFD_RELOC_16_GOT_PCREL:
4855 case BFD_RELOC_16_GOTOFF:
4856 case BFD_RELOC_LO16_GOTOFF:
4857 case BFD_RELOC_HI16_GOTOFF:
4858 case BFD_RELOC_HI16_S_GOTOFF:
4859 case BFD_RELOC_LO16_BASEREL:
4860 case BFD_RELOC_HI16_BASEREL:
4861 case BFD_RELOC_HI16_S_BASEREL:
4862 case BFD_RELOC_PPC_EMB_NADDR16:
4863 case BFD_RELOC_PPC_EMB_NADDR16_LO:
4864 case BFD_RELOC_PPC_EMB_NADDR16_HI:
4865 case BFD_RELOC_PPC_EMB_NADDR16_HA:
4866 case BFD_RELOC_PPC_EMB_SDAI16:
4867 case BFD_RELOC_PPC_EMB_SDA2REL:
4868 case BFD_RELOC_PPC_EMB_SDA2I16:
4869 case BFD_RELOC_PPC_EMB_RELSEC16:
4870 case BFD_RELOC_PPC_EMB_RELST_LO:
4871 case BFD_RELOC_PPC_EMB_RELST_HI:
4872 case BFD_RELOC_PPC_EMB_RELST_HA:
4873 case BFD_RELOC_PPC_EMB_RELSDA:
4874 case BFD_RELOC_PPC_TOC16:
4875 if (fixp->fx_pcrel)
4876 {
4877 if (fixp->fx_addsy != NULL)
4878 as_bad_where (fixp->fx_file, fixp->fx_line,
4879 _("cannot emit PC relative %s relocation against %s"),
4880 bfd_get_reloc_code_name (fixp->fx_r_type),
4881 S_GET_NAME (fixp->fx_addsy));
4882 else
4883 as_bad_where (fixp->fx_file, fixp->fx_line,
4884 _("cannot emit PC relative %s relocation"),
4885 bfd_get_reloc_code_name (fixp->fx_r_type));
4886 }
4887
4888 md_number_to_chars (fixp->fx_frag->fr_literal + fixp->fx_where,
4889 value, 2);
4890 break;
4891
4892 /* This case happens when you write, for example,
4893 lis %r3,(L1-L2)@ha
4894 where L1 and L2 are defined later. */
4895 case BFD_RELOC_HI16:
4896 if (fixp->fx_pcrel)
4897 abort ();
4898 md_number_to_chars (fixp->fx_frag->fr_literal + fixp->fx_where,
4899 value >> 16, 2);
4900 break;
4901 case BFD_RELOC_HI16_S:
4902 if (fixp->fx_pcrel)
4903 abort ();
4904 md_number_to_chars (fixp->fx_frag->fr_literal + fixp->fx_where,
4905 (value + 0x8000) >> 16, 2);
4906 break;
4907
4908 /* Because SDA21 modifies the register field, the size is set to 4
4909 bytes, rather than 2, so offset it here appropriately */
4910 case BFD_RELOC_PPC_EMB_SDA21:
4911 if (fixp->fx_pcrel)
4912 abort ();
4913
4914 md_number_to_chars (fixp->fx_frag->fr_literal + fixp->fx_where
4915 + ((target_big_endian) ? 2 : 0),
4916 value, 2);
4917 break;
4918
4919 case BFD_RELOC_8:
4920 if (fixp->fx_pcrel)
4921 abort ();
4922
4923 md_number_to_chars (fixp->fx_frag->fr_literal + fixp->fx_where,
4924 value, 1);
4925 break;
4926
4927 case BFD_RELOC_24_PLT_PCREL:
4928 case BFD_RELOC_PPC_LOCAL24PC:
4929 if (!fixp->fx_pcrel && !fixp->fx_done)
4930 abort ();
4931
4932 if (fixp->fx_done)
4933 {
4934 char *where;
4935 unsigned long insn;
4936
4937 /* Fetch the instruction, insert the fully resolved operand
4938 value, and stuff the instruction back again. */
4939 where = fixp->fx_frag->fr_literal + fixp->fx_where;
4940 if (target_big_endian)
4941 insn = bfd_getb32 ((unsigned char *) where);
4942 else
4943 insn = bfd_getl32 ((unsigned char *) where);
4944 if ((value & 3) != 0)
4945 as_bad_where (fixp->fx_file, fixp->fx_line,
4946 _("must branch to an address a multiple of 4"));
4947 if ((offsetT) value < -0x40000000
4948 || (offsetT) value >= 0x40000000)
4949 as_bad_where (fixp->fx_file, fixp->fx_line,
4950 _("@local or @plt branch destination is too far away, %ld bytes"),
4951 value);
4952 insn = insn | (value & 0x03fffffc);
4953 if (target_big_endian)
4954 bfd_putb32 ((bfd_vma) insn, (unsigned char *) where);
4955 else
4956 bfd_putl32 ((bfd_vma) insn, (unsigned char *) where);
4957 }
4958 break;
4959
4960 case BFD_RELOC_VTABLE_INHERIT:
4961 fixp->fx_done = 0;
4962 if (fixp->fx_addsy
4963 && !S_IS_DEFINED (fixp->fx_addsy)
4964 && !S_IS_WEAK (fixp->fx_addsy))
4965 S_SET_WEAK (fixp->fx_addsy);
4966 break;
4967
4968 case BFD_RELOC_VTABLE_ENTRY:
4969 fixp->fx_done = 0;
4970 break;
4971
4972 default:
4973 fprintf(stderr,
4974 _("Gas failure, reloc value %d\n"), fixp->fx_r_type);
4975 fflush(stderr);
4976 abort ();
4977 }
4978 }
4979
4980 #ifdef OBJ_ELF
4981 fixp->fx_addnumber = value;
4982 #else
4983 if (fixp->fx_r_type != BFD_RELOC_PPC_TOC16)
4984 fixp->fx_addnumber = 0;
4985 else
4986 {
4987 #ifdef TE_PE
4988 fixp->fx_addnumber = 0;
4989 #else
4990 /* We want to use the offset within the data segment of the
4991 symbol, not the actual VMA of the symbol. */
4992 fixp->fx_addnumber =
4993 - bfd_get_section_vma (stdoutput, S_GET_SEGMENT (fixp->fx_addsy));
4994 #endif
4995 }
4996 #endif
4997
4998 return 1;
4999 }
5000
5001 /* Generate a reloc for a fixup. */
5002
5003 arelent *
5004 tc_gen_reloc (seg, fixp)
5005 asection *seg;
5006 fixS *fixp;
5007 {
5008 arelent *reloc;
5009
5010 reloc = (arelent *) xmalloc (sizeof (arelent));
5011
5012 reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
5013 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
5014 reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
5015 reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
5016 if (reloc->howto == (reloc_howto_type *) NULL)
5017 {
5018 as_bad_where (fixp->fx_file, fixp->fx_line,
5019 _("reloc %d not supported by object file format"), (int)fixp->fx_r_type);
5020 return NULL;
5021 }
5022 reloc->addend = fixp->fx_addnumber;
5023
5024 return reloc;
5025 }