CODE COMPOSER VERSION 2.03
==========================

Visit our web site at www.go-dsp.com for up to the date product information 
and frequently asked questions.

1 NEW FEATURES
--------------

The following is a list of new features that have been added since the 
previous 1.60 release.  For more information, please refer to the on-line
help.

1.1 Quickwatch and Quickwatch Add
---------------------------------
Code Composer now has a Quickwatch window.  The watch window tool bar
button has been changed to launch the Quickwatch window instead of the
watch window.  To use the Quickwatch feature, place the cursor on a 
variable in the source window and press the Quickwatch tool bar button.
The Quickwatch tool bar button only responds if the active window is
a source window.  The Quickwatch window has a button for adding the
variable to the watch window.  You can bypass the Quickwatch window
and add the variable directly to the watch window using the QUICK_WATCH_ADD
menu item on the right mouse pop-up window.

1.2 File Printing
-----------------
Code Composer now supports printing of source files from the File menu item.  
Printing of graph windows or memory windows is not supported.

1.3 Patch Assembler
-------------------
The Dis-Assembly window now has a Patch Assembler.  You can access the
patch assembler from the right mouse pop-up menu for the Dis-Assembly
window.

1.4 Algebraic Disassembly support for C54x
------------------------------------------
Code Composer has the option of displaying algebraic disassembly instead
of mnemonic.  Use OPTION-DIS_ASSEMBLY to change this setting.

1.5 Assembly Source Level Debugging for C5x/C2xx
------------------------------------------------
Code Composer supports assembly source level debugging for the C5x/C2xx 
when used in conjunction with TI's Assembler tools version 6.63 or later.
You need to specify the "-g" option when you assembly your source.

1.6 Drag and Drop from the File Manager
---------------------------------------
Code Composer supports drag and drop of filenames from the file manager.
For every file dropped, Code Composer will attempt to open the file
as a source window for editing.  The only restriction is that you must
drop the file on the background of the main window, and not into an 
a child window.

1.7 New File IO controls
------------------------
A new file IO window is created for each file.  This window displays
progress information and has controls to pause, resume, skip forward, 
or rewind the file to the begining.

1.8 GOTO Line Number
--------------------
To position a source window at a particular line number, select 
GOTO_LINE, from the right mouse pop-up menu for the source window.

1.9 Tab Size Option for Editor
------------------------------
The Editor has a global tab size option that can be changed from the
Options..Editor menu command.  The tab setting determines how many 
spaces there are between tab positions.

1.10 New Project Management Features
------------------------------------
The build window buffer has increased from 200 lines to 1000 lines.  In
addition, the build output is logged to a file called "build.log" in the 
directory of the current project.  Therefore, if your build output 
exceeds 1000 lines, you can look at this file.

The order of files for linking has been changed.  Originally, new files
added to the project were linked last.  Now, new files added to the
project are linked before older files.  Also source files are always
linked before *.obj and *.lib files independent of when they were added
to the project.  This arrangement should make it easier to override 
functions in a library.

The Show Dependencies window has been changed to eliminate redundant
information.  Now, if an include file is listed twice, its dependencies
are not shown.  Instead, "(etc...)" is displayed.  Also, double-clicking
a file in the Dependency window will automatically open the file in an
edit window.

The project build no longer copies C source files to the link directory.

1.11 Multiprocessor Configuration
---------------------------------
The Code Composer Setup program has been changed to make it easier to
add CPU names to the multiprocessor configuration.  If you add the name
CPU_A or dsp0, and then hit the ADD button again, Code Composer will
automatically generate a unique name by incrementing the last character(s).
This means the second processor will become CPU_B or dsp1.

To Add large numbers of processors with incrementing names, follow these
instructions:
    1) Remove All processors by pressing the remove all button.
    2) Enter the name of the last processor, e.g., CPU_ZZ, dsp100, etc...
       and Press the INSERT button.
    3) Enter the name of the first processor, e.g., CPU_AA or dsp000.
       and Press the INSERT button.
    4) While the INSERT button is current, hold down the SPACE BAR to
       rapidly add all processors between the first and the last.
    5) Wait for the warning message "Processor CPU_ZZ already exists" 
       to be displayed when all processors have been added.

The error message displayed during initialization of the target, now 
has ABORT, RETRY, and IGNORE options.  ABORT will stop attempting to
initialize DSPs in a multiprocessor environment.  IGNORE will simply
skip to the next DSP in a multiprocessor environment.  ABORT and IGNORE
have the same effect in a single processor environment, or on the last
processor in a multiprocessor environment.


2 PROBLEMS FIXED SINCE VERSION 1.56
-----------------------------------

