gas/config/tc-ppc.c

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