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