开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > Linux/Unix编程 > 查看源码
entry.S
资源名称：linux-2.4.20.tar.gz　[点击查看]
上传用户：jlfgdled
上传日期：2013-04-10
资源大小：33168k
文件大小：64k
源码类别：

Linux/Unix编程

开发平台：

Unix_Linux

entry.S：源码内容
  1. /*
  2.  * Linux/PA-RISC Project (http://www.parisc-linux.org/)
  3.  *
  4.  * kernel entry points (interruptions, system call wrappers)
  5.  *  Copyright (C) 1999,2000 Philipp Rumpf 
  6.  *  Copyright (C) 1999 SuSE GmbH Nuernberg 
  7.  *  Copyright (C) 2000 Hewlett-Packard (John Marvin)
  8.  *  Copyright (C) 1999 Hewlett-Packard (Frank Rowand)
  9.  *
  10.  *    This program is free software; you can redistribute it and/or modify
  11.  *    it under the terms of the GNU General Public License as published by
  12.  *    the Free Software Foundation; either version 2, or (at your option)
  13.  *    any later version.
  14.  *
  15.  *    This program is distributed in the hope that it will be useful,
  16.  *    but WITHOUT ANY WARRANTY; without even the implied warranty of
  17.  *    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  18.  *    GNU General Public License for more details.
  19.  *
  20.  *    You should have received a copy of the GNU General Public License
  21.  *    along with this program; if not, write to the Free Software
  22.  *    Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.
  23.  */
  25. #include <linux/config.h>
  26. #include <asm/offset.h>
  28. /* we have the following possibilities to act on an interruption:
  29.  *  - handle in assembly and use shadowed registers only
  30.  *  - save registers to kernel stack and handle in assembly or C */
  33. #include <asm/assembly.h> /* for LDREG/STREG defines */
  34. #include <asm/pgtable.h>
  35. #include <asm/psw.h>
  36. #include <asm/signal.h>
  37. #include <asm/unistd.h>
  39. #ifdef __LP64__
  40. #define FRAME_SIZE 128
  41. #define CMPIB           cmpib,*
  42. #define CMPB            cmpb,*
  44. .level 2.0w
  45. #else
  46. #define FRAME_SIZE 64
  47. #define CMPIB           cmpib,
  48. #define CMPB            cmpb,
  50. .level 2.0
  51. #endif
  53. .import         pa_dbit_lock,data
  55. /* space_to_prot macro creates a prot id from a space id */
  57. #if (SPACEID_SHIFT) == 0
  58. .macro  space_to_prot spc prot
  59. depd,z  spc,62,31,prot
  60. .endm
  61. #else
  62. .macro  space_to_prot spc prot
  63. extrd,u spc,(64 - (SPACEID_SHIFT)),32,prot
  64. .endm
  65. #endif
  67. /* Switch to virtual mapping, trashing only %r1 */
  68. .macro  virt_map
  69. rsm     PSW_SM_Q,%r0
  70. tovirt_r1 %r29
  71. mfsp %sr7, %r1
  72. or,=    %r0,%r1,%r0 /* Only save sr7 in sr3 if sr7 != 0 */
  73. mtsp %r1, %sr3
  74. mtsp %r0, %sr4
  75. mtsp %r0, %sr5
  76. mtsp %r0, %sr6
  77. mtsp %r0, %sr7
  78. ldil L%KERNEL_PSW, %r1
  79. ldo R%KERNEL_PSW(%r1), %r1
  80. mtctl %r1, %cr22
  81. mtctl %r0, %cr17
  82. mtctl %r0, %cr17
  83. ldil L%4f, %r1
  84. ldo R%4f(%r1), %r1
  85. mtctl %r1, %cr18
  86. ldo 4(%r1), %r1
  87. mtctl %r1, %cr18
  88. rfir
  89. nop
  90. 4:
  91. .endm
  93. /*
  94.  * The "get_stack" macros are responsible for determining the
  95.  * kernel stack value.
  96.  *
  97.  * For Faults:
  98.  *      If sr7 == 0
  99.  *          Already using a kernel stack, so call the
  100.  *          get_stack_use_r30 macro to push a pt_regs structure
  101.  *          on the stack, and store registers there.
  102.  *      else
  103.  *          Need to set up a kernel stack, so call the
  104.  *          get_stack_use_cr30 macro to set up a pointer
  105.  *          to the pt_regs structure contained within the
  106.  *          task pointer pointed to by cr30. Set the stack
  107.  *          pointer to point to the end of the task structure.
  108.  *
  109.  * For Interrupts:
  110.  *      If sr7 == 0
  111.  *          Already using a kernel stack, check to see if r30
  112.  *          is already pointing to the per processor interrupt
  113.  *          stack. If it is, call the get_stack_use_r30 macro
  114.  *          to push a pt_regs structure on the stack, and store
  115.  *          registers there. Otherwise, call get_stack_use_cr31
  116.  *          to get a pointer to the base of the interrupt stack
  117.  *          and push a pt_regs structure on that stack.
  118.  *      else
  119.  *          Need to set up a kernel stack, so call the
  120.  *          get_stack_use_cr30 macro to set up a pointer
  121.  *          to the pt_regs structure contained within the
  122.  *          task pointer pointed to by cr30. Set the stack
  123.  *          pointer to point to the end of the task structure.
  124.  *          N.B: We don't use the interrupt stack for the
  125.  *          first interrupt from userland, because signals/
  126.  *          resched's are processed when returning to userland,
  127.  *          and we can sleep in those cases.
  128.  *
  129.  * Note that we use shadowed registers for temps until
  130.  * we can save %r26 and %r29. %r26 is used to preserve
  131.  * %r8 (a shadowed register) which temporarily contained
  132.  * either the fault type ("code") or the eirr. We need
  133.  * to use a non-shadowed register to carry the value over
  134.  * the rfir in virt_map. We use %r26 since this value winds
  135.  * up being passed as the argument to either do_cpu_irq_mask
  136.  * or handle_interruption. %r29 is used to hold a pointer
  137.  * the register save area, and once again, it needs to
  138.  * be a non-shadowed register so that it survives the rfir.
  139.  *
  140.  * N.B. TASK_SZ_ALGN and PT_SZ_ALGN include space for a stack frame.
  141.  */
  143. .macro  get_stack_use_cr30
  145. /* we save the registers in the task struct */
  147. mfctl   %cr30, %r1
  148. tophys  %r1,%r9
  149. ldo     TASK_REGS(%r9),%r9
  150. STREG   %r30, PT_GR30(%r9)
  151. ldo TASK_SZ_ALGN(%r1), %r30
  152. STREG   %r29,PT_GR29(%r9)
  153. STREG   %r26,PT_GR26(%r9)
  154. copy    %r9,%r29
  155. .endm
  157. .macro  get_stack_use_r30
  159. /* we put a struct pt_regs on the stack and save the registers there */
  161. tophys  %r30,%r9
  162. STREG   %r30,PT_GR30(%r9)
  163. ldo PT_SZ_ALGN(%r30),%r30
  164. STREG   %r29,PT_GR29(%r9)
  165. STREG   %r26,PT_GR26(%r9)
  166. copy    %r9,%r29
  167. .endm
  169. .macro  rest_stack
  170. LDREG   PT_GR1(%r29), %r1
  171. LDREG   PT_GR30(%r29),%r30
  172. LDREG   PT_GR29(%r29),%r29
  173. .endm
  175. /* default interruption handler
  176.  * (calls traps.c:handle_interruption) */
  177. .macro def code
  178. b intr_save
  179. ldi     code, %r8
  180. .align 32
  181. .endm
  183. /* Interrupt interruption handler
  184.  * (calls irq.c:do_cpu_irq_mask) */
  185. .macro extint code
  186. b intr_extint
  187. mfsp    %sr7,%r16
  188. .align 32
  189. .endm
  191. .import os_hpmc, code
  193. /* HPMC handler */
  194. .macro hpmc code
  195. nop /* must be a NOP, will be patched later */
  196. ldil L%PA(os_hpmc), %r3
  197. ldo R%PA(os_hpmc)(%r3), %r3
  198. bv,n 0(%r3)
  199. nop
  200. .word 0 /* checksum (will be patched) */
  201. .word PA(os_hpmc) /* address of handler */
  202. .word 0 /* length of handler */
  203. .endm
  205. /*
  206.  * Performance Note: Instructions will be moved up into
  207.  * this part of the code later on, once we are sure
  208.  * that the tlb miss handlers are close to final form.
  209.  */
  211. /* Register definitions for tlb miss handler macros */
  213. va  = r8 /* virtual address for which the trap occured */
  214. spc = r24 /* space for which the trap occured */
  216. #ifndef __LP64__
  218. /*
  219.  * itlb miss interruption handler (parisc 1.1 - 32 bit)
  220.  */
  222. .macro itlb_11 code
  224. mfctl %pcsq, spc
  225. b itlb_miss_11
  226. mfctl %pcoq, va
  228. .align 32
  229. .endm
  230. #endif
  232. /*
  233.  * itlb miss interruption handler (parisc 2.0)
  234.  */
  236. .macro itlb_20 code
  237. mfctl %pcsq, spc
  238. #ifdef __LP64__
  239. b       itlb_miss_20w
  240. #else
  241. b itlb_miss_20
  242. #endif
  243. mfctl %pcoq, va
  245. .align 32
  246. .endm
  248. #ifndef __LP64__
  249. /*
  250.  * naitlb miss interruption handler (parisc 1.1 - 32 bit)
  251.  *
  252.  * Note: naitlb misses will be treated
  253.  * as an ordinary itlb miss for now.
  254.  * However, note that naitlb misses
  255.  * have the faulting address in the
  256.  * IOR/ISR.
  257.  */
  259. .macro naitlb_11 code
  261. mfctl %isr,spc
  262. b itlb_miss_11
  263. mfctl  %ior,va
  264. /* FIXME: If user causes a naitlb miss, the priv level may not be in
  265.  * lower bits of va, where the itlb miss handler is expecting them
  266.  */
  268. .align 32
  269. .endm
  270. #endif
  272. /*
  273.  * naitlb miss interruption handler (parisc 2.0)
  274.  *
  275.  * Note: naitlb misses will be treated
  276.  * as an ordinary itlb miss for now.
  277.  * However, note that naitlb misses
  278.  * have the faulting address in the
  279.  * IOR/ISR.
  280.  */
  282. .macro naitlb_20 code
  284. mfctl %isr,spc
  285. #ifdef __LP64__
  286. b       itlb_miss_20w
  287. #else
  288. b itlb_miss_20
  289. #endif
  290. mfctl  %ior,va
  291. /* FIXME: If user causes a naitlb miss, the priv level may not be in
  292.  * lower bits of va, where the itlb miss handler is expecting them
  293.  */
  295. .align 32
  296. .endm
  298. #ifndef __LP64__
  299. /*
  300.  * dtlb miss interruption handler (parisc 1.1 - 32 bit)
  301.  */
  303. .macro dtlb_11 code
  305. mfctl %isr, spc
  306. b dtlb_miss_11
  307. mfctl %ior, va
  309. .align 32
  310. .endm
  311. #endif
  313. /*
  314.  * dtlb miss interruption handler (parisc 2.0)
  315.  */
  317. .macro dtlb_20 code
  319. mfctl %isr, spc
  320. #ifdef __LP64__
  321. b       dtlb_miss_20w
  322. #else
  323. b dtlb_miss_20
  324. #endif
  325. mfctl %ior, va
  327. .align 32
  328. .endm
  330. #ifndef __LP64__
  331. /* nadtlb miss interruption handler (parisc 1.1 - 32 bit) */
  333. .macro nadtlb_11 code
  335. mfctl %isr,spc
  336. b       nadtlb_miss_11
  337. mfctl %ior,va
  339. .align 32
  340. .endm
  341. #endif
  343. /* nadtlb miss interruption handler (parisc 2.0) */
  345. .macro nadtlb_20 code
  347. mfctl %isr,spc
  348. #ifdef __LP64__
  349. b       nadtlb_miss_20w
  350. #else
  351. b       nadtlb_miss_20
  352. #endif
  353. mfctl %ior,va
  355. .align 32
  356. .endm
  358. #ifndef __LP64__
  359. /*
  360.  * dirty bit trap interruption handler (parisc 1.1 - 32 bit)
  361.  */
  363. .macro dbit_11 code
  365. mfctl %isr,spc
  366. b dbit_trap_11
  367. mfctl %ior,va
  369. .align 32
  370. .endm
  371. #endif
  373. /*
  374.  * dirty bit trap interruption handler (parisc 2.0)
  375.  */
  377. .macro dbit_20 code
  379. mfctl %isr,spc
  380. #ifdef __LP64__
  381. b       dbit_trap_20w
  382. #else
  383. b dbit_trap_20
  384. #endif
  385. mfctl %ior,va
  387. .align 32
  388. .endm
  390. /*
  391.  * Align fault_vector_20 on 4K boundary so that both
  392.  * fault_vector_11 and fault_vector_20 are on the
  393.  * same page. This is only necessary as long as we
  394.  * write protect the kernel text, which we may stop
  395.  * doing once we use large page translations to cover
  396.  * the static part of the kernel address space.
  397.  */
  399. .export fault_vector_20
  401. .text
  403. .align 4096
  405. fault_vector_20:
  406. /* First vector is invalid (0) */
  407. .ascii "cows can fly"
  408. .byte 0
  409. .align 32
  411. hpmc  1
  412. def  2
  413. def  3
  414. extint  4
  415. def  5
  416. itlb_20  6
  417. def  7
  418. def  8
  419. def              9
  420. def 10
  421. def 11
  422. def 12
  423. def 13
  424. def 14
  425. dtlb_20 15
  426. #if 0
  427. naitlb_20 16
  428. #else
  429. def             16
  430. #endif
  431. nadtlb_20 17
  432. def 18
  433. def 19
  434. dbit_20 20
  435. def 21
  436. def 22
  437. def 23
  438. def 24
  439. def 25
  440. def 26
  441. def 27
  442. def 28
  443. def 29
  444. def 30
  445. def 31
  447. #ifndef __LP64__
  449. .export fault_vector_11
  451. .align 2048
  453. fault_vector_11:
  454. /* First vector is invalid (0) */
  455. .ascii "cows can fly"
  456. .byte 0
  457. .align 32
  459. hpmc  1
  460. def  2
  461. def  3
  462. extint  4
  463. def  5
  464. itlb_11  6
  465. def  7
  466. def  8
  467. def              9
  468. def 10
  469. def 11
  470. def 12
  471. def 13
  472. def 14
  473. dtlb_11 15
  474. #if 0
  475. naitlb_11 16
  476. #else
  477. def             16
  478. #endif
  479. nadtlb_11 17
  480. def 18
  481. def 19
  482. dbit_11 20
  483. def 21
  484. def 22
  485. def 23
  486. def 24
  487. def 25
  488. def 26
  489. def 27
  490. def 28
  491. def 29
  492. def 30
  493. def 31
  495. #endif
  497. .import handle_interruption,code
  498. .import handle_real_interruption,code
  499. .import do_cpu_irq_mask,code
  500. .import parisc_stopkernel,code
  502. /*
  503.  * r26 = function to be called
  504.  * r25 = argument to pass in
  505.  * r24 = flags for do_fork()
  506.  *
  507.  * Kernel threads don't ever return, so they don't need
  508.  * a true register context. We just save away the arguments
  509.  * for copy_thread/ret_ to properly set up the child.
  510.  */
  512. #define CLONE_VM 0x100 /* Must agree with <linux/sched.h> */
  514. .export __kernel_thread, code
  515. .import do_fork
  516. __kernel_thread:
  517. STREG %r2, -RP_OFFSET(%r30)
  519. copy %r30, %r1
  520. ldo PT_SZ_ALGN(%r30),%r30
  521. #ifdef __LP64__
  522. /* Yo, function pointers in wide mode are little structs... -PB */
  523. ldd 24(%r26), %r2
  524. STREG %r2, PT_GR27(%r1) /* Store childs %dp */
  525. ldd 16(%r26), %r26
  526. #endif
  527. STREG %r26, PT_GR26(%r1)  /* Store function & argument for child */
  528. STREG %r25, PT_GR25(%r1)
  529. ldo CLONE_VM(%r0), %r26   /* Force CLONE_VM since only init_mm */
  530. or %r26, %r24, %r26      /* will have kernel mappings.  */
  531. copy %r0, %r25
  532. #ifdef __LP64__
  533. ldo -16(%r30),%r29 /* Reference param save area */
  534. #endif
  535. bl do_fork, %r2
  536. copy %r1, %r24
  538. /* Parent Returns here */
  540. LDREG -PT_SZ_ALGN-RP_OFFSET(%r30), %r2
  541. bv %r0(%r2)
  542. ldo -PT_SZ_ALGN(%r30), %r30
  544. /*
  545.  * Child Returns here
  546.  *
  547.  * copy_thread moved args from temp save area set up above
  548.  * into task save area.
  549.  */
  551. .export ret_from_kernel_thread
  552. ret_from_kernel_thread:
  554. /* Call schedule_tail first though */
  555. bl schedule_tail, %r2
  556. nop
  558. LDREG TASK_PT_GR26-TASK_SZ_ALGN(%r30), %r1
  559. LDREG TASK_PT_GR25-TASK_SZ_ALGN(%r30), %r26
  560. #ifdef __LP64__
  561. LDREG TASK_PT_GR27-TASK_SZ_ALGN(%r30), %r27
  562. #endif
  563. ble 0(%sr7, %r1)
  564. copy %r31, %r2
  566. #ifdef __LP64__
  567. ldo -16(%r30),%r29 /* Reference param save area */
  568. loadgp /* Thread could have been in a module */
  569. #endif
  570. b sys_exit
  571. ldi 0, %r26
  573. .import sys_execve, code
  574. .export __execve, code
  575. __execve:
  576. copy %r2, %r15
  577. copy %r30, %r16
  578. ldo PT_SZ_ALGN(%r30), %r30
  579. STREG %r26, PT_GR26(%r16)
  580. STREG %r25, PT_GR25(%r16)
  581. STREG %r24, PT_GR24(%r16)
  582. #ifdef __LP64__
  583. ldo -16(%r30),%r29 /* Reference param save area */
  584. #endif
  585. bl sys_execve, %r2
  586. copy %r16, %r26
  588. cmpib,=,n 0,%r28,intr_return    /* forward */
  590. /* yes, this will trap and die. */
  591. copy %r15, %r2
  592. copy %r16, %r30
  593. bv %r0(%r2)
  594. nop
  596. .align 4
  598. /*
  599.  * struct task_struct *_switch_to(struct task_struct *prev,
  600.  * struct task_struct *next)
  601.  *
  602.  * switch kernel stacks and return prev */
  603. .export _switch_to, code
  604. _switch_to:
  605. STREG  %r2, -RP_OFFSET(%r30)
  607. callee_save
  609. ldil L%_switch_to_ret, %r2
  610. ldo R%_switch_to_ret(%r2), %r2
  612. STREG %r2, TASK_PT_KPC(%r26)
  613. LDREG TASK_PT_KPC(%r25), %r2
  615. STREG %r30, TASK_PT_KSP(%r26)
  616. LDREG TASK_PT_KSP(%r25), %r30
  617. bv %r0(%r2)
  618. mtctl   %r25,%cr30
  620. _switch_to_ret:
  621. mtctl %r0, %cr0 /* Needed for single stepping */
  622. callee_rest
  624. LDREG -RP_OFFSET(%r30), %r2
  625. bv %r0(%r2)
  626. copy %r26, %r28
  628. /*
  629.  * Common rfi return path for interruptions, kernel execve, and
  630.  * sys_rt_sigreturn (sometimes).  The sys_rt_sigreturn syscall will
  631.  * return via this path if the signal was received when the process
  632.  * was running; if the process was blocked on a syscall then the
  633.  * normal syscall_exit path is used.  All syscalls for traced
  634.  * proceses exit via intr_restore.
  635.  *
  636.  * XXX If any syscalls that change a processes space id ever exit
  637.  * this way, then we will need to copy %sr3 in to PT_SR[3..7], and
  638.  * adjust IASQ[0..1].
  639.  *
  640.  * Note that the following code uses a "relied upon translation".
  641.  * See the parisc ACD for details. The ssm is necessary due to a
  642.  * PCXT bug.
  643.  */
  645. .align 4096
  647. .export syscall_exit_rfi
  648. syscall_exit_rfi:
  649. mfctl   %cr30,%r16
  650. ldo TASK_REGS(%r16),%r16
  651. /* Force iaoq to userspace, as the user has had access to our current
  652.  * context via sigcontext. Also Filter the PSW for the same reason.
  653.  */
  654. LDREG PT_IAOQ0(%r16),%r19
  655. depi 3,31,2,%r19
  656. STREG %r19,PT_IAOQ0(%r16)
  657. LDREG PT_IAOQ1(%r16),%r19
  658. depi 3,31,2,%r19
  659. STREG %r19,PT_IAOQ1(%r16)
  660. LDREG   PT_PSW(%r16),%r19
  661. ldil    L%USER_PSW_MASK,%r1
  662. ldo     R%USER_PSW_MASK(%r1),%r1
  663. #ifdef __LP64__
  664. ldil    L%USER_PSW_HI_MASK,%r20
  665. ldo     R%USER_PSW_HI_MASK(%r20),%r20
  666. depd    %r20,31,32,%r1
  667. #endif
  668. and     %r19,%r1,%r19 /* Mask out bits that user shouldn't play with */
  669. ldil    L%USER_PSW,%r1
  670. ldo     R%USER_PSW(%r1),%r1
  671. or      %r19,%r1,%r19 /* Make sure default USER_PSW bits are set */
  672. STREG   %r19,PT_PSW(%r16)
  674. /*
  675.  * If we aren't being traced, we never saved space registers
  676.  * (we don't store them in the sigcontext), so set them
  677.  * to "proper" values now (otherwise we'll wind up restoring
  678.  * whatever was last stored in the task structure, which might
  679.  * be inconsistant if an interrupt occured while on the gateway
  680.  * page) Note that we may be "trashing" values the user put in
  681.  * them, but we don't support the the user changing them.
  682.  */
  684. STREG   %r0,PT_SR2(%r16)
  685. mfsp    %sr3,%r19
  686. STREG   %r19,PT_SR0(%r16)
  687. STREG   %r19,PT_SR1(%r16)
  688. STREG   %r19,PT_SR3(%r16)
  689. STREG   %r19,PT_SR4(%r16)
  690. STREG   %r19,PT_SR5(%r16)
  691. STREG   %r19,PT_SR6(%r16)
  692. STREG   %r19,PT_SR7(%r16)
  694. intr_return:
  695. ssm     PSW_SM_I, %r0
  697. /* Check for software interrupts */
  699. .import irq_stat,data
  701. ldil L%irq_stat,%r19
  702. ldo R%irq_stat(%r19),%r19
  703. #ifdef CONFIG_SMP
  704. mfctl   %cr30,%r1
  705. ldw TASK_PROCESSOR(%r1),%r1 /* get cpu # - int */
  706. /* shift left ____cacheline_aligned (aka L1_CACHE_BYTES) amount
  707. ** irq_stat[] is defined using ____cacheline_aligned.
  708. */
  709. #ifdef __LP64__
  710. shld %r1, 6, %r20
  711. #else
  712. shlw %r1, 5, %r20
  713. #endif
  714. add     %r19,%r20,%r19 /* now have &irq_stat[smp_processor_id()] */
  715. #endif /* CONFIG_SMP */
  717. LDREG   IRQSTAT_SIRQ_PEND(%r19),%r20    /* hardirq.h: unsigned long */
  718. cmpib,<>,n 0,%r20,intr_do_softirq /* forward */
  720. intr_check_resched:
  722. /* check for reschedule */
  723. mfctl   %cr30,%r1
  724. LDREG     TASK_NEED_RESCHED(%r1),%r19 /* sched.h: long need_resched */
  725. CMPIB<>,n 0,%r19,intr_do_resched /* forward */
  727. intr_check_sig:
  728. /* As above */
  729. mfctl   %cr30,%r1
  730. ldw TASK_SIGPENDING(%r1),%r19 /* sched.h: int sigpending */
  731. cmpib,<>,n 0,%r19,intr_do_signal /* forward */
  733. intr_restore:
  734. copy            %r16,%r29
  735. ldo             PT_FR31(%r29),%r1
  736. rest_fp         %r1
  737. rest_general    %r29
  738. ssm 0,%r0
  739. nop
  740. nop
  741. nop
  742. nop
  743. nop
  744. nop
  745. nop
  746. tophys_r1       %r29
  747. rsm             (PSW_SM_Q|PSW_SM_P|PSW_SM_D|PSW_SM_I),%r0
  748. rest_specials %r29
  749. rest_stack
  750. rfi
  751. nop
  752. nop
  753. nop
  754. nop
  755. nop
  756. nop
  757. nop
  758. nop
  760. .import do_softirq,code
  761. intr_do_softirq:
  762. bl      do_softirq,%r2
  763. #ifdef __LP64__
  764. ldo -16(%r30),%r29 /* Reference param save area */
  765. #else
  766. nop
  767. #endif
  768. b       intr_check_resched
  769. nop
  771. .import schedule,code
  772. intr_do_resched:
  773. /* Only do reschedule if we are returning to user space */
  774. LDREG   PT_IASQ0(%r16), %r20
  775. CMPIB= 0,%r20,intr_restore /* backward */
  776. nop
  777. LDREG   PT_IASQ1(%r16), %r20
  778. CMPIB= 0,%r20,intr_restore /* backward */
  779. nop
  781. #ifdef __LP64__
  782. ldo -16(%r30),%r29 /* Reference param save area */
  783. #endif
  785. ldil L%intr_return, %r2
  786. b schedule
  787. ldo R%intr_return(%r2), %r2 /* return to intr_return, not here */
  790. .import do_signal,code
  791. intr_do_signal:
  792. /* Only do signals if we are returning to user space */
  793. LDREG   PT_IASQ0(%r16), %r20
  794. CMPIB= 0,%r20,intr_restore /* backward */
  795. nop
  796. LDREG   PT_IASQ1(%r16), %r20
  797. CMPIB= 0,%r20,intr_restore /* backward */
  798. nop
  800. copy %r0, %r24 /* unsigned long in_syscall */
  801. copy %r16, %r25 /* struct pt_regs *regs */
  802. ssm     PSW_SM_I, %r0
  803. #ifdef __LP64__
  804. ldo -16(%r30),%r29 /* Reference param save area */
  805. #endif
  806. bl do_signal,%r2
  807. copy %r0, %r26 /* sigset_t *oldset = NULL */
  809. b intr_restore
  810. nop
  812. /*
  813.  * External interrupts.
  814.  */
  816. intr_extint:
  817. CMPIB=,n 0,%r16,1f /* on User or kernel stack? */
  818. get_stack_use_cr30
  819. b,n 3f
  821. 1:
  822. #if 0  /* Interrupt Stack support not working yet! */
  823. mfctl %cr31,%r1
  824. copy %r30,%r17
  825. /* FIXME! depi below has hardcoded idea of interrupt stack size (32k)*/
  826. #ifdef __LP64__
  827. depdi 0,63,15,%r17
  828. #else
  829. depi 0,31,15,%r17
  830. #endif
  831. CMPB=,n %r1,%r17,2f
  832. get_stack_use_cr31
  833. b,n 3f
  834. #endif
  835. 2:
  836. get_stack_use_r30
  838. 3:
  839. save_specials %r29
  840. virt_map
  841. save_general %r29
  843. ldo PT_FR0(%r29), %r24
  844. save_fp %r24
  846. loadgp
  848. copy %r29, %r26 /* arg0 is pt_regs */
  849. copy %r29, %r16 /* save pt_regs */
  850. ldil L%intr_return, %r2
  851. #ifdef __LP64__
  852. ldo -16(%r30),%r29 /* Reference param save area */
  853. #endif
  854. b do_cpu_irq_mask
  855. ldo R%intr_return(%r2), %r2 /* return to intr_return, not here */
  859. /* Generic interruptions (illegal insn, unaligned, page fault, etc) */
  861. .export         intr_save, code /* for os_hpmc */
  863. intr_save:
  864. mfsp    %sr7,%r16
  865. CMPIB=,n 0,%r16,1f
  866. get_stack_use_cr30
  867. b 2f
  868. copy    %r8,%r26
  870. 1:
  871. get_stack_use_r30
  872. copy    %r8,%r26
  874. 2:
  875. save_specials %r29
  877. /* If this trap is a itlb miss, skip saving/adjusting isr/ior */
  879. /*
  880.  * FIXME: 1) Use a #define for the hardwired "6" below (and in
  881.  *           traps.c.
  882.  *        2) Once we start executing code above 4 Gb, we need
  883.  *           to adjust iasq/iaoq here in the same way we
  884.  *           adjust isr/ior below.
  885.  */
  887. CMPIB=,n        6,%r26,skip_save_ior
  889. /* save_specials left ipsw value in r8 for us to test */
  891. mfctl           %cr20, %r16 /* isr */
  892. mfctl           %cr21, %r17 /* ior */
  894. #ifdef __LP64__
  895. /*
  896.  * If the interrupted code was running with W bit off (32 bit),
  897.  * clear the b bits (bits 0 & 1) in the ior.
  898.  */
  899. extrd,u,*<>     %r8,PSW_W_BIT,1,%r0
  900. depdi           0,1,2,%r17
  902. /*
  903.  * FIXME: This code has hardwired assumptions about the split
  904.  *        between space bits and offset bits. This will change
  905.  *        when we allow alternate page sizes.
  906.  */
  908. /* adjust isr/ior. */
  910. extrd,u         %r16,63,7,%r1    /* get high bits from isr for ior */
  911. depd            %r1,31,7,%r17    /* deposit them into ior */
  912. depdi           0,63,7,%r16      /* clear them from isr */
  913. #endif
  914. STREG           %r16, PT_ISR(%r29)
  915. STREG           %r17, PT_IOR(%r29)
  918. skip_save_ior:
  919. virt_map
  920. save_general %r29
  922. ldo PT_FR0(%r29), %r25
  923. save_fp %r25
  925. loadgp
  927. copy %r29, %r25 /* arg1 is pt_regs */
  928. #ifdef CONFIG_KWDB
  929. copy %r29, %r3 /* KWDB - update frame pointer (gr3) */
  930. #endif
  932. #ifdef __LP64__
  933. ldo -16(%r30),%r29 /* Reference param save area */
  934. #endif
  936. ldil L%intr_return, %r2
  937. copy %r25, %r16 /* save pt_regs */
  939. b handle_interruption
  940. ldo R%intr_return(%r2), %r2 /* return to intr_return */
  943. /*
  944.  * Note for all tlb miss handlers:
  945.  *
  946.  * cr24 contains a pointer to the kernel address space
  947.  * page directory.
  948.  *
  949.  * cr25 contains a pointer to the current user address
  950.  * space page directory.
  951.  *
  952.  * sr3 will contain the space id of the user address space
  953.  * of the current running thread while that thread is
  954.  * running in the kernel.
  955.  */
  957. /*
  958.  * register number allocations.  Note that these are all
  959.  * in the shadowed registers
  960.  */
  962. t0 = r1 /* temporary register 0 */
  963. va = r8 /* virtual address for which the trap occured */
  964. t1 = r9 /* temporary register 1 */
  965. pte  = r16 /* pte/phys page # */
  966. prot = r17 /* prot bits */
  967. spc  = r24 /* space for which the trap occured */
  968. ptp = r25 /* page directory/page table pointer */
  970. #ifdef __LP64__
  972. dtlb_miss_20w:
  973. extrd,u         spc,63,7,t1     /* adjust va */
  974. depd            t1,31,7,va      /* adjust va */
  975. depdi           0,63,7,spc      /* adjust space */
  976. mfctl           %cr25,ptp /* Assume user space miss */
  977. or,*<>          %r0,spc,%r0     /* If it is user space, nullify */
  978. mfctl           %cr24,ptp /* Load kernel pgd instead */
  979. extrd,u         va,33,9,t1      /* Get pgd index */
  981. mfsp            %sr7,t0 /* Get current space */
  982. or,*=           %r0,t0,%r0      /* If kernel, nullify following test */
  983. cmpb,*<>,n       t0,spc,dtlb_fault /* forward */
  985. /* First level page table lookup */
  987. ldd,s           t1(ptp),ptp
  988. extrd,u         va,42,9,t0     /* get second-level index */
  989. bb,>=,n         ptp,_PAGE_PRESENT_BIT,dtlb_check_alias_20w
  990. depdi           0,63,12,ptp     /* clear prot bits */
  992. /* Second level page table lookup */
  994. ldd,s           t0(ptp),ptp
  995. extrd,u         va,51,9,t0     /* get third-level index */
  996. bb,>=,n         ptp,_PAGE_PRESENT_BIT,dtlb_check_alias_20w
  997. depdi           0,63,12,ptp     /* clear prot bits */
  999. /* Third level page table lookup */
  1001. shladd           t0,3,ptp,ptp
  1002. ldi _PAGE_ACCESSED,t1
  1003. ldd              0(ptp),pte
  1004. bb,>=,n          pte,_PAGE_PRESENT_BIT,dtlb_check_alias_20w
  1006. /* Check whether the "accessed" bit was set, otherwise do so */
  1008. or t1,pte,t0 /* t0 has R bit set */
  1009. and,*<>         t1,pte,%r0      /* test and nullify if already set */
  1010. std             t0,0(ptp)       /* write back pte */
  1012. space_to_prot   spc prot        /* create prot id from space */
  1013. depd            pte,8,7,prot    /* add in prot bits from pte */
  1015. extrd,u,*=      pte,_PAGE_USER_BIT+32,1,r0
  1016. depdi 7,11,3,prot   /* Set for user space (1 rsvd for read) */
  1017. extrd,u,*=  pte,_PAGE_GATEWAY_BIT+32,1,r0
  1018. depdi 0,11,2,prot /* If Gateway, Set PL2 to 0 */
  1020. /* Get rid of prot bits and convert to page addr for idtlbt */
  1022. depdi 0,63,12,pte
  1023. extrd,u         pte,56,52,pte
  1024. idtlbt          pte,prot
  1026. rfir
  1027. nop
  1029. dtlb_check_alias_20w:
  1031. /* Check to see if fault is in the temporary alias region */
  1033. cmpib,*<>,n     0,spc,dtlb_fault /* forward */
  1034. ldil            L%(TMPALIAS_MAP_START),t0
  1035. copy            va,t1
  1036. depdi           0,63,23,t1
  1037. cmpb,*<>,n      t0,t1,dtlb_fault /* forward */
  1038. ldi             (_PAGE_DIRTY|_PAGE_WRITE|_PAGE_READ),prot
  1039. depd,z          prot,8,7,prot
  1041. /*
  1042.  * OK, it is in the temp alias region, check whether "from" or "to".
  1043.  * Check "subtle" note in pacache.S re: r23/r26.
  1044.  */
  1046. extrd,u,*=      va,41,1,r0
  1047. or,*tr          %r23,%r0,pte    /* If "from" use "from" page */
  1048. or,*            %r26,%r0,pte    /* else "to", use "to" page  */
  1050. idtlbt          pte,prot
  1052. rfir
  1053. nop
  1055. nadtlb_miss_20w:
  1056. extrd,u         spc,63,7,t1     /* adjust va */
  1057. depd            t1,31,7,va      /* adjust va */
  1058. depdi           0,63,7,spc      /* adjust space */
  1059. mfctl           %cr25,ptp /* Assume user space miss */
  1060. or,*<>          %r0,spc,%r0     /* If it is user space, nullify */
  1061. mfctl           %cr24,ptp /* Load kernel pgd instead */
  1062. extrd,u         va,33,9,t1      /* Get pgd index */
  1064. mfsp            %sr7,t0 /* Get current space */
  1065. or,*=           %r0,t0,%r0      /* If kernel, nullify following test */
  1066. cmpb,*<>,n       t0,spc,nadtlb_fault /* forward */
  1068. /* First level page table lookup */
  1070. ldd,s           t1(ptp),ptp
  1071. extrd,u         va,42,9,t0     /* get second-level index */
  1072. bb,>=,n         ptp,_PAGE_PRESENT_BIT,nadtlb_emulate
  1073. depdi           0,63,12,ptp     /* clear prot bits */
  1075. /* Second level page table lookup */
  1077. ldd,s           t0(ptp),ptp
  1078. extrd,u         va,51,9,t0     /* get third-level index */
  1079. bb,>=,n         ptp,_PAGE_PRESENT_BIT,nadtlb_emulate
  1080. depdi           0,63,12,ptp     /* clear prot bits */
  1082. /* Third level page table lookup */
  1084. shladd           t0,3,ptp,ptp
  1085. ldi _PAGE_ACCESSED,t1
  1086. ldd              0(ptp),pte
  1087. bb,>=,n          pte,_PAGE_PRESENT_BIT,nadtlb_check_flush_20w
  1089. space_to_prot   spc prot        /* create prot id from space */
  1090. depd            pte,8,7,prot    /* add in prot bits from pte */
  1092. extrd,u,*=      pte,_PAGE_USER_BIT+32,1,r0
  1093. depdi 7,11,3,prot   /* Set for user space (1 rsvd for read) */
  1094. extrd,u,*=  pte,_PAGE_GATEWAY_BIT+32,1,r0
  1095. depdi 0,11,2,prot /* If Gateway, Set PL2 to 0 */
  1097. /* Get rid of prot bits and convert to page addr for idtlbt */
  1099. depdi 0,63,12,pte
  1100. extrd,u         pte,56,52,pte
  1101. idtlbt          pte,prot
  1103. rfir
  1104. nop
  1106. nadtlb_check_flush_20w:
  1107. bb,>=,n          pte,_PAGE_FLUSH_BIT,nadtlb_emulate
  1109. /* Insert a "flush only" translation */
  1111. depdi,z         7,7,3,prot
  1112. depdi           1,10,1,prot
  1114. /* Get rid of prot bits and convert to page addr for idtlbt */
  1116. depdi 0,63,12,pte
  1117. extrd,u         pte,56,52,pte
  1118. idtlbt          pte,prot
  1120. rfir
  1121. nop
  1123. #else
  1125. dtlb_miss_11:
  1126. mfctl           %cr25,ptp /* Assume user space miss */
  1127. or,<>           %r0,spc,%r0 /* If it is user space, nullify */
  1128. mfctl           %cr24,ptp /* Load kernel pgd instead */
  1129. extru va,9,10,t1 /* Get pgd index */
  1131. mfsp            %sr7,t0 /* Get current space */
  1132. or,=            %r0,t0,%r0 /* If kernel, nullify following test */
  1133. cmpb,<>,n       t0,spc,dtlb_fault /* forward */
  1135. /* First level page table lookup */
  1137. ldwx,s t1(ptp),ptp
  1138. extru va,19,10,t0 /* get second-level index */
  1139. bb,>=,n         ptp,_PAGE_PRESENT_BIT,dtlb_check_alias_11
  1140. depi 0,31,12,ptp /* clear prot bits */
  1142. /* Second level page table lookup */
  1144. sh2addl   t0,ptp,ptp
  1145. ldi _PAGE_ACCESSED,t1
  1146. ldw  0(ptp),pte
  1147. bb,>=,n          pte,_PAGE_PRESENT_BIT,dtlb_check_alias_11
  1149. /* Check whether the "accessed" bit was set, otherwise do so */
  1151. or t1,pte,t0 /* t0 has R bit set */
  1152. and,<> t1,pte,%r0 /* test and nullify if already set */
  1153. stw t0,0(ptp) /* write back pte */
  1155. zdep            spc,30,15,prot  /* create prot id from space */
  1156. dep             pte,8,7,prot    /* add in prot bits from pte */
  1158. extru,= pte,_PAGE_NO_CACHE_BIT,1,r0
  1159. depi 1,12,1,prot
  1160. extru,=         pte,_PAGE_USER_BIT,1,r0
  1161. depi 7,11,3,prot   /* Set for user space (1 rsvd for read) */
  1162. extru,=  pte,_PAGE_GATEWAY_BIT,1,r0
  1163. depi 0,11,2,prot /* If Gateway, Set PL2 to 0 */
  1165. /* Get rid of prot bits and convert to page addr for idtlba */
  1167. depi 0,31,12,pte
  1168. extru pte,24,25,pte
  1170. mfsp %sr1,t0  /* Save sr1 so we can use it in tlb inserts */
  1171. mtsp spc,%sr1
  1173. idtlba pte,(%sr1,va)
  1174. idtlbp prot,(%sr1,va)
  1176. mtsp t0, %sr1 /* Restore sr1 */
  1178. rfir
  1179. nop
  1181. dtlb_check_alias_11:
  1183. /* Check to see if fault is in the temporary alias region */
  1185. cmpib,<>,n      0,spc,dtlb_fault /* forward */
  1186. ldil            L%(TMPALIAS_MAP_START),t0
  1187. copy            va,t1
  1188. depwi           0,31,23,t1
  1189. cmpb,<>,n       t0,t1,dtlb_fault /* forward */
  1190. ldi             (_PAGE_DIRTY|_PAGE_WRITE|_PAGE_READ),prot
  1191. depw,z          prot,8,7,prot
  1193. /*
  1194.  * OK, it is in the temp alias region, check whether "from" or "to".
  1195.  * Check "subtle" note in pacache.S re: r23/r26.
  1196.  */
  1198. extrw,u,=       va,9,1,r0
  1199. or,tr           %r23,%r0,pte    /* If "from" use "from" page */
  1200. or              %r26,%r0,pte    /* else "to", use "to" page  */
  1202. idtlba          pte,(va)
  1203. idtlbp          prot,(va)
  1205. rfir
  1206. nop
  1208. nadtlb_miss_11:
  1209. mfctl           %cr25,ptp /* Assume user space miss */
  1210. or,<>           %r0,spc,%r0 /* If it is user space, nullify */
  1211. mfctl           %cr24,ptp /* Load kernel pgd instead */
  1212. extru va,9,10,t1 /* Get pgd index */
  1214. mfsp            %sr7,t0 /* Get current space */
  1215. or,=            %r0,t0,%r0 /* If kernel, nullify following test */
  1216. cmpb,<>,n       t0,spc,nadtlb_fault /* forward */
  1218. /* First level page table lookup */
  1220. ldwx,s t1(ptp),ptp
  1221. extru va,19,10,t0 /* get second-level index */
  1222. bb,>=,n         ptp,_PAGE_PRESENT_BIT,nadtlb_emulate
  1223. depi 0,31,12,ptp /* clear prot bits */
  1225. /* Second level page table lookup */
  1227. sh2addl   t0,ptp,ptp
  1228. ldi _PAGE_ACCESSED,t1
  1229. ldw  0(ptp),pte
  1230. bb,>=,n          pte,_PAGE_PRESENT_BIT,nadtlb_check_flush_11
  1232. zdep            spc,30,15,prot  /* create prot id from space */
  1233. dep             pte,8,7,prot    /* add in prot bits from pte */
  1235. extru,= pte,_PAGE_NO_CACHE_BIT,1,r0
  1236. depi 1,12,1,prot
  1237. extru,=         pte,_PAGE_USER_BIT,1,r0
  1238. depi 7,11,3,prot   /* Set for user space (1 rsvd for read) */
  1239. extru,=  pte,_PAGE_GATEWAY_BIT,1,r0
  1240. depi 0,11,2,prot /* If Gateway, Set PL2 to 0 */
  1242. /* Get rid of prot bits and convert to page addr for idtlba */
  1244. depi 0,31,12,pte
  1245. extru pte,24,25,pte
  1247. mfsp %sr1,t0  /* Save sr1 so we can use it in tlb inserts */
  1248. mtsp spc,%sr1
  1250. idtlba pte,(%sr1,va)
  1251. idtlbp prot,(%sr1,va)
  1253. mtsp t0, %sr1 /* Restore sr1 */
  1255. rfir
  1256. nop
  1258. nadtlb_check_flush_11:
  1259. bb,>=,n          pte,_PAGE_FLUSH_BIT,nadtlb_emulate
  1261. /* Insert a "flush only" translation */
  1263. zdepi           7,7,3,prot
  1264. depi            1,10,1,prot
  1266. /* Get rid of prot bits and convert to page addr for idtlba */
  1268. depi 0,31,12,pte
  1269. extru pte,24,25,pte
  1271. mfsp %sr1,t0  /* Save sr1 so we can use it in tlb inserts */
  1272. mtsp spc,%sr1
  1274. idtlba pte,(%sr1,va)
  1275. idtlbp prot,(%sr1,va)
  1277. mtsp t0, %sr1 /* Restore sr1 */
  1279. rfir
  1280. nop
  1282. dtlb_miss_20:
  1283. mfctl           %cr25,ptp /* Assume user space miss */
  1284. or,<>           %r0,spc,%r0 /* If it is user space, nullify */
  1285. mfctl           %cr24,ptp /* Load kernel pgd instead */
  1286. extru va,9,10,t1 /* Get pgd index */
  1288. mfsp            %sr7,t0 /* Get current space */
  1289. or,=            %r0,t0,%r0 /* If kernel, nullify following test */
  1290. cmpb,<>,n       t0,spc,dtlb_fault /* forward */
  1292. /* First level page table lookup */
  1294. ldwx,s t1(ptp),ptp
  1295. extru va,19,10,t0 /* get second-level index */
  1296. bb,>=,n         ptp,_PAGE_PRESENT_BIT,dtlb_check_alias_20
  1297. depi 0,31,12,ptp /* clear prot bits */
  1299. /* Second level page table lookup */
  1301. sh2addl   t0,ptp,ptp
  1302. ldi _PAGE_ACCESSED,t1
  1303. ldw  0(ptp),pte
  1304. bb,>=,n          pte,_PAGE_PRESENT_BIT,dtlb_check_alias_20
  1306. /* Check whether the "accessed" bit was set, otherwise do so */
  1308. or t1,pte,t0 /* t0 has R bit set */
  1309. and,<> t1,pte,%r0 /* test and nullify if already set */
  1310. stw t0,0(ptp) /* write back pte */
  1312. space_to_prot   spc prot        /* create prot id from space */
  1313. depd            pte,8,7,prot    /* add in prot bits from pte */
  1315. extrd,u,*=      pte,_PAGE_USER_BIT+32,1,r0
  1316. depdi 7,11,3,prot   /* Set for user space (1 rsvd for read) */
  1317. extrd,u,*=  pte,_PAGE_GATEWAY_BIT+32,1,r0
  1318. depdi 0,11,2,prot /* If Gateway, Set PL2 to 0 */
  1320. /* Get rid of prot bits and convert to page addr for idtlbt */
  1322. extrd,s         pte,35,4,t0
  1323. depdi 0,63,12,pte /* clear lower 12 bits */
  1324.         addi,=          1,t0,0 
  1325.         extrd,u,*tr     pte,56,25,pte 
  1326. extrd,s pte,56,25,pte /* bit 31:8 >> 8  */ 
  1327. idtlbt          pte,prot
  1329. rfir
  1330. nop
  1332. dtlb_check_alias_20:
  1334. /* Check to see if fault is in the temporary alias region */
  1336. cmpib,<>,n      0,spc,dtlb_fault /* forward */
  1337. ldil            L%(TMPALIAS_MAP_START),t0
  1338. copy            va,t1
  1339. depwi           0,31,23,t1
  1340. cmpb,<>,n       t0,t1,dtlb_fault /* forward */
  1341. ldi             (_PAGE_DIRTY|_PAGE_WRITE|_PAGE_READ),prot
  1342. depd,z          prot,8,7,prot
  1344. /*
  1345.  * OK, it is in the temp alias region, check whether "from" or "to".
  1346.  * Check "subtle" note in pacache.S re: r23/r26.
  1347.  */
  1349. extrw,u,=       va,9,1,r0
  1350. or,tr           %r23,%r0,pte    /* If "from" use "from" page */
  1351. or              %r26,%r0,pte    /* else "to", use "to" page  */
  1353. idtlbt          pte,prot
  1355. rfir
  1356. nop
  1358. nadtlb_miss_20:
  1359. mfctl           %cr25,ptp /* Assume user space miss */
  1360. or,<>           %r0,spc,%r0 /* If it is user space, nullify */
  1361. mfctl           %cr24,ptp /* Load kernel pgd instead */
  1362. extru va,9,10,t1 /* Get pgd index */
  1364. mfsp            %sr7,t0 /* Get current space */
  1365. or,=            %r0,t0,%r0 /* If kernel, nullify following test */
  1366. cmpb,<>,n       t0,spc,nadtlb_fault /* forward */
  1368. /* First level page table lookup */
  1370. ldwx,s t1(ptp),ptp
  1371. extru va,19,10,t0 /* get second-level index */
  1372. bb,>=,n         ptp,_PAGE_PRESENT_BIT,nadtlb_emulate
  1373. depi 0,31,12,ptp /* clear prot bits */
  1375. /* Second level page table lookup */
  1377. sh2addl   t0,ptp,ptp
  1378. ldi _PAGE_ACCESSED,t1
  1379. ldw  0(ptp),pte
  1380. bb,>=,n          pte,_PAGE_PRESENT_BIT,nadtlb_check_flush_20
  1382. space_to_prot   spc prot        /* create prot id from space */
  1383. depd            pte,8,7,prot    /* add in prot bits from pte */
  1385. extrd,u,*=      pte,_PAGE_USER_BIT+32,1,r0
  1386. depdi 7,11,3,prot   /* Set for user space (1 rsvd for read) */
  1387. extrd,u,*=  pte,_PAGE_GATEWAY_BIT+32,1,r0
  1388. depdi 0,11,2,prot /* If Gateway, Set PL2 to 0 */
  1390. /* Get rid of prot bits and convert to page addr for idtlbt */
  1392.         extrd,s         pte,35,4,t0
  1393.         depdi           0,63,12,pte     /* clear lower 12 bits */
  1394.         addi,=          1,t0,0
  1395.         extrd,u,*tr     pte,56,25,pte
  1396.         extrd,s         pte,56,25,pte   /* bit 31:8 >> 8  */
  1397.         idtlbt          pte,prot
  1399. rfir
  1400. nop
  1402. nadtlb_check_flush_20:
  1403. bb,>=,n          pte,_PAGE_FLUSH_BIT,nadtlb_emulate
  1405. /* Insert a "flush only" translation */
  1407. depdi,z         7,7,3,prot
  1408. depdi           1,10,1,prot
  1410. /* Get rid of prot bits and convert to page addr for idtlbt */
  1412. depdi 0,63,12,pte
  1413. extrd,u         pte,56,32,pte
  1414. idtlbt          pte,prot
  1416. rfir
  1417. nop
  1418. #endif
  1420. nadtlb_emulate:
  1422. /*
  1423.  * Non access misses can be caused by fdc,fic,pdc,lpa,probe and
  1424.  * probei instructions. We don't want to fault for these
  1425.  * instructions (not only does it not make sense, it can cause
  1426.  * deadlocks, since some flushes are done with the mmap
  1427.  * semaphore held). If the translation doesn't exist, we can't
  1428.  * insert a translation, so have to emulate the side effects
  1429.  * of the instruction. Since we don't insert a translation
  1430.  * we can get a lot of faults during a flush loop, so it makes
  1431.  * sense to try to do it here with minimum overhead. We only
  1432.  * emulate fdc,fic & pdc instructions whose base and index
  1433.  * registers are not shadowed. We defer everything else to the
  1434.  * "slow" path.
  1435.  */
  1437. mfctl           %cr19,%r9 /* Get iir */
  1438. ldi             0x280,%r16
  1439. and             %r9,%r16,%r17
  1440. cmpb,<>,n       %r16,%r17,nadtlb_fault /* Not fdc,fic,pdc */
  1441. bb,>=,n         %r9,26,nadtlb_nullify  /* m bit not set, just nullify */
  1442. b,l             get_register,%r25
  1443. extrw,u         %r9,15,5,%r8           /* Get index register # */
  1444. CMPIB=,n        -1,%r1,nadtlb_fault    /* have to use slow path */
  1445. copy            %r1,%r24
  1446. b,l             get_register,%r25
  1447. extrw,u         %r9,10,5,%r8           /* Get base register # */
  1448. CMPIB=,n        -1,%r1,nadtlb_fault    /* have to use slow path */
  1449. b,l             set_register,%r25
  1450. add,l           %r1,%r24,%r1           /* doesn't affect c/b bits */
  1452. nadtlb_nullify:
  1453. mfctl           %cr22,%r8              /* Get ipsw */
  1454. ldil            L%PSW_N,%r9
  1455. or              %r8,%r9,%r8            /* Set PSW_N */
  1456. mtctl           %r8,%cr22
  1458. rfir
  1459. nop
  1461. #ifdef __LP64__
  1462. itlb_miss_20w:
  1464. /*
  1465.  * I miss is a little different, since we allow users to fault
  1466.  * on the gateway page which is in the kernel address space.
  1467.  */
  1469. extrd,u         spc,63,7,t1     /* adjust va */
  1470. depd            t1,31,7,va      /* adjust va */
  1471. depdi           0,63,7,spc      /* adjust space */
  1472. cmpib,*=        0,spc,itlb_miss_kernel_20w
  1473. extrd,u         va,33,9,t1      /* Get pgd index */
  1475. mfctl           %cr25,ptp /* load user pgd */
  1477. mfsp            %sr7,t0 /* Get current space */
  1478. or,*=           %r0,t0,%r0      /* If kernel, nullify following test */
  1479. cmpb,*<>,n      t0,spc,itlb_fault /* forward */
  1481. /* First level page table lookup */
  1483. itlb_miss_common_20w:
  1484. ldd,s           t1(ptp),ptp
  1485. extrd,u         va,42,9,t0     /* get second-level index */
  1486. bb,>=,n  ptp,_PAGE_PRESENT_BIT,itlb_fault
  1487. depdi           0,63,12,ptp     /* clear prot bits */
  1489. /* Second level page table lookup */
  1491. ldd,s           t0(ptp),ptp
  1492. extrd,u         va,51,9,t0     /* get third-level index */
  1493. bb,>=,n         ptp,_PAGE_PRESENT_BIT,itlb_fault
  1494. depdi           0,63,12,ptp     /* clear prot bits */
  1496. /* Third level page table lookup */
  1498. shladd           t0,3,ptp,ptp
  1499. ldi _PAGE_ACCESSED,t1
  1500. ldd              0(ptp),pte
  1501. bb,>=,n          pte,_PAGE_PRESENT_BIT,itlb_fault
  1503. /* Check whether the "accessed" bit was set, otherwise do so */
  1505. or t1,pte,t0 /* t0 has R bit set */
  1506. and,*<>         t1,pte,%r0      /* test and nullify if already set */
  1507. std             t0,0(ptp)       /* write back pte */
  1509. space_to_prot   spc prot        /* create prot id from space */
  1510. depd            pte,8,7,prot    /* add in prot bits from pte */
  1512. extrd,u,*=      pte,_PAGE_USER_BIT+32,1,r0
  1513. depdi 7,11,3,prot   /* Set for user space (1 rsvd for read) */
  1514. extrd,u,*=  pte,_PAGE_GATEWAY_BIT+32,1,r0
  1515. depdi 0,11,2,prot /* If Gateway, Set PL2 to 0 */
  1517. /* Get rid of prot bits and convert to page addr for iitlbt */
  1519. depdi 0,63,12,pte
  1520. extrd,u         pte,56,32,pte
  1521. iitlbt          pte,prot
  1523. rfir
  1524. nop
  1526. itlb_miss_kernel_20w:
  1527. b               itlb_miss_common_20w
  1528. mfctl           %cr24,ptp /* Load kernel pgd */
  1529. #else
  1531. itlb_miss_11:
  1533. /*
  1534.  * I miss is a little different, since we allow users to fault
  1535.  * on the gateway page which is in the kernel address space.
  1536.  */
  1538. cmpib,=         0,spc,itlb_miss_kernel_11
  1539. extru va,9,10,t1 /* Get pgd index */
  1541. mfctl           %cr25,ptp /* load user pgd */
  1543. mfsp            %sr7,t0 /* Get current space */
  1544. or,=            %r0,t0,%r0 /* If kernel, nullify following test */
  1545. cmpb,<>,n       t0,spc,itlb_fault /* forward */
  1547. /* First level page table lookup */
  1549. itlb_miss_common_11:
  1550. ldwx,s t1(ptp),ptp
  1551. extru va,19,10,t0 /* get second-level index */
  1552. bb,>=,n  ptp,_PAGE_PRESENT_BIT,itlb_fault
  1553. depi 0,31,12,ptp /* clear prot bits */
  1555. /* Second level page table lookup */
  1557. sh2addl   t0,ptp,ptp
  1558. ldi _PAGE_ACCESSED,t1
  1559. ldw  0(ptp),pte
  1560. bb,>=,n   pte,_PAGE_PRESENT_BIT,itlb_fault
  1562. /* Check whether the "accessed" bit was set, otherwise do so */
  1564. or t1,pte,t0 /* t0 has R bit set */
  1565. and,<> t1,pte,%r0 /* test and nullify if already set */
  1566. stw t0,0(ptp) /* write back pte */
  1568. zdep            spc,30,15,prot  /* create prot id from space */
  1569. dep             pte,8,7,prot    /* add in prot bits from pte */
  1571. extru,= pte,_PAGE_NO_CACHE_BIT,1,r0
  1572. depi 1,12,1,prot
  1573. extru,=         pte,_PAGE_USER_BIT,1,r0
  1574. depi 7,11,3,prot   /* Set for user space (1 rsvd for read) */
  1575. extru,=  pte,_PAGE_GATEWAY_BIT,1,r0
  1576. depi 0,11,2,prot /* If Gateway, Set PL2 to 0 */
  1578. /* Get rid of prot bits and convert to page addr for iitlba */
  1580. depi 0,31,12,pte
  1581. extru pte,24,25,pte
  1583. mfsp %sr1,t0  /* Save sr1 so we can use it in tlb inserts */
  1584. mtsp spc,%sr1
  1586. iitlba pte,(%sr1,va)
  1587. iitlbp prot,(%sr1,va)
  1589. mtsp t0, %sr1 /* Restore sr1 */
  1591. rfir
  1592. nop
  1594. itlb_miss_kernel_11:
  1595. b               itlb_miss_common_11
  1596. mfctl           %cr24,ptp /* Load kernel pgd */
  1598. itlb_miss_20:
  1600. /*
  1601.  * I miss is a little different, since we allow users to fault
  1602.  * on the gateway page which is in the kernel address space.
  1603.  */
  1605. cmpib,=         0,spc,itlb_miss_kernel_20
  1606. extru va,9,10,t1 /* Get pgd index */
  1608. mfctl           %cr25,ptp /* load user pgd */
  1610. mfsp            %sr7,t0 /* Get current space */
  1611. or,=            %r0,t0,%r0 /* If kernel, nullify following test */
  1612. cmpb,<>,n       t0,spc,itlb_fault /* forward */
  1614. /* First level page table lookup */
  1616. itlb_miss_common_20:
  1617. ldwx,s t1(ptp),ptp
  1618. extru va,19,10,t0 /* get second-level index */
  1619. bb,>=,n  ptp,_PAGE_PRESENT_BIT,itlb_fault
  1620. depi 0,31,12,ptp /* clear prot bits */
  1622. /* Second level page table lookup */
  1624. sh2addl   t0,ptp,ptp
  1625. ldi _PAGE_ACCESSED,t1
  1626. ldw  0(ptp),pte
  1627. bb,>=,n   pte,_PAGE_PRESENT_BIT,itlb_fault
  1629. /* Check whether the "accessed" bit was set, otherwise do so */
  1631. or t1,pte,t0 /* t0 has R bit set */
  1632. and,<> t1,pte,%r0 /* test and nullify if already set */
  1633. stw t0,0(ptp) /* write back pte */
  1635. space_to_prot   spc prot        /* create prot id from space */
  1636. depd            pte,8,7,prot    /* add in prot bits from pte */
  1638. extrd,u,*=      pte,_PAGE_USER_BIT+32,1,r0
  1639. depdi 7,11,3,prot   /* Set for user space (1 rsvd for read) */
  1640. extrd,u,*=  pte,_PAGE_GATEWAY_BIT+32,1,r0
  1641. depdi 0,11,2,prot /* If Gateway, Set PL2 to 0 */
  1643. /* Get rid of prot bits and convert to page addr for iitlbt */
  1645.         extrd,s         pte,35,4,t0 
  1646.         depdi           0,63,12,pte     /* clear lower 12 bits */
  1647.         addi,=          1,t0,0
  1648.         extrd,u,*tr     pte,56,25,pte 
  1649.         extrd,s         pte,56,25,pte   /* bit 31:8 >> 8  */
  1650. iitlbt          pte,prot
  1652. rfir
  1653. nop
  1656. itlb_miss_kernel_20:
  1657. b               itlb_miss_common_20
  1658. mfctl           %cr24,ptp /* Load kernel pgd */
  1659. #endif
  1661. #ifdef __LP64__
  1663. dbit_trap_20w:
  1664. extrd,u         spc,63,7,t1     /* adjust va */
  1665. depd            t1,31,7,va      /* adjust va */
  1666. depdi           0,1,2,va        /* adjust va */
  1667. depdi           0,63,7,spc      /* adjust space */
  1668. mfctl           %cr25,ptp /* Assume user space miss */
  1669. or,*<>          %r0,spc,%r0     /* If it is user space, nullify */
  1670. mfctl           %cr24,ptp /* Load kernel pgd instead */
  1671. extrd,u         va,33,9,t1      /* Get pgd index */
  1673. mfsp            %sr7,t0 /* Get current space */
  1674. or,*=           %r0,t0,%r0      /* If kernel, nullify following test */
  1675. cmpb,*<>,n       t0,spc,dbit_fault /* forward */
  1677. /* First level page table lookup */
  1679. ldd,s           t1(ptp),ptp
  1680. extrd,u         va,42,9,t0     /* get second-level index */
  1681. bb,>=,n         ptp,_PAGE_PRESENT_BIT,dbit_fault
  1682. depdi           0,63,12,ptp     /* clear prot bits */
  1684. /* Second level page table lookup */
  1686. ldd,s           t0(ptp),ptp
  1687. extrd,u         va,51,9,t0     /* get third-level index */
  1688. bb,>=,n         ptp,_PAGE_PRESENT_BIT,dbit_fault
  1689. depdi           0,63,12,ptp     /* clear prot bits */
  1691. /* Third level page table lookup */
  1693. shladd           t0,3,ptp,ptp
  1694. #ifdef CONFIG_SMP
  1695. CMPIB=,n        0,spc,dbit_nolock_20w
  1696. ldil            L%PA(pa_dbit_lock),t0
  1697. ldo             R%PA(pa_dbit_lock)(t0),t0
  1699. dbit_spin_20w:
  1700. ldcw            0(t0),t1
  1701. cmpib,=         0,t1,dbit_spin_20w
  1702. nop
  1704. dbit_nolock_20w:
  1705. #endif
  1706. ldi (_PAGE_ACCESSED|_PAGE_DIRTY),t1
  1707. ldd              0(ptp),pte
  1708. bb,>=,n          pte,_PAGE_PRESENT_BIT,dbit_fault
  1710. /* Set Accessed and Dirty bits in the pte */
  1712. or t1,pte,pte
  1713. std             pte,0(ptp)      /* write back pte */
  1715. space_to_prot   spc prot        /* create prot id from space */
  1716. depd            pte,8,7,prot    /* add in prot bits from pte */
  1718. extrd,u,*=      pte,_PAGE_USER_BIT+32,1,r0
  1719. depdi 7,11,3,prot   /* Set for user space (1 rsvd for read) */
  1720. extrd,u,*=  pte,_PAGE_GATEWAY_BIT+32,1,r0
  1721. depdi 0,11,2,prot /* If Gateway, Set PL2 to 0 */
  1723. /* Get rid of prot bits and convert to page addr for idtlbt */
  1725. depdi 0,63,12,pte
  1726. extrd,u         pte,56,52,pte
  1727. idtlbt          pte,prot
  1728. #ifdef CONFIG_SMP
  1729. CMPIB=,n        0,spc,dbit_nounlock_20w
  1730. ldi             1,t1
  1731. stw             t1,0(t0)
  1733. dbit_nounlock_20w:
  1734. #endif
  1736. rfir
  1737. nop
  1738. #else
  1740. dbit_trap_11:
  1741. mfctl           %cr25,ptp /* Assume user space trap */
  1742. or,<>           %r0,spc,%r0 /* If it is user space, nullify */
  1743. mfctl           %cr24,ptp /* Load kernel pgd instead */
  1744. extru va,9,10,t1 /* Get pgd index */
  1746. mfsp            %sr7,t0 /* Get current space */
  1747. or,=            %r0,t0,%r0 /* If kernel, nullify following test */
  1748. cmpb,<>,n       t0,spc,dbit_fault /* forward */
  1750. /* First level page table lookup */
  1752. ldwx,s t1(ptp),ptp
  1753. extru va,19,10,t0 /* get second-level index */
  1754. bb,>=,n  ptp,_PAGE_PRESENT_BIT,dbit_fault
  1755. depi 0,31,12,ptp /* clear prot bits */
  1757. /* Second level page table lookup */
  1759. sh2addl   t0,ptp,ptp
  1760. #ifdef CONFIG_SMP
  1761. CMPIB=,n        0,spc,dbit_nolock_11
  1762. ldil            L%PA(pa_dbit_lock),t0
  1763. ldo             R%PA(pa_dbit_lock)(t0),t0
  1765. dbit_spin_11:
  1766. ldcw            0(t0),t1
  1767. cmpib,=         0,t1,dbit_spin_11
  1768. nop
  1770. dbit_nolock_11:
  1771. #endif
  1772. ldi (_PAGE_ACCESSED|_PAGE_DIRTY),t1
  1773. ldw  0(ptp),pte
  1774. bb,>=,n   pte,_PAGE_PRESENT_BIT,dbit_fault
  1776. /* Set Accessed and Dirty bits in the pte */
  1778. or t1,pte,pte
  1779. stw pte,0(ptp) /* write back pte */
  1781. zdep            spc,30,15,prot  /* create prot id from space */
  1782. dep             pte,8,7,prot    /* add in prot bits from pte */
  1784. extru,= pte,_PAGE_NO_CACHE_BIT,1,r0
  1785. depi 1,12,1,prot
  1786. extru,=         pte,_PAGE_USER_BIT,1,r0
  1787. depi 7,11,3,prot /* Set for user space (1 rsvd for read) */
  1788. extru,=  pte,_PAGE_GATEWAY_BIT,1,r0
  1789. depi 0,11,2,prot /* If Gateway, Set PL2 to 0 */
  1791. /* Get rid of prot bits and convert to page addr for idtlba */
  1793. depi 0,31,12,pte
  1794. extru pte,24,25,pte
  1796. mfsp            %sr1,t1  /* Save sr1 so we can use it in tlb inserts */
  1797. mtsp spc,%sr1
  1799. idtlba pte,(%sr1,va)
  1800. idtlbp prot,(%sr1,va)
  1802. mtsp            t1, %sr1     /* Restore sr1 */
  1803. #ifdef CONFIG_SMP
  1804. CMPIB=,n        0,spc,dbit_nounlock_11
  1805. ldi             1,t1
  1806. stw             t1,0(t0)
  1808. dbit_nounlock_11:
  1809. #endif
  1811. rfir
  1812. nop
  1814. dbit_trap_20:
  1815. mfctl           %cr25,ptp /* Assume user space trap */
  1816. or,<>           %r0,spc,%r0 /* If it is user space, nullify */
  1817. mfctl           %cr24,ptp /* Load kernel pgd instead */
  1818. extru va,9,10,t1 /* Get pgd index */
  1820. mfsp            %sr7,t0 /* Get current space */
  1821. or,=            %r0,t0,%r0 /* If kernel, nullify following test */
  1822. cmpb,<>,n       t0,spc,dbit_fault /* forward */
  1824. /* First level page table lookup */
  1826. ldwx,s t1(ptp),ptp
  1827. extru va,19,10,t0 /* get second-level index */
  1828. bb,>=,n  ptp,_PAGE_PRESENT_BIT,dbit_fault
  1829. depi 0,31,12,ptp /* clear prot bits */
  1831. /* Second level page table lookup */
  1833. sh2addl   t0,ptp,ptp
  1834. #ifdef CONFIG_SMP
  1835. CMPIB=,n        0,spc,dbit_nolock_20
  1836. ldil            L%PA(pa_dbit_lock),t0
  1837. ldo             R%PA(pa_dbit_lock)(t0),t0
  1839. dbit_spin_20:
  1840. ldcw            0(t0),t1
  1841. cmpib,=         0,t1,dbit_spin_20
  1842. nop
  1844. dbit_nolock_20:
  1845. #endif
  1846. ldi (_PAGE_ACCESSED|_PAGE_DIRTY),t1
  1847. ldw  0(ptp),pte
  1848. bb,>=,n   pte,_PAGE_PRESENT_BIT,dbit_fault
  1850. /* Set Accessed and Dirty bits in the pte */
  1852. or t1,pte,pte
  1853. stw pte,0(ptp) /* write back pte */
  1855. space_to_prot   spc prot        /* create prot id from space */
  1856. depd            pte,8,7,prot    /* add in prot bits from pte */
  1858. extrd,u,*=      pte,_PAGE_USER_BIT+32,1,r0
  1859. depdi 7,11,3,prot   /* Set for user space (1 rsvd for read) */
  1860. extrd,u,*=  pte,_PAGE_GATEWAY_BIT+32,1,r0
  1861. depdi 0,11,2,prot /* If Gateway, Set PL2 to 0 */
  1863.         extrd,s         pte,35,4,t0 
  1864.         depdi           0,63,12,pte     /* clear lower 12 bits */
  1865.         addi,=          1,t0,0
  1866.         extrd,u,*tr     pte,56,25,pte 
  1867.         extrd,s         pte,56,25,pte   /* bit 31:8 >> 8  */
  1868.         idtlbt          pte,prot
  1870. #ifdef CONFIG_SMP
  1871. CMPIB=,n        0,spc,dbit_nounlock_20
  1872. ldi             1,t1
  1873. stw             t1,0(t0)
  1875. dbit_nounlock_20:
  1876. #endif
  1878. rfir
  1879. nop
  1880. #endif
  1882. .import handle_interruption,code
  1884. kernel_bad_space:
  1885. b               intr_save
  1886. ldi             31,%r8  /* Use an unused code */
  1888. dbit_fault:
  1889. b               intr_save
  1890. ldi             20,%r8
  1892. itlb_fault:
  1893. b               intr_save
  1894. ldi             6,%r8
  1896. nadtlb_fault:
  1897. b               intr_save
  1898. ldi             17,%r8
  1900. dtlb_fault:
  1901. b               intr_save
  1902. ldi             15,%r8
  1904. /* Register saving semantics for system calls:
  1906.    %r1    clobbered by system call macro in userspace
  1907.    %r2    saved in PT_REGS by gateway page
  1908.    %r3  - %r18    preserved by C code (saved by signal code)
  1909.    %r19 - %r20    saved in PT_REGS by gateway page
  1910.    %r21 - %r22    non-standard syscall args
  1911.    stored in kernel stack by gateway page
  1912.    %r23 - %r26    arg3-arg0, saved in PT_REGS by gateway page
  1913.    %r27 - %r30    saved in PT_REGS by gateway page
  1914.    %r31    syscall return pointer
  1915.  */
  1917. /* Floating point registers (FIXME: what do we do with these?)
  1919.    %fr0  - %fr3    status/exception, not preserved
  1920.    %fr4  - %fr7    arguments
  1921.    %fr8  - %fr11   not preserved by C code
  1922.    %fr12 - %fr21   preserved by C code
  1923.    %fr22 - %fr31   not preserved by C code
  1924.  */
  1926. .macro reg_save regs
  1927. STREG %r3, PT_GR3(regs)
  1928. STREG %r4, PT_GR4(regs)
  1929. STREG %r5, PT_GR5(regs)
  1930. STREG %r6, PT_GR6(regs)
  1931. STREG %r7, PT_GR7(regs)
  1932. STREG %r8, PT_GR8(regs)
  1933. STREG %r9, PT_GR9(regs)
  1934. STREG   %r10,PT_GR10(regs)
  1935. STREG   %r11,PT_GR11(regs)
  1936. STREG   %r12,PT_GR12(regs)
  1937. STREG   %r13,PT_GR13(regs)
  1938. STREG   %r14,PT_GR14(regs)
  1939. STREG   %r15,PT_GR15(regs)
  1940. STREG   %r16,PT_GR16(regs)
  1941. STREG   %r17,PT_GR17(regs)
  1942. STREG   %r18,PT_GR18(regs)
  1943. .endm
  1945. .macro reg_restore regs
  1946. LDREG PT_GR3(regs), %r3
  1947. LDREG PT_GR4(regs), %r4
  1948. LDREG PT_GR5(regs), %r5
  1949. LDREG PT_GR6(regs), %r6
  1950. LDREG PT_GR7(regs), %r7
  1951. LDREG PT_GR8(regs), %r8
  1952. LDREG PT_GR9(regs), %r9
  1953. LDREG   PT_GR10(regs),%r10
  1954. LDREG   PT_GR11(regs),%r11
  1955. LDREG   PT_GR12(regs),%r12
  1956. LDREG   PT_GR13(regs),%r13
  1957. LDREG   PT_GR14(regs),%r14
  1958. LDREG   PT_GR15(regs),%r15
  1959. LDREG   PT_GR16(regs),%r16
  1960. LDREG   PT_GR17(regs),%r17
  1961. LDREG   PT_GR18(regs),%r18
  1962. .endm
  1964. .export sys_fork_wrapper
  1965. .export child_return
  1966. sys_fork_wrapper:
  1967. ldo TASK_REGS-TASK_SZ_ALGN-FRAME_SIZE(%r30),%r1 /* get pt regs */
  1968. reg_save %r1
  1969. mfctl %cr27, %r3
  1970. STREG %r3, PT_CR27(%r1)
  1972. STREG %r2,-RP_OFFSET(%r30)
  1973. ldo FRAME_SIZE(%r30),%r30
  1974. #ifdef __LP64__
  1975. ldo -16(%r30),%r29 /* Reference param save area */
  1976. #endif
  1978. /* These are call-clobbered registers and therefore
  1979.    also syscall-clobbered (we hope). */
  1980. STREG %r2,PT_GR19(%r1) /* save for child */
  1981. STREG %r30,PT_GR21(%r1)
  1983. LDREG PT_GR30(%r1),%r25
  1984. copy %r1,%r24
  1985. bl sys_clone,%r2
  1986. ldi SIGCHLD,%r26
  1988. LDREG -RP_OFFSET-FRAME_SIZE(%r30),%r2
  1989. wrapper_exit:
  1990. ldo -FRAME_SIZE(%r30),%r30 /* get the stackframe */
  1991. ldo TASK_REGS-TASK_SZ_ALGN-FRAME_SIZE(%r30),%r1    /* get pt regs */
  1993. LDREG PT_CR27(%r1), %r3
  1994. mtctl %r3, %cr27
  1995. reg_restore %r1
  1997. /* strace expects syscall # to be preserved in r20 */
  1998. ldi __NR_fork,%r20
  1999. bv %r0(%r2)
  2000. STREG %r20,PT_GR20(%r1)
  2002. /* Set the return value for the child */
  2003. child_return:
  2004. bl schedule_tail, %r2
  2005. nop
  2007. LDREG TASK_PT_GR19-TASK_SZ_ALGN-FRAME_SIZE-FRAME_SIZE(%r30),%r2
  2008. b wrapper_exit
  2009. copy %r0,%r28
  2012. .export sys_clone_wrapper
  2013. sys_clone_wrapper:
  2014. ldo TASK_REGS-TASK_SZ_ALGN-FRAME_SIZE(%r30),%r1 /* get pt regs */
  2015. reg_save %r1
  2016. mfctl %cr27, %r3
  2017. STREG %r3, PT_CR27(%r1)
  2019. STREG %r2,-RP_OFFSET(%r30)
  2020. ldo FRAME_SIZE(%r30),%r30
  2021. #ifdef __LP64__
  2022. ldo -16(%r30),%r29 /* Reference param save area */
  2023. #endif
  2025. STREG %r2,PT_GR19(%r1) /* save for child */
  2026. STREG %r30,PT_GR21(%r1)
  2027. bl sys_clone,%r2
  2028. copy %r1,%r24
  2030. b wrapper_exit
  2031. LDREG -RP_OFFSET-FRAME_SIZE(%r30),%r2
  2033. .export sys_vfork_wrapper
  2034. sys_vfork_wrapper:
  2035. ldo TASK_REGS-TASK_SZ_ALGN-FRAME_SIZE(%r30),%r1 /* get pt regs */
  2036. reg_save %r1
  2037. mfctl %cr27, %r3
  2038. STREG %r3, PT_CR27(%r1)
  2040. STREG %r2,-RP_OFFSET(%r30)
  2041. ldo FRAME_SIZE(%r30),%r30
  2042. #ifdef __LP64__
  2043. ldo -16(%r30),%r29 /* Reference param save area */
  2044. #endif
  2046. STREG %r2,PT_GR19(%r1) /* save for child */
  2047. STREG %r30,PT_GR21(%r1)
  2049. bl sys_vfork,%r2
  2050. copy %r1,%r26
  2052. b wrapper_exit
  2053. LDREG -RP_OFFSET-FRAME_SIZE(%r30),%r2
  2056. .macro  execve_wrapper execve
  2057. ldo TASK_REGS-TASK_SZ_ALGN-FRAME_SIZE(%r30),%r1     /* get pt regs */
  2059. /*
  2060.  * Do we need to save/restore r3-r18 here?
  2061.  * I don't think so. why would new thread need old
  2062.  * threads registers?
  2063.  */
  2065. /* %arg0 - %arg3 are already saved for us. */
  2067. STREG %r2,-RP_OFFSET(%r30)
  2068. ldo FRAME_SIZE(%r30),%r30
  2069. #ifdef __LP64__
  2070. ldo -16(%r30),%r29 /* Reference param save area */
  2071. #endif
  2072. bl execve,%r2
  2073. copy %r1,%arg0
  2075. ldo -FRAME_SIZE(%r30),%r30
  2076. LDREG -RP_OFFSET(%r30),%r2
  2078. /* If exec succeeded we need to load the args */
  2080. ldo -1024(%r0),%r1
  2081. cmpb,>>= %r28,%r1,error_execve
  2082. copy %r2,%r19
  2084. error_execve:
  2085. bv %r0(%r19)
  2086. nop
  2087. .endm
  2089. .export sys_execve_wrapper
  2090. .import sys_execve
  2092. sys_execve_wrapper:
  2093. execve_wrapper sys_execve
  2095. #ifdef __LP64__
  2096. .export sys32_execve_wrapper
  2097. .import sys32_execve
  2099. sys32_execve_wrapper:
  2100. execve_wrapper sys32_execve
  2101. #endif
  2103. .export sys_rt_sigreturn_wrapper
  2104. sys_rt_sigreturn_wrapper:
  2105. ldo TASK_REGS-TASK_SZ_ALGN-FRAME_SIZE(%r30), %r26
  2106. /* Don't save regs, we are going to restore them from sigcontext. */
  2107. STREG %r2, -RP_OFFSET(%r30)
  2108. #ifdef __LP64__
  2109. ldo FRAME_SIZE(%r30), %r30
  2110. bl sys_rt_sigreturn,%r2
  2111. ldo -16(%r30),%r29 /* Reference param save area */
  2112. #else
  2113. bl sys_rt_sigreturn,%r2
  2114. ldo FRAME_SIZE(%r30), %r30
  2115. #endif
  2117. ldo -FRAME_SIZE(%r30), %r30
  2118. LDREG -RP_OFFSET(%r30), %r2
  2120. /* FIXME: I think we need to restore a few more things here. */
  2121. ldo TASK_REGS-TASK_SZ_ALGN-FRAME_SIZE(%r30),%r1     /* get pt regs */
  2122. reg_restore %r1
  2124. /* If the signal was received while the process was blocked on a
  2125.  * syscall, then r2 will take us to syscall_exit; otherwise r2 will
  2126.  * take us to syscall_exit_rfi and on to intr_return.
  2127.  */
  2128. bv %r0(%r2)
  2129. LDREG PT_GR28(%r1),%r28  /* reload original r28 for syscall_exit */
  2131. .export sys_sigaltstack_wrapper
  2132. sys_sigaltstack_wrapper:
  2133. /* Get the user stack pointer */
  2134. LDREG -TASK_SZ_ALGN-FRAME_SIZE+TASK_PT_GR30(%r30), %r24
  2135. STREG %r2, -RP_OFFSET(%r30)
  2136. #ifdef __LP64__
  2137. ldo FRAME_SIZE(%r30), %r30
  2138. bl do_sigaltstack,%r2
  2139. ldo -16(%r30),%r29 /* Reference param save area */
  2140. #else
  2141. bl do_sigaltstack,%r2
  2142. ldo FRAME_SIZE(%r30), %r30
  2143. #endif
  2145. ldo -FRAME_SIZE(%r30), %r30
  2146. LDREG -RP_OFFSET(%r30), %r2
  2147. bv %r0(%r2)
  2148. nop
  2150. #ifdef __LP64__
  2151. .export sys32_sigaltstack_wrapper
  2152. sys32_sigaltstack_wrapper:
  2153. /* Get the user stack pointer */
  2154. LDREG -TASK_SZ_ALGN-FRAME_SIZE+TASK_PT_GR30(%r30), %r24
  2155. STREG %r2, -RP_OFFSET(%r30)
  2156. ldo FRAME_SIZE(%r30), %r30
  2157. bl do_sigaltstack32,%r2
  2158. ldo -16(%r30),%r29 /* Reference param save area */
  2160. ldo -FRAME_SIZE(%r30), %r30
  2161. LDREG -RP_OFFSET(%r30), %r2
  2162. bv %r0(%r2)
  2163. nop
  2164. #endif
  2166. .export sys_rt_sigsuspend_wrapper
  2167. sys_rt_sigsuspend_wrapper:
  2168. ldo TASK_REGS-TASK_SZ_ALGN-FRAME_SIZE(%r30), %r24
  2169. reg_save %r24
  2171. STREG %r2, -RP_OFFSET(%r30)
  2172. #ifdef __LP64__
  2173. ldo FRAME_SIZE(%r30), %r30
  2174. bl sys_rt_sigsuspend,%r2
  2175. ldo -16(%r30),%r29 /* Reference param save area */
  2176. #else
  2177. bl sys_rt_sigsuspend,%r2
  2178. ldo FRAME_SIZE(%r30), %r30
  2179. #endif
  2181. ldo -FRAME_SIZE(%r30), %r30
  2182. LDREG -RP_OFFSET(%r30), %r2
  2184. ldo TASK_REGS-TASK_SZ_ALGN-FRAME_SIZE(%r30),%r1
  2185. reg_restore %r1
  2187. bv %r0(%r2)
  2188. nop
  2190. .export syscall_exit
  2191. syscall_exit:
  2192. /* NOTE: HP-UX syscalls also come through here
  2193.    after hpux_syscall_exit fixes up return
  2194.    values. */
  2195. /* NOTE: Not all syscalls exit this way.  rt_sigreturn will exit
  2196.  * via syscall_exit_rfi if the signal was received while the process
  2197.  * was running.
  2198.  */
  2200. /* save return value now */
  2202. STREG     %r28,TASK_PT_GR28-TASK_SZ_ALGN-FRAME_SIZE(%r30)
  2204. /* Save other hpux returns if personality is PER_HPUX */
  2206. #define PER_HPUX 0xe /* <linux/personality.h> cannot be easily included */
  2208. LDREG     TASK_PERSONALITY-TASK_SZ_ALGN-FRAME_SIZE(%r30),%r19
  2209. CMPIB<>,n PER_HPUX,%r19,1f
  2210. STREG     %r22,TASK_PT_GR22-TASK_SZ_ALGN-FRAME_SIZE(%r30)
  2211. STREG     %r29,TASK_PT_GR29-TASK_SZ_ALGN-FRAME_SIZE(%r30)
  2212. 1:
  2214. /* Seems to me that dp could be wrong here, if the syscall involved
  2215.  * calling a module, and nothing got round to restoring dp on return.
  2216.  */
  2217. loadgp
  2219. syscall_check_bh:
  2221. /* Check for software interrupts */
  2223. .import irq_stat,data
  2225. ldil    L%irq_stat,%r19
  2226. ldo     R%irq_stat(%r19),%r19
  2228. #ifdef CONFIG_SMP
  2229. /* sched.h: int processor */
  2230. /* %r26 is used as scratch register to index into irq_stat[] */
  2231. ldw     TASK_PROCESSOR-TASK_SZ_ALGN-FRAME_SIZE(%r30),%r26 /* cpu # */
  2233. /* shift left ____cacheline_aligned (aka L1_CACHE_BYTES) bits */
  2234. #ifdef __LP64__
  2235. shld %r26, 6, %r20
  2236. #else
  2237. shlw %r26, 5, %r20
  2238. #endif
  2239. add     %r19,%r20,%r19 /* now have &irq_stat[smp_processor_id()] */
  2240. #endif /* CONFIG_SMP */
  2242. LDREG   IRQSTAT_SIRQ_PEND(%r19),%r20    /* hardirq.h: unsigned long */
  2243. cmpib,<>,n 0,%r20,syscall_do_softirq /* forward */
  2245. syscall_check_resched:
  2247. /* check for reschedule */
  2249. LDREG  TASK_NEED_RESCHED-TASK_SZ_ALGN-FRAME_SIZE(%r30),%r19 /* long */
  2250. CMPIB<>,n 0,%r19,syscall_do_resched /* forward */
  2252. syscall_check_sig:
  2253. ldo     -TASK_SZ_ALGN-FRAME_SIZE(%r30),%r1         /* get task ptr */
  2254. /* check for pending signals */
  2255. ldw     TASK_SIGPENDING(%r1),%r19
  2256. cmpib,<>,n 0,%r19,syscall_do_signal  /* forward */
  2258. syscall_restore:
  2259. LDREG TASK_PTRACE(%r1), %r19 /* Are we being ptraced? */
  2260. bb,<,n %r19,31,syscall_restore_rfi
  2262. ldo TASK_PT_FR31(%r1),%r19    /* reload fpregs */
  2263. rest_fp %r19
  2265. LDREG TASK_PT_SAR(%r1),%r19    /* restore SAR */
  2266. mtsar %r19
  2268. LDREG TASK_PT_GR2(%r1),%r2    /* restore user rp */
  2269. LDREG TASK_PT_GR19(%r1),%r19
  2270. LDREG   TASK_PT_GR20(%r1),%r20
  2271. LDREG TASK_PT_GR21(%r1),%r21
  2272. LDREG TASK_PT_GR22(%r1),%r22
  2273. LDREG TASK_PT_GR23(%r1),%r23
  2274. LDREG TASK_PT_GR24(%r1),%r24
  2275. LDREG TASK_PT_GR25(%r1),%r25
  2276. LDREG TASK_PT_GR26(%r1),%r26
  2277. LDREG TASK_PT_GR27(%r1),%r27    /* restore user dp */
  2278. LDREG TASK_PT_GR28(%r1),%r28    /* syscall return value */
  2279. LDREG TASK_PT_GR29(%r1),%r29
  2280. LDREG TASK_PT_GR31(%r1),%r31    /* restore syscall rp */
  2282. rsm     PSW_SM_I, %r0
  2283. LDREG   TASK_PT_GR30(%r1),%r30             /* restore user sp */
  2284. mfsp %sr3,%r1    /* Get users space id */
  2285. mtsp    %r1,%sr7                           /* Restore sr7 */
  2286. ssm     PSW_SM_I, %r0
  2287. mtsp %r1,%sr4    /* Restore sr4 */
  2288. mtsp %r1,%sr5    /* Restore sr5 */
  2289. mtsp %r1,%sr6    /* Restore sr6 */
  2291. depi 3,31,2,%r31    /* ensure return to user mode. */
  2293. #ifdef __LP64__
  2294. /* Since we are returning to a 32 bit user process, we always
  2295.  * clear the W bit. This means that the be (and mtsp) gets
  2296.  * executed in narrow mode, but that is OK, since we are
  2297.  * returning to a 32 bit process. When we support 64 bit processes
  2298.  * we won't clear the W bit, so the be will run in wide mode.
  2299.  */
  2301. be 0(%sr3,%r31)    /* return to user space */
  2302. rsm PSW_SM_W, %r0
  2303. #else
  2304. be,n    0(%sr3,%r31)                       /* return to user space */
  2305. #endif
  2307. /* We have to return via an RFI, so that PSW T and R bits can be set
  2308.  * appropriately.
  2309.  * This sets up pt_regs so we can return via intr_restore, which is not
  2310.  * the most efficient way of doing things, but it works.
  2311.  */
  2312. syscall_restore_rfi:
  2313. ldo -1(%r0),%r2    /* Set recovery cntr to -1 */
  2314. mtctl %r2,%cr0    /*   for immediate trap */
  2315. LDREG TASK_PT_PSW(%r1),%r2    /* Get old PSW */
  2316. ldi 0x0b,%r20    /* Create new PSW */
  2317. depi -1,13,1,%r20    /* C, Q, D, and I bits */
  2318. bb,>=,n %r19,15,try_tbit    /* PT_SINGLESTEP */
  2319. depi -1,27,1,%r20    /* R bit */
  2320. try_tbit:
  2321. bb,>=,n %r19,14,psw_setup    /* PT_BLOCKSTEP, see ptrace.c */
  2322. depi -1,7,1,%r20    /* T bit */
  2323. psw_setup:
  2324. STREG %r20,TASK_PT_PSW(%r1)
  2326. /* Always store space registers, since sr3 can be changed (e.g. fork) */
  2328. mfsp    %sr3,%r25
  2329. STREG   %r25,TASK_PT_SR3(%r1)
  2330. STREG   %r25,TASK_PT_SR4(%r1)
  2331. STREG   %r25,TASK_PT_SR5(%r1)
  2332. STREG   %r25,TASK_PT_SR6(%r1)
  2333. STREG   %r25,TASK_PT_SR7(%r1)
  2334. STREG   %r25,TASK_PT_IASQ0(%r1)
  2335. STREG   %r25,TASK_PT_IASQ1(%r1)
  2337. /* XXX W bit??? */
  2338. /* Now if old D bit is clear, it means we didn't save all registers
  2339.  * on syscall entry, so do that now.  This only happens on TRACEME
  2340.  * calls, or if someone attached to us while we were on a syscall.
  2341.  * We could make this more efficient by not saving r3-r18, but
  2342.  * then we wouldn't be able to use the common intr_restore path.
  2343.  * It is only for traced processes anyway, so performance is not
  2344.  * an issue.
  2345.  */
  2346. bb,< %r2,30,pt_regs_ok    /* Branch if D set */
  2347. ldo TASK_REGS(%r1),%r25
  2348. reg_save %r25    /* Save r3 to r18 */
  2349. mfsp %sr0,%r2
  2350. STREG %r2,TASK_PT_SR0(%r1)
  2351. mfsp %sr1,%r2
  2352. STREG %r2,TASK_PT_SR1(%r1)
  2353. mfsp %sr2,%r2
  2354. STREG %r2,TASK_PT_SR2(%r1)
  2355. pt_regs_ok:
  2356. LDREG TASK_PT_GR31(%r1),%r2
  2357. depi 3,31,2,%r2    /* ensure return to user mode. */
  2358. STREG %r2,TASK_PT_IAOQ0(%r1)
  2359. ldo 4(%r2),%r2
  2360. STREG %r2,TASK_PT_IAOQ1(%r1)
  2361. copy %r25,%r16
  2362. b intr_restore
  2363. nop
  2365. .import do_softirq,code
  2366. syscall_do_softirq:
  2367. bl      do_softirq,%r2
  2368. nop
  2369. b       syscall_check_resched
  2370. ssm     PSW_SM_I, %r0  /* do_softirq returns with I bit off */
  2372. .import schedule,code
  2373. syscall_do_resched:
  2374. bl schedule,%r2
  2375. #ifdef __LP64__
  2376. ldo -16(%r30),%r29 /* Reference param save area */
  2377. #else
  2378. nop
  2379. #endif
  2380. b       syscall_check_bh  /* if resched, we start over again */
  2381. nop
  2383. .import do_signal,code
  2384. syscall_do_signal:
  2385. /* Save callee-save registers (for sigcontext).
  2386.    FIXME: After this point the process structure should be
  2387.    consistent with all the relevant state of the process
  2388.    before the syscall.  We need to verify this. */
  2389. ldo TASK_REGS(%r1), %r25 /* struct pt_regs *regs */
  2390. reg_save %r25
  2392. ldi 1, %r24 /* unsigned long in_syscall */
  2394. #ifdef __LP64__
  2395. ldo -16(%r30),%r29 /* Reference param save area */
  2396. #endif
  2397. bl do_signal,%r2
  2398. copy %r0, %r26 /* sigset_t *oldset = NULL */
  2400. ldo     -TASK_SZ_ALGN-FRAME_SIZE(%r30), %r1     /* reload task ptr */
  2401. ldo TASK_REGS(%r1), %r20 /* reload pt_regs */
  2402. reg_restore %r20
  2404. b,n     syscall_restore
  2406. /*
  2407.  * get_register is used by the non access tlb miss handlers to
  2408.  * copy the value of the general register specified in r8 into
  2409.  * r1. This routine can't be used for shadowed registers, since
  2410.  * the rfir will restore the original value. So, for the shadowed
  2411.  * registers we put a -1 into r1 to indicate that the register
  2412.  * should not be used (the register being copied could also have
  2413.  * a -1 in it, but that is OK, it just means that we will have
  2414.  * to use the slow path instead).
  2415.  */
  2417. get_register:
  2418. blr     %r8,%r0
  2419. nop
  2420. bv      %r0(%r25)    /* r0 */
  2421. copy    %r0,%r1
  2422. bv      %r0(%r25)    /* r1 - shadowed */
  2423. ldi     -1,%r1
  2424. bv      %r0(%r25)    /* r2 */
  2425. copy    %r2,%r1
  2426. bv      %r0(%r25)    /* r3 */
  2427. copy    %r3,%r1
  2428. bv      %r0(%r25)    /* r4 */
  2429. copy    %r4,%r1
  2430. bv      %r0(%r25)    /* r5 */
  2431. copy    %r5,%r1
  2432. bv      %r0(%r25)    /* r6 */
  2433. copy    %r6,%r1
  2434. bv      %r0(%r25)    /* r7 */
  2435. copy    %r7,%r1
  2436. bv      %r0(%r25)    /* r8 - shadowed */
  2437. ldi     -1,%r1
  2438. bv      %r0(%r25)    /* r9 - shadowed */
  2439. ldi     -1,%r1
  2440. bv      %r0(%r25)    /* r10 */
  2441. copy    %r10,%r1
  2442. bv      %r0(%r25)    /* r11 */
  2443. copy    %r11,%r1
  2444. bv      %r0(%r25)    /* r12 */
  2445. copy    %r12,%r1
  2446. bv      %r0(%r25)    /* r13 */
  2447. copy    %r13,%r1
  2448. bv      %r0(%r25)    /* r14 */
  2449. copy    %r14,%r1
  2450. bv      %r0(%r25)    /* r15 */
  2451. copy    %r15,%r1
  2452. bv      %r0(%r25)    /* r16 - shadowed */
  2453. ldi     -1,%r1
  2454. bv      %r0(%r25)    /* r17 - shadowed */
  2455. ldi     -1,%r1
  2456. bv      %r0(%r25)    /* r18 */
  2457. copy    %r18,%r1
  2458. bv      %r0(%r25)    /* r19 */
  2459. copy    %r19,%r1
  2460. bv      %r0(%r25)    /* r20 */
  2461. copy    %r20,%r1
  2462. bv      %r0(%r25)    /* r21 */
  2463. copy    %r21,%r1
  2464. bv      %r0(%r25)    /* r22 */
  2465. copy    %r22,%r1
  2466. bv      %r0(%r25)    /* r23 */
  2467. copy    %r23,%r1
  2468. bv      %r0(%r25)    /* r24 - shadowed */
  2469. ldi     -1,%r1
  2470. bv      %r0(%r25)    /* r25 - shadowed */
  2471. ldi     -1,%r1
  2472. bv      %r0(%r25)    /* r26 */
  2473. copy    %r26,%r1
  2474. bv      %r0(%r25)    /* r27 */
  2475. copy    %r27,%r1
  2476. bv      %r0(%r25)    /* r28 */
  2477. copy    %r28,%r1
  2478. bv      %r0(%r25)    /* r29 */
  2479. copy    %r29,%r1
  2480. bv      %r0(%r25)    /* r30 */
  2481. copy    %r30,%r1
  2482. bv      %r0(%r25)    /* r31 */
  2483. copy    %r31,%r1
  2485. /*
  2486.  * set_register is used by the non access tlb miss handlers to
  2487.  * copy the value of r1 into the general register specified in
  2488.  * r8.
  2489.  */
  2491. set_register:
  2492. blr     %r8,%r0
  2493. nop
  2494. bv      %r0(%r25)    /* r0 (silly, but it is a place holder) */
  2495. copy    %r1,%r0
  2496. bv      %r0(%r25)    /* r1 */
  2497. copy    %r1,%r1
  2498. bv      %r0(%r25)    /* r2 */
  2499. copy    %r1,%r2
  2500. bv      %r0(%r25)    /* r3 */
  2501. copy    %r1,%r3
  2502. bv      %r0(%r25)    /* r4 */
  2503. copy    %r1,%r4
  2504. bv      %r0(%r25)    /* r5 */
  2505. copy    %r1,%r5
  2506. bv      %r0(%r25)    /* r6 */
  2507. copy    %r1,%r6
  2508. bv      %r0(%r25)    /* r7 */
  2509. copy    %r1,%r7
  2510. bv      %r0(%r25)    /* r8 */
  2511. copy    %r1,%r8
  2512. bv      %r0(%r25)    /* r9 */
  2513. copy    %r1,%r9
  2514. bv      %r0(%r25)    /* r10 */
  2515. copy    %r1,%r10
  2516. bv      %r0(%r25)    /* r11 */
  2517. copy    %r1,%r11
  2518. bv      %r0(%r25)    /* r12 */
  2519. copy    %r1,%r12
  2520. bv      %r0(%r25)    /* r13 */
  2521. copy    %r1,%r13
  2522. bv      %r0(%r25)    /* r14 */
  2523. copy    %r1,%r14
  2524. bv      %r0(%r25)    /* r15 */
  2525. copy    %r1,%r15
  2526. bv      %r0(%r25)    /* r16 */
  2527. copy    %r1,%r16
  2528. bv      %r0(%r25)    /* r17 */
  2529. copy    %r1,%r17
  2530. bv      %r0(%r25)    /* r18 */
  2531. copy    %r1,%r18
  2532. bv      %r0(%r25)    /* r19 */
  2533. copy    %r1,%r19
  2534. bv      %r0(%r25)    /* r20 */
  2535. copy    %r1,%r20
  2536. bv      %r0(%r25)    /* r21 */
  2537. copy    %r1,%r21
  2538. bv      %r0(%r25)    /* r22 */
  2539. copy    %r1,%r22
  2540. bv      %r0(%r25)    /* r23 */
  2541. copy    %r1,%r23
  2542. bv      %r0(%r25)    /* r24 */
  2543. copy    %r1,%r24
  2544. bv      %r0(%r25)    /* r25 */
  2545. copy    %r1,%r25
  2546. bv      %r0(%r25)    /* r26 */
  2547. copy    %r1,%r26
  2548. bv      %r0(%r25)    /* r27 */
  2549. copy    %r1,%r27
  2550. bv      %r0(%r25)    /* r28 */
  2551. copy    %r1,%r28
  2552. bv      %r0(%r25)    /* r29 */
  2553. copy    %r1,%r29
  2554. bv      %r0(%r25)    /* r30 */
  2555. copy    %r1,%r30
  2556. bv      %r0(%r25)    /* r31 */
  2557. copy    %r1,%r31