Presentation is loading. Please wait.

Presentation is loading. Please wait.

II:1 x86 Assembly - Control. II:2 Alternate reference source Go to the source: Intel 64 and IA32 

Published byNoel Robinson Modified over 8 years ago

Similar presentations

Presentation on theme: "II:1 x86 Assembly - Control. II:2 Alternate reference source Go to the source: Intel 64 and IA32 "— Presentation transcript:

1 II:1 x86 Assembly - Control

2 II:2 Alternate reference source Go to the source: Intel 64 and IA32  http://download.intel.com/products/processor/manual/253665.pd f http://download.intel.com/products/processor/manual/253665.pd f  See fig 3.1, 3.4, 3.5, 3.8  Section 5.1 (Intel format), ENTER/LEAVE (6.5.1, 6.5.2) Or AMD: http://support.amd.com/us/Embedded_TechDocs/24592.pdf http://support.amd.com/us/Embedded_TechDocs/24592.pdf See Fig 3-3 & rest of chapter 3 for instruction set Or this useful site: http://asm.sourceforge.net/http://asm.sourceforge.net/ Quiz (email out late Friday; do at home (open book but not open neighbor; bring to class and grade in class Tues). ASM Data moves and simple arithmetic (up until end of class today).

3 II:3 CPU Review: Assembly Programmer’s View Programmer-Visible State  PC: Program counter  Address of next instruction  Called “EIP” (IA32)  Register file  Heavily used program data  Condition codes  Store status information about most recent arithmetic operation  Used for conditional branching  Memory  Byte addressable array  Code, user data, (some) OS data  Includes stack used to support procedures PC Registers Memory Object Code Program Data OS Data Addresses Data Instructions Stack Condition Codes

4 II:4 Review: x86 instructions mov: movl, movw, movb add/sub/imul: sal/shl/sar/shr: xor/and/or: inc/dec/neq/not: lea:

5 II:5 Review: movl Operand Combinations Cannot do memory-memory transfer with a single instruction movl Imm Reg Mem Reg Mem Reg Mem Reg SourceDestC Analog movl $0x4,%eaxtemp = 0x4; movl $-147,(%eax)*p = -147; movl %eax,%edxtemp2 = temp1; movl %eax,(%edx)*p = temp; movl (%eax),%edxtemp = *p; Src,Dest

6 II:6 Review: Memory Addressing Modes Normal(R)Mem[Reg[R]]  Register R specifies memory address movl (%ecx),%eax DisplacementD(R)Mem[Reg[R]+D]  Register R specifies start of memory region  Constant displacement D specifies offset movl 8(%ebp),%edx

7 II:7 Review: Memory Addressing Modes Most General Form D(Rb,Ri,S)Mem[Reg[Rb]+S*Reg[Ri]+ D]  D: Constant “displacement” 1, 2, or 4 bytes  Rb: Base register: Any of 8 integer registers  Ri:Index register: Any, except for %esp  Unlikely you’d use %ebp, either  S: Scale: 1, 2, 4, or 8 (why these numbers?) Special Cases (Rb,Ri)Mem[Reg[Rb]+Reg[Ri]] D(Rb,Ri)Mem[Reg[Rb]+Reg[Ri]+D] (Rb,Ri,S)Mem[Reg[Rb]+S*Reg[Ri]]

8 II:8 Processor State (IA32, Partial) Information about currently executing program  Temporary data ( %eax, … )  Location of runtime stack ( %ebp,%esp )  Location of current code control point ( %eip, … )  Status of recent tests ( CF,ZF,SF,OF ) %eip General purpose registers Current stack top Current stack frame Instruction pointer CFZFSFOF Condition codes %eax %ecx %edx %ebx %esi %edi %esp %ebp

9 II:9 Condition Codes (Implicit Setting) Single bit registers CF Carry Flag (for unsigned) SF Sign Flag (for signed) ZF Zero Flag OF Overflow Flag (for signed) Implicitly set (think of it as side effect) by arithmetic operations Example: addl Src,Dest ↔ t = a+b  CF set if carry out from most significant bit (unsigned overflow)  ZF set if t == 0  SF set if t < 0 (as signed)  OF set if two’s complement (signed) overflow (a>0 && b>0 && t =0) Not set by lea instruction

