gas/config/tc-ppc.c

   1 /* tc-ppc.c -- Assemble for the PowerPC or POWER (RS/6000)
   2    Copyright (C) 1994, 1995, 1996, 1997, 1998, 1999, 2000
   3    Free Software Foundation, Inc.
   4    Written by Ian Lance Taylor, Cygnus Support.
   5
   6    This file is part of GAS, the GNU Assembler.
   7
   8    GAS is free software; you can redistribute it and/or modify
   9    it under the terms of the GNU General Public License as published by
  10    the Free Software Foundation; either version 2, or (at your option)
  11    any later version.
  12
  13    GAS is distributed in the hope that it will be useful,
  14    but WITHOUT ANY WARRANTY; without even the implied warranty of
  15    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16    GNU General Public License for more details.
  17
  18    You should have received a copy of the GNU General Public License
  19    along with GAS; see the file COPYING.  If not, write to the Free
  20    Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  21    02111-1307, USA.  */
  22
  23 #include <stdio.h>
  24 #include <ctype.h>
  25 #include "as.h"
  26 #include "subsegs.h"
  27
  28 #include "opcode/ppc.h"
  29
  30 #ifdef OBJ_ELF
  31 #include "elf/ppc.h"
  32 #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     symbol_get_tc (sym)->within = ppc_current_block;
