Carnegie Mellon

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 1

 Carnegie Mellon

Bits, Bytes, and Integers – Part 2

15-213: Introduction to Computer Systems
3rd Lecture, May 29, 2021

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 2

 Carnegie Mellon

Assignment Announcements
 Lab 0 available via Autolab.
▪ Due Fri, June 4, 11:59pm
▪ No grace days
▪ No late submissions
▪ Just do it!
 Lab 1 available via Autolab
▪ Released
▪ Due Fri, June 4, 11:59pm
▪ Read instructions carefully: writeup, bits.c, tests.c
Quirky software infrastructure
▪
▪ Based on lectures 2, 3, and 4 (CS:APP Chapter 2)
▪ After today’s lecture you will know everything for the integer
problems
▪ Floating point covered Tue, June 1
Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 3
 Carnegie Mellon

Summary From Last Lecture

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

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 4

 Carnegie Mellon

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

Sign Bit

Two’s Complement Examples (w = 5)

-16 8 4 2 1
10 = 0 1 0 1 0 8+2 = 10

-16 8 4 2 1
-10 = 1 0 1 1 0 -16+4+2 = -10

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 5

 Carnegie Mellon

Unsigned & Signed Numeric Values

X B2U(X) B2T(X)  Equivalence
0000 0 0 ▪ Same encodings for nonnegative
0001 1 1 values
0010 2 2
 Uniqueness
0011 3 3
0100 4 4 ▪ Every bit pattern represents
0101 5 5 unique integer value
0110 6 6 ▪ Each representable integer has
0111 7 7 unique bit encoding
1000 8 –8  Expression containing signed
1001 9 –7
1010 10 –6
and unsigned int:
int is cast to unsigned
1011 11 –5
1100 12 –4
1101 13 –3
1110 14 –2
1111 15 –1

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 6

 Carnegie Mellon

Sign Extension and Truncation

 Sign Extension

 Truncation

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 7

 Carnegie Mellon

 Misunderstanding integers
can lead to the end of the
world as we know it!
 Thule (Qaanaaq), Greenland
 US DoD “Site J” Ballistic
Missile Early Warning
System (BMEWS)
 10/5/60: world nearly ends
 Missile radar echo: 1/8s
 BMEWS reports: 75s echo(!)
 1000s of objects reported
 NORAD alert level 5:
▪ Immediate incoming nuclear
attack!!!!

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 8

 Carnegie Mellon

 Kruschev was in NYC 10/5/60 (weird time to attack)

▪ someone in Qaanaaq said “why not go check outside?”
 “Missiles” were actually THE MOON RISING OVER NORWAY
 Expected max distance: 3000 mi; Moon distance: .25M miles!
 .25M miles % sizeof(distance) = 2200mi.
 Overflow of distance nearly caused nuclear apocalypse!!
Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 9
 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
 Representations in memory, pointers, strings
 Summary

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 10

 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 0 0 0000

1 1 0001
▪ Ignores carry output 2 2 0010
3 3 0011
 Implements Modular Arithmetic 4 4 0100
5 5 0101
s = UAddw(u , v) = u + v mod 2w 6 6 0110
7 7 0111
unsigned char 8 8 1000
1110 1001 E9 223 9 9 1001
+ 1101 0101 + D5 + 213 A 10 1010
B 11 1011
C 12 1100
D 13 1101
E 14 1110
F 15 1111
Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 11
 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 0 0 0000

1 1 0001
▪ Ignores carry output 2 2 0010
3 3 0011
 Implements Modular Arithmetic 4 4 0100
5 5 0101
s = UAddw(u , v) = u + v mod 2w 6 6 0110
7 7 0111
unsigned char 8 8 1000
1110 1001 E9 223 9 9 1001
+ 1101 0101 + D5 + 213 A 10 1010
B 11 1011
1 1011 1110 1BE 446 C 12 1100
D 13 1101
1011 1110 BE 190 E 14 1110
F 15 1111
Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 12
 Carnegie Mellon

Visualizing (Mathematical) Integer Addition

 Integer Addition Add4(u , v)
▪ 4-bit integers u, v Integer Addition

▪ Compute true sum

Add4(u , v)
▪ Values increase linearly 32
with u and v 28

▪ Forms planar surface 24

20
16
14
12 12
8 10
8
4
0 4
6
v
0
2 2
4
6
u 8
10
12
14
0

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 13

 Carnegie Mellon

Visualizing Unsigned Addition

 Wraps Around Overflow

▪ If true sum ≥ 2w
▪ At most once UAdd4(u , v)

True Sum 16
14
2w+1 Overflow 12
10
8
2w 6 12
14

