 @@ -1,1769 +1,1778 @@
-#	$NetBSD: bsd.own.mk,v 1.1289.2.2 2023/10/20 16:04:59 martin Exp $
+#	$NetBSD: bsd.own.mk,v 1.1289.2.3 2024/04/18 15:21:55 martin Exp $
 # This needs to be before bsd.init.mk
 .if defined(BSD_MK_COMPAT_FILE)
 .include <${BSD_MK_COMPAT_FILE}>
 .endif
 .if !defined(_BSD_OWN_MK_)
 _BSD_OWN_MK_=1
 MAKECONF?=	/etc/mk.conf
 .-include "${MAKECONF}"
+#
 # CPU model, derived from MACHINE_ARCH
+#
 MACHINE_CPU=	${MACHINE_ARCH:C/mips.*e[bl]/mips/:C/sh3e[bl]/sh3/:S/coldfire/m68k/:S/m68000/m68k/:C/e?arm.*/arm/:S/powerpc64/powerpc/:S/aarch64eb/aarch64/:S/or1knd/or1k/:C/riscv../riscv/}
 .if (${MACHINE_ARCH} == "mips64el" || \
      ${MACHINE_ARCH} == "mips64eb" || \
      ${MACHINE_ARCH} == "mipsn64el" || \
      ${MACHINE_ARCH} == "mipsn64eb")
 MACHINE_MIPS64= 	1
 .else
 MACHINE_MIPS64= 	0
 .endif
+#
 # Subdirectory used below ${RELEASEDIR} when building a release
+#
 .if !empty(MACHINE:Mevbarm) || !empty(MACHINE:Mevbmips) \
 	|| !empty(MACHINE:Mevbsh3)
 RELEASEMACHINEDIR?=	${MACHINE}-${MACHINE_ARCH}
 .else
 RELEASEMACHINEDIR?=	${MACHINE}
 .endif
+#
 # Subdirectory or path component used for the following paths:
 #   distrib/${RELEASEMACHINE}
 #   distrib/notes/${RELEASEMACHINE}
 #   etc/etc.${RELEASEMACHINE}
 # Used when building a release.
+#
 RELEASEMACHINE?=	${MACHINE}
+#
 # NEED_OWN_INSTALL_TARGET is set to "no" by pkgsrc/mk/bsd.pkg.mk to
 # ensure that things defined by <bsd.own.mk> (default targets,
 # INSTALL_FILE, etc.) are not conflicting with bsd.pkg.mk.
+#
 NEED_OWN_INSTALL_TARGET?=	yes
+#
 # This lists the platforms which do not have working in-tree toolchains.  For
 # the in-tree gcc toolchain, this list is empty.
+#
 # If some future port is not supported by the in-tree toolchain, this should
 # be set to "yes" for that port only.
+#
 # .if ${MACHINE} == "playstation2"
 # TOOLCHAIN_MISSING?=	yes
 # .endif
 TOOLCHAIN_MISSING?=	no
+#
 # GCC Using platforms.
+#
 .if ${MKGCC:Uyes} != "no"
+#
 # What GCC is used?
+#
 HAVE_GCC?=	10
+#
 # Platforms that can't run a modern GCC natively
 .if ${MACHINE_ARCH} == "m68000"
 MKGCCCMDS?=	no
 .endif
+#
 # We import the old gcc as "gcc.old" when upgrading.  EXTERNAL_GCC_SUBDIR is
 # set to the relevant subdirectory in src/external/gpl3 for his HAVE_GCC.
+#
 .if ${HAVE_GCC} == 9
 EXTERNAL_GCC_SUBDIR?=	gcc.old
 .elif ${HAVE_GCC} == 10
 EXTERNAL_GCC_SUBDIR?=	gcc
 .else
 EXTERNAL_GCC_SUBDIR?=	/does/not/exist
 .endif
 .else
 MKGCCCMDS?=	no
 .endif
+#
 # What binutils is used?
+#
 HAVE_BINUTILS?=	234
 .if ${HAVE_BINUTILS} == 234
 EXTERNAL_BINUTILS_SUBDIR=	binutils
 .elif ${HAVE_BINUTILS} == 231
 EXTERNAL_BINUTILS_SUBDIR=	binutils.old
 .else
 EXTERNAL_BINUTILS_SUBDIR=	/does/not/exist
 .endif
+#
 # What GDB is used?
+#
 HAVE_GDB?=	1100
 .if ${HAVE_GDB} == 1100
 EXTERNAL_GDB_SUBDIR=		gdb
 .elif ${HAVE_GDB} == 830
 EXTERNAL_GDB_SUBDIR=		gdb.old
 .else
 EXTERNAL_GDB_SUBDIR=		/does/not/exist
 .endif
+#
 # What OpenSSL is used?
+#
 HAVE_OPENSSL?=  30
 .if ${HAVE_OPENSSL} == 30
 EXTERNAL_OPENSSL_SUBDIR=openssl
 .elif ${HAVE_OPENSSL} == 11
 EXTERNAL_OPENSSL_SUBDIR=openssl.old
 .else
 EXTERNAL_OPENSSL_SUBDIR=/does/not/exist
 .endif
+#
 # Does the platform support ACPI?
+#
 .if ${MACHINE} == "i386" || \
     ${MACHINE} == "amd64" || \
     ${MACHINE} == "ia64" || \
     !empty(MACHINE_ARCH:Maarch64*)
 HAVE_ACPI=	yes
 .else
 HAVE_ACPI=	no
 .endif
+#
 # Does the platform support UEFI?
+#
 .if ${MACHINE} == "i386" || \
     ${MACHINE} == "amd64" || \
     ${MACHINE} == "ia64" || \
     !empty(MACHINE_ARCH:Mearmv7*) || \
     !empty(MACHINE_ARCH:Maarch64*) || \
     ${MACHINE_ARCH} == "riscv64"
 HAVE_UEFI=	yes
 .else
 HAVE_UEFI=	no
 .endif
+#
 # Does the platform support NVMM?
+#
 .if ${MACHINE_ARCH} == "x86_64"
 HAVE_NVMM=	yes
 .else
 HAVE_NVMM=	no
 .endif
 .if !empty(MACHINE_ARCH:Mearm*)
 _LIBC_COMPILER_RT.${MACHINE_ARCH}=	yes
 .endif
 _LIBC_COMPILER_RT.aarch64=	yes
 _LIBC_COMPILER_RT.aarch64eb=	yes
 _LIBC_COMPILER_RT.i386=		yes
 _LIBC_COMPILER_RT.powerpc=	yes
 _LIBC_COMPILER_RT.powerpc64=	yes
 _LIBC_COMPILER_RT.sparc=	yes
 _LIBC_COMPILER_RT.sparc64=	yes
 _LIBC_COMPILER_RT.x86_64=	yes
 .if ${HAVE_LLVM:Uno} == "yes" && ${_LIBC_COMPILER_RT.${MACHINE_ARCH}:Uno} == "yes"
 HAVE_LIBGCC?=	no
 .else
 HAVE_LIBGCC?=	yes
 .endif
 # Should libgcc have unwinding code?
 .if ${HAVE_LLVM:Uno} == "yes" || !empty(MACHINE_ARCH:Mearm*)
 HAVE_LIBGCC_EH?=	no
 .else
 HAVE_LIBGCC_EH?=	yes
 .endif
 # Coverity does not like SSP
 .if defined(COVERITY_TOP_CONFIG) || \
     ${MACHINE} == "alpha" || \
     ${MACHINE} == "hppa" || \
     ${MACHINE} == "ia64" || \
     ${MACHINE_CPU} == "mips"
 HAVE_SSP?=	no
 .else
 HAVE_SSP?=	yes
 .if !defined(NOFORT) && ${USE_FORT:Uno} != "no"
 USE_SSP?=	yes
 .endif
 .endif
+#
 # What version of jemalloc we use (100 is the one
 # built-in to libc from 2005 (pre version 3).
+#
 .if ${MACHINE_ARCH} == "vax" || ${MACHINE} == "sun2"
 HAVE_JEMALLOC?=		100
 .else
 HAVE_JEMALLOC?=		510
 .endif
 .if empty(.MAKEFLAGS:tW:M*-V .OBJDIR*)
 .if defined(MAKEOBJDIRPREFIX) || defined(MAKEOBJDIR)
 PRINTOBJDIR=	${MAKE} -r -V .OBJDIR -f /dev/null xxx
 .else
 PRINTOBJDIR=	${MAKE} -V .OBJDIR
 .endif
 .else
 PRINTOBJDIR=	echo /error/bsd.own.mk/PRINTOBJDIR # avoid infinite recursion
 .endif
+#
 # Determine if running in the NetBSD source tree by checking for the
 # existence of build.sh and tools/ in the current or a parent directory,
 # and setting _SRC_TOP_ to the result.
+#
 .if !defined(_SRC_TOP_)			# {
 _SRC_TOP_!= cd "${.CURDIR}"; while :; do \
 		here=$$(pwd); \
 		[ -f build.sh  ] && [ -d tools ] && { echo $$here; break; }; \
 		case $$here in /) echo ""; break;; esac; \
 		cd ..; done
 .MAKEOVERRIDES+=	_SRC_TOP_
 .endif					# }
+#
 # If _SRC_TOP_ != "", we're within the NetBSD source tree.
 # * Set defaults for NETBSDSRCDIR and _SRC_TOP_OBJ_.
 # * Define _NETBSD_VERSION_DEPENDS.  Targets that depend on the
 #   NetBSD version, or on variables defined at build time, can
 #   declare a dependency on ${_NETBSD_VERSION_DEPENDS}.
+#
 .if (${_SRC_TOP_} != "")		# {
 NETBSDSRCDIR?=	${_SRC_TOP_}
 .if !defined(_SRC_TOP_OBJ_)
 _SRC_TOP_OBJ_!=		cd "${_SRC_TOP_}" && ${PRINTOBJDIR}
 .MAKEOVERRIDES+=	_SRC_TOP_OBJ_
 .endif
 _NETBSD_VERSION_DEPENDS=	${_SRC_TOP_OBJ_}/params
 _NETBSD_VERSION_DEPENDS+=	${NETBSDSRCDIR}/sys/sys/param.h
 _NETBSD_VERSION_DEPENDS+=	${NETBSDSRCDIR}/sys/conf/newvers.sh
 _NETBSD_VERSION_DEPENDS+=	${NETBSDSRCDIR}/sys/conf/osrelease.sh
 ${_SRC_TOP_OBJ_}/params: .NOTMAIN .OPTIONAL # created by top level "make build"
 .endif	# _SRC_TOP_ != ""		# }
 .if (${_SRC_TOP_} != "") && \
     (${TOOLCHAIN_MISSING} == "no" || defined(EXTERNAL_TOOLCHAIN))
 USETOOLS?=	yes
 .endif
 USETOOLS?=	no
 .if ${MACHINE_ARCH} == "mips" || ${MACHINE_ARCH} == "mips64" || \
     ${MACHINE_ARCH} == "sh3"
 .BEGIN:
 	@echo "Must set MACHINE_ARCH to one of ${MACHINE_ARCH}eb or ${MACHINE_ARCH}el"
 	@false
 .elif defined(REQUIRETOOLS) && \
       (${TOOLCHAIN_MISSING} == "no" || defined(EXTERNAL_TOOLCHAIN)) && \
       ${USETOOLS} == "no"
 .BEGIN:
 	@echo "USETOOLS=no, but this component requires a version-specific host toolchain"
 	@false
 .endif
+#
 # Host platform information; may be overridden
+#
 .include <bsd.host.mk>
 .if ${USETOOLS} == "yes"						# {
+#
 # Provide a default for TOOLDIR.
+#
 .if !defined(TOOLDIR)
 TOOLDIR:=	${_SRC_TOP_OBJ_}/tooldir.${HOST_OSTYPE}
 .MAKEOVERRIDES+= TOOLDIR
 .endif
+#
 # This is the prefix used for the NetBSD-sourced tools.
+#
 _TOOL_PREFIX?=	nb
+#
 # If an external toolchain base is specified, use it.
+#
 .if defined(EXTERNAL_TOOLCHAIN)						# {
 AR=		${EXTERNAL_TOOLCHAIN}/bin/${MACHINE_GNU_PLATFORM}-ar
 AS=		${EXTERNAL_TOOLCHAIN}/bin/${MACHINE_GNU_PLATFORM}-as
 LD=		${EXTERNAL_TOOLCHAIN}/bin/${MACHINE_GNU_PLATFORM}-ld
 NM=		${EXTERNAL_TOOLCHAIN}/bin/${MACHINE_GNU_PLATFORM}-nm
 OBJCOPY=	${EXTERNAL_TOOLCHAIN}/bin/${MACHINE_GNU_PLATFORM}-objcopy
 OBJDUMP=	${EXTERNAL_TOOLCHAIN}/bin/${MACHINE_GNU_PLATFORM}-objdump
 RANLIB=		${EXTERNAL_TOOLCHAIN}/bin/${MACHINE_GNU_PLATFORM}-ranlib
 READELF=	${EXTERNAL_TOOLCHAIN}/bin/${MACHINE_GNU_PLATFORM}-readelf
 SIZE=		${EXTERNAL_TOOLCHAIN}/bin/${MACHINE_GNU_PLATFORM}-size
 STRINGS=	${EXTERNAL_TOOLCHAIN}/bin/${MACHINE_GNU_PLATFORM}-strings
 STRIP=		${EXTERNAL_TOOLCHAIN}/bin/${MACHINE_GNU_PLATFORM}-strip
 TOOL_CC.gcc=		${EXTERNAL_TOOLCHAIN}/bin/${MACHINE_GNU_PLATFORM}-gcc
 TOOL_CPP.gcc=		${EXTERNAL_TOOLCHAIN}/bin/${MACHINE_GNU_PLATFORM}-cpp
 TOOL_CXX.gcc=		${EXTERNAL_TOOLCHAIN}/bin/${MACHINE_GNU_PLATFORM}-c++
 TOOL_FC.gcc=		${EXTERNAL_TOOLCHAIN}/bin/${MACHINE_GNU_PLATFORM}-gfortran
 TOOL_OBJC.gcc=		${EXTERNAL_TOOLCHAIN}/bin/${MACHINE_GNU_PLATFORM}-gcc
 TOOL_CC.clang=		${EXTERNAL_TOOLCHAIN}/bin/${MACHINE_GNU_PLATFORM}-clang
 TOOL_CPP.clang=		${EXTERNAL_TOOLCHAIN}/bin/${MACHINE_GNU_PLATFORM}-clang-cpp
 TOOL_CXX.clang=		${EXTERNAL_TOOLCHAIN}/bin/${MACHINE_GNU_PLATFORM}-clang++
 TOOL_OBJC.clang=	${EXTERNAL_TOOLCHAIN}/bin/${MACHINE_GNU_PLATFORM}-clang
 .else									# } {
 # Define default locations for common tools.
 .if ${USETOOLS_BINUTILS:Uyes} == "yes"					#  {
 AR=		${TOOLDIR}/bin/${MACHINE_GNU_PLATFORM}-ar
 AS=		${TOOLDIR}/bin/${MACHINE_GNU_PLATFORM}-as
 LD=		${TOOLDIR}/bin/${MACHINE_GNU_PLATFORM}-ld
 NM=		${TOOLDIR}/bin/${MACHINE_GNU_PLATFORM}-nm
 OBJCOPY=	${TOOLDIR}/bin/${MACHINE_GNU_PLATFORM}-objcopy
 OBJDUMP=	${TOOLDIR}/bin/${MACHINE_GNU_PLATFORM}-objdump
 RANLIB=		${TOOLDIR}/bin/${MACHINE_GNU_PLATFORM}-ranlib
 READELF=	${TOOLDIR}/bin/${MACHINE_GNU_PLATFORM}-readelf
 SIZE=		${TOOLDIR}/bin/${MACHINE_GNU_PLATFORM}-size
 STRINGS=	${TOOLDIR}/bin/${MACHINE_GNU_PLATFORM}-strings
 STRIP=		${TOOLDIR}/bin/${MACHINE_GNU_PLATFORM}-strip
 # GCC supports C, C++, Fortran and Objective C
 TOOL_CC.gcc=		${TOOLDIR}/bin/${MACHINE_GNU_PLATFORM}-gcc
 TOOL_CPP.gcc=		${TOOLDIR}/bin/${MACHINE_GNU_PLATFORM}-cpp
 TOOL_CXX.gcc=		${TOOLDIR}/bin/${MACHINE_GNU_PLATFORM}-c++
 TOOL_FC.gcc=		${TOOLDIR}/bin/${MACHINE_GNU_PLATFORM}-gfortran
 TOOL_OBJC.gcc=		${TOOLDIR}/bin/${MACHINE_GNU_PLATFORM}-gcc
 .endif									#  }
 # Clang supports C, C++ and Objective C
 TOOL_CC.clang=		${TOOLDIR}/bin/${MACHINE_GNU_PLATFORM}-clang
 TOOL_CPP.clang=		${TOOLDIR}/bin/${MACHINE_GNU_PLATFORM}-clang-cpp
 TOOL_CXX.clang=		${TOOLDIR}/bin/${MACHINE_GNU_PLATFORM}-clang++
 TOOL_OBJC.clang=	${TOOLDIR}/bin/${MACHINE_GNU_PLATFORM}-clang
 # PCC supports C and Fortran
 TOOL_CC.pcc=		${TOOLDIR}/bin/${MACHINE_GNU_PLATFORM}-pcc
 TOOL_CPP.pcc=		${TOOLDIR}/bin/${MACHINE_GNU_PLATFORM}-pcpp
 TOOL_CXX.pcc=		${TOOLDIR}/bin/${MACHINE_GNU_PLATFORM}-p++
 .endif	# EXTERNAL_TOOLCHAIN						# }
+#
 # Make sure DESTDIR is set, so that builds with these tools always
 # get appropriate -nostdinc, -nostdlib, etc. handling.  The default is
 # <empty string>, meaning start from /, the root directory.
