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