4 10
8
2
6 v
0 0 4

Modular Sum 0
2
4
6
2

u 8
10
12
14
0

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 14

 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 1110 1001 E9 -23
+ 1101 0101 + D5 + -43
1 1011 1110 1BE -66
1011 1110 BE -66
Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 15
 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–1 011…1
▪ Treat remaining bits as
2’s comp. integer 0 000…0 0 000…0

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

1 000…0 NegOver
–2w

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 16

 Carnegie Mellon

Visualizing 2’s Complement Addition

NegOver

 Values
▪ 4-bit two’s comp. TAdd4(u , v)
▪ Range from -8 to +7
 Wraps Around
8
▪ If sum  2w–1 6

Becomes negative
▪ 4
2

▪ At most once 0
6

▪ If sum < –2w–1

-2 4
-4 2
0
▪ Becomes positive
-6
-2
-8

▪ At most once -8
-6
-4 -6
-4
v
-2
0 -8
2
u 4
6 PosOver

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 17

 Carnegie Mellon

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

u + v + 22ww−1 u + v  TMin w (NegOver)


TAddw (u,v) = u + v TMinw  u + v  TMax w
u + v − 22ww−1 TMax w  u + v (PosOver)


Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 18

 Carnegie Mellon

Multiplication
 Goal: Computing Product of w-bit numbers x, y
▪ Either signed or unsigned
 But, exact results can be bigger than w bits
▪ Unsigned: up to 2w bits
Result range: 0 ≤ x * y ≤ (2w – 1) 2 = 22w – 2w+1 + 1
▪
▪ Two’s complement min (negative): Up to 2w-1 bits
▪ Result range: x * y ≥ (–2w–1)*(2w–1–1) = –22w–2 + 2w–1
▪ Two’s complement max (positive): Up to 2w bits, but only for (TMinw)2
▪ Result range: x * y ≤ (–2w–1) 2 = 22w–2

 So, maintaining exact results…

▪ would need to keep expanding word size with each product computed
▪ is done in software, if needed
▪ e.g., by “arbitrary precision” arithmetic packages

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 19

 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
1110 1001 E9 223
* 1101 0101 * D5 * 213
1100 0001 1101 1101 C1DD 47499
1101 1101 DD 221
Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 20
 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

1110 1001 E9 -23

* 1101 0101 * D5 * -43
0000 0011 1101 1101 03DD 989
1101 1101 DD -35
Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 21
 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
Important Lession:
Trust Your Compiler!
Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 22
 Carnegie Mellon

Multiplication
 Goal: Computing Product of w-bit numbers x, y
▪ Either signed or unsigned
 But, exact results can be bigger than w bits
▪ Unsigned: up to 2w bits
Result range: 0 ≤ x * y ≤ (2w – 1) 2 = 22w – 2w+1 + 1
▪
▪ Two’s complement min (negative): Up to 2w-1 bits
▪ Result range: x * y ≥ (–2w–1)*(2w–1–1) = –22w–2 + 2w–1
▪ Two’s complement max (positive): Up to 2w bits, but only for (TMinw)2
▪ Result range: x * y ≤ (–2w–1) 2 = 22w–2

 So, maintaining exact results…

▪ would need to keep expanding word size with each product computed
▪ is done in software, if needed
▪ e.g., by “arbitrary precision” arithmetic packages

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 23

 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

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 24

 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

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 25

 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  0 •••
1 1 1 1 ••• . 1 ••• 1 1

Biasing has no effect

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 26
 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  0 •••
1 1 1 1 ••• . •••

Incremented by 1
Biasing adds 1 to final result
Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 27
 Carnegie Mellon

Negation: Complement & Increment

 Negate through complement and increase
~x + 1 == -x
 Example
▪ Observation: ~x + x == 1111…111 == -1

x 10011101
+ ~x 0 1 1 0 0 0 1 0
-1 11111111

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
Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 28
 Carnegie Mellon

Complement & Increment Examples

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

x = TMin
Decimal Hex Binary
x -32768 80 00 10000000 00000000
~x 32767 7F FF 01111111 11111111
~x+1 -32768 80 00 10000000 00000000

Canonical counter example

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 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
 Representations in memory, pointers, strings

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 30

 Carnegie Mellon

Arithmetic: Basic Rules

 Addition:
▪ Unsigned/signed: Normal addition followed by truncate,
same operation on bit level
▪ Unsigned: addition mod 2w
▪ Mathematical addition + possible subtraction of 2w
▪ Signed: modified addition mod 2w (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 2w
▪ Signed: modified multiplication mod 2w (result in proper range)

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 31

 Carnegie Mellon

Why Should I Use Unsigned?

 Don’t use without understanding implications
▪ 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)
. . .

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 32

 Carnegie Mellon

