| |
Code Generation Tools
TMS320C6000 Optimizing C Compiler/ Assembler/Linker
The TMS320C6000 Code Generation Tools provide a flexible, software-driven
development environment so that application development can achieve faster time-to-market with smaller product development teams -- at performance levels only previously possible with expensive and time-consuming custom hardware. For the part number of this tool package, please see TMS320C6000 Development Tools, Part Numbers and Pricing.
Key parts of the environment are the highly advanced C compiler and TI's revolutionary Assembly Optimizer -- the first technology in
the DSP industry to automatically optimize assembly code. Together, these tools give hardware designers a highly efficient, user-centered way to extract the code parallelisms that make the new 'C6000 platform so powerful.
The 'C6000 platform's development environment extends the power of DSP design to a new set of users who do not have extensive knowledge of DSP architecture, allowing them to take full advantage of the world's most powerful DSP. This highly-structured, architecture-independent C code development environment dramatically reduces development time for new products. At the same time, it maintains the inherent performance benefits of the 'C6000 generation's advanced VLIW architecture.
The 'C6000 compiler offers an average improvement in execution speed of 3X over state-of-the-art fixed-point DSP C compilers for DSP. The C Compiler accepts ANSI C source code and produces efficient 'C6000 assembly language source code, performing a wide variety of optimizations to improve the efficiency of the compiled code. The compiler incorporates four levels of state-of-the-art generic and target-specific optimizations. The level of optimizations is selectable. The ANSI-compliant C compiler was validated with the Perenial, Plum-Hall C Validation Suite and the K&R Test.
Optimizations include:
- Optimizations specific to the TMS320C6201 processor
- Software pipelining
- If conversion/predicated execution
- Memory address cloning
- Memory address dependence elimination
- General Optimizations
- Branch optimizations/control-flow simplification,
- Alias disambiguation,
- Copy propagation,
- Common subexpression elimination,
- Redundant assignment elimination,
- Loop induction variable optimizations/strength reduction,
- Loop rotation,
- Loop invariant code motion,
- Inline expansion of function calls,
- File level optimizations,
- Data flow optimizations,
- Expression simplification,
- Register variables,
- Register tracking/targeting,
- Cost-based register allocation,
For application code sections that require fine tuning of assembly code, the 'C6000 platform's unique Assembly Optimizer provides designers the same transparent programming capability as the C compiler. The tool supports automatic scheduling, optimizing, and separation of fine-grained parallel tasks from serial, in-line assembly code -- delivering a level of simplicity and power that is unprecedented in assembly-level tools.
The Code Generation Tools package includes:
A shell program that calls the individual programs with
the desired options. The shell program can call the parser, the optimizer,
the Assembly Optimizer, the code generator, the interlist utility, the
assembler, and the linker.
The parser reads the C source code file, performs
preprocessing functions, verifies the syntax, and produces an intermediate
file that is used as an input to the optimizer or code generator. It also
handles macro definitions and expansions, #include files, and conditional
compilation.
The optimizer reads the intermediate file generated
by the parser, and performs various general and target specific
optimizations to improve the execution speed of the program. Optimizations
include rearranging statements and expressions, allcoating variables into
registers, unrolling smaller loops that will not pipeline, and combining
several C source files into one module to perform other optimizations that
are rarely applied with file-level optimization. The optimizer also does
the initial analysis for pipelining loops (software pipelining loops with a
large enough trip count), a process that is completed by the code generator.
The Assembly Optimizer takes in
linear assembly instructions. The Assembly Optimizer takes this serial
assembly file and creates an intermediate file (like the parser and optimizer)
which is input into the code generator. The code generator then produces
optimized and/or software pipelined assembly code.
The code generator reads the intermediate file generated
by the parser, the optimizer, or the Assembly Optimizer and converts it to a
'C6000 assembly source code file.
The interlist utility adds comments containing the C
source code within the assembly language source code file. The interlist
utility allows you to inspect the assembly code generated for each C
statement. You can choose whether or not to include the optimizer comments.
The assembler translates assembly language source
code files into machine language COFF (Common Object File Format) object
files. The assembly files can contain 'C6000 assembly language instructions,
assembler directives, and macro directives. The assembler processes source
statements in a text file to produce a relocatable object file, produces a
source listing, allows you to segment your code into sections, defines and
references global symbols, allows conditional assembly, and supports macros.
It also supports a macro language that enables users to create their
own "instructions."
The archiver allows you to manage archive files (also
called libraries) which consist of a collection of source code files or
COFF object files. The archiver allows you to combine several individual files
into a single file called an archive or a library. You can delete, replace,
add, and extract members of a library.
The run-time support archive is a collection of C files,
C header files, and assembly language source files that implement ANSI
standard runtime-support functions (including math.h, stdio.h, time.h, etc).
The library-build utility allows you to build a customized
COFF object library from a source code archive.
The linker allows you to combine COFF object files into
a single executable COFF output file. The linker allocates relocatable
sections and symbols and resolves external references between input files.
The linker also accepts previously linked files and library members as input.
The loader allows you to run a program and display values
via the C I/O library. When your application completes, load6x displays the
number of clock cycles that were required to execute your application. You
can create batch files or shell scripts to run several 'C6000 executables and
date and store the output.
The hex conversion utility allows you to convert an
executable COFF output file into ASCII-Hex, Intel MSC-86, Extended Tektronix,
Motorola-S, or TI-Tagged Object file format that can be used as input to an
EPROM programmer.
The cross-reference utility accepts linked object files and
produces a listing of all symbols, their definitions, including names of linked
source files where they are defined and referenced.
|