the hardware/software interface › courses › cse351 › ... · the hardware/software interface...

The Hardware/Software Interface CSE351 Spring 2015

Instructor: Katelin Bailey

Teaching Assistants: Kaleo Brandt, Dylan Johnson, Luke Nelson, Alfian Rizqi, Kritin Vij, David Wong, and Shan Yang

Lecture 3

Announcements

2

• Everyone waiting to get in should have heard by now• If we talked about auditing, please send me mail so I have your UWnetIDs

Announcements

2

mailto:[email protected]


• Lab 0 due on Monday, still having fun?• Covering arrays today in lecture

Announcements

2




• Lab 1 goes out today, by the end of class

Announcements

2




• Lab 1 goes out today, by the end of class• Stuck on something? Confused at the end of class?

• Post on the discussion board• Come by office hours (mine or the TAs: posted online)• Send mail to [email protected]

Announcements

2






• Readings for each lecture are posted on the website

Announcements

2






• Readings for each lecture are posted on the website• Slides for each lecture are posted ~1 day ahead of time

• A 1-page summary of concepts and definitions will go up after class Not everything you need to know but most of the important topics.

Announcements

2


Roadmap

3

‣Memory, data, & addressing ‣ Integers & floats ‣Machine code & C ‣ x86 assembly ‣ Procedures & stacks ‣ Arrays & structs ‣Memory & caches ‣ Processes ‣ Virtual memory ‣Memory allocation ‣ Java vs. C

car *c = malloc(sizeof(car)); c->miles = 100; c->gals = 17; float mpg = get_mpg(c); free(c);

Car c = new Car(); c.setMiles(100); c.setGals(17); float mpg = c.getMPG();

get_mpg: pushq %rbp movq %rsp, %rbp ... popq %rbp ret

Java:C:

Assembly language:

Machine code: 0111010000011000 100011010000010000000010 1000100111000010 110000011111101000011111

Computer system:

OS:

• Brief review of topics from last lecture• Arrays and address arithmetic• Strings as arrays• Boolean algebra and bitwise manipulations

Today

4

• Brief review of topics from last lecture • Arrays and address arithmetic• Strings as arrays• Boolean algebra and bitwise manipulations

Today

5

Binary, Hex, Decimal Format (review)

6

• Byte = 8 bits (binary digits) = 2 hex digits


6


• 0x 00 00 01 5F is hex format • 4 bytes —> 32 bits


6



• In Binary?• 0000 0000 0000 0000 0000 0001 0101 1111• 101011111


6



• In Binary?• 0000 0000 0000 0000 0000 0001 0101 1111• 101011111


6

1 0 1 0 1 1 1 1 1 binary number8 7 6 5 4 3 2 1 0 bit numbering

28 27 26 25 24 23 22 21 20 bit numbering



• In Binary?• 0000 0000 0000 0000 0000 0001 0101 1111• 101011111

• In Decimal?• 28 + 26 + 24 + 23 + 22 + 21 + 20

• 256+64+16+8+4+2+1 =>351• Bits are numbered from 0!


6

1 0 1 0 1 1 1 1 1 binary number8 7 6 5 4 3 2 1 0 bit numbering

28 27 26 25 24 23 22 21 20 bit numbering

Words & Addresses (review)

7

• A word is fixed number of contiguous bytes in memory, chosen by HW

• the largest unit of data a machine instruction can use


7


• the largest unit of data a machine instruction can use• word size = address size = register size (Always!)

• take advantage of all bytes we’re given, can’t use more than we have!


7



• take advantage of all bytes we’re given, can’t use more than we have!• Word size bounds the size of the address space and memory.

• word size = w bits —> 2w addresses• 32-bit (4-byte) words —> 32-bit (4-byte) addresses —> 232 bytes of space• 64-bit (8-byte) words —> 64-bit (8-byte) addresses —> 264 bytes of space


7



