As of 1 September 2005, Byte Craft Limited's corporate address will be:

The ::ETPUmisc host interface macro can now optionally accept a parameter in parentheses. If given, ::ETPUmisc expands to the MISC checkword for the program from offset 0 to the given offset, rounded up to the nearest 32-bit program word. For instance:

::ETPUmisc(::ETPUmaxrom)

generates a MISC value for only the generated program (including constants).

::ETPUtype returns enhanced host information about the type of variables.

If the variable given as a parameter to ::ETPUtype is a simple variable, the macro expands to that macro type. If the variable is an array, structure member, or union member, ::ETPUtype expands to a C macro call, one of:

__etpu_struct_data() //for structure members

__etpu_struct_array() //for arrays

__etpu_struct_packed_int() //for integer bit fields

The eTPU_C compiler implements improved branch chaining: e.g.,

 jcc to jmp
jmp to jmp
jmp to end 

The compiler previously expanded ::ETPUcode32 to an image that was, on occasion, one byte too long. This bug has been fixed.

Constant divides that referenced a register other than the Accumulator were improperly generated. This bug has been fixed.

#pragma fill has been permanently enabled.

Similar to #pragma option FILLROM, #pragma option FILLROMWORD writes a default value to unused program ROM. Its value is a 32-bit integer, and it writes this value to unused 4-byte program words (on 32-bit boundaries). If both are specified in a program #pragma option FILLROMWORD takes precedence.

ELF file generation has been enhanced:

#pragma ETPU_function name [, standard|alternate] [, LOCAL_LIMIT = local_ram_size] [@ function_number];

The #pragma ETPU_function directive has an added parameter, LOCAL_LIMIT. This allows you to specify the maximum LOCAL memory to be allocated to the ETPU_function. If the compiled code uses more than this amount of local RAM, the compiler issues an error.

The environment block of the .COD file now includes the actual ETPU_function local RAM allocation for each ETPU_function. The environment block entry is as follows:

<location> <message-id>  LOCAL_RAM  <size in bytes> <RAM/SPRAM>

This is an example environment block entry:

0000 0238     e       LOCAL_RAM    24 RAM

This information also appears in the new listing file reports, below.

The eTPU_C compiler now issues some new reports in the listing file.

After every entry table report (describing the channel conditions for the thread), the compiler will identify the total local RAM memory used.

ssss          Thread Local RAM size

This reports the amount of RAM, used by automatic variables, declared within the thread.

At the end of each ETPU_function, the compiler identifies the total local RAM used by the function (again, for automatic variables).

hhhh          Local RAM requirements for ETPU_function name

After every ETPU_function, the local RAM used is compared to the LOCAL_LIMIT declared in the #pragma ETPU_function directive. If the limit has been exceeded, an error is generated:

User Error Local RAM requirements for name exceeds LOCAL_LIMIT declaration

At the end of the listing file, eTPU_C appends a report about RAM usage by each ETPU_function:

 eTPU FUNCTION SUMMARY 
  3         xyz  0200  0288  (34 words)  SRAM =   24  Local RAM =   32   4         uvw  0288  02CC  (17 words)  SRAM =   24  Local RAM =   24 

The report describes each ETPU_function, by number and name:

The following intrinsic is new:

eTPU_C offers full support for eTPU macro assembly. See the documentation for details.