Chapter 1

Definitions

Assembler - converts source (assembly) code into machine language
Linker - combines multiple object files created by assembler into one executable file
Debugger - allows stepping through a running program to examine registers and memory
MASM Programs:

32-bit (protected) mode - runs on all x86 and x64 Windows
64-bit mode - runs on x86 Windows
Machine Language - numeric language understood by CPU
Assembly Language - lowest human-readable language. Has 1-to-1 relation with machine language

One-to-one relation

One assembly instruction is converted into one machine instruction
High-level languages have one-to-many relation, where one HLL instruction can be expanded into multiple machine instructions

High-Level Languages - (C++, Python). Have 1-to-many relation
Registers - storage in CPU holding intermediate results of operations

Assembly Usage

Assembly language is NOT portable
Each family of processors has its own version of assembly language
Almost every high-level language is portable

Good Assembly Use-Cases

embedded programs (in AC controller)
real-time hardware monitoring
game consoles software
device drivers

Virtual Machine Concept

Computer by itsself can only execute machine code. (L0)
For humans, it's not understandable, so we write higher-level code (L2)
Sometimes, that is not flexible enough, so we create higher levels (L3)

For computers to understand L1 code, we have two possibilities:

Interpretation - each L1 instruction is decoded by an L0 interpreter at runtime and run. Causes delays
Translation - whole L1 code is first translated into L0 code (by L0 translator) and then run directly on hardware

We can also turn this concept by using Virtual Machines instead of languages
Higher-level VM turns its code into one understandable by VM one level below
Each VM can be either software or hardware-based

Real computer situation

Instruction Set Architecture (level 2) - set of basic operations (add, move, multiply) executed directly by hardware or by microprocessor embedded program - microprogram

Data Representation

Numeric Systems

binary (base 2)
octal (base 8)
decimal (base 10)
hexadecimal (base 16)

Binary Integers

Sequence of 16 bits, starting from the Most Significant bit (MSb) to the Least Significant bit (LSb)

\overset{15}{\underset{M S b}{0}} 1 1 0 1 0 1 \overset{8}{1} 1 0 1 0 0 0 1 \overset{0}{\underset{L S b}{1}}

Binary integers can be signed or unsigned (positive by default)
Bit position values: starting from LSb ( $i = 0$ ), each bit has an increasing value of $2^{i}$

Binary to Decimal Conversion

We multiply value of each bit ( $0 / 1$ ) by the bit's weight, and add all of the products together

10011_{2} = 1 \cdot 2^{4} + 0 \cdot 2^{3} + 0 \cdot 2^{2} + 1 \cdot 2^{1} + 1 \cdot 2^{0} = 16 + 2 + 1 = 19_{10}

Decimal to Binary Conversion

We divide the decimal by base (2) and save the remainder starting from LSB upwards

\begin{aligned} 37 / 2 = 18 r. 1 \\ 18 / 2 = 9 r. 0 \\ 9 / 2 = 4 r. 1 & \to 100101_{2} \\ 4 / 2 = 2 r. 0 \\ 2 / 2 = 1 r. 0 \\ 1 / 2 = 0 r. 1 \end{aligned}

Binary Addition

\begin{aligned} 0 + 0 = 0 \\ 0 + 1 = 1 \\ 1 + 0 = 1 \\ 1 + 1 = 10 \end{aligned}

To add two binary numbers, we add bits of the same weight, and (if applicable), carry $1$ into next, higher bit

\begin{aligned} 0 \overset{1}{0} \overset{1}{1} \overset{1}{0} 1 1 & 11 \end{aligned}

\begin{array}{rrrrrrrrrrr} 0 & \overset{1}{0} & \overset{1}{1} & \overset{1}{0} & 1 & 1 & 11 \\ + & 0 & 1 & 1 & 1 & 1 & 0 & + & 30 \\ = & 1 & 0 & 1 & 0 & 0 & 1 & 41 \end{array}

Binary Subtraction

\begin{matrix} 0 & \overset{0}{1} & \overset{0}{1} & 0 & 0 & 13 \\ - & 0 & 0 & 1 & 1 & 1 & 7 \\ 0 & 0 & 1 & 1 & 0 & 6 \end{matrix}

bit 0 is easy - $1 - 1 = 0$
For bit 1, we have to borrow $1$ from higher bit (2), so it turns into $10 - 1 = 1$ , and for bit 2, $0$ is left

A simple approach would be to take a Two's Complement of the second value, and turn the problem from $13 - 7$ into $13 + (- 7)$ which is easy to calculate and can be done on the same circuit

Integer Storage Sizes

Byte - 8 bits
Word - 2 bytes, 16 bits
Double Word - 4 bytes, 32 bits
Quad Word - 8 bytes, 64 bits
Double Quad Word - 16 bytes, 128 bits

Signed Binary Integers

We use MSb as the SIGN bit
0 - positive
1 - negative

Hexadecimal numbers

Easier to read than binary for large numbers
Digits are $0 - F$ with values $0 - 15$

\overset{0001}{1} \overset{0110}{6} \overset{1010}{A} \overset{0111}{7} \overset{1001}{9} \overset{1100}{C}

One hex digit is equal to 4 bits

Hexadecimal to Decimal Conversion

Same method as for bin-dec. Multiply each digit by its weight ( $16^{i}$ )

