Readme for C2000 Code Generation Tools v25.11.1.LTS

Table of Contents

LTS Release

The C2000 CGT v25.11.x.LTS release is an LTS release.

Definitions

Compiler Downloads and Documentation

Documentation for the “TI C2000 Optimizing Compiler User’s Guide” and the “TI C2000 Assembly Language User’s Guide” is available online at:

https://www.ti.com/tool/C2000-CGT

TI E2E Community

Questions concerning TI Code Generation Tools can be posted to the TI E2E Community forums at:

The following is the top-level webpage for all of TI’s Code Generation Tools.

If submitting a defect report, please attach a scaled-down test case with command-line options and the compiler version number to allow us to reproduce the issue easily.

Defect Tracking Database

Compiler defect reports can be tracked at the Development Tools bug database at:

https://sir.ext.ti.com/

What’s New - Features Added in 25.11.0.LTS Release:

EABI is now enabled by default

The default ABI is now EABI with –abi=eabi instead of –abi=coffabi.

For more details about COFF vs EABI, please see below:
https://software-dl.ti.com/ccs/esd/documents/C2000_c28x_migration_from_coff_to_eabi.html

Performance improvements C28


Improvements in modulo/division operations for 32-bit integers
The existing support for optimizations for modulo/division operations for 16-bit integers has been extended for 32-bit integers. The optimization requires --opt_level=0 or higher and --opt_for_speed=3 (-mf3) or higher.

For example, below expression:

    if (int32_var % 3)

generates below call to an RTS library routine with -o0 -mf2:

    MOVB      ACC,#3
    MOVL      *-SP[2],ACC
    MOVL      ACC,XAR0
    FFC       XAR7,#L$MOD
    TEST      ACC
    B         $C$L3,EQ

and will instead be optimized to below with -o0 -mf3:

    MOV       T,#31    
    MOVL      XAR4,XAR2
    ASRL      ACC,T    
    MOVL      XAR7,ACC 
    MOV       AL,#43691
    MOV       AH,#10922
    MOVL      XT,ACC   
    IMPYL     P,XT,XAR4
    SPM       #1         
    QMPYL     ACC,XT,XAR4
    MOV       T,#31     
    ASR64     ACC:P,T  
    SUBUL     P,XAR7  
    MOVL      ACC,P  
    ADDL      ACC,P << PM
    MOVL      XT,ACC    
    MOVL      ACC,XAR4 
    SUBL      ACC,XT  
    B         $C$L3,EQ


Improvements in use of MIN/MAX and CMP instructions to avoid branches:
Extended the current C28 support for optimizing if/else to MAX/MIN instructions for float to also optimize for integers. This optimization applies to both variable and constant values for min and max.

    if (sum > max) sum = max;
    if (sum < min) sum = min;

NOTE: ternary operator was already optimized for both floats and integers.

Improvements were also implemented to optimize the following saturation idioms for floats and integers, eliminating the redundant else branches:"

  if (sum > max)      sum = max;
  else if (sum < min) sum = min;
Or this case:
  if (sum > max)      out = max;
  else if (sum < min) out = min;
       else           out = sum;

Note: This optimization works by default for constant max/min values. However, for variable min/max, the optimization is only performed when the –sat_var_opt option is set to “on”:

  --sat_var_opt=on,off

Crucial Note: Users must explicitly enable (opt-in) this variable min/max optimization because it alters the C code’s behavior if the variable min’s value exceeds the variable max’s value.


New C28 saturation intrinsics: 

int  = __add_sat(int, int);       16bit addition with saturation
int  = __sub_sat(int, int);       16bit subtraction with saturation
long = __addl_sat(long, long);    32bit addition with saturation
long = __subl_sat(long, long);    32bit subtraction with saturation
long = __satlow16_fast(long);     faster implementation of __satlow16(long)

See Compiler User Guide spru514 pdf Table 7-6 for more details on each of above.

LFU improvements


Option –lfu_default has new setting “all”
Option –lfu_default has new setting “all” in addition to “preserve” and “none” where “all” specifies to treat: existing variables without attribute(preserve) as lfu-“preserve” and new variables without attribute(update) as lfu-“update”.

New default behavior:

when no option is specified, default is "all" instead of only "preserve"  
--lfu_default           no argument means default-"all" 
--lfu_default=all       do both default-"preserve" and default-"update"
--lfu_default=preserve  only default-"preserve" (no default-"update")
--lfu_default=none      do not do any default-"preserve" or default-"update"


Warning for LFU attributes with const globals/statics
The following warnings are now emitted when lfu attributes update or preserve are used with const global/static variables:

warning #30025-D: Const variable "gvar_const" has attribute(preserve) and
will be placed into section .TI.bound at the same address as the reference 
executable which may not be what was intended for const data.

