[rng] Work around broken RTC periodic interrupts in Hyper-V

Some versions of Hyper-V (observed in some Microsoft Azure virtual
machines as noted in commit 74222cd ("[rng] Check for functioning RTC
interrupt"), and now in Windows Server 2022) fail to properly emulate
the RTC periodic interrupt.  The typical symptom is that only a single
interrupt will be generated: subsequent interrupts will appear to be
asserted by the virtual RTC but will be ignored by the virtual PIC.

Experiments show that this apparent hypervisor bug can be worked
around by disabling and re-enabling the periodic interrupt within the
interrupt handler.

Apply this workaround only if required, since doing so will
substantially increase the overhead of each RTC interrupt.

Signed-off-by: Michael Brown <mcb30@ipxe.org>

.github/workflows/build.yml

@@ -0,0 +1,120 @@
+name: Build
+
+on: push
+
+jobs:
+
+  cache:
+    name: Cache
+    runs-on: ubuntu-22.04
+    steps:
+      - name: Cache permissions
+        run: |
+          sudo chown $(id -un) /var/cache/apt/archives
+      - name: Cache packages
+        uses: actions/cache@v3
+        with:
+          path: /var/cache/apt/archives/*.deb
+          key: apt-cache-${{ github.run_id }}-${{ github.run_attempt }}
+          restore-keys: |
+            apt-cache-
+      - name: Download packages
+        run: |
+          sudo apt update
+          sudo apt install -y -d -o Acquire::Retries=50 \
+                           mtools syslinux isolinux \
+                           libc6-dev-i386 valgrind \
+                           gcc-arm-none-eabi gcc-aarch64-linux-gnu
+
+  x86:
+    name: x86
+    runs-on: ubuntu-22.04
+    needs: cache
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+      - name: Cache permissions
+        run: |
+          sudo chown $(id -un) /var/cache/apt/archives
+      - name: Cache packages
+        uses: actions/cache/restore@v3
+        with:
+          path: /var/cache/apt/archives/*.deb
+          key: apt-cache-${{ github.run_id }}-${{ github.run_attempt }}
+      - name: Install packages
+        run: |
+          sudo dpkg --add-architecture i386
+          sudo apt update
+          sudo apt install -y -o Acquire::Retries=50 \
+                           mtools syslinux isolinux \
+                           libc6-dev-i386 libc6-dbg:i386 valgrind
+      - name: Build (BIOS)
+        run: |
+          make -j 4 -C src
+      - name: Build (Everything)
+        run: |
+          make -j 4 -C src everything
+      - name: Test
+        run: |
+          valgrind ./src/bin-i386-linux/tests.linux
+          valgrind ./src/bin-x86_64-linux/tests.linux
+
+  arm32:
+    name: ARM32
+    runs-on: ubuntu-22.04
+    needs: cache
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+      - name: Cache permissions
+        run: |
+          sudo chown $(id -un) /var/cache/apt/archives
+      - name: Cache packages
+        uses: actions/cache/restore@v3
+        with:
+          path: /var/cache/apt/archives/*.deb
+          key: apt-cache-${{ github.run_id }}-${{ github.run_attempt }}
+      - name: Install packages
+        run: |
+          sudo apt update
+          sudo apt install -y -o Acquire::Retries=50 \
+                           mtools syslinux isolinux gcc-arm-none-eabi
+      - name: Build
+        run: |
+          make -j 4 -C src CROSS=arm-none-eabi- \
+               bin-arm32-efi/intel.efi \
+               bin-arm32-efi/intel.usb \
+               bin-arm32-efi/intel.iso
+
+  arm64:
+    name: ARM64
+    runs-on: ubuntu-22.04
+    needs: cache
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v3
+        with:
+          fetch-depth: 0
+      - name: Cache permissions
+        run: |
+          sudo chown $(id -un) /var/cache/apt/archives
+      - name: Cache packages
+        uses: actions/cache/restore@v3
+        with:
+          path: /var/cache/apt/archives/*.deb
+          key: apt-cache-${{ github.run_id }}-${{ github.run_attempt }}
+      - name: Install packages
+        run: |
+          sudo apt update
+          sudo apt install -y -o Acquire::Retries=50 \
+                           mtools syslinux isolinux gcc-aarch64-linux-gnu
+      - name: Build
+        run: |
+          make -j 4 -C src CROSS=aarch64-linux-gnu- \
+               bin-arm64-efi/ipxe.efi \
+               bin-arm64-efi/ipxe.usb \
+               bin-arm64-efi/ipxe.iso

.github/workflows/coverity.yml

@@ -0,0 +1,37 @@
+name: Coverity Scan
+
+on:
+  push:
+    branches:
+      - coverity_scan
+
+jobs:
+  submit:
+    name: Submit
+    runs-on: ubuntu-22.04
+    steps:
+      - name: Check out code
+        uses: actions/checkout@v3
+      - name: Download Coverity Scan
+        run: |
+          curl --form token=${{ secrets.COVERITY_SCAN_TOKEN }} \
+               --form project=${{ github.repository }} \
+               --output coverity.tar.gz \
+               https://scan.coverity.com/download/cxx/linux64
+          mkdir -p /opt/coverity
+          sudo tar xvzf coverity.tar.gz --strip 1 --directory /opt/coverity
+      - name: Build via Coverity Scan
+        run: |
+          make -C src bin/deps
+          /opt/coverity/bin/cov-build --dir cov-int make -C src bin/blib.a
+      - name: Create submission
+        run : |
+          tar cvzf cov-int.tar.gz cov-int
+      - name: Submit to Coverity Scan
+        run: |
+          curl --form token=${{ secrets.COVERITY_SCAN_TOKEN }} \
+               --form email=${{ secrets.COVERITY_SCAN_EMAIL }} \
+               --form file=@cov-int.tar.gz \
+               --form version=${{ github.sha }} \
+               --form description=${{ github.ref }} \
+               https://scan.coverity.com/builds?project=${{ github.repository }}

.travis.yml

@@ -1,57 +0,0 @@
-dist: trusty
-
-sudo: false
-
-git:
-  depth: false
-
-language: c
-
-cache: ccache
-
-compiler:
-  - gcc
-
-addons:
-  apt:
-    packages:
-      - binutils-dev
-      - liblzma-dev
-      - syslinux
-      - genisoimage
-  coverity_scan:
-    project:
-      name: "ipxe/ipxe"
-      version: $TRAVIS_COMMIT
-    build_command_prepend: "make -C src bin/deps"
-    build_command: "make -C src bin/blib.a"
-    branch_pattern: coverity_scan
-
-env:
-  global:
-    - MAKEFLAGS="-j 4"
-
-script:
-  - make -C src bin/blib.a
-  - make -C src bin/ipxe.pxe
-  - make -C src bin/ipxe.usb
-  - make -C src bin/ipxe.iso
-  - make -C src bin/8086100e.mrom
-  - make -C src bin-x86_64-pcbios/blib.a
-  - make -C src bin-x86_64-pcbios/ipxe.pxe
-  - make -C src bin-x86_64-pcbios/ipxe.usb
-  - make -C src bin-x86_64-pcbios/ipxe.iso
-  - make -C src bin-x86_64-pcbios/8086100e.mrom
-  - make -C src bin-x86_64-efi/blib.a
-  - make -C src bin-x86_64-efi/ipxe.efi
-  - make -C src bin-x86_64-efi/intel.efidrv
-  - make -C src bin-x86_64-efi/intel.efirom
-  - make -C src bin-i386-efi/blib.a
-  - make -C src bin-i386-efi/ipxe.efi
-  - make -C src bin-i386-efi/intel.efidrv
-  - make -C src bin-i386-efi/intel.efirom
-  - make -C src bin-x86_64-linux/blib.a
-  - make -C src bin-x86_64-linux/tap.linux
-  - make -C src bin-x86_64-linux/af_packet.linux
-  - make -C src bin-x86_64-linux/tests.linux
-  - ./src/bin-x86_64-linux/tests.linux

contrib/cloud/aws-import

@@ -0,0 +1,139 @@
+#!/usr/bin/env python3
+
+import argparse
+from base64 import b64encode
+from concurrent.futures import ThreadPoolExecutor, as_completed
+from datetime import date
+from hashlib import sha256
+from itertools import count
+import subprocess
+
+import boto3
+
+BLOCKSIZE = 512 * 1024
+
+
+def detect_architecture(image):
+    """Detect CPU architecture"""
+    mdir = subprocess.run(['mdir', '-b', '-i', image, '::/EFI/BOOT'],
+                          stdout=subprocess.PIPE, stderr=subprocess.PIPE)
+    if any(b'BOOTAA64.EFI' in x for x in mdir.stdout.splitlines()):
+        return 'arm64'
+    return 'x86_64'
+
+
+def create_snapshot(region, description, image):
+    """Create an EBS snapshot"""
+    client = boto3.client('ebs', region_name=region)
+    snapshot = client.start_snapshot(VolumeSize=1,
+                                     Description=description)
+    snapshot_id = snapshot['SnapshotId']
+    with open(image, 'rb') as fh:
+        for block in count():
+            data = fh.read(BLOCKSIZE)
+            if not data:
+                break
+            data = data.ljust(BLOCKSIZE, b'\0')
+            checksum = b64encode(sha256(data).digest()).decode()
+            client.put_snapshot_block(SnapshotId=snapshot_id,
+                                      BlockIndex=block,
+                                      BlockData=data,
+                                      DataLength=BLOCKSIZE,
+                                      Checksum=checksum,
+                                      ChecksumAlgorithm='SHA256')
+    client.complete_snapshot(SnapshotId=snapshot_id,
+                             ChangedBlocksCount=block)
+    return snapshot_id
+
+
+def import_image(region, name, architecture, image, public):
+    """Import an AMI image"""
+    client = boto3.client('ec2', region_name=region)
+    resource = boto3.resource('ec2', region_name=region)
+    description = '%s (%s)' % (name, architecture)
+    snapshot_id = create_snapshot(region=region, description=description,
+                                  image=image)
+    client.get_waiter('snapshot_completed').wait(SnapshotIds=[snapshot_id])
+    image = client.register_image(Architecture=architecture,
+                                  BlockDeviceMappings=[{
+                                      'DeviceName': '/dev/sda1',
+                                      'Ebs': {
+                                          'SnapshotId': snapshot_id,
+                                          'VolumeType': 'standard',
+                                      },
+                                  }],
+                                  EnaSupport=True,
+                                  Name=description,
+                                  RootDeviceName='/dev/sda1',
+                                  SriovNetSupport='simple',
+                                  VirtualizationType='hvm')
+    image_id = image['ImageId']
+    client.get_waiter('image_available').wait(ImageIds=[image_id])
+    if public:
+        resource.Image(image_id).modify_attribute(Attribute='launchPermission',
+                                                  OperationType='add',
+                                                  UserGroups=['all'])
+    return image_id
+
+
+def launch_link(region, image_id):
+    """Construct a web console launch link"""
+    return ("https://console.aws.amazon.com/ec2/v2/home?"
+            "region=%s#LaunchInstanceWizard:ami=%s" % (region, image_id))
+
+
+# Parse command-line arguments
+parser = argparse.ArgumentParser(description="Import AWS EC2 image (AMI)")
+parser.add_argument('--name', '-n',
+                    help="Image name")
+parser.add_argument('--public', '-p', action='store_true',
+                    help="Make image public")
+parser.add_argument('--region', '-r', action='append',
+                    help="AWS region(s)")
+parser.add_argument('--wiki', '-w', metavar='FILE',
+                    help="Generate Dokuwiki table")
+parser.add_argument('image', nargs='+', help="iPXE disk image")
+args = parser.parse_args()
+
+# Detect CPU architectures
+architectures = {image: detect_architecture(image) for image in args.image}
+
+# Use default name if none specified
+if not args.name:
+    args.name = 'iPXE (%s)' % date.today().strftime('%Y-%m-%d')
+
+# Use all regions if none specified
+if not args.region:
+    args.region = sorted(x['RegionName'] for x in
+                         boto3.client('ec2').describe_regions()['Regions'])
+
+# Use one thread per import to maximise parallelism
+imports = [(region, image) for region in args.region for image in args.image]
+with ThreadPoolExecutor(max_workers=len(imports)) as executor:
+    futures = {executor.submit(import_image,
+                               region=region,
+                               name=args.name,
+                               architecture=architectures[image],
+                               image=image,
+                               public=args.public): (region, image)
+               for region, image in imports}
+    results = {futures[future]: future.result()
+               for future in as_completed(futures)}
+
+# Construct Dokuwiki table
+wikitab = ["^ AWS region  ^ CPU architecture  ^ AMI ID  ^\n"] + list(
+    "| ''%s''  | ''%s''  | ''[[%s|%s]]''  |\n" % (
+        region,
+        architectures[image],
+        launch_link(region, results[(region, image)]),
+        results[(region, image)],
+    ) for region, image in imports)
+if args.wiki:
+    with open(args.wiki, 'wt') as fh:
+        fh.writelines(wikitab)
+
+# Show created images
+for region, image in imports:
+    print("%s %s %s %s" % (
+        region, image, architectures[image], results[(region, image)]
+    ))

src/Makefile

@@ -10,6 +10,7 @@ LDFLAGS		:=
 HOST_CFLAGS	:=
 MAKEDEPS	:= Makefile
 CROSS_COMPILE	?= $(CROSS)
+SYMBOL_PREFIX	:=
 
 ###############################################################################
 #
@@ -23,6 +24,7 @@ CP		:= cp
 ECHO		:= echo
 PRINTF		:= printf
 PERL		:= perl
+PYTHON		:= python
 TRUE		:= true
 CC		:= $(CROSS_COMPILE)gcc
 CPP		:= $(CC) -E
@@ -48,9 +50,8 @@ ELF2EFI32	:= ./util/elf2efi32
 ELF2EFI64	:= ./util/elf2efi64
 EFIROM		:= ./util/efirom
 EFIFATBIN	:= ./util/efifatbin
-ICCFIX		:= ./util/iccfix
 EINFO		:= ./util/einfo
-GENKEYMAP	:= ./util/genkeymap.pl
+GENKEYMAP	:= ./util/genkeymap.py
 DOXYGEN		:= doxygen
 LCAB		:= lcab
 QEMUIMG		:= qemu-img
@@ -190,7 +191,7 @@ vmware : bin/8086100f.mrom bin/808610d3.mrom bin/10222000.rom bin/15ad07b0.rom
 	@$(ECHO) '    bin/10222000.rom  -- vlance/pcnet32'
 	@$(ECHO) '    bin/15ad07b0.rom  -- vmxnet3'
 	@$(ECHO) 
-	@$(ECHO) 'For more information, see http://ipxe.org/howto/vmware'
+	@$(ECHO) 'For more information, see https://ipxe.org/howto/vmware'
 	@$(ECHO)
 	@$(ECHO) '==========================================================='
 

src/Makefile.efi

@@ -43,12 +43,13 @@ $(BIN)/%.drv.efi : $(BIN)/%.efidrv
 
 $(BIN)/%.efirom : $(BIN)/%.efidrv $(EFIROM)
 	$(QM)$(ECHO) "  [FINISH] $@"
-	$(Q)$(EFIROM) -v $(TGT_PCI_VENDOR) -d $(TGT_PCI_DEVICE) $< $@
+	$(Q)$(EFIROM) -v $(firstword $(TGT_PCI_VENDOR) 0) \
+		      -d $(firstword $(TGT_PCI_DEVICE) 0) -c $< $@
 
 $(BIN)/efidrv.cab : $(BIN)/alldrv.efis # $(ALL_drv.efi) is not yet defined
 	$(QM)$(ECHO) "  [CAB] $@"
 	$(Q)$(LCAB) -n -q $(ALL_drv.efi) $@
 
-$(BIN)/%.usb : $(BIN)/%.efi
-	$(QM)$(ECHO) "  [GENEFIDSK] $@"
-	$(Q)bash util/genefidsk -o $@ -b $(EFI_BOOT_FILE) $<
+$(BIN)/%.iso $(BIN)/%.usb : $(BIN)/%.efi util/genfsimg
+	$(QM)$(ECHO) "  [GENFSIMG] $@"
+	$(Q)util/genfsimg -o $@ $<

src/Makefile.housekeeping

@@ -76,9 +76,7 @@ CCDEFS		:= $(shell $(CC) -E -x c -c /dev/null -dM | cut -d" " -f2)
 ccdefs:
 	@$(ECHO) $(CCDEFS)
 
-ifeq ($(filter __ICC,$(CCDEFS)),__ICC)
-CCTYPE		:= icc
-else
+ifeq ($(filter __GNUC__,$(CCDEFS)),__GNUC__)
 CCTYPE		:= gcc
 endif
 cctype:
@@ -113,6 +111,13 @@ $(warning Use GNU ld instead)
 $(error Unsuitable build environment found)
 endif
 
+OBJCOPY_ETC_BANNER := $(shell $(OBJCOPY) --version | grep 'elftoolchain')
+ifneq ($(OBJCOPY_ETC_BANNER),)
+$(warning The elftoolchain objcopy is unsuitable for building iPXE)
+$(warning Use binutils objcopy instead)
+$(error Unsuitable build environment found)
+endif
+
 ###############################################################################
 #
 # Check if $(eval ...) is available to use
@@ -364,7 +369,43 @@ endif
 # Include architecture-specific include path
 ifdef ARCH
 INCDIRS		+= arch/$(ARCH)/include
-INCDIRS		+= arch/$(ARCH)/include/$(PLATFORM)
+endif
+
+###############################################################################
+#
+# Especially ugly workarounds
+
+# Some widespread patched versions of gcc include -fPIE -Wl,-pie by
+# default.  Note that gcc will exit *successfully* if it fails to
+# recognise an option that starts with "no", so we have to test for
+# output on stderr instead of checking the exit status.
+#
+# Current versions of gcc require -no-pie; older versions require
+# -nopie.  We therefore test for both.
+#
+# This workaround must be determined only after the
+# architecture-specific Makefile has been included, since some
+# platforms (e.g. bin-x86_64-efi) will explicitly require the use of
+# -fpie.
+#
+ifeq ($(filter -fpie,$(CFLAGS)),)
+ifeq ($(CCTYPE),gcc)
+PIE_TEST = [ -z "`$(CC) -fno-PIE -no-pie -x c -c /dev/null -o /dev/null 2>&1`" ]
+PIE_FLAGS := $(shell $(PIE_TEST) && $(ECHO) '-fno-PIE -no-pie')
+PIE_TEST2 = [ -z "`$(CC) -fno-PIE -nopie -x c -c /dev/null -o /dev/null 2>&1`" ]
+PIE_FLAGS2 := $(shell $(PIE_TEST2) && $(ECHO) '-fno-PIE -nopie')
+WORKAROUND_CFLAGS += $(PIE_FLAGS) $(PIE_FLAGS2)
+endif
+endif
+
+# Some widespread patched versions of gcc include -fcf-protection=full
+# by default.
+#
+ifeq ($(CCTYPE),gcc)
+CFP_TEST = $(CC) -fcf-protection=none -x c -c /dev/null -o /dev/null \
+		 >/dev/null 2>&1
+CFP_FLAGS := $(shell $(CFP_TEST) && $(ECHO) '-fcf-protection=none')
+WORKAROUND_CFLAGS += $(CFP_FLAGS)
 endif
 
 ###############################################################################
@@ -420,33 +461,9 @@ ifeq ($(CCTYPE),gcc)
 CFLAGS		+= -ffreestanding
 CFLAGS		+= -fcommon
 CFLAGS		+= -Wall -W -Wformat-nonliteral
+CFLAGS		+= -Wno-array-bounds -Wno-dangling-pointer
 HOST_CFLAGS	+= -Wall -W -Wformat-nonliteral
-endif
-ifeq ($(CCTYPE),icc)
-CFLAGS		+= -fno-builtin
-CFLAGS		+= -no-ip
-CFLAGS		+= -no-gcc
-CFLAGS		+= -diag-disable 111 # Unreachable code
-CFLAGS		+= -diag-disable 128 # Unreachable loop
-CFLAGS		+= -diag-disable 170 # Array boundary checks
-CFLAGS		+= -diag-disable 177 # Unused functions
-CFLAGS		+= -diag-disable 181 # printf() format checks
-CFLAGS		+= -diag-disable 188 # enum strictness
-CFLAGS		+= -diag-disable 193 # Undefined preprocessor identifiers
-CFLAGS		+= -diag-disable 280 # switch ( constant )
-CFLAGS		+= -diag-disable 310 # K&R parameter lists
-CFLAGS		+= -diag-disable 424 # Extra semicolon
-CFLAGS		+= -diag-disable 589 # Declarations mid-code
-CFLAGS		+= -diag-disable 593 # Unused variables
-CFLAGS		+= -diag-disable 810 # Casting ints to smaller ints
-CFLAGS		+= -diag-disable 981 # Sequence point violations
-CFLAGS		+= -diag-disable 1292 # Ignored attributes
-CFLAGS		+= -diag-disable 1338 # void pointer arithmetic
-CFLAGS		+= -diag-disable 1361 # Variable-length arrays
-CFLAGS		+= -diag-disable 1418 # Missing prototypes
-CFLAGS		+= -diag-disable 1419 # Missing prototypes
-CFLAGS		+= -diag-disable 1599 # Hidden variables
-CFLAGS		+= -Wall -Wmissing-declarations
+HOST_CFLAGS	+= -Wno-array-bounds -Wno-dangling-pointer
 endif
 CFLAGS		+= $(WORKAROUND_CFLAGS) $(EXTRA_CFLAGS)
 ASFLAGS		+= $(WORKAROUND_ASFLAGS) $(EXTRA_ASFLAGS)
@@ -461,35 +478,6 @@ ASFLAGS		+= --fatal-warnings
 HOST_CFLAGS	+= -Werror
 endif
 
-# Function trace recorder state in the last build.  This is needed
-# in order to correctly rebuild whenever the function recorder is
-# enabled/disabled.
-#
-FNREC_STATE	:= $(BIN)/.fnrec.state
-ifeq ($(wildcard $(FNREC_STATE)),)
-FNREC_OLD	:= <invalid>
-else
-FNREC_OLD	:= $(shell cat $(FNREC_STATE))
-endif
-ifeq ($(FNREC_OLD),$(FNREC))
-$(FNREC_STATE) :
-else
-$(FNREC_STATE) : clean
-$(shell $(ECHO) "$(FNREC)" > $(FNREC_STATE))
-endif
-
-VERYCLEANUP	+= $(FNREC_STATE)
-MAKEDEPS	+= $(FNREC_STATE)
-
-ifeq ($(FNREC),1)
-# Enabling -finstrument-functions affects gcc's analysis and leads to spurious
-# warnings about use of uninitialised variables.
-#
-CFLAGS		+= -Wno-uninitialized
-CFLAGS		+= -finstrument-functions
-CFLAGS		+= -finstrument-functions-exclude-file-list=core/fnrec.c
-endif
-
 # Enable per-item sections and section garbage collection.  Note that
 # some older versions of gcc support -fdata-sections but treat it as
 # implying -fno-common, which would break our build.  Some other older
@@ -523,6 +511,10 @@ CFLAGS		+= -include include/compiler.h
 #
 CFLAGS		+= -DASM_TCHAR='$(ASM_TCHAR)' -DASM_TCHAR_OPS='$(ASM_TCHAR_OPS)'
 
+# Inhibit the default -Dlinux
+#
+CFLAGS		+= -Ulinux
+
 # CFLAGS for specific object types
 #
 CFLAGS_c	+=
@@ -540,16 +532,6 @@ OBJ_CFLAGS	= $(CFLAGS_$(OBJECT)) -DOBJECT=$(subst -,_,$(OBJECT))
 $(BIN)/%.flags :
 	@$(ECHO) $(OBJ_CFLAGS)
 
-# ICC requires postprocessing objects to fix up table alignments
-#
-ifeq ($(CCTYPE),icc)
-POST_O		= && $(ICCFIX) $@
-POST_O_DEPS	:= $(ICCFIX)
-else
-POST_O		:=
-POST_O_DEPS	:=
-endif
-
 # Debug level calculations
 #
 DBGLVL_MAX	= -DDBGLVL_MAX=$(firstword $(subst ., ,$(1)))
@@ -559,9 +541,9 @@ DBGLVL		= $(call DBGLVL_MAX,$(1)) $(call DBGLVL_DFLT,$(1))
 # Rules for specific object types.
 #
 COMPILE_c	= $(CC) $(CFLAGS) $(CFLAGS_c) $(OBJ_CFLAGS)
-RULE_c		= $(Q)$(COMPILE_c) -c $< -o $@ $(POST_O)
+RULE_c		= $(Q)$(COMPILE_c) -c $< -o $@
 RULE_c_to_ids.o = $(Q)$(ECHO_E) '$(OBJ_IDS_ASM_NL)' | $(ASSEMBLE_S) -o $@
-RULE_c_to_dbg%.o= $(Q)$(COMPILE_c) $(call DBGLVL,$*) -c $< -o $@ $(POST_O)
+RULE_c_to_dbg%.o= $(Q)$(COMPILE_c) $(call DBGLVL,$*) -c $< -o $@
 RULE_c_to_c	= $(Q)$(COMPILE_c) -E -c $< > $@
 RULE_c_to_s	= $(Q)$(COMPILE_c) -S -g0 -c $< -o $@
 
@@ -801,6 +783,38 @@ include/ipxe/profile.h : $(PROFILE_LIST)
 
 .PRECIOUS : include/ipxe/profile.h
 
+# (Single-element) list of function recorder configuration
+#
+FNREC_LIST := $(BIN)/.fnrec.list
+ifeq ($(wildcard $(FNREC_LIST)),)
+FNREC_OLD := <invalid>
+else
+FNREC_OLD := $(shell cat $(FNREC_LIST))
+endif
+ifneq ($(FNREC_OLD),$(FNREC))
+$(shell $(ECHO) "$(FNREC)" > $(FNREC_LIST))
+endif
+
+$(FNREC_LIST) : $(MAKEDEPS)
+
+VERYCLEANUP += $(FNREC_LIST)
+
+# Function recorder configuration
+#
+ifeq ($(FNREC),1)
+# Enabling -finstrument-functions affects gcc's analysis and leads to spurious
+# warnings about use of uninitialised variables.
+#
+CFLAGS		+= -Wno-uninitialized
+CFLAGS		+= -finstrument-functions
+CFLAGS		+= -finstrument-functions-exclude-file-list=core/fnrec.c
+endif
+
+include/compiler.h : $(FNREC_LIST)
+	$(Q)$(TOUCH) $@
+
+.PRECIOUS : include/compiler.h
+
 # These files use .incbin inline assembly to include a binary file.
 # Unfortunately ccache does not detect this dependency and caches
 # builds even when the binary file has changed.
@@ -872,7 +886,7 @@ endef
 # $(3) is the source base name (e.g. "rtl8139")
 #
 define rules_template_parts
-$$(BIN)/$(3).o : $(1) $$(MAKEDEPS) $$(POST_O_DEPS) $$($(3)_DEPS)
+$$(BIN)/$(3).o : $(1) $$(MAKEDEPS) $$($(3)_DEPS)
 	$$(QM)$(ECHO) "  [BUILD] $$@"
 	$$(RULE_$(2))
 BOBJS += $$(BIN)/$(3).o
@@ -887,7 +901,7 @@ endef
 # $(4) is the destination type (e.g. "dbg%.o")
 #
 define rules_template_target
-$$(BIN)/$(3).$(4) : $(1) $$(MAKEDEPS) $$(POST_O_DEPS) $$($(3)_DEPS)
+$$(BIN)/$(3).$(4) : $(1) $$(MAKEDEPS) $$($(3)_DEPS)
 	$$(QM)$(ECHO) "  [BUILD] $$@"
 	$$(RULE_$(2)_to_$(4))
 $(TGT)_OBJS += $$(BIN)/$(3).$(4)
@@ -909,7 +923,7 @@ $(BIN)/deps/%.d : % $(MAKEDEPS)
 
 # Calculate list of dependency files
 #
-AUTO_DEPS	= $(patsubst %,$(BIN)/deps/%.d,$(AUTO_SRCS))
+AUTO_DEPS	= $(patsubst %,$(BIN)/deps/%.d,$(AUTO_SRCS) core/version.c)
 autodeps :
 	@$(ECHO) $(AUTO_DEPS)
 VERYCLEANUP	+= $(BIN)/deps
@@ -1093,9 +1107,10 @@ TGT_LD_ENTRY	= _$(TGT_PREFIX)_start
 #
 TGT_LD_FLAGS	= $(foreach SYM,$(TGT_LD_ENTRY) $(TGT_LD_DRIVERS) \
 		    $(TGT_LD_DEVLIST) obj_config obj_config_$(PLATFORM),\
-		    -u $(SYM) --defsym check_$(SYM)=$(SYM) ) \
+		    -u $(SYMBOL_PREFIX)$(SYM) \
+		    --defsym check_$(SYM)=$(SYMBOL_PREFIX)$(SYM) ) \
 		  $(patsubst %,--defsym %,$(TGT_LD_IDS)) \
-		  -e $(TGT_LD_ENTRY)
+		  -e $(SYMBOL_PREFIX)$(TGT_LD_ENTRY)
 
 # Calculate list of debugging versions of objects to be included in
 # the target.
@@ -1156,23 +1171,43 @@ BLIB		= $(BIN)/blib.a
 $(BLIB) : $(BLIB_OBJS) $(BLIB_LIST) $(MAKEDEPS)
 	$(Q)$(RM) $(BLIB)
 	$(QM)$(ECHO) "  [AR] $@"
-	$(Q)$(AR) r $@ $(sort $(BLIB_OBJS))
-	$(Q)$(RANLIB) $@
+	$(Q)$(AR) rD $@ $(sort $(BLIB_OBJS))
+	$(Q)$(OBJCOPY) --enable-deterministic-archives \
+		       --prefix-symbols=$(SYMBOL_PREFIX) $@
+	$(Q)$(RANLIB) -D $@
 blib : $(BLIB)
 
 # Command to generate build ID.  Must be unique for each $(BIN)/%.tmp,
 # even within the same build run.
 #
-BUILD_ID_CMD	:= perl -e 'printf "0x%08x", int ( rand ( 0xffffffff ) );'
+# The build ID is supposed to be collision-free across all ROMs that
+# might ever end up installed in the same system.  It doesn't just
+# disambiguate targets within a single build; it also disambiguates
+# different builds (such as builds for multiple ROMs all built from
+# the same blib.a).
+#
+BUILD_ID_CMD = cat $^ | cksum | awk '{print $$1}'
 
 # Build timestamp
 #
+# Used as a means to automatically select the newest version of iPXE
+# if multiple iPXE drivers are loaded concurrently in a UEFI system.
+#
+# It gets rounded down to the nearest minute when used for this
+# purpose.
+#
+ifdef SOURCE_DATE_EPOCH
+BUILD_TIMESTAMP := $(SOURCE_DATE_EPOCH)
+else ifdef GITVERSION
+BUILD_TIMESTAMP := $(shell git log -1 --pretty=%ct)
+else
 BUILD_TIMESTAMP := $(shell date +%s)
+endif
 
 # Build version
 #
 GIT_INDEX := $(if $(GITVERSION),$(if $(wildcard ../.git/index),../.git/index))
-$(BIN)/version.%.o : core/version.c $(MAKEDEPS) $(GIT_INDEX)
+$(BIN)/version.%.o : core/version.c $(MAKEDEPS) $(version_DEPS) $(GIT_INDEX)
 	$(QM)$(ECHO) "  [VERSION] $@"
 	$(Q)$(COMPILE_c) -DBUILD_NAME="\"$*\"" \
 		-DVERSION_MAJOR=$(VERSION_MAJOR) \
@@ -1180,6 +1215,7 @@ $(BIN)/version.%.o : core/version.c $(MAKEDEPS) $(GIT_INDEX)
 		-DVERSION_PATCH=$(VERSION_PATCH) \
 		-DVERSION="\"$(VERSION)\"" \
 		-c $< -o $@
+	$(Q)$(OBJCOPY) --prefix-symbols=$(SYMBOL_PREFIX) $@
 
 # Build an intermediate object file from the objects required for the
 # specified target.
@@ -1187,7 +1223,7 @@ $(BIN)/version.%.o : core/version.c $(MAKEDEPS) $(GIT_INDEX)
 $(BIN)/%.tmp : $(BIN)/version.%.o $(BLIB) $(MAKEDEPS) $(LDSCRIPT)
 	$(QM)$(ECHO) "  [LD] $@"
 	$(Q)$(LD) $(LDFLAGS) -T $(LDSCRIPT) $(TGT_LD_FLAGS) $< $(BLIB) -o $@ \
-		--defsym _build_id=`$(BUILD_ID_CMD)` \
+		--defsym _build_id=$(shell $(BUILD_ID_CMD)) \
 		--defsym _build_timestamp=$(BUILD_TIMESTAMP) \
 		-Map $(BIN)/$*.tmp.map
 	$(Q)$(OBJDUMP) -ht $@ | $(PERL) $(SORTOBJDUMP) >> $(BIN)/$*.tmp.map
@@ -1398,7 +1434,7 @@ $(ELF2EFI64) : util/elf2efi.c $(MAKEDEPS)
 	$(Q)$(HOST_CC) $(HOST_CFLAGS) -idirafter include -DEFI_TARGET64 $< -o $@
 CLEANUP += $(ELF2EFI64)
 
-$(EFIROM) : util/efirom.c $(MAKEDEPS)
+$(EFIROM) : util/efirom.c util/eficompress.c $(MAKEDEPS)
 	$(QM)$(ECHO) "  [HOSTCC] $@"
 	$(Q)$(HOST_CC) $(HOST_CFLAGS) -idirafter include -o $@ $<
 CLEANUP += $(EFIROM)
@@ -1408,15 +1444,6 @@ $(EFIFATBIN) : util/efifatbin.c $(MAKEDEPS)
 	$(Q)$(HOST_CC) $(HOST_CFLAGS) -idirafter include -o $@ $<
 CLEANUP += $(EFIFATBIN)
 
-###############################################################################
-#
-# The ICC fixup utility
-#
-$(ICCFIX) : util/iccfix.c $(MAKEDEPS)
-	$(QM)$(ECHO) "  [HOSTCC] $@"
-	$(Q)$(HOST_CC) $(HOST_CFLAGS) -idirafter include -o $@ $<
-CLEANUP += $(ICCFIX)
-
 ###############################################################################
 #
 # The error usage information utility
@@ -1541,7 +1568,7 @@ endif # defined(BIN)
 #
 
 hci/keymap/keymap_%.c :
-	$(Q)$(PERL) $(GENKEYMAP) $* > $@
+	$(Q)$(PYTHON) $(GENKEYMAP) $* > $@
 
 ###############################################################################
 #
@@ -1556,13 +1583,14 @@ hci/keymap/keymap_%.c :
 #
 
 ifeq ($(NUM_BINS),0)
-ALLBINS		:= bin{,-*}
-CLEANUP		:= $(patsubst $(BIN)/%,$(ALLBINS)/%,$(CLEANUP))
-VERYCLEANUP	:= $(patsubst $(BIN)/%,$(ALLBINS)/%,$(VERYCLEANUP))
+ALLBINS		:= bin bin-*
+ALLBIN		= $(foreach B,$(ALLBINS),$(patsubst $(BIN)/%,$(B)/%,$(1)))
+CLEANUP		:= $(foreach C,$(CLEANUP),$(call ALLBIN,$(C)))
+VERYCLEANUP	:= $(foreach V,$(VERYCLEANUP),$(call ALLBIN,$(V)))
 endif
 
 clean :
-	$(RM) $(CLEANUP)
+	$(RM) -r $(CLEANUP)
 
 veryclean : clean
 	$(RM) -r $(VERYCLEANUP)

src/Makefile.linux

@@ -0,0 +1,55 @@
+# -*- makefile -*- : Force emacs to use Makefile mode
+
+# Prefix all iPXE symbols to avoid collisions with platform libraries
+#
+SYMBOL_PREFIX	= _ipxe__
+
+# Enable valgrind
+#
+CFLAGS		+= -UNVALGRIND
+
+# The Linux linker script
+#
+LDSCRIPT	= scripts/linux.lds
+
+# Use a two-stage link
+#
+LDFLAGS		+= -r -d
+
+# Source directories
+#
+SRCDIRS		+= drivers/linux
+SRCDIRS		+= interface/linux
+NON_AUTO_SRCS	+= interface/linux/linux_api.c
+
+# Media types
+#
+NON_AUTO_MEDIA = linux
+
+# Compiler flags for building host API wrapper
+#
+LINUX_CFLAGS	+= -Os -idirafter include -DSYMBOL_PREFIX=$(SYMBOL_PREFIX)
+
+# Check for libslirp
+#
+LIBSLIRP_TEST = $(CC) $(LINUX_CFLAGS) -x c /dev/null -nostartfiles \
+		      -include slirp/libslirp.h -lslirp \
+		      -o /dev/null >/dev/null 2>&1
+WITH_LIBSLIRP	:= $(shell $(LIBSLIRP_TEST) && $(ECHO) yes)
+ifneq ($(WITH_LIBSLIRP),)
+LINUX_CFLAGS	+= -DHAVE_LIBSLIRP
+LINUX_LIBS	+= -lslirp
+endif
+
+# Host API wrapper
+#
+$(BIN)/linux_api.o : interface/linux/linux_api.c include/ipxe/linux_api.h \
+		     include/ipxe/slirp.h $(MAKEDEPS)
+	$(QM)$(ECHO) "  [BUILD] $@"
+	$(Q)$(CC) $(LINUX_CFLAGS) $(WORKAROUND_CFLAGS) -o $@ -c $<
+
+# Rule to generate final binary
+#
+$(BIN)/%.linux : $(BIN)/%.linux.tmp $(BIN)/linux_api.o
+	$(QM)$(ECHO) "  [FINISH] $@"
+	$(Q)$(CC) $(LINUX_CFLAGS) $(WORKAROUND_CFLAGS) -o $@ $^ $(LINUX_LIBS)

src/arch/arm/Makefile.linux

@@ -0,0 +1,6 @@
+# -*- makefile -*- : Force emacs to use Makefile mode
+
+# Include generic Linux Makefile
+#
+MAKEDEPS	+= Makefile.linux
+include Makefile.linux

src/arch/arm/include/bits/io.h

@@ -9,6 +9,9 @@
 
 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
 
+/** Page shift */
+#define PAGE_SHIFT 12
+
 #include <ipxe/arm_io.h>
 
 #endif /* _BITS_IO_H */

src/arch/arm/include/ipxe/arm_io.h

@@ -20,9 +20,6 @@ FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
  *
  */
 
-/** Page shift */
-#define PAGE_SHIFT 12
-
 /*
  * Physical<->Bus address mappings
  *

src/arch/arm32/Makefile

@@ -5,7 +5,7 @@ SRCDIRS		+= arch/arm32/libgcc
 
 # ARM32-specific flags
 #
-CFLAGS		+= -mthumb -mcpu=cortex-a15 -mabi=aapcs -mfloat-abi=soft
+CFLAGS		+= -mthumb -mcpu=cortex-a15 -mabi=aapcs
 CFLAGS		+= -mword-relocations
 ASFLAGS		+= -mthumb -mcpu=cortex-a15
 
@@ -13,6 +13,11 @@ ASFLAGS		+= -mthumb -mcpu=cortex-a15
 #
 CFLAGS		+= -fshort-wchar
 
+# EFI requires that enums are always 32 bits, and nothing else
+# currently cares
+#
+CFLAGS		+= -fno-short-enums
+
 # Include common ARM Makefile
 MAKEDEPS	+= arch/arm/Makefile
 include arch/arm/Makefile

src/arch/arm32/Makefile.efi

@@ -1,8 +1,8 @@
 # -*- makefile -*- : Force emacs to use Makefile mode
 
-# UEFI requires that enums are always 32 bits
+# EFI uses the soft float ABI
 #
-CFLAGS		+= -fno-short-enums
+CFLAGS		+= -mfloat-abi=soft
 
 # Specify EFI image builder
 #

src/arch/arm32/core/setjmp.S

@@ -1,5 +1,6 @@
 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL )
 
+	.section ".note.GNU-stack", "", %progbits
 	.text
 	.arm
 

src/arch/arm32/include/bits/compiler.h

@@ -8,6 +8,9 @@ FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
 
 #ifndef ASSEMBLY
 
+/** Unprefixed constant operand modifier */
+#define ASM_NO_PREFIX "c"
+
 #define __asmcall
 #define __libgcc
 

src/arch/arm32/include/efi/ipxe/dhcp_arch.h

@@ -1,40 +0,0 @@
-/*
- * Copyright (C) 2015 Michael Brown <mbrown@fensystems.co.uk>.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301, USA.
- *
- * You can also choose to distribute this program under the terms of
- * the Unmodified Binary Distribution Licence (as given in the file
- * COPYING.UBDL), provided that you have satisfied its requirements.
- */
-
-#ifndef _DHCP_ARCH_H
-#define _DHCP_ARCH_H
-
-/** @file
- *
- * Architecture-specific DHCP options
- */
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-#include <ipxe/dhcp.h>
-
-#define DHCP_ARCH_CLIENT_ARCHITECTURE DHCP_CLIENT_ARCHITECTURE_ARM32
-
-#define DHCP_ARCH_CLIENT_NDI 1 /* UNDI */ , 3, 10 /* v3.10 */
-
-#endif

src/arch/arm32/include/ipxe/efi/dhcparch.h

@@ -0,0 +1,20 @@
+#ifndef _IPXE_EFI_DHCPARCH_H
+#define _IPXE_EFI_DHCPARCH_H
+
+/** @file
+ *
+ * DHCP client architecture definitions
+ *
+ */
+
+FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
+
+#include <ipxe/dhcp.h>
+
+/** DHCP client architecture */
+#define DHCP_ARCH_CLIENT_ARCHITECTURE DHCP_CLIENT_ARCHITECTURE_ARM32
+
+/** DHCP client network device interface */
+#define DHCP_ARCH_CLIENT_NDI 1 /* UNDI */ , 3, 10 /* v3.10 */
+
+#endif /* _IPXE_EFI_DHCPARCH_H */

src/arch/arm32/libgcc/lldivmod.S

@@ -1,5 +1,6 @@
 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL )
 
+	.section ".note.GNU-stack", "", %progbits
 	.text
 	.thumb
 

src/arch/arm32/libgcc/llshift.S

@@ -1,5 +1,6 @@
 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL )
 
