This module implements xdc.platform.IPlatform and defines configuration
parameters that correspond to this platform's Cpu's, Board's, etc.
The configuration parameters are initialized in this package's
configuration script (package.cfg) and "bound" to the TCOM object
model. Once they are part of the model, these parameters are
queried by a program's configuration script.
This particular platform has a single Cpu, and therefore, only
declares a single CPU configuration object. Multi-CPU platforms
would declare multiple Cpu configuration parameters (one per
platform CPU).
struct Platform.Board |
![](../../../Arrow_up.png) |
Board-level description
XDCscript usage |
meta-domain |
var obj = new Platform.Board;
obj.id = String ...
// unique id within the platform
obj.boardName = String ...
// name of the board
obj.boardFamily = String ...
// optional family name
obj.boardRevision = String ...
// optional revision string
struct Platform.Memory |
![](../../../Arrow_up.png) |
A named contiguous range of addresses
XDCscript usage |
meta-domain |
var obj = new Platform.Memory;
obj.comment = String ...
// description of this block
obj.name = String ...
// name of memory segment
obj.space = String ...
// "code", "data", "code/data", etc..
obj.page = UInt ...
// page of memory segment
obj.base = UInt ...
// base address of memory segment
obj.len = UInt ...
// length of memory segment
obj.access = String ...
// attributes of memory: "RWX" must be u.c
DETAILS
Memory structures are used in the description of the memory available
from CPUs and platforms.
config Platform.BOARD // module-wide |
![](../../../Arrow_up.png) |
XDCscript usage |
meta-domain |
id: "0",
boardName: "evmDM420",
boardFamily: "evmDM420",
boardRevision: null
};
config Platform.CPU // module-wide |
![](../../../Arrow_up.png) |
XDCscript usage |
meta-domain |
id: "0",
clockRate: 486.0,
catalogName: "ti.catalog.c6000",
deviceName: "TMS320CDM420",
revision: ""
};
Instance Config Parameters |
![](../../../Arrow_up.png) |
XDCscript usage |
meta-domain |
var params = new Platform.Params;
// Instance config-params object
params.codeMemory = String "DDR2";
// The default segment for code sections
// A custom mapping of memory names to memory objects
params.dataMemory = String "DDR2";
// The default segment for data sections
// A mapping of memory names to memory objects for external memory
[
"DDR2",
{
name: "DDR2",
base: 0x80000000,
len: 0x10000000
}
]
];
params.renameMap = String[string] undefined;
// A map for renaming memory objects
params.sectMap = String[string] undefined;
// A mapping of linker output section names to memory segments
params.stackMemory = String "DDR2";
// The default segment for stack
config Platform.codeMemory // instance |
![](../../../Arrow_up.png) |
The default segment for code sections
XDCscript usage |
meta-domain |
var params = new Platform.Params;
...
params.codeMemory = String "DDR2";
DETAILS
Each target has a section map with keys equal to the names of all
sections that compiler and assembler for that target generate. The
value for each key is either "code" or "data" or "stack". A linker
template reads that map and puts all "code" sections in the segment
defined by this configuration parameter.
SEE
config Platform.customMemoryMap // instance |
![](../../../Arrow_up.png) |
A custom mapping of memory names to memory objects
XDCscript usage |
meta-domain |
var params = new Platform.Params;
...
DETAILS
This parameter allows platform instances to completely overwrite a
default memory map based on the internal memory map coming from CPU's
memory map and externalMemoryMap.
Custom memory map must fit within the default memory map.
config Platform.dataMemory // instance |
![](../../../Arrow_up.png) |
The default segment for data sections
XDCscript usage |
meta-domain |
var params = new Platform.Params;
...
params.dataMemory = String "DDR2";
DETAILS
Each target has a section map with keys equal to the names of all
sections that compiler and assembler for that target generate. The
value for each key is either "code" or "data" or "stack". A linker
template reads that map and puts all "data" sections in the segment
defined by this configuration parameter.
SEE
config Platform.externalMemoryMap // instance |
![](../../../Arrow_up.png) |
A mapping of memory names to memory objects for external memory
XDCscript usage |
meta-domain |
var params = new Platform.Params;
...
[
"DDR2",
{
name: "DDR2",
base: 0x80000000,
len: 0x10000000
}
]
];
DETAILS
This parameter defines the external portion of the platform's memory
map.
config Platform.renameMap // instance |
![](../../../Arrow_up.png) |
A map for renaming memory objects
XDCscript usage |
meta-domain |
var params = new Platform.Params;
...
params.renameMap = String[string] undefined;
DETAILS
This map renames memory objects. If you do not want to change
addresses in the default memory map, but you only want to rename the
existing memory objects, you should use this parameter.
This map and 'customMemoryMap' should not be used together because this
map renames the default memory, but then 'customMemoryMap' replaces the
default memory objects. The parameters 'codeMemory', 'dataMemory' and
'stackMemory' are not automatically reassigned to new names. It is the
user's responsibility to set those parameters accordingly to
'renameMap'.
config Platform.sectMap // instance |
![](../../../Arrow_up.png) |
A mapping of linker output section names to memory segments
XDCscript usage |
meta-domain |
var params = new Platform.Params;
...
params.sectMap = String[string] undefined;
DETAILS
During the generation of linker command files, the templates used to
create these files examine several sources of information to determine
the placement of named output sections into memory segments defined
by the platform. The default placement, described below,
uses information from the target and this platform's
codeMemory,
dataMemory, and
stackMemory configuration parameters.
sectMap is used to override this default placement of
output sections (".text", ".cinit", etc.) to a memory
segment defined by the platform's memory map. For example, even if
a platform's codeMemory parameter is defined to be "SRAM" and
".cinit" output sections are "code" sections, if the platform also
defines the following sectMap, the section ".cinit" will be placed
into a memory segment named "DDR2".
sectMap[] = [
[".cinit", "DDR2"],
];
NOTE
If an output section has an entry in
Program.sectMap, that entry
overrides the placement specified by this
sectMap. A program's
sectMap configuration always overrides the platform's
sectMap
settings.
DEFAULT MAPPING
The default placement of a target's output sections into memory
segments defined by the platform is determined by the following
configuration parameters:
- ITarget.sectMap
used to map a named output section to either "code", "data",
or "stack"
- codeMemory
names a memory segment that will contain all "code"
output sections
- dataMemory
names a memory segment that will contain all "data"
output sections
- stackMemory
names a memory segment that will contain all "stack"
output sections
SEE
config Platform.stackMemory // instance |
![](../../../Arrow_up.png) |
The default segment for stack
XDCscript usage |
meta-domain |
var params = new Platform.Params;
...
params.stackMemory = String "DDR2";
DETAILS
Each target has a section map with keys equal to the names of all
sections that compiler and assembler for that target generate. The
value for each key is either "code" or "data" or "stack". A linker
template reads that map and puts all "stack" sections in the segment
defined by this configuration parameter.
SEE
Instance Creation |
![](../../../Arrow_up.png) |
XDCscript usage |
meta-domain |
var params =
new Platform.
Params;
// Allocate instance config-params
params.config = ...
// Assign individual configs
var inst = Platform.create(String name, Any args, params);
// Create an instance-object
ARGUMENTS
name
the name of the platform instance being created
This name is the suffix of the platform
specification supplied in the build script after
the platform name (and optional ':') prefix has
been removed. So the platform instance name
"joes.platform.foo:bar" results in the name "bar"
and the name "joes.platform.foo" result in the name
"".
args
deprecated parameter that should not be used in
a platform instance implementation
Platform.getCpuDataSheet() // instance |
![](../../../Arrow_up.png) |
Get the Cpu data sheet object corresponding to specified cpu id
XDCscript usage |
meta-domain |
inst.getCpuDataSheet(Any cpuId) returns Any
ARGUMENTS
cpuId
a string that corresponds to the platform-specific id
of a CPU on this platform that runs executables.
DETAILS
This function executes in either the Configuration object model
or the Build object model.
RETURNS
Returns an
xdc.platform.ICpuDataSheet
instance object that corresponds to the specified
cpuId.
THROWS
Error exceptions are thrown for fatal errors.
Platform.getExeContext() // instance |
![](../../../Arrow_up.png) |
Get execution context object corresponding to the specified program
XDCscript usage |
meta-domain |
inst.getExeContext(Any prog) returns Any
ARGUMENTS
prog
the xdc.cfg.Program object representing the
program being configured.
This object contains the following properties that
allows the platform to determine the appropriate Cpu
object to return (if there is more than one):
prog.build.cpuId,
prog.build.cpuArgs,
prog.build.target,
DETAILS
This is called before the program's configuration script runs to
get the Cpu object that is assigned to the program's cpu field.
Note: that the build script for the program is responsible for
specifying the CPU; this is done by either implicitly naming the
platform or explicitly naming a particular CPU on the platform
(see
xdc.bld.Executable.Attrs.cpuId).
This function executes in the Configuration object model.
RETURNS
Returns an
xdc.platform.IExeContext instance
object that corresponds to the CPU that will run the
specified program.
THROWS
Error exceptions are thrown for fatal errors.
Platform.getExecCmd() // instance |
![](../../../Arrow_up.png) |
Get the exec command used to run the program on this platform
XDCscript usage |
meta-domain |
inst.getExecCmd(Any prog, Any platPath) returns Any
ARGUMENTS
prog
the xdc.cfg.Program object representing the
program being configured.
This object contains the following properties that
allows the platform to determine the appropriate Cpu
object to return (if there is more than one):
prog.build.cpuId,
prog.build.cpuArgs,
prog.build.target
platPath
full path to the platform package for the program
DETAILS
This function is called after the program's configuration script runs
and returns commands that are used to load and run the specified
program. These commands are placed in a makefile that is included
by the client package's generated makefile. Thus, the commands may
refer to macros defined in this environment; e.g., $(SHELL) and
$(XDCROOT), etc.
The special macro
$(1) expands to test-specific arguments
(
xdc.bld.Test.attrs.execArgs) that are passed from the test
to the platform's exec command. Thus, all platforms that support
arguments to their exec command, should embed "
$(1)" within the
command string at the appropriate place to have these arguments
interpreted the exec command.
For example, a platform that uses a shell script to run executables
and allows options to be passed to the shell script might return
the following string:
"$(SHELL) <exec_path> $(1) <exe_name>"
where,
<exec_path> is the absolute path to the platform's exec
shell script, and
<prog_name> is the name of the executable relative
to the package's base directory (i.e.,
xdc.cfg.Program.name).
This function executes in the Configuration object model.
RETURNS
Returns a string of commands used to execute this
program in the context of the XDC generated makefiles.
THROWS
Error exceptions are thrown for fatal errors.
Platform.getLinkTemplate() // instance |
![](../../../Arrow_up.png) |
Get Linker Command file template used to link an executable
XDCscript usage |
meta-domain |
inst.getLinkTemplate(Any prog) returns Any
ARGUMENTS
prog
the xdc.cfg.Program object representing the
program being configured.
This object contains the following properties that
allows the platform to determine the appropriate link
template to return:
- prog.build.cpuId,
- prog.build.cpuArgs,
- prog.build.target
DETAILS
In the event that no template is provided by the program
configuration script (see
xdc.cfg.Program.linkTemplate),
the template file identified by this method is used to generate the
linker command file used to create the executable.
This function executes in the Configuration object model and
is called after the program configuration script runs. The template
is expanded in the context of the Configuration Object Model.
RETURNS
Returns a path string to a template file or null. If
null, no linker command file is generated; otherwise
this path is relative to the package path.
THROWS
Error exceptions are thrown for fatal errors.