+#
 DESTDIR?=
 # Don't append another copy of sysroot (coming from COMPATCPPFLAGS etc.)
 # because it confuses Coverity. Still we need to cov-configure specially
 # for each specific sysroot argument.
 # Also don't add a sysroot at all if a rumpkernel build.
 .if !defined(HOSTPROG) && !defined(HOSTLIB) && !defined(RUMPRUN)
 .  if ${DESTDIR} != ""
 .	if empty(CPPFLAGS:M*--sysroot=*)
 CPPFLAGS+=	--sysroot=${DESTDIR}
 .	endif
 LDFLAGS+=	--sysroot=${DESTDIR}
 .  else
 .	if empty(CPPFLAGS:M*--sysroot=*)
 CPPFLAGS+=	--sysroot=/
 .	endif
 LDFLAGS+=	--sysroot=/
 .  endif
 .endif
 DBSYM=		${TOOLDIR}/bin/${MACHINE_GNU_PLATFORM}-dbsym
 ARM_ELF2AOUT=	${TOOLDIR}/bin/${_TOOL_PREFIX}arm-elf2aout
 M68K_ELF2AOUT=	${TOOLDIR}/bin/${_TOOL_PREFIX}m68k-elf2aout
 MIPS_ELF2ECOFF=	${TOOLDIR}/bin/${_TOOL_PREFIX}mips-elf2ecoff
 INSTALL=	${TOOLDIR}/bin/${MACHINE_GNU_PLATFORM}-install
 LEX=		${TOOLDIR}/bin/${_TOOL_PREFIX}lex
 LINT=		CC=${CC:Q} ${TOOLDIR}/bin/${MACHINE_GNU_PLATFORM}-lint
 LORDER=		NM=${NM:Q} MKTEMP=${TOOL_MKTEMP:Q} ${TOOLDIR}/bin/${_TOOL_PREFIX}lorder
 MKDEP=		CC=${CC:Q} ${TOOLDIR}/bin/${_TOOL_PREFIX}mkdep
 MKDEPCXX=	CC=${CXX:Q} ${TOOLDIR}/bin/${_TOOL_PREFIX}mkdep
 PAXCTL=		${TOOLDIR}/bin/${_TOOL_PREFIX}paxctl
 TSORT=		${TOOLDIR}/bin/${_TOOL_PREFIX}tsort -q
 YACC=		${TOOLDIR}/bin/${_TOOL_PREFIX}yacc
 TOOL_AMIGAAOUT2BB=	${TOOLDIR}/bin/${_TOOL_PREFIX}amiga-aout2bb
 TOOL_AMIGAELF2BB=	${TOOLDIR}/bin/${_TOOL_PREFIX}amiga-elf2bb
 TOOL_AMIGATXLT=		${TOOLDIR}/bin/${_TOOL_PREFIX}amiga-txlt
 TOOL_ASN1_COMPILE=	${TOOLDIR}/bin/${_TOOL_PREFIX}asn1_compile
 TOOL_AWK=		${TOOLDIR}/bin/${_TOOL_PREFIX}awk
 TOOL_CAP_MKDB=		${TOOLDIR}/bin/${_TOOL_PREFIX}cap_mkdb
 TOOL_CAT=		${TOOLDIR}/bin/${_TOOL_PREFIX}cat
 TOOL_CKSUM=		${TOOLDIR}/bin/${_TOOL_PREFIX}cksum
 TOOL_CLANG_TBLGEN=	${TOOLDIR}/bin/${_TOOL_PREFIX}clang-tblgen
 TOOL_COMPILE_ET=	${TOOLDIR}/bin/${_TOOL_PREFIX}compile_et
 TOOL_CONFIG=		${TOOLDIR}/bin/${_TOOL_PREFIX}config
 TOOL_CRUNCHGEN=		MAKE=${.MAKE:Q} ${TOOLDIR}/bin/${_TOOL_PREFIX}crunchgen
 TOOL_CTAGS=		${TOOLDIR}/bin/${_TOOL_PREFIX}ctags
 TOOL_CTFCONVERT=	${TOOLDIR}/bin/${_TOOL_PREFIX}ctfconvert
 TOOL_CTFMERGE=		${TOOLDIR}/bin/${_TOOL_PREFIX}ctfmerge
 TOOL_CVSLATEST=		${TOOLDIR}/bin/${_TOOL_PREFIX}cvslatest
 TOOL_DATE=		${TOOLDIR}/bin/${_TOOL_PREFIX}date
 TOOL_DB=		${TOOLDIR}/bin/${_TOOL_PREFIX}db
 TOOL_DISKLABEL=		${TOOLDIR}/bin/${_TOOL_PREFIX}disklabel
 TOOL_DTC=		${TOOLDIR}/bin/${_TOOL_PREFIX}dtc
 TOOL_EQN=		${TOOLDIR}/bin/${_TOOL_PREFIX}eqn
 TOOL_FDISK=		${TOOLDIR}/bin/${MACHINE_GNU_PLATFORM}-fdisk
 TOOL_FGEN=		${TOOLDIR}/bin/${_TOOL_PREFIX}fgen
 TOOL_GENASSYM=		${TOOLDIR}/bin/${_TOOL_PREFIX}genassym
 TOOL_GENCAT=		${TOOLDIR}/bin/${_TOOL_PREFIX}gencat
 TOOL_GMAKE=		${TOOLDIR}/bin/${_TOOL_PREFIX}gmake
 TOOL_GPT=		${TOOLDIR}/bin/${_TOOL_PREFIX}gpt
 TOOL_GREP=		${TOOLDIR}/bin/${_TOOL_PREFIX}grep
 GROFF_SHARE_PATH=	${TOOLDIR}/share/groff
 TOOL_GROFF_ENV= \
     GROFF_ENCODING= \
     GROFF_BIN_PATH=${TOOLDIR}/lib/groff \
     GROFF_FONT_PATH=${GROFF_SHARE_PATH}/site-font:${GROFF_SHARE_PATH}/font \
     GROFF_TMAC_PATH=${GROFF_SHARE_PATH}/site-tmac:${GROFF_SHARE_PATH}/tmac
 TOOL_GROFF=		${TOOL_GROFF_ENV} ${TOOLDIR}/bin/${_TOOL_PREFIX}groff ${GROFF_FLAGS}
 TOOL_HEXDUMP=		${TOOLDIR}/bin/${_TOOL_PREFIX}hexdump
 TOOL_HP300MKBOOT=	${TOOLDIR}/bin/${_TOOL_PREFIX}hp300-mkboot
 TOOL_HPPAMKBOOT=	${TOOLDIR}/bin/${_TOOL_PREFIX}hppa-mkboot
 TOOL_INDXBIB=		${TOOLDIR}/bin/${_TOOL_PREFIX}indxbib
 TOOL_INSTALLBOOT=	${TOOLDIR}/bin/${_TOOL_PREFIX}installboot
 TOOL_INSTALL_INFO=	${TOOLDIR}/bin/${_TOOL_PREFIX}install-info
 TOOL_JOIN=		${TOOLDIR}/bin/${_TOOL_PREFIX}join
 TOOL_LLVM_TBLGEN=	${TOOLDIR}/bin/${_TOOL_PREFIX}llvm-tblgen
 TOOL_M4=		${TOOLDIR}/bin/${_TOOL_PREFIX}m4
 TOOL_MACPPCFIXCOFF=	${TOOLDIR}/bin/${_TOOL_PREFIX}macppc-fixcoff
 TOOL_MAKEFS=		${TOOLDIR}/bin/${_TOOL_PREFIX}makefs
 TOOL_MAKEINFO=		${TOOLDIR}/bin/${_TOOL_PREFIX}makeinfo
 TOOL_MAKEKEYS=		${TOOLDIR}/bin/${_TOOL_PREFIX}makekeys
 TOOL_MAKESTRS=		${TOOLDIR}/bin/${_TOOL_PREFIX}makestrs
 TOOL_MAKEWHATIS=	${TOOLDIR}/bin/${_TOOL_PREFIX}makewhatis
 TOOL_MANDOC_ASCII=	${TOOLDIR}/bin/${_TOOL_PREFIX}mandoc -Tascii
 TOOL_MANDOC_HTML=	${TOOLDIR}/bin/${_TOOL_PREFIX}mandoc -Thtml
 TOOL_MANDOC_LINT=	${TOOLDIR}/bin/${_TOOL_PREFIX}mandoc -Tlint
 TOOL_MDSETIMAGE=	${TOOLDIR}/bin/${MACHINE_GNU_PLATFORM}-mdsetimage
 TOOL_MENUC=		MENUDEF=${TOOLDIR}/share/misc ${TOOLDIR}/bin/${_TOOL_PREFIX}menuc
 TOOL_ARMELF2AOUT=	${TOOLDIR}/bin/${_TOOL_PREFIX}arm-elf2aout
 TOOL_M68KELF2AOUT=	${TOOLDIR}/bin/${_TOOL_PREFIX}m68k-elf2aout
 TOOL_MIPSELF2ECOFF=	${TOOLDIR}/bin/${_TOOL_PREFIX}mips-elf2ecoff
 TOOL_MKCSMAPPER=	${TOOLDIR}/bin/${_TOOL_PREFIX}mkcsmapper
 TOOL_MKESDB=		${TOOLDIR}/bin/${_TOOL_PREFIX}mkesdb
 TOOL_MKLOCALE=		${TOOLDIR}/bin/${_TOOL_PREFIX}mklocale
 TOOL_MKMAGIC=		${TOOLDIR}/bin/${_TOOL_PREFIX}file
 TOOL_MKNOD=		${TOOLDIR}/bin/${_TOOL_PREFIX}mknod
 TOOL_MKTEMP=		${TOOLDIR}/bin/${_TOOL_PREFIX}mktemp
 TOOL_MKUBOOTIMAGE=	${TOOLDIR}/bin/${_TOOL_PREFIX}mkubootimage
 TOOL_ELFTOSB=		${TOOLDIR}/bin/${_TOOL_PREFIX}elftosb
 TOOL_MSGC=		MSGDEF=${TOOLDIR}/share/misc ${TOOLDIR}/bin/${_TOOL_PREFIX}msgc
 TOOL_MTREE=		${TOOLDIR}/bin/${_TOOL_PREFIX}mtree
 TOOL_MVME68KWRTVID=	${TOOLDIR}/bin/${_TOOL_PREFIX}mvme68k-wrtvid
 TOOL_NBPERF=		${TOOLDIR}/bin/${_TOOL_PREFIX}perf
 TOOL_NCDCS=		${TOOLDIR}/bin/${_TOOL_PREFIX}ibmnws-ncdcs
 TOOL_PAX=		${TOOLDIR}/bin/${_TOOL_PREFIX}pax
 TOOL_PIC=		${TOOLDIR}/bin/${_TOOL_PREFIX}pic
 TOOL_PIGZ=		${TOOLDIR}/bin/${_TOOL_PREFIX}pigz
 TOOL_XZ=		${TOOLDIR}/bin/${_TOOL_PREFIX}xz
 TOOL_PKG_CREATE=	${TOOLDIR}/bin/${_TOOL_PREFIX}pkg_create
 TOOL_POWERPCMKBOOTIMAGE=${TOOLDIR}/bin/${_TOOL_PREFIX}powerpc-mkbootimage
 TOOL_PWD_MKDB=		${TOOLDIR}/bin/${_TOOL_PREFIX}pwd_mkdb
 TOOL_REFER=		${TOOLDIR}/bin/${_TOOL_PREFIX}refer
 TOOL_ROFF_ASCII=	${TOOL_GROFF_ENV} ${TOOLDIR}/bin/${_TOOL_PREFIX}nroff
 TOOL_ROFF_DOCASCII=	${TOOL_GROFF} -Tascii
 TOOL_ROFF_DOCHTML=	${TOOL_GROFF} -Thtml
 TOOL_ROFF_DVI=		${TOOL_GROFF} -Tdvi ${ROFF_PAGESIZE}
 TOOL_ROFF_HTML=		${TOOL_GROFF} -Tlatin1 -mdoc2html
 TOOL_ROFF_PS=		${TOOL_GROFF} -Tps ${ROFF_PAGESIZE}
 TOOL_ROFF_RAW=		${TOOL_GROFF} -Z
 TOOL_RPCGEN=		RPCGEN_CPP=${CPP:Q} ${TOOLDIR}/bin/${_TOOL_PREFIX}rpcgen
 TOOL_SED=		${TOOLDIR}/bin/${_TOOL_PREFIX}sed
 TOOL_SLC=		${TOOLDIR}/bin/${_TOOL_PREFIX}slc
 TOOL_SOELIM=		${TOOLDIR}/bin/${_TOOL_PREFIX}soelim
 TOOL_SORTINFO=		${TOOLDIR}/bin/${_TOOL_PREFIX}sortinfo
 TOOL_SPARKCRC=		${TOOLDIR}/bin/${_TOOL_PREFIX}sparkcrc
 TOOL_STAT=		${TOOLDIR}/bin/${_TOOL_PREFIX}stat
 TOOL_STRFILE=		${TOOLDIR}/bin/${_TOOL_PREFIX}strfile
 TOOL_SUNLABEL=		${TOOLDIR}/bin/${_TOOL_PREFIX}sunlabel
 TOOL_TBL=		${TOOLDIR}/bin/${_TOOL_PREFIX}tbl
 TOOL_TIC=		${TOOLDIR}/bin/${_TOOL_PREFIX}tic
 TOOL_UUDECODE=		${TOOLDIR}/bin/${_TOOL_PREFIX}uudecode
 TOOL_VGRIND=		${TOOLDIR}/bin/${_TOOL_PREFIX}vgrind -f
 TOOL_VFONTEDPR=		${TOOLDIR}/libexec/${_TOOL_PREFIX}vfontedpr
 TOOL_ZIC=		${TOOLDIR}/bin/${_TOOL_PREFIX}zic
 .else	# USETOOLS != yes						# } {
 # Clang supports C, C++ and Objective C
 TOOL_CC.clang=		clang
 TOOL_CPP.clang=		clang-cpp
 TOOL_CXX.clang=		clang++
 TOOL_OBJC.clang=	clang
 # GCC supports C, C++, Fortran and Objective C
 TOOL_CC.gcc=	gcc
 TOOL_CPP.gcc=	cpp
 TOOL_CXX.gcc=	c++
 TOOL_FC.gcc=	gfortran
 TOOL_OBJC.gcc=	gcc
 # PCC supports C and Fortran
 TOOL_CC.pcc=		pcc
 TOOL_CPP.pcc=		pcpp
 TOOL_CXX.pcc=		p++
 TOOL_AMIGAAOUT2BB=	amiga-aout2bb
 TOOL_AMIGAELF2BB=	amiga-elf2bb
 TOOL_AMIGATXLT=		amiga-txlt
 TOOL_ASN1_COMPILE=	asn1_compile
 TOOL_AWK=		awk
 TOOL_CAP_MKDB=		cap_mkdb
 TOOL_CAT=		cat
 TOOL_CKSUM=		cksum
 TOOL_CLANG_TBLGEN=	clang-tblgen
 TOOL_COMPILE_ET=	compile_et
 TOOL_CONFIG=		config
 TOOL_CRUNCHGEN=		crunchgen
 TOOL_CTAGS=		ctags
 TOOL_CTFCONVERT=	ctfconvert
 TOOL_CTFMERGE=		ctfmerge
 TOOL_CVSLATEST=		cvslatest
 TOOL_DATE=		date
 TOOL_DB=		db
 TOOL_DISKLABEL=		disklabel
 TOOL_DTC=		dtc
 TOOL_EQN=		eqn
 TOOL_FDISK=		fdisk
 TOOL_FGEN=		fgen
 TOOL_GENASSYM=		genassym
 TOOL_GENCAT=		gencat
 TOOL_GMAKE=		gmake
 TOOL_GPT=		gpt
 TOOL_GREP=		grep
 TOOL_GROFF=		groff
 TOOL_HEXDUMP=		hexdump
 TOOL_HP300MKBOOT=	hp300-mkboot
 TOOL_HPPAMKBOOT=	hppa-mkboot
 TOOL_INDXBIB=		indxbib
 TOOL_INSTALLBOOT=	installboot
 TOOL_INSTALL_INFO=	install-info
 TOOL_JOIN=		join
 TOOL_LLVM_TBLGEN=	llvm-tblgen
 TOOL_M4=		m4
 TOOL_MACPPCFIXCOFF=	macppc-fixcoff
 TOOL_MAKEFS=		makefs
 TOOL_MAKEINFO=		makeinfo
 TOOL_MAKEKEYS=		makekeys
 TOOL_MAKESTRS=		makestrs
 TOOL_MAKEWHATIS=	/usr/libexec/makewhatis
 TOOL_MANDOC_ASCII=	mandoc -Tascii
 TOOL_MANDOC_HTML=	mandoc -Thtml
 TOOL_MANDOC_LINT=	mandoc -Tlint
 TOOL_MDSETIMAGE=	mdsetimage
 TOOL_MENUC=		menuc
 TOOL_ARMELF2AOUT=	arm-elf2aout
 TOOL_M68KELF2AOUT=	m68k-elf2aout
 TOOL_MIPSELF2ECOFF=	mips-elf2ecoff
 TOOL_MKCSMAPPER=	mkcsmapper
 TOOL_MKESDB=		mkesdb
 TOOL_MKLOCALE=		mklocale
 TOOL_MKMAGIC=		file
 TOOL_MKNOD=		mknod
 TOOL_MKTEMP=		mktemp
 TOOL_MKUBOOTIMAGE=	mkubootimage
 TOOL_ELFTOSB=		elftosb
 TOOL_MSGC=		msgc
 TOOL_MTREE=		mtree
 TOOL_MVME68KWRTVID=	wrtvid
 TOOL_NBPERF=		nbperf
 TOOL_NCDCS=		ncdcs
 TOOL_PAX=		pax
 TOOL_PIC=		pic
 TOOL_PIGZ=		pigz
 TOOL_XZ=		xz
 TOOL_PKG_CREATE=	pkg_create
 TOOL_POWERPCMKBOOTIMAGE=	powerpc-mkbootimage
 TOOL_PWD_MKDB=		pwd_mkdb
 TOOL_REFER=		refer
 TOOL_ROFF_ASCII=	nroff
 TOOL_ROFF_DOCASCII=	${TOOL_GROFF} -Tascii
 TOOL_ROFF_DOCHTML=	${TOOL_GROFF} -Thtml
 TOOL_ROFF_DVI=		${TOOL_GROFF} -Tdvi ${ROFF_PAGESIZE}
 TOOL_ROFF_HTML=		${TOOL_GROFF} -Tlatin1 -mdoc2html
 TOOL_ROFF_PS=		${TOOL_GROFF} -Tps ${ROFF_PAGESIZE}
 TOOL_ROFF_RAW=		${TOOL_GROFF} -Z
 TOOL_RPCGEN=		rpcgen
 TOOL_SED=		sed
 TOOL_SOELIM=		soelim
 TOOL_SORTINFO=		sortinfo
 TOOL_SPARKCRC=		sparkcrc
 TOOL_STAT=		stat
 TOOL_STRFILE=		strfile
 TOOL_SUNLABEL=		sunlabel
 TOOL_TBL=		tbl
 TOOL_TIC=		tic
 TOOL_UUDECODE=		uudecode
 TOOL_VGRIND=		vgrind -f
 TOOL_VFONTEDPR=		/usr/libexec/vfontedpr
 TOOL_ZIC=		zic
 .endif	# USETOOLS != yes						# }
 # Standalone code should not be compiled with PIE or CTF
 # Should create a better test
 .if defined(BINDIR) && ${BINDIR} == "/usr/mdec"
 NOPIE=			# defined
 NOCTF=			# defined
 .elif ${MACHINE} == "sun2"
 NOPIE=			# we don't have PIC, so no PIE
 .endif
 # Fallback to ensure that all variables are defined to something
 TOOL_CC.false=		false
 TOOL_CPP.false=		false
 TOOL_CXX.false=		false
 TOOL_FC.false=		false
 TOOL_OBJC.false=	false
 AVAILABLE_COMPILER?=	${HAVE_PCC:Dpcc} ${HAVE_LLVM:Dclang} ${HAVE_GCC:Dgcc} false
 .for _t in CC CPP CXX FC OBJC
 ACTIVE_${_t}=	${AVAILABLE_COMPILER:@.c.@ ${ !defined(UNSUPPORTED_COMPILER.${.c.}) && defined(TOOL_${_t}.${.c.}) :? ${.c.} : }@:[1]}
 SUPPORTED_${_t}=${AVAILABLE_COMPILER:Nfalse:@.c.@ ${ !defined(UNSUPPORTED_COMPILER.${.c.}) && defined(TOOL_${_t}.${.c.}) :? ${.c.} : }@}
 .endfor
 # make bugs prevent moving this into the .for loop
 CC=		${TOOL_CC.${ACTIVE_CC}}
 CPP=		${TOOL_CPP.${ACTIVE_CPP}}
 CXX=		${TOOL_CXX.${ACTIVE_CXX}}
 FC=		${TOOL_FC.${ACTIVE_FC}}
 OBJC=		${TOOL_OBJC.${ACTIVE_OBJC}}
 # For each ${MACHINE_CPU}, list the ports that use it.
 MACHINES.aarch64=	evbarm
 MACHINES.alpha=		alpha
 MACHINES.arm=		acorn32 cats epoc32 evbarm hpcarm \
 			iyonix netwinder shark zaurus
 MACHINES.coldfire=	evbcf
 MACHINES.i386=		i386
 MACHINES.ia64=		ia64
 MACHINES.hppa=		hppa
 MACHINES.m68000=	sun2
 MACHINES.m68k=		amiga atari cesfic hp300 luna68k mac68k \
 			news68k next68k sun3 x68k
 MACHINES.mips=		algor arc cobalt emips evbmips ews4800mips \
 			hpcmips mipsco newsmips pmax sbmips sgimips
 MACHINES.or1k=		or1k
 MACHINES.powerpc=	amigappc bebox evbppc ibmnws macppc mvmeppc \
 			ofppc prep rs6000 sandpoint
 MACHINES.riscv=		riscv
 MACHINES.sh3=		dreamcast evbsh3 hpcsh landisk mmeye
 MACHINES.sparc=		sparc sparc64
 MACHINES.sparc64=	sparc64
 MACHINES.vax=		vax
 MACHINES.x86_64=	amd64
 # OBJCOPY flags to create a.out binaries for old firmware
 # shared among src/distrib and ${MACHINE}/conf/Makefile.${MACHINE}.inc
 .if ${MACHINE_CPU} == "arm"
 OBJCOPY_ELF2AOUT_FLAGS?=	\
 	-O a.out-arm-netbsd	\
 	-R .ident		\
 	-R .ARM.attributes	\
 	-R .ARM.exidx		\
 	-R .ARM.extab		\
 	-R .SUNW_ctf		\
 	-R .arm.atpcs		\
 	-R .comment		\
 	-R .debug_abbrev	\
 	-R .debug_aranges	\
 	-R .debug_info		\
 	-R .debug_line		\
 	-R .debug_frame		\
 	-R .debug_loc		\
 	-R .debug_pubnames	\
 	-R .debug_pubtypes	\
 	-R .debug_ranges	\
 	-R .debug_str		\
 	-R .debug_macinfo	\
 	-R .eh_frame		\
 	-R .note.netbsd.ident
 .endif
+#
 # Targets to check if DESTDIR or RELEASEDIR is provided
+#
 .if !target(check_DESTDIR)
 check_DESTDIR: .PHONY .NOTMAIN
 .if !defined(DESTDIR)
 	@echo "setenv DESTDIR before doing that!"
 	@false
 .else
 	@true
 .endif
 .endif
 .if !target(check_RELEASEDIR)
 check_RELEASEDIR: .PHONY .NOTMAIN
 .if !defined(RELEASEDIR)
 	@echo "setenv RELEASEDIR before doing that!"
 	@false
 .else
 	@true
 .endif
 .endif
+#
 # Where the system object and source trees are kept; can be configurable
 # by the user in case they want them in ~/foosrc and ~/fooobj (for example).
+#
 BSDSRCDIR?=	/usr/src
 BSDOBJDIR?=	/usr/obj
 NETBSDSRCDIR?=	${BSDSRCDIR}
 BINGRP?=	wheel
 BINOWN?=	root
 BINMODE?=	555
 NONBINMODE?=	444
 # These are here mainly because we don't want suid root in case
 # a Makefile defines BINMODE.
 RUMPBINGRP?=	wheel
 RUMPBINOWN?=	root
 RUMPBINMODE?=	555
 RUMPNONBINMODE?=444
 MANDIR?=	/usr/share/man
 MANGRP?=	wheel
 MANOWN?=	root
 MANMODE?=	${NONBINMODE}
 MANINSTALL?=	${_MANINSTALL}
 INFODIR?=	/usr/share/info
 INFOGRP?=	wheel
 INFOOWN?=	root
 INFOMODE?=	${NONBINMODE}
 LIBDIR?=	/usr/lib
 LINTLIBDIR?=	/usr/libdata/lint
 LIBGRP?=	${BINGRP}
 LIBOWN?=	${BINOWN}
 LIBMODE?=	${NONBINMODE}
 DOCDIR?=	/usr/share/doc
 DOCGRP?=	wheel
 DOCOWN?=	root
 DOCMODE?=	${NONBINMODE}
 NLSDIR?=	/usr/share/nls
 NLSGRP?=	wheel
 NLSOWN?=	root
 NLSMODE?=	${NONBINMODE}
 KMODULEGRP?=	wheel
 KMODULEOWN?=	root
 KMODULEMODE?=	${NONBINMODE}
 LOCALEDIR?=	/usr/share/locale
 LOCALEGRP?=	wheel
 LOCALEOWN?=	root
 LOCALEMODE?=	${NONBINMODE}
 FIRMWAREDIR?=	/libdata/firmware
 FIRMWAREGRP?=	wheel
 FIRMWAREOWN?=	root
 FIRMWAREMODE?=	${NONBINMODE}
 DEBUGDIR?=	/usr/libdata/debug
 DEBUGGRP?=	wheel
 DEBUGOWN?=	root
 DEBUGMODE?=	${NONBINMODE}
 DTBDIR?=	/boot/dtb
 DTBGRP?=	wheel
 DTBOWN?=	root
 DTBMODE?=	${NONBINMODE}
 MKDIRMODE?=	0755
 MKDIRPERM?=	-m ${MKDIRMODE}
+#
 # Data-driven table using make variables to control how
 # toolchain-dependent targets and shared libraries are built
 # for different platforms and object formats.
+#
 # OBJECT_FMT:		currently either "ELF" or "a.out".
+#
 # All platforms are ELF.
+#
 OBJECT_FMT=	ELF
+#
 # If this platform's toolchain is missing, we obviously cannot build it.
+#
 .if ${TOOLCHAIN_MISSING} != "no"
 MKBINUTILS:= no
 MKGDB:= no
 MKGCC:= no
 .endif
+#
 # If we are using an external toolchain, we can still build the target's
 # binutils, but we cannot build GCC's support libraries, since those are
 # tightly-coupled to the version of GCC being used.
+#
 .if defined(EXTERNAL_TOOLCHAIN)
 MKGCC:= no
 .endif
 MKGDB.or1k=	no
 MKGDB.riscv32=	no
 MKGDB.riscv64=	no
 # No kernel modules for or1k or riscv (yet)
 MKKMOD.or1k=	no
 MKKMOD.riscv32=	no
 MKKMOD.riscv64=	no
 # No profiling for or1k (yet)
 MKPROFILE.or1k=	no
 MKPROFILE.riscv32=no
 MKPROFILE.riscv64=no
+#
 # The m68000 port is incomplete.
+#
 .if ${MACHINE_ARCH} == "m68000"
 NOPIC=		# defined
 MKISCSI=	no
 # XXX GCC 4 outputs mcount() calling sequences that try to load values
 # from over 64KB away and this fails to assemble.
 .if defined(HAVE_GCC)
 NOPROFILE=	# defined
 .endif
 .endif
+#
 # GCC warnings with simple disables.  Use these with eg
 # COPTS.foo.c+= ${GCC_NO_STRINGOP_TRUNCATION}.
+#
 GCC_NO_FORMAT_TRUNCATION=	${${ACTIVE_CC} == "gcc" && ${HAVE_GCC:U0} >= 7:? -Wno-format-truncation :}
 GCC_NO_FORMAT_OVERFLOW=		${${ACTIVE_CC} == "gcc" && ${HAVE_GCC:U0} >= 7:? -Wno-format-overflow :}
 GCC_NO_STRINGOP_OVERFLOW=	${${ACTIVE_CC} == "gcc" && ${HAVE_GCC:U0} >= 7:? -Wno-stringop-overflow :}
 GCC_NO_IMPLICIT_FALLTHRU=	${${ACTIVE_CC} == "gcc" && ${HAVE_GCC:U0} >= 7:? -Wno-implicit-fallthrough :}
 GCC_NO_STRINGOP_TRUNCATION=	${${ACTIVE_CC} == "gcc" && ${HAVE_GCC:U0} >= 8:? -Wno-stringop-truncation :}
 GCC_NO_CAST_FUNCTION_TYPE=	${${ACTIVE_CC} == "gcc" && ${HAVE_GCC:U0} >= 8:? -Wno-cast-function-type :}
 GCC_NO_ADDR_OF_PACKED_MEMBER=	${${ACTIVE_CC} == "gcc" && ${HAVE_GCC:U0} >= 9:? -Wno-address-of-packed-member :}
 GCC_NO_MAYBE_UNINITIALIZED=	${${ACTIVE_CC} == "gcc" && ${HAVE_GCC:U0} >= 10:? -Wno-maybe-uninitialized :}
 GCC_NO_RETURN_LOCAL_ADDR=	${${ACTIVE_CC} == "gcc" && ${HAVE_GCC:U0} >= 10:? -Wno-return-local-addr :}
+#
 # Clang warnings
+#
 CLANG_NO_ADDR_OF_PACKED_MEMBER=	${${ACTIVE_CC} == "clang" :? -Wno-error=address-of-packed-member :}
 NO_ADDR_OF_PACKED_MEMBER=	${CLANG_NO_ADDR_OF_PACKED_MEMBER} ${GCC_NO_ADDR_OF_PACKED_MEMBER}
+#
 # The ia64 port is incomplete.
+#
 MKGDB.ia64=	no
+#
 # On VAX using ELF, all objects are PIC, not just shared libraries,
 # so don't build the _pic version. VAX has no native TLS support either,
 # so differences between TLS models are not relevant.
+#
 MKPICLIB.vax=	no
+#
 # Location of the file that contains the major and minor numbers of the
 # version of a shared library.  If this file exists a shared library
 # will be built by <bsd.lib.mk>.
+#
 SHLIB_VERSION_FILE?= ${.CURDIR}/shlib_version
+#
 # GNU sources and packages sometimes see architecture names differently.
+#
 GNU_ARCH.aarch64eb=aarch64_be
 GNU_ARCH.coldfire=m5407
 GNU_ARCH.earm=arm
 GNU_ARCH.earmhf=arm
 GNU_ARCH.earmeb=armeb
 GNU_ARCH.earmhfeb=armeb
 GNU_ARCH.earmv4=armv4
 GNU_ARCH.earmv4eb=armv4eb
 GNU_ARCH.earmv5=arm
 GNU_ARCH.earmv5hf=arm
 GNU_ARCH.earmv5eb=armeb
 GNU_ARCH.earmv5hfeb=armeb
 GNU_ARCH.earmv6=armv6
 GNU_ARCH.earmv6hf=armv6
 GNU_ARCH.earmv6eb=armv6eb
 GNU_ARCH.earmv6hfeb=armv6eb
 GNU_ARCH.earmv7=armv7
 GNU_ARCH.earmv7hf=armv7
 GNU_ARCH.earmv7eb=armv7eb
 GNU_ARCH.earmv7hfeb=armv7eb
 GNU_ARCH.i386=i486
 GCC_CONFIG_ARCH.i386=i486
 GCC_CONFIG_TUNE.i386=nocona
 GCC_CONFIG_TUNE.x86_64=nocona
 GNU_ARCH.m68000=m68010
 GNU_ARCH.sh3eb=sh
 GNU_ARCH.sh3el=shle
 GNU_ARCH.mips64eb=mips64
 MACHINE_GNU_ARCH=${GNU_ARCH.${MACHINE_ARCH}:U${MACHINE_ARCH}}
+#
 # In order to identify NetBSD to GNU packages, we sometimes need
 # an "elf" tag for historically a.out platforms.
