gas/config/tc-ppc.c

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