Assembly ARM. Execution flow MIPS. Calcolatori Elettronici e Sistemi Operativi. Examples MAX2 MAX3. return maximum between 2 integers

Transcription

1 Calcolatori Elettronici e Sistemi Operativi ARM Registers rules (ARM Procedure Call Standard [APCS]): name register use Assembly R0 <--> R0 function result (on function return) and first argument (on function entry) R1 <--> R1 second function argument (caller saved) R2 <--> R2 third function argument function argument (caller saved) R3 <--> R3 forth function argument function argument (caller saved) R4 <--> R4 local variable (callee saved) R8 <--> R9 local variable (callee saved) R9 <--> R9 local variable (callee saved) (or platform ecific data as base [static]) R10 <--> R10 local variable (callee saved) (or platform ecific data as limit [static]) <--> R11 pointer ip <--> R12 intra-procedure call scratch (can be used for local vars) <--> R13 pointer lr <--> R14 return address (HW) pc <--> R15 program counter (HW) Arguments above 4th: on MIPS Execution flow Registers rules (MIPS call convention): nome registro uso tipico zero <--> R0 0 (HW constant) at <--> R1 v0 <--> R2 function result (lowest 32 bits) v1 <--> R3 function result (highestest 32 bits, if needed) a0 <--> R4 first function argument a1 <--> R5 second function argument a2 <--> R6 third function argument a3 <--> R7 forth function argument t0 <--> R8 temporary (not saved) t7 <--> R15 temporary (not saved) s0 <--> R16 temporary (saved) s7 <--> R23 temporary (saved) t8 <--> R24 temporary (not saved) t9 <--> R25 temporary (not saved) k0 <--> R26 reserved for kernel k1 <--> R27 reserved for kernel Arguments above 4th: on gp <--> R28 global data pointer <--> R29 pointer <--> R30 pointer ra <--> R31 return address (HW) Examples MAX2 return maximum between 2 integers MAX3 return maximum among 3 integers

2 MAX2: ARM - (1) MAX2: ARM - (2) int max2(int a, int b) if (a>b) return a; else return b; max2:.global max2.type max2, %function // not mandatory cmp r0, r1 // if a>b ble ELSE int max2(int a, int b) if (a>b) return a; else return b; max2:.global max2.type max2, %function // not mandatory cmp r0, r1 // if a>b bgt ENDF // return a not needed THEN: // unused label mov r0, r0 // return a mov pc, lr ENDF: mov r0, r1 // else return b mov pc, lr return to caller ELSE: mov r0, r1 // return b mov pc, lr MAX2: ARM - (3) ARM condition suffixes int max2(int a, int b) if (a>b) return a; else return b; max2: conditional execution.global max2.type max2, %function // not mandatory cmp r0, r1 // if! a>b movle r0, r1 // return b mov pc, lr Main mnemonics EQ: equal NE: not equal LT: less than (for signed values) LE: less or equal (for signed values) GT: greater than (for signed values) GE: greater or equal (for signed values) HI: greater than (for unsigned values) LS: less or equal (for unsigned values)

