Announcements* Hardware:*Logical*View* Hardware:*SemiVLogical*View* Hardware:*Physical*View*

Transcription

1 Announcements* Hardware:*Logical*View* On*the*website:*cs.uw.edu/351* Speedometer!** Anonymous*feedback*form* Make*sure*you*are*subscribed*to*the*mailing*list* Lecture*slides*on*the*web*schedule*(these*will*be*linked*1>2*days*prior)* Lab*0,*having*fun?**Make*sure*to*start*earl Discussion*boards* Videos*for*opGonal*reference* *not*exactlthe*same*slides*as*we ll*use* Tips*for*C,*debugging,*etc.* Lecture*content* Office*hours*posted:*if*thedon t*work*for*you,*let*us*know* Anyone*not*yet*enrolled?**If*not,*see*me*right*aCer*class* New*secEon*being*created*for*Th*11:30* *statuned* CPU* Memor Bus* Disks* Net* USB* Etc.* 1* 2* Hardware:*SemiVLogical*View* Hardware:*Physical*View* Graphics* CPU* Memor USB Network* USB I/O* (Bus)* Audio* Storage* I/O* controller* CPU* Memor Storage*connecEons* 3* 4*

2 Hardware:*351*View*(version*0)* Hardware:*351*View*(version*1)*?* instructions Memor ivcache* take*352 instructions this*week Memor CPU* data CPU* registers* data CPU*executes*instrucEons;*memorstores*data* To*execute*an*instrucEon,*the*CPU*must:* fetch*an*instrucgon;* fetch*the*data*used*bthe*instrucgon;*and,*finally,* execute*the*instrucgon*on*the*data which*maresult*in*wrigng*data*back*to*memory.* 5* The*CPU*holds*instrucEons*temporarilin*the*instrucEon*cache* The*CPU*holds*data*temporarilin*a*fixed*number*of*registers* InstrucEon*and*operand*fetching*is*HWVcontrolled* Data*movement*is*programmerVcontrolled* We ll*learn*about*the*instrucgons*the*cpu*executes* * take*352*to*find*out*how*it*executes*them* 6* Hardware:*351*View*(version*1)* How*are*data* CPU* and*instruceons* represented?* ivcache* take*352 registers* instructions data The*CPU*holds*instrucEons*temporarilin*the*instrucEon*cache.* How*does*a* The*CPU*holds*data*temporarilin*a*fixed*number*of*registers.* InstrucEon*fetching*is*HWVcontrolled.* program*find*its* Data*movement*is*programmerVcontrolled.* this*week Memor data*in*memory?* Roadmap* C:* car *c = malloc(sizeof(car)); c->miles = 100; c->gals = 17; float mpg = get_mpg(c); free(c); Assembl language:* Machine* code:* Computer* system:* get_mpg: pushq movq... popq ret %rbp %rsp, %rbp %rbp Java:* Car c = new Car(); c.setmiles(100); c.setgals(17); float mpg = c.getmpg(); OS:* Integers*&*floats* Machine*code*&*C* x86*assembl Procedures*&*stacks* Arrays*&*structs* Memor&*caches* Processes* Virtual*memor MemorallocaEon* Java*vs.*C* 7* 8*

