Hardware & Software Architecture Week 7 & 8 Hardware & Software Architecture

Basic Instruction Set The x86 instruction set is extremely huge, but we usually don't need to use them all. Here are some simple instructions you should know to get you started: Instruction Description ADD Adds the two operands and stores the result into the first operand. SUB Subtracts the second operand from the first and stores the result in the first operand. MUL Multiplies the operand with the Accumulator Register and stores the result in the Accumulator Register. DIV Divides the Accumulator Register by the operand and stores the result in the Accumulator Register. AND Performs the bitwise logical AND operation on the operands and stores the result in the first operand. OR Performs the bitwise logical OR operation on the operands and stores the result in the first operand. INC Increases the value of the operand by 1 and stores the result in the operand. DEC Decreases the value of the operand by 1 and stores the result in the operand.

Basic Instruction Set … Description NEG Negates the operand and stores the result in the operand. PUSH Pushes the value of the operand on to the top of the stack. POP Pops the value of the top item of the stack in to the operand. MOV Stores the second operand's value in the first operand. CMP Subtracts the second operand from the first operand and sets the respective flags. JMP Jumps to label. INT constant Calls the interrupt specified by the operand.

Basic instructions… mov eax,10000h add eax,40000h sub eax,20000h The MOV instruction moves (copies) the integer 10000h to the EAX register. The first operand (EAX) is called the destination operand, and the second operand is called the source operand. add eax,40000h The ADD instruction adds 40000h to the EAX register. sub eax,20000h The SUB instruction subtracts 20000h from the EAX register.

Moving Data into Registers The first thing we will want to learn about programming at the level of the CPU, is how to put data into registers. For this we use the MOV instruction. code fragment which moves the number 47 into the EDX register: >> MOV EDX, 47 The following code moves the hexadecimal number A4C9 into the 16 bit AX register: >> MOV AX, 0A4C9h Similarly, if we wished to move the binary number 01101110 into the 8 bit BH register we would type the following code: >> MOV BH, 01101110b

Starting with an Example TITLE Add and Subtract (AddSub.asm) ; Adds and subtracts three 32-bit integers ; (10000h + 40000h + 20000h) INCLUDE Irvine32.inc .code main PROC mov eax,10000h ; EAX = 10000h add eax,40000h ; EAX = 50000h sub eax,20000h ; EAX = 30000h call DumpRegs ; display registers exit main ENDP END main Title/header Include file Code section

Meanings of the Code Assembly code Machine code MOV EAX, 10000h B8 00010000 (Move 10000h into EAX) ADD EAX, 40000h 05 00040000 (Add 40000h to EAX) SUB EAX, 20000h 2D 00020000 (SUB 20000h from EAX) Operand in instruction 6

Fetched MOV EAX, 10000h Register Memory ALU B8 00010000 EAX EBX data … EBX data B8 00 01 MOV EAX, 10000h 00 00 05 00 ALU 04 ADD EAX, 40000h 00 00 SUB EAX, 20000h IR PC B8 00010000 0000011 … address 7

Execute MOV EAX, 10000h Register Memory ALU B8 00010000 EAX 00010000 … 00010000 EBX data B8 00 01 MOV EAX, 10000h 00 00 05 00 ALU 04 ADD EAX, 40000h 00 00 SUB EAX, 20000h IR PC B8 00010000 0000011 … address 8

Fetched ADD EAX, 40000h Register Memory ALU 05 00040000 EAX 00010000 … 00010000 EBX data B8 00 01 MOV EAX, 10000h 00 00 05 00 ALU 04 ADD EAX, 40000h 00 00 SUB EAX, 20000h IR PC 05 00040000 0001000 … address 9

Execute ADD EAX, 40000h Register Memory ALU 05 00040000 EAX 00050000 … 00050000 00010000 EBX data B8 00 01 MOV EAX, 10000h 00 00 05 00 ALU 04 ADD EAX, 40000h 00 00 SUB EAX, 20000h IR PC 05 00040000 0001000 … address 10

Chapter Overview Basic Elements of Assembly Language Integer constants and expressions Character and string constants Reserved words and identifiers Directives and instructions Labels Mnemonics and Operands Comments Example: Adding and Subtracting Integers Assembling, Linking, and Running Programs Defining Data Symbolic Constants Real-Address Mode Programming

