Summer 2003 Lecture 11 06/25/03

Size: px

Start display at page:

Download "Summer 2003 Lecture 11 06/25/03"

Gwen Walker
5 years ago
Views:

1 Summer 2003 Lecture 11 06/25/03 Maskable Hardware Interrupt Process Sequence 1) CPU samples level of interrupt pin at end of last cycle of previous instruction. 2) If the interrupt pin is high, rather than perform the next instruction fetch cycle, the CPU will begin an interrupt acknowledge cycle. 3) The INTA pin is brought low during two successive bus cycles. During the second INTA cycle, the interrupt number will be sampled on the system data bus. 4) The CPU will save the current FLAGS, CS and IP on the stack. 5) The interrupt flag in the FLAGS register is cleared. 6) The interrupt vector address will be computed from the interrupt number, and the corresponding vector will be fetched from the interrupt vector table. 7) The interrupt vector will be loaded into CS and IP. 8) The CPU will start executing the next instruction at the beginning of the interrupt service routine. Implementing Standard C Control Structures: IF THEN ELSE The IF-THEN control construct is the most basic form of decision making structure in programming. The specified condition is tested and if it is true, the associated block of code is executed. If the condition is not true, execution continues: if (condition) { true case code This is implemented in assembler using some instruction that sets the flags, usually CMP, AND, OR, or XOR. If the flag is set indicating that the condition is not true, a conditional jump will jump around the IF code. The only thing tricky about this is to make sure that you have correctly implemented the test for not condition, so that the jump around the if clause code occurs when it is supposed to. if (a == b) { mov ax,a blah; jnz endif

2 blah The IF-THEN can be combined with an ELSE clause, giving an IF-THEN- ELSE construct. If the specified condition is true, the if clause code is executed, otherwise the else clause code is executed. Again, this can be implemented as a test followed by a conditional jump. This can be done one of two ways. 1. If the condition is true, jump to the if block, otherwise fall through to the else code. This is the more natural way to write it, but the if and else blocks end up being in the opposite order from how they would appear in C. 2. If the condition is not true, jump to the else block, otherwise, fall through to the if block. This puts the if and else clauses in the more natural order. However, as with the IF-THEN above, it requires correctly implementing the test for not condition for the jump to the else clause.

3 In each case, following the end of the first clause, a jump is made to the end of the IF construct. if (a == b) { true clause else { false clause mov ax,a mov ax,a jz doif jnz doelse doelse: doif: false clause true clause jmp endif jmp endif doif: doelse: true clause false clause The most complete form of the IF control construct adds additional ELSE IF tests to add more possible choices. In this case, the first IF condition is evaluated. If the test is true, the code associated with the IF clause is executed. If it is not true, the first ELSE IF condition is evaluated. If true, the associated block of code is executed, if not the next ELSE IF condition is tested, and so on. If no ELSE IF conditions are true, then the final ELSE clause code is executed. This is best implemented using the second form as shown above. Test the first condition, if true, fall through to the associated block of code, if not true, jump to the test of the second condition, and so on, so that if the final test if false, a jump is taken to the else clause code. After each of the IF or ELSE IF clauses has executed, a jump is made to the ENDIF. if (a == b) { mov ax,a first clause jnz test2 else if (a == c) { second clause first clause else if (a == d) { jmp endif third clause test2: cmp ax,c

4 jnz test3 else { final clause second clause jmp endif test3: cmp ax,d jnz doelse third clause jmp endif doelse: final clause WHILE The C WHILE loop tests a condition at the beginning of the loop. If the test is satisfied, the body of the loop is executed and the test is performed again. The body of the loop will be executed as long as the test is satisfied. Because the test is made at the top of the loop, the will not be executed at all if the test is not satisfied the first time. This is most naturally implemented in assembler using a similar test to that of the IF THEN, followed by a jump around the body of the loop if the condition is false. Following the is a jump back to the top of the loop and the test. while (a == b) { ltop: mov ax,a jnz lend jmp ltop lend: DO WHILE The DO-WHILE loop in C is similar to the WHILE loop, except that the test is made at the end of the loop instead of the beginning. The will execute at least once.

5 When implementing this in assembler, it is most natural to use a test of the loop condition at the bottom of the loop, and if the condition is satisfied to jump back to the top of the loop. do { ltop: while (a == b); mov ax,a jz ltop

6 FOR LOOP The FOR loop in C uses an initialization expression, a test expression, and a reinitialization expression. The initialization expression is performed once at the beginning of the construct. The test expression tests a condition, and if the test is satisfied, the body of the loop will be executed. Following the body of the loop, the reinitialization expression will be executed and then the test expression is again executed. The test is at the beginning of the loop, and so the will not be executed at all if the test fails the first time. The general syntax for a C FOR loop is as follows: for (<init expr>; <test expr>; <reinit expr>) { This is semantically equivalent to the following C constructs: init expr; while (test expr) { reinit expr;

7 The implementation of this in assembler follows directly from the above description for the implementation of the WHILE loop. for (inx = 0; inx < 10; inx++) {movinx,0 ltop: mov ax,inx cmp ax,10 jae lend add inx,1 jmp ltop lend:

Summer 2003 Lecture 12 06/26/03

Summer 2003 Lecture 12 06/26/03 Implementing Standard C Control Structures: IF THEN ELSE if (a == b) { mov ax,a blah; cmp ax,b jnz endif blah endif: if (a == b) { true clause else { false clause mov ax,a