2. Integers

signed values implicitly cast to unsiged → even for comparison operators

• -1 > 0U because -1 cast to unsigned ist umax.

Common mistake is passing a signed int into a function that expects unsigned → memory leak or vuln.

Sign extension:

• to extend from w to w+k bits, make k copies of the sign bit (MSB).
• two’s complement works that way → we add -127 (or whatever the minus is) + … those bits.
  • by induction → extending by 1 does $-2^n+2^{n-1}$ since the top 1 is now a large +
  • this gives me $-2^n+2^{n-1}=-2^{n-1}$.
    unsigned is always zero extension!

Unsigned: Adding numbers is always with carry truncated → in C at least (in assembly, you can recover carry flag)

• addition in C is an abelian group (since it’s mod addition)
  Signed: same carry truncation happens
• (int) ((uint) u + (uint) v) == u + v same thing!
• you can overflow and underflow
  • this happens when there is not carry into the MSB and it’s suddenly positive

Multipliation:

• Unsigned:
  • we need twice the number of bits after multiplication
  • discard the top bits
  • $u\cdot v\mathrm{mod}{2}^w$ for w-long ints
  • it’s a commutative ring with unsigned addition
• Signed also discards the top half
  • the lower half is exactly the same as the unsigned mult!
  • it works with the - * + case as well, it automatically gives you the MSB bit set

Multiplication is much cheaper than division → we can shift and multiply with special numbers to divide, which is much faster! (Note, this mostly only works on unsigned numbers!!!)

• shifting is multiplying or dividing by 2
• (u << 5) - (u << 3) == u * 24
  • because 32 - 8 = 2
  • TODO: why does this not overflow sometimes????
• right shift is floored division (euclidean)

With signed integers, division gets more complicated → the MSB is also shifted somewhere → we need arithmetic shift commands!

• arithmetic shifting fills the left with 1s, as seen before this compensates
• but! it rounds the wrong direction with u < 0!
• we want to round towards 0!!!
  • so we want $\lceil s/2^k\rceil$ but do $\lfloor (s+2^k-1)/2^k\rfloor$
  • compiler does this automatically by checking for negatives

2.1. Bit-Level Representation (CS:APP 2.1)

2.1.1. Byte Ordering

Endianness

A multi-byte object is stored at consecutive addresses, and its address is that of the lowest byte. Little-endian (x86) stores the least significant byte first; big-endian stores the most significant byte first.

Example: int x = 0x01234567 at address 0x100:

• little-endian: 0x100: 67 45 23 01
• big-endian: 0x100: 01 23 45 67

To detect the byte order we cast an int to (char *). Then we can access individual bytes.

2.1.2. Bitwise and Logical Operators

Bitwise vs Logical Operators

& | ^ ~ act on each bit position independently. && || ! treat any nonzero value as true, return 0 or 1, and short-circuit.

Example (8-bit):

• 0x69 & 0x55 → 0x41
• 0x69 && 0x55 → 1
• ~0x41 → 0xBE
• !0x41 → 0

Bit $k$ of x:

• set: x | (1u << k)
• clear: x & ~(1u << k)
• toggle: x ^ (1u << k)
• test: (x >> k) & 1

2.1.3. Shifts

Shift Operations

We can shift either right or left:

• left shift:
  • x << k drops the top $k$ bits and fills with 0 from the right.
• right shift:
  • A logical right shift fills with 0
  • An arithmetic right shift fills with copies of the MSB

Note: an arithmetic shift occurs in C for signed types, not unsigned. Otherwise a logical shift is used.

Example: For x = 10100010:

• x << 3 → 00010000
• logical x >> 2 → 00101000
• arithmetic x >> 2 → 11101000

2.2. Integer Encodings (CS:APP 2.2)

2.2.1. Unsigned and Two’s Complement

Encodings

For a bit vector $\vec{x}=[x_{w-1},\dots ,x_0]$:

$$B2U_w(\vec{x})=\sum _{i=0}^{w-1}{x}_i{2}^{i}B2T_w(\vec{x})=-x_{w-1}{2}^{w-1}+\sum _{i=0}^{w-2}{x}_i{2}^i$$

The MSB of a two’s-complement number has negative weight $-2^{w-1}$ (e.g. $-128$ for $w=8$).

Ranges and Identities

$$UMa{x}_w=2^w-1TMi{n}_w=-2^{w-1}TMa{x}_w=2^{w-1}-1$$

Note: Identities

• $\neg x+1=-x$
• $|TMin|=TMax+1$
  • → asymmetric range (-128 to 127 for 8 bits)
