gas/config/tc-ppc.c

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