+	.section ".note.GNU-stack", "", %progbits
 	.text
 	.arm
 

src/arch/arm64/Makefile.efi

@@ -1,9 +1,5 @@
 # -*- makefile -*- : Force emacs to use Makefile mode
 
-# Avoid untranslatable relocations
-#
-CFLAGS		+= -fno-pic
-
 # Specify EFI image builder
 #
 ELF2EFI		= $(ELF2EFI64)

src/arch/arm64/Makefile.linux

@@ -0,0 +1,10 @@
+# -*- makefile -*- : Force emacs to use Makefile mode
+
+# Starting virtual address
+#
+LDFLAGS += -Ttext=0x400000
+
+# Include generic Linux Makefile
+#
+MAKEDEPS += arch/arm/Makefile.linux
+include arch/arm/Makefile.linux

src/arch/arm64/include/bits/compiler.h

@@ -8,6 +8,9 @@ FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
 
 #ifndef ASSEMBLY
 
+/** Unprefixed constant operand modifier */
+#define ASM_NO_PREFIX "c"
+
 #define __asmcall
 #define __libgcc
 

src/arch/arm64/include/efi/ipxe/dhcp_arch.h

@@ -1,40 +0,0 @@
-/*
- * Copyright (C) 2015 Michael Brown <mbrown@fensystems.co.uk>.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301, USA.
- *
- * You can also choose to distribute this program under the terms of
- * the Unmodified Binary Distribution Licence (as given in the file
- * COPYING.UBDL), provided that you have satisfied its requirements.
- */
-
-#ifndef _DHCP_ARCH_H
-#define _DHCP_ARCH_H
-
-/** @file
- *
- * Architecture-specific DHCP options
- */
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-#include <ipxe/dhcp.h>
-
-#define DHCP_ARCH_CLIENT_ARCHITECTURE DHCP_CLIENT_ARCHITECTURE_ARM64
-
-#define DHCP_ARCH_CLIENT_NDI 1 /* UNDI */ , 3, 10 /* v3.10 */
-
-#endif