3 MAX2: MIPS - (1) MAX2: MIPS - (2) int max2(int a, int b) if (a>b) return a; else return b; max2:.set noreorder.globl max2 slt $t0, $a1, $a0 // t0 <- (a>b) beq $t0, $zero, ELSE int max2(int a, int b) if (a>b) return a; else return b; max2:.set noreorder.globl max2 slt $t0, $a1, $a0 // t0 <- (a>b) beq $t0, $zero, ELSE THEN: // unused label move $v0, $a0 // return a ($v0<-$a0) // ELSE: move $v0, $a1 // return b ($v0<-$a1) // use delay slot THEN: // unused label // move $v0, $a0 // return a ($v0<-$a0) ELSE: // move $v0, $a1 // return b ($v0<-$a1) zero <--> R0 0 (costant) at <--> R1 v0 <--> R2 retval (LO) v1 <--> R3 retval (HI) a0 <--> R4 arg 1 a1 <--> R5 arg 2 zero <--> R0 0 (costant) at <--> R1 v0 <--> R2 retval (LO) v1 <--> R3 retval (HI) a0 <--> R4 arg 1 a1 <--> R5 arg 2 MAX2: MIPS - (3) MAX2: MIPS - (3) int max2(int a, int b) if (a>b) return a; else return b; max2:.set noreorder.globl max2 slt $t0, $a1, $a0 // t0 <- (a>b) bne $t0, $zero, ENDF move $v0, $a0 // return a ($v0<-$a0) int max2(int a, int b) if (a>b) return a; else return b; max2:.set noreorder.globl max2 slt $8, $5, $4 // t0 <- (a>b) bne $8, $0, ENDF move $2, $4 // return a ($v0<-$a0) use delay slot ENDF: move $v0, $a1 // return b ($v0<-$a1) // use delay slot ENDF: move $2, $5 // return b ($v0<-$a1) j $31 // zero <--> R0 0 (costant) at <--> R1 v0 <--> R2 retval (LO) v1 <--> R3 retval (HI) a0 <--> R4 arg 1 a1 <--> R5 arg 2 zero <--> R0 0 (costant) at <--> R1 v0 <--> R2 retval (LO) v1 <--> R3 retval (HI) a0 <--> R4 arg 1 a1 <--> R5 arg 2 Explicit register names

4 MAX3 - (1) MAX3 - (2) int max3a(int a, int b, int c) if (a>b) if (a>c) return a; else return c; else if (b>c) return b; else return c;.global max3 ARM max3: cmp r0, r1 // if a>b ble ELSE THEN: // unused label cmp r0, r2 movlt r0, r2 // if! a>c r0 <- c mov pc, lr // return (res. in r0) ELSE: cmp r1, r2 movge r0, r1 // if b >= c r0 <- b movlt r0, r2 // if b < c r0 <- c mov pc, lr // return (res. in r0).set noreorder.globl max3 MIPS max3: slt $t0, $a1, $a0 //t0 <- (a>b) (1) beq $t0, $zero, ELSE1 THEN1 // unused label slt $t0, $a2, $a0 //t0 <- (a>c) (2) beq $t0, $zero, ELSE2 THEN2: // unused label move $v0, $a0 //return a ELSE2: move $v0, $a2 //return c ELSE1: slt $t0, $a2, $a1 //t0 <- (b>c) (3) beq $t0, $zero, ELSE3 THEN3: // unused label move $v0, $a1 //return b ELSE3: move $v0, $a2 //return c int max3a(int a, int b, int c) /* m = MAX(a,b) */ /* return MAX(m,c) */ int m; if (a>b) m=a; else m=b; if (m>c) return m; else return c;.global max3 max3: cmp r0, r1 movlt r0, r1 // r0 <- max(a,b) cmp r0, r2 movlt r0, r2 // r0 <- max(r0,c) mov pc, lr // return ARM.set noreorder.globl max3 MIPS max3: slt $t0, $a1, $a0 // t0 <- (a>b) beq $t0, $zero, M1 move $v0, $a1 move $v0, $a0 // $v0 <- max(a,b) M1: slt $t0, $a2, $v0 // t0 <- (v0>c) bne $t0, $zero, ENDF // move $v0, $v0 move $v0, $a2 // $v0 <- max(v0,c) ENDF: Arrays and ARM Addressing Modes Examples strcpy uses strings factorial function (recursive) call Mul function call mcd function call LDMDA (Decrement After) <==> LDMFA (Full Ascending) LDMIA (Increment After) <==> LDMFD (Full Descending) LDMDB (Decrement Before) <==> LDMEA (Empty Ascending) es. ldmdb,, <==> ldmea,, LDMIB (Increment Before) <==> LDMED (Empty Descending) STMDA (Decrement After) <==> STMED (Empty Descending) STMIA (Increment After) <==> STMEA (Empty Ascending) STMDB (Decrement Before) <==> STMFD (Full Descending) es. stmdb!,, <==> stmfd!,, STMIB (Increment Before) <==> STMFA (Full Ascending)

