machine language - 3f03 alan wassyng itb 166 [email protected] january - april 2006

Machine Language - 3F03

Alan Wassyng

ITB 166

[email protected]

January - April 2006

2

3F03 - Overview

• Before we start, let’s refresh our knowledge of C. Consider how we could solve the following problem in C: We have an analog I/O hardware module

that provides 12-bit analog input and output capability for 8 inputs and 8 outputs on a PC.

Construct a C routine to read any one of the analog inputs - 0..7

int GetAI(int IOpoint);

3

3F03 - Overview

• How the analog board works Set the IO channel using the IOpoint Set the control register according to the IO

channel LSB Read the value at the data register - that

value is the LSB of the analog input Set the control register according to the IO

channel MSB Read the value at the data register - that

value is the MSB of the analog input

4

3F03 - Overview

• Definitions Base address = 0100h Control register address = Base address+1

Data register address = Base address LSB of IO channel = IOpoint*2 MSB of IO channel = IOpoint*2+1

5

3F03 - Overview

• Required StepsSo, create OutPort(p, val) that sets the value of hardware port p, to val, and create InPort(p) that reads the value of port p. Then the following sequence reads the analog input value of IOpoint (IOpoint = 0,1,2,3,4,5,6,7. p and val are 16-bit).

OutPort(Control register, LSB of IO channel)

ValueLSB = InPort(Data register)

OutPort(Control register, MSB of IO channel)

ValueMSB = InPort(Data register)

Value = ValueMSB*256+ValueLSB

6

3F03 - Overview

• You have 10 minutes to rough-out a solution, i.e C code for OutPort, InPort and GetAI. Do it in groups of 3 or 4.

7

int GetAI(int IOpoint);

void OutPort(int p, int val);

int InPort(int p);

OutPort(Control register, LSB of IO channel)

ValueLSB = InPort(Data register)

OutPort(Control register, MSB of IO channel)

ValueMSB = InPort(Data register)

Value = ValueMSB*256+ValueLSB

• Base address = 0100h

• Control register address = Base address+1 • Data register address = Base address• LSB of IO channel = IOpoint*2• MSB of IO channel = IOpoint*2+1

3F03 - Overview

least significant byte

8

3F03 - Overview

• So, what did you find? It is not obvious as to how to access the

hardware from within a standard C program.

• High-level languages were developed to enable programmers to work at a higher level of abstraction without concerning themselves too much about the hardware - but it is sometimes necessary to “sink” to the hardware level.

9

3F03 - Overview

• Course Rules TAs

• Yazhi Wang - [email protected]• Ryan Lortie - [email protected]

Assignments• 4 assignments - 16% of total grade*• Exams - open book• Mid Term - 30% of total grade*• Final Exam - 54% of total grade*

* assuming a final exam grade of 50%. If the final exam grade is < 50% it will be used as the total grade for the course.

10

3F03 - Overview

• Course Rules Lectures Tue,Wed,Fri 9:30 ABB 271 Tutorial Thur 9:30 ITB 237

http://www.cas.mcmaster.ca/~se3f03/

11

3F03 - Overview

• Course Rules Assignments & Exams

• Do - explain what you have done and what you have assumed

• Do - keep to the topic• Do - support your arguments with direct

reference to code extracts where necessary• Don’t - assume the reader knows more than

you do• Don’t - pad your answers with incorrect facts!• SHORT IS BETTER THAN WRONG

12

3F03 - Overview

• Course Objectives Machine level programming concepts. The role of assembler programming in the

current software industry. How the concepts of assembler

programming can help you even though you, personally, program all the time in a high-level language.

13

3F03 - Overview

Table of ContentsAssembler basicsComputer arithmetic, binary, octal, hex80x86 assembler through example

problems - Debug & NASMBIOS and Operating SystemsSimple data structures in assemblerUnderstanding compiler outputInline assemblerInterfacing to high-level languagesMIPS - Using SPIMCISC versus RISC hardware

132022

75112146190201204216

Page

14

3F03 - Assembler Basics

• Machine Language A typical processor

RegistersArithmetic & Logic

Control

Data Path

Registers are simply fast memory locations. Some may have specific roles to play, while others may be more general.

15


• Word size The word size of a processor is the largest

number of bits it works with as a unit. The original Intel 8088/8086 has a 16-bit

word size. The registers are 16 bits and the 8086 works with 16 bit words in memory. The 8088 has an 8-bit data bus.

The Intel Pentium chips have a 32-bit word size.

Later we’ll see how Intel retains backward compatibility in its processors.

16


• Machine Instructions Each processor has its own unique set of

registers and instructions. Examples:

10110100 00001001 moves 09 into highbyte of reg AX

01000011 increment reg BXby 1

Note the difference in these instructions. The first one required 2 bytes, the second only 1 byte. (They also require a different number of clock cycles.)

17


• Assembler Converts easier to read/create mnemonics

and operands to machine language. One-to-one correspondence between

assembler statements and machine instructions - usually, since sometimes an assembler statement is an instruction to the assembler program itself.

Assemblers are often augmented by macro extensions.

18


• 80x86 assembler (Intel notation) General structure

label mnemonic operand(s) comment

SET: MOV AX,BX ;move BX into AX dest,source

ADD AX,BX ;add BX to AX and

;store in AX

19


• 80x86 Layout

8 bits16 bits32 bits

EAX

EBX

ECX

EDX

ESIEDIESPEBP

AH AL

BH BL

CH

DH DL

CL

CSDSSSES

FSGS

20


• 80x86 “Special” Registers IP - The instruction pointer

• points to next instruction to be exceuted

FLAGS (EFLAGS in 80386 and higher)• OF - overflow• DF - direction (strings in memory)• IF - interrupt• TF - trap• SF - sign• ZF - zero• AF - auxiliary carry (for BCD arithmetic)• PF - parity• CF - carry

21

3F03 - Computer arithmetic, binary, octal, hex

• Integers Be specific about size (number of bits) and

signage (signed or unsigned). Typical 16-bit signed integers:

• Stored in 2’s complement format• Bit 15 (msb): 1 negative, 0 positive• -32768 integer 32767• 1000000000000000 i 0111111111111111• 8000 i 7FFF

Unsigned integers• 0 integer 65535• 0 integer FFFF

22

3F03 - Computer arithmetic, binary, octal, hex

• Octal DEC used octal for its very successful mini-

computers - PDP and VAX. Not used much in current architectures.

• Hex Almost everything we do in the assembler

will be in Hex. Get familiar with it! Each hex digit represents a nybble

0 - F represents 0000 - 1111

23

3F03 - 80x86 assembler

• Addresses Addresses in the 8088, 8086, 80286 world

are written in the form• segment:offset• segments start on 16 byte boundaries - the first

at 0000, the second at 0010, etc. We specify the number of the segment, 0000, 0001 etc.

• offset is a 16 bit address that represents an offset from the start of the specified segment.

Addresses in the 80386 (and later) world can mimic the earlier, restricted addresses, or can be represented by a “flat” model so that segments are not necessary.

24


• Addresses Consider the address 0001:0032

0000

0001

0002

Segment 0

Segment 1

Segment 2

0001:0032 = 0000:0042 = 0002:0022

25


• Open a DOS window and run Debug.

26


• A few Debug commands-a assemble following statements

end by blank statement

-u unassemble

-u addr unassemble from addr(ess)

-t trace, execute next statement

and show registers

-r show registers

-? get list of commands

-q quit

27


• Debug examples

28


ADD - Arithmetic Addition

Usage: ADD dest,src Modifies flags: AF CF OF PF SF ZF

Adds "src" to "dest" and replacing the original contents of "dest". Both operands are binary.

Clocks SizeOperands 808x 286 386 486 Bytes

reg,reg 3 2 2 1 2mem,reg 16+EA 7 7 3 2-4 (W88=24+EA)reg,mem 9+EA 7 6 2 2-4 (W88=13+EA)reg,immed 4 3 2 1 3-4mem,immed 17+EA 7 7 3 3-6 (W88=23+EA)accum,immed 4 3 2 1 2-3

29


INC - Increment

Usage: INC dest

Modifies flags: AF OF PF SF ZF

Adds one to destination unsigned binary operand.

Clocks Size

Operands 808x 286 386 486 Bytes

reg8 3 2 2 1 2

reg16 3 2 2 1 1

reg32 3 2 2 1 1

mem 15+EA 7 6 3 2-4 (W88=23+EA)

30


What happens if we add 12F2 +220F

------ 3501

What if we work with 8 bits at a time?Will this work? mov al, F2

mov ah, 12mov bl, 0Fmov bh, 22add al, bladd ah, bh

31


ADC - Add With Carry

Usage: ADC dest,src

Modifies flags: AF CF OF SF PF ZF

Sums two binary operands placing the result in the destination. If CF is set, a 1 is added to the destination.

Clocks Size

Operands 808x 286 386 486 Bytes

reg,reg 3 2 2 1 2

mem,reg 16+EA 7 7 3 2-4 (W88=24+EA)

reg,mem 9+EA 7 6 2 2-4 (W88=13+EA)

reg,immed 4 3 2 1 3-4

mem,immed 17+EA 7 7 3 3-6 (W88=23+EA)

accum,immed 4 3 2 1 2-3

32


If we use ADC rather than ADD everything works just fine.

mov al, F2mov ah, 12mov bl, 0Fmov bh, 22add al, bladc ah, bh

33


• URL for Intel 80x86 Instructions

http://www.penguin.cz/~literakl/intel/intel.html

34


• Some registers have special roles The names of the general registers were

chosen to reflect the specific roles they can play:

• AX - accumulator (brief history)

• BX - base register

• CX - counter register

• DX - data register

35


• Loop example - in Debug1478:0100 MOV AX,0

1478:0103 MOV CX,5

1478:0106 INC AX

1478:0107 LOOP 0106

36


• Loop example - in Debug1478:0100 MOV AX,0

1478:0103 MOV CX,5

1478:0106 INC AX

1478:0107 LOOP 0106

counter

37


• LOOP - Decrement CX and Loop if CX Not Zero Usage: LOOP label Modifies Flags: None Decrements CX by 1 and transfers control to

"label" if CX is not Zero. The "label" operand must be within -128 or 127 bytes of the instruction following the loop instruction

38


• Loop example - in AssemblerMOV AX,0

MOV CX,5

LBL: INC AX

LOOP LBL

39


• Loop example - in AssemblerMOV AX,0

