Bits, Bytes and Integers

CSCI 232: Computer Organization

Week 2
reading:
Bryant & O’Hallaron, Ch. 2
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
 Everything is bits
 Each bit is 0 or 1
 By encoding/interpreting sets of bits in various ways
▪ Computers determine what to do (instructions)
▪ … and represent and manipulate numbers, sets, strings, etc…
 Why bits? Electronic Implementation
▪ Easy to store with bistable elements
▪ Reliably transmitted on noisy and inaccurate wires
0 1 0

1.1V
0.9V

0.2V
0.0V
Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 6
 Encoding Byte Values
0 0 0000
 Byte = 8 bits 1 1 0001
▪ Binary 000000002 to 111111112 2 2 0010
3 3 0011
▪ Decimal: 010 to 25510 4 4 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
▪ Write FA1D37B16 in C as A 10 1010
B 11 1011
– 0xFA1D37B C 12 1100
– 0xfa1d37b D 13 1101
E 14 1110
F 15 1111
Decimal to binary by successive divisions

15213: 0011 1011 0110 1101

3 B 6 D
Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 8
 Example Data Representations
C Data Type Typical 32-bit Typical 64-bit x86-64

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

pointer 4 8 8

Integeres are always represented in twos complement form.

Sizes in bytes
The number of bytes allocated varies with machine and compiler. This chart shows the values typical of
32-bit and 64-bit machines

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

 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 10

Terminologies for integer data/arithmetic
 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 11

 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 11

 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

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

 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

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

 Example: 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 }
Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 14
 Bit-Level Operations in C
 Operations &, |, ~, ^ Available in C
0 0 0000
▪ Apply to any “integral” data type 1 1 0001
▪ long, int, short, char, unsigned 2 2 0010
3 3 0011
▪ View arguments as bit vectors 4 4 0100
5 5 0101
▪ Arguments applied bit-wise 6 6 0110
 Examples (Char data type) 7 7 0111
8 8 1000
▪ ~0x41 → 0xBE 9 9 1001
~0100 000122→
~01000001
▪ →10111110
1011 11102 2 A 10 1010
B 11 1011
▪ ~0x00 → 0xFF C 12 1100
▪ ~0000
~00000000
000022→→11111111
1111 11112 2 D 13 1101
E 14 1110
▪ 0x69 & 0x55 → 0x41 F 15 1111
▪ 0110
01101001
100122&&01010101
0101 01012 2→→01000001
0100 0001
2 2

▪ 0x69 | 0x55 → 0x7D

▪ 0110
01101001
100122||01010101
0101 01012 2→→01111101
0111 1101
2 2

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

 Contrast: Logic Operations in C
 Contrast to Bit-Level Operators
▪ Logic Operations: &&, ||, !
▪ View 0 as “False”
▪ Anything nonzero as “True”
▪ Always return 0 or 1
▪ Early termination
 Examples (char data type)
Watch out for && vs. & (and || vs. |)…
▪ !0x41 → 0x00 Super common C programming pitfall!
▪ !0x00 → 0x01
▪ !!0x41→ 0x01

▪ 0x69 && 0x55 → 0x01

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

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

 Logic Operations in C

Line 1 - Condition is true

Line 2 - Condition is true
Line 3 - Condition is not true
Line 4 - Condition is true
 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
▪
▪ Logical shift
▪ Fill with 0’s on left
▪ Arithmetic shift
▪ Replicate most significant bit on left

 Undefined Behavior
▪ Shift amount < 0 or ≥ word size
Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 18
 Logic Shift Operation
#include<stdio.h>
int main()
Output
{
// a = 5(00000101), b = 9(00001001) a<<1 = 10 b<<1 = 18
unsigned char a = 5, b = 9;

// The result is 00001010

printf("a<<1 = %d\n", a<<1);

// The result is 00010010

printf("b<<1 = %d\n", b<<1);
return 0;
}
 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
 Summary

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

 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

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
The hexadecimal value of a negative decimal number can be obtained starting from the binary
 Sign Bit value of that decimal number positive value.The binary value needs to be negated and then, to add
1.
▪ For 2’s complement, most significant bit indicates sign
▪ 0 for nonnegative
▪ 1 for negative 20
Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition
 Two-complement: Simple Example

-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

A two's-complement number system encodes positive and negative numbers in a

binary number representation. The weight of each bit is a power of two, except for the
most significant bit, whose weight is the negative of the corresponding power of two.

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

 Two-complement 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
Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 22
 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
▪ 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

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

 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

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

 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   Can Invert Mappings
1001 9 –7
1010 10 –6
▪ U2B(x) = B2U-1(x)
1011 11 –5 ▪Bit pattern for unsigned
1100 12 –4 integer
1101 13 –3 ▪ T2B(x) = B2T-1(x)
1110 14 –2 ▪ Bit pattern for two’s comp
1111 15 –1 integer
Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 25
 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 27

 Mapping Signed  Unsigned
