Bits and Bytes

Topics

Representing information as bits Bit-level manipulations

Boolean algebra Expressing in C

Binary Representations
Base 2 Number Representation

Represent 1521310 as 111011011011012 Represent 1.2010 as 1.0011001100110011[0011]2 Represent 1.5213 X 104 as 1.11011011011012 X 213

Electronic Implementation

Easy to store with bistable elements Reliably transmitted on noisy and inaccurate wires
0 1 0

3.3V 2.8V

0.5V
0.0V
2 CMSC 313, F 09

Encoding Byte Values

Byte = 8 bits

Binary 000000002 Decimal: 010 Hexadecimal 0016

to to to

111111112 25510 FF16

First digit must not be 0 in C

Base 16 number representation Use characters 0 to 9 and A to F Write FA1D37B16 in C as 0xFA1D37B

Or 0xfa1d37b

0 1 2 3 4 5 6 7 8 9 A B C D E F

0 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15

0000 0001 0010 0011 0100 0101 0110 0111 1000 1001 1010 1011 1100 1101 1110 1111

CMSC 313, F 09

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

4

Where different program objects should be stored All allocation within single virtual address space
CMSC 313, F 09

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

CMSC 313, F 09

Word-Oriented Memory Organization 32-bit 64-bit

Words Words

Bytes Addr. 0000 0001 0002 0003 0004 0005 0006 0007 0008 0009 0010 0011 0012 0013 0014 0015
CMSC 313, F 09

Addresses Specify Byte Locations

Addr = 0000 ?? Addr = 0000 ?? Addr = 0004 ??

Address of first byte in word Addresses of successive words differ by 4 (32-bit) or 8 (64-bit) 1 word equals to 4 byte In 64 bits, 1 word equals 8 bytes.

Addr = 0008 ??

Addr = 0008 ??

Addr = 0012 ?? 6

Data Representations
Sizes of C Objects (in Bytes)

C Data Type
char 1 short 2 int

Typical 32-bit Intel IA32

1 2 4 4 8 4 8 8 4 1 2 4 8 8 4 8 10/12 8

x86-64

4 long 4 long long float 4 double long double char * 4

8 8 10/16

Or any other pointer

CMSC 313, F 09

Byte Ordering
How should bytes within multi-byte word be ordered in memory?
Conventions

Big Endian: Sun, PPC Mac, Internet

(used in Internet Protocols) Least significant byte has highest address

Example: Windows OS Least significant byte has lowest address

Little Endian: x86

CMSC 313, F 09

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

0x100 0x101 0x102 0x103

Big Endian

01
Little Endian

23

45

67

0x100 0x101 0x102 0x103

67
9

45

23

01
CMSC 313, F 09

Reading Byte-Reversed Listings

Disassembly

Text representation of binary machine code Generated by program that reads the machine code

Example Fragment
Address 8048365: 8048366: 804836c: Instruction Code 5b 81 c3 ab 12 00 00 83 bb 28 00 00 00 00 Assembly Rendition pop %ebx add $0x12ab,%ebx cmpl $0x0,0x28(%ebx)

Deciphering Numbers

10

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

CMSC 313, F 09

Examining Data Representations

Code to Print Byte Representation of Data

Casting pointer to unsigned char * creates byte array

typedef unsigned char *pointer; void show_bytes(pointer start, int len) { int i; for (i = 0; i < len; i++) printf("0x%p\t0x%.2x\n", start+i, start[i]); printf("\n"); } printf directives: %p: Print pointer %x: Print Hexadecimal

11

CMSC 313, F 09

show_bytes Execution Example

int a = 15213; printf("int a = 15213;\n");

show_bytes((pointer) &a, sizeof(int));

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

0x11ffffcbb
12

0x00
CMSC 313, F 09

