Bits, Bytes, and Integers

1. Bits, Bytes, and Integers Spring, 2019 EuiseongSeo (euiseong@skku.edu) This Powerpoint slides are modified from its original version available at http://www.cs.cmu.edu/afs/cs/academic/class/15213-s09/www/lectures/ppt-sources/

2. Representing information as bits • Bit-level manipulations • Integers • Representation: unsigned and signed • Conversion, casting • Expanding, truncating • Addition, negation, multiplication, shifting • Summary Bits, Bytes, and Integers

3. 0 1 0 3.3V 2.8V 0.5V 0.0V Binary Representations

4. 14 15 13 10 12 11 D A B E 0100 1110 0000 1101 0001 1100 0010 C 1000 1011 1010 0101 0110 1001 0111 1111 0011 8 4 4 5 7 6 6 3 5 8 2 1 1 0 0 3 7 9 9 2 F • Byte = 8 bits • Binary 000000002 to 111111112 • Decimal: 010 to 25510 • Hexadecimal 0016 to FF16 • Base 16 number representation • Use characters ‘0’ to ‘9’ and ‘A’ to ‘F’ • Write FA1D37B16 in C as • 0xFA1D37B • 0xfa1d37b Decimal Binary Hex Encoding Byte Values

5. 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 • Where different program objects should be stored • All allocation within single virtual address space 00•••0 FF•••F • • • Byte-Oriented Memory Organization

6. 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 Machine Words

7. 0008 0012 0008 0004 0000 0000 32-bit Words 64-bit Words • Addresses specify byte locations • Address of first byte in word • Addresses of successive words differ by 4 (32-bit) or 8 (64-bit) Bytes Addr. 0000 Addr = ?? 0001 0002 Addr = ?? 0003 0004 Addr = ?? 0005 0006 0007 0008 Addr = ?? 0009 0010 Addr = ?? 0011 0012 Addr = ?? 0013 0014 0015 Word-Oriented Memory Organization

8. Computer and compiler support multiple data formats • Using different ways to encode data • Integers and floating point • Using different lengths Data Sizes

9. Data Representations

10. A multi-byte object is stored as a contiguous sequence of bytes • With a address of the object given by the smallest address of the bytes • How should bytes within a multi-byte word be ordered in memory? • Conventions • Big Endian: Sun, PPC Mac, Internet • Least significant byte has highest address • Little Endian: x86 • Least significant byte has lowest address Byte Ordering

11. 01 23 45 67 01 23 45 67 0x100 0x101 0x103 0x102 0x101 0x102 0x103 0x100 • 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 45 67 67 45 01 01 23 23 Byte Ordering Example Big Endian Little Endian

12. Disassembly • Text representation of binary machine code • Generated by program that reads the machine code • Example Fragment • Deciphering Numbers • Value: 0x12ab • Pad to 32 bits: 0x000012ab • Split into bytes: 00 00 12 ab • Reverse: ab 12 00 00 Reading Byte-Reversed Listings 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)

