 @@ -1,162 +1,156 @@
-#	$NetBSD: Makefile.aarch64,v 1.24 2023/07/26 03:39:55 rin Exp $
+#	$NetBSD: Makefile.aarch64,v 1.25 2023/07/28 02:41:30 rin Exp $
 # Makefile for NetBSD
+#
 # This makefile is constructed from a machine description:
 #	config machineid
 # Most changes should be made in the machine description
 #	/sys/arch/<arch>/conf/``machineid''
 # after which you should do
 #	config machineid
 # Machine generic makefile changes should be made in
 #	/sys/arch/arm/conf/Makefile.arm
 # after which config should be rerun for all machines of that type.
+#
 # To specify debugging, add the config line: makeoptions DEBUG="-g"
 # A better way is to specify -g only for a few files.
+#
 #	makeoptions DEBUGLIST="uvm* trap if_*"
 USETOOLS?=	no
 NEED_OWN_INSTALL_TARGET?=no
 .include <bsd.own.mk>
 ##
 ## (1) port identification
 ##
 THISARM=	$S/arch/${MACHINE}
 ARM=		$S/arch/aarch64
 GENASSYM_CONF=	${ARM}/aarch64/genassym.cf
 .-include "$S/arch/${MACHINE}/conf/Makefile.${MACHINE}.inc"
 ##
 ## (2) compile settings
 ##
 # CPPFLAGS set by platform-specific Makefile fragment.
 CFLAGS+=	-march=armv8-a+nofp+nosimd
 #CFLAGS+=	-fomit-frame-pointer
 CFLAGS+=	-fno-omit-frame-pointer
 CFLAGS+=	-mno-omit-leaf-frame-pointer
 #CFLAGS+=	-mno-unaligned-access
 .if defined(PROF) && ${HAVE_GCC:U0} > 0
 # For accurate profiling, it is better to suppress the tail call.
 CFLAGS+=	-fno-optimize-sibling-calls
 .endif
 .if ${ARMV83_PAC:U0} > 0 && ${ARMV85_BTI:U0} > 0
 CFLAGS+=	-mbranch-protection=pac-ret+bti
 .else
 .if ${ARMV83_PAC:U0} > 0
 CFLAGS+=	-mbranch-protection=pac-ret
 .endif
 .if ${ARMV85_BTI:U0} > 0
 CFLAGS+=	-mbranch-protection=bti
 .endif
 .endif
 .if ${KASAN:U0} > 0 && ${HAVE_GCC:U0} > 0
 KASANFLAGS=	-fsanitize=kernel-address \
 		--param asan-globals=1 --param asan-stack=1 \
 		--param asan-instrument-allocas=1 \
 		-fsanitize-address-use-after-scope \
 		-fasan-shadow-offset=0xDFFF600000000000
 .for f in subr_asan.c
 KASANFLAGS.${f}=	# empty
 .endfor
 CFLAGS+=	${KASANFLAGS.${.IMPSRC:T}:U${KASANFLAGS}}
 .endif
 ##
 ## (3) libkern and compat
 ##
 OPT_MODULAR=	%MODULAR%
 ##
 ## (4) local objects, compile rules, and dependencies
 ##
 MD_OBJS+=	${SYSTEM_FIRST_OBJ} locore.o
 MD_CFILES+=
 MD_SFILES+=	${SYSTEM_FIRST_SFILE} ${ARM}/aarch64/locore.S
 .if defined(SYSTEM_FIRST_OBJ)
 ${SYSTEM_FIRST_OBJ}: ${SYSTEM_FIRST_SFILE} assym.h
 	${NORMAL_S}
 .endif
 locore.o: ${ARM}/aarch64/locore.S assym.h
 	${NORMAL_S}
 ##
 ## (5) link settings
 ##
 KERNLDSCRIPT?=	${ARM}/conf/kern.ldscript
 LOADADDRESS?=	0xffffc00000000000
 LINKFLAGS_NORMAL=	-X
 # Strip AArch64 mapping symbols from the kernel image, as they interfere
-# with ddb, but don't strip them in netbsd.gdb.
+# with ddb, but don't strip them in netbsd.gdb. See Makefile.kern.inc.
-AA64_STRIP_SYMBOLS=	--strip-symbol='[$$][dx]' \
+ARCH_STRIP_SYMBOLS=	--strip-symbol='[$$][dx]' \
 			--strip-symbol='[$$][dx]\.*'
 .if (defined(DEBUG) && !empty(DEBUG:M-g*)) || (!defined(DEBUG) && \
 	(${MKDEBUGKERNEL:Uno} == "yes" || ${MKDEBUG:Uno} == "yes"))
 OBJCOPY_STRIPFLAGS=	-g -w ${AA64_STRIP_SYMBOLS}
 .else
 SYSTEM_LD_TAIL=		@${OBJCOPY} -w ${AA64_STRIP_SYMBOLS} $@
 .endif
 ##
 ## (6) port specific target dependencies
 ##
 # depend on DIAGNOSTIC etc.
 cpuswitch.o fault.o machdep.o: Makefile
 # various assembly files that depend on assym.h
 atomic.o bcopy_page.o bcopyinout.o copystr.o cpuswitch.o cpu_in_cksum.o: assym.h
 exception.o sigcode.o: assym.h
 spl.o vectors.o: assym.h
 ##
 ## (7) misc settings
 ##
 # define .MAIN _before_ the make() check, so that implicit target
 # would be defined
 .MAIN: all
 .if !make(obj) && !make(clean) && !make(cleandir)
 .BEGIN::
 	-@rm -f arm && \
 		ln -s $S/arch/arm/include arm
 .endif
 ##
 ## (8) config(8) generated machinery
 ##
 %INCLUDES
 %OBJS
 %CFILES
 %SFILES
 %LOAD
 %RULES
 ##
 ## (9) after the config file is inserted
 ##
 ##
 ## (10) port independent kernel machinery
 ##
 .include "$S/conf/Makefile.kern.inc"
 ##
 ## (11) Appending make options.
 ##
 %MAKEOPTIONSAPPEND

 @@ -1,170 +1,164 @@