5 Stack ARM Addressing Modes r15 (pc) r15 (pc) r15 (pc) Full Descending Empy Descending Empty Ascending ST: decrement before LD: increment after STMFD LDMFD STMDB LDMIA ST: decrement after LD: increment before STMED LDMED STMDA LDMIB ST: increment after LD: decrement before STMEA LDMEA STMIA LDMDB r15 (pc) Full Ascending ST: increment before LD: decrement after STMFA LDMFA STMIB LDMDA stmfd!,,,, ip, lr stmfd: store multiple full-descending (decrement before) start address = (5 registers to store)! update index register = save from here saving order is fixed (registers are saved in increasing order) and cannot be varied e.g.: stmfd!,, is not valid ARM Addressing Modes ARM Addressing Modes stmfd!,,,, ip, lr full-descending (decrement before) start address = (5 registers to store) restore from here stmfd!,,,, ip, lr full-descending (decrement before) start address = (5 registers to store) restore from here ldmfd!,,,, ip, lr full-descending (increment after) start address = = ldmea,,,, ip, lr empty-ascending (decrement before) start address = (5 registers to restore) fixed ( can change during the execution)

6 ARM ARM: function prologue/epilogue No allocation: local vars in r0-r3 - no other functions called increasing addresses local variables saved changed registers local-1 local-2 local-3 -r10 (if changed) (old) lr caller (after allocation) (on entry) Registers lr must be saved if another function is called. For -r14, only actually modified registers are saved. Registers r1-r3 must not be saved. Register r0 is the return value. Function arguments above fourth are in the caller. mov pc, lr return to caller Stack allocation (to save local registers): local vars in r0-r6 (with or without functions calling) stmfd!,,, r6, lr ldmfd!,,, r6, pc save data (,, r6 are used by function save) restore registers and return to caller Position of is not a standard r6 lr ARM: function prologue/epilogue ARM: function prologue/epilogue Stack allocation: local vars in r0- and on stmfd!,,, lr sub,, #4 add,, #4 ldmfd!,,, pc str lr, [, #-4]! ldr pc, [], #4 local-1 lr save data (, are used by function save) allocate room on (4 bytes in this example) unroll restore registers and return to caller Stack allocation (save lr only): local vars in r0-r3 another function is called save lr return to caller Stack allocation (save local registers, make room for other local variables, use the pointer) mov ip, stmfd!,,,, lr sub, ip, #0 sub,, #8 ( may change) add,, #8 ldmfd!,,,, pc ip can be used as a scratch register on function enter save current value of save data (, are used by function save) compute the - address allocate local variables restore registers local2 local1 : restore old pointer lrpc: return to caller

7 ARM: function prologue/epilogue Stack allocation (save local registers, make room for other local variables, use the pointer) mov ip, stmfd!,,,, lr sub, ip, #4 sub,, #8 ( may change) add,, #8 ldmfd!,,,, pc save current value of save data (, are used by function save) compute the - address allocate local variables restore registers : restore old pointer lrpc: return to caller ARM: function prologue/epilogue Stack allocation (save local registers, make room for other local variables, use the pointer) stmfd!,,,, lr add,, #16 sub,, #8 ( may change) add,, #8 ldmfd!,,,, pc save data (, are used by function save) compute the - address allocate local variables restore registers : restore old pointer lrpc: return to caller local2 local1 local2 local1 ip can be used as a scratch register on function enter Rules for can differ (e.g., point to the upper used location) Using : local variables are at fixed offsets from (local1: [-20] local2: [-24]) ARM: post/pre - increment/decrement MIPS Access with no pointer changes: ldr / ldrb / str / strb Rd, [Rs, #offset] Example: ldr R4, [R6, #20] -- R4 <= MEM[R6+20] Access with pre-change on pointer ldr / ldrb / str / strb Rd, [Rs, #offset]! Example: ldr R2, [R1, #4]! -- R1 <= R1+4 ; R2 <= MEM[R1] Access with post-change on pointer ldr / ldrb / str / strb Rd, [Rs], #offset increasing addresses outgoing arguments ptr to global data local vars saved registers input arguments arg 1 arg 2 arg 3 arg 4 arg 5 global ptr local 1 local 2 s0-s7 ra arg 1 arg 2 (after allocation) (on entry) The must be 8-byte aligned can be used as pointer. Outgoing args (if needed): args passed in registers are not written on by the caller (but room is allocated). Ptr to global: not mandatory if not changed Space for local vars is 8-byte aligned Space for saved registers is 8-byte aligned Other blocks can be 8-byte aligned (not mandatory) Space for s0-s7 must be reserved and used only for registers actually modified. ra must be saved for non-leaf functions. Example: ldrb R7, [R0], #4 -- R7(lsb) <= MEM[R0] ; R0 <= R0+4 Position of is not a standard.