MOV CX,5

LBL: INC AX

LOOP LBL

40


• Loop example - source file Create file TestLoop.asm in editor

[BITS 16] ; Set 16 bit code

[ORG 0x0100] ; Set code start

[SECTION .text] ; Code segment

mov ax, 0000

mov cx, 0005

LBL: inc ax

loop LBL

mov ax, $4C00 ; Prepare to exit

int $21 ; Terminate prog

41


• Loop example - assemble source Assemble and link file using NASM

NASM TestLoop.asm -o TestLoop.com

Assemble, link & make listing fileNASM TestLoop.asm -l TestLoop.txt -o TestLoop.com

42


• Loop example - TestLoop.txt 1 [BITS 16] ; Set 16 bit code

2 [ORG 0x0100] ; Set code start

3

4 [SECTION .text] ; Code segment

5

6 00000000 B80000 mov ax, 0000

7 00000003 B90500 mov cx, 0005

8 00000006 40 LBL: inc ax

9 00000007 E2FD loop LBL

10

11 00000009 B8004C mov ax, $4C00 ; Prepare to exit

12 0000000C CD21 int $21 ; Terminate prog

43


• Loop example - TestLoop.txt 1 [BITS 16] ; Set 16 bit code

2 [ORG 0x0100] ; Set code start

3

4 [SECTION .text] ; Code segment

5

6 00000000 B80000 mov ax, 0000

7 00000003 B90500 mov cx, 0005

8 00000006 40 LBL: inc ax

9 00000007 E2FD loop LBL

10

11 00000009 B8004C mov ax, $4C00 ; Prepare to exit

12 0000000C CD21 int $21 ; Terminate prog

How is this number calculated?

44


• Loop, with CMP and Jxx - in Debug1478:0100 MOV AX,0

1478:0103 MOV CX,5

1478:0106 INC AX

1478:0107 DEC CX

1478:0108 CMP CX,0

1478:010B JNZ 0106

45


• CMP - Compare Usage: CMP dest,src Modifies Flags: AF CF OF PF SF ZF Subtracts source from destination and

updates the flags but does not save result. Flags can subsequently be checked for conditions.

46


• JXX - Jump Instructions Table

Mnm Meaning Jump Condition

JA Jump if Above CF=0 & ZF=0

JAE Jump if Above or Equal CF=0

JB Jump if Below CF=1

… … ...

47


• Loop, with CMP and Jxx - in Debug1478:0100 MOV AX,0

1478:0103 MOV CX,5

1478:0106 INC AX

1478:0107 DEC CX

1478:0108 JNZ 0106

48


• Typical addressing modes labelopcode operands

An operand can be a:• register - the value contained in a register• immediate - a constant in the instruction• absolute - a memory location in the instruction• register indirect - a memory location whose

address is in a register• displacement - a memory location offset from an

address in a register• indexed - a memory location whose address is

the sum of values in two registers• memory indirect - the address is in a memory

location whose address is in a register

49


• Typical addressing modes Register and immediate modes we have already

seen

MOV AX,1

MOV BX,AX

register immediate

50


• Typical addressing modes Absolute address mode

MOV AX,[0200]

value stored in memory location DS:0200

51


• Typical addressing modes Register indirect

MOV AX,[BX]

value stored at address contained in DS:BX

52


• Typical addressing modes Displacement

MOV DI,4

MOV AX,[0200+DI]

value stored at DS:0204

53


• Typical addressing modes Indexed

MOV BX,0200

MOV DI,4

MOV AX,[BX+DI]

value stored at DS:0204

54


• Typical addressing modes Memory indirect

MOV DI,0204

MOV BX,[DI]

MOV AX,[BX]

If DS:0204 contains 0256,

then AX will contain

whatever is stored at

DS:0256

55


• Typical addressing modes Memory indirect

MOV DI,0204

MOV BX,[DI]

MOV AX,[BX]

If DS:0204 contains 0256,

then AX will contain

whatever is stored at

DS:0256

Byte addresses in memory

0200 0204

0250 0256

0256

1234

DI

BX

AX = 1234

56


• 80x86 Restrictions MOV cannot move memory to memory

MOV AX,[0200] Use this insteadMOV [0210],AX

MOV cannot move a segment register into another segment register.

MOV cannot move immediate data into a segment register.

Mov cannot move an 8-bit register half into a 16-bit register.

In real mode, only BP, BX, SI and DI can hold an offset for memory data.

57


• Complications arising from memory access instructions Consider NEG [BX]

• [BX] is a reference to data stored at the address DS:BX. How big is that data?

• How would we reference just a byte?• Use a type specifier! In Debug and MASM these

are of the form BYTE PTR, WORD PTR etc. In NASM we simply use BYTE, WORD, etc.

e.g. NEG BYTE [BX]

58


• Text strings in assembler Define the string (or a place holder) in the

data segment - actually we define the address at which the string starts as well as the characters in the string.

Move the starting address of the string into a register, and go from there ….

59


; TextEx.asm


[ORG 0100H] ; Set code start address to 100h (COM file)

[SECTION .text] ; Code Section

START:

mov dx, msg ; Loads ADDRESS of msg into dx

mov ah,9 ; DOS Fn 9 displays text pointed to by dx

; to standard output.

int 21H ; INT 21H - DOS interrupt.

mov ax, 04C00H ; This DOS function exits the program

int 21H ; and returns control to DOS.

[SECTION .data] ; Section containing initialised data

; Now store the text string ending it with CR, LF and "S"

msg db "Hello world", 13, 10, "$"

60


; TextEx2.asm


[ORG 0100H] ; Set code start address to 100h (COM file)


START:

mov dx, msg ; Loads ADDRESS of msg into dx

mov ah,9 ; DOS Fn 9 displays text pointed to by dx

; to standard output.

int 21H ; INT 21H - DOS interrupt.

mov ax, 04C00H ; This DOS function exits the program

int 21H ; and returns control to DOS.

[SECTION .data] ; Section containing initialised data

; Now store the text string ending it with CR, LF and "S"

msg db "Hello world", 0DH, 0AH, "$"

61


; TextEx3.asm

[BITS 16] ; Set 16 bit code[ORG 0100H] ; Set code start address to 100h (COM file)[SECTION .text] ; Code SectionSTART: mov si, msg ; Loads ADDRESS of msg into si mov di, msg2 ; Loads ADDRESS of msg2 ino diCOPY: mov ah, BYTE [si] ; move contents of si into ah mov BYTE [di],ah ; move ah into contents of di inc di ; point to next char in destination inc si ; point to next char in source cmp ah,"$" ; test if end of string jne COPY ; if not end of string, do more chars mov dx,msg ; Loads address of msg into dx mov ah,9 ; DOS Fn 9 displays text pointed to by dx ; to standard output. int 21H ; INT 21H - DOS interrupt. mov dx,msg2 ; Loads address of msg2 into dx mov ah,9 ; DOS Fn 9 int 21H mov ax, 04C00H ; This DOS function exits the program int 21H ; and returns control to DOS.[SECTION .data] ; Section containing initialised data; Now store the text string ending it with CR, LF and "S"msg db "Hello world", 0DH, 0AH, "$"

msg2 times 80 db "$"

62


; TextEx4.asm

[BITS 16] ; Set 16 bit code[ORG 0100H] ; Set code start address to 100h (COM file)[SECTION .text] ; Code SectionSTART: mov si, msg ; Loads ADDRESS of msg into si mov di, msg2 ; Loads ADDRESS of msg2 ino diCOPY: mov ah, BYTE [si] ; move contents of si into ah cmp ah,"a" ; if char < "a" jl NOCHNG ; then jump to NOCHNG cmp ah,"z" ; if char > "z" jg NOCHNG ; then jump to NOCHNG sub ah,"a"-"A" ; if lower case, subtract "a"-"A"NOCHNG: mov BYTE [di],ah ; move ah into contents of di inc di ; point to next char in destination inc si ; point to next char in source cmp ah,"$" ; test if end of string jne COPY ; if not end of string, do more chars mov dx,msg ; Loads address of msg into dx mov ah,9 ; DOS Fn 9 displays text pointed to by dx ; to standard output. int 21H ; INT 21H - DOS interrupt. mov dx,msg2 ; Loads address of msg2 into dx mov ah,9 ; DOS Fn 9 int 21H mov ax, 04C00H ; This DOS function exits the program int 21H ; and returns control to DOS.[SECTION .data] ; Section containing initialised data; Now store the text string ending it with CR, LF and "S"msg db "Hello world", 0DH, 0AH, "$"

msg2 times 80 db "$"

63

3F03 - 80x86 assembler; TextEx5.asm[BITS 16] ; Set 16 bit code[ORG 0100H] ; Set code start address to 100h (COM file); Set constantsCR equ 0DHLF equ 0AHEOS equ "$"[SECTION .text] ; Code SectionSTART: mov si, msg ; Loads ADDRESS of msg into si mov di, msg2 ; Loads ADDRESS of msg2 ino diCOPY: mov ah, BYTE [si] ; move contents of si into ah cmp ah,"a" ; if char < "a" jl NOCHNG ; then jump to NOCHNG cmp ah,"z" ; if char > "z" jg NOCHNG ; then jump to NOCHNG sub ah,"a"-"A" ; if lower case, subtract "a"-"A"NOCHNG: mov BYTE [di],ah ; move ah into contents of di inc di ; point to next char in destination inc si ; point to next char in source cmp ah,"$" ; test if end of string jne COPY ; if not end of string, do more chars mov dx,msg ; Loads address of msg into dx mov ah,9 ; DOS Fn 9 displays text pointed to by dx ; to standard output. int 21H ; INT 21H - DOS interrupt. mov dx,msg2 ; Loads address of msg2 into dx mov ah,9 ; DOS Fn 9 int 21H mov ax, 04C00H ; This DOS function exits the program int 21H ; and returns control to DOS.[SECTION .data] ; Section containing initialised data; Now store the text string ending it with CR, LF and "S"msg db "Hello world", CR, LF, EOSmsg2 times 80 db EOS

64


