This module defines an embedded target for Linux on Arm. The target
generates code compatible with the "v6" architecture.
typedef GCArmv6.StringArray |
|
typedef String GCArmv6_StringArray[];
struct GCArmv6.ArchiveGoal |
|
The goal specification passed to the archive
function
XDCscript usage |
meta-domain |
var obj = new GCArmv6.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 GCArmv6.Command |
|
Required command and options
XDCscript usage |
meta-domain |
var obj = new GCArmv6.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 GCArmv6.CommandSet |
|
The commands necessary to create a specified goal
XDCscript usage |
meta-domain |
var obj = new GCArmv6.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 GCArmv6.CompileGoal |
|
The goal specification passed to the compile
function
XDCscript usage |
meta-domain |
var obj = new GCArmv6.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 GCArmv6.CompileOptions |
|
Options passed to the compiler/assembler
XDCscript usage |
meta-domain |
var obj = new GCArmv6.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
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 GCArmv6.DebugGen |
|
Debugger integration support
XDCscript usage |
meta-domain |
var obj = new GCArmv6.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 GCArmv6.Extension |
|
File extension to file type association
XDCscript usage |
meta-domain |
var obj = new GCArmv6.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 GCArmv6.LinkGoal |
|
The goal specification passed to the link function
XDCscript usage |
meta-domain |
var obj = new GCArmv6.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 GCArmv6.Model |
|
Target runtime model
XDCscript usage |
meta-domain |
var obj = new GCArmv6.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 GCArmv6.OptionSet |
|
Collection of tool-chain options
XDCscript usage |
meta-domain |
var obj = new GCArmv6.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 GCArmv6.Options |
|
User configurable command options
XDCscript usage |
meta-domain |
var obj = new GCArmv6.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 ti.targets.ITarget.Command.
struct GCArmv6.StdTypes |
|
Standard base types supported by all targets
XDCscript usage |
meta-domain |
var obj = new GCArmv6.StdTypes;
SEE
config GCArmv6.CYGWIN // module-wide |
|
Is the target's compiler a cygwin executable
XDCscript usage |
meta-domain |
const GCArmv6.CYGWIN = Bool false;
DETAILS
Since file names produced by cygin-based tools differ from the
names understood by other Windows executables, it is important
to avoid using the names output by cygwin tools as input to
non-cygwin programs. This property tells the target whether
or not it's possible to use the output from gcc -MD -MF, for
example.
config GCArmv6.alignDirectiveSupported // module-wide |
|
The compiler supports an align directive
XDCscript usage |
meta-domain |
const GCArmv6.alignDirectiveSupported = Bool false;
config GCArmv6.ar // module-wide |
|
The command used to create an archive
XDCscript usage |
meta-domain |
cmd: "$(rootDir)/$(GCCTARG)/bin/ar",
opts: "cr"
};
config GCArmv6.asm // module-wide |
|
The command used to assembles assembly source files into object files
XDCscript usage |
meta-domain |
cmd: "$(rootDir)/$(LONGNAME) -c -x assembler",
opts: "-march=armv6"
};
config GCArmv6.base // module-wide |
|
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 GCArmv6.bitsPerChar // module-wide |
|
The number of bits in a variable of type char
XDCscript usage |
meta-domain |
const GCArmv6.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 GCArmv6.cc // module-wide |
|
The command used to compile C/C++ source files into object files
XDCscript usage |
meta-domain |
cmd: "$(rootDir)/$(LONGNAME) -c -MD -MF $@.dep",
opts: "-march=armv6"
};
config GCArmv6.isa // module-wide |
|
CPU Instruction Set Architecture (ISA)
XDCscript usage |
meta-domain |
const GCArmv6.isa = String "v6";
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 GCArmv6.lnk // module-wide |
|
The command used to link executables
XDCscript usage |
meta-domain |
cmd: "$(rootDir)/$(LONGNAME)",
opts: ""
};
config GCArmv6.model // module-wide |
|
Run-time model
XDCscript usage |
meta-domain |
DETAILS
This structure identifies a particular run-time model
used by the compiler to generate instructions.
config GCArmv6.name // module-wide |
|
Nickname for this target
XDCscript usage |
meta-domain |
const GCArmv6.name = String "GCArmv6";
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 GCArmv6.os // module-wide |
|
Name of OS required to run programs built for this target
XDCscript usage |
meta-domain |
const GCArmv6.os = String "Linux";
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 GCArmv6.rts // module-wide |
|
Name of a run-time support package to include
XDCscript usage |
meta-domain |
const GCArmv6.rts = String "gnu.targets.arm.rtsv6";
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 GCArmv6.sectMap // module-wide |
|
Output section name to segment type mapping
XDCscript usage |
meta-domain |
const GCArmv6.sectMap = String[string] computed value;
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 GCArmv6.stdInclude // module-wide |
|
Standard C/C++ types header
XDCscript usage |
meta-domain |
const GCArmv6.stdInclude = String "gnu/targets/arm/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 GCArmv6.stdTypes // module-wide |
|
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: 4
},
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: 4
},
t_Long: {
size: 4,
align: 4
},
t_LDouble: {
size: 8,
align: 4
},
t_LLong: {
size: 8,
align: 4
},
t_Ptr: {
size: 4,
align: 4
},
t_Short: {
size: 2,
align: 2
}
};
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 GCArmv6.suffix // module-wide |
|
Suffix appended to all objs, libraries, and executable
XDCscript usage |
meta-domain |
const GCArmv6.suffix = String "v6";
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 GCArmv6.GCCTARG // module-wide |
|
The name of the platform executing programs produced by this target
XDCscript usage |
meta-domain |
GCArmv6.GCCTARG = String null;
DETAILS
This string can be supplied by the user, otherwise is is obtained
from the compiler and follows the GNU standard format
(<cpu>-<manufacturer>-<os> or <cpu>-<manufacturer>-<kernel>-<os>);
e.g., "sparc-sun-solaris2.6" or "i586-pc-linux-gnu".
When building a GCC compiler, there are three different execution
platforms to consider: the platform used to "build" the compiler, the
"host" platform that runs the compiler, and the "target" platform
that runs the executables produced by the compiler. All three
platforms are identified using a
configuration name
defined by GNU Autotools.
GCCTARG is the name of the "target"
platform.
config GCArmv6.GCCVERS // module-wide |
|
Version number of the GCC compiler; e.g., "3.2"
XDCscript usage |
meta-domain |
GCArmv6.GCCVERS = String null;
DETAILS
This string can be supplied by the user, otherwise it is obtained
by running "gcc -dumpversion".
config GCArmv6.LONGNAME // module-wide |
|
The "long name" of the gcc compiler
XDCscript usage |
meta-domain |
GCArmv6.LONGNAME = String undefined;
DETAILS
This name is used (in conjunction with rootDir) to find the compiler
and linker for this target. The format of LONGNAME is always
"/bin/<machine>-gcc". For majority of the targets, the default value
for LONGNAME does not ever need to be changed. But, there are
targets where the different but compatible compilers may have
different LONGNAME parameters. For such targets and compilers,
LONGNAME can be set in config.bld.
EXAMPLE
If a version 2007q3 of the CodeSourcery GNU toolchain for Arm is
installed in C:/CodeSourcery/arm-2007q3, the following settings in
config.bld configure gnu.targets.arm.GCArmv6 target to use that
toolchain:
var GCArmv6 = xdc.module("gnu.targets.arm.GCArmv6");
GCArmv6.rootDir = "C:/CodeSourcery/arm-2007q3";
GCArmv6.LONGNAME = "bin/arm-none-linux-gnueabi-gcc";
config GCArmv6.arOpts // module-wide |
|
User configurable archiver options
XDCscript usage |
meta-domain |
prefix: "",
suffix: ""
};
config GCArmv6.asmOpts // module-wide |
|
User configurable assembler options
XDCscript usage |
meta-domain |
prefix: "",
suffix: ""
};
config GCArmv6.ccOpts // module-wide |
|
User configurable compiler options
XDCscript usage |
meta-domain |
prefix: "-fPIC -Wunused",
suffix: "-Dfar= "
};
config GCArmv6.compatibleSuffixes // module-wide |
|
Array of suffixes used by targets compatible with this target
XDCscript usage |
meta-domain |
GCArmv6.compatibleSuffixes = String[] [
"v5T",
"470MV",
"v5t"
];
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 GCArmv6.debugGen // module-wide |
|
Debugger/IDE file generation support
XDCscript usage |
meta-domain |
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.
config GCArmv6.execExt // module-wide |
|
Extension for executables
XDCscript usage |
meta-domain |
GCArmv6.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 GCArmv6.extensions // module-wide |
|
File extensions recognized by this target
XDCscript usage |
meta-domain |
[
".asm",
{
suf: ".asm",
typ: "asm"
}
],
[
".c",
{
suf: ".c",
typ: "c"
}
],
[
".cpp",
{
suf: ".cpp",
typ: "cpp"
}
],
[
".cxx",
{
suf: ".cxx",
typ: "cpp"
}
],
[
".C",
{
suf: ".C",
typ: "cpp"
}
],
[
".cc",
{
suf: ".cc",
typ: "cpp"
}
]
];
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"];
config GCArmv6.includeOpts // module-wide |
|
Additional user configurable target-specific include path options
XDCscript usage |
meta-domain |
GCArmv6.includeOpts = String "";
config GCArmv6.lnkOpts // module-wide |
|
User configurable linker options
XDCscript usage |
meta-domain |
prefix: "",
suffix: "-lstdc++ -L$(rootDir)/$(GCCTARG)/lib"
};
config GCArmv6.noStdLinkScript // module-wide |
|
Don't use the standard linker script
XDCscript usage |
meta-domain |
GCArmv6.noStdLinkScript = Bool false;
DETAILS
If true, add a -T flag before the generated package/cfg/*.xdl
file passed to the linker. This flag suppresses use of the
standard linker script implicit in the GCC flow, which effectively
says the generated .xdl file assumes total control for all
MEMORY and SECTION directives.
config GCArmv6.platform // module-wide |
|
The default platform name for this target
XDCscript usage |
meta-domain |
GCArmv6.platform = String "host.platforms.arm";
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 GCArmv6.platforms // module-wide |
|
A set of platforms that can support this target
XDCscript usage |
meta-domain |
GCArmv6.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 GCArmv6.profiles // module-wide |
|
Profiles supported by this target
XDCscript usage |
meta-domain |
[
"debug",
{
compileOpts: {
copts: "-g",
defs: "-D_DEBUG_=1"
},
linkOpts: "-g"
}
],
[
"release",
{
compileOpts: {
copts: "-O2"
},
linkOpts: ""
}
],
[
"profile",
{
compileOpts: {
copts: "-g -pg"
},
linkOpts: "-pg"
}
],
[
"coverage",
{
compileOpts: {
copts: "-fprofile-arcs -ftest-coverage"
},
linkOpts: "-fprofile-arcs -ftest-coverage"
}
]
];
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 GCArmv6.remoteHost // module-wide |
|
Remote host used to run compiler, linker, and archiver tools
XDCscript usage |
meta-domain |
GCArmv6.remoteHost = String undefined;
DETAILS
If remoteHost is null (or undefined), the configured compiler
is run locally; otherwise, remoteHost is taken to be the host name
of the machine that that should be used to run the specified compiler.
All target commands are prefixed with a command that uses rsh to run
the commands on the specified host. Thus, in order to use this
setting, the remote machine must be support rsh and the user must
have permission to run commands from the local machine on the remote
host named remoteHost. This usually involves adding a line to the
user's ~/.rhosts file on the remote machine of the form:
local-machine-name user-name
where local-machine-name is the name of the local machine and
user-name is the user's login name on the local machine.
config GCArmv6.rootDir // module-wide |
|
Installation directory for this target's code generation tools
XDCscript usage |
meta-domain |
GCArmv6.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 GCArmv6.version // module-wide |
|
The Compatibility Key associated with this target
XDCscript usage |
meta-domain |
GCArmv6.version = String undefined;
DETAILS
The first two components of this target's 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.
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 3.4.6, the
Compatibility Key is [1,0,3.4,6].
config GCArmv6.versionMap // module-wide |
|
Map of GCC compiler version numbers to compatibility keys
XDCscript usage |
meta-domain |
GCArmv6.versionMap = String[string] [
[
"gcc3.2",
"1,0,3.2,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 compatibilty key is used to
validate consistency among a collection of packages used in
a configuration.
The compiler version string is "gcc<ver>", where <ver> is
GCCVERS.
If a compiler version is not found in this map the default is
"1,0,<ver>", where <ver> is the compiler version number. Thus,
the user only needs to extend this table when a significant
incompatibility occurs or when two versions of the compiler should
be treated as 100% compatible.
SEE
GCArmv6.archive( ) // module-wide |
|
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.
GCArmv6.compile( ) // module-wide |
|
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.
GCArmv6.findSuffix( ) // module-wide |
|
Find the suffix that is compatible with this target
XDCscript usage |
meta-domain |
GCArmv6.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.
GCArmv6.getISAChain( ) // module-wide |
|
Get this target's ISA "is compatible with" relation
XDCscript usage |
meta-domain |
GCArmv6.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.
GCArmv6.getVersion( ) // module-wide |
|
Get a target-specific Compatibility Key string
XDCscript usage |
meta-domain |
GCArmv6.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.
GCArmv6.link( ) // module-wide |
|
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.
GCArmv6.scompile( ) // module-wide |
|
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.
GCArmv6.selectSuffix( ) // module-wide |
|
Select the suffix that is compatible with this target
XDCscript usage |
meta-domain |
GCArmv6.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.