Download presentation
Presentation is loading. Please wait.
Published byCameron Casey Modified over 9 years ago
1
Carnegie Mellon 1 This Week: Integers Integers Representation: unsigned and signed Conversion, casting Expanding, truncating Addition, negation, multiplication, shifting Summary
2
Carnegie Mellon 2 Sign Extension 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 = x w–1,…, x w–1, x w–1, x w–2,…, x 0 k copies of MSB X X w w k
3
Carnegie Mellon 3 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 = -15213; int iy = (int) y;
4
Carnegie Mellon 4 Summary: Expanding, Truncating: Basic Rules Expanding (e.g., short int to int) Unsigned: zeros added Signed: sign extension Both yield expected result Truncating (e.g., unsigned to unsigned short) Unsigned/signed: bits are truncated Result reinterpreted Unsigned: mod operation Signed: similar to mod For small numbers yields expected behaviour
5
Carnegie Mellon 5 This Week: Integers Integers Representation: unsigned and signed Conversion, casting Expanding, truncating Addition, negation, multiplication, shifting Summary
6
Carnegie Mellon 6 Negation: Complement & Increment Claim: Following Holds for 2’s Complement ~x + 1 == -x Complement Observation: ~x + x == 1111…111 == -1 10010111 x 01101000 ~x+ 11111111
7
Carnegie Mellon 7 Complement & Increment Examples x = 15213 x = 0
8
Carnegie Mellon 8 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)
9
Carnegie Mellon 9 Visualizing (Mathematical) Integer Addition Integer Addition 4-bit integers u, v Compute true sum Add 4 (u, v) Values increase linearly with u and v Forms planar surface Add 4 (u, v) u v
10
Carnegie Mellon 10 Visualizing Unsigned Addition Wraps Around If true sum ≥ 2 w At most once 0 2w2w 2 w+1 UAdd 4 (u, v) u v True Sum Modular Sum Overflow
11
Carnegie Mellon 11 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
12
Carnegie Mellon 12 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)
13
Carnegie Mellon 13 TAdd Overflow Functionality True sum requires w+1 bits Drop off MSB Treat remaining bits as 2’s comp. integer –2 w –1 –1 –2 w 0 2 w –1 True Sum TAdd Result 1 000…0 1 011…1 0 000…0 0 100…0 0 111…1 100…0 000…0 011…1 PosOver NegOver
14
Carnegie Mellon 14 Visualizing 2’s Complement Addition Values 4-bit two’s comp. Range from -8 to +7 Wraps Around If sum 2 w–1 Becomes negative At most once If sum < –2 w–1 Becomes positive At most once TAdd 4 (u, v) u v PosOver NegOver
15
Carnegie Mellon 15 Characterizing TAdd Functionality True sum requires w+1 bits Drop off MSB Treat remaining bits as 2’s comp. integer u v < 0> 0 < 0 > 0 Negative Overflow Positive Overflow TAdd(u, v)
16
Carnegie Mellon 16 Mathematical Properties of TAdd Isomorphic Group to unsigneds with 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
17
Carnegie Mellon 17 Multiplication Computing Exact Product of w-bit numbers x, y Either signed or unsigned Ranges Unsigned: 0 ≤ x * y ≤ (2 w – 1) 2 = 2 2w – 2 w+1 + 1 Up to 2w bits Two’s complement min: x * y ≥ (–2 w–1 )*(2 w–1 –1) = –2 2w–2 + 2 w–1 Up to 2w–1 bits Two’s complement max: x * y ≤ (–2 w–1 ) 2 = 2 2w–2 Up to 2w bits, but only for (TMin w ) 2 Maintaining Exact Results Would need to keep expanding word size with each product computed Done in software by “arbitrary precision” arithmetic packages
18
Carnegie Mellon 18 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)
19
Carnegie Mellon 19 Code Security Example #2 SUN XDR library Widely used library for transferring data between machines void* copy_elements(void *ele_src[], int ele_cnt, size_t ele_size); ele_src malloc(ele_cnt * ele_size)
20
Carnegie Mellon 20 XDR Code void* copy_elements(void *ele_src[], int ele_cnt, size_t ele_size) { /* * Allocate buffer for ele_cnt objects, each of ele_size bytes * and copy from locations designated by ele_src */ void *result = malloc(ele_cnt * ele_size); if (result == NULL) /* malloc failed */ return NULL; void *next = result; int i; for (i = 0; i < ele_cnt; i++) { /* Copy object i to destination */ memcpy(next, ele_src[i], ele_size); /* Move pointer to next memory region */ next += ele_size; } return result; }
21
Carnegie Mellon 21 XDR Vulnerability What if: ele_cnt = 2 20 + 1 ele_size = 4096 = 2 12 Allocation= ?? How can I make this function secure? malloc(ele_cnt * ele_size)
22
Carnegie Mellon 22 Signed Multiplication in C Standard Multiplication Function Ignores high order w bits Some of which are different for signed vs. unsigned multiplication Lower bits are the same u v * u · v True Product: 2*w bits Operands: w bits Discard w bits: w bits TMult w (u, v)
23
Carnegie Mellon 23 Power-of-2 Multiply with Shift Operation u << k gives u * 2 k Both signed and unsigned Examples u << 3==u * 8 u << 5 - u << 3==u * 24 Most machines shift and add faster than multiply Compiler generates this code automatically 001000 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
24
Carnegie Mellon 24 leal(%eax,%eax,2), %eax sall$2, %eax Compiled Multiplication Code C compiler automatically generates shift/add code when multiplying by constant int mul12(int x) { return x*12; } t <- x+x*2 return t << 2; C Function Compiled Arithmetic OperationsExplanation
25
Carnegie Mellon 25 Unsigned Power-of-2 Divide with Shift Quotient of Unsigned by Power of 2 u >> k gives u / 2 k Uses logical shift 001000 u 2k2k / u / 2 k Division: Operands: k 000 u / 2 k Result:. Binary Point 0 0000
26
Carnegie Mellon 26 shrl$3, %eax Compiled Unsigned Division Code Uses logical shift for unsigned For Java Users Logical shift written as >>> unsigned udiv8(unsigned x) { return x/8; } # Logical shift return x >> 3; C Function Compiled Arithmetic Operations Explanation
27
Carnegie Mellon 27 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 < 0 001000 x 2k2k / x / 2 k Division: Operands: k 0 RoundDown(x / 2 k ) Result:. Binary Point 0
28
Carnegie Mellon 28 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: 001000 u 2k2k / u / 2 k k 1 000 1 011. Binary Point 1 000111 +2 k –1 111 1 111 Biasing has no effect
29
Carnegie Mellon 29 Correct Power-of-2 Divide (Cont.) Divisor: Dividend: Case 2: Rounding 001000 x 2k2k / x / 2 k k 1 1 011. Binary Point 1 000111 +2 k –1 1 Biasing adds 1 to final result Incremented by 1
30
Carnegie Mellon 30 testl %eax, %eax jsL4 L3: sarl$3, %eax ret L4: addl$7, %eax jmpL3 Compiled Signed Division Code Uses arithmetic shift for int For Java Users Arith. shift written as >> int idiv8(int x) { return x/8; } if x < 0 x += 7; # Arithmetic shift return x >> 3; C Function Compiled Arithmetic Operations Explanation
31
Carnegie Mellon 31 Arithmetic: Basic Rules Addition: Unsigned/signed: Normal addition followed by truncate, same operation on bit level Unsigned: addition mod 2 w Mathematical addition + possible subtraction of 2w Signed: modified addition mod 2 w (result in proper range) Mathematical addition + possible addition or subtraction of 2 w Multiplication: Unsigned/signed: Normal multiplication followed by truncate, same operation on bit level Unsigned: multiplication mod 2 w Signed: modified multiplication mod 2 w (result in proper range)
32
Carnegie Mellon 32 Arithmetic: Basic Rules Unsigned ints, 2’s complement ints are isomorphic rings: isomorphism = casting Left shift Unsigned/signed: multiplication by 2 k Always logical shift Right shift Unsigned: logical shift, div (division + round to zero) by 2 k Signed: arithmetic shift Positive numbers: div (division + round to zero) by 2 k Negative numbers: div (division + round away from zero) by 2 k Use biasing to fix
33
Carnegie Mellon 33 This Week: Integers Integers Representation: unsigned and signed Conversion, casting Expanding, truncating Addition, negation, multiplication, shifting Summary
34
Carnegie Mellon 34 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))
35
Carnegie Mellon 35 Why Should I Use Unsigned? Don’t Use Just Because Number Nonnegative Easy to make mistakes unsigned i; for (i = cnt-2; i >= 0; i--) a[i] += a[i+1]; Can be very subtle #define DELTA sizeof(int) int i; for (i = CNT; i-DELTA >= 0; i-= DELTA)... Do Use When Performing Modular Arithmetic Multiprecision arithmetic Do Use When Using Bits to Represent Sets Logical right shift, no sign extension
Similar presentations
© 2025 SlidePlayer.com. Inc.
All rights reserved.