• take advantage of all bytes we’re given, can’t use more than we have!• Word size bounds the size of the address space and memory.

• word size = w bits —> 2w addresses• 32-bit (4-byte) words —> 32-bit (4-byte) addresses —> 232 bytes of space• 64-bit (8-byte) words —> 64-bit (8-byte) addresses —> 264 bytes of space

• Doesn’t mean we have 232 bytes (4GB) of memory, just means we could find all of those bytes if we had them.


7

0x000x040x080x0C0x100x140x180x1C0x200x24

• Data of size n only stored at addresses a where a mod n = 0

• n is usually a power of 2.• A 32-bit (4-byte) word-aligned

view of memory:• Each row is a word composed of 4 bytes.• Cells in a row are the word’s bytes.

Memory Alignment (review)

8

More about alignment later in the course.

0x00 0x01 0x02 0x03(note hex addresses)

0x04 0x05 0x06 0x07

0x000x040x080x0C0x100x140x180x1C0x200x24

• An address is a location in memory• A pointer is a data object that holds an address.• The value 351 is stored at address 0x04.

• 35110 = 15F16 = 0x00 00 01 5F• A pointer stored at address 0x1C

points to address 0x04.• A pointer to a pointer is stored at address 0x24. • The value 12 is stored

at address 0x14. • Is it a pointer?

Addresses and Pointers (review)

9

5F010000

04000000

1C000000

1C000000

0x000x040x080x0C0x100x140x180x1C0x200x24

Big & Little Endian (review)

10

5F010000

04000000

1C000000

1C000000

0x000x040x080x0C0x100x140x180x1C0x200x24


10

5F010000

04000000

1C000000

1C000000

Big-Endian

0x000x040x080x0C0x100x140x180x1C0x200x24


10

5F010000

04000000

1C000000

1C000000

Little-Endian Big-Endian

0x000x040x080x0C0x100x140x180x1C0x200x24


10

5F010000

04000000

1C000000

1C000000

0x000x040x080x0C0x100x140x180x1C0x200x24

0000015F

00000004

0000001C

0000001C

Little-Endian Big-Endian

• Left-hand-side = right-hand-side;• LHS must evaluate to a memory location.• RHS must evaluate to a value. (Could be an address!)• Store RHS value at LHS location.

• int x, y;• x = 0;• y = 0x3CD02700;• x = y + 3;

• // Get value at y, add 3, put it in x.• int *z

Assignment in C (review)

11

0x000x040x080x0C0x100x140x180x1C0x200x24

3CD02703

3CD02700

& = ‘address of ’* = ‘value at address’ or ‘dereference’

x

y

z


• int x, y;• x = 0;• y = 0x3CD02700;• x = y + 3;

• // Get value at y, add 3, put it in x.• int *z = &y + 3;

• // Get address of y, add 12 put it in z


12

0x000x040x080x0C0x100x140x180x1C0x200x24

3CD02703

3CD02700


x

y

z00000024


• int x, y;• x = 0;• y = 0x3CD02700;• x = y + 3;




12

0x000x040x080x0C0x100x140x180x1C0x200x24

3CD02703

3CD02700


x

y

z

Pointer arithmetic is scaled by size of target type.

00000024


• int x, y;• x = 0;• y = 0x3CD02700;• x = y + 3;




12

0x000x040x080x0C0x100x140x180x1C0x200x24

3CD02703

3CD02700


x

y

z


00000024

0x18 = 24 (decimal) + 12 36 = 0x24


• int x, y;• x = 0;• y = 0x3CD02700;• x = y + 3;




12

0x000x040x080x0C0x100x140x180x1C0x200x24

3CD02703

3CD02700


x

y

z


Pointer arithmetic can be dangerous.

00000024

0x18 = 24 (decimal) + 12 36 = 0x24


• int x, y;• x = 0;• y = 0x3CD02700;• x = y + 3;


• // Get address of y, add 12 put it in z• *z = y;

• // Get value of y, put it at the address stored in z