The following is a list of problems fixed since release 1.56.

2.1 TMS320C54x Processor Specific Problems
------------------------------------------
Problems where bit fields do not display correctly in the watch window 
have been fixed.

Problems with displaying floating point variables inside the watch window 
have been fixed.

Problems where the first instruction after loading a new program and running
does not execute properly have been fixed.  The problem was that the
pipeline was not flushed properly when a new program was loaded.  

2.2 Project Management 
----------------------
Problems where symbols for local static variables are missing, when using 
the Floating Point Compiler (C3x/C4x) version 4.7, have been fixed.

2.3 Editor 
---------- 
The user is now prompted to save files that need saving before quitting.

Problems where the cursor is not always visible when a new source window 
is opened have been fixed.

When a program is reloaded, the source window no longer reverts back from
mixed mode to non-mixed mode.
 
2.4 Miscellaneous 
----------------- 
For problems where C3x/C4x Code Composer cannot properly single step 
into an RPTS instruction, Code Composer automatically uses STEP OVER 
instead of STEP INTO to avoid the problem.  You no longer need to prevent 
the compiler from generating an RPTS instruction by selecting the "Disable 
RPTS instruction for loops" in the "Code Generation" section of the 
"Compiler Options" under project options.

Problems where the watch window doesn't show the correct value for 
register mapped function arguments have been fixed.

Problems where assembly breakpoints do not get displayed in the 
source window after loading a workspace have been fixed.

Restrictions have been relaxed for the Call Stack window.  The frame
pointer no longer has to point within the ".stack" section.  However, the 
Call Stack window will not be able to trace back through the Call 
Stack if C-source information is missing from the calling function.

The problem of displaying contents of memory addresses for a specific memory 
space (program, data, or I/O) in the Watch window in the form:

	*(int *)0x1000@prog, x

has been fixed.

3 KNOWN PROBLEMS
----------------
 
The following is a list of known problems in the current release (2.00) 
of Code Composer.   
 
3.1 TMS320C54x Processor Specific Problems
------------------------------------------
The ARP field of the ST0 register should not be modified.  If it is modified,
it appears that the target processor starts running.  To clear the 
problem you must reset the target using the DEBUG-RESET menu item.  This
problem exists on TI's debugger as well.

The C54x pipeline can produce unexpected results when using probe-points 
Because the pipeline is not flushed before the probe-point hits, 
the order of operations may be reversed.  For example, if your reading
data from file into a memory buffer, and the probe-point is located
immediately after zeroing the buffer, the last location may get cleared
after the probe-point hits, instead of before.  To be safe, your 
probe-point should not rely on the previous instruction completing execution.

3.2 Project Management 
----------------------
TI's floating point compiler, version 4.5 or earlier, will run out of 
memory under MS Windows if optimizations are enabled.  This is true 
if the compiler is run in a DOS box, or if run using Code Composer.  
The work-around is to disable all optimizations while under Windows.  
The fix is to upgrade to TI's floating point compiler version 4.6 which 
includes a protected mode memory manager that is compatible with 
Windows.  However, if you run two or more instances of the version 4.6 
compiler your system may crash.  This is true if the compilers are run 
in separate DOS boxes, or if they are run from Code Composer. 
 
No warning message is generated when build options exceed 128 
characters and are truncated.  Error messages may be generated by the 
compiler when the project is built because of a truncated option flag. 

The C_OPTION environment variable may be set by a third parties install
program.  The C_OPTION environment variable may override project options
you have selected within Code Composer's project options dialog.  
Type "set" in a command shell or run GEL_System("set") within a 
command line dialog to display the current OS environment settings to 
see if C_OPTIONS is defined.
 
3.3 Editor 
---------- 
Code Composer will report that the file was not found when creating a 
new source file using the File..Open menu item.  Use the File..New 
menu item to create new source files instead. 
 
3.4 Miscellaneous 
----------------- 
You cannot edit CPU registers as floating-point numbers using the 
"Edit Register" dialog.  Instead, use the "Edit Variable" dialog using 
the pre-defined symbols "F0" to "F7" for the registers "R0" to "R7" 
respectively.  To view floating point registers, add these symbols to the 
watch window.  Similarly, to edit the exponent byte of floating-point 
registers, use the "Edit Variable" dialog using the pre-defined symbols 
"E0" to "E7" for the exponent bytes of the registers "R0" to "R7" 
respectively. 
 
If you have compiler optimization enabled, the compiler may not 
maintain the c-stack frame properly.  Therefore, the "Call Stack" may 
not contain correct information.  The "Step Out" function may not 
operate properly either.  Both of these functions rely on the c-stack. 
 