3 Memory,*Data,*and*Addressing* RepresenEng*informaEon*as*bits*and*bytes* Organizing*and*addressing*data*in*memor ManipulaEng*data*in*memorusing*C* Boolean*algebra*and*bitVlevel*manipulaEons* ivcache* take*352 instructions this*week Memor How*are*data* CPU* and*instruceons* represented?* registers* data 9* 10* BinarRepresentaEons* Describing*Byte*Values* Base*2*number*representaEon* A*base*2*digit*(0*o*1)*is*called*a*bit.* Represent* *as* * *or** * Binar * *VV** * Byte*8*bits*(binardigits)* Decimal ***************0 10 *VV**255 10* Electronic*implementaEon* Easto*store*with*bi>stable*elements* Reliabltransmi[ed*on*noisand*inaccurate*wires** 3.3V* 2.8V* 0.5V* 0.0V* 0* 1* 0 Hexadecimal****************00 16 *VV**FF 16* Byte*2*hexadecimal*(or* hex *or*base*16)*digits* Base*16*number*representaGon* Use*characters* 0 *to* 9 *and* A *to* F * Write*FA1D37B 16 *in*c** as***0xfa1d37b or***0xfa1d37b More*on*specific*data*types*later 0* 0* 00 1* 1* 00 2* 2* 0010* 3* 3* 0011* 4* 4* 01 5* 5* 01 6* 6* 0110* 7* 7* 0111* 8* 8* 10 9* 9* 10 A* 10* 1010* B* 11* 1011* C* 12* 11 D* 13* 11 E* 14* 1110* F* 15* 1111* 11* 12*

4 ByteVOriented*MemorOrganizaEon* ivcache* take*352 CPU* registers* instructions data this*week Memor How*does*a* program*find*its* data*in*memory?*! Conceptually,*memoris*a*single,*large*arraof*bytes,* each*with*an*unique*address*(index).* The*value*of*each*byte*in*memorcan*be*read*and*wrijen.* Programs*refer*to*bytes*in*memorbtheir*addresses.* Domain*of*possible*addresses*address)space) But*not*all*values*(e.g.,)351)*fit*in*a*single*byte Store*addresses*to* remember *where*other*data*is*in*memory.* How*much*memorcan*we*address*with*1>byte*(8>bit)*addresses?* ManoperaEons*actualluse*mulEVbyte*values.* 13* 14* Machine*Words* WordVOriented*MemorOrganizaEon* fixed*number*of*coneguous*bytes*in*memory,*chosen*bhw* the*largest*unit*of*data*a*machine*instruceon*can*use) word*size*address*size*register*size* Word*size*bounds*the*size*of*the*address)space)and*memory.* word*size*w*bits**=>**2 w *addresses* UnGl*recently,*most*machines*used*32Vbit*(4Vbyte)*words.* PotenGal*address*space:*2 32 *addresses* 2 32 *bytes* 4*10 9 *bytes*4*billion*bytes*4gb* (living*humans*/*addressable*bytes* *1.8)* Became*too*small*for*memory>intensive*applicaGons* Current*x86*systems*use*64Vbit*(8Vbyte)*words.* PotenGal*address*space:*2 64 *addresses* 2 64 *bytes* *1.8*10 19 *bytes*18*billion*billion*bytes*18*eb*(exabytes)* (possible*living*acquaintances*/*addressable*bytes* 2.8)* 15* Addresses*specif* locaeons*of*bytes*in*memor Address*of*word* *address*of*first*byte*in*word* Addresses*of*successive*words** differ*bword*size*(in*bytes):* e.g.,*4*(32>bit)*or*8*(64>bit)* Address*of*word*0,*1,*..*10?* 64>bit* Words*??*??* 32>bit* Words*??*??*??*??* Bytes* Addr.* * 0003* * 0006* 0007* 0008* 0009* 0010* 0011* 0012* 0013* 0014* 0015* 16*

5 WordVOriented*MemorOrganizaEon* MemorAlignment* Addresses*sEll*specif* locaeons*of*bytes*in*memor Address*of*word* *address*of*first*byte*in*word* Addresses*of*successive*words** differ*bword*size*(in*bytes):* e.g.,*4*(32>bit)*or*8*(64>bit)* Address*of*word*0,*1,*..*10? * Alignment* 64>bit* Words* 00??* 0008*??* 32>bit* Words* 00??* 00??* 0008*??* 0012*??* Bytes* Addr.* * 0003* * 0006* 0007* 0008* 0009* 0010* 0011* 0012* 0013* 0014* 0015* 17* Data*of*size*n)onlstored*at*addresses*a*where*a*mod*n*0* ConvenGon*or*rule,*depending*on*plamorm.* n*is*usualla*power*of*2.* A*32Vbit*(4Vbyte)*wordValigned* view*of*memory:* Each*row*is*a*word*composed*of*4*bytes.* Cells*in*a*row*are*the*word s*bytes.* 0x05* 0x06* 0x07* 0x 0x 0x02* 0x03* More*about*alignment*later*in*the*course.* (note*he addresses)* 0x 18* Addresses*and*Pointers* Addresses*and*Pointers* An*address*is*a*locaEon*in*memor A*pointer*is*a*data*object*that*holds*an*address.* The*value*351*is*stored*at*address*0x04.* *15F 16 *0x 0x An*address*is*a*locaEon*in*memor A*pointer*is*a*data*object*that*holds*an*address.* The*value*351*is*stored*at*address*0x04.* *15F 16 *0x A*pointer*stored*at*address* points*to*address*0x04.* 0x 19* 20*

