BITS, BYTES, AND INTEGERS

COMPUTER ARCHITECTURE AND

ORGANIZATION
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
 Making ints from bytes
 Summary

2
Encoding Byte Values
al y
x ci m ar
n
 Byte = 8 bits He De Bi
0 0 0000
 Binary 000000002 to 111111112 1
2
1
2
0001
0010
 Decimal: 010 to 25510 3
4
3
4
0011
0100
 Hexadecimal 0016 to FF16 5 5 0101
6 6 0110
 Base 16 number representation 7 7 0111
8 8 1000
 Use characters ‘0’ to ‘9’ and ‘A’ to ‘F’ 9 9 1001
A 10 1010
 Write FA1D37B16 in C as B 11 1011
 0xFA1D37B C 12 1100
D 13 1101
 0xfa1d37b E 14 1110
F 15 1111

3
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  A|B = 1 when either A=1 or B=1
B=1

Not Exclusive-Or (Xor)

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

4
General Boolean Algebras
 Operate on Bit Vectors
 Operations applied bitwise
01101001 01101001 01101001
& 01010101 | 01010101 ^ 01010101 ~ 01010101
01000001
01000001 01111101
01111101 00111100
00111100 10101010
10101010

 All of the Properties of Boolean Algebra Apply

5
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 [1 byte])
 In gdb, p/t 0xE prints 1110
 ~0x41 → 0xBE
 ~010000012 → 101111102
 ~0x00 → 0xFF
 ~000000002 → 111111112
 0x69 & 0x55 → 0x41
 011010012 & 010101012 → 010000012
 0x69 | 0x55 → 0x7D
 011010012 | 010101012 → 011111012

6
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
 MSB Least significant bit (LSB)

 01010101 { 0, 2, 4, 6 }
 76543210
 Operations
 & Intersection 01000001 { 0, 6 }
 | Union 01111101 { 0, 2, 3, 4, 5, 6 }
 ^ Symmetric difference00111100 { 2, 3, 4, 5 }
 ~ Complement 10101010 { 1, 3, 5, 7 }

7
Contrast: Logic Operations in C
 Contrast to Logical Operators
 &&, ||, !
 View 0 as “False”
 Anything nonzero as “True”
 Always return 0 or 1
 Short circuit

 Examples (char data type)

 !0x41 → 0x00
 !0x00 → 0x01
 !!0x41 → 0x01

 0x69 && 0x55 → 0x01

 0x69 || 0x55 → 0x01

p && *p (avoids null pointer access)

8
Shift Operations
 Left Shift: x << y
 Shift bit-vector x left y positions Argument x 01100010
 Throw away extra bits on left
 Fill with 0’s on right << 3 00010000
 Right Shift: x >> y Log. >> 2 00011000
 Shift bit-vector x right y positions Arith. >> 2 00011000
 Throw away extra bits on right
 Logical shift
 Fill with 0’s on left Argument x 10100010
 Arithmetic shift << 3 00010000
 Replicate most significant bit on left
Log. >> 2 00101000
 Undefined Behavior
 Shift amount < 0 or ≥ word size Arith. >> 2 11101000

9
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
 Making ints from bytes
 Summary

10
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

11
How to encode unsigned integers?

 Just use exponential notation (4 bit numbers)

 0110 = 0*23 + 1*22 + 1*21 + 0*20 = 6
 1001 = 1*23 + 0*22 + 0*21 + 1*20 = 9
 (Just like 13 = 1*101 + 3*100)
 No negative numbers, a single zero (0000)

 What happens if we represent positive&negative

numbers as an unsigned number plus sign bit?

12
How to encode signed integers?

 Want: Positive and negative values

 Want: Single circuit to add positive and negative
values (i.e., no subtractor circuit)
 Solution: Two’s complement
 Positive numbers easy (4 bits)
 0110 = 0*23 + 1*22 + 1*21 + 0*20 = 6
 Negative numbers a bit weird
 1 + -1 = 0, so 0001 + X = 0, so X = 1111
 -1 = 1111 in two’s compliment

13
Unsigned & Signed Numeric Values
X B2U(X) B2T(X)  Equivalence
0000 0 0
0001 1 1
 Same encodings for
