How to compute the integer absolute value

If you are not allowed to use the minus sign you could do something like this:

int absVal(int x) {
  return ((x >> 31) + x) ^ (x >> 31);
}

For assembly the most efficient would be to initialize a value to 0, substract the integer, and then take the max:

pxor mm1, mm1 ; set mm1 to all zeros
psubw mm1, mm0 ; make each mm1 word contain the negative of each mm0 word
pmaxswmm1, mm0 ; mm1 will contain only the positive (larger) values - the absolute value

In C#, you can implement abs() without using any local variables:

public static long abs(long d) => (d + (d >>= 63)) ^ d;

public static int abs(int d) => (d + (d >>= 31)) ^ d;

Note: regarding 0x80000000 (int.MinValue) and 0x8000000000000000 (long.MinValue):

As with all of the other bitwise/non-branching methods shown on this page, this gives the single non-mathematical result abs(int.MinValue) == int.MinValue (likewise for long.MinValue). These represent the only cases where result value is negative, that is, where the MSB of the two's-complement result is 1 -- and are also the only cases where the input value is returned unchanged. I don't believe this important point was mentioned elsewhere on this page.

The code shown above depends on the value of d used on the right side of the xor being the value of d updated during the computation of left side. To C# programmers this will seem obvious. They are used to seeing code like this because .NET formally incorporates a strong memory model which strictly guarantees the correct fetching sequence here. The reason I mention this is because in C or C++ one may need to be more cautious. The memory models of the latter are considerably more permissive, which may allow certain compiler optimizations to issue out-of-order fetches. Obviously, in such a regime, fetch-order sensitivity would represent a correctness hazard.

If you don't want to rely on implementation of sign extension while right bit shifting, you can modify the way you calculate the mask:

mask = ~((n >> 31) & 1) + 1

then proceed as was already demonstrated in the previous answers:

(n ^ mask) - mask