6 Addresses*and*Pointers* Addresses*and*Pointers* An*address*is*a*locaEon*in*memor An*address*is*a*locaEon*in*memor A*pointer*is*a*data*object*that*holds*an*address.* A*pointer*is*a*data*object*that*holds*an*address.* The*value*351*is*stored*at*address*0x04.* *15F 16 *0x A*pointer*stored*at*address* points*to*address*0x04.* A*pointer*to*a*pointer** is*stored*at*address*0x24.* 1C* 0x The*value*351*is*stored*at*address*0x04.* *15F 16 *0x A*pointer*stored*at*address* 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?* 0C* 1C* 0x 21* 22* Data*RepresentaEons* Byte*Ordering* Sizes*of*data*types*(in*bytes)* Java*Data*Type *C*Data*Type *Typical*32>bit *x86>64* boolean *bool *1 *1* byte *char *1 *1* char * *2 *2* short *short*int *2 *2* int *int *4 *4* float *float *4 *4* *long*int *4 *8* double *double *8 *8* long *long*long *8 *8* * *long*double *8 *16* (reference) *pointer** *4 *8* How*should*bytes*within*a*word*be*ordered*in*memory?* Example:*Store*the*4Vbyte*word*0xa1*b2*c3*d4.* In*what*order*will*the*bytes*be*stored?* ConvenEons!* Big>endian,*Li[le>endian* Based*on*Gulliver s)travels:*tribes*cut*eggs*on*different*sides*(big,*li[le)* 23* 24*

7 Byte*Ordering* Byte*Ordering*Example* BigVEndian*(PowerPC,*SPARC,*The*Internet)* Least*significant*byte*has*highest*address* LijleVEndian*(x86)* Least*significant*byte*has*lowest*address* Example* Variable*has*4>byte*representaGon*0xa1b2c3d4* Address*of*variable*is*0x1 Big*Endian* Lijle*Endian* 0x1 0x1 0x102* 0x103* a1* b2* 23* 45* c3* d4* 67* 0x1 0x1 0x102* 0x103* d4* 67* 45* c3* b2* 23* a1* higher*addresses* lower*addresses* int x = 12345; // long int = word long int y = 12345; IA32,*x86V64* 39* 30* SPARC* 30* 39* IA32* 39* 30* Decimal:! 12345! Binary: Hex: x86v64* 39* 30* 32Vbit* SPARC* 30* 39* 64Vbit* SPARC* 30* 39* 25* 26* Reading*ByteVReversed*LisEngs* Disassembl Take*binarmachine*code*and*generate*an*assemblcode*version.* Does*the*reverse*of*the*assembler.* Example*instrucEon*in*memor* add*value*0x12ab*to*register* ebx *(a)special)loca7on)in)cpu s)memory)) Address!Instruction Code!Assembly Rendition! : 81 c3 ab add $0x12ab,%ebx Reading*ByteVReversed*LisEngs* Disassembl Take*binarmachine*code*and*generate*an*assemblcode*version.* Does*the*reverse*of*the*assembler.* Example*instrucEon*in*memor* add*value*0x12ab*to*register* ebx *(a)special)loca7on)in)cpu s)memory)) Address!Instruction Code!Assembly Rendition! : 81 c3 ab add $0x12ab,%ebx Deciphering*numbers* Value:* Pad*to*32*bits:* Split*into*bytes:* Reverse*(lijleVendian):* *0x12ab* *0x000012ab* *12*ab* *ab*12* 28*

8 Addresses*and*Pointers*in*C* int* ptr;! int x = 5;! int y = 2;! ptr = &x;! Dereference)ptr. ) y = 1 + *ptr;! Declares*a*variable,*ptr,*that*is*a* pointer*to*(i.e.,*holds*the*address*of)* an*int*in*memory.* Declares*two*variables,*and*y,*that*hold*ints,* and*sets*them*to*5*and*2,*respecgvely.* Sets*ptr*to*the*address*of*x.* Now,* ptr)points)to)x. ) What*is****(&y)***?* Sets*to*1*plus*the*value*at*the*address*held*bptr.*** Because*ptr*points*to*x,*this*is*to*y=1+x;! 29* A*variable*is*represented*ba*memorlocaEon.* IniEally,*it*mahold*anvalue.* //*is*at*locagon*0x04,*is*at*0x18.* A7* 32* 29* F3* EE* EE* EE* EE* FA* CE* CA* FE* 26* 10* FF* F4* 96* 42* 17* 34* 0x 30* A*variable*is*represented*ba*memorlocaEon.* IniEally,*it*mahold*anvalue.* //*is*at*locagon*0x04,*is*at*0x18.* 29* F3* 0x LeCVhandVside*rightVhandVside;* LHS*must*evaluate*to*a*memorloca7on.* RHS*must*evaluate*to*a*value.*(could*be*an*address!)* Store*RHS*value*at*LHS*locaGon.* 0;* 0x 31* 32*