src/arch/arm64/include/ipxe/efi/dhcparch.h

@@ -0,0 +1,20 @@
+#ifndef _IPXE_EFI_DHCPARCH_H
+#define _IPXE_EFI_DHCPARCH_H
+
+/** @file
+ *
+ * DHCP client architecture definitions
+ *
+ */
+
+FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
+
+#include <ipxe/dhcp.h>
+
+/** DHCP client architecture */
+#define DHCP_ARCH_CLIENT_ARCHITECTURE DHCP_CLIENT_ARCHITECTURE_ARM64
+
+/** DHCP client network device interface */
+#define DHCP_ARCH_CLIENT_NDI 1 /* UNDI */ , 3, 10 /* v3.10 */
+
+#endif /* _IPXE_EFI_DHCPARCH_H */

src/arch/i386/Makefile

@@ -69,22 +69,6 @@ CFLAGS		+= -fshort-wchar
 #
 CFLAGS			+= -Ui386
 
-# Some widespread patched versions of gcc include -fPIE -Wl,-pie by
-# default.  Note that gcc will exit *successfully* if it fails to
-# recognise an option that starts with "no", so we have to test for
-# output on stderr instead of checking the exit status.
-#
-# Current versions of gcc require -no-pie; older versions require
-# -nopie.  We therefore test for both.
-#
-ifeq ($(CCTYPE),gcc)
-PIE_TEST = [ -z "`$(CC) -fno-PIE -no-pie -x c -c /dev/null -o /dev/null 2>&1`" ]
-PIE_FLAGS := $(shell $(PIE_TEST) && $(ECHO) '-fno-PIE -no-pie')
-PIE_TEST2 = [ -z "`$(CC) -fno-PIE -nopie -x c -c /dev/null -o /dev/null 2>&1`" ]
-PIE_FLAGS2 := $(shell $(PIE_TEST2) && $(ECHO) '-fno-PIE -nopie')
-WORKAROUND_CFLAGS += $(PIE_FLAGS) $(PIE_FLAGS2)
-endif
-
 # i386-specific directories containing source files
 #
 SRCDIRS		+= arch/i386/core

src/arch/i386/Makefile.linux

@@ -1,6 +1,14 @@
-LDSCRIPT = arch/i386/scripts/linux.lds
+# -*- makefile -*- : Force emacs to use Makefile mode
 
-SRCDIRS += arch/i386/core/linux
+# Starting virtual address
+#
+LDFLAGS += -Ttext=0x08048000
 
+# Compiler flags for building host API wrapper
+#
+LINUX_CFLAGS	+= -m32
+
+# Include generic Linux Makefile
+#
 MAKEDEPS += arch/x86/Makefile.linux
 include arch/x86/Makefile.linux

src/arch/i386/core/linux/linux_syscall.S

@@ -1,45 +0,0 @@
-
-	.section ".data"
-	.globl linux_errno
-
-linux_errno:	.int 0
-
-	.section ".text"
-	.code32
-	.globl linux_syscall
-	.type  linux_syscall, @function
-
-linux_syscall:
-	/* Save registers */
-	pushl	%ebx
-	pushl	%esi
-	pushl	%edi
-	pushl	%ebp
-
-	movl	20(%esp), %eax  // C arg1 -> syscall number
-	movl	24(%esp), %ebx  // C arg2 -> syscall arg1
-	movl	28(%esp), %ecx  // C arg3 -> syscall arg2
-	movl	32(%esp), %edx  // C arg4 -> syscall arg3
-	movl	36(%esp), %esi  // C arg5 -> syscall arg4
-	movl	40(%esp), %edi  // C arg6 -> syscall arg5
-	movl	44(%esp), %ebp  // C arg7 -> syscall arg6
-
-	int	$0x80
-
-	/* Restore registers */
-	popl	%ebp
-	popl	%edi
-	popl	%esi
-	popl	%ebx
-
-	cmpl	$-4095, %eax
-	jae	1f
-	ret
-
-1:
-	negl	%eax
-	movl	%eax, linux_errno
-	movl	$-1, %eax
-	ret
-
-	.size linux_syscall, . - linux_syscall

src/arch/i386/core/linux/linuxprefix.S

@@ -1,28 +0,0 @@
-#include <linux/unistd.h>
-
-	.section ".text"
-	.code32
-	.globl _linux_start
-	.type _linux_start, @function
-
-_linux_start:
-	xorl	%ebp, %ebp
-
-	popl	%esi       // save argc
-	movl	%esp, %edi // save argv
-
-	andl	$~15, %esp // 16-byte align the stack
-
-	pushl	%edi // argv -> C arg2
-	pushl	%esi // argc -> C arg1
-
-	call	save_args
-
-	/* Our main doesn't use any arguments */
-	call	main
-
-	movl	%eax, %ebx // rc -> syscall arg1
-	movl	$__NR_exit, %eax
-	int	$0x80
-
-	.size _linux_start, . - _linux_start

src/arch/i386/include/bits/compiler.h

@@ -8,8 +8,11 @@ FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
 
 #ifndef ASSEMBLY
 
+/** Unprefixed constant operand modifier */
+#define ASM_NO_PREFIX "c"
+
 /** Declare a function with standard calling conventions */
-#define __asmcall __attribute__ (( used, cdecl, regparm(0) ))
+#define __asmcall __attribute__ (( cdecl, regparm(0) ))
 
 /**
  * Declare a function with libgcc implicit linkage

src/arch/i386/include/bits/linux_api.h

@@ -1,6 +0,0 @@
-#ifndef _I386_LINUX_API_H
-#define _I386_LINUX_API_H
-
-#define __SYSCALL_mmap __NR_mmap2
-
-#endif /* _I386_LINUX_API_H */

src/arch/i386/include/ipxe/efi/dhcparch.h

@@ -0,0 +1,20 @@
+#ifndef _IPXE_EFI_DHCPARCH_H
+#define _IPXE_EFI_DHCPARCH_H
+
+/** @file
+ *
+ * DHCP client architecture definitions
+ *
+ */
+
+FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
+
+#include <ipxe/dhcp.h>
+
+/** DHCP client architecture */
+#define DHCP_ARCH_CLIENT_ARCHITECTURE DHCP_CLIENT_ARCHITECTURE_IA32
+
+/** DHCP client network device interface */
+#define DHCP_ARCH_CLIENT_NDI 1 /* UNDI */ , 3, 10 /* v3.10 */
+
+#endif /* _IPXE_EFI_DHCPARCH_H */

src/arch/i386/scripts/i386-kir.lds

@@ -136,6 +136,8 @@ SECTIONS {
 	*(.note.*)
 	*(.discard)
 	*(.discard.*)
+	*(.sbat)
+	*(.sbat.*)
     }
 
     /*

src/arch/loong64/Makefile

@@ -0,0 +1,26 @@
+# Assembler section type character
+#
+ASM_TCHAR	:= @
+ASM_TCHAR_OPS	:= @
+
+# LoongArch64-specific flags
+#
+CFLAGS		+= -fstrength-reduce -fomit-frame-pointer
+CFLAGS		+= -falign-jumps=1 -falign-loops=1 -falign-functions=1
+
+# Check if -mno-explicit-relocs is valid
+ifeq ($(CCTYPE),gcc)
+MNER_TEST = $(CC) -mno-explicit-relocs -x c -c /dev/null -o /dev/null >/dev/null 2>&1
+MNER_FLAGS := $(shell $(MNER_TEST) && $(ECHO) '-mno-explicit-relocs')
+WORKAROUND_CFLAGS += $(MNER_FLAGS)
+endif
+
+# EFI requires -fshort-wchar, and nothing else currently uses wchar_t
+CFLAGS		+= -fshort-wchar
+
+# LoongArch64-specific directories containing source files
+SRCDIRS		+= arch/loong64/core
+
+# Include platform-specific Makefile
+MAKEDEPS	+= arch/loong64/Makefile.$(PLATFORM)
+include arch/loong64/Makefile.$(PLATFORM)

src/arch/loong64/Makefile.linux

@@ -0,0 +1,10 @@
+# -*- makefile -*- : Force emacs to use Makefile mode
+
+# Starting virtual address
+#
+LDFLAGS += -Ttext=0x120000000
+
+# Include generic Linux Makefile
+#
+MAKEDEPS += Makefile.linux
+include Makefile.linux

src/arch/loong64/core/loong64_bigint.c

@@ -0,0 +1,120 @@
+/*
+ * Copyright (C) 2012 Michael Brown <mbrown@fensystems.co.uk>.
+ * Copyright (c) 2023, Xiaotian Wu <wuxiaotian@loongson.cn>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA.
+ *
+ * You can also choose to distribute this program under the terms of
+ * the Unmodified Binary Distribution Licence (as given in the file
+ * COPYING.UBDL), provided that you have satisfied its requirements.
+ */
+
+FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
+
+#include <stdint.h>
+#include <string.h>
+#include <ipxe/bigint.h>
+
+/** @file
+ *
+ * Big integer support
+ */
+
+/**
+ * Multiply big integers
+ *
+ * @v multiplicand0	Element 0 of big integer to be multiplied
+ * @v multiplier0	Element 0 of big integer to be multiplied
+ * @v result0		Element 0 of big integer to hold result
+ * @v size		Number of elements
+ */
+void bigint_multiply_raw ( const uint64_t *multiplicand0,
+			   const uint64_t *multiplier0,
+			   uint64_t *result0, unsigned int size ) {
+	const bigint_t ( size ) __attribute__ (( may_alias )) *multiplicand =
+		( ( const void * ) multiplicand0 );
+	const bigint_t ( size ) __attribute__ (( may_alias )) *multiplier =
+		( ( const void * ) multiplier0 );
+	bigint_t ( size * 2 ) __attribute__ (( may_alias )) *result =
+		( ( void * ) result0 );
+	unsigned int i;
+	unsigned int j;
+	uint64_t multiplicand_element;
+	uint64_t multiplier_element;
+	uint64_t *result_elements;
+	uint64_t discard_low;
+	uint64_t discard_high;
+	uint64_t discard_temp_low;
+	uint64_t discard_temp_high;
+
+	/* Zero result */
+	memset ( result, 0, sizeof ( *result ) );
+
+	/* Multiply integers one element at a time */
+	for ( i = 0 ; i < size ; i++ ) {
+		multiplicand_element = multiplicand->element[i];
+		for ( j = 0 ; j < size ; j++ ) {
+			multiplier_element = multiplier->element[j];
+			result_elements = &result->element[ i + j ];
+			/* Perform a single multiply, and add the
+			 * resulting double-element into the result,
+			 * carrying as necessary.  The carry can
+			 * never overflow beyond the end of the
+			 * result, since:
+			 *
+			 *     a < 2^{n}, b < 2^{n} => ab < 2^{2n}
+			 */
+			__asm__ __volatile__ ( "mul.d   %1, %6, %7\n\t"
+					       "mulh.du %2, %6, %7\n\t"
+
+					       "ld.d    %3, %0, 0\n\t"
+					       "ld.d    %4, %0, 8\n\t"
+
+					       "add.d   %3, %3, %1\n\t"
+					       "sltu    $t0, %3, %1\n\t"
+
+					       "add.d   %4, %4, %2\n\t"
+					       "sltu    $t1, %4, %2\n\t"
+
+					       "add.d   %4, %4, $t0\n\t"
+					       "sltu    $t0, %4, $t0\n\t"
+					       "or      $t0, $t0, $t1\n\t"
+
+					       "st.d    %3,  %0, 0\n\t"
+					       "st.d    %4,  %0, 8\n\t"
+
+					       "addi.d  %0,  %0, 16\n\t"
+					       "beqz    $t0, 2f\n"
+					       "1:\n\t"
+					       "ld.d    %3,  %0, 0\n\t"
+					       "add.d   %3,  %3, $t0\n\t"
+					       "sltu    $t0, %3, $t0\n\t"
+					       "st.d    %3,  %0, 0\n\t"
+					       "addi.d  %0, %0, 8\n\t"
+					       "bnez    $t0, 1b\n"
+					       "2:"
+					       : "+r" ( result_elements ),
+						 "=&r" ( discard_low ),
+						 "=&r" ( discard_high ),
+						 "=r" ( discard_temp_low ),
+						 "=r" ( discard_temp_high ),
+						 "+m" ( *result )
+					       : "r" ( multiplicand_element ),
+						 "r" ( multiplier_element )
+					       : "t0", "t1" );
+		}
+	}
+}

src/arch/loong64/core/loong64_string.c

