[Bug libc/29313] New: MIN/MAX macros can cause double evaluation of arguments

[Bug libc/29313] New: MIN/MAX macros can cause double evaluation of arguments

[gkoumplias at gmail dot com]

https://sourceware.org/bugzilla/show_bug.cgi?id=29313

            Bug ID: 29313
           Summary: MIN/MAX macros can cause double evaluation of
                    arguments
           Product: glibc
           Version: 2.36
            Status: UNCONFIRMED
          Severity: normal
          Priority: P2
         Component: libc
          Assignee: unassigned at sourceware dot org
          Reporter: gkoumplias at gmail dot com
                CC: drepper.fsp at gmail dot com
  Target Milestone: ---

* MIN, MAX macros as defined in misc/sys/param.h
https://sourceware.org/git/?p=glibc.git;a=blob_plain;f=misc/sys/param.h;hb=HEAD
can cause the double evaluation of one of the passed in arguments.
Currently MAX is defined as:
#define MAX(a,b) (((a)>(b))?(a):(b))
This will evaluate the maximum argument twice.

* A test case to reproduce this would go like this:
int a = 1000;
int b = 10;
MAX(a++, b++) ;
// This will fail as a will be 1002 due to double evaluation by the MAX macro
EXPECT_EQ(a, 1001)

* solution
#define max(a,b) \
   ({ __typeof__ (a) _a = (a); \
       __typeof__ (b) _b = (b); \
     _a > _b ? _a : _b; })

* A discussion (and a solution) for the matter can be found here
https://stackoverflow.com/questions/3437404/min-and-max-in-c


Thanks

-- 
You are receiving this mail because:
You are on the CC list for the bug.

[Bug libc/29313] MIN/MAX macros can cause double evaluation of arguments

[schwab@linux-m68k.org]

https://sourceware.org/bugzilla/show_bug.cgi?id=29313

Andreas Schwab <schwab@linux-m68k.org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
             Status|UNCONFIRMED                 |RESOLVED
         Resolution|---                         |WORKSFORME

--- Comment #1 from Andreas Schwab <schwab@linux-m68k.org> ---
The non-standard header <sys/params.h> is copied directly from BSD.  Don't use
it.

-- 
You are receiving this mail because:
You are on the CC list for the bug.

[Bug libc/29313] MIN/MAX macros can cause double evaluation of arguments

[adhemerval.zanella at linaro dot org]

https://sourceware.org/bugzilla/show_bug.cgi?id=29313

Adhemerval Zanella <adhemerval.zanella at linaro dot org> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |adhemerval.zanella at linaro dot o
                   |                            |rg

--- Comment #2 from Adhemerval Zanella <adhemerval.zanella at linaro dot org> ---
(In reply to Andreas Schwab from comment #1)
> The non-standard header <sys/params.h> is copied directly from BSD.  Don't
> use it.

Can't we do better? We can use the __typeof__ to avoid double evaluation at
least for gcc/clang.

-- 
You are receiving this mail because:
You are on the CC list for the bug.

[Bug libc/29313] MIN/MAX macros can cause double evaluation of arguments

[goldstein.w.n at gmail dot com]

https://sourceware.org/bugzilla/show_bug.cgi?id=29313

Noah Goldstein <goldstein.w.n at gmail dot com> changed:

           What    |Removed                     |Added
----------------------------------------------------------------------------
                 CC|                            |goldstein.w.n at gmail dot com

--- Comment #3 from Noah Goldstein <goldstein.w.n at gmail dot com> ---
(In reply to Vasilis Gkoumplias from comment #0)
> * MIN, MAX macros as defined in misc/sys/param.h
> https://sourceware.org/git/?p=glibc.git;a=blob_plain;f=misc/sys/param.h;
> hb=HEAD
> can cause the double evaluation of one of the passed in arguments.
> Currently MAX is defined as:
> #define MAX(a,b) (((a)>(b))?(a):(b))
> This will evaluate the maximum argument twice.
> 
> * A test case to reproduce this would go like this:
> int a = 1000;
> int b = 10;
> MAX(a++, b++) ;
> // This will fail as a will be 1002 due to double evaluation by the MAX macro
> EXPECT_EQ(a, 1001)
> 
> * solution
> #define max(a,b) \
>    ({ __typeof__ (a) _a = (a); \
>        __typeof__ (b) _b = (b); \
>      _a > _b ? _a : _b; })
> 
> * A discussion (and a solution) for the matter can be found here
> https://stackoverflow.com/questions/3437404/min-and-max-in-c
> 
I don't think we can change the existing macros to that because
they will no longer be usable outside of functions.

#define MAX(x, y) ((x) > (y) ? (x) : (y))

#define max(a, b)                                                             
\
    ({                                                                        
\
        __typeof__(a) _a = (a);                                               
\
        __typeof__(b) _b = (b);                                               
\
        _a > _b ? _a : _b;                                                    
\
    })


enum { A = 1, B = 2 };

// Okay
enum { C = MAX(A, B) };

// Compile error
enum { D = max(A, B) };


> 
> Thanks

-- 
You are receiving this mail because:
You are on the CC list for the bug.