8 MIPS: function prologue/epilogue MIPS: function prologue/epilogue No allocation: local vars in $t0-$t9 (and $a0-$a3, $v0, $v1) - no other functions called return to caller Stack allocation (to save local registers): a local var in $s0 - no other functions called Stack allocation: other functions called subu $,$,24 sw $ra,20($) lw $ra,20($) addu $,$,24 allocate (8-byte aligned) save $ra restore $ra return to caller and restore $ Stack allocation: save a local register ($s0) - other functions called arg 1 arg 2 arg 3 arg 4 $ra subu $,$,8 sw $s0,4($) lw $s0,4($) addu $,$,8 allocate (8-byte aligned) save $s0 restore registers return to caller and restore $ padding $s0 subu $,$,24 sw $ra,20($) sw $s0,16($) lw $ra,20($) lw $s0,26($) addu $,$,24 allocate (8-byte aligned) save registers restore registers return to caller and restore $ arg 1 arg 2 arg 3 arg 4 $s0 $ra MIPS: function prologue/epilogue MIPS: memory access Stack allocation: save a local register ($s0) use locals on - other functions called subu $,$,32 sw $ra,28($) sw $s0,24($) local_var is 24($) lw $ra,28($) lw $s0,24($) addu $,$,32 using a pointer: subu $,$,40 sw $,32($) move $,$ sw $ra,36($) sw $s0,28($) local_var is 20($) lw $ra,36($) lw $,32($) lw $s0,28($) addu $,$,40 allocate (8-byte aligned) save registers restore registers return to caller and restore $ allocate and set ptr save registers restore registers return to caller and restore $ arg 1 arg 2 arg 3 arg 4 local_var $s0 $ra arg 1 arg 2 arg 3 arg 4 local_var $s0 $ $ra lw / lb / sw / sb $Rd, offset($rs) Examples: lw $a0, 12($a4) -- $a0 <= MEM[$a4+12] lb $a3, 0($a2) -- $a3(lsb) <= MEM[$a2] sw $v1, 4($t0) -- MEM[$t0+4] <= $v1 A cycle delay is needed before loaded data are ready (use to avoid hazards)

