Carnegie Mellon

Bits, Bytes, and Integers

1
 Carnegie Mellon

Today: Bits, Bytes, and Integers

 Representing information as bits
 Bit-level manipulations
 Integers
▪ Representation: unsigned and signed
▪ Conversion, casting
▪ Expanding, truncating
▪ Addition, negation, multiplication, shifting
 Summary

2
 Carnegie Mellon

Binary Representations

0 1 0
3.3V
2.8V

0.5V
0.0V

3
 Carnegie Mellon

Encoding Byte Values

 Byte = 8 bits
▪ Binary 000000002 to 111111112 0 0 0000
▪ Decimal: 010 to 25510 1 1 0001
2 2 0010
▪ Hexadecimal 0016 to FF16 3 3 0011
▪ Base 16 number representation 4 4 0100
5 5 0101
▪ Use characters ‘0’ to ‘9’ and ‘A’ to ‘F’ 6 6 0110
7 7 0111
▪ Write FA1D37B16 in C as 8 8 1000
– 0xFA1D37B 9 9 1001
A 10 1010
– 0xfa1d37b B 11 1011
C 12 1100
D 13 1101
E 14 1110
F 15 1111

4
 Carnegie Mellon

Byte-Oriented Memory Organization

•••

 Programs Refer to Virtual Addresses

▪ Conceptually very large array of bytes
▪ Actually implemented with hierarchy of different memory types
▪ System provides address space private to particular “process”
▪ Program being executed
▪ Program can clobber its own data, but not that of others
 Compiler + Run-Time System Control Allocation
▪ Where different program objects should be stored
▪ All allocation within single virtual address space

5
 Carnegie Mellon

Machine Words
 Machine Has “Word Size”
▪ Nominal size of integer-valued data
▪ Including addresses
▪ Most current machines use 32 bits (4 bytes) words
▪ Limits addresses to 4GB
▪ Becoming too small for memory-intensive applications
▪ High-end systems use 64 bits (8 bytes) words
▪ Potential address space ≈ 1.8 X 1019 bytes
▪ x86-64 machines support 48-bit addresses: 256 Terabytes
▪ Machines support multiple data formats
▪ Fractions or multiples of word size
▪ Always integral number of bytes

6
 Carnegie Mellon

Word-Oriented Memory Organization

32-bit 64-bit
Bytes Addr.
 Addresses Specify Byte Words Words
Locations 0000
Addr
▪ Address of first byte in word =
0001
0000
?? 0002
▪ Addresses of successive words differ Addr
0003
by 4 (32-bit) or 8 (64-bit) =
0000
?? 0004
Addr
=
0005
0004
?? 0006
0007
0008
Addr
=
0009
0008
?? 0010
Addr
= 0011
0008
?? 0012
Addr
=
0013
0012
?? 0014
0015
7
 Carnegie Mellon

Data Representations
C Data Type Typical 32-bit Intel IA32 x86-64

char 1 1 1

short 2 2 2

int 4 4 4

long 4 4 8

long long 8 8 8
float 4 4 4

double 8 8 8

long double 8 10/12 10/16

pointer 4 4 8

8
 Carnegie Mellon

Byte Ordering
 How should bytes within a multi-byte word be ordered in
memory?
 Conventions
▪ Big Endian: Sun, PPC Mac, Internet
▪ Least significant byte has highest address
▪ Little Endian: x86
▪ Least significant byte has lowest address

9
 Carnegie Mellon

Byte Ordering Example

 Big Endian
▪ Least significant byte has highest address
 Little Endian
▪ Least significant byte has lowest address
 Example
▪ Variable x has 4-byte representation 0x01234567
▪ Address given by &x is 0x100

Big Endian 0x100 0x101 0x102 0x103

01 23 45 67

Little Endian 0x100 0x101 0x102 0x103

67 45 23 01

10
 Carnegie Mellon

Reading Byte-Reversed Listings

 Disassembly
