Menu
Search

Command-line Reference

overview

Report a bug
If you spot a problem with this page, click here to create a Bugzilla issue.
Improve this page
Quickly fork, edit online, and submit a pull request for this page. Requires a signed-in GitHub account. This works well for small changes. If you'd like to make larger changes you may want to consider using a local clone.

DMD Compiler for Windows

Requirements and Downloads

  1. DMD Compiler
  2. Windows operating system, Windows 7 or later, 32 or 64 bit
  3. Download dmc.zip (C and C++ compiler) for Win32 (not required, but it complements dmd for Windows)

Installation

Hint - The official installer performs these steps automatically.

Open a console window (for Windows XP this is done by clicking on [Start][Command Prompt]). All the tools are command line tools, which means they are run from a console window. Switch to the root directory. Unzip the files in the root directory. dmd.zip will create a \dmd2 directory with all the files in it. dmc.zip will create a \dm directory with all the files in it.

A typical session might look like:

C:\Documents and Settings\Your Name>cd \
C:\>unzip dmd.zip
C:\>unzip dmc.zip
  • All tools can be run directly from the archive: 
    ~/dmd/linux/bin64/dmd
    To install dmd globally, add this bin folder to your PATH.

    • Example

    Run:

    \dmd2\windows\bin\shell all.sh

    in the \dmd2\samples\d directory for several small examples.

    Compiler Arguments and Switches

    dmd files... -switches...
    files...
    File Extensions
    Extension File Type
    none D source files
    .d D source files
    .dd Ddoc source files
    .di D interface files
    .obj Object files to link in
    .lib Object code libraries to search
    .exe Output executable file
    .def module definition file
    .res resource file
    @cmdfile
    If cmdfile is an environment variable, read the compiler arguments and switches from the value of that variable. Otherwise, read compiler arguments and switches from the text file cmdfile. The file may contain single-line comments starting with the hash symbol (#).
    -allinst
    Generate code for all template instantiations
    -betterC
    Adjusts the compiler to implement D as a better C:
    • Predefines D_BetterC version.
    • Assert Expressions, when they fail, call the C runtime library assert failure function rather than a function in the D runtime.
    • Array overflows call the C runtime library assert failure function rather than a function in the D runtime.
    • Final switch errors call the C runtime library assert failure function rather than a function in the D runtime.
    • Does not automatically link with phobos runtime library.
    • Module constructors and destructors are not generated meaning that static and shared static constructors and destructors will not get called.
    • ModuleInfo is not generated.
    • TypeInfo instances will not be generated for structs.
    -boundscheck=[on|safeonly|off ]
    Controls if bounds checking is enabled.
    • on: Bounds checks are enabled for all code. This is the default.
    • safeonly: Bounds checks are enabled only in @safe code. This is the default for -release builds.
    • off: Bounds checks are disabled completely (even in @safe code). This option should be used with caution and as a last resort to improve performance. Confirm turning off @safe bounds checks is worthwhile by benchmarking.
    -c
    Compile only, do not link
    -color
    Turn colored console output on
    -color=[on|off ]
    Show colored console output. The default depends on terminal capabilities.
    • on: always use colored output. Same as -color
    • off: never use colored output.
    -conf=filename
    Use config file at filename
    -cov
    Do code coverage analysis
    -cov=nnn
    Perform code coverage analysis and generate .lst file with report.
    dmd -cov -unittest myprog.d
    -D

    Generate documentation from source.

    Note: mind the security considerations.

    -Dddirectory
    Write documentation file to directory . -op can be used if the original package hierarchy should be retained
    -Dffilename
    Write documentation file to filename
    -d
    Silently allow deprecated features and use of symbols with deprecated attributes.
    -dw
    Show use of deprecated features as warnings (default)
    -de
    Show use of deprecated features as errors (halt compilation)
    -debug
    Compile in debug code
    -debug=level
    Compile in debug level <= level
    -debug=ident
    Compile in debug identifier ident
    -debuglib=name
    Link in libname as the default library when compiling for symbolic debugging instead of lib. If libname is not supplied, then no default library is linked in.
    -defaultlib=name
    Link in libname as the default library when not compiling for symbolic debugging instead of lib. If libname is not supplied, then no default library is linked in.
    -deps
    Print module dependencies (imports/file/version/debug/lib)
    -deps=filename
    Without filename, print module dependencies (imports/file/version/debug/lib). With filename, write module dependencies as text to filename (only imports).
    -dip25
    Implement http://wiki.dlang.org/DIP25
    -dip1000
    Implement https://github.com/dlang/DIPs/blob/master/DIPs/DIP1000.md
    -dip1008
    Implement https://github.com/dlang/DIPs/blob/master/DIPs/DIP1008.md
    -fPIC
    Generate position independent code
    -g
    Add CodeView symbolic debug info with D extensions for debuggers such as Ddbg
    -gf
    Emit debug info for all referenced types
    -gs
    Always emit stack frame
    -gx
    Adds stack stomp code, which overwrites the stack frame memory upon function exit.
    -H
    Generate D interface file
    -Hd=directory
    Write D interface file to dir directory. -op can be used if the original package hierarchy should be retained.
    -Hf=filename
    Write 'header' file to filename
    --help
    Print help and exit
    -I=directory
    Look for imports also in directory
    -i[=pattern ]

    Enables "include imports" mode, where the compiler will include imported modules in the compilation, as if they were given on the command line. By default, when this option is enabled, all imported modules are included except those in druntime/phobos. This behavior can be overriden by providing patterns via -i=<pattern>. A pattern of the form -i=<package> is an "inclusive pattern", whereas a pattern of the form -i=-<package> is an "exclusive pattern". Inclusive patterns will include all module's whose names match the pattern, whereas exclusive patterns will exclude them. For example. all modules in the package foo.bar can be included using -i=foo.bar or excluded using -i=-foo.bar. Note that each component of the fully qualified name must match the pattern completely, so the pattern foo.bar would not match a module named foo.barx.

    The default behavior of excluding druntime/phobos is accomplished by internally adding a set of standard exclusions, namely, -i=-std -i=-core -i=-etc -i=-object. Note that these can be overriden with -i=std -i=core -i=etc -i=object.

    When a module matches multiple patterns, matches are prioritized by their component length, where a match with more components takes priority (i.e. pattern foo.bar.baz has priority over foo.bar).

    By default modules that don't match any pattern will be included. However, if at least one inclusive pattern is given, then modules not matching any pattern will be excluded. This behavior can be overriden by usig -i=. to include by default or -i=-. to exclude by default.

    Note that multiple -i=... options are allowed, each one adds a pattern.

    -ignore
    Ignore unsupported pragmas
    -inline
    Inline functions at the discretion of the compiler. This can improve performance, at the expense of making it more difficult to use a debugger on it.
    -J=directory
    Where to look for files for ImportExpressions. This switch is required in order to use ImportExpressions. path is a ; separated list of paths. Multiple -J's can be used, and the paths are searched in the same order.
    -L=linkerflag
    Pass linkerflag to the linker link.exe , for example,
    -lib
    Generate library file as output instead of object file(s). All compiled source files, as well as object files and library files specified on the command line, are inserted into the output library. Compiled source modules may be partitioned into several object modules to improve granularity. The name of the library is taken from the name of the first source module to be compiled. This name can be overridden with the -of switch.
    -m32
    Compile a 32 bit executable. This is the default. The generated object code is in OMF and is meant to be used with the Digital Mars C/C++ compiler.
    -m32mscoff
    Generate 32 bit code and write MS-COFF object files
    -m64
    The generated object code is in MS-COFF and is meant to be used with the Microsoft Visual Studio 10 or later compiler.
    -main
    Add a default main() function when compiling. This is useful when unittesting a library, as it enables running the unittests in a library without having to manually define an entry-point function.
    -man
    Open default browser on this page
    -map
    Generate a .map file
    -mcpu=id
    Set the target architecture for code generation, where:
    ?
    list alternatives
    baseline
    the minimum architecture for the target platform (default)
    avx
    generate AVX instructions instead of SSE instructions for vector and floating point operations. Not available for 32 bit memory models other than OSX32.
    native
    use the architecture the compiler is running on
    -mcpu=?
    List all architecture options
    -mscrtlib=name
    If building MS-COFF object files with -m64 or -m32mscoff, embed a reference to the given C runtime library libname into the object file containing main, DllMain or WinMain for automatic linking. The default is libcmt (release version with static linkage), the other usual alternatives are libcmtd, msvcrt and msvcrtd. If libname is empty, no C runtime library is automatically linked in.
    -mv=package.module =
    Use path/filename as the source file for package.module. This is used when the source file path and names are not the same as the package and module hierarchy. The rightmost components of the path/filename and package.module can be omitted if they are the same.
    -noboundscheck
    Turns off all array bounds checking, even for safe functions. Deprecated (use -boundscheck=off instead).
    -O
    Optimize generated code. For fastest executables, compile with the -O -release -inline -boundscheck=off switches together.
    -o-
    Suppress generation of object file. Useful in conjuction with -D or -H flags.
    -od=directory
    Write object files relative to directory objdir instead of to the current directory. -op can be used if the original package hierarchy should be retained
    -of=filename
    Set output file name to filename in the output directory. The output file can be an object file, executable file, or library file depending on the other switches.
    -op
    Normally the path for .d source files is stripped off when generating an object, interface, or Ddoc file name. -op will leave it on.
    -profile
    Profile runtime performance of generated code
    -profile=gc
    profile the runtime performance of the generated code.
    • gc: Instrument calls to memory allocation and write a report to the file profilegc.log upon program termination.
    -release
    Compile release version, which means not emitting run-time checks for contracts and asserts. Array bounds checking is not done for system and trusted functions, and assertion failures are undefined behaviour.
    -run srcfile
    Compile, link, and run the program srcfile with the rest of the command line, args..., as the arguments to the program. No .obj or executable file is left behind.
    -shared
    Generate DLL library
    -transition=id
    Show additional info about language change identified by id
    -transition=?
    List all language changes
    -unittest
    Compile in unittest code, turns on asserts, and sets the unittest version identifier
    -v
    Enable verbose output for each compiler pass
    -vcolumns
    Print character (column) numbers in diagnostics
    -verrors=num
    Limit the number of error messages (0 means unlimited)
    -verrors=spec
    Show errors from speculative compiles such as __traits(compiles,...)
    --version
    Print compiler version and exit
    -version=level
    Compile in version level >= level
    -version=ident
    Compile in version identifier ident
    -vgc
    List all gc allocations including hidden ones
    -vtls
    List all variables going into thread local storage
    -w
    Enable warnings
    -wi
    Enable informational warnings (i.e. compilation still proceeds normally)
    -X
    Generate JSON file
    -Xf=filename
    Write JSON file to filename

    Empty switches, i.e. "", are ignored.

    Files

    \dmd2\src\phobos\
    D runtime library source
    \dmd2\src\dmd\
    D compiler front end source under dual (GPL and Artistic) license
    \dmd2\html\d\
    Documentation
    \dmd2\samples\d\
    Sample D programs
    \dmd2\windows\bin\ddemangle.exe
    D symbol demangler
    \dmd2\windows\bin\dman.exe
    D manual lookup tool
    \dmd2\windows\bin\dmd.exe
    D compiler executable
    \dmd2\windows\bin\dub.exe
    D's package manager
    \dmd2\windows\bin\dustmite.exe
    D source code minimizer
    \dmd2\windows\bin\link.exe
    OPTLINK
    \dmd2\windows\bin\make.exe
    Digitalmars Make
    \dmd2\windows\bin\replace.exe
    Find/replace text in files
    \dmd2\windows\bin\rdmd.exe
    D build tool for script-like D code execution
    \dmd2\windows\bin\\dmd2\windows\bin\sc.ini
    Global compiler settings
    \dmd2\windows\bin\shell.exe
    Simple command line shell
    \dmd2\windows\bin\windbg.exe
    Microsoft debugger
    \dmd2\windows\lib\lib
    D runtime library

    Linking

    Linking is done directly by the dmd compiler after a successful compile. To prevent dmd from running the linker, use the -c switch.

    32 bit programs must be linked with the D runtime library phobos.lib, followed by the Digital Mars C runtime library snn.lib. This is done automatically as long as the directories for the libraries are on the LIB environment variable path. A typical way to set LIB would be: 

    set LIB=\dmd2\lib;\dm\lib

    If the dmd command is used to both compile and link to an executable, it will make certain optimizations that are valid only for Windows executable files. Do not use the resulting .obj files in a DLL. To compile modules into .obj files that can be used in an exe or DLL, compile with -c and -shared.

    Linking 32 bit programs is done using Digital Mars link.exe.

    Linking 64 bit programs is done using the Microsoft linker by default. If the Microsoft linker is not found, the included LLVM linker LLD will be used.

    Environment Variables

    The D compiler dmd uses the following environment variables:

    DFLAGS
    The value of DFLAGS is treated as if it were appended to the command line to dmd.exe.
    LIB
    The linker uses LIB to search for library files. For D, it will normally be set to:
    set LIB=\dmd2\lib;\dm\lib
    LINKCMD
    dmd normally runs the linker by looking for link.exe along the PATH. To use a specific linker for 32 bit programs instead, set the LINKCMD environment variable to it. For example:
    set LINKCMD=\dmd\windows\bin\link
    LINKCMD64
    dmd normally runs the linker by looking for link.exe along the PATH. To use a specific linker for 64 bit programs instead, set the LINKCMD64 environment variable to it. For example:
    set LINKCMD64=C:\Program Files (x86)\Microsoft Visual Studio 15.0\VC\bin\amd64\link.exe
    PATH
    If the linker is not found in the same directory as dmd.exe is in, the PATH is searched for it. Note: other linkers named link.exe will likely not work. Make sure the Digital Mars link.exe is found first in the PATH before other link.exe's, or use LINKCMD to specifically identify which linker to use.

    sc.ini Initialization File

    dmd will look for the initialization file sc.ini in the following sequence of directories:

    1. current working directory
    2. directory specified by the HOME environment variable
    3. directory dmd.exe resides in

    If found, environment variable settings in the file will override any existing settings. This is handy to make dmd independent of programs with conflicting use of environment variables.

    Initialization File Format

    Comments are lines that begin with ; and are ignored.

    Environment variables follow the [Environment] section heading, in NAME=value pairs. The NAMEs are treated as upper case. Comments are lines that start with ;. For example: 

    ; sc.ini file for dmd
; Names enclosed by %% are searched for in the existing environment
; and inserted. The special name %@P% is replaced with the path
; to this file.
[Environment]
LIB="%@P%\..\lib";\dm\lib

DFLAGS="-I%@P%\..\src\phobos" "-I%@P%\..\src\druntime\import"
LINKCMD="%@P%\..\..\dm\bin"
DDOCFILE=mysettings.ddoc

    Location Independence of sc.ini

    The %@P% is replaced with the path to sc.ini. Thus, if the fully qualified file name sc.ini is c:\dmd2\bin\sc.ini, then %@P% will be replaced with c:\dmd2\bin, and the above sc.ini will be interpreted as: 

    [Environment]
LIB="c:\dmd2\bin\..\lib";\dm\lib

DFLAGS="-Ic:\dmd2\bin\..\src\phobos" "-Ic:\dmd2\bin\..\src\druntime\import"
LINKCMD="c:\dmd2\bin\..\..\dm\bin"
DDOCFILE=mysettings.ddoc

    This enables your dmd setup to be moved around without having to re-edit sc.ini.

    Common Installation Problems

    Differences between Windows and Linux versions

    D Interface Files

    When an import declaration is processed in a D source file, the compiler searches for the D source file corresponding to the import, and processes that source file to extract the information needed from it. Alternatively, the compiler can instead look for a corresponding D interface file. A D interface file contains only what an import of the module needs, rather than the whole implementation of that module.

    The advantages of using a D interface file for imports rather than a D source file are:

    D interface files can be created by the compiler from a D source file by using the -H switch to the compiler. D interface files have the .di file extension. When the compiler resolves an import declaration, it first looks for a .di D interface file, then it looks for a D source file.

    D interface files bear some analogous similarities to C++ header files. But they are not required in the way that C++ header files are, and they are not part of the D language. They are a feature of the compiler, and serve only as an optimization of the build process.

    Building Executables

    dmd can build an executable much faster if as many of the source files as possible are put on the command line.

    Another advantage to putting multiple source files on the same invocation of dmd is that dmd will be able to do some level of cross-module optimizations, such as function inlining across modules.

    The -i flag can be used to automatically compile imported modules

    Building Libraries

    There are three ways to build a library. For example, given foo.d and bar.d which are to be compiled, and existing object file abc.obj and existing library def.lib which are all to be combined into a library foo.lib:

    1. Compile modules separately and then run the librarian on them: 
      dmd -c foo.d
dmd -c bar.d
lib -c -p32 foo.lib foo.obj bar.obj abc.obj def.lib
del foo.obj bar.obj
      This option is typical when using a makefile to avoid compiling modules that have already been compiled.
    2. Compile modules together and then run the librarian on them: 
      dmd -c foo.d bar.d
lib -c -p32 foo.lib foo.obj bar.obj abc.obj def.lib
del foo.obj bar.obj
    3. Use dmd to compile and build library in one operation: 
      dmd -lib foo.d bar.d abc.obj def.lib
      No object files are written to disk, it's all done in memory. Using -lib also has the advantage that modules may be compiled into multiple object files rather than exactly one per module. This improves granularity of the library without having to break up the modules.

    Compiling dmd

    Complete source code is provided to build the compiler. Follow these steps:

    cd \dmd2\src\dmd
make -f win32.mak

    Compiling Phobos

    Complete source code is provided to build Phobos, the D runtime library. Follow these steps:

    cd \dmd2\src\druntime
make -f win32.mak
cd ..\phobos
make -f win32.mak
    )