Subversion Repositories Kolibri OS

Rev

Rev 5222 | Blame | Compare with Previous | Last modification | View Log | RSS feed

  1. /* read.c - read a source file -
  2.    Copyright (C) 1986-2015 Free Software Foundation, Inc.
  3.  
  4.    This file is part of GAS, the GNU Assembler.
  5.  
  6.    GAS is free software; you can redistribute it and/or modify
  7.    it under the terms of the GNU General Public License as published by
  8.    the Free Software Foundation; either version 3, or (at your option)
  9.    any later version.
  10.  
  11.    GAS is distributed in the hope that it will be useful,
  12.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  13.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14.    GNU General Public License for more details.
  15.  
  16.    You should have received a copy of the GNU General Public License
  17.    along with GAS; see the file COPYING.  If not, write to the Free
  18.    Software Foundation, 51 Franklin Street - Fifth Floor, Boston, MA
  19.    02110-1301, USA.  */
  20.  
  21. /* If your chars aren't 8 bits, you will change this a bit (eg. to 0xFF).
  22.    But then, GNU isn't spozed to run on your machine anyway.
  23.    (RMS is so shortsighted sometimes.)  */
  24. #define MASK_CHAR ((int)(unsigned char) -1)
  25.  
  26. /* This is the largest known floating point format (for now). It will
  27.    grow when we do 4361 style flonums.  */
  28. #define MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT (16)
  29.  
  30. /* Routines that read assembler source text to build spaghetti in memory.
  31.    Another group of these functions is in the expr.c module.  */
  32.  
  33. #include "as.h"
  34. #include "safe-ctype.h"
  35. #include "subsegs.h"
  36. #include "sb.h"
  37. #include "macro.h"
  38. #include "obstack.h"
  39. #include "ecoff.h"
  40. #include "dw2gencfi.h"
  41. #include "wchar.h"
  42.  
  43. #ifndef TC_START_LABEL
  44. #define TC_START_LABEL(STR, NUL_CHAR, NEXT_CHAR) (NEXT_CHAR == ':')
  45. #endif
  46.  
  47. /* Set by the object-format or the target.  */
  48. #ifndef TC_IMPLICIT_LCOMM_ALIGNMENT
  49. #define TC_IMPLICIT_LCOMM_ALIGNMENT(SIZE, P2VAR)                \
  50.   do                                                            \
  51.     {                                                           \
  52.       if ((SIZE) >= 8)                                          \
  53.         (P2VAR) = 3;                                            \
  54.       else if ((SIZE) >= 4)                                     \
  55.         (P2VAR) = 2;                                            \
  56.       else if ((SIZE) >= 2)                                     \
  57.         (P2VAR) = 1;                                            \
  58.       else                                                      \
  59.         (P2VAR) = 0;                                            \
  60.     }                                                           \
  61.   while (0)
  62. #endif
  63.  
  64. char *input_line_pointer;       /*->next char of source file to parse.  */
  65.  
  66. #if BITS_PER_CHAR != 8
  67. /*  The following table is indexed by[(char)] and will break if
  68.     a char does not have exactly 256 states (hopefully 0:255!)!  */
  69. die horribly;
  70. #endif
  71.  
  72. #ifndef LEX_AT
  73. #define LEX_AT 0
  74. #endif
  75.  
  76. #ifndef LEX_BR
  77. /* The RS/6000 assembler uses {,},[,] as parts of symbol names.  */
  78. #define LEX_BR 0
  79. #endif
  80.  
  81. #ifndef LEX_PCT
  82. /* The Delta 68k assembler permits % inside label names.  */
  83. #define LEX_PCT 0
  84. #endif
  85.  
  86. #ifndef LEX_QM
  87. /* The PowerPC Windows NT assemblers permits ? inside label names.  */
  88. #define LEX_QM 0
  89. #endif
  90.  
  91. #ifndef LEX_HASH
  92. /* The IA-64 assembler uses # as a suffix designating a symbol.  We include
  93.    it in the symbol and strip it out in tc_canonicalize_symbol_name.  */
  94. #define LEX_HASH 0
  95. #endif
  96.  
  97. #ifndef LEX_DOLLAR
  98. #define LEX_DOLLAR 3
  99. #endif
  100.  
  101. #ifndef LEX_TILDE
  102. /* The Delta 68k assembler permits ~ at start of label names.  */
  103. #define LEX_TILDE 0
  104. #endif
  105.  
  106. /* Used by is_... macros. our ctype[].  */
  107. char lex_type[256] = {
  108.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* @ABCDEFGHIJKLMNO */
  109.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* PQRSTUVWXYZ[\]^_ */
  110.   0, 0, 0, LEX_HASH, LEX_DOLLAR, LEX_PCT, 0, 0, 0, 0, 0, 0, 0, 0, 3, 0, /* _!"#$%&'()*+,-./ */
  111.   1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 0, 0, 0, 0, LEX_QM,  /* 0123456789:;<=>? */
  112.   LEX_AT, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,  /* @ABCDEFGHIJKLMNO */
  113.   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR, 0, LEX_BR, 0, 3, /* PQRSTUVWXYZ[\]^_ */
  114.   0, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,       /* `abcdefghijklmno */
  115.   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, LEX_BR, 0, LEX_BR, LEX_TILDE, 0, /* pqrstuvwxyz{|}~.  */
  116.   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  117.   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  118.   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  119.   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  120.   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  121.   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  122.   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3,
  123.   3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3, 3
  124. };
  125.  
  126. /* In: a character.
  127.    Out: 1 if this character ends a line.
  128.         2 if this character is a line separator.  */
  129. char is_end_of_line[256] = {
  130. #ifdef CR_EOL
  131.   1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 0, 0,       /* @abcdefghijklmno */
  132. #else
  133.   1, 0, 0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 0, 0, 0,       /* @abcdefghijklmno */
  134. #endif
  135.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* */
  136.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* _!"#$%&'()*+,-./ */
  137.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* 0123456789:;<=>? */
  138.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* */
  139.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* */
  140.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* */
  141.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* */
  142.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* */
  143.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* */
  144.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* */
  145.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* */
  146.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* */
  147.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* */
  148.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,       /* */
  149.   0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0        /* */
  150. };
  151.  
  152. #ifndef TC_CASE_SENSITIVE
  153. char original_case_string[128];
  154. #endif
  155.  
  156. /* Functions private to this file.  */
  157.  
  158. static char *buffer;    /* 1st char of each buffer of lines is here.  */
  159. static char *buffer_limit;      /*->1 + last char in buffer.  */
  160.  
  161. /* TARGET_BYTES_BIG_ENDIAN is required to be defined to either 0 or 1
  162.    in the tc-<CPU>.h file.  See the "Porting GAS" section of the
  163.    internals manual.  */
  164. int target_big_endian = TARGET_BYTES_BIG_ENDIAN;
  165.  
  166. /* Variables for handling include file directory table.  */
  167.  
  168. /* Table of pointers to directories to search for .include's.  */
  169. char **include_dirs;
  170.  
  171. /* How many are in the table.  */
  172. int include_dir_count;
  173.  
  174. /* Length of longest in table.  */
  175. int include_dir_maxlen = 1;
  176.  
  177. #ifndef WORKING_DOT_WORD
  178. struct broken_word *broken_words;
  179. int new_broken_words;
  180. #endif
  181.  
  182. /* The current offset into the absolute section.  We don't try to
  183.    build frags in the absolute section, since no data can be stored
  184.    there.  We just keep track of the current offset.  */
  185. addressT abs_section_offset;
  186.  
  187. /* If this line had an MRI style label, it is stored in this variable.
  188.    This is used by some of the MRI pseudo-ops.  */
  189. symbolS *line_label;
  190.  
  191. /* This global variable is used to support MRI common sections.  We
  192.    translate such sections into a common symbol.  This variable is
  193.    non-NULL when we are in an MRI common section.  */
  194. symbolS *mri_common_symbol;
  195.  
  196. /* In MRI mode, after a dc.b pseudo-op with an odd number of bytes, we
  197.    need to align to an even byte boundary unless the next pseudo-op is
  198.    dc.b, ds.b, or dcb.b.  This variable is set to 1 if an alignment
  199.    may be needed.  */
  200. static int mri_pending_align;
  201.  
  202. #ifndef NO_LISTING
  203. #ifdef OBJ_ELF
  204. /* This variable is set to be non-zero if the next string we see might
  205.    be the name of the source file in DWARF debugging information.  See
  206.    the comment in emit_expr for the format we look for.  */
  207. static int dwarf_file_string;
  208. #endif
  209. #endif
  210.  
  211. /* If the target defines the md_frag_max_var hook then we know
  212.    enough to implement the .bundle_align_mode features.  */
  213. #ifdef md_frag_max_var
  214. # define HANDLE_BUNDLE
  215. #endif
  216.  
  217. #ifdef HANDLE_BUNDLE
  218. /* .bundle_align_mode sets this.  Normally it's zero.  When nonzero,
  219.    it's the exponent of the bundle size, and aligned instruction bundle
  220.    mode is in effect.  */
  221. static unsigned int bundle_align_p2;
  222.  
  223. /* These are set by .bundle_lock and .bundle_unlock.  .bundle_lock sets
  224.    bundle_lock_frag to frag_now and then starts a new frag with
  225.    frag_align_code.  At the same time, bundle_lock_frain gets frchain_now,
  226.    so that .bundle_unlock can verify that we didn't change segments.
  227.    .bundle_unlock resets both to NULL.  If we detect a bundling violation,
  228.    then we reset bundle_lock_frchain to NULL as an indicator that we've
  229.    already diagnosed the error with as_bad and don't need a cascade of
  230.    redundant errors, but bundle_lock_frag remains set to indicate that
  231.    we are expecting to see .bundle_unlock.  */
  232. static fragS *bundle_lock_frag;
  233. static frchainS *bundle_lock_frchain;
  234.  
  235. /* This is incremented by .bundle_lock and decremented by .bundle_unlock,
  236.    to allow nesting.  */
  237. static unsigned int bundle_lock_depth;
  238. #endif
  239.  
  240. static void do_s_func (int end_p, const char *default_prefix);
  241. static void do_align (int, char *, int, int);
  242. static void s_align (int, int);
  243. static void s_altmacro (int);
  244. static void s_bad_end (int);
  245. static void s_reloc (int);
  246. static int hex_float (int, char *);
  247. static segT get_known_segmented_expression (expressionS * expP);
  248. static void pobegin (void);
  249. static size_t get_non_macro_line_sb (sb *);
  250. static void generate_file_debug (void);
  251. static char *_find_end_of_line (char *, int, int, int);
  253. void
  254. read_begin (void)
  255. {
  256.   const char *p;
  257.  
  258.   pobegin ();
  259.   obj_read_begin_hook ();
  260.  
  261.   /* Something close -- but not too close -- to a multiple of 1024.
  262.      The debugging malloc I'm using has 24 bytes of overhead.  */
  263.   obstack_begin (&notes, chunksize);
  264.   obstack_begin (&cond_obstack, chunksize);
  265.  
  266. #ifndef tc_line_separator_chars
  267. #define tc_line_separator_chars line_separator_chars
  268. #endif
  269.   /* Use machine dependent syntax.  */
  270.   for (p = tc_line_separator_chars; *p; p++)
  271.     is_end_of_line[(unsigned char) *p] = 2;
  272.   /* Use more.  FIXME-SOMEDAY.  */
  273.  
  274.   if (flag_mri)
  275.     lex_type['?'] = 3;
  276. }
  278. #ifndef TC_ADDRESS_BYTES
  279. #define TC_ADDRESS_BYTES address_bytes
  280.  
  281. static inline int
  282. address_bytes (void)
  283. {
  284.   /* Choose smallest of 1, 2, 4, 8 bytes that is large enough to
  285.      contain an address.  */
  286.   int n = (stdoutput->arch_info->bits_per_address - 1) / 8;
  287.   n |= n >> 1;
  288.   n |= n >> 2;
  289.   n += 1;
  290.   return n;
  291. }
  292. #endif
  293.  
  294. /* Set up pseudo-op tables.  */
  295.  
  296. static struct hash_control *po_hash;
  297.  
  298. static const pseudo_typeS potable[] = {
  299.   {"abort", s_abort, 0},
  300.   {"align", s_align_ptwo, 0},
  301.   {"altmacro", s_altmacro, 1},
  302.   {"ascii", stringer, 8+0},
  303.   {"asciz", stringer, 8+1},
  304.   {"balign", s_align_bytes, 0},
  305.   {"balignw", s_align_bytes, -2},
  306.   {"balignl", s_align_bytes, -4},
  307. /* block  */
  308. #ifdef HANDLE_BUNDLE
  309.   {"bundle_align_mode", s_bundle_align_mode, 0},
  310.   {"bundle_lock", s_bundle_lock, 0},
  311.   {"bundle_unlock", s_bundle_unlock, 0},
  312. #endif
  313.   {"byte", cons, 1},
  314.   {"comm", s_comm, 0},
  315.   {"common", s_mri_common, 0},
  316.   {"common.s", s_mri_common, 1},
  317.   {"data", s_data, 0},
  318.   {"dc", cons, 2},
  319. #ifdef TC_ADDRESS_BYTES
  320.   {"dc.a", cons, 0},
  321. #endif
  322.   {"dc.b", cons, 1},
  323.   {"dc.d", float_cons, 'd'},
  324.   {"dc.l", cons, 4},
  325.   {"dc.s", float_cons, 'f'},
  326.   {"dc.w", cons, 2},
  327.   {"dc.x", float_cons, 'x'},
  328.   {"dcb", s_space, 2},
  329.   {"dcb.b", s_space, 1},
  330.   {"dcb.d", s_float_space, 'd'},
  331.   {"dcb.l", s_space, 4},
  332.   {"dcb.s", s_float_space, 'f'},
  333.   {"dcb.w", s_space, 2},
  334.   {"dcb.x", s_float_space, 'x'},
  335.   {"ds", s_space, 2},
  336.   {"ds.b", s_space, 1},
  337.   {"ds.d", s_space, 8},
  338.   {"ds.l", s_space, 4},
  339.   {"ds.p", s_space, 12},
  340.   {"ds.s", s_space, 4},
  341.   {"ds.w", s_space, 2},
  342.   {"ds.x", s_space, 12},
  343.   {"debug", s_ignore, 0},
  344. #ifdef S_SET_DESC
  345.   {"desc", s_desc, 0},
  346. #endif
  347. /* dim  */
  348.   {"double", float_cons, 'd'},
  349. /* dsect  */
  350.   {"eject", listing_eject, 0},  /* Formfeed listing.  */
  351.   {"else", s_else, 0},
  352.   {"elsec", s_else, 0},
  353.   {"elseif", s_elseif, (int) O_ne},
  354.   {"end", s_end, 0},
  355.   {"endc", s_endif, 0},
  356.   {"endfunc", s_func, 1},
  357.   {"endif", s_endif, 0},
  358.   {"endm", s_bad_end, 0},
  359.   {"endr", s_bad_end, 1},
  360. /* endef  */
  361.   {"equ", s_set, 0},
  362.   {"equiv", s_set, 1},
  363.   {"eqv", s_set, -1},
  364.   {"err", s_err, 0},
  365.   {"error", s_errwarn, 1},
  366.   {"exitm", s_mexit, 0},
  367. /* extend  */
  368.   {"extern", s_ignore, 0},      /* We treat all undef as ext.  */
  369.   {"appfile", s_app_file, 1},
  370.   {"appline", s_app_line, 1},
  371.   {"fail", s_fail, 0},
  372.   {"file", s_app_file, 0},
  373.   {"fill", s_fill, 0},
  374.   {"float", float_cons, 'f'},
  375.   {"format", s_ignore, 0},
  376.   {"func", s_func, 0},
  377.   {"global", s_globl, 0},
  378.   {"globl", s_globl, 0},
  379.   {"hword", cons, 2},
  380.   {"if", s_if, (int) O_ne},
  381.   {"ifb", s_ifb, 1},
  382.   {"ifc", s_ifc, 0},
  383.   {"ifdef", s_ifdef, 0},
  384.   {"ifeq", s_if, (int) O_eq},
  385.   {"ifeqs", s_ifeqs, 0},
  386.   {"ifge", s_if, (int) O_ge},
  387.   {"ifgt", s_if, (int) O_gt},
  388.   {"ifle", s_if, (int) O_le},
  389.   {"iflt", s_if, (int) O_lt},
  390.   {"ifnb", s_ifb, 0},
  391.   {"ifnc", s_ifc, 1},
  392.   {"ifndef", s_ifdef, 1},
  393.   {"ifne", s_if, (int) O_ne},
  394.   {"ifnes", s_ifeqs, 1},
  395.   {"ifnotdef", s_ifdef, 1},
  396.   {"incbin", s_incbin, 0},
  397.   {"include", s_include, 0},
  398.   {"int", cons, 4},
  399.   {"irp", s_irp, 0},
  400.   {"irep", s_irp, 0},
  401.   {"irpc", s_irp, 1},
  402.   {"irepc", s_irp, 1},
  403.   {"lcomm", s_lcomm, 0},
  404.   {"lflags", s_ignore, 0},      /* Listing flags.  */
  405.   {"linefile", s_app_line, 0},
  406.   {"linkonce", s_linkonce, 0},
  407.   {"list", listing_list, 1},    /* Turn listing on.  */
  408.   {"llen", listing_psize, 1},
  409.   {"long", cons, 4},
  410.   {"lsym", s_lsym, 0},
  411.   {"macro", s_macro, 0},
  412.   {"mexit", s_mexit, 0},
  413.   {"mri", s_mri, 0},
  414.   {".mri", s_mri, 0},   /* Special case so .mri works in MRI mode.  */
  415.   {"name", s_ignore, 0},
  416.   {"noaltmacro", s_altmacro, 0},
  417.   {"noformat", s_ignore, 0},
  418.   {"nolist", listing_list, 0},  /* Turn listing off.  */
  419.   {"nopage", listing_nopage, 0},
  420.   {"octa", cons, 16},
  421.   {"offset", s_struct, 0},
  422.   {"org", s_org, 0},
  423.   {"p2align", s_align_ptwo, 0},
  424.   {"p2alignw", s_align_ptwo, -2},
  425.   {"p2alignl", s_align_ptwo, -4},
  426.   {"page", listing_eject, 0},
  427.   {"plen", listing_psize, 0},
  428.   {"print", s_print, 0},
  429.   {"psize", listing_psize, 0},  /* Set paper size.  */
  430.   {"purgem", s_purgem, 0},
  431.   {"quad", cons, 8},
  432.   {"reloc", s_reloc, 0},
  433.   {"rep", s_rept, 0},
  434.   {"rept", s_rept, 0},
  435.   {"rva", s_rva, 4},
  436.   {"sbttl", listing_title, 1},  /* Subtitle of listing.  */
  437. /* scl  */
  438. /* sect  */
  439.   {"set", s_set, 0},
  440.   {"short", cons, 2},
  441.   {"single", float_cons, 'f'},
  442. /* size  */
  443.   {"space", s_space, 0},
  444.   {"skip", s_space, 0},
  445.   {"sleb128", s_leb128, 1},
  446.   {"spc", s_ignore, 0},
  447.   {"stabd", s_stab, 'd'},
  448.   {"stabn", s_stab, 'n'},
  449.   {"stabs", s_stab, 's'},
  450.   {"string", stringer, 8+1},
  451.   {"string8", stringer, 8+1},
  452.   {"string16", stringer, 16+1},
  453.   {"string32", stringer, 32+1},
  454.   {"string64", stringer, 64+1},
  455.   {"struct", s_struct, 0},
  456. /* tag  */
  457.   {"text", s_text, 0},
  458.  
  459.   /* This is for gcc to use.  It's only just been added (2/94), so gcc
  460.      won't be able to use it for a while -- probably a year or more.
  461.      But once this has been released, check with gcc maintainers
  462.      before deleting it or even changing the spelling.  */
  463.   {"this_GCC_requires_the_GNU_assembler", s_ignore, 0},
  464.   /* If we're folding case -- done for some targets, not necessarily
  465.      all -- the above string in an input file will be converted to
  466.      this one.  Match it either way...  */
  467.   {"this_gcc_requires_the_gnu_assembler", s_ignore, 0},
  468.  
  469.   {"title", listing_title, 0},  /* Listing title.  */
  470.   {"ttl", listing_title, 0},
  471. /* type  */
  472.   {"uleb128", s_leb128, 0},
  473. /* use  */
  474. /* val  */
  475.   {"xcom", s_comm, 0},
  476.   {"xdef", s_globl, 0},
  477.   {"xref", s_ignore, 0},
  478.   {"xstabs", s_xstab, 's'},
  479.   {"warning", s_errwarn, 0},
  480.   {"weakref", s_weakref, 0},
  481.   {"word", cons, 2},
  482.   {"zero", s_space, 0},
  483.   {NULL, NULL, 0}                       /* End sentinel.  */
  484. };
  485.  
  486. static offsetT
  487. get_absolute_expr (expressionS *exp)
  488. {
  489.   expression_and_evaluate (exp);
  490.   if (exp->X_op != O_constant)
  491.     {
  492.       if (exp->X_op != O_absent)
  493.         as_bad (_("bad or irreducible absolute expression"));
  494.       exp->X_add_number = 0;
  495.     }
  496.   return exp->X_add_number;
  497. }
  498.  
  499. offsetT
  500. get_absolute_expression (void)
  501. {
  502.   expressionS exp;
  503.  
  504.   return get_absolute_expr (&exp);
  505. }
  506.  
  507. static int pop_override_ok = 0;
  508. static const char *pop_table_name;
  509.  
  510. void
  511. pop_insert (const pseudo_typeS *table)
  512. {
  513.   const char *errtxt;
  514.   const pseudo_typeS *pop;
  515.   for (pop = table; pop->poc_name; pop++)
  516.     {
  517.       errtxt = hash_insert (po_hash, pop->poc_name, (char *) pop);
  518.       if (errtxt && (!pop_override_ok || strcmp (errtxt, "exists")))
  519.         as_fatal (_("error constructing %s pseudo-op table: %s"), pop_table_name,
  520.                   errtxt);
  521.     }
  522. }
  523.  
  524. #ifndef md_pop_insert
  525. #define md_pop_insert()         pop_insert(md_pseudo_table)
  526. #endif
  527.  
  528. #ifndef obj_pop_insert
  529. #define obj_pop_insert()        pop_insert(obj_pseudo_table)
  530. #endif
  531.  
  532. #ifndef cfi_pop_insert
  533. #define cfi_pop_insert()        pop_insert(cfi_pseudo_table)
  534. #endif
  535.  
  536. static void
  537. pobegin (void)
  538. {
  539.   po_hash = hash_new ();
  540.  
  541.   /* Do the target-specific pseudo ops.  */
  542.   pop_table_name = "md";
  543.   md_pop_insert ();
  544.  
  545.   /* Now object specific.  Skip any that were in the target table.  */
  546.   pop_table_name = "obj";
  547.   pop_override_ok = 1;
  548.   obj_pop_insert ();
  549.  
  550.   /* Now portable ones.  Skip any that we've seen already.  */
  551.   pop_table_name = "standard";
  552.   pop_insert (potable);
  553.  
  554.   /* Now CFI ones.  */
  555.   pop_table_name = "cfi";
  556.   pop_override_ok = 1;
  557.   cfi_pop_insert ();
  558. }
  560. #define HANDLE_CONDITIONAL_ASSEMBLY(num_read)                           \
  561.   if (ignore_input ())                                                  \
  562.     {                                                                   \
  563.       char *eol = find_end_of_line (input_line_pointer - (num_read),    \
  564.                                     flag_m68k_mri);                     \
  565.       input_line_pointer = (input_line_pointer <= buffer_limit          \
  566.                             && eol >= buffer_limit)                     \
  567.                            ? buffer_limit                               \
  568.                            : eol + 1;                                   \
  569.       continue;                                                         \
  570.     }
  571.  
  572. /* This function is used when scrubbing the characters between #APP
  573.    and #NO_APP.  */
  574.  
  575. static char *scrub_string;
  576. static char *scrub_string_end;
  577.  
  578. static size_t
  579. scrub_from_string (char *buf, size_t buflen)
  580. {
  581.   size_t copy;
  582.  
  583.   copy = scrub_string_end - scrub_string;
  584.   if (copy > buflen)
  585.     copy = buflen;
  586.   memcpy (buf, scrub_string, copy);
  587.   scrub_string += copy;
  588.   return copy;
  589. }
  590.  
  591. /* Helper function of read_a_source_file, which tries to expand a macro.  */
  592. static int
  593. try_macro (char term, const char *line)
  594. {
  595.   sb out;
  596.   const char *err;
  597.   macro_entry *macro;
  598.  
  599.   if (check_macro (line, &out, &err, &macro))
  600.     {
  601.       if (err != NULL)
  602.         as_bad ("%s", err);
  603.       *input_line_pointer++ = term;
  604.       input_scrub_include_sb (&out,
  605.                               input_line_pointer, 1);
  606.       sb_kill (&out);
  607.       buffer_limit =
  608.         input_scrub_next_buffer (&input_line_pointer);
  609. #ifdef md_macro_info
  610.       md_macro_info (macro);
  611. #endif
  612.       return 1;
  613.     }
  614.   return 0;
  615. }
  616.  
  617. #ifdef HANDLE_BUNDLE
  618. /* Start a new instruction bundle.  Returns the rs_align_code frag that
  619.    will be used to align the new bundle.  */
  620. static fragS *
  621. start_bundle (void)
  622. {
  623.   fragS *frag = frag_now;
  624.  
  625.   frag_align_code (0, 0);
  626.  
  627.   while (frag->fr_type != rs_align_code)
  628.     frag = frag->fr_next;
  629.  
  630.   gas_assert (frag != frag_now);
  631.  
  632.   return frag;
  633. }
  634.  
  635. /* Calculate the maximum size after relaxation of the region starting
  636.    at the given frag and extending through frag_now (which is unfinished).  */
  637. static unsigned int
  638. pending_bundle_size (fragS *frag)
  639. {
  640.   unsigned int offset = frag->fr_fix;
  641.   unsigned int size = 0;
  642.  
  643.   gas_assert (frag != frag_now);
  644.   gas_assert (frag->fr_type == rs_align_code);
  645.  
  646.   while (frag != frag_now)
  647.     {
  648.       /* This should only happen in what will later become an error case.  */
  649.       if (frag == NULL)
  650.         return 0;
  651.  
  652.       size += frag->fr_fix;
  653.       if (frag->fr_type == rs_machine_dependent)
  654.         size += md_frag_max_var (frag);
  655.  
  656.       frag = frag->fr_next;
  657.     }
  658.  
  659.   gas_assert (frag == frag_now);
  660.   size += frag_now_fix ();
  661.   if (frag->fr_type == rs_machine_dependent)
  662.     size += md_frag_max_var (frag);
  663.  
  664.   gas_assert (size >= offset);
  665.  
  666.   return size - offset;
  667. }
  668.  
  669. /* Finish off the frag created to ensure bundle alignment.  */
  670. static void
  671. finish_bundle (fragS *frag, unsigned int size)
  672. {
  673.   gas_assert (bundle_align_p2 > 0);
  674.   gas_assert (frag->fr_type == rs_align_code);
  675.  
  676.   if (size > 1)
  677.     {
  678.       /* If there is more than a single byte, then we need to set up the
  679.          alignment frag.  Otherwise we leave it at its initial state from
  680.          calling frag_align_code (0, 0), so that it does nothing.  */
  681.       frag->fr_offset = bundle_align_p2;
  682.       frag->fr_subtype = size - 1;
  683.     }
  684.  
  685.   /* We do this every time rather than just in s_bundle_align_mode
  686.      so that we catch any affected section without needing hooks all
  687.      over for all paths that do section changes.  It's cheap enough.  */
  688.   record_alignment (now_seg, bundle_align_p2 - OCTETS_PER_BYTE_POWER);
  689. }
  690.  
  691. /* Assemble one instruction.  This takes care of the bundle features
  692.    around calling md_assemble.  */
  693. static void
  694. assemble_one (char *line)
  695. {
  696.   fragS *insn_start_frag = NULL;
  697.  
  698.   if (bundle_lock_frchain != NULL && bundle_lock_frchain != frchain_now)
  699.     {
  700.       as_bad (_("cannot change section or subsection inside .bundle_lock"));
  701.       /* Clearing this serves as a marker that we have already complained.  */
  702.       bundle_lock_frchain = NULL;
  703.     }
  704.  
  705.   if (bundle_lock_frchain == NULL && bundle_align_p2 > 0)
  706.     insn_start_frag = start_bundle ();
  707.  
  708.   md_assemble (line);
  709.  
  710.   if (bundle_lock_frchain != NULL)
  711.     {
  712.       /* Make sure this hasn't pushed the locked sequence
  713.          past the bundle size.  */
  714.       unsigned int bundle_size = pending_bundle_size (bundle_lock_frag);
  715.       if (bundle_size > (1U << bundle_align_p2))
  716.         as_bad (_("\
  717. .bundle_lock sequence at %u bytes but .bundle_align_mode limit is %u bytes"),
  718.                 bundle_size, 1U << bundle_align_p2);
  719.     }
  720.   else if (bundle_align_p2 > 0)
  721.     {
  722.       unsigned int insn_size = pending_bundle_size (insn_start_frag);
  723.  
  724.       if (insn_size > (1U << bundle_align_p2))
  725.         as_bad (_("\
  726. single instruction is %u bytes long but .bundle_align_mode limit is %u"),
  727.                 (unsigned int) insn_size, 1U << bundle_align_p2);
  728.  
  729.       finish_bundle (insn_start_frag, insn_size);
  730.     }
  731. }
  732.  
  733. #else  /* !HANDLE_BUNDLE */
  734.  
  735. # define assemble_one(line) md_assemble(line)
  736.  
  737. #endif  /* HANDLE_BUNDLE */
  738.  
  739. /* We read the file, putting things into a web that represents what we
  740.    have been reading.  */
  741. void
  742. read_a_source_file (char *name)
  743. {
  744.   char nul_char;
  745.   char next_char;
  746.   char *s;              /* String of symbol, '\0' appended.  */
  747.   int temp;
  748.   pseudo_typeS *pop;
  749.  
  750. #ifdef WARN_COMMENTS
  751.   found_comment = 0;
  752. #endif
  753.  
  754.   buffer = input_scrub_new_file (name);
  755.  
  756.   listing_file (name);
  757.   listing_newline (NULL);
  758.   register_dependency (name);
  759.  
  760.   /* Generate debugging information before we've read anything in to denote
  761.      this file as the "main" source file and not a subordinate one
  762.      (e.g. N_SO vs N_SOL in stabs).  */
  763.   generate_file_debug ();
  764.  
  765.   while ((buffer_limit = input_scrub_next_buffer (&input_line_pointer)) != 0)
  766.     {                           /* We have another line to parse.  */
  767. #ifndef NO_LISTING
  768.       /* In order to avoid listing macro expansion lines with labels
  769.          multiple times, keep track of which line was last issued.  */
  770.       static char *last_eol;
  771.  
  772.       last_eol = NULL;
  773. #endif
  774.       while (input_line_pointer < buffer_limit)
  775.         {
  776.           bfd_boolean was_new_line;
  777.           /* We have more of this buffer to parse.  */
  778.  
  779.           /* We now have input_line_pointer->1st char of next line.
  780.              If input_line_pointer [-1] == '\n' then we just
  781.              scanned another line: so bump line counters.  */
  782.           was_new_line = is_end_of_line[(unsigned char) input_line_pointer[-1]];
  783.           if (was_new_line)
  784.             {
  785.               symbol_set_value_now (&dot_symbol);
  786. #ifdef md_start_line_hook
  787.               md_start_line_hook ();
  788. #endif
  789.               if (input_line_pointer[-1] == '\n')
  790.                 bump_line_counters ();
  791.             }
  792.  
  793. #ifndef NO_LISTING
  794.           /* If listing is on, and we are expanding a macro, then give
  795.              the listing code the contents of the expanded line.  */
  796.           if (listing)
  797.             {
  798.               if ((listing & LISTING_MACEXP) && macro_nest > 0)
  799.                 {
  800.                   /* Find the end of the current expanded macro line.  */
  801.                   s = find_end_of_line (input_line_pointer, flag_m68k_mri);
  802.  
  803.                   if (s != last_eol)
  804.                     {
  805.                       char *copy;
  806.                       int len;
  807.  
  808.                       last_eol = s;
  809.                       /* Copy it for safe keeping.  Also give an indication of
  810.                          how much macro nesting is involved at this point.  */
  811.                       len = s - input_line_pointer;
  812.                       copy = (char *) xmalloc (len + macro_nest + 2);
  813.                       memset (copy, '>', macro_nest);
  814.                       copy[macro_nest] = ' ';
  815.                       memcpy (copy + macro_nest + 1, input_line_pointer, len);
  816.                       copy[macro_nest + 1 + len] = '\0';
  817.  
  818.                       /* Install the line with the listing facility.  */
  819.                       listing_newline (copy);
  820.                     }
  821.                 }
  822.               else
  823.                 listing_newline (NULL);
  824.             }
  825. #endif
  826.           if (was_new_line)
  827.             {
  828.               line_label = NULL;
  829.  
  830.               if (LABELS_WITHOUT_COLONS || flag_m68k_mri)
  831.                 {
  832.                   next_char = * input_line_pointer;
  833.                   /* Text at the start of a line must be a label, we
  834.                      run down and stick a colon in.  */
  835.                   if (is_name_beginner (next_char) || next_char == '"')
  836.                     {
  837.                       char *line_start;
  838.                       int mri_line_macro;
  839.  
  840.                       HANDLE_CONDITIONAL_ASSEMBLY (0);
  841.  
  842.                       nul_char = get_symbol_name (& line_start);
  843.                       next_char = (nul_char == '"' ? input_line_pointer[1] : nul_char);
  844.  
  845.                       /* In MRI mode, the EQU and MACRO pseudoops must
  846.                          be handled specially.  */
  847.                       mri_line_macro = 0;
  848.                       if (flag_m68k_mri)
  849.                         {
  850.                           char *rest = input_line_pointer + 1;
  851.  
  852.                           if (*rest == ':')
  853.                             ++rest;
  854.                           if (*rest == ' ' || *rest == '\t')
  855.                             ++rest;
  856.                           if ((strncasecmp (rest, "EQU", 3) == 0
  857.                                || strncasecmp (rest, "SET", 3) == 0)
  858.                               && (rest[3] == ' ' || rest[3] == '\t'))
  859.                             {
  860.                               input_line_pointer = rest + 3;
  861.                               equals (line_start,
  862.                                       strncasecmp (rest, "SET", 3) == 0);
  863.                               continue;
  864.                             }
  865.                           if (strncasecmp (rest, "MACRO", 5) == 0
  866.                               && (rest[5] == ' '
  867.                                   || rest[5] == '\t'
  868.                                   || is_end_of_line[(unsigned char) rest[5]]))
  869.                             mri_line_macro = 1;
  870.                         }
  871.  
  872.                       /* In MRI mode, we need to handle the MACRO
  873.                          pseudo-op specially: we don't want to put the
  874.                          symbol in the symbol table.  */
  875.                       if (!mri_line_macro
  876. #ifdef TC_START_LABEL_WITHOUT_COLON
  877.                           && TC_START_LABEL_WITHOUT_COLON (nul_char, next_char)
  878. #endif
  879.                           )
  880.                         line_label = colon (line_start);
  881.                       else
  882.                         line_label = symbol_create (line_start,
  883.                                                     absolute_section,
  884.                                                     (valueT) 0,
  885.                                                     &zero_address_frag);
  886.  
  887.                       next_char = restore_line_pointer (nul_char);
  888.                       if (next_char == ':')
  889.                         input_line_pointer++;
  890.                     }
  891.                 }
  892.             }
  893.  
  894.           /* We are at the beginning of a line, or similar place.
  895.              We expect a well-formed assembler statement.
  896.              A "symbol-name:" is a statement.
  897.  
  898.              Depending on what compiler is used, the order of these tests
  899.              may vary to catch most common case 1st.
  900.              Each test is independent of all other tests at the (top)
  901.              level.  */
  902.           do
  903.             nul_char = next_char = *input_line_pointer++;
  904.           while (next_char == '\t' || next_char == ' ' || next_char == '\f');
  905.  
  906.           /* C is the 1st significant character.
  907.              Input_line_pointer points after that character.  */
  908.           if (is_name_beginner (next_char) || next_char == '"')
  909.             {
  910.               char *rest;
  911.  
  912.               /* Want user-defined label or pseudo/opcode.  */
  913.               HANDLE_CONDITIONAL_ASSEMBLY (1);
  914.  
  915.               --input_line_pointer;
  916.               nul_char = get_symbol_name (& s); /* name's delimiter.  */
  917.               next_char = (nul_char == '"' ? input_line_pointer[1] : nul_char);
  918.               rest = input_line_pointer + (nul_char == '"' ? 2 : 1);
  919.  
  920.               /* NEXT_CHAR is character after symbol.
  921.                  The end of symbol in the input line is now '\0'.
  922.                  S points to the beginning of the symbol.
  923.                    [In case of pseudo-op, s->'.'.]
  924.                  Input_line_pointer->'\0' where NUL_CHAR was.  */
  925.               if (TC_START_LABEL (s, nul_char, next_char))
  926.                 {
  927.                   if (flag_m68k_mri)
  928.                     {
  929.                       /* In MRI mode, \tsym: set 0 is permitted.  */
  930.                       if (*rest == ':')
  931.                         ++rest;
  932.  
  933.                       if (*rest == ' ' || *rest == '\t')
  934.                         ++rest;
  935.  
  936.                       if ((strncasecmp (rest, "EQU", 3) == 0
  937.                            || strncasecmp (rest, "SET", 3) == 0)
  938.                           && (rest[3] == ' ' || rest[3] == '\t'))
  939.                         {
  940.                           input_line_pointer = rest + 3;
  941.                           equals (s, 1);
  942.                           continue;
  943.                         }
  944.                     }
  945.  
  946.                   line_label = colon (s);       /* User-defined label.  */
  947.                   restore_line_pointer (nul_char);
  948.                   ++ input_line_pointer;
  949. #ifdef tc_check_label
  950.                   tc_check_label (line_label);
  951. #endif
  952.                   /* Input_line_pointer->after ':'.  */
  953.                   SKIP_WHITESPACE ();
  954.                 }
  955.               else if ((next_char == '=' && *rest == '=')
  956.                        || ((next_char == ' ' || next_char == '\t')
  957.                            && rest[0] == '='
  958.                            && rest[1] == '='))
  959.                 {
  960.                   equals (s, -1);
  961.                   demand_empty_rest_of_line ();
  962.                 }
  963.               else if ((next_char == '='
  964.                        || ((next_char == ' ' || next_char == '\t')
  965.                             && *rest == '='))
  966. #ifdef TC_EQUAL_IN_INSN
  967.                            && !TC_EQUAL_IN_INSN (next_char, s)
  968. #endif
  969.                            )
  970.                 {
  971.                   equals (s, 1);
  972.                   demand_empty_rest_of_line ();
  973.                 }
  974.               else
  975.                 {
  976.                   /* Expect pseudo-op or machine instruction.  */
  977.                   pop = NULL;
  978.  
  979. #ifndef TC_CASE_SENSITIVE
  980.                   {
  981.                     char *s2 = s;
  982.  
  983.                     strncpy (original_case_string, s2, sizeof (original_case_string));
  984.                     original_case_string[sizeof (original_case_string) - 1] = 0;
  985.  
  986.                     while (*s2)
  987.                       {
  988.                         *s2 = TOLOWER (*s2);
  989.                         s2++;
  990.                       }
  991.                   }
  992. #endif
  993.                   if (NO_PSEUDO_DOT || flag_m68k_mri)
  994.                     {
  995.                       /* The MRI assembler uses pseudo-ops without
  996.                          a period.  */
  997.                       pop = (pseudo_typeS *) hash_find (po_hash, s);
  998.                       if (pop != NULL && pop->poc_handler == NULL)
  999.                         pop = NULL;
  1000.                     }
  1001.  
  1002.                   if (pop != NULL
  1003.                       || (!flag_m68k_mri && *s == '.'))
  1004.                     {
  1005.                       /* PSEUDO - OP.
  1006.  
  1007.                          WARNING: next_char may be end-of-line.
  1008.                          We lookup the pseudo-op table with s+1 because we
  1009.                          already know that the pseudo-op begins with a '.'.  */
  1010.  
  1011.                       if (pop == NULL)
  1012.                         pop = (pseudo_typeS *) hash_find (po_hash, s + 1);
  1013.                       if (pop && !pop->poc_handler)
  1014.                         pop = NULL;
  1015.  
  1016.                       /* In MRI mode, we may need to insert an
  1017.                          automatic alignment directive.  What a hack
  1018.                          this is.  */
  1019.                       if (mri_pending_align
  1020.                           && (pop == NULL
  1021.                               || !((pop->poc_handler == cons
  1022.                                     && pop->poc_val == 1)
  1023.                                    || (pop->poc_handler == s_space
  1024.                                        && pop->poc_val == 1)
  1025. #ifdef tc_conditional_pseudoop
  1026.                                    || tc_conditional_pseudoop (pop)
  1027. #endif
  1028.                                    || pop->poc_handler == s_if
  1029.                                    || pop->poc_handler == s_ifdef
  1030.                                    || pop->poc_handler == s_ifc
  1031.                                    || pop->poc_handler == s_ifeqs
  1032.                                    || pop->poc_handler == s_else
  1033.                                    || pop->poc_handler == s_endif
  1034.                                    || pop->poc_handler == s_globl
  1035.                                    || pop->poc_handler == s_ignore)))
  1036.                         {
  1037.                           do_align (1, (char *) NULL, 0, 0);
  1038.                           mri_pending_align = 0;
  1039.  
  1040.                           if (line_label != NULL)
  1041.                             {
  1042.                               symbol_set_frag (line_label, frag_now);
  1043.                               S_SET_VALUE (line_label, frag_now_fix ());
  1044.                             }
  1045.                         }
  1046.  
  1047.                       /* Print the error msg now, while we still can.  */
  1048.                       if (pop == NULL)
  1049.                         {
  1050.                           char *end = input_line_pointer;
  1051.  
  1052.                           (void) restore_line_pointer (nul_char);
  1053.                           s_ignore (0);
  1054.                           nul_char = next_char = *--input_line_pointer;
  1055.                           *input_line_pointer = '\0';
  1056.                           if (! macro_defined || ! try_macro (next_char, s))
  1057.                             {
  1058.                               *end = '\0';
  1059.                               as_bad (_("unknown pseudo-op: `%s'"), s);
  1060.                               *input_line_pointer++ = nul_char;
  1061.                             }
  1062.                           continue;
  1063.                         }
  1064.  
  1065.                       /* Put it back for error messages etc.  */
  1066.                       next_char = restore_line_pointer (nul_char);
  1067.                       /* The following skip of whitespace is compulsory.
  1068.                          A well shaped space is sometimes all that separates
  1069.                          keyword from operands.  */
  1070.                       if (next_char == ' ' || next_char == '\t')
  1071.                         input_line_pointer++;
  1072.  
  1073.                       /* Input_line is restored.
  1074.                          Input_line_pointer->1st non-blank char
  1075.                          after pseudo-operation.  */
  1076.                       (*pop->poc_handler) (pop->poc_val);
  1077.  
  1078.                       /* If that was .end, just get out now.  */
  1079.                       if (pop->poc_handler == s_end)
  1080.                         goto quit;
  1081.                     }
  1082.                   else
  1083.                     {
  1084.                       /* WARNING: next_char may be end-of-line.  */
  1085.                       /* Also: input_line_pointer->`\0` where nul_char was.  */
  1086.                       (void) restore_line_pointer (nul_char);
  1087.                       input_line_pointer = _find_end_of_line (input_line_pointer, flag_m68k_mri, 1, 0);
  1088.                       next_char = nul_char = *input_line_pointer;
  1089.                       *input_line_pointer = '\0';
  1090.  
  1091.                       generate_lineno_debug ();
  1092.  
  1093.                       if (macro_defined && try_macro (next_char, s))
  1094.                         continue;
  1095.  
  1096.                       if (mri_pending_align)
  1097.                         {
  1098.                           do_align (1, (char *) NULL, 0, 0);
  1099.                           mri_pending_align = 0;
  1100.                           if (line_label != NULL)
  1101.                             {
  1102.                               symbol_set_frag (line_label, frag_now);
  1103.                               S_SET_VALUE (line_label, frag_now_fix ());
  1104.                             }
  1105.                         }
  1106.  
  1107.                       assemble_one (s); /* Assemble 1 instruction.  */
  1108.  
  1109.                       *input_line_pointer++ = nul_char;
  1110.  
  1111.                       /* We resume loop AFTER the end-of-line from
  1112.                          this instruction.  */
  1113.                     }
  1114.                 }
  1115.               continue;
  1116.             }
  1117.  
  1118.           /* Empty statement?  */
  1119.           if (is_end_of_line[(unsigned char) next_char])
  1120.             continue;
  1121.  
  1122.           if ((LOCAL_LABELS_DOLLAR || LOCAL_LABELS_FB) && ISDIGIT (next_char))
  1123.             {
  1124.               /* local label  ("4:")  */
  1125.               char *backup = input_line_pointer;
  1126.  
  1127.               HANDLE_CONDITIONAL_ASSEMBLY (1);
  1128.  
  1129.               temp = next_char - '0';
  1130.  
  1131.               if (nul_char == '"')
  1132.                 ++ input_line_pointer;
  1133.  
  1134.               /* Read the whole number.  */
  1135.               while (ISDIGIT (*input_line_pointer))
  1136.                 {
  1137.                   temp = (temp * 10) + *input_line_pointer - '0';
  1138.                   ++input_line_pointer;
  1139.                 }
  1140.  
  1141.               if (LOCAL_LABELS_DOLLAR
  1142.                   && *input_line_pointer == '$'
  1143.                   && *(input_line_pointer + 1) == ':')
  1144.                 {
  1145.                   input_line_pointer += 2;
  1146.  
  1147.                   if (dollar_label_defined (temp))
  1148.                     {
  1149.                       as_fatal (_("label \"%d$\" redefined"), temp);
  1150.                     }
  1151.  
  1152.                   define_dollar_label (temp);
  1153.                   colon (dollar_label_name (temp, 0));
  1154.                   continue;
  1155.                 }
  1156.  
  1157.               if (LOCAL_LABELS_FB
  1158.                   && *input_line_pointer++ == ':')
  1159.                 {
  1160.                   fb_label_instance_inc (temp);
  1161.                   colon (fb_label_name (temp, 0));
  1162.                   continue;
  1163.                 }
  1164.  
  1165.               input_line_pointer = backup;
  1166.             }
  1167.  
  1168.           if (next_char && strchr (line_comment_chars, next_char))
  1169.             {                   /* Its a comment.  Better say APP or NO_APP.  */
  1170.               sb sbuf;
  1171.               char *ends;
  1172.               char *new_buf;
  1173.               char *new_tmp;
  1174.               unsigned int new_length;
  1175.               char *tmp_buf = 0;
  1176.  
  1177.               s = input_line_pointer;
  1178.               if (strncmp (s, "APP\n", 4))
  1179.                 {
  1180.                   /* We ignore it.  */
  1181.                   ignore_rest_of_line ();
  1182.                   continue;
  1183.                 }
  1184.               bump_line_counters ();
  1185.               s += 4;
  1186.  
  1187.               ends = strstr (s, "#NO_APP\n");
  1188.  
  1189.               if (!ends)
  1190.                 {
  1191.                   unsigned int tmp_len;
  1192.                   unsigned int num;
  1193.  
  1194.                   /* The end of the #APP wasn't in this buffer.  We
  1195.                      keep reading in buffers until we find the #NO_APP
  1196.                      that goes with this #APP  There is one.  The specs
  1197.                      guarantee it...  */
  1198.                   tmp_len = buffer_limit - s;
  1199.                   tmp_buf = (char *) xmalloc (tmp_len + 1);
  1200.                   memcpy (tmp_buf, s, tmp_len);
  1201.                   do
  1202.                     {
  1203.                       new_tmp = input_scrub_next_buffer (&buffer);
  1204.                       if (!new_tmp)
  1205.                         break;
  1206.                       else
  1207.                         buffer_limit = new_tmp;
  1208.                       input_line_pointer = buffer;
  1209.                       ends = strstr (buffer, "#NO_APP\n");
  1210.                       if (ends)
  1211.                         num = ends - buffer;
  1212.                       else
  1213.                         num = buffer_limit - buffer;
  1214.  
  1215.                       tmp_buf = (char *) xrealloc (tmp_buf, tmp_len + num);
  1216.                       memcpy (tmp_buf + tmp_len, buffer, num);
  1217.                       tmp_len += num;
  1218.                     }
  1219.                   while (!ends);
  1220.  
  1221.                   input_line_pointer = ends ? ends + 8 : NULL;
  1222.  
  1223.                   s = tmp_buf;
  1224.                   ends = s + tmp_len;
  1225.  
  1226.                 }
  1227.               else
  1228.                 {
  1229.                   input_line_pointer = ends + 8;
  1230.                 }
  1231.  
  1232.               scrub_string = s;
  1233.               scrub_string_end = ends;
  1234.  
  1235.               new_length = ends - s;
  1236.               new_buf = (char *) xmalloc (new_length);
  1237.               new_tmp = new_buf;
  1238.               for (;;)
  1239.                 {
  1240.                   size_t space;
  1241.                   size_t size;
  1242.  
  1243.                   space = (new_buf + new_length) - new_tmp;
  1244.                   size = do_scrub_chars (scrub_from_string, new_tmp, space);
  1245.  
  1246.                   if (size < space)
  1247.                     {
  1248.                       new_tmp[size] = 0;
  1249.                       break;
  1250.                     }
  1251.  
  1252.                   new_buf = (char *) xrealloc (new_buf, new_length + 100);
  1253.                   new_tmp = new_buf + new_length;
  1254.                   new_length += 100;
  1255.                 }
  1256.  
  1257.               if (tmp_buf)
  1258.                 free (tmp_buf);
  1259.  
  1260.               /* We've "scrubbed" input to the preferred format.  In the
  1261.                  process we may have consumed the whole of the remaining
  1262.                  file (and included files).  We handle this formatted
  1263.                  input similar to that of macro expansion, letting
  1264.                  actual macro expansion (possibly nested) and other
  1265.                  input expansion work.  Beware that in messages, line
  1266.                  numbers and possibly file names will be incorrect.  */
  1267.               new_length = strlen (new_buf);
  1268.               sb_build (&sbuf, new_length);
  1269.               sb_add_buffer (&sbuf, new_buf, new_length);
  1270.               input_scrub_include_sb (&sbuf, input_line_pointer, 0);
  1271.               sb_kill (&sbuf);
  1272.               buffer_limit = input_scrub_next_buffer (&input_line_pointer);
  1273.               free (new_buf);
  1274.               continue;
  1275.             }
  1276.  
  1277.           HANDLE_CONDITIONAL_ASSEMBLY (1);
  1278.  
  1279. #ifdef tc_unrecognized_line
  1280.           if (tc_unrecognized_line (next_char))
  1281.             continue;
  1282. #endif
  1283.           input_line_pointer--;
  1284.           /* Report unknown char as error.  */
  1285.           demand_empty_rest_of_line ();
  1286.         }
  1287.     }
  1288.  
  1289.  quit:
  1290.   symbol_set_value_now (&dot_symbol);
  1291.  
  1292. #ifdef HANDLE_BUNDLE
  1293.   if (bundle_lock_frag != NULL)
  1294.     {
  1295.       as_bad_where (bundle_lock_frag->fr_file, bundle_lock_frag->fr_line,
  1296.                     _(".bundle_lock with no matching .bundle_unlock"));
  1297.       bundle_lock_frag = NULL;
  1298.       bundle_lock_frchain = NULL;
  1299.       bundle_lock_depth = 0;
  1300.     }
  1301. #endif
  1302.  
  1303. #ifdef md_cleanup
  1304.   md_cleanup ();
  1305. #endif
  1306.   /* Close the input file.  */
  1307.   input_scrub_close ();
  1308. #ifdef WARN_COMMENTS
  1309.   {
  1310.     if (warn_comment && found_comment)
  1311.       as_warn_where (found_comment_file, found_comment,
  1312.                      "first comment found here");
  1313.   }
  1314. #endif
  1315. }
  1316.  
  1317. /* Convert O_constant expression EXP into the equivalent O_big representation.
  1318.    Take the sign of the number from SIGN rather than X_add_number.  */
  1319.  
  1320. static void
  1321. convert_to_bignum (expressionS *exp, int sign)
  1322. {
  1323.   valueT value;
  1324.   unsigned int i;
  1325.  
  1326.   value = exp->X_add_number;
  1327.   for (i = 0; i < sizeof (exp->X_add_number) / CHARS_PER_LITTLENUM; i++)
  1328.     {
  1329.       generic_bignum[i] = value & LITTLENUM_MASK;
  1330.       value >>= LITTLENUM_NUMBER_OF_BITS;
  1331.     }
  1332.   /* Add a sequence of sign bits if the top bit of X_add_number is not
  1333.      the sign of the original value.  */
  1334.   if ((exp->X_add_number < 0) == !sign)
  1335.     generic_bignum[i++] = sign ? LITTLENUM_MASK : 0;
  1336.   exp->X_op = O_big;
  1337.   exp->X_add_number = i;
  1338. }
  1339.  
  1340. /* For most MRI pseudo-ops, the line actually ends at the first
  1341.    nonquoted space.  This function looks for that point, stuffs a null
  1342.    in, and sets *STOPCP to the character that used to be there, and
  1343.    returns the location.
  1344.  
  1345.    Until I hear otherwise, I am going to assume that this is only true
  1346.    for the m68k MRI assembler.  */
  1347.  
  1348. char *
  1349. mri_comment_field (char *stopcp)
  1350. {
  1351.   char *s;
  1352. #ifdef TC_M68K
  1353.   int inquote = 0;
  1354.  
  1355.   know (flag_m68k_mri);
  1356.  
  1357.   for (s = input_line_pointer;
  1358.        ((!is_end_of_line[(unsigned char) *s] && *s != ' ' && *s != '\t')
  1359.         || inquote);
  1360.        s++)
  1361.     {
  1362.       if (*s == '\'')
  1363.         inquote = !inquote;
  1364.     }
  1365. #else
  1366.   for (s = input_line_pointer;
  1367.        !is_end_of_line[(unsigned char) *s];
  1368.        s++)
  1369.     ;
  1370. #endif
  1371.   *stopcp = *s;
  1372.   *s = '\0';
  1373.  
  1374.   return s;
  1375. }
  1376.  
  1377. /* Skip to the end of an MRI comment field.  */
  1378.  
  1379. void
  1380. mri_comment_end (char *stop, int stopc)
  1381. {
  1382.   know (flag_mri);
  1383.  
  1384.   input_line_pointer = stop;
  1385.   *stop = stopc;
  1386.   while (!is_end_of_line[(unsigned char) *input_line_pointer])
  1387.     ++input_line_pointer;
  1388. }
  1389.  
  1390. void
  1391. s_abort (int ignore ATTRIBUTE_UNUSED)
  1392. {
  1393.   as_fatal (_(".abort detected.  Abandoning ship."));
  1394. }
  1395.  
  1396. /* Guts of .align directive.  N is the power of two to which to align.
  1397.    FILL may be NULL, or it may point to the bytes of the fill pattern.
  1398.    LEN is the length of whatever FILL points to, if anything.  MAX is
  1399.    the maximum number of characters to skip when doing the alignment,
  1400.    or 0 if there is no maximum.  */
  1401.  
  1402. static void
  1403. do_align (int n, char *fill, int len, int max)
  1404. {
  1405.   if (now_seg == absolute_section)
  1406.     {
  1407.       if (fill != NULL)
  1408.         while (len-- > 0)
  1409.           if (*fill++ != '\0')
  1410.             {
  1411.               as_warn (_("ignoring fill value in absolute section"));
  1412.               break;
  1413.             }
  1414.       fill = NULL;
  1415.       len = 0;
  1416.     }
  1417.  
  1418. #ifdef md_flush_pending_output
  1419.   md_flush_pending_output ();
  1420. #endif
  1421. #ifdef md_do_align
  1422.   md_do_align (n, fill, len, max, just_record_alignment);
  1423. #endif
  1424.  
  1425.   /* Only make a frag if we HAVE to...  */
  1426.   if (n != 0 && !need_pass_2)
  1427.     {
  1428.       if (fill == NULL)
  1429.         {
  1430.           if (subseg_text_p (now_seg))
  1431.             frag_align_code (n, max);
  1432.           else
  1433.             frag_align (n, 0, max);
  1434.         }
  1435.       else if (len <= 1)
  1436.         frag_align (n, *fill, max);
  1437.       else
  1438.         frag_align_pattern (n, fill, len, max);
  1439.     }
  1440.  
  1441. #ifdef md_do_align
  1442.  just_record_alignment: ATTRIBUTE_UNUSED_LABEL
  1443. #endif
  1444.  
  1445.   record_alignment (now_seg, n - OCTETS_PER_BYTE_POWER);
  1446. }
  1447.  
  1448. /* Handle the .align pseudo-op.  A positive ARG is a default alignment
  1449.    (in bytes).  A negative ARG is the negative of the length of the
  1450.    fill pattern.  BYTES_P is non-zero if the alignment value should be
  1451.    interpreted as the byte boundary, rather than the power of 2.  */
  1452. #ifndef TC_ALIGN_LIMIT
  1453. #define TC_ALIGN_LIMIT (stdoutput->arch_info->bits_per_address - 1)
  1454. #endif
  1455.  
  1456. static void
  1457. s_align (int arg, int bytes_p)
  1458. {
  1459.   unsigned int align_limit = TC_ALIGN_LIMIT;
  1460.   unsigned int align;
  1461.   char *stop = NULL;
  1462.   char stopc = 0;
  1463.   offsetT fill = 0;
  1464.   int max;
  1465.   int fill_p;
  1466.  
  1467.   if (flag_mri)
  1468.     stop = mri_comment_field (&stopc);
  1469.  
  1470.   if (is_end_of_line[(unsigned char) *input_line_pointer])
  1471.     {
  1472.       if (arg < 0)
  1473.         align = 0;
  1474.       else
  1475.         align = arg;    /* Default value from pseudo-op table.  */
  1476.     }
  1477.   else
  1478.     {
  1479.       align = get_absolute_expression ();
  1480.       SKIP_WHITESPACE ();
  1481.  
  1482. #ifdef TC_ALIGN_ZERO_IS_DEFAULT
  1483.       if (arg > 0 && align == 0)
  1484.         align = arg;
  1485. #endif
  1486.     }
  1487.  
  1488.   if (bytes_p)
  1489.     {
  1490.       /* Convert to a power of 2.  */
  1491.       if (align != 0)
  1492.         {
  1493.           unsigned int i;
  1494.  
  1495.           for (i = 0; (align & 1) == 0; align >>= 1, ++i)
  1496.             ;
  1497.           if (align != 1)
  1498.             as_bad (_("alignment not a power of 2"));
  1499.  
  1500.           align = i;
  1501.         }
  1502.     }
  1503.  
  1504.   if (align > align_limit)
  1505.     {
  1506.       align = align_limit;
  1507.       as_warn (_("alignment too large: %u assumed"), align);
  1508.     }
  1509.  
  1510.   if (*input_line_pointer != ',')
  1511.     {
  1512.       fill_p = 0;
  1513.       max = 0;
  1514.     }
  1515.   else
  1516.     {
  1517.       ++input_line_pointer;
  1518.       if (*input_line_pointer == ',')
  1519.         fill_p = 0;
  1520.       else
  1521.         {
  1522.           fill = get_absolute_expression ();
  1523.           SKIP_WHITESPACE ();
  1524.           fill_p = 1;
  1525.         }
  1526.  
  1527.       if (*input_line_pointer != ',')
  1528.         max = 0;
  1529.       else
  1530.         {
  1531.           ++input_line_pointer;
  1532.           max = get_absolute_expression ();
  1533.         }
  1534.     }
  1535.  
  1536.   if (!fill_p)
  1537.     {
  1538.       if (arg < 0)
  1539.         as_warn (_("expected fill pattern missing"));
  1540.       do_align (align, (char *) NULL, 0, max);
  1541.     }
  1542.   else
  1543.     {
  1544.       int fill_len;
  1545.  
  1546.       if (arg >= 0)
  1547.         fill_len = 1;
  1548.       else
  1549.         fill_len = -arg;
  1550.       if (fill_len <= 1)
  1551.         {
  1552.           char fill_char;
  1553.  
  1554.           fill_char = fill;
  1555.           do_align (align, &fill_char, fill_len, max);
  1556.         }
  1557.       else
  1558.         {
  1559.           char ab[16];
  1560.  
  1561.           if ((size_t) fill_len > sizeof ab)
  1562.             abort ();
  1563.           md_number_to_chars (ab, fill, fill_len);
  1564.           do_align (align, ab, fill_len, max);
  1565.         }
  1566.     }
  1567.  
  1568.   demand_empty_rest_of_line ();
  1569.  
  1570.   if (flag_mri)
  1571.     mri_comment_end (stop, stopc);
  1572. }
  1573.  
  1574. /* Handle the .align pseudo-op on machines where ".align 4" means
  1575.    align to a 4 byte boundary.  */
  1576.  
  1577. void
  1578. s_align_bytes (int arg)
  1579. {
  1580.   s_align (arg, 1);
  1581. }
  1582.  
  1583. /* Handle the .align pseudo-op on machines where ".align 4" means align
  1584.    to a 2**4 boundary.  */
  1585.  
  1586. void
  1587. s_align_ptwo (int arg)
  1588. {
  1589.   s_align (arg, 0);
  1590. }
  1591.  
  1592. /* Switch in and out of alternate macro mode.  */
  1593.  
  1594. static void
  1595. s_altmacro (int on)
  1596. {
  1597.   demand_empty_rest_of_line ();
  1598.   macro_set_alternate (on);
  1599. }
  1600.  
  1601. /* Read a symbol name from input_line_pointer.
  1602.  
  1603.    Stores the symbol name in a buffer and returns a pointer to this buffer.
  1604.    The buffer is xalloc'ed.  It is the caller's responsibility to free
  1605.    this buffer.
  1606.  
  1607.    The name is not left in the i_l_p buffer as it may need processing
  1608.    to handle escape characters.
  1609.  
  1610.    Advances i_l_p to the next non-whitespace character.
  1611.  
  1612.    If a symbol name could not be read, the routine issues an error
  1613.    messages, skips to the end of the line and returns NULL.  */
  1614.  
  1615. char *
  1616. read_symbol_name (void)
  1617. {
  1618.   char * name;
  1619.   char * start;
  1620.   char c;
  1621.  
  1622.   c = *input_line_pointer++;
  1623.  
  1624.   if (c == '"')
  1625.     {
  1626. #define SYM_NAME_CHUNK_LEN 128
  1627.       ptrdiff_t len = SYM_NAME_CHUNK_LEN;
  1628.       char * name_end;
  1629.       unsigned int C;
  1630.  
  1631.       start = name = xmalloc (len + 1);
  1632.  
  1633.       name_end = name + SYM_NAME_CHUNK_LEN;
  1634.  
  1635.       while (is_a_char (C = next_char_of_string ()))
  1636.         {
  1637.           if (name >= name_end)
  1638.             {
  1639.               ptrdiff_t sofar;
  1640.  
  1641.               sofar = name - start;
  1642.               len += SYM_NAME_CHUNK_LEN;
  1643.               start = xrealloc (start, len + 1);
  1644.               name_end = start + len;
  1645.               name = start + sofar;
  1646.             }
  1647.  
  1648.           *name++ = (char) C;
  1649.         }
  1650.       *name = 0;
  1651.  
  1652.       /* Since quoted symbol names can contain non-ASCII characters,
  1653.          check the string and warn if it cannot be recognised by the
  1654.          current character set.  */
  1655.       if (mbstowcs (NULL, name, len) == (size_t) -1)
  1656.         as_warn (_("symbol name not recognised in the current locale"));
  1657.     }
  1658.   else if (is_name_beginner (c) || c == '\001')
  1659.     {
  1660.       ptrdiff_t len;
  1661.  
  1662.       name = input_line_pointer - 1;
  1663.  
  1664.       /* We accept \001 in a name in case this is
  1665.          being called with a constructed string.  */
  1666.       while (is_part_of_name (c = *input_line_pointer++)
  1667.              || c == '\001')
  1668.         ;
  1669.  
  1670.       len = (input_line_pointer - name) - 1;
  1671.       start = xmalloc (len + 1);
  1672.  
  1673.       memcpy (start, name, len);
  1674.       start[len] = 0;
  1675.  
  1676.       /* Skip a name ender char if one is present.  */
  1677.       if (! is_name_ender (c))
  1678.         --input_line_pointer;
  1679.     }
  1680.   else
  1681.     name = start = NULL;
  1682.  
  1683.   if (name == start)
  1684.     {
  1685.       as_bad (_("expected symbol name"));
  1686.       ignore_rest_of_line ();
  1687.       return NULL;
  1688.     }
  1689.  
  1690.   SKIP_WHITESPACE ();
  1691.  
  1692.   return start;
  1693. }
  1694.  
  1695.  
  1696. symbolS *
  1697. s_comm_internal (int param,
  1698.                  symbolS *(*comm_parse_extra) (int, symbolS *, addressT))
  1699. {
  1700.   char *name;
  1701.   offsetT temp, size;
  1702.   symbolS *symbolP = NULL;
  1703.   char *stop = NULL;
  1704.   char stopc = 0;
  1705.   expressionS exp;
  1706.  
  1707.   if (flag_mri)
  1708.     stop = mri_comment_field (&stopc);
  1709.  
  1710.   if ((name = read_symbol_name ()) == NULL)
  1711.     goto out;
  1712.  
  1713.   /* Accept an optional comma after the name.  The comma used to be
  1714.      required, but Irix 5 cc does not generate it for .lcomm.  */
  1715.   if (*input_line_pointer == ',')
  1716.     input_line_pointer++;
  1717.  
  1718.   temp = get_absolute_expr (&exp);
  1719.   size = temp;
  1720.   size &= ((addressT) 2 << (stdoutput->arch_info->bits_per_address - 1)) - 1;
  1721.   if (exp.X_op == O_absent)
  1722.     {
  1723.       as_bad (_("missing size expression"));
  1724.       ignore_rest_of_line ();
  1725.       goto out;
  1726.     }
  1727.   else if (temp != size || !exp.X_unsigned)
  1728.     {
  1729.       as_warn (_("size (%ld) out of range, ignored"), (long) temp);
  1730.       ignore_rest_of_line ();
  1731.       goto out;
  1732.     }
  1733.  
  1734.   symbolP = symbol_find_or_make (name);
  1735.   if ((S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP))
  1736.       && !S_IS_COMMON (symbolP))
  1737.     {
  1738.       if (!S_IS_VOLATILE (symbolP))
  1739.         {
  1740.           symbolP = NULL;
  1741.           as_bad (_("symbol `%s' is already defined"), name);
  1742.           ignore_rest_of_line ();
  1743.           goto out;
  1744.         }
  1745.       symbolP = symbol_clone (symbolP, 1);
  1746.       S_SET_SEGMENT (symbolP, undefined_section);
  1747.       S_SET_VALUE (symbolP, 0);
  1748.       symbol_set_frag (symbolP, &zero_address_frag);
  1749.       S_CLEAR_VOLATILE (symbolP);
  1750.     }
  1751.  
  1752.   size = S_GET_VALUE (symbolP);
  1753.   if (size == 0)
  1754.     size = temp;
  1755.   else if (size != temp)
  1756.     as_warn (_("size of \"%s\" is already %ld; not changing to %ld"),
  1757.              name, (long) size, (long) temp);
  1758.  
  1759.   if (comm_parse_extra != NULL)
  1760.     symbolP = (*comm_parse_extra) (param, symbolP, size);
  1761.   else
  1762.     {
  1763.       S_SET_VALUE (symbolP, (valueT) size);
  1764.       S_SET_EXTERNAL (symbolP);
  1765.       S_SET_SEGMENT (symbolP, bfd_com_section_ptr);
  1766.     }
  1767.  
  1768.   demand_empty_rest_of_line ();
  1769.  out:
  1770.   if (flag_mri)
  1771.     mri_comment_end (stop, stopc);
  1772.   if (name != NULL)
  1773.     free (name);
  1774.   return symbolP;
  1775. }
  1776.  
  1777. void
  1778. s_comm (int ignore)
  1779. {
  1780.   s_comm_internal (ignore, NULL);
  1781. }
  1782.  
  1783. /* The MRI COMMON pseudo-op.  We handle this by creating a common
  1784.    symbol with the appropriate name.  We make s_space do the right
  1785.    thing by increasing the size.  */
  1786.  
  1787. void
  1788. s_mri_common (int small ATTRIBUTE_UNUSED)
  1789. {
  1790.   char *name;
  1791.   char c;
  1792.   char *alc = NULL;
  1793.   symbolS *sym;
  1794.   offsetT align;
  1795.   char *stop = NULL;
  1796.   char stopc = 0;
  1797.  
  1798.   if (!flag_mri)
  1799.     {
  1800.       s_comm (0);
  1801.       return;
  1802.     }
  1803.  
  1804.   stop = mri_comment_field (&stopc);
  1805.  
  1806.   SKIP_WHITESPACE ();
  1807.  
  1808.   name = input_line_pointer;
  1809.   if (!ISDIGIT (*name))
  1810.     c = get_symbol_name (& name);
  1811.   else
  1812.     {
  1813.       do
  1814.         {
  1815.           ++input_line_pointer;
  1816.         }
  1817.       while (ISDIGIT (*input_line_pointer));
  1818.  
  1819.       c = *input_line_pointer;
  1820.       *input_line_pointer = '\0';
  1821.  
  1822.       if (line_label != NULL)
  1823.         {
  1824.           alc = (char *) xmalloc (strlen (S_GET_NAME (line_label))
  1825.                                   + (input_line_pointer - name)
  1826.                                   + 1);
  1827.           sprintf (alc, "%s%s", name, S_GET_NAME (line_label));
  1828.           name = alc;
  1829.         }
  1830.     }
  1831.  
  1832.   sym = symbol_find_or_make (name);
  1833.   c = restore_line_pointer (c);
  1834.   if (alc != NULL)
  1835.     free (alc);
  1836.  
  1837.   if (*input_line_pointer != ',')
  1838.     align = 0;
  1839.   else
  1840.     {
  1841.       ++input_line_pointer;
  1842.       align = get_absolute_expression ();
  1843.     }
  1844.  
  1845.   if (S_IS_DEFINED (sym) && !S_IS_COMMON (sym))
  1846.     {
  1847.       as_bad (_("symbol `%s' is already defined"), S_GET_NAME (sym));
  1848.       ignore_rest_of_line ();
  1849.       mri_comment_end (stop, stopc);
  1850.       return;
  1851.     }
  1852.  
  1853.   S_SET_EXTERNAL (sym);
  1854.   S_SET_SEGMENT (sym, bfd_com_section_ptr);
  1855.   mri_common_symbol = sym;
  1856.  
  1857. #ifdef S_SET_ALIGN
  1858.   if (align != 0)
  1859.     S_SET_ALIGN (sym, align);
  1860. #else
  1861.   (void) align;
  1862. #endif
  1863.  
  1864.   if (line_label != NULL)
  1865.     {
  1866.       expressionS exp;
  1867.       exp.X_op = O_symbol;
  1868.       exp.X_add_symbol = sym;
  1869.       exp.X_add_number = 0;
  1870.       symbol_set_value_expression (line_label, &exp);
  1871.       symbol_set_frag (line_label, &zero_address_frag);
  1872.       S_SET_SEGMENT (line_label, expr_section);
  1873.     }
  1874.  
  1875.   /* FIXME: We just ignore the small argument, which distinguishes
  1876.      COMMON and COMMON.S.  I don't know what we can do about it.  */
  1877.  
  1878.   /* Ignore the type and hptype.  */
  1879.   if (*input_line_pointer == ',')
  1880.     input_line_pointer += 2;
  1881.   if (*input_line_pointer == ',')
  1882.     input_line_pointer += 2;
  1883.  
  1884.   demand_empty_rest_of_line ();
  1885.  
  1886.   mri_comment_end (stop, stopc);
  1887. }
  1888.  
  1889. void
  1890. s_data (int ignore ATTRIBUTE_UNUSED)
  1891. {
  1892.   segT section;
  1893.   int temp;
  1894.  
  1895.   temp = get_absolute_expression ();
  1896.   if (flag_readonly_data_in_text)
  1897.     {
  1898.       section = text_section;
  1899.       temp += 1000;
  1900.     }
  1901.   else
  1902.     section = data_section;
  1903.  
  1904.   subseg_set (section, (subsegT) temp);
  1905.  
  1906.   demand_empty_rest_of_line ();
  1907. }
  1908.  
  1909. /* Handle the .appfile pseudo-op.  This is automatically generated by
  1910.    do_scrub_chars when a preprocessor # line comment is seen with a
  1911.    file name.  This default definition may be overridden by the object
  1912.    or CPU specific pseudo-ops.  This function is also the default
  1913.    definition for .file; the APPFILE argument is 1 for .appfile, 0 for
  1914.    .file.  */
  1915.  
  1916. void
  1917. s_app_file_string (char *file, int appfile ATTRIBUTE_UNUSED)
  1918. {
  1919. #ifdef LISTING
  1920.   if (listing)
  1921.     listing_source_file (file);
  1922. #endif
  1923.   register_dependency (file);
  1924. #ifdef obj_app_file
  1925.   obj_app_file (file, appfile);
  1926. #endif
  1927. }
  1928.  
  1929. void
  1930. s_app_file (int appfile)
  1931. {
  1932.   char *s;
  1933.   int length;
  1934.  
  1935.   /* Some assemblers tolerate immediately following '"'.  */
  1936.   if ((s = demand_copy_string (&length)) != 0)
  1937.     {
  1938.       int may_omit
  1939.         = (!new_logical_line_flags (s, -1, 1) && appfile);
  1940.  
  1941.       /* In MRI mode, the preprocessor may have inserted an extraneous
  1942.          backquote.  */
  1943.       if (flag_m68k_mri
  1944.           && *input_line_pointer == '\''
  1945.           && is_end_of_line[(unsigned char) input_line_pointer[1]])
  1946.         ++input_line_pointer;
  1947.  
  1948.       demand_empty_rest_of_line ();
  1949.       if (!may_omit)
  1950.         s_app_file_string (s, appfile);
  1951.     }
  1952. }
  1953.  
  1954. static int
  1955. get_linefile_number (int *flag)
  1956. {
  1957.   SKIP_WHITESPACE ();
  1958.  
  1959.   if (*input_line_pointer < '0' || *input_line_pointer > '9')
  1960.     return 0;
  1961.  
  1962.   *flag = get_absolute_expression ();
  1963.  
  1964.   return 1;
  1965. }
  1966.  
  1967. /* Handle the .appline pseudo-op.  This is automatically generated by
  1968.    do_scrub_chars when a preprocessor # line comment is seen.  This
  1969.    default definition may be overridden by the object or CPU specific
  1970.    pseudo-ops.  */
  1971.  
  1972. void
  1973. s_app_line (int appline)
  1974. {
  1975.   char *file = NULL;
  1976.   int l;
  1977.  
  1978.   /* The given number is that of the next line.  */
  1979.   if (appline)
  1980.     l = get_absolute_expression ();
  1981.   else if (!get_linefile_number (&l))
  1982.     {
  1983.       ignore_rest_of_line ();
  1984.       return;
  1985.     }
  1986.  
  1987.   l--;
  1988.  
  1989.   if (l < -1)
  1990.     /* Some of the back ends can't deal with non-positive line numbers.
  1991.        Besides, it's silly.  GCC however will generate a line number of
  1992.        zero when it is pre-processing builtins for assembler-with-cpp files:
  1993.  
  1994.           # 0 "<built-in>"
  1995.  
  1996.        We do not want to barf on this, especially since such files are used
  1997.        in the GCC and GDB testsuites.  So we check for negative line numbers
  1998.        rather than non-positive line numbers.  */
  1999.     as_warn (_("line numbers must be positive; line number %d rejected"),
  2000.              l + 1);
  2001.   else
  2002.     {
  2003.       int flags = 0;
  2004.       int length = 0;
  2005.  
  2006.       if (!appline)
  2007.         {
  2008.           SKIP_WHITESPACE ();
  2009.  
  2010.           if (*input_line_pointer == '"')
  2011.             file = demand_copy_string (&length);
  2012.  
  2013.           if (file)
  2014.             {
  2015.               int this_flag;
  2016.  
  2017.               while (get_linefile_number (&this_flag))
  2018.                 switch (this_flag)
  2019.                   {
  2020.                     /* From GCC's cpp documentation:
  2021.                        1: start of a new file.
  2022.                        2: returning to a file after having included
  2023.                           another file.
  2024.                        3: following text comes from a system header file.
  2025.                        4: following text should be treated as extern "C".
  2026.  
  2027.                        4 is nonsensical for the assembler; 3, we don't
  2028.                        care about, so we ignore it just in case a
  2029.                        system header file is included while
  2030.                        preprocessing assembly.  So 1 and 2 are all we
  2031.                        care about, and they are mutually incompatible.
  2032.                        new_logical_line_flags() demands this.  */
  2033.                   case 1:
  2034.                   case 2:
  2035.                     if (flags && flags != (1 << this_flag))
  2036.                       as_warn (_("incompatible flag %i in line directive"),
  2037.                                this_flag);
  2038.                     else
  2039.                       flags |= 1 << this_flag;
  2040.                     break;
  2041.  
  2042.                   case 3:
  2043.                   case 4:
  2044.                     /* We ignore these.  */
  2045.                     break;
  2046.  
  2047.                   default:
  2048.                     as_warn (_("unsupported flag %i in line directive"),
  2049.                              this_flag);
  2050.                     break;
  2051.                   }
  2052.  
  2053.               if (!is_end_of_line[(unsigned char)*input_line_pointer])
  2054.                 file = 0;
  2055.             }
  2056.         }
  2057.  
  2058.       if (appline || file)
  2059.         {
  2060.           new_logical_line_flags (file, l, flags);
  2061. #ifdef LISTING
  2062.           if (listing)
  2063.             listing_source_line (l);
  2064. #endif
  2065.         }
  2066.     }
  2067.   if (appline || file)
  2068.     demand_empty_rest_of_line ();
  2069.   else
  2070.     ignore_rest_of_line ();
  2071. }
  2072.  
  2073. /* Handle the .end pseudo-op.  Actually, the real work is done in
  2074.    read_a_source_file.  */
  2075.  
  2076. void
  2077. s_end (int ignore ATTRIBUTE_UNUSED)
  2078. {
  2079.   if (flag_mri)
  2080.     {
  2081.       /* The MRI assembler permits the start symbol to follow .end,
  2082.          but we don't support that.  */
  2083.       SKIP_WHITESPACE ();
  2084.       if (!is_end_of_line[(unsigned char) *input_line_pointer]
  2085.           && *input_line_pointer != '*'
  2086.           && *input_line_pointer != '!')
  2087.         as_warn (_("start address not supported"));
  2088.     }
  2089. }
  2090.  
  2091. /* Handle the .err pseudo-op.  */
  2092.  
  2093. void
  2094. s_err (int ignore ATTRIBUTE_UNUSED)
  2095. {
  2096.   as_bad (_(".err encountered"));
  2097.   demand_empty_rest_of_line ();
  2098. }
  2099.  
  2100. /* Handle the .error and .warning pseudo-ops.  */
  2101.  
  2102. void
  2103. s_errwarn (int err)
  2104. {
  2105.   int len;
  2106.   /* The purpose for the conditional assignment is not to
  2107.      internationalize the directive itself, but that we need a
  2108.      self-contained message, one that can be passed like the
  2109.      demand_copy_C_string return value, and with no assumption on the
  2110.      location of the name of the directive within the message.  */
  2111.   char *msg
  2112.     = (err ? _(".error directive invoked in source file")
  2113.        : _(".warning directive invoked in source file"));
  2114.  
  2115.   if (!is_it_end_of_statement ())
  2116.     {
  2117.       if (*input_line_pointer != '\"')
  2118.         {
  2119.           as_bad (_("%s argument must be a string"),
  2120.                   err ? ".error" : ".warning");
  2121.           ignore_rest_of_line ();
  2122.           return;
  2123.         }
  2124.  
  2125.       msg = demand_copy_C_string (&len);
  2126.       if (msg == NULL)
  2127.         return;
  2128.     }
  2129.  
  2130.   if (err)
  2131.     as_bad ("%s", msg);
  2132.   else
  2133.     as_warn ("%s", msg);
  2134.   demand_empty_rest_of_line ();
  2135. }
  2136.  
  2137. /* Handle the MRI fail pseudo-op.  */
  2138.  
  2139. void
  2140. s_fail (int ignore ATTRIBUTE_UNUSED)
  2141. {
  2142.   offsetT temp;
  2143.   char *stop = NULL;
  2144.   char stopc = 0;
  2145.  
  2146.   if (flag_mri)
  2147.     stop = mri_comment_field (&stopc);
  2148.  
  2149.   temp = get_absolute_expression ();
  2150.   if (temp >= 500)
  2151.     as_warn (_(".fail %ld encountered"), (long) temp);
  2152.   else
  2153.     as_bad (_(".fail %ld encountered"), (long) temp);
  2154.  
  2155.   demand_empty_rest_of_line ();
  2156.  
  2157.   if (flag_mri)
  2158.     mri_comment_end (stop, stopc);
  2159. }
  2160.  
  2161. void
  2162. s_fill (int ignore ATTRIBUTE_UNUSED)
  2163. {
  2164.   expressionS rep_exp;
  2165.   long size = 1;
  2166.   long fill = 0;
  2167.   char *p;
  2168.  
  2169. #ifdef md_flush_pending_output
  2170.   md_flush_pending_output ();
  2171. #endif
  2172.  
  2173. #ifdef md_cons_align
  2174.   md_cons_align (1);
  2175. #endif
  2176.  
  2177.   get_known_segmented_expression (&rep_exp);
  2178.   if (*input_line_pointer == ',')
  2179.     {
  2180.       input_line_pointer++;
  2181.       size = get_absolute_expression ();
  2182.       if (*input_line_pointer == ',')
  2183.         {
  2184.           input_line_pointer++;
  2185.           fill = get_absolute_expression ();
  2186.         }
  2187.     }
  2188.  
  2189.   /* This is to be compatible with BSD 4.2 AS, not for any rational reason.  */
  2190. #define BSD_FILL_SIZE_CROCK_8 (8)
  2191.   if (size > BSD_FILL_SIZE_CROCK_8)
  2192.     {
  2193.       as_warn (_(".fill size clamped to %d"), BSD_FILL_SIZE_CROCK_8);
  2194.       size = BSD_FILL_SIZE_CROCK_8;
  2195.     }
  2196.   if (size < 0)
  2197.     {
  2198.       as_warn (_("size negative; .fill ignored"));
  2199.       size = 0;
  2200.     }
  2201.   else if (rep_exp.X_op == O_constant && rep_exp.X_add_number <= 0)
  2202.     {
  2203.       if (rep_exp.X_add_number < 0)
  2204.         as_warn (_("repeat < 0; .fill ignored"));
  2205.       size = 0;
  2206.     }
  2207.  
  2208.   if (size && !need_pass_2)
  2209.     {
  2210.       if (rep_exp.X_op == O_constant)
  2211.         {
  2212.           p = frag_var (rs_fill, (int) size, (int) size,
  2213.                         (relax_substateT) 0, (symbolS *) 0,
  2214.                         (offsetT) rep_exp.X_add_number,
  2215.                         (char *) 0);
  2216.         }
  2217.       else
  2218.         {
  2219.           /* We don't have a constant repeat count, so we can't use
  2220.              rs_fill.  We can get the same results out of rs_space,
  2221.              but its argument is in bytes, so we must multiply the
  2222.              repeat count by size.  */
  2223.  
  2224.           symbolS *rep_sym;
  2225.           rep_sym = make_expr_symbol (&rep_exp);
  2226.           if (size != 1)
  2227.             {
  2228.               expressionS size_exp;
  2229.               size_exp.X_op = O_constant;
  2230.               size_exp.X_add_number = size;
  2231.  
  2232.               rep_exp.X_op = O_multiply;
  2233.               rep_exp.X_add_symbol = rep_sym;
  2234.               rep_exp.X_op_symbol = make_expr_symbol (&size_exp);
  2235.               rep_exp.X_add_number = 0;
  2236.               rep_sym = make_expr_symbol (&rep_exp);
  2237.             }
  2238.  
  2239.           p = frag_var (rs_space, (int) size, (int) size,
  2240.                         (relax_substateT) 0, rep_sym, (offsetT) 0, (char *) 0);
  2241.         }
  2242.  
  2243.       memset (p, 0, (unsigned int) size);
  2244.  
  2245.       /* The magic number BSD_FILL_SIZE_CROCK_4 is from BSD 4.2 VAX
  2246.          flavoured AS.  The following bizarre behaviour is to be
  2247.          compatible with above.  I guess they tried to take up to 8
  2248.          bytes from a 4-byte expression and they forgot to sign
  2249.          extend.  */
  2250. #define BSD_FILL_SIZE_CROCK_4 (4)
  2251.       md_number_to_chars (p, (valueT) fill,
  2252.                           (size > BSD_FILL_SIZE_CROCK_4
  2253.                            ? BSD_FILL_SIZE_CROCK_4
  2254.                            : (int) size));
  2255.       /* Note: .fill (),0 emits no frag (since we are asked to .fill 0 bytes)
  2256.          but emits no error message because it seems a legal thing to do.
  2257.          It is a degenerate case of .fill but could be emitted by a
  2258.          compiler.  */
  2259.     }
  2260.   demand_empty_rest_of_line ();
  2261. }
  2262.  
  2263. void
  2264. s_globl (int ignore ATTRIBUTE_UNUSED)
  2265. {
  2266.   char *name;
  2267.   int c;
  2268.   symbolS *symbolP;
  2269.   char *stop = NULL;
  2270.   char stopc = 0;
  2271.  
  2272.   if (flag_mri)
  2273.     stop = mri_comment_field (&stopc);
  2274.  
  2275.   do
  2276.     {
  2277.       if ((name = read_symbol_name ()) == NULL)
  2278.         return;
  2279.  
  2280.       symbolP = symbol_find_or_make (name);
  2281.       S_SET_EXTERNAL (symbolP);
  2282.  
  2283.       SKIP_WHITESPACE ();
  2284.       c = *input_line_pointer;
  2285.       if (c == ',')
  2286.         {
  2287.           input_line_pointer++;
  2288.           SKIP_WHITESPACE ();
  2289.           if (is_end_of_line[(unsigned char) *input_line_pointer])
  2290.             c = '\n';
  2291.         }
  2292.  
  2293.       free (name);
  2294.     }
  2295.   while (c == ',');
  2296.  
  2297.   demand_empty_rest_of_line ();
  2298.  
  2299.   if (flag_mri)
  2300.     mri_comment_end (stop, stopc);
  2301. }
  2302.  
  2303. /* Handle the MRI IRP and IRPC pseudo-ops.  */
  2304.  
  2305. void
  2306. s_irp (int irpc)
  2307. {
  2308.   char *file, *eol;
  2309.   unsigned int line;
  2310.   sb s;
  2311.   const char *err;
  2312.   sb out;
  2313.  
  2314.   as_where (&file, &line);
  2315.  
  2316.   eol = find_end_of_line (input_line_pointer, 0);
  2317.   sb_build (&s, eol - input_line_pointer);
  2318.   sb_add_buffer (&s, input_line_pointer, eol - input_line_pointer);
  2319.   input_line_pointer = eol;
  2320.  
  2321.   sb_new (&out);
  2322.  
  2323.   err = expand_irp (irpc, 0, &s, &out, get_non_macro_line_sb);
  2324.   if (err != NULL)
  2325.     as_bad_where (file, line, "%s", err);
  2326.  
  2327.   sb_kill (&s);
  2328.  
  2329.   input_scrub_include_sb (&out, input_line_pointer, 1);
  2330.   sb_kill (&out);
  2331.   buffer_limit = input_scrub_next_buffer (&input_line_pointer);
  2332. }
  2333.  
  2334. /* Handle the .linkonce pseudo-op.  This tells the assembler to mark
  2335.    the section to only be linked once.  However, this is not supported
  2336.    by most object file formats.  This takes an optional argument,
  2337.    which is what to do about duplicates.  */
  2338.  
  2339. void
  2340. s_linkonce (int ignore ATTRIBUTE_UNUSED)
  2341. {
  2342.   enum linkonce_type type;
  2343.  
  2344.   SKIP_WHITESPACE ();
  2345.  
  2346.   type = LINKONCE_DISCARD;
  2347.  
  2348.   if (!is_end_of_line[(unsigned char) *input_line_pointer])
  2349.     {
  2350.       char *s;
  2351.       char c;
  2352.  
  2353.       c = get_symbol_name (& s);
  2354.       if (strcasecmp (s, "discard") == 0)
  2355.         type = LINKONCE_DISCARD;
  2356.       else if (strcasecmp (s, "one_only") == 0)
  2357.         type = LINKONCE_ONE_ONLY;
  2358.       else if (strcasecmp (s, "same_size") == 0)
  2359.         type = LINKONCE_SAME_SIZE;
  2360.       else if (strcasecmp (s, "same_contents") == 0)
  2361.         type = LINKONCE_SAME_CONTENTS;
  2362.       else
  2363.         as_warn (_("unrecognized .linkonce type `%s'"), s);
  2364.  
  2365.       (void) restore_line_pointer (c);
  2366.     }
  2367.  
  2368. #ifdef obj_handle_link_once
  2369.   obj_handle_link_once (type);
  2370. #else /* ! defined (obj_handle_link_once) */
  2371.   {
  2372.     flagword flags;
  2373.  
  2374.     if ((bfd_applicable_section_flags (stdoutput) & SEC_LINK_ONCE) == 0)
  2375.       as_warn (_(".linkonce is not supported for this object file format"));
  2376.  
  2377.     flags = bfd_get_section_flags (stdoutput, now_seg);
  2378.     flags |= SEC_LINK_ONCE;
  2379.     switch (type)
  2380.       {
  2381.       default:
  2382.         abort ();
  2383.       case LINKONCE_DISCARD:
  2384.         flags |= SEC_LINK_DUPLICATES_DISCARD;
  2385.         break;
  2386.       case LINKONCE_ONE_ONLY:
  2387.         flags |= SEC_LINK_DUPLICATES_ONE_ONLY;
  2388.         break;
  2389.       case LINKONCE_SAME_SIZE:
  2390.         flags |= SEC_LINK_DUPLICATES_SAME_SIZE;
  2391.         break;
  2392.       case LINKONCE_SAME_CONTENTS:
  2393.         flags |= SEC_LINK_DUPLICATES_SAME_CONTENTS;
  2394.         break;
  2395.       }
  2396.     if (!bfd_set_section_flags (stdoutput, now_seg, flags))
  2397.       as_bad (_("bfd_set_section_flags: %s"),
  2398.               bfd_errmsg (bfd_get_error ()));
  2399.   }
  2400. #endif /* ! defined (obj_handle_link_once) */
  2401.  
  2402.   demand_empty_rest_of_line ();
  2403. }
  2404.  
  2405. void
  2406. bss_alloc (symbolS *symbolP, addressT size, int align)
  2407. {
  2408.   char *pfrag;
  2409.   segT current_seg = now_seg;
  2410.   subsegT current_subseg = now_subseg;
  2411.   segT bss_seg = bss_section;
  2412.  
  2413. #if defined (TC_MIPS) || defined (TC_ALPHA)
  2414.   if (OUTPUT_FLAVOR == bfd_target_ecoff_flavour
  2415.       || OUTPUT_FLAVOR == bfd_target_elf_flavour)
  2416.     {
  2417.       /* For MIPS and Alpha ECOFF or ELF, small objects are put in .sbss.  */
  2418.       if (size <= bfd_get_gp_size (stdoutput))
  2419.         {
  2420.           bss_seg = subseg_new (".sbss", 1);
  2421.           seg_info (bss_seg)->bss = 1;
  2422.           if (!bfd_set_section_flags (stdoutput, bss_seg, SEC_ALLOC))
  2423.             as_warn (_("error setting flags for \".sbss\": %s"),
  2424.                      bfd_errmsg (bfd_get_error ()));
  2425.         }
  2426.     }
  2427. #endif
  2428.   subseg_set (bss_seg, 1);
  2429.  
  2430.   if (align)
  2431.     {
  2432.       record_alignment (bss_seg, align);
  2433.       frag_align (align, 0, 0);
  2434.     }
  2435.  
  2436.   /* Detach from old frag.  */
  2437.   if (S_GET_SEGMENT (symbolP) == bss_seg)
  2438.     symbol_get_frag (symbolP)->fr_symbol = NULL;
  2439.  
  2440.   symbol_set_frag (symbolP, frag_now);
  2441.   pfrag = frag_var (rs_org, 1, 1, 0, symbolP, size, NULL);
  2442.   *pfrag = 0;
  2443.  
  2444. #ifdef S_SET_SIZE
  2445.   S_SET_SIZE (symbolP, size);
  2446. #endif
  2447.   S_SET_SEGMENT (symbolP, bss_seg);
  2448.  
  2449. #ifdef OBJ_COFF
  2450.   /* The symbol may already have been created with a preceding
  2451.      ".globl" directive -- be careful not to step on storage class
  2452.      in that case.  Otherwise, set it to static.  */
  2453.   if (S_GET_STORAGE_CLASS (symbolP) != C_EXT)
  2454.     S_SET_STORAGE_CLASS (symbolP, C_STAT);
  2455. #endif /* OBJ_COFF */
  2456.  
  2457.   subseg_set (current_seg, current_subseg);
  2458. }
  2459.  
  2460. offsetT
  2461. parse_align (int align_bytes)
  2462. {
  2463.   expressionS exp;
  2464.   addressT align;
  2465.  
  2466.   SKIP_WHITESPACE ();
  2467.   if (*input_line_pointer != ',')
  2468.     {
  2469.     no_align:
  2470.       as_bad (_("expected alignment after size"));
  2471.       ignore_rest_of_line ();
  2472.       return -1;
  2473.     }
  2474.  
  2475.   input_line_pointer++;
  2476.   SKIP_WHITESPACE ();
  2477.  
  2478.   align = get_absolute_expr (&exp);
  2479.   if (exp.X_op == O_absent)
  2480.     goto no_align;
  2481.  
  2482.   if (!exp.X_unsigned)
  2483.     {
  2484.       as_warn (_("alignment negative; 0 assumed"));
  2485.       align = 0;
  2486.     }
  2487.  
  2488.   if (align_bytes && align != 0)
  2489.     {
  2490.       /* convert to a power of 2 alignment */
  2491.       unsigned int alignp2 = 0;
  2492.       while ((align & 1) == 0)
  2493.         align >>= 1, ++alignp2;
  2494.       if (align != 1)
  2495.         {
  2496.           as_bad (_("alignment not a power of 2"));
  2497.           ignore_rest_of_line ();
  2498.           return -1;
  2499.         }
  2500.       align = alignp2;
  2501.     }
  2502.   return align;
  2503. }
  2504.  
  2505. /* Called from s_comm_internal after symbol name and size have been
  2506.    parsed.  NEEDS_ALIGN is 0 if it was an ".lcomm" (2 args only),
  2507.    1 if this was a ".bss" directive which has a 3rd argument
  2508.    (alignment as a power of 2), or 2 if this was a ".bss" directive
  2509.    with alignment in bytes.  */
  2510.  
  2511. symbolS *
  2512. s_lcomm_internal (int needs_align, symbolS *symbolP, addressT size)
  2513. {
  2514.   addressT align = 0;
  2515.  
  2516.   if (needs_align)
  2517.     {
  2518.       align = parse_align (needs_align - 1);
  2519.       if (align == (addressT) -1)
  2520.         return NULL;
  2521.     }
  2522.   else
  2523.     /* Assume some objects may require alignment on some systems.  */
  2524.     TC_IMPLICIT_LCOMM_ALIGNMENT (size, align);
  2525.  
  2526.   bss_alloc (symbolP, size, align);
  2527.   return symbolP;
  2528. }
  2529.  
  2530. void
  2531. s_lcomm (int needs_align)
  2532. {
  2533.   s_comm_internal (needs_align, s_lcomm_internal);
  2534. }
  2535.  
  2536. void
  2537. s_lcomm_bytes (int needs_align)
  2538. {
  2539.   s_comm_internal (needs_align * 2, s_lcomm_internal);
  2540. }
  2541.  
  2542. void
  2543. s_lsym (int ignore ATTRIBUTE_UNUSED)
  2544. {
  2545.   char *name;
  2546.   expressionS exp;
  2547.   symbolS *symbolP;
  2548.  
  2549.   /* We permit ANY defined expression: BSD4.2 demands constants.  */
  2550.   if ((name = read_symbol_name ()) == NULL)
  2551.     return;
  2552.  
  2553.   if (*input_line_pointer != ',')
  2554.     {
  2555.       as_bad (_("expected comma after \"%s\""), name);
  2556.       goto err_out;
  2557.     }
  2558.  
  2559.   input_line_pointer++;
  2560.   expression_and_evaluate (&exp);
  2561.  
  2562.   if (exp.X_op != O_constant
  2563.       && exp.X_op != O_register)
  2564.     {
  2565.       as_bad (_("bad expression"));
  2566.       goto err_out;
  2567.     }
  2568.  
  2569.   symbolP = symbol_find_or_make (name);
  2570.  
  2571.   if (S_GET_SEGMENT (symbolP) == undefined_section)
  2572.     {
  2573.       /* The name might be an undefined .global symbol; be sure to
  2574.          keep the "external" bit.  */
  2575.       S_SET_SEGMENT (symbolP,
  2576.                      (exp.X_op == O_constant
  2577.                       ? absolute_section
  2578.                       : reg_section));
  2579.       S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
  2580.     }
  2581.   else
  2582.     {
  2583.       as_bad (_("symbol `%s' is already defined"), name);
  2584.     }
  2585.  
  2586.   demand_empty_rest_of_line ();
  2587.   free (name);
  2588.   return;
  2589.  
  2590.  err_out:
  2591.   ignore_rest_of_line ();
  2592.   free (name);
  2593.   return;
  2594. }
  2595.  
  2596. /* Read a line into an sb.  Returns the character that ended the line
  2597.    or zero if there are no more lines.  */
  2598.  
  2599. static int
  2600. get_line_sb (sb *line, int in_macro)
  2601. {
  2602.   char *eol;
  2603.  
  2604.   if (input_line_pointer[-1] == '\n')
  2605.     bump_line_counters ();
  2606.  
  2607.   if (input_line_pointer >= buffer_limit)
  2608.     {
  2609.       buffer_limit = input_scrub_next_buffer (&input_line_pointer);
  2610.       if (buffer_limit == 0)
  2611.         return 0;
  2612.     }
  2613.  
  2614.   eol = _find_end_of_line (input_line_pointer, flag_m68k_mri, 0, in_macro);
  2615.   sb_add_buffer (line, input_line_pointer, eol - input_line_pointer);
  2616.   input_line_pointer = eol;
  2617.  
  2618.   /* Don't skip multiple end-of-line characters, because that breaks support
  2619.      for the IA-64 stop bit (;;) which looks like two consecutive end-of-line
  2620.      characters but isn't.  Instead just skip one end of line character and
  2621.      return the character skipped so that the caller can re-insert it if
  2622.      necessary.   */
  2623.   return *input_line_pointer++;
  2624. }
  2625.  
  2626. static size_t
  2627. get_non_macro_line_sb (sb *line)
  2628. {
  2629.   return get_line_sb (line, 0);
  2630. }
  2631.  
  2632. static size_t
  2633. get_macro_line_sb (sb *line)
  2634. {
  2635.   return get_line_sb (line, 1);
  2636. }
  2637.  
  2638. /* Define a macro.  This is an interface to macro.c.  */
  2639.  
  2640. void
  2641. s_macro (int ignore ATTRIBUTE_UNUSED)
  2642. {
  2643.   char *file, *eol;
  2644.   unsigned int line;
  2645.   sb s;
  2646.   const char *err;
  2647.   const char *name;
  2648.  
  2649.   as_where (&file, &line);
  2650.  
  2651.   eol = find_end_of_line (input_line_pointer, 0);
  2652.   sb_build (&s, eol - input_line_pointer);
  2653.   sb_add_buffer (&s, input_line_pointer, eol - input_line_pointer);
  2654.   input_line_pointer = eol;
  2655.  
  2656.   if (line_label != NULL)
  2657.     {
  2658.       sb label;
  2659.       size_t len;
  2660.  
  2661.       name = S_GET_NAME (line_label);
  2662.       len = strlen (name);
  2663.       sb_build (&label, len);
  2664.       sb_add_buffer (&label, name, len);
  2665.       err = define_macro (0, &s, &label, get_macro_line_sb, file, line, &name);
  2666.       sb_kill (&label);
  2667.     }
  2668.   else
  2669.     err = define_macro (0, &s, NULL, get_macro_line_sb, file, line, &name);
  2670.   if (err != NULL)
  2671.     as_bad_where (file, line, err, name);
  2672.   else
  2673.     {
  2674.       if (line_label != NULL)
  2675.         {
  2676.           S_SET_SEGMENT (line_label, absolute_section);
  2677.           S_SET_VALUE (line_label, 0);
  2678.           symbol_set_frag (line_label, &zero_address_frag);
  2679.         }
  2680.  
  2681.       if (((NO_PSEUDO_DOT || flag_m68k_mri)
  2682.            && hash_find (po_hash, name) != NULL)
  2683.           || (!flag_m68k_mri
  2684.               && *name == '.'
  2685.               && hash_find (po_hash, name + 1) != NULL))
  2686.         as_warn_where (file,
  2687.                  line,
  2688.                  _("attempt to redefine pseudo-op `%s' ignored"),
  2689.                  name);
  2690.     }
  2691.  
  2692.   sb_kill (&s);
  2693. }
  2694.  
  2695. /* Handle the .mexit pseudo-op, which immediately exits a macro
  2696.    expansion.  */
  2697.  
  2698. void
  2699. s_mexit (int ignore ATTRIBUTE_UNUSED)
  2700. {
  2701.   if (macro_nest)
  2702.     {
  2703.       cond_exit_macro (macro_nest);
  2704.       buffer_limit = input_scrub_next_buffer (&input_line_pointer);
  2705.     }
  2706.   else
  2707.     as_warn (_("ignoring macro exit outside a macro definition."));
  2708. }
  2709.  
  2710. /* Switch in and out of MRI mode.  */
  2711.  
  2712. void
  2713. s_mri (int ignore ATTRIBUTE_UNUSED)
  2714. {
  2715.   int on;
  2716. #ifdef MRI_MODE_CHANGE
  2717.   int old_flag;
  2718. #endif
  2719.  
  2720.   on = get_absolute_expression ();
  2721. #ifdef MRI_MODE_CHANGE
  2722.   old_flag = flag_mri;
  2723. #endif
  2724.   if (on != 0)
  2725.     {
  2726.       flag_mri = 1;
  2727. #ifdef TC_M68K
  2728.       flag_m68k_mri = 1;
  2729. #endif
  2730.       macro_mri_mode (1);
  2731.     }
  2732.   else
  2733.     {
  2734.       flag_mri = 0;
  2735. #ifdef TC_M68K
  2736.       flag_m68k_mri = 0;
  2737. #endif
  2738.       macro_mri_mode (0);
  2739.     }
  2740.  
  2741.   /* Operator precedence changes in m68k MRI mode, so we need to
  2742.      update the operator rankings.  */
  2743.   expr_set_precedence ();
  2744.  
  2745. #ifdef MRI_MODE_CHANGE
  2746.   if (on != old_flag)
  2747.     MRI_MODE_CHANGE (on);
  2748. #endif
  2749.  
  2750.   demand_empty_rest_of_line ();
  2751. }
  2752.  
  2753. /* Handle changing the location counter.  */
  2754.  
  2755. static void
  2756. do_org (segT segment, expressionS *exp, int fill)
  2757. {
  2758.   if (segment != now_seg
  2759.       && segment != absolute_section
  2760.       && segment != expr_section)
  2761.     as_bad (_("invalid segment \"%s\""), segment_name (segment));
  2762.  
  2763.   if (now_seg == absolute_section)
  2764.     {
  2765.       if (fill != 0)
  2766.         as_warn (_("ignoring fill value in absolute section"));
  2767.       if (exp->X_op != O_constant)
  2768.         {
  2769.           as_bad (_("only constant offsets supported in absolute section"));
  2770.           exp->X_add_number = 0;
  2771.         }
  2772.       abs_section_offset = exp->X_add_number;
  2773.     }
  2774.   else
  2775.     {
  2776.       char *p;
  2777.       symbolS *sym = exp->X_add_symbol;
  2778.       offsetT off = exp->X_add_number * OCTETS_PER_BYTE;
  2779.  
  2780.       if (exp->X_op != O_constant && exp->X_op != O_symbol)
  2781.         {
  2782.           /* Handle complex expressions.  */
  2783.           sym = make_expr_symbol (exp);
  2784.           off = 0;
  2785.         }
  2786.  
  2787.       p = frag_var (rs_org, 1, 1, (relax_substateT) 0, sym, off, (char *) 0);
  2788.       *p = fill;
  2789.     }
  2790. }
  2791.  
  2792. void
  2793. s_org (int ignore ATTRIBUTE_UNUSED)
  2794. {
  2795.   segT segment;
  2796.   expressionS exp;
  2797.   long temp_fill;
  2798.  
  2799. #ifdef md_flush_pending_output
  2800.   md_flush_pending_output ();
  2801. #endif
  2802.  
  2803.   /* The m68k MRI assembler has a different meaning for .org.  It
  2804.      means to create an absolute section at a given address.  We can't
  2805.      support that--use a linker script instead.  */
  2806.   if (flag_m68k_mri)
  2807.     {
  2808.       as_bad (_("MRI style ORG pseudo-op not supported"));
  2809.       ignore_rest_of_line ();
  2810.       return;
  2811.     }
  2812.  
  2813.   /* Don't believe the documentation of BSD 4.2 AS.  There is no such
  2814.      thing as a sub-segment-relative origin.  Any absolute origin is
  2815.      given a warning, then assumed to be segment-relative.  Any
  2816.      segmented origin expression ("foo+42") had better be in the right
  2817.      segment or the .org is ignored.
  2818.  
  2819.      BSD 4.2 AS warns if you try to .org backwards. We cannot because
  2820.      we never know sub-segment sizes when we are reading code.  BSD
  2821.      will crash trying to emit negative numbers of filler bytes in
  2822.      certain .orgs. We don't crash, but see as-write for that code.
  2823.  
  2824.      Don't make frag if need_pass_2==1.  */
  2825.   segment = get_known_segmented_expression (&exp);
  2826.   if (*input_line_pointer == ',')
  2827.     {
  2828.       input_line_pointer++;
  2829.       temp_fill = get_absolute_expression ();
  2830.     }
  2831.   else
  2832.     temp_fill = 0;
  2833.  
  2834.   if (!need_pass_2)
  2835.     do_org (segment, &exp, temp_fill);
  2836.  
  2837.   demand_empty_rest_of_line ();
  2838. }
  2839.  
  2840. /* Handle parsing for the MRI SECT/SECTION pseudo-op.  This should be
  2841.    called by the obj-format routine which handles section changing
  2842.    when in MRI mode.  It will create a new section, and return it.  It
  2843.    will set *TYPE to the section type: one of 'C' (code), 'D' (data),
  2844.    'M' (mixed), or 'R' (romable).  The flags will be set in the section.  */
  2845.  
  2846. void
  2847. s_mri_sect (char *type ATTRIBUTE_UNUSED)
  2848. {
  2849. #ifdef TC_M68K
  2850.  
  2851.   char *name;
  2852.   char c;
  2853.   segT seg;
  2854.  
  2855.   SKIP_WHITESPACE ();
  2856.  
  2857.   name = input_line_pointer;
  2858.   if (!ISDIGIT (*name))
  2859.     c = get_symbol_name (& name);
  2860.   else
  2861.     {
  2862.       do
  2863.         {
  2864.           ++input_line_pointer;
  2865.         }
  2866.       while (ISDIGIT (*input_line_pointer));
  2867.  
  2868.       c = *input_line_pointer;
  2869.       *input_line_pointer = '\0';
  2870.     }
  2871.  
  2872.   name = xstrdup (name);
  2873.  
  2874.   c = restore_line_pointer (c);
  2875.  
  2876.   seg = subseg_new (name, 0);
  2877.  
  2878.   if (c == ',')
  2879.     {
  2880.       int align;
  2881.  
  2882.       ++input_line_pointer;
  2883.       align = get_absolute_expression ();
  2884.       record_alignment (seg, align);
  2885.     }
  2886.  
  2887.   *type = 'C';
  2888.   if (*input_line_pointer == ',')
  2889.     {
  2890.       c = *++input_line_pointer;
  2891.       c = TOUPPER (c);
  2892.       if (c == 'C' || c == 'D' || c == 'M' || c == 'R')
  2893.         *type = c;
  2894.       else
  2895.         as_bad (_("unrecognized section type"));
  2896.       ++input_line_pointer;
  2897.  
  2898.       {
  2899.         flagword flags;
  2900.  
  2901.         flags = SEC_NO_FLAGS;
  2902.         if (*type == 'C')
  2903.           flags = SEC_ALLOC | SEC_LOAD | SEC_READONLY | SEC_CODE;
  2904.         else if (*type == 'D' || *type == 'M')
  2905.           flags = SEC_ALLOC | SEC_LOAD | SEC_DATA;
  2906.         else if (*type == 'R')
  2907.           flags = SEC_ALLOC | SEC_LOAD | SEC_DATA | SEC_READONLY | SEC_ROM;
  2908.         if (flags != SEC_NO_FLAGS)
  2909.           {
  2910.             if (!bfd_set_section_flags (stdoutput, seg, flags))
  2911.               as_warn (_("error setting flags for \"%s\": %s"),
  2912.                        bfd_section_name (stdoutput, seg),
  2913.                        bfd_errmsg (bfd_get_error ()));
  2914.           }
  2915.       }
  2916.     }
  2917.  
  2918.   /* Ignore the HP type.  */
  2919.   if (*input_line_pointer == ',')
  2920.     input_line_pointer += 2;
  2921.  
  2922.   demand_empty_rest_of_line ();
  2923.  
  2924. #else /* ! TC_M68K */
  2925. #ifdef TC_I960
  2926.  
  2927.   char *name;
  2928.   char c;
  2929.   segT seg;
  2930.  
  2931.   SKIP_WHITESPACE ();
  2932.  
  2933.   c = get_symbol_name (& name);
  2934.  
  2935.   name = xstrdup (name);
  2936.  
  2937.   c = restore_line_pointer (c);
  2938.  
  2939.   seg = subseg_new (name, 0);
  2940.  
  2941.   if (c != ',')
  2942.     *type = 'C';
  2943.   else
  2944.     {
  2945.       char *sectype;
  2946.  
  2947.       ++input_line_pointer;
  2948.       SKIP_WHITESPACE ();
  2949.       c = get_symbol_name (& sectype);
  2950.       if (*sectype == '\0')
  2951.         *type = 'C';
  2952.       else if (strcasecmp (sectype, "text") == 0)
  2953.         *type = 'C';
  2954.       else if (strcasecmp (sectype, "data") == 0)
  2955.         *type = 'D';
  2956.       else if (strcasecmp (sectype, "romdata") == 0)
  2957.         *type = 'R';
  2958.       else
  2959.         as_warn (_("unrecognized section type `%s'"), sectype);
  2960.       (void) restore_line_pointer (c);
  2961.     }
  2962.  
  2963.   if (*input_line_pointer == ',')
  2964.     {
  2965.       char *seccmd;
  2966.  
  2967.       ++input_line_pointer;
  2968.       SKIP_WHITESPACE ();
  2969.       c = get_symbol_name (& seccmd);
  2970.       if (strcasecmp (seccmd, "absolute") == 0)
  2971.         {
  2972.           as_bad (_("absolute sections are not supported"));
  2973.           *input_line_pointer = c;
  2974.           ignore_rest_of_line ();
  2975.           return;
  2976.         }
  2977.       else if (strcasecmp (seccmd, "align") == 0)
  2978.         {
  2979.           int align;
  2980.  
  2981.           (void) restore_line_pointer (c);
  2982.           align = get_absolute_expression ();
  2983.           record_alignment (seg, align);
  2984.         }
  2985.       else
  2986.         {
  2987.           as_warn (_("unrecognized section command `%s'"), seccmd);
  2988.           (void) restore_line_pointer (c);
  2989.         }
  2990.     }
  2991.  
  2992.   demand_empty_rest_of_line ();
  2993.  
  2994. #else /* ! TC_I960 */
  2995.   /* The MRI assembler seems to use different forms of .sect for
  2996.      different targets.  */
  2997.   as_bad ("MRI mode not supported for this target");
  2998.   ignore_rest_of_line ();
  2999. #endif /* ! TC_I960 */
  3000. #endif /* ! TC_M68K */
  3001. }
  3002.  
  3003. /* Handle the .print pseudo-op.  */
  3004.  
  3005. void
  3006. s_print (int ignore ATTRIBUTE_UNUSED)
  3007. {
  3008.   char *s;
  3009.   int len;
  3010.  
  3011.   s = demand_copy_C_string (&len);
  3012.   if (s != NULL)
  3013.     printf ("%s\n", s);
  3014.   demand_empty_rest_of_line ();
  3015. }
  3016.  
  3017. /* Handle the .purgem pseudo-op.  */
  3018.  
  3019. void
  3020. s_purgem (int ignore ATTRIBUTE_UNUSED)
  3021. {
  3022.   if (is_it_end_of_statement ())
  3023.     {
  3024.       demand_empty_rest_of_line ();
  3025.       return;
  3026.     }
  3027.  
  3028.   do
  3029.     {
  3030.       char *name;
  3031.       char c;
  3032.  
  3033.       SKIP_WHITESPACE ();
  3034.       c = get_symbol_name (& name);
  3035.       delete_macro (name);
  3036.       *input_line_pointer = c;
  3037.       SKIP_WHITESPACE_AFTER_NAME ();
  3038.     }
  3039.   while (*input_line_pointer++ == ',');
  3040.  
  3041.   --input_line_pointer;
  3042.   demand_empty_rest_of_line ();
  3043. }
  3044.  
  3045. /* Handle the .endm/.endr pseudo-ops.  */
  3046.  
  3047. static void
  3048. s_bad_end (int endr)
  3049. {
  3050.   as_warn (_(".end%c encountered without preceding %s"),
  3051.            endr ? 'r' : 'm',
  3052.            endr ? ".rept, .irp, or .irpc" : ".macro");
  3053.   demand_empty_rest_of_line ();
  3054. }
  3055.  
  3056. /* Handle the .rept pseudo-op.  */
  3057.  
  3058. void
  3059. s_rept (int ignore ATTRIBUTE_UNUSED)
  3060. {
  3061.   int count;
  3062.  
  3063.   count = get_absolute_expression ();
  3064.  
  3065.   do_repeat (count, "REPT", "ENDR");
  3066. }
  3067.  
  3068. /* This function provides a generic repeat block implementation.   It allows
  3069.    different directives to be used as the start/end keys.  */
  3070.  
  3071. void
  3072. do_repeat (int count, const char *start, const char *end)
  3073. {
  3074.   sb one;
  3075.   sb many;
  3076.  
  3077.   sb_new (&one);
  3078.   if (!buffer_and_nest (start, end, &one, get_non_macro_line_sb))
  3079.     {
  3080.       as_bad (_("%s without %s"), start, end);
  3081.       return;
  3082.     }
  3083.  
  3084.   sb_build (&many, count * one.len);
  3085.   while (count-- > 0)
  3086.     sb_add_sb (&many, &one);
  3087.  
  3088.   sb_kill (&one);
  3089.  
  3090.   input_scrub_include_sb (&many, input_line_pointer, 1);
  3091.   sb_kill (&many);
  3092.   buffer_limit = input_scrub_next_buffer (&input_line_pointer);
  3093. }
  3094.  
  3095. /* Like do_repeat except that any text matching EXPANDER in the
  3096.    block is replaced by the itteration count.  */
  3097.  
  3098. void
  3099. do_repeat_with_expander (int count,
  3100.                          const char * start,
  3101.                          const char * end,
  3102.                          const char * expander)
  3103. {
  3104.   sb one;
  3105.   sb many;
  3106.  
  3107.   sb_new (&one);
  3108.   if (!buffer_and_nest (start, end, &one, get_non_macro_line_sb))
  3109.     {
  3110.       as_bad (_("%s without %s"), start, end);
  3111.       return;
  3112.     }
  3113.  
  3114.   sb_new (&many);
  3115.  
  3116.   if (expander != NULL && strstr (one.ptr, expander) != NULL)
  3117.     {
  3118.       while (count -- > 0)
  3119.         {
  3120.           int len;
  3121.           char * sub;
  3122.           sb processed;
  3123.  
  3124.           sb_build (& processed, one.len);
  3125.           sb_add_sb (& processed, & one);
  3126.           sub = strstr (processed.ptr, expander);
  3127.           len = sprintf (sub, "%d", count);
  3128.           gas_assert (len < 8);
  3129.           strcpy (sub + len, sub + 8);
  3130.           processed.len -= (8 - len);
  3131.           sb_add_sb (& many, & processed);
  3132.           sb_kill (& processed);
  3133.         }
  3134.     }
  3135.   else
  3136.     while (count-- > 0)
  3137.       sb_add_sb (&many, &one);
  3138.  
  3139.   sb_kill (&one);
  3140.  
  3141.   input_scrub_include_sb (&many, input_line_pointer, 1);
  3142.   sb_kill (&many);
  3143.   buffer_limit = input_scrub_next_buffer (&input_line_pointer);
  3144. }
  3145.  
  3146. /* Skip to end of current repeat loop; EXTRA indicates how many additional
  3147.    input buffers to skip.  Assumes that conditionals preceding the loop end
  3148.    are properly nested.
  3149.  
  3150.    This function makes it easier to implement a premature "break" out of the
  3151.    loop.  The EXTRA arg accounts for other buffers we might have inserted,
  3152.    such as line substitutions.  */
  3153.  
  3154. void
  3155. end_repeat (int extra)
  3156. {
  3157.   cond_exit_macro (macro_nest);
  3158.   while (extra-- >= 0)
  3159.     buffer_limit = input_scrub_next_buffer (&input_line_pointer);
  3160. }
  3161.  
  3162. static void
  3163. assign_symbol (char *name, int mode)
  3164. {
  3165.   symbolS *symbolP;
  3166.  
  3167.   if (name[0] == '.' && name[1] == '\0')
  3168.     {
  3169.       /* Turn '. = mumble' into a .org mumble.  */
  3170.       segT segment;
  3171.       expressionS exp;
  3172.  
  3173.       segment = get_known_segmented_expression (&exp);
  3174.  
  3175.       if (!need_pass_2)
  3176.         do_org (segment, &exp, 0);
  3177.  
  3178.       return;
  3179.     }
  3180.  
  3181.   if ((symbolP = symbol_find (name)) == NULL
  3182.       && (symbolP = md_undefined_symbol (name)) == NULL)
  3183.     {
  3184.       symbolP = symbol_find_or_make (name);
  3185. #ifndef NO_LISTING
  3186.       /* When doing symbol listings, play games with dummy fragments living
  3187.          outside the normal fragment chain to record the file and line info
  3188.          for this symbol.  */
  3189.       if (listing & LISTING_SYMBOLS)
  3190.         {
  3191.           extern struct list_info_struct *listing_tail;
  3192.           fragS *dummy_frag = (fragS *) xcalloc (1, sizeof (fragS));
  3193.           dummy_frag->line = listing_tail;
  3194.           dummy_frag->fr_symbol = symbolP;
  3195.           symbol_set_frag (symbolP, dummy_frag);
  3196.         }
  3197. #endif
  3198. #if defined (OBJ_COFF) && !defined (TE_PE)
  3199.       /* "set" symbols are local unless otherwise specified.  */
  3200.       SF_SET_LOCAL (symbolP);
  3201. #endif
  3202.     }
  3203.  
  3204.   if (S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP))
  3205.     {
  3206.       if ((mode != 0 || !S_IS_VOLATILE (symbolP))
  3207.           && !S_CAN_BE_REDEFINED (symbolP))
  3208.         {
  3209.           as_bad (_("symbol `%s' is already defined"), name);
  3210.           symbolP = symbol_clone (symbolP, 0);
  3211.         }
  3212.       /* If the symbol is volatile, copy the symbol and replace the
  3213.          original with the copy, so that previous uses of the symbol will
  3214.          retain the value of the symbol at the point of use.  */
  3215.       else if (S_IS_VOLATILE (symbolP))
  3216.         symbolP = symbol_clone (symbolP, 1);
  3217.     }
  3218.  
  3219.   if (mode == 0)
  3220.     S_SET_VOLATILE (symbolP);
  3221.   else if (mode < 0)
  3222.     S_SET_FORWARD_REF (symbolP);
  3223.  
  3224.   pseudo_set (symbolP);
  3225. }
  3226.  
  3227. /* Handle the .equ, .equiv, .eqv, and .set directives.  If EQUIV is 1,
  3228.    then this is .equiv, and it is an error if the symbol is already
  3229.    defined.  If EQUIV is -1, the symbol additionally is a forward
  3230.    reference.  */
  3231.  
  3232. void
  3233. s_set (int equiv)
  3234. {
  3235.   char *name;
  3236.  
  3237.   /* Especial apologies for the random logic:
  3238.      this just grew, and could be parsed much more simply!
  3239.      Dean in haste.  */
  3240.   if ((name = read_symbol_name ()) == NULL)
  3241.     return;
  3242.  
  3243.   if (*input_line_pointer != ',')
  3244.     {
  3245.       as_bad (_("expected comma after \"%s\""), name);
  3246.       ignore_rest_of_line ();
  3247.       free (name);
  3248.       return;
  3249.     }
  3250.  
  3251.   input_line_pointer++;
  3252.   assign_symbol (name, equiv);
  3253.   demand_empty_rest_of_line ();
  3254.   free (name);
  3255. }
  3256.  
  3257. void
  3258. s_space (int mult)
  3259. {
  3260.   expressionS exp;
  3261.   expressionS val;
  3262.   char *p = 0;
  3263.   char *stop = NULL;
  3264.   char stopc = 0;
  3265.   int bytes;
  3266.  
  3267. #ifdef md_flush_pending_output
  3268.   md_flush_pending_output ();
  3269. #endif
  3270.  
  3271. #ifdef md_cons_align
  3272.   md_cons_align (1);
  3273. #endif
  3274.  
  3275.   if (flag_mri)
  3276.     stop = mri_comment_field (&stopc);
  3277.  
  3278.   /* In m68k MRI mode, we need to align to a word boundary, unless
  3279.      this is ds.b.  */
  3280.   if (flag_m68k_mri && mult > 1)
  3281.     {
  3282.       if (now_seg == absolute_section)
  3283.         {
  3284.           abs_section_offset += abs_section_offset & 1;
  3285.           if (line_label != NULL)
  3286.             S_SET_VALUE (line_label, abs_section_offset);
  3287.         }
  3288.       else if (mri_common_symbol != NULL)
  3289.         {
  3290.           valueT mri_val;
  3291.  
  3292.           mri_val = S_GET_VALUE (mri_common_symbol);
  3293.           if ((mri_val & 1) != 0)
  3294.             {
  3295.               S_SET_VALUE (mri_common_symbol, mri_val + 1);
  3296.               if (line_label != NULL)
  3297.                 {
  3298.                   expressionS *symexp;
  3299.  
  3300.                   symexp = symbol_get_value_expression (line_label);
  3301.                   know (symexp->X_op == O_symbol);
  3302.                   know (symexp->X_add_symbol == mri_common_symbol);
  3303.                   symexp->X_add_number += 1;
  3304.                 }
  3305.             }
  3306.         }
  3307.       else
  3308.         {
  3309.           do_align (1, (char *) NULL, 0, 0);
  3310.           if (line_label != NULL)
  3311.             {
  3312.               symbol_set_frag (line_label, frag_now);
  3313.               S_SET_VALUE (line_label, frag_now_fix ());
  3314.             }
  3315.         }
  3316.     }
  3317.  
  3318.   bytes = mult;
  3319.  
  3320.   expression (&exp);
  3321.  
  3322.   SKIP_WHITESPACE ();
  3323.   if (*input_line_pointer == ',')
  3324.     {
  3325.       ++input_line_pointer;
  3326.       expression (&val);
  3327.     }
  3328.   else
  3329.     {
  3330.       val.X_op = O_constant;
  3331.       val.X_add_number = 0;
  3332.     }
  3333.  
  3334.   if (val.X_op != O_constant
  3335.       || val.X_add_number < - 0x80
  3336.       || val.X_add_number > 0xff
  3337.       || (mult != 0 && mult != 1 && val.X_add_number != 0))
  3338.     {
  3339.       resolve_expression (&exp);
  3340.       if (exp.X_op != O_constant)
  3341.         as_bad (_("unsupported variable size or fill value"));
  3342.       else
  3343.         {
  3344.           offsetT i;
  3345.  
  3346.           if (mult == 0)
  3347.             mult = 1;
  3348.           bytes = mult * exp.X_add_number;
  3349.           for (i = 0; i < exp.X_add_number; i++)
  3350.             emit_expr (&val, mult);
  3351.         }
  3352.     }
  3353.   else
  3354.     {
  3355.       if (now_seg == absolute_section || mri_common_symbol != NULL)
  3356.         resolve_expression (&exp);
  3357.  
  3358.       if (exp.X_op == O_constant)
  3359.         {
  3360.           offsetT repeat;
  3361.  
  3362.           repeat = exp.X_add_number;
  3363.           if (mult)
  3364.             repeat *= mult;
  3365.           bytes = repeat;
  3366.           if (repeat <= 0)
  3367.             {
  3368.               if (!flag_mri)
  3369.                 as_warn (_(".space repeat count is zero, ignored"));
  3370.               else if (repeat < 0)
  3371.                 as_warn (_(".space repeat count is negative, ignored"));
  3372.               goto getout;
  3373.             }
  3374.  
  3375.           /* If we are in the absolute section, just bump the offset.  */
  3376.           if (now_seg == absolute_section)
  3377.             {
  3378.               abs_section_offset += repeat;
  3379.               goto getout;
  3380.             }
  3381.  
  3382.           /* If we are secretly in an MRI common section, then
  3383.              creating space just increases the size of the common
  3384.              symbol.  */
  3385.           if (mri_common_symbol != NULL)
  3386.             {
  3387.               S_SET_VALUE (mri_common_symbol,
  3388.                            S_GET_VALUE (mri_common_symbol) + repeat);
  3389.               goto getout;
  3390.             }
  3391.  
  3392.           if (!need_pass_2)
  3393.             p = frag_var (rs_fill, 1, 1, (relax_substateT) 0, (symbolS *) 0,
  3394.                           (offsetT) repeat, (char *) 0);
  3395.         }
  3396.       else
  3397.         {
  3398.           if (now_seg == absolute_section)
  3399.             {
  3400.               as_bad (_("space allocation too complex in absolute section"));
  3401.               subseg_set (text_section, 0);
  3402.             }
  3403.  
  3404.           if (mri_common_symbol != NULL)
  3405.             {
  3406.               as_bad (_("space allocation too complex in common section"));
  3407.               mri_common_symbol = NULL;
  3408.             }
  3409.  
  3410.           if (!need_pass_2)
  3411.             p = frag_var (rs_space, 1, 1, (relax_substateT) 0,
  3412.                           make_expr_symbol (&exp), (offsetT) 0, (char *) 0);
  3413.         }
  3414.  
  3415.       if (p)
  3416.         *p = val.X_add_number;
  3417.     }
  3418.  
  3419.  getout:
  3420.  
  3421.   /* In MRI mode, after an odd number of bytes, we must align to an
  3422.      even word boundary, unless the next instruction is a dc.b, ds.b
  3423.      or dcb.b.  */
  3424.   if (flag_mri && (bytes & 1) != 0)
  3425.     mri_pending_align = 1;
  3426.  
  3427.   demand_empty_rest_of_line ();
  3428.  
  3429.   if (flag_mri)
  3430.     mri_comment_end (stop, stopc);
  3431. }
  3432.  
  3433. /* This is like s_space, but the value is a floating point number with
  3434.    the given precision.  This is for the MRI dcb.s pseudo-op and
  3435.    friends.  */
  3436.  
  3437. void
  3438. s_float_space (int float_type)
  3439. {
  3440.   offsetT count;
  3441.   int flen;
  3442.   char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
  3443.   char *stop = NULL;
  3444.   char stopc = 0;
  3445.  
  3446. #ifdef md_cons_align
  3447.   md_cons_align (1);
  3448. #endif
  3449.  
  3450.   if (flag_mri)
  3451.     stop = mri_comment_field (&stopc);
  3452.  
  3453.   count = get_absolute_expression ();
  3454.  
  3455.   SKIP_WHITESPACE ();
  3456.   if (*input_line_pointer != ',')
  3457.     {
  3458.       as_bad (_("missing value"));
  3459.       ignore_rest_of_line ();
  3460.       if (flag_mri)
  3461.         mri_comment_end (stop, stopc);
  3462.       return;
  3463.     }
  3464.  
  3465.   ++input_line_pointer;
  3466.  
  3467.   SKIP_WHITESPACE ();
  3468.  
  3469.   /* Skip any 0{letter} that may be present.  Don't even check if the
  3470.    * letter is legal.  */
  3471.   if (input_line_pointer[0] == '0'
  3472.       && ISALPHA (input_line_pointer[1]))
  3473.     input_line_pointer += 2;
  3474.  
  3475.   /* Accept :xxxx, where the x's are hex digits, for a floating point
  3476.      with the exact digits specified.  */
  3477.   if (input_line_pointer[0] == ':')
  3478.     {
  3479.       flen = hex_float (float_type, temp);
  3480.       if (flen < 0)
  3481.         {
  3482.           ignore_rest_of_line ();
  3483.           if (flag_mri)
  3484.             mri_comment_end (stop, stopc);
  3485.           return;
  3486.         }
  3487.     }
  3488.   else
  3489.     {
  3490.       char *err;
  3491.  
  3492.       err = md_atof (float_type, temp, &flen);
  3493.       know (flen <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
  3494.       know (err != NULL || flen > 0);
  3495.       if (err)
  3496.         {
  3497.           as_bad (_("bad floating literal: %s"), err);
  3498.           ignore_rest_of_line ();
  3499.           if (flag_mri)
  3500.             mri_comment_end (stop, stopc);
  3501.           return;
  3502.         }
  3503.     }
  3504.  
  3505.   while (--count >= 0)
  3506.     {
  3507.       char *p;
  3508.  
  3509.       p = frag_more (flen);
  3510.       memcpy (p, temp, (unsigned int) flen);
  3511.     }
  3512.  
  3513.   demand_empty_rest_of_line ();
  3514.  
  3515.   if (flag_mri)
  3516.     mri_comment_end (stop, stopc);
  3517. }
  3518.  
  3519. /* Handle the .struct pseudo-op, as found in MIPS assemblers.  */
  3520.  
  3521. void
  3522. s_struct (int ignore ATTRIBUTE_UNUSED)
  3523. {
  3524.   char *stop = NULL;
  3525.   char stopc = 0;
  3526.  
  3527.   if (flag_mri)
  3528.     stop = mri_comment_field (&stopc);
  3529.   abs_section_offset = get_absolute_expression ();
  3530. #if defined (OBJ_ELF) || defined (OBJ_MAYBE_ELF)
  3531.   /* The ELF backend needs to know that we are changing sections, so
  3532.      that .previous works correctly. */
  3533.   if (IS_ELF)
  3534.     obj_elf_section_change_hook ();
  3535. #endif
  3536.   subseg_set (absolute_section, 0);
  3537.   demand_empty_rest_of_line ();
  3538.   if (flag_mri)
  3539.     mri_comment_end (stop, stopc);
  3540. }
  3541.  
  3542. void
  3543. s_text (int ignore ATTRIBUTE_UNUSED)
  3544. {
  3545.   int temp;
  3546.  
  3547.   temp = get_absolute_expression ();
  3548.   subseg_set (text_section, (subsegT) temp);
  3549.   demand_empty_rest_of_line ();
  3550. }
  3551.  
  3552. /* .weakref x, y sets x as an alias to y that, as long as y is not
  3553.    referenced directly, will cause y to become a weak symbol.  */
  3554. void
  3555. s_weakref (int ignore ATTRIBUTE_UNUSED)
  3556. {
  3557.   char *name;
  3558.   symbolS *symbolP;
  3559.   symbolS *symbolP2;
  3560.   expressionS exp;
  3561.  
  3562.   if ((name = read_symbol_name ()) == NULL)
  3563.     return;
  3564.  
  3565.   symbolP = symbol_find_or_make (name);
  3566.  
  3567.   if (S_IS_DEFINED (symbolP) || symbol_equated_p (symbolP))
  3568.     {
  3569.       if (!S_IS_VOLATILE (symbolP))
  3570.         {
  3571.           as_bad (_("symbol `%s' is already defined"), name);
  3572.           goto err_out;
  3573.         }
  3574.       symbolP = symbol_clone (symbolP, 1);
  3575.       S_CLEAR_VOLATILE (symbolP);
  3576.     }
  3577.  
  3578.   SKIP_WHITESPACE ();
  3579.  
  3580.   if (*input_line_pointer != ',')
  3581.     {
  3582.       as_bad (_("expected comma after \"%s\""), name);
  3583.       goto err_out;
  3584.     }
  3585.  
  3586.   input_line_pointer++;
  3587.  
  3588.   SKIP_WHITESPACE ();
  3589.   free (name);
  3590.  
  3591.   if ((name = read_symbol_name ()) == NULL)
  3592.     return;
  3593.  
  3594.   if ((symbolP2 = symbol_find_noref (name, 1)) == NULL
  3595.       && (symbolP2 = md_undefined_symbol (name)) == NULL)
  3596.     {
  3597.       symbolP2 = symbol_find_or_make (name);
  3598.       S_SET_WEAKREFD (symbolP2);
  3599.     }
  3600.   else
  3601.     {
  3602.       symbolS *symp = symbolP2;
  3603.  
  3604.       while (S_IS_WEAKREFR (symp) && symp != symbolP)
  3605.         {
  3606.           expressionS *expP = symbol_get_value_expression (symp);
  3607.  
  3608.           gas_assert (expP->X_op == O_symbol
  3609.                   && expP->X_add_number == 0);
  3610.           symp = expP->X_add_symbol;
  3611.         }
  3612.       if (symp == symbolP)
  3613.         {
  3614.           char *loop;
  3615.  
  3616.           loop = concat (S_GET_NAME (symbolP),
  3617.                          " => ", S_GET_NAME (symbolP2), (const char *) NULL);
  3618.  
  3619.           symp = symbolP2;
  3620.           while (symp != symbolP)
  3621.             {
  3622.               char *old_loop = loop;
  3623.  
  3624.               symp = symbol_get_value_expression (symp)->X_add_symbol;
  3625.               loop = concat (loop, " => ", S_GET_NAME (symp),
  3626.                              (const char *) NULL);
  3627.               free (old_loop);
  3628.             }
  3629.  
  3630.           as_bad (_("%s: would close weakref loop: %s"),
  3631.                   S_GET_NAME (symbolP), loop);
  3632.  
  3633.           free (loop);
  3634.           free (name);
  3635.           ignore_rest_of_line ();
  3636.           return;
  3637.         }
  3638.  
  3639.       /* Short-circuiting instead of just checking here might speed
  3640.          things up a tiny little bit, but loop error messages would
  3641.          miss intermediate links.  */
  3642.       /* symbolP2 = symp; */
  3643.     }
  3644.  
  3645.   memset (&exp, 0, sizeof (exp));
  3646.   exp.X_op = O_symbol;
  3647.   exp.X_add_symbol = symbolP2;
  3648.  
  3649.   S_SET_SEGMENT (symbolP, undefined_section);
  3650.   symbol_set_value_expression (symbolP, &exp);
  3651.   symbol_set_frag (symbolP, &zero_address_frag);
  3652.   S_SET_WEAKREFR (symbolP);
  3653.  
  3654.   demand_empty_rest_of_line ();
  3655.   free (name);
  3656.   return;
  3657.  
  3658.  err_out:
  3659.   ignore_rest_of_line ();
  3660.   free (name);
  3661.   return;
  3662. }
  3664.  
  3665. /* Verify that we are at the end of a line.  If not, issue an error and
  3666.    skip to EOL.  */
  3667.  
  3668. void
  3669. demand_empty_rest_of_line (void)
  3670. {
  3671.   SKIP_WHITESPACE ();
  3672.   if (is_end_of_line[(unsigned char) *input_line_pointer])
  3673.     input_line_pointer++;
  3674.   else
  3675.     {
  3676.       if (ISPRINT (*input_line_pointer))
  3677.         as_bad (_("junk at end of line, first unrecognized character is `%c'"),
  3678.                  *input_line_pointer);
  3679.       else
  3680.         as_bad (_("junk at end of line, first unrecognized character valued 0x%x"),
  3681.                  *input_line_pointer);
  3682.       ignore_rest_of_line ();
  3683.     }
  3684.  
  3685.   /* Return pointing just after end-of-line.  */
  3686.   know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
  3687. }
  3688.  
  3689. /* Silently advance to the end of line.  Use this after already having
  3690.    issued an error about something bad.  */
  3691.  
  3692. void
  3693. ignore_rest_of_line (void)
  3694. {
  3695.   while (input_line_pointer < buffer_limit
  3696.          && !is_end_of_line[(unsigned char) *input_line_pointer])
  3697.     input_line_pointer++;
  3698.  
  3699.   input_line_pointer++;
  3700.  
  3701.   /* Return pointing just after end-of-line.  */
  3702.   know (is_end_of_line[(unsigned char) input_line_pointer[-1]]);
  3703. }
  3704.  
  3705. /* Sets frag for given symbol to zero_address_frag, except when the
  3706.    symbol frag is already set to a dummy listing frag.  */
  3707.  
  3708. static void
  3709. set_zero_frag (symbolS *symbolP)
  3710. {
  3711.   if (symbol_get_frag (symbolP)->fr_type != rs_dummy)
  3712.     symbol_set_frag (symbolP, &zero_address_frag);
  3713. }
  3714.  
  3715. /* In:  Pointer to a symbol.
  3716.         Input_line_pointer->expression.
  3717.  
  3718.    Out: Input_line_pointer->just after any whitespace after expression.
  3719.         Tried to set symbol to value of expression.
  3720.         Will change symbols type, value, and frag;  */
  3721.  
  3722. void
  3723. pseudo_set (symbolS *symbolP)
  3724. {
  3725.   expressionS exp;
  3726.   segT seg;
  3727.  
  3728.   know (symbolP);               /* NULL pointer is logic error.  */
  3729.  
  3730.   if (!S_IS_FORWARD_REF (symbolP))
  3731.     (void) expression (&exp);
  3732.   else
  3733.     (void) deferred_expression (&exp);
  3734.  
  3735.   if (exp.X_op == O_illegal)
  3736.     as_bad (_("illegal expression"));
  3737.   else if (exp.X_op == O_absent)
  3738.     as_bad (_("missing expression"));
  3739.   else if (exp.X_op == O_big)
  3740.     {
  3741.       if (exp.X_add_number > 0)
  3742.         as_bad (_("bignum invalid"));
  3743.       else
  3744.         as_bad (_("floating point number invalid"));
  3745.     }
  3746.   else if (exp.X_op == O_subtract
  3747.            && !S_IS_FORWARD_REF (symbolP)
  3748.            && SEG_NORMAL (S_GET_SEGMENT (exp.X_add_symbol))
  3749.            && (symbol_get_frag (exp.X_add_symbol)
  3750.                == symbol_get_frag (exp.X_op_symbol)))
  3751.     {
  3752.       exp.X_op = O_constant;
  3753.       exp.X_add_number = (S_GET_VALUE (exp.X_add_symbol)
  3754.                           - S_GET_VALUE (exp.X_op_symbol));
  3755.     }
  3756.  
  3757.   if (symbol_section_p (symbolP))
  3758.     {
  3759.       as_bad ("attempt to set value of section symbol");
  3760.       return;
  3761.     }
  3762.  
  3763.   switch (exp.X_op)
  3764.     {
  3765.     case O_illegal:
  3766.     case O_absent:
  3767.     case O_big:
  3768.       exp.X_add_number = 0;
  3769.       /* Fall through.  */
  3770.     case O_constant:
  3771.       S_SET_SEGMENT (symbolP, absolute_section);
  3772.       S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
  3773.       set_zero_frag (symbolP);
  3774.       break;
  3775.  
  3776.     case O_register:
  3777. #ifndef TC_GLOBAL_REGISTER_SYMBOL_OK
  3778.       if (S_IS_EXTERNAL (symbolP))
  3779.         {
  3780.           as_bad ("can't equate global symbol `%s' with register name",
  3781.                   S_GET_NAME (symbolP));
  3782.           return;
  3783.         }
  3784. #endif
  3785.       S_SET_SEGMENT (symbolP, reg_section);
  3786.       S_SET_VALUE (symbolP, (valueT) exp.X_add_number);
  3787.       set_zero_frag (symbolP);
  3788.       symbol_get_value_expression (symbolP)->X_op = O_register;
  3789.       break;
  3790.  
  3791.     case O_symbol:
  3792.       seg = S_GET_SEGMENT (exp.X_add_symbol);
  3793.       /* For x=undef+const, create an expression symbol.
  3794.          For x=x+const, just update x except when x is an undefined symbol
  3795.          For x=defined+const, evaluate x.  */
  3796.       if (symbolP == exp.X_add_symbol
  3797.           && (seg != undefined_section
  3798.               || !symbol_constant_p (symbolP)))
  3799.         {
  3800.           *symbol_X_add_number (symbolP) += exp.X_add_number;
  3801.           break;
  3802.         }
  3803.       else if (!S_IS_FORWARD_REF (symbolP) && seg != undefined_section)
  3804.         {
  3805.           symbolS *s = exp.X_add_symbol;
  3806.  
  3807.           if (S_IS_COMMON (s))
  3808.             as_bad (_("`%s' can't be equated to common symbol '%s'"),
  3809.                     S_GET_NAME (symbolP), S_GET_NAME (s));
  3810.  
  3811.           S_SET_SEGMENT (symbolP, seg);
  3812.           S_SET_VALUE (symbolP, exp.X_add_number + S_GET_VALUE (s));
  3813.           symbol_set_frag (symbolP, symbol_get_frag (s));
  3814.           copy_symbol_attributes (symbolP, s);
  3815.           break;
  3816.         }
  3817.       S_SET_SEGMENT (symbolP, undefined_section);
  3818.       symbol_set_value_expression (symbolP, &exp);
  3819.       copy_symbol_attributes (symbolP, exp.X_add_symbol);
  3820.       set_zero_frag (symbolP);
  3821.       break;
  3822.  
  3823.     default:
  3824.       /* The value is some complex expression.  */
  3825.       S_SET_SEGMENT (symbolP, expr_section);
  3826.       symbol_set_value_expression (symbolP, &exp);
  3827.       set_zero_frag (symbolP);
  3828.       break;
  3829.     }
  3830. }
  3832. /*                      cons()
  3833.  
  3834.    CONStruct more frag of .bytes, or .words etc.
  3835.    Should need_pass_2 be 1 then emit no frag(s).
  3836.    This understands EXPRESSIONS.
  3837.  
  3838.    Bug (?)
  3839.  
  3840.    This has a split personality. We use expression() to read the
  3841.    value. We can detect if the value won't fit in a byte or word.
  3842.    But we can't detect if expression() discarded significant digits
  3843.    in the case of a long. Not worth the crocks required to fix it.  */
  3844.  
  3845. /* Select a parser for cons expressions.  */
  3846.  
  3847. /* Some targets need to parse the expression in various fancy ways.
  3848.    You can define TC_PARSE_CONS_EXPRESSION to do whatever you like
  3849.    (for example, the HPPA does this).  Otherwise, you can define
  3850.    BITFIELD_CONS_EXPRESSIONS to permit bitfields to be specified, or
  3851.    REPEAT_CONS_EXPRESSIONS to permit repeat counts.  If none of these
  3852.    are defined, which is the normal case, then only simple expressions
  3853.    are permitted.  */
  3854.  
  3855. #ifdef TC_M68K
  3856. static void
  3857. parse_mri_cons (expressionS *exp, unsigned int nbytes);
  3858. #endif
  3859.  
  3860. #ifndef TC_PARSE_CONS_EXPRESSION
  3861. #ifdef BITFIELD_CONS_EXPRESSIONS
  3862. #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \
  3863.   (parse_bitfield_cons (EXP, NBYTES), TC_PARSE_CONS_RETURN_NONE)
  3864. static void
  3865. parse_bitfield_cons (expressionS *exp, unsigned int nbytes);
  3866. #endif
  3867. #ifdef REPEAT_CONS_EXPRESSIONS
  3868. #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \
  3869.   (parse_repeat_cons (EXP, NBYTES), TC_PARSE_CONS_RETURN_NONE)
  3870. static void
  3871. parse_repeat_cons (expressionS *exp, unsigned int nbytes);
  3872. #endif
  3873.  
  3874. /* If we haven't gotten one yet, just call expression.  */
  3875. #ifndef TC_PARSE_CONS_EXPRESSION
  3876. #define TC_PARSE_CONS_EXPRESSION(EXP, NBYTES) \
  3877.   (expression (EXP), TC_PARSE_CONS_RETURN_NONE)
  3878. #endif
  3879. #endif
  3880.  
  3881. void
  3882. do_parse_cons_expression (expressionS *exp,
  3883.                           int nbytes ATTRIBUTE_UNUSED)
  3884. {
  3885.   (void) TC_PARSE_CONS_EXPRESSION (exp, nbytes);
  3886. }
  3887.  
  3888.  
  3889. /* Worker to do .byte etc statements.
  3890.    Clobbers input_line_pointer and checks end-of-line.  */
  3891.  
  3892. static void
  3893. cons_worker (int nbytes,        /* 1=.byte, 2=.word, 4=.long.  */
  3894.              int rva)
  3895. {
  3896.   int c;
  3897.   expressionS exp;
  3898.   char *stop = NULL;
  3899.   char stopc = 0;
  3900.  
  3901. #ifdef md_flush_pending_output
  3902.   md_flush_pending_output ();
  3903. #endif
  3904.  
  3905.   if (flag_mri)
  3906.     stop = mri_comment_field (&stopc);
  3907.  
  3908.   if (is_it_end_of_statement ())
  3909.     {
  3910.       demand_empty_rest_of_line ();
  3911.       if (flag_mri)
  3912.         mri_comment_end (stop, stopc);
  3913.       return;
  3914.     }
  3915.  
  3916. #ifdef TC_ADDRESS_BYTES
  3917.   if (nbytes == 0)
  3918.     nbytes = TC_ADDRESS_BYTES ();
  3919. #endif
  3920.  
  3921. #ifdef md_cons_align
  3922.   md_cons_align (nbytes);
  3923. #endif
  3924.  
  3925.   c = 0;
  3926.   do
  3927.     {
  3928.       TC_PARSE_CONS_RETURN_TYPE ret = TC_PARSE_CONS_RETURN_NONE;
  3929. #ifdef TC_CONS_FIX_CHECK
  3930.       fixS **cur_fix = &frchain_now->fix_tail;
  3931.  
  3932.       if (*cur_fix != NULL)
  3933.         cur_fix = &(*cur_fix)->fx_next;
  3934. #endif
  3935.  
  3936. #ifdef TC_M68K
  3937.       if (flag_m68k_mri)
  3938.         parse_mri_cons (&exp, (unsigned int) nbytes);
  3939.       else
  3940. #endif
  3941.         {
  3942. #if 0
  3943.           if (*input_line_pointer == '"')
  3944.             {
  3945.               as_bad (_("unexpected `\"' in expression"));
  3946.               ignore_rest_of_line ();
  3947.               return;
  3948.             }
  3949. #endif
  3950.           ret = TC_PARSE_CONS_EXPRESSION (&exp, (unsigned int) nbytes);
  3951.         }
  3952.  
  3953.       if (rva)
  3954.         {
  3955.           if (exp.X_op == O_symbol)
  3956.             exp.X_op = O_symbol_rva;
  3957.           else
  3958.             as_fatal (_("rva without symbol"));
  3959.         }
  3960.       emit_expr_with_reloc (&exp, (unsigned int) nbytes, ret);
  3961. #ifdef TC_CONS_FIX_CHECK
  3962.       TC_CONS_FIX_CHECK (&exp, nbytes, *cur_fix);
  3963. #endif
  3964.       ++c;
  3965.     }
  3966.   while (*input_line_pointer++ == ',');
  3967.  
  3968.   /* In MRI mode, after an odd number of bytes, we must align to an
  3969.      even word boundary, unless the next instruction is a dc.b, ds.b
  3970.      or dcb.b.  */
  3971.   if (flag_mri && nbytes == 1 && (c & 1) != 0)
  3972.     mri_pending_align = 1;
  3973.  
  3974.   input_line_pointer--;         /* Put terminator back into stream.  */
  3975.  
  3976.   demand_empty_rest_of_line ();
  3977.  
  3978.   if (flag_mri)
  3979.     mri_comment_end (stop, stopc);
  3980. }
  3981.  
  3982. void
  3983. cons (int size)
  3984. {
  3985.   cons_worker (size, 0);
  3986. }
  3987.  
  3988. void
  3989. s_rva (int size)
  3990. {
  3991.   cons_worker (size, 1);
  3992. }
  3993.  
  3994. /* .reloc offset, reloc_name, symbol+addend.  */
  3995.  
  3996. static void
  3997. s_reloc (int ignore ATTRIBUTE_UNUSED)
  3998. {
  3999.   char *stop = NULL;
  4000.   char stopc = 0;
  4001.   expressionS exp;
  4002.   char *r_name;
  4003.   int c;
  4004.   struct reloc_list *reloc;
  4005.   struct _bfd_rel { char *name; bfd_reloc_code_real_type code; };
  4006.   static struct _bfd_rel bfd_relocs[] = {
  4007.     { "NONE", BFD_RELOC_NONE },
  4008.     { "8", BFD_RELOC_8 },
  4009.     { "16", BFD_RELOC_16 },
  4010.     { "32", BFD_RELOC_32 },
  4011.     { "64", BFD_RELOC_64 }
  4012.   };
  4013.  
  4014.   reloc = (struct reloc_list *) xmalloc (sizeof (*reloc));
  4015.  
  4016.   if (flag_mri)
  4017.     stop = mri_comment_field (&stopc);
  4018.  
  4019.   expression (&exp);
  4020.   switch (exp.X_op)
  4021.     {
  4022.     case O_illegal:
  4023.     case O_absent:
  4024.     case O_big:
  4025.     case O_register:
  4026.       as_bad (_("missing or bad offset expression"));
  4027.       goto err_out;
  4028.     case O_constant:
  4029.       exp.X_add_symbol = section_symbol (now_seg);
  4030.       exp.X_op = O_symbol;
  4031.       /* Fall thru */
  4032.     case O_symbol:
  4033.       if (exp.X_add_number == 0)
  4034.         {
  4035.           reloc->u.a.offset_sym = exp.X_add_symbol;
  4036.           break;
  4037.         }
  4038.       /* Fall thru */
  4039.     default:
  4040.       reloc->u.a.offset_sym = make_expr_symbol (&exp);
  4041.       break;
  4042.     }
  4043.  
  4044.   SKIP_WHITESPACE ();
  4045.   if (*input_line_pointer != ',')
  4046.     {
  4047.       as_bad (_("missing reloc type"));
  4048.       goto err_out;
  4049.     }
  4050.  
  4051.   ++input_line_pointer;
  4052.   SKIP_WHITESPACE ();
  4053.   c = get_symbol_name (& r_name);
  4054.   if (strncasecmp (r_name, "BFD_RELOC_", 10) == 0)
  4055.     {
  4056.       unsigned int i;
  4057.  
  4058.       for (reloc->u.a.howto = NULL, i = 0; i < ARRAY_SIZE (bfd_relocs); i++)
  4059.         if (strcasecmp (r_name + 10, bfd_relocs[i].name) == 0)
  4060.           {
  4061.             reloc->u.a.howto = bfd_reloc_type_lookup (stdoutput,
  4062.                                                       bfd_relocs[i].code);
  4063.             break;
  4064.           }
  4065.     }
  4066.   else
  4067.   reloc->u.a.howto = bfd_reloc_name_lookup (stdoutput, r_name);
  4068.   *input_line_pointer = c;
  4069.   if (reloc->u.a.howto == NULL)
  4070.     {
  4071.       as_bad (_("unrecognized reloc type"));
  4072.       goto err_out;
  4073.     }
  4074.  
  4075.   exp.X_op = O_absent;
  4076.   SKIP_WHITESPACE_AFTER_NAME ();
  4077.   if (*input_line_pointer == ',')
  4078.     {
  4079.       ++input_line_pointer;
  4080.       expression (&exp);
  4081.     }
  4082.   switch (exp.X_op)
  4083.     {
  4084.     case O_illegal:
  4085.     case O_big:
  4086.     case O_register:
  4087.       as_bad (_("bad reloc expression"));
  4088.     err_out:
  4089.       ignore_rest_of_line ();
  4090.       free (reloc);
  4091.       if (flag_mri)
  4092.         mri_comment_end (stop, stopc);
  4093.       return;
  4094.     case O_absent:
  4095.       reloc->u.a.sym = NULL;
  4096.       reloc->u.a.addend = 0;
  4097.       break;
  4098.     case O_constant:
  4099.       reloc->u.a.sym = NULL;
  4100.       reloc->u.a.addend = exp.X_add_number;
  4101.       break;
  4102.     case O_symbol:
  4103.       reloc->u.a.sym = exp.X_add_symbol;
  4104.       reloc->u.a.addend = exp.X_add_number;
  4105.       break;
  4106.     default:
  4107.       reloc->u.a.sym = make_expr_symbol (&exp);
  4108.       reloc->u.a.addend = 0;
  4109.       break;
  4110.     }
  4111.  
  4112.   as_where (&reloc->file, &reloc->line);
  4113.   reloc->next = reloc_list;
  4114.   reloc_list = reloc;
  4115.  
  4116.   demand_empty_rest_of_line ();
  4117.   if (flag_mri)
  4118.     mri_comment_end (stop, stopc);
  4119. }
  4120.  
  4121. /* Put the contents of expression EXP into the object file using
  4122.    NBYTES bytes.  If need_pass_2 is 1, this does nothing.  */
  4123.  
  4124. void
  4125. emit_expr (expressionS *exp, unsigned int nbytes)
  4126. {
  4127.   emit_expr_with_reloc (exp, nbytes, TC_PARSE_CONS_RETURN_NONE);
  4128. }
  4129.  
  4130. void
  4131. emit_expr_with_reloc (expressionS *exp,
  4132.                       unsigned int nbytes,
  4133.                       TC_PARSE_CONS_RETURN_TYPE reloc)
  4134. {
  4135.   operatorT op;
  4136.   char *p;
  4137.   valueT extra_digit = 0;
  4138.  
  4139.   /* Don't do anything if we are going to make another pass.  */
  4140.   if (need_pass_2)
  4141.     return;
  4142.  
  4143.   frag_grow (nbytes);
  4144.   dot_value = frag_now_fix ();
  4145.   dot_frag = frag_now;
  4146.  
  4147. #ifndef NO_LISTING
  4148. #ifdef OBJ_ELF
  4149.   /* When gcc emits DWARF 1 debugging pseudo-ops, a line number will
  4150.      appear as a four byte positive constant in the .line section,
  4151.      followed by a 2 byte 0xffff.  Look for that case here.  */
  4152.   {
  4153.     static int dwarf_line = -1;
  4154.  
  4155.     if (strcmp (segment_name (now_seg), ".line") != 0)
  4156.       dwarf_line = -1;
  4157.     else if (dwarf_line >= 0
  4158.              && nbytes == 2
  4159.              && exp->X_op == O_constant
  4160.              && (exp->X_add_number == -1 || exp->X_add_number == 0xffff))
  4161.       listing_source_line ((unsigned int) dwarf_line);
  4162.     else if (nbytes == 4
  4163.              && exp->X_op == O_constant
  4164.              && exp->X_add_number >= 0)
  4165.       dwarf_line = exp->X_add_number;
  4166.     else
  4167.       dwarf_line = -1;
  4168.   }
  4169.  
  4170.   /* When gcc emits DWARF 1 debugging pseudo-ops, a file name will
  4171.      appear as a 2 byte TAG_compile_unit (0x11) followed by a 2 byte
  4172.      AT_sibling (0x12) followed by a four byte address of the sibling
  4173.      followed by a 2 byte AT_name (0x38) followed by the name of the
  4174.      file.  We look for that case here.  */
  4175.   {
  4176.     static int dwarf_file = 0;
  4177.  
  4178.     if (strcmp (segment_name (now_seg), ".debug") != 0)
  4179.       dwarf_file = 0;
  4180.     else if (dwarf_file == 0
  4181.              && nbytes == 2
  4182.              && exp->X_op == O_constant
  4183.              && exp->X_add_number == 0x11)
  4184.       dwarf_file = 1;
  4185.     else if (dwarf_file == 1
  4186.              && nbytes == 2
  4187.              && exp->X_op == O_constant
  4188.              && exp->X_add_number == 0x12)
  4189.       dwarf_file = 2;
  4190.     else if (dwarf_file == 2
  4191.              && nbytes == 4)
  4192.       dwarf_file = 3;
  4193.     else if (dwarf_file == 3
  4194.              && nbytes == 2
  4195.              && exp->X_op == O_constant
  4196.              && exp->X_add_number == 0x38)
  4197.       dwarf_file = 4;
  4198.     else
  4199.       dwarf_file = 0;
  4200.  
  4201.     /* The variable dwarf_file_string tells stringer that the string
  4202.        may be the name of the source file.  */
  4203.     if (dwarf_file == 4)
  4204.       dwarf_file_string = 1;
  4205.     else
  4206.       dwarf_file_string = 0;
  4207.   }
  4208. #endif
  4209. #endif
  4210.  
  4211.   if (check_eh_frame (exp, &nbytes))
  4212.     return;
  4213.  
  4214.   op = exp->X_op;
  4215.  
  4216.   /* Allow `.word 0' in the absolute section.  */
  4217.   if (now_seg == absolute_section)
  4218.     {
  4219.       if (op != O_constant || exp->X_add_number != 0)
  4220.         as_bad (_("attempt to store value in absolute section"));
  4221.       abs_section_offset += nbytes;
  4222.       return;
  4223.     }
  4224.  
  4225.   /* Handle a negative bignum.  */
  4226.   if (op == O_uminus
  4227.       && exp->X_add_number == 0
  4228.       && symbol_get_value_expression (exp->X_add_symbol)->X_op == O_big
  4229.       && symbol_get_value_expression (exp->X_add_symbol)->X_add_number > 0)
  4230.     {
  4231.       int i;
  4232.       unsigned long carry;
  4233.  
  4234.       exp = symbol_get_value_expression (exp->X_add_symbol);
  4235.  
  4236.       /* Negate the bignum: one's complement each digit and add 1.  */
  4237.       carry = 1;
  4238.       for (i = 0; i < exp->X_add_number; i++)
  4239.         {
  4240.           unsigned long next;
  4241.  
  4242.           next = (((~(generic_bignum[i] & LITTLENUM_MASK))
  4243.                    & LITTLENUM_MASK)
  4244.                   + carry);
  4245.           generic_bignum[i] = next & LITTLENUM_MASK;
  4246.           carry = next >> LITTLENUM_NUMBER_OF_BITS;
  4247.         }
  4248.  
  4249.       /* We can ignore any carry out, because it will be handled by
  4250.          extra_digit if it is needed.  */
  4251.  
  4252.       extra_digit = (valueT) -1;
  4253.       op = O_big;
  4254.     }
  4255.  
  4256.   if (op == O_absent || op == O_illegal)
  4257.     {
  4258.       as_warn (_("zero assumed for missing expression"));
  4259.       exp->X_add_number = 0;
  4260.       op = O_constant;
  4261.     }
  4262.   else if (op == O_big && exp->X_add_number <= 0)
  4263.     {
  4264.       as_bad (_("floating point number invalid"));
  4265.       exp->X_add_number = 0;
  4266.       op = O_constant;
  4267.     }
  4268.   else if (op == O_register)
  4269.     {
  4270.       as_warn (_("register value used as expression"));
  4271.       op = O_constant;
  4272.     }
  4273.  
  4274.   p = frag_more ((int) nbytes);
  4275.  
  4276.   if (reloc != TC_PARSE_CONS_RETURN_NONE)
  4277.     {
  4278.       emit_expr_fix (exp, nbytes, frag_now, p, reloc);
  4279.       return;
  4280.     }
  4281.  
  4282. #ifndef WORKING_DOT_WORD
  4283.   /* If we have the difference of two symbols in a word, save it on
  4284.      the broken_words list.  See the code in write.c.  */
  4285.   if (op == O_subtract && nbytes == 2)
  4286.     {
  4287.       struct broken_word *x;
  4288.  
  4289.       x = (struct broken_word *) xmalloc (sizeof (struct broken_word));
  4290.       x->next_broken_word = broken_words;
  4291.       broken_words = x;
  4292.       x->seg = now_seg;
  4293.       x->subseg = now_subseg;
  4294.       x->frag = frag_now;
  4295.       x->word_goes_here = p;
  4296.       x->dispfrag = 0;
  4297.       x->add = exp->X_add_symbol;
  4298.       x->sub = exp->X_op_symbol;
  4299.       x->addnum = exp->X_add_number;
  4300.       x->added = 0;
  4301.       x->use_jump = 0;
  4302.       new_broken_words++;
  4303.       return;
  4304.     }
  4305. #endif
  4306.  
  4307.   /* If we have an integer, but the number of bytes is too large to
  4308.      pass to md_number_to_chars, handle it as a bignum.  */
  4309.   if (op == O_constant && nbytes > sizeof (valueT))
  4310.     {
  4311.       extra_digit = exp->X_unsigned ? 0 : -1;
  4312.       convert_to_bignum (exp, !exp->X_unsigned);
  4313.       op = O_big;
  4314.     }
  4315.  
  4316.   if (op == O_constant)
  4317.     {
  4318.       valueT get;
  4319.       valueT use;
  4320.       valueT mask;
  4321.       valueT hibit;
  4322.       valueT unmask;
  4323.  
  4324.       /* JF << of >= number of bits in the object is undefined.  In
  4325.          particular SPARC (Sun 4) has problems.  */
  4326.       if (nbytes >= sizeof (valueT))
  4327.         {
  4328.           mask = 0;
  4329.           if (nbytes > sizeof (valueT))
  4330.             hibit = 0;
  4331.           else
  4332.             hibit = (valueT) 1 << (nbytes * BITS_PER_CHAR - 1);
  4333.         }
  4334.       else
  4335.         {
  4336.           /* Don't store these bits.  */
  4337.           mask = ~(valueT) 0 << (BITS_PER_CHAR * nbytes);
  4338.           hibit = (valueT) 1 << (nbytes * BITS_PER_CHAR - 1);
  4339.         }
  4340.  
  4341.       unmask = ~mask;           /* Do store these bits.  */
  4342.  
  4343. #ifdef NEVER
  4344.       "Do this mod if you want every overflow check to assume SIGNED 2's complement data.";
  4345.       mask = ~(unmask >> 1);    /* Includes sign bit now.  */
  4346. #endif
  4347.  
  4348.       get = exp->X_add_number;
  4349.       use = get & unmask;
  4350.       if ((get & mask) != 0
  4351.           && ((get & mask) != mask
  4352.               || (get & hibit) == 0))
  4353.         {               /* Leading bits contain both 0s & 1s.  */
  4354. #if defined (BFD64) && BFD_HOST_64BIT_LONG_LONG
  4355. #ifndef __MSVCRT__
  4356.           as_warn (_("value 0x%llx truncated to 0x%llx"),
  4357.                    (unsigned long long) get, (unsigned long long) use);
  4358. #else
  4359.           as_warn (_("value 0x%I64x truncated to 0x%I64x"),
  4360.                    (unsigned long long) get, (unsigned long long) use);
  4361. #endif
  4362. #else
  4363.           as_warn (_("value 0x%lx truncated to 0x%lx"),
  4364.                    (unsigned long) get, (unsigned long) use);
  4365. #endif
  4366.         }
  4367.       /* Put bytes in right order.  */
  4368.       md_number_to_chars (p, use, (int) nbytes);
  4369.     }
  4370.   else if (op == O_big)
  4371.     {
  4372.       unsigned int size;
  4373.       LITTLENUM_TYPE *nums;
  4374.  
  4375.       size = exp->X_add_number * CHARS_PER_LITTLENUM;
  4376.       if (nbytes < size)
  4377.         {
  4378.           int i = nbytes / CHARS_PER_LITTLENUM;
  4379.           if (i != 0)
  4380.             {
  4381.               LITTLENUM_TYPE sign = 0;
  4382.               if ((generic_bignum[--i]
  4383.                    & (1 << (LITTLENUM_NUMBER_OF_BITS - 1))) != 0)
  4384.                 sign = ~(LITTLENUM_TYPE) 0;
  4385.               while (++i < exp->X_add_number)
  4386.                 if (generic_bignum[i] != sign)
  4387.                   break;
  4388.             }
  4389.           if (i < exp->X_add_number)
  4390.             as_warn (_("bignum truncated to %d bytes"), nbytes);
  4391.           size = nbytes;
  4392.         }
  4393.  
  4394.       if (nbytes == 1)
  4395.         {
  4396.           md_number_to_chars (p, (valueT) generic_bignum[0], 1);
  4397.           return;
  4398.         }
  4399.       know (nbytes % CHARS_PER_LITTLENUM == 0);
  4400.  
  4401.       if (target_big_endian)
  4402.         {
  4403.           while (nbytes > size)
  4404.             {
  4405.               md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM);
  4406.               nbytes -= CHARS_PER_LITTLENUM;
  4407.               p += CHARS_PER_LITTLENUM;
  4408.             }
  4409.  
  4410.           nums = generic_bignum + size / CHARS_PER_LITTLENUM;
  4411.           while (size >= CHARS_PER_LITTLENUM)
  4412.             {
  4413.               --nums;
  4414.               md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM);
  4415.               size -= CHARS_PER_LITTLENUM;
  4416.               p += CHARS_PER_LITTLENUM;
  4417.             }
  4418.         }
  4419.       else
  4420.         {
  4421.           nums = generic_bignum;
  4422.           while (size >= CHARS_PER_LITTLENUM)
  4423.             {
  4424.               md_number_to_chars (p, (valueT) *nums, CHARS_PER_LITTLENUM);
  4425.               ++nums;
  4426.               size -= CHARS_PER_LITTLENUM;
  4427.               p += CHARS_PER_LITTLENUM;
  4428.               nbytes -= CHARS_PER_LITTLENUM;
  4429.             }
  4430.  
  4431.           while (nbytes >= CHARS_PER_LITTLENUM)
  4432.             {
  4433.               md_number_to_chars (p, extra_digit, CHARS_PER_LITTLENUM);
  4434.               nbytes -= CHARS_PER_LITTLENUM;
  4435.               p += CHARS_PER_LITTLENUM;
  4436.             }
  4437.         }
  4438.     }
  4439.   else
  4440.     emit_expr_fix (exp, nbytes, frag_now, p, TC_PARSE_CONS_RETURN_NONE);
  4441. }
  4442.  
  4443. void
  4444. emit_expr_fix (expressionS *exp, unsigned int nbytes, fragS *frag, char *p,
  4445.                TC_PARSE_CONS_RETURN_TYPE r ATTRIBUTE_UNUSED)
  4446. {
  4447.   int offset = 0;
  4448.   unsigned int size = nbytes;
  4449.  
  4450.   memset (p, 0, size);
  4451.  
  4452.   /* Generate a fixS to record the symbol value.  */
  4453.  
  4454. #ifdef TC_CONS_FIX_NEW
  4455.   TC_CONS_FIX_NEW (frag, p - frag->fr_literal + offset, size, exp, r);
  4456. #else
  4457.   if (r != TC_PARSE_CONS_RETURN_NONE)
  4458.   {
  4459.       reloc_howto_type *reloc_howto;
  4460.  
  4461.       reloc_howto = bfd_reloc_type_lookup (stdoutput, r);
  4462.       size = bfd_get_reloc_size (reloc_howto);
  4463.  
  4464.       if (size > nbytes)
  4465.         {
  4466.           as_bad (_("%s relocations do not fit in %u bytes\n"),
  4467.                   reloc_howto->name, nbytes);
  4468.           return;
  4469.         }
  4470.       else if (target_big_endian)
  4471.         offset = nbytes - size;
  4472.     }
  4473.   else
  4474.     switch (size)
  4475.       {
  4476.       case 1:
  4477.         r = BFD_RELOC_8;
  4478.         break;
  4479.       case 2:
  4480.         r = BFD_RELOC_16;
  4481.         break;
  4482.       case 3:
  4483.         r = BFD_RELOC_24;
  4484.         break;
  4485.       case 4:
  4486.         r = BFD_RELOC_32;
  4487.         break;
  4488.       case 8:
  4489.         r = BFD_RELOC_64;
  4490.         break;
  4491.       default:
  4492.         as_bad (_("unsupported BFD relocation size %u"), size);
  4493.         return;
  4494.       }
  4495.   fix_new_exp (frag, p - frag->fr_literal + offset, size,
  4496.                exp, 0, r);
  4497. #endif
  4498. }
  4500. #ifdef BITFIELD_CONS_EXPRESSIONS
  4501.  
  4502. /* i960 assemblers, (eg, asm960), allow bitfields after ".byte" as
  4503.    w:x,y:z, where w and y are bitwidths and x and y are values.  They
  4504.    then pack them all together. We do a little better in that we allow
  4505.    them in words, longs, etc. and we'll pack them in target byte order
  4506.    for you.
  4507.  
  4508.    The rules are: pack least significant bit first, if a field doesn't
  4509.    entirely fit, put it in the next unit.  Overflowing the bitfield is
  4510.    explicitly *not* even a warning.  The bitwidth should be considered
  4511.    a "mask".
  4512.  
  4513.    To use this function the tc-XXX.h file should define
  4514.    BITFIELD_CONS_EXPRESSIONS.  */
  4515.  
  4516. static void
  4517. parse_bitfield_cons (exp, nbytes)
  4518.      expressionS *exp;
  4519.      unsigned int nbytes;
  4520. {
  4521.   unsigned int bits_available = BITS_PER_CHAR * nbytes;
  4522.   char *hold = input_line_pointer;
  4523.  
  4524.   (void) expression (exp);
  4525.  
  4526.   if (*input_line_pointer == ':')
  4527.     {
  4528.       /* Bitfields.  */
  4529.       long value = 0;
  4530.  
  4531.       for (;;)
  4532.         {
  4533.           unsigned long width;
  4534.  
  4535.           if (*input_line_pointer != ':')
  4536.             {
  4537.               input_line_pointer = hold;
  4538.               break;
  4539.             }                   /* Next piece is not a bitfield.  */
  4540.  
  4541.           /* In the general case, we can't allow
  4542.              full expressions with symbol
  4543.              differences and such.  The relocation
  4544.              entries for symbols not defined in this
  4545.              assembly would require arbitrary field
  4546.              widths, positions, and masks which most
  4547.              of our current object formats don't
  4548.              support.
  4549.  
  4550.              In the specific case where a symbol
  4551.              *is* defined in this assembly, we
  4552.              *could* build fixups and track it, but
  4553.              this could lead to confusion for the
  4554.              backends.  I'm lazy. I'll take any
  4555.              SEG_ABSOLUTE. I think that means that
  4556.              you can use a previous .set or
  4557.              .equ type symbol.  xoxorich.  */
  4558.  
  4559.           if (exp->X_op == O_absent)
  4560.             {
  4561.               as_warn (_("using a bit field width of zero"));
  4562.               exp->X_add_number = 0;
  4563.               exp->X_op = O_constant;
  4564.             }                   /* Implied zero width bitfield.  */
  4565.  
  4566.           if (exp->X_op != O_constant)
  4567.             {
  4568.               *input_line_pointer = '\0';
  4569.               as_bad (_("field width \"%s\" too complex for a bitfield"), hold);
  4570.               *input_line_pointer = ':';
  4571.               demand_empty_rest_of_line ();
  4572.               return;
  4573.             }                   /* Too complex.  */
  4574.  
  4575.           if ((width = exp->X_add_number) > (BITS_PER_CHAR * nbytes))
  4576.             {
  4577.               as_warn (_("field width %lu too big to fit in %d bytes: truncated to %d bits"),
  4578.                        width, nbytes, (BITS_PER_CHAR * nbytes));
  4579.               width = BITS_PER_CHAR * nbytes;
  4580.             }                   /* Too big.  */
  4581.  
  4582.           if (width > bits_available)
  4583.             {
  4584.               /* FIXME-SOMEDAY: backing up and reparsing is wasteful.  */
  4585.               input_line_pointer = hold;
  4586.               exp->X_add_number = value;
  4587.               break;
  4588.             }                   /* Won't fit.  */
  4589.  
  4590.           /* Skip ':'.  */
  4591.           hold = ++input_line_pointer;
  4592.  
  4593.           (void) expression (exp);
  4594.           if (exp->X_op != O_constant)
  4595.             {
  4596.               char cache = *input_line_pointer;
  4597.  
  4598.               *input_line_pointer = '\0';
  4599.               as_bad (_("field value \"%s\" too complex for a bitfield"), hold);
  4600.               *input_line_pointer = cache;
  4601.               demand_empty_rest_of_line ();
  4602.               return;
  4603.             }                   /* Too complex.  */
  4604.  
  4605.           value |= ((~(-(1 << width)) & exp->X_add_number)
  4606.                     << ((BITS_PER_CHAR * nbytes) - bits_available));
  4607.  
  4608.           if ((bits_available -= width) == 0
  4609.               || is_it_end_of_statement ()
  4610.               || *input_line_pointer != ',')
  4611.             {
  4612.               break;
  4613.             }                   /* All the bitfields we're gonna get.  */
  4614.  
  4615.           hold = ++input_line_pointer;
  4616.           (void) expression (exp);
  4617.         }
  4618.  
  4619.       exp->X_add_number = value;
  4620.       exp->X_op = O_constant;
  4621.       exp->X_unsigned = 1;
  4622.       exp->X_extrabit = 0;
  4623.     }
  4624. }
  4625.  
  4626. #endif /* BITFIELD_CONS_EXPRESSIONS */
  4628. /* Handle an MRI style string expression.  */
  4629.  
  4630. #ifdef TC_M68K
  4631. static void
  4632. parse_mri_cons (expressionS *exp, unsigned int nbytes)
  4633. {
  4634.   if (*input_line_pointer != '\''
  4635.       && (input_line_pointer[1] != '\''
  4636.           || (*input_line_pointer != 'A'
  4637.               && *input_line_pointer != 'E')))
  4638.     (void) TC_PARSE_CONS_EXPRESSION (exp, nbytes);
  4639.   else
  4640.     {
  4641.       unsigned int scan;
  4642.       unsigned int result = 0;
  4643.  
  4644.       /* An MRI style string.  Cut into as many bytes as will fit into
  4645.          a nbyte chunk, left justify if necessary, and separate with
  4646.          commas so we can try again later.  */
  4647.       if (*input_line_pointer == 'A')
  4648.         ++input_line_pointer;
  4649.       else if (*input_line_pointer == 'E')
  4650.         {
  4651.           as_bad (_("EBCDIC constants are not supported"));
  4652.           ++input_line_pointer;
  4653.         }
  4654.  
  4655.       input_line_pointer++;
  4656.       for (scan = 0; scan < nbytes; scan++)
  4657.         {
  4658.           if (*input_line_pointer == '\'')
  4659.             {
  4660.               if (input_line_pointer[1] == '\'')
  4661.                 {
  4662.                   input_line_pointer++;
  4663.                 }
  4664.               else
  4665.                 break;
  4666.             }
  4667.           result = (result << 8) | (*input_line_pointer++);
  4668.         }
  4669.  
  4670.       /* Left justify.  */
  4671.       while (scan < nbytes)
  4672.         {
  4673.           result <<= 8;
  4674.           scan++;
  4675.         }
  4676.  
  4677.       /* Create correct expression.  */
  4678.       exp->X_op = O_constant;
  4679.       exp->X_add_number = result;
  4680.  
  4681.       /* Fake it so that we can read the next char too.  */
  4682.       if (input_line_pointer[0] != '\'' ||
  4683.           (input_line_pointer[0] == '\'' && input_line_pointer[1] == '\''))
  4684.         {
  4685.           input_line_pointer -= 2;
  4686.           input_line_pointer[0] = ',';
  4687.           input_line_pointer[1] = '\'';
  4688.         }
  4689.       else
  4690.         input_line_pointer++;
  4691.     }
  4692. }
  4693. #endif /* TC_M68K */
  4695. #ifdef REPEAT_CONS_EXPRESSIONS
  4696.  
  4697. /* Parse a repeat expression for cons.  This is used by the MIPS
  4698.    assembler.  The format is NUMBER:COUNT; NUMBER appears in the
  4699.    object file COUNT times.
  4700.  
  4701.    To use this for a target, define REPEAT_CONS_EXPRESSIONS.  */
  4702.  
  4703. static void
  4704. parse_repeat_cons (exp, nbytes)
  4705.      expressionS *exp;
  4706.      unsigned int nbytes;
  4707. {
  4708.   expressionS count;
  4709.   int i;
  4710.  
  4711.   expression (exp);
  4712.  
  4713.   if (*input_line_pointer != ':')
  4714.     {
  4715.       /* No repeat count.  */
  4716.       return;
  4717.     }
  4718.  
  4719.   ++input_line_pointer;
  4720.   expression (&count);
  4721.   if (count.X_op != O_constant
  4722.       || count.X_add_number <= 0)
  4723.     {
  4724.       as_warn (_("unresolvable or nonpositive repeat count; using 1"));
  4725.       return;
  4726.     }
  4727.  
  4728.   /* The cons function is going to output this expression once.  So we
  4729.      output it count - 1 times.  */
  4730.   for (i = count.X_add_number - 1; i > 0; i--)
  4731.     emit_expr (exp, nbytes);
  4732. }
  4733.  
  4734. #endif /* REPEAT_CONS_EXPRESSIONS */
  4736. /* Parse a floating point number represented as a hex constant.  This
  4737.    permits users to specify the exact bits they want in the floating
  4738.    point number.  */
  4739.  
  4740. static int
  4741. hex_float (int float_type, char *bytes)
  4742. {
  4743.   int length;
  4744.   int i;
  4745.  
  4746.   switch (float_type)
  4747.     {
  4748.     case 'f':
  4749.     case 'F':
  4750.     case 's':
  4751.     case 'S':
  4752.       length = 4;
  4753.       break;
  4754.  
  4755.     case 'd':
  4756.     case 'D':
  4757.     case 'r':
  4758.     case 'R':
  4759.       length = 8;
  4760.       break;
  4761.  
  4762.     case 'x':
  4763.     case 'X':
  4764.       length = 12;
  4765.       break;
  4766.  
  4767.     case 'p':
  4768.     case 'P':
  4769.       length = 12;
  4770.       break;
  4771.  
  4772.     default:
  4773.       as_bad (_("unknown floating type type '%c'"), float_type);
  4774.       return -1;
  4775.     }
  4776.  
  4777.   /* It would be nice if we could go through expression to parse the
  4778.      hex constant, but if we get a bignum it's a pain to sort it into
  4779.      the buffer correctly.  */
  4780.   i = 0;
  4781.   while (hex_p (*input_line_pointer) || *input_line_pointer == '_')
  4782.     {
  4783.       int d;
  4784.  
  4785.       /* The MRI assembler accepts arbitrary underscores strewn about
  4786.          through the hex constant, so we ignore them as well.  */
  4787.       if (*input_line_pointer == '_')
  4788.         {
  4789.           ++input_line_pointer;
  4790.           continue;
  4791.         }
  4792.  
  4793.       if (i >= length)
  4794.         {
  4795.           as_warn (_("floating point constant too large"));
  4796.           return -1;
  4797.         }
  4798.       d = hex_value (*input_line_pointer) << 4;
  4799.       ++input_line_pointer;
  4800.       while (*input_line_pointer == '_')
  4801.         ++input_line_pointer;
  4802.       if (hex_p (*input_line_pointer))
  4803.         {
  4804.           d += hex_value (*input_line_pointer);
  4805.           ++input_line_pointer;
  4806.         }
  4807.       if (target_big_endian)
  4808.         bytes[i] = d;
  4809.       else
  4810.         bytes[length - i - 1] = d;
  4811.       ++i;
  4812.     }
  4813.  
  4814.   if (i < length)
  4815.     {
  4816.       if (target_big_endian)
  4817.         memset (bytes + i, 0, length - i);
  4818.       else
  4819.         memset (bytes, 0, length - i);
  4820.     }
  4821.  
  4822.   return length;
  4823. }
  4824.  
  4825. /*                      float_cons()
  4826.  
  4827.    CONStruct some more frag chars of .floats .ffloats etc.
  4828.    Makes 0 or more new frags.
  4829.    If need_pass_2 == 1, no frags are emitted.
  4830.    This understands only floating literals, not expressions. Sorry.
  4831.  
  4832.    A floating constant is defined by atof_generic(), except it is preceded
  4833.    by 0d 0f 0g or 0h. After observing the STRANGE way my BSD AS does its
  4834.    reading, I decided to be incompatible. This always tries to give you
  4835.    rounded bits to the precision of the pseudo-op. Former AS did premature
  4836.    truncation, restored noisy bits instead of trailing 0s AND gave you
  4837.    a choice of 2 flavours of noise according to which of 2 floating-point
  4838.    scanners you directed AS to use.
  4839.  
  4840.    In:  input_line_pointer->whitespace before, or '0' of flonum.  */
  4841.  
  4842. void
  4843. float_cons (/* Clobbers input_line-pointer, checks end-of-line.  */
  4844.             int float_type      /* 'f':.ffloat ... 'F':.float ...  */)
  4845. {
  4846.   char *p;
  4847.   int length;                   /* Number of chars in an object.  */
  4848.   char *err;            /* Error from scanning floating literal.  */
  4849.   char temp[MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT];
  4850.  
  4851.   if (is_it_end_of_statement ())
  4852.     {
  4853.       demand_empty_rest_of_line ();
  4854.       return;
  4855.     }
  4856.  
  4857. #ifdef md_flush_pending_output
  4858.   md_flush_pending_output ();
  4859. #endif
  4860.  
  4861. #ifdef md_cons_align
  4862.   md_cons_align (1);
  4863. #endif
  4864.  
  4865.   do
  4866.     {
  4867.       /* input_line_pointer->1st char of a flonum (we hope!).  */
  4868.       SKIP_WHITESPACE ();
  4869.  
  4870.       /* Skip any 0{letter} that may be present. Don't even check if the
  4871.          letter is legal. Someone may invent a "z" format and this routine
  4872.          has no use for such information. Lusers beware: you get
  4873.          diagnostics if your input is ill-conditioned.  */
  4874.       if (input_line_pointer[0] == '0'
  4875.           && ISALPHA (input_line_pointer[1]))
  4876.         input_line_pointer += 2;
  4877.  
  4878.       /* Accept :xxxx, where the x's are hex digits, for a floating
  4879.          point with the exact digits specified.  */
  4880.       if (input_line_pointer[0] == ':')
  4881.         {
  4882.           ++input_line_pointer;
  4883.           length = hex_float (float_type, temp);
  4884.           if (length < 0)
  4885.             {
  4886.               ignore_rest_of_line ();
  4887.               return;
  4888.             }
  4889.         }
  4890.       else
  4891.         {
  4892.           err = md_atof (float_type, temp, &length);
  4893.           know (length <= MAXIMUM_NUMBER_OF_CHARS_FOR_FLOAT);
  4894.           know (err != NULL || length > 0);
  4895.           if (err)
  4896.             {
  4897.               as_bad (_("bad floating literal: %s"), err);
  4898.               ignore_rest_of_line ();
  4899.               return;
  4900.             }
  4901.         }
  4902.  
  4903.       if (!need_pass_2)
  4904.         {
  4905.           int count;
  4906.  
  4907.           count = 1;
  4908.  
  4909. #ifdef REPEAT_CONS_EXPRESSIONS
  4910.           if (*input_line_pointer == ':')
  4911.             {
  4912.               expressionS count_exp;
  4913.  
  4914.               ++input_line_pointer;
  4915.               expression (&count_exp);
  4916.  
  4917.               if (count_exp.X_op != O_constant
  4918.                   || count_exp.X_add_number <= 0)
  4919.                 as_warn (_("unresolvable or nonpositive repeat count; using 1"));
  4920.               else
  4921.                 count = count_exp.X_add_number;
  4922.             }
  4923. #endif
  4924.  
  4925.           while (--count >= 0)
  4926.             {
  4927.               p = frag_more (length);
  4928.               memcpy (p, temp, (unsigned int) length);
  4929.             }
  4930.         }
  4931.       SKIP_WHITESPACE ();
  4932.     }
  4933.   while (*input_line_pointer++ == ',');
  4934.  
  4935.   /* Put terminator back into stream.  */
  4936.   --input_line_pointer;
  4937.   demand_empty_rest_of_line ();
  4938. }
  4940. /* Return the size of a LEB128 value.  */
  4941.  
  4942. static inline int
  4943. sizeof_sleb128 (offsetT value)
  4944. {
  4945.   int size = 0;
  4946.   unsigned byte;
  4947.  
  4948.   do
  4949.     {
  4950.       byte = (value & 0x7f);
  4951.       /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
  4952.          Fortunately, we can structure things so that the extra work reduces
  4953.          to a noop on systems that do things "properly".  */
  4954.       value = (value >> 7) | ~(-(offsetT)1 >> 7);
  4955.       size += 1;
  4956.     }
  4957.   while (!(((value == 0) && ((byte & 0x40) == 0))
  4958.            || ((value == -1) && ((byte & 0x40) != 0))));
  4959.  
  4960.   return size;
  4961. }
  4962.  
  4963. static inline int
  4964. sizeof_uleb128 (valueT value)
  4965. {
  4966.   int size = 0;
  4967.  
  4968.   do
  4969.     {
  4970.       value >>= 7;
  4971.       size += 1;
  4972.     }
  4973.   while (value != 0);
  4974.  
  4975.   return size;
  4976. }
  4977.  
  4978. int
  4979. sizeof_leb128 (valueT value, int sign)
  4980. {
  4981.   if (sign)
  4982.     return sizeof_sleb128 ((offsetT) value);
  4983.   else
  4984.     return sizeof_uleb128 (value);
  4985. }
  4986.  
  4987. /* Output a LEB128 value.  */
  4988.  
  4989. static inline int
  4990. output_sleb128 (char *p, offsetT value)
  4991. {
  4992.   char *orig = p;
  4993.   int more;
  4994.  
  4995.   do
  4996.     {
  4997.       unsigned byte = (value & 0x7f);
  4998.  
  4999.       /* Sadly, we cannot rely on typical arithmetic right shift behaviour.
  5000.          Fortunately, we can structure things so that the extra work reduces
  5001.          to a noop on systems that do things "properly".  */
  5002.       value = (value >> 7) | ~(-(offsetT)1 >> 7);
  5003.  
  5004.       more = !((((value == 0) && ((byte & 0x40) == 0))
  5005.                 || ((value == -1) && ((byte & 0x40) != 0))));
  5006.       if (more)
  5007.         byte |= 0x80;
  5008.  
  5009.       *p++ = byte;
  5010.     }
  5011.   while (more);
  5012.  
  5013.   return p - orig;
  5014. }
  5015.  
  5016. static inline int
  5017. output_uleb128 (char *p, valueT value)
  5018. {
  5019.   char *orig = p;
  5020.  
  5021.   do
  5022.     {
  5023.       unsigned byte = (value & 0x7f);
  5024.       value >>= 7;
  5025.       if (value != 0)
  5026.         /* More bytes to follow.  */
  5027.         byte |= 0x80;
  5028.  
  5029.       *p++ = byte;
  5030.     }
  5031.   while (value != 0);
  5032.  
  5033.   return p - orig;
  5034. }
  5035.  
  5036. int
  5037. output_leb128 (char *p, valueT value, int sign)
  5038. {
  5039.   if (sign)
  5040.     return output_sleb128 (p, (offsetT) value);
  5041.   else
  5042.     return output_uleb128 (p, value);
  5043. }
  5044.  
  5045. /* Do the same for bignums.  We combine sizeof with output here in that
  5046.    we don't output for NULL values of P.  It isn't really as critical as
  5047.    for "normal" values that this be streamlined.  */
  5048.  
  5049. static inline int
  5050. output_big_sleb128 (char *p, LITTLENUM_TYPE *bignum, int size)
  5051. {
  5052.   char *orig = p;
  5053.   valueT val = 0;
  5054.   int loaded = 0;
  5055.   unsigned byte;
  5056.  
  5057.   /* Strip leading sign extensions off the bignum.  */
  5058.   while (size > 1
  5059.          && bignum[size - 1] == LITTLENUM_MASK
  5060.          && bignum[size - 2] > LITTLENUM_MASK / 2)
  5061.     size--;
  5062.  
  5063.   do
  5064.     {
  5065.       /* OR in the next part of the littlenum.  */
  5066.       val |= (*bignum << loaded);
  5067.       loaded += LITTLENUM_NUMBER_OF_BITS;
  5068.       size--;
  5069.       bignum++;
  5070.  
  5071.       /* Add bytes until there are less than 7 bits left in VAL
  5072.          or until every non-sign bit has been written.  */
  5073.       do
  5074.         {
  5075.           byte = val & 0x7f;
  5076.           loaded -= 7;
  5077.           val >>= 7;
  5078.           if (size > 0
  5079.               || val != ((byte & 0x40) == 0 ? 0 : ((valueT) 1 << loaded) - 1))
  5080.             byte |= 0x80;
  5081.  
  5082.           if (orig)
  5083.             *p = byte;
  5084.           p++;
  5085.         }
  5086.       while ((byte & 0x80) != 0 && loaded >= 7);
  5087.     }
  5088.   while (size > 0);
  5089.  
  5090.   /* Mop up any left-over bits (of which there will be less than 7).  */
  5091.   if ((byte & 0x80) != 0)
  5092.     {
  5093.       /* Sign-extend VAL.  */
  5094.       if (val & (1 << (loaded - 1)))
  5095.         val |= ~0U << loaded;
  5096.       if (orig)
  5097.         *p = val & 0x7f;
  5098.       p++;
  5099.     }
  5100.  
  5101.   return p - orig;
  5102. }
  5103.  
  5104. static inline int
  5105. output_big_uleb128 (char *p, LITTLENUM_TYPE *bignum, int size)
  5106. {
  5107.   char *orig = p;
  5108.   valueT val = 0;
  5109.   int loaded = 0;
  5110.   unsigned byte;
  5111.  
  5112.   /* Strip leading zeros off the bignum.  */
  5113.   /* XXX: Is this needed?  */
  5114.   while (size > 0 && bignum[size - 1] == 0)
  5115.     size--;
  5116.  
  5117.   do
  5118.     {
  5119.       if (loaded < 7 && size > 0)
  5120.         {
  5121.           val |= (*bignum << loaded);
  5122.           loaded += 8 * CHARS_PER_LITTLENUM;
  5123.           size--;
  5124.           bignum++;
  5125.         }
  5126.  
  5127.       byte = val & 0x7f;
  5128.       loaded -= 7;
  5129.       val >>= 7;
  5130.  
  5131.       if (size > 0 || val)
  5132.         byte |= 0x80;
  5133.  
  5134.       if (orig)
  5135.         *p = byte;
  5136.       p++;
  5137.     }
  5138.   while (byte & 0x80);
  5139.  
  5140.   return p - orig;
  5141. }
  5142.  
  5143. static int
  5144. output_big_leb128 (char *p, LITTLENUM_TYPE *bignum, int size, int sign)
  5145. {
  5146.   if (sign)
  5147.     return output_big_sleb128 (p, bignum, size);
  5148.   else
  5149.     return output_big_uleb128 (p, bignum, size);
  5150. }
  5151.  
  5152. /* Generate the appropriate fragments for a given expression to emit a
  5153.    leb128 value.  */
  5154.  
  5155. static void
  5156. emit_leb128_expr (expressionS *exp, int sign)
  5157. {
  5158.   operatorT op = exp->X_op;
  5159.   unsigned int nbytes;
  5160.  
  5161.   if (op == O_absent || op == O_illegal)
  5162.     {
  5163.       as_warn (_("zero assumed for missing expression"));
  5164.       exp->X_add_number = 0;
  5165.       op = O_constant;
  5166.     }
  5167.   else if (op == O_big && exp->X_add_number <= 0)
  5168.     {
  5169.       as_bad (_("floating point number invalid"));
  5170.       exp->X_add_number = 0;
  5171.       op = O_constant;
  5172.     }
  5173.   else if (op == O_register)
  5174.     {
  5175.       as_warn (_("register value used as expression"));
  5176.       op = O_constant;
  5177.     }
  5178.   else if (op == O_constant
  5179.            && sign
  5180.            && (exp->X_add_number < 0) == !exp->X_extrabit)
  5181.     {
  5182.       /* We're outputting a signed leb128 and the sign of X_add_number
  5183.          doesn't reflect the sign of the original value.  Convert EXP
  5184.          to a correctly-extended bignum instead.  */
  5185.       convert_to_bignum (exp, exp->X_extrabit);
  5186.       op = O_big;
  5187.     }
  5188.  
  5189.   /* Let check_eh_frame know that data is being emitted.  nbytes == -1 is
  5190.      a signal that this is leb128 data.  It shouldn't optimize this away.  */
  5191.   nbytes = (unsigned int) -1;
  5192.   if (check_eh_frame (exp, &nbytes))
  5193.     abort ();
  5194.  
  5195.   /* Let the backend know that subsequent data may be byte aligned.  */
  5196. #ifdef md_cons_align
  5197.   md_cons_align (1);
  5198. #endif
  5199.  
  5200.   if (op == O_constant)
  5201.     {
  5202.       /* If we've got a constant, emit the thing directly right now.  */
  5203.  
  5204.       valueT value = exp->X_add_number;
  5205.       int size;
  5206.       char *p;
  5207.  
  5208.       size = sizeof_leb128 (value, sign);
  5209.       p = frag_more (size);
  5210.       output_leb128 (p, value, sign);
  5211.     }
  5212.   else if (op == O_big)
  5213.     {
  5214.       /* O_big is a different sort of constant.  */
  5215.  
  5216.       int size;
  5217.       char *p;
  5218.  
  5219.       size = output_big_leb128 (NULL, generic_bignum, exp->X_add_number, sign);
  5220.       p = frag_more (size);
  5221.       output_big_leb128 (p, generic_bignum, exp->X_add_number, sign);
  5222.     }
  5223.   else
  5224.     {
  5225.       /* Otherwise, we have to create a variable sized fragment and
  5226.          resolve things later.  */
  5227.  
  5228.       frag_var (rs_leb128, sizeof_uleb128 (~(valueT) 0), 0, sign,
  5229.                 make_expr_symbol (exp), 0, (char *) NULL);
  5230.     }
  5231. }
  5232.  
  5233. /* Parse the .sleb128 and .uleb128 pseudos.  */
  5234.  
  5235. void
  5236. s_leb128 (int sign)
  5237. {
  5238.   expressionS exp;
  5239.  
  5240. #ifdef md_flush_pending_output
  5241.   md_flush_pending_output ();
  5242. #endif
  5243.  
  5244.   do
  5245.     {
  5246.       expression (&exp);
  5247.       emit_leb128_expr (&exp, sign);
  5248.     }
  5249.   while (*input_line_pointer++ == ',');
  5250.  
  5251.   input_line_pointer--;
  5252.   demand_empty_rest_of_line ();
  5253. }
  5255. static void
  5256. stringer_append_char (int c, int bitsize)
  5257. {
  5258.   if (!target_big_endian)
  5259.     FRAG_APPEND_1_CHAR (c);
  5260.  
  5261.   switch (bitsize)
  5262.     {
  5263.     case 64:
  5264.       FRAG_APPEND_1_CHAR (0);
  5265.       FRAG_APPEND_1_CHAR (0);
  5266.       FRAG_APPEND_1_CHAR (0);
  5267.       FRAG_APPEND_1_CHAR (0);
  5268.       /* Fall through.  */
  5269.     case 32:
  5270.       FRAG_APPEND_1_CHAR (0);
  5271.       FRAG_APPEND_1_CHAR (0);
  5272.       /* Fall through.  */
  5273.     case 16:
  5274.       FRAG_APPEND_1_CHAR (0);
  5275.       /* Fall through.  */
  5276.     case 8:
  5277.       break;
  5278.     default:
  5279.       /* Called with invalid bitsize argument.  */
  5280.       abort ();
  5281.       break;
  5282.     }
  5283.   if (target_big_endian)
  5284.     FRAG_APPEND_1_CHAR (c);
  5285. }
  5286.  
  5287. /* Worker to do .ascii etc statements.
  5288.    Reads 0 or more ',' separated, double-quoted strings.
  5289.    Caller should have checked need_pass_2 is FALSE because we don't
  5290.    check it.
  5291.    Checks for end-of-line.
  5292.    BITS_APPENDZERO says how many bits are in a target char.
  5293.    The bottom bit is set if a NUL char should be appended to the strings.  */
  5294.  
  5295. void
  5296. stringer (int bits_appendzero)
  5297. {
  5298.   const int bitsize = bits_appendzero & ~7;
  5299.   const int append_zero = bits_appendzero & 1;
  5300.   unsigned int c;
  5301. #if !defined(NO_LISTING) && defined (OBJ_ELF)
  5302.   char *start;
  5303. #endif
  5304.  
  5305. #ifdef md_flush_pending_output
  5306.   md_flush_pending_output ();
  5307. #endif
  5308.  
  5309. #ifdef md_cons_align
  5310.   md_cons_align (1);
  5311. #endif
  5312.  
  5313.   /* The following awkward logic is to parse ZERO or more strings,
  5314.      comma separated. Recall a string expression includes spaces
  5315.      before the opening '\"' and spaces after the closing '\"'.
  5316.      We fake a leading ',' if there is (supposed to be)
  5317.      a 1st, expression. We keep demanding expressions for each ','.  */
  5318.   if (is_it_end_of_statement ())
  5319.     {
  5320.       c = 0;                    /* Skip loop.  */
  5321.       ++input_line_pointer;     /* Compensate for end of loop.  */
  5322.     }
  5323.   else
  5324.     {
  5325.       c = ',';                  /* Do loop.  */
  5326.     }
  5327.   /* If we have been switched into the abs_section then we
  5328.      will not have an obstack onto which we can hang strings.  */
  5329.   if (now_seg == absolute_section)
  5330.     {
  5331.       as_bad (_("strings must be placed into a section"));
  5332.       c = 0;
  5333.       ignore_rest_of_line ();
  5334.     }
  5335.  
  5336.   while (c == ',' || c == '<' || c == '"')
  5337.     {
  5338.       SKIP_WHITESPACE ();
  5339.       switch (*input_line_pointer)
  5340.         {
  5341.         case '\"':
  5342.           ++input_line_pointer; /*->1st char of string.  */
  5343. #if !defined(NO_LISTING) && defined (OBJ_ELF)
  5344.           start = input_line_pointer;
  5345. #endif
  5346.  
  5347.           while (is_a_char (c = next_char_of_string ()))
  5348.             stringer_append_char (c, bitsize);
  5349.  
  5350.           if (append_zero)
  5351.             stringer_append_char (0, bitsize);
  5352.  
  5353.           know (input_line_pointer[-1] == '\"');
  5354.  
  5355. #if !defined(NO_LISTING) && defined (OBJ_ELF)
  5356.           /* In ELF, when gcc is emitting DWARF 1 debugging output, it
  5357.              will emit .string with a filename in the .debug section
  5358.              after a sequence of constants.  See the comment in
  5359.              emit_expr for the sequence.  emit_expr will set
  5360.              dwarf_file_string to non-zero if this string might be a
  5361.              source file name.  */
  5362.           if (strcmp (segment_name (now_seg), ".debug") != 0)
  5363.             dwarf_file_string = 0;
  5364.           else if (dwarf_file_string)
  5365.             {
  5366.               c = input_line_pointer[-1];
  5367.               input_line_pointer[-1] = '\0';
  5368.               listing_source_file (start);
  5369.               input_line_pointer[-1] = c;
  5370.             }
  5371. #endif
  5372.  
  5373.           break;
  5374.         case '<':
  5375.           input_line_pointer++;
  5376.           c = get_single_number ();
  5377.           stringer_append_char (c, bitsize);
  5378.           if (*input_line_pointer != '>')
  5379.             as_bad (_("expected <nn>"));
  5380.  
  5381.           input_line_pointer++;
  5382.           break;
  5383.         case ',':
  5384.           input_line_pointer++;
  5385.           break;
  5386.         }
  5387.       SKIP_WHITESPACE ();
  5388.       c = *input_line_pointer;
  5389.     }
  5390.  
  5391.   demand_empty_rest_of_line ();
  5392. }
  5394. /* FIXME-SOMEDAY: I had trouble here on characters with the
  5395.     high bits set.  We'll probably also have trouble with
  5396.     multibyte chars, wide chars, etc.  Also be careful about
  5397.     returning values bigger than 1 byte.  xoxorich.  */
  5398.  
  5399. unsigned int
  5400. next_char_of_string (void)
  5401. {
  5402.   unsigned int c;
  5403.  
  5404.   c = *input_line_pointer++ & CHAR_MASK;
  5405.   switch (c)
  5406.     {
  5407.     case '\"':
  5408.       c = NOT_A_CHAR;
  5409.       break;
  5410.  
  5411.     case '\n':
  5412.       as_warn (_("unterminated string; newline inserted"));
  5413.       bump_line_counters ();
  5414.       break;
  5415.  
  5416. #ifndef NO_STRING_ESCAPES
  5417.     case '\\':
  5418.       switch (c = *input_line_pointer++ & CHAR_MASK)
  5419.         {
  5420.         case 'b':
  5421.           c = '\b';
  5422.           break;
  5423.  
  5424.         case 'f':
  5425.           c = '\f';
  5426.           break;
  5427.  
  5428.         case 'n':
  5429.           c = '\n';
  5430.           break;
  5431.  
  5432.         case 'r':
  5433.           c = '\r';
  5434.           break;
  5435.  
  5436.         case 't':
  5437.           c = '\t';
  5438.           break;
  5439.  
  5440.         case 'v':
  5441.           c = '\013';
  5442.           break;
  5443.  
  5444.         case '\\':
  5445.         case '"':
  5446.           break;                /* As itself.  */
  5447.  
  5448.         case '0':
  5449.         case '1':
  5450.         case '2':
  5451.         case '3':
  5452.         case '4':
  5453.         case '5':
  5454.         case '6':
  5455.         case '7':
  5456.         case '8':
  5457.         case '9':
  5458.           {
  5459.             long number;
  5460.             int i;
  5461.  
  5462.             for (i = 0, number = 0;
  5463.                  ISDIGIT (c) && i < 3;
  5464.                  c = *input_line_pointer++, i++)
  5465.               {
  5466.                 number = number * 8 + c - '0';
  5467.               }
  5468.  
  5469.             c = number & CHAR_MASK;
  5470.           }
  5471.           --input_line_pointer;
  5472.           break;
  5473.  
  5474.         case 'x':
  5475.         case 'X':
  5476.           {
  5477.             long number;
  5478.  
  5479.             number = 0;
  5480.             c = *input_line_pointer++;
  5481.             while (ISXDIGIT (c))
  5482.               {
  5483.                 if (ISDIGIT (c))
  5484.                   number = number * 16 + c - '0';
  5485.                 else if (ISUPPER (c))
  5486.                   number = number * 16 + c - 'A' + 10;
  5487.                 else
  5488.                   number = number * 16 + c - 'a' + 10;
  5489.                 c = *input_line_pointer++;
  5490.               }
  5491.             c = number & CHAR_MASK;
  5492.             --input_line_pointer;
  5493.           }
  5494.           break;
  5495.  
  5496.         case '\n':
  5497.           /* To be compatible with BSD 4.2 as: give the luser a linefeed!!  */
  5498.           as_warn (_("unterminated string; newline inserted"));
  5499.           c = '\n';
  5500.           bump_line_counters ();
  5501.           break;
  5502.  
  5503.         default:
  5504.  
  5505. #ifdef ONLY_STANDARD_ESCAPES
  5506.           as_bad (_("bad escaped character in string"));
  5507.           c = '?';
  5508. #endif /* ONLY_STANDARD_ESCAPES */
  5509.  
  5510.           break;
  5511.         }
  5512.       break;
  5513. #endif /* ! defined (NO_STRING_ESCAPES) */
  5514.  
  5515.     default:
  5516.       break;
  5517.     }
  5518.   return (c);
  5519. }
  5521. static segT
  5522. get_segmented_expression (expressionS *expP)
  5523. {
  5524.   segT retval;
  5525.  
  5526.   retval = expression (expP);
  5527.   if (expP->X_op == O_illegal
  5528.       || expP->X_op == O_absent
  5529.       || expP->X_op == O_big)
  5530.     {
  5531.       as_bad (_("expected address expression"));
  5532.       expP->X_op = O_constant;
  5533.       expP->X_add_number = 0;
  5534.       retval = absolute_section;
  5535.     }
  5536.   return retval;
  5537. }
  5538.  
  5539. static segT
  5540. get_known_segmented_expression (expressionS *expP)
  5541. {
  5542.   segT retval = get_segmented_expression (expP);
  5543.  
  5544.   if (retval == undefined_section)
  5545.     {
  5546.       /* There is no easy way to extract the undefined symbol from the
  5547.          expression.  */
  5548.       if (expP->X_add_symbol != NULL
  5549.           && S_GET_SEGMENT (expP->X_add_symbol) != expr_section)
  5550.         as_warn (_("symbol \"%s\" undefined; zero assumed"),
  5551.                  S_GET_NAME (expP->X_add_symbol));
  5552.       else
  5553.         as_warn (_("some symbol undefined; zero assumed"));
  5554.       retval = absolute_section;
  5555.       expP->X_op = O_constant;
  5556.       expP->X_add_number = 0;
  5557.     }
  5558.   return retval;
  5559. }
  5560.  
  5561. char                            /* Return terminator.  */
  5562. get_absolute_expression_and_terminator (long *val_pointer /* Return value of expression.  */)
  5563. {
  5564.   /* FIXME: val_pointer should probably be offsetT *.  */
  5565.   *val_pointer = (long) get_absolute_expression ();
  5566.   return (*input_line_pointer++);
  5567. }
  5569. /* Like demand_copy_string, but return NULL if the string contains any '\0's.
  5570.    Give a warning if that happens.  */
  5571.  
  5572. char *
  5573. demand_copy_C_string (int *len_pointer)
  5574. {
  5575.   char *s;
  5576.  
  5577.   if ((s = demand_copy_string (len_pointer)) != 0)
  5578.     {
  5579.       int len;
  5580.  
  5581.       for (len = *len_pointer; len > 0; len--)
  5582.         {
  5583.           if (*s == 0)
  5584.             {
  5585.               s = 0;
  5586.               len = 1;
  5587.               *len_pointer = 0;
  5588.               as_bad (_("this string may not contain \'\\0\'"));
  5589.             }
  5590.         }
  5591.     }
  5592.  
  5593.   return s;
  5594. }
  5596. /* Demand string, but return a safe (=private) copy of the string.
  5597.    Return NULL if we can't read a string here.  */
  5598.  
  5599. char *
  5600. demand_copy_string (int *lenP)
  5601. {
  5602.   unsigned int c;
  5603.   int len;
  5604.   char *retval;
  5605.  
  5606.   len = 0;
  5607.   SKIP_WHITESPACE ();
  5608.   if (*input_line_pointer == '\"')
  5609.     {
  5610.       input_line_pointer++;     /* Skip opening quote.  */
  5611.  
  5612.       while (is_a_char (c = next_char_of_string ()))
  5613.         {
  5614.           obstack_1grow (&notes, c);
  5615.           len++;
  5616.         }
  5617.       /* JF this next line is so demand_copy_C_string will return a
  5618.          null terminated string.  */
  5619.       obstack_1grow (&notes, '\0');
  5620.       retval = (char *) obstack_finish (&notes);
  5621.     }
  5622.   else
  5623.     {
  5624.       as_bad (_("missing string"));
  5625.       retval = NULL;
  5626.       ignore_rest_of_line ();
  5627.     }
  5628.   *lenP = len;
  5629.   return (retval);
  5630. }
  5632. /* In:  Input_line_pointer->next character.
  5633.  
  5634.    Do:  Skip input_line_pointer over all whitespace.
  5635.  
  5636.    Out: 1 if input_line_pointer->end-of-line.  */
  5637.  
  5638. int
  5639. is_it_end_of_statement (void)
  5640. {
  5641.   SKIP_WHITESPACE ();
  5642.   return (is_end_of_line[(unsigned char) *input_line_pointer]);
  5643. }
  5644.  
  5645. void
  5646. equals (char *sym_name, int reassign)
  5647. {
  5648.   char *stop = NULL;
  5649.   char stopc = 0;
  5650.  
  5651.   input_line_pointer++;
  5652.   if (*input_line_pointer == '=')
  5653.     input_line_pointer++;
  5654.   if (reassign < 0 && *input_line_pointer == '=')
  5655.     input_line_pointer++;
  5656.  
  5657.   while (*input_line_pointer == ' ' || *input_line_pointer == '\t')
  5658.     input_line_pointer++;
  5659.  
  5660.   if (flag_mri)
  5661.     stop = mri_comment_field (&stopc);
  5662.  
  5663.   assign_symbol (sym_name, reassign >= 0 ? !reassign : reassign);
  5664.  
  5665.   if (flag_mri)
  5666.     {
  5667.       demand_empty_rest_of_line ();
  5668.       mri_comment_end (stop, stopc);
  5669.     }
  5670. }
  5671.  
  5672. /* .incbin -- include a file verbatim at the current location.  */
  5673.  
  5674. void
  5675. s_incbin (int x ATTRIBUTE_UNUSED)
  5676. {
  5677.   FILE * binfile;
  5678.   char * path;
  5679.   char * filename;
  5680.   char * binfrag;
  5681.   long   skip = 0;
  5682.   long   count = 0;
  5683.   long   bytes;
  5684.   int    len;
  5685.  
  5686. #ifdef md_flush_pending_output
  5687.   md_flush_pending_output ();
  5688. #endif
  5689.  
  5690. #ifdef md_cons_align
  5691.   md_cons_align (1);
  5692. #endif
  5693.  
  5694.   SKIP_WHITESPACE ();
  5695.   filename = demand_copy_string (& len);
  5696.   if (filename == NULL)
  5697.     return;
  5698.  
  5699.   SKIP_WHITESPACE ();
  5700.  
  5701.   /* Look for optional skip and count.  */
  5702.   if (* input_line_pointer == ',')
  5703.     {
  5704.       ++ input_line_pointer;
  5705.       skip = get_absolute_expression ();
  5706.  
  5707.       SKIP_WHITESPACE ();
  5708.  
  5709.       if (* input_line_pointer == ',')
  5710.         {
  5711.           ++ input_line_pointer;
  5712.  
  5713.           count = get_absolute_expression ();
  5714.           if (count == 0)
  5715.             as_warn (_(".incbin count zero, ignoring `%s'"), filename);
  5716.  
  5717.           SKIP_WHITESPACE ();
  5718.         }
  5719.     }
  5720.  
  5721.   demand_empty_rest_of_line ();
  5722.  
  5723.   /* Try opening absolute path first, then try include dirs.  */
  5724.   binfile = fopen (filename, FOPEN_RB);
  5725.   if (binfile == NULL)
  5726.     {
  5727.       int i;
  5728.  
  5729.       path = (char *) xmalloc ((unsigned long) len + include_dir_maxlen + 5);
  5730.  
  5731.       for (i = 0; i < include_dir_count; i++)
  5732.         {
  5733.           sprintf (path, "%s/%s", include_dirs[i], filename);
  5734.  
  5735.           binfile = fopen (path, FOPEN_RB);
  5736.           if (binfile != NULL)
  5737.             break;
  5738.         }
  5739.  
  5740.       if (binfile == NULL)
  5741.         as_bad (_("file not found: %s"), filename);
  5742.     }
  5743.   else
  5744.     path = xstrdup (filename);
  5745.  
  5746.   if (binfile)
  5747.     {
  5748.       long   file_len;
  5749.  
  5750.       register_dependency (path);
  5751.  
  5752.       /* Compute the length of the file.  */
  5753.       if (fseek (binfile, 0, SEEK_END) != 0)
  5754.         {
  5755.           as_bad (_("seek to end of .incbin file failed `%s'"), path);
  5756.           goto done;
  5757.         }
  5758.       file_len = ftell (binfile);
  5759.  
  5760.       /* If a count was not specified use the remainder of the file.  */
  5761.       if (count == 0)
  5762.         count = file_len - skip;
  5763.  
  5764.       if (skip < 0 || count < 0 || file_len < 0 || skip + count > file_len)
  5765.         {
  5766.           as_bad (_("skip (%ld) or count (%ld) invalid for file size (%ld)"),
  5767.                   skip, count, file_len);
  5768.           goto done;
  5769.         }
  5770.  
  5771.       if (fseek (binfile, skip, SEEK_SET) != 0)
  5772.         {
  5773.           as_bad (_("could not skip to %ld in file `%s'"), skip, path);
  5774.           goto done;
  5775.         }
  5776.  
  5777.       /* Allocate frag space and store file contents in it.  */
  5778.       binfrag = frag_more (count);
  5779.  
  5780.       bytes = fread (binfrag, 1, count, binfile);
  5781.       if (bytes < count)
  5782.         as_warn (_("truncated file `%s', %ld of %ld bytes read"),
  5783.                  path, bytes, count);
  5784.     }
  5785. done:
  5786.   if (binfile != NULL)
  5787.     fclose (binfile);
  5788.   if (path)
  5789.     free (path);
  5790. }
  5791.  
  5792. /* .include -- include a file at this point.  */
  5793.  
  5794. void
  5795. s_include (int arg ATTRIBUTE_UNUSED)
  5796. {
  5797.   char *filename;
  5798.   int i;
  5799.   FILE *try_file;
  5800.   char *path;
  5801.  
  5802.   if (!flag_m68k_mri)
  5803.     {
  5804.       filename = demand_copy_string (&i);
  5805.       if (filename == NULL)
  5806.         {
  5807.           /* demand_copy_string has already printed an error and
  5808.              called ignore_rest_of_line.  */
  5809.           return;
  5810.         }
  5811.     }
  5812.   else
  5813.     {
  5814.       SKIP_WHITESPACE ();
  5815.       i = 0;
  5816.       while (!is_end_of_line[(unsigned char) *input_line_pointer]
  5817.              && *input_line_pointer != ' '
  5818.              && *input_line_pointer != '\t')
  5819.         {
  5820.           obstack_1grow (&notes, *input_line_pointer);
  5821.           ++input_line_pointer;
  5822.           ++i;
  5823.         }
  5824.  
  5825.       obstack_1grow (&notes, '\0');
  5826.       filename = (char *) obstack_finish (&notes);
  5827.       while (!is_end_of_line[(unsigned char) *input_line_pointer])
  5828.         ++input_line_pointer;
  5829.     }
  5830.  
  5831.   demand_empty_rest_of_line ();
  5832.   path = (char *) xmalloc ((unsigned long) i
  5833.                            + include_dir_maxlen + 5 /* slop */ );
  5834.  
  5835.   for (i = 0; i < include_dir_count; i++)
  5836.     {
  5837.       strcpy (path, include_dirs[i]);
  5838.       strcat (path, "/");
  5839.       strcat (path, filename);
  5840.       if (0 != (try_file = fopen (path, FOPEN_RT)))
  5841.         {
  5842.           fclose (try_file);
  5843.           goto gotit;
  5844.         }
  5845.     }
  5846.  
  5847.   free (path);
  5848.   path = filename;
  5849. gotit:
  5850.   /* malloc Storage leak when file is found on path.  FIXME-SOMEDAY.  */
  5851.   register_dependency (path);
  5852.   input_scrub_insert_file (path);
  5853. }
  5854.  
  5855. void
  5856. add_include_dir (char *path)
  5857. {
  5858.   int i;
  5859.  
  5860.   if (include_dir_count == 0)
  5861.     {
  5862.       include_dirs = (char **) xmalloc (2 * sizeof (*include_dirs));
  5863.       include_dirs[0] = ".";    /* Current dir.  */
  5864.       include_dir_count = 2;
  5865.     }
  5866.   else
  5867.     {
  5868.       include_dir_count++;
  5869.       include_dirs =
  5870.         (char **) xrealloc (include_dirs,
  5871.                            include_dir_count * sizeof (*include_dirs));
  5872.     }
  5873.  
  5874.   include_dirs[include_dir_count - 1] = path;   /* New one.  */
  5875.  
  5876.   i = strlen (path);
  5877.   if (i > include_dir_maxlen)
  5878.     include_dir_maxlen = i;
  5879. }
  5881. /* Output debugging information to denote the source file.  */
  5882.  
  5883. static void
  5884. generate_file_debug (void)
  5885. {
  5886.   if (debug_type == DEBUG_STABS)
  5887.     stabs_generate_asm_file ();
  5888. }
  5889.  
  5890. /* Output line number debugging information for the current source line.  */
  5891.  
  5892. void
  5893. generate_lineno_debug (void)
  5894. {
  5895.   switch (debug_type)
  5896.     {
  5897.     case DEBUG_UNSPECIFIED:
  5898.     case DEBUG_NONE:
  5899.     case DEBUG_DWARF:
  5900.       break;
  5901.     case DEBUG_STABS:
  5902.       stabs_generate_asm_lineno ();
  5903.       break;
  5904.     case DEBUG_ECOFF:
  5905.       ecoff_generate_asm_lineno ();
  5906.       break;
  5907.     case DEBUG_DWARF2:
  5908.       /* ??? We could here indicate to dwarf2dbg.c that something
  5909.          has changed.  However, since there is additional backend
  5910.          support that is required (calling dwarf2_emit_insn), we
  5911.          let dwarf2dbg.c call as_where on its own.  */
  5912.       break;
  5913.     }
  5914. }
  5915.  
  5916. /* Output debugging information to mark a function entry point or end point.
  5917.    END_P is zero for .func, and non-zero for .endfunc.  */
  5918.  
  5919. void
  5920. s_func (int end_p)
  5921. {
  5922.   do_s_func (end_p, NULL);
  5923. }
  5924.  
  5925. /* Subroutine of s_func so targets can choose a different default prefix.
  5926.    If DEFAULT_PREFIX is NULL, use the target's "leading char".  */
  5927.  
  5928. static void
  5929. do_s_func (int end_p, const char *default_prefix)
  5930. {
  5931.   /* Record the current function so that we can issue an error message for
  5932.      misplaced .func,.endfunc, and also so that .endfunc needs no
  5933.      arguments.  */
  5934.   static char *current_name;
  5935.   static char *current_label;
  5936.  
  5937.   if (end_p)
  5938.     {
  5939.       if (current_name == NULL)
  5940.         {
  5941.           as_bad (_("missing .func"));
  5942.           ignore_rest_of_line ();
  5943.           return;
  5944.         }
  5945.  
  5946.       if (debug_type == DEBUG_STABS)
  5947.         stabs_generate_asm_endfunc (current_name, current_label);
  5948.  
  5949.       current_name = current_label = NULL;
  5950.     }
  5951.   else /* ! end_p */
  5952.     {
  5953.       char *name, *label;
  5954.       char delim1, delim2;
  5955.  
  5956.       if (current_name != NULL)
  5957.         {
  5958.           as_bad (_(".endfunc missing for previous .func"));
  5959.           ignore_rest_of_line ();
  5960.           return;
  5961.         }
  5962.  
  5963.       delim1 = get_symbol_name (& name);
  5964.       name = xstrdup (name);
  5965.       *input_line_pointer = delim1;
  5966.       SKIP_WHITESPACE_AFTER_NAME ();
  5967.       if (*input_line_pointer != ',')
  5968.         {
  5969.           if (default_prefix)
  5970.             {
  5971.               if (asprintf (&label, "%s%s", default_prefix, name) == -1)
  5972.                 as_fatal ("%s", xstrerror (errno));
  5973.             }
  5974.           else
  5975.             {
  5976.               char leading_char = bfd_get_symbol_leading_char (stdoutput);
  5977.               /* Missing entry point, use function's name with the leading
  5978.                  char prepended.  */
  5979.               if (leading_char)
  5980.                 {
  5981.                   if (asprintf (&label, "%c%s", leading_char, name) == -1)
  5982.                     as_fatal ("%s", xstrerror (errno));
  5983.                 }
  5984.               else
  5985.                 label = name;
  5986.             }
  5987.         }
  5988.       else
  5989.         {
  5990.           ++input_line_pointer;
  5991.           SKIP_WHITESPACE ();
  5992.           delim2 = get_symbol_name (& label);
  5993.           label = xstrdup (label);
  5994.           restore_line_pointer (delim2);
  5995.         }
  5996.  
  5997.       if (debug_type == DEBUG_STABS)
  5998.         stabs_generate_asm_func (name, label);
  5999.  
  6000.       current_name = name;
  6001.       current_label = label;
  6002.     }
  6003.  
  6004.   demand_empty_rest_of_line ();
  6005. }
  6007. #ifdef HANDLE_BUNDLE
  6008.  
  6009. void
  6010. s_bundle_align_mode (int arg ATTRIBUTE_UNUSED)
  6011. {
  6012.   unsigned int align = get_absolute_expression ();
  6013.   SKIP_WHITESPACE ();
  6014.   demand_empty_rest_of_line ();
  6015.  
  6016.   if (align > (unsigned int) TC_ALIGN_LIMIT)
  6017.     as_fatal (_(".bundle_align_mode alignment too large (maximum %u)"),
  6018.               (unsigned int) TC_ALIGN_LIMIT);
  6019.  
  6020.   if (bundle_lock_frag != NULL)
  6021.     {
  6022.       as_bad (_("cannot change .bundle_align_mode inside .bundle_lock"));
  6023.       return;
  6024.     }
  6025.  
  6026.   bundle_align_p2 = align;
  6027. }
  6028.  
  6029. void
  6030. s_bundle_lock (int arg ATTRIBUTE_UNUSED)
  6031. {
  6032.   demand_empty_rest_of_line ();
  6033.  
  6034.   if (bundle_align_p2 == 0)
  6035.     {
  6036.       as_bad (_(".bundle_lock is meaningless without .bundle_align_mode"));
  6037.       return;
  6038.     }
  6039.  
  6040.   if (bundle_lock_depth == 0)
  6041.     {
  6042.       bundle_lock_frchain = frchain_now;
  6043.       bundle_lock_frag = start_bundle ();
  6044.     }
  6045.   ++bundle_lock_depth;
  6046. }
  6047.  
  6048. void
  6049. s_bundle_unlock (int arg ATTRIBUTE_UNUSED)
  6050. {
  6051.   unsigned int size;
  6052.  
  6053.   demand_empty_rest_of_line ();
  6054.  
  6055.   if (bundle_lock_frag == NULL)
  6056.     {
  6057.       as_bad (_(".bundle_unlock without preceding .bundle_lock"));
  6058.       return;
  6059.     }
  6060.  
  6061.   gas_assert (bundle_align_p2 > 0);
  6062.  
  6063.   gas_assert (bundle_lock_depth > 0);
  6064.   if (--bundle_lock_depth > 0)
  6065.     return;
  6066.  
  6067.   size = pending_bundle_size (bundle_lock_frag);
  6068.  
  6069.   if (size > (1U << bundle_align_p2))
  6070.     as_bad (_(".bundle_lock sequence is %u bytes, but bundle size only %u"),
  6071.             size, 1 << bundle_align_p2);
  6072.   else
  6073.     finish_bundle (bundle_lock_frag, size);
  6074.  
  6075.   bundle_lock_frag = NULL;
  6076.   bundle_lock_frchain = NULL;
  6077. }
  6078.  
  6079. #endif  /* HANDLE_BUNDLE */
  6081. void
  6082. s_ignore (int arg ATTRIBUTE_UNUSED)
  6083. {
  6084.   ignore_rest_of_line ();
  6085. }
  6086.  
  6087. void
  6088. read_print_statistics (FILE *file)
  6089. {
  6090.   hash_print_statistics (file, "pseudo-op table", po_hash);
  6091. }
  6092.  
  6093. /* Inserts the given line into the input stream.
  6094.  
  6095.    This call avoids macro/conditionals nesting checking, since the contents of
  6096.    the line are assumed to replace the contents of a line already scanned.
  6097.  
  6098.    An appropriate use of this function would be substitution of input lines when
  6099.    called by md_start_line_hook().  The given line is assumed to already be
  6100.    properly scrubbed.  */
  6101.  
  6102. void
  6103. input_scrub_insert_line (const char *line)
  6104. {
  6105.   sb newline;
  6106.   size_t len = strlen (line);
  6107.   sb_build (&newline, len);
  6108.   sb_add_buffer (&newline, line, len);
  6109.   input_scrub_include_sb (&newline, input_line_pointer, 0);
  6110.   sb_kill (&newline);
  6111.   buffer_limit = input_scrub_next_buffer (&input_line_pointer);
  6112. }
  6113.  
  6114. /* Insert a file into the input stream; the path must resolve to an actual
  6115.    file; no include path searching or dependency registering is performed.  */
  6116.  
  6117. void
  6118. input_scrub_insert_file (char *path)
  6119. {
  6120.   input_scrub_include_file (path, input_line_pointer);
  6121.   buffer_limit = input_scrub_next_buffer (&input_line_pointer);
  6122. }
  6123.  
  6124. /* Find the end of a line, considering quotation and escaping of quotes.  */
  6125.  
  6126. #if !defined(TC_SINGLE_QUOTE_STRINGS) && defined(SINGLE_QUOTE_STRINGS)
  6127. # define TC_SINGLE_QUOTE_STRINGS 1
  6128. #endif
  6129.  
  6130. static char *
  6131. _find_end_of_line (char *s, int mri_string, int insn ATTRIBUTE_UNUSED,
  6132.                    int in_macro)
  6133. {
  6134.   char inquote = '\0';
  6135.   int inescape = 0;
  6136.  
  6137.   while (!is_end_of_line[(unsigned char) *s]
  6138.          || (inquote && !ISCNTRL (*s))
  6139.          || (inquote == '\'' && flag_mri)
  6140. #ifdef TC_EOL_IN_INSN
  6141.          || (insn && TC_EOL_IN_INSN (s))
  6142. #endif
  6143.          /* PR 6926:  When we are parsing the body of a macro the sequence
  6144.             \@ is special - it refers to the invocation count.  If the @
  6145.             character happens to be registered as a line-separator character
  6146.             by the target, then the is_end_of_line[] test above will have
  6147.             returned true, but we need to ignore the line separating
  6148.             semantics in this particular case.  */
  6149.          || (in_macro && inescape && *s == '@')
  6150.         )
  6151.     {
  6152.       if (mri_string && *s == '\'')
  6153.         inquote ^= *s;
  6154.       else if (inescape)
  6155.         inescape = 0;
  6156.       else if (*s == '\\')
  6157.         inescape = 1;
  6158.       else if (!inquote
  6159.                ? *s == '"'
  6160. #ifdef TC_SINGLE_QUOTE_STRINGS
  6161.                  || (TC_SINGLE_QUOTE_STRINGS && *s == '\'')
  6162. #endif
  6163.                : *s == inquote)
  6164.         inquote ^= *s;
  6165.       ++s;
  6166.     }
  6167.   if (inquote)
  6168.     as_warn (_("missing closing `%c'"), inquote);
  6169.   if (inescape && !ignore_input ())
  6170.     as_warn (_("stray `\\'"));
  6171.   return s;
  6172. }
  6173.  
  6174. char *
  6175. find_end_of_line (char *s, int mri_string)
  6176. {
  6177.   return _find_end_of_line (s, mri_string, 0, 0);
  6178. }
  6179.