DCC64.EXE, the Delphi 64-bit Command Line Compiler

From RAD Studio XE2
Jump to: navigation, search

Go Up to Command Line Utilities Index

DCC64.exe compiles Delphi applications that target the 64-bit Windows platform. DCC64 runs on the 32-bit Windows development platform, so using DCC64 is cross-platform application development, even if you are using a 64-bit Windows development system.

DCC64 Features

  • Native integer types are 64-bit.
  • Pointers are 64-bit.
  • Dynamic arrays have 64-bit indexes.
  • Floating-point operations can be performed in single or double precision. Extended precision floating-point operations are not supported.
  • SHL/SHR behavior: 32-bit integers are shifted in 32-bit space, 64-bit integers are shifted in 64-bit space.
  • Mixed Pascal/assembly code is not supported.

Command Line Help

C:\>dcc64 -h
 Embarcadero Delphi for Win64 compiler version 23.0
 Copyright (c) 1983,2011 Embarcadero Technologies, Inc.
 Syntax: dcc64 [options] filename [options]
   -A<unit>=<alias> = Set unit alias
   -B = Build all units             
   -CC = Console target             
   -CG = GUI target                 
   -D<syms> = Define conditionals   
   -E<path> = EXE/DLL output directory
   -F<offset> = Find error          
   -GD = Detailed map file          
   -GP = Map file with publics      
   -GS = Map file with segments     
   -H = Output hint messages        
   -I<paths> = Include directories  
   -K<addr> = Set image base addr   
   -LE<path> = package .bpl output directory
   -LN<path> = package .dcp output directory
   -LU<package> = Use package       
   -M = Make modified units         
   -N0<path> = unit .dcu output directory
   -NH<path> = unit .hpp output directory
   -NO<path> = unit .obj output directory
   -NB<path> = unit .bpi output directory
   -NS<namespaces> = Namespace search path
   -O<paths> = Object directories   
   -P = look for 8.3 file names also
   -Q = Quiet compile               
   -R<paths> = Resource directories 
   -U<paths> = Unit directories     
   -V = Debug information in EXE    
   -VR = Generate remote debug (RSM)
   -VT = Debug information in TDS   
   -W[+|-|^][warn_id] = Output warning messages
   -Z = Output 'never build' DCPs   
   -$<dir> = Compiler directive     
   --help = Show this help screen   
   --version = Show name and version
   --codepage:<cp> = specify source file encoding
   --default-namespace:<namespace> = set namespace
   --depends = output unit dependency information
   --doc = output XML documentation 
   --drc = output resource string .drc file
   --no-config = do not load default dcc64.cfg file
   --description:<string> = set executable description
   --inline:{on|off|auto} = function inlining control
   --peflags:<flags> = set extra PE Header flags field
   --peoptflags:<flags> = set extra PE Header optional flags field
   --peosversion:<major>.<minor> = set OS Version fields in PE Header (default: 5.0)
   --pesubsysversion:<major>.<minor> = set Subsystem Version fields in PE Header (default: 4.0)
   --peuserversion:<major>.<minor> = set User Version fields in PE Header (default: 0.0)
 Compiler switches: -$<letter><state> (defaults are shown below)
   A8  Aligned record fields         
   B-  Full boolean Evaluation       
   C+  Evaluate assertions at runtime
   D+  Debug information             
   G+  Use imported data references  
   H+  Use long strings by default   
   I+  I/O checking                  
   J-  Writeable structured consts   
   L+  Local debug symbols           
   M-  Runtime type info             
   O+  Optimization                  
   P+  Open string params            
   Q-  Integer overflow checking     
   R-  Range checking                
   T-  Typed @ operator              
   V+  Strict var-strings            
   W-  Generate stack frames         
   X+  Extended syntax               
   Y+  Symbol reference info         
   Z1  Minimum size of enum types    
 Stack size: -$M<minStackSize[,maxStackSize]> (default 16384,1048576)

64-bit Inline Assembler

DCC64.EXE supports 64-bit assembly code, with some limitations. Routines must be written completely in Delphi or in assembler (no mixing is allowed).

Pseudo-ops are provided to manage the stack. These are described in the following table.

Pseudo-op Description


Use this pseudo-instruction when calling external functions. This pseudo-instruction maps the function parameters in accordance with the x64 calling convention. When used, a pseudo-variable, @params, is available for passing stack parameters to called functions. Use @params as a byte array where the first stack parameter is @params[32], locations 0-31 represent the 4 register parameters.


Generates code to save and restore the non-volatile general purpose register in prologue and epilogue.


Has the same functionality as .PUSHNV REG, except that .SAVENV XMM# is for non-volatile XMM registers.


Forcibly disables the generation of a stack frame as long as there are no local variables declared and the parameter count is less than 4. Use only for "leaf" functions.

See Also