Reserved Words, Directives TITLE Add and … ; Adds and subtracts ; (10000h + … INCLUDE Irvine32.inc .code main PROC mov eax,10000h add eax,40000h sub eax,20000h call DumpRegs exit main ENDP END main TITLE: Define program listing title Reserved word of directive Reserved words Instruction mnemonics, directives, type attributes, operators, predefined symbols See MASM reference in Appendix A Directives: Commands for assembler

Directive vs Instruction Directives: tell assembler what to do Commands that are recognized and acted upon by the assembler, e.g. declare code, data areas, select memory model, declare procedures, etc. Not part of the Intel instruction set Different assemblers have different directives Instructions: tell CPU what to do Assembled into machine code by assembler Executed at runtime by the CPU Member of the Intel IA-32 instruction set Format: LABEL (option), Mnemonic, Operands, Comment

Comments Single-line comments Multi-line comments TITLE Add and … ; Adds and subtracts ; (10000h + … INCLUDE Irvine32.inc .code main PROC mov eax,10000h add eax,40000h sub eax,20000h call DumpRegs exit main ENDP END main Single-line comments begin with semicolon (;) Multi-line comments begin with COMMENT directive and a programmer-chosen character, end with the same character, e.g. COMMENT ! Comment line 1 Comment line 2 !

Include Files INCLUDE directive: TITLE Add and … ; Adds and subtracts ; (10000h + … INCLUDE Irvine32.inc .code main PROC mov eax,10000h add eax,40000h sub eax,20000h call DumpRegs exit main ENDP END main INCLUDE directive: Copies necessary definitions and setup information from a text file named Irvine32.inc, located in the assembler’s INCLUDE directory (see Chapt 5)

Code Segment .code directive: TITLE Add and … ; Adds and subtracts ; (10000h + … INCLUDE Irvine32.inc .code main PROC mov eax,10000h add eax,40000h sub eax,20000h call DumpRegs exit main ENDP END main .code directive: Marks the beginning of the code segment, where all executable statements in a program are located

Procedure Definition TITLE Add and … ; Adds and subtracts ; (10000h + … INCLUDE Irvine32.inc .code main PROC mov eax,10000h add eax,40000h sub eax,20000h call DumpRegs exit main ENDP END main Procedure defined by: [label] PROC [label] ENDP Label: Place markers: marks the address (offset) of code and data Assigned a numeric address by assembler Follow identifier rules Data label: must be unique, e.g. myArray Code label: target of jump and loop instructions, e.g. L1:

Identifiers Identifiers: TITLE Add and … ; Adds and subtracts ; (10000h + … INCLUDE Irvine32.inc .code main PROC mov eax,10000h add eax,40000h sub eax,20000h call DumpRegs exit main ENDP END main Identifiers: A programmer-chosen name to identify a variable, a constant, a procedure, or a code label 1-247 characters, including digits not case sensitive first character must be a letter, _, @, ?, or $

Instructions Destination operand Source operand immediate values TITLE Add and … ; Adds and subtracts ; (10000h + … INCLUDE Irvine32.inc .code main PROC mov eax,10000h add eax,40000h sub eax,20000h call DumpRegs exit main ENDP END main [label:] mnemonic operand(s) [;comment] Instruction mnemonics: help to memorize examples: MOV, ADD, SUB, MUL, INC, DEC Operands: constant constant expression register memory (data label, register) Destination operand Source operand immediate values

Instruction Format Examples No operands stc ; set Carry flag nop ; no operation One operand inc eax ; register inc myByte ; memory Two operands add ebx,ecx ; register, register sub myByte,25 ; memory, constant add eax,36 * 25 ; register, constant-expr.

I/O Not easy, if program by ourselves Two steps: call DumpRegs: TITLE Add and … ; Adds and subtracts ; (10000h + … INCLUDE Irvine32.inc .code main PROC mov eax,10000h add eax,40000h sub eax,20000h call DumpRegs exit main ENDP END main Not easy, if program by ourselves Will use the library provided by the author Two steps: Include the library (Irvine32.inc) in your code Call the subroutines call DumpRegs: Calls the procedure to displays current values of processor registers

Remaining exit: END main: TITLE Add and … ; Adds and subtracts ; (10000h + … INCLUDE Irvine32.inc .code main PROC mov eax,10000h add eax,40000h sub eax,20000h call DumpRegs exit main ENDP END main exit: Halts the program Not a MSAM keyword, but a command defined in Irvine32.inc END main: Marks the last line of the program to be assembled Identifies the name of the program’s startup procedure

Example Program Output Program output, showing registers and flags EAX=00030000 EBX=7FFDF000 ECX=00000101 EDX=FFFFFFFF ESI=00000000 EDI=00000000 EBP=0012FFF0 ESP=0012FFC4 EIP=00401024 EFL=00000206 CF=0 SF=0 ZF=0 OF=0

What's Next Basic Elements of Assembly Language Example: Adding and Subtracting Integers Assembling, Linking, and Running Programs Defining Data Symbolic Constants Real-Address Mode Programming

Assemble-Link-Execute Cycle Steps from creating a source program through executing the compiled program http://kipirvine.com/asm/gettingStarted/index.htm

Download, Install, and Run MASM 6.15 (with all examples of textbook) Masm615.zip: download from the course web site Unzip the archive and run setup.exe Choose the installation directory Suggest using the default directory See index.htm in the archive for details Go to C:\Masm615 (if installed default) Write assembly source code TextPad, NotePad++, UltraEdit or … make32 abc (where abc is your file name) When assembled, just write abc to run the code.

Suggestion Study make32.bat and make16.bat To know where assembling stage and linking stage are Think about linking with other language (ex: C or C++ or …) Understand that MASM is only one of the assemblers, and there are still many other assemblers to use Try to use NASM or TASM Try to use high‐level compiler to generate assembly codes gcc or visual c++ or turbo c or …

Listing File Use it to see how your program is compiled Contains source code addresses object code (machine language) segment names symbols (variables, procedures, and constants) Example: addSub.lst

What's Next Basic Elements of Assembly Language Example: Adding and Subtracting Integers Assembling, Linking, and Running Programs Defining Data Intrinsic Data Types Data Definition Statement Defining BYTE, SBYTE, WORD, SWORD, DWORD, SDWORD, QWORD, TBYTE Defining Real Number Data Little Endian Order Symbolic Constants Real-Address Mode Programming

Intrinsic Data Types BYTE 8-bit unsigned integer SBYTE 8-bit signed integer WORD 16-bit unsigned integer SWORD 16-bit signed integer DWORD 32-bit unsigned integer SDWORD 32-bit signed integer

Data Definition Statement A data definition statement sets aside storage in memory for a variable May optionally assign a name (label) to the data Syntax: [name] directive initializer [,initializer] . . . value1 BYTE 10 All initializers become binary data in memory Use ? if no initialization necessary Example: Var1 BYTE ?

Defining BYTE and SBYTE Data Each of following defines a single byte of storage: value1 BYTE 'A' ; character constant value2 BYTE 0 ; smallest unsigned byte value3 BYTE 255 ; largest unsigned byte value4 SBYTE -128 ; smallest signed byte value5 SBYTE +127 ; largest signed byte value6 BYTE ? ; uninitialized byte

Defining Byte Arrays list1 BYTE 10,20,30,40 list2 BYTE 10,20,30,40 Examples that use multiple initializers: list1 BYTE 10,20,30,40 list2 BYTE 10,20,30,40 BYTE 50,60,70,80 BYTE 81,82,83,84 list3 BYTE ?,32,41h,00100010b list4 BYTE 0Ah,20h,‘A’,22h

Defining Strings An array of characters str1 BYTE "Enter your name",0 Usually enclosed in quotation marks Will often be null-terminated To continue a single string across multiple lines, end each line with a comma str1 BYTE "Enter your name",0 str2 BYTE 'Error: halting program',0 str3 BYTE 'A','E','I','O','U' greeting BYTE "Welcome to the Encryption Demo program " BYTE "created at Tabuk University.",0 menu BYTE "Checking Account",0dh,0ah,0dh,0ah, "1. Create a new account",0dh,0ah, "2. Open an existing account",0dh,0ah, "Choice> ",0 End-of-line sequence: 0Dh = carriage return 0Ah = line feed

Using the DUP Operator Use DUP to allocate (create space for) an array or string Syntax: counter DUP (argument) Counter and argument must be constants or constant expressions var1 BYTE 20 DUP(0) ; 20 bytes, all equal to zero var2 BYTE 20 DUP(?) ; 20 bytes, uninitialized var3 BYTE 4 DUP("STACK"); 20 bytes, ; "STACKSTACKSTACKSTACK"

Defining WORD and SWORD Define storage for 16-bit integers or double characters single value or multiple values word1 WORD 65535 ; largest unsigned value word2 SWORD –32768 ; smallest signed value word3 WORD ? ; uninitialized, unsigned word4 WORD "AB" ; double characters myList WORD 1,2,3,4,5 ; array of words array WORD 5 DUP(?) ; uninitialized array

Defining Other Types of Data Storage definitions for 32-bit integers, quadwords, tenbyte values, and real numbers: val1 DWORD 12345678h ; unsigned val2 SDWORD –2147483648 ; signed val3 DWORD 20 DUP(?) ; unsigned array val4 SDWORD –3,–2,–1,0,1 ; signed array

Adding Variables to AddSub TITLE Add and Subtract, Version 2 (AddSub2.asm) ; This program adds and subtracts 32-bit unsigned ; integers and stores the sum in a variable. INCLUDE Irvine32.inc .data val1 DWORD 10000h val2 DWORD 40000h val3 DWORD 20000h finalVal DWORD ? .code main PROC mov eax,val1 ; start with 10000h add eax,val2 ; add 40000h sub eax,val3 ; subtract 20000h mov finalVal,eax ; store the result (30000h) call DumpRegs ; display the registers exit main ENDP END main