; TextEx6.asm[BITS 16] ; Set 16 bit code[ORG 0100H] ; Set code start address to 100h (COM file); Set constantsCR equ 0DHLF equ 0AHEOS equ "$"[SECTION .text] ; Code SectionSTART: mov cx,msglen ; move length of msg into cx mov si, msg ; Loads ADDRESS of msg into si mov di, msg2 ; Loads ADDRESS of msg2 ino diCOPY: mov ah, BYTE [si] ; move contents of si into ah cmp ah,"a" ; if char < "a" jl NOCHNG ; then jump to NOCHNG cmp ah,"z" ; if char > "z" jg NOCHNG ; then jump to NOCHNG sub ah,"a"-"A" ; if lower case, subtract "a"-"A"NOCHNG: mov BYTE [di],ah ; move ah into contents of di inc di ; point to next char in destination inc si ; point to next char in source loop COPY ; do more chars until all chars in msg done mov dx,msg ; Loads address of msg into dx mov ah,9 ; DOS Fn 9 displays text pointed to by dx ; to standard output. int 21H ; INT 21H - DOS interrupt. mov dx,msg2 ; Loads address of msg2 into dx mov ah,9 ; DOS Fn 9 int 21H mov ax, 04C00H ; This DOS function exits the program int 21H ; and returns control to DOS.[SECTION .data] ; Section containing initialised data; Now store the text string ending it with CR, LF and "S"msg db "Hello world", CR, LF, EOSmsglen db $-msg

msg2 times 80 db EOS

65


; TextEx6f.asm[BITS 16] ; Set 16 bit code[ORG 0100H] ; Set code start address to 100h (COM file); Set constantsCR equ 0DHLF equ 0AHEOS equ "$"[SECTION .text] ; Code SectionSTART: mov cx, 0 ; zero cx mov cl,[msglen] ; move length of msg into cl mov si, msg ; Loads ADDRESS of msg into si mov di, msg2 ; Loads ADDRESS of msg2 ino diCOPY: mov ah, BYTE [si] ; move contents of si into ah cmp ah,"a" ; if char < "a" jl NOCHNG ; then jump to NOCHNG cmp ah,"z" ; if char > "z" jg NOCHNG ; then jump to NOCHNG sub ah,"a"-"A" ; if lower case, subtract "a"-"A"NOCHNG: mov BYTE [di],ah ; move ah into contents of di inc di ; point to next char in destination inc si ; point to next char in source loop COPY ; do more chars until all chars in msg done mov dx,msg ; Loads address of msg into dx mov ah,9 ; DOS Fn 9 displays text pointed to by dx ; to standard output. int 21H ; INT 21H - DOS interrupt. mov dx,msg2 ; Loads address of msg2 into dx mov ah,9 ; DOS Fn 9 int 21H mov ax, 04C00H ; This DOS function exits the program int 21H ; and returns control to DOS.[SECTION .data] ; Section containing initialised data; Now store the text string ending it with CR, LF and "S"msg db "Hello world", CR, LF, EOSmsglen db $-msg

msg2 times 80 db EOS

66


• Recap The processor understands binary

instructions (32-bit, 16-bit etc) and works with binary data.

The basic building blocks are registers which are just special memory locations within the processor.

We write programs in Assembler, which is a notation that gets translated (by software) into machine language.

67


• Assembler The principal tasks performed by an

assembler:• Replace opcodes and operands by their

machine level equivalents.• Replace symbolic names by relocatable

addresses.

68


• Linking Why do we need a “linker”? What does it do?

• In general, the assembler produces a “relocatable” object file - a file containing the machine instructions translated from the assembler source code, including “unresolved external symbols”.

• The linker combines all the listed object files, resolves all external references, and constructs an executable file that is ready to be “loaded” and executed.

• The loader has the task of installing the executable file at the correct starting location immediately prior to being invoked.

69


• Relocatable object file - opcodes plus: Import table

• Named locations that are unknown but assumed to be defined in files that will be linked with this one.

Relocation table• Locations within the current file that must be

modified at link time to take into account the offset of the current file within the final exectable program.

Export table• Named locations in the current file that may be

referred to in other relocatable object files.

70


• Complications in linking Relocation typically involves not only

modifying addresses simply by taking into account the offset of the particular file, but may also combine code segments into a single code segment, and data segments into a single data segment, etc.

71


• NASM The Net-wide Assembler is an open source

initiative and is available (free) for a variety of operating systems - DOS, Windows & Linux.

The author(s) tried to make it more explicit and consistent with respect to the way in which it treats memory references than is MASM.

It is capable of producing .COM .OBJ and .EXE files.

72


• NASM NASM is therefore both an assembler and

a linker. In general, we usually use two separate

programs to perform these functions. We can do that now as well. NASM will be used as an assembler, and unless the linking is trivial (a .COM file, or a single source file), we would use a linker such as ALINK to link the required .OBJ files.

73


• Example of an EXE file; TestExe.asmsegment code PUBLIC

Indicate to the linker where execution should start..start:

mov ax,data mov ds,ax Set up data segment mov ax,stack mov ss,ax Set up stack segment mov sp,stacktop Set up stack pointer at top of stack

mov ax,0000 mov cx,0005LBL: inc ax loop LBL

mov ax, $4C00 ; Prepare to exit int 0x21 ; Terminate prog

segment data PUBLIC

segment stack stack resb 64stacktop:

74


NASM TestExe.asm -fobj -o TestExe.obj

Alink TestExe.obj -oEXE -o TestExe.exe

Execute: TestExe

Examine TestExe.exe using Debug

75


; TestExe2.asmsegment code PUBLIC

..start:

mov ax,data mov ds,ax mov ax,stack mov ss,ax mov sp,stacktop

mov cx,0005LBL: mov dx,msg mov ah,09 Display text each time through loop int 0x21 loop LBL


segment data PUBLICmsg db "This is just an example",CR,LF,EOSCR equ 0x0DLF equ 0x0AEOS equ "$"


76


; TestExe3.asmsegment code PUBLIC

..start:

mov ax,data mov ds,ax mov ax,stack mov ss,ax mov sp,stacktop

mov cx,0005 mov dx,msg mov ah,09 Safe?LBL: int 0x21 loop LBL


segment data PUBLICmsg db "This is just an example",CR,LF,EOSCR equ 0x0DLF equ 0x0AEOS equ "$"


77


• BIOS, OS and Device Drivers Basic Input-Output System provides low

level routines that interface to the hardware through software interrupts.

Typically, the OS includes routines that build on the BIOS level interface to provide users with even more capability than does the BIOS.

Devices that were not included in the BIOS have to be serviced by Device Drivers. These provide input-output services for the particular device.

78


Device Drivers

Hardware

BIOSDD1

DD2

App 1 App 2 App 3

Operating System

VideoKeyboardOther Hardware

79


• Example - Graphics through BIOS Set video modes (INT 10h, Fn 0)

• AH = 0, AL = video mode• Typical video modes

2 80 x 25 2 colours text

3 80 x 25 16 colourstext

0Dh 320 x 200 16 colours graphics 12h 640 x 480 16 colours graphics 13h 320 x 200 256 colours graphics 6Ah 800 x 600 16 colours graphics

• Coordinates 0,0 top left Xmax,Ymax bottom right

80


Get video mode info (INT 10h, Fn 0Fh)• AH = 0Fh• Returns:

AL = current display mode AH = number of columns (characters or pixels) BH = active video page

81


Write graphics pixel (INT 10h, Fn 0Ch)• AH = 0, AL = pixel value (0 to max colours - 1)• BH = video page• CX = x-coordinate• DX = y-coordinate

• If bit 7 in AL is set (=1), the new pixel will be XORed with the current contents of the pixel.

This allows us to erase pixels.

82


• Draw a horizontal line from (100,150) to

(250,150) Set graphics mode For x = 100 to 250

• Set pixel colour• Set pixel

Wait for a key press Exit program

83


; DrawLn1.asm[BITS 16] ; Set 16 bit code[ORG 0100H] ; Set code start address to 100h (COM file)[SECTION .text] ; Code SectionSTART: mov ah,0FH ; Get video info int 10H mov [savemode],al ; Save the current video mode mov ah,0 mov al,0DH int 10H ; switch to graphics 320 x 200, 16 colours; Now draw line: CX - x, DX - y, AL - colour, BH - video page mov cx,99 mov bh,0 mov dx,150 mov ah,0CHLine: inc cx int 10H cmp cx,250 jl Line ; Repeat until cx > 250

mov ah,0 ; Wait for keypress int 16H

mov ah,0 ; Replace original video mode mov al,[savemode] int 10H

mov ax, 04C00H ; This DOS function exits the program int 21H ; and returns control to DOS.[SECTION .data] ; Section containing initialised datasavemode db 0

84


; DrawLn2.asmSTART: mov ah,0FH ; Get video info int 10H mov [savemode],al ; Save the current video mode mov ah,0 mov al,0DH int 10H ; switch to graphics 320 x 200, 16 colours mov ah,0 ; Wait for keypress int 16H; Now draw line: CX - x, DX - y, AL - colour, BH - video page mov bh,0 mov ah,0CH mov dx,191Yloop: dec dx mov cx,9Line: inc cx int 10H cmp cx,310 ; Do new x until x > 310 jl Line cmp dx,10 ; Do new Y until Y < 10 jg Yloop mov ah,0 ; Wait for keypress int 16H mov ah,0 ; Replace original video mode mov al,[savemode] int 10H mov ax, 04C00H ; This DOS function exits the program int 21H ; and returns control to DOS.[SECTION .data] ; Section containing initialised datasavemode db 0

x

y

85

3F03 - 80x86 assembler; DrawLn3.asmSTART: mov ah,0FH ; Get video info int 10H mov [savemode],al ; Save the current video mode mov ah,0 mov al,0DH int 10H ; switch to graphics 320 x 200, 16 colours mov ah,0 int 16H; Now draw line: CX - x, DX - y, AL - colour, BH - video page mov bh,0 mov ah,0CH mov dx,191Yloop: dec dx mov cx,9 mov al,3Line: inc cx int 10H cmp cx,310 jl Line cmp dx,10 jg Yloop mov ah,0 int 16H mov ah,0 mov al,[savemode] int 10H mov ax, 04C00H ; This DOS function exits the program int 21H ; and returns control to DOS.[SECTION .data] ; Section containing initialised datasavemode db 0

Pixel colour

86


; DrawLn4.asm.. .. .. .. ; Now draw line: CX - x, DX - y, AL - colour, BH - video page mov bh,0 mov ah,0CH mov dx,191Yloop: dec dx mov cx,9 xor al,al Zero ALLine: inc al Next colour cmp al,15 jl NoReset xor al,al Zero AL if colour > 15 - starts from 0 againNoReset: inc cx int 10H cmp cx,310 jl Line cmp dx,10 jg Yloop mov ah,0 int 16H mov ah,0 mov al,[savemode] int 10H mov ax, 04C00H ; This DOS function exits the program int 21H ; and returns control to DOS.[SECTION .data] ; Section containing initialised datasavemode db 0

