Provided by: yasm_1.3.0-2build1_amd64 bug


       yasm - The Yasm Modular Assembler


       yasm [-f format] [-o outfile] [other options...] {infile}

       yasm -h


       The Yasm Modular Assembler is a portable, retargetable assembler written under the “new”
       (2 or 3 clause) BSD license. Yasm currently supports the x86 and AMD64 instruction sets,
       accepts NASM and GAS assembler syntaxes, outputs binary, ELF32, ELF64, COFF, Win32, and
       Win64 object formats, and generates source debugging information in STABS, DWARF 2, and
       CodeView 8 formats.

       YASM consists of the yasm command, libyasm, the core backend library, and a large number
       of modules. Currently, libyasm and the loadable modules are statically built into the yasm

       The yasm command assembles the file infile and directs output to the file outfile if
       specified. If outfile is not specified, yasm will derive a default output file name from
       the name of its input file, usually by appending .o or .obj, or by removing all extensions
       for a raw binary file. Failing that, the output file name will be yasm.out.

       If called with an infile of “-”, yasm assembles the standard input and directs output to
       the file outfile, or yasm.out if no outfile is specified.


       Many options may be given in one of two forms: either a dash followed by a single letter,
       or two dashes followed by a long option name. Options are listed in alphabetical order.

   General Options
       -a arch or --arch=arch: Select target architecture
           Selects the target architecture. The default architecture is “x86”, which supports
           both the IA-32 and derivatives and AMD64 instruction sets. To print a list of
           available architectures to standard output, use “help” as arch. See yasm_arch(7) for a
           list of supported architectures.

       -f format or --oformat=format: Select object format
           Selects the output object format. The default object format is “bin”, which is a flat
           format binary with no relocation. To print a list of available object formats to
           standard output, use “help” as format. See yasm_objfmts(7) for a list of supported
           object formats.

       -g debug or --dformat=debug: Select debugging format
           Selects the debugging format for debug information. Debugging information can be used
           by a debugger to associate executable code back to the source file or get data
           structure and type information. Available debug formats vary between different object
           formats; yasm will error when an invalid combination is selected. The default object
           format is selected by the object format. To print a list of available debugging
           formats to standard output, use “help” as debug. See yasm_dbgfmts(7) for a list of
           supported debugging formats.

       -L list or --lformat=list: Select list file format
           Selects the format/style of the output list file. List files typically intermix the
           original source with the machine code generated by the assembler. The default list
           format is “nasm”, which mimics the NASM list file format. To print a list of available
           list file formats to standard output, use “help” as list.

       -l listfile or --list=listfile: Specify list filename
           Specifies the name of the output list file. If this option is not used, no list file
           is generated.

       -m machine or --machine=machine: Select target machine architecture
           Selects the target machine architecture. Essentially a subtype of the selected
           architecture, the machine type selects between major subsets of an architecture. For
           example, for the “x86” architecture, the two available machines are “x86”, which is
           used for the IA-32 and derivative 32-bit instruction set, and “amd64”, which is used
           for the 64-bit instruction set. This differentiation is required to generate the
           proper object file for relocatable object formats such as COFF and ELF. To print a
           list of available machines for a given architecture to standard output, use “help” as
           machine and the given architecture using -a arch. See yasm_arch(7) for more details.

       -o filename or --objfile=filename: Specify object filename
           Specifies the name of the output file, overriding any default name generated by Yasm.

       -p parser or --parser=parser: Select parser
           Selects the parser (the assembler syntax). The default parser is “nasm”, which
           emulates the syntax of NASM, the Netwide Assembler. Another available parser is “gas”,
           which emulates the syntax of GNU AS. To print a list of available parsers to standard
           output, use “help” as parser. See yasm_parsers(7) for a list of supported parsers.

       -r preproc or --preproc=preproc: Select preprocessor
           Selects the preprocessor to use on the input file before passing it to the parser.
           Preprocessors often provide macro functionality that is not included in the main
           parser. The default preprocessor is “nasm”, which is an imported version of the actual
           NASM preprocessor. A “raw” preprocessor is also available, which simply skips the
           preprocessing step, passing the input file directly to the parser. To print a list of
           available preprocessors to standard output, use “help” as preproc.

       -h or --help: Print a summary of options
           Prints a summary of invocation options. All other options are ignored, and no output
           file is generated.

       --version: Get the Yasm version
           This option causes Yasm to prints the version number of Yasm as well as a license
           summary to standard output. All other options are ignored, and no output file is

   Warning Options
       -W options have two contrary forms: -Wname and -Wno-name. Only the non-default forms are
       shown here.

       The warning options are handled in the order given on the command line, so if -w is
       followed by -Worphan-labels, all warnings are turned off except for orphan-labels.

       -w: Inhibit all warning messages
           This option causes Yasm to inhibit all warning messages. As discussed above, this
           option may be followed by other options to re-enable specified warnings.

       -Werror: Treat warnings as errors
           This option causes Yasm to treat all warnings as errors. Normally warnings do not
           prevent an object file from being generated and do not result in a failure exit status
           from yasm, whereas errors do. This option makes warnings equivalent to errors in terms
           of this behavior.

       -Wno-unrecognized-char: Do not warn on unrecognized input characters
           Causes Yasm to not warn on unrecognized characters found in the input. Normally Yasm
           will generate a warning for any non-ASCII character found in the input file.

       -Worphan-labels: Warn on labels lacking a trailing option
           When using the NASM-compatible parser, causes Yasm to warn about labels found alone on
           a line without a trailing colon. While these are legal labels in NASM syntax, they may
           be unintentional, due to typos or macro definition ordering.

       -X style: Change error/warning reporting style
           Selects a specific output style for error and warning messages. The default is “gnu”
           style, which mimics the output of gcc. The “vc” style is also available, which mimics
           the output of Microsoft´s Visual C++ compiler.

           This option is available so that Yasm integrates more naturally into IDE environments
           such as Visual Studio or Emacs, allowing the IDE to correctly recognize the
           error/warning message as such and link back to the offending line of source code.

   Preprocessor Options
       While these preprocessor options theoretically will affect any preprocessor, the only
       preprocessor currently in Yasm is the “nasm” preprocessor.

       -D macro[=value]: Pre-define a macro
           Pre-defines a single-line macro. The value is optional (if no value is given, the
           macro is still defined, but to an empty value).

       -e or --preproc-only: Only preprocess
           Stops assembly after the preprocessing stage; preprocessed output is sent to the
           specified output name or, if no output name is specified, the standard output. No
           object file is produced.

       -I path: Add include file path
           Adds directory path to the search path for include files. The search path defaults to
           only including the directory in which the source file resides.

       -P filename: Pre-include a file
           Pre-includes file filename, making it look as though filename was prepended to the
           input. Can be useful for prepending multi-line macros that the -D can´t support.

       -U macro: Undefine a macro
           Undefines a single-line macro (may be either a built-in macro or one defined earlier
           in the command line with -D.


       To assemble NASM syntax, 32-bit x86 source source.asm into ELF file source.o, warning on
       orphan labels:

           yasm -f elf32 -Worphan-labels source.asm

       To assemble NASM syntax AMD64 source x.asm into Win64 file object.obj:

           yasm -f win64 -o object.obj x.asm

       To assemble already preprocessed NASM syntax x86 source y.asm into flat binary file

           yasm -f bin -r raw -o y.asm


       The yasm command exits 0 on success, and nonzero if an error occurs.


       Yasm´s NASM parser and preprocessor, while they strive to be as compatible as possible
       with NASM, have a few incompatibilities due to YASM´s different internal structure.

       Yasm´s GAS parser and preprocessor are missing a number of features present in GNU AS.


       As object files are often architecture and machine dependent, not all combinations of
       object formats, architectures, and machines are legal; trying to use an invalid
       combination will result in an error.

       There is no support for symbol maps.


       yasm_arch(7), yasm_dbgfmts(7), yasm_objfmts(7), yasm_parsers(7)

       Related tools: as(1), ld(1), nasm(1)


       When using the “x86” architecture, it is overly easy to generate AMD64 code (using the
       BITS 64 directive) and generate a 32-bit object file (by failing to specify -m amd64 or
       selecting a 64-bit object format such as ELF64 on the command line).


       Peter Johnson <>


       Copyright © 2004, 2005, 2006, 2007 Peter Johnson