▪ Text representation of binary machine code
▪ Generated by program that reads the machine code
 Example Fragment
Address Instruction Code Assembly Rendition
8048365: 5b pop %ebx
8048366: 81 c3 ab 12 00 00 add $0x12ab,%ebx
804836c: 83 bb 28 00 00 00 00 cmpl $0x0,0x28(%ebx)

 Deciphering Numbers
▪ Value: 0x12ab
▪ Pad to 32 bits: 0x000012ab
▪ Split into bytes: 00 00 12 ab
▪ Reverse: ab 12 00 00

11
 Carnegie Mellon

Decimal: 15213
Representing Integers Binary: 0011 1011 0110 1101
Hex: 3 B 6 D

int A = 15213; long int C = 15213;

IA32, x86-64 Sun
IA32 x86-64 Sun
6D 00
6D 6D 00
3B 00
3B 3B 00
00 3B
00 6D 00 00 3B
00 00 6D
00
int B = -15213; 00
00
IA32, x86-64 Sun
00
93 FF
C4 FF
FF C4
FF 93 Two’s complement representation
(Covered later)
12
 Carnegie Mellon

Representing Strings
char S[6] = "18243";
 Strings in C
▪ Represented by array of characters
▪ Each character encoded in ASCII format Linux/Alpha Sun
▪ Standard 7-bit encoding of character set 31 31
▪ Character “0” has code 0x30 38 38
– Digit i has code 0x30+i 32 32
▪ String should be null-terminated 34 34
▪ Final character = 0
33 33
 Compatibility 00 00
▪ Byte ordering not an issue

13
 Carnegie Mellon

Today: Bits, Bytes, and Integers

 Representing information as bits
 Bit-level manipulations
 Integers
▪ Representation: unsigned and signed
▪ Conversion, casting
▪ Expanding, truncating
▪ Addition, negation, multiplication, shifting
 Summary

14
 Carnegie Mellon

Boolean Algebra
 Developed by George Boole in 19th Century
▪ Algebraic representation of logic
▪ Encode “True” as 1 and “False” as 0
And Or
◼ A&B = 1 when both A=1 and B=1 ◼ A|B = 1 when either A=1 or B=1

Not Exclusive-Or (Xor)

◼ ~A = 1 when A=0 ◼ A^B = 1 when either A=1 or B=1, but not both

15
 Carnegie Mellon

General Boolean Algebras

 Operate on Bit Vectors
▪ Operations applied bitwise
01101001 01101001 01101001
& 01010101 | 01010101 ^ 01010101 ~ 01010101
01000001
01000001 1111101
01111101 00111100 10101010
10101010

 All of the Properties of Boolean Algebra Apply

16
 Carnegie Mellon

Representing & Manipulating Sets

 Representation
▪ Width w bit vector represents subsets of {0, …, w–1}
▪ aj = 1 if j ∈ A

▪ 01101001 { 0, 3, 5, 6 }
▪ 76543210

▪ 01010101 { 0, 2, 4, 6 }
▪ 76543210
 Operations
▪ & Intersection 01000001 { 0, 6 }
▪ | Union 01111101 { 0, 2, 3, 4, 5, 6 }
▪ ^ Symmetric difference 00111100 { 2, 3, 4, 5 }
▪ ~ Complement 10101010 { 1, 3, 5, 7 }
17
 Carnegie Mellon

Bit-Level Operations in C
 Operations &, |, ~, ^ Available in C
▪ Apply to any “integral” data type
▪ long, int, short, char, unsigned
▪ View arguments as bit vectors
▪ Arguments applied bit-wise
 Examples (Char data type)
▪ ~0x41 = 0xBE
▪ ~010000012 = 101111102
▪ ~0x00 = 0xFF
▪ ~000000002 = 111111112
▪ 0x69 & 0x55 = 0x41
▪ 011010012 & 010101012 = 010000012
▪ 0x69 | 0x55 = 0x7D
▪ 011010012 | 010101012 = 011111012

