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