13

0x000x040x080x0C0x100x140x180x1C0x200x24

3CD02703

3CD02700


x

y

z00000024

3CD02700

• Brief review of topics from last lecture• Arrays and address arithmetic • Strings as arrays• Boolean algebra and bitwise manipulations

Today

14

Arrays in C

15

Declaration: int a[6]; a is a name for the array’s address,not a pointer to the array.

Arrays are adjacent locations in memory storing the same type of data object.

0x000x040x080x0C0x100x140x180x1C0x200x24

Arrays in C

15



element type

0x000x040x080x0C0x100x140x180x1C0x200x24

Arrays in C

15



element type

name

0x000x040x080x0C0x100x140x180x1C0x200x24

Arrays in C

15



element type

name

number of elements

0x000x040x080x0C0x100x140x180x1C0x200x24

Arrays in C

16

Declaration: int a[6];

0x000x040x080x0C0x100x140x180x1C0x200x24

a[0]a[1]

a[5]

…

Indexing: The address of a[i] is the address of a[0] plus i times the element size in bytes.

a is a name for the array’s address,not a pointer to the array.


Arrays in C

16


0x000x040x080x0C0x100x140x180x1C0x200x24

a[0]a[1]

a[5]

…

a[0] = 0x015f; a[5] = a[0];




Arrays in C

16


0x000x040x080x0C0x100x140x180x1C0x200x24

0000015F a[0]a[1]

a[5]

…

a[0] = 0x015f; a[5] = a[0];




Arrays in C

16


0x000x040x080x0C0x100x140x180x1C0x200x24

0000015F

0000015F

a[0]a[1]

a[5]

…

a[0] = 0x015f; a[5] = a[0];




Arrays in C

16


0x000x040x080x0C0x100x140x180x1C0x200x24

0000015F

0000015F

a[0]a[1]

a[5]

…

a[0] = 0x015f; a[5] = a[0];




sizeof(int) = 4 =word size (convenient)

Arrays in C

17


0x000x040x080x0C0x100x140x180x1C0x200x24

0000015F

0000015F

a[0]a[1]

a[5]

…

a[0] = 0x015f; a[5] = a[0];




No boundscheck:

Arrays in C

17


0x000x040x080x0C0x100x140x180x1C0x200x24

0000015F

0000015F

a[0]a[1]

a[5]

…

a[0] = 0x015f; a[5] = a[0];




a[6] = 0xBAD; a[-1] = 0xBAD;

No boundscheck:

Arrays in C

17


0x000x040x080x0C0x100x140x180x1C0x200x24

0000015F

0000015F

a[0]a[1]

a[5]

…

a[0] = 0x015f; a[5] = a[0];




a[6] = 0xBAD; a[-1] = 0xBAD;

No boundscheck:

00000BAD

Arrays in C

17


0x000x040x080x0C0x100x140x180x1C0x200x24

0000015F

0000015F

a[0]a[1]

a[5]

…

a[0] = 0x015f; a[5] = a[0];




a[6] = 0xBAD; a[-1] = 0xBAD;

No boundscheck:

00000BAD

00000BAD

Arrays in C

18


0x000x040x080x0C0x100x140x180x1C0x200x24

0000015F

0000015F

a[0]a[1]

a[5]

…

a[0] = 0x015f; a[5] = a[0];




a[6] = 0xBAD; a[-1] = 0xBAD;

No boundscheck:

00000BAD

00000BADPointers:

Arrays in C

18


0x000x040x080x0C0x100x140x180x1C0x200x24

0000015F

0000015F

a[0]a[1]

a[5]

…

a[0] = 0x015f; a[5] = a[0];




a[6] = 0xBAD; a[-1] = 0xBAD;

No boundscheck:

00000BAD

00000BADPointers: int* p; p = a; p = &a[0];

Arrays in C

18


0x000x040x080x0C0x100x140x180x1C0x200x24

0000015F

0000015F

