SPRUI04F july 2015 – april 2023
A technique that determines when two pointer expressions cannot point to the same location, allowing the compiler to freely optimize such expressions.
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.
A process in which the linker calculates the final memory addresses of output sections.
American National Standards Institute; an organization that establishes standards voluntarily followed by industries.
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.
A collection of individual files grouped into a single file by the 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.
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.
A statement that initializes a variable with a value.
The process of initializing global C variables (contained in the .cinit section) before program execution begins.
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.
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
A set of statements that are grouped together within braces and treated as an entity.
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.
Per ANSI/ISO C, the smallest addressable unit that can hold a character.
A software program that translates C source statements into assembly language source statements.
A compiler tool that takes the file produced by the parser or the optimizer and produces an assembly language source file.
Common object file format; a system of object files configured according to a standard developed by AT&T. This ABI is no longer supported.
A file that contains options, filenames, directives, or commands for the linker or hex conversion utility.
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.
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.
Memory that the linker has specified for allocation.
A type whose value cannot change.
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.
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.
A function call where one function calls another using the function's name.
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).
See alias disambiguation
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.
Executable and Linkable Format; a system of object files configured according to the System V Application Binary Interface specification.
A hardware development system that duplicates the TMS320C6000 operation.
A point in target memory where execution starts.
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.
The portion of code in a function that restores the stack and returns.
A linked, executable object file that is downloaded and executed on a target system.
A constant, a symbol, or a series of constants and symbols separated by arithmetic operators.
A symbol that is used in the current program module but defined or declared in a different program module.
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).
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.
A symbol that is either defined in the current module and accessed in another, or accessed in the current module but defined in another.
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.
A function call where one function calls another function by giving the address of the called function.
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.
A section from an object file that will be linked into an executable object file.
A section from an object file that will be linked into an executable object file.
A C/C++ preprocessor that is merged with the parser, allowing for faster compilation. Stand-alone preprocessing or preprocessed listing is also available.
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.
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.
International Organization for Standardization; a worldwide federation of national standards bodies, which establishes international standards voluntarily followed by industries.
The body of a software-pipelined loop between the pipelined-loop prolog and the pipelined-loop epilog.
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.
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.
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.
An output file, created by the assembler, which lists source statements, their line numbers, and their effects on the section program counter (SPC).
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
A device that places an executable object file into system memory.
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.
A user-defined routine that can be used as an instruction.
The process of invoking a macro.
A block of source statements that define the name and the code that make up a macro.
The process of inserting source statements into your code in place of a macro call.
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.
A map of target system memory space that is partitioned into functional blocks.
A compiler-specific feature that encodes a function name with information regarding the function's arguments return types.
An assembled or linked file that contains machine-language object code.
An archive library made up of individual object files.
An argument of an assembly language instruction, assembler directive, or macro directive that supplies information to the operation performed by the instruction or directive.
A software tool that improves the execution speed and reduces the size of C programs. See also assembly optimizer.
Command-line parameters that allow you to request additional or specific functions when you invoke a software tool.
A final, allocated section in a linked, executable module.
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.
The process of assigning a data path to each instruction.
A technique where a second instruction begins executing before the first instruction has been completed. You can have several instructions in the pipeline, each at a different processing stage.
An operation that retrieves a data object from a stack.
A preprocessor directive that provides directions to the compiler about how to treat a particular statement.
A software tool that interprets macro definitions, expands macros, interprets header files, interprets conditional compilation, and acts upon preprocessor directives.
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.
The portion of code in a function that sets up the stack.
An operation that places a data object on a stack for temporary storage.
An option that suppresses the normal banner and the progress information.
Executable code or initialized data in an output section.
A process in which the linker adjusts all the references to a symbol when the symbol's address changes.
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.
Standard ISO functions that perform tasks that are not part of the C language (such as memory allocation, string conversion, and string searches).
A library file, rts.src, which contains the source for the run time-support functions.
A relocatable block of code or data that ultimately will be contiguous with other sections in the memory map.
A process that fills the unused MSBs of a value with the value's sign bit.
A technique used by the C/C++ optimizer to schedule instructions from a loop so that multiple iterations of the loop execute in parallel.
A file that contains C/C++ code or assembly language code that is compiled or assembled to form an object file.
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.
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.
An entry in the symbol table that indicates how to access a symbol.
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.
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.
A string of alphanumeric characters that represents an address or a value.
The ability of a software tool to retain symbolic information that can be used by a debugging tool such as an emulator.
The system on which the object code you have developed is executed.
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.
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 ^.
The number of times that a loop executes before it terminates.
Memory that is not defined as part of the memory map and cannot be loaded with code or data.
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.
A value that is treated as a nonnegative number, regardless of its actual sign.
A 32-bit addressable location in target memory