From: enevill@acorn.co.uk (Edward Nevill) Subject: New SWI veneers Date: 4 Oct 91 17:11:01 GMT Organization: Acorn Computers Ltd, Cambridge, England Here is an optimised SWI veneer which can be used instead of _kernel_swi. It is significantly faster than _kernel_swi and is much easier to use (IMHO). Enjoy, Edward. --- swiv.h --- /* SWI veneers: * Written by Edward Nevill and Jonathan Roach in an idle moment between projects. */ /* Anonymous Error type */ typedef struct Error Error; /* Generic SWI interface * swi(swino,mask,regs...) * swino = SWI number to call as defined in h.swis, X bit set if you wish the * X form of the SWI to be called, clear if you want the non X form. * reg_mask = mask of in / out registers * bits 0-9: Bit N set => Register N specified on input * Bit N clear => Register N unspecified on input * bits 22-31: Bit N set => Register N-22 on output stored * in address specified in varargs list. * ... In order, input registers followed by output registers, * starting at r0 and going up. * returns 0 or errorblock pointer if X-bit set * returns r0 if X-bit clear * swix(swino,mask,regs...) * This behaves identically to 'swi' except that it always calls the X form. * * Eg: * swi(OS_SWINumberToString, IN(R0|R1|R2), n, buf, 255); * e = swi(XOS_SWINumberFromString, IN(R1)|OUT(R0), str, &n); * - Error block pointer (or 0) is returned so must get returned R0 * - via argument list. * e = swix(OS_SWINumberFromString, IN(R1)|OUT(R0), str, &n); * - As above but uses the swix function rather that setting the X bit * explicitly (saves one instruction on SWI call). * e = swi(OS_File, IN(R0|R1|R2|R3)|OUT(R4), 255, name, buff, 0, &len); * - We don't care about the load, exec or attrs so don't specify * them in the output registers. */ extern Error *swix(int swino, int reg_mask, ...); extern int swi(int swino, int reg_mask, ...); /* Register mask macros * The bits in the register mask are arranged as follows: * 31 30 29 ... 22 ... 8 ... 2 1 0 * O0 O1 O2 ... O9 I9 ... I2 I1 I0 I(N) = bit set if R(N) used on entry * O(N) = bit set if R(N) written on exit * The bits are arranged like this to optimise the case where a SWI is being * called with a small number of input and output registers. For example, a SWI * call which uses R0-R5 on entry and R0-R1 on exit will have a register mask * of 0xC000003f which can be loaded into an ARM register in one instruction * (the compiler performs this optimisation, even when the constant wraps * around between bits 0 and 31). Using the more obvious coding of I0-I9 in bits * 0 - 9 and O0-O9 in bits 16-23 leads to a constant of 0x0003003f which require * two instructions. */ #define IN(m) (m) #define OUT(m) ((unsigned)(m&1)<<31|(m&2)<<29|(m&4)<<27|(m&8)<<25|(m&16)<<23|\ (m&32)<<21|(m&64)<<19|(m&128)<<17|(m&256)<<15|(m&512)<<13) /* The register names * Change these to use different names if you use R0 - R9 elsewhere in your program */ #define R0 0x001 #define R1 0x002 #define R2 0x004 #define R3 0x008 #define R4 0x010 #define R5 0x020 #define R6 0x040 #define R7 0x080 #define R8 0x100 #define R9 0x200 --- swiv.s --- r0 RN 0 r1 RN 1 r2 RN 2 r3 RN 3 r4 RN 4 r5 RN 5 r6 RN 6 r7 RN 7 r8 RN 8 r9 RN 9 r10 RN 10 r11 RN 11 r12 RN 12 sp RN 13 lr RN 14 pc RN 15 AREA |C$$code|, CODE, READONLY SWIReturnInst LDR pc, [sp, #0*4] EXPORT swix swix ROUT ORR r0, r0, #&20000 EXPORT swi swi ROUT ; Construct a stack frame that looks something like this: ; returnval ; LDMIA r12!, {r0..rn} ; SWI xxxxxx ; LDR pc, [sp] ; saved r4-r11,lr ; saved r1 ; saved input values (r2...rn) STMFD sp!, {r1-r3} ; Save r1 and put 1st two variadic args on stack BIC r2, r0, #&ff000000 ORR r2, r2, #&ef000000 ; Construct SWI instruction ADR r0, SWIReturn BIC r1, r1, #&ff000000 ; Construct LDMIA R12!, {regs} instruction, if BICS r1, r1, #&00ff0000 ; {regs} = {} (IE no input regs) we must not ORRNE r1, r1, #&e8000000 ; use an LDMIA R12!, {} instruction as this is an ORRNE r1, r1, #&00bc0000 ; invalid instruction, we use a suitable NOP instead MOVEQ r1, #0 ; 0 = opcode for ANDEQ r0, r0, r0 (a suitable NOP) LDR r3, SWIReturnInst STMFD sp!, {r0-r9,r11,lr} ; Save regs and set up SWI call routine (in R0-R3) ADD r12, sp, #(12+1)*4 ; Point R12 at input regs on stack. ADD pc, sp, #4 ; Call routine on stack SWIReturn LDR lr, [sp, #(12+0)*4] ; Fetch reg mask again MOVS lr, lr, ASL #1 ; Shift out setting C if R0 to be written, N LDRCS r11, [r12], #4 ; if R1 to be written. STRCS r0, [r11] LDRMI r11, [r12], #4 STRMI r1, [r11] MOVS lr, lr, ASL #2 ; Shift 2 bits each time for the next 2 regs LDRCS r11, [r12], #4 STRCS r2, [r11] LDRMI r11, [r12], #4 STRMI r3, [r11] MOVS lr, lr, ASL #2 LDRCS r11, [r12], #4 STRCS r4, [r11] LDRMI r11, [r12], #4 STRMI r5, [r11] MOVS lr, lr, ASL #2 LDRCS r11, [r12], #4 STRCS r6, [r11] LDRMI r11, [r12], #4 STRMI r7, [r11] MOVS lr, lr, ASL #2 LDRCS r11, [r12], #4 STRCS r8, [r11] LDRMI r11, [r12], #4 STRMI r9, [r11] LDR r1, [sp, #2*4] TST r1, #&20000 ; X-bit clear CMPEQ pc, #&80000000 ; SET V flag if so, so R0 not cleared MOVVC r0, #0 ; Clear R0 if no error (or X-bit clear) ADD sp, sp, #4*4 ; Drop SWI call routine LDMIA sp!, {r4-r9,r11,lr} ADD sp, sp, #3*4 ; Drop saved R1 and 1st two variadic args. MOVS pc, lr END --- switime.c --- /* This program times the 'swi' and '_kernel_swi' veneers. It calls the X form of * OS_GenerateError (the fastest possible swi since all it does is set the V flag). * It calls it with a sample register set which would be used to call XOS_ReadVarVal. * * IE. It sets up the registers as though it were calling XOS_ReadVarVal and then * calls a trivial SWI (XOS_GenerateError) so that it only measure the overhead of * calling a typical SWI. * * Timings for an A540 in mode 0 * swi _kernel_sw * Cache enabled 168 csec 252 csec * Cache disabled 340 csec 497 csec * * It also serves as an example of how much easier the 'swi' veneer is to use. Note the * 6 or 7 lines required using '_kernel_swi' compared with the one line using 'swi'. */ #include #include "kernel.h" #include "swiv.h" #include "swis.h" int main(void) { _kernel_swi_regs r; int t1, t2, t3; int i; int exists; t1 = swi(OS_ReadMonotonicTime, 0); for (i = 0; i < 100000; i++) swix(OS_GenerateError, IN(R0|R2|R3|R4)|OUT(R2), "ADFSFiler$Path", -1, 0, 0, &exists); t2 = swi(OS_ReadMonotonicTime, 0); for (i = 0; i < 100000; i++) { r.r[0] = (int)"ADFSFiler$Path"; r.r[2] = -1; r.r[3] = 0; r.r[4] = 0; _kernel_swi(OS_GenerateError, &r, &r); exists = r.r[2]; } t3 = swi(OS_ReadMonotonicTime, 0); printf("Times:-\nswix = %d csec\n_kernel_swi = %d csec\n", t2-t1, t3-t2); return 0; } --- From: enevill@acorn.co.uk (Edward Nevill) Subject: New SWI veneers (2) Date: 21 Oct 91 16:01:22 GMT Organization: Acorn Computers Ltd, Cambridge, England A couple of weeks ago I posted a set of variadic swi wrapper routines, unfortunately they contained a bug. The macro OUT defined in h.swiv currently reads #define OUT(m) ((unsigned)(m&1)<<31|(m&2)<<29|(m&4)<<27|\ (m&8)<<25|(m&16)<<23|(m&32)<<21|(m&64)<<19|\ (m&128)<<17|(m&256)<<15|(m&512)<<13) it should read #define OUT(m) ((unsigned)((m)&1)<<31|((m)&2)<<29|((m)&4)<<27|\ ((m)&8)<<25|((m)&16)<<23|((m)&32)<<21|((m)&64)<<19|\ ((m)&128)<<17|((m)&256)<<15|((m)&512)<<13) IE. it should have a pair of brackets around each 'm' in the macro expansion. Given that a typical use of the macro is something like OUT(R0|R1) this can lead to fatal results (eg address exceptions, stack trampling) so you should change your headers to use the new macros. Edward.