chromium/third_party/nasm/asm/nasm.c

/* ----------------------------------------------------------------------- *
 *
 *   Copyright 1996-2020 The NASM Authors - All Rights Reserved
 *   See the file AUTHORS included with the NASM distribution for
 *   the specific copyright holders.
 *
 *   Redistribution and use in source and binary forms, with or without
 *   modification, are permitted provided that the following
 *   conditions are met:
 *
 *   * Redistributions of source code must retain the above copyright
 *     notice, this list of conditions and the following disclaimer.
 *   * Redistributions in binary form must reproduce the above
 *     copyright notice, this list of conditions and the following
 *     disclaimer in the documentation and/or other materials provided
 *     with the distribution.
 *
 *     THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND
 *     CONTRIBUTORS "AS IS" AND ANY EXPRESS OR IMPLIED WARRANTIES,
 *     INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES OF
 *     MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
 *     DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR
 *     CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL,
 *     SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT
 *     NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
 *     LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION)
 *     HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
 *     CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR
 *     OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE,
 *     EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 *
 * ----------------------------------------------------------------------- */

/*
 * The Netwide Assembler main program module
 */

#include "compiler.h"


#include "nasm.h"
#include "nasmlib.h"
#include "nctype.h"
#include "error.h"
#include "saa.h"
#include "raa.h"
#include "floats.h"
#include "stdscan.h"
#include "insns.h"
#include "preproc.h"
#include "parser.h"
#include "eval.h"
#include "assemble.h"
#include "labels.h"
#include "outform.h"
#include "listing.h"
#include "iflag.h"
#include "quote.h"
#include "ver.h"

/*
 * This is the maximum number of optimization passes to do.  If we ever
 * find a case where the optimizer doesn't naturally converge, we might
 * have to drop this value so the assembler doesn't appear to just hang.
 */
#define MAX_OPTIMIZE …

struct forwrefinfo { … };

const char *_progname;

static void parse_cmdline(int, char **, int);
static void assemble_file(const char *, struct strlist *);
static bool skip_this_pass(errflags severity);
static void usage(void);
static void help(FILE *);

struct error_format { … };

static const struct error_format errfmt_gnu  = …;
static const struct error_format errfmt_msvc = …;
static const struct error_format *errfmt = …;
static struct strlist *warn_list;
static struct nasm_errhold *errhold_stack;

unsigned int debug_nasm;        /* Debugging messages? */

static bool using_debug_info, opt_verbose_info;
static const char *debug_format;

#ifndef ABORT_ON_PANIC
#define ABORT_ON_PANIC …
#endif
static bool abort_on_panic = …;
static bool keep_all;

bool tasm_compatible_mode = …;
enum pass_type _pass_type;
const char * const _pass_types[] = …;
int64_t _passn;
int globalrel = …;
int globalbnd = …;

struct compile_time official_compile_time;

const char *inname;
const char *outname;
static const char *listname;
static const char *errname;

static int64_t globallineno;    /* for forward-reference tracking */

const struct ofmt *ofmt = …;
const struct ofmt_alias *ofmt_alias = …;
const struct dfmt *dfmt;

FILE *error_file;               /* Where to write error messages */

FILE *ofile = …;
struct optimization optimizing = …; /* number of optimization passes to take */
static int cmd_sb = …;    /* by default */

iflag_t cpu;
static iflag_t cmd_cpu;

struct location location;
bool in_absolute;                 /* Flag we are in ABSOLUTE seg */
struct location absolute;         /* Segment/offset inside ABSOLUTE */

static struct RAA *offsets;

static struct SAA *forwrefs;    /* keep track of forward references */
static const struct forwrefinfo *forwref;

static const struct preproc_ops *preproc;
static struct strlist *include_path;
bool pp_noline;                 /* Ignore %line directives */

#define OP_NORMAL …
#define OP_PREPROCESS …
#define OP_DEPEND …

static unsigned int operating_mode;

/* Dependency flags */
static bool depend_emit_phony = …;
static bool depend_missing_ok = …;
static const char *depend_target = …;
static const char *depend_file = …;
struct strlist *depend_list;

static bool want_usage;
static bool terminate_after_phase;
bool user_nolist = …;

static char *quote_for_pmake(const char *str);
static char *quote_for_wmake(const char *str);
static char *(*quote_for_make)(const char *) = …;

#if defined(OF_MACHO) || defined(OF_MACHO64)
extern bool macho_set_min_os(const char *str);
#endif

/*
 * Execution limits that can be set via a command-line option or %pragma
 */

/*
 * This is really unlimited; it would take far longer than the
 * current age of the universe for this limit to be reached even on
 * much faster CPUs than currently exist.
*/
#define LIMIT_MAX_VAL …

int64_t nasm_limit[LIMIT_MAX+1];

struct limit_info { … };
/* The order here must match enum nasm_limit in nasm.h */
static const struct limit_info limit_info[LIMIT_MAX+1] = …;

static void set_default_limits(void)
{ … }

enum directive_result
nasm_set_limit(const char *limit, const char *valstr)
{ … }