10 II:10 Condition Codes (Explicit Setting: Compare) Explicit Setting by Compare Instruction cmpl Src2,Src1# NOTE THE OPERANDS ORDER cmpl b,a like computing a-b without setting destination  CF set if carry out from most significant bit (used for unsigned comparisons)  ZF set if a == b  SF set if (a-b) < 0 (as signed)  OF set if two’s complement (signed) overflow (a>0 && b 0 && (a-b)>0)

11 II:11 Condition Codes (Explicit Setting: Test) Explicit Setting by Test instruction testl Src2,Src1 testl b,a like computing a&b without setting destination  Sets condition codes based on value of Src1 & Src2  Useful to have one of the operands be a mask  ZF set when a&b == 0  SF set when a&b < 0

12 II:12 Reading Condition Codes SetX Instructions  Set single byte based on combinations of condition codes SetXConditionDescription seteZF Equal / Zero setne~ZF Not Equal / Not Zero setsSF Negative setns~SF Nonnegative setg~(SF^OF)&~ZF Greater (Signed) setge~(SF^OF) Greater or Equal (Signed) setl(SF^OF) Less (Signed) setle(SF^OF)|ZF Less or Equal (Signed) seta~CF&~ZF Above (unsigned) setbCF Below (unsigned)

13 II:13 Reading Condition Codes (Cont.) SetX Instructions: Set single byte based on combination of condition codes One of 8 addressable byte registers  Does not alter remaining 3 bytes  Typically use movzbl to finish job int gt (int x, int y) { return x > y; } movl 12(%ebp),%eax# eax = y cmpl %eax,8(%ebp)# Compare x and y setg %al# al = x > y movzbl %al,%eax# Zero rest of %eax Note inverted ordering! Body %eax %ecx %edx %ebx %esi %edi %esp %ebp %al%ah %cl%ch %dl%dh %bl%bh

14 II:14 Explanation: MOVSBL and MOVZBL MOVSBL and MOVZBL  * MOVSBL sign-extends a single byte, and copies it into a double- word destination  * MOVZBL expands a single byte to 32 bits with 24 leading zeros, and copies it into a double-word destination Example: %eax = 0x12345678 %edx = 0xAAAABBBB MOVB %dh, %al %eax = 0x123456BB MOVSBL %dh, %eax %eax = 0xFFFFFFBB MOVZBL %dh, %eax %eax = 0x000000BB

15 II:15 Jumping jX Instructions  Jump to different part of code depending on condition codes jXConditionDescription jmp1 Unconditional jeZF Equal / Zero jne~ZF Not Equal / Not Zero jsSF Negative jns~SF Nonnegative jg~(SF^OF)&~ZF Greater (Signed) jge~(SF^OF) Greater or Equal (Signed) jl(SF^OF) Less (Signed) jle(SF^OF)|ZF Less or Equal (Signed) ja~CF&~ZF Above (unsigned) jbCF Below (unsigned)

16 II:16 Conditional Branch Example int absdiff(int x, int y) { int result; if (x > y) { result = x-y; } else { result = y-x; } return result; } absdiff: pushl %ebp movl %esp, %ebp movl 8(%ebp), %edx movl 12(%ebp), %eax cmpl %eax, %edx jle.L7 subl %eax, %edx movl %edx, %eax.L8: leave ret.L7: subl %edx, %eax jmp.L8 Body1 Setup Finish Body2

17 II:17 Review: stack movl 8(%ebp), %edx movl 12(%ebp), %eax cmpl %eax, %edx jle.L7 subl %eax, %edx movl %edx, %eax Stack (in memory) y x Rtn adr Old % ebp %ebp 0 4 8 12 Offset Old % ebx -4 int absdiff(int x, int y) { int result; if (x > y) { result = x-y; } else { result = y-x; } return result; } Review: stack & function parameters

