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