87


; DrawLn5.asm.. .. .. .. ; Now draw line: CX - x, DX - y, AL - colour, BH - video page mov bh,0 mov ah,0CH mov dx,191Yloop: dec dx mov cx,9 xor al,al Zero ALLine: inc al Next colour inc cx int 10H cmp cx,310 jl Line

cmp dx,10 jg Yloop

mov ah,0 int 16H

mov ah,0 mov al,[savemode] int 10H

mov ax, 04C00H ; This DOS function exits the program int 21H ; and returns control to DOS.[SECTION .data] ; Section containing initialised datasavemode db 0

88


• Memory-Mapped Graphics Mode 13H - 320 x 200 256 colours Two-dimensional array of bytes Each byte describes a single pixel at x,y

• The bytes for each row (y) are contiguous

The video colour palette is at port 3C8H The RGB entries are sent to port 3C9H Video buffer starts at A000H

89


• Memory-Mapped Graphics0,0 1,0 2,0 3,0 4,0 5,0 6,0 7,0 8,0 9,0

0,1 1,1 2,1 3,1 4,1 5,1 6,1 7,1 8,1 9,1

0,2 1,2 2,2 3,2 4,2 5,2 6,2 7,2 8,2 9,2

0,3 1,3 2,3 3,3 4,3 5,3 6,3 7,3 8,3 9,3

0,4 1,4 2,4 3,4 4,4 5,4 6,4 7,4 8,4 9,4

0,0 1,0 2,0 3,0 4,0 5,0 6,0 7,0 8,0 9,0 0,1 1,1

0 1 2 3 4 5 6 7 8 9 10 11

2,1 3,1 4,1 5,1 6,1 7,1 8,1 9,1 0,2 1,2 2,2 3,2

12 13 14 15 16 17 18 19 20 21 22 23

4,2 5,2 6,2 7,2 8,2 9,2 0,3 1,3 2,3 3,3 4,3 5,3

24 25 26 27 28 29 30 31 32 33 34 35

6,3 7,3 8,3 9,3 0,4 1,4 2,4 3,4 4,4 5,4 6,4 7,4

36 37 38 39 40 41 42 43 44 45 46 47

8,4 9,4

48 49

10 x 5 pixelsConvert pixel location to bytenumber in video segment.Given x,y: byte number is y*10 + x

Start of video segment

90


; MemMap1.asm

segment code

..start:

mov ax,data Have to do it as an EXE program

mov ds,ax since we need access to memory

mov ax,stack outside the limits of a COM program

mov ss,ax

mov sp,stacktop

; store original video mode

mov ah,0Fh

int 10H

mov [savemode],al

; change video mode to 13H

mov ah,0

mov al,13H

int 10H

; wait for keypress

mov ah,0

int 16H

; set es to point to video buffer

mov ax,0A000H

mov es,ax

91


; draw pixel at cx,bx

mov bx,191

Yloop:

dec bx

mov ax,bx

mov dx,320

mul dx ; multiply ax by 320 for each y

mov di,ax ; put start byte for each row in di

mov cx,9 ; x value

xor al,al ; colour value in current palette

add di,cx ; include x in start address

Line:

inc al ; next colour

inc cx ; next pixel

inc di ; increment address in row

mov [es:di],al ; move pixel colour into pixel byte address

cmp cx,310

jl Line

cmp bx,10

jg Yloop

92


mov ah,0

int 16H ; wait for keypress

mov ah,0

mov al,[savemode]

int 10H ; restore original video mode

mov ax, $4C00 ; Prepare to exit

int 0x21 ; Terminate prog

segment data

savemode resb 1

segment stack stack

resb 256

stacktop:

93


; MemMap2.asm

segment code

.. .. .. ..

; loop 5 times

xor si,si

Count:

inc si

mov bp,si

and bp,0001

; draw pixel at cx,bx

mov bx,191

Yloop:

dec bx

mov ax,bx

mov dx,320

mul dx ; multiply ax by 320 for each y

mov di,ax ; put start byte for each row in di

mov cx,9 ; x value

xor al,al ; colour value in current palette

add di,cx ; include x in start address

94


Line:

cmp bp,1 ;

jne Zero ; don't increment colour if si is even

inc al ; next colour

Zero:

inc cx ; next pixel

inc di ; increment address in row

mov [es:di],al ; move pixel colour into pixel byte address

cmp cx,310

jl Line

cmp bx,10

jg Yloop

cmp si,5

jl Count

.. .. .. ..

segment data

savemode resb 1

segment stack stack

resb 256

stacktop:

95


Compare MemMap2 with DrawLn6, where DrawLn6 is the same as DrawLn5 but with the same loop (5 times) as in MemMap2.

DrawLn6 is clearly slower - it flickers between iterations. MemMap2 shows no such flicker.

96


Screen display from DrawLn

Screen display from MemMap

97


Screen display from DrawLn

Screen display from MemMap

Single pixel “blip” caused by pressing PrtSc

98


To change the palette we need to write to the hardware ports.

Colour 0 in the palette is always the background colour.

• To change the background colour to a mid-range blue (for instance), we set colour 0 to 35.

