Coverage Report

Created: 2024-05-21 06:29

/src/binutils-gdb/gas/fuzz_as.h
Line
Count
Source (jump to first uncovered line)
1
/* as.c - GAS main program.
2
   Copyright (C) 1987-2024 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, but WITHOUT
12
   ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
13
   or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
14
   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
/* Main program for AS; a 32-bit assembler of GNU.
22
   Understands command arguments.
23
   Has a few routines that don't fit in other modules because they
24
   are shared.
25
26
        bugs
27
28
   : initialisers
29
    Since no-one else says they will support them in future: I
30
   don't support them now.  */
31
32
#define COMMON
33
34
/* Disable code to set FAKE_LABEL_NAME in obj-multi.h, to avoid circular
35
   reference.  */
36
#define INITIALIZING_EMULS
37
38
#include "as.h"
39
#include "subsegs.h"
40
#include "output-file.h"
41
#include "sb.h"
42
#include "macro.h"
43
#include "dwarf2dbg.h"
44
#include "dw2gencfi.h"
45
#include "codeview.h"
46
#include "bfdver.h"
47
#include "write.h"
48
#include "ginsn.h"
49
50
#ifdef HAVE_ITBL_CPU
51
#include "itbl-ops.h"
52
#else
53
#define itbl_init()
54
#endif
55
56
#ifdef USING_CGEN
57
/* Perform any cgen specific initialisation for gas.  */
58
extern void gas_cgen_begin (void);
59
#endif
60
61
/* We build a list of defsyms as we read the options, and then define
62
   them after we have initialized everything.  */
63
struct defsym_list
64
{
65
  struct defsym_list *next;
66
  char *name;
67
  valueT value;
68
};
69
70
71
/* True if a listing is wanted.  */
72
int listing;
73
74
/* Type of debugging to generate.  */
75
enum debug_info_type debug_type = DEBUG_UNSPECIFIED;
76
int use_gnu_debug_info_extensions = 0;
77
78
#ifndef MD_DEBUG_FORMAT_SELECTOR
79
#define MD_DEBUG_FORMAT_SELECTOR NULL
80
#endif
81
static enum debug_info_type (*md_debug_format_selector) (int *) = MD_DEBUG_FORMAT_SELECTOR;
82
83
/* Maximum level of macro nesting.  */
84
int max_macro_nest = 100;
85
86
/* argv[0]  */
87
static char * myname;
88
89
/* The default obstack chunk size.  If we set this to zero, the
90
   obstack code will use whatever will fit in a 4096 byte block.  */
91
int chunksize = 0;
92
93
/* To monitor memory allocation more effectively, make this non-zero.
94
   Then the chunk sizes for gas and bfd will be reduced.  */
95
int debug_memory = 0;
96
97
/* Enable verbose mode.  */
98
int verbose = 0;
99
100
/* Which version of DWARF CIE to produce.  This default value of -1
101
   indicates that this value has not been set yet, a default value is
102
   provided in dwarf2_init.  A different value can also be supplied by the
103
   command line flag --gdwarf-cie-version, or by a target in
104
   MD_AFTER_PARSE_ARGS.  */
105
int flag_dwarf_cie_version = -1;
106
107
/* The maximum level of DWARF DEBUG information we should manufacture.
108
   This defaults to 3 unless overridden by a command line option.  */
109
unsigned int dwarf_level = 3;
110
111
#if defined OBJ_ELF || defined OBJ_MAYBE_ELF
112
int flag_use_elf_stt_common = DEFAULT_GENERATE_ELF_STT_COMMON;
113
bool flag_generate_build_notes = DEFAULT_GENERATE_BUILD_NOTES;
114
#endif
115
116
segT reg_section;
117
segT expr_section;
118
segT text_section;
119
segT data_section;
120
segT bss_section;
121
122
/* Name of listing file.  */
123
static char *listing_filename = NULL;
124
125
static struct defsym_list *defsyms;
126
127
static long start_time;
128
129

130
#ifdef USE_EMULATIONS
131
#define EMULATION_ENVIRON "AS_EMULATION"
132
133
extern struct emulation mipsbelf, mipslelf, mipself;
134
extern struct emulation i386coff, i386elf, i386aout;
135
extern struct emulation crisaout, criself;
136
137
static struct emulation *const emulations[] = { EMULATIONS };
138
static const int n_emulations = sizeof (emulations) / sizeof (emulations[0]);
139
140
static void
141
select_emulation_mode (int argc, char **argv)
142
{
143
  int i;
144
  char *p;
145
  const char *em = NULL;
146
147
  for (i = 1; i < argc; i++)
148
    if (startswith (argv[i], "--em"))
149
      break;
150
151
  if (i == argc)
152
    goto do_default;
153
154
  p = strchr (argv[i], '=');
155
  if (p)
156
    p++;
157
  else
158
    p = argv[i + 1];
159
160
  if (!p || !*p)
161
    as_fatal (_("missing emulation mode name"));
162
  em = p;
163
164
 do_default:
165
  if (em == 0)
166
    em = getenv (EMULATION_ENVIRON);
167
  if (em == 0)
168
    em = DEFAULT_EMULATION;
169
170
  if (em)
171
    {
172
      for (i = 0; i < n_emulations; i++)
173
  if (!strcmp (emulations[i]->name, em))
174
    break;
175
      if (i == n_emulations)
176
  as_fatal (_("unrecognized emulation name `%s'"), em);
177
      this_emulation = emulations[i];
178
    }
179
  else
180
    this_emulation = emulations[0];
181
182
  this_emulation->init ();
183
}
184
185
const char *
186
default_emul_bfd_name (void)
187
{
188
  abort ();
189
  return NULL;
190
}
191
192
void
193
common_emul_init (void)
194
{
195
  this_format = this_emulation->format;
196
197
  if (this_emulation->leading_underscore == 2)
198
    this_emulation->leading_underscore = this_format->dfl_leading_underscore;
199
200
  if (this_emulation->default_endian != 2)
201
    target_big_endian = this_emulation->default_endian;
202
203
  if (this_emulation->fake_label_name == 0)
204
    {
205
      if (this_emulation->leading_underscore)
206
  this_emulation->fake_label_name = FAKE_LABEL_NAME;
207
      else
208
  /* What other parameters should we test?  */
209
  this_emulation->fake_label_name = "." FAKE_LABEL_NAME;
210
    }
211
}
212
#endif
213
214
void
215
print_version_id (void)
216
0
{
217
0
  static int printed;
218
219
0
  if (printed)
220
0
    return;
221
0
  printed = 1;
222
223
0
  fprintf (stderr, _("GNU assembler version %s (%s) using BFD version %s\n"),
224
0
     VERSION, TARGET_ALIAS, BFD_VERSION_STRING);
225
0
}
226
227
#ifdef DEFAULT_FLAG_COMPRESS_DEBUG
228
enum compressed_debug_section_type flag_compress_debug
229
  = DEFAULT_COMPRESSED_DEBUG_ALGORITHM;
230
#define DEFAULT_COMPRESSED_DEBUG_ALGORITHM_HELP \
231
0
        DEFAULT_COMPRESSED_DEBUG_ALGORITHM
