TASKING TriCore v6.2r2  Inspector v1.0r6
Release Note

Scope

This release note covers the initial features of the TASKING TriCore v6.2r2 Inspector v1.0r6.

For release notes prior to v1.0r6, please visit the TASKING TriCore Inspector support website.

Contents

Important Notices

TriCore v6.2r2 Inspector v1.0r6 is based on TASKING VX-toolset for TriCore v6.2r2 patch 2. Inspector operates identically to the VX-toolset (except for the issue detection) down to the linker.

Generation of the final executable image by the linker has been disabled.

Components of the VX-toolset dealing with the final executable image, library sources and examples have been removed from the product.

Components modified for the issue detection have been renamed with prefix insp_ (insp_cctc, insp_cptc, insp_ctc, insp_astc, insp_ltc).

You can use the TASKING Inspector v1.0r6 for the TASKING VX-toolset for TriCore v6.2r2 product and any of the patches, with the following restrictions:

The inspector components now also silently accept the given detection options meant for other components. This prevents errors when e.g. passing an option file to all tools with a list of --detect or --ignore detector options.

Build Numbers

All executable files in this release have the following build number: Build 24041646.

Base Features

Detection options

By default, Inspector detects and reports full set of supported issues. The following options allow the user to customize this set:

--ignore=<issue-id>,... - disables detection of specified issues.

--detect=<issue-id>,... - disables detection of all issues and enables detection of specified issues only.

These options are supported by the Control Program, C/C++ Compiler, Assembler and Linker. Issue ID corresponds to issue's identification on the TASKING Issue Portal.

Detection messages

Inspector indicates issue detection by producing a warning message in two possible ways:

1. Definite detection.

Reported when Inspector can guarantee by detector's construction that the processed code is affected by the triggered issue. Note that the affected code may still be removed from the final executable image by subsequent optimizations or linker - this requires manual verification.

Example: ctc W999: [25/12] [INSP] detected occurrence of issue TCVX-44082.

2. Potential detection.

Reported when the issue is triggered, but Inspector can not guarantee that the processed code has been affected. Location and/or some additional information will be reported to facilitate verification by the user.

Example: ctc W998: [10/29] [INSP] detected potential occurrence of issue TCVX-43595.

3. No detection.

No definite or potential issues detected for the enabled list of detectors.

Example: [INSP] No definite or potential issues detected for the enabled list of detectors

Detection by assembly comparison

Some potential detectors produce a lot of false positives. To narrow the processing, assembly comparison mode is introduced.

--detect-asm=<issue-id> - with this option Inspector only detects a single specified issue.

After initial potential detection Inspector generates two instances of assembly code - affected and not affected by the issue.

If the comparison of these generated assembly files produces any meaningful difference, Inspector reports it and indicates locations of the generated files for the further analysis.

Message logging

Inspector supports separate logging of detection messages.

--insp-log=<file> - with this option all detection messages are duplicated into the specified file.

The log file is written in append mode and clearing it at the right moment is your responsibility

The logging mechanism supports concurrent writing for the multi-threaded build, but file locking over network is unreliable, so it shouldn't be used with a remotely located log file.

Issues Detected in v1.0r6

