Get rid of unnecessary use of m4(1) by using cpp(1) instead.

(John tells me there were problems when trying this before,
but it appears to be safe these day.)

OK'ed by:	jhb
Repocopied by:	joe

9 files changed, 53 insertions, 1925 deletions

diff --git a/sys/boot/i386/btx/btx/Makefile b/sys/boot/i386/btx/btx/Makefile
index 9ed8d49..510716f 100644
--- a/sys/boot/i386/btx/btx/Makefile
+++ b/sys/boot/i386/btx/btx/Makefile
@@ -3,13 +3,11 @@
 PROG=	btx.out
 INTERNALPROG=
 NOMAN=
-SRCS=	btx.s
+SRCS=	btx.S
 CLEANFILES= btx
 
-M4?=	m4
-
 .if defined(PAGING)
-M4FLAGS+=	-DPAGING
+CFLAGS+=-DPAGING
 .endif
 
 .if defined(BOOT_BTX_NOHANG)
@@ -18,15 +16,15 @@ BOOT_BTX_FLAGS=0x1
 BOOT_BTX_FLAGS=0x0
 .endif
 
-AFLAGS+=	--defsym BTX_FLAGS=${BOOT_BTX_FLAGS}
+CFLAGS+=-DBTX_FLAGS=${BOOT_BTX_FLAGS}
 
 .if defined(BTX_SERIAL)
 BOOT_COMCONSOLE_PORT?= 0x3f8
 BOOT_COMCONSOLE_SPEED?= 9600
 B2SIOFMT?=	0x3
 
-M4FLAGS+=	-DBTX_SERIAL -DSIOPRT=${BOOT_COMCONSOLE_PORT} \
-		-DSIOFMT=${B2SIOFMT} -DSIOSPD=${BOOT_COMCONSOLE_SPEED}
+CFLAGS+=-DBTX_SERIAL -DSIOPRT=${BOOT_COMCONSOLE_PORT} \
+	-DSIOFMT=${B2SIOFMT} -DSIOSPD=${BOOT_COMCONSOLE_SPEED}
 .endif
 
 ORG=	0x9000
@@ -38,8 +36,4 @@ LDFLAGS=-N -e start -Ttext ${ORG}
 btx: btx.out
 	objcopy -S -O binary btx.out ${.TARGET}
 
-btx.o: btx.s
-	(cd ${.CURDIR}; ${M4} ${M4FLAGS} btx.s) | \
-	   ${AS} ${AFLAGS} -o ${.TARGET}
-
 .include <bsd.prog.mk>
diff --git a/sys/boot/i386/btx/btx/btx.S b/sys/boot/i386/btx/btx/btx.S
index 0215530..6695ef4 100644
--- a/sys/boot/i386/btx/btx/btx.S
+++ b/sys/boot/i386/btx/btx/btx.S
@@ -158,7 +158,7 @@ init.4: 	movb $_ESP0H,TSS_ESP0+1(%di)	# Set ESP0
 		movb $SEL_SDATA,TSS_SS0(%di)	# Set SS0
 		movb $_ESP1H,TSS_ESP1+1(%di)	# Set ESP1
 		movb $_TSSIO,TSS_MAP(%di)	# Set I/O bit map base
