February 4, 2003 CSCE 212 Computer Architecture Lecture 3 Representing Integers

– 2 – CSCE 212H Sp 03 Bit-Level Operations in C Operations &, |, ~, ^ Available in C Apply to any “integral” data type long, int, short, char View arguments as bit vectors Arguments applied bit-wise Examples (Char data type) ~0x41 --> 0xBE ~ > ~0x00 --> 0xFF ~ > x69 & 0x55 --> 0x & > x69 | 0x55 --> 0x7D | >

– 3 – CSCE 212H Sp 03 Contrast: Logic Operations in C 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)

– 4 – CSCE 212H Sp 03 Shift Operations 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 Useful with two’s complement integer representation

– 5 – CSCE 212H Sp 03 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 */ *x = *x ^ *y; /* #1 */ *y = *x ^ *y; /* #2 */ *y = *x ^ *y; /* #2 */ *x = *x ^ *y; /* #3 */ *x = *x ^ *y; /* #3 */}

– 6 – CSCE 212H Sp 03 C Integer Puzzles Assume machine with 32 bit word size, two’s complement integers For each of the following C expressions, either: Argue that is true for all argument values Give example where not true x < 0  ((x*2) < 0) ux >= 0 x & 7 == 7  (x<<30) < 0 ux > -1 x > y  -x < -y x * x >= 0 x > 0 && y > 0  x + y > 0 x >= 0  -x <= 0 x = 0 int x = foo(); int y = bar(); unsigned ux = x; unsigned uy = y; Initialization

– 7 – CSCE 212H Sp 03 Encoding Integers short int x = 15213; short int y = ; C short 2 bytes long Sign Bit For 2’s complement, most significant bit indicates sign 0 for nonnegative 1 for negative Unsigned Two’s Complement Sign Bit

– 8 – CSCE 212H Sp 03 Encoding Example (Cont.) x = 15213: y = :

– 9 – CSCE 212H Sp 03 Numeric Ranges Unsigned Values UMin=0 000…0 UMax = 2 w – 1 111…1 Two’s Complement Values TMin= –2 w–1 100…0 TMax = 2 w–1 – 1 011…1 Other Values Minus 1 111…1 Values for W = 16

– 10 – CSCE 212H Sp 03 Values for Different Word Sizes Observations |TMin | = TMax + 1 Asymmetric range UMax=2 * TMax + 1 C Programming #include K&R App. B11 Declares constants, e.g., ULONG_MAX LONG_MAX LONG_MIN Values platform-specific

– 11 – CSCE 212H Sp 03 short int x = 15213; unsigned short int ux = (unsigned short) x; short int y = ; unsigned short int uy = (unsigned short) y; Casting Signed to Unsigned C Allows Conversions from Signed to Unsigned Resulting Value No change in bit representation Nonnegative values unchanged ux = Negative values change into (large) positive values uy = 50323

– 12 – CSCE 212H Sp 03 Relation Between Signed & Unsigned uy = y + 2 * 32768=y

– 13 – CSCE 212H Sp 03 Signed vs. Unsigned in C Constants By default are considered to be signed integers Unsigned if have “U” as suffix 0U, UCasting Explicit casting between signed & unsigned int tx, ty; unsigned ux, uy; tx = (int) ux; uy = (unsigned) ty; Implicit casting also occurs via assignments and procedure calls tx = ux; uy = ty;

– 14 – CSCE 212H Sp 03 00U== unsigned -10< signed -10U> unsigned > signed U < unsigned -1-2 > signed (unsigned) -1-2 > unsigned U < unsigned (int) U > signed Casting Surprises Expression Evaluation If mix unsigned and signed in single expression, signed values implicitly cast to unsigned Including comparison operations, ==, = Examples for W = 32 Constant 1 Constant 2 RelationEvaluation 00U U U (unsigned) U (int) U

– 15 – CSCE 212H Sp 03 0 TMax TMin –1 –2 0 UMax UMax – 1 TMax TMax + 1 2’s Comp. Range Unsigned Range Explanation of Casting Surprises 2’s Comp.  Unsigned Ordering Inversion Negative  Big Positive

