#### 3.4.5 Other Linker Script Commands

There are a few other linker scripts commands.

`ASSERT(exp, message)`

  Ensure that exp is non-zero. If it is zero, then exit the linker with an error code, and print message.

  Note that assertions are checked before the final stages of linking take place. This means that expressions involving symbols PROVIDEd inside section definitions will fail if the user has not set values for those symbols. The only exception to this rule is PROVIDEd symbols that just reference dot. Thus an assertion like this:

        .stack :
        {
          PROVIDE (__stack = .);
          PROVIDE (__stack_size = 0x100);
          ASSERT ((__stack > (_end + __stack_size)), "Error: No room left for the stack");
        }

  will fail if `__stack_size` is not defined elsewhere. Symbols PROVIDEd outside of section definitions are evaluated earlier, so they can be used inside ASSERTions. Thus:

        PROVIDE (__stack_size = 0x100);
        .stack :
        {
          PROVIDE (__stack = .);
          ASSERT ((__stack > (_end + __stack_size)), "Error: No room left for the stack");
        }

  will work.

`EXTERN(symbol symbol …)`

  Force symbol to be entered in the output file as an undefined symbol. Doing this may, for example, trigger linking of additional modules from standard libraries. You may list several symbols for each `EXTERN`, and you may use `EXTERN` multiple times. This command has the same effect as the ‘`-u`’ command-line option.

`FORCE_COMMON_ALLOCATION`

  This command has the same effect as the ‘`-d`’ command-line option: to make `ld` assign space to common symbols even if a relocatable output file is specified (‘`-r`’).

`INHIBIT_COMMON_ALLOCATION`

  This command has the same effect as the ‘`--no-define-common`’ command-line option: to make `ld` omit the assignment of addresses to common symbols even for a non-relocatable output file.

`FORCE_GROUP_ALLOCATION`

  This command has the same effect as the ‘`--force-group-allocation`’ command-line option: to make `ld` place section group members like normal input sections, and to delete the section groups even if a relocatable output file is specified (‘`-r`’).

`INSERT [ AFTER | BEFORE ] output_section`

  This command is typically used in a script specified by ‘`-T`’ to augment the default `SECTIONS` with, for example, overlays. It inserts all prior linker script statements after (or before) output_section, and also causes ‘`-T`’ to not override the default linker script. The exact insertion point is as for orphan sections. See Location Counter. The insertion happens after the linker has mapped input sections to output sections. Prior to the insertion, since ‘`-T`’ scripts are parsed before the default linker script, statements in the ‘`-T`’ script occur before the default linker script statements in the internal linker representation of the script. In particular, input section assignments will be made to ‘`-T`’ output sections before those in the default script. Here is an example of how a ‘`-T`’ script using `INSERT` might look:

      SECTIONS
      {
        OVERLAY :
        {
          .ov1 { ov1*(.text) }
          .ov2 { ov2*(.text) }
        }
      }
      INSERT AFTER .text;

`NOCROSSREFS(section section …)`

  This command may be used to tell `ld` to issue an error about any references among certain output sections.

  In certain types of programs, particularly on embedded systems when using overlays, when one section is loaded into memory, another section will not be. Any direct references between the two sections would be errors. For example, it would be an error if code in one section called a function defined in the other section.

  The `NOCROSSREFS` command takes a list of output section names. If `ld` detects any cross references between the sections, it reports an error and returns a non-zero exit status. Note that the `NOCROSSREFS` command uses output section names, not input section names.

`NOCROSSREFS_TO(tosection fromsection …)`

  This command may be used to tell `ld` to issue an error about any references to one section from a list of other sections.

  The `NOCROSSREFS` command is useful when ensuring that two or more output sections are entirely independent but there are situations where a one-way dependency is needed. For example, in a multi-core application there may be shared code that can be called from each core but for safety must never call back.

  The `NOCROSSREFS_TO` command takes a list of output section names. The first section can not be referenced from any of the other sections. If `ld` detects any references to the first section from any of the other sections, it reports an error and returns a non-zero exit status. Note that the `NOCROSSREFS_TO` command uses output section names, not input section names.

`OUTPUT_ARCH(bfdarch)`

  Specify a particular output machine architecture. The argument is one of the names used by the BFD library (see BFD). You can see the architecture of an object file by using the `objdump` program with the ‘`-f`’ option.

`LD_FEATURE(string)`

  This command may be used to modify `ld` behavior. If string is `"SANE_EXPR"` then absolute symbols and numbers in a script are simply treated as numbers everywhere. See Expression Section.