Last Time. Compiler requirements C preprocessor Volatile

Transcription

1 Last Time Compiler requirements C preprocessor Volatile

2 Today Coding and translation of interrupt handlers Coding inline assembly Compiler intrinsics

3 Interrupts 30-second interrupt review: Interrupts are a kind of asynchronous exception When some external condition becomes true, CPU jumps to the interrupt vector When interrupt returns, previously executing code resumes as if nothing happened With appropriate compiler support interrupts look just like regular functions Don t be fooled there are major semantic differences between interrupts and functions Interrupts are concurrent They don t obey the calling convention

4 ColdFire Interrupt declspec(interrupt) void rtc_handler(void) { MCF_GPIO_PORTTC ^= 0xf; }

5 Interrupt Assembly _rtc_handler1: 0x strldsr #0x2700 0x link a6,#0 0x A lea -12(a7),a7 0x E movem.l d0-d1/a0,(a7) 0x lea IPSBAR ,a0 0x move.b (a0),d1 0x A moveq #0,d0 0x C move.b d1,d0 0x E eori.l #0xf,d0 0x move.b d0,(a0) 0x movem.l (a7),d0-d1/a0 0x A unlk a6 0x C addq.l #4,a7 0x E rte

6 ARM / GCC Interrupt void attribute ((interrupt("irq"))) tc0_cmp (void); { timeval++; VICVectAddr = 0; } Other embedded compilers provide analogous extensions Later lectures: correct usage of interrupts

7 Inline Assembly Two reasons to add assembly into a C program: 1. Need to say something that can t be said in C 2. Need higher performance than the C compiler provides In both cases Write most of a function in C and then throw in a few instructions of assembly where needed Let the compiler do the grunt work of respecting the calling convention When writing asm to increase performance: Be absolutely sure you identified the culprit First try to write faster C

8 CodeWarrior Inline Asm long square (short a) { long result=0; asm { move.w a,d0 // fetch function argument a mulu.w d0,d0 // multiply move.l d0,result // store in local result } return result; } Compiler generates glue code integrating the assembler and C code

9 Inline Assembly Example square: 0x link a6,#0 0x subq.l #8,a7 0x move.w d0,-8(a6) 0x A clr.l -6(a6) 0x E move.w -8(a6),d0 0x mulu.w d0,d0 0x move.l d0,-6(a6) 0x move.l -6(a6),d0 0x C unlk a6 0x E rts

10 GCC Inline Assembly Format: asm volatile (code : outputs : inputs : clobbers ); Code instructions Outputs maps results of instructions into C variables Inputs maps C variables to inputs of instructions Clobbers tells the compiler to forget the contents of some registers This syntax is much more difficult to use than CodeWarrior s!

11 Intrinsics Intrinsic functions are built in to the compiler As opposed to living in a library somewhere Why do compilers support intrinsics? Efficiency can perform interesting optimizations Ease of use Compile can add function calls where they do not exist in your code Compiler can eliminate library calls in your code Need to be careful when compiler inserts function calls for you performance of resulting code may be bad

12 Intrinsic Example 1 int smul (int x, int y) { return x*y; } ColdFire code: _smul: 0x link a6,#0 0x muls.l d1,d0 0x unlk a6 0x A rts

13 More Example 1 ARM7 smul: mul bx lr r0, r1, r0 AVR smul: rcall mulhi3 ret

14 Intrinsic Example 2 int sdiv (int x, int y) { return x/y; } ColdFire code: _sdiv: 0x link a6,#0 0x divs.l d1,d0 0x unlk a6 0x A rts

15 More Example 2 On ARM7 sdiv: str lr, [sp, #-4]! bl divsi3 ldr pc, [sp], #4 On AVR sdiv: rcall divmodhi4 mov r25,r23 mov r24,r22 ret

16 Example 3 struct foo { int x, y[3]; double z; }; void struct_copy2 (struct foo *a, struct foo *b) { *a=*b; } ColdFire code: struct_copy2: 0x link a6,#0 0x moveq #6,d1 0x move.w (a1),(a0) 0x move.w 2(a1),2(a0) 0x E addq.l #4,a1 0x addq.l #4,a0 0x subq.l #1,d1 0x bne.s *-14 0x unlk a6 0x rts

17 More Example 3 On ARM7 struct_copy2: str lr, [sp, #-4]! mov lr, r1 mov ip, r0 ldmia lr!, {r0, r1, r2, r3} stmia ip!, {r0, r1, r2, r3} ldmia lr, {r0, r1} stmia ip, {r0, r1} ldr pc, [sp], #4

18 Example 4 int len_hello1 (void) { return strlen ("hello"); } ColdFire code: len_hello1: 0x link a6,#0 0x lea _@71,a0 0x A jsr _strlen 0x unlk a6 0x rts

19 More Example 4 ARM7 len_hello1: mov r0, #5 bx lr

20 Summary You need to understand what actually happens on the processor Interrupts are fundamental to what embedded systems do We ll be seeing more about them soon Inline assembly lets you get fine-grain control Intrinsics hide things from you Function calls can appear, disappear relative to what you expect from the code For example all floating point is emulated in software on our ColdFire processors Need to look at compiler output to see what happened