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