13. Code to print byte representation of data • Textbook Figure 2.4 at page 42 • Casting pointer to unsigned char * creates byte array Examining Data Representations typedef unsigned char *pointer; void show_bytes(pointer start, intlen){ inti; for (i = 0; i < len; i++) printf(”%p\t0x%.2x\n",start+i, start[i]); printf("\n"); }

14. show_bytes Execution Example int a = 15213; printf("int a = 15213;\n"); show_bytes((pointer) &a, sizeof(int)); Result (Linux): int a = 15213; 0x11ffffcb8 0x6d 0x11ffffcb9 0x3b 0x11ffffcba 0x00 0x11ffffcbb 0x00

15. 00 6D 3B 00 00 3B 6D 00 00 00 FF C4 00 6D 3B 93 FF 93 00 C4 00 3B FF 6D 00 00 FF 00 00 3B 6D 00 Sun IA32 Sun IA32, x86-64 IA32, x86-64 Sun Representing Integers Decimal: 15213 Binary: 0011 1011 0110 1101 Hex: 3 B 6 D int A = 15213; long int C = 15213; x86-64 int B = -15213; Two’s complement representation

16. Representing Pointers Sun IA32 x86-64 int B = -15213; int *P = &B; Different compilers & machines assign different locations to objects

17. Strings in C • 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 Representing Strings char S[6] = "18243"; Linux/Alpha Sun

18. Encode Program as Sequence of Instructions • Each simple operation • Arithmetic operation • Read or write memory • Conditional branch • Instructions encoded as bytes • Alpha’s, Sun’s, Mac’s use 4 byte instructions • Reduced Instruction Set Computer (RISC) • PC’s use variable length instructions • Complex Instruction Set Computer (CISC) • Different instruction types and encodings for different machines • Most code not binary compatible • Programs are Byte Sequences Too! Machine-Level Code Representation

19. 81 00 01 90 C3 02 00 80 E0 00 30 FA 08 09 42 6B Representing Instructions • For this example, Alpha & Sun use two 4-byte instructions • Use differing numbers of instructions in other cases • PC uses 7 instructions with lengths 1, 2, and 3 bytes • Same for NT and for Linux • NT / Linux not fully binary compatible Alpha sum Sun sum PC sum 55 89 E5 8B 45 0C 03 45 int sum(int x, int y) { return x+y; } 08 89 EC 5D C3 Different machines use totally different instructions and encodings

20. Representing information as bits • Bit-level manipulations • Integers • Representation: unsigned and signed • Conversion, casting • Expanding, truncating • Addition, negation, multiplication, shifting • Summary Bits, Bytes, and Integers

21. Developed by George Boole in 19th Century • Algebraic representation of logic • Encode “True” as 1 and “False” as 0 Boolean Algebra and A&B = 1 when both A=1 and B=1 or 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

22. Operate on Bit Vectors • Operations applied bitwise • All of the Properties of Boolean Algebra Apply General Boolean Algebras 01101001 & 01010101 01000001 01101001 | 01010101 01111101 01101001 ^ 01010101 00111100 ~ 01010101 10101010 01000001 01111101 00111100 10101010

23. Operations &, |, ~, ^available in C • Apply to any “integral” data type • long, int, short, char, unsigned • View arguments as bit vectors • Arguments applied bit-wise • Examples (char data type) • ~0x41 ➙ 0xBE • ~010000012 ➙ 101111102 • ~0x00 ➙ 0xFF • ~000000002 ➙ 111111112 • 0x69 & 0x55 ➙ 0x41 • 011010012 & 010101012 ➙ 010000012 • 0x69 | 0x55 ➙ 0x7D • 011010012 | 010101012 ➙ 011111012 Bit-Level Operations in C

24. Contrast to Logical Operators • &&, ||, ! • View 0 as “False” • Anything nonzero as “True” • Always return 0 or 1 • Early termination • Examples (char data type) • !0x41 ➙ 0x00 • !0x00 ➙ 0x01 • !!0x41 ➙ 0x01 • 0x69 && 0x55 ➙ 0x01 • 0x69 || 0x55 ➙ 0x01 • p && *p (avoids null pointer access) Logic Operations in C

25. Left Shift: x << y • Shift bit-vector x left y positions • Throw away extra bits on left • Fill with 0’s on right • 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 right • Undefined Behavior • Shift amount < 0 or ≥ word size Argument x Argument x 01100010 00010000 00011000 00011000 10100010 00010000 00101000 11101000 00010000 11101000 00011000 00101000 00010000 11101000 00101000 00010000 00011000 00011000 00011000 00010000 Arith. >> 2 Arith. >> 2 Log. >> 2 Log. >> 2 << 3 << 3 Shift Operations

26. B A Cool Stuff with xor • Bitwise xor is form of addition • With extra property that every value is its own additive inverse • A ^ A = 0 void funny(int *x, int *y) { *x = *x ^ *y; /* #1 */ *y = *x ^ *y; /* #2 */ *x = *x ^ *y; /* #3 */ } *x *y Begin A B 1 A^B B 2 A^B (A^B)^B = A 3 (A^B)^A = B A End

27. Summary • It’s all about bits & bytes • Numbers • Programs • Text • Different machines follow different conventions • Word size • Byte ordering • Representations and encoding • Boolean algebra is mathematical basis • Basic form encodes “false” as 0, “true” as 1 • General form like bit-level operations in C • Good for representing & manipulating sets

28. Representing information as bits • Bit-level manipulations • Integers • Representation: unsigned and signed • Conversion, casting • Expanding, truncating • Addition, negation, multiplication, shifting • Summary Bits, Bytes, and Integers

29. C short 2 bytes long • Sign Bit • For 2’s complement, most significant bit indicates sign • 0 for nonnegative • 1 for negative Encoding Integers Unsigned Two’s Complement short int x = 15213; short int y = -15213; Sign Bit

30. Encoding Example x = 15213: 00111011 01101101 y = -15213: 11000100 10010011

31. Numeric Ranges • Unsigned Values • UMin = 0 • 000…0 • UMax = 2w – 1 • 111…1 • Two’s Complement Values • TMin = –2w–1 • 100…0 • TMax = 2w–1 – 1 • 011…1 • Other Values • Minus 1 • 111…1 Values for w = 16

32. Values for Different Word Sizes • Observations • |TMin | = TMax + 1 • Asymmetric range • UMax = 2 * TMax + 1 • C Programming • #include <limits.h> • Declares constants, e.g., • ULONG_MAX • LONG_MAX • LONG_MIN • Values platform specific

33. Unsigned & Signed Numeric Values X B2U(X) B2T(X) • Equivalence • Same encodings for nonnegative values • Uniqueness • Every bit pattern represents unique integer value • Each representable integer has unique bit encoding •  Can invert mappings • U2B(x) = B2U-1(x) • Bit pattern for unsigned integer • T2B(x) = B2T-1(x) • Bit pattern for two’s comp integer 0000 0 0 0001 1 1 0010 2 2 0011 3 3 0100 4 4 0101 5 5 0110 6 6 0111 7 7 1000 8 –8 1001 9 –7 1010 10 –6 1011 11 –5 1100 12 –4 1101 13 –3 1110 14 –2 1111 15 –1

34. Representing information as bits • Bit-level manipulations • Integers • Representation: unsigned and signed • Conversion, casting • Expanding, truncating • Addition, negation, multiplication, shifting • Summary Bits, Bytes, and Integers

35. Mappings between unsigned and two’s complement numbers • keep bit representations and reinterpret Mapping Between Signed & Unsigned Two’s Complement Unsigned T2U x ux T2B B2U Maintain Same Bit Pattern Unsigned Two’s Complement U2T ux x U2B B2T Maintain Same Bit Pattern

36. T2U U2T Mapping Signed  Unsigned

37. = +/- 16 Mapping Signed  Unsigned

38. + - + + + + • • • • • • + + + + + + Relation between Signed & Unsigned Two’s Complement Unsigned T2U x ux T2B B2U Maintain Same Bit Pattern w–1 0 ux x Large negative weight becomes Large positive weight

39. 2’s Comp.  Unsigned • Ordering Inversion • Negative  Big Positive Conversion Visualized UMax UMax – 1 TMax+ 1 Unsigned Range TMax TMax 2’s Complement Range 0 0 –1 –2 TMin

40. Constants • By default are considered to be signed integers • Unsigned if have “U” as suffix • 0U, 4294967259U • Casting • Explicit casting between signed & unsigned same as U2T and T2U • inttx, ty; • unsigned ux, uy; • tx = (int) ux; • uy = (unsigned) ty; • Implicit casting also occurs via assignments and procedure calls • tx = ux; • uy = ty; Signed vs. Unsigned in C

41. Expression Evaluation • If there is a mix of unsigned and signed in single expression • Signed values implicitly cast to unsigned • Including comparison operations <, >, ==, <=, >= • Example W = 32:TMIN = -2,147,483,648:TMAX = 2,147,483,647 Casting Surprises

42. Bit pattern is maintained • But reinterpreted • Can have unexpected effects: adding or subtracting 2w • Expression containing signed and unsigned int • int is cast to unsigned!! Casting Basic Rules

43. Representing information as bits • Bit-level manipulations • Integers • Representation: unsigned and signed • Conversion, casting • Expanding, truncating • Addition, negation, multiplication, shifting • Summary Today: Bits, Bytes, and Integers

44. Task: • 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 w X • • • • • • X  • • • • • • w k Sign Extension k copies of MSB

45. Converting from smaller to larger integer data type C automatically performs sign extension Sign Extension Example short int x = 15213; int ix = (int) x; short int y = -15213; intiy = (int) y;

46. Prove correctness by induction on k • Induction step • Extending by single bit maintains value • Key observation: –2w = –2w+1 + 2w w X - • • • X - + • • • w+1 Justification For Sign Extension

47. Truncating a number can alter its value • A form of overflow • For an unsigned number of x • Result of truncating it to k bits is equivalent to computing x mod 2k B2Uk([xk,xk-1,…,x0])= B2Uw([xw,xw-1,…,x0])mod 2k B2Tk([xk,xk-1,…,x0])= U2Tk(B2Uw([xw,xw-1,…,x0])mod 2k) Truncating Numbers int x = 50323; short int ux = (short) x; // -15213 int y = sx; // -15213

48. Expanding (e.g., shortint to int) • Unsigned: zeros added • Signed: sign extension • Both yield expected result • Truncating (e.g., unsigned to unsignedshort) • Unsigned/signed: bits are truncated • Result reinterpreted • Unsigned: mod operation • Signed: similar to mod • For small numbers yields expected behavior Expanding, Truncating: Basic Rules

49. Implicit conversion of singed to unsigned • Can lead to error or vulnerabilities • Be careful when using unsigned numbers • Java supports only signed integers • >> : arithmetic shift • >>> : logical shift Advice on Singed and Unsigned

50. Representing information as bits • Bit-level manipulations • Integers • Representation: unsigned and signed • Conversion, casting • Expanding, truncating • Addition, negation, multiplication, shifting • Summary Today: Bits, Bytes, and Integers