-#	$NetBSD: Makefile.arm,v 1.56 2023/07/26 03:39:55 rin Exp $
+#	$NetBSD: Makefile.arm,v 1.57 2023/07/28 02:41:30 rin Exp $
 # Makefile for NetBSD
+#
 # This makefile is constructed from a machine description:
 #	config machineid
 # Most changes should be made in the machine description
 #	/sys/arch/<arch>/conf/``machineid''
 # after which you should do
 #	config machineid
 # Machine generic makefile changes should be made in
 #	/sys/arch/arm/conf/Makefile.arm
 # after which config should be rerun for all machines of that type.
+#
 # To specify debugging, add the config line: makeoptions DEBUG="-g"
 # A better way is to specify -g only for a few files.
+#
 #	makeoptions DEBUGLIST="uvm* trap if_*"
 USETOOLS?=	no
 NEED_OWN_INSTALL_TARGET?=no
 .include <bsd.own.mk>
 ##
 ## (1) port identification
 ##
 THISARM=	$S/arch/${MACHINE}
 ARM=		$S/arch/arm
 GENASSYM_CONF=	${ARM}/arm32/genassym.cf
 .-include "$S/arch/${MACHINE}/conf/Makefile.${MACHINE}.inc"
 ##
 ## (2) compile settings
 ##
 # CPPFLAGS set by platform-specific Makefile fragment.
 AFLAGS+=	-x assembler-with-cpp
 COPTS.arm32_kvminit.c+=		-fno-stack-protector
 COPTS.vfp_init.c=		-mfpu=vfp
 CLANG_OBSOLETE_MULTI_ST=	${${ACTIVE_CC} == "clang":? -Wa,-W :}
 AFLAGS.bcopyinout.S+=	-marm
 AFLAGS.blockio.S+=	-marm ${CLANG_OBSOLETE_MULTI_ST}
 AFLAGS.copystr.S+=	-marm
 AFLAGS.cpufunc_asm.S+=	${CLANG_OBSOLETE_MULTI_ST}
 AFLAGS.cpuswitch.S+=	-marm -mfpu=vfp
 AFLAGS.exception.S+=	-marm ${CLANG_OBSOLETE_MULTI_ST}
 AFLAGS.fiq_subr.S+=	${CLANG_OBSOLETE_MULTI_ST}
 AFLAGS.fusu.S+=		-marm
 AFLAGS.irq_dispatch.S+=	-marm ${CLANG_OBSOLETE_MULTI_ST}
 AFLAGS.locore.S+=	-marm ${CLANG_OBSOLETE_MULTI_ST}
 CFLAGS+=	 	-mfloat-abi=soft
 # This files use instructions deprecated for ARMv7+, but still
 # included in kernel that build with higher -mcpu=... settings.
 CPPFLAGS.cpufunc_asm_armv4.S+=	-mcpu=arm8
 CPPFLAGS.cpufunc_asm_armv6.S+=	-mcpu=arm1136j-s
 CPPFLAGS.cpufunc_asm_arm11.S+=	-mcpu=arm1136j-s
 CPPFLAGS.cpufunc_asm_xscale.S+=	-mcpu=xscale
 OPT_DDB=	%DDB%
 .if !empty(OPT_DDB) && ${HAVE_GCC:U0} > 0
 CFLAGS+=	-mapcs-frame
 .endif
 # Note: -fasan-shadow-offset=
 #	KASAN_SHADOW_START - (__MD_KERNMEM_BASE >> KASAN_SHADOW_SCALE_SHIFT) =
 #       0xc000_0000 - (0x8000_0000 >> 3) = 0xb000_0000
+#
 .if ${KASAN:U0} > 0 && ${HAVE_GCC:U0} > 0
 KASANFLAGS=	\
 	-fsanitize=kernel-address \
 	--param asan-globals=1 \
 	--param asan-stack=1 \
 	--param asan-instrument-allocas=1 \
 	-fsanitize-address-use-after-scope \
 	-fasan-shadow-offset=0xb0000000
 .for f in subr_asan.c
 KASANFLAGS.${f}=	# empty
 .endfor
 CFLAGS+=	${KASANFLAGS.${.IMPSRC:T}:U${KASANFLAGS}}
 .endif
 ##
 ## (3) libkern and compat
 ##
 OPT_MODULAR=	%MODULAR%
 ##
 ## (4) local objects, compile rules, and dependencies
 ##
 MD_OBJS+=	${SYSTEM_FIRST_OBJ} locore.o
 MD_CFILES+=
 MD_SFILES+=	${SYSTEM_FIRST_SFILE} ${ARM}/arm32/locore.S
 .if defined(SYSTEM_FIRST_OBJ)
 ${SYSTEM_FIRST_OBJ}: ${SYSTEM_FIRST_SFILE} assym.h
 	${NORMAL_S}
 .endif
 locore.o: ${ARM}/arm32/locore.S assym.h
 	${NORMAL_S}
 ##
 ## (5) link settings
 ##
 LOADADDRESS?=	0xF0000000
 LINKFLAGS_NORMAL=	-X
 # Strip ARM mapping symbols from the kernel image, as they interfere
