struct Arm7.ArchiveGoal |
![](../../../../Arrow_up.png) |
The goal specification passed to the archive
function
XDCscript usage |
meta-domain |
var obj = new Arm7.ArchiveGoal;
obj.base = String ...
// base name of the source and destination
obj.dstPrefix = String ...
// directory prefix of destination file
obj.dstSuffix = String ...
// suffix of destination file; e.g., ".a62"
obj.files = String ...
// String of files to archive
obj.profile = String ...
// index into profiles map
obj.opts = String ...
// goal specific archiver options
SEE
struct Arm7.Command |
![](../../../../Arrow_up.png) |
Required command and options
XDCscript usage |
meta-domain |
var obj = new Arm7.Command;
obj.cmd = String ...
// the command to run
obj.opts = String ...
// required options for the command
FIELDS
cmd
name of a tool-chain executable without any path
information. The location of this executable is
specified by the binDir (or pathPrefix)
configuration parameter.
opts
required options passed to the command; these options
can not be changed or eliminated by user's
configuration script.
DETAILS
The compile, link, and archive functions in this interface are
implemented by expanding the strings specified in this structure
and inserting strings from the Options structure to form a single
command. The strings in this structure can not be changed by
the user (they are fixed by the target), but the string in the
Options structure may be changed by the user.
The final command is:
Command.cmd Options.prefix Command.opts Options.suffix
struct Arm7.CommandSet |
![](../../../../Arrow_up.png) |
The commands necessary to create a specified goal
XDCscript usage |
meta-domain |
var obj = new Arm7.CommandSet;
obj.msg = String ...
// brief message describing subsequent commands
obj.cmds = String ...
// commands necessary to generate goal
obj.path = String[] ...
// host-independent representation of PATH
obj.envs = String[] ...
// environment variable settings for the cmds
FIELDS
msg
a brief synopsis of the commands specified by cmds;
this string is output in lieu of cmds when building
in "non-verbose" mode.
cmds
a single string of commands that must be executed
to complete the specified operation. Multiple
commands may be specified by separating each command
with the '\n' character.
To facilitate the creation of "portable" makefiles and
to simplify the implementation of targets, certain
distinguished "macros" may be embedded in this string.
The build engine replaces these macros with the
values described below.
- $(rootDir)
-
the target's rootDir configuration
parameter
- $(packageBase)
-
the target package's
xdc.IPackage.packageBase property
- $(XDCINCS)
-
a set of "-I" options that names each
repository in the package path
envs
an array of "name=value" strings that represent
environment variables that are defined prior to the
execution of the commands specified by cmds
path
an array of directory names that are used to compose
the PATH environment variable that is in effect when
the commands specified by cmds are run.
DETAILS
This structure is the return value of the
compile,
link and
archive functions. This value is then
used to generate a makefile or any other files necessary to generate
a specified goal.
SEE
struct Arm7.CompileGoal |
![](../../../../Arrow_up.png) |
The goal specification passed to the compile
function
XDCscript usage |
meta-domain |
var obj = new Arm7.CompileGoal;
obj.base = String ...
// base name of the source and destination
obj.dstPrefix = String ...
// directory prefix of destination file
obj.dstSuffix = String ...
// suffix of destination file; e.g., ".o62"
obj.srcSuffix = String ...
// optional suffix of source file; e.g., ".c"
obj.srcPrefix = String ...
// optional directory prefix of source file
obj.profile = String ...
// index into profiles map
// goal specific compiler options
obj.configOpts = Bool ...
// true if compiling the generated C config file
SEE
struct Arm7.CompileOptions |
![](../../../../Arrow_up.png) |
Options passed to the compiler/assembler
XDCscript usage |
meta-domain |
var obj = new Arm7.CompileOptions;
obj.aopts = String ...
// goal specific ASM options
obj.copts = String ...
// goal specific C compiler options
obj.cfgcopts = String ...
// goal specific C config file options
obj.defs = String ...
// goal specific C/ASM definition options
obj.incs = String ...
// goal specific C/ASM include options
FIELDS
aopts
a string of target-specific assembler options
copts
a string of target-specific C/C++ compiler options
cfgcopts
a string of C/C++ compiler options for C config file,
includes 'copts' in addition to the value passed
defs
a string of macro definitions each of the form
"-Dname=value" separated by white space
incs
a string of include directories each of the form
"-Idir" separated by white space
PREDEFINED MACROS
The XDC Build Engine automatically adds several predefined macros via
-D definitions that enable conditional compilation of source files
based on build-specific attributes.
- xdc_bld__profile_{profile_name}
-
this symbol is always defined and {profile_name} is the
compile goal's (see CompileGoal) profile name.
In addition, each target defines a set of macros that enable clients
to portably support big/little endian targets, for example. These
macros are indirectly included by sources that include
xdc/std.h;
see
xdc.
SEE
struct Arm7.DebugGen |
![](../../../../Arrow_up.png) |
Debugger integration support
XDCscript usage |
meta-domain |
var obj = new Arm7.DebugGen;
obj.execTemplate = String ...
// debugger template for executable
obj.execPattern = String ...
// exec file name pattern
obj.packageTemplate = String ...
// debugger template for package
obj.packagePattern = String ...
// package file name pattern
DETAILS
This structure specifies additional files that are generated
in order to support integration with a debugger. For example, the
default setting for TI targets specifies the generation of CCS
project files that allow one to easily debug executables that have
been constructed from multiple packages.
There are two "types" of debug support files that are generated;
one for the package as a whole, and one for each executable.
Since packages may contain portable sources that are built for more
than one target, a "package-level" file is generated for each target
used in the package. A separate file is generated for each
executable built within the package.
The execTemplate and packageTemplate fields name a template that
is expanded in the context of the config model and the build
model, respectively. These fields should be set to a file name
string which is relative to the package path; e.g., the string
"ti/targets/cc_exec.xdt" refers to the file "cc_exec.xdt" in the
ti.targets package located along the package path.
Preconditions for the execTemplate:
- this
-
the configured program object (xdc.cfg.Program);
i.e., the program object *after* the program's
configuration script completes.
- $args
-
array of arguments passed to the template
- $args[1]
-
the name of the executable being produced for this
configuration.
- environment
-
hash table of XDC global parameters; e.g., "xdc.path",
"xdc.root", ...
Preconditions for the packageTemplate:
- this
-
the "package contents" object (i.e.,
xdc.bld.PackageContents) *after* the package's
build script (package.bld) completes.
- $args
-
array of arguments passed to the template
- $args[0]
-
the target (a module implementing the
xdc.bld.ITarget interface)
- $args[1]
-
hash-table of all package sources
- environment
-
hash table of XDC global parameters; e.g., "xdc.path",
"xdc.root", ...
The execPattern and packagePattern fields are expressions that
are expanded prior to template expansion to determine the name of
the output file. Expressions of the form "$(name)" within the
pattern string are expanded if "name" is one of the built-in
variables listed below.
Built-in variables for execPattern:
- cfgName
-
the name of the generated configuration file (without
any directory prefix);
- cfgDir
-
the name of the directory containing the config file;
- exeName
-
the name of the executable file (without any
directory prefix);
- exeDir
-
the directory containing the executable file.
Both the exeDir and cfgDir are relative to the directory
containing the package.bld script.
Built-in variables for packagePattern:
- pkgName
-
the package's name (e.g., "ti.targets");
- trgName
-
the target's name property;
- trgSuffix
-
the target's suffix property.
SEE
struct Arm7.Extension |
![](../../../../Arrow_up.png) |
File extension to file type association
XDCscript usage |
meta-domain |
var obj = new Arm7.Extension;
obj.suf = String ...
// file extension (including any '.')
obj.typ = String ...
// type of this file; e.g., "c", "asm", ..
FIELDS
suf
the file extension including any '.' characters
typ
the type of the file having this extension.
Allowable file type identifiers include:
- "c"
-
C language source file
- "asm"
-
assembly language source file
- "cpp"
-
C++ language source file
DETAILS
This structure is used by the Build Engine to determine whether a
file should be treated as C++, C, or assembly language source.
SEE
struct Arm7.LinkGoal |
![](../../../../Arrow_up.png) |
The goal specification passed to the link function
XDCscript usage |
meta-domain |
var obj = new Arm7.LinkGoal;
obj.base = String ...
// base name of the source and destination
obj.dstPrefix = String ...
// directory prefix of destination file
obj.dstSuffix = String ...
// suffix of destination file; e.g., ".x62"
obj.files = String ...
// string of files to link with
obj.profile = String ...
// index into profiles map
obj.opts = String ...
// goal specific linker options
obj.dllMode = Bool ...
// true if we're linking an assembly
obj.isRom = Bool ...
// reflects the isRom attribute
SEE
struct Arm7.Model |
![](../../../../Arrow_up.png) |
Target runtime model
XDCscript usage |
meta-domain |
var obj = new Arm7.Model;
obj.endian = String ...
// endian-ness of this target
obj.codeModel = String ...
// target-specific code model
obj.dataModel = String ...
// target-specific data model
obj.shortEnums = Bool ...
// if true, enums are packed into smallest integral type
FIELDS
(endian) this string specifies the endianess of the
generated code. Valid values include:
- "big"
-
big endian
- "little"
-
little endian
- null
-
unspecified
(codeModel) this string specifies a target-specific code size
model. Valid values include:
- "near"
-
C54 near mode
- "far"
-
C54 far mode
- undefined
-
unspecified
(dataModel) this string specifies a target-specific data size
model. Valid values include:
- "large"
-
C55, C28 large model
- undefined
-
unspecified
(shortEnums) this flag specifies if a target fits the values
of an enumeration into the smallest integer type
that can accept all values. If that is the case,
this flag must be set to true. If all values are
the size of an Int, this flag can be either set
to false or left unspecified.
SEE
struct Arm7.OptionSet |
![](../../../../Arrow_up.png) |
Collection of tool-chain options
XDCscript usage |
meta-domain |
var obj = new Arm7.OptionSet;
// profile-specific compiler opts
obj.linkOpts = String ...
// profile-specific linker opts
obj.archiveOpts = String ...
// profile-specific archiver opts
// ITargetFilter instance descs
FIELDS
compilerOptions
a set of compiler/assembler options
linkOpts
a string of target-specific linker options
archiveOpts
a string of target-specific archiver options
filters
an array of filters applied (in order) to
tool-chain commands
DETAILS
This structure is used to define a collection of tool-chain
options that are used as a group to achieve some effect supported
by the tool-chain. For example, some compilers require that
specific options be passed to the compiler *and* linker in order
to generate execution profile information or code coverage
statistics.
SEE
struct Arm7.Options |
![](../../../../Arrow_up.png) |
User configurable command options
XDCscript usage |
meta-domain |
var obj = new Arm7.Options;
obj.prefix = String ...
// options that appear before Command.opts
obj.suffix = String ...
// options that appear after Command.opts
DETAILS
The option strings allow the user to pass additional parameters to the
executable that is responsible for compiling, linker, or archiving.
See
xdc.bld.ITarget2.Command.
struct Arm7.StdTypes |
![](../../../../Arrow_up.png) |
Standard base types supported by all targets
XDCscript usage |
meta-domain |
var obj = new Arm7.StdTypes;
SEE
config Arm7.alignDirectiveSupported // module-wide |
![](../../../../Arrow_up.png) |
The compiler supports an align directive
XDCscript usage |
meta-domain |
const Arm7.alignDirectiveSupported = Bool true;
config Arm7.ar // module-wide |
![](../../../../Arrow_up.png) |
The command used to create an archive
XDCscript usage |
meta-domain |
cmd: "ar470",
opts: "rq"
};
config Arm7.asm // module-wide |
![](../../../../Arrow_up.png) |
The command used to assembles assembly source files into object files
XDCscript usage |
meta-domain |
cmd: "cl470 -c",
opts: " -me -mv4 --abi=eabi"
};
config Arm7.base // module-wide |
![](../../../../Arrow_up.png) |
A target that this target is based upon
XDCscript usage |
meta-domain |
DETAILS
If non-
null, this target shares the same tool-chain of the specified
base target. This parameter is used to determine various default
values for target configuration parameters. For example, the default
setting of
rootDir is the value of the base's
rootDir setting.
config Arm7.bitsPerChar // module-wide |
![](../../../../Arrow_up.png) |
The number of bits in a variable of type char
XDCscript usage |
meta-domain |
const Arm7.bitsPerChar = Int 8;
DETAILS
This constant allows one to determine the precise number of bits in
each of the types specified in the stdTypes map. For example, the
number of bits in the target t's int type is
t.stdTypes.t_Int.size * t.bitsPerChar
config Arm7.cc // module-wide |
![](../../../../Arrow_up.png) |
The command used to compile C/C++ source files into object files
XDCscript usage |
meta-domain |
cmd: "cl470 -c",
opts: " -me -mv4 --abi=eabi"
};
config Arm7.isa // module-wide |
![](../../../../Arrow_up.png) |
CPU Instruction Set Architecture (ISA)
XDCscript usage |
meta-domain |
const Arm7.isa = String "v4T";
DETAILS
This parameter is used to identify a set of targets that produce
code for a common ISA. This is used by build scripts that need to
build for all targets that support a particular device.
For example, the build script for a package that is designed for
the TMS32064xx (and no other CPU) can easily specify that it
should be built for all targets that generate code for the
TMS320C64xx without having to specify a specific target. This
allows the user to add new targets (big endian, little endian,
different compilers, etc.) that build for the TMS320C64xx without
having to modify the package's build script.
Note that this field should not be confused with platform ISA
names; this field is defined by target tool-chains and may differ
from the names given by a CPU device.
SEE
config Arm7.lnk // module-wide |
![](../../../../Arrow_up.png) |
The command used to link executables
XDCscript usage |
meta-domain |
cmd: "lnk470",
opts: "--silicon_version=4 --strict_compatibility=on"
};
config Arm7.model // module-wide |
![](../../../../Arrow_up.png) |
Run-time model
XDCscript usage |
meta-domain |
endian: "little",
shortEnums: true
};
DETAILS
This structure identifies a particular run-time model
used by the compiler to generate instructions.
config Arm7.name // module-wide |
![](../../../../Arrow_up.png) |
Nickname for this target
XDCscript usage |
meta-domain |
const Arm7.name = String "Arm7";
DETAILS
This name is typically the name of the module without the package
name prefix. Thus, it is not necessarily globally unique.
Use the $name property of the module to get a globally unique name
for the target.
config Arm7.os // module-wide |
![](../../../../Arrow_up.png) |
Name of OS required to run programs built for this target
XDCscript usage |
meta-domain |
const Arm7.os = String computed value;
DETAILS
Native executables are run by the host OS. This OS often
defines runtime interfaces that all executables (implicitly or
explicitly) use.
If os is undefined, then no OS is required.
config Arm7.rts // module-wide |
![](../../../../Arrow_up.png) |
Name of a run-time support package to include
XDCscript usage |
meta-domain |
const Arm7.rts = String "ti.targets.arm.rtsarm";
DETAILS
Development environments often provide a set of common run-time
support functions that all other code can easily utilize; e.g.,
some means for performing a "printf", normal program termination
with "exit status", etc. If the rts parameter is non-null, it is
the name of a package that is implicitly imported when building
any executable that is built using this target. If rts is
undefined, no rts package is imported.
This parameter makes it possible for the target producer to name
a package that provides a target-specific implementation of a runtime
support interface. Clients of a target do not need to explicitly
name a target specific rts implementation; thus, it is not
possible for the client to inadvertently name the wrong (or an
incompatible) rts implementation.
Note: this package is *NOT* included if the executable's
xdc.bld.Executable.attrs.rtsName attribute is set to
null;
see
xdc.bld.Executable.Attrs. It is also not included if the
executable is a legacy DSP/BIOS program.
config Arm7.sectMap // module-wide |
![](../../../../Arrow_up.png) |
Output section name to segment type mapping
XDCscript usage |
meta-domain |
const Arm7.sectMap = String[string] [
[
".text",
"code"
],
[
".stack",
"stack"
],
[
".bss",
"data"
],
[
".cinit",
"code"
],
[
".init_array",
"code"
],
[
".const",
"code"
],
[
".data",
"data"
],
[
".rodata",
"data"
],
[
".neardata",
"data"
],
[
".fardata",
"data"
],
[
".switch",
"data"
],
[
".sysmem",
"data"
],
[
".far",
"data"
],
[
".args",
"data"
],
[
".cio",
"data"
]
];
DETAILS
This hash table is used to determine whether a particular object file
output section (".text", ".stack", etc.) requires 'data', 'code' or
'stack' memory segment.
This sectMap is referenced by linker command file templates during
generation to create linker command files. The Platform defines the
default memory segments for code and data, and based on this map and
the default segments, the linker command file template places an
output section into a physical memory segment.
Note that the
xdc.cfg.Program object and the
xdc.platform.IPlatform instance have a
sectMap parameter. Both the
Program's and
IPlatform's
sectMap
can augment and/or override the placement for a section, but
xdc.cfg.Program.sectMap takes precedence. Therefore, this
sectMap and the default segments from the platform define an
initial section map which is then augmented by the
Program's and
IPlatform's section map.
config Arm7.stdTypes // module-wide |
![](../../../../Arrow_up.png) |
Size and alignment for standard base types
XDCscript usage |
meta-domain |
t_IArg: {
size: 4,
align: 4
},
t_Char: {
size: 1,
align: 1
},
t_Double: {
size: 8,
align: 8
},
t_Float: {
size: 4,
align: 4
},
t_Fxn: {
size: 4,
align: 4
},
t_Int: {
size: 4,
align: 4
},
t_Int8: {
size: 1,
align: 1
},
t_Int16: {
size: 2,
align: 2
},
t_Int32: {
size: 4,
align: 4
},
t_Int64: {
size: 8,
align: 8
},
t_Long: {
size: 4,
align: 4
},
t_LDouble: {
size: 8,
align: 8
},
t_LLong: {
size: 8,
align: 8
},
t_Ptr: {
size: 4,
align: 4
},
t_Short: {
size: 2,
align: 2
},
t_Size: {
size: 4,
align: 4
}
};
DETAILS
The values of size are the values returned by the
target-specific sizeof() operator applied to the specified
type (as defined by the C language). The align value is the number
of chars used in the alignment of the specified type.
config Arm7.suffix // module-wide |
![](../../../../Arrow_up.png) |
Suffix appended to all objs, libraries, and executable
XDCscript usage |
meta-domain |
const Arm7.suffix = String "e7";
DETAILS
All files generated by this target (object files, archives,
executables, etc.) have file names whose extensions end with
suffix. In particular, targets create files with the following
extensions:
- ".a<suffix>"
-
archive files (i.e., libraries)
- ".o<suffix>"
-
object files
- ".s<suffix>"
-
assembly language source (see scompile())
- ".x<suffix>"
-
executable files
This suffix should be chosen to globally and uniquely identify the
EABI (Embedded Application Binary Interface) of the objects produced
by this target. Targets with the same suffix should
should produce 100% EABI compatible objects and, targets with different
suffixes should produce objects with incompatible EABIs.
SEE
config Arm7.vers // module-wide |
![](../../../../Arrow_up.png) |
The command used to get the tool-chain to return a version number
XDCscript usage |
meta-domain |
cmd: "cl470",
opts: "--compiler_revision"
};
config Arm7.arOpts // module-wide |
![](../../../../Arrow_up.png) |
User configurable archiver options
XDCscript usage |
meta-domain |
prefix: "",
suffix: ""
};
config Arm7.asmOpts // module-wide |
![](../../../../Arrow_up.png) |
User configurable assembler options
XDCscript usage |
meta-domain |
prefix: "-qq",
suffix: ""
};
DETAILS
Defaults:
config Arm7.binDir // module-wide |
![](../../../../Arrow_up.png) |
This parameter controls the location of the target's commands
XDCscript usage |
meta-domain |
Arm7.binDir = String "$(rootDir)/bin/";
DETAILS
All build commands returned within a command set
(xdc.bld.ITarget.CommandSet.cmds) are formed by prefixing binDir
to this target's Command.cmd specification. For example, the
compile command returned is formed as follows:
where, $(binDir) is this target's binDir value and $(cc.cmd) is
the value of this target's cc.cmd string.
If binDir is non-empty then it must end with '/'. If it is empty,
the target's commands (compiler, linker, archiver, etc.) will be
located along a path constructed from this target's pathPrefix.
config Arm7.ccConfigOpts // module-wide |
![](../../../../Arrow_up.png) |
User configurable compiler options for the generated config C file.
---fp_mode=strict
disable conversion of double-precision computations to
single-precision computations when the result is assigned to
a single-precision variable
XDCscript usage |
meta-domain |
prefix: "$(ccOpts.prefix) -ms --fp_mode=strict",
suffix: "$(ccOpts.suffix)"
};
DETAILS
By default, this parameter inherits values specified in
ccOpts. The strings
"$(ccOpts.prefix)" and
"$(ccOpts.suffix)" are expanded into the values specified by
ccOpts for this target.
config Arm7.ccOpts // module-wide |
![](../../../../Arrow_up.png) |
User configurable compiler options
XDCscript usage |
meta-domain |
prefix: "-qq -pdsw225",
suffix: ""
};
DETAILS
Defaults:
- -qq
-
super quiet mode
- -pdsw225
-
generate a warning for implicitly declared functions; i.e.,
functions without prototypes
config Arm7.compatibleSuffixes // module-wide |
![](../../../../Arrow_up.png) |
Array of suffixes used by targets compatible with this target
XDCscript usage |
meta-domain |
Arm7.compatibleSuffixes = String[] [
"470"
];
DETAILS
This array is used to identify a set of targets that produce
code that can be linked with code produced by this target, where the
order of suffixes defines the order of preferrence. This
parameter is used by findSuffixes().
For example, an Arm target which builds for v6 architecture might have
the following values in its compatibleSuffix: ["v5T", "MV470"].
This means that code produced by targets with suffixes "v5T' and
"MV470" can be linked with code produced by that target, and that "v5T"
code is more preferred than "MV470" code.
config Arm7.debugGen // module-wide |
![](../../../../Arrow_up.png) |
TI Debugger/IDE file generation support
XDCscript usage |
meta-domain |
execTemplate: "ti/targets/ccs_exec.xdt",
execPattern: "$(cfgDir)$(cfgName).pjt",
packageTemplate: "ti/targets/ccs_package.xdt",
packagePattern: "package/$(pkgName).pjt"
};
DETAILS
This parameter allows one to automatically generate files that
can be used by an IDE to more easily debug (and possibly rebuild)
specified goals.
To avoid unnecessary build time overhead, these files are not always
generated; by default, they are only generated for "debug" profiles.
The generation of these files is controlled by the
xdc.cfg.Program.gen configuration parameter. To force these
files to be generated for a particular executable, add the following
line to the executable's program configuration script:
Program.gen.debuggerFiles = true;
It is also possible to disable the generation of selected files by
setting the appropriate fields of
DebugGen to
null in
your
config.bld script.
The settings below generate CCS project files that enable one
to debug (and even rebuild) Executables from within the CCS GUI.
To avoid unnecessary build time overhead, these files are not always
generated; by default, they are only generated for "debug" profiles.
The generation of these files is controlled by the
xdc.cfg.Program.gen configuration parameter. To force these
files to be generated for a particular executable, add the following
line to the executable's program configuration script:
Program.gen.debuggerFiles = true;
It is also possible to control the generation via build options; see
xdc.bld.ITarget.DebugGen.
Note: if you are using CCS 2.x, disable CodeMaestro to prevent
instabilities when re-loading project files. CodeMaestro can be
disabled via: Options->"Customize ..."->"CodeMaestro Settings"
To debug an executable:
- load generated project for the executable:
package/cfg/<cfg_name>.pjt
- load generated GEL script for the executable:
package/cfg/<cfg_name>.gel
- load prerequisite packages:
GEL->"XDC Package"->open_project
where <cfg_name> is the name of the executable (foo.x62) with the
'.' replaced by and '_' (foo_x62).
Alternatively, one can use the ccs_start.pl script in this package
to automate the steps above. In addition, it is possible to
associate ccs_start.bat (also in this package) with the generated
.pjt files to automate the above by double-clicking on the .pjt
file.
To avoid navigation to the executable via file menus, you can load
the executable associated with the project via:
GEL->"XDC Package"->load_executable
SEE ALSO
xdc.bld.ITarget contains addition information about
how to create and use these templates.
config Arm7.execExt // module-wide |
![](../../../../Arrow_up.png) |
Extension for executables
XDCscript usage |
meta-domain |
Arm7.execExt = String undefined;
DETAILS
Operating systems and tools often have a strong preference for a
specific extension for executables; e.g., Windows expects executables
to have the extension ".exe". If this parameter is set, executables
will be given the specified extension instead of the default
".x<suffix>", where <suffix> is the target's suffix parameter.
The execExt is an expression that is expanded prior to use.
Expressions of the form "$(name)" within the
pattern string are expanded if "name" is one of the built-in
variables listed below.
Built-in variables for execExt:
- trgName
-
the target's name property
- trgSuffix
-
the target's suffix property
- platPName
-
the executable's platform package name
- platIName
-
the executable's platform instance name
EXAMPLE
If you want to build a portable executable for multiple
targets side-by-side and you want (or need) to use a fixed extension
such as ".out" for all executables, setting execExt to
"_$(trgSuffix).out" for all targets ensures that all generated
executables will have unique names and yet share a common extension
of ".out".
config Arm7.extensions // module-wide |
![](../../../../Arrow_up.png) |
File extensions recognized by TI targets
XDCscript usage |
meta-domain |
DETAILS
This is a user modifiable table used to customize file extensions
recognized by each target.
For example, to add a new assembly language extension, say ".s64",
to the target ti.targets.C64P, add the following lines to the
build model startup script:
var C64P = xdc.module('ti.targets.C64P');
C64P.extensions[".s64"] = {
suf: ".s64", typ: "asm"
};
Note that individual targets may add additional language types.
It is also possible to remove default extensions. For example, to
remove the "`.asm`" extension from the target `ti.targets.C64P`, add
the following lines to the build model startup script:
var C64P = xdc.module('ti.targets.C64P');
delete C64P.extensions[".asm"];
TI SPECIFICS
For TI targets, the typ string field of an
xdc.bld.ITarget.Extension structure may be of the form
"<cmd>:<langOpt>" where <cmd> is one of "asm", "c", "cpp",
and <langOpt> is the language option to used to identify the source
language of a source file. This allows one to explicitly control the
language flag passed to the compiler based on a source file's
extension; in particular, one can define separate source extensions
for "linear" and "scheduled" assembly files, or simply cause ".s62"
files to be treated as "linear" assembly rather than "scheduled"
assembly.
For example,
tiTargets.C62.extensions[".s62"] = {suf: ".s62", typ: "asm:-fl"};
causes all ".s62" files to be treated as linear assembly.
If no ':' appears in the typ string, a default will be used:
"-fa" for "asm" files "-fc" for "c" files, and "-fp" for
"cpp" files.
config Arm7.includeOpts // module-wide |
![](../../../../Arrow_up.png) |
Additional user configurable target-specific include path options
XDCscript usage |
meta-domain |
Arm7.includeOpts = String "-I$(rootDir)/include/rts -I$(rootDir)/include ";
config Arm7.linkLib // module-wide |
![](../../../../Arrow_up.png) |
Default Arm7 cgtools runtime library to link with
XDCscript usage |
meta-domain |
Arm7.linkLib = String "rtsv4_A_le_eabi.lib";
config Arm7.lnkOpts // module-wide |
![](../../../../Arrow_up.png) |
User configurable linker options
XDCscript usage |
meta-domain |
prefix: "-w -q -u _c_int00",
suffix: "-c -m $(XDCCFGDIR)/$@.map "
};
DETAILS
Defaults:
- -w
-
Display linker warnings
- -q
-
Quite run
- -u
-
Place unresolved external symbol into symbol table
- -c
-
ROM autoinitialization model
- -m
-
create a map file
config Arm7.pathPrefix // module-wide |
![](../../../../Arrow_up.png) |
A prefix to the PATH environment variable
XDCscript usage |
meta-domain |
Arm7.pathPrefix = String "";
DETAILS
Each target command is executed with C_DIR set to "" and PATH
set as follows:
$(pathPrefix);$(binDir);$(PATH)
where, $(pathPrefix) and $(binDir) are the values of the
configuration parameters and $(PATH) is the value of the PATH
environment variable set by the xdc command (type 'xdc -n' to
see this).
Embedded ';' characters within pathPrefix separate directory
names. On UNIX hosts these ';' characters are convered to an
appropriate separator; i.e., ':'.
config Arm7.platform // module-wide |
![](../../../../Arrow_up.png) |
The default platform name for this target
XDCscript usage |
meta-domain |
Arm7.platform = String "ti.platforms.sim470xx";
DETAILS
Build scripts often build for just one platform per target. This
parameter allows one to establish a default platform for each
target in a build.
If this parameter is
null or
undefined and
platforms
array is non-empty, it is initialized to be the first element of the
platforms array (i.e.,
platforms[0]).
config Arm7.platforms // module-wide |
![](../../../../Arrow_up.png) |
A set of platforms that can support this target
XDCscript usage |
meta-domain |
Arm7.platforms = String[] [ ];
DETAILS
Some build scripts build executables for "all" platforms; e.g.,
regression test suites. This parameter allows one to establish
a set of platforms that build scripts can legitimately use to
create executables, for example.
If this array is empty (i.e., has length 0) and
platform
is non-
null, platforms is initialized to an array of one element
equal to
platform.
config Arm7.profiles // module-wide |
![](../../../../Arrow_up.png) |
Standard options profiles for the TI tool-chain
XDCscript usage |
meta-domain |
[
"debug",
{
compileOpts: {
copts: "--symdebug:dwarf",
defs: "-D_DEBUG_=1"
}
}
],
[
"release",
{
compileOpts: {
copts: "-O2"
}
}
],
[
"profile",
{
compileOpts: {
copts: "--symdebug:dwarf"
}
}
],
[
"coverage",
{
compileOpts: {
copts: "--symdebug:dwarf"
}
}
],
[
"whole_program",
{
compileOpts: {
copts: "-oe -O2 -ms"
}
}
],
[
"whole_program_debug",
{
compileOpts: {
copts: "-oe --symdebug:dwarf -ms"
}
}
]
];
DETAILS
A profile is a collection of tool options used to create a
library or executable that supports a certain "flavor" of library
or executable; e.g., "debug" or "release".
Some profile names are supported by all targets even though the
targets use different compilers (and therefore different options).
These profile names makes it possible for a package to build
libraries or executables in a "debug" (or "release") profile
independent of the target, for example.
All targets are required to support "debug" and "release" profile
names.
Profile options are added to beginning of any goal specific options
specified by the user before being passed to the target.
config Arm7.rootDir // module-wide |
![](../../../../Arrow_up.png) |
Installation directory for this target's code generation tools
XDCscript usage |
meta-domain |
Arm7.rootDir = String undefined;
DETAILS
Since each target potentially "wraps" a different compiler tool-chain
and each tool-chain will, in general, assume a different physical
design for the installation of the compiler and its associated
libraries and headers, one must consult each specific target to know
how to set this parameter.
If the
base parameter is
null, this parameter *must* be
set by the user; otherwise,
rootDir defaults to the value
base.rootDir.
config Arm7.stdInclude // module-wide |
![](../../../../Arrow_up.png) |
Standard C/C++ types header
XDCscript usage |
meta-domain |
Arm7.stdInclude = String "ti/targets/arm/elf/std.h";
DETAILS
This string identifies a header containing the C/C++ definitions
required to enable use of
xdc/std.h in C/C++ sources; see
xdc.
The value of this string is used by
xdc/std.h to include
target-specific definitions of the types
Int8,
Int16, etc. In
addition, this header supplies target-specific definitions of the
predefined
xdc_target__* macros required by
xdc/std.h.
Since this header must supply target-specific values for
target-independent names the structure of this header is usually of
the form:
// if target macros are not already defined,
#if !defined(xdc_target_macros_include__)
// include target-specific definitions
#if defined(TARGET1)
#include "target1.h"
#elif defined(TARGET2)
#include "target2.h"
#elif ...
:
#else
#error unsupported target
#endif
#endif
// include common definitions
:
The check of the symbol xdc_target_macros_include__ exists to
allow others that define new targets to include this header to
get common definitions for a family of related targets.
To simplify the creation of the target-specific header files, the
template file stddefs.xdt in this package can be used to
automatically generate the required definitions from each target's
.xdc specification.
config Arm7.version // module-wide |
![](../../../../Arrow_up.png) |
The Compatibility Key associated with this target
XDCscript usage |
meta-domain |
Arm7.version = String undefined;
DETAILS
The first two components of this target Compatibility Key are '1,0'.
The rest of the Key represents the compiler version. The third
component combines the major and the minor version number in the format
Major.Minor. The fourth component is the patch number, and the optional
fifth component is the version of an Alpha or Beta release.
READONLY
This value is automatically computed by the XDC Build
Engine by executing the
getVersion() function after
package.bld completes but prior to generating
package.mak.
EXAMPLE
If this target's rootDir points to the compiler version 6.0.11, the
Compatibility Key is [1,0,6.0,11]. If this target's rootDir points to
the compiler version 7.0.0B1, the Compatibility Key is [1,0,7.0,0,1].
config Arm7.versionMap // module-wide |
![](../../../../Arrow_up.png) |
Map of TI compiler version numbers to compatibility keys
XDCscript usage |
meta-domain |
Arm7.versionMap = String[string] [
[
"TMS320C6x_4.32",
"1,0,4.32,0"
],
[
"TMS320C55x_2.56",
"1,0,2.56,0"
],
[
"TMS320C54x_3.83",
"1,0,3.83,0"
],
[
"TMS320C2000_3.07",
"1,0,3.07,0"
]
];
DETAILS
versionMap is a user modifiable table used to map tool-chain
version numbers to Compatibility Keys.
Each target defines the format of the tool-chain version obtained
from the tool-chain. The user can then map new tool-chain version
strings to an appropriate compatibility key.
Each target must respect the mapping defined by this table; i.e.,
if the user supplies a compatibility key in this map, it must be
returned when
getVersion() is called.
Thus, it is possible for the user to assert that any two compiler
tool chains should be treated as equivalent (or incompatible) by
mapping their version numbers to identical (incompatible)
compatibility keys.
This map translates version string information from the compiler
into a compatibility key. The compatibility key is used to validate
consistency among a collection of packages used in a configuration.
TI compiler strings are formed by parsing the output of the
compiler's --compiler_revision option and creating a string of the
form:
where <comp> is the first word of the output and <ver> is the
version number that appears on this same line.
There are two forms of version numbers output by the TI code gen
tools; an "old" style that is of the form "<major>.<minor>" and a
new style of the form "<major>.<minor>.<update>[.<branch>][<qual>],
where <major>, <minor>, <update>, and <branch> are non-negative
integers and <qual> is of the form "[IBAP]<yyddd>", and <yyddd>
is the last two digits of the year concatenated with the number of
the day.
If a compiler version is not found in this map the default is
"1,0,<major>.<minor>" for old style version numbers, and
"1,0,<major>.<minor>,<update>[.<branch>][,<yyddd>]" for new style
version numbers.
The user only needs to extend this table when a significant
incompatibility occurs (and this package doesn't know about it) or
when two versions of the compiler should be treated as 100%
compatible.
SEE
EXAMPLES
var C62 = xdc.useModule('ti.targets.C62');
// assert that 4.0 is forward compatible with 4.32
C62.versionMap["TMS320C6x_4.32"] = "1,0,4.0,0";
// assert that 4.28 is incompatible with all other compilers
C62.versionMap["TMS320C6x_4.28"] = "1,1,4.28,0";
Arm7.archive() // module-wide |
![](../../../../Arrow_up.png) |
Create an archive
XDCscript usage |
meta-domain |
ARGUMENTS
DETAILS
This function is called during makefile generation to convert build
goals into specific commands that generate the specified goal.
RETURNS
This function returns a
CommandSet. If non-
null, this
object defines the commands that must be executed to create the
specified object file. If
null, then goal can not be achieved.
THROWS
Error exceptions are thrown for fatal errors.
Arm7.asmName() // module-wide |
![](../../../../Arrow_up.png) |
The function that converts a C name into an assembly name
XDCscript usage |
meta-domain |
Arm7.asmName(String CName) returns String
Arm7.compile() // module-wide |
![](../../../../Arrow_up.png) |
Compile a source file into an object file
XDCscript usage |
meta-domain |
ARGUMENTS
goal
a CompileGoal that specifies what file to
compile, the output file name, and any goal-specific
options to use
DETAILS
This function is called during makefile generation to convert build
goals into specific commands that generate the specified object
file goal.
RETURNS
This function retuns a
CommandSet. If non-
null,
this object defines the commands that must be executed to create the
specified object file. If
null, then goal can not be achieved.
THROWS
Error exceptions are thrown for fatal errors.
Arm7.findSuffix() // module-wide |
![](../../../../Arrow_up.png) |
Find the suffix that is compatible with this target
XDCscript usage |
meta-domain |
Arm7.findSuffix(Any pkg) returns Any
ARGUMENTS
pkg
a package object or an array of target suffix strings
(see suffix).
DETAILS
This function determines the list of targets supported by the
package given as the argument. From that list, this function
returns the suffix of a target that is compatible with this target.
Compatibility in this case means that object files created by a
target having the suffix returned by this function can be linked
into an executable produced using this target. In the case where more
than one suffix is compatible, this function returns a suffix in the
following order of preference:
- if this target's suffix is in the list, that suffix is returned.
- suffixes from compatibleSuffixes are matched against the list
from the first to the last, and the first one with the match is
returned.
RETURNS
This function returns the suffix string of a target compatible with
this target or null if pkg does not support any target compatible
with this target.
Arm7.genConstCustom() // module-wide |
![](../../../../Arrow_up.png) |
Return any custom generated code related to generated constants
XDCscript usage |
meta-domain |
Arm7.genConstCustom(String[] constants) returns String
PARAMS
array of constants generated in the config C
file
RETURNS
This function returns custom C code that will be embedded into the
generated config C file. If there is nothing to be added, this function
returns 'null'. If a target never generates any such code, it can rely
on the default implementation that always returns 'null'.
Arm7.getISAChain() // module-wide |
![](../../../../Arrow_up.png) |
Get this target's ISA "is compatible with" relation
XDCscript usage |
meta-domain |
Arm7.getISAChain(Any isa) returns Any
ARGUMENTS
isa
the ISA identifier string for the ISA to lookup; if null
then the target's ISA is used (ITarget.isa).
DETAILS
Returns an array of ISA names (including this target's ISA) that
represents the "is a" relation between ISA's. The array starts with
the most general ISA and ends with this target's ISA or with the
optionally specified argument. This relation is used to:
- pre-define macro definitions that enable code to be
conditionally compiled based on compatible versions of a
target's ISA.
- locate appropriate source files during makefile generation;
each ISA named in a chain causes the extensions ".s"isa to be
added to the ITarget.extensions table (in the reverse order
that they appear in the chain). For example, if a target's
ISA is "64P" and the returned chain is ["62", "64", "64P"],
the following assembly language suffixes are added to
the target's extensions table: ".s64P", ".s64", ".s62".
- determine the assembly language suffix used during legacy BIOS
configuration; the first element of the target's ISA chain
defines the suffix. For example, if a target's ISA is "64P"
and the returned chain is ["62", "64", "64P"], the assembly
suffix is ".s62".
This relation may also be used in the future to help validate
combinations of targets and platforms; a target's CPU ISA must
appear on the chain specified by the platform's CPU ISA.
RETURNS
This function returns an array of ISA strings where the last string
is the optionally specified ISA string or this target's ISA,
and the first string is the "base" ISA in the
is source compatible" relationship.
If the specified ISA string is not in this target's chain
of compatible targets, null is returned.
THROWS
Error exceptions are thrown for fatal errors.
Arm7.getVersion() // module-wide |
![](../../../../Arrow_up.png) |
Get a target-specific Compatibility Key string
XDCscript usage |
meta-domain |
Arm7.getVersion() returns String
DETAILS
This function is called during makefile generation to obtain a
target-specific Compatibility Key string. This string is of the
form:
"<pkg>.<mod>{<d0>,<d1>,<d2>,<d3>"
where, <pkg>.<mod> is the name of the target, and <d0>, <d1>,
etc. forms a Compatibility Key.
RETURNS
This function returns a string that encodes the name of the target
and its Compatibility Key.
THROWS
Error exceptions are thrown for fatal errors.
Arm7.link() // module-wide |
![](../../../../Arrow_up.png) |
Link object files to produce an executable
XDCscript usage |
meta-domain |
ARGUMENTS
goal
a LinkGoal that specifies the output file
name, a list of files to link with, and any goal-specific
options to use
DETAILS
This function is called during makefile generation to convert build
goals into specific commands that generate the specified goal.
RETURNS
This function returns a
CommandSet. If non-
null, this
object defines the commands that must be executed to create the
specified object file. If
null, then goal can not be
achieved.
THROWS
Error exceptions are thrown for fatal errors.
Arm7.scompile() // module-wide |
![](../../../../Arrow_up.png) |
Compile a source file into an assembly language file
XDCscript usage |
meta-domain |
ARGUMENTS
goal
a CompileGoal that specifies what file to
compile, the output file name, and any goal-specific
options to use
DETAILS
This function is called during makefile generation to convert build
goals into specific commands that generate the specified assembly
language source goal.
RETURNS
This function returns a
CommandSet. If non-
null, this
object defines the commands that must be executed to create the
specified assembly language file. If
null, then goal
can not be achieved or is unnecessary (e.g., because
the source file is already an asm file).
THROWS
Error exceptions are thrown for fatal errors.
Arm7.selectSuffix() // module-wide |
![](../../../../Arrow_up.png) |
Select the suffix that is compatible with this target
XDCscript usage |
meta-domain |
Arm7.selectSuffix(String[] suffixList) returns String
ARGUMENTS
suffixList
an array of target suffix strings
(see suffix).
DETAILS
From a list of suffixes supplied as an argument, this function
returns the suffix compatible with this target. Compatibility in
this case means that object files created by a target having the
suffix returned by this function can be linked into an executable
produced using this target. In the case where more than one suffix
is compatible, this function returns a suffix in the following order
of preference:
- if this target's suffix is in the list, that suffix is returned.
- suffixes from compatibleSuffixes are matched against the list
from the first to the last, and the first one with the match is
returned.
RETURNS
This function returns the suffix string of a target compatible with
this target or null if no such suffix is found in the list of
suffixes specified by the first argument.