9 strcpy: C strcpy: ARM assembly void my_strcpy(char *dest, char *src) while (*src) *(dest++) = *(src++); *dest=0; on function entry: r0 = dest r1 = src on function entry: r0 = dest r1 = src setup local_1 <= r0 [dest] local_2 <= r1 [src] if (*local_2 == 0) goto endloop *local_1 <= *local_2 local_1++ local_2++ goto loop end *local_1 <= 0 return (restore ) setup local_1 <- r0 local_2 <- r1 r1 <- local_2 ; r2 <- MEM[r1] ; if (r2== 0) goto endloop r1 <- local_1 ; r2 <- local_2 ; r3 <- MEM[r2] ; MEM[r1] <- r3 r1++ ; local_1 <- r1 ; r2++ ; local_2 <- r2 goto loop end r1 <-local_1 ; r2 <- 0 ; MEM[r1] <- r2 return (restore ) strcpy: ARM assembly strcpy: ARM assembly using local vars allocate choice: use pointer save on : ( pointer of caller) lr return address (not really needed, since there are no function calls) allocate on : local1 local2 stmfd!,, lr ; save on regs that will be modified add,, #8 ; compute (base of ) sub,, #8 ; reserve room on for local vars ; (8 bytes) ; local_1: MEM[-12] local_2: MEM[-16] str r0, [, #-12] ; local_1 <- dest (dest is in r0) str r1, [, #-16] ; local_2 <- src (src is in r1) ldr r1, [, #-16] ; r1 <- local_2 ldrb r2, [r1, #0] ; r2 <- *local_2 cmp r2, #0 ; compare *local_2 and 0 beq endloop ; jump to endloop label local2 local