@@ -0,0 +1,266 @@
+/*
+ * Copyright (C) 2016 Michael Brown <mbrown@fensystems.co.uk>.
+ * Copyright (c) 2023, Xiaotian Wu <wuxiaotian@loongson.cn>
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA.
+ *
+ * You can also choose to distribute this program under the terms of
+ * the Unmodified Binary Distribution Licence (as given in the file
+ * COPYING.UBDL), provided that you have satisfied its requirements.
+ */
+
+/** @file
+ *
+ * Optimised string operations
+ *
+ */
+
+FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
+
+#include <string.h>
+
+/**
+ * Copy memory area
+ *
+ * @v dest		Destination address
+ * @v src		Source address
+ * @v len		Length
+ * @ret dest		Destination address
+ */
+void loong64_memcpy ( void *dest, const void *src, size_t len ) {
+	void *discard_dest;
+	void *discard_end;
+	const void *discard_src;
+	size_t discard_offset;
+	unsigned long discard_data;
+	unsigned long discard_low;
+	unsigned long discard_high;
+
+	/* If length is too short, then just copy individual bytes.
+	 */
+	if ( len < 16 ) {
+		__asm__ __volatile__ ( "beqz %0, 2f\n\t"
+				       "\n1:\n\t"
+				       "addi.d %0, %0, -1\n\t"
+				       "ldx.b %1, %3, %0\n\t"
+				       "stx.b %1, %2, %0\n\t"
+				       "bnez %0, 1b\n\t"
+				       "\n2:\n\t"
+				       : "=&r" ( discard_offset ),
+					 "=&r" ( discard_data )
+				       : "r" ( dest ), "r" ( src ), "0" ( len )
+				       : "memory", "t0" );
+		return;
+	}
+
+	/* Copy 16 bytes at a time: one initial
+	 * potentially unaligned access, multiple destination-aligned
+	 * accesses, one final potentially unaligned access.
+	 */
+	__asm__ __volatile__ ( "ld.d %3, %1, 0\n\t"
+			       "ld.d %4, %1, 8\n\t"
+			       "addi.d %1, %1, 16\n\t"
+			       "st.d %3, %0, 0\n\t"
+			       "st.d %4, %0, 8\n\t"
+			       "addi.d %0, %0, 16\n\t"
+			       "andi %3, %0, 15\n\t"
+			       "sub.d %0, %0, %3\n\t"
+			       "sub.d %1, %1, %3\n\t"
+			       "addi.d $t0, $zero, 0xf\n\t"
+			       "andn %2, %5, $t0\n\t"
+			       "b 2f\n\t"
+			       "\n1:\n\t"
+			       "ld.d %3, %1, 0\n\t"
+			       "ld.d %4, %1, 8\n\t"
+			       "addi.d %1, %1, 16\n\t"
+			       "st.d %3, %0, 0\n\t"
+			       "st.d %4, %0, 8\n\t"
+			       "addi.d %0, %0, 16\n\t"
+			       "\n2:\n\t"
+			       "bne %0, %2, 1b\n\t"
+			       "ld.d %3, %6, -16\n\t"
+			       "ld.d %4, %6, -8\n\t"
+			       "st.d %3, %5, -16\n\t"
+			       "st.d %4, %5, -8\n\t"
+			       : "=&r" ( discard_dest ),
+				 "=&r" ( discard_src ),
+				 "=&r" ( discard_end ),
+				 "=&r" ( discard_low ),
+				 "=&r" ( discard_high )
+			       : "r" ( dest + len ), "r" ( src + len ),
+				 "0" ( dest ), "1" ( src )
+			       : "memory", "t0" );
+}
+
+/**
+ * Zero memory region
+ *
+ * @v dest		Destination region
+ * @v len		Length
+ */
+void loong64_bzero ( void *dest, size_t len ) {
+	size_t discard_offset;
+	void *discard_dest;
+	void *discard_end;
+
+	/* If length is too short, then just zero individual bytes.
+	 */
+	if ( len < 16 ) {
+		__asm__ __volatile__ ( "beqz %0, 2f\n\t"
+				       "\n1:\n\t"
+				       "addi.d %0, %0, -1\n\t"
+				       "stx.b $zero, %1, %0\n\t"
+				       "bnez %0, 1b\n\t"
+				       "\n2:\n\t"
+				       : "=&r" ( discard_offset )
+				       : "r" ( dest ), "0" ( len )
+				       : "memory" );
+		return;
+	}
+
+	/* To zero 16 bytes at a time: one initial
+	 * potentially unaligned access, multiple aligned accesses,
+	 * one final potentially unaligned access.
+	 */
+
+	__asm__ __volatile__ ( "st.d $zero, %0, 0\n\t"
+			       "st.d $zero, %0, 8\n\t"
+			       "addi.d %0, %0, 16\n\t"
+			       "addi.w $t0, $zero, 15\n\t"
+			       "andn %0, %0, $t0\n\t"
+			       "addi.w $t0, $zero, 15\n\t"
+			       "andn %1, %2, $t0\n\t"
+			       "b 2f\n\t"
+			       "\n1:\n\t"
+			       "st.d $zero, %0, 0\n\t"
+			       "st.d $zero, %0, 8\n\t"
+			       "addi.d %0, %0, 16\n\t"
+			       "\n2:\n\t"
+			       "bne %0, %1, 1b\n\t"
+			       "st.d $zero, %2, -16\n\t"
+			       "st.d $zero, %2, -8\n\t"
+			       : "=&r" ( discard_dest ),
+				 "=&r" ( discard_end )
+			       : "r" ( dest + len ), "0" ( dest )
+			       : "memory", "t0" );
+}
+
+/**
+ * Fill memory region
+ *
+ * @v dest		Destination region
+ * @v len		Length
+ * @v character		Fill character
+ *
+ * The unusual parameter order is to allow for more efficient
+ * tail-calling to loong64_memset() when zeroing a region.
+ */
+void loong64_memset ( void *dest, size_t len, int character ) {
+	size_t discard_offset;
+
+	/* Use optimised zeroing code if applicable */
+	if ( character == 0 ) {
+		loong64_bzero ( dest, len );
+		return;
+	}
+
+	/* Fill one byte at a time.  Calling memset() with a non-zero
+	 * value is relatively rare and unlikely to be
+	 * performance-critical.
+	 */
+	__asm__ __volatile__ ( "beqz %0, 2f\n\t"
+			       "\n1:\n\t"
+			       "addi.d %0, %0, -1\n\t"
+			       "stx.b %2, %1, %0\n\t"
+			       "bnez %0, 1b\n\t"
+			       "\n2:\n\t"
+			       : "=&r" ( discard_offset )
+			       : "r" ( dest ), "r" ( character ), "0" ( len )
+			       : "memory" );
+}
+
+/**
+ * Copy (possibly overlapping) memory region forwards
+ *
+ * @v dest		Destination region
+ * @v src		Source region
+ * @v len		Length
+ */
+void loong64_memmove_forwards ( void *dest, const void *src, size_t len ) {
+	void *discard_dest;
+	const void *discard_src;
+	unsigned long discard_data;
+
+	/* Assume memmove() is not performance-critical, and perform a
+	 * bytewise copy for simplicity.
+	 */
+	__asm__ __volatile__ ( "b 2f\n\t"
+			       "\n1:\n\t"
+			       "ld.b %2, %1, 0\n\t"
+			       "addi.d %1, %1, 1\n\t"
+			       "st.b %2, %0, 0\n\t"
+			       "addi.d %0, %0, 1\n\t"
+			       "\n2:\n\t"
+			       "bne %0, %3, 1b\n\t"
+			       : "=&r" ( discard_dest ),
+				 "=&r" ( discard_src ),
+				 "=&r" ( discard_data )
+			       : "r" ( dest + len ), "0" ( dest ), "1" ( src )
+			       : "memory" );
+}
+
+/**
+ * Copy (possibly overlapping) memory region backwards
+ *
+ * @v dest		Destination region
+ * @v src		Source region
+ * @v len		Length
+ */
+void loong64_memmove_backwards ( void *dest, const void *src, size_t len ) {
+	size_t discard_offset;
+	unsigned long discard_data;
+
+	/* Assume memmove() is not performance-critical, and perform a
+	 * bytewise copy for simplicity.
+	 */
+	__asm__ __volatile__ ( "beqz %0, 2f\n\t"
+			       "\n1:\n\t"
+			       "addi.d %0, %0, -1\n\t"
+			       "ldx.b %1, %3, %0\n\t"
+			       "stx.b %1, %2, %0\n\t"
+			       "bnez %0, 1b\n\t"
+			       "\n2:\n\t"
+			       : "=&r" ( discard_offset ),
+				 "=&r" ( discard_data )
+			       : "r" ( dest ), "r" ( src ), "0" ( len )
+			       : "memory" );
+}
+
+/**
+ * Copy (possibly overlapping) memory region
+ *
+ * @v dest		Destination region
+ * @v src		Source region
+ * @v len		Length
+ */
+void loong64_memmove ( void *dest, const void *src, size_t len ) {
+
+	if ( dest <= src ) {
+		loong64_memmove_forwards ( dest, src, len );
+	} else {
+		loong64_memmove_backwards ( dest, src, len );
+	}
+}

src/arch/loong64/core/setjmp.S

@@ -0,0 +1,53 @@
+FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL )
+
+	.section ".note.GNU-stack", "", %progbits
+	.text
+/*
+   int setjmp(jmp_buf env);
+*/
+	.globl	setjmp
+	.type	setjmp, %function
+setjmp:
+	/* Store registers */
+	st.d	$s0, $a0, 0x0
+	st.d	$s1, $a0, 0x8
+	st.d	$s2, $a0, 0x10
+	st.d	$s3, $a0, 0x18
+	st.d	$s4, $a0, 0x20
+	st.d	$s5, $a0, 0x28
+	st.d	$s6, $a0, 0x30
+	st.d	$s7, $a0, 0x38
+	st.d	$s8, $a0, 0x40
+	st.d	$fp, $a0, 0x48
+	st.d	$sp, $a0, 0x50
+	st.d	$ra, $a0, 0x58
+
+	move	$a0, $zero
+	jirl	$zero, $ra, 0
+	.size	setjmp, . - setjmp
+
+/*
+   void longjmp(jmp_buf env, int val);
+*/
+	.globl	longjmp
+	.type	longjmp, %function
+longjmp:
+	/* Restore registers */
+	ld.d	$s0, $a0, 0x0
+	ld.d	$s1, $a0, 0x8
+	ld.d	$s2, $a0, 0x10
+	ld.d	$s3, $a0, 0x18
+	ld.d	$s4, $a0, 0x20
+	ld.d	$s5, $a0, 0x28
+	ld.d	$s6, $a0, 0x30
+	ld.d	$s7, $a0, 0x38
+	ld.d	$s8, $a0, 0x40
+	ld.d	$fp, $a0, 0x48
+	ld.d	$sp, $a0, 0x50
+	ld.d	$ra, $a0, 0x58
+	addi.d	$a0, $zero, 1    # a0 = 1
+	beqz	$a1, .exit       # if (a1 == 0); goto L0
+	move	$a0, $a1         # a0 = a1
+.exit:
+	jirl	$zero, $ra, 0
+	.size	longjmp, . - longjmp

src/arch/loong64/include/bits/acpi.h

@@ -0,0 +1,12 @@
+#ifndef _BITS_ACPI_H
+#define _BITS_ACPI_H
+
+/** @file
+ *
+ * LoongArch64-specific ACPI API implementations
+ *
+ */
+
+FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
+
+#endif /* _BITS_ACPI_H */

src/arch/loong64/include/bits/bigint.h

@@ -0,0 +1,336 @@
+#ifndef _BITS_BIGINT_H
+#define _BITS_BIGINT_H
+
+/** @file
+ *
+ * Big integer support
+ */
+
+FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
+
+#include <stdint.h>
+#include <string.h>
+#include <strings.h>
+
+/** Element of a big integer */
+typedef uint64_t bigint_element_t;
+
+/**
+ * Initialise big integer
+ *
+ * @v value0	Element 0 of big integer to initialise
+ * @v size		Number of elements
+ * @v data		Raw data
+ * @v len		Length of raw data
+ */
+static inline __attribute__ (( always_inline )) void
+bigint_init_raw ( uint64_t *value0, unsigned int size,
+		  const void *data, size_t len ) {
+	size_t pad_len = ( sizeof ( bigint_t ( size ) ) - len );
+	uint8_t *value_byte = ( ( void * ) value0 );
+	const uint8_t *data_byte = ( data + len );
+
+	/* Copy raw data in reverse order, padding with zeros */
+	while ( len-- )
+		*(value_byte++) = *(--data_byte);
+	while ( pad_len-- )
+		*(value_byte++) = 0;
+}
+
+/**
+ * Add big integers
+ *
+ * @v addend0		Element 0 of big integer to add
+ * @v value0		Element 0 of big integer to be added to
+ * @v size		Number of elements
+ */
+static inline __attribute__ (( always_inline )) void
+bigint_add_raw ( const uint64_t *addend0, uint64_t *value0,
+		 unsigned int size ) {
+	bigint_t ( size ) __attribute__ (( may_alias )) *value =
+		( ( void * ) value0 );
+	uint64_t *discard_addend;
+	uint64_t *discard_value;
+	uint64_t discard_addend_i;
+	uint64_t discard_value_i;
+	unsigned int discard_size;
+	__asm__ __volatile__ ( "move   $t0, $zero\n"
+			       "1:\n\t"
+			       "ld.d   %3, %0, 0\n\t"
+			       "addi.d %0, %0, 8\n\t"
+			       "ld.d   %4, %1, 0\n\t"
+
+			       "add.d  %4, %4, $t0\n\t"
+			       "sltu   $t0, %4, $t0\n\t"
+
+			       "add.d  %4, %4, %3\n\t"
+			       "sltu   $t1, %4, %3\n\t"
+
+			       "or     $t0, $t0, $t1\n\t"
+			       "st.d   %4,  %1, 0\n\t"
+			       "addi.d %1, %1, 8\n\t"
+			       "addi.w %2, %2, -1\n\t"
+			       "bnez   %2, 1b"
+			       : "=r" ( discard_addend ),
+				 "=r" ( discard_value ),
+				 "=r" ( discard_size ),
+				 "=r" ( discard_addend_i ),
+				 "=r" ( discard_value_i ),
+				 "+m" ( *value )
+			       : "0" ( addend0 ),
+				 "1" ( value0 ),
+				 "2" ( size )
+			       : "t0", "t1" );
+}
+
+/**
+ * Subtract big integers
+ *
+ * @v subtrahend0	Element 0 of big integer to subtract
+ * @v value0		Element 0 of big integer to be subtracted from
+ * @v size		Number of elements
+ */
+static inline __attribute__ (( always_inline )) void
+bigint_subtract_raw ( const uint64_t *subtrahend0, uint64_t *value0,
+		      unsigned int size ) {
+	uint64_t *discard_subtrahend;
+	uint64_t *discard_value;
+	uint64_t discard_subtrahend_i;
+	uint64_t discard_value_i;
+	unsigned int discard_size;
+	unsigned int flag = 0;
+
+	discard_subtrahend = (uint64_t*) subtrahend0;
+	discard_value = value0;
+	discard_size = size;
+
+	do {
+		discard_subtrahend_i = *discard_subtrahend;
+		discard_subtrahend++;
+		discard_value_i = *discard_value;
+
+		discard_value_i = discard_value_i - discard_subtrahend_i - flag;
+
+		if ( *discard_value < (discard_subtrahend_i + flag)) {
+			flag = 1;
+		} else {
+			flag = 0;
+		}
+
+		*discard_value = discard_value_i;
+
+		discard_value++;
+		discard_size -= 1;
+	} while (discard_size != 0);
+}
+
+/**
+ * Rotate big integer left
+ *
+ * @v value0		Element 0 of big integer
+ * @v size		Number of elements
+ */
+static inline __attribute__ (( always_inline )) void
+bigint_rol_raw ( uint64_t *value0, unsigned int size ) {
+	uint64_t *discard_value;
+	uint64_t discard_value_i;
+	unsigned int discard_size;
+	uint64_t current_value_i;
+	unsigned int flag = 0;
+
+	discard_value = value0;
+	discard_size = size;
+	do {
+		discard_value_i = *discard_value;
+		current_value_i = discard_value_i;
+
+		discard_value_i += discard_value_i + flag;
+
+		if (discard_value_i < current_value_i) {
+			flag = 1;
+		} else {
+			flag = 0;
+		}
+
+		*discard_value = discard_value_i;
+		discard_value++;
+		discard_size -= 1;
+	} while ( discard_size != 0 );
+}
+
+/**
+ * Rotate big integer right
+ *
+ * @v value0		Element 0 of big integer
+ * @v size		Number of elements
+ */
+static inline __attribute__ (( always_inline )) void
+bigint_ror_raw ( uint64_t *value0, unsigned int size ) {
+	uint64_t *discard_value;
+	uint64_t discard_value_i;
+	uint64_t discard_value_j;
+	unsigned int discard_size;
+
+	discard_value = value0;
+	discard_size = size;
+
+	discard_value_j = 0;
+
+	do {
+		discard_size -= 1;
+
+		discard_value_i = *(discard_value + discard_size);
+
+		discard_value_j = (discard_value_j << 63) | (discard_value_i >> 1);
+
+		*(discard_value + discard_size) = discard_value_j;
+
+		discard_value_j = discard_value_i;
+	} while ( discard_size > 0 );
+}
+
+/**
+ * Test if big integer is equal to zero
+ *
+ * @v value0		Element 0 of big integer
+ * @v size		Number of elements
+ * @ret is_zero		Big integer is equal to zero
+ */
+static inline __attribute__ (( always_inline, pure )) int
+bigint_is_zero_raw ( const uint64_t *value0, unsigned int size ) {
+	const uint64_t *value = value0;
+	uint64_t value_i;
+
+	do {
+		value_i = *(value++);
+		if ( value_i )
+			break;
+	} while ( --size );
+
+	return ( value_i == 0 );
+}
+
+/**
+ * Compare big integers
+ *
+ * @v value0		Element 0 of big integer
+ * @v reference0	Element 0 of reference big integer
+ * @v size		Number of elements
+ * @ret geq		Big integer is greater than or equal to the reference
+ */
+static inline __attribute__ (( always_inline, pure )) int
+bigint_is_geq_raw ( const uint64_t *value0, const uint64_t *reference0,
+		    unsigned int size ) {
+	const uint64_t *value = ( value0 + size );
+	const uint64_t *reference = ( reference0 + size );
+	uint64_t value_i;
+	uint64_t reference_i;
+
+	do {
+		value_i = *(--value);
+		reference_i = *(--reference);
+		if ( value_i != reference_i )
+			break;
+	} while ( --size );
+
+	return ( value_i >= reference_i );
+}
+
+/**
+ * Test if bit is set in big integer
+ *
+ * @v value0		Element 0 of big integer
+ * @v size		Number of elements
+ * @v bit		Bit to test
+ * @ret is_set		Bit is set
+ */
+static inline __attribute__ (( always_inline )) int
+bigint_bit_is_set_raw ( const uint64_t *value0, unsigned int size,
+			unsigned int bit ) {
+	const bigint_t ( size ) __attribute__ (( may_alias )) *value =
+		( ( const void * ) value0 );
+	unsigned int index = ( bit / ( 8 * sizeof ( value->element[0] ) ) );
+	unsigned int subindex = ( bit % ( 8 * sizeof ( value->element[0] ) ) );
+
+	return ( !! ( value->element[index] & ( 1UL << subindex ) ) );
+}
+
+/**
+ * Find highest bit set in big integer
+ *
+ * @v value0		Element 0 of big integer
+ * @v size		Number of elements
+ * @ret max_bit		Highest bit set + 1 (or 0 if no bits set)
+ */
+static inline __attribute__ (( always_inline )) int
+bigint_max_set_bit_raw ( const uint64_t *value0, unsigned int size ) {
+	const uint64_t *value = ( value0 + size );
+	int max_bit = ( 8 * sizeof ( bigint_t ( size ) ) );
+	uint64_t value_i;
+
+	do {
+		value_i = *(--value);
+		max_bit -= ( 64 - fls ( value_i ) );
+		if ( value_i )
+			break;
+	} while ( --size );
+
+	return max_bit;
+}
+
+/**
+ * Grow big integer
+ *
+ * @v source0		Element 0 of source big integer
+ * @v source_size	Number of elements in source big integer
+ * @v dest0		Element 0 of destination big integer
+ * @v dest_size		Number of elements in destination big integer
+ */
+static inline __attribute__ (( always_inline )) void
+bigint_grow_raw ( const uint64_t *source0, unsigned int source_size,
+		  uint64_t *dest0, unsigned int dest_size ) {
+	unsigned int pad_size = ( dest_size - source_size );
+
+	memcpy ( dest0, source0, sizeof ( bigint_t ( source_size ) ) );
+	memset ( ( dest0 + source_size ), 0, sizeof ( bigint_t ( pad_size ) ) );
+}
+
+/**
+ * Shrink big integer
+ *
+ * @v source0		Element 0 of source big integer
+ * @v source_size	Number of elements in source big integer
+ * @v dest0		Element 0 of destination big integer
+ * @v dest_size		Number of elements in destination big integer
+ */
+static inline __attribute__ (( always_inline )) void
+bigint_shrink_raw ( const uint64_t *source0, unsigned int source_size __unused,
+		    uint64_t *dest0, unsigned int dest_size ) {
+
+	memcpy ( dest0, source0, sizeof ( bigint_t ( dest_size ) ) );
+}
+
+/**
+ * Finalise big integer
+ *
+ * @v value0		Element 0 of big integer to finalise
+ * @v size		Number of elements
+ * @v out		Output buffer
+ * @v len		Length of output buffer
+ */
+static inline __attribute__ (( always_inline )) void
+bigint_done_raw ( const uint64_t *value0, unsigned int size __unused,
+		  void *out, size_t len ) {
+	const uint8_t *value_byte = ( ( const void * ) value0 );
+	uint8_t *out_byte = ( out + len );
+
+	/* Copy raw data in reverse order */
+	while ( len-- )
+		*(--out_byte) = *(value_byte++);
+}
+
+extern void bigint_multiply_raw ( const uint64_t *multiplicand0,
+				  const uint64_t *multiplier0,
+				  uint64_t *value0, unsigned int size );
+
+#endif /* _BITS_BIGINT_H */

src/arch/loong64/include/bits/bitops.h