9 LeCVhandVside*rightVhandVside;* LHS*must*evaluate*to*a*memorloca7on.* RHS*must*evaluate*to*a*value.*(could*be*an*address!)* Store*RHS*value*at*LHS*locaGon.* 0;* 0x3CD02700;* 33* lijle*endian!* 0x LeCVhandVside*rightVhandVside;* LHS*must*evaluate*to*a*memorloca7on.* RHS*must*evaluate*to*a*value.*(could*be*an*address!)* Store*RHS*value*at*LHS*locaGon.* 0;* 0x3CD02700;* +*3;* //*Get*value*at*y,*add*3,*put*it*in*x.* 34* 03* 0x LeCVhandVside*rightVhandVside;* LHS*must*evaluate*to*a*memorloca7on.* RHS*must*evaluate*to*a*value.*(could*be*an*address!)* Store*RHS*value*at*LHS*locaGon.* 0;* 0x3CD02700;* +*3;** //*Get*value*at*y,*add*3,*put*it*in*x.* int**z* 35* 03* 0x z* LeCVhandVside*rightVhandVside;* LHS*must*evaluate*to*a*memorloca7on.* RHS*must*evaluate*to*a*value.*(could*be*an*address!)* Store*RHS*value*at*LHS*locaGon.* 0;* 0x3CD02700;* +*3;** //*Get*value*at*y,*add*3,*put*it*in*x.* int**z*&+*3;* //*Get*address*of*y,*add*???,*put*it*in*z.* 36* 03* 0x z*

10 LeCVhandVside*rightVhandVside;* LHS*must*evaluate*to*a*memorloca7on.* RHS*must*evaluate*to*a*value.*(could*be*an*address!)* Store*RHS*value*at*LHS*locaGon.* 0;* 0x3CD02700;* +*3;* //*Get*value*at*y,*add*3,*put*it*in*x.* int**z*&+*3;* //*Get*address*of*y,*add*12,*put*it*in*z.* 37* 03* 0x z* 24* Pointer*arithmeGc*is*scaled*bsize*of*target*type.) Pointer*arithmeEc* can*be*dangerous.) LeCVhandVside*rightVhandVside;* LHS*must*evaluate*to*a*memorloca7on.* RHS*must*evaluate*to*a*value.*(could*be*an*address!)* Store*RHS*value*at*LHS*locaGon.* 0;* 0x3CD02700;* +*3;** //*Get*value*at*y,*add*3,*put*it*in*x.* int**z*&+*3;* //*Get*address*of*y,*add*12,*put*it*in*z.* *z*y;* //*What*does*this*do?* 38* 03* 0x z* 24* LeCVhandVside*rightVhandVside;* LHS*must*evaluate*to*a*memorloca7on.* RHS*must*evaluate*to*a*value.*(could*be*an*address!)* Store*RHS*value*at*LHS*locaGon.* 0;* 0x3CD02700;* +*3;*** //*Get*value*at*y,*add*3,*put*it*in*x.* int**z*&+*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.* 39* 03* 0x z* 24* The*target*of*a*pointer*is* also*a*memorlocagon.) 40* 0x element*type* name* number*of* elements*

