15-213

1
15-213The course that gives CMU its Zip!
IntegersSep 7, 2004

• Topics
• Numeric Encodings
• Unsigned Twos complement
• Programming Implications
• C promotion rules
• Basic operations
• Addition, negation, multiplication
• Programming Implications
• Consequences of overflow
• Using shifts to perform power-of-2 multiply/divide

class03.ppt
15-213 F04
2
C Puzzles

• Taken from old exams
• Assume machine with 32 bit word size, twos
  complement integers
• For each of the following C expressions, either
• Argue that is true for all argument values
• Give example where not true

• x lt 0 ??? ((x2) lt 0)
• ux gt 0
• x 7 7 ??? (xltlt30) lt 0
• ux gt -1
• x gt y ??? -x lt -y
• x x gt 0
• x gt 0 y gt 0 ??? x y gt 0
• x gt 0 ?? -x lt 0
• x lt 0 ?? -x gt 0

Initialization
int x foo() int y bar() unsigned ux
x unsigned uy y
3
Encoding Integers
Unsigned
Twos Complement
short int x 15213 short int y -15213
Sign Bit

• C short 2 bytes long
• Sign Bit
• For 2s complement, most significant bit
  indicates sign
• 0 for nonnegative
• 1 for negative

4
Encoding Example (Cont.)
x 15213 00111011 01101101 y
-15213 11000100 10010011
5
Numeric Ranges

• Unsigned Values
• UMin 0
• 0000
• UMax 2w 1
• 1111

• Twos Complement Values
• TMin 2w1
• 1000
• TMax 2w1 1
• 0111
• Other Values
• Minus 1
• 1111

Values for W 16
6
Values for Different Word Sizes

• C Programming
•  include ltlimits.hgt
• KR App. B11
• Declares constants, e.g.,
•  ULONG_MAX
•  LONG_MAX
•  LONG_MIN
• Values platform-specific

• Observations
• TMin TMax 1
• Asymmetric range
• UMax 2 TMax 1

7
Unsigned Signed Numeric Values

• 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 twos comp integer

8
Casting Signed to Unsigned

• C Allows Conversions from Signed to Unsigned
• Resulting Value
• No change in bit representation
• Nonnegative values unchanged
• ux 15213
• Negative values change into (large) positive
  values
• uy 50323

short int x 15213 unsigned
short int ux (unsigned short) x short int
y -15213 unsigned short int uy
(unsigned short) y
9
Relation between Signed Unsigned
10
Relation Between Signed Unsigned

• uy y 2 32768 y 65536

11
Signed vs. Unsigned in C

• 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
• 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

12
Casting Surprises

• Expression Evaluation
• If mix unsigned and signed in single expression,
  signed values implicitly cast to unsigned
• Including comparison operations lt, gt, , lt, gt
• Examples for W 32
• Constant1 Constant2 Relation Evaluation
• 0 0U
• -1 0
• -1 0U
• 2147483647 -2147483648
• 2147483647U -2147483648
• -1 -2
• (unsigned) -1 -2
• 2147483647 2147483648U
• 2147483647 (int) 2147483648U

0 0U unsigned -1 0 lt signed -1 0U gt unsigned
2147483647 -2147483648 gt signed 2147483647U -2
147483648 lt unsigned -1 -2 gt signed (unsigned)
-1 -2 gt unsigned 2147483647 2147483648U
lt unsigned 2147483647 (int)
2147483648U gt signed
13
Explanation of Casting Surprises

• 2s Comp. ? Unsigned
• Ordering Inversion
• Negative ? Big Positive

14
Sign Extension

• Task
• Given w-bit signed integer x
• Convert it to wk-bit integer with same value
• Rule
• Make k copies of sign bit
• X ? xw1 ,, xw1 , xw1 , xw2 ,, x0

k copies of MSB
15
Sign Extension Example
short int x 15213 int ix (int) x
short int y -15213 int iy (int) y

• Converting from smaller to larger integer data
  type
• C automatically performs sign extension

16
Justification For Sign Extension

• Prove Correctness by Induction on k
• Induction Step extending by single bit maintains
  value
• Key observation 2w1 2w 2w1
• Look at weight of upper bits
• X 2w1 xw1
• X ? 2w xw1 2w1 xw1 2w1 xw1

17
Why Should I Use Unsigned?

• Dont Use Just Because Number Nonzero
• C compilers on some machines generate less
  efficient code
• unsigned i
• for (i 1 i lt cnt i)
• ai ai-1
• Easy to make mistakes
• for (i cnt-2 i gt 0 i--)
• ai ai1
• Do Use When Performing Modular Arithmetic
• Multiprecision arithmetic
• Other esoteric stuff
• Do Use When Need Extra Bits Worth of Range
• Working right up to limit of word size