@@ -0,0 +1,102 @@
+#ifndef _BITS_BITOPS_H
+#define _BITS_BITOPS_H
+
+/** @file
+ *
+ * loongArch bit operations
+ *
+ * We perform atomic bit set and bit clear operations using "ll"
+ * and "sc".  We use the output constraint to inform the
+ * compiler that any memory from the start of the bit field up to and
+ * including the byte containing the bit may be modified.  (This is
+ * overkill but shouldn't matter in practice since we're unlikely to
+ * subsequently read other bits from the same bit field.)
+ */
+
+FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
+
+#include <stdint.h>
+
+/**
+ * Test and set bit atomically
+ *
+ * @v bit		Bit to set
+ * @v bits		Bit field
+ * @ret old		Old value of bit (zero or non-zero)
+ */
+static inline __attribute__ (( always_inline )) int
+test_and_set_bit ( unsigned int bit, volatile void *bits ) {
+	unsigned int index = ( bit / 64 );
+	unsigned int offset = ( bit % 64 );
+	volatile uint64_t *qword = ( ( ( volatile uint64_t * ) bits ) + index );
+	uint64_t mask = ( 1UL << offset );
+	uint64_t old;
+	uint64_t new;
+
+	__asm__ __volatile__ ( "1:				\n\t"
+			       "ll.d %[old], %[qword]		\n\t"
+			       "or   %[new], %[old], %[mask]	\n\t"
+			       "sc.d %[new], %[qword]		\n\t"
+			       "beqz %[new], 1b			\n\t"
+			       : [old] "=&r" ( old ),
+				 [new] "=&r" ( new ),
+				 [qword] "+m" ( *qword )
+			       : [mask] "r" ( mask )
+			       : "cc", "memory");
+	return ( !! ( old & mask ) );
+}
+
+/**
+ * Test and clear bit atomically
+ *
+ * @v bit		Bit to set
+ * @v bits		Bit field
+ * @ret old		Old value of bit (zero or non-zero)
+ */
+static inline __attribute__ (( always_inline )) int
+test_and_clear_bit ( unsigned int bit, volatile void *bits ) {
+	unsigned int index = ( bit / 64 );
+	unsigned int offset = ( bit % 64 );
+	volatile uint64_t *qword = ( ( ( volatile uint64_t * ) bits ) + index );
+	uint64_t mask = ( 1UL << offset );
+	uint64_t old;
+	uint64_t new;
+
+	__asm__ __volatile__ ( "1:				\n\t"
+			       "ll.d %[old], %[qword]		\n\t"
+			       "andn %[new], %[old], %[mask]	\n\t"
+			       "sc.d %[new], %[qword]		\n\t"
+			       "beqz %[new], 1b			\n\t"
+			       : [old] "=&r" ( old ),
+				 [new] "=&r" ( new ),
+				 [qword] "+m" ( *qword )
+			       : [mask] "r" ( mask )
+			       : "cc", "memory");
+	return ( !! ( old & mask ) );
+}
+
+/**
+ * Set bit atomically
+ *
+ * @v bit		Bit to set
+ * @v bits		Bit field
+ */
+static inline __attribute__ (( always_inline )) void
+set_bit ( unsigned int bit, volatile void *bits ) {
+
+	test_and_set_bit ( bit, bits );
+}
+
+/**
+ * Clear bit atomically
+ *
+ * @v bit		Bit to set
+ * @v bits		Bit field
+ */
+static inline __attribute__ (( always_inline )) void
+clear_bit ( unsigned int bit, volatile void *bits ) {
+
+	test_and_clear_bit ( bit, bits );
+}
+
+#endif /* _BITS_BITOPS_H */

src/arch/loong64/include/bits/byteswap.h

@@ -0,0 +1,47 @@
+#ifndef _BITS_BYTESWAP_H
+#define _BITS_BYTESWAP_H
+
+/** @file
+ *
+ * Byte-order swapping functions
+ *
+ */
+
+#include <stdint.h>
+
+FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
+
+static inline __attribute__ (( always_inline, const )) uint16_t
+__bswap_variable_16 ( uint16_t x ) {
+	__asm__ ( "revb.2h %0, %1" : "=r" ( x ) : "r" ( x ) );
+	return x;
+}
+
+static inline __attribute__ (( always_inline )) void
+__bswap_16s ( uint16_t *x ) {
+	*x = __bswap_variable_16 ( *x );
+}
+
+static inline __attribute__ (( always_inline, const )) uint32_t
+__bswap_variable_32 ( uint32_t x ) {
+	__asm__ ( "revb.2w %0, %1" : "=r" ( x ) : "r" ( x ) );
+	return x;
+}
+
+static inline __attribute__ (( always_inline )) void
+__bswap_32s ( uint32_t *x ) {
+	*x = __bswap_variable_32 ( *x );
+}
+
+static inline __attribute__ (( always_inline, const )) uint64_t
+__bswap_variable_64 ( uint64_t x ) {
+	__asm__ ( "revb.d %0, %1" : "=r" ( x ) : "r" ( x ) );
+	return x;
+}
+
+static inline __attribute__ (( always_inline )) void
+__bswap_64s ( uint64_t *x ) {
+	*x = __bswap_variable_64 ( *x );
+}
+
+#endif

src/arch/loong64/include/bits/compiler.h

@@ -0,0 +1,19 @@
+#ifndef _BITS_COMPILER_H
+#define _BITS_COMPILER_H
+
+FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
+
+/** Dummy relocation type */
+#define RELOC_TYPE_NONE R_LARCH_NONE
+
+#ifndef ASSEMBLY
+
+/** Unprefixed constant operand modifier */
+#define ASM_NO_PREFIX "a"
+
+#define __asmcall
+#define __libgcc
+
+#endif /* ASSEMBLY */
+
+#endif /*_BITS_COMPILER_H */

src/arch/loong64/include/bits/endian.h

@@ -0,0 +1,8 @@
+#ifndef _BITS_ENDIAN_H
+#define _BITS_ENDIAN_H
+
+FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
+
+#define __BYTE_ORDER __LITTLE_ENDIAN
+
+#endif /* _BITS_ENDIAN_H */

src/arch/loong64/include/bits/entropy.h

@@ -0,0 +1,12 @@
+#ifndef _BITS_ENTROPY_H
+#define _BITS_ENTROPY_H
+
+/** @file
+ *
+ * LoongArch64-specific entropy API implementations
+ *
+ */
+
+FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
+
+#endif /* _BITS_ENTROPY_H */

src/arch/loong64/include/bits/errfile.h

@@ -0,0 +1,19 @@
+#ifndef _BITS_ERRFILE_H
+#define _BITS_ERRFILE_H
+
+/** @file
+ *
+ * LoongArch64-specific error file identifiers
+ *
+ */
+
+FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
+
+/**
+ * @addtogroup errfile Error file identifiers
+ * @{
+ */
+
+/** @} */
+
+#endif /* _BITS_ERRFILE_H */

src/arch/loong64/include/bits/hyperv.h

@@ -0,0 +1,12 @@
+#ifndef _BITS_HYPERV_H
+#define _BITS_HYPERV_H
+
+/** @file
+ *
+ * Hyper-V interface
+ *
+ */
+
+FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
+
+#endif /* _BITS_HYPERV_H */

src/arch/loong64/include/bits/io.h

@@ -0,0 +1,15 @@
+#ifndef _BITS_IO_H
+#define _BITS_IO_H
+
+/** @file
+ *
+ * LoongArch64-specific I/O API implementations
+ *
+ */
+
+FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
+
+/** Page shift */
+#define PAGE_SHIFT 12
+
+#endif /* _BITS_IO_H */

src/arch/loong64/include/bits/iomap.h

@@ -0,0 +1,12 @@
+#ifndef _BITS_IOMAP_H
+#define _BITS_IOMAP_H
+
+/** @file
+ *
+ * LoongArch64-specific I/O mapping API implementations
+ *
+ */
+
+FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
+
+#endif /* _BITS_IOMAP_H */

src/arch/loong64/include/bits/nap.h

@@ -0,0 +1,12 @@
+#ifndef _BITS_NAP_H
+#define _BITS_NAP_H
+
+/** @file
+ *
+ * LoongArch64-specific CPU sleeping API implementations
+ *
+ */
+
+FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
+
+#endif /* _BITS_MAP_H */

src/arch/loong64/include/bits/pci_io.h

@@ -0,0 +1,12 @@
+#ifndef _BITS_PCI_IO_H
+#define _BITS_PCI_IO_H
+
+/** @file
+ *
+ * LoongArch64-specific PCI I/O API implementations
+ *
+ */
+
+FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
+
+#endif /* _BITS_PCI_IO_H */

src/arch/loong64/include/bits/profile.h

@@ -0,0 +1,28 @@
+#ifndef _BITS_PROFILE_H
+#define _BITS_PROFILE_H
+
+/** @file
+ *
+ * Profiling
+ *
+ */
+
+FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
+
+#include <stdint.h>
+
+/**
+ * Get profiling timestamp
+ *
+ * @ret timestamp	Timestamp
+ */
+static inline __attribute__ (( always_inline )) uint64_t
+profile_timestamp ( void ) {
+	uint64_t cycles;
+
+	/* Read cycle counter */
+	__asm__ __volatile__ ( "rdtime.d %0, $zero\n\t" : "=r" ( cycles ) );
+	return cycles;
+}
+
+#endif /* _BITS_PROFILE_H */

src/arch/loong64/include/bits/reboot.h

@@ -0,0 +1,12 @@
+#ifndef _BITS_REBOOT_H
+#define _BITS_REBOOT_H
+
+/** @file
+ *
+ * LoongArch64-specific reboot API implementations
+ *
+ */
+
+FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
+
+#endif /* _BITS_REBOOT_H */

src/arch/loong64/include/bits/sanboot.h

@@ -0,0 +1,12 @@
+#ifndef _BITS_SANBOOT_H
+#define _BITS_SANBOOT_H
+
+/** @file
+ *
+ * LoongArch64-specific sanboot API implementations
+ *
+ */
+
+FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
+
+#endif /* _BITS_SANBOOT_H */

src/arch/loong64/include/bits/smbios.h

@@ -0,0 +1,12 @@
+#ifndef _BITS_SMBIOS_H
+#define _BITS_SMBIOS_H
+
+/** @file
+ *
+ * LoongArch64-specific SMBIOS API implementations
+ *
+ */
+
+FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
+
+#endif /* _BITS_SMBIOS_H */

src/arch/loong64/include/bits/stdint.h

@@ -0,0 +1,23 @@
+#ifndef _BITS_STDINT_H
+#define _BITS_STDINT_H
+
+FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
+
+typedef __SIZE_TYPE__		size_t;
+typedef signed long		ssize_t;
+typedef signed long		off_t;
+
+typedef unsigned char		uint8_t;
+typedef unsigned short		uint16_t;
+typedef unsigned int		uint32_t;
+typedef unsigned long long	uint64_t;
+
+typedef signed char		int8_t;
+typedef signed short		int16_t;
+typedef signed int		int32_t;
+typedef signed long long	int64_t;
+
+typedef unsigned long		physaddr_t;
+typedef unsigned long		intptr_t;
+
+#endif /* _BITS_STDINT_H */

src/arch/loong64/include/bits/string.h

@@ -0,0 +1,61 @@
+#ifndef _BITS_STRING_H
+#define _BITS_STRING_H
+
+FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
+
+/** @file
+ *
+ * String functions
+ *
+ */
+
+extern void loong64_bzero ( void *dest, size_t len );
+extern void loong64_memset ( void *dest, size_t len, int character );
+extern void loong64_memcpy ( void *dest, const void *src, size_t len );
+extern void loong64_memmove_forwards ( void *dest, const void *src, size_t len );
+extern void loong64_memmove_backwards ( void *dest, const void *src, size_t len );
+extern void loong64_memmove ( void *dest, const void *src, size_t len );
+
+/**
+ * Fill memory region
+ *
+ * @v dest		Destination region
+ * @v character		Fill character
+ * @v len		Length
+ * @ret dest		Destination region
+ */
+static inline __attribute__ (( always_inline )) void *
+memset ( void *dest, int character, size_t len ) {
+	loong64_memset ( dest, len, character );
+	return dest;
+}
+
+/**
+ * Copy memory region
+ *
+ * @v dest		Destination region
+ * @v src		Source region
+ * @v len		Length
+ * @ret dest		Destination region
+ */
+static inline __attribute__ (( always_inline )) void *
+memcpy ( void *dest, const void *src, size_t len ) {
+	loong64_memcpy ( dest, src, len );
+	return dest;
+}
+
+/**
+ * Copy (possibly overlapping) memory region
+ *
+ * @v dest		Destination region
+ * @v src		Source region
+ * @v len		Length
+ * @ret dest		Destination region
+ */
+static inline __attribute__ (( always_inline )) void *
+memmove ( void *dest, const void *src, size_t len ) {
+	loong64_memmove ( dest, src, len );
+	return dest;
+}
+
+#endif /* _BITS_STRING_H */

src/arch/loong64/include/bits/strings.h

@@ -0,0 +1,69 @@
+#ifndef _BITS_STRINGS_H
+#define _BITS_STRINGS_H
+
+/** @file
+ *
+ * String functions
+ *
+ */
+
+FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
+
+/**
+ * Find first (i.e. least significant) set bit
+ *
+ * @v value		Value
+ * @ret lsb		Least significant bit set in value (LSB=1), or zero
+ */
+static inline __attribute__ (( always_inline )) int __ffsll ( long long value ){
+	unsigned long long bits = value;
+	unsigned long long lsb;
+	unsigned int lz;
+
+	/* Extract least significant set bit */
+	lsb = ( bits & -bits );
+
+	/* Count number of leading zeroes before LSB */
+	__asm__ ( "clz.d %0, %1" : "=r" ( lz ) : "r" ( lsb ) );
+
+	return ( 64 - lz );
+}
+
+/**
+ * Find first (i.e. least significant) set bit
+ *
+ * @v value		Value
+ * @ret lsb		Least significant bit set in value (LSB=1), or zero
+ */
+static inline __attribute__ (( always_inline )) int __ffsl ( long value ) {
+
+	return __ffsll ( value );
+}
+
+/**
+ * Find last (i.e. most significant) set bit
+ *
+ * @v value		Value
+ * @ret msb		Most significant bit set in value (LSB=1), or zero
+ */
+static inline __attribute__ (( always_inline )) int __flsll ( long long value ){
+	unsigned int lz;
+
+	/* Count number of leading zeroes */
+	__asm__ ( "clz.d %0, %1" : "=r" ( lz ) : "r" ( value ) );
+
+	return ( 64 - lz );
+}
+
+/**
+ * Find last (i.e. most significant) set bit
+ *
+ * @v value		Value
+ * @ret msb		Most significant bit set in value (LSB=1), or zero
+ */
+static inline __attribute__ (( always_inline )) int __flsl ( long value ) {
+
+	return __flsll ( value );
+}
+
+#endif /* _BITS_STRINGS_H */

src/arch/loong64/include/bits/tcpip.h

@@ -0,0 +1,19 @@
+#ifndef _BITS_TCPIP_H
+#define _BITS_TCPIP_H
+
+/** @file
+ *
+ * Transport-network layer interface
+ *
+ */
+
+FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
+
+static inline __attribute__ (( always_inline )) uint16_t
+tcpip_continue_chksum ( uint16_t partial, const void *data, size_t len ) {
+
+	/* Not yet optimised */
+	return generic_tcpip_continue_chksum ( partial, data, len );
+}
+
+#endif /* _BITS_TCPIP_H */

src/arch/loong64/include/bits/time.h

@@ -0,0 +1,12 @@
+#ifndef _BITS_TIME_H
+#define _BITS_TIME_H
+
+/** @file
+ *
+ * LoongArch64-specific time API implementations
+ *
+ */
+
+FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
+
+#endif /* _BITS_TIME_H */

src/arch/loong64/include/bits/uaccess.h

@@ -0,0 +1,12 @@
+#ifndef _BITS_UACCESS_H
+#define _BITS_UACCESS_H
+
+/** @file
+ *
+ * LoongArch64-specific user access API implementations
+ *
+ */
+
+FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
+
+#endif /* _BITS_UACCESS_H */

src/arch/loong64/include/bits/uart.h

@@ -0,0 +1,12 @@
+#ifndef _BITS_UART_H
+#define _BITS_UART_H
+
+/** @file
+ *
+ * 16550-compatible UART
+ *
+ */
+
+FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
+
+#endif /* _BITS_UART_H */

src/arch/loong64/include/bits/umalloc.h

@@ -0,0 +1,12 @@
+#ifndef _BITS_UMALLOC_H
+#define _BITS_UMALLOC_H
+
+/** @file
+ *
+ * LoongArch64-specific user memory allocation API implementations
+ *
+ */
+
+FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
+
+#endif /* _BITS_UMALLOC_H */

src/arch/loong64/include/bits/xen.h

@@ -0,0 +1,13 @@
+#ifndef _BITS_XEN_H
+#define _BITS_XEN_H
+
+/** @file
+ *
+ * Xen interface
+ *
+ */
+FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
+
+#include <ipxe/nonxen.h>
+
+#endif /* _BITS_XEN_H */

src/arch/loong64/include/gdbmach.h

@@ -0,0 +1,45 @@
+#ifndef GDBMACH_H
+#define GDBMACH_H
+
+/** @file
+ *
+ * GDB architecture specifics
+ *
+ * This file declares functions for manipulating the machine state and
+ * debugging context.
+ *
+ */
+
+#include <stdint.h>
+
+typedef unsigned long gdbreg_t;
+
+/* Register snapshot */
+enum {
+	/* Not yet implemented */
+	GDBMACH_NREGS,
+};
+
+#define GDBMACH_SIZEOF_REGS ( GDBMACH_NREGS * sizeof ( gdbreg_t ) )
+
+static inline void gdbmach_set_pc ( gdbreg_t *regs, gdbreg_t pc ) {
+	/* Not yet implemented */
+	( void ) regs;
+	( void ) pc;
+}
+
+static inline void gdbmach_set_single_step ( gdbreg_t *regs, int step ) {
+	/* Not yet implemented */
+	( void ) regs;
+	( void ) step;
+}
+
+static inline void gdbmach_breakpoint ( void ) {
+	/* Not yet implemented */
+}
+
+extern int gdbmach_set_breakpoint ( int type, unsigned long addr, size_t len,
+				    int enable );
+extern void gdbmach_init ( void );
+
+#endif /* GDBMACH_H */

src/arch/loong64/include/ipxe/efi/dhcparch.h

@@ -0,0 +1,20 @@
+#ifndef _IPXE_EFI_DHCPARCH_H
+#define _IPXE_EFI_DHCPARCH_H
+
+/** @file
+ *
+ * DHCP client architecture definitions
+ *
+ */
+
+FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
+
+#include <ipxe/dhcp.h>
+
+/** DHCP client architecture */
+#define DHCP_ARCH_CLIENT_ARCHITECTURE DHCP_CLIENT_ARCHITECTURE_LOONG64
+
+/** DHCP client network device interface */
+#define DHCP_ARCH_CLIENT_NDI 1 /* UNDI */ , 3, 10 /* v3.10 */
+
+#endif /* _IPXE_EFI_DHCPARCH_H */

src/arch/loong64/include/limits.h

@@ -0,0 +1,53 @@
+#ifndef LIMITS_H
+#define LIMITS_H	1
+
+/* Number of bits in a `char' */
+#define CHAR_BIT	8
+
+/* Minimum and maximum values a `signed char' can hold */
+#define SCHAR_MIN	(-128)
+#define SCHAR_MAX	127
+
+/* Maximum value an `unsigned char' can hold. (Minimum is 0.) */
+#define UCHAR_MAX	255
+
+/* Minimum and maximum values a `char' can hold */
+#define CHAR_MIN	SCHAR_MIN
+#define CHAR_MAX	SCHAR_MAX
+
+/* Minimum and maximum values a `signed short int' can hold */
+#define SHRT_MIN	(-32768)
+#define SHRT_MAX	32767
+
+/* Maximum value an `unsigned short' can hold. (Minimum is 0.) */
+#define USHRT_MAX	65535
+
+/* Minimum and maximum values a `signed int' can hold */
+#define INT_MIN		(-INT_MAX - 1)
+#define INT_MAX		2147483647
+
+/* Maximum value an `unsigned int' can hold. (Minimum is 0.) */
+#define UINT_MAX	4294967295U
+
+/* Minimum and maximum values a `signed int' can hold */
+#define INT_MAX		2147483647
+#define INT_MIN		(-INT_MAX - 1)
+
+/* Maximum value an `unsigned int' can hold. (Minimum is 0.) */
+#define UINT_MAX	4294967295U
+
+/* Minimum and maximum values a `signed long' can hold */
+#define LONG_MAX	9223372036854775807L
+#define LONG_MIN	(-LONG_MAX - 1L)
+
+/* Maximum value an `unsigned long' can hold. (Minimum is 0.) */
+#define ULONG_MAX	18446744073709551615UL
+
+/* Minimum and maximum values a `signed long long' can hold */
+#define LLONG_MAX	9223372036854775807LL
+#define LLONG_MIN	(-LONG_MAX - 1LL)
+
+/* Maximum value an `unsigned long long' can hold. (Minimum is 0.) */
+#define ULLONG_MAX	18446744073709551615ULL
+
+#endif /* LIMITS_H */

src/arch/loong64/include/setjmp.h

