module xdc.cfg.Program

metaonly module xdc.cfg.Program

The Program object for the configuration object model

XDCscript usage
XDCspec declarations
Individual elements
Additional documentation

This module defines the "root" of the configuration object model; all configuration settings are for the executable represented by this object. Program configuration scripts reference this module via the global variable Program; i.e., Program implicitly initialized as follows: [ more ... ]

XDCspec summary sourced in xdc/cfg/Program.xdc

metaonly module Program { ...

XDCscript usage meta-domain

var Program = xdc.useModule('xdc.cfg.Program');

module-wide constants & types

var obj = new Program.GenerationOptions// Options that control the files generated as part of program configuration;

obj.debuggerFiles// if true, generate debugger "project" files = Bool ...

var obj = new Program.SectionSpec// Map that instructs the linker where to place output sections;

obj.runSegment// segment where section contents are run = String ...

obj.loadSegment// segment where section contents are loaded = String ...

obj.runAddress// start address of section when run = UInt ...

obj.loadAddress// start address of section when loaded = UInt ...

obj.runAlign// alignment of section within runSegment = UInt ...

obj.loadAlign// alignment of section within loadSegment = UInt ...

obj.type// target-specific flags = String ...

obj.fill// fill value = UInt ...

module-wide config parameters

Program.argSize// The size allocated for command line args to the executable = UInt 0x200;

Program.build// This program's build attributes = Any undefined;

Program.buildPackage// The name of the executable's package = String undefined;

Program.codeModel// The memory model for code = String null;

Program.cpu// The execution context "seen" by the executable = IExeContext.Instance undefined;

Program.dataModel// The memory model for data = String null;

Program.endian// The endianess of the executable = String null;

Program.execCmd// The command used to run this executable = String undefined;

Program.gen// Generation options for this executable = Program.GenerationOptions undefined;

Program.global// Global variable declarations = Any[string] undefined;

Program.heap// The size of the executable's initial heap = UInt 0x1000;

Program.linkTemplate// The template for the Program's linker command file = String null;

Program.main// The main entry point for the program = Int(*)(Int,Char*[]) undefined;

Program.name// The name of the executable file = String undefined;

Program.platform// The executable's platform instance object = IPlatform.Instance undefined;

Program.platformName// The name of the executable's platform = String undefined;

Program.sectMap// A section name to SectionSpec mapping = Any[string] undefined;

Program.stack// The size of the executable's initial stack = UInt 0x1000;

Program.sysStack// The size of the executable's initial system stack = UInt 0x1000;

module-wide functions

Program.exportModule// Force all the symbols of a module to be part of a configuration( String modName ) returns Void

Program.getSectMap// Return the complete mapping of section names to SectionSpec entries( ) returns Any

XDCspec declarations sourced in xdc/cfg/Program.xdc

package xdc.cfg;

metaonly module Program {

module-wide constants & types

metaonly struct GenerationOptions// Options that control the files generated as part of program configuration {

Bool debuggerFiles// if true, generate debugger "project" files;

};

metaonly struct SectionSpec// Map that instructs the linker where to place output sections {

String runSegment// segment where section contents are run;

String loadSegment// segment where section contents are loaded;

UInt runAddress// start address of section when run;

UInt loadAddress// start address of section when loaded;

UInt runAlign// alignment of section within runSegment;

UInt loadAlign// alignment of section within loadSegment;

String type// target-specific flags;

UInt fill// fill value;

};

module-wide config parameters

config UInt argSize// The size allocated for command line args to the executable = 0x200;

config Any build// This program's build attributes;

config String buildPackage// The name of the executable's package;

config String codeModel// The memory model for code = null;

config IExeContext.Instance cpu// The execution context "seen" by the executable;

config String dataModel// The memory model for data = null;

config String endian// The endianess of the executable = null;

config String execCmd// The command used to run this executable;

config Program.GenerationOptions gen// Generation options for this executable;

config Any global// Global variable declarations[string];

config UInt heap// The size of the executable's initial heap = 0x1000;

config String linkTemplate// The template for the Program's linker command file = null;

config Int (*main// The main entry point for the program)(Int,Char*[]);

config String name// The name of the executable file;

config IPlatform.Instance platform// The executable's platform instance object;

config String platformName// The name of the executable's platform;

config Any sectMap// A section name to SectionSpec mapping[string];

config UInt stack// The size of the executable's initial stack = 0x1000;

config UInt sysStack// The size of the executable's initial system stack = 0x1000;

module-wide functions

Void exportModule// Force all the symbols of a module to be part of a configuration( String modName );

function getSectMap// Return the complete mapping of section names to SectionSpec entries( );

}

DETAILS

      var Program = xdc.useModule('xdc.cfg.Program');

After a configuration script completes successfully, the XDC runtime generates the following files:

package/cfg/<exe_name>.c
package/cfg/<exe_name>.xdl

where <exe_name> is the name of the executable with the final '.' character replaced with an '_'.

The generated C file contains code and data from each module used by the program and must be compiled and linked with the other sources to produce the final executable.

The generated linker command file must also be used during this final link step. This linker command file is produced by expanding a template specified by xdc.cfg.Program.linkTemplate. Each template is responsible for expanding templates specified by each imported package's getSects method (see xdc.IPackage.getSects). This allows each package participating in the configuration of an executable to contribute a portion of the executable's linker command file.

struct Program.GenerationOptions