## Issues with Rounding in the GCC Implementation of the ISO 18037:2008 Standard Fixed-Point Arithmetic

Embedded systems are based on low-power, low-performance processors and can be found in various medical devices, smart watches, various communication devices, cars, planes, mobile phones and many other places. These systems come in a hardware and software package optimized for specific computational tasks and most commonly have real-time constraints. As these systems usually have energy usage and cost constraints too, sophisticated numerical hardware that can process floating-point data is not included, but rather only integer arithmetic, which is simpler in terms of area and power of the processors.

ISO 18037:2008 is a standard for embedded C programming language support. It lays out various rules that C compilers should support to make embedded systems easier to program using a high-level language. One of the most important definitions in this standard is *fixed-point arithmetic* data types and operations. Support for fixed-point arithmetic is highly desirable, since if it is not provided integers with scaling factors have to be used, which makes code hard to maintain and debug and most commonly requires assembler level changes or completely new implementations for each different platform.

The GCC compiler provides some support of the fixed-point arithmetic defined in this standard for ARM processors. However, in my recent technical report (https://arxiv.org/abs/2001.01496) I demonstrated various numerical pitfalls that programmers of embedded systems based on ARM and using GCC can get into. The issues demonstrated include

- larger than half machine epsilon errors in rounding decimal constants to fixed-point data types,
- errors in conversions between different data types,
- incorrect pre-rounding of arguments of mixed-format arithmetic operations before the operation is performed, and
- lack of rounding of the outputs of arithmetic operations.

These findings can be used to improve the accuracy of various embedded numerical libraries that might be using this compiler. To demonstrate one of the issues, here is a piece of test code:

The multiplication operation is a *mixed-format operation*, since it multiplies an *unsigned long fract* argument with an *accum* argument, therefore it is subject to prerounding of the *unsigned long fract* argument as described in the report. Since the comparison step in the* if ()* sees that the argument *a* is larger than zero and *b* larger than 1, the code is executed with a hope that *c* will not be set to zero. However, in the arithmetic operation, *a* is incorrectly pre-rounded to 0, which causes *c = 0*b*, an unexpected outcome and a bug that is hard to detect and fix.