@@ -0,0 +1,31 @@
+#ifndef _SETJMP_H
+#define _SETJMP_H
+
+FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
+
+#include <stdint.h>
+
+/** jump buffer env*/
+typedef struct {
+	uint64_t s0;
+	uint64_t s1;
+	uint64_t s2;
+	uint64_t s3;
+	uint64_t s4;
+	uint64_t s5;
+	uint64_t s6;
+	uint64_t s7;
+	uint64_t s8;
+
+	uint64_t fp;
+	uint64_t sp;
+	uint64_t ra;
+} jmp_buf[1];
+
+extern int __asmcall __attribute__ (( returns_twice ))
+setjmp ( jmp_buf env );
+
+extern void __asmcall __attribute__ (( noreturn ))
+longjmp ( jmp_buf env, int val );
+
+#endif /* _SETJMP_H */

src/arch/x86/Makefile

@@ -22,9 +22,6 @@ SRCDIRS		+= arch/x86/drivers/xen
 SRCDIRS		+= arch/x86/drivers/hyperv
 SRCDIRS		+= arch/x86/transitions
 
-# breaks building some of the linux-related objects
-CFLAGS		+= -Ulinux
-
 # disable valgrind
 CFLAGS		+= -DNVALGRIND
 

src/arch/x86/Makefile.linux

@@ -1,13 +1,6 @@
-MEDIA = linux
+# -*- makefile -*- : Force emacs to use Makefile mode
 
-# enable valgrind
-CFLAGS += -UNVALGRIND
-
-INCDIRS += arch/x86/include/linux
-SRCDIRS += interface/linux
-SRCDIRS += drivers/linux
-SRCDIRS += arch/x86/core/linux
-
-$(BIN)/%.linux : $(BIN)/%.linux.tmp
-	$(QM)$(ECHO) "  [FINISH] $@"
-	$(Q)$(CP) $< $@
+# Include generic Linux Makefile
+#
+MAKEDEPS	+= Makefile.linux
+include Makefile.linux

src/arch/x86/Makefile.pcbios

@@ -4,18 +4,15 @@
 #
 SRCDIRS		+= arch/x86/drivers/net
 
-# The i386 linker script
+# The linker scripts
 #
 LDSCRIPT	= arch/x86/scripts/pcbios.lds
+LDSCRIPT_PREFIX	= arch/x86/scripts/prefixonly.lds
 
 # Stop ld from complaining about our customised linker script
 #
 LDFLAGS		+= -N --no-check-sections
 
-# Prefix always starts at address zero
-#
-LDFLAGS		+= --section-start=.prefix=0
-
 # Media types.
 #
 MEDIA		+= rom
@@ -57,46 +54,11 @@ LIST_NAME_mrom := ROMS
 LIST_NAME_pcirom := ROMS
 LIST_NAME_isarom := ROMS
 
-# Locations of isolinux files
-#
-SYSLINUX_DIR_LIST	:= \
-	/usr/lib/syslinux \
-	/usr/lib/syslinux/bios \
-	/usr/lib/syslinux/modules/bios \
-	/usr/share/syslinux \
-	/usr/share/syslinux/bios \
-	/usr/share/syslinux/modules/bios \
-	/usr/local/share/syslinux \
-	/usr/local/share/syslinux/bios \
-	/usr/local/share/syslinux/modules/bios \
-	/usr/lib/ISOLINUX
-ISOLINUX_BIN_LIST	:= \
-	$(ISOLINUX_BIN) \
-	$(patsubst %,%/isolinux.bin,$(SYSLINUX_DIR_LIST))
-LDLINUX_C32_LIST	:= \
-	$(LDLINUX_C32) \
-	$(patsubst %,%/ldlinux.c32,$(SYSLINUX_DIR_LIST))
-ISOLINUX_BIN	= $(firstword $(wildcard $(ISOLINUX_BIN_LIST)))
-LDLINUX_C32	= $(firstword $(wildcard $(LDLINUX_C32_LIST)))
-
-# rule to make a non-emulation ISO boot image
+# ISO or FAT filesystem images
 NON_AUTO_MEDIA	+= iso
-%iso:	%lkrn util/geniso
-	$(QM)$(ECHO) "  [GENISO] $@"
-	$(Q)ISOLINUX_BIN=$(ISOLINUX_BIN) LDLINUX_C32=$(LDLINUX_C32) \
-	    VERSION="$(VERSION)" bash util/geniso -o $@ $<
-
-# rule to make a floppy emulation ISO boot image
-NON_AUTO_MEDIA	+= liso
-%liso:	%lkrn util/geniso
-	$(QM)$(ECHO) "  [GENISO] $@"
-	$(Q)VERSION="$(VERSION)" bash util/geniso -l -o $@ $<
-
-# rule to make a syslinux floppy image (mountable, bootable)
-NON_AUTO_MEDIA	+= sdsk
-%sdsk:	%lkrn util/gensdsk
-	$(QM)$(ECHO) "  [GENSDSK] $@"
-	$(Q)bash util/gensdsk $@ $<
+$(BIN)/%.iso $(BIN)/%.sdsk: $(BIN)/%.lkrn util/genfsimg
+	$(QM)$(ECHO) "  [GENFSIMG] $@"
+	$(Q)util/genfsimg -o $@ $<
 
 # rule to write disk images to /dev/fd0
 NON_AUTO_MEDIA	+= fd0
@@ -108,12 +70,12 @@ NON_AUTO_MEDIA	+= fd0
 # Special target for building Master Boot Record binary
 $(BIN)/mbr.tmp : $(BIN)/mbr.o
 	$(QM)$(ECHO) "  [LD] $@"
-	$(Q)$(LD) $(LDFLAGS) -o $@ -e mbr $<
+	$(Q)$(LD) $(LDFLAGS) -T $(LDSCRIPT_PREFIX) -o $@ -e mbr $<
 
 # rule to make a USB disk image
 $(BIN)/usbdisk.tmp : $(BIN)/usbdisk.o
 	$(QM)$(ECHO) "  [LD] $@"
-	$(Q)$(LD) $(LDFLAGS) -o $@ -e mbr $<
+	$(Q)$(LD) $(LDFLAGS) -T $(LDSCRIPT_PREFIX) -o $@ -e mbr $<
 
 NON_AUTO_MEDIA	+= usb
 %usb: $(BIN)/usbdisk.bin %hd

src/arch/x86/core/cachedhcp.c

@@ -1,179 +0,0 @@
-/*
- * Copyright (C) 2013 Michael Brown <mbrown@fensystems.co.uk>.
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301, USA.
- *
- * You can also choose to distribute this program under the terms of
- * the Unmodified Binary Distribution Licence (as given in the file
- * COPYING.UBDL), provided that you have satisfied its requirements.
- */
-
-FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
-
-#include <stdint.h>
-#include <stdlib.h>
-#include <ipxe/dhcppkt.h>
-#include <ipxe/init.h>
-#include <ipxe/netdevice.h>
-#include <realmode.h>
-#include <pxe_api.h>
-
-/** @file
- *
- * Cached DHCP packet
- *
- */
-
-/** Cached DHCPACK physical address
- *
- * This can be set by the prefix.
- */
-uint32_t __bss16 ( cached_dhcpack_phys );
-#define cached_dhcpack_phys __use_data16 ( cached_dhcpack_phys )
-
-/** Colour for debug messages */
-#define colour &cached_dhcpack_phys
-
-/** Cached DHCPACK */
-static struct dhcp_packet *cached_dhcpack;
-
-/**
- * Cached DHCPACK startup function
- *
- */
-static void cachedhcp_init ( void ) {
-	struct dhcp_packet *dhcppkt;
-	struct dhcp_packet *tmp;
-	struct dhcphdr *dhcphdr;
-	size_t max_len;
-	size_t len;
-
-	/* Do nothing if no cached DHCPACK is present */
-	if ( ! cached_dhcpack_phys ) {
-		DBGC ( colour, "CACHEDHCP found no cached DHCPACK\n" );
-		return;
-	}
-
-	/* No reliable way to determine length before parsing packet;
-	 * start by assuming maximum length permitted by PXE.
-	 */
-	max_len = sizeof ( BOOTPLAYER_t );
-
-	/* Allocate and populate DHCP packet */
-	dhcppkt = zalloc ( sizeof ( *dhcppkt ) + max_len );
-	if ( ! dhcppkt ) {
-		DBGC ( colour, "CACHEDHCP could not allocate copy\n" );
-		return;
-	}
-	dhcphdr = ( ( ( void * ) dhcppkt ) + sizeof ( *dhcppkt ) );
-	copy_from_user ( dhcphdr, phys_to_user ( cached_dhcpack_phys ), 0,
-			 max_len );
-	dhcppkt_init ( dhcppkt, dhcphdr, max_len );
-
-	/* Shrink packet to required length.  If reallocation fails,
-	 * just continue to use the original packet and waste the
-	 * unused space.
-	 */
-	len = dhcppkt_len ( dhcppkt );
-	assert ( len <= max_len );
-	tmp = realloc ( dhcppkt, ( sizeof ( *dhcppkt ) + len ) );
-	if ( tmp )
-		dhcppkt = tmp;
-
-	/* Reinitialise packet at new address */
-	dhcphdr = ( ( ( void * ) dhcppkt ) + sizeof ( *dhcppkt ) );
-	dhcppkt_init ( dhcppkt, dhcphdr, len );
-
-	/* Store as cached DHCPACK, and mark original copy as consumed */
-	DBGC ( colour, "CACHEDHCP found cached DHCPACK at %08x+%zx\n",
-	       cached_dhcpack_phys, len );
-	cached_dhcpack = dhcppkt;
-	cached_dhcpack_phys = 0;
-}
-
-/**
- * Cached DHCPACK startup function
- *
- */
-static void cachedhcp_startup ( void ) {
-
-	/* If cached DHCP packet was not claimed by any network device
-	 * during startup, then free it.
-	 */
-	if ( cached_dhcpack ) {
-		DBGC ( colour, "CACHEDHCP freeing unclaimed cached DHCPACK\n" );
-		dhcppkt_put ( cached_dhcpack );
-		cached_dhcpack = NULL;
-	}
-}
-
-/** Cached DHCPACK initialisation function */
-struct init_fn cachedhcp_init_fn __init_fn ( INIT_NORMAL ) = {
-	.initialise = cachedhcp_init,
-};
-
-/** Cached DHCPACK startup function */
-struct startup_fn cachedhcp_startup_fn __startup_fn ( STARTUP_LATE ) = {
-	.name = "cachedhcp",
-	.startup = cachedhcp_startup,
-};
-
-/**
- * Apply cached DHCPACK to network device, if applicable
- *
- * @v netdev		Network device
- * @ret rc		Return status code
- */
-static int cachedhcp_probe ( struct net_device *netdev ) {
-	struct ll_protocol *ll_protocol = netdev->ll_protocol;
-	int rc;
-
-	/* Do nothing unless we have a cached DHCPACK */
-	if ( ! cached_dhcpack )
-		return 0;
-
-	/* Do nothing unless cached DHCPACK's MAC address matches this
-	 * network device.
-	 */
-	if ( memcmp ( netdev->ll_addr, cached_dhcpack->dhcphdr->chaddr,
-		      ll_protocol->ll_addr_len ) != 0 ) {
-		DBGC ( colour, "CACHEDHCP cached DHCPACK does not match %s\n",
-		       netdev->name );
-		return 0;
-	}
-	DBGC ( colour, "CACHEDHCP cached DHCPACK is for %s\n", netdev->name );
-
-	/* Register as DHCP settings for this network device */
-	if ( ( rc = register_settings ( &cached_dhcpack->settings,
-					netdev_settings ( netdev ),
-					DHCP_SETTINGS_NAME ) ) != 0 ) {
-		DBGC ( colour, "CACHEDHCP could not register settings: %s\n",
-		       strerror ( rc ) );
-		return rc;
-	}
-
-	/* Claim cached DHCPACK */
-	dhcppkt_put ( cached_dhcpack );
-	cached_dhcpack = NULL;
-
-	return 0;
-}
-
-/** Cached DHCP packet network device driver */
-struct net_driver cachedhcp_driver __net_driver = {
-	.name = "cachedhcp",
-	.probe = cachedhcp_probe,
-};

src/arch/x86/core/linux/linux_api.c

@@ -1,149 +0,0 @@
-/*
- * Copyright (C) 2010 Piotr Jaroszyński <p.jaroszynski@gmail.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- */
-
-FILE_LICENCE ( GPL2_OR_LATER );
-
-/** @file
- *
- * Implementation of most of the linux API.
- */
-
-#include <linux_api.h>
-
-#include <stdarg.h>
-#include <asm/unistd.h>
-#include <string.h>
-
-int linux_open ( const char *pathname, int flags ) {
-	return linux_syscall ( __NR_open, pathname, flags );
-}
-
-int linux_close ( int fd ) {
-	return linux_syscall ( __NR_close, fd );
-}
-
-off_t linux_lseek ( int fd, off_t offset, int whence ) {
-	return linux_syscall ( __NR_lseek, fd, offset, whence );
-}
-
-__kernel_ssize_t linux_read ( int fd, void *buf, __kernel_size_t count ) {
-	return linux_syscall ( __NR_read, fd, buf, count );
-}
-
-__kernel_ssize_t linux_write ( int fd, const void *buf,
-			       __kernel_size_t count ) {
-	return linux_syscall  (  __NR_write, fd, buf, count );
-}
-
-int linux_fcntl ( int fd, int cmd, ... ) {
-	long arg;
-	va_list list;
-
-	va_start ( list, cmd );
-	arg = va_arg ( list, long );
-	va_end ( list );
-
-	return linux_syscall ( __NR_fcntl, fd, cmd, arg );
-}
-
-int linux_ioctl ( int fd, int request, ... ) {
-	void *arg;
-	va_list list;
-
-	va_start ( list, request );
-	arg = va_arg ( list, void * );
-	va_end ( list );
-
-	return linux_syscall ( __NR_ioctl, fd, request, arg );
-}
-
-int linux_poll ( struct pollfd *fds, nfds_t nfds, int timeout ) {
-	return linux_syscall ( __NR_poll, fds, nfds, timeout );
-}
-
-int linux_nanosleep ( const struct timespec *req, struct timespec *rem ) {
-	return linux_syscall ( __NR_nanosleep, req, rem );
-}
-
-int linux_usleep ( useconds_t usec ) {
-	struct timespec ts = {
-		.tv_sec = ( ( long ) ( usec / 1000000 ) ),
-		.tv_nsec = ( ( long ) ( usec % 1000000 ) * 1000UL ),
-	};
-
-	return linux_nanosleep ( &ts, NULL );
-}
-
-int linux_gettimeofday ( struct timeval *tv, struct timezone *tz ) {
-	return linux_syscall ( __NR_gettimeofday, tv, tz );
-}
-
-void * linux_mmap ( void *addr, __kernel_size_t length, int prot, int flags,
-		    int fd, __kernel_off_t offset ) {
-	return ( void * ) linux_syscall ( __SYSCALL_mmap, addr, length, prot,
-					  flags, fd, offset );
-}
-
-void * linux_mremap ( void *old_address, __kernel_size_t old_size,
-		      __kernel_size_t new_size, int flags ) {
-	return ( void * ) linux_syscall ( __NR_mremap, old_address, old_size,
-					  new_size, flags );
-}
-
-int linux_munmap ( void *addr, __kernel_size_t length ) {
-	return linux_syscall ( __NR_munmap, addr, length );
-}
-
-int linux_socket ( int domain, int type_, int protocol ) {
-#ifdef __NR_socket
-	return linux_syscall ( __NR_socket, domain, type_, protocol );
-#else
-#ifndef SOCKOP_socket
-# define SOCKOP_socket 1
-#endif
-	unsigned long sc_args[] = { domain, type_, protocol };
-	return linux_syscall ( __NR_socketcall, SOCKOP_socket, sc_args );
-#endif
-}
-
-int linux_bind ( int fd, const struct sockaddr *addr, socklen_t addrlen ) {
-#ifdef __NR_bind
-	return linux_syscall ( __NR_bind, fd, addr, addrlen );
-#else
-#ifndef SOCKOP_bind
-# define SOCKOP_bind 2
-#endif
-	unsigned long sc_args[] = { fd, (unsigned long)addr, addrlen };
-	return linux_syscall ( __NR_socketcall, SOCKOP_bind, sc_args );
-#endif
-}
-
-ssize_t linux_sendto ( int fd, const void *buf, size_t len, int flags,
-		       const struct sockaddr *daddr, socklen_t addrlen ) {
-#ifdef __NR_sendto
-	return linux_syscall ( __NR_sendto, fd, buf, len, flags,
-			       daddr, addrlen );
-#else
-#ifndef SOCKOP_sendto
-# define SOCKOP_sendto 11
-#endif
-	unsigned long sc_args[] = { fd, (unsigned long)buf, len,
-				    flags, (unsigned long)daddr, addrlen };
-	return linux_syscall ( __NR_socketcall, SOCKOP_sendto, sc_args );
-#endif
-}

src/arch/x86/core/linux/linux_strerror.c

@@ -1,169 +0,0 @@
-/*
- * Copyright (C) 2010 Piotr Jaroszyński <p.jaroszynski@gmail.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
- */
-
-FILE_LICENCE(GPL2_OR_LATER);
-
-/** @file
- *
- * linux_strerror implementation
- */
-
-#include <linux_api.h>
-#include <stdio.h>
-
-/** Error names from glibc */
-static const char *errors[] = {
-	"Success",
-	"Operation not permitted",
-	"No such file or directory",
-	"No such process",
-	"Interrupted system call",
-	"Input/output error",
-	"No such device or address",
-	"Argument list too long",
-	"Exec format error",
-	"Bad file descriptor",
-	"No child processes",
-	"Resource temporarily unavailable",
-	"Cannot allocate memory",
-	"Permission denied",
-	"Bad address",
-	"Block device required",
-	"Device or resource busy",
-	"File exists",
-	"Invalid cross-device link",
-	"No such device",
-	"Not a directory",
-	"Is a directory",
-	"Invalid argument",
-	"Too many open files in system",
-	"Too many open files",
-	"Inappropriate ioctl for device",
-	"Text file busy",
-	"File too large",
-	"No space left on device",
-	"Illegal seek",
-	"Read-only file system",
-	"Too many links",
-	"Broken pipe",
-	"Numerical argument out of domain",
-	"Numerical result out of range",
-	"Resource deadlock avoided",
-	"File name too long",
-	"No locks available",
-	"Function not implemented",
-	"Directory not empty",
-	"Too many levels of symbolic links",
-	"",
-	"No message of desired type",
-	"Identifier removed",
-	"Channel number out of range",
-	"Level 2 not synchronized",
-	"Level 3 halted",
-	"Level 3 reset",
-	"Link number out of range",
-	"Protocol driver not attached",
-	"No CSI structure available",
-	"Level 2 halted",
-	"Invalid exchange",
-	"Invalid request descriptor",
-	"Exchange full",
-	"No anode",
-	"Invalid request code",
-	"Invalid slot",
-	"",
-	"Bad font file format",
-	"Device not a stream",
-	"No data available",
-	"Timer expired",
-	"Out of streams resources",
-	"Machine is not on the network",
-	"Package not installed",
-	"Object is remote",
-	"Link has been severed",
-	"Advertise error",
-	"Srmount error",
-	"Communication error on send",
-	"Protocol error",
-	"Multihop attempted",
-	"RFS specific error",
-	"Bad message",
-	"Value too large for defined data type",
-	"Name not unique on network",
-	"File descriptor in bad state",
-	"Remote address changed",
-	"Can not access a needed shared library",
-	"Accessing a corrupted shared library",
-	".lib section in a.out corrupted",
-	"Attempting to link in too many shared libraries",
-	"Cannot exec a shared library directly",
-	"Invalid or incomplete multibyte or wide character",
-	"Interrupted system call should be restarted",
-	"Streams pipe error",
-	"Too many users",
-	"Socket operation on non-socket",
-	"Destination address required",
-	"Message too long",
-	"Protocol wrong type for socket",
-	"Protocol not available",
-	"Protocol not supported",
-	"Socket type not supported",
-	"Operation not supported",
-	"Protocol family not supported",
-	"Address family not supported by protocol",
-	"Address already in use",
-	"Cannot assign requested address",
-	"Network is down",
-	"Network is unreachable",
-	"Network dropped connection on reset",
-	"Software caused connection abort",
-	"Connection reset by peer",
-	"No buffer space available",
-	"Transport endpoint is already connected",
-	"Transport endpoint is not connected",
-	"Cannot send after transport endpoint shutdown",
-	"Too many references: cannot splice",
-	"Connection timed out",
-	"Connection refused",
-	"Host is down",
-	"No route to host",
-	"Operation already in progress",
-	"Operation now in progress",
-	"Stale NFS file handle",
-	"Structure needs cleaning",
-	"Not a XENIX named type file",
-	"No XENIX semaphores available",
-	"Is a named type file",
-	"Remote I/O error",
-	"Disk quota exceeded",
-	"No medium found",
-	"Wrong medium type",
-};
-
-const char *linux_strerror(int errnum)
-{
-	static char errbuf[64];
-	static int errors_size = sizeof(errors) / sizeof(*errors);
-	
-	if (errnum >= errors_size || errnum < 0) {
-		snprintf(errbuf, sizeof(errbuf), "Error %#08x", errnum);
-		return errbuf;
-	} else {
-		return errors[errnum];
-	}
-}

