metaonly module iar.targets.msp430.MSP430X_small

IAR MSP430X little endian, large code model, small data model target

Configuration settings sourced in iar/targets/msp430/MSP430X_small.xdc
var MSP430X_small = xdc.useModule('iar.targets.msp430.MSP430X_small');
module-wide constants & types
        obj.base// base name of the source and destination = String  ...
        obj.dstPrefix// directory prefix of destination file = String  ...
        obj.dstSuffix// suffix of destination file; e.g., ".a62" = String  ...
        obj.files// String of files to archive = String  ...
        obj.profile// index into profiles map = String  ...
        obj.opts// goal specific archiver options = String  ...
 
        obj.cmd// the command to run = String  ...
        obj.opts// required options for the command = String  ...
 
        obj.msg// brief message describing subsequent commands = String  ...
        obj.cmds// commands necessary to generate goal = String  ...
        obj.path// host-independent representation of PATH = String[]  ...
        obj.envs// environment variable settings for the cmds = String[]  ...
 
        obj.base// base name of the source and destination = String  ...
        obj.dstPrefix// directory prefix of destination file = String  ...
        obj.dstSuffix// suffix of destination file; e.g., ".o62" = String  ...
        obj.srcSuffix// optional suffix of source file; e.g., ".c" = String  ...
        obj.srcPrefix// optional directory prefix of source file = String  ...
        obj.profile// index into profiles map = String  ...
 
        obj.aopts// goal specific ASM options = String  ...
        obj.copts// goal specific C compiler options = String  ...
        obj.cfgcopts// goal specific C config file options = String  ...
        obj.defs// goal specific C/ASM definition options = String  ...
        obj.incs// goal specific C/ASM include options = String  ...
 
        obj.execTemplate// debugger template for executable = String  ...
        obj.execPattern// exec file name pattern = String  ...
        obj.packageTemplate// debugger template for package = String  ...
        obj.packagePattern// package file name pattern = String  ...
 
        obj.suf// file extension (including any '.') = String  ...
        obj.typ// type of this file; e.g., "c", "asm", .. = String  ...
 
        obj.base// base name of the source and destination = String  ...
        obj.dstPrefix// directory prefix of destination file = String  ...
        obj.dstSuffix// suffix of destination file; e.g., ".x62" = String  ...
        obj.files// string of files to link with = String  ...
        obj.profile// index into profiles map = String  ...
        obj.opts// goal specific linker options = String  ...
        obj.dllMode// true if we're linking an assembly = Bool  ...
        obj.isRom// reflects the isRom attribute = Bool  ...
 
        obj.endian// endian-ness of this target = String  ...
        obj.codeModel// target-specific code model = String  ...
        obj.dataModel// target-specific data model = String  ...
 
        obj.linkOpts// profile-specific linker opts = String  ...
        obj.archiveOpts// profile-specific archiver opts = String  ...
 
        obj.prefix// options that appear before Command.opts = String  ...
        obj.suffix// options that appear after Command.opts = String  ...
 
        obj.t_IArg = ITarget.TypeInfo  ...
        obj.t_Char = ITarget.TypeInfo  ...
        obj.t_Double = ITarget.TypeInfo  ...
        obj.t_Float = ITarget.TypeInfo  ...
        obj.t_Fxn = ITarget.TypeInfo  ...
        obj.t_Int = ITarget.TypeInfo  ...
        obj.t_Int8 = ITarget.TypeInfo  ...
        obj.t_Int16 = ITarget.TypeInfo  ...
        obj.t_Int32 = ITarget.TypeInfo  ...
        obj.t_Int40 = ITarget.TypeInfo  ...
        obj.t_Int64 = ITarget.TypeInfo  ...
        obj.t_Long = ITarget.TypeInfo  ...
        obj.t_LDouble = ITarget.TypeInfo  ...
        obj.t_LLong = ITarget.TypeInfo  ...
        obj.t_Ptr = ITarget.TypeInfo  ...
        obj.t_Short = ITarget.TypeInfo  ...
        obj.t_Size = ITarget.TypeInfo  ...