– 16 – CSCE 212H Sp 03 Sign Extension Task: Given w-bit signed integer x Convert it to w+k-bit integer with same valueRule: Make k copies of sign bit: X = x w–1,…, x w–1, x w–1, x w–2,…, x 0 k copies of MSB X X w w k

– 17 – CSCE 212H Sp 03 Sign Extension Example Converting from smaller to larger integer data type C automatically performs sign extension short int x = 15213; int ix = (int) x; short int y = ; int iy = (int) y;

– 18 – CSCE 212H Sp 03 Why Should I Use Unsigned? Don’t Use Just Because Numbers Nonnegative C compilers on some machines generate less efficient code unsigned i; for (i = 1; i < cnt; i++) a[i] += a[i-1]; Easy to make mistakes for (i = cnt-2; i >= 0; i--) a[i] += a[i+1]; Do Use When Performing Modular Arithmetic Multiprecision arithmetic Other esoteric stuff Do Use When Need Extra Bit’s Worth of Range Working right up to limit of word size

– 19 – CSCE 212H Sp 03 Negating with Complement & Increment Claim: Following Holds for 2’s Complement ~x + 1 == -xComplement Observation: ~x + x == 1111…11 2 == -1Increment ~x + x + (-x + 1)==-1 + (-x + 1) ~x + 1==-x Warning: Be cautious treating int ’s as integers x ~x

– 20 – CSCE 212H Sp 03 Comp. & Incr. Examples x =

– 21 – CSCE 212H Sp 03 Unsigned Addition Standard Addition Function Ignores carry output Implements Modular Arithmetic s= UAdd w (u, v)=u + v mod 2 w u v + u + v True Sum: w+1 bits Operands: w bits Discard Carry: w bits UAdd w (u, v)

– 22 – CSCE 212H Sp 03 Mathematical Properties Modular Addition Forms an Abelian Group Closed under addition 0  UAdd w (u, v)  2 w –1 Commutative UAdd w (u, v) = UAdd w (v, u) Associative UAdd w (t, UAdd w (u, v)) = UAdd w (UAdd w (t, u ), v) 0 is additive identity UAdd w (u, 0) = u Every element has additive inverse Let UComp w (u ) = 2 w – u UAdd w (u, UComp w (u )) = 0

– 23 – CSCE 212H Sp 03 Two’s Complement Addition TAdd and UAdd have Identical Bit-Level Behavior Signed vs. unsigned addition in C: int s, t, u, v; s = (int) ((unsigned) u + (unsigned) v); t = u + v Will give s == t u v + u + v True Sum: w+1 bits Operands: w bits Discard Carry: w bits TAdd w (u, v)

– 24 – CSCE 212H Sp 03 Characterizing TAdd Functionality True sum requires w+1 bits Drop off MSB Treat remaining bits as 2’s comp. integer –2 w –1 –2 w 0 2 w –1 True Sum TAdd Result 1 000… … … … …1 100…0 000…0 011…1 PosOver NegOver (NegOver) (PosOver) u v < 0> 0 < 0 > 0 NegOver PosOver TAdd(u, v)

– 25 – CSCE 212H Sp 03 Detecting 2’s Comp. Overflow Task Given s = TAdd w (u, v) Determine if s = Add w (u, v) Example int s, u, v; s = u + v;Claim Overflow iff either: u, v < 0, s  0(NegOver) u, v  0, s < 0(PosOver) overflow = (u<0 == v<0) && (u<0 != s<0); 0 2 w –1 PosOver NegOver

