SPRU514Z July   2001  – October 2023 SM320F28335-EP

 

  1.   1
  2.   Read This First
    1.     About This Manual
    2.     Notational Conventions
    3.     Related Documentation
    4.     Related Documentation From Texas Instruments
    5.     Trademarks
  3. 1 Introduction to the Software Development Tools
    1. 1.1 Software Development Tools Overview
    2. 1.2 Compiler Interface
    3. 1.3 ANSI/ISO Standard
    4. 1.4 Output Files
    5. 1.5 Utilities
  4. 2 Using the C/C++ Compiler
    1. 2.1  About the Compiler
    2. 2.2  Invoking the C/C++ Compiler
    3. 2.3  Changing the Compiler's Behavior with Options
      1. 2.3.1  Linker Options
      2. 2.3.2  Frequently Used Options
      3. 2.3.3  Miscellaneous Useful Options
      4. 2.3.4  Run-Time Model Options
      5. 2.3.5  Symbolic Debugging and Profiling Options
      6. 2.3.6  Specifying Filenames
      7. 2.3.7  Changing How the Compiler Interprets Filenames
      8. 2.3.8  Changing How the Compiler Processes C Files
      9. 2.3.9  Changing How the Compiler Interprets and Names Extensions
      10. 2.3.10 Specifying Directories
      11. 2.3.11 Assembler Options
      12. 2.3.12 Deprecated Options
    4. 2.4  Controlling the Compiler Through Environment Variables
      1. 2.4.1 Setting Default Compiler Options (C2000_C_OPTION)
      2. 2.4.2 Naming One or More Alternate Directories (C2000_C_DIR)
    5. 2.5  Controlling the Preprocessor
      1. 2.5.1  Predefined Macro Names
      2. 2.5.2  The Search Path for #include Files
        1. 2.5.2.1 Adding a Directory to the #include File Search Path (--include_path Option)
      3. 2.5.3  Support for the #warning and #warn Directives
      4. 2.5.4  Generating a Preprocessed Listing File (--preproc_only Option)
      5. 2.5.5  Continuing Compilation After Preprocessing (--preproc_with_compile Option)
      6. 2.5.6  Generating a Preprocessed Listing File with Comments (--preproc_with_comment Option)
      7. 2.5.7  Generating Preprocessed Listing with Line-Control Details (--preproc_with_line Option)
      8. 2.5.8  Generating Preprocessed Output for a Make Utility (--preproc_dependency Option)
      9. 2.5.9  Generating a List of Files Included with #include (--preproc_includes Option)
      10. 2.5.10 Generating a List of Macros in a File (--preproc_macros Option)
    6. 2.6  Passing Arguments to main()
    7. 2.7  Understanding Diagnostic Messages
      1. 2.7.1 Controlling Diagnostic Messages
      2. 2.7.2 How You Can Use Diagnostic Suppression Options
    8. 2.8  Other Messages
    9. 2.9  Generating Cross-Reference Listing Information (--gen_cross_reference_listing Option)
    10. 2.10 Generating a Raw Listing File (--gen_preprocessor_listing Option)
    11. 2.11 Using Inline Function Expansion
      1. 2.11.1 Inlining Intrinsic Operators
      2. 2.11.2 Inlining Restrictions
      3. 2.11.3 Unguarded Definition-Controlled Inlining
        1. 2.11.3.1 Using the Inline Keyword
      4. 2.11.4 Guarded Inlining and the _INLINE Preprocessor Symbol
        1. 2.11.4.1 Header File string.h
        2. 2.11.4.2 Library Definition File
    12. 2.12 Using Interlist
    13. 2.13 About the Application Binary Interface
    14. 2.14 Enabling Entry Hook and Exit Hook Functions
    15. 2.15 Live Firmware Update (LFU)
  5. 3 Optimizing Your Code
    1. 3.1  Invoking Optimization
    2. 3.2  Controlling Code Size Versus Speed
    3. 3.3  Performing File-Level Optimization (--opt_level=3 option)
      1. 3.3.1 Creating an Optimization Information File (--gen_opt_info Option)
    4. 3.4  Program-Level Optimization (--program_level_compile and --opt_level=3 options)
      1. 3.4.1 Controlling Program-Level Optimization (--call_assumptions Option)
      2. 3.4.2 Optimization Considerations When Mixing C/C++ and Assembly
    5. 3.5  Automatic Inline Expansion (--auto_inline Option)
    6. 3.6  Link-Time Optimization (--opt_level=4 Option)
      1. 3.6.1 Option Handling
      2. 3.6.2 Incompatible Types
    7. 3.7  Using Feedback Directed Optimization
      1. 3.7.1 Feedback Directed Optimization
        1. 3.7.1.1 Phase 1 -- Collect Program Profile Information
        2. 3.7.1.2 Phase 2 -- Use Application Profile Information for Optimization
        3. 3.7.1.3 Generating and Using Profile Information
        4. 3.7.1.4 Example Use of Feedback Directed Optimization
        5. 3.7.1.5 The .ppdata Section
        6. 3.7.1.6 Feedback Directed Optimization and Code Size Tune
        7. 3.7.1.7 Instrumented Program Execution Overhead
        8. 3.7.1.8 Invalid Profile Data
      2. 3.7.2 Profile Data Decoder
      3. 3.7.3 Feedback Directed Optimization API
      4. 3.7.4 Feedback Directed Optimization Summary
    8. 3.8  Using Profile Information to Analyze Code Coverage
      1. 3.8.1 Code Coverage
        1. 3.8.1.1 Phase1 -- Collect Program Profile Information
        2. 3.8.1.2 Phase 2 -- Generate Code Coverage Reports
      2. 3.8.2 Related Features and Capabilities
        1. 3.8.2.1 Path Profiler
        2. 3.8.2.2 Analysis Options
        3. 3.8.2.3 Environment Variables
    9. 3.9  Special Considerations When Using Optimization
      1. 3.9.1 Use Caution With asm Statements in Optimized Code
      2. 3.9.2 Use the Volatile Keyword for Necessary Memory Accesses
        1. 3.9.2.1 Use Caution When Accessing Aliased Variables
        2. 3.9.2.2 Use the --aliased_variables Option to Indicate That the Following Technique Is Used
        3. 3.9.2.3 On FPU Targets Only: Use restrict Keyword to Indicate That Pointers Are Not Aliased
          1. 3.9.2.3.1 Use of the restrict Type Qualifier With Pointers
          2. 3.9.2.3.2 Use of the restrict Type Qualifier With Pointers
    10. 3.10 Using the Interlist Feature With Optimization
    11. 3.11 Data Page (DP) Pointer Load Optimization
    12. 3.12 Debugging and Profiling Optimized Code
      1. 3.12.1 Profiling Optimized Code
    13. 3.13 Increasing Code-Size Optimizations (--opt_for_space Option)
    14. 3.14 Compiler Support for Re-Entrant VCU Code
    15. 3.15 Compiler Support for Generating DMAC Instructions
      1. 3.15.1 Automatic Generation of DMAC Instructions
      2. 3.15.2 Assertions to Specify Data Address Alignment
      3. 3.15.3 __dmac Intrinsic
    16. 3.16 What Kind of Optimization Is Being Performed?
      1. 3.16.1  Cost-Based Register Allocation
      2. 3.16.2  Alias Disambiguation
      3. 3.16.3  Branch Optimizations and Control-Flow Simplification
      4. 3.16.4  Data Flow Optimizations
      5. 3.16.5  Expression Simplification
      6. 3.16.6  Inline Expansion of Functions
      7. 3.16.7  Function Symbol Aliasing
      8. 3.16.8  Induction Variables and Strength Reduction
      9. 3.16.9  Loop-Invariant Code Motion
      10. 3.16.10 Loop Rotation
      11. 3.16.11 Instruction Scheduling
      12. 3.16.12 Register Variables
      13. 3.16.13 Register Tracking/Targeting
      14. 3.16.14 Tail Merging
      15. 3.16.15 Autoincrement Addressing
      16. 3.16.16 Removing Comparisons to Zero
      17. 3.16.17 RPTB Generation (for FPU Targets Only)
  6. 4 Linking C/C++ Code
    1. 4.1 Invoking the Linker Through the Compiler (-z Option)
      1. 4.1.1 Invoking the Linker Separately
      2. 4.1.2 Invoking the Linker as Part of the Compile Step
      3. 4.1.3 Disabling the Linker (--compile_only Compiler Option)
    2. 4.2 Linker Code Optimizations
      1. 4.2.1 Generating Function Subsections (--gen_func_subsections Compiler Option)
      2. 4.2.2 Generating Aggregate Data Subsections (--gen_data_subsections Compiler Option)
    3. 4.3 Controlling the Linking Process
      1. 4.3.1 Including the Run-Time-Support Library
        1. 4.3.1.1 Automatic Run-Time-Support Library Selection
          1. 4.3.1.1.1 Using the --issue_remarks Option
        2. 4.3.1.2 Manual Run-Time-Support Library Selection
        3. 4.3.1.3 Library Order for Searching for Symbols
      2. 4.3.2 Run-Time Initialization
      3. 4.3.3 Initialization by the Interrupt Vector
      4. 4.3.4 Global Object Constructors
      5. 4.3.5 Specifying the Type of Global Variable Initialization
      6. 4.3.6 Specifying Where to Allocate Sections in Memory
      7. 4.3.7 A Sample Linker Command File
    4. 4.4 Linking C28x and C2XLP Code
  7. 5 Post-Link Optimizer
    1. 5.1 The Post-Link Optimizer’s Role in the Software Development Flow
    2. 5.2 Removing Redundant DP Loads
    3. 5.3 Tracking DP Values Across Branches
    4. 5.4 Tracking DP Values Across Function Calls
    5. 5.5 Other Post-Link Optimizations
    6. 5.6 Controlling Post-Link Optimizations
      1. 5.6.1 Excluding Files (-ex Option)
      2. 5.6.2 Controlling Post-Link Optimization Within an Assembly File
      3. 5.6.3 Retaining Post-Link Optimizer Output (--keep_asm Option)
      4. 5.6.4 Disable Optimization Across Function Calls (-nf Option )
      5. 5.6.5 Annotating Assembly with Advice (--plink_advice_only option)
    7. 5.7 Restrictions on Using the Post-Link Optimizer
    8. 5.8 Naming the Outfile (--output_file Option)
  8. 6 C/C++ Language Implementation
    1. 6.1  Characteristics of TMS320C28x C
      1. 6.1.1 Implementation-Defined Behavior
    2. 6.2  Characteristics of TMS320C28x C++
    3. 6.3  Data Types
      1. 6.3.1 Size of Enum Types
      2. 6.3.2 Support for 64-Bit Integers
      3. 6.3.3 C28x double and long double Floating-Point Types
    4. 6.4  File Encodings and Character Sets
    5. 6.5  Keywords
      1. 6.5.1 The const Keyword
      2. 6.5.2 The __cregister Keyword
      3. 6.5.3 The __interrupt Keyword
      4. 6.5.4 The restrict Keyword
      5. 6.5.5 The volatile Keyword
    6. 6.6  C++ Exception Handling
    7. 6.7  Register Variables and Parameters
    8. 6.8  The __asm Statement
    9. 6.9  Pragma Directives
      1. 6.9.1  The CALLS Pragma
      2. 6.9.2  The CLINK Pragma
      3. 6.9.3  The CODE_ALIGN Pragma
      4. 6.9.4  The CODE_SECTION Pragma
      5. 6.9.5  The DATA_ALIGN Pragma
      6. 6.9.6  The DATA_SECTION Pragma
        1. 6.9.6.1 Using the DATA_SECTION Pragma C Source File
        2. 6.9.6.2 Using the DATA_SECTION Pragma C++ Source File
        3. 6.9.6.3 Using the DATA_SECTION Pragma Assembly Source File
      7. 6.9.7  The Diagnostic Message Pragmas
      8. 6.9.8  The FAST_FUNC_CALL Pragma
      9. 6.9.9  The FORCEINLINE Pragma
      10. 6.9.10 The FORCEINLINE_RECURSIVE Pragma
      11. 6.9.11 The FUNC_ALWAYS_INLINE Pragma
      12. 6.9.12 The FUNC_CANNOT_INLINE Pragma
      13. 6.9.13 The FUNC_EXT_CALLED Pragma
      14. 6.9.14 The FUNCTION_OPTIONS Pragma
      15. 6.9.15 The INTERRUPT Pragma
      16. 6.9.16 The LOCATION Pragma
      17. 6.9.17 The MUST_ITERATE Pragma
        1. 6.9.17.1 The MUST_ITERATE Pragma Syntax
        2. 6.9.17.2 Using MUST_ITERATE to Expand Compiler Knowledge of Loops
      18. 6.9.18 The NOINIT and PERSISTENT Pragmas
      19. 6.9.19 The NOINLINE Pragma
      20. 6.9.20 The NO_HOOKS Pragma
      21. 6.9.21 The once Pragma
      22. 6.9.22 The RETAIN Pragma
      23. 6.9.23 The SET_CODE_SECTION and SET_DATA_SECTION Pragmas
      24. 6.9.24 The UNROLL Pragma
      25. 6.9.25 The WEAK Pragma
    10. 6.10 The _Pragma Operator
    11. 6.11 Application Binary Interface
    12. 6.12 Object File Symbol Naming Conventions (Linknames)
    13. 6.13 Initializing Static and Global Variables in COFF ABI Mode
      1. 6.13.1 Initializing Static and Global Variables With the Linker
      2. 6.13.2 Initializing Static and Global Variables With the const Type Qualifier
    14. 6.14 Changing the ANSI/ISO C/C++ Language Mode
      1. 6.14.1 C99 Support (--c99)
      2. 6.14.2 C11 Support (--c11)
      3. 6.14.3 Strict ANSI Mode and Relaxed ANSI Mode (--strict_ansi and --relaxed_ansi)
    15. 6.15 GNU and Clang Language Extensions
      1. 6.15.1 Extensions
      2. 6.15.2 Function Attributes
      3. 6.15.3 For Loop Attributes
      4. 6.15.4 Variable Attributes
      5. 6.15.5 Type Attributes
      6. 6.15.6 Built-In Functions
      7. 6.15.7 Using the Byte Peripheral Type Attribute
    16. 6.16 Compiler Limits
  9. 7 Run-Time Environment
    1. 7.1  Memory Model
      1. 7.1.1 Sections
      2. 7.1.2 C/C++ System Stack
      3. 7.1.3 Allocating .econst to Program Memory
      4. 7.1.4 Dynamic Memory Allocation
      5. 7.1.5 Initialization of Variables
      6. 7.1.6 Allocating Memory for Static and Global Variables
      7. 7.1.7 Field/Structure Alignment
      8. 7.1.8 Character String Constants
    2. 7.2  Register Conventions
      1. 7.2.1 TMS320C28x Register Use and Preservation
      2. 7.2.2 Status Registers
    3. 7.3  Function Structure and Calling Conventions
      1. 7.3.1 How a Function Makes a Call
      2. 7.3.2 How a Called Function Responds
      3. 7.3.3 Special Case for a Called Function (Large Frames)
      4. 7.3.4 Accessing Arguments and Local Variables
      5. 7.3.5 Allocating the Frame and Accessing 32-Bit Values in Memory
    4. 7.4  Accessing Linker Symbols in C and C++
    5. 7.5  Interfacing C and C++ With Assembly Language
      1. 7.5.1 Using Assembly Language Modules With C/C++ Code
      2. 7.5.2 Accessing Assembly Language Functions From C/C++
        1. 7.5.2.1 Calling an Assembly Language Function From a C/C++ Program
        2. 7.5.2.2 Assembly Language Program Called by
        3.       261
      3. 7.5.3 Accessing Assembly Language Variables From C/C++
        1. 7.5.3.1 Accessing Assembly Language Global Variables
          1. 7.5.3.1.1 Assembly Language Variable Program
          2. 7.5.3.1.2 C Program to Access Assembly Language From
        2.       266
        3. 7.5.3.2 Accessing Assembly Language Constants
          1. 7.5.3.2.1 Accessing an Assembly Language Constant From C
          2. 7.5.3.2.2 Assembly Language Program for
          3.        270
      4. 7.5.4 Sharing C/C++ Header Files With Assembly Source
      5. 7.5.5 Using Inline Assembly Language
    6. 7.6  Using Intrinsics to Access Assembly Language Statements
      1. 7.6.1 Floating Point Conversion Intrinsics
      2. 7.6.2 Floating Point Unit (FPU) Intrinsics
      3. 7.6.3 Trigonometric Math Unit (TMU) Intrinsics
      4. 7.6.4 Fast Integer Division Intrinsics
    7. 7.7  Interrupt Handling
      1. 7.7.1 General Points About Interrupts
      2. 7.7.2 Using C/C++ Interrupt Routines
    8. 7.8  Integer Expression Analysis
      1. 7.8.1 Operations Evaluated With Run-Time-Support Calls
      2. 7.8.2 Division Operations with Fast Integer Division Support
      3. 7.8.3 C/C++ Code Access to the Upper 16 Bits of 16-Bit Multiply
    9. 7.9  Floating-Point Expression Analysis
    10. 7.10 System Initialization
      1. 7.10.1 Boot Hook Functions for System Pre-Initialization
      2. 7.10.2 Run-Time Stack
      3. 7.10.3 Automatic Initialization of Variables for COFF
        1. 7.10.3.1 Initialization Tables
        2.       291
        3. 7.10.3.2 Autoinitialization of Variables at Run Time for COFF
        4. 7.10.3.3 Initialization of Variables at Load Time for COFF
        5. 7.10.3.4 Global Constructors
      4. 7.10.4 Automatic Initialization of Variables for EABI
        1. 7.10.4.1 Zero Initializing Variables
        2. 7.10.4.2 Direct Initialization for EABI
        3. 7.10.4.3 Autoinitialization of Variables at Run Time for EABI
        4. 7.10.4.4 Autoinitialization Tables for EABI
          1. 7.10.4.4.1 Length Followed by Data Format
          2. 7.10.4.4.2 Zero Initialization Format
          3. 7.10.4.4.3 Run Length Encoded (RLE) Format
          4. 7.10.4.4.4 Lempel-Ziv-Storer-Szymanski Compression (LZSS) Format
        5. 7.10.4.5 Initialization of Variables at Load Time
        6. 7.10.4.6 Global Constructors
  10. 8 Using Run-Time-Support Functions and Building Libraries
    1. 8.1 C and C++ Run-Time Support Libraries
      1. 8.1.1 Linking Code With the Object Library
      2. 8.1.2 Header Files
      3. 8.1.3 Modifying a Library Function
      4. 8.1.4 Support for String Handling
      5. 8.1.5 Minimal Support for Internationalization
      6. 8.1.6 Support for Time and Clock Functions
      7. 8.1.7 Allowable Number of Open Files
      8. 8.1.8 Library Naming Conventions
    2. 8.2 The C I/O Functions
      1. 8.2.1 High-Level I/O Functions
        1. 8.2.1.1 Formatting and the Format Conversion Buffer
      2. 8.2.2 Overview of Low-Level I/O Implementation
        1.       open
        2.       close
        3.       read
        4.       write
        5.       lseek
        6.       unlink
        7.       rename
      3. 8.2.3 Device-Driver Level I/O Functions
        1.       DEV_open
        2.       DEV_close
        3.       DEV_read
        4.       DEV_write
        5.       DEV_lseek
        6.       DEV_unlink
        7.       DEV_rename
      4. 8.2.4 Adding a User-Defined Device Driver for C I/O
        1. 8.2.4.1 Mapping Default Streams to Device
      5. 8.2.5 The device Prefix
        1.       add_device
        2.       339
        3. 8.2.5.1 Program for C I/O Device
    3. 8.3 Handling Reentrancy (_register_lock() and _register_unlock() Functions)
    4. 8.4 Reinitializing Variables During a Warm Start
    5. 8.5 Library-Build Process
      1. 8.5.1 Required Non-Texas Instruments Software
      2. 8.5.2 Using the Library-Build Process
        1. 8.5.2.1 Automatic Standard Library Rebuilding by the Linker
        2. 8.5.2.2 Invoking mklib Manually
          1. 8.5.2.2.1 Building Standard Libraries
          2. 8.5.2.2.2 Shared or Read-Only Library Directory
          3. 8.5.2.2.3 Building Libraries With Custom Options
          4. 8.5.2.2.4 The mklib Program Option Summary
      3. 8.5.3 Extending mklib
        1. 8.5.3.1 Underlying Mechanism
        2. 8.5.3.2 Libraries From Other Vendors
  11. 9 C++ Name Demangler
    1. 9.1 Invoking the C++ Name Demangler
    2. 9.2 Sample Usage of the C++ Name Demangler
  12. 10CLA Compiler
    1. 10.1 How to Invoke the CLA Compiler
      1. 10.1.1 CLA-Specific Options
    2. 10.2 CLA C Language Implementation
      1. 10.2.1 Variables and Data Types
      2. 10.2.2 Pragmas, Keywords, and Intrinsics
      3. 10.2.3 Optimizations with the CLA Compiler
      4. 10.2.4 C Language Restrictions
      5. 10.2.5 Memory Model - Sections
      6. 10.2.6 Function Structure and Calling Conventions
  13.   A Glossary
    1.     369
  14.   B Revision History
  15.   B Earlier Revisions