module-wide config parameters
        cmd: "xar",
        opts: ""
    };
        cmd: "a430",
        opts: "-v1 --data_model small --code_model large -D__SMALL_DATA_MODEL__ -DUSE_LARGE_CODE_MODEL=1"
    };
        cmd: "icc430",
        opts: "-e --core=430X --data_model=small --save_reg20"
    };
        cmd: "xlink",
        opts: ""
    };
        endian: "little",
        codeModel: "large",
        dataModel: "small",
        shortEnums: true
    };
    const MSP430X_small.name// Nickname for this target = String "MSP430X_small";
    const MSP430X_small.rts// Name of a run-time support package to include = String "iar.targets.msp430.rts";
    const MSP430X_small.sectMap// Output section name to segment type mapping = String[string] computed value;
        t_IArg: {
            size: 4,
            align: 2
        },
        t_Char: {
            size: 1,
            align: 1
        },
        t_Double: {
            size: 4,
            align: 2
        },
        t_Float: {
            size: 4,
            align: 2
        },
        t_Fxn: {
            size: 4,
            align: 2
        },
        t_Int: {
            size: 2,
            align: 2
        },
        t_Int8: {
            size: 1,
            align: 1
        },
        t_Int16: {
            size: 2,
            align: 2
        },
        t_Int32: {
            size: 4,
            align: 2
        },
        t_Long: {
            size: 4,
            align: 2
        },
        t_LDouble: {
            size: 4,
            align: 2
        },
        t_LLong: {
            size: 8,
            align: 2
        },
        t_Ptr: {
            size: 2,
            align: 2
        },
        t_Short: {
            size: 2,
            align: 2
        },
        t_Size: {
            size: 2,
            align: 2
        }
    };
        cmd: "icc430",
        opts: "-v"
    };
        cmd: "xlib",
        opts: "-c"
    };
 
        prefix: "",
        suffix: ""
    };
        prefix: "-S",
        suffix: ""
    };
    MSP430X_small.binDir//  = String "$(rootDir)/bin/";
        prefix: "$(ccOpts.prefix)",
        suffix: "$(ccOpts.suffix)"
    };
        prefix: "--silent",
        suffix: "--diag_suppress=Pa050,Go005"
    };
        [
            ".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"
            }
        ],
        [
            ".s43",
            {
                suf: ".s43",
                typ: "asm"
            }
        ]
    ];
        prefix: "-S",
        suffix: "-xens -l $(XDCCFGDIR)/$@.map -rt -e_PrintfSmall=_Printf -e_ScanfSmall=_Scanf -s __program_start"
    };
    MSP430X_small.platform// The default platform name for this target = String "ti.platforms.msp430:MSP430F5438:1";
        [
            "debug",
            {
                compileOpts: {
                    copts: "--debug --dlib_config $(rootDir)/lib/dlib/dl430xlsfn.h"
                },
                linkOpts: "$(rootDir)/lib/dlib/dl430xlsfn.r43"
            }
        ],
        [
            "release",
            {
                compileOpts: {
                    copts: "-Ohs --dlib_config $(rootDir)/lib/dlib/dl430xlsfn.h"
                },
                linkOpts: "$(rootDir)/lib/dlib/dl430xlsfn.r43"
            }
        ],
        [
            "debug_full",
            {
                compileOpts: {
                    copts: "--debug --dlib_config $(rootDir)/lib/dlib/dl430xlsff.h"
                },
                linkOpts: "$(rootDir)/lib/dlib/dl430xlsff.r43"
            }
        ],
        [
            "release_full",
            {
                compileOpts: {
                    copts: "-Ohs --dlib_config $(rootDir)/lib/dlib/dl430xlsff.h"
                },
                linkOpts: "$(rootDir)/lib/dlib/dl430xlsff.r43"
            }
        ]
    ];
    MSP430X_small.stdInclude// Standard C/C++ types header = String "iar/targets/msp430/std.h";
        prefix: "",
        suffix: "\"MAKE-LIBRARY $@\""
    };