18
Negating with Complement Increment

• Claim Following Holds for 2s Complement
• x 1 -x
• Complement
• Observation x x 1111112 -1
• Increment
• x x (-x 1) -1 (-x 1)
• x 1 -x
• Warning Be cautious treating ints as integers
• OK here

19
Comp. Incr. Examples
x 15213
0
20
Unsigned Addition
u
Operands w bits
v

True Sum w1 bits
u v
Discard Carry w bits
UAddw(u , v)

• Standard Addition Function
• Ignores carry output
• Implements Modular Arithmetic
• s UAddw(u , v) u v mod 2w

21
Visualizing Integer Addition

• Integer Addition
• 4-bit integers u, v
• Compute true sum Add4(u , v)
• Values increase linearly with u and v
• Forms planar surface

Add4(u , v)
v
u
22
Visualizing Unsigned Addition

• Wraps Around
• If true sum 2w
• At most once

Overflow
UAdd4(u , v)
True Sum
Overflow
v
Modular Sum
u
23
Mathematical Properties

• Modular Addition Forms an Abelian Group
• Closed under addition
• 0  ? UAddw(u , v)   ?  2w 1
• Commutative
• UAddw(u , v)     UAddw(v , u)
• Associative
• UAddw(t, UAddw(u , v))     UAddw(UAddw(t, u ),
  v)
• 0 is additive identity
• UAddw(u , 0)    u
• Every element has additive inverse
• Let UCompw (u )   2w u
• UAddw(u , UCompw (u ))    0

24
Twos Complement Addition
u
Operands w bits
v

True Sum w1 bits
u v
Discard Carry w bits
TAddw(u , v)

• 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

25
Characterizing TAdd

• Functionality
• True sum requires w1 bits
• Drop off MSB
• Treat remaining bits as 2s comp. integer

PosOver
NegOver
(NegOver)
(PosOver)
26
Visualizing 2s Comp. Addition
NegOver

• Values
• 4-bit twos comp.
• Range from -8 to 7
• Wraps Around
• If sum ? 2w1
• Becomes negative
• At most once
• If sum lt 2w1
• Becomes positive
• At most once

TAdd4(u , v)
v
u
PosOver
27
Detecting 2s Comp. Overflow

• Task
• Given s TAddw(u , v)
• Determine if s Addw(u , v)
• Example
• int s, u, v
• s u v
• Claim
• Overflow iff either
• u, v lt 0, s ? 0 (NegOver)
• u, v ? 0, s lt 0 (PosOver)
• ovf (ult0 vlt0) (ult0 ! slt0)

28
Mathematical Properties of TAdd

• Isomorphic Algebra to UAdd
• TAddw(u , v) U2T(UAddw(T2U(u ), T2U(v)))
• Since both have identical bit patterns
• Twos Complement Under TAdd Forms a Group
• Closed, Commutative, Associative, 0 is additive
  identity
