• Important information
• New features
• Known problems
• Program corrections
• User guide corrections
• Miscellaneous
• Release history

Important information

• ID code and system register setting
  From version 2.60 and later, setting the ID code bytes and system registers like MDES, OFS0 and OFS1, etc, is no longer done in the linker configuration files. Default values are set in the runtime libraries and if you want to override these, you do this on C or assembler level. See the Development Guide for detailed information.

• Binary compatibility
  The function calling convention in version 2.4x was changed to better match the Renesas ABI. In v2.5x, the function calling convention was changed again, this time due to changes in the ROPI implementation. This means that object modules produced with earlier versions of the compiler cannot be linked together with modules produced with version 2.4x and 2.5x, respectively.

New features

• None

Known Problems

• None

Program Corrections

• Compile result is not the same with same source/compiler options. [EW25510]
• The reserved parts of the NMI vector and the option-setting memory are zeroed, but should be all ones. [EW25513]

User guide corrections

• Intrinsic functions
  • __macw1
    Syntax: __macw1(short* data1, short* data2, unsigned long count);
    Description: Executes multiply-accumulate operation on 16-bit signed data values and returns the result as a 16-bit signed data value. Note that the operation result is rounded by using the RACW #1 instruction. The arguments data1 and data2 each specify the start address of a 16-bit signed data array. The argument count specifies the length of (number of elements in) the arrays.
  • __macw2
    Syntax: __macw2(short* data1, short* data2, unsigned long count);
    Description: Same functionality as __macw1 except that __macw2 is using the RACW #2 instruction.
  • __macl
    Syntax: short __macl(short* data1, short* data2, unsigned long count);
    Description: Executes multiply-accumulate operations on 16-bit signed data values and returns the result as a 32-bit signed data value. The arguments data1 and data2 each specify the start address of a 16-bit signed data array. The argument count specifies the length of (number of elements in) the arrays.
• Predefined preprocessor symbols
  • __RXV1
    Defined if RX V1 core is used (--core=rxv1).
  • __RXV2
    Defined if RX V2 core is used (--core=rxv2).
  • __BIG
    Defined if big-endian mode is used (--endian=b).
  • __LIT
    Defined if little-endian mode is used (--endian=l).
  • __DBL4
    Defined if 32-bit doubles are used (--double=32).
  • __DBL8
    Defined if 64-bit doubles are used (--double=64).
  • __INT_SHORT
    Defined if 16-bit integers are used (--int=16).
  • __FPU
    Defined if FPU is used (--no_fpu is not used).
• Compiler option --enum_is_int
  Syntax: --enum_is_int
  Description: Use this option to force the size of all enumeration types to be at least 4 bytes.
  Note: This option will not consider the fact that an enum type can be larger than an integer type. Prebuilt libraries are built without this option.

Miscellaneous

• Nothing

Release history

2.80.1 2015-06-30

Program corrections

• The use of the intrinsic function __illegal_opcode() results in an internal error. [EW25430]
• Subtracting one pointer from another sometimes causes an internal error. [EW25362]
• The compiler optimization technique constant propagation requires an extremely long compile time for certain code examples. [EW25298]
• An internal error is sometimes generated after an undefined section error "Error[As010]: Section name expected". [EW25135]

New features

• DSP intrinsic functions added
  Intrinsic functions for DSP multiply-accumulate operations have been added.

2.70.1 2015-02-23

Program corrections

• The development guide is using an incorrect interrupt vector table naming. [EW25153]
• Stack usage is calculated also for functions that are explicitly listed with the stack usage control directive exclude. [EW24936]
• The compiler does not check the MISRA-C:2004 rule 10.6 correctly. It bases the check on the usage of the constant instead of on the type of the constant. [EW24733]
• At high optimization, an increment of a pointer by a bit field causes a register variable to be destroyed. [EW25182]

New features

• The compiler can now optionally generate both position-independent code and/or position-independent data.
• The compiler optimizes for higher execution speed compared to the previous version.
• The C/C++ Development Guide, and C-SPY Debugging Guide have been updated to reflect the product changes.