0010 2 2 nonnegative values
0011 3 3  Uniqueness
0100 4 4  Every bit pattern represents
0101 5 5
0110 6 6
unique integer value
0111 7 7  Each representable integer has
1000 8 –8 unique bit encoding
1001 9 –7
1010 10 –6
  Can Invert Mappings
1011 11 –5  U2B(x) = B2U-1(x)
1100 12 –4  Bit pattern for unsigned integer
1101 13 –3  T2B(x) = B2T-1(x)
1110 14 –2
 Bit pattern for two’s comp integer
1111 15 –1 14
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
15
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 16
Numeric Ranges

 Unsigned Values  Two’s Complement Values

 UMin = 0  TMin = –2w–1
000…0 100…0
 UMax = 2w – 1  TMax = 2w–1 – 1
111…1 011…1
 Other Values
 Minus 1

111…1
Values for W = 16
Decimal Hex Binary
UMax 65535 FF FF 11111111 11111111
TMax 32767 7F FF 01111111 11111111
TMin -32768 80 00 10000000 00000000
-1 -1 FF FF 11111111 11111111
0 0 00 00 00000000 00000000

17
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
 #include <limits.h>
 |TMin | = TMax + 1
 Declares constants, e.g.,
 Asymmetric range  ULONG_MAX
 UMax = 2 * TMax  LONG_MAX
+1  LONG_MIN
 Values platform specific

18
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
 Making ints from bytes
 Summary

19
 Mapping Between Signed & Unsigned

Two’s Complement Unsigned

T2U
x T2B B2U ux
X
Maintain Same Bit Pattern

Unsigned U2T Two’s Complement

ux U2B B2T x
X
Maintain Same Bit Pattern

 Mappings between unsigned and two’s complement numbers:

keep bit representations and reinterpret
20
Mapping Signed 
Unsigned
Bits Signed Unsigned
0000 0 0
0001 1 1
0010 2 2
0011 3 3
0100 4 4
0101 5 5
0110 6
T2U 6
0111 7 U2T 7
1000 -8 8
1001 -7 9
1010 -6 10
1011 -5 11
1100 -4 12
1101 -3 13
1110 -2 14
1111 -1 15
21
Mapping Signed 
Unsigned
Bits Signed Unsigned
0000 0 0
0001 1 1
0010 2 2
0011 3 3
0100 4 = 4
0101 5 5
0110 6 6
0111 7 7
1000 -8 8
1001 -7 9
1010 -6 10
1011 -5 +/- 16 11
1100 -4 12
1101 -3 13
1110 -2 14
1111 -1 15

22
Conversion Visualized

 2’s Comp.  Unsigned UMax

UMax – 1
 Ordering Inversion
 Negative  Big Positive
TMax + 1 Unsigned
TMax TMax Range

2’s Complement
0 0
Range
–1
–2

TMin
24
Negation: Complement & Increment

 Claim: Following Holds for 2’s Complement

~x + 1 == -x
 Complement
 Observation: ~x + x == 1111…111 == -1

x 10011101
+ ~x 01100010
-1 11111111

25
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

26
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
 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 <, >, ==, <=, >=

 Constant1 Constant2 Relation Evaluation

0 0U == unsigned
0 0U
-1 0 < signed
-1 0
-1 0U > unsigned
-1 0U
2147483647 -2147483648 > signed
2147483647 -2147483647-1
2147483647U -2147483648 < unsigned
2147483647U -2147483647-1
-1 -2 > signed
-1 -2
(unsigned) -1 -2 > unsigned
(unsigned)-1-2
2147483647 2147483648U < unsigned
2147483647 2147483648U
> signed
2147483647 (int) 2147483648U 28
 Code Security Example
/* Kernel memory region holding user-accessible data */
#define KSIZE 1024
char kbuf[KSIZE];

/* Copy at most maxlen bytes from kernel region to user buffer */

int copy_from_kernel(void *user_dest, int maxlen) {
/* Byte count len is minimum of buffer size and maxlen */
int len = KSIZE < maxlen ? KSIZE : maxlen;
memcpy(user_dest, kbuf, len);
return len;
}

 Similar to code found in FreeBSD’s implementation of

getpeername
 There are legions of smart people trying to find vulnerabilities
