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