a[0]a[1]

a[5]

…

a[0] = 0x015f; a[5] = a[0];




a[6] = 0xBAD; a[-1] = 0xBAD;

No boundscheck:

00000BAD


equivalent {

Arrays in C

18


0x000x040x080x0C0x100x140x180x1C0x200x24

0000015F

0000015F

a[0]a[1]

a[5]

…

a[0] = 0x015f; a[5] = a[0];




a[6] = 0xBAD; a[-1] = 0xBAD;

No boundscheck:

00000BAD


equivalent {

00000004 p

Arrays in C

19


0x000x040x080x0C0x100x140x180x1C0x200x24

0000015F

0000015F

a[0]a[1]

a[5]

…

a[0] = 0x015f; a[5] = a[0];




a[6] = 0xBAD; a[-1] = 0xBAD;

No boundscheck:

00000BAD

00000BAD

00000004 p

Pointers:

equivalent {int* p; p = a; p = &a[0]; *p = 0xA;

Arrays in C

20


0x000x040x080x0C0x100x140x180x1C0x200x24

0000000A

0000015F

a[0]a[1]

a[5]

…

a[0] = 0x015f; a[5] = a[0];




a[6] = 0xBAD; a[-1] = 0xBAD;

No boundscheck:

00000BAD

00000BAD

00000004 p

Pointers:


Arrays in C

21


0x000x040x080x0C0x100x140x180x1C0x200x24

0000000A

0000015F

a[0]a[1]

a[5]

…

a[0] = 0x015f; a[5] = a[0];




a[6] = 0xBAD; a[-1] = 0xBAD;

No boundscheck:

00000BAD

00000BAD

00000004 p

Pointers:


0000000B

p[1] = 0xB;

array indexing = address arithmetic Both are scaled by the size of the type.

Arrays in C

22


0x000x040x080x0C0x100x140x180x1C0x200x24

0000000A

0000015F

a[0]a[1]

a[5]

…

a[0] = 0x015f; a[5] = a[0];




a[6] = 0xBAD; a[-1] = 0xBAD;

No boundscheck:

00000BAD

00000BAD

00000004 p

Pointers:


0000000B

p[1] = 0xB;


Arrays in C

23


0x000x040x080x0C0x100x140x180x1C0x200x24

0000000A

0000015F

a[0]a[1]

a[5]

…

a[0] = 0x015f; a[5] = a[0];




a[6] = 0xBAD; a[-1] = 0xBAD;

No boundscheck:

00000BAD

00000BAD

00000004 p

Pointers:


0000000B

p[1] = 0xB; *(p + 1) = 0xB;

equivalent {


Arrays in C

24


0x000x040x080x0C0x100x140x180x1C0x200x24

0000000A

0000015F

a[0]a[1]

a[5]

…

a[0] = 0x015f; a[5] = a[0];




a[6] = 0xBAD; a[-1] = 0xBAD;

No boundscheck:

00000BAD

00000BADPointers:


0000000B

equivalent {p[1] = 0xB; *(p + 1) = 0xB; p = p + 2; p00000004 p


Arrays in C

25


0x000x040x080x0C0x100x140x180x1C0x200x24

0000000A

0000015F

a[0]a[1]

a[5]

…

a[0] = 0x015f; a[5] = a[0];




a[6] = 0xBAD; a[-1] = 0xBAD;

No boundscheck:

00000BAD

00000BADPointers:


0000000B

equivalent {p[1] = 0xB; *(p + 1) = 0xB; p = p + 2; p0000000C


Arrays in C

26


0x000x040x080x0C0x100x140x180x1C0x200x24

0000000A

0000015F

a[0]a[1]

a[5]

…

a[0] = 0x015f; a[5] = a[0];




a[6] = 0xBAD; a[-1] = 0xBAD;

No boundscheck:

00000BAD

00000BAD

p

Pointers:


0000000B

equivalent {p[1] = 0xB; *(p + 1) = 0xB; p = p + 2; 0000000C

*p = a[1] + 1;


Arrays in C

27


0x000x040x080x0C0x100x140x180x1C0x200x24

0000000A

0000015F

a[0]a[1]

a[5]

…

a[0] = 0x015f; a[5] = a[0];




a[6] = 0xBAD; a[-1] = 0xBAD;

No boundscheck:

00000BAD

00000BAD

p

Pointers:


0000000B

equivalent {p[1] = 0xB; *(p + 1) = 0xB; p = p + 2; 0000000C

*p = a[1] + 1;

0000000C

• Brief review of topics from last lecture• Arrays and address arithmetic• Strings as arrays • Boolean algebra and bitwise manipulations

Today

28

• A C-style string is represented by an array of bytes (char).— Elements are one-byte ASCII codes for each character. — ASCII = American Standard Code for Information Interchange

Representing strings

29

• A C-style string is represented by an array of bytes (char).— Elements are one-byte ASCII codes for each character. — ASCII = American Standard Code for Information Interchange

32 space 48 0 64 @ 80 P 96 ` 112 p33 ! 49 1 65 A 81 Q 97 a 113 q34 ” 50 2 66 B 82 R 98 b 114 r35 # 51 3 67 C 83 S 99 c 115 s36 $ 52 4 68 D 84 T 100 d 116 t37 % 53 5 69 E 85 U 101 e 117 u38 & 54 6 70 F 86 V 102 f 118 v39 ’ 55 7 71 G 87 W 103 g 119 w40 ( 56 8 72 H 88 X 104 h 120 x41 ) 57 9 73 I 89 Y 105 I 121 y42 * 58 : 74 J 90 Z 106 j 122 z43 + 59 ; 75 K 91 [ 107 k 123 {44 , 60 < 76 L 92 \ 108 l 124 |45 - 61 = 77 M 93 ] 109 m 125 }46 . 62 > 78 N 94 ^ 110 n 126 ~47 / 63 ? 79 O 95 _ 111 o 127 del

Representing strings

29

Null-terminated Strings

30

• For example, “Harry Potter” can be stored as a 13-byte array.


30



72 97 114 114 121 32 80 111 116 116 101 114 0

H a r r y P o t t e r \0

30


• Why do we put a 0, or null zero, at the end of the string?• Note the special symbol: string[12] = '\0';


72 97 114 114 121 32 80 111 116 116 101 114 0


30


• Why do we put a 0, or null zero, at the end of the string?• Note the special symbol: string[12] = '\0';

• How do we compute the string length?


72 97 114 114 121 32 80 111 116 116 101 114 0


30

Endianness and Strings

31

• Byte ordering (endianness) is not an issue for 1-byte values.• Arrays are not values; elements are values; chars are single bytes.


31


• Unicode characters – up to 4 bytes/character• ASCII codes still work (just add leading zeros).

Unicode can support the many characters in all languages in the world.• Java and C have libraries for Unicode (Java commonly uses 2 bytes/char)


31





31

char s[6] = "12345";

IA32, x86-64 SPARC

3334

3132

3500

3334

3132

3500

C (char = 1 byte)





31

char s[6] = "12345";

IA32, x86-64 SPARC

3334

3132

3500

3334

3132

3500

C (char = 1 byte)String s = "123";

IA32, x86-64 SPARC

0032

0031

0033

3200

3100

3300

Java (char = 2 bytes)

(not all of the String representation is shown)

?

• Brief review of topics from last lecture• Arrays and address arithmetic• Strings as arrays• Boolean algebra and bitwise manipulations

Today

32

• Code to print byte representation of data• Any data type can be treated as a byte array by casting it to char.

• C has unchecked casts. << DANGER >>

Examining Data Representations

printf directives:%p Print pointer \t Tab

%x Print value as hex \n New line

33




typedef char byte; // size of char == 1 byte

void show_bytes(byte* start, int len) { int i; for (i = 0; i < len; i++) printf("%p\t0x%.2x\n", start+i, *(start+i)); printf("\n"); }



33




typedef char byte; // size of char == 1 byte

void show_bytes(byte* start, int len) { int i; for (i = 0; i < len; i++) printf("%p\t0x%.2x\n", start+i, *(start+i)); printf("\n"); }



33

void show_int (int x) { show_bytes( (byte *) &x, sizeof(int)); }

show_bytes Execution Example

34


int a = 12345; // represented as 0x00003039 printf("int a = 12345;\n"); show_int(a); // show_bytes((pointer) &a, sizeof(int));

34


int a = 12345; // represented as 0x00003039 printf("int a = 12345;\n"); show_int(a); // show_bytes((pointer) &a, sizeof(int));

Result (Linux):int a = 12345; 0x11ffffcb8 0x39 0x11ffffcb9 0x30 0x11ffffcba 0x00 0x11ffffcbb 0x00

34

Boolean Algebra

35

• Developed by George Boole in 19th Century

Boolean Algebra

35


• Algebraic representation of logic

Boolean Algebra

35


• Algebraic representation of logic• Encode “True” as 1 and “False” as 0

Boolean Algebra

35



• AND: A&B = 1 when both A is 1 and B is 1

Boolean Algebra

35



• AND: A&B = 1 when both A is 1 and B is 1• OR: A|B = 1 when either A is 1 or B is 1

Boolean Algebra

35



• AND: A&B = 1 when both A is 1 and B is 1• OR: A|B = 1 when either A is 1 or B is 1• XOR: A^B = 1 when either A is 1 or B is 1, but not both

Boolean Algebra

35



• AND: A&B = 1 when both A is 1 and B is 1• OR: A|B = 1 when either A is 1 or B is 1• XOR: A^B = 1 when either A is 1 or B is 1, but not both• NOT: ~A = 1 when A is 0 and vice-versa

Boolean Algebra

35



• AND: A&B = 1 when both A is 1 and B is 1• OR: A|B = 1 when either A is 1 or B is 1• XOR: A^B = 1 when either A is 1 or B is 1, but not both• NOT: ~A = 1 when A is 0 and vice-versa• DeMorgan’s Law: ~(A | B) = ~A & ~B

Boolean Algebra

35




& 0 10 0 01 0 1

Boolean Algebra

35




& 0 10 0 01 0 1

| 0 10 0 11 1 1

Boolean Algebra

35




& 0 10 0 01 0 1

| 0 10 0 11 1 1

^ 0 10 0 11 1 0

Boolean Algebra

35




& 0 10 0 01 0 1

~0 11 0

| 0 10 0 11 1 1

^ 0 10 0 11 1 0

Boolean Algebra

35

General Boolean Algebras

36

• Operate on bit vectors• Operations applied bitwise


36


01101001 & 01010101 01000001


36


01101001 & 01010101 01000001

01101001 | 01010101 01111101


36


01101001 & 01010101 01000001

01101001 | 01010101 01111101

01101001 ^ 01010101 00111100


36


01101001 & 01010101 01000001

01101001 | 01010101 01111101

01101001 ^ 01010101 00111100

~ 01010101 10101010


36


• All of the properties of Boolean algebra apply

01101001 & 01010101 01000001

01101001 | 01010101 01111101

01101001 ^ 01010101 00111100

~ 01010101 10101010


36



01101001 & 01010101 01000001

01101001 | 01010101 01111101

01101001 ^ 01010101 00111100

~ 01010101 10101010

01010101 ^ 01010101 00000000


36



• How does this relate to set operations?

01101001 & 01010101 01000001

01101001 | 01010101 01111101

01101001 ^ 01010101 00111100

~ 01010101 10101010

01010101 ^ 01010101 00000000


36

Representing & Manipulating Sets

37

• Representation


37

• Representation• A w-bit vector represents subsets of {0, …, w–1}


37

• Representation• A w-bit vector represents subsets of {0, …, w–1}• aj = 1 iff j ∈ A


37


01101001 { 0, 3, 5, 6 }


37


01101001 { 0, 3, 5, 6 } 76543210


37


01101001 { 0, 3, 5, 6 } 76543210

01010101 { 0, 2, 4, 6 }


37


01101001 { 0, 3, 5, 6 } 76543210

01010101 { 0, 2, 4, 6 } 76543210


37


01101001 { 0, 3, 5, 6 } 76543210

01010101 { 0, 2, 4, 6 } 76543210

• Operations


37


01101001 { 0, 3, 5, 6 } 76543210

01010101 { 0, 2, 4, 6 } 76543210

• Operations• & Intersection 01000001 { 0, 6 }


37


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 }


37


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 }


37


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 }


37

Bit-Level Operations in C

38

• & | ^ ~


38

• & | ^ ~• Apply to any “integral” data type


38

• & | ^ ~• Apply to any “integral” data type• long, int, short, char, unsigned


38


• View arguments as bit vectors


38


• View arguments as bit vectors• Examples (char data type)


38


• View arguments as bit vectors• Examples (char data type)• ~0x41 --> 0xBE


38



~010000012 --> 101111102


38



~010000012 --> 101111102

• ~0x00 --> 0xFF


38



~010000012 --> 101111102

• ~0x00 --> 0xFF~000000002 --> 111111112


38



~010000012 --> 101111102

• ~0x00 --> 0xFF~000000002 --> 111111112

• 0x69 & 0x55 --> 0x41


38



~010000012 --> 101111102

• ~0x00 --> 0xFF~000000002 --> 111111112

• 0x69 & 0x55 --> 0x41011010012 & 010101012 --> 010000012


38



~010000012 --> 101111102

• ~0x00 --> 0xFF~000000002 --> 111111112

• 0x69 & 0x55 --> 0x41011010012 & 010101012 --> 010000012

• 0x69 | 0x55 --> 0x7D


38



~010000012 --> 101111102

• ~0x00 --> 0xFF~000000002 --> 111111112

• 0x69 & 0x55 --> 0x41011010012 & 010101012 --> 010000012

• 0x69 | 0x55 --> 0x7D011010012 | 010101012 --> 011111012


38



~010000012 --> 101111102

• ~0x00 --> 0xFF~000000002 --> 111111112

• 0x69 & 0x55 --> 0x41011010012 & 010101012 --> 010000012

• 0x69 | 0x55 --> 0x7D011010012 | 010101012 --> 011111012

• Many bit-twiddling puzzles in Lab 1


38

Contrast: Logic Operations in C

39

• Contrast to logical operators


39

• Contrast to logical operators• && || !


39


• 0 is “False”


39



• Anything nonzero is “True”


39




• Always return 0 or 1


39





• Early termination a.k.a. short-circuit evaluation


39






• Examples (char data type)


39






• Examples (char data type)• !0x41 --> 0x00


39







• !0x00 --> 0x01


39







• !0x00 --> 0x01

• !!0x41 --> 0x01


39







• !0x00 --> 0x01

• !!0x41 --> 0x01

• 0x69 && 0x55 --> 0x01


39







• !0x00 --> 0x01

• !!0x41 --> 0x01

• 0x69 && 0x55 --> 0x01

• 0x69 || 0x55 --> 0x01


39







• !0x00 --> 0x01

• !!0x41 --> 0x01

• 0x69 && 0x55 --> 0x01

• 0x69 || 0x55 --> 0x01

• p && *p++ (avoids null pointer access, null pointer = x00000000 )


39





• Readings for each lecture are posted on the website• Slides for each lecture are posted ~1 day ahead of time

• A 1-page summary of concepts and definitions will go up after class Not everything you need to know but most of the important topics.

Announcements

40


the hardware/software interface › courses › cse351 › ... · the hardware/software interface...

Documents