Using the builtin function __builtin_add_overflow_p in gcc

Question

I was wondering on how to use this function, because I get an error when I do this:

#define INT_ADD_OVERFLOW_P(a, b) \
__builtin_add_overflow_p (a, b, (__typeof__ ((a) + (b))) 0);
#include <stdio.h>
#include <assert.h>
__int main()
{
    int x1 = -1073741826;
    int y1 = -1073741826;
    int z1 = x1+y1; 
    INT_ADD_OVERFLOW_P ( x1,  y1);
    printf("%d\n",z1);
    return 0;
}

Compile_OUTPUT:

gcc -c -Wall -D DEBUG  tempFile.c
gcc tempFile.o -o tempFile
Makefile:8: recipe for target 'tempFile' failed//new error after update

Compile_ERROR:

tempFile.c: In function ‘main’:
tempFile.c:10:1: warning: implicit declaration of function        ‘__builtin_add_overflow_p’ [-Wimplicit-function-declaration]
tempFile.o: In function `main':
tempFile.c:(.text+0x44): undefined reference to `__builtin_add_overflow_p'
collect2: ld returned 1 exit status
make: *** [tempFile] Error 1

Here is a link to the functions I want to use:

https://gcc.gnu.org/onlinedocs/gcc/Integer-Overflow-Builtins.html

Here is the makefile that i'm using:

compiler=gcc
CFLAGS=-c -Wall -D DEBUG 
programname=tempFile

all: $(programname)

$(programname): $(programname).o
    $(compiler) $(programname).o -o $(programname)

$(programname).o: $(programname).c
    $(compiler) $(CFLAGS) $(programname).c

clean:
    rm *o $(programname)

There's your problem - those builtins were added in a later version. (5.something I think) — user253751, Jul 28 '16 at 02:21
Upgrading to ubuntu 16.04 to install gcc 5 will tell you how it goes — Eagle, Jul 28 '16 at 02:30
So I upgraded to 16.04, running gcc version 5.4.0 20160609 - Got a new error "Makefile:8: recipe for target 'tempFile' failed" added it to the question. I still also get the error undefined refence to __builtin_add_overflow_p — Eagle, Jul 28 '16 at 22:31

Maxim Pestryakov · Accepted Answer · 2016-11-25T22:17:52.347

6

__builtin_add_overflow_p is supported by GCC 7 that has not been released yet

edited Nov 25 '16 at 22:17

answered Nov 25 '16 at 22:06

Maxim Pestryakov

599
7
13

score 1 · Answer 2 · edited Aug 06 '16 at 01:48

1

So I figured out how to use the built-in functions. Instead of using __builtin_add_overflow_p I used __builtin_add_overflow

#include <stdio.h>
#include <assert.h>

int main(void)
{
  int x1 = -1073741826;
  int y1 = -1073741826;
  int z1 = x1 + y1; 
  int temp;

  printf("%d\n", __builtin_add_overflow(x1, y1, &temp));
  if (__builtin_add_overflow(x1, y1, &temp)) {
    printf("overflow detected");
  }
  printf("%d\n", z1);

  return 0;
}

edited Aug 06 '16 at 01:48

sigjuice

28,661
12
68
93

answered Aug 01 '16 at 02:45

Eagle

339
1
3
14

Can you explain the difference between the two calls? – 2501 Aug 01 '16 at 07:50
1

The built-in functions that ends with a p are similar to __builtin_add_overflow, __builtin_sub_overflow and __builtin_mul_overflow. The difference is that the functions that end with a p don't store the result of the arithmetic operation anywhere and the last argument is not a pointer, but some expression with integral type other than enumerated or Boolean type. Here is a link to integral types http://msdn.microsoft.com/en-us/library/exx3b86w%28v=vs.80%29.aspx – Eagle Aug 01 '16 at 10:00
1

I don´t see why this would be an answer. Your question asked for how to use one function, and your solution is using an other function which has a different definition? Put it as a comment to your question instead saying "not my problem anymore, but question remains". – Andreas Aug 05 '16 at 16:30

score 0 · Answer 3 · answered Mar 31 '23 at 09:40

You can also use __builtin_add_overflow_p to implement something a bit like a saturating addition:

#define sadd(a, b)                                             \
    ({                                                         \
        __auto_type _a = (a);                                  \
        __auto_type _b = (b);                                  \
        __builtin_add_overflow_p(_a, _b, _a) ? _a : (_a + _b); \
    })

Example:

uint8_t foo = 253;

foo = sadd(foo, 1); // foo = 254
foo = sadd(foo, 1); // foo = 255
foo = sadd(foo, 1); // foo = 255

This is using a GCC extension called Statement Expressions, and __auto_type is explained here https://gcc.gnu.org/onlinedocs/gcc/Typeof.html.

The call to __builtin_add_overflow_p is saying, if there would be an overflow from addition of a and b (the first 2 arguments), stored in a (the 3rd argument), return the original value of a, otherwise return the result of the addition between a and b.

You could also probably use __builtin_add_overflow if you added a 3rd variable c, and returned that if the result didn't overflow, otherwise return a.

Using the builtin function __builtin_add_overflow_p in gcc

3 Answers3