Skip site navigation (1)Skip section navigation (2)

FreeBSD Manual Pages

  
 
  

home | help
MOLD(1)			    General Commands Manual		       MOLD(1)

NAME
       mold - a	modern linker

SYNOPSIS
       mold [option...]	file...

DESCRIPTION
       mold is a faster	drop-in	replacement for	the default GNU	ld(1).

   How to use
       See https://github.com/rui314/mold#how-to-use.

   Compatibility
       mold  is	 designed  to be a drop-in replacement for the GNU linkers for
       linking user-land programs. If your user-land program cannot  be	 built
       due   to	  missing   command-line   options,   please  file  a  bug  at
       https://github.com/rui314/mold/issues.

       mold supports a very limited set	of linker script  features,  which  is
       just sufficient to read /usr/lib/x86_64-linux-gnu/libc.so on Linux sys-
       tems  (on Linux,	that file is contrary to its name not a	shared library
       but an ASCII linker script that loads a real libc.so file.)

       Beyond that, we have no plan to support any  additional	linker	script
       features.  The  linker script is	an ad-hoc, over-designed, complex lan-
       guage which we believe needs to be replaced by a	simpler	mechanism.  We
       have a plan to add a replacement	for the	linker script to mold instead.

   Archive symbol resolution
       Traditionally,  Unix  linkers are sensitive to the order	in which input
       files appear on the command line. They process  input  files  from  the
       first  (leftmost)  file	to the last (rightmost)	file one-by-one. While
       reading input files, they maintain sets of defined and  undefined  sym-
       bols.  When  visiting  an archive file (.a files), they pull out	object
       files to	resolve	as many	undefined symbols as possible and move	on  to
       the  next  input	 file. Object files that weren't pulled	out will never
       have a chance for a second look.

       Due to this behavior, you usually have to add archive files at the  end
       of  a  command  line,  so  that when a linker reaches archive files, it
       knows what symbols remain as undefined.

       If you put archive files	at the beginning of a command line,  a	linker
       doesn't	have  any  undefined symbols, and thus no object files will be
       pulled out from archives. You can change	the processing order by	 using
       the  --start-group  and	--end-group options, though they make a	linker
       slower.

       mold, as	well as	the LLVM lld(1)	linker,	takes  a  different  approach.
       They  remember which symbols can	be resolved from archive files instead
       of forgetting them after	processing each	archive. Therefore,  mold  and
       lld(1)  can  "go	 back" in a command line to pull out object files from
       archives	if they	are needed to  resolve	remaining  undefined  symbols.
       They are	not sensitive to the input file	order.

       --start-group and --end-group are still accepted	by mold	and lld(1) for
       compatibility with traditional linkers, but they	are silently ignored.

   Dynamic symbol resolution
       Some  Unix  linker features are difficult to understand without compre-
       hending the semantics of	dynamic	 symbol	 resolution.  Therefore,  even
       though it's not specific	to mold, we'll explain it here.

       We  use	"ELF module" or	just "module" as a collective term to refer to
       an executable or	a shared library file in the ELF format.

       An ELF module may have lists of imported	symbols	and exported  symbols,
       as  well	 as a list of shared library names from	which imported symbols
       should be imported. The point is	that imported symbols are not bound to
       any specific shared library until runtime.

       Here is how the Unix dynamic linker resolves dynamic symbols. Upon  the
       start  of  an  ELF program, the dynamic linker constructs a list	of ELF
       modules which, as a whole, consist of  a	 complete  program.  The  exe-
       cutable file is always at the beginning of the list followed by its de-
       pendent	shared	libraries. An imported symbol is searched from the be-
       ginning of the list to the end. If two or more modules define the  same
       symbol,	the  one  that appears first in	the list takes precedence over
       the others.

       This Unix semantics are contrary	to systems such	as Windows that	have a
       two-level namespace for dynamic symbols.	On Windows, for	 example,  dy-
       namic  symbols  are  represented	as a tuple of (symbol-name, shared-li-
       brary-name), so that each dynamic symbol	is guaranteed to  be  resolved
       from some specific library.

       Typically,  an  ELF  module that	exports	a symbol also imports the same
       symbol. Such a symbol is	usually	resolved to itself, but	that's not the
       case if a module	that appears before it in the symbol search list  pro-
       vides another definition	of the same symbol.

       Let's take malloc as an example.	Assume that you	define your version of
       malloc  in  your	 main executable file. Then, all malloc	calls from any
       module are resolved to your function instead of the one	in  libc,  be-
       cause  the  executable is always	at the beginning of the	dynamic	symbol
       search list. Note that even malloc calls	within libc  are  resolved  to
       your  definition	 since	libc exports and imports malloc. Therefore, by
       defining	malloc yourself, you can overwrite a library function, and the
       malloc in libc becomes dead code.

       These Unix semantics are	tricky and sometimes considered	 harmful.  For
       example,	 assume	that you accidentally define atoi as a global function
       in your executable that behaves completely differently from the one  in
       the  C  standard.  Then,	all atoi function calls	from any modules (even
       function	calls within libc) are redirected to your function instead  of
       the  one	 in  libc,  which  will	very likely cause a problem. That is a
       somewhat	surprising consequence for an accidental name conflict.	On the
       other hand, this	semantic is sometimes useful because it	 allows	 users
       to  override  library  functions	 without rebuilding modules containing
       them.

       Whether good or bad, you	should keep these semantics in mind to	under-
       stand Unix linkers' behaviors.

   Build reproducibility
       mold's  output  is  deterministic. That is, if you pass the same	object
       files and the same command-line options to the same version of mold, it
       is guaranteed that mold produces	the bit-for-bit	identical output.  The
       linker's	 internal  randomness, such as the timing of thread scheduling
       or iteration orders of hash tables, doesn't affect the output.

       mold does not have any host-specific default settings. This is contrary
       to the GNU linkers, for which some configurable values,	such  as  sys-
       tem-dependent  library  search paths, are hard-coded. mold depends only
       on its command-line arguments.

