#define INT_MIN     (-2147483647 - 1)

1
2
3
4
5
6
7
8
9
10
11
12
13

#include <stdio.h>
#include <limits.h>
#include <float.h>
 
int main(void)
{
	if (-2147483648 > 0)     printf("positive\n");
	if (-2147483647 - 1 < 0) printf("negative\n");
	if (INT_MIN == -INT_MIN) printf("equal\n");
	if (FLT_MIN > 0)         printf("floating\n");
 
	return 0;
}

19 thoughts on “INT_MIN”

1. mouser July 16, 2009 at 22:26

   nice!
   it took me a minute to realize you were saying that the root of the problem was that the POSITIVE value 2147483648 could not be stored as a (signed) int, and that this little bit of assymetry is the problem.
2. SteveJ July 17, 2009 at 14:12

   My favourite compiler does a good job of this:

   $ gcc signed.c -o signed
   signed.c: In function `main':
   signed.c:7: warning: this decimal constant is unsigned only in ISO C90
   signed.c:9: warning: integer overflow in expression
   
   $ ./signed
   positive
   negative
   equal
   floating
   
   $ gcc signed.c -o signed -std=c99
   signed.c: In function `main':
   signed.c:9: warning: integer overflow in expression
   
   $ ./signed
   negative
   equal
   floating
   

   So, the surprising standard behaviour gets a warning, and the unsurprising standard behaviour doesn’t, even with no warnings explicitly enabled.

   I was briefly surprised by FLT_MIN, but only because I never use it, so it wasn’t until I saw the answer that I remembered what it means
3. Jibz Post authorJuly 18, 2009 at 09:20

   gcc has some very good warnings on this example yes.

   Thanks for the reply.
4. Ruben July 18, 2009 at 15:47

   Tcc doesn’t complain at all. It apparantly simply let’s the value overflow, even though it claims to support most of C99:

   positive
   negative
   equal
   floating
5. Jibz Post authorJuly 18, 2009 at 18:15

   That is interesting, in C99 it should not print ‘positive’.

   Might be worth letting the developers know.
6. arobins July 19, 2009 at 09:20

   this was kind of funny to me. i ran this in windows on VC++ Express and on minGW. the assembly for each is what is interesting.

   minGW just decides to print them
   %%BEGIN minGW
   pushl %ebp
   movl %esp, %ebp
   subl $8, %esp
   andl $-16, %esp
   movl $0, %eax
   addl $15, %eax
   addl $15, %eax
   shrl $4, %eax
   sall $4, %eax
   movl %eax, -4(%ebp)
   movl -4(%ebp), %eax
   call __alloca
   call ___main
   movl $LC0, (%esp)
   call _printf
   movl $LC1, (%esp)
   call _printf
   movl $LC2, (%esp)
   call _printf
   movl $LC3, (%esp)
   call _printf
   movl $0, %eax
   leave
   ret
   %%END minGW

   CL decides to check but… it checks if the value in the register is equal to what is in the register???
   %%BEGIN CL.exe
   ; Line 7
   mov eax, 1 ; Sets the register to 1 then…
   test eax, eax ; Makes sure 1 is equal to 1
   je SHORT $LN4@main
   push OFFSET $SG2536
   call _printf
   add esp, 4
   $LN4@main:
   %%END CL.exe

   Nice trick.
7. Jibz Post authorJuly 22, 2009 at 11:45

   The test instruction performs a bit-wise and operation and sets the flags without modifying the operands.

   Testing a register against itself is a common idiom to check if the register is zero, probably mostly because it is shorter than a cmp.

   mov eax, 1 ; Sets the register to 1 then… test eax, eax ; Check if register is zero je SHORT $LN4@main ...

   So Visual C++ is being very very literal about translating the if statement directly to assembly instructions.

   Thanks for the reply, it is interesting to see what different compilers do.
