Contents

HSM

Support for the special function registers (SFR) of the HSM is
available through a separate installer. For security reasons related to
the HSM, Altium will verify the possible availability of the SFR
installer to an end user with Infineon. Once Infineon gives Altium
permission to release the SFR installer, we will make it available
through a secure FTP location.

Simulator update

To support the latest AURIX derivatives hardware it is required to
upgrade to the latest simulator from Infineon, TSIM v1.11.61. Therefore
this version is included in this release.

This section gives an overview of the most important new
features and improvements in v5.0r1. See the sections with fixed issues
for a complete list.

Support for MISRA C:2012

This release adds MISRA-C12 support to the C compiler. Rules
selection and related configuration can be
done from Eclipse. See the User Guide for the list of rules supported
by the TriCore C compiler, PCP C compiler and ARM C Compiler (HSM).

Eclipse IDE update to version 'Kepler'

This release holds an updated version 4.3.2 of the IDE Eclipse named
Kepler. For features, improvements and bug fixes please refer to the Eclipse community web-site.

New AURIX derivatives SFR support

SFR support has been added for the following AURIX derivatives: TC21x, TC22x, TC26x B-step and TC29x B-step.

TriBoard support TC27x C-step

With this release the AURIX TriBoard TC27x C-step is being supported.

Shift JIS Kanji support

In order to allow for Japanese character support on non-Japanese
systems (like PCs), you can use the Shift JIS Kanji Code standard. This
standard combines two successive ASCII characters to represent one
Kanji character. A valid Kanji combination is only possible within the
following ranges:

First (high) byte is in the range 0x81-0x9f or 0xe0-0xef.

Second (low) byte is in the range 0x40-0x7e or 0x80-0xfc

Compiler option -Ak and Assembler option --kanji enables support for
Shift JIS encoded Kanji multi-byte characters in strings and (wide)
character constants. Without this option, encodings with 0x5c as the
second byte conflict with the use of the backslash ('\') as an escape
character. Shift JIS in comments is supported regardless of this option.

Note that Shift JIS also includes Katakana and Hiragana.

Improved floating point configuration: --fp-model

The C compilers and control program support a new option --fp-model
to control all floating point related
settings. Some of those settings were formerly done with separate
options. Also Eclipse got a new separate
page for setting the floating point model options.

The following flags are available:

--fp-model=<flag>

Description

Target

Replaces
and deprecates option

0

strict alias for
--fp-model=CFLNRStZ

TriCore, PCP

1

precise alias for
--fp-model=cFLNRSTZ

TriCore, PCP

2 (default)

fast-double alias
for --fp-model=cFlnrSTz

TriCore, PCP

3

fast-single alias
for --fp-model=cflnrSTz

TriCore

c/C +/-contract

allow expression
contraction

TriCore, PCP

--no-macs

f/F +/-float

treat 'double' as
'float'

TriCore

--no-double

l/L +/-fastlib

allow less precise
library functions

TriCore, PCP

n/N +/-nonan

allow
optimizations to ignore NaN/Inf

TriCore, PCP

r/R +/-rewrite

allow expression
rewriting

TriCore, PCP

s/S +/-soft

use software
floating point library

TriCore

--no-fpu,
--fpu-present

t/T +/-trap

support trapping
on exceptions

TriCore, PCP

--fp-trap

z/Z +/-negzero

ignore sign of -0.0

TriCore, PCP

The defaults are:

TriCore : --fp-model=2 , cFlnrSTz

PCP : --fp-model=2 , clnrTz

With --fp-model=+contract you allow the compiler to contract multiple
float operations into a single operation, with different rounding
results. A possible example is fused multiply-add.

With --fp-model=+float you tell the compiler to treat variables and
constants of type double as float. Because the float type takes less
space, execution speed increases and code size decreases, both at the
cost of less precision.
Used libraries have to be built with the same setting for this option.

With --fp-model=+fastlib you allow the compiler to select faster but
less accurate library functions for certain floating-point operations.

With --fp-model=+nonan you allow the compiler to ignore NaN or Inf
input values. An example is to replace multiply by zero with zero.

With --fp-model=+rewrite you allow the compiler to rewrite
expressions
by reassociating. This might result in rounding differences and
possibly different exceptions.
An example is to rewrite (a*c)+(b*c) as (a+b)*c.

With --fp-model=+soft no hardware floating point instructions are
generated, only calls to the software floating point library.

With --fp-model=+negzero you allow the compiler to ignore the sign
of
-0.0 values. An example is to replace (a-a) by zero.

Related pragmas

#pragma STDC FP_CONTRACT (*) (+)

Standard ISO-C99 pragma, that controls the
+contract flag of
--fp-model.

#pragma fp_negzero (*) (+)

Control the +negzero flag of --fp-model.

#pragma fp_nonan (*) (+)

Control the +nonan flag of --fp-model.

#pragma fp_rewrite (*) (+)

Control the +rewrite flag of --fp-model.

TriCore Compiler __atbit() and __bit are deprecated

The compiler (up to
version v4.x of the toolset) was supporting
__atbit() for backwards compatibility. With v5.0r1 it is deprecated.
When used the following warning will be given:

W766: __atbit has been deprecated, use classic method of C masking and
shifting, intrinsic functions __extru and __imaskldmst or bitfields.

You should rewrite your application as recommended.

TriCore Compiler __bit is deprecated

The compiler was supporting __bit, but actually it was exactly the
same as _Bool. The __bit was used with __atbit() which has been
deprecated too. Use _Bool instead.

Changes in High Level Dumper

Some updates have been made to the High Level Dumper, hldumptc.
Below is a small list with the major updates. For the complete list
refer to 160-39604 .

Command-line option --data-dump-format is replaced with --hex. Both data sections as code sections will be dumped hexadecimally.

When specifying --disassembly-intermix=-single-line one expects
multilpe source lines to be displayed preceding an instruction.
However, the interpretation of this command-line option is flawed such
that multi-source-line mode does not get enabled. Work-around: use -iS
instead.

A new sub-option has been added to -e: b/B +/-basic-types expand arrays with basic C types

Restrict ELF symbol lookup to code and data for higher quality of symbols in disassembly

For a quick start, just start the TriCore Eclipse IDE
from the Start menu. This will start the Eclipse based
development environment. You will be asked to select a workspace. In
case you used Eclipse before it is recommended to select a new
workspace. After clicking OK, you will see the 'Welcome' view. On this
view you will see icons that link to specific information. You can, for
example, select the 'Samples' icon and import the TriCore project
examples, PCP project examples, MCS project examples, 8051 project
examples and/or ARM example projects.

Another icon on the Welcome page,
the 'First
Steps' icon,
links to the 'TriCore Getting Started' document. This is a good
starting point for exploring the capabilities
of the environment and the tools.

How to obtain a license key

TASKING products are protected with TASKING license management
software. You need a license key
when you install a TASKING product on a computer. When you order a
TASKING product from Altium or one of its
distributors, a license key will be sent to you by email or on paper.

See the Getting Started with the TASKING VX-toolset for TriCore
guide for
information on obtaining a license.