From 5746cf2977bab637710f707ab6ffd43231ea7ce3 Mon Sep 17 00:00:00 2001 From: guenther Date: Tue, 6 Dec 2022 18:50:59 +0000 Subject: [PATCH] _C_LABEL() and _ASM_LABEL() are no longer useful in the "everything is ELF" world. Eliminate use of them in m88k code. ok aoyama@ --- lib/libc/arch/m88k/gen/divsi3.S | 4 +- lib/libc/arch/m88k/gen/modsi3.S | 4 +- lib/libc/arch/m88k/gen/udivsi3.S | 4 +- lib/libc/arch/m88k/gen/umodsi3.S | 4 +- sys/arch/luna88k/luna88k/locore.S | 6 +- sys/arch/luna88k/luna88k/locore0.S | 114 ++++++------ sys/arch/luna88k/stand/boot/locore.S | 56 +++--- sys/arch/m88k/include/asm.h | 20 +- sys/arch/m88k/m88k/atomic.S | 34 ++-- sys/arch/m88k/m88k/eh_common.S | 256 +++++++++++++------------- sys/arch/m88k/m88k/process.S | 6 +- sys/arch/m88k/m88k/subr.S | 238 ++++++++++++------------ sys/lib/libkern/arch/m88k/bzero.S | 18 +- sys/lib/libkern/arch/m88k/copy_subr.S | 116 ++++++------ 14 files changed, 440 insertions(+), 440 deletions(-) diff --git a/lib/libc/arch/m88k/gen/divsi3.S b/lib/libc/arch/m88k/gen/divsi3.S index 09da2607c82..18629b74fa9 100644 --- a/lib/libc/arch/m88k/gen/divsi3.S +++ b/lib/libc/arch/m88k/gen/divsi3.S @@ -1,4 +1,4 @@ -/* $OpenBSD: divsi3.S,v 1.3 2013/06/05 22:48:21 miod Exp $ */ +/* $OpenBSD: divsi3.S,v 1.4 2022/12/06 18:50:59 guenther Exp $ */ /* * Copyright (c) 2013 Miodrag Vallat. @@ -24,7 +24,7 @@ */ #ifndef LDSO -.weak _C_LABEL(__divsi3) +.weak __divsi3 #endif ENTRY(__divsi3) /* if divider is zero, trap */ diff --git a/lib/libc/arch/m88k/gen/modsi3.S b/lib/libc/arch/m88k/gen/modsi3.S index dee1779a7dd..be377f5fbe3 100644 --- a/lib/libc/arch/m88k/gen/modsi3.S +++ b/lib/libc/arch/m88k/gen/modsi3.S @@ -1,4 +1,4 @@ -/* $OpenBSD: modsi3.S,v 1.2 2013/06/05 22:48:21 miod Exp $ */ +/* $OpenBSD: modsi3.S,v 1.3 2022/12/06 18:50:59 guenther Exp $ */ /* * Copyright (c) 2013 Miodrag Vallat. @@ -24,7 +24,7 @@ */ #ifndef LDSO -.weak _C_LABEL(__modsi3) +.weak __modsi3 #endif ENTRY(__modsi3) /* if divider is zero, trap */ diff --git a/lib/libc/arch/m88k/gen/udivsi3.S b/lib/libc/arch/m88k/gen/udivsi3.S index bc776bfc25b..345243e1b5d 100644 --- a/lib/libc/arch/m88k/gen/udivsi3.S +++ b/lib/libc/arch/m88k/gen/udivsi3.S @@ -1,4 +1,4 @@ -/* $OpenBSD: udivsi3.S,v 1.3 2013/06/05 22:48:21 miod Exp $ */ +/* $OpenBSD: udivsi3.S,v 1.4 2022/12/06 18:50:59 guenther Exp $ */ /* * Copyright (c) 2013 Miodrag Vallat. @@ -24,7 +24,7 @@ */ #ifndef LDSO -.weak _C_LABEL(__udivsi3) +.weak __udivsi3 #endif ENTRY(__udivsi3) /* if divider is zero, trap */ diff --git a/lib/libc/arch/m88k/gen/umodsi3.S b/lib/libc/arch/m88k/gen/umodsi3.S index 701bff893b1..eacf6867ffb 100644 --- a/lib/libc/arch/m88k/gen/umodsi3.S +++ b/lib/libc/arch/m88k/gen/umodsi3.S @@ -1,4 +1,4 @@ -/* $OpenBSD: umodsi3.S,v 1.2 2013/06/05 22:48:21 miod Exp $ */ +/* $OpenBSD: umodsi3.S,v 1.3 2022/12/06 18:50:59 guenther Exp $ */ /* * Copyright (c) 2013 Miodrag Vallat. @@ -24,7 +24,7 @@ */ #ifndef LDSO -.weak _C_LABEL(__umodsi3) +.weak __umodsi3 #endif ENTRY(__umodsi3) /* if divider is zero, trap */ diff --git a/sys/arch/luna88k/luna88k/locore.S b/sys/arch/luna88k/luna88k/locore.S index 410d15a7925..680ac8a0417 100644 --- a/sys/arch/luna88k/luna88k/locore.S +++ b/sys/arch/luna88k/luna88k/locore.S @@ -1,4 +1,4 @@ -/* $OpenBSD: locore.S,v 1.32 2017/07/23 09:17:17 aoyama Exp $ */ +/* $OpenBSD: locore.S,v 1.33 2022/12/06 18:50:59 guenther Exp $ */ /* * Copyright (c) 1998 Steve Murphree, Jr. * Copyright (c) 1996 Nivas Madhur @@ -69,8 +69,8 @@ GLOBAL(delay) bcnd eq0, %r2, 2f - or.u %r3, %r0, %hi16(_C_LABEL(cpuspeed)) - ld %r3, %r3, %lo16(_C_LABEL(cpuspeed)) + or.u %r3, %r0, %hi16(cpuspeed) + ld %r3, %r3, %lo16(cpuspeed) mul %r4, %r2, %r3 subu %r4, %r4, 4 /* overhead of these instructions */ diff --git a/sys/arch/luna88k/luna88k/locore0.S b/sys/arch/luna88k/luna88k/locore0.S index b05f7a0093c..7bc752d24ad 100644 --- a/sys/arch/luna88k/luna88k/locore0.S +++ b/sys/arch/luna88k/luna88k/locore0.S @@ -1,4 +1,4 @@ -/* $OpenBSD: locore0.S,v 1.5 2022/10/14 20:53:18 aoyama Exp $ */ +/* $OpenBSD: locore0.S,v 1.6 2022/12/06 18:50:59 guenther Exp $ */ /* * Copyright (c) 1998 Steve Murphree, Jr. * Copyright (c) 1996 Nivas Madhur @@ -106,10 +106,10 @@ ASGLOBAL(__start) * A few identical jump instructions to make sure the pipeline is * in a good state. Probably overkill, but it's cheap. */ - br _ASM_LABEL(main_start) - br _ASM_LABEL(main_start) - br _ASM_LABEL(main_start) - br _ASM_LABEL(main_start) + br main_start + br main_start + br main_start + br main_start /* * Startup code common to all processors. @@ -121,14 +121,14 @@ ASLOCAL(main_start) cmp %r11, %r2, %r10 bb1 ne, %r11, 1f - or.u %r10, %r0, %hi16(_C_LABEL(esym)) - st %r3, %r10, %lo16(_C_LABEL(esym)) + or.u %r10, %r0, %hi16(esym) + st %r3, %r10, %lo16(esym) 1: #endif or %r24, %r0, %r4 /* save bootdev */ or %r25, %r0, %r5 /* save boothowto */ - bsr _ASM_LABEL(setup_psr) + bsr setup_psr stcr %r0, VBR /* start with VBR set to zero */ FLUSH_PIPELINE @@ -137,8 +137,8 @@ ASLOCAL(main_start) * Now we will compete with the other processors to see which one * will be elected as the main one. */ - or.u %r11, %r0, %hi16(_C_LABEL(cpu_hatch_mutex)) - or %r11, %r11, %lo16(_C_LABEL(cpu_hatch_mutex)) + or.u %r11, %r0, %hi16(cpu_hatch_mutex) + or %r11, %r11, %lo16(cpu_hatch_mutex) 1: FLUSH_PIPELINE or %r22, %r0, 1 @@ -158,8 +158,8 @@ ASLOCAL(main_start) 4: /* now try to grab the master_mpu prize */ FLUSH_PIPELINE - or.u %r11, %r0, %hi16(_ASM_LABEL(master_mpu)) - or %r11, %r11, %lo16(_ASM_LABEL(master_mpu)) + or.u %r11, %r0, %hi16(master_mpu) + or %r11, %r11, %lo16(master_mpu) or %r22, %r0, 1 xmem %r22, %r11, %r0 @@ -170,7 +170,7 @@ ASLOCAL(main_start) * Note that we haven't released the interprocessor lock.... * We'll do that when we're ready for another CPU to go. */ - bcnd ne0, %r22, _ASM_LABEL(secondary_init) + bcnd ne0, %r22, secondary_init /* * Main processor specific initialization (with @@ -178,29 +178,29 @@ ASLOCAL(main_start) */ ASLOCAL(main_init) /* clear BSS. PROM might have already done this... */ - or.u %r2, %r0, %hi16(_C_LABEL(edata)) - or %r2, %r2, %lo16(_C_LABEL(edata)) - or.u %r4, %r0, %hi16(_C_LABEL(end)) - or %r4, %r4, %lo16(_C_LABEL(end)) - bsr.n _C_LABEL(bzero) /* bzero(edata, end-edata) */ + or.u %r2, %r0, %hi16(edata) + or %r2, %r2, %lo16(edata) + or.u %r4, %r0, %hi16(end) + or %r4, %r4, %lo16(end) + bsr.n bzero /* bzero(edata, end-edata) */ subu %r3, %r4, %r2 /* figure out the end of the kernel image. */ #if defined(DDB) || NKSYMS > 0 - or.u %r4, %r0, %hi16(_C_LABEL(esym)) - ld %r4, %r4, %lo16(_C_LABEL(esym)) + or.u %r4, %r0, %hi16(esym) + ld %r4, %r4, %lo16(esym) bcnd ne0, %r4, 1f #endif - or.u %r4, %r0, %hi16(_C_LABEL(end)) - or %r4, %r4, %lo16(_C_LABEL(end)) /* if no symbols */ + or.u %r4, %r0, %hi16(end) + or %r4, %r4, %lo16(end) /* if no symbols */ 1: - or.u %r5, %r0, %hi16(_C_LABEL(first_addr)) - st %r4, %r5, %lo16(_C_LABEL(first_addr)) + or.u %r5, %r0, %hi16(first_addr) + st %r4, %r5, %lo16(first_addr) - or.u %r5, %r0, %hi16(_C_LABEL(bootdev)) - st %r24, %r5, %lo16(_C_LABEL(bootdev)) - or.u %r5, %r0, %hi16(_C_LABEL(boothowto)) - st %r25, %r5, %lo16(_C_LABEL(boothowto)) + or.u %r5, %r0, %hi16(bootdev) + st %r24, %r5, %lo16(bootdev) + or.u %r5, %r0, %hi16(boothowto) + st %r25, %r5, %lo16(boothowto) /* * Have curcpu() point to a valid cpuinfo structure, @@ -209,23 +209,23 @@ ASLOCAL(main_init) * mutex diagnostic code. */ #ifdef MULTIPROCESSOR - or.u %r11, %r0, %hi16(_ASM_LABEL(dummy_cpu)) - or %r11, %r11, %lo16(_ASM_LABEL(dummy_cpu)) + or.u %r11, %r0, %hi16(dummy_cpu) + or %r11, %r11, %lo16(dummy_cpu) #else /* Need to make sure this matches non-MP curcpu() */ - or.u %r11, %r0, %hi16(_C_LABEL(m88k_cpus)) - or %r11, %r11, %lo16(_C_LABEL(m88k_cpus)) + or.u %r11, %r0, %hi16(m88k_cpus) + or %r11, %r11, %lo16(m88k_cpus) #endif stcr %r11, CPU /* Switch to startup stack */ - or.u %r31, %r0, %hi16(_ASM_LABEL(initstack_end)) - or %r31, %r31, %lo16(_ASM_LABEL(initstack_end)) + or.u %r31, %r0, %hi16(initstack_end) + or %r31, %r31, %lo16(initstack_end) - or.u %r3, %r0, %hi16(_C_LABEL(vector_list)) - or %r3, %r3, %lo16(_C_LABEL(vector_list)) + or.u %r3, %r0, %hi16(vector_list) + or %r3, %r3, %lo16(vector_list) - bsr.n _C_LABEL(luna88k_vector_init) + bsr.n luna88k_vector_init ldcr %r2, VBR /* PIO stuff */ @@ -238,13 +238,13 @@ ASLOCAL(main_init) mak %r10, %r10, 0<8> /* shift left 8 bit */ ld.bu %r12, %r11, %lo16(OBIO_PIO0B) /* dipsw-2 (from portB) */ or %r10, %r10, %r12 - or.u %r11, %r0, %hi16(_C_LABEL(dipswitch)) - st.h %r10, %r11, %lo16(_C_LABEL(dipswitch)) + or.u %r11, %r0, %hi16(dipswitch) + st.h %r10, %r11, %lo16(dipswitch) /* read frame buffer depth from ROM work area */ ld %r12, %r0, %lo16(0x00001114) /* frame buffer depth */ - or.u %r13, %r0, %hi16(_C_LABEL(hwplanebits)) - st %r12, %r13, %lo16(_C_LABEL(hwplanebits)) + or.u %r13, %r0, %hi16(hwplanebits) + st %r12, %r13, %lo16(hwplanebits) /* * By default, sysconsole is set to 0 (means using ttya). If @@ -255,8 +255,8 @@ ASLOCAL(main_init) bb0 14, %r10, 1f /* if dipsw-1:2 is on, skip */ bcnd eq0, %r12, 1f /* if hwplanebits == 0, skip */ or %r10, %r0, 1 /* set sysconsole = 1 */ - or.u %r11, %r0, %hi16(_C_LABEL(sysconsole)) - st %r10, %r11, %lo16(_C_LABEL(sysconsole)) + or.u %r11, %r0, %hi16(sysconsole) + st %r10, %r11, %lo16(sysconsole) 1: or %r10, %r0, 0x84 /* initialize pio1 */ @@ -278,7 +278,7 @@ ASLOCAL(main_init) * We are still using the interrupt stack here, thus we are not * affected... */ - bsr _C_LABEL(luna88k_bootstrap) + bsr luna88k_bootstrap /* * ...and we can switch to the u area stack now. @@ -288,11 +288,11 @@ ASLOCAL(main_init) addu %r31, %r31, USPACE /* call main() - no arguments although main() still defines one */ - bsr _C_LABEL(main) + bsr main - or.u %r2, %r0, %hi16(_ASM_LABEL(main_panic)) - bsr.n _C_LABEL(panic) - or %r2, %r2, %lo16(_ASM_LABEL(main_panic)) + or.u %r2, %r0, %hi16(main_panic) + bsr.n panic + or %r2, %r2, %lo16(main_panic) .data .balign 4 @@ -313,8 +313,8 @@ ASLOCAL(secondary_init) * This is necessary for early spl*() usage, as well as * mutex diagnostic code. */ - or.u %r11, %r0, %hi16(_ASM_LABEL(dummy_cpu)) - or %r11, %r11, %lo16(_ASM_LABEL(dummy_cpu)) + or.u %r11, %r0, %hi16(dummy_cpu) + or %r11, %r11, %lo16(dummy_cpu) st %r0, %r11, CI_FLAGS /* reset CIF_PRIMARY */ stcr %r11, CPU @@ -325,11 +325,11 @@ ASLOCAL(secondary_init) * use and we'll switch to it. */ - or.u %r31, %r0, %hi16(_ASM_LABEL(slavestack_end)) - bsr.n _C_LABEL(secondary_pre_main) /* set cpu number */ - or %r31, %r31, %lo16(_ASM_LABEL(slavestack_end)) + or.u %r31, %r0, %hi16(slavestack_end) + bsr.n secondary_pre_main /* set cpu number */ + or %r31, %r31, %lo16(slavestack_end) - bsr.n _C_LABEL(secondary_main) + bsr.n secondary_main addu %r31, %r2, USPACE /* switch to idle stack */ #else @@ -377,7 +377,7 @@ ASLOCAL(slavestack_end) ASLOCAL(u0) .space USPACE GLOBAL(proc0paddr) - .word _ASM_LABEL(u0) /* KVA of proc0 uarea */ + .word u0 /* KVA of proc0 uarea */ /* The first processor to XMEM this becomes the master */ ASLOCAL(master_mpu) @@ -391,8 +391,8 @@ ASLOCAL(dummy_cpu) .word 0 /* ci_curpcb */ .word 0 /* ci_curpmap */ .word 0 /* ci_cpuid */ - .word _ASM_LABEL(dummy_mplock) /* ci_mp_atomic_begin */ - .word _ASM_LABEL(dummy_mplock) /* ci_mp_atomic_end */ + .word dummy_mplock /* ci_mp_atomic_begin */ + .word dummy_mplock /* ci_mp_atomic_end */ .space CPU_INFO_SIZEOF - 7 * 4 #endif diff --git a/sys/arch/luna88k/stand/boot/locore.S b/sys/arch/luna88k/stand/boot/locore.S index ed9db57f29a..deb153e4a7c 100644 --- a/sys/arch/luna88k/stand/boot/locore.S +++ b/sys/arch/luna88k/stand/boot/locore.S @@ -1,4 +1,4 @@ -/* $OpenBSD: locore.S,v 1.3 2022/10/14 20:53:19 aoyama Exp $ */ +/* $OpenBSD: locore.S,v 1.4 2022/12/06 18:50:59 guenther Exp $ */ /* * Copyright (c) 2013 Miodrag Vallat. @@ -67,11 +67,11 @@ ASLOCAL(main_start) * They will then proceed to run the kernel, as if the kernel * had been directly booted from the PROM. */ - or.u %r3, %r0, %hi16(_ASM_LABEL(cpu_park_address)) - or %r3, %r3, %lo16(_ASM_LABEL(cpu_park_address)) + or.u %r3, %r0, %hi16(cpu_park_address) + or %r3, %r3, %lo16(cpu_park_address) - or.u %r2, %r0, %hi16(_ASM_LABEL(cpu_park)) - or %r2, %r2, %lo16(_ASM_LABEL(cpu_park)) + or.u %r2, %r0, %hi16(cpu_park) + or %r2, %r2, %lo16(cpu_park) FLUSH_PIPELINE xmem %r2, %r3, %r0 @@ -80,18 +80,18 @@ ASLOCAL(main_start) 1: /* clear BSS */ - or.u %r2, %r0, %hi16(_C_LABEL(edata)) - or %r2, %r2, %lo16(_C_LABEL(edata)) - or.u %r4, %r0, %hi16(_C_LABEL(end)) - or %r4, %r4, %lo16(_C_LABEL(end)) + or.u %r2, %r0, %hi16(edata) + or %r2, %r2, %lo16(edata) + or.u %r4, %r0, %hi16(end) + or %r4, %r4, %lo16(end) 1: st %r0, %r2, %r0 addu %r2, %r2, 4 cmp %r3, %r2, %r4 bb1 ne, %r3, 1b /* setup stack, below our image */ - or.u %r31, %r0, %hi16(_ASM_LABEL(__start)) - or %r31, %r31, %lo16(_ASM_LABEL(__start)) + or.u %r31, %r0, %hi16(__start) + or %r31, %r31, %lo16(__start) /* read dip switch settings */ or.u %r11, %r0, %hi16(OBIO_PIO0A) @@ -100,11 +100,11 @@ ASLOCAL(main_start) ld.bu %r12, %r11, %lo16(OBIO_PIO0B) or %r10, %r10, %r12 - or.u %r11, %r0, %hi16(_C_LABEL(dipswitch)) - st.h %r10, %r11, %lo16(_C_LABEL(dipswitch)) + or.u %r11, %r0, %hi16(dipswitch) + st.h %r10, %r11, %lo16(dipswitch) - bsr _C_LABEL(main) - bsr _C_LABEL(_rtt) + bsr main + bsr _rtt 1: br 1b ASLOCAL(cpu_park) @@ -115,30 +115,30 @@ ASLOCAL(cpu_park) bcnd ne0, %r2, 9b /* if kernel entry point is known, exit */ - or.u %r1, %r0, %hi16(_C_LABEL(cpu_boot)) - ld %r1, %r1, %lo16(_C_LABEL(cpu_boot)) - bcnd eq0, %r1, _ASM_LABEL(cpu_park) + or.u %r1, %r0, %hi16(cpu_boot) + ld %r1, %r1, %lo16(cpu_boot) + bcnd eq0, %r1, cpu_park or.u %r2, %r0, 1 9: subu %r2, %r2, 1 bcnd ne0, %r2, 9b - or.u %r2, %r0, %hi16(_C_LABEL(cpu_bootarg1)) - ld %r2, %r2, %lo16(_C_LABEL(cpu_bootarg1)) - or.u %r3, %r0, %hi16(_C_LABEL(cpu_bootarg2)) - ld %r3, %r3, %lo16(_C_LABEL(cpu_bootarg2)) - or.u %r4, %r0, %hi16(_C_LABEL(cpu_bootarg3)) - ld %r4, %r4, %lo16(_C_LABEL(cpu_bootarg3)) - or.u %r5, %r0, %hi16(_C_LABEL(cpu_bootarg4)) - ld %r5, %r5, %lo16(_C_LABEL(cpu_bootarg4)) + or.u %r2, %r0, %hi16(cpu_bootarg1) + ld %r2, %r2, %lo16(cpu_bootarg1) + or.u %r3, %r0, %hi16(cpu_bootarg2) + ld %r3, %r3, %lo16(cpu_bootarg2) + or.u %r4, %r0, %hi16(cpu_bootarg3) + ld %r4, %r4, %lo16(cpu_bootarg3) + or.u %r5, %r0, %hi16(cpu_bootarg4) + ld %r5, %r5, %lo16(cpu_bootarg4) jmp %r1 GLOBAL(delay) bcnd eq0, %r2, 2f - or.u %r3, %r0, %hi16(_C_LABEL(cpuspeed)) - ld %r3, %r3, %lo16(_C_LABEL(cpuspeed)) + or.u %r3, %r0, %hi16(cpuspeed) + ld %r3, %r3, %lo16(cpuspeed) mul %r4, %r2, %r3 subu %r4, %r4, 4 1: diff --git a/sys/arch/m88k/include/asm.h b/sys/arch/m88k/include/asm.h index 6c858a99382..666aef6c75a 100644 --- a/sys/arch/m88k/include/asm.h +++ b/sys/arch/m88k/include/asm.h @@ -1,4 +1,4 @@ -/* $OpenBSD: asm.h,v 1.15 2016/05/27 16:32:38 deraadt Exp $ */ +/* $OpenBSD: asm.h,v 1.16 2022/12/06 18:50:59 guenther Exp $ */ /* * Mach Operating System @@ -36,29 +36,29 @@ #define _ENTRY(name) \ .text; .align 3; .globl name; .type name,@function; name: -#define ENTRY(name) _ENTRY(_C_LABEL(name)) -#define ASENTRY(name) _ENTRY(_ASM_LABEL(name)) +#define ENTRY(name) _ENTRY(name) +#define ASENTRY(name) _ENTRY(name) #define END(name) \ .size name,.-name #define GLOBAL(name) \ - .globl _C_LABEL(name); _C_LABEL(name): + .globl name; name: #define ASGLOBAL(name) \ - .globl _ASM_LABEL(name); _ASM_LABEL(name): + .globl name; name: #define LOCAL(name) \ - _C_LABEL(name): + name: #define ASLOCAL(name) \ - _ASM_LABEL(name): + name: #define BSS(name, size) \ - .comm _C_LABEL(name), size + .comm name, size #define ASBSS(name, size) \ - .comm _ASM_LABEL(name), size + .comm name, size #define STRONG_ALIAS(alias,sym) \ .global alias; \ @@ -180,7 +180,7 @@ #define RTE_ERROR_BIT 0 #define VECTOR(x) \ - .word _C_LABEL(x) + .word x #endif /* _LOCORE */ diff --git a/sys/arch/m88k/m88k/atomic.S b/sys/arch/m88k/m88k/atomic.S index a99df714af0..87bc46529b4 100644 --- a/sys/arch/m88k/m88k/atomic.S +++ b/sys/arch/m88k/m88k/atomic.S @@ -1,4 +1,4 @@ -/* $OpenBSD: atomic.S,v 1.6 2014/07/15 16:26:28 miod Exp $ */ +/* $OpenBSD: atomic.S,v 1.7 2022/12/06 18:50:59 guenther Exp $ */ /* * Copyright (c) 2009 Miodrag Vallat. @@ -51,50 +51,50 @@ ASLOCAL(__atomic_interlock) ENTRY(atomic_setbits_int) or %r5, %r1, %r0 /* save return address */ - bsr _C_LABEL(__atomic_lock) + bsr __atomic_lock ld %r4, %r2, %r0 or %r4, %r4, %r3 st %r4, %r2, %r0 - br _C_LABEL(__atomic_unlock) + br __atomic_unlock ENTRY(atomic_clearbits_int) or %r5, %r1, %r0 /* save return address */ - bsr _C_LABEL(__atomic_lock) + bsr __atomic_lock ld %r4, %r2, %r0 or %r4, %r4, %r3 xor %r4, %r4, %r3 /* r4 &= ~r3 */ st %r4, %r2, %r0 - br _C_LABEL(__atomic_unlock) + br __atomic_unlock ENTRY(atomic_add_int_nv_mp) or %r5, %r1, %r0 /* save return address */ - bsr _C_LABEL(__atomic_lock) + bsr __atomic_lock or %r9, %r2, %r0 ld %r2, %r9, %r0 addu %r2, %r2, %r3 st %r2, %r9, %r0 - br _C_LABEL(__atomic_unlock) + br __atomic_unlock ENTRY(atomic_sub_int_nv_mp) or %r5, %r1, %r0 /* save return address */ - bsr _C_LABEL(__atomic_lock) + bsr __atomic_lock or %r9, %r2, %r0 ld %r2, %r9, %r0 subu %r2, %r2, %r3 st %r2, %r9, %r0 - br _C_LABEL(__atomic_unlock) + br __atomic_unlock ENTRY(atomic_cas_uint_mp) or %r5, %r1, %r0 /* save return address */ - bsr _C_LABEL(__atomic_lock) + bsr __atomic_lock ld %r9, %r2, %r0 cmp %r3, %r3, %r9 @@ -103,17 +103,17 @@ ENTRY(atomic_cas_uint_mp) 1: or %r2, %r9, %r0 - br _C_LABEL(__atomic_unlock) + br __atomic_unlock ENTRY(atomic_swap_uint_mp) or %r5, %r1, %r0 /* save return address */ - bsr _C_LABEL(__atomic_lock) + bsr __atomic_lock ld %r4, %r2, %r0 st %r3, %r2, %r0 or %r2, %r4, %r0 - br _C_LABEL(__atomic_unlock) + br __atomic_unlock GLOBAL(__atomic_lock) @@ -130,8 +130,8 @@ ASLOCAL(__atomic_lock_88110) * then grab the interlock. */ - or.u %r6, %r0, %hi16(_ASM_LABEL(__atomic_interlock)) - or %r6, %r6, %lo16(_ASM_LABEL(__atomic_interlock)) + or.u %r6, %r0, %hi16(__atomic_interlock) + or %r6, %r6, %lo16(__atomic_interlock) ldcr %r7, PSR set %r8, %r7, 1 @@ -157,8 +157,8 @@ GLOBAL(__atomic_lock_88100) * the interlock. */ - or.u %r6, %r0, %hi16(_ASM_LABEL(__atomic_interlock)) - or %r6, %r6, %lo16(_ASM_LABEL(__atomic_interlock)) + or.u %r6, %r0, %hi16(__atomic_interlock) + or %r6, %r6, %lo16(__atomic_interlock) ldcr %r7, PSR set %r8, %r7, 1 diff --git a/sys/arch/m88k/m88k/eh_common.S b/sys/arch/m88k/m88k/eh_common.S index 18219b895d3..5f8bfbd81f7 100644 --- a/sys/arch/m88k/m88k/eh_common.S +++ b/sys/arch/m88k/m88k/eh_common.S @@ -1,4 +1,4 @@ -/* $OpenBSD: eh_common.S,v 1.63 2022/09/04 06:49:11 jsg Exp $ */ +/* $OpenBSD: eh_common.S,v 1.64 2022/12/06 18:50:59 guenther Exp $ */ /* * Mach Operating System * Copyright (c) 1993-1991 Carnegie Mellon University @@ -233,7 +233,7 @@ /* Invoke a C function with 2 arguments */ #define CALL(NAME, ARG1, ARG2) \ or %r2, %r0, ARG1; \ - bsr.n _C_LABEL(NAME); \ + bsr.n NAME; \ or %r3, %r0, ARG2 /* Invoke a function and return elsewhere */ @@ -314,7 +314,7 @@ clr FLAGS, FLAGS, 1 ; \ set FLAGS, FLAGS, 1 ; \ /* get a stack (exception frame) */ \ -1: bsr _ASM_LABEL(m88100_setup_phase_one) ; \ +1: bsr m88100_setup_phase_one ; \ /* TMP2 now free -- use to set EF_VECTOR */ \ or TMP2, %r0, NUM ; \ st TMP2, %r31, EF_VECTOR ; \ @@ -323,7 +323,7 @@ SSBR_STUFF \ /* call setup_phase_two to restart the FPU */ \ /* and to save all general registers. */ \ - bsr _ASM_LABEL(m88100_setup_phase_two) + bsr m88100_setup_phase_two #endif #ifdef M88110 @@ -338,24 +338,24 @@ bb0 PSR_SUPERVISOR_MODE_BIT, %r1, 1f ; \ set FLAGS, FLAGS, 1 ; \ /* get a stack and an exception frame */ ; \ -1: bsr _ASM_LABEL(m88110_setup_phase_one) ; \ +1: bsr m88110_setup_phase_one ; \ /* TMP2 now free -- use to set EF_VECTOR */ ; \ or TMP2, %r0, NUM ; \ /* call setup_phase_two to save all general */ ; \ /* registers. */ ; \ st TMP2, %r30, EF_VECTOR ; \ - bsr _ASM_LABEL(m88110_setup_phase_two) + bsr m88110_setup_phase_two #endif /* Some defines for use with PREP88100() */ #define Clear_SSBR_Dest \ - bsr _ASM_LABEL(clear_dest_ssbr_bit); + bsr clear_dest_ssbr_bit; #define M88100_Data_Precheck \ bb1.n FLAG_IGNORE_DATA_EXCEPTION, FLAGS, \ - _ASM_LABEL(m88100_ignore_data_exception); + m88100_ignore_data_exception; #define M88110_Data_Precheck \ bb1.n FLAG_IGNORE_DATA_EXCEPTION, FLAGS, \ - _ASM_LABEL(m88110_ignore_data_exception); + m88110_ignore_data_exception; #ifdef M88100 /* @@ -367,20 +367,20 @@ GLOBAL(unknown_handler) PREP88100("unknown", 0,,) or %r2, %r0, T_UNKNOWNFLT or %r3, %r0, %r30 - XCALL(_C_LABEL(m88100_trap), _ASM_LABEL(check_ast)) + XCALL(m88100_trap, check_ast) /* interrupt exception handler */ GLOBAL(interrupt_handler) PREP88100("interrupt", 1,,) or %r2, %r0, %r30 - XCALL(_C_LABEL(interrupt), _ASM_LABEL(check_ast)) + XCALL(interrupt, check_ast) /* instruction access exception handler */ GLOBAL(instruction_access_handler) PREP88100("inst", 2,,) or %r2, %r0, T_INSTFLT or %r3, %r0, %r30 - XCALL(_C_LABEL(m88100_trap), _ASM_LABEL(check_ast)) + XCALL(m88100_trap, check_ast) /* * data access exception handler -- @@ -389,25 +389,25 @@ GLOBAL(instruction_access_handler) GLOBAL(data_exception_handler_bootstrap) PREP88100("data", 3,, M88100_Data_Precheck) /* No need to call m88100_trap(T_DATAFLT) as PREP will do this for us */ - br _ASM_LABEL(check_ast) + br check_ast GLOBAL(data_exception_handler) PREP88100("data", 3,,) /* No need to call m88100_trap(T_DATAFLT) as PREP will do this for us */ - br _ASM_LABEL(check_ast) + br check_ast /* misaligned access exception handler */ GLOBAL(misaligned_handler) PREP88100("misalign", 4, Clear_SSBR_Dest,) or %r2, %r0, T_MISALGNFLT or %r3, %r0, %r30 - XCALL(_C_LABEL(m88100_trap), _ASM_LABEL(check_ast)) + XCALL(m88100_trap, check_ast) /* unimplemented opcode exception handler */ GLOBAL(unimplemented_handler) PREP88100("unimp", 5,,) or %r2, %r0, T_ILLFLT or %r3, %r0, %r30 - XCALL(_C_LABEL(m88100_trap), _ASM_LABEL(check_ast)) + XCALL(m88100_trap, check_ast) /* * Some versions of the chip have a bug whereby false privilege @@ -423,96 +423,96 @@ GLOBAL(privilege_handler) 1: PREP88100("privilege", 6, Clear_SSBR_Dest,) or %r2, %r0, T_PRIVINFLT or %r3, %r0, %r30 - XCALL(_C_LABEL(m88100_trap), _ASM_LABEL(check_ast)) + XCALL(m88100_trap, check_ast) /* bounds checking exception handler */ GLOBAL(bounds_handler) PREP88100("bounds", 7, Clear_SSBR_Dest,) or %r2, %r0, T_BNDFLT or %r3, %r0, %r30 - XCALL(_C_LABEL(m88100_trap), _ASM_LABEL(check_ast)) + XCALL(m88100_trap, check_ast) /* integer divide-by-zero exception handler */ GLOBAL(divide_handler) PREP88100("divide", 8, Clear_SSBR_Dest,) or %r2, %r0, T_ZERODIV or %r3, %r0, %r30 - XCALL(_C_LABEL(m88100_trap), _ASM_LABEL(check_ast)) + XCALL(m88100_trap, check_ast) /* integer overflow exception handler */ GLOBAL(overflow_handler) PREP88100("overflow", 9,,) or %r2, %r0, T_OVFFLT or %r3, %r0, %r30 - XCALL(_C_LABEL(m88100_trap), _ASM_LABEL(check_ast)) + XCALL(m88100_trap, check_ast) /* Floating-point precise handler */ #define FPp_SSBR_STUFF \ - bsr _ASM_LABEL(clear_FPp_ssbr_bit); + bsr clear_FPp_ssbr_bit; GLOBAL(fp_precise_handler) PREP88100("FPU precise", 114, FPp_SSBR_STUFF,) or %r2, %r0, T_FPEPFLT or %r3, %r0, %r30 - XCALL(_C_LABEL(m88100_trap), _ASM_LABEL(check_ast)) + XCALL(m88100_trap, check_ast) /* Floating-point imprecise handler */ #define FPi_SSBR_STUFF \ - bsr _ASM_LABEL(clear_FPi_ssbr_bit); + bsr clear_FPi_ssbr_bit; GLOBAL(fp_imprecise_handler) PREP88100("FPU imprecise", 115, FPi_SSBR_STUFF,) or %r2, %r0, T_FPEIFLT or %r3, %r0, %r30 - XCALL(_C_LABEL(m88100_trap), _ASM_LABEL(check_ast)) + XCALL(m88100_trap, check_ast) /* trap 450: system calls */ GLOBAL(syscall_handler) PREP88100("syscall", 450,,) ld %r2, %r30, GENREG_OFF(13) or %r3, %r0, %r30 - XCALL(_C_LABEL(m88100_syscall), _ASM_LABEL(check_ast)) + XCALL(m88100_syscall, check_ast) /* trap 451: cache flush (necessary for trampolines) */ GLOBAL(cache_flush_handler) PREP88100("cache_flush", 451,,) or %r2, %r0, %r30 - XCALL(_C_LABEL(cache_flush), _ASM_LABEL(check_ast)) + XCALL(cache_flush, check_ast) GLOBAL(sigsys) PREP88100("sigsys", 501,,) or %r2, %r0, T_SIGSYS or %r3, %r0, %r30 - XCALL(_C_LABEL(m88100_trap), _ASM_LABEL(check_ast)) + XCALL(m88100_trap, check_ast) GLOBAL(stepbpt) PREP88100("stepbpt", 504,,) or %r2, %r0, T_STEPBPT or %r3, %r0, %r30 - XCALL(_C_LABEL(m88100_trap), _ASM_LABEL(check_ast)) + XCALL(m88100_trap, check_ast) GLOBAL(userbpt) PREP88100("userbpt", 511,,) or %r2, %r0, T_USERBPT or %r3, %r0, %r30 - XCALL(_C_LABEL(m88100_trap), _ASM_LABEL(check_ast)) + XCALL(m88100_trap, check_ast) #ifdef DDB GLOBAL(break) PREP88100("break", 130,,) or %r2, %r0, T_KDB_BREAK or %r3, %r0, %r30 - XCALL(_C_LABEL(m88100_trap), _ASM_LABEL(check_ast)) + XCALL(m88100_trap, check_ast) GLOBAL(trace) PREP88100("trace", 131,,) or %r2, %r0, T_KDB_TRACE or %r3, %r0, %r30 - XCALL(_C_LABEL(m88100_trap), _ASM_LABEL(check_ast)) + XCALL(m88100_trap, check_ast) GLOBAL(entry) PREP88100("kdb", 132,,) or %r2, %r0, T_KDB_ENTRY or %r3, %r0, %r30 - XCALL(_C_LABEL(m88100_trap), _ASM_LABEL(check_ast)) + XCALL(m88100_trap, check_ast) #endif /* @@ -543,13 +543,13 @@ GLOBAL(reset_handler) or %r29, %r0, 0 1: or %r26, %r0, %r31 /* save old stack */ - or.u %r31, %r0, %hi16(_ASM_LABEL(initstack_end)) - or %r31, %r31, %lo16(_ASM_LABEL(initstack_end)) + or.u %r31, %r0, %hi16(initstack_end) + or %r31, %r31, %lo16(initstack_end) #ifdef DEBUG /* zero the stack, so we'll know what we're lookin' at */ - or.u %r27, %r0, %hi16(_ASM_LABEL(initstack)) - or %r27, %r27, %lo16(_ASM_LABEL(initstack)) + or.u %r27, %r0, %hi16(initstack) + or %r27, %r27, %lo16(initstack) 1: cmp %r28, %r27, %r31 bb1 ge, %r28, 2f /* branch if at the end of the stack */ st %r0, %r0, %r27 @@ -651,7 +651,7 @@ GLOBAL(reset_handler) st %r20, %r31, 0x00 #endif - bsr.n _C_LABEL(error_fatal) + bsr.n error_fatal or %r2, %r0, %r30 /* turn interrupts back on */ @@ -689,8 +689,8 @@ ASLOCAL(m88100_ignore_data_exception) */ /* the "+2" below is to set the VALID bit. */ - or.u %r2, %r0, %hi16(_ASM_LABEL(badaddr__return_nonzero) + 2) - or %r2, %r2, %lo16(_ASM_LABEL(badaddr__return_nonzero) + 2) + or.u %r2, %r0, %hi16(badaddr__return_nonzero + 2) + or %r2, %r2, %lo16(badaddr__return_nonzero + 2) stcr %r2, SNIP /* Make it the next instruction to execute */ addu %r2, %r2, 4 stcr %r2, SFIP /* and the next one after that, too. */ @@ -721,8 +721,8 @@ ASLOCAL(m88110_ignore_data_exception) * to blast r2..r9 as we see fit. */ - or.u %r2, %r0, %hi16(_ASM_LABEL(badaddr__return_nonzero)) - or %r2, %r2, %lo16(_ASM_LABEL(badaddr__return_nonzero)) + or.u %r2, %r0, %hi16(badaddr__return_nonzero) + or %r2, %r2, %lo16(badaddr__return_nonzero) stcr %r2, EXIP /* Make it the next instruction to execute */ stcr %r0, DSR /* Clear exception status */ RTE @@ -765,31 +765,31 @@ GLOBAL(badaddr) /* make sure the upper 28 bits of the size are zero... */ ext %r6, %r3, 0<4> - bcnd.n ne0, %r6, _ASM_LABEL(badaddr__return_nonzero) + bcnd.n ne0, %r6, badaddr__return_nonzero stcr %r5, SR1 - or.u %r6, %r0, %hi16(_ASM_LABEL(badaddr_switch)) - or %r6, %r6, %lo16(_ASM_LABEL(badaddr_switch)) + or.u %r6, %r0, %hi16(badaddr_switch) + or %r6, %r6, %lo16(badaddr_switch) lda %r3, %r6[%r3] jmp %r3 ASLOCAL(badaddr_switch) - br _ASM_LABEL(badaddr__return_nonzero) - br _ASM_LABEL(badaddr__b) - br _ASM_LABEL(badaddr__h) - br _ASM_LABEL(badaddr__return_nonzero) - br _ASM_LABEL(badaddr__w) - br _ASM_LABEL(badaddr__return_nonzero) - br _ASM_LABEL(badaddr__return_nonzero) - br _ASM_LABEL(badaddr__return_nonzero) - br _ASM_LABEL(badaddr__d) - br _ASM_LABEL(badaddr__return_nonzero) - br _ASM_LABEL(badaddr__return_nonzero) - br _ASM_LABEL(badaddr__return_nonzero) - br _ASM_LABEL(badaddr__return_nonzero) - br _ASM_LABEL(badaddr__return_nonzero) - br _ASM_LABEL(badaddr__return_nonzero) - br _ASM_LABEL(badaddr__return_nonzero) + br badaddr__return_nonzero + br badaddr__b + br badaddr__h + br badaddr__return_nonzero + br badaddr__w + br badaddr__return_nonzero + br badaddr__return_nonzero + br badaddr__return_nonzero + br badaddr__d + br badaddr__return_nonzero + br badaddr__return_nonzero + br badaddr__return_nonzero + br badaddr__return_nonzero + br badaddr__return_nonzero + br badaddr__return_nonzero + br badaddr__return_nonzero /* * The load attempts below will either fault or not. If they fault, @@ -803,40 +803,40 @@ ASLOCAL(badaddr__b) FLUSH_PIPELINE ld.b %r6, %r2, 0 FLUSH_PIPELINE - br.n _ASM_LABEL(badaddr__return) + br.n badaddr__return or %r2, %r0, %r0 ASLOCAL(badaddr__h) /* It's a bad address if it's misaligned. */ - bb1 0, %r2, _ASM_LABEL(badaddr__return_nonzero) + bb1 0, %r2, badaddr__return_nonzero FLUSH_PIPELINE ld.h %r6, %r2, 0 FLUSH_PIPELINE - br.n _ASM_LABEL(badaddr__return) + br.n badaddr__return or %r2, %r0, %r0 ASLOCAL(badaddr__w) /* It's a bad address if it's misaligned. */ - bb1 0, %r2, _ASM_LABEL(badaddr__return_nonzero) - bb1 1, %r2, _ASM_LABEL(badaddr__return_nonzero) + bb1 0, %r2, badaddr__return_nonzero + bb1 1, %r2, badaddr__return_nonzero FLUSH_PIPELINE ld %r6, %r2, 0 FLUSH_PIPELINE - br.n _ASM_LABEL(badaddr__return) + br.n badaddr__return or %r2, %r0, %r0 /* indicate a zero (address not bad) return.*/ ASLOCAL(badaddr__d) /* It's a bad address if it's misaligned. */ - bb1 0, %r2, _ASM_LABEL(badaddr__return_nonzero) - bb1 1, %r2, _ASM_LABEL(badaddr__return_nonzero) - bb1 2, %r2, _ASM_LABEL(badaddr__return_nonzero) + bb1 0, %r2, badaddr__return_nonzero + bb1 1, %r2, badaddr__return_nonzero + bb1 2, %r2, badaddr__return_nonzero FLUSH_PIPELINE ld.d %r6, %r2, 0 FLUSH_PIPELINE - br.n _ASM_LABEL(badaddr__return) + br.n badaddr__return or %r2, %r0, %r0 /* indicate a zero (address not bad) return.*/ ASLOCAL(badaddr__return_nonzero) @@ -881,9 +881,9 @@ ASLOCAL(m88100_setup_phase_one) NOP NOP - bb1 FLAG_ENABLING_FPU, FLAGS, _ASM_LABEL(m88100_use_SR3_pcb) + bb1 FLAG_ENABLING_FPU, FLAGS, m88100_use_SR3_pcb /* are we coming in from user mode? If so, pick up process pcb */ - bb0 FLAG_FROM_KERNEL, FLAGS, _ASM_LABEL(m88100_pickup_stack) + bb0 FLAG_FROM_KERNEL, FLAGS, m88100_pickup_stack /* Interrupt in kernel mode, not FPU restart */ /* @@ -905,7 +905,7 @@ ASLOCAL(m88100_setup_phase_one) st %r1, %r31, EF_SR3 addu %r1, %r31, TRAPFRAME_SIZEOF /* save previous r31 */ - br.n _ASM_LABEL(m88100_have_pcb) + br.n m88100_have_pcb st %r1, %r31, GENREG_OFF(31) ASLOCAL(m88100_use_SR3_pcb) @@ -944,7 +944,7 @@ ASLOCAL(m88100_use_SR3_pcb) or %r31, %r0, %r30 /* make r31 our pointer. */ addu %r30, %r30, TRAPFRAME_SIZEOF /* r30 now has previous SR3 */ st %r30, %r31, EF_SR3 /* save previous SR3 */ - br.n _ASM_LABEL(m88100_have_pcb) + br.n m88100_have_pcb xcr %r30, %r30, SR3 /* restore r30 */ 1: /* we took an exception while restarting the FPU from user space. @@ -961,7 +961,7 @@ ASLOCAL(m88100_use_SR3_pcb) ld %r1, %r30, GENREG_OFF(0) /* restore old r1 */ st %r0, %r30, GENREG_OFF(0) /* repair that frame */ st %r1, %r31, GENREG_OFF(1) /* store r1 */ - br.n _ASM_LABEL(m88100_have_pcb) + br.n m88100_have_pcb xcr %r30, %r30, SR3 /* restore r30 */ ASLOCAL(m88100_pickup_stack) @@ -1346,8 +1346,8 @@ ASLOCAL(m88100_setup_phase_two) stcr TMP, EPSR /* the "+2" below is to set the VALID_BIT */ - or.u TMP, %r0, %hi16(_ASM_LABEL(m88100_fpu_enable) + 2) - or TMP, TMP, %lo16(_ASM_LABEL(m88100_fpu_enable) + 2) + or.u TMP, %r0, %hi16(m88100_fpu_enable + 2) + or TMP, TMP, %lo16(m88100_fpu_enable + 2) stcr TMP, SNIP addu TMP, TMP, 4 stcr TMP, SFIP @@ -1473,7 +1473,7 @@ ASLOCAL(m88100_fpu_enable) 1: /* get and save IPL */ - bsr _C_LABEL(getipl) + bsr getipl st %r2, %r30, EF_MASK /* @@ -1542,20 +1542,20 @@ GLOBAL(m88110_unknown_handler) PREP88110("unknown", 0,) or %r2, %r0, T_UNKNOWNFLT or %r3, %r0, %r30 - XCALL(_C_LABEL(m88110_trap), _ASM_LABEL(check_ast)) + XCALL(m88110_trap, check_ast) /* interrupt exception handler */ GLOBAL(m88110_interrupt_handler) PREP88110("interrupt", 1,) or %r2, %r0, %r30 - XCALL(_C_LABEL(interrupt), _ASM_LABEL(check_ast)) + XCALL(interrupt, check_ast) /* instruction access exception handler */ GLOBAL(m88110_instruction_access_handler) PREP88110("inst", 2,) or %r2, %r0, T_INSTFLT or %r3, %r0, %r30 - XCALL(_C_LABEL(m88110_trap), _ASM_LABEL(check_ast)) + XCALL(m88110_trap, check_ast) /* * data access exception handler -- * See badaddr() below for info about Data_Precheck. @@ -1564,138 +1564,138 @@ GLOBAL(m88110_data_exception_handler_bootstrap) PREP88110("data", 3, M88110_Data_Precheck) or %r2, %r0, T_DATAFLT or %r3, %r0, %r30 - XCALL(_C_LABEL(m88110_trap), _ASM_LABEL(check_ast)) + XCALL(m88110_trap, check_ast) GLOBAL(m88110_data_exception_handler) PREP88110("data", 3,) or %r2, %r0, T_DATAFLT or %r3, %r0, %r30 - XCALL(_C_LABEL(m88110_trap), _ASM_LABEL(check_ast)) + XCALL(m88110_trap, check_ast) /* misaligned access exception handler */ GLOBAL(m88110_misaligned_handler) PREP88110("misalign", 4,) or %r2, %r0, T_MISALGNFLT or %r3, %r0, %r30 - XCALL(_C_LABEL(m88110_trap), _ASM_LABEL(check_ast)) + XCALL(m88110_trap, check_ast) /* unimplemented opcode exception handler */ GLOBAL(m88110_unimplemented_handler) PREP88110("unimp", 5,) or %r2, %r0, T_ILLFLT or %r3, %r0, %r30 - XCALL(_C_LABEL(m88110_trap), _ASM_LABEL(check_ast)) + XCALL(m88110_trap, check_ast) /* privilege exception handler */ GLOBAL(m88110_privilege_handler) PREP88110("privilege", 6,) or %r2, %r0, T_PRIVINFLT or %r3, %r0, %r30 - XCALL(_C_LABEL(m88110_trap), _ASM_LABEL(check_ast)) + XCALL(m88110_trap, check_ast) /* bounds checking exception handler */ GLOBAL(m88110_bounds_handler) PREP88110("bounds", 7,) or %r2, %r0, T_BNDFLT or %r3, %r0, %r30 - XCALL(_C_LABEL(m88110_trap), _ASM_LABEL(check_ast)) + XCALL(m88110_trap, check_ast) /* integer divide-by-zero exception handler */ GLOBAL(m88110_divide_handler) PREP88110("divide", 8,) or %r2, %r0, T_ZERODIV or %r3, %r0, %r30 - XCALL(_C_LABEL(m88110_trap), _ASM_LABEL(check_ast)) + XCALL(m88110_trap, check_ast) /* integer overflow exception handler */ GLOBAL(m88110_overflow_handler) PREP88110("overflow", 9,) or %r2, %r0, T_OVFFLT or %r3, %r0, %r30 - XCALL(_C_LABEL(m88110_trap), _ASM_LABEL(check_ast)) + XCALL(m88110_trap, check_ast) /* Floating-point precise handler */ GLOBAL(m88110_fpu_handler) PREP88110("FPU", 114,) or %r2, %r0, T_FPEPFLT or %r3, %r0, %r30 - XCALL(_C_LABEL(m88110_trap), _ASM_LABEL(check_ast)) + XCALL(m88110_trap, check_ast) /* non-maskable interrupt handler (IPIs, ABORT button) */ GLOBAL(m88110_nonmaskable) PREP88110("NMI", 11,) or %r2, %r0, %r30 - XCALL(_C_LABEL(nmi), _ASM_LABEL(nmi_return)) + XCALL(nmi, nmi_return) /* software walk data MMU read miss handler */ GLOBAL(m88110_data_read_miss) PREP88110("88110 data read miss", 12,) or %r2, %r0, T_110_DRM or %r3, %r0, %r30 - XCALL(_C_LABEL(m88110_trap), _ASM_LABEL(check_ast)) + XCALL(m88110_trap, check_ast) /* software walk data MMU write miss handler */ GLOBAL(m88110_data_write_miss) PREP88110("88110 data write miss", 13,) or %r2, %r0, T_110_DWM or %r3, %r0, %r30 - XCALL(_C_LABEL(m88110_trap), _ASM_LABEL(check_ast)) + XCALL(m88110_trap, check_ast) /* software walk inst MMU ATC miss handler */ GLOBAL(m88110_inst_atc_miss) PREP88110("88110 inst ATC miss", 14,) or %r2, %r0, T_110_IAM or %r3, %r0, %r30 - XCALL(_C_LABEL(m88110_trap), _ASM_LABEL(check_ast)) + XCALL(m88110_trap, check_ast) /* trap 450: system calls */ GLOBAL(m88110_syscall_handler) PREP88110("syscall", 450,) ld %r2, %r30, GENREG_OFF(13) or %r3, %r0, %r30 - XCALL(_C_LABEL(m88110_syscall), _ASM_LABEL(check_ast)) + XCALL(m88110_syscall, check_ast) /* trap 451: cache flush (necessary for trampolines) */ GLOBAL(m88110_cache_flush_handler) PREP88110("cache_flush", 451,) or %r2, %r0, %r30 - XCALL(_C_LABEL(cache_flush), _ASM_LABEL(check_ast)) + XCALL(cache_flush, check_ast) GLOBAL(m88110_sigsys) PREP88110("sigsys", 501,) or %r2, %r0, T_SIGSYS or %r3, %r0, %r30 - XCALL(_C_LABEL(m88110_trap), _ASM_LABEL(check_ast)) + XCALL(m88110_trap, check_ast) GLOBAL(m88110_stepbpt) PREP88110("stepbpt", 504,) or %r2, %r0, T_STEPBPT or %r3, %r0, %r30 - XCALL(_C_LABEL(m88110_trap), _ASM_LABEL(check_ast)) + XCALL(m88110_trap, check_ast) GLOBAL(m88110_userbpt) PREP88110("userbpt", 511,) or %r2, %r0, T_USERBPT or %r3, %r0, %r30 - XCALL(_C_LABEL(m88110_trap), _ASM_LABEL(check_ast)) + XCALL(m88110_trap, check_ast) #ifdef DDB GLOBAL(m88110_break) PREP88110("break", 130,) or %r2, %r0, T_KDB_BREAK or %r3, %r0, %r30 - XCALL(_C_LABEL(m88110_trap), _ASM_LABEL(check_ast)) + XCALL(m88110_trap, check_ast) GLOBAL(m88110_trace) PREP88110("trace", 131,) or %r2, %r0, T_KDB_TRACE or %r3, %r0, %r30 - XCALL(_C_LABEL(m88110_trap), _ASM_LABEL(check_ast)) + XCALL(m88110_trap, check_ast) GLOBAL(m88110_entry) PREP88110("kdb", 132,) or %r2, %r0, T_KDB_ENTRY or %r3, %r0, %r30 - XCALL(_C_LABEL(m88110_trap), _ASM_LABEL(check_ast)) + XCALL(m88110_trap, check_ast) #endif /* @@ -1724,13 +1724,13 @@ GLOBAL(m88110_reset_handler) or %r29, %r0, 0 1: or %r26, %r0, %r31 /* save old stack */ - or.u %r31, %r0, %hi16(_ASM_LABEL(initstack_end)) - or %r31, %r31, %lo16(_ASM_LABEL(initstack_end)) + or.u %r31, %r0, %hi16(initstack_end) + or %r31, %r31, %lo16(initstack_end) #ifdef DEBUG /* zero the stack, so we'll know what we're lookin' at */ - or.u %r27, %r0, %hi16(_ASM_LABEL(initstack)) - or %r27, %r27, %lo16(_ASM_LABEL(initstack)) + or.u %r27, %r0, %hi16(initstack) + or %r27, %r27, %lo16(initstack) 1: cmp %r28, %r27, %r31 bb1 ge, %r28, 2f /* branch if at the end of the stack */ st %r0, %r0, %r27 @@ -1818,7 +1818,7 @@ GLOBAL(m88110_reset_handler) #endif or %r2, %r0, %r30 - bsr _C_LABEL(error_fatal) + bsr error_fatal /* turn interrupts back on */ ldcr %r1, PSR @@ -1876,7 +1876,7 @@ ASLOCAL(m88110_setup_phase_one) * with interrupts disabled, and we won't check for AST or soft * interrupts before returning to the cpu_switchto kernel code. */ - bb1 FLAG_FROM_KERNEL, FLAGS, _ASM_LABEL(m88110_kernel_stack) + bb1 FLAG_FROM_KERNEL, FLAGS, m88110_kernel_stack /* * Otherwise, this is an exception in user mode, we'll use the PCB @@ -1900,7 +1900,7 @@ ASLOCAL(m88110_setup_phase_one) ld %r31, %r1, CI_CURPCB addu %r31, %r31, USPACE - br _ASM_LABEL(m88110_have_stack) + br m88110_have_stack ASLOCAL(m88110_kernel_stack) /* Exception in kernel mode */ @@ -2009,8 +2009,8 @@ ASLOCAL(m88110_setup_phase_two) clr TMP, TMP, 1 /* enable shadowing */ stcr TMP, EPSR - or.u TMP, %r0, %hi16(_ASM_LABEL(m88110_shadow_enable)) - or TMP, TMP, %lo16(_ASM_LABEL(m88110_shadow_enable)) + or.u TMP, %r0, %hi16(m88110_shadow_enable) + or TMP, TMP, %lo16(m88110_shadow_enable) stcr TMP, EXIP xcr FLAGS,FLAGS,SR1 @@ -2097,7 +2097,7 @@ ASLOCAL(m88110_shadow_enable) */ /* get and save IPL */ - bsr _C_LABEL(getipl) + bsr getipl st %r2, %r30, EF_MASK subu %r31, %r31, 8 /* make some breathing space */ @@ -2160,10 +2160,10 @@ ASGLOBAL(check_ast) /* do not service AST and soft interrupts if interrupts were disabled */ ld %r2, FPTR, EF_EPSR - bb1 PSR_INTERRUPT_DISABLE_BIT, %r2, _ASM_LABEL(ast_done) + bb1 PSR_INTERRUPT_DISABLE_BIT, %r2, ast_done /* ...or we were not at spl0 */ ld %r2, FPTR, EF_MASK - bcnd ne0, %r2, _ASM_LABEL(ast_done) + bcnd ne0, %r2, ast_done #ifdef MULTIPROCESSOR /* @@ -2173,9 +2173,9 @@ ASGLOBAL(check_ast) or %r15, %r0, %r0 addu %r3, %r3, CI_SOFTIPI_CB xmem %r15, %r3, %r0 - bcnd eq0, %r15, _ASM_LABEL(do_softint) + bcnd eq0, %r15, do_softint - bsr.n _C_LABEL(setipl) + bsr.n setipl or %r2, %r0, IPL_NONE jsr %r15 @@ -2185,18 +2185,18 @@ ASLOCAL(do_softint) /* * Process soft interrupts, if any. */ - bsr _C_LABEL(spl0) + bsr spl0 /* do not service AST if not returning to user mode */ ld %r2, FPTR, EF_EPSR - bb1 PSR_SUPERVISOR_MODE_BIT, %r2, _ASM_LABEL(ast_done) + bb1 PSR_SUPERVISOR_MODE_BIT, %r2, ast_done 1: ldcr %r2, CPU ld %r3, %r2, CI_CURPROC ld %r2, %r3, P_ASTPENDING - bcnd eq0, %r2, _ASM_LABEL(ast_done) + bcnd eq0, %r2, ast_done - bsr.n _C_LABEL(ast) + bsr.n ast or %r2, %r0, FPTR br 1b @@ -2212,10 +2212,10 @@ ASLOCAL(do_softint) ENTRY(proc_trampoline) #ifdef MULTIPROCESSOR - bsr _C_LABEL(proc_trampoline_mp) + bsr proc_trampoline_mp #endif - bsr.n _C_LABEL(setipl) /* setipl(IPL_NONE) */ + bsr.n setipl /* setipl(IPL_NONE) */ or %r2, %r0, %r0 ld %r1, %r31, 0 /* load func */ @@ -2245,13 +2245,13 @@ ASGLOBAL(ast_done) FLUSH_PIPELINE /* now ready to return....*/ - bsr.n _C_LABEL(setipl) + bsr.n setipl ld %r2, FPTR, EF_MASK /* get pre-exception ipl */ #if defined(M88100) && defined(M88110) ldcr %r2, PID extu %r3, %r2, 8<8> - bcnd ne0, %r3, _ASM_LABEL(m88110_user_rte) + bcnd ne0, %r3, m88110_user_rte /* FALLTHROUGH */ #endif @@ -2411,7 +2411,7 @@ ASLOCAL(m88110_restore) * or not. */ ASLOCAL(nmi_return) - bcnd ne0, %r2, _ASM_LABEL(check_ast) + bcnd ne0, %r2, check_ast ld FPTR, %r31, 0 /* grab exception frame pointer */ @@ -2428,7 +2428,7 @@ ASLOCAL(nmi_return) FLUSH_PIPELINE /* now ready to return....*/ - bsr.n _C_LABEL(setipl) + bsr.n setipl ld %r2, FPTR, EF_MASK /* get pre-exception ipl */ #ifdef MULTIPROCESSOR @@ -2436,8 +2436,8 @@ ASLOCAL(nmi_return) * Reenable NMIs if necessary. */ or %r2, FPTR, %r0 - bsr _C_LABEL(nmi_wrapup) + bsr nmi_wrapup #endif - br _ASM_LABEL(m88110_restore) + br m88110_restore #endif diff --git a/sys/arch/m88k/m88k/process.S b/sys/arch/m88k/m88k/process.S index 245691b27cc..ef97b19e4ea 100644 --- a/sys/arch/m88k/m88k/process.S +++ b/sys/arch/m88k/m88k/process.S @@ -1,4 +1,4 @@ -/* $OpenBSD: process.S,v 1.26 2013/05/17 22:35:19 miod Exp $ */ +/* $OpenBSD: process.S,v 1.27 2022/12/06 18:50:59 guenther Exp $ */ /* * Copyright (c) 1996 Nivas Madhur * All rights reserved. @@ -51,7 +51,7 @@ ENTRY(cpu_switchto) ldcr %r2, CPU ld %r2, %r2, CI_CURPCB st %r1, %r2, PCB_PC /* save return address */ - bsr _ASM_LABEL(__savectx) + bsr __savectx /* note that we don't need to recover r1 at this point */ /* inline pmap_deactivate(oldproc) */ @@ -75,7 +75,7 @@ ENTRY(cpu_switchto) ld %r2, %r3, P_ADDR st %r2, %r11, CI_CURPCB /* curpcb = p->p_addr */ - bsr.n _C_LABEL(pmap_activate) /* pmap_activate(newproc) */ + bsr.n pmap_activate /* pmap_activate(newproc) */ or %r2, %r0, %r3 ldcr %r2, PSR diff --git a/sys/arch/m88k/m88k/subr.S b/sys/arch/m88k/m88k/subr.S index fceab377bd3..b209a8fd9e8 100644 --- a/sys/arch/m88k/m88k/subr.S +++ b/sys/arch/m88k/m88k/subr.S @@ -1,4 +1,4 @@ -/* $OpenBSD: subr.S,v 1.27 2017/05/29 06:06:52 mpi Exp $ */ +/* $OpenBSD: subr.S,v 1.28 2022/12/06 18:50:59 guenther Exp $ */ /* * Mach Operating System * Copyright (c) 1993-1992 Carnegie Mellon University @@ -199,8 +199,8 @@ ENTRY(copyin) /* set up fault handler */ ldcr %r5, CPU ld %r6, %r5, CI_CURPCB - or.u %r5, %r0, %hi16(_ASM_LABEL(Lciflt)) - or %r5, %r5, %lo16(_ASM_LABEL(Lciflt)) + or.u %r5, %r0, %hi16(Lciflt) + or %r5, %r5, %lo16(Lciflt) st %r5, %r6, PCB_ONFAULT /* pcb_onfault = Lciflt */ /* @@ -210,25 +210,25 @@ ENTRY(copyin) * to save an hyperthetical fraction of cycle. */ cmp %r9, LEN, 8 - bb1 lt, %r9, _ASM_LABEL(copyin_byte_only) + bb1 lt, %r9, copyin_byte_only /* If they're not aligned similarly, use byte only... */ xor %r9, SRC, DEST mask %r8, %r9, 0x3 - bcnd ne0, %r8, _ASM_LABEL(copyin_byte_only) + bcnd ne0, %r8, copyin_byte_only /* * At this point, we don't know if they're word aligned or not, * but we know that what needs to be done to one to align * it is what's needed for the other. */ - bb1 0, SRC, _ASM_LABEL(copyin_left_align_to_halfword) + bb1 0, SRC, copyin_left_align_to_halfword ASLOCAL(copyin_left_aligned_to_halfword) - bb1 1, SRC, _ASM_LABEL(copyin_left_align_to_word) + bb1 1, SRC, copyin_left_align_to_word ASLOCAL(copyin_left_aligned_to_word) - bb1 0, LEN, _ASM_LABEL(copyin_right_align_to_halfword) + bb1 0, LEN, copyin_right_align_to_halfword ASLOCAL(copyin_right_aligned_to_halfword) - bb1 1, LEN, _ASM_LABEL(copyin_right_align_to_word) + bb1 1, LEN, copyin_right_align_to_word ASLOCAL(copyin_right_aligned_to_word) /* @@ -236,7 +236,7 @@ ASLOCAL(copyin_right_aligned_to_word) * boundary, and LEN is a multiple of 4. We want it an even * multiple of 4. */ - bb1.n 2, LEN, _ASM_LABEL(copyin_right_align_to_doubleword) + bb1.n 2, LEN, copyin_right_align_to_doubleword or %r7, %r0, 4 ASLOCAL(copyin_right_aligned_to_doubleword) @@ -258,9 +258,9 @@ ASLOCAL(copyin_right_aligned_to_doubleword) st %r5, DEST, %r0 addu SRC, SRC, 8 st %r6, DEST, %r7 - bcnd.n ne0, LEN, _ASM_LABEL(copyin_right_aligned_to_doubleword) + bcnd.n ne0, LEN, copyin_right_aligned_to_doubleword addu DEST, DEST, 8 - br.n _ASM_LABEL(Lcidone) + br.n Lcidone or %r2, %r0, %r0 /* successful return */ ASLOCAL(copyin_left_align_to_halfword) @@ -276,7 +276,7 @@ ASLOCAL(copyin_left_align_to_halfword) subu LEN, LEN, 1 st.b %r5, DEST, %r0 addu SRC, SRC, 1 - br.n _ASM_LABEL(copyin_left_aligned_to_halfword) + br.n copyin_left_aligned_to_halfword addu DEST, DEST, 1 ASLOCAL(copyin_left_align_to_word) @@ -292,7 +292,7 @@ ASLOCAL(copyin_left_align_to_word) subu LEN, LEN, 2 st.h %r5, DEST, %r0 addu SRC, SRC, 2 - br.n _ASM_LABEL(copyin_left_aligned_to_word) + br.n copyin_left_aligned_to_word addu DEST, DEST, 2 ASLOCAL(copyin_right_align_to_halfword) @@ -306,7 +306,7 @@ ASLOCAL(copyin_right_align_to_halfword) #else ld.b.usr %r5, SRC, LEN #endif - br.n _ASM_LABEL(copyin_right_aligned_to_halfword) + br.n copyin_right_aligned_to_halfword st.b %r5, DEST, LEN ASLOCAL(copyin_right_align_to_word) @@ -320,7 +320,7 @@ ASLOCAL(copyin_right_align_to_word) #else ld.h.usr %r5, SRC, LEN #endif - br.n _ASM_LABEL(copyin_right_aligned_to_word) + br.n copyin_right_aligned_to_word st.h %r5, DEST, LEN ASLOCAL(copyin_right_align_to_doubleword) @@ -334,9 +334,9 @@ ASLOCAL(copyin_right_align_to_doubleword) #else ld.usr %r5, SRC, LEN #endif - bcnd.n ne0, LEN, _ASM_LABEL(copyin_right_aligned_to_doubleword) + bcnd.n ne0, LEN, copyin_right_aligned_to_doubleword st %r5, DEST, LEN - br.n _ASM_LABEL(Lcidone) + br.n Lcidone or %r2, %r0, %r0 /* successful return */ ASLOCAL(copyin_byte_only) @@ -365,7 +365,7 @@ ASLOCAL(Lcidone) st %r0, %r6, PCB_ONFAULT ASLOCAL(Lciflt) - br.n _ASM_LABEL(Lcidone) + br.n Lcidone or %r2, %r0, EFAULT /* return fault */ #undef SRC @@ -385,13 +385,13 @@ ASLOCAL(Lciflt) ENTRY(copyin32) /* check for source alignment */ mask %r8, SRC, 0x3 - bcnd ne0, %r8, _ASM_LABEL(copyin32_misaligned) + bcnd ne0, %r8, copyin32_misaligned /* set up fault handler */ ldcr %r5, CPU ld %r6, %r5, CI_CURPCB - or.u %r5, %r0, %hi16(_ASM_LABEL(Lciflt)) - or %r5, %r5, %lo16(_ASM_LABEL(Lciflt)) + or.u %r5, %r0, %hi16(Lciflt) + or %r5, %r5, %lo16(Lciflt) st %r5, %r6, PCB_ONFAULT /* pcb_onfault = Lciflt */ #ifdef ERRATA__XXX_USR @@ -404,7 +404,7 @@ ENTRY(copyin32) ld.usr %r5, SRC, %r0 #endif st %r5, DEST, %r0 - br.n _ASM_LABEL(Lcidone) + br.n Lcidone or %r2, %r0, %r0 /* successful return */ ASLOCAL(copyin32_misaligned) @@ -438,12 +438,12 @@ ENTRY(copyinstr) /* setup fault handler */ ldcr %r6, CPU ld %r7, %r6, CI_CURPCB - or.u %r6, %r0, %hi16(_ASM_LABEL(Lcisflt)) - or %r6, %r6, %lo16(_ASM_LABEL(Lcisflt)) + or.u %r6, %r0, %hi16(Lcisflt) + or %r6, %r6, %lo16(Lcisflt) st %r6, %r7, PCB_ONFAULT or %r6, %r0, 0 - bcnd lt0, CNT, _ASM_LABEL(Lcisflt) - bcnd eq0, CNT, _ASM_LABEL(Lcistoolong) + bcnd lt0, CNT, Lcisflt + bcnd eq0, CNT, Lcistoolong 1: #ifdef ERRATA__XXX_USR NOP @@ -464,11 +464,11 @@ ASLOCAL(Lcistoolong) or %r2, %r0, ENAMETOOLONG /* overflow */ ASLOCAL(Lcisnull) - bcnd eq0,%r6, _ASM_LABEL(Lcisdone) /* do not attempt to clear last byte */ + bcnd eq0,%r6, Lcisdone /* do not attempt to clear last byte */ /* if we did not write to the string */ subu %r6, %r6, 1 st.b %r0, DEST, %r6 /* clear last byte */ - br.n _ASM_LABEL(Lcisdone) + br.n Lcisdone addu %r6, %r6, 1 2: /* all done */ or %r2, %r0, 0 @@ -483,7 +483,7 @@ ASLOCAL(Lcisdone) st %r0, %r6, PCB_ONFAULT /* clear the handler */ ASLOCAL(Lcisflt) - br.n _ASM_LABEL(Lcisnull) + br.n Lcisnull or %r2, %r0, EFAULT /* return fault */ #undef SRC @@ -507,8 +507,8 @@ ENTRY(copyout) /* setup fault handler */ ldcr %r5, CPU ld %r6, %r5, CI_CURPCB - or.u %r5, %r0, %hi16(_ASM_LABEL(Lcoflt)) - or %r5, %r5, %lo16(_ASM_LABEL(Lcoflt)) + or.u %r5, %r0, %hi16(Lcoflt) + or %r5, %r5, %lo16(Lcoflt) st %r5, %r6, PCB_ONFAULT /* pcb_onfault = Lcoflt */ /* @@ -518,25 +518,25 @@ ENTRY(copyout) * to save an hyperthetical fraction of cycle. */ cmp %r9, LEN, 8 - bb1 lt, %r9, _ASM_LABEL(copyout_byte_only) + bb1 lt, %r9, copyout_byte_only /* If they're not aligned similarly, use byte only... */ xor %r9, SRC, DEST mask %r8, %r9, 0x3 - bcnd ne0, %r8, _ASM_LABEL(copyout_byte_only) + bcnd ne0, %r8, copyout_byte_only /* * At this point, we don't know if they're word aligned or not, * but we know that what needs to be done to one to align * it is what's needed for the other. */ - bb1 0, SRC, _ASM_LABEL(copyout_left_align_to_halfword) + bb1 0, SRC, copyout_left_align_to_halfword ASLOCAL(copyout_left_aligned_to_halfword) - bb1 1, SRC, _ASM_LABEL(copyout_left_align_to_word) + bb1 1, SRC, copyout_left_align_to_word ASLOCAL(copyout_left_aligned_to_word) - bb1 0, LEN, _ASM_LABEL(copyout_right_align_to_halfword) + bb1 0, LEN, copyout_right_align_to_halfword ASLOCAL(copyout_right_aligned_to_halfword) - bb1 1, LEN, _ASM_LABEL(copyout_right_align_to_word) + bb1 1, LEN, copyout_right_align_to_word ASLOCAL(copyout_right_aligned_to_word) /* @@ -544,7 +544,7 @@ ASLOCAL(copyout_right_aligned_to_word) * boundary, and LEN is a multiple of 4. We want it an even * multiple of 4. */ - bb1.n 2, LEN, _ASM_LABEL(copyout_right_align_to_doubleword) + bb1.n 2, LEN, copyout_right_align_to_doubleword or %r7, %r0, 4 ASLOCAL(copyout_right_aligned_to_doubleword) @@ -570,10 +570,10 @@ ASLOCAL(copyout_right_aligned_to_doubleword) #else st.usr %r6, DEST, %r7 #endif - bcnd.n ne0, LEN, _ASM_LABEL(copyout_right_aligned_to_doubleword) + bcnd.n ne0, LEN, copyout_right_aligned_to_doubleword addu DEST, DEST, 8 or %r2, %r0, %r0 /* successful return */ - br _ASM_LABEL(Lcodone) + br Lcodone /***************************************************/ ASLOCAL(copyout_left_align_to_halfword) @@ -589,7 +589,7 @@ ASLOCAL(copyout_left_align_to_halfword) st.b.usr %r5, DEST, %r0 #endif addu SRC, SRC, 1 - br.n _ASM_LABEL(copyout_left_aligned_to_halfword) + br.n copyout_left_aligned_to_halfword addu DEST, DEST, 1 ASLOCAL(copyout_left_align_to_word) @@ -605,7 +605,7 @@ ASLOCAL(copyout_left_align_to_word) st.h.usr %r5, DEST, %r0 #endif addu SRC, SRC, 2 - br.n _ASM_LABEL(copyout_left_aligned_to_word) + br.n copyout_left_aligned_to_word addu DEST, DEST, 2 ASLOCAL(copyout_right_align_to_halfword) @@ -617,9 +617,9 @@ ASLOCAL(copyout_right_align_to_halfword) NOP NOP NOP - br _ASM_LABEL(copyout_right_aligned_to_halfword) + br copyout_right_aligned_to_halfword #else - br.n _ASM_LABEL(copyout_right_aligned_to_halfword) + br.n copyout_right_aligned_to_halfword st.b.usr %r5, DEST, LEN #endif @@ -632,9 +632,9 @@ ASLOCAL(copyout_right_align_to_word) NOP NOP NOP - br _ASM_LABEL(copyout_right_aligned_to_word) + br copyout_right_aligned_to_word #else - br.n _ASM_LABEL(copyout_right_aligned_to_word) + br.n copyout_right_aligned_to_word st.h.usr %r5, DEST, LEN #endif @@ -647,12 +647,12 @@ ASLOCAL(copyout_right_align_to_doubleword) NOP NOP NOP - bcnd ne0, LEN, _ASM_LABEL(copyout_right_aligned_to_doubleword) + bcnd ne0, LEN, copyout_right_aligned_to_doubleword #else - bcnd.n ne0, LEN, _ASM_LABEL(copyout_right_aligned_to_doubleword) + bcnd.n ne0, LEN, copyout_right_aligned_to_doubleword st.usr %r5, DEST, LEN #endif - br.n _ASM_LABEL(Lcodone) + br.n Lcodone or %r2, %r0, %r0 /* successful return */ ASLOCAL(copyout_byte_only) @@ -683,7 +683,7 @@ ASLOCAL(Lcodone) st %r0, %r6, PCB_ONFAULT /* clear the handler */ ASLOCAL(Lcoflt) - br.n _ASM_LABEL(Lcodone) + br.n Lcodone or %r2, %r0, EFAULT /* return fault */ #undef SRC @@ -710,11 +710,11 @@ ENTRY(copyoutstr) /* setup fault handler */ ldcr %r6, CPU ld %r7, %r6, CI_CURPCB - or.u %r6, %r0, %hi16(_ASM_LABEL(Lcosflt)) - or %r6, %r6, %lo16(_ASM_LABEL(Lcosflt)) + or.u %r6, %r0, %hi16(Lcosflt) + or %r6, %r6, %lo16(Lcosflt) st %r6, %r7, PCB_ONFAULT - bcnd lt0, CNT, _ASM_LABEL(Lcosflt) - bcnd eq0, CNT, _ASM_LABEL(Lcosdone) + bcnd lt0, CNT, Lcosflt + bcnd eq0, CNT, Lcosdone or %r6, %r0, 0 1: ld.bu %r7, SRC, %r6 @@ -731,14 +731,14 @@ ENTRY(copyoutstr) addu %r6, %r6, 1 cmp %r7, %r6, CNT bb1 lt, %r7, 1b - br.n _ASM_LABEL(Lcosdone) + br.n Lcosdone or %r2, %r0, ENAMETOOLONG 2: - br.n _ASM_LABEL(Lcosdone) + br.n Lcosdone or %r2, %r0, 0 ASLOCAL(Lcosflt) - br.n _ASM_LABEL(Lcosdone) + br.n Lcosdone or %r2, %r0, EFAULT ASLOCAL(Lcosdone) @@ -766,23 +766,23 @@ ENTRY(kcopy) subu %r31, %r31, 16 ldcr %r5, CPU ld %r6, %r5, CI_CURPCB - or.u %r5, %r0, %hi16(_ASM_LABEL(kcopy_fault)) + or.u %r5, %r0, %hi16(kcopy_fault) ld %r7, %r6, PCB_ONFAULT - or %r5, %r5, %lo16(_ASM_LABEL(kcopy_fault)) + or %r5, %r5, %lo16(kcopy_fault) st %r7, %r31, 0 /* save old pcb_onfault */ st %r5, %r6, PCB_ONFAULT /* pcb_onfault = kcopy_fault */ - bcnd le0, %r4, _ASM_LABEL(kcopy_out) /* nothing to do if <= 0 */ + bcnd le0, %r4, kcopy_out /* nothing to do if <= 0 */ /* * check position of source and destination data */ cmp %r9, %r2, %r3 /* compare source address to destination */ - bb1 eq, %r9, _ASM_LABEL(kcopy_out) /* nothing to do if equal */ - bb1 lo, %r9, _ASM_LABEL(kcopy_reverse) /* reverse copy if src < dest */ + bb1 eq, %r9, kcopy_out /* nothing to do if equal */ + bb1 lo, %r9, kcopy_reverse /* reverse copy if src < dest */ /* * source address is greater than destination address, copy forward */ cmp %r9, %r4, 16 /* see if we have at least 16 bytes */ - bb1 lt, %r9, _ASM_LABEL(kf_byte_copy) /* copy bytes for small length */ + bb1 lt, %r9, kf_byte_copy /* copy bytes for small length */ /* * determine copy strategy based on alignment of source and destination */ @@ -790,8 +790,8 @@ ENTRY(kcopy) mask %r7, %r3, 3 /* get 2 low order bits of destination addr */ mak %r6, %r6, 0<4>/* convert source bits to table offset */ mak %r7, %r7, 0<2>/* convert destination bits to table offset */ - or.u %r12, %r0, %hi16(_ASM_LABEL(kf_strat)) - or %r12, %r12, %lo16(_ASM_LABEL(kf_strat)) + or.u %r12, %r0, %hi16(kf_strat) + or %r12, %r12, %lo16(kf_strat) addu %r6, %r6, %r7 /* compute final table offset for strategy */ ld %r12, %r12, %r6 /* load the strategy routine */ jmp %r12 /* branch to strategy routine */ @@ -808,7 +808,7 @@ ASLOCAL(kf_3byte_word_copy) st.b %r8, %r3, 2 /* store byte to destination */ addu %r2, %r2, 3 /* increment source pointer */ addu %r3, %r3, 3 /* increment destination pointer */ - br.n _ASM_LABEL(kf_word_copy)/* copy full words */ + br.n kf_word_copy/* copy full words */ subu %r4, %r4, 3 /* decrement length */ /* @@ -819,7 +819,7 @@ ASLOCAL(kf_1half_word_copy) st.h %r6, %r3, 0 /* store half-word to destination */ addu %r2, %r2, 2 /* increment source pointer */ addu %r3, %r3, 2 /* increment destination pointer */ - br.n _ASM_LABEL(kf_word_copy)/* copy full words */ + br.n kf_word_copy/* copy full words */ subu %r4, %r4, 2 /* decrement remaining length */ /* @@ -837,7 +837,7 @@ ASLOCAL(kf_1byte_word_copy) */ ASLOCAL(kf_word_copy) cmp %r10, %r4, 16 /* see if we have 16 bytes remaining */ - bb1 lo, %r10, _ASM_LABEL(kf_byte_copy) /* not enough left, copy bytes */ + bb1 lo, %r10, kf_byte_copy /* not enough left, copy bytes */ ld %r6, %r2, 0 /* load first word */ ld %r7, %r2, 4 /* load second word */ ld %r8, %r2, 8 /* load third word */ @@ -848,7 +848,7 @@ ASLOCAL(kf_word_copy) st %r9, %r3, 12 /* store fourth word */ addu %r2, %r2, 16 /* increment source pointer */ addu %r3, %r3, 16 /* increment destination pointer */ - br.n _ASM_LABEL(kf_word_copy)/* copy another block */ + br.n kf_word_copy/* copy another block */ subu %r4, %r4, 16 /* decrement remaining length */ ASLOCAL(kf_1byte_half_copy) @@ -861,7 +861,7 @@ ASLOCAL(kf_1byte_half_copy) ASLOCAL(kf_half_copy) cmp %r10, %r4, 16 /* see if we have 16 bytes remaining */ - bb1 lo, %r10, _ASM_LABEL(kf_byte_copy) /* not enough left, copy bytes */ + bb1 lo, %r10, kf_byte_copy /* not enough left, copy bytes */ ld.hu %r6, %r2, 0 /* load first half-word */ ld.hu %r7, %r2, 2 /* load second half-word */ ld.hu %r8, %r2, 4 /* load third half-word */ @@ -880,16 +880,16 @@ ASLOCAL(kf_half_copy) st.h %r13, %r3, 14 /* store eighth half-word */ addu %r2, %r2, 16 /* increment source pointer */ addu %r3, %r3, 16 /* increment destination pointer */ - br.n _ASM_LABEL(kf_half_copy)/* copy another block */ + br.n kf_half_copy/* copy another block */ subu %r4, %r4, 16 /* decrement remaining length */ ASLOCAL(kf_byte_copy) - bcnd eq0, %r4, _ASM_LABEL(kcopy_out) /* branch if nothing left to copy */ + bcnd eq0, %r4, kcopy_out /* branch if nothing left to copy */ ld.bu %r6, %r2, 0 /* load byte from source */ st.b %r6, %r3, 0 /* store byte in destination */ addu %r2, %r2, 1 /* increment source pointer */ addu %r3, %r3, 1 /* increment destination pointer */ - br.n _ASM_LABEL(kf_byte_copy)/* branch for next byte */ + br.n kf_byte_copy/* branch for next byte */ subu %r4, %r4, 1 /* decrement remaining length */ /* @@ -905,7 +905,7 @@ ASLOCAL(kcopy_reverse) * check for short data */ cmp %r9, %r4, 16 /* see if we have at least 16 bytes */ - bb1 lt, %r9, _ASM_LABEL(kr_byte_copy) /* copy bytes for small data length */ + bb1 lt, %r9, kr_byte_copy /* copy bytes for small data length */ /* * determine copy strategy based on alignment of source and destination */ @@ -913,8 +913,8 @@ ASLOCAL(kcopy_reverse) mask %r7, %r3, 3 /* get 2 low order bits of destination addr */ mak %r6, %r6, 0<4>/* convert source bits to table offset */ mak %r7, %r7, 0<2>/* convert destination bits to table offset */ - or.u %r12, %r0, %hi16(_ASM_LABEL(kr_strat)) - or %r12, %r12, %lo16(_ASM_LABEL(kr_strat)) + or.u %r12, %r0, %hi16(kr_strat) + or %r12, %r12, %lo16(kr_strat) addu %r6, %r6, %r7 /* compute final table offset for strategy */ ld %r12, %r12, %r6 /* load the strategy routine */ jmp %r12 /* branch to strategy routine */ @@ -931,7 +931,7 @@ ASLOCAL(kr_3byte_word_copy) st.b %r6, %r3, 0 /* store byte to destination */ st.b %r7, %r3, 1 /* store byte to destination */ st.b %r8, %r3, 2 /* store byte to destination */ - br.n _ASM_LABEL(kr_word_copy)/* copy full words */ + br.n kr_word_copy/* copy full words */ subu %r4, %r4, 3 /* decrement length */ /* @@ -942,7 +942,7 @@ ASLOCAL(kr_1half_word_copy) subu %r3, %r3, 2 /* decrement destination pointer */ ld.hu %r6, %r2, 0 /* load half-word from source */ st.h %r6, %r3, 0 /* store half-word to destination */ - br.n _ASM_LABEL(kr_word_copy)/* copy full words */ + br.n kr_word_copy/* copy full words */ subu %r4, %r4, 2 /* decrement remaining length */ /* @@ -960,7 +960,7 @@ ASLOCAL(kr_1byte_word_copy) */ ASLOCAL(kr_word_copy) cmp %r10, %r4, 16 /* see if we have 16 bytes remaining */ - bb1 lo, %r10, _ASM_LABEL(kr_byte_copy) /* not enough left, copy bytes */ + bb1 lo, %r10, kr_byte_copy /* not enough left, copy bytes */ subu %r2, %r2, 16 /* decrement source pointer */ subu %r3, %r3, 16 /* decrement destination pointer */ ld %r6, %r2, 0 /* load first word */ @@ -971,7 +971,7 @@ ASLOCAL(kr_word_copy) st %r7, %r3, 4 /* store second word */ st %r8, %r3, 8 /* store third word */ st %r9, %r3, 12 /* store fourth word */ - br.n _ASM_LABEL(kr_word_copy)/* copy another block */ + br.n kr_word_copy/* copy another block */ subu %r4, %r4, 16 /* decrement remaining length */ ASLOCAL(kr_1byte_half_copy) @@ -984,7 +984,7 @@ ASLOCAL(kr_1byte_half_copy) ASLOCAL(kr_half_copy) cmp %r10, %r4, 16 /* see if we have 16 bytes remaining */ - bb1 lo, %r10, _ASM_LABEL(kr_byte_copy) /* not enough left, copy bytes */ + bb1 lo, %r10, kr_byte_copy /* not enough left, copy bytes */ subu %r2, %r2, 16 /* decrement source pointer */ subu %r3, %r3, 16 /* decrement destination pointer */ ld.hu %r6, %r2, 0 /* load first half-word */ @@ -1003,16 +1003,16 @@ ASLOCAL(kr_half_copy) st.h %r11, %r3, 10 /* store sixth half-word */ st.h %r12, %r3, 12 /* store seventh half-word */ st.h %r13, %r3, 14 /* store eighth half-word */ - br.n _ASM_LABEL(kr_half_copy)/* copy another block */ + br.n kr_half_copy/* copy another block */ subu %r4, %r4, 16 /* decrement remaining length */ ASLOCAL(kr_byte_copy) - bcnd eq0, %r4, _ASM_LABEL(kcopy_out) /* branch if nothing left to copy */ + bcnd eq0, %r4, kcopy_out /* branch if nothing left to copy */ subu %r2, %r2, 1 /* decrement source pointer */ subu %r3, %r3, 1 /* decrement destination pointer */ ld.bu %r6, %r2, 0 /* load byte from source */ st.b %r6, %r3, 0 /* store byte in destination */ - br.n _ASM_LABEL(kr_byte_copy)/* branch for next byte */ + br.n kr_byte_copy/* branch for next byte */ subu %r4, %r4, 1 /* decrement remaining length */ ASLOCAL(kcopy_out) @@ -1026,46 +1026,46 @@ ASLOCAL(kcopy_out_fault) st %r7, %r6, PCB_ONFAULT /* restore previous pcb_onfault */ ASLOCAL(kcopy_fault) - br.n _ASM_LABEL(kcopy_out_fault) + br.n kcopy_out_fault or %r2, %r0, EFAULT /* return fault */ .data .align 2 ASLOCAL(kf_strat) - .word _ASM_LABEL(kf_word_copy) - .word _ASM_LABEL(kf_byte_copy) - .word _ASM_LABEL(kf_half_copy) - .word _ASM_LABEL(kf_byte_copy) - .word _ASM_LABEL(kf_byte_copy) - .word _ASM_LABEL(kf_3byte_word_copy) - .word _ASM_LABEL(kf_byte_copy) - .word _ASM_LABEL(kf_1byte_half_copy) - .word _ASM_LABEL(kf_half_copy) - .word _ASM_LABEL(kf_byte_copy) - .word _ASM_LABEL(kf_1half_word_copy) - .word _ASM_LABEL(kf_byte_copy) - .word _ASM_LABEL(kf_byte_copy) - .word _ASM_LABEL(kf_1byte_half_copy) - .word _ASM_LABEL(kf_byte_copy) - .word _ASM_LABEL(kf_1byte_word_copy) + .word kf_word_copy + .word kf_byte_copy + .word kf_half_copy + .word kf_byte_copy + .word kf_byte_copy + .word kf_3byte_word_copy + .word kf_byte_copy + .word kf_1byte_half_copy + .word kf_half_copy + .word kf_byte_copy + .word kf_1half_word_copy + .word kf_byte_copy + .word kf_byte_copy + .word kf_1byte_half_copy + .word kf_byte_copy + .word kf_1byte_word_copy ASLOCAL(kr_strat) - .word _ASM_LABEL(kr_word_copy) - .word _ASM_LABEL(kr_byte_copy) - .word _ASM_LABEL(kr_half_copy) - .word _ASM_LABEL(kr_byte_copy) - .word _ASM_LABEL(kr_byte_copy) - .word _ASM_LABEL(kr_1byte_word_copy) - .word _ASM_LABEL(kr_byte_copy) - .word _ASM_LABEL(kr_1byte_half_copy) - .word _ASM_LABEL(kr_half_copy) - .word _ASM_LABEL(kr_byte_copy) - .word _ASM_LABEL(kr_1half_word_copy) - .word _ASM_LABEL(kr_byte_copy) - .word _ASM_LABEL(kr_byte_copy) - .word _ASM_LABEL(kr_1byte_half_copy) - .word _ASM_LABEL(kr_byte_copy) - .word _ASM_LABEL(kr_3byte_word_copy) + .word kr_word_copy + .word kr_byte_copy + .word kr_half_copy + .word kr_byte_copy + .word kr_byte_copy + .word kr_1byte_word_copy + .word kr_byte_copy + .word kr_1byte_half_copy + .word kr_half_copy + .word kr_byte_copy + .word kr_1half_word_copy + .word kr_byte_copy + .word kr_byte_copy + .word kr_1byte_half_copy + .word kr_byte_copy + .word kr_3byte_word_copy #ifdef DDB /* @@ -1150,7 +1150,7 @@ GLOBAL(esigcode) GLOBAL(sigfill) tb0 0, %r0, 130 /* breakpoint */ GLOBAL(sigfillsiz) - .word _C_LABEL(sigfillsiz) - _C_LABEL(sigfill) + .word sigfillsiz - sigfill /* * Helper functions for pmap_copy_page() and pmap_zero_page(). diff --git a/sys/lib/libkern/arch/m88k/bzero.S b/sys/lib/libkern/arch/m88k/bzero.S index a5e03a684b8..20ecefaf583 100644 --- a/sys/lib/libkern/arch/m88k/bzero.S +++ b/sys/lib/libkern/arch/m88k/bzero.S @@ -1,4 +1,4 @@ -/* $OpenBSD: bzero.S,v 1.3 2022/01/11 09:21:35 jsg Exp $ */ +/* $OpenBSD: bzero.S,v 1.4 2022/12/06 18:51:00 guenther Exp $ */ /* * Mach Operating System * Copyright (c) 1993-1992 Carnegie Mellon University @@ -60,16 +60,16 @@ ENTRY(bzero) * (of the destination address). If either are set, it's * not word aligned. */ - bb1 0, R_dest, _ASM_LABEL(not_initially_word_aligned) - bb1 1, R_dest, _ASM_LABEL(not_initially_word_aligned) + bb1 0, R_dest, not_initially_word_aligned + bb1 1, R_dest, not_initially_word_aligned ASLOCAL(now_word_aligned) /* * before we get into the main loop, grab the * address of the label "mark" below. */ - or.u R_mark_address, %r0, %hi16(_ASM_LABEL(mark)) - or R_mark_address, R_mark_address, %lo16(_ASM_LABEL(mark)) + or.u R_mark_address, %r0, %hi16(mark) + or R_mark_address, R_mark_address, %lo16(mark) ASLOCAL(top_of_main_loop) #define MAX_AT_ONE_TIME 128 @@ -89,7 +89,7 @@ ASLOCAL(top_of_main_loop) clr R_bytes, R_len, 2<0> /* if we're done clearing WORDS, jump out */ - bcnd eq0, R_bytes, _ASM_LABEL(done_doing_words) + bcnd eq0, R_bytes, done_doing_words /* if the number of bytes > MAX_AT_ONE_TIME, do only the max */ cmp R_temp, R_bytes, MAX_AT_ONE_TIME @@ -160,7 +160,7 @@ ASLOCAL(do_max) st %r0, R_dest, 0x00 /* 0 */ ASLOCAL(mark) - br.n _ASM_LABEL(top_of_main_loop) + br.n top_of_main_loop addu R_dest, R_dest, R_bytes /* bump up the dest address */ ASLOCAL(done_doing_words) @@ -182,9 +182,9 @@ ASLOCAL(not_initially_word_aligned) st.b %r0, R_dest, 0 addu R_dest, R_dest, 1 mask R_temp, R_dest, 0x3 - bcnd.n eq0, R_temp, _ASM_LABEL(now_word_aligned) + bcnd.n eq0, R_temp, now_word_aligned subu R_len, R_len, 1 - br _ASM_LABEL(not_initially_word_aligned) + br not_initially_word_aligned #undef R_dest #undef R_len diff --git a/sys/lib/libkern/arch/m88k/copy_subr.S b/sys/lib/libkern/arch/m88k/copy_subr.S index 6f8dcdc0362..212eb369a9d 100644 --- a/sys/lib/libkern/arch/m88k/copy_subr.S +++ b/sys/lib/libkern/arch/m88k/copy_subr.S @@ -1,4 +1,4 @@ -/* $OpenBSD: copy_subr.S,v 1.6 2013/06/15 18:38:18 miod Exp $ */ +/* $OpenBSD: copy_subr.S,v 1.7 2022/12/06 18:51:00 guenther Exp $ */ /* * Mach Operating System * Copyright (c) 1993-1992 Carnegie Mellon University @@ -60,15 +60,15 @@ ENTRY(bcopy) or SAVE, DEST, %r0 #endif - bcnd eq0,LEN,_ASM_LABEL(bcopy_out) /* nothing to do if == 0 */ + bcnd eq0,LEN,bcopy_out /* nothing to do if == 0 */ /* * check position of source and destination data */ cmp %r9,SRC,DEST /* compare source address to destination */ - bb1 eq,%r9,_ASM_LABEL(bcopy_out) /* nothing to do if equal */ + bb1 eq,%r9,bcopy_out /* nothing to do if equal */ #if defined(MEMMOVE) || defined(OVBCOPY) - bb1 lo,%r9,_ASM_LABEL(bcopy_reverse) /* reverse copy if src < dest */ + bb1 lo,%r9,bcopy_reverse /* reverse copy if src < dest */ #endif /* @@ -76,7 +76,7 @@ ENTRY(bcopy) * not have to care about overlapping areas: copy forward */ cmp %r9,LEN,16 /* see if we have at least 16 bytes */ - bb1 lt,%r9,_ASM_LABEL(f_byte_copy) /* copy bytes for small data length */ + bb1 lt,%r9,f_byte_copy /* copy bytes for small data length */ /* * determine copy strategy based on alignment of source and destination */ @@ -84,8 +84,8 @@ ENTRY(bcopy) mask %r7,DEST,3 /* get 2 low order bits of destination addr */ mak %r6,%r6,0<4> /* convert source bits to table offset */ mak %r7,%r7,0<2> /* convert destination bits to table offset */ - or.u %r12,%r0,%hi16(_ASM_LABEL(f_strat)) - or %r12,%r12,%lo16(_ASM_LABEL(f_strat)) + or.u %r12,%r0,%hi16(f_strat) + or %r12,%r12,%lo16(f_strat) addu %r6,%r6,%r7 /* compute final table offset for strategy */ ld %r12,%r12,%r6 /* load the strategy routine */ jmp %r12 /* branch to strategy routine */ @@ -102,7 +102,7 @@ ASLOCAL(f_3byte_word_copy) st.b %r8,DEST,2 /* store byte to destination */ addu SRC,SRC,3 /* increment source pointer */ addu DEST,DEST,3 /* increment destination pointer */ - br.n _ASM_LABEL(f_word_copy) /* copy full words */ + br.n f_word_copy /* copy full words */ subu LEN,LEN,3 /* decrement length */ /* @@ -113,7 +113,7 @@ ASLOCAL(f_1half_word_copy) st.h %r6,DEST,0 /* store half-word to destination */ addu SRC,SRC,2 /* increment source pointer */ addu DEST,DEST,2 /* increment destination pointer */ - br.n _ASM_LABEL(f_word_copy) /* copy full words */ + br.n f_word_copy /* copy full words */ subu LEN,LEN,2 /* decrement remaining length */ /* @@ -131,7 +131,7 @@ ASLOCAL(f_1byte_word_copy) */ ASLOCAL(f_word_copy) cmp %r10,LEN,16 /* see if we have 16 bytes remaining */ - bb1 lo,%r10,_ASM_LABEL(f_byte_copy) /* not enough left, copy bytes */ + bb1 lo,%r10,f_byte_copy /* not enough left, copy bytes */ ld %r6,SRC,0 /* load first word */ ld %r7,SRC,4 /* load second word */ ld %r8,SRC,8 /* load third word */ @@ -142,7 +142,7 @@ ASLOCAL(f_word_copy) st %r9,DEST,12 /* store fourth word */ addu SRC,SRC,16 /* increment source pointer */ addu DEST,DEST,16 /* increment destination pointer */ - br.n _ASM_LABEL(f_word_copy) /* branch to copy another block */ + br.n f_word_copy /* branch to copy another block */ subu LEN,LEN,16 /* decrement remaining length */ ASLOCAL(f_1byte_half_copy) @@ -155,7 +155,7 @@ ASLOCAL(f_1byte_half_copy) ASLOCAL(f_half_copy) cmp %r10,LEN,16 /* see if we have 16 bytes remaining */ - bb1 lo,%r10,_ASM_LABEL(f_byte_copy) /* not enough left, copy bytes */ + bb1 lo,%r10,f_byte_copy /* not enough left, copy bytes */ ld.hu %r6,SRC,0 /* load first half-word */ ld.hu %r7,SRC,2 /* load second half-word */ ld.hu %r8,SRC,4 /* load third half-word */ @@ -174,16 +174,16 @@ ASLOCAL(f_half_copy) st.h %r13,DEST,14 /* store eighth half-word */ addu SRC,SRC,16 /* increment source pointer */ addu DEST,DEST,16 /* increment destination pointer */ - br.n _ASM_LABEL(f_half_copy) /* branch to copy another block */ + br.n f_half_copy /* branch to copy another block */ subu LEN,LEN,16 /* decrement remaining length */ ASLOCAL(f_byte_copy) - bcnd eq0,LEN,_ASM_LABEL(bcopy_out) /* branch if nothing left to copy */ + bcnd eq0,LEN,bcopy_out /* branch if nothing left to copy */ ld.bu %r6,SRC,0 /* load byte from source */ st.b %r6,DEST,0 /* store byte in destination */ addu SRC,SRC,1 /* increment source pointer */ addu DEST,DEST,1 /* increment destination pointer */ - br.n _ASM_LABEL(f_byte_copy) /* branch for next byte */ + br.n f_byte_copy /* branch for next byte */ subu LEN,LEN,1 /* decrement remaining length */ #if defined(MEMMOVE) || defined(OVBCOPY) @@ -200,7 +200,7 @@ ASLOCAL(bcopy_reverse) * check for short data */ cmp %r9,LEN,16 /* see if we have at least 16 bytes */ - bb1 lt,%r9,_ASM_LABEL(r_byte_copy) /* copy bytes for small data length */ + bb1 lt,%r9,r_byte_copy /* copy bytes for small data length */ /* * determine copy strategy based on alignment of source and destination */ @@ -208,8 +208,8 @@ ASLOCAL(bcopy_reverse) mask %r7,DEST,3 /* get 2 low order bits of destination addr */ mak %r6,%r6,0<4> /* convert source bits to table offset */ mak %r7,%r7,0<2> /* convert destination bits to table offset */ - or.u %r12,%r0,%hi16(_ASM_LABEL(r_strat)) - or %r12,%r12,%lo16(_ASM_LABEL(r_strat)) + or.u %r12,%r0,%hi16(r_strat) + or %r12,%r12,%lo16(r_strat) addu %r6,%r6,%r7 /* compute final table offset for strategy */ ld %r12,%r12,%r6 /* load the strategy routine */ jmp %r12 /* branch to strategy routine */ @@ -226,7 +226,7 @@ ASLOCAL(r_3byte_word_copy) st.b %r6,DEST,0 /* store byte to destination */ st.b %r7,DEST,1 /* store byte to destination */ st.b %r8,DEST,2 /* store byte to destination */ - br.n _ASM_LABEL(r_word_copy) /* copy full words */ + br.n r_word_copy /* copy full words */ subu LEN,LEN,3 /* decrement length */ /* @@ -237,7 +237,7 @@ ASLOCAL(r_1half_word_copy) subu DEST,DEST,2 /* decrement destination pointer */ ld.hu %r6,SRC,0 /* load half-word from source */ st.h %r6,DEST,0 /* store half-word to destination */ - br.n _ASM_LABEL(r_word_copy) /* copy full words */ + br.n r_word_copy /* copy full words */ subu LEN,LEN,2 /* decrement remaining length */ /* @@ -255,7 +255,7 @@ ASLOCAL(r_1byte_word_copy) */ ASLOCAL(r_word_copy) cmp %r10,LEN,16 /* see if we have 16 bytes remaining */ - bb1 lo,%r10,_ASM_LABEL(r_byte_copy) /* not enough left, copy bytes */ + bb1 lo,%r10,r_byte_copy /* not enough left, copy bytes */ subu SRC,SRC,16 /* decrement source pointer */ subu DEST,DEST,16 /* decrement destination pointer */ ld %r6,SRC,0 /* load first word */ @@ -266,7 +266,7 @@ ASLOCAL(r_word_copy) st %r7,DEST,4 /* store second word */ st %r8,DEST,8 /* store third word */ st %r9,DEST,12 /* store fourth word */ - br.n _ASM_LABEL(r_word_copy) /* branch to copy another block */ + br.n r_word_copy /* branch to copy another block */ subu LEN,LEN,16 /* decrement remaining length */ ASLOCAL(r_1byte_half_copy) @@ -279,7 +279,7 @@ ASLOCAL(r_1byte_half_copy) ASLOCAL(r_half_copy) cmp %r10,LEN,16 /* see if we have 16 bytes remaining */ - bb1 lo,%r10,_ASM_LABEL(r_byte_copy) /* not enough left, copy bytes */ + bb1 lo,%r10,r_byte_copy /* not enough left, copy bytes */ subu SRC,SRC,16 /* decrement source pointer */ subu DEST,DEST,16 /* decrement destination pointer */ ld.hu %r6,SRC,0 /* load first half-word */ @@ -298,16 +298,16 @@ ASLOCAL(r_half_copy) st.h %r11,DEST,10 /* store sixth half-word */ st.h %r12,DEST,12 /* store seventh half-word */ st.h %r13,DEST,14 /* store eighth half-word */ - br.n _ASM_LABEL(r_half_copy) /* branch to copy another block */ + br.n r_half_copy /* branch to copy another block */ subu LEN,LEN,16 /* decrement remaining length */ ASLOCAL(r_byte_copy) - bcnd eq0,LEN,_ASM_LABEL(bcopy_out) /* branch if nothing left to copy */ + bcnd eq0,LEN,bcopy_out /* branch if nothing left to copy */ subu SRC,SRC,1 /* decrement source pointer */ subu DEST,DEST,1 /* decrement destination pointer */ ld.bu %r6,SRC,0 /* load byte from source */ st.b %r6,DEST,0 /* store byte in destination */ - br.n _ASM_LABEL(r_byte_copy) /* branch for next byte */ + br.n r_byte_copy /* branch for next byte */ subu LEN,LEN,1 /* decrement remaining length */ #endif /* MEMMOVE || OVBCOPY */ @@ -322,39 +322,39 @@ ASLOCAL(bcopy_out) .data .align 2 ASLOCAL(f_strat) - .word _ASM_LABEL(f_word_copy) - .word _ASM_LABEL(f_byte_copy) - .word _ASM_LABEL(f_half_copy) - .word _ASM_LABEL(f_byte_copy) - .word _ASM_LABEL(f_byte_copy) - .word _ASM_LABEL(f_3byte_word_copy) - .word _ASM_LABEL(f_byte_copy) - .word _ASM_LABEL(f_1byte_half_copy) - .word _ASM_LABEL(f_half_copy) - .word _ASM_LABEL(f_byte_copy) - .word _ASM_LABEL(f_1half_word_copy) - .word _ASM_LABEL(f_byte_copy) - .word _ASM_LABEL(f_byte_copy) - .word _ASM_LABEL(f_1byte_half_copy) - .word _ASM_LABEL(f_byte_copy) - .word _ASM_LABEL(f_1byte_word_copy) + .word f_word_copy + .word f_byte_copy + .word f_half_copy + .word f_byte_copy + .word f_byte_copy + .word f_3byte_word_copy + .word f_byte_copy + .word f_1byte_half_copy + .word f_half_copy + .word f_byte_copy + .word f_1half_word_copy + .word f_byte_copy + .word f_byte_copy + .word f_1byte_half_copy + .word f_byte_copy + .word f_1byte_word_copy #if defined(MEMMOVE) || defined(OVBCOPY) ASLOCAL(r_strat) - .word _ASM_LABEL(r_word_copy) - .word _ASM_LABEL(r_byte_copy) - .word _ASM_LABEL(r_half_copy) - .word _ASM_LABEL(r_byte_copy) - .word _ASM_LABEL(r_byte_copy) - .word _ASM_LABEL(r_1byte_word_copy) - .word _ASM_LABEL(r_byte_copy) - .word _ASM_LABEL(r_1byte_half_copy) - .word _ASM_LABEL(r_half_copy) - .word _ASM_LABEL(r_byte_copy) - .word _ASM_LABEL(r_1half_word_copy) - .word _ASM_LABEL(r_byte_copy) - .word _ASM_LABEL(r_byte_copy) - .word _ASM_LABEL(r_1byte_half_copy) - .word _ASM_LABEL(r_byte_copy) - .word _ASM_LABEL(r_3byte_word_copy) + .word r_word_copy + .word r_byte_copy + .word r_half_copy + .word r_byte_copy + .word r_byte_copy + .word r_1byte_word_copy + .word r_byte_copy + .word r_1byte_half_copy + .word r_half_copy + .word r_byte_copy + .word r_1half_word_copy + .word r_byte_copy + .word r_byte_copy + .word r_1byte_half_copy + .word r_byte_copy + .word r_3byte_word_copy #endif -- 2.20.1