2850
2851   if (exp.X_op != O_symbol
2852       || ! S_IS_EXTERNAL (exp.X_add_symbol)
2853       || S_GET_SEGMENT (exp.X_add_symbol) != bss_section)
2854     ppc_frob_label (sym);
2855   else
2856     {
2857       symbol_remove (sym, &symbol_rootP, &symbol_lastP);
2858       symbol_append (sym, exp.X_add_symbol, &symbol_rootP, &symbol_lastP);
2859       if (symbol_get_tc (ppc_current_csect)->within == exp.X_add_symbol)
2860         symbol_get_tc (ppc_current_csect)->within = sym;
2861     }
2862
2863   demand_empty_rest_of_line ();
2864 }
2865
2866 /* The .function pseudo-op.  This takes several arguments.  The first
2867    argument seems to be the external name of the symbol.  The second
2868    argment seems to be the label for the start of the function.  gcc
2869    uses the same name for both.  I have no idea what the third and
2870    fourth arguments are meant to be.  The optional fifth argument is
2871    an expression for the size of the function.  In COFF this symbol
2872    gets an aux entry like that used for a csect.  */
2873
2874 static void
2875 ppc_function (ignore)
2876      int ignore ATTRIBUTE_UNUSED;
2877 {
2878   char *name;
2879   char endc;
2880   char *s;
2881   symbolS *ext_sym;
2882   symbolS *lab_sym;
2883
2884   name = input_line_pointer;
2885   endc = get_symbol_end ();
2886
2887   /* Ignore any [PR] suffix.  */
2888   name = ppc_canonicalize_symbol_name (name);
2889   s = strchr (name, '[');
2890   if (s != (char *) NULL
2891       && strcmp (s + 1, "PR]") == 0)
2892     *s = '\0';
2893
2894   ext_sym = symbol_find_or_make (name);
2895
2896   *input_line_pointer = endc;
2897
2898   if (*input_line_pointer != ',')
2899     {
2900       as_bad (_("missing symbol name"));
2901       ignore_rest_of_line ();
2902       return;
2903     }
2904   ++input_line_pointer;
2905
2906   name = input_line_pointer;
2907   endc = get_symbol_end ();
2908
2909   lab_sym = symbol_find_or_make (name);
2910
2911   *input_line_pointer = endc;
2912
2913   if (ext_sym != lab_sym)
2914     {
2915       expressionS exp;
2916
2917       exp.X_op = O_symbol;
2918       exp.X_add_symbol = lab_sym;
2919       exp.X_op_symbol = NULL;
2920       exp.X_add_number = 0;
2921       exp.X_unsigned = 0;
2922       symbol_set_value_expression (ext_sym, &exp);
2923     }
2924
2925   if (symbol_get_tc (ext_sym)->class == -1)
2926     symbol_get_tc (ext_sym)->class = XMC_PR;
2927   symbol_get_tc (ext_sym)->output = 1;
2928
2929   if (*input_line_pointer == ',')
2930     {
2931       expressionS ignore;
2932
2933       /* Ignore the third argument.  */
2934       ++input_line_pointer;
2935       expression (&ignore);
2936       if (*input_line_pointer == ',')
2937         {
2938           /* Ignore the fourth argument.  */
2939           ++input_line_pointer;
2940           expression (&ignore);
2941           if (*input_line_pointer == ',')
2942             {
2943               /* The fifth argument is the function size.  */
2944               ++input_line_pointer;
2945               symbol_get_tc (ext_sym)->size = symbol_new ("L0\001",
2946                                                           absolute_section,
2947                                                           (valueT) 0,
2948                                                           &zero_address_frag);
2949               pseudo_set (symbol_get_tc (ext_sym)->size);
2950             }
2951         }
2952     }
2953
2954   S_SET_DATA_TYPE (ext_sym, DT_FCN << N_BTSHFT);
2955   SF_SET_FUNCTION (ext_sym);
2956   SF_SET_PROCESS (ext_sym);
2957   coff_add_linesym (ext_sym);
2958
2959   demand_empty_rest_of_line ();
2960 }
2961
2962 /* The .bf pseudo-op.  This is just like a COFF C_FCN symbol named
2963    ".bf".  */
2964
2965 static void
2966 ppc_bf (ignore)
2967      int ignore ATTRIBUTE_UNUSED;
2968 {
2969   symbolS *sym;
2970
2971   sym = symbol_make (".bf");
2972   S_SET_SEGMENT (sym, text_section);
2973   symbol_set_frag (sym, frag_now);
2974   S_SET_VALUE (sym, frag_now_fix ());
2975   S_SET_STORAGE_CLASS (sym, C_FCN);
2976
2977   coff_line_base = get_absolute_expression ();
2978
2979   S_SET_NUMBER_AUXILIARY (sym, 1);
2980   SA_SET_SYM_LNNO (sym, coff_line_base);
2981
2982   symbol_get_tc (sym)->output = 1;
2983
2984   ppc_frob_label (sym);
2985
2986   demand_empty_rest_of_line ();
2987 }
2988
2989 /* The .ef pseudo-op.  This is just like a COFF C_FCN symbol named
2990    ".ef", except that the line number is absolute, not relative to the
2991    most recent ".bf" symbol.  */
2992
2993 static void
2994 ppc_ef (ignore)
2995      int ignore ATTRIBUTE_UNUSED;
2996 {
2997   symbolS *sym;
2998
2999   sym = symbol_make (".ef");
3000   S_SET_SEGMENT (sym, text_section);
3001   symbol_set_frag (sym, frag_now);
3002   S_SET_VALUE (sym, frag_now_fix ());
3003   S_SET_STORAGE_CLASS (sym, C_FCN);
3004   S_SET_NUMBER_AUXILIARY (sym, 1);
3005   SA_SET_SYM_LNNO (sym, get_absolute_expression ());
3006   symbol_get_tc (sym)->output = 1;
3007
3008   ppc_frob_label (sym);
3009
3010   demand_empty_rest_of_line ();
3011 }
3012
3013 /* The .bi and .ei pseudo-ops.  These take a string argument and
3014    generates a C_BINCL or C_EINCL symbol, which goes at the start of
3015    the symbol list.  */
3016
3017 static void
3018 ppc_biei (ei)
3019      int ei;
3020 {
3021   static symbolS *last_biei;
3022
3023   char *name;
3024   int len;
3025   symbolS *sym;
3026   symbolS *look;
3027
3028   name = demand_copy_C_string (&len);
3029
3030   /* The value of these symbols is actually file offset.  Here we set
3031      the value to the index into the line number entries.  In
3032      ppc_frob_symbols we set the fix_line field, which will cause BFD
3033      to do the right thing.  */
3034
3035   sym = symbol_make (name);
3036   /* obj-coff.c currently only handles line numbers correctly in the
3037      .text section.  */
3038   S_SET_SEGMENT (sym, text_section);
3039   S_SET_VALUE (sym, coff_n_line_nos);
3040   symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
3041
3042   S_SET_STORAGE_CLASS (sym, ei ? C_EINCL : C_BINCL);
3043   symbol_get_tc (sym)->output = 1;
3044
3045   for (look = last_biei ? last_biei : symbol_rootP;
3046        (look != (symbolS *) NULL
3047         && (S_GET_STORAGE_CLASS (look) == C_FILE
3048             || S_GET_STORAGE_CLASS (look) == C_BINCL
3049             || S_GET_STORAGE_CLASS (look) == C_EINCL));
3050        look = symbol_next (look))
3051     ;
3052   if (look != (symbolS *) NULL)
3053     {
3054       symbol_remove (sym, &symbol_rootP, &symbol_lastP);
3055       symbol_insert (sym, look, &symbol_rootP, &symbol_lastP);
3056       last_biei = sym;
3057     }
3058
3059   demand_empty_rest_of_line ();
3060 }
3061
3062 /* The .bs pseudo-op.  This generates a C_BSTAT symbol named ".bs".
3063    There is one argument, which is a csect symbol.  The value of the
3064    .bs symbol is the index of this csect symbol.  */
3065
3066 static void
3067 ppc_bs (ignore)
3068      int ignore ATTRIBUTE_UNUSED;
3069 {
3070   char *name;
3071   char endc;
3072   symbolS *csect;
3073   symbolS *sym;
3074
3075   if (ppc_current_block != NULL)
3076     as_bad (_("nested .bs blocks"));
3077
3078   name = input_line_pointer;
3079   endc = get_symbol_end ();
3080
3081   csect = symbol_find_or_make (name);
3082
3083   *input_line_pointer = endc;
3084
3085   sym = symbol_make (".bs");
3086   S_SET_SEGMENT (sym, now_seg);
3087   S_SET_STORAGE_CLASS (sym, C_BSTAT);
3088   symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
3089   symbol_get_tc (sym)->output = 1;
3090
3091   symbol_get_tc (sym)->within = csect;
3092
3093   ppc_frob_label (sym);
3094
3095   ppc_current_block = sym;
3096
3097   demand_empty_rest_of_line ();
3098 }
3099
3100 /* The .es pseudo-op.  Generate a C_ESTART symbol named .es.  */
3101
3102 static void
3103 ppc_es (ignore)
3104      int ignore ATTRIBUTE_UNUSED;
3105 {
3106   symbolS *sym;
3107
3108   if (ppc_current_block == NULL)
3109     as_bad (_(".es without preceding .bs"));
3110
3111   sym = symbol_make (".es");
3112   S_SET_SEGMENT (sym, now_seg);
3113   S_SET_STORAGE_CLASS (sym, C_ESTAT);
3114   symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
3115   symbol_get_tc (sym)->output = 1;
3116
3117   ppc_frob_label (sym);
3118
3119   ppc_current_block = NULL;
3120
3121   demand_empty_rest_of_line ();
3122 }
3123
3124 /* The .bb pseudo-op.  Generate a C_BLOCK symbol named .bb, with a
3125    line number.  */
3126
3127 static void
3128 ppc_bb (ignore)
3129      int ignore ATTRIBUTE_UNUSED;
3130 {
3131   symbolS *sym;
3132
3133   sym = symbol_make (".bb");
3134   S_SET_SEGMENT (sym, text_section);
3135   symbol_set_frag (sym, frag_now);
3136   S_SET_VALUE (sym, frag_now_fix ());
3137   S_SET_STORAGE_CLASS (sym, C_BLOCK);
3138
3139   S_SET_NUMBER_AUXILIARY (sym, 1);
3140   SA_SET_SYM_LNNO (sym, get_absolute_expression ());
3141
3142   symbol_get_tc (sym)->output = 1;
3143
3144   SF_SET_PROCESS (sym);
3145
3146   ppc_frob_label (sym);
3147
3148   demand_empty_rest_of_line ();
3149 }
3150
3151 /* The .eb pseudo-op.  Generate a C_BLOCK symbol named .eb, with a
3152    line number.  */
3153
3154 static void
3155 ppc_eb (ignore)
3156      int ignore ATTRIBUTE_UNUSED;
3157 {
3158   symbolS *sym;
3159
3160   sym = symbol_make (".eb");
3161   S_SET_SEGMENT (sym, text_section);
3162   symbol_set_frag (sym, frag_now);
3163   S_SET_VALUE (sym, frag_now_fix ());
3164   S_SET_STORAGE_CLASS (sym, C_BLOCK);
3165   S_SET_NUMBER_AUXILIARY (sym, 1);
3166   SA_SET_SYM_LNNO (sym, get_absolute_expression ());
3167   symbol_get_tc (sym)->output = 1;
3168
3169   SF_SET_PROCESS (sym);
3170
3171   ppc_frob_label (sym);
3172
3173   demand_empty_rest_of_line ();
3174 }
3175
3176 /* The .bc pseudo-op.  This just creates a C_BCOMM symbol with a
3177    specified name.  */
3178
3179 static void
3180 ppc_bc (ignore)
3181      int ignore ATTRIBUTE_UNUSED;
3182 {
3183   char *name;
3184   int len;
3185   symbolS *sym;
3186
3187   name = demand_copy_C_string (&len);
3188   sym = symbol_make (name);
3189   S_SET_SEGMENT (sym, ppc_coff_debug_section);
3190   symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
3191   S_SET_STORAGE_CLASS (sym, C_BCOMM);
3192   S_SET_VALUE (sym, 0);
3193   symbol_get_tc (sym)->output = 1;
3194
3195   ppc_frob_label (sym);
3196
3197   demand_empty_rest_of_line ();
3198 }
3199
3200 /* The .ec pseudo-op.  This just creates a C_ECOMM symbol.  */
3201
3202 static void
3203 ppc_ec (ignore)
3204      int ignore ATTRIBUTE_UNUSED;
3205 {
3206   symbolS *sym;
3207
3208   sym = symbol_make (".ec");
3209   S_SET_SEGMENT (sym, ppc_coff_debug_section);
3210   symbol_get_bfdsym (sym)->flags |= BSF_DEBUGGING;
3211   S_SET_STORAGE_CLASS (sym, C_ECOMM);
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 .toc pseudo-op.  Switch to the .toc subsegment.  */
3221
3222 static void
3223 ppc_toc (ignore)
3224      int ignore ATTRIBUTE_UNUSED;
3225 {
3226   if (ppc_toc_csect != (symbolS *) NULL)
3227     subseg_set (data_section, symbol_get_tc (ppc_toc_csect)->subseg);
3228   else
3229     {
3230       subsegT subseg;
3231       symbolS *sym;
3232       symbolS *list;
3233
3234       subseg = ppc_data_subsegment;
3235       ++ppc_data_subsegment;
3236
3237       subseg_new (segment_name (data_section), subseg);
3238       ppc_toc_frag = frag_now;
3239
3240       sym = symbol_find_or_make ("TOC[TC0]");
3241       symbol_set_frag (sym, frag_now);
3242       S_SET_SEGMENT (sym, data_section);
3243       S_SET_VALUE (sym, (valueT) frag_now_fix ());
3244       symbol_get_tc (sym)->subseg = subseg;
3245       symbol_get_tc (sym)->output = 1;
3246       symbol_get_tc (sym)->within = sym;
3247
3248       ppc_toc_csect = sym;
3249
3250       for (list = ppc_data_csects;
3251            symbol_get_tc (list)->next != (symbolS *) NULL;
3252            list = symbol_get_tc (list)->next)
3253         ;
3254       symbol_get_tc (list)->next = sym;
3255
3256       symbol_remove (sym, &symbol_rootP, &symbol_lastP);
3257       symbol_append (sym, symbol_get_tc (list)->within, &symbol_rootP,
3258                      &symbol_lastP);
3259     }
3260
3261   ppc_current_csect = ppc_toc_csect;
3262
3263   demand_empty_rest_of_line ();
3264 }
3265
3266 /* The AIX assembler automatically aligns the operands of a .long or
3267    .short pseudo-op, and we want to be compatible.  */
3268
3269 static void
3270 ppc_xcoff_cons (log_size)
3271      int log_size;
3272 {
3273   frag_align (log_size, 0, 0);
3274   record_alignment (now_seg, log_size);
3275   cons (1 << log_size);
3276 }
3277
3278 static void
3279 ppc_machine(dummy)
3280     int dummy ATTRIBUTE_UNUSED;
3281 {
3282     discard_rest_of_line();
3283    /* What does aix use this for?  */
3284 }
3285
3286 static void
3287 ppc_vbyte (dummy)
3288      int dummy ATTRIBUTE_UNUSED;
3289 {
3290   expressionS exp;
3291   int byte_count;
3292
3293   (void) expression (&exp);
3294
3295   if (exp.X_op != O_constant)
3296     {
3297       as_bad (_("non-constant byte count"));
3298       return;
3299     }
3300
3301   byte_count = exp.X_add_number;
3302
3303   if (*input_line_pointer != ',')
3304     {
3305       as_bad (_("missing value"));
3306       return;
3307     }
3308
3309   ++input_line_pointer;
3310   cons (byte_count);
3311 }
3312
3313 #endif /* OBJ_XCOFF */
3314 \f
3315 /* The .tc pseudo-op.  This is used when generating either XCOFF or
3316    ELF.  This takes two or more arguments.
3317
3318    When generating XCOFF output, the first argument is the name to
3319    give to this location in the toc; this will be a symbol with class
3320    TC.  The rest of the arguments are 4 byte values to actually put at
3321    this location in the TOC; often there is just one more argument, a
3322    relocateable symbol reference.
3323
3324    When not generating XCOFF output, the arguments are the same, but
3325    the first argument is simply ignored.  */
3326
3327 static void
3328 ppc_tc (ignore)
3329      int ignore ATTRIBUTE_UNUSED;
3330 {
3331 #ifdef OBJ_XCOFF
3332
3333   /* Define the TOC symbol name.  */
3334   {
3335     char *name;
3336     char endc;
3337     symbolS *sym;
3338
3339     if (ppc_toc_csect == (symbolS *) NULL
3340         || ppc_toc_csect != ppc_current_csect)
3341       {
3342         as_bad (_(".tc not in .toc section"));
3343         ignore_rest_of_line ();
3344         return;
3345       }
3346
3347     name = input_line_pointer;
3348     endc = get_symbol_end ();
3349
3350     sym = symbol_find_or_make (name);
3351
3352     *input_line_pointer = endc;
3353
3354     if (S_IS_DEFINED (sym))
3355       {
3356         symbolS *label;
3357
3358         label = symbol_get_tc (ppc_current_csect)->within;
3359         if (symbol_get_tc (label)->class != XMC_TC0)
3360           {
3361             as_bad (_(".tc with no label"));
3362             ignore_rest_of_line ();
3363             return;
3364           }
3365
3366         S_SET_SEGMENT (label, S_GET_SEGMENT (sym));
3367         symbol_set_frag (label, symbol_get_frag (sym));
3368         S_SET_VALUE (label, S_GET_VALUE (sym));
3369
3370         while (! is_end_of_line[(unsigned char) *input_line_pointer])
3371           ++input_line_pointer;
3372
3373         return;
3374       }
3375
3376     S_SET_SEGMENT (sym, now_seg);
3377     symbol_set_frag (sym, frag_now);
3378     S_SET_VALUE (sym, (valueT) frag_now_fix ());
3379     symbol_get_tc (sym)->class = XMC_TC;
3380     symbol_get_tc (sym)->output = 1;
3381
3382     ppc_frob_label (sym);
3383   }
3384
3385 #else /* ! defined (OBJ_XCOFF) */
3386
3387   /* Skip the TOC symbol name.  */
3388   while (is_part_of_name (*input_line_pointer)
3389          || *input_line_pointer == '['
3390          || *input_line_pointer == ']'
3391          || *input_line_pointer == '{'
3392          || *input_line_pointer == '}')
3393     ++input_line_pointer;
3394
3395   /* Align to a four byte boundary.  */
3396   frag_align (2, 0, 0);
3397   record_alignment (now_seg, 2);
3398
3399 #endif /* ! defined (OBJ_XCOFF) */
3400
3401   if (*input_line_pointer != ',')
3402     demand_empty_rest_of_line ();
3403   else
3404     {
3405       ++input_line_pointer;
3406       cons ((ppc_size == PPC_OPCODE_64) ? 8 : 4);
3407     }
3408 }
3409 \f
3410 #ifdef TE_PE
3411
3412 /* Pseudo-ops specific to the Windows NT PowerPC PE (coff) format */
3413
3414 /* Set the current section.  */
3415 static void
3416 ppc_set_current_section (new)
3417      segT new;
3418 {
3419   ppc_previous_section = ppc_current_section;
3420   ppc_current_section = new;
3421 }
3422
3423 /* pseudo-op: .previous
3424    behaviour: toggles the current section with the previous section.
3425    errors:    None
3426    warnings:  "No previous section"
3427 */
3428 static void
3429 ppc_previous(ignore)
3430      int ignore ATTRIBUTE_UNUSED;
3431 {
3432   symbolS *tmp;
3433
3434   if (ppc_previous_section == NULL)
3435     {
3436       as_warn(_("No previous section to return to. Directive ignored."));
3437       return;
3438     }
3439
3440   subseg_set(ppc_previous_section, 0);
3441
3442   ppc_set_current_section(ppc_previous_section);
3443 }
3444
3445 /* pseudo-op: .pdata
3446    behaviour: predefined read only data section
3447               double word aligned
3448    errors:    None
3449    warnings:  None
3450    initial:   .section .pdata "adr3"
3451               a - don't know -- maybe a misprint
3452               d - initialized data
3453               r - readable
3454               3 - double word aligned (that would be 4 byte boundary)
3455
3456    commentary:
3457    Tag index tables (also known as the function table) for exception
3458    handling, debugging, etc.
3459
3460 */
3461 static void
3462 ppc_pdata(ignore)
3463      int ignore ATTRIBUTE_UNUSED;
3464 {
3465   if (pdata_section == 0)
3466     {
3467       pdata_section = subseg_new (".pdata", 0);
3468
3469       bfd_set_section_flags (stdoutput, pdata_section,
3470                              (SEC_ALLOC | SEC_LOAD | SEC_RELOC
3471                               | SEC_READONLY | SEC_DATA ));
3472
3473       bfd_set_section_alignment (stdoutput, pdata_section, 2);
3474     }
3475   else
3476     {
3477       pdata_section = subseg_new(".pdata", 0);
3478     }
3479   ppc_set_current_section(pdata_section);
3480 }
3481
3482 /* pseudo-op: .ydata
3483    behaviour: predefined read only data section
3484               double word aligned
3485    errors:    None
3486    warnings:  None
3487    initial:   .section .ydata "drw3"
3488               a - don't know -- maybe a misprint
3489               d - initialized data
3490               r - readable
3491               3 - double word aligned (that would be 4 byte boundary)
3492    commentary:
3493    Tag tables (also known as the scope table) for exception handling,
3494    debugging, etc.
3495 */
3496 static void
3497 ppc_ydata(ignore)
3498      int ignore ATTRIBUTE_UNUSED;
3499 {
3500   if (ydata_section == 0)
3501     {
3502       ydata_section = subseg_new (".ydata", 0);
3503       bfd_set_section_flags (stdoutput, ydata_section,
3504                          (SEC_ALLOC | SEC_LOAD | SEC_RELOC
3505                                        | SEC_READONLY | SEC_DATA ));
3506
3507       bfd_set_section_alignment (stdoutput, ydata_section, 3);
3508     }
3509   else
3510     {
3511       ydata_section = subseg_new (".ydata", 0);
3512     }
3513   ppc_set_current_section(ydata_section);
3514 }
3515
3516 /* pseudo-op: .reldata
3517    behaviour: predefined read write data section
3518               double word aligned (4-byte)
3519               FIXME: relocation is applied to it
3520               FIXME: what's the difference between this and .data?
3521    errors:    None
3522    warnings:  None
3523    initial:   .section .reldata "drw3"
3524               d - initialized data
3525               r - readable
3526               w - writeable
3527               3 - double word aligned (that would be 8 byte boundary)
3528
3529    commentary:
3530    Like .data, but intended to hold data subject to relocation, such as
3531    function descriptors, etc.
3532 */
3533 static void
3534 ppc_reldata(ignore)
3535      int ignore ATTRIBUTE_UNUSED;
3536 {
3537   if (reldata_section == 0)
3538     {
3539       reldata_section = subseg_new (".reldata", 0);
3540
3541       bfd_set_section_flags (stdoutput, reldata_section,
3542                              ( SEC_ALLOC | SEC_LOAD | SEC_RELOC
3543                               | SEC_DATA ));
3544
3545       bfd_set_section_alignment (stdoutput, reldata_section, 2);
3546     }
3547   else
3548     {
3549       reldata_section = subseg_new (".reldata", 0);
3550     }
3551   ppc_set_current_section(reldata_section);
3552 }
3553
3554 /* pseudo-op: .rdata
3555    behaviour: predefined read only data section
3556               double word aligned
3557    errors:    None
3558    warnings:  None
3559    initial:   .section .rdata "dr3"
3560               d - initialized data
3561               r - readable
3562               3 - double word aligned (that would be 4 byte boundary)
3563 */
3564 static void
3565 ppc_rdata(ignore)
3566      int ignore ATTRIBUTE_UNUSED;
3567 {
3568   if (rdata_section == 0)
3569     {
3570       rdata_section = subseg_new (".rdata", 0);
3571       bfd_set_section_flags (stdoutput, rdata_section,
3572                              (SEC_ALLOC | SEC_LOAD | SEC_RELOC
3573                               | SEC_READONLY | SEC_DATA ));
3574
3575       bfd_set_section_alignment (stdoutput, rdata_section, 2);
3576     }
3577   else
3578     {
3579       rdata_section = subseg_new (".rdata", 0);
3580     }
3581   ppc_set_current_section(rdata_section);
3582 }
3583
3584 /* pseudo-op: .ualong
3585    behaviour: much like .int, with the exception that no alignment is
3586               performed.
3587               FIXME: test the alignment statement
3588    errors:    None
3589    warnings:  None
3590 */
3591 static void
3592 ppc_ualong(ignore)
3593      int ignore ATTRIBUTE_UNUSED;
3594 {
3595   /* try for long */
3596   cons ( 4 );
3597 }
3598
3599 /* pseudo-op: .znop  <symbol name>
3600    behaviour: Issue a nop instruction
3601               Issue a IMAGE_REL_PPC_IFGLUE relocation against it, using
3602               the supplied symbol name.
3603    errors:    None
3604    warnings:  Missing symbol name
3605 */
3606 static void
3607 ppc_znop(ignore)
3608      int ignore ATTRIBUTE_UNUSED;
3609 {
3610   unsigned long insn;
3611   const struct powerpc_opcode *opcode;
3612   expressionS ex;
3613   char *f;
3614
3615   symbolS *sym;
3616
3617   /* Strip out the symbol name */
3618   char *symbol_name;
3619   char c;
3620   char *name;
3621   unsigned int exp;
3622   flagword flags;
3623   asection *sec;
3624
3625   symbol_name = input_line_pointer;
3626   c = get_symbol_end ();
3627
3628   name = xmalloc (input_line_pointer - symbol_name + 1);
3629   strcpy (name, symbol_name);
3630
3631   sym = symbol_find_or_make (name);
3632
3633   *input_line_pointer = c;
3634
3635   SKIP_WHITESPACE ();
3636
3637   /* Look up the opcode in the hash table.  */
3638   opcode = (const struct powerpc_opcode *) hash_find (ppc_hash, "nop");
3639
3640   /* stick in the nop */
3641   insn = opcode->opcode;
3642
3643   /* Write out the instruction.  */
3644   f = frag_more (4);
3645   md_number_to_chars (f, insn, 4);
3646   fix_new (frag_now,
3647            f - frag_now->fr_literal,
3648            4,
3649            sym,
3650            0,
3651            0,
3652            BFD_RELOC_16_GOT_PCREL);
3653
3654 }
3655
3656 /* pseudo-op:
3657    behaviour:
3658    errors:
3659    warnings:
3660 */
3661 static void
3662 ppc_pe_comm(lcomm)
3663      int lcomm;
3664 {
3665   register char *name;
3666   register char c;
3667   register char *p;
3668   offsetT temp;
3669   register symbolS *symbolP;
3670   offsetT align;
3671
3672   name = input_line_pointer;
3673   c = get_symbol_end ();
3674
3675   /* just after name is now '\0' */
3676   p = input_line_pointer;
3677   *p = c;
3678   SKIP_WHITESPACE ();
3679   if (*input_line_pointer != ',')
3680     {
3681       as_bad (_("Expected comma after symbol-name: rest of line ignored."));
3682       ignore_rest_of_line ();
3683       return;
3684     }
3685
3686   input_line_pointer++;         /* skip ',' */
3687   if ((temp = get_absolute_expression ()) < 0)
3688     {
3689       as_warn (_(".COMMon length (%ld.) <0! Ignored."), (long) temp);
3690       ignore_rest_of_line ();
3691       return;
3692     }
3693
3694   if (! lcomm)
3695     {
3696       /* The third argument to .comm is the alignment.  */
3697       if (*input_line_pointer != ',')
3698         align = 3;
3699       else
3700         {
3701           ++input_line_pointer;
3702           align = get_absolute_expression ();
3703           if (align <= 0)
3704             {
3705               as_warn (_("ignoring bad alignment"));
3706               align = 3;
3707             }
3708         }
3709     }
3710
3711   *p = 0;
3712   symbolP = symbol_find_or_make (name);
3713
3714   *p = c;
3715   if (S_IS_DEFINED (symbolP) && ! S_IS_COMMON (symbolP))
3716     {
3717       as_bad (_("Ignoring attempt to re-define symbol `%s'."),
3718               S_GET_NAME (symbolP));
3719       ignore_rest_of_line ();
3720       return;
3721     }
3722
3723   if (S_GET_VALUE (symbolP))
3724     {
3725       if (S_GET_VALUE (symbolP) != (valueT) temp)
3726         as_bad (_("Length of .comm \"%s\" is already %ld. Not changed to %ld."),
3727                 S_GET_NAME (symbolP),
3728                 (long) S_GET_VALUE (symbolP),
3729                 (long) temp);
3730     }
3731   else
3732     {
3733       S_SET_VALUE (symbolP, (valueT) temp);
3734       S_SET_EXTERNAL (symbolP);
3735     }
3736
3737   demand_empty_rest_of_line ();
3738 }
3739
3740 /*
3741  * implement the .section pseudo op:
3742  *      .section name {, "flags"}
3743  *                ^         ^
3744  *                |         +--- optional flags: 'b' for bss
3745  *                |                              'i' for info
3746  *                +-- section name               'l' for lib
3747  *                                               'n' for noload
3748  *                                               'o' for over
3749  *                                               'w' for data
3750  *                                               'd' (apparently m88k for data)
3751  *                                               'x' for text
3752  * But if the argument is not a quoted string, treat it as a
3753  * subsegment number.
3754  *
3755  * FIXME: this is a copy of the section processing from obj-coff.c, with
3756  * additions/changes for the moto-pas assembler support. There are three
3757  * categories:
3758  *
3759  * FIXME: I just noticed this. This doesn't work at all really. It it
3760  *        setting bits that bfd probably neither understands or uses. The
3761  *        correct approach (?) will have to incorporate extra fields attached
3762  *        to the section to hold the system specific stuff. (krk)
3763  *
3764  * Section Contents:
3765  * 'a' - unknown - referred to in documentation, but no definition supplied
3766  * 'c' - section has code
3767  * 'd' - section has initialized data
3768  * 'u' - section has uninitialized data
3769  * 'i' - section contains directives (info)
3770  * 'n' - section can be discarded
3771  * 'R' - remove section at link time
3772  *
3773  * Section Protection:
3774  * 'r' - section is readable
3775  * 'w' - section is writeable
3776  * 'x' - section is executable
3777  * 's' - section is sharable
3778  *
3779  * Section Alignment:
3780  * '0' - align to byte boundary
3781  * '1' - align to halfword undary
3782  * '2' - align to word boundary
3783  * '3' - align to doubleword boundary
3784  * '4' - align to quadword boundary
3785  * '5' - align to 32 byte boundary
3786  * '6' - align to 64 byte boundary
3787  *
3788  */
3789
3790 void
3791 ppc_pe_section (ignore)
3792      int ignore ATTRIBUTE_UNUSED;
3793 {
3794   /* Strip out the section name */
3795   char *section_name;
3796   char c;
3797   char *name;
3798   unsigned int exp;
3799   flagword flags;
3800   segT sec;
3801   int align;
3802
3803   section_name = input_line_pointer;
3804   c = get_symbol_end ();
3805
3806   name = xmalloc (input_line_pointer - section_name + 1);
3807   strcpy (name, section_name);
3808
3809   *input_line_pointer = c;
3810
3811   SKIP_WHITESPACE ();
3812
3813   exp = 0;
3814   flags = SEC_NO_FLAGS;
3815
3816   if (strcmp (name, ".idata$2") == 0)
3817     {
3818       align = 0;
3819     }
3820   else if (strcmp (name, ".idata$3") == 0)
3821     {
3822       align = 0;
3823     }
3824   else if (strcmp (name, ".idata$4") == 0)
3825     {
3826       align = 2;
3827     }
3828   else if (strcmp (name, ".idata$5") == 0)
3829     {
3830       align = 2;
3831     }
3832   else if (strcmp (name, ".idata$6") == 0)
3833     {
3834       align = 1;
3835     }
3836   else
3837     align = 4; /* default alignment to 16 byte boundary */
3838
3839   if (*input_line_pointer == ',')
3840     {
3841       ++input_line_pointer;
3842       SKIP_WHITESPACE ();
3843       if (*input_line_pointer != '"')
3844         exp = get_absolute_expression ();
3845       else
3846         {
3847           ++input_line_pointer;
3848           while (*input_line_pointer != '"'
3849                  && ! is_end_of_line[(unsigned char) *input_line_pointer])
3850             {
3851               switch (*input_line_pointer)
3852                 {
3853                   /* Section Contents */
3854                 case 'a': /* unknown */
3855                   as_bad (_("Unsupported section attribute -- 'a'"));
3856                   break;
3857                 case 'c': /* code section */
3858                   flags |= SEC_CODE;
3859                   break;
3860                 case 'd': /* section has initialized data */
3861                   flags |= SEC_DATA;
3862                   break;
3863                 case 'u': /* section has uninitialized data */
3864                   /* FIXME: This is IMAGE_SCN_CNT_UNINITIALIZED_DATA
3865                      in winnt.h */
3866                   flags |= SEC_ROM;
3867                   break;
3868                 case 'i': /* section contains directives (info) */
3869                   /* FIXME: This is IMAGE_SCN_LNK_INFO
3870                      in winnt.h */
3871                   flags |= SEC_HAS_CONTENTS;
3872                   break;
3873                 case 'n': /* section can be discarded */
3874                   flags &=~ SEC_LOAD;
3875                   break;
3876                 case 'R': /* Remove section at link time */
3877                   flags |= SEC_NEVER_LOAD;
3878                   break;
3879
3880                   /* Section Protection */
3881                 case 'r': /* section is readable */
3882                   flags |= IMAGE_SCN_MEM_READ;
3883                   break;
3884                 case 'w': /* section is writeable */
3885                   flags |= IMAGE_SCN_MEM_WRITE;
3886                   break;
3887                 case 'x': /* section is executable */
3888                   flags |= IMAGE_SCN_MEM_EXECUTE;
3889                   break;
3890                 case 's': /* section is sharable */
3891                   flags |= IMAGE_SCN_MEM_SHARED;
3892                   break;
3893
3894                   /* Section Alignment */
3895                 case '0': /* align to byte boundary */
3896                   flags |= IMAGE_SCN_ALIGN_1BYTES;
3897                   align = 0;
3898                   break;
3899                 case '1':  /* align to halfword boundary */
3900                   flags |= IMAGE_SCN_ALIGN_2BYTES;
3901                   align = 1;
3902                   break;
3903                 case '2':  /* align to word boundary */
3904                   flags |= IMAGE_SCN_ALIGN_4BYTES;
3905                   align = 2;
3906                   break;
3907                 case '3':  /* align to doubleword boundary */
3908                   flags |= IMAGE_SCN_ALIGN_8BYTES;
3909                   align = 3;
3910                   break;
3911                 case '4':  /* align to quadword boundary */
3912                   flags |= IMAGE_SCN_ALIGN_16BYTES;
3913                   align = 4;
3914                   break;
3915                 case '5':  /* align to 32 byte boundary */
3916                   flags |= IMAGE_SCN_ALIGN_32BYTES;
3917                   align = 5;
3918                   break;
3919                 case '6':  /* align to 64 byte boundary */
3920                   flags |= IMAGE_SCN_ALIGN_64BYTES;
3921                   align = 6;
3922                   break;
3923
3924                 default:
3925                   as_bad(_("unknown section attribute '%c'"),
3926                          *input_line_pointer);
3927                   break;
3928                 }
3929               ++input_line_pointer;
3930             }
3931           if (*input_line_pointer == '"')
3932             ++input_line_pointer;
3933         }
3934     }
3935
3936   sec = subseg_new (name, (subsegT) exp);
3937
3938   ppc_set_current_section(sec);
3939
3940   if (flags != SEC_NO_FLAGS)
3941     {
3942       if (! bfd_set_section_flags (stdoutput, sec, flags))
3943         as_bad (_("error setting flags for \"%s\": %s"),
3944                 bfd_section_name (stdoutput, sec),
3945                 bfd_errmsg (bfd_get_error ()));
3946     }
3947
3948   bfd_set_section_alignment(stdoutput, sec, align);
3949
3950 }
3951
3952 static void
3953 ppc_pe_function (ignore)
3954      int ignore ATTRIBUTE_UNUSED;
3955 {
3956   char *name;
3957   char endc;
3958   symbolS *ext_sym;
3959
3960   name = input_line_pointer;
3961   endc = get_symbol_end ();
3962
3963   ext_sym = symbol_find_or_make (name);
3964
3965   *input_line_pointer = endc;
3966
3967   S_SET_DATA_TYPE (ext_sym, DT_FCN << N_BTSHFT);
3968   SF_SET_FUNCTION (ext_sym);
3969   SF_SET_PROCESS (ext_sym);
3970   coff_add_linesym (ext_sym);
3971
3972   demand_empty_rest_of_line ();
3973 }
3974
3975 static void
3976 ppc_pe_tocd (ignore)
3977      int ignore ATTRIBUTE_UNUSED;
3978 {
3979   if (tocdata_section == 0)
3980     {
3981       tocdata_section = subseg_new (".tocd", 0);
3982       /* FIXME: section flags won't work */
3983       bfd_set_section_flags (stdoutput, tocdata_section,
3984                              (SEC_ALLOC | SEC_LOAD | SEC_RELOC
3985                               | SEC_READONLY | SEC_DATA ));
3986
3987       bfd_set_section_alignment (stdoutput, tocdata_section, 2);
3988     }
3989   else
3990     {
3991       rdata_section = subseg_new (".tocd", 0);
3992     }
3993
3994   ppc_set_current_section(tocdata_section);
3995
3996   demand_empty_rest_of_line ();
3997 }
3998
3999 /* Don't adjust TOC relocs to use the section symbol.  */
4000
4001 int
4002 ppc_pe_fix_adjustable (fix)
4003      fixS *fix;
4004 {
4005   return fix->fx_r_type != BFD_RELOC_PPC_TOC16;
4006 }
4007
4008 #endif
4009 \f
4010 #ifdef OBJ_XCOFF
4011
4012 /* XCOFF specific symbol and file handling.  */
4013
4014 /* Canonicalize the symbol name.  We use the to force the suffix, if
4015    any, to use square brackets, and to be in upper case.  */
4016
4017 char *
4018 ppc_canonicalize_symbol_name (name)
4019      char *name;
4020 {
4021   char *s;
4022
4023   if (ppc_stab_symbol)
4024     return name;
4025
4026   for (s = name; *s != '\0' && *s != '{' && *s != '['; s++)
4027     ;
4028   if (*s != '\0')
4029     {
4030       char brac;
4031
4032       if (*s == '[')
4033         brac = ']';
4034       else
4035         {
4036           *s = '[';
4037           brac = '}';
4038         }
4039
4040       for (s++; *s != '\0' && *s != brac; s++)
4041         if (islower (*s))
4042           *s = toupper (*s);
4043
4044       if (*s == '\0' || s[1] != '\0')
4045         as_bad (_("bad symbol suffix"));
4046
4047       *s = ']';
4048     }
4049
4050   return name;
4051 }
4052
4053 /* Set the class of a symbol based on the suffix, if any.  This is
4054    called whenever a new symbol is created.  */
4055
4056 void
4057 ppc_symbol_new_hook (sym)
4058      symbolS *sym;
4059 {
4060   struct ppc_tc_sy *tc;
4061   const char *s;
4062
4063   tc = symbol_get_tc (sym);
4064   tc->next = NULL;
4065   tc->output = 0;
4066   tc->class = -1;
4067   tc->real_name = NULL;
4068   tc->subseg = 0;
4069   tc->align = 0;
4070   tc->size = NULL;
4071   tc->within = NULL;
4072
4073   if (ppc_stab_symbol)
4074     return;
4075
4076   s = strchr (S_GET_NAME (sym), '[');
4077   if (s == (const char *) NULL)
4078     {
4079       /* There is no suffix.  */
4080       return;
4081     }
4082
4083   ++s;
4084
4085   switch (s[0])
4086     {
4087     case 'B':
4088       if (strcmp (s, "BS]") == 0)
4089         tc->class = XMC_BS;
4090       break;
4091     case 'D':
4092       if (strcmp (s, "DB]") == 0)
4093         tc->class = XMC_DB;
4094       else if (strcmp (s, "DS]") == 0)
4095         tc->class = XMC_DS;
4096       break;
4097     case 'G':
4098       if (strcmp (s, "GL]") == 0)
4099         tc->class = XMC_GL;
4100       break;
4101     case 'P':
4102       if (strcmp (s, "PR]") == 0)
4103         tc->class = XMC_PR;
4104       break;
4105     case 'R':
4106       if (strcmp (s, "RO]") == 0)
4107         tc->class = XMC_RO;
4108       else if (strcmp (s, "RW]") == 0)
4109         tc->class = XMC_RW;
4110       break;
4111     case 'S':
4112       if (strcmp (s, "SV]") == 0)
4113         tc->class = XMC_SV;
4114       break;
4115     case 'T':
4116       if (strcmp (s, "TC]") == 0)
4117         tc->class = XMC_TC;
4118       else if (strcmp (s, "TI]") == 0)
4119         tc->class = XMC_TI;
4120       else if (strcmp (s, "TB]") == 0)
4121         tc->class = XMC_TB;
4122       else if (strcmp (s, "TC0]") == 0 || strcmp (s, "T0]") == 0)
4123         tc->class = XMC_TC0;
4124       break;
4125     case 'U':
4126       if (strcmp (s, "UA]") == 0)
4127         tc->class = XMC_UA;
4128       else if (strcmp (s, "UC]") == 0)
4129         tc->class = XMC_UC;
4130       break;
4131     case 'X':
4132       if (strcmp (s, "XO]") == 0)
4133         tc->class = XMC_XO;
4134       break;
4135     }
4136
4137   if (tc->class == -1)
4138     as_bad (_("Unrecognized symbol suffix"));
4139 }
4140
4141 /* Set the class of a label based on where it is defined.  This
4142    handles symbols without suffixes.  Also, move the symbol so that it
4143    follows the csect symbol.  */
4144
4145 void
4146 ppc_frob_label (sym)
4147      symbolS *sym;
4148 {
4149   if (ppc_current_csect != (symbolS *) NULL)
4150     {
4151       if (symbol_get_tc (sym)->class == -1)
4152         symbol_get_tc (sym)->class = symbol_get_tc (ppc_current_csect)->class;
4153
4154       symbol_remove (sym, &symbol_rootP, &symbol_lastP);
4155       symbol_append (sym, symbol_get_tc (ppc_current_csect)->within,
4156                      &symbol_rootP, &symbol_lastP);
4157       symbol_get_tc (ppc_current_csect)->within = sym;
4158     }
4159 }
4160
4161 /* This variable is set by ppc_frob_symbol if any absolute symbols are
4162    seen.  It tells ppc_adjust_symtab whether it needs to look through
4163    the symbols.  */
4164
4165 static boolean ppc_saw_abs;
4166
4167 /* Change the name of a symbol just before writing it out.  Set the
4168    real name if the .rename pseudo-op was used.  Otherwise, remove any
4169    class suffix.  Return 1 if the symbol should not be included in the
4170    symbol table.  */
4171
4172 int
4173 ppc_frob_symbol (sym)
4174      symbolS *sym;
4175 {
4176   static symbolS *ppc_last_function;
4177   static symbolS *set_end;
4178
4179   /* Discard symbols that should not be included in the output symbol
4180      table.  */
4181   if (! symbol_used_in_reloc_p (sym)
4182       && ((symbol_get_bfdsym (sym)->flags & BSF_SECTION_SYM) != 0
4183           || (! S_IS_EXTERNAL (sym)
4184               && ! symbol_get_tc (sym)->output
4185               && S_GET_STORAGE_CLASS (sym) != C_FILE)))
4186     return 1;
4187
4188   if (symbol_get_tc (sym)->real_name != (char *) NULL)
4189     S_SET_NAME (sym, symbol_get_tc (sym)->real_name);
4190   else
4191     {
4192       const char *name;
4193       const char *s;
4194
4195       name = S_GET_NAME (sym);
4196       s = strchr (name, '[');
4197       if (s != (char *) NULL)
4198         {
4199           unsigned int len;
4200           char *snew;
4201
4202           len = s - name;
4203           snew = xmalloc (len + 1);
4204           memcpy (snew, name, len);
4205           snew[len] = '\0';
4206
4207           S_SET_NAME (sym, snew);
4208         }
4209     }
4210
4211   if (set_end != (symbolS *) NULL)
4212     {
4213       SA_SET_SYM_ENDNDX (set_end, sym);
4214       set_end = NULL;
4215     }
4216
4217   if (SF_GET_FUNCTION (sym))
4218     {
4219       if (ppc_last_function != (symbolS *) NULL)
4220         as_bad (_("two .function pseudo-ops with no intervening .ef"));
4221       ppc_last_function = sym;
4222       if (symbol_get_tc (sym)->size != (symbolS *) NULL)
4223         {
4224           resolve_symbol_value (symbol_get_tc (sym)->size, 1);
4225           SA_SET_SYM_FSIZE (sym,
4226                             (long) S_GET_VALUE (symbol_get_tc (sym)->size));
4227         }
4228     }
4229   else if (S_GET_STORAGE_CLASS (sym) == C_FCN
4230            && strcmp (S_GET_NAME (sym), ".ef") == 0)
4231     {
4232       if (ppc_last_function == (symbolS *) NULL)
4233         as_bad (_(".ef with no preceding .function"));
4234       else
4235         {
4236           set_end = ppc_last_function;
4237           ppc_last_function = NULL;
4238
4239           /* We don't have a C_EFCN symbol, but we need to force the
4240              COFF backend to believe that it has seen one.  */
4241           coff_last_function = NULL;
4242         }
4243     }
4244
4245   if (! S_IS_EXTERNAL (sym)
4246       && (symbol_get_bfdsym (sym)->flags & BSF_SECTION_SYM) == 0
4247       && S_GET_STORAGE_CLASS (sym) != C_FILE
4248       && S_GET_STORAGE_CLASS (sym) != C_FCN
4249       && S_GET_STORAGE_CLASS (sym) != C_BLOCK
4250       && S_GET_STORAGE_CLASS (sym) != C_BSTAT
4251       && S_GET_STORAGE_CLASS (sym) != C_ESTAT
4252       && S_GET_STORAGE_CLASS (sym) != C_BINCL
4253       && S_GET_STORAGE_CLASS (sym) != C_EINCL
4254       && S_GET_SEGMENT (sym) != ppc_coff_debug_section)
4255     S_SET_STORAGE_CLASS (sym, C_HIDEXT);
4256
4257   if (S_GET_STORAGE_CLASS (sym) == C_EXT
4258       || S_GET_STORAGE_CLASS (sym) == C_HIDEXT)
4259     {
4260       int i;
4261       union internal_auxent *a;
4262
4263       /* Create a csect aux.  */
4264       i = S_GET_NUMBER_AUXILIARY (sym);
4265       S_SET_NUMBER_AUXILIARY (sym, i + 1);
4266       a = &coffsymbol (symbol_get_bfdsym (sym))->native[i + 1].u.auxent;
4267       if (symbol_get_tc (sym)->class == XMC_TC0)
4268         {
4269           /* This is the TOC table.  */
4270           know (strcmp (S_GET_NAME (sym), "TOC") == 0);
4271           a->x_csect.x_scnlen.l = 0;
4272           a->x_csect.x_smtyp = (2 << 3) | XTY_SD;
4273         }
4274       else if (symbol_get_tc (sym)->subseg != 0)
4275         {
4276           /* This is a csect symbol.  x_scnlen is the size of the
4277              csect.  */
4278           if (symbol_get_tc (sym)->next == (symbolS *) NULL)
4279             a->x_csect.x_scnlen.l = (bfd_section_size (stdoutput,
4280                                                        S_GET_SEGMENT (sym))
4281                                      - S_GET_VALUE (sym));
4282           else
4283             {
4284               resolve_symbol_value (symbol_get_tc (sym)->next, 1);
4285               a->x_csect.x_scnlen.l = (S_GET_VALUE (symbol_get_tc (sym)->next)
4286                                        - S_GET_VALUE (sym));
4287             }
4288           a->x_csect.x_smtyp = (symbol_get_tc (sym)->align << 3) | XTY_SD;
4289         }
4290       else if (S_GET_SEGMENT (sym) == bss_section)
4291         {
4292           /* This is a common symbol.  */
4293           a->x_csect.x_scnlen.l = symbol_get_frag (sym)->fr_offset;
4294           a->x_csect.x_smtyp = (symbol_get_tc (sym)->align << 3) | XTY_CM;
4295           if (S_IS_EXTERNAL (sym))
4296             symbol_get_tc (sym)->class = XMC_RW;
4297           else
4298             symbol_get_tc (sym)->class = XMC_BS;
4299         }
4300       else if (S_GET_SEGMENT (sym) == absolute_section)
4301         {
4302           /* This is an absolute symbol.  The csect will be created by
4303              ppc_adjust_symtab.  */
4304           ppc_saw_abs = true;
4305           a->x_csect.x_smtyp = XTY_LD;
4306           if (symbol_get_tc (sym)->class == -1)
4307             symbol_get_tc (sym)->class = XMC_XO;
4308         }
4309       else if (! S_IS_DEFINED (sym))
4310         {
4311           /* This is an external symbol.  */
4312           a->x_csect.x_scnlen.l = 0;
4313           a->x_csect.x_smtyp = XTY_ER;
4314         }
4315       else if (symbol_get_tc (sym)->class == XMC_TC)
4316         {
4317           symbolS *next;
4318
4319           /* This is a TOC definition.  x_scnlen is the size of the
4320              TOC entry.  */
4321           next = symbol_next (sym);
4322           while (symbol_get_tc (next)->class == XMC_TC0)
4323             next = symbol_next (next);
4324           if (next == (symbolS *) NULL
4325               || symbol_get_tc (next)->class != XMC_TC)
4326             {
4327               if (ppc_after_toc_frag == (fragS *) NULL)
4328                 a->x_csect.x_scnlen.l = (bfd_section_size (stdoutput,
4329                                                            data_section)
4330                                          - S_GET_VALUE (sym));
4331               else
4332                 a->x_csect.x_scnlen.l = (ppc_after_toc_frag->fr_address
4333                                          - S_GET_VALUE (sym));
4334             }
4335           else
4336             {
4337               resolve_symbol_value (next, 1);
4338               a->x_csect.x_scnlen.l = (S_GET_VALUE (next)
4339                                        - S_GET_VALUE (sym));
4340             }
4341           a->x_csect.x_smtyp = (2 << 3) | XTY_SD;
4342         }
4343       else
4344         {
4345           symbolS *csect;
4346
4347           /* This is a normal symbol definition.  x_scnlen is the
4348              symbol index of the containing csect.  */
4349           if (S_GET_SEGMENT (sym) == text_section)
4350             csect = ppc_text_csects;
4351           else if (S_GET_SEGMENT (sym) == data_section)
4352             csect = ppc_data_csects;
4353           else
4354             abort ();
4355
4356           /* Skip the initial dummy symbol.  */
4357           csect = symbol_get_tc (csect)->next;
4358
4359           if (csect == (symbolS *) NULL)
4360             {
4361               as_warn (_("warning: symbol %s has no csect"), S_GET_NAME (sym));
4362               a->x_csect.x_scnlen.l = 0;
4363             }
4364           else
4365             {
4366               while (symbol_get_tc (csect)->next != (symbolS *) NULL)
4367                 {
4368                   resolve_symbol_value (symbol_get_tc (csect)->next, 1);
4369                   if (S_GET_VALUE (symbol_get_tc (csect)->next)
4370                       > S_GET_VALUE (sym))
4371                     break;
4372                   csect = symbol_get_tc (csect)->next;
4373                 }
4374
4375               a->x_csect.x_scnlen.p =
4376                 coffsymbol (symbol_get_bfdsym (csect))->native;
4377               coffsymbol (symbol_get_bfdsym (sym))->native[i + 1].fix_scnlen =
4378                 1;
4379             }
4380           a->x_csect.x_smtyp = XTY_LD;
4381         }
4382
4383       a->x_csect.x_parmhash = 0;
4384       a->x_csect.x_snhash = 0;
4385       if (symbol_get_tc (sym)->class == -1)
4386         a->x_csect.x_smclas = XMC_PR;
4387       else
4388         a->x_csect.x_smclas = symbol_get_tc (sym)->class;
4389       a->x_csect.x_stab = 0;
4390       a->x_csect.x_snstab = 0;
4391
4392       /* Don't let the COFF backend resort these symbols.  */
4393       symbol_get_bfdsym (sym)->flags |= BSF_NOT_AT_END;
4394     }
4395   else if (S_GET_STORAGE_CLASS (sym) == C_BSTAT)
4396     {
4397       /* We want the value to be the symbol index of the referenced
4398          csect symbol.  BFD will do that for us if we set the right
4399          flags.  */
4400       S_SET_VALUE (sym,
4401                    ((valueT)
4402                     coffsymbol (symbol_get_bfdsym
4403                                 (symbol_get_tc (sym)->within))->native));
4404       coffsymbol (symbol_get_bfdsym (sym))->native->fix_value = 1;
4405     }
4406   else if (S_GET_STORAGE_CLASS (sym) == C_STSYM)
4407     {
4408       symbolS *block;
4409       symbolS *csect;
4410
4411       /* The value is the offset from the enclosing csect.  */
4412       block = symbol_get_tc (sym)->within;
4413       csect = symbol_get_tc (block)->within;
4414       resolve_symbol_value (csect, 1);
4415       S_SET_VALUE (sym, S_GET_VALUE (sym) - S_GET_VALUE (csect));
4416     }
4417   else if (S_GET_STORAGE_CLASS (sym) == C_BINCL
4418            || S_GET_STORAGE_CLASS (sym) == C_EINCL)
4419     {
4420       /* We want the value to be a file offset into the line numbers.
4421          BFD will do that for us if we set the right flags.  We have
4422          already set the value correctly.  */
4423       coffsymbol (symbol_get_bfdsym (sym))->native->fix_line = 1;
4424     }
4425
4426   return 0;
4427 }
4428
4429 /* Adjust the symbol table.  This creates csect symbols for all
4430    absolute symbols.  */
4431
4432 void
4433 ppc_adjust_symtab ()
4434 {
4435   symbolS *sym;
4436
4437   if (! ppc_saw_abs)
4438     return;
4439
4440   for (sym = symbol_rootP; sym != NULL; sym = symbol_next (sym))
4441     {
4442       symbolS *csect;
4443       int i;
4444       union internal_auxent *a;
4445
4446       if (S_GET_SEGMENT (sym) != absolute_section)
4447         continue;
4448
4449       csect = symbol_create (".abs[XO]", absolute_section,
4450                              S_GET_VALUE (sym), &zero_address_frag);
4451       symbol_get_bfdsym (csect)->value = S_GET_VALUE (sym);
4452       S_SET_STORAGE_CLASS (csect, C_HIDEXT);
4453       i = S_GET_NUMBER_AUXILIARY (csect);
4454       S_SET_NUMBER_AUXILIARY (csect, i + 1);
4455       a = &coffsymbol (symbol_get_bfdsym (csect))->native[i + 1].u.auxent;
4456       a->x_csect.x_scnlen.l = 0;
4457       a->x_csect.x_smtyp = XTY_SD;
4458       a->x_csect.x_parmhash = 0;
4459       a->x_csect.x_snhash = 0;
4460       a->x_csect.x_smclas = XMC_XO;
4461       a->x_csect.x_stab = 0;
4462       a->x_csect.x_snstab = 0;
4463
4464       symbol_insert (csect, sym, &symbol_rootP, &symbol_lastP);
4465
4466       i = S_GET_NUMBER_AUXILIARY (sym);
4467       a = &coffsymbol (symbol_get_bfdsym (sym))->native[i].u.auxent;
4468       a->x_csect.x_scnlen.p = coffsymbol (symbol_get_bfdsym (csect))->native;
4469       coffsymbol (symbol_get_bfdsym (sym))->native[i].fix_scnlen = 1;
4470     }
4471
4472   ppc_saw_abs = false;
4473 }
4474
4475 /* Set the VMA for a section.  This is called on all the sections in
4476    turn.  */
4477
4478 void
4479 ppc_frob_section (sec)
4480      asection *sec;
4481 {
4482   static bfd_size_type vma = 0;
4483
4484   bfd_set_section_vma (stdoutput, sec, vma);
4485   vma += bfd_section_size (stdoutput, sec);
4486 }
4487
4488 #endif /* OBJ_XCOFF */
4489 \f
4490 /* Turn a string in input_line_pointer into a floating point constant
4491    of type TYPE, and store the appropriate bytes in *LITP.  The number
4492    of LITTLENUMS emitted is stored in *SIZEP.  An error message is
4493    returned, or NULL on OK.  */
4494
4495 char *
4496 md_atof (type, litp, sizep)
4497      int type;
4498      char *litp;
4499      int *sizep;
4500 {
4501   int prec;
4502   LITTLENUM_TYPE words[4];
4503   char *t;
4504   int i;
4505
4506   switch (type)
4507     {
4508     case 'f':
4509       prec = 2;
4510       break;
4511
4512     case 'd':
4513       prec = 4;
4514       break;
4515
4516     default:
4517       *sizep = 0;
4518       return _("bad call to md_atof");
4519     }
4520
4521   t = atof_ieee (input_line_pointer, type, words);
4522   if (t)
4523     input_line_pointer = t;
4524
4525   *sizep = prec * 2;
4526
4527   if (target_big_endian)
4528     {
4529       for (i = 0; i < prec; i++)
4530         {
4531           md_number_to_chars (litp, (valueT) words[i], 2);
4532           litp += 2;
4533         }
4534     }
4535   else
4536     {
4537       for (i = prec - 1; i >= 0; i--)
4538         {
4539           md_number_to_chars (litp, (valueT) words[i], 2);
4540           litp += 2;
4541         }
4542     }
4543
4544   return NULL;
4545 }
4546
4547 /* Write a value out to the object file, using the appropriate
4548    endianness.  */
4549
4550 void
4551 md_number_to_chars (buf, val, n)
4552      char *buf;
4553      valueT val;
4554      int n;
4555 {
4556   if (target_big_endian)
4557     number_to_chars_bigendian (buf, val, n);
4558   else
4559     number_to_chars_littleendian (buf, val, n);
4560 }
4561
4562 /* Align a section (I don't know why this is machine dependent).  */
4563
4564 valueT
4565 md_section_align (seg, addr)
4566      asection *seg;
4567      valueT addr;
4568 {
4569   int align = bfd_get_section_alignment (stdoutput, seg);
4570
4571   return ((addr + (1 << align) - 1) & (-1 << align));
4572 }
4573
4574 /* We don't have any form of relaxing.  */
4575
4576 int
4577 md_estimate_size_before_relax (fragp, seg)
4578      fragS *fragp ATTRIBUTE_UNUSED;
4579      asection *seg ATTRIBUTE_UNUSED;
4580 {
4581   abort ();
4582   return 0;
4583 }
4584
4585 /* Convert a machine dependent frag.  We never generate these.  */
4586
4587 void
4588 md_convert_frag (abfd, sec, fragp)
4589      bfd *abfd ATTRIBUTE_UNUSED;
4590      asection *sec ATTRIBUTE_UNUSED;
4591      fragS *fragp ATTRIBUTE_UNUSED;
4592 {
4593   abort ();
4594 }
4595
4596 /* We have no need to default values of symbols.  */
4597
4598 symbolS *
4599 md_undefined_symbol (name)
4600      char *name ATTRIBUTE_UNUSED;
4601 {
4602   return 0;
4603 }
4604 \f
4605 /* Functions concerning relocs.  */
4606
4607 /* The location from which a PC relative jump should be calculated,
4608    given a PC relative reloc.  */
4609
4610 long
4611 md_pcrel_from_section (fixp, sec)
4612      fixS *fixp;
4613      segT sec ATTRIBUTE_UNUSED;
4614 {
4615   return fixp->fx_frag->fr_address + fixp->fx_where;
4616 }
4617
4618 #ifdef OBJ_XCOFF
4619
4620 /* This is called to see whether a fixup should be adjusted to use a
4621    section symbol.  We take the opportunity to change a fixup against
4622    a symbol in the TOC subsegment into a reloc against the
4623    corresponding .tc symbol.  */
4624
4625 int
4626 ppc_fix_adjustable (fix)
4627      fixS *fix;
4628 {
4629   valueT val;
4630
4631   resolve_symbol_value (fix->fx_addsy, 1);
4632   val = S_GET_VALUE (fix->fx_addsy);
4633   if (ppc_toc_csect != (symbolS *) NULL
4634       && fix->fx_addsy != (symbolS *) NULL
4635       && fix->fx_addsy != ppc_toc_csect
4636       && S_GET_SEGMENT (fix->fx_addsy) == data_section
4637       && val >= ppc_toc_frag->fr_address
4638       && (ppc_after_toc_frag == (fragS *) NULL
4639           || val < ppc_after_toc_frag->fr_address))
4640     {
4641       symbolS *sy;
4642
4643       for (sy = symbol_next (ppc_toc_csect);
4644            sy != (symbolS *) NULL;
4645            sy = symbol_next (sy))
4646         {
4647           if (symbol_get_tc (sy)->class == XMC_TC0)
4648             continue;
4649           if (symbol_get_tc (sy)->class != XMC_TC)
4650             break;
4651           resolve_symbol_value (sy, 1);
4652           if (val == S_GET_VALUE (sy))
4653             {
4654               fix->fx_addsy = sy;
4655               fix->fx_addnumber = val - ppc_toc_frag->fr_address;
4656               return 0;
4657             }
4658         }
4659
4660       as_bad_where (fix->fx_file, fix->fx_line,
4661                     _("symbol in .toc does not match any .tc"));
4662     }
4663
4664   /* Possibly adjust the reloc to be against the csect.  */
4665   if (fix->fx_addsy != (symbolS *) NULL
4666       && symbol_get_tc (fix->fx_addsy)->subseg == 0
4667       && symbol_get_tc (fix->fx_addsy)->class != XMC_TC0
4668       && symbol_get_tc (fix->fx_addsy)->class != XMC_TC
4669       && S_GET_SEGMENT (fix->fx_addsy) != bss_section
4670       /* Don't adjust if this is a reloc in the toc section.  */
4671       && (S_GET_SEGMENT (fix->fx_addsy) != data_section
4672           || ppc_toc_csect == NULL
4673           || val < ppc_toc_frag->fr_address
4674           || (ppc_after_toc_frag != NULL
4675               && val >= ppc_after_toc_frag->fr_address)))
4676     {
4677       symbolS *csect;
4678
4679       if (S_GET_SEGMENT (fix->fx_addsy) == text_section)
4680         csect = ppc_text_csects;
4681       else if (S_GET_SEGMENT (fix->fx_addsy) == data_section)
4682         csect = ppc_data_csects;
4683       else
4684         abort ();
4685
4686       /* Skip the initial dummy symbol.  */
4687       csect = symbol_get_tc (csect)->next;
4688
4689       if (csect != (symbolS *) NULL)
4690         {
4691           while (symbol_get_tc (csect)->next != (symbolS *) NULL
4692                  && (symbol_get_frag (symbol_get_tc (csect)->next)->fr_address
4693                      <= val))
4694             {
4695               /* If the csect address equals the symbol value, then we
4696                  have to look through the full symbol table to see
4697                  whether this is the csect we want.  Note that we will
4698                  only get here if the csect has zero length.  */
4699               if ((symbol_get_frag (csect)->fr_address == val)
4700                   && S_GET_VALUE (csect) == S_GET_VALUE (fix->fx_addsy))
4701                 {
4702                   symbolS *scan;
4703
4704                   for (scan = symbol_next (csect);
4705                        scan != NULL;
4706                        scan = symbol_next (scan))
4707                     {
4708                       if (symbol_get_tc (scan)->subseg != 0)
4709                         break;
4710                       if (scan == fix->fx_addsy)
4711                         break;
4712                     }
4713
4714                   /* If we found the symbol before the next csect
4715                      symbol, then this is the csect we want.  */
4716                   if (scan == fix->fx_addsy)
4717                     break;
4718                 }
4719
4720               csect = symbol_get_tc (csect)->next;
4721             }
4722
4723           fix->fx_offset += (S_GET_VALUE (fix->fx_addsy)
4724                              - symbol_get_frag (csect)->fr_address);
4725           fix->fx_addsy = csect;
4726         }
4727     }
4728
4729   /* Adjust a reloc against a .lcomm symbol to be against the base
4730      .lcomm.  */
4731   if (fix->fx_addsy != (symbolS *) NULL
4732       && S_GET_SEGMENT (fix->fx_addsy) == bss_section
4733       && ! S_IS_EXTERNAL (fix->fx_addsy))
4734     {
4735       resolve_symbol_value (symbol_get_frag (fix->fx_addsy)->fr_symbol, 1);
4736       fix->fx_offset +=
4737         (S_GET_VALUE (fix->fx_addsy)
4738          - S_GET_VALUE (symbol_get_frag (fix->fx_addsy)->fr_symbol));
4739       fix->fx_addsy = symbol_get_frag (fix->fx_addsy)->fr_symbol;
4740     }
4741
4742   return 0;
4743 }
4744
4745 /* A reloc from one csect to another must be kept.  The assembler
4746    will, of course, keep relocs between sections, and it will keep
4747    absolute relocs, but we need to force it to keep PC relative relocs
4748    between two csects in the same section.  */
4749
4750 int
4751 ppc_force_relocation (fix)
4752      fixS *fix;
4753 {
4754   /* At this point fix->fx_addsy should already have been converted to
4755      a csect symbol.  If the csect does not include the fragment, then
4756      we need to force the relocation.  */
4757   if (fix->fx_pcrel
4758       && fix->fx_addsy != NULL
4759       && symbol_get_tc (fix->fx_addsy)->subseg != 0
4760       && ((symbol_get_frag (fix->fx_addsy)->fr_address
4761            > fix->fx_frag->fr_address)
4762           || (symbol_get_tc (fix->fx_addsy)->next != NULL
4763               && (symbol_get_frag (symbol_get_tc (fix->fx_addsy)->next)->fr_address
4764                   <= fix->fx_frag->fr_address))))
4765     return 1;
4766
4767   return 0;
4768 }
4769
4770 #endif /* OBJ_XCOFF */
4771
4772 /* See whether a symbol is in the TOC section.  */
4773
4774 static int
4775 ppc_is_toc_sym (sym)
4776      symbolS *sym;
4777 {
4778 #ifdef OBJ_XCOFF
4779   return symbol_get_tc (sym)->class == XMC_TC;
4780 #else
4781   return strcmp (segment_name (S_GET_SEGMENT (sym)), ".got") == 0;
4782 #endif
4783 }
4784
4785 /* Apply a fixup to the object code.  This is called for all the
4786    fixups we generated by the call to fix_new_exp, above.  In the call
4787    above we used a reloc code which was the largest legal reloc code
4788    plus the operand index.  Here we undo that to recover the operand
4789    index.  At this point all symbol values should be fully resolved,
4790    and we attempt to completely resolve the reloc.  If we can not do
4791    that, we determine the correct reloc code and put it back in the
4792    fixup.  */
4793
4794 int
4795 md_apply_fix3 (fixp, valuep, seg)
4796      fixS *fixp;
4797      valueT *valuep;
4798      segT seg;
4799 {
4800   valueT value;
4801
4802 #ifdef OBJ_ELF
4803   value = *valuep;
4804   if (fixp->fx_addsy != NULL)
4805     {
4806       /* `*valuep' may contain the value of the symbol on which the reloc
4807          will be based; we have to remove it.  */
4808       if (symbol_used_in_reloc_p (fixp->fx_addsy)
4809           && S_GET_SEGMENT (fixp->fx_addsy) != absolute_section
4810           && S_GET_SEGMENT (fixp->fx_addsy) != undefined_section
4811           && ! bfd_is_com_section (S_GET_SEGMENT (fixp->fx_addsy)))
4812         value -= S_GET_VALUE (fixp->fx_addsy);
4813
4814       /* FIXME: Why '+'?  Better yet, what exactly is '*valuep'
4815          supposed to be?  I think this is related to various similar
4816          FIXMEs in tc-i386.c and tc-sparc.c.  */
4817       if (fixp->fx_pcrel)
4818         value += fixp->fx_frag->fr_address + fixp->fx_where;
4819     }
4820   else
4821     {
4822       fixp->fx_done = 1;
4823     }
4824 #else
4825   /* FIXME FIXME FIXME: The value we are passed in *valuep includes
4826      the symbol values.  Since we are using BFD_ASSEMBLER, if we are
4827      doing this relocation the code in write.c is going to call
4828      bfd_install_relocation, which is also going to use the symbol
4829      value.  That means that if the reloc is fully resolved we want to
4830      use *valuep since bfd_install_relocation is not being used.
4831      However, if the reloc is not fully resolved we do not want to use
4832      *valuep, and must use fx_offset instead.  However, if the reloc
4833      is PC relative, we do want to use *valuep since it includes the
4834      result of md_pcrel_from.  This is confusing.  */
4835   if (fixp->fx_addsy == (symbolS *) NULL)
4836     {
4837       value = *valuep;
4838       fixp->fx_done = 1;
4839     }
4840   else if (fixp->fx_pcrel)
4841     value = *valuep;
4842   else
4843     {
4844       value = fixp->fx_offset;
4845       if (fixp->fx_subsy != (symbolS *) NULL)
4846         {
4847           if (S_GET_SEGMENT (fixp->fx_subsy) == absolute_section)
4848             value -= S_GET_VALUE (fixp->fx_subsy);
4849           else
4850             {
4851               /* We can't actually support subtracting a symbol.  */
4852               as_bad_where (fixp->fx_file, fixp->fx_line,
4853                             _("expression too complex"));
4854             }
4855         }
4856     }
4857 #endif
4858
4859   if ((int) fixp->fx_r_type >= (int) BFD_RELOC_UNUSED)
4860     {
4861       int opindex;
4862       const struct powerpc_operand *operand;
4863       char *where;
4864       unsigned long insn;
4865
4866       opindex = (int) fixp->fx_r_type - (int) BFD_RELOC_UNUSED;
4867
4868       operand = &powerpc_operands[opindex];
4869
4870 #ifdef OBJ_XCOFF
4871       /* It appears that an instruction like
4872              l 9,LC..1(30)
4873          when LC..1 is not a TOC symbol does not generate a reloc.  It
4874          uses the offset of LC..1 within its csect.  However, .long
4875          LC..1 will generate a reloc.  I can't find any documentation
4876          on how these cases are to be distinguished, so this is a wild
4877          guess.  These cases are generated by gcc -mminimal-toc.  */
4878       if ((operand->flags & PPC_OPERAND_PARENS) != 0
4879           && operand->bits == 16
4880           && operand->shift == 0
4881           && operand->insert == NULL
4882           && fixp->fx_addsy != NULL
4883           && symbol_get_tc (fixp->fx_addsy)->subseg != 0
4884           && symbol_get_tc (fixp->fx_addsy)->class != XMC_TC
4885           && symbol_get_tc (fixp->fx_addsy)->class != XMC_TC0
4886           && S_GET_SEGMENT (fixp->fx_addsy) != bss_section)
4887         {
4888           value = fixp->fx_offset;
4889           fixp->fx_done = 1;
4890         }
4891 #endif
4892
4893       /* Fetch the instruction, insert the fully resolved operand
4894          value, and stuff the instruction back again.  */
4895       where = fixp->fx_frag->fr_literal + fixp->fx_where;
4896       if (target_big_endian)
4897         insn = bfd_getb32 ((unsigned char *) where);
4898       else
4899         insn = bfd_getl32 ((unsigned char *) where);
4900       insn = ppc_insert_operand (insn, operand, (offsetT) value,
4901                                  fixp->fx_file, fixp->fx_line);
4902       if (target_big_endian)
4903         bfd_putb32 ((bfd_vma) insn, (unsigned char *) where);
4904       else
4905         bfd_putl32 ((bfd_vma) insn, (unsigned char *) where);
4906
4907       if (fixp->fx_done)
4908         {
4909           /* Nothing else to do here.  */
4910           return 1;
4911         }
4912
4913       /* Determine a BFD reloc value based on the operand information.
4914          We are only prepared to turn a few of the operands into
4915          relocs.
4916          FIXME: We need to handle the DS field at the very least.
4917          FIXME: Selecting the reloc type is a bit haphazard; perhaps
4918          there should be a new field in the operand table.  */
4919       if ((operand->flags & PPC_OPERAND_RELATIVE) != 0
4920           && operand->bits == 26
4921           && operand->shift == 0)
4922         fixp->fx_r_type = BFD_RELOC_PPC_B26;
4923       else if ((operand->flags & PPC_OPERAND_RELATIVE) != 0
4924           && operand->bits == 16
4925           && operand->shift == 0)
4926         fixp->fx_r_type = BFD_RELOC_PPC_B16;
4927       else if ((operand->flags & PPC_OPERAND_ABSOLUTE) != 0
4928                && operand->bits == 26
4929                && operand->shift == 0)
4930         fixp->fx_r_type = BFD_RELOC_PPC_BA26;
4931       else if ((operand->flags & PPC_OPERAND_ABSOLUTE) != 0
4932                && operand->bits == 16
4933                && operand->shift == 0)
4934         fixp->fx_r_type = BFD_RELOC_PPC_BA16;
4935       else if ((operand->flags & PPC_OPERAND_PARENS) != 0
4936                && operand->bits == 16
4937                && operand->shift == 0
4938                && fixp->fx_addsy != NULL
4939                && ppc_is_toc_sym (fixp->fx_addsy))
4940         {
4941           fixp->fx_size = 2;
4942           if (target_big_endian)
4943             fixp->fx_where += 2;
4944           fixp->fx_r_type = BFD_RELOC_PPC_TOC16;
4945         }
4946       else
4947         {
4948           char *sfile;
4949           unsigned int sline;
4950
4951           /* Use expr_symbol_where to see if this is an expression
4952              symbol.  */
4953           if (expr_symbol_where (fixp->fx_addsy, &sfile, &sline))
4954             as_bad_where (fixp->fx_file, fixp->fx_line,
4955                           _("unresolved expression that must be resolved"));
4956           else
4957             as_bad_where (fixp->fx_file, fixp->fx_line,
4958                           _("unsupported relocation type"));
4959           fixp->fx_done = 1;
4960           return 1;
4961         }
4962     }
4963   else
4964     {
4965 #ifdef OBJ_ELF
4966       ppc_elf_validate_fix (fixp, seg);
4967 #endif
4968       switch (fixp->fx_r_type)
4969         {
4970         case BFD_RELOC_32:
4971         case BFD_RELOC_CTOR:
4972           if (fixp->fx_pcrel)
4973             fixp->fx_r_type = BFD_RELOC_32_PCREL;
4974                                         /* fall through */
4975
4976         case BFD_RELOC_RVA:
4977         case BFD_RELOC_32_PCREL:
4978         case BFD_RELOC_32_BASEREL:
4979         case BFD_RELOC_PPC_EMB_NADDR32:
4980           md_number_to_chars (fixp->fx_frag->fr_literal + fixp->fx_where,
4981                               value, 4);
4982           break;
4983
4984         case BFD_RELOC_64:
4985           if (fixp->fx_pcrel)
4986             fixp->fx_r_type = BFD_RELOC_64_PCREL;
4987                                         /* fall through */
4988         case BFD_RELOC_64_PCREL:
4989           md_number_to_chars (fixp->fx_frag->fr_literal + fixp->fx_where,
4990                               value, 8);
4991           break;
4992         case BFD_RELOC_LO16:
4993         case BFD_RELOC_16:
4994         case BFD_RELOC_GPREL16:
4995         case BFD_RELOC_16_GOT_PCREL:
4996         case BFD_RELOC_16_GOTOFF:
4997         case BFD_RELOC_LO16_GOTOFF:
4998         case BFD_RELOC_HI16_GOTOFF:
4999         case BFD_RELOC_HI16_S_GOTOFF:
5000         case BFD_RELOC_LO16_BASEREL:
5001         case BFD_RELOC_HI16_BASEREL:
5002         case BFD_RELOC_HI16_S_BASEREL:
5003         case BFD_RELOC_PPC_EMB_NADDR16:
5004         case BFD_RELOC_PPC_EMB_NADDR16_LO:
5005         case BFD_RELOC_PPC_EMB_NADDR16_HI:
5006         case BFD_RELOC_PPC_EMB_NADDR16_HA:
5007         case BFD_RELOC_PPC_EMB_SDAI16:
5008         case BFD_RELOC_PPC_EMB_SDA2REL:
5009         case BFD_RELOC_PPC_EMB_SDA2I16:
5010         case BFD_RELOC_PPC_EMB_RELSEC16:
5011         case BFD_RELOC_PPC_EMB_RELST_LO:
5012         case BFD_RELOC_PPC_EMB_RELST_HI:
5013         case BFD_RELOC_PPC_EMB_RELST_HA:
5014         case BFD_RELOC_PPC_EMB_RELSDA:
5015         case BFD_RELOC_PPC_TOC16:
5016           if (fixp->fx_pcrel)
5017             {
5018               if (fixp->fx_addsy != NULL)
5019                 as_bad_where (fixp->fx_file, fixp->fx_line,
5020                               _("cannot emit PC relative %s relocation against %s"),
5021                               bfd_get_reloc_code_name (fixp->fx_r_type),
5022                               S_GET_NAME (fixp->fx_addsy));
5023               else
5024                 as_bad_where (fixp->fx_file, fixp->fx_line,
5025                               _("cannot emit PC relative %s relocation"),
5026                               bfd_get_reloc_code_name (fixp->fx_r_type));
5027             }
5028
5029           md_number_to_chars (fixp->fx_frag->fr_literal + fixp->fx_where,
5030                               value, 2);
5031           break;
5032
5033           /* This case happens when you write, for example,
5034              lis %r3,(L1-L2)@ha
5035              where L1 and L2 are defined later.  */
5036         case BFD_RELOC_HI16:
5037           if (fixp->fx_pcrel)
5038             abort ();
5039           md_number_to_chars (fixp->fx_frag->fr_literal + fixp->fx_where,
5040                               value >> 16, 2);
5041           break;
5042         case BFD_RELOC_HI16_S:
5043           if (fixp->fx_pcrel)
5044             abort ();
5045           md_number_to_chars (fixp->fx_frag->fr_literal + fixp->fx_where,
5046                               (value + 0x8000) >> 16, 2);
5047           break;
5048
5049           /* Because SDA21 modifies the register field, the size is set to 4
5050              bytes, rather than 2, so offset it here appropriately */
5051         case BFD_RELOC_PPC_EMB_SDA21:
5052           if (fixp->fx_pcrel)
5053             abort ();
5054
5055           md_number_to_chars (fixp->fx_frag->fr_literal + fixp->fx_where
5056                               + ((target_big_endian) ? 2 : 0),
5057                               value, 2);
5058           break;
5059
5060         case BFD_RELOC_8:
5061           if (fixp->fx_pcrel)
5062             abort ();
5063
5064           md_number_to_chars (fixp->fx_frag->fr_literal + fixp->fx_where,
5065                               value, 1);
5066           break;
5067
5068         case BFD_RELOC_24_PLT_PCREL:
5069         case BFD_RELOC_PPC_LOCAL24PC:
5070           if (!fixp->fx_pcrel && !fixp->fx_done)
5071             abort ();
5072
5073           if (fixp->fx_done)
5074           {
5075             char *where;
5076             unsigned long insn;
5077
5078             /* Fetch the instruction, insert the fully resolved operand
5079                value, and stuff the instruction back again.  */
5080             where = fixp->fx_frag->fr_literal + fixp->fx_where;
5081             if (target_big_endian)
5082               insn = bfd_getb32 ((unsigned char *) where);
5083             else
5084               insn = bfd_getl32 ((unsigned char *) where);
5085             if ((value & 3) != 0)
5086               as_bad_where (fixp->fx_file, fixp->fx_line,
5087                             _("must branch to an address a multiple of 4"));
5088             if ((offsetT) value < -0x40000000
5089                 || (offsetT) value >= 0x40000000)
5090               as_bad_where (fixp->fx_file, fixp->fx_line,
5091                             _("@local or @plt branch destination is too far away, %ld bytes"),
5092                             value);
5093             insn = insn | (value & 0x03fffffc);
5094             if (target_big_endian)
5095               bfd_putb32 ((bfd_vma) insn, (unsigned char *) where);
5096             else
5097               bfd_putl32 ((bfd_vma) insn, (unsigned char *) where);
5098           }
5099           break;
5100
5101         case BFD_RELOC_VTABLE_INHERIT:
5102           fixp->fx_done = 0;
5103           if (fixp->fx_addsy
5104               && !S_IS_DEFINED (fixp->fx_addsy)
5105               && !S_IS_WEAK (fixp->fx_addsy))
5106             S_SET_WEAK (fixp->fx_addsy);
5107           break;
5108
5109         case BFD_RELOC_VTABLE_ENTRY:
5110           fixp->fx_done = 0;
5111           break;
5112
5113         default:
5114           fprintf (stderr,
5115                   _("Gas failure, reloc value %d\n"), fixp->fx_r_type);
5116           fflush(stderr);
5117           abort ();
5118         }
5119     }
5120
5121 #ifdef OBJ_ELF
5122   fixp->fx_addnumber = value;
5123 #else
5124   if (fixp->fx_r_type != BFD_RELOC_PPC_TOC16)
5125     fixp->fx_addnumber = 0;
5126   else
5127     {
5128 #ifdef TE_PE
5129       fixp->fx_addnumber = 0;
5130 #else
5131       /* We want to use the offset within the data segment of the
5132          symbol, not the actual VMA of the symbol.  */
5133       fixp->fx_addnumber =
5134         - bfd_get_section_vma (stdoutput, S_GET_SEGMENT (fixp->fx_addsy));
5135 #endif
5136     }
5137 #endif
5138
5139   return 1;
5140 }
5141
5142 /* Generate a reloc for a fixup.  */
5143
5144 arelent *
5145 tc_gen_reloc (seg, fixp)
5146      asection *seg ATTRIBUTE_UNUSED;
5147      fixS *fixp;
5148 {
5149   arelent *reloc;
5150
5151   reloc = (arelent *) xmalloc (sizeof (arelent));
5152
5153   reloc->sym_ptr_ptr = (asymbol **) xmalloc (sizeof (asymbol *));
5154   *reloc->sym_ptr_ptr = symbol_get_bfdsym (fixp->fx_addsy);
5155   reloc->address = fixp->fx_frag->fr_address + fixp->fx_where;
5156   reloc->howto = bfd_reloc_type_lookup (stdoutput, fixp->fx_r_type);
5157   if (reloc->howto == (reloc_howto_type *) NULL)
5158     {
5159       as_bad_where (fixp->fx_file, fixp->fx_line,
5160                     _("reloc %d not supported by object file format"), (int)fixp->fx_r_type);
5161       return NULL;
5162     }
5163   reloc->addend = fixp->fx_addnumber;
5164
5165   return reloc;
5166 }