Hexadecimal Notation

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

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: 160 = 1, 161 = 16, 162 = 256, 163 = 4096, … • Write 32-bit addresses using 8 hex digits • Example: This 32-bit binary number 11000000000000000000000000000000 is written more briefly as: C0000000 (hex)

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

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)

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)

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 and 0x61 represents 01100001 • This suggest a way to do ascii conversions

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!

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;

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

The program’s loop movl $buffer, %ebx movl nbytes, %ecx again: cmpb $’a’, (%ebx) jb nochg cmpb $’z’, (%ebx) ja nochg andb $0xDF, (%ebx) nochg: incl %ebx loop again

The ‘password’ program main obtain_password verify_validity notify_the_user grant_or_refuse request_input receive_reply

Enhanced ‘password’ main obtain_password verify_validity notify_the_user grant_or_refuse request_input receive_reply use_uppercase

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

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

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

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

‘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 and jecxz • Also (for early exits): loope/loopz and loopne/loopnz

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

Might your count be zero? movl nbytes, %ecx jecxz finis again: # the body of your loop goes here loop again finis:

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

Hexadecimal Notation