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