Write 0 to port 3C8H (colour #) Write 0 to port 3C9H (Red) Write 0 to port 3C9H (Green) Write 35 to port 3C9H (Blue)

99


; MemMap4.asmsegment code.. .. .. ..; change video mode to 13H mov ah,0 mov al,13H int 10H; change background colour to a dark shade of blue mov dx,3c8H mov al,0 out dx,al ; colour 0 in the palette means background ; colour. Specify RGB values next. mov dx,3c9H mov al,0 ; red set to 0 out dx,al mov al,0 ; green set to 0 out dx,al mov al,35 ; set blue to 35 (max is 63) out dx,al; wait for keypress mov ah,0 int 16H; set es to point to video buffer mov ax,0A000H mov es,ax; draw pixel at cx,bx.. .. .. ..segment datasavemode resb 1


100


We can also modify any other colours in the palette.

For example, we can modify colours so that the palette contains mainly shades of red:

• Colour Red Green Blue

i=1,63 i 0 0

63+i i 15 15

126+i i 30 30

189+i i 45 45

253,255 No Change to these

101


; MemMap5.asmsegment code.. .. .. ..; change background colour to a dark shade of blue mov dx,3c8H mov al,0 out dx,al ; colour 0 in the palette means background ; colour. Specify RGB values next. mov dx,3c9H mov al,0 ; red set to 0 out dx,al mov al,0 ; green set to 0 out dx,al mov al,35 ; set blue to 35 (max is 63) out dx,al; modify palette to various shades of red; first 63 values: i 0 0, i=1,63; next 63 values: i 15 15; next 63 values: i 30 30; next 63 values: i 45 45; last 3 values: unchanged mov ah,0 ; BG value mov bh,15 ; BG increment mov bl,0 ; start i (less 1) mov bp,4 ; number of major loops

102


OuterLoop: mov cx,63 ; 63 counts in inner loopInnerLoop: inc bl mov dx,3c8H mov al,bl out dx,al mov dx,3c9H mov al,bl ; red out dx,al mov al,ah ; green out dx,al out dx,al ; blue loop InnerLoop add ah,bh ; next BG value dec bp jg OuterLoop

; wait for keypress mov ah,0 int 16H.. .. .. .. mov ax, $4C00 ; Prepare to exit int 0x21 ; Terminate prog

segment datasavemode resb 1


103


Output of original palette colours

Output of modified palette colours

Single pixel “blip” caused by pressing PrtSc

104


• What are the advantages and dis-advantages of accessing hardware directly rather than through the BIOS or the operating system? Advantages: speed & functionality

• Going directly to hardware is always faster rather than going through layers of system software.

• If new hardware is compatible with existing hardware but adds capabilities.

Disadvantages: compatibility• BIOS / operating system software makes hardware

from various manufacturers look the same to our applications.

105


• What is the mapping if we have a mode that uses a maximum of 16 colours rather than 256? Each byte in memory specifies the colour of

two pixels. Setting the colour of a single pixel becomes

more complicated than the 256 colour case because we have to be certain not to disturb the “companion” pixel in the byte of interest.

The mapping from x,y coordinate to byte number is also slightly more complicated.

106


Setting the colour of a single pixel - 16 colours

01234567

pixel npixel n+1

Current bytein memory

01234567

AND withthis mask

1 1 1 1 0 0 0 0

To set the value of pixel n (x is even):

01234567

OR with thisbyte

0 0 0 0 p3 p2 p1 p0

where p3 p2 p1 p0 are the bits specifyingthe colour of pixel n

107


Setting the colour of a single pixel - 16 colours

01234567

pixel n-1pixel n

Current bytein memory

01234567

AND withthis mask

0 0 0 0 1 1 1 1

To set the value of pixel n (x is odd):

01234567

OR with thisbyte

0 0 0 0p3 p2 p1 p0

where p3 p2 p1 p0 are the bits specifyingthe colour of pixel n

108


Memory map - 16 colours0,0 1,0 2,0 3,0 4,0 5,0 6,0 7,0 8,0 9,0

0,1 1,1 2,1 3,1 4,1 5,1 6,1 7,1 8,1 9,1

0,2 1,2 2,2 3,2 4,2 5,2 6,2 7,2 8,2 9,2

0,3 1,3 2,3 3,3 4,3 5,3 6,3 7,3 8,3 9,3

0,4 1,4 2,4 3,4 4,4 5,4 6,4 7,4 8,4 9,4

0,0 1,0 2,0 3,0 4,0 5,0 6,0 7,0 8,0 9,0 0,1 1,1

0 1 2 3 4 5

2,1 3,1 4,1 5,1 6,1 7,1 8,1 9,1 0,2 1,2 2,2 3,2

6 7 8 9 10 11

4,2 5,2 6,2 7,2 8,2 9,2 0,3 1,3 2,3 3,3 4,3 5,3

12 13 14 15 16 17

6,3 7,3 8,3 9,3 0,4 1,4 2,4 3,4 4,4 5,4 6,4 7,4

18 19 20 21 22 23

8,4 9,4

24

10 x 5 pixelsConvert pixel location to byte numberin video segment.Given x,y: byte number is y*10/2 + x div 2

Start of video segment

109


• Some necessary bit manipulation Shift right

• Most processors have an instruction that provides a binary shift right capability. This shifts every bit, starting with the least significant bit, a specified number of bit positions to the right. The least significant bit(s) is(are) lost. Zeros are moved into the vacated positions at the most significant bit end of the byte. Bytes/words are described by

bn ... b3 b2 b1 b0, where n is 7 (bytes) or 15 (words) etc.

SHR AX,1 is equivalent to AX divided by 2 (integer result)

SHR AX,n is equivalent to AX divided by 2n

Shift left• SHL AX,n is equivalent to multiplication by 2n

110


• Results of 16 colour direct mapped graphics The previous scheme does not work - why

not?• Our assumption that, in this mode, each byte

holds the colour value of two adjacent pixels, was incorrect.

• This mode comes from the EGA video card (mid 1980s), and for technical reasons, the card used “bit planes”. Each of the four bit planes represents a single bit for each pixel, so the final colour of a pixel is calculated from the bit pattern associated with that pixel on each of the planes.

111


• 16 colour bit planes

320

01

10

xy

A0000

112


• Hardware ports A hardware port is a device that connects the

processor to external peripherals. There are 1024 ports on the 80x86, identified

by their address: 0H - 3FFH. (Third party vendors may have ports in the range 3FFH - FFFFH. The PS/2 has ports outside 3FFH.)

They are actually special memory locations, but are not part of the conventional memory at all. (They do not take up any memory locations in the standard memory map.)

113


• Hardware ports We already saw that we can output values to

a port:MOV DX,port number

MOV AL,byte to output to port

OUT DX,AL

Similarly, we can read inputs from a port:MOV DX,port number

IN AL,DX

We can read/write bytes/words and sometimes double words from/to ports.

Can also use “immediate” port numbers.

114

3F03 - Data structures in assembler

• Creating and using data structures in assembler. We will specifically consider working with

arrays/tables in assembler. Some assemblers have the equivalent of a

“struct”. Creating data structures in such cases is similar to creating them in a high-level language.

115


• Arrays An array is a structure such that each

element in the structure is of the same type, and the elements are numbered consecutively and stored in contiguous memory.

Examples:• array1 db 20H, 30H, 40H• array2 dw 0251H, 4521H, 3F61H• array3 times 200 db 0• array4 resw 150

116


• Arrays Size of the array

• Could manually count elements (not practical)array1 db 23H, 41H, 55H, 26H

array1_sz db 4

• Use “current location” as we did with stringsarray2 db 23H, 41H, 55H, 26H

array2_sz equ $-array2

array3 dw 1234H, 2F43H, 3AE4H, 6A7BH

array3_sz equ ($-array3)/2

• Size is an integral part of the definitionarray4_sz equ 250

array4 resb array4_sz

117


• Arrays Accessing array elements - many ways to

access elements. One of the more common ways is to use indexed address mode.

• Set base register to address of start of array• Use index register as offset in array

(Could just use index register to point to each element, i.e. index register contains the element’s actual address.)

118

3F03 - Data structures in assembler; Arrays1.asm[BITS 16] ; Set 16 bit code[ORG 0100H] ; Set code start address to 100h (COM file)[SECTION .text] ; Code Section

START: mov bx,IntArray ; bx points to IntArray xor si,si ; zero si used as offset in IntArray xor cx,cx ; zero cx used as index; Initialise arrayInit: mov [bx+si],cx ; mov value of cx into array inc si inc si ; next word in array inc cx ; increment index cmp cx,10 jl Init ; if index < 10 do it again; Add elements of array xor ax,ax ; zero ax to accumulate sum xor si,si ; zero si offset in array xor cx,cx ; zero indexSum: add ax,[bx+si] ; add current array element inc si inc si ; next word in array inc cx ; increment index cmp cx,10 jl Sum ; if index < 10 do it again mov ax, 04C00H ; This DOS function exits the program int 21H ; and returns control to DOS.

[SECTION .data] ; Section containing initialised dataIntArray times 80 dw 0

119

3F03 - Data structures in assembler; Arrays2.asm.. .. .. .. ..; display result mov bx,ax ; copy result into bx and bx,0F000H ; mask everything except high nybble shr bx,12 ; move high nybble into low nybble mov di,result ; start of result string mov si,digits ; start of digits add si,bx ; pointer to representation of nybble mov dh,[si] mov [di],dh ; copy representation into first char mov bx,ax ; copy result into bx and bx,0F00H ; mask everything except low nybble in MSB shr bx,8 ; shift into low nybble inc di ; next char position in result mov si,digits add si,bx ; pointer to representation of nybble mov dh,[si] mov [di],dh ; copy representation into second char mov bx,ax ; copy result into bx and bx,00F0H ; mask everything except high nybble in LSB shr bx,4 ; shift into low nybble inc di ; next char position in result mov si,digits add si,bx ; pointer to representation of nybble mov dh,[si] mov [di],dh ; copy representation into third char mov bx,ax ; copy result into bx and bx,000FH ; mask everything except low nybble inc di ; next char position in result mov si,digits add si,bx ; pointer to representation of nybble mov dh,[si] mov [di],dh ; copy representation into fourth char mov dx,result mov ah,9 int 21H ; display result string on standard output.. .. .. .. ..[SECTION .data] ; Section containing initialised dataIntArray times 80 dw 0result db '0000',CR,LF,EOSdigits db '0123456789ABCDEF'

120


121

3F03 - Data structures in assembler; Arrays3.asm[BITS 16] ; Set 16 bit code[ORG 0100H] ; Set code start address to 100h (COM file)

[SECTION .text] ; Code SectionCR equ 0DHLF equ 0AHEOS equ '$'

START: mov cx,0 mov di,screenstr mov ah,'*'NextChar: mov [di],ah inc di inc cx cmp cx,1600 jl NextChar

mov dx,screenstr mov ah,9 int 21H ; display result string on standard output

mov ax, 04C00H ; This DOS function exits the program int 21H ; and returns control to DOS.

[SECTION .data] ; Section containing initialised datascreenstr times 1600 db '-' db CR,LF,EOS

122


123


[SECTION .text] ; Code SectionCR equ 0DHLF equ 0AHEOS equ '$'

START: mov cx,1600 mov di,screenstr mov al,'*'

cld rep stosb




124


125



CR equ 0DHLF equ 0AHEOS equ '$'START: mov cx,800 mov di,screenstr mov al,'*'

cld rep stosb




Modified

126


127


• Tables - two dimensional arrays Just like the memory-mapped graphics, the

table is stored in contiguous memory cells, not in a physical two-dimensional array.

The cells in a row are contiguous. The cells in a column are separated by one

row’s storage (number of columns multiplied by the number of bytes in each element).

Accesssing elements is pretty much the same as in single dimensioned arrays.

128

3F03 - Data structures in assembler; Tables1.asm[BITS 16] ; Set 16 bit code[ORG 0100H] ; Set code start address to 100h (COM file)[SECTION .text] ; Code Section

START:; add elements in third column (col = 2) xor ax,ax mov [sum],ax ; initialise sum xor cx,cx ; index of row mov dx,tableA ; address of tableA in dx

NextRow: push dx mov bx,dx mov ax,Ncols ; multiply Ncols by cx mul cx pop dx add bx,ax ; address of start of row cx in bx mov si,2 ; index of third column xor ax,ax ; initialise to zero mov al,[bx+si] ; byte at address Ncols*row + col add ax,[sum] ; add in previous sum mov [sum],ax ; store sum inc cx ; next row cmp cx,Nrows jl NextRow

129

3F03 - Data structures in assembler; display result mov bx,[sum] ; copy result into bx and bx,0F000H ; mask everything except high nybble shr bx,12 ; move high nybble into low nybble mov di,result ; start of result string mov si,digits ; start of digits add si,bx ; pointer to representation of nybble mov dh,[si] mov [di],dh ; copy representation into first char .. .. .. .. mov bx,[sum] ; copy result into bx and bx,000FH ; mask everything except low nybble inc di ; next char position in result mov si,digits add si,bx ; pointer to representation of nybble mov dh,[si] mov [di],dh ; copy representation into fourth char

mov dx,result mov ah,9 int 21H ; display result string on standard output.. .. .. .. ..[SECTION .data] ; Section containing initialised dataCR equ 0DHLF equ 0AHEOS equ '$'tableA db 10H, 20H, 30H, 40H, 50H db 11H, 21H, 31H, 41H, 51H db 12H, 22H, 32H, 42H, 52H db 13H, 23H, 33H, 43H, 53HNrows equ 4Ncols equ 5sum dw 0result db '0000',CR,LF,EOSdigits db '0123456789ABCDEF'

130


131

3F03 - Data structures in assembler; Tables2.asm[BITS 16] ; Set 16 bit code[ORG 0100H] ; Set code start address to 100h (COM file)[SECTION .text] ; Code SectionSTART:; add elements in fourth column (col = 3) xor ax,ax mov [sum],ax ; initialise sum xor cx,cx ; index of row mov dx,tableA ; address of tableA in dx

NextRow: push dx mov bx,dx mov ax,Ncols ; multiply Ncols by cx mul cx pop dx add bx,ax ; address of start of row cx in bx mov si,3 ; index of fourth column xor ax,ax ; initialise to zero mov al,[bx+si] ; byte at address Ncols*row + col add ax,[sum] ; add in previous sum mov [sum],ax ; store sum inc cx ; next row cmp cx,Nrows jl NextRow

.. .. .. .. ..

132

3F03 - Data structures in assembler; Tables3.asm[BITS 16] ; Set 16 bit code[ORG 0100H] ; Set code start address to 100h (COM file)[SECTION .text] ; Code SectionSTART: xor di,di ; zero col index mov bp,sum ; bp points to sum

NextCol:; add elements in column di xor ax,ax mov [bp+di],ax ; initialise sum xor cx,cx ; index of row mov dx,tableA ; address of tableA in dx

NextRow:.. .. .. .. .. inc di ; next row cmp di,Ncols jl NextCol ; if not done all cols do next col mov ax, 04C00H ; This DOS function exits the program int 21H ; and returns control to DOS.[SECTION .data] ; Section containing initialised dataCR equ 0DHLF equ 0AHEOS equ '$'tableA db 10H, 20H, 30H, 40H, 50H db 11H, 21H, 31H, 41H, 51H db 12H, 22H, 32H, 42H, 52H db 13H, 23H, 33H, 43H, 53HNrows equ 4Ncols equ 5sum times Ncols dw 0result db '0000',CR,LF,EOSdigits db '0123456789ABCDEF'

133


134

3F03 - Data structures in assembler; Tables4.asm[BITS 16] ; Set 16 bit code[ORG 0100H] ; Set code start address to 100h (COM file)[SECTION .text] ; Code SectionSTART: xor di,di ; zero col index mov bp,sum ; bp points to sumNextCol: push bp push di; add elements in column di xor ax,ax mov [bp+di],ax ; initialise sum xor cx,cx ; index of row mov dx,tableA ; address of tableA in dxNextRow: push dx mov bx,dx mov ax,Ncols ; multiply Ncols by cx mul cx pop dx add bx,ax ; address of start of row cx in bx mov si,di ; index of column xor ax,ax ; initialise to zero mov al,[bx+si] ; byte at address Ncols*row + col add ax,[bp+si] ; add in previous sum mov [bp+si],ax ; store sum inc cx ; next row cmp cx,Nrows jl NextRow

135

3F03 - Data structures in assembler; display result mov bp,[bp+di] ; store column total mov bx,bp ; copy result into bxmov bx,bp ; copy result into bx and bx,0F000H ; mask everything except high nybble shr bx,12 ; move high nybble into low nybble mov di,result ; start of result string mov si,digits ; start of digits add si,bx ; pointer to representation of nybble mov dh,[si] mov [di],dh ; copy representation into first char mov bx,bp ; copy result into bxmov bx,bp ; copy result into bx and bx,0F00H ; mask everything except low nybble in MSB shr bx,8 ; shift into low nybble inc di ; next char position in result mov si,digits add si,bx ; pointer to representation of nybble mov dh,[si] mov [di],dh ; copy representation into second char mov bx,bp ; copy result into bxmov bx,bp ; copy result into bx and bx,00F0H ; mask everything except high nybble in LSB shr bx,4 ; shift into low nybble inc di ; next char position in result mov si,digits add si,bx ; pointer to representation of nybble mov dh,[si] mov [di],dh ; copy representation into third char mov bx,bp ; copy result into bxmov bx,bp ; copy result into bx and bx,000FH ; mask everything except low nybble inc di ; next char position in result mov si,digits add si,bx ; pointer to representation of nybble mov dh,[si] mov [di],dh ; copy representation into fourth char

136

3F03 - Data structures in assembler mov dx,result mov ah,9 int 21H ; display result string on standard output

pop di pop bp

inc di ; next column cmp di,Ncols jge NoMore ; jump done this way otherwise too far jmp NextCol ; if not done all cols do next col

NoMore: mov ax, 04C00H ; This DOS function exits the program int 21H ; and returns control to DOS.

[SECTION .data] ; Section containing initialised dataCR equ 0DHLF equ 0AHEOS equ '$'tableA db 10H, 20H, 30H, 40H, 50H db 11H, 21H, 31H, 41H, 51H db 12H, 22H, 32H, 42H, 52H db 13H, 23H, 33H, 43H, 53HNrows equ 4Ncols equ 5sum times Ncols dw 0result db '0000',CR,LF,EOSdigits db '0123456789ABCDEF'

137


So, what was wrong with our program?

138

3F03 - Data structures in assembler; Tables5.asm.. .. .. ..START: xor di,di ; zero col index mov bp,sum ; bp points to sum

NextCol: Multiply by 2 when dealing with words.. .. .. .. shl di,1 mov [bp+di],ax ; initialise sum shr di,1.. .. .. .. Restore di afterwardsNextRow:.. .. .. .. mov al,[bx+si] ; byte at address Ncols*row + col shl si,1 add ax,[bp+si] ; add in previous sum mov [bp+si],ax ; store sum shr si,1.. .. .. ..; display result shl di,1 mov bp,[bp+di] ; store column total shr di,1.. .. .. .. inc di ; next column cmp di,Ncols jge NoMore ; jump done this way otherwise too far jmp NextCol ; if not done all cols do next col.. .. .. ..sum times Ncols dw 0result db '0000',CR,LF,EOSdigits db '0123456789ABCDEF'

139


140


• Using the array name as the base address. It is quite common to use the name of the

array/table/structure as the base address. The previous example can be rewritten using

the address of sum instead of loading it into bp.

141

3F03 - Data structures in assembler; Tables6.asm[BITS 16] ; Set 16 bit code[ORG 0100H] ; Set code start address to 100h (COM file)[SECTION .text] ; Code SectionSTART: xor di,di ; zero col indexNextCol: push di; add elements in column di xor ax,ax shl di,1 mov [sum+di],ax ; initialise sum shr di,1 xor cx,cx ; index of row mov dx,tableA ; address of tableA in dxNextRow: push dx mov bx,dx mov ax,Ncols ; multiply Ncols by cx mul cx pop dx add bx,ax ; address of start of row cx in bx mov si,di ; index of column xor ax,ax ; initialise to zero mov al,[bx+si] ; byte at address Ncols*row + col shl si,1 add ax,[sum+si] ; add in previous sum mov [sum+si],ax ; store sum shr si,1 inc cx ; next row cmp cx,Nrows jl NextRow

142

3F03 - Data structures in assembler; display result shl di,1 mov bp,[sum+di] ; store column total shr di,1 mov bx,bp ; copy result into bx and bx,0F000H ; mask everything except high nybble shr bx,12 ; move high nybble into low nybble mov di,result ; start of result string mov si,digits ; start of digits add si,bx ; pointer to representation of nybble mov dh,[si] mov [di],dh ; copy representation into first char.. .. .. .. .. mov dx,result mov ah,9 int 21H ; display result string on standard output pop di inc di ; next column cmp di,Ncols jge NoMore ; jump done this way otherwise too far jmp NextCol ; if not done all cols do next colNoMore: mov ax, 04C00H ; This DOS function exits the program int 21H ; and returns control to DOS.[SECTION .data] ; Section containing initialised data.. .. .. .. ..tableA db 10H, 20H, 30H, 40H, 50H db 11H, 21H, 31H, 41H, 51H db 12H, 22H, 32H, 42H, 52H db 13H, 23H, 33H, 43H, 53HNrows equ 4Ncols equ 5sum times Ncols dw 0result db '0000',CR,LF,EOSdigits db '0123456789ABCDEF'

143


• Struc Both MASM and NASM allow us to define

structures using a Struct/Struc directive/macro.

NASM does not have any intrinsic structure support - it simply provides a mechanism for defining structures that occupy contiguous memory locations.

• In MASM, a field component of a Struct is referenced by name.field, i.e. there is an underlying support for the structure.

• In NASM, we can “fool” the assembler by defining the fields as “.field_name”.

144


• Struc example Employee info

struc employee .name: resb 32 ; string[32] .salary: resd 1 ; 32-bit integer .date: resb 3 ; yy mm dd

endstruc

Create an instance of employee byperson: istruc employee

at employee.name db ‘A.N. Other’

at employee.salary dd 75000at employee.date db 01H,

0BH, 1AHiend

145

3F03 - Data structures in assembler; Struc1.asm[BITS 16] ; Set 16 bit code[ORG 0100H] ; Set code start address to 100h (COM file)[SECTION .text] ; Code SectionCR equ 0DHLF equ 0AHEOS equ '$'

START: struc employee.name: resb 32.salary: resd 1.date: resb 3 endstruc

person: istruc employee at employee.name, db 'A.N. Other',CR,LF,EOS at employee.salary, dd 75000 at employee.date, db 01H, 0BH, 1AH iend

mov dx,person+employee.name mov ah,9 int 21H ; display result string on standard output

mov ax,04C00H ; This DOS function exits the program int 21H ; and returns control to DOS.

[SECTION .data] ; Section containing data

146


147

3F03 - Data structures in assembler; Struc2.asm.. .. .. ..START: struc employee.name: resb 32.salary: resd 1.date: resb 3 endstrucperson1: istruc employee at employee.name, db 'A.N. Other',CR,LF,EOS at employee.salary, dd 75000 at employee.date, db 01H, 0BH, 1AH iend mov dx,person1+employee.name mov ah,9 int 21H ; display result string on standard outputperson2: istruc employee at employee.name, db ‘N.X. Twon’,CR,LF,EOS at employee.salary, dd 79000 at employee.date, db 03H, 05H, 12H iend mov dx,person2+employee.name mov ah,9 int 21H ; display result string on standard output

mov ax,04C00H ; This DOS function exits the program int 21H ; and returns control to DOS.

[SECTION .data] ; Section containing data

148

3F03 - Compiler Output

• Compilers produce assembler versions of the high-level code

• Usually the compiler just produces the assembler version as object code, but we can (usually) direct the compiler to produce an assembler listing as well

• Compilers have set methods of converting high-level code into assembler It MAY be posible to hand-code the assembler

more efficiently BUT, usually a great deal of thought has gone

into the compiler algorithms - so they tend to produce very good code

149

3F03 - Compiler Output/* TestSums.c */#include <stdio.h>

void sums(int a, int b, int *c);

void sums(int a, int b, int *c){ *c = a+b;}

main(){ int a,b,c; a = 5; b = 7; sums(a,b,&c); printf("sum=%d\n",c);

}

150

3F03 - Compiler OutputOutput from Visual C++

PUBLIC _sums; COMDAT _sums_TEXT SEGMENT_a$ = 8_b$ = 12_c$ = 16

151

3F03 - Compiler Output_sums PROC NEAR ; COMDAT; File C:\3f03_2002\Asm\TestSums.c; Line 7

push ebpmov ebp, espsub esp, 64 ; 00000040Hpush ebxpush esipush edilea edi, DWORD PTR [ebp-64]mov ecx, 16 ; 00000010Hmov eax, -858993460 ; ccccccccHrep stosd

; Line 8mov eax, DWORD PTR _a$[ebp]add eax, DWORD PTR _b$[ebp]mov ecx, DWORD PTR _c$[ebp]mov DWORD PTR [ecx], eax

; Line 9pop edipop esipop ebxmov esp, ebppop ebpret 0

_sums ENDP_TEXT ENDS

152

3F03 - Compiler OutputPUBLIC _mainPUBLIC ??_C@_07JNMI@sum?$DN?$CFd?6?$AA@ ; `string'EXTRN _printf:NEAREXTRN __chkesp:NEAR; COMDAT ??_C@_07JNMI@sum?$DN?$CFd?6?$AA@; File C:\3f03_2002\Asm\TestSums.cCONST SEGMENT??_C@_07JNMI@sum?$DN?$CFd?6?$AA@ DB 'sum=%d', 0aH, 00H ;

`string'CONST ENDS; COMDAT _main_TEXT SEGMENT_a$ = -4_b$ = -8_c$ = -12

153

3F03 - Compiler Output_main PROC NEAR ; COMDAT; File C:\3f03_2002\Asm\TestSums.c; Line 13

push ebpmov ebp, espsub esp, 76 ; 0000004cHpush ebxpush esipush edilea edi, DWORD PTR [ebp-76]mov ecx, 19 ; 00000013Hmov eax, -858993460 ; ccccccccHrep stosd

; Line 15mov DWORD PTR _a$[ebp], 5

; Line 16mov DWORD PTR _b$[ebp], 7

; Line 17lea eax, DWORD PTR _c$[ebp]push eaxmov ecx, DWORD PTR _b$[ebp]push ecxmov edx, DWORD PTR _a$[ebp]push edxcall _sumsadd esp, 12 ; 0000000cH

154

3F03 - Compiler Output; Line 18

mov eax, DWORD PTR _c$[ebp]push eaxpush OFFSET FLAT:??_C@_07JNMI@sum?$DN?$CFd?6?$AA@ ; `string'call _printfadd esp, 8

; Line 20pop edipop esipop ebxadd esp, 76 ; 0000004cHcmp ebp, espcall __chkespmov esp, ebppop ebpret 0

_main ENDP_TEXT ENDS

155


• Consider the stack as we set up the call to sums in main, and then as sums is executed we will not consider the details after sums has

completed calculating the sum and placing it in the appropriate location in the stack

156


push ebp

Stack frame

ebp esp

157


mov ebp,esp

Stack frame

ebpesp ebp

158


sub esp,76

Stack frame

ebp ebp

esp

76 bytes

159


push ebx

Stack frame

ebp ebp

esp

76 bytes

ebx

160


push esi

Stack frame

ebp ebp

esp

76 bytes

ebxesi

161


push edi

Stack frame

ebp ebp

esp

76 bytes

ebxesiedi

162


lea edi, dword ptr [ebp-76]mov ecx,19mov eax,-858993460rep stosd

Stack frame

ebp ebp

esp

76 bytes

ebxesiedi

... ...11001100110011001100110011001100

... ...

11001100110011001100110011001100

11001100110011001100110011001100

11001100110011001100110011001100

11001100110011001100110011001100

163


mov dword ptr _a$[ebp],5

_a$ = -4 in main

Stack frame

ebp ebp

esp

76 bytes

ebxesiedi

... ...11001100110011001100110011001100

... ...

11001100110011001100110011001100

11001100110011001100110011001100

11001100110011001100110011001100

5

164


mov dword ptr _b$[ebp],7

_b$ = -8 in main

Stack frame

ebp ebp

esp

76 bytes

ebxesiedi

... ...11001100110011001100110011001100

... ...

11001100110011001100110011001100

11001100110011001100110011001100

57

165


lea eax,dword ptr _c$[ebp]

_c$ = -12 in main

Stack frame

ebp ebp

esp

76 bytes

ebxesiedi

... ...11001100110011001100110011001100

... ...

11001100110011001100110011001100

11001100110011001100110011001100

57

eax

-12 bytes

166


push eax

Stack frame

ebp ebp

esp

76 bytes

ebxesiedi

... ...11001100110011001100110011001100

... ...

11001100110011001100110011001100

11001100110011001100110011001100

57

ptr

eax = ptr

167Stack frame

ebp ebp

esp

76 bytes

ebxesiedi

... ...11001100110011001100110011001100

... ...

11001100110011001100110011001100

11001100110011001100110011001100

57

ptr

eax = ptr

ecx-8 bytes


mov ecx,dword ptr _b$[ebp]

168


push ecx

Stack frame

ebp ebp

esp

76 bytes

ebxesiedi

... ...11001100110011001100110011001100

... ...

11001100110011001100110011001100

11001100110011001100110011001100

57

ptr

eax = ptrecx = 7

ecx

169Stack frame

ebp ebp

esp

76 bytes

ebxesiedi

... ...11001100110011001100110011001100

... ...

11001100110011001100110011001100

11001100110011001100110011001100

57

ptr

eax = ptrecx = 7

ecxedx

-4


mov edx,dword ptr _a$[ebp]

170


push edx

Stack frame

ebp ebp

esp

76 bytes

ebxesiedi

... ...11001100110011001100110011001100

... ...

11001100110011001100110011001100

11001100110011001100110011001100

57

ptr

eax = ptrecx = 7edx = 5

edxecx

171


push ebp

now in sums

Stack frame

ebp ebp

esp

76 bytes

ebxesiedi

... ...11001100110011001100110011001100

... ...

11001100110011001100110011001100

11001100110011001100110011001100

57

ptr


ebp (main)

edxecx

172


mov ebp,esp

Stack frame

ebp ebp

esp

76 bytes

ebxesiedi

... ...11001100110011001100110011001100

... ...

11001100110011001100110011001100

11001100110011001100110011001100

57

ptr


ebp (main) ebp

edxecx

173


sub esp,64

Stack frame

ebp ebp

76 bytes

ebxesiedi

... ...11001100110011001100110011001100

... ...

11001100110011001100110011001100

11001100110011001100110011001100

57

ptr


ebp (main) ebp

esp

64 bytes

edxecx

174


push ebx

Stack frame

ebp ebp

76 bytes

ebxesiedi

... ...11001100110011001100110011001100

... ...

11001100110011001100110011001100

11001100110011001100110011001100

57

ptr


ebp (main) ebp

esp

64 bytes

ebx

edxecx

175


push esi

Stack frame

ebp ebp

76 bytes

ebxesiedi

... ...11001100110011001100110011001100

... ...

11001100110011001100110011001100

11001100110011001100110011001100

57

ptr


ebp (main) ebp

esp

64 bytes

ebxesi

edxecx

176


push edi

Stack frame

ebp ebp

76 bytes

ebxesiedi

... ...11001100110011001100110011001100

... ...

11001100110011001100110011001100

11001100110011001100110011001100

57

ptr


ebp (main) ebp

esp

64 bytes

ebxesiedi

edxecx

177


lea edi,dword ptr [ebp-64]mov ecx,16mov eax, -858993460rep stosd

Stack frame

ebp ebp

76 bytes

ebxesiedi

... ...11001100110011001100110011001100

... ...

11001100110011001100110011001100

11001100110011001100110011001100

57

ptr


ebp (main) ebp

esp

64 bytes

ebxesiedi

11001100110011001100110011001100

11001100110011001100110011001100

... ...11001100110011001100110011001100

... ...

edxecx

178Stack frame

ebp ebp

76 bytes

ebxesiedi

... ...11001100110011001100110011001100

... ...

11001100110011001100110011001100

11001100110011001100110011001100

57

ptr


ebp (main) ebp

esp

64 bytes

ebxesiedi

11001100110011001100110011001100

11001100110011001100110011001100

... ...11001100110011001100110011001100

... ...

eax

edxecx

4 bytes


mov eax,dword ptr _a$[ebp]

_a$ = 4 in sums

179Stack frame

ebp ebp

76 bytes

ebxesiedi

... ...11001100110011001100110011001100

... ...

11001100110011001100110011001100

11001100110011001100110011001100

57

ptr


ebp (main) ebp

esp

64 bytes

ebxesiedi

11001100110011001100110011001100

11001100110011001100110011001100

... ...11001100110011001100110011001100

... ...

eax+eax

edxecx

8 bytes


add eax,dword ptr _b$[ebp]

_b$ = 8 in sums

180Stack frame

ebp ebp

76 bytes

ebxesiedi

... ...11001100110011001100110011001100

... ...

11001100110011001100110011001100

11001100110011001100110011001100

57

ptr


ebp (main) ebp

esp

64 bytes

ebxesiedi

11001100110011001100110011001100

11001100110011001100110011001100

... ...11001100110011001100110011001100

... ...

eax+eaxecx

edxecx

12 bytes


mov ecx,dword ptr _c$[ebp]

_c$ = 12 in sums

181


mov dword ptr [ecx],eax

Stack frame

ebp ebp

76 bytes

ebxesiedi

... ...11001100110011001100110011001100

... ...

11001100110011001100110011001100

57

ptr


ebp (main) ebp

esp

64 bytes

ebxesiedi

11001100110011001100110011001100

11001100110011001100110011001100

... ...11001100110011001100110011001100

... ...

eax+eaxecx

12

edx

182


• What can we learn from the above listings? C prefixes identifiers with _ In calling sub-programs:

• A stack frame is established in which parameters are placed on the stack in the order from right to left

• bp or ebp is used only as the base pointer - to point to sp when the call is invoked

• specific registers are protected - ebp, ebx, esi, edi

183


/* TestSum2.c */#include <stdio.h>

int sums(int a, int b);

int sums(int a, int b){ return (a+b);}

main(){ int a,b; a = 5; b = 7; printf("sum=%d\n",sums(a,b));

}

184

3F03 - Compiler Output_TEXT SEGMENT_a$ = 8_b$ = 12_sums PROC NEAR ; COMDAT; File C:\3F03_2002\ASM\TestSum2.c; Line 7


; Line 8mov eax, DWORD PTR _a$[ebp]add eax, DWORD PTR _b$[ebp]

; Line 9pop edipop esipop ebxmov esp, ebppop ebpret 0

_sums ENDP_TEXT ENDS

185

3F03 - Compiler Output; COMDAT _main_TEXT SEGMENT_a$ = -4_b$ = -8_main PROC NEAR ; COMDAT; File C:\3F03_2002\ASM\TestSum2.c; Line 13


; Line 15mov DWORD PTR _a$[ebp], 5

; Line 16mov DWORD PTR _b$[ebp], 7

; Line 17mov eax, DWORD PTR _b$[ebp]push eaxmov ecx, DWORD PTR _a$[ebp]push ecxcall _sums

186


add esp, 8push eaxpush OFFSET FLAT:??_C@_07JNMI@sum?$DN?$CFd?6?$AA@ ; `string'call _printfadd esp, 8

; Line 19pop edipop esipop ebxadd esp, 72 ; 00000048Hcmp ebp, espcall __chkespmov esp, ebppop ebpret 0

_main ENDP_TEXT ENDSEND

187


• What about c functions that return values? The parameters are handled as previously

noted. Scalar returned values are returned in AX or

DX:AX.

188


• How about gcc? In case we get the idea that the interface

details we observe using Visual C++ are restricted to that implementation (it should not be), we can also examine output from gcc.

To this end, we can examine the assembler listing generated for TestSums.c by gcc.

The listing is shown next.

189


.file "TestSums.c"gcc2_compiled.:___gnu_compiled_c:.text

.p2align 2.globl _sums_sums:

pushl %ebpmovl %esp,%ebppushl %ebxmovl 16(%ebp),%eaxmovl 8(%ebp),%edxmovl 12(%ebp),%ecxleal (%ecx,%edx),%ebxmovl %ebx,(%eax)

L1:movl -4(%ebp),%ebxleaveret

LC0:.ascii "sum=%d\12\0".p2align 2

gcc uses AT&T assembler formatfor the generated assembler.

ins source,destination

ins will have b, w, or l as a suffix:b - byte 8 bitsw - word 16 bitsl - long 32 bits

% precedes registersn(%eax) means %eax+n

190

3F03 - Compiler Output.globl _main_main:

pushl %ebpmovl %esp,%ebpsubl $12,%espmovl $5,-4(%ebp)movl $7,-8(%ebp)leal -12(%ebp),%eaxpushl %eaxmovl -8(%ebp),%eaxpushl %eaxmovl -4(%ebp),%eaxpushl %eaxcall _sumsaddl $12,%espmovl -12(%ebp),%eaxpushl %eaxpushl $LC0call _printfaddl $8,%esp

L2:leaveret

clean up stack etc

191


• So, gcc interfaces work in exactly the same way as do the interfaces in Visual C++ The gcc compiler does not fill the stack frame

between ebp and esp with a known value as does Visual C++

192

3F03 - Inline Assembler

• Inline assembler Many high-level language compilers allow us to

write blocks of assembler code within a sub-program

The advantage of inline assembler is that the interfacing between programs is handled by the high-level language

The assembler instructions available to be used inline usually forms a subset of the full set of instructions available to be used if we are writing the entire sub-program in assembler

Examples in Visual C++ and gcc follow -

193

3F03 - Inline Assembler/* TestSum3.c - Visual C++ */#include <stdio.h>


int sums(int a, int b){ int r; _asm {

mov eax, DWORD PTR 8[ebp] add eax, DWORD PTR 12[ebp] mov r, eax

} return (r);}


}