in programs
29
Typical Usage
/* Kernel memory region holding user-accessible data */
#define KSIZE 1024
char kbuf[KSIZE];

/* Copy at most maxlen bytes from kernel region to user buffer */

int copy_from_kernel(void *user_dest, int maxlen) {
/* Byte count len is minimum of buffer size and maxlen */
int len = KSIZE < maxlen ? KSIZE : maxlen;
memcpy(user_dest, kbuf, len);
return len;
}

#define MSIZE 528

void getstuff() {
char mybuf[MSIZE];
copy_from_kernel(mybuf, MSIZE);
printf(“%s\n”, mybuf);
}
30
Malicious Usage /* Declaration of library function memcpy */
void *memcpy(void *dest, void *src, size_t n);

/* Kernel memory region holding user-accessible data */

#define KSIZE 1024
char kbuf[KSIZE];

/* Copy at most maxlen bytes from kernel region to user buffer */

int copy_from_kernel(void *user_dest, int maxlen) {
/* Byte count len is minimum of buffer size and maxlen */
int len = KSIZE < maxlen ? KSIZE : maxlen;
memcpy(user_dest, kbuf, len);
return len;
}

#define MSIZE 528

void getstuff() {
char mybuf[MSIZE];
copy_from_kernel(mybuf, -MSIZE);
. . .
}
31
 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!!

32
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
 Making ints from bytes
 Summary

33
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 w
X • • •
k copies of MSB

• • •

X • • • • • •
 k w 34
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

35
 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 36
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

37
Unsigned Addition
u • • •
Operands: w bits
+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

38
Visualizing (Mathematical) Integer Addition

 Integer Addition Add4(u , v)

4-bit integers u, v
Integer Addition


 Compute true sum

Add4(u , v) 32

28
 Values increase 24

linearly with u and v 20

16
14

Forms planar surface

12 12
 8
10
8
4
6
0
0
4 v
2 2
4
6
8
u 10
12
14
0

39
Visualizing Unsigned Addition

 Wraps Around Overflow

 If true sum ≥ 2w UAdd4(u , v)

 At most once
16
True Sum 14

2w+1 Overflow 12

10

8
14
2 w 6
10
12

4
8
2
6 v
0 0
0
4

Modular Sum 2
4
6
8
2

u 10
12
14
0

40
Mathematical Properties

 Modular Addition Forms an Abelian Group

 Closed under addition
0   UAddw(u , v)     2w –1
 Commutative
UAddw(u , v)  =   UAddw(v , u)
 Associative
UAddw(t, UAddw(u , v))  =   UAddw(UAddw(t, u ), v)
 0 is additive identity
UAddw(u , 0)  =  u
 Every element has additive inverse
 Let UCompw (u )  = 2w – u
UAddw(u , UCompw (u ))  =  0

41
Two’s Complement Addition

u • • •
Operands: w bits
+ 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

42
TAdd Overflow

 Functionality True Sum

0 111…1 2w–1
 True sum requires PosOver
TAdd Result
w+1 bits 0 100…0 2w –1 011…1
 Drop off MSB
0 000…0 0
 Treat remaining 000…0

bits as 2’s comp. 1 011…1 –2w –1–1 100…0

integer
1 000…0 NegOver
–2w

43
Visualizing 2’s Complement Addition
NegOver

 Values
 4-bit two’s comp. TAdd4(u , v)
 Range from -8 to +7
 Wraps Around 8

6
 If sum  2w–1 4

2
 Becomes negative 0
6
-2 4
 At most once -4
2
0
-6
 If sum < –2w–1 -8 -4
-2

-8
-6 v
 Becomes positive -4
-2
0
2 -8
-6

4
PosOver
 At most once u 6

44
 Characterizing TAdd

Positive Overflow
 Functionality TAdd(u , v)
 True sum requires >0
w+1 bits v
<0
 Drop off MSB
Treat remaining bits <0 >0
 u
Negative Overflow
as 2’s comp. integer

u  v  22ww 1 u  v  TMin w (NegOver)


TAdd w (u,v)  u  v TMinw  u  v  TMax w
u  v  22ww1 TMax w  u  v
 (PosOver)

45
 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 46
 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

47
 Code Security Example #2
 SUN XDR library
Widely used library for transferring data between
void*machines
copy_elements(void *ele_src[], int ele_cnt, size_t ele_size);