src/arch/x86/core/pcidirect.c

@@ -45,7 +45,7 @@ void pcidirect_prepare ( struct pci_device *pci, int where ) {
 	       PCIDIRECT_CONFIG_ADDRESS );
 }
 
-PROVIDE_PCIAPI_INLINE ( direct, pci_num_bus );
+PROVIDE_PCIAPI_INLINE ( direct, pci_discover );
 PROVIDE_PCIAPI_INLINE ( direct, pci_read_config_byte );
 PROVIDE_PCIAPI_INLINE ( direct, pci_read_config_word );
 PROVIDE_PCIAPI_INLINE ( direct, pci_read_config_dword );
@@ -53,3 +53,5 @@ PROVIDE_PCIAPI_INLINE ( direct, pci_write_config_byte );
 PROVIDE_PCIAPI_INLINE ( direct, pci_write_config_word );
 PROVIDE_PCIAPI_INLINE ( direct, pci_write_config_dword );
 PROVIDE_PCIAPI_INLINE ( direct, pci_ioremap );
+
+struct pci_api pcidirect_api = PCIAPI_RUNTIME ( direct );

src/arch/x86/core/runtime.c

@@ -38,7 +38,6 @@ FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
 #include <ipxe/init.h>
 #include <ipxe/image.h>
 #include <ipxe/script.h>