18 II:18 Review: stack & function parameters movl 8(%ebp), %edx# edx = x movl 12(%ebp), %eax# eax = y cmpl %eax, %edx jle.L7 subl %eax, %edx movl %edx, %eax Stack (in memory) y x Rtn adr Old % ebp %ebp 0 4 8 12 Offset Old % ebx -4 int absdiff(int x, int y) { int result; if (x > y) { result = x-y; } else { result = y-x; } return result; }

19 II:19 Conditional Branch Example (Cont.) C allows “goto” as means of transferring control  Closer to machine-level programming style Generally considered bad coding style int goto_ad(int x, int y) { int result; if (x <= y) goto Else; result = x-y; Exit: return result; Else: result = y-x; goto Exit; } absdiff: pushl %ebp movl %esp, %ebp movl 8(%ebp), %edx #x movl 12(%ebp), %eax #y cmpl %eax, %edx jle.L7 subl %eax, %edx movl %edx, %eax.L8: leave ret.L7: subl %edx, %eax jmp.L8

20 II:20 Conditional Branch Example (Cont.) int goto_ad(int x, int y) { int result; if (x <= y) goto Else; result = x-y; Exit: return result; Else: result = y-x; goto Exit; } absdiff: pushl %ebp movl %esp, %ebp movl 8(%ebp), %edx #x movl 12(%ebp), %eax #y cmpl %eax, %edx jle.L7 subl %eax, %edx movl %edx, %eax.L8: leave ret.L7: subl %edx, %eax jmp.L8

21 II:21 Conditional Branch Example (Cont.) int goto_ad(int x, int y) { int result; if (x <= y) goto Else; result = x-y; Exit: return result; Else: result = y-x; goto Exit; } absdiff: pushl %ebp movl %esp, %ebp movl 8(%ebp), %edx #x movl 12(%ebp), %eax #y cmpl %eax, %edx jle.L7 subl %eax, %edx movl %edx, %eax.L8: leave ret.L7: subl %edx, %eax jmp.L8

22 II:22 Conditional Branch Example (Cont.) int goto_ad(int x, int y) { int result; if (x <= y) goto Else; result = x-y; Exit: return result; Else: result = y-x; goto Exit; } absdiff: pushl %ebp movl %esp, %ebp movl 8(%ebp), %edx #x movl 12(%ebp), %eax #y cmpl %eax, %edx jle.L7 subl %eax, %edx movl %edx, %eax.L8: leave ret.L7: subl %edx, %eax jmp.L8

23 II:23 Conditional Branch Example (Cont.) int goto_ad(int x, int y) { int result; if (x <= y) goto Else; result = x-y; Exit: return result; Else: result = y-x; goto Exit; } absdiff: pushl %ebp movl %esp, %ebp movl 8(%ebp), %edx #x movl 12(%ebp), %eax #y cmpl %eax, %edx jle.L7 subl %eax, %edx movl %edx, %eax.L8: leave ret.L7: subl %edx, %eax jmp.L8

24 II:24 C Code val = Test ? Then-Expr : Else-Expr ; Goto Version nt = !Test ; if (nt) goto Else; val = Then-Expr ; Done:... Else: val = Else-Expr ; goto Done; General Conditional Expression Translation  Test is expression returning integer = 0 interpreted as false  0 interpreted as true  Create separate code regions for then & else expressions  Execute appropriate one val = x>y ? x-y : y-x; Conditional transfer of control

25 II:25 Conditional transfer of data Conditional move instruction  cmovC src, dest  Move value from src to dest if condition C holds  More efficient than conditional branching (simple control flow)  Overhead: both possible return values are computed absdiff: # x in %edi, y in %esi movl %edi, %eax # eax = x movl %esi, %edx # edx = y subl %esi, %eax # eax = x-y subl %edi, %edx # edx = y-x cmpl %esi, %edi # x:y cmovle %edx, %eax # eax=edx if <= ret int absdiff( int x, int y) { int result; if (x > y) { result = x-y; } else { result = y-x; } return result; }

26 II:26 C Code Conditional Move Version val1 = Then-Expr ; val2 = Else-Expr ; val1 = val2 if ! Test ; General Form with Conditional Move Both values get computed Overwrite then-value with else-value if condition doesn’t hold Don’t use when:  Then or else expression have side effects  Then and else expression are too expensive val1 = Test ? Then-Expr : Else-Expr ;