• $TMin+TMax=-1$.
• The pattern of all ones is $UMax$ unsigned and $-1$ signed.

Example

2.2.2. Signed–Unsigned Conversion

T2U and U2T

Casting between signed and unsigned values of the same width keeps the bits, and

$$T2U_w(x)=\{\begin{array}{ll}x+2^w& x<0\\ x& x\ge 0\end{array}U2T_w(u)=\{\begin{array}{ll}u-2^w& u>TMa{x}_w\\ u& u\le TMa{x}_w\end{array}$$

Proof: For the same bit vector, $B2U_w(\vec{x})-B2T_w(\vec{x})$ $=x_{w-1}\left(2^{w-1}-(-2^{w-1})\right)$ $=x_{w-1}{2}^w$, and $x_{w-1}=1$ exactly when the signed value is negative.

• the shift by +TMAX only happens when the sign bit is 1!

Example:

Implicit Conversion:

Example: for (unsigned i = n-1; i >= 0; i--) never terminates because unsigned >= 0 is always true!

---

TODO

2.2.3. Sign Extension and Truncation

Sign Extension

Extending a $w$-bit two’s-complement number to $w+k$ bits by prepending $k$ copies of the MSB preserves its value. Unsigned numbers are always zero-extended.

Proof: By induction on $k$, so it suffices to show $k=1$. If $x_{w-1}=0$, nothing changes. If $x_{w-1}=1$, the old MSB changes weight from $-2^{w-1}$ to $+2^{w-1}$ and the new MSB contributes $-2^w$. The net change in those two positions is $-2^w+2^{w-1}=-2^{w-1}$, which equals the old contribution.

Example: $-5=$ 1011 becomes 11111011 $=-128+64+32+16+8+2+1=-5$, while unsigned 1011 $=11$ becomes 00001011. For short sx = -12345;, the cast (unsigned) sx first sign-extends to int and then reinterprets: $-12345+2^{32}=4294954951$.

Truncation

Truncating $\vec{x}$ to its low $k$ bits gives

$$B2U_k=B2U_w(\vec{x})\mathrm{mod}{2}^{k}B2T_k=U2T_k\left(B2U_w(\vec{x})\mathrm{mod}{2}^k\right)$$

Example: (short) 53191 $=53191-2^{16}=-12345$.

2.3. Integer Arithmetic (CS:APP 2.3)

2.3.1. Addition

Unsigned Addition

$UAd{d}_w(u,v)=(u+v)\mathrm{mod}{2}^w$. The carry out of the MSB is discarded in C; in assembly it survives in the carry flag CF.

Group Structure

$\left(\{0,\dots ,2^w-1\},UAd{d}_w\right)$ is an abelian group with identity 0 and inverse $2^w-u$ for $u\ne 0$ (the inverse of 0 is 0).

Proof: It is $\mathbb{Z}/2^w\mathbb{Z}$ with canonical representatives, so closure, associativity and commutativity are inherited.

Two's-Complement Addition

$TAd{d}_w(x,y)=U2T_w\left(UAd{d}_w(T2U_w(x),T2U_w(y))\right)$, i.e. the same adder circuit. Hence (int)((unsigned)u + (unsigned)v) == u + v. For $x,y\in [TMi{n}_w,TMa{x}_w]$:

$$TAd{d}_w(x,y)=\{\begin{array}{ll}x+y-2^w& 2^{w-1}\le x+y\text{(positive overflow)}\\ x+y& -2^{w-1}\le x+y<2^{w-1}\\ x+y+2^w& x+y<-2^{w-1}\text{(negative overflow)}\end{array}$$

Overflow Detection

• Signed: overflow occurs iff $x$ and $y$ have the same sign and the result has the other sign. Equivalently, the carry into the MSB differs from the carry out of it.
• Unsigned: overflow occurs iff $UAd{d}_w(u,v)<u$.

Example ($w=4$):

Sum	Bits	Result	Case
$5+5$	0101 + 0101 = 1010	$-6=10-16$	positive overflow
$-8+(-5)$	1000 + 1011 = (1)0011	$3=-13+16$	negative overflow
unsigned $9+12$		$21\mathrm{mod}16=5$

Signed overflow is UB in ISO C. The course models it as wraparound (as with gcc -fwrapv), but optimizers may assume it never happens, e.g. by folding x + 1 > x to true.

2.3.2. Negation

Two's-Complement Negation

$$-x=\sim x+1$$

for all $x$, including $-TMin=TMin$.

Proof: $x+\sim x$ is the all-ones pattern, i.e. $-1$; add 1 to both sides. For $TMin$: 100..0 $\to$ 011..1 $\to$ 100..0.

Example: $5=$ 0101 $\to$ 1010 $\to$ 1011 $=-5$. This explains 1 + (a << 3) + ~a $=8a+(-a-1)+1=7a$.

2.3.3. Multiplication

Truncated Multiplication

The exact product of two $w$-bit numbers needs up to $2w$ bits; C keeps only the low $w$:

$$UMul{t}_w(u,v)=uv\mathrm{mod}{2}^{w}TMul{t}_w(x,y)=U2T_w\left(xy\mathrm{mod}{2}^w\right)$$

$UMul{t}_w$ and $UAd{d}_w$ form the commutative ring $\mathbb{Z}/2^w\mathbb{Z}$.

Bit-Level Equivalence

$TMul{t}_w$ and $UMul{t}_w$ produce identical bit patterns: $T2B_w(TMul{t}_w(x,y))=U2B_w\left(UMul{t}_w(T2U_w(x),T2U_w(y))\right)$. One imul instruction therefore serves both.

Proof: $T2U_w(x)\equiv x(\mathrm{mod}{2}^w)$, so $T2U_w(x)\cdot T2U_w(y)\equiv xy(\mathrm{mod}{2}^w)$. Both results are the same residue, reinterpreted.

Example ($w=3$, 101 $\times$ 011):

Interpretation	Exact product	Low 3 bits
unsigned $5\cdot 3=15$	001111	111 $=7$
signed $-3\cdot 3=-9$	110111	111 $=-1$

Mixed signs come out right (MSB set) as long as the true product fits in $w$ bits.

2.3.4. Multiplication by Constants

Shift as Multiplication

For signed and unsigned $x$: x << k $=x\cdot 2^k\mathrm{mod}{2}^w$. Hence, if $K$ has a run of ones from bit $n$ down to bit $m$:

$$x\cdot K=(x\ll (n+1))-(x\ll m)$$

A shift and an add take about 1 cycle each; imul takes about 3.

Intermediate Overflow Cancels

(x << 5) - (x << 3) == x * 24 holds for all $x$, even when x << 5 overflows.

Proof: Every operation is in $\mathbb{Z}/2^w\mathbb{Z}$, so $32x-8x\equiv 24x(\mathrm{mod}{2}^w)$. x * 24 is reduced modulo $2^w$ as well, so both sides are the same residue, wraparound included.
→ It gives the correct answer, as long as the answer is representable!

• note this works since two’s complement works modulo for left shifts!

Example:

Product	Shift form
$24=$ 11000	(x << 5) - (x << 3)
$7x$	(x << 3) - x
$14x$	(x << 4) - (x << 1)
$22x$ (HS22 option d)	(a << 4) + (a << 2) + (a << 1)

2.3.5. Division by Powers of Two

Unsigned Division by Shift

For unsigned $u$: u >> k $=\lfloor u/2^k\rfloor$, using a logical shift.

Proof: $u={\sum }_i{u}_i{2}^i$. The shift keeps ${\sum }_{i\ge k}{u}_i{2}^{i-k}$ and drops ${\sum }_{i<k}{u}_i{2}^i<2^k$, which is exactly the remainder.

Signed Division by Shift

For signed $x$, the arithmetic shift gives x >> k $=\lfloor x/2^k\rfloor$, which rounds toward $-\infty$. C requires rounding toward 0, i.e. $\lceil x/2^k\rceil$ for $x<0$. For $x<0$:

$$\lceil \frac{x}{2^k}\rceil =\text{(x + (1 << k) - 1) >> k}$$

Ceiling via Floor

For integers $x$ and $y>0$: $\lceil x/y\rceil =\lfloor (x+y-1)/y\rfloor$.

Proof: Write $x=qy+r$ with $0\le r<y$. If $r=0$, both sides equal $q$. Otherwise $y\le r+y-1<2y$, so the right side is $q+1=\lceil x/y\rceil$.

Example: $-12340/16=-771.25$. Then -12340 >> 4 $=-772$, which is wrong, while (-12340 + 15) >> 4 $=-771$, which is correct. The compiler emits the sign test itself: ((a < 0) ? a + 3 : a) >> 2 == a / 4.

For other constants, compilers multiply by a reciprocal and shift. For example, unsigned 32-bit x / 3 becomes ((uint64_t)x * 0xAAAAAAAB) >> 33.