-ifdef(`PAGING',`
+#ifdef PAGING
 #
 # Create page directory.
 #
@@ -191,25 +191,25 @@ init.6: 	mov $0x7,%al			# Set U:W:P flags
 init.7: 	stosl				# Set entry
 		add %edx,%eax			# Next address
 		loop init.6			# Till done
-')
+#endif
 #
 # Bring up the system.
 #
 		mov $0x2820,%bx			# Set protected mode
 		callw setpic			#  IRQ offsets
 		lidt idtdesc	 		# Set IDT
-ifdef(`PAGING',`
+#ifdef PAGING
 		xor %eax,%eax			# Set base
 		mov $MEM_DIR>>0x8,%ah		#  of page
 		mov %eax,%cr3			#  directory
-')
+#endif
 		lgdt gdtdesc	 		# Set GDT
 		mov %cr0,%eax			# Switch to protected
-ifdef(`PAGING',`
+#ifdef PAGING
 		or $0x80000001,%eax             #  mode and enable paging
-',`
+#else
 		or $0x01,%eax			#  mode
-')
+#endif
 		mov %eax,%cr0			#  
 		ljmp $SEL_SCODE,$init.8		# To 32-bit code
 		.code32
@@ -240,9 +240,9 @@ init.8: 	xorl %ecx,%ecx			# Zero
 		movb $0x7,%cl			# Set remaining
 init.9:		push $0x0			#  general
 		loop init.9			#  registers
-ifdef(`BTX_SERIAL',`
+#ifdef BTX_SERIAL
 		call sio_init			# setup the serial console
-')
+#endif
 		popa				#  and initialize
 		popl %es			# Initialize
 		popl %ds			#  user
@@ -860,13 +860,13 @@ intx30: 	cmpl $SYS_EXEC,%eax		# Exec system call?
 		movl $MEM_USR,%eax		# User base address
 		addl 0xc(%esp,1),%eax		# Change to user
 		leal 0x4(%eax),%esp		#  stack
-ifdef(`PAGING',`
+#ifdef PAGING
 		movl %cr0,%eax			# Turn
 		andl $~0x80000000,%eax		#  off
 		movl %eax,%cr0			#  paging
 		xorl %eax,%eax			# Flush
 		movl %eax,%cr3			#  TLB
-')
+#endif
 		popl %eax			# Call
 		call *%eax			#  program
 intx30.1:	orb $0x1,%ss:btx_hdr+0x7	# Flag reboot
@@ -970,7 +970,7 @@ putstr: 	lodsb				# Load char
 		testb %al,%al			# End of string?
 		jnz putstr.0			# No
 		ret				# To caller
-ifdef(`BTX_SERIAL',`
+#ifdef BTX_SERIAL
 		.set SIO_PRT,SIOPRT		# Base port
 		.set SIO_FMT,SIOFMT		# 8N1
 		.set SIO_DIV,(115200/SIOSPD)	# 115200 / SPD
@@ -1043,7 +1043,7 @@ putchr.1:	pushl %eax			# Push the character
 		call sio_putc			# Output the character
 		popa				# Restore
 		ret				# To caller
-',`
+#else
 #
 # Output character AL to the console.
 #
@@ -1085,7 +1085,7 @@ putchr.3:	cmpb $SCR_ROW,%dh		# Beyond screen?
 putchr.4:	movw %dx,(%ebx) 		# Update position
 		popa				# Restore
 		ret				# To caller
-')
+#endif
 
 		.p2align 4
 #
diff --git a/sys/boot/i386/btx/btx/btx.s b/sys/boot/i386/btx/btx/btx.s
deleted file mode 100644
index 0215530..0000000
--- a/sys/boot/i386/btx/btx/btx.s
+++ /dev/null
@@ -1,1173 +0,0 @@
-#
-# Copyright (c) 1998 Robert Nordier
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms are freely
-# permitted provided that the above copyright notice and this
-# paragraph and the following disclaimer are duplicated in all
-# such forms.
-#
-# This software is provided "AS IS" and without any express or
-# implied warranties, including, without limitation, the implied
-# warranties of merchantability and fitness for a particular
-# purpose.
-#
-
-# $FreeBSD$
-
-#
-# Memory layout.
-#
-		.set MEM_BTX,0x1000		# Start of BTX memory
-		.set MEM_ESP0,0x1800		# Supervisor stack
-		.set MEM_BUF,0x1800		# Scratch buffer
-		.set MEM_ESP1,0x1e00		# Link stack
-		.set MEM_IDT,0x1e00		# IDT
-		.set MEM_TSS,0x1f98		# TSS
-		.set MEM_MAP,0x2000		# I/O bit map
-		.set MEM_DIR,0x4000		# Page directory
-		.set MEM_TBL,0x5000		# Page tables
-		.set MEM_ORG,0x9000		# BTX code
-		.set MEM_USR,0xa000		# Start of user memory
-#
-# Paging control.
-#
-		.set PAG_SIZ,0x1000		# Page size
-		.set PAG_CNT,0x1000		# Pages to map
-#
-# Segment selectors.
-#
-		.set SEL_SCODE,0x8		# Supervisor code
-		.set SEL_SDATA,0x10		# Supervisor data
-		.set SEL_RCODE,0x18		# Real mode code
-		.set SEL_RDATA,0x20		# Real mode data
-		.set SEL_UCODE,0x28|3		# User code
-		.set SEL_UDATA,0x30|3		# User data
-		.set SEL_TSS,0x38		# TSS
-#
-# Task state segment fields.
-#
-		.set TSS_ESP0,0x4		# PL 0 ESP
-		.set TSS_SS0,0x8		# PL 0 SS
-		.set TSS_ESP1,0xc		# PL 1 ESP
-		.set TSS_MAP,0x66		# I/O bit map base
-#
-# System calls.
-#
-		.set SYS_EXIT,0x0		# Exit
-		.set SYS_EXEC,0x1		# Exec
-#
-# V86 constants.
-#
-		.set V86_FLG,0x208eff		# V86 flag mask
-		.set V86_STK,0x400		# V86 stack allowance
-#
-# Dump format control bytes.
-#
-		.set DMP_X16,0x1		# Word
-		.set DMP_X32,0x2		# Long
-		.set DMP_MEM,0x4		# Memory
-		.set DMP_EOL,0x8		# End of line
-#
-# Screen defaults and assumptions.
-#
-		.set SCR_MAT,0x7		# Mode/attribute
-		.set SCR_COL,0x50		# Columns per row
-		.set SCR_ROW,0x19		# Rows per screen
-#
-# BIOS Data Area locations.
-#
-		.set BDA_MEM,0x413		# Free memory
-		.set BDA_KEYFLAGS,0x417		# Keyboard shift-state flags
-		.set BDA_SCR,0x449		# Video mode
-		.set BDA_POS,0x450		# Cursor position
-		.set BDA_BOOT,0x472		# Boot howto flag
-#
-# Derivations, for brevity.
-#
-		.set _ESP0H,MEM_ESP0>>0x8	# Byte 1 of ESP0
-		.set _ESP1H,MEM_ESP1>>0x8	# Byte 1 of ESP1
-		.set _TSSIO,MEM_MAP-MEM_TSS	# TSS I/O base
-		.set _TSSLM,MEM_DIR-MEM_TSS-1	# TSS limit
-		.set _IDTLM,MEM_TSS-MEM_IDT-1	# IDT limit
-#
-# Code segment.
-#
-		.globl start
-		.code16
-start:						# Start of code
-#
-# BTX header.
-#
-btx_hdr:	.byte 0xeb			# Machine ID
-		.byte 0xe			# Header size
-		.ascii "BTX"			# Magic
-		.byte 0x1			# Major version
-		.byte 0x1			# Minor version
-		.byte BTX_FLAGS			# Flags
-		.word PAG_CNT-MEM_ORG>>0xc	# Paging control
-		.word break-start		# Text size
-		.long 0x0			# Entry address
-#
-# Initialization routine.
-#
-init:		cli				# Disable interrupts
-		xor %ax,%ax			# Zero/segment
-		mov %ax,%ss			# Set up
-		mov $MEM_ESP0,%sp		#  stack
-		mov %ax,%es			# Address
-		mov %ax,%ds			#  data
-		pushl $0x2			# Clear
-		popfl				#  flags
-#
-# Initialize memory.
-#
-		mov $MEM_IDT,%di		# Memory to initialize
-		mov $(MEM_ORG-MEM_IDT)/2,%cx	# Words to zero
-		push %di			# Save
-		rep				# Zero-fill
-		stosw				#  memory
-		pop %di				# Restore
-#
-# Create IDT.
-#
-		mov $idtctl,%si			# Control string
-init.1: 	lodsb				# Get entry
-		cbw				#  count
-		xchg %ax,%cx			#  as word
-		jcxz init.4			# If done
-		lodsb				# Get segment
-		xchg %ax,%dx	 		#  P:DPL:type
-		lodsw				# Get control
-		xchg %ax,%bx			#  set
-		lodsw				# Get handler offset
-		mov $SEL_SCODE,%dh		# Segment selector
-init.2: 	shr %bx				# Handle this int?
-		jnc init.3			# No
-		mov %ax,(%di)			# Set handler offset
-		mov %dh,0x2(%di)		#  and selector
-		mov %dl,0x5(%di)		# Set P:DPL:type
-		add $0x4,%ax			# Next handler
-init.3: 	lea 0x8(%di),%di		# Next entry
-		loop init.2			# Till set done
-		jmp init.1			# Continue
-#
-# Initialize TSS.
-#
-init.4: 	movb $_ESP0H,TSS_ESP0+1(%di)	# Set ESP0
-		movb $SEL_SDATA,TSS_SS0(%di)	# Set SS0
-		movb $_ESP1H,TSS_ESP1+1(%di)	# Set ESP1
-		movb $_TSSIO,TSS_MAP(%di)	# Set I/O bit map base
-ifdef(`PAGING',`
-#
-# Create page directory.
-#
-		xor %edx,%edx			# Page
-		mov $PAG_SIZ>>0x8,%dh		#  size
-		xor %eax,%eax			# Zero
-		mov $MEM_DIR,%di		# Page directory
-		mov $PAG_CNT>>0xa,%cl		# Entries
-		mov $MEM_TBL|0x7,%ax	 	# First entry
-init.5: 	stosl				# Write entry
-		add %dx,%ax			# To next
-		loop init.5			# Till done
-#
-# Create page tables.
-#
-		mov $MEM_TBL,%di		# Page table
-		mov $PAG_CNT>>0x8,%ch		# Entries
-		xor %ax,%ax			# Start address
-init.6: 	mov $0x7,%al			# Set U:W:P flags
-		cmp btx_hdr+0x8,%cx	 	# Standard user page?
-		jb init.7			# Yes
-		cmp $PAG_CNT-MEM_BTX>>0xc,%cx	# BTX memory?
-		jae init.7			# No or first page
-		and $~0x2,%al			# Clear W flag
-		cmp $PAG_CNT-MEM_USR>>0xc,%cx	# User page zero?
-		jne init.7			# No
-		testb $0x80,btx_hdr+0x7		# Unmap it?
-		jz init.7			# No
-		and $~0x1,%al			# Clear P flag
-init.7: 	stosl				# Set entry
-		add %edx,%eax			# Next address
-		loop init.6			# Till done
-')
-#
-# Bring up the system.
-#
-		mov $0x2820,%bx			# Set protected mode
-		callw setpic			#  IRQ offsets
-		lidt idtdesc	 		# Set IDT
-ifdef(`PAGING',`
-		xor %eax,%eax			# Set base
-		mov $MEM_DIR>>0x8,%ah		#  of page
-		mov %eax,%cr3			#  directory
-')
-		lgdt gdtdesc	 		# Set GDT
-		mov %cr0,%eax			# Switch to protected
-ifdef(`PAGING',`
-		or $0x80000001,%eax             #  mode and enable paging
-',`
-		or $0x01,%eax			#  mode
-')
-		mov %eax,%cr0			#  
-		ljmp $SEL_SCODE,$init.8		# To 32-bit code
-		.code32
-init.8: 	xorl %ecx,%ecx			# Zero
-		movb $SEL_SDATA,%cl		# To 32-bit
-		movw %cx,%ss			#  stack
-#
-# Launch user task.
-#
-		movb $SEL_TSS,%cl		# Set task
-		ltr %cx				#  register
-		movl $MEM_USR,%edx		# User base address
-		movzwl %ss:BDA_MEM,%eax 	# Get free memory
-		shll $0xa,%eax			# To bytes
-		subl $0x1000,%eax		# Less arg space
-		subl %edx,%eax			# Less base
-		movb $SEL_UDATA,%cl		# User data selector
-		pushl %ecx			# Set SS
-		pushl %eax			# Set ESP
-		push $0x202			# Set flags (IF set)
-		push $SEL_UCODE			# Set CS
-		pushl btx_hdr+0xc		# Set EIP
-		pushl %ecx			# Set GS
-		pushl %ecx			# Set FS
-		pushl %ecx			# Set DS
-		pushl %ecx			# Set ES
-		pushl %edx			# Set EAX
-		movb $0x7,%cl			# Set remaining
-init.9:		push $0x0			#  general
-		loop init.9			#  registers
-ifdef(`BTX_SERIAL',`
-		call sio_init			# setup the serial console
-')
-		popa				#  and initialize
-		popl %es			# Initialize
-		popl %ds			#  user
-		popl %fs			#  segment
-		popl %gs			#  registers
-		iret				# To user mode
-#
-# Exit routine.
-#
-exit:		cli				# Disable interrupts
-		movl $MEM_ESP0,%esp		# Clear stack
-#
-# Turn off paging.
-#
-		movl %cr0,%eax			# Get CR0
-		andl $~0x80000000,%eax		# Disable
-		movl %eax,%cr0			#  paging
-		xorl %ecx,%ecx			# Zero
-		movl %ecx,%cr3			# Flush TLB
-#
-# Restore the GDT in case we caught a kernel trap.
-#
-		lgdt gdtdesc	 		# Set GDT
-#
-# To 16 bits.
-#
-		ljmpw $SEL_RCODE,$exit.1	# Reload CS
-		.code16
-exit.1: 	mov $SEL_RDATA,%cl		# 16-bit selector
-		mov %cx,%ss			# Reload SS
-		mov %cx,%ds			# Load
-		mov %cx,%es			#  remaining
-		mov %cx,%fs			#  segment
-		mov %cx,%gs			#  registers
-#
-# To real-address mode.
-#
-		dec %ax				# Switch to
-		mov %eax,%cr0			#  real mode
-		ljmp $0x0,$exit.2		# Reload CS
-exit.2: 	xor %ax,%ax			# Real mode segment
-		mov %ax,%ss			# Reload SS
-		mov %ax,%ds			# Address data
-		mov $0x7008,%bx			# Set real mode
-		callw setpic			#  IRQ offsets
-		lidt ivtdesc	 		# Set IVT
-#
-# Reboot or await reset.
-#
-		sti				# Enable interrupts
-		testb $0x1,btx_hdr+0x7		# Reboot?
-exit.3:		jz exit.3			# No
-		movw $0x1234, BDA_BOOT		# Do a warm boot
-		ljmp $0xf000,$0xfff0		# reboot the machine
-#
-# Set IRQ offsets by reprogramming 8259A PICs.
-#
-setpic: 	in $0x21,%al			# Save master
-		push %ax			#  IMR
-		in $0xa1,%al			# Save slave
-		push %ax			#  IMR
-		movb $0x11,%al			# ICW1 to
-		outb %al,$0x20			#  master,
-		outb %al,$0xa0			#  slave
-		movb %bl,%al			# ICW2 to
-		outb %al,$0x21			#  master
-		movb %bh,%al			# ICW2 to
-		outb %al,$0xa1			#  slave
-		movb $0x4,%al			# ICW3 to
-		outb %al,$0x21			#  master
-		movb $0x2,%al			# ICW3 to
-		outb %al,$0xa1			#  slave
-		movb $0x1,%al			# ICW4 to
-		outb %al,$0x21			#  master,
-		outb %al,$0xa1			#  slave
-		pop %ax				# Restore slave
-		outb %al,$0xa1			#  IMR
-		pop %ax				# Restore master
-		outb %al,$0x21			#  IMR
-		retw				# To caller
-		.code32
-#
-# Initiate return from V86 mode to user mode.
-#
-inthlt: 	hlt				# To supervisor mode
-#
-# Exception jump table.
-#
-intx00: 	push $0x0			# Int 0x0: #DE
-		jmp ex_noc			# Divide error
-		push $0x1			# Int 0x1: #DB
-		jmp ex_noc			# Debug
-		push $0x3			# Int 0x3: #BP
-		jmp ex_noc			# Breakpoint
-		push $0x4			# Int 0x4: #OF
-		jmp ex_noc			# Overflow
-		push $0x5			# Int 0x5: #BR
-		jmp ex_noc			# BOUND range exceeded
-		push $0x6			# Int 0x6: #UD
-		jmp ex_noc			# Invalid opcode
-		push $0x7			# Int 0x7: #NM
-		jmp ex_noc			# Device not available
-		push $0x8			# Int 0x8: #DF
-		jmp except			# Double fault
-		push $0xa			# Int 0xa: #TS
-		jmp except			# Invalid TSS
-		push $0xb			# Int 0xb: #NP
-		jmp except			# Segment not present
-		push $0xc			# Int 0xc: #SS
-		jmp except			# Stack segment fault
-		push $0xd			# Int 0xd: #GP
-		jmp ex_v86			# General protection
-		push $0xe			# Int 0xe: #PF
-		jmp except			# Page fault
-intx10: 	push $0x10			# Int 0x10: #MF
-		jmp ex_noc			# Floating-point error
-#
-# Handle #GP exception.
-#
-ex_v86: 	testb $0x2,0x12(%esp,1) 	# V86 mode?
-		jz except			# No
-		jmp v86mon			# To monitor
-#
-# Save a zero error code.
-#
-ex_noc: 	pushl (%esp,1)			# Duplicate int no
-		movb $0x0,0x4(%esp,1)		# Fake error code
-#
-# Handle exception.
-#
-except: 	cld				# String ops inc
-		pushl %ds			# Save
-		pushl %es			#  most
-		pusha				#  registers
-		movb $0x6,%al			# Push loop count
-		testb $0x2,0x3a(%esp,1) 	# V86 mode?
-		jnz except.1			# Yes
-		pushl %gs			# Set GS
-		pushl %fs			# Set FS
-		pushl %ds			# Set DS
-		pushl %es			# Set ES
-		movb $0x2,%al			# Push loop count
-		cmpw $SEL_SCODE,0x44(%esp,1)	# Supervisor mode?
-		jne except.1			# No
-		pushl %ss			# Set SS
-		leal 0x50(%esp,1),%eax		# Set
-		pushl %eax			#  ESP
-		jmp except.2			# Join common code
-except.1:	pushl 0x50(%esp,1)		# Set GS, FS, DS, ES
-		decb %al			#  (if V86 mode), and
-		jne except.1			#  SS, ESP
-except.2:	push $SEL_SDATA			# Set up
-		popl %ds			#  to
-		pushl %ds			#  address
-		popl %es			#  data
-		movl %esp,%ebx			# Stack frame
-		movl $dmpfmt,%esi		# Dump format string
-		movl $MEM_BUF,%edi		# Buffer
-		pushl %edi			# Dump to
-		call dump			#  buffer
-		popl %esi			#  and
-		call putstr			#  display
-		leal 0x18(%esp,1),%esp		# Discard frame
-		popa				# Restore
-		popl %es			#  registers
-		popl %ds			#  saved
-		cmpb $0x3,(%esp,1)		# Breakpoint?
-		je except.3			# Yes
-		cmpb $0x1,(%esp,1)		# Debug?
-		jne except.2a			# No
-		testl $0x100,0x10(%esp,1)	# Trap flag set?
-		jnz except.3			# Yes
-except.2a:	jmp exit			# Exit
-except.3:	leal 0x8(%esp,1),%esp		# Discard err, int no
-		iret				# From interrupt
-#
-# Return to user mode from V86 mode.
-#
-intrtn: 	cld				# String ops inc
-		pushl %ds			# Address
-		popl %es			#  data
-		leal 0x3c(%ebp),%edx		# V86 Segment registers
-		movl MEM_TSS+TSS_ESP1,%esi	# Link stack pointer
-		lodsl				# INT_V86 args pointer
-		movl %esi,%ebx			# Saved exception frame
-		testl %eax,%eax 		# INT_V86 args?
-		jz intrtn.2			# No
-		movl $MEM_USR,%edi		# User base
-		movl 0x1c(%esi),%ebx		# User ESP
-		movl %eax,(%edi,%ebx,1) 	# Restore to user stack
-		leal 0x8(%edi,%eax,1),%edi	# Arg segment registers
-		testb $0x4,-0x6(%edi)		# Return flags?
-		jz intrtn.1			# No
-		movl 0x30(%ebp),%eax		# Get V86 flags
-		movw %ax,0x18(%esi)		# Set user flags
-intrtn.1:	leal 0x10(%esi),%ebx		# Saved exception frame
-		xchgl %edx,%esi 		# Segment registers
-		movb $0x4,%cl			# Update seg regs
-		rep				#  in INT_V86
-		movsl				#  args
-intrtn.2:	movl %edx,%esi			# Segment registers
-		leal 0x28(%ebp),%edi		# Set up seg
-		movb $0x4,%cl			#  regs for
-		rep				#  later
-		movsl				#  pop
-		movl %ebx,%esi			# Restore exception
-		movb $0x5,%cl			#  frame to
-		rep				#  supervisor
-		movsl				#  stack
-		movl %esi,MEM_TSS+TSS_ESP1	# Link stack pointer
-		popa				# Restore
-		leal 0x8(%esp,1),%esp		# Discard err, int no
-		popl %es			# Restore
-		popl %ds			#  user
-		popl %fs			#  segment
-		popl %gs			#  registers
-		iret				# To user mode
-#
-# V86 monitor.
-#
-v86mon: 	cld				# String ops inc
-		pushl $SEL_SDATA		# Set up for
-		popl %ds			#  flat addressing
-		pusha				# Save registers
-		movl %esp,%ebp			# Address stack frame
-		movzwl 0x2c(%ebp),%edi		# Load V86 CS
-		shll $0x4,%edi			# To linear
-		movl 0x28(%ebp),%esi		# Load V86 IP
-		addl %edi,%esi			# Code pointer
-		xorl %ecx,%ecx			# Zero
-		movb $0x2,%cl			# 16-bit operands
-		xorl %eax,%eax			# Zero
-v86mon.1:	lodsb				# Get opcode
-		cmpb $0x66,%al			# Operand size prefix?
-		jne v86mon.2			# No
-		movb $0x4,%cl			# 32-bit operands
-		jmp v86mon.1			# Continue
-v86mon.2:	cmpb $0xf4,%al			# HLT?
-		jne v86mon.3			# No
-		cmpl $inthlt+0x1,%esi		# Is inthlt?
-		jne v86mon.7			# No (ignore)
-		jmp intrtn			# Return to user mode
-v86mon.3:	cmpb $0xf,%al			# Prefixed instruction?
-		jne v86mon.4			# No
-		cmpb $0x09,(%esi)		# Is it a WBINVD?
-		je v86wbinvd			# Yes
-		cmpb $0x30,(%esi)		# Is it a WRMSR?
-		je v86wrmsr			# Yes
-		cmpb $0x32,(%esi)		# Is it a RDMSR?
-		je v86rdmsr			# Yes
-		cmpb $0x20,(%esi)		# Is this a
-		jne v86mon.4			#  MOV EAX,CR0
-		cmpb $0xc0,0x1(%esi)		#  instruction?
-		je v86mov			# Yes
-v86mon.4:	cmpb $0xfa,%al			# CLI?
-		je v86cli			# Yes
-		cmpb $0xfb,%al			# STI?
-		je v86sti			# Yes
-		movzwl 0x38(%ebp),%ebx		# Load V86 SS
-		shll $0x4,%ebx			# To offset
-		pushl %ebx			# Save
-		addl 0x34(%ebp),%ebx		# Add V86 SP
-		movl 0x30(%ebp),%edx		# Load V86 flags
-		cmpb $0x9c,%al			# PUSHF/PUSHFD?
-		je v86pushf			# Yes
-		cmpb $0x9d,%al			# POPF/POPFD?
-		je v86popf			# Yes
-		cmpb $0xcd,%al			# INT imm8?
-		je v86intn			# Yes
-		cmpb $0xcf,%al			# IRET/IRETD?
-		je v86iret			# Yes
-		popl %ebx			# Restore
-		popa				# Restore
-		jmp except			# Handle exception
-v86mon.5:	movl %edx,0x30(%ebp)		# Save V86 flags
-v86mon.6:	popl %edx			# V86 SS adjustment
-		subl %edx,%ebx			# Save V86
-		movl %ebx,0x34(%ebp)		#  SP
-v86mon.7:	subl %edi,%esi			# From linear
-		movl %esi,0x28(%ebp)		# Save V86 IP
-		popa				# Restore
-		leal 0x8(%esp,1),%esp		# Discard int no, error
-		iret				# To V86 mode
-#
-# Emulate MOV EAX,CR0.
-#
-v86mov: 	movl %cr0,%eax			# CR0 to
-		movl %eax,0x1c(%ebp)		#  saved EAX
-		incl %esi			# Adjust IP
-#
-# Return from emulating a 0x0f prefixed instruction
-#
-v86preret:	incl %esi			# Adjust IP
-		jmp v86mon.7			# Finish up
-#
-# Emulate WBINVD
-#
-v86wbinvd:	wbinvd				# Write back and invalidate
-						#  cache
-		jmp v86preret			# Finish up
-#
-# Emulate WRMSR
-#
-v86wrmsr:	movl 0x18(%ebp),%ecx		# Get user's %ecx (MSR to write)
-		movl 0x14(%ebp),%edx		# Load the value
-		movl 0x1c(%ebp),%eax		#  to write
-		wrmsr				# Write MSR
-		jmp v86preret			# Finish up
-#
-# Emulate RDMSR
-#
-v86rdmsr:	movl 0x18(%ebp),%ecx		# MSR to read
-		rdmsr				# Read the MSR
-		movl %eax,0x1c(%ebp)		# Return the value of
-		movl %edx,0x14(%ebp)		#  the MSR to the user
-		jmp v86preret			# Finish up
-#
-# Emulate CLI.
-#
-v86cli: 	andb $~0x2,0x31(%ebp)		# Clear IF
-		jmp v86mon.7			# Finish up
-#
-# Emulate STI.
-#
-v86sti: 	orb $0x2,0x31(%ebp)		# Set IF
-		jmp v86mon.7			# Finish up
-#
-# Emulate PUSHF/PUSHFD.
-#
-v86pushf:	subl %ecx,%ebx			# Adjust SP
-		cmpb $0x4,%cl			# 32-bit
-		je v86pushf.1			# Yes
-		data16				# 16-bit
-v86pushf.1:	movl %edx,(%ebx)		# Save flags
-		jmp v86mon.6			# Finish up
-#
-# Emulate IRET/IRETD.
-#
-v86iret:	movzwl (%ebx),%esi		# Load V86 IP
-		movzwl 0x2(%ebx),%edi		# Load V86 CS
-		leal 0x4(%ebx),%ebx		# Adjust SP
-		movl %edi,0x2c(%ebp)		# Save V86 CS
-		xorl %edi,%edi			# No ESI adjustment
-#
-# Emulate POPF/POPFD (and remainder of IRET/IRETD).
-#
-v86popf:	cmpb $0x4,%cl			# 32-bit?
-		je v86popf.1			# Yes
-		movl %edx,%eax			# Initialize
-		data16				# 16-bit
-v86popf.1:	movl (%ebx),%eax		# Load flags
-		addl %ecx,%ebx			# Adjust SP
-		andl $V86_FLG,%eax		# Merge
-		andl $~V86_FLG,%edx		#  the
-		orl %eax,%edx			#  flags
-		jmp v86mon.5			# Finish up
-#
-# trap int 15, function 87
-# reads %es:%si from saved registers on stack to find a GDT containing
-# source and destination locations
-# reads count of words from saved %cx
-# returns success by setting %ah to 0
-#
-int15_87:	pushl %eax			# Save 
-		pushl %ebx			#  some information 
-		pushl %esi			#  onto the stack.
-		pushl %edi
-		xorl %eax,%eax			# clean EAX 
-		xorl %ebx,%ebx			# clean EBX 
-		movl 0x4(%ebp),%esi		# Get user's ESI
-		movl 0x3C(%ebp),%ebx		# store ES
-		movw %si,%ax			# store SI
-		shll $0x4,%ebx			# Make it a seg.
-		addl %eax,%ebx			# ebx=(es<<4)+si
-		movb 0x14(%ebx),%al		# Grab the
-		movb 0x17(%ebx),%ah		#  necessary
-		shll $0x10,%eax			#  information
-		movw 0x12(%ebx),%ax		#  from
-		movl %eax,%esi			#  the
-		movb 0x1c(%ebx),%al		#  GDT in order to
-		movb 0x1f(%ebx),%ah		#  have %esi offset
-		shll $0x10,%eax			#  of source and %edi
-		movw 0x1a(%ebx),%ax		#  of destination.
-		movl %eax,%edi
-		pushl %ds			# Make:
-		popl %es			# es = ds
-		pushl %ecx			# stash ECX
-		xorl %ecx,%ecx			# highw of ECX is clear
-		movw 0x18(%ebp),%cx		# Get user's ECX
-		shll $0x1,%ecx			# Convert from num words to num
-						#  bytes
-		rep				# repeat...
-		movsb				#  perform copy.
-		popl %ecx			# Restore
-		popl %edi
-		popl %esi			#  previous
-		popl %ebx			#  register
-		popl %eax			#  values.
-		movb $0x0,0x1d(%ebp)		# set ah = 0 to indicate
-						#  success
-		andb $0xfe,%dl			# clear CF
-		jmp v86mon.5			# Finish up
-
-#
-# Reboot the machine by setting the reboot flag and exiting
-#
-reboot:		orb $0x1,btx_hdr+0x7		# Set the reboot flag
-		jmp exit			# Terminate BTX and reboot
-
-#
-# Emulate INT imm8... also make sure to check if it's int 15/87
-#
-v86intn:	lodsb				# Get int no
-		cmpb $0x19,%al			# is it int 19?
-		je reboot			#  yes, reboot the machine
-		cmpb $0x15,%al			# is it int 15?
-		jne v86intn.3			#  no, skip parse
-		pushl %eax                      # stash EAX
-		movl 0x1c(%ebp),%eax		# user's saved EAX
-		cmpb $0x87,%ah			# is it the memcpy subfunction?
-		jne v86intn.1			#  no, keep checking
-		popl %eax			# get the stack straight
-		jmp int15_87			# it's our cue
-v86intn.1:	cmpw $0x4f53,%ax		# is it the delete key callout?
-		jne v86intn.2			#  no, handle the int normally
-		movb BDA_KEYFLAGS,%al		# get the shift key state
-		andb $0xc,%al			# mask off just Ctrl and Alt
-		cmpb $0xc,%al			# are both Ctrl and Alt down?
-		jne v86intn.2			#  no, handle the int normally
-		popl %eax			# restore EAX
-		jmp reboot			# reboot the machine
-v86intn.2:	popl %eax			# restore EAX
-v86intn.3:	subl %edi,%esi			# From
-		shrl $0x4,%edi			#  linear
-		movw %dx,-0x2(%ebx)		# Save flags
-		movw %di,-0x4(%ebx)		# Save CS
-		leal -0x6(%ebx),%ebx		# Adjust SP
-		movw %si,(%ebx) 		# Save IP
-		shll $0x2,%eax			# Scale
-		movzwl (%eax),%esi		# Load IP
-		movzwl 0x2(%eax),%edi		# Load CS
-		movl %edi,0x2c(%ebp)		# Save CS
-		xorl %edi,%edi			# No ESI adjustment
-		andb $~0x1,%dh			# Clear TF
-		jmp v86mon.5			# Finish up
-#
-# Hardware interrupt jump table.
-#
-intx20: 	push $0x8			# Int 0x20: IRQ0
-		jmp int_hw			# V86 int 0x8
-		push $0x9			# Int 0x21: IRQ1
-		jmp int_hw			# V86 int 0x9
-		push $0xa			# Int 0x22: IRQ2
-		jmp int_hw			# V86 int 0xa
-		push $0xb			# Int 0x23: IRQ3
-		jmp int_hw			# V86 int 0xb
-		push $0xc			# Int 0x24: IRQ4
-		jmp int_hw			# V86 int 0xc
-		push $0xd			# Int 0x25: IRQ5
-		jmp int_hw			# V86 int 0xd
-		push $0xe			# Int 0x26: IRQ6
-		jmp int_hw			# V86 int 0xe
-		push $0xf			# Int 0x27: IRQ7
-		jmp int_hw			# V86 int 0xf
-		push $0x70			# Int 0x28: IRQ8
-		jmp int_hw			# V86 int 0x70
-		push $0x71			# Int 0x29: IRQ9
-		jmp int_hw			# V86 int 0x71
-		push $0x72			# Int 0x2a: IRQ10
-		jmp int_hw			# V86 int 0x72
-		push $0x73			# Int 0x2b: IRQ11
-		jmp int_hw			# V86 int 0x73
-		push $0x74			# Int 0x2c: IRQ12
-		jmp int_hw			# V86 int 0x74
-		push $0x75			# Int 0x2d: IRQ13
-		jmp int_hw			# V86 int 0x75
-		push $0x76			# Int 0x2e: IRQ14
-		jmp int_hw			# V86 int 0x76
-		push $0x77			# Int 0x2f: IRQ15
-		jmp int_hw			# V86 int 0x77
-#
-# Reflect hardware interrupts.
-#
-int_hw: 	testb $0x2,0xe(%esp,1)		# V86 mode?
-		jz intusr			# No
-		pushl $SEL_SDATA		# Address
-		popl %ds			#  data
-		xchgl %eax,(%esp,1)		# Swap EAX, int no
-		pushl %ebp			# Address
-		movl %esp,%ebp			#  stack frame
-		pushl %ebx			# Save
-		shll $0x2,%eax			# Get int
-		movl (%eax),%eax		#  vector
-		subl $0x6,0x14(%ebp)		# Adjust V86 ESP
-		movzwl 0x18(%ebp),%ebx		# V86 SS
-		shll $0x4,%ebx			#  * 0x10
-		addl 0x14(%ebp),%ebx		#  + V86 ESP
-		xchgw %ax,0x8(%ebp)		# Swap V86 IP
-		rorl $0x10,%eax 		# Swap words
-		xchgw %ax,0xc(%ebp)		# Swap V86 CS
-		roll $0x10,%eax 		# Swap words
-		movl %eax,(%ebx)		# CS:IP for IRET
-		movl 0x10(%ebp),%eax		# V86 flags
-		movw %ax,0x4(%ebx)		# Flags for IRET
-		andb $~0x3,0x11(%ebp)		# Clear IF, TF
-		popl %ebx			# Restore
-		popl %ebp			#  saved
-		popl %eax			#  registers
-		iret				# To V86 mode
-#
-# Invoke V86 interrupt from user mode, with arguments.
-#
-intx31: 	stc				# Have btx_v86
-		pushl %eax			# Missing int no
-#
-# Invoke V86 interrupt from user mode.
-#
-intusr: 	std				# String ops dec
-		pushl %eax			# Expand
-		pushl %eax			#  stack
-		pushl %eax			#  frame
-		pusha				# Save
-		pushl %gs			# Save
-		movl %esp,%eax			#  seg regs
-		pushl %fs			#  and
-		pushl %ds			#  point
-		pushl %es			#  to them
-		push $SEL_SDATA			# Set up
-		popl %ds			#  to
-		pushl %ds			#  address
-		popl %es			#  data
-		movl $MEM_USR,%ebx		# User base
-		movl %ebx,%edx			#  address
-		jc intusr.1			# If btx_v86
-		xorl %edx,%edx			# Control flags
-		xorl %ebp,%ebp			# btx_v86 pointer
-intusr.1:	leal 0x50(%esp,1),%esi		# Base of frame
-		pushl %esi			# Save
-		addl -0x4(%esi),%ebx		# User ESP
-		movl MEM_TSS+TSS_ESP1,%edi	# Link stack pointer
-		leal -0x4(%edi),%edi		# Adjust for push
-		xorl %ecx,%ecx			# Zero
-		movb $0x5,%cl			# Push exception
-		rep				#  frame on
-		movsl				#  link stack
-		xchgl %eax,%esi 		# Saved seg regs
-		movl 0x40(%esp,1),%eax		# Get int no
-		testl %edx,%edx 		# Have btx_v86?
-		jz intusr.2			# No
-		movl (%ebx),%ebp		# btx_v86 pointer
-		movb $0x4,%cl			# Count
-		addl %ecx,%ebx			# Adjust for pop
-		rep				# Push saved seg regs
-		movsl				#  on link stack
-		addl %ebp,%edx			# Flatten btx_v86 ptr
-		leal 0x14(%edx),%esi		# Seg regs pointer
-		movl 0x4(%edx),%eax		# Get int no/address
-		movzwl 0x2(%edx),%edx		# Get control flags
-intusr.2:	movl %ebp,(%edi)		# Push btx_v86 and
-		movl %edi,MEM_TSS+TSS_ESP1	#  save link stack ptr
-		popl %edi			# Base of frame
-		xchgl %eax,%ebp 		# Save intno/address
-		movl 0x48(%esp,1),%eax		# Get flags
-		testb $0x2,%dl			# Simulate CALLF?
-		jnz intusr.3			# Yes
-		decl %ebx			# Push flags
-		decl %ebx			#  on V86
-		movw %ax,(%ebx) 		#  stack
-intusr.3:	movb $0x4,%cl			# Count
-		subl %ecx,%ebx			# Push return address
-		movl $inthlt,(%ebx)		#  on V86 stack
-		rep				# Copy seg regs to
-		movsl				#  exception frame
-		xchgl %eax,%ecx 		# Save flags
-		movl %ebx,%eax			# User ESP
-		subl $V86_STK,%eax		# Less bytes
-		ja intusr.4			#  to
-		xorl %eax,%eax			#  keep
-intusr.4:	shrl $0x4,%eax			# Gives segment
-		stosl				# Set SS
-		shll $0x4,%eax			# To bytes
-		xchgl %eax,%ebx 		# Swap
-		subl %ebx,%eax			# Gives offset
-		stosl				# Set ESP
-		xchgl %eax,%ecx 		# Get flags
-		btsl $0x11,%eax 		# Set VM
-		andb $~0x1,%ah			# Clear TF
-		stosl				# Set EFL
-		xchgl %eax,%ebp 		# Get int no/address
-		testb $0x1,%dl			# Address?
-		jnz intusr.5			# Yes
-		shll $0x2,%eax			# Scale
-		movl (%eax),%eax		# Load int vector
-intusr.5:	movl %eax,%ecx			# Save
-		shrl $0x10,%eax 		# Gives segment
-		stosl				# Set CS
-		movw %cx,%ax			# Restore
-		stosl				# Set EIP
-		leal 0x10(%esp,1),%esp		# Discard seg regs
-		popa				# Restore
-		iret				# To V86 mode
-#
-# System Call.
-#
-intx30: 	cmpl $SYS_EXEC,%eax		# Exec system call?
-		jne intx30.1			# No
-		pushl %ss			# Set up
-		popl %es			#  all
-		pushl %es			#  segment
-		popl %ds			#  registers
-		pushl %ds			#  for the
-		popl %fs			#  program
-		pushl %fs			#  we're
-		popl %gs			#  invoking
-		movl $MEM_USR,%eax		# User base address
-		addl 0xc(%esp,1),%eax		# Change to user
-		leal 0x4(%eax),%esp		#  stack
-ifdef(`PAGING',`
-		movl %cr0,%eax			# Turn
-		andl $~0x80000000,%eax		#  off
-		movl %eax,%cr0			#  paging
-		xorl %eax,%eax			# Flush
-		movl %eax,%cr3			#  TLB
-')
-		popl %eax			# Call
-		call *%eax			#  program
-intx30.1:	orb $0x1,%ss:btx_hdr+0x7	# Flag reboot
-		jmp exit			# Exit
-#
-# Dump structure [EBX] to [EDI], using format string [ESI].
-#
-dump.0: 	stosb				# Save char
-dump:		lodsb				# Load char
-		testb %al,%al			# End of string?
-		jz dump.10			# Yes
-		testb $0x80,%al 		# Control?
-		jz dump.0			# No
-		movb %al,%ch			# Save control
-		movb $'=',%al			# Append
-		stosb				#  '='
-		lodsb				# Get offset
-		pushl %esi			# Save
-		movsbl %al,%esi 		# To
-		addl %ebx,%esi			#  pointer
-		testb $DMP_X16,%ch		# Dump word?
-		jz dump.1			# No
-		lodsw				# Get and
-		call hex16			#  dump it
-dump.1: 	testb $DMP_X32,%ch		# Dump long?
-		jz dump.2			# No
-		lodsl				# Get and
-		call hex32			#  dump it
-dump.2: 	testb $DMP_MEM,%ch		# Dump memory?
-		jz dump.8			# No
-		pushl %ds			# Save
-		testb $0x2,0x52(%ebx)		# V86 mode?
-		jnz dump.3			# Yes
-		verr 0x4(%esi)	 		# Readable selector?
-		jnz dump.3			# No
-		ldsl (%esi),%esi		# Load pointer
-		jmp dump.4			# Join common code
-dump.3: 	lodsl				# Set offset
-		xchgl %eax,%edx 		# Save
-		lodsl				# Get segment
-		shll $0x4,%eax			#  * 0x10
-		addl %edx,%eax			#  + offset
-		xchgl %eax,%esi 		# Set pointer
-dump.4: 	movb $2,%dl			# Num lines
-dump.4a:	movb $0x10,%cl			# Bytes to dump
-dump.5: 	lodsb				# Get byte and
-		call hex8			#  dump it
-		decb %cl			# Keep count
-		jz dump.6a			# If done
-		movb $'-',%al			# Separator
-		cmpb $0x8,%cl			# Half way?
-		je dump.6			# Yes
-		movb $' ',%al			# Use space
-dump.6: 	stosb				# Save separator
-		jmp dump.5			# Continue
-dump.6a:	decb %dl			# Keep count
-		jz dump.7			# If done
-		movb $0xa,%al			# Line feed
-		stosb				# Save one
-		movb $7,%cl			# Leading
-		movb $' ',%al			#  spaces
-dump.6b:	stosb				# Dump
-		decb %cl			#  spaces
-		jnz dump.6b
-		jmp dump.4a			# Next line
-dump.7: 	popl %ds			# Restore
-dump.8: 	popl %esi			# Restore
-		movb $0xa,%al			# Line feed
-		testb $DMP_EOL,%ch		# End of line?
-		jnz dump.9			# Yes
-		movb $' ',%al			# Use spaces
-		stosb				# Save one
-dump.9: 	jmp dump.0			# Continue
-dump.10:	stosb				# Terminate string
-		ret				# To caller
-#
-# Convert EAX, AX, or AL to hex, saving the result to [EDI].
-#
-hex32:		pushl %eax			# Save
-		shrl $0x10,%eax 		# Do upper
-		call hex16			#  16
-		popl %eax			# Restore
-hex16:		call hex16.1			# Do upper 8
-hex16.1:	xchgb %ah,%al			# Save/restore
-hex8:		pushl %eax			# Save
-		shrb $0x4,%al			# Do upper
-		call hex8.1			#  4
-		popl %eax			# Restore
-hex8.1: 	andb $0xf,%al			# Get lower 4
-		cmpb $0xa,%al			# Convert
-		sbbb $0x69,%al			#  to hex
-		das				#  digit
-		orb $0x20,%al			# To lower case
-		stosb				# Save char
-		ret				# (Recursive)
-#
-# Output zero-terminated string [ESI] to the console.
-#
-putstr.0:	call putchr			# Output char
-putstr: 	lodsb				# Load char
-		testb %al,%al			# End of string?
-		jnz putstr.0			# No
-		ret				# To caller
-ifdef(`BTX_SERIAL',`
-		.set SIO_PRT,SIOPRT		# Base port
-		.set SIO_FMT,SIOFMT		# 8N1
-		.set SIO_DIV,(115200/SIOSPD)	# 115200 / SPD
-
-# void sio_init(void)
-
-sio_init:	movw $SIO_PRT+0x3,%dx		# Data format reg
-		movb $SIO_FMT|0x80,%al		# Set format
-		outb %al,(%dx)			#  and DLAB
-		pushl %edx			# Save
-		subb $0x3,%dl			# Divisor latch reg
-		movw $SIO_DIV,%ax		# Set
-		outw %ax,(%dx)			#  BPS
-		popl %edx			# Restore
-		movb $SIO_FMT,%al		# Clear
-		outb %al,(%dx)			#  DLAB
-		incl %edx			# Modem control reg
-		movb $0x3,%al			# Set RTS,
-		outb %al,(%dx)			#  DTR
-		incl %edx			# Line status reg
-
-# void sio_flush(void)
-
-sio_flush.0:	call sio_getc.1 		# Get character
-sio_flush:	call sio_ischar 		# Check for character
-		jnz sio_flush.0 		# Till none
-		ret				# To caller
-
-# void sio_putc(int c)
-
-sio_putc:	movw $SIO_PRT+0x5,%dx		# Line status reg
-		xor %ecx,%ecx			# Timeout
-		movb $0x40,%ch			#  counter
-sio_putc.1:	inb (%dx),%al			# Transmitter
-		testb $0x20,%al 		#  buffer empty?
-		loopz sio_putc.1		# No
-		jz sio_putc.2			# If timeout
-		movb 0x4(%esp,1),%al		# Get character
-		subb $0x5,%dl			# Transmitter hold reg
-		outb %al,(%dx)			# Write character
-sio_putc.2:	ret $0x4			# To caller
-
-# int sio_getc(void)
-
-sio_getc:	call sio_ischar 		# Character available?
-		jz sio_getc			# No
-sio_getc.1:	subb $0x5,%dl			# Receiver buffer reg
-		inb (%dx),%al			# Read character
-		ret				# To caller
-
-# int sio_ischar(void)
-
-sio_ischar:	movw $SIO_PRT+0x5,%dx		# Line status register
-		xorl %eax,%eax			# Zero
-		inb (%dx),%al			# Received data
-		andb $0x1,%al			#  ready?
-		ret				# To caller
-
-#
-# Output character AL to the serial console.
-#
-putchr: 	pusha				# Save
-		cmpb $10, %al			# is it a newline?
-		jne putchr.1			#  no?, then leave
-		push $13			# output a carriage
-		call sio_putc			#  return first
-		movb $10, %al			# restore %al
-putchr.1:	pushl %eax			# Push the character
-						#  onto the stack
-		call sio_putc			# Output the character
-		popa				# Restore
-		ret				# To caller
-',`
-#
-# Output character AL to the console.
-#
-putchr: 	pusha				# Save
-		xorl %ecx,%ecx			# Zero for loops
-		movb $SCR_MAT,%ah		# Mode/attribute
-		movl $BDA_POS,%ebx		# BDA pointer
-		movw (%ebx),%dx 		# Cursor position
-		movl $0xb8000,%edi		# Regen buffer (color)
-		cmpb %ah,BDA_SCR-BDA_POS(%ebx)	# Mono mode?
-		jne putchr.1			# No
-		xorw %di,%di			# Regen buffer (mono)
-putchr.1:	cmpb $0xa,%al			# New line?
-		je putchr.2			# Yes
-		xchgl %eax,%ecx 		# Save char
-		movb $SCR_COL,%al		# Columns per row
-		mulb %dh			#  * row position
-		addb %dl,%al			#  + column
-		adcb $0x0,%ah			#  position
-		shll %eax			#  * 2
-		xchgl %eax,%ecx 		# Swap char, offset
-		movw %ax,(%edi,%ecx,1)		# Write attr:char
-		incl %edx			# Bump cursor
-		cmpb $SCR_COL,%dl		# Beyond row?
-		jb putchr.3			# No
-putchr.2:	xorb %dl,%dl			# Zero column
-		incb %dh			# Bump row
-putchr.3:	cmpb $SCR_ROW,%dh		# Beyond screen?
-		jb putchr.4			# No
-		leal 2*SCR_COL(%edi),%esi	# New top line
-		movw $(SCR_ROW-1)*SCR_COL/2,%cx # Words to move
-		rep				# Scroll
-		movsl				#  screen
-		movb $0x20,%al			# Space
-		movb $SCR_COL,%cl		# Columns to clear
-		rep				# Clear
-		stosw				#  line
-		movb $SCR_ROW-1,%dh		# Bottom line
-putchr.4:	movw %dx,(%ebx) 		# Update position
-		popa				# Restore
-		ret				# To caller
-')
-
-		.p2align 4
-#
-# Global descriptor table.
-#
-gdt:		.word 0x0,0x0,0x0,0x0		# Null entry
-		.word 0xffff,0x0,0x9a00,0xcf	# SEL_SCODE
-		.word 0xffff,0x0,0x9200,0xcf	# SEL_SDATA
-		.word 0xffff,0x0,0x9a00,0x0	# SEL_RCODE
-		.word 0xffff,0x0,0x9200,0x0	# SEL_RDATA
-		.word 0xffff,MEM_USR,0xfa00,0xcf# SEL_UCODE
-		.word 0xffff,MEM_USR,0xf200,0xcf# SEL_UDATA
-		.word _TSSLM,MEM_TSS,0x8900,0x0 # SEL_TSS
-gdt.1:
-#
-# Pseudo-descriptors.
-#
-gdtdesc:	.word gdt.1-gdt-1,gdt,0x0	# GDT
-idtdesc:	.word _IDTLM,MEM_IDT,0x0	# IDT
-ivtdesc:	.word 0x400-0x0-1,0x0,0x0	# IVT
-#
-# IDT construction control string.
-#
-idtctl: 	.byte 0x10,  0x8e		# Int 0x0-0xf
-		.word 0x7dfb,intx00		#  (exceptions)
-		.byte 0x10,  0x8e		# Int 0x10
-		.word 0x1,   intx10		#  (exception)
-		.byte 0x10,  0x8e		# Int 0x20-0x2f
-		.word 0xffff,intx20		#  (hardware)
-		.byte 0x1,   0xee		# int 0x30
-		.word 0x1,   intx30		#  (system call)
-		.byte 0x2,   0xee		# Int 0x31-0x32
-		.word 0x1,   intx31		#  (V86, null)
-		.byte 0x0			# End of string
-#
-# Dump format string.
-#
-dmpfmt: 	.byte '\n'			# "\n"
-		.ascii "int"			# "int="
-		.byte 0x80|DMP_X32,	   0x40 # "00000000  "
-		.ascii "err"			# "err="
-		.byte 0x80|DMP_X32,	   0x44 # "00000000  "
-		.ascii "efl"			# "efl="
-		.byte 0x80|DMP_X32,	   0x50 # "00000000  "
-		.ascii "eip"			# "eip="
-		.byte 0x80|DMP_X32|DMP_EOL,0x48 # "00000000\n"
-		.ascii "eax"			# "eax="
-		.byte 0x80|DMP_X32,	   0x34 # "00000000  "
-		.ascii "ebx"			# "ebx="
-		.byte 0x80|DMP_X32,	   0x28 # "00000000  "
-		.ascii "ecx"			# "ecx="
-		.byte 0x80|DMP_X32,	   0x30 # "00000000  "
-		.ascii "edx"			# "edx="
-		.byte 0x80|DMP_X32|DMP_EOL,0x2c # "00000000\n"
-		.ascii "esi"			# "esi="
-		.byte 0x80|DMP_X32,	   0x1c # "00000000  "
-		.ascii "edi"			# "edi="
-		.byte 0x80|DMP_X32,	   0x18 # "00000000  "
-		.ascii "ebp"			# "ebp="
-		.byte 0x80|DMP_X32,	   0x20 # "00000000  "
-		.ascii "esp"			# "esp="
-		.byte 0x80|DMP_X32|DMP_EOL,0x0	# "00000000\n"
-		.ascii "cs"			# "cs="
-		.byte 0x80|DMP_X16,	   0x4c # "0000  "
-		.ascii "ds"			# "ds="
-		.byte 0x80|DMP_X16,	   0xc	# "0000  "
-		.ascii "es"			# "es="
-		.byte 0x80|DMP_X16,	   0x8	# "0000  "
-		.ascii "  "			# "  "
-		.ascii "fs"			# "fs="
-		.byte 0x80|DMP_X16,	   0x10 # "0000  "
-		.ascii "gs"			# "gs="
-		.byte 0x80|DMP_X16,	   0x14 # "0000  "
-		.ascii "ss"			# "ss="
-		.byte 0x80|DMP_X16|DMP_EOL,0x4	# "0000\n"
-		.ascii "cs:eip" 		# "cs:eip="
-		.byte 0x80|DMP_MEM|DMP_EOL,0x48 # "00 00 ... 00 00\n"
-		.ascii "ss:esp" 		# "ss:esp="
-		.byte 0x80|DMP_MEM|DMP_EOL,0x0	# "00 00 ... 00 00\n"
-		.asciz "BTX halted\n"		# End
-#
-# End of BTX memory.
-#
-		.p2align 4
-break:
diff --git a/sys/boot/i386/btx/btxldr/Makefile b/sys/boot/i386/btx/btxldr/Makefile
index 23008a5..358e396 100644
--- a/sys/boot/i386/btx/btxldr/Makefile
+++ b/sys/boot/i386/btx/btxldr/Makefile
@@ -3,14 +3,13 @@
 PROG=	btxldr.out
 INTERNALPROG=
 NOMAN=
-SRCS=	btxldr.s
+SRCS=	btxldr.S
 CLEANFILES= btxldr
 
-M4?=	m4
-M4FLAGS+=	-DLOADER_ADDRESS=${LOADER_ADDRESS}
+CFLAGS+=-DLOADER_ADDRESS=${LOADER_ADDRESS}
 
 .if defined(BTXLDR_VERBOSE)
-M4FLAGS+=	-DBTXLDR_VERBOSE
+CFLAGS+=-DBTXLDR_VERBOSE
 .endif
 
 all: btxldr
@@ -20,8 +19,4 @@ LDFLAGS=-N -e start -Ttext ${LOADER_ADDRESS}
 btxldr: btxldr.out
 	objcopy -S -O binary btxldr.out ${.TARGET}
 
-btxldr.o: btxldr.s
-	(cd ${.CURDIR}; ${M4} ${M4FLAGS} btxldr.s ) | \
-		${AS} ${AFLAGS} -o ${.TARGET}
-
 .include <bsd.prog.mk>
diff --git a/sys/boot/i386/btx/btxldr/btxldr.S b/sys/boot/i386/btx/btxldr/btxldr.S
index 7d4b121..1a94212 100644
--- a/sys/boot/i386/btx/btxldr/btxldr.S
+++ b/sys/boot/i386/btx/btxldr/btxldr.S
@@ -69,16 +69,16 @@ start:		cld				# String ops inc
 		movzwl BDA_MEM,%eax		# Get base memory
 		shll $0xa,%eax			#  in bytes
 		movl %eax,%ebp			# Base of user stack
-ifdef(`BTXLDR_VERBOSE',`
+#ifdef BTXLDR_VERBOSE
 		movl $m_mem,%esi		# Display
 		call hexout			#  amount of
 		call putstr			#  base memory
-')
+#endif
 		lgdt gdtdesc			# Load new GDT
 #
 # Relocate caller's arguments.
 #
-ifdef(`BTXLDR_VERBOSE',`
+#ifdef BTXLDR_VERBOSE
 		movl $m_esp,%esi		# Display
 		movl %esp,%eax			#  caller
 		call hexout			#  stack
@@ -91,7 +91,7 @@ start.1:	movl (%ebx),%eax		# Get argument and
 		call hexout			# Display it
 		loop start.1			# Till done
 		call putstr			# End message
-')
+#endif
 		movl $0x48,%ecx 		# Allocate space
 		subl %ecx,%ebp			#  for bootinfo
 		movl 0x18(%esp,1),%esi		# Source: bootinfo
@@ -101,24 +101,24 @@ start.1:	movl (%ebx),%eax		# Get argument and
 		rep				# Copy
 		movsb				#  it
 		movl %ebp,0x18(%esp,1)		# Update pointer
-ifdef(`BTXLDR_VERBOSE',`
+#ifdef BTXLDR_VERBOSE
 		movl $m_rel_bi,%esi		# Display
 		movl %ebp,%eax			#  bootinfo
 		call hexout			#  relocation
 		call putstr			#  message
-')
+#endif
 start_null_bi:	movl $0x18,%ecx 		# Allocate space
 		subl %ecx,%ebp			#  for arguments
 		leal 0x4(%esp,1),%esi		# Source
 		movl %ebp,%edi			# Destination
 		rep				# Copy
 		movsb				#  them
-ifdef(`BTXLDR_VERBOSE',`
+#ifdef BTXLDR_VERBOSE
 		movl $m_rel_args,%esi		# Display
 		movl %ebp,%eax			#  argument
 		call hexout			#  relocation
 		call putstr			#  message
-')
+#endif
 #
 # Set up BTX kernel.
 #
@@ -149,30 +149,30 @@ ifdef(`BTXLDR_VERBOSE',`
 		addl $MEM_TBL,%edi		#  address
 		pushl %edi			# Save load address
 		movzwl 0xa(%ebx),%ecx		# Image size
-ifdef(`BTXLDR_VERBOSE',`
+#ifdef BTXLDR_VERBOSE
 		pushl %ecx			# Save image size
-')
+#endif
 		rep				# Relocate
 		movsb				#  BTX
 		movl %esi,%ebx			# Keep place
-ifdef(`BTXLDR_VERBOSE',`
+#ifdef BTXLDR_VERBOSE
 		movl $m_rel_btx,%esi		# Restore
 		popl %eax			#  parameters
 		call hexout			#  and
-')
+#endif
 		popl %ebp			#  display
-ifdef(`BTXLDR_VERBOSE',`
+#ifdef BTXLDR_VERBOSE
 		movl %ebp,%eax			#  the
 		call hexout			#  relocation
 		call putstr			#  message
-')
+#endif
 		addl $PAG_SIZ,%ebp		# Display
-ifdef(`BTXLDR_VERBOSE',`
+#ifdef BTXLDR_VERBOSE
 		movl $m_base,%esi		#  the
 		movl %ebp,%eax			#  user
 		call hexout			#  base
 		call putstr			#  address
-')
+#endif
 #
 # Set up ELF-format client program.
 #
@@ -182,18 +182,18 @@ ifdef(`BTXLDR_VERBOSE',`
 		call putstr			#  message
 start.2:	jmp start.2			# Hang
 start.3:
-ifdef(`BTXLDR_VERBOSE',`
+#ifdef BTXLDR_VERBOSE
 		movl $m_elf,%esi		# Display ELF
 		call putstr			#  message
 		movl $m_segs,%esi		# Format string
-')
+#endif
 		movl $0x2,%edi			# Segment count
 		movl 0x1c(%ebx),%edx		# Get e_phoff
 		addl %ebx,%edx			# To pointer
 		movzwl 0x2c(%ebx),%ecx		# Get e_phnum
 start.4:	cmpl $0x1,(%edx)		# Is p_type PT_LOAD?
 		jne start.6			# No
-ifdef(`BTXLDR_VERBOSE',`
+#ifdef BTXLDR_VERBOSE
 		movl 0x4(%edx),%eax		# Display
 		call hexout			#  p_offset
 		movl 0x8(%edx),%eax		# Display
@@ -203,7 +203,7 @@ ifdef(`BTXLDR_VERBOSE',`
 		movl 0x14(%edx),%eax		# Display
 		call hexout			#  p_memsz
 		call putstr			# End message
-')
+#endif
 		pushl %esi			# Save
 		pushl %edi			#  working
 		pushl %ecx			#  registers
@@ -228,10 +228,10 @@ start.5:	popl %ecx			# Restore
 start.6:	addl $0x20,%edx 		# To next entry
 		loop start.4			# Till done
 start.7:
-ifdef(`BTXLDR_VERBOSE',`
+#ifdef BTXLDR_VERBOSE
 		movl $m_done,%esi		# Display done
 		call putstr			#  message
-')
+#endif
 		movl $start.8,%esi		# Real mode stub
 		movl $MEM_STUB,%edi		# Destination
 		movl $start.9-start.8,%ecx	# Size
@@ -366,7 +366,7 @@ gdtdesc:	.word gdt.1-gdt-1		# Limit
 m_logo: 	.asciz " \nBTX loader 1.00  "
 m_vers: 	.asciz "BTX version is \0\n"
 e_fmt:		.asciz "Error: Client format not supported\n"
-ifdef(`BTXLDR_VERBOSE',`
+#ifdef BTXLDR_VERBOSE
 m_mem:		.asciz "Starting in protected mode (base mem=\0)\n"
 m_esp:		.asciz "Arguments passed (esp=\0):\n"
 m_args: 	.asciz"<howto="
@@ -389,7 +389,7 @@ m_segs: 	.asciz "text segment: offset="
 		.asciz " filesz="
 		.asciz " memsz=\0\n"
 m_done: 	.asciz "Loading complete\n"
-')
+#endif
 #
 # Uninitialized data area.
 #
diff --git a/sys/boot/i386/btx/btxldr/btxldr.s b/sys/boot/i386/btx/btxldr/btxldr.s
deleted file mode 100644
index 7d4b121..0000000
--- a/sys/boot/i386/btx/btxldr/btxldr.s
+++ /dev/null
@@ -1,396 +0,0 @@
-#
-# Copyright (c) 1998 Robert Nordier
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms are freely
-# permitted provided that the above copyright notice and this
-# paragraph and the following disclaimer are duplicated in all
-# such forms.
-#
-# This software is provided "AS IS" and without any express or
-# implied warranties, including, without limitation, the implied
-# warranties of merchantability and fitness for a particular
-# purpose.
-#
-
-# $FreeBSD$
-
-#
-# Prototype BTX loader program, written in a couple of hours.  The
-# real thing should probably be more flexible, and in C.
-#
-
-#
-# Memory locations.
-#
-		.set MEM_STUB,0x600		# Real mode stub
-		.set MEM_ESP,0x1000		# New stack pointer
-		.set MEM_TBL,0x5000		# BTX page tables
-		.set MEM_ENTRY,0x9010		# BTX entry point
-		.set MEM_DATA,start+0x1000	# Data segment
-#
-# Segment selectors.
-#
-		.set SEL_SCODE,0x8		# 4GB code
-		.set SEL_SDATA,0x10		# 4GB data
-		.set SEL_RCODE,0x18		# 64K code
-		.set SEL_RDATA,0x20		# 64K data
-#
-# Paging constants.
-#
-		.set PAG_SIZ,0x1000		# Page size
-		.set PAG_ENT,0x4		# Page entry size
-#
-# Screen constants.
-#
-		.set SCR_MAT,0x7		# Mode/attribute
-		.set SCR_COL,0x50		# Columns per row
-		.set SCR_ROW,0x19		# Rows per screen
-#
-# BIOS Data Area locations.
-#
-		.set BDA_MEM,0x413		# Free memory
-		.set BDA_SCR,0x449		# Video mode
-		.set BDA_POS,0x450		# Cursor position
-#
-# Required by aout gas inadequacy.
-#
-		.set SIZ_STUB,0x1a		# Size of stub
-#
-# We expect to be loaded by boot2 at the origin defined in ./Makefile.
-#
-		.globl start
-#
-# BTX program loader for ELF clients.
-#
-start:		cld				# String ops inc
-		movl $m_logo,%esi		# Identify
-		call putstr			#  ourselves
-		movzwl BDA_MEM,%eax		# Get base memory
-		shll $0xa,%eax			#  in bytes
-		movl %eax,%ebp			# Base of user stack
-ifdef(`BTXLDR_VERBOSE',`
-		movl $m_mem,%esi		# Display
-		call hexout			#  amount of
-		call putstr			#  base memory
-')
-		lgdt gdtdesc			# Load new GDT
-#
-# Relocate caller's arguments.
-#
-ifdef(`BTXLDR_VERBOSE',`
-		movl $m_esp,%esi		# Display
-		movl %esp,%eax			#  caller
-		call hexout			#  stack
-		call putstr			#  pointer
-		movl $m_args,%esi		# Format string
-		leal 0x4(%esp,1),%ebx		# First argument
-		movl $0x6,%ecx			# Count
-start.1:	movl (%ebx),%eax		# Get argument and
-		addl $0x4,%ebx			#  bump pointer
-		call hexout			# Display it
-		loop start.1			# Till done
-		call putstr			# End message
-')
-		movl $0x48,%ecx 		# Allocate space
-		subl %ecx,%ebp			#  for bootinfo
-		movl 0x18(%esp,1),%esi		# Source: bootinfo
-		cmpl $0x0, %esi			# If the bootinfo pointer
-		je start_null_bi		#  is null, don't copy it
-		movl %ebp,%edi			# Destination
-		rep				# Copy
-		movsb				#  it
-		movl %ebp,0x18(%esp,1)		# Update pointer
-ifdef(`BTXLDR_VERBOSE',`
-		movl $m_rel_bi,%esi		# Display
-		movl %ebp,%eax			#  bootinfo
-		call hexout			#  relocation
-		call putstr			#  message
-')
-start_null_bi:	movl $0x18,%ecx 		# Allocate space
-		subl %ecx,%ebp			#  for arguments
-		leal 0x4(%esp,1),%esi		# Source
-		movl %ebp,%edi			# Destination
-		rep				# Copy
-		movsb				#  them
-ifdef(`BTXLDR_VERBOSE',`
-		movl $m_rel_args,%esi		# Display
-		movl %ebp,%eax			#  argument
-		call hexout			#  relocation
-		call putstr			#  message
-')
-#
-# Set up BTX kernel.
-#
-		movl $MEM_ESP,%esp		# Set up new stack
-		movl $MEM_DATA,%ebx		# Data segment
-		movl $m_vers,%esi		# Display BTX
-		call putstr			#  version message
-		movb 0x5(%ebx),%al		# Get major version
-		addb $'0',%al			# Display
-		call putchr			#  it
-		movb $'.',%al			# And a
-		call putchr			#  dot
-		movb 0x6(%ebx),%al		# Get minor
-		xorb %ah,%ah			#  version
-		movb $0xa,%dl			# Divide
-		divb %dl,%al			#  by 10
-		addb $'0',%al			# Display
-		call putchr			#  tens
-		movb %ah,%al			# Get units
-		addb $'0',%al			# Display
-		call putchr			#  units
-		call putstr			# End message
-		movl %ebx,%esi			# BTX image
-		movzwl 0x8(%ebx),%edi		# Compute
-		orl $PAG_SIZ/PAG_ENT-1,%edi	#  the
-		incl %edi			#  BTX
-		shll $0x2,%edi			#  load
-		addl $MEM_TBL,%edi		#  address
-		pushl %edi			# Save load address
-		movzwl 0xa(%ebx),%ecx		# Image size
-ifdef(`BTXLDR_VERBOSE',`
-		pushl %ecx			# Save image size
-')
-		rep				# Relocate
-		movsb				#  BTX
-		movl %esi,%ebx			# Keep place
-ifdef(`BTXLDR_VERBOSE',`
-		movl $m_rel_btx,%esi		# Restore
-		popl %eax			#  parameters
-		call hexout			#  and
-')
-		popl %ebp			#  display
-ifdef(`BTXLDR_VERBOSE',`
-		movl %ebp,%eax			#  the
-		call hexout			#  relocation
-		call putstr			#  message
-')
-		addl $PAG_SIZ,%ebp		# Display
-ifdef(`BTXLDR_VERBOSE',`
-		movl $m_base,%esi		#  the
-		movl %ebp,%eax			#  user
-		call hexout			#  base
-		call putstr			#  address
-')
-#
-# Set up ELF-format client program.
-#
-		cmpl $0x464c457f,(%ebx) 	# ELF magic number?
-		je start.3			# Yes
-		movl $e_fmt,%esi		# Display error
-		call putstr			#  message
-start.2:	jmp start.2			# Hang
-start.3:
-ifdef(`BTXLDR_VERBOSE',`
-		movl $m_elf,%esi		# Display ELF
-		call putstr			#  message
-		movl $m_segs,%esi		# Format string
-')
-		movl $0x2,%edi			# Segment count
-		movl 0x1c(%ebx),%edx		# Get e_phoff
-		addl %ebx,%edx			# To pointer
-		movzwl 0x2c(%ebx),%ecx		# Get e_phnum
-start.4:	cmpl $0x1,(%edx)		# Is p_type PT_LOAD?
-		jne start.6			# No
-ifdef(`BTXLDR_VERBOSE',`
-		movl 0x4(%edx),%eax		# Display
-		call hexout			#  p_offset
-		movl 0x8(%edx),%eax		# Display
-		call hexout			#  p_vaddr
-		movl 0x10(%edx),%eax		# Display
-		call hexout			#  p_filesz
-		movl 0x14(%edx),%eax		# Display
-		call hexout			#  p_memsz
-		call putstr			# End message
-')
-		pushl %esi			# Save
-		pushl %edi			#  working
-		pushl %ecx			#  registers
-		movl 0x4(%edx),%esi		# Get p_offset
-		addl %ebx,%esi			#  as pointer
-		movl 0x8(%edx),%edi		# Get p_vaddr
-		addl %ebp,%edi			#  as pointer
-		movl 0x10(%edx),%ecx		# Get p_filesz
-		rep				# Set up
-		movsb				#  segment
-		movl 0x14(%edx),%ecx		# Any bytes
-		subl 0x10(%edx),%ecx		#  to zero?
-		jz start.5			# No
-		xorb %al,%al			# Then
-		rep				#  zero
-		stosb				#  them
-start.5:	popl %ecx			# Restore
-		popl %edi			#  working
-		popl %esi			#  registers
-		decl %edi			# Segments to do
-		je start.7			# If none
-start.6:	addl $0x20,%edx 		# To next entry
-		loop start.4			# Till done
-start.7:
-ifdef(`BTXLDR_VERBOSE',`
-		movl $m_done,%esi		# Display done
-		call putstr			#  message
-')
-		movl $start.8,%esi		# Real mode stub
-		movl $MEM_STUB,%edi		# Destination
-		movl $start.9-start.8,%ecx	# Size
-		rep				# Relocate
-		movsb				#  it
-		ljmp $SEL_RCODE,$MEM_STUB	# To 16-bit code
-		.code16
-start.8:	xorw %ax,%ax			# Data
-		movb $SEL_RDATA,%al		#  selector
-		movw %ax,%ss			# Reload SS
-		movw %ax,%ds			# Reset
-		movw %ax,%es			#  other
-		movw %ax,%fs			#  segment
-		movw %ax,%gs			#  limits
-		movl %cr0,%eax			# Switch to
-		decw %ax			#  real
-		movl %eax,%cr0			#  mode
-		ljmp $0,$MEM_ENTRY		# Jump to BTX entry point
-start.9:
-		.code32
-#
-# Output message [ESI] followed by EAX in hex.
-#
-hexout: 	pushl %eax			# Save
-		call putstr			# Display message
-		popl %eax			# Restore
-		pushl %esi			# Save
-		pushl %edi			#  caller's
-		movl $buf,%edi			# Buffer
-		pushl %edi			# Save
-		call hex32			# To hex
-		xorb %al,%al			# Terminate
-		stosb				#  string
-		popl %esi			# Restore
-hexout.1:	lodsb				# Get a char
-		cmpb $'0',%al			# Leading zero?
-		je hexout.1			# Yes
-		testb %al,%al			# End of string?
-		jne hexout.2			# No
-		decl %esi			# Undo
-hexout.2:	decl %esi			# Adjust for inc
-		call putstr			# Display hex
-		popl %edi			# Restore
-		popl %esi			#  caller's
-		ret				# To caller
-#
-# Output zero-terminated string [ESI] to the console.
-#
-putstr.0:	call putchr			# Output char
-putstr: 	lodsb				# Load char
-		testb %al,%al			# End of string?
-		jne putstr.0			# No
-		ret				# To caller
-#
-# Output character AL to the console.
-#
-putchr: 	pusha				# Save
-		xorl %ecx,%ecx			# Zero for loops
-		movb $SCR_MAT,%ah		# Mode/attribute
-		movl $BDA_POS,%ebx		# BDA pointer
-		movw (%ebx),%dx 		# Cursor position
-		movl $0xb8000,%edi		# Regen buffer (color)
-		cmpb %ah,BDA_SCR-BDA_POS(%ebx)	# Mono mode?
-		jne putchr.1			# No
-		xorw %di,%di			# Regen buffer (mono)
-putchr.1:	cmpb $0xa,%al			# New line?
-		je putchr.2			# Yes
-		xchgl %eax,%ecx 		# Save char
-		movb $SCR_COL,%al		# Columns per row
-		mulb %dh			#  * row position
-		addb %dl,%al			#  + column
-		adcb $0x0,%ah			#  position
-		shll %eax			#  * 2
-		xchgl %eax,%ecx 		# Swap char, offset
-		movw %ax,(%edi,%ecx,1)		# Write attr:char
-		incl %edx			# Bump cursor
-		cmpb $SCR_COL,%dl		# Beyond row?
-		jb putchr.3			# No
-putchr.2:	xorb %dl,%dl			# Zero column
-		incb %dh			# Bump row
-putchr.3:	cmpb $SCR_ROW,%dh		# Beyond screen?
-		jb putchr.4			# No
-		leal 2*SCR_COL(%edi),%esi	# New top line
-		movw $(SCR_ROW-1)*SCR_COL/2,%cx # Words to move
-		rep				# Scroll
-		movsl				#  screen
-		movb $' ',%al			# Space
-		movb $SCR_COL,%cl		# Columns to clear
-		rep				# Clear
-		stosw				#  line
-		movb $SCR_ROW-1,%dh		# Bottom line
-putchr.4:	movw %dx,(%ebx) 		# Update position
-		popa				# Restore
-		ret				# To caller
-#
-# Convert EAX, AX, or AL to hex, saving the result to [EDI].
-#
-hex32:		pushl %eax			# Save
-		shrl $0x10,%eax 		# Do upper
-		call hex16			#  16
-		popl %eax			# Restore
-hex16:		call hex16.1			# Do upper 8
-hex16.1:	xchgb %ah,%al			# Save/restore
-hex8:		pushl %eax			# Save
-		shrb $0x4,%al			# Do upper
-		call hex8.1			#  4
-		popl %eax			# Restore
-hex8.1: 	andb $0xf,%al			# Get lower 4
-		cmpb $0xa,%al			# Convert
-		sbbb $0x69,%al			#  to hex
-		das				#  digit
-		orb $0x20,%al			# To lower case
-		stosb				# Save char
-		ret				# (Recursive)
-
-		.data
-		.p2align 4
-#
-# Global descriptor table.
-#
-gdt:		.word 0x0,0x0,0x0,0x0		# Null entry
-		.word 0xffff,0x0,0x9a00,0xcf	# SEL_SCODE
-		.word 0xffff,0x0,0x9200,0xcf	# SEL_SDATA
-		.word 0xffff,0x0,0x9a00,0x0	# SEL_RCODE
-		.word 0xffff,0x0,0x9200,0x0	# SEL_RDATA
-gdt.1:
-gdtdesc:	.word gdt.1-gdt-1		# Limit
-		.long gdt			# Base
-#
-# Messages.
-#
-m_logo: 	.asciz " \nBTX loader 1.00  "
-m_vers: 	.asciz "BTX version is \0\n"
-e_fmt:		.asciz "Error: Client format not supported\n"
-ifdef(`BTXLDR_VERBOSE',`
-m_mem:		.asciz "Starting in protected mode (base mem=\0)\n"
-m_esp:		.asciz "Arguments passed (esp=\0):\n"
-m_args: 	.asciz"<howto="
-		.asciz" bootdev="
-		.asciz" junk="
-		.asciz" "
-		.asciz" "
-		.asciz" bootinfo=\0>\n"
-m_rel_bi:	.asciz "Relocated bootinfo (size=48) to \0\n"
-m_rel_args:	.asciz "Relocated arguments (size=18) to \0\n"
-m_rel_btx:	.asciz "Relocated kernel (size=\0) to \0\n"
-m_base: 	.asciz "Client base address is \0\n"
-m_elf:		.asciz "Client format is ELF\n"
-m_segs: 	.asciz "text segment: offset="
-		.asciz " vaddr="
-		.asciz " filesz="
-		.asciz " memsz=\0\n"
-		.asciz "data segment: offset="
-		.asciz " vaddr="
-		.asciz " filesz="
-		.asciz " memsz=\0\n"
-m_done: 	.asciz "Loading complete\n"
-')
-#
-# Uninitialized data area.
-#
-buf:						# Scratch buffer
diff --git a/sys/boot/i386/pxeldr/Makefile b/sys/boot/i386/pxeldr/Makefile
index 3d9228f..f628e6d 100644
--- a/sys/boot/i386/pxeldr/Makefile
+++ b/sys/boot/i386/pxeldr/Makefile
@@ -7,21 +7,20 @@ PROG=	${LDR}.out
 INTERNALPROG=
 FILES=	${BOOT}
 MAN=	${BOOT}.8
-SRCS=	${LDR}.s
+SRCS=	${LDR}.S
 CLEANFILES= ${BOOT}
 
 BOOT=	pxeboot
 LDR=	pxeldr
 ORG=	0x7c00
 LOADER=	loader
-M4?=	m4
 
 .if defined(BOOT_PXELDR_PROBE_KEYBOARD)
-M4FLAGS+= -DPROBE_KEYBOARD
+CFLAGS+=-DPROBE_KEYBOARD
 .endif
 
 .if defined(BOOT_PXELDR_ALWAYS_SERIAL)
-M4FLAGS+= -DALWAYS_SERIAL
+CFLAGS+=-DALWAYS_SERIAL
 .endif
 
 LOADERBIN= ${.OBJDIR}/../loader/loader.bin
@@ -40,10 +39,6 @@ ${LDR}: ${LDR}.out
 
 LDFLAGS+= -N -e start -Ttext ${ORG}
 
-${LDR}.o: ${LDR}.s
-	(cd ${.CURDIR}; ${M4} ${M4FLAGS} ${LDR}.s) | \
-	    ${AS} ${AFLAGS} -o ${.TARGET}
-
 CLEANFILES+= ${LOADER}
 
 ${LOADER}: ${LOADERBIN} ${BTXLDR} ${BTXKERN}
diff --git a/sys/boot/i386/pxeldr/pxeldr.S b/sys/boot/i386/pxeldr/pxeldr.S
index fa93c9c..a4bd663 100644
--- a/sys/boot/i386/pxeldr/pxeldr.S
+++ b/sys/boot/i386/pxeldr/pxeldr.S
@@ -110,12 +110,12 @@ start:		cld				# string ops inc
 		orb $KARGS_FLAGS_PXE, 0x8(%bx)	# kargs->bootflags |=
 						#  KARGS_FLAGS_PXE
 		popl 0xc(%bx)			# kargs->pxeinfo = *PXENV+
-ifdef(`ALWAYS_SERIAL',`
+#ifdef ALWAYS_SERIAL
 #
 # set the RBX_SERIAL bit in the howto byte.
 		orl $RB_SERIAL, (%bx)		# enable serial console
-')
-ifdef(`PROBE_KEYBOARD',`
+#endif
+#ifdef PROBE_KEYBOARD
 #
 # Look at the BIOS data area to see if we have an enhanced keyboard.  If not,
 # set the RBX_SERIAL bit in the howto byte.
@@ -123,7 +123,7 @@ ifdef(`PROBE_KEYBOARD',`
 		jnz keyb			# yes, so skip
 		orl $RB_SERIAL, (%bx)		# enable serial console
 keyb:
-')
+#endif
 #
 # Turn on the A20 address line
 #
diff --git a/sys/boot/i386/pxeldr/pxeldr.s b/sys/boot/i386/pxeldr/pxeldr.s
deleted file mode 100644
index fa93c9c..0000000
--- a/sys/boot/i386/pxeldr/pxeldr.s
+++ /dev/null
@@ -1,287 +0,0 @@
-#
-# Copyright (c) 2000 John Baldwin
-# All rights reserved.
-#
-# Redistribution and use in source and binary forms are freely
-# permitted provided that the above copyright notice and this
-# paragraph and the following disclaimer are duplicated in all
-# such forms.
-#
-# This software is provided "AS IS" and without any express or
-# implied warranties, including, without limitation, the implied
-# warranties of merchantability and fitness for a particular
-# purpose.
-#
-
-# $FreeBSD$
-
-#
-# This simple program is a preloader for the normal boot3 loader.  It is simply
-# prepended to the beginning of a fully built and btxld'd loader.  It then
-# copies the loader to the address boot2 normally loads it, emulates the
-# boot[12] environment (protected mode, a bootinfo struct, etc.), and then jumps
-# to the start of btxldr to start the boot process.  This method allows a stock
-# /boot/loader to be booted over the network via PXE w/o having to write a
-# separate PXE-aware client just to load the loader.
-#
-
-#
-# Memory locations.
-#
-		.set MEM_PAGE_SIZE,0x1000	# memory page size, 4k
-		.set MEM_ARG,0x900		# Arguments at start
-		.set MEM_ARG_BTX,0xa100		# Where we move them to so the
-						#  BTX client can see them
-		.set MEM_ARG_SIZE,0x18		# Size of the arguments
-		.set MEM_BTX_ADDRESS,0x9000	# where BTX lives
-		.set MEM_BTX_ENTRY,0x9010	# where BTX starts to execute
-		.set MEM_BTX_OFFSET,MEM_PAGE_SIZE # offset of BTX in the loader
-		.set MEM_BTX_CLIENT,0xa000	# where BTX clients live
-		.set MEM_BIOS_KEYBOARD,0x496	# BDA byte with keyboard bit
-#
-# a.out header fields
-#
-		.set AOUT_TEXT,0x04		# text segment size
-		.set AOUT_DATA,0x08		# data segment size
-		.set AOUT_BSS,0x0c		# zero'd BSS size
-		.set AOUT_SYMBOLS,0x10		# symbol table
-		.set AOUT_ENTRY,0x14		# entry point
-		.set AOUT_HEADER,MEM_PAGE_SIZE	# size of the a.out header
-#
-# Flags for kargs->bootflags
-#
-		.set KARGS_FLAGS_PXE,0x2	# flag to indicate booting from
-						#  PXE loader
-#
-# Boot howto bits
-#
-		.set RB_SERIAL,0x1000		# serial console
-#
-# Segment selectors.
-#
-		.set SEL_SDATA,0x8		# Supervisor data
-		.set SEL_RDATA,0x10		# Real mode data
-		.set SEL_SCODE,0x18		# PM-32 code
-		.set SEL_SCODE16,0x20		# PM-16 code
-#
-# BTX constants
-#
-		.set INT_SYS,0x30		# BTX syscall interrupt
-#
-# Bit in MEM_BIOS_KEYBOARD that is set if an enhanced keyboard is present
-#
-		.set KEYBOARD_BIT,0x10
-#
-# We expect to be loaded by the BIOS at 0x7c00 (standard boot loader entry
-# point)
-#
-		.code16
-		.globl start
-		.org 0x0, 0x0
-#
-# BTX program loader for PXE network booting
-#
-start:		cld				# string ops inc
-		xorw %ax, %ax			# zero %ax
-		movw %ax, %ss			# setup the
-		movw $start, %sp		#  stack
-		movw %es, %cx			# save PXENV+ segment
-		movw %ax, %ds			# setup the
-		movw %ax, %es			#  data segments
-		andl $0xffff, %ecx		# clear upper words
-		andl $0xffff, %ebx		#  of %ebx and %ecx
-		shll $4, %ecx			# calculate the offset of
-		addl %ebx, %ecx			#  the PXENV+ struct and
-		pushl %ecx			#  save it on the stack
-		movw $welcome_msg, %si		# %ds:(%si) -> welcome message
-		callw putstr			# display the welcome message
-#
-# Setup the arguments that the loader is expecting from boot[12]
-#
-		movw $bootinfo_msg, %si		# %ds:(%si) -> boot args message
-		callw putstr			# display the message
-		movw $MEM_ARG, %bx		# %ds:(%bx) -> boot args
-		movw %bx, %di			# %es:(%di) -> boot args
-		xorl %eax, %eax			# zero %eax
-		movw $(MEM_ARG_SIZE/4), %cx	# Size of arguments in 32-bit
-						#  dwords
-		rep				# Clear the arguments
-		stosl				#  to zero
-		orb $KARGS_FLAGS_PXE, 0x8(%bx)	# kargs->bootflags |=
-						#  KARGS_FLAGS_PXE
-		popl 0xc(%bx)			# kargs->pxeinfo = *PXENV+
-ifdef(`ALWAYS_SERIAL',`
-#
-# set the RBX_SERIAL bit in the howto byte.
-		orl $RB_SERIAL, (%bx)		# enable serial console
-')
-ifdef(`PROBE_KEYBOARD',`
-#
-# Look at the BIOS data area to see if we have an enhanced keyboard.  If not,
-# set the RBX_SERIAL bit in the howto byte.
-		testb $KEYBOARD_BIT, MEM_BIOS_KEYBOARD # keyboard present?
-		jnz keyb			# yes, so skip
-		orl $RB_SERIAL, (%bx)		# enable serial console
-keyb:
-')
-#
-# Turn on the A20 address line
-#
-		callw seta20			# Turn A20 on
-#
-# Relocate the loader and BTX using a very lazy protected mode
-#
-		movw $relocate_msg, %si		# Display the
-		callw putstr			#  relocation message
-		movl end+AOUT_ENTRY, %edi	# %edi is the destination
-		movl $(end+AOUT_HEADER), %esi	# %esi is
-						#  the start of the text
-						#  segment
-		movl end+AOUT_TEXT, %ecx	# %ecx = length of the text
-						#  segment
-		lgdt gdtdesc			# setup our own gdt
-		cli				# turn off interrupts
-		movl %cr0, %eax			# Turn on
-		orb $0x1, %al			#  protected
-		movl %eax, %cr0			#  mode
-		ljmp $SEL_SCODE,$pm_start	# long jump to clear the
-						#  instruction pre-fetch queue
-		.code32
-pm_start:	movw $SEL_SDATA, %ax		# Initialize
-		movw %ax, %ds			#  %ds and
-		movw %ax, %es			#  %es to a flat selector
-		rep				# Relocate the
-		movsb				#  text segment
-		addl $(MEM_PAGE_SIZE - 1), %edi	# pad %edi out to a new page
-		andl $~(MEM_PAGE_SIZE - 1), %edi #  for the data segment
-		movl end+AOUT_DATA, %ecx	# size of the data segment
-		rep				# Relocate the
-		movsb				#  data segment
-		movl end+AOUT_BSS, %ecx		# size of the bss
-		xorl %eax, %eax			# zero %eax
-		addb $3, %cl			# round %ecx up to
-		shrl $2, %ecx			#  a multiple of 4
-		rep				# zero the
-		stosl				#  bss
-		movl end+AOUT_ENTRY, %esi	# %esi -> relocated loader
-		addl $MEM_BTX_OFFSET, %esi	# %esi -> BTX in the loader
-		movl $MEM_BTX_ADDRESS, %edi	# %edi -> where BTX needs to go
-		movzwl 0xa(%esi), %ecx		# %ecx -> length of BTX
-		rep				# Relocate
-		movsb				#  BTX
-		ljmp $SEL_SCODE16,$pm_16	# Jump to 16-bit PM
-		.code16
-pm_16:		movw $SEL_RDATA, %ax		# Initialize
-		movw %ax, %ds			#  %ds and
-		movw %ax, %es			#  %es to a real mode selector
-		movl %cr0, %eax			# Turn off
-		andb $~0x1, %al			#  protected
-		movl %eax, %cr0			#  mode
-		ljmp $0,$pm_end			# Long jump to clear the
-						#  instruction pre-fetch queue
-pm_end:		sti				# Turn interrupts back on now
-#
-# Copy the BTX client to MEM_BTX_CLIENT
-#
-		xorw %ax, %ax			# zero %ax and set
-		movw %ax, %ds			#  %ds and %es
-		movw %ax, %es			#  to segment 0
-		movw $MEM_BTX_CLIENT, %di	# Prepare to relocate
-		movw $btx_client, %si		#  the simple btx client
-		movw $(btx_client_end-btx_client), %cx # length of btx client
-		rep				# Relocate the
-		movsb				#  simple BTX client
-#
-# Copy the boot[12] args to where the BTX client can see them
-#
-		movw $MEM_ARG, %si		# where the args are at now
-		movw $MEM_ARG_BTX, %di		# where the args are moving to
-		movw $(MEM_ARG_SIZE/4), %cx	# size of the arguments in longs
-		rep				# Relocate
-		movsl				#  the words
-#
-# Save the entry point so the client can get to it later on
-#
-		movl end+AOUT_ENTRY, %eax	# load the entry point
-		stosl				# add it to the end of the
-						#  arguments
-#
-# Now we just start up BTX and let it do the rest
-#
-		movw $jump_message, %si		# Display the
-		callw putstr			#  jump message
-		ljmp $0,$MEM_BTX_ENTRY		# Jump to the BTX entry point
-
-#
-# Display a null-terminated string
-#
-putstr:		lodsb				# load %al from %ds:(%si)
-		testb %al,%al			# stop at null
-		jnz putc			# if the char != null, output it
-		retw				# return when null is hit
-putc:		movw $0x7,%bx			# attribute for output
-		movb $0xe,%ah			# BIOS: put_char
-		int $0x10			# call BIOS, print char in %al
-		jmp putstr			# keep looping
-
-#
-# Enable A20
-#
-seta20: 	cli				# Disable interrupts
-seta20.1:	inb $0x64,%al			# Get status
-		testb $0x2,%al			# Busy?
-		jnz seta20.1			# Yes
-		movb $0xd1,%al			# Command: Write
-		outb %al,$0x64			#  output port
-seta20.2:	inb $0x64,%al			# Get status
-		testb $0x2,%al			# Busy?
-		jnz seta20.2			# Yes
-		movb $0xdf,%al			# Enable
-		outb %al,$0x60			#  A20
-		sti				# Enable interrupts
-		retw				# To caller
-
-#
-# BTX client to start btxldr
-#
-		.code32
-btx_client:	movl $(MEM_ARG_BTX-MEM_BTX_CLIENT+MEM_ARG_SIZE-4), %esi
-						# %ds:(%esi) -> end
-						#  of boot[12] args
-		movl $(MEM_ARG_SIZE/4), %ecx	# Number of words to push
-		std				# Go backwards
-push_arg:	lodsl				# Read argument
-		pushl %eax			# Push it onto the stack
-		loop push_arg			# Push all of the arguments
-		cld				# In case anyone depends on this
-		pushl MEM_ARG_BTX-MEM_BTX_CLIENT+MEM_ARG_SIZE # Entry point of
-						#  the loader
-		pushl %eax			# Emulate a near call
-		movl $0x1, %eax			# 'exec' system call
-		int $INT_SYS			# BTX system call
-btx_client_end:
-		.code16
-
-		.p2align 4
-#
-# Global descriptor table.
-#
-gdt:		.word 0x0,0x0,0x0,0x0		# Null entry
-		.word 0xffff,0x0,0x9200,0xcf	# SEL_SDATA
-		.word 0xffff,0x0,0x9200,0x0	# SEL_RDATA
-		.word 0xffff,0x0,0x9a00,0xcf	# SEL_SCODE (32-bit)
-		.word 0xffff,0x0,0x9a00,0x8f	# SEL_SCODE16 (16-bit)
-gdt.1:
-#
-# Pseudo-descriptors.
-#
-gdtdesc:	.word gdt.1-gdt-1		# Limit
-		.long gdt			# Base
-
-welcome_msg:	.asciz	"PXE Loader 1.00\r\n\n"
-bootinfo_msg:	.asciz	"Building the boot loader arguments\r\n"
-relocate_msg:	.asciz	"Relocating the loader and the BTX\r\n"
-jump_message:	.asciz	"Starting the BTX loader\r\n"
-
-		.p2align 4
-end: