Inconsistent results with < and <= in C with max and min ints

Question

I'm writing some C code to look at the bit representations of integers. In the process I found code that returns different results based on optimization settings. Am I just doing something wrong, or is this a compiler bug?

Here is the code:

#include <stdio.h>

int test(int x, int n)
{
  int TMin_n = -(1 << (n-1));
  int TMax_n = (1 << (n-1)) - 1;
  return x >= TMin_n && x <= TMax_n;
}

int main(){

    int x = 0x80000000;
    int n = 0x20;
    if(test(x,n)){
        printf("passes\n");
    }
    else{
        printf("fails\n");
    }
}

If I compile it this way I get a passing result

$ gcc tester.c -o tester
$ ./tester
passes

If I compile it this way I get a failing result

$ gcc -O1 tester.c -o tester
$ ./tester
fails

The problem is that

x <= TMax_n

is evaluating as false in the optimized case only.

Here is my platform details:

$ gcc --version
Configured with: --prefix=/Applications/Xcode.app/Contents/Developer/usr --with-gxx-include-dir=/usr/include/c++/4.2.1
Apple LLVM version 8.0.0 (clang-800.0.42.1)
Target: x86_64-apple-darwin16.4.0
Thread model: posix
InstalledDir: /Applications/Xcode.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin

Community · Accepted Answer · 2020-06-20 09:12:55Z

5

Your platform apparently uses 32 bit int type. 0x20 is 32, which means that 1 << (n-1) inside your function attempts to shift 1 by 31 bit. The behavior is undefined, since this expression has signed type (1 has type int) and value of 2³¹ is not representable in it.

6.5.7 Bitwise shift operators

4 The result of E1 << E2 is E1 left-shifted E2 bit positions; vacated bits are filled with zeros. [...] If E1 has a signed type and nonnegative value, and E1 × 2^E2 is representable in the result type, then that is the resulting value; otherwise, the behavior is undefined.

What you are observing is the consequences of that undefined behavior. There's nothing unusual in seeing its manifestations to depend on the compiler's optimization settings.

edited Jun 20, 2020 at 9:12

CommunityBot

11 silver badge

answered Feb 3, 2017 at 1:40

AnT stands with Russia

323k44 gold badges548 silver badges793 bronze badges

Sign up to request clarification or add additional context in comments.

2 Comments

AnT stands with Russia Over a year ago

@djp3: C language does not have such thing as "just shift the bits". As you see above the << operator is defined as multiplication by a power of 2. And if that multiplication overflows, the behavior is undefined. More precisely, if you want to "just shift the bits" make sure to use unsigned types as operands. With signed types once you start shifting out of (or into) the sign bit, things typically fall apart. Left shift is undefined, right shift is implementation-defined. On C++ side of things C++14 switched to implementation-defined for this left shift. But C keeps it undefined for now.

AnT stands with Russia Over a year ago

@djp3: Note also that even if you compiled this as C++14 and ended up with the expected signed 0x80000000 after the shift, the subsequent unary - or binary - 1 would still overflow things and trigger undefined behavior.

Collectives™ on Stack Overflow

Inconsistent results with < and <= in C with max and min ints

1 Answer 1

2 Comments

Your Answer

Hot Network Questions

Collectives™ on Stack Overflow

1 Answer 1

2 Comments

Your Answer

Sign up or log in

Post as a guest

Related