The IPA control file is a stream file that contains additional
IPA processing directives. The control file can be a member of a file,
and uses the QSYS.LIB naming convention (for example, /qsys.lib/mylib.lib/xx.file/yy.mbr).
The IPACTLFILE parameter identifies the path name of this file.
IPA issues an error message if the control file directives have
syntax that is not valid.
You can specify the following directives in the control file:
exits=name[,name]
Specifies a list of functions, each of which always ends the
program. You can optimize calls to these functions (for example, by
eliminating save and restore sequences), because the calls never return
to the program. These functions must not call any other parts of the
program that have IL data associated with them.
inline=attribute
Specifies how you want the compiler to identify functions that
you want it to process inline. You can specify the following attributes
for this directive:
auto
Specifies that the inliner should determine if a function can
be inlined on the basis of the inline-limit and inline-threshold values.
The noinline directive overrides automatic inlining. This is the default.
noauto
Specifies that IPA should consider for inlining only the functions
that you have specified by name with the inline directive.
name[,name]
Specifies a list of functions that you want to inline. The functions
may or may not be inlined.
name[,name] from name[,name]
Specifies a list of functions that are desirable candidates
for inlining, if a particular function or list of functions calls
the functions. The functions may or may not be inlined.
inline-limit=num
Specifies the maximum relative size (in abstract code units)
to which a function can grow before inlining stops. Abstract code
units are proportional in size to the executable code in the function.
Larger values for this number allow the compiler to inline larger
subprograms, more subprogram calls, or both. This directive is applicable
only when inline=auto is on. The default value is 8192.
inline-threshold=size
Specifies the maximum size (in abstract code units) of a function
that can be a candidate for automatic inlining. This directive is
applicable only when inline=auto is on. The default size is 1024.
isolated=name[,name]
Specifies a list of "isolated" functions. Isolated functions
are those that do not directly (or indirectly through another function
within its call chain) refer to or change global variables that are
accessible to visible functions. IPA assumes that functions that are
bound from service programs are isolated.
lowfreq=name[,name]
Specifies names of functions that are expected to be called
infrequently. These are typically error handling functions or trace
functions. IPA can make other parts of the program faster by doing
less optimization for calls to these functions.
missing=attribute
Specifies the interprocedural behavior of missing functions.
Missing functions are those that do not have IL data associated with
them, and that are not explicitly named in an unknown, safe, isolated,
or pure directive. These directives specify how much optimization
IPA can safely perform on calls to library routines that do not have
IL data associated with them.
IPA has no visibility to the code
within these functions. You must ensure that all user references are
resolved with user libraries or runtime libraries.
The default
setting for this directive is unknown. Unknown instructs
IPA to make pessimistic assumptions about the data that may be used
and changed through a call to such a missing function, and about the
functions that may be called indirectly through it. You can specify
the following attributes for this directive:
unknown
Specifies that the missing functions are "unknown". See the
description for the unknown directive below. This is the default attribute.
safe
Specifies that the missing functions are "safe". See the description
for the safe directive, below.
isolated
Specifies that the missing functions are "isolated". See the
description for the isolated directive, above.
pure
Specifies that the missing functions are "pure". See the description
for the pure directive, below.
noinline=name[,name]
Specifies a list of functions that the compiler will not inline.
noinline=name[,name] from name[,name]
Specifies a list of functions that the compiler will not inline,
if the functions are called from a particular function or list of
functions.
partition=small| medium|large|unsigned-integer
Specifies the size of each program partition that IPA creates.
The size of the partition is directly proportional to the time required
to link and the quality of the generated code. When the partition
size is large, the time required to link is longer but the quality
of the generated code is generally better.
The default for this
directive is medium.
For a finer degree of control, you can
use an unsigned-integer value to specify the partition size. The integer
is in abstract code units, and its meaning may change between releases.
You should only use this integer for very short term tuning efforts,
or for those situations where the number of partitions must remain
constant.
pure=name[,name]
Specifies a list of pure functions.
These are functions that are safe and isolated. A pure function has
no observable internal state. This means that the returned value for
a given call of a function is independent of any previous or future
calls of the function.
safe=name[,name]
Specifies a list of safe functions.
These are functions that do not directly or indirectly call any function
that has IL data associated with it. A safe function may refer to
and change global variables.
unknown=name[,name]
Specifies a list of unknown functions.
These are functions that are not safe, isolated, or pure.