OPTION NOTATIONS
       Multi-letter long options may precede either a single  dash  or	double
       dashes,	except	for those starting with	the letter "o".	For historical
       reasons,	long options beginning with "o"	must precede double dashes.

       For example, you	can spell --as-needed as -as-needed, but --omagic must
       not be spelled as -omagic. -omagic will be interpreted not as  --omagic
       but as -o magic.

MOLD-SPECIFIC OPTIONS
       --chroot=dir
	      Set dir as the root directory.

       --color-diagnostics=[ auto | always | never ]
	      Show  diagnostic	messages in color using	ANSI escape sequences.
	      auto means that mold prints out messages in color	 only  if  the
	      standard output is connected to a	TTY. Default is	auto.

       --color-diagnostics
	      Synonym for --color-diagnostics=auto.

       --no-color-diagnostics
	      Synonym for --color-diagnostics=never.

       --detach, --no-detach
	      Permit  or do not	permit mold to create a	debug info file	in the
	      background.

       --fork, --no-fork
	      Spawn a child process and	let it do  the	actual	linking.  When
	      linking  a  large	 program, the OS kernel	can take a few hundred
	      milliseconds to terminate	a mold process.	--fork hides that  la-
	      tency. By	default, it does fork.

       --perf Print performance	statistics.

       --print-dependencies
	      Print out	dependency information for input files.

	      Each line	of the output for this option shows which file depends
	      on  which	 file  to use a	specific symbol. This option is	useful
	      for debugging why	some object  file  in  a  static  archive  got
	      linked  or  why  some shared library is kept in an output	file's
	      dependency list even with	--as-needed.

       --relocatable-merge-sections
	      By default, mold doesn't merge input sections by name when merg-
	      ing input	object files into a single output object file for  -r.
	      For  example,  .text.foo and .text.bar aren't merged for -r even
	      though they are merged into .text	based on the  default  section
	      merging rules.

	      This  option changes the behavior	so that	mold merges input sec-
	      tions by name by the default section merging rules.

       --repro
	      Archive input files, as well as a	text file  containing  command
	      line  options,  in  a tar	file so	that you can run mold with the
	      exact same inputs	again. This is useful for reporting a bug with
	      a	reproducer. The	output filename	is  path/to/output.tar,	 where
	      path/to/output is	an output filename specified by	-o.

       --reverse-sections
	      Reverse  the  order  of input sections before assigning them the
	      offsets in the output file.

	      This option is useful for	finding	bugs that depend on  the  ini-
	      tialization  order  of  global  objects. In C++, constructors of
	      global objects in	a single source	file are guaranteed to be exe-
	      cuted in the source order, but there's no	such guarantee	across
	      compilation units. Usually, constructors are executed in the or-
	      der given	to the linker, but depending on	it is a	mistake.

	      By  reversing  the  order	of input sections using	--reverse-sec-
	      tions, you can easily test that your program works  in  the  re-
	      versed initialization order.

       --run command arg...
	      Run  command with	mold as	/usr/bin/ld. Specifically, mold	runs a
	      given command with the LD_PRELOAD	environment set	 to  intercept
	      exec(3)  family functions	and replaces argv[0] with itself if it
	      is ld, ld.gold, or ld.lld.

       --separate-debug-file, --separate-debug-file=file
	      Bundle debug info	sections into a	separate file instead  of  em-
	      bedding  them  in	an output executable or	a shared library. mold
	      creates a	debug info file	in the background by default, so  that
	      you can start running your executable as soon as possible.

	      By default, the debug info file is created in the	same directory
	      as  is the output	file, with the .dbg file extension. That file-
	      name is embedded into the	output file so that gdb	can  automati-
	      cally  find  the	debug  info file for the output	file. For more
	      info about gdb features related to  separate  debug  files,  see
	      https://sourceware.org/gdb/current/onlinedocs/gdb.html/Sepa-
	      rate-Debug-Files.html.

	      mold holds a file	lock with flock(2) while creating a debug info
	      file in the background.

	      If you don't want	to create a debug info file in the background,
	      pass the --no-detach option.

       --shuffle-sections, --shuffle-sections=number
	      Randomize	 the  output  by shuffling the order of	input sections
	      before assigning them the	offsets	in the output file. If a  num-
	      ber  is given, it's used as a seed for the random	number genera-
	      tor, so that the linker produces the same	output	for  the  same
	      seed. If no seed is given, a random number is used as a seed.

	      This  option  is useful for benchmarking.	Modern CPUs are	sensi-
	      tive to a	program's memory layout. A seemingly benign change  in
	      program  layout,	such as	a small	size increase of a function in
	      the middle of a program, can affect the  program's  performance.
	      Therefore,  even	if you write new code and get a	good benchmark
	      result, it is hard to say	whether	the new	code improves the pro-
	      gram's performance; it is	possible that the  new	memory	layout
	      happens to perform better.

	      By  running  a  benchmark	 multiple times	with randomized	memory
	      layouts using --shuffle-sections,	you can	isolate	your program's
	      real performance number from the	randomness  caused  by	memory
	      layout changes.

       --spare-program-headers=number
	      Append  the  given  number  of PT_NULL entries to	the end	of the
	      program header, so that post-link	processing  tools  can	easily
	      add new segments by overwriting the null entries.

	      Note  that  ELF  requires	 all  PT_LOAD segments to be sorted by
	      p_vaddr. Therefore, if you add a new LOAD	segment, you may  need
	      to sort the entire program header.

       --stats
	      Print input statistics.

       --thread-count=count
	      Use count	number of threads.

       --threads, --no-threads
	      Use  multiple  threads. By default, mold uses as many threads as
	      the number of cores or 32, whichever is smaller. The  reason  it
	      is  capped  at 32	is because mold	doesn't	scale well beyond that
	      point.  To  use  only   one   thread,   pass   --no-threads   or
	      --thread-count=1.

       --quick-exit, --no-quick-exit
	      Use or do	not use	quick_exit to exit.

       -z rewrite-endbr, -z norewrite-endbr
	      As  a  security measure, some CPU	instruction sets have recently
	      gained a feature to protect control flow integrity by  disallow-
	      ing indirect branches by default.	If the feature is enabled, the
	      instruction  that	 is  executed  immediately  after  an indirect
	      branch must  be  an  branch  target  marker  instruction,	 or  a
	      CPU-level	fault will raise. The marker instruction is also known
	      as  "landing  pad"  instruction,	to which indirect branches can
	      land. This feature makes ROP attacks harder to conduct.

	      To use the feature, a function whose pointer is taken  needs  to
	      begin  with a landing pad	because	a function call	via a function
	      pointer is compiled to an	indirect branch. On the	other hand, if
	      a	function is called only	directly (i.e. referred	to only	by di-
	      rect branch instructions), it doesn't have to begin with it.

	      By default, the compiler always emits a landing pad at  the  be-
	      ginning  of each global function because it doesn't know whether
	      or not the function's pointer is taken  in  another  translation
	      unit.  As	a result, the resulting	binary has more	attack surface
	      than necessary.

	      If --rewrite-endbr is  given,  mold  conducts  a	whole  program
	      analysis	to  identify  functions	 whose	addresses are actually
	      taken  and  rewrites  landing  pads  with	 no-ops	 for   non-ad-
	      dress-taken functions, reducing the attack surface.

	      This feature is currently	available only on x86-64.