ele_src

malloc(ele_cnt * ele_size)

48
 XDR Code
void* copy_elements(void *ele_src[], int ele_cnt, size_t ele_size) {
/*
* Allocate buffer for ele_cnt objects, each of ele_size bytes
* and copy from locations designated by ele_src
*/
void *result = malloc(ele_cnt * ele_size);
if (result == NULL)
/* malloc failed */
return NULL;
void *next = result;
int i;
for (i = 0; i < ele_cnt; i++) {
/* Copy object i to destination */
memcpy(next, ele_src[i], ele_size);
/* Move pointer to next memory region */
next += ele_size;
}
return result;
}
49
 XDR Vulnerability
malloc(ele_cnt * ele_size)
 What if:
 ele_cnt = 220 + 1
 ele_size = 4096 = 212
 Allocation = ??

 How can I make this function secure?

50
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

51
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
52
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
53
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

54
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 >>>
55
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

56
Arithmetic: Basic Rules
 Addition:
 Unsigned/signed: Normal addition followed by truncate,
same operation on bit level
 Unsigned: addition mod 2 w
 Mathematical addition + possible subtraction of 2w
 Signed: modified addition mod 2 w (result in proper range)
 Mathematical addition + possible addition or subtraction of 2w

 Multiplication:
 Unsigned/signed: Normal multiplication followed by truncate, same
operation on bit level
 Unsigned: multiplication mod 2 w
 Signed: modified multiplication mod 2 w (result in proper range)

60
Arithmetic: Basic Rules
 Unsigned ints, 2’s complement ints are isomorphic rings: isomorphism =
casting

 Left shift
 Unsigned/signed: multiplication by 2k
 Always logical shift

 Right shift
 Unsigned: logical shift, div (division + round to zero) by 2 k
 Signed: arithmetic shift
 Positivenumbers: div (division + round to zero) by 2 k
 Negative numbers: div (division + round away from zero) by 2 k
Use biasing to fix

61
Today: Integers
 Representing information as bits
 Bit-level manipulations
 Integers
 Representation: unsigned and signed
 Conversion, casting
 Expanding, truncating
 Addition, negation, multiplication, shifting
 Summary
 Making ints from bytes
 Summary

62
Properties of Unsigned Arithmetic

 Unsigned Multiplication with Addition Forms Commutative Ring

 Addition is commutative group
 Closed under multiplication
0   UMultw(u , v)    2w –1
 Multiplication Commutative
UMultw(u , v)  =   UMultw(v , u)
 Multiplication is Associative
UMultw(t, UMultw(u , v))  =   UMultw(UMultw(t, u ), v)
 1 is multiplicative identity
UMultw(u , 1)  =  u
 Multiplication distributes over addtion
UMultw(t, UAddw(u , v))  =   UAddw(UMultw(t, u ), UMultw(t, v))

63
 Properties of Two’s Comp. Arithmetic

 Isomorphic Algebras
 Unsigned multiplication and addition
 Truncating to w bits
 Two’s complement multiplication and addition
 Truncating to w bits
 Both Form Rings
 Isomorphic to ring of integers mod 2w
 Comparison to (Mathematical) Integer Arithmetic
 Both are rings
 Integers obey ordering properties, e.g.,
u>0 u+v>v
u > 0, v > 0  u · v > 0
 These properties are not obeyed by two’s comp. arithmetic
TMax + 1 == TMin
15213 * 30426 == -10030 (16-bit words)
64
Why Should I Use Unsigned?

 Don’t Use Just Because Number Nonnegative

 Easy to make mistakes
unsigned i;
for (i = cnt-2; i >= 0; i--)
a[i] += a[i+1];
 Can be very subtle
#define DELTA sizeof(int)
int i;
for (i = CNT; i-DELTA >= 0; i-= DELTA)
. . .
 Do Use When Performing Modular Arithmetic
 Multiprecision arithmetic
 Do Use When Using Bits to Represent Sets
 Logical right shift, no sign extension 65
Today: Integers
 Representing information as bits
 Bit-level manipulations
 Integers
 Representation: unsigned and signed
 Conversion, casting
 Expanding, truncating
 Addition, negation, multiplication, shifting
 Summary
 Making ints from bytes
 Summary

