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 = PPC_OPCODE_ANY;
 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-freebsd" : "elf32-powerpc-freebsd")
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, "%s", 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 ("%s", 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 ("%s", 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
2513         {
2514           if (ex.X_op == O_symbol && str[0] == '(')
2515             {
2516               const char *sym_name = S_GET_NAME (ex.X_add_symbol);
2517               if (sym_name[0] == '.')
2518                 ++sym_name;
2519
2520               if (strcasecmp (sym_name, "__tls_get_addr") == 0)
2521                 {
2522                   expressionS tls_exp;
2523
2524                   hold = input_line_pointer;
2525                   input_line_pointer = str + 1;
2526                   expression (&tls_exp);
2527                   if (tls_exp.X_op == O_symbol)
2528                     {
2529                       reloc = BFD_RELOC_UNUSED;
2530                       if (strncasecmp (input_line_pointer, "@tlsgd)", 7) == 0)
2531                         {
2532                           reloc = BFD_RELOC_PPC_TLSGD;
2533                           input_line_pointer += 7;
2534                         }
2535                       else if (strncasecmp (input_line_pointer, "@tlsld)", 7) == 0)
2536                         {
2537                           reloc = BFD_RELOC_PPC_TLSLD;
2538                           input_line_pointer += 7;
2539                         }
2540                       if (reloc != BFD_RELOC_UNUSED)
2541                         {
2542                           SKIP_WHITESPACE ();
2543                           str = input_line_pointer;
2544
2545                           if (fc >= MAX_INSN_FIXUPS)
2546                             as_fatal (_("too many fixups"));
2547                           fixups[fc].exp = tls_exp;
2548                           fixups[fc].opindex = *opindex_ptr;
2549                           fixups[fc].reloc = reloc;
2550                           ++fc;
2551                         }
2552                     }
2553                   input_line_pointer = hold;
2554                 }
2555             }
2556
2557           if ((reloc = ppc_elf_suffix (&str, &ex)) != BFD_RELOC_UNUSED)
2558             {
2559               /* Some TLS tweaks.  */
2560               switch (reloc)
2561                 {
2562                 default:
2563                   break;
2564
2565                 case BFD_RELOC_PPC_TLS:
2566                   insn = ppc_insert_operand (insn, operand, ppc_obj64 ? 13 : 2,
2567                                              (char *) NULL, 0);
2568                   break;
2569
2570                   /* We'll only use the 32 (or 64) bit form of these relocations
2571                      in constants.  Instructions get the 16 bit form.  */
2572                 case BFD_RELOC_PPC_DTPREL:
2573                   reloc = BFD_RELOC_PPC_DTPREL16;
2574                   break;
2575                 case BFD_RELOC_PPC_TPREL:
2576                   reloc = BFD_RELOC_PPC_TPREL16;
2577                   break;
2578                 }
2579
2580               /* For the absolute forms of branches, convert the PC
2581                  relative form back into the absolute.  */
2582               if ((operand->flags & PPC_OPERAND_ABSOLUTE) != 0)
2583                 {
2584                   switch (reloc)
2585                     {
2586                     case BFD_RELOC_PPC_B26:
2587                       reloc = BFD_RELOC_PPC_BA26;
2588                       break;
2589                     case BFD_RELOC_PPC_B16:
2590                       reloc = BFD_RELOC_PPC_BA16;
2591                       break;
2592                     case BFD_RELOC_PPC_B16_BRTAKEN:
2593                       reloc = BFD_RELOC_PPC_BA16_BRTAKEN;
2594                       break;
2595                     case BFD_RELOC_PPC_B16_BRNTAKEN:
2596                       reloc = BFD_RELOC_PPC_BA16_BRNTAKEN;
2597                       break;
2598                     default:
2599                       break;
2600                     }
2601                 }
2602
2603               if (ppc_obj64
2604                   && (operand->flags & (PPC_OPERAND_DS | PPC_OPERAND_DQ)) != 0)
2605                 {
2606                   switch (reloc)
2607                     {
2608                     case BFD_RELOC_16:
2609                       reloc = BFD_RELOC_PPC64_ADDR16_DS;
2610                       break;
2611                     case BFD_RELOC_LO16:
2612                       reloc = BFD_RELOC_PPC64_ADDR16_LO_DS;
2613                       break;
2614                     case BFD_RELOC_16_GOTOFF:
2615                       reloc = BFD_RELOC_PPC64_GOT16_DS;
2616                       break;
2617                     case BFD_RELOC_LO16_GOTOFF:
2618                       reloc = BFD_RELOC_PPC64_GOT16_LO_DS;
2619                       break;
2620                     case BFD_RELOC_LO16_PLTOFF:
2621                       reloc = BFD_RELOC_PPC64_PLT16_LO_DS;
2622                       break;
2623                     case BFD_RELOC_16_BASEREL:
2624                       reloc = BFD_RELOC_PPC64_SECTOFF_DS;
2625                       break;
2626                     case BFD_RELOC_LO16_BASEREL:
2627                       reloc = BFD_RELOC_PPC64_SECTOFF_LO_DS;
2628                       break;
2629                     case BFD_RELOC_PPC_TOC16:
2630                       reloc = BFD_RELOC_PPC64_TOC16_DS;
2631                       break;
2632                     case BFD_RELOC_PPC64_TOC16_LO:
2633                       reloc = BFD_RELOC_PPC64_TOC16_LO_DS;
2634                       break;
2635                     case BFD_RELOC_PPC64_PLTGOT16:
2636                       reloc = BFD_RELOC_PPC64_PLTGOT16_DS;
2637                       break;
2638                     case BFD_RELOC_PPC64_PLTGOT16_LO:
2639                       reloc = BFD_RELOC_PPC64_PLTGOT16_LO_DS;
2640                       break;
2641                     case BFD_RELOC_PPC_DTPREL16:
2642                       reloc = BFD_RELOC_PPC64_DTPREL16_DS;
2643                       break;
2644                     case BFD_RELOC_PPC_DTPREL16_LO:
2645                       reloc = BFD_RELOC_PPC64_DTPREL16_LO_DS;
2646                       break;
2647                     case BFD_RELOC_PPC_TPREL16:
2648                       reloc = BFD_RELOC_PPC64_TPREL16_DS;
2649                       break;
2650                     case BFD_RELOC_PPC_TPREL16_LO:
2651                       reloc = BFD_RELOC_PPC64_TPREL16_LO_DS;
2652                       break;
2653                     case BFD_RELOC_PPC_GOT_DTPREL16:
2654                     case BFD_RELOC_PPC_GOT_DTPREL16_LO:
2655                     case BFD_RELOC_PPC_GOT_TPREL16:
2656                     case BFD_RELOC_PPC_GOT_TPREL16_LO:
2657                       break;
2658                     default:
2659                       as_bad (_("unsupported relocation for DS offset field"));
2660                       break;
2661                     }
2662                 }
2663             }
2664
2665           /* We need to generate a fixup for this expression.  */
2666           if (fc >= MAX_INSN_FIXUPS)
2667             as_fatal (_("too many fixups"));
2668           fixups[fc].exp = ex;
2669           fixups[fc].opindex = *opindex_ptr;
2670           fixups[fc].reloc = reloc;
2671           ++fc;
2672         }
2673 #else /* OBJ_ELF */
2674       else
2675         {
2676           /* We need to generate a fixup for this expression.  */
2677           if (fc >= MAX_INSN_FIXUPS)
2678             as_fatal (_("too many fixups"));
2679           fixups[fc].exp = ex;
2680           fixups[fc].opindex = *opindex_ptr;
2681           fixups[fc].reloc = BFD_RELOC_UNUSED;
2682           ++fc;
2683         }
2684 #endif /* OBJ_ELF */
2685
2686       if (need_paren)
2687         {
2688           endc = ')';
2689           need_paren = 0;
2690         }
2691       else if ((operand->flags & PPC_OPERAND_PARENS) != 0)
2692         {
2693           endc = '(';
2694           need_paren = 1;
2695         }
2696       else
2697         endc = ',';
2698
2699       /* The call to expression should have advanced str past any
2700          whitespace.  */
2701       if (*str != endc
2702           && (endc != ',' || *str != '\0'))
2703         {
2704           as_bad (_("syntax error; found `%c' but expected `%c'"), *str, endc);
2705           break;
2706         }
2707
2708       if (*str != '\0')
2709         ++str;
2710     }
2711
2712   while (ISSPACE (*str))
2713     ++str;
2714
2715   if (*str != '\0')
2716     as_bad (_("junk at end of line: `%s'"), str);
2717
2718 #ifdef OBJ_ELF
2719   /* Do we need/want a APUinfo section? */
2720   if (ppc_cpu & (PPC_OPCODE_SPE
2721                | PPC_OPCODE_ISEL | PPC_OPCODE_EFS
2722                | PPC_OPCODE_BRLOCK | PPC_OPCODE_PMR | PPC_OPCODE_CACHELCK
2723                | PPC_OPCODE_RFMCI))
2724     {
2725       /* These are all version "1".  */
2726       if (opcode->flags & PPC_OPCODE_SPE)
2727         ppc_apuinfo_section_add (PPC_APUINFO_SPE, 1);
2728       if (opcode->flags & PPC_OPCODE_ISEL)
2729         ppc_apuinfo_section_add (PPC_APUINFO_ISEL, 1);
2730       if (opcode->flags & PPC_OPCODE_EFS)
2731         ppc_apuinfo_section_add (PPC_APUINFO_EFS, 1);
2732       if (opcode->flags & PPC_OPCODE_BRLOCK)
2733         ppc_apuinfo_section_add (PPC_APUINFO_BRLOCK, 1);
2734       if (opcode->flags & PPC_OPCODE_PMR)
2735         ppc_apuinfo_section_add (PPC_APUINFO_PMR, 1);
2736       if (opcode->flags & PPC_OPCODE_CACHELCK)
2737         ppc_apuinfo_section_add (PPC_APUINFO_CACHELCK, 1);
2738       if (opcode->flags & PPC_OPCODE_RFMCI)
2739         ppc_apuinfo_section_add (PPC_APUINFO_RFMCI, 1);
2740     }
2741 #endif
2742
2743   /* Write out the instruction.  */
2744   f = frag_more (4);
2745   addr_mod = frag_now_fix () & 3;
2746   if (frag_now->has_code && frag_now->insn_addr != addr_mod)
2747     as_bad (_("instruction address is not a multiple of 4"));
2748   frag_now->insn_addr = addr_mod;
2749   frag_now->has_code = 1;
2750   md_number_to_chars (f, insn, 4);
2751
2752 #ifdef OBJ_ELF
2753   dwarf2_emit_insn (4);
2754 #endif
2755
2756   /* Create any fixups.  At this point we do not use a
2757      bfd_reloc_code_real_type, but instead just use the
2758      BFD_RELOC_UNUSED plus the operand index.  This lets us easily
2759      handle fixups for any operand type, although that is admittedly
2760      not a very exciting feature.  We pick a BFD reloc type in
2761      md_apply_fix.  */
2762   for (i = 0; i < fc; i++)
2763     {
2764       const struct powerpc_operand *operand;
2765
2766       operand = &powerpc_operands[fixups[i].opindex];
2767       if (fixups[i].reloc != BFD_RELOC_UNUSED)
2768         {
2769           reloc_howto_type *reloc_howto;
2770           int size;
2771           int offset;
2772           fixS *fixP;
2773
2774           reloc_howto = bfd_reloc_type_lookup (stdoutput, fixups[i].reloc);
2775           if (!reloc_howto)
2776             abort ();
2777
2778           size = bfd_get_reloc_size (reloc_howto);
2779           offset = target_big_endian ? (4 - size) : 0;
2780
2781           if (size < 1 || size > 4)
2782             abort ();
2783
2784           fixP = fix_new_exp (frag_now,
2785                               f - frag_now->fr_literal + offset,
2786                               size,
2787                               &fixups[i].exp,
2788                               reloc_howto->pc_relative,
2789                               fixups[i].reloc);
2790
2791           /* Turn off complaints that the addend is too large for things like
2792              foo+100000@ha.  */
2793           switch (fixups[i].reloc)
2794             {
2795             case BFD_RELOC_16_GOTOFF:
2796             case BFD_RELOC_PPC_TOC16:
2797             case BFD_RELOC_LO16:
2798             case BFD_RELOC_HI16:
2799             case BFD_RELOC_HI16_S:
2800 #ifdef OBJ_ELF
2801             case BFD_RELOC_PPC64_HIGHER:
2802             case BFD_RELOC_PPC64_HIGHER_S:
2803             case BFD_RELOC_PPC64_HIGHEST:
2804             case BFD_RELOC_PPC64_HIGHEST_S:
2805 #endif
2806               fixP->fx_no_overflow = 1;
2807               break;
2808             default:
2809               break;
2810             }
2811         }
2812       else
2813         fix_new_exp (frag_now,
2814                      f - frag_now->fr_literal,
2815                      4,
2816                      &fixups[i].exp,
2817                      (operand->flags & PPC_OPERAND_RELATIVE) != 0,
2818                      ((bfd_reloc_code_real_type)
2819                       (fixups[i].opindex + (int) BFD_RELOC_UNUSED)));
2820     }
2821 }
2822
2823 /* Handle a macro.  Gather all the operands, transform them as
2824    described by the macro, and call md_assemble recursively.  All the
2825    operands are separated by commas; we don't accept parentheses
2826    around operands here.  */
2827
2828 static void
2829 ppc_macro (char *str, const struct powerpc_macro *macro)
2830 {
2831   char *operands[10];
2832   unsigned int count;
2833   char *s;
2834   unsigned int len;
2835   const char *format;
2836   unsigned int arg;
2837   char *send;
2838   char *complete;
2839
2840   /* Gather the users operands into the operands array.  */
2841   count = 0;
2842   s = str;
2843   while (1)
2844     {
2845       if (count >= sizeof operands / sizeof operands[0])
2846         break;
2847       operands[count++] = s;
2848       s = strchr (s, ',');
2849       if (s == (char *) NULL)
2850         break;
2851       *s++ = '\0';
2852     }
2853
2854   if (count != macro->operands)
2855     {
2856       as_bad (_("wrong number of operands"));
2857       return;
2858     }
2859
2860   /* Work out how large the string must be (the size is unbounded
2861      because it includes user input).  */
2862   len = 0;
2863   format = macro->format;
2864   while (*format != '\0')
2865     {
2866       if (*format != '%')
2867         {
2868           ++len;
2869           ++format;
2870         }
2871       else
2872         {
2873           arg = strtol (format + 1, &send, 10);
2874           know (send != format && arg < count);
2875           len += strlen (operands[arg]);
2876           format = send;
2877         }
2878     }
2879
2880   /* Put the string together.  */
2881   complete = s = (char *) alloca (len + 1);
2882   format = macro->format;
2883   while (*format != '\0')
2884     {
2885       if (*format != '%')
2886         *s++ = *format++;
2887       else
2888         {
2889           arg = strtol (format + 1, &send, 10);
2890           strcpy (s, operands[arg]);
2891           s += strlen (s);
2892           format = send;
2893         }
2894     }
2895   *s = '\0';
2896
2897   /* Assemble the constructed instruction.  */
2898   md_assemble (complete);
2899 }
2900 \f
2901 #ifdef OBJ_ELF
2902 /* For ELF, add support for SHF_EXCLUDE and SHT_ORDERED.  */
2903
2904 int
2905 ppc_section_letter (int letter, char **ptr_msg)
2906 {
2907   if (letter == 'e')
2908     return SHF_EXCLUDE;
2909
2910   *ptr_msg = _("Bad .section directive: want a,e,w,x,M,S,G,T in string");
2911   return -1;
2912 }
2913
2914 int
2915 ppc_section_word (char *str, size_t len)
2916 {
2917   if (len == 7 && strncmp (str, "exclude", 7) == 0)
2918     return SHF_EXCLUDE;
2919
2920   return -1;
2921 }
2922
2923 int
2924 ppc_section_type (char *str, size_t len)
2925 {
2926   if (len == 7 && strncmp (str, "ordered", 7) == 0)
2927     return SHT_ORDERED;
2928
2929   return -1;
2930 }
2931
2932 int
2933 ppc_section_flags (int flags, int attr, int type)
2934 {
2935   if (type == SHT_ORDERED)
2936     flags |= SEC_ALLOC | SEC_LOAD | SEC_SORT_ENTRIES;
2937
2938   if (attr & SHF_EXCLUDE)
2939     flags |= SEC_EXCLUDE;
2940
2941   return flags;
2942 }
2943 #endif /* OBJ_ELF */
2944
2945 \f
2946 /* Pseudo-op handling.  */
2947
2948 /* The .byte pseudo-op.  This is similar to the normal .byte
2949    pseudo-op, but it can also take a single ASCII string.  */
2950
2951 static void
2952 ppc_byte (int ignore ATTRIBUTE_UNUSED)
2953 {
2954   if (*input_line_pointer != '\"')
2955     {
2956       cons (1);
2957       return;
2958     }
2959
2960   /* Gather characters.  A real double quote is doubled.  Unusual
2961      characters are not permitted.  */
2962   ++input_line_pointer;
2963   while (1)
2964     {
2965       char c;
2966
2967       c = *input_line_pointer++;
2968
2969       if (c == '\"')
2970         {
2971           if (*input_line_pointer != '\"')
2972             break;
2973           ++input_line_pointer;
2974         }
2975
2976       FRAG_APPEND_1_CHAR (c);
2977     }
2978
2979   demand_empty_rest_of_line ();
2980 }
2981 \f
2982 #ifdef OBJ_XCOFF
2983
2984 /* XCOFF specific pseudo-op handling.  */
2985
2986 /* This is set if we are creating a .stabx symbol, since we don't want
2987    to handle symbol suffixes for such symbols.  */
2988 static bfd_boolean ppc_stab_symbol;
2989
2990 /* The .comm and .lcomm pseudo-ops for XCOFF.  XCOFF puts common
2991    symbols in the .bss segment as though they were local common
2992    symbols, and uses a different smclas.  The native Aix 4.3.3 assembler
2993    aligns .comm and .lcomm to 4 bytes.  */
2994
2995 static void
2996 ppc_comm (int lcomm)
2997 {
2998   asection *current_seg = now_seg;
2999   subsegT current_subseg = now_subseg;
3000   char *name;
3001   char endc;
3002   char *end_name;
3003   offsetT size;
3004   offsetT align;
3005   symbolS *lcomm_sym = NULL;
3006   symbolS *sym;
3007   char *pfrag;
3008
3009   name = input_line_pointer;
3010   endc = get_symbol_end ();
3011   end_name = input_line_pointer;
3012   *end_name = endc;
3013
3014   if (*input_line_pointer != ',')
3015     {
3016       as_bad (_("missing size"));
3017       ignore_rest_of_line ();
3018       return;
3019     }
3020   ++input_line_pointer;
3021
3022   size = get_absolute_expression ();
3023   if (size < 0)
3024     {
3025       as_bad (_("negative size"));
3026       ignore_rest_of_line ();
3027       return;
3028     }
3029
3030   if (! lcomm)
3031     {
3032       /* The third argument to .comm is the alignment.  */
3033       if (*input_line_pointer != ',')
3034         align = 2;
3035       else
3036         {
3037           ++input_line_pointer;
3038           align = get_absolute_expression ();
3039           if (align <= 0)
3040             {
3041               as_warn (_("ignoring bad alignment"));
3042               align = 2;
3043             }
3044         }
3045     }
3046   else
3047     {
3048       char *lcomm_name;
3049       char lcomm_endc;
3050
3051       if (size <= 4)
3052         align = 2;
3053       else
3054         align = 3;
3055
3056       /* The third argument to .lcomm appears to be the real local
3057          common symbol to create.  References to the symbol named in
3058          the first argument are turned into references to the third
3059          argument.  */
3060       if (*input_line_pointer != ',')
3061         {
3062           as_bad (_("missing real symbol name"));
3063           ignore_rest_of_line ();
3064           return;
3065         }
3066       ++input_line_pointer;
3067
3068       lcomm_name = input_line_pointer;
3069       lcomm_endc = get_symbol_end ();
3070
3071       lcomm_sym = symbol_find_or_make (lcomm_name);
3072
3073       *input_line_pointer = lcomm_endc;
3074     }
3075
3076   *end_name = '\0';
3077   sym = symbol_find_or_make (name);
3078   *end_name = endc;
3079
3080   if (S_IS_DEFINED (sym)
3081       || S_GET_VALUE (sym) != 0)
3082     {
3083       as_bad (_("attempt to redefine symbol"));
3084       ignore_rest_of_line ();
3085       return;
3086     }
3087
3088   record_alignment (bss_section, align);
3089
3090   if (! lcomm
3091       || ! S_IS_DEFINED (lcomm_sym))
3092     {
3093       symbolS *def_sym;
3094       offsetT def_size;
3095
3096       if (! lcomm)
3097         {
3098           def_sym = sym;
3099           def_size = size;
3100           S_SET_EXTERNAL (sym);
3101         }
3102       else
3103         {
3104           symbol_get_tc (lcomm_sym)->output = 1;
3105           def_sym = lcomm_sym;
3106           def_size = 0;
3107         }
3108
3109       subseg_set (bss_section, 1);
3110       frag_align (align, 0, 0);
3111
3112       symbol_set_frag (def_sym, frag_now);
3113       pfrag = frag_var (rs_org, 1, 1, (relax_substateT) 0, def_sym,
3114                         def_size, (char *) NULL);
3115       *pfrag = 0;
3116       S_SET_SEGMENT (def_sym, bss_section);
3117       symbol_get_tc (def_sym)->align = align;
3118     }
3119   else if (lcomm)
3120     {
3121       /* Align the size of lcomm_sym.  */
3122       symbol_get_frag (lcomm_sym)->fr_offset =
3123         ((symbol_get_frag (lcomm_sym)->fr_offset + (1 << align) - 1)
3124          &~ ((1 << align) - 1));
3125       if (align > symbol_get_tc (lcomm_sym)->align)
3126         symbol_get_tc (lcomm_sym)->align = align;
3127     }
3128
3129   if (lcomm)
3130     {
3131       /* Make sym an offset from lcomm_sym.  */
3132       S_SET_SEGMENT (sym, bss_section);
3133       symbol_set_frag (sym, symbol_get_frag (lcomm_sym));
3134       S_SET_VALUE (sym, symbol_get_frag (lcomm_sym)->fr_offset);
3135       symbol_get_frag (lcomm_sym)->fr_offset += size;
3136     }
3137
3138   subseg_set (current_seg, current_subseg);
3139
3140   demand_empty_rest_of_line ();
3141 }
3142
3143 /* The .csect pseudo-op.  This switches us into a different
3144    subsegment.  The first argument is a symbol whose value is the
3145    start of the .csect.  In COFF, csect symbols get special aux
3146    entries defined by the x_csect field of union internal_auxent.  The
3147    optional second argument is the alignment (the default is 2).  */
3148
3149 static void
3150 ppc_csect (int ignore ATTRIBUTE_UNUSED)
3151 {
3152   char *name;
3153   char endc;
3154   symbolS *sym;
3155   offsetT align;
3156
3157   name = input_line_pointer;
3158   endc = get_symbol_end ();
3159
3160   sym = symbol_find_or_make (name);
3161
3162   *input_line_pointer = endc;
3163
3164   if (S_GET_NAME (sym)[0] == '\0')
3165     {
3166       /* An unnamed csect is assumed to be [PR].  */
3167       symbol_get_tc (sym)->class = XMC_PR;
3168     }
3169
3170   align = 2;
3171   if (*input_line_pointer == ',')
3172     {
3173       ++input_line_pointer;
3174       align = get_absolute_expression ();
3175     }
3176
3177   ppc_change_csect (sym, align);
3178
3179   demand_empty_rest_of_line ();
3180 }
3181
3182 /* Change to a different csect.  */
3183
3184 static void
3185 ppc_change_csect (symbolS *sym, offsetT align)
3186 {
3187   if (S_IS_DEFINED (sym))
3188     subseg_set (S_GET_SEGMENT (sym), symbol_get_tc (sym)->subseg);
3189   else
3190     {
3191       symbolS **list_ptr;
3192       int after_toc;
3193       int hold_chunksize;
3194       symbolS *list;
3195       int is_code;
3196       segT sec;
3197
3198       /* This is a new csect.  We need to look at the symbol class to
3199          figure out whether it should go in the text section or the
3200          data section.  */
3201       after_toc = 0;
3202       is_code = 0;
3203       switch (symbol_get_tc (sym)->class)
3204         {
3205         case XMC_PR:
3206         case XMC_RO:
3207         case XMC_DB:
3208         case XMC_GL:
3209         case XMC_XO:
3210         case XMC_SV:
3211         case XMC_TI:
3212         case XMC_TB:
3213           S_SET_SEGMENT (sym, text_section);
3214           symbol_get_tc (sym)->subseg = ppc_text_subsegment;
3215           ++ppc_text_subsegment;
3216           list_ptr = &ppc_text_csects;
3217           is_code = 1;
3218           break;
3219         case XMC_RW:
3220         case XMC_TC0:
3221         case XMC_TC:
3222         case XMC_DS:
3223         case XMC_UA:
3224         case XMC_BS:
3225         case XMC_UC:
3226           if (ppc_toc_csect != NULL
3227               && (symbol_get_tc (ppc_toc_csect)->subseg + 1
3228                   == ppc_data_subsegment))
3229             after_toc = 1;
3230           S_SET_SEGMENT (sym, data_section);
3231           symbol_get_tc (sym)->subseg = ppc_data_subsegment;
3232           ++ppc_data_subsegment;
3233           list_ptr = &ppc_data_csects;
3234           break;
3235         default:
3236           abort ();
3237         }
3238
3239       /* We set the obstack chunk size to a small value before
3240          changing subsegments, so that we don't use a lot of memory
3241          space for what may be a small section.  */
3242       hold_chunksize = chunksize;
3243       chunksize = 64;
3244
3245       sec = subseg_new (segment_name (S_GET_SEGMENT (sym)),
3246                         symbol_get_tc (sym)->subseg);
3247
3248       chunksize = hold_chunksize;
3249
3250       if (after_toc)
3251         ppc_after_toc_frag = frag_now;
3252
3253       record_alignment (sec, align);
3254       if (is_code)
3255         frag_align_code (align, 0);
3256       else
3257         frag_align (align, 0, 0);
3258
3259       symbol_set_frag (sym, frag_now);
3260       S_SET_VALUE (sym, (valueT) frag_now_fix ());
3261
3262       symbol_get_tc (sym)->align = align;
3263       symbol_get_tc (sym)->output = 1;
3264       symbol_get_tc (sym)->within = sym;
3265
3266       for (list = *list_ptr;
3267            symbol_get_tc (list)->next != (symbolS *) NULL;
3268            list = symbol_get_tc (list)->next)
3269         ;
3270       symbol_get_tc (list)->next = sym;
3271
3272       symbol_remove (sym, &symbol_rootP, &symbol_lastP);
3273       symbol_append (sym, symbol_get_tc (list)->within, &symbol_rootP,
3274                      &symbol_lastP);
3275     }
3276
3277   ppc_current_csect = sym;
3278 }
3279
3280 /* This function handles the .text and .data pseudo-ops.  These
3281    pseudo-ops aren't really used by XCOFF; we implement them for the
3282    convenience of people who aren't used to XCOFF.  */
3283
3284 static void
3285 ppc_section (int type)
3286 {
3287   const char *name;
3288   symbolS *sym;
3289
3290   if (type == 't')
3291     name = ".text[PR]";
3292   else if (type == 'd')
3293     name = ".data[RW]";
3294   else
3295     abort ();
3296
3297   sym = symbol_find_or_make (name);
3298
3299   ppc_change_csect (sym, 2);
3300
3301   demand_empty_rest_of_line ();
3302 }
3303
3304 /* This function handles the .section pseudo-op.  This is mostly to
3305    give an error, since XCOFF only supports .text, .data and .bss, but
3306    we do permit the user to name the text or data section.  */
3307
3308 static void
3309 ppc_named_section (int ignore ATTRIBUTE_UNUSED)
3310 {
3311   char *user_name;
3312   const char *real_name;
3313   char c;
3314   symbolS *sym;
3315
3316   user_name = input_line_pointer;
3317   c = get_symbol_end ();
3318
3319   if (strcmp (user_name, ".text") == 0)
3320     real_name = ".text[PR]";
3321   else if (strcmp (user_name, ".data") == 0)
3322     real_name = ".data[RW]";
3323   else
3324     {
3325       as_bad (_("The XCOFF file format does not support arbitrary sections"));
3326       *input_line_pointer = c;
3327       ignore_rest_of_line ();
3328       return;
3329     }
3330
3331   *input_line_pointer = c;
3332
3333   sym = symbol_find_or_make (real_name);
3334
3335   ppc_change_csect (sym, 2);
3336
3337   demand_empty_rest_of_line ();
3338 }
3339
3340 /* The .extern pseudo-op.  We create an undefined symbol.  */
3341
3342 static void
3343 ppc_extern (int ignore ATTRIBUTE_UNUSED)
3344 {
3345   char *name;
3346   char endc;
3347
3348   name = input_line_pointer;
3349   endc = get_symbol_end ();
3350
3351   (void) symbol_find_or_make (name);
3352
3353   *input_line_pointer = endc;
3354
3355   demand_empty_rest_of_line ();
3356 }
3357
3358 /* The .lglobl pseudo-op.  Keep the symbol in the symbol table.  */
3359
3360 static void
3361 ppc_lglobl (int ignore ATTRIBUTE_UNUSED)
3362 {
3363   char *name;
3364   char endc;
3365   symbolS *sym;
3366
3367   name = input_line_pointer;
3368   endc = get_symbol_end ();
3369
3370   sym = symbol_find_or_make (name);
3371
3372   *input_line_pointer = endc;
3373
3374   symbol_get_tc (sym)->output = 1;
3375
3376   demand_empty_rest_of_line ();
3377 }
3378
3379 /* The .rename pseudo-op.  The RS/6000 assembler can rename symbols,
3380    although I don't know why it bothers.  */
3381
3382 static void
3383 ppc_rename (int ignore ATTRIBUTE_UNUSED)
3384 {
3385   char *name;
3386   char endc;
3387   symbolS *sym;
3388   int len;
3389
3390   name = input_line_pointer;
3391   endc = get_symbol_end ();
3392
3393   sym = symbol_find_or_make (name);
3394
3395   *input_line_pointer = endc;
3396
3397   if (*input_line_pointer != ',')
3398     {
3399       as_bad (_("missing rename string"));
3400       ignore_rest_of_line ();
3401       return;
3402     }
3403   ++input_line_pointer;
3404
3405   symbol_get_tc (sym)->real_name = demand_copy_C_string (&len);
3406
3407   demand_empty_rest_of_line ();
3408 }
3409
3410 /* The .stabx pseudo-op.  This is similar to a normal .stabs
3411    pseudo-op, but slightly different.  A sample is
3412        .stabx "main:F-1",.main,142,0
3413    The first argument is the symbol name to create.  The second is the
3414    value, and the third is the storage class.  The fourth seems to be
3415    always zero, and I am assuming it is the type.  */
3416
3417 static void
3418 ppc_stabx (int ignore ATTRIBUTE_UNUSED)
3419 {
3420   char *name;
3421   int len;
3422   symbolS *sym;
3423   expressionS exp;
3424
3425   name = demand_copy_C_string (&len);
3426
3427   if (*input_line_pointer != ',')
3428     {
3429       as_bad (_("missing value"));
3430       return;
3431     }
3432   ++input_line_pointer;
3433
3434   ppc_stab_symbol = TRUE;
3435   sym = symbol_make (name);
3436   ppc_stab_symbol = FALSE;
3437
3438   symbol_get_tc (sym)->real_name = name;
3439
3440   (void) expression (&exp);
3441
3442   switch (exp.X_op)
3443     {
3444     case O_illegal:
3445     case O_absent:
3446     case O_big:
3447       as_bad (_("illegal .stabx expression; zero assumed"));
3448       exp.X_add_number = 0;
3449       /* Fall through.  */
3450     case O_constant:
3451       S_SET_VALUE (sym, (valueT) exp.X_add_number);
3452       symbol_set_frag (sym, &zero_address_frag);
3453       break;
3454
3455     case O_symbol:
3456       if (S_GET_SEGMENT (exp.X_add_symbol) == undefined_section)
3457         symbol_set_value_expression (sym, &exp);
3458       else
3459         {
3460           S_SET_VALUE (sym,
3461                        exp.X_add_number + S_GET_VALUE (exp.X_add_symbol));
3462           symbol_set_frag (sym, symbol_get_frag (exp.X_add_symbol));
3463         }
3464       break;
3465
3466     default:
3467       /* The value is some complex expression.  This will probably
3468          fail at some later point, but this is probably the right
3469          thing to do here.  */
3470       symbol_set_value_expression (sym, &exp);
3471       break;
3472     }
3473
3474   S_SET_SEGMENT (sym, ppc_coff_debug_section);
3475   symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
3476
3477   if (*input_line_pointer != ',')
3478     {
3479       as_bad (_("missing class"));
3480       return;
3481     }
3482   ++input_line_pointer;
3483
3484   S_SET_STORAGE_CLASS (sym, get_absolute_expression ());
3485
3486   if (*input_line_pointer != ',')
3487     {
3488       as_bad (_("missing type"));
3489       return;
3490     }
3491   ++input_line_pointer;
3492
3493   S_SET_DATA_TYPE (sym, get_absolute_expression ());
3494
3495   symbol_get_tc (sym)->output = 1;
3496
3497   if (S_GET_STORAGE_CLASS (sym) == C_STSYM) {
3498
3499     symbol_get_tc (sym)->within = ppc_current_block;
3500
3501     /* In this case :
3502
3503        .bs name
3504        .stabx   "z",arrays_,133,0
3505        .es
3506
3507        .comm arrays_,13768,3
3508
3509        resolve_symbol_value will copy the exp's "within" into sym's when the
3510        offset is 0.  Since this seems to be corner case problem,
3511        only do the correction for storage class C_STSYM.  A better solution
3512        would be to have the tc field updated in ppc_symbol_new_hook.  */
3513
3514     if (exp.X_op == O_symbol)
3515       {
3516         symbol_get_tc (exp.X_add_symbol)->within = ppc_current_block;
3517       }
3518   }
3519
3520   if (exp.X_op != O_symbol
3521       || ! S_IS_EXTERNAL (exp.X_add_symbol)
3522       || S_GET_SEGMENT (exp.X_add_symbol) != bss_section)
3523     ppc_frob_label (sym);
3524   else
3525     {
3526       symbol_remove (sym, &symbol_rootP, &symbol_lastP);
3527       symbol_append (sym, exp.X_add_symbol, &symbol_rootP, &symbol_lastP);
3528       if (symbol_get_tc (ppc_current_csect)->within == exp.X_add_symbol)
3529         symbol_get_tc (ppc_current_csect)->within = sym;
3530     }
3531
3532   demand_empty_rest_of_line ();
3533 }
3534
3535 /* The .function pseudo-op.  This takes several arguments.  The first
3536    argument seems to be the external name of the symbol.  The second
3537    argument seems to be the label for the start of the function.  gcc
3538    uses the same name for both.  I have no idea what the third and
3539    fourth arguments are meant to be.  The optional fifth argument is
3540    an expression for the size of the function.  In COFF this symbol
3541    gets an aux entry like that used for a csect.  */
3542
3543 static void
3544 ppc_function (int ignore ATTRIBUTE_UNUSED)
3545 {
3546   char *name;
3547   char endc;
3548   char *s;
3549   symbolS *ext_sym;
3550   symbolS *lab_sym;
3551
3552   name = input_line_pointer;
3553   endc = get_symbol_end ();
3554
3555   /* Ignore any [PR] suffix.  */
3556   name = ppc_canonicalize_symbol_name (name);
3557   s = strchr (name, '[');
3558   if (s != (char *) NULL
3559       && strcmp (s + 1, "PR]") == 0)
3560     *s = '\0';
3561
3562   ext_sym = symbol_find_or_make (name);
3563
3564   *input_line_pointer = endc;
3565
3566   if (*input_line_pointer != ',')
3567     {
3568       as_bad (_("missing symbol name"));
3569       ignore_rest_of_line ();
3570       return;
3571     }
3572   ++input_line_pointer;
3573
3574   name = input_line_pointer;
3575   endc = get_symbol_end ();
3576
3577   lab_sym = symbol_find_or_make (name);
3578
3579   *input_line_pointer = endc;
3580
3581   if (ext_sym != lab_sym)
3582     {
3583       expressionS exp;
3584
3585       exp.X_op = O_symbol;
3586       exp.X_add_symbol = lab_sym;
3587       exp.X_op_symbol = NULL;
3588       exp.X_add_number = 0;
3589       exp.X_unsigned = 0;
3590       symbol_set_value_expression (ext_sym, &exp);
3591     }
3592
3593   if (symbol_get_tc (ext_sym)->class == -1)
3594     symbol_get_tc (ext_sym)->class = XMC_PR;
3595   symbol_get_tc (ext_sym)->output = 1;
3596
3597   if (*input_line_pointer == ',')
3598     {
3599       expressionS ignore;
3600
3601       /* Ignore the third argument.  */
3602       ++input_line_pointer;
3603       expression (&ignore);
3604       if (*input_line_pointer == ',')
3605         {
3606           /* Ignore the fourth argument.  */
3607           ++input_line_pointer;
3608           expression (&ignore);
3609           if (*input_line_pointer == ',')
3610             {
3611               /* The fifth argument is the function size.  */
3612               ++input_line_pointer;
3613               symbol_get_tc (ext_sym)->size = symbol_new ("L0\001",
3614                                                           absolute_section,
3615                                                           (valueT) 0,
3616                                                           &zero_address_frag);
3617               pseudo_set (symbol_get_tc (ext_sym)->size);
3618             }
3619         }
3620     }
3621
3622   S_SET_DATA_TYPE (ext_sym, DT_FCN << N_BTSHFT);
3623   SF_SET_FUNCTION (ext_sym);
3624   SF_SET_PROCESS (ext_sym);
3625   coff_add_linesym (ext_sym);
3626
3627   demand_empty_rest_of_line ();
3628 }
3629
3630 /* The .bf pseudo-op.  This is just like a COFF C_FCN symbol named
3631    ".bf".  If the pseudo op .bi was seen before .bf, patch the .bi sym
3632    with the correct line number */
3633
3634 static symbolS *saved_bi_sym = 0;
3635
3636 static void
3637 ppc_bf (int ignore ATTRIBUTE_UNUSED)
3638 {
3639   symbolS *sym;
3640
3641   sym = symbol_make (".bf");
3642   S_SET_SEGMENT (sym, text_section);
3643   symbol_set_frag (sym, frag_now);
3644   S_SET_VALUE (sym, frag_now_fix ());
3645   S_SET_STORAGE_CLASS (sym, C_FCN);
3646
3647   coff_line_base = get_absolute_expression ();
3648
3649   S_SET_NUMBER_AUXILIARY (sym, 1);
3650   SA_SET_SYM_LNNO (sym, coff_line_base);
3651
3652   /* Line number for bi.  */
3653   if (saved_bi_sym)
3654     {
3655       S_SET_VALUE (saved_bi_sym, coff_n_line_nos);
3656       saved_bi_sym = 0;
3657     }
3658
3659
3660   symbol_get_tc (sym)->output = 1;
3661
3662   ppc_frob_label (sym);
3663
3664   demand_empty_rest_of_line ();
3665 }
3666
3667 /* The .ef pseudo-op.  This is just like a COFF C_FCN symbol named
3668    ".ef", except that the line number is absolute, not relative to the
3669    most recent ".bf" symbol.  */
3670
3671 static void
3672 ppc_ef (int ignore ATTRIBUTE_UNUSED)
3673 {
3674   symbolS *sym;
3675
3676   sym = symbol_make (".ef");
3677   S_SET_SEGMENT (sym, text_section);
3678   symbol_set_frag (sym, frag_now);
3679   S_SET_VALUE (sym, frag_now_fix ());
3680   S_SET_STORAGE_CLASS (sym, C_FCN);
3681   S_SET_NUMBER_AUXILIARY (sym, 1);
3682   SA_SET_SYM_LNNO (sym, get_absolute_expression ());
3683   symbol_get_tc (sym)->output = 1;
3684
3685   ppc_frob_label (sym);
3686
3687   demand_empty_rest_of_line ();
3688 }
3689
3690 /* The .bi and .ei pseudo-ops.  These take a string argument and
3691    generates a C_BINCL or C_EINCL symbol, which goes at the start of
3692    the symbol list.  The value of .bi will be know when the next .bf
3693    is encountered.  */
3694
3695 static void
3696 ppc_biei (int ei)
3697 {
3698   static symbolS *last_biei;
3699
3700   char *name;
3701   int len;
3702   symbolS *sym;
3703   symbolS *look;
3704
3705   name = demand_copy_C_string (&len);
3706
3707   /* The value of these symbols is actually file offset.  Here we set
3708      the value to the index into the line number entries.  In
3709      ppc_frob_symbols we set the fix_line field, which will cause BFD
3710      to do the right thing.  */
3711
3712   sym = symbol_make (name);
3713   /* obj-coff.c currently only handles line numbers correctly in the
3714      .text section.  */
3715   S_SET_SEGMENT (sym, text_section);
3716   S_SET_VALUE (sym, coff_n_line_nos);
3717   symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
3718
3719   S_SET_STORAGE_CLASS (sym, ei ? C_EINCL : C_BINCL);
3720   symbol_get_tc (sym)->output = 1;
3721
3722   /* Save bi.  */
3723   if (ei)
3724     saved_bi_sym = 0;
3725   else
3726     saved_bi_sym = sym;
3727
3728   for (look = last_biei ? last_biei : symbol_rootP;
3729        (look != (symbolS *) NULL
3730         && (S_GET_STORAGE_CLASS (look) == C_FILE
3731             || S_GET_STORAGE_CLASS (look) == C_BINCL
3732             || S_GET_STORAGE_CLASS (look) == C_EINCL));
3733        look = symbol_next (look))
3734     ;
3735   if (look != (symbolS *) NULL)
3736     {
3737       symbol_remove (sym, &symbol_rootP, &symbol_lastP);
3738       symbol_insert (sym, look, &symbol_rootP, &symbol_lastP);
3739       last_biei = sym;
3740     }
3741
3742   demand_empty_rest_of_line ();
3743 }
3744
3745 /* The .bs pseudo-op.  This generates a C_BSTAT symbol named ".bs".
3746    There is one argument, which is a csect symbol.  The value of the
3747    .bs symbol is the index of this csect symbol.  */
3748
3749 static void
3750 ppc_bs (int ignore ATTRIBUTE_UNUSED)
3751 {
3752   char *name;
3753   char endc;
3754   symbolS *csect;
3755   symbolS *sym;
3756
3757   if (ppc_current_block != NULL)
3758     as_bad (_("nested .bs blocks"));
3759
3760   name = input_line_pointer;
3761   endc = get_symbol_end ();
3762
3763   csect = symbol_find_or_make (name);
3764
3765   *input_line_pointer = endc;
3766
3767   sym = symbol_make (".bs");
3768   S_SET_SEGMENT (sym, now_seg);
3769   S_SET_STORAGE_CLASS (sym, C_BSTAT);
3770   symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
3771   symbol_get_tc (sym)->output = 1;
3772
3773   symbol_get_tc (sym)->within = csect;
3774
3775   ppc_frob_label (sym);
3776
3777   ppc_current_block = sym;
3778
3779   demand_empty_rest_of_line ();
3780 }
3781
3782 /* The .es pseudo-op.  Generate a C_ESTART symbol named .es.  */
3783
3784 static void
3785 ppc_es (int ignore ATTRIBUTE_UNUSED)
3786 {
3787   symbolS *sym;
3788
3789   if (ppc_current_block == NULL)
3790     as_bad (_(".es without preceding .bs"));
3791
3792   sym = symbol_make (".es");
3793   S_SET_SEGMENT (sym, now_seg);
3794   S_SET_STORAGE_CLASS (sym, C_ESTAT);
3795   symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
3796   symbol_get_tc (sym)->output = 1;
3797
3798   ppc_frob_label (sym);
3799
3800   ppc_current_block = NULL;
3801
3802   demand_empty_rest_of_line ();
3803 }
3804
3805 /* The .bb pseudo-op.  Generate a C_BLOCK symbol named .bb, with a
3806    line number.  */
3807
3808 static void
3809 ppc_bb (int ignore ATTRIBUTE_UNUSED)
3810 {
3811   symbolS *sym;
3812
3813   sym = symbol_make (".bb");
3814   S_SET_SEGMENT (sym, text_section);
3815   symbol_set_frag (sym, frag_now);
3816   S_SET_VALUE (sym, frag_now_fix ());
3817   S_SET_STORAGE_CLASS (sym, C_BLOCK);
3818
3819   S_SET_NUMBER_AUXILIARY (sym, 1);
3820   SA_SET_SYM_LNNO (sym, get_absolute_expression ());
3821
3822   symbol_get_tc (sym)->output = 1;
3823
3824   SF_SET_PROCESS (sym);
3825
3826   ppc_frob_label (sym);
3827
3828   demand_empty_rest_of_line ();
3829 }
3830
3831 /* The .eb pseudo-op.  Generate a C_BLOCK symbol named .eb, with a
3832    line number.  */
3833
3834 static void
3835 ppc_eb (int ignore ATTRIBUTE_UNUSED)
3836 {
3837   symbolS *sym;
3838
3839   sym = symbol_make (".eb");
3840   S_SET_SEGMENT (sym, text_section);
3841   symbol_set_frag (sym, frag_now);
3842   S_SET_VALUE (sym, frag_now_fix ());
3843   S_SET_STORAGE_CLASS (sym, C_BLOCK);
3844   S_SET_NUMBER_AUXILIARY (sym, 1);
3845   SA_SET_SYM_LNNO (sym, get_absolute_expression ());
3846   symbol_get_tc (sym)->output = 1;
3847
3848   SF_SET_PROCESS (sym);
3849
3850   ppc_frob_label (sym);
3851
3852   demand_empty_rest_of_line ();
3853 }
3854
3855 /* The .bc pseudo-op.  This just creates a C_BCOMM symbol with a
3856    specified name.  */
3857
3858 static void
3859 ppc_bc (int ignore ATTRIBUTE_UNUSED)
3860 {
3861   char *name;
3862   int len;
3863   symbolS *sym;
3864
3865   name = demand_copy_C_string (&len);
3866   sym = symbol_make (name);
3867   S_SET_SEGMENT (sym, ppc_coff_debug_section);
3868   symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
3869   S_SET_STORAGE_CLASS (sym, C_BCOMM);
3870   S_SET_VALUE (sym, 0);
3871   symbol_get_tc (sym)->output = 1;
3872
3873   ppc_frob_label (sym);
3874
3875   demand_empty_rest_of_line ();
3876 }
3877
3878 /* The .ec pseudo-op.  This just creates a C_ECOMM symbol.  */
3879
3880 static void
3881 ppc_ec (int ignore ATTRIBUTE_UNUSED)
3882 {
3883   symbolS *sym;
3884
3885   sym = symbol_make (".ec");
3886   S_SET_SEGMENT (sym, ppc_coff_debug_section);
3887   symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
3888   S_SET_STORAGE_CLASS (sym, C_ECOMM);
3889   S_SET_VALUE (sym, 0);
3890   symbol_get_tc (sym)->output = 1;
3891
3892   ppc_frob_label (sym);
3893
3894   demand_empty_rest_of_line ();
3895 }
3896
3897 /* The .toc pseudo-op.  Switch to the .toc subsegment.  */
3898
3899 static void
3900 ppc_toc (int ignore ATTRIBUTE_UNUSED)
3901 {
3902   if (ppc_toc_csect != (symbolS *) NULL)
3903     subseg_set (data_section, symbol_get_tc (ppc_toc_csect)->subseg);
3904   else
3905     {
3906       subsegT subseg;
3907       symbolS *sym;
3908       symbolS *list;
3909
3910       subseg = ppc_data_subsegment;
3911       ++ppc_data_subsegment;
3912
3913       subseg_new (segment_name (data_section), subseg);
3914       ppc_toc_frag = frag_now;
3915
3916       sym = symbol_find_or_make ("TOC[TC0]");
3917       symbol_set_frag (sym, frag_now);
3918       S_SET_SEGMENT (sym, data_section);
3919       S_SET_VALUE (sym, (valueT) frag_now_fix ());
3920       symbol_get_tc (sym)->subseg = subseg;
3921       symbol_get_tc (sym)->output = 1;
3922       symbol_get_tc (sym)->within = sym;
3923
3924       ppc_toc_csect = sym;
3925
3926       for (list = ppc_data_csects;
3927            symbol_get_tc (list)->next != (symbolS *) NULL;
3928            list = symbol_get_tc (list)->next)
3929         ;
3930       symbol_get_tc (list)->next = sym;
3931
3932       symbol_remove (sym, &symbol_rootP, &symbol_lastP);
3933       symbol_append (sym, symbol_get_tc (list)->within, &symbol_rootP,
3934                      &symbol_lastP);
3935     }
3936
3937   ppc_current_csect = ppc_toc_csect;
3938
3939   demand_empty_rest_of_line ();
3940 }
3941
3942 /* The AIX assembler automatically aligns the operands of a .long or
3943    .short pseudo-op, and we want to be compatible.  */
3944
3945 static void
3946 ppc_xcoff_cons (int log_size)
3947 {
3948   frag_align (log_size, 0, 0);
3949   record_alignment (now_seg, log_size);
3950   cons (1 << log_size);
3951 }
3952
3953 static void
3954 ppc_vbyte (int dummy ATTRIBUTE_UNUSED)
3955 {
3956   expressionS exp;
3957   int byte_count;
3958
3959   (void) expression (&exp);
3960
3961   if (exp.X_op != O_constant)
3962     {
3963       as_bad (_("non-constant byte count"));
3964       return;
3965     }
3966
3967   byte_count = exp.X_add_number;
3968
3969   if (*input_line_pointer != ',')
3970     {
3971       as_bad (_("missing value"));
3972       return;
3973     }
3974
3975   ++input_line_pointer;
3976   cons (byte_count);
3977 }
3978
3979 #endif /* OBJ_XCOFF */
3980 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
3981 \f
3982 /* The .tc pseudo-op.  This is used when generating either XCOFF or
3983    ELF.  This takes two or more arguments.
3984
3985    When generating XCOFF output, the first argument is the name to
3986    give to this location in the toc; this will be a symbol with class
3987    TC.  The rest of the arguments are N-byte values to actually put at
3988    this location in the TOC; often there is just one more argument, a
3989    relocatable symbol reference.  The size of the value to store
3990    depends on target word size.  A 32-bit target uses 4-byte values, a
3991    64-bit target uses 8-byte values.
3992
3993    When not generating XCOFF output, the arguments are the same, but
3994    the first argument is simply ignored.  */
3995
3996 static void
3997 ppc_tc (int ignore ATTRIBUTE_UNUSED)
3998 {
3999 #ifdef OBJ_XCOFF
4000
4001   /* Define the TOC symbol name.  */
4002   {
4003     char *name;
4004     char endc;
4005     symbolS *sym;
4006
4007     if (ppc_toc_csect == (symbolS *) NULL
4008         || ppc_toc_csect != ppc_current_csect)
4009       {
4010         as_bad (_(".tc not in .toc section"));
4011         ignore_rest_of_line ();
4012         return;
4013       }
4014
4015     name = input_line_pointer;
4016     endc = get_symbol_end ();
4017
4018     sym = symbol_find_or_make (name);
4019
4020     *input_line_pointer = endc;
4021
4022     if (S_IS_DEFINED (sym))
4023       {
4024         symbolS *label;
4025
4026         label = symbol_get_tc (ppc_current_csect)->within;
4027         if (symbol_get_tc (label)->class != XMC_TC0)
4028           {
4029             as_bad (_(".tc with no label"));
4030             ignore_rest_of_line ();
4031             return;
4032           }
4033
4034         S_SET_SEGMENT (label, S_GET_SEGMENT (sym));
4035         symbol_set_frag (label, symbol_get_frag (sym));
4036         S_SET_VALUE (label, S_GET_VALUE (sym));
4037
4038         while (! is_end_of_line[(unsigned char) *input_line_pointer])
4039           ++input_line_pointer;
4040
4041         return;
4042       }
4043
4044     S_SET_SEGMENT (sym, now_seg);
4045     symbol_set_frag (sym, frag_now);
4046     S_SET_VALUE (sym, (valueT) frag_now_fix ());
4047     symbol_get_tc (sym)->class = XMC_TC;
4048     symbol_get_tc (sym)->output = 1;
4049
4050     ppc_frob_label (sym);
4051   }
4052
4053 #endif /* OBJ_XCOFF */
4054 #ifdef OBJ_ELF
4055   int align;
4056
4057   /* Skip the TOC symbol name.  */
4058   while (is_part_of_name (*input_line_pointer)
4059          || *input_line_pointer == '['
4060          || *input_line_pointer == ']'
4061          || *input_line_pointer == '{'
4062          || *input_line_pointer == '}')
4063     ++input_line_pointer;
4064
4065   /* Align to a four/eight byte boundary.  */
4066   align = ppc_obj64 ? 3 : 2;
4067   frag_align (align, 0, 0);
4068   record_alignment (now_seg, align);
4069 #endif /* OBJ_ELF */
4070
4071   if (*input_line_pointer != ',')
4072     demand_empty_rest_of_line ();
4073   else
4074     {
4075       ++input_line_pointer;
4076       cons (ppc_obj64 ? 8 : 4);
4077     }
4078 }
4079
4080 /* Pseudo-op .machine.  */
4081
4082 static void
4083 ppc_machine (int ignore ATTRIBUTE_UNUSED)
4084 {
4085   char *cpu_string;
4086 #define MAX_HISTORY 100
4087   static unsigned long *cpu_history;
4088   static int curr_hist;
4089
4090   SKIP_WHITESPACE ();
4091
4092   if (*input_line_pointer == '"')
4093     {
4094       int len;
4095       cpu_string = demand_copy_C_string (&len);
4096     }
4097   else
4098     {
4099       char c;
4100       cpu_string = input_line_pointer;
4101       c = get_symbol_end ();
4102       cpu_string = xstrdup (cpu_string);
4103       *input_line_pointer = c;
4104     }
4105
4106   if (cpu_string != NULL)
4107     {
4108       unsigned long old_cpu = ppc_cpu;
4109       char *p;
4110
4111       for (p = cpu_string; *p != 0; p++)
4112         *p = TOLOWER (*p);
4113
4114       if (strcmp (cpu_string, "push") == 0)
4115         {
4116           if (cpu_history == NULL)
4117             cpu_history = xmalloc (MAX_HISTORY * sizeof (*cpu_history));
4118
4119           if (curr_hist >= MAX_HISTORY)
4120             as_bad (_(".machine stack overflow"));
4121           else
4122             cpu_history[curr_hist++] = ppc_cpu;
4123         }
4124       else if (strcmp (cpu_string, "pop") == 0)
4125         {
4126           if (curr_hist <= 0)
4127             as_bad (_(".machine stack underflow"));
4128           else
4129             ppc_cpu = cpu_history[--curr_hist];
4130         }
4131       else if (parse_cpu (cpu_string))
4132         ;
4133       else
4134         as_bad (_("invalid machine `%s'"), cpu_string);
4135
4136       if (ppc_cpu != old_cpu)
4137         ppc_setup_opcodes ();
4138     }
4139
4140   demand_empty_rest_of_line ();
4141 }
4142
4143 /* See whether a symbol is in the TOC section.  */
4144
4145 static int
4146 ppc_is_toc_sym (symbolS *sym)
4147 {
4148 #ifdef OBJ_XCOFF
4149   return symbol_get_tc (sym)->class == XMC_TC;
4150 #endif
4151 #ifdef OBJ_ELF
4152   const char *sname = segment_name (S_GET_SEGMENT (sym));
4153   if (ppc_obj64)
4154     return strcmp (sname, ".toc") == 0;
4155   else
4156     return strcmp (sname, ".got") == 0;
4157 #endif
4158 }
4159 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
4160 \f
4161 #ifdef TE_PE
4162
4163 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format.  */
4164
4165 /* Set the current section.  */
4166 static void
4167 ppc_set_current_section (segT new)
4168 {
4169   ppc_previous_section = ppc_current_section;
4170   ppc_current_section = new;
4171 }
4172
4173 /* pseudo-op: .previous
4174    behaviour: toggles the current section with the previous section.
4175    errors:    None
4176    warnings:  "No previous section"  */
4177
4178 static void
4179 ppc_previous (int ignore ATTRIBUTE_UNUSED)
4180 {
4181   symbolS *tmp;
4182
4183   if (ppc_previous_section == NULL)
4184     {
4185       as_warn (_("No previous section to return to. Directive ignored."));
4186       return;
4187     }
4188
4189   subseg_set (ppc_previous_section, 0);
4190
4191   ppc_set_current_section (ppc_previous_section);
4192 }
4193
4194 /* pseudo-op: .pdata
4195    behaviour: predefined read only data section
4196               double word aligned
4197    errors:    None
4198    warnings:  None
4199    initial:   .section .pdata "adr3"
4200               a - don't know -- maybe a misprint
4201               d - initialized data
4202               r - readable
4203               3 - double word aligned (that would be 4 byte boundary)
4204
4205    commentary:
4206    Tag index tables (also known as the function table) for exception
4207    handling, debugging, etc.  */
4208
4209 static void
4210 ppc_pdata (int ignore ATTRIBUTE_UNUSED)
4211 {
4212   if (pdata_section == 0)
4213     {
4214       pdata_section = subseg_new (".pdata", 0);
4215
4216       bfd_set_section_flags (stdoutput, pdata_section,
4217                              (SEC_ALLOC | SEC_LOAD | SEC_RELOC
4218                               | SEC_READONLY | SEC_DATA ));
4219
4220       bfd_set_section_alignment (stdoutput, pdata_section, 2);
4221     }
4222   else
4223     {
4224       pdata_section = subseg_new (".pdata", 0);
4225     }
4226   ppc_set_current_section (pdata_section);
4227 }
4228
4229 /* pseudo-op: .ydata
4230    behaviour: predefined read only data section
4231               double word aligned
4232    errors:    None
4233    warnings:  None
4234    initial:   .section .ydata "drw3"
4235               a - don't know -- maybe a misprint
4236               d - initialized data
4237               r - readable
4238               3 - double word aligned (that would be 4 byte boundary)
4239    commentary:
4240    Tag tables (also known as the scope table) for exception handling,
4241    debugging, etc.  */
4242
4243 static void
4244 ppc_ydata (int ignore ATTRIBUTE_UNUSED)
4245 {
4246   if (ydata_section == 0)
4247     {
4248       ydata_section = subseg_new (".ydata", 0);
4249       bfd_set_section_flags (stdoutput, ydata_section,
4250                              (SEC_ALLOC | SEC_LOAD | SEC_RELOC
4251                               | SEC_READONLY | SEC_DATA ));
4252
4253       bfd_set_section_alignment (stdoutput, ydata_section, 3);
4254     }
4255   else
4256     {
4257       ydata_section = subseg_new (".ydata", 0);
4258     }
4259   ppc_set_current_section (ydata_section);
4260 }
4261
4262 /* pseudo-op: .reldata
4263    behaviour: predefined read write data section
4264               double word aligned (4-byte)
4265               FIXME: relocation is applied to it
4266               FIXME: what's the difference between this and .data?
4267    errors:    None
4268    warnings:  None
4269    initial:   .section .reldata "drw3"
4270               d - initialized data
4271               r - readable
4272               w - writeable
4273               3 - double word aligned (that would be 8 byte boundary)
4274
4275    commentary:
4276    Like .data, but intended to hold data subject to relocation, such as
4277    function descriptors, etc.  */
4278
4279 static void
4280 ppc_reldata (int ignore ATTRIBUTE_UNUSED)
4281 {
4282   if (reldata_section == 0)
4283     {
4284       reldata_section = subseg_new (".reldata", 0);
4285
4286       bfd_set_section_flags (stdoutput, reldata_section,
4287                              (SEC_ALLOC | SEC_LOAD | SEC_RELOC
4288                               | SEC_DATA));
4289
4290       bfd_set_section_alignment (stdoutput, reldata_section, 2);
4291     }
4292   else
4293     {
4294       reldata_section = subseg_new (".reldata", 0);
4295     }
4296   ppc_set_current_section (reldata_section);
4297 }
4298
4299 /* pseudo-op: .rdata
4300    behaviour: predefined read only data section
4301               double word aligned
4302    errors:    None
4303    warnings:  None
4304    initial:   .section .rdata "dr3"
4305               d - initialized data
4306               r - readable
4307               3 - double word aligned (that would be 4 byte boundary)  */
4308
4309 static void
4310 ppc_rdata (int ignore ATTRIBUTE_UNUSED)
4311 {
4312   if (rdata_section == 0)
4313     {
4314       rdata_section = subseg_new (".rdata", 0);
4315       bfd_set_section_flags (stdoutput, rdata_section,
4316                              (SEC_ALLOC | SEC_LOAD | SEC_RELOC
4317                               | SEC_READONLY | SEC_DATA ));
4318
4319       bfd_set_section_alignment (stdoutput, rdata_section, 2);
4320     }
4321   else
4322     {
4323       rdata_section = subseg_new (".rdata", 0);
4324     }
4325   ppc_set_current_section (rdata_section);
4326 }
4327
4328 /* pseudo-op: .ualong
4329    behaviour: much like .int, with the exception that no alignment is
4330               performed.
4331               FIXME: test the alignment statement
4332    errors:    None
4333    warnings:  None  */
4334
4335 static void
4336 ppc_ualong (int ignore ATTRIBUTE_UNUSED)
4337 {
4338   /* Try for long.  */
4339   cons (4);
4340 }
4341
4342 /* pseudo-op: .znop  <symbol name>
4343    behaviour: Issue a nop instruction
4344               Issue a IMAGE_REL_PPC_IFGLUE relocation against it, using
4345               the supplied symbol name.
4346    errors:    None
4347    warnings:  Missing symbol name  */
4348
4349 static void
4350 ppc_znop (int ignore ATTRIBUTE_UNUSED)
4351 {
4352   unsigned long insn;
4353   const struct powerpc_opcode *opcode;
4354   expressionS ex;
4355   char *f;
4356   symbolS *sym;
4357   char *symbol_name;
4358   char c;
4359   char *name;
4360   unsigned int exp;
4361   flagword flags;
4362   asection *sec;
4363
4364   /* Strip out the symbol name.  */
4365   symbol_name = input_line_pointer;
4366   c = get_symbol_end ();
4367
4368   name = xmalloc (input_line_pointer - symbol_name + 1);
4369   strcpy (name, symbol_name);
4370
4371   sym = symbol_find_or_make (name);
4372
4373   *input_line_pointer = c;
4374
4375   SKIP_WHITESPACE ();
4376
4377   /* Look up the opcode in the hash table.  */
4378   opcode = (const struct powerpc_opcode *) hash_find (ppc_hash, "nop");
4379
4380   /* Stick in the nop.  */
4381   insn = opcode->opcode;
4382
4383   /* Write out the instruction.  */
4384   f = frag_more (4);
4385   md_number_to_chars (f, insn, 4);
4386   fix_new (frag_now,
4387            f - frag_now->fr_literal,
4388            4,
4389            sym,
4390            0,
4391            0,
4392            BFD_RELOC_16_GOT_PCREL);
4393
4394 }
4395
4396 /* pseudo-op:
4397    behaviour:
4398    errors:
4399    warnings:  */
4400
4401 static void
4402 ppc_pe_comm (int lcomm)
4403 {
4404   char *name;
4405   char c;
4406   char *p;
4407   offsetT temp;
4408   symbolS *symbolP;
4409   offsetT align;
4410
4411   name = input_line_pointer;
4412   c = get_symbol_end ();
4413
4414   /* just after name is now '\0'.  */
4415   p = input_line_pointer;
4416   *p = c;
4417   SKIP_WHITESPACE ();
4418   if (*input_line_pointer != ',')
4419     {
4420       as_bad (_("Expected comma after symbol-name: rest of line ignored."));
4421       ignore_rest_of_line ();
4422       return;
4423     }
4424
4425   input_line_pointer++;         /* skip ',' */
4426   if ((temp = get_absolute_expression ()) < 0)
4427     {
4428       as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) temp);
4429       ignore_rest_of_line ();
4430       return;
4431     }
4432
4433   if (! lcomm)
4434     {
4435       /* The third argument to .comm is the alignment.  */
4436       if (*input_line_pointer != ',')
4437         align = 3;
4438       else
4439         {
4440           ++input_line_pointer;
4441           align = get_absolute_expression ();
4442           if (align <= 0)
4443             {
4444               as_warn (_("ignoring bad alignment"));
4445               align = 3;
4446             }
4447         }
4448     }
4449
4450   *p = 0;
4451   symbolP = symbol_find_or_make (name);
4452
4453   *p = c;
4454   if (S_IS_DEFINED (symbolP) && ! S_IS_COMMON (symbolP))
4455     {
4456       as_bad (_("Ignoring attempt to re-define symbol `%s'."),
4457               S_GET_NAME (symbolP));
4458       ignore_rest_of_line ();
4459       return;
4460     }
4461
4462   if (S_GET_VALUE (symbolP))
4463     {
4464       if (S_GET_VALUE (symbolP) != (valueT) temp)
4465         as_bad (_("Length of .comm \"%s\" is already %ld. Not changed to %ld."),
4466                 S_GET_NAME (symbolP),
4467                 (long) S_GET_VALUE (symbolP),
4468                 (long) temp);
4469     }
4470   else
4471     {
4472       S_SET_VALUE (symbolP, (valueT) temp);
4473       S_SET_EXTERNAL (symbolP);
4474       S_SET_SEGMENT (symbolP, bfd_com_section_ptr);
4475     }
4476
4477   demand_empty_rest_of_line ();
4478 }
4479
4480 /*
4481  * implement the .section pseudo op:
4482  *      .section name {, "flags"}
4483  *                ^         ^
4484  *                |         +--- optional flags: 'b' for bss
4485  *                |                              'i' for info
4486  *                +-- section name               'l' for lib
4487  *                                               'n' for noload
4488  *                                               'o' for over
4489  *                                               'w' for data
4490  *                                               'd' (apparently m88k for data)
4491  *                                               'x' for text
4492  * But if the argument is not a quoted string, treat it as a
4493  * subsegment number.
4494  *
4495  * FIXME: this is a copy of the section processing from obj-coff.c, with
4496  * additions/changes for the moto-pas assembler support. There are three
4497  * categories:
4498  *
4499  * FIXME: I just noticed this. This doesn't work at all really. It it
4500  *        setting bits that bfd probably neither understands or uses. The
4501  *        correct approach (?) will have to incorporate extra fields attached
4502  *        to the section to hold the system specific stuff. (krk)
4503  *
4504  * Section Contents:
4505  * 'a' - unknown - referred to in documentation, but no definition supplied
4506  * 'c' - section has code
4507  * 'd' - section has initialized data
4508  * 'u' - section has uninitialized data
4509  * 'i' - section contains directives (info)
4510  * 'n' - section can be discarded
4511  * 'R' - remove section at link time
4512  *
4513  * Section Protection:
4514  * 'r' - section is readable
4515  * 'w' - section is writeable
4516  * 'x' - section is executable
4517  * 's' - section is sharable
4518  *
4519  * Section Alignment:
4520  * '0' - align to byte boundary
4521  * '1' - align to halfword undary
4522  * '2' - align to word boundary
4523  * '3' - align to doubleword boundary
4524  * '4' - align to quadword boundary
4525  * '5' - align to 32 byte boundary
4526  * '6' - align to 64 byte boundary
4527  *
4528  */
4529
4530 void
4531 ppc_pe_section (int ignore ATTRIBUTE_UNUSED)
4532 {
4533   /* Strip out the section name.  */
4534   char *section_name;
4535   char c;
4536   char *name;
4537   unsigned int exp;
4538   flagword flags;
4539   segT sec;
4540   int align;
4541
4542   section_name = input_line_pointer;
4543   c = get_symbol_end ();
4544
4545   name = xmalloc (input_line_pointer - section_name + 1);
4546   strcpy (name, section_name);
4547
4548   *input_line_pointer = c;
4549
4550   SKIP_WHITESPACE ();
4551
4552   exp = 0;
4553   flags = SEC_NO_FLAGS;
4554
4555   if (strcmp (name, ".idata$2") == 0)
4556     {
4557       align = 0;
4558     }
4559   else if (strcmp (name, ".idata$3") == 0)
4560     {
4561       align = 0;
4562     }
4563   else if (strcmp (name, ".idata$4") == 0)
4564     {
4565       align = 2;
4566     }
4567   else if (strcmp (name, ".idata$5") == 0)
4568     {
4569       align = 2;
4570     }
4571   else if (strcmp (name, ".idata$6") == 0)
4572     {
4573       align = 1;
4574     }
4575   else
4576     /* Default alignment to 16 byte boundary.  */
4577     align = 4;
4578
4579   if (*input_line_pointer == ',')
4580     {
4581       ++input_line_pointer;
4582       SKIP_WHITESPACE ();
4583       if (*input_line_pointer != '"')
4584         exp = get_absolute_expression ();
4585       else
4586         {
4587           ++input_line_pointer;
4588           while (*input_line_pointer != '"'
4589                  && ! is_end_of_line[(unsigned char) *input_line_pointer])
4590             {
4591               switch (*input_line_pointer)
4592                 {
4593                   /* Section Contents */
4594                 case 'a': /* unknown */
4595                   as_bad (_("Unsupported section attribute -- 'a'"));
4596                   break;
4597                 case 'c': /* code section */
4598                   flags |= SEC_CODE;
4599                   break;
4600                 case 'd': /* section has initialized data */
4601                   flags |= SEC_DATA;
4602                   break;
4603                 case 'u': /* section has uninitialized data */
4604                   /* FIXME: This is IMAGE_SCN_CNT_UNINITIALIZED_DATA
4605                      in winnt.h */
4606                   flags |= SEC_ROM;
4607                   break;
4608                 case 'i': /* section contains directives (info) */
4609                   /* FIXME: This is IMAGE_SCN_LNK_INFO
4610                      in winnt.h */
4611                   flags |= SEC_HAS_CONTENTS;
4612                   break;
4613                 case 'n': /* section can be discarded */
4614                   flags &=~ SEC_LOAD;
4615                   break;
4616                 case 'R': /* Remove section at link time */
4617                   flags |= SEC_NEVER_LOAD;
4618                   break;
4619 #if IFLICT_BRAIN_DAMAGE
4620                   /* Section Protection */
4621                 case 'r': /* section is readable */
4622                   flags |= IMAGE_SCN_MEM_READ;
4623                   break;
4624                 case 'w': /* section is writeable */
4625                   flags |= IMAGE_SCN_MEM_WRITE;
4626                   break;
4627                 case 'x': /* section is executable */
4628                   flags |= IMAGE_SCN_MEM_EXECUTE;
4629                   break;
4630                 case 's': /* section is sharable */
4631                   flags |= IMAGE_SCN_MEM_SHARED;
4632                   break;
4633
4634                   /* Section Alignment */
4635                 case '0': /* align to byte boundary */
4636                   flags |= IMAGE_SCN_ALIGN_1BYTES;
4637                   align = 0;
4638                   break;
4639                 case '1':  /* align to halfword boundary */
4640                   flags |= IMAGE_SCN_ALIGN_2BYTES;
4641                   align = 1;
4642                   break;
4643                 case '2':  /* align to word boundary */
4644                   flags |= IMAGE_SCN_ALIGN_4BYTES;
4645                   align = 2;
4646                   break;
4647                 case '3':  /* align to doubleword boundary */
4648                   flags |= IMAGE_SCN_ALIGN_8BYTES;
4649                   align = 3;
4650                   break;
4651                 case '4':  /* align to quadword boundary */
4652                   flags |= IMAGE_SCN_ALIGN_16BYTES;
4653                   align = 4;
4654                   break;
4655                 case '5':  /* align to 32 byte boundary */
4656                   flags |= IMAGE_SCN_ALIGN_32BYTES;
4657                   align = 5;
4658                   break;
4659                 case '6':  /* align to 64 byte boundary */
4660                   flags |= IMAGE_SCN_ALIGN_64BYTES;
4661                   align = 6;
4662                   break;
4663 #endif
4664                 default:
4665                   as_bad (_("unknown section attribute '%c'"),
4666                           *input_line_pointer);
4667                   break;
4668                 }
4669               ++input_line_pointer;
4670             }
4671           if (*input_line_pointer == '"')
4672             ++input_line_pointer;
4673         }
4674     }
4675
4676   sec = subseg_new (name, (subsegT) exp);
4677
4678   ppc_set_current_section (sec);
4679
4680   if (flags != SEC_NO_FLAGS)
4681     {
4682       if (! bfd_set_section_flags (stdoutput, sec, flags))
4683         as_bad (_("error setting flags for \"%s\": %s"),
4684                 bfd_section_name (stdoutput, sec),
4685                 bfd_errmsg (bfd_get_error ()));
4686     }
4687
4688   bfd_set_section_alignment (stdoutput, sec, align);
4689 }
4690
4691 static void
4692 ppc_pe_function (int ignore ATTRIBUTE_UNUSED)
4693 {
4694   char *name;
4695   char endc;
4696   symbolS *ext_sym;
4697
4698   name = input_line_pointer;
4699   endc = get_symbol_end ();
4700
4701   ext_sym = symbol_find_or_make (name);
4702
4703   *input_line_pointer = endc;
4704
4705   S_SET_DATA_TYPE (ext_sym, DT_FCN << N_BTSHFT);
4706   SF_SET_FUNCTION (ext_sym);
4707   SF_SET_PROCESS (ext_sym);
4708   coff_add_linesym (ext_sym);
4709
4710   demand_empty_rest_of_line ();
4711 }
4712
4713 static void
4714 ppc_pe_tocd (int ignore ATTRIBUTE_UNUSED)
4715 {
4716   if (tocdata_section == 0)
4717     {
4718       tocdata_section = subseg_new (".tocd", 0);
4719       /* FIXME: section flags won't work.  */
4720       bfd_set_section_flags (stdoutput, tocdata_section,
4721                              (SEC_ALLOC | SEC_LOAD | SEC_RELOC
4722                               | SEC_READONLY | SEC_DATA));
4723
4724       bfd_set_section_alignment (stdoutput, tocdata_section, 2);
4725     }
4726   else
4727     {
4728       rdata_section = subseg_new (".tocd", 0);
4729     }
4730
4731   ppc_set_current_section (tocdata_section);
4732
4733   demand_empty_rest_of_line ();
4734 }
4735
4736 /* Don't adjust TOC relocs to use the section symbol.  */
4737
4738 int
4739 ppc_pe_fix_adjustable (fixS *fix)
4740 {
4741   return fix->fx_r_type != BFD_RELOC_PPC_TOC16;
4742 }
4743
4744 #endif
4745 \f
4746 #ifdef OBJ_XCOFF
4747
4748 /* XCOFF specific symbol and file handling.  */
4749
4750 /* Canonicalize the symbol name.  We use the to force the suffix, if
4751    any, to use square brackets, and to be in upper case.  */
4752
4753 char *
4754 ppc_canonicalize_symbol_name (char *name)
4755 {
4756   char *s;
4757
4758   if (ppc_stab_symbol)
4759     return name;
4760
4761   for (s = name; *s != '\0' && *s != '{' && *s != '['; s++)
4762     ;
4763   if (*s != '\0')
4764     {
4765       char brac;
4766
4767       if (*s == '[')
4768         brac = ']';
4769       else
4770         {
4771           *s = '[';
4772           brac = '}';
4773         }
4774
4775       for (s++; *s != '\0' && *s != brac; s++)
4776         *s = TOUPPER (*s);
4777
4778       if (*s == '\0' || s[1] != '\0')
4779         as_bad (_("bad symbol suffix"));
4780
4781       *s = ']';
4782     }
4783
4784   return name;
4785 }
4786
4787 /* Set the class of a symbol based on the suffix, if any.  This is
4788    called whenever a new symbol is created.  */
4789
4790 void
4791 ppc_symbol_new_hook (symbolS *sym)
4792 {
4793   struct ppc_tc_sy *tc;
4794   const char *s;
4795
4796   tc = symbol_get_tc (sym);
4797   tc->next = NULL;
4798   tc->output = 0;
4799   tc->class = -1;
4800   tc->real_name = NULL;
4801   tc->subseg = 0;
4802   tc->align = 0;
4803   tc->size = NULL;
4804   tc->within = NULL;
4805
4806   if (ppc_stab_symbol)
4807     return;
4808
4809   s = strchr (S_GET_NAME (sym), '[');
4810   if (s == (const char *) NULL)
4811     {
4812       /* There is no suffix.  */
4813       return;
4814     }
4815
4816   ++s;
4817
4818   switch (s[0])
4819     {
4820     case 'B':
4821       if (strcmp (s, "BS]") == 0)
4822         tc->class = XMC_BS;
4823       break;
4824     case 'D':
4825       if (strcmp (s, "DB]") == 0)
4826         tc->class = XMC_DB;
4827       else if (strcmp (s, "DS]") == 0)
4828         tc->class = XMC_DS;
4829       break;
4830     case 'G':
4831       if (strcmp (s, "GL]") == 0)
4832         tc->class = XMC_GL;
4833       break;
4834     case 'P':
4835       if (strcmp (s, "PR]") == 0)
4836         tc->class = XMC_PR;
4837       break;
4838     case 'R':
4839       if (strcmp (s, "RO]") == 0)
4840         tc->class = XMC_RO;
4841       else if (strcmp (s, "RW]") == 0)
4842         tc->class = XMC_RW;
4843       break;
4844     case 'S':
4845       if (strcmp (s, "SV]") == 0)
4846         tc->class = XMC_SV;
4847       break;
4848     case 'T':
4849       if (strcmp (s, "TC]") == 0)
4850         tc->class = XMC_TC;
4851       else if (strcmp (s, "TI]") == 0)
4852         tc->class = XMC_TI;
4853       else if (strcmp (s, "TB]") == 0)
4854         tc->class = XMC_TB;
4855       else if (strcmp (s, "TC0]") == 0 || strcmp (s, "T0]") == 0)
4856         tc->class = XMC_TC0;
4857       break;
4858     case 'U':
4859       if (strcmp (s, "UA]") == 0)
4860         tc->class = XMC_UA;
4861       else if (strcmp (s, "UC]") == 0)
4862         tc->class = XMC_UC;
4863       break;
4864     case 'X':
4865       if (strcmp (s, "XO]") == 0)
4866         tc->class = XMC_XO;
4867       break;
4868     }
4869
4870   if (tc->class == -1)
4871     as_bad (_("Unrecognized symbol suffix"));
4872 }
4873
4874 /* Set the class of a label based on where it is defined.  This
4875    handles symbols without suffixes.  Also, move the symbol so that it
4876    follows the csect symbol.  */
4877
4878 void
4879 ppc_frob_label (symbolS *sym)
4880 {
4881   if (ppc_current_csect != (symbolS *) NULL)
4882     {
4883       if (symbol_get_tc (sym)->class == -1)
4884         symbol_get_tc (sym)->class = symbol_get_tc (ppc_current_csect)->class;
4885
4886       symbol_remove (sym, &symbol_rootP, &symbol_lastP);
4887       symbol_append (sym, symbol_get_tc (ppc_current_csect)->within,
4888                      &symbol_rootP, &symbol_lastP);
4889       symbol_get_tc (ppc_current_csect)->within = sym;
4890     }
4891
4892 #ifdef OBJ_ELF
4893   dwarf2_emit_label (sym);
4894 #endif
4895 }
4896
4897 /* This variable is set by ppc_frob_symbol if any absolute symbols are
4898    seen.  It tells ppc_adjust_symtab whether it needs to look through
4899    the symbols.  */
4900
4901 static bfd_boolean ppc_saw_abs;
4902
4903 /* Change the name of a symbol just before writing it out.  Set the
4904    real name if the .rename pseudo-op was used.  Otherwise, remove any
4905    class suffix.  Return 1 if the symbol should not be included in the
4906    symbol table.  */
4907
4908 int
4909 ppc_frob_symbol (symbolS *sym)
4910 {
4911   static symbolS *ppc_last_function;
4912   static symbolS *set_end;
4913
4914   /* Discard symbols that should not be included in the output symbol
4915      table.  */
4916   if (! symbol_used_in_reloc_p (sym)
4917       && ((symbol_get_bfdsym (sym)->flags & BSF_SECTION_SYM) != 0
4918           || (! (S_IS_EXTERNAL (sym) || S_IS_WEAK (sym))
4919               && ! symbol_get_tc (sym)->output
4920               && S_GET_STORAGE_CLASS (sym) != C_FILE)))
4921     return 1;
4922
4923   /* This one will disappear anyway.  Don't make a csect sym for it.  */
4924   if (sym == abs_section_sym)
4925     return 1;
4926
4927   if (symbol_get_tc (sym)->real_name != (char *) NULL)
4928     S_SET_NAME (sym, symbol_get_tc (sym)->real_name);
4929   else
4930     {
4931       const char *name;
4932       const char *s;
4933
4934       name = S_GET_NAME (sym);
4935       s = strchr (name, '[');
4936       if (s != (char *) NULL)
4937         {
4938           unsigned int len;
4939           char *snew;
4940
4941           len = s - name;
4942           snew = xmalloc (len + 1);
4943           memcpy (snew, name, len);
4944           snew[len] = '\0';
4945
4946           S_SET_NAME (sym, snew);
4947         }
4948     }
4949
4950   if (set_end != (symbolS *) NULL)
4951     {
4952       SA_SET_SYM_ENDNDX (set_end, sym);
4953       set_end = NULL;
4954     }
4955
4956   if (SF_GET_FUNCTION (sym))
4957     {
4958       if (ppc_last_function != (symbolS *) NULL)
4959         as_bad (_("two .function pseudo-ops with no intervening .ef"));
4960       ppc_last_function = sym;
4961       if (symbol_get_tc (sym)->size != (symbolS *) NULL)
4962         {
4963           resolve_symbol_value (symbol_get_tc (sym)->size);
4964           SA_SET_SYM_FSIZE (sym,
4965                             (long) S_GET_VALUE (symbol_get_tc (sym)->size));
4966         }
4967     }
4968   else if (S_GET_STORAGE_CLASS (sym) == C_FCN
4969            && strcmp (S_GET_NAME (sym), ".ef") == 0)
4970     {
4971       if (ppc_last_function == (symbolS *) NULL)
4972         as_bad (_(".ef with no preceding .function"));
4973       else
4974         {
4975           set_end = ppc_last_function;
4976           ppc_last_function = NULL;
4977
4978           /* We don't have a C_EFCN symbol, but we need to force the
4979              COFF backend to believe that it has seen one.  */
4980           coff_last_function = NULL;
4981         }
4982     }
4983
4984   if (! (S_IS_EXTERNAL (sym) || S_IS_WEAK (sym))
4985       && (symbol_get_bfdsym (sym)->flags & BSF_SECTION_SYM) == 0
4986       && S_GET_STORAGE_CLASS (sym) != C_FILE
4987       && S_GET_STORAGE_CLASS (sym) != C_FCN
4988       && S_GET_STORAGE_CLASS (sym) != C_BLOCK
4989       && S_GET_STORAGE_CLASS (sym) != C_BSTAT
4990       && S_GET_STORAGE_CLASS (sym) != C_ESTAT
4991       && S_GET_STORAGE_CLASS (sym) != C_BINCL
4992       && S_GET_STORAGE_CLASS (sym) != C_EINCL
4993       && S_GET_SEGMENT (sym) != ppc_coff_debug_section)
4994     S_SET_STORAGE_CLASS (sym, C_HIDEXT);
4995
4996   if (S_GET_STORAGE_CLASS (sym) == C_EXT
4997       || S_GET_STORAGE_CLASS (sym) == C_HIDEXT)
4998     {
4999       int i;
5000       union internal_auxent *a;
5001
5002       /* Create a csect aux.  */
5003       i = S_GET_NUMBER_AUXILIARY (sym);
5004       S_SET_NUMBER_AUXILIARY (sym, i + 1);
5005       a = &coffsymbol (symbol_get_bfdsym (sym))->native[i + 1].u.auxent;
5006       if (symbol_get_tc (sym)->class == XMC_TC0)
5007         {
5008           /* This is the TOC table.  */
5009           know (strcmp (S_GET_NAME (sym), "TOC") == 0);
5010           a->x_csect.x_scnlen.l = 0;
5011           a->x_csect.x_smtyp = (2 << 3) | XTY_SD;
5012         }
5013       else if (symbol_get_tc (sym)->subseg != 0)
5014         {
5015           /* This is a csect symbol.  x_scnlen is the size of the
5016              csect.  */
5017           if (symbol_get_tc (sym)->next == (symbolS *) NULL)
5018             a->x_csect.x_scnlen.l = (bfd_section_size (stdoutput,
5019                                                        S_GET_SEGMENT (sym))
5020                                      - S_GET_VALUE (sym));
5021           else
5022             {
5023               resolve_symbol_value (symbol_get_tc (sym)->next);
5024               a->x_csect.x_scnlen.l = (S_GET_VALUE (symbol_get_tc (sym)->next)
5025                                        - S_GET_VALUE (sym));
5026             }
5027           a->x_csect.x_smtyp = (symbol_get_tc (sym)->align << 3) | XTY_SD;
5028         }
5029       else if (S_GET_SEGMENT (sym) == bss_section)
5030         {
5031           /* This is a common symbol.  */
5032           a->x_csect.x_scnlen.l = symbol_get_frag (sym)->fr_offset;
5033           a->x_csect.x_smtyp = (symbol_get_tc (sym)->align << 3) | XTY_CM;
5034           if (S_IS_EXTERNAL (sym))
5035             symbol_get_tc (sym)->class = XMC_RW;
5036           else
5037             symbol_get_tc (sym)->class = XMC_BS;
5038         }
5039       else if (S_GET_SEGMENT (sym) == absolute_section)
5040         {
5041           /* This is an absolute symbol.  The csect will be created by
5042              ppc_adjust_symtab.  */
5043           ppc_saw_abs = TRUE;
5044           a->x_csect.x_smtyp = XTY_LD;
5045           if (symbol_get_tc (sym)->class == -1)
5046             symbol_get_tc (sym)->class = XMC_XO;
5047         }
5048       else if (! S_IS_DEFINED (sym))
5049         {
5050           /* This is an external symbol.  */
5051           a->x_csect.x_scnlen.l = 0;
5052           a->x_csect.x_smtyp = XTY_ER;
5053         }
5054       else if (symbol_get_tc (sym)->class == XMC_TC)
5055         {
5056           symbolS *next;
5057
5058           /* This is a TOC definition.  x_scnlen is the size of the
5059              TOC entry.  */
5060           next = symbol_next (sym);
5061           while (symbol_get_tc (next)->class == XMC_TC0)
5062             next = symbol_next (next);
5063           if (next == (symbolS *) NULL
5064               || symbol_get_tc (next)->class != XMC_TC)
5065             {
5066               if (ppc_after_toc_frag == (fragS *) NULL)
5067                 a->x_csect.x_scnlen.l = (bfd_section_size (stdoutput,
5068                                                            data_section)
5069                                          - S_GET_VALUE (sym));
5070               else
5071                 a->x_csect.x_scnlen.l = (ppc_after_toc_frag->fr_address
5072                                          - S_GET_VALUE (sym));
5073             }
5074           else
5075             {
5076               resolve_symbol_value (next);
5077               a->x_csect.x_scnlen.l = (S_GET_VALUE (next)
5078                                        - S_GET_VALUE (sym));
5079             }
5080           a->x_csect.x_smtyp = (2 << 3) | XTY_SD;
5081         }
5082       else
5083         {
5084           symbolS *csect;
5085
5086           /* This is a normal symbol definition.  x_scnlen is the
5087              symbol index of the containing csect.  */
5088           if (S_GET_SEGMENT (sym) == text_section)
5089             csect = ppc_text_csects;
5090           else if (S_GET_SEGMENT (sym) == data_section)
5091             csect = ppc_data_csects;
5092           else
5093             abort ();
5094
5095           /* Skip the initial dummy symbol.  */
5096           csect = symbol_get_tc (csect)->next;
5097
5098           if (csect == (symbolS *) NULL)
5099             {
5100               as_warn (_("warning: symbol %s has no csect"), S_GET_NAME (sym));
5101               a->x_csect.x_scnlen.l = 0;
5102             }
5103           else
5104             {
5105               while (symbol_get_tc (csect)->next != (symbolS *) NULL)
5106                 {
5107                   resolve_symbol_value (symbol_get_tc (csect)->next);
5108                   if (S_GET_VALUE (symbol_get_tc (csect)->next)
5109                       > S_GET_VALUE (sym))
5110                     break;
5111                   csect = symbol_get_tc (csect)->next;
5112                 }
5113
5114               a->x_csect.x_scnlen.p =
5115                 coffsymbol (symbol_get_bfdsym (csect))->native;
5116               coffsymbol (symbol_get_bfdsym (sym))->native[i + 1].fix_scnlen =
5117                 1;
5118             }
5119           a->x_csect.x_smtyp = XTY_LD;
5120         }
5121
5122       a->x_csect.x_parmhash = 0;
5123       a->x_csect.x_snhash = 0;
5124       if (symbol_get_tc (sym)->class == -1)
5125         a->x_csect.x_smclas = XMC_PR;
5126       else
5127         a->x_csect.x_smclas = symbol_get_tc (sym)->class;
5128       a->x_csect.x_stab = 0;
5129       a->x_csect.x_snstab = 0;
5130
5131       /* Don't let the COFF backend resort these symbols.  */
5132       symbol_get_bfdsym (sym)->flags |= BSF_NOT_AT_END;
5133     }
5134   else if (S_GET_STORAGE_CLASS (sym) == C_BSTAT)
5135     {
5136       /* We want the value to be the symbol index of the referenced
5137          csect symbol.  BFD will do that for us if we set the right
5138          flags.  */
5139       asymbol *bsym = symbol_get_bfdsym (symbol_get_tc (sym)->within);
5140       combined_entry_type *c = coffsymbol (bsym)->native;
5141
5142       S_SET_VALUE (sym, (valueT) (size_t) c);
5143       coffsymbol (symbol_get_bfdsym (sym))->native->fix_value = 1;
5144     }
5145   else if (S_GET_STORAGE_CLASS (sym) == C_STSYM)
5146     {
5147       symbolS *block;
5148       symbolS *csect;
5149
5150       /* The value is the offset from the enclosing csect.  */
5151       block = symbol_get_tc (sym)->within;
5152       csect = symbol_get_tc (block)->within;
5153       resolve_symbol_value (csect);
5154       S_SET_VALUE (sym, S_GET_VALUE (sym) - S_GET_VALUE (csect));
5155     }
5156   else if (S_GET_STORAGE_CLASS (sym) == C_BINCL
5157            || S_GET_STORAGE_CLASS (sym) == C_EINCL)
5158     {
5159       /* We want the value to be a file offset into the line numbers.
5160          BFD will do that for us if we set the right flags.  We have
5161          already set the value correctly.  */
5162       coffsymbol (symbol_get_bfdsym (sym))->native->fix_line = 1;
5163     }
5164
5165   return 0;
5166 }
5167
5168 /* Adjust the symbol table.  This creates csect symbols for all
5169    absolute symbols.  */
5170
5171 void
5172 ppc_adjust_symtab (void)
5173 {
5174   symbolS *sym;
5175
5176   if (! ppc_saw_abs)
5177     return;
5178
5179   for (sym = symbol_rootP; sym != NULL; sym = symbol_next (sym))
5180     {
5181       symbolS *csect;
5182       int i;
5183       union internal_auxent *a;
5184
5185       if (S_GET_SEGMENT (sym) != absolute_section)
5186         continue;
5187
5188       csect = symbol_create (".abs[XO]", absolute_section,
5189                              S_GET_VALUE (sym), &zero_address_frag);
5190       symbol_get_bfdsym (csect)->value = S_GET_VALUE (sym);
5191       S_SET_STORAGE_CLASS (csect, C_HIDEXT);
5192       i = S_GET_NUMBER_AUXILIARY (csect);
5193       S_SET_NUMBER_AUXILIARY (csect, i + 1);
5194       a = &coffsymbol (symbol_get_bfdsym (csect))->native[i + 1].u.auxent;
5195       a->x_csect.x_scnlen.l = 0;
5196       a->x_csect.x_smtyp = XTY_SD;
5197       a->x_csect.x_parmhash = 0;
5198       a->x_csect.x_snhash = 0;
5199       a->x_csect.x_smclas = XMC_XO;
5200       a->x_csect.x_stab = 0;
5201       a->x_csect.x_snstab = 0;
5202
5203       symbol_insert (csect, sym, &symbol_rootP, &symbol_lastP);
5204
5205       i = S_GET_NUMBER_AUXILIARY (sym);
5206       a = &coffsymbol (symbol_get_bfdsym (sym))->native[i].u.auxent;
5207       a->x_csect.x_scnlen.p = coffsymbol (symbol_get_bfdsym (csect))->native;
5208       coffsymbol (symbol_get_bfdsym (sym))->native[i].fix_scnlen = 1;
5209     }
5210
5211   ppc_saw_abs = FALSE;
5212 }
5213
5214 /* Set the VMA for a section.  This is called on all the sections in
5215    turn.  */
5216
5217 void
5218 ppc_frob_section (asection *sec)
5219 {
5220   static bfd_vma vma = 0;
5221
5222   vma = md_section_align (sec, vma);
5223   bfd_set_section_vma (stdoutput, sec, vma);
5224   vma += bfd_section_size (stdoutput, sec);
5225 }
5226
5227 #endif /* OBJ_XCOFF */
5228 \f
5229 /* Turn a string in input_line_pointer into a floating point constant
5230    of type TYPE, and store the appropriate bytes in *LITP.  The number
5231    of LITTLENUMS emitted is stored in *SIZEP.  An error message is
5232    returned, or NULL on OK.  */
5233
5234 char *
5235 md_atof (int type, char *litp, int *sizep)
5236 {
5237   int prec;
5238   LITTLENUM_TYPE words[4];
5239   char *t;
5240   int i;
5241
5242   switch (type)
5243     {
5244     case 'f':
5245       prec = 2;
5246       break;
5247
5248     case 'd':
5249       prec = 4;
5250       break;
5251
5252     default:
5253       *sizep = 0;
5254       return _("bad call to md_atof");
5255     }
5256
5257   t = atof_ieee (input_line_pointer, type, words);
5258   if (t)
5259     input_line_pointer = t;
5260
5261   *sizep = prec * 2;
5262
5263   if (target_big_endian)
5264     {
5265       for (i = 0; i < prec; i++)
5266         {
5267           md_number_to_chars (litp, (valueT) words[i], 2);
5268           litp += 2;
5269         }
5270     }
5271   else
5272     {
5273       for (i = prec - 1; i >= 0; i--)
5274         {
5275           md_number_to_chars (litp, (valueT) words[i], 2);
5276           litp += 2;
5277         }
5278     }
5279
5280   return NULL;
5281 }
5282
5283 /* Write a value out to the object file, using the appropriate
5284    endianness.  */
5285
5286 void
5287 md_number_to_chars (char *buf, valueT val, int n)
5288 {
5289   if (target_big_endian)
5290     number_to_chars_bigendian (buf, val, n);
5291   else
5292     number_to_chars_littleendian (buf, val, n);
5293 }
5294
5295 /* Align a section (I don't know why this is machine dependent).  */
5296
5297 valueT
5298 md_section_align (asection *seg ATTRIBUTE_UNUSED, valueT addr)
5299 {
5300 #ifdef OBJ_ELF
5301   return addr;
5302 #else
5303   int align = bfd_get_section_alignment (stdoutput, seg);
5304
5305   return ((addr + (1 << align) - 1) & (-1 << align));
5306 #endif
5307 }
5308
5309 /* We don't have any form of relaxing.  */
5310
5311 int
5312 md_estimate_size_before_relax (fragS *fragp ATTRIBUTE_UNUSED,
5313                                asection *seg ATTRIBUTE_UNUSED)
5314 {
5315   abort ();
5316   return 0;
5317 }
5318
5319 /* Convert a machine dependent frag.  We never generate these.  */
5320
5321 void
5322 md_convert_frag (bfd *abfd ATTRIBUTE_UNUSED,
5323                  asection *sec ATTRIBUTE_UNUSED,
5324                  fragS *fragp ATTRIBUTE_UNUSED)
5325 {
5326   abort ();
5327 }
5328
5329 /* We have no need to default values of symbols.  */
5330
5331 symbolS *
5332 md_undefined_symbol (char *name ATTRIBUTE_UNUSED)
5333 {
5334   return 0;
5335 }
5336 \f
5337 /* Functions concerning relocs.  */
5338
5339 /* The location from which a PC relative jump should be calculated,
5340    given a PC relative reloc.  */
5341
5342 long
5343 md_pcrel_from_section (fixS *fixp, segT sec ATTRIBUTE_UNUSED)
5344 {
5345   return fixp->fx_frag->fr_address + fixp->fx_where;
5346 }
5347
5348 #ifdef OBJ_XCOFF
5349
5350 /* This is called to see whether a fixup should be adjusted to use a
5351    section symbol.  We take the opportunity to change a fixup against
5352    a symbol in the TOC subsegment into a reloc against the
5353    corresponding .tc symbol.  */
5354
5355 int
5356 ppc_fix_adjustable (fixS *fix)
5357 {
5358   valueT val = resolve_symbol_value (fix->fx_addsy);
5359   segT symseg = S_GET_SEGMENT (fix->fx_addsy);
5360   TC_SYMFIELD_TYPE *tc;
5361
5362   if (symseg == absolute_section)
5363     return 0;
5364
5365   if (ppc_toc_csect != (symbolS *) NULL
5366       && fix->fx_addsy != ppc_toc_csect
5367       && symseg == data_section
5368       && val >= ppc_toc_frag->fr_address
5369       && (ppc_after_toc_frag == (fragS *) NULL
5370           || val < ppc_after_toc_frag->fr_address))
5371     {
5372       symbolS *sy;
5373
5374       for (sy = symbol_next (ppc_toc_csect);
5375            sy != (symbolS *) NULL;
5376            sy = symbol_next (sy))
5377         {
5378           TC_SYMFIELD_TYPE *sy_tc = symbol_get_tc (sy);
5379
5380           if (sy_tc->class == XMC_TC0)
5381             continue;
5382           if (sy_tc->class != XMC_TC)
5383             break;
5384           if (val == resolve_symbol_value (sy))
5385             {
5386               fix->fx_addsy = sy;
5387               fix->fx_addnumber = val - ppc_toc_frag->fr_address;
5388               return 0;
5389             }
5390         }
5391
5392       as_bad_where (fix->fx_file, fix->fx_line,
5393                     _("symbol in .toc does not match any .tc"));
5394     }
5395
5396   /* Possibly adjust the reloc to be against the csect.  */
5397   tc = symbol_get_tc (fix->fx_addsy);
5398   if (tc->subseg == 0
5399       && tc->class != XMC_TC0
5400       && tc->class != XMC_TC
5401       && symseg != bss_section
5402       /* Don't adjust if this is a reloc in the toc section.  */
5403       && (symseg != data_section
5404           || ppc_toc_csect == NULL
5405           || val < ppc_toc_frag->fr_address
5406           || (ppc_after_toc_frag != NULL
5407               && val >= ppc_after_toc_frag->fr_address)))
5408     {
5409       symbolS *csect;
5410       symbolS *next_csect;
5411
5412       if (symseg == text_section)
5413         csect = ppc_text_csects;
5414       else if (symseg == data_section)
5415         csect = ppc_data_csects;
5416       else
5417         abort ();
5418
5419       /* Skip the initial dummy symbol.  */
5420       csect = symbol_get_tc (csect)->next;
5421
5422       if (csect != (symbolS *) NULL)
5423         {
5424           while ((next_csect = symbol_get_tc (csect)->next) != (symbolS *) NULL
5425                  && (symbol_get_frag (next_csect)->fr_address <= val))
5426             {
5427               /* If the csect address equals the symbol value, then we
5428                  have to look through the full symbol table to see
5429                  whether this is the csect we want.  Note that we will
5430                  only get here if the csect has zero length.  */
5431               if (symbol_get_frag (csect)->fr_address == val
5432                   && S_GET_VALUE (csect) == val)
5433                 {
5434                   symbolS *scan;
5435
5436                   for (scan = symbol_next (csect);
5437                        scan != NULL;
5438                        scan = symbol_next (scan))
5439                     {
5440                       if (symbol_get_tc (scan)->subseg != 0)
5441                         break;
5442                       if (scan == fix->fx_addsy)
5443                         break;
5444                     }
5445
5446                   /* If we found the symbol before the next csect
5447                      symbol, then this is the csect we want.  */
5448                   if (scan == fix->fx_addsy)
5449                     break;
5450                 }
5451
5452               csect = next_csect;
5453             }
5454
5455           fix->fx_offset += val - symbol_get_frag (csect)->fr_address;
5456           fix->fx_addsy = csect;
5457         }
5458       return 0;
5459     }
5460
5461   /* Adjust a reloc against a .lcomm symbol to be against the base
5462      .lcomm.  */
5463   if (symseg == bss_section
5464       && ! S_IS_EXTERNAL (fix->fx_addsy))
5465     {
5466       symbolS *sy = symbol_get_frag (fix->fx_addsy)->fr_symbol;
5467
5468       fix->fx_offset += val - resolve_symbol_value (sy);
5469       fix->fx_addsy = sy;
5470     }
5471
5472   return 0;
5473 }
5474
5475 /* A reloc from one csect to another must be kept.  The assembler
5476    will, of course, keep relocs between sections, and it will keep
5477    absolute relocs, but we need to force it to keep PC relative relocs
5478    between two csects in the same section.  */
5479
5480 int
5481 ppc_force_relocation (fixS *fix)
5482 {
5483   /* At this point fix->fx_addsy should already have been converted to
5484      a csect symbol.  If the csect does not include the fragment, then
5485      we need to force the relocation.  */
5486   if (fix->fx_pcrel
5487       && fix->fx_addsy != NULL
5488       && symbol_get_tc (fix->fx_addsy)->subseg != 0
5489       && ((symbol_get_frag (fix->fx_addsy)->fr_address
5490            > fix->fx_frag->fr_address)
5491           || (symbol_get_tc (fix->fx_addsy)->next != NULL
5492               && (symbol_get_frag (symbol_get_tc (fix->fx_addsy)->next)->fr_address
5493                   <= fix->fx_frag->fr_address))))
5494     return 1;
5495
5496   return generic_force_reloc (fix);
5497 }
5498
5499 #endif /* OBJ_XCOFF */
5500
5501 #ifdef OBJ_ELF
5502 /* If this function returns non-zero, it guarantees that a relocation
5503    will be emitted for a fixup.  */
5504
5505 int
5506 ppc_force_relocation (fixS *fix)
5507 {
5508   /* Branch prediction relocations must force a relocation, as must
5509      the vtable description relocs.  */
5510   switch (fix->fx_r_type)
5511     {
5512     case BFD_RELOC_PPC_B16_BRTAKEN:
5513     case BFD_RELOC_PPC_B16_BRNTAKEN:
5514     case BFD_RELOC_PPC_BA16_BRTAKEN:
5515     case BFD_RELOC_PPC_BA16_BRNTAKEN:
5516     case BFD_RELOC_24_PLT_PCREL:
5517     case BFD_RELOC_PPC64_TOC:
5518       return 1;
5519     default:
5520       break;
5521     }
5522
5523   if (fix->fx_r_type >= BFD_RELOC_PPC_TLS
5524       && fix->fx_r_type <= BFD_RELOC_PPC64_DTPREL16_HIGHESTA)
5525     return 1;
5526
5527   return generic_force_reloc (fix);
5528 }
5529
5530 int
5531 ppc_fix_adjustable (fixS *fix)
5532 {
5533   return (fix->fx_r_type != BFD_RELOC_16_GOTOFF
5534           && fix->fx_r_type != BFD_RELOC_LO16_GOTOFF
5535           && fix->fx_r_type != BFD_RELOC_HI16_GOTOFF
5536           && fix->fx_r_type != BFD_RELOC_HI16_S_GOTOFF
5537           && fix->fx_r_type != BFD_RELOC_GPREL16
5538           && fix->fx_r_type != BFD_RELOC_VTABLE_INHERIT
5539           && fix->fx_r_type != BFD_RELOC_VTABLE_ENTRY
5540           && !(fix->fx_r_type >= BFD_RELOC_PPC_TLS
5541                && fix->fx_r_type <= BFD_RELOC_PPC64_DTPREL16_HIGHESTA));
5542 }
5543 #endif
5544
5545 /* Implement HANDLE_ALIGN.  This writes the NOP pattern into an
5546    rs_align_code frag.  */
5547
5548 void
5549 ppc_handle_align (struct frag *fragP)
5550 {
5551   valueT count = (fragP->fr_next->fr_address
5552                   - (fragP->fr_address + fragP->fr_fix));
5553
5554   if (count != 0 && (count & 3) == 0)
5555     {
5556       char *dest = fragP->fr_literal + fragP->fr_fix;
5557
5558       fragP->fr_var = 4;
5559       md_number_to_chars (dest, 0x60000000, 4);
5560
5561       if ((ppc_cpu & PPC_OPCODE_POWER6) != 0)
5562         {
5563           /* For power6, we want the last nop to be a group terminating
5564              one, "ori 1,1,0".  Do this by inserting an rs_fill frag
5565              immediately after this one, with its address set to the last
5566              nop location.  This will automatically reduce the number of
5567              nops in the current frag by one.  */
5568           if (count > 4)
5569             {
5570               struct frag *group_nop = xmalloc (SIZEOF_STRUCT_FRAG + 4);
5571
5572               memcpy (group_nop, fragP, SIZEOF_STRUCT_FRAG);
5573               group_nop->fr_address = group_nop->fr_next->fr_address - 4;
5574               group_nop->fr_fix = 0;
5575               group_nop->fr_offset = 1;
5576               group_nop->fr_type = rs_fill;
5577               fragP->fr_next = group_nop;
5578               dest = group_nop->fr_literal;
5579             }
5580
5581           md_number_to_chars (dest, 0x60210000, 4);
5582         }
5583     }
5584 }
5585
5586 /* Apply a fixup to the object code.  This is called for all the
5587    fixups we generated by the call to fix_new_exp, above.  In the call
5588    above we used a reloc code which was the largest legal reloc code
5589    plus the operand index.  Here we undo that to recover the operand
5590    index.  At this point all symbol values should be fully resolved,
5591    and we attempt to completely resolve the reloc.  If we can not do
5592    that, we determine the correct reloc code and put it back in the
5593    fixup.  */
5594
5595 void
5596 md_apply_fix (fixS *fixP, valueT *valP, segT seg ATTRIBUTE_UNUSED)
5597 {
5598   valueT value = * valP;
5599
5600 #ifdef OBJ_ELF
5601   if (fixP->fx_addsy != NULL)
5602     {
5603       /* Hack around bfd_install_relocation brain damage.  */
5604       if (fixP->fx_pcrel)
5605         value += fixP->fx_frag->fr_address + fixP->fx_where;
5606     }
5607   else
5608     fixP->fx_done = 1;
5609 #else
5610   /* FIXME FIXME FIXME: The value we are passed in *valP includes
5611      the symbol values.  If we are doing this relocation the code in
5612      write.c is going to call bfd_install_relocation, which is also
5613      going to use the symbol value.  That means that if the reloc is
5614      fully resolved we want to use *valP since bfd_install_relocation is
5615      not being used.
5616      However, if the reloc is not fully resolved we do not want to use
5617      *valP, and must use fx_offset instead.  However, if the reloc
5618      is PC relative, we do want to use *valP since it includes the
5619      result of md_pcrel_from.  This is confusing.  */
5620   if (fixP->fx_addsy == (symbolS *) NULL)
5621     fixP->fx_done = 1;
5622
5623   else if (fixP->fx_pcrel)
5624     ;
5625
5626   else
5627     value = fixP->fx_offset;
5628 #endif
5629
5630   if (fixP->fx_subsy != (symbolS *) NULL)
5631     {
5632       /* We can't actually support subtracting a symbol.  */
5633       as_bad_where (fixP->fx_file, fixP->fx_line, _("expression too complex"));
5634     }
5635
5636   if ((int) fixP->fx_r_type >= (int) BFD_RELOC_UNUSED)
5637     {
5638       int opindex;
5639       const struct powerpc_operand *operand;
5640       char *where;
5641       unsigned long insn;
5642
5643       opindex = (int) fixP->fx_r_type - (int) BFD_RELOC_UNUSED;
5644
5645       operand = &powerpc_operands[opindex];
5646
5647 #ifdef OBJ_XCOFF
5648       /* An instruction like `lwz 9,sym(30)' when `sym' is not a TOC symbol
5649          does not generate a reloc.  It uses the offset of `sym' within its
5650          csect.  Other usages, such as `.long sym', generate relocs.  This
5651          is the documented behaviour of non-TOC symbols.  */
5652       if ((operand->flags & PPC_OPERAND_PARENS) != 0
5653           && (operand->bitm & 0xfff0) == 0xfff0
5654           && operand->shift == 0
5655           && (operand->insert == NULL || ppc_obj64)
5656           && fixP->fx_addsy != NULL
5657           && symbol_get_tc (fixP->fx_addsy)->subseg != 0
5658           && symbol_get_tc (fixP->fx_addsy)->class != XMC_TC
5659           && symbol_get_tc (fixP->fx_addsy)->class != XMC_TC0
5660           && S_GET_SEGMENT (fixP->fx_addsy) != bss_section)
5661         {
5662           value = fixP->fx_offset;
5663           fixP->fx_done = 1;
5664         }
5665 #endif
5666
5667       /* Fetch the instruction, insert the fully resolved operand
5668          value, and stuff the instruction back again.  */
5669       where = fixP->fx_frag->fr_literal + fixP->fx_where;
5670       if (target_big_endian)
5671         insn = bfd_getb32 ((unsigned char *) where);
5672       else
5673         insn = bfd_getl32 ((unsigned char *) where);
5674       insn = ppc_insert_operand (insn, operand, (offsetT) value,
5675                                  fixP->fx_file, fixP->fx_line);
5676       if (target_big_endian)
5677         bfd_putb32 ((bfd_vma) insn, (unsigned char *) where);
5678       else
5679         bfd_putl32 ((bfd_vma) insn, (unsigned char *) where);
5680
5681       if (fixP->fx_done)
5682         /* Nothing else to do here.  */
5683         return;
5684
5685       assert (fixP->fx_addsy != NULL);
5686
5687       /* Determine a BFD reloc value based on the operand information.
5688          We are only prepared to turn a few of the operands into
5689          relocs.  */
5690       if ((operand->flags & PPC_OPERAND_RELATIVE) != 0
5691           && operand->bitm == 0x3fffffc
5692           && operand->shift == 0)
5693         fixP->fx_r_type = BFD_RELOC_PPC_B26;
5694       else if ((operand->flags & PPC_OPERAND_RELATIVE) != 0
5695           && operand->bitm == 0xfffc
5696           && operand->shift == 0)
5697         {
5698           fixP->fx_r_type = BFD_RELOC_PPC_B16;
5699 #ifdef OBJ_XCOFF
5700           fixP->fx_size = 2;
5701           if (target_big_endian)
5702             fixP->fx_where += 2;
5703 #endif
5704         }
5705       else if ((operand->flags & PPC_OPERAND_ABSOLUTE) != 0
5706                && operand->bitm == 0x3fffffc
5707                && operand->shift == 0)
5708         fixP->fx_r_type = BFD_RELOC_PPC_BA26;
5709       else if ((operand->flags & PPC_OPERAND_ABSOLUTE) != 0
5710                && operand->bitm == 0xfffc
5711                && operand->shift == 0)
5712         {
5713           fixP->fx_r_type = BFD_RELOC_PPC_BA16;
5714 #ifdef OBJ_XCOFF
5715           fixP->fx_size = 2;
5716           if (target_big_endian)
5717             fixP->fx_where += 2;
5718 #endif
5719         }
5720 #if defined (OBJ_XCOFF) || defined (OBJ_ELF)
5721       else if ((operand->flags & PPC_OPERAND_PARENS) != 0
5722                && (operand->bitm & 0xfff0) == 0xfff0
5723                && operand->shift == 0)
5724         {
5725           if (ppc_is_toc_sym (fixP->fx_addsy))
5726             {
5727               fixP->fx_r_type = BFD_RELOC_PPC_TOC16;
5728 #ifdef OBJ_ELF
5729               if (ppc_obj64
5730                   && (operand->flags & PPC_OPERAND_DS) != 0)
5731                 fixP->fx_r_type = BFD_RELOC_PPC64_TOC16_DS;
5732 #endif
5733             }
5734           else
5735             {
5736               fixP->fx_r_type = BFD_RELOC_16;
5737 #ifdef OBJ_ELF
5738               if (ppc_obj64
5739                   && (operand->flags & PPC_OPERAND_DS) != 0)
5740                 fixP->fx_r_type = BFD_RELOC_PPC64_ADDR16_DS;
5741 #endif
5742             }
5743           fixP->fx_size = 2;
5744           if (target_big_endian)
5745             fixP->fx_where += 2;
5746         }
5747 #endif /* defined (OBJ_XCOFF) || defined (OBJ_ELF) */
5748       else
5749         {
5750           char *sfile;
5751           unsigned int sline;
5752
5753           /* Use expr_symbol_where to see if this is an expression
5754              symbol.  */
5755           if (expr_symbol_where (fixP->fx_addsy, &sfile, &sline))
5756             as_bad_where (fixP->fx_file, fixP->fx_line,
5757                           _("unresolved expression that must be resolved"));
5758           else
5759             as_bad_where (fixP->fx_file, fixP->fx_line,
5760                           _("unsupported relocation against %s"),
5761                           S_GET_NAME (fixP->fx_addsy));
5762           fixP->fx_done = 1;
5763           return;
5764         }
5765     }
5766   else
5767     {
5768 #ifdef OBJ_ELF
5769       ppc_elf_validate_fix (fixP, seg);
5770 #endif
5771       switch (fixP->fx_r_type)
5772         {
5773         case BFD_RELOC_CTOR:
5774           if (ppc_obj64)
5775             goto ctor64;
5776           /* fall through */
5777
5778         case BFD_RELOC_32:
5779           if (fixP->fx_pcrel)
5780             fixP->fx_r_type = BFD_RELOC_32_PCREL;
5781           /* fall through */
5782
5783         case BFD_RELOC_RVA:
5784         case BFD_RELOC_32_PCREL:
5785         case BFD_RELOC_PPC_EMB_NADDR32:
5786           md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
5787                               value, 4);
5788           break;
5789
5790         case BFD_RELOC_64:
5791         ctor64:
5792           if (fixP->fx_pcrel)
5793             fixP->fx_r_type = BFD_RELOC_64_PCREL;
5794           /* fall through */
5795
5796         case BFD_RELOC_64_PCREL:
5797           md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
5798                               value, 8);
5799           break;
5800
5801         case BFD_RELOC_GPREL16:
5802         case BFD_RELOC_16_GOT_PCREL:
5803         case BFD_RELOC_16_GOTOFF:
5804         case BFD_RELOC_LO16_GOTOFF:
5805         case BFD_RELOC_HI16_GOTOFF:
5806         case BFD_RELOC_HI16_S_GOTOFF:
5807         case BFD_RELOC_16_BASEREL:
5808         case BFD_RELOC_LO16_BASEREL:
5809         case BFD_RELOC_HI16_BASEREL:
5810         case BFD_RELOC_HI16_S_BASEREL:
5811         case BFD_RELOC_PPC_EMB_NADDR16:
5812         case BFD_RELOC_PPC_EMB_NADDR16_LO:
5813         case BFD_RELOC_PPC_EMB_NADDR16_HI:
5814         case BFD_RELOC_PPC_EMB_NADDR16_HA:
5815         case BFD_RELOC_PPC_EMB_SDAI16:
5816         case BFD_RELOC_PPC_EMB_SDA2REL:
5817         case BFD_RELOC_PPC_EMB_SDA2I16:
5818         case BFD_RELOC_PPC_EMB_RELSEC16:
5819         case BFD_RELOC_PPC_EMB_RELST_LO:
5820         case BFD_RELOC_PPC_EMB_RELST_HI:
5821         case BFD_RELOC_PPC_EMB_RELST_HA:
5822         case BFD_RELOC_PPC_EMB_RELSDA:
5823         case BFD_RELOC_PPC_TOC16:
5824 #ifdef OBJ_ELF
5825         case BFD_RELOC_PPC64_TOC16_LO:
5826         case BFD_RELOC_PPC64_TOC16_HI:
5827         case BFD_RELOC_PPC64_TOC16_HA:
5828 #endif
5829           if (fixP->fx_pcrel)
5830             {
5831               if (fixP->fx_addsy != NULL)
5832                 as_bad_where (fixP->fx_file, fixP->fx_line,
5833                               _("cannot emit PC relative %s relocation against %s"),
5834                               bfd_get_reloc_code_name (fixP->fx_r_type),
5835                               S_GET_NAME (fixP->fx_addsy));
5836               else
5837                 as_bad_where (fixP->fx_file, fixP->fx_line,
5838                               _("cannot emit PC relative %s relocation"),
5839                               bfd_get_reloc_code_name (fixP->fx_r_type));
5840             }
5841
5842           md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
5843                               value, 2);
5844           break;
5845
5846         case BFD_RELOC_16:
5847           if (fixP->fx_pcrel)
5848             fixP->fx_r_type = BFD_RELOC_16_PCREL;
5849           /* fall through */
5850
5851         case BFD_RELOC_16_PCREL:
5852           md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
5853                               value, 2);
5854           break;
5855
5856         case BFD_RELOC_LO16:
5857           if (fixP->fx_pcrel)
5858             fixP->fx_r_type = BFD_RELOC_LO16_PCREL;
5859           /* fall through */
5860
5861         case BFD_RELOC_LO16_PCREL:
5862           md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
5863                               value, 2);
5864           break;
5865
5866           /* This case happens when you write, for example,
5867              lis %r3,(L1-L2)@ha
5868              where L1 and L2 are defined later.  */
5869         case BFD_RELOC_HI16:
5870           if (fixP->fx_pcrel)
5871             fixP->fx_r_type = BFD_RELOC_HI16_PCREL;
5872           /* fall through */
5873
5874         case BFD_RELOC_HI16_PCREL:
5875           md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
5876                               PPC_HI (value), 2);
5877           break;
5878
5879         case BFD_RELOC_HI16_S:
5880           if (fixP->fx_pcrel)
5881             fixP->fx_r_type = BFD_RELOC_HI16_S_PCREL;
5882           /* fall through */
5883
5884         case BFD_RELOC_HI16_S_PCREL:
5885           md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
5886                               PPC_HA (value), 2);
5887           break;
5888
5889 #ifdef OBJ_ELF
5890         case BFD_RELOC_PPC64_HIGHER:
5891           if (fixP->fx_pcrel)
5892             abort ();
5893           md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
5894                               PPC_HIGHER (value), 2);
5895           break;
5896
5897         case BFD_RELOC_PPC64_HIGHER_S:
5898           if (fixP->fx_pcrel)
5899             abort ();
5900           md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
5901                               PPC_HIGHERA (value), 2);
5902           break;
5903
5904         case BFD_RELOC_PPC64_HIGHEST:
5905           if (fixP->fx_pcrel)
5906             abort ();
5907           md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
5908                               PPC_HIGHEST (value), 2);
5909           break;
5910
5911         case BFD_RELOC_PPC64_HIGHEST_S:
5912           if (fixP->fx_pcrel)
5913             abort ();
5914           md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
5915                               PPC_HIGHESTA (value), 2);
5916           break;
5917
5918         case BFD_RELOC_PPC64_ADDR16_DS:
5919         case BFD_RELOC_PPC64_ADDR16_LO_DS:
5920         case BFD_RELOC_PPC64_GOT16_DS:
5921         case BFD_RELOC_PPC64_GOT16_LO_DS:
5922         case BFD_RELOC_PPC64_PLT16_LO_DS:
5923         case BFD_RELOC_PPC64_SECTOFF_DS:
5924         case BFD_RELOC_PPC64_SECTOFF_LO_DS:
5925         case BFD_RELOC_PPC64_TOC16_DS:
5926         case BFD_RELOC_PPC64_TOC16_LO_DS:
5927         case BFD_RELOC_PPC64_PLTGOT16_DS:
5928         case BFD_RELOC_PPC64_PLTGOT16_LO_DS:
5929           if (fixP->fx_pcrel)
5930             abort ();
5931           {
5932             char *where = fixP->fx_frag->fr_literal + fixP->fx_where;
5933             unsigned long val, mask;
5934
5935             if (target_big_endian)
5936               val = bfd_getb32 (where - 2);
5937             else
5938               val = bfd_getl32 (where);
5939             mask = 0xfffc;
5940             /* lq insns reserve the four lsbs.  */
5941             if ((ppc_cpu & PPC_OPCODE_POWER4) != 0
5942                 && (val & (0x3f << 26)) == (56u << 26))
5943               mask = 0xfff0;
5944             val |= value & mask;
5945             if (target_big_endian)
5946               bfd_putb16 ((bfd_vma) val, where);
5947             else
5948               bfd_putl16 ((bfd_vma) val, where);
5949           }
5950           break;
5951
5952         case BFD_RELOC_PPC_B16_BRTAKEN:
5953         case BFD_RELOC_PPC_B16_BRNTAKEN:
5954         case BFD_RELOC_PPC_BA16_BRTAKEN:
5955         case BFD_RELOC_PPC_BA16_BRNTAKEN:
5956           break;
5957
5958         case BFD_RELOC_PPC_TLS:
5959         case BFD_RELOC_PPC_TLSLD:
5960         case BFD_RELOC_PPC_TLSGD:
5961           break;
5962
5963         case BFD_RELOC_PPC_DTPMOD:
5964         case BFD_RELOC_PPC_TPREL16:
5965         case BFD_RELOC_PPC_TPREL16_LO:
5966         case BFD_RELOC_PPC_TPREL16_HI:
5967         case BFD_RELOC_PPC_TPREL16_HA:
5968         case BFD_RELOC_PPC_TPREL:
5969         case BFD_RELOC_PPC_DTPREL16:
5970         case BFD_RELOC_PPC_DTPREL16_LO:
5971         case BFD_RELOC_PPC_DTPREL16_HI:
5972         case BFD_RELOC_PPC_DTPREL16_HA:
5973         case BFD_RELOC_PPC_DTPREL:
5974         case BFD_RELOC_PPC_GOT_TLSGD16:
5975         case BFD_RELOC_PPC_GOT_TLSGD16_LO:
5976         case BFD_RELOC_PPC_GOT_TLSGD16_HI:
5977         case BFD_RELOC_PPC_GOT_TLSGD16_HA:
5978         case BFD_RELOC_PPC_GOT_TLSLD16:
5979         case BFD_RELOC_PPC_GOT_TLSLD16_LO:
5980         case BFD_RELOC_PPC_GOT_TLSLD16_HI:
5981         case BFD_RELOC_PPC_GOT_TLSLD16_HA:
5982         case BFD_RELOC_PPC_GOT_TPREL16:
5983         case BFD_RELOC_PPC_GOT_TPREL16_LO:
5984         case BFD_RELOC_PPC_GOT_TPREL16_HI:
5985         case BFD_RELOC_PPC_GOT_TPREL16_HA:
5986         case BFD_RELOC_PPC_GOT_DTPREL16:
5987         case BFD_RELOC_PPC_GOT_DTPREL16_LO:
5988         case BFD_RELOC_PPC_GOT_DTPREL16_HI:
5989         case BFD_RELOC_PPC_GOT_DTPREL16_HA:
5990         case BFD_RELOC_PPC64_TPREL16_DS:
5991         case BFD_RELOC_PPC64_TPREL16_LO_DS:
5992         case BFD_RELOC_PPC64_TPREL16_HIGHER:
5993         case BFD_RELOC_PPC64_TPREL16_HIGHERA:
5994         case BFD_RELOC_PPC64_TPREL16_HIGHEST:
5995         case BFD_RELOC_PPC64_TPREL16_HIGHESTA:
5996         case BFD_RELOC_PPC64_DTPREL16_DS:
5997         case BFD_RELOC_PPC64_DTPREL16_LO_DS:
5998         case BFD_RELOC_PPC64_DTPREL16_HIGHER:
5999         case BFD_RELOC_PPC64_DTPREL16_HIGHERA:
6000         case BFD_RELOC_PPC64_DTPREL16_HIGHEST:
6001         case BFD_RELOC_PPC64_DTPREL16_HIGHESTA:
6002           S_SET_THREAD_LOCAL (fixP->fx_addsy);
6003           break;
6004 #endif
6005           /* Because SDA21 modifies the register field, the size is set to 4
6006              bytes, rather than 2, so offset it here appropriately.  */
6007         case BFD_RELOC_PPC_EMB_SDA21:
6008           if (fixP->fx_pcrel)
6009             abort ();
6010
6011           md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where
6012                               + ((target_big_endian) ? 2 : 0),
6013                               value, 2);
6014           break;
6015
6016         case BFD_RELOC_8:
6017           if (fixP->fx_pcrel)
6018             {
6019               /* This can occur if there is a bug in the input assembler, eg:
6020                  ".byte <undefined_symbol> - ."  */
6021               if (fixP->fx_addsy)
6022                 as_bad (_("Unable to handle reference to symbol %s"),
6023                         S_GET_NAME (fixP->fx_addsy));
6024               else
6025                 as_bad (_("Unable to resolve expression"));
6026               fixP->fx_done = 1;
6027             }
6028           else
6029             md_number_to_chars (fixP->fx_frag->fr_literal + fixP->fx_where,
6030                                 value, 1);
6031           break;
6032
6033         case BFD_RELOC_24_PLT_PCREL:
6034         case BFD_RELOC_PPC_LOCAL24PC:
6035           if (!fixP->fx_pcrel && !fixP->fx_done)
6036             abort ();
6037
6038           if (fixP->fx_done)
6039             {
6040               char *where;
6041               unsigned long insn;
6042
6043               /* Fetch the instruction, insert the fully resolved operand
6044                  value, and stuff the instruction back again.  */
6045               where = fixP->fx_frag->fr_literal + fixP->fx_where;
6046               if (target_big_endian)
6047                 insn = bfd_getb32 ((unsigned char *) where);
6048               else
6049                 insn = bfd_getl32 ((unsigned char *) where);
6050               if ((value & 3) != 0)
6051                 as_bad_where (fixP->fx_file, fixP->fx_line,
6052                               _("must branch to an address a multiple of 4"));
6053               if ((offsetT) value < -0x40000000
6054                   || (offsetT) value >= 0x40000000)
6055                 as_bad_where (fixP->fx_file, fixP->fx_line,
6056                               _("@local or @plt branch destination is too far away, %ld bytes"),
6057                               (long) value);
6058               insn = insn | (value & 0x03fffffc);
6059               if (target_big_endian)
6060                 bfd_putb32 ((bfd_vma) insn, (unsigned char *) where);
6061               else
6062                 bfd_putl32 ((bfd_vma) insn, (unsigned char *) where);
6063             }
6064           break;
6065
6066         case BFD_RELOC_VTABLE_INHERIT:
6067           fixP->fx_done = 0;
6068           if (fixP->fx_addsy
6069               && !S_IS_DEFINED (fixP->fx_addsy)
6070               && !S_IS_WEAK (fixP->fx_addsy))
6071             S_SET_WEAK (fixP->fx_addsy);
6072           break;
6073
6074         case BFD_RELOC_VTABLE_ENTRY:
6075           fixP->fx_done = 0;
6076           break;
6077
6078 #ifdef OBJ_ELF
6079           /* Generated by reference to `sym@tocbase'.  The sym is
6080              ignored by the linker.  */
6081         case BFD_RELOC_PPC64_TOC:
6082           fixP->fx_done = 0;
6083           break;
6084 #endif
6085         default:
6086           fprintf (stderr,
6087                    _("Gas failure, reloc value %d\n"), fixP->fx_r_type);
6088           fflush (stderr);
6089           abort ();
6090         }
6091     }
6092
6093 #ifdef OBJ_ELF
6094   fixP->fx_addnumber = value;
6095
6096   /* PowerPC uses RELA relocs, ie. the reloc addend is stored separately
6097      from the section contents.  If we are going to be emitting a reloc
6098      then the section contents are immaterial, so don't warn if they
6099      happen to overflow.  Leave such warnings to ld.  */
6100   if (!fixP->fx_done)
6101     fixP->fx_no_overflow = 1;
6102 #else
6103   if (fixP->fx_r_type != BFD_RELOC_PPC_TOC16)
6104     fixP->fx_addnumber = 0;
6105   else
6106     {
6107 #ifdef TE_PE
6108       fixP->fx_addnumber = 0;
6109 #else
6110       /* We want to use the offset within the data segment of the
6111          symbol, not the actual VMA of the symbol.  */
6112       fixP->fx_addnumber =
6113         - bfd_get_section_vma (stdoutput, S_GET_SEGMENT (fixP->fx_addsy));
6114 #endif
6115     }
6116 #endif
6117 }
6118
6119 /* Generate a reloc for a fixup.  */
6120
6121 arelent *
6122 tc_gen_reloc (asection *seg ATTRIBUTE_UNUSED, fixS *fixp)
6123 {
6124   arelent *reloc;
6125
6126   reloc = (arelent *) xmalloc (sizeof (arelent));
6127
6128   reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
6129   *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
6130   reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
6131   reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
6132   if (reloc->howto == (reloc_howto_type *) NULL)
6133     {
6134       as_bad_where (fixp->fx_file, fixp->fx_line,
6135                     _("reloc %d not supported by object file format"),
6136                     (int) fixp->fx_r_type);
6137       return NULL;
6138     }
6139   reloc->addend = fixp->fx_addnumber;
6140
6141   return reloc;
6142 }
6143
6144 void
6145 ppc_cfi_frame_initial_instructions (void)
6146 {
6147   cfi_add_CFA_def_cfa (1, 0);
6148 }
6149
6150 int
6151 tc_ppc_regname_to_dw2regnum (char *regname)
6152 {
6153   unsigned int regnum = -1;
6154   unsigned int i;
6155   const char *p;
6156   char *q;
6157   static struct { char *name; int dw2regnum; } regnames[] =
6158     {
6159       { "sp", 1 }, { "r.sp", 1 }, { "rtoc", 2 }, { "r.toc", 2 },
6160       { "mq", 64 }, { "lr", 65 }, { "ctr", 66 }, { "ap", 67 },
6161       { "cr", 70 }, { "xer", 76 }, { "vrsave", 109 }, { "vscr", 110 },
6162       { "spe_acc", 111 }, { "spefscr", 112 }
6163     };
6164
6165   for (i = 0; i < ARRAY_SIZE (regnames); ++i)
6166     if (strcmp (regnames[i].name, regname) == 0)
6167       return regnames[i].dw2regnum;
6168
6169   if (regname[0] == 'r' || regname[0] == 'f' || regname[0] == 'v')
6170     {
6171       p = regname + 1 + (regname[1] == '.');
6172       regnum = strtoul (p, &q, 10);
6173       if (p == q || *q || regnum >= 32)
6174         return -1;
6175       if (regname[0] == 'f')
6176         regnum += 32;
6177       else if (regname[0] == 'v')
6178         regnum += 77;
6179     }
6180   else if (regname[0] == 'c' && regname[1] == 'r')
6181     {
6182       p = regname + 2 + (regname[2] == '.');
6183       if (p[0] < '0' || p[0] > '7' || p[1])
6184         return -1;
6185       regnum = p[0] - '0' + 68;
6186     }
6187   return regnum;
6188 }