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