232
#else
233
#define DEFAULT_COMPRESSED_DEBUG_ALGORITHM_HELP COMPRESS_DEBUG_NONE
234
#endif
235
236
static void
237
show_usage (FILE * stream)
238
0
{
239
0
  fprintf (stream, _("Usage: %s [option...] [asmfile...]\n"), myname);
240
241
0
  fprintf (stream, _("\
242
0
Options:\n\
243
0
  -a[sub-option...]   turn on listings\n\
244
0
                          Sub-options [default hls]:\n\
245
0
                          c      omit false conditionals\n\
246
0
                          d      omit debugging directives\n\
247
0
                          g      include general info\n\
248
0
                          h      include high-level source\n\
249
0
                          i      include ginsn and synthesized CFI info\n\
250
0
                          l      include assembly\n\
251
0
                          m      include macro expansions\n\
252
0
                          n      omit forms processing\n\
253
0
                          s      include symbols\n\
254
0
                          =FILE  list to FILE (must be last sub-option)\n"));
255
256
0
  fprintf (stream, _("\
257
0
  --alternate             initially turn on alternate macro syntax\n"));
258
0
  fprintf (stream, _("\
259
0
  --compress-debug-sections[={none|zlib|zlib-gnu|zlib-gabi|zstd}]\n\
260
0
                          compress DWARF debug sections\n")),
261
0
  fprintf (stream, _("\
262
0
                Default: %s\n"),
263
0
     bfd_get_compression_algorithm_name
264
0
             (DEFAULT_COMPRESSED_DEBUG_ALGORITHM_HELP));
265
266
0
  fprintf (stream, _("\
267
0
  --nocompress-debug-sections\n\
268
0
                          don't compress DWARF debug sections\n"));
269
0
  fprintf (stream, _("\
270
0
  -D                      produce assembler debugging messages\n"));
271
0
  fprintf (stream, _("\
272
0
  --dump-config           display how the assembler is configured and then exit\n"));
273
0
  fprintf (stream, _("\
274
0
  --debug-prefix-map OLD=NEW\n\
275
0
                          map OLD to NEW in debug information\n"));
276
0
  fprintf (stream, _("\
277
0
  --defsym SYM=VAL        define symbol SYM to given value\n"));
278
#ifdef USE_EMULATIONS
279
  {
280
    int i;
281
    const char *def_em;
282
283
    fprintf (stream, "\
284
  --emulation=[");
285
    for (i = 0; i < n_emulations - 1; i++)
286
      fprintf (stream, "%s | ", emulations[i]->name);
287
    fprintf (stream, "%s]\n", emulations[i]->name);
288
289
    def_em = getenv (EMULATION_ENVIRON);
290
    if (!def_em)
291
      def_em = DEFAULT_EMULATION;
292
    fprintf (stream, _("\
293
                          emulate output (default %s)\n"), def_em);
294
  }
295
#endif
296
0
#if defined OBJ_ELF || defined OBJ_MAYBE_ELF
297
0
  fprintf (stream, _("\
298
0
  --execstack             require executable stack for this object\n"));
299
0
  fprintf (stream, _("\
300
0
  --noexecstack           don't require executable stack for this object\n"));
301
0
  fprintf (stream, _("\
302
0
  --size-check=[error|warning]\n\
303
0
        ELF .size directive check (default --size-check=error)\n"));
304
0
  fprintf (stream, _("\
305
0
  --elf-stt-common=[no|yes] "));
306
0
  if (DEFAULT_GENERATE_ELF_STT_COMMON)
307
0
    fprintf (stream, _("(default: yes)\n"));
308
0
  else
309
0
    fprintf (stream, _("(default: no)\n"));
310
0
  fprintf (stream, _("\
311
0
                          generate ELF common symbols with STT_COMMON type\n"));
312
0
  fprintf (stream, _("\
313
0
  --sectname-subst        enable section name substitution sequences\n"));
314
315
0
  fprintf (stream, _("\
316
0
  --generate-missing-build-notes=[no|yes] "));
317
#if DEFAULT_GENERATE_BUILD_NOTES
318
  fprintf (stream, _("(default: yes)\n"));
319
#else
320
0
  fprintf (stream, _("(default: no)\n"));
321
0
#endif
322
0
  fprintf (stream, _("\
323
0
                          generate GNU Build notes if none are present in the input\n"));
324
0
  fprintf (stream, _("\
325
0
  --gsframe               generate SFrame stack trace information\n"));
326
0
# if defined (TARGET_USE_SCFI) && defined (TARGET_USE_GINSN)
327
0
  fprintf (stream, _("\
328
0
  --scfi=experimental     Synthesize DWARF CFI for hand-written asm\n\
329
0
                          (experimental support)\n"));
330
0
# endif
331
0
#endif /* OBJ_ELF */
332
333
0
  fprintf (stream, _("\
334
0
  -f                      skip whitespace and comment preprocessing\n"));
335
0
  fprintf (stream, _("\
336
0
  -g --gen-debug          generate debugging information\n"));
337
0
  fprintf (stream, _("\
338
0
  --gstabs                generate STABS debugging information\n"));
339
0
  fprintf (stream, _("\
340
0
  --gstabs+               generate STABS debug info with GNU extensions\n"));
341
0
  fprintf (stream, _("\
342
0
  --gdwarf-<N>            generate DWARF<N> debugging information. 2 <= <N> <= 5\n"));
343
0
  fprintf (stream, _("\
344
0
  --gdwarf-cie-version=<N> generate version 1, 3 or 4 DWARF CIEs\n"));
345
0
  fprintf (stream, _("\
346
0
  --gdwarf-sections       generate per-function section names for DWARF line information\n"));
347
#if defined (TE_PE) && defined (O_secrel)
348
  fprintf (stream, _("\
349
  --gcodeview             generate CodeView debugging information\n"));
350
#endif
351
0
  fprintf (stream, _("\
352
0
  --hash-size=<N>         ignored\n"));
353
0
  fprintf (stream, _("\
354
0
  --help                  show all assembler options\n"));
355
0
  fprintf (stream, _("\
356
0
  --target-help           show target specific options\n"));
357
0
  fprintf (stream, _("\
358
0
  -I DIR                  add DIR to search list for .include directives\n"));
359
0
  fprintf (stream, _("\
360
0
  -J                      don't warn about signed overflow\n"));
361
0
  fprintf (stream, _("\
362
0
  -K                      warn when differences altered for long displacements\n"));
363
0
  fprintf (stream, _("\
364
0
  -L,--keep-locals        keep local symbols (e.g. starting with `L')\n"));
365
0
  fprintf (stream, _("\
366
0
  -M,--mri                assemble in MRI compatibility mode\n"));
367
0
  fprintf (stream, _("\
368
0
  --MD FILE               write dependency information in FILE (default none)\n"));
369
0
  fprintf (stream, _("\
370
0
  --multibyte-handling=<method>\n\
371
0
                          what to do with multibyte characters encountered in the input\n"));
372
0
  fprintf (stream, _("\
373
0
  -nocpp                  ignored\n"));
374
0
  fprintf (stream, _("\
375
0
  -no-pad-sections        do not pad the end of sections to alignment boundaries\n"));
376
0
  fprintf (stream, _("\
377
0
  -o OBJFILE              name the object-file output OBJFILE (default a.out)\n"));
378
0
  fprintf (stream, _("\
379
0
  -R                      fold data section into text section\n"));
380
0
  fprintf (stream, _("\
381
0
  --reduce-memory-overheads ignored\n"));
382
0
  fprintf (stream, _("\
383
0
  --statistics            print various measured statistics from execution\n"));
384
0
  fprintf (stream, _("\
385
0
  --strip-local-absolute  strip local absolute symbols\n"));
386
0
  fprintf (stream, _("\
387
0
  --traditional-format    Use same format as native assembler when possible\n"));
388
0
  fprintf (stream, _("\
389
0
  --version               print assembler version number and exit\n"));
390
0
  fprintf (stream, _("\
391
0
  -W  --no-warn           suppress warnings\n"));
392
0
  fprintf (stream, _("\
393
0
  --warn                  don't suppress warnings\n"));
394
0
  fprintf (stream, _("\
395
0
  --fatal-warnings        treat warnings as errors\n"));
396
#ifdef HAVE_ITBL_CPU
397
  fprintf (stream, _("\
398
  --itbl INSTTBL          extend instruction set to include instructions\n\
399
                          matching the specifications defined in file INSTTBL\n"));
400
#endif
401
0
  fprintf (stream, _("\
402
0
  -w                      ignored\n"));
403
0
  fprintf (stream, _("\
404
0
  -X                      ignored\n"));
405
0
  fprintf (stream, _("\
406
0
  -Z                      generate object file even after errors\n"));
407
0
  fprintf (stream, _("\
408
0
  --listing-lhs-width     set the width in words of the output data column of\n\
409
0
                          the listing\n"));
410
0
  fprintf (stream, _("\
411
0
  --listing-lhs-width2    set the width in words of the continuation lines\n\
412
0
                          of the output data column; ignored if smaller than\n\
413
0
                          the width of the first line\n"));
414
0
  fprintf (stream, _("\
415
0
  --listing-rhs-width     set the max width in characters of the lines from\n\
416
0
                          the source file\n"));
417
0
  fprintf (stream, _("\
418
0
  --listing-cont-lines    set the maximum number of continuation lines used\n\
419
0
                          for the output data column of the listing\n"));
420
0
  fprintf (stream, _("\
421
0
  @FILE                   read options from FILE\n"));
422
423
0
  md_show_usage (stream);
424
425
0
  fputc ('\n', stream);
426
427
0
  if (REPORT_BUGS_TO[0] && stream == stdout)
428
0
    fprintf (stream, _("Report bugs to %s\n"), REPORT_BUGS_TO);
429
0
}
430
431
/* Since it is easy to do here we interpret the special arg "-"
432
   to mean "use stdin" and we set that argv[] pointing to "".
433
   After we have munged argv[], the only things left are source file
434
   name(s) and ""(s) denoting stdin. These file names are used
435
   (perhaps more than once) later.
436
437
   check for new machine-dep cmdline options in
438
   md_parse_option definitions in config/tc-*.c.  */
439
440
static void
441
parse_args (int * pargc, char *** pargv)
442
0
{
443
0
  int old_argc;
444
0
  int new_argc;
445
0
  char ** old_argv;
446
0
  char ** new_argv;
447
  /* Starting the short option string with '-' is for programs that
448
     expect options and other ARGV-elements in any order and that care about
449
     the ordering of the two.  We describe each non-option ARGV-element
450
     as if it were the argument of an option with character code 1.  */
451
0
  char *shortopts;
452
0
  extern const char *md_shortopts;
453
0
  static const char std_shortopts[] =
454
0
  {
455
0
    '-', 'J',
456
#ifndef WORKING_DOT_WORD
457
    /* -K is not meaningful if .word is not being hacked.  */
458
    'K',
459
#endif
460
0
    'L', 'M', 'R', 'W', 'Z', 'a', ':', ':', 'D', 'f', 'g', ':',':', 'I', ':', 'o', ':',
461
0
#ifndef VMS
462
    /* -v takes an argument on VMS, so we don't make it a generic
463
       option.  */
464
0
    'v',
465
0
#endif
466
0
    'w', 'X',
467
#ifdef HAVE_ITBL_CPU
468
    /* New option for extending instruction set (see also --itbl below).  */
469
    't', ':',
470
#endif
471
0
    '\0'
472
0
  };
473
0
  struct option *longopts;
474
0
  extern struct option md_longopts[];
475
0
  extern size_t md_longopts_size;
476
  /* Codes used for the long options with no short synonyms.  */
477
0
  enum option_values
478
0
    {
479
0
      OPTION_HELP = OPTION_STD_BASE,
480
0
      OPTION_NOCPP,
481
0
      OPTION_STATISTICS,
482
0
      OPTION_VERSION,
483
0
      OPTION_DUMPCONFIG,
484
0
      OPTION_VERBOSE,
485
0
      OPTION_EMULATION,
486
0
      OPTION_DEBUG_PREFIX_MAP,
487
0
      OPTION_DEFSYM,
488
0
      OPTION_LISTING_LHS_WIDTH,
489
0
      OPTION_LISTING_LHS_WIDTH2, /* = STD_BASE + 10 */
490
0
      OPTION_LISTING_RHS_WIDTH,
491
0
      OPTION_LISTING_CONT_LINES,
492
0
      OPTION_DEPFILE,
493
0
      OPTION_GSTABS,
494
0
      OPTION_GSTABS_PLUS,
495
0
      OPTION_GDWARF_2,
496
0
      OPTION_GDWARF_3,
497
0
      OPTION_GDWARF_4,
498
0
      OPTION_GDWARF_5,
499
0
      OPTION_GDWARF_SECTIONS, /* = STD_BASE + 20 */
500
0
      OPTION_GDWARF_CIE_VERSION,
501
0
      OPTION_GCODEVIEW,
502
0
      OPTION_STRIP_LOCAL_ABSOLUTE,
503
0
      OPTION_TRADITIONAL_FORMAT,
504
0
      OPTION_WARN,
505
0
      OPTION_TARGET_HELP,
506
0
      OPTION_EXECSTACK,
507
0
      OPTION_NOEXECSTACK,
508
0
      OPTION_SIZE_CHECK,
509
0
      OPTION_ELF_STT_COMMON,
510
0
      OPTION_ELF_BUILD_NOTES, /* = STD_BASE + 30 */
511
0
      OPTION_SECTNAME_SUBST,
512
0
      OPTION_ALTERNATE,
513
0
      OPTION_AL,
514
0
      OPTION_HASH_TABLE_SIZE,
515
0
      OPTION_REDUCE_MEMORY_OVERHEADS,
516
0
      OPTION_WARN_FATAL,
517
0
      OPTION_COMPRESS_DEBUG,
518
0
      OPTION_NOCOMPRESS_DEBUG,
519
0
      OPTION_NO_PAD_SECTIONS,
520
0
      OPTION_MULTIBYTE_HANDLING,  /* = STD_BASE + 40 */
521
0
      OPTION_SFRAME,
522
0
      OPTION_SCFI
523
    /* When you add options here, check that they do
524
       not collide with OPTION_MD_BASE.  See as.h.  */
525
0
    };
526
527
0
  static const struct option std_longopts[] =
528
0
  {
529
    /* Note: commas are placed at the start of the line rather than
530
       the end of the preceding line so that it is simpler to
531
       selectively add and remove lines from this list.  */
532
0
    {"alternate", no_argument, NULL, OPTION_ALTERNATE}
533
    /* The entry for "a" is here to prevent getopt_long_only() from
534
       considering that -a is an abbreviation for --alternate.  This is
535
       necessary because -a=<FILE> is a valid switch but getopt would
536
       normally reject it since --alternate does not take an argument.  */
537
0
    ,{"a", optional_argument, NULL, 'a'}
538
    /* Handle -al=<FILE>.  */
539
0
    ,{"al", optional_argument, NULL, OPTION_AL}
540
0
    ,{"compress-debug-sections", optional_argument, NULL, OPTION_COMPRESS_DEBUG}
541
0
    ,{"nocompress-debug-sections", no_argument, NULL, OPTION_NOCOMPRESS_DEBUG}
542
0
    ,{"debug-prefix-map", required_argument, NULL, OPTION_DEBUG_PREFIX_MAP}
543
0
    ,{"defsym", required_argument, NULL, OPTION_DEFSYM}
544
0
    ,{"dump-config", no_argument, NULL, OPTION_DUMPCONFIG}
545
0
    ,{"emulation", required_argument, NULL, OPTION_EMULATION}
546
0
#if defined OBJ_ELF || defined OBJ_MAYBE_ELF
547
0
    ,{"execstack", no_argument, NULL, OPTION_EXECSTACK}
548
0
    ,{"noexecstack", no_argument, NULL, OPTION_NOEXECSTACK}
549
0
    ,{"size-check", required_argument, NULL, OPTION_SIZE_CHECK}
550
0
    ,{"elf-stt-common", required_argument, NULL, OPTION_ELF_STT_COMMON}
551
0
    ,{"sectname-subst", no_argument, NULL, OPTION_SECTNAME_SUBST}
552
0
    ,{"generate-missing-build-notes", required_argument, NULL, OPTION_ELF_BUILD_NOTES}
553
0
    ,{"gsframe", no_argument, NULL, OPTION_SFRAME}
554
0
# if defined (TARGET_USE_SCFI) && defined (TARGET_USE_GINSN)
555
0
    ,{"scfi", required_argument, NULL, OPTION_SCFI}
556
0
# endif
557
0
#endif /* OBJ_ELF || OBJ_MAYBE_ELF.  */
558
0
    ,{"fatal-warnings", no_argument, NULL, OPTION_WARN_FATAL}
559
0
    ,{"gdwarf-2", no_argument, NULL, OPTION_GDWARF_2}
560
0
    ,{"gdwarf-3", no_argument, NULL, OPTION_GDWARF_3}
561
0
    ,{"gdwarf-4", no_argument, NULL, OPTION_GDWARF_4}
562
0
    ,{"gdwarf-5", no_argument, NULL, OPTION_GDWARF_5}
563
    /* GCC uses --gdwarf-2 but GAS used to to use --gdwarf2,
564
       so we keep it here for backwards compatibility.  */
565
0
    ,{"gdwarf2", no_argument, NULL, OPTION_GDWARF_2}
566
0
    ,{"gdwarf-sections", no_argument, NULL, OPTION_GDWARF_SECTIONS}
567
0
    ,{"gdwarf-cie-version", required_argument, NULL, OPTION_GDWARF_CIE_VERSION}
568
#if defined (TE_PE) && defined (O_secrel)
569
    ,{"gcodeview", no_argument, NULL, OPTION_GCODEVIEW}
570
#endif
571
0
    ,{"gen-debug", no_argument, NULL, 'g'}
572
0
    ,{"gstabs", no_argument, NULL, OPTION_GSTABS}
573
0
    ,{"gstabs+", no_argument, NULL, OPTION_GSTABS_PLUS}
574
0
    ,{"hash-size", required_argument, NULL, OPTION_HASH_TABLE_SIZE}
575
0
    ,{"help", no_argument, NULL, OPTION_HELP}
576
#ifdef HAVE_ITBL_CPU
577
    /* New option for extending instruction set (see also -t above).
578
       The "-t file" or "--itbl file" option extends the basic set of
579
       valid instructions by reading "file", a text file containing a
580
       list of instruction formats.  The additional opcodes and their
581
       formats are added to the built-in set of instructions, and
582
       mnemonics for new registers may also be defined.  */
583
    ,{"itbl", required_argument, NULL, 't'}
584
#endif
585
    /* getopt allows abbreviations, so we do this to stop it from
586
       treating -k as an abbreviation for --keep-locals.  Some
587
       ports use -k to enable PIC assembly.  */
588
0
    ,{"keep-locals", no_argument, NULL, 'L'}
589
0
    ,{"keep-locals", no_argument, NULL, 'L'}
590
0
    ,{"listing-lhs-width", required_argument, NULL, OPTION_LISTING_LHS_WIDTH}
591
0
    ,{"listing-lhs-width2", required_argument, NULL, OPTION_LISTING_LHS_WIDTH2}
592
0
    ,{"listing-rhs-width", required_argument, NULL, OPTION_LISTING_RHS_WIDTH}
593
0
    ,{"listing-cont-lines", required_argument, NULL, OPTION_LISTING_CONT_LINES}
594
0
    ,{"MD", required_argument, NULL, OPTION_DEPFILE}
595
0
    ,{"mri", no_argument, NULL, 'M'}
596
0
    ,{"nocpp", no_argument, NULL, OPTION_NOCPP}
597
0
    ,{"no-pad-sections", no_argument, NULL, OPTION_NO_PAD_SECTIONS}
598
0
    ,{"no-warn", no_argument, NULL, 'W'}
599
0
    ,{"reduce-memory-overheads", no_argument, NULL, OPTION_REDUCE_MEMORY_OVERHEADS}
600
0
    ,{"statistics", no_argument, NULL, OPTION_STATISTICS}
601
0
    ,{"strip-local-absolute", no_argument, NULL, OPTION_STRIP_LOCAL_ABSOLUTE}
602
0
    ,{"version", no_argument, NULL, OPTION_VERSION}
603
0
    ,{"verbose", no_argument, NULL, OPTION_VERBOSE}
604
0
    ,{"target-help", no_argument, NULL, OPTION_TARGET_HELP}
605
0
    ,{"traditional-format", no_argument, NULL, OPTION_TRADITIONAL_FORMAT}
606
0
    ,{"warn", no_argument, NULL, OPTION_WARN}
607
0
    ,{"multibyte-handling", required_argument, NULL, OPTION_MULTIBYTE_HANDLING}
608
0
  };
609
610
  /* Construct the option lists from the standard list and the target
611
     dependent list.  Include space for an extra NULL option and
612
     always NULL terminate.  */
613
0
  shortopts = concat (std_shortopts, md_shortopts, (char *) NULL);
614
0
  longopts = (struct option *) xmalloc (sizeof (std_longopts)
615
0
                                        + md_longopts_size + sizeof (struct option));
616
0
  memcpy (longopts, std_longopts, sizeof (std_longopts));
617
0
  memcpy (((char *) longopts) + sizeof (std_longopts), md_longopts, md_longopts_size);
618
0
  memset (((char *) longopts) + sizeof (std_longopts) + md_longopts_size,
619
0
    0, sizeof (struct option));
620
621
  /* Make a local copy of the old argv.  */
622
0
  old_argc = *pargc;
623
0
  old_argv = *pargv;
624
625
  /* Initialize a new argv that contains no options.  */
626
0
  new_argv = notes_alloc (sizeof (char *) * (old_argc + 1));
627
0
  new_argv[0] = old_argv[0];
628
0
  new_argc = 1;
629
0
  new_argv[new_argc] = NULL;
630
631
0
  while (1)
632
0
    {
633
      /* getopt_long_only is like getopt_long, but '-' as well as '--' can
634
   indicate a long option.  */
635
0
      int longind;
636
0
      int optc = getopt_long_only (old_argc, old_argv, shortopts, longopts,
637
0
           &longind);
638
639
0
      if (optc == -1)
640
0
  break;
641
642
0
      switch (optc)
643
0
  {
644
0
  default:
645
    /* md_parse_option should return 1 if it recognizes optc,
646
       0 if not.  */
647
0
    if (md_parse_option (optc, optarg) != 0)
648
0
      break;
649
    /* `-v' isn't included in the general short_opts list, so check for
650
       it explicitly here before deciding we've gotten a bad argument.  */
651
0
    if (optc == 'v')
652
0
      {
653
#ifdef VMS
654
        /* Telling getopt to treat -v's value as optional can result
655
     in it picking up a following filename argument here.  The
656
     VMS code in md_parse_option can return 0 in that case,
657
     but it has no way of pushing the filename argument back.  */
658
        if (optarg && *optarg)
659
    new_argv[new_argc++] = optarg, new_argv[new_argc] = NULL;
660
        else
661
#else
662
0
        case 'v':
663
0
#endif
664
0
        case OPTION_VERBOSE:
665
0
    print_version_id ();
666
0
    verbose = 1;
667
0
        break;
668
0
      }
669
0
    else
670
0
      as_bad (_("unrecognized option -%c%s"), optc, optarg ? optarg : "");
671
    /* Fall through.  */
672
673
0
  case '?':
674
0
    exit (EXIT_FAILURE);
675
676
0
  case 1:     /* File name.  */
677
0
    if (!strcmp (optarg, "-"))
678
0
      optarg = (char *) "";
679
0
    new_argv[new_argc++] = optarg;
680
0
    new_argv[new_argc] = NULL;
681
0
    break;
682
683
0
  case OPTION_TARGET_HELP:
684
0
    md_show_usage (stdout);
685
0
    exit (EXIT_SUCCESS);
686
687
0
  case OPTION_HELP:
688
0
    show_usage (stdout);
689
0
    exit (EXIT_SUCCESS);
690
691
0
  case OPTION_NOCPP:
692
0
    break;
693
694
0
  case OPTION_NO_PAD_SECTIONS:
695
0
    do_not_pad_sections_to_alignment = 1;
696
0
    break;
697
698
0
  case OPTION_STATISTICS:
699
0
    flag_print_statistics = 1;
700
0
    break;
701
702
0
  case OPTION_STRIP_LOCAL_ABSOLUTE:
703
0
    flag_strip_local_absolute = 1;
704
0
    break;
705
706
0
  case OPTION_TRADITIONAL_FORMAT:
707
0
    flag_traditional_format = 1;
708
0
    break;
709
710
0
  case OPTION_MULTIBYTE_HANDLING:
711
0
    if (strcmp (optarg, "allow") == 0)
712
0
      multibyte_handling = multibyte_allow;
713
0
    else if (strcmp (optarg, "warn") == 0)
714
0
      multibyte_handling = multibyte_warn;
715
0
    else if (strcmp (optarg, "warn-sym-only") == 0)
716
0
      multibyte_handling = multibyte_warn_syms;
717
0
    else if (strcmp (optarg, "warn_sym_only") == 0)
718
0
      multibyte_handling = multibyte_warn_syms;
719
0
    else
720
0
      as_fatal (_("unexpected argument to --multibyte-input-option: '%s'"), optarg);
721
0
    break;
722
723
0
  case OPTION_VERSION:
724
    /* This output is intended to follow the GNU standards document.  */
725
0
    printf (_("GNU assembler %s\n"), BFD_VERSION_STRING);
726
0
    printf (_("Copyright (C) 2024 Free Software Foundation, Inc.\n"));
727
0
    printf (_("\
728
0
This program is free software; you may redistribute it under the terms of\n\
729
0
the GNU General Public License version 3 or later.\n\
730
0
This program has absolutely no warranty.\n"));
731
#ifdef TARGET_WITH_CPU
732
    printf (_("This assembler was configured for a target of `%s' "
733
        "and default,\ncpu type `%s'.\n"),
734
      TARGET_ALIAS, TARGET_WITH_CPU);
735
#else
736
0
    printf (_("This assembler was configured for a target of `%s'.\n"),
737
0
      TARGET_ALIAS);
738
0
#endif
739
0
    exit (EXIT_SUCCESS);
740
741
0
  case OPTION_EMULATION:
742
#ifdef USE_EMULATIONS
743
    if (strcmp (optarg, this_emulation->name))
744
      as_fatal (_("multiple emulation names specified"));
745
#else
746
0
    as_fatal (_("emulations not handled in this configuration"));
747
0
#endif
748
0
    break;
749
750
0
  case OPTION_DUMPCONFIG:
751
0
    fprintf (stderr, _("alias = %s\n"), TARGET_ALIAS);
752
0
    fprintf (stderr, _("canonical = %s\n"), TARGET_CANONICAL);
753
0
    fprintf (stderr, _("cpu-type = %s\n"), TARGET_CPU);
754
#ifdef TARGET_OBJ_FORMAT
755
    fprintf (stderr, _("format = %s\n"), TARGET_OBJ_FORMAT);
756
#endif
757
0
#ifdef TARGET_FORMAT
758
0
    fprintf (stderr, _("bfd-target = %s\n"), TARGET_FORMAT);
759
0
#endif
760
0
    exit (EXIT_SUCCESS);
761
762
0
  case OPTION_COMPRESS_DEBUG:
763
0
    if (optarg)
764
0
      {
765
0
#if defined OBJ_ELF || defined OBJ_MAYBE_ELF
766
0
        flag_compress_debug = bfd_get_compression_algorithm (optarg);
767
0
#ifndef HAVE_ZSTD
768
0
        if (flag_compress_debug == COMPRESS_DEBUG_ZSTD)
769
0
      as_fatal (_ ("--compress-debug-sections=zstd: gas is not "
770
0
             "built with zstd support"));
771
0
#endif
772
0
        if (flag_compress_debug == COMPRESS_UNKNOWN)
773
0
    as_fatal (_("Invalid --compress-debug-sections option: `%s'"),
774
0
        optarg);
775
#else
776
        as_fatal (_("--compress-debug-sections=%s is unsupported"),
777
      optarg);
778
#endif
779
0
      }
780
0
    else
781
0
      flag_compress_debug = DEFAULT_COMPRESSED_DEBUG_ALGORITHM;
782
0
    break;
783
784
0
  case OPTION_NOCOMPRESS_DEBUG:
785
0
    flag_compress_debug = COMPRESS_DEBUG_NONE;
786
0
    break;
787
788
0
  case OPTION_DEBUG_PREFIX_MAP:
789
0
    add_debug_prefix_map (optarg);
790
0
    break;
791
792
0
  case OPTION_DEFSYM:
793
0
    {
794
0
      char *s;
795
0
      valueT i;
796
0
      struct defsym_list *n;
797
798
0
      for (s = optarg; *s != '\0' && *s != '='; s++)
799
0
        ;
800
0
      if (*s == '\0')
801
0
        as_fatal (_("bad defsym; format is --defsym name=value"));
802
0
      *s++ = '\0';
803
0
      i = bfd_scan_vma (s, (const char **) NULL, 0);
804
0
      n = XNEW (struct defsym_list);
805
0
      n->next = defsyms;
806
0
      n->name = optarg;
807
0
      n->value = i;
808
0
      defsyms = n;
809
0
    }
810
0
    break;
811
812
#ifdef HAVE_ITBL_CPU
813
  case 't':
814
    {
815
      /* optarg is the name of the file containing the instruction
816
         formats, opcodes, register names, etc.  */
817
      if (optarg == NULL)
818
        {
819
    as_warn (_("no file name following -t option"));
820
    break;
821
        }
822
823
      /* Parse the file and add the new instructions to our internal
824
         table.  If multiple instruction tables are specified, the
825
         information from this table gets appended onto the existing
826
         internal table.  */
827
      if (itbl_parse (optarg) != 0)
828
        as_fatal (_("failed to read instruction table %s\n"),
829
      optarg);
830
    }
831
    break;
832
#endif
833
834
0
  case OPTION_DEPFILE:
835
0
    start_dependencies (optarg);
836
0
    break;
837
838
0
  case 'g':
839
    /* Some backends, eg Alpha and Mips, use the -g switch for their
840
       own purposes.  So we check here for an explicit -g and allow
841
       the backend to decide if it wants to process it.  */
842
0
    if (   old_argv[optind - 1][1] == 'g'
843
0
        && md_parse_option (optc, optarg))
844
0
      continue;
845
846
    /* We end up here for any -gsomething-not-already-a-long-option.
847
       give some useful feedback on not (yet) supported -gdwarfxxx
848
       versions/sections/options.  */
849
0
    if (startswith (old_argv[optind - 1], "-gdwarf"))
850
0
      as_fatal (_("unknown DWARF option %s\n"), old_argv[optind - 1]);
851
0
    else if (old_argv[optind - 1][1] == 'g' && optarg != NULL)
852
0
      as_fatal (_("unknown option `%s'"), old_argv[optind - 1]);
853
854
0
    if (md_debug_format_selector)
855
0
      debug_type = md_debug_format_selector (& use_gnu_debug_info_extensions);
856
0
    else if (IS_ELF)
857
0
      {
858
0
        debug_type = DEBUG_DWARF2;
859
0
        dwarf_level = 2;
860
0
      }
861
0
    else
862
0
      debug_type = DEBUG_STABS;
863
0
    break;
864
865
0
  case OPTION_GSTABS_PLUS:
866
0
    use_gnu_debug_info_extensions = 1;
867
    /* Fall through.  */
868
0
  case OPTION_GSTABS:
869
0
    debug_type = DEBUG_STABS;
870
0
    break;
871
872
0
  case OPTION_GDWARF_2:
873
0
    debug_type = DEBUG_DWARF2;
874
0
    dwarf_level = 2;
875
0
    break;
876
877
0
  case OPTION_GDWARF_3:
878
0
    debug_type = DEBUG_DWARF2;
879
0
    dwarf_level = 3;
880
0
    break;
881
882
0
  case OPTION_GDWARF_4:
883
0
    debug_type = DEBUG_DWARF2;
884
0
    dwarf_level = 4;
885
0
    break;
886
887
0
  case OPTION_GDWARF_5:
888
0
    debug_type = DEBUG_DWARF2;
889
0
    dwarf_level = 5;
890
0
    break;
891
892
0
  case OPTION_GDWARF_SECTIONS:
893
0
    flag_dwarf_sections = true;
894
0
    break;
895
896
#if defined (TE_PE) && defined (O_secrel)
897
  case OPTION_GCODEVIEW:
898
    debug_type = DEBUG_CODEVIEW;
899
    break;
900
#endif
901
902
0
        case OPTION_GDWARF_CIE_VERSION:
903
0
    flag_dwarf_cie_version = atoi (optarg);
904
          /* The available CIE versions are 1 (DWARF 2), 3 (DWARF 3), and 4
905
             (DWARF 4 and 5).  */
906
0
    if (flag_dwarf_cie_version < 1
907
0
              || flag_dwarf_cie_version == 2
908
0
              || flag_dwarf_cie_version > 4)
909
0
            as_fatal (_("Invalid --gdwarf-cie-version `%s'"), optarg);
910
0
    switch (flag_dwarf_cie_version)
911
0
      {
912
0
      case 1:
913
0
        if (dwarf_level < 2)
914
0
    dwarf_level = 2;
915
0
        break;
916
0
      case 3:
917
0
        if (dwarf_level < 3)
918
0
    dwarf_level = 3;
919
0
        break;
920
0
      default:
921
0
        if (dwarf_level < 4)
922
0
    dwarf_level = 4;
923
0
        break;
924
0
      }
925
0
    break;
926
927
0
  case 'J':
928
0
    flag_signed_overflow_ok = 1;
929
0
    break;
930
931
#ifndef WORKING_DOT_WORD
932
  case 'K':
933
    flag_warn_displacement = 1;
934
    break;
935
#endif
936
0
  case 'L':
937
0
    flag_keep_locals = 1;
938
0
    break;
939
940
0
  case OPTION_LISTING_LHS_WIDTH:
941
0
    listing_lhs_width = atoi (optarg);
942
0
    if (listing_lhs_width_second < listing_lhs_width)
943
0
      listing_lhs_width_second = listing_lhs_width;
944
0
    break;
945
0
  case OPTION_LISTING_LHS_WIDTH2:
946
0
    {
947
0
      int tmp = atoi (optarg);
948
949
0
      if (tmp > listing_lhs_width)
950
0
        listing_lhs_width_second = tmp;
951
0
    }
952
0
    break;
953
0
  case OPTION_LISTING_RHS_WIDTH:
954
0
    listing_rhs_width = atoi (optarg);
955
0
    break;
956
0
  case OPTION_LISTING_CONT_LINES:
957
0
    listing_lhs_cont_lines = atoi (optarg);
958
0
    break;
959
960
0
  case 'M':
961
0
    flag_mri = 1;
962
#ifdef TC_M68K
963
    flag_m68k_mri = 1;
964
#endif
965
0
    break;
966
967
0
  case 'R':
968
0
    flag_readonly_data_in_text = 1;
969
0
    break;
970
971
0
  case 'W':
972
0
    flag_no_warnings = 1;
973
0
    break;
974
975
0
  case OPTION_WARN:
976
0
    flag_no_warnings = 0;
977
0
    flag_fatal_warnings = 0;
978
0
    break;
979
980
0
  case OPTION_WARN_FATAL:
981
0
    flag_no_warnings = 0;
982
0
    flag_fatal_warnings = 1;
983
0
    break;
984
985
0
#if defined OBJ_ELF || defined OBJ_MAYBE_ELF
986
0
  case OPTION_EXECSTACK:
987
0
    flag_execstack = 1;
988
0
    flag_noexecstack = 0;
989
0
    break;
990
991
0
  case OPTION_NOEXECSTACK:
992
0
    flag_noexecstack = 1;
993
0
    flag_execstack = 0;
994
0
    break;
995
996
0
# if defined (TARGET_USE_SCFI) && defined (TARGET_USE_GINSN)
997
0
  case OPTION_SCFI:
998
0
    if (optarg && strcasecmp (optarg, "experimental") == 0)
999
0
      flag_synth_cfi = SYNTH_CFI_EXPERIMENTAL;
1000
0
    else
1001
0
      as_fatal (_("Invalid --scfi= option: `%s'; suggested option: experimental"),
1002
0
          optarg);
1003
0
    break;
1004
0
# endif
1005
1006
0
  case OPTION_SIZE_CHECK:
1007
0
    if (strcasecmp (optarg, "error") == 0)
1008
0
      flag_allow_nonconst_size = false;
1009
0
    else if (strcasecmp (optarg, "warning") == 0)
1010
0
      flag_allow_nonconst_size = true;
1011
0
    else
1012
0
      as_fatal (_("Invalid --size-check= option: `%s'"), optarg);
1013
0
    break;
1014
1015
0
  case OPTION_ELF_STT_COMMON:
1016
0
    if (strcasecmp (optarg, "no") == 0)
1017
0
      flag_use_elf_stt_common = 0;
1018
0
    else if (strcasecmp (optarg, "yes") == 0)
1019
0
      flag_use_elf_stt_common = 1;
1020
0
    else
1021
0
      as_fatal (_("Invalid --elf-stt-common= option: `%s'"),
1022
0
          optarg);
1023
0
    break;
1024
1025
0
  case OPTION_SECTNAME_SUBST:
1026
0
    flag_sectname_subst = 1;
1027
0
    break;
1028
1029
0
  case OPTION_ELF_BUILD_NOTES:
1030
0
    if (strcasecmp (optarg, "no") == 0)
1031
0
      flag_generate_build_notes = false;
1032
0
    else if (strcasecmp (optarg, "yes") == 0)
1033
0
      flag_generate_build_notes = true;
1034
0
    else
1035
0
      as_fatal (_("Invalid --generate-missing-build-notes option: `%s'"),
1036
0
          optarg);
1037
0
    break;
1038
1039
0
  case OPTION_SFRAME:
1040
0
    flag_gen_sframe = 1;
1041
0
    break;
1042
1043
0
#endif /* OBJ_ELF */
1044
1045
0
  case 'Z':
1046
0
    flag_always_generate_output = 1;
1047
0
    break;
1048
1049
0
  case OPTION_AL:
1050
0
    listing |= LISTING_LISTING;
1051
0
    if (optarg)
1052
0
      listing_filename = notes_strdup (optarg);
1053
0
    break;
1054
1055
0
  case OPTION_ALTERNATE:
1056
0
    optarg = old_argv [optind - 1];
1057
0
    while (* optarg == '-')
1058
0
      optarg ++;
1059
1060
0
    if (strcmp (optarg, "alternate") == 0)
1061
0
      {
1062
0
        flag_macro_alternate = 1;
1063
0
        break;
1064
0
      }
1065
0
    optarg ++;
1066
    /* Fall through.  */
1067
1068
0
  case 'a':
1069
0
    if (optarg)
1070
0
      {
1071
0
        if (optarg != old_argv[optind] && optarg[-1] == '=')
1072
0
    --optarg;
1073
1074
0
        if (md_parse_option (optc, optarg) != 0)
1075
0
    break;
1076
1077
0
        while (*optarg)
1078
0
    {
1079
0
      switch (*optarg)
1080
0
        {
1081
0
        case 'c':
1082
0
          listing |= LISTING_NOCOND;
1083
0
          break;
1084
0
        case 'd':
1085
0
          listing |= LISTING_NODEBUG;
1086
0
          break;
1087
0
        case 'g':
1088
0
          listing |= LISTING_GENERAL;
1089
0
          break;
1090
0
        case 'h':
1091
0
          listing |= LISTING_HLL;
1092
0
          break;
1093
0
        case 'i':
1094
0
          listing |= LISTING_GINSN_SCFI;
1095
0
          break;
1096
0
        case 'l':
1097
0
          listing |= LISTING_LISTING;
1098
0
          break;
1099
0
        case 'm':
1100
0
          listing |= LISTING_MACEXP;
1101
0
          break;
1102
0
        case 'n':
1103
0
          listing |= LISTING_NOFORM;
1104
0
          break;
1105
0
        case 's':
1106
0
          listing |= LISTING_SYMBOLS;
1107
0
          break;
1108
0
        case '=':
1109
0
          listing_filename = notes_strdup (optarg + 1);
1110
0
          optarg += strlen (listing_filename);
1111
0
          break;
1112
0
        default:
1113
0
          as_fatal (_("invalid listing option `%c'"), *optarg);
1114
0
          break;
1115
0
        }
1116
0
      optarg++;
1117
0
    }
1118
0
      }
1119
0
    if (!listing)
1120
0
      listing = LISTING_DEFAULT;
1121
0
    break;
1122
1123
0
  case 'D':
1124
    /* DEBUG is implemented: it debugs different
1125
       things from other people's assemblers.  */
1126
0
    flag_debug = 1;
1127
0
    break;
1128
1129
0
  case 'f':
1130
0
    flag_no_comments = 1;
1131
0
    break;
1132
1133
0
  case 'I':
1134
0
    {     /* Include file directory.  */
1135
0
      char *temp = notes_strdup (optarg);
1136
1137
0
      add_include_dir (temp);
1138
0
      break;
1139
0
    }
1140
1141
0
  case 'o':
1142
0
    out_file_name = notes_strdup (optarg);
1143
0
    break;
1144
1145
0
  case 'w':
1146
0
    break;
1147
1148
0
  case 'X':
1149
    /* -X means treat warnings as errors.  */
1150
0
    break;
1151
1152
0
  case OPTION_REDUCE_MEMORY_OVERHEADS:
1153
0
    break;
1154
1155
0
  case OPTION_HASH_TABLE_SIZE:
1156
0
    break;
1157
0
  }
1158
0
    }
1159
1160
0
  free (shortopts);
1161
0
  free (longopts);
1162
1163
0
  *pargc = new_argc;
1164
0
  *pargv = new_argv;
1165
1166
#ifdef md_after_parse_args
1167
  md_after_parse_args ();
1168
#endif
1169
0
}
1170
1171
static void
1172
dump_statistics (void)
1173
0
{
1174
0
  long run_time = get_run_time () - start_time;
1175
1176
0
  fprintf (stderr, _("%s: total time in assembly: %ld.%06ld\n"),
1177
0
     myname, run_time / 1000000, run_time % 1000000);
1178
1179
0
  subsegs_print_statistics (stderr);
1180
0
  write_print_statistics (stderr);
1181
0
  symbol_print_statistics (stderr);
1182
0
  read_print_statistics (stderr);
1183
1184
0
#ifdef tc_print_statistics
1185
0
  tc_print_statistics (stderr);
1186
0
#endif
1187
1188
#ifdef obj_print_statistics
1189
  obj_print_statistics (stderr);
1190
#endif
1191
0
}
1192

1193
/* Here to attempt 1 pass over each input file.
1194
   We scan argv[*] looking for filenames or exactly "" which is
1195
   shorthand for stdin. Any argv that is NULL is not a file-name.
1196
   We set need_pass_2 TRUE if, after this, we still have unresolved
1197
   expressions of the form (unknown value)+-(unknown value).
1198
1199
   Note the un*x semantics: there is only 1 logical input file, but it
1200
   may be a catenation of many 'physical' input files.  */
1201
1202
static void
1203
perform_an_assembly_pass (int argc, char ** argv)
1204
736
{
1205
736
  int saw_a_file = 0;
1206
736
#ifndef OBJ_MACH_O
1207
736
  flagword applicable;
1208
736
#endif
1209
1210
736
  need_pass_2 = 0;
1211
1212
736
#ifndef OBJ_MACH_O
1213
  /* Create the standard sections, and those the assembler uses
1214
     internally.  */
1215
736
  text_section = subseg_new (TEXT_SECTION_NAME, 0);
1216
736
  data_section = subseg_new (DATA_SECTION_NAME, 0);
1217
736
  bss_section = subseg_new (BSS_SECTION_NAME, 0);
1218
  /* @@ FIXME -- we're setting the RELOC flag so that sections are assumed
1219
     to have relocs, otherwise we don't find out in time.  */
1220
736
  applicable = bfd_applicable_section_flags (stdoutput);
1221
736
  bfd_set_section_flags (text_section,
1222
736
       applicable & (SEC_ALLOC | SEC_LOAD | SEC_RELOC
1223
736
               | SEC_CODE | SEC_READONLY));
1224
736
  bfd_set_section_flags (data_section,
1225
736
       applicable & (SEC_ALLOC | SEC_LOAD | SEC_RELOC
1226
736
               | SEC_DATA));
1227
736
  bfd_set_section_flags (bss_section, applicable & SEC_ALLOC);
1228
736
  seg_info (bss_section)->bss = 1;
1229
736
#endif
1230
736
  subseg_new (BFD_ABS_SECTION_NAME, 0);
1231
736
  subseg_new (BFD_UND_SECTION_NAME, 0);
1232
736
  reg_section = subseg_new ("*GAS `reg' section*", 0);
1233
736
  expr_section = subseg_new ("*GAS `expr' section*", 0);
1234
1235
736
#ifndef OBJ_MACH_O
1236
736
  subseg_set (text_section, 0);
1237
736
#endif
1238
1239
  /* This may add symbol table entries, which requires having an open BFD,
1240
     and sections already created.  */
1241
736
  md_begin ();
1242
1243
#ifdef USING_CGEN
1244
  gas_cgen_begin ();
1245
#endif
1246
736
#ifdef obj_begin
1247
736
  obj_begin ();
1248
736
#endif
1249
1250
  /* Skip argv[0].  */
1251
736
  argv++;
1252
736
  argc--;
1253
1254
1.47k
  while (argc--)
1255
736
    {
1256
736
      if (*argv)
1257
736
  {     /* Is it a file-name argument?  */
1258
736
    saw_a_file++;
1259
    /* argv->"" if stdin desired, else->filename.  */
1260
736
    read_a_source_file (*argv);
1261
736
  }
1262
736
      argv++;     /* Completed that argv.  */
1263
736
    }
1264
736
  if (!saw_a_file)
1265
0
    read_a_source_file ("");
1266
736
}
1267
1268
static void
1269
free_notes (void)
1270
736
{
1271
736
  _obstack_free (&notes, NULL);
1272
736
}
1273
1274
/* Early initialisation, before gas prints messages.  */
1275
1276
static void
1277
gas_early_init (int *argcp, char ***argvp)
1278
736
{
1279
736
  start_time = get_run_time ();
1280
736
  signal_init ();
1281
1282
736
#ifdef HAVE_LC_MESSAGES
1283
736
  setlocale (LC_MESSAGES, "");
1284
736
#endif
1285
736
  setlocale (LC_CTYPE, "");
1286
736
  bindtextdomain (PACKAGE, LOCALEDIR);
1287
736
  textdomain (PACKAGE);
1288
1289
736
  if (debug_memory)
1290
0
    chunksize = 64;
1291
1292
736
#ifndef OBJ_DEFAULT_OUTPUT_FILE_NAME
1293
736
#define OBJ_DEFAULT_OUTPUT_FILE_NAME "a.out"
1294
736
#endif
1295
1296
736
  out_file_name = OBJ_DEFAULT_OUTPUT_FILE_NAME;
1297
1298
736
  hex_init ();
1299
736
  if (bfd_init () != BFD_INIT_MAGIC)
1300
0
    as_fatal (_("libbfd ABI mismatch"));
1301
1302
736
  obstack_begin (&notes, chunksize);
1303
736
  xatexit (free_notes);
1304
1305
736
  myname = **argvp;
1306
736
  xmalloc_set_program_name (myname);
1307
736
  bfd_set_error_program_name (myname);
1308
1309
736
  expandargv (argcp, argvp);
1310
1311
736
  init_include_dir ();
1312
1313
#ifdef HOST_SPECIAL_INIT
1314
  HOST_SPECIAL_INIT (*argcp, *argvp);
1315
#endif
1316
1317
#ifdef USE_EMULATIONS
1318
  select_emulation_mode (*argcp, *argvp);
1319
#endif
1320
736
}
1321
1322
/* The bulk of gas initialisation.  This is after args are parsed.  */
1323
1324
static void
1325
gas_init (void)
1326
736
{
1327
736
  symbol_begin ();
1328
736
  frag_init ();
1329
736
  subsegs_begin ();
1330
736
  read_begin ();
1331
736
  input_scrub_begin ();
1332
736
  expr_begin ();
1333
736
  eh_begin ();
1334
1335
736
  macro_init ();
1336
1337
736
  dwarf2_init ();
1338
1339
736
  local_symbol_make (".gasversion.", absolute_section,
1340
736
         &predefined_address_frag, BFD_VERSION / 10000UL);
1341
1342
  /* Note: Put new initialisation calls that don't depend on stdoutput
1343
     being open above this point.  stdoutput must be open for anything
1344
     that might use stdoutput objalloc memory, eg. calling bfd_alloc
1345
     or creating global symbols (via bfd_make_empty_symbol).  */
1346
736
  xatexit (output_file_close);
1347
736
  output_file_create (out_file_name);
1348
736
  gas_assert (stdoutput != 0);
1349
1350
  /* Must be called before output_file_close.  xexit calls the xatexit
1351
     list in reverse order.  */
1352
736
  if (flag_print_statistics)
1353
0
    xatexit (dump_statistics);
1354
1355
736
  dot_symbol_init ();
1356
1357
#ifdef tc_init_after_args
1358
  tc_init_after_args ();
1359
#endif
1360
1361
736
  itbl_init ();
1362
1363
  /* Now that we have fully initialized, and have created the output
1364
     file, define any symbols requested by --defsym command line
1365
     arguments.  */
1366
736
  while (defsyms != NULL)
1367
0
    {
1368
0
      symbolS *sym;
1369
0
      struct defsym_list *next;
1370
1371
0
      sym = symbol_new (defsyms->name, absolute_section,
1372
0
      &zero_address_frag, defsyms->value);
1373
      /* Make symbols defined on the command line volatile, so that they
1374
   can be redefined inside a source file.  This makes this assembler's
1375
   behaviour compatible with earlier versions, but it may not be
1376
   completely intuitive.  */
1377
0
      S_SET_VOLATILE (sym);
1378
0
      symbol_table_insert (sym);
1379
0
      next = defsyms->next;
1380
0
      free (defsyms);
1381
0
      defsyms = next;
1382
0
    }
1383
736
}
1384
1385
int
1386
old_main32 (int argc, char **argv);
1387
int old_main32 (int argc, char ** argv)
1388
0
{
1389
0
  char ** argv_orig = argv;
1390
0
  struct stat sob;
1391
1392
0
  gas_early_init (&argc, &argv);
1393
1394
  /* Call parse_args before gas_init so that switches like
1395
     --hash-size can be honored.  */
1396
0
  parse_args (&argc, &argv);
1397
1398
0
  if (argc > 1 && stat (out_file_name, &sob) == 0)
1399
0
    {
1400
0
      int i;
1401
1402
0
      for (i = 1; i < argc; ++i)
1403
0
  {
1404
0
    struct stat sib;
1405
1406
    /* Check that the input file and output file are different.  */
1407
0
    if (stat (argv[i], &sib) == 0
1408
0
        && sib.st_ino == sob.st_ino
1409
        /* POSIX emulating systems may support stat() but if the
1410
     underlying file system does not support a file serial number
1411
     of some kind then they will return 0 for the inode.  So
1412
     two files with an inode of 0 may not actually be the same.
1413
     On real POSIX systems no ordinary file will ever have an
1414
     inode of 0.  */
1415
0
        && sib.st_ino != 0
1416
        /* Different files may have the same inode number if they
1417
     reside on different devices, so check the st_dev field as
1418
     well.  */
1419
0
        && sib.st_dev == sob.st_dev
1420
        /* PR 25572: Only check regular files.  Devices, sockets and so
1421
     on might actually work as both input and output.  Plus there
1422
     is a use case for using /dev/null as both input and output
1423
     when checking for command line option support in a script:
1424
       as --foo /dev/null -o /dev/null; if $? then ...  */
1425
0
        && S_ISREG (sib.st_mode))
1426
0
      {
1427
0
        const char *saved_out_file_name = out_file_name;
1428
1429
        /* Don't let as_fatal remove the output file!  */
1430
0
        out_file_name = NULL;
1431
0
        as_fatal (_("The input '%s' and output '%s' files are the same"),
1432
0
      argv[i], saved_out_file_name);
1433
0
      }
1434
0
  }
1435
0
    }
1436
1437
0
  gas_init ();
1438
1439
  /* Assemble it.  */
1440
0
  perform_an_assembly_pass (argc, argv);
1441
1442
0
  cond_finish_check (-1);
1443
1444
#ifdef md_finish
1445
  md_finish ();
1446
#endif
1447
1448
0
#if defined OBJ_ELF || defined OBJ_MAYBE_ELF
1449
0
  if ((flag_execstack || flag_noexecstack)
1450
0
      && OUTPUT_FLAVOR == bfd_target_elf_flavour)
1451
0
    {
1452
0
      segT gnustack;
1453
1454
0
      gnustack = subseg_new (".note.GNU-stack", 0);
1455
0
      bfd_set_section_flags (gnustack,
1456
0
           SEC_READONLY | (flag_execstack ? SEC_CODE : 0));
1457
1458
0
    }
1459
0
#endif
1460
1461
0
  codeview_finish ();
1462
1463
  /* If we've been collecting dwarf2 .debug_line info, either for
1464
     assembly debugging or on behalf of the compiler, emit it now.  */
1465
0
  dwarf2_finish ();
1466
1467
  /* If we constructed dwarf2 .eh_frame info, either via .cfi
1468
     directives from the user or by the backend, emit it now.  */
1469
0
  cfi_finish ();
1470
1471
0
  keep_it = 0;
1472
0
  if (seen_at_least_1_file ())
1473
0
    {
1474
0
      int n_warns, n_errs;
1475
0
      char warn_msg[50];
1476
0
      char err_msg[50];
1477
1478
0
      write_object_file ();
1479
1480
0
      n_warns = had_warnings ();
1481
0
      n_errs = had_errors ();
1482
1483
0
      sprintf (warn_msg,
1484
0
         ngettext ("%d warning", "%d warnings", n_warns), n_warns);
1485
0
      sprintf (err_msg,
1486
0
         ngettext ("%d error", "%d errors", n_errs), n_errs);
1487
0
      if (flag_fatal_warnings && n_warns != 0)
1488
0
  {
1489
0
    if (n_errs == 0)
1490
0
      as_bad (_("%s, treating warnings as errors"), warn_msg);
1491
0
    n_errs += n_warns;
1492
0
  }
1493
1494
0
      if (n_errs == 0)
1495
0
  keep_it = 1;
1496
0
      else if (flag_always_generate_output)
1497
0
  {
1498
    /* The -Z flag indicates that an object file should be generated,
1499
       regardless of warnings and errors.  */
1500
0
    keep_it = 1;
1501
0
    fprintf (stderr, _("%s, %s, generating bad object file\n"),
1502
0
       err_msg, warn_msg);
1503
0
  }
1504
0
    }
1505
1506
0
  fflush (stderr);
1507
1508
0
#ifndef NO_LISTING
1509
0
  listing_print (listing_filename, argv_orig);
1510
0
#endif
1511
1512
0
  input_scrub_end ();
1513
1514
  /* Use xexit instead of return, because under VMS environments they
1515
     may not place the same interpretation on the value given.  */
1516
0
  if (had_errors () != 0)
1517
0
    xexit (EXIT_FAILURE);
1518
1519
  /* Only generate dependency file if assembler was successful.  */
1520
0
  print_dependencies ();
1521
1522
0
  xexit (EXIT_SUCCESS);
1523
0
}