Bitwise operations on 32-bit unsigned ints?

Question

JavaScript converts operands to 32-bit signed ints before doing bitwise operations. It also does the operation with 32-bit signed ints, meaning that the result is a 32-bit signed int.

Because I'd like to do bitwise operations with 32-bit unsigned ints, I'm wondering if there is a way to use JavaScript's mangled result to find out the intended result.

To demonstrate my idea, for example, in C, which is the reference as to what I'd like,

unsigned int a = 3774191835u;
unsigned int b = a >> 2;
/* b == 943547958 */

In JavaScript,

 var a = 3774191835;
 var b = a >> 2;
 /* b == -130193866 */

Let's try this with a different operation. In C,

unsigned int a = 1986735448u;
unsigned int b = a << 1;
/* b == 3973470896 */

In JavaScript,

 var a = 1986735448;
 var b = a << 1;
 /* b == -321496400 */

Now that JavaScript has evaluated my bitwise operation with the operand as an signed int, we of course, get a different result to what we would in C, where we can properly do bitwise operations on unsigned ints.

I know it's possible, but I'm unsure of a way that I can, essentially, turn JavaScript's result into the intended result.

---

Zero-fill right shift the result by zero works for the second case only, but not the first.

 var a = 3774191835;
 var b = (a >> 2) >>> 0;
 /* b == 4164773430 */

 var a = 1986735448;
 var b = (a << 1) >>> 0;
 /* b == 3973470896 */

Zircon

Answer 1

You only have to follow these rules:

1. always end bit wise ops with >>> 0 so the result gets interpreted as unsigned.
2. don't use >>. If the left-most bit is 1 it will try to preseve the sign and thus will introduce 1's to the left. Always use >>>.

Examples:

C:  (3774191835 >> 2) | 2147483648
js: (3774191835 >>> 2 | 2147483648) >>> 0

C:  1986735448 << 1
js: (1986735448 << 1) >>> 0

C:  3774191835 & 4294967295
js: (3774191835 & 4294967295) >>> 0

Only if the last op is >>>, >>> 0 is not necessary.

Aubade

+1 and this is also nicely described here: >>> Zero-fill right shift @ MDN – Literally

Oh, Javascript, why must you be so odd? – Jane

Answer 2

It's ugly, but:

var a = 1986735448;
var b = (a << 1) >>> 0;
/* b = 3973470896 */

Tristatristam

@Delan Azabani, It's just because >>> returns an unsigned value. The shift does the same thing signed or not it's only the Javascript engines interpretation of the bit that changes. For that reason you only have to >>> 0 once after multiple bitwise operations like ((a | 2) << 1) >>> 0 – Tristatristam

I understand that; however, (3774191835 >> 2) >>> 0 returns 4164773430 in JavaScript, which is wrong. I'm not really sure what to do here. – Zircon

Answer 3

JavaScript takes care of this problem by offering two bit shift operators, >> and >>>. You want >>> to do a shift without shifting the sign bit.

Ballarat

No, it doesn't. JavaScript still converts operands to 32-bit signed ints, and returns the operation's result as a 32-bit signed int. Please see my updated answer, that shows that this is not related to bit shifts specifically. – Zircon

When I do alert(3774191835>>>2), it gives me 943547958, so I guess something's happening in the assignment? – Ballarat

That specific case might happen to be fixed with an unsigned right shift, but what about all the other operators? – Zircon

It seems @PaulPRO has an answer for that ^_^ – Ballarat

+, -, * don't care about the signedness, the result (binary bit pattern) is the same. for divide you can use (a >>> 0) / b – Kristianson