SPNU151W January   1998  – March 2023 66AK2E05 , 66AK2H06 , 66AK2H12 , 66AK2H14 , AM1705 , AM1707 , AM1802 , AM1806 , AM1808 , AM1810 , AM5K2E04 , OMAP-L132 , OMAP-L137 , OMAP-L138 , SM470R1B1M-HT , TMS470R1A288 , TMS470R1A384 , TMS470R1A64 , TMS470R1B1M , TMS470R1B512 , TMS470R1B768

 

  1.   Read This First
    1.     About This Manual
    2.     Notational Conventions
    3.     Related Documentation
    4.     Related Documentation From Texas Instruments
    5.     Trademarks
  2. 1Introduction 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
  3. 2Using 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 (TI_ARM_C_OPTION)
      2. 2.4.2 Naming One or More Alternate Directories (TI_ARM_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
    12. 2.12 Using Interlist
    13. 2.13 Controlling Application Binary Interface
    14. 2.14 VFP Support
    15. 2.15 Enabling Entry Hook and Exit Hook Functions
  4. 3Optimizing 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  Accessing Aliased Variables in Optimized Code
    10. 3.10 Use Caution With asm Statements in Optimized Code
    11. 3.11 Using the Interlist Feature With Optimization
    12. 3.12 Debugging and Profiling Optimized Code
      1. 3.12.1 Profiling Optimized Code
    13. 3.13 What Kind of Optimization Is Being Performed?
      1. 3.13.1  Cost-Based Register Allocation
      2. 3.13.2  Alias Disambiguation
      3. 3.13.3  Branch Optimizations and Control-Flow Simplification
      4. 3.13.4  Data Flow Optimizations
      5. 3.13.5  Expression Simplification
      6. 3.13.6  Inline Expansion of Functions
      7. 3.13.7  Function Symbol Aliasing
      8. 3.13.8  Induction Variables and Strength Reduction
      9. 3.13.9  Loop-Invariant Code Motion
      10. 3.13.10 Loop Rotation
      11. 3.13.11 Instruction Scheduling
      12. 3.13.12 Tail Merging
      13. 3.13.13 Autoincrement Addressing
      14. 3.13.14 Block Conditionalizing
        1. 3.13.14.1 Block Conditionalizing C Source
        2. 3.13.14.2 C/C++ Compiler Output for
      15. 3.13.15 Epilog Inlining
      16. 3.13.16 Removing Comparisons to Zero
      17. 3.13.17 Integer Division With Constant Divisor
      18. 3.13.18 Branch Chaining
  5. 4Linking 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 Generate List of Dead Functions (--generate_dead_funcs_list 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 of Cinit and Watchdog Timer Hold
      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
  6. 5C/C++ Language Implementation
    1. 5.1  Characteristics of ARM C
      1. 5.1.1 Implementation-Defined Behavior
    2. 5.2  Characteristics of ARM C++
    3. 5.3  Using MISRA C 2004
    4. 5.4  Using the ULP Advisor
    5. 5.5  Data Types
      1. 5.5.1 Size of Enum Types
    6. 5.6  File Encodings and Character Sets
    7. 5.7  Keywords
      1. 5.7.1 The const Keyword
      2. 5.7.2 The __interrupt Keyword
      3. 5.7.3 The volatile Keyword
    8. 5.8  C++ Exception Handling
    9. 5.9  Register Variables and Parameters
      1. 5.9.1 Local Register Variables and Parameters
      2. 5.9.2 Global Register Variables
    10. 5.10 The __asm Statement
    11. 5.11 Pragma Directives
      1. 5.11.1  The CALLS Pragma
      2. 5.11.2  The CHECK_MISRA Pragma
      3. 5.11.3  The CHECK_ULP Pragma
      4. 5.11.4  The CODE_SECTION Pragma
      5. 5.11.5  The CODE_STATE Pragma
      6. 5.11.6  The DATA_ALIGN Pragma
      7. 5.11.7  The DATA_SECTION Pragma
        1. 5.11.7.1 Using the DATA_SECTION Pragma C Source File
        2. 5.11.7.2 Using the DATA_SECTION Pragma C++ Source File
        3. 5.11.7.3 Using the DATA_SECTION Pragma Assembly Source File
      8. 5.11.8  The Diagnostic Message Pragmas
      9. 5.11.9  The DUAL_STATE Pragma
      10. 5.11.10 The FORCEINLINE Pragma
      11. 5.11.11 The FORCEINLINE_RECURSIVE Pragma
      12. 5.11.12 The FUNC_ALWAYS_INLINE Pragma
      13. 5.11.13 The FUNC_CANNOT_INLINE Pragma
      14. 5.11.14 The FUNC_EXT_CALLED Pragma
      15. 5.11.15 The FUNCTION_OPTIONS Pragma
      16. 5.11.16 The INTERRUPT Pragma
      17. 5.11.17 The LOCATION Pragma
      18. 5.11.18 The MUST_ITERATE Pragma
        1. 5.11.18.1 The MUST_ITERATE Pragma Syntax
        2. 5.11.18.2 Using MUST_ITERATE to Expand Compiler Knowledge of Loops
      19. 5.11.19 The NOINIT and PERSISTENT Pragmas
      20. 5.11.20 The NOINLINE Pragma
      21. 5.11.21 The NO_HOOKS Pragma
      22. 5.11.22 The once Pragma
      23. 5.11.23 The pack Pragma
      24. 5.11.24 The PROB_ITERATE Pragma
      25. 5.11.25 The RESET_MISRA Pragma
      26. 5.11.26 The RESET_ULP Pragma
      27. 5.11.27 The RETAIN Pragma
      28. 5.11.28 The SET_CODE_SECTION and SET_DATA_SECTION Pragmas
      29. 5.11.29 The SWI_ALIAS Pragma
      30. 5.11.30 The TASK Pragma
      31. 5.11.31 The UNROLL Pragma
      32. 5.11.32 The WEAK Pragma
    12. 5.12 The _Pragma Operator
    13. 5.13 Application Binary Interface
    14. 5.14 ARM Instruction Intrinsics
    15. 5.15 Object File Symbol Naming Conventions (Linknames)
    16. 5.16 Changing the ANSI/ISO C/C++ Language Mode
      1. 5.16.1 C99 Support (--c99)
      2. 5.16.2 C11 Support (--c11)
      3. 5.16.3 Strict ANSI Mode and Relaxed ANSI Mode (--strict_ansi and --relaxed_ansi)
    17. 5.17 GNU , Clang, and ACLE Language Extensions
      1. 5.17.1 Extensions
      2. 5.17.2 Function Attributes
      3. 5.17.3 For Loop Attributes
      4. 5.17.4 Variable Attributes
      5. 5.17.5 Type Attributes
      6. 5.17.6 Built-In Functions
    18. 5.18 AUTOSAR
    19. 5.19 Compiler Limits
  7. 6Run-Time Environment
    1. 6.1  Memory Model
      1. 6.1.1 Sections
      2. 6.1.2 C/C++ System Stack
      3. 6.1.3 Dynamic Memory Allocation
    2. 6.2  Object Representation
      1. 6.2.1 Data Type Storage
        1. 6.2.1.1 char and short Data Types (signed and unsigned)
        2. 6.2.1.2 float, int, and long Data Types (signed and unsigned)
        3. 6.2.1.3 double, long double, and long long Data Types (signed and unsigned)
        4. 6.2.1.4 Pointer to Data Member Types
        5. 6.2.1.5 Pointer to Member Function Types
        6. 6.2.1.6 Structure and Array Alignment
      2. 6.2.2 Bit Fields
      3. 6.2.3 Character String Constants
    3. 6.3  Register Conventions
    4. 6.4  Function Structure and Calling Conventions
      1. 6.4.1 How a Function Makes a Call
      2. 6.4.2 How a Called Function Responds
      3. 6.4.3 C Exception Handler Calling Convention
      4. 6.4.4 Accessing Arguments and Local Variables
    5. 6.5  Accessing Linker Symbols in C and C++
    6. 6.6  Interfacing C and C++ With Assembly Language
      1. 6.6.1 Using Assembly Language Modules With C/C++ Code
      2. 6.6.2 Accessing Assembly Language Functions From C/C++
        1. 6.6.2.1 Calling an Assembly Language Function From a C/C++ Program
        2. 6.6.2.2 Assembly Language Program Called by
        3.       237
      3. 6.6.3 Accessing Assembly Language Variables From C/C++
        1. 6.6.3.1 Accessing Assembly Language Global Variables
          1. 6.6.3.1.1 Assembly Language Variable Program
          2. 6.6.3.1.2 C Program to Access Assembly Language From
        2.       242
        3. 6.6.3.2 Accessing Assembly Language Constants
          1. 6.6.3.2.1 Accessing an Assembly Language Constant From C
          2. 6.6.3.2.2 Assembly Language Program for
          3.        246
      4. 6.6.4 Sharing C/C++ Header Files With Assembly Source
      5. 6.6.5 Using Inline Assembly Language
      6. 6.6.6 Modifying Compiler Output
    7. 6.7  Interrupt Handling
      1. 6.7.1 Saving Registers During Interrupts
      2. 6.7.2 Using C/C++ Interrupt Routines
      3. 6.7.3 Using Assembly Language Interrupt Routines
      4. 6.7.4 How to Map Interrupt Routines to Interrupt Vectors
        1. 6.7.4.1 Sample intvecs.asm File
      5. 6.7.5 Using Software Interrupts
      6. 6.7.6 Other Interrupt Information
    8. 6.8  Intrinsic Run-Time-Support Arithmetic and Conversion Routines
      1. 6.8.1 CPSR Register and Interrupt Intrinsics
    9. 6.9  Built-In Functions
    10. 6.10 System Initialization
      1. 6.10.1 Boot Hook Functions for System Pre-Initialization
      2. 6.10.2 Run-Time Stack
      3. 6.10.3 Automatic Initialization of Variables
        1. 6.10.3.1 Zero Initializing Variables
        2. 6.10.3.2 Direct Initialization
        3. 6.10.3.3 Autoinitialization of Variables at Run Time
        4. 6.10.3.4 Autoinitialization Tables
          1. 6.10.3.4.1 Length Followed by Data Format
          2. 6.10.3.4.2 Zero Initialization Format
          3. 6.10.3.4.3 Run Length Encoded (RLE) Format
          4. 6.10.3.4.4 Lempel-Ziv-Storer-Szymanski Compression (LZSS) Format
          5. 6.10.3.4.5 Sample C Code to Process the C Autoinitialization Table
        5. 6.10.3.5 Initialization of Variables at Load Time
        6. 6.10.3.6 Global Constructors
      4. 6.10.4 Initialization Tables
    11. 6.11 Dual-State Interworking Under TIABI (Deprecated)
      1. 6.11.1 Level of Dual-State Support
      2. 6.11.2 Implementation
        1. 6.11.2.1 Naming Conventions for Entry Points
        2. 6.11.2.2 Indirect Calls
          1. 6.11.2.2.1 C Code Compiled for 16-BIS State: sum( )
          2. 6.11.2.2.2 16-Bit Assembly Program for
          3. 6.11.2.2.3 C Code Compiled for 32-BIS State: sum( )
          4. 6.11.2.2.4 32-Bit Assembly Program for
          5.        286
  8. 7Using Run-Time-Support Functions and Building Libraries
    1. 7.1 C and C++ Run-Time Support Libraries
      1. 7.1.1 Linking Code With the Object Library
      2. 7.1.2 Header Files
      3. 7.1.3 Modifying a Library Function
      4. 7.1.4 Support for String Handling
      5. 7.1.5 Minimal Support for Internationalization
      6. 7.1.6 Support for Time and Clock Functions
      7. 7.1.7 Allowable Number of Open Files
      8. 7.1.8 Nonstandard Header Files in the Source Tree
      9. 7.1.9 Library Naming Conventions
    2. 7.2 The C I/O Functions
      1. 7.2.1 High-Level I/O Functions
        1. 7.2.1.1 Formatting and the Format Conversion Buffer
      2. 7.2.2 Overview of Low-Level I/O Implementation
        1.       open
        2.       close
        3.       read
        4.       write
        5.       lseek
        6.       unlink
        7.       rename
      3. 7.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. 7.2.4 Adding a User-Defined Device Driver for C I/O
        1. 7.2.4.1 Mapping Default Streams to Device
      5. 7.2.5 The device Prefix
        1.       add_device
        2.       321
        3. 7.2.5.1 Program for C I/O Device
    3. 7.3 Handling Reentrancy (_register_lock() and _register_unlock() Functions)
    4. 7.4 Library-Build Process
      1. 7.4.1 Required Non-Texas Instruments Software
      2. 7.4.2 Using the Library-Build Process
        1. 7.4.2.1 Automatic Standard Library Rebuilding by the Linker
        2. 7.4.2.2 Invoking mklib Manually
          1. 7.4.2.2.1 Building Standard Libraries
          2. 7.4.2.2.2 Shared or Read-Only Library Directory
          3. 7.4.2.2.3 Building Libraries With Custom Options
          4. 7.4.2.2.4 The mklib Program Option Summary
      3. 7.4.3 Extending mklib
        1. 7.4.3.1 Underlying Mechanism
        2. 7.4.3.2 Libraries From Other Vendors
  9. 8C++ Name Demangler
    1. 8.1 Invoking the C++ Name Demangler
    2. 8.2 Sample Usage of the C++ Name Demangler
  10.   A Glossary
    1.     A.1 Terminology
  11.   B Revision History
  12.   B Earlier Revisions

Terminology

    absolute lister

    A debugging tool that allows you to create assembler listings that contain absolute addresses.

    alias disambiguation

    A technique that determines when two pointer expressions cannot point to the same location, allowing the compiler to freely optimize such expressions.

    aliasing

    The ability for a single object to be accessed in more than one way, such as when two pointers point to a single object. It can disrupt optimization, because any indirect reference could refer to any other object.

    allocation

    A process in which the linker calculates the final memory addresses of output sections.

    ANSI

    American National Standards Institute; an organization that establishes standards voluntarily followed by industries.

    Application Binary Interface (ABI)

    A standard that specifies the interface between two object modules. An ABI specifies how functions are called and how information is passed from one program component to another.

    archive library

    A collection of individual files grouped into a single file by the archiver.

    archiver

    A software program that collects several individual files into a single file called an archive library. With the archiver, you can add, delete, extract, or replace members of the archive library.

    assembler

    A software program that creates a machine-language program from a source file that contains assembly language instructions, directives, and macro definitions. The assembler substitutes absolute operation codes for symbolic operation codes and absolute or relocatable addresses for symbolic addresses.

    assignment statement

    A statement that initializes a variable with a value.

    autoinitialization

    The process of initializing global C variables (contained in the .cinit section) before program execution begins.

    autoinitialization at run time

    An autoinitialization method used by the linker when linking C code. The linker uses this method when you invoke it with the --rom_model link option. The linker loads the .cinit section of data tables into memory, and variables are initialized at run time.

    big endian

    An addressing protocol in which bytes are numbered from left to right within a word. More significant bytes in a word have lower numbered addresses. Endian ordering is hardware-specific and is determined at reset. See also little endian

    BIS

    Bit instruction set.

    block

    A set of statements that are grouped together within braces and treated as an entity.

    .bss section

    One of the default object file sections. You use the assembler .bss directive to reserve a specified amount of space in the memory map that you can use later for storing data. The .bss section is uninitialized.

    byte

    Per ANSI/ISO C, the smallest addressable unit that can hold a character.

    C/C++ compiler

    A software program that translates C source statements into assembly language source statements.

    code generator

    A compiler tool that takes the file produced by the parser or the optimizer and produces an assembly language source file.

    COFF

    Common object file format; a system of object files configured according to a standard developed by AT&T. This ABI is no longer supported.

    command file

    A file that contains options, filenames, directives, or commands for the linker or hex conversion utility.

    comment

    A source statement (or portion of a source statement) that documents or improves readability of a source file. Comments are not compiled, assembled, or linked; they have no effect on the object file.

    compiler program

    A utility that lets you compile, assemble, and optionally link in one step. The compiler runs one or more source modules through the compiler (including the parser, optimizer, and code generator), the assembler, and the linker.

    configured memory

    Memory that the linker has specified for allocation.

    constant

    A type whose value cannot change.

    cross-reference listing

    An output file created by the assembler that lists the symbols that were defined, what line they were defined on, which lines referenced them, and their final values.

    .data section

    One of the default object file sections. The .data section is an initialized section that contains initialized data. You can use the .data directive to assemble code into the .data section.

    direct call

    A function call where one function calls another using the function's name.

    directives

    Special-purpose commands that control the actions and functions of a software tool (as opposed to assembly language instructions, which control the actions of a device).

    disambiguation

    See alias disambiguation

    dynamic memory allocation

    A technique used by several functions (such as malloc, calloc, and realloc) to dynamically allocate memory for variables at run time. This is accomplished by defining a large memory pool (heap) and using the functions to allocate memory from the heap.

    ELF

    Executable and Linkable Format; a system of object files configured according to the System V Application Binary Interface specification.

    emulator

    A hardware development system that duplicates the ARM operation.

    entry point

    A point in target memory where execution starts.

    environment variable

    A system symbol that you define and assign to a string. Environmental variables are often included in Windows batch files or UNIX shell scripts such as .cshrc or .profile.

    epilog

    The portion of code in a function that restores the stack and returns.

    executable object file

    A linked, executable object file that is downloaded and executed on a target system.

    expression

    A constant, a symbol, or a series of constants and symbols separated by arithmetic operators.

    external symbol

    A symbol that is used in the current program module but defined or declared in a different program module.

    file-level optimization

    A level of optimization where the compiler uses the information that it has about the entire file to optimize your code (as opposed to program-level optimization, where the compiler uses information that it has about the entire program to optimize your code).

    function inlining

    The process of inserting code for a function at the point of call. This saves the overhead of a function call and allows the optimizer to optimize the function in the context of the surrounding code.

    global symbol

    A symbol that is either defined in the current module and accessed in another, or accessed in the current module but defined in another.

    high-level language debugging

    The ability of a compiler to retain symbolic and high-level language information (such as type and function definitions) so that a debugging tool can use this information.

    indirect call

    A function call where one function calls another function by giving the address of the called function.

    initialization at load time

    An autoinitialization method used by the linker when linking C/C++ code. The linker uses this method when you invoke it with the --ram_model link option. This method initializes variables at load time instead of run time.

    initialized section

    A section from an object file that will be linked into an executable object file.

    input section

    A section from an object file that will be linked into an executable object file.

    integrated preprocessor

    A C/C++ preprocessor that is merged with the parser, allowing for faster compilation. Stand-alone preprocessing or preprocessed listing is also available.

    interlist feature

    A feature that inserts as comments your original C/C++ source statements into the assembly language output from the assembler. The C/C++ statements are inserted next to the equivalent assembly instructions.

    intrinsics

    Operators that are used like functions and produce assembly language code that would otherwise be inexpressible in C, or would take greater time and effort to code.

    ISO

    International Organization for Standardization; a worldwide federation of national standards bodies, which establishes international standards voluntarily followed by industries.

    K&R C

    Kernighan and Ritchie C, the de facto standard as defined in the first edition of The C Programming Language (K&R). Most K&R C programs written for earlier, non-ISO C compilers should correctly compile and run without modification.

    label

    A symbol that begins in column 1 of an assembler source statement and corresponds to the address of that statement. A label is the only assembler statement that can begin in column 1.

    linker

    A software program that combines object files to form an executable object file that can be allocated into system memory and executed by the device.

    listing file

    An output file, created by the assembler, which lists source statements, their line numbers, and their effects on the section program counter (SPC).

    little endian

    An addressing protocol in which bytes are numbered from right to left within a word. More significant bytes in a word have higher numbered addresses. Endian ordering is hardware-specific and is determined at reset. See also big endian

    loader

    A device that places an executable object file into system memory.

    loop unrolling

    An optimization that expands small loops so that each iteration of the loop appears in your code. Although loop unrolling increases code size, it can improve the performance of your code.

    macro

    A user-defined routine that can be used as an instruction.

    macro call

    The process of invoking a macro.

    macro definition

    A block of source statements that define the name and the code that make up a macro.

    macro expansion

    The process of inserting source statements into your code in place of a macro call.

    map file

    An output file, created by the linker, which shows the memory configuration, section composition, section allocation, symbol definitions and the addresses at which the symbols were defined for your program.

    memory map

    A map of target system memory space that is partitioned into functional blocks.

    name mangling

    A compiler-specific feature that encodes a function name with information regarding the function's arguments return types.

    object file

    An assembled or linked file that contains machine-language object code.

    object library

    An archive library made up of individual object files.

    operand

    An argument of an assembly language instruction, assembler directive, or macro directive that supplies information to the operation performed by the instruction or directive.

    optimizer

    A software tool that improves the execution speed and reduces the size of C programs.

    options

    Command-line parameters that allow you to request additional or specific functions when you invoke a software tool.

    output section

    A final, allocated section in a linked, executable module.

    parser

    A software tool that reads the source file, performs preprocessing functions, checks the syntax, and produces an intermediate file used as input for the optimizer or code generator.

    partitioning

    The process of assigning a data path to each instruction.

    pop

    An operation that retrieves a data object from a stack.

    pragma

    A preprocessor directive that provides directions to the compiler about how to treat a particular statement.

    preprocessor

    A software tool that interprets macro definitions, expands macros, interprets header files, interprets conditional compilation, and acts upon preprocessor directives.

    program-level optimization

    An aggressive level of optimization where all of the source files are compiled into one intermediate file. Because the compiler can see the entire program, several optimizations are performed with program-level optimization that are rarely applied during file-level optimization.

    prolog

    The portion of code in a function that sets up the stack.

    push

    An operation that places a data object on a stack for temporary storage.

    quiet run

    An option that suppresses the normal banner and the progress information.

    raw data

    Executable code or initialized data in an output section.

    relocation

    A process in which the linker adjusts all the references to a symbol when the symbol's address changes.

    run-time environment

    The run time parameters in which your program must function. These parameters are defined by the memory and register conventions, stack organization, function call conventions, and system initialization.

    run-time-support functions

    Standard ISO functions that perform tasks that are not part of the C language (such as memory allocation, string conversion, and string searches).

    run-time-support library

    A library file, rts.src, which contains the source for the run time-support functions.

    section

    A relocatable block of code or data that ultimately will be contiguous with other sections in the memory map.

    sign extend

    A process that fills the unused MSBs of a value with the value's sign bit.

    simulator

    A software development system that simulates ARM operation.

    source file

    A file that contains C/C++ code or assembly language code that is compiled or assembled to form an object file.

    stand-alone preprocessor

    A software tool that expands macros, #include files, and conditional compilation as an independent program. It also performs integrated preprocessing, which includes parsing of instructions.

    static variable

    A variable whose scope is confined to a function or a program. The values of static variables are not discarded when the function or program is exited; their previous value is resumed when the function or program is reentered.

    storage class

    An entry in the symbol table that indicates how to access a symbol.

    string table

    A table that stores symbol names that are longer than eight characters (symbol names of eight characters or longer cannot be stored in the symbol table; instead they are stored in the string table). The name portion of the symbol's entry points to the location of the string in the string table.

    structure

    A collection of one or more variables grouped together under a single name.

    subsection

    A relocatable block of code or data that ultimately will occupy continuous space in the memory map. Subsections are smaller sections within larger sections. Subsections give you tighter control of the memory map.

    symbol

    A string of alphanumeric characters that represents an address or a value.

    symbolic debugging

    The ability of a software tool to retain symbolic information that can be used by a debugging tool such as an emulator or simulator.

    target system

    The system on which the object code you have developed is executed.

    .text section

    One of the default object file sections. The .text section is initialized and contains executable code. You can use the .text directive to assemble code into the .text section.

    trigraph sequence

    A 3-character sequence that has a meaning (as defined by the ISO 646-1983 Invariant Code Set). These characters cannot be represented in the C character set and are expanded to one character. For example, the trigraph ??' is expanded to ^.

    trip count

    The number of times that a loop executes before it terminates.

    unconfigured memory

    Memory that is not defined as part of the memory map and cannot be loaded with code or data.

    uninitialized section

    A object file section that reserves space in the memory map but that has no actual contents. These sections are built with the .bss and .usect directives.

    unsigned value

    A value that is treated as a nonnegative number, regardless of its actual sign.

    variable

    A symbol representing a quantity that can assume any of a set of values.

    veneer

    A sequence of instructions that serves as an alternate entry point into a routine if a state change is required.

    word

    A 32-bit addressable location in target memory