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