8. mwb1100 October 27, 2009 at 08:37

   The assembly output from the MSVC example is likely the result of a non-optimized (debug) build. Generally the complier follows things very literally (so as not to confuse things when debugging – also to let you have the ability to set breakpoints at any point corresponding to the original source code).

   It’s never a great idea to look at the assembly output for a debug build and draw conclusions about the quality of code generation of the compiler.
9. Peter Hamilton September 8, 2011 at 01:19

   Running on a Mac only prints negative, equal and floating.

   melker:Programming peter$ gcc -v
   Using built-in specs.
   Target: i686-apple-darwin11
   Configured with: /private/var/tmp/llvmgcc42/llvmgcc42-2335.15~25/src/configure –disable-checking –enable-werror –prefix=/Developer/usr/llvm-gcc-4.2 –mandir=/share/man –enable-languages=c,objc,c++,obj-c++ –program-prefix=llvm- –program-transform-name=/^[cg][^.-]*$/s/$/-4.2/ –with-slibdir=/usr/lib –build=i686-apple-darwin11 –enable-llvm=/private/var/tmp/llvmgcc42/llvmgcc42-2335.15~25/dst-llvmCore/Developer/usr/local –program-prefix=i686-apple-darwin11- –host=x86_64-apple-darwin11 –target=i686-apple-darwin11 –with-gxx-include-dir=/usr/include/c++/4.2.1
   Thread model: posix
   gcc version 4.2.1 (Based on Apple Inc. build 5658) (LLVM build 2335.15.00)
   melker:Programming peter$ ./a.out
   negative
   equal
   floating
   melker:Programming peter$
10. Josh Haberman September 8, 2011 at 01:49

    This bit of asymmetry also leads to this interesting security implication: http://my.opera.com/taviso/blog/show.dml/639454

    (In short, (INT_MIN / -1) can crash your program with an exception, since the result can’t be represented in an integer. It’s an easy way to crash a program that does integer math on untrusted input.
11. sdfghj September 8, 2011 at 01:52

    print(“%d\n”, -2147483648 < 0);
    print("%d\n", (unsigned int)-2147483648 < 0);
    print("%d\n", (int)-2147483648 < 0);
    print("%d\n", (long)-2147483648 < 0);
    print("%d\n", (unsigned long)-2147483648 < 0);
    print("%d\n", -2147483647 – 1 < 0);

    When compiled with Ken Thompson's C compiler for the 386, the above program prints the following output:

    0
    0
    1
    1
    0
    1
12. foolhunger September 8, 2011 at 02:55

    Great! I have saw this on CSAPP before, and the C99 output surprised me:)
13. lowell September 8, 2011 at 03:32

    Clang in OS X Lion 10.7.2:

    $ clang signed.c -o signed -Wall
    $ ./signed
    negative
    equal
    floating
14. lowell September 8, 2011 at 03:34

    WTF; NM. This was on HN so I thought it was new; didn’t notice the 2009 dates on the comments or the post itself.
15. Jibz Post authorSeptember 8, 2011 at 07:35

    Thank you for the comments (even if the post is a few years old, I believe the issue remains).

    Peter, normally I would expect GCC to default to C89 (with extensions) which should show ‘positive’. I wonder if it being a LLVM version makes a difference?

    Josh, that is an interesting observation, thanks for the link!

    lowell, it looks like clang follows the C99 standard mostly, so the output is expected, but it is a bit surprising it does not produce any warnings at all.
16. Robin September 8, 2011 at 09:57

    @ Peter Hamilton

    Because you’re compiling it as a 64-bit application on your 64-bit OS. The article is pointing out a 32-bit problem. If you compile the source code with “-arch i386″, forcing it as a 32-bit executable, the test will work.
17. David September 8, 2011 at 10:09

    Typo: (-32766 – 1)
18. David September 8, 2011 at 10:10

    Oops. I need to read harder.

19. Pingback: Smashing the Stack, IO – Level 2 | A Tale of Glim