-# with ddb, but don't strip them in netbsd.gdb.
+# with ddb, but don't strip them in netbsd.gdb. See Makefile.kern.inc.
-ARM_STRIP_SYMBOLS=	--strip-symbol='[$$][atd]' \
+ARCH_STRIP_SYMBOLS=	--strip-symbol='[$$][atd]' \
 			--strip-symbol='[$$][atd]\.*'
 .if (defined(DEBUG) && !empty(DEBUG:M-g*)) || (!defined(DEBUG) && \
 	(${MKDEBUGKERNEL:Uno} == "yes" || ${MKDEBUG:Uno} == "yes"))
 OBJCOPY_STRIPFLAGS=	-g -w ${ARM_STRIP_SYMBOLS}
 .else
 SYSTEM_LD_TAIL=		@${OBJCOPY} -w ${ARM_STRIP_SYMBOLS} $@
 .endif
 ##
 ## (6) port specific target dependencies
 ##
 # depend on CPU configuration
 cpufunc.o cpufunc_asm.o: Makefile
 # depend on DIAGNOSTIC etc.
 cpuswitch.o fault.o machdep.o: Makefile
 # various assembly files that depend on assym.h
 atomic.o bcopy_page.o bcopyinout.o copystr.o cpuswitch.o cpu_in_cksum.o: assym.h
 exception.o fiq_subr.o fusu.o irq_dispatch.o isa_irq.o sigcode.o: assym.h
 spl.o vectors.o: assym.h
 ##
 ## (7) misc settings
 ##
 ##
 ## (8) config(8) generated machinery
 ##
 %INCLUDES
 %OBJS
 %CFILES
 %SFILES
 %LOAD
 %RULES
 ##
 ## (9) after the config file is inserted
 ##
 .for f in ${SFILES:T:Mcpufunc_asm*}
 AFLAGS.${f}+=-marm
 .endfor
 ##
 ## (10) port independent kernel machinery
 ##
 .include "$S/conf/Makefile.kern.inc"
 ##
 ## (11) Appending make options.
 ##
 %MAKEOPTIONSAPPEND

 @@ -1,585 +1,595 @@
-#	$NetBSD: Makefile.kern.inc,v 1.298 2023/07/26 03:39:55 rin Exp $
+#	$NetBSD: Makefile.kern.inc,v 1.299 2023/07/28 02:41:31 rin Exp $
+#
 # This file contains common `MI' targets and definitions and it is included
 # at the bottom of each `MD' ${MACHINE}/conf/Makefile.${MACHINE}.
+#
 # Each target in this file should be protected with `if !target(target)'
 # or `if !commands(target)' and each variable should only be conditionally
 # assigned `VAR ?= VALUE', so that everything can be overridden.
+#
 # DEBUG is set to -g if debugging.
 # PROF is set to -pg if profiling.
+#
 # To specify debugging, add the config line: makeoptions DEBUG="-g"
 # A better way is to specify -g only for a few files.
+#
 #	makeoptions DEBUGLIST="uvm* trap if_*"