Representing Integers
int A = 15213; int B = -15213;
Decimal: 15213 Binary: Hex: IA32 A 6D 3B 00 00 Sun A 00 00 3B 6D IA32 B 93 C4 FF FF 0011 1011 0110 1101 3 B 6 Sun B FF FF C4 93 D

Twos complement representation (Covered later)

13

CMSC 313, F 09

Representing Pointers
int B = -15213; int *P = &B;
Sun P EF FF FB 2C IA32 P D4 F8 FF BF

Different compilers & machines assign different locations to objects

14 CMSC 313, F 09

Representing Strings
Strings in C

char S[6] = "15213";

Linux/Alpha S Sun S 31 35 32 31 33 00 31 35 32 31 33 00

Represented by array of characters Each character encoded in ASCII format

Standard 7-bit encoding of character set Character 0 has code 0x30

Digit i has code 0x30+i

String should be null-terminated

Final character = 0

Compatibility

Byte ordering not an issue

15

CMSC 313, F 09

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

~A = 1 when A=0

Exclusive-Or (xor)

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

16

CMSC 313, F 09

Application of Boolean Algebra

Applied to Digital Systems by Claude Shannon

1937 MIT Masters Thesis Reason about networks of relay switches

Encode closed switch as 1, open switch as 0

A&~B
A ~A ~B

Connection when A&~B | ~A&B

B ~A&B

= A^B

17

CMSC 313, F 09

General Boolean Algebras

Operate on Bit Vectors

Operations applied bitwise

01101001 & 01010101 01000001 01000001

01101001 | 01010101 01111101 01111101

01101001 ^ 01010101 00111100 00111100

~ 01010101 10101010 10101010

All of the Properties of Boolean Algebra Apply

18

CMSC 313, F 09

Representing & Manipulating Sets

Representation

Width w bit vector represents subsets of {0, , w1} aj = 1 if j A 01101001 { 0, 3, 5, 6 } 76543210 01010101 76543210
{ 0, 2, 4, 6 }

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 }
CMSC 313, F 09

19

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 ~0x41 -->

~010000012

Examples (char data type)

0xBE
--> 101111102 111111112

~0x00 -->
~000000002

0xFF
-->

0x69 & 0x55 0x69 | 0x55

--> -->

0x41 0x7D

011010012 & 010101012 --> 010000012

011010012 | 010101012 --> 011111012

20 CMSC 313, F 09

Contrast: Logic Operations in C

Contrast to Logical Operators

&&, ||, !
View 0 as False Anything nonzero as True Always return 0 or 1 Early termination (short-cut evaluation)

Examples (char data type)

!0x41 --> !0x00 --> !!0x41 -->

0x00 0x01 0x01 --> --> 0x01 0x01

CMSC 313, F 09

21

0x69 && 0x55 0x69 || 0x55 p && *p access)

(avoids null pointer

Shift Operations
Left Shift:

x << y
Argument x 01100010 << 3 Log. >> 2 00010000 00011000

Shift bit-vector x left y positions

Throw away extra bits on left Fill with 0s on right

Right Shift:

x >> y

Shift bit-vector x right y positions

Throw away extra bits on right

Arith. >> 2 00011000

Argument x 10100010 << 3 Log. >> 2 00010000 00101000

Logical shift
Fill with 0s on left

Arithmetic shift
Replicate most significant bit on

Arith. >> 2 11101000

right

Undefined Behavior
22

Shift amount < 0 or word size

CMSC 313, F 09

C operator quiz
int x = 44;
int y = 10; int z;
z = x & y; printf( %x, %d, z, z ); /* output: 0x10, 8 */

z = y | x; printf( %x, %d, z, z ); /* output: 0x2E, 46 */ z = (x & 0x4) << 2; printf( %x, %d, z, z ); /* output: 0x20, 32 */ z = (y | 5) & 0x3; /* output: 0x3, 3 */ printf( %x, %d, z, z ); z = x && y; printf( %d, z ); /* output: 1 */

23

CMSC 313, F 09