18
 Carnegie Mellon

Contrast: Logic Operations in C

 Contrast to Logical Operators
▪ &&, ||, !
▪ View 0 as “False”
▪ Anything nonzero as “True”
▪ Always return 0 or 1
▪ Early termination
 Examples (char data type)
▪ !0x41 = 0x00
▪ !0x00 = 0x01
▪ !!0x41 = 0x01

▪ 0x69 && 0x55 = 0x01

▪ 0x69 || 0x55 = 0x01

19
 Carnegie Mellon

Shift Operations
 Left Shift: x << y Argument x 01100010
▪ Shift bit-vector x left y positions << 3 00010000
– Throw away extra bits on left
Log. >> 2 00011000
▪ Fill with 0’s on right
Arith. >> 2 00011000
 Right Shift: x >> y
▪ Shift bit-vector x right y positions
▪ Throw away extra bits on right Argument x 10100010

▪ Logical shift << 3 00010000

▪ Fill with 0’s on left Log. >> 2 00101000
▪ Arithmetic shift
Arith. >> 2 11101000
▪ Replicate most significant bit on right

 Undefined Behavior
▪ Shift amount < 0 or ≥ word size
20
 Carnegie Mellon

Today: Bits, Bytes, and Integers

 Representing information as bits
 Bit-level manipulations
 Integers
▪ Representation: unsigned and signed
▪ Conversion, casting
▪ Expanding, truncating
▪ Addition, negation, multiplication, shifting
 Summary

21
 Carnegie Mellon

Encoding Integers
Unsigned Two’s Complement
w−1 w−2
 xi 2  xi 2
i w−1 i
B2U(X) = B2T(X) = − xw−1 2 +
i=0 i=0

short int x = 15213;

short int y = -15213; Sign
Bit
 C short 2 bytes long
Decimal Hex Binary
x 15213 3B 6D 00111011 01101101
y -15213 C4 93 11000100 10010011

 Sign Bit
▪ For 2’s complement, most significant bit indicates sign
▪ 0 for nonnegative
▪ 1 for negative

22
 Carnegie Mellon

Encoding Example (Cont.)

x = 15213: 00111011 01101101
y = -15213: 11000100 10010011

Weight 15213 -15213

1 1 1 1 1
2 0 0 1 2
4 1 4 0 0
8 1 8 0 0
16 0 0 1 16
32 1 32 0 0
64 1 64 0 0
128 0 0 1 128
256 1 256 0 0
512 1 512 0 0
1024 0 0 1 1024
2048 1 2048 0 0
4096 1 4096 0 0
8192 1 8192 0 0
16384 0 0 1 16384
-32768 0 0 1 -32768
Sum 15213 -15213 23
 Carnegie Mellon

Values for Different Word Sizes

W
8 16 32 64
UMax 255 65,535 4,294,967,295 18,446,744,073,709,551,615
TMax 127 32,767 2,147,483,647 9,223,372,036,854,775,807
TMin -128 -32,768 -2,147,483,648 -9,223,372,036,854,775,808

 Observations  C Programming
▪ |TMin | = TMax + 1 ▪ #include <limits.h>
▪ Asymmetric range ▪ Declares constants, e.g.,
▪ UMax = 2 * TMax + 1 ▪ ULONG_MAX
▪ LONG_MAX
▪ LONG_MIN
▪ Values platform specific

24
 Carnegie Mellon

Today: Bits, Bytes, and Integers

 Representing information as bits
 Bit-level manipulations
 Integers
▪ Representation: unsigned and signed
▪ Conversion, casting
▪ Expanding, truncating
▪ Addition, negation, multiplication, shifting
 Summary

25
 Carnegie Mellon

Conversion Visualized
 2’s Comp.  Unsigned
▪ Ordering Inversion UMax
▪ Negative  Big Positive
UMax – 1

TMax + 1 Unsigned
TMax TMax Range

2’s Complement
0 0
Range
–1
–2

TMin
26
 Carnegie Mellon