27 II:27 C Code int fact_do(int x) { int result = 1; do { result *= x; x = x-1; } while (x > 1); return result; } Goto Version int fact_goto(int x) { int result = 1; loop: result *= x; x = x-1; if (x > 1) goto loop; return result; } “Do-While” Loop Example Use backward branch to continue looping Only take branch when “while” condition holds

28 II:28 Goto Version int fact_goto(int x) { int result = 1; loop: result *= x; x = x-1; if (x > 1) goto loop; return result; } “Do-While” Loop Compilation Registers: %edxx %eaxresult fact_goto: pushl %ebp# Setup movl %esp,%ebp# Setup movl $1,%eax# eax = 1 movl 8(%ebp),%edx# edx = x.L11: imull %edx,%eax# result *= x decl %edx# x-- cmpl $1,%edx# Compare x : 1 jg.L11# if > goto loop movl %ebp,%esp# Finish popl %ebp# Finish ret# Finish Assembly

29 II:29 C Code do Body while ( Test ); Goto Version loop: Body if ( Test ) goto loop General “Do-While” Translation Body: Test returns integer = 0 interpreted as false  0 interpreted as true { Statement 1 ; Statement 2 ; … Statement n ; }

30 II:30 C Code int fact_while(int x) { int result = 1; while (x > 1) { result *= x; x = x-1; }; return result; } Goto Version #1 int fact_while_goto(int x) { int result = 1; loop: if (!(x > 1)) goto done; result *= x; x = x-1; goto loop; done: return result; } “While” Loop Example Is this code equivalent to the do-while version? Must jump out of loop if test fails

31 II:31 C Code int fact_while(int x) { int result = 1; while (x > 1) { result *= x; x = x-1; }; return result; } Goto Version #2 int fact_while_goto2(int x) { int result = 1; if (!(x > 1)) goto done; loop: result *= x; x = x-1; if (x > 1) goto loop; done: return result; } Alternative “While” Loop Translation Historically used by GCC Uses same inner loop as do- while version Guards loop entry with extra test

32 II:32 While version while ( Test ) Body Do-While Version if (! Test ) goto done; do Body while( Test ); done: General “While” Translation Goto Version if (! Test ) goto done; loop: Body if ( Test ) goto loop; done:

33 II:33 C Code int fact_while(int x) { int result = 1; while (x > 1) { result *= x; x = x-1; }; return result; } Goto Version int fact_while_goto3(int x) { int result = 1; goto middle; loop: result *= x; x = x-1; middle: if (x > 1) goto loop; return result; } New Style “While” Loop Translation Recent technique for GCC  Both IA32 & x86-64 First iteration jumps over body computation within loop

34 II:34 C Code while ( Test ) Body Jump-to-Middle While Translation Avoids duplicating test code Unconditional goto incurs no performance penalty for loops compiled in similar fashion Goto Version goto middle; loop: Body middle: if ( Test ) goto loop; Goto (Previous) Version if (! Test ) goto done; loop: Body if ( Test ) goto loop; done:

35 II:35 int fact_while(int x) { int result = 1; while (x > 1) { result *= x; x--; }; return result; } # x in %edx, result in %eax jmp.L34 # goto Middle.L35: # Loop: imull %edx, %eax # result *= x decl %edx # x--.L34: # Middle: cmpl $1, %edx # x:1 jg.L35 # if >, goto Loop Jump-to-Middle Example

36 II:36 Summary Do-While loop While-Do loop C Code do Body while ( Test ); Goto Version loop: Body if ( Test ) goto loop While version while ( Test ) Body Do-While Version if (! Test ) goto done; do Body while( Test ); done: Goto Version if (! Test ) goto done; loop: Body if ( Test ) goto loop; done: goto middle; loop: Body middle: if ( Test ) goto loop; or