+#
 # all ports are expected to include bsd.own.mk for toolchain settings
 # Default DEBUG to -g if kernel debug info is requested by MKDEBUGKERNEL=yes
 .if ${MKDEBUGKERNEL:Uno} == "yes" || ${MKDEBUG:Uno} == "yes"
 DEBUG?=-g
 .else
 DEBUG?=
 .endif
 ##
 ## (0) toolchain settings for things that aren't part of the standard
 ## toolchain
 ##
 HOST_SH?=	sh
 DBSYM?=		dbsym
 MKDEP?=		mkdep
 STRIP?=		strip
 OBJCOPY?=	objcopy
 OBJDUMP?=	objdump
 CSCOPE?=	cscope
 MKID?=		mkid
 UUDECODE?=	${TOOL_UUDECODE:Uuudecode}
 HEXDUMP?=	${TOOL_HEXDUMP:Uhexdump}
 GENASSYM?=	${TOOL_GENASSYM:Ugenassym}
 .MAKEOVERRIDES+=USETOOLS	# make sure proper value is propagated
 _MKMSG?=		@\#
 _MKSHMSG?=		echo
 _MKSHECHO?=		echo
 _MKSHNOECHO=		:
 _MKMSG_CREATE?=		:
 _MKTARGET_COMPILE?=	:
 _MKTARGET_CREATE?=	:
 ##
 ## (1) port independent source tree identification
 ##
 # source tree is located via $S relative to the compilation directory
 .ifndef S
 S!=	cd ../../../.. && pwd
 .endif
 ##
 ## (2) compile settings
 ##
 ## CPPFLAGS, CFLAGS, and AFLAGS must be set in the port's Makefile
 ##
 INCLUDES?=	-I. ${EXTRA_INCLUDES} -I${S}/../common/include -I$S/arch \
 		-I$S -nostdinc
 CPPFLAGS+=	${INCLUDES} ${IDENT} -D_KERNEL -D_KERNEL_OPT
 .if !defined(COVERITY_TOP_CONFIG)
 CPPFLAGS+=	-std=gnu99
 .endif
 .if ${KERNEL_DIR:Uno} == "yes"
 CPPFLAGS+=	-DKERNEL_DIR
 .endif
 DEFCOPTS?=	-O2
 COPTS?=		${DEFCOPTS}
 DBG=		# might contain unwanted -Ofoo
 CWARNFLAGS+=	-Wall -Wno-main -Wno-format-zero-length -Wpointer-arith
 CWARNFLAGS+=	-Wmissing-prototypes -Wstrict-prototypes
 CWARNFLAGS+=	-Wold-style-definition
 CWARNFLAGS+=	-Wswitch -Wshadow
 CWARNFLAGS+=	-Wcast-qual -Wwrite-strings
 CWARNFLAGS+=	-Wno-unreachable-code
 #CWARNFLAGS+=	-Wc++-compat -Wno-error=c++-compat
 CWARNFLAGS+=	-Wno-pointer-sign -Wno-attributes
 CWARNFLAGS+=	-Wno-type-limits
 .  if ${MACHINE} == "i386" || ${MACHINE_ARCH} == "x86_64" || \
 	${MACHINE_ARCH} == "sparc64" || ${MACHINE} == "prep"
 CWARNFLAGS+=	-Wextra -Wno-unused-parameter
 .  endif
 .  if ${MACHINE} == "i386" || ${MACHINE_ARCH} == "x86_64"
 CWARNFLAGS+=	-Wold-style-definition
 .  endif
 # Add -Wno-sign-compare.  -Wsign-compare is included in -Wall as of GCC 3.3,
 # but our sources aren't up for it yet.
 CWARNFLAGS+=	-Wno-sign-compare
 CWARNFLAGS.clang+=	-Wno-unknown-pragmas -Wno-conversion \
 			-Wno-self-assign \
 			-Wno-error=constant-conversion
 CWARNFLAGS+=		${CC_WNO_ADDRESS_OF_PACKED_MEMBER}
 CWARNFLAGS.ah_regdomain.c= ${${ACTIVE_CC} == "clang":? \
     -Wno-shift-count-negative -Wno-shift-count-overflow:}
 CWARNFLAGS.ioconf.c= ${${ACTIVE_CC} == "clang":? -Wno-unused-const-variable :}
 CFLAGS+=	-ffreestanding -fno-zero-initialized-in-bss
 CFLAGS+=	${${ACTIVE_CC} == "gcc":? -fno-delete-null-pointer-checks :}
 CFLAGS+=	${DEBUG} ${COPTS}
 AFLAGS+=	-D_LOCORE -Wa,--fatal-warnings
 # example usage to find largest stack users in kernel compile directory:
 #    find . -name \*.su | xargs awk '{ printf "%6d %s\n", $2, $1 }' | sort -n
 .if ${MACHINE} != "vax"
 # GCC/vax 8.4 does not support -fstack-usage.
 CFLAGS+=	${${ACTIVE_CC} == "gcc":? -fstack-usage -Wstack-usage=3584 :}
 .endif
 CWARNFLAGS+=	-Walloca
 # XXX
 .if defined(HAVE_GCC) || defined(HAVE_LLVM)
 CFLAGS+=	-fno-strict-aliasing
 CFLAGS+=	-fno-common
 .endif
 # Use the per-source COPTS variables to add -g to just those
 # files that match the shell patterns given in ${DEBUGLIST}
+#
 .for i in ${DEBUGLIST}
 . for j in ${ALLFILES:M*.c:T:M$i.c}
 COPTS.${j}+=-g
 . endfor
 .endfor
 # Always compile debugsyms.c with debug information.
 # This allows gdb to use type informations.
