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