int64_t switch_segment(int32_t segment)
{ … }

static void set_curr_offs(int64_t l_off)
{ … }

static void increment_offset(int64_t delta)
{ … }

/*
 * Define system-defined macros that are not part of
 * macros/standard.mac.
 */
static void define_macros(void)
{ … }

/*
 * Initialize the preprocessor, set up the include path, and define
 * the system-included macros.  This is called between passes 1 and 2
 * of parsing the command options; ofmt and dfmt are defined at this
 * point.
 *
 * Command-line specified preprocessor directives (-p, -d, -u,
 * --pragma, --before) are processed after this function.
 */
static void preproc_init(struct strlist *ipath)
{ … }

static void emit_dependencies(struct strlist *list)
{ … }

/* Convert a struct tm to a POSIX-style time constant */
static int64_t make_posix_time(const struct tm *tm)
{ … }

/*
 * Quote a filename string if and only if it is necessary.
 * It is considered necessary if any one of these is true:
 * 1. The filename contains control characters;
 * 2. The filename starts or ends with a space or quote mark;
 * 3. The filename contains more than one space in a row;
 * 4. The filename is empty.
 *
 * The filename is returned in a newly allocated buffer.
 */
static char *nasm_quote_filename(const char *fn)
{ … }

static void timestamp(void)
{ … }

int main(int argc, char **argv)
{ … }

/*
 * Get a parameter for a command line option.
 * First arg must be in the form of e.g. -f...
 */
static char *get_param(char *p, char *q, bool *advance)
{ … }

/*
 * Copy a filename
 */
static void copy_filename(const char **dst, const char *src, const char *what)
{ … }

/*
 * Convert a string to a POSIX make-safe form
 */
static char *quote_for_pmake(const char *str)
{ … }

/*
 * Convert a string to a Watcom make-safe form
 */
static char *quote_for_wmake(const char *str)
{ … }

enum text_options { … };
enum need_arg { … };

struct textargs { … };
static const struct textargs textopts[] = …;

static void show_version(void)
{ … }

static bool stopoptions = …;
static bool process_arg(char *p, char *q, int pass)
{ … }

#define ARG_BUF_DELTA …

static void process_respfile(FILE * rfile, int pass)
{ … }

/* Function to process args from a string of args, rather than the
 * argv array. Used by the environment variable and response file
 * processing.
 */
static void process_args(char *args, int pass)
{ … }

static void process_response_file(const char *file, int pass)
{ … }

static void parse_cmdline(int argc, char **argv, int pass)
{ … }

static void forward_refs(insn *instruction)
{ … }

static void process_insn(insn *instruction)
{ … }

static void assemble_file(const char *fname, struct strlist *depend_list)
{ … }

/**
 * get warning index; 0 if this is non-suppressible.
 */
static size_t warn_index(errflags severity)
{ … }

static bool skip_this_pass(errflags severity)
{ … }

/**
 * check for suppressed message (usually warnings or notes)
 *
 * @param severity the severity of the warning or error
 * @return true if we should abort error/warning printing
 */
static bool is_suppressed(errflags severity)
{ … }

/**
 * Return the true error type (the ERR_MASK part) of the given
 * severity, accounting for warnings that may need to be promoted to
 * error.
 *
 * @param severity the severity of the warning or error
 * @return true if we should error out
 */
static errflags true_error_type(errflags severity)
{ … }

/*
 * The various error type prefixes
 */
static const char * const error_pfx_table[ERR_MASK+1] = …;
static const char no_file_name[] = …; /* What to print if no file name */

/*
 * For fatal/critical/panic errors, kill this process.
 */
static fatal_func die_hard(errflags true_type, errflags severity)
{ … }

/*
 * Returns the struct src_location appropriate for use, after some
 * potential filename mangling.
 */
static struct src_location error_where(errflags severity)
{ … }

/*
 * error reporting for critical and panic errors: minimize
 * the amount of system dependencies for getting a message out,
 * and in particular try to avoid memory allocations.
 */
fatal_func nasm_verror_critical(errflags severity, const char *fmt, va_list args)
{ … }

/**
 * Stack of tentative error hold lists.
 */
struct nasm_errtext { … };
struct nasm_errhold { … };

static void nasm_free_error(struct nasm_errtext *et)
{ … }

static void nasm_issue_error(struct nasm_errtext *et);

struct nasm_errhold *nasm_error_hold_push(void)
{ … }

void nasm_error_hold_pop(struct nasm_errhold *eh, bool issue)
{ … }

/**
 * common error reporting
 * This is the common back end of the error reporting schemes currently
 * implemented.  It prints the nature of the warning and then the
 * specific error message to error_file and may or may not return.  It
 * doesn't return if the error severity is a "panic" or "debug" type.
 *
 * @param severity the severity of the warning or error
 * @param fmt the printf style format string
 */
void nasm_verror(errflags severity, const char *fmt, va_list args)
{ … }

/*
 * Actually print, list and take action on an error
 */
static void nasm_issue_error(struct nasm_errtext *et)
{ … }

static void usage(void)
{ … }

static void help(FILE *out)
{ … }