37 II:37 “For” Loop Example: Square-and-Multiply Algorithm  Exploit bit representation: p = p 0 + 2p 1 + 2 2 p 2 + … 2 n–1 p n–1  Gives: x p = z 0 · z 1 2 · (z 2 2 ) 2 · … · (…((z n –1 2 ) 2 )…) 2 z i = 1 when p i = 0 z i = x when p i = 1  Complexity O(log p) /* Compute x raised to nonnegative power p */ int ipwr_for(int x, unsigned p) { int result; for (result = 1; p != 0; p = p>>1) { if (p & 0x1) result *= x; x = x*x; } return result; } n–1 times Example 3 10 = 3 2 * 3 8 = 3 2 * ((3 2 ) 2 ) 2

38 II:38 ipwr Computation /* Compute x raised to nonnegative power p */ int ipwr_for(int x, unsigned p) { int result; for (result = 1; p != 0; p = p>>1) { if (p & 0x1) result *= x; x = x*x; } return result; } before iteration resultx=3p=10 1 1310=1010 2 2 195= 101 2 3 9812= 10 2 4 965611= 1 2 5 59049430467210

39 II:39 “For” Loop Example for ( Init ; Test ; Update ) Body int result; for (result = 1; p != 0; p = p>>1) { if (p & 0x1) result *= x; x = x*x; } General Form Init result = 1 Test p != 0 Update p = p >> 1 Body { if (p & 0x1) result *= x; x = x*x; }

40 II:40 “For”  “While”  “Do-While” for ( Init ; Test ; Update ) Body Init ; while ( Test ) { Body Update ; } Goto Version Init ; if (! Test ) goto done; loop: Body Update ; if ( Test ) goto loop; done: While Version For Version Do-While Version Init ; if (! Test ) goto done; do { Body Update ; } while ( Test ) done:

41 II:41 For-Loop: Compilation #1 for ( Init ; Test ; Update ) Body Goto Version Init ; if (! Test ) goto done; loop: Body Update ; if ( Test ) goto loop; done: For Version for (result = 1; p != 0; p = p>>1) { if (p & 0x1) result *= x; x = x*x; } result = 1; if (p == 0) goto done; loop: if (p & 0x1) result *= x; x = x*x; p = p >> 1; if (p != 0) goto loop; done:

42 II:42 “For”  “While” (Jump-to-Middle) for ( Init ; Test ; Update ) Body Init ; while ( Test ) { Body Update ; } Init ; goto middle; loop: Body Update ; middle: if ( Test ) goto loop; done: While Version For Version Goto Version

43 II:43 For-Loop: Compilation #2 for ( Init ; Test ; Update ) Body Init ; goto middle; loop: Body Update ; middle: if ( Test ) goto loop; done: For Version Goto Version for (result = 1; p != 0; p = p>>1) { if (p & 0x1) result *= x; x = x*x; } result = 1; goto middle; loop: if (p & 0x1) result *= x; x = x*x; p = p >> 1; middle: if (p != 0) goto loop; done:

44 II:44 Switch Statement Example Multiple case labels  Here: 5, 6 Fall through cases  Here: 2 Missing cases  Here: 4 long switch_eg (long x, long y, long z) { long w = 1; switch(x) { case 1: w = y*z; break; case 2: w = y/z; /* Fall Through */ case 3: w += z; break; case 5: case 6: w -= z; break; default: w = 2; } return w; }

45 II:45 Jump Table Structure Code Block 0 Targ0: Code Block 1 Targ1: Code Block 2 Targ2: Code Block n–1 Targn-1: Targ0 Targ1 Targ2 Targn-1 jtab: target = JTab[x]; goto *target; switch(x) { case val_0: Block 0 case val_1: Block 1 case val_n-1: Block n–1 } Switch Form Approximate Translation Jump Table Jump Targets +4...

46 II:46 Switch Statement Example Setup: switch_eg: pushl %ebp# Setup movl %esp, %ebp# Setup pushl %ebx# Setup movl $1, %ebx# w = 1 movl 8(%ebp), %edx# edx = x movl 16(%ebp), %ecx# ecx = z cmpl $6, %edx# x:6 ja.L61# if > goto default jmp *.L62(,%edx,4)# goto JTab[x] long switch_eg(long x, long y, long z) { long w = 1; switch(x) {... } return w; } Indirect jump Jump table.section.rodata.align 4.L62:.long.L61 # x = 0.long.L56 # x = 1.long.L57 # x = 2.long.L58 # x = 3.long.L61 # x = 4.long.L60 # x = 5.long.L60 # x = 6