module-wide functions
 
 
struct MSP430X_small.ArchiveGoal

The goal specification passed to the archive function

Configuration settings
var obj = new MSP430X_small.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 MSP430X_small.Command

Required command and options

Configuration settings
var obj = new MSP430X_small.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 MSP430X_small.CommandSet

The commands necessary to create a specified goal

Configuration settings
var obj = new MSP430X_small.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 MSP430X_small.CompileGoal

The goal specification passed to the compile function

Configuration settings
var obj = new MSP430X_small.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
    obj.opts = ITarget.CompileOptions  ...
    // goal specific compiler options
    obj.configOpts = Bool  ...
    // true if compiling the generated C config file
 
SEE
 
struct MSP430X_small.CompileOptions

Options passed to the compiler/assembler

Configuration settings
var obj = new MSP430X_small.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 MSP430X_small.DebugGen

Debugger integration support

Configuration settings
var obj = new MSP430X_small.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 MSP430X_small.Extension

File extension to file type association

Configuration settings
var obj = new MSP430X_small.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 MSP430X_small.LinkGoal

The goal specification passed to the link function

Configuration settings
var obj = new MSP430X_small.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 MSP430X_small.Model

Target runtime model

Configuration settings
var obj = new MSP430X_small.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 MSP430X_small.OptionSet

Collection of tool-chain options

Configuration settings
var obj = new MSP430X_small.OptionSet;
 
    obj.compileOpts = ITarget.CompileOptions  ...
    // profile-specific compiler opts
    obj.linkOpts = String  ...
    // profile-specific linker opts
    obj.archiveOpts = String  ...
    // profile-specific archiver opts
    obj.filters = ITargetFilter.InstDesc[]  ...
    // 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 MSP430X_small.Options

User configurable command options

Configuration settings
var obj = new MSP430X_small.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 MSP430X_small.StdTypes

Standard base types supported by all targets

Configuration settings
var obj = new MSP430X_small.StdTypes;
 
    obj.t_IArg = ITarget.TypeInfo  ...
    obj.t_Char = ITarget.TypeInfo  ...
    obj.t_Double = ITarget.TypeInfo  ...
    obj.t_Float = ITarget.TypeInfo  ...
    obj.t_Fxn = ITarget.TypeInfo  ...
    obj.t_Int = ITarget.TypeInfo  ...
    obj.t_Int8 = ITarget.TypeInfo  ...
    obj.t_Int16 = ITarget.TypeInfo  ...
    obj.t_Int32 = ITarget.TypeInfo  ...
    obj.t_Int40 = ITarget.TypeInfo  ...
    obj.t_Int64 = ITarget.TypeInfo  ...
    obj.t_Long = ITarget.TypeInfo  ...
    obj.t_LDouble = ITarget.TypeInfo  ...
    obj.t_LLong = ITarget.TypeInfo  ...
    obj.t_Ptr = ITarget.TypeInfo  ...
    obj.t_Short = ITarget.TypeInfo  ...
    obj.t_Size = ITarget.TypeInfo  ...
 
SEE
 
config MSP430X_small.alignDirectiveSupported  // module-wide

The compiler supports an align directive

Configuration settings
const MSP430X_small.alignDirectiveSupported = Bool true;
 
 
config MSP430X_small.ar  // module-wide

The command used to create an archive

Configuration settings
const MSP430X_small.ar = ITarget.Command {
    cmd: "xar",
    opts: ""
};
 
 
config MSP430X_small.asm  // module-wide

The command used to assembles assembly source files into object files

Configuration settings
const MSP430X_small.asm = MSP430X_small.Command {
    cmd: "a430",
    opts: "-v1 --data_model small --code_model large -D__SMALL_DATA_MODEL__ -DUSE_LARGE_CODE_MODEL=1"
};
 