-#include <ipxe/umalloc.h>
 #include <realmode.h>
 
 /** Command line physical address
@@ -180,7 +179,6 @@ static int cmdline_init ( void ) {
  */
 static int initrd_init ( void ) {
 	struct image *image;
-	int rc;
 
 	/* Do nothing if no initrd was specified */
 	if ( ! initrd_phys ) {
@@ -194,53 +192,18 @@ static int initrd_init ( void ) {
 	DBGC ( colour, "RUNTIME found initrd at [%x,%x)\n",
 	       initrd_phys, ( initrd_phys + initrd_len ) );
 
-	/* Allocate image */
-	image = alloc_image ( NULL );
+	/* Create initrd image */
+	image = image_memory ( "<INITRD>", phys_to_user ( initrd_phys ),
+			       initrd_len );
 	if ( ! image ) {
-		DBGC ( colour, "RUNTIME could not allocate image for "
-		       "initrd\n" );
-		rc = -ENOMEM;
-		goto err_alloc_image;
+		DBGC ( colour, "RUNTIME could not create initrd image\n" );
+		return -ENOMEM;
 	}
-	if ( ( rc = image_set_name ( image, "<INITRD>" ) ) != 0 ) {
-		DBGC ( colour, "RUNTIME could not set image name: %s\n",
-		       strerror ( rc ) );
-		goto err_set_name;
-	}
-
-	/* Allocate and copy initrd content */
-	image->data = umalloc ( initrd_len );
-	if ( ! image->data ) {
-		DBGC ( colour, "RUNTIME could not allocate %d bytes for "
-		       "initrd\n", initrd_len );
-		rc = -ENOMEM;
-		goto err_umalloc;
-	}
-	image->len = initrd_len;
-	memcpy_user ( image->data, 0, phys_to_user ( initrd_phys ), 0,
-		      initrd_len );
 
 	/* Mark initrd as consumed */
 	initrd_phys = 0;
 
-	/* Register image */
-	if ( ( rc = register_image ( image ) ) != 0 ) {
-		DBGC ( colour, "RUNTIME could not register initrd: %s\n",
-		       strerror ( rc ) );
-		goto err_register_image;
-	}
-
-	/* Drop our reference to the image */
-	image_put ( image );
-
 	return 0;
-
- err_register_image:
- err_umalloc:
- err_set_name:
-	image_put ( image );
- err_alloc_image:
-	return rc;
 }
 
 /**

src/arch/x86/core/stack.S

@@ -13,7 +13,7 @@ FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL )
  ****************************************************************************
  */
 	.section ".stack", "aw", @nobits
-	.align 8
+	.balign 8
 	.globl _stack
 _stack:
 	.space STACK_SIZE

src/arch/x86/core/stack16.S

@@ -7,7 +7,7 @@ FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL )
  ****************************************************************************
  */
 	.section ".stack16", "aw", @nobits
-	.align 8
+	.balign 8
 	.globl _stack16
 _stack16:
 	.space 4096

src/arch/x86/core/x86_bigint.c

@@ -75,17 +75,18 @@ void bigint_multiply_raw ( const uint32_t *multiplicand0,
 			 *
 			 *     a < 2^{n}, b < 2^{n} => ab < 2^{2n}
 			 */
-			__asm__ __volatile__ ( "mull %4\n\t"
-					       "addl %%eax, (%5,%2,4)\n\t"
-					       "adcl %%edx, 4(%5,%2,4)\n\t"
+			__asm__ __volatile__ ( "mull %5\n\t"
+					       "addl %%eax, (%6,%2,4)\n\t"
+					       "adcl %%edx, 4(%6,%2,4)\n\t"
 					       "\n1:\n\t"
-					       "adcl $0, 8(%5,%2,4)\n\t"
+					       "adcl $0, 8(%6,%2,4)\n\t"
 					       "inc %2\n\t"
 						       /* Does not affect CF */
 					       "jc 1b\n\t"
 					       : "=&a" ( discard_a ),
 						 "=&d" ( discard_d ),
-						 "=&r" ( index )
+						 "=&r" ( index ),
+						 "+m" ( *result )
 					       : "0" ( multiplicand_element ),
 						 "g" ( multiplier_element ),
 						 "r" ( result_elements ),

src/arch/x86/drivers/net/undinet.c

@@ -104,6 +104,13 @@ static union u_PXENV_ANY __bss16 ( undinet_params );
 SEGOFF16_t __bss16 ( undinet_entry_point );
 #define undinet_entry_point __use_data16 ( undinet_entry_point )
 
+/* Read TSC in real mode only when profiling */
+#if PROFILING
+#define RDTSC_IF_PROFILING "rdtsc\n\t"
+#else
+#define RDTSC_IF_PROFILING ""
+#endif
+
 /** IRQ profiler */
 static struct profiler undinet_irq_profiler __profiler =
 	{ .name = "undinet.irq" };
@@ -288,14 +295,14 @@ static int undinet_call ( struct undi_nic *undinic, unsigned int function,
 	 */
 	profile_start ( &profiler->total );
 	__asm__ __volatile__ ( REAL_CODE ( "pushl %%ebp\n\t" /* gcc bug */
-					   "rdtsc\n\t"
+					   RDTSC_IF_PROFILING
 					   "pushl %%eax\n\t"
 					   "pushw %%es\n\t"
 					   "pushw %%di\n\t"
 					   "pushw %%bx\n\t"
 					   "lcall *undinet_entry_point\n\t"
 					   "movw %%ax, %%bx\n\t"
-					   "rdtsc\n\t"
+					   RDTSC_IF_PROFILING
 					   "addw $6, %%sp\n\t"
 					   "popl %%edx\n\t"
 					   "popl %%ebp\n\t" /* gcc bug */ )

src/arch/x86/image/bzimage.c

@@ -252,13 +252,17 @@ static void bzimage_update_header ( struct image *image,
  */
 static int bzimage_parse_cmdline ( struct image *image,
 				   struct bzimage_context *bzimg,
-				   const char *cmdline ) {
+				   char *cmdline ) {
+	char *sep;
 	char *vga;
 	char *mem;
 
 	/* Look for "vga=" */
 	if ( ( vga = strstr ( cmdline, "vga=" ) ) ) {
 		vga += 4;
+		sep = strchr ( vga, ' ' );
+		if ( sep )
+			*sep = '\0';
 		if ( strcmp ( vga, "normal" ) == 0 ) {
 			bzimg->vid_mode = BZI_VID_MODE_NORMAL;
 		} else if ( strcmp ( vga, "ext" ) == 0 ) {
@@ -267,11 +271,13 @@ static int bzimage_parse_cmdline ( struct image *image,
 			bzimg->vid_mode = BZI_VID_MODE_ASK;
 		} else {
 			bzimg->vid_mode = strtoul ( vga, &vga, 0 );
-			if ( *vga && ( *vga != ' ' ) ) {
-				DBGC ( image, "bzImage %p strange \"vga=\""
+			if ( *vga ) {
+				DBGC ( image, "bzImage %p strange \"vga=\" "
 				       "terminator '%c'\n", image, *vga );
 			}
 		}
+		if ( sep )
+			*sep = ' ';
 	}
 
 	/* Look for "mem=" */
@@ -326,32 +332,6 @@ static void bzimage_set_cmdline ( struct image *image,
 	DBGC ( image, "bzImage %p command line \"%s\"\n", image, cmdline );
 }
 
-/**
- * Parse standalone image command line for cpio parameters
- *
- * @v image		bzImage file
- * @v cpio		CPIO header
- * @v cmdline		Command line
- */
-static void bzimage_parse_cpio_cmdline ( struct image *image,
-					 struct cpio_header *cpio,
-					 const char *cmdline ) {
-	char *arg;
-	char *end;
-	unsigned int mode;
-
-	/* Look for "mode=" */
-	if ( ( arg = strstr ( cmdline, "mode=" ) ) ) {
-		arg += 5;
-		mode = strtoul ( arg, &end, 8 /* Octal for file mode */ );
-		if ( *end && ( *end != ' ' ) ) {
-			DBGC ( image, "bzImage %p strange \"mode=\""
-			       "terminator '%c'\n", image, *end );
-		}
-		cpio_set_field ( cpio->c_mode, ( 0100000 | mode ) );
-	}
-}
-
 /**
  * Align initrd length
  *
@@ -374,11 +354,9 @@ static inline size_t bzimage_align ( size_t len ) {
 static size_t bzimage_load_initrd ( struct image *image,
 				    struct image *initrd,
 				    userptr_t address ) {
-	char *filename = initrd->cmdline;
-	char *cmdline;
+	const char *filename = cpio_name ( initrd );
 	struct cpio_header cpio;
 	size_t offset;
-	size_t name_len;
 	size_t pad_len;
 
 	/* Do not include kernel image itself as an initrd */
@@ -386,25 +364,7 @@ static size_t bzimage_load_initrd ( struct image *image,
 		return 0;
 
 	/* Create cpio header for non-prebuilt images */
-	if ( filename && filename[0] ) {
-		cmdline = strchr ( filename, ' ' );
-		name_len = ( ( cmdline ? ( ( size_t ) ( cmdline - filename ) )
-			       : strlen ( filename ) ) + 1 /* NUL */ );
-		memset ( &cpio, '0', sizeof ( cpio ) );
-		memcpy ( cpio.c_magic, CPIO_MAGIC, sizeof ( cpio.c_magic ) );
-		cpio_set_field ( cpio.c_mode, 0100644 );
-		cpio_set_field ( cpio.c_nlink, 1 );
-		cpio_set_field ( cpio.c_filesize, initrd->len );
-		cpio_set_field ( cpio.c_namesize, name_len );
-		if ( cmdline ) {
-			bzimage_parse_cpio_cmdline ( image, &cpio,
-						     ( cmdline + 1 /* ' ' */ ));
-		}
-		offset = ( ( sizeof ( cpio ) + name_len + 0x03 ) & ~0x03 );
-	} else {
-		offset = 0;
-		name_len = 0;
-	}
+	offset = cpio_header ( initrd, &cpio );
 
 	/* Copy in initrd image body (and cpio header if applicable) */
 	if ( address ) {
@@ -413,7 +373,7 @@ static size_t bzimage_load_initrd ( struct image *image,
 			memset_user ( address, 0, 0, offset );
 			copy_to_user ( address, 0, &cpio, sizeof ( cpio ) );
 			copy_to_user ( address, sizeof ( cpio ), filename,
-				       ( name_len - 1 /* NUL (or space) */ ) );
+				       cpio_name_len ( initrd ) );
 		}
 		DBGC ( image, "bzImage %p initrd %p [%#08lx,%#08lx,%#08lx)"
 		       "%s%s\n", image, initrd, user_to_phys ( address, 0 ),
@@ -568,7 +528,7 @@ static void bzimage_load_initrds ( struct image *image,
  */
 static int bzimage_exec ( struct image *image ) {
 	struct bzimage_context bzimg;
-	const char *cmdline = ( image->cmdline ? image->cmdline : "" );
+	char *cmdline = ( image->cmdline ? image->cmdline : "" );
 	int rc;
 
 	/* Read and parse header from image */

src/arch/x86/image/initrd.c

@@ -29,6 +29,7 @@ FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
 #include <ipxe/uaccess.h>
 #include <ipxe/init.h>
 #include <ipxe/memblock.h>
+#include <ipxe/cpio.h>
 
 /** @file
  *
@@ -175,18 +176,18 @@ static int initrd_swap_any ( userptr_t free, size_t free_len ) {
 		/* Search for adjacent image */
 		for_each_image ( high ) {
 
-			/* If we have found the adjacent image, swap and exit */
-			if ( high->data == adjacent ) {
-				initrd_swap ( low, high, free, free_len );
-				return 1;
-			}
-
 			/* Stop search if all remaining potential
 			 * adjacent images are already in the correct
 			 * order.
 			 */
 			if ( high == low )
 				break;
+
+			/* If we have found the adjacent image, swap and exit */
+			if ( high->data == adjacent ) {
+				initrd_swap ( low, high, free, free_len );
+				return 1;
+			}
 		}
 	}
 

src/arch/x86/include/bios.h

@@ -6,6 +6,11 @@ FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
 #define BDA_SEG 0x0040
 #define BDA_EBDA 0x000e
 #define BDA_EQUIPMENT_WORD 0x0010
+#define BDA_KB0 0x0017
+#define BDA_KB0_RSHIFT 0x01
+#define BDA_KB0_LSHIFT 0x02
+#define BDA_KB0_CTRL 0x04
+#define BDA_KB0_CAPSLOCK 0x040
 #define BDA_FBMS 0x0013
 #define BDA_TICKS 0x006c
 #define BDA_MIDNIGHT 0x0070
@@ -13,5 +18,7 @@ FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
 #define BDA_REBOOT_WARM 0x1234
 #define BDA_NUM_DRIVES 0x0075
 #define BDA_CHAR_HEIGHT 0x0085
+#define BDA_KB2 0x0096
+#define BDA_KB2_RALT 0x08
 
 #endif /* BIOS_H */

src/arch/x86/include/bits/bigint.h

@@ -25,19 +25,22 @@ typedef uint32_t bigint_element_t;
 static inline __attribute__ (( always_inline )) void
 bigint_init_raw ( uint32_t *value0, unsigned int size,
 		  const void *data, size_t len ) {
-	long pad_len = ( sizeof ( bigint_t ( size ) ) - len );
+	bigint_t ( size ) __attribute__ (( may_alias )) *value =
+		( ( void * ) value0 );
+	long pad_len = ( sizeof ( *value ) - len );
 	void *discard_D;
 	long discard_c;
 
 	/* Copy raw data in reverse order, padding with zeros */
 	__asm__ __volatile__ ( "\n1:\n\t"
-			       "movb -1(%2,%1), %%al\n\t"
+			       "movb -1(%3,%1), %%al\n\t"
 			       "stosb\n\t"
 			       "loop 1b\n\t"
 			       "xorl %%eax, %%eax\n\t"
-			       "mov %3, %1\n\t"
+			       "mov %4, %1\n\t"
 			       "rep stosb\n\t"
-			       : "=&D" ( discard_D ), "=&c" ( discard_c )
+			       : "=&D" ( discard_D ), "=&c" ( discard_c ),
+				 "+m" ( *value )
 			       : "r" ( data ), "g" ( pad_len ), "0" ( value0 ),
 				 "1" ( len )
 			       : "eax" );
@@ -53,6 +56,8 @@ bigint_init_raw ( uint32_t *value0, unsigned int size,
 static inline __attribute__ (( always_inline )) void
 bigint_add_raw ( const uint32_t *addend0, uint32_t *value0,
 		 unsigned int size ) {
+	bigint_t ( size ) __attribute__ (( may_alias )) *value =
+		( ( void * ) value0 );
 	long index;
 	void *discard_S;
 	long discard_c;
@@ -60,11 +65,11 @@ bigint_add_raw ( const uint32_t *addend0, uint32_t *value0,
 	__asm__ __volatile__ ( "xor %0, %0\n\t" /* Zero %0 and clear CF */
 			       "\n1:\n\t"
 			       "lodsl\n\t"
-			       "adcl %%eax, (%3,%0,4)\n\t"
+			       "adcl %%eax, (%4,%0,4)\n\t"
 			       "inc %0\n\t" /* Does not affect CF */
 			       "loop 1b\n\t"
 			       : "=&r" ( index ), "=&S" ( discard_S ),
-				 "=&c" ( discard_c )
+				 "=&c" ( discard_c ), "+m" ( *value )
 			       : "r" ( value0 ), "1" ( addend0 ), "2" ( size )
 			       : "eax" );
 }
@@ -79,6 +84,8 @@ bigint_add_raw ( const uint32_t *addend0, uint32_t *value0,
 static inline __attribute__ (( always_inline )) void
 bigint_subtract_raw ( const uint32_t *subtrahend0, uint32_t *value0,
 		      unsigned int size ) {
+	bigint_t ( size ) __attribute__ (( may_alias )) *value =
+		( ( void * ) value0 );
 	long index;
 	void *discard_S;
 	long discard_c;
@@ -86,11 +93,11 @@ bigint_subtract_raw ( const uint32_t *subtrahend0, uint32_t *value0,
 	__asm__ __volatile__ ( "xor %0, %0\n\t" /* Zero %0 and clear CF */
 			       "\n1:\n\t"
 			       "lodsl\n\t"
-			       "sbbl %%eax, (%3,%0,4)\n\t"
+			       "sbbl %%eax, (%4,%0,4)\n\t"
 			       "inc %0\n\t" /* Does not affect CF */
 			       "loop 1b\n\t"
 			       : "=&r" ( index ), "=&S" ( discard_S ),
-				 "=&c" ( discard_c )
+				 "=&c" ( discard_c ), "+m" ( *value )
 			       : "r" ( value0 ), "1" ( subtrahend0 ),
 				 "2" ( size )
 			       : "eax" );
@@ -104,15 +111,18 @@ bigint_subtract_raw ( const uint32_t *subtrahend0, uint32_t *value0,
  */
 static inline __attribute__ (( always_inline )) void
 bigint_rol_raw ( uint32_t *value0, unsigned int size ) {
+	bigint_t ( size ) __attribute__ (( may_alias )) *value =
+		( ( void * ) value0 );
 	long index;
 	long discard_c;
 
 	__asm__ __volatile__ ( "xor %0, %0\n\t" /* Zero %0 and clear CF */
 			       "\n1:\n\t"
-			       "rcll $1, (%2,%0,4)\n\t"
+			       "rcll $1, (%3,%0,4)\n\t"
 			       "inc %0\n\t" /* Does not affect CF */
 			       "loop 1b\n\t"
-			       : "=&r" ( index ), "=&c" ( discard_c )
+			       : "=&r" ( index ), "=&c" ( discard_c ),
+				 "+m" ( *value )
 			       : "r" ( value0 ), "1" ( size ) );
 }
 
@@ -124,13 +134,15 @@ bigint_rol_raw ( uint32_t *value0, unsigned int size ) {
  */
 static inline __attribute__ (( always_inline )) void
 bigint_ror_raw ( uint32_t *value0, unsigned int size ) {
+	bigint_t ( size ) __attribute__ (( may_alias )) *value =
+		( ( void * ) value0 );
 	long discard_c;
 
 	__asm__ __volatile__ ( "clc\n\t"
 			       "\n1:\n\t"
-			       "rcrl $1, -4(%1,%0,4)\n\t"
+			       "rcrl $1, -4(%2,%0,4)\n\t"
 			       "loop 1b\n\t"
-			       : "=&c" ( discard_c )
+			       : "=&c" ( discard_c ), "+m" ( *value )
 			       : "r" ( value0 ), "0" ( size ) );
 }
 
@@ -239,6 +251,8 @@ bigint_max_set_bit_raw ( const uint32_t *value0, unsigned int size ) {
 static inline __attribute__ (( always_inline )) void
 bigint_grow_raw ( const uint32_t *source0, unsigned int source_size,
 		  uint32_t *dest0, unsigned int dest_size ) {
+	bigint_t ( dest_size ) __attribute__ (( may_alias )) *dest =
+		( ( void * ) dest0 );
 	long pad_size = ( dest_size - source_size );
 	void *discard_D;
 	void *discard_S;
@@ -246,10 +260,10 @@ bigint_grow_raw ( const uint32_t *source0, unsigned int source_size,
 
 	__asm__ __volatile__ ( "rep movsl\n\t"
 			       "xorl %%eax, %%eax\n\t"
-			       "mov %3, %2\n\t"
+			       "mov %4, %2\n\t"
 			       "rep stosl\n\t"
 			       : "=&D" ( discard_D ), "=&S" ( discard_S ),
-				 "=&c" ( discard_c )
+				 "=&c" ( discard_c ), "+m" ( *dest )
 			       : "g" ( pad_size ), "0" ( dest0 ),
 				 "1" ( source0 ), "2" ( source_size )
 			       : "eax" );
@@ -266,13 +280,15 @@ bigint_grow_raw ( const uint32_t *source0, unsigned int source_size,
 static inline __attribute__ (( always_inline )) void
 bigint_shrink_raw ( const uint32_t *source0, unsigned int source_size __unused,
 		    uint32_t *dest0, unsigned int dest_size ) {
+	bigint_t ( dest_size ) __attribute__ (( may_alias )) *dest =
+		( ( void * ) dest0 );
 	void *discard_D;
 	void *discard_S;
 	long discard_c;
 
 	__asm__ __volatile__ ( "rep movsl\n\t"
 			       : "=&D" ( discard_D ), "=&S" ( discard_S ),
-				 "=&c" ( discard_c )
+				 "=&c" ( discard_c ), "+m" ( *dest )
 			       : "0" ( dest0 ), "1" ( source0 ),
 				 "2" ( dest_size )
 			       : "eax" );
@@ -289,15 +305,19 @@ bigint_shrink_raw ( const uint32_t *source0, unsigned int source_size __unused,
 static inline __attribute__ (( always_inline )) void
 bigint_done_raw ( const uint32_t *value0, unsigned int size __unused,
 		  void *out, size_t len ) {
+	struct {
+		uint8_t bytes[len];
+	} __attribute__ (( may_alias )) *out_bytes = out;
 	void *discard_D;
 	long discard_c;
 
 	/* Copy raw data in reverse order */
 	__asm__ __volatile__ ( "\n1:\n\t"
-			       "movb -1(%2,%1), %%al\n\t"
+			       "movb -1(%3,%1), %%al\n\t"
 			       "stosb\n\t"
 			       "loop 1b\n\t"
-			       : "=&D" ( discard_D ), "=&c" ( discard_c )
+			       : "=&D" ( discard_D ), "=&c" ( discard_c ),
+				 "+m" ( *out_bytes )
 			       : "r" ( value0 ), "0" ( out ), "1" ( len )
 			       : "eax" );
 }

src/arch/x86/include/bits/bitops.h

@@ -29,7 +29,7 @@ set_bit ( unsigned int bit, volatile void *bits ) {
 		uint8_t byte[ ( bit / 8 ) + 1 ];
 	} *bytes = bits;
 
-	__asm__ __volatile__ ( "lock bts %1, %0"
+	__asm__ __volatile__ ( "lock btsl %k1, %0"
 			       : "+m" ( *bytes ) : "Ir" ( bit ) );
 }
 
@@ -45,7 +45,7 @@ clear_bit ( unsigned int bit, volatile void *bits ) {
 		uint8_t byte[ ( bit / 8 ) + 1 ];
 	} *bytes = bits;
 
-	__asm__ __volatile__ ( "lock btr %1, %0"
+	__asm__ __volatile__ ( "lock btrl %k1, %0"
 			       : "+m" ( *bytes ) : "Ir" ( bit ) );
 }
 
@@ -63,7 +63,7 @@ test_and_set_bit ( unsigned int bit, volatile void *bits ) {
 	} *bytes = bits;
 	int old;
 
-	__asm__ __volatile__ ( "lock bts %2, %0\n\t"
+	__asm__ __volatile__ ( "lock btsl %k2, %0\n\t"
 			       "sbb %1, %1\n\t"
 			       : "+m" ( *bytes ), "=r"  ( old )
 			       : "Ir" ( bit ) );
@@ -84,7 +84,7 @@ test_and_clear_bit ( unsigned int bit, volatile void *bits ) {
 	} *bytes = bits;
 	int old;
 
-	__asm__ __volatile__ ( "lock btr %2, %0\n\t"
+	__asm__ __volatile__ ( "lock btrl %k2, %0\n\t"
 			       "sbb %1, %1\n\t"
 			       : "+m" ( *bytes ), "=r"  ( old )
 			       : "Ir" ( bit ) );

src/arch/x86/include/bits/io.h

@@ -9,6 +9,9 @@
 
 FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
 
+/** Page shift */
+#define PAGE_SHIFT 12
+
 #include <ipxe/x86_io.h>
 
 #endif /* _BITS_IO_H */

src/arch/x86/include/bits/linux_api_platform.h

@@ -1,6 +0,0 @@
-#ifndef _LINUX_API_PLATFORM_H
-#define _LINUX_API_PLATFORM_H
-
-extern int linux_errno;
-
-#endif /* _LINUX_API_PLATFORM_H */

src/arch/x86/include/bits/pci_io.h

@@ -11,5 +11,6 @@ FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
 
 #include <ipxe/pcibios.h>
 #include <ipxe/pcidirect.h>
+#include <ipxe/pcicloud.h>
 
 #endif /* _BITS_PCI_IO_H */

src/arch/x86/include/initrd.h

@@ -11,13 +11,6 @@ FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
 
 #include <ipxe/uaccess.h>
 
-/** Minimum alignment for initrds
- *
- * Some versions of Linux complain about initrds that are not
- * page-aligned.
- */
-#define INITRD_ALIGN 4096
-
 /** Minimum free space required to reshuffle initrds
  *
  * Chosen to avoid absurdly long reshuffling times

src/arch/x86/include/ipxe/cpuid.h

@@ -42,6 +42,12 @@ struct x86_features {
 /** Hypervisor is present */
 #define CPUID_FEATURES_INTEL_ECX_HYPERVISOR 0x80000000UL
 
+/** TSC is present */
+#define CPUID_FEATURES_INTEL_EDX_TSC 0x00000010UL
+
+/** FXSAVE and FXRSTOR are supported */
+#define CPUID_FEATURES_INTEL_EDX_FXSR 0x01000000UL
+
 /** Get largest extended function */
 #define CPUID_AMD_MAX_FN 0x80000000UL
 

src/arch/x86/include/ipxe/pcbios/dhcparch.h

@@ -0,0 +1,20 @@
+#ifndef _IPXE_PCBIOS_DHCPARCH_H
+#define _IPXE_PCBIOS_DHCPARCH_H
+
+/** @file
+ *
+ * DHCP client architecture definitions
+ *
+ */
+
+FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
+
+#include <ipxe/dhcp.h>
+
+/** DHCP client architecture */
+#define DHCP_ARCH_CLIENT_ARCHITECTURE DHCP_CLIENT_ARCHITECTURE_X86
+
+/** DHCP client network device interface */
+#define DHCP_ARCH_CLIENT_NDI 1 /* UNDI */ , 2, 1 /* v2.1 */
+
+#endif /* _IPXE_PCBIOS_DHCPARCH_H */

src/arch/x86/include/ipxe/pcibios.h

@@ -145,4 +145,6 @@ PCIAPI_INLINE ( pcbios, pci_ioremap ) ( struct pci_device *pci __unused,
 	return ioremap ( bus_addr, len );
 }
 
+extern struct pci_api pcibios_api;
+
 #endif /* _IPXE_PCIBIOS_H */

src/arch/x86/include/ipxe/pcicloud.h

@@ -0,0 +1,18 @@
+#ifndef _IPXE_PCICLOUD_H
+#define _IPXE_PCICLOUD_H
+
+/** @file
+ *
+ * Cloud VM PCI configuration space access
+ *
+ */
+
+FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
+
+#ifdef PCIAPI_CLOUD
+#define PCIAPI_PREFIX_cloud
+#else
+#define PCIAPI_PREFIX_cloud __cloud_
+#endif
+
+#endif /* _IPXE_PCICLOUD_H */

src/arch/x86/include/ipxe/pcidirect.h

@@ -26,14 +26,18 @@ struct pci_device;
 extern void pcidirect_prepare ( struct pci_device *pci, int where );
 
 /**
- * Determine number of PCI buses within system
+ * Find next PCI bus:dev.fn address range in system
  *
- * @ret num_bus		Number of buses
+ * @v busdevfn		Starting PCI bus:dev.fn address
+ * @v range		PCI bus:dev.fn address range to fill in
  */
-static inline __always_inline int
-PCIAPI_INLINE ( direct, pci_num_bus ) ( void ) {
-	/* No way to work this out via Type 1 accesses */
-	return 0x100;
+static inline __always_inline void
+PCIAPI_INLINE ( direct, pci_discover ) ( uint32_t busdevfn __unused,
+					 struct pci_range *range ) {
+
+	/* Scan first bus and rely on bridge detection to find higher buses */
+	range->start = PCI_BUSDEVFN ( 0, 0, 0, 0 );
+	range->count = PCI_BUSDEVFN ( 0, 1, 0, 0 );
 }
 
 /**
@@ -151,4 +155,6 @@ PCIAPI_INLINE ( direct, pci_ioremap ) ( struct pci_device *pci __unused,
 	return ioremap ( bus_addr, len );
 }
 
+extern struct pci_api pcidirect_api;
+
 #endif /* _PCIDIRECT_H */

src/arch/x86/include/ipxe/rsdp.h

@@ -15,4 +15,17 @@ FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
 #define ACPI_PREFIX_rsdp __rsdp_
 #endif
 
+/**
+ * Locate ACPI table
+ *
+ * @v signature		Requested table signature
+ * @v index		Requested index of table with this signature
+ * @ret table		Table, or UNULL if not found
+ */
+static inline __attribute__ (( always_inline )) userptr_t
+ACPI_INLINE ( rsdp, acpi_find ) ( uint32_t signature, unsigned int index ) {
+
+	return acpi_find_via_rsdt ( signature, index );
+}
+
 #endif /* _IPXE_RSDP_H */

src/arch/x86/include/ipxe/x86_io.h

@@ -28,9 +28,6 @@ FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
  *
  */
 
-/** Page shift */
-#define PAGE_SHIFT 12
-
 /*
  * Physical<->Bus address mappings
  *

src/arch/x86/include/linux/ipxe/dhcp_arch.h

@@ -1,41 +0,0 @@
-/*
- * Copyright (C) 2010 Piotr Jaroszyński <p.jaroszynski@gmail.com>
- *
- * This program is free software; you can redistribute it and/or
- * modify it under the terms of the GNU General Public License as
- * published by the Free Software Foundation; either version 2 of the
- * License, or (at your option) any later version.
- *
- * This program is distributed in the hope that it will be useful, but
- * WITHOUT ANY WARRANTY; without even the implied warranty of
- * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
- * General Public License for more details.
- *
- * You should have received a copy of the GNU General Public License
- * along with this program; if not, write to the Free Software
- * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
- * 02110-1301, USA.
- *
- * You can also choose to distribute this program under the terms of
- * the Unmodified Binary Distribution Licence (as given in the file
- * COPYING.UBDL), provided that you have satisfied its requirements.
- */
-
-#ifndef _LINUX_DHCP_ARCH_H
-#define _LINUX_DHCP_ARCH_H
-
-/** @file
- *
- * Architecture-specific DHCP options
- */
-
-FILE_LICENCE(GPL2_OR_LATER_OR_UBDL);
-
-#include <ipxe/dhcp.h>
-
-// Emulate one of the supported arch-platforms
-#include <arch/i386/include/pcbios/ipxe/dhcp_arch.h>
-//#include <arch/i386/include/efi/ipxe/dhcp_arch.h>
-//#include <arch/x86_64/include/efi/ipxe/dhcp_arch.h>
-
-#endif

src/arch/x86/interface/pcbios/acpi_timer.c

@@ -107,7 +107,7 @@ static int acpi_timer_probe ( void ) {
 	unsigned int pm_tmr_blk;
 
 	/* Locate FADT */
-	fadt = acpi_find ( FADT_SIGNATURE, 0 );
+	fadt = acpi_table ( FADT_SIGNATURE, 0 );
 	if ( ! fadt ) {
 		DBGC ( &acpi_timer, "ACPI could not find FADT\n" );
 		return -ENOENT;

src/arch/x86/interface/pcbios/acpipwr.c

@@ -42,6 +42,69 @@ FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
 /** _S5_ signature */
 #define S5_SIGNATURE ACPI_SIGNATURE ( '_', 'S', '5', '_' )
 
+/**
+ * Extract \_Sx value from DSDT/SSDT
+ *
+ * @v zsdt		DSDT or SSDT
+ * @v len		Length of DSDT/SSDT
+ * @v offset		Offset of signature within DSDT/SSDT
+ * @v data		Data buffer
+ * @ret rc		Return status code
+ *
+ * In theory, extracting the \_Sx value from the DSDT/SSDT requires a
+ * full ACPI parser plus some heuristics to work around the various
+ * broken encodings encountered in real ACPI implementations.
+ *
+ * In practice, we can get the same result by scanning through the
+ * DSDT/SSDT for the signature (e.g. "_S5_"), extracting the first
+ * four bytes, removing any bytes with bit 3 set, and treating
+ * whatever is left as a little-endian value.  This is one of the
+ * uglier hacks I have ever implemented, but it's still prettier than
+ * the ACPI specification itself.
+ */
+static int acpi_extract_sx ( userptr_t zsdt, size_t len, size_t offset,
+			     void *data ) {
+	unsigned int *sx = data;
+	uint8_t bytes[4];
+	uint8_t *byte;
+
+	/* Skip signature and package header */
+	offset += ( 4 /* signature */ + 3 /* package header */ );
+
+	/* Sanity check */
+	if ( ( offset + sizeof ( bytes ) /* value */ ) > len ) {
+		return -EINVAL;
+	}
+
+	/* Read first four bytes of value */
+	copy_from_user ( bytes, zsdt, offset, sizeof ( bytes ) );
+	DBGC ( colour, "ACPI found \\_Sx containing %02x:%02x:%02x:%02x\n",
+	       bytes[0], bytes[1], bytes[2], bytes[3] );
+
+	/* Extract \Sx value.  There are three potential encodings
+	 * that we might encounter:
+	 *
+	 * - SLP_TYPa, SLP_TYPb, rsvd, rsvd
+	 *
+	 * - <byteprefix>, SLP_TYPa, <byteprefix>, SLP_TYPb, ...
+	 *
+	 * - <dwordprefix>, SLP_TYPa, SLP_TYPb, 0, 0
+	 *
+	 * Since <byteprefix> and <dwordprefix> both have bit 3 set,
+	 * and valid SLP_TYPx must have bit 3 clear (since SLP_TYPx is
+	 * a 3-bit field), we can just skip any bytes with bit 3 set.
+	 */
+	byte = bytes;
+	if ( *byte & 0x08 )
+		byte++;
+	*sx = *(byte++);
+	if ( *byte & 0x08 )
+		byte++;
+	*sx |= ( *byte << 8 );
+
+	return 0;
+}
+
 /**
  * Power off the computer using ACPI
  *
@@ -56,11 +119,11 @@ int acpi_poweroff ( void ) {
 	unsigned int pm1b_cnt;
 	unsigned int slp_typa;
 	unsigned int slp_typb;
-	int s5;
+	unsigned int s5;
 	int rc;
 
 	/* Locate FADT */
-	fadt = acpi_find ( FADT_SIGNATURE, 0 );
+	fadt = acpi_table ( FADT_SIGNATURE, 0 );
 	if ( ! fadt ) {
 		DBGC ( colour, "ACPI could not find FADT\n" );
 		return -ENOENT;
@@ -74,9 +137,8 @@ int acpi_poweroff ( void ) {
 	pm1b_cnt = ( pm1b_cnt_blk + ACPI_PM1_CNT );
 
 	/* Extract \_S5 from DSDT or any SSDT */
-	s5 = acpi_sx ( S5_SIGNATURE );
-	if ( s5 < 0 ) {
-		rc = s5;
+	if ( ( rc = acpi_extract ( S5_SIGNATURE, &s5,
+				   acpi_extract_sx ) ) != 0 ) {
 		DBGC ( colour, "ACPI could not extract \\_S5: %s\n",
 		       strerror ( rc ) );
 		return rc;

src/arch/x86/interface/pcbios/bios_cachedhcp.c

@@ -0,0 +1,77 @@
+/*
+ * Copyright (C) 2013 Michael Brown <mbrown@fensystems.co.uk>.
+ *
+ * This program is free software; you can redistribute it and/or
+ * modify it under the terms of the GNU General Public License as
+ * published by the Free Software Foundation; either version 2 of the
+ * License, or any later version.
+ *
+ * This program is distributed in the hope that it will be useful, but
+ * WITHOUT ANY WARRANTY; without even the implied warranty of
+ * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
+ * General Public License for more details.
+ *
+ * You should have received a copy of the GNU General Public License
+ * along with this program; if not, write to the Free Software
+ * Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
+ * 02110-1301, USA.
+ *
+ * You can also choose to distribute this program under the terms of
+ * the Unmodified Binary Distribution Licence (as given in the file
+ * COPYING.UBDL), provided that you have satisfied its requirements.
+ */
+
+FILE_LICENCE ( GPL2_OR_LATER_OR_UBDL );
+
+#include <stdint.h>
+#include <ipxe/init.h>
+#include <ipxe/cachedhcp.h>
+#include <realmode.h>
+#include <pxe_api.h>
+
+/** @file
+ *
+ * Cached DHCP packet
+ *
+ */
+
+/** Cached DHCPACK physical address
+ *
+ * This can be set by the prefix.
+ */
+uint32_t __bss16 ( cached_dhcpack_phys );
+#define cached_dhcpack_phys __use_data16 ( cached_dhcpack_phys )
+
+/** Colour for debug messages */
+#define colour &cached_dhcpack_phys
+
+/**
+ * Cached DHCPACK initialisation function
+ *
+ */
+static void cachedhcp_init ( void ) {
+	int rc;
+
+	/* Do nothing if no cached DHCPACK is present */
+	if ( ! cached_dhcpack_phys ) {
+		DBGC ( colour, "CACHEDHCP found no cached DHCPACK\n" );
+		return;
+	}
+
+	/* Record cached DHCPACK */
+	if ( ( rc = cachedhcp_record ( &cached_dhcpack, 0,
+				       phys_to_user ( cached_dhcpack_phys ),
+				       sizeof ( BOOTPLAYER_t ) ) ) != 0 ) {
+		DBGC ( colour, "CACHEDHCP could not record DHCPACK: %s\n",
+		       strerror ( rc ) );
+		return;
+	}
+
+	/* Mark as consumed */
+	cached_dhcpack_phys = 0;
+}
+
+/** Cached DHCPACK initialisation function */
+struct init_fn cachedhcp_init_fn __init_fn ( INIT_NORMAL ) = {
+	.initialise = cachedhcp_init,
+};