ETEC Release Details

V1.10A New Features
  • Improved optimizations (~5% code-size reduction)

  • Added -msgStyle=GNU option to the compiler. This causes warning & error messages to be output in GNU-style which is compatible with the default Eclipse CDT error parsers; this allows for click-on-problem-to-source-line capability.

  • Added -msgLimit=NUM option to the compiler to allow the number of warning/error messages to be limited. The default is 50 before output is suspended.

  • Added -ppOnly option to the compiler. Specifying this option forces the compiler to stop after only the pre-processing stage has been completed. If -out= has been specified the pre-processor output is directed there; otherwise it comes out on stdout.

  • Added -signedchar and -unsignedchar options to the compiler; the default is to treat the "char" type as unsigned.

  • more complete void* support

V1.20A, V1.20B. V1.20C New Features
  • Integrated a new tool in the ETEC compiler toolkit - ETEC_cpp.exe - that provides C preprocessing support. It can be used stand-alone if the user requires it, but typically is just run automatically by the C compiler (ETEC_cc.exe). This fixes several long-standing problems w/ regards to backslash line continuation and #/## macro processing. GNU cpp.exe is no longer used by any ASH WARE tool.

  • Provide a set of intrinsic functions that provide access to eTPU ALU/MDU hardware from C language constructs.  See the V1.11 Reference Manual (or later), or the standard header file eTpu_Lib.h, for details.

  • Support inline assembly with Freescale syntax.  The stand-alone ETEC Assembler also supports the existing (Freescale) assembly laguage syntax, and is now at beta release level.  With this new inline assembly capability, Freescale sets 3 and 4 have been successfully ported to compile under ETEC.

  • ETEC now provides the capability to compile with a global scratchpad programming model / calling convention via the compiler command option "-globalScratchpad".  In contrast to the default stack-based programming model, when local variables overrun the ability to be stored in registers, or when arguments are passed to functions, rather than be allocated to a dynamic stack, they are assigned static global addresses in the "scratchpad".  This is how legacy eTPU code generation tools worked, so in some cases this simplifies the porting process.  It can also result in slightly smaller & lower latency code in some cases, although it typically requires more data memory.  Note, however, that this option must be used carefully on dual eTPU systems, since if the same eTPU function is running simultaneously on both eTPU engines, and it uses scratchpad, there is the potential for a coherency issue as both eTPUs are pointing at the same scratchpad locations.

  • When the target is an eTPU2, there exists an engine scratchpad programming model / calling convention option via the command line argument "-engineScratchpad".  This provides the benefits of the the scratchpad model described above, but without the dual eTPU engine coherency conflict as now each eTPU engine has its own copy of scratchpad data in its engine relative address space.  Note that the global scratchpad model may be a better option even on the eTPU2, as the engine scratchpad code generation can be slightly less optimal is some cases, and it uses more overall data memory.

  • Users can declare variables to be allocated out of engine relative memory using the TR18037 named address space syntax on the eTPU2 target.  ETEC has added the keyword "_ENGINE" and "register _ENGINEBASE" (typedef'ed to register_engine_base) to support this capability.  "_ENGINE" function syntactically like a type qualifier.

  • The handling of named register variables has changed slightly with this release.  Named registers a, b, c, d, sr, diob, macl, and mach can be allocated by a user-declared variable, however, the compiler will still use diob (indirect memory access), macl and mach (if an MDU operation is specified), and b (if a stack operation is required) when required.  If the compiler uses diob or b in conflict with a user-defined named register variable, it issues warning regarding the conflict.  Named register variables are treated as global scope in the sense that named register variables are not saved and restored when a function call is made; this fact can be used to implicitly pass arguments to functions, but the technique is not recommended for general practice.

  • ETEC now allows name register qualifiers to be applied to function parameters, thus forcing the parameter to be passed via the specified register.  A significant amount of existing code in Freescale's sets 3 and 4 pass parameters using "registera".  ETEC now supports this, and parameter passing is not limited to "registera" - all other registers can be used although care must be taken and this is not a recommended technique.

  • The CC condition code register type now supports access to the "lower or same" (CC.LS) and the "less than" (CC.LT) condition tests.

V1.25A New Features
  • declaration of function pointers, and assignment to function pointer variables is now supported.  Calls via function pointers are still not supported.

  • struct, union and _Bool array (bit array) initializers are now fully supported.

  • given the thread-based nature of eTPU execution, ETEC now provides the concept of "no-return" function calls. Such functions are called fragments and are specified by using the special return type "_eTPU_fragment". Give the no-return functionality, _eTPU_fragment is essentially equivalent to the void type. When a call to a fragment is made, the compiler generates a jump opcode rather than a call opcode since no return ever occurs. Additionally, no state such as registers, stack frame, etc. is saved since execution cannot return to the caller, thereby saving unnecessary overhead. Fragments support passing parameters just like normal functions, and the calling conventions are the same except for the state save (on both caller and callee sides). Note that on the fragment (callee) side, there is also reduced state saving as non-volatile registers do not need to be saved, nor does the return address register. Internal to the function, fragments work just like any other C function - they can make calls, even to other fragments. Note that the compiler will attempt to detect stranded code that follows a call to a fragment, and issue a warning if it finds such code.

  • .map file output has been enhanced : global scratchpad variables are listed in a a new .globalscratchpad section, data stored in the engine-relative address space is listed in the .engine and .enginescratchpad segments (if any; eTPU2 only), and channel frame variable locations & channel frame sizes are included as well.

  • inline assembly supports symbolic access of engine-relative address space variables.

  • a new specialized version of the C switch statement that provides reduced thread length operation and in most cases reduced code size, at the cost of user control over state values and some of the robustness features of the standard C switch statement, has been implemented. The tradeoffs should be carefully considered before choosing to use this feature. This 'state switch', as it is referred to, makes efficient use of the eTPU architecture's dispatch instruction. The dispatch instruction allows a jump (or call) to the instruction at the address of the current program counter, plus a variable displacement which can be up to 255 instructions/opcodes. This feature is activated through two new keywords, _eTPU_state_switch and _eTPU_state_switch_enum.

  • the auto-defines file has been enhanced in the area of struct/union tag type data. Two pieces of size data are output - the sizeof() the tag type (includes any necessary padding), and a raw size that does not include padding. The alignment of the tag type, relative to a word (double-even) address is also now provided.

V1.25 Build B New Features (2009-October-18)
  • added -verbSuppress command line options that provide greater user control over ETEC tool output.

  • the worst case thread length (WCTL) is now calculated by the ETEC linker and output as part of the analysis file (*_ana.html).

  • added verification capabilities for ensuring that WCTL, code size, and memory usage meet required constraints. See the new #pragma verify_wctl, #pragma verify_code_size, and #pragma verify_memory_size pragmas.

V1.25 Build C New Features (2009-December-16)
  • added a warning when a constant address of incorrect alignment is detected.

  • improved the register allocation scheme within function with regards to local variables.

  • constructs such as "const int MY_CONST_VAL = 17;" no longer use parameter RAM storage unless they have to (e.g. if their address is referenced, or if they have extern storage class).

  • the auto-defines file has been enhanced to provide type information for all variables and structure members.  WARNING: the bit offset provided with bit-field members has been changed to be the offset within its containing unit, rather than the offset from the start of the structure!  This greatly improves the useability of the bit-field auto-define information, but may cause compatibility issues.  No further future changes are planned.

  • a beta-release feature called auto-struct has been added to the ETEC product.  Enabling auto-struct triggers the linker to output an auto-struct file, which consists of a set of data structures that can be used from the host-side to overlay the various memory sections in the eTPU data memory.  This allows direct read/write access of eTPU parameters from the host through a C struct reference.  At the very least it can improve the debugging experience by allowing direct viewing of eTPU data symbolically from most host debugging tools.  The feature is enabled through the "-autostruct" linker option.

  • the "-mode=ETPUC" compile option is no longer necessary (but it does no harm to continue using it).

V1.30A New Features (2010-Mar-26)
  • Support new software licensing mechanisms.  Besides the existing node-locked licensing scheme, network (floating) licenses and USB dongle-based licenses are now supported.

  • Added a -NetworkRetry command line option to the linker that allows a client computer to wait for a user-specified amount of time for a Network License to become available. If there is still no license available after the user-specified amount of time, then the linker runs in demo mode and will fail to link code that exceeds demo limitations.

V1.30B New Features (2010-Apr-15)
  • no functional changes

V1.30C New Features (2010-May-3)
  • no new features

V1.31A New Features (2010-Jun-15)
  • improved product documentation to include indexed PDF user and reference manuals.  These match the printed documentation that comes with the product (if so ordered).  ETEC and Simulator manuals are available from within the eTPU/eTPU2 Simulator's menu system.

  • for network licenses the ability to check-out a license for an extended period while out of network contact with the network license server has been added.  The check-out (and check-in if needed) is accomplished through command line options to the ETEC Linker (shown below).  The License Reference Manual should be consulted for further details.

    • -networkCheckout= : Attempts to checkout a network license until the specified date and time.  The HH field is in 24 hour time.  No linking is done; only the license checkout.

    • -networkCheckin : Returns a checked out license to the network license server; only needed if returning the license early.

V1.31B New Features (2010-Jul-12)
  • added ability to calculate WCTL (worst-case thread latency) on most MDU operations (previously had been limited to compiler-generated MDU operations)

  • added ability to calculate ability to force the WCTL for a particular thread or 'c' function.

  • added ability to calculate WCTL through simple loops by specifying a maximum loop traversal count.

  • further improvements in product documentation 

V1.31C New Features (2010-Aug-13)
  • overhauled the demo installation

V1.31E New Features (2010-Oct-13)
  • the default error handling library import can now be disabled and/or overriden in the linker through the use of the -ErrorLib- command option.

  • the -ImpDataEnd linker option allows import of .cod executable files that have their global ram allocation split between lower and upper global memory.

V1.31F New Features (2010-Dec-22)
  • bug fixes only (see bug list)

V2.00A New Features (2011-May-9)
  • significant optimization improvements. Users should see a code size decrease in the 5-15+% range, and at least an equivalent improvement in worst-case thread length (WCTL).

  • expand -lst and -map options in the linker to provide more flexible output options. List files can be output into their matching source file directories (-lstInSrc) or in a specified directory (-lst=). The map file can be output into a specified path and file name (-map=).

  • added a new pragma "same_chan_frame_base ". When this is specified for an eTPU function or class, it tells the compiler and optimizer that all channel changes within in the code are to channels that share the same channel frame base address (CPBA). This allows redundant read and write memory access reduction to work across chan register changes, thereby allowing more optimal code generation.

  • improved the global scratchpad warning so that it only warns on each function (eTPU, C, thread, etc.) that ends up using the global scratchpad. The warning comes from the linker rather than the compiler.

  • support the preload_p01() and preload_p23() intrinsics that control a thread's preload setting. In ETEC mode, this feature is supported with the new thread parameter's _eTPU_preload_low and _eTPU_preload_high. In general, this control should not be needed and it is best left to the compiler/linker to choose the best preload option.

  • added new pragmas "export_autodef_macro" and "export_autodef_text" that allow users to export eTPU source macros to the auto-defines file, or any user-defined text.

V2.00B New Features (2011-Jun-29)
  • Add new __multsXX(), __multuXX(), and __divuXX() intrinsic functions. These should be used when the user requires that the MDU perform the operation (otherwise in some cases the compiler may transform a mult/div operation to shifts/adds).

  • Improved path handling in the linker so that source files can be found for generating .lst files when the input object files are not in the current working directory.

  • The global error handler source is now included with the install, and its debug information is exported into executables. Additionally, a user error entry has been added. See the manuals for more details.

  • the installer has been modernized, although it retains a similar look and feel.

V2.01A New Features (2011-Dec-09)
  • Added linker option -elfgd.  When specified, the output ELF/DWARF file includes a segment for the global data.  This segment has RW attributes set and an alignment of 4 bytes.  The address is the relative SDM address (typically 0).

  • In ETEC mode, eTPU classes may now use the public and private keywords to allow users to set the visibility status of their channel frame variables.  By default, the contents of a class definition are public, so re-compiling existing code will not result in any changes.  Currently the visibility status only affects auto-generated host interface files - the "defines" file and the "auto-struct" file.  Channel frame variables with a private visibility setting will not show up in these host interface files.

V2.10B New Features (2012-May-23)
  • When using the eTPU-C programming paradigm, channel frame variables can be defined either by making them parameters of an eTPU-C function, or by declaring them as static variables inside the eTPU-C function scope.  In the past, all channel frame variables, whether declared via eTPU-C function parameter or via the static mechanism, were exported into the auto-defines file.  This continues to be the default.  However, via the use of "#pragma private_static_channel_frame" the static declared channel frame variables can be kept private from the auto-defines file.  The matching "#pragma public_static_channel_frame" can be used to switch the state back to the default within a single source file.

  • The ETPU_function #pragma has been extended to allow the entry table pin direction to be defined (for auto-defines export).  The enhanced syntax is: #pragma ETPU_function [, {standard | alternate}] [, {etpd_input | etpd_output}] [@ ];

  • Typecast to 32-bit integer (signed or unsigned) is now supported.  If the data type is signed, sign extension into the upper 8 bits will be performed.  Adding this explicit capability can allow for tighter code generation when converting a 24-bit (or smaller) int to 32-bits.

  • The auto-struct feature has been enhanced in that the PSE (24-bit access) area is now covered by 2 additional structure mappings - one for signed access and the other for unsigned.  This makes it easier to ensure on the host side that all unsigned PSE reads mask the upper 8-bits off after the read.  Additionally, auto-struct generation now is defaulted to on, but can be disabled with the "-autostruct-" linker option.

  • A new -msgPath option has been added to the compiler to allow the user to control whether filenames output in warning/error messages are shown as they are input (typically no or relative path) or with full absolute path.  Default is "as-is" (relative).  This option is independent of the message style.  Note that the GNU message style used to output absolute path by default but no longer does.

  • A new message style "DIAB" has been added.  It causes error/warning messages to be formatted in the style of the Diab (WindRiver) compiler.

  • Additional compiler optimization has been introduced.  One side effect of this is a DATA RAM write within an infinite loop (no possible exit) will be eliminated.  For instance, in the following example the DATA RAM write will be optimized away.

static int errorFlag;

while( 1 )


    errorFlag = 1;


The issue is that the optimizer does not see the write being active at the end of any thread and therefore eliminates it.  The solution is to modify the code by adding a volatile keyword to the variable, as follows.

volatile static int errorFlag;

while( 1 )


    errorFlag = 1;


  • Enhanced debug line number mapping improves single-stepping, breakpoints, etc.

V2.10C New Features (2012-May-25)
  • In order to avoid .lst file overwrites and ambiguity, the .lst file naming algorithm has been adjusted slightly.  Previously, and source file that generated opcodes would have a .lst file created and named by replacing its original file extension with .lst.  However, if both a .c and .h file (for example) with the same root file name generated code, then the .lst file of one would overwrite the other.  Now only .c files have their extension replaced by .lst when creating listing files.  For all other extensions, the full source file name has ".lst" appended to it when generating the .lst file, thereby preventing any naming conflicts.

V2.20A New Features (2013-Jan-03)
  • the generation of enum type data in the auto-defines file has been enhanced slightly.  Now all globally declared enum types are output to the auto-defines file, regardless of whether any global variables are declared to be of the enum type.  This allows the user, for example, to declare an enumeration for their HSR values and have it exported automatically into the auto-defines file, even though it is not otherwise used in the eTPU code.

  • anonymous tag types (enum, struct, union) are NOT exported in the global auto-defines section anymore.  This prevents potential conflicts that make the auto-defines file unuseable.  It is recommended that named tag types be used, or they be named via typedef.

V2.20B New Features (2013-Jan-16)
  • no new features

V2.21A New Features (2013-Sep-23)
  • none

V2.22A New Features (2013-Dec-03)
  • a new keyword "_eTPU_constant_table" has been implemented that allows the creation of 24-bit data constant lookup tables.  These tables live in code memory (SCM) rather than data memory (SDM), and so are of advantage in cases where more SCM is available than SDM.

V2.22B New Features (2013-Dec-15)
  • none

V2.23A New Features (2014-Feb-24)
  • none

V2.23B New Features (2014-Mar-12)
  • the NXP set 3/4 PWMF function has been updated to the latest version

V2.30A New Features (2014-Jun-16)
  • Add an improvement to the local variable register allocation technique.  Additional registers may be made available for local variables at inner scopes, if the scopes do not do operations that discount the register usage.  Note that this is only helpful when local variables are declared at inner scopes.  I.e. code can potentially be compiled to a more optimal binary executable if the software developer declares temporary variables only at the scope it is needed, and not above.

  • New compiler optimization that allows local variables to re-use registers when they do not overlap in any way.

  • Provide better support for the u/U and l/L integer constant suffixes.

  • Support all testable channel flags in the condition code (CC) struct (e.g. FM0, FM1).

  • Support capability to alias any type to the channel frame, not just via a pointer. So a declaration like "struct PPA_ChannelParameters register_chan_base *PPA_this;" can instead look like "struct PPA_ChannelParameters register_chan_base PPA_chan_frame;", allowing the code to reference parameters via the '.' operator than the '->' in function calls.

  • Support assigning a type when using named registers to pass parameters

  • Support passing a 32-bit argument through named register p31_0

V2.30B New Features (2014-Jul-11)
  • Clean up pathing.  Include file paths are search paths are relative to the source file directory, not the current working directory.

V2.30C New Features (2014-Sep-07)
  • in ETpu_Lib.h the prototypes for the error handling library code have been updated to properly reflect how they actually work, and to address a small issue. The handlers "_Error_handler_entry" and "_Error_handler_unexpected_thread" are now set with matches disabled during thread. This is primarily of important for the latter handler, wherein it may be handling an unexpected link and yet a match is perfectly valid for the channel and should not get cleared.  The handlers "_Error_handler_scm_off_weeds" and "_Error_handler_fill_weeds" have been changed to fragments (_eTPU_fragment) to reflect the fact that they are called and are not directly referenced in entry tables. 

V2.30D New Features (2014-Oct-02)
  • no changes

V2.40A New Features (2015-Jun-24)
  • no changes

V2.40C New Features (2015-Aug-03)
  • no changes

V2.40E New Features (2015-Sep-02)
  • disable a C Preprocessor (ETEC_cpp.exe)  warning that really wasn't necessary.  No more warnings about finding unknown preprocessor directives in source disabled via #if/#ifdef conditional compilation.  Note that since the simulator / DevTool uses the C Preprocessor, this change applies to script/vector file processing as well.

  • add a new search mode option to the compiler (ETEC_cc.exe) called -IMode.  It allows the user to specify that any search paths provided by the -I option should be relative to the current working directory, rather than the default of relative to the source file under compilation directory.

  • The keepout macro name in the auto-defines file has been changed to only be based on the auto-defines file output name.  If the auto-defines name is Filename.h, then the keepout macro will be __Filename_H.

V2.41A New Features (2015-Sep-20)
  • no changes

V2.41B New Features (2015-Oct-07)
  • no changes

V2.41C New Features (2015-Nov-01)
  • The auto-struct output capability has been enhanced to support the global mnemonic (linker option -gm), in order to allow multiple auto-struct files to coexist, and the initialized data macro names have been updated to be more standards compliant when a global mnemonic has been applied.  In both cases, output is unchanged unless a global mnemonic (linker option -gm) has been specified. 

V2.42A New Features (2016-Jan-05)
  • no changes

V2.42J New Features (2016-Jun-22)
  • no changes

V2.43G New Features (2017-Jan-11)
  • no changes

V2.43H New Features (2017-Feb-02)
  • no changes

V2.44A New Features (2017-May-2)
  • no changes

V2.50A New Features (2018-Jan-1)
  • an explicit locating mechanism has been added for global variables.  The primary purpose of this is to allow large data items or buffers to be placed at the end of memory, beyond the 1K default global area, yet still be accessed directly and as efficiently as possible.

V2.60C New Features (2018-Aug-13)
  • none

V2.61A New Features (2019-Mar-06)
  • none

V2.62A New Features (2020-Jan-16)
  • added ability to access public class data members from other classes or the global scope

  • class data members (channel variables) can now be provided initial values that flow into the initialized data support generated at link time

  • some specialty registers can now be specified as general purpose and thus available to the compiler to generate more optimal code.  This is done via the -setreggp= compiler option.  The registers to which this applies are TRR, TPR (16 bit), TCR1 and TCR2.

  • new host interface macros ::ETPUenginebase_a/b and ::ETPUstackbase_a/b have been added to allow for export of important base address information for use by host code.

  • the inline function handling by the compiler has been improved significantly, although inlining will not occur under all circumstances, e.g. if the inline-designated function contains inline assembly.

V2.62C New Features (2020-Mar-14)
  • new host interface macro ::ETPUstacksize has been added, to allow export of the maximum stack size necessary (always equates to 0 if the stack programming model is not used).

  • new host interface macro ::ETPUfunctionstackbase( or ) has been added, which provides the channel frame offset to the stack frame base address variable.  If the function in question does not use the stack, an invalid offset of 0xFFFF is output.

V2.62D New Features (2020-Jul-14)
  • no new features

V2.62E New Features (2020-Dec-16)
  • explicitly support the C99 fixed width types int8_t, int16_t, int24_t, int32_t, uint8_t, uint16_t, uint24_t, uint32_t, fract8_t, fract16_t, fract24_t, ufract8_t, ufract16_t, ufract24

V2.63A New Features (2021-Mar-17)
  • no new features

V2.63B New Features (2021-Sep-17)
  • update the -ErrorLib- (disable default error handling library) ETEC linker option to output a minimal code image if no user defined fill opcode, unused entry thread handler, or unused code memory handler are defined.  This results in a smaller array of opcodes in the output <>_scm.h file, or user-defined file output via the #pragma write facility, which is in some cases useful.

V3.00A New Features (2022-Jan-13)
  • major optimization enhancements - in some cases ETEC now generates executable code over 20% smaller and faster than competing tools.

  • a new option has been added to the compiler called "-passParamByReg".  It overrides the default scratchpad calling convention of passing all function call parameters via scratchpad memory, and instead passes as many as possible via register.  The register selection algorithm is the same as that used by the stack programming model, which means up to 3 parameters can be passed by register.

  • for completeness, the assembler now supports the -i= and -d= command line options.

V3.01A New Features (2022-Nov-21)
  • add the -fractFullPrec option to the compiler to enable full precision multiplication of signed fractional data. The historical behavior has been to truncate the LSB (faster).

  • add a new capability to auto-generate templates of host API code for all eTPU functions in a build, enabled by the new -awac linker option.  See the new AutoCode demo for an example of how this works.

  • change performance, scratchpad and stack messages have been changed from warning-level to informational-level, as that much better categorizes what they are. They can still be individually disabled per message type, or the entire class of informational messages can be suppressed.

  • the linker now supports the capability to combine two independent sets of code each with their own entry table into one final image.  The need for this is rare, but useful in the case where independent development teams each have control of one eTPU engine, one A and the other B.

  • the -ErrorFill- linker option has been added to support the case where the user wants to use an error handler (default or custom), but does not want the unused portions of SCM to be filled with error-handling data.

  • add the -endian=<mode> option to the ETEC linker to support enhancements to the auto-generated host code for the new S32K39x parts, in which the Arm Cortex-M7 cores are little-endian.  This new option can simplify support of eTPU API code across all target types.

ASH2 Logo.png