DETAILS
Defaults:
-v1
MSP430X architecture
-D__SMALL_DATA_MODEL__
indicate that this is small model to assembly code; IAR does currently have any pre-defined macros for this purpose; we use this symbol because it is the same as that used by the TI compiler (so some degree of portability is possible).
 
config MSP430X_small.base  // module-wide

A target that this target is based upon

Configuration settings
const MSP430X_small.base = ITarget.Module computed value;
 
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 MSP430X_small.bitsPerChar  // module-wide

The number of bits in a variable of type char

Configuration settings
const MSP430X_small.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 MSP430X_small.cc  // module-wide

The command used to compile C/C++ source files into object files

Configuration settings
const MSP430X_small.cc = MSP430X_small.Command {
    cmd: "icc430",
    opts: "-e --core=430X --data_model=small --save_reg20"
};
 
DETAILS
Defaults:
-e
enable compiler extensions so it's possible to get segment start addresses in C, via:
              #pragma segment = "CSTACK"
              isrStack = __segment_begin("CSTACK");
---core=430X MSP430X architecture ---data_model Small data model for MSP430X architecture ---save_reg20 All 20 bits of registers are preserved in all interrupt functions
 
config MSP430X_small.isa  // module-wide

CPU Instruction Set Architecture (ISA)

Configuration settings
const MSP430X_small.isa = String "430X";
 
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 MSP430X_small.lnk  // module-wide

The command used to link executables

Configuration settings
const MSP430X_small.lnk = ITarget.Command {
    cmd: "xlink",
    opts: ""
};
 
 
config MSP430X_small.model  // module-wide

Run-time model

Configuration settings
const MSP430X_small.model = ITarget.Model {
    endian: "little",
    codeModel: "large",
    dataModel: "small",
    shortEnums: true
};
 
DETAILS
This structure identifies a particular run-time model used by the compiler to generate instructions.
 
config MSP430X_small.name  // module-wide

Nickname for this target

Configuration settings
const MSP430X_small.name = String "MSP430X_small";
 
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 MSP430X_small.os  // module-wide

Name of OS required to run programs built for this target

Configuration settings
const MSP430X_small.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 MSP430X_small.rts  // module-wide

Name of a run-time support package to include

Configuration settings
const MSP430X_small.rts = String "iar.targets.msp430.rts";
 
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.
 
config MSP430X_small.sectMap  // module-wide

Output section name to segment type mapping

Configuration settings
const MSP430X_small.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 MSP430X_small.stdTypes  // module-wide

Size and alignment for standard base types

