Lines Matching full:we
20 * We use a two-level table approach. The user and kernel exception vectors
62 * We get here when an exception occurred while we were in userland.
63 * We switch to the kernel stack and jump to the first level handler
90 * We get this exception when we were already in kernel space.
91 * We decrement the current stack pointer (kernel) by PT_KERNEL_SIZE and
94 * Note: we need to preserve space for the spill region.
116 * We get this exception when another exception occurs while were are
118 * or 'expected' exceptions, for example memory exception when we were trying
124 * We decode the exception and take the appropriate action. However, the
164 * - If we ever implement handling signals while in double exceptions, the
194 * In case of a critical condition where the kernel cannot recover, we jump
198 * a0: last address before we jumped to the unrecoverable_exception.
204 * FIXME: Note: we currently don't allow signal handling coming from a double
224 /* Check if we are currently handling a window exception. */
225 /* Note: We don't need to indicate that we enter a critical section. */
252 * We return to the instruction in user space that caused the window
253 * underflow exception. Therefore, we change window base to the value
254 * before we entered the window underflow exception and prepare the
255 * registers to return as if we were coming from a regular exception
257 * Note: We can trash the current window frame (a0...a3) and depc!
267 /* We are now in the previous window frame. Save registers again. */
284 * We only allow the ITLB miss exception if we are in kernel space.
303 /* Critical! We can't handle this situation. PANIC! */
316 .Lfixup:/* Check for a fixup handler or if we were in a critical section. */
361 * We return to the instruction in user space that caused the window
362 * overflow exception. Therefore, we change window base to the value
363 * before we entered the window overflow exception and prepare the
364 * registers to return as if we were coming from a regular exception
367 * NOTE: We CANNOT trash the current window frame (a0...a3), but we
371 * save a0, then clobber a0. To restart the handler, we have to restore
374 * To keep things simple, we take advantage of the fact all overflow
376 * that instruction, we can safely restore a0 from where it was saved
425 * We have to use ROTW for this, because WSR.WINDOWBASE requires
447 * We are now in the user code's original window frame.
492 * We get here with windowbase set to the window that was being spilled and
496 * We do the following here:
499 * (we'll need to rotate window back and there's no place to save this
507 * - return to user. By the time we get to this fixup handler all information
509 * the window overflow handler is lost, so we just return to userspace to
562 * may be lost before we get here. There are no free registers,
563 * so we need to use EXC_TABLE_DOUBLE_SAVE area.
630 * all vectors are within ~ 4 kB range of each other, so we can
689 * Note: We rerun the underflow handlers if we hit an exception, so
690 * we try to access any page that would cause a page fault early.