gas/config/tc-ppc.c

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