+#
 COPTS.debugsyms.c+=	-g
 # Add CTF sections for DTrace
 .if defined(CTFCONVERT)
 COMPILE_CTFCONVERT=	${_MKSHECHO}\
 			${CTFCONVERT} ${CTFFLAGS} ${.TARGET} && \
 			${CTFCONVERT} ${CTFFLAGS} ${.TARGET}
 .else
 COMPILE_CTFCONVERT=	${_MKSHNOECHO}
 .endif
 KCOMPILE.c=	${CC} ${COPTS.${<:T}} ${CFLAGS} ${CPPFLAGS} -c $< -o $@
 KCOMPILE.s=	${CC} ${AFLAGS} ${AFLAGS.${<:T}} ${CPPFLAGS} -c $< -o $@
 KLINK.o=	${LD} -r ${LINKFORMAT} -Map=${.TARGET}.map -o ${.TARGET} ${.ALLSRC}
 # compile rules: rules are named ${TYPE}_${SUFFIX} where TYPE is NORMAL or
 # NOPROF and SUFFIX is the file suffix, capitalized (e.g. C for a .c file).
 NORMAL_C?=	@${_MKSHMSG} "compile  ${.CURDIR:T}/${.TARGET}" && \
 		${_MKSHECHO} ${KCOMPILE.c} ${PROF} && \
 		${KCOMPILE.c} ${PROF} && \
 		${COMPILE_CTFCONVERT}
 NOPROF_C?=	@${_MKSHMSG} "compile  ${.CURDIR:T}/${.TARGET}" && \
 		${_MKSHECHO} ${KCOMPILE.c} && \
 		${KCOMPILE.c} && \
 		${COMPILE_CTFCONVERT}
 NORMAL_S?=	@${_MKSHMSG} "compile  ${.CURDIR:T}/${.TARGET}" && \
 		${_MKSHECHO} ${KCOMPILE.s} && \
 		${KCOMPILE.s}
 # link rules:
 LINK_O?=	@${_MKSHMSG} "   link  ${.CURDIR:T}/${.TARGET}" && \
 		${_MKSHECHO} ${KLINK.o} && \
 		${KLINK.o}
 ##
 ## (3) libkern
 ##
 ## Set OPT_MODULAR in the port Makefile if module(7) is enabled,
 ## as documented in $S/lib/libkern/Makefile.inc.
 ##
 ### find out what to use for libkern
 .include "$S/lib/libkern/Makefile.inc"
 .ifndef PROF
 LIBKERN?=	${KERNLIB}
 .else
 LIBKERN?=	${KERNLIB_PROF}
 .endif
 LIBKERNLN?=	${KERNLIBLN}
 ##
 ## (4) local objects, compile rules, and dependencies
 ##
 ## Each port should have a corresponding section with settings for
 ## MD_CFILES, MD_SFILES, and MD_OBJS, along with build rules for same.
 ##
 .if !defined(___USE_SUFFIX_RULES___)
 _MD_OBJS=	${MD_OBJS:T}
 .else
 _MD_OBJS=	${MD_OBJS}
 .endif
 ##
 ## (5) link settings
 ##
 ## TEXTADDR (or LOADADDRESS), LINKFORMAT, LINKSCRIPT, and any EXTRA_LINKFLAGS
 ## must be set in the port's Makefile.  The port specific definitions for
 ## LINKFLAGS_NORMAL and LINKFLAGS_DEBUG will added to the LINKFLAGS
 ## depending on the value of DEBUG.
 ##
 # load lines for config "xxx" will be emitted as:
 # xxx: ${SYSTEM_DEP} swapxxxx.o vers.o build_kernel
 SYSTEM_LIB=	${MD_LIBS} ${LIBKERN}
 SYSTEM_OBJ?=	${_MD_OBJS} ${OBJS} ${SYSTEM_LIB}
 SYSTEM_DEP+=	Makefile ${SYSTEM_OBJ:O}
 .if defined(CTFMERGE)
 SYSTEM_CTFMERGE= ${CTFMERGE} ${CTFMFLAGS} -o ${.TARGET} ${SYSTEM_OBJ} ${EXTRA_OBJ} vers.o
 .else
 SYSTEM_CTFMERGE= ${_MKSHECHO}
 .endif
 REMOVE_SWAP=   [@]
 .for k in ${KERNELS}
 REMOVE_SWAP:=  ${REMOVE_SWAP}:Nswap${k}.o
 .endfor
 SYSTEM_LD_HEAD?=@rm -f $@
 SYSTEM_LD?=	${_MKSHMSG} "   link  ${.CURDIR:T}/${.TARGET}"; \
 		${_MKSHECHO}\
 		${LD} -Map ${.TARGET}.map --cref ${LINKFLAGS} -o ${.TARGET} \
 		'$${SYSTEM_OBJ:${REMOVE_SWAP}}' '$${EXTRA_OBJ}' vers.o \
 		${OBJS:M*swap${.TARGET}.o}; \
 		${LD} -Map ${.TARGET}.map --cref ${LINKFLAGS} -o ${.TARGET} \
 		${SYSTEM_OBJ:${REMOVE_SWAP}} ${EXTRA_OBJ} vers.o \
 		${OBJS:M*swap${.TARGET}.o}
 TEXTADDR?=	${LOADADDRESS}			# backwards compatibility
 LINKTEXT?=	${TEXTADDR:C/.+/-Ttext &/}
 LINKDATA?=	${DATAADDR:C/.+/-Tdata &/}
 ENTRYPOINT?=	start
 LINKENTRY?=	${ENTRYPOINT:C/.+/-e &/}
 LINKFLAGS?=	${LINKFORMAT} ${LINKSCRIPT} ${LINKTEXT} ${LINKDATA} ${LINKENTRY} \
 		${EXTRA_LINKFLAGS}
 LINKFLAGS_DEBUG?=	-X
 KERNEL_CONFIG?=	${KERNEL_BUILD:T}
-SYSTEM_LD_TAIL?= @${_MKSHECHO}
+SYSTEM_LD_TAIL?=	@${_MKSHECHO}
-SYSTEM_LD_TAIL+= && ${TOOL_SED} '/const char sccs/!d;s/.*@(.)//;s/" "//;s/\\.*//' vers.c && \
+OBJCOPY_STRIPFLAGS?=	-g
 		${SIZE} $@ && ${SYSTEM_CTFMERGE} && chmod 755 $@
 SYSTEM_LD_TAIL+= && runit() { echo $$@; $$@; }