– 26 – CSCE 212H Sp 03 Mathematical Properties of TAdd Isomorphic Algebra to UAdd TAdd w (u, v) = U2T(UAdd w (T2U(u ), T2U(v))) Since both have identical bit patterns Two’s Complement Under TAdd Forms a Group Closed, Commutative, Associative, 0 is additive identity Every element has additive inverse Let TComp w (u ) = U2T(UComp w (T2U(u )) TAdd w (u, TComp w (u )) = 0

– 27 – CSCE 212H Sp 03 Unsigned vs. Signed Multiplication Unsigned Multiplication unsigned ux = (unsigned) x; unsigned uy = (unsigned) y; unsigned up = ux * uy Truncates product to w-bit number up = UMult w (ux, uy) Modular arithmetic: up = ux  uy mod 2 w Two’s Complement Multiplication int x, y; int p = x * y; Compute exact product of two w-bit numbers x, y Truncate result to w-bit number p = TMult w (x, y)

– 28 – CSCE 212H Sp 03 Unsigned Multiplication in C Standard Multiplication Function Ignores high order w bits Implements Modular Arithmetic UMult w (u, v)=u · v mod 2 w u v * u · v True Product: 2*w bits Operands: w bits Discard w bits: w bits UMult w (u, v)

– 29 – CSCE 212H Sp 03 Unsigned vs. Signed Multiplication Unsigned Multiplication unsigned ux = (unsigned) x; unsigned uy = (unsigned) y; unsigned up = ux * uy Two’s Complement Multiplication int x, y; int p = x * y;Relation Signed multiplication gives same bit-level result as unsigned up == (unsigned) p

– 30 – CSCE 212H Sp 03 Power-of-2 Multiply with Shift Operation u << k gives u * 2 k Both signed and unsignedExamples u << 3==u * 8 u << 5 - u << 3==u * 24 Most machines shift and add much faster than multiply Compiler generates this code automatically u 2k2k * u · 2 k True Product: w+k bits Operands: w bits Discard k bits: w bits UMult w (u, 2 k ) k 000 TMult w (u, 2 k ) 000

– 31 – CSCE 212H Sp 03 Unsigned Power-of-2 Divide with Shift Quotient of Unsigned by Power of 2 u >> k gives  u / 2 k  Uses logical shift u 2k2k / u / 2 k Division: Operands: k 0  u / 2 k  Result:. Binary Point 0

– 32 – CSCE 212H Sp 03 Signed Power-of-2 Divide with Shift Quotient of Signed by Power of 2 x >> k gives  x / 2 k  Uses arithmetic shift Rounds wrong direction when u < x 2k2k / x / 2 k Division: Operands: k 0 RoundDown(x / 2 k ) Result:. Binary Point 0

– 33 – CSCE 212H Sp 03 Correct Power-of-2 Divide Quotient of Negative Number by Power of 2 Want  x / 2 k  (Round Toward 0) Compute as  (x+ 2 k -1)/ 2 k  In C: (x + (1 > k Biases dividend toward 0 Case 1: No rounding Divisor: Dividend: u 2k2k /  u / 2 k  k Binary Point k +– Biasing has no effect

– 34 – CSCE 212H Sp 03 Correct Power-of-2 Divide (Cont.) Divisor: Dividend: Case 2: Rounding x 2k2k /  x / 2 k  k Binary Point k +–1 1 Biasing adds 1 to final result Incremented by 1

– 35 – CSCE 212H Sp 03 Properties of Unsigned Arithmetic Unsigned Multiplication with Addition Forms Commutative Ring Addition is commutative group Closed under multiplication 0  UMult w (u, v)  2 w –1 Multiplication Commutative UMult w (u, v) = UMult w (v, u) Multiplication is Associative UMult w (t, UMult w (u, v)) = UMult w (UMult w (t, u ), v) 1 is multiplicative identity UMult w (u, 1) = u Multiplication distributes over addtion UMult w (t, UAdd w (u, v)) = UAdd w (UMult w (t, u ), UMult w (t, v))

– 36 – CSCE 212H Sp 03 Properties of Two’s Comp. Arithmetic Isomorphic Algebras Unsigned multiplication and addition Truncating to w bits Two’s complement multiplication and addition Truncating to w bits Both Form Rings Isomorphic to ring of integers mod 2 w Comparison to Integer Arithmetic Both are rings Integers obey ordering properties, e.g., u > 0  u + v > v u > 0, v > 0  u · v > 0 These properties are not obeyed by two’s comp. arithmetic TMax + 1== TMin * 30426== (16-bit words)