B Earlier Revisions

The following table lists changes made to this document prior to changes to the document numbering format. The left column identifies the first version of this document in which that particular change appeared.

Earlier Revisions
Version Added Chapter Location Additions / Modifications / Deletions
SPRU514T Using the Compiler Section 2.3.4 Inlined memcpy calls now support >255 words through the use of RPT with a register operand. This allows inlining of memcpy of up to 65535 words. However, the maximum value specified with --rpt_threshold is still 256.
SPRU514T Using the Compiler,
Run-Time Environment		 Section 2.3.4 and Section 7.6 Clarified that TMU1 support is available for EABI only.
SPRU514T Using the Compiler,
CLA Compiler		 Section 2.3, Section 10.1.1, and Section 10.2.2 Added the --cla_signed_compare_workaround option for the CLA compiler. Added comparison intrinsics for the CLA compiler.
SPRU514T Linking Section 4.3.5 Clarified that either --rom_model or --ram_model is required if only the linker is being run, but --rom_model is the default if the compiler runs on C/C++ files on the same command line.
SPRU514T C/C++ Language Section 6.9.21 The #pragma once is now documented for use in header files.
SPRU514T C/C++ Language Section 6.15.4, Section 10.2.1, and Section 10.2.4 The linker now provides diagnostics about certain problems with blocking access and interactions between CLA and C28 code.
SPRU514T Run-Time Environment Section 7.6.3 Corrected assembly instruction equivalents for __atan, __cos, and __sin TMU intrinsics.
SPRU514T Run-Time Environment Section 7.6.4 Clarified that fast integer division requires EABI and FPU32 or FPU64. The types returned by fast integer division intrinsics that divide a 64-bit value by a 32-bit value have changed. In addition, the assembly performed by these intrinsics has been optimized.
SPRU514T Run-Time Environment Section 7.10.4.1 Clarified that zero initialization takes place only if the --rom_model linker option is used, not if the --ram_model option is used.
SPRU514S -- throughout -- The default file extensions for object files created by the compiler have been changed in order to prevent conflicts when C and C++ files have the same names. Object files generated from C source files have the .c.obj extension. Object files generated from C++ source files have the .cpp.obj extension.
SPRU514S Using the Compiler,
Optimization		 Section 2.3 and Section 3.14 The --isr_save_vcu_regs compiler option has been added.
SPRU514S CLA Compiler Section 10.2.1 and Section 10.2.4 Added information about declaring variables shared by CLA and C28x code and about function calls between C28x and CLA code.
SPRU514R.1 Using the Compiler,
Run-Time Environment		 Section 2.3.4, Section 7.6.4, and Section 7.8.2 Added information about fast integer division in regard to the built-in integer division and modulo operators ("/" and "%") and intrinsics.
SPRU514R.1 Run-Time Environment Section 7.1.7 Clarify bit-field alignment rules.
SPRU514R.1 Run-Time Environment Section 7.6.2 Added intrinsics specific to FPU64 and information about COFF vs. EABI use of FPU64.
SPRU514R.1 CLA Compiler Section 10.2 Clarified recommendation for int type usage.
SPRU514R -- throughout -- Added further documentation of EABI support. This includes identifying features that are supported only for COFF or EABI. Identified examples as COFF-specific where necessary.
SPRU514R Using the Compiler Section 2.3 Added command-line options for EABI, including --cinit_compression, --copy_compression, --extern_c_can_throw, --retain, --unused_section_elimination, and --zero_init.
SPRU514R Using the Compiler Section 2.3.1 Added the --emit_references:file linker option.
SPRU514R Using the Compiler Section 2.3.4 Added the --silicon_errata_fpu1_workaround option.
SPRU514R Using the Compiler Section 2.5.1 Documented that C standard macros such as __STDC_VERSION__ are supported.
SPRU514R Using the Compiler Section 2.11.1 Added information about situations where intrinsics may not be inlined.
SPRU514R Using the Compiler,
C/C++ Language		 Section 2.13, Section 6.11 Added information about supported Application Binary Interfaces (ABIs).
SPRU514R Linking C/C++ Code,
Run-Time Environment		 Section 4.3.6, Section 7.1.1 Added EABI-specific sections such as .bss, .const, .sysmem, and .init_array. Also added .args, .ppdata, and .ppinfo sections.
SPRU514R C/C++ Language Section 6.3 Added EABI-specific information about double and wchar_t data types.
SPRU514R C/C++ Language Section 6.9 Added the LOCATION, NOINIT, PERSISTENT, and WEAK pragmas.
SPRU514R C/C++ Language Section 6.12 Added EABI-specific information about namespaces.
SPRU514R C/C++ Language Section 6.14.1 Updated list of C99 non-supported run-time functions.
SPRU514R C/C++ Language Section 6.15.2 Added documentation for the aligned, calls, naked, and weak function attributes.
SPRU514R C/C++ Language Section 6.15.4 Added documentation for the location, noinit, persistent, and weak variable attributes.
SPRU514R Run-Time Environment Section 7.2.1 Added FPU64 registers.
SPRU514R Run-Time Environment Section 7.6 Corrected descriptions of values returned by TMU intrinsics such as __sin() and __cos().
SPRU514R Run-Time Environment Section 7.10.4 Added information about automatic initialization of variables for EABI.
SPRU514R Run-Time Support Functions Section 8.1.8 Added EABI-specific run-time library naming conventions.
SPRU514R Run-Time Support Functions DEV_lseek topic Corrected syntax documented for DEV_lseek function.
SPRU514Q Introduction,
Using the Compiler,
C/C++ Language		 Section 1.3, Section 2.3, Section 6.1, and Section 6.14.2 Added support for C11.
SPRU514Q Using the Compiler Section 2.3.4 Added support for EABI. The COFF ABI is the default.
SPRU514Q Using the Compiler Section 2.3.1 Added the --ecc=on linker option, which enables ECC generation. Note that ECC generation is now off by default.
SPRU514Q Using the Compiler Section 2.3.4 and Section 7.6 Added 64-bit FPU support via --float_support=fpu64.
SPRU514Q Using the Compiler,
Run-Time Environment		 Section 2.3.4 and Section 7.6 Added support for fast integer division via --idiv_support.
SPRU514Q Using the Compiler,
C/C++ Language		 Section 2.3.4 and Section 7.6 Added further TMU support via --tmu_support=tmu1.
SPRU514Q Using the Compiler Section 2.3.4 Added Cyclic Redundancy Check support via --vcu_support=vcrc.
SPRU514Q Using the Compiler Section 2.5.1 The __TI_STRICT_ANSI_MODE__ and __TI_STRICT_FP_MODE__ macros are defined as 0 if their conditions are false.
SPRU514Q Using the Compiler,
C/C++ Language		 Section 2.11 and Section 6.9 Revised the section on inline function expansion and its subsections to include new pragmas and changes to the compilers decision-making about what functions to inline. The FORCEINLINE, FORCEINLINE_RECURSIVE, and NOINLINE pragmas have been added.
SPRU514Q Optimization,
C/C++ Language		 Section 3.11 and Section 6.15.4 Added blocked and noblocked attributes for better Data Page (DP) pointer load optimization. The --disable_dp_load_opt option is no longer recommended.
SPRU514Q C/C++ Language Section 6.2 Removed several C++ features from the exception list because they have been supported for several releases.
SPRU514Q C/C++ Language Section 6.3.3 and Section 7.6 Added a recommendation that 32-bit floating point values be declared as float, not as double. (Both are currently 32 bits.) Modified intrinsic syntax descriptions to use "float" for 32-bit values.
SPRU514Q C/C++ Language Section 6.4 Added information about character sets and file encoding.
SPRU514Q C/C++ Language Section 6.15.2 and Section 6.15.4 Added "retain" as a function attribute and variable attribute.
SPRU514Q C/C++ Language Section 6.15.6 Clarified the availability of the __builtin_sqrt() and __builtin_sqrtf() functions.
SPRU514Q CLA Compiler Section 10.2 Corrected the syntax for the __mswapf intrinsic.
SPRU514P C/C++ Language Section 6.15 The compiler now supports several Clang __has_ macro extensions.
SPRU514P C/C++ Language Section 6.15.1 The wrapper header file GCC extension (#include_next) is now supported.
SPRU514O C/C++ Language Section 6.5.1 Clarified exceptions to const data storage set by the const keyword.
SPRU514N Optimization Section 3.7.1.4 Corrected error in command to process the profile data.
SPRU514M Using the Compiler
C/C++ Language, and
CLA Compiler		 Section 2.3, Section 2.3.4, Section 2.5.1, Section 6.9.15, and Section 10.2 Documented support for CLA version 2 and CLA v2 background tasks.
SPRU514M Using the Compiler,
C/C++ Language		 Section 2.3.3 Revised to state that --check_misra option is required even if the CHECK_MISRA pragma is used.
SPRU514M Using the Compiler Section 2.3.5 Removed the --symdebug:coff option, which is no longer supported.
SPRU514M Using the Compiler Section 2.10 Corrected the document to describe the ---gen_preprocessor_listing option. The name --gen_parser_listing was incorrect.
SPRU514M Optimization Section 3.11 Provided information about data page blocking.
SPRU514L Optimization Section 3.7.3 Corrected function names for _TI_start_pprof_collection() and _TI_stop_pprof_collection().
SPRU514L CLA Compiler Section 10.2 Provided additional information and an example for the __msetflg intrinsic.
SPRU514K Using the Compiler -- Several compiler options have been deprecated, removed, or renamed. The compiler continues to accept some of the deprecated options, but they are not recommended for use.
SPRU514J Using the Compiler Section 2.3 and Section 4.2.2 The --gen_data_subsections option has been added.
SPRU514J Using the Compiler Section 2.3.5 The --symdebug:dwarf_version compiler option has been added. This option sets the DWARF debugging format version used.
SPRU514J Optimization Section 3.7 and Section 3.8 Feedback directed optimization is described. This technique can be used for code coverage analysis.
SPRU514J C/C++ Language Section 6.9.1 A CALLS pragma has been added to specify a set of functions that can be called indirectly from a specified calling function. Using this pragma allows such indirect calls to be included in the calculation of a functions' inclusive stack size.
SPRU514J C/C++ Language Section 6.15.7 A byte_peripheral type attribute and an intrinsic have been added to access byte peripheral data.
SPRU514J Run-Time Environment Section 7.6 Intrinsics have been added to perform unsigned integer division. The new intrinsics are __euclidean_div_i32byu32(), __rpt_subcul(), and __subcul().
SPRU514J Run-Time Environment Section 7.10.1 Additional boot hook functions are available. These can be customized for use during system initialization.
SPRU514I Using the Compiler Table 2-7 The --cla_default option has been added. This option causes files with an extension of .c to be processed as CLA files.
SPRU514I Using the Compiler Section 2.3.4 The --ramfunc option has been added. If set, this option places all functions in RAM.
SPRU514I Using the Compiler -- The --no_fast_branch option has been deprecated.
SPRU514I C/C++ Language Section 6.14.1 C99 math support is now available, including float and long double versions of floating point math functions.
SPRU514I C/C++ Language Section 6.15.2 The ramfunc function attribute has been added. It specifies that a function should be placed in RAM.
SPRU514I Run-Time Environment Section 7.3.2 Added XAR6 to the list of registers and corrected the location in which the address of the returned structure is placed.
SPRU514I Run-Time Environment Section 7.6 Added the __eallow and __edis intrinsics.
SPRU514I CLA Compiler Section 10.2.4 Most GCC extensions are now supported by the CLA compiler.
SPRU514H Introduction Section 1.3 Added support for C99 and C++03.
SPRU514H Using the Compiler Table 2-7 Added support for C99 and C++03. The -gcc option has been deprecated. The --relaxed_ansi option is now the default.
SPRU514H Using the Compiler Section 2.3.3 Added the --advice:performance option.
SPRU514H Using the Compiler Section 2.3.4 The --silicon_version=27 option is no longer supported.
SPRU514G Using the Compiler Section 2.3.4 Added --tmu_support=tmu0 option. This option also affects the behavior of the --float_support and --fp_mode=relaxed options.
SPRU514G Using the Compiler Section 2.3.4 Added support for Type 1 CLA via --cla_support=cla1.
SPRU514G Using the Compiler Section 2.3.4 Added support for Type 2 VCU via --vcu_support=vcu2.
SPRU514H Using the Compiler Section 2.3.11 Added information about the --flash_prefetch_warn option.
SPRU514H Using the Compiler Section 2.5.1 Added several predefined macro names that were not documented.
SPRU514H Using the Compiler Section 2.5.3 Documented that the #warning and #warn preprocessor directives are supported.
SPRU514H Using the Compiler Section 2.6 Added section on techniques for passing arguments to main().
SPRU514H Using the Compiler Section 2.11 Documented that the inline keyword is now enabled in all modes except C89 strict ANSI mode.
SPRU514H C/C++ Language Section 6.3 The size of pointer types on C28x is now 32 bits instead of 22 bits. The near and far keywords are deprecated. The small memory model is no longer supported; the only memory model uses 32-bit pointers. The .bss, .const, and .sysmem sections are no longer used; the .ebss, .econst, and .esysmem sections are used instead. (Symbol addresses are assumed to be less than 22 bits for performance reasons.)
SPRU514H C/C++ Language Section 6.1.1 Added section documenting implementation-defined behavior.
SPRU514H C/C++ Language Section 6.3.1 Added documentation on the size of enum types.
SPRU514H C/C++ Language Section 6.9.15, Section 6.9.22, and Section 6.15.2 Added C++ syntax for the INTERRUPT and RETAIN pragmas. Also removed unnecessary semicolons from #pragma syntax specifications. Also the GCC interrupt and alias function attributes are now supported.
SPRU514H C/C++ Language Section 6.9.11 and Section 6.9.12 Added the FUNC_ALWAYS_INLINE and FUNC_CANNOT_INLINE pragmas.
SPRU514H C/C++ Language Section 6.9.7 Added the diag_push and diag_pop diagnostic message pragmas.
SPRU514H C/C++ Language Section 6.14, Section 6.14.1, and Section 6.14.3 Added support for C99 and C++03. The --relaxed_ansi option is now the default and --strict_ansi is the other option; "normal mode" for standards violation strictness is no longer available.
SPRU514H Run-Time Environment Section 7.4 Added reference to section on accessing linker symbols in C and C++ in the Assembly Language Tools User's Guide.
SPRU514G Run-Time Environment Table 7-6 and Table 7-8 Added intrinsics for TMU instructions and for reading from and writing to memory using 32-bit addresses for data placed higher than the usual 22-bit address range.
SPRU514H Run-Time Support Functions Section 8.1.3 RTS source code is no longer provided in a rtssrc.zip file. Instead, it is located in separate files in the lib/src subdirectory of the compiler installation.
SPRU514H C++ Name Demangler Section 9.1 Corrected information about name demangler options.
SPRU514H CLA Compiler Section 10.1 Non-recursive function calls and more than two function parameters are now supported for CLA code. CLA scratchpad management has been simplified; it is no longer necessary to specify a size for the scratchpad in the linker command file. The compiler now supports both the interrupt attribute and the INTERRUPT pragma for CLA interrupts.