Bits Signed Unsigned
0000 0 0
0001 1 1
0010 2 2
0011 3 3
0100 4 4
0101 5 5
T2U
0110 6 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
Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 29
 Relation between Signed & Unsigned

Two’s Complement Unsigned

T2U
x T2B B2U ux
X
Maintain Same Bit Pattern

w–1 0
ux + + + ••• +++
x - ++ ••• +++

Large negative weight

becomes
Large positive weight
Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition 31
 • Consider the following
example where the cast
Type casting operator causes the division of
one integer variable by
another to be performed as a
• Converting one datatype into floating-point operation.
another is known as type #include <stdio.h>
casting or, type-conversion. For main() {

example, if you want to store a int sum = 17, count = 5;

double mean;
'long' value into a simple mean = (double) sum / count;
integer then you can type cast printf("Value of mean : %f\n", mean );

'long' to 'int'. You can convert }

the values from one type to

another explicitly using • Output:
the cast operator. Value of mean : 3.400000
 Signed vs. Unsigned in C
 Constants
▪ By default are considered to be signed integers

 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; int fun(unsigned u);
uy = ty; uy = fun(tx);

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

 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 37

 Sign Extension
Sign extension is the operation, in computer arithmetic, of increasing the number of bits of a binary
 Task: number while preserving the number's sign (positive/negative) and value.

▪ 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
Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition
w 38
 Sign Extension: Simple Example

Positive number Negative number

-16 8 4 2 1 -16 8 4 2 1

10 = 0 1 0 1 0 -10 = 1 0 1 1 0

-32 16 8 4 2 1 -32 16 8 4 2 1

10 = 0 0 1 0 1 0 -10 = 1 1 0 1 1 0

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

 Larger 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

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

 Truncation
The trunc() math function in C programming language returns
the truncated value from the floating point value and return
integer value.

trunc() : This function truncates the decimal value from floating

point value and returns an integer value.

#include <stdio.h>
#include <math.h>
int main() truncated value of
{ 17.070000 is 17.000000
double x=17.07,y=46.107,z=234.867; truncated value of
printf("truncated value of %f is %f\n",x,trunc(x)); 46.107000 is 46.000000
printf("truncated value of %f is %f\n",y,trunc(y)); truncated value of
printf("truncated value of %f is %f\n",y,trunc(z)); 234.867000 is 234.000000
getch();
return 0;}
 Truncation
 Task:
▪ Given k+w-bit signed or unsigned integer X
▪ Convert it to w-bit integer X’ with same value for “small enough” X
 Rule:
▪ Drop top k bits:
▪ X  = xw–1 , xw–2 ,…, x0

k w
X ••• •••

•••

X •••
w 41
Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition
 Modulus Method

2 mod 16 example

The modulus method requires us to first find out what the highest common
multiple of the Divisor (16) is that is equal to or less than the Dividend (2).

We can see that multiples of 16 are 0, 16, 32, 48, etc. The highest multiple
that is less than or equal to 2 is 0.

So the final step in the modulus method here is to subtract the divisor
highest multiple from the Dividend and answer the question "what is 2
modulus 16?":

2-0=2
 Truncation: Simple Example
No sign change Sign change
-16 8 4 2 1 -16 8 4 2 1

2 = 0 0 0 1 0 10 = 0 1 0 1 0

-8 4 2 1 -8 4 2 1

2 = 0 0 1 0 -6 = 1 0 1 0
2 mod 16 = 2 10 mod 16 = 10U mod 16 = 10U = -6

-16 8 4 2 1 -16 8 4 2 1

-6 = 1 1 0 1 0 -10 = 1 0 1 1 0

-8 4 2 1 -8 4 2 1

-6 = 1 0 1 0 6 = 0 1 1 0
-6 mod 16 = 26U mod 16 = 10U = -6 -10 mod 16 = 22U mod 16 = 6U = 6

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

 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 (in magnitude) numbers yields expected behavior

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

Integral Data Types
• C supports a variety of integral data types—ones that represent finite
ranges of integers along with the ranges of values they can have for
“typical” 32- and 64-bit programs.

• Each type can specify a size with keyword char, short, long, as well as
an indication of whether the represented numbers are all
nonnegative (declared as unsigned), or possibly negative (the
default.)
Typical ranges for C integral data types for
32-bit programs
Typical ranges for C integral data types for
64-bit programs
Guaranteed ranges for C integral data types
 AURAK

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

53
 AURAK

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

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

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
long double − − 10/16

pointer 4 8 8

56
 AURAK

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

57
 AURAK

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

58
 AURAK

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
3B 00 6D 6D 00
3B 3B 00
00 3B
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

59
 AURAK

Representing Pointers
int B = -15213;
int *P = &B;
declare an integer
pointer ‘p’ and assign Sun IA32 x86-64
the address of ‘b’ to it 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 62

 AURAK

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
 String should be null-terminated 31 31
 Final character = 0
33 33
 Compatibility 00 00
 Byte ordering not an issue

63