warning #30025-D: Const variable "svar_arr_const" has attribute(update) and
will be placed into section .TI.update which may not be what was intended for
const data.


Warning for linker command files for .TI.update section
The following warnings are now emitted when an LFU link includes a linker command file that does not have an explicit entry for output section .TI.update, or if the .TI.update section has type=NOINIT:

Warning #10504-D: ".TI.update" section used for __attribute__((update))
requires an explicit SECTIONS specification entry for ".TI.update" to
ensure expected lfu warm start behavior.

warning #10505-D: ".TI.update" section cannot be type=NOINIT for lfu use
with __attribute__(update).


Warning for LFU attribute(update) for existing variables
The following warning is now emitted when a variable with attribute(update) was found to be in the reference executable:

warning #30024-D: Variable "gvar" with attribute update already has an
entry in the reference executable's symbol table. It will be placed in
the .TI.update section instead of preserving at the same address as in
the reference executable.


Warning for LFU attribute(preserve) with a new variable
The following warning is now emitted when lfu attribute(preserve) is used on a variable that was not in the reference executable:

warning #30023-D: Variable "gvar" with attribute(preserve) has no entry
in the the reference executable's symbol table and therefore cannot be
preserved. Remove attribute(preserve).

Hex utility warning for --binary without --image

Below warning is now emitted when the hex utility tool is used with output format –binary and does not also include –image or a ROM directive which are required in order to preserve any holes in memory. const global/static variables:

warning: Output format option --binary requires --image and a ROMS directive to avoid ignoring holes in memory.

Enabled support for attribute((constructor(priority))

The optional priority input to the constructor attribute is now supported.

__attribute__((constructor(102))) void func() { ...

If the –xml_link_info=file option is specified on the linker command line, then an XML representation of the link information will be generated into the specified file. This linker-generated XML link information file will now contain a string representation of the linker command line used to invoke the linker.

Example

If we compile and link a simple program as follows:

%> cl2000 hello.c -z -llnk.cmd --xml_link_info=hello.xml -mhello.map

Then the “hello.xml” file will contain a command-line XML tag like the following:

  <?xml version="1.0" encoding="ISO-8859-1" ?>
  <link_info>
    <banner>TMS320C2000 Linker Unix v25.11.0.LTS (a0196512 - Nov 13 2025)</banner>
    <copyright>Copyright (c) 1996-2025 Texas Instruments Incorporated</copyright>
    <command_line>lnk2000 --tm_feedback=/tmp/TIJepouSAsB -c --buffer_diagnostics --float_support=softlib hello.obj --ecc=off --library=lnk.cmd --xml_link_info=hello.xml --map_file=hello.map</command_line>
    ...
  </link_info>

Linker Command File Size-Based align(power2) Operator

The linker now supports a new variant of the align operator, align(power2), that can be applied to an output section specification to effect an alignment of the output section to the next power-of-2, such that the selected power-of-2 is greater than or equal to the size of the output section’s contents.

Example

Consider a simple function to be defined in a user-named section called “.myscn”:

#include <stdio.h>
__attribute__((section(".myscn")))
void myfcn(void) {
    printf("hello\n");
}

The output section in which “.myscn” will be placed could be specified as follows:

SECTIONS
{
    ...
    .myscn: { myfile.o(.myscn) } align(power2) > MEM
    ...
}

When the link is performed, the linker will use the size of the “.myscn” output section to determine the alignment to apply in order to determine where in the MEM region the output section is to be allocated. Let’s suppose that the “.myscn” output section contains not only the definition of myfcn(), but also a linker-generated 8-byte trampoline to enable myfcn() to reach printf() in the event that printf() is placed out of range from myfcn():

.myscn     0    000012c0    00000018
                000012c0    00000010     tryme.o (.myscn)
                000012d0    00000008     libc.a : printf.c.obj (.tramp.printf.1)

The content of the “.myscn” output section adds up to 24 bytes, and so the align(power2) operator will force the “.myscn” output section to be allocated to a 32-byte boundary within the MEM region.

Resolved defects

Resolved defects in v25.11.1.LTS:

ID Summary
CODEGEN-15488 QKIT: setting COVFILELIST in CCS IDE for coverage compare needs workaround
CODEGEN-15061 Compiler fails to add extra delay slot between DIVF32 at end of function and ‘MOV32 ACC,R0H’ at the start of a called function
CODEGEN-15018 Linker crashes while processing local common symbols
CODEGEN-14868 C2000Ware source using inconsistent type definitions has parser errors after fix for EXT_EP-12834 in 22.6.3.LTS and 25.11.0.LTS
CODEGEN-14803 C28 64-bit integer multiply with post-increment incorrectly increments pointer too much
CODEGEN-11171 C2000: Compiler manual mistakenly states global and static variables go in the .econst section

Known defects (dynamic)

The following link will lead to an updated list of known defects in this release:

Known defects – dynamic