10 strcpy: ARM assembly strcpy: ARM assembly (opt) ldr r2, [, #-16] ; r2 <- local_2 ldr r1, [, #-12] ; r1 <- local_1 ldrb r3, [r2, #0] ; r3 <- MEM[r2] (r3 <- *local_2 ; load only one byte) strb r3, [r1, #0] ; MEM[r1] <- r3 (*local_1 <- *local_2 ; write only one byte) add r1, r1, #1 ; r1 <- r1+1 (r1 <- local_1+1) str r1, [, #-12] ; local_1 <- r1 (update local_1) add r2, r2, #1 ; r2 <- r2+1 (r2 <- local_2+1) str r2, [, #-16] ; local_2 <- r2 (update local_2) b loop ; jump back to loop end ldr r1, [, #-12] ; r1 <- MEM[-12] (r1 <- local_1) mov r2, #0 ; r2 <- 0 strb r2, [r1, #0] ; MEM[r1] <- r2 (*local_1 <- 0) return: add,, #8 ; delete local vars ldmfd!,, pc ; restore registers from ; (pc is loaded with the previous value ; of lr) on function entry: r0 = dest r1 = src setup if (*r1 == 0) goto endloop r0++ <= r3 r3 <= *(++r1) if (r3!=0) goto loop end *r0 <= 0 return (restore ) on function entry: r0 = dest r1 = src setup r3 <- MEM[r1] ; if (r3 == 0) goto endloop MEM[r0++] <- r3 r3 <- MEM[++r1] if (r3!=0) goto loop end r3 <- 0 ; MEM[r0] <- r3 return (restore ) strcpy: ARM assembly (opt) strcpy: MIPS assembly ldrb r3, [r1, #0] ; r3 <- MEM[r1] (r3 <- *src) cmp r3, #0 ; compare *src and 0 beq endloop ; if r3==0 jump to endloop label strb r3, [r0], #1 ; MEM[r0] <- r3 ; r0 <- r0 + 1 (*(dest++) <-r3 ) ldrb r3, [r1, #1]! ; r3 <- MEM[r1+1] ; r1<-r1+1 (r3 <- *++src) cmp r3, #0 ; compare r3 and 0 bne loop ; if r3!= 0 jump back to loop label end strb r3, [r0, #0] ; MEM[r0] <- r3 (*dest <- 0; here, r3 contains 0) mov pc, lr ; return choice: save args on choice: use pointer save on : ( pointer of caller) save on : dest ($a0) src ($a1) no local vars, no function calls is not required function arguments dest src

11 strcpy: MIPS assembly strcpy: MIPS assembly subu $,$,8 ; reserve room on (8 bytes: and ra) sw $,0($) ; save move $,$ ; <- sw $a0,8($) ; save first function argument (in MEM[+8]) sw $a1,12($) ; save second function argument (in MEM[+12]) lw $v0,12($) ; v0 <- src ; wait for memory read lb $v1,0($v0) ; v1 <- *src ; wait for memory read beq $v1,$zero,endloop ; if v1==0 jump to endloop label ; delay slot (jump slot) saved registers function arguments ra dest src dest: +8 src: +12 lw $a0,12($) ; a0 <- src lw $v0,8($) ; v0 <- dest lbu $a3,0($a0) ; a3 <- *src (load one byte) sb $a3,0($v0) ; *dest <- a3 (*dest <- *src write one byte) addu $a0,$a0,1 ; a0 <- a0+1 sw $a0,12($) ; src <- a0 (src++) addu $v0,$v0,1 ; v0 <- v0+1 sw $v0,8($) ; dest <- v0 (dest++) j loop ; jump back to loop label end lw $v0,8($) ; v0 <- dest sb $zero,0($v0) ; *dest <- 0 return: move $,$ ; restore lw $,0($) ; restore from addu $,$,8 ; free memory used reserved for local variables ; return strcpy: MIPS assembly (opt) ARM: multiplication / division lb $v0,0($a1) ; v0 <- MEM[a1] (v0 <- *src) beq $v0,$zero,endloop ; if se v0==0 jump to endloop addu $a1,$a1,1 ; a1 <- a1+1 (src++) (use delay slot) sb $v0,0($a0) ; MEM[a0] <- v0 (*dest <- v0) j loop ; jump back to loop addu $a0,$a0,1 ; a0 <- a0+1 (dest++) (use delay slot) end ; return sb $zero,0($a0) ; *dest <- 0 (use delay slot) Multiplication: instruction mul mul R0, R1, R2 -- R0 <= R1*R2 Division/module: functions ( divsi3 and modsi3) res = divsi3(a,b) -- res <= a/b mov R0, dividend mov R0, dividend mov R1, divisor mov R1, divisor bl divsi3 bl modsi3 -- in R0 the division result -- in R0 the module

12 MIPS: multiplication / division factorial: C Multiplication: instruction mult 64-bit result in ecial registers hi and low mult $a0,$v1 mflo $a1 -- $a1 <= $a0 * $v1 (32 low bits) int factorial(int n) if (n<0) return 0; else if (n==0) return 1; else return n*factorial(n-1); Division/module: instruction div Division result in lo, module in hi div $t8,$t1 mflo $a1 -- $a1 <= $t8 / $t1 mfhi $a2 -- $a2 <= $t8 % $t1 factorial: ARM assembly factorial: MIPS assembly factorial: stmfd!,, lr ; save registers ( will be used) subs, r0, #0 ; <- r0-0 and set flags movlt r0, #0 ; if r0-0 < 0 (last operation that set flags) r0<-0 ldmltfd!,, pc ; if r0-0 < 0 (last operation that set flags) restore ; registers e return compute: beq return ; if r0-0 = 0 jump to return sub r0,, #1 ; r0 <- -1 (argument for the next ; function call) bl factorial ; recursive function call mul r0,, r0 ; r0 <- r0 (compute the result to return) ldmfd!,, pc ; restore registers and return return: mov r0, #1 ; r0 <- 1 ldmfd!,, pc ; restore registers and return factorial: subu $,$,24 ; reserve room ; (memory for ra, s0, arguments for called f [4 word]) function arguments n arguments for called function saved registers function arguments n s0 ra n

13 factorial: MIPS assembly Mul: C factorial: subu $,$,24 ; reserve (room for ra, s0, args [4 word]) sw $s0,16($) ; save s0 (will be used) move $s0,$a0 ; s0 <- a0 (s0 <- n) bgez $s0,compute ; if s0>=0 jump to compute sw $ra,20($) ; save return address (use delay slot) j return ; jump to return move $v0,$zero ; v0 <- 0 (use delay slot) compute: beq $s0,$zero,return ; if s0==zero jump to return li $v0,1 ; v0 <- 1 (use delay slot) jal factorial ; recursive function call addu $a0,$s0,-1 ; a0 <- s0-1 (argument for the recursive function call) ; (use delay slot) mult $s0,$v0 ; <hi,lo> <- s0 v0 (hi e lo: ecial registers) mflo $v0 ; v0 <- lo return: lw $ra,20($) ; restore ra lw $s0,16($) ; restore s0 ; return addu $,$,24 ; free allocated ace ; (use delay slot) int Mul(unsigned int a, unsigned int b) if (b==0) return 0; else if (b==1) return a; else return a+mul(a,b-1); Mul: ARM assembly Mul: MIPS assembly Mul: stmfd!,, lr mov, r0 ; save r0 (r0 will be written by the recursive call) cmp r1, #0 ; b ==0? moveq r0, r1 ; return 0 ldmeqfd!,, pc cmp r1, #1 ; b==1? beq return ; return a (a is still in r0) sub r1, r1, #1 bl Mul ; r0 = Mul(a,b-1) add r0,, r0 ; r0 = r0+a return: ldmfd!,, pc ; return Mul: subu $,$,24 sw $s0,16($) move $s0,$a0 ; save a0 (a0 will be overwritten by the recursive call) sw $ra,20($) beq $a1,$zero,return ; b ==0? move $v0,$zero ; return 0 (use delay slot) li $v0,1 beq $a1,$v0,label ; b ==1? move $a0,$s0 ; return a (a is in s0) (use delay slot) jal Mul addu $a1,$a1,-1 ; v0 = Mul(a,b-1) (use delay slot) j return addu $v0,$s0,$v0 ; compute the return value: a+v0 (use delay slot) label: move $v0,$s0 return: lw $ra,20($) lw $s0,16($) addu $,$,24

14 mcd: C mcd: ARM assembly int mcd(int a, int b) if (b==0) return a; if (a>b) return mcd(b, a%b); else return mcd(a, b%a); tail-end recursion: can easily become a loop mcd: label: stmfd!,,, lr mov, r0 mov, r1 cmp, #0 moveq r0, ldmeqfd!,,, pc ; b==0? return a cmp, ; set flags movgt r0, movgt r1, movle r0, movle r1, ; r0=max(,) r1=min(,) movgt, ; =min(,) (for next computation iterations) bl modsi3 ; r0 = r0 % r1 mov, r0 ; = r0 % r1 b label ; recursion (with no function call: tail end recursion) ; loop computes mcd(,) Note: the library function " modsi3" computes the remainder between its two arguments mcd: MIPS assembly Reversing mcd_ricor: label_3: bne $a1,$zero,label_1 slt $v0,$a1,$a0 move $v0,$a0 label_1: beq $v0,$zero,label_2 div $zero,$a0,$a1 mfhi $v0 move $a0,$a1 j label_3 move $a1,$v0 ; a0=b; a1=a%b label_2: ; a1>=a0 div $zero,$a1,$a0 mfhi $v0 j label_3 move $a1,$v0 ; a0=a; a1=b%a Notes: 1. when a division is performed, the quotient is stored into the ecial register lo and the remainder is stored into the ecial register hi 2. the instruction mfhi loads the content of hi into the indicated general purpose register To inect: unkwnown1 ARM assembly unkwnown2 MIPS assembly

15 ?: ARM assembly?: MIPS assembly unknown1: ldrb r2, [r0], #1 ldrb r3, [r1], #1 cmp r2, #0 beq label_1 cmp r2, r3 beq unknown1 mvnls r0, #0 // ls: comparison result is < (unsigned values) movhi r0, #1 // hi: comparison result is > (unsigned values) mov pc, lr label_1: mvn r0, #0 // mvn: mov negated (mov r0, not #0) cmp r3, #0 moveq r0, #0 mov pc, lr unknown2: move $v0,$zero lbu $v1,0($a0) beq $v1,$zero,label_3 andi $a1,$a1,0x00ff label_1: bne $v1,$a1,label_2 addu $v0,$v0,1 label_2: addu $a0,$a0,1 lbu $v1,0($a0) bne $v1,$zero,label_1 label_3: