gas/config/tc-ppc.c

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