Signed vs. Unsigned in C

 Constants
▪ By default are considered to be signed integers
▪ Unsigned if have “U” as suffix
0U, 4294967259U
 Casting
▪ Explicit casting between signed & unsigned same as U2T and T2U
int tx, ty;
unsigned ux, uy;
tx = (int) ux;
uy = (unsigned) ty;

▪ Implicit casting also occurs via assignments and procedure calls

tx = ux;
uy = ty;

27
 Carnegie Mellon

Casting Surprises
 Expression Evaluation
▪ If there is a mix of unsigned and signed in single expression,
signed values implicitly cast to unsigned
▪ Including comparison operations <, >, ==, <=, >=
▪ Examples for W = 32: TMIN = -2,147,483,648 , TMAX = 2,147,483,647
 Constant1 Constant2 Relation Evaluation
0 0 0U
0U == unsigned
-1 -1 00 < signed
-1 -1 0U
0U > unsigned
2147483647
2147483647 -2147483647-1
-2147483648 > signed
2147483647U
2147483647U -2147483647-1
-2147483648 < unsigned
-1 -1 -2
-2 > signed
(unsigned)-1
(unsigned) -1 -2
-2 > unsigned
2147483647
2147483647 2147483648U
2147483648U < unsigned
2147483647
2147483647 (int)2147483648U
(int) 2147483648U > signed
28
 Carnegie Mellon

Summary
Casting Signed ↔ Unsigned: Basic Rules
 Bit pattern is maintained
 But reinterpreted
 Can have unexpected effects: adding or subtracting 2w

 Expression containing signed and unsigned int

▪ int is cast to unsigned!!

29
 Carnegie Mellon

Today: Bits, Bytes, and Integers

 Representing information as bits
 Bit-level manipulations
 Integers
▪ Representation: unsigned and signed
▪ Conversion, casting
▪ Expanding, truncating
▪ Addition, negation, multiplication, shifting
 Summary

30
 Carnegie Mellon

Sign Extension
 Task:
▪ Given w-bit signed integer x
▪ Convert it to w+k-bit integer with same value
 Rule:
▪ Make k copies of sign bit:
▪ X = xw–1 ,…, xw–1 , xw–1 , xw–2 ,…, x0

k copies of MSB w
X •••

•••

X= ••• •••
k w 31
 Carnegie Mellon

Sign Extension Example

short int x = 15213;
int ix = (int) x;
short int y = -15213;
int iy = (int) y;

Decimal Hex Binary

x 15213 3B 6D 00111011 01101101
ix 15213 00 00 3B 6D 00000000 00000000 00111011 01101101
y -15213 C4 93 11000100 10010011
iy -15213 FF FF C4 93 11111111 11111111 11000100 10010011

 Converting from smaller to larger integer data type

 C automatically performs sign extension

32
 Carnegie Mellon

Summary:
Expanding, Truncating: Basic Rules
 Expanding (e.g., short int to int)
▪ Unsigned: zeros added
▪ Signed: sign extension
▪ Both yield expected result

 Truncating (e.g., unsigned to unsigned short)

▪ Unsigned/signed: bits are truncated
▪ Result reinterpreted
▪ Unsigned: mod operation
▪ Signed: similar to mod
▪ For small numbers yields expected behaviour

33
 Carnegie Mellon

Today: Bits, Bytes, and Integers

 Representing information as bits
 Bit-level manipulations
 Integers
▪ Representation: unsigned and signed
▪ Conversion, casting
▪ Expanding, truncating
▪ Addition, negation, multiplication, shifting
 Summary

34
 Carnegie Mellon

Negation: Complement & Increment

 Claim: Following Holds for 2’s Complement
~x + 1 == -x
 Complement
▪ Observation: ~x + x == 1111…111 == -1
x 10011101
+ ~x 0 1 1 0 0 0 1 0
-1 11111111
 Complete Proof?

35
 Carnegie Mellon

Complement & Increment Examples