identifier signals an inlineassembler block enclosedwithin { }

194


• The previous example does not show why inline assembler is useful, since we used our knowledge of how the interface works to access the parameters.

• This was done to demonstrate the actual inline process.

• The good news is that we could re-write the program as follows:

195

3F03 - Inline Assembler/* TestSum5.c - Visual C++ */#include <stdio.h>


int sums(int a, int b){ int r; _asm {

mov eax, aadd eax, bmov r, eax

} return (r);}


}

In an inline assembler blockwe can directly referenceexisting identifiers!

196


• gcc also allows inline assembler as shown on the next slide.

197

3F03 - Inline Assembler/* TstSum4.c - gcc */#include <stdio.h>


int sums(int a, int b){ asm volatile ( "movl %0, %%eax" "\n\t" "addl %1, %%eax" "\n\t" : : "r" (a), "r" (b) );}


}

gcc inline is clumsy - asm (inst :outputs :inputs :clobbered)

optional

optional formatting codes

I/O: %0 is first one, etc

registers need %% prefix

first input is a register

198


• What about other languages?• For example, Delphi is an integrated

environment that implements an object Pascal compiler and supports inline assembler.

199


200


201


202


203

3F03 - Interfacing Assembler

• Don’t assume that all languages have the same rules for setting up the interface between procedures.