47 II:47 Assembly Setup Explanation Table Structure  Each target requires 4 bytes  Base address at.L62 Jumping Direct: jmp.L61  Jump target is denoted by label.L61 Indirect: jmp *.L62(,%edx,4)  Start of jump table:. L62  Must scale by factor of 4 (labels have 32-bit = 4 Bytes on IA32)  Fetch target from effective Address. L61 + edx*4  Only for 0  x  6.section.rodata.align 4.L62:.long.L61 # x = 0.long.L56 # x = 1.long.L57 # x = 2.long.L58 # x = 3.long.L61 # x = 4.long.L60 # x = 5.long.L60 # x = 6 Jump table

48 II:48 Jump Table.section.rodata.align 4.L62:.long.L61 # x = 0.long.L56 # x = 1.long.L57 # x = 2.long.L58 # x = 3.long.L61 # x = 4.long.L60 # x = 5.long.L60 # x = 6 Jump table switch(x) { case 1: //.L56 w = y*z; break; case 2: //.L57 w = y/z; /* Fall Through */ case 3: //.L58 w += z; break; case 5: case 6: //.L60 w -= z; break; default: //.L61 w = 2; }

49 II:49 Code Blocks (Partial).L61: // Default case movl $2, %ebx # w = 2 movl %ebx, %eax # Return w popl %ebx leave ret.L57: // Case 2: movl 12(%ebp), %eax # y cltd # Div prep idivl %ecx # y/z movl %eax, %ebx # w = y/z # Fall through.L58: // Case 3: addl %ecx, %ebx # w+= z movl %ebx, %eax # Return w popl %ebx leave ret switch(x) {... case 2: //.L57 w = y/z; /* Fall Through */ case 3: //.L58 w += z; break;... default: //.L61 w = 2; }

50 II:50 IA32 Object Code Setup  Label.L61 becomes address 0x8048630  Label.L62 becomes address 0x80488dc 08048610 :... 8048622: 77 0c ja 8048630 8048624: ff 24 95 dc 88 04 08 jmp *0x80488dc(,%edx,4) switch_eg:... ja.L61# if > goto default jmp *.L62(,%edx,4)# goto JTab[x] Assembly Code Disassembled Object Code

51 II:51 Types of jumps Direct jump  Absolute jump je $0x00804000  PC relative jump je $14 je $-14 Indirect jump jmp %eax jmp 8(%eax) jmp (%eax, %ebx, 4)

Download ppt "II:1 x86 Assembly - Control. II:2 Alternate reference source Go to the source: Intel 64 and IA32 "

Similar presentations

Fabián E. Bustamante, Spring 2007 Machine-Level Programming II: Control Flow Today Condition codes Control flow structures Next time Procedures.

Fabián E. Bustamante, Spring 2007 Machine-Level Programming II: Control Flow Today Condition codes Control flow structures Next time Procedures.
1 Carnegie Mellon Machine-Level Programming II: Arithmetic & Control 15-213 / 18-213: Introduction to Computer Systems 6 th Lecture, Jan 29, 2015 Carnegie.

1 Carnegie Mellon Machine-Level Programming II: Arithmetic & Control / : Introduction to Computer Systems 6 th Lecture, Jan 29, 2015 Carnegie.
MACHINE-LEVEL PROGRAMMING II: ARITHMETIC & CONTROL.

MACHINE-LEVEL PROGRAMMING II: ARITHMETIC & CONTROL.
University of Washington Announcements Lab 1 due last night Lab 2 release soon HW1 due Monday night 1.

University of Washington Announcements Lab 1 due last night Lab 2 release soon HW1 due Monday night 1.
1 Carnegie Mellon Machine-Level Programming II: Arithmetic & Control 15-213 / 18-213: Introduction to Computer Systems 6 th Lecture, May 28, 2015 Carnegie.