GNU-COMPATIBLE OPTIONS
       --help Report usage information to stdout and exit.

       -v, --version
	      Report version information to stdout.

       -V     Report version and target	information to stdout.

       -E, --export-dynamic, --no-export-dynamic
	      When  creating  an  executable,  using  the -E option causes all
	      global symbols to	be put into the	dynamic	symbol table, so  that
	      the symbols are visible from other ELF modules at	runtime.

	      By  default,  or	if  --no-export-dynamic	is given, only symbols
	      that are referenced by DSOs at link-time are  exported  from  an
	      executable.

       -F libname, --filter=libname
	      Set the DT_FILTER	dynamic	section	field to libname.

       -I file,	--dynamic-linker=file, --no-dynamic-linker
	      Set  the	dynamic	linker path to file. If	no -I option is	given,
	      or if --no-dynamic-linker	is given, no dynamic  linker  path  is
	      set to an	output file. This is contrary to the GNU linkers which
	      set  a default dynamic linker path in that case. This difference
	      doesn't usually make any difference because the compiler	driver
	      always passes -I to the linker.

       -L dir, --library-path=dir
	      Add  dir	to  the	 list  of library search paths from which mold
	      searches libraries for the -l option.

	      Unlike the GNU linkers, mold does	not have default search	paths.
	      This difference doesn't usually make any difference because  the
	      compiler	driver always passes all necessary search paths	to the
	      linker.

       -M, --print-map
	      Write a map file to stdout.

       -N, --omagic, --no-omagic
	      Force mold to emit an output file	with an	 old-fashioned	memory
	      layout.  First, it makes the first data segment not aligned to a
	      page boundary. Second, text segments are marked as  writable  if
	      the option is given.

       -S, --strip-debug
	      Omit .debug_* sections from the output file.

       -T file,	--script=file
	      Read linker script from file.

       -X, --discard-locals
	      Discard  temporary local symbols to reduce the sizes of the sym-
	      bol table	and the	string table. Temporary	local symbols are  lo-
	      cal  symbols  starting  with .L. Compilers usually generate such
	      symbols for unnamed program elements such	as string literals  or
	      floating-point literals.

       -e symbol, --entry=symbol:

       -f shlib, --auxiliary=shlib
	      Set the DT_AUXILIARY dynamic section field to shlib.

       -h libname, --soname=libname
	      Set  the DT_SONAME dynamic section field to libname. This	option
	      is used when creating a shared object file. Typically, when  you
	      create libfoo.so,	you want to pass --soname=foo to a linker.

       -l libname
	      Search  for  liblibname.so  or  liblibname.a from	library	search
	      paths.

       -m target
	      Choose a target.

       -o file,	--output=file
	      Use file as the output file name instead	of  the	 default  name
	      a.out.

       -r, --relocatable
	      Instead  of  generating  an  executable or a shared object file,
	      combine input object files to generate another object file  that
	      can be used as an	input to a linker.

       -s, --strip-all
	      Omit .symtab section from	the output file.

       -u symbol, --undefined=symbol
	      If  symbol  remains as an	undefined symbol after reading all ob-
	      ject files, and if there is a static archive  that  contains  an
	      object  file  defining symbol, pull out the object file and link
	      it so that the output file contains a definition of symbol.

       -y symbol, --trace-symbol=symbol
	      Trace references to symbol.

       --Bdynamic
	      Link against shared libraries.

       --Bstatic
	      Do not link against shared libraries.

       --Bsymbolic
	      When creating a shared library, make global symbols  export-only
	      (i.e.  do	 not  import the same symbol). As a result, references
	      within a shared library are always  resolved  locally,  negating
	      symbol  override at runtime. See "Dynamic	symbol resolution" for
	      more information about symbol imports and	exports.

       --Bsymbolic-functions
	      This option has the same effect as --Bsymbolic  but  works  only
	      for  function  symbols.  Data symbols remain being both imported
	      and exported.

       --Bsymbolic-non-weak
	      This option has the same effect as --Bsymbolic  but  works  only
	      for  non-weak  symbols.  Weak symbols remain being both imported
	      and exported.

       --Bsymbolic-non-weak-functions
	      This option has the same effect as --Bsymbolic  but  works  only
	      for  non-weak  function  symbols.	Data symbols and weak function
	      symbols remain being both	imported and exported.

       --Bno-symbolic
	      Cancel --Bsymbolic, --Bsymbolic-functions,  --Bsymbolic-non-weak
	      and --Bsymbolic-non-weak-functions.

       --Map=file
	      Write map	file to	file.

       --Tbss=address
	      Alias for	--section-start=.bss=address.

       --Tdata=address
	      Alias for	--section-start=.data=address.

       --Ttext=address
	      Alias for	--section-start=.text=address.

       --allow-multiple-definition
	      Normally,	the linker reports an error if there are more than one
	      definition of a symbol. This option changes the default behavior
	      so that it doesn't report	an error for duplicate definitions and
	      instead use the first definition.

       --allow-shlib-undefined,	--no-allow-shlib-undefined
	      Even if mold succeeds in linking a main executable without unde-
	      fined  symbol  errors, you may still encounter symbol lookup er-
	      rors at runtime because the dynamic linker cannot	find some sym-
	      bols in shared libraries in any ELF module. This occurs  because
	      mold ignores undefined symbols in	shared libraries by default.

	      If you pass --no-allow-shlib-undefined, mold verifies that unde-
	      fined symbols in shared libraries	given to the linker can	be re-
	      solved  at  link-time. In	other words, this converts the runtime
	      error to a link-time error.

	      Note that	you need to pass all shared libraries, including indi-
	      rectly dependent ones, to	the linker as arguments	for -l.	 If  a
	      shared  library  depends	on  a library that's not passed	to the
	      linker, the verification will be skipped for that	file.

       --as-needed, --no-as-needed
	      By default, shared libraries given to the	 linker	 are  uncondi-
	      tionally	added  to  the list of required	libraries in an	output
	      file. However, shared libraries after --as-needed	are  added  to
	      the  list	 only when at least one	symbol is actually used	by the
	      output file. In other words, shared libraries after  --as-needed
	      are  not	added  to the list of needed libraries if they are not
	      needed by	a program.

	      The --no-as-needed option	restores the default behavior for sub-
	      sequent files.

       --build-id=[ md5	| sha1 | sha256	| fast | uuid |	0xhexstring | none ]
	      Create a .note.gnu.build-id section containing a byte string  to
	      uniquely identify	an output file.	sha256 compute a 256-bit cryp-
	      tographic	hash of	an output file and set it to build-id. md5 and
	      sha1  compute the	same hash but truncate it to 128 and 160 bits,
	      respectively, before setting it to build-id. uuid	sets a	random
	      128-bit  UUID. 0xhexstring sets hexstring. fast is a synonym for
	      sha256.

       --build-id
	      Synonym for --build-id=sha256.

       --no-build-id
	      Synonym for --build-id=none.

       --compress-debug-sections=[ zlib	| zlib-gabi | zstd | none ]
	      Compress DWARF debug info	(.debug_* sections) using the zlib  or
	      zstd compression algorithm. zlib-gabi is an alias	for zlib.

       --defsym=symbol=value
	      Define symbol as an alias	for value.

	      value  is	 either	 an integer (in	decimal	or hexadecimal with 0x
	      prefix) or a symbol name.	If an integer is  given	 as  a	value,
	      symbol is	defined	as an absolute symbol with the given value.

       --default-symver
	      Use  soname  as  a symbol	version	and append that	version	to all
	      symbols.

       --demangle, --no-demangle
	      Demangle C++ and Rust symbols in log messages.

       --dependency-file=file
	      Write a dependency file to file. The  contents  of  the  written
	      file  is	readable  by make(1), which defines only one rule with
	      the linker's output file as a target and all input files as  its
	      prerequisites.  Users  are expected to include the generated de-
	      pendency file into a Makefile to automate	the dependency manage-
	      ment. This option	is analogous to	the  compiler's	 -MM  -MF  op-
	      tions.

       --dynamic-list=file
	      Read  a  list of dynamic symbols from file. Same as --export-dy-
	      namic-symbol-list, except	that it	implies	--Bsymbolic.  If  file
	      does not exist in	the current directory, it is searched from li-
	      brary search paths for the sake of compatibility with GNU	ld.

       --eh-frame-hdr, --no-eh-frame-hdr
	      Create .eh_frame_hdr section.

       --emit-relocs
	      The  linker usually "consumes" relocation	sections. That is, the
	      linker applies relocations to  other  sections,  and  relocation
	      sections themselves are discarded.

	      The  --emit-relocs instructs the linker to leave relocation sec-
	      tions in the output file.	Some post-link binary analysis or  op-
	      timization tools such as LLVM Bolt need them.

       --enable-new-dtags, --disable-new-dtags
	      By  default,  mold  emits	 DT_RUNPATH  for  --rpath. If you pass
	      --disable-new-dtags, mold	emits DT_RPATH for --rpath instead.

       --execute-only:

       --exclude-libs=libraries	...
	      Mark all symbols in the given libraries hidden.

       --export-dynamic-symbol=symbol
	      Put symbols matching symbol in the dynamic symbol	table.	symbol
	      may be a glob pattern in the same	syntax as for the --export-dy-
	      namic-symbol-list	or --version-script options.

       --export-dynamic-symbol-list=file
	      Read a list of dynamic symbols from file.

       --fatal-warnings, --no-fatal-warnings
	      Treat warnings as	errors.

       --fini=symbol
	      Call symbol at unload-time.

       --gc-sections, --no-gc-sections
	      Remove unreferenced sections.

       --gdb-index
	      Create  a	 .gdb_index  section  to speed up GNU debugger.	To use
	      this, you	need to	compile	source files with  the	-ggnu-pubnames
	      compiler flag.

       --hash-style=[ sysv | gnu | both	| none ]
	      Set hash style.

       --icf=[ safe | all | none ], --no-icf
	      It is not	uncommon for a program to contain many identical func-
	      tions  that  differ  only	 in  name. For example,	a C++ template
	      std::vector is very likely to be instantiated to	the  identical
	      code  for	std::vector<int> and std::vector<unsigned> because the
	      container	cares only about the size of the parameter type. Iden-
	      tical Code Folding (ICF) is a size optimization to identify  and
	      merge such identical functions.

	      If  --icf=all  is	given, mold tries to merge all identical func-
	      tions. This reduces the size of the output most, but it is not a
	      "safe" optimization. It is guaranteed in	C  and	C++  that  two
	      pointers	pointing  two different	functions will never be	equal,
	      but --icf=all breaks that	assumption as two identical  functions
	      have  the	 same  address	after merging. So a care must be taken
	      when you use this	flag that your program does not	depend on  the
	      function pointer uniqueness.

	      --icf=safe  is a flag to merge functions only when it is safe to
	      do so. That is, if a program does	not take an address of a func-
	      tion, it is safe to merge	that function with other function,  as
	      you  cannot compare a function pointer with something else with-
	      out taking an address of a function.

	      --icf=safe needs to  be  used  with  a  compiler	that  supports
	      .llvm_addrsig  section which contains the	information as to what
	      symbols are address-taken. LLVM/Clang supports that  section  by
	      default.	Since  GCC  does  not  support	it yet,	you cannot use
	      --icf=safe with GCC (it doesn't do any harm but  can't  optimize
	      at all.)

	      --icf=none and --no-icf disables ICF.

       --ignore-data-address-equality
	      Make  ICF	to merge not only functions but	also data. This	option
	      should be	used in	combination with --icf=all.

       --image-base=addr
	      Set the base address to addr.

       --init=symbol
	      Call symbol at load-time.

       --no-undefined
	      Report undefined symbols (even with --shared).

       --noinhibit-exec
	      Create an	output file even if errors occur.

       --package-metadata==percent-encoded-string
	      Embed a specified	string into the	 .note.package	section.  This
	      option  is designed for build scripts that generate binary pack-
	      ages, such as .rpm or .deb, to include package metadata in  each
	      executable.  It simplifies the process of	identifying the	corre-
	      sponding package for a given executable or core file.

	      An argument to this option is treated as percent-encoded and de-
	      coded before being inserted into the section,  allowing  you  to
	      avoid  the  use of the comma (,) character in the	argument. This
	      is useful	because	the compiler replaces all occurrences of  com-
	      mas  in  -Wl,  with spaces before	forwarding them	to the linker.
	      Note that	mold always interprets	the  argument  as  percent-en-
	      coded, so	you also need to escape	all occurrences	of % as	%25.

       --pack-dyn-relocs=[ relr	| none ]
	      If  relr is specified, all R_*_RELATIVE relocations are put into
	      .relr.dyn	section	instead	 of  .rel.dyn  or  .rela.dyn  section.
	      Since  .relr.dyn section uses a space-efficient encoding scheme,
	      specifying this flag can reduce the size of the output. This  is
	      typically	most effective for position-independent	executable.

	      Note  that a runtime loader has to support .relr.dyn to run exe-
	      cutables or shared libraries linked with --pack-dyn-relocs=relr.
	      As of 2022, only ChromeOS, Android and Fuchsia support it.

       --pie, --pic-executable,	--no-pie, --no-pic-executable
	      Create a position-independent executable.

       --print-gc-sections, --no-print-gc-sections
	      Print removed unreferenced sections.

       --print-icf-sections, --no-print-icf-sections
	      Print folded identical sections.

       --push-state, --pop-state
	      --push-state  saves   the	  current   values   of	  --as-needed,
	      --whole-archive, --static, and --start-lib. The saved values can
	      be restored by pop-state.

	      --push-state and --pop-state pairs can nest.

	      These  options are useful	when you want to construct linker com-
	      mand line	options	programmatically. For example, if you want  to
	      link  libfoo.so  by as-needed basis but don't want to change the
	      global  state  of	 --as-needed,  you  can	 append	  --push-state
	      --as-needed  -lfoo  --pop-state  to  the linker command line op-
	      tions.

       --relax,	--no-relax
	      Rewrite machine instructions with	more efficient ones  for  some
	      relocations. The feature is enabled by default.

       --require-defined=symbol
	      Like  --undefined,  except the new symbol	must be	defined	by the
	      end of the link.

       --retain-symbols-file=file
	      Keep only	symbols	listed in file.	file is	a text file containing
	      a	symbol name on each line. mold discards	all local  symbols  as
	      well  as	global symbol that are not in file. Note that this op-
	      tion removes symbols only	from .symtab section and does not  af-
	      fect .dynsym section, which is used for dynamic linking.

       --rpath=dir
	      Add dir to runtime search	paths.

       --section-start=section=address
	      Set address to section. address is a hexadecimal number that may
	      start with an optional 0x.

       --shared, --Bshareable
	      Create a share library.

       --spare-dynamic-tags=number
	      Append  the  given  number  of DT_NULL entries to	the end	of the
	      .dynamic section,	so that	post-link processing tools can	easily
	      add new dynamic tags by overwriting the null entries.

       --start-lib, --end-lib
	      Handle object files between --start-lib and --end-lib as if they
	      were  in	an  archive file. That means object files between them
	      are linked only when they	are needed to resolve  undefined  sym-
	      bols.  The  options  are useful if you want to link object files
	      only when	they are needed	but want to avoid the overhead of run-
	      ning ar(3).

       --static
	      Do not link against shared libraries.

       --sysroot=dir
	      Set target system	root directory to dir.

       --trace
	      Print name of each input file.

       --undefined-glob=pattern
	      Synonym for --undefined, except that  --undefined-glob  takes  a
	      glob pattern instead of just a single symbol name.

       --undefined-version, --no-undefined-version
	      By default, mold warns on	a symbol specified by a	version	script
	      or  by --export-dynamic-symbol if	it is not defined. You can si-
	      lence the	warning	by --undefined-version.

       --unique=pattern
	      Don't merge input	sections that match  the  given	 glob  pattern
	      pattern.

       --unresolved-symbols=[ report-all | ignore-all |	ignore-in-object-files
       | ignore-in-shared-libs ]
	      How to handle undefined symbols.

       --version-script=file
	      Read  version  script  from  file. If file does not exist	in the
	      current directory, it is searched	from library search paths  for
	      the sake of compatibility	with GNU ld.

       --warn-common, --no-warn-common
	      Warn about common	symbols.

       --warn-once
	      Only  warn  once	for  each undefined symbol instead of warn for
	      each relocation referring	an undefined symbol.

       --warn-unresolved-symbols, --error-unresolved-symbols
	      Normally,	the linker reports an error  for  unresolved  symbols.
	      --warn-unresolved-symbols	 option	turns it into a	warning. --er-
	      ror-unresolved-symbols option restores the default behavior.

       --whole-archive,	--no-whole-archive
	      When archive files (.a files) are	given to the linker, only  ob-
	      ject  files that are needed to resolve undefined symbols are ex-
	      tracted from them	and linked to an output	file.  --whole-archive
	      changes that behavior for	subsequent archives so that the	linker
	      extracts all object files	and links them to an output. For exam-
	      ple,  if	you  are creating a shared object file and you want to
	      include all archive members  to  the  output,  you  should  pass
	      --whole-archive.	--no-whole-archive restores the	default	behav-
	      ior for subsequent archives.

       --wrap=symbol
	      Make symbol be resolved to __wrap_symbol.	 The  original	symbol
	      can  be resolved as __real_symbol. This option is	typically used
	      for wrapping an existing function.

       -z cet-report=[ warning | error | none ]
	      Intel Control-flow Enforcement Technology	(CET)  is  a  new  x86
	      feature available	since Tiger Lake which is released in 2020. It
	      defines  new instructions	to harden security to protect programs
	      from control hijacking attacks. You can tell the compiler	to use
	      the feature by specifying	the -fcf-protection flag.

	      -z cet-report flag is used to make sure that  all	 object	 files
	      were compiled with a correct -fcf-protection flag. If warning or
	      error  are  given, mold prints out a warning or an error message
	      if an object file	was not	compiled with the compiler flag.

	      mold looks for GNU_PROPERTY_X86_FEATURE_1_IBT bit	and  GNU_PROP-
	      ERTY_X86_FEATURE_1_SHSTK	bit  in	 .note.gnu.property section to
	      determine	whether	or  not	 an  object  file  was	compiled  with
	      -fcf-protection.

       -z now, -z lazy
	      By  default,  functions  referring  to other ELF modules are re-
	      solved by	the dynamic linker when	they are called	for the	 first
	      time.  -z	 now  marks  an	executable or a	shared library file so
	      that all dynamic symbols are resolved when a file	is  loaded  to
	      memory. -z lazy restores the default behavior.

       -z origin
	      Mark object requiring immediate $ORIGIN processing at runtime.

       -z ibt Turn on GNU_PROPERTY_X86_FEATURE_1_IBT bit in .note.gnu.property
	      section  to  indicate that the output uses IBT-enabled PLT. This
	      option implies -z	ibtplt.

       -z ibtplt
	      Generate Intel Branch Tracking (IBT)-enabled PLT	which  is  the
	      default on x86-64. This is the default.

       -z execstack, -z	noexecstack
	      By  default,  the	pages for the stack area (i.e. the pages where
	      local variables reside) are not executable for security reasons.
	      -z execstack makes it executable.	-z  noexecstack	 restores  the
	      default behavior.

       -z keep-text-section-prefix, -z nokeep-text-section-prefix
	      Keep  .text.hot,	.text.unknown,	.text.unlikely,	.text.startup,
	      and .text.exit as	separate sections in the final binary  instead
	      of merging them as .text.

       -z rodynamic
	      Make the .dynamic	section	read-only.

       -z relro, -z norelro
	      Some sections such as .dynamic have to be	writable only during a
	      module  is  being	loaded to memory. Once the dynamic linker fin-
	      ishes its	job, such sections won't be mutated by	anyone.	 As  a
	      security	mitigation,  it	 is  preferred	to  make such segments
	      read-only	during program execution.

	      -z relro puts such sections into a special segment called	relro.
	      The dynamic linker makes a relro segment read-only after it fin-
	      ishes its	job.

	      By default, mold generates a relro segment. -z norelro  disables
	      the feature.

       -z sectionheader, -z nosectionheader
	      -z  nosectionheader  tell	the linker to omit the section header.
	      By default, the linker does not omit the section header.

       -z separate-loadable-segments, -z separate-code,	-z noseparate-code
	      If one memory page contains multiple segments, the page  protec-
	      tion  bits  are  set  in	such  a	way that the needed attributes
	      (writable	or executable) are satisfied for  all  segments.  This
	      usually happens at a boundary of two segments with two different
	      attributes.

	      separate-loadable-segments  adds	paddings between segments with
	      different	attributes so that they	do not share  the  same	 page.
	      This is the default.

	      separate-code adds paddings only between executable and non-exe-
	      cutable segments.

	      noseparate-code does not add any paddings	between	segments.

       -z defs,	-z nodefs
	      Report undefined symbols (even with --shared).

       -z shstk
	      Enforce shadow stack by turning GNU_PROPERTY_X86_FEATURE_1_SHSTK
	      bit  in  .note.gnu.property output section. Shadow stack is part
	      of Intel Control-flow Enforcement	 Technology  (CET),  which  is
	      available	since Tiger Lake (2020).

       -z start_stop_visibility=[ hidden | protected ]
	      If  a  section name is valid as a	C identifier (i.e., it matches
	      /^[_a-zA-Z][_a-zA-Z0-9]*$/), mold	 creates  __start_SECNAME  and
	      __stop_SECNAME symbols to	mark the beginning and end of the sec-
	      tion, where SECNAME is the section name.

	      You can make these marker	symbols	visible	from other ELF modules
	      by  passing  -z start_stop_visibility=protected. Default is hid-
	      den.

       -z text,	-z notext, -z textoff
	      mold by default reports an error if dynamic relocations are cre-
	      ated in read-only	sections. If  -z  notext  or  -z  textoff  are
	      given,  mold  creates such dynamic relocations without reporting
	      an error.	-z text	restores the default behavior.

       -z max-page-size=number
	      Some CPU ISAs support multiple memory page  sizes.  This	option
	      specifies	 the  maximum  page size that an output	binary can run
	      on. In general, binaries built for a larger page size can	run on
	      a	system with a smaller page size, but not vice versa.  The  de-
	      fault  value  is	4 KiB for i386,	x86-64,	and RISC-V, and	64 KiB
	      for ARM64.

       -z nodefaultlib
	      Make the dynamic loader ignore default search paths.

       -z nodelete
	      Mark DSO non-deletable at	runtime.

       -z nodlopen
	      Mark DSO not available to	dlopen(3). This	option makes it	possi-
	      ble for the linker to optimize thread-local variable accesses by
	      rewriting	instructions for some targets.

       -z nodump
	      Mark DSO not available to	dldump(3).

       -z nocopyreloc
	      Do not create copy relocations.

       -z initfirst
	      Mark DSO to be initialized first at runtime.

       -z interpose
	      Mark object to interpose all DSOs	but executable.

       -(, -), -EL, -Onumber, --dc, --dp, --end-group, --no-add-needed,
       --no-copy-dt-needed-entries, --nostdlib,	--rpath-link=Ar	dir,
       --sort-common, --sort-section, --start-group, --warn-constructors,
       --warn-once, --fix-cortex-a53-835769, --fix-cortex-a53-843419, -z com-
       breloc, -z common-page-size, -z nocombreloc
	      Ignored