x = 15213
Decimal Hex Binary
x 15213 3B 6D 00111011 01101101
~x -15214 C4 92 11000100 10010010
~x+1 -15213 C4 93 11000100 10010011
y -15213 C4 93 11000100 10010011

x=0
Decimal Hex Binary
0 0 00 00 00000000 00000000
~0 -1 FF FF 11111111 11111111
~0+1 0 00 00 00000000 00000000

36
 Carnegie Mellon

Unsigned Addition
Operands: w bits u •••
+v •••
True Sum: w+1 bits
u+v •••
Discard Carry: w bits UAddw(u , v) •••

 Standard Addition Function

▪ Ignores carry output
 Implements Modular Arithmetic
s = UAddw(u , v) = u + v mod 2w

 u+ v u + v  2w
UAdd w (u,v) =  w
u + v − 2 u + v  2w

37
 Carnegie Mellon

Two’s Complement Addition

Operands: w bits u •••
+ v •••
True Sum: w+1 bits
u+v •••
Discard Carry: w bits TAddw(u , v) •••

 TAdd and UAdd have Identical Bit-Level Behavior

▪ Signed vs. unsigned addition in C:
int s, t, u, v;
s = (int) ((unsigned) u + (unsigned) v);
t = u + v
▪ Will give s == t

38
 Carnegie Mellon

TAdd Overflow
 Functionality True Sum
▪ True sum requires w+1 0 111…1 2w–1
PosOver
bits TAdd Result
▪ Drop off MSB 0 100…0 2w –1 011…1
▪ Treat remaining bits as
2’s comp. integer 0 000…0 0 000…0

1 011…1 –2w –1–1 100…0

1 000…0 NegOver
–2w

39
 Carnegie Mellon

Multiplication
 Computing Exact Product of w-bit numbers x, y
▪ Either signed or unsigned
 Ranges
▪ Unsigned: 0 ≤ x * y ≤ (2w – 1) 2 = 22w – 2w+1 + 1
▪Up to 2w bits
▪ Two’s complement min: x * y ≥ (–2w–1)*(2w–1–1) = –22w–2 + 2w–1
▪ Up to 2w–1 bits
▪ Two’s complement max: x * y ≤ (–2w–1) 2 = 22w–2
▪ Up to 2w bits, but only for (TMinw)2

 Maintaining Exact Results

▪ Would need to keep expanding word size with each product computed
▪ Done in software by “arbitrary precision” arithmetic packages

40
 Carnegie Mellon

Unsigned Multiplication in C
u •••
Operands: w bits
* v •••
True Product: 2*w bits u · v ••• •••
UMultw(u , v) •••
Discard w bits: w bits

 Standard Multiplication Function

▪ Ignores high order w bits
 Implements Modular Arithmetic
UMultw(u , v)= u · v mod 2w

41
 Carnegie Mellon

Signed Multiplication in C
u •••
Operands: w bits
* v •••
True Product: 2*w bits u · v ••• •••
TMultw(u , v) •••
Discard w bits: w bits

 Standard Multiplication Function

▪ Ignores high order w bits
▪ Some of which are different for signed
vs. unsigned multiplication
▪ Lower bits are the same

42
 Carnegie Mellon

Power-of-2 Multiply with Shift

 Operation
▪ u << k gives u * 2k
▪ Both signed and unsigned k
u •••
Operands: w bits
* 2k 0 ••• 0 1 0 ••• 0 0
True Product: w+k bits u · 2k ••• 0 ••• 0 0
Discard k bits: w bits UMultw(u , 2k) ••• 0 ••• 0 0
TMultw(u , 2k)
 Examples
▪ u << 3 == u * 8
▪ u << 5 - u << 3 == u * 24
▪ Most machines shift and add faster than multiply
▪ Compiler generates this code automatically

43
 Carnegie Mellon

Compiled Multiplication Code

C Function
int mul12(int x)
{
return x*12;
}

Compiled Arithmetic Operations Explanation

