1. Hexadecimal Notation Using sixteen as a number base when representing binary data

2. Positional Notation (Base 16) Set of sixteen digit-symbols: 0,1,2,3,4,5,6,7,8,9,A,B,C,D,E,F Position-values are powers of sixteen: 16 0 = 1, 16 1 = 16, 16 2 = 256, 16 3 = 4096, … Write 32-bit addresses using 8 hex digits Example: This 32-bit binary number 11000000000000000000000000000000 is written more briefly as: C0000000 (hex)

3. ‘nybbles’ Each hex digit represents 4-bits: 0 = 00008 = 1000 1 = 00019 = 1001 2 = 0010A = 1010 3 = 0011B = 1011 4 = 0100C = 1100 5 = 0101D = 1101 6 = 0110E = 1110 7 = 0111F = 1111

4. Conversions Register AL holds 8 binary digits (bits) Example:AL = 01100001 (binary) One byte (8-bits) equals two nybbles: AL = 0110 0001 Each nybble (4-bits) is just one hex digit: Example:AL = 61 (hex)

5. Interpreting numbers Our assembler understands hex notation Assembler also recognizes ‘octal’ (base 8) Notations conform to C language syntax Numbers are assumed decimal (base 10) unless otherwise indicated (via a ‘prefix’) Example:50 means ‘fifty’ (base 10) but 0x50 means ‘eighty’ (base 16) and 050 means ‘forty’ (base 8)

6. ASCII-codes in hex Uppercase letter ‘A’ is ascii-code 65 Very often it’s written (in hex) as 0x41 Lowercase letter ‘a’ is ascii-code 97 And very often is written (in hex) as 0x61 Hex makes it easy to ‘see’ the binary data Examples: 0x41 represents 01000001 and0x61 represents 01100001 This suggest a way to do ascii conversions

7. Lowercase vs. Uppercase Ascii-codes for lowercase letters (‘a’-’z’): 0x61, 0x62, 0x63, …, 0x79, 0x7A Ascii-codes for uppercase letters (‘A’-’Z’): 0x41, 0x42, 0x43, …, 0x59, 0x5A We can visualize these values as ‘bits’ – lowercase: 01100001, …, 01111010 – uppercase: 01000001, …, 01011010 We see bit number 5 is where they differ!

8. Using ‘AND’ and ‘OR’ We can use the ‘bitwise-OR’ operator to convert uppercase to lowercase: i.e., lowercase = uppercase | 0x20; We can use the ‘bitwise-AND’ operator to convert lowercase to uppercase: i.e.,uppercase = lowercase & 0xDF;

9. The ‘toupper.s’ program We can write an assembly language loop to convert a user’s input into uppercase Select a 32-bit register to use as a ‘pointer’ Example: movl$buffer, %ebx In case EBX points to a lowercase letter, we can convert it to uppercase by using: andb$0xDF, (%ebx) # resets bit 5 to 0 The ‘b’ suffix here tells the operand’s size

10. The program’s loop movl$buffer, %ebx movlnbytes, %ecx again:cmpb$’a’, (%ebx) jbnochg cmpb$’z’, (%ebx) janochg andb$0xDF, (%ebx) nochg:incl%ebx loopagain

11. The ‘password’ program main obtain_passwordnotify_the_usergrant_or_refuseverify_validity request_inputreceive_reply

12. Enhanced ‘password’ main obtain_passwordnotify_the_usergrant_or_refuseverify_validity request_inputreceive_reply use_uppercase

13. Typical kinds of loops ‘while’ loops: So long as a condition is true perform the action in the body of this loop ‘until’ loops: Perform the action in the body of this loop until condition is no longer true Note: a while-loop can be empty, but an until-loop always executes at least once

14. Flowcharts condition action TRUE leave FALSE TRUE FALSE leave WHILE-LOOP UNTIL-LOOP initializations enter

15. A typical ‘WHILE’ loop movb$FALSE, done again: cmpb$FALSE, done jnefinis # the body of the loop goes here # (and may alter the ‘done’ flag) jmpagain finis:

16. A typical ‘UNTIL’ loop movb$TRUE, done again: # the body of the loop goes here # (and may alter the ‘done’ flag) cmpb$TRUE, done jeagain

17. ‘Counted’ loops Very often we know in advance the number of times that the body of a loop needs to execute In these cases the loop’s exit-condition is based on the changing value of a counter Sometimes a counted loop needs to allow for an early exit (before the final count is reached) Pentium has some special support-instructions: loop andjecxz Also (for early exits): loope/loopz and loopne/loopnz

18. A typical ‘counted’ loop movl$array, %ebx movl$0, %eax movl$50, %ecx nxadd:addl(%ebx), %eax addl$4, %ebx loopnxadd movl%eax, total

19. Might your count be zero? movlnbytes, %ecx jecxzfinis again: # the body of your loop goes here loopagain finis:

20. An ‘early exit’ example # gets the first non-blank character from ‘inbuf’ # (where ‘nbytes’ is length of the ‘inbuf’ array) movl$inbuf, %esi movlnbytes, %ecx again:movb(%esi), %al incl%esi cmpb$’ ’, %al loopeagain