3 B A 4 = 3 \cdot 16^{3} + 11 \cdot 16^{2} + A \cdot 16^{1} + 4 \cdot 16^{0} = 12288 + 2816 + 160 + 4 = 15268

Decimal to Hexadecimal Conversion

Again, exactly the same process as for dec-bin. Divide by base ( $16$ ) and take the remainder

\begin{aligned} 422 / 16 = 26 r. 6 \\ 26 / 16 = 1 r. 10 & \to & 1 A 6 \\ 1 / 16 = 0 r. 1 \end{aligned}

Hexadecimal Addition

Works in the same way as binary, just with base 16

\begin{array}{rrrr} \overset{1}{6} & A & 2 \\ + & 4 & 9 & A \\ B & 3 & C \end{array}

Two's Complement

Most used notation of numbers, allowing for easy addition with negative numbers. Addition is exactly the same as Binary Addition
Additionally, gets rid of negative-zero problem
To get a negative complement of a number, we have to use formula

- x = \bar{x} + 1

\begin{array}{rrrrr} 00101100 & 44 & 10011000 & - 104 \\ 1. invert the number & 11010011 & 01100111 \\ 2. add 1 to the invert & 11010100 & - 44 & 01101000 & 104 \end{array}

Hexadecimal Two's Complement

Same process. Taking complement of a hex digit $x$ means taking $15 - x$

\begin{matrix} 4 A 92 & \to & B 56 D + 1 & \to & B 56 E \\ F 14 C & \to & 0 E B 3 + 1 & \to & O E B 4 \end{matrix}

Signed Binary to Decimal Conversion

If the $SIGN$ bit is 0 (positive number) the number is converted as unsigned binary
If the number is negative ( $MSB = 1$ ) we calculate the positive Two's Complement equivalent, and then convert that to decimal

Minimum and Maximum Values

Signed Byte - $[- 2^{7}, 2^{7} - 1]$
Signed Word - $[- 2^{15}, 2^{15} - 1]$
Signed Double Word - $[- 2^{31}, 2^{31} - 1]$
Signed Quad Word - $[- 2^{63}, 2^{63} - 1]$

Large Data Sizes

1 kilobyte = $2^{10}$ = 1024B
1 megabyte = $2^{20}$ = 1024kB
1 gigabyte = $2^{30}$ = 1024MB
1 terabyte = $2^{40}$ = 1024GB
1 petabyte = $2^{50}$ = 1024TB
1 exabyte = $2^{60}$ = 1024PB
1 zettabyte = $2^{70}$ = 1024EB
1 yottabyte = $2^{80}$ = 1024ZB

Terminology for Numeric Data Representation

01000001 as an integer is $65$ , as a character - $A$
To differentiate, we introduce naming:

Binary digit string - " $01000001$ "
Decimal digit string - " $65$ "
Hexadecimal digit string - " $41$ "
Octal digit string - " $101$ "

Storing characters

To represent a character, computers use character sets, where each value corresponds to one character
The most basic, 7-bit set is called ASCII (American Standard Code for Information Interchange)
Because ASCII uses only 7 bits, the additional space is used for proprietary sets (i.e. Greek letters on early IBMs)

ANSI (American National Standards Institute) defines 8-bit, 256 character set, with first 128 being letters and symbols on standard US keyboard, next 128 for international letters, currency symbols and fractions

Today, we need to store lots more of characters, and we do it in UNICODE standard.

UTF-8 - used in HTML, equal values to ASCII
UTF-16 - balance of efficiency ans storage. MS Windows uses this as base. Character encoded in 16 bits.
UTF-32 - bit set, where storage isn't a concern

ASCII String

Sequence of 1 or more characters is called a string
String ABC123 is stored as $41 h, 42 h, 43 h, 31 h, 32 h, 33 h$
Most systems require a null-terminated strings ('\0') as an indicator of the end of the string

ASCII Control Characters

Codes $0 - 31$ are set for control charactes, which are indicators for the system
Most common:

8 - backspace
9 - tab
10 - line feed (enter)
11 form feed (next page)
13 - carriage return
27 escape

Binary-Coded Decimal BCD Numbers

Unpacked BCD

One decimal digit is stored in one byte

1234 \to \overset{hex bytess}{01, 02, 03, 04}

If the order is equal to decimal (high-order digits first) - Big-Endian Order
If the order is opposite to decimal - Little-Endian Order

Packed BCD

Two digits are stored in one byte

1234 \to \overset{hex bytes}{12, 34}

This saves $2 \times$ space, but takes more time to unpack and display

Boolean expressions

Boolean algebra defies expressions on values TRUE or FALSE
Basic operations:

NOT - $\neg, \sim,^{'},!, \bar{x}$
AND - $\land, ∙$
OR - $\lor, +$

\begin{array}{ccc} NOT & AND & OR \\ \begin{array}{cc} A & \bar{A} \\ 1 & 0 \\ 0 & 1 \end{array} & \begin{array}{ccc} A & B & A \land B \\ 0 & 0 & 0 \\ 0 & 1 & 0 \\ 1 & 0 & 0 \\ 1 & 1 & 1 \end{array} & \begin{array}{cc} A & B & A \lor B \\ 0 & 0 & 0 \\ 0 & 1 & 1 \\ 1 & 0 & 1 \\ 1 & 1 & 1 \end{array} \end{array}

Multiplexer

(Y \land S) \lor (X \land \bar{S})