2.60.5 2014-09-05

Program corrections

• The compiler will generate an internal error if a char or short variable is saturated. Example: [EW24945]

  short x;
  void restrict_x()
  {
    if(x < 12)
      x = 12;
    if(x > 2345)
      x = 2345;
  }

2.60.4 2014-09-02

Program corrections

• Only a NOP instruction is inserted instead of the actual delay loop if you use the intrinsic function __delay_cycles(). [EW24862]
• Saturation code for short and char was not handled by the compiler and therefore an internal error was generated. Example: short b = c > 0xfff ? 0xfff : c < 0 ? 0 : c; [EW24891]
• In rare cases the compiler optimizes two instructions to one by replacing the second instruction with a new one and then removing the first instruction. The error occurs when the new instruction uses a register that has been changed between the original first and second instruction. [EW24918]

2.60.2 2014-06-23

Program corrections

• The compiler marks main() as a call graph root. This leads to a warning and that main() stack usage is counted twice. [EW24676]

2.60.1 2014-04-15

Program corrections

• Multiplying two long variables into a resulting long long variable will in some cases destroy the contents of the two multiplied variables. [EW24574]
• In rare cases, a memory dependency problem in the compiler causes the same project built on two different computers to produce slightly different output. The reason is that a different amount of function inlining is performed by the compiler. The code is functionally correct in both cases. [EW24550]
• If arithmetic saturation is implemented and the saturation value is a multiple of two, incorrect code will be generated. [EW24390]
  //Example signed
  int signed_saturate(int i)
  {
    if( i > 1<<n-1)  //n is 2 to 31
      i = 1<<n-1;  // causes error
    if( i < -1<<n)
      i = -1<<n;  // causes error
    return i;
  }
  //Example unsigned
  unsigned int unsigned_saturate(unsigned int i)
  {
    if( i > 1<<n-1)  //n is 2 to 31
      i = 1<<n-1;  // causes error
    return i;
  }
  

New features

• Stack usage analysis
  With stack usage analysis enabled, a stack usage section will be added to the linker map file with listings of the maximum stack depth for each call graph root. The analysis process can be customized to take into account such constructs as calls via function pointers and recursion. The output can optionally be generated in XML format for post-processing activities.

2.50.1 2013-12-03

New features

• RXv2 core support
  Support for the new Renesas RXv2 core has been added. The RXv2 core is backward compatible with the RXv1 core, while delivering improved performance and reduced power consumption.

2.42.3 2013-10-18

Program corrections

• A problem in the optimizer will in rare cases cause the error CoreUtil/General]: signed not set when optimizing for size. [EW24030]

2.42.2 2013-06-26

Program corrections

• Error Pa128 (truncating cast in constant expression) is suppressable in some cases where doing so will result in an internal error. [EW23964]
• The combination having a volatile variable that is read but not used together with the common subexpression elimination optimization enabled can in rare cases result in incorrect code being generated. [EW23959]
• The error "Error[As025]: Limit exceeded" is in some cases generated when you have objects bigger than 64KBytes. [EW23958]
• For function calls where parameters are casted from float to unsigned int or unsigned long, the second parameter in the call can in some cases get an incorrect value. [EW24015]

2.42.1 2013-04-19

Program corrections

• At optimization level High, the compiler in some cases moves an ADD instruction to optimize away a compare instruction without checking if the source register is valid for the new location of the ADD instruction. [EW23881]
• Expressions including a function-local static variable (v) can be incorrectly optimized (on optimization level High), if v is initialized with a non-zero constant and every assignment to v assigns it another constant. [EW23856]
• A function call is in some cases optimized away when using optimization level High, favoring size (-Ohz), and the near data model. [EW23755]

2.41.2 2012-12-13

Program corrections

• Two nested loops where both loop variables were used in the same index expression in an array access or pointer indirection, and the variables were of a smaller type than the index type for the array or pointer type, could trigger an internal error. [EW23598]
• Reading and writing to the interrupt stack pointer via the intrinsic function _builtin_get_isp() no longer causes an internal error. [EW23638]

New features

