projects / deliverable / binutils-gdb.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
bfd/
[deliverable/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, 2003,
3 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011, 2012
4 Free Software Foundation, Inc.
5 Written by Ian Lance Taylor, Cygnus Support.
6
7 This file is part of GAS, the GNU Assembler.
8
9 GAS is free software; you can redistribute it and/or modify
10 it under the terms of the GNU General Public License as published by
11 the Free Software Foundation; either version 3, or (at your option)
12 any later version.
13
14 GAS is distributed in the hope that it will be useful,
15 but WITHOUT ANY WARRANTY; without even the implied warranty of
16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
17 GNU General Public License for more details.
18
19 You should have received a copy of the GNU General Public License
20 along with GAS; see the file COPYING. If not, write to the Free
21 Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
22 02110-1301, USA. */
23
24 #include "as.h"
25 #include "safe-ctype.h"
26 #include "subsegs.h"
27 #include "dw2gencfi.h"
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 #ifdef OBJ_XCOFF
40 #include "coff/xcoff.h"
41 #include "libxcoff.h"
42 #endif
43
44 /* This is the assembler for the PowerPC or POWER (RS/6000) chips. */
45
46 /* Tell the main code what the endianness is. */
47 extern int target_big_endian;
48
49 /* Whether or not, we've set target_big_endian. */
50 static int set_target_endian = 0;
51
52 /* Whether to use user friendly register names. */
53 #ifndef TARGET_REG_NAMES_P
54 #ifdef TE_PE
55 #define TARGET_REG_NAMES_P TRUE
56 #else
57 #define TARGET_REG_NAMES_P FALSE
58 #endif
59 #endif
60
61 /* Macros for calculating LO, HI, HA, HIGHER, HIGHERA, HIGHEST,
62 HIGHESTA. */
63
64 /* #lo(value) denotes the least significant 16 bits of the indicated. */
65 #define PPC_LO(v) ((v) & 0xffff)
66
67 /* #hi(value) denotes bits 16 through 31 of the indicated value. */
68 #define PPC_HI(v) (((v) >> 16) & 0xffff)
69
70 /* #ha(value) denotes the high adjusted value: bits 16 through 31 of
71 the indicated value, compensating for #lo() being treated as a
72 signed number. */
73 #define PPC_HA(v) PPC_HI ((v) + 0x8000)
74
75 /* #higher(value) denotes bits 32 through 47 of the indicated value. */
76 #define PPC_HIGHER(v) (((v) >> 16 >> 16) & 0xffff)
77
78 /* #highera(value) denotes bits 32 through 47 of the indicated value,
79 compensating for #lo() being treated as a signed number. */
80 #define PPC_HIGHERA(v) PPC_HIGHER ((v) + 0x8000)
81
82 /* #highest(value) denotes bits 48 through 63 of the indicated value. */
83 #define PPC_HIGHEST(v) (((v) >> 24 >> 24) & 0xffff)
84
85 /* #highesta(value) denotes bits 48 through 63 of the indicated value,
86 compensating for #lo being treated as a signed number. */
87 #define PPC_HIGHESTA(v) PPC_HIGHEST ((v) + 0x8000)
88
89 #define SEX16(val) ((((val) & 0xffff) ^ 0x8000) - 0x8000)
90
91 static bfd_boolean reg_names_p = TARGET_REG_NAMES_P;
92
93 static void ppc_macro (char *, const struct powerpc_macro *);
94 static void ppc_byte (int);
95
96 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
97 static void ppc_tc (int);
98 static void ppc_machine (int);
99 #endif
100
101 #ifdef OBJ_XCOFF
102 static void ppc_comm (int);
103 static void ppc_bb (int);
104 static void ppc_bc (int);
105 static void ppc_bf (int);
106 static void ppc_biei (int);
107 static void ppc_bs (int);
108 static void ppc_eb (int);
109 static void ppc_ec (int);
110 static void ppc_ef (int);
111 static void ppc_es (int);
112 static void ppc_csect (int);
113 static void ppc_dwsect (int);
114 static void ppc_change_csect (symbolS *, offsetT);
115 static void ppc_function (int);
116 static void ppc_extern (int);
117 static void ppc_lglobl (int);
118 static void ppc_ref (int);
119 static void ppc_section (int);
120 static void ppc_named_section (int);
121 static void ppc_stabx (int);
122 static void ppc_rename (int);
123 static void ppc_toc (int);
124 static void ppc_xcoff_cons (int);
125 static void ppc_vbyte (int);
126 #endif
127
128 #ifdef OBJ_ELF
129 static void ppc_elf_cons (int);
130 static void ppc_elf_rdata (int);
131 static void ppc_elf_lcomm (int);
132 #endif
133
134 #ifdef TE_PE
135 static void ppc_previous (int);
136 static void ppc_pdata (int);
137 static void ppc_ydata (int);
138 static void ppc_reldata (int);
139 static void ppc_rdata (int);
140 static void ppc_ualong (int);
141 static void ppc_znop (int);
142 static void ppc_pe_comm (int);
143 static void ppc_pe_section (int);
144 static void ppc_pe_function (int);
145 static void ppc_pe_tocd (int);
146 #endif
147 \f
148 /* Generic assembler global variables which must be defined by all
149 targets. */
150
151 #ifdef OBJ_ELF
152 /* This string holds the chars that always start a comment. If the
153 pre-processor is disabled, these aren't very useful. The macro
154 tc_comment_chars points to this. We use this, rather than the
155 usual comment_chars, so that we can switch for Solaris conventions. */
156 static const char ppc_solaris_comment_chars[] = "#!";
157 static const char ppc_eabi_comment_chars[] = "#";
158
159 #ifdef TARGET_SOLARIS_COMMENT
160 const char *ppc_comment_chars = ppc_solaris_comment_chars;
161 #else
162 const char *ppc_comment_chars = ppc_eabi_comment_chars;
163 #endif
164 #else
165 const char comment_chars[] = "#";
166 #endif
167
168 /* Characters which start a comment at the beginning of a line. */
169 const char line_comment_chars[] = "#";
170
171 /* Characters which may be used to separate multiple commands on a
172 single line. */
173 const char line_separator_chars[] = ";";
174
175 /* Characters which are used to indicate an exponent in a floating
176 point number. */
177 const char EXP_CHARS[] = "eE";
178
179 /* Characters which mean that a number is a floating point constant,
180 as in 0d1.0. */
181 const char FLT_CHARS[] = "dD";
182
183 /* Anything that can start an operand needs to be mentioned here,
184 to stop the input scrubber eating whitespace. */
185 const char ppc_symbol_chars[] = "%[";
186
187 /* The dwarf2 data alignment, adjusted for 32 or 64 bit. */
188 int ppc_cie_data_alignment;
189
190 /* The dwarf2 minimum instruction length. */
191 int ppc_dwarf2_line_min_insn_length;
192
193 /* More than this number of nops in an alignment op gets a branch
194 instead. */
195 unsigned long nop_limit = 4;
196
197 /* The type of processor we are assembling for. This is one or more
198 of the PPC_OPCODE flags defined in opcode/ppc.h. */
199 ppc_cpu_t ppc_cpu = 0;
200 ppc_cpu_t sticky = 0;
201
202 /* Flags set on encountering toc relocs. */
203 enum {
204 has_large_toc_reloc = 1,
205 has_small_toc_reloc = 2
206 } toc_reloc_types;
207 \f
208 /* The target specific pseudo-ops which we support. */
209
210 const pseudo_typeS md_pseudo_table[] =
211 {
212 /* Pseudo-ops which must be overridden. */
213 { "byte", ppc_byte, 0 },
214
215 #ifdef OBJ_XCOFF
216 /* Pseudo-ops specific to the RS/6000 XCOFF format. Some of these
217 legitimately belong in the obj-*.c file. However, XCOFF is based
218 on COFF, and is only implemented for the RS/6000. We just use
219 obj-coff.c, and add what we need here. */
220 { "comm", ppc_comm, 0 },
221 { "lcomm", ppc_comm, 1 },
222 { "bb", ppc_bb, 0 },
223 { "bc", ppc_bc, 0 },
224 { "bf", ppc_bf, 0 },
225 { "bi", ppc_biei, 0 },
226 { "bs", ppc_bs, 0 },
227 { "csect", ppc_csect, 0 },
228 { "dwsect", ppc_dwsect, 0 },
229 { "data", ppc_section, 'd' },
230 { "eb", ppc_eb, 0 },
231 { "ec", ppc_ec, 0 },
232 { "ef", ppc_ef, 0 },
233 { "ei", ppc_biei, 1 },
234 { "es", ppc_es, 0 },
235 { "extern", ppc_extern, 0 },
236 { "function", ppc_function, 0 },
237 { "lglobl", ppc_lglobl, 0 },
238 { "ref", ppc_ref, 0 },
239 { "rename", ppc_rename, 0 },
240 { "section", ppc_named_section, 0 },
241 { "stabx", ppc_stabx, 0 },
242 { "text", ppc_section, 't' },
243 { "toc", ppc_toc, 0 },
244 { "long", ppc_xcoff_cons, 2 },
245 { "llong", ppc_xcoff_cons, 3 },
246 { "word", ppc_xcoff_cons, 1 },
247 { "short", ppc_xcoff_cons, 1 },
248 { "vbyte", ppc_vbyte, 0 },
249 #endif
250
251 #ifdef OBJ_ELF
252 { "llong", ppc_elf_cons, 8 },
253 { "quad", ppc_elf_cons, 8 },
254 { "long", ppc_elf_cons, 4 },
255 { "word", ppc_elf_cons, 2 },
256 { "short", ppc_elf_cons, 2 },
257 { "rdata", ppc_elf_rdata, 0 },
258 { "rodata", ppc_elf_rdata, 0 },
259 { "lcomm", ppc_elf_lcomm, 0 },
260 #endif
261
262 #ifdef TE_PE
263 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
264 { "previous", ppc_previous, 0 },
265 { "pdata", ppc_pdata, 0 },
266 { "ydata", ppc_ydata, 0 },
267 { "reldata", ppc_reldata, 0 },
268 { "rdata", ppc_rdata, 0 },
269 { "ualong", ppc_ualong, 0 },
270 { "znop", ppc_znop, 0 },
271 { "comm", ppc_pe_comm, 0 },
272 { "lcomm", ppc_pe_comm, 1 },
273 { "section", ppc_pe_section, 0 },
274 { "function", ppc_pe_function,0 },
275 { "tocd", ppc_pe_tocd, 0 },
276 #endif
277
278 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
279 { "tc", ppc_tc, 0 },
280 { "machine", ppc_machine, 0 },
281 #endif
282
283 { NULL, NULL, 0 }
284 };
285
286 \f
287 /* Predefined register names if -mregnames (or default for Windows NT).
288 In general, there are lots of them, in an attempt to be compatible
289 with a number of other Windows NT assemblers. */
290
291 /* Structure to hold information about predefined registers. */
292 struct pd_reg
293 {
294 char *name;
295 int value;
296 };
297
298 /* List of registers that are pre-defined:
299
300 Each general register has predefined names of the form:
301 1. r<reg_num> which has the value <reg_num>.
302 2. r.<reg_num> which has the value <reg_num>.
303
304 Each floating point register has predefined names of the form:
305 1. f<reg_num> which has the value <reg_num>.
306 2. f.<reg_num> which has the value <reg_num>.
307
308 Each vector unit register has predefined names of the form:
309 1. v<reg_num> which has the value <reg_num>.
310 2. v.<reg_num> which has the value <reg_num>.
311
312 Each condition register has predefined names of the form:
313 1. cr<reg_num> which has the value <reg_num>.
314 2. cr.<reg_num> which has the value <reg_num>.
315
316 There are individual registers as well:
317 sp or r.sp has the value 1
318 rtoc or r.toc has the value 2
319 fpscr has the value 0
320 xer has the value 1
321 lr has the value 8
322 ctr has the value 9
323 pmr has the value 0
324 dar has the value 19
325 dsisr has the value 18
326 dec has the value 22
327 sdr1 has the value 25
328 srr0 has the value 26
329 srr1 has the value 27
330
331 The table is sorted. Suitable for searching by a binary search. */
332
333 static const struct pd_reg pre_defined_registers[] =
334 {
335 { "cr.0", 0 }, /* Condition Registers */
336 { "cr.1", 1 },
337 { "cr.2", 2 },
338 { "cr.3", 3 },
339 { "cr.4", 4 },
340 { "cr.5", 5 },
341 { "cr.6", 6 },
342 { "cr.7", 7 },
343
344 { "cr0", 0 },
345 { "cr1", 1 },
346 { "cr2", 2 },
347 { "cr3", 3 },
348 { "cr4", 4 },
349 { "cr5", 5 },
350 { "cr6", 6 },
351 { "cr7", 7 },
352
353 { "ctr", 9 },
354
355 { "dar", 19 }, /* Data Access Register */
356 { "dec", 22 }, /* Decrementer */
357 { "dsisr", 18 }, /* Data Storage Interrupt Status Register */
358
359 { "f.0", 0 }, /* Floating point registers */
360 { "f.1", 1 },
361 { "f.10", 10 },
362 { "f.11", 11 },
363 { "f.12", 12 },
364 { "f.13", 13 },
365 { "f.14", 14 },
366 { "f.15", 15 },
367 { "f.16", 16 },
368 { "f.17", 17 },
369 { "f.18", 18 },
370 { "f.19", 19 },
371 { "f.2", 2 },
372 { "f.20", 20 },
373 { "f.21", 21 },
374 { "f.22", 22 },
375 { "f.23", 23 },
376 { "f.24", 24 },
377 { "f.25", 25 },
378 { "f.26", 26 },
379 { "f.27", 27 },
380 { "f.28", 28 },
381 { "f.29", 29 },
382 { "f.3", 3 },
383 { "f.30", 30 },
384 { "f.31", 31 },
385
386 { "f.32", 32 }, /* Extended floating point scalar registers (ISA 2.06). */
387 { "f.33", 33 },
388 { "f.34", 34 },
389 { "f.35", 35 },
390 { "f.36", 36 },
391 { "f.37", 37 },
392 { "f.38", 38 },
393 { "f.39", 39 },
394 { "f.4", 4 },
395 { "f.40", 40 },
396 { "f.41", 41 },
397 { "f.42", 42 },
398 { "f.43", 43 },
399 { "f.44", 44 },
400 { "f.45", 45 },
401 { "f.46", 46 },
402 { "f.47", 47 },
403 { "f.48", 48 },
404 { "f.49", 49 },
405 { "f.5", 5 },
406 { "f.50", 50 },
407 { "f.51", 51 },
408 { "f.52", 52 },
409 { "f.53", 53 },
410 { "f.54", 54 },
411 { "f.55", 55 },
412 { "f.56", 56 },
413 { "f.57", 57 },
414 { "f.58", 58 },
415 { "f.59", 59 },
416 { "f.6", 6 },
417 { "f.60", 60 },
418 { "f.61", 61 },
419 { "f.62", 62 },
420 { "f.63", 63 },
421 { "f.7", 7 },
422 { "f.8", 8 },
423 { "f.9", 9 },
424
425 { "f0", 0 },
426 { "f1", 1 },
427 { "f10", 10 },
428 { "f11", 11 },
429 { "f12", 12 },
430 { "f13", 13 },
431 { "f14", 14 },
432 { "f15", 15 },
433 { "f16", 16 },
434 { "f17", 17 },
435 { "f18", 18 },
436 { "f19", 19 },
437 { "f2", 2 },
438 { "f20", 20 },
439 { "f21", 21 },
440 { "f22", 22 },
441 { "f23", 23 },
442 { "f24", 24 },
443 { "f25", 25 },
444 { "f26", 26 },
445 { "f27", 27 },
446 { "f28", 28 },
447 { "f29", 29 },
448 { "f3", 3 },
449 { "f30", 30 },
450 { "f31", 31 },
451
452 { "f32", 32 }, /* Extended floating point scalar registers (ISA 2.06). */
453 { "f33", 33 },
454 { "f34", 34 },
455 { "f35", 35 },
456 { "f36", 36 },
457 { "f37", 37 },
458 { "f38", 38 },
459 { "f39", 39 },
460 { "f4", 4 },
461 { "f40", 40 },
462 { "f41", 41 },
463 { "f42", 42 },
464 { "f43", 43 },
465 { "f44", 44 },
466 { "f45", 45 },
467 { "f46", 46 },
468 { "f47", 47 },
469 { "f48", 48 },
470 { "f49", 49 },
471 { "f5", 5 },
472 { "f50", 50 },
473 { "f51", 51 },
474 { "f52", 52 },
475 { "f53", 53 },
476 { "f54", 54 },
477 { "f55", 55 },
478 { "f56", 56 },
479 { "f57", 57 },
480 { "f58", 58 },
481 { "f59", 59 },
482 { "f6", 6 },
483 { "f60", 60 },
484 { "f61", 61 },
485 { "f62", 62 },
486 { "f63", 63 },
487 { "f7", 7 },
488 { "f8", 8 },
489 { "f9", 9 },
490
491 { "fpscr", 0 },
492
493 /* Quantization registers used with pair single instructions. */
494 { "gqr.0", 0 },
495 { "gqr.1", 1 },
496 { "gqr.2", 2 },
497 { "gqr.3", 3 },
498 { "gqr.4", 4 },
499 { "gqr.5", 5 },
500 { "gqr.6", 6 },
501 { "gqr.7", 7 },
502 { "gqr0", 0 },
503 { "gqr1", 1 },
504 { "gqr2", 2 },
505 { "gqr3", 3 },
506 { "gqr4", 4 },
507 { "gqr5", 5 },
508 { "gqr6", 6 },
509 { "gqr7", 7 },
510
511 { "lr", 8 }, /* Link Register */
512
513 { "pmr", 0 },
514
515 { "r.0", 0 }, /* General Purpose Registers */
516 { "r.1", 1 },
517 { "r.10", 10 },
518 { "r.11", 11 },
519 { "r.12", 12 },
520 { "r.13", 13 },
521 { "r.14", 14 },
522 { "r.15", 15 },
523 { "r.16", 16 },
524 { "r.17", 17 },
525 { "r.18", 18 },
526 { "r.19", 19 },
527 { "r.2", 2 },
528 { "r.20", 20 },
529 { "r.21", 21 },
530 { "r.22", 22 },
531 { "r.23", 23 },
532 { "r.24", 24 },
533 { "r.25", 25 },
534 { "r.26", 26 },
535 { "r.27", 27 },
536 { "r.28", 28 },
537 { "r.29", 29 },
538 { "r.3", 3 },
539 { "r.30", 30 },
540 { "r.31", 31 },
541 { "r.4", 4 },
542 { "r.5", 5 },
543 { "r.6", 6 },
544 { "r.7", 7 },
545 { "r.8", 8 },
546 { "r.9", 9 },
547
548 { "r.sp", 1 }, /* Stack Pointer */
549
550 { "r.toc", 2 }, /* Pointer to the table of contents */
551
552 { "r0", 0 }, /* More general purpose registers */
553 { "r1", 1 },
554 { "r10", 10 },
555 { "r11", 11 },
556 { "r12", 12 },
557 { "r13", 13 },
558 { "r14", 14 },
559 { "r15", 15 },
560 { "r16", 16 },
561 { "r17", 17 },
562 { "r18", 18 },
563 { "r19", 19 },
564 { "r2", 2 },
565 { "r20", 20 },
566 { "r21", 21 },
567 { "r22", 22 },
568 { "r23", 23 },
569 { "r24", 24 },
570 { "r25", 25 },
571 { "r26", 26 },
572 { "r27", 27 },
573 { "r28", 28 },
574 { "r29", 29 },
575 { "r3", 3 },
576 { "r30", 30 },
577 { "r31", 31 },
578 { "r4", 4 },
579 { "r5", 5 },
580 { "r6", 6 },
581 { "r7", 7 },
582 { "r8", 8 },
583 { "r9", 9 },
584
585 { "rtoc", 2 }, /* Table of contents */
586
587 { "sdr1", 25 }, /* Storage Description Register 1 */
588
589 { "sp", 1 },
590
591 { "srr0", 26 }, /* Machine Status Save/Restore Register 0 */
592 { "srr1", 27 }, /* Machine Status Save/Restore Register 1 */
593
594 { "v.0", 0 }, /* Vector (Altivec/VMX) registers */
595 { "v.1", 1 },
596 { "v.10", 10 },
597 { "v.11", 11 },
598 { "v.12", 12 },
599 { "v.13", 13 },
600 { "v.14", 14 },
601 { "v.15", 15 },
602 { "v.16", 16 },
603 { "v.17", 17 },
604 { "v.18", 18 },
605 { "v.19", 19 },
606 { "v.2", 2 },
607 { "v.20", 20 },
608 { "v.21", 21 },
609 { "v.22", 22 },
610 { "v.23", 23 },
611 { "v.24", 24 },
612 { "v.25", 25 },
613 { "v.26", 26 },
614 { "v.27", 27 },
615 { "v.28", 28 },
616 { "v.29", 29 },
617 { "v.3", 3 },
618 { "v.30", 30 },
619 { "v.31", 31 },
620 { "v.4", 4 },
621 { "v.5", 5 },
622 { "v.6", 6 },
623 { "v.7", 7 },
624 { "v.8", 8 },
625 { "v.9", 9 },
626
627 { "v0", 0 },
628 { "v1", 1 },
629 { "v10", 10 },
630 { "v11", 11 },
631 { "v12", 12 },
632 { "v13", 13 },
633 { "v14", 14 },
634 { "v15", 15 },
635 { "v16", 16 },
636 { "v17", 17 },
637 { "v18", 18 },
638 { "v19", 19 },
639 { "v2", 2 },
640 { "v20", 20 },
641 { "v21", 21 },
642 { "v22", 22 },
643 { "v23", 23 },
644 { "v24", 24 },
645 { "v25", 25 },
646 { "v26", 26 },
647 { "v27", 27 },
648 { "v28", 28 },
649 { "v29", 29 },
650 { "v3", 3 },
651 { "v30", 30 },
652 { "v31", 31 },
653 { "v4", 4 },
654 { "v5", 5 },
655 { "v6", 6 },
656 { "v7", 7 },
657 { "v8", 8 },
658 { "v9", 9 },
659
660 { "vs.0", 0 }, /* Vector Scalar (VSX) registers (ISA 2.06). */
661 { "vs.1", 1 },
662 { "vs.10", 10 },
663 { "vs.11", 11 },
664 { "vs.12", 12 },
665 { "vs.13", 13 },
666 { "vs.14", 14 },
667 { "vs.15", 15 },
668 { "vs.16", 16 },
669 { "vs.17", 17 },
670 { "vs.18", 18 },
671 { "vs.19", 19 },
672 { "vs.2", 2 },
673 { "vs.20", 20 },
674 { "vs.21", 21 },
675 { "vs.22", 22 },
676 { "vs.23", 23 },
677 { "vs.24", 24 },
678 { "vs.25", 25 },
679 { "vs.26", 26 },
680 { "vs.27", 27 },
681 { "vs.28", 28 },
682 { "vs.29", 29 },
683 { "vs.3", 3 },
684 { "vs.30", 30 },
685 { "vs.31", 31 },
686 { "vs.32", 32 },
687 { "vs.33", 33 },
688 { "vs.34", 34 },
689 { "vs.35", 35 },
690 { "vs.36", 36 },
691 { "vs.37", 37 },
692 { "vs.38", 38 },
693 { "vs.39", 39 },
694 { "vs.4", 4 },
695 { "vs.40", 40 },
696 { "vs.41", 41 },
697 { "vs.42", 42 },
698 { "vs.43", 43 },
699 { "vs.44", 44 },
700 { "vs.45", 45 },
701 { "vs.46", 46 },
702 { "vs.47", 47 },
703 { "vs.48", 48 },
704 { "vs.49", 49 },
705 { "vs.5", 5 },
706 { "vs.50", 50 },
707 { "vs.51", 51 },
708 { "vs.52", 52 },
709 { "vs.53", 53 },
710 { "vs.54", 54 },
711 { "vs.55", 55 },
712 { "vs.56", 56 },
713 { "vs.57", 57 },
714 { "vs.58", 58 },
715 { "vs.59", 59 },
716 { "vs.6", 6 },
717 { "vs.60", 60 },
718 { "vs.61", 61 },
719 { "vs.62", 62 },
720 { "vs.63", 63 },
721 { "vs.7", 7 },
722 { "vs.8", 8 },
723 { "vs.9", 9 },
724
725 { "vs0", 0 },
726 { "vs1", 1 },
727 { "vs10", 10 },
728 { "vs11", 11 },
729 { "vs12", 12 },
730 { "vs13", 13 },
731 { "vs14", 14 },
732 { "vs15", 15 },
733 { "vs16", 16 },
734 { "vs17", 17 },
735 { "vs18", 18 },
736 { "vs19", 19 },
737 { "vs2", 2 },
738 { "vs20", 20 },
739 { "vs21", 21 },
740 { "vs22", 22 },
741 { "vs23", 23 },
742 { "vs24", 24 },
743 { "vs25", 25 },
744 { "vs26", 26 },
745 { "vs27", 27 },
746 { "vs28", 28 },
747 { "vs29", 29 },
748 { "vs3", 3 },
749 { "vs30", 30 },
750 { "vs31", 31 },
751 { "vs32", 32 },
752 { "vs33", 33 },
753 { "vs34", 34 },
754 { "vs35", 35 },
755 { "vs36", 36 },
756 { "vs37", 37 },
757 { "vs38", 38 },
758 { "vs39", 39 },
759 { "vs4", 4 },
760 { "vs40", 40 },
761 { "vs41", 41 },
762 { "vs42", 42 },
763 { "vs43", 43 },
764 { "vs44", 44 },
765 { "vs45", 45 },
766 { "vs46", 46 },
767 { "vs47", 47 },
768 { "vs48", 48 },
769 { "vs49", 49 },
770 { "vs5", 5 },
771 { "vs50", 50 },
772 { "vs51", 51 },
773 { "vs52", 52 },
774 { "vs53", 53 },
775 { "vs54", 54 },
776 { "vs55", 55 },
777 { "vs56", 56 },
778 { "vs57", 57 },
779 { "vs58", 58 },
780 { "vs59", 59 },
781 { "vs6", 6 },
782 { "vs60", 60 },
783 { "vs61", 61 },
784 { "vs62", 62 },
785 { "vs63", 63 },
786 { "vs7", 7 },
787 { "vs8", 8 },
788 { "vs9", 9 },
789
790 { "xer", 1 },
791
792 };
793
794 #define REG_NAME_CNT (sizeof (pre_defined_registers) / sizeof (struct pd_reg))
795
796 /* Given NAME, find the register number associated with that name, return
797 the integer value associated with the given name or -1 on failure. */
798
799 static int
800 reg_name_search (const struct pd_reg *regs, int regcount, const char *name)
801 {
802 int middle, low, high;
803 int cmp;
804
805 low = 0;
806 high = regcount - 1;
807
808 do
809 {
810 middle = (low + high) / 2;
811 cmp = strcasecmp (name, regs[middle].name);
812 if (cmp < 0)
813 high = middle - 1;
814 else if (cmp > 0)
815 low = middle + 1;
816 else
817 return regs[middle].value;
818 }
819 while (low <= high);
820
821 return -1;
822 }
823
824 /*
825 * Summary of register_name.
826 *
827 * in: Input_line_pointer points to 1st char of operand.
828 *
829 * out: A expressionS.
830 * The operand may have been a register: in this case, X_op == O_register,
831 * X_add_number is set to the register number, and truth is returned.
832 * Input_line_pointer->(next non-blank) char after operand, or is in its
833 * original state.
834 */
835
836 static bfd_boolean
837 register_name (expressionS *expressionP)
838 {
839 int reg_number;
840 char *name;
841 char *start;
842 char c;
843
844 /* Find the spelling of the operand. */
845 start = name = input_line_pointer;
846 if (name[0] == '%' && ISALPHA (name[1]))
847 name = ++input_line_pointer;
848
849 else if (!reg_names_p || !ISALPHA (name[0]))
850 return FALSE;
851
852 c = get_symbol_end ();
853 reg_number = reg_name_search (pre_defined_registers, REG_NAME_CNT, name);
854
855 /* Put back the delimiting char. */
856 *input_line_pointer = c;
857
858 /* Look to see if it's in the register table. */
859 if (reg_number >= 0)
860 {
861 expressionP->X_op = O_register;
862 expressionP->X_add_number = reg_number;
863
864 /* Make the rest nice. */
865 expressionP->X_add_symbol = NULL;
866 expressionP->X_op_symbol = NULL;
867 return TRUE;
868 }
869
870 /* Reset the line as if we had not done anything. */
871 input_line_pointer = start;
872 return FALSE;
873 }
874 \f
875 /* This function is called for each symbol seen in an expression. It
876 handles the special parsing which PowerPC assemblers are supposed
877 to use for condition codes. */
878
879 /* Whether to do the special parsing. */
880 static bfd_boolean cr_operand;
881
882 /* Names to recognize in a condition code. This table is sorted. */
883 static const struct pd_reg cr_names[] =
884 {
885 { "cr0", 0 },
886 { "cr1", 1 },
887 { "cr2", 2 },
888 { "cr3", 3 },
889 { "cr4", 4 },
890 { "cr5", 5 },
891 { "cr6", 6 },
892 { "cr7", 7 },
893 { "eq", 2 },
894 { "gt", 1 },
895 { "lt", 0 },
896 { "so", 3 },
897 { "un", 3 }
898 };
899
900 /* Parsing function. This returns non-zero if it recognized an
901 expression. */
902
903 int
904 ppc_parse_name (const char *name, expressionS *exp)
905 {
906 int val;
907
908 if (! cr_operand)
909 return 0;
910
911 if (*name == '%')
912 ++name;
913 val = reg_name_search (cr_names, sizeof cr_names / sizeof cr_names[0],
914 name);
915 if (val < 0)
916 return 0;
917
918 exp->X_op = O_constant;
919 exp->X_add_number = val;
920
921 return 1;
922 }
923 \f
924 /* Local variables. */
925
926 /* Whether to target xcoff64/elf64. */
927 static unsigned int ppc_obj64 = BFD_DEFAULT_TARGET_SIZE == 64;
928
929 /* Opcode hash table. */
930 static struct hash_control *ppc_hash;
931
932 /* Macro hash table. */
933 static struct hash_control *ppc_macro_hash;
934
935 #ifdef OBJ_ELF
936 /* What type of shared library support to use. */
937 static enum { SHLIB_NONE, SHLIB_PIC, SHLIB_MRELOCATABLE } shlib = SHLIB_NONE;
938
939 /* Flags to set in the elf header. */
940 static flagword ppc_flags = 0;
941
942 /* Whether this is Solaris or not. */
943 #ifdef TARGET_SOLARIS_COMMENT
944 #define SOLARIS_P TRUE
945 #else
946 #define SOLARIS_P FALSE
947 #endif
948
949 static bfd_boolean msolaris = SOLARIS_P;
950 #endif
951
952 #ifdef OBJ_XCOFF
953
954 /* The RS/6000 assembler uses the .csect pseudo-op to generate code
955 using a bunch of different sections. These assembler sections,
956 however, are all encompassed within the .text or .data sections of
957 the final output file. We handle this by using different
958 subsegments within these main segments. */
959
960 /* Next subsegment to allocate within the .text segment. */
961 static subsegT ppc_text_subsegment = 2;
962
963 /* Linked list of csects in the text section. */
964 static symbolS *ppc_text_csects;
965
966 /* Next subsegment to allocate within the .data segment. */
967 static subsegT ppc_data_subsegment = 2;
968
969 /* Linked list of csects in the data section. */
970 static symbolS *ppc_data_csects;
971
972 /* The current csect. */
973 static symbolS *ppc_current_csect;
974
975 /* The RS/6000 assembler uses a TOC which holds addresses of functions
976 and variables. Symbols are put in the TOC with the .tc pseudo-op.
977 A special relocation is used when accessing TOC entries. We handle
978 the TOC as a subsegment within the .data segment. We set it up if
979 we see a .toc pseudo-op, and save the csect symbol here. */
980 static symbolS *ppc_toc_csect;
981
982 /* The first frag in the TOC subsegment. */
983 static fragS *ppc_toc_frag;
984
985 /* The first frag in the first subsegment after the TOC in the .data
986 segment. NULL if there are no subsegments after the TOC. */
987 static fragS *ppc_after_toc_frag;
988
989 /* The current static block. */
990 static symbolS *ppc_current_block;
991
992 /* The COFF debugging section; set by md_begin. This is not the
993 .debug section, but is instead the secret BFD section which will
994 cause BFD to set the section number of a symbol to N_DEBUG. */
995 static asection *ppc_coff_debug_section;
996
997 /* Structure to set the length field of the dwarf sections. */
998 struct dw_subsection {
999 /* Subsections are simply linked. */
1000 struct dw_subsection *link;
1001
1002 /* The subsection number. */
1003 subsegT subseg;
1004
1005 /* Expression to compute the length of the section. */
1006 expressionS end_exp;
1007 };
1008
1009 static struct dw_section {
1010 /* Corresponding section. */
1011 segT sect;
1012
1013 /* Simply linked list of subsections with a label. */
1014 struct dw_subsection *list_subseg;
1015
1016 /* The anonymous subsection. */
1017 struct dw_subsection *anon_subseg;
1018 } dw_sections[XCOFF_DWSECT_NBR_NAMES];
1019 #endif /* OBJ_XCOFF */
1020
1021 #ifdef TE_PE
1022
1023 /* Various sections that we need for PE coff support. */
1024 static segT ydata_section;
1025 static segT pdata_section;
1026 static segT reldata_section;
1027 static segT rdata_section;
1028 static segT tocdata_section;
1029
1030 /* The current section and the previous section. See ppc_previous. */
1031 static segT ppc_previous_section;
1032 static segT ppc_current_section;
1033
1034 #endif /* TE_PE */
1035
1036 #ifdef OBJ_ELF
1037 symbolS *GOT_symbol; /* Pre-defined "_GLOBAL_OFFSET_TABLE" */
1038 #define PPC_APUINFO_ISEL 0x40
1039 #define PPC_APUINFO_PMR 0x41
1040 #define PPC_APUINFO_RFMCI 0x42
1041 #define PPC_APUINFO_CACHELCK 0x43
1042 #define PPC_APUINFO_SPE 0x100
1043 #define PPC_APUINFO_EFS 0x101
1044 #define PPC_APUINFO_BRLOCK 0x102
1045 #define PPC_APUINFO_VLE 0x104
1046
1047 /*
1048 * We keep a list of APUinfo
1049 */
1050 unsigned long *ppc_apuinfo_list;
1051 unsigned int ppc_apuinfo_num;
1052 unsigned int ppc_apuinfo_num_alloc;
1053 #endif /* OBJ_ELF */
1054 \f
1055 #ifdef OBJ_ELF
1056 const char *const md_shortopts = "b:l:usm:K:VQ:";
1057 #else
1058 const char *const md_shortopts = "um:";
1059 #endif
1060 #define OPTION_NOPS (OPTION_MD_BASE + 0)
1061 const struct option md_longopts[] = {
1062 {"nops", required_argument, NULL, OPTION_NOPS},
1063 {NULL, no_argument, NULL, 0}
1064 };
1065 const size_t md_longopts_size = sizeof (md_longopts);
1066
1067 int
1068 md_parse_option (int c, char *arg)
1069 {
1070 ppc_cpu_t new_cpu;
1071
1072 switch (c)
1073 {
1074 case 'u':
1075 /* -u means that any undefined symbols should be treated as
1076 external, which is the default for gas anyhow. */
1077 break;
1078
1079 #ifdef OBJ_ELF
1080 case 'l':
1081 /* Solaris as takes -le (presumably for little endian). For completeness
1082 sake, recognize -be also. */
1083 if (strcmp (arg, "e") == 0)
1084 {
1085 target_big_endian = 0;
1086 set_target_endian = 1;
1087 if (ppc_cpu & PPC_OPCODE_VLE)
1088 as_bad (_("the use of -mvle requires big endian."));
1089 }
1090 else
1091 return 0;
1092
1093 break;
1094
1095 case 'b':
1096 if (strcmp (arg, "e") == 0)
1097 {
1098 target_big_endian = 1;
1099 set_target_endian = 1;
1100 }
1101 else
1102 return 0;
1103
1104 break;
1105
1106 case 'K':
1107 /* Recognize -K PIC. */
1108 if (strcmp (arg, "PIC") == 0 || strcmp (arg, "pic") == 0)
1109 {
1110 shlib = SHLIB_PIC;
1111 ppc_flags |= EF_PPC_RELOCATABLE_LIB;
1112 }
1113 else
1114 return 0;
1115
1116 break;
1117 #endif
1118
1119 /* a64 and a32 determine whether to use XCOFF64 or XCOFF32. */
1120 case 'a':
1121 if (strcmp (arg, "64") == 0)
1122 {
1123 #ifdef BFD64
1124 ppc_obj64 = 1;
1125 if (ppc_cpu & PPC_OPCODE_VLE)
1126 as_bad (_("the use of -mvle requires -a32."));
1127 #else
1128 as_fatal (_("%s unsupported"), "-a64");
1129 #endif
1130 }
1131 else if (strcmp (arg, "32") == 0)
1132 ppc_obj64 = 0;
1133 else
1134 return 0;
1135 break;
1136
1137 case 'm':
1138 new_cpu = ppc_parse_cpu (ppc_cpu, &sticky, arg);
1139 if (new_cpu != 0)
1140 {
1141 ppc_cpu = new_cpu;
1142 if (strcmp (arg, "vle") == 0)
1143 {
1144 if (set_target_endian && target_big_endian == 0)
1145 as_bad (_("the use of -mvle requires big endian."));
1146 if (ppc_obj64)
1147 as_bad (_("the use of -mvle requires -a32."));
1148 }
1149 }
1150
1151 else if (strcmp (arg, "regnames") == 0)
1152 reg_names_p = TRUE;
1153
1154 else if (strcmp (arg, "no-regnames") == 0)
1155 reg_names_p = FALSE;
1156
1157 #ifdef OBJ_ELF
1158 /* -mrelocatable/-mrelocatable-lib -- warn about initializations
1159 that require relocation. */
1160 else if (strcmp (arg, "relocatable") == 0)
1161 {
1162 shlib = SHLIB_MRELOCATABLE;
1163 ppc_flags |= EF_PPC_RELOCATABLE;
1164 }
1165
1166 else if (strcmp (arg, "relocatable-lib") == 0)
1167 {
1168 shlib = SHLIB_MRELOCATABLE;
1169 ppc_flags |= EF_PPC_RELOCATABLE_LIB;
1170 }
1171
1172 /* -memb, set embedded bit. */
1173 else if (strcmp (arg, "emb") == 0)
1174 ppc_flags |= EF_PPC_EMB;
1175
1176 /* -mlittle/-mbig set the endianness. */
1177 else if (strcmp (arg, "little") == 0
1178 || strcmp (arg, "little-endian") == 0)
1179 {
1180 target_big_endian = 0;
1181 set_target_endian = 1;
1182 if (ppc_cpu & PPC_OPCODE_VLE)
1183 as_bad (_("the use of -mvle requires big endian."));
1184 }
1185
1186 else if (strcmp (arg, "big") == 0 || strcmp (arg, "big-endian") == 0)
1187 {
1188 target_big_endian = 1;
1189 set_target_endian = 1;
1190 }
1191
1192 else if (strcmp (arg, "solaris") == 0)
1193 {
1194 msolaris = TRUE;
1195 ppc_comment_chars = ppc_solaris_comment_chars;
1196 }
1197
1198 else if (strcmp (arg, "no-solaris") == 0)
1199 {
1200 msolaris = FALSE;
1201 ppc_comment_chars = ppc_eabi_comment_chars;
1202 }
1203 #endif
1204 else
1205 {
1206 as_bad (_("invalid switch -m%s"), arg);
1207 return 0;
1208 }
1209 break;
1210
1211 #ifdef OBJ_ELF
1212 /* -V: SVR4 argument to print version ID. */
1213 case 'V':
1214 print_version_id ();
1215 break;
1216
1217 /* -Qy, -Qn: SVR4 arguments controlling whether a .comment section
1218 should be emitted or not. FIXME: Not implemented. */
1219 case 'Q':
1220 break;
1221
1222 /* Solaris takes -s to specify that .stabs go in a .stabs section,
1223 rather than .stabs.excl, which is ignored by the linker.
1224 FIXME: Not implemented. */
1225 case 's':
1226 if (arg)
1227 return 0;
1228
1229 break;
1230 #endif
1231
1232 case OPTION_NOPS:
1233 {
1234 char *end;
1235 nop_limit = strtoul (optarg, &end, 0);
1236 if (*end)
1237 as_bad (_("--nops needs a numeric argument"));
1238 }
1239 break;
1240
1241 default:
1242 return 0;
1243 }
1244
1245 return 1;
1246 }
1247
1248 void
1249 md_show_usage (FILE *stream)
1250 {
1251 fprintf (stream, _("\
1252 PowerPC options:\n\
1253 -a32 generate ELF32/XCOFF32\n\
1254 -a64 generate ELF64/XCOFF64\n\
1255 -u ignored\n\
1256 -mpwrx, -mpwr2 generate code for POWER/2 (RIOS2)\n\
1257 -mpwr generate code for POWER (RIOS1)\n\
1258 -m601 generate code for PowerPC 601\n\
1259 -mppc, -mppc32, -m603, -m604\n\
1260 generate code for PowerPC 603/604\n\
1261 -m403 generate code for PowerPC 403\n\
1262 -m405 generate code for PowerPC 405\n\
1263 -m440 generate code for PowerPC 440\n\
1264 -m464 generate code for PowerPC 464\n\
1265 -m476 generate code for PowerPC 476\n\
1266 -m7400, -m7410, -m7450, -m7455\n\
1267 generate code for PowerPC 7400/7410/7450/7455\n\
1268 -m750cl generate code for PowerPC 750cl\n"));
1269 fprintf (stream, _("\
1270 -mppc64, -m620 generate code for PowerPC 620/625/630\n\
1271 -mppc64bridge generate code for PowerPC 64, including bridge insns\n\
1272 -mbooke generate code for 32-bit PowerPC BookE\n\
1273 -ma2 generate code for A2 architecture\n\
1274 -mpower4, -mpwr4 generate code for Power4 architecture\n\
1275 -mpower5, -mpwr5, -mpwr5x\n\
1276 generate code for Power5 architecture\n\
1277 -mpower6, -mpwr6 generate code for Power6 architecture\n\
1278 -mpower7, -mpwr7 generate code for Power7 architecture\n\
1279 -mpower8, -mpwr8 generate code for Power8 architecture\n\
1280 -mcell generate code for Cell Broadband Engine architecture\n\
1281 -mcom generate code Power/PowerPC common instructions\n\
1282 -many generate code for any architecture (PWR/PWRX/PPC)\n"));
1283 fprintf (stream, _("\
1284 -maltivec generate code for AltiVec\n\
1285 -mvsx generate code for Vector-Scalar (VSX) instructions\n\
1286 -mhtm generate code for Hardware Transactional Memory\n\
1287 -me300 generate code for PowerPC e300 family\n\
1288 -me500, -me500x2 generate code for Motorola e500 core complex\n\
1289 -me500mc, generate code for Freescale e500mc core complex\n\
1290 -me500mc64, generate code for Freescale e500mc64 core complex\n\
1291 -me5500, generate code for Freescale e5500 core complex\n\
1292 -me6500, generate code for Freescale e6500 core complex\n\
1293 -mspe generate code for Motorola SPE instructions\n\
1294 -mvle generate code for Freescale VLE instructions\n\
1295 -mtitan generate code for AppliedMicro Titan core complex\n\
1296 -mregnames Allow symbolic names for registers\n\
1297 -mno-regnames Do not allow symbolic names for registers\n"));
1298 #ifdef OBJ_ELF
1299 fprintf (stream, _("\
1300 -mrelocatable support for GCC's -mrelocatble option\n\
1301 -mrelocatable-lib support for GCC's -mrelocatble-lib option\n\
1302 -memb set PPC_EMB bit in ELF flags\n\
1303 -mlittle, -mlittle-endian, -le\n\
1304 generate code for a little endian machine\n\
1305 -mbig, -mbig-endian, -be\n\
1306 generate code for a big endian machine\n\
1307 -msolaris generate code for Solaris\n\
1308 -mno-solaris do not generate code for Solaris\n\
1309 -K PIC set EF_PPC_RELOCATABLE_LIB in ELF flags\n\
1310 -V print assembler version number\n\
1311 -Qy, -Qn ignored\n"));
1312 #endif
1313 fprintf (stream, _("\
1314 -nops=count when aligning, more than COUNT nops uses a branch\n"));
1315 }
1316 \f
1317 /* Set ppc_cpu if it is not already set. */
1318
1319 static void
1320 ppc_set_cpu (void)
1321 {
1322 const char *default_os = TARGET_OS;
1323 const char *default_cpu = TARGET_CPU;
1324
1325 if ((ppc_cpu & ~(ppc_cpu_t) PPC_OPCODE_ANY) == 0)
1326 {
1327 if (ppc_obj64)
1328 ppc_cpu |= PPC_OPCODE_PPC | PPC_OPCODE_64;
1329 else if (strncmp (default_os, "aix", 3) == 0
1330 && default_os[3] >= '4' && default_os[3] <= '9')
1331 ppc_cpu |= PPC_OPCODE_COMMON;
1332 else if (strncmp (default_os, "aix3", 4) == 0)
1333 ppc_cpu |= PPC_OPCODE_POWER;
1334 else if (strcmp (default_cpu, "rs6000") == 0)
1335 ppc_cpu |= PPC_OPCODE_POWER;
1336 else if (strncmp (default_cpu, "powerpc", 7) == 0)
1337 ppc_cpu |= PPC_OPCODE_PPC;
1338 else
1339 as_fatal (_("unknown default cpu = %s, os = %s"),
1340 default_cpu, default_os);
1341 }
1342 }
1343
1344 /* Figure out the BFD architecture to use. This function and ppc_mach
1345 are called well before md_begin, when the output file is opened. */
1346
1347 enum bfd_architecture
1348 ppc_arch (void)
1349 {
1350 const char *default_cpu = TARGET_CPU;
1351 ppc_set_cpu ();
1352
1353 if ((ppc_cpu & PPC_OPCODE_PPC) != 0)
1354 return bfd_arch_powerpc;
1355 if ((ppc_cpu & PPC_OPCODE_VLE) != 0)
1356 return bfd_arch_powerpc;
1357 if ((ppc_cpu & PPC_OPCODE_POWER) != 0)
1358 return bfd_arch_rs6000;
1359 if ((ppc_cpu & (PPC_OPCODE_COMMON | PPC_OPCODE_ANY)) != 0)
1360 {
1361 if (strcmp (default_cpu, "rs6000") == 0)
1362 return bfd_arch_rs6000;
1363 else if (strncmp (default_cpu, "powerpc", 7) == 0)
1364 return bfd_arch_powerpc;
1365 }
1366
1367 as_fatal (_("neither Power nor PowerPC opcodes were selected."));
1368 return bfd_arch_unknown;
1369 }
1370
1371 unsigned long
1372 ppc_mach (void)
1373 {
1374 if (ppc_obj64)
1375 return bfd_mach_ppc64;
1376 else if (ppc_arch () == bfd_arch_rs6000)
1377 return bfd_mach_rs6k;
1378 else if (ppc_cpu & PPC_OPCODE_TITAN)
1379 return bfd_mach_ppc_titan;
1380 else if (ppc_cpu & PPC_OPCODE_VLE)
1381 return bfd_mach_ppc_vle;
1382 else
1383 return bfd_mach_ppc;
1384 }
1385
1386 extern char*
1387 ppc_target_format (void)
1388 {
1389 #ifdef OBJ_COFF
1390 #ifdef TE_PE
1391 return target_big_endian ? "pe-powerpc" : "pe-powerpcle";
1392 #elif TE_POWERMAC
1393 return "xcoff-powermac";
1394 #else
1395 # ifdef TE_AIX5
1396 return (ppc_obj64 ? "aix5coff64-rs6000" : "aixcoff-rs6000");
1397 # else
1398 return (ppc_obj64 ? "aixcoff64-rs6000" : "aixcoff-rs6000");
1399 # endif
1400 #endif
1401 #endif
1402 #ifdef OBJ_ELF
1403 # ifdef TE_FreeBSD
1404 return (ppc_obj64 ? "elf64-powerpc-freebsd" : "elf32-powerpc-freebsd");
1405 # elif defined (TE_VXWORKS)
1406 return "elf32-powerpc-vxworks";
1407 # else
1408 return (target_big_endian
1409 ? (ppc_obj64 ? "elf64-powerpc" : "elf32-powerpc")
1410 : (ppc_obj64 ? "elf64-powerpcle" : "elf32-powerpcle"));
1411 # endif
1412 #endif
1413 }
1414
1415 /* Validate one entry in powerpc_opcodes[] or vle_opcodes[].
1416 Return TRUE if there's a problem, otherwise FALSE. */
1417
1418 static bfd_boolean
1419 insn_validate (const struct powerpc_opcode *op)
1420 {
1421 const unsigned char *o;
1422 unsigned long omask = op->mask;
1423
1424 /* The mask had better not trim off opcode bits. */
1425 if ((op->opcode & omask) != op->opcode)
1426 {
1427 as_bad (_("mask trims opcode bits for %s"), op->name);
1428 return TRUE;
1429 }
1430
1431 /* The operands must not overlap the opcode or each other. */
1432 for (o = op->operands; *o; ++o)
1433 {
1434 if (*o >= num_powerpc_operands)
1435 {
1436 as_bad (_("operand index error for %s"), op->name);
1437 return TRUE;
1438 }
1439 else
1440 {
1441 const struct powerpc_operand *operand = &powerpc_operands[*o];
1442 if (operand->shift != PPC_OPSHIFT_INV)
1443 {
1444 unsigned long mask;
1445
1446 if (operand->shift >= 0)
1447 mask = operand->bitm << operand->shift;
1448 else
1449 mask = operand->bitm >> -operand->shift;
1450 if (omask & mask)
1451 {
1452 as_bad (_("operand %d overlap in %s"),
1453 (int) (o - op->operands), op->name);
1454 return TRUE;
1455 }
1456 omask |= mask;
1457 }
1458 }
1459 }
1460 return FALSE;
1461 }
1462
1463 /* Insert opcodes and macros into hash tables. Called at startup and
1464 for .machine pseudo. */
1465
1466 static void
1467 ppc_setup_opcodes (void)
1468 {
1469 const struct powerpc_opcode *op;
1470 const struct powerpc_opcode *op_end;
1471 const struct powerpc_macro *macro;
1472 const struct powerpc_macro *macro_end;
1473 bfd_boolean bad_insn = FALSE;
1474
1475 if (ppc_hash != NULL)
1476 hash_die (ppc_hash);
1477 if (ppc_macro_hash != NULL)
1478 hash_die (ppc_macro_hash);
1479
1480 /* Insert the opcodes into a hash table. */
1481 ppc_hash = hash_new ();
1482
1483 if (ENABLE_CHECKING)
1484 {
1485 unsigned int i;
1486
1487 /* An index into powerpc_operands is stored in struct fix
1488 fx_pcrel_adjust which is 8 bits wide. */
1489 gas_assert (num_powerpc_operands < 256);
1490
1491 /* Check operand masks. Code here and in the disassembler assumes
1492 all the 1's in the mask are contiguous. */
1493 for (i = 0; i < num_powerpc_operands; ++i)
1494 {
1495 unsigned long mask = powerpc_operands[i].bitm;
1496 unsigned long right_bit;
1497 unsigned int j;
1498
1499 right_bit = mask & -mask;
1500 mask += right_bit;
1501 right_bit = mask & -mask;
1502 if (mask != right_bit)
1503 {
1504 as_bad (_("powerpc_operands[%d].bitm invalid"), i);
1505 bad_insn = TRUE;
1506 }
1507 for (j = i + 1; j < num_powerpc_operands; ++j)
1508 if (memcmp (&powerpc_operands[i], &powerpc_operands[j],
1509 sizeof (powerpc_operands[0])) == 0)
1510 {
1511 as_bad (_("powerpc_operands[%d] duplicates powerpc_operands[%d]"),
1512 j, i);
1513 bad_insn = TRUE;
1514 }
1515 }
1516 }
1517
1518 op_end = powerpc_opcodes + powerpc_num_opcodes;
1519 for (op = powerpc_opcodes; op < op_end; op++)
1520 {
1521 if (ENABLE_CHECKING)
1522 {
1523 if (op != powerpc_opcodes)
1524 {
1525 int old_opcode = PPC_OP (op[-1].opcode);
1526 int new_opcode = PPC_OP (op[0].opcode);
1527
1528 #ifdef PRINT_OPCODE_TABLE
1529 printf ("%-14s\t#%04d\tmajor op: 0x%x\top: 0x%x\tmask: 0x%x\tflags: 0x%llx\n",
1530 op->name, op - powerpc_opcodes, (unsigned int) new_opcode,
1531 (unsigned int) op->opcode, (unsigned int) op->mask,
1532 (unsigned long long) op->flags);
1533 #endif
1534
1535 /* The major opcodes had better be sorted. Code in the
1536 disassembler assumes the insns are sorted according to
1537 major opcode. */
1538 if (new_opcode < old_opcode)
1539 {
1540 as_bad (_("major opcode is not sorted for %s"),
1541 op->name);
1542 bad_insn = TRUE;
1543 }
1544 }
1545 bad_insn |= insn_validate (op);
1546 }
1547
1548 if ((ppc_cpu & op->flags) != 0
1549 && !(ppc_cpu & op->deprecated))
1550 {
1551 const char *retval;
1552
1553 retval = hash_insert (ppc_hash, op->name, (void *) op);
1554 if (retval != NULL)
1555 {
1556 as_bad (_("duplicate instruction %s"),
1557 op->name);
1558 bad_insn = TRUE;
1559 }
1560 }
1561 }
1562
1563 if ((ppc_cpu & PPC_OPCODE_ANY) != 0)
1564 for (op = powerpc_opcodes; op < op_end; op++)
1565 hash_insert (ppc_hash, op->name, (void *) op);
1566
1567 op_end = vle_opcodes + vle_num_opcodes;
1568 for (op = vle_opcodes; op < op_end; op++)
1569 {
1570 if (ENABLE_CHECKING)
1571 {
1572 if (op != vle_opcodes)
1573 {
1574 unsigned old_seg, new_seg;
1575
1576 old_seg = VLE_OP (op[-1].opcode, op[-1].mask);
1577 old_seg = VLE_OP_TO_SEG (old_seg);
1578 new_seg = VLE_OP (op[0].opcode, op[0].mask);
1579 new_seg = VLE_OP_TO_SEG (new_seg);
1580
1581 #ifdef PRINT_OPCODE_TABLE
1582 printf ("%-14s\t#%04d\tmajor op: 0x%x\top: 0x%x\tmask: 0x%x\tflags: 0x%llx\n",
1583 op->name, op - powerpc_opcodes, (unsigned int) new_opcode,
1584 (unsigned int) op->opcode, (unsigned int) op->mask,
1585 (unsigned long long) op->flags);
1586 #endif
1587 /* The major opcodes had better be sorted. Code in the
1588 disassembler assumes the insns are sorted according to
1589 major opcode. */
1590 if (new_seg < old_seg)
1591 {
1592 as_bad (_("major opcode is not sorted for %s"),
1593 op->name);
1594 bad_insn = TRUE;
1595 }
1596 }
1597
1598 bad_insn |= insn_validate (op);
1599 }
1600
1601 if ((ppc_cpu & op->flags) != 0
1602 && !(ppc_cpu & op->deprecated))
1603 {
1604 const char *retval;
1605
1606 retval = hash_insert (ppc_hash, op->name, (void *) op);
1607 if (retval != NULL)
1608 {
1609 as_bad (_("duplicate instruction %s"),
1610 op->name);
1611 bad_insn = TRUE;
1612 }
1613 }
1614 }
1615
1616 if ((ppc_cpu & PPC_OPCODE_VLE) != 0)
1617 for (op = vle_opcodes; op < op_end; op++)
1618 hash_insert (ppc_hash, op->name, (void *) op);
1619
1620 /* Insert the macros into a hash table. */
1621 ppc_macro_hash = hash_new ();
1622
1623 macro_end = powerpc_macros + powerpc_num_macros;
1624 for (macro = powerpc_macros; macro < macro_end; macro++)
1625 {
1626 if ((macro->flags & ppc_cpu) != 0 || (ppc_cpu & PPC_OPCODE_ANY) != 0)
1627 {
1628 const char *retval;
1629
1630 retval = hash_insert (ppc_macro_hash, macro->name, (void *) macro);
1631 if (retval != (const char *) NULL)
1632 {
1633 as_bad (_("duplicate macro %s"), macro->name);
1634 bad_insn = TRUE;
1635 }
1636 }
1637 }
1638
1639 if (bad_insn)
1640 abort ();
1641 }
1642
1643 /* This function is called when the assembler starts up. It is called
1644 after the options have been parsed and the output file has been
1645 opened. */
1646
1647 void
1648 md_begin (void)
1649 {
1650 ppc_set_cpu ();
1651
1652 ppc_cie_data_alignment = ppc_obj64 ? -8 : -4;
1653 ppc_dwarf2_line_min_insn_length = (ppc_cpu & PPC_OPCODE_VLE) ? 2 : 4;
1654
1655 #ifdef OBJ_ELF
1656 /* Set the ELF flags if desired. */
1657 if (ppc_flags && !msolaris)
1658 bfd_set_private_flags (stdoutput, ppc_flags);
1659 #endif
1660
1661 ppc_setup_opcodes ();
1662
1663 /* Tell the main code what the endianness is if it is not overridden
1664 by the user. */
1665 if (!set_target_endian)
1666 {
1667 set_target_endian = 1;
1668 target_big_endian = PPC_BIG_ENDIAN;
1669 }
1670
1671 #ifdef OBJ_XCOFF
1672 ppc_coff_debug_section = coff_section_from_bfd_index (stdoutput, N_DEBUG);
1673
1674 /* Create dummy symbols to serve as initial csects. This forces the
1675 text csects to precede the data csects. These symbols will not
1676 be output. */
1677 ppc_text_csects = symbol_make ("dummy\001");
1678 symbol_get_tc (ppc_text_csects)->within = ppc_text_csects;
1679 ppc_data_csects = symbol_make ("dummy\001");
1680 symbol_get_tc (ppc_data_csects)->within = ppc_data_csects;
1681 #endif
1682
1683 #ifdef TE_PE
1684
1685 ppc_current_section = text_section;
1686 ppc_previous_section = 0;
1687
1688 #endif
1689 }
1690
1691 void
1692 ppc_cleanup (void)
1693 {
1694 #ifdef OBJ_ELF
1695 if (ppc_apuinfo_list == NULL)
1696 return;
1697
1698 /* Ok, so write the section info out. We have this layout:
1699
1700 byte data what
1701 ---- ---- ----
1702 0 8 length of "APUinfo\0"
1703 4 (n*4) number of APU's (4 bytes each)
1704 8 2 note type 2
1705 12 "APUinfo\0" name
1706 20 APU#1 first APU's info
1707 24 APU#2 second APU's info
1708 ... ...
1709 */
1710 {
1711 char *p;
1712 asection *seg = now_seg;
1713 subsegT subseg = now_subseg;
1714 asection *apuinfo_secp = (asection *) NULL;
1715 unsigned int i;
1716
1717 /* Create the .PPC.EMB.apuinfo section. */
1718 apuinfo_secp = subseg_new (".PPC.EMB.apuinfo", 0);
1719 bfd_set_section_flags (stdoutput,
1720 apuinfo_secp,
1721 SEC_HAS_CONTENTS | SEC_READONLY);
1722
1723 p = frag_more (4);
1724 md_number_to_chars (p, (valueT) 8, 4);
1725
1726 p = frag_more (4);
1727 md_number_to_chars (p, (valueT) ppc_apuinfo_num * 4, 4);
1728
1729 p = frag_more (4);
1730 md_number_to_chars (p, (valueT) 2, 4);
1731
1732 p = frag_more (8);
1733 strcpy (p, "APUinfo");
1734
1735 for (i = 0; i < ppc_apuinfo_num; i++)
1736 {
1737 p = frag_more (4);
1738 md_number_to_chars (p, (valueT) ppc_apuinfo_list[i], 4);
1739 }
1740
1741 frag_align (2, 0, 0);
1742
1743 /* We probably can't restore the current segment, for there likely
1744 isn't one yet... */
1745 if (seg && subseg)
1746 subseg_set (seg, subseg);
1747 }
1748 #endif
1749 }
1750
1751 /* Insert an operand value into an instruction. */
1752
1753 static unsigned long
1754 ppc_insert_operand (unsigned long insn,
1755 const struct powerpc_operand *operand,
1756 offsetT val,
1757 ppc_cpu_t cpu,
1758 char *file,
1759 unsigned int line)
1760 {
1761 long min, max, right;
1762
1763 max = operand->bitm;
1764 right = max & -max;
1765 min = 0;
1766
1767 if ((operand->flags & PPC_OPERAND_SIGNED) != 0)
1768 {
1769 if ((operand->flags & PPC_OPERAND_SIGNOPT) == 0)
1770 max = (max >> 1) & -right;
1771 min = ~max & -right;
1772 }
1773
1774 if ((operand->flags & PPC_OPERAND_PLUS1) != 0)
1775 max++;
1776
1777 if ((operand->flags & PPC_OPERAND_NEGATIVE) != 0)
1778 {
1779 long tmp = min;
1780 min = -max;
1781 max = -tmp;
1782 }
1783
1784 if (min <= max)
1785 {
1786 /* Some people write constants with the sign extension done by
1787 hand but only up to 32 bits. This shouldn't really be valid,
1788 but, to permit this code to assemble on a 64-bit host, we
1789 sign extend the 32-bit value to 64 bits if so doing makes the
1790 value valid. */
1791 if (val > max
1792 && (offsetT) (val - 0x80000000 - 0x80000000) >= min
1793 && (offsetT) (val - 0x80000000 - 0x80000000) <= max
1794 && ((val - 0x80000000 - 0x80000000) & (right - 1)) == 0)
1795 val = val - 0x80000000 - 0x80000000;
1796
1797 /* Similarly, people write expressions like ~(1<<15), and expect
1798 this to be OK for a 32-bit unsigned value. */
1799 else if (val < min
1800 && (offsetT) (val + 0x80000000 + 0x80000000) >= min
1801 && (offsetT) (val + 0x80000000 + 0x80000000) <= max
1802 && ((val + 0x80000000 + 0x80000000) & (right - 1)) == 0)
1803 val = val + 0x80000000 + 0x80000000;
1804
1805 else if (val < min
1806 || val > max
1807 || (val & (right - 1)) != 0)
1808 as_bad_value_out_of_range (_("operand"), val, min, max, file, line);
1809 }
1810
1811 if (operand->insert)
1812 {
1813 const char *errmsg;
1814
1815 errmsg = NULL;
1816 insn = (*operand->insert) (insn, (long) val, cpu, &errmsg);
1817 if (errmsg != (const char *) NULL)
1818 as_bad_where (file, line, "%s", errmsg);
1819 }
1820 else if (operand->shift >= 0)
1821 insn |= ((long) val & operand->bitm) << operand->shift;
1822 else
1823 insn |= ((long) val & operand->bitm) >> -operand->shift;
1824
1825 return insn;
1826 }
1827
1828 \f
1829 #ifdef OBJ_ELF
1830 /* Parse @got, etc. and return the desired relocation. */
1831 static bfd_reloc_code_real_type
1832 ppc_elf_suffix (char **str_p, expressionS *exp_p)
1833 {
1834 struct map_bfd {
1835 char *string;
1836 unsigned int length : 8;
1837 unsigned int valid32 : 1;
1838 unsigned int valid64 : 1;
1839 unsigned int reloc;
1840 };
1841
1842 char ident[20];
1843 char *str = *str_p;
1844 char *str2;
1845 int ch;
1846 int len;
1847 const struct map_bfd *ptr;
1848
1849 #define MAP(str, reloc) { str, sizeof (str) - 1, 1, 1, reloc }
1850 #define MAP32(str, reloc) { str, sizeof (str) - 1, 1, 0, reloc }
1851 #define MAP64(str, reloc) { str, sizeof (str) - 1, 0, 1, reloc }
1852
1853 static const struct map_bfd mapping[] = {
1854 MAP ("l", BFD_RELOC_LO16),
1855 MAP ("h", BFD_RELOC_HI16),
1856 MAP ("ha", BFD_RELOC_HI16_S),
1857 MAP ("brtaken", BFD_RELOC_PPC_B16_BRTAKEN),
1858 MAP ("brntaken", BFD_RELOC_PPC_B16_BRNTAKEN),
1859 MAP ("got", BFD_RELOC_16_GOTOFF),
1860 MAP ("got@l", BFD_RELOC_LO16_GOTOFF),
1861 MAP ("got@h", BFD_RELOC_HI16_GOTOFF),
1862 MAP ("got@ha", BFD_RELOC_HI16_S_GOTOFF),
1863 MAP ("plt@l", BFD_RELOC_LO16_PLTOFF),
1864 MAP ("plt@h", BFD_RELOC_HI16_PLTOFF),
1865 MAP ("plt@ha", BFD_RELOC_HI16_S_PLTOFF),
1866 MAP ("copy", BFD_RELOC_PPC_COPY),
1867 MAP ("globdat", BFD_RELOC_PPC_GLOB_DAT),
1868 MAP ("sectoff", BFD_RELOC_16_BASEREL),
1869 MAP ("sectoff@l", BFD_RELOC_LO16_BASEREL),
1870 MAP ("sectoff@h", BFD_RELOC_HI16_BASEREL),
1871 MAP ("sectoff@ha", BFD_RELOC_HI16_S_BASEREL),
1872 MAP ("tls", BFD_RELOC_PPC_TLS),
1873 MAP ("dtpmod", BFD_RELOC_PPC_DTPMOD),
1874 MAP ("dtprel", BFD_RELOC_PPC_DTPREL),
1875 MAP ("dtprel@l", BFD_RELOC_PPC_DTPREL16_LO),
1876 MAP ("dtprel@h", BFD_RELOC_PPC_DTPREL16_HI),
1877 MAP ("dtprel@ha", BFD_RELOC_PPC_DTPREL16_HA),
1878 MAP ("tprel", BFD_RELOC_PPC_TPREL),
1879 MAP ("tprel@l", BFD_RELOC_PPC_TPREL16_LO),
1880 MAP ("tprel@h", BFD_RELOC_PPC_TPREL16_HI),
1881 MAP ("tprel@ha", BFD_RELOC_PPC_TPREL16_HA),
1882 MAP ("got@tlsgd", BFD_RELOC_PPC_GOT_TLSGD16),
1883 MAP ("got@tlsgd@l", BFD_RELOC_PPC_GOT_TLSGD16_LO),
1884 MAP ("got@tlsgd@h", BFD_RELOC_PPC_GOT_TLSGD16_HI),
1885 MAP ("got@tlsgd@ha", BFD_RELOC_PPC_GOT_TLSGD16_HA),
1886 MAP ("got@tlsld", BFD_RELOC_PPC_GOT_TLSLD16),
1887 MAP ("got@tlsld@l", BFD_RELOC_PPC_GOT_TLSLD16_LO),
1888 MAP ("got@tlsld@h", BFD_RELOC_PPC_GOT_TLSLD16_HI),
1889 MAP ("got@tlsld@ha", BFD_RELOC_PPC_GOT_TLSLD16_HA),
1890 MAP ("got@dtprel", BFD_RELOC_PPC_GOT_DTPREL16),
1891 MAP ("got@dtprel@l", BFD_RELOC_PPC_GOT_DTPREL16_LO),
1892 MAP ("got@dtprel@h", BFD_RELOC_PPC_GOT_DTPREL16_HI),
1893 MAP ("got@dtprel@ha", BFD_RELOC_PPC_GOT_DTPREL16_HA),
1894 MAP ("got@tprel", BFD_RELOC_PPC_GOT_TPREL16),
1895 MAP ("got@tprel@l", BFD_RELOC_PPC_GOT_TPREL16_LO),
1896 MAP ("got@tprel@h", BFD_RELOC_PPC_GOT_TPREL16_HI),
1897 MAP ("got@tprel@ha", BFD_RELOC_PPC_GOT_TPREL16_HA),
1898 MAP32 ("fixup", BFD_RELOC_CTOR),
1899 MAP32 ("plt", BFD_RELOC_24_PLT_PCREL),
1900 MAP32 ("pltrel24", BFD_RELOC_24_PLT_PCREL),
1901 MAP32 ("local24pc", BFD_RELOC_PPC_LOCAL24PC),
1902 MAP32 ("local", BFD_RELOC_PPC_LOCAL24PC),
1903 MAP32 ("pltrel", BFD_RELOC_32_PLT_PCREL),
1904 MAP32 ("sdarel", BFD_RELOC_GPREL16),
1905 MAP32 ("sdarel@l", BFD_RELOC_PPC_VLE_SDAREL_LO16A),
1906 MAP32 ("sdarel@h", BFD_RELOC_PPC_VLE_SDAREL_HI16A),
1907 MAP32 ("sdarel@ha", BFD_RELOC_PPC_VLE_SDAREL_HA16A),
1908 MAP32 ("naddr", BFD_RELOC_PPC_EMB_NADDR32),
1909 MAP32 ("naddr16", BFD_RELOC_PPC_EMB_NADDR16),
1910 MAP32 ("naddr@l", BFD_RELOC_PPC_EMB_NADDR16_LO),
1911 MAP32 ("naddr@h", BFD_RELOC_PPC_EMB_NADDR16_HI),
1912 MAP32 ("naddr@ha", BFD_RELOC_PPC_EMB_NADDR16_HA),
1913 MAP32 ("sdai16", BFD_RELOC_PPC_EMB_SDAI16),
1914 MAP32 ("sda2rel", BFD_RELOC_PPC_EMB_SDA2REL),
1915 MAP32 ("sda2i16", BFD_RELOC_PPC_EMB_SDA2I16),
1916 MAP32 ("sda21", BFD_RELOC_PPC_EMB_SDA21),
1917 MAP32 ("sda21@l", BFD_RELOC_PPC_VLE_SDA21_LO),
1918 MAP32 ("mrkref", BFD_RELOC_PPC_EMB_MRKREF),
1919 MAP32 ("relsect", BFD_RELOC_PPC_EMB_RELSEC16),
1920 MAP32 ("relsect@l", BFD_RELOC_PPC_EMB_RELST_LO),
1921 MAP32 ("relsect@h", BFD_RELOC_PPC_EMB_RELST_HI),
1922 MAP32 ("relsect@ha", BFD_RELOC_PPC_EMB_RELST_HA),
1923 MAP32 ("bitfld", BFD_RELOC_PPC_EMB_BIT_FLD),
1924 MAP32 ("relsda", BFD_RELOC_PPC_EMB_RELSDA),
1925 MAP32 ("xgot", BFD_RELOC_PPC_TOC16),
1926 MAP64 ("higher", BFD_RELOC_PPC64_HIGHER),
1927 MAP64 ("highera", BFD_RELOC_PPC64_HIGHER_S),
1928 MAP64 ("highest", BFD_RELOC_PPC64_HIGHEST),
1929 MAP64 ("highesta", BFD_RELOC_PPC64_HIGHEST_S),
1930 MAP64 ("tocbase", BFD_RELOC_PPC64_TOC),
1931 MAP64 ("toc", BFD_RELOC_PPC_TOC16),
1932 MAP64 ("toc@l", BFD_RELOC_PPC64_TOC16_LO),
1933 MAP64 ("toc@h", BFD_RELOC_PPC64_TOC16_HI),
1934 MAP64 ("toc@ha", BFD_RELOC_PPC64_TOC16_HA),
1935 MAP64 ("dtprel@higher", BFD_RELOC_PPC64_DTPREL16_HIGHER),
1936 MAP64 ("dtprel@highera", BFD_RELOC_PPC64_DTPREL16_HIGHERA),
1937 MAP64 ("dtprel@highest", BFD_RELOC_PPC64_DTPREL16_HIGHEST),
1938 MAP64 ("dtprel@highesta", BFD_RELOC_PPC64_DTPREL16_HIGHESTA),
1939 MAP64 ("tprel@higher", BFD_RELOC_PPC64_TPREL16_HIGHER),
1940 MAP64 ("tprel@highera", BFD_RELOC_PPC64_TPREL16_HIGHERA),
1941 MAP64 ("tprel@highest", BFD_RELOC_PPC64_TPREL16_HIGHEST),
1942 MAP64 ("tprel@highesta", BFD_RELOC_PPC64_TPREL16_HIGHESTA),
1943 { (char *) 0, 0, 0, 0, BFD_RELOC_UNUSED }
1944 };
1945
1946 if (*str++ != '@')
1947 return BFD_RELOC_UNUSED;
1948
1949 for (ch = *str, str2 = ident;
1950 (str2 < ident + sizeof (ident) - 1
1951 && (ISALNUM (ch) || ch == '@'));
1952 ch = *++str)
1953 {
1954 *str2++ = TOLOWER (ch);
1955 }
1956
1957 *str2 = '\0';
1958 len = str2 - ident;
1959
1960 ch = ident[0];
1961 for (ptr = &mapping[0]; ptr->length > 0; ptr++)
1962 if (ch == ptr->string[0]
1963 && len == ptr->length
1964 && memcmp (ident, ptr->string, ptr->length) == 0
1965 && (ppc_obj64 ? ptr->valid64 : ptr->valid32))
1966 {
1967 int reloc = ptr->reloc;
1968
1969 if (!ppc_obj64 && exp_p->X_add_number != 0)
1970 {
1971 switch (reloc)
1972 {
1973 case BFD_RELOC_16_GOTOFF:
1974 case BFD_RELOC_LO16_GOTOFF:
1975 case BFD_RELOC_HI16_GOTOFF:
1976 case BFD_RELOC_HI16_S_GOTOFF:
1977 as_warn (_("identifier+constant@got means "
1978 "identifier@got+constant"));
1979 break;
1980
1981 case BFD_RELOC_PPC_GOT_TLSGD16:
1982 case BFD_RELOC_PPC_GOT_TLSGD16_LO:
1983 case BFD_RELOC_PPC_GOT_TLSGD16_HI:
1984 case BFD_RELOC_PPC_GOT_TLSGD16_HA:
1985 case BFD_RELOC_PPC_GOT_TLSLD16:
1986 case BFD_RELOC_PPC_GOT_TLSLD16_LO:
1987 case BFD_RELOC_PPC_GOT_TLSLD16_HI:
1988 case BFD_RELOC_PPC_GOT_TLSLD16_HA:
1989 case BFD_RELOC_PPC_GOT_DTPREL16:
1990 case BFD_RELOC_PPC_GOT_DTPREL16_LO:
1991 case BFD_RELOC_PPC_GOT_DTPREL16_HI:
1992 case BFD_RELOC_PPC_GOT_DTPREL16_HA:
1993 case BFD_RELOC_PPC_GOT_TPREL16:
1994 case BFD_RELOC_PPC_GOT_TPREL16_LO:
1995 case BFD_RELOC_PPC_GOT_TPREL16_HI:
1996 case BFD_RELOC_PPC_GOT_TPREL16_HA:
1997 as_bad (_("symbol+offset not supported for got tls"));
1998 break;
1999 }
2000 }
2001
2002 /* Now check for identifier@suffix+constant. */
2003 if (*str == '-' || *str == '+')
2004 {
2005 char *orig_line = input_line_pointer;
2006 expressionS new_exp;
2007
2008 input_line_pointer = str;
2009 expression (&new_exp);
2010 if (new_exp.X_op == O_constant)
2011 {
2012 exp_p->X_add_number += new_exp.X_add_number;
2013 str = input_line_pointer;
2014 }
2015
2016 if (&input_line_pointer != str_p)
2017 input_line_pointer = orig_line;
2018 }
2019 *str_p = str;
2020
2021 if (reloc == (int) BFD_RELOC_PPC64_TOC
2022 && exp_p->X_op == O_symbol
2023 && strcmp (S_GET_NAME (exp_p->X_add_symbol), ".TOC.") == 0)
2024 {
2025 /* Change the symbol so that the dummy .TOC. symbol can be
2026 omitted from the object file. */
2027 exp_p->X_add_symbol = &abs_symbol;
2028 }
2029
2030 return (bfd_reloc_code_real_type) reloc;
2031 }
2032
2033 return BFD_RELOC_UNUSED;
2034 }
2035
2036 /* Like normal .long/.short/.word, except support @got, etc.
2037 Clobbers input_line_pointer, checks end-of-line. */
2038 static void
2039 ppc_elf_cons (int nbytes /* 1=.byte, 2=.word, 4=.long, 8=.llong */)
2040 {
2041 expressionS exp;
2042 bfd_reloc_code_real_type reloc;
2043
2044 if (is_it_end_of_statement ())
2045 {
2046 demand_empty_rest_of_line ();
2047 return;
2048 }
2049
2050 do
2051 {
2052 expression (&exp);
2053 if (exp.X_op == O_symbol
2054 && *input_line_pointer == '@'
2055 && (reloc = ppc_elf_suffix (&input_line_pointer,
2056 &exp)) != BFD_RELOC_UNUSED)
2057 {
2058 reloc_howto_type *reloc_howto;
2059 int size;
2060
2061 reloc_howto = bfd_reloc_type_lookup (stdoutput, reloc);
2062 size = bfd_get_reloc_size (reloc_howto);
2063
2064 if (size > nbytes)
2065 {
2066 as_bad (_("%s relocations do not fit in %d bytes\n"),
2067 reloc_howto->name, nbytes);
2068 }
2069 else
2070 {
2071 char *p;
2072 int offset;
2073
2074 p = frag_more (nbytes);
2075 memset (p, 0, nbytes);
2076 offset = 0;
2077 if (target_big_endian)
2078 offset = nbytes - size;
2079 fix_new_exp (frag_now, p - frag_now->fr_literal + offset, size,
2080 &exp, 0, reloc);
2081 }
2082 }
2083 else
2084 emit_expr (&exp, (unsigned int) nbytes);
2085 }
2086 while (*input_line_pointer++ == ',');
2087
2088 /* Put terminator back into stream. */
2089 input_line_pointer--;
2090 demand_empty_rest_of_line ();
2091 }
2092
2093 /* Solaris pseduo op to change to the .rodata section. */
2094 static void
2095 ppc_elf_rdata (int xxx)
2096 {
2097 char *save_line = input_line_pointer;
2098 static char section[] = ".rodata\n";
2099
2100 /* Just pretend this is .section .rodata */
2101 input_line_pointer = section;
2102 obj_elf_section (xxx);
2103
2104 input_line_pointer = save_line;
2105 }
2106
2107 /* Pseudo op to make file scope bss items. */
2108 static void
2109 ppc_elf_lcomm (int xxx ATTRIBUTE_UNUSED)
2110 {
2111 char *name;
2112 char c;
2113 char *p;
2114 offsetT size;
2115 symbolS *symbolP;
2116 offsetT align;
2117 segT old_sec;
2118 int old_subsec;
2119 char *pfrag;
2120 int align2;
2121
2122 name = input_line_pointer;
2123 c = get_symbol_end ();
2124
2125 /* just after name is now '\0'. */
2126 p = input_line_pointer;
2127 *p = c;
2128 SKIP_WHITESPACE ();
2129 if (*input_line_pointer != ',')
2130 {
2131 as_bad (_("expected comma after symbol-name: rest of line ignored."));
2132 ignore_rest_of_line ();
2133 return;
2134 }
2135
2136 input_line_pointer++; /* skip ',' */
2137 if ((size = get_absolute_expression ()) < 0)
2138 {
2139 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) size);
2140 ignore_rest_of_line ();
2141 return;
2142 }
2143
2144 /* The third argument to .lcomm is the alignment. */
2145 if (*input_line_pointer != ',')
2146 align = 8;
2147 else
2148 {
2149 ++input_line_pointer;
2150 align = get_absolute_expression ();
2151 if (align <= 0)
2152 {
2153 as_warn (_("ignoring bad alignment"));
2154 align = 8;
2155 }
2156 }
2157
2158 *p = 0;
2159 symbolP = symbol_find_or_make (name);
2160 *p = c;
2161
2162 if (S_IS_DEFINED (symbolP) && ! S_IS_COMMON (symbolP))
2163 {
2164 as_bad (_("ignoring attempt to re-define symbol `%s'."),
2165 S_GET_NAME (symbolP));
2166 ignore_rest_of_line ();
2167 return;
2168 }
2169
2170 if (S_GET_VALUE (symbolP) && S_GET_VALUE (symbolP) != (valueT) size)
2171 {
2172 as_bad (_("length of .lcomm \"%s\" is already %ld. Not changed to %ld."),
2173 S_GET_NAME (symbolP),
2174 (long) S_GET_VALUE (symbolP),
2175 (long) size);
2176
2177 ignore_rest_of_line ();
2178 return;
2179 }
2180
2181 /* Allocate_bss. */
2182 old_sec = now_seg;
2183 old_subsec = now_subseg;
2184 if (align)
2185 {
2186 /* Convert to a power of 2 alignment. */
2187 for (align2 = 0; (align & 1) == 0; align >>= 1, ++align2);
2188 if (align != 1)
2189 {
2190 as_bad (_("common alignment not a power of 2"));
2191 ignore_rest_of_line ();
2192 return;
2193 }
2194 }
2195 else
2196 align2 = 0;
2197
2198 record_alignment (bss_section, align2);
2199 subseg_set (bss_section, 0);
2200 if (align2)
2201 frag_align (align2, 0, 0);
2202 if (S_GET_SEGMENT (symbolP) == bss_section)
2203 symbol_get_frag (symbolP)->fr_symbol = 0;
2204 symbol_set_frag (symbolP, frag_now);
2205 pfrag = frag_var (rs_org, 1, 1, (relax_substateT) 0, symbolP, size,
2206 (char *) 0);
2207 *pfrag = 0;
2208 S_SET_SIZE (symbolP, size);
2209 S_SET_SEGMENT (symbolP, bss_section);
2210 subseg_set (old_sec, old_subsec);
2211 demand_empty_rest_of_line ();
2212 }
2213
2214 /* Validate any relocations emitted for -mrelocatable, possibly adding
2215 fixups for word relocations in writable segments, so we can adjust
2216 them at runtime. */
2217 static void
2218 ppc_elf_validate_fix (fixS *fixp, segT seg)
2219 {
2220 if (fixp->fx_done || fixp->fx_pcrel)
2221 return;
2222
2223 switch (shlib)
2224 {
2225 case SHLIB_NONE:
2226 case SHLIB_PIC:
2227 return;
2228
2229 case SHLIB_MRELOCATABLE:
2230 if (fixp->fx_r_type <= BFD_RELOC_UNUSED
2231 && fixp->fx_r_type != BFD_RELOC_16_GOTOFF
2232 && fixp->fx_r_type != BFD_RELOC_HI16_GOTOFF
2233 && fixp->fx_r_type != BFD_RELOC_LO16_GOTOFF
2234 && fixp->fx_r_type != BFD_RELOC_HI16_S_GOTOFF
2235 && fixp->fx_r_type != BFD_RELOC_16_BASEREL
2236 && fixp->fx_r_type != BFD_RELOC_LO16_BASEREL
2237 && fixp->fx_r_type != BFD_RELOC_HI16_BASEREL
2238 && fixp->fx_r_type != BFD_RELOC_HI16_S_BASEREL
2239 && (seg->flags & SEC_LOAD) != 0
2240 && strcmp (segment_name (seg), ".got2") != 0
2241 && strcmp (segment_name (seg), ".dtors") != 0
2242 && strcmp (segment_name (seg), ".ctors") != 0
2243 && strcmp (segment_name (seg), ".fixup") != 0
2244 && strcmp (segment_name (seg), ".gcc_except_table") != 0
2245 && strcmp (segment_name (seg), ".eh_frame") != 0
2246 && strcmp (segment_name (seg), ".ex_shared") != 0)
2247 {
2248 if ((seg->flags & (SEC_READONLY | SEC_CODE)) != 0
2249 || fixp->fx_r_type != BFD_RELOC_CTOR)
2250 {
2251 as_bad_where (fixp->fx_file, fixp->fx_line,
2252 _("relocation cannot be done when using -mrelocatable"));
2253 }
2254 }
2255 return;
2256 }
2257 }
2258
2259 /* Prevent elf_frob_file_before_adjust removing a weak undefined
2260 function descriptor sym if the corresponding code sym is used. */
2261
2262 void
2263 ppc_frob_file_before_adjust (void)
2264 {
2265 symbolS *symp;
2266 asection *toc;
2267
2268 if (!ppc_obj64)
2269 return;
2270
2271 for (symp = symbol_rootP; symp; symp = symbol_next (symp))
2272 {
2273 const char *name;
2274 char *dotname;
2275 symbolS *dotsym;
2276 size_t len;
2277
2278 name = S_GET_NAME (symp);
2279 if (name[0] == '.')
2280 continue;
2281
2282 if (! S_IS_WEAK (symp)
2283 || S_IS_DEFINED (symp))
2284 continue;
2285
2286 len = strlen (name) + 1;
2287 dotname = xmalloc (len + 1);
2288 dotname[0] = '.';
2289 memcpy (dotname + 1, name, len);
2290 dotsym = symbol_find_noref (dotname, 1);
2291 free (dotname);
2292 if (dotsym != NULL && (symbol_used_p (dotsym)
2293 || symbol_used_in_reloc_p (dotsym)))
2294 symbol_mark_used (symp);
2295
2296 }
2297
2298 toc = bfd_get_section_by_name (stdoutput, ".toc");
2299 if (toc != NULL
2300 && toc_reloc_types != has_large_toc_reloc
2301 && bfd_section_size (stdoutput, toc) > 0x10000)
2302 as_warn (_("TOC section size exceeds 64k"));
2303 }
2304
2305 /* .TOC. used in an opd entry as .TOC.@tocbase doesn't need to be
2306 emitted. Other uses of .TOC. will cause the symbol to be marked
2307 with BSF_KEEP in md_apply_fix. */
2308
2309 void
2310 ppc_elf_adjust_symtab (void)
2311 {
2312 if (ppc_obj64)
2313 {
2314 symbolS *symp;
2315 symp = symbol_find (".TOC.");
2316 if (symp != NULL)
2317 {
2318 asymbol *bsym = symbol_get_bfdsym (symp);
2319 if ((bsym->flags & BSF_KEEP) == 0)
2320 symbol_remove (symp, &symbol_rootP, &symbol_lastP);
2321 else
2322 S_SET_WEAK (symp);
2323 }
2324 }
2325 }
2326 #endif /* OBJ_ELF */
2327 \f
2328 #ifdef TE_PE
2329
2330 /*
2331 * Summary of parse_toc_entry.
2332 *
2333 * in: Input_line_pointer points to the '[' in one of:
2334 *
2335 * [toc] [tocv] [toc32] [toc64]
2336 *
2337 * Anything else is an error of one kind or another.
2338 *
2339 * out:
2340 * return value: success or failure
2341 * toc_kind: kind of toc reference
2342 * input_line_pointer:
2343 * success: first char after the ']'
2344 * failure: unchanged
2345 *
2346 * settings:
2347 *
2348 * [toc] - rv == success, toc_kind = default_toc
2349 * [tocv] - rv == success, toc_kind = data_in_toc
2350 * [toc32] - rv == success, toc_kind = must_be_32
2351 * [toc64] - rv == success, toc_kind = must_be_64
2352 *
2353 */
2354
2355 enum toc_size_qualifier
2356 {
2357 default_toc, /* The toc cell constructed should be the system default size */
2358 data_in_toc, /* This is a direct reference to a toc cell */
2359 must_be_32, /* The toc cell constructed must be 32 bits wide */
2360 must_be_64 /* The toc cell constructed must be 64 bits wide */
2361 };
2362
2363 static int
2364 parse_toc_entry (enum toc_size_qualifier *toc_kind)
2365 {
2366 char *start;
2367 char *toc_spec;
2368 char c;
2369 enum toc_size_qualifier t;
2370
2371 /* Save the input_line_pointer. */
2372 start = input_line_pointer;
2373
2374 /* Skip over the '[' , and whitespace. */
2375 ++input_line_pointer;
2376 SKIP_WHITESPACE ();
2377
2378 /* Find the spelling of the operand. */
2379 toc_spec = input_line_pointer;
2380 c = get_symbol_end ();
2381
2382 if (strcmp (toc_spec, "toc") == 0)
2383 {
2384 t = default_toc;
2385 }
2386 else if (strcmp (toc_spec, "tocv") == 0)
2387 {
2388 t = data_in_toc;
2389 }
2390 else if (strcmp (toc_spec, "toc32") == 0)
2391 {
2392 t = must_be_32;
2393 }
2394 else if (strcmp (toc_spec, "toc64") == 0)
2395 {
2396 t = must_be_64;
2397 }
2398 else
2399 {
2400 as_bad (_("syntax error: invalid toc specifier `%s'"), toc_spec);
2401 *input_line_pointer = c;
2402 input_line_pointer = start;
2403 return 0;
2404 }
2405
2406 /* Now find the ']'. */
2407 *input_line_pointer = c;
2408
2409 SKIP_WHITESPACE (); /* leading whitespace could be there. */
2410 c = *input_line_pointer++; /* input_line_pointer->past char in c. */
2411
2412 if (c != ']')
2413 {
2414 as_bad (_("syntax error: expected `]', found `%c'"), c);
2415 input_line_pointer = start;
2416 return 0;
2417 }
2418
2419 *toc_kind = t;
2420 return 1;
2421 }
2422 #endif
2423
2424 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
2425 /* See whether a symbol is in the TOC section. */
2426
2427 static int
2428 ppc_is_toc_sym (symbolS *sym)
2429 {
2430 #ifdef OBJ_XCOFF
2431 return (symbol_get_tc (sym)->symbol_class == XMC_TC
2432 || symbol_get_tc (sym)->symbol_class == XMC_TC0);
2433 #endif
2434 #ifdef OBJ_ELF
2435 const char *sname = segment_name (S_GET_SEGMENT (sym));
2436 if (ppc_obj64)
2437 return strcmp (sname, ".toc") == 0;
2438 else
2439 return strcmp (sname, ".got") == 0;
2440 #endif
2441 }
2442 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
2443 \f
2444
2445 #ifdef OBJ_ELF
2446 #define APUID(a,v) ((((a) & 0xffff) << 16) | ((v) & 0xffff))
2447 static void
2448 ppc_apuinfo_section_add (unsigned int apu, unsigned int version)
2449 {
2450 unsigned int i;
2451
2452 /* Check we don't already exist. */
2453 for (i = 0; i < ppc_apuinfo_num; i++)
2454 if (ppc_apuinfo_list[i] == APUID (apu, version))
2455 return;
2456
2457 if (ppc_apuinfo_num == ppc_apuinfo_num_alloc)
2458 {
2459 if (ppc_apuinfo_num_alloc == 0)
2460 {
2461 ppc_apuinfo_num_alloc = 4;
2462 ppc_apuinfo_list = (unsigned long *)
2463 xmalloc (sizeof (unsigned long) * ppc_apuinfo_num_alloc);
2464 }
2465 else
2466 {
2467 ppc_apuinfo_num_alloc += 4;
2468 ppc_apuinfo_list = (unsigned long *) xrealloc (ppc_apuinfo_list,
2469 sizeof (unsigned long) * ppc_apuinfo_num_alloc);
2470 }
2471 }
2472 ppc_apuinfo_list[ppc_apuinfo_num++] = APUID (apu, version);
2473 }
2474 #undef APUID
2475 #endif
2476 \f
2477
2478 /* We need to keep a list of fixups. We can't simply generate them as
2479 we go, because that would require us to first create the frag, and
2480 that would screw up references to ``.''. */
2481
2482 struct ppc_fixup
2483 {
2484 expressionS exp;
2485 int opindex;
2486 bfd_reloc_code_real_type reloc;
2487 };
2488
2489 #define MAX_INSN_FIXUPS (5)
2490
2491 /* Form I16L. */
2492 #define E_OR2I_INSN 0x7000C000
2493 #define E_AND2I_DOT_INSN 0x7000C800
2494 #define E_OR2IS_INSN 0x7000D000
2495 #define E_LIS_INSN 0x7000E000
2496 #define E_AND2IS_DOT_INSN 0x7000E800
2497
2498 /* Form I16A. */
2499 #define E_ADD2I_DOT_INSN 0x70008800
2500 #define E_ADD2IS_INSN 0x70009000
2501 #define E_CMP16I_INSN 0x70009800
2502 #define E_MULL2I_INSN 0x7000A000
2503 #define E_CMPL16I_INSN 0x7000A800
2504 #define E_CMPH16I_INSN 0x7000B000
2505 #define E_CMPHL16I_INSN 0x7000B800
2506
2507 /* This routine is called for each instruction to be assembled. */
2508
2509 void
2510 md_assemble (char *str)
2511 {
2512 char *s;
2513 const struct powerpc_opcode *opcode;
2514 unsigned long insn;
2515 const unsigned char *opindex_ptr;
2516 int skip_optional;
2517 int need_paren;
2518 int next_opindex;
2519 struct ppc_fixup fixups[MAX_INSN_FIXUPS];
2520 int fc;
2521 char *f;
2522 int addr_mod;
2523 int i;
2524 unsigned int insn_length;
2525
2526 /* Get the opcode. */
2527 for (s = str; *s != '\0' && ! ISSPACE (*s); s++)
2528 ;
2529 if (*s != '\0')
2530 *s++ = '\0';
2531
2532 /* Look up the opcode in the hash table. */
2533 opcode = (const struct powerpc_opcode *) hash_find (ppc_hash, str);
2534 if (opcode == (const struct powerpc_opcode *) NULL)
2535 {
2536 const struct powerpc_macro *macro;
2537
2538 macro = (const struct powerpc_macro *) hash_find (ppc_macro_hash, str);
2539 if (macro == (const struct powerpc_macro *) NULL)
2540 as_bad (_("unrecognized opcode: `%s'"), str);
2541 else
2542 ppc_macro (s, macro);
2543
2544 return;
2545 }
2546
2547 insn = opcode->opcode;
2548
2549 str = s;
2550 while (ISSPACE (*str))
2551 ++str;
2552
2553 /* PowerPC operands are just expressions. The only real issue is
2554 that a few operand types are optional. All cases which might use
2555 an optional operand separate the operands only with commas (in some
2556 cases parentheses are used, as in ``lwz 1,0(1)'' but such cases never
2557 have optional operands). Most instructions with optional operands
2558 have only one. Those that have more than one optional operand can
2559 take either all their operands or none. So, before we start seriously
2560 parsing the operands, we check to see if we have optional operands,
2561 and if we do, we count the number of commas to see which operands
2562 have been omitted. */
2563 skip_optional = 0;
2564 for (opindex_ptr = opcode->operands; *opindex_ptr != 0; opindex_ptr++)
2565 {
2566 const struct powerpc_operand *operand;
2567
2568 operand = &powerpc_operands[*opindex_ptr];
2569 if ((operand->flags & PPC_OPERAND_OPTIONAL) != 0)
2570 {
2571 unsigned int opcount;
2572 unsigned int num_operands_expected;
2573
2574 /* There is an optional operand. Count the number of
2575 commas in the input line. */
2576 if (*str == '\0')
2577 opcount = 0;
2578 else
2579 {
2580 opcount = 1;
2581 s = str;
2582 while ((s = strchr (s, ',')) != (char *) NULL)
2583 {
2584 ++opcount;
2585 ++s;
2586 }
2587 }
2588
2589 /* Compute the number of expected operands.
2590 Do not count fake operands. */
2591 for (num_operands_expected = 0, i = 0; opcode->operands[i]; i ++)
2592 if ((powerpc_operands [opcode->operands[i]].flags & PPC_OPERAND_FAKE) == 0)
2593 ++ num_operands_expected;
2594
2595 /* If there are fewer operands in the line then are called
2596 for by the instruction, we want to skip the optional
2597 operands. */
2598 if (opcount < num_operands_expected)
2599 skip_optional = 1;
2600
2601 break;
2602 }
2603 }
2604
2605 /* Gather the operands. */
2606 need_paren = 0;
2607 next_opindex = 0;
2608 fc = 0;
2609 for (opindex_ptr = opcode->operands; *opindex_ptr != 0; opindex_ptr++)
2610 {
2611 const struct powerpc_operand *operand;
2612 const char *errmsg;
2613 char *hold;
2614 expressionS ex;
2615 char endc;
2616
2617 if (next_opindex == 0)
2618 operand = &powerpc_operands[*opindex_ptr];
2619 else
2620 {
2621 operand = &powerpc_operands[next_opindex];
2622 next_opindex = 0;
2623 }
2624 errmsg = NULL;
2625
2626 /* If this is a fake operand, then we do not expect anything
2627 from the input. */
2628 if ((operand->flags & PPC_OPERAND_FAKE) != 0)
2629 {
2630 insn = (*operand->insert) (insn, 0L, ppc_cpu, &errmsg);
2631 if (errmsg != (const char *) NULL)
2632 as_bad ("%s", errmsg);
2633 continue;
2634 }
2635
2636 /* If this is an optional operand, and we are skipping it, just
2637 insert a zero. */
2638 if ((operand->flags & PPC_OPERAND_OPTIONAL) != 0
2639 && skip_optional)
2640 {
2641 if (operand->insert)
2642 {
2643 insn = (*operand->insert) (insn, 0L, ppc_cpu, &errmsg);
2644 if (errmsg != (const char *) NULL)
2645 as_bad ("%s", errmsg);
2646 }
2647 if ((operand->flags & PPC_OPERAND_NEXT) != 0)
2648 next_opindex = *opindex_ptr + 1;
2649 continue;
2650 }
2651
2652 /* Gather the operand. */
2653 hold = input_line_pointer;
2654 input_line_pointer = str;
2655
2656 #ifdef TE_PE
2657 if (*input_line_pointer == '[')
2658 {
2659 /* We are expecting something like the second argument here:
2660 *
2661 * lwz r4,[toc].GS.0.static_int(rtoc)
2662 * ^^^^^^^^^^^^^^^^^^^^^^^^^^^
2663 * The argument following the `]' must be a symbol name, and the
2664 * register must be the toc register: 'rtoc' or '2'
2665 *
2666 * The effect is to 0 as the displacement field
2667 * in the instruction, and issue an IMAGE_REL_PPC_TOCREL16 (or
2668 * the appropriate variation) reloc against it based on the symbol.
2669 * The linker will build the toc, and insert the resolved toc offset.
2670 *
2671 * Note:
2672 * o The size of the toc entry is currently assumed to be
2673 * 32 bits. This should not be assumed to be a hard coded
2674 * number.
2675 * o In an effort to cope with a change from 32 to 64 bits,
2676 * there are also toc entries that are specified to be
2677 * either 32 or 64 bits:
2678 * lwz r4,[toc32].GS.0.static_int(rtoc)
2679 * lwz r4,[toc64].GS.0.static_int(rtoc)
2680 * These demand toc entries of the specified size, and the
2681 * instruction probably requires it.
2682 */
2683
2684 int valid_toc;
2685 enum toc_size_qualifier toc_kind;
2686 bfd_reloc_code_real_type toc_reloc;
2687
2688 /* Go parse off the [tocXX] part. */
2689 valid_toc = parse_toc_entry (&toc_kind);
2690
2691 if (!valid_toc)
2692 {
2693 ignore_rest_of_line ();
2694 break;
2695 }
2696
2697 /* Now get the symbol following the ']'. */
2698 expression (&ex);
2699
2700 switch (toc_kind)
2701 {
2702 case default_toc:
2703 /* In this case, we may not have seen the symbol yet,
2704 since it is allowed to appear on a .extern or .globl
2705 or just be a label in the .data section. */
2706 toc_reloc = BFD_RELOC_PPC_TOC16;
2707 break;
2708 case data_in_toc:
2709 /* 1. The symbol must be defined and either in the toc
2710 section, or a global.
2711 2. The reloc generated must have the TOCDEFN flag set
2712 in upper bit mess of the reloc type.
2713 FIXME: It's a little confusing what the tocv
2714 qualifier can be used for. At the very least, I've
2715 seen three uses, only one of which I'm sure I can
2716 explain. */
2717 if (ex.X_op == O_symbol)
2718 {
2719 gas_assert (ex.X_add_symbol != NULL);
2720 if (symbol_get_bfdsym (ex.X_add_symbol)->section
2721 != tocdata_section)
2722 {
2723 as_bad (_("[tocv] symbol is not a toc symbol"));
2724 }
2725 }
2726
2727 toc_reloc = BFD_RELOC_PPC_TOC16;
2728 break;
2729 case must_be_32:
2730 /* FIXME: these next two specifically specify 32/64 bit
2731 toc entries. We don't support them today. Is this
2732 the right way to say that? */
2733 toc_reloc = BFD_RELOC_UNUSED;
2734 as_bad (_("unimplemented toc32 expression modifier"));
2735 break;
2736 case must_be_64:
2737 /* FIXME: see above. */
2738 toc_reloc = BFD_RELOC_UNUSED;
2739 as_bad (_("unimplemented toc64 expression modifier"));
2740 break;
2741 default:
2742 fprintf (stderr,
2743 _("Unexpected return value [%d] from parse_toc_entry!\n"),
2744 toc_kind);
2745 abort ();
2746 break;
2747 }
2748
2749 /* We need to generate a fixup for this expression. */
2750 if (fc >= MAX_INSN_FIXUPS)
2751 as_fatal (_("too many fixups"));
2752
2753 fixups[fc].reloc = toc_reloc;
2754 fixups[fc].exp = ex;
2755 fixups[fc].opindex = *opindex_ptr;
2756 ++fc;
2757
2758 /* Ok. We've set up the fixup for the instruction. Now make it
2759 look like the constant 0 was found here. */
2760 ex.X_unsigned = 1;
2761 ex.X_op = O_constant;
2762 ex.X_add_number = 0;
2763 ex.X_add_symbol = NULL;
2764 ex.X_op_symbol = NULL;
2765 }
2766
2767 else
2768 #endif /* TE_PE */
2769 {
2770 if ((reg_names_p
2771 && (((operand->flags & PPC_OPERAND_CR_BIT) != 0)
2772 || ((operand->flags & PPC_OPERAND_CR_REG) != 0)))
2773 || !register_name (&ex))
2774 {
2775 char save_lex = lex_type['%'];
2776
2777 if (((operand->flags & PPC_OPERAND_CR_REG) != 0)
2778 || (operand->flags & PPC_OPERAND_CR_BIT) != 0)
2779 {
2780 cr_operand = TRUE;
2781 lex_type['%'] |= LEX_BEGIN_NAME;
2782 }
2783 expression (&ex);
2784 cr_operand = FALSE;
2785 lex_type['%'] = save_lex;
2786 }
2787 }
2788
2789 str = input_line_pointer;
2790 input_line_pointer = hold;
2791
2792 if (ex.X_op == O_illegal)
2793 as_bad (_("illegal operand"));
2794 else if (ex.X_op == O_absent)
2795 as_bad (_("missing operand"));
2796 else if (ex.X_op == O_register)
2797 {
2798 insn = ppc_insert_operand (insn, operand, ex.X_add_number,
2799 ppc_cpu, (char *) NULL, 0);
2800 }
2801 else if (ex.X_op == O_constant)
2802 {
2803 #ifdef OBJ_ELF
2804 /* Allow @HA, @L, @H on constants. */
2805 bfd_reloc_code_real_type reloc;
2806 char *orig_str = str;
2807
2808 if ((reloc = ppc_elf_suffix (&str, &ex)) != BFD_RELOC_UNUSED)
2809 switch (reloc)
2810 {
2811 default:
2812 str = orig_str;
2813 break;
2814
2815 case BFD_RELOC_LO16:
2816 /* X_unsigned is the default, so if the user has done
2817 something which cleared it, we always produce a
2818 signed value. */
2819 if (ex.X_unsigned && ! (operand->flags & PPC_OPERAND_SIGNED))
2820 ex.X_add_number &= 0xffff;
2821 else
2822 ex.X_add_number = SEX16 (ex.X_add_number);
2823 break;
2824
2825 case BFD_RELOC_HI16:
2826 if (ex.X_unsigned && ! (operand->flags & PPC_OPERAND_SIGNED))
2827 ex.X_add_number = PPC_HI (ex.X_add_number);
2828 else
2829 ex.X_add_number = SEX16 (PPC_HI (ex.X_add_number));
2830 break;
2831
2832 case BFD_RELOC_HI16_S:
2833 if (ex.X_unsigned && ! (operand->flags & PPC_OPERAND_SIGNED))
2834 ex.X_add_number = PPC_HA (ex.X_add_number);
2835 else
2836 ex.X_add_number = SEX16 (PPC_HA (ex.X_add_number));
2837 break;
2838
2839 case BFD_RELOC_PPC64_HIGHER:
2840 if (ex.X_unsigned && ! (operand->flags & PPC_OPERAND_SIGNED))
2841 ex.X_add_number = PPC_HIGHER (ex.X_add_number);
2842 else
2843 ex.X_add_number = SEX16 (PPC_HIGHER (ex.X_add_number));
2844 break;
2845
2846 case BFD_RELOC_PPC64_HIGHER_S:
2847 if (ex.X_unsigned && ! (operand->flags & PPC_OPERAND_SIGNED))
2848 ex.X_add_number = PPC_HIGHERA (ex.X_add_number);
2849 else
2850 ex.X_add_number = SEX16 (PPC_HIGHERA (ex.X_add_number));
2851 break;
2852
2853 case BFD_RELOC_PPC64_HIGHEST:
2854 if (ex.X_unsigned && ! (operand->flags & PPC_OPERAND_SIGNED))
2855 ex.X_add_number = PPC_HIGHEST (ex.X_add_number);
2856 else
2857 ex.X_add_number = SEX16 (PPC_HIGHEST (ex.X_add_number));
2858 break;
2859
2860 case BFD_RELOC_PPC64_HIGHEST_S:
2861 if (ex.X_unsigned && ! (operand->flags & PPC_OPERAND_SIGNED))
2862 ex.X_add_number = PPC_HIGHESTA (ex.X_add_number);
2863 else
2864 ex.X_add_number = SEX16 (PPC_HIGHESTA (ex.X_add_number));
2865 break;
2866 }
2867 #endif /* OBJ_ELF */
2868 insn = ppc_insert_operand (insn, operand, ex.X_add_number,
2869 ppc_cpu, (char *) NULL, 0);
2870 }
2871 else
2872 {
2873 bfd_reloc_code_real_type reloc = BFD_RELOC_UNUSED;
2874 #ifdef OBJ_ELF
2875 if (ex.X_op == O_symbol && str[0] == '(')
2876 {
2877 const char *sym_name = S_GET_NAME (ex.X_add_symbol);
2878 if (sym_name[0] == '.')
2879 ++sym_name;
2880
2881 if (strcasecmp (sym_name, "__tls_get_addr") == 0)
2882 {
2883 expressionS tls_exp;
2884
2885 hold = input_line_pointer;
2886 input_line_pointer = str + 1;
2887 expression (&tls_exp);
2888 if (tls_exp.X_op == O_symbol)
2889 {
2890 reloc = BFD_RELOC_UNUSED;
2891 if (strncasecmp (input_line_pointer, "@tlsgd)", 7) == 0)
2892 {
2893 reloc = BFD_RELOC_PPC_TLSGD;
2894 input_line_pointer += 7;
2895 }
2896 else if (strncasecmp (input_line_pointer, "@tlsld)", 7) == 0)
2897 {
2898 reloc = BFD_RELOC_PPC_TLSLD;
2899 input_line_pointer += 7;
2900 }
2901 if (reloc != BFD_RELOC_UNUSED)
2902 {
2903 SKIP_WHITESPACE ();
2904 str = input_line_pointer;
2905
2906 if (fc >= MAX_INSN_FIXUPS)
2907 as_fatal (_("too many fixups"));
2908 fixups[fc].exp = tls_exp;
2909 fixups[fc].opindex = *opindex_ptr;
2910 fixups[fc].reloc = reloc;
2911 ++fc;
2912 }
2913 }
2914 input_line_pointer = hold;
2915 }
2916 }
2917
2918 if ((reloc = ppc_elf_suffix (&str, &ex)) != BFD_RELOC_UNUSED)
2919 {
2920 /* Some TLS tweaks. */
2921 switch (reloc)
2922 {
2923 default:
2924 break;
2925
2926 case BFD_RELOC_PPC_TLS:
2927 if (!_bfd_elf_ppc_at_tls_transform (opcode->opcode, 0))
2928 as_bad (_("@tls may not be used with \"%s\" operands"),
2929 opcode->name);
2930 else if (operand->shift != 11)
2931 as_bad (_("@tls may only be used in last operand"));
2932 else
2933 insn = ppc_insert_operand (insn, operand,
2934 ppc_obj64 ? 13 : 2,
2935 ppc_cpu, (char *) NULL, 0);
2936 break;
2937
2938 /* We'll only use the 32 (or 64) bit form of these relocations
2939 in constants. Instructions get the 16 bit form. */
2940 case BFD_RELOC_PPC_DTPREL:
2941 reloc = BFD_RELOC_PPC_DTPREL16;
2942 break;
2943 case BFD_RELOC_PPC_TPREL:
2944 reloc = BFD_RELOC_PPC_TPREL16;
2945 break;
2946 }
2947
2948 /* If VLE-mode convert LO/HI/HA relocations. */
2949 if (opcode->flags & PPC_OPCODE_VLE)
2950 {
2951 int tmp_insn = insn & opcode->mask;
2952
2953 int use_d_reloc = (tmp_insn == E_OR2I_INSN
2954 || tmp_insn == E_AND2I_DOT_INSN
2955 || tmp_insn == E_OR2IS_INSN
2956 || tmp_insn == E_LIS_INSN
2957 || tmp_insn == E_AND2IS_DOT_INSN);
2958
2959
2960 int use_a_reloc = (tmp_insn == E_ADD2I_DOT_INSN
2961 || tmp_insn == E_ADD2IS_INSN
2962 || tmp_insn == E_CMP16I_INSN
2963 || tmp_insn == E_MULL2I_INSN
2964 || tmp_insn == E_CMPL16I_INSN
2965 || tmp_insn == E_CMPH16I_INSN
2966 || tmp_insn == E_CMPHL16I_INSN);
2967
2968 switch (reloc)
2969 {
2970 default:
2971 break;
2972
2973 case BFD_RELOC_PPC_EMB_SDA21:
2974 reloc = BFD_RELOC_PPC_VLE_SDA21;
2975 break;
2976
2977 case BFD_RELOC_LO16:
2978 if (use_d_reloc)
2979 reloc = BFD_RELOC_PPC_VLE_LO16D;
2980 else if (use_a_reloc)
2981 reloc = BFD_RELOC_PPC_VLE_LO16A;
2982 break;
2983
2984 case BFD_RELOC_HI16:
2985 if (use_d_reloc)
2986 reloc = BFD_RELOC_PPC_VLE_HI16D;
2987 else if (use_a_reloc)
2988 reloc = BFD_RELOC_PPC_VLE_HI16A;
2989 break;
2990
2991 case BFD_RELOC_HI16_S:
2992 if (use_d_reloc)
2993 reloc = BFD_RELOC_PPC_VLE_HA16D;
2994 else if (use_a_reloc)
2995 reloc = BFD_RELOC_PPC_VLE_HA16A;
2996 break;
2997
2998 case BFD_RELOC_PPC_VLE_SDAREL_LO16A:
2999 if (use_d_reloc)
3000 reloc = BFD_RELOC_PPC_VLE_SDAREL_LO16D;
3001 break;
3002
3003 case BFD_RELOC_PPC_VLE_SDAREL_HI16A:
3004 if (use_d_reloc)
3005 reloc = BFD_RELOC_PPC_VLE_SDAREL_HI16D;
3006 break;
3007
3008 case BFD_RELOC_PPC_VLE_SDAREL_HA16A:
3009 if (use_d_reloc)
3010 reloc = BFD_RELOC_PPC_VLE_SDAREL_HA16D;
3011 break;
3012 }
3013 }
3014
3015 /* For the absolute forms of branches, convert the PC
3016 relative form back into the absolute. */
3017 if ((operand->flags & PPC_OPERAND_ABSOLUTE) != 0)
3018 {
3019 switch (reloc)
3020 {
3021 case BFD_RELOC_PPC_B26:
3022 reloc = BFD_RELOC_PPC_BA26;
3023 break;
3024 case BFD_RELOC_PPC_B16:
3025 reloc = BFD_RELOC_PPC_BA16;
3026 break;
3027 case BFD_RELOC_PPC_B16_BRTAKEN:
3028 reloc = BFD_RELOC_PPC_BA16_BRTAKEN;
3029 break;
3030 case BFD_RELOC_PPC_B16_BRNTAKEN:
3031 reloc = BFD_RELOC_PPC_BA16_BRNTAKEN;
3032 break;
3033 default:
3034 break;
3035 }
3036 }
3037
3038 switch (reloc)
3039 {
3040 case BFD_RELOC_PPC_TOC16:
3041 toc_reloc_types |= has_small_toc_reloc;
3042 break;
3043 case BFD_RELOC_PPC64_TOC16_LO:
3044 case BFD_RELOC_PPC64_TOC16_HI:
3045 case BFD_RELOC_PPC64_TOC16_HA:
3046 toc_reloc_types |= has_large_toc_reloc;
3047 break;
3048 default:
3049 break;
3050 }
3051
3052 if ((operand->flags & (PPC_OPERAND_DS | PPC_OPERAND_DQ)) != 0)
3053 {
3054 switch (reloc)
3055 {
3056 case BFD_RELOC_16:
3057 reloc = BFD_RELOC_PPC64_ADDR16_DS;
3058 break;
3059 case BFD_RELOC_LO16:
3060 reloc = BFD_RELOC_PPC64_ADDR16_LO_DS;
3061 break;
3062 case BFD_RELOC_16_GOTOFF:
3063 reloc = BFD_RELOC_PPC64_GOT16_DS;
3064 break;
3065 case BFD_RELOC_LO16_GOTOFF:
3066 reloc = BFD_RELOC_PPC64_GOT16_LO_DS;
3067 break;
3068 case BFD_RELOC_LO16_PLTOFF:
3069 reloc = BFD_RELOC_PPC64_PLT16_LO_DS;
3070 break;
3071 case BFD_RELOC_16_BASEREL:
3072 reloc = BFD_RELOC_PPC64_SECTOFF_DS;
3073 break;
3074 case BFD_RELOC_LO16_BASEREL:
3075 reloc = BFD_RELOC_PPC64_SECTOFF_LO_DS;
3076 break;
3077 case BFD_RELOC_PPC_TOC16:
3078 reloc = BFD_RELOC_PPC64_TOC16_DS;
3079 break;
3080 case BFD_RELOC_PPC64_TOC16_LO:
3081 reloc = BFD_RELOC_PPC64_TOC16_LO_DS;
3082 break;
3083 case BFD_RELOC_PPC64_PLTGOT16:
3084 reloc = BFD_RELOC_PPC64_PLTGOT16_DS;
3085 break;
3086 case BFD_RELOC_PPC64_PLTGOT16_LO:
3087 reloc = BFD_RELOC_PPC64_PLTGOT16_LO_DS;
3088 break;
3089 case BFD_RELOC_PPC_DTPREL16:
3090 reloc = BFD_RELOC_PPC64_DTPREL16_DS;
3091 break;
3092 case BFD_RELOC_PPC_DTPREL16_LO:
3093 reloc = BFD_RELOC_PPC64_DTPREL16_LO_DS;
3094 break;
3095 case BFD_RELOC_PPC_TPREL16:
3096 reloc = BFD_RELOC_PPC64_TPREL16_DS;
3097 break;
3098 case BFD_RELOC_PPC_TPREL16_LO:
3099 reloc = BFD_RELOC_PPC64_TPREL16_LO_DS;
3100 break;
3101 case BFD_RELOC_PPC_GOT_DTPREL16:
3102 case BFD_RELOC_PPC_GOT_DTPREL16_LO:
3103 case BFD_RELOC_PPC_GOT_TPREL16:
3104 case BFD_RELOC_PPC_GOT_TPREL16_LO:
3105 break;
3106 default:
3107 as_bad (_("unsupported relocation for DS offset field"));
3108 break;
3109 }
3110 }
3111 }
3112 #endif /* OBJ_ELF */
3113
3114 if (reloc != BFD_RELOC_UNUSED)
3115 ;
3116 /* Determine a BFD reloc value based on the operand information.
3117 We are only prepared to turn a few of the operands into
3118 relocs. */
3119 else if ((operand->flags & PPC_OPERAND_RELATIVE) != 0
3120 && operand->bitm == 0x3fffffc
3121 && operand->shift == 0)
3122 reloc = BFD_RELOC_PPC_B26;
3123 else if ((operand->flags & PPC_OPERAND_RELATIVE) != 0
3124 && operand->bitm == 0xfffc
3125 && operand->shift == 0)
3126 reloc = BFD_RELOC_PPC_B16;
3127 else if ((operand->flags & PPC_OPERAND_RELATIVE) != 0
3128 && operand->bitm == 0x1fe
3129 && operand->shift == -1)
3130 reloc = BFD_RELOC_PPC_VLE_REL8;
3131 else if ((operand->flags & PPC_OPERAND_RELATIVE) != 0
3132 && operand->bitm == 0xfffe
3133 && operand->shift == 0)
3134 reloc = BFD_RELOC_PPC_VLE_REL15;
3135 else if ((operand->flags & PPC_OPERAND_RELATIVE) != 0
3136 && operand->bitm == 0x1fffffe
3137 && operand->shift == 0)
3138 reloc = BFD_RELOC_PPC_VLE_REL24;
3139 else if ((operand->flags & PPC_OPERAND_ABSOLUTE) != 0
3140 && operand->bitm == 0x3fffffc
3141 && operand->shift == 0)
3142 reloc = BFD_RELOC_PPC_BA26;
3143 else if ((operand->flags & PPC_OPERAND_ABSOLUTE) != 0
3144 && operand->bitm == 0xfffc
3145 && operand->shift == 0)
3146 reloc = BFD_RELOC_PPC_BA16;
3147 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
3148 else if ((operand->flags & PPC_OPERAND_PARENS) != 0
3149 && (operand->bitm & 0xfff0) == 0xfff0
3150 && operand->shift == 0)
3151 {
3152 if (ppc_is_toc_sym (ex.X_add_symbol))
3153 {
3154 reloc = BFD_RELOC_PPC_TOC16;
3155 #ifdef OBJ_ELF
3156 if (ppc_obj64
3157 && (operand->flags & PPC_OPERAND_DS) != 0)
3158 reloc = BFD_RELOC_PPC64_TOC16_DS;
3159 #endif
3160 }
3161 else
3162 {
3163 reloc = BFD_RELOC_16;
3164 #ifdef OBJ_ELF
3165 if (ppc_obj64
3166 && (operand->flags & PPC_OPERAND_DS) != 0)
3167 reloc = BFD_RELOC_PPC64_ADDR16_DS;
3168 #endif
3169 }
3170 }
3171 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
3172
3173 /* We need to generate a fixup for this expression. */
3174 if (fc >= MAX_INSN_FIXUPS)
3175 as_fatal (_("too many fixups"));
3176 fixups[fc].exp = ex;
3177 fixups[fc].opindex = *opindex_ptr;
3178 fixups[fc].reloc = reloc;
3179 ++fc;
3180 }
3181
3182 if (need_paren)
3183 {
3184 endc = ')';
3185 need_paren = 0;
3186 /* If expecting more operands, then we want to see "),". */
3187 if (*str == endc && opindex_ptr[1] != 0)
3188 {
3189 do
3190 ++str;
3191 while (ISSPACE (*str));
3192 endc = ',';
3193 }
3194 }
3195 else if ((operand->flags & PPC_OPERAND_PARENS) != 0)
3196 {
3197 endc = '(';
3198 need_paren = 1;
3199 }
3200 else
3201 endc = ',';
3202
3203 /* The call to expression should have advanced str past any
3204 whitespace. */
3205 if (*str != endc
3206 && (endc != ',' || *str != '\0'))
3207 {
3208 if (*str == '\0')
3209 as_bad (_("syntax error; end of line, expected `%c'"), endc);
3210 else
3211 as_bad (_("syntax error; found `%c', expected `%c'"), *str, endc);
3212 break;
3213 }
3214
3215 if (*str != '\0')
3216 ++str;
3217 }
3218
3219 while (ISSPACE (*str))
3220 ++str;
3221
3222 if (*str != '\0')
3223 as_bad (_("junk at end of line: `%s'"), str);
3224
3225 #ifdef OBJ_ELF
3226 /* Do we need/want an APUinfo section? */
3227 if ((ppc_cpu & (PPC_OPCODE_E500 | PPC_OPCODE_E500MC | PPC_OPCODE_VLE)) != 0
3228 && !ppc_obj64)
3229 {
3230 /* These are all version "1". */
3231 if (opcode->flags & PPC_OPCODE_SPE)
3232 ppc_apuinfo_section_add (PPC_APUINFO_SPE, 1);
3233 if (opcode->flags & PPC_OPCODE_ISEL)
3234 ppc_apuinfo_section_add (PPC_APUINFO_ISEL, 1);
3235 if (opcode->flags & PPC_OPCODE_EFS)
3236 ppc_apuinfo_section_add (PPC_APUINFO_EFS, 1);
3237 if (opcode->flags & PPC_OPCODE_BRLOCK)
3238 ppc_apuinfo_section_add (PPC_APUINFO_BRLOCK, 1);
3239 if (opcode->flags & PPC_OPCODE_PMR)
3240 ppc_apuinfo_section_add (PPC_APUINFO_PMR, 1);
3241 if (opcode->flags & PPC_OPCODE_CACHELCK)
3242 ppc_apuinfo_section_add (PPC_APUINFO_CACHELCK, 1);
3243 if (opcode->flags & PPC_OPCODE_RFMCI)
3244 ppc_apuinfo_section_add (PPC_APUINFO_RFMCI, 1);
3245 if (opcode->flags & PPC_OPCODE_VLE)
3246 ppc_apuinfo_section_add (PPC_APUINFO_VLE, 1);
3247 }
3248 #endif
3249
3250 /* Write out the instruction. */
3251 /* Differentiate between two and four byte insns. */
3252 if (ppc_mach () == bfd_mach_ppc_vle)
3253 {
3254 if (PPC_OP_SE_VLE (insn))
3255 insn_length = 2;
3256 else
3257 insn_length = 4;
3258 addr_mod = frag_now_fix () & 1;
3259 }
3260 else
3261 {
3262 insn_length = 4;
3263 addr_mod = frag_now_fix () & 3;
3264 }
3265 /* All instructions can start on a 2 byte boundary for VLE. */
3266 f = frag_more (insn_length);
3267 if (frag_now->has_code && frag_now->insn_addr != addr_mod)
3268 {
3269 if (ppc_mach() == bfd_mach_ppc_vle)
3270 as_bad (_("instruction address is not a multiple of 2"));
3271 else
3272 as_bad (_("instruction address is not a multiple of 4"));
3273 }
3274 frag_now->insn_addr = addr_mod;
3275 frag_now->has_code = 1;
3276 md_number_to_chars (f, insn, insn_length);
3277
3278 #ifdef OBJ_ELF
3279 dwarf2_emit_insn (insn_length);
3280 #endif
3281
3282 /* Create any fixups. */
3283 for (i = 0; i < fc; i++)
3284 {
3285 fixS *fixP;
3286 if (fixups[i].reloc != BFD_RELOC_UNUSED)
3287 {
3288 reloc_howto_type *reloc_howto;
3289 int size;
3290 int offset;
3291
3292 reloc_howto = bfd_reloc_type_lookup (stdoutput, fixups[i].reloc);
3293 if (!reloc_howto)
3294 abort ();
3295
3296 size = bfd_get_reloc_size (reloc_howto);
3297 offset = target_big_endian ? (insn_length - size) : 0;
3298
3299 if (size < 1 || size > 4)
3300 abort ();
3301
3302 fixP = fix_new_exp (frag_now,
3303 f - frag_now->fr_literal + offset,
3304 size,
3305 &fixups[i].exp,
3306 reloc_howto->pc_relative,
3307 fixups[i].reloc);
3308 }
3309 else
3310 {
3311 const struct powerpc_operand *operand;
3312
3313 operand = &powerpc_operands[fixups[i].opindex];
3314 fixP = fix_new_exp (frag_now,
3315 f - frag_now->fr_literal,
3316 insn_length,
3317 &fixups[i].exp,
3318 (operand->flags & PPC_OPERAND_RELATIVE) != 0,
3319 BFD_RELOC_UNUSED);
3320 }
3321 fixP->fx_pcrel_adjust = fixups[i].opindex;
3322 }
3323 }
3324
3325 /* Handle a macro. Gather all the operands, transform them as
3326 described by the macro, and call md_assemble recursively. All the
3327 operands are separated by commas; we don't accept parentheses
3328 around operands here. */
3329
3330 static void
3331 ppc_macro (char *str, const struct powerpc_macro *macro)
3332 {
3333 char *operands[10];
3334 unsigned int count;
3335 char *s;
3336 unsigned int len;
3337 const char *format;
3338 unsigned int arg;
3339 char *send;
3340 char *complete;
3341
3342 /* Gather the users operands into the operands array. */
3343 count = 0;
3344 s = str;
3345 while (1)
3346 {
3347 if (count >= sizeof operands / sizeof operands[0])
3348 break;
3349 operands[count++] = s;
3350 s = strchr (s, ',');
3351 if (s == (char *) NULL)
3352 break;
3353 *s++ = '\0';
3354 }
3355
3356 if (count != macro->operands)
3357 {
3358 as_bad (_("wrong number of operands"));
3359 return;
3360 }
3361
3362 /* Work out how large the string must be (the size is unbounded
3363 because it includes user input). */
3364 len = 0;
3365 format = macro->format;
3366 while (*format != '\0')
3367 {
3368 if (*format != '%')
3369 {
3370 ++len;
3371 ++format;
3372 }
3373 else
3374 {
3375 arg = strtol (format + 1, &send, 10);
3376 know (send != format && arg < count);
3377 len += strlen (operands[arg]);
3378 format = send;
3379 }
3380 }
3381
3382 /* Put the string together. */
3383 complete = s = (char *) alloca (len + 1);
3384 format = macro->format;
3385 while (*format != '\0')
3386 {
3387 if (*format != '%')
3388 *s++ = *format++;
3389 else
3390 {
3391 arg = strtol (format + 1, &send, 10);
3392 strcpy (s, operands[arg]);
3393 s += strlen (s);
3394 format = send;
3395 }
3396 }
3397 *s = '\0';
3398
3399 /* Assemble the constructed instruction. */
3400 md_assemble (complete);
3401 }
3402 \f
3403 #ifdef OBJ_ELF
3404 /* For ELF, add support for SHT_ORDERED. */
3405
3406 int
3407 ppc_section_type (char *str, size_t len)
3408 {
3409 if (len == 7 && strncmp (str, "ordered", 7) == 0)
3410 return SHT_ORDERED;
3411
3412 return -1;
3413 }
3414
3415 int
3416 ppc_section_flags (flagword flags, bfd_vma attr ATTRIBUTE_UNUSED, int type)
3417 {
3418 if (type == SHT_ORDERED)
3419 flags |= SEC_ALLOC | SEC_LOAD | SEC_SORT_ENTRIES;
3420
3421 return flags;
3422 }
3423 #endif /* OBJ_ELF */
3424
3425 \f
3426 /* Pseudo-op handling. */
3427
3428 /* The .byte pseudo-op. This is similar to the normal .byte
3429 pseudo-op, but it can also take a single ASCII string. */
3430
3431 static void
3432 ppc_byte (int ignore ATTRIBUTE_UNUSED)
3433 {
3434 if (*input_line_pointer != '\"')
3435 {
3436 cons (1);
3437 return;
3438 }
3439
3440 /* Gather characters. A real double quote is doubled. Unusual
3441 characters are not permitted. */
3442 ++input_line_pointer;
3443 while (1)
3444 {
3445 char c;
3446
3447 c = *input_line_pointer++;
3448
3449 if (c == '\"')
3450 {
3451 if (*input_line_pointer != '\"')
3452 break;
3453 ++input_line_pointer;
3454 }
3455
3456 FRAG_APPEND_1_CHAR (c);
3457 }
3458
3459 demand_empty_rest_of_line ();
3460 }
3461 \f
3462 #ifdef OBJ_XCOFF
3463
3464 /* XCOFF specific pseudo-op handling. */
3465
3466 /* This is set if we are creating a .stabx symbol, since we don't want
3467 to handle symbol suffixes for such symbols. */
3468 static bfd_boolean ppc_stab_symbol;
3469
3470 /* The .comm and .lcomm pseudo-ops for XCOFF. XCOFF puts common
3471 symbols in the .bss segment as though they were local common
3472 symbols, and uses a different smclas. The native Aix 4.3.3 assembler
3473 aligns .comm and .lcomm to 4 bytes. */
3474
3475 static void
3476 ppc_comm (int lcomm)
3477 {
3478 asection *current_seg = now_seg;
3479 subsegT current_subseg = now_subseg;
3480 char *name;
3481 char endc;
3482 char *end_name;
3483 offsetT size;
3484 offsetT align;
3485 symbolS *lcomm_sym = NULL;
3486 symbolS *sym;
3487 char *pfrag;
3488
3489 name = input_line_pointer;
3490 endc = get_symbol_end ();
3491 end_name = input_line_pointer;
3492 *end_name = endc;
3493
3494 if (*input_line_pointer != ',')
3495 {
3496 as_bad (_("missing size"));
3497 ignore_rest_of_line ();
3498 return;
3499 }
3500 ++input_line_pointer;
3501
3502 size = get_absolute_expression ();
3503 if (size < 0)
3504 {
3505 as_bad (_("negative size"));
3506 ignore_rest_of_line ();
3507 return;
3508 }
3509
3510 if (! lcomm)
3511 {
3512 /* The third argument to .comm is the alignment. */
3513 if (*input_line_pointer != ',')
3514 align = 2;
3515 else
3516 {
3517 ++input_line_pointer;
3518 align = get_absolute_expression ();
3519 if (align <= 0)
3520 {
3521 as_warn (_("ignoring bad alignment"));
3522 align = 2;
3523 }
3524 }
3525 }
3526 else
3527 {
3528 char *lcomm_name;
3529 char lcomm_endc;
3530
3531 if (size <= 4)
3532 align = 2;
3533 else
3534 align = 3;
3535
3536 /* The third argument to .lcomm appears to be the real local
3537 common symbol to create. References to the symbol named in
3538 the first argument are turned into references to the third
3539 argument. */
3540 if (*input_line_pointer != ',')
3541 {
3542 as_bad (_("missing real symbol name"));
3543 ignore_rest_of_line ();
3544 return;
3545 }
3546 ++input_line_pointer;
3547
3548 lcomm_name = input_line_pointer;
3549 lcomm_endc = get_symbol_end ();
3550
3551 lcomm_sym = symbol_find_or_make (lcomm_name);
3552
3553 *input_line_pointer = lcomm_endc;
3554 }
3555
3556 *end_name = '\0';
3557 sym = symbol_find_or_make (name);
3558 *end_name = endc;
3559
3560 if (S_IS_DEFINED (sym)
3561 || S_GET_VALUE (sym) != 0)
3562 {
3563 as_bad (_("attempt to redefine symbol"));
3564 ignore_rest_of_line ();
3565 return;
3566 }
3567
3568 record_alignment (bss_section, align);
3569
3570 if (! lcomm
3571 || ! S_IS_DEFINED (lcomm_sym))
3572 {
3573 symbolS *def_sym;
3574 offsetT def_size;
3575
3576 if (! lcomm)
3577 {
3578 def_sym = sym;
3579 def_size = size;
3580 S_SET_EXTERNAL (sym);
3581 }
3582 else
3583 {
3584 symbol_get_tc (lcomm_sym)->output = 1;
3585 def_sym = lcomm_sym;
3586 def_size = 0;
3587 }
3588
3589 subseg_set (bss_section, 1);
3590 frag_align (align, 0, 0);
3591
3592 symbol_set_frag (def_sym, frag_now);
3593 pfrag = frag_var (rs_org, 1, 1, (relax_substateT) 0, def_sym,
3594 def_size, (char *) NULL);
3595 *pfrag = 0;
3596 S_SET_SEGMENT (def_sym, bss_section);
3597 symbol_get_tc (def_sym)->align = align;
3598 }
3599 else if (lcomm)
3600 {
3601 /* Align the size of lcomm_sym. */
3602 symbol_get_frag (lcomm_sym)->fr_offset =
3603 ((symbol_get_frag (lcomm_sym)->fr_offset + (1 << align) - 1)
3604 &~ ((1 << align) - 1));
3605 if (align > symbol_get_tc (lcomm_sym)->align)
3606 symbol_get_tc (lcomm_sym)->align = align;
3607 }
3608
3609 if (lcomm)
3610 {
3611 /* Make sym an offset from lcomm_sym. */
3612 S_SET_SEGMENT (sym, bss_section);
3613 symbol_set_frag (sym, symbol_get_frag (lcomm_sym));
3614 S_SET_VALUE (sym, symbol_get_frag (lcomm_sym)->fr_offset);
3615 symbol_get_frag (lcomm_sym)->fr_offset += size;
3616 }
3617
3618 subseg_set (current_seg, current_subseg);
3619
3620 demand_empty_rest_of_line ();
3621 }
3622
3623 /* The .csect pseudo-op. This switches us into a different
3624 subsegment. The first argument is a symbol whose value is the
3625 start of the .csect. In COFF, csect symbols get special aux
3626 entries defined by the x_csect field of union internal_auxent. The
3627 optional second argument is the alignment (the default is 2). */
3628
3629 static void
3630 ppc_csect (int ignore ATTRIBUTE_UNUSED)
3631 {
3632 char *name;
3633 char endc;
3634 symbolS *sym;
3635 offsetT align;
3636
3637 name = input_line_pointer;
3638 endc = get_symbol_end ();
3639
3640 sym = symbol_find_or_make (name);
3641
3642 *input_line_pointer = endc;
3643
3644 if (S_GET_NAME (sym)[0] == '\0')
3645 {
3646 /* An unnamed csect is assumed to be [PR]. */
3647 symbol_get_tc (sym)->symbol_class = XMC_PR;
3648 }
3649
3650 align = 2;
3651 if (*input_line_pointer == ',')
3652 {
3653 ++input_line_pointer;
3654 align = get_absolute_expression ();
3655 }
3656
3657 ppc_change_csect (sym, align);
3658
3659 demand_empty_rest_of_line ();
3660 }
3661
3662 /* Change to a different csect. */
3663
3664 static void
3665 ppc_change_csect (symbolS *sym, offsetT align)
3666 {
3667 if (S_IS_DEFINED (sym))
3668 subseg_set (S_GET_SEGMENT (sym), symbol_get_tc (sym)->subseg);
3669 else
3670 {
3671 symbolS **list_ptr;
3672 int after_toc;
3673 int hold_chunksize;
3674 symbolS *list;
3675 int is_code;
3676 segT sec;
3677
3678 /* This is a new csect. We need to look at the symbol class to
3679 figure out whether it should go in the text section or the
3680 data section. */
3681 after_toc = 0;
3682 is_code = 0;
3683 switch (symbol_get_tc (sym)->symbol_class)
3684 {
3685 case XMC_PR:
3686 case XMC_RO:
3687 case XMC_DB:
3688 case XMC_GL:
3689 case XMC_XO:
3690 case XMC_SV:
3691 case XMC_TI:
3692 case XMC_TB:
3693 S_SET_SEGMENT (sym, text_section);
3694 symbol_get_tc (sym)->subseg = ppc_text_subsegment;
3695 ++ppc_text_subsegment;
3696 list_ptr = &ppc_text_csects;
3697 is_code = 1;
3698 break;
3699 case XMC_RW:
3700 case XMC_TC0:
3701 case XMC_TC:
3702 case XMC_DS:
3703 case XMC_UA:
3704 case XMC_BS:
3705 case XMC_UC:
3706 if (ppc_toc_csect != NULL
3707 && (symbol_get_tc (ppc_toc_csect)->subseg + 1
3708 == ppc_data_subsegment))
3709 after_toc = 1;
3710 S_SET_SEGMENT (sym, data_section);
3711 symbol_get_tc (sym)->subseg = ppc_data_subsegment;
3712 ++ppc_data_subsegment;
3713 list_ptr = &ppc_data_csects;
3714 break;
3715 default:
3716 abort ();
3717 }
3718
3719 /* We set the obstack chunk size to a small value before
3720 changing subsegments, so that we don't use a lot of memory
3721 space for what may be a small section. */
3722 hold_chunksize = chunksize;
3723 chunksize = 64;
3724
3725 sec = subseg_new (segment_name (S_GET_SEGMENT (sym)),
3726 symbol_get_tc (sym)->subseg);
3727
3728 chunksize = hold_chunksize;
3729
3730 if (after_toc)
3731 ppc_after_toc_frag = frag_now;
3732
3733 record_alignment (sec, align);
3734 if (is_code)
3735 frag_align_code (align, 0);
3736 else
3737 frag_align (align, 0, 0);
3738
3739 symbol_set_frag (sym, frag_now);
3740 S_SET_VALUE (sym, (valueT) frag_now_fix ());
3741
3742 symbol_get_tc (sym)->align = align;
3743 symbol_get_tc (sym)->output = 1;
3744 symbol_get_tc (sym)->within = sym;
3745
3746 for (list = *list_ptr;
3747 symbol_get_tc (list)->next != (symbolS *) NULL;
3748 list = symbol_get_tc (list)->next)
3749 ;
3750 symbol_get_tc (list)->next = sym;
3751
3752 symbol_remove (sym, &symbol_rootP, &symbol_lastP);
3753 symbol_append (sym, symbol_get_tc (list)->within, &symbol_rootP,
3754 &symbol_lastP);
3755 }
3756
3757 ppc_current_csect = sym;
3758 }
3759
3760 static void
3761 ppc_change_debug_section (unsigned int idx, subsegT subseg)
3762 {
3763 segT sec;
3764 flagword oldflags;
3765 const struct xcoff_dwsect_name *dw = &xcoff_dwsect_names[idx];
3766
3767 sec = subseg_new (dw->name, subseg);
3768 oldflags = bfd_get_section_flags (stdoutput, sec);
3769 if (oldflags == SEC_NO_FLAGS)
3770 {
3771 /* Just created section. */
3772 gas_assert (dw_sections[idx].sect == NULL);
3773
3774 bfd_set_section_flags (stdoutput, sec, SEC_DEBUGGING);
3775 bfd_set_section_alignment (stdoutput, sec, 0);
3776 dw_sections[idx].sect = sec;
3777 }
3778
3779 /* Not anymore in a csect. */
3780 ppc_current_csect = NULL;
3781 }
3782
3783 /* The .dwsect pseudo-op. Defines a DWARF section. Syntax is:
3784 .dwsect flag [, opt-label ]
3785 */
3786
3787 static void
3788 ppc_dwsect (int ignore ATTRIBUTE_UNUSED)
3789 {
3790 offsetT flag;
3791 symbolS *opt_label;
3792 const struct xcoff_dwsect_name *dw;
3793 struct dw_subsection *subseg;
3794 struct dw_section *dws;
3795 int i;
3796
3797 /* Find section. */
3798 flag = get_absolute_expression ();
3799 dw = NULL;
3800 for (i = 0; i < XCOFF_DWSECT_NBR_NAMES; i++)
3801 if (xcoff_dwsect_names[i].flag == flag)
3802 {
3803 dw = &xcoff_dwsect_names[i];
3804 break;
3805 }
3806
3807 /* Parse opt-label. */
3808 if (*input_line_pointer == ',')
3809 {
3810 const char *label;
3811 char c;
3812
3813 ++input_line_pointer;
3814
3815 label = input_line_pointer;
3816 c = get_symbol_end ();
3817 opt_label = symbol_find_or_make (label);
3818 *input_line_pointer = c;
3819 }
3820 else
3821 opt_label = NULL;
3822
3823 demand_empty_rest_of_line ();
3824
3825 /* Return now in case of unknown subsection. */
3826 if (dw == NULL)
3827 {
3828 as_bad (_("no known dwarf XCOFF section for flag 0x%08x\n"),
3829 (unsigned)flag);
3830 return;
3831 }
3832
3833 /* Find the subsection. */
3834 dws = &dw_sections[i];
3835 subseg = NULL;
3836 if (opt_label != NULL && S_IS_DEFINED (opt_label))
3837 {
3838 /* Sanity check (note that in theory S_GET_SEGMENT mustn't be null). */
3839 if (dws->sect == NULL || S_GET_SEGMENT (opt_label) != dws->sect)
3840 {
3841 as_bad (_("label %s was not defined in this dwarf section"),
3842 S_GET_NAME (opt_label));
3843 subseg = dws->anon_subseg;
3844 opt_label = NULL;
3845 }
3846 else
3847 subseg = symbol_get_tc (opt_label)->u.dw;
3848 }
3849
3850 if (subseg != NULL)
3851 {
3852 /* Switch to the subsection. */
3853 ppc_change_debug_section (i, subseg->subseg);
3854 }
3855 else
3856 {
3857 /* Create a new dw subsection. */
3858 subseg = (struct dw_subsection *)
3859 xmalloc (sizeof (struct dw_subsection));
3860
3861 if (opt_label == NULL)
3862 {
3863 /* The anonymous one. */
3864 subseg->subseg = 0;
3865 subseg->link = NULL;
3866 dws->anon_subseg = subseg;
3867 }
3868 else
3869 {
3870 /* A named one. */
3871 if (dws->list_subseg != NULL)
3872 subseg->subseg = dws->list_subseg->subseg + 1;
3873 else
3874 subseg->subseg = 1;
3875
3876 subseg->link = dws->list_subseg;
3877 dws->list_subseg = subseg;
3878 symbol_get_tc (opt_label)->u.dw = subseg;
3879 }
3880
3881 ppc_change_debug_section (i, subseg->subseg);
3882
3883 if (dw->def_size)
3884 {
3885 /* Add the length field. */
3886 expressionS *exp = &subseg->end_exp;
3887 int sz;
3888
3889 if (opt_label != NULL)
3890 symbol_set_value_now (opt_label);
3891
3892 /* Add the length field. Note that according to the AIX assembler
3893 manual, the size of the length field is 4 for powerpc32 but
3894 12 for powerpc64. */
3895 if (ppc_obj64)
3896 {
3897 /* Write the 64bit marker. */
3898 md_number_to_chars (frag_more (4), -1, 4);
3899 }
3900
3901 exp->X_op = O_subtract;
3902 exp->X_op_symbol = symbol_temp_new_now ();
3903 exp->X_add_symbol = symbol_temp_make ();
3904
3905 sz = ppc_obj64 ? 8 : 4;
3906 exp->X_add_number = -sz;
3907 emit_expr (exp, sz);
3908 }
3909 }
3910 }
3911
3912 /* This function handles the .text and .data pseudo-ops. These
3913 pseudo-ops aren't really used by XCOFF; we implement them for the
3914 convenience of people who aren't used to XCOFF. */
3915
3916 static void
3917 ppc_section (int type)
3918 {
3919 const char *name;
3920 symbolS *sym;
3921
3922 if (type == 't')
3923 name = ".text[PR]";
3924 else if (type == 'd')
3925 name = ".data[RW]";
3926 else
3927 abort ();
3928
3929 sym = symbol_find_or_make (name);
3930
3931 ppc_change_csect (sym, 2);
3932
3933 demand_empty_rest_of_line ();
3934 }
3935
3936 /* This function handles the .section pseudo-op. This is mostly to
3937 give an error, since XCOFF only supports .text, .data and .bss, but
3938 we do permit the user to name the text or data section. */
3939
3940 static void
3941 ppc_named_section (int ignore ATTRIBUTE_UNUSED)
3942 {
3943 char *user_name;
3944 const char *real_name;
3945 char c;
3946 symbolS *sym;
3947
3948 user_name = input_line_pointer;
3949 c = get_symbol_end ();
3950
3951 if (strcmp (user_name, ".text") == 0)
3952 real_name = ".text[PR]";
3953 else if (strcmp (user_name, ".data") == 0)
3954 real_name = ".data[RW]";
3955 else
3956 {
3957 as_bad (_("the XCOFF file format does not support arbitrary sections"));
3958 *input_line_pointer = c;
3959 ignore_rest_of_line ();
3960 return;
3961 }
3962
3963 *input_line_pointer = c;
3964
3965 sym = symbol_find_or_make (real_name);
3966
3967 ppc_change_csect (sym, 2);
3968
3969 demand_empty_rest_of_line ();
3970 }
3971
3972 /* The .extern pseudo-op. We create an undefined symbol. */
3973
3974 static void
3975 ppc_extern (int ignore ATTRIBUTE_UNUSED)
3976 {
3977 char *name;
3978 char endc;
3979
3980 name = input_line_pointer;
3981 endc = get_symbol_end ();
3982
3983 (void) symbol_find_or_make (name);
3984
3985 *input_line_pointer = endc;
3986
3987 demand_empty_rest_of_line ();
3988 }
3989
3990 /* The .lglobl pseudo-op. Keep the symbol in the symbol table. */
3991
3992 static void
3993 ppc_lglobl (int ignore ATTRIBUTE_UNUSED)
3994 {
3995 char *name;
3996 char endc;
3997 symbolS *sym;
3998
3999 name = input_line_pointer;
4000 endc = get_symbol_end ();
4001
4002 sym = symbol_find_or_make (name);
4003
4004 *input_line_pointer = endc;
4005
4006 symbol_get_tc (sym)->output = 1;
4007
4008 demand_empty_rest_of_line ();
4009 }
4010
4011 /* The .ref pseudo-op. It takes a list of symbol names and inserts R_REF
4012 relocations at the beginning of the current csect.
4013
4014 (In principle, there's no reason why the relocations _have_ to be at
4015 the beginning. Anywhere in the csect would do. However, inserting
4016 at the beginning is what the native assmebler does, and it helps to
4017 deal with cases where the .ref statements follow the section contents.)
4018
4019 ??? .refs don't work for empty .csects. However, the native assembler
4020 doesn't report an error in this case, and neither yet do we. */
4021
4022 static void
4023 ppc_ref (int ignore ATTRIBUTE_UNUSED)
4024 {
4025 char *name;
4026 char c;
4027
4028 if (ppc_current_csect == NULL)
4029 {
4030 as_bad (_(".ref outside .csect"));
4031 ignore_rest_of_line ();
4032 return;
4033 }
4034
4035 do
4036 {
4037 name = input_line_pointer;
4038 c = get_symbol_end ();
4039
4040 fix_at_start (symbol_get_frag (ppc_current_csect), 0,
4041 symbol_find_or_make (name), 0, FALSE, BFD_RELOC_NONE);
4042
4043 *input_line_pointer = c;
4044 SKIP_WHITESPACE ();
4045 c = *input_line_pointer;
4046 if (c == ',')
4047 {
4048 input_line_pointer++;
4049 SKIP_WHITESPACE ();
4050 if (is_end_of_line[(unsigned char) *input_line_pointer])
4051 {
4052 as_bad (_("missing symbol name"));
4053 ignore_rest_of_line ();
4054 return;
4055 }
4056 }
4057 }
4058 while (c == ',');
4059
4060 demand_empty_rest_of_line ();
4061 }
4062
4063 /* The .rename pseudo-op. The RS/6000 assembler can rename symbols,
4064 although I don't know why it bothers. */
4065
4066 static void
4067 ppc_rename (int ignore ATTRIBUTE_UNUSED)
4068 {
4069 char *name;
4070 char endc;
4071 symbolS *sym;
4072 int len;
4073
4074 name = input_line_pointer;
4075 endc = get_symbol_end ();
4076
4077 sym = symbol_find_or_make (name);
4078
4079 *input_line_pointer = endc;
4080
4081 if (*input_line_pointer != ',')
4082 {
4083 as_bad (_("missing rename string"));
4084 ignore_rest_of_line ();
4085 return;
4086 }
4087 ++input_line_pointer;
4088
4089 symbol_get_tc (sym)->real_name = demand_copy_C_string (&len);
4090
4091 demand_empty_rest_of_line ();
4092 }
4093
4094 /* The .stabx pseudo-op. This is similar to a normal .stabs
4095 pseudo-op, but slightly different. A sample is
4096 .stabx "main:F-1",.main,142,0
4097 The first argument is the symbol name to create. The second is the
4098 value, and the third is the storage class. The fourth seems to be
4099 always zero, and I am assuming it is the type. */
4100
4101 static void
4102 ppc_stabx (int ignore ATTRIBUTE_UNUSED)
4103 {
4104 char *name;
4105 int len;
4106 symbolS *sym;
4107 expressionS exp;
4108
4109 name = demand_copy_C_string (&len);
4110
4111 if (*input_line_pointer != ',')
4112 {
4113 as_bad (_("missing value"));
4114 return;
4115 }
4116 ++input_line_pointer;
4117
4118 ppc_stab_symbol = TRUE;
4119 sym = symbol_make (name);
4120 ppc_stab_symbol = FALSE;
4121
4122 symbol_get_tc (sym)->real_name = name;
4123
4124 (void) expression (&exp);
4125
4126 switch (exp.X_op)
4127 {
4128 case O_illegal:
4129 case O_absent:
4130 case O_big:
4131 as_bad (_("illegal .stabx expression; zero assumed"));
4132 exp.X_add_number = 0;
4133 /* Fall through. */
4134 case O_constant:
4135 S_SET_VALUE (sym, (valueT) exp.X_add_number);
4136 symbol_set_frag (sym, &zero_address_frag);
4137 break;
4138
4139 case O_symbol:
4140 if (S_GET_SEGMENT (exp.X_add_symbol) == undefined_section)
4141 symbol_set_value_expression (sym, &exp);
4142 else
4143 {
4144 S_SET_VALUE (sym,
4145 exp.X_add_number + S_GET_VALUE (exp.X_add_symbol));
4146 symbol_set_frag (sym, symbol_get_frag (exp.X_add_symbol));
4147 }
4148 break;
4149
4150 default:
4151 /* The value is some complex expression. This will probably
4152 fail at some later point, but this is probably the right
4153 thing to do here. */
4154 symbol_set_value_expression (sym, &exp);
4155 break;
4156 }
4157
4158 S_SET_SEGMENT (sym, ppc_coff_debug_section);
4159 symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
4160
4161 if (*input_line_pointer != ',')
4162 {
4163 as_bad (_("missing class"));
4164 return;
4165 }
4166 ++input_line_pointer;
4167
4168 S_SET_STORAGE_CLASS (sym, get_absolute_expression ());
4169
4170 if (*input_line_pointer != ',')
4171 {
4172 as_bad (_("missing type"));
4173 return;
4174 }
4175 ++input_line_pointer;
4176
4177 S_SET_DATA_TYPE (sym, get_absolute_expression ());
4178
4179 symbol_get_tc (sym)->output = 1;
4180
4181 if (S_GET_STORAGE_CLASS (sym) == C_STSYM)
4182 {
4183 /* In this case :
4184
4185 .bs name
4186 .stabx "z",arrays_,133,0
4187 .es
4188
4189 .comm arrays_,13768,3
4190
4191 resolve_symbol_value will copy the exp's "within" into sym's when the
4192 offset is 0. Since this seems to be corner case problem,
4193 only do the correction for storage class C_STSYM. A better solution
4194 would be to have the tc field updated in ppc_symbol_new_hook. */
4195
4196 if (exp.X_op == O_symbol)
4197 {
4198 if (ppc_current_block == NULL)
4199 as_bad (_(".stabx of storage class stsym must be within .bs/.es"));
4200
4201 symbol_get_tc (sym)->within = ppc_current_block;
4202 symbol_get_tc (exp.X_add_symbol)->within = ppc_current_block;
4203 }
4204 }
4205
4206 if (exp.X_op != O_symbol
4207 || ! S_IS_EXTERNAL (exp.X_add_symbol)
4208 || S_GET_SEGMENT (exp.X_add_symbol) != bss_section)
4209 ppc_frob_label (sym);
4210 else
4211 {
4212 symbol_remove (sym, &symbol_rootP, &symbol_lastP);
4213 symbol_append (sym, exp.X_add_symbol, &symbol_rootP, &symbol_lastP);
4214 if (symbol_get_tc (ppc_current_csect)->within == exp.X_add_symbol)
4215 symbol_get_tc (ppc_current_csect)->within = sym;
4216 }
4217
4218 demand_empty_rest_of_line ();
4219 }
4220
4221 /* The .function pseudo-op. This takes several arguments. The first
4222 argument seems to be the external name of the symbol. The second
4223 argument seems to be the label for the start of the function. gcc
4224 uses the same name for both. I have no idea what the third and
4225 fourth arguments are meant to be. The optional fifth argument is
4226 an expression for the size of the function. In COFF this symbol
4227 gets an aux entry like that used for a csect. */
4228
4229 static void
4230 ppc_function (int ignore ATTRIBUTE_UNUSED)
4231 {
4232 char *name;
4233 char endc;
4234 char *s;
4235 symbolS *ext_sym;
4236 symbolS *lab_sym;
4237
4238 name = input_line_pointer;
4239 endc = get_symbol_end ();
4240
4241 /* Ignore any [PR] suffix. */
4242 name = ppc_canonicalize_symbol_name (name);
4243 s = strchr (name, '[');
4244 if (s != (char *) NULL
4245 && strcmp (s + 1, "PR]") == 0)
4246 *s = '\0';
4247
4248 ext_sym = symbol_find_or_make (name);
4249
4250 *input_line_pointer = endc;
4251
4252 if (*input_line_pointer != ',')
4253 {
4254 as_bad (_("missing symbol name"));
4255 ignore_rest_of_line ();
4256 return;
4257 }
4258 ++input_line_pointer;
4259
4260 name = input_line_pointer;
4261 endc = get_symbol_end ();
4262
4263 lab_sym = symbol_find_or_make (name);
4264
4265 *input_line_pointer = endc;
4266
4267 if (ext_sym != lab_sym)
4268 {
4269 expressionS exp;
4270
4271 exp.X_op = O_symbol;
4272 exp.X_add_symbol = lab_sym;
4273 exp.X_op_symbol = NULL;
4274 exp.X_add_number = 0;
4275 exp.X_unsigned = 0;
4276 symbol_set_value_expression (ext_sym, &exp);
4277 }
4278
4279 if (symbol_get_tc (ext_sym)->symbol_class == -1)
4280 symbol_get_tc (ext_sym)->symbol_class = XMC_PR;
4281 symbol_get_tc (ext_sym)->output = 1;
4282
4283 if (*input_line_pointer == ',')
4284 {
4285 expressionS exp;
4286
4287 /* Ignore the third argument. */
4288 ++input_line_pointer;
4289 expression (& exp);
4290 if (*input_line_pointer == ',')
4291 {
4292 /* Ignore the fourth argument. */
4293 ++input_line_pointer;
4294 expression (& exp);
4295 if (*input_line_pointer == ',')
4296 {
4297 /* The fifth argument is the function size. */
4298 ++input_line_pointer;
4299 symbol_get_tc (ext_sym)->u.size = symbol_new
4300 ("L0\001", absolute_section,(valueT) 0, &zero_address_frag);
4301 pseudo_set (symbol_get_tc (ext_sym)->u.size);
4302 }
4303 }
4304 }
4305
4306 S_SET_DATA_TYPE (ext_sym, DT_FCN << N_BTSHFT);
4307 SF_SET_FUNCTION (ext_sym);
4308 SF_SET_PROCESS (ext_sym);
4309 coff_add_linesym (ext_sym);
4310
4311 demand_empty_rest_of_line ();
4312 }
4313
4314 /* The .bf pseudo-op. This is just like a COFF C_FCN symbol named
4315 ".bf". If the pseudo op .bi was seen before .bf, patch the .bi sym
4316 with the correct line number */
4317
4318 static symbolS *saved_bi_sym = 0;
4319
4320 static void
4321 ppc_bf (int ignore ATTRIBUTE_UNUSED)
4322 {
4323 symbolS *sym;
4324
4325 sym = symbol_make (".bf");
4326 S_SET_SEGMENT (sym, text_section);
4327 symbol_set_frag (sym, frag_now);
4328 S_SET_VALUE (sym, frag_now_fix ());
4329 S_SET_STORAGE_CLASS (sym, C_FCN);
4330
4331 coff_line_base = get_absolute_expression ();
4332
4333 S_SET_NUMBER_AUXILIARY (sym, 1);
4334 SA_SET_SYM_LNNO (sym, coff_line_base);
4335
4336 /* Line number for bi. */
4337 if (saved_bi_sym)
4338 {
4339 S_SET_VALUE (saved_bi_sym, coff_n_line_nos);
4340 saved_bi_sym = 0;
4341 }
4342
4343
4344 symbol_get_tc (sym)->output = 1;
4345
4346 ppc_frob_label (sym);
4347
4348 demand_empty_rest_of_line ();
4349 }
4350
4351 /* The .ef pseudo-op. This is just like a COFF C_FCN symbol named
4352 ".ef", except that the line number is absolute, not relative to the
4353 most recent ".bf" symbol. */
4354
4355 static void
4356 ppc_ef (int ignore ATTRIBUTE_UNUSED)
4357 {
4358 symbolS *sym;
4359
4360 sym = symbol_make (".ef");
4361 S_SET_SEGMENT (sym, text_section);
4362 symbol_set_frag (sym, frag_now);
4363 S_SET_VALUE (sym, frag_now_fix ());
4364 S_SET_STORAGE_CLASS (sym, C_FCN);
4365 S_SET_NUMBER_AUXILIARY (sym, 1);
4366 SA_SET_SYM_LNNO (sym, get_absolute_expression ());
4367 symbol_get_tc (sym)->output = 1;
4368
4369 ppc_frob_label (sym);
4370
4371 demand_empty_rest_of_line ();
4372 }
4373
4374 /* The .bi and .ei pseudo-ops. These take a string argument and
4375 generates a C_BINCL or C_EINCL symbol, which goes at the start of
4376 the symbol list. The value of .bi will be know when the next .bf
4377 is encountered. */
4378
4379 static void
4380 ppc_biei (int ei)
4381 {
4382 static symbolS *last_biei;
4383
4384 char *name;
4385 int len;
4386 symbolS *sym;
4387 symbolS *look;
4388
4389 name = demand_copy_C_string (&len);
4390
4391 /* The value of these symbols is actually file offset. Here we set
4392 the value to the index into the line number entries. In
4393 ppc_frob_symbols we set the fix_line field, which will cause BFD
4394 to do the right thing. */
4395
4396 sym = symbol_make (name);
4397 /* obj-coff.c currently only handles line numbers correctly in the
4398 .text section. */
4399 S_SET_SEGMENT (sym, text_section);
4400 S_SET_VALUE (sym, coff_n_line_nos);
4401 symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
4402
4403 S_SET_STORAGE_CLASS (sym, ei ? C_EINCL : C_BINCL);
4404 symbol_get_tc (sym)->output = 1;
4405
4406 /* Save bi. */
4407 if (ei)
4408 saved_bi_sym = 0;
4409 else
4410 saved_bi_sym = sym;
4411
4412 for (look = last_biei ? last_biei : symbol_rootP;
4413 (look != (symbolS *) NULL
4414 && (S_GET_STORAGE_CLASS (look) == C_FILE
4415 || S_GET_STORAGE_CLASS (look) == C_BINCL
4416 || S_GET_STORAGE_CLASS (look) == C_EINCL));
4417 look = symbol_next (look))
4418 ;
4419 if (look != (symbolS *) NULL)
4420 {
4421 symbol_remove (sym, &symbol_rootP, &symbol_lastP);
4422 symbol_insert (sym, look, &symbol_rootP, &symbol_lastP);
4423 last_biei = sym;
4424 }
4425
4426 demand_empty_rest_of_line ();
4427 }
4428
4429 /* The .bs pseudo-op. This generates a C_BSTAT symbol named ".bs".
4430 There is one argument, which is a csect symbol. The value of the
4431 .bs symbol is the index of this csect symbol. */
4432
4433 static void
4434 ppc_bs (int ignore ATTRIBUTE_UNUSED)
4435 {
4436 char *name;
4437 char endc;
4438 symbolS *csect;
4439 symbolS *sym;
4440
4441 if (ppc_current_block != NULL)
4442 as_bad (_("nested .bs blocks"));
4443
4444 name = input_line_pointer;
4445 endc = get_symbol_end ();
4446
4447 csect = symbol_find_or_make (name);
4448
4449 *input_line_pointer = endc;
4450
4451 sym = symbol_make (".bs");
4452 S_SET_SEGMENT (sym, now_seg);
4453 S_SET_STORAGE_CLASS (sym, C_BSTAT);
4454 symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
4455 symbol_get_tc (sym)->output = 1;
4456
4457 symbol_get_tc (sym)->within = csect;
4458
4459 ppc_frob_label (sym);
4460
4461 ppc_current_block = sym;
4462
4463 demand_empty_rest_of_line ();
4464 }
4465
4466 /* The .es pseudo-op. Generate a C_ESTART symbol named .es. */
4467
4468 static void
4469 ppc_es (int ignore ATTRIBUTE_UNUSED)
4470 {
4471 symbolS *sym;
4472
4473 if (ppc_current_block == NULL)
4474 as_bad (_(".es without preceding .bs"));
4475
4476 sym = symbol_make (".es");
4477 S_SET_SEGMENT (sym, now_seg);
4478 S_SET_STORAGE_CLASS (sym, C_ESTAT);
4479 symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
4480 symbol_get_tc (sym)->output = 1;
4481
4482 ppc_frob_label (sym);
4483
4484 ppc_current_block = NULL;
4485
4486 demand_empty_rest_of_line ();
4487 }
4488
4489 /* The .bb pseudo-op. Generate a C_BLOCK symbol named .bb, with a
4490 line number. */
4491
4492 static void
4493 ppc_bb (int ignore ATTRIBUTE_UNUSED)
4494 {
4495 symbolS *sym;
4496
4497 sym = symbol_make (".bb");
4498 S_SET_SEGMENT (sym, text_section);
4499 symbol_set_frag (sym, frag_now);
4500 S_SET_VALUE (sym, frag_now_fix ());
4501 S_SET_STORAGE_CLASS (sym, C_BLOCK);
4502
4503 S_SET_NUMBER_AUXILIARY (sym, 1);
4504 SA_SET_SYM_LNNO (sym, get_absolute_expression ());
4505
4506 symbol_get_tc (sym)->output = 1;
4507
4508 SF_SET_PROCESS (sym);
4509
4510 ppc_frob_label (sym);
4511
4512 demand_empty_rest_of_line ();
4513 }
4514
4515 /* The .eb pseudo-op. Generate a C_BLOCK symbol named .eb, with a
4516 line number. */
4517
4518 static void
4519 ppc_eb (int ignore ATTRIBUTE_UNUSED)
4520 {
4521 symbolS *sym;
4522
4523 sym = symbol_make (".eb");
4524 S_SET_SEGMENT (sym, text_section);
4525 symbol_set_frag (sym, frag_now);
4526 S_SET_VALUE (sym, frag_now_fix ());
4527 S_SET_STORAGE_CLASS (sym, C_BLOCK);
4528 S_SET_NUMBER_AUXILIARY (sym, 1);
4529 SA_SET_SYM_LNNO (sym, get_absolute_expression ());
4530 symbol_get_tc (sym)->output = 1;
4531
4532 SF_SET_PROCESS (sym);
4533
4534 ppc_frob_label (sym);
4535
4536 demand_empty_rest_of_line ();
4537 }
4538
4539 /* The .bc pseudo-op. This just creates a C_BCOMM symbol with a
4540 specified name. */
4541
4542 static void
4543 ppc_bc (int ignore ATTRIBUTE_UNUSED)
4544 {
4545 char *name;
4546 int len;
4547 symbolS *sym;
4548
4549 name = demand_copy_C_string (&len);
4550 sym = symbol_make (name);
4551 S_SET_SEGMENT (sym, ppc_coff_debug_section);
4552 symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
4553 S_SET_STORAGE_CLASS (sym, C_BCOMM);
4554 S_SET_VALUE (sym, 0);
4555 symbol_get_tc (sym)->output = 1;
4556
4557 ppc_frob_label (sym);
4558
4559 demand_empty_rest_of_line ();
4560 }
4561
4562 /* The .ec pseudo-op. This just creates a C_ECOMM symbol. */
4563
4564 static void
4565 ppc_ec (int ignore ATTRIBUTE_UNUSED)
4566 {
4567 symbolS *sym;
4568
4569 sym = symbol_make (".ec");
4570 S_SET_SEGMENT (sym, ppc_coff_debug_section);
4571 symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
4572 S_SET_STORAGE_CLASS (sym, C_ECOMM);
4573 S_SET_VALUE (sym, 0);
4574 symbol_get_tc (sym)->output = 1;
4575
4576 ppc_frob_label (sym);
4577
4578 demand_empty_rest_of_line ();
4579 }
4580
4581 /* The .toc pseudo-op. Switch to the .toc subsegment. */
4582
4583 static void
4584 ppc_toc (int ignore ATTRIBUTE_UNUSED)
4585 {
4586 if (ppc_toc_csect != (symbolS *) NULL)
4587 subseg_set (data_section, symbol_get_tc (ppc_toc_csect)->subseg);
4588 else
4589 {
4590 subsegT subseg;
4591 symbolS *sym;
4592 symbolS *list;
4593
4594 subseg = ppc_data_subsegment;
4595 ++ppc_data_subsegment;
4596
4597 subseg_new (segment_name (data_section), subseg);
4598 ppc_toc_frag = frag_now;
4599
4600 sym = symbol_find_or_make ("TOC[TC0]");
4601 symbol_set_frag (sym, frag_now);
4602 S_SET_SEGMENT (sym, data_section);
4603 S_SET_VALUE (sym, (valueT) frag_now_fix ());
4604 symbol_get_tc (sym)->subseg = subseg;
4605 symbol_get_tc (sym)->output = 1;
4606 symbol_get_tc (sym)->within = sym;
4607
4608 ppc_toc_csect = sym;
4609
4610 for (list = ppc_data_csects;
4611 symbol_get_tc (list)->next != (symbolS *) NULL;
4612 list = symbol_get_tc (list)->next)
4613 ;
4614 symbol_get_tc (list)->next = sym;
4615
4616 symbol_remove (sym, &symbol_rootP, &symbol_lastP);
4617 symbol_append (sym, symbol_get_tc (list)->within, &symbol_rootP,
4618 &symbol_lastP);
4619 }
4620
4621 ppc_current_csect = ppc_toc_csect;
4622
4623 demand_empty_rest_of_line ();
4624 }
4625
4626 /* The AIX assembler automatically aligns the operands of a .long or
4627 .short pseudo-op, and we want to be compatible. */
4628
4629 static void
4630 ppc_xcoff_cons (int log_size)
4631 {
4632 frag_align (log_size, 0, 0);
4633 record_alignment (now_seg, log_size);
4634 cons (1 << log_size);
4635 }
4636
4637 static void
4638 ppc_vbyte (int dummy ATTRIBUTE_UNUSED)
4639 {
4640 expressionS exp;
4641 int byte_count;
4642
4643 (void) expression (&exp);
4644
4645 if (exp.X_op != O_constant)
4646 {
4647 as_bad (_("non-constant byte count"));
4648 return;
4649 }
4650
4651 byte_count = exp.X_add_number;
4652
4653 if (*input_line_pointer != ',')
4654 {
4655 as_bad (_("missing value"));
4656 return;
4657 }
4658
4659 ++input_line_pointer;
4660 cons (byte_count);
4661 }
4662
4663 void
4664 ppc_xcoff_end (void)
4665 {
4666 int i;
4667
4668 for (i = 0; i < XCOFF_DWSECT_NBR_NAMES; i++)
4669 {
4670 struct dw_section *dws = &dw_sections[i];
4671 struct dw_subsection *dwss;
4672
4673 if (dws->anon_subseg)
4674 {
4675 dwss = dws->anon_subseg;
4676 dwss->link = dws->list_subseg;
4677 }
4678 else
4679 dwss = dws->list_subseg;
4680
4681 for (; dwss != NULL; dwss = dwss->link)
4682 if (dwss->end_exp.X_add_symbol != NULL)
4683 {
4684 subseg_set (dws->sect, dwss->subseg);
4685 symbol_set_value_now (dwss->end_exp.X_add_symbol);
4686 }
4687 }
4688 }
4689
4690 #endif /* OBJ_XCOFF */
4691 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
4692 \f
4693 /* The .tc pseudo-op. This is used when generating either XCOFF or
4694 ELF. This takes two or more arguments.
4695
4696 When generating XCOFF output, the first argument is the name to
4697 give to this location in the toc; this will be a symbol with class
4698 TC. The rest of the arguments are N-byte values to actually put at
4699 this location in the TOC; often there is just one more argument, a
4700 relocatable symbol reference. The size of the value to store
4701 depends on target word size. A 32-bit target uses 4-byte values, a
4702 64-bit target uses 8-byte values.
4703
4704 When not generating XCOFF output, the arguments are the same, but
4705 the first argument is simply ignored. */
4706
4707 static void
4708 ppc_tc (int ignore ATTRIBUTE_UNUSED)
4709 {
4710 #ifdef OBJ_XCOFF
4711
4712 /* Define the TOC symbol name. */
4713 {
4714 char *name;
4715 char endc;
4716 symbolS *sym;
4717
4718 if (ppc_toc_csect == (symbolS *) NULL
4719 || ppc_toc_csect != ppc_current_csect)
4720 {
4721 as_bad (_(".tc not in .toc section"));
4722 ignore_rest_of_line ();
4723 return;
4724 }
4725
4726 name = input_line_pointer;
4727 endc = get_symbol_end ();
4728
4729 sym = symbol_find_or_make (name);
4730
4731 *input_line_pointer = endc;
4732
4733 if (S_IS_DEFINED (sym))
4734 {
4735 symbolS *label;
4736
4737 label = symbol_get_tc (ppc_current_csect)->within;
4738 if (symbol_get_tc (label)->symbol_class != XMC_TC0)
4739 {
4740 as_bad (_(".tc with no label"));
4741 ignore_rest_of_line ();
4742 return;
4743 }
4744
4745 S_SET_SEGMENT (label, S_GET_SEGMENT (sym));
4746 symbol_set_frag (label, symbol_get_frag (sym));
4747 S_SET_VALUE (label, S_GET_VALUE (sym));
4748
4749 while (! is_end_of_line[(unsigned char) *input_line_pointer])
4750 ++input_line_pointer;
4751
4752 return;
4753 }
4754
4755 S_SET_SEGMENT (sym, now_seg);
4756 symbol_set_frag (sym, frag_now);
4757 S_SET_VALUE (sym, (valueT) frag_now_fix ());
4758 symbol_get_tc (sym)->symbol_class = XMC_TC;
4759 symbol_get_tc (sym)->output = 1;
4760
4761 ppc_frob_label (sym);
4762 }
4763
4764 #endif /* OBJ_XCOFF */
4765 #ifdef OBJ_ELF
4766 int align;
4767
4768 /* Skip the TOC symbol name. */
4769 while (is_part_of_name (*input_line_pointer)
4770 || *input_line_pointer == ' '
4771 || *input_line_pointer == '['
4772 || *input_line_pointer == ']'
4773 || *input_line_pointer == '{'
4774 || *input_line_pointer == '}')
4775 ++input_line_pointer;
4776
4777 /* Align to a four/eight byte boundary. */
4778 align = ppc_obj64 ? 3 : 2;
4779 frag_align (align, 0, 0);
4780 record_alignment (now_seg, align);
4781 #endif /* OBJ_ELF */
4782
4783 if (*input_line_pointer != ',')
4784 demand_empty_rest_of_line ();
4785 else
4786 {
4787 ++input_line_pointer;
4788 cons (ppc_obj64 ? 8 : 4);
4789 }
4790 }
4791
4792 /* Pseudo-op .machine. */
4793
4794 static void
4795 ppc_machine (int ignore ATTRIBUTE_UNUSED)
4796 {
4797 char *cpu_string;
4798 #define MAX_HISTORY 100
4799 static ppc_cpu_t *cpu_history;
4800 static int curr_hist;
4801
4802 SKIP_WHITESPACE ();
4803
4804 if (*input_line_pointer == '"')
4805 {
4806 int len;
4807 cpu_string = demand_copy_C_string (&len);
4808 }
4809 else
4810 {
4811 char c;
4812 cpu_string = input_line_pointer;
4813 c = get_symbol_end ();
4814 cpu_string = xstrdup (cpu_string);
4815 *input_line_pointer = c;
4816 }
4817
4818 if (cpu_string != NULL)
4819 {
4820 ppc_cpu_t old_cpu = ppc_cpu;
4821 ppc_cpu_t new_cpu;
4822 char *p;
4823
4824 for (p = cpu_string; *p != 0; p++)
4825 *p = TOLOWER (*p);
4826
4827 if (strcmp (cpu_string, "push") == 0)
4828 {
4829 if (cpu_history == NULL)
4830 cpu_history = xmalloc (MAX_HISTORY * sizeof (*cpu_history));
4831
4832 if (curr_hist >= MAX_HISTORY)
4833 as_bad (_(".machine stack overflow"));
4834 else
4835 cpu_history[curr_hist++] = ppc_cpu;
4836 }
4837 else if (strcmp (cpu_string, "pop") == 0)
4838 {
4839 if (curr_hist <= 0)
4840 as_bad (_(".machine stack underflow"));
4841 else
4842 ppc_cpu = cpu_history[--curr_hist];
4843 }
4844 else if ((new_cpu = ppc_parse_cpu (ppc_cpu, &sticky, cpu_string)) != 0)
4845 ppc_cpu = new_cpu;
4846 else
4847 as_bad (_("invalid machine `%s'"), cpu_string);
4848
4849 if (ppc_cpu != old_cpu)
4850 ppc_setup_opcodes ();
4851 }
4852
4853 demand_empty_rest_of_line ();
4854 }
4855 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
4856 \f
4857 #ifdef TE_PE
4858
4859 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format. */
4860
4861 /* Set the current section. */
4862 static void
4863 ppc_set_current_section (segT new)
4864 {
4865 ppc_previous_section = ppc_current_section;
4866 ppc_current_section = new;
4867 }
4868
4869 /* pseudo-op: .previous
4870 behaviour: toggles the current section with the previous section.
4871 errors: None
4872 warnings: "No previous section" */
4873
4874 static void
4875 ppc_previous (int ignore ATTRIBUTE_UNUSED)
4876 {
4877 if (ppc_previous_section == NULL)
4878 {
4879 as_warn (_("no previous section to return to, ignored."));
4880 return;
4881 }
4882
4883 subseg_set (ppc_previous_section, 0);
4884
4885 ppc_set_current_section (ppc_previous_section);
4886 }
4887
4888 /* pseudo-op: .pdata
4889 behaviour: predefined read only data section
4890 double word aligned
4891 errors: None
4892 warnings: None
4893 initial: .section .pdata "adr3"
4894 a - don't know -- maybe a misprint
4895 d - initialized data
4896 r - readable
4897 3 - double word aligned (that would be 4 byte boundary)
4898
4899 commentary:
4900 Tag index tables (also known as the function table) for exception
4901 handling, debugging, etc. */
4902
4903 static void
4904 ppc_pdata (int ignore ATTRIBUTE_UNUSED)
4905 {
4906 if (pdata_section == 0)
4907 {
4908 pdata_section = subseg_new (".pdata", 0);
4909
4910 bfd_set_section_flags (stdoutput, pdata_section,
4911 (SEC_ALLOC | SEC_LOAD | SEC_RELOC
4912 | SEC_READONLY | SEC_DATA ));
4913
4914 bfd_set_section_alignment (stdoutput, pdata_section, 2);
4915 }
4916 else
4917 {
4918 pdata_section = subseg_new (".pdata", 0);
4919 }
4920 ppc_set_current_section (pdata_section);
4921 }
4922
4923 /* pseudo-op: .ydata
4924 behaviour: predefined read only data section
4925 double word aligned
4926 errors: None
4927 warnings: None
4928 initial: .section .ydata "drw3"
4929 a - don't know -- maybe a misprint
4930 d - initialized data
4931 r - readable
4932 3 - double word aligned (that would be 4 byte boundary)
4933 commentary:
4934 Tag tables (also known as the scope table) for exception handling,
4935 debugging, etc. */
4936
4937 static void
4938 ppc_ydata (int ignore ATTRIBUTE_UNUSED)
4939 {
4940 if (ydata_section == 0)
4941 {
4942 ydata_section = subseg_new (".ydata", 0);
4943 bfd_set_section_flags (stdoutput, ydata_section,
4944 (SEC_ALLOC | SEC_LOAD | SEC_RELOC
4945 | SEC_READONLY | SEC_DATA ));
4946
4947 bfd_set_section_alignment (stdoutput, ydata_section, 3);
4948 }
4949 else
4950 {
4951 ydata_section = subseg_new (".ydata", 0);
4952 }
4953 ppc_set_current_section (ydata_section);
4954 }
4955
4956 /* pseudo-op: .reldata
4957 behaviour: predefined read write data section
4958 double word aligned (4-byte)
4959 FIXME: relocation is applied to it
4960 FIXME: what's the difference between this and .data?
4961 errors: None
4962 warnings: None
4963 initial: .section .reldata "drw3"
4964 d - initialized data
4965 r - readable
4966 w - writeable
4967 3 - double word aligned (that would be 8 byte boundary)
4968
4969 commentary:
4970 Like .data, but intended to hold data subject to relocation, such as
4971 function descriptors, etc. */
4972
4973 static void
4974 ppc_reldata (int ignore ATTRIBUTE_UNUSED)
4975 {
4976 if (reldata_section == 0)
4977 {
4978 reldata_section = subseg_new (".reldata", 0);
4979
4980 bfd_set_section_flags (stdoutput, reldata_section,
4981 (SEC_ALLOC | SEC_LOAD | SEC_RELOC
4982 | SEC_DATA));
4983
4984 bfd_set_section_alignment (stdoutput, reldata_section, 2);
4985 }
4986 else
4987 {
4988 reldata_section = subseg_new (".reldata", 0);
4989 }
4990 ppc_set_current_section (reldata_section);
4991 }
4992
4993 /* pseudo-op: .rdata
4994 behaviour: predefined read only data section
4995 double word aligned
4996 errors: None
4997 warnings: None
4998 initial: .section .rdata "dr3"
4999 d - initialized data
5000 r - readable
5001 3 - double word aligned (that would be 4 byte boundary) */
5002
5003 static void
5004 ppc_rdata (int ignore ATTRIBUTE_UNUSED)
5005 {
5006 if (rdata_section == 0)
5007 {
5008 rdata_section = subseg_new (".rdata", 0);
5009 bfd_set_section_flags (stdoutput, rdata_section,
5010 (SEC_ALLOC | SEC_LOAD | SEC_RELOC
5011 | SEC_READONLY | SEC_DATA ));
5012
5013 bfd_set_section_alignment (stdoutput, rdata_section, 2);
5014 }
5015 else
5016 {
5017 rdata_section = subseg_new (".rdata", 0);
5018 }
5019 ppc_set_current_section (rdata_section);
5020 }
5021
5022 /* pseudo-op: .ualong
5023 behaviour: much like .int, with the exception that no alignment is
5024 performed.
5025 FIXME: test the alignment statement
5026 errors: None
5027 warnings: None */
5028
5029 static void
5030 ppc_ualong (int ignore ATTRIBUTE_UNUSED)
5031 {
5032 /* Try for long. */
5033 cons (4);
5034 }
5035
5036 /* pseudo-op: .znop <symbol name>
5037 behaviour: Issue a nop instruction
5038 Issue a IMAGE_REL_PPC_IFGLUE relocation against it, using
5039 the supplied symbol name.
5040 errors: None
5041 warnings: Missing symbol name */
5042
5043 static void
5044 ppc_znop (int ignore ATTRIBUTE_UNUSED)
5045 {
5046 unsigned long insn;
5047 const struct powerpc_opcode *opcode;
5048 char *f;
5049 symbolS *sym;
5050 char *symbol_name;
5051 char c;
5052 char *name;
5053
5054 /* Strip out the symbol name. */
5055 symbol_name = input_line_pointer;
5056 c = get_symbol_end ();
5057
5058 name = xmalloc (input_line_pointer - symbol_name + 1);
5059 strcpy (name, symbol_name);
5060
5061 sym = symbol_find_or_make (name);
5062
5063 *input_line_pointer = c;
5064
5065 SKIP_WHITESPACE ();
5066
5067 /* Look up the opcode in the hash table. */
5068 opcode = (const struct powerpc_opcode *) hash_find (ppc_hash, "nop");
5069
5070 /* Stick in the nop. */
5071 insn = opcode->opcode;
5072
5073 /* Write out the instruction. */
5074 f = frag_more (4);
5075 md_number_to_chars (f, insn, 4);
5076 fix_new (frag_now,
5077 f - frag_now->fr_literal,
5078 4,
5079 sym,
5080 0,
5081 0,
5082 BFD_RELOC_16_GOT_PCREL);
5083
5084 }
5085
5086 /* pseudo-op:
5087 behaviour:
5088 errors:
5089 warnings: */
5090
5091 static void
5092 ppc_pe_comm (int lcomm)
5093 {
5094 char *name;
5095 char c;
5096 char *p;
5097 offsetT temp;
5098 symbolS *symbolP;
5099 offsetT align;
5100
5101 name = input_line_pointer;
5102 c = get_symbol_end ();
5103
5104 /* just after name is now '\0'. */
5105 p = input_line_pointer;
5106 *p = c;
5107 SKIP_WHITESPACE ();
5108 if (*input_line_pointer != ',')
5109 {
5110 as_bad (_("expected comma after symbol-name: rest of line ignored."));
5111 ignore_rest_of_line ();
5112 return;
5113 }
5114
5115 input_line_pointer++; /* skip ',' */
5116 if ((temp = get_absolute_expression ()) < 0)
5117 {
5118 as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) temp);
5119 ignore_rest_of_line ();
5120 return;
5121 }
5122
5123 if (! lcomm)
5124 {
5125 /* The third argument to .comm is the alignment. */
5126 if (*input_line_pointer != ',')
5127 align = 3;
5128 else
5129 {
5130 ++input_line_pointer;
5131 align = get_absolute_expression ();
5132 if (align <= 0)
5133 {
5134 as_warn (_("ignoring bad alignment"));
5135 align = 3;
5136 }
5137 }
5138 }
5139
5140 *p = 0;
5141 symbolP = symbol_find_or_make (name);
5142
5143 *p = c;
5144 if (S_IS_DEFINED (symbolP) && ! S_IS_COMMON (symbolP))
5145 {
5146 as_bad (_("ignoring attempt to re-define symbol `%s'."),
5147 S_GET_NAME (symbolP));
5148 ignore_rest_of_line ();
5149 return;
5150 }
5151
5152 if (S_GET_VALUE (symbolP))
5153 {
5154 if (S_GET_VALUE (symbolP) != (valueT) temp)
5155 as_bad (_("length of .comm \"%s\" is already %ld. Not changed to %ld."),
5156 S_GET_NAME (symbolP),
5157 (long) S_GET_VALUE (symbolP),
5158 (long) temp);
5159 }
5160 else
5161 {
5162 S_SET_VALUE (symbolP, (valueT) temp);
5163 S_SET_EXTERNAL (symbolP);
5164 S_SET_SEGMENT (symbolP, bfd_com_section_ptr);
5165 }
5166
5167 demand_empty_rest_of_line ();
5168 }
5169
5170 /*
5171 * implement the .section pseudo op:
5172 * .section name {, "flags"}
5173 * ^ ^
5174 * | +--- optional flags: 'b' for bss
5175 * | 'i' for info
5176 * +-- section name 'l' for lib
5177 * 'n' for noload
5178 * 'o' for over
5179 * 'w' for data
5180 * 'd' (apparently m88k for data)
5181 * 'x' for text
5182 * But if the argument is not a quoted string, treat it as a
5183 * subsegment number.
5184 *
5185 * FIXME: this is a copy of the section processing from obj-coff.c, with
5186 * additions/changes for the moto-pas assembler support. There are three
5187 * categories:
5188 *
5189 * FIXME: I just noticed this. This doesn't work at all really. It it
5190 * setting bits that bfd probably neither understands or uses. The
5191 * correct approach (?) will have to incorporate extra fields attached
5192 * to the section to hold the system specific stuff. (krk)
5193 *
5194 * Section Contents:
5195 * 'a' - unknown - referred to in documentation, but no definition supplied
5196 * 'c' - section has code
5197 * 'd' - section has initialized data
5198 * 'u' - section has uninitialized data
5199 * 'i' - section contains directives (info)
5200 * 'n' - section can be discarded
5201 * 'R' - remove section at link time
5202 *
5203 * Section Protection:
5204 * 'r' - section is readable
5205 * 'w' - section is writeable
5206 * 'x' - section is executable
5207 * 's' - section is sharable
5208 *
5209 * Section Alignment:
5210 * '0' - align to byte boundary
5211 * '1' - align to halfword undary
5212 * '2' - align to word boundary
5213 * '3' - align to doubleword boundary
5214 * '4' - align to quadword boundary
5215 * '5' - align to 32 byte boundary
5216 * '6' - align to 64 byte boundary
5217 *
5218 */
5219
5220 void
5221 ppc_pe_section (int ignore ATTRIBUTE_UNUSED)
5222 {
5223 /* Strip out the section name. */
5224 char *section_name;
5225 char c;
5226 char *name;
5227 unsigned int exp;
5228 flagword flags;
5229 segT sec;
5230 int align;
5231
5232 section_name = input_line_pointer;
5233 c = get_symbol_end ();
5234
5235 name = xmalloc (input_line_pointer - section_name + 1);
5236 strcpy (name, section_name);
5237
5238 *input_line_pointer = c;
5239
5240 SKIP_WHITESPACE ();
5241
5242 exp = 0;
5243 flags = SEC_NO_FLAGS;
5244
5245 if (strcmp (name, ".idata$2") == 0)
5246 {
5247 align = 0;
5248 }
5249 else if (strcmp (name, ".idata$3") == 0)
5250 {
5251 align = 0;
5252 }
5253 else if (strcmp (name, ".idata$4") == 0)
5254 {
5255 align = 2;
5256 }
5257 else if (strcmp (name, ".idata$5") == 0)
5258 {
5259 align = 2;
5260 }
5261 else if (strcmp (name, ".idata$6") == 0)
5262 {
5263 align = 1;
5264 }
5265 else
5266 /* Default alignment to 16 byte boundary. */
5267 align = 4;
5268
5269 if (*input_line_pointer == ',')
5270 {
5271 ++input_line_pointer;
5272 SKIP_WHITESPACE ();
5273 if (*input_line_pointer != '"')
5274 exp = get_absolute_expression ();
5275 else
5276 {
5277 ++input_line_pointer;
5278 while (*input_line_pointer != '"'
5279 && ! is_end_of_line[(unsigned char) *input_line_pointer])
5280 {
5281 switch (*input_line_pointer)
5282 {
5283 /* Section Contents */
5284 case 'a': /* unknown */
5285 as_bad (_("unsupported section attribute -- 'a'"));
5286 break;
5287 case 'c': /* code section */
5288 flags |= SEC_CODE;
5289 break;
5290 case 'd': /* section has initialized data */
5291 flags |= SEC_DATA;
5292 break;
5293 case 'u': /* section has uninitialized data */
5294 /* FIXME: This is IMAGE_SCN_CNT_UNINITIALIZED_DATA
5295 in winnt.h */
5296 flags |= SEC_ROM;
5297 break;
5298 case 'i': /* section contains directives (info) */
5299 /* FIXME: This is IMAGE_SCN_LNK_INFO
5300 in winnt.h */
5301 flags |= SEC_HAS_CONTENTS;
5302 break;
5303 case 'n': /* section can be discarded */
5304 flags &=~ SEC_LOAD;
5305 break;
5306 case 'R': /* Remove section at link time */
5307 flags |= SEC_NEVER_LOAD;
5308 break;
5309 #if IFLICT_BRAIN_DAMAGE
5310 /* Section Protection */
5311 case 'r': /* section is readable */
5312 flags |= IMAGE_SCN_MEM_READ;
5313 break;
5314 case 'w': /* section is writeable */
5315 flags |= IMAGE_SCN_MEM_WRITE;
5316 break;
5317 case 'x': /* section is executable */
5318 flags |= IMAGE_SCN_MEM_EXECUTE;
5319 break;
5320 case 's': /* section is sharable */
5321 flags |= IMAGE_SCN_MEM_SHARED;
5322 break;
5323
5324 /* Section Alignment */
5325 case '0': /* align to byte boundary */
5326 flags |= IMAGE_SCN_ALIGN_1BYTES;
5327 align = 0;
5328 break;
5329 case '1': /* align to halfword boundary */
5330 flags |= IMAGE_SCN_ALIGN_2BYTES;
5331 align = 1;
5332 break;
5333 case '2': /* align to word boundary */
5334 flags |= IMAGE_SCN_ALIGN_4BYTES;
5335 align = 2;
5336 break;
5337 case '3': /* align to doubleword boundary */
5338 flags |= IMAGE_SCN_ALIGN_8BYTES;
5339 align = 3;
5340 break;
5341 case '4': /* align to quadword boundary */
5342 flags |= IMAGE_SCN_ALIGN_16BYTES;
5343 align = 4;
5344 break;
5345 case '5': /* align to 32 byte boundary */
5346 flags |= IMAGE_SCN_ALIGN_32BYTES;
5347 align = 5;
5348 break;
5349 case '6': /* align to 64 byte boundary */
5350 flags |= IMAGE_SCN_ALIGN_64BYTES;
5351 align = 6;
5352 break;
5353 #endif
5354 default:
5355 as_bad (_("unknown section attribute '%c'"),
5356 *input_line_pointer);
5357 break;
5358 }
5359 ++input_line_pointer;
5360 }
5361 if (*input_line_pointer == '"')
5362 ++input_line_pointer;
5363 }
5364 }
5365
5366 sec = subseg_new (name, (subsegT) exp);
5367
5368 ppc_set_current_section (sec);
5369
5370 if (flags != SEC_NO_FLAGS)
5371 {
5372 if (! bfd_set_section_flags (stdoutput, sec, flags))
5373 as_bad (_("error setting flags for \"%s\": %s"),
5374 bfd_section_name (stdoutput, sec),
5375 bfd_errmsg (bfd_get_error ()));
5376 }
5377
5378 bfd_set_section_alignment (stdoutput, sec, align);
5379 }
5380
5381 static void
5382 ppc_pe_function (int ignore ATTRIBUTE_UNUSED)
5383 {
5384 char *name;
5385 char endc;
5386 symbolS *ext_sym;
5387
5388 name = input_line_pointer;
5389 endc = get_symbol_end ();
5390
5391 ext_sym = symbol_find_or_make (name);
5392
5393 *input_line_pointer = endc;
5394
5395 S_SET_DATA_TYPE (ext_sym, DT_FCN << N_BTSHFT);
5396 SF_SET_FUNCTION (ext_sym);
5397 SF_SET_PROCESS (ext_sym);
5398 coff_add_linesym (ext_sym);
5399
5400 demand_empty_rest_of_line ();
5401 }
5402
5403 static void
5404 ppc_pe_tocd (int ignore ATTRIBUTE_UNUSED)
5405 {
5406 if (tocdata_section == 0)
5407 {
5408 tocdata_section = subseg_new (".tocd", 0);
5409 /* FIXME: section flags won't work. */
5410 bfd_set_section_flags (stdoutput, tocdata_section,
5411 (SEC_ALLOC | SEC_LOAD | SEC_RELOC
5412 | SEC_READONLY | SEC_DATA));
5413
5414 bfd_set_section_alignment (stdoutput, tocdata_section, 2);
5415 }
5416 else
5417 {
5418 rdata_section = subseg_new (".tocd", 0);
5419 }
5420
5421 ppc_set_current_section (tocdata_section);
5422
5423 demand_empty_rest_of_line ();
5424 }
5425
5426 /* Don't adjust TOC relocs to use the section symbol. */
5427
5428 int
5429 ppc_pe_fix_adjustable (fixS *fix)
5430 {
5431 return fix->fx_r_type != BFD_RELOC_PPC_TOC16;
5432 }
5433
5434 #endif
5435 \f
5436 #ifdef OBJ_XCOFF
5437
5438 /* XCOFF specific symbol and file handling. */
5439
5440 /* Canonicalize the symbol name. We use the to force the suffix, if
5441 any, to use square brackets, and to be in upper case. */
5442
5443 char *
5444 ppc_canonicalize_symbol_name (char *name)
5445 {
5446 char *s;
5447
5448 if (ppc_stab_symbol)
5449 return name;
5450
5451 for (s = name; *s != '\0' && *s != '{' && *s != '['; s++)
5452 ;
5453 if (*s != '\0')
5454 {
5455 char brac;
5456
5457 if (*s == '[')
5458 brac = ']';
5459 else
5460 {
5461 *s = '[';
5462 brac = '}';
5463 }
5464
5465 for (s++; *s != '\0' && *s != brac; s++)
5466 *s = TOUPPER (*s);
5467
5468 if (*s == '\0' || s[1] != '\0')
5469 as_bad (_("bad symbol suffix"));
5470
5471 *s = ']';
5472 }
5473
5474 return name;
5475 }
5476
5477 /* Set the class of a symbol based on the suffix, if any. This is
5478 called whenever a new symbol is created. */
5479
5480 void
5481 ppc_symbol_new_hook (symbolS *sym)
5482 {
5483 struct ppc_tc_sy *tc;
5484 const char *s;
5485
5486 tc = symbol_get_tc (sym);
5487 tc->next = NULL;
5488 tc->output = 0;
5489 tc->symbol_class = -1;
5490 tc->real_name = NULL;
5491 tc->subseg = 0;
5492 tc->align = 0;
5493 tc->u.size = NULL;
5494 tc->u.dw = NULL;
5495 tc->within = NULL;
5496
5497 if (ppc_stab_symbol)
5498 return;
5499
5500 s = strchr (S_GET_NAME (sym), '[');
5501 if (s == (const char *) NULL)
5502 {
5503 /* There is no suffix. */
5504 return;
5505 }
5506
5507 ++s;
5508
5509 switch (s[0])
5510 {
5511 case 'B':
5512 if (strcmp (s, "BS]") == 0)
5513 tc->symbol_class = XMC_BS;
5514 break;
5515 case 'D':
5516 if (strcmp (s, "DB]") == 0)
5517 tc->symbol_class = XMC_DB;
5518 else if (strcmp (s, "DS]") == 0)
5519 tc->symbol_class = XMC_DS;
5520 break;
5521 case 'G':
5522 if (strcmp (s, "GL]") == 0)
5523 tc->symbol_class = XMC_GL;
5524 break;
5525 case 'P':
5526 if (strcmp (s, "PR]") == 0)
5527 tc->symbol_class = XMC_PR;
5528 break;
5529 case 'R':
5530 if (strcmp (s, "RO]") == 0)
5531 tc->symbol_class = XMC_RO;
5532 else if (strcmp (s, "RW]") == 0)
5533 tc->symbol_class = XMC_RW;
5534 break;
5535 case 'S':
5536 if (strcmp (s, "SV]") == 0)
5537 tc->symbol_class = XMC_SV;
5538 break;
5539 case 'T':
5540 if (strcmp (s, "TC]") == 0)
5541 tc->symbol_class = XMC_TC;
5542 else if (strcmp (s, "TI]") == 0)
5543 tc->symbol_class = XMC_TI;
5544 else if (strcmp (s, "TB]") == 0)
5545 tc->symbol_class = XMC_TB;
5546 else if (strcmp (s, "TC0]") == 0 || strcmp (s, "T0]") == 0)
5547 tc->symbol_class = XMC_TC0;
5548 break;
5549 case 'U':
5550 if (strcmp (s, "UA]") == 0)
5551 tc->symbol_class = XMC_UA;
5552 else if (strcmp (s, "UC]") == 0)
5553 tc->symbol_class = XMC_UC;
5554 break;
5555 case 'X':
5556 if (strcmp (s, "XO]") == 0)
5557 tc->symbol_class = XMC_XO;
5558 break;
5559 }
5560
5561 if (tc->symbol_class == -1)
5562 as_bad (_("unrecognized symbol suffix"));
5563 }
5564
5565 /* Set the class of a label based on where it is defined. This
5566 handles symbols without suffixes. Also, move the symbol so that it
5567 follows the csect symbol. */
5568
5569 void
5570 ppc_frob_label (symbolS *sym)
5571 {
5572 if (ppc_current_csect != (symbolS *) NULL)
5573 {
5574 if (symbol_get_tc (sym)->symbol_class == -1)
5575 symbol_get_tc (sym)->symbol_class = symbol_get_tc (ppc_current_csect)->symbol_class;
5576
5577 symbol_remove (sym, &symbol_rootP, &symbol_lastP);
5578 symbol_append (sym, symbol_get_tc (ppc_current_csect)->within,
5579 &symbol_rootP, &symbol_lastP);
5580 symbol_get_tc (ppc_current_csect)->within = sym;
5581 symbol_get_tc (sym)->within = ppc_current_csect;
5582 }
5583
5584 #ifdef OBJ_ELF
5585 dwarf2_emit_label (sym);
5586 #endif
5587 }
5588
5589 /* This variable is set by ppc_frob_symbol if any absolute symbols are
5590 seen. It tells ppc_adjust_symtab whether it needs to look through
5591 the symbols. */
5592
5593 static bfd_boolean ppc_saw_abs;
5594
5595 /* Change the name of a symbol just before writing it out. Set the
5596 real name if the .rename pseudo-op was used. Otherwise, remove any
5597 class suffix. Return 1 if the symbol should not be included in the
5598 symbol table. */
5599
5600 int
5601 ppc_frob_symbol (symbolS *sym)
5602 {
5603 static symbolS *ppc_last_function;
5604 static symbolS *set_end;
5605
5606 /* Discard symbols that should not be included in the output symbol
5607 table. */
5608 if (! symbol_used_in_reloc_p (sym)
5609 && ((symbol_get_bfdsym (sym)->flags & BSF_SECTION_SYM) != 0
5610 || (! (S_IS_EXTERNAL (sym) || S_IS_WEAK (sym))
5611 && ! symbol_get_tc (sym)->output
5612 && S_GET_STORAGE_CLASS (sym) != C_FILE)))
5613 return 1;
5614
5615 /* This one will disappear anyway. Don't make a csect sym for it. */
5616 if (sym == abs_section_sym)
5617 return 1;
5618
5619 if (symbol_get_tc (sym)->real_name != (char *) NULL)
5620 S_SET_NAME (sym, symbol_get_tc (sym)->real_name);
5621 else
5622 {
5623 const char *name;
5624 const char *s;
5625
5626 name = S_GET_NAME (sym);
5627 s = strchr (name, '[');
5628 if (s != (char *) NULL)
5629 {
5630 unsigned int len;
5631 char *snew;
5632
5633 len = s - name;
5634 snew = xmalloc (len + 1);
5635 memcpy (snew, name, len);
5636 snew[len] = '\0';
5637
5638 S_SET_NAME (sym, snew);
5639 }
5640 }
5641
5642 if (set_end != (symbolS *) NULL)
5643 {
5644 SA_SET_SYM_ENDNDX (set_end, sym);
5645 set_end = NULL;
5646 }
5647
5648 if (SF_GET_FUNCTION (sym))
5649 {
5650 if (ppc_last_function != (symbolS *) NULL)
5651 as_bad (_("two .function pseudo-ops with no intervening .ef"));
5652 ppc_last_function = sym;
5653 if (symbol_get_tc (sym)->u.size != (symbolS *) NULL)
5654 {
5655 resolve_symbol_value (symbol_get_tc (sym)->u.size);
5656 SA_SET_SYM_FSIZE (sym,
5657 (long) S_GET_VALUE (symbol_get_tc (sym)->u.size));
5658 }
5659 }
5660 else if (S_GET_STORAGE_CLASS (sym) == C_FCN
5661 && strcmp (S_GET_NAME (sym), ".ef") == 0)
5662 {
5663 if (ppc_last_function == (symbolS *) NULL)
5664 as_bad (_(".ef with no preceding .function"));
5665 else
5666 {
5667 set_end = ppc_last_function;
5668 ppc_last_function = NULL;
5669
5670 /* We don't have a C_EFCN symbol, but we need to force the
5671 COFF backend to believe that it has seen one. */
5672 coff_last_function = NULL;
5673 }
5674 }
5675
5676 if (! (S_IS_EXTERNAL (sym) || S_IS_WEAK (sym))
5677 && (symbol_get_bfdsym (sym)->flags & BSF_SECTION_SYM) == 0
5678 && S_GET_STORAGE_CLASS (sym) != C_FILE
5679 && S_GET_STORAGE_CLASS (sym) != C_FCN
5680 && S_GET_STORAGE_CLASS (sym) != C_BLOCK
5681 && S_GET_STORAGE_CLASS (sym) != C_BSTAT
5682 && S_GET_STORAGE_CLASS (sym) != C_ESTAT
5683 && S_GET_STORAGE_CLASS (sym) != C_BINCL
5684 && S_GET_STORAGE_CLASS (sym) != C_EINCL
5685 && S_GET_SEGMENT (sym) != ppc_coff_debug_section)
5686 S_SET_STORAGE_CLASS (sym, C_HIDEXT);
5687
5688 if (S_GET_STORAGE_CLASS (sym) == C_EXT
5689 || S_GET_STORAGE_CLASS (sym) == C_AIX_WEAKEXT
5690 || S_GET_STORAGE_CLASS (sym) == C_HIDEXT)
5691 {
5692 int i;
5693 union internal_auxent *a;
5694
5695 /* Create a csect aux. */
5696 i = S_GET_NUMBER_AUXILIARY (sym);
5697 S_SET_NUMBER_AUXILIARY (sym, i + 1);
5698 a = &coffsymbol (symbol_get_bfdsym (sym))->native[i + 1].u.auxent;
5699 if (symbol_get_tc (sym)->symbol_class == XMC_TC0)
5700 {
5701 /* This is the TOC table. */
5702 know (strcmp (S_GET_NAME (sym), "TOC") == 0);
5703 a->x_csect.x_scnlen.l = 0;
5704 a->x_csect.x_smtyp = (2 << 3) | XTY_SD;
5705 }
5706 else if (symbol_get_tc (sym)->subseg != 0)
5707 {
5708 /* This is a csect symbol. x_scnlen is the size of the
5709 csect. */
5710 if (symbol_get_tc (sym)->next == (symbolS *) NULL)
5711 a->x_csect.x_scnlen.l = (bfd_section_size (stdoutput,
5712 S_GET_SEGMENT (sym))
5713 - S_GET_VALUE (sym));
5714 else
5715 {
5716 resolve_symbol_value (symbol_get_tc (sym)->next);
5717 a->x_csect.x_scnlen.l = (S_GET_VALUE (symbol_get_tc (sym)->next)
5718 - S_GET_VALUE (sym));
5719 }
5720 a->x_csect.x_smtyp = (symbol_get_tc (sym)->align << 3) | XTY_SD;
5721 }
5722 else if (S_GET_SEGMENT (sym) == bss_section)
5723 {
5724 /* This is a common symbol. */
5725 a->x_csect.x_scnlen.l = symbol_get_frag (sym)->fr_offset;
5726 a->x_csect.x_smtyp = (symbol_get_tc (sym)->align << 3) | XTY_CM;
5727 if (S_IS_EXTERNAL (sym))
5728 symbol_get_tc (sym)->symbol_class = XMC_RW;
5729 else
5730 symbol_get_tc (sym)->symbol_class = XMC_BS;
5731 }
5732 else if (S_GET_SEGMENT (sym) == absolute_section)
5733 {
5734 /* This is an absolute symbol. The csect will be created by
5735 ppc_adjust_symtab. */
5736 ppc_saw_abs = TRUE;
5737 a->x_csect.x_smtyp = XTY_LD;
5738 if (symbol_get_tc (sym)->symbol_class == -1)
5739 symbol_get_tc (sym)->symbol_class = XMC_XO;
5740 }
5741 else if (! S_IS_DEFINED (sym))
5742 {
5743 /* This is an external symbol. */
5744 a->x_csect.x_scnlen.l = 0;
5745 a->x_csect.x_smtyp = XTY_ER;
5746 }
5747 else if (symbol_get_tc (sym)->symbol_class == XMC_TC)
5748 {
5749 symbolS *next;
5750
5751 /* This is a TOC definition. x_scnlen is the size of the
5752 TOC entry. */
5753 next = symbol_next (sym);
5754 while (symbol_get_tc (next)->symbol_class == XMC_TC0)
5755 next = symbol_next (next);
5756 if (next == (symbolS *) NULL
5757 || symbol_get_tc (next)->symbol_class != XMC_TC)
5758 {
5759 if (ppc_after_toc_frag == (fragS *) NULL)
5760 a->x_csect.x_scnlen.l = (bfd_section_size (stdoutput,
5761 data_section)
5762 - S_GET_VALUE (sym));
5763 else
5764 a->x_csect.x_scnlen.l = (ppc_after_toc_frag->fr_address
5765 - S_GET_VALUE (sym));
5766 }
5767 else
5768 {
5769 resolve_symbol_value (next);
5770 a->x_csect.x_scnlen.l = (S_GET_VALUE (next)
5771 - S_GET_VALUE (sym));
5772 }
5773 a->x_csect.x_smtyp = (2 << 3) | XTY_SD;
5774 }
5775 else
5776 {
5777 symbolS *csect;
5778
5779 /* This is a normal symbol definition. x_scnlen is the
5780 symbol index of the containing csect. */
5781 if (S_GET_SEGMENT (sym) == text_section)
5782 csect = ppc_text_csects;
5783 else if (S_GET_SEGMENT (sym) == data_section)
5784 csect = ppc_data_csects;
5785 else
5786 abort ();
5787
5788 /* Skip the initial dummy symbol. */
5789 csect = symbol_get_tc (csect)->next;
5790
5791 if (csect == (symbolS *) NULL)
5792 {
5793 as_warn (_("warning: symbol %s has no csect"), S_GET_NAME (sym));
5794 a->x_csect.x_scnlen.l = 0;
5795 }
5796 else
5797 {
5798 while (symbol_get_tc (csect)->next != (symbolS *) NULL)
5799 {
5800 resolve_symbol_value (symbol_get_tc (csect)->next);
5801 if (S_GET_VALUE (symbol_get_tc (csect)->next)
5802 > S_GET_VALUE (sym))
5803 break;
5804 csect = symbol_get_tc (csect)->next;
5805 }
5806
5807 a->x_csect.x_scnlen.p =
5808 coffsymbol (symbol_get_bfdsym (csect))->native;
5809 coffsymbol (symbol_get_bfdsym (sym))->native[i + 1].fix_scnlen =
5810 1;
5811 }
5812 a->x_csect.x_smtyp = XTY_LD;
5813 }
5814
5815 a->x_csect.x_parmhash = 0;
5816 a->x_csect.x_snhash = 0;
5817 if (symbol_get_tc (sym)->symbol_class == -1)
5818 a->x_csect.x_smclas = XMC_PR;
5819 else
5820 a->x_csect.x_smclas = symbol_get_tc (sym)->symbol_class;
5821 a->x_csect.x_stab = 0;
5822 a->x_csect.x_snstab = 0;
5823
5824 /* Don't let the COFF backend resort these symbols. */
5825 symbol_get_bfdsym (sym)->flags |= BSF_NOT_AT_END;
5826 }
5827 else if (S_GET_STORAGE_CLASS (sym) == C_BSTAT)
5828 {
5829 /* We want the value to be the symbol index of the referenced
5830 csect symbol. BFD will do that for us if we set the right
5831 flags. */
5832 asymbol *bsym = symbol_get_bfdsym (symbol_get_tc (sym)->within);
5833 combined_entry_type *c = coffsymbol (bsym)->native;
5834
5835 S_SET_VALUE (sym, (valueT) (size_t) c);
5836 coffsymbol (symbol_get_bfdsym (sym))->native->fix_value = 1;
5837 }
5838 else if (S_GET_STORAGE_CLASS (sym) == C_STSYM)
5839 {
5840 symbolS *block;
5841 valueT base;
5842
5843 block = symbol_get_tc (sym)->within;
5844 if (block)
5845 {
5846 /* The value is the offset from the enclosing csect. */
5847 symbolS *csect;
5848
5849 csect = symbol_get_tc (block)->within;
5850 resolve_symbol_value (csect);
5851 base = S_GET_VALUE (csect);
5852 }
5853 else
5854 base = 0;
5855
5856 S_SET_VALUE (sym, S_GET_VALUE (sym) - base);
5857 }
5858 else if (S_GET_STORAGE_CLASS (sym) == C_BINCL
5859 || S_GET_STORAGE_CLASS (sym) == C_EINCL)
5860 {
5861 /* We want the value to be a file offset into the line numbers.
5862 BFD will do that for us if we set the right flags. We have
5863 already set the value correctly. */
5864 coffsymbol (symbol_get_bfdsym (sym))->native->fix_line = 1;
5865 }
5866
5867 return 0;
5868 }
5869
5870 /* Adjust the symbol table. This creates csect symbols for all
5871 absolute symbols. */
5872
5873 void
5874 ppc_adjust_symtab (void)
5875 {
5876 symbolS *sym;
5877
5878 if (! ppc_saw_abs)
5879 return;
5880
5881 for (sym = symbol_rootP; sym != NULL; sym = symbol_next (sym))
5882 {
5883 symbolS *csect;
5884 int i;
5885 union internal_auxent *a;
5886
5887 if (S_GET_SEGMENT (sym) != absolute_section)
5888 continue;
5889
5890 csect = symbol_create (".abs[XO]", absolute_section,
5891 S_GET_VALUE (sym), &zero_address_frag);
5892 symbol_get_bfdsym (csect)->value = S_GET_VALUE (sym);
5893 S_SET_STORAGE_CLASS (csect, C_HIDEXT);
5894 i = S_GET_NUMBER_AUXILIARY (csect);
5895 S_SET_NUMBER_AUXILIARY (csect, i + 1);
5896 a = &coffsymbol (symbol_get_bfdsym (csect))->native[i + 1].u.auxent;
5897 a->x_csect.x_scnlen.l = 0;
5898 a->x_csect.x_smtyp = XTY_SD;
5899 a->x_csect.x_parmhash = 0;
5900 a->x_csect.x_snhash = 0;
5901 a->x_csect.x_smclas = XMC_XO;
5902 a->x_csect.x_stab = 0;
5903 a->x_csect.x_snstab = 0;
5904
5905 symbol_insert (csect, sym, &symbol_rootP, &symbol_lastP);
5906
5907 i = S_GET_NUMBER_AUXILIARY (sym);
5908 a = &coffsymbol (symbol_get_bfdsym (sym))->native[i].u.auxent;
5909 a->x_csect.x_scnlen.p = coffsymbol (symbol_get_bfdsym (csect))->native;
5910 coffsymbol (symbol_get_bfdsym (sym))->native[i].fix_scnlen = 1;
5911 }
5912
5913 ppc_saw_abs = FALSE;
5914 }
5915
5916 /* Set the VMA for a section. This is called on all the sections in
5917 turn. */
5918
5919 void
5920 ppc_frob_section (asection *sec)
5921 {
5922 static bfd_vma vma = 0;
5923
5924 /* Dwarf sections start at 0. */
5925 if (bfd_get_section_flags (NULL, sec) & SEC_DEBUGGING)
5926 return;
5927
5928 vma = md_section_align (sec, vma);
5929 bfd_set_section_vma (stdoutput, sec, vma);
5930 vma += bfd_section_size (stdoutput, sec);
5931 }
5932
5933 #endif /* OBJ_XCOFF */
5934 \f
5935 char *
5936 md_atof (int type, char *litp, int *sizep)
5937 {
5938 return ieee_md_atof (type, litp, sizep, target_big_endian);
5939 }
5940
5941 /* Write a value out to the object file, using the appropriate
5942 endianness. */
5943
5944 void
5945 md_number_to_chars (char *buf, valueT val, int n)
5946 {
5947 if (target_big_endian)
5948 number_to_chars_bigendian (buf, val, n);
5949 else
5950 number_to_chars_littleendian (buf, val, n);
5951 }
5952
5953 /* Align a section (I don't know why this is machine dependent). */
5954
5955 valueT
5956 md_section_align (asection *seg ATTRIBUTE_UNUSED, valueT addr)
5957 {
5958 #ifdef OBJ_ELF
5959 return addr;
5960 #else
5961 int align = bfd_get_section_alignment (stdoutput, seg);
5962
5963 return ((addr + (1 << align) - 1) & (-1 << align));
5964 #endif
5965 }
5966
5967 /* We don't have any form of relaxing. */
5968
5969 int
5970 md_estimate_size_before_relax (fragS *fragp ATTRIBUTE_UNUSED,
5971 asection *seg ATTRIBUTE_UNUSED)
5972 {
5973 abort ();
5974 return 0;
5975 }
5976
5977 /* Convert a machine dependent frag. We never generate these. */
5978
5979 void
5980 md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED,
5981 asection *sec ATTRIBUTE_UNUSED,
5982 fragS *fragp ATTRIBUTE_UNUSED)
5983 {
5984 abort ();
5985 }
5986
5987 /* We have no need to default values of symbols. */
5988
5989 symbolS *
5990 md_undefined_symbol (char *name ATTRIBUTE_UNUSED)
5991 {
5992 return 0;
5993 }
5994 \f
5995 /* Functions concerning relocs. */
5996
5997 /* The location from which a PC relative jump should be calculated,
5998 given a PC relative reloc. */
5999
6000 long
6001 md_pcrel_from_section (fixS *fixp, segT sec ATTRIBUTE_UNUSED)
6002 {
6003 return fixp->fx_frag->fr_address + fixp->fx_where;
6004 }
6005
6006 #ifdef OBJ_XCOFF
6007
6008 /* This is called to see whether a fixup should be adjusted to use a
6009 section symbol. We take the opportunity to change a fixup against
6010 a symbol in the TOC subsegment into a reloc against the
6011 corresponding .tc symbol. */
6012
6013 int
6014 ppc_fix_adjustable (fixS *fix)
6015 {
6016 valueT val = resolve_symbol_value (fix->fx_addsy);
6017 segT symseg = S_GET_SEGMENT (fix->fx_addsy);
6018 TC_SYMFIELD_TYPE *tc;
6019
6020 if (symseg == absolute_section)
6021 return 0;
6022
6023 /* Always adjust symbols in debugging sections. */
6024 if (bfd_get_section_flags (stdoutput, symseg) & SEC_DEBUGGING)
6025 return 1;
6026
6027 if (ppc_toc_csect != (symbolS *) NULL
6028 && fix->fx_addsy != ppc_toc_csect
6029 && symseg == data_section
6030 && val >= ppc_toc_frag->fr_address
6031 && (ppc_after_toc_frag == (fragS *) NULL
6032 || val < ppc_after_toc_frag->fr_address))
6033 {
6034 symbolS *sy;
6035
6036 for (sy = symbol_next (ppc_toc_csect);
6037 sy != (symbolS *) NULL;
6038 sy = symbol_next (sy))
6039 {
6040 TC_SYMFIELD_TYPE *sy_tc = symbol_get_tc (sy);
6041
6042 if (sy_tc->symbol_class == XMC_TC0)
6043 continue;
6044 if (sy_tc->symbol_class != XMC_TC)
6045 break;
6046 if (val == resolve_symbol_value (sy))
6047 {
6048 fix->fx_addsy = sy;
6049 fix->fx_addnumber = val - ppc_toc_frag->fr_address;
6050 return 0;
6051 }
6052 }
6053
6054 as_bad_where (fix->fx_file, fix->fx_line,
6055 _("symbol in .toc does not match any .tc"));
6056 }
6057
6058 /* Possibly adjust the reloc to be against the csect. */
6059 tc = symbol_get_tc (fix->fx_addsy);
6060 if (tc->subseg == 0
6061 && tc->symbol_class != XMC_TC0
6062 && tc->symbol_class != XMC_TC
6063 && symseg != bss_section
6064 /* Don't adjust if this is a reloc in the toc section. */
6065 && (symseg != data_section
6066 || ppc_toc_csect == NULL
6067 || val < ppc_toc_frag->fr_address
6068 || (ppc_after_toc_frag != NULL
6069 && val >= ppc_after_toc_frag->fr_address)))
6070 {
6071 symbolS *csect = tc->within;
6072
6073 /* If the symbol was not declared by a label (eg: a section symbol),
6074 use the section instead of the csect. This doesn't happen in
6075 normal AIX assembly code. */
6076 if (csect == NULL)
6077 csect = seg_info (symseg)->sym;
6078
6079 fix->fx_offset += val - symbol_get_frag (csect)->fr_address;
6080 fix->fx_addsy = csect;
6081
6082 return 0;
6083 }
6084
6085 /* Adjust a reloc against a .lcomm symbol to be against the base
6086 .lcomm. */
6087 if (symseg == bss_section
6088 && ! S_IS_EXTERNAL (fix->fx_addsy))
6089 {
6090 symbolS *sy = symbol_get_frag (fix->fx_addsy)->fr_symbol;
6091
6092 fix->fx_offset += val - resolve_symbol_value (sy);
6093 fix->fx_addsy = sy;
6094 }
6095
6096 return 0;
6097 }
6098
6099 /* A reloc from one csect to another must be kept. The assembler
6100 will, of course, keep relocs between sections, and it will keep
6101 absolute relocs, but we need to force it to keep PC relative relocs
6102 between two csects in the same section. */
6103
6104 int
6105 ppc_force_relocation (fixS *fix)
6106 {
6107 /* At this point fix->fx_addsy should already have been converted to
6108 a csect symbol. If the csect does not include the fragment, then
6109 we need to force the relocation. */
6110 if (fix->fx_pcrel
6111 && fix->fx_addsy != NULL
6112 && symbol_get_tc (fix->fx_addsy)->subseg != 0
6113 && ((symbol_get_frag (fix->fx_addsy)->fr_address
6114 > fix->fx_frag->fr_address)
6115 || (symbol_get_tc (fix->fx_addsy)->next != NULL
6116 && (symbol_get_frag (symbol_get_tc (fix->fx_addsy)->next)->fr_address
6117 <= fix->fx_frag->fr_address))))
6118 return 1;
6119
6120 return generic_force_reloc (fix);
6121 }
6122
6123 void
6124 ppc_new_dot_label (symbolS *sym)
6125 {
6126 /* Anchor this label to the current csect for relocations. */
6127 symbol_get_tc (sym)->within = ppc_current_csect;
6128 }
6129
6130 #endif /* OBJ_XCOFF */
6131
6132 #ifdef OBJ_ELF
6133 /* If this function returns non-zero, it guarantees that a relocation
6134 will be emitted for a fixup. */
6135
6136 int
6137 ppc_force_relocation (fixS *fix)
6138 {
6139 /* Branch prediction relocations must force a relocation, as must
6140 the vtable description relocs. */
6141 switch (fix->fx_r_type)
6142 {
6143 case BFD_RELOC_PPC_B16_BRTAKEN:
6144 case BFD_RELOC_PPC_B16_BRNTAKEN:
6145 case BFD_RELOC_PPC_BA16_BRTAKEN:
6146 case BFD_RELOC_PPC_BA16_BRNTAKEN:
6147 case BFD_RELOC_24_PLT_PCREL:
6148 case BFD_RELOC_PPC64_TOC:
6149 return 1;
6150 default:
6151 break;
6152 }
6153
6154 if (fix->fx_r_type >= BFD_RELOC_PPC_TLS
6155 && fix->fx_r_type <= BFD_RELOC_PPC64_DTPREL16_HIGHESTA)
6156 return 1;
6157
6158 return generic_force_reloc (fix);
6159 }
6160
6161 int
6162 ppc_fix_adjustable (fixS *fix)
6163 {
6164 return (fix->fx_r_type != BFD_RELOC_16_GOTOFF
6165 && fix->fx_r_type != BFD_RELOC_LO16_GOTOFF
6166 && fix->fx_r_type != BFD_RELOC_HI16_GOTOFF
6167 && fix->fx_r_type != BFD_RELOC_HI16_S_GOTOFF
6168 && fix->fx_r_type != BFD_RELOC_PPC64_GOT16_DS
6169 && fix->fx_r_type != BFD_RELOC_PPC64_GOT16_LO_DS
6170 && fix->fx_r_type != BFD_RELOC_GPREL16
6171 && fix->fx_r_type != BFD_RELOC_VTABLE_INHERIT
6172 && fix->fx_r_type != BFD_RELOC_VTABLE_ENTRY
6173 && !(fix->fx_r_type >= BFD_RELOC_PPC_TLS
6174 && fix->fx_r_type <= BFD_RELOC_PPC64_DTPREL16_HIGHESTA));
6175 }
6176 #endif
6177
6178 void
6179 ppc_frag_check (struct frag *fragP)
6180 {
6181 if (!fragP->has_code)
6182 return;
6183
6184 if (ppc_mach() == bfd_mach_ppc_vle)
6185 {
6186 if (((fragP->fr_address + fragP->insn_addr) & 1) != 0)
6187 as_bad (_("instruction address is not a multiple of 2"));
6188 }
6189 else
6190 {
6191 if (((fragP->fr_address + fragP->insn_addr) & 3) != 0)
6192 as_bad (_("instruction address is not a multiple of 4"));
6193 }
6194 }
6195
6196 /* Implement HANDLE_ALIGN. This writes the NOP pattern into an
6197 rs_align_code frag. */
6198
6199 void
6200 ppc_handle_align (struct frag *fragP)
6201 {
6202 valueT count = (fragP->fr_next->fr_address
6203 - (fragP->fr_address + fragP->fr_fix));
6204
6205 if (ppc_mach() == bfd_mach_ppc_vle && count != 0 && (count & 1) == 0)
6206 {
6207 char *dest = fragP->fr_literal + fragP->fr_fix;
6208
6209 fragP->fr_var = 2;
6210 md_number_to_chars (dest, 0x4400, 2);
6211 }
6212 else if (count != 0 && (count & 3) == 0)
6213 {
6214 char *dest = fragP->fr_literal + fragP->fr_fix;
6215
6216 fragP->fr_var = 4;
6217
6218 if (count > 4 * nop_limit && count < 0x2000000)
6219 {
6220 struct frag *rest;
6221
6222 /* Make a branch, then follow with nops. Insert another
6223 frag to handle the nops. */
6224 md_number_to_chars (dest, 0x48000000 + count, 4);
6225 count -= 4;
6226 if (count == 0)
6227 return;
6228
6229 rest = xmalloc (SIZEOF_STRUCT_FRAG + 4);
6230 memcpy (rest, fragP, SIZEOF_STRUCT_FRAG);
6231 fragP->fr_next = rest;
6232 fragP = rest;
6233 rest->fr_address += rest->fr_fix + 4;
6234 rest->fr_fix = 0;
6235 /* If we leave the next frag as rs_align_code we'll come here
6236 again, resulting in a bunch of branches rather than a
6237 branch followed by nops. */
6238 rest->fr_type = rs_align;
6239 dest = rest->fr_literal;
6240 }
6241
6242 md_number_to_chars (dest, 0x60000000, 4);
6243
6244 if ((ppc_cpu & PPC_OPCODE_POWER6) != 0
6245 || (ppc_cpu & PPC_OPCODE_POWER7) != 0
6246 || (ppc_cpu & PPC_OPCODE_POWER8) != 0)
6247 {
6248 /* For power6, power7 and power8, we want the last nop to be a group
6249 terminating one. Do this by inserting an rs_fill frag immediately
6250 after this one, with its address set to the last nop location.
6251 This will automatically reduce the number of nops in the current
6252 frag by one. */
6253 if (count > 4)
6254 {
6255 struct frag *group_nop = xmalloc (SIZEOF_STRUCT_FRAG + 4);
6256
6257 memcpy (group_nop, fragP, SIZEOF_STRUCT_FRAG);
6258 group_nop->fr_address = group_nop->fr_next->fr_address - 4;
6259 group_nop->fr_fix = 0;
6260 group_nop->fr_offset = 1;
6261 group_nop->fr_type = rs_fill;
6262 fragP->fr_next = group_nop;
6263 dest = group_nop->fr_literal;
6264 }
6265
6266 if ((ppc_cpu & PPC_OPCODE_POWER7) != 0
6267 || (ppc_cpu & PPC_OPCODE_POWER8) != 0)
6268 {
6269 if (ppc_cpu & PPC_OPCODE_E500MC)
6270 /* e500mc group terminating nop: "ori 0,0,0". */
6271 md_number_to_chars (dest, 0x60000000, 4);
6272 else
6273 /* power7/power8 group terminating nop: "ori 2,2,0". */
6274 md_number_to_chars (dest, 0x60420000, 4);
6275 }
6276 else
6277 /* power6 group terminating nop: "ori 1,1,0". */
6278 md_number_to_chars (dest, 0x60210000, 4);
6279 }
6280 }
6281 }
6282
6283 /* Apply a fixup to the object code. This is called for all the
6284 fixups we generated by the calls to fix_new_exp, above. */
6285
6286 void
6287 md_apply_fix (fixS *fixP, valueT *valP, segT seg ATTRIBUTE_UNUSED)
6288 {
6289 valueT value = * valP;
6290
6291 #ifdef OBJ_ELF
6292 if (fixP->fx_addsy != NULL)
6293 {
6294 /* Hack around bfd_install_relocation brain damage. */
6295 if (fixP->fx_pcrel)
6296 value += fixP->fx_frag->fr_address + fixP->fx_where;
6297 }
6298 else
6299 fixP->fx_done = 1;
6300 #else
6301 /* FIXME FIXME FIXME: The value we are passed in *valP includes
6302 the symbol values. If we are doing this relocation the code in
6303 write.c is going to call bfd_install_relocation, which is also
6304 going to use the symbol value. That means that if the reloc is
6305 fully resolved we want to use *valP since bfd_install_relocation is
6306 not being used.
6307 However, if the reloc is not fully resolved we do not want to
6308 use *valP, and must use fx_offset instead. If the relocation
6309 is PC-relative, we then need to re-apply md_pcrel_from_section
6310 to this new relocation value. */
6311 if (fixP->fx_addsy == (symbolS *) NULL)
6312 fixP->fx_done = 1;
6313
6314 else
6315 {
6316 value = fixP->fx_offset;
6317 if (fixP->fx_pcrel)
6318 value -= md_pcrel_from_section (fixP, seg);
6319 }
6320 #endif
6321
6322 if (fixP->fx_subsy != (symbolS *) NULL)
6323 {
6324 /* We can't actually support subtracting a symbol. */
6325 as_bad_where (fixP->fx_file, fixP->fx_line, _("expression too complex"));
6326 }
6327
6328 if (fixP->fx_pcrel_adjust != 0)
6329 {
6330 /* Handle relocs in an insn. */
6331
6332 int opindex = fixP->fx_pcrel_adjust & 0xff;
6333 const struct powerpc_operand *operand = &powerpc_operands[opindex];
6334 char *where;
6335 unsigned long insn;
6336 offsetT fieldval;
6337
6338 #ifdef OBJ_XCOFF
6339 /* An instruction like `lwz 9,sym(30)' when `sym' is not a TOC symbol
6340 does not generate a reloc. It uses the offset of `sym' within its
6341 csect. Other usages, such as `.long sym', generate relocs. This
6342 is the documented behaviour of non-TOC symbols. */
6343 if ((operand->flags & PPC_OPERAND_PARENS) != 0
6344 && (operand->bitm & 0xfff0) == 0xfff0
6345 && operand->shift == 0
6346 && (operand->insert == NULL || ppc_obj64)
6347 && fixP->fx_addsy != NULL
6348 && symbol_get_tc (fixP->fx_addsy)->subseg != 0
6349 && symbol_get_tc (fixP->fx_addsy)->symbol_class != XMC_TC
6350 && symbol_get_tc (fixP->fx_addsy)->symbol_class != XMC_TC0
6351 && S_GET_SEGMENT (fixP->fx_addsy) != bss_section)
6352 {
6353 value = fixP->fx_offset;
6354 fixP->fx_done = 1;
6355 }
6356 #endif
6357 fieldval = value;
6358 switch (fixP->fx_r_type)
6359 {
6360 #ifdef OBJ_ELF
6361 case BFD_RELOC_PPC64_ADDR16_LO_DS:
6362 if (fixP->fx_pcrel)
6363 goto bad_pcrel;
6364 /* fall through */
6365 #endif
6366 case BFD_RELOC_LO16:
6367 if (fixP->fx_pcrel)
6368 fixP->fx_r_type = BFD_RELOC_LO16_PCREL;
6369 /* fall through */
6370 case BFD_RELOC_LO16_PCREL:
6371 case BFD_RELOC_PPC_VLE_LO16A:
6372 case BFD_RELOC_PPC_VLE_LO16D:
6373 fieldval = value & 0xffff;
6374 sign_extend_16:
6375 if ((operand->flags & PPC_OPERAND_SIGNED) != 0)
6376 fieldval = (fieldval ^ 0x8000) - 0x8000;
6377 fixP->fx_no_overflow = 1;
6378 break;
6379
6380 case BFD_RELOC_HI16:
6381 if (fixP->fx_pcrel)
6382 fixP->fx_r_type = BFD_RELOC_HI16_PCREL;
6383 /* fall through */
6384 case BFD_RELOC_HI16_PCREL:
6385 case BFD_RELOC_PPC_VLE_HI16A:
6386 case BFD_RELOC_PPC_VLE_HI16D:
6387 fieldval = PPC_HI (value);
6388 goto sign_extend_16;
6389
6390 case BFD_RELOC_HI16_S:
6391 if (fixP->fx_pcrel)
6392 fixP->fx_r_type = BFD_RELOC_HI16_S_PCREL;
6393 /* fall through */
6394 case BFD_RELOC_HI16_S_PCREL:
6395 case BFD_RELOC_PPC_VLE_HA16A:
6396 case BFD_RELOC_PPC_VLE_HA16D:
6397 fieldval = PPC_HA (value);
6398 goto sign_extend_16;
6399
6400 #ifdef OBJ_ELF
6401 case BFD_RELOC_PPC64_HIGHER:
6402 if (fixP->fx_pcrel)
6403 goto bad_pcrel;
6404 fieldval = PPC_HIGHER (value);
6405 goto sign_extend_16;
6406
6407 case BFD_RELOC_PPC64_HIGHER_S:
6408 if (fixP->fx_pcrel)
6409 goto bad_pcrel;
6410 fieldval = PPC_HIGHERA (value);
6411 goto sign_extend_16;
6412
6413 case BFD_RELOC_PPC64_HIGHEST:
6414 if (fixP->fx_pcrel)
6415 goto bad_pcrel;
6416 fieldval = PPC_HIGHEST (value);
6417 goto sign_extend_16;
6418
6419 case BFD_RELOC_PPC64_HIGHEST_S:
6420 if (fixP->fx_pcrel)
6421 goto bad_pcrel;
6422 fieldval = PPC_HIGHESTA (value);
6423 goto sign_extend_16;
6424
6425 /* The following relocs can't be calculated by the assembler.
6426 Leave the field zero. */
6427 case BFD_RELOC_PPC_TPREL16:
6428 case BFD_RELOC_PPC_TPREL16_LO:
6429 case BFD_RELOC_PPC_TPREL16_HI:
6430 case BFD_RELOC_PPC_TPREL16_HA:
6431 case BFD_RELOC_PPC_DTPREL16:
6432 case BFD_RELOC_PPC_DTPREL16_LO:
6433 case BFD_RELOC_PPC_DTPREL16_HI:
6434 case BFD_RELOC_PPC_DTPREL16_HA:
6435 case BFD_RELOC_PPC_GOT_TLSGD16:
6436 case BFD_RELOC_PPC_GOT_TLSGD16_LO:
6437 case BFD_RELOC_PPC_GOT_TLSGD16_HI:
6438 case BFD_RELOC_PPC_GOT_TLSGD16_HA:
6439 case BFD_RELOC_PPC_GOT_TLSLD16:
6440 case BFD_RELOC_PPC_GOT_TLSLD16_LO:
6441 case BFD_RELOC_PPC_GOT_TLSLD16_HI:
6442 case BFD_RELOC_PPC_GOT_TLSLD16_HA:
6443 case BFD_RELOC_PPC_GOT_TPREL16:
6444 case BFD_RELOC_PPC_GOT_TPREL16_LO:
6445 case BFD_RELOC_PPC_GOT_TPREL16_HI:
6446 case BFD_RELOC_PPC_GOT_TPREL16_HA:
6447 case BFD_RELOC_PPC_GOT_DTPREL16:
6448 case BFD_RELOC_PPC_GOT_DTPREL16_LO:
6449 case BFD_RELOC_PPC_GOT_DTPREL16_HI:
6450 case BFD_RELOC_PPC_GOT_DTPREL16_HA:
6451 case BFD_RELOC_PPC64_TPREL16_DS:
6452 case BFD_RELOC_PPC64_TPREL16_LO_DS:
6453 case BFD_RELOC_PPC64_TPREL16_HIGHER:
6454 case BFD_RELOC_PPC64_TPREL16_HIGHERA:
6455 case BFD_RELOC_PPC64_TPREL16_HIGHEST:
6456 case BFD_RELOC_PPC64_TPREL16_HIGHESTA:
6457 case BFD_RELOC_PPC64_DTPREL16_DS:
6458 case BFD_RELOC_PPC64_DTPREL16_LO_DS:
6459 case BFD_RELOC_PPC64_DTPREL16_HIGHER:
6460 case BFD_RELOC_PPC64_DTPREL16_HIGHERA:
6461 case BFD_RELOC_PPC64_DTPREL16_HIGHEST:
6462 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:
6463 gas_assert (fixP->fx_addsy != NULL);
6464 S_SET_THREAD_LOCAL (fixP->fx_addsy);
6465 fieldval = 0;
6466 if (fixP->fx_pcrel)
6467 goto bad_pcrel;
6468 break;
6469
6470 /* These also should leave the field zero for the same
6471 reason. Note that older versions of gas wrote values
6472 here. If we want to go back to the old behaviour, then
6473 all _LO and _LO_DS cases will need to be treated like
6474 BFD_RELOC_LO16_PCREL above. Similarly for _HI etc. */
6475 case BFD_RELOC_16_GOTOFF:
6476 case BFD_RELOC_LO16_GOTOFF:
6477 case BFD_RELOC_HI16_GOTOFF:
6478 case BFD_RELOC_HI16_S_GOTOFF:
6479 case BFD_RELOC_LO16_PLTOFF:
6480 case BFD_RELOC_HI16_PLTOFF:
6481 case BFD_RELOC_HI16_S_PLTOFF:
6482 case BFD_RELOC_GPREL16:
6483 case BFD_RELOC_16_BASEREL:
6484 case BFD_RELOC_LO16_BASEREL:
6485 case BFD_RELOC_HI16_BASEREL:
6486 case BFD_RELOC_HI16_S_BASEREL:
6487 case BFD_RELOC_PPC_TOC16:
6488 case BFD_RELOC_PPC64_TOC16_LO:
6489 case BFD_RELOC_PPC64_TOC16_HI:
6490 case BFD_RELOC_PPC64_TOC16_HA:
6491 case BFD_RELOC_PPC64_PLTGOT16:
6492 case BFD_RELOC_PPC64_PLTGOT16_LO:
6493 case BFD_RELOC_PPC64_PLTGOT16_HI:
6494 case BFD_RELOC_PPC64_PLTGOT16_HA:
6495 case BFD_RELOC_PPC64_GOT16_DS:
6496 case BFD_RELOC_PPC64_GOT16_LO_DS:
6497 case BFD_RELOC_PPC64_PLT16_LO_DS:
6498 case BFD_RELOC_PPC64_SECTOFF_DS:
6499 case BFD_RELOC_PPC64_SECTOFF_LO_DS:
6500 case BFD_RELOC_PPC64_TOC16_DS:
6501 case BFD_RELOC_PPC64_TOC16_LO_DS:
6502 case BFD_RELOC_PPC64_PLTGOT16_DS:
6503 case BFD_RELOC_PPC64_PLTGOT16_LO_DS:
6504 case BFD_RELOC_PPC_EMB_NADDR16:
6505 case BFD_RELOC_PPC_EMB_NADDR16_LO:
6506 case BFD_RELOC_PPC_EMB_NADDR16_HI:
6507 case BFD_RELOC_PPC_EMB_NADDR16_HA:
6508 case BFD_RELOC_PPC_EMB_SDAI16:
6509 case BFD_RELOC_PPC_EMB_SDA2I16:
6510 case BFD_RELOC_PPC_EMB_SDA2REL:
6511 case BFD_RELOC_PPC_EMB_SDA21:
6512 case BFD_RELOC_PPC_EMB_MRKREF:
6513 case BFD_RELOC_PPC_EMB_RELSEC16:
6514 case BFD_RELOC_PPC_EMB_RELST_LO:
6515 case BFD_RELOC_PPC_EMB_RELST_HI:
6516 case BFD_RELOC_PPC_EMB_RELST_HA:
6517 case BFD_RELOC_PPC_EMB_BIT_FLD:
6518 case BFD_RELOC_PPC_EMB_RELSDA:
6519 case BFD_RELOC_PPC_VLE_SDA21:
6520 case BFD_RELOC_PPC_VLE_SDA21_LO:
6521 case BFD_RELOC_PPC_VLE_SDAREL_LO16A:
6522 case BFD_RELOC_PPC_VLE_SDAREL_LO16D:
6523 case BFD_RELOC_PPC_VLE_SDAREL_HI16A:
6524 case BFD_RELOC_PPC_VLE_SDAREL_HI16D:
6525 case BFD_RELOC_PPC_VLE_SDAREL_HA16A:
6526 case BFD_RELOC_PPC_VLE_SDAREL_HA16D:
6527 gas_assert (fixP->fx_addsy != NULL);
6528 /* Fall thru */
6529
6530 case BFD_RELOC_PPC_TLS:
6531 case BFD_RELOC_PPC_TLSGD:
6532 case BFD_RELOC_PPC_TLSLD:
6533 fieldval = 0;
6534 if (fixP->fx_pcrel)
6535 goto bad_pcrel;
6536 break;
6537 #endif
6538
6539 default:
6540 break;
6541 }
6542
6543 #ifdef OBJ_ELF
6544 /* powerpc uses RELA style relocs, so if emitting a reloc the field
6545 contents can stay at zero. */
6546 #define APPLY_RELOC fixP->fx_done
6547 #else
6548 #define APPLY_RELOC 1
6549 #endif
6550 if ((fieldval != 0 && APPLY_RELOC) || operand->insert != NULL)
6551 {
6552 /* Fetch the instruction, insert the fully resolved operand
6553 value, and stuff the instruction back again. */
6554 where = fixP->fx_frag->fr_literal + fixP->fx_where;
6555 if (target_big_endian)
6556 {
6557 if (fixP->fx_size == 4)
6558 insn = bfd_getb32 ((unsigned char *) where);
6559 else
6560 insn = bfd_getb16 ((unsigned char *) where);
6561 }
6562 else
6563 {
6564 if (fixP->fx_size == 4)
6565 insn = bfd_getl32 ((unsigned char *) where);
6566 else
6567 insn = bfd_getl16 ((unsigned char *) where);
6568 }
6569 insn = ppc_insert_operand (insn, operand, fieldval,
6570 fixP->tc_fix_data.ppc_cpu,
6571 fixP->fx_file, fixP->fx_line);
6572 if (target_big_endian)
6573 {
6574 if (fixP->fx_size == 4)
6575 bfd_putb32 ((bfd_vma) insn, (unsigned char *) where);
6576 else
6577 bfd_putb16 ((bfd_vma) insn, (unsigned char *) where);
6578 }
6579 else
6580 {
6581 if (fixP->fx_size == 4)
6582 bfd_putl32 ((bfd_vma) insn, (unsigned char *) where);
6583 else
6584 bfd_putl16 ((bfd_vma) insn, (unsigned char *) where);
6585 }
6586 }
6587
6588 if (fixP->fx_done)
6589 /* Nothing else to do here. */
6590 return;
6591
6592 gas_assert (fixP->fx_addsy != NULL);
6593 if (fixP->fx_r_type == BFD_RELOC_UNUSED)
6594 {
6595 char *sfile;
6596 unsigned int sline;
6597
6598 /* Use expr_symbol_where to see if this is an expression
6599 symbol. */
6600 if (expr_symbol_where (fixP->fx_addsy, &sfile, &sline))
6601 as_bad_where (fixP->fx_file, fixP->fx_line,
6602 _("unresolved expression that must be resolved"));
6603 else
6604 as_bad_where (fixP->fx_file, fixP->fx_line,
6605 _("unsupported relocation against %s"),
6606 S_GET_NAME (fixP->fx_addsy));
6607 fixP->fx_done = 1;
6608 return;
6609 }
6610 }
6611 else
6612 {
6613 int size = 0;
6614 offsetT fieldval = value;
6615
6616 /* Handle relocs in data. */
6617 switch (fixP->fx_r_type)
6618 {
6619 case BFD_RELOC_CTOR:
6620 if (ppc_obj64)
6621 goto ctor64;
6622 /* fall through */
6623
6624 case BFD_RELOC_32:
6625 if (fixP->fx_pcrel)
6626 fixP->fx_r_type = BFD_RELOC_32_PCREL;
6627 /* fall through */
6628
6629 case BFD_RELOC_32_PCREL:
6630 case BFD_RELOC_RVA:
6631 size = 4;
6632 break;
6633
6634 case BFD_RELOC_64:
6635 ctor64:
6636 if (fixP->fx_pcrel)
6637 fixP->fx_r_type = BFD_RELOC_64_PCREL;
6638 /* fall through */
6639
6640 case BFD_RELOC_64_PCREL:
6641 size = 8;
6642 break;
6643
6644 case BFD_RELOC_16:
6645 if (fixP->fx_pcrel)
6646 fixP->fx_r_type = BFD_RELOC_16_PCREL;
6647 /* fall through */
6648
6649 case BFD_RELOC_16_PCREL:
6650 size = 2;
6651 break;
6652
6653 case BFD_RELOC_8:
6654 if (fixP->fx_pcrel)
6655 {
6656 #ifdef OBJ_ELF
6657 bad_pcrel:
6658 #endif
6659 if (fixP->fx_addsy)
6660 {
6661 char *sfile;
6662 unsigned int sline;
6663
6664 /* Use expr_symbol_where to see if this is an
6665 expression symbol. */
6666 if (expr_symbol_where (fixP->fx_addsy, &sfile, &sline))
6667 as_bad_where (fixP->fx_file, fixP->fx_line,
6668 _("unresolved expression that must"
6669 " be resolved"));
6670 else
6671 as_bad_where (fixP->fx_file, fixP->fx_line,
6672 _("cannot emit PC relative %s relocation"
6673 " against %s"),
6674 bfd_get_reloc_code_name (fixP->fx_r_type),
6675 S_GET_NAME (fixP->fx_addsy));
6676 }
6677 else
6678 as_bad_where (fixP->fx_file, fixP->fx_line,
6679 _("unable to resolve expression"));
6680 fixP->fx_done = 1;
6681 }
6682 else
6683 size = 1;
6684 break;
6685
6686 case BFD_RELOC_VTABLE_INHERIT:
6687 if (fixP->fx_addsy
6688 && !S_IS_DEFINED (fixP->fx_addsy)
6689 && !S_IS_WEAK (fixP->fx_addsy))
6690 S_SET_WEAK (fixP->fx_addsy);
6691 /* Fall thru */
6692
6693 case BFD_RELOC_VTABLE_ENTRY:
6694 fixP->fx_done = 0;
6695 break;
6696
6697 #ifdef OBJ_ELF
6698 /* These can appear with @l etc. in data. */
6699 case BFD_RELOC_LO16:
6700 if (fixP->fx_pcrel)
6701 fixP->fx_r_type = BFD_RELOC_LO16_PCREL;
6702 case BFD_RELOC_LO16_PCREL:
6703 size = 2;
6704 break;
6705
6706 case BFD_RELOC_HI16:
6707 if (fixP->fx_pcrel)
6708 fixP->fx_r_type = BFD_RELOC_HI16_PCREL;
6709 case BFD_RELOC_HI16_PCREL:
6710 size = 2;
6711 fieldval = PPC_HI (value);
6712 break;
6713
6714 case BFD_RELOC_HI16_S:
6715 if (fixP->fx_pcrel)
6716 fixP->fx_r_type = BFD_RELOC_HI16_S_PCREL;
6717 case BFD_RELOC_HI16_S_PCREL:
6718 size = 2;
6719 fieldval = PPC_HA (value);
6720 break;
6721
6722 case BFD_RELOC_PPC64_HIGHER:
6723 if (fixP->fx_pcrel)
6724 goto bad_pcrel;
6725 size = 2;
6726 fieldval = PPC_HIGHER (value);
6727 break;
6728
6729 case BFD_RELOC_PPC64_HIGHER_S:
6730 if (fixP->fx_pcrel)
6731 goto bad_pcrel;
6732 size = 2;
6733 fieldval = PPC_HIGHERA (value);
6734 break;
6735
6736 case BFD_RELOC_PPC64_HIGHEST:
6737 if (fixP->fx_pcrel)
6738 goto bad_pcrel;
6739 size = 2;
6740 fieldval = PPC_HIGHEST (value);
6741 break;
6742
6743 case BFD_RELOC_PPC64_HIGHEST_S:
6744 if (fixP->fx_pcrel)
6745 goto bad_pcrel;
6746 size = 2;
6747 fieldval = PPC_HIGHESTA (value);
6748 break;
6749
6750 case BFD_RELOC_PPC_DTPMOD:
6751 case BFD_RELOC_PPC_TPREL:
6752 case BFD_RELOC_PPC_DTPREL:
6753 S_SET_THREAD_LOCAL (fixP->fx_addsy);
6754 break;
6755
6756 /* Just punt all of these to the linker. */
6757 case BFD_RELOC_PPC_B16_BRTAKEN:
6758 case BFD_RELOC_PPC_B16_BRNTAKEN:
6759 case BFD_RELOC_16_GOTOFF:
6760 case BFD_RELOC_LO16_GOTOFF:
6761 case BFD_RELOC_HI16_GOTOFF:
6762 case BFD_RELOC_HI16_S_GOTOFF:
6763 case BFD_RELOC_LO16_PLTOFF:
6764 case BFD_RELOC_HI16_PLTOFF:
6765 case BFD_RELOC_HI16_S_PLTOFF:
6766 case BFD_RELOC_PPC_COPY:
6767 case BFD_RELOC_PPC_GLOB_DAT:
6768 case BFD_RELOC_16_BASEREL:
6769 case BFD_RELOC_LO16_BASEREL:
6770 case BFD_RELOC_HI16_BASEREL:
6771 case BFD_RELOC_HI16_S_BASEREL:
6772 case BFD_RELOC_PPC_TLS:
6773 case BFD_RELOC_PPC_DTPREL16_LO:
6774 case BFD_RELOC_PPC_DTPREL16_HI:
6775 case BFD_RELOC_PPC_DTPREL16_HA:
6776 case BFD_RELOC_PPC_TPREL16_LO:
6777 case BFD_RELOC_PPC_TPREL16_HI:
6778 case BFD_RELOC_PPC_TPREL16_HA:
6779 case BFD_RELOC_PPC_GOT_TLSGD16:
6780 case BFD_RELOC_PPC_GOT_TLSGD16_LO:
6781 case BFD_RELOC_PPC_GOT_TLSGD16_HI:
6782 case BFD_RELOC_PPC_GOT_TLSGD16_HA:
6783 case BFD_RELOC_PPC_GOT_TLSLD16:
6784 case BFD_RELOC_PPC_GOT_TLSLD16_LO:
6785 case BFD_RELOC_PPC_GOT_TLSLD16_HI:
6786 case BFD_RELOC_PPC_GOT_TLSLD16_HA:
6787 case BFD_RELOC_PPC_GOT_DTPREL16:
6788 case BFD_RELOC_PPC_GOT_DTPREL16_LO:
6789 case BFD_RELOC_PPC_GOT_DTPREL16_HI:
6790 case BFD_RELOC_PPC_GOT_DTPREL16_HA:
6791 case BFD_RELOC_PPC_GOT_TPREL16:
6792 case BFD_RELOC_PPC_GOT_TPREL16_LO:
6793 case BFD_RELOC_PPC_GOT_TPREL16_HI:
6794 case BFD_RELOC_PPC_GOT_TPREL16_HA:
6795 case BFD_RELOC_24_PLT_PCREL:
6796 case BFD_RELOC_PPC_LOCAL24PC:
6797 case BFD_RELOC_32_PLT_PCREL:
6798 case BFD_RELOC_GPREL16:
6799 case BFD_RELOC_PPC_VLE_SDAREL_LO16A:
6800 case BFD_RELOC_PPC_VLE_SDAREL_HI16A:
6801 case BFD_RELOC_PPC_VLE_SDAREL_HA16A:
6802 case BFD_RELOC_PPC_EMB_NADDR32:
6803 case BFD_RELOC_PPC_EMB_NADDR16:
6804 case BFD_RELOC_PPC_EMB_NADDR16_LO:
6805 case BFD_RELOC_PPC_EMB_NADDR16_HI:
6806 case BFD_RELOC_PPC_EMB_NADDR16_HA:
6807 case BFD_RELOC_PPC_EMB_SDAI16:
6808 case BFD_RELOC_PPC_EMB_SDA2REL:
6809 case BFD_RELOC_PPC_EMB_SDA2I16:
6810 case BFD_RELOC_PPC_EMB_SDA21:
6811 case BFD_RELOC_PPC_VLE_SDA21_LO:
6812 case BFD_RELOC_PPC_EMB_MRKREF:
6813 case BFD_RELOC_PPC_EMB_RELSEC16:
6814 case BFD_RELOC_PPC_EMB_RELST_LO:
6815 case BFD_RELOC_PPC_EMB_RELST_HI:
6816 case BFD_RELOC_PPC_EMB_RELST_HA:
6817 case BFD_RELOC_PPC_EMB_BIT_FLD:
6818 case BFD_RELOC_PPC_EMB_RELSDA:
6819 case BFD_RELOC_PPC64_TOC:
6820 case BFD_RELOC_PPC_TOC16:
6821 case BFD_RELOC_PPC64_TOC16_LO:
6822 case BFD_RELOC_PPC64_TOC16_HI:
6823 case BFD_RELOC_PPC64_TOC16_HA:
6824 case BFD_RELOC_PPC64_DTPREL16_HIGHER:
6825 case BFD_RELOC_PPC64_DTPREL16_HIGHERA:
6826 case BFD_RELOC_PPC64_DTPREL16_HIGHEST:
6827 case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:
6828 case BFD_RELOC_PPC64_TPREL16_HIGHER:
6829 case BFD_RELOC_PPC64_TPREL16_HIGHERA:
6830 case BFD_RELOC_PPC64_TPREL16_HIGHEST:
6831 case BFD_RELOC_PPC64_TPREL16_HIGHESTA:
6832 fixP->fx_done = 0;
6833 break;
6834 #endif
6835
6836 #ifdef OBJ_XCOFF
6837 case BFD_RELOC_NONE:
6838 break;
6839 #endif
6840
6841 default:
6842 fprintf (stderr,
6843 _("Gas failure, reloc value %d\n"), fixP->fx_r_type);
6844 fflush (stderr);
6845 abort ();
6846 }
6847
6848 if (size && APPLY_RELOC)
6849 md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
6850 fieldval, size);
6851 }
6852
6853 #ifdef OBJ_ELF
6854 ppc_elf_validate_fix (fixP, seg);
6855 fixP->fx_addnumber = value;
6856
6857 /* PowerPC uses RELA relocs, ie. the reloc addend is stored separately
6858 from the section contents. If we are going to be emitting a reloc
6859 then the section contents are immaterial, so don't warn if they
6860 happen to overflow. Leave such warnings to ld. */
6861 if (!fixP->fx_done)
6862 {
6863 fixP->fx_no_overflow = 1;
6864
6865 /* Arrange to emit .TOC. as a normal symbol if used in anything
6866 but .TOC.@tocbase. */
6867 if (ppc_obj64
6868 && fixP->fx_r_type != BFD_RELOC_PPC64_TOC
6869 && fixP->fx_addsy != NULL
6870 && strcmp (S_GET_NAME (fixP->fx_addsy), ".TOC.") == 0)
6871 symbol_get_bfdsym (fixP->fx_addsy)->flags |= BSF_KEEP;
6872 }
6873 #else
6874 if (fixP->fx_r_type != BFD_RELOC_PPC_TOC16)
6875 fixP->fx_addnumber = 0;
6876 else
6877 {
6878 #ifdef TE_PE
6879 fixP->fx_addnumber = 0;
6880 #else
6881 /* We want to use the offset within the toc, not the actual VMA
6882 of the symbol. */
6883 fixP->fx_addnumber =
6884 - bfd_get_section_vma (stdoutput, S_GET_SEGMENT (fixP->fx_addsy))
6885 - S_GET_VALUE (ppc_toc_csect);
6886 #endif
6887 }
6888 #endif
6889 }
6890
6891 /* Generate a reloc for a fixup. */
6892
6893 arelent *
6894 tc_gen_reloc (asection *seg ATTRIBUTE_UNUSED, fixS *fixp)
6895 {
6896 arelent *reloc;
6897
6898 reloc = (arelent *) xmalloc (sizeof (arelent));
6899
6900 reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
6901 *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
6902 reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
6903 reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
6904 if (reloc->howto == (reloc_howto_type *) NULL)
6905 {
6906 as_bad_where (fixp->fx_file, fixp->fx_line,
6907 _("reloc %d not supported by object file format"),
6908 (int) fixp->fx_r_type);
6909 return NULL;
6910 }
6911 reloc->addend = fixp->fx_addnumber;
6912
6913 return reloc;
6914 }
6915
6916 void
6917 ppc_cfi_frame_initial_instructions (void)
6918 {
6919 cfi_add_CFA_def_cfa (1, 0);
6920 }
6921
6922 int
6923 tc_ppc_regname_to_dw2regnum (char *regname)
6924 {
6925 unsigned int regnum = -1;
6926 unsigned int i;
6927 const char *p;
6928 char *q;
6929 static struct { char *name; int dw2regnum; } regnames[] =
6930 {
6931 { "sp", 1 }, { "r.sp", 1 }, { "rtoc", 2 }, { "r.toc", 2 },
6932 { "mq", 64 }, { "lr", 65 }, { "ctr", 66 }, { "ap", 67 },
6933 { "cr", 70 }, { "xer", 76 }, { "vrsave", 109 }, { "vscr", 110 },
6934 { "spe_acc", 111 }, { "spefscr", 112 }
6935 };
6936
6937 for (i = 0; i < ARRAY_SIZE (regnames); ++i)
6938 if (strcmp (regnames[i].name, regname) == 0)
6939 return regnames[i].dw2regnum;
6940
6941 if (regname[0] == 'r' || regname[0] == 'f' || regname[0] == 'v')
6942 {
6943 p = regname + 1 + (regname[1] == '.');
6944 regnum = strtoul (p, &q, 10);
6945 if (p == q || *q || regnum >= 32)
6946 return -1;
6947 if (regname[0] == 'f')
6948 regnum += 32;
6949 else if (regname[0] == 'v')
6950 regnum += 77;
6951 }
6952 else if (regname[0] == 'c' && regname[1] == 'r')
6953 {
6954 p = regname + 2 + (regname[2] == '.');
6955 if (p[0] < '0' || p[0] > '7' || p[1])
6956 return -1;
6957 regnum = p[0] - '0' + 68;
6958 }
6959 return regnum;
6960 }
GDB Binutils - Deliverables
This page took 0.21544 seconds and 5 git commands to generate.