Annotation of sys/arch/m88k/m88k/subr.S, Revision 1.1
1.1 ! nbrk 1: /* $OpenBSD: subr.S,v 1.14 2006/11/18 22:48:44 miod Exp $ */
! 2: /*
! 3: * Mach Operating System
! 4: * Copyright (c) 1993-1992 Carnegie Mellon University
! 5: * Copyright (c) 1991 OMRON Corporation
! 6: * Copyright (c) 1996 Nivas Madhur
! 7: * Copyright (c) 1998 Steve Murphree, Jr.
! 8: * All Rights Reserved.
! 9: *
! 10: * Permission to use, copy, modify and distribute this software and its
! 11: * documentation is hereby granted, provided that both the copyright
! 12: * notice and this permission notice appear in all copies of the
! 13: * software, derivative works or modified versions, and any portions
! 14: * thereof, and that both notices appear in supporting documentation.
! 15: *
! 16: * CARNEGIE MELLON AND OMRON ALLOW FREE USE OF THIS SOFTWARE IN ITS "AS IS"
! 17: * CONDITION. CARNEGIE MELLON AND OMRON DISCLAIM ANY LIABILITY OF ANY KIND
! 18: * FOR ANY DAMAGES WHATSOEVER RESULTING FROM THE USE OF THIS SOFTWARE.
! 19: *
! 20: * Carnegie Mellon requests users of this software to return to
! 21: *
! 22: * Software Distribution Coordinator or Software.Distribution@CS.CMU.EDU
! 23: * School of Computer Science
! 24: * Carnegie Mellon University
! 25: * Pittsburgh PA 15213-3890
! 26: *
! 27: * any improvements or extensions that they make and grant Carnegie the
! 28: * rights to redistribute these changes.
! 29: */
! 30:
! 31: #include "assym.h"
! 32:
! 33: #include <sys/errno.h>
! 34:
! 35: #include <machine/asm.h>
! 36: #include <machine/trap.h>
! 37:
! 38: #ifdef M88100
! 39:
! 40: /*
! 41: * DO_LOAD_ADDRESS
! 42: *
! 43: * unsigned int do_load_word(address, supervisor_mode)
! 44: * vaddr_t address; \\ in r2
! 45: * boolean_t supervisor_mode; \\ in r3
! 46: *
! 47: * Return the word at ADDRESS (from user space if SUPERVISOR_MODE is zero,
! 48: * supervisor space if non-zero).
! 49: *
! 50: */
! 51:
! 52: ENTRY(do_load_word) /* do_load_word(address, supervisor) */
! 53: bcnd ne0,r3,1f
! 54: #ifdef ERRATA__XXX_USR
! 55: NOP
! 56: ld.usr r2,r2,r0
! 57: NOP
! 58: NOP
! 59: NOP
! 60: jmp r1
! 61: #else
! 62: jmp.n r1
! 63: ld.usr r2,r2,r0
! 64: #endif
! 65: 1: jmp.n r1
! 66: ld r2,r2,r0
! 67:
! 68: ENTRY(do_load_half) /* do_load_half(address, supervisor) */
! 69: bcnd ne0,r3,1f
! 70: #ifdef ERRATA__XXX_USR
! 71: NOP
! 72: ld.h.usr r2,r2,r0
! 73: NOP
! 74: NOP
! 75: NOP
! 76: jmp r1
! 77: #else
! 78: jmp.n r1
! 79: ld.h.usr r2,r2,r0
! 80: #endif
! 81: 1: jmp.n r1
! 82: ld.h r2,r2,r0
! 83:
! 84: ENTRY(do_load_byte) /* do_load_byte(address, supervisor) */
! 85: bcnd ne0,r3,1f
! 86: #ifdef ERRATA__XXX_USR
! 87: NOP
! 88: ld.b.usr r2,r2,r0
! 89: NOP
! 90: NOP
! 91: NOP
! 92: jmp r1
! 93: #else
! 94: jmp.n r1
! 95: ld.b.usr r2,r2,r0
! 96: #endif
! 97: 1: jmp.n r1
! 98: ld.b r2,r2,r0
! 99:
! 100: ENTRY(do_store_word) /* do_store_word(address, data, supervisor) */
! 101: bcnd ne0,r4,1f
! 102: #ifdef ERRATA__XXX_USR
! 103: NOP
! 104: st.usr r3,r2,r0
! 105: NOP
! 106: NOP
! 107: NOP
! 108: jmp r1
! 109: #else
! 110: jmp.n r1
! 111: st.usr r3,r2,r0
! 112: #endif
! 113: 1: jmp.n r1
! 114: st r3,r2,r0
! 115:
! 116: ENTRY(do_store_half) /* do_store_half(address, data, supervisor) */
! 117: bcnd ne0,r4,1f
! 118: #ifdef ERRATA__XXX_USR
! 119: NOP
! 120: st.h.usr r3,r2,r0
! 121: NOP
! 122: NOP
! 123: NOP
! 124: jmp r1
! 125: #else
! 126: jmp.n r1
! 127: st.h.usr r3,r2,r0
! 128: #endif
! 129: 1: jmp.n r1
! 130: st.h r3,r2,r0
! 131:
! 132: ENTRY(do_store_byte) /* do_store_byte(address, data, supervisor) */
! 133: bcnd ne0,r4,1f
! 134: #ifdef ERRATA__XXX_USR
! 135: NOP
! 136: st.b.usr r3,r2,r0
! 137: NOP
! 138: NOP
! 139: NOP
! 140: jmp r1
! 141: #else
! 142: jmp.n r1
! 143: st.b.usr r3,r2,r0
! 144: #endif
! 145: 1: jmp.n r1
! 146: st.b r3,r2,r0
! 147:
! 148: ENTRY(do_xmem_word) /* do_xmem_word(address, data, supervisor) */
! 149: bcnd ne0,r4,1f
! 150: #ifdef ERRATA__XXX_USR
! 151: NOP
! 152: xmem.usr r3,r2,r0
! 153: NOP
! 154: NOP
! 155: NOP
! 156: jmp r1
! 157: #else
! 158: jmp.n r1
! 159: xmem.usr r3,r2,r0
! 160: #endif
! 161: 1: jmp.n r1
! 162: xmem r3,r2,r0
! 163:
! 164: ENTRY(do_xmem_byte) /* do_xmem_byte(address, data, supervisor) */
! 165: bcnd ne0,r4,1f
! 166: #ifdef ERRATA__XXX_USR
! 167: NOP
! 168: xmem.bu.usr r3,r2,r0
! 169: NOP
! 170: NOP
! 171: NOP
! 172: jmp r1
! 173: #else
! 174: jmp.n r1
! 175: xmem.bu.usr r3,r2,r0
! 176: #endif
! 177: 1: jmp.n r1
! 178: xmem.bu r3,r2,r0
! 179:
! 180: #endif /* M88100 */
! 181:
! 182: /*
! 183: * Copy specified amount of data from user space into the kernel
! 184: * copyin(from, to, len)
! 185: * r2 == from (user source address)
! 186: * r3 == to (kernel destination address)
! 187: * r4 == length
! 188: * (r1=return addr)
! 189: */
! 190:
! 191: #define SRC r2
! 192: #define DEST r3
! 193: #define LEN r4
! 194:
! 195: ENTRY(copyin)
! 196: /* set up fault handler */
! 197: ldcr r5, CPU
! 198: ld r6, r5, CI_CURPCB
! 199: or.u r5, r0, hi16(_ASM_LABEL(Lciflt))
! 200: or r5, r5, lo16(_ASM_LABEL(Lciflt))
! 201: st r5, r6, PCB_ONFAULT /* pcb_onfault = Lciflt */
! 202:
! 203: /*
! 204: * If it's a small length (less than 8), then do byte-by-byte.
! 205: * Despite not being optimal if len is 4, and from and to
! 206: * are word-aligned, this is still faster than doing more tests
! 207: * to save an hyperthetical fraction of cycle.
! 208: */
! 209: cmp r9, LEN, 8
! 210: bb1 lt, r9, _ASM_LABEL(copyin_byte_only)
! 211:
! 212: /* If they're not aligned similarly, use byte only... */
! 213: xor r9, SRC, DEST
! 214: mask r8, r9, 0x3
! 215: bcnd ne0, r8, _ASM_LABEL(copyin_byte_only)
! 216:
! 217: /*
! 218: * At this point, we don't know if they're word aligned or not,
! 219: * but we know that what needs to be done to one to align
! 220: * it is what's needed for the other.
! 221: */
! 222: bb1 0, SRC, _ASM_LABEL(copyin_left_align_to_halfword)
! 223: ASLOCAL(copyin_left_aligned_to_halfword)
! 224: bb1 1, SRC, _ASM_LABEL(copyin_left_align_to_word)
! 225: ASLOCAL(copyin_left_aligned_to_word)
! 226: bb1 0, LEN, _ASM_LABEL(copyin_right_align_to_halfword)
! 227: ASLOCAL(copyin_right_aligned_to_halfword)
! 228: bb1 1, LEN, _ASM_LABEL(copyin_right_align_to_word)
! 229: ASLOCAL(copyin_right_aligned_to_word)
! 230:
! 231: /*
! 232: * At this point, both SRC and DEST are aligned to a word
! 233: * boundary, and LEN is a multiple of 4. We want it an even
! 234: * multiple of 4.
! 235: */
! 236: bb1.n 2, LEN, _ASM_LABEL(copyin_right_align_to_doubleword)
! 237: or r7, r0, 4
! 238:
! 239: ASLOCAL(copyin_right_aligned_to_doubleword)
! 240: #ifdef ERRATA__XXX_USR
! 241: NOP
! 242: ld.usr r5, SRC, r0
! 243: NOP
! 244: NOP
! 245: NOP
! 246: ld.usr r6, SRC, r7
! 247: NOP
! 248: NOP
! 249: NOP
! 250: #else
! 251: ld.usr r5, SRC, r0
! 252: ld.usr r6, SRC, r7
! 253: #endif
! 254: subu LEN, LEN, 8
! 255: st r5, DEST, r0
! 256: addu SRC, SRC, 8
! 257: st r6, DEST, r7
! 258: bcnd.n ne0, LEN, _ASM_LABEL(copyin_right_aligned_to_doubleword)
! 259: addu DEST, DEST, 8
! 260: br.n _ASM_LABEL(Lcidone)
! 261: or r2, r0, r0 /* successful return */
! 262:
! 263: ASLOCAL(copyin_left_align_to_halfword)
! 264: #ifdef ERRATA__XXX_USR
! 265: NOP
! 266: ld.b.usr r5, SRC, r0
! 267: NOP
! 268: NOP
! 269: NOP
! 270: #else
! 271: ld.b.usr r5, SRC, r0
! 272: #endif
! 273: subu LEN, LEN, 1
! 274: st.b r5, DEST, r0
! 275: addu SRC, SRC, 1
! 276: br.n _ASM_LABEL(copyin_left_aligned_to_halfword)
! 277: addu DEST, DEST, 1
! 278:
! 279: ASLOCAL(copyin_left_align_to_word)
! 280: #ifdef ERRATA__XXX_USR
! 281: NOP
! 282: ld.h.usr r5, SRC, r0
! 283: NOP
! 284: NOP
! 285: NOP
! 286: #else
! 287: ld.h.usr r5, SRC, r0
! 288: #endif
! 289: subu LEN, LEN, 2
! 290: st.h r5, DEST, r0
! 291: addu SRC, SRC, 2
! 292: br.n _ASM_LABEL(copyin_left_aligned_to_word)
! 293: addu DEST, DEST, 2
! 294:
! 295: ASLOCAL(copyin_right_align_to_halfword)
! 296: subu LEN, LEN, 1
! 297: #ifdef ERRATA__XXX_USR
! 298: NOP
! 299: ld.b.usr r5, SRC, LEN
! 300: NOP
! 301: NOP
! 302: NOP
! 303: #else
! 304: ld.b.usr r5, SRC, LEN
! 305: #endif
! 306: br.n _ASM_LABEL(copyin_right_aligned_to_halfword)
! 307: st.b r5, DEST, LEN
! 308:
! 309: ASLOCAL(copyin_right_align_to_word)
! 310: subu LEN, LEN, 2
! 311: #ifdef ERRATA__XXX_USR
! 312: NOP
! 313: ld.h.usr r5, SRC, LEN
! 314: NOP
! 315: NOP
! 316: NOP
! 317: #else
! 318: ld.h.usr r5, SRC, LEN
! 319: #endif
! 320: br.n _ASM_LABEL(copyin_right_aligned_to_word)
! 321: st.h r5, DEST, LEN
! 322:
! 323: ASLOCAL(copyin_right_align_to_doubleword)
! 324: subu LEN, LEN, 4
! 325: #ifdef ERRATA__XXX_USR
! 326: NOP
! 327: ld.usr r5, SRC, LEN
! 328: NOP
! 329: NOP
! 330: NOP
! 331: #else
! 332: ld.usr r5, SRC, LEN
! 333: #endif
! 334: bcnd.n ne0, LEN, _ASM_LABEL(copyin_right_aligned_to_doubleword)
! 335: st r5, DEST, LEN
! 336: br.n _ASM_LABEL(Lcidone)
! 337: or r2, r0, r0 /* successful return */
! 338:
! 339: ASLOCAL(copyin_byte_only)
! 340: bcnd eq0, LEN, 2f
! 341: 1:
! 342: subu LEN, LEN, 1
! 343: #ifdef ERRATA__XXX_USR
! 344: NOP
! 345: ld.b.usr r5, SRC, LEN
! 346: NOP
! 347: NOP
! 348: NOP
! 349: #else
! 350: ld.b.usr r5, SRC, LEN
! 351: #endif
! 352: bcnd.n ne0, LEN, 1b
! 353: st.b r5, DEST, LEN
! 354: 2:
! 355: or r2, r0, r0 /* successful return */
! 356: /* FALLTHROUGH */
! 357:
! 358: ASLOCAL(Lcidone)
! 359: ldcr r5, CPU
! 360: ld r6, r5, CI_CURPCB
! 361: jmp.n r1
! 362: st r0,r6,PCB_ONFAULT
! 363:
! 364: ASLOCAL(Lciflt)
! 365: br.n _ASM_LABEL(Lcidone)
! 366: or r2, r0, EFAULT /* return fault */
! 367:
! 368: #undef SRC
! 369: #undef DEST
! 370: #undef LEN
! 371:
! 372: /*######################################################################*/
! 373: /*######################################################################*/
! 374:
! 375: /*
! 376: * Copy a null terminated string from the user space to the kernel
! 377: * address space.
! 378: *
! 379: * copyinstr(from, to, maxlen, &lencopied)
! 380: * r2 == from
! 381: * r3 == to
! 382: * r4 == maxlen
! 383: * r5 == len actually transferred (includes the terminating NUL!!!)
! 384: * r6 & r7 - used as temporaries
! 385: */
! 386: #define SRC r2
! 387: #define DEST r3
! 388: #define CNT r4
! 389: #define LEN r5
! 390:
! 391: ENTRY(copyinstr)
! 392:
! 393: /* setup fault handler */
! 394: ldcr r6, CPU
! 395: ld r7, r6, CI_CURPCB
! 396: or.u r6, r0, hi16(_ASM_LABEL(Lcisflt))
! 397: or r6, r6, lo16(_ASM_LABEL(Lcisflt))
! 398: st r6, r7, PCB_ONFAULT
! 399: or r6, r0, 0
! 400: bcnd lt0, CNT, _ASM_LABEL(Lcisflt)
! 401: bcnd eq0, CNT, _ASM_LABEL(Lcistoolong)
! 402: 1:
! 403: #ifdef ERRATA__XXX_USR
! 404: NOP
! 405: ld.bu.usr r7, SRC, r6
! 406: NOP
! 407: NOP
! 408: NOP
! 409: #else
! 410: ld.bu.usr r7, SRC, r6
! 411: #endif
! 412: st.b r7, DEST, r6
! 413: bcnd.n eq0, r7, 2f /* all done */
! 414: addu r6, r6, 1
! 415: cmp r7, r6, CNT
! 416: bb1 lt, r7, 1b
! 417:
! 418: ASLOCAL(Lcistoolong)
! 419: or r2, r0, ENAMETOOLONG /* overflow */
! 420:
! 421: ASLOCAL(Lcisnull)
! 422: bcnd eq0,r6, _ASM_LABEL(Lcisdone) /* do not attempt to clear last byte */
! 423: /* if we did not write to the string */
! 424: subu r6, r6, 1
! 425: st.b r0, DEST, r6 /* clear last byte */
! 426: br.n _ASM_LABEL(Lcisdone)
! 427: addu r6, r6, 1
! 428: 2: /* all done */
! 429: or r2, r0, 0
! 430:
! 431: ASLOCAL(Lcisdone)
! 432: bcnd eq0, LEN, 3f
! 433: st r6, r0, LEN
! 434: 3:
! 435: ldcr r5, CPU
! 436: ld r6, r5, CI_CURPCB
! 437: jmp.n r1
! 438: st r0,r6,PCB_ONFAULT /* clear the handler */
! 439:
! 440: ASLOCAL(Lcisflt)
! 441: br.n _ASM_LABEL(Lcisnull)
! 442: or r2, r0, EFAULT /* return fault */
! 443:
! 444: #undef SRC
! 445: #undef DEST
! 446: #undef CNT
! 447: #undef LEN
! 448:
! 449: /*
! 450: * Copy specified amount of data from kernel to the user space
! 451: * Copyout(from, to, len)
! 452: * r2 == from (kernel source address)
! 453: * r3 == to (user destination address)
! 454: * r4 == length
! 455: */
! 456:
! 457: #define SRC r2
! 458: #define DEST r3
! 459: #define LEN r4
! 460:
! 461: ENTRY(copyout)
! 462: /* setup fault handler */
! 463: ldcr r5, CPU
! 464: ld r6, r5, CI_CURPCB
! 465: or.u r5, r0, hi16(_ASM_LABEL(Lcoflt))
! 466: or r5, r5, lo16(_ASM_LABEL(Lcoflt))
! 467: st r5, r6, PCB_ONFAULT /* pcb_onfault = Lcoflt */
! 468:
! 469: /*
! 470: * If it's a small length (less than 8), then do byte-by-byte.
! 471: * Despite not being optimal if len is 4, and from and to
! 472: * are word-aligned, this is still faster than doing more tests
! 473: * to save an hyperthetical fraction of cycle.
! 474: */
! 475: cmp r9, LEN, 8
! 476: bb1 lt, r9, _ASM_LABEL(copyout_byte_only)
! 477:
! 478: /* If they're not aligned similarly, use byte only... */
! 479: xor r9, SRC, DEST
! 480: mask r8, r9, 0x3
! 481: bcnd ne0, r8, _ASM_LABEL(copyout_byte_only)
! 482:
! 483: /*
! 484: * At this point, we don't know if they're word aligned or not,
! 485: * but we know that what needs to be done to one to align
! 486: * it is what's needed for the other.
! 487: */
! 488: bb1 0, SRC, _ASM_LABEL(copyout_left_align_to_halfword)
! 489: ASLOCAL(copyout_left_aligned_to_halfword)
! 490: bb1 1, SRC, _ASM_LABEL(copyout_left_align_to_word)
! 491: ASLOCAL(copyout_left_aligned_to_word)
! 492: bb1 0, LEN, _ASM_LABEL(copyout_right_align_to_halfword)
! 493: ASLOCAL(copyout_right_aligned_to_halfword)
! 494: bb1 1, LEN, _ASM_LABEL(copyout_right_align_to_word)
! 495: ASLOCAL(copyout_right_aligned_to_word)
! 496:
! 497: /*
! 498: * At this point, both SRC and DEST are aligned to a word
! 499: * boundary, and LEN is a multiple of 4. We want it an even
! 500: * multiple of 4.
! 501: */
! 502: bb1.n 2, LEN, _ASM_LABEL(copyout_right_align_to_doubleword)
! 503: or r7, r0, 4
! 504:
! 505: ASLOCAL(copyout_right_aligned_to_doubleword)
! 506: ld r5, SRC, r0
! 507: ld r6, SRC, r7
! 508: subu LEN, LEN, 8
! 509: #ifdef ERRATA__XXX_USR
! 510: NOP
! 511: st.usr r5, DEST, r0
! 512: NOP
! 513: NOP
! 514: NOP
! 515: #else
! 516: st.usr r5, DEST, r0
! 517: #endif
! 518: addu SRC, SRC, 8
! 519: #ifdef ERRATA__XXX_USR
! 520: NOP
! 521: st.usr r6, DEST, r7
! 522: NOP
! 523: NOP
! 524: NOP
! 525: #else
! 526: st.usr r6, DEST, r7
! 527: #endif
! 528: bcnd.n ne0, LEN, _ASM_LABEL(copyout_right_aligned_to_doubleword)
! 529: addu DEST, DEST, 8
! 530: or r2, r0, r0 /* successful return */
! 531: br _ASM_LABEL(Lcodone)
! 532:
! 533: /***************************************************/
! 534: ASLOCAL(copyout_left_align_to_halfword)
! 535: ld.b r5, SRC, r0
! 536: subu LEN, LEN, 1
! 537: #ifdef ERRATA__XXX_USR
! 538: NOP
! 539: st.b.usr r5, DEST, r0
! 540: NOP
! 541: NOP
! 542: NOP
! 543: #else
! 544: st.b.usr r5, DEST, r0
! 545: #endif
! 546: addu SRC, SRC, 1
! 547: br.n _ASM_LABEL(copyout_left_aligned_to_halfword)
! 548: addu DEST, DEST, 1
! 549:
! 550: ASLOCAL(copyout_left_align_to_word)
! 551: ld.h r5, SRC, r0
! 552: subu LEN, LEN, 2
! 553: #ifdef ERRATA__XXX_USR
! 554: NOP
! 555: st.h.usr r5, DEST, r0
! 556: NOP
! 557: NOP
! 558: NOP
! 559: #else
! 560: st.h.usr r5, DEST, r0
! 561: #endif
! 562: addu SRC, SRC, 2
! 563: br.n _ASM_LABEL(copyout_left_aligned_to_word)
! 564: addu DEST, DEST, 2
! 565:
! 566: ASLOCAL(copyout_right_align_to_halfword)
! 567: subu LEN, LEN, 1
! 568: ld.b r5, SRC, LEN
! 569: #ifdef ERRATA__XXX_USR
! 570: NOP
! 571: st.b.usr r5, DEST, LEN
! 572: NOP
! 573: NOP
! 574: NOP
! 575: br _ASM_LABEL(copyout_right_aligned_to_halfword)
! 576: #else
! 577: br.n _ASM_LABEL(copyout_right_aligned_to_halfword)
! 578: st.b.usr r5, DEST, LEN
! 579: #endif
! 580:
! 581: ASLOCAL(copyout_right_align_to_word)
! 582: subu LEN, LEN, 2
! 583: ld.h r5, SRC, LEN
! 584: #ifdef ERRATA__XXX_USR
! 585: NOP
! 586: st.h.usr r5, DEST, LEN
! 587: NOP
! 588: NOP
! 589: NOP
! 590: br _ASM_LABEL(copyout_right_aligned_to_word)
! 591: #else
! 592: br.n _ASM_LABEL(copyout_right_aligned_to_word)
! 593: st.h.usr r5, DEST, LEN
! 594: #endif
! 595:
! 596: ASLOCAL(copyout_right_align_to_doubleword)
! 597: subu LEN, LEN, 4
! 598: ld r5, SRC, LEN
! 599: #ifdef ERRATA__XXX_USR
! 600: NOP
! 601: st.usr r5, DEST, LEN
! 602: NOP
! 603: NOP
! 604: NOP
! 605: bcnd ne0, LEN, _ASM_LABEL(copyout_right_aligned_to_doubleword)
! 606: #else
! 607: bcnd.n ne0, LEN, _ASM_LABEL(copyout_right_aligned_to_doubleword)
! 608: st.usr r5, DEST, LEN
! 609: #endif
! 610: br.n _ASM_LABEL(Lcodone)
! 611: or r2, r0, r0 /* successful return */
! 612:
! 613: ASLOCAL(copyout_byte_only)
! 614: bcnd eq0, LEN, 2f
! 615: 1:
! 616: subu LEN, LEN, 1
! 617: ld.b r5, SRC, LEN
! 618: #ifdef ERRATA__XXX_USR
! 619: NOP
! 620: st.b.usr r5, DEST, LEN
! 621: NOP
! 622: NOP
! 623: NOP
! 624: bcnd ne0, LEN, 1b
! 625: #else
! 626: bcnd.n ne0, LEN, 1b
! 627: st.b.usr r5, DEST, LEN
! 628: #endif
! 629:
! 630: 2:
! 631: or r2, r0, r0 /* successful return */
! 632: /* FALLTHROUGH */
! 633:
! 634: ASLOCAL(Lcodone)
! 635: ldcr r5, CPU
! 636: ld r6, r5, CI_CURPCB
! 637: jmp.n r1
! 638: st r0,r6,PCB_ONFAULT /* clear the handler */
! 639:
! 640: ASLOCAL(Lcoflt)
! 641: br.n _ASM_LABEL(Lcodone)
! 642: or r2, r0, EFAULT /* return fault */
! 643:
! 644: #undef SRC
! 645: #undef DEST
! 646: #undef LEN
! 647:
! 648: /*
! 649: * Copy a null terminated string from the kernel space to the user
! 650: * address space.
! 651: *
! 652: * copyoutstr(from, to, maxlen, &lencopied)
! 653: * r2 == from
! 654: * r3 == to
! 655: * r4 == maxlen that can be copied
! 656: * r5 == len actually copied (including the terminating NUL!!!)
! 657: */
! 658:
! 659: #define SRC r2
! 660: #define DEST r3
! 661: #define CNT r4
! 662: #define LEN r5
! 663:
! 664: ENTRY(copyoutstr)
! 665: /* setup fault handler */
! 666: ldcr r6, CPU
! 667: ld r7, r6, CI_CURPCB
! 668: or.u r6, r0, hi16(_ASM_LABEL(Lcosflt))
! 669: or r6, r6, lo16(_ASM_LABEL(Lcosflt))
! 670: st r6, r7, PCB_ONFAULT
! 671: bcnd lt0, CNT, _ASM_LABEL(Lcosflt)
! 672: bcnd eq0, CNT, _ASM_LABEL(Lcosdone)
! 673: or r6, r0, 0
! 674: 1:
! 675: ld.bu r7, SRC, r6
! 676: #ifdef ERRATA__XXX_USR
! 677: NOP
! 678: st.b.usr r7, DEST, r6
! 679: NOP
! 680: NOP
! 681: NOP
! 682: #else
! 683: st.b.usr r7, DEST, r6
! 684: #endif
! 685: bcnd.n eq0, r7, 2f /* all done */
! 686: addu r6, r6, 1
! 687: cmp r7, r6, CNT
! 688: bb1 lt, r7, 1b
! 689: br.n _ASM_LABEL(Lcosdone)
! 690: or r2, r0, ENAMETOOLONG
! 691: 2:
! 692: br.n _ASM_LABEL(Lcosdone)
! 693: or r2, r0, 0
! 694:
! 695: ASLOCAL(Lcosflt)
! 696: br.n _ASM_LABEL(Lcosdone)
! 697: or r2, r0, EFAULT
! 698:
! 699: ASLOCAL(Lcosdone)
! 700: bcnd eq0, LEN, 3f
! 701: st r6, r0, LEN
! 702: 3:
! 703: ldcr r5, CPU
! 704: ld r6, r5, CI_CURPCB
! 705: jmp.n r1
! 706: st r0,r6,PCB_ONFAULT /* clear the handler */
! 707:
! 708: #undef SRC
! 709: #undef DEST
! 710: #undef CNT
! 711: #undef LEN
! 712:
! 713: /*######################################################################*/
! 714:
! 715: /*
! 716: * kcopy(const void *src, void *dst, size_t len);
! 717: *
! 718: * Copy len bytes from src to dst, aborting if we encounter a page fault.
! 719: */
! 720: ENTRY(kcopy)
! 721: ldcr r5, CPU
! 722: ld r6, r5, CI_CURPCB
! 723: or.u r5, r0, hi16(_ASM_LABEL(kcopy_fault))
! 724: or r5, r5, lo16(_ASM_LABEL(kcopy_fault))
! 725: st r5, r6, PCB_ONFAULT /* pcb_onfault = kcopy_fault */
! 726: bcnd le0,r4,_ASM_LABEL(kcopy_out) /* nothing to do if <= 0 */
! 727: /*
! 728: * check position of source and destination data
! 729: */
! 730: cmp r9,r2,r3 /* compare source address to destination */
! 731: bb1 eq,r9,_ASM_LABEL(kcopy_out) /* nothing to do if equal */
! 732: bb1 lo,r9,_ASM_LABEL(kcopy_reverse) /* reverse copy if src < dest */
! 733: /*
! 734: * source address is greater than destination address, copy forward
! 735: */
! 736: cmp r9,r4,16 /* see if we have at least 16 bytes */
! 737: bb1 lt,r9,_ASM_LABEL(kf_byte_copy) /* copy bytes for small length */
! 738: /*
! 739: * determine copy strategy based on alignment of source and destination
! 740: */
! 741: mask r6,r2,3 /* get 2 low order bits of source address */
! 742: mask r7,r3,3 /* get 2 low order bits of destintation addr */
! 743: mak r6,r6,0<4> /* convert source bits to table offset */
! 744: mak r7,r7,0<2> /* convert destination bits to table offset */
! 745: or.u r12,r0,hi16(_ASM_LABEL(kf_strat))
! 746: or r12,r12,lo16(_ASM_LABEL(kf_strat))
! 747: addu r6,r6,r7 /* compute final table offset for strategy */
! 748: ld r12,r12,r6 /* load the strategy routine */
! 749: jmp r12 /* branch to strategy routine */
! 750:
! 751: /*
! 752: * Copy three bytes from src to destination then copy words
! 753: */
! 754: ASLOCAL(kf_3byte_word_copy)
! 755: ld.bu r6,r2,0 /* load byte from source */
! 756: ld.bu r7,r2,1 /* load byte from source */
! 757: ld.bu r8,r2,2 /* load byte from source */
! 758: st.b r6,r3,0 /* store byte to destination */
! 759: st.b r7,r3,1 /* store byte to destination */
! 760: st.b r8,r3,2 /* store byte to destination */
! 761: addu r2,r2,3 /* increment source pointer */
! 762: addu r3,r3,3 /* increment destination pointer */
! 763: br.n _ASM_LABEL(kf_word_copy) /* copy full words */
! 764: subu r4,r4,3 /* decrement length */
! 765:
! 766: /*
! 767: * Copy 1 halfword from src to destination then copy words
! 768: */
! 769: ASLOCAL(kf_1half_word_copy)
! 770: ld.hu r6,r2,0 /* load half-word from source */
! 771: st.h r6,r3,0 /* store half-word to destination */
! 772: addu r2,r2,2 /* increment source pointer */
! 773: addu r3,r3,2 /* increment destination pointer */
! 774: br.n _ASM_LABEL(kf_word_copy) /* copy full words */
! 775: subu r4,r4,2 /* decrement remaining length */
! 776:
! 777: /*
! 778: * Copy 1 byte from src to destination then copy words
! 779: */
! 780: ASLOCAL(kf_1byte_word_copy)
! 781: ld.bu r6,r2,0 /* load 1 byte from source */
! 782: st.b r6,r3,0 /* store 1 byte to destination */
! 783: addu r2,r2,1 /* increment source pointer */
! 784: addu r3,r3,1 /* increment destination pointer */
! 785: subu r4,r4,1 /* decrement remaining length */
! 786: /* fall through to word copy */
! 787: /*
! 788: * Copy as many full words as possible, 4 words per loop
! 789: */
! 790: ASLOCAL(kf_word_copy)
! 791: cmp r10,r4,16 /* see if we have 16 bytes remaining */
! 792: bb1 lo,r10,_ASM_LABEL(kf_byte_copy) /* not enough left, copy bytes */
! 793: ld r6,r2,0 /* load first word */
! 794: ld r7,r2,4 /* load second word */
! 795: ld r8,r2,8 /* load third word */
! 796: ld r9,r2,12 /* load fourth word */
! 797: st r6,r3,0 /* store first word */
! 798: st r7,r3,4 /* store second word */
! 799: st r8,r3,8 /* store third word */
! 800: st r9,r3,12 /* store fourth word */
! 801: addu r2,r2,16 /* increment source pointer */
! 802: addu r3,r3,16 /* increment destination pointer */
! 803: br.n _ASM_LABEL(kf_word_copy) /* copy another block */
! 804: subu r4,r4,16 /* decrement remaining length */
! 805:
! 806: ASLOCAL(kf_1byte_half_copy)
! 807: ld.bu r6,r2,0 /* load 1 byte from source */
! 808: st.b r6,r3,0 /* store 1 byte to destination */
! 809: addu r2,r2,1 /* increment source pointer */
! 810: addu r3,r3,1 /* increment destination pointer */
! 811: subu r4,r4,1 /* decrement remaining length */
! 812: /* fall through to half copy */
! 813:
! 814: ASLOCAL(kf_half_copy)
! 815: cmp r10,r4,16 /* see if we have 16 bytes remaining */
! 816: bb1 lo,r10,_ASM_LABEL(kf_byte_copy) /* not enough left, copy bytes */
! 817: ld.hu r6,r2,0 /* load first half-word */
! 818: ld.hu r7,r2,2 /* load second half-word */
! 819: ld.hu r8,r2,4 /* load third half-word */
! 820: ld.hu r9,r2,6 /* load fourth half-word */
! 821: ld.hu r10,r2,8 /* load fifth half-word */
! 822: ld.hu r11,r2,10 /* load sixth half-word */
! 823: ld.hu r12,r2,12 /* load seventh half-word */
! 824: ld.hu r13,r2,14 /* load eighth half-word */
! 825: st.h r6,r3,0 /* store first half-word */
! 826: st.h r7,r3,2 /* store second half-word */
! 827: st.h r8,r3,4 /* store third half-word */
! 828: st.h r9,r3,6 /* store fourth half-word */
! 829: st.h r10,r3,8 /* store fifth half-word */
! 830: st.h r11,r3,10 /* store sixth half-word */
! 831: st.h r12,r3,12 /* store seventh half-word */
! 832: st.h r13,r3,14 /* store eighth half-word */
! 833: addu r2,r2,16 /* increment source pointer */
! 834: addu r3,r3,16 /* increment destination pointer */
! 835: br.n _ASM_LABEL(kf_half_copy) /* copy another block */
! 836: subu r4,r4,16 /* decrement remaining length */
! 837:
! 838: ASLOCAL(kf_byte_copy)
! 839: bcnd eq0,r4,_ASM_LABEL(kcopy_out) /* branch if nothing left to copy */
! 840: ld.bu r6,r2,0 /* load byte from source */
! 841: st.b r6,r3,0 /* store byte in destination */
! 842: addu r2,r2,1 /* increment source pointer */
! 843: addu r3,r3,1 /* increment destination pointer */
! 844: br.n _ASM_LABEL(kf_byte_copy) /* branch for next byte */
! 845: subu r4,r4,1 /* decrement remaining length */
! 846:
! 847: /*
! 848: * source address is less than destination address, copy in reverse
! 849: */
! 850: ASLOCAL(kcopy_reverse)
! 851: /*
! 852: * start copy pointers at end of data
! 853: */
! 854: addu r2,r2,r4 /* start source at end of data */
! 855: addu r3,r3,r4 /* start destination at end of data */
! 856: /*
! 857: * check for short data
! 858: */
! 859: cmp r9,r4,16 /* see if we have at least 16 bytes */
! 860: bb1 lt,r9,_ASM_LABEL(kr_byte_copy) /* copy bytes for small data length */
! 861: /*
! 862: * determine copy strategy based on alignment of source and destination
! 863: */
! 864: mask r6,r2,3 /* get 2 low order bits of source address */
! 865: mask r7,r3,3 /* get 2 low order bits of destintation addr */
! 866: mak r6,r6,0<4> /* convert source bits to table offset */
! 867: mak r7,r7,0<2> /* convert destination bits to table offset */
! 868: or.u r12,r0,hi16(_ASM_LABEL(kr_strat))
! 869: or r12,r12,lo16(_ASM_LABEL(kr_strat))
! 870: addu r6,r6,r7 /* compute final table offset for strategy */
! 871: ld r12,r12,r6 /* load the strategy routine */
! 872: jmp r12 /* branch to strategy routine */
! 873:
! 874: /*
! 875: * Copy three bytes from src to destination then copy words
! 876: */
! 877: ASLOCAL(kr_3byte_word_copy)
! 878: subu r2,r2,3 /* decrement source pointer */
! 879: subu r3,r3,3 /* decrement destination pointer */
! 880: ld.bu r6,r2,0 /* load byte from source */
! 881: ld.bu r7,r2,1 /* load byte from source */
! 882: ld.bu r8,r2,2 /* load byte from source */
! 883: st.b r6,r3,0 /* store byte to destination */
! 884: st.b r7,r3,1 /* store byte to destination */
! 885: st.b r8,r3,2 /* store byte to destination */
! 886: br.n _ASM_LABEL(kr_word_copy) /* copy full words */
! 887: subu r4,r4,3 /* decrement length */
! 888:
! 889: /*
! 890: * Copy 1 halfword from src to destination then copy words
! 891: */
! 892: ASLOCAL(kr_1half_word_copy)
! 893: subu r2,r2,2 /* decrement source pointer */
! 894: subu r3,r3,2 /* decrement destination pointer */
! 895: ld.hu r6,r2,0 /* load half-word from source */
! 896: st.h r6,r3,0 /* store half-word to destination */
! 897: br.n _ASM_LABEL(kr_word_copy) /* copy full words */
! 898: subu r4,r4,2 /* decrement remaining length */
! 899:
! 900: /*
! 901: * Copy 1 byte from src to destination then copy words
! 902: */
! 903: ASLOCAL(kr_1byte_word_copy)
! 904: subu r2,r2,1 /* decrement source pointer */
! 905: subu r3,r3,1 /* decrement destination pointer */
! 906: ld.bu r6,r2,0 /* load 1 byte from source */
! 907: st.b r6,r3,0 /* store 1 byte to destination */
! 908: subu r4,r4,1 /* decrement remaining length */
! 909: /* fall through to word copy */
! 910: /*
! 911: * Copy as many full words as possible, 4 words per loop
! 912: */
! 913: ASLOCAL(kr_word_copy)
! 914: cmp r10,r4,16 /* see if we have 16 bytes remaining */
! 915: bb1 lo,r10,_ASM_LABEL(kr_byte_copy) /* not enough left, copy bytes */
! 916: subu r2,r2,16 /* decrement source pointer */
! 917: subu r3,r3,16 /* decrement destination pointer */
! 918: ld r6,r2,0 /* load first word */
! 919: ld r7,r2,4 /* load second word */
! 920: ld r8,r2,8 /* load third word */
! 921: ld r9,r2,12 /* load fourth word */
! 922: st r6,r3,0 /* store first word */
! 923: st r7,r3,4 /* store second word */
! 924: st r8,r3,8 /* store third word */
! 925: st r9,r3,12 /* store fourth word */
! 926: br.n _ASM_LABEL(kr_word_copy) /* copy another block */
! 927: subu r4,r4,16 /* decrement remaining length */
! 928:
! 929: ASLOCAL(kr_1byte_half_copy)
! 930: subu r2,r2,1 /* decrement source pointer */
! 931: subu r3,r3,1 /* decrement destination pointer */
! 932: ld.bu r6,r2,0 /* load 1 byte from source */
! 933: st.b r6,r3,0 /* store 1 byte to destination */
! 934: subu r4,r4,1 /* decrement remaining length */
! 935: /* fall through to half copy */
! 936:
! 937: ASLOCAL(kr_half_copy)
! 938: cmp r10,r4,16 /* see if we have 16 bytes remaining */
! 939: bb1 lo,r10,_ASM_LABEL(kr_byte_copy) /* not enough left, copy bytes */
! 940: subu r2,r2,16 /* decrement source pointer */
! 941: subu r3,r3,16 /* decrement destination pointer */
! 942: ld.hu r6,r2,0 /* load first half-word */
! 943: ld.hu r7,r2,2 /* load second half-word */
! 944: ld.hu r8,r2,4 /* load third half-word */
! 945: ld.hu r9,r2,6 /* load fourth half-word */
! 946: ld.hu r10,r2,8 /* load fifth half-word */
! 947: ld.hu r11,r2,10 /* load sixth half-word */
! 948: ld.hu r12,r2,12 /* load seventh half-word */
! 949: ld.hu r13,r2,14 /* load eighth half-word */
! 950: st.h r6,r3,0 /* store first half-word */
! 951: st.h r7,r3,2 /* store second half-word */
! 952: st.h r8,r3,4 /* store third half-word */
! 953: st.h r9,r3,6 /* store fourth half-word */
! 954: st.h r10,r3,8 /* store fifth half-word */
! 955: st.h r11,r3,10 /* store sixth half-word */
! 956: st.h r12,r3,12 /* store seventh half-word */
! 957: st.h r13,r3,14 /* store eighth half-word */
! 958: br.n _ASM_LABEL(kr_half_copy) /* copy another block */
! 959: subu r4,r4,16 /* decrement remaining length */
! 960:
! 961: ASLOCAL(kr_byte_copy)
! 962: bcnd eq0,r4,_ASM_LABEL(kcopy_out) /* branch if nothing left to copy */
! 963: subu r2,r2,1 /* decrement source pointer */
! 964: subu r3,r3,1 /* decrement destination pointer */
! 965: ld.bu r6,r2,0 /* load byte from source */
! 966: st.b r6,r3,0 /* store byte in destination */
! 967: br.n _ASM_LABEL(kr_byte_copy) /* branch for next byte */
! 968: subu r4,r4,1 /* decrement remaining length */
! 969:
! 970: ASLOCAL(kcopy_out)
! 971: or r2, r0, 0 /* return success */
! 972: ASLOCAL(kcopy_out_fault)
! 973: ldcr r5, CPU
! 974: ld r6, r5, CI_CURPCB
! 975: jmp.n r1 /* all done, return to caller */
! 976: st r0, r6, PCB_ONFAULT /* clear the handler */
! 977:
! 978: ASLOCAL(kcopy_fault)
! 979: br.n _ASM_LABEL(kcopy_out_fault)
! 980: or r2, r0, EFAULT /* return fault */
! 981:
! 982: data
! 983: align 4
! 984: ASLOCAL(kf_strat)
! 985: word _ASM_LABEL(kf_word_copy)
! 986: word _ASM_LABEL(kf_byte_copy)
! 987: word _ASM_LABEL(kf_half_copy)
! 988: word _ASM_LABEL(kf_byte_copy)
! 989: word _ASM_LABEL(kf_byte_copy)
! 990: word _ASM_LABEL(kf_3byte_word_copy)
! 991: word _ASM_LABEL(kf_byte_copy)
! 992: word _ASM_LABEL(kf_1byte_half_copy)
! 993: word _ASM_LABEL(kf_half_copy)
! 994: word _ASM_LABEL(kf_byte_copy)
! 995: word _ASM_LABEL(kf_1half_word_copy)
! 996: word _ASM_LABEL(kf_byte_copy)
! 997: word _ASM_LABEL(kf_byte_copy)
! 998: word _ASM_LABEL(kf_1byte_half_copy)
! 999: word _ASM_LABEL(kf_byte_copy)
! 1000: word _ASM_LABEL(kf_1byte_word_copy)
! 1001:
! 1002: ASLOCAL(kr_strat)
! 1003: word _ASM_LABEL(kr_word_copy)
! 1004: word _ASM_LABEL(kr_byte_copy)
! 1005: word _ASM_LABEL(kr_half_copy)
! 1006: word _ASM_LABEL(kr_byte_copy)
! 1007: word _ASM_LABEL(kr_byte_copy)
! 1008: word _ASM_LABEL(kr_1byte_word_copy)
! 1009: word _ASM_LABEL(kr_byte_copy)
! 1010: word _ASM_LABEL(kr_1byte_half_copy)
! 1011: word _ASM_LABEL(kr_half_copy)
! 1012: word _ASM_LABEL(kr_byte_copy)
! 1013: word _ASM_LABEL(kr_1half_word_copy)
! 1014: word _ASM_LABEL(kr_byte_copy)
! 1015: word _ASM_LABEL(kr_byte_copy)
! 1016: word _ASM_LABEL(kr_1byte_half_copy)
! 1017: word _ASM_LABEL(kr_byte_copy)
! 1018: word _ASM_LABEL(kr_3byte_word_copy)
! 1019:
! 1020: /*
! 1021: * non-local goto
! 1022: * int setjmp(label_t *);
! 1023: * void longjmp(label_t*);
! 1024: */
! 1025: ENTRY(setjmp)
! 1026: st r1,r2,0
! 1027: st r14,r2,4
! 1028: st r15,r2,2*4
! 1029: st r16,r2,3*4
! 1030: st r17,r2,4*4
! 1031: st r18,r2,5*4
! 1032: st r19,r2,6*4
! 1033: st r20,r2,7*4
! 1034: st r21,r2,8*4
! 1035: st r22,r2,9*4
! 1036: st r23,r2,10*4
! 1037: st r24,r2,11*4
! 1038: st r25,r2,12*4
! 1039: st r26,r2,13*4
! 1040: st r27,r2,14*4
! 1041: st r28,r2,15*4
! 1042: st r29,r2,16*4
! 1043: st r30,r2,17*4
! 1044: st r31,r2,18*4
! 1045: jmp.n r1
! 1046: or r2,r0,r0
! 1047:
! 1048: ENTRY(longjmp)
! 1049: ld r1,r2,0
! 1050: ld r14,r2,4
! 1051: ld r15,r2,2*4
! 1052: ld r16,r2,3*4
! 1053: ld r17,r2,4*4
! 1054: ld r18,r2,5*4
! 1055: ld r19,r2,6*4
! 1056: ld r20,r2,7*4
! 1057: ld r21,r2,8*4
! 1058: ld r22,r2,9*4
! 1059: ld r23,r2,10*4
! 1060: ld r24,r2,11*4
! 1061: ld r25,r2,12*4
! 1062: ld r26,r2,13*4
! 1063: ld r27,r2,14*4
! 1064: ld r28,r2,15*4
! 1065: ld r29,r2,16*4
! 1066: ld r30,r2,17*4
! 1067: ld r31,r2,18*4
! 1068: jmp.n r1
! 1069: or r2,r0,1
! 1070:
! 1071: /*
! 1072: * Signal trampoline code.
! 1073: * The kernel arranges for the handler to be invoked directly, and return
! 1074: * here.
! 1075: */
! 1076: GLOBAL(sigcode) /* r31 points to sigframe */
! 1077: ld r2, r31, 0 /* pick sigcontext* */
! 1078: or r13, r0, SYS_sigreturn
! 1079: tb0 0, r0, 128 /* syscall trap, calling sigreturn */
! 1080: NOP | failure return
! 1081: #ifdef dontbother /* sigreturn will not return unless it fails */
! 1082: NOP | success return
! 1083: #endif
! 1084: or r13, r0, SYS_exit
! 1085: tb0 0, r0, 128 /* syscall trap, exit */
! 1086: /*
! 1087: * this never returns, but we need to provide fetchable instructions
! 1088: * for the 88100 pipeline.
! 1089: */
! 1090: NOP
! 1091: NOP
! 1092: GLOBAL(esigcode)
CVSweb
![[BACK]](/icons/back.gif){kind=icon}
Return to subr.S CVS log ![[TXT]](/icons/text.gif){kind=icon}
![[DIR]](/icons/dir.gif){kind=icon}
Up to [local] / sys / arch / m88k / m88k