DetectorSummarySIL
level
Inspector
component(s)
Assembly
comparison
Issue
detection
TCVX-34183Assembler should by default make code sections at least 2 byte alignedSIL-2insp_ltcDefinite
TCVX-39025LSL: prevent an allocation of the user stack in the PCP memorySIL-2insp_ltcDefinite
TCVX-40469Linker allows cloned sections outside the available DSPR0 memory rangeSIL-2insp_ltcDefinite
TCVX-40928AURIX multi-core: hex file does not contain code for cloned functions in ROMSIL-2insp_ltcDefinite
TCVX-41279Issues with designated initializers for an element of an array of structsSIL-2insp_ctcPotential
TCVX-43102Optimization of struct return may lead to overlapping struct copySIL-2insp_ctcPotential
TCVX-43123Assembler astc --core=tc1.6.2 silently processed deprecated instruction mulms.hSIL-2insp_astcDefinite
TCVX-43189Memory settings for DFLASH for TC21x and TC22x are wrongSIL-2insp_ltcDefinite
TCVX-43195Linker misplaces .alignment_protection sections in reserved memory or a reserved section without noticeSIL-2insp_ltcDefinite
TCVX-43219Control program silently changes floating-point settings when --eabi-compliant option is usedSIL-2insp_cctcDefinite
TCVX-43543Sizeof operator applied to a VLA involving variable post-modification causes wrong codeSIL-2insp_ctcPotential
TCVX-43546Linker does not insert alignment_protection sections when a group includes sections with a different alignmentSIL-2insp_ltcDefinite
TCVX-43579Incorrect alignment for bit-field of size 0 with --eabi=-char-bitfieldSIL-2insp_ctcDefinite
TCVX-43580Alignment for bit-field of size 0 does not conform to the TriCore EABISIL-2insp_cptc,
insp_ctc
Definite
TCVX-43587GLO tracker optimization problem for unitialized variableSIL-2insp_ctcPotential
TCVX-43595LSL reserved sections may be selected by select statements resulting in a corrupt internal linker stateSIL-2insp_ltcDefinite
TCVX-43610Copy table in output section overwritten by next section in output sectionSIL-2insp_ltcPotential
TCVX-43696Reading elements of a const aggregate object as a larger type may result in an incorrect value.SIL-4insp_ctcDefinite
TCVX-43704Non justified if condition optimizationSIL-3insp_ctcPotential
TCVX-43855Bitfield of type "short int" or "long int" is treated as unsignedSIL-2insp_ctcDefinite
TCVX-43868Run-time error for double _Complex expression passing to a functionSIL-3insp_ctcDefinite
TCVX-43893C compiler omits value assignment to pointer type function argument with forward store optimization enabledSIL-4insp_ctcPotential
TCVX-43913Compile-time concatenation of character string literal with unicode string literal failsSIL-2insp_ctcDefinite
TCVX-43915Unroll small loops optimization leads to wrong code when speed tradeoff -t0 usedSIL-3insp_ctcDefinite
TCVX-43916C compiler - Generic Assembly Code optimization leads to false array index location in loopSIL-4insp_ctcDefinite
TCVX-43928Incorrect reordering of volatile memory readsSIL-4insp_ctcPotential
TCVX-43980Linker may hang when the size of an output section is at least 2 MBSIL-2insp_ltcDefinite
TCVX-43986AURIX 2G LSL files allow duplicate TriCore vector handlers to be located in SCR xramSIL-2insp_ltcPotential
TCVX-43994Linker ltc allows duplicate interrupt vectors to be located in vector tableSIL-3insp_ltcPotential
TCVX-43998Invalid constant propagation with tripple indirectionSIL-2insp_ctcPotential
TCVX-44008Include file may be skipped when same filename is included from different directoriesSIL-2insp_ctc,
insp_ltc
Definite
TCVX-44014Missing initialization for local variable in a specific test caseSIL-3insp_ctcPotential
TCVX-44043Incorrect conversion of _Complex type to _BoolSIL-3insp_ctcMixed
TCVX-44050Linker inserts section in an ordered, contiguous, fill groupSIL-2insp_ltcPotential
TCVX-44077C compiler generates malloc call for variable length arraySIL-2insp_ctcDefinite
TCVX-44082Intrinsics __extracthwN and __extractbbyteN may return wrong resultSIL-3insp_ctcDefinite
TCVX-44102Loop invariant code optimization issueSIL-3insp_ctcPotential
TCVX-44201Linker - clone .text .clone code sections missing in copytable when using --non-romable optionSIL-2insp_ltcDefinite
TCVX-44218Large floating-point numbers become zero when converted to _Float16SIL-3insp_ctcPotential
TCVX-44224Wrong result multiplying two INIFINITY values when using software floating-point librarySIL-3insp_ctcPotential
TCVX-44237Illegal double word access to SFR register rangeSIL-3insp_ctcPotential
TCVX-44257Compiler violates EABI due to 4 byte user stack frame generationSIL-3insp_ctcDefinite
TCVX-44267Linker: option --whole-archive ignores object modules without exported symbolsSIL-2insp_ltcDefinite
TCVX-44278C++ compiler: generated code results in address 0x0000000 access causing bus trapSIL-2insp_cptcPotential
TCVX-44309MISRA C 2012 rule 10.4 checker reports false positive and fails to detect a violationSIL-3insp_ctcPotential
TCVX-44339Subnormal values may incorrectly compare equal to zeroSIL-3insp_ctcPotential
TCVX-44383For non-trapping floating point comparisons: NaN == NaN incorrectly returns trueSIL-3insp_ctcPotential
TCVX-44387Erroneous code in code compaction function leads to invalid function parameterSIL-3insp_ctcPotential
TCVX-44393Compiler issues double word accesses for data located in MCS memorySIL-3insp_ctcPotential
TCVX-44400Wrong value is loaded into a 48-bit struct if used as a member of a larger 64-bit structSIL-3insp_ctcPotential
TCVX-44407C compiler front-end may produce imprecise FP result (±1 bit difference)SIL-4insp_ctc,
insp_ltc
Potential
TCVX-44417Compiler generates wrong code for loops with 64-bit iteratorsSIL-2insp_ctcPotential
TCVX-44419Linker does not insert alignment_protection section when copy_unit is greater than 1SIL-2insp_ltcPotential
TCVX-44421Conversion of float to integer raises "Overflow" instead of "Invalid operation" exceptionSIL-3insp_ctcPotential
TCVX-44423libfprt: subnormal values incorrectly compare equal to zeroSIL-3insp_ctcPotential
TCVX-44426FPU version of C library is not selected with control program option --fp-model=StSIL-2insp_cctcDefinite
TCVX-44441Incorrect use of a loop instructionSIL-3insp_ctcDefinite
TCVX-44443Intrinsics __getbyteN and __gethwN may return wrong resultSIL-3insp_ctcDefinite
TCVX-44453Incorrect propagation of __pure__ function call resultSIL-3insp_ctcDefinite
TCVX-44461No error on narrowing conversion from char to boolSIL-2insp_cptcPotential
TCVX-44522The __dsync() intrinsic does not always work as a memory fenceSIL-3insp_ctcPotential
TCVX-44541FP library: QNAN used in IEEE 754 arithmetic operations and in IEEE 754 unordered-quiet predicates leads to incorrect raising of FE_INVALID exceptionSIL-2insp_ctcPotential
TCVX-44642Common subexpression elimination optimization may violate #pragma STDC FENV_ACCESS ONSIL-3insp_ctcPotential
TCVX-44645TriCore compiler may generate double word access instructions to peripheral memorySIL-3insp_ctcPotential
TCVX-44670Type conversions involving _Bool may produce wrong resultSIL-3insp_ctcPotential
TCVX-44674The address values for FFT Accelerator in register files for tc26xb are incorrectSIL-2insp_ctc,
insp_astc,
insp_ltc
Mixed
TCVX-44677Erroneous code ignoring a break condition in an endless loopSIL-3insp_ctcDefinite
TCVX-44684Erroneous code generated using generic assembly code optimizationsSIL-3insp_ctcDefinite
TCVX-44711Linker segmentation fault on very long symbol namesSIL-2insp_ltcDefinite
TCVX-44737Compiler generates wrong codeSIL-3insp_ctcPotential
TCVX-44738C compiler: wrong code generation for float-to-int conversion when using #pragma STDC FENV_ACCESS ON: no FE_INVALID is raisedSIL-2insp_ctcPotential
TCVX-44743Control flow simplification optimization may violate #pragma STDC FENV_ACCESS ONSIL-3insp_ctcPotential
TCVX-44744Constant propagation optimization may violate #pragma STDC FENV_ACCESS ONSIL-3insp_ctcPotential
TCVX-44751Incorrect optimization of left-shift operatorSIL-3insp_ctcDefinite
TCVX-44759C compiler: incorrect optimization of conditional multiple variable accessSIL-3insp_ctcDefinite
TCVX-44769Conversion double-to-float may produce 0 instead of FLT_MINSIL-3insp_ctcPotential
TCVX-44776Function @FLD accepts negative arguments with undefined behaviorSIL-2insp_astcDefinite
TCVX-44792Erroneous code generation due to loop fusion optimizationSIL-3insp_ctcDefinite
TCVX-44793C compiler: missing truncation for cast that is converted to _BoolSIL-3insp_ctcPotential
TCVX-44796FPU instructions may corrupt 64-bit integer computationsSIL-4insp_ctcPotential
TCVX-44802Non EABI compliant bitfield offset used in a struct with a structsize larger than 32 bitSIL-4insp_ctcMixed
TCVX-44808C compiler: incorrect integer promotion using expression simplification optimizationSIL-3insp_ctcPotential
TCVX-44817DSP-C: operations on __sfract / __wrap __sfract may produce incorrect resultsSIL-4insp_ctcPotential
TCVX-44836Missing zero-extend for indirect store to _Bool automatic variableSIL-4insp_ctcDefinite
TCVX-44839DSP-C: Constant folding involving fixed-point types may produce incorrect resultsSIL-4insp_ctcMixed
TCVX-44840C compiler: Incorrect CSE of VLA size expressionSIL-3insp_ctcDefinite
TCVX-44843C compiler: unexpected "Assertion failed" when using _Alignas for an object with block scopeSIL-3insp_ctcDefinite
TCVX-44846C compiler: flexible array member initialization: diagnostics may be missingSIL-2insp_ctcMixed
TCVX-44878Evaluation of floating expressions involving NaN may produce wrong resultsSIL-4insp_ctcPotential
TCVX-44901FP library: incorrect missing FE_INVALID exceptionSIL-2insp_ctcPotential
TCVX-44903Compiler overwrites a complete byte in a bitstruct whereas only two bits are modifiedSIL-3insp_ctcDefinite
TCVX-44907Wrong code generation for an if-else statementSIL-3insp_ctcPotential
TCVX-44912Optimization ignores __weak__ attribute in the codeSIL-3insp_ctcPotential
TCVX-44913Erroneous code generated for C++ code using __disable_and_save and __restore intrinsicsSIL-4insp_ctcPotential
TCVX-44935User stack demand higher than calculated by the C compilerSIL-2insp_ltcPotential
TCVX-44959Control program: incorrect handling of -L option without argumentSIL-2insp_cctcDefinite
TCVX-45025C Compiler: _Bool - incorrect expression evaluationSIL-3insp_ctcDefinite
TCVX-45026Compiler conducts a signed division instead of an unsigned one in a specific use caseSIL-3insp_ctcDefinite
TCVX-45028C compiler ignores cast in a specific use case for a function return valueSIL-4insp_ctcPotential
TCVX-45041Erroneous code when loading a _Bool type variable into a char type using a _Bool pointer in an inline functionSIL-3insp_ctcPotential
TCVX-45069Flow optimization causes missing read operationSIL-4insp_ctcPotential
TCVX-45074Wrong ABS pattern optimization for float or doubleSIL-3insp_ctcDefinite
TCVX-45080Invalid strength reduction for subscript with unsigned wraparoundSIL-3insp_ctcPotential
TCVX-45091Wrong bit-field alignment for a short type member of a structSIL-4insp_ctcMixed
TCVX-45097C compiler generates incorrect array index valuesSIL-3insp_ctcDefinite
TCVX-45104Loop invariant code optimization issueSIL-3insp_ctcPotential
TCVX-45105Wrong iterator values after jumping into loopSIL-3insp_ctcPotential
TCVX-45112Memory access out of bounds due to a missing conversion of the loop incrementSIL-3insp_ctcDefinite
TCVX-45113Signed instead of unsigned division/moduloSIL-3insp_ctcDefinite
TCVX-45115Erroneous code in a specific switch caseSIL-3insp_ctcPotential
TCVX-45118Forward store optimization for weak variable causes NULL pointer dereferenceSIL-3insp_ctcPotential
TCVX-45146Compiler generates ld.da/st.da instructions for copying 8-byte structs in peripheral memorySIL-3insp_ctcPotential
TCVX-45186Linker buffer overflow triggered by very long symbol namesSIL-2insp_ltcDefinite
TCVX-45188Invalid floating-point transformation x - x == 0SIL-2insp_ctcPotential
TCVX-45198C compiler: missing cast to shortSIL-2insp_ctcPotential
TCVX-45201Erroneous code due to a missing cast in a specific use caseSIL-3insp_ctcDefinite
TCVX-45204Erroneous spilling of 64-bit variablesSIL-4insp_ctcDefinite
TCVX-45206Incorrect sign extension for compound operation on bit-field with -OE and --eabi=CDSIL-3insp_ctcPotential
TCVX-45218Erroneous code for do-while loopSIL-3insp_ctcPotential
TCVX-45234C Compiler: initialization of an automatic struct member removed by optimizationsSIL-3insp_ctcDefinite
Notes