• In fact, Pascal and C use a different order for placing parameters on the stack.

• Pascal does not prefix identifiers with _.• Also, the different languages (and

sometimes different implementations of the same language) have different rules for which registers must be protected.

204

3F03 - Interfacing Assembler

• Calling assembler sub-programs from a high-level language: Principles for C:

• Know which memory model is being used• Protect base pointer• Copy stack pointer into base pointer• Set up local stack allowing for all local variables• C identifiers must be prefixed by _• Load parameters onto stack, right to left• Return values in AX• Protect ebx, esi, edi• Before returning from call, restore ebx, esi, edi• Restore stack pointer• Restore base pointer• Link assembled code (.obj) with rest of object code

205

3F03 - 80x86 Conclusions

• Final comments Note that a major difference between many

high-level languages and assembler is that the assembler does not support type checking.

We have not considered floating-point operations.

We have not discussed macros which are a major contribution to productivity in assembler programming.

We have concentrated on principles and concepts.

206

3F03 - Introduction to MIPS

• MIPS 32 registers - prefixed by $ “simple” instructions many instructions use 3 operands

• add $t0, $s1, $s2$t0 = $s1 + $s2

special registers• $a0-$a3: registers for passing parameters• $v0-$v1: registers for returning results• $ra: register that holds the return

