Build Switch

The directory in which CodeWarrior is installed.

Setting is automatic when you install CodeWarrior for NITRO. When setting with bash in cygwin, the path must be enclosed in single quotes:

% export CWFolder_NITRO='D:/Program Files/Metrowerks/CodeWarrior' 

When setting with Windows environment variables, it becomes:

D:/Program Files/Metrowerks/CodeWarrior

Both / and \ will work as path delimiters.

Initial value: C:\Program Files\Metrowerks\CodeWarrior for NITRO V0.5

Directory that contains the CodeWarrior license file.

Initial value: none. Normally this is not required.

NITROSDK is installed in this directory. Additionally, $NITROSDK is deployed in this directory.

Although / and \ will both work as path delimiters, there are many cases in which the IDE in CodeWarrior prefers \, so we recommend using \.

Initial value: C:\NitroSDK. However, if the SDK is provided by the installer, the path that is selected by the installer will be set.

The NITRO compile target is specified as shown below.
The architecture is specified with NITRO_PLATFORM, and the exact version related to the TS is specified with NITRO_TS_VERSION.

Switching by NITRO_PLATFORM
TS	IS-NITRO-EMULATOR hardware or the NINTENDO-DS retail unit (Detailed differences between the versions is selected with NITRO_TS_VERSION)
TEG	TEG board
BB	Breadboard

Switching by NITRO_TS_VERSION
0	From TS Bread Board to IS-NITRO-EMULATOR hardware Ver. C
100	IS-NITRO-EMULATOR hardware Ver. D
200	IS-NITRO-EMULATOR hardware Ver. E or Nintendo DS retail device (current as of 9/10/04)

Initial value: NITRO_PLATFORM=TS and NITRO_TS_VERSION=100

This specifies the NITRO compile target main memory size. This environment variable is currently disabled.

4M	4 Megabytes
8M	8 Megabytes

Initial value: 4M

Compiler specification. However, currently only CodeWarrior is supported.

CW	CodeWarrior
ARM	ARM ADS
GCC	GNU C Compiler

Initial value: CW

You can select from the following compile targets: DEBUG version, RELEASE version, FINALROM version. When the make command is executed, the compile options and the linked libraries will change according to this setting. Unlike other variables, this variable is enabled by setting a value that is applicable to one of the three values.

Initial value: NITRO_RELEASE

When some value has been specified, the STATIC/OVERLAY segment is compressed after the link is completed.
Initial value: None (no compression)

This build switch is enabled only for applications. It is disabled at SDK build time. If a value is set, the program will build for a DS Single-Card Play child program that uses overlays.

If some value is set, the -profile option is added when compiling. This is primarily used during debugging so that input and output can be traced during execution. For more details, please refer to OS_DumpCallTrace().

Initial value: None (-profile is invalid)

If some value is set, remove the specified -g option when performing a standard compile or when linking. This can shorten the link processing time that causes problems in large-scale projects.

Initial value: None (-g is valid)

IS-NITRO-EMULATOR related files are installed in this directory.
Setting is automatic when you install IS-NITRO-EMULATOR.
If this environment variable exists, the IS-NITRO-EMULATOR related library is automatically linked.

Initial value: C:/Program Files/INTELLIGENT SYSTEMS/IS-NITRO-EMULATOR

In case some value was set, the code for the automated test becomes effective. Management macro for SDK.

Initial value: None. (test code is invalid)

One of these is defined in accordance with the NITRO compile target specification (environment variable NITRO_PLATFORM).

SDK_BB	Breadboard (not currently used)
SDK_TEG	TEG board
SDK_TS	TS

Initial value: SDK_TEG

One of these is defined in accordance with the NITRO compile target main memory size specification (environment variable NITRO_MEMSIZE).

SDK_4M	4 Megabytes
SDK_8M	8 Megabytes

Initial value: SDK_4M

One of these is defined in accordance with the processor for which the compile or assembly is performed.

SDK_ARM9	Build for main processor
SDK_ARM7	Build for subprocessor

Initial value: SDK_ARM9

Shows whether the compiler option is set to generate Thumb code or ARM code.

This is simply to show "Initial Settings". You must reference the definition macro that is incorporated in the compiler to see which code is actually being generated (in the case of CW, _thumb_).

We recommend that when pragma has been used to explicitly switch code generation within one range of the source, when this range ends you should return code generation to the setting shown by this value.

SDK_CODE_ARM	Command set for ARM
SDK_CODE_THUMB	Command set for THUMB

Initial value: CODEGEN_CC/CODEGEN_AS settings

One of these is defined in accordance with the compiler that is being used.

SDK_CW	CodeWarrior
SDK_ADS	ARM ADS
SDK_GCC	GNU C Compiler

Initial value: SDK_CW

This is defined when assembling with the assembler.

Use this when you want to note that sharing the C header file will cause an error in the assembler.

One of these is defined in accordance with which one of the target compile targets has been specified: DEBUG, RELEASE, or FINALROM).

SDK_DEBUG	DEBUG version
SDK_RELEASE	RELEASE version
SDK_FINALROM	FINALROM version

Initial value: SDK_RELEASE

This 8-digit number indicates the packaging date of the SDK as YYYYMMDD.