1 Carnegie Mellon Machine-Level Programming II: Arithmetic & Control / : Introduction to Computer Systems 6 th Lecture, May 28, 2015 Carnegie.
Machine-Level Programming II: Control Flow Today Condition codes Control flow structures Next time Procedures.

Machine-Level Programming II: Control Flow Today Condition codes Control flow structures Next time Procedures.
Machine-Level Programming II: Control Flow Sept. 12, 2002 Topics Condition Codes Setting Testing Control Flow If-then-else Varieties of Loops Switch Statements.

Machine-Level Programming II: Control Flow Sept. 12, 2002 Topics Condition Codes Setting Testing Control Flow If-then-else Varieties of Loops Switch Statements.
Machine-Level Programming II Control Flow Sept. 13, 2001 Topics Condition Codes –Setting –Testing Control Flow –If-then-else –Varieties of Loops –Switch.

Machine-Level Programming II Control Flow Sept. 13, 2001 Topics Condition Codes –Setting –Testing Control Flow –If-then-else –Varieties of Loops –Switch.
Machine-Level Programming II: Control Flow September 1, 2008 Topics Condition Codes Setting Testing Control Flow If-then-else Varieties of Loops Switch.

Machine-Level Programming II: Control Flow September 1, 2008 Topics Condition Codes Setting Testing Control Flow If-then-else Varieties of Loops Switch.
1 Introduction to x86 Assembly, part II or “What does my laptop actually do?” Ymir Vigfusson Some slides gracefully borrowed from

1 Introduction to x86 Assembly, part II or “What does my laptop actually do?” Ymir Vigfusson Some slides gracefully borrowed from
Machine-Level Programming 3 Control Flow Topics Control Flow Switch Statements Jump Tables.

Machine-Level Programming 3 Control Flow Topics Control Flow Switch Statements Jump Tables.
Machine-Level Programming II: Control Flow Topics Condition codes Conditional branches Loops Switch statements CS 105 “Tour of the Black Holes of Computing”

Machine-Level Programming II: Control Flow Topics Condition codes Conditional branches Loops Switch statements CS 105 “Tour of the Black Holes of Computing”
1 Carnegie Mellon Machine-Level Programming II: Arithmetic & Control 15-213: Introduction to Computer Systems 5 th Lecture, Sep. 7, 2010 Carnegie Mellon.

1 Carnegie Mellon Machine-Level Programming II: Arithmetic & Control : Introduction to Computer Systems 5 th Lecture, Sep. 7, 2010 Carnegie Mellon.
1 Seoul National University Machine-Level Programming II: Arithmetic & Control.

1 Seoul National University Machine-Level Programming II: Arithmetic & Control.
University of Washington x86 Programming III The Hardware/Software Interface CSE351 Winter 2013.

University of Washington x86 Programming III The Hardware/Software Interface CSE351 Winter 2013.
Machine-Level Programming III: Switch Statements and IA32 Procedures Seoul National University.

Machine-Level Programming III: Switch Statements and IA32 Procedures Seoul National University.
Machine-Level Programming V: Switch Statements Comp 21000: Introduction to Computer Systems & Assembly Lang Systems book chapter 3* * Modified slides from.

Machine-Level Programming V: Switch Statements Comp 21000: Introduction to Computer Systems & Assembly Lang Systems book chapter 3* * Modified slides from.
1 Machine-Level Programming III: Arithmetic & Condition Codes Comp 21000: Introduction to Computer Organization & Systems March 2015 Systems book chapter.

1 Machine-Level Programming III: Arithmetic & Condition Codes Comp 21000: Introduction to Computer Organization & Systems March 2015 Systems book chapter.
1 Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition Carnegie Mellon Machine-Level Programming II: Control 15-213: Introduction.

1 Bryant and O’Hallaron, Computer Systems: A Programmer’s Perspective, Third Edition Carnegie Mellon Machine-Level Programming II: Control : Introduction.
Machine-Level Programming II: Control Flow Topics Condition Codes Setting Testing Control Flow If-then-else Varieties of loops Switch statements CS 105.

Machine-Level Programming II: Control Flow Topics Condition Codes Setting Testing Control Flow If-then-else Varieties of loops Switch statements CS 105.

Similar presentations

Ads by Google