Counting Down with Unsigned

 Proper way to use unsigned as loop index
unsigned i;
for (i = cnt-2; i < cnt; i--)
a[i] += a[i+1];
 See Robert Seacord, Secure Coding in C and C++
▪ C Standard guarantees that unsigned addition will behave like modular
arithmetic
▪ 0 – 1 → UMax

 Even better
size_t i;
for (i = cnt-2; i < cnt; i--)
a[i] += a[i+1];
▪ Data type size_t defined as unsigned value with length = word size

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 33

 Carnegie Mellon

Why Should I Use Unsigned? (cont.)

 Do Use When Performing Modular Arithmetic
▪ Multiprecision arithmetic
 Do Use When Using Bits to Represent Sets
▪ Logical right shift, no sign extension
 Do Use In System Programming
▪ Bit masks, device commands,…

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 34

 Carnegie Mellon

Quiz Time!

Check out:

https://canvas.cmu.edu/courses/23122/quizzes/61
569

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 35

 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
 Representations in memory, pointers, strings

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 36

 Carnegie Mellon

Byte-Oriented Memory Organization

•••

 Programs refer to data by address

▪ Conceptually, envision it as a very large array of bytes
In reality, it’s not, but can think of it that way
▪
▪ An address is like an index into that array
▪ and, a pointer variable stores an address

 Note: system provides private address spaces to each “process”

▪ Think of a process as a program being executed
▪ So, a program can clobber its own data, but not that of others

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 37

 Carnegie Mellon

Machine Words
 Any given computer has a “Word Size”
▪ Nominal size of integer-valued data
▪ and of addresses

▪ Until recently, most machines used 32 bits (4 bytes) as word size

▪ Limits addresses to 4GB (232 bytes)

▪ Increasingly, machines have 64-bit word size

▪ Potentially, could have 18 EB (exabytes) of addressable memory
▪ That’s 18.4 X 1018

▪ Machines still support multiple data formats

▪ Fractions or multiples of word size
▪ Always integral number of bytes
Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 38
 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
Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 39
 Carnegie Mellon

Example Data Representations

C Data Type Typical 32-bit Typical 64-bit x86-64

char 1 1 1
short 2 2 2
int 4 4 4
long 4 8 8
float 4 4 4
double 8 8 8

pointer 4 8 8

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 40

 Carnegie Mellon

Byte Ordering
 So, how are the bytes within a multi-byte word ordered in
memory?
 Conventions
▪ Big Endian: Sun (Oracle SPARC), PPC Mac, Internet
Least significant byte has highest address
▪
▪ Little Endian: x86, ARM processors running Android, iOS, and Linux
▪ Least significant byte has lowest address

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 41

 Carnegie Mellon

Byte Ordering Example

 Example
▪ Variable x has 4-byte value of 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

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 42

 Carnegie Mellon

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

int A = 15213; long int C = 15213;

Increasing addresses

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

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 43

 Carnegie Mellon

Examining Data Representations

 Code to Print Byte Representation of Data
▪ Casting pointer to unsigned char * allows treatment as a byte array
typedef unsigned char *pointer;

void show_bytes(pointer start, size_t len){

size_t i;
for (i = 0; i < len; i++)
printf(”%p\t0x%.2x\n",start+i, start[i]);
printf("\n");
}

Printf directives:
%p: Print pointer
%x: Print Hexadecimal

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 44

 Carnegie Mellon

show_bytes Execution Example

int a = 15213;
printf("int a = 15213;\n");
show_bytes((pointer) &a, sizeof(int));

Result (Linux x86-64):

int a = 15213;
0x7fffb7f71dbc 6d
0x7fffb7f71dbd 3b
0x7fffb7f71dbe 00
0x7fffb7f71dbf 00

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 45

 Carnegie Mellon

Representing Pointers
int B = -15213;
int *P = &B;

Sun IA32 x86-64

EF AC 3C
FF 28 1B
FB F5 FE
2C FF 82
FD
7F
00
00

Different compilers & machines assign different locations to objects

Even get different results each time run program
Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 46
 Carnegie Mellon

Representing Strings
char S[6] = "18213";
 Strings in C
▪ Represented by array of characters
▪ Each character encoded in ASCII format IA32 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
▪ man ascii for code table 31 31
▪ String should be null-terminated 33 33
▪ Final character = 0
00 00
 Compatibility
▪ Byte ordering not an issue

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 47

 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

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 48

 Carnegie Mellon

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

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 49

 Carnegie Mellon

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
unsigned uy = y; x >> 3 == x/8
x & (x-1) != 0

Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 50