This value is defined in the $NitroSDK/include/nitro/version.h file.

Because version.h is not included in nitro.h, use the #include <nitro/version.h> statement when referencing this value from the source code.

Generally, SDK_PACKING_DATE and SDK_VERSION_DATE are set in same date value. However, when applying a patch for some kind of modification after the release of the SDK, SDK_PACKING_DATE becomes the release date of the patch and SDK_VERSION_DATE becomes the release date of the SDK that is the target to be modified.

This is an SDK Management Macro.

When build is performed, it works with the environment variable NITRO_AUTOTEST.

The testing code inside your SDK needs to be written as valid auto-test code, only when this macro is defined.

There are other temporary compile switches, such as those shown below. Currently no general method has been prepared for these user compile switches. Use them as keywords when searching.

SDK_NO_THREAD	Creates a library that does not use the THREAD function.
SDK_*BUG_*	This is the bug handling switch.
SDK_NO_INTERWORKING	Creates a library that does not consider Thumb/ARM switching.
SDK_SMALL_BUILD	Creates a library with a smaller code size by limiting some functions. (Operation of libraries created with this option is not guaranteed.)

This symbol controls the size of the DTCM stack used during application startup. Games can be customized by revising the LCF file or LCF specification file.

The OS_Init() function allocates the DTCM region that can be used (excluding the region reserved by the system and interrupt process) to the stack and DTCM arena based on the stack size determined by this value. The configuration method used by OS_Init() depends on whether the value of SDK_SYS_STACKSIZE is positive, negative, or 0.

For Positive Values	The value of SDK_SYS_STACKSIZE is taken as the stack size and the remaining region is allocated to the DTCM arena.
For 0	All available DTCM is set as the stack. The DTCM arena cannot be used.
For Negative Values	The absolute value of SDK_SYS_STACKSIZE is set as the size of the DTCM arena and the remaining region is used as the stack.

Initial Value: 0
All available DTCM is used as the stack.

This is the stack size that is used in the interrupt routine. It is secured as a system region in DTCM.

Here we have taken into account function calls in the interrupt routine that use a lot of the stack, such as OS_Printf. Therefore the initial value is a little high. It is possible to reduce this in the ship ROM version, which will not use OS_Printf.

Depending on the debug environment, you will have to call the debug routine from the interrupt handler, and in some cases you will need to increase this value. For this refer to the documentation for each debug environment.

Initial value: 0x400 bytes.

Initial value of the Low address of the main arena.
This value is automatically set during linking.

Enumerates directories you want to associate with the make process.

Initial value: None

Enumerates the Makefiles that you want to associate with the make process.

Initial value: None

Enumerates source files you want to compile or assemble.

Based on each file extension, make will attempt to generate object files using a compiler or assembler for the following programming languages:

Extension	Programming language
.c	C
.cpp	C++
.s	Assembler

Lists the source files to compile or assemble. The object files created from the files specified here are registered as being affiliated with the OVERLAY group.

Specifies the source file's directory.

Initial value: ./src

The initial value is a path specified by src. The path is relative to the directory from which make is performed.

If there is a private include file (an include file specific to the module) this specifies the directory. You don't need to use this if it is not needed.

Initial value: ./include

make outputs all temporary files to this directory.

This may be changed to accommodate the source tree. Therefore, avoid overwrite within Makefile in individual directories.

Specify this if you want to use your own link command file (.lcf).

Initial value: $NitroSDK/include/nitro/arm9.$(NITRO_PLATFORM).lcf

Specifies the source configuration file when automatically creating a link command file with the makelcf command.

Initial Value: Not Defined

Specifies the file describing ROM file contents. This file is passed to the makerom command and is a hint for ROM creation.

Specifies a target file with .srl format or .nef format.

It compiles or assembles the source files specified by SRCS, and links the resultant object files, making them the target files.

When .srl files are specified as the target, .nef files will be created automatically.

Specifies when you want to create a library file.

It compiles or assembles the source files specified by SRCS, and links the resultant object files, making them a library.

Normally TARGET_BIN and TARGET_LIB are not set at the same time.

Specifies when you want to create an object file as a target.

Normally this is not used very much. Use it for a library when you want to compile crt0.c and install it as a library.

This switches between generating code for the Main Processor and the Sub Processor. This is often specified in the Makefile.

ARM9	Code for Main Processor
ARM7	Code for Sub Processor

Initial value: ARM9 (Code for Main Processor)

All items with relative paths attached to TARGET_BIN and TARGET_LIB will be set automatically. The directories where .srl/.a files are stored will change according to NITRO_PLATFORM and NITRO_DEBUG/ NITRO_RELEASE/ NITRO_FINALROM settings. This macro was prepared to absorb this difference.

Enumerates the files you want to install. The TARGETS described above will function in this setting.

Initial value: None

Sets file installation target.

Initial value: None

If there are other include files, this specifies their directory.

If there are other library files, this enumerates their directory with LLIBRARY_DIRS, and the library files with LLIBRARIES.

When make clean or make clobber are executed, this specifies the files that will be erased with the object file. When using make clean, the files specified with LDIRT_CLEAN are erased; when using make clobber, the files specified with both LDIRT_CLEAN and LDIRT_CLOBBER are erased.