1 / 27

# CET 3510 - Microcomputer Systems Technology Lecture 5 - PowerPoint PPT Presentation

CET 3510 - Microcomputer Systems Technology Lecture 5. Dr. José M. Reyes Álamo. Outline. Review: of Comparisons of Set on Condition Statement Labels Unconditional Jumps Conditional Jumps. Review of Comparison. HLA Syntax: cmp (Left, Right)

I am the owner, or an agent authorized to act on behalf of the owner, of the copyrighted work described.

## PowerPoint Slideshow about 'CET 3510 - Microcomputer Systems Technology Lecture 5' - gage

Download Policy: Content on the Website is provided to you AS IS for your information and personal use and may not be sold / licensed / shared on other websites without getting consent from its author.While downloading, if for some reason you are not able to download a presentation, the publisher may have deleted the file from their server.

- - - - - - - - - - - - - - - - - - - - - - - - - - E N D - - - - - - - - - - - - - - - - - - - - - - - - - -
Presentation Transcript

### CET 3510 - Microcomputer Systems TechnologyLecture 5

Dr. José M. Reyes Álamo

• Review:

• of Comparisons

• of Set on Condition

• Statement Labels

• Unconditional Jumps

• Conditional Jumps

• HLA Syntax: cmp(Left, Right)

• Used for comparisons, same as sub, but instead of returning the result only sets certain bits in the flags register.

• Z: The zero flag is set if and only if Left = Right.

• S:The sign flag is set to one if the result is negative.

• O: The overflow flag is set if the difference of Left and Right produced an overflow or underflow.

• C:The carry flag is set if subtracting Right from Left requires a borrow.

• The set on condition (or setcc) instructions set a single byte operand (register or memory location) to zero or one depending on the values in the flags register

• These instructions store a zero into the operand if the condition is false, a one if the condition is true

• Useful for mapping the result of a comparison to a Boolean value

• HLA control structures are similar to C++ and other high-level language

• These are NOT true assembly language

• Now you will learn how these are represented in real assembly

• A low level control structure usually transfers control from one point in your program to another.

• Transfer destination is typically specified of using a statement label.

• A statement label consists of a valid HLA identifier and a colon.

• Don’t have to be declared before you use it

• Syntax

aLabel:

• Transfer control to a label via a jump (goto) instruction

• Call a label via the CALL instruction,

• Take the address of a label

• Use the address-of operator &

Syntax:

lea( reg32, Memory_operand );

program labelDemo;

#include( "stdlib.hhf" );

begin labelDemo;

lbl1:

lea( ebx, lbl1 );

stdout.put( "&lbl1=\$", ebx, " &lbl2=", &lbl2, nl );

lbl2:

end labelDemo;

• The jmp(jump) instruction unconditionally transfers control to another point in the program.

• There are three forms of this instruction one direct jump, and two indirect in the following forms:

• jmp label;

• jmp( reg32 );

• jmp( mem32 );

• Direct jump specifies the target using a label

• The label is usually on the same line as an executable instruction or appears on a line preceding an executable machine instruction.

• The direct jump instruction is the most commonly used.

• Equivalent to a GOTO statement

• Syntax:

jmplaterInPgm;

laterInPgm:

• Transfers control to the instruction whose address is specified in the 32-bit general purpose register.

• You must load the specified register with the address of some machine instruction prior to the execution of the JMP.

• Syntax:

mov(&laterInPgm, ebx);

jmp (ebx);

laterInPgm:

• Memory indirect fetches a dword value from the specified memory location and transfers control to the instruction at the address specified by the contents of the memory location.

• Similar to the register indirect JMP except the address appears in a memory location rather than in a register.

• Syntax:

<< statements >>

LabelPtr:dword := &stmtLabel;

jmp (LabelPtr);

stmtLabel:

• Low-level JMP instructions can get you into a lot of trouble.

• If you do not initialize a register with the address of a valid instruction and you jump indirect through that register, the results are undefined.

• If you do not initialize a dword variable with the address of a legal instruction, jumping indirect through that memory location will probably crash your program.

• Unconditional jmpprovides transfer of control but does not allow you to make decisions.

• Conditional jumps handle this task.

• Conditional jumps are the basic tool for creating loops (i.e. while, for, repeat) and other conditionally executable statements (i.e. if, switch)

• Syntax

jcc label;

cc indicated the type of test you are performing.

• The conditional jumps test one or more flags in the EFLAGS register to see if they match a particular pattern.

• If the flags match, the control jumps to the target label.

• If the match fails, the CPU ignores the conditional jump and execution continues with the next instruction.

• Most of the time, conditional jumps follow the execution of a cmpinstruction as the cmp sets the EFLAGS register allowing tests for less than, greater than, equality, etc.

• Conditional jump instructions do not provide an indirect form, only allow is a jump to a label in your program.

• Conditional jump target label must be within 32,768 bytes of the jump instruction.

• This generally corresponds to somewhere between 8,000 and 32,000 machine instructions, it is unlikely you will ever encounter this restriction.

• In many instances you will need to generate the opposite of a specific jump instruction.

• If the second letter of the jccinstruction is not an “n”, insert an “n” after the “j”. (e.g., je becomes jne and jlbecomes jnl)

• If the second letter of the jccinstruction is an “n”, then remove that “n” from the instruction. (e.g., jngbecomes jgand jnebecomes je.

• Exception: jpe(jump if parity is even) vs. jpo(jump if parity is odd).

if (x == y)

a++;

mov(x, bx)

mov(y, cx)

cmp( bx, cx );

jneSkipStmts;

inc( ax );

SkipStmts:

C++

HLA

mov (0, eax);

mov (100, ebx);

WhileLabel:

cmp(eax, ebx);

jnlWhileDone;

inc(eax);

jmpWhileLabel;

WhileDone:

• C++

x = 0;

while(x <= 100){

x++;

}

C++

HLA