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