66
 Byte-Oriented Memory Organization
• •0 •• F
• •
00 FF
•••

 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
67
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
 Fractionsor multiples of word size
 Always integral number of bytes

68
 Word-Oriented Memory Organization
32-bit 64-bit
Bytes Addr.
Words Words
 Addresses Specify Byte
0000
Locations Addr
= 0001
 Address of first byte in word 0000
?? 0002
Addr
= 0003
 Addresses of successive 0000
?? 0004
Addr
words differ by 4 (32-bit) or = 0005
0004
?? 0006
8 (64-bit) 0007
0008
Addr
= 0009
0008
??
Addr
0010
= 0011
0008
?? 0012
Addr
=
0013
0012
?? 0014
0015
69
 Where do addresses come from?
 The compilation pipeline
0 1000
Library
Library Library
Routines
Routines Routines
0 100 1100
prog
prog PP P:
P: :: :: :
:: ::
push ......
push :: :
:: push ......
push
inc :: :
foo() inc inc SP, SP, 44
foo() inc SP,
SP, xx jmp jmp
jmp 175 jmp 1175
:: jmp jmp 75 75 175
jmp _foo
_foo :: :: :
:: :: ...... ...
75 ...... 175 1175
end
end PP foo: ......
foo:

Compilation Assembly Linking Loading

70
 int A[10];

 int main() {
 int j = 10;
 printf("Location and difference %p %ld(1-0) %ld(1-0)\n",
 &A[0],
 &A[1] - &A[0],
 &A[1] - A);
 printf(" Int differences %ld(sizeof) %ld(1-0) %ld(2-0) %ld(3-0)\n",
 sizeof(A[0]),
 &A[1] - &A[0],
 &A[2] - &A[0],
 &A[3] - &A[0]);
 printf(" Byte differences %ld(sizeof) %ld(1-0) %ld(2-0) %ld(3-0)\n",
 sizeof(A[0]),
 (char*)&A[1] - (char*)&A[0],
 (char*)&A[2] - (char*)&A[0],
 (char*)&A[3] - (char*)&A[0]);
 printf(" j Value %d pointer %p\n", j, &j);

 return 0;
 }

