You copied the Doc URL to your clipboard.

Arm Compiler armlink User Guide : Use of $Super$$ and $Sub$$ to patch symbol definitions

Use of $Super$$ and $Sub$$ to patch symbol definitions

There are special patterns that you can use for situations where an existing symbol cannot be modified or recompiled.

An existing symbol cannot be modified if, for example, it is located in an external library or in ROM code. In such cases, you can use the $Super$$ and $Sub$$ patterns to patch an existing symbol.

To patch the definition of the function foo(), $Sub$$foo and the original definition of foo() must be a global or weak definition:

$Super$$foo

Identifies the original unpatched function foo(). Use this pattern to call the original function directly.

$Sub$$foo

Identifies the new function that is called instead of the original function foo(). Use this pattern to add processing before or after the original function.

The $Sub$$ and $Super$$ linker mechanism can operate only on symbol definitions and references that are visible to the tool. For example, the compiler can replace a call to printf("Hello\n") with puts("Hello") in a C program. Only the reference to the symbol puts is visible to the linker, so defining $Sub$$printf will not redirect this call.

Note

  • The $Sub$$ and $Super$$ mechanism only works at static link time, $Super$$ references cannot be imported or exported into the dynamic symbol table.
  • If the compiler inlines a function, for example foo(), then it is not possible to patch the inlined function with the substitute function, $Sub$$foo.

Example

The following example shows how to use $Super$$ and $Sub$$ to insert a call to the function ExtraFunc() before the call to the legacy function foo().

extern void ExtraFunc(void);
extern void $Super$$foo(void);

/* this function is called instead of the original foo() */
void $Sub$$foo(void)
{
  ExtraFunc();    /* does some extra setup work */
  $Super$$foo();  /* calls the original foo() function */
                  /* To avoid calling the original foo() function
                   * omit the $Super$$foo(); function call.
                   */
}
Was this page helpful? Yes No