TASKING TriCore v6.3r1  Inspector v1.0r5 Release Note

Scope

This release note covers the initial features of the TASKING TriCore v6.3r1 Inspector v1.0r5.

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

Contents

Important Notices

TriCore v6.3r1 Inspector v1.0r5 is based on the TASKING VX-toolset for TriCore v6.3r1 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.0r5 for the TASKING VX-toolset for TriCore v6.3r1 product and any of the patches, with the following restrictions:

Build Numbers

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

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: [7/12] [INSP] detected occurrence of issue TCVX-44043.

2. Potential detection.

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

Example: ltc W998: [2/51] [INSP] detected potential occurrence of issue TCVX-43994.

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 the 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 should not be used with a remotely located log file.

Issues Detected in v1.0r5

DetectorSummarySIL
level
Inspector
component(s)
Assembly
comparison
Issue
detection
TCVX-39025LSL: prevent an allocation of the user stack in the PCP memorySIL-2insp_ltcDefinite
TCVX-39753Call graph not correct for aliasesSIL-2insp_ctcPotential
TCVX-40928AURIX multi-core: hex file does not contain code for cloned functions in ROMSIL-2insp_ltcDefinite
TCVX-43123Assembler astc --core=tc1.6.2 silently processed deprecated instruction mulms.hSIL-2insp_astcDefinite
TCVX-43994Linker ltc allows duplicate interrupt vectors to be located in vector tableSIL-3insp_ltcPotential
TCVX-44077C compiler generates malloc call for variable length arraySIL-2insp_ctcDefinite
TCVX-44201Linker - clone .text .clone code sections missing in copytable when using --non-romable optionSIL-2insp_ltcDefinite
TCVX-44224Wrong result multiplying two INIFINITY values when using software floating-point librarySIL-3insp_ctcPotential
TCVX-44231Wrong sizeof result for atomic_flag typeSIL-3insp_cptcDefinite
TCVX-44237Illegal double word access to SFR register rangeSIL-3insp_ctcPotential
TCVX-44245C compiler: wrong code generation when using packed structures with members of 16-bit signed typesSIL-3insp_ctcPotential
TCVX-44255C compiler: wrong code generation when using packed structures with some members declared as bit fieldsSIL-3insp_ctcMixed
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-44437Incorrect code for branch target align optimization when tail merging optimization activeSIL-3insp_ctcDefinite
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-44545Overlapping sections created when a reserved section is used with a memory fill entrySIL-2insp_ltcDefinite
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-44753Atomic load is removed in some casesSIL-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_ctcDefinite
TCVX-44872Compiler ignores variable value change after this has been passed by reference in a function callSIL-4insp_ctcPotential
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-45100MISRA global rules are not checked when only one module is suppliedSIL-3insp_ctcDefinite
TCVX-45101An atomic_flag type variable (stdatomic.h) ends up in cached memorySIL-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.0r5

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.0r5

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.