• New core option for RX100
  

2.41.1 2012-11-27

New features

• Improved Source Browser performance
  The Source Browser now consumes less resources, which leads to better performance compared to the previous version.
• Improved optimization
  The compiler optimizes for higher execution speed compared to the previous version.
• Extended inline assembler
  The inline assembler has been extended with the possibility to take input arguments, give return values, and read or write to C symbols. The syntax is similar to the syntax used in GNU GCC.

2.40.1 2012-06-01

New features

• Support for multiple inheritance
  The compiler now supports the C++ feature Multiple inheritance.

• Improved optimization
  The compiler optimizes both for smaller code size and higher execution speed, compared to the previous version.

Program corrections

• When two variables with absolute locations are defined in different modules, the addresses no longer get reversed. [EW23236]

2.30.1 2011-06-28

Program corrections

• The total number of errors and warnings presented by the compiler was doubled compared to the real amount. [EW22505]
• In an expression on the form u.c[2]=(unsigned char)*p++;, *p was in some cases incorrectly treated as signed. [EW22504]
• Under high optimization, a sign extending cast could be removed even when required for correct results. [EW22445]
• 32-bit floating point comparisons with zero no longer exclude 0.0 from the expected range if subnormal numbers are disabled. [EW22389]
• A struct that was member of another struct, smaller than or equal to 4 bytes and passed as a parameter could in some cases lead to incorrect code and trigger a warning. [EW22985]

2.20.4 2011-04-08

New features

• Under high optimization (-Oh or -Ohs) and in combination with the option --align_func=4, performance has been improved by more efficient alignment of internal labels.

Program corrections

• The intrinsics __get_interrupt_level() and __set_interrupt_level() operated on bits 24 to bit 26 only and not bit 23. [EW22258]
• At optimization level high, MOV.L instead of MOVU.W was sometimes used to copy 16-bit return values into registers which lead to that the high bits were not cleared as required. This has been corrected. [EW22267]
• In some cases the compiler instruction scheduler moved instructions over _disable_interrupt() and _enable_interrupt() which is not allowed. This has been corrected. [EW22272]
• Calls to functions that return small structs with alignment less than 4 sometimes lead to an internal error in the compiler. [EW22287]
• Loops accessing special function registers (SFRs) could be optimized into SMOVF or SSTR instructions, leading to unexpected program behavior because of unpredictable access byte order. [EW22345]

2.20.3 2011-02-01

Program corrections

• 8- and 16-bit function parameters and return values were sometimes not properly extended as required by the RX ABI. This has been corrected. [EW22172]

2.20.1 2010-12-20

New features

• Position-independent code and data (ropi)
  The compiler can now optionally generate position-independent code and position-independent data.

• DLIB multithreaded support
  The DLIB library now has improved support for threaded environments. See DLIB multi-threaded support for more information.

• Improved optimization
  Code generated for long long, double and floating-point operations is now several times faster compared to the previous version. Some optimizations that are beneficial for benchmark suites like Coremark and Dhrystone have also been implemented but not to the extent that code size grows dramatically and therefore cannot be used in real applications.

Program corrections

• Left shift on short and char variables did not cast back the result to the original data types. [EW21972]
• Empty switch case bodies could generate an internal error on optimization level low. [EW21808]

2.10.1 2010-06-02

New features

• Renesas RX ABI compliance
  The IAR compiler, assembler, linker and debugger now comply on C level with Renesas ABI (Application Binary Interface), based on ELF/DWARF. An advantage with this compliance is that modules produced with the Renesas toolchain can be linked with IAR Embedded Workbench for RX.
• C99 compliance
  The IAR C/C++ Compiler for RX now supports the ISO/IEC 9899:1999 standard.

Program corrections

• Returning from an interrupt function could cause undefined behavior if the function used only one register. [EW21599]
• An interrupt function that only used one register could generate an illegal instruction, POPM R1,R1. [EW21757]

1.12 2010-01-15

• Code generation for string move functions was not correct. This has now been corrected. [EW21360]

1.11 2009-10-05

1.10 2009-05-05

• Initial release.