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