ENVIRONMENT VARIABLES
       MOLD_JOBS
	      If this variable is set to 1, only one mold process will run  at
	      a	 time. If a new	mold process is	initiated while	another	is al-
	      ready active, the	new process will wait  until  the  active  one
	      completes	before starting.

	      The  primary reason for this environment variable	is to minimize
	      peak memory usage. Since mold is designed	to operate  with  high
	      parallelism,  running multiple mold instances simultaneously may
	      not be beneficial. If you	execute	N instances  of	 mold  concur-
	      rently,  it  could require N times the time and N	times the mem-
	      ory. On the other	hand, running them one after the  other	 might
	      still  take  N  times longer, but	the peak memory	usage would be
	      the same as running just a single	instance.

	      If your build system invokes multiple linker processes  simulta-
	      neously  and  some of them often get killed due to out-of-memory
	      errors, you might	consider setting this environment variable  to
	      1	to see if it addresses the OOM issue.

	      Currently, any value other than 1	is silently ignored.

       MOLD_DEBUG
	      If  this	variable is set	to a non-empty string, mold embeds its
	      command-line options in the output file's	.comment section.

       MOLD_REPRO
	      Setting this variable to a non-empty string has the same	effect
	      as passing the --repro option.

SEE ALSO
       gold(1),	ld(1), elf(5), ld.so(8)

AUTHOR
       Rui Ueyama ruiu@cs.stanford.edu

BUGS
       Report bugs to https://github.com/rui314/mold/issues.

				 January 2025			       MOLD(1)

Want to link to this manual page? Use this URL:
<https://man.freebsd.org/cgi/man.cgi?query=ld.mold&sektion=1&manpath=FreeBSD+Ports+14.3.quarterly>

home | help