+#
 .if (!empty(MACHINE_ARCH:Mearm*))
 MACHINE_GNU_PLATFORM?=${MACHINE_GNU_ARCH}--netbsdelf-${MACHINE_ARCH:C/eb//:C/v[4-7]//:S/earm/eabi/}
 .elif (${MACHINE_GNU_ARCH} == "arm" || \
      ${MACHINE_GNU_ARCH} == "armeb" || \
      ${MACHINE_ARCH} == "i386" || \
      ${MACHINE_CPU} == "m68k" || \
      ${MACHINE_GNU_ARCH} == "sh" || \
      ${MACHINE_GNU_ARCH} == "shle" || \
      ${MACHINE_ARCH} == "sparc" || \
      ${MACHINE_ARCH} == "vax")
 MACHINE_GNU_PLATFORM?=${MACHINE_GNU_ARCH}--netbsdelf
 .else
 MACHINE_GNU_PLATFORM?=${MACHINE_GNU_ARCH}--netbsd
 .endif
 .if !empty(MACHINE_ARCH:M*arm*)
 # Flags to pass to CC for using the old APCS ABI on ARM for compat or stand.
 ARM_APCS_FLAGS=	-mabi=apcs-gnu -mfloat-abi=soft -marm
 ARM_APCS_FLAGS+= ${${ACTIVE_CC} == "gcc" && ${HAVE_GCC:U0} >= 8:? -mno-thumb-interwork :}
 ARM_APCS_FLAGS+=${${ACTIVE_CC} == "clang":? -target ${MACHINE_GNU_ARCH}--netbsdelf -B ${TOOLDIR}/${MACHINE_GNU_PLATFORM}/bin :}
 .endif
 GENASSYM_CPPFLAGS+=	${${ACTIVE_CC} == "clang":? -no-integrated-as :}
 TARGETS+=	all clean cleandir depend dependall includes \
 		install lint obj regress tags html analyze describe \
 		rumpdescribe
 PHONY_NOTMAIN =	all clean cleandir depend dependall distclean includes \
 		install lint obj regress beforedepend afterdepend \
 		beforeinstall afterinstall realinstall realdepend realall \
 		html subdir-all subdir-install subdir-depend analyze describe \
 		rumpdescribe
 .PHONY:		${PHONY_NOTMAIN}
 .NOTMAIN:	${PHONY_NOTMAIN}
 .if ${NEED_OWN_INSTALL_TARGET} != "no"
 .if !target(install)
 install:	beforeinstall .WAIT subdir-install realinstall .WAIT afterinstall
 beforeinstall:
 subdir-install:
 realinstall:
 afterinstall:
 .endif
 all:		realall subdir-all
 subdir-all:
 realall:
 depend:		realdepend subdir-depend
 subdir-depend:
 realdepend:
 distclean:	cleandir
 cleandir:	clean
 dependall:	.NOTMAIN realdepend .MAKE
 	@cd "${.CURDIR}"; ${MAKE} realall
 .endif
+#
 # Define MKxxx variables (which are either yes or no) for users
 # to set in /etc/mk.conf and override in the make environment.
 # These should be tested with `== "no"' or `!= "no"'.
 # The NOxxx variables should only be set by Makefiles.
+#
 # Please keep etc/Makefile and share/man/man5/mk.conf.5 in sync
 # with changes to the MK* variables here.
+#
+#
 # Supported NO* options (if defined, MK* will be forced to "no",
 # regardless of user's mk.conf setting).
+#
 # Source makefiles should set NO*, and not MK*, and must do so before
 # including bsd.own.mk.
+#
 .for var in \
 	NOCOMPAT NOCRYPTO NODOC NOHTML NOINFO NOLIBCSANITIZER NOLINKLIB \
 	NOLINT NOMAN NONLS NOOBJ NOPIC NOPICINSTALL NOPROFILE NOSHARE \
 	NOSTATICLIB NODEBUGLIB NOSANITIZER NORELRO
 .if defined(${var})
 MK${var:S/^NO//}:=	no
 .endif
 .endfor
+#
 # Older-style variables that enabled behaviour when set.
+#
 .for var in MANZ UNPRIVED UPDATE
 .if defined(${var})
 MK${var}:=	yes
 .endif
 .endfor
+#
 # MK* options which have variable defaults.
+#
+#
 # aarch64eb is not yet supported for MKCOMPAT.
+#
 .if ${MACHINE_ARCH} == "x86_64" || \
     ${MACHINE_ARCH} == "sparc64" || \
     ${MACHINE_MIPS64} || \
     ${MACHINE_ARCH} == "powerpc64" || \
     (${MACHINE_ARCH} == "aarch64" && ${HAVE_GCC:U0} == 0) || \
     ${MACHINE_ARCH} == "riscv64" || \
     !empty(MACHINE_ARCH:Mearm*)
 MKCOMPAT?=	yes
 .else
 # Don't let this build where it really isn't supported.
 MKCOMPAT:=	no
 .endif
 .if ${MKCOMPAT} == "no"
 MKCOMPATTESTS:=	no
 MKCOMPATX11:=	no
 .endif
 .if ${MACHINE_MIPS64} \
     || (${MACHINE} == "evbppc" && ${MACHINE_ARCH} == "powerpc")
 MKCOMPATMODULES?=	yes
 .else
 MKCOMPATMODULES:=	no
 .endif
+#
 # These platforms use softfloat by default.
+#
 .if ${MACHINE_MIPS64}
 MKSOFTFLOAT?=	yes
 .endif
+#
 # These platforms always use softfloat.
+#
 .if (${MACHINE_CPU} == "arm" && ${MACHINE_ARCH:M*hf*} == "") || \
     ${MACHINE_ARCH} == "coldfire" || ${MACHINE_CPU} == "or1k" || \
     ${MACHINE} == "emips" || ${MACHINE_CPU} == "sh3"
 MKSOFTFLOAT=	yes
 .endif
 .if ${MACHINE} == "emips"
 SOFTFLOAT_BITS=	32
 .endif
+#
 # We want to build zfs only for amd64, aarch64 and sparc64 by default for now.
+#
 .if ${MACHINE} == "amd64" || \
     ${MACHINE} == "sparc64" || \
     !empty(MACHINE_ARCH:Maarch64*)
 MKZFS?=		yes
 .endif
+#
 # DTrace works on amd64, i386, aarch64, and earm*
+#
 .if ${MACHINE} == "i386" || \
     ${MACHINE} == "amd64" || \
     ${MACHINE_ARCH} == "aarch64" || \
     !empty(MACHINE_ARCH:Mearm*)
 MKDTRACE?=	yes
 MKCTF?=		yes
 .endif
+#
 # PIE is enabled on many platforms by default.
+#
 # Coverity does not like PIE
 .if !defined(COVERITY_TOP_CONFIG) && \
     (${MACHINE_ARCH} == "i386" || \
     ${MACHINE_ARCH} == "x86_64" || \
     !empty(MACHINE_ARCH:Maarch64*) || \
     ${MACHINE_CPU} == "arm" || \
     ${MACHINE_CPU} == "m68k" || \
     ${MACHINE_CPU} == "mips" || \
     ${MACHINE_CPU} == "sh3" || \
     ${MACHINE} == "sparc64")
 MKPIE?=		yes
 .else
 MKPIE?=		no
 .endif
+#
 # RELRO is enabled on i386, amd64, and aarch64 by default
+#
 .if ${MACHINE} == "i386" || \
     ${MACHINE} == "amd64" || \
     !empty(MACHINE_ARCH:Maarch64*)
 MKRELRO?=	partial
 .else
 MKRELRO?=	no
 .endif
 .if ${MACHINE_ARCH} == "x86_64" || ${MACHINE_ARCH} == "i386"
 MKSTATICPIE?=	yes
 .else
 MKSTATICPIE?=	no
 .endif
+#
 # MK* options which default to "yes".
+#
 _MKVARS.yes= \
 	MKARGON2 \
 	MKATF \
 	MKBINUTILS \
 	MKBSDTAR \
 	MKCOMPLEX MKCVS MKCXX \
 	MKDOC MKDTC \
 	MKDYNAMICROOT \
 	MKGCC MKGDB MKGROFF \
 	MKHESIOD MKHTML \
 	MKIEEEFP MKINET6 MKINFO MKIPFILTER MKISCSI \
 	MKKERBEROS \
 	MKKMOD \
 	MKLDAP MKLIBSTDCXX MKLINKLIB MKLVM \
 	MKMAN MKMANDOC \
 	MKMDNS \
 	MKMAKEMANDB \
 	MKNLS \
 	MKNPF \
 	MKOBJ \
 	MKPAM MKPERFUSE \
 	MKPF MKPIC MKPICLIB MKPOSTFIX MKPROFILE \
 	MKRUMP \
 	MKSHARE MKSKEY MKSTATICLIB \
 	MKUNBOUND \
 	MKX11FONTS \
 	MKYP
 .for var in ${_MKVARS.yes}
 ${var}?=	${${var}.${MACHINE_ARCH}:Uyes}
 .endfor
+#
 # MKGCCCMDS is only valid if we are building GCC so make it dependent on that.
+#
 _MKVARS.yes += MKGCCCMDS
 MKGCCCMDS?=	${MKGCC}
+#
 # Sanitizers, only "address" and "undefined" are supported by gcc
+#
 MKSANITIZER?=	no
 USE_SANITIZER?=	address
+#
 # Sanitizers implemented in libc, only "undefined" is supported
+#
 MKLIBCSANITIZER?=	no
 USE_LIBCSANITIZER?=	undefined
+#
 # Exceptions to the above:
+#
 # RUMP uses -nostdinc which coverity does not like
 # It also does not use many new files, so disable it
 .if defined(COVERITY_TOP_CONFIG)
 MKRUMP=		no
 .endif
+#
 # Build a dynamically linked /bin and /sbin, with the necessary shared
 # libraries moved from /usr/lib to /lib and the shared linker moved
 # from /usr/libexec to /lib
+#
 # Note that if the BINDIR is not /bin or /sbin, then we always use the
 # non-DYNAMICROOT behavior (i.e. it is only enabled for programs in /bin
 # and /sbin).  See <bsd.shlib.mk>.
+#
 # For ia64, ld.elf_so not yet implemented
 .if ${MACHINE_ARCH} == "ia64"
 MKDYNAMICROOT=	no
 .endif
 .if defined(MKREPRO)
 MKARZERO ?= ${MKREPRO}
 GROFF_FLAGS ?= -dpaper=letter
 ROFF_PAGESIZE ?= -P-pletter
 .endif
+#
 # Install the kernel as /netbsd/kernel and the modules in /netbsd/modules
+#
 KERNEL_DIR?=	no
 # Only install the general firmware on some systems
 MKFIRMWARE.amd64=		yes
 MKFIRMWARE.cobalt=		yes
 MKFIRMWARE.evbarm=		yes
 MKFIRMWARE.evbmips=		yes
 MKFIRMWARE.evbppc=		yes
 MKFIRMWARE.hpcarm=		yes
 MKFIRMWARE.hppa=		yes
 MKFIRMWARE.i386=		yes
 MKFIRMWARE.mac68k=		yes
 MKFIRMWARE.macppc=		yes
 MKFIRMWARE.sandpoint=		yes
 MKFIRMWARE.sparc64=		yes
 # Only install the GPU firmware on DRM-happy systems.
 MKNOUVEAUFIRMWARE.x86_64=	yes
 MKNOUVEAUFIRMWARE.i386=		yes
 MKNOUVEAUFIRMWARE.aarch64=	yes
 MKRADEONFIRMWARE.x86_64=	yes
 MKRADEONFIRMWARE.i386=		yes
 MKRADEONFIRMWARE.aarch64=	yes
 MKAMDGPUFIRMWARE.x86_64=	yes
 MKAMDGPUFIRMWARE.i386=		yes
 # Only install the tegra firmware on evbarm.
 MKTEGRAFIRMWARE.evbarm=		yes
 # Only build devicetree (dtb) files on armv6, armv7, and aarch64.
 MKDTB.aarch64=			yes
 MKDTB.aarch64eb=		yes
 MKDTB.earmv6=			yes
 MKDTB.earmv6hf=			yes
 MKDTB.earmv6eb=			yes
 MKDTB.earmv6hfeb=		yes
 MKDTB.earmv7=			yes
 MKDTB.earmv7hf=			yes
 MKDTB.earmv7eb=			yes
 MKDTB.earmv7hfeb=		yes
 MKDTB.riscv32=			yes
 MKDTB.riscv64=			yes
 HAVE_MESA_VER?=	19
 .if ${HAVE_MESA_VER} == 19
 EXTERNAL_MESALIB_DIR?=	MesaLib.old
 .elif ${HAVE_MESA_VER} == 21
 EXTERNAL_MESALIB_DIR?=	MesaLib
 .endif
 # Default to LLVM run-time if x86 or aarch64 and X11 and Mesa 18 or newer
 # XXX This knows that MKX11=no is default below, but would
 # require splitting the below loop in two parts.
 .if ${MKX11:Uno} != "no" && ${HAVE_MESA_VER} >= 19
 MKLLVMRT.amd64=		yes
 MKLLVMRT.i386=		yes
 MKLLVMRT.aarch64=	yes
 .endif
 # Just-in-time compiler for bpf, npf acceleration
 MKSLJIT.aarch64=	yes
 MKSLJIT.i386=		yes
 MKSLJIT.sparc=		yes
 #MKSLJIT.sparc64=	yes	# not suppored in sljit (yet?)
 MKSLJIT.x86_64=		yes
 #MKSLJIT.powerpc=	yes	# XXX
 #MKSLJIT.powerpc64=	yes	# XXX
 #MKSLJIT.mipsel=	yes	# XXX
 #MKSLJIT.mipseb=	yes	# XXX
 #MKSLJIT.mips64el=	yes	# XXX
 #MKSLJIT.mips64eb=	yes	# XXX
 #MKSLJIT.riscv32=	yes	# not until we update sljit
 #MKSLJIT.riscv64=	yes	# not until we update sljit
 # compat with old names
 MKDEBUGKERNEL?=${MKKDEBUG:Uno}
 MKDEBUGTOOLS?=${MKTOOLSDEBUG:Uno}
+#
 # MK* options which default to "no".  Note that MKZFS has a different
 # default for some platforms, see above.  Please keep alphabetically
 # sorted with at most one letter per line.
+#
 _MKVARS.no= \
 	MKAMDGPUFIRMWARE \
 	MKARZERO \
 	MKBSDGREP \
 	MKCATPAGES MKCOMPATTESTS MKCOMPATX11 MKCTF \
 	MKDEBUG MKDEBUGLIB MKDTB MKDTRACE \
 	MKFIRMWARE \
 	MKGROFFHTMLDOC \
 	MKKYUA \
 	MKLIBCXX MKLLD MKLLDB MKLLVM MKLLVMRT MKLINT \
 	MKMANZ MKMCLINKER \
 	MKNOUVEAUFIRMWARE MKNSD \
 	MKOBJDIRS \
 	MKPCC MKPICINSTALL MKPIGZGZIP \
 	MKRADEONFIRMWARE MKREPRO \
 	MKSLJIT MKSOFTFLOAT MKSTRIPIDENT \
 	MKTEGRAFIRMWARE MKTPM \
 	MKUNPRIVED MKUPDATE \
 	MKX11 MKX11MOTIF MKXORG_SERVER \
 	MKZFS
 .for var in ${_MKVARS.no}
 ${var}?=	${${var}.${MACHINE_ARCH}:U${${var}.${MACHINE}:Uno}}
 .endfor
 .if ${MACHINE_ARCH} == "i386" || \
     ${MACHINE_ARCH} == "x86_64" || \
     ${MACHINE_ARCH} == "sparc"
 MKSLJIT=	yes
 .endif
+#
 # Which platforms build the xorg-server drivers (as opposed
 # to just Xnest and Xvfb.)
+#
 .if ${MACHINE} == "alpha"	|| \
     ${MACHINE} == "amd64"	|| \
     ${MACHINE} == "amiga"	|| \
     ${MACHINE} == "bebox"	|| \
     ${MACHINE} == "cats"	|| \
     ${MACHINE} == "dreamcast"	|| \
     ${MACHINE} == "ews4800mips"	|| \
     ${MACHINE} == "evbarm"	|| \
     ${MACHINE} == "evbmips"	|| \
     ${MACHINE} == "evbppc"	|| \
     ${MACHINE} == "hp300"	|| \
     ${MACHINE} == "hpcarm"	|| \
     ${MACHINE} == "hpcmips"	|| \
     ${MACHINE} == "hpcsh"	|| \
     ${MACHINE} == "hppa"	|| \
     ${MACHINE} == "i386"	|| \
     ${MACHINE} == "ibmnws"	|| \
     ${MACHINE} == "iyonix"	|| \
     ${MACHINE} == "luna68k"	|| \
     ${MACHINE} == "mac68k"	|| \
     ${MACHINE} == "macppc"	|| \
     ${MACHINE} == "netwinder"	|| \
     ${MACHINE} == "newsmips"	|| \
     ${MACHINE} == "pmax"	|| \
     ${MACHINE} == "prep"	|| \
     ${MACHINE} == "ofppc"	|| \
     ${MACHINE} == "sgimips"	|| \
     ${MACHINE} == "shark"	|| \
     ${MACHINE} == "sparc"	|| \
     ${MACHINE} == "sparc64"	|| \
     ${MACHINE} == "vax"		|| \
     ${MACHINE} == "zaurus"
 MKXORG_SERVER=yes
 .endif
+#
 # Force some options off if their dependencies are off.
+#
 .if ${MKCXX} == "no"
 MKATF:=		no
 MKGCCCMDS:=	no
 MKGDB:=		no
 MKGROFF:=	no
 MKKYUA:=	no
 .endif
 .if ${MKMAN} == "no"
 MKCATPAGES:=	no
 MKHTML:=	no
 .endif
 _MANINSTALL=	maninstall
 .if ${MKCATPAGES} != "no"
 _MANINSTALL+=	catinstall
 .endif
 .if ${MKHTML} != "no"
 _MANINSTALL+=	htmlinstall
 .endif
 .if ${MKLINKLIB} == "no"
 MKLINT:=	no
 MKPICINSTALL:=	no
 MKPROFILE:=	no
 .endif
 .if ${MKPIC} == "no"
 MKPICLIB:=	no
 .endif
 .if ${MKOBJ} == "no"
 MKOBJDIRS:=	no
 .endif
 .if ${MKSHARE} == "no"
 MKCATPAGES:=	no
 MKDOC:=		no
 MKINFO:=	no
 MKHTML:=	no
 MKMAN:=		no
 MKNLS:=		no
 .endif
 .if !empty(MACHINE_ARCH:Mearm*)
 _NEEDS_LIBCXX.${MACHINE_ARCH}=	yes
 .endif
 _NEEDS_LIBCXX.aarch64=		yes
 _NEEDS_LIBCXX.aarch64eb=	yes
 _NEEDS_LIBCXX.i386=		yes
 _NEEDS_LIBCXX.powerpc=		yes
 _NEEDS_LIBCXX.powerpc64=	yes
 _NEEDS_LIBCXX.sparc=		yes
 _NEEDS_LIBCXX.sparc64=		yes
 _NEEDS_LIBCXX.x86_64=		yes
 .if ${MKLLVM} == "yes" && ${_NEEDS_LIBCXX.${MACHINE_ARCH}:Uno} == "yes"
 MKLIBCXX:=	yes
 .endif
+#
 # Disable MKSTRIPSYM if MKDEBUG is enabled.
+#
 .if ${MKDEBUG} != "no"
 MKSTRIPSYM:=	no
 .endif
+#
 # install(1) parameters.
+#
 COPY?=		-c
 .if ${MKUPDATE} == "no"
 PRESERVE?=
 .else
 PRESERVE?=	-p
 .endif
 RENAME?=	-r
 HRDLINK?=	-l h
 SYMLINK?=	-l s
 METALOG?=	${DESTDIR}/METALOG
 METALOG.add?=	${TOOL_CAT} -l >> ${METALOG}
 .if (${_SRC_TOP_} != "")	# only set INSTPRIV if inside ${NETBSDSRCDIR}
 .if ${MKUNPRIVED} != "no"
 INSTPRIV.unpriv=-U -M ${METALOG} -D ${DESTDIR} -h sha256
 .else
 INSTPRIV.unpriv=
 .endif
 INSTPRIV?=	${INSTPRIV.unpriv} -N ${NETBSDSRCDIR}/etc
 .endif
 STRIPFLAG?=
 INSTALL_DIR?=		${INSTALL} ${INSTPRIV} -d
 INSTALL_FILE?=		${INSTALL} ${INSTPRIV} ${COPY} ${PRESERVE} ${RENAME}
 INSTALL_LINK?=		${INSTALL} ${INSTPRIV} ${HRDLINK} ${RENAME}
 INSTALL_SYMLINK?=	${INSTALL} ${INSTPRIV} ${SYMLINK} ${RENAME}
 # for crunchide & ldd, define the OBJECT_FMTS used by a MACHINE_ARCH
+#
 OBJECT_FMTS=
 .if	${MACHINE_ARCH} != "alpha" && ${MACHINE_ARCH} != "ia64"
 OBJECT_FMTS+=	elf32
 .endif
 .if	${MACHINE_ARCH} == "alpha" || ${MACHINE_ARCH:M*64*} != ""
 . if !(${MKCOMPAT:Uyes} == "no" && ${MACHINE_CPU} == "mips")
 OBJECT_FMTS+=	elf64
 . endif
 .endif
+#
 # Set defaults for the USE_xxx variables.
+#
+#
 # USE_* options which default to "no" and will be forced to "no" if their
 # corresponding MK* variable is set to "no".
+#
 .for var in USE_SKEY
 .if (${${var:S/USE_/MK/}} == "no")
 ${var}:= no
 .else
 ${var}?= no
 .endif
 .endfor
+#
 # USE_* options which default to "yes" unless their corresponding MK*
 # variable is set to "no".
+#
 .for var in USE_HESIOD USE_INET6 USE_KERBEROS USE_LDAP USE_PAM USE_YP
 .if (${${var:S/USE_/MK/}} == "no")
 ${var}:= no
 .else
 ${var}?= yes
 .endif
 .endfor
+#
 # USE_* options which default to "yes".
+#
 .for var in USE_JEMALLOC
 ${var}?= yes
 .endfor
+#
 # USE_* options which default to "no".
+#
 # For now, disable pigz as compressor by default
 .for var in USE_PIGZGZIP
 ${var}?= no
 .endfor
 # Default to USE_XZ_SETS on some 64bit architectures where decompressor
 # memory will likely not be in short supply.
 # Since pigz can not create .xz format files currently, disable .xz
 # format if USE_PIGZGZIP is enabled.
 .if ${USE_PIGZGZIP} == "no" && \
     (${MACHINE} == "amd64" || \
      ${MACHINE} == "sparc64" || \
      !empty(MACHINE_ARCH:Maarch64*))
 USE_XZ_SETS?= yes
 .else
 USE_XZ_SETS?= no
 .endif
+#
 # TOOL_GZIP and friends.  These might refer to TOOL_PIGZ or to the host gzip.
+#
 .if ${USE_PIGZGZIP} != "no"
 TOOL_GZIP=		${TOOL_PIGZ}
 GZIP_N_FLAG?=		-nT
 .else
 TOOL_GZIP=		gzip
 GZIP_N_FLAG?=		-n
 .endif
 TOOL_GZIP_N=		${TOOL_GZIP} ${GZIP_N_FLAG}
+#
 # Where X11 sources are and where it is installed to.
+#
 .if !defined(X11SRCDIR)
 .if exists(${NETBSDSRCDIR}/../xsrc)
 X11SRCDIR!=		cd "${NETBSDSRCDIR}/../xsrc" && pwd
 .else
 X11SRCDIR=		/usr/xsrc
 .endif
 .endif # !defined(X11SRCDIR)
 X11SRCDIR.local?=	${X11SRCDIR}/local
 X11ROOTDIR?=		/usr/X11R7
 X11BINDIR?=		${X11ROOTDIR}/bin
 X11ETCDIR?=		/etc/X11
 X11FONTDIR?=		${X11ROOTDIR}/lib/X11/fonts
 X11INCDIR?=		${X11ROOTDIR}/include
 X11LIBDIR?=		${X11ROOTDIR}/lib/X11
 X11MANDIR?=		${X11ROOTDIR}/man
 X11SHAREDIR?=		${X11ROOTDIR}/share
 X11USRLIBDIR?=		${X11ROOTDIR}/lib${MLIBDIR:D/${MLIBDIR}}
+#
 # New modular-xorg based builds
+#
 X11SRCDIRMIT?=		${X11SRCDIR}/external/mit
 .for _lib in \
 	FS ICE SM X11 XScrnSaver XTrap Xau Xcomposite Xcursor Xdamage \
 	Xdmcp Xevie Xext Xfixes Xfont Xfont2 Xft Xi Xinerama Xmu Xpresent Xpm \
 	Xrandr Xrender Xres Xt Xtst Xv XvMC Xxf86dga Xxf86misc Xxf86vm drm \
 	epoxy fontenc vdpau xkbfile xkbui Xaw pciaccess xcb xshmfence \
 	pthread-stubs xcvt
 X11SRCDIR.${_lib}?=		${X11SRCDIRMIT}/lib${_lib}/dist
 .endfor
 .for _proto in \
 	xcb- xorg
 X11SRCDIR.${_proto}proto?=		${X11SRCDIRMIT}/${_proto}proto/dist
 .endfor
 # During transition from xorg-server 1.10 to 1.20
 .if \
     ${MACHINE} == "alpha"	|| \
     ${MACHINE} == "netwinder"	|| \
     ${MACHINE} == "sgimips"	|| \
     ${MACHINE} == "vax"
 HAVE_XORG_SERVER_VER?=110
 .else
 HAVE_XORG_SERVER_VER?=120
 .endif
 .if ${HAVE_XORG_SERVER_VER} == "120"
 XORG_SERVER_SUBDIR?=xorg-server
 . if ${MACHINE} == "amd64" || ${MACHINE} == "i386" || ${MACHINE} == "evbarm"
 HAVE_XORG_GLAMOR?=	yes
 . endif
 .else
 XORG_SERVER_SUBDIR?=xorg-server.old
 .endif
 X11SRCDIR.xorg-server?=		${X11SRCDIRMIT}/${XORG_SERVER_SUBDIR}/dist
 HAVE_XORG_GLAMOR?=	no
 # Build glamor extension?
 .for _dir in \
 	xtrans fontconfig freetype evieext mkfontscale bdftopcf \
 	xorg-cf-files imake xbiff xkeyboard-config \
 	xcompmgr xbitmaps appres xeyes xev xedit sessreg pixman \
 	beforelight bitmap editres makedepend fonttosfnt fslsfonts fstobdf \
 	glu glw mesa-demos MesaGLUT MesaLib MesaLib.old MesaLib7 \
 	ico iceauth listres lndir \
 	luit xproxymanagementprotocol mkfontdir oclock proxymngr rgb \
 	rstart setxkbmap showfont smproxy transset twm viewres \
 	util-macros \
 	x11perf xauth xcalc xclipboard \
 	xclock xcmsdb xconsole xditview xdpyinfo xdriinfo xdm \
 	xfd xf86dga xfindproxy xfontsel xfwp xgamma xgc xhost xinit \
 	xkill xload xlogo xlsatoms xlsclients xlsfonts xmag xmessage \
 	xmh xmodmap xmore xman xprop xrandr xrdb xrefresh xset \
 	xsetmode xsetpointer xsetroot xsm xstdcmap xvidtune xvinfo \
 	xwininfo xwud xkbprint xkbevd \
 	xterm xwd xfs xfsinfo xtrap xkbutils xkbcomp \
 	xinput xcb-util xorg-docs \
 	font-adobe-100dpi font-adobe-75dpi font-adobe-utopia-100dpi \
 	font-adobe-utopia-75dpi font-adobe-utopia-type1 \
 	font-alias \
 	font-bh-100dpi font-bh-75dpi font-bh-lucidatypewriter-100dpi \
 	font-bh-lucidatypewriter-75dpi font-bh-ttf font-bh-type1 \
 	font-bitstream-100dpi font-bitstream-75dpi font-bitstream-type1 \
 	font-cursor-misc font-daewoo-misc font-dec-misc font-ibm-type1 \
 	font-isas-misc font-jis-misc font-misc-misc font-mutt-misc \
 	font-sony-misc font-util ttf-bitstream-vera encodings
 X11SRCDIR.${_dir}?=		${X11SRCDIRMIT}/${_dir}/dist
 .endfor
 # X11SRCDIR.Mesa points to the currently used Mesa sources
 X11SRCDIR.Mesa?=		${X11SRCDIRMIT}/${EXTERNAL_MESALIB_DIR}/dist
 .for _i in \
 	elographics keyboard mouse synaptics vmmouse void ws
 X11SRCDIR.xf86-input-${_i}?=	${X11SRCDIRMIT}/xf86-input-${_i}/dist
 .endfor
 # xf86-video-modesetting move into the server build.
 EXTRA_DRIVERS=
 .if ${HAVE_XORG_SERVER_VER} == "120"
 X11SRCDIR.xf86-video-modesetting=${X11SRCDIR.xorg-server}/hw/xfree86/drivers/modesetting
 .else
 EXTRA_DRIVERS=	modesetting
 .endif
 .for _v in \
 	ag10e amdgpu apm ark ast ati ati-kms chips cirrus crime \
 	geode glint i128 i740 igs imstt intel intel-old intel-2014 \
 	${EXTRA_DRIVERS} mach64 mga \
 	neomagic newport nouveau nsc nv openchrome pnozz \
 	r128 rendition \
 	s3 s3virge savage siliconmotion sis suncg14 \
 	suncg6 sunffb sunleo suntcx \
 	tdfx tga trident tseng vboxvideo vesa vga vmware wsfb xgi
 X11SRCDIR.xf86-video-${_v}?=	${X11SRCDIRMIT}/xf86-video-${_v}/dist
 .endfor
 X11DRI?=			yes
 X11LOADABLE?=			yes
+#
 # MAKEDIRTARGET dir target [extra make(1) params]
 #	run "cd $${dir} && ${MAKEDIRTARGETENV} ${MAKE} [params] $${target}", with a pretty message
+#
 MAKEDIRTARGETENV?=
 MAKEDIRTARGET=\
 	@_makedirtarget() { \
 		dir="$$1"; shift; \
 		target="$$1"; shift; \
 		case "$${dir}" in \
 		/*)	this="$${dir}/"; \
 			real="$${dir}" ;; \
 		.)	this="${_THISDIR_}"; \
 			real="${.CURDIR}" ;; \
 		*)	this="${_THISDIR_}$${dir}/"; \
 			real="${.CURDIR}/$${dir}" ;; \
 		esac; \
 		show=$${this:-.}; \
 		echo "$${target} ===> $${show%/}$${1:+	(with: $$@)}"; \
 		cd "$${real}" \
 		&& ${MAKEDIRTARGETENV} ${MAKE} _THISDIR_="$${this}" "$$@" $${target}; \
 	}; \
 	_makedirtarget
+#
 # MAKEVERBOSE support.  Levels are:
 #	0	Minimal output ("quiet")
 #	1	Describe what is occurring
 #	2	Describe what is occurring and echo the actual command
 #	3	Ignore the effect of the "@" prefix in make commands
 #	4	Trace shell commands using the shell's -x flag
+#
 MAKEVERBOSE?=		2
 .if ${MAKEVERBOSE} == 0
 _MKMSG?=	@\#
 _MKSHMSG?=	: echo
 _MKSHECHO?=	: echo
 .SILENT:
 .elif ${MAKEVERBOSE} == 1
 _MKMSG?=	@echo '   '
 _MKSHMSG?=	echo '   '
 _MKSHECHO?=	: echo
 .SILENT:
 .else	# MAKEVERBOSE >= 2
 _MKMSG?=	@echo '\#  '
 _MKSHMSG?=	echo '\#  '
 _MKSHECHO?=	echo
 .SILENT: __makeverbose_dummy_target__
 .endif	# MAKEVERBOSE >= 2
 .if ${MAKEVERBOSE} >= 3
 .MAKEFLAGS:	-dl
 .endif	# ${MAKEVERBOSE} >= 3
 .if ${MAKEVERBOSE} >= 4
 .MAKEFLAGS:	-dx
 .endif	# ${MAKEVERBOSE} >= 4
 _MKMSG_BUILD?=		${_MKMSG} "  build "
 _MKMSG_CREATE?=		${_MKMSG} " create "
 _MKMSG_COMPILE?=	${_MKMSG} "compile "
 _MKMSG_FORMAT?=		${_MKMSG} " format "
 _MKMSG_INSTALL?=	${_MKMSG} "install "
 _MKMSG_LINK?=		${_MKMSG} "   link "
 _MKMSG_LEX?=		${_MKMSG} "    lex "
 _MKMSG_REMOVE?=		${_MKMSG} " remove "
 _MKMSG_YACC?=		${_MKMSG} "   yacc "
 _MKSHMSG_CREATE?=	${_MKSHMSG} " create "
 _MKSHMSG_INSTALL?=	${_MKSHMSG} "install "
 _MKTARGET_BUILD?=	${_MKMSG_BUILD} ${.CURDIR:T}/${.TARGET}
 _MKTARGET_CREATE?=	${_MKMSG_CREATE} ${.CURDIR:T}/${.TARGET}
 _MKTARGET_COMPILE?=	${_MKMSG_COMPILE} ${.CURDIR:T}/${.TARGET}
 _MKTARGET_FORMAT?=	${_MKMSG_FORMAT} ${.CURDIR:T}/${.TARGET}
 _MKTARGET_INSTALL?=	${_MKMSG_INSTALL} ${.TARGET}
 _MKTARGET_LINK?=	${_MKMSG_LINK} ${.CURDIR:T}/${.TARGET}
 _MKTARGET_LEX?=		${_MKMSG_LEX} ${.CURDIR:T}/${.TARGET}
 _MKTARGET_REMOVE?=	${_MKMSG_REMOVE} ${.TARGET}
 _MKTARGET_YACC?=	${_MKMSG_YACC} ${.CURDIR:T}/${.TARGET}
 .if ${MKMANDOC} == "yes"
 TARGETS+=	lintmanpages
 .endif
 TESTSBASE=	/usr/tests${MLIBDIR:D/${MLIBDIR}}
 # Override with tools versions if needed
 .if ${MKCTF:Uno} != "no" && !defined(NOCTF) && \
     (exists(${TOOL_CTFCONVERT}) || exists(/usr/bin/${TOOL_CTFCONVERT}))
 CTFCONVERT=	${TOOL_CTFCONVERT}
 CTFMERGE=	${TOOL_CTFMERGE}
 .endif
 .endif	# !defined(_BSD_OWN_MK_)

 @@ -1,2056 +1,2060 @@
-/*	$NetBSD: sljitNativeARM_64.c,v 1.4 2019/01/20 23:14:16 alnsn Exp $	*/
+/*	$NetBSD: sljitNativeARM_64.c,v 1.4.30.1 2024/04/18 15:21:55 martin Exp $	*/
 /*
  *    Stack-less Just-In-Time compiler
+ *
  *    Copyright Zoltan Herczeg (hzmester@freemail.hu). All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without modification, are
  * permitted provided that the following conditions are met:
+ *
  *   1. Redistributions of source code must retain the above copyright notice, this list of
  *      conditions and the following disclaimer.
+ *
  *   2. Redistributions in binary form must reproduce the above copyright notice, this list
  *      of conditions and the following disclaimer in the documentation and/or other materials
  *      provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDER(S) AND CONTRIBUTORS ``AS IS'' AND ANY
  * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED WARRANTIES
  * OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE DISCLAIMED. IN NO EVENT
  * SHALL THE COPYRIGHT HOLDER(S) OR CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT,
  * INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED
  * TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR
  * BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN
  * ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 SLJIT_API_FUNC_ATTRIBUTE const char* sljit_get_platform_name(void)
+{
 	return "ARM-64" SLJIT_CPUINFO;
+}
 /* Length of an instruction word */
 typedef sljit_u32 sljit_ins;
 #define TMP_ZERO	(0)
 #define TMP_REG1	(SLJIT_NUMBER_OF_REGISTERS + 2)
 #define TMP_REG2	(SLJIT_NUMBER_OF_REGISTERS + 3)
 #define TMP_REG3	(SLJIT_NUMBER_OF_REGISTERS + 4)
 #define TMP_LR		(SLJIT_NUMBER_OF_REGISTERS + 5)
 #define TMP_SP		(SLJIT_NUMBER_OF_REGISTERS + 6)
 #define TMP_FREG1	(0)
 #define TMP_FREG2	(SLJIT_NUMBER_OF_FLOAT_REGISTERS + 1)
 static const sljit_u8 reg_map[SLJIT_NUMBER_OF_REGISTERS + 8] = {
 , 0, 1, 2, 3, 4, 5, 6, 7, 12, 13, 14, 15, 16, 17, 8, 28, 27, 26, 25, 24, 23, 22, 21, 20, 19, 29, 9, 10, 11, 30, 31
 };
 #define W_OP (1 << 31)
 #define RD(rd) (reg_map[rd])
 #define RT(rt) (reg_map[rt])
 #define RN(rn) (reg_map[rn] << 5)
 #define RT2(rt2) (reg_map[rt2] << 10)
 #define RM(rm) (reg_map[rm] << 16)
 #define VD(vd) (vd)
 #define VT(vt) (vt)
 #define VN(vn) ((vn) << 5)
 #define VM(vm) ((vm) << 16)
 /* --------------------------------------------------------------------- */
 /*  Instrucion forms                                                     */
 /* --------------------------------------------------------------------- */
 #define ADC 0x9a000000
 #define ADD 0x8b000000
 #define ADDI 0x91000000
 #define AND 0x8a000000
 #define ANDI 0x92000000
 #define ASRV 0x9ac02800
 #define B 0x14000000
 #define B_CC 0x54000000
 #define BL 0x94000000
 #define BLR 0xd63f0000
 #define BR 0xd61f0000
 #define BRK 0xd4200000
 #define CBZ 0xb4000000
 #define CLZ 0xdac01000
 #define CSINC 0x9a800400
 #define EOR 0xca000000
 #define EORI 0xd2000000
 #define FABS 0x1e60c000
 #define FADD 0x1e602800
 #define FCMP 0x1e602000
 #define FCVT 0x1e224000
 #define FCVTZS 0x9e780000
 #define FDIV 0x1e601800
 #define FMOV 0x1e604000
 #define FMUL 0x1e600800
 #define FNEG 0x1e614000
 #define FSUB 0x1e603800
 #define LDRI 0xf9400000
 #define LDP 0xa9400000
 #define LDP_PST 0xa8c00000
 #define LSLV 0x9ac02000
 #define LSRV 0x9ac02400
 #define MADD 0x9b000000
 #define MOVK 0xf2800000
 #define MOVN 0x92800000
 #define MOVZ 0xd2800000
 #define NOP 0xd503201f
 #define ORN 0xaa200000
 #define ORR 0xaa000000
 #define ORRI 0xb2000000
 #define RET 0xd65f0000
 #define SBC 0xda000000
 #define SBFM 0x93000000
 #define SCVTF 0x9e620000
 #define SDIV 0x9ac00c00
 #define SMADDL 0x9b200000
 #define SMULH 0x9b403c00
 #define STP 0xa9000000
 #define STP_PRE 0xa9800000
 #define STRI 0xf9000000
 #define STR_FI 0x3d000000
 #define STR_FR 0x3c206800
 #define STUR_FI 0x3c000000
 #define SUB 0xcb000000
 #define SUBI 0xd1000000
 #define SUBS 0xeb000000
 #define UBFM 0xd3000000
 #define UDIV 0x9ac00800
 #define UMULH 0x9bc03c00
 /* dest_reg is the absolute name of the register
    Useful for reordering instructions in the delay slot. */
 static sljit_s32 push_inst(struct sljit_compiler *compiler, sljit_ins ins)
+{
 	sljit_ins *ptr = (sljit_ins*)ensure_buf(compiler, sizeof(sljit_ins));
 	FAIL_IF(!ptr);
 	*ptr = ins;
 	compiler->size++;
 	return SLJIT_SUCCESS;
+}
 static SLJIT_INLINE sljit_s32 emit_imm64_const(struct sljit_compiler *compiler, sljit_s32 dst, sljit_uw imm)
+{
 	FAIL_IF(push_inst(compiler, MOVZ | RD(dst) | ((imm & 0xffff) << 5)));
 	FAIL_IF(push_inst(compiler, MOVK | RD(dst) | (((imm >> 16) & 0xffff) << 5) | (1 << 21)));
 	FAIL_IF(push_inst(compiler, MOVK | RD(dst) | (((imm >> 32) & 0xffff) << 5) | (2 << 21)));
 	return push_inst(compiler, MOVK | RD(dst) | ((imm >> 48) << 5) | (3 << 21));
+}
 static SLJIT_INLINE void modify_imm64_const(sljit_ins* inst, sljit_uw new_imm)
+{
 	sljit_s32 dst = inst[0] & 0x1f;
 	SLJIT_ASSERT((inst[0] & 0xffe00000) == MOVZ && (inst[1] & 0xffe00000) == (MOVK | (1 << 21)));
 	inst[0] = MOVZ | dst | ((new_imm & 0xffff) << 5);
 	inst[1] = MOVK | dst | (((new_imm >> 16) & 0xffff) << 5) | (1 << 21);
 	inst[2] = MOVK | dst | (((new_imm >> 32) & 0xffff) << 5) | (2 << 21);
 	inst[3] = MOVK | dst | ((new_imm >> 48) << 5) | (3 << 21);
+}
 static SLJIT_INLINE sljit_s32 detect_jump_type(struct sljit_jump *jump, sljit_ins *code_ptr, sljit_ins *code, sljit_sw executable_offset)
+{
 	sljit_sw diff;
 	sljit_uw target_addr;
 	if (jump->flags & SLJIT_REWRITABLE_JUMP) {
 		jump->flags |= PATCH_ABS64;
 		return 0;
+	}
 	if (jump->flags & JUMP_ADDR)
 		target_addr = jump->u.target;
 	else {
 		SLJIT_ASSERT(jump->flags & JUMP_LABEL);
 		target_addr = (sljit_uw)(code + jump->u.label->size) + (sljit_uw)executable_offset;
+	}
 	diff = (sljit_sw)target_addr - (sljit_sw)(code_ptr + 4) - executable_offset;
 	if (jump->flags & IS_COND) {
 		diff += sizeof(sljit_ins);
 		if (diff <= 0xfffff && diff >= -0x100000) {
 			code_ptr[-5] ^= (jump->flags & IS_CBZ) ? (0x1 << 24) : 0x1;
 			jump->addr -= sizeof(sljit_ins);
 			jump->flags |= PATCH_COND;
 			return 5;
+		}
 		diff -= sizeof(sljit_ins);
+	}
 	if (diff <= 0x7ffffff && diff >= -0x8000000) {
 		jump->flags |= PATCH_B;
 		return 4;
+	}
 	if (target_addr <= 0xffffffffl) {
 		if (jump->flags & IS_COND)
 			code_ptr[-5] -= (2 << 5);
 		code_ptr[-2] = code_ptr[0];
 		return 2;
+	}
 	if (target_addr <= 0xffffffffffffl) {
 		if (jump->flags & IS_COND)
 			code_ptr[-5] -= (1 << 5);
 		jump->flags |= PATCH_ABS48;
 		code_ptr[-1] = code_ptr[0];
 		return 1;
+	}
 	jump->flags |= PATCH_ABS64;
 	return 0;
+}
 SLJIT_API_FUNC_ATTRIBUTE void* sljit_generate_code(struct sljit_compiler *compiler)
+{
 	struct sljit_memory_fragment *buf;
 	sljit_ins *code;
 	sljit_ins *code_ptr;
 	sljit_ins *buf_ptr;
 	sljit_ins *buf_end;
 	sljit_uw word_count;
 	sljit_sw executable_offset;
 	sljit_uw addr;
 	sljit_s32 dst;
 	struct sljit_label *label;
 	struct sljit_jump *jump;
 	struct sljit_const *const_;
 	CHECK_ERROR_PTR();
 	CHECK_PTR(check_sljit_generate_code(compiler));
 	reverse_buf(compiler);
 	code = (sljit_ins*)SLJIT_MALLOC_EXEC(compiler->size * sizeof(sljit_ins));
 	PTR_FAIL_WITH_EXEC_IF(code);
 	buf = compiler->buf;
 	code_ptr = code;
 	word_count = 0;
 	executable_offset = SLJIT_EXEC_OFFSET(code);
 	label = compiler->labels;
 	jump = compiler->jumps;
 	const_ = compiler->consts;
 	do {
 		buf_ptr = (sljit_ins*)buf->memory;
 		buf_end = buf_ptr + (buf->used_size >> 2);
 		do {
 			*code_ptr = *buf_ptr++;
 			/* These structures are ordered by their address. */
 			SLJIT_ASSERT(!label || label->size >= word_count);
 			SLJIT_ASSERT(!jump || jump->addr >= word_count);
 			SLJIT_ASSERT(!const_ || const_->addr >= word_count);
 			if (label && label->size == word_count) {
 				label->addr = (sljit_uw)SLJIT_ADD_EXEC_OFFSET(code_ptr, executable_offset);
 				label->size = code_ptr - code;
 				label = label->next;
+			}
 			if (jump && jump->addr == word_count) {
 					jump->addr = (sljit_uw)(code_ptr - 4);
 					code_ptr -= detect_jump_type(jump, code_ptr, code, executable_offset);
 					jump = jump->next;
+			}
 			if (const_ && const_->addr == word_count) {
 				const_->addr = (sljit_uw)code_ptr;
 				const_ = const_->next;
+			}
 			code_ptr ++;
 			word_count ++;
 		} while (buf_ptr < buf_end);
 		buf = buf->next;
 	} while (buf);
 	if (label && label->size == word_count) {
 		label->addr = (sljit_uw)SLJIT_ADD_EXEC_OFFSET(code_ptr, executable_offset);
 		label->size = code_ptr - code;
 		label = label->next;
+	}
 	SLJIT_ASSERT(!label);
 	SLJIT_ASSERT(!jump);
 	SLJIT_ASSERT(!const_);
 	SLJIT_ASSERT(code_ptr - code <= (sljit_sw)compiler->size);
 	jump = compiler->jumps;
 	while (jump) {
 		do {
 			addr = (jump->flags & JUMP_LABEL) ? jump->u.label->addr : jump->u.target;
 			buf_ptr = (sljit_ins *)jump->addr;
 			if (jump->flags & PATCH_B) {
 				addr = (sljit_sw)(addr - (sljit_uw)SLJIT_ADD_EXEC_OFFSET(buf_ptr, executable_offset)) >> 2;
 				SLJIT_ASSERT((sljit_sw)addr <= 0x1ffffff && (sljit_sw)addr >= -0x2000000);
 				buf_ptr[0] = ((jump->flags & IS_BL) ? BL : B) | (addr & 0x3ffffff);
 				if (jump->flags & IS_COND)
 					buf_ptr[-1] -= (4 << 5);
 				break;
+			}
 			if (jump->flags & PATCH_COND) {
 				addr = (sljit_sw)(addr - (sljit_uw)SLJIT_ADD_EXEC_OFFSET(buf_ptr, executable_offset)) >> 2;
 				SLJIT_ASSERT((sljit_sw)addr <= 0x3ffff && (sljit_sw)addr >= -0x40000);
 				buf_ptr[0] = (buf_ptr[0] & ~0xffffe0) | ((addr & 0x7ffff) << 5);
 				break;
+			}
 			SLJIT_ASSERT((jump->flags & (PATCH_ABS48 | PATCH_ABS64)) || addr <= 0xffffffffl);
 			SLJIT_ASSERT((jump->flags & PATCH_ABS64) || addr <= 0xffffffffffffl);
 			dst = buf_ptr[0] & 0x1f;
 			buf_ptr[0] = MOVZ | dst | ((addr & 0xffff) << 5);
 			buf_ptr[1] = MOVK | dst | (((addr >> 16) & 0xffff) << 5) | (1 << 21);
 			if (jump->flags & (PATCH_ABS48 | PATCH_ABS64))
 				buf_ptr[2] = MOVK | dst | (((addr >> 32) & 0xffff) << 5) | (2 << 21);
 			if (jump->flags & PATCH_ABS64)
 				buf_ptr[3] = MOVK | dst | (((addr >> 48) & 0xffff) << 5) | (3 << 21);
 		} while (0);
 		jump = jump->next;
+	}
 	compiler->error = SLJIT_ERR_COMPILED;
 	compiler->executable_offset = executable_offset;
 	compiler->executable_size = (code_ptr - code) * sizeof(sljit_ins);
 	code = (sljit_ins *)SLJIT_ADD_EXEC_OFFSET(code, executable_offset);
 	code_ptr = (sljit_ins *)SLJIT_ADD_EXEC_OFFSET(code_ptr, executable_offset);
 	SLJIT_CACHE_FLUSH(code, code_ptr);
 	return code;
+}
 /* --------------------------------------------------------------------- */
 /*  Core code generator functions.                                       */
 /* --------------------------------------------------------------------- */
 #define COUNT_TRAILING_ZERO(value, result) \
 	result = 0; \
 	if (!(value & 0xffffffff)) { \
 		result += 32; \
 		value >>= 32; \
 	} \
 	if (!(value & 0xffff)) { \
 		result += 16; \
 		value >>= 16; \
 	} \
 	if (!(value & 0xff)) { \
 		result += 8; \
 		value >>= 8; \
 	} \
 	if (!(value & 0xf)) { \
 		result += 4; \
 		value >>= 4; \
 	} \
 	if (!(value & 0x3)) { \
 		result += 2; \
 		value >>= 2; \
 	} \
 	if (!(value & 0x1)) { \
 		result += 1; \
 		value >>= 1; \
+	}
 #define LOGICAL_IMM_CHECK 0x100
 static sljit_ins logical_imm(sljit_sw imm, sljit_s32 len)
+{
 	sljit_s32 negated, ones, right;
 	sljit_uw mask, uimm;
 	sljit_ins ins;
 	if (len & LOGICAL_IMM_CHECK) {
 		len &= ~LOGICAL_IMM_CHECK;
 		if (len == 32 && (imm == 0 || imm == -1))
 			return 0;
 		if (len == 16 && ((sljit_s32)imm == 0 || (sljit_s32)imm == -1))
 			return 0;
+	}
 	SLJIT_ASSERT((len == 32 && imm != 0 && imm != -1)
 		|| (len == 16 && (sljit_s32)imm != 0 && (sljit_s32)imm != -1));
 	uimm = (sljit_uw)imm;
 	while (1) {
 		if (len <= 0) {
 			SLJIT_UNREACHABLE();
 			return 0;
+		}
 		mask = ((sljit_uw)1 << len) - 1;
 		if ((uimm & mask) != ((uimm >> len) & mask))
 			break;
 		len >>= 1;
+	}
 	len <<= 1;
 	negated = 0;
 	if (uimm & 0x1) {
 		negated = 1;
 		uimm = ~uimm;
+	}
 	if (len < 64)
 		uimm &= ((sljit_uw)1 << len) - 1;
 	/* Unsigned right shift. */
 	COUNT_TRAILING_ZERO(uimm, right);
 	/* Signed shift. We also know that the highest bit is set. */
 	imm = (sljit_sw)~uimm;
 	SLJIT_ASSERT(imm < 0);
 	COUNT_TRAILING_ZERO(imm, ones);
 	if (~imm)
 		return 0;
 	if (len == 64)
 		ins = 1 << 22;
 	else
 		ins = (0x3f - ((len << 1) - 1)) << 10;
 	if (negated)
 		return ins | ((len - ones - 1) << 10) | ((len - ones - right) << 16);
 	return ins | ((ones - 1) << 10) | ((len - right) << 16);
+}
 #undef COUNT_TRAILING_ZERO
 static sljit_s32 load_immediate(struct sljit_compiler *compiler, sljit_s32 dst, sljit_sw simm)
+{
 	sljit_uw imm = (sljit_uw)simm;
 	sljit_s32 i, zeros, ones, first;
 	sljit_ins bitmask;
 	if (imm <= 0xffff)
 		return push_inst(compiler, MOVZ | RD(dst) | (imm << 5));
 	if (simm >= -0x10000 && simm < 0)
 		return push_inst(compiler, MOVN | RD(dst) | ((~imm & 0xffff) << 5));
 	if (imm <= 0xffffffffl) {
 		if ((imm & 0xffff0000l) == 0xffff0000)
 			return push_inst(compiler, (MOVN ^ W_OP) | RD(dst) | ((~imm & 0xffff) << 5));
 		if ((imm & 0xffff) == 0xffff)
 			return push_inst(compiler, (MOVN ^ W_OP) | RD(dst) | ((~imm & 0xffff0000l) >> (16 - 5)) | (1 << 21));
 		bitmask = logical_imm(simm, 16);
 		if (bitmask != 0)
 			return push_inst(compiler, (ORRI ^ W_OP) | RD(dst) | RN(TMP_ZERO) | bitmask);
+	}
 	else {
 		bitmask = logical_imm(simm, 32);
 		if (bitmask != 0)
 			return push_inst(compiler, ORRI | RD(dst) | RN(TMP_ZERO) | bitmask);
+	}
 	if (imm <= 0xffffffffl) {
 		FAIL_IF(push_inst(compiler, MOVZ | RD(dst) | ((imm & 0xffff) << 5)));
 		return push_inst(compiler, MOVK | RD(dst) | ((imm & 0xffff0000l) >> (16 - 5)) | (1 << 21));
+	}
 	if (simm >= -0x100000000l && simm < 0) {
 		FAIL_IF(push_inst(compiler, MOVN | RD(dst) | ((~imm & 0xffff) << 5)));
 		return push_inst(compiler, MOVK | RD(dst) | ((imm & 0xffff0000l) >> (16 - 5)) | (1 << 21));
+	}
 	/* A large amount of number can be constructed from ORR and MOVx,
 	but computing them is costly. We don't  */
 	zeros = 0;
 	ones = 0;
 	for (i = 4; i > 0; i--) {
 		if ((simm & 0xffff) == 0)
 			zeros++;
 		if ((simm & 0xffff) == 0xffff)
 			ones++;
 		simm >>= 16;
+	}
 	simm = (sljit_sw)imm;
 	first = 1;
 	if (ones > zeros) {
 		simm = ~simm;
 		for (i = 0; i < 4; i++) {
 			if (!(simm & 0xffff)) {
 				simm >>= 16;
 				continue;
+			}
 			if (first) {
 				first = 0;
 				FAIL_IF(push_inst(compiler, MOVN | RD(dst) | ((simm & 0xffff) << 5) | (i << 21)));
+			}
 			else
 				FAIL_IF(push_inst(compiler, MOVK | RD(dst) | ((~simm & 0xffff) << 5) | (i << 21)));
 			simm >>= 16;
+		}
 		return SLJIT_SUCCESS;
+	}
 	for (i = 0; i < 4; i++) {
 		if (!(simm & 0xffff)) {
 			simm >>= 16;
 			continue;
+		}
 		if (first) {
 			first = 0;
 			FAIL_IF(push_inst(compiler, MOVZ | RD(dst) | ((simm & 0xffff) << 5) | (i << 21)));
+		}
 		else
 			FAIL_IF(push_inst(compiler, MOVK | RD(dst) | ((simm & 0xffff) << 5) | (i << 21)));
 		simm >>= 16;
+	}
 	return SLJIT_SUCCESS;
+}
 #define ARG1_IMM	0x0010000
 #define ARG2_IMM	0x0020000
 #define INT_OP		0x0040000
 #define SET_FLAGS	0x0080000
 #define UNUSED_RETURN	0x0100000
 #define SLOW_DEST	0x0200000
 #define SLOW_SRC1	0x0400000
 #define SLOW_SRC2	0x0800000
 #define CHECK_FLAGS(flag_bits) \
 	if (flags & SET_FLAGS) { \
 		inv_bits |= flag_bits; \
 		if (flags & UNUSED_RETURN) \
 			dst = TMP_ZERO; \
+	}
 static sljit_s32 emit_op_imm(struct sljit_compiler *compiler, sljit_s32 flags, sljit_s32 dst, sljit_sw arg1, sljit_sw arg2)
+{
 	/* dst must be register, TMP_REG1
 	   arg1 must be register, TMP_REG1, imm
 	   arg2 must be register, TMP_REG2, imm */
 	sljit_ins inv_bits = (flags & INT_OP) ? (1 << 31) : 0;
 	sljit_ins inst_bits;
 	sljit_s32 op = (flags & 0xffff);
 	sljit_s32 reg;
 	sljit_sw imm, nimm;
 	if (SLJIT_UNLIKELY((flags & (ARG1_IMM | ARG2_IMM)) == (ARG1_IMM | ARG2_IMM))) {
 		/* Both are immediates. */
 		flags &= ~ARG1_IMM;
 		if (arg1 == 0 && op != SLJIT_ADD && op != SLJIT_SUB)
 			arg1 = TMP_ZERO;
 		else {
 			FAIL_IF(load_immediate(compiler, TMP_REG1, arg1));
 			arg1 = TMP_REG1;
+		}
+	}
 	if (flags & (ARG1_IMM | ARG2_IMM)) {
 		reg = (flags & ARG2_IMM) ? arg1 : arg2;
 		imm = (flags & ARG2_IMM) ? arg2 : arg1;
 		switch (op) {
 		case SLJIT_MUL:
 		case SLJIT_NEG:
 		case SLJIT_CLZ:
 		case SLJIT_ADDC:
 		case SLJIT_SUBC:
 			/* No form with immediate operand (except imm 0, which
 			is represented by a ZERO register). */
 			break;
 		case SLJIT_MOV:
 			SLJIT_ASSERT(!(flags & SET_FLAGS) && (flags & ARG2_IMM) && arg1 == TMP_REG1);
 			return load_immediate(compiler, dst, imm);
 		case SLJIT_NOT:
 			SLJIT_ASSERT(flags & ARG2_IMM);
 			FAIL_IF(load_immediate(compiler, dst, (flags & INT_OP) ? (~imm & 0xffffffff) : ~imm));
 			goto set_flags;
 		case SLJIT_SUB:
 			if (flags & ARG1_IMM)
 				break;
 			imm = -imm;
 			/* Fall through. */
 		case SLJIT_ADD:
 			if (imm == 0) {
 				CHECK_FLAGS(1 << 29);
 				return push_inst(compiler, ((op == SLJIT_ADD ? ADDI : SUBI) ^ inv_bits) | RD(dst) | RN(reg));
+			}
 			if (imm > 0 && imm <= 0xfff) {
 				CHECK_FLAGS(1 << 29);
 				return push_inst(compiler, (ADDI ^ inv_bits) | RD(dst) | RN(reg) | (imm << 10));
+			}
 			nimm = -imm;
 			if (nimm > 0 && nimm <= 0xfff) {
 				CHECK_FLAGS(1 << 29);
 				return push_inst(compiler, (SUBI ^ inv_bits) | RD(dst) | RN(reg) | (nimm << 10));
+			}
 			if (imm > 0 && imm <= 0xffffff && !(imm & 0xfff)) {
 				CHECK_FLAGS(1 << 29);
 				return push_inst(compiler, (ADDI ^ inv_bits) | RD(dst) | RN(reg) | ((imm >> 12) << 10) | (1 << 22));
+			}
 			if (nimm > 0 && nimm <= 0xffffff && !(nimm & 0xfff)) {
 				CHECK_FLAGS(1 << 29);
 				return push_inst(compiler, (SUBI ^ inv_bits) | RD(dst) | RN(reg) | ((nimm >> 12) << 10) | (1 << 22));
+			}
 			if (imm > 0 && imm <= 0xffffff && !(flags & SET_FLAGS)) {
 				FAIL_IF(push_inst(compiler, (ADDI ^ inv_bits) | RD(dst) | RN(reg) | ((imm >> 12) << 10) | (1 << 22)));
 				return push_inst(compiler, (ADDI ^ inv_bits) | RD(dst) | RN(dst) | ((imm & 0xfff) << 10));
+			}
 			if (nimm > 0 && nimm <= 0xffffff && !(flags & SET_FLAGS)) {
 				FAIL_IF(push_inst(compiler, (SUBI ^ inv_bits) | RD(dst) | RN(reg) | ((nimm >> 12) << 10) | (1 << 22)));
 				return push_inst(compiler, (SUBI ^ inv_bits) | RD(dst) | RN(dst) | ((nimm & 0xfff) << 10));
+			}
 			break;
 		case SLJIT_AND:
 			inst_bits = logical_imm(imm, LOGICAL_IMM_CHECK | ((flags & INT_OP) ? 16 : 32));
 			if (!inst_bits)
 				break;
 			CHECK_FLAGS(3 << 29);
 			return push_inst(compiler, (ANDI ^ inv_bits) | RD(dst) | RN(reg) | inst_bits);
 		case SLJIT_OR:
 		case SLJIT_XOR:
 			inst_bits = logical_imm(imm, LOGICAL_IMM_CHECK | ((flags & INT_OP) ? 16 : 32));
 			if (!inst_bits)
 				break;
 			if (op == SLJIT_OR)
 				inst_bits |= ORRI;
 			else
 				inst_bits |= EORI;
 			FAIL_IF(push_inst(compiler, (inst_bits ^ inv_bits) | RD(dst) | RN(reg)));
 			goto set_flags;
 		case SLJIT_SHL:
 			if (flags & ARG1_IMM)
 				break;
 			if (flags & INT_OP) {
 				imm &= 0x1f;
 				FAIL_IF(push_inst(compiler, (UBFM ^ inv_bits) | RD(dst) | RN(arg1) | ((-imm & 0x1f) << 16) | ((31 - imm) << 10)));
+			}
 			else {
 				imm &= 0x3f;
 				FAIL_IF(push_inst(compiler, (UBFM ^ inv_bits) | RD(dst) | RN(arg1) | (1 << 22) | ((-imm & 0x3f) << 16) | ((63 - imm) << 10)));
+			}
 			goto set_flags;
 		case SLJIT_LSHR:
 		case SLJIT_ASHR:
 			if (flags & ARG1_IMM)
 				break;
 			if (op == SLJIT_ASHR)
 				inv_bits |= 1 << 30;
 			if (flags & INT_OP) {
 				imm &= 0x1f;
 				FAIL_IF(push_inst(compiler, (UBFM ^ inv_bits) | RD(dst) | RN(arg1) | (imm << 16) | (31 << 10)));
+			}
 			else {
 				imm &= 0x3f;
 				FAIL_IF(push_inst(compiler, (UBFM ^ inv_bits) | RD(dst) | RN(arg1) | (1 << 22) | (imm << 16) | (63 << 10)));
+			}
 			goto set_flags;
 		default:
 			SLJIT_UNREACHABLE();
 			break;
+		}
 		if (flags & ARG2_IMM) {
 			if (arg2 == 0)
 				arg2 = TMP_ZERO;
 			else {
 				FAIL_IF(load_immediate(compiler, TMP_REG2, arg2));
 				arg2 = TMP_REG2;
+			}
+		}
 		else {
 			if (arg1 == 0)
 				arg1 = TMP_ZERO;
 			else {
 				FAIL_IF(load_immediate(compiler, TMP_REG1, arg1));
 				arg1 = TMP_REG1;
+			}
+		}
+	}
 	/* Both arguments are registers. */
 	switch (op) {
 	case SLJIT_MOV:
 	case SLJIT_MOV_P:
 	case SLJIT_MOVU:
 	case SLJIT_MOVU_P:
 		SLJIT_ASSERT(!(flags & SET_FLAGS) && arg1 == TMP_REG1);
 		if (dst == arg2)
 			return SLJIT_SUCCESS;
 		return push_inst(compiler, ORR | RD(dst) | RN(TMP_ZERO) | RM(arg2));
 	case SLJIT_MOV_U8:
 	case SLJIT_MOVU_U8:
 		SLJIT_ASSERT(!(flags & SET_FLAGS) && arg1 == TMP_REG1);
 		return push_inst(compiler, (UBFM ^ (1 << 31)) | RD(dst) | RN(arg2) | (7 << 10));
 	case SLJIT_MOV_S8:
 	case SLJIT_MOVU_S8:
 		SLJIT_ASSERT(!(flags & SET_FLAGS) && arg1 == TMP_REG1);
 		if (!(flags & INT_OP))
 			inv_bits |= 1 << 22;
 		return push_inst(compiler, (SBFM ^ inv_bits) | RD(dst) | RN(arg2) | (7 << 10));
 	case SLJIT_MOV_U16:
 	case SLJIT_MOVU_U16:
 		SLJIT_ASSERT(!(flags & SET_FLAGS) && arg1 == TMP_REG1);
 		return push_inst(compiler, (UBFM ^ (1 << 31)) | RD(dst) | RN(arg2) | (15 << 10));
 	case SLJIT_MOV_S16:
 	case SLJIT_MOVU_S16:
 		SLJIT_ASSERT(!(flags & SET_FLAGS) && arg1 == TMP_REG1);
 		if (!(flags & INT_OP))
 			inv_bits |= 1 << 22;
 		return push_inst(compiler, (SBFM ^ inv_bits) | RD(dst) | RN(arg2) | (15 << 10));
 	case SLJIT_MOV_U32:
 	case SLJIT_MOVU_U32:
 		SLJIT_ASSERT(!(flags & SET_FLAGS) && arg1 == TMP_REG1);
 		if ((flags & INT_OP) && dst == arg2)
 			return SLJIT_SUCCESS;
 		return push_inst(compiler, (ORR ^ (1 << 31)) | RD(dst) | RN(TMP_ZERO) | RM(arg2));
 	case SLJIT_MOV_S32:
 	case SLJIT_MOVU_S32:
 		SLJIT_ASSERT(!(flags & SET_FLAGS) && arg1 == TMP_REG1);
 		if ((flags & INT_OP) && dst == arg2)
 			return SLJIT_SUCCESS;
 		return push_inst(compiler, SBFM | (1 << 22) | RD(dst) | RN(arg2) | (31 << 10));
 	case SLJIT_NOT:
 		SLJIT_ASSERT(arg1 == TMP_REG1);
 		FAIL_IF(push_inst(compiler, (ORN ^ inv_bits) | RD(dst) | RN(TMP_ZERO) | RM(arg2)));
 		goto set_flags;
 	case SLJIT_NEG:
 		SLJIT_ASSERT(arg1 == TMP_REG1);
 		if (flags & SET_FLAGS)
 			inv_bits |= 1 << 29;
 		return push_inst(compiler, (SUB ^ inv_bits) | RD(dst) | RN(TMP_ZERO) | RM(arg2));
 	case SLJIT_CLZ:
 		SLJIT_ASSERT(arg1 == TMP_REG1);
 		FAIL_IF(push_inst(compiler, (CLZ ^ inv_bits) | RD(dst) | RN(arg2)));
 		goto set_flags;
 	case SLJIT_ADD:
 		CHECK_FLAGS(1 << 29);
 		return push_inst(compiler, (ADD ^ inv_bits) | RD(dst) | RN(arg1) | RM(arg2));
 	case SLJIT_ADDC:
 		CHECK_FLAGS(1 << 29);
 		return push_inst(compiler, (ADC ^ inv_bits) | RD(dst) | RN(arg1) | RM(arg2));
 	case SLJIT_SUB:
 		CHECK_FLAGS(1 << 29);
 		return push_inst(compiler, (SUB ^ inv_bits) | RD(dst) | RN(arg1) | RM(arg2));
 	case SLJIT_SUBC:
 		CHECK_FLAGS(1 << 29);
 		return push_inst(compiler, (SBC ^ inv_bits) | RD(dst) | RN(arg1) | RM(arg2));
 	case SLJIT_MUL:
 		if (!(flags & SET_FLAGS))
 			return push_inst(compiler, (MADD ^ inv_bits) | RD(dst) | RN(arg1) | RM(arg2) | RT2(TMP_ZERO));
 		if (flags & INT_OP) {
 			FAIL_IF(push_inst(compiler, SMADDL | RD(dst) | RN(arg1) | RM(arg2) | (31 << 10)));
 			FAIL_IF(push_inst(compiler, ADD | RD(TMP_LR) | RN(TMP_ZERO) | RM(dst) | (2 << 22) | (31 << 10)));
 			return push_inst(compiler, SUBS | RD(TMP_ZERO) | RN(TMP_LR) | RM(dst) | (2 << 22) | (63 << 10));
+		}
 		FAIL_IF(push_inst(compiler, SMULH | RD(TMP_LR) | RN(arg1) | RM(arg2)));
 		FAIL_IF(push_inst(compiler, MADD | RD(dst) | RN(arg1) | RM(arg2) | RT2(TMP_ZERO)));
 		return push_inst(compiler, SUBS | RD(TMP_ZERO) | RN(TMP_LR) | RM(dst) | (2 << 22) | (63 << 10));
 	case SLJIT_AND:
 		CHECK_FLAGS(3 << 29);
 		return push_inst(compiler, (AND ^ inv_bits) | RD(dst) | RN(arg1) | RM(arg2));
 	case SLJIT_OR:
 		FAIL_IF(push_inst(compiler, (ORR ^ inv_bits) | RD(dst) | RN(arg1) | RM(arg2)));
 		goto set_flags;
 	case SLJIT_XOR:
 		FAIL_IF(push_inst(compiler, (EOR ^ inv_bits) | RD(dst) | RN(arg1) | RM(arg2)));
 		goto set_flags;
 	case SLJIT_SHL:
 		FAIL_IF(push_inst(compiler, (LSLV ^ inv_bits) | RD(dst) | RN(arg1) | RM(arg2)));
 		goto set_flags;
 	case SLJIT_LSHR:
 		FAIL_IF(push_inst(compiler, (LSRV ^ inv_bits) | RD(dst) | RN(arg1) | RM(arg2)));
 		goto set_flags;
 	case SLJIT_ASHR:
 		FAIL_IF(push_inst(compiler, (ASRV ^ inv_bits) | RD(dst) | RN(arg1) | RM(arg2)));
 		goto set_flags;
+	}
 	SLJIT_UNREACHABLE();
 	return SLJIT_SUCCESS;
 set_flags:
 	if (flags & SET_FLAGS)
 		return push_inst(compiler, (SUBS ^ inv_bits) | RD(TMP_ZERO) | RN(dst) | RM(TMP_ZERO));
 	return SLJIT_SUCCESS;
+}
 #define STORE		0x01
 #define SIGNED		0x02
 #define UPDATE		0x04
 #define ARG_TEST	0x08
 #define BYTE_SIZE	0x000
 #define HALF_SIZE	0x100
 #define INT_SIZE	0x200
 #define WORD_SIZE	0x300
 #define MEM_SIZE_SHIFT(flags) ((flags) >> 8)
 static const sljit_ins sljit_mem_imm[4] = {
 /* u l */ 0x39400000 /* ldrb [reg,imm] */,
 /* u s */ 0x39000000 /* strb [reg,imm] */,
 /* s l */ 0x39800000 /* ldrsb [reg,imm] */,
 /* s s */ 0x39000000 /* strb [reg,imm] */,
 };
 static const sljit_ins sljit_mem_simm[4] = {
 /* u l */ 0x38400000 /* ldurb [reg,imm] */,
 /* u s */ 0x38000000 /* sturb [reg,imm] */,
 /* s l */ 0x38800000 /* ldursb [reg,imm] */,
 /* s s */ 0x38000000 /* sturb [reg,imm] */,
 };
 static const sljit_ins sljit_mem_pre_simm[4] = {
 /* u l */ 0x38400c00 /* ldrb [reg,imm]! */,
 /* u s */ 0x38000c00 /* strb [reg,imm]! */,
 /* s l */ 0x38800c00 /* ldrsb [reg,imm]! */,
 /* s s */ 0x38000c00 /* strb [reg,imm]! */,
 };
 static const sljit_ins sljit_mem_reg[4] = {
 /* u l */ 0x38606800 /* ldrb [reg,reg] */,
 /* u s */ 0x38206800 /* strb [reg,reg] */,
 /* s l */ 0x38a06800 /* ldrsb [reg,reg] */,
 /* s s */ 0x38206800 /* strb [reg,reg] */,
 };
 /* Helper function. Dst should be reg + value, using at most 1 instruction, flags does not set. */
 static sljit_s32 emit_set_delta(struct sljit_compiler *compiler, sljit_s32 dst, sljit_s32 reg, sljit_sw value)
+{
 	if (value >= 0) {
 		if (value <= 0xfff)
 			return push_inst(compiler, ADDI | RD(dst) | RN(reg) | (value << 10));
 		if (value <= 0xffffff && !(value & 0xfff))
 			return push_inst(compiler, ADDI | (1 << 22) | RD(dst) | RN(reg) | (value >> 2));
+	}
 	else {
 		value = -value;
 		if (value <= 0xfff)
 			return push_inst(compiler, SUBI | RD(dst) | RN(reg) | (value << 10));
 		if (value <= 0xffffff && !(value & 0xfff))
 			return push_inst(compiler, SUBI | (1 << 22) | RD(dst) | RN(reg) | (value >> 2));
+	}
 	return SLJIT_ERR_UNSUPPORTED;
+}
 /* Can perform an operation using at most 1 instruction. */
 static sljit_s32 getput_arg_fast(struct sljit_compiler *compiler, sljit_s32 flags, sljit_s32 reg, sljit_s32 arg, sljit_sw argw)
+{
 	sljit_u32 shift = MEM_SIZE_SHIFT(flags);
 	SLJIT_ASSERT(arg & SLJIT_MEM);
 	if (SLJIT_UNLIKELY(flags & UPDATE)) {
 		if ((arg & REG_MASK) && !(arg & OFFS_REG_MASK) && argw <= 255 && argw >= -256) {
 			if (SLJIT_UNLIKELY(flags & ARG_TEST))
 				return 1;
 			arg &= REG_MASK;
 			argw &= 0x1ff;
 			FAIL_IF(push_inst(compiler, sljit_mem_pre_simm[flags & 0x3]
 				| (shift << 30) | RT(reg) | RN(arg) | (argw << 12)));
 			return -1;
+		}
 		return 0;
+	}
 	if (SLJIT_UNLIKELY(arg & OFFS_REG_MASK)) {
 		argw &= 0x3;
 		if (argw && argw != shift)
 			return 0;
 		if (SLJIT_UNLIKELY(flags & ARG_TEST))
 			return 1;
 		FAIL_IF(push_inst(compiler, sljit_mem_reg[flags & 0x3] | (shift << 30) | RT(reg)
 			| RN(arg & REG_MASK) | RM(OFFS_REG(arg)) | (argw ? (1 << 12) : 0)));
 		return -1;
+	}
 	arg &= REG_MASK;
 	if (argw >= 0 && (argw >> shift) <= 0xfff && (argw & ((1 << shift) - 1)) == 0) {
 		if (SLJIT_UNLIKELY(flags & ARG_TEST))
 			return 1;
 		FAIL_IF(push_inst(compiler, sljit_mem_imm[flags & 0x3] | (shift << 30)
 			| RT(reg) | RN(arg) | (argw << (10 - shift))));
 		return -1;
+	}
 	if (argw > 255 || argw < -256)
 		return 0;
 	if (SLJIT_UNLIKELY(flags & ARG_TEST))
 		return 1;
 	FAIL_IF(push_inst(compiler, sljit_mem_simm[flags & 0x3] | (shift << 30)
 		| RT(reg) | RN(arg) | ((argw & 0x1ff) << 12)));
 	return -1;
+}
 /* see getput_arg below.
    Note: can_cache is called only for binary operators. Those
    operators always uses word arguments without write back. */
 static sljit_s32 can_cache(sljit_s32 arg, sljit_sw argw, sljit_s32 next_arg, sljit_sw next_argw)
+{
 	sljit_sw diff;
 	if ((arg & OFFS_REG_MASK) || !(next_arg & SLJIT_MEM))
 		return 0;
 	if (!(arg & REG_MASK)) {
 		diff = argw - next_argw;
 		if (diff <= 0xfff && diff >= -0xfff)
 			return 1;
 		return 0;
+	}
 	if (argw == next_argw)
 		return 1;
 	diff = argw - next_argw;
 	if (arg == next_arg && diff <= 0xfff && diff >= -0xfff)
 		return 1;
 	return 0;
+}
 /* Emit the necessary instructions. See can_cache above. */
 static sljit_s32 getput_arg(struct sljit_compiler *compiler, sljit_s32 flags, sljit_s32 reg,
 	sljit_s32 arg, sljit_sw argw, sljit_s32 next_arg, sljit_sw next_argw)
+{
 	sljit_u32 shift = MEM_SIZE_SHIFT(flags);
 	sljit_s32 tmp_r, other_r;
 	sljit_sw diff;
 	SLJIT_ASSERT(arg & SLJIT_MEM);
 	if (!(next_arg & SLJIT_MEM)) {
 		next_arg = 0;
 		next_argw = 0;
+	}
 	tmp_r = (flags & STORE) ? TMP_REG3 : reg;
 	if (SLJIT_UNLIKELY((flags & UPDATE) && (arg & REG_MASK))) {
 		/* Update only applies if a base register exists. */
 		other_r = OFFS_REG(arg);
 		if (!other_r) {
 			other_r = arg & REG_MASK;
 			SLJIT_ASSERT(other_r != reg);
 			if (argw >= 0 && argw <= 0xffffff) {
 				if ((argw & 0xfff) != 0)
 					FAIL_IF(push_inst(compiler, ADDI | RD(other_r) | RN(other_r) | ((argw & 0xfff) << 10)));
 				if (argw >> 12)
 					FAIL_IF(push_inst(compiler, ADDI | (1 << 22) | RD(other_r) | RN(other_r) | ((argw >> 12) << 10)));
 				return push_inst(compiler, sljit_mem_imm[flags & 0x3] | (shift << 30) | RT(reg) | RN(other_r));
+			}
 			else if (argw < 0 && argw >= -0xffffff) {
 				argw = -argw;
 				if ((argw & 0xfff) != 0)
 					FAIL_IF(push_inst(compiler, SUBI | RD(other_r) | RN(other_r) | ((argw & 0xfff) << 10)));
 				if (argw >> 12)
 					FAIL_IF(push_inst(compiler, SUBI | (1 << 22) | RD(other_r) | RN(other_r) | ((argw >> 12) << 10)));
 				return push_inst(compiler, sljit_mem_imm[flags & 0x3] | (shift << 30) | RT(reg) | RN(other_r));
+			}
 			if (compiler->cache_arg == SLJIT_MEM) {
 				if (argw == compiler->cache_argw) {
 					other_r = TMP_REG3;
 					argw = 0;
+				}
 				else if (emit_set_delta(compiler, TMP_REG3, TMP_REG3, argw - compiler->cache_argw) != SLJIT_ERR_UNSUPPORTED) {
 					FAIL_IF(compiler->error);
 					compiler->cache_argw = argw;
 					other_r = TMP_REG3;
 					argw = 0;
+				}
+			}
 			if (argw) {
 				FAIL_IF(load_immediate(compiler, TMP_REG3, argw));
 				compiler->cache_arg = SLJIT_MEM;
 				compiler->cache_argw = argw;
 				other_r = TMP_REG3;
 				argw = 0;
+			}
+		}
 		/* No caching here. */
 		arg &= REG_MASK;
 		FAIL_IF(push_inst(compiler, sljit_mem_reg[flags & 0x3] | (shift << 30) | RT(reg) | RN(arg) | RM(other_r)));
 		return push_inst(compiler, ADD | RD(arg) | RN(arg) | RM(other_r));
+	}
 	if (arg & OFFS_REG_MASK) {
 		other_r = OFFS_REG(arg);
 		arg &= REG_MASK;
 		FAIL_IF(push_inst(compiler, ADD | RD(tmp_r) | RN(arg) | RM(other_r) | ((argw & 0x3) << 10)));
 		return push_inst(compiler, sljit_mem_imm[flags & 0x3] | (shift << 30) | RT(reg) | RN(tmp_r));
+	}
 	if (compiler->cache_arg == arg) {
 		diff = argw - compiler->cache_argw;
 		if (diff <= 255 && diff >= -256)
 			return push_inst(compiler, sljit_mem_simm[flags & 0x3] | (shift << 30)
 				| RT(reg) | RN(TMP_REG3) | ((diff & 0x1ff) << 12));
 		if (emit_set_delta(compiler, TMP_REG3, TMP_REG3, diff) != SLJIT_ERR_UNSUPPORTED) {
 			FAIL_IF(compiler->error);
 			return push_inst(compiler, sljit_mem_imm[flags & 0x3] | (shift << 30) | RT(reg) | RN(arg));
+		}
+	}
 	if (argw >= 0 && argw <= 0xffffff && (argw & ((1 << shift) - 1)) == 0) {
 		FAIL_IF(push_inst(compiler, ADDI | (1 << 22) | RD(tmp_r) | RN(arg & REG_MASK) | ((argw >> 12) << 10)));
 		return push_inst(compiler, sljit_mem_imm[flags & 0x3] | (shift << 30)
 			| RT(reg) | RN(tmp_r) | ((argw & 0xfff) << (10 - shift)));
+	}
 	diff = argw - next_argw;
 	next_arg = (arg & REG_MASK) && (arg == next_arg) && diff <= 0xfff && diff >= -0xfff && diff != 0;
 	arg &= REG_MASK;
 	if (arg && compiler->cache_arg == SLJIT_MEM) {
 		if (compiler->cache_argw == argw)
 			return push_inst(compiler, sljit_mem_reg[flags & 0x3] | (shift << 30) | RT(reg) | RN(arg) | RM(TMP_REG3));
 		if (emit_set_delta(compiler, TMP_REG3, TMP_REG3, argw - compiler->cache_argw) != SLJIT_ERR_UNSUPPORTED) {
 			FAIL_IF(compiler->error);
 			compiler->cache_argw = argw;
 			return push_inst(compiler, sljit_mem_reg[flags & 0x3] | (shift << 30) | RT(reg) | RN(arg) | RM(TMP_REG3));
+		}
+	}
 	compiler->cache_argw = argw;
 	if (next_arg && emit_set_delta(compiler, TMP_REG3, arg, argw) != SLJIT_ERR_UNSUPPORTED) {
 		FAIL_IF(compiler->error);
 		compiler->cache_arg = SLJIT_MEM | arg;
 		arg = 0;
+	}
 	else {
 		FAIL_IF(load_immediate(compiler, TMP_REG3, argw));
 		compiler->cache_arg = SLJIT_MEM;
 		if (next_arg) {
 			FAIL_IF(push_inst(compiler, ADD | RD(TMP_REG3) | RN(TMP_REG3) | RM(arg)));
 			compiler->cache_arg = SLJIT_MEM | arg;
 			arg = 0;
+		}
+	}
 	if (arg)
 		return push_inst(compiler, sljit_mem_reg[flags & 0x3] | (shift << 30) | RT(reg) | RN(arg) | RM(TMP_REG3));
 	return push_inst(compiler, sljit_mem_imm[flags & 0x3] | (shift << 30) | RT(reg) | RN(TMP_REG3));
+}
 static SLJIT_INLINE sljit_s32 emit_op_mem(struct sljit_compiler *compiler, sljit_s32 flags, sljit_s32 reg, sljit_s32 arg, sljit_sw argw)
+{
 	if (getput_arg_fast(compiler, flags, reg, arg, argw))
 		return compiler->error;
 	compiler->cache_arg = 0;
 	compiler->cache_argw = 0;
 	return getput_arg(compiler, flags, reg, arg, argw, 0, 0);
+}
 static SLJIT_INLINE sljit_s32 emit_op_mem2(struct sljit_compiler *compiler, sljit_s32 flags, sljit_s32 reg, sljit_s32 arg1, sljit_sw arg1w, sljit_s32 arg2, sljit_sw arg2w)
+{
 	if (getput_arg_fast(compiler, flags, reg, arg1, arg1w))
 		return compiler->error;
 	return getput_arg(compiler, flags, reg, arg1, arg1w, arg2, arg2w);
+}
 /* --------------------------------------------------------------------- */
 /*  Entry, exit                                                          */
 /* --------------------------------------------------------------------- */
 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_enter(struct sljit_compiler *compiler,
 	sljit_s32 options, sljit_s32 args, sljit_s32 scratches, sljit_s32 saveds,
 	sljit_s32 fscratches, sljit_s32 fsaveds, sljit_s32 local_size)
+{
 	sljit_s32 i, tmp, offs, prev, saved_regs_size;
 	CHECK_ERROR();
 	CHECK(check_sljit_emit_enter(compiler, options, args, scratches, saveds, fscratches, fsaveds, local_size));
 	set_emit_enter(compiler, options, args, scratches, saveds, fscratches, fsaveds, local_size);
 	saved_regs_size = GET_SAVED_REGISTERS_SIZE(scratches, saveds, 0);
 	local_size += saved_regs_size + SLJIT_LOCALS_OFFSET;
 	local_size = (local_size + 15) & ~0xf;
 	compiler->local_size = local_size;
-	if (local_size <= (63 * sizeof(sljit_sw))) {
+	SLJIT_ASSERT(local_size >= 0);
 	if ((size_t)local_size <= (63 * sizeof(sljit_sw))) {
 		FAIL_IF(push_inst(compiler, STP_PRE | 29 | RT2(TMP_LR)
 			| RN(TMP_SP) | ((-(local_size >> 3) & 0x7f) << 15)));
 		FAIL_IF(push_inst(compiler, ADDI | RD(SLJIT_SP) | RN(TMP_SP) | (0 << 10)));
 		offs = (local_size - saved_regs_size) << (15 - 3);
 	} else {
 		offs = 0 << 15;
 		if (saved_regs_size & 0x8) {
 			offs = 1 << 15;
 			saved_regs_size += sizeof(sljit_sw);
+		}
 		local_size -= saved_regs_size + SLJIT_LOCALS_OFFSET;
 		if (saved_regs_size > 0)
 			FAIL_IF(push_inst(compiler, SUBI | RD(TMP_SP) | RN(TMP_SP) | (saved_regs_size << 10)));
+	}
 	tmp = saveds < SLJIT_NUMBER_OF_SAVED_REGISTERS ? (SLJIT_S0 + 1 - saveds) : SLJIT_FIRST_SAVED_REG;
 	prev = -1;
 	for (i = SLJIT_S0; i >= tmp; i--) {
 		if (prev == -1) {
 			if (!(offs & (1 << 15))) {
 				prev = i;
 				continue;
+			}
 			FAIL_IF(push_inst(compiler, STRI | RT(i) | RN(TMP_SP) | (offs >> 5)));
 			offs += 1 << 15;
 			continue;
+		}
 		FAIL_IF(push_inst(compiler, STP | RT(prev) | RT2(i) | RN(TMP_SP) | offs));
 		offs += 2 << 15;
 		prev = -1;
+	}
 	for (i = scratches; i >= SLJIT_FIRST_SAVED_REG; i--) {
 		if (prev == -1) {
 			if (!(offs & (1 << 15))) {
 				prev = i;
 				continue;
+			}
 			FAIL_IF(push_inst(compiler, STRI | RT(i) | RN(TMP_SP) | (offs >> 5)));
 			offs += 1 << 15;
 			continue;
+		}
 		FAIL_IF(push_inst(compiler, STP | RT(prev) | RT2(i) | RN(TMP_SP) | offs));
 		offs += 2 << 15;
 		prev = -1;
+	}
 	SLJIT_ASSERT(prev == -1);
-	if (compiler->local_size > (63 * sizeof(sljit_sw))) {
+	SLJIT_ASSERT(compiler->local_size >= 0);
 	if ((size_t)compiler->local_size > (63 * sizeof(sljit_sw))) {
 		/* The local_size is already adjusted by the saved registers. */
 		if (local_size > 0xfff) {
 			FAIL_IF(push_inst(compiler, SUBI | RD(TMP_SP) | RN(TMP_SP) | ((local_size >> 12) << 10) | (1 << 22)));
 			local_size &= 0xfff;
+		}
 		if (local_size)
 			FAIL_IF(push_inst(compiler, SUBI | RD(TMP_SP) | RN(TMP_SP) | (local_size << 10)));
 		FAIL_IF(push_inst(compiler, STP_PRE | 29 | RT2(TMP_LR)
 			| RN(TMP_SP) | ((-(16 >> 3) & 0x7f) << 15)));
 		FAIL_IF(push_inst(compiler, ADDI | RD(SLJIT_SP) | RN(TMP_SP) | (0 << 10)));
+	}
 	if (args >= 1)
 		FAIL_IF(push_inst(compiler, ORR | RD(SLJIT_S0) | RN(TMP_ZERO) | RM(SLJIT_R0)));
 	if (args >= 2)
 		FAIL_IF(push_inst(compiler, ORR | RD(SLJIT_S1) | RN(TMP_ZERO) | RM(SLJIT_R1)));
 	if (args >= 3)
 		FAIL_IF(push_inst(compiler, ORR | RD(SLJIT_S2) | RN(TMP_ZERO) | RM(SLJIT_R2)));
 	return SLJIT_SUCCESS;
+}
 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_set_context(struct sljit_compiler *compiler,
 	sljit_s32 options, sljit_s32 args, sljit_s32 scratches, sljit_s32 saveds,
 	sljit_s32 fscratches, sljit_s32 fsaveds, sljit_s32 local_size)
+{
 	CHECK_ERROR();
 	CHECK(check_sljit_set_context(compiler, options, args, scratches, saveds, fscratches, fsaveds, local_size));
 	set_set_context(compiler, options, args, scratches, saveds, fscratches, fsaveds, local_size);
 	local_size += GET_SAVED_REGISTERS_SIZE(scratches, saveds, 0) + SLJIT_LOCALS_OFFSET;
 	local_size = (local_size + 15) & ~0xf;
 	compiler->local_size = local_size;
 	return SLJIT_SUCCESS;
+}
 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_return(struct sljit_compiler *compiler, sljit_s32 op, sljit_s32 src, sljit_sw srcw)
+{
 	sljit_s32 local_size;
 	sljit_s32 i, tmp, offs, prev, saved_regs_size;
 	CHECK_ERROR();
 	CHECK(check_sljit_emit_return(compiler, op, src, srcw));
 	FAIL_IF(emit_mov_before_return(compiler, op, src, srcw));
 	local_size = compiler->local_size;
 	saved_regs_size = GET_SAVED_REGISTERS_SIZE(compiler->scratches, compiler->saveds, 0);
-	if (local_size <= (63 * sizeof(sljit_sw)))
+	SLJIT_ASSERT(local_size >= 0);
 	if ((size_t)local_size <= (63 * sizeof(sljit_sw)))
 		offs = (local_size - saved_regs_size) << (15 - 3);
 	else {
 		FAIL_IF(push_inst(compiler, LDP_PST | 29 | RT2(TMP_LR)
 			| RN(TMP_SP) | (((16 >> 3) & 0x7f) << 15)));
 		offs = 0 << 15;
 		if (saved_regs_size & 0x8) {
 			offs = 1 << 15;
 			saved_regs_size += sizeof(sljit_sw);
+		}
 		local_size -= saved_regs_size + SLJIT_LOCALS_OFFSET;
 		if (local_size > 0xfff) {
 			FAIL_IF(push_inst(compiler, ADDI | RD(TMP_SP) | RN(TMP_SP) | ((local_size >> 12) << 10) | (1 << 22)));
 			local_size &= 0xfff;
+		}
 		if (local_size)
 			FAIL_IF(push_inst(compiler, ADDI | RD(TMP_SP) | RN(TMP_SP) | (local_size << 10)));
+	}
 	tmp = compiler->saveds < SLJIT_NUMBER_OF_SAVED_REGISTERS ? (SLJIT_S0 + 1 - compiler->saveds) : SLJIT_FIRST_SAVED_REG;
 	prev = -1;
 	for (i = SLJIT_S0; i >= tmp; i--) {
 		if (prev == -1) {
 			if (!(offs & (1 << 15))) {
 				prev = i;
 				continue;
+			}
 			FAIL_IF(push_inst(compiler, LDRI | RT(i) | RN(TMP_SP) | (offs >> 5)));
 			offs += 1 << 15;
 			continue;
+		}
 		FAIL_IF(push_inst(compiler, LDP | RT(prev) | RT2(i) | RN(TMP_SP) | offs));
 		offs += 2 << 15;
 		prev = -1;
+	}
 	for (i = compiler->scratches; i >= SLJIT_FIRST_SAVED_REG; i--) {
 		if (prev == -1) {
 			if (!(offs & (1 << 15))) {
 				prev = i;
 				continue;
+			}
 			FAIL_IF(push_inst(compiler, LDRI | RT(i) | RN(TMP_SP) | (offs >> 5)));
 			offs += 1 << 15;
 			continue;
+		}
 		FAIL_IF(push_inst(compiler, LDP | RT(prev) | RT2(i) | RN(TMP_SP) | offs));
 		offs += 2 << 15;
 		prev = -1;
+	}
 	SLJIT_ASSERT(prev == -1);
-	if (compiler->local_size <= (63 * sizeof(sljit_sw))) {
+	SLJIT_ASSERT(compiler->local_size >= 0);
 	if ((size_t)compiler->local_size <= (63 * sizeof(sljit_sw))) {
 		FAIL_IF(push_inst(compiler, LDP_PST | 29 | RT2(TMP_LR)
 			| RN(TMP_SP) | (((local_size >> 3) & 0x7f) << 15)));
 	} else if (saved_regs_size > 0) {
 		FAIL_IF(push_inst(compiler, ADDI | RD(TMP_SP) | RN(TMP_SP) | (saved_regs_size << 10)));
+	}
 	FAIL_IF(push_inst(compiler, RET | RN(TMP_LR)));
 	return SLJIT_SUCCESS;
+}
 /* --------------------------------------------------------------------- */
 /*  Operators                                                            */
 /* --------------------------------------------------------------------- */
 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_op0(struct sljit_compiler *compiler, sljit_s32 op)
+{
 	sljit_ins inv_bits = (op & SLJIT_I32_OP) ? (1 << 31) : 0;
 	CHECK_ERROR();
 	CHECK(check_sljit_emit_op0(compiler, op));
 	op = GET_OPCODE(op);
 	switch (op) {
 	case SLJIT_BREAKPOINT:
 		return push_inst(compiler, BRK);
 	case SLJIT_NOP:
 		return push_inst(compiler, NOP);
 	case SLJIT_LMUL_UW:
 	case SLJIT_LMUL_SW:
 		FAIL_IF(push_inst(compiler, ORR | RD(TMP_REG1) | RN(TMP_ZERO) | RM(SLJIT_R0)));
 		FAIL_IF(push_inst(compiler, MADD | RD(SLJIT_R0) | RN(SLJIT_R0) | RM(SLJIT_R1) | RT2(TMP_ZERO)));
 		return push_inst(compiler, (op == SLJIT_LMUL_UW ? UMULH : SMULH) | RD(SLJIT_R1) | RN(TMP_REG1) | RM(SLJIT_R1));
 	case SLJIT_DIVMOD_UW:
 	case SLJIT_DIVMOD_SW:
 		FAIL_IF(push_inst(compiler, (ORR ^ inv_bits) | RD(TMP_REG1) | RN(TMP_ZERO) | RM(SLJIT_R0)));
 		FAIL_IF(push_inst(compiler, ((op == SLJIT_DIVMOD_UW ? UDIV : SDIV) ^ inv_bits) | RD(SLJIT_R0) | RN(SLJIT_R0) | RM(SLJIT_R1)));
 		FAIL_IF(push_inst(compiler, (MADD ^ inv_bits) | RD(SLJIT_R1) | RN(SLJIT_R0) | RM(SLJIT_R1) | RT2(TMP_ZERO)));
 		return push_inst(compiler, (SUB ^ inv_bits) | RD(SLJIT_R1) | RN(TMP_REG1) | RM(SLJIT_R1));
 	case SLJIT_DIV_UW:
 	case SLJIT_DIV_SW:
 		return push_inst(compiler, ((op == SLJIT_DIV_UW ? UDIV : SDIV) ^ inv_bits) | RD(SLJIT_R0) | RN(SLJIT_R0) | RM(SLJIT_R1));
+	}
 	return SLJIT_SUCCESS;
+}
 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_op1(struct sljit_compiler *compiler, sljit_s32 op,
 	sljit_s32 dst, sljit_sw dstw,
 	sljit_s32 src, sljit_sw srcw)
+{
 	sljit_s32 dst_r, flags, mem_flags;
 	sljit_s32 op_flags = GET_ALL_FLAGS(op);
 	CHECK_ERROR();
 	CHECK(check_sljit_emit_op1(compiler, op, dst, dstw, src, srcw));
 	ADJUST_LOCAL_OFFSET(dst, dstw);
 	ADJUST_LOCAL_OFFSET(src, srcw);
 	compiler->cache_arg = 0;
 	compiler->cache_argw = 0;
 	dst_r = SLOW_IS_REG(dst) ? dst : TMP_REG1;
 	op = GET_OPCODE(op);
 	if (op >= SLJIT_MOV && op <= SLJIT_MOVU_P) {
 		switch (op) {
 		case SLJIT_MOV:
 		case SLJIT_MOV_P:
 			flags = WORD_SIZE;
 			break;
 		case SLJIT_MOV_U8:
 			flags = BYTE_SIZE;
 			if (src & SLJIT_IMM)
 				srcw = (sljit_u8)srcw;
 			break;
 		case SLJIT_MOV_S8:
 			flags = BYTE_SIZE | SIGNED;
 			if (src & SLJIT_IMM)
 				srcw = (sljit_s8)srcw;
 			break;
 		case SLJIT_MOV_U16:
 			flags = HALF_SIZE;
 			if (src & SLJIT_IMM)
 				srcw = (sljit_u16)srcw;
 			break;
 		case SLJIT_MOV_S16:
 			flags = HALF_SIZE | SIGNED;
 			if (src & SLJIT_IMM)
 				srcw = (sljit_s16)srcw;
 			break;
 		case SLJIT_MOV_U32:
 			flags = INT_SIZE;
 			if (src & SLJIT_IMM)
 				srcw = (sljit_u32)srcw;
 			break;
 		case SLJIT_MOV_S32:
 			flags = INT_SIZE | SIGNED;
 			if (src & SLJIT_IMM)
 				srcw = (sljit_s32)srcw;
 			break;
 		case SLJIT_MOVU:
 		case SLJIT_MOVU_P:
 			flags = WORD_SIZE | UPDATE;
 			break;
 		case SLJIT_MOVU_U8:
 			flags = BYTE_SIZE | UPDATE;
 			if (src & SLJIT_IMM)
 				srcw = (sljit_u8)srcw;
 			break;
 		case SLJIT_MOVU_S8:
 			flags = BYTE_SIZE | SIGNED | UPDATE;
 			if (src & SLJIT_IMM)
 				srcw = (sljit_s8)srcw;
 			break;
 		case SLJIT_MOVU_U16:
 			flags = HALF_SIZE | UPDATE;
 			if (src & SLJIT_IMM)
 				srcw = (sljit_u16)srcw;
 			break;
 		case SLJIT_MOVU_S16:
 			flags = HALF_SIZE | SIGNED | UPDATE;
 			if (src & SLJIT_IMM)
 				srcw = (sljit_s16)srcw;
 			break;
 		case SLJIT_MOVU_U32:
 			flags = INT_SIZE | UPDATE;
 			if (src & SLJIT_IMM)
 				srcw = (sljit_u32)srcw;
 			break;
 		case SLJIT_MOVU_S32:
 			flags = INT_SIZE | SIGNED | UPDATE;
 			if (src & SLJIT_IMM)
 				srcw = (sljit_s32)srcw;
 			break;
 		default:
 			SLJIT_UNREACHABLE();
 			flags = 0;
 			break;
+		}
 		if (src & SLJIT_IMM)
 			FAIL_IF(emit_op_imm(compiler, SLJIT_MOV | ARG2_IMM, dst_r, TMP_REG1, srcw));
 		else if (src & SLJIT_MEM) {
 			if (getput_arg_fast(compiler, flags, dst_r, src, srcw))
 				FAIL_IF(compiler->error);
 			else
 				FAIL_IF(getput_arg(compiler, flags, dst_r, src, srcw, dst, dstw));
 		} else {
 			if (dst_r != TMP_REG1)
 				return emit_op_imm(compiler, op | ((op_flags & SLJIT_I32_OP) ? INT_OP : 0), dst_r, TMP_REG1, src);
 			dst_r = src;
+		}
 		if (dst & SLJIT_MEM) {
 			if (getput_arg_fast(compiler, flags | STORE, dst_r, dst, dstw))
 				return compiler->error;
 			else
 				return getput_arg(compiler, flags | STORE, dst_r, dst, dstw, 0, 0);
+		}
 		return SLJIT_SUCCESS;
+	}
 	flags = HAS_FLAGS(op_flags) ? SET_FLAGS : 0;
 	mem_flags = WORD_SIZE;
 	if (op_flags & SLJIT_I32_OP) {
 		flags |= INT_OP;
 		mem_flags = INT_SIZE;
+	}
 	if (dst == SLJIT_UNUSED)
 		flags |= UNUSED_RETURN;
 	if (src & SLJIT_MEM) {
 		if (getput_arg_fast(compiler, mem_flags, TMP_REG2, src, srcw))
 			FAIL_IF(compiler->error);
 		else
 			FAIL_IF(getput_arg(compiler, mem_flags, TMP_REG2, src, srcw, dst, dstw));
 		src = TMP_REG2;
+	}
 	if (src & SLJIT_IMM) {
 		flags |= ARG2_IMM;
 		if (op_flags & SLJIT_I32_OP)
 			srcw = (sljit_s32)srcw;
 	} else
 		srcw = src;
 	emit_op_imm(compiler, flags | op, dst_r, TMP_REG1, srcw);
 	if (dst & SLJIT_MEM) {
 		if (getput_arg_fast(compiler, mem_flags | STORE, dst_r, dst, dstw))
 			return compiler->error;
 		else
 			return getput_arg(compiler, mem_flags | STORE, dst_r, dst, dstw, 0, 0);
+	}
 	return SLJIT_SUCCESS;
+}
 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_op2(struct sljit_compiler *compiler, sljit_s32 op,
 	sljit_s32 dst, sljit_sw dstw,
 	sljit_s32 src1, sljit_sw src1w,
 	sljit_s32 src2, sljit_sw src2w)
+{
 	sljit_s32 dst_r, flags, mem_flags;
 	CHECK_ERROR();
 	CHECK(check_sljit_emit_op2(compiler, op, dst, dstw, src1, src1w, src2, src2w));
 	ADJUST_LOCAL_OFFSET(dst, dstw);
 	ADJUST_LOCAL_OFFSET(src1, src1w);
 	ADJUST_LOCAL_OFFSET(src2, src2w);
 	compiler->cache_arg = 0;
 	compiler->cache_argw = 0;
 	dst_r = SLOW_IS_REG(dst) ? dst : TMP_REG1;
 	flags = HAS_FLAGS(op) ? SET_FLAGS : 0;
 	mem_flags = WORD_SIZE;
 	if (op & SLJIT_I32_OP) {
 		flags |= INT_OP;
 		mem_flags = INT_SIZE;
+	}
 	if (dst == SLJIT_UNUSED)
 		flags |= UNUSED_RETURN;
 	if ((dst & SLJIT_MEM) && !getput_arg_fast(compiler, mem_flags | STORE | ARG_TEST, TMP_REG1, dst, dstw))
 		flags |= SLOW_DEST;
 	if (src1 & SLJIT_MEM) {
 		if (getput_arg_fast(compiler, mem_flags, TMP_REG1, src1, src1w))
 			FAIL_IF(compiler->error);
 		else
 			flags |= SLOW_SRC1;
+	}
 	if (src2 & SLJIT_MEM) {
 		if (getput_arg_fast(compiler, mem_flags, TMP_REG2, src2, src2w))
 			FAIL_IF(compiler->error);
 		else
 			flags |= SLOW_SRC2;
+	}
 	if ((flags & (SLOW_SRC1 | SLOW_SRC2)) == (SLOW_SRC1 | SLOW_SRC2)) {
 		if (!can_cache(src1, src1w, src2, src2w) && can_cache(src1, src1w, dst, dstw)) {
 			FAIL_IF(getput_arg(compiler, mem_flags, TMP_REG2, src2, src2w, src1, src1w));
 			FAIL_IF(getput_arg(compiler, mem_flags, TMP_REG1, src1, src1w, dst, dstw));
+		}
 		else {
 			FAIL_IF(getput_arg(compiler, mem_flags, TMP_REG1, src1, src1w, src2, src2w));
 			FAIL_IF(getput_arg(compiler, mem_flags, TMP_REG2, src2, src2w, dst, dstw));
+		}
+	}
 	else if (flags & SLOW_SRC1)
 		FAIL_IF(getput_arg(compiler, mem_flags, TMP_REG1, src1, src1w, dst, dstw));
 	else if (flags & SLOW_SRC2)
 		FAIL_IF(getput_arg(compiler, mem_flags, TMP_REG2, src2, src2w, dst, dstw));
 	if (src1 & SLJIT_MEM)
 		src1 = TMP_REG1;
 	if (src2 & SLJIT_MEM)
 		src2 = TMP_REG2;
 	if (src1 & SLJIT_IMM)
 		flags |= ARG1_IMM;
 	else
 		src1w = src1;
 	if (src2 & SLJIT_IMM)
 		flags |= ARG2_IMM;
 	else
 		src2w = src2;
 	emit_op_imm(compiler, flags | GET_OPCODE(op), dst_r, src1w, src2w);
 	if (dst & SLJIT_MEM) {
 		if (!(flags & SLOW_DEST)) {
 			getput_arg_fast(compiler, mem_flags | STORE, dst_r, dst, dstw);
 			return compiler->error;
+		}
 		return getput_arg(compiler, mem_flags | STORE, TMP_REG1, dst, dstw, 0, 0);
+	}
 	return SLJIT_SUCCESS;
+}
 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_get_register_index(sljit_s32 reg)
+{
 	CHECK_REG_INDEX(check_sljit_get_register_index(reg));
 	return reg_map[reg];
+}
 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_get_float_register_index(sljit_s32 reg)
+{
 	CHECK_REG_INDEX(check_sljit_get_float_register_index(reg));
 	return reg;
+}
 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_op_custom(struct sljit_compiler *compiler,
 	void *instruction, sljit_s32 size)
+{
 	CHECK_ERROR();
 	CHECK(check_sljit_emit_op_custom(compiler, instruction, size));
 	return push_inst(compiler, *(sljit_ins*)instruction);
+}
 /* --------------------------------------------------------------------- */
 /*  Floating point operators                                             */
 /* --------------------------------------------------------------------- */
 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_is_fpu_available(void)
+{
 #ifdef SLJIT_IS_FPU_AVAILABLE
 	return SLJIT_IS_FPU_AVAILABLE;
 #else
 	/* Available by default. */
 	return 1;
 #endif
+}
 static sljit_s32 emit_fop_mem(struct sljit_compiler *compiler, sljit_s32 flags, sljit_s32 reg, sljit_s32 arg, sljit_sw argw)
+{
 	sljit_u32 shift = MEM_SIZE_SHIFT(flags);
 	sljit_ins ins_bits = (shift << 30);
 	sljit_s32 other_r;
 	sljit_sw diff;
 	SLJIT_ASSERT(arg & SLJIT_MEM);
 	if (!(flags & STORE))
 		ins_bits |= 1 << 22;
 	if (arg & OFFS_REG_MASK) {
 		argw &= 3;
 		if (!argw || argw == shift)
 			return push_inst(compiler, STR_FR | ins_bits | VT(reg)
 				| RN(arg & REG_MASK) | RM(OFFS_REG(arg)) | (argw ? (1 << 12) : 0));
 		other_r = OFFS_REG(arg);
 		arg &= REG_MASK;
 		FAIL_IF(push_inst(compiler, ADD | RD(TMP_REG1) | RN(arg) | RM(other_r) | (argw << 10)));
 		arg = TMP_REG1;
 		argw = 0;
+	}
 	arg &= REG_MASK;
 	if (arg && argw >= 0 && ((argw >> shift) <= 0xfff) && (argw & ((1 << shift) - 1)) == 0)
 		return push_inst(compiler, STR_FI | ins_bits | VT(reg) | RN(arg) | (argw << (10 - shift)));
 	if (arg && argw <= 255 && argw >= -256)
 		return push_inst(compiler, STUR_FI | ins_bits | VT(reg) | RN(arg) | ((argw & 0x1ff) << 12));
 	/* Slow cases */
 	if (compiler->cache_arg == SLJIT_MEM && argw != compiler->cache_argw) {
 		diff = argw - compiler->cache_argw;
 		if (!arg && diff <= 255 && diff >= -256)
 			return push_inst(compiler, STUR_FI | ins_bits | VT(reg) | RN(TMP_REG3) | ((diff & 0x1ff) << 12));
 		if (emit_set_delta(compiler, TMP_REG3, TMP_REG3, argw - compiler->cache_argw) != SLJIT_ERR_UNSUPPORTED) {
 			FAIL_IF(compiler->error);
 			compiler->cache_argw = argw;
+		}
+	}
 	if (compiler->cache_arg != SLJIT_MEM || argw != compiler->cache_argw) {
 		compiler->cache_arg = SLJIT_MEM;
 		compiler->cache_argw = argw;
 		FAIL_IF(load_immediate(compiler, TMP_REG3, argw));
+	}
 	if (arg & REG_MASK)
 		return push_inst(compiler, STR_FR | ins_bits | VT(reg) | RN(arg) | RM(TMP_REG3));
 	return push_inst(compiler, STR_FI | ins_bits | VT(reg) | RN(TMP_REG3));
+}
 static SLJIT_INLINE sljit_s32 sljit_emit_fop1_conv_sw_from_f64(struct sljit_compiler *compiler, sljit_s32 op,
 	sljit_s32 dst, sljit_sw dstw,
 	sljit_s32 src, sljit_sw srcw)
+{
 	sljit_s32 dst_r = SLOW_IS_REG(dst) ? dst : TMP_REG1;
 	sljit_ins inv_bits = (op & SLJIT_F32_OP) ? (1 << 22) : 0;
 	if (GET_OPCODE(op) == SLJIT_CONV_S32_FROM_F64)
 		inv_bits |= (1 << 31);
 	if (src & SLJIT_MEM) {
 		emit_fop_mem(compiler, (op & SLJIT_F32_OP) ? INT_SIZE : WORD_SIZE, TMP_FREG1, src, srcw);
 		src = TMP_FREG1;
+	}
 	FAIL_IF(push_inst(compiler, (FCVTZS ^ inv_bits) | RD(dst_r) | VN(src)));
 	if (dst_r == TMP_REG1 && dst != SLJIT_UNUSED)
 		return emit_op_mem(compiler, ((GET_OPCODE(op) == SLJIT_CONV_S32_FROM_F64) ? INT_SIZE : WORD_SIZE) | STORE, TMP_REG1, dst, dstw);
 	return SLJIT_SUCCESS;
+}
 static SLJIT_INLINE sljit_s32 sljit_emit_fop1_conv_f64_from_sw(struct sljit_compiler *compiler, sljit_s32 op,
 	sljit_s32 dst, sljit_sw dstw,
 	sljit_s32 src, sljit_sw srcw)
+{
 	sljit_s32 dst_r = FAST_IS_REG(dst) ? dst : TMP_FREG1;
 	sljit_ins inv_bits = (op & SLJIT_F32_OP) ? (1 << 22) : 0;
 	if (GET_OPCODE(op) == SLJIT_CONV_F64_FROM_S32)
 		inv_bits |= (1 << 31);
 	if (src & SLJIT_MEM) {
 		emit_op_mem(compiler, ((GET_OPCODE(op) == SLJIT_CONV_F64_FROM_S32) ? INT_SIZE : WORD_SIZE), TMP_REG1, src, srcw);
 		src = TMP_REG1;
 	} else if (src & SLJIT_IMM) {
 #if (defined SLJIT_CONFIG_X86_64 && SLJIT_CONFIG_X86_64)
 		if (GET_OPCODE(op) == SLJIT_CONV_F64_FROM_S32)
 			srcw = (sljit_s32)srcw;
 #endif
 		FAIL_IF(load_immediate(compiler, TMP_REG1, srcw));
 		src = TMP_REG1;
+	}
 	FAIL_IF(push_inst(compiler, (SCVTF ^ inv_bits) | VD(dst_r) | RN(src)));
 	if (dst & SLJIT_MEM)
 		return emit_fop_mem(compiler, ((op & SLJIT_F32_OP) ? INT_SIZE : WORD_SIZE) | STORE, TMP_FREG1, dst, dstw);
 	return SLJIT_SUCCESS;
+}
 static SLJIT_INLINE sljit_s32 sljit_emit_fop1_cmp(struct sljit_compiler *compiler, sljit_s32 op,
 	sljit_s32 src1, sljit_sw src1w,
 	sljit_s32 src2, sljit_sw src2w)
+{
 	sljit_s32 mem_flags = (op & SLJIT_F32_OP) ? INT_SIZE : WORD_SIZE;
 	sljit_ins inv_bits = (op & SLJIT_F32_OP) ? (1 << 22) : 0;
 	if (src1 & SLJIT_MEM) {
 		emit_fop_mem(compiler, mem_flags, TMP_FREG1, src1, src1w);
 		src1 = TMP_FREG1;
+	}
 	if (src2 & SLJIT_MEM) {
 		emit_fop_mem(compiler, mem_flags, TMP_FREG2, src2, src2w);
 		src2 = TMP_FREG2;
+	}
 	return push_inst(compiler, (FCMP ^ inv_bits) | VN(src1) | VM(src2));
+}
 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_fop1(struct sljit_compiler *compiler, sljit_s32 op,
 	sljit_s32 dst, sljit_sw dstw,
 	sljit_s32 src, sljit_sw srcw)
+{
 	sljit_s32 dst_r, mem_flags = (op & SLJIT_F32_OP) ? INT_SIZE : WORD_SIZE;
 	sljit_ins inv_bits;
 	CHECK_ERROR();
 	compiler->cache_arg = 0;
 	compiler->cache_argw = 0;
 	SLJIT_COMPILE_ASSERT((INT_SIZE ^ 0x100) == WORD_SIZE, must_be_one_bit_difference);
 	SELECT_FOP1_OPERATION_WITH_CHECKS(compiler, op, dst, dstw, src, srcw);
 	inv_bits = (op & SLJIT_F32_OP) ? (1 << 22) : 0;
 	dst_r = FAST_IS_REG(dst) ? dst : TMP_FREG1;
 	if (src & SLJIT_MEM) {
 		emit_fop_mem(compiler, (GET_OPCODE(op) == SLJIT_CONV_F64_FROM_F32) ? (mem_flags ^ 0x100) : mem_flags, dst_r, src, srcw);
 		src = dst_r;
+	}
 	switch (GET_OPCODE(op)) {
 	case SLJIT_MOV_F64:
 		if (src != dst_r) {
 			if (dst_r != TMP_FREG1)
 				FAIL_IF(push_inst(compiler, (FMOV ^ inv_bits) | VD(dst_r) | VN(src)));
 			else
 				dst_r = src;
+		}
 		break;
 	case SLJIT_NEG_F64:
 		FAIL_IF(push_inst(compiler, (FNEG ^ inv_bits) | VD(dst_r) | VN(src)));
 		break;
 	case SLJIT_ABS_F64:
 		FAIL_IF(push_inst(compiler, (FABS ^ inv_bits) | VD(dst_r) | VN(src)));
 		break;
 	case SLJIT_CONV_F64_FROM_F32:
 		FAIL_IF(push_inst(compiler, FCVT | ((op & SLJIT_F32_OP) ? (1 << 22) : (1 << 15)) | VD(dst_r) | VN(src)));
 		break;
+	}
 	if (dst & SLJIT_MEM)
 		return emit_fop_mem(compiler, mem_flags | STORE, dst_r, dst, dstw);
 	return SLJIT_SUCCESS;
+}
 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_fop2(struct sljit_compiler *compiler, sljit_s32 op,
 	sljit_s32 dst, sljit_sw dstw,
 	sljit_s32 src1, sljit_sw src1w,
 	sljit_s32 src2, sljit_sw src2w)
+{
 	sljit_s32 dst_r, mem_flags = (op & SLJIT_F32_OP) ? INT_SIZE : WORD_SIZE;
 	sljit_ins inv_bits = (op & SLJIT_F32_OP) ? (1 << 22) : 0;
 	CHECK_ERROR();
 	CHECK(check_sljit_emit_fop2(compiler, op, dst, dstw, src1, src1w, src2, src2w));
 	ADJUST_LOCAL_OFFSET(dst, dstw);
 	ADJUST_LOCAL_OFFSET(src1, src1w);
 	ADJUST_LOCAL_OFFSET(src2, src2w);
 	compiler->cache_arg = 0;
 	compiler->cache_argw = 0;
 	dst_r = FAST_IS_REG(dst) ? dst : TMP_FREG1;
 	if (src1 & SLJIT_MEM) {
 		emit_fop_mem(compiler, mem_flags, TMP_FREG1, src1, src1w);
 		src1 = TMP_FREG1;
+	}
 	if (src2 & SLJIT_MEM) {
 		emit_fop_mem(compiler, mem_flags, TMP_FREG2, src2, src2w);
 		src2 = TMP_FREG2;
+	}
 	switch (GET_OPCODE(op)) {
 	case SLJIT_ADD_F64:
 		FAIL_IF(push_inst(compiler, (FADD ^ inv_bits) | VD(dst_r) | VN(src1) | VM(src2)));
 		break;
 	case SLJIT_SUB_F64:
 		FAIL_IF(push_inst(compiler, (FSUB ^ inv_bits) | VD(dst_r) | VN(src1) | VM(src2)));
 		break;
 	case SLJIT_MUL_F64:
 		FAIL_IF(push_inst(compiler, (FMUL ^ inv_bits) | VD(dst_r) | VN(src1) | VM(src2)));
 		break;
 	case SLJIT_DIV_F64:
 		FAIL_IF(push_inst(compiler, (FDIV ^ inv_bits) | VD(dst_r) | VN(src1) | VM(src2)));
 		break;
+	}
 	if (!(dst & SLJIT_MEM))
 		return SLJIT_SUCCESS;
 	return emit_fop_mem(compiler, mem_flags | STORE, TMP_FREG1, dst, dstw);
+}
 /* --------------------------------------------------------------------- */
 /*  Other instructions                                                   */
 /* --------------------------------------------------------------------- */
 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_fast_enter(struct sljit_compiler *compiler, sljit_s32 dst, sljit_sw dstw)
+{
 	CHECK_ERROR();
 	CHECK(check_sljit_emit_fast_enter(compiler, dst, dstw));
 	ADJUST_LOCAL_OFFSET(dst, dstw);
 	/* For UNUSED dst. Uncommon, but possible. */
 	if (dst == SLJIT_UNUSED)
 		return SLJIT_SUCCESS;
 	if (FAST_IS_REG(dst))
 		return push_inst(compiler, ORR | RD(dst) | RN(TMP_ZERO) | RM(TMP_LR));
 	/* Memory. */
 	return emit_op_mem(compiler, WORD_SIZE | STORE, TMP_LR, dst, dstw);
+}
 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_fast_return(struct sljit_compiler *compiler, sljit_s32 src, sljit_sw srcw)
+{
 	CHECK_ERROR();
 	CHECK(check_sljit_emit_fast_return(compiler, src, srcw));
 	ADJUST_LOCAL_OFFSET(src, srcw);
 	if (FAST_IS_REG(src))
 		FAIL_IF(push_inst(compiler, ORR | RD(TMP_LR) | RN(TMP_ZERO) | RM(src)));
 	else if (src & SLJIT_MEM)
 		FAIL_IF(emit_op_mem(compiler, WORD_SIZE, TMP_LR, src, srcw));
 	else if (src & SLJIT_IMM)
 		FAIL_IF(load_immediate(compiler, TMP_LR, srcw));
 	return push_inst(compiler, RET | RN(TMP_LR));
+}
 /* --------------------------------------------------------------------- */
 /*  Conditional instructions                                             */
 /* --------------------------------------------------------------------- */
 static sljit_uw get_cc(sljit_s32 type)
+{
 	switch (type) {
 	case SLJIT_EQUAL:
 	case SLJIT_MUL_NOT_OVERFLOW:
 	case SLJIT_EQUAL_F64:
 		return 0x1;
 	case SLJIT_NOT_EQUAL:
 	case SLJIT_MUL_OVERFLOW:
 	case SLJIT_NOT_EQUAL_F64:
 		return 0x0;
 	case SLJIT_LESS:
 	case SLJIT_LESS_F64:
 		return 0x2;
 	case SLJIT_GREATER_EQUAL:
 	case SLJIT_GREATER_EQUAL_F64:
 		return 0x3;
 	case SLJIT_GREATER:
 	case SLJIT_GREATER_F64:
 		return 0x9;
 	case SLJIT_LESS_EQUAL:
 	case SLJIT_LESS_EQUAL_F64:
 		return 0x8;
 	case SLJIT_SIG_LESS:
 		return 0xa;
 	case SLJIT_SIG_GREATER_EQUAL:
 		return 0xb;
 	case SLJIT_SIG_GREATER:
 		return 0xd;
 	case SLJIT_SIG_LESS_EQUAL:
 		return 0xc;
 	case SLJIT_OVERFLOW:
 	case SLJIT_UNORDERED_F64:
 		return 0x7;
 	case SLJIT_NOT_OVERFLOW:
 	case SLJIT_ORDERED_F64:
 		return 0x6;
 	default:
 		SLJIT_UNREACHABLE();
 		return 0xe;
+	}
+}
 SLJIT_API_FUNC_ATTRIBUTE struct sljit_label* sljit_emit_label(struct sljit_compiler *compiler)
+{
 	struct sljit_label *label;
 	CHECK_ERROR_PTR();
 	CHECK_PTR(check_sljit_emit_label(compiler));
 	if (compiler->last_label && compiler->last_label->size == compiler->size)
 		return compiler->last_label;
 	label = (struct sljit_label*)ensure_abuf(compiler, sizeof(struct sljit_label));
 	PTR_FAIL_IF(!label);
 	set_label(label, compiler);
 	return label;
+}
 SLJIT_API_FUNC_ATTRIBUTE struct sljit_jump* sljit_emit_jump(struct sljit_compiler *compiler, sljit_s32 type)
+{
 	struct sljit_jump *jump;
 	CHECK_ERROR_PTR();
 	CHECK_PTR(check_sljit_emit_jump(compiler, type));
 	jump = (struct sljit_jump*)ensure_abuf(compiler, sizeof(struct sljit_jump));
 	PTR_FAIL_IF(!jump);
 	set_jump(jump, compiler, type & SLJIT_REWRITABLE_JUMP);
 	type &= 0xff;
 	if (type < SLJIT_JUMP) {
 		jump->flags |= IS_COND;
 		PTR_FAIL_IF(push_inst(compiler, B_CC | (6 << 5) | get_cc(type)));
+	}
 	else if (type >= SLJIT_FAST_CALL)
 		jump->flags |= IS_BL;
 	PTR_FAIL_IF(emit_imm64_const(compiler, TMP_REG1, 0));
 	jump->addr = compiler->size;
 	PTR_FAIL_IF(push_inst(compiler, ((type >= SLJIT_FAST_CALL) ? BLR : BR) | RN(TMP_REG1)));
 	return jump;
+}
 static SLJIT_INLINE struct sljit_jump* emit_cmp_to0(struct sljit_compiler *compiler, sljit_s32 type,
 	sljit_s32 src, sljit_sw srcw)
+{
 	struct sljit_jump *jump;
 	sljit_ins inv_bits = (type & SLJIT_I32_OP) ? (1 << 31) : 0;
 	SLJIT_ASSERT((type & 0xff) == SLJIT_EQUAL || (type & 0xff) == SLJIT_NOT_EQUAL);
 	ADJUST_LOCAL_OFFSET(src, srcw);
 	jump = (struct sljit_jump*)ensure_abuf(compiler, sizeof(struct sljit_jump));
 	PTR_FAIL_IF(!jump);
 	set_jump(jump, compiler, type & SLJIT_REWRITABLE_JUMP);
 	jump->flags |= IS_CBZ | IS_COND;
 	if (src & SLJIT_MEM) {
 		PTR_FAIL_IF(emit_op_mem(compiler, inv_bits ? INT_SIZE : WORD_SIZE, TMP_REG1, src, srcw));
 		src = TMP_REG1;
+	}
 	else if (src & SLJIT_IMM) {
 		PTR_FAIL_IF(load_immediate(compiler, TMP_REG1, srcw));
 		src = TMP_REG1;
+	}
 	SLJIT_ASSERT(FAST_IS_REG(src));
 	if ((type & 0xff) == SLJIT_EQUAL)
 		inv_bits |= 1 << 24;
 	PTR_FAIL_IF(push_inst(compiler, (CBZ ^ inv_bits) | (6 << 5) | RT(src)));
 	PTR_FAIL_IF(emit_imm64_const(compiler, TMP_REG1, 0));
 	jump->addr = compiler->size;
 	PTR_FAIL_IF(push_inst(compiler, BR | RN(TMP_REG1)));
 	return jump;
+}
 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_ijump(struct sljit_compiler *compiler, sljit_s32 type, sljit_s32 src, sljit_sw srcw)
+{
 	struct sljit_jump *jump;
 	CHECK_ERROR();
 	CHECK(check_sljit_emit_ijump(compiler, type, src, srcw));
 	ADJUST_LOCAL_OFFSET(src, srcw);
 	/* In ARM, we don't need to touch the arguments. */
 	if (!(src & SLJIT_IMM)) {
 		if (src & SLJIT_MEM) {
 			FAIL_IF(emit_op_mem(compiler, WORD_SIZE, TMP_REG1, src, srcw));
 			src = TMP_REG1;
+		}
 		return push_inst(compiler, ((type >= SLJIT_FAST_CALL) ? BLR : BR) | RN(src));
+	}
 	jump = (struct sljit_jump*)ensure_abuf(compiler, sizeof(struct sljit_jump));
 	FAIL_IF(!jump);
 	set_jump(jump, compiler, JUMP_ADDR | ((type >= SLJIT_FAST_CALL) ? IS_BL : 0));
 	jump->u.target = srcw;
 	FAIL_IF(emit_imm64_const(compiler, TMP_REG1, 0));
 	jump->addr = compiler->size;
 	return push_inst(compiler, ((type >= SLJIT_FAST_CALL) ? BLR : BR) | RN(TMP_REG1));
+}
 SLJIT_API_FUNC_ATTRIBUTE sljit_s32 sljit_emit_op_flags(struct sljit_compiler *compiler, sljit_s32 op,
 	sljit_s32 dst, sljit_sw dstw,
 	sljit_s32 src, sljit_sw srcw,
 	sljit_s32 type)
+{
 	sljit_s32 dst_r, flags, mem_flags;
 	sljit_ins cc;
 	CHECK_ERROR();
 	CHECK(check_sljit_emit_op_flags(compiler, op, dst, dstw, src, srcw, type));
 	ADJUST_LOCAL_OFFSET(dst, dstw);
 	ADJUST_LOCAL_OFFSET(src, srcw);
 	if (dst == SLJIT_UNUSED)
 		return SLJIT_SUCCESS;
 	cc = get_cc(type & 0xff);
 	dst_r = FAST_IS_REG(dst) ? dst : TMP_REG1;
 	if (GET_OPCODE(op) < SLJIT_ADD) {
 		FAIL_IF(push_inst(compiler, CSINC | (cc << 12) | RD(dst_r) | RN(TMP_ZERO) | RM(TMP_ZERO)));
 		if (dst_r != TMP_REG1)
 			return SLJIT_SUCCESS;
 		return emit_op_mem(compiler, (GET_OPCODE(op) == SLJIT_MOV ? WORD_SIZE : INT_SIZE) | STORE, TMP_REG1, dst, dstw);
+	}
 	compiler->cache_arg = 0;
 	compiler->cache_argw = 0;
 	flags = HAS_FLAGS(op) ? SET_FLAGS : 0;
 	mem_flags = WORD_SIZE;
 	if (op & SLJIT_I32_OP) {
 		flags |= INT_OP;
 		mem_flags = INT_SIZE;
+	}
 	if (src & SLJIT_MEM) {
 		FAIL_IF(emit_op_mem2(compiler, mem_flags, TMP_REG1, src, srcw, dst, dstw));
 		src = TMP_REG1;
 		srcw = 0;
 	} else if (src & SLJIT_IMM)
 		flags |= ARG1_IMM;
 	FAIL_IF(push_inst(compiler, CSINC | (cc << 12) | RD(TMP_REG2) | RN(TMP_ZERO) | RM(TMP_ZERO)));
 	emit_op_imm(compiler, flags | GET_OPCODE(op), dst_r, src, TMP_REG2);
 	if (dst_r != TMP_REG1)
 		return SLJIT_SUCCESS;
 	return emit_op_mem2(compiler, mem_flags | STORE, TMP_REG1, dst, dstw, 0, 0);
+}
 SLJIT_API_FUNC_ATTRIBUTE struct sljit_const* sljit_emit_const(struct sljit_compiler *compiler, sljit_s32 dst, sljit_sw dstw, sljit_sw init_value)
+{
 	struct sljit_const *const_;
 	sljit_s32 dst_r;
 	CHECK_ERROR_PTR();
 	CHECK_PTR(check_sljit_emit_const(compiler, dst, dstw, init_value));
 	ADJUST_LOCAL_OFFSET(dst, dstw);
 	const_ = (struct sljit_const*)ensure_abuf(compiler, sizeof(struct sljit_const));
 	PTR_FAIL_IF(!const_);
 	set_const(const_, compiler);
 	dst_r = SLOW_IS_REG(dst) ? dst : TMP_REG1;
 	PTR_FAIL_IF(emit_imm64_const(compiler, dst_r, init_value));
 	if (dst & SLJIT_MEM)
 		PTR_FAIL_IF(emit_op_mem(compiler, WORD_SIZE | STORE, dst_r, dst, dstw));
 	return const_;
+}
 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_jump_addr(sljit_uw addr, sljit_uw new_target, sljit_sw executable_offset)
+{
 	sljit_ins* inst = (sljit_ins*)addr;
 	modify_imm64_const(inst, new_target);
 	inst = (sljit_ins *)SLJIT_ADD_EXEC_OFFSET(inst, executable_offset);
 	SLJIT_CACHE_FLUSH(inst, inst + 4);
+}
 SLJIT_API_FUNC_ATTRIBUTE void sljit_set_const(sljit_uw addr, sljit_sw new_constant, sljit_sw executable_offset)
+{
 	sljit_ins* inst = (sljit_ins*)addr;
 	modify_imm64_const(inst, new_constant);
 	inst = (sljit_ins *)SLJIT_ADD_EXEC_OFFSET(inst, executable_offset);
 	SLJIT_CACHE_FLUSH(inst, inst + 4);
+}

 @@ -1,54 +1,59 @@
-/*	$NetBSD: sljit_machdep.h,v 1.3 2020/12/11 18:03:33 skrll Exp $	*/
+/*	$NetBSD: sljit_machdep.h,v 1.3.18.1 2024/04/18 15:21:55 martin Exp $	*/
 /*-
  * Copyright (c) 2014 Alexander Nasonov.
  * All rights reserved.
+ *
  * Redistribution and use in source and binary forms, with or without
  * modification, are permitted provided that the following conditions
  * are met:
  * 1. Redistributions of source code must retain the above copyright
  *    notice, this list of conditions and the following disclaimer.
  * 2. Redistributions in binary form must reproduce the above copyright
  *    notice, this list of conditions and the following disclaimer in the
  *    documentation and/or other materials provided with the distribution.
+ *
  * THIS SOFTWARE IS PROVIDED BY THE NETBSD FOUNDATION, INC. AND CONTRIBUTORS
  * ``AS IS'' AND ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED
  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  * PURPOSE ARE DISCLAIMED.  IN NO EVENT SHALL THE FOUNDATION OR CONTRIBUTORS
  * BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR
  * CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF
  * SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR PROFITS; OR BUSINESS
  * INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY OF LIABILITY, WHETHER IN
  * CONTRACT, STRICT LIABILITY, OR TORT (INCLUDING NEGLIGENCE OR OTHERWISE)
  * ARISING IN ANY WAY OUT OF THE USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE
  * POSSIBILITY OF SUCH DAMAGE.
  */
 #ifndef _AARCH64_SLJITARCH_H
 #define _AARCH64_SLJITARCH_H
 #include <sys/cdefs.h>
 #ifdef _KERNEL
 #include <machine/types.h>
 #include <arm/cpufunc.h>
 #else
 #include <stddef.h>
 #include <stdint.h>
 #include <aarch64/sysarch.h>
 #endif
 #define SLJIT_CONFIG_ARM_64 1
-#ifdef _KERNEL
+#ifdef _HARDKERNEL
 /*
  * XXX Currently sys/rump/include/machine/cpu.h doesn't have
  * ci_cpufuncs for cpu_icache_sync_range, so we do this only for
  * non-rump kernels for now.
  */
 #define SLJIT_CACHE_FLUSH(from, to) \
 	cpu_icache_sync_range((vaddr_t)(from), (vsize_t)((to) - (from)))
 #else
 #define SLJIT_CACHE_FLUSH(from, to) \
 	(void)__builtin___clear_cache((char *)(from), (char *)(to))
 #endif
 #endif

 @@ -1,505 +1,499 @@
-#	$NetBSD: Makefile,v 1.274.2.2 2023/12/30 19:13:50 martin Exp $
+#	$NetBSD: Makefile,v 1.274.2.3 2024/04/18 15:21:55 martin Exp $
 .include <bsd.own.mk>
 # For all platforms
 # Modules for compatibility with earlier versions of NetBSD
 SUBDIR+=	compat_util
 SUBDIR+=	compat_43   compat_sysctl_09_43
 SUBDIR+=	compat_09   compat_10   compat_12   compat_13   compat_14
 SUBDIR+=	compat_16   compat_20   compat_30   compat_40   compat_50
 SUBDIR+=	compat_60   compat_70   compat_80   compat_90
 SUBDIR+=	compat_sysv_10 compat_sysv_14 compat_sysv_50
 SUBDIR+=	compat_50_quota
 SUBDIR+=	compat_raid_50
 SUBDIR+=	compat_raid_80
 SUBDIR+=	compat_crypto_50
 SUBDIR+=	accf_dataready
 SUBDIR+=	accf_httpready
 SUBDIR+=	adosfs
 SUBDIR+=	adiantum
 SUBDIR+=	aht20temp
 SUBDIR+=	aio
 SUBDIR+=	audio
 SUBDIR+=	autofs
 SUBDIR+=	blake2s
 SUBDIR+=	blowfish
 SUBDIR+=	bpf
 SUBDIR+=	bpf_filter
 SUBDIR+=	bmx280thp
 SUBDIR+=	bmx280thpi2c
 SUBDIR+=	bufq_disksort
 SUBDIR+=	bufq_fcfs
 SUBDIR+=	bufq_priocscan
 SUBDIR+=	bufq_readprio
 SUBDIR+=	camellia
 SUBDIR+=	cast128
 SUBDIR+=	ccd
 SUBDIR+=	cd9660
 SUBDIR+=	cgd
 SUBDIR+=	chfs
 SUBDIR+=	clockctl
 SUBDIR+=	compat_ossaudio
 SUBDIR+=	crypto
 SUBDIR+=	coda
 SUBDIR+=	coda5
 SUBDIR+=	coredump
 SUBDIR+=	dbcool
 SUBDIR+=	des
 SUBDIR+=	dk_subr
 SUBDIR+=	drvctl
 SUBDIR+=	efs
 SUBDIR+=	ext2fs
 SUBDIR+=	exec_script
 SUBDIR+=	fdesc
 SUBDIR+=	ffs
 SUBDIR+=	filecore
 SUBDIR+=	flash
 SUBDIR+=	fss
 SUBDIR+=	gpio
 SUBDIR+=	gpioiic
 SUBDIR+=	gpioow
 SUBDIR+=	gpiosim
 SUBDIR+=	gpioirq
 SUBDIR+=	gpiopps
 SUBDIR+=	hfs
 SUBDIR+=	hythygtemp
 SUBDIR+=	am2315temp
 SUBDIR+=	i2cexec
 SUBDIR+=	i2c_bitbang
 SUBDIR+=	i2c_subr
 SUBDIR+=	if_agr
 SUBDIR+=	if_aue
 SUBDIR+=	if_axe
 SUBDIR+=	if_axen
 SUBDIR+=	if_cdce
 SUBDIR+=	if_cue
 SUBDIR+=	if_faith
 SUBDIR+=	if_gif
 SUBDIR+=	if_gre
 SUBDIR+=	if_kue
 SUBDIR+=	if_l2tp
 SUBDIR+=	if_lagg
 SUBDIR+=	if_loop
 SUBDIR+=	if_mpls
 SUBDIR+=	if_mue
 SUBDIR+=	if_npflog
 SUBDIR+=	if_ppp
 SUBDIR+=	if_pppoe
 SUBDIR+=	if_run
 SUBDIR+=	if_sl
 SUBDIR+=	if_smsc
 SUBDIR+=	if_srt srt
 SUBDIR+=	if_stf
 SUBDIR+=	if_tap tap
 SUBDIR+=	if_tun tun
 SUBDIR+=	if_udav
 SUBDIR+=	if_upl
 SUBDIR+=	if_ure
 SUBDIR+=	if_url
 SUBDIR+=	if_urndis
 SUBDIR+=	if_vlan
 SUBDIR+=	if_wg
 SUBDIR+=	iic
 SUBDIR+=	ip_ecn
 SUBDIR+=	ipl
 SUBDIR+=	kernfs
 SUBDIR+=	layerfs
 SUBDIR+=	lfs
 SUBDIR+=	lua
 SUBDIR+=	luasystm
 SUBDIR+=	luapmf
 SUBDIR+=	mfs
 SUBDIR+=	midi
 SUBDIR+=	midi_seq
 SUBDIR+=	miiverbose
 SUBDIR+=	miniroot
 SUBDIR+=	mqueue
 SUBDIR+=	msdos
 SUBDIR+=	nand
 SUBDIR+=	nandemulator
 SUBDIR+=	nfs
 SUBDIR+=	nfsserver
 SUBDIR+=	nilfs
 SUBDIR+=	npf
 SUBDIR+=	npf_alg_icmp
 SUBDIR+=	npf_ext_log
 SUBDIR+=	npf_ext_normalize
 SUBDIR+=	npf_ext_rndblock
 SUBDIR+=	ntfs
 SUBDIR+=	null
 SUBDIR+=	onewire
 SUBDIR+=	opencrypto
 SUBDIR+=	overlay
 SUBDIR+=	pad
 SUBDIR+=	pciverbose
 SUBDIR+=	pf
 SUBDIR+=	ppp_bsdcomp
 SUBDIR+=	ppp_deflate
 SUBDIR+=	procfs
 SUBDIR+=	ptrace
 SUBDIR+=	ptrace_common
 SUBDIR+=	ptyfs
 SUBDIR+=	puffs
 SUBDIR+=	putter
 SUBDIR+=	raid
 SUBDIR+=	scmd
 SUBDIR+=	scmdi2c
 SUBDIR+=	scsi_subr
 SUBDIR+=	scsiverbose
 SUBDIR+=	sdtemp
 SUBDIR+=	secmodel_bsd44
 SUBDIR+=	secmodel_extensions
 SUBDIR+=	secmodel_overlay
 SUBDIR+=	securelevel
 SUBDIR+=	sequencer
 SUBDIR+=	sgp40mox
 SUBDIR+=	sht3xtemp
 SUBDIR+=	sht4xtemp
 SUBDIR+=	si70xxtemp
 SUBDIR+=	skipjack
 SUBDIR+=	slcompress
 SUBDIR+=	spdmem
 SUBDIR+=	spkr
 SUBDIR+=	sppp_subr
 SUBDIR+=	sysmon
 SUBDIR+=	sysmon_envsys
 SUBDIR+=	sysmon_power
 SUBDIR+=	sysmon_taskq
 SUBDIR+=	sysmon_wdog
 SUBDIR+=	sysvbfs
 SUBDIR+=	sysv_ipc
 SUBDIR+=	suser
 SUBDIR+=	swcrypto
 SUBDIR+=	swsensor
 SUBDIR+=	swwdog
 SUBDIR+=	tmpfs
 SUBDIR+=	ualea
 SUBDIR+=	uatp
 SUBDIR+=	udf
 SUBDIR+=	ufs
 SUBDIR+=	umap
 SUBDIR+=	union
 SUBDIR+=	usbnet
 SUBDIR+=	usbverbose
 SUBDIR+=	vcoda
 SUBDIR+=	v7fs
 SUBDIR+=	vnd
 SUBDIR+=	wapbl
 SUBDIR+=	wsbell
 SUBDIR+=	zlib
 SUBDIR+=	tprof
 .if (defined(NOTYET))
 SUBDIR+=	unionfs
 .endif
 .if ${MKBINUTILS} != "no"
 SUBDIR+=	xldscripts
 .endif
 # Machine dependent section
 .if ${MACHINE_ARCH} == "i386" || \
     ${MACHINE_CPU} == "m68k"
 SUBDIR+=	exec_aout
 .endif
 .if ${MACHINE_ARCH} != "alpha" && \
     ${MACHINE_ARCH} != "ia64"
 SUBDIR+=	exec_elf32
 .endif
 .if ${MACHINE_CPU} == "aarch64" || \
     ${MACHINE_ARCH} == "alpha" || \
     ${MACHINE_ARCH} == "ia64" || \
     ${MACHINE_ARCH} == "sparc64" || \
     ${MACHINE_ARCH} == "x86_64"
 SUBDIR+=	exec_elf64
 .endif
 .if ${MACHINE_ARCH} == "i386" || \
     ${MACHINE_ARCH} == "x86_64"
 SUBDIR+=	amdsmn
 SUBDIR+=	amdtemp
 SUBDIR+=	amdzentemp
 SUBDIR+=	coretemp
 SUBDIR+=	est
 SUBDIR+=	hdafg
 SUBDIR+=	hdaudio
 SUBDIR+=	hdaudio_pci
 SUBDIR+=	hdaudioverbose
 SUBDIR+=	hpet
 SUBDIR+=	ichsmb
 SUBDIR+=	odcm
 SUBDIR+=	powernow
 SUBDIR+=	tco
 SUBDIR+=	tprof_x86
 SUBDIR+=	vmt
 .endif
 .if ${HAVE_NVMM:Uno} == "yes"
 SUBDIR+=	nvmm
 .endif
 # Builds on architectures with PCI bus
 .if \
      ${MACHINE} == "evbarm" || \
      ${MACHINE_ARCH} == "i386" || \
      ${MACHINE_ARCH} == "x86_64"
 #SUBDIR+=	hifn
 SUBDIR+=	if_iavf
 SUBDIR+=	if_ixl
 SUBDIR+=	ubsec
 .endif
 .if ${MKSLJIT} != "no"
 # No modules for 32-bit arm, mips and powerpc yet.
 .if ${MACHINE_ARCH} == "aarch64" || \
     ${MACHINE_ARCH} == "i386"    || \
     ${MACHINE_ARCH} == "sparc"   || \
     ${MACHINE_ARCH} == "x86_64"
 SUBDIR+=	bpfjit
 SUBDIR+=	sljit
 .endif
 .endif
+#
 # ACPI modules
+#
 .if ${MACHINE_ARCH} == "i386" || \
     ${MACHINE_ARCH} == "ia64" || \
     ${MACHINE_ARCH} == "x86_64"
 SUBDIR+=	acpiverbose
 .endif
 .if ${MACHINE_ARCH} == "i386" || \
     ${MACHINE_ARCH} == "x86_64"
 SUBDIR+=	acpiacad
 SUBDIR+=	acpibat
 SUBDIR+=	acpibut
 SUBDIR+=	acpicpu
 SUBDIR+=	acpidalb
 SUBDIR+=	acpifan
 SUBDIR+=	acpilid
 SUBDIR+=	acpipmtr
 SUBDIR+=	acpitz
 SUBDIR+=	acpivga
 SUBDIR+=	acpiwdrt
 SUBDIR+=	acpiwmi
 SUBDIR+=	aibs
 SUBDIR+=	asus
 SUBDIR+=	fujbp
 SUBDIR+=	fujhk
 SUBDIR+=	hpacel
 SUBDIR+=	hpqlb
 SUBDIR+=	thinkpad
 SUBDIR+=	wmidell
 SUBDIR+=	wmieeepc
 SUBDIR+=	wmihp
 SUBDIR+=	wmimsi
 .endif
 .include "${.CURDIR}/../compat/netbsd32/netbsd32.mk"
 .if ${COMPAT_USE_NETBSD32} != "no"
 SUBDIR+=	compat_netbsd32
 SUBDIR+=	compat_netbsd32_09	compat_netbsd32_12
 SUBDIR+=	compat_netbsd32_13	compat_netbsd32_16
 SUBDIR+=	compat_netbsd32_20	compat_netbsd32_30
 SUBDIR+=	compat_netbsd32_40	compat_netbsd32_50
 SUBDIR+=	compat_netbsd32_60	compat_netbsd32_80
 SUBDIR+=	compat_netbsd32_90
 SUBDIR+=	compat_netbsd32_43
 SUBDIR+=	compat_netbsd32_coredump
 SUBDIR+=	compat_netbsd32_mqueue
 SUBDIR+=	compat_netbsd32_nfssrv
 SUBDIR+=	compat_netbsd32_ptrace
 SUBDIR+=	compat_netbsd32_quota
 SUBDIR+=	compat_netbsd32_quota_50
 SUBDIR+=	compat_netbsd32_raid
 SUBDIR+=	compat_netbsd32_sysvipc
 SUBDIR+=	compat_netbsd32_sysvipc_10
 SUBDIR+=	compat_netbsd32_sysvipc_14
 SUBDIR+=	compat_netbsd32_sysvipc_50
 .if ${MACHINE_ARCH} == "x86_64"
 SUBDIR+=	compat_linux32
 .endif
 .endif
 .if ${MACHINE_ARCH} == "i386"
 SUBDIR+=	ati_pcigart
 SUBDIR+=	compat_freebsd
 SUBDIR+=	mach64drm
 SUBDIR+=	mgadrm
 SUBDIR+=	nsclpcsio
 SUBDIR+=	padlock
 SUBDIR+=	r128drm
 #SUBDIR+=	radeondrm
 SUBDIR+=	savagedrm
 SUBDIR+=	sisdrm
 SUBDIR+=	tdfxdrm
 SUBDIR+=	viac7temp
 .endif
 .if ${MACHINE_ARCH} == "i386" || \
     ${MACHINE_ARCH} == "x86_64"
 SUBDIR+=	amdgpu
 SUBDIR+=	compat_linux
 SUBDIR+=	drm
 SUBDIR+=	drmkms
 SUBDIR+=	drmkms_agp
 SUBDIR+=	drmkms_linux
 SUBDIR+=	drmkms_pci
 SUBDIR+=	drmkms_sched
 SUBDIR+=	drmkms_ttm
 SUBDIR+=	i915drm
 SUBDIR+=	i915drmkms
 SUBDIR+=	viadrmums
+#
 # ISA modules
+#
 SUBDIR+=	aps
 SUBDIR+=	finsio
 SUBDIR+=	itesio
 SUBDIR+=	lm
 SUBDIR+=	lm_isa
 SUBDIR+=	lm_isa_common
 SUBDIR+=	lm_wbsio
 SUBDIR+=	wbsio
 .endif
 .if ${MACHINE_CPU} == "aarch64"
 SUBDIR+=	compat_linux
 SUBDIR+=	compat_linux32
 .endif
 .if ${MACHINE_CPU} == "m68k"
 SUBDIR+=	compat_aoutm68k
 #SUBDIR+=	compat_linux
 #SUBDIR+=	compat_sunos
 .endif
 .if ${MACHINE_ARCH} == "i386" || \
     ${MACHINE_ARCH} == "x86_64" || \
     ${MACHINE_ARCH} == "sparc64"
 SUBDIR+=	pwdog
 .endif
 .include <bsd.own.mk>
+#
 # NetBSD/usermode support
+#
 .if ${MACHINE_ARCH} == "i386" || \
     ${MACHINE_ARCH} == "x86_64"
 SUBDIR+=	../arch/usermode/modules/syscallemu
 .endif
 # we need our device mapper for LVM
 .if (${MKLVM} != "no")
 SUBDIR+= 	dm
 .endif
 .if (${MKDTRACE} != "no")
 SUBDIR+=	cyclic
 SUBDIR+=	dtrace
 .endif
 SUBDIR+=        sodium
 # we need solaris for the dtrace and zfs modules
 .if (${MKDTRACE} != "no" || ${MKZFS} != "no")
 SUBDIR+=        solaris
 .endif
 .if (${MKZFS} != "no")
 SUBDIR+=	zfs
 .endif
 .if (${MKCOMPATMODULES} != "no")
 SUBDIR+=	arch
 .endif
+#
 # DTV modules
+#
 SUBDIR+=	dtv
 SUBDIR+=	dtv_math
 .if ${MACHINE_ARCH} == "i386" || ${MACHINE_ARCH} == "x86_64"
 # tuners/demods
 SUBDIR+=	au8522
 SUBDIR+=	cx24227
 SUBDIR+=	lg3303
 SUBDIR+=	mt2131
 SUBDIR+=	nxt2k
 SUBDIR+=	tvpll
 SUBDIR+=	xc3028
 SUBDIR+=	xc5k
 SUBDIR+=	zl10353
 # hardware drivers
 SUBDIR+=	auvitek
 SUBDIR+=	coram
 SUBDIR+=	cxdtv
 SUBDIR+=	emdtv
 # Intel Integrated Memory Controller and associated SMBus
 # (Experimental)
 SUBDIR+=	imc
 SUBDIR+=	imcsmb
 .endif
 .if (${MKISCSI} != "no")
 SUBDIR+=	iscsi
 .endif
 # For now, all of these are disabled, pending resolution of how to deal
 # with attachment-specific modules and bus-specific modules (as opposed
 # to machine- or architecture-specific modules)
 .if 0
 SUBDIR+=	aac
 SUBDIR+=	amr
 SUBDIR+=	ataraid
 SUBDIR+=	cac
 SUBDIR+=	cac_eisa
 SUBDIR+=	cac_pci
 SUBDIR+=	emuxki
 SUBDIR+=	if_aq
 SUBDIR+=	if_vioif
 SUBDIR+=	if_vmx
 SUBDIR+=	ld
 SUBDIR+=	ld_aac
 SUBDIR+=	ld_amr
 SUBDIR+=	ld_ataraid
 SUBDIR+=	ld_cac
 SUBDIR+=	ld_icp
 SUBDIR+=	ld_mlx
 SUBDIR+=	ld_sdmmc
 SUBDIR+=	ld_twa
 SUBDIR+=	ld_twe
 SUBDIR+=	ld_virtio
 SUBDIR+=	mlx
 SUBDIR+=	mlx_eisa
 SUBDIR+=	mlx_pci
 SUBDIR+=	ld_nvme
 SUBDIR+=	nvme
 SUBDIR+=	twa
 SUBDIR+=	twe
 SUBDIR+=	vio9p
 SUBDIR+=	viomb
 SUBDIR+=	virtio
 SUBDIR+=	virtio_pci
 SUBDIR+=	vioscsi
 .endif
 SUBDIR+=	examples	# build these regularly to avoid bit-rot
 .include <bsd.subdir.mk>