11 41* 0x a[0]* a[1]* a[5]* a[0]*0x015f;* a[5]*a[0];* 42* 0x a[0]* a[1]* a[5]* a[0]*0x015f;* a[5]*a[0];* a[6]*0xbad;* a[v1]*0xbad;* check:* 43* 0x p* a[0]* a[1]* a[5]* a[0]*0x015f;* a[5]*a[0];* Pointers:* {* a[6]*0xbad;* a[v1]*0xbad;* check:* int**p;* p*a;* p*&a[0];* 44* 0x p* a[0]* a[1]* a[5]* a[0]*0x015f;* a[5]*a[0];* Pointers:* {* a[6]*0xbad;* a[v1]*0xbad;* check:* int**p;* p*a;* p*&a[0];* *p*0xa;*

12 45* 0A* 0x p* a[0]* a[1]* a[5]* a[0]*0x015f;* a[5]*a[0];* Pointers:* {* a[6]*0xbad;* a[v1]*0xbad;* check:* int**p;* p*a;* p*&a[0];* *p*0xa;* 46* 0A* 0x p* a[0]* a[1]* a[5]* a[0]*0x015f;* a[5]*a[0];* Pointers:* {* a[6]*0xbad;* a[v1]*0xbad;* check:* int**p;* p*a;* p*&a[0];* *p*0xa;* p[1]*0xb;* array)indexing)=)address)arithme8c) Both*are*scaled*bthe*size*of*the*type.* 47* 0A* 0x p* a[0]* a[1]* a[5]* a[0]*0x015f;* a[5]*a[0];* Pointers:* {* a[6]*0xbad;* a[v1]*0xbad;* check:* int**p;* p*a;* p*&a[0];* *p*0xa;* p[1]*0xb;* array)indexing)=)address)arithme8c) Both*are*scaled*bthe*size*of*the*type.* 48* 0A* 0x p* a[0]* a[1]* a[5]* a[0]*0x015f;* a[5]*a[0];* Pointers:* {* a[6]*0xbad;* a[v1]*0xbad;* check:* int**p;* p*a;* p*&a[0];* *p*0xa;* {* p[1]*0xb;* *(p*+*1)*0xb;*

13 a[0]*0x015f;* a[5]*a[0];* a[6]*0xbad;* check:* a[v1]*0xbad;* Pointers:* int**p;* p*a;* {* p*&a[0];* *p*0xa;* p[1]*0xb;* {**(p*+*1)*0xb;* p*p*+*2;* array)indexing)=)address)arithme8c) Both*are*scaled*bthe*size*of*the*type.* 0x 0A* a[0]* a[1]* a[5]* p* a[0]*0x015f;* a[5]*a[0];* a[6]*0xbad;* check:* a[v1]*0xbad;* Pointers:* int**p;* p*a;* {* p*&a[0];* *p*0xa;* p[1]*0xb;* {**(p*+*1)*0xb;* p*p*+*2;* array)indexing)=)address)arithme8c) Both*are*scaled*bthe*size*of*the*type.* 0x 0A* a[0]* a[1]* a[5]* 0C* p* 49* 50* a[0]*0x015f;* a[5]*a[0];* a[6]*0xbad;* check:* a[v1]*0xbad;* Pointers:* int**p;* p*a;* {* p*&a[0];* *p*0xa;* p[1]*0xb;* {**(p*+*1)*0xb;* p*p*+*2;* array)indexing)=)address)arithme8c) Both*are*scaled*bthe*size*of*the*type.* *p*a[1]*+*1;* 0x 0A* a[0]* a[1]* 0C* a[5]* 0C* p* 51* RepresenEng*strings* A*CVstyle*string*is*represented*ban*arraof*bytes*(char).* Elements*are*one>byte*ASCII*codes*for*each*character.* ASCII*American*Standard*Code*for*InformaGon*Interchange* 32 space P 96 ` 112 p 33! A 81 Q 97 a 113 q B 82 R 98 b 114 r 35 # C 83 S 99 c 115 s 36 $ D 84 T 100 d 116 t 37 % E 85 U 101 e 117 u 38 & F 86 V 102 f 118 v G 87 W 103 g 119 w 40 ( H 88 X 104 h 120 x 41 ) I 89 Y 105 I 121 y 42 * 58 : 74 J 90 Z 106 j 122 z ; 75 K 91 [ 107 k 123 { 44, 60 < 76 L 92 \ 108 l = 77 M 93 ] 109 m 125 } > 78 N 94 ^ 110 n 126 ~ 47 / 63? 79 O 95 _ 111 o 127 del 52*

14 NullVterminated*Strings* H a r r y P o t t e r \0 For*example,* HarrPojer *can*be*stored*as*a*13vbyte*array.* Whdo*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?* Endianness*and*Strings* C*(char*1*byte)* Java*(char*2*bytes)* char s[6] = "12345"; String?* s = "123"; (not*all*of*the*string*representagon*is*shown)* IA32,*x86V64* SPARC* IA32,*x86V64* SPARC* 31* 31* 31* 32* 32* 31* 33* 33* 32* 34* 34* 32* 35* 35* 33* 33* Byte*ordering*(endianness)*is*not*an*issue*for*1Vbyte*values.* Arrays*are*not*values;*elements*are*values;*chars*are*single*bytes.* Unicode*characters* *up*to*4*bytes/character* ASCII*codes*sGll*work*(just*add*leading*zeros).* Unicode*can*support*the*mancharacters*in*all*languages*in*the*world.* Java*and*C*have*libraries*for*Unicode*(Java*commonluses*2*bytes/char)* 53* 54* Examining*Data*RepresentaEons* show_bytes*execueon*example* Code*to*print*byte*representaEon*of*data* Andata*type*can*be*treated*as*a*byte)arrabcasEng*it*to*char C*has*unchecked*casts.**<<*DANGER*>>* 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"); } void show_int (int x) { show_bytes( (byte *) &x, sizeof(int)); } prindireceves:* *%p *Print*pointer* *\t *Tab* *%x *Print*value*as*he *\n *New*line* 55* int a = 12345; // represented as 0x 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 56*

15 Boolean*Algebra* General*Boolean*Algebras* Developed*bGeorge*Boole*in*19th*Centur Algebraic*representaGon*of*logic* Encode* True *as*1*and* False *as*0* 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* Operate*on*bit*vectors* OperaGons*applied*bitwise* **** &* ** *** * ** *** ^* ** All*of*the*properEes*of*Boolean*algebra*appl *** ^* ** ~* ** * How*does*this*relate*to*set*operaEons?* 57* 58* RepresenEng*&*ManipulaEng*Sets* BitVLevel*OperaEons*in*C* RepresentaEon* A*w>bit*vector*represents*subsets*of*{0,*,*w 1}* a j *1*iff*j** *A) {*0,*3,*5,*6*}* {*0,*2,*4,*6*}* OperaEons* &* *IntersecGon * {*0,*6*}* ** *Union * {*0,*2,*3,*4,*5,*6*}* ^ *Symmetric*difference * {*2,*3,*4,*5*}* ~ *Complement * {*1,*3,*5,*7*}* &*** ***^***~* Applto*an integral *data*type* long,**int,**short,**char, unsigned View*arguments*as*bit*vectors* Examples*(char*data*type)* ~0x41 --> 0xBE ~ > ~0x00 --> 0xFF ~ > x69 & 0x55 --> 0x & > x69 0x55 --> 0x7D > * Some*bitVtwiddling*puzzles*in*Lab*1* 59* 60*

16 Contrast:*Logic*OperaEons*in*C* Contrast*to*logical*operators* &&***** *****!* 0*is* False * Anything*nonzero*is* True * Always*return*0*or*1* EarlterminaGon****a.k.a.***short>circuit*evaluaGon* Examples*(char*data*type)*!0x41 --> 0x00!0x00 --> 0x01!!0x41 --> 0x01 0x69 && 0x55 --> 0x01 0x69 0x55 --> 0x01 p && *p++ (avoids*null*pointer*access,*null*pointer*0x000000)* 61*