In x86 assembly, the overflow flag is set when an `add` or `sub` operation on a signed integer overflows, and the carry flag is set when an operation on an unsigned integer overflows.

However, when it comes to the `inc` and `dec` instructions, the situation seems to be somewhat different. According to this [website](http://www.c-jump.com/CIS77/ASM/Flags/lecture.html), the `inc` instruction does not affect the carry flag at all.

But I can't find any information about how `inc` and `dec` affect the overflow flag, if at all.

Do `inc` or `dec` set the overflow flag when an integer overflow occurs? And is this behavior the same for both signed and unsigned integers?

============================= **EDIT** =============================

Okay, so essentially the consensus here is that INC and DEC should behave the same as ADD and SUB, in terms of setting flags, with the exception of the carry flag. This is also what it says in the Intel manual.

The problem is I can't actually reproduce this behavior in practice, when it comes to unsigned integers.

Consider the following assembly code (using GCC inline assembly to make it easier to print out results.)

```
int8_t ovf = 0;

__asm__
(
    "movb $-128, %%bh;"
    "decb %%bh;"
    "seto %b0;"
    : "=g"(ovf)
    :
    : "%bh"
);

printf("Overflow flag: %d\n", ovf);

```

Here we decrement a signed 8-bit value of -128. Since -128 is the smallest possible value, an overflow is inevitable. As expected, this prints out: `Overflow flag: 1`

But when we do the same with an *unsigned* value, the behavior isn't as I expect:

```
int8_t ovf = 0;

__asm__
(
    "movb $255, %%bh;"
    "incb %%bh;"
    "seto %b0;"
    : "=g"(ovf)
    :
    : "%bh"
);

printf("Overflow flag: %d\n", ovf);

```

Here I increment an unsigned 8-bit value of 255. Since 255 is the largest possible value, an overflow is inevitable. However, this prints out: `Overflow flag: 0`. 

Huh? Why didn't it set the overflow flag in this case?