Go to main content

man pages section 1: User Commands

Exit Print View

Updated: Wednesday, July 27, 2022

yasm (1)


yasm - The Yasm Modular Assembler


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

yasm -h


The Yasm Modular Assembler                                             YASM(1)

       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 executable.

       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

       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

       -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

       -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 generated.

   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

       -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"

       -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 y.com:

           yasm -f bin -r raw -o y.com 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.

       See attributes(7) for descriptions of the following attributes:

       |Availability   | developer/yasm        |
       |Stability      | Pass-through volatile |

       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 <peter@tortall.net>

       Copyright (C) 2004, 2005, 2006, 2007 Peter Johnson

       Source code for open source software components in Oracle Solaris can
       be found at https://www.oracle.com/downloads/opensource/solaris-source-

       This software was built from source available at
       https://github.com/oracle/solaris-userland.  The original community
       source was downloaded from

       Further information about this software can be found on the open source
       community website at http://yasm.tortall.net/.

Yasm                              April 2007                           YASM(1)