71
 int A[10];

 int main() {
 int j = 10;
 printf("Location and difference %p
%ld(1-0) %ld(1-0)\n",
 &A[0],
 &A[1] - &A[0],
 &A[1] - A);


72
 Output
 int A[10];

 int main() {
 int j = 10;
 printf("Location and difference %p %ld(1-0)
%ld(1-0)\n",
 &A[0],
 &A[1] - &A[0],
 &A[1] - A);
 Location and difference 0x601040 1(1-0) 1(1-0)

73
 int A[10];

 int main() {
 …
 printf(" Int differences
%ld(sizeof) %ld(1-0) %ld(2-0) %ld(3-0)\n",
 sizeof(A[0]),
 &A[1] - &A[0],
 &A[2] - &A[0],
 &A[3] - &A[0]);

74
 int A[10];

 int main() {
 …
 printf(" Int differences
%ld(sizeof) %ld(1-0) %ld(2-0) %ld(3-0)\n",
 sizeof(A[0]),
 &A[1] - &A[0],
 &A[2] - &A[0],
 &A[3] - &A[0]);
 Int differences 4(sizeof) 1(1-0) 2(2-0) 3(3-
0)

75
 int A[10];

 int main() {
 int j = 10;
 …
 printf(" Byte differences %ld(sizeof)
%ld(1-0) %ld(2-0) %ld(3-0)\n",
 sizeof(A[0]),
 (char*)&A[1] - (char*)&A[0],
 (char*)&A[2] - (char*)&A[0],
 (char*)&A[3] - (char*)&A[0]);
 printf(" j Value %d pointer %p\n",
j, &j);

76
 int A[10];

 int main() {
 int j = 10;
 …
 printf(" Byte differences %ld(sizeof)
%ld(1-0) %ld(2-0) %ld(3-0)\n",
 sizeof(A[0]),
 (char*)&A[1] - (char*)&A[0],
 (char*)&A[2] - (char*)&A[0],
 (char*)&A[3] - (char*)&A[0]);
 printf(" j Value %d pointer %p\n", j,
&j);
 Byte differences 4(sizeof) 4(1-0) 8(2-0) 12(3-0)

77
 int A[10];

 int main() {
 int j = 10;
 …
 printf(" j Value %d pointer %p\n", j,
&j);

 return 0;
 }

78
 int A[10];

 int main() {
 int j = 10;
 …
 printf(" j Value %d pointer %p\n", j,
&j);

 return 0;
 }
 j Value 10 pointer 0x7fff860787ec

79
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

80
 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
01 23
23 45
45 67
67
Little Endian 0x100 0x101 0x102 0x103
67
67 45
45 23
23 01
01
81
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

82
Examining Data Representations
 Code to Print Byte Representation of Data
 Casting pointer to unsigned char * creates byte array
typedef
typedef unsigned
unsigned char
char *pointer;
*pointer;

void
void show_bytes(pointer
show_bytes(pointer start,
start, int
int len){
len){
int
int i;
i;
for
for (i
(i == 0;
0; ii << len;
len; i++)
i++)
printf(”%p\t0x%.2x\n",start+i,
printf(”%p\t0x%.2x\n",start+i, start[i]);
start[i]);
printf("\n");
printf("\n");
}}

Printf directives:
%p: Print pointer
%x: Print Hexadecimal
83
show_bytes Execution Example
int
int aa == 15213;
15213;
printf("int
printf("int aa == 15213;\n");
15213;\n");
show_bytes((pointer)
show_bytes((pointer) &a,
&a, sizeof(int));
sizeof(int));

Result (Linux):
int
int aa == 15213;
15213;
0x11ffffcb8
0x11ffffcb8 0x6d
0x6d
0x11ffffcb9
0x11ffffcb9 0x3b
0x3b
0x11ffffcba
0x11ffffcba 0x00
0x00
0x11ffffcbb
0x11ffffcbb 0x00
0x00

84
Data alignment
 A memory address a, is said to be n-byte aligned
when a is a multiple of n bytes.
 n is a power of two in all interesting cases
 Every byte address is aligned
 A 4-byte quantity is aligned at addresses 0, 4, 8,…
 Some architectures require alignment (e.g., MIPS)
 Some architectures tolerate misalignment at
performance penalty (e.g., x86)

85
Data alignment in C structs
 Struct members are never reordered in C & C++
 Compiler adds padding so each member is aligned
 struct {char a; char b;} no padding
 struct {char a; short b;} one byte pad after a
 Last member is padded so the total size of the
structure is a multiple of the largest alignment of
any structure member (so struct can go in array)
 struct containing int requires 4-byte alignment
 struct containing long requires 8-byte (on 64-bit arch)

86
Data alignment malloc
 malloc(1)
 16-byte aligned results on 32-bit
 32-byte aligned results on 64-bit
 int posix_memalign(void **memptr, size_t
alignment, size_t size);
 Allocates size bytes
 Places the address of the allocated memory in *memptr
 Address will be a multiple of alignment, which must
be a power of two and a multiple of sizeof(void *)

87
 Decimal:
Decimal: 15213
15213
Representing Integers
Binary:
Binary: 0011
00111011
10110110
01101101
1101
Hex:
Hex: 33 BB 66 DD

int A = 15213; long int C = 15213;

IA32, x86-64 Sun
IA32 x86-64 Sun
6D 00
3B 00 6D 6D 00
00 3B 3B 3B 00
00 00 3B
00 6D
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)
88
 Representing Pointers
int
int BB == -15213;
-15213;
int
int *P
*P == &B;
&B; Sun IA32 x86-64
EF D4 0C
FF F8 89
FB FF EC
2C BF FF
FF
7F
00
00

Different compilers & machines assign different locations to objects

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

90
 Integer C Puzzles
• x<0  ((x*2) < 0)
• ux >= 0
• x & 7 == 7  (x<<30) < 0
• ux > -1
• x>y  -x < -y
• x * x >= 0
Initialization • x > 0 && y > 0  x + y > 0
• x >= 0  -x <= 0
int x = foo(); • x <= 0  -x >= 0
int y = bar(); • (x|-x)>>31 == -1
unsigned ux = x; • ux >> 3 == ux/8
• x >> 3 == x/8
unsigned uy = y;
• x & (x-1) != 0

91