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