address protected registers

• $s0-$s7: must be protected by callee unprotected registers

• $t0-$t9: need not be protected by callee

207


• MIPS Register type addressing mode

• all operands are registers Immediate type addressing mode

• one of the operands is a constant Jump type addressing mode

• pseudoindirect - 26 bit address field Base or displacement addressing mode

• operand is a memory address, sum of register and a constant

PC-relative addressing mode• address is an offset to the PC address

208


• MIPS Instruction categories

• Arithmetic add (add), subtract(sub), add immediate (addi)

• Data transfer load word (lw), store word (sw), store byte (sb), load upper

immediate (lui), copy register to register (move)• Conditional branch

branch on equal (beq), branch on not equal (bne), set on less than (slt), set less than immediate (slti)

• Unconditional jump jump (j), jump register (jr), jump and link (jal)

209


• Simple example

.textmain:

li $s0, 62 # fli $s1, 55 # gli $s2, 7 # hli $s3, 96 # kadd $t0, $s0, $s1 # f + gadd $t1, $s2, $s3 # h + ksub $s0, $t0, $t1 # (f + g) - (h +

k)jr $ra # unconditional

jump# to return

address

210


• We can use SPIM to simulate the MIPS hardware. SPIM is available for the major operating systems. We will use the PC version.

211


212


• System Calls load system call code into $v0 load arguments into $a0-$a3 values returned in $v0 (if necessary)

see Patterson & Hennessy, pages A-48/49

213


• Back to the example

.datastr:

.asciiz “Result is: “

.textmain:

li $s0, 62 # fli $s1, 55 # gli $s2, 7 # hli $s3, 96 # kadd $t0, $s0, $s1 # f + gadd $t1, $s2, $s3 # h + ksub $s0, $t0, $t1 # (f + g) - (h + k)li $v0, 4 # for print_strla $a0, str # address of strsyscall # print the stringli $v0, 1 # for print_intmove $a0, $s0 # put result in $a0syscall # print resultjr $ra # unconditional jump

# to return address

214


• Example.data # data section

theArray: # theArray is an address in memory and.space 160 # has 160 bytes available for use.text # code section

main: # main programli $t6, 1 # load imediate value 1 into register t6li $t7, 4 # load immediate value 4 into register t7sw $t6, theArray($0) # store word from register t6 in theArray[0]sw $t6, theArray($t7) # store word from register t6 in theArray[0+t7]li $t0, 8 # load immediate value 8 into register t0

loop: # labeladdi $t3, $t0, -8 # add immediate value -8 to value in register t0

# and store in register t3addi $t4, $t0, -4 # add immediate value -4 to value in register t0

# and store in register t4lw $t1, theArray($t3) # load word from theArray[0+t3] in register t1lw $t2, theArray($t4) # load word from theArray[0+t4] in register t2add $t5, $t1, $t2 # add values in registers t1 and t2 in register t5sw $t5, theArray($t0) # store word from register t5 in theArray[0+t0]addi $t0, $t0, 4 # add immediate value 4 to value in register t0

# and store in register t0blt $t0, 160, loop # branch to loop if value in register t0 < 160jr $ra # unconditionally jump to address in register ra

215


• So what does the previous example do? We can re-comment the example, being more

specific about the effect of each statement

216

3F03 - Introduction to MIPS• Specific annotation for example

.data # data sectiontheArray: # theArray is an address in memory and

.space 160 # has 160 bytes available for use

.text # code sectionmain: # main program

li $t6, 1 # load imediate value 1 into register t6# initial value = 1

li $t7, 4 # load immediate value 4 into register t7sw $t6, theArray($0) # store word from register t6 in theArray[0]

# f(0) = 1sw $t6, theArray($t7) # store word from register t6 in theArray[0+t7]

# f(1) = 1li $t0, 8 # load immediate value 8 into register t0

# address of f(n)loop: # label

addi $t3, $t0, -8 # add immediate value -8 to value in register t0# and store in register t3# address of f(n-2) in t3

addi $t4, $t0, -4 # add immediate value -4 to value in register t0# and store in register t4# address of f(n-1) in t4

lw $t1, theArray($t3) # load word from theArray[0+t3] in register t1# load f(n-2) into t1

lw $t2, theArray($t4) # load word from theArray[0+t4] in register t2# load f(n-1) into t2

add $t5, $t1, $t2 # add values in registers t1 and t2 in register t5# f(n-2) + f(n-1) into t5

sw $t5, theArray($t0) # store word from register t5 in theArray[0+t0]# f(n) = f(n-2) + f(n-1) stored in t5

addi $t0, $t0, 4 # add immediate value 4 to value in register t0# and store in register t0# address of f(n+1)

blt $t0, 160, loop # branch to loop if value in register t0 < 160# 160 bytes is 40 elements

jr $ra # unconditionally jump to address in register ra

217


• So what does it do?

It computes and stores the Fibonacci numbers:

fib(0) = 1fib(1) = 1fib(n) = fib(n-1) + fib(n-2), n=2,3,4,…,39

218


• MIPS MIPS is a load-store architecture

• Only load and store instructions access memory RISC - Reduced Instruction Set Computer

• fixed instruction length• load-store architecture• limited addressing modes• limited operations

Well-suited for use by compilers rather than by human coders

machine language - 3f03 alan wassyng itb 166 [email protected] january - april 2006

Documents