• Every element has additive inverse
• Let TCompw (u )    U2T(UCompw(T2U(u ))
• TAddw(u , TCompw (u ))    0

29
Multiplication

• Computing Exact Product of w-bit numbers x, y
• Either signed or unsigned
• Ranges
• Unsigned 0 x y (2w 1) 2 22w 2w1
  1
• Up to 2w bits
• Twos complement min x y (2w1)(2w11)
  22w2 2w1
• Up to 2w1 bits
• Twos complement max x y (2w1) 2 22w2
• Up to 2w bits, but only for (TMinw)2
• Maintaining Exact Results
• Would need to keep expanding word size with each
  product computed
• Done in software by arbitrary precision
  arithmetic packages

30
Unsigned Multiplication in C
u
Operands w bits
v

u v
True Product 2w bits
UMultw(u , v)
Discard w bits w bits

• Standard Multiplication Function
• Ignores high order w bits
• Implements Modular Arithmetic
• UMultw(u , v) u v mod 2w

31
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
  UMultw(ux, uy)
• Modular arithmetic up ux ? uy mod 2w
• Twos 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 TMultw(x, y)

32
Unsigned vs. Signed Multiplication

• Unsigned Multiplication
• unsigned ux (unsigned) x
• unsigned uy (unsigned) y
• unsigned up ux uy
• Twos Complement Multiplication
• int x, y
• int p x y
• Relation
• Signed multiplication gives same bit-level result
  as unsigned
• up (unsigned) p

33
Power-of-2 Multiply with Shift

• Operation
• u ltlt k gives u 2k
• Both signed and unsigned
• Examples
• u ltlt 3 u 8
• u ltlt 5 - u ltlt 3 u 24
• Most machines shift and add faster than multiply
• Compiler generates this code automatically

k
u
  
Operands w bits
2k

0
0
1
0
0
0


u 2k
True Product wk bits
0
0
0

UMultw(u , 2k)
0
0
0


Discard k bits w bits
TMultw(u , 2k)
34
Compiled Multiplication Code
C Function
int mul12(int x) return x12
Compiled Arithmetic Operations
Explanation
leal (eax,eax,2), eax sall 2, eax
t lt- xx2 return t ltlt 2

• C compiler automatically generates shift/add code
  when multiplying by constant

35
Unsigned Power-of-2 Divide with Shift

• Quotient of Unsigned by Power of 2
• u gtgt k gives ? u / 2k ?
• Uses logical shift

k
u
Binary Point

Operands
2k
/
0
0
1
0
0
0


u / 2k
Division
.

0

Result
? u / 2k ?

0

36
Compiled Unsigned Division Code
C Function
unsigned udiv8(unsigned x) return x/8
Compiled Arithmetic Operations
Explanation
shrl 3, eax
Logical shift return x gtgt 3

• Uses logical shift for unsigned
• For Java Users
• Logical shift written as gtgtgt

37
Signed Power-of-2 Divide with Shift

• Quotient of Signed by Power of 2
• x gtgt k gives ? x / 2k ?
• Uses arithmetic shift
• Rounds wrong direction when u lt 0

38
Correct Power-of-2 Divide

• Quotient of Negative Number by Power of 2
• Want ? x / 2k ? (Round Toward 0)
• Compute as ? (x2k-1)/ 2k ?
• In C (x (1ltltk)-1) gtgt k
• Biases dividend toward 0
• Case 1 No rounding

k
Dividend
u
1

0
0
0

2k 1
0
0
0
1
1
1


Binary Point
1

1
1
1

Divisor
2k
/
0
0
1
0
0
0


? u / 2k ?
.
1

0
1
1

1
1
1
1

Biasing has no effect
39
Correct Power-of-2 Divide (Cont.)
Case 2 Rounding
k
Dividend
x
1


2k 1
0
0
0
1
1
1


1


Binary Point
Incremented by 1
Divisor
2k
/
0
0
1
0
0
0


? x / 2k ?
.
1

0
1
1

1

Biasing adds 1 to final result
Incremented by 1
40
Compiled Signed Division Code
C Function
int idiv8(int x) return x/8
Compiled Arithmetic Operations
Explanation
testl eax, eax js L4 L3 sarl 3,
eax ret L4 addl 7, eax jmp L3
if x lt 0 x 7 Arithmetic shift return
x gtgt 3

• Uses arithmetic shift for int
• For Java Users
• Arith. shift written as gtgt

41
Properties of Unsigned Arithmetic

• Unsigned Multiplication with Addition Forms
  Commutative Ring
• Addition is commutative group
• Closed under multiplication
• 0  ? UMultw(u , v)  ?  2w 1
• Multiplication Commutative
• UMultw(u , v)     UMultw(v , u)
• Multiplication is Associative
• UMultw(t, UMultw(u , v))     UMultw(UMultw(t, u
  ), v)
• 1 is multiplicative identity
• UMultw(u , 1)    u
• Multiplication distributes over addtion
• UMultw(t, UAddw(u , v))     UAddw(UMultw(t, u ),
  UMultw(t, v))

42
Properties of Twos Comp. Arithmetic

• Isomorphic Algebras
• Unsigned multiplication and addition
• Truncating to w bits
• Twos complement multiplication and addition
• Truncating to w bits
• Both Form Rings
• Isomorphic to ring of integers mod 2w
• Comparison to Integer Arithmetic
• Both are rings
• Integers obey ordering properties, e.g.,
• u gt 0 ? u v gt v
• u gt 0, v gt 0 ? u v gt 0
• These properties are not obeyed by twos comp.
  arithmetic
• TMax 1 TMin
• 15213 30426 -10030 (16-bit words)

43
C Puzzle Answers

• Assume machine with 32 bit word size, twos comp.
  integers
• TMin makes a good counterexample in many cases

• x lt 0 ?? ((x2) lt 0) False TMin
• ux gt 0 True 0 UMin
• x 7 7 ?? (xltlt30) lt 0 True x1 1
• ux gt -1 False 0
• x gt y ?? -x lt -y False -1, TMin
• x x gt 0 False 30426
• x gt 0 y gt 0 ?? x y gt 0 False TMax, TMax
• x gt 0 ?? -x lt 0 True TMax lt 0
• x lt 0 ?? -x gt 0 False TMin

• x lt 0 ?? ((x2) lt 0)
• ux gt 0
• x 7 7 ?? (xltlt30) lt 0
• ux gt -1
• x gt y ?? -x lt -y
• x x gt 0
• x gt 0 y gt 0 ?? x y gt 0
• x gt 0 ?? -x lt 0
• x lt 0 ?? -x gt 0