-OBJCOPY_STRIPFLAGS?= -g
+# Strip some architecture-defined symbols from kernel image, while
 # keep them in netbsd.gdb.
 .if defined(ARCH_STRIP_SYMBOLS)
 .if empty(DEBUG:M-g*)
 SYSTEM_LD_TAIL+=	&& ${OBJCOPY} -w ${ARCH_STRIP_SYMBOLS} $@
 .endif
 OBJCOPY_STRIPFLAGS+=	-w ${ARCH_STRIP_SYMBOLS}
 .endif
 SYSTEM_LD_TAIL+= && ${TOOL_SED} \
 	'/const char sccs/!d;s/.*@(.)//;s/" "//;s/\\.*//' vers.c && \
 	${SIZE} $@ && ${SYSTEM_CTFMERGE} && chmod 755 $@ && \
 	runit() { echo $$@; $$@; }
 SYSTEM_LD_TAIL_DEBUG?=&& \
 	runit mv -f $@ $@.gdb && \
 	runit ${OBJCOPY} --only-keep-debug $@.gdb $@-${KERNEL_CONFIG}.debug && \
 	runit ${OBJCOPY} ${OBJCOPY_STRIPFLAGS} -p -R .gnu_debuglink \
 	    --add-gnu-debuglink=$@-${KERNEL_CONFIG}.debug $@.gdb $@ && \
 	runit chmod 755 $@ $@.gdb $@-${KERNEL_CONFIG}.debug
 LINKFLAGS_NORMAL?=	-S
 STRIPFLAGS?=	-g
 .if !empty(DEBUG:M-g*)
 SYSTEM_LD_TAIL+=${SYSTEM_LD_TAIL_DEBUG}
 LINKFLAGS+=	${LINKFLAGS_DEBUG}
 EXTRA_KERNELS+= ${KERNELS:@.KERNEL.@${.KERNEL.}.gdb@}
 CTFFLAGS+=	-g
 TARGETSFX=	.gdb
 .elifndef PROF
 LINKFLAGS+=	${LINKFLAGS_NORMAL}
 .endif
 .if ${MKDEBUG:Uno} == "yes"
 # XXX: KERNEL_DIR?
 debuginstall: install-kernel-debug
 .for k in ${KERNELS}
 install-kernel-debug: ${DESTDIR}${DEBUGDIR}/${k}-${KERNEL_CONFIG}.debug
 ${DESTDIR}${DEBUGDIR}/${k}-${KERNEL_CONFIG}.debug: ${k}-${KERNEL_CONFIG}.debug
 	${_MKTARGET_INSTALL}
 	${INSTALL_FILE} -o root -g bin -m 444 ${.ALLSRC} ${.TARGET}
 .endfor
 .else
 debuginstall:
 .endif
 SYSTEM_LD_HEAD+=	${SYSTEM_LD_HEAD_EXTRA}
 SYSTEM_LD_TAIL_STAGE1=	${SYSTEM_LD_TAIL}
 SYSTEM_LD_TAIL_STAGE2=	${SYSTEM_LD_TAIL}
 .if defined(COPY_SYMTAB)
 SYSTEM_LD_TAIL_STAGE2+=	&& runit ${DBSYM} $@
 .if !empty(DEBUG:M-g)
 SYSTEM_LD_TAIL_STAGE2+=	&& runit ${DBSYM} $@.gdb
 .endif
 .endif
 SYSTEM_LD_TAIL_STAGE2+=	${SYSTEM_LD_TAIL_EXTRA}
 ##
 ## (6) port independent targets and dependencies: assym.h, vers.o
 ##
 .if !defined(___USE_SUFFIX_RULES___)
 # Generate list of *.o files to pass to ${LD}, preserving order.
 #	x/y/z/a.[csS] -> a.[csS]
 #	a.[csS] -> a.o
 OBJS=	${ALLFILES:C|^.*/([^/]*\.[csS])$|\1|:C|^(.*)\.[csS]$|\1.o|}
 CFILES=	${ALLFILES:M*.c}
 SFILES=	${ALLFILES:M*.[sS]}
 OFILES=	${ALLFILES:M*.o}
 # absolute, generated (build directory), relative (under $S)
 _CFILES=${CFILES:M/*} ${CFILES:N/*:N*/*} ${CFILES:N/*:M*/*:C|^|$S/|}
 _SFILES=${SFILES:M/*} ${SFILES:N/*:N*/*} ${SFILES:N/*:M*/*:C|^|$S/|}
 _MD_CFILES=${MD_CFILES}
 _MD_SFILES=${MD_SFILES}
 CSRCS=	${_MD_CFILES} ${_CFILES}
 SSRCS=	${_MD_SFILES} ${_SFILES}
 SRCS=	${CSRCS} ${SSRCS}
 .else # ___USE_SUFFIX_RULES___
 OBJS=	${ALLFILES:C|\.[csS]$|.o|}
 SRCS=	${ALLFILES:M*.[csS]}
 .endif # ___USE_SUFFIX_RULES___
 .if !defined(___USE_SUFFIX_RULES___)
 .for _s in ${_CFILES}
 .if !commands(${_s:T:R}.o)
 ${_s:T:R}.o: ${_s}
 	${NORMAL_C}
 .endif
 .endfor
 .for _s in ${_SFILES}
 .if !commands(${_s:T:R}.o)
 ${_s:T:R}.o: ${_s}
 	${NORMAL_S}
 .endif
 .endfor
 .endif # !___USE_SUFFIX_RULES___
 .include "${S}/conf/ldscript.mk"
 .include "${S}/conf/assym.mk"
 .include "${S}/conf/newvers.mk"
 .include "${S}/dev/splash/splash.mk"
 .include "${S}/conf/mdroot.mk"
 .include "${S}/conf/lint.mk"
 .include "${S}/conf/cscope.mk"
 .include "${S}/conf/gdbinit.mk"
 .include "${S}/conf/ssp.mk"
 .if "${_SKIP_DTS}" != "yes"
 .include "${S}/conf/dts.mk"
 .endif
 .include "${S}/conf/copts.mk"
 ##
 ## (7) misc targets: install, clean(dir), depend(all), lint, links, tags,
 ##                   cscope, mkid
 ##
 ## Any ports that have other stuff to be cleaned up should fill in
 ## EXTRA_CLEAN.  Some ports may want different settings for
 ## KERNLINTFLAGS, MKDEP_CFLAGS, or MKDEP_AFLAGS.
 ##
 ##
 ## clean
 ##
 .if !target(__CLEANKERNEL)
 __CLEANKERNEL: .USE
 	${_MKMSG} "${.TARGET}ing the kernel objects"
 	rm -f ${KERNELS} *.map *.[io] *.ko *.ln [a-z]*.s *.su vers.c \
 	    eddep tags [Ee]rrs linterrs makelinks assym.h.tmp assym.h \
 	    ${EXTRA_KERNELS} ${EXTRA_CLEAN}
 .endif
 .if !target(kernelnames)
 kernelnames:
 	@echo "${KERNELS} ${EXTRA_KERNELS}"
 .endif
 .if !target(__CLEANDEPEND)
 __CLEANDEPEND: .USE
 	echo .depend ${DEPS} | xargs rm -f --
 .endif
 # do not !target these, the kern and compat Makefiles augment them
 cleandir distclean: __CLEANKERNEL __CLEANDEPEND
 clean: __CLEANKERNEL
 depend: .depend
 dependall: depend .WAIT all
 ##
 ## depend
 ##
 .if !target(.depend)
 MKDEP_AFLAGS?=	${AFLAGS}
 MKDEP_CFLAGS?=	${CFLAGS}
 .if !defined(___USE_SUFFIX_RULES___)
 DEPS+=	${SRCS:T:R:S/$/.d/g}
 .else
 DEPS+=	${SRCS:R:S/$/.d/g}
 .endif
 .if !defined(___USE_SUFFIX_RULES___)
 .for _s in ${SSRCS}
 .if !commands(${_s:T:R}.d)
 ${_s:T:R}.d: ${_s}
 	${_MKTARGET_CREATE}
 	${MKDEP} -f ${.TARGET}.tmp -- ${MKDEP_AFLAGS} \
 	    ${CPPFLAGS} ${CPPFLAGS.${_s:T}} ${_s}
 	mv -f ${.TARGET}.tmp ${.TARGET}
 .endif
 .endfor
 .for _s in ${CSRCS}
 .if !commands(${_s:T:R}.d)
 ${_s:T:R}.d: ${_s}
 	${_MKTARGET_CREATE}
 	${MKDEP} -f ${.TARGET}.tmp -- ${MKDEP_CFLAGS} \
 	    ${CPPFLAGS} ${CPPFLAGS.${_s:T}} ${_s}
 	mv -f ${.TARGET}.tmp ${.TARGET}
 .endif
 .endfor
 .endif # !___USE_SUFFIX_RULES___
 .depend: ${DEPS:O}
 	${_MKTARGET_CREATE}
 	echo "${.ALLSRC}" | ${MKDEP} -D
 .endif
 ##
 ## install
 ##
 # List of kernel images that will be installed into the root file system.
 # Some platforms may need to install more than one (e.g. a netbsd.aout file
 # to be loaded directly by the firmware), so this can be overridden by them.
 KERNIMAGES?=	netbsd
 .if !target(install)
 # The install target can be redefined by putting a
 # install-kernel-${MACHINE_NAME} target into /etc/mk.conf
 MACHINE_NAME!=  uname -n
 install: install-kernel-${MACHINE_NAME}
 .if !target(install-kernel-${MACHINE_NAME})
 install-kernel-${MACHINE_NAME}:
 .for _K in ${KERNIMAGES}
 .if ${KERNEL_DIR:Uno} == "yes"
 	rm -fr ${DESTDIR}/o${_K}
 	mv ${DESTDIR}/${_K} ${DESTDIR}/o${_K}
 	mkdir -p ${DESTDIR}/${_K}
 	cp ${_K} ${DESTDIR}/${_K}/kernel
 .else
 	rm -f ${DESTDIR}/o${_K}
 	ln ${DESTDIR}/${_K} ${DESTDIR}/o${_K}
 	cp ${_K} ${DESTDIR}/n${_K}
 	mv ${DESTDIR}/n${_K} ${DESTDIR}/${_K}
 .endif
 .endfor
 .endif
 .endif
 ##
 ## the kernel
 ##
 AFLAGS+=	${AOPTS.${.IMPSRC:T}}
 CFLAGS+=	${COPTS.${.IMPSRC:T}} ${CPUFLAGS.${.IMPSRC:T}}
 CPPFLAGS+=	${CPPFLAGS.${.IMPSRC:T}}
 CWARNFLAGS+=	${CWARNFLAGS.${.IMPSRC:T}}
 .for _v in COPTS CPPFLAGS CWARNFLAGS
 .for _c in ${CSRCS}
 ${_v}.${_c:T}+=${OPT.${_c:T}:@.o.@${${_v}.${.o.}}@}
 .endfor
 .endfor
 .MAIN: all
 all: .gdbinit
 .for k in ${KERNELS}
 all: .WAIT ${k}
 ${k}: ${SYSTEM_DEP:O} swap${k}.o vers.o build_kernel #${MKLINT:Myes:%=lint}
 .endfor
 .if !defined(COPY_SYMTAB)
 build_kernel: .USE
 	${SYSTEM_LD_HEAD}
 	${SYSTEM_LD}
 	${SYSTEM_LD_TAIL_STAGE2}
 .else
 .for k in ${KERNELS}
 ${k}: $S/kern/kern_ksyms_buf.c
 .endfor
 build_kernel: .USE
 	${CC} ${CFLAGS} ${CPPFLAGS} \
 	    -c $S/kern/kern_ksyms_buf.c -o kern_ksyms_buf.o
 	${SYSTEM_LD_HEAD}
 	${SYSTEM_LD} kern_ksyms_buf.o
 	${SYSTEM_LD_TAIL_STAGE1}
 	${CC} ${CFLAGS} ${CPPFLAGS} \
 	    -DSYMTAB_SPACE=$$(${DBSYM} -P ${.TARGET}${TARGETSFX}) \
 	    -c $S/kern/kern_ksyms_buf.c -o kern_ksyms_buf_real.o
 	${SYSTEM_LD_HEAD}
 	${SYSTEM_LD} kern_ksyms_buf_real.o
 	${SYSTEM_LD_TAIL_STAGE2}
 .endif
 .include <bsd.files.mk>
 .include <bsd.clang-analyze.mk>
 ##
 ## suffix rules
 ##
 .if defined(___USE_SUFFIX_RULES___)
 .SUFFIXES: .s .d
 .s.d:
 	${_MKTARGET_CREATE}
 	${MKDEP} -f $@.tmp -- ${MKDEP_AFLAGS} ${CPPFLAGS} ${CPPFLAGS.${<:T}} $<
 	mv -f $@.tmp $@
 .SUFFIXES: .S .d
 .S.d:
 	${_MKTARGET_CREATE}
 	${MKDEP} -f $@.tmp -- ${MKDEP_AFLAGS} ${CPPFLAGS} ${CPPFLAGS.${<:T}} $<
 	mv -f $@.tmp $@
 .SUFFIXES: .c .d
 .c.d:
 	${_MKTARGET_CREATE}
 	${MKDEP} -f $@.tmp -- ${MKDEP_CFLAGS} ${CPPFLAGS} ${CPPFLAGS.${<:T}} $<
 	mv -f $@.tmp $@
 .SUFFIXES: .c .o .go .po
 .c.o:
 	@${_MKSHMSG} "compile  ${.CURDIR:T}/${.TARGET}"
 	@${_MKSHECHO} ${KCOMPILE.c}
 	@${KCOMPILE.c}
 	@${COMPILE_CTFCONVERT}
 .c.go:
 	@${_MKSHMSG} "compile  ${.CURDIR:T}/${.TARGET}"
 	@${_MKSHECHO} ${KCOMPILE.c} -g
 	@${KCOMPILE.c} -g
 	@${COMPILE_CTFCONVERT}
 .c.po:
 	@${_MKSHMSG} "compile  ${.CURDIR:T}/${.TARGET}"
 	@${_MKSHECHO} ${KCOMPILE.c} -pg
 	@${KCOMPILE.c} -pg
 	@${COMPILE_CTFCONVERT}
 .SUFFIXES: .s .o .go .po
 .s.o:
 	@${_MKSHMSG} "compile  ${.CURDIR:T}/${.TARGET}"
 	@${_MKSHECHO} ${KCOMPILE.s}
 	@${KCOMPILE.s}
 .s.go:
 	@${_MKSHMSG} "compile  ${.CURDIR:T}/${.TARGET}"
 	@${_MKSHECHO} ${KCOMPILE.s} -g
 	@${KCOMPILE.s} -g
 .s.po:
 	@${_MKSHMSG} "compile  ${.CURDIR:T}/${.TARGET}"
 	@${_MKSHECHO} ${KCOMPILE.s} -pg
 	@${KCOMPILE.s} -pg
 .S.o:
 	@${_MKSHMSG} "compile  ${.CURDIR:T}/${.TARGET}"
 	@${_MKSHECHO} ${KCOMPILE.s}
 	@${KCOMPILE.s}
 .S.go:
 	@${_MKSHMSG} "compile  ${.CURDIR:T}/${.TARGET}"
 	@${_MKSHECHO} ${KCOMPILE.s} -g
 	@${KCOMPILE.s} -g
 .S.po:
 	@${_MKSHMSG} "compile  ${.CURDIR:T}/${.TARGET}"
 	@${_MKSHECHO} ${KCOMPILE.s} -pg
 	@${KCOMPILE.s} -pg
 .endif # ___USE_SUFFIX_RULES___
 ##
 ## the end
 ##