Cet 3510 microcomputer systems technology lecture 5
1 / 27

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

  • Uploaded on

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.
Download Presentation

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

An Image/Link below is provided (as is) to download presentation

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 technology lecture 5

CET 3510 - Microcomputer Systems TechnologyLecture 5

Dr. José M. Reyes Álamo


  • Review:

    • of Comparisons

    • of Set on Condition

  • Statement Labels

  • Unconditional Jumps

  • Conditional Jumps

Review of comparison
Review of Comparison

  • 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.

Review on set on condition
Review on Set on Condition

  • 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

Low level control structures
Low Level Control Structures

  • 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

Statement labels
Statement Labels

  • 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


Operations with labels
Operations with Labels

  • 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 &

    • Use the command load effective address lea


      lea( reg32, Memory_operand );

Obtaining the address of a label
Obtaining the Address of a Label

program labelDemo;

#include( "stdlib.hhf" );

begin labelDemo;


lea( ebx, lbl1 );

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


end labelDemo;

Unconditional jump jmp
Unconditional Jump (JMP)

  • 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
Direct Jump

  • 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:



Register indirect jump
Register Indirect Jump

  • 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);


Memory indirect jump
Memory Indirect Jump

  • 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);



  • 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.

Conditional jump
Conditional Jump

  • 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.

Conditional jump tests
Conditional Jump Tests

  • 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 limitations
Conditional Jump Limitations

  • 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.

Conditional jump tips
Conditional Jump Tips

  • 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).

Example of an decision statement
Example of an decision statement

if (x == y)


mov(x, bx)

mov(y, cx)

cmp( bx, cx );


inc( ax );




Example of a loop statement
Example of a loop statement

mov (0, eax);

mov (100, ebx);


cmp(eax, ebx);





  • C++

    x = 0;

    while(x <= 100){