gas/config/tc-ppc.c

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