Configuration settings
const MSP430X_small.stdTypes = ITarget.StdTypes {
    t_IArg: {
        size: 4,
        align: 2
    },
    t_Char: {
        size: 1,
        align: 1
    },
    t_Double: {
        size: 4,
        align: 2
    },
    t_Float: {
        size: 4,
        align: 2
    },
    t_Fxn: {
        size: 4,
        align: 2
    },
    t_Int: {
        size: 2,
        align: 2
    },
    t_Int8: {
        size: 1,
        align: 1
    },
    t_Int16: {
        size: 2,
        align: 2
    },
    t_Int32: {
        size: 4,
        align: 2
    },
    t_Long: {
        size: 4,
        align: 2
    },
    t_LDouble: {
        size: 4,
        align: 2
    },
    t_LLong: {
        size: 8,
        align: 2
    },
    t_Ptr: {
        size: 2,
        align: 2
    },
    t_Short: {
        size: 2,
        align: 2
    },
    t_Size: {
        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 MSP430X_small.suffix  // module-wide

Suffix appended to all objs, libraries, and executable

Configuration settings
const MSP430X_small.suffix = String "r430XS";
 
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 produce 100% EABI compatible objects and, targets with different suffixes should produce objects with incompatible EABIs.
SEE
 
config MSP430X_small.vers  // module-wide

The command used to get the tool-chain to return a version number

Configuration settings
const MSP430X_small.vers = ITarget.Command {
    cmd: "icc430",
    opts: "-v"
};
 
 
config MSP430X_small.xlib  // module-wide

The command used to modify a library

Configuration settings
const MSP430X_small.xlib = ITarget.Command {
    cmd: "xlib",
    opts: "-c"
};
 
DETAILS
Defaults:
-c
run command line
 
config MSP430X_small.arOpts  // module-wide

User configurable archiver options

Configuration settings
MSP430X_small.arOpts = ITarget.Options {
    prefix: "",
    suffix: ""
};
 
 
config MSP430X_small.asmOpts  // module-wide

User configurable assembler options

Configuration settings
MSP430X_small.asmOpts = ITarget.Options {
    prefix: "-S",
    suffix: ""
};
 
DETAILS
Defaults:
-S
Silent operation
 
config MSP430X_small.binDir  // module-wide
Configuration settings
MSP430X_small.binDir = String "$(rootDir)/bin/";
 
 
config MSP430X_small.ccConfigOpts  // module-wide

User configurable compiler options for the generated config C file

Configuration settings
MSP430X_small.ccConfigOpts = ITarget2.Options {
    prefix: "$(ccOpts.prefix)",
    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 MSP430X_small.ccOpts  // module-wide

User configurable compiler options

Configuration settings
MSP430X_small.ccOpts = ITarget.Options {
    prefix: "--silent",
    suffix: "--diag_suppress=Pa050,Go005"
};
 
DETAILS
Defaults:
--silent
Silent operation
--diag_suppress
Pa050 complains about Unix EOL characters Go005 complains about function inlining
 
config MSP430X_small.cmdPrefix  // module-wide

Prefix to put in front of each command

Configuration settings
MSP430X_small.cmdPrefix = String "";
 
DETAILS
This string is put in front of every Command before being passed to the shell for execution. This string can be used to run the compiler in emulation environments.
 
config MSP430X_small.compatibleSuffixes  // module-wide

Array of suffixes used by targets compatible with this target

Configuration settings
MSP430X_small.compatibleSuffixes = String[] undefined;
 
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 MSP430X_small.debugGen  // module-wide

Debugger/IDE file generation support

Configuration settings
MSP430X_small.debugGen = ITarget.DebugGen undefined;
 
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 MSP430X_small.execExt  // module-wide

Extension for executables

Configuration settings
MSP430X_small.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 MSP430X_small.extensions  // module-wide

The IAR assembly file extension recognised by this target

Configuration settings
MSP430X_small.extensions = ITarget.Extension[string] [
    [
        ".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"
        }
    ],
    [
        ".s43",
        {
            suf: ".s43",
            typ: "asm"
        }
    ]
];
 
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 MSP430X_small.includeOpts  // module-wide

Additional user configurable target-specific include path options

Configuration settings
MSP430X_small.includeOpts = String "";
 
 
config MSP430X_small.lnkOpts  // module-wide

User configurable linker options

Configuration settings
MSP430X_small.lnkOpts = ITarget2.Options {
    prefix: "-S",
    suffix: "-xens -l $(XDCCFGDIR)/$@.map -rt -e_PrintfSmall=_Printf -e_ScanfSmall=_Scanf -s __program_start"
};
 
DETAILS
Defaults:
-S
Silent operation
-xens
Cross reference list generated in map file
-l
Generates a map file
-rt
Plugins in IAR debugger low level functions
-e
Redirects function call to another function at link time
-s
Program entry point
 
config MSP430X_small.platform  // module-wide

The default platform name for this target

Configuration settings
MSP430X_small.platform = String "ti.platforms.msp430:MSP430F5438:1";
 
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 MSP430X_small.platforms  // module-wide

A set of platforms that can support this target

Configuration settings
MSP430X_small.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 MSP430X_small.profiles  // module-wide

Standard options profiles for the IAR MSP430 tool-chain

Configuration settings
MSP430X_small.profiles = ITarget.OptionSet[string] [
    [
        "debug",
        {
            compileOpts: {
                copts: "--debug --dlib_config $(rootDir)/lib/dlib/dl430xlsfn.h"
            },
            linkOpts: "$(rootDir)/lib/dlib/dl430xlsfn.r43"
        }
    ],
    [
        "release",
        {
            compileOpts: {
                copts: "-Ohs --dlib_config $(rootDir)/lib/dlib/dl430xlsfn.h"
            },
            linkOpts: "$(rootDir)/lib/dlib/dl430xlsfn.r43"
        }
    ],
    [
        "debug_full",
        {
            compileOpts: {
                copts: "--debug --dlib_config $(rootDir)/lib/dlib/dl430xlsff.h"
            },
            linkOpts: "$(rootDir)/lib/dlib/dl430xlsff.r43"
        }
    ],
    [
        "release_full",
        {
            compileOpts: {
                copts: "-Ohs --dlib_config $(rootDir)/lib/dlib/dl430xlsff.h"
            },
            linkOpts: "$(rootDir)/lib/dlib/dl430xlsff.r43"
        }
    ]
];
 
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 MSP430X_small.rawVersion  // module-wide

The raw version string from the compiler

Configuration settings
MSP430X_small.rawVersion = String undefined;
 
READONLY
This value is automatically computed by the XDC Build Engine by executing the getRawVersion() function after package.bld completes but prior to generating package.mak.
 
config MSP430X_small.rootDir  // module-wide

Installation directory for this target's code generation tools

Configuration settings
MSP430X_small.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 MSP430X_small.stdInclude  // module-wide

Standard C/C++ types header

Configuration settings
MSP430X_small.stdInclude = String "iar/targets/msp430/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 MSP430X_small.version  // module-wide

The Compatibility Key associated with this target

Configuration settings
MSP430X_small.version = String undefined;
 
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.
 
config MSP430X_small.versionMap  // module-wide

Map of compiler version numbers to compatibility keys

Configuration settings
MSP430X_small.versionMap = String[string] [ ];
 
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.
SEE
 
config MSP430X_small.xlibOpts  // module-wide

User configurable xlib options

Configuration settings
MSP430X_small.xlibOpts = ITarget.Options {
    prefix: "",
    suffix: "\"MAKE-LIBRARY $@\""
};
 
DETAILS
Defaults:
MAKE-LIBRARY
changes a module to library type
 
MSP430X_small.archive()  // module-wide

Create an archive

Configuration settings
MSP430X_small.archive(ITarget.ArchiveGoal* goal) returns ITarget.CommandSet*
 
ARGUMENTS
goal — the ArchiveGoal defining the archive to build.
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.
 
MSP430X_small.compile()  // module-wide

Compile a source file into an object file

Configuration settings
MSP430X_small.compile(ITarget.CompileGoal* goal) returns ITarget.CommandSet*
 
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.
 
MSP430X_small.findSuffix()  // module-wide

Find the suffix that is compatible with this target

Configuration settings
MSP430X_small.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:
  1. if this target's suffix is in the list, that suffix is returned.
  2. suffixes from compatibleSuffixes are matched against the list in the order they appear in compatibleSuffixes, and the first one found in the list 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.
 
MSP430X_small.genConstCustom()  // module-wide

Return any custom generated code related to generated constants

Configuration settings
MSP430X_small.genConstCustom(String[] names, String[] types) returns String
 
DETAILS
This function is invoked for each constant in the generated config C file. This includes module-level config parameter, as well as the internal data structures that define modules, interfaces and instances. A target is given a chance to add any target-specific pragmas or attributes for the generated constants. The set of the data supplied to this function overlaps with the data supplied to genVisibleData, so their output must be coordinated to avoid duplicate or inconsistent definitions or directives.
PARAMS
array of constant names generated in the config C file
array of types; each type corresponds to the element of names with the same index
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.
 
MSP430X_small.genVisibleData()  // module-wide

Return any custom generated code related to data generated in the config C file

Configuration settings
MSP430X_small.genVisibleData(String[] quals, String[] types, String[] names) returns String
 
DETAILS
This function is invoked for each module-level configuration parameter in the configuration. Such parameters are represented by constants in the generated config C file.
A target is given a chance to add any target-specific pragmas or attributes for the generated constants. The set of the data supplied to this function overlaps with the data supplied to genConstCustom, so their output must be coordinated to avoid duplicate or inconsistent definitions or directives.
PARAMS
array of declaration qualifiers for the generated data
array of types for the generated data
array of variable names; each name corresponds to the elements of quals and types with the same index
RETURNS
This function returns custom C code that will be embedded into the generated config C file. The purpose of the function is to allow targets to add pragmas or attributes to prevent elimination of data in case of partially linker objects. 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.
 
MSP430X_small.genVisibleFxns()  // module-wide

Return any custom generated code related to functions generated in the config C file

Configuration settings
MSP430X_small.genVisibleFxns(String[] types, String[] names, String[] args) returns String
 
PARAMS
array of types of functions' return values
array of functions' names; each name corresponds to the elements of types and args with the same index
array of functions' argument lists, including qualifiers
RETURNS
This function returns custom C code that will be embedded into the generated config C file. The purpose of the function is to allow targets to add pragmas or attributes to prevent elimination of functions in case of partially linker objects.
 
MSP430X_small.genVisibleLibFxns()  // module-wide

Return any custom generated code related to functions that are included in the configuration, but are not generated in the config C file

Configuration settings
MSP430X_small.genVisibleLibFxns(String[] types, String[] names, String[] args) returns String
 
PARAMS
array of types of functions' return values
array of functions' names; each name corresponds to the elements of types and args with the same index
array of functions' argument lists, including qualifiers
RETURNS
This function returns custom C code that will be embedded into the generated config C file. The purpose of the function is to allow targets to add pragmas or attributes to prevent elimination of functions in case of partially linker objects. These functions are managed separately from the functions that are generated in the config C file because some pragmas and attributes can be used only for functions defined in the same compilation unit where the paragmas and attributes are generated. For functions that are not generated in the config C file, and the mentioned restrictions exist, targets may have to create references that will prevent elimination of functions defined outside of the config C file.
 
MSP430X_small.getISAChain()  // module-wide

Get this target's ISA "is compatible with" relation

Configuration settings
MSP430X_small.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:
  1. pre-define macro definitions that enable code to be conditionally compiled based on compatible versions of a target's ISA.
  2. 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".
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.
 
MSP430X_small.getRawVersion()  // module-wide

Get a target-specific raw compiler version string

Configuration settings
MSP430X_small.getRawVersion() returns String
 
DETAILS
This function is called during makefile generation to obtain a target-specific raw compiler version string.
RETURNS
This function returns a string, typically provided by the compiler itself, that identifies the version of the compiler referenced by rootDir.
THROWS
Error exceptions are thrown for fatal errors.
 
MSP430X_small.getVersion()  // module-wide

Get a target-specific Compatibility Key string

Configuration settings
MSP430X_small.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.
 
MSP430X_small.link()  // module-wide

Link object files to produce an executable

Configuration settings
MSP430X_small.link(ITarget.LinkGoal* goal) returns ITarget.CommandSet*
 
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.
 
MSP430X_small.scompile()  // module-wide

Compile a source file into an assembly language file

Configuration settings
MSP430X_small.scompile(ITarget.CompileGoal* goal) returns ITarget.CommandSet*
 
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.
 
MSP430X_small.selectSuffix()  // module-wide

Select the suffix that is compatible with this target

Configuration settings
MSP430X_small.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:
  1. if this target's suffix is in the list, that suffix is returned.
  2. suffixes from compatibleSuffixes are matched against the list in the order they appear in compatibleSuffixes, and the first one found in the list 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.
generated on Tue, 14 Feb 2017 20:00:28 GMT