leal (%eax,%eax,2), %eax t <- x+x*2
sall $2, %eax return t << 2;

 C compiler automatically generates shift/add code when

multiplying by constant

44
 Carnegie Mellon

Unsigned Power-of-2 Divide with Shift

 Quotient of Unsigned by Power of 2
▪ u >> k gives ⎣u / 2k⎦
▪ Uses logical shift
k
u ••• ••• Binary Point
Operands:
/ 2k 0 ••• 0 1 0 ••• 0 0
Division: u / 2k 0 ••• 0 0 ••• . •••

Result: ⎣ u / 2k ⎦ 0 ••• 0 0 •••

Division Computed Hex Binary

x 15213 15213 3B 6D 00111011 01101101
x >> 1 7606.5 7606 1D B6 00011101 10110110
x >> 4 950.8125 950 03 B6 00000011 10110110
x >> 8 59.4257813 59 00 3B 00000000 00111011

45
 Carnegie Mellon

Compiled Unsigned Division Code

C Function
unsigned udiv8(unsigned x)
{
return x/8;
}

Compiled Arithmetic Operations Explanation

shrl $3, %eax # Logical shift
return x >> 3;

 Uses logical shift for unsigned

 For Java Users
▪ Logical shift written as >>>

46
 Carnegie Mellon

Signed Power-of-2 Divide with Shift

 Quotient of Signed by Power of 2
▪ x >> k gives ⎣ x / 2k ⎦
▪ Uses arithmetic shift
▪ Rounds wrong direction when u < 0
k
x ••• ••• Binary Point
Operands:
/ 2k 0 ••• 0 1 0 ••• 0 0
Division: x / 2k 0 ••• ••• . •••
Result: RoundDown(x / 2k) 0 ••• •••
Division Computed Hex Binary
y -15213 -15213 C4 93 11000100 10010011
y >> 1 -7606.5 -7607 E2 49 11100010 01001001
y >> 4 -950.8125 -951 FC 49 11111100 01001001
y >> 8 -59.4257813 -60 FF C4 11111111 11000100

47
 Carnegie Mellon

Correct Power-of-2 Divide

 Quotient of Negative Number by Power of 2
▪ Want ⎡x / 2k ⎤ (Round Toward 0)
▪ Compute as ⎣ (x+2k-1)/ 2k ⎦
▪ In C: (x + (1<<k)-1) >> k
▪ Biases dividend toward 0

Case 1: No rounding k
Dividend: u 1 ••• 0 ••• 0 0
+2k –1 0 ••• 0 0 1 ••• 1 1
1 ••• 1 ••• 1 1 Binary Point
Divisor: / 2k 0 ••• 0 1 0 ••• 0 0

⎡u / 2k ⎤ 10 ••• 1 1 1 ••• . 1 ••• 1 1

Biasing has no effect

48
 Carnegie Mellon

Correct Power-of-2 Divide (Cont.)

Case 2: Rounding
k
Dividend: x 1 ••• •••
+2k –1 0 ••• 0 0 1 ••• 1 1
1 ••• •••

Incremented by 1 Binary Point

Divisor: / 2k 0 ••• 0 1 0 ••• 0 0

⎡x / 2k ⎤ 10 ••• 1 1 1 ••• . •••

Incremented by 1
Biasing adds 1 to final result
49
 Carnegie Mellon

Compiled Signed Division Code

C Function
int idiv8(int x)
{
return x/8;
}

Compiled Arithmetic Operations Explanation

testl %eax, %eax if x < 0
js L4 x += 7;
L3: # Arithmetic shift
sarl $3, %eax return x >> 3;
ret
L4:
addl $7, %eax  Uses arithmetic shift for int
jmp L3
 For Java Users
▪ Arith. shift written as >>

50
 Carnegie Mellon

Today: Integers
 Representation: unsigned and signed
 Conversion, casting
 Expanding, truncating
 Addition, negation, multiplication, shifting
 Summary

51