Issues Not Detected in v1.0r6

These issues have been deemed impossible to detect in any meaningful way during compilation. User manual contains a detailed description of the situation when the issue might occur and how to prevent it.

Fixed Issues in v1.0r6

License Information

TASKING products are protected with TASKING license management software.

License key

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

See the TASKING License Management (TLM) Support page for information on obtaining a license.

Improved parallel process license handling

Some TASKING licenses can be limited to a maximum number of parallel processes per user (seat). When the maximum number of parallel processes is reached a new client process is set to waiting until the number of running client processes under the same license seat is below the process limit.

You can set the TSK_PROCESS_WAIT option in licopt.txt, or as an environment variable, to the parallel process time-out (default: unlimited). This specifies the number of seconds the system is allowed to wait for a process to run if the maximum number of parallel processes permitted by the license is already running.

Improved verbose logging

You can set the TSK_LOG_VERBOSE option in licopt.txt, or as an environment variable, to different verbose levels. With level 3 or higher, detailed license configuration information is shown, which is useful for debugging licensing problems. For example, it shows the environment variables or options used, the license key and the search path.

License pool mechanism

You can now define a named pool of specific licenses on the local license server.

A license pool is useful to specify that the licenses for one or more products shall be grouped together. This can be the case for example when your license agreement has constraints on geographical location, such as a single site license, country license or continental license. In that case you can put all product licenses that are allowed to be used by a specific location into a license pool.

Pool names for TASKING products released after March 2023 have the syntax POOL-name, where the name is free to choose from 1 up to 14 characters. Pool names are also supported with existing TASKING products, as long as you use the new local license server and specify the pool names in the fixed format POOL-xxxx-xxxx-xxxx.
Note that you also need to use this fixed pool name format if you are mixing older and newer TASKING products.

The PRODUCT keyword has been deprecated, but still works for backwards compatibility.

Support for wait for a free license

You can now set the TSK_LICENSE_WAIT option in licopt.txt to a configurable time period to wait for a free license seat to become available instead of directly terminating when a license request is denied.