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