Linux-2.6.12-rc2v2.6.12-rc2

Initial git repository build. I'm not bothering with the full history,
even though we have it. We can create a separate "historical" git
archive of that later if we want to, and in the meantime it's about
3.2GB when imported into git - space that would just make the early
git days unnecessarily complicated, when we don't have a lot of good
infrastructure for it.

Let it rip!

1 files changed, 114 insertions, 0 deletions

diff --git a/arch/arm26/nwfpe/entry.S b/arch/arm26/nwfpe/entry.S
new file mode 100644
index 000000000000..7d6dfaad80c2
--- /dev/null
+++ b/arch/arm26/nwfpe/entry.S
@@ -0,0 +1,114 @@
+/*
+    NetWinder Floating Point Emulator
+    (c) Rebel.COM, 1998
+    (c) Philip Blundell 1998-1999
+
+    Direct questions, comments to Scott Bambrough <scottb@netwinder.org>
+
+    This program is free software; you can redistribute it and/or modify
+    it under the terms of the GNU General Public License as published by
+    the Free Software Foundation; either version 2 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU General Public License for more details.
+
+    You should have received a copy of the GNU General Public License
+    along with this program; if not, write to the Free Software
+    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
+*/
+
+#include <asm/asm_offsets.h>
+
+/* This is the kernel's entry point into the floating point emulator.
+It is called from the kernel with code similar to this:
+
+        mov     fp, #0
+        teqp    pc, #PSR_I_BIT | MODE_SVC
+        ldr     r4, .LC2
+        ldr     pc, [r4]                @ Call FP module USR entry point
+
+The kernel expects the emulator to return via one of two possible
+points of return it passes to the emulator.  The emulator, if
+successful in its emulation, jumps to ret_from_exception and the
+kernel takes care of returning control from the trap to the user code.
+If the emulator is unable to emulate the instruction, it returns to
+fpundefinstr and the kernel halts the user program with a core dump.
+
+This routine does four things:
+
+1) It saves SP into a variable called userRegisters.  The kernel has
+created a struct pt_regs on the stack and saved the user registers
+into it.  See /usr/include/asm/proc/ptrace.h for details.  The
+emulator code uses userRegisters as the base of an array of words from
+which the contents of the registers can be extracted.
+
+2) It locates the FP emulator work area within the TSS structure and
+points `fpa11' to it.
+
+3) It calls EmulateAll to emulate a floating point instruction.
+EmulateAll returns 1 if the emulation was successful, or 0 if not.
+
+4) If an instruction has been emulated successfully, it looks ahead at
+the next instruction.  If it is a floating point instruction, it
+executes the instruction, without returning to user space.  In this
+way it repeatedly looks ahead and executes floating point instructions
+until it encounters a non floating point instruction, at which time it
+returns via _fpreturn.
+
+This is done to reduce the effect of the trap overhead on each
+floating point instructions.  GCC attempts to group floating point
+instructions to allow the emulator to spread the cost of the trap over
+several floating point instructions.  */
+
+        .globl  nwfpe_enter
+nwfpe_enter:
+        mov     sl, sp
+        bl      FPA11_CheckInit         @ check to see if we are initialised
+
+        ldr     r5, [sp, #60]           @ get contents of PC
+        bic     r5, r5, #0xfc000003
+        ldr     r0, [r5, #-4]           @ get actual instruction into r0
+        bl      EmulateAll              @ emulate the instruction
+1:      cmp     r0, #0                  @ was emulation successful
+        beq     fpundefinstr            @ no, return failure
+
+next:
+.Lx1:   ldrt    r6, [r5], #4            @ get the next instruction and
+                                        @ increment PC
+
+        and     r2, r6, #0x0F000000     @ test for FP insns
+        teq     r2, #0x0C000000
+        teqne   r2, #0x0D000000
+        teqne   r2, #0x0E000000
+        bne     ret_from_exception      @ return ok if not a fp insn
+
+        ldr     r9, [sp, #60]           @ get new condition codes
+        and     r9, r9, #0xfc000003
+        orr     r7, r5, r9
+        str     r7, [sp, #60]           @ update PC copy in regs
+
+        mov     r0, r6                  @ save a copy
+        mov     r1, r9                  @ fetch the condition codes
+        bl      checkCondition          @ check the condition
+        cmp     r0, #0                  @ r0 = 0 ==> condition failed
+
+        @ if condition code failed to match, next insn
+        beq     next                    @ get the next instruction;
+            
+        mov     r0, r6                  @ prepare for EmulateAll()
+        adr     lr, 1b
+        orr     lr, lr, #3
+        b       EmulateAll              @ if r0 != 0, goto EmulateAll
+
+.Lret:  b       ret_from_exception      @ let the user eat segfaults
+        
+        @ We need to be prepared for the instruction at .Lx1 to fault.
+        @ Emit the appropriate exception gunk to fix things up.
+        .section __ex_table,"a"
+        .align  3
+        .long   .Lx1
+        ldr     lr, [lr, $(.Lret - .Lx1)/4]
+        .previous