# Linker

The linker merges object and archive files into executable images, relocating the program data to their final locations in memory and resolving the symbol references both within and between files.

The linker supports most, but not all, features in the Hexagon GNU linker.

## Command

To start the linker from the command line:

hexagon-link [<option>...] [<input_file>...]
    Copy to clipboard

Where `option` is one or more of the following:

@<file>
    --allow-multiple-definition
    --as-needed                   | --no-as-needed
    -Bdynamic                     | -dy
    -Bshareable                   | -shared
    -Bstatic                      | -dn  | -non_shared  | -static
    -Bsymbolic
    -build-id=style
    --cache-file <filename>
    -cref
    -d
    --defsym <symbol=expression>
    --demangle-style <style>
    -discard-all
    -discard-locals
    --dynamic-linker=<file>
    --dynamic-list=<file>
    -eh-frame-hdr
    --entry=<entry>                 | -e <entry>
    --export-dynamic              | -E
    -extern-list=<file>
    --global-merge-non-alloc-strings
    -fatal-warnings               | -no-fatal-warnings
    -filetype=(obj|dso|exe)
    -fini=<name>
    --force-dynamic
    -fPIC
    -g
    --gc-sections
    -gpsize <size>                  | -G <size>
    -hash-size=size
    -hash-style=(sysv|gnu|both)
    --help
    --image-base=<address>
    -init=<name>
    -l<archive>
    --library=<namespec>            | -l<namespec>
    --library-path=<searchdir>      | -L<searchdir>
    -m=<emulation>
    -Map=<mapfile>
    -MapDetail <value>
    -MapStyle <value>
    -march=<version>                | -mcpu=<version>
    -merge-strings
    -mtriple=(hexagon-unknown-elf|hexagon-unknown-linux)
    -mv67 | -mv67t | -mv68 | -mv69 | -mv71 | -mv71t | -mv73
    --no-threads
    -no-trampolines
    -no-undefined
    -noinhibit-exec
    -nostdlib
    --output=<output>               | -o <output>
    -p
    --print-gc-sections
    --print-map                   | -M
    --progress-bar
    --relocatable                 | -r
    -relocation-model=(default|static|pic|dynamic-no-pic)
    --reproduce <file>
    --reproduce-compressed <file>
    -rpath-<pathname>
    -rpath-link=<pathname>
    -save-temps
    -save-temps[=<directory>]      |
    --save-temps[=directory>]
    --script=<file>                 | -T <file>
    --section-start section=<org>
    -soname=<name>                  | -h <name>
    --start-group=<archive> ... --end-group | -( <archive> ... -)
    --strip-all
    --strip-debug                 | -S
    -symdef <file>
    -sysroot=<pathname>
    --trace-symbol <symbolname>   | -trace=symbol=<symbolname>
    --trace=<type>                  | -t=<type>
    --trace-lto
    --trace=reloc=<relocname>     | -trace-reloc <reloc>
    --trace=section=<sectionname> | -trace-section <sectionname>
    --trace-merge-strings=<all|allocatable_sections|section>
    --trace=symdef
    --undefined=<symbol>            | -u <symbol>
    --unresolved-symbols=method
    -use-memory
    -version
    --version-script=file
    --whole-archive               | --no-whole-archive
    --wrap=<symbol>
    -z <keyword>
    Copy to clipboard

Except for the command name, the linker is invoked like the GNU linker, and it supports the most commonly-used options in the GNU linker.

Arguments specified on the command line with no option switch are assumed to be input files. The input files can be object files, linker scripts, or static libraries. Static libraries are a collection of object files and are created using the **ar** program. The linker supports both ordinary archives and thin archives. If the linker cannot recognize an input file as either an object file or a static library, then it treats it as a linker script file (see [Linker scripts](https://docs.qualcomm.com/doc/80-N3040-23/topic/linker.html#hu-linker-linker-scripts)).

Note

The `@file` option allows linker options and input files to be specified in a text file rather than directly on the command line.

## Options

Option names can be truncated if they uniquely identify the option. For example, `-allow- multiple-def` can be used instead of `-allow-multiple-definition`.

@<file>
    Copy to clipboard

Include linker command arguments from the specified text file.

--allow-multiple-definition
    Copy to clipboard

Allow multiple definitions of a symbol to exist in the files being linked.

Only the first definition is used; the additional ones are ignored. Typically, the linker flags multiple symbol definitions with an error.

--as-needed
    --no-as-needed
    Copy to clipboard

These options are accepted for compatibility with the linker, but they are ignored.

-Bdynamic
    -dy
    Copy to clipboard

Link against dynamic libraries.

This option can be used multiple times. It affects the library searching performed by subsequent occurrences of the `-l` option.

-Bshareable
    -shared
    Copy to clipboard

Create a shared library.

-Bstatic
    -dn
    -non_shared
    -static
    Copy to clipboard

Link against static libraries.

-Bsymbolic
    Copy to clipboard

Bind global symbol references to the symbol definition in a shared library.

-build-id=style
    Copy to clipboard

This option has no effect. It is provided for compatibility with the GNU linker.

--cache-file <filename>
    Copy to clipboard

Describe how input sections were matched to output sections based on the linker script, and speed up subsequent links.

- If a cache file called `<filename>` exists, consume it to speed up linker script rule matching.
- If a cache file does not exist, create a file to be consumed in the next link.

This option has no effect if the link is partial or if a linker script containing rules is not specified.

-cref
    Copy to clipboard

Generate a cross-reference table. The table is written to the standard output.

-d
    Copy to clipboard

Allocate space for common symbols. This is done even if the output is specified as relocatable (using the `-r` option).

--defsym <symbol=expression>
    Copy to clipboard

Create a global symbol in the output file, containing the absolute address given by `expression`. This option can be used multiple times.

The expression is limited to a hexadecimal constant or existing symbol name, with the optional addition or subtraction of a second hexadecimal constant or symbol.

--demangle-style <style>
    Copy to clipboard

Determine whether to demangle C++ symbols in linker map files based on style, where style is one of the following:

- `demangle` - Demangle C++ symbols
- `none` - Do not demangle C++ symbols

-discard-all
    Copy to clipboard

Delete all local symbols from the output file.

-discard-locals
    Copy to clipboard

Delete all temporary local symbols from the output file.

--dynamic-linker=<file>
    Copy to clipboard

Specify a dynamic linker.

--dynamic-list=<file>
    Copy to clipboard

Add symbols to the dynamic symbol table of a dynamic executable.

The specified text file contains one or more lists of symbol names, with each list having the following form:

> 
> 
> {
>     symbol1;
>     symbol2;
>     symbol3;
>     };
>     Copy to clipboard

This option can be used multiple times.

The dynamic symbol table is used by the dynamic loader to resolve external symbols associated with shared libraries.

Note

All symbols in the dynamic symbol table must already be defined in the linker input object files. Otherwise, the linker will generate an error message.

-eh-frame-hdr
    Copy to clipboard

In the output file, create the ELF note section, `.note.gnu.build-id`, and the ELF segment header, `PT_GNU_EH_FRAME`.

--entry=entry
    -e entry
    Copy to clipboard

Use the specified symbol as the program entry point.

--export-dynamic
    -E
    Copy to clipboard

Export all dynamic symbols.

By default, the only dynamic symbols exported are those referenced by dynamic objects that are explicitly specified during linking. Dynamic symbols can be selectively exported with `--dynamic-list`.

This option automatically enables `--force-dynamic`.

-extern-list=<file>
    Copy to clipboard

Add symbols to the external symbol table of the output file.

The specified text file contains one or more lists of symbol names, with each list having the following form:

> 
> 
> {
>     symbol1;
>     symbol2;
>     symbol3;
>     };
>     Copy to clipboard

This option can be used multiple times.

The external symbol table is used to force additional object files to be linked into the program. The specified symbols are assumed to be defined in archive libraries.

Symbols in the external symbol table are *garbagecollected* during linking.

If the specified symbol is already defined in one of the linker input files, the linker uses that definition and does not add the symbol to the external symbol table; the symbol and its dependencies will not be garbage collected.

Note

This option is equivalent to using multiple `-u` options.

--[no-]fatal-internal-errors
    Copy to clipboard

Disable/enable fatal internal errors. Default behavior: internal errors are non-fatal.

-fatal-warnings
    -no-fatal-warnings
    Copy to clipboard

Convert warnings into fatal errors.

`-no-fatal-warnings` restores the default behavior.

--global-merge-non-alloc-strings
    Copy to clipboard

By default, identical strings across different inputs are merged into a single copy by the linker only if the strings are placed in the same output section. This option allows `non-alloc-strings` to be merged into a single copy even if they are placed in different output sections. This option has no effect for alloc strings.

-filetype=(obj|dso|exe)
    Copy to clipboard

Output file type (not all types are supported on all targets).

> 
> 
> obj
>     Copy to clipboard
> 
> 
> Generate a relocatable object file (`*.o`)
> 
> 
> dso
>     Copy to clipboard
> 
> 
> Generate a dynamic shared object file (`.so`)
> 
> 
> exe
>     Copy to clipboard
> 
> 
> Generate an executable object file (`*.exe`)

-fini=<name>
    Copy to clipboard

Specify the function called when an executable or shared object is unloaded, by setting `DT_FINI`. The default function name is `_fini`.

--force-dynamic
    Copy to clipboard

Force the output file to include dynamic sections.

Force the linker to create dynamic sections. This operation makes a dynamic executable.

-fPIC
    Copy to clipboard

Set the relocation model to PIC. This option is equivalent to `-relocation- model=pic`.

-g
    Copy to clipboard

Generate debug information.

--gc-sections
    Copy to clipboard

Delete all unused input sections from the output file (garbage collection).

Sections are not considered unused if they contain the entry symbol, undefined symbols, or symbols used with dynamic objects or shared libraries.

The deleted sections can be displayed with `--print-gc-sections`.

**Exception**

The retain attribute can be associated with any symbol (`code`, `data`, `bss`). This attribute forces the linker to retain when garbage collection is invoked.

The linker will keep all input sections that are specified by the retain attribute. For more details about the retain attribute, see the *Attributes* chapter in the *Qualcomm Hexagon LLVM C/C++ Compiler User Guide* (80-VB419-8986).

-gpsize <size>
    -G <size>
    Copy to clipboard

Specify the maximum size (in bytes) of data items allocated in the global `bss` section. The default value is 8.

-hash-size=<size>
    Copy to clipboard

This option has no effect. It is provided for compatibility with the GNU linker.

-hash-style=(sysv|gnu|both)
    Copy to clipboard

Specify the hash table type used in the linker.

> 
> 
> sysv
>     Copy to clipboard
> 
> 
> Classic ELF `.hash` section.
> 
> 
> gnu
>     Copy to clipboard
> 
> 
> New-style GNU `.gnu.hash` section.
> 
> 
> both
>     Copy to clipboard
> 
> 
> Both ELF and GNU hash tables.

--help
    Copy to clipboard

Display the list of linker command options.

--image-base=address
    Copy to clipboard

Set the base address of the output image. This address is used as the initial value of the dot symbol in the linker script. If this option is not specified, the base address is set to a target-defined default value.

-init=<name>
    Copy to clipboard

Specify the function called when an executable or shared object is loaded, by setting `DT_INIT`. The default function name is `_init`.

-l<archive>
    Copy to clipboard

Add the specified archive file to the list of files to link. This option can be used multiple times.

--library=<namespec>
    -l<namespec>
    Copy to clipboard

Add the archive or object file specified by namespec to the list of files to link. This option can be used multiple times.

If namespec is in the form of `:filename`, the linker searches the library path for a file called `filename`. Otherwise, it searches the library path for a file called `libnamespec.a`.

The linker can also search for files on systems that support shared libraries. The linker searches a directory for a library called `libnamespec.so` before searching for one called `libnamespec.a` (by convention, the SO extension indicates a shared library). However, this behavior does not apply to `:filename`, which always specifies a file called `filename`.

The `--Bdynamic` or `-dy` switch can be used to switch the linker to search shared libraries.

The `-Bstatic` switch can be used to switch the linker to search for archive libraries.

--library-path=<searchdir>
    -L<searchdir>
    Copy to clipboard

Add the specified path name to the list of paths used to search for libraries and scripts. This option can be used multiple times.

-m=<emulation>
    Copy to clipboard

This option has no effect. It is provided for compatibility with the GNU linker.

-Map=<mapfile>
    Copy to clipboard

Generate a link map file with the specified file name.

-MapDetail <value>
    Copy to clipboard

Provide path conversion or string details in the map file.

The `<value>` argument can be one of the following options.

- `absolute-path` - Convert all input file paths to absolute paths in the Map file.
- `show-strings` - If a symbol points to a string section type, display that string in the map file when `show-strings` is enabled.
- `show-debug-strings` - The map file lists strings that were merged with each other, but debug strings are excluded by default in order to reduce map file size. This option includes string merges for debug strings in the map file.

-MapStyle <value,...>
    Copy to clipboard

Set the format of the link map file.

This option can accept multiple comma-separated values to generate map files in multiple formats. The argument can be one of the following:

- Any combination of:

    - `txt` - Generates the map file in text format. (Default)
    - `yaml` - Generates the map file in YAML format.
    - `binary` - Generates the map file in binary format using the protocol buffer binary encoding.
- `all` - Generates link map files in all the supported formats.

The map file name provided is taken by the default style map file. If multiple map styles are provided, a map file is generated for each non-default map style with an extension added to the map file name. For example, `-Map m -MapStyle txt,binary` creates a text map file with name `m` and `a` binary style map file with name `m.bin`. The non-default style extensions for the map file created are:

- txt - `<name>.txt`
- binary - `<name>.bin`
- yaml - `<name>.yaml`

-march=<version>
    -mcpu=<version>
    Copy to clipboard

Specify the Hexagon processor version of the linker output file. The default value is the version specified in the first input file.

For more information, see the *Qualcomm Hexagon Programmer’s Reference Manual*.

Note

Not all of the -march and -mcpu option settings are supported in a specific Hexagon tools release. For more information, see [Processor versions](https://docs.qualcomm.com/doc/80-N3040-23/topic/utilities-ug-overview.html#hu-processor-versions).

-mtriple=(hexagon-unknown-elf|hexagon-unknown-linux)
    Copy to clipboard

Specify the target triple (processor, operating system, ABI) of the linker output.

-mv68
    Copy to clipboard

Equivalent to `-march hexagonv68`.

-mv69
    Copy to clipboard

Equivalent to `-march hexagonv69`.

-mv71
    Copy to clipboard

Equivalent to `-march hexagonv71`.

-mv71t
    Copy to clipboard

Equivalent to `-march hexagonv71t` (Small Core).

-mv73
    Copy to clipboard

Equivalent to `-march hexagonv73`.

-mv75
    Copy to clipboard

Equivalent to `-march hexagonv75`.

-mv77
    Copy to clipboard

Equivalent to `-march hexagonv77`.

-mv79
    Copy to clipboard

Equivalent to `-march hexagonv79`.

--no-threads
    Copy to clipboard

Disable threads at link time.

-no-trampolines
    Copy to clipboard

Do not add trampolines to the linked code.

-no-undefined
    Copy to clipboard

Do not allow unresolved references in the linked code.

-noinhibit-exec
    Copy to clipboard

Do not delete the output file after a linker error.

-nostdlib
    Copy to clipboard

Search only the library directories that are specified on the command line.

--output=<output>
    -o <output>
    Copy to clipboard

Specify the linker output file. The default name is `a.out`.

-p
    Copy to clipboard

This option has no effect. It is provided for compatibility with the Arm linker.

--print-gc-sections
    Copy to clipboard

Display all sections that were removed by garbage collection during linking. Use this option in conjunction with `-gc-sections`.

--print-map
    -M
    Copy to clipboard

Generate a link map file that provides information on how the object files were linked. For more information, see [Link maps](https://docs.qualcomm.com/doc/80-N3040-23/topic/linker.html#hu-linker-link-maps).

--progress-bar
    Copy to clipboard

Display the progress of the current operation. For a usage example, see [-reproduce options](https://docs.qualcomm.com/doc/80-N3040-23/topic/linker.html#hu-linker-options-examples-reproduce-options).

--relocatable
    -r
    Copy to clipboard

Create a relocatable object. The default object is an absolute file.

-relocation-model=(default|static|pic|dynamic-no-pic)
    Copy to clipboard

Specify a relocation model, which can be one of the following options.

> 
> 
> default
>     Copy to clipboard
> 
> 
> Target default relocation model
> 
> 
> static
>     Copy to clipboard
> 
> 
> Non-relocatable code
> 
> 
> pic
>     Copy to clipboard
> 
> 
> Fully relocatable, position-independent code.
> 
> 
> dynamic-no-pic
>     Copy to clipboard
> 
> 
> Relocatable external references, non-relocatable code.

--reproduce <file>
    Copy to clipboard

Create a tar archive of all input files and dependencies, and use the archive to inspect issues. For a usage example, see [-reproduce options](https://docs.qualcomm.com/doc/80-N3040-23/topic/linker.html#hu-linker-options-examples-reproduce-options).

--reproduce-compressed <file>
    Copy to clipboard

Create a zlib-compressed tar archive of all input files and dependencies, and use the archive to inspect issues. For a usage example, see [-reproduce options](https://docs.qualcomm.com/doc/80-N3040-23/topic/linker.html#hu-linker-options-examples-reproduce-options).

This option is available only on Linux.

-rpath-<pathname>
    Copy to clipboard

Add the specified path name to the search path for the runtime library. For a usage example, see [Use -rpath option](https://docs.qualcomm.com/doc/80-N3040-23/topic/linker.html#hu-linker-options-examples-rpath-option).

-rpath-link=<pathname>
    Copy to clipboard

This option has no effect. It is provided for compatibility with the GNU linker.

-save-temps
    --save-temps
    --save-temps=directory
    Copy to clipboard

Save the temporary files produced by LTO. If a directory is specified, temporary files are saved in that directory. Otherwise, they are saved in the same directory as the output file.

--script=<file>
    -T <file>
    Copy to clipboard

Specify the linker script file (see [Linker scripts](https://docs.qualcomm.com/doc/80-N3040-23/topic/linker.html#hu-linker-linker-scripts)).

--section-start section=<org>
    Copy to clipboard

Set the start address of the specified section. The org value must be a hexadecimal integer.

This option can be repeated multiple times.

-soname=<name>
    -h <name>
    Copy to clipboard

Set the internal name of a shared library by setting `DT_SONAME`.

--start-group=<archive> - --end-group
    -( <archive> ... -)
    Copy to clipboard

Resolve circular symbol references in the specified files and libraries.

Because the linker must repeatedly search the libraries to resolve circular references, this option significantly affects the linker performance. Use it only when circular symbol references are present.

Specify files and libraries by placing them between the `-(` and `-)` options or the `--start-group` and `--end-group` options.

--strip-all
    Copy to clipboard

Do not include any symbol information in the output file.

--strip-debug
    -S
    Copy to clipboard

Do not include debugger symbols in the output file.

-symdef <file>
    Copy to clipboard

Specify a file that the linker emits after processing all the input files when it is ready to output the ELF file.

The symdef file contains all global symbols and their addresses. The file can later be used in a subsequent link, and the linker uses the symbols specified in the file as absolute symbols.

-sysroot=<pathname>
    Copy to clipboard

Specify the system root directory, overriding the `configure-time` default.

This option is useful only in Linux.

--trace-symbol <symbolname>
    -trace=symbol=<symbolname>
    Copy to clipboard

Make the linker trace the symbol name from all input files.

If no exact match is found, the argument is treated as a regular expression.

--trace=<type>
    -t=<type>
    Copy to clipboard

Display trace information that indicates how the files are being linked. The following types of information can be displayed.

- `command-line` - Display linker options specified on the command line
- `file` - Display files specified for linking
- `garbage-collection` - Display garbage collection performed during linking
- `lto` - Display information about various stages of lto
- `clade` - Display clade operation information performed during linking
- `dynamic-linking` - Display dynamic linking operations performed by the linker
- `merge-strings=<all|allocatable_sections|section>` - Show how duplicate strings were merged for:

    - All sections: `--trace=merge-strings=all`
    - Allocatable sections only: `--trace=merge-strings=all`
    - Strings going into a specific output section: `--trace=merge-strings=<section>`
    - Alias: `trace-merge-strings=<all|allocatable_sections|section>`
- `plugin` - Display various plug-in load/unload and execution operations
- `symbols` - Display program symbols processed by the linker, and indicate how they are resolved
- `sym-reloc` - Display symbol relocation performed by the linker
- `trampolines` - Display details on trampolines created by the linker
- `wrap-symbols` - Display symbols that rename information to support the `--wrap` option

    - `linker-script` - Display linker script operation performed by the linker
    - `live-edges` - Display reachable sections when garbage collection is enabled during linking
    - `all-symbols` - Display symbol resolution information for all the symbols
    - `symdef` - Display usage of symdef files for symbol resolution
    - `threads` - Display threads information during linking

This option can be repeated multiple times.

--trace-lto
    Copy to clipboard

Display verbose information describing stages of lto.

This option is an alias for `--trace=lto`.

--trace=reloc=<relocname>
    -trace-reloc <reloc>
    Copy to clipboard

Display verbose information about a particular relocation for all input files.

If no exact match is found, the argument is treated as a regular expression.

--trace=section=<sectionname>
    -trace-section <sectionname>
    Copy to clipboard

Display verbose information about a particular section from all input files.

If no exact match is found, the argument is treated as a regular expression.

--undefined=<symbol>
    -u <symbol>
    Copy to clipboard

Add the specified symbol to the external symbol table of the output file. This is typically done to force additional object files to be linked into a program.

Note

Symbols in the external symbol table are garbage collected during linking.

If the specified symbol is already defined in one of the linker input files, the linker uses that definition and does not add the symbol to the external symbol table. The symbol and its dependencies will not be garbage collected.

This option can be repeated multiple times.

--unique-output-sections
    Copy to clipboard

For partial links, place each input section in its own output section. This option has no effect for other link modes.

--unresolved-symbols=<method>
    Copy to clipboard

Determine how to handle unresolved symbols.

There are four possible values for `method`.

- `ignore-all` - Do not report any unresolved symbols.
- `report-all` - Report all unresolved symbols. (Default)
- `ignore-in-object-files` - Report unresolved symbols that are contained in shared libraries, but ignore them if they come from regular object files.
- `ignore-in-shared-libs` - Report unresolved symbols that come from regular object files, but ignore them if they come from shared libraries.

    This value can be useful when creating a dynamic binary and it is known that all the shared libraries that it should be referencing are included on the linker command line.

-use-memory
    Copy to clipboard

Use the memory buffer for linker operations.

--warn-limit=<value>
    Copy to clipboard

Maximum number of warnings to emit (0 = no limit)

-W<warn-type>
    Copy to clipboard

Print warnings which are OFF by default

-Wall
    Copy to clipboard

Print all warnings

-W[no-]linker-script
    Copy to clipboard

Display warnings detected while parsing linker scripts

-W[no]attribute-mix
    Copy to clipboard

Display a warning if object files of RISC-V with different attributes are being linked

-W[no-]archive-file
    Copy to clipboard

Display warnings detected while reading archive files

-W[no-]linker-script-memory
    Copy to clipboard

Display warnings detected while processing linker script memory command

-version
    Copy to clipboard

Display the linker release version.

--version-script=file
    Copy to clipboard

Control symbols to be exported in a dynamic symbol table.

--whole-archive
    --no-whole-archive
    Copy to clipboard

Link into the program every object file that is contained in the specified archives.

Archives are specified by appearing between the `--whole-archive` and `--no-whole-archive` options.

--wrap=<symbol>
    Copy to clipboard

Create a wrapper for the specified symbol.

Resolve any undefined references to the symbol as references to wrap\_symbol, and resolve any undefined references to the symbol real\_symbol as references to symbol.

This option can be repeated multiple times.

-z <keyword>
    Copy to clipboard

Extended options for the linker, where `keyword` is one of the following suboptions. For usage examples, see [Use -z suboptions](https://docs.qualcomm.com/doc/80-N3040-23/topic/linker.html#hu-linker-options-examples-use-z-suboptions).

> 
> 
> clade-file=<file>
>     Copy to clipboard
> 
> 
> Set the CLADE file name.
> 
> 
> combreloc
>     Copy to clipboard
> 
> 
> Merge dynamic relocations into one section and sort them.
> 
> 
> nocombreloc
>     Copy to clipboard
> 
> 
> Do not merge dynamic relocations into one section.
> 
> 
> global
>     Copy to clipboard
> 
> 
> Make symbols in a dynamic shared object available for subsequently loaded objects.
> 
> 
> defs
>     Copy to clipboard
> 
> 
> Report unresolved symbols in object files.
> 
> 
> muldefs
>     Copy to clipboard
> 
> 
> Allow multiple definitions.
> 
> 
> initfirst
>     Copy to clipboard
> 
> 
> This option is ignored.
> 
> 
> nocopyreloc
>     Copy to clipboard
> 
> 
> Do not create copy relocations.
> 
> 
> nodefaultlib
>     Copy to clipboard
> 
> 
> This option is ignored.
> 
> 
> relro
>     Copy to clipboard
> 
> 
> Create a RELRO program header.
> 
> 
> norelro
>     Copy to clipboard
> 
> 
> Do not create a RELRO program header.
> 
> 
> lazy
>     Copy to clipboard
> 
> 
> Mark an object as lazy runtime binding.
> 
> 
> When generating an executable or shared library, this option tells the dynamic linker to defer a function call resolution to the point when the function is called (lazy binding) rather than at load time. Lazy binding is the default setting.
> 
> 
> now
>     Copy to clipboard
> 
> 
> Mark an object as immediate runtime binding. When generating an executable or shared library, this option tells the dynamic linker to bind references immediately.
> 
> 
> origin
>     Copy to clipboard
> 
> 
> This option is ignored.
> 
> 
> text
>     Copy to clipboard
> 
> 
> Treat `DT_TEXTREL` in a shared object as an error.
> 
> 
> execstack
>     Copy to clipboard
> 
> 
> Mark an executable as requiring an executable stack.
> 
> 
> noexecstack
>     Copy to clipboard
> 
> 
> Mark an executable as not requiring an executable stack.
> 
> 
> common-page-size=<value>
>     Copy to clipboard
> 
> 
> Set the emulation common page size to a specified value.
> 
> 
> max-page-size=SIZE
>     Copy to clipboard
> 
> 
> Set maximum page size to `SIZE`.
> 
> 
> nodelete
>     Copy to clipboard
> 
> 
> Mark a dynamic shared object as non-deletable at runtime.
> 
> 
> compactdyn
>     Copy to clipboard
> 
> 
> Reduce the number of entries in the dynamic table.

### Examples

#### Unique output sections

The `-unique-output-sections` option may be used for a partial link step if it is required for input sections to remain as granular as possible for the final link step. For example, the profile-based section sorting plug-in can produce better results if input sections are granular. The linker may be able to garbage collect more symbols if this option is used.

Example usage:

$ cat 1.c
    extern int bar();
    int foo() {return bar();}
    
    $ cat 2.c
    int bar() {return 0;}
    
    $ cat 3.c
    int baz() {return 0;}
    
    $ cat script.t
    SECTIONS {
      .text : {
        *(.text.*)
      }
    }
    
    $ hexagon-clang -c 1.c 2.c 3.c -ffunction-sections
    $ hexagon-link 1.o 2.o 3.o -r -T script.t -o merged.o
    $ hexagon-link 1.o 2.o 3.o -r -T script.t --unique-output-sections -o unique.o
    Copy to clipboard

**layout of merged.o (without unique output sections)**

$ hexagon-llvm-readelf -S merged.o
    There are 9 section headers, starting at offset 0x2a0:
    
    Section Headers:
      [Nr] Name                Type            Address  Off    Size   ES Flg Lk Inf Al
      [ 0]                     NULL            00000000 000034 000000 00      0   0  0
      [ 1] .text               PROGBITS        00000000 000040 00002c 00  AX  0   0 16
      [ 2] .comment            PROGBITS        00000000 00006c 0000be 01  MS  0   0  1
      [ 3] .note.GNU-stack     PROGBITS        00000000 00012a 000000 00      0   0  1
      [ 4] .note.llvm.cgmdinfo NOTE            00000000 00012a 000032 00      0   0  1
      [ 5] .rela.text          RELA            00000000 00015c 00000c 0c   I  7   1  4
      [ 6] .shstrtab           STRTAB          00000000 000168 000059 00      0   0  1
      [ 7] .symtab             SYMTAB          00000000 0001c4 0000a0 10      8   7  4
      [ 8] .strtab             STRTAB          00000000 000264 00003c 00      0   0  1
    
    Key to Flags:
      W (write), A (alloc), X (execute), M (merge), S (strings), I (info),
      L (link order), O (extra OS processing required), G (group), T (TLS),
      C (compressed), x (unknown), o (OS specific), E (exclude),
      R (retain), p (processor specific)
    Copy to clipboard

**layout of unique.o (with -unique-output-sections)**

$ hexagon-llvm-readelf -S unique.o
    There are 15 section headers, starting at offset 0x3c0:
    
    Section Headers:
      [Nr] Name                Type            Address  Off    Size   ES Flg Lk Inf Al
      [ 0]                     NULL            00000000 000034 000000 00      0   0  0
      [ 1] .text               PROGBITS        00000000 000040 00000c 00  AX  0   0 16
      [ 2] .text               PROGBITS        00000000 000050 00000c 00  AX  0   0 16
      [ 3] .text               PROGBITS        00000000 000060 00000c 00  AX  0   0 16
      [ 4] .comment            PROGBITS        00000000 00006c 000056 01  MS  0   0  1
      [ 5] .note.GNU-stack     PROGBITS        00000000 0000c2 000000 00      0   0  1
      [ 6] .note.llvm.cgmdinfo NOTE            00000000 0000c2 000032 00      0   0  1
      [ 7] .note.GNU-stack     PROGBITS        00000000 0000f4 000000 00      0   0  1
      [ 8] .note.GNU-stack     PROGBITS        00000000 0000f4 000000 00      0   0  1
      [ 9] .comment            PROGBITS        00000000 0000f4 000081 01  MS  0   0  1
      [10] .note.qc.reloc.section.map NOTE     00000000 000175 00002a 00      0   0  1
      [11] .rela.text          RELA            00000000 0001a0 00000c 0c   I 13   1  4
      [12] .shstrtab           STRTAB          00000000 0001ac 0000a9 00      0   0  1
      [13] .symtab             SYMTAB          00000000 000258 0000e0 10     14  11  4
      [14] .strtab             STRTAB          00000000 000338 00006c 00      0   0  1
    Copy to clipboard

The input `.text` sections are merged into a single output `.text` section in the `merged.o` file produced without `-unique-output-sections`. With `--unique-output-sections`, each output section contains exactly one input section, which is why we have three `.text` sections—one for each input `.text` section.

In the final link step, the linker is able to garbage collect the unreferenced baz symbol for `unique.o` but not for `merged.o`.

$ hexagon-link merged.o -e foo --gc-sections -o merged.out
    $ hexagon-link unique.o -e foo --gc-sections -o unique.out
    $ hexagon-llvm-readelf -s merged.out
    
    Symbol table '.symtab' contains 12 entries:
       Num:    Value  Size Type    Bind   Vis       Ndx Name
         0: 00000000     0 NOTYPE  LOCAL  DEFAULT   UND
         1: 00000000     0 SECTION LOCAL  DEFAULT     1 .text
         2: 00000000     0 SECTION LOCAL  DEFAULT     2 .comment
         3: 00000000     0 SECTION LOCAL  DEFAULT     3 .note.llvm.cgmdinfo
         4: 00000000     0 FILE    LOCAL  DEFAULT   ABS 1.c
         5: 00000000     0 FILE    LOCAL  DEFAULT   ABS 2.c
         6: 00000000     0 FILE    LOCAL  DEFAULT   ABS 3.c
         7: 00000000    12 FUNC    GLOBAL DEFAULT     1 foo
         8: 00000000     0 NOTYPE  GLOBAL DEFAULT   ABS _MSG_BASE_
         9: 00000010    12 FUNC    GLOBAL DEFAULT     1 bar
        10: 00000020    12 FUNC    GLOBAL DEFAULT     1 baz
        11: 00000031     0 NOTYPE  GLOBAL DEFAULT   ABS __end
    
    $hexagon-llvm-readelf -s unique.out
    Symbol table '.symtab' contains 11 entries:
       Num:    Value  Size Type    Bind   Vis       Ndx Name
         0: 00000000     0 NOTYPE  LOCAL  DEFAULT   UND
         1: 00000000     0 SECTION LOCAL  DEFAULT     1 .text
         2: 00000000     0 SECTION LOCAL  DEFAULT     2 .comment
         3: 00000000     0 SECTION LOCAL  DEFAULT     3 .note.llvm.cgmdinfo
         4: 00000000     0 FILE    LOCAL  DEFAULT   ABS 1.c
         5: 00000000     0 FILE    LOCAL  DEFAULT   ABS 2.c
         6: 00000000     0 FILE    LOCAL  DEFAULT   ABS 3.c
         7: 00000000    12 FUNC    GLOBAL DEFAULT     1 foo
         8: 00000000     0 NOTYPE  GLOBAL DEFAULT   ABS _MSG_BASE_
         9: 00000010    12 FUNC    GLOBAL DEFAULT     1 bar
        10: 00000021     0 NOTYPE  GLOBAL DEFAULT   ABS __end
    Copy to clipboard

The `merged.out` file contains the unreferenced baz symbol while the `unique.out` file does not.

#### -reproduce options

This section provides an example of using the reproduce options to create a tar archive file of all input files and dependencies.

--reproduce <tar file>
    Copy to clipboard

This option creates a tar archive file that you simply untar. The extracted directory is named after output file.

The tar file contains a response.txt file, which is the actual command that reproduces the complete link command.

--reproduce-compressed <tar file>
    Copy to clipboard

Because this option creates a zlib-compressed tar archive file, you must first decompress it using `pigz`. Then extract the resulting uncompressed tar archive. The extracted directory is named after the output file.

The tar file contains a `response.txt` file, which is the actual command that reproduces the complete link command.

--progress-bar
    Copy to clipboard

Use this additional option to display the progress of writing the tar file.

**Create the tar file**

1. For either `--reproduce` or `--reproduce-compressed` option, enter the following lines in the source code:

1. c: int foo() {return bar();)
        2. c: int bar() {return 0;)
        hexagon-clang -c 1.c 2.c
        Copy to clipboard

    After the source code is compiled, the 1.o and 2.o object files are created and ready to be linked.
2. At the command line, enter one of the following commands.

    - For the non-compressed tar file:

> 
> 
> hexagon-link 1.o 2.o -o output.elf --reproduce a.tar
>             Copy to clipboard

        Where:

> 
> 
> - `1.o 2.o` are the object files
>         - `output.elf` is the output file
>         - `a.tar` is the name of tar file
    - For the compressed tar file:

> 
> 
> hexagon-link 1.o 2.o -o output.elf --reproduce-compressed a.tar.gz
>             Copy to clipboard

        Where:

> 
> 
> - `1.o 2.o` are the object files
>         - `output.elf` is the output file
>         - `a.tar.gz` is the name of compressed tar file
3. To untar the archive file, do one of the following:

    - For the a.tar file, extract the contents:

> 
> 
> tar xvf a.tar
>             Copy to clipboard
    - For the compressed tar file:

> 
> 
> 1. First decompress it:
> 
> 
> pigz -d a.tar.gz
>                 Copy to clipboard
>         2. Then untar the file:
> 
> 
> tar xvf a.tar
>                 Copy to clipboard

    The extracted directory is named after the output file: `reproduce.output.elf`.
4. Change to the extracted directory:

cd reproduce.output.elf
        Copy to clipboard

    The directory contains the following files:

Object/6060996770729379307.o
        Object/485776965734910591.o
        Copy to clipboard

    Copies of the input files, `1.o` and `2.o` respectively, that are renamed to their sha2 hash value plus file extension in the original file, if present.

    Files are categorized by type. In this case, object files `1.o` and `2.o` are placed in the Object directory within the tarball. If linker scripts were used, the tarball includes a Cache directory that contains the linker script cache file (see `-cache-file`). The original paths are in the `mapping.ini` file.

mapping.ini
        Copy to clipboard

    Contains the path to the sha2 hash mapping for all file paths in the tar file.

    Any input file or dependency that is written to the tar file has a mapping file entry that contains its original path and hash.

    Each type of file has its own category in the mapping file. Categories include the following:

> 
> 
> - [Shared libraries]
>     - [Archive files]
>     - [Plug-ins]
>     - [Object files]
>     - [Symdef files]
>     - [Bitcode files]
>     - [Linker scripts]
>     - [Other files]
>     - [Object files]
> 
> 
> 
> > 
> > 
> > 1. o=6060996770729379307.o
> >             2. o=485776965734910591.o
> >             Copy to clipboard

response.txt
        Copy to clipboard

    Contains the actual command that reruns the original link within the tar file:

> 
> 
> hexagon-link Object/6060996770729379307.o Object/485776965734910591.o -o output.elf --mapping- file=mapping.ini
>         Copy to clipboard

    Where the `--mapping-file` option replaces hashes with paths at runtime when the response file is run.

version.txt
        Copy to clipboard

    Contains the LLVM and linker version information:

> 
> 
> MCLD: 13.0 LLVM: 13.0.0
>         Copy to clipboard
5. To execute the link:

./response.txt
        Copy to clipboard

**Show the progress**

To display the progress of writing the tar file, add the `--progress-bar` option:

hexagon-link 1.o 2.o --reproduce a.tar --progress-bar
    
    Progress : [====================================================]100%
    0s
    Copy to clipboard

#### Use -rpath option

Use the `-rpath=<pathname>` option when linking an ELF executable with shared objects. This option provides the linker with the information that the loader requires to resolve some of the dynamic dependencies at runtime, and it instructs the linker to store that information in the dynamic section of the executable.

All `-rpath` arguments are concatenated and passed to the runtime linker, which uses them to locate shared objects at runtime.

The `foo.c`, `bar.c`, `foobar.c`, and `main.c` files are used for these examples.

In `foo.c`:

#include <stdio.h>
    
    void foo(void)
    {
        puts(__func__);
    }
    Copy to clipboard

In `bar.c`:

#include <stdio.h>
    
    void bar(void)
    {
        puts(__func__);
    }
    Copy to clipboard

In `foobar.c`:

extern void foo(void);
    extern void bar(void);
    
    void foobar(void)
    {
        foo();
        bar();
    }
    Copy to clipboard

In `main.c`:

extern void foobar(void);
    
    int main(void)
    {
        foobar();
        return 0;
    }
    Copy to clipboard

**Example 1**

hexagon-clang -c -fPIC foo.c
    hexagon-link -shared -o libfoo.so foo.o
    
    hexagon-clang -c -fPIC bar.c
    hexagon-link -shared -o libbar.so bar.o
    
    hexagon-clang -c -fPIC foobar.c
    hexagon-link -shared -o libfoobar.so foobar.o -dynamic -lfoo -lbar
    
    hexagon-readelf -d libfoobar.so
    Copy to clipboard

The output of `hexagon-readelf -d libfoobar.so` contains the following lines. Only the dependencies are present, but not the location to look for those dependencies.

Dynamic section at offset 0x1000 contains 15 entries:
      Tag        Type          Name/Value
      0x00000001 (NEEDED)      Shared library: [libfoo.so]
      0x00000001 (NEEDED)      Shared library: [libbar.so]
    Copy to clipboard

**Example 2**

In the following example, `-rpath` is used when creating an executable, so running `readelf` on the executable will show the run path.

hexagon-clang -c main.c
    hexagon-link -o out main.o -dynamic -lfoobar -rpath=<rpath-pathname>
    
    hexagon-readelf -d out
    Copy to clipboard

The output of `hexagon-readelf` -d out shows that the executable contains the provided `runpath`:

Dynamic section at offset 0x2000 contains 15 entries:
      Tag        Type          Name/Value
      0x00000001 (NEEDED)      Shared library: [libfoobar.so]
      0x0000001d (RUNPATH)     Library runpath: [<rpath-pathname>]
    Copy to clipboard

#### Use -z suboptions

This section provides examples of using the `-z <keyword>` sub-options.

The `shlib.c` test file is used for the following examples.

#include <assert.h>
    int a = 10;
    int b = 20;
    int c = 30;
    static int a1 = 40;
    static int b1 = 50;
    static int c1 = 60;
    static int *d1 = &c1;
    int *x;
    static int *d2 = &c;
    static int localfn() {
      return 0;
    }
    
    int (*hexrelativefn)() = &localfn;
    
    int fn1() {
      printf("%d\n",b);
      printf("%d\n",b1);
      assert(b == 20);
      assert(b1 == 50);
      return 0;
    }
    
    int fn2() {
      x = &c;
      printf("%d\n",*x);
      printf("%d\n",c1);
      assert(*x == 30);
      assert(*d2 == 30);
      assert(c == 30);
      assert(c1 == 60);
      return 0;
    }
    
    int fn() {
      printf("hello world\n");
      printf("%d\n",a);
      printf("%d\n",a1);
      printf("%d\n",*d1);
      assert(a == 10);
      assert(a1 == 40);
      assert(*d1 == 60);
      (*hexrelativefn)();
      fn1();
      fn2();
      return 0;
    }
    Copy to clipboard

**Examples**

-z clade-file=<file>
    Copy to clipboard

Set the CLADE file name. It only applicable for the hexagon-link command.

For a CLADE file named `dicts.bin`:

> 
> 
> hexagon-link -z clade-file=dicts.bin 1.o 2.o -o out
>     Copy to clipboard

-z combreloc
    Copy to clipboard

Merge dynamic relocations into one section and sorts them. The relocations are sorted and placed at the top of the output of readelf `-r <shared-object>`.

Example:

> 
> 
> hexagon-clang -fcommon -mv658 -O2 -mv658 -fPIC -c shlib.c -o shlib.o
>     hexagon-link --emit-relocs -mcpu=hexagonv658 initS.o shlib.o finiS.o -o libshlib.so -dy -shared -z combreloc
>     Copy to clipboard

The output of `hexagon-readelf -r libshlib.so` contains the following lines. The items are sorted by the `combreloc` suboption:

> 
> 
> Relocation section '.rela.dyn' at offset 0x2dc contains 8 entries:
>      Offset     Info    Type             Sym. Value  Symbol's Name + Addend
>     0000109c  00000023 R_HEX_RELATIVE                 6ac
>     000010ac  00000306 R_HEX_32           000004e0    __cxa_finalize_stub + 0
>     000010c0  00000421 R_HEX_GLOB_DAT     00000000    __cxa_finalize + 0
>     000010c8  00000a21 R_HEX_GLOB_DAT     0000109c    hexrelativefn + 0
>     000010c4  00000c21 R_HEX_GLOB_DAT     00001090    a + 0
>     000010b4  00000d21 R_HEX_GLOB_DAT     00001094    b + 0
>     000010b8  00000e21 R_HEX_GLOB_DAT     00001098    c + 0
>     000010bc  00001121 R_HEX_GLOB_DAT     00001100    x + 0
>     Copy to clipboard

-z nocombreloc
    Copy to clipboard

Prevent dynamic relocations from being merged into one section. The dynamic relocations are not sorted in the output of `readelf -r <shared-object>`.

Example:

> 
> 
> hexagon-clang -fcommon -mv658 -O2 -mv658 -fPIC -c shlib.c -o shlib.o
>     hexagon-link --emit-relocs -mcpu=hexagonv658 initS.o shlib.o finiS.o -o libshlib.so -dy -shared -z nocombreloc
>     Copy to clipboard

The output of `hexagon-readelf -r libshlib.so` contains the following lines. The items are not sorted due to use of the `nocombreloc` suboption:

> 
> 
> Relocation section '.rela.dyn' at offset 0x2dc contains 8 entries:
>      Offset     Info    Type              Sym. Value  Symbol's Name + Addend
>     000010ac  00000306 R_HEX_32            000004e0   __cxa_finalize_stub + 0
>     000010b4  00000d21 R_HEX_GLOB_DAT      00001094   b + 0
>     000010b8  00000421 R_HEX_GLOB_DAT      00000000   __cxa_finalize + 0
>     000010bc  00000e21 R_HEX_GLOB_DAT      00001098   c + 0
>     000010c0  00001121 R_HEX_GLOB_DAT      00001100   x + 0
>     000010c4  00000c21 R_HEX_GLOB_DAT      00001090   a + 0
>     000010c8  00000a21 R_HEX_GLOB_DAT      0000109c   hexrelativefn + 0
>     0000109c  00000023 R_HEX_RELATIVE                 6ac
>     Copy to clipboard

-z global
    Copy to clipboard

Make symbols in the dynamic shared object available for subsequently loaded objects.

Example:

> 
> 
> > 
> > 
> > Copy to clipboard
> 
> 
> 
> hexagon-clang -fcommon -mv658 -O2 -mv658 -fPIC -c shlib.c -o shlib.o
> hexagon-link –emit-relocs -mcpu=hexagonv658 initS.o shlib.o finiS.o -o libshlib.so -dy -shared -z global

The output of `readelf -d libshlib.so` has the following line:

> 
> 
> 0x6ffffffb (FLAGS_1) GLOBAL.
>     Copy to clipboard

-z defs
    Copy to clipboard

Report unresolved symbols in object files.

Example in `defs.c`:

> 
> 
> int foo() {
>       return bar();
>     }
>     
>     hexagon-clang -fcommon -mv658 -O2 -mv658 -fPIC -c defs.c -o defs.o
>     hexagon-link -shared defs.o -o defs.so
>     Copy to clipboard

The link in the example produces *not error*.

> 
> 
> hexagon-link -shared defs.o -o defs.so -z defs
>     Error: defs.o(.text+0x0): undefined reference to `bar'
>     Fatal: Linking had errors.
>     Copy to clipboard

-z muldefs
    Copy to clipboard

Allow for multiple definitions, thus suppressing multiple definition errors.

Example in `muldef.c`:

> 
> 
> int foo = 0;
>     int main() { return foo; }
>     
>     muldefCopy.c:
>     int foo = 0;
>     int main() { return foo; }
>     
>     hexagon-clang -c muldef.c
>     hexagon-clang -c muldefCopy.c
>     
>     hexagon-link muldef.o muldefCopy.o
>     Error: multiple definition of symbol `foo' in file muldef.o and muldefCopy.o
>     Error: multiple definition of symbol `main' in file muldef.o and muldefCopy.o
>     Fatal: Linking had errors.
>     Copy to clipboard

Use `-z muldefs` in the link to suppress the errors:

> 
> 
> hexagon-link muldef.o muldefCopy.o -z muldefs
>     <no-error>
>     Copy to clipboard

-z nocopyreloc
    Copy to clipboard

Tell the linker to not create copy relocations. The following example includes four test files.

In `1.c`:

> 
> 
> extern int foo;
>     int bar() {
>       return foo;
>     }
>     Copy to clipboard

In `2.c`:

> 
> 
> extern int foo;
>     int car() {
>       return foo;
>     }
>     Copy to clipboard

In `3.c`:

> 
> 
> extern int foo;
>     int baz() { return foo; }
>     Copy to clipboard

In `4.c`:

> 
> 
> int foo = 10;
>     Copy to clipboard

The following link line:

> 
> 
> hexagon-link 1.o 2.o 3.o -Bdynamic lib4.so -o out -z nocopyreloc
>     Copy to clipboard

Results in the following error:

> 
> 
> "Cannot copy symbol foo"
>     Copy to clipboard

-z relro
    Copy to clipboard

Create a RELRO program header.

Example in `relro.c`:

> 
> 
> __attribute__((constructor)) int cfoo() { return 0; }
>     __attribute__((destructor)) int dbar() { return 0; }
>     int val = 10;
>     // Access val from GOT.
>     __attribute__((section(".text.foo"))) int foo() { return val; }
>     __attribute__((section(".text.bar"))) int bar() { return foo(); }
>     
>     hexagon-clang -c relro.c -fPIC -fno-use-init-array
>     hexagon-link relro.o -shared -o relro.so -z relro -z now
>     Copy to clipboard

The output of readelf -l -W relro.so has the following item in the program headers:

> 
> 
> GNU_RELRO   0x001000 0x00001000 0x00001000 0x000b8 0x000b8 RW  0x8
>     Copy to clipboard

-z norelro
    Copy to clipboard

Prevent a RELRO program header from being created.

Example in `relro.c`:

> 
> 
> __attribute__((constructor)) int cfoo() { return 0; }
>     __attribute__((destructor)) int dbar() { return 0; }
>     int val = 10;
>     // Access val from GOT.
>     __attribute__((section(".text.foo"))) int foo() { return val; }
>     __attribute__((section(".text.bar"))) int bar() { return foo(); }
>     
>     hexagon-clang -c relro.c -fPIC -fno-use-init-array
>     hexagon-link relro.o -shared -o relro.so -z norelro -z now
>     Copy to clipboard

The output of `readelf -l -W relro.so` does not have a header with `GNU_RELRO`.

-z lazy
    Copy to clipboard

Mark an object lazy runtime binding.

Example in `relro.c`:

> 
> 
> __attribute__((constructor)) int cfoo() { return 0; }
>     __attribute__((destructor)) int dbar() { return 0; }
>     int val = 10;
>     // Access val from GOT.
>     __attribute__((section(".text.foo"))) int foo() { return val; }
>     __attribute__((section(".text.bar"))) int bar() { return foo(); }
>     
>     hexagon-clang -c relro.c -fPIC -fno-use-init-array
>     hexagon-link relro.o -shared -o relro.so -z relro -z lazy
>     Copy to clipboard

The output of `readelf -l -W relro.so` has the following lines:

> 
> 
> Program Headers:
>       Type         Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg  Align
>       LOAD         0x000000 0x00000000 0x00000000 0x0025c 0x0025c R E  0x1000
>       LOAD         0x001000 0x00001000 0x00001000 0x010b0 0x010b0 RW   0x1000
>       DYNAMIC      0x001008 0x00001008 0x00001008 0x00080 0x00080 RW   0x4
>       GNU_RELRO    0x001000 0x00001000 0x00001000 0x0008c 0x0008c RW   0x4
>     Copy to clipboard

-z now
    Copy to clipboard

Mark an object non-lazy runtime binding.

Example in `relro.c`:

> 
> 
> __attribute__((constructor)) int cfoo() { return 0; }
>     __attribute__((destructor)) int dbar() { return 0; }
>     int val = 10;
>     // Access val from GOT.
>     __attribute__((section(".text.foo"))) int foo() { return val; }
>     __attribute__((section(".text.bar"))) int bar() { return foo(); }
>     
>     hexagon-clang -c relro.c -fPIC -fno-use-init-array
>     hexagon-link relro.o -shared -o relro.so -z relro -z now
>     Copy to clipboard

The output of `readelf -l -W relro.so` has the following lines:

> 
> 
> Program Headers:
>      Type          Offset   VirtAddr   PhysAddr   FileSiz MemSiz  Flg  Align
>      LOAD          0x000000 0x00000000 0x00000000 0x0022c 0x0022c R E  0x1000
>      LOAD          0x001000 0x00001000 0x00001000 0x010bc 0x010bc RW   0x1000
>      DYNAMIC       0x001008 0x00001008 0x00001008 0x00090 0x00090 RW   0x4
>      GNU_RELRO     0x001000 0x00001000 0x00001000 0x000b8 0x000b8 RW   0x8
>     Copy to clipboard

-z text
    Copy to clipboard

Treat `DT_TEXTREL` in a shared object as an error.

-z execstack
    Copy to clipboard

Mark an executable as requiring an executable stack.

Example in `1.c`:

> 
> 
> int main()
>     {
>        return 0;
>     
>     hexagon-clang -target aarch64 -fPIC 1.c -c -o 1.o
>     hexagon-link -march aarch64 -Bshareable 1.o -o 1.so -z execstack
>     Copy to clipboard

The output of `readelf -a -W 1.so` has the following item that includes Execute (`E`):

> 
> 
> GNU_STACK      0x000000 0x0000000000000000 0x0000000000000000 0x000000 0x000000 RWE 0
>     Copy to clipboard

-z noexecstack
    Copy to clipboard

Mark an executable as not requiring an executable stack.

Example in `1.c`:

> 
> 
> int main()
>     {
>        return 0;
>     }
>     hexagon-clang -target aarch64 -fPIC 1.c -c -o 1.o
>     hexagon-link -march aarch64 -Bshareable 1.o -o 1.so -z noexecstack
>     Copy to clipboard

The output of `readelf -a -W 1.so` has the following item that does not include `E`:

> 
> 
> GNU_STACK      0x000000 0x0000000000000000 0x0000000000000000 0x000000 0x000000 RW  0
>     Copy to clipboard

-z common-page-size=<value>
    Copy to clipboard

Set the emulation common page size to the specified value. This example uses two files.

In `max.s`:

> 
> 
> .section ".data", "wa"
>     .long 0x12345678
>     Copy to clipboard

In `max.t`:

> 
> 
> SECTIONS
>     {
>       . = 0x4017dc;
>       . = DATA_SEGMENT_ALIGN (CONSTANT (MAXPAGESIZE), CONSTANT (COMMONPAGESIZE));
>       .data : { *(.data) }
>       . = DATA_SEGMENT_END (.);
>     }
>     
>     hexagon-clang -c max.s
>     hexagon-link max.o -T max.t -z max-page-size=0x2000 -z common-page-size= 0x1000
>     Copy to clipboard

The output of `readelf -S -W a.out` has entries like the following:

> 
> 
> .data         PROGBITS       00403000 001000 000004 00  WA  0   0  1
>     .comment      PROGBITS       00000000 001004 00002c 00  MS  0   0  1
>     Copy to clipboard

-z max-page-size=<SIZE>
    Copy to clipboard

Set the maximum page size to `SIZE`. This example uses two files.

In `max.s`:

> 
> 
> .section ".data", "wa"
>     .long 0x12345678
>     Copy to clipboard

In `max.t`:

> 
> 
> SECTIONS
>     {
>       . = 0x4017dc;
>       . = DATA_SEGMENT_ALIGN (CONSTANT (MAXPAGESIZE), CONSTANT (COMMONPAGESIZE));
>       .data : { *(.data) }
>       . = DATA_SEGMENT_END (.);
>     }
>     
>     hexagon-clang -c max.s
>     hexagon-link max.o -T max.t -z max-page-size=0x500 -z common-page-size= 0x1000
>     Copy to clipboard

The output of `readelf -S -W a.out` has lines that show the maximum page size value that overrides the common page size:

> 
> 
> .data          PROGBITS     00401800 000500 000004 00  WA  0   0  1
>     .comment       PROGBITS     00000000 000504 00002c 00  MS  0   0  1
>     Copy to clipboard

-z nodelete
    Copy to clipboard

Mark a dynamic shared object as non-deletable at runtime.

Example in `nodelete.c`:

> 
> 
> int foo() {
>       return 0;
>     }
>     
>     hexagon-clang nodelete.c -c -fPIC
>     hexagon-link -shared nodelete.o -z nodelete -z now --enable-new-dtags -o nodelete.so
>     Copy to clipboard

The output of `readelf -d nodelete.so` has the following line:

> 
> 
> 0x6ffffffb (FLAGS_1)                    Flags: NOW NODELETE
>     Copy to clipboard

-z compactdyn
    Copy to clipboard

Reduce the number of entries in the dynamic table.

For example, `PLTGOT` and `DEBUG` are not added if this option is present in the command line.

## Environment variables

Other than command-line options, the linker behavior is also affected by the QCLDFLAGS environment variable. The linker internally appends the `QCLDFLAGS` value to the link command. For example:

export QCLDFLAGS=“-dy lib2.so --gc-sections” hexagon-link -o main.elf
    main.o lib1.a
    Copy to clipboard

The above command is effectively the same as:

Export QCLDFLAGS=""
    hexagon-link -o main.elf main.o lib1.a -dy lib2.so --gc-sections
    Copy to clipboard

## Link maps

Link maps are optionally generated by the linker. They provide the following information on how the files were linked:

- Link information
- Link stats
- Archive and object files that are accessed
- Common symbols that are allocated
- Linker script (if specified)
- Memory map of sections and symbols

A link map is generated as a text file. The file can be specified on the command line with either the `-Map` or `--print-map` option. For more information, see [Options](https://docs.qualcomm.com/doc/80-N3040-23/topic/linker.html#hu-linker-options).

Link maps can have two output formats:

- Conventional GNU map file format
- YAML map file format

Apart from the link information and the link stats, the link maps are divided into four major sections: the archive section, the common symbols section, the linker script section, and the memory map section.

Link information contains information such as link type, target architecture information, link command line, OS-specific information (like page size).

Link stats contains the following information

- Number of object files
- Thread count
- Number of input sections
- Number of zero-sized input sections
- Output symbol stats
- Discarded symbol stats
- Number of output sections
- Number of orphan input sections
- Output file size
- Retain section stats
- Archive member count
- Image start address
- Entry point information
- Load information of PHDRS, and file header

Note

Link stats only contains non-zero stats. Any stats that are 0 or null are not included in the link stats output.

The following table shows the link map sections.

| Section | Section entry format |
| --- | --- |
| Archive | archive_file (symbol_define_object_file)<br>       symbol_reference_object_file (symbol)<br>    Copy to clipboard |
| Common symbols | symbol size archive_file (symbol_define_object_file)<br>    Copy to clipboard |
| Linker script | linker_script_command<br>    Copy to clipboard |
| Memory map | output_section addr size<br>        input_section addr size object_file<br>            symbol addr<br>            ...<br>        ...<br>    Copy to clipboard |

Note

Link map section entries are described in detail in the following sections.

### Example link map file

The following code example shows a typical link map file.

Note

The map file has been shortened for readability.

Archive member included because of file (symbol)
    /pkg/qct/software/hexagon/releases/tools/23.0/Tools/bin/../target/hexagon/lib/v60/libstandalone.a (low_thread.o)
    /pkg/qct/software/hexagon/releases/tools/23.0/Tools/bin/../target/hexagon/lib/v60/crt0_standalone.o (thread_stop)
    /pkg/qct/software/hexagon/releases/tools/23.0/Tools/bin/../target/hexagon/lib/v60/libstandalone.a (sys_get_cmdline.o)
    /pkg/qct/software/hexagon/releases/tools/23.0/Tools/bin/../target/hexagon/lib/v60/crt0.o (sys_get_cmdline)
    
    ...
    
    Allocating common symbols
    Common symbol     size    file
    
    __eh_nodes        0x4     /pkg/qct/software/hexagon/releases/tools/23.0/Tools/bin/
                               target/hexagon/lib/v60/libc.a (xregister.o)
    
    ...
    
    Linker Script and memory map
    START GROUP
    END GROUP
    LOAD /pkg/qct/software/hexagon/releases/tools/23.0/Tools/bin/../target/hexagon/lib/v60/crt0_standalone.o[v60]
    LOAD /pkg/qct/software/hexagon/releases/tools/23.0/Tools/bin/../target/hexagon/lib/v60/crt0.o[v60]
    LOAD /pkg/qct/software/hexagon/releases/tools/23.0/Tools/bin/../target/hexagon/lib/v60/init.o[v60]
    
    ...
    
                  0x0    0x0
    
    .start        0x0    0x3dc0
    (.start)
    .start        0x0    0x3b88   /pkg/qct/software/hexagon/releases/tools/23.0/Tools/
                                   bin/../target/hexagon/lib/v60/crt0_standalone.o
        0x5b8        .CheckWB
        0x724        .FinishOverrides
        0x104        .Init
    
    ...
    
    .start        0x3ba0 0x220    /pkg/qct/software/hexagon/releases/tools/23.0/Tools/
                                   bin/../target/hexagon/lib/v60/crt0.o
        0x3d34        .PreArgs
        0x3ce0        .PreBSS
        0x3d34        .PreBSSSkip
        0x3c78        .SkipUpdate
        0x3ba0        .start
        0x0           _start
        0x3bb8        hexagon_pre_main
        0x3d34        hexagon_start_main
        0x3bb8        qdsp6_pre_main
        0x3d34        qdsp6_start_main
        0x0           start
    
    .init    0x4000        0x54
    (.init)
    .init    0x4000        0x54    /pkg/qct/software/hexagon/releases/tools/23.0/Tools/
                                    bin/../target/hexagon/lib/v60/init.o
             0x4000        .init
             0x4000        _init
    
    .text    0x5000       0x20f0
    
    ...
    Copy to clipboard

### Archive section

The archive section of a link map lists each archive file that was accessed by the linker, together with the symbol reference that caused the archive file to be accessed.

Each entry in the archive section contains the following items:

- The full path name of the archive file accessed by the linker
- The name of the archived object file that defines the symbol (in parentheses)
- The full path name of the object file that contains the symbol reference
- The name of the referenced symbol (in parentheses)

In the following example, the `thread_stop` symbol is referenced in `crt0_standalone.o`  and defined in `low_thread.o`, which in turn is stored in the `libstandalone.a archive` file:

/pkg/qct/software/hexagon/releases/tools/23.0/Tools/bin/../target/hexagon/lib/v60/libstandalone.a (low_thread.o)
    /pkg/qct/software/hexagon/releases/tools/23.0/Tools/bin/../target/hexagon/lib/v60/crt0_standalone.o (thread_stop)
    Copy to clipboard

### Common symbols section

The common symbols section of a link map lists the common symbols that were allocated in memory by the linker.

Each entry in the common symbols section contains the following item:

- The name of the symbol
- The size of the memory area allocated for the symbol
- The full path name of the archive file accessed by the linker
- The name of the archived object file that defines the symbol (in parentheses)

In the following example, the common symbol, `__eh_nodes`, has size 0x4 and is defined in `xregister.o`, which in turn is stored in the `libc.a` archive file:

__eh_nodes         0x4    /pkg/qct/software/hexagon/releases/tools/23.0/Tools/bin/target/hexagon/lib/v60/libc.a (xregister.o)
    Copy to clipboard

### Linker script section

The linker script section of a link map lists the complete linker script that was specified for the link. For more information on linker scripts see [Linker scripts](https://docs.qualcomm.com/doc/80-N3040-23/topic/linker.html#hu-linker-linker-scripts).

Note

Linker scripts are optional; if a script is not specified on the linker command line, the link map will not include a linker script.

The linker script section also has all the linker scripts used, listed in a recursive manner.

In the following example, the `a.t` script is a linker script passed to the linker. It has an `INCLUDE` command to include `ld.t`:

Linker scripts used (including INCLUDE command)
    /tmp/a.t
            ld.t
    Copy to clipboard

The next example shows the initial lines of a linker script section:

START GROUP
    END GROUP
    LOAD /pkg/qct/software/hexagon/releases/tools/23.0/Tools/bin/../target/ hexagon/lib/v60/crt0_standalone.o[v60]
    LOAD /pkg/qct/software/hexagon/releases/tools/23.0/Tools/bin/../target/ hexagon/lib/v60/crt0.o[v60]
    LOAD /pkg/qct/software/hexagon/releases/tools/23.0/Tools/bin/../target/ hexagon/lib/v60/init.o[v60]
    ...
    Copy to clipboard

### Memory map section

The memory map section of a link map lists how symbols and assembly language sections (see [Sections](https://docs.qualcomm.com/doc/80-N3040-23/topic/assembler.html#hu-sections)) are assigned to memory in the output file.

The memory map section lists one or more output sections in the order they are assigned by the linker. Each entry in the memory map section contains the following items:

- The output section, including various output section properties, such as start address, section size, alignment, and output section type and flags
- Each input section that is mapped to the output section (including its start address, section size, section type, permissions, and the full path name of the object file containing the section)
- Each symbol defined in the input section (including its assigned value)

In the following example, the output section `.start` has the start address 0x0 and size 0x3dc0. Two input sections (also named `.start`) are mapped to this output section: the first has start address 0x0 and size 0x3b88, and the second has start address 0x3ba0 and size 0x220. Following each section descriptor is a list of the symbols in the section:

.start      0x0   0x3dc0
    (.start)
    .start      0x0   0x3b88   /pkg/qct/software/hexagon/releases/tools/23.0/Tools/bin/../target/ hexagon/lib/v60/crt0_standalone.o
        0x5b8      .CheckWB
        0x724      .FinishOverrides
        0x104      .Init
        ...
    
    .start      0x3ba0   0x220   /pkg/qct/software/hexagon/releases/tools/23.0/Tools/bin/../target/ hexagon/lib/v60/crt0.o
        0x3d34      .PreArgs
        0x3ce0      .PreBSS
    Copy to clipboard

The map file also prints garbage-collected sections and symbols in the memory map section. The garbage-collected sections are prefixed with `#` and are marked with `<GC>`. The following example shows the printing of a garbage-collected section in map file.

foobar  0x0     0xc # Offset: 0x1000, LMA: 0x0, Alignment: 0x10, Flags: SHF_ALLOC|SHF_EXECINSTR, Type: SHT_PROGBITS
    *(*.foo) #Rule 1, script.t [1:0]
    # .text.foo     <GC>    0xc     1.o     #SHT_PROGBITS,SHF_ALLOC|SHF_EXECINSTR,16
    #       foo
    *(*.bar) #Rule 2, script.t [1:0]
    # .text.bar     <GC>    0xc     1.o     #SHT_PROGBITS,SHF_ALLOC|SHF_EXECINSTR,16
    #       bar
    *(*.baz) #Rule 3, script.t [1:0]
    .text.baz       0x0     0xc     1.o     #SHT_PROGBITS,SHF_ALLOC|SHF_EXECINSTR,16
            0x0             baz
    *(foobar) #Rule 4, Internal-LinkerScript (Implicit rule inserted by Linker) [0:0]
    Copy to clipboard

`.text.foo` and `.text.baz` are prefixed with `#` and marked with `<GC>` because they are garbage- collected sections and thus are not part of the output image. The symbols of garbage-collected sections, bar, and foo are also included in the output.

The map file also shows how identical strings were merged. In the following example output section `.rodata` contains one string `"abc"` which is duplicated 6 times. The map file shows how identical strings are merged to a single copy.

map.s
    
    .section .rodata.str1.1,“aMS”,%progbits,1
    .string “abc”
    .section .rodata.str2.1,“aMS”,%progbits,1
    .string “abc”
    .string “abc”
    .string “abc”
    .string “abc”
    .string “abc”
    
    Map file
    
    .rodata0x00x4 # Offset: 0x1000, LMA: 0x0, Alignment: 0x1, Flags: SHF_ALLOC|SHF_MERGE|SHF_STRINGS, Type: SHT_PROGBITS
    .rodata.str1.10x00x4map.o #SHT_PROGBITS,SHF_ALLOC|SHF_MERGE|SHF_STRINGS,1[ Contents: abc]
        .rodata.str2.10x0map.o
        .rodata.str2.10x4map.o
        .rodata.str2.10x8map.o
        .rodata.str2.10xcmap.o
        .rodata.str2.10x10map.o
    Copy to clipboard

Only the first string is included and all others are merged with that string, denoted by indentation. To save size, by default debug string merges are not shown. To show them use the `-MapDetail=show-debug-strings` option.

### Changes to GNU format maps

#### LTO-related changes

With the incorporation of the LTO feature in the tools, the Map has two main sections:

- Pre-LTO map section
- Post-LTO map section

Pre-LTO maps only have an archive section and a linker script section. For example:

Pre-LTO map records:
    Archive member included because of file (symbol)
    /prj/dsp/qdsp6/release/internal/branch-8.0/linux64/latest/Tools/bin/../ target/hexagon/lib/v60/G0/libstandalone.a(pte.o)
    /prj/dsp/qdsp6/release/internal/branch-8.0/linux64/latest/Tools/bin/../ target/hexagon/lib/v60/G0/crt0_standalone.o (UPTE_START)
    /prj/dsp/qdsp6/release/internal/branch-8.0/linux64/latest/Tools/bin/../ target/hexagon/lib/v60/G0/libstandalone.a(low_thread.o)
    /prj/dsp/qdsp6/release/internal/branch-8.0/linux64/latest/Tools/bin/../ target/hexagon/lib/v60/G0/crt0_standalone.o (thread_stop)
    /prj/dsp/qdsp6/release/internal/branch-8.0/linux64/latest/Tools/bin/../ target/hexagon/lib/v60/G0/libstandalone.a(sys_get_cmdline.o)
    Copy to clipboard

The linker script and memory map sections for the pre-LTO section have the file type marked with the files loaded. For an ELF file type, the architecture version is printed, making it easier to inspect. For example:

Linker Script and memory map:
    LOAD /prj/dsp/qdsp6/release/internal/branch-8.0/linux64/latest/Tools/ bin/../target/hexagon/lib/v60/G0/crt0_standalone.o[v60]
    LOAD /prj/dsp/qdsp6/release/internal/branch-8.0/linux64/latest/Tools/ bin/../target/hexagon/lib/v60/G0/crt0.o[v60]
    LOAD /prj/dsp/qdsp6/release/internal/branch-8.0/linux64/latest/Tools/ bin/../target/hexagon/lib/v60/G0/init.o[v60]
    LOAD /tmp/a-323fe1.o [Bitcode]
    Copy to clipboard

The sections in the post-LTO section are similar to the old map file with one exception. Files marked as `SKIPPED` in the map files are not processed again by the linker since they have been processed before invoking the LTO code generator. For example:

Linker Script and memory map:
    LOAD /tmp/lto-llvm-0-324c9e.o[v60]
    SKIPPED /tmp/a.t (ELF)
    SKIPPED /prj/dsp/qdsp6/release/internal/branch-8.0/linux64/latest/Tools/ bin/../target/hexagon/lib/v60/G0/crt0_standalone.o (ELF)
    SKIPPED /prj/dsp/qdsp6/release/internal/branch-8.0/linux64/latest/Tools/ bin/../target/hexagon/lib/v60/G0/crt0.o (ELF)
    Copy to clipboard

#### Miscellaneous information in map file

Additional information is not printed in the GNU format map file.

Following are examples of useful tool chain information and inferred settings for the linker from command line options:

# Linker from QuIC LLVM Hexagon Clang version: hexagon-clang-80-9530
    # Linker based on LLVM version: 3.9
    # CPU Architecture Version: hexagonv60
    # Target triple environment for the link: unknown
    # Maximum GP size: 0
    # Link type: Static
    # LTO Flag: Enabled
    # LTO Options: codegen
    # ABI Page Size: 0x1000
    Copy to clipboard

The memory map section now has extra information for output and input sections.

Output sections display their offset and LMA with the VMA:

.text   0x5000  0x60cc # Offset: 0x5000, LMA: 0x5000
    Copy to clipboard

Input sections display the section permissions and section alignment with the input file from which the section came:

.text   0x50c0  0x10    /tmp/lto-llvm-0-324c9e.o        #SHT_PROGBITS,SHF_ALLOC|SHF_EXECINSTR,16
    Copy to clipboard

#### YAML format for map files

YAML maps have information that is a hybrid of the GNU maps and are structured for easier parsing.

Header:
    Architecture:    Hexagon
    Emulation:       v60
    AddressSize:     32bit
    VersionInformation:
    CompilerVersion: hexagon-clang-80-9530
    LinkerVersion:   3.9
    Copy to clipboard

The `ArchiveRecords` list is similar to GNU maps in that it has a list of archive members pulled and the referring object that caused this inclusion of the member.

ArchiveRecords:
      - Origin:          '/prj/dsp/qdsp6/release/internal/branch-8.0/linux64/ latest/ Tools/bin/../target/hexagon/lib/v60/G0/libstandalone.a(pte.o)'
        Referred:        '/prj/dsp/qdsp6/release/internal/branch-8.0/linux64/ latest/Tools/bin/../target/hexagon/lib/v60/G0/crt0_standalone.o (UPTE_START)'
      - Origin:          '/prj/dsp/qdsp6/release/internal/branch-8.0/linux64/ latest/Tools/bin/../target/hexagon/lib/v60/G0/libstandalone.a(low_thread.o)'
        Referred:        '/prj/dsp/qdsp6/release/internal/branch-8.0/linux64/ latest/Tools/bin/../target/hexagon/lib/v60/G0/crt0_standalone.o (thread_stop)'
      - Origin:          '/prj/dsp/qdsp6/release/internal/branch-8.0/linux64/ latest/Tools/bin/../target/hexagon/lib/v60/G0/libstandalone.a(sys_get_cmdline)'
    Copy to clipboard

The `Commons` list is the list of common symbols that are allocated.

Commons:
      - Name:            __eh_nodes
        Size:            0x00000004
        InputPath:       /prj/dsp/qdsp6/release/internal/branch-8.0/linux64/ latest/Tools/bin/../target/hexagon/lib/v60/G0/libc.a
        InputName:       xregister.o
    Copy to clipboard

The `Inputs` list shows the inputs that are loaded for this link instance.

Inputs:
      - 'LOAD /prj/dsp/qdsp6/release/internal/branch-8.0/linux64/latest/ Tools/bin/../target/hexagon/lib/v60/G0/crt0_standalone.o[v60]'
      - 'LOAD /prj/dsp/qdsp6/release/internal/branch-8.0/linux64/latest/ Tools/bin/../target/hexagon/lib/v60/G0/crt0.o[v60]'
      - 'LOAD /prj/dsp/qdsp6/release/internal/branch-8.0/linux64/latest/ Tools/bin/../target/hexagon/lib/v60/G0/init.o[v60]'
      - 'LOAD /tmp/a-835971.o[v60]'
    Copy to clipboard

The image description in YAML is more symbol-centric. The description of the output sections is a structure that contains the name, permissions, type, and memory information. The contents of the sections are then listed as structures describing the name of the symbol, type, size, and value.

**Example**

- Name:            .start
      Type:            [ SHT_PROGBITS ]
      Permissions:     [ SHF_ALLOC, SHF_WRITE, SHF_EXECINSTR ]
      Address:         0x0000000000000000
      Offset:          0x0000000000001000
      Size:            0x0000000000003EC0
    
      Contents:
        - Name:            .start
          Type:            [ SHT_PROGBITS ]
          Permissions:     [ SHF_ALLOC, SHF_WRITE, SHF_EXECINSTR ]
          LinkerScript:    'KEEP (*(.start ))'
          Offset:          0x0000000000000000
          Size:            0x0000000000001C88
          Origin:          /prj/dsp/qdsp6/release/internal/branch-8.0/linux64/ latest/Tools/bin/../target/hexagon/lib/v60/G0/crt0_standalone.o
          Alignment:       64
          Symbols:
            - Symbol:          _start
              Type:            [ STT_FUNC ]
              Scope:           0
              Size:            0x00000018
              Value:           0x0000000000000000
            - Symbol:          .start
              Type:            [ STT_OBJECT, STT_FUNC, STT_SECT ]
              Scope:           2
              Size:            0x00000000
              Value:           0x0000000000000000
            - Symbol:          start
              Type:            [ STT_FUNC ]
              Scope:           0
              Size:            0x00000018
              Value:           0x0000000000000000
            - Symbol:          R0_mailbox
              Type:            [  ]
              Scope:           2
              Size:            0x00000000
              Value:           0x0000000000000020
            - Symbol:          zebu_mailboxes
              Type:            [  ]
              Scope:           2
              Size:            0x00000000
              Value:           0x0000000000000020
            - Symbol:          R1_mailbox
              Type:            [  ]
              Scope:           2
              Size:            0x00000000
              Value:           0x0000000000000024
    Copy to clipboard

## Linker scripts

Linker scripts are used to provide a detailed specification of how the files are to be linked. The scripts offer greater control over linking than is available using just the linker command options (see [Options](https://docs.qualcomm.com/doc/80-N3040-23/topic/linker.html#hu-linker-options)).

Linker scripts are optional. In most cases, the default behavior of the linker is sufficient (with input sections merged according to their section names, and segments ordered by sections that share similar permissions).

Linker scripts control the following properties:

- Output file format
- Program entry point
- Library search paths
- Section memory placement
- Section removal
- Section runtime properties

A linker script consists of a sequence of commands stored in a text file (the commands are described in Section 4.5.4). The script file can be specified on the command line either with the -T option or by specifying the file as one of the input files. The linker can distinguish between script files and object files, and it handles each file accordingly.

The following table lists commands supported in linker script files.

| Command | Description |
| --- | --- |
| `ALIGN` | Align location counter to specified boundary |
| `ASSERT` | Linker script assertion |
| `CONSTRUCTORS` | Accepted for compatibility, but ignored |
| `ENTRY` | Program execution entry point |
| `EXCLUDE_FILE` | Exclude file from input section list |
| `FILEHDR` | ELF file header |
| `FILL` | Output section fill |
| `INCLUDE` | Include linker script file |
| `KEEP` | Prevent input section from being garbage collected |
| `OUTPUT_ARCH` | Target processor |
| `OUTPUT_FORMAT` | Output properties (file format, endianness) |
| `PHDRS` | Object file program header |
| `PROVIDE` | Conditional symbol definition |
| `SEARCH_DIR` | Library search path |
| `SECTIONS` | Section mapping and memory placement |
| `SEGMENT_START` | Return base address of output section |
| `SIZEOF_HEADERS` | Size of the output file header |
| `MEMORY` | Assign names to ranges of memory and manage them |
| `REGION_ALIAS` | Create an alias for a named memory region |

Note

Linker scripts are like the scripts used with the GNU linker. However, no compatibility is guaranteed; only the features and syntax described in this document are supported.

### Script example

The following example shows a linker script that demonstrates the scripting features:

OUTPUT_FORMAT (elf32-littlehexagon)
    OUTPUT_ARCH (hexagon)
    ENTRY (main)
    SEARCH_DIR("./")
    
    SECTIONS
    {
      .text.mcldfn (0x2000) : { *(.text.mcldfn*) }
      . = ALIGN(0x1000);
    
      PROVIDE(__etext = .);
      __text_start = . + 0x1000 - 0x1000;
      .text : { *(.text.*) }

      .data : { *(.data.*) }
    
      . = SEGMENT_START(".bss", 0x80000);
      .bss : { *(.bss.*) }
    
      .init : { KEEP (*(.init)) }
      __bss_start = .;
      __bss_end = .;
    
    }
    Copy to clipboard

The script contains several commands that specify various link properties, and a `SECTIONS` command (see [SECTIONS](https://docs.qualcomm.com/doc/80-N3040-23/topic/linker.html#hu-linker-scripts-commands-sections-bookmark)) that specifies two things:

- How input sections are mapped to output sections
- Where output sections are located in memory

Wild-card characters in the SECTIONS command indicate that multiple input sections are mapped to a single output section.

A period (.) is used to indicate the current location counter. However, be aware that it is assigned several different values in the `SECTIONS` command.

.text.mcldfn
    Copy to clipboard

In the example script file, all input sections whose names begin with `.text.mcldfn` are mapped to an output section named `.text.mcldfn`, and the merged output section is located at the virtual memory address 0x2000.

The current location counter is then advanced to the next 0x1000 address boundary past the end of the output section `.text.mcldfn` (using the `ALIGN` directive).

The `__etext` symbol is conditionally defined with the current location counter value if any unresolved symbol references exist for the symbol (using the `PROVIDE` command).

The `__text_start` symbol is assigned the current location counter value plus the following expression. (Arithmetic expressions can be used in linker script statements.)

.text
    Copy to clipboard

All input sections that begin with `.text` are mapped to the output section `.text`, and the merged output section is located at the current location counter.

The previously-referenced section `.text.mcldfn` is not affected by this statement (even though it matches the section name wildcard `.text.*`) because it was already merged in the previous link script statement.

.data
    Copy to clipboard

Next, the current location counter is assigned the base address of the output section `.data` (using the `SEGMENT_START` directive). If this section is not defined, the default value of 0x50000 is used instead.

All input sections whose names begin with `.data` are mapped to the output section `.data`, and the merged output section is located at the current location counter (as specified by the preceding statement in the script).

.bss
    Copy to clipboard

Next, the current location counter is assigned the base address of the output section `.bss` (using the `SEGMENT_START` directive). If this section is not defined, the default value of 0x80000 is used instead.

All input sections whose names begin with `.bss` are mapped to the output section `.bss`, and the merged output section is located at the current location counter (as specified by the preceding statement in the script).

.init
    Copy to clipboard

All input sections whose names begin with `.init` are mapped to the output section `.init`, and the merged output section is located at the current location counter (as specified by the preceding statement in the script).

In addition, none of the input sections will ever be removed from memory if garbage collection is enabled (as specified by the `KEEP` directive).

Finally, the symbols `__bss_start` and `__bss_end` are both assigned the current location counter value.

### Script syntax

Following is the basic syntax for link scripts.

Symbols
    Copy to clipboard

Symbol names must begin with a letter, underscore, or period. They can include letters, numbers, underscores, hyphens, or periods.

Comments
    Copy to clipboard

Comments can appear in linker scripts:

> 
> 
> /* comment */
>     Copy to clipboard

Strings
    Copy to clipboard

Character strings can be specified as parameters with or without delimiter characters:

> 
> 
> OUTPUT_FORMAT ("elf32-littlehexagon")
>     OUTPUT_ARCH (hexagon)
>     Copy to clipboard

Expressions
    Copy to clipboard

Expressions are similar to C and support all C arithmetic operators. They are evaluated as type long or unsigned long.

Location counter
    Copy to clipboard

A period (`.`) is used as a symbol to indicate the current location counter. It is used only in the `SECTIONS` command (see [SECTIONS](https://docs.qualcomm.com/doc/80-N3040-23/topic/linker.html#hu-linker-scripts-commands-sections-bookmark)), where it designates locations in the output section:

> 
> 
> . = ALIGN(0x1000);
>     . = . + 0x1000;
>     Copy to clipboard

Assigning a value to the location counter symbol changes the location counter to the specified value. The location counter can be moved forward by arbitrary amounts to create gaps in an output section. However, it cannot be moved backwards.

Symbol assignment
    Copy to clipboard

Symbols (including the location counter) can be assigned constants or expressions:

> 
> 
> __text_start = . + 0x1000;
>     Copy to clipboard

Assignment statements are similar to C and support all C assignment operators. They must be terminated with a semicolon (`;`).

### Input sections

Input sections can be stored in files or archives. They are specified in the `SECTIONS` (see [SECTIONS](https://docs.qualcomm.com/doc/80-N3040-23/topic/linker.html#hu-linker-scripts-commands-sections-bookmark)) with the following syntax:

[<path>][<archive>:][<file>](<section>...)
    Copy to clipboard

The standard wild-card characters (`*`, `?`, and so on.) can be used anywhere in an input section specification to do the following:

- Specify multiple paths, archives, or files where sections will be searched for
- Specify multiple sections as input sections

The following table lists examples of input section specifications.

| Specification | Description |
| --- | --- |
| `modem/lte/lt.lib:lt_init.o(.text.*)` | Specify one or more `.text.` sections from a specific object file (`lt_init.o`) in a specific archive (`lt.lib`) |
| `modem/lte/lt.lib:(.text.*)` | Specify one or more .text. sections from any object file in the specified archive (`lt.lib`) |
| `modem/lte/*:(.text.*)` | Specify one or more `.text.` sections from any archive in the specified directory (`modem/lte`) |
| `*(.text.*)` | Specify one or more `.text.` sections from any archive or object file in the entire file system |
| `*lt_init.o:(.text.*)` | Specify no sections at all (because an object file is specified where an archive should be, this is an invalid specification) |

### Script commands

ALIGN (<value>)
    Copy to clipboard

Return the value of the location counter after it has been aligned to a specified address boundary.

This directive is used in expressions. It increases the current location counter value until it is an integral multiple of the specified numeric value, and returns the increased value. The actual location counter is not affected.

ASSERT(<expression>, <string>)
    Copy to clipboard

Add an assertion to the linker script.

If the specified expression evaluates to zero, the linker displays the specified string as an error message and then exits with an error result code.

CONSTRUCTORS
    Copy to clipboard

Script command that is accepted for compatibility, but it is ignored.

ENTRY (<symbol>)
    Copy to clipboard

Specify the program execution entry point, which is the first instruction that is executed after a program is loaded. This command is equivalent to the linker command-line option, `-e`.

EXCLUDE_FILE (<file> ...)
    Copy to clipboard

Reduce the number of items matched by a wild card in an input section (see [SECTIONS](https://docs.qualcomm.com/doc/80-N3040-23/topic/linker.html#hu-linker-scripts-commands-sections-bookmark)). Excluded items can be files, archives, or archive members.

In a section-mapping statement, wild-card characters can be used to specify multiple files or archives. For example:

> 
> 
> *(.text)
>     Copy to clipboard

The `EXCLUDE_FILE` command can be specified in an input section as if it were a file name, but its effect is to exclude all specified items from the input section. For example, the following input section description includes all files ending with `.text` except for `myfile.text`:

> 
> 
> *(EXCLUDE_FILE(myfile.text) .text .data)
>     Copy to clipboard

Note

If an exclusion is used in a list of section names, it applies only to the immediately following section name in the list (.text in the example). For several examples of using exclusions, see [Link-time optimization](https://docs.qualcomm.com/doc/80-N3040-23/topic/linker.html#hu-linker-link-time-optimization).

FILL (<value>)
    Copy to clipboard

Assign the specified value to any memory locations in an output section that were not assigned values during linking. Only the memory locations following the command are affected.

`FILL` can be specified multiple times to assign different fill values to different parts of the section.

Note

This command can be used only in an input section description (see [SECTIONS](https://docs.qualcomm.com/doc/80-N3040-23/topic/linker.html#hu-linker-scripts-commands-sections-bookmark)).

INCLUDE (<file>)
    Copy to clipboard

Include the contents of the specified text file at the current location in the linker script. The specified file is searched for in the current directory and in any directory that the linker uses to search for libraries.

Include files can be nested.

KEEP (<input_sections>)
    Copy to clipboard

Specify input sections that are never to be removed from memory if garbage collection is enabled.

This command is used in section-mapping statements. The input section specification is wrapped as an argument of the `KEEP` directive. For example, `KEEP (*(.init))`.

Garbage control of sections is controlled with the `--gc-sections` option.

OUTPUT_ARCH ("hexagon")
    Copy to clipboard

Specify the target processor architecture.

This command accepts only the hexagon parameter because the target processor is always the Hexagon processor.

OUTPUT_FORMAT ("elf32-littlehexagon")
    Copy to clipboard

Specify the output file properties.

This command accepts only the `elf32-littlehexagon` parameter because the output file format is always 32-bit ELF format, and the Hexagon processor byte order is always little-endian.

PHDRS
    Copy to clipboard

Set information in the program header of an ELF output file.

> 
> 
> PHDRS
>     {
>       name type [FILEHDR] [PHDRS] [AT (address)] [FLAGS (flags)]
>     }
>     Copy to clipboard

Where:

- `name` specifies the program header in the `SECTIONS` command (see [SECTIONS](https://docs.qualcomm.com/doc/80-N3040-23/topic/linker.html#hu-linker-scripts-commands-sections-bookmark)).
- `type` specifies the program header type:

> 
> 
> - `PT_LOAD` - Loadable segment
>     - `PT_NULL` - Linker does not include a section in a segment

Note

No loadable section should be set to `PT_NULL`.
- `FILEHDR` and `PHDRS` - Use these keywords after the program header type to further describe the contents of the segment.

> 
> 
> - `FILEHDR` - The segment is to be included in the ELF file header.
>     - `PHDRS` - The segment is to include the ELF program headers.
- `FLAGS` sets the `p_flags` field in the program header. Supported values:
- `PF_X=1` (Execute)
- `PF_W=2` (Write)
- `PF_R=4` (Read)
- `PF_MASKOS=0x0FF00000` (Bit masking for operating system-specific semantics)
- `PF_MASKPROC=0xF0000000` (Bit masking for processor-specific semantics)

The value of `FLAGS` must be an integer. For example, `FLAGS(5)` sets `p_flags` to `PF_R | PF_X, and FLAGS(0x03000000)` sets the operating system-specific flags.

Note

If the sections in an output file have different flag settings than what is specified in `PHDRS`, the linker combines the two flags using a bitwise `or`.

Only one program header specification can be assigned to a given section. For example, the following linker script generates a linker error that indicates the same section cannot be included in two different segments:

> 
> 
> PHDRS {
>     phdr1 PT_LOAD;
>     phdr2 PT_LOAD;
>     }
>     .text : {
>     *(*.text*)
>     } : phdr1 :phdr2
>     Copy to clipboard

The `PHDRS` command overrides the default program header settings of the linker.

PROVIDE (<symbol>=<expression>);
    Copy to clipboard

Conditionally define a symbol in the linker script.

The symbol is defined with the specified value only if any unresolved references exist for the symbol during linking.

This command must be terminated with a semicolon (`;`).

SEARCH_DIR (path)
    Copy to clipboard

Add the specified path to the list of paths that the linker uses to search for libraries.

This command is equivalent to the linker command-line option, `-L`.

SECTIONS
    Copy to clipboard

Tell the linker how to map input sections to output sections, and where output sections are located in memory.

> 
> 
> SECTIONS {
>        sections-command
>        sections-command
>        sections-command
>        sections-command
>     }
>     Copy to clipboard

The sections-command can be one of the following:

- An `ENTRY` command
- A symbol assignment
- An output section description

The command contains one or more section-commands, and each can be either a section mapping statement or a symbol assignment statement:

- A section-mapping statement specifies one or more input sections in one or more library files (.text.mcldfn), and maps those sections to the specified output section. It can also use the optional addr attribute to specify the virtual memory address of the output section.
- Symbol assignment statements are used to set the location counter (see [Script syntax](https://docs.qualcomm.com/doc/80-N3040-23/topic/linker.html#hu-linker-scripts-script-syntax-sub)). The counter serves as the default address in subsequent section- mapping statements that do not explicitly specify an address.

In a section-mapping statement, wild-card characters can be used to specify multiple library files or input sections. For example, `{*(.text.*)}`.

Use the `-M` linker command line option to view the section mapping produced by a linker script.

Note

The `SECTIONS` command must appear once and only once in a linker script; all the other script commands are optional.

**Output section**

Each output section command can be one of the following:

- A symbol assignment
- An input section description
- Output section data

The output section has the following format:

> 
> 
> outputsectionname (overridetype [,permissions]) [address] [expression] [plugin_type] [(type)] : [AT(lma)] [ALIGN(section_alignment)] [SUBALIGN(subsection_alignment)] [constraint]
>     {
>         output-section-command
>         output-section-command
>         ...
>     } [>region] [AT>lma_region] [:phdr :phdr ...] [=fill]
>     Copy to clipboard

Where:

- `outputsectionname` specifies the name of the output section. The output section name, `/DISCARD/`, is special. It is used as a way to tell the linker to discard specific input sections.
- `overridetype` overrides the output section type by using overrides.

    Only the PROGBITS value is supported. When PROGBITS is used, the linker overrides the type default setting to PROGBITS.

    For Hexagon environments, the following types are supported to allow the section to be compressed using the CLADE plug-in:

> 
> 
> - `COMPRESS`
>     - `COMPRESS_RW`
>     - `COMPRESS_RO`
- `permissions` overrides the permissions of the output section. Supported values:

> 
> 
> - `RW`
>     - `RWX`
>     - `RX`
>     - `R`
- `address` is an expression for specifying the virtual memory address of the output section. This field is optional. The linker sets the virtual address to the current value of the location counter.
- `expression` specifies that an address can be an arbitrary expression.
- `plugin_type` specifies a plug-in to be run on that output section. Supported types:

> 
> 
> - `PLUGIN_CONTROL_FILESZ`
>     - `PLUGIN_CONTROL_MEMSZ`
>     - `PLUGIN_ITER_CHUNKS`
- `type` specifies the type for an output section. Each output section can have a type. Only the `NOLOAD` type is supported with the Qualcomm Linker (QCLD).
- `AT(lma)` specifies a physical address for a section.

    Every section has a virtual address (VMA) and a physical address (LMA). The linker typically sets the LMA to be equal to the VMA. You can change that by using the `AT` keyword. The `lma` expression that follows the `AT` keyword specifies the physical address of the section.
- `ALIGN(section_alignment)` aligns the output section start address. The start address is increased until it is an integral multiple of the expression specified in `section_align`.
- `SUBALIGN(subsection_alignment)` aligns the start address of an input section within an output section. The input section start address is increased until it is an integral multiple of the expression specified in `subsection_align`.
- `constraint` specifies the output section constraint. Supported values:

> 
> 
> - `ONLY_IF_RO` - Create the output section only if all of its input sections are read only.
>     - `ONLY_IF_RW` - Create the output section only if all of its input sections are read-write.
- `region` specifies the named memory region defined using the `MEMORY` or `REGION_ALIAS` directive
- `lma_region` specifies the named memory region defined using the `MEMORY` or `REGION_ALIAS` directive
- `:phdr` assigns the section to a previously-defined program segment.

    If a section is assigned to one or more segments, all subsequently allocated sections are assigned to those segments as well, unless they explicitly specify a `:phdr` attribute.
- `=fill` assigns the value of the specified expression to all unspecified memory areas of the section.

SEGMENT_START (section, default)
    Copy to clipboard

Return the base address of the specified output section. If the section is not defined, the specified address value is returned instead.

This command is used in expressions. The section is specified as a character string, and the default value as an address value. For example, `SEGMENT_START(".data", 0x1000)`.

SIZEOF_HEADERS
    Copy to clipboard

Return the size in bytes of the output file’s headers.

If the linker script uses the `SIZEOF_HEADERS` built-in function when producing an ELF output file, the linker must compute the number of program headers before it determines all the section addresses and sizes.

MEMORY
    Copy to clipboard

The `MEMORY` directive identifies ranges of memory that are available at runtime and can be used by a program. Each range has several characteristics:

- Name - Defines a memory region. The name is referred to by the output section defined using the `SECTIONS` command.
- Starting address (`ORIGIN`) - Defines the starting virtual address or the physical address of the memory region.
- `LENGTH` - Maximum permissible size of the memory region; specified in bytes
- Attributes - Optional attribute definitions for the memory region used to control placement of sections which do not assign memory region. The attributes can be defined and are optional. When defined they can contain the following letters.

    - `R` - Read-only section
    - `W` - Read/write section
    - `X` - Executable section
    - `A` - Allocatable section
    - `I` - Initialized section
    - `L` - Same as `I`
    - `!` - Invert the sense of any of the attributes that follow

The general syntax of a memory directive is:

> 
> 
> MEMORY
>     {
>         name_1 [( attributes )] : ORIGIN = expr, LENGTH = expr
>         name_n [( attributes )] : ORIGIN = expr, LENGTH = expr
>     }
>     
>     For example:
>     
>     MEMORY {
>       b1 (rx) : ORIGIN = 100, LENGTH = 48
>       b2 (rx) : ORIGIN = 200, LENGTH = 48
>       b3 (rw) : ORIGIN = 300, LENGTH = 48
>     }
>     
>     PHDRS {
>       A PT_LOAD;
>       B PT_LOAD;
>       C PT_LOAD;
>       D PT_LOAD;
>     }
>     
>     SECTIONS {
>       .t1 : { *(.text.foo) } >b1 :A
>       .t2 : { *(.text.bar) } >b2 :B
>       .t3 : { *(.text.baz) } >b3 :C
>       .t4 : { *(.text.far) } >b3 :D
>     }
>     Copy to clipboard

The above example defines memory regions `b1`, `b2`, and `b3` with starting virtual addresses of 100, 200, and 300.

The linker script assigns the following output sections to memory regions.

- The output section `t1` is assigned to region `b1`.
- The output section `t2` is assigned to region `b2`.
- The output section `t3` and `t4` is assigned the same memory region `b3`.

The memory regions all have a maximum budget of 48 bytes.

**Errors**

During program layout, if for some reason the sections do not fit in the budget, the linker issues an error.

**Output section data**

The output section data command includes `BYTE`, `SHORT`, `LONG`, `QUAD`, and `SQUAD` commands. They can be used to insert explicit bytes in an output section. `BYTE`, `SHORT`, `LONG`, and `QUAD` commands store 1, 2, 4, and 8 bytes, respectively. The location counter is incremented by the number of bytes stored. Each of these commands takes an expression that provides the value to be stored. For example:

> 
> 
> SECTIONS {
>       .BYTES : {
>         BYTE(0xab)
>         LONG(0x9a9b9c9d)
>       }
>       .text : { *(.text*) }
>     }
>     Copy to clipboard

The `.BYTES` output section will have 5 bytes size and contains the values as specified by the `BYTE` and `LONG` commands.

REGION_ALIAS
    Copy to clipboard

The `REGION_ALIAS` function creates an alias for a memory region.

The syntax of how it can be used is:

> 
> 
> REGION_ALIAS(alias_name, memory_region_name)
>     Copy to clipboard

The following shows a complete `MEMORY` and `REGION_ALIAS` example.

> 
> 
> MEMORY {
>       b1 (rx) : ORIGIN = 0x100, LENGTH = 0x220
>       b2 (rx) : ORIGIN = 0x200, LENGTH = 0x200
>       b3 (rx) : ORIGIN = 0x500, LENGTH = 0x100
>       lmab1 (rx) : ORIGIN = 0x3000, LENGTH = 0x220
>       lmab2 (rx) : ORIGIN = 0x6000, LENGTH = 0x200
>       lmab3 (rx) : ORIGIN = 0x9000, LENGTH = 0x100
>     }
>     REGION_ALIAS("r1", "b1")
>     REGION_ALIAS("r2", "b2")
>     REGION_ALIAS("r3", "b3")
>     SECTIONS {
>       .t1 : { *(.text.foo) } > r1 AT > lmab1
>       .t2 : { *(.text.bar) } > r2 AT > lmab2
>       .t3 : { *(.text.baz) } > r3 AT > lmab3
>     }
>     Copy to clipboard

The above example creates 3 aliases, `r1`, `r2`, and `r3` which alias to `b1`, `b2`, and `b3` respectively.

### Examples of linker scripts

This section presents several example linker scripts that demonstrate how to use exclusions to specify input files for linking, and how to build static and dynamic executables.

#### Exclude file in archive

To exclude a file in an archive from being linked, specify the archive as part of the input expression, and specify the file to be excluded as the parameter of the following `EXCLUDE_FILE (file ...)` command.

Note

Any sections whose names match the exclusion are still included in the link unless they are stored in the excluded archive.

The following example uses four relocatable files: `a1.o`, `a2.o`, `a3.o`, `a4.o`. Each file contains functions named `foo_N` and `bar_N`, where `N` indicates the digit in the file name. The linker script excludes `foo_2` but not `bar_2` from `.text1` (because `EXCLUDE_FILE` applies only to the immediately following section name):

script.t :
    SECTIONS {
      .text1 : {
        *lib23.a:(EXCLUDE_FILE(a2.o) .text.foo* .text.bar*)
      }
      .text2 : {
      *(*)
      }
    }
    
    hexagon-clang -ffunction-sections -c a1.c a2.c a3.c a4.c -mv5
    hexagon-ar cr lib23.a a2.o a3.o
    hexagon-ar cr lib4.a a4.o
    hexagon-link -T script.t -o mcld.out a1.o --whole-archive lib23.a lib4.a
    --no-whole-archive
    Copy to clipboard

**Section headers (starting at offset 0x22a0)**

[Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al
    [ 0]                   NULL            00000000 000000 000000 00      0   0  0
    [ 1] .text1            PROGBITS        00000000 001000 00002c 00  AX  0   0 16
    [ 2] .text2            PROGBITS        00000030 002030 00009c 00 WAX  0   0 16
    Copy to clipboard

**Symbol table**

Num:    Value  Size Type    Bind   Vis      Ndx Name
      8: 00000040    12 FUNC    GLOBAL DEFAULT    2 bar_1
      9: 00000000    12 FUNC    GLOBAL DEFAULT    1 bar_2
     10: 00000020    12 FUNC    GLOBAL DEFAULT    1 bar_3
     11: 000000c0    12 FUNC    GLOBAL DEFAULT    2 bar_4
     12: 00000030    12 FUNC    GLOBAL DEFAULT    2 foo_1
     13: 000000a0    12 FUNC    GLOBAL DEFAULT    2 foo_2
     14: 00000010    12 FUNC    GLOBAL DEFAULT    1 foo_3
     15: 000000b0    12 FUNC    GLOBAL DEFAULT    2 foo_4
    Copy to clipboard

#### Exclude all files in archive

To exclude all files in an archive from being linked, specify the archive to be excluded as the parameter of the `EXCLUDE_FILE (file ...)` command.

Note

Any sections whose names match the exclusion are still included in the link unless they are stored in the excluded archive.

The following example uses four relocatable files: `a1.o`, `a2.o`, `a3.o`, `a4.o`. Each file contains functions named `foo_N` and `bar_N`, where `N` indicates the digit in the file name. The linker script excludes `foo_2/3` but not `bar_2/3` from `.text1` (because `EXCLUDE_FILE` applies only to the immediately following section name):

script.t :
    SECTIONS {
      .text1 : {
        *lib*:(EXCLUDE_FILE(*lib23.a) .text.foo* .text.bar*)
      }
      .text2 : {
      *(*)
      }
    }
    
    hexagon-clang -ffunction-sections -c a1.c a2.c a3.c a4.c -mv5
    hexagon-ar cr lib23.a a2.o a3.o
    hexagon-ar cr lib4.a a4.o
    hexagon-link -T script.t -o mcld.out a1.o --whole-archive lib23.a lib4.a
    --no-whole-archive
    Copy to clipboard

**Section headers (starting at offset 0x22a0)**

[Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al
    [ 0]                   NULL            00000000 000000 000000 00      0   0  0
    [ 1] .text1            PROGBITS        00000000 001000 00003c 00  AX  0   0 16
    [ 2] .text2            PROGBITS        00000040 002040 00008c 00 WAX  0   0 16
    Copy to clipboard

**Symbol table**

Num:    Value  Size Type    Bind   Vis      Ndx Name
      8: 00000050    12 FUNC    GLOBAL DEFAULT    2 bar_1
      9: 00000000    12 FUNC    GLOBAL DEFAULT    1 bar_2
     10: 00000010    12 FUNC    GLOBAL DEFAULT    1 bar_3
     11: 00000030    12 FUNC    GLOBAL DEFAULT    1 bar_4
     12: 00000040    12 FUNC    GLOBAL DEFAULT    2 foo_1
     13: 000000b0    12 FUNC    GLOBAL DEFAULT    2 foo_2
     14: 000000c0    12 FUNC    GLOBAL DEFAULT    2 foo_3
     15: 00000020    12 FUNC    GLOBAL DEFAULT    1 foo_4
    Copy to clipboard

#### Exclude multiple files

To exclude multiple files from being linked, specify the files as parameters of the `EXCLUDE_FILE (file ...)` command.

Note

`EXCLUDE_FILE` accepts multiple file name parameters.

The following example uses four relocatable files: `a1.o`, `a2.o`, `a3.o`, `a4.o`. Each file contains functions named `foo_N` and `bar_N`, where `N` indicates the digit in the file name. The linker script excludes `foo_2/3` but not `bar_2/3` from `.text1` (because `EXCLUDE_FILE` applies only to the immediately following section name):

script.t :
    SECTIONS {
      .text1 : {
        *lib*:(EXCLUDE_FILE(a2.0 a3.0) .text.foo* .text.bar*)
      }
      .text2 : {
      *(*)
      }
    }
    
    hexagon-clang -ffunction-sections -c a1.c a2.c a3.c a4.c -mv5
    hexagon-ar cr lib23.a a2.o a3.o
    hexagon-ar cr lib4.a a4.o
    hexagon-link -T script.t -o mcld.out a1.o --whole-archive lib23.a lib4.a
    --no-whole-archive
    Copy to clipboard

**Section headers (starting at offset 0x2260)**

[Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al
    [ 0]                   NULL            00000000 000000 000000 00      0   0  0
    [ 1] .text1            PROGBITS        00000000 001000 00003c 00  AX  0   0 16
    [ 2] .text2            PROGBITS        00000040 002040 000040 00 WAX  0   0 16
    Copy to clipboard

**Symbol table**

Num:    Value  Size Type    Bind   Vis      Ndx Name
      8: 00000050    12 FUNC    GLOBAL DEFAULT    2 bar_1
      9: 00000000    12 FUNC    GLOBAL DEFAULT    1 bar_2
     10: 00000010    12 FUNC    GLOBAL DEFAULT    1 bar_3
     11: 00000030    12 FUNC    GLOBAL DEFAULT    1 bar_4
     12: 00000040    12 FUNC    GLOBAL DEFAULT    2 foo_1
     13: 00000060    12 FUNC    GLOBAL DEFAULT    2 foo_2
     14: 00000070    12 FUNC    GLOBAL DEFAULT    2 foo_3
     15: 00000020    12 FUNC    GLOBAL DEFAULT    1 foo_4
    Copy to clipboard

#### Exclude archive and non-archive files

To exclude both archive and a non-archive files from being linked, specify the files as parameters of the `EXCLUDE_FILE (file ...)` command. This command searches both inside and outside archives for files to exclude.

The following example uses four relocatable files: `a1.o`, `a2.o`, `a3.o`, `a4.o`. Each file contains functions named `foo_N` and `bar_N`, where `N` indicates the digit in the file name. The linker script excludes `foo_1/2` but not `bar_1/2` from `.text1` (because `EXCLUDE_FILE` applies only to the immediately following section name):

script.t :
    SECTIONS {
      .text1 : {
        *:(EXCLUDE_FILE(a[12].o) .text.foo* .text.bar*)
      }
      .text2 : {
      *(*)
      }
    }
    
    hexagon-clang -ffunction-sections -c a1.c a2.c a3.c a4.c -mv5
    hexagon-ar cr lib23.a a2.o a3.o
    hexagon-ar cr lib4.a a4.o
    hexagon-link -T script.t -o mcld.out a1.o --whole-archive lib23.a lib4.a
    --no-whole-archive
    Copy to clipboard

**Section headers (starting at offset 0x2260)**

[Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al
    [ 0]                   NULL            00000000 000000 000000 00      0   0  0
    [ 1] .text1            PROGBITS        00000000 001000 00004c 00  AX  0   0 16
    [ 2] .text2            PROGBITS        00000050 002050 000030 00 WAX  0   0 16
    Copy to clipboard

**Symbol table**

Num:    Value  Size Type    Bind   Vis      Ndx Name
      8: 00000060    12 FUNC    GLOBAL DEFAULT    2 bar_1
      9: 00000000    12 FUNC    GLOBAL DEFAULT    1 bar_2
     10: 00000020    12 FUNC    GLOBAL DEFAULT    1 bar_3
     11: 00000040    12 FUNC    GLOBAL DEFAULT    1 bar_4
     12: 00000050    12 FUNC    GLOBAL DEFAULT    2 foo_1
     13: 00000070    12 FUNC    GLOBAL DEFAULT    2 foo_2
     14: 00000010    12 FUNC    GLOBAL DEFAULT    1 foo_3
     15: 00000030    12 FUNC    GLOBAL DEFAULT    1 foo_4
    Copy to clipboard

#### Conflicting wild cards

If a section is both included and excluded in an input file specification, the exclusion has no effect, and any following section name will act like a normal wild card.

Note

This is a common error when using linker scripts.

The following example uses four relocatable files: `a1.o`, `a2.o`, `a3.o`, `a4.o`. Each file contains functions named `foo_N` and `bar_N`, where `N` indicates the digit in the file name. The linker script does not exclude `foo_2` from `.text1` (because `EXCLUDE_FILE` has no effect in this case):

script.t :
    SECTIONS {
      .text1 : {
      *lib23.a:(.text.foo* EXCLUDE_FILE(a2.o) .text.foo* .text.bar*)
      }
      .text2 : {
      *(*)
      }
    }
    
    hexagon-clang -ffunction-sections -c a1.c a2.c a3.c a4.c -mv5
    hexagon-ar cr lib23.a a2.o a3.o
    hexagon-ar cr lib4.a a4.o
    hexagon-link -T script.t -o mcld.out a1.o --whole-archive lib23.a lib4.a
    --no-whole-archive
    Copy to clipboard

Copy to clipboard

**Section headers (starting at offset 0x22a0)**

> 
> 
> [Nr] Name              Type            Addr     Off    Size   ES Flg Lk Inf Al
> [ 0]                   NULL            00000000 000000 000000 00      0   0  0
> [ 1] .text1            PROGBITS        00000000 001000 00003c 00  AX  0   0 16
> [ 2] .text2            PROGBITS        00000040 002040 00008c 00 WAX  0   0 16

**Symbol table**

Num:    Value  Size Type    Bind   Vis      Ndx Name
      8: 00000050    12 FUNC    GLOBAL DEFAULT    2 bar_1
      9: 00000010    12 FUNC    GLOBAL DEFAULT    1 bar_2
     10: 00000030    12 FUNC    GLOBAL DEFAULT    1 bar_3
     11: 000000c0    12 FUNC    GLOBAL DEFAULT    2 bar_4
     12: 00000040    12 FUNC    GLOBAL DEFAULT    2 foo_1
     13: 00000000    12 FUNC    GLOBAL DEFAULT    1 foo_2
     14: 00000020    12 FUNC    GLOBAL DEFAULT    1 foo_3
     15: 000000b0    12 FUNC    GLOBAL DEFAULT    2 foo_4
    Copy to clipboard

#### Build static executable

The following code example presents the linker script file for a static executable.

/* Script for -z combreloc: combine and sort reloc sections */
    OUTPUT_FORMAT("elf32-littlehexagon", "elf32-bighexagon",
                  "elf32-littlehexagon")
    OUTPUT_ARCH(hexagon)
    ENTRY(start)
    SEARCH_DIR("/opt/codesourcery/hexagon/lib");
    SECTIONS
    {
      /* Code starts. */
      .start          :
      {
        KEEP (*(.start))
      } =0x00c0007f
      . = ALIGN(4K);
      .init           :
      {
        KEEP (*(.init))
      } =0x00c0007f
      .text           :
      {
        *(.text.unlikely .text.*_unlikely)
        *(.text.hot .text.hot.* .gnu.linkonce.t.hot.*)
        *(.text .stub .text.* .gnu.linkonce.t.*)
        /* .gnu.warning sections are handled specially by elf32.em.  */
        *(.gnu.warning)
      } =0x00c0007f
      .fini           :
      {
        KEEP (*(.fini))
      } =0x00c0007f
      PROVIDE (__etext = .);
      PROVIDE (_etext = .);
      PROVIDE (etext = .);
      . = ALIGN(4K);
      /* Constants start. */
      .rodata         :
            {
              *(.rodata.hot .rodata.hot.* .gnu.linkonce.r.hot.*)
              *(.rodata .rodata.* .gnu.linkonce.r.*)
            }
      .eh_frame_hdr   :  { *(.eh_frame_hdr) }
      .eh_frame       :  ONLY_IF_RO { KEEP (*(.eh_frame)) }
      .gcc_except_table   :  ONLY_IF_RO { *(.gcc_except_table .gcc_except_table.*) }
      /* Data start. */
      /* Adjust the address for the data segment.  We want to adjust up to
         the same address within the page on the next page up.  */
      . = ALIGN (CONSTANT (MAXPAGESIZE)) - ((CONSTANT (MAXPAGESIZE) - .) &
                (CONSTANT (MAXPAGESIZE) - 1)); . = DATA_SEGMENT_ALIGN
                (CONSTANT (MAXPAGESIZE), CONSTANT (COMMONPAGESIZE));
      /* Exception handling  */
      .eh_frame       :  ONLY_IF_RW { KEEP (*(.eh_frame)) }
      .gcc_except_table   :  ONLY_IF_RW { *(.gcc_except_table .gcc_except_table.*) }
      .preinit_array     :
      {
        PROVIDE_HIDDEN (__preinit_array_start = .);
        KEEP (*(.preinit_array))
        PROVIDE_HIDDEN (__preinit_array_end = .);
      }
      .init_array     :
      {
         PROVIDE_HIDDEN (__init_array_start = .);
         KEEP (*(SORT(.init_array.*)))
         KEEP (*(.init_array))
         PROVIDE_HIDDEN (__init_array_end = .);
      }
      .fini_array     :
      {
        PROVIDE_HIDDEN (__fini_array_start = .);
        KEEP (*(.fini_array))
        KEEP (*(SORT(.fini_array.*)))
        PROVIDE_HIDDEN (__fini_array_end = .);
      }
      . = ALIGN(4K);
      .ctors          :
      {
        /* gcc uses crtbegin.o to find the start of
           the constructors, so we make sure it is
           first.  Because this is a wildcard, it
           doesn't matter if the user does not
           actually link against crtbegin.o; the
           linker won't look for a file to match a
           wildcard.  The wildcard also means that it
           doesn't matter which directory crtbegin.o
           is in.  */
        KEEP (*crtbegin.o(.ctors))
        KEEP (*crtbegin?.o(.ctors))
        /* We don't want to include the .ctor section from
           the crtend.o file until after the sorted ctors.
           The .ctor section from the crtend file contains the
           end of ctors marker and it must be last */
        KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o fini.o) .ctors))
        KEEP (*(SORT(.ctors.*)))
        KEEP (*(.ctors))
      }
      .dtors          :
      {
        KEEP (*crtbegin.o(.dtors))
        KEEP (*crtbegin?.o(.dtors))
        KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o fini.o) .dtors))
        KEEP (*(SORT(.dtors.*)))
        KEEP (*(.dtors))
      }
      .data           :
      {
        *(.data.hot .data.hot.* .gnu.linkonce.d.hot.*)
        *(.data .data.* .gnu.linkonce.d.*)
        SORT(CONSTRUCTORS)
      }
      _edata = .; PROVIDE (edata = .);
      . = ALIGN (64);
      __bss_start = .;
      .bss            :
      {
       *(.dynbss)
       *(.bss.hot .bss.hot.* .gnu.linkonce.b.hot.*)
       *(.bss .bss.* .gnu.linkonce.b.*)
       *(COMMON)
    
       /* Align here to ensure that the .bss section occupies space up to
          _end.  Align after .bss to ensure correct alignment even if the
          .bss section disappears because there are no input sections. */
       . = ALIGN (. != 0 ? 64 : 1);
      }
      . = ALIGN (64);
      _end = .;
      /* Small data start. */
      . = ALIGN(4K);
      . = ALIGN (64);
      .sdata          :
      {
        PROVIDE (_SDA_BASE_ = .);
        *(.sdata.1 .sdata.1.* .gnu.linkonce.s.1.*)
        *(.sbss.1 .sbss.1.* .gnu.linkonce.sb.1.*)
        *(.scommon.1 .scommon.1.*)
        *(.sdata.2 .sdata.2.* .gnu.linkonce.s.2.*)
        *(.sbss.2 .sbss.2.* .gnu.linkonce.sb.2.*)
        *(.scommon.2 .scommon.2.*)
        *(.sdata.4 .sdata.4.* .gnu.linkonce.s.4.*)
        *(.sbss.4 .sbss.4.* .gnu.linkonce.sb.4.*)
        *(.scommon.4 .scommon.4.*)
        *(.lit[a4] .lit[a4].* .gnu.linkonce.l[a4].*)
        *(.sdata.8 .sdata.8.* .gnu.linkonce.s.8.*)
        *(.sbss.8 .sbss.8.* .gnu.linkonce.sb.8.*)
        *(.scommon.8 .scommon.8.*)
        *(.lit8 .lit8.* .gnu.linkonce.l8.*)
        *(.sdata.hot .sdata.hot.* .gnu.linkonce.s.hot.*)
        *(.sdata .sdata.* .gnu.linkonce.s.*)
      }
      .sbss           :
      {
        PROVIDE (__sbss_start = .);
        PROVIDE (___sbss_start = .);
        *(.dynsbss)
        *(.sbss.hot .sbss.hot.* .gnu.linkonce.sb.hot.*)
        *(.sbss .sbss.* .gnu.linkonce.sb.*)
        *(.scommon .scommon.*)
        . = ALIGN (. != 0 ? 64 : 1);
        PROVIDE (__sbss_end = .);
        PROVIDE (___sbss_end = .);
      }
      . = ALIGN (64);
      PROVIDE (end = .);
      . = DATA_SEGMENT_END (.);
      /* Stabs debugging sections.  */
      .stab          0 :  { *(.stab) }
      .stabstr       0 :  { *(.stabstr) }
      .stab.excl     0 :  { *(.stab.excl) }
      .stab.exclstr  0 :  { *(.stab.exclstr) }
      .stab.index    0 :  { *(.stab.index) }
      .stab.indexstr 0 :  { *(.stab.indexstr) }
      .comment       0 :  { *(.comment) }
      /* DWARF debug sections.
         Symbols in the DWARF debugging sections are relative to the beginning
         of the section so we begin them at 0.  */
      /* DWARF 1 */
      .debug          0 :  { *(.debug) }
      .line           0 :  { *(.line) }
      /* GNU DWARF 1 extensions */
      .debug_srcinfo  0 :  { *(.debug_srcinfo) }
      .debug_sfnames  0 :  { *(.debug_sfnames) }
      /* DWARF 1.1 and DWARF 2 */
      .debug_aranges  0 :  { *(.debug_aranges) }
      .debug_pubnames 0 :  { *(.debug_pubnames) }
      /* DWARF 2 */
      .debug_info     0 :  { *(.debug_info .gnu.linkonce.wi.*) }
      .debug_abbrev   0 :  { *(.debug_abbrev) }
      .debug_line     0 :  { *(.debug_line) }
      .debug_frame    0 :  { *(.debug_frame) }
      .debug_str      0 :  { *(.debug_str) }
      .debug_loc      0 :  { *(.debug_loc) }
      .debug_macinfo  0 :  { *(.debug_macinfo) }
      /* SGI/MIPS DWARF 2 extensions */
      .debug_weaknames 0 :  { *(.debug_weaknames) }
      .debug_funcnames 0 :  { *(.debug_funcnames) }
      .debug_typenames 0 :  { *(.debug_typenames) }
      .debug_varnames  0 :  { *(.debug_varnames) }
      /* DWARF 3 */
      .debug_pubtypes 0 :  { *(.debug_pubtypes) }
      .debug_ranges   0 :  { *(.debug_ranges) }
      .gnu.attributes 0 :  { KEEP (*(.gnu.attributes)) }
      /DISCARD/       :  { *(.note.GNU-stack) *(.gnu_debuglink) *(.gnu.lto_*) }
    }
    Copy to clipboard

#### Build dynamic executable

The following code example presents the linker script file for a dynamic executable.

/* Script for -z combreloc: combine and sort reloc sections */
    OUTPUT_FORMAT("elf32-littlehexagon", "elf32-littlehexagon",
                  "elf32-littlehexagon")
    ENTRY(start)
    SEARCH_DIR("/opt/codesourcery/hexagon/lib");
    SECTIONS
    {
      /* Start EBI memory. */
      .interp         :
                         { *(.interp) }
      .note.gnu.build-id :  { *(.note.gnu.build-id) }
      .hash           :  { *(.hash) }
      .gnu.hash       :  { *(.gnu.hash) }
      .dynsym         :  { *(.dynsym) }
      .dynstr         :  { *(.dynstr) }
      .rela.dyn       :
        {
          *(.rela.init)
          *(.rela.text .rela.text.* .rela.gnu.linkonce.t.*)
          *(.rela.fini)
          *(.rela.rodata .rela.rodata.* .rela.gnu.linkonce.r.*)
          *(.rela.data .rela.data.* .rela.gnu.linkonce.d.*)
          *(.rela.tdata .rela.tdata.* .rela.gnu.linkonce.td.*)
          *(.rela.tbss .rela.tbss.* .rela.gnu.linkonce.tb.*)
          *(.rela.ctors)
          *(.rela.dtors)
          *(.rela.got)
          *(.rela.sdata .rela.lit[a48] .rela.sdata.* .rela.lit[a48].*
            .rela.gnu. linkonce.s.* .rela.gnu.linkonce.l[a48].*)
          *(.rela.sbss .rela.sbss.* .rela.gnu.linkonce.sb.*)
          *(.rela.sdata2 .rela.sdata2.* .rela.gnu.linkonce.s2.*)
          *(.rela.sbss2 .rela.sbss2.* .rela.gnu.linkonce.sb2.*)
          *(.rela.bss .rela.bss.* .rela.gnu.linkonce.b.*)
           PROVIDE_HIDDEN (__rela_iplt_start = .);
          *(.rela.iplt)
          PROVIDE_HIDDEN (__rela_iplt_end = .);
        }
      .rela.plt       :
        {
          *(.rela.plt)
        }
      /* Code starts. */
      . = ALIGN (DEFINED (TEXTALIGN) ? (TEXTALIGN * 1K) : CONSTANT (MAXPAGESIZE));
      .start          :
      {
        KEEP (*(.start))
      } =0x00c0007f
      . = ALIGN(4K);
      .init           :
      {
        KEEP (*(.init))
      } =0x00c0007f
      .plt            :  { *(.plt) }
      . = ALIGN (. + CONSTANT (COMMONPAGESIZE), CONSTANT (COMMONPAGESIZE));
      .text           :
      {
        *(.text.unlikely .text.*_unlikely)
        *(.text.hot .text.hot.* .gnu.linkonce.t.hot.*)
        *(.text .stub .text.* .gnu.linkonce.t.*)
        /* .gnu.warning sections are handled specially by elf32.em.  */
        *(.gnu.warning)
      } =0x00c0007f
      .fini           :
      {
        KEEP (*(.fini))
      } =0x00c0007f
      PROVIDE (__etext = .);
      PROVIDE (_etext = .);
      PROVIDE (etext = .);
    /* Constants start. */
      . = ALIGN (4K);
      .rodata         :
            {
              *(.rodata.hot .rodata.hot.* .gnu.linkonce.r.hot.*)
              *(.rodata .rodata.* .gnu.linkonce.r.*)
            }
      .eh_frame_hdr   :  { *(.eh_frame_hdr) }
      .eh_frame       :  ONLY_IF_RO { KEEP (*(.eh_frame)) }
      .gcc_except_table   :  ONLY_IF_RO { *(.gcc_except_table .gcc_except_table.*) }
      /* Data start. */
      . = ALIGN (4K);
      /* Exception handling  */
      .eh_frame       :  ONLY_IF_RW { KEEP (*(.eh_frame)) }
      .gcc_except_table   :  ONLY_IF_RW { *(.gcc_except_table .gcc_except_table.*) }
      .preinit_array     :
      {
        PROVIDE_HIDDEN (__preinit_array_start = .);
        KEEP (*(.preinit_array))
        PROVIDE_HIDDEN (__preinit_array_end = .);
      }
      .init_array     :
      {
         PROVIDE_HIDDEN (__init_array_start = .);
         KEEP (*(SORT(.init_array.*)))
         KEEP (*(.init_array))
         PROVIDE_HIDDEN (__init_array_end = .);
      }
      .fini_array     :
      {
        PROVIDE_HIDDEN (__fini_array_start = .);
        KEEP (*(.fini_array))
        KEEP (*(SORT(.fini_array.*)))
        PROVIDE_HIDDEN (__fini_array_end = .);
      }
      .ctors          :
      {
        /* gcc uses crtbegin.o to find the start of
           the constructors, so we make sure it is
           first.  Because this is a wildcard, it
           doesn't matter if the user does not
           actually link against crtbegin.o; the
           linker won't look for a file to match a
           wildcard.  The wildcard also means that it
           doesn't matter which directory crtbegin.o
           is in.  */
        KEEP (*crtbegin.o(.ctors))
        KEEP (*crtbegin?.o(.ctors))
    
        /* We don't want to include the .ctor section from
           the crtend.o file until after the sorted ctors.
           The .ctor section from the crtend file contains the
           end of ctors marker and it must be last */
        KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o fini.o) .ctors))
        KEEP (*(SORT(.ctors.*)))
        KEEP (*(.ctors))
      }
      .dtors          :
      {
        KEEP (*crtbegin.o(.dtors))
        KEEP (*crtbegin?.o(.dtors))
        KEEP (*(EXCLUDE_FILE (*crtend.o *crtend?.o fini.o) .dtors))
        KEEP (*(SORT(.dtors.*)))
        KEEP (*(.dtors))
      }
      _DYNAMIC = .;
      .dynamic        :  { *(.dynamic) }
      .got            :  { *(.got) *(.igot) }
      . = DATA_SEGMENT_RELRO_END (16, .);
      .got.plt        :  { *(.got.plt)  *(.igot.plt) }
      .data           :
      {
        *(.data.hot .data.hot.* .gnu.linkonce.d.hot.*)
        *(.data .data.* .gnu.linkonce.d.*)
        SORT(CONSTRUCTORS)
      }
      .data1          :  { *(.data1) }
      _edata = .; PROVIDE (edata = .);
      /* Small data start. */
      . = ALIGN (4K);
      . = ALIGN (64);
      .sdata          :
      {
        PROVIDE (_SDA_BASE_ = .);
        *(.sdata.1.8 .sdata.1.8.* .gnu.linkonce.s.1.8.*)
        *(.sbss.1.8 .sbss.1.8.* .gnu.linkonce.sb.1.8.*)
        *(.scommon.1.8 .scommon.1.8.*)
        *(.sdata.1.4 .sdata.1.4.* .gnu.linkonce.s.1.4.*)
        *(.sbss.1.4 .sbss.1.4.* .gnu.linkonce.sb.1.4.*)
        *(.scommon.1.4 .scommon.1.4.*)
        *(.sdata.1.2 .sdata.1.2.* .gnu.linkonce.s.1.2.*)
        *(.sbss.1.2 .sbss.1.2.* .gnu.linkonce.sb.1.2.*)
        *(.scommon.1.2 .scommon.1.2.*)
        *(.sdata.1.1 .sdata.1.1.* .gnu.linkonce.s.1.1.*)
        *(.sbss.1.1 .sbss.1.1.* .gnu.linkonce.sb.1.1.*)
        *(.scommon.1.1 .scommon.1.1.*)
        *(.sdata.1 .sdata.1.* .gnu.linkonce.s.1.*)
        *(.sbss.1 .sbss.1.* .gnu.linkonce.sb.1.*)
        *(.scommon.1 .scommon.1.*)
        *(.sdata.2.8 .sdata.2.8.* .gnu.linkonce.s.2.8.*)
        *(.sbss.2.8 .sbss.2.8.* .gnu.linkonce.sb.2.8.*)
        *(.scommon.2.8 .scommon.2.8.*)
        *(.sdata.2.4 .sdata.2.4.* .gnu.linkonce.s.2.4.*)
        *(.sbss.2.4 .sbss.2.4.* .gnu.linkonce.sb.2.4.*)
        *(.scommon.2.4 .scommon.2.4.*)
        *(.sdata.2.2 .sdata.2.2.* .gnu.linkonce.s.2.2.*)
        *(.sbss.2.2 .sbss.2.2.* .gnu.linkonce.sb.2.2.*)
        *(.scommon.2.2 .scommon.2.2.*)
        *(.sdata.2 .sdata.2.* .gnu.linkonce.s.2.*)
        *(.sbss.2 .sbss.2.* .gnu.linkonce.sb.2.*)
        *(.scommon.2 .scommon.2.*)
        *(.sdata.4.8 .sdata.4.8.* .gnu.linkonce.s.4.8.*)
        *(.sbss.4.8 .sbss.4.8.* .gnu.linkonce.sb.4.8.*)
        *(.scommon.4.8 .scommon.4.8.*)
        *(.sdata.4.4 .sdata.4.4.* .gnu.linkonce.s.4.4.*)
        *(.sbss.4.4 .sbss.4.4.* .gnu.linkonce.sb.4.4.*)
        *(.scommon.4.4 .scommon.4.4.*)
        *(.sdata.4 .sdata.4.* .gnu.linkonce.s.4.*)
        *(.sbss.4 .sbss.4.* .gnu.linkonce.sb.4.*)
        *(.scommon.4 .scommon.4.*)
        *(.lit[a4] .lit[a4].* .gnu.linkonce.l4.*)
        *(.sdata.8.8 .sdata.8.8.* .gnu.linkonce.s.8.8.*)
        *(.sbss.8.8 .sbss.8.8.* .gnu.linkonce.sb.8.8.*)
        *(.scommon.8.8 .scommon.8.8.*)
        *(.sdata.8 .sdata.8.* .gnu.linkonce.s.8.*)
        *(.sbss.8 .sbss.8.* .gnu.linkonce.sb.8.*)
        *(.scommon.8 .scommon.8.*)
        *(.lit8 .lit8.* .gnu.linkonce.l8.*)
        *(.sdata.hot .sdata.hot.* .gnu.linkonce.s.hot.*)
        *(.sdata .sdata.* .gnu.linkonce.s.*)
      }
      .got            :  { *(.got) *(.igot) }
      . = ALIGN (64);
      .sbss           :
      {
        PROVIDE (__sbss_start = .);
        PROVIDE (___sbss_start = .);
        *(.dynsbss)
        *(.sbss.hot .sbss.hot.* .gnu.linkonce.sb.hot.*)
        *(.sbss .sbss.* .gnu.linkonce.sb.*)
        *(.scommon .scommon.*)
        . = ALIGN (. != 0 ? 64 : 1);
        PROVIDE (__sbss_end = .);
        PROVIDE (___sbss_end = .);
      }
      . = ALIGN (64);
      __bss_start = .;
      .bss            :
      {
       *(.dynbss)
       *(.bss.hot .bss.hot.* .gnu.linkonce.b.hot.*)
       *(.bss .bss.* .gnu.linkonce.b.*)
       *(COMMON)
       /* Align here to ensure that the .bss section occupies space up to
          _end.  Align after .bss to ensure correct alignment even if the
          .bss section disappears because there are no input sections. */
       . = ALIGN (. != 0 ? 64 : 1);
      }
      . = ALIGN (64);
      _end = .;
      . = ALIGN (64);
      PROVIDE (end = .);
      . = DATA_SEGMENT_END (.);
      .comment       0 :  { *(.comment) }
      /* DWARF debug sections.
         Symbols in the DWARF debugging sections are relative to the beginning
         of the section so we begin them at 0.  */
      /* DWARF 1 */
      .debug          0 :  { *(.debug) }
      .line           0 :  { *(.line) }
      /* GNU DWARF 1 extensions */
      .debug_srcinfo  0 :  { *(.debug_srcinfo) }
      .debug_sfnames  0 :  { *(.debug_sfnames) }
      /* DWARF 1.1 and DWARF 2 */
      .debug_aranges  0 :  { *(.debug_aranges) }
      .debug_pubnames 0 :  { *(.debug_pubnames) }
      /* DWARF 2 */
      .debug_info     0 :  { *(.debug_info .gnu.linkonce.wi.*) }
      .debug_abbrev   0 :  { *(.debug_abbrev) }
      .debug_line     0 :  { *(.debug_line) }
      .debug_frame    0 :  { *(.debug_frame) }
      .debug_str      0 :  { *(.debug_str) }
      .debug_loc      0 :  { *(.debug_loc) }
      .debug_macinfo  0 :  { *(.debug_macinfo) }
      /* SGI/MIPS DWARF 2 extensions */
      .debug_weaknames 0 :  { *(.debug_weaknames) }
      .debug_funcnames 0 :  { *(.debug_funcnames) }
      .debug_typenames 0 :  { *(.debug_typenames) }
      .debug_varnames  0 :  { *(.debug_varnames) }
      /* DWARF 3 */
      .debug_pubtypes 0 :  { *(.debug_pubtypes) }
      .debug_ranges   0 :  { *(.debug_ranges) }
      .gnu.attributes 0 :  { KEEP (*(.gnu.attributes)) }
      /DISCARD/       :  { *(.note.GNU-stack) *(.gnu_debuglink) *(.gnu.lto_*) }
    }
    Copy to clipboard

#### Rule matching for common symbols

The below linker script shows how to match common symbols using input section descriptions.

SECTIONS {
      .scommon1 : { *(.scommon.1) }
      .scommon4 : { *(.scommon.4) }
      .common : { *(COMMON) *(.scommon*) }
    }
    Copy to clipboard

In the above example, the `.scommon1` output section matches all common symbols that have a section index corresponding to the section `.scommon.1`. The `.scommon4` output section matches all common symbols that have a section index corresponding to the `.scommon.4`. The `.common` section matches all remaining common symbols.

#### Map sections to memory regions with access permission

The following linker script tells the linker to put all input sections from all files with the name `.text.foo` into an output section with the name `.foo`. The output  section is loaded into a memory region with write/execute (W/X) access permission at runtime.

PHDRS {
      foophdr PT_LOAD FLAGS(5);
    }
    
    SECTIONS {
       .foo : { *(.text.foo) } :foophdr
    }
    Copy to clipboard

The output section, `.foo`, goes to the segment named foophdr with read/write permission. You can examine the result by using the `readelf` program with the `-l` option.

## Link-time optimization

Link-time optimization (LTO) is a compilation mode in which an intermediated language is written to object files and the optimizer is invoked during the linking stage. This approach has the following advantages:

- The scope of inter-procedural analysis can encompass the entire program that is visible at link-time.
- Compared to the file-by-file approach, where every file is optimized independently, LTO can leverage knowledge of the entire program to apply various inter-procedural optimizations (function inlining, dead code stripping, and so on).

The following graphic illustrates an overview of where LTO fits in the compilation process.

![../../_images/hex-utilities-lto-overview.png](data:image/png;base64,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)

### Example

The following example illustrates the advantages of the LTO integrated approach and clean interface. This example requires a system linker that supports LTO through the interface described in this document. In this example:

- Input source file `a.c` is compiled into LLVM bitcode form.
- Input source file `main.c` is compiled into native object code.

--- a.h ---
    extern int foo1(void);
    extern void foo2(void);
    extern void foo4(void);
    --- a.c ---
    #include “a.h”
    
    static signed int i = 0;
    void foo2(void){
      i = -1;
    }
    
    static int foo3(){
      foo4();
      return 10;
    }
    
    int foo1(void){
      int data = 0;
    
      if(i<0)
        data = foo3();
      data = data + 42;
      return data;
    }
    
    --- main.c ---
    #include <stdio.h>
    #include “a.h”
    
    void foo4(void){
      printf(“Hi\n”);
    }
    
    int main(){
      return foo1();
    }
    To compile, run:
    % clang -emit-llvm -c a.c -o a.o  # <-- a.o is the LLVM bitcode file
    % clang -c main.c -o main.o       # <-- main.o is the native object file
    % clang a.o main.o -o main        # <-- standard link command without
                                            modifications
    Copy to clipboard

In this example:

- The linker recognizes that `foo2()` is an externally visible symbol defined in the LLVM bitcode file. The linker completes its usual symbol resolution pass and finds that `foo2()` is not used anywhere. This information is used by the LLVM optimizer and it removes `foo2()`.
- As soon as `foo2()` is removed, the optimizer recognizes that condition `i < 0` is always false, which means `foo3()` is never used. Hence, the optimizer also removes `foo3()`.
- This, in turn, enables the linker to remove `foo4()`.

This example illustrates the advantage of tight integration with the linker. Here, the optimizer cannot remove `foo3()` without the linker’s input.

### Multiphase communication between libLTO and linker

The linker collects information about symbol definitions and uses in various link objects, which is more accurate than any information collected by other tools during typical build cycles. The linker collects this information by looking at the definitions and uses of the symbols in native `.o` files and using symbol visibility information. The linker also uses user- supplied information, such as a list of exported symbols.

The LLVM optimizer collects control flow information and data flow information, and it knows much more about program structure from the optimizer’s point of view. The goal is to take advantage of tight integration between the linker and the optimizer by sharing this information during various linking phases.

## Develop linker plug-ins

The QCLD allows one or more linker plug-ins to be loaded and called during link time. Develop the linker plug-ins to query the linker about objects being linked during link time, and to evaluate their properties. You can also change the order and contents of output sections using this approach.

Use C++ to develop the linker plug-ins. They are built as shared libraries that allow the linker to dynamically load at link time. The plug-ins use a fixed API that allows you to communicate with the linker.

Plug-ins are currently supported on all architectures where the functionality is available.

The Hexagon Tools 8.2 release introduced the functionality for writing plug-ins and integrating the functionality at link time.

### Plug-in usage

Most developers use linker scripts, and the linker plug-in functionality can therefore be exercised using linker scripts. This is to promote ease of use and have less maintenance overhead. It is also easier to integrate with existing builds. The linker can also provide better diagnostics.

### Linker wrapper

Build a plug-in as a dynamic library and interact with the linkerusing an opaque `LinkerWrapper` handle. The linker wrapper exists as a shared library that you link with the user plug-in. The linker wrapper is named `libLW.so` on Linux platforms and `LW.dll` on Windows platforms.

### User plug-in types

The intent of each user-developed plug-in is associated with an appropriate interface. You can implement the plug-in algorithm by deriving it from one such interface.

You can use more than one interface in a single plug-in. Plug-in chaining can be used interchangeably to denote when you are mixing more than one interface in a single plug-in. The rest of this section might use `PluginType` interchangeably to denote this.

Currently, four interface types are available. More interface types will be added based on new use cases in the future. Each interface type has an associated header file that you can include in the plug-in:

| Interface type | Header file |
| --- | --- |
| Section iterator plug-in type | `SectionIteratorPlugin.h` |
| Chunk iterator plug-in type | `ChunkIteratorPlugin.h` |
| Control memory size plug-in type | `ControlMemorySizePlugin.h` |
| Control file size plug-in type | `ControlFileSizePlugin.h` |

### LinkerScript changes

Linker plug-ins can be enabled using linker scripts. The linker script keyword uses a fixed syntax:

<PluginType>("<LibraryName>", "<PluginName>" [, "<PluginOptions>"])
    Copy to clipboard

**Options**

PluginType
    Copy to clipboard

Corresponds to one of the available interface types.

LibraryName
    Copy to clipboard

Corresponds to the dynamic library that contains the plug-in for the linker to load.

This option uses the same linker semantics for linking to the linker in a library, allowing ease of use. It uses the name of the library without the `lib` prefix on Linux and without the `SO/DLL` extension on Linux/Windows, respectively.

PluginName
    Copy to clipboard

Specify the name of the plug-in. The linker queries the dynamic library to provide an implementation for the specified interface type.

PluginOptions
    Copy to clipboard

Pass an option to the plug-in.

### User plug-in work flow

Use the following steps to create one or more linker plug-ins.

1. Determine the appropriate interfaces.
2. Include the appropriate header file.
3. Create a C++ class derived from one of the interface types.
4. Associate the implementation of the interface to have a unique name.
5. Build a shared library.
6. Write a `RegisterAll()` function to register the plug-ins.
7. Write a `getPlugin()` function to return the appropriate plug-in when the linker queries with `PluginName()`.

### Linker work flow

All user plug-ins that are loaded by the linker must be initialized properly before the plug-in can communicate with the linker and perform the steps.

#### Linker operation

The linker performs the following sequence of operations with respect to plug-ins:

1. Parses the linker script and finds all plug-ins.
2. Loads the library specified by `LibraryName`.

    1. Uses `LD_LIBRARY_PATH` on Linux.
    2. Uses a standard method for searching dynamic libraries in Windows.
3. Calls the `RegisterAll()` function in the library, which registers all the plug-ins that are contained in the library.
4. Queries the library using the `getPlugin()` function with `PluginName`.

    The library returns the appropriate object for the linker to use to run the plug-in algorithm.
5. Inspects the plug-in to verify that the linker script keyword and the object have the same interface type.
6. Initializes the plug-in with any additional options provided.
7. Passes the appropriate content to the plug-in expressed as data structures for that `PluginType`.
8. Runs the plug-in algorithm.

    Because more than one plug-in can be used and because plug-ins can be chained, the linker unloads the library only after all user plug-ins have been called.
9. Before the plug-in is unloaded, the linker calls a function to destroy the plug-in.

    This is the last step before the library is unloaded.
10. The linker then unloads the plug-in.

#### Plug-in tracing

Trace the linker work flow with the following option:

-trace==plugin
    Copy to clipboard

### Plug-in data structures

Appropriate data structures are exchanged depending on the specified plug-in interface type.

These data structures are also used to communicate with the linker and get appropriate information from the linker.

Block
    Copy to clipboard

Corresponds to the content of the output section with corrected relocations.

Chunk
    Copy to clipboard

Corresponds to a piece of an input section. Examples:

- Individual strings of a section that contains merged strings
- Contents of an output section

INIFile
    Copy to clipboard

Represents the contents of a configuration file in ini format. An `ini` file can be serialized into this data structure using `LinkerWrapprer::readINIFile` and written using `LinkerWrapper::writeINIFile`.

LinkerScriptRule
    Copy to clipboard

Corresponds to a `LinkerScriptRule` in an `OutputSection`.

OutputSection
    Copy to clipboard

Corresponds to an `OutputSection` section in the LinkerScript or output ELF file.

Section
    Copy to clipboard

Corresponds to an input section from an ELF file.

Symbol
    Copy to clipboard

Corresponds to an ELF symbol.

Use
    Copy to clipboard

Corresponds to a relocation from a chunk or section.

### LinkerWrapper commands

The plug-in uses the LinkerWrapper to communicate and exchange information with the linker. Following are the LinkerWrapper commands.

Note

Use the `PluginADT.h` file to learn about the APIs documented in the header file.

AllocateMemory
    Copy to clipboard

Allocate memory that must live for the duration of the link.

The `ControlMemorySize` and `ControlFileSize` interface types are the most common users of this functionality.

findConfigFile(<filename>)
    Copy to clipboard

Searches for a file matching `filename` in the linker’s search path, and returns the absolute path of the matching file if it is found. Otherwise, the command returns an empty string.

getOutputSection(<Section>)
    Copy to clipboard

Determine which `OutputSection` was chosen by the linker. The `OutputSection` is usually chosen by the linker by matching rules in the linker script.

getSymbol(<SymbolName>)
    Copy to clipboard

Get more information from the linker for a symbol (specified by `SymbolName`).

getUses(<Chunk>)
    Copy to clipboard

Query the linker to find out what a `Chunk` refers to. The API returns a vector of uses.

getUses(<Section>)
    Copy to clipboard

Queries the linker to find out what a `Section` refers to. The API returns a vector of uses.

getVersion
    Copy to clipboard

Return the version of the LinkerWrapper as a string. This command is useful for diagnostics.

MatchPattern(<Pattern>, <Name>)
    Copy to clipboard

Utility function that allows the plug-in to match a Glob Pattern with a string.

readINIFile(<FileName>)
    Copy to clipboard

Returns an INIFile data structure representing the configuration file, `FileName`.

resetError
    Copy to clipboard

Reset any error status.

setLinkerFatalError
    Copy to clipboard

Used by the plug-in when it discovers there is an unhandled case when trying to link input files to produce an output image.

setOutputSection(<Section>, <OutputSectionName>)
    Copy to clipboard

Place the `Section` into the specified `OutputSection` in the linker script.

This command allows linker script decisions to be overridden for that `Section`.

writeINIFile(<INIFile>, <OutputPath>)
    Copy to clipboard

Write the INIFile to the `OutputPath`, and, depending on the success of the operation, returns `std::<error_code>`.

### Linker plug-in interface

Following is the plug-in interface that the linker will use and provide implementation for the functions:

class Plugin {
    public:
    /* Initialize the plugin with options specified */
    virtual void Init(std::string Options) = 0;
    /* The actual algorithm that will be implemented */
    virtual Status Run (bool Verbose)= 0;
    /* Linker will call Destroy, and the client can free up any data
    structures that are not relevant */
    virtual void Destroy()= 0;
    /* Returns the last error; a value of 0 means there was no error */
    virtual uint32_t GetLastError()= 0;
    /* Returns the error as a string */
    virtual std::string GetLastErrorAsString ()= 0;
    /* Returns the name of the plugin */
    virtual std::string GetName()= 0;
    /* Destructor */
    virtual -Plugin(){}
    };
    Copy to clipboard

### Plug-in interfaces

The following interfaces are available in the release toolchain.

#### SectionIterator interface

Use the linker script keyword, `PLUGIN_ITER_SECTIONS`.

This interface allows you to process every input section from every object file by implementing `processSection()`.

class SectionIteratorPlugin : public Plugin {
    public:
    /* Chunk Section that the linker will call the client with */
    virtual void processSection(Section S)= 0;
    };
    Copy to clipboard

#### SectionMatcher interface

Use the linker script keyword, `PLUGIN_SECTION_MATCHER`.

This interface allows you to process every input section, and it allows the plug-in to read any section. You can use the interface to read metadata sections or read sections that were garbage collected by the linker. `SectionMatcherPlugin` differs from `SectionIteratorPlugin` in that it allows any section content to be read before assigning output sections.

class SectionMatcherPlugin : public Plugin {
    public:
    /* Sections that the linker will call the client with */
    virtual void processSection(Section S) = 0;
    };
    Copy to clipboard

#### ChunkIterator interface

Use the linker script keyword, `PLUGIN_ITER_CHUNKS`.

This interface allows you to process every input chunk in an output section using `ProcessChunk()`.

The processed chunks are returned when the linker calls `getChunks()`.

class ChunkIteratorPlugin : public Plugin {
    public:
    /* Chunks that the linker will call the client with */
    virtual void processChunk(Chunk C) = 0;
    virtual std::vector<Chunk> getChunks()= 0;
    };
    Copy to clipboard

#### ControlFileSize interface

Use the linker script keyword, `PLUGIN_CONTROL FILESZ`.

This interface allows you to process the output memory block contained in an output section using `AddBlocks()`.

The processed block is returned when the linker calls `GetBlocks()`.

An example of such a plug-in is to take the memory block, compress it, and then return it to the linker.

class ControlFileSizePlugin : public Plugin {
    public:
    /* Memory blocks that the linker will call the client with */
    virtual void AddBlocks(Block memBlock) = 0;
    /* Return memory blocks to the client */
    virtual std::vector<Block> GetBlocks()= 0;
    };
    Copy to clipboard

#### ControlMemorySize interface

Use the linker script keyword, `PLUGIN_CONTROL MEMSZ`.

This interface allows you to process the output memory block contained in an output section using `AddBlocks()`.

The processed block is returned when the linker calls `GetBlocks()`.

class ControlMemorySizePlugin : public Plugin {
    public:
    /* Memory blocks that the linker will call the client with */
    virtual void AddBlocks(Block memBlock) = 0;
    /* Return memory blocks to the client */
    virtual std::vector<Block> GetBlocks()= 0;
    };
    Copy to clipboard

#### OutputSectionIterator interface

Use the linker script keyword, `PLUGIN_OUTPUT_SECTION_ITER`.

The interface is defined as follows:

class OutputSectionIteratorPlugin : public Plugin {  public:
    /* OutputSection that the linker will call the client  with */
    virtual void processOutputSection(OutputSection O)= 0;
    };
    Copy to clipboard

The interface allows the plug-in to iterate over all output sections and their contents. Contents of output sections are described by rules.

The `OutputSectionIterator` is called at various times during the linking stages:

- `BeforeLayout`
- `CreatingSections`
- `AfterLayout`

The state of the linker can be queried by calling a function `getState` in the LinkerWrapper. Depending on the state of the linker, the plug-in can query `OutputSections` and its contents appropriately.

The `OutputSectionIterator` interface allows the plug-in to iterate over rules specified in the `OutputSection` and what sections are essentially contained in a `LinkerScriptRule`. Depending on the state of the Linker, the contents of the `LinkerScriptRule` can be modified. Modifications of `LinkerScriptRule` contents include changing the `OutputSection` for a Section, changing the `OutputSection` for a Chunk.

BeforeLayout
    Copy to clipboard

When the state of the linker is set to `BeforeLayout`, the plug-in can query each rule for its contents. The contents of the Rule can on`ly be `Sections`.

Call the `setOutputSection()` function in the LinkerWrapper to set the Section point to a different `OutputSection`.

Finish with all the assignments to different output sections by calling `finishAssignOutputSections` in the LinkerWrapper.

CreatingSections
    Copy to clipboard

When the state of the linker is set to CreatingSections, the plug-in can query each rule for its contents. The contents of the Rule can only be Chunks.

Call APIs specified in the LinkerScriptRule to do one of the following:

- `addChunk` - Add a Chunk to a LinkerScriptRule
- `removeChunk` - Remove a Chunk from a LinkerScriptRule
- `updateChunk` - Replace Chunks in a LinkerScriptRule

AfterLayout
    Copy to clipboard

When the state of the linker is set to `AfterLayout`, the plug-in can query for the size of the `OutputSection`.

### Signal handling

If a crash occurs, the linker signal handler emits a message that displays whether the crash came from the linker or the plug-in. For example:

Fatal: !!!PLUGIN CRASHED!!!
    User specified plugin LinkerCrashPlugin caused segmentation fault
    Fatal: Please rerun link with /tmp/reproduce-aa23c0.sh and contact support
    Copy to clipboard

The message indicates whether the crash happened in the linker or plug-in, and it includes a path to a script that can reproduce the failure.

### Map file

The Map file records any changes made by the plug-in for the layout. This is a good place to determine how the layout was affected due to the plug-in algorithm.

### Example plug-ins

#### Match island sections and get uses

**LinkerScript**

PHDRS {
    P PT_LOAD;
    A PT_LOAD;
    }
    PLUGIN_ITER_SECTIONS ("matchislandsections", "MATCHANDFINDUSES") SECTIONS {
      .island : {
        *(.text.island*)
      }:P
      .bar :{
        *(.text.bar)
      }:A
    }
    Copy to clipboard

**Example user code for linking**

int foo(){return 0; }
    int bar (){return foo(); }
    _attribute_((section (".text.island_baz")))int baz(){return foo()+ bar();
    }
    Copy to clipboard

**Plug-in code**

#include “SectioniteratorPlugin.h”
    #include <iostream>
    #include <string>
    #include <cstring>
    #include <unordered_map>
    #include <algorithm>
    #include <queue>
    #include <set>
    
    using namespace QCLD;
    
    class DLL_A_EXPORT FindUsesPlugin : public SectionIteratorPlugin {
    public:
      FindUsesPlugin() : SectionIteratorPlugin ("MATCHANDFINDUSES"){}
      void Init(std::string Options)override {}
      void processSection(QCLD::Section S)override {
        if (S.matchPattern(".text.island*"))
          m_Sections.push_back(S);
      }
    
      Status Run(bool Trace) override {
        for (auto &S : m_Sections)
          printSectionUses(S);
        return Plugin::Status::SUCCESS;
      }
    
      void printSectionUses(QCLD::Section S){
        std::queue<QCLD::Use> Uses;
        for (auto &U : Linker->getUses(S))
          Uses.push(U);
        std::set<Chunk, Chunk::Compare> SectionUses;
        while (!Uses.empty()){
          Use &U = Uses.front();
          Uses.pop();
          Chunk ChunkForUse = U.getChunk{);
          SectionUses.insert(ChunkForUse);
          for (auto &V : Linker->getUses(ChunkForUse))
            Uses.push(V);
        }
        std::cout << "Uses for section " << S.getName() << "\n";
        for (auto &C : SectionUses )
          std::cout << C.getName() << "\n";
      }
    
      void Destroy() override {}
    
      uint32_t GetLastError() override { return 0; }
      std::string GetlastErrorAsString() override { return "SUCCESS"; }
      std::string GetName() override { return "MATCHANDFINDUSES "; }
    
    private:
      std::vector<QCLD::Section> m_Sections;
    
    };
    std::unordered_map<std::string, Plugin *> Plugins;
    extern "C" {
    bool DLL_A_EXPORT RegisterAll(){
        Plugins["MATCHANDFINDUSES"]= new FindUsesPlugin();
        return true;
      }
    
      Plugin DLL_A_EXPORT *getPlugin(const char *T) {
        return Plugins[std::string(T)];
      }
    }
    Copy to clipboard

#### Reorder chunks

**Linker script**

PHDRS {
      P PT_LOAD;
      A PT_LOAD;
      B PT_LOAD;
    }
    SECTIONS {
    .foo PLUGIN_ITER_CHUNKS("order","ORDERBLOCKS", "G0") : {
        *(.text.foo)
        *(.text.baz)
      }:P
      .bar :{
        *(.text.bar)
      }:A
      .plugin : {
        *(.pluginfoo )
      }:B
    }
    Copy to clipboard

**Input file for linking**

int foo() { return bar(); }
    int bar() { return foo(); }
    int baz() { return foo()+ bar(); }
    Copy to clipboard

**Plug-in code**

#include "ChunkIteratorPlugin.h"
    #include <string>
    #include <cstring>
    #include <unordered_map>
    #include <algorithm>
    
    using namespace QCLD;
    
    class DLL_A_EXPORT OrderChunksPlugin : public ChunkIteratorPlugin {
    
    public:
    
      OrderChunksPlugin() : ChunkIteratorPlugin("ORDERBLOCKS"), Chunks(){}
    
      void Init(std::string Options) override {}
    
      void processChunk(Chunk C) override {Chunks.push_back(C); }
    
      Status Run(bool Trace) override {
        std::sort(Chunks.begin(), Chunks.end(),
                  [](const Chunk &A, const Chunk &B) { return A.getName ()<
                  B.getName(); });
        return Plugin::Status::SUCCESS;
        }
    
      std::vector<Chunk> getChunks() override { return Chunks; }
    
      void Destroy() override {}
    
      uint32_t GetLastError() override { return 0; }
    
      std::string GetLastErrorAsString() override { return "SUCCESS"; }
    
      std::string GetName() override { return "ORDERBLOCKS"; }
    
    private:
    
      std::vector<Chunk> Chunks;
    
    };
    
    std::unordered_map<std::string, Plugin *> Plugins;
    
    extern "C" {
    bool DLL_A_EXPORT RegisterAll() {
      Plugins["ORDERBLOCKS"]= new OrderChunksPlugin ();
      return true;
      }
      Plugin DLL_A_EXPORT *getPlugin(const char *T) {
        return Plugins [std :string(T)];
      }
    }
    Copy to clipboard

## Bundled plug-ins

The plug-ins described in this section are included with the linker as part of the toolchain release and can be used without installing them separately.

### Section budgeting

Section budgeting enables you to allocate a size budget for specific output sections. If an output section exceeds its size budget, section budgeting moves input sections into a user- defined overflow section based on a priority ordering. The priority is determined using profile counts if the compiler’s profile-driven section placement functionality is being used.

- Sections with the lowest PGO counts (if section placement is being used) are moved first.
- If the section is still not within budget after all sections with PGO counts have been moved to the overflow section, sections are moved in the reverse order in which they appear in the output section (last in, first out).

#### Configuration

The section budgeting plug-in must be enabled in the linker script using the following directive at the top level (outside any `SECTIONS {...}` block or similar block):

PLUGIN_ITER_SECTIONS("SectionBudgetingV2", "SectionBudgetingV2", "budget.cfg")
    Copy to clipboard

Alternatively, the configuration file can also be specified via the `SECTION_BUDGETING_CFG` environment variable. If an environment variable is used, the file name in the linker script can be left blank, as in the following example:

PLUGIN_ITER_SECTIONS("SectionBudgetingV2", "SectionBudgetingV2", "")
    Copy to clipboard

The `budget.cfg` file specifies the budgets and overflow sections:

.hotcode:
       size: 4096
       overflow: .text
    .hotdata:
       size: 2048
       overflow: .data
    GLOBAL:
        report-file: budget-report.log
        section-contents-file: budget-contents.log
    .text_foo:
        size: 22528
        policy: no-overflow
    
    .rodata_foo:
        size: 7168
        policy: no-overflow
    
    .text_sw_hot:
        size: 229376
        overflow: .text_sw
    Copy to clipboard

Note

The indentation (using an equal amount of spaces) of `size:` and `policy:` is significant. This is a YAML file, so you can use # to comment out lines. The budget is specified in bytes.

The configuration file must be located in the directory from which the linker is called (typically `build/ms/`).

The `GLOBAL` configuration specifies an optional report file (`report-file:`) name to contain summary of taken actions, and an optional detailed report file (`section-contents-file:`) name to contain a full list of objects allocated to every section.

### Profile-based section sorting plug-in

This plug-in allows you to rearrange the layout of functions in an output section based on call graph and run-time behavior (via profile guided feedback) in a way that increases spatial access locality and decreases frequent call distance. This may also reduce the number of trampolines.

The default section layout chosen by the linker generally follows the order of files on the command line as well as linker script rules (if specified). However, the C/C++ standards do not guarantee a specific order of functions in the final executable. The section sorting plug-in takes advantage of this fact by detecting strongly connected components in the function call graph (over-imposed with call frequencies) and arranging them in closely located clusters with the cluster size driven by instruction cache block parameters. This increases the probability of cache hits for frequent callers/callees. The clusters themselves are arranged in random order.

For example, as shown in the graphic, any arrangement of these functions other than ABCD in memory will result in a larger overall call distance if call frequency is considered. Following figure describes the section sorting plug-in.

![../../_images/hex-utilities-section-sort-plugin.jpeg](data:image/jpeg;base64,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)

#### Configuration

To enable the section sorting plug-in, use the following syntax in the linker script:

.mytext PLUGIN_ITER_CHUNKS("SortPGO","SORTPGO","LLVMProfile.prof")
    {
     *dir1*:(.text .text.*)
     *dir2*:(.text .text.*)
    }
    Copy to clipboard

### Control flow integrity

Control flow integrity (CFI) is a security feature that provides protection against malicious attacks targeted at control flow. A common attack vector is to use indirect branch instruction to force control flow to transfer to malicious code. The Hexagon toolchain supports an optimized version of CFI—single label CFI (SLCFI)—that protects against these attack vectors without the code and runtime overhead of traditional CFI implementations.

SLCFI requires support from the compiler, linker, and runtime (RT) components.

1. At compile time, the compiler detects all functions that can be targeted with indirect jumps (`callr, jumpr`).
2. The linker separates the functions into dedicated corrals and replaces `callr/jumpr` instructions to the functions with a call to a RT wrapper (`__llvm_cfi_handler`) provided from the RT library.
3. This wrapper checks whether the access via `callr/jumpr` instructions is targeting one of the corralled functions.
4. Any other access is ignored and/or flagged as malicious.

The `-fsingle-label-cfi` flag enables SLCFI.

The following figure shows a conceptual implementation of SLCFI.

![../../_images/hex-utilities-cfi.png](data:image/png;base64,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)

## Tools

### Proto2txt

Proto2txt takes a binary map file as input and produces a text representation of the map file. This tool is actively being developed and more features are being added.

#### Command and options

To start the tool from the command line:

proto2txt <option,...>
    Copy to clipboard

Where `<option,...>` is one or more of the following:

-detailed-info
    -dump
    --help
    --map-file <name>
    --output <path> | -o <path>
    --version
    Copy to clipboard

#### Options

-detailed-info
    Copy to clipboard

Print detailed information with the linker map.

-dump
    Copy to clipboard

Dump all information including linker map and debug information.

--help
    Copy to clipboard

Print option help content.

--map-file <name>
    Copy to clipboard

Specify a binary map file name.

--output <path>
    -o <path>
    Copy to clipboard

Specify a path to the file to write output.

--version
    Copy to clipboard

Print the version.

#### Example

$ proto2txt --map-file map.bin
    Copy to clipboard

**Output**

# Linker from QuIC LLVM Hexagon Clang version Version 8.6 Engineering Release: hexagon-clang-86-6805
    # Linker based on LLVM version: 13.0
    # Notable linker command/script options:
    # CPU Architecture Version:
    # Target triple environment for the link: unknown
    # Maximum GP size: 8
    # Link type: Static
    # ABI Page Size: 0x1000
    # CommandLine : /prj/qct/llvm/release/internal/HEXAGON/branch-8.6/linux64/latest/Tools/bin/hexagon-link 1.o -MapStyle binary -Map map
    # LinkStats Begin
    # ObjectFiles : 1
    ...
    <linker map continued>
    Copy to clipboard

### Proto2yaml

Proto2yaml takes as input a binary map file and produces a YAML representation of the map file.

This tool is actively being developed and more features are being added.

#### Command

To start the tool from the command line:

proto2yaml <option,...>
    Copy to clipboard

Where `<option,...>` is one or more of the following:

--help
    --map-file name
    --output <path> | -o <path>
    --version
    Copy to clipboard

#### Options

--help
    Copy to clipboard

Print option help.

--map-file <name>
    Copy to clipboard

Specify a binary map file name.

--output <path>
    -o <path>
    Copy to clipboard

Specify a path to the file to write output.

--version
    Copy to clipboard

Print the version.

#### Example

$ proto2yaml --map-file map.bin
    Copy to clipboard

**Output**

---
    Header:
      Architecture:    hexagon
      Emulation:       hexagonv68
      AddressSize:     32bit
    VersionInformation:
      CompilerVersion: '8.6 Engineering Release: hexagon-clang-86-6805'
      LinkerVersion:   '13.0'
    LinkStats:
      - Name:            ObjectFiles
        Count:           1
    ...
    <linker map continued>
    Copy to clipboard

### DeepMapParser.py

Use DeepMapParser.py to parse binary linker map files generated by the linker.

From the command line tool, you can view and analyze the link map file. From the DeepMap GUI tool, you can see a deep analysis of the linker map files.

When used with Python from the toolchain, C++ bindings help to speed up the DeepMapParser.

#### Command

To start the tool from the command line:

python DeepMapParser.py [<option>,...]
    Copy to clipboard

Where `[<options>,...]` is one or more of the following:

--filter-discard-kind discard_kind
    --filter-input-files <path(object-file)>
    --filter-input-sections <name>
    --filter-output-sections <name>
    --filter-segments <name>
    --filter-symbols <name>
    --filter-type <type>
    --generate-mappings
    --help                |  -h
    --map-file <name>
    --output-file <name>    | -o <name>
    --output-style <format> | -os <format>
    --show-commandline-data
    --show-header
    --show-input-files
    --show-input-sections
    --show-link-stats
    --show-linker-scripts
    --show-load-sequence
    --show-output-sections
    --show-segments
    --show-symbols
    --sort-input-files <value,...>
    --sort-input-sections <value,...>
    --sort-output-sections <value,...>
    --sort-symbols <value,...>
    --verbose  | -v
    Copy to clipboard

#### Options

--filter-discard-kind discard_kind
    Copy to clipboard

Filter on input sections that were discarded from the output file.

--filter-input-files <path(object-file)>
    Copy to clipboard

Filter on input files in the file path.

For objects in archives, the path is in the format, `<Archive-Path(object-file)>`&gt;.

--filter-input-sections <name>
    Copy to clipboard

Filter on the input section by name.

--filter-output-sections <name>
    Copy to clipboard

Filter on the output section by name.

--filter-segments <name>
    Copy to clipboard

Filter on segments or load regions by name.

--filter-symbols <name>
    Copy to clipboard

Filter on symbols by name.

--filter-type <type>
    Copy to clipboard

Filter type for pattern matching.

--generate-mappings
    Copy to clipboard

Generates internal mappings between input sections, output sections and symbols. This mapping can be used with `-verify` switch to validate the binary linker map against the ELF file.

--help
    -h
    Copy to clipboard

Display command usage information and the list of command options.

--map-file <name>
    Copy to clipboard

Specify the path and name of the binary map file.

--output-file <name>
    -o <name>
    Copy to clipboard

Specify the name of the output file to write to.

-output-style <format>
    -os <format>
    Copy to clipboard

Set the output file format as text or CSV. The default setting is text.

--show-commandline-data
    Copy to clipboard

Print the complete link command used to create an output file.

--show-header
    Copy to clipboard

Print the map file header.

--show-input-files
    Copy to clipboard

Print all the input files that are passed to the linker.

--show-input-sections
    Copy to clipboard

Print the filtered input sections.

The following options can be used with this `--show-input-sections` option to filter its output:

> 
> 
> --filter-input-files
>     --filter-input-sections
>     Copy to clipboard

--show-link-stats
    Copy to clipboard

Print the link statistics.

--show-linker-scripts
    Copy to clipboard

Print the hierarchy of the linker script file.

--show-load-sequence
    Copy to clipboard

Print the input files in sequence as seen by the linker.

-show-output-sections
    Copy to clipboard

Print all output sections.

--show-segments
    Copy to clipboard

Print the filtered segments.

The `--filter-segments` option can be used with this `--show-segments` option to filter its output.

--show-symbols
    Copy to clipboard

Print the filtered symbols.

The following options can be used with this `--show-symbols` option to filter its output:

> 
> 
> --filter-input-files
>     --filter-input-sections
>     --filter-output-sections
>     --filter-symbols
>     Copy to clipboard

--sort-input-files <value,...>
    Copy to clipboard

Sort on input files based on one or more of the following values.

- `arch` - Sort the input files by archive files.
- `obj` - Sort the input files by object files.
- `origin` - Sort the input files by object and archive file paths.
- `usage` - Sort the input files by files used or not used, essentially grouping them by usage.

--sort-input-sections <value,...>
    Copy to clipboard

Sort on input sections based on one or more of the following values.

- `alignment` - Sort the input sections by alignment.
- `flagString` - Sort the input sections by section flags.
- `name` - Sort the input sections by the name of the input section.
- `offset` - Sort the input sections by offset.
- `origin` - Sort the input sections by the origin path of the section.
- `physicalAddress` - Sort the input sections by physical address.
- `size` - Sort the input sections by size.
- `typeString` - Sort the input sections by section type.
- `virtualAddress` - Sort the input sections by virtual address.

--sort-output-sections <value,...>
    Copy to clipboard

Sort on output sections based on one or more of the following values.

- `addr` - Sort the output sections by virtual address.
- `alignment` - Sort the output sections by section alignment.
- `flagString` - Sort the output sections by section flag.
- `lma` - Sort the output sections by physical address.
- `name` - Sort the output sections by section name.
- `offset` - Sort the output sections by section offset.
- `size` - Sort the output sections by section size.
- `typeString` - Sort the output sections by section type.

--sort-symbols <value,...>
    Copy to clipboard

Sort on symbols based on one or more of the following values.

- `name` - Sort the symbols by symbol name.
- `origin` - Sort the symbols by symbol origin path.
- `size` - Sort the symbols by symbol size.

--verbose
    -v
    Copy to clipboard

Show detailed output for any DeepMapParser option.

#### Example

> 
> 
> $ python3 DeepMapParser.py –map-file map.bin –show-header

**Output**

Using C++ bindings for binary map file
    
    # Linker from QuIC LLVM Hexagon Clang version Version 8.6 Engineering Release: hexagon-clang-86-6805
    # Linker based on LLVM version: 13.0
    # Notable linker command/script options:
    # CPU Architecture Version:
    # Target triple environment for the link: unknown
    # Maximum GP size: 8
    # Link type: Static
    # ABI Page Size: 0x1000
    # CommandLine : /prj/qct/llvm/release/internal/HEXAGON/branch-8.6/linux64/latest/Tools/bin/hexagon-link 1.o -MapStyle binary -Map map
    Copy to clipboard

## Control symbol exports

Use the `--dynamic-list`, `-E`, and `--version-script` options to control the symbols that are added to the `.dynsym` section of the dynamic linker.

### Use –dynamic-list and -E options

The `--dynamic-list` and `-E` options only affect an executable that was created by linking with a shared object.

- The `-E` option exports all symbols. The linker does not regard any `--dynamic-list` if it is used with this option.
- The `--dynamic-list` option exports symbols that are in a file that is passed with this option.

Typically, the linker exports all symbols that are not defined but are resolved by the shared library at runtime in the `.dynsym` table. These exported symbols are added together with the symbols that are in the dynamic list.

**Example**

In `main.c`:

extern int foo();
    int bar() { return 1; } int baz() { return 2; }
    int main() { return bar() + baz() + foo() ; }
    Copy to clipboard

In `foo.c`:

int foo() { return 3; }
    int anotherfoo() { return 4;}
    static int foo_local() { return foo(); }
    int shlibbar() { return foo() + anotherfoo(); }
    Copy to clipboard

In `list`:

{
    bar;
    };
    Copy to clipboard

Note

In the dynamic list, each symbol name ends with a semicolon, as does the list itself.

Usage:

hexagon-clang -fpic -c foo.c -o foo.o hexagon-clang -c main.c
    hexagon-link -shared -o libfoo.so foo.o
    hexagon-link -dy --dynamic-list list main.o libfoo.so -o main
    hexagon-readelf -D -s main
    Copy to clipboard

Symbol table for the image:

Num Buc:    Value  Size  Type  Bind   Vis      Ndx  Name
      2   0: 000000d0    12  FUNC  GLOBAL DEFAULT    7  bar
      1   0: 00000000     0  FUNC  GLOBAL DEFAULT  UND  foo
    Copy to clipboard

Note

As shown, foo was exported even though it was not in the list, because it was required to fully resolve main at runtime.

Usage:

hexagon-link -dy -E --dynamic-list list main.o libfoo.so
    hexagon-readelf -D -s main
    Copy to clipboard

Symbol table for the image:

Num Buc:    Value  Size  Type  Bind   Vis      Ndx  Name
      3   1: 00000118    48  FUNC  GLOBAL DEFAULT    7  main
      4   2: 0000010c    12  FUNC  GLOBAL DEFAULT    7  baz
      2   4: 00000100    12  FUNC  GLOBAL DEFAULT    7  bar
      1   4: 00000000     0  FUNC  GLOBAL DEFAULT  UND  foo
    Copy to clipboard

The `--dynamic-list` option has no effect on linking a shared object. To build an executable, the `--dynamic-list` option has the same effect with `--force-dynamic` as with the `-dy` option.

The `--dynamic-list` option has no effect on garbage collection in the linker. The symbols that are not to be collected by garbage collection optimization must be explicitly listed in the linker script or added to the script using the `--extern-list` option.

### Use –version-script option

The `--version-script` option is more useful when creating shared objects (although it can be used in creating executables) to control symbol exports in the `.dynsym` table.

The version script has two scope specifiers: `global` and `local`. The symbols listed under each specifier are used as guides to restrict the symbol export. This script is only used to restrict, and not increase, a symbol’s scope. Symbols can also be specified with glob patterns for matching symbols. The version script also takes effect when creating program independent executables that have a `-shared` switch passed to them.

**Example**

version_script
    {
      global:
      foo*;
      local:
      *bar*;
    };
    Copy to clipboard

Usage:

hexagon-link -shared --version-script=version_script -o libfoo.so foo.o
    hexagon-readelf -D -s libfoo.so
    Copy to clipboard

Symbol table for the image:

Num Buc:    Value  Size  Type  Bind   Vis     Ndx  Name
      1   0: 00000160    12  FUNC  GLOBAL DEFAULT   6  foo
      2   2: 00000188    12  FUNC  GLOBAL DEFAULT   6  anotherfoo
    Copy to clipboard

Observations:

- `foo_local` was not exported despite matching a pattern in the global scope because it is a local symbol.
- Both `bar` and `shlibbar` were not exported because they are restricted to the local scope, as specified in the version script.

Note

Use the version script to control symbol versions using version nodes and a dependent node specification in the script. Currently, these features are not supported. Only anonymous version nodes for symbols are supported.

Last Published: Oct 06, 2026

[Previous Topic
Packet comparison](https://docs.qualcomm.com/bundle/publicresource/80-N3040-23/topics/assembler.md)