Merge branch 'master' into andrey/ext4_inline_data

Conflicts:
	grub-core/fs/ext2.c

.gitignore

@@ -246,4 +246,3 @@ build-aux/test-driver
 /garbage-gen
 /garbage-gen.exe
 /grub-fs-tester
-grub-core/build-grub-module-verifier

INSTALL

@@ -15,14 +15,15 @@ configuring the GRUB.
   Note: older versions may work but support is limited
 
   Experimental support for clang 3.3 or later (results in much bigger binaries)
-  for i386, x86_64, arm (including thumb), arm64, mips(el), powerpc, sparc64
+  for i386, x86_64, arm (except thumb), arm64, mips(el), powerpc, sparc64
   Note: clang 3.2 or later works for i386 and x86_64 targets but results in
         much bigger binaries.
 	earlier versions not tested
   Note: clang 3.2 or later works for arm
+	None of tested clang versions generated usable thumb code
 	earlier versions not tested
-  Note: clang on arm64 is not supported due to
-	https://llvm.org/bugs/show_bug.cgi?id=26030
+  Note: clang 3.3 or later works for arm64
+	earlier versions have no arm64 support
   Note: clang 3.3 or later works for mips(el)
 	earlier versions fail to generate .reginfo and hence gprel relocations
 	fail.

Makefile.am

@@ -145,116 +145,109 @@ if COND_real_platform
 
 if COND_i386_coreboot
 QEMU32=qemu-system-i386
-MINIMUM_CPU_LINUX=pentium2
 endif
 
 if COND_i386_multiboot
 QEMU32=qemu-system-i386
-MINIMUM_CPU_LINUX=pentium2
 endif
 
 if COND_i386_ieee1275
 QEMU32=qemu-system-i386
-MINIMUM_CPU_LINUX=pentium2
 endif
 
 if COND_i386_qemu
 QEMU32=qemu-system-i386
-MINIMUM_CPU_LINUX=pentium2
 endif
 
 if COND_i386_pc
 QEMU32=qemu-system-i386
-MINIMUM_CPU_LINUX=pentium2
 endif
 
 if COND_i386_efi
 QEMU32=qemu-system-i386
-MINIMUM_CPU_LINUX=pentium2
 endif
 
 if COND_x86_64_efi
 QEMU32=qemu-system-x86_64
-MINIMUM_CPU_LINUX=core2duo
 endif
 
 linux.init.x86_64: $(srcdir)/grub-core/tests/boot/linux.init-x86_64.S $(srcdir)/grub-core/tests/boot/qemu-shutdown-x86.S
-	$(TARGET_CC) -o $@ $< -static -m64 -nostdlib -nostdinc -DSUCCESSFUL_BOOT_STRING=\"$(SUCCESSFUL_BOOT_STRING)\"
+	$(TARGET_CC) -o $@ $< -m64 -nostdlib -nostdinc -DSUCCESSFUL_BOOT_STRING=\"$(SUCCESSFUL_BOOT_STRING)\"
 
 linux.init.i386: $(srcdir)/grub-core/tests/boot/linux.init-i386.S $(srcdir)/grub-core/tests/boot/qemu-shutdown-x86.S
-	$(TARGET_CC) -o $@ $< -static -m32 -nostdlib -nostdinc -DSUCCESSFUL_BOOT_STRING=\"$(SUCCESSFUL_BOOT_STRING)\"
+	$(TARGET_CC) -o $@ $< -m32 -nostdlib -nostdinc -DSUCCESSFUL_BOOT_STRING=\"$(SUCCESSFUL_BOOT_STRING)\"
 
 linux.init.mips: $(srcdir)/grub-core/tests/boot/linux.init-mips.S
-	$(TARGET_CC) -o $@ $< -static -nostdlib -nostdinc -DSUCCESSFUL_BOOT_STRING=\"$(SUCCESSFUL_BOOT_STRING)\"
+	$(TARGET_CC) -o $@ $< -nostdlib -nostdinc -DSUCCESSFUL_BOOT_STRING=\"$(SUCCESSFUL_BOOT_STRING)\"
 
 linux.init.ppc: $(srcdir)/grub-core/tests/boot/linux.init-ppc.S
-	$(TARGET_CC) -o $@ $< -static -nostdlib -nostdinc -DSUCCESSFUL_BOOT_STRING=\"$(SUCCESSFUL_BOOT_STRING)\"
+	$(TARGET_CC) -o $@ $< -nostdlib -nostdinc -DSUCCESSFUL_BOOT_STRING=\"$(SUCCESSFUL_BOOT_STRING)\"
 
 linux.init.mipsel: $(srcdir)/grub-core/tests/boot/linux.init-mips.S
-	$(TARGET_CC) -o $@ $< -static -nostdlib -nostdinc -DSUCCESSFUL_BOOT_STRING=\"$(SUCCESSFUL_BOOT_STRING)\"
+	$(TARGET_CC) -o $@ $< -nostdlib -nostdinc -DSUCCESSFUL_BOOT_STRING=\"$(SUCCESSFUL_BOOT_STRING)\"
 
 linux.init.loongson: $(srcdir)/grub-core/tests/boot/linux.init-mips.S
-	$(TARGET_CC) -o $@ $< -static -nostdlib -nostdinc -DSUCCESSFUL_BOOT_STRING=\"$(SUCCESSFUL_BOOT_STRING)\" -DREBOOT=1
+	$(TARGET_CC) -o $@ $< -nostdlib -nostdinc -DSUCCESSFUL_BOOT_STRING=\"$(SUCCESSFUL_BOOT_STRING)\" -DREBOOT=1
 
 multiboot.elf: $(srcdir)/grub-core/tests/boot/kernel-i386.S $(srcdir)/grub-core/tests/boot/qemu-shutdown-x86.S
-	$(TARGET_CC) -o $@ $< -DSUCCESSFUL_BOOT_STRING=\"$(SUCCESSFUL_BOOT_STRING)\" -static -ffreestanding -nostdlib -nostdinc -DTARGET_MULTIBOOT=1 -Wl,--build-id=none -Wl,-N -Wl,-Ttext,0x100000 -m32 -I$(srcdir)/include
+	$(TARGET_CC) -o $@ $< -DSUCCESSFUL_BOOT_STRING=\"$(SUCCESSFUL_BOOT_STRING)\" -ffreestanding -nostdlib -nostdinc -DTARGET_MULTIBOOT=1 -Wl,--build-id=none -Wl,-N -Wl,-Ttext,0x100000 -m32 -I$(srcdir)/include
 
 kfreebsd.elf: $(srcdir)/grub-core/tests/boot/kernel-i386.S $(srcdir)/grub-core/tests/boot/qemu-shutdown-x86.S
-	$(TARGET_CC) -o $@ $< -DSUCCESSFUL_BOOT_STRING=\"$(SUCCESSFUL_BOOT_STRING)\" -static -ffreestanding -nostdlib -nostdinc -Wl,--build-id=none -Wl,-N -Wl,-Ttext,0x100000 -m32 -I$(srcdir)/include
+	$(TARGET_CC) -o $@ $< -DSUCCESSFUL_BOOT_STRING=\"$(SUCCESSFUL_BOOT_STRING)\" -ffreestanding -nostdlib -nostdinc -Wl,--build-id=none -Wl,-N -Wl,-Ttext,0x100000 -m32 -I$(srcdir)/include
 
 kfreebsd.aout: kfreebsd.elf
-	$(TARGET_OBJCOPY) -O a.out-i386-linux $< $@ -j .text
+	$(TARGET_OBJCOPY) -O a.out-i386-linux $< $@ -R .note.gnu.build-id -R .note.gnu.gold-version
 
 pc-chainloader.elf: $(srcdir)/grub-core/tests/boot/kernel-8086.S $(srcdir)/grub-core/tests/boot/qemu-shutdown-x86.S
-	$(TARGET_CC) -o $@ $< -static -DTARGET_CHAINLOADER=1 -DSUCCESSFUL_BOOT_STRING=\"$(SUCCESSFUL_BOOT_STRING)\" -ffreestanding -nostdlib -nostdinc -Wl,--build-id=none -Wl,-N -Wl,-Ttext,0x7c00 -m32
+	$(TARGET_CC) -o $@ $< -DTARGET_CHAINLOADER=1 -DSUCCESSFUL_BOOT_STRING=\"$(SUCCESSFUL_BOOT_STRING)\" -ffreestanding -nostdlib -nostdinc -Wl,--build-id=none -Wl,-N -Wl,-Ttext,0x7c00 -m32
 
 pc-chainloader.bin: pc-chainloader.elf
 	$(TARGET_OBJCOPY) -O binary --strip-unneeded -R .note -R .comment -R .note.gnu.build-id -R .reginfo -R .rel.dyn -R .note.gnu.gold-version $< $@;
 
 ntldr.elf: $(srcdir)/grub-core/tests/boot/kernel-8086.S $(srcdir)/grub-core/tests/boot/qemu-shutdown-x86.S
-	$(TARGET_CC) -o $@ $< -DTARGET_NTLDR=1 -DSUCCESSFUL_BOOT_STRING=\"$(SUCCESSFUL_BOOT_STRING)\" -static -ffreestanding -nostdlib -nostdinc -Wl,--build-id=none -Wl,-N -Wl,-Ttext,0 -m32
+	$(TARGET_CC) -o $@ $< -DTARGET_NTLDR=1 -DSUCCESSFUL_BOOT_STRING=\"$(SUCCESSFUL_BOOT_STRING)\" -ffreestanding -nostdlib -nostdinc -Wl,--build-id=none -Wl,-N -Wl,-Ttext,0 -m32
 
 ntldr.bin: ntldr.elf
-	$(TARGET_OBJCOPY) -O binary --strip-unneeded -j .text $< $@;
+	$(TARGET_OBJCOPY) -O binary --strip-unneeded -R .note -R .comment -R .note.gnu.build-id -R .reginfo -R .rel.dyn -R .note.gnu.gold-version $< $@;
 
 multiboot2.elf: $(srcdir)/grub-core/tests/boot/kernel-i386.S $(srcdir)/grub-core/tests/boot/qemu-shutdown-x86.S
-	$(TARGET_CC) -static -o $@ $< -DSUCCESSFUL_BOOT_STRING=\"$(SUCCESSFUL_BOOT_STRING)\" -ffreestanding -nostdlib -nostdinc -Wl,--build-id=none -Wl,-N -Wl,-Ttext,0x100000 -m32 -I$(srcdir)/include -DTARGET_MULTIBOOT2=1
+	$(TARGET_CC) -o $@ $< -DSUCCESSFUL_BOOT_STRING=\"$(SUCCESSFUL_BOOT_STRING)\" -ffreestanding -nostdlib -nostdinc -Wl,--build-id=none -Wl,-N -Wl,-Ttext,0x100000 -m32 -I$(srcdir)/include -DTARGET_MULTIBOOT2=1
 
 kfreebsd.init.x86_64: $(srcdir)/grub-core/tests/boot/kfreebsd.init-x86_64.S $(srcdir)/grub-core/tests/boot/qemu-shutdown-x86.S
-	$(TARGET_CC) -o $@ $< -m64 -static -nostdlib -nostdinc -DSUCCESSFUL_BOOT_STRING=\"$(SUCCESSFUL_BOOT_STRING)\" && freebsd-brandelf -t FreeBSD $@
+	$(TARGET_CC) -o $@ $< -m64 -nostdlib -nostdinc -DSUCCESSFUL_BOOT_STRING=\"$(SUCCESSFUL_BOOT_STRING)\" && freebsd-brandelf -t FreeBSD $@
 
 kfreebsd.init.i386: $(srcdir)/grub-core/tests/boot/kfreebsd.init-i386.S $(srcdir)/grub-core/tests/boot/qemu-shutdown-x86.S
-	$(TARGET_CC) -o $@ $< -m32 -static -nostdlib -nostdinc -DSUCCESSFUL_BOOT_STRING=\"$(SUCCESSFUL_BOOT_STRING)\" && freebsd-brandelf -t FreeBSD $@
+	$(TARGET_CC) -o $@ $< -m32 -nostdlib -nostdinc -DSUCCESSFUL_BOOT_STRING=\"$(SUCCESSFUL_BOOT_STRING)\" && freebsd-brandelf -t FreeBSD $@
 
 knetbsd.init.i386: $(srcdir)/grub-core/tests/boot/kbsd.init-i386.S $(srcdir)/grub-core/tests/boot/qemu-shutdown-x86.S
-	$(TARGET_CC) -o $@ $< -m32 -static -nostdlib -nostdinc -DTARGET_NETBSD=1 -DSUCCESSFUL_BOOT_STRING=\"$(SUCCESSFUL_BOOT_STRING)\"
+	$(TARGET_CC) -o $@ $< -m32 -nostdlib -nostdinc -DTARGET_NETBSD=1 -DSUCCESSFUL_BOOT_STRING=\"$(SUCCESSFUL_BOOT_STRING)\"
 
 kopenbsd.init.i386: $(srcdir)/grub-core/tests/boot/kbsd.init-i386.S $(srcdir)/grub-core/tests/boot/qemu-shutdown-x86.S
-	$(TARGET_CC) -o $@ $< -m32 -static -nostdlib -nostdinc -DTARGET_OPENBSD=1 -DSUCCESSFUL_BOOT_STRING=\"$(SUCCESSFUL_BOOT_STRING)\"
+	$(TARGET_CC) -o $@ $< -m32 -nostdlib -nostdinc -DTARGET_OPENBSD=1 -DSUCCESSFUL_BOOT_STRING=\"$(SUCCESSFUL_BOOT_STRING)\"
 
 knetbsd.init.x86_64: $(srcdir)/grub-core/tests/boot/kbsd.init-x86_64.S $(srcdir)/grub-core/tests/boot/qemu-shutdown-x86.S
-	$(TARGET_CC) -o $@ $< -m64 -DTARGET_NETBSD=1 -static -nostdlib -nostdinc -DSUCCESSFUL_BOOT_STRING=\"$(SUCCESSFUL_BOOT_STRING)\"
+	$(TARGET_CC) -o $@ $< -m64 -DTARGET_NETBSD=1 -nostdlib -nostdinc -DSUCCESSFUL_BOOT_STRING=\"$(SUCCESSFUL_BOOT_STRING)\"
 
 kopenbsd.init.x86_64: $(srcdir)/grub-core/tests/boot/kbsd.init-x86_64.S $(srcdir)/grub-core/tests/boot/qemu-shutdown-x86.S
-	$(TARGET_CC) -o $@ $< -m64 -DTARGET_OPENBSD=1 -static -nostdlib -nostdinc -DSUCCESSFUL_BOOT_STRING=\"$(SUCCESSFUL_BOOT_STRING)\"
+	$(TARGET_CC) -o $@ $< -m64 -DTARGET_OPENBSD=1 -nostdlib -nostdinc -DSUCCESSFUL_BOOT_STRING=\"$(SUCCESSFUL_BOOT_STRING)\"
 
 linux-initramfs.mips: linux.init.mips Makefile
-	TDIR=`mktemp -d "$${TMPDIR:-/tmp}/tmp.XXXXXXXXXX"` && cp $< $$TDIR/init && (cd $$TDIR && echo ./init | cpio -R 0:0 --quiet --dereference -o -H newc) | gzip > $@ && rm -rf $$TDIR
+	TDIR=`mktemp -d "$${TMPDIR:-/tmp}/tmp.XXXXXXXXXX"` && cp $< $$TDIR/init && (cd $$TDIR && echo ./init | cpio --quiet --dereference -o -H newc) | gzip > $@ && rm -rf $$TDIR
 
 linux-initramfs.ppc: linux.init.ppc Makefile
-	TDIR=`mktemp -d "$${TMPDIR:-/tmp}/tmp.XXXXXXXXXX"` && cp $< $$TDIR/init && (cd $$TDIR && echo ./init | cpio -R 0:0 --quiet --dereference -o -H newc) | gzip > $@ && rm -rf $$TDIR
+	TDIR=`mktemp -d "$${TMPDIR:-/tmp}/tmp.XXXXXXXXXX"` && cp $< $$TDIR/init && (cd $$TDIR && echo ./init | cpio --quiet --dereference -o -H newc) | gzip > $@ && rm -rf $$TDIR
 
 linux-initramfs.mipsel: linux.init.mipsel Makefile
-	TDIR=`mktemp -d "$${TMPDIR:-/tmp}/tmp.XXXXXXXXXX"` && cp $< $$TDIR/init && (cd $$TDIR && echo ./init | cpio -R 0:0 --quiet --dereference -o -H newc) | gzip > $@ && rm -rf $$TDIR
+	TDIR=`mktemp -d "$${TMPDIR:-/tmp}/tmp.XXXXXXXXXX"` && cp $< $$TDIR/init && (cd $$TDIR && echo ./init | cpio --quiet --dereference -o -H newc) | gzip > $@ && rm -rf $$TDIR
 
 linux-initramfs.loongson: linux.init.loongson Makefile
-	TDIR=`mktemp -d "$${TMPDIR:-/tmp}/tmp.XXXXXXXXXX"` && cp $< $$TDIR/init && (cd $$TDIR && echo ./init | cpio -R 0:0 --quiet --dereference -o -H newc) | gzip > $@ && rm -rf $$TDIR
+	TDIR=`mktemp -d "$${TMPDIR:-/tmp}/tmp.XXXXXXXXXX"` && cp $< $$TDIR/init && (cd $$TDIR && echo ./init | cpio --quiet --dereference -o -H newc) | gzip > $@ && rm -rf $$TDIR
 
 linux-initramfs.i386: linux.init.i386 Makefile
-	TDIR=`mktemp -d "$${TMPDIR:-/tmp}/tmp.XXXXXXXXXX"` && cp $< $$TDIR/init && (cd $$TDIR && echo ./init | cpio -R 0:0 --quiet --dereference -o -H newc) | gzip > $@ && rm -rf $$TDIR
+	TDIR=`mktemp -d "$${TMPDIR:-/tmp}/tmp.XXXXXXXXXX"` && cp $< $$TDIR/init && (cd $$TDIR && echo ./init | cpio --quiet --dereference -o -H newc) | gzip > $@ && rm -rf $$TDIR
 
 linux-initramfs.x86_64: linux.init.x86_64 Makefile
-	TDIR=`mktemp -d "$${TMPDIR:-/tmp}/tmp.XXXXXXXXXX"` && cp $< $$TDIR/init && (cd $$TDIR && echo ./init | cpio -R 0:0 --quiet --dereference -o -H newc) | gzip > $@ && rm -rf $$TDIR
+	TDIR=`mktemp -d "$${TMPDIR:-/tmp}/tmp.XXXXXXXXXX"` && cp $< $$TDIR/init && (cd $$TDIR && echo ./init | cpio --quiet --dereference -o -H newc) | gzip > $@ && rm -rf $$TDIR
 
 kfreebsd-mfsroot.i386.img: kfreebsd.init.i386 Makefile
 	TDIR=`mktemp -d "$${TMPDIR:-/tmp}/tmp.XXXXXXXXXX"` && mkdir $$TDIR/dev && mkdir $$TDIR/sbin && cp $< $$TDIR/sbin/init && makefs -t ffs -s 30m -f 1000 -o minfree=0,version=1 $@ $$TDIR && rm -rf $$TDIR
@@ -313,7 +306,7 @@ bootcheck-knetbsd-x86_64: knetbsd.miniroot-image.x86_64.gz $(GRUB_PAYLOADS_DIR)/
 	./grub-shell --timeout=$(BOOTCHECK_TIMEOUT) --qemu=qemu-system-x86_64 --files=/miniroot.gz=knetbsd.miniroot-image.x86_64.gz --files=/knetbsd=$(GRUB_PAYLOADS_DIR)/knetbsd.x86_64 $(srcdir)/grub-core/tests/boot/knetbsd.cfg | grep $(SUCCESSFUL_BOOT_STRING) > /dev/null
 
 bootcheck-linux-i386: linux-initramfs.i386 $(GRUB_PAYLOADS_DIR)/linux.i386 $(srcdir)/grub-core/tests/boot/linux.cfg grub-shell
-	./grub-shell --timeout=$(BOOTCHECK_TIMEOUT) --qemu=$(QEMU32) --files=/initrd=linux-initramfs.i386 --files=/linux=$(GRUB_PAYLOADS_DIR)/linux.i386 $(srcdir)/grub-core/tests/boot/linux.cfg --qemu-opts="-cpu $(MINIMUM_CPU_LINUX)" | grep $(SUCCESSFUL_BOOT_STRING) > /dev/null
+	./grub-shell --timeout=$(BOOTCHECK_TIMEOUT) --qemu=$(QEMU32) --files=/initrd=linux-initramfs.i386 --files=/linux=$(GRUB_PAYLOADS_DIR)/linux.i386 $(srcdir)/grub-core/tests/boot/linux.cfg | grep $(SUCCESSFUL_BOOT_STRING) > /dev/null
 
 bootcheck-linux-x86_64: linux-initramfs.x86_64 $(GRUB_PAYLOADS_DIR)/linux.x86_64 $(srcdir)/grub-core/tests/boot/linux.cfg grub-shell
 	./grub-shell --timeout=$(BOOTCHECK_TIMEOUT) --qemu=qemu-system-x86_64 --files=/initrd=linux-initramfs.x86_64 --files=/linux=$(GRUB_PAYLOADS_DIR)/linux.x86_64 $(srcdir)/grub-core/tests/boot/linux.cfg | grep $(SUCCESSFUL_BOOT_STRING) > /dev/null
@@ -376,12 +369,6 @@ if COND_i386_coreboot
 BOOTCHECKS = bootcheck-kfreebsd-aout bootcheck-kopenbsd-i386 bootcheck-kopenbsd-x86_64 bootcheck-multiboot bootcheck-multiboot2 bootcheck-linux-i386 bootcheck-linux-x86_64 bootcheck-knetbsd-x86_64 bootcheck-kfreebsd-x86_64 bootcheck-kfreebsd-i386
 endif
 
-if COND_i386_ieee1275
-# *BSD requires ACPI
-#legacy protocol (linux16) makes early BIOS calls.
-BOOTCHECKS = bootcheck-kfreebsd-aout bootcheck-multiboot bootcheck-multiboot2 bootcheck-linux-i386 bootcheck-linux-x86_64
-endif
-
 if COND_i386_pc
 #pc chainloader by definition is only for i386-pc
 #ntldr and bootmgr require BIOS.

NEWS

@@ -51,8 +51,6 @@ New in 2.02:
   * Parse `nd' disk names in GRUB Legacy configuration files.
   * Issue separate DNS queries for IPv4 and IPv6.
   * Support IPv6 Router Advertisement to configure default router.
-  * New variable net_<interface>_next_server containing next server
-    from BOOTP reply.
 
 * Coreboot improvements:
   * CBFS support both in on-disk images (loopback) and flash.
@@ -173,7 +171,6 @@ New in 2.02:
   * Use fixed timestamp when generating GRUB image for reproducible builds.
   * Verify at build time that modules contain only supported relocations and their
     structure matches what boot-time module loader expects.
-  * Do not require fonts on powerpc-ieee1275.
 
 * Revision control moved to git.
 

acinclude.m4

@@ -390,58 +390,6 @@ else
 [fi]
 ])
 
-AC_DEFUN([grub_CHECK_LINK_PIE],[
-[# Position independent executable.
-link_nopie_needed=no]
-AC_MSG_CHECKING([whether linker needs disabling of PIE to work])
-AC_LANG_CONFTEST([AC_LANG_SOURCE([[]])])
-
-[if eval "$ac_compile -Wl,-r,-d -nostdlib -Werror -o conftest.o" 2> /dev/null; then]
-  AC_MSG_RESULT([no])
-  [# Should we clear up other files as well, having called `AC_LANG_CONFTEST'?
-  rm -f conftest.o
-else
-  link_nopie_needed=yes]
-  AC_MSG_RESULT([yes])
-[fi]
-])
-
-
-dnl Check if the Linker supports `-no-pie'.
-AC_DEFUN([grub_CHECK_NO_PIE],
-[AC_MSG_CHECKING([whether linker accepts -no-pie])
-AC_CACHE_VAL(grub_cv_cc_ld_no_pie,
-[save_LDFLAGS="$LDFLAGS"
-LDFLAGS="$LDFLAGS -no-pie -nostdlib -Werror"
-AC_LINK_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
-	       [grub_cv_cc_ld_no_pie=yes],
-	       [grub_cv_cc_ld_no_pie=no])
-LDFLAGS="$save_LDFLAGS"
-])
-AC_MSG_RESULT([$grub_cv_cc_ld_no_pie])
-nopie_possible=no
-if test "x$grub_cv_cc_ld_no_pie" = xyes ; then
-  nopie_possible=yes
-fi
-])
-
-AC_DEFUN([grub_CHECK_NO_PIE_ONEWORD],
-[AC_MSG_CHECKING([whether linker accepts -nopie])
-AC_CACHE_VAL(grub_cv_cc_ld_no_pie_oneword,
-[save_LDFLAGS="$LDFLAGS"
-LDFLAGS="$LDFLAGS -nopie -nostdlib -Werror"
-AC_LINK_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
-	       [grub_cv_cc_ld_no_pie_oneword=yes],
-	       [grub_cv_cc_ld_no_pie_oneword=no])
-LDFLAGS="$save_LDFLAGS"
-])
-AC_MSG_RESULT([$grub_cv_cc_ld_no_pie_oneword])
-nopie_oneword_possible=no
-if test "x$grub_cv_cc_ld_no_pie_oneword" = xyes ; then
-  nopie_oneword_possible=yes
-fi
-])
-
 dnl Check if the C compiler supports `-fPIC'.
 AC_DEFUN([grub_CHECK_PIC],[
 [# Position independent executable.

asm-tests/i386-pc.S

@@ -1,16 +1,12 @@
 /* on x86 old clang doesn't support .code16
    newer clang supports it but creates 6-byte jumps instead of 3-byte ones
-   which makes us go over boot sector size.
-   Starting with 3.9 clang emits 3-byte jumps but still creates 8-bytes movl
-   instead of 5-bytes, so code overflows into data.  */
+   which makes us go over boot sector size.  */
 
 	.code16
 	jmp far
 	.org 4
 	jmp nearer
 	.org 6
-	movl nearer, %ebx
-	.org 11
 	.space 100
 nearer:
 	.space 200

conf/Makefile.common

@@ -41,7 +41,7 @@ CCASFLAGS_KERNEL = $(CCASFLAGS_CPU) $(CCASFLAGS_PLATFORM)
 STRIPFLAGS_KERNEL = -R .rel.dyn -R .reginfo -R .note -R .comment -R .drectve -R .note.gnu.gold-version -R .MIPS.abiflags -R .ARM.exidx
 
 CFLAGS_MODULE = $(CFLAGS_PLATFORM) -ffreestanding
-LDFLAGS_MODULE = $(LDFLAGS_PLATFORM) -nostdlib $(TARGET_LDFLAGS_OLDMAGIC) $(TARGET_INCREMENTAL_LINK)
+LDFLAGS_MODULE = $(LDFLAGS_PLATFORM) -nostdlib $(TARGET_LDFLAGS_OLDMAGIC) -Wl,-r,-d
 CPPFLAGS_MODULE = $(CPPFLAGS_CPU) $(CPPFLAGS_PLATFORM)
 CCASFLAGS_MODULE = $(CCASFLAGS_CPU) $(CCASFLAGS_PLATFORM)
 

configure.ac

@@ -31,7 +31,7 @@ dnl (such as BUILD_CC, BUILD_CFLAGS, etc.) for the build type and variables
 dnl with the prefix "TARGET_" (such as TARGET_CC, TARGET_CFLAGS, etc.) are
 dnl used for the target type. See INSTALL for full list of variables.
 
-AC_INIT([GRUB],[2.03],[bug-grub@gnu.org])
+AC_INIT([GRUB],[2.02~beta3],[bug-grub@gnu.org])
 
 AC_CONFIG_AUX_DIR([build-aux])
 
@@ -373,10 +373,7 @@ case "$host_os" in
      ;;
   *)
      AC_CHECK_SIZEOF(off_t)
-     if test x"$ac_cv_sizeof_off_t" != x8 ; then
-       AC_CHECK_SIZEOF(off64_t)
-       test x"$ac_cv_sizeof_off64_t" = x8 || AC_MSG_ERROR([Large file support is required])
-     fi;;
+     test x"$ac_cv_sizeof_off_t" = x8 || AC_MSG_ERROR([Large file support is required]);;
 esac
 
 if test x$USE_NLS = xno; then
@@ -392,14 +389,7 @@ fi
 # Check for functions and headers.
 AC_CHECK_FUNCS(posix_memalign memalign getextmntent)
 AC_CHECK_HEADERS(sys/param.h sys/mount.h sys/mnttab.h limits.h)
-
-# glibc 2.25 still includes sys/sysmacros.h in sys/types.h but emits deprecation
-# warning which causes compilation failure later with -Werror. So use -Werror here
-# as well to force proper sys/sysmacros.h detection.
-SAVED_CFLAGS="$CFLAGS"
-CFLAGS="$HOST_CFLAGS -Werror"
 AC_HEADER_MAJOR
-CFLAGS="$SAVED_CFLAGS"
 
 AC_CHECK_MEMBERS([struct statfs.f_fstypename],,,[$ac_includes_default
 #include <sys/param.h>
@@ -459,16 +449,6 @@ case "$build_os" in
 esac
 AC_SUBST(BUILD_EXEEXT)
 
-# In some build environments like termux /bin/sh is not a valid
-# shebang. Use $SHELL instead if it's executable and /bin/sh isn't
-BUILD_SHEBANG=/bin/sh
-for she in /bin/sh "$SHELL"; do
-  if test -x "$she" ; then
-    BUILD_SHEBANG="$she"
-  fi
-done
-AC_SUBST(BUILD_SHEBANG)
-
 # For gnulib.
 gl_INIT
 
@@ -903,25 +883,6 @@ if test x"$target_cpu" = xsparc64 ; then
   TARGET_LDFLAGS="$TARGET_LDFLAGS $grub_cv_target_cc_mno_relax"
 fi
 
-AC_CACHE_CHECK([for incremental link options], grub_cv_target_cc_incremental_link, [
-  grub_cv_target_cc_incremental_link=no
-  for cand in "-Wl,-r,-d" "-static -Wl,-r,-d"; do
-    #AC_LINK_IFELSE doesn't handle non-executable output correctly
-    echo > conftest_inclink.c
-    if $TARGET_CC -o /dev/null $TARGET_CFLAGS $TARGET_CPPFLAGS $TARGET_LDFLAGS -nostdlib -Werror $cand conftest_inclink.c >&AS_MESSAGE_LOG_FD 2>&AS_MESSAGE_LOG_FD; then
-      grub_cv_target_cc_incremental_link="$cand"
-      break
-    fi
-  done
-])
-
-if test x"$grub_cv_target_cc_incremental_link" = xno ; then
-  AC_MSG_ERROR([could not find incremental link options])
-fi
-
-TARGET_INCREMENTAL_LINK="$grub_cv_target_cc_incremental_link"
-AC_SUBST(TARGET_INCREMENTAL_LINK)
-
 # By default, GCC 4.4 generates .eh_frame sections containing unwind
 # information in some cases where it previously did not. GRUB doesn't need
 # these and they just use up vital space. Restore the old compiler
@@ -1184,23 +1145,14 @@ if test "$target_cpu"-"$platform" = x86_64-efi; then
 fi
 
 if test "x$target_cpu" = xarm; then
-  AC_CACHE_CHECK([for options to disable movt and movw], grub_cv_target_cc_mno_movt, [
-    grub_cv_target_cc_mno_movt=no
-    for cand in "-mno-movt" \
-		"-mllvm -arm-use-movt=0"; do
-      if test x"$grub_cv_target_cc_mno_movt" != xno ; then
-        break
-      fi
-      CFLAGS="$TARGET_CFLAGS $cand -Werror"
-      CPPFLAGS="$TARGET_CPPFLAGS"
-      AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
-		        [grub_cv_target_cc_mno_movt="$cand"], [])
-    done
+  AC_CACHE_CHECK([whether option -mlong-calls works], grub_cv_cc_mlong_calls, [
+    CFLAGS="$TARGET_CFLAGS -mlong-calls -Werror"
+    AC_COMPILE_IFELSE([AC_LANG_PROGRAM([[]], [[]])],
+		      [grub_cv_cc_mlong_calls=yes],
+		      [grub_cv_cc_mlong_calls=no])
   ])
-
-  if test x"$grub_cv_target_cc_mno_movt" != xno ; then
-    # A trick so that clang doesn't see it on link stage
-    TARGET_CPPFLAGS="$TARGET_CPPFLAGS $grub_cv_target_cc_mno_movt"
+  if test "x$grub_cv_cc_mlong_calls" = xyes; then
+    TARGET_CFLAGS="$TARGET_CFLAGS -mlong-calls"
   fi
   AC_CACHE_CHECK([whether option -mthumb-interwork works], grub_cv_cc_mthumb_interwork, [
     CFLAGS="$TARGET_CFLAGS -mthumb-interwork -Werror"
@@ -1233,25 +1185,13 @@ CFLAGS="$TARGET_CFLAGS"
 
 # Position independent executable.
 grub_CHECK_PIE
-grub_CHECK_NO_PIE
-grub_CHECK_NO_PIE_ONEWORD
 [# Need that, because some distributions ship compilers that include
-# `-fPIE' or '-fpie' and '-pie' in the default specs.
+# `-fPIE' or '-fpie' in the default specs.
 if [ x"$pie_possible" = xyes ]; then
   TARGET_CFLAGS="$TARGET_CFLAGS -fno-PIE -fno-pie"
-fi
-
-if [ x"$link_nopie_needed" = xyes ] || [ x"$pie_possible" = xyes ]; then
-  if [ x"$nopie_possible" = xyes ]; then
-    TARGET_LDFLAGS="$TARGET_LDFLAGS -no-pie"
-  fi
-  if [ x"$nopie_oneword_possible" = xyes ]; then
-    TARGET_LDFLAGS="$TARGET_LDFLAGS -nopie"
-  fi
 fi]
 
 CFLAGS="$TARGET_CFLAGS"
-LDFLAGS="$TARGET_LDFLAGS"
 
 # Position independent executable.
 grub_CHECK_PIC
@@ -1260,12 +1200,9 @@ grub_CHECK_PIC
 # and reload $gp in every function.
 # GCC implements it using symbol __gnu_local_gp in non-PIC as well.
 # However with clang we need PIC for this reloading to happen.
-# With arm64 we need relocations that are in some way representable in
-# PE as we need to support arm64-efi. Without -fPIC clang generates
-# movk's which aren't representable.
 # Since default varies across dictributions use either -fPIC or -fno-PIC
 # explicitly.
-if ( test x$target_cpu = xmips || test x$target_cpu = xmipsel || test x$target_cpu = xarm64 ) && test "x$grub_cv_cc_target_clang" = xyes ; then
+if ( test x$target_cpu = xmips || test x$target_cpu = xmipsel ) && test "x$grub_cv_cc_target_clang" = xyes ; then
    TARGET_CFLAGS="$TARGET_CFLAGS -fPIC"
 elif [ x"$pic_possible" = xyes ]; then
    TARGET_CFLAGS="$TARGET_CFLAGS -fno-PIC"
@@ -1618,11 +1555,11 @@ if test x"$grub_build_mkfont_excuse" = x ; then
 else
   enable_build_grub_mkfont=no
 fi
-if test x"$enable_build_grub_mkfont" = xno && ( test "x$platform" = xqemu || test "x$platform" = xloongson || test "x$platform" = xqemu_mips || test "x$platform" = xcoreboot ); then
+if test x"$enable_build_grub_mkfont" = xno && ( test "x$platform" = xqemu || test "x$platform" = xloongson || test "x$platform" = xqemu_mips || test "x$target_cpu"-"$platform" = xpowerpc-ieee1275 || test "x$platform" = xcoreboot ); then
   if test x"$grub_build_mkfont_excuse" = x ; then
-    AC_MSG_ERROR([qemu, coreboot and loongson ports need build-time grub-mkfont])
+    AC_MSG_ERROR([qemu, powerpc-ieee1275, coreboot and loongson ports needs build-time grub-mkfont])
   else
-    AC_MSG_ERROR([qemu, coreboot and loongson ports need build-time grub-mkfont ($grub_build_mkfont_excuse)])
+    AC_MSG_ERROR([qemu, powerpc-ieee1275, coreboot and loongson ports needs build-time grub-mkfont ($grub_build_mkfont_excuse)])
   fi
 fi
 
@@ -1692,11 +1629,11 @@ if test x"$enable_build_grub_mkfont" = xno ; then
   FONT_SOURCE=
 fi
 
-if test "x$FONT_SOURCE" = x && ( test "x$platform" = xqemu || test "x$platform" = xloongson || test "x$platform" = xqemu_mips || test "x$platform" = xcoreboot ); then
+if test "x$FONT_SOURCE" = x && ( test "x$platform" = xqemu || test "x$platform" = xloongson || test "x$platform" = xqemu_mips || test "x$target_cpu"-"$platform" = xpowerpc-ieee1275 || test "x$platform" = xcoreboot ); then
   if test x"$grub_build_mkfont_excuse" = x ; then
-    AC_MSG_ERROR([qemu, coreboot and loongson ports need unifont])
+    AC_MSG_ERROR([qemu, powerpc-ieee1275, coreboot and loongson ports need unifont])
   else
-    AC_MSG_ERROR([qemu, coreboot and loongson ports need unifont ($grub_build_mkfont_excuse)])
+    AC_MSG_ERROR([qemu, powerpc-ieee1275, coreboot and loongson ports need unifont ($grub_build_mkfont_excuse)])
   fi
 fi
 

docs/grub.texi

@@ -2446,10 +2446,6 @@ The boot file name provided by DHCP.  Read-only.
 The name of the DHCP server responsible for these boot parameters.
 Read-only.
 
-@item net_@var{<interface>}_next_server
-The IP address of the next (usually, TFTP) server provided by DHCP.
-Read-only.
-
 @item net_default_interface
 Initially set to name of network interface that was used to load grub.
 Read-write, although setting it affects only interpretation of
@@ -3066,7 +3062,6 @@ These variables have special meaning to GRUB.
 * net_@var{<interface>}_hostname::
 * net_@var{<interface>}_ip::
 * net_@var{<interface>}_mac::
-* net_@var{<interface>}_next_server::
 * net_@var{<interface>}_rootpath::
 * net_default_interface::
 * net_default_ip::
@@ -3218,10 +3213,9 @@ source for more details.
 @node default
 @subsection default
 
-If this variable is set, it identifies a menu entry that should be
-selected by default, possibly after a timeout (@pxref{timeout}).  The
-entry may be identified by number (starting from 0 at each level of
-the hierarchy), by title, or by id.
+If this variable is set, it identifies a menu entry that should be selected
+by default, possibly after a timeout (@pxref{timeout}).  The entry may be
+identified by number or by id.
 
 For example, if you have:
 
@@ -3237,26 +3231,24 @@ then you can make this the default using:
 default=example-gnu-linux
 @end example
 
-If the entry is in a submenu, then it must be identified using the
-number, title, or id of each of the submenus starting from the top
-level, followed by the number, title, or id of the menu entry itself,
-with each element separated by @samp{>}.  For example, take the
-following menu structure:
+If the entry is in a submenu, then it must be identified using the titles of
+each of the submenus starting from the top level followed by the number or
+title of the menu entry itself, separated by @samp{>}.  For example, take
+the following menu structure:
 
 @example
-GNU/Hurd --id gnu-hurd
-  Standard Boot --id=gnu-hurd-std
-  Rescue shell --id=gnu-hurd-rescue
-Other platforms --id=other
-  Minix --id=minix
-    Version 3.4.0 --id=minix-3.4.0
-    Version 3.3.0 --id=minix-3.3.0
-  GRUB Invaders --id=grub-invaders
+Submenu 1
+  Menu Entry 1
+  Menu Entry 2
+Submenu 2
+  Submenu 3
+    Menu Entry 3
+    Menu Entry 4
+  Menu Entry 5
 @end example
 
-The more recent release of Minix would then be identified as
-@samp{Other platforms>Minix>Version 3.4.0}, or as @samp{1>0>0}, or as
-@samp{other>minix>minix-3.4.0}.
+``Menu Entry 3'' would then be identified as
+@samp{Submenu 2>Submenu 3>Menu Entry 3}.
 
 This variable is often set by @samp{GRUB_DEFAULT} (@pxref{Simple
 configuration}), @command{grub-set-default}, or @command{grub-reboot}.
@@ -3430,12 +3422,6 @@ The default is the value of @samp{color_normal} (@pxref{color_normal}).
 @xref{Network}.
 
 
-@node net_@var{<interface>}_next_server
-@subsection net_@var{<interface>}_next_server
-
-@xref{Network}.
-
-
 @node net_@var{<interface>}_rootpath
 @subsection net_@var{<interface>}_rootpath
 

grub-core/Makefile.am

@@ -278,7 +278,7 @@ BUILT_SOURCES += symlist.h
 
 symlist.c: symlist.h gensymlist.sh
 	$(TARGET_CPP) $(DEFS) $(INCLUDES) $(AM_CPPFLAGS) $(CPPFLAGS_KERNEL) $(CPPFLAGS) -DGRUB_SYMBOL_GENERATOR=1 symlist.h > symlist.p || (rm -f symlist.p; exit 1)
-	cat symlist.p | $(SHELL) $(srcdir)/gensymlist.sh $(top_builddir)/config.h $(KERNEL_HEADER_FILES) >$@ || (rm -f $@; exit 1)
+	cat symlist.p | /bin/sh $(srcdir)/gensymlist.sh $(top_builddir)/config.h $(KERNEL_HEADER_FILES) >$@ || (rm -f $@; exit 1)
 	rm -f symlist.p
 CLEANFILES += symlist.c
 BUILT_SOURCES += symlist.c

grub-core/Makefile.core.def

@@ -49,20 +49,20 @@ kernel = {
 
   nostrip = emu;
 
-  emu_ldflags              = '$(TARGET_INCREMENTAL_LINK)';
-  i386_efi_ldflags         = '$(TARGET_INCREMENTAL_LINK)';
+  emu_ldflags              = '-Wl,-r,-d';
+  i386_efi_ldflags         = '-Wl,-r,-d';
   i386_efi_stripflags      = '--strip-unneeded -K start -R .note -R .comment -R .note.gnu.gold-version';
-  x86_64_efi_ldflags       = '$(TARGET_INCREMENTAL_LINK)';
+  x86_64_efi_ldflags       = '-Wl,-r,-d';
   x86_64_efi_stripflags    = '--strip-unneeded -K start -R .note -R .comment -R .note.gnu.gold-version';
 
   ia64_efi_cflags = '-fno-builtin -fpic -minline-int-divide-max-throughput';
-  ia64_efi_ldflags = '$(TARGET_INCREMENTAL_LINK)';
+  ia64_efi_ldflags = '-Wl,-r,-d';
   ia64_efi_stripflags = '--strip-unneeded -K start -R .note -R .comment -R .note.gnu.gold-version';
 
-  arm_efi_ldflags          = '$(TARGET_INCREMENTAL_LINK)';
+  arm_efi_ldflags          = '-Wl,-r,-d';
   arm_efi_stripflags       = '--strip-unneeded -K start -R .note -R .comment -R .note.gnu.gold-version';
 
-  arm64_efi_ldflags          = '$(TARGET_INCREMENTAL_LINK)';
+  arm64_efi_ldflags          = '-Wl,-r,-d';
   arm64_efi_stripflags       = '--strip-unneeded -K start -R .note -R .comment -R .note.gnu.gold-version -R .eh_frame';
 
   i386_pc_ldflags          = '$(TARGET_IMG_LDFLAGS)';
@@ -90,7 +90,7 @@ kernel = {
   i386_qemu_cppflags     = '-DGRUB_BOOT_MACHINE_LINK_ADDR=$(GRUB_BOOT_MACHINE_LINK_ADDR)';
   emu_cflags = '$(CFLAGS_GNULIB)';
   emu_cppflags = '$(CPPFLAGS_GNULIB)';
-  arm_uboot_ldflags       = '$(TARGET_INCREMENTAL_LINK)';
+  arm_uboot_ldflags       = '-Wl,-r,-d';
   arm_uboot_stripflags    = '--strip-unneeded -K start -R .note -R .comment -R .note.gnu.gold-version';
 
   i386_pc_startup = kern/i386/pc/startup.S;
@@ -212,10 +212,8 @@ kernel = {
 
   arm_efi = kern/arm/efi/init.c;
   arm_efi = kern/arm/efi/misc.c;
-  arm_efi = kern/efi/fdt.c;
 
   arm64_efi = kern/arm64/efi/init.c;
-  arm64_efi = kern/efi/fdt.c;
 
   i386_pc = kern/i386/pc/init.c;
   i386_pc = kern/i386/pc/mmap.c;
@@ -1533,7 +1531,6 @@ module = {
   i386_xen = lib/i386/xen/relocator.S;
   x86_64_xen = lib/x86_64/xen/relocator.S;
   xen = lib/i386/relocator_common_c.c;
-  x86_64_efi = lib/x86_64/efi/relocator.c;
 
   extra_dist = lib/i386/relocator_common.S;
   extra_dist = kern/powerpc/cache_flush.S;
@@ -1961,11 +1958,6 @@ module = {
   common = tests/example_functional_test.c;
 };
 
-module = {
-  name = strtoull_test;
-  common = tests/strtoull_test.c;
-};
-
 module = {
   name = setjmp_test;
   common = tests/setjmp_test.c;

grub-core/commands/acpi.c

@@ -761,10 +761,10 @@ grub_cmd_acpi (struct grub_extcmd_context *ctxt, int argc, char **args)
     struct grub_efi_guid acpi = GRUB_EFI_ACPI_TABLE_GUID;
     struct grub_efi_guid acpi20 = GRUB_EFI_ACPI_20_TABLE_GUID;
 
-    efi_call_2 (grub_efi_system_table->boot_services->install_configuration_table,
-      &acpi20, grub_acpi_get_rsdpv2 ());
-    efi_call_2 (grub_efi_system_table->boot_services->install_configuration_table,
-      &acpi, grub_acpi_get_rsdpv1 ());
+    grub_efi_system_table->boot_services->install_configuration_table
+      (&acpi20, grub_acpi_get_rsdpv2 ());
+    grub_efi_system_table->boot_services->install_configuration_table
+      (&acpi, grub_acpi_get_rsdpv1 ());
   }
 #endif
 

grub-core/commands/hdparm.c

@@ -328,7 +328,6 @@ grub_cmd_hdparm (grub_extcmd_context_t ctxt, int argc, char **args)
 	  ata = ((struct grub_scsi *) disk->data)->data;
 	  break;
 	}
-      /* FALLTHROUGH */
     default:
       grub_disk_close (disk);
       return grub_error (GRUB_ERR_IO, "not an ATA device");

grub-core/commands/legacycfg.c

@@ -517,7 +517,7 @@ grub_cmd_legacy_initrd (struct grub_command *mycmd __attribute__ ((unused)),
 #endif
 			   );
 
-      return cmd->func (cmd, argc ? 1 : 0, args);
+      return cmd->func (cmd, argc, args);
     }
   if (kernel_type == MULTIBOOT)
     {

grub-core/commands/nativedisk.c

@@ -79,7 +79,6 @@ get_uuid (const char *name, char **uuid, int getnative)
     case GRUB_DISK_DEVICE_XEN:
       if (getnative)
 	break;
-      /* FALLTHROUGH */
 
       /* Virtual disks.  */
       /* GRUB dynamically generated files.  */

grub-core/disk/cryptodisk.c

@@ -282,7 +282,6 @@ grub_cryptodisk_endecrypt (struct grub_cryptodisk *dev,
 	  break;
 	case GRUB_CRYPTODISK_MODE_IV_PLAIN64:
 	  iv[1] = grub_cpu_to_le32 (sector >> 32);
-	  /* FALLTHROUGH */
 	case GRUB_CRYPTODISK_MODE_IV_PLAIN:
 	  iv[0] = grub_cpu_to_le32 (sector & 0xFFFFFFFF);
 	  break;

grub-core/disk/efi/efidisk.c

@@ -80,15 +80,6 @@ make_devices (void)
 	/* This should not happen... Why?  */
 	continue;
 
-      /* iPXE adds stub Block IO protocol to loaded image device handle. It is
-         completely non-functional and simply returns an error for every method.
-        So attempt to detect and skip it. Magic number is literal "iPXE" and
-        check block size as well */
-      /* FIXME: shoud we close it? We do not do it elsewhere */
-      if (bio->media && bio->media->media_id == 0x69505845U &&
-         bio->media->block_size == 1)
-         continue;
-
       d = grub_malloc (sizeof (*d));
       if (! d)
 	{
@@ -224,7 +215,7 @@ name_devices (struct grub_efidisk_data *devices)
 	    {
 	    case GRUB_EFI_HARD_DRIVE_DEVICE_PATH_SUBTYPE:
 	      is_hard_drive = 1;
-	      /* Intentionally fall through.  */
+	      /* Fall through by intention.  */
 	    case GRUB_EFI_CDROM_DEVICE_PATH_SUBTYPE:
 	      {
 		struct grub_efidisk_data *parent, *parent2;

grub-core/efiemu/mm.c

@@ -417,7 +417,6 @@ fill_hook (grub_uint64_t addr, grub_uint64_t size, grub_memory_type_t type,
       default:
 	grub_dprintf ("efiemu",
 		      "Unknown memory type %d. Assuming unusable\n", type);
-	/* FALLTHROUGH */
       case GRUB_MEMORY_RESERVED:
 	return grub_efiemu_add_to_mmap (addr, size,
 					GRUB_EFI_UNUSABLE_MEMORY);

grub-core/fs/btrfs.c

@@ -227,11 +227,11 @@ grub_btrfs_read_logical (struct grub_btrfs_data *data,
 static grub_err_t
 read_sblock (grub_disk_t disk, struct grub_btrfs_superblock *sb)
 {
-  struct grub_btrfs_superblock sblock;
   unsigned i;
   grub_err_t err = GRUB_ERR_NONE;
   for (i = 0; i < ARRAY_SIZE (superblock_sectors); i++)
     {
+      struct grub_btrfs_superblock sblock;
       /* Don't try additional superblocks beyond device size.  */
       if (i && (grub_le_to_cpu64 (sblock.this_device.size)
 		>> GRUB_DISK_SECTOR_BITS) <= superblock_sectors[i])

grub-core/fs/ext2.c

@@ -89,6 +89,9 @@ GRUB_MOD_LICENSE ("GPLv3+");
 #define EXT4_FEATURE_RO_COMPAT_GDT_CSUM		0x0010
 #define EXT4_FEATURE_RO_COMPAT_DIR_NLINK	0x0020
 #define EXT4_FEATURE_RO_COMPAT_EXTRA_ISIZE	0x0040
+#define EXT4_FEATURE_RO_COMPAT_QUOTA            0x0100
+#define EXT4_FEATURE_RO_COMPAT_BIGALLOC         0x0200
+#define EXT4_FEATURE_RO_COMPAT_METADATA_CSUM    0x0400
 /* Superblock filesystem feature flags (back-incompatible)
  * A filesystem with any of these enabled should not be attempted to be read
  * by a driver that does not understand them, since they usually indicate
@@ -102,6 +105,11 @@ GRUB_MOD_LICENSE ("GPLv3+");
 #define EXT4_FEATURE_INCOMPAT_64BIT		0x0080
 #define EXT4_FEATURE_INCOMPAT_MMP		0x0100
 #define EXT4_FEATURE_INCOMPAT_FLEX_BG		0x0200
+#define EXT4_FEATURE_INCOMPAT_EA_INODE          0x0400 /* EA in inode */
+#define EXT4_FEATURE_INCOMPAT_DIRDATA           0x1000 /* data in dirent */
+#define EXT4_FEATURE_INCOMPAT_BG_USE_META_CSUM  0x2000 /* use crc32c for bg */
+#define EXT4_FEATURE_INCOMPAT_LARGEDIR          0x4000 /* >2GB or 3-lvl htree */
+#define EXT4_FEATURE_INCOMPAT_INLINE_DATA       0x8000 /* data in inode */
 
 /* The set of back-incompatible features this driver DOES support. Add (OR)
  * flags here as the related features are implemented into the driver.  */
@@ -109,7 +117,8 @@ GRUB_MOD_LICENSE ("GPLv3+");
                                        | EXT4_FEATURE_INCOMPAT_EXTENTS  \
                                        | EXT4_FEATURE_INCOMPAT_FLEX_BG \
                                        | EXT2_FEATURE_INCOMPAT_META_BG \
-                                       | EXT4_FEATURE_INCOMPAT_64BIT)
+                                       | EXT4_FEATURE_INCOMPAT_64BIT \
+				       | EXT4_FEATURE_INCOMPAT_INLINE_DATA)
 /* List of rationales for the ignored "incompatible" features:
  * needs_recovery: Not really back-incompatible - was added as such to forbid
  *                 ext2 drivers from mounting an ext3 volume with a dirty
@@ -316,12 +325,40 @@ struct grub_ext4_extent_idx
   grub_uint16_t unused;
 };
 
+#define EXT4_XATTR_MAGIC	0xEA020000
+#define EXT4_XATTR_INDEX_SYSTEM	7
+#define EXT4_XATTR_SYSTEM_DATA	"data"
+#define EXT4_INLINE_DOTDOT_SIZE	4
+
+struct grub_ext4_xattr_entry
+{
+  grub_uint8_t name_len;	/* length of name */
+  grub_uint8_t name_index;	/* attribute name index */
+  grub_uint16_t value_offs;	/* offset in disk block of value */
+  grub_uint32_t value_block;	/* disk block attribute is stored on */
+  grub_uint32_t value_size;	/* size of attribute value */
+  grub_uint32_t hash;		/* hash value of name and value */
+  char name[0];			/* attribute name */
+} GRUB_PACKED;
+
+#define EXT4_XATTR_LEN(name_len) \
+  (ALIGN_UP((name_len) + sizeof(struct grub_ext4_xattr_entry), 4))
+#define EXT4_XATTR_NEXT(entry) \
+  ((struct grub_ext4_xattr_entry *)( \
+   (char *)(entry) + EXT4_XATTR_LEN((entry)->name_len)))
+#define IS_LAST_ENTRY(entry) (grub_get_unaligned32 (entry) == 0)
+
+
 struct grub_fshelp_node
 {
   struct grub_ext2_data *data;
   struct grub_ext2_inode inode;
-  int ino;
+  grub_uint32_t ino;
   int inode_read;
+  grub_disk_addr_t inode_base;	/* Inode filesystem block */
+  grub_off_t inode_offs;	/* Inode offset in filesystem block */
+  grub_off_t inline_offs;	/* Offset of inline data from start of inode */
+  grub_size_t inline_size;	/* Size of inline data */
 };
 
 /* Information about a "mounted" ext2 filesystem.  */
@@ -367,6 +404,66 @@ group_has_super_block (struct grub_ext2_data *data, grub_uint64_t group)
 	  is_power_of(group, 3));
 }
 
+/* Inline data is stored using inline extended attributes. Attributes consist
+   of entry and value. Entries start after inode proper, following 4 bytes
+   magic header. Each entry is 4 bytes aligned, end of list is marked with
+   4 bytes zero. Values are stored after entries.
+
+   Inline data is stored as system attribute with name "data". First part of
+   data is kept in space reserved for block pointers, so it is valid for value
+   size to be zero. Offset is apparently non-zero even in this case.
+ */
+inline static void
+grub_ext2_find_inline_data (struct grub_fshelp_node *node, grub_size_t isize,
+			    struct grub_ext2_inode *inode)
+{
+  grub_size_t extra;
+  grub_uint8_t *ihdr;
+  struct grub_ext4_xattr_entry *entry;
+  grub_uint8_t *iend = (grub_uint8_t *) inode + isize - sizeof (grub_uint32_t);
+
+  node->inline_offs = 0;
+
+  if (isize < EXT2_GOOD_OLD_INODE_SIZE + sizeof (grub_uint16_t))
+    return;
+  extra = grub_le_to_cpu16 (*((grub_uint16_t *) inode
+			      + (EXT2_GOOD_OLD_INODE_SIZE / 2)));
+  if (EXT2_GOOD_OLD_INODE_SIZE + extra + 4 > isize)
+    return;
+  ihdr = ((grub_uint8_t *) inode
+	  + EXT2_GOOD_OLD_INODE_SIZE + extra);
+  if (grub_get_unaligned32 (ihdr)
+      != grub_cpu_to_le32_compile_time (EXT4_XATTR_MAGIC))
+    return;
+  entry = (struct grub_ext4_xattr_entry *) (ihdr + 4);
+  for (; (grub_uint8_t *) entry < iend && !IS_LAST_ENTRY(entry);
+       entry = EXT4_XATTR_NEXT(entry))
+    {
+      grub_size_t value_size;
+      grub_off_t value_offs;
+
+      if (entry->value_block)
+	continue;
+      if (entry->name_index != EXT4_XATTR_INDEX_SYSTEM)
+	continue;
+      if (entry->name_len != sizeof (EXT4_XATTR_SYSTEM_DATA) - 1)
+	continue;
+      if (grub_memcmp (entry->name, EXT4_XATTR_SYSTEM_DATA, sizeof (EXT4_XATTR_SYSTEM_DATA) - 1))
+	continue;
+      value_size = grub_le_to_cpu32 (entry->value_size);
+      value_offs = grub_le_to_cpu16 (entry->value_offs);
+      /* extra is additional size of base inode. Extended attributes start
+	 after base inode, offset is calculated from the end of extended
+	 attributes header.
+      */
+      if (EXT2_GOOD_OLD_INODE_SIZE + extra + 4 + value_offs + value_size > isize)
+	continue;
+      node->inline_offs = EXT2_GOOD_OLD_INODE_SIZE + extra + 4 + value_offs;
+      node->inline_size = value_size;
+      return;
+    }
+}
+
 /* Read into BLKGRP the blockgroup descriptor of blockgroup GROUP of
    the mounted filesystem DATA.  */
 inline static grub_err_t
@@ -568,6 +665,52 @@ grub_ext2_read_file (grub_fshelp_node_t node,
 		     grub_disk_read_hook_t read_hook, void *read_hook_data,
 		     grub_off_t pos, grub_size_t len, char *buf)
 {
+  /* Does inode have inine data? */
+  if (node->inline_offs)
+    {
+      grub_size_t cp_len;
+      grub_off_t cp_pos;
+      grub_ssize_t total = 0;
+
+      if (pos < 60)
+	{
+	  cp_pos = node->inode_offs + ((char *)&node->inode.blocks - (char *)&node->inode) + pos;
+	  cp_len = 60 - pos;
+	  if (cp_len > len)
+	    cp_len = len;
+
+	  node->data->disk->read_hook = read_hook;
+	  node->data->disk->read_hook_data = read_hook_data;
+	  grub_disk_read (node->data->disk, node->inode_base, cp_pos,
+			  cp_len, buf);
+	  node->data->disk->read_hook = 0;
+	  if (grub_errno)
+	    return -1;
+	  pos += cp_len;
+	  buf += cp_len;
+	  len -= cp_len;
+	  total = cp_len;
+	}
+
+      if (len)
+	{
+	  pos -= 60;
+	  if (pos >= node->inline_size)
+	    return 0;
+	  if (pos + len > node->inline_size)
+	    len = node->inline_size - pos;
+	  cp_pos = node->inode_offs + node->inline_offs + pos;
+	  node->data->disk->read_hook = read_hook;
+	  node->data->disk->read_hook_data = read_hook_data;
+	  grub_disk_read (node->data->disk, node->inode_base, cp_pos,
+			  len, buf);
+	  node->data->disk->read_hook = 0;
+          if (!grub_errno)
+	    total += len;
+	}
+      return total;
+    }
+
   return grub_fshelp_read_file (node->data->disk, node,
 				read_hook, read_hook_data,
 				pos, len, buf, grub_ext2_read_block,
@@ -578,17 +721,28 @@ grub_ext2_read_file (grub_fshelp_node_t node,
 }
 
 
-/* Read the inode INO for the file described by DATA into INODE.  */
+/* Read the inode NODE->INO for the file described by NODE->DATA into NODE->INODE.  */
 static grub_err_t
-grub_ext2_read_inode (struct grub_ext2_data *data,
-		      int ino, struct grub_ext2_inode *inode)
+grub_ext2_read_inode (struct grub_fshelp_node *node)
 {
+  struct grub_ext2_data *data = node->data;
+  grub_uint32_t ino = node->ino;
   struct grub_ext2_block_group blkgrp;
   struct grub_ext2_sblock *sblock = &data->sblock;
   int inodes_per_block;
   unsigned int blkno;
   unsigned int blkoff;
   grub_disk_addr_t base;
+  struct grub_ext2_inode *full_inode;
+  grub_size_t full_isize;
+
+  if (node->inode_read)
+    return 0;
+
+  full_isize = EXT2_INODE_SIZE (data);
+  full_inode = grub_malloc (full_isize);
+  if (!full_inode)
+    return 0;
 
   /* It is easier to calculate if the first inode is 0.  */
   ino--;
@@ -597,9 +751,12 @@ grub_ext2_read_inode (struct grub_ext2_data *data,
                         ino / grub_le_to_cpu32 (sblock->inodes_per_group),
 			&blkgrp);
   if (grub_errno)
-    return grub_errno;
+    {
+      grub_free (full_inode);
+      return grub_errno;
+    }
 
-  inodes_per_block = EXT2_BLOCK_SIZE (data) / EXT2_INODE_SIZE (data);
+  inodes_per_block = EXT2_BLOCK_SIZE (data) / full_isize;
   blkno = (ino % grub_le_to_cpu32 (sblock->inodes_per_group))
     / inodes_per_block;
   blkoff = (ino % grub_le_to_cpu32 (sblock->inodes_per_group))
@@ -611,12 +768,19 @@ grub_ext2_read_inode (struct grub_ext2_data *data,
 	     << 32);
 
   /* Read the inode.  */
-  if (grub_disk_read (data->disk,
-		      ((base + blkno) << LOG2_EXT2_BLOCK_SIZE (data)),
-		      EXT2_INODE_SIZE (data) * blkoff,
-		      sizeof (struct grub_ext2_inode), inode))
-    return grub_errno;
+  node->inode_base = (base + blkno) << LOG2_EXT2_BLOCK_SIZE (data);
+  node->inode_offs = full_isize * blkoff;
+  if (grub_disk_read (data->disk, node->inode_base, node->inode_offs,
+		      full_isize, full_inode))
+    {
+      grub_free (full_inode);
+      return grub_errno;
+    }
+  grub_memcpy (&node->inode, full_inode, sizeof (struct grub_ext2_inode));
 
+  node->inode_read = 1;
+  grub_ext2_find_inline_data (node, full_isize, full_inode);
+  grub_free (full_inode);  
   return 0;
 }
 
@@ -677,11 +841,9 @@ grub_ext2_mount (grub_disk_t disk)
 
   data->diropen.data = data;
   data->diropen.ino = 2;
-  data->diropen.inode_read = 1;
-
   data->inode = &data->diropen.inode;
 
-  grub_ext2_read_inode (data, 2, data->inode);
+  grub_ext2_read_inode (&data->diropen);
   if (grub_errno)
     goto fail;
 
@@ -701,12 +863,9 @@ grub_ext2_read_symlink (grub_fshelp_node_t node)
   char *symlink;
   struct grub_fshelp_node *diro = node;
 
-  if (! diro->inode_read)
-    {
-      grub_ext2_read_inode (diro->data, diro->ino, &diro->inode);
-      if (grub_errno)
-	return 0;
-    }
+  grub_ext2_read_inode (diro);
+  if (grub_errno)
+    return 0;
 
   symlink = grub_malloc (grub_le_to_cpu32 (diro->inode.size) + 1);
   if (! symlink)
@@ -742,11 +901,42 @@ grub_ext2_iterate_dir (grub_fshelp_node_t dir,
   unsigned int fpos = 0;
   struct grub_fshelp_node *diro = (struct grub_fshelp_node *) dir;
 
-  if (! diro->inode_read)
+  grub_ext2_read_inode (diro);
+  if (grub_errno)
+    return 0;
+
+  /* Inline directory has only parent inode number and no explicit entries
+     for . or ..; simulate them */
+  if (diro->inline_offs)
     {
-      grub_ext2_read_inode (diro->data, diro->ino, &diro->inode);
+      struct grub_fshelp_node *dot, *dotdot;
+      grub_uint32_t inum;
+
+      dot = grub_malloc (sizeof (struct grub_fshelp_node));
+      if (!dot)
+	return 0;
+
+      dot->inode_read = 0;
+      dot->ino = dir->ino;
+      dot->data = diro->data;
+      if (hook (".", FILETYPE_DIRECTORY, dot, hook_data))
+	return 1;
+
+      /* First 4 bytes of inline directory data is parent inode number */
+      grub_ext2_read_file (diro, 0, 0, 0, EXT4_INLINE_DOTDOT_SIZE, (char *) &inum);
       if (grub_errno)
 	return 0;
+      dotdot = grub_malloc (sizeof (struct grub_fshelp_node));
+      if (!dotdot)
+	return 0;
+
+      dotdot->inode_read = 0;
+      dotdot->ino = grub_le_to_cpu32 (inum);
+      dotdot->data = diro->data;
+      if (hook ("..", FILETYPE_DIRECTORY, dotdot, hook_data))
+	return 1;
+
+      fpos = EXT4_INLINE_DOTDOT_SIZE;
     }
 
   /* Search the file.  */
@@ -797,17 +987,13 @@ grub_ext2_iterate_dir (grub_fshelp_node_t dir,
 	    {
 	      /* The filetype can not be read from the dirent, read
 		 the inode to get more information.  */
-	      grub_ext2_read_inode (diro->data,
-                                    grub_le_to_cpu32 (dirent.inode),
-				    &fdiro->inode);
+	      grub_ext2_read_inode (fdiro);
 	      if (grub_errno)
 		{
 		  grub_free (fdiro);
 		  return 0;
 		}
 
-	      fdiro->inode_read = 1;
-
 	      if ((grub_le_to_cpu16 (fdiro->inode.mode)
 		   & FILETYPE_INO_MASK) == FILETYPE_INO_DIRECTORY)
 		type = GRUB_FSHELP_DIR;
@@ -852,14 +1038,11 @@ grub_ext2_open (struct grub_file *file, const char *name)
   if (err)
     goto fail;
 
-  if (! fdiro->inode_read)
-    {
-      err = grub_ext2_read_inode (data, fdiro->ino, &fdiro->inode);
-      if (err)
-	goto fail;
-    }
+  err = grub_ext2_read_inode (fdiro);
+  if (err)
+    goto fail;
 
-  grub_memcpy (data->inode, &fdiro->inode, sizeof (struct grub_ext2_inode));
+  grub_memcpy (&data->diropen, fdiro, sizeof (struct grub_fshelp_node));
   grub_free (fdiro);
 
   file->size = grub_le_to_cpu32 (data->inode->size);
@@ -918,13 +1101,9 @@ grub_ext2_dir_iter (const char *filename, enum grub_fshelp_filetype filetype,
   struct grub_dirhook_info info;
 
   grub_memset (&info, 0, sizeof (info));
-  if (! node->inode_read)
-    {
-      grub_ext2_read_inode (ctx->data, node->ino, &node->inode);
-      if (!grub_errno)
-	node->inode_read = 1;
-      grub_errno = GRUB_ERR_NONE;
-    }
+  grub_ext2_read_inode (node);
+  grub_errno = GRUB_ERR_NONE;
+
   if (node->inode_read)
     {
       info.mtimeset = 1;

grub-core/fs/fat.c

@@ -189,11 +189,7 @@ struct grub_fshelp_node {
   struct grub_fat_data *data;
 
   grub_uint8_t attr;
-#ifndef MODE_EXFAT
-  grub_uint32_t file_size;
-#else
-  grub_uint64_t file_size;
-#endif
+  grub_ssize_t file_size;
   grub_uint32_t file_cluster;
   grub_uint32_t cur_cluster_num;
   grub_uint32_t cur_cluster;

grub-core/fs/squash4.c

@@ -823,12 +823,7 @@ direct_read (struct grub_squash_data *data,
       curread = data->blksz - boff;
       if (curread > len)
 	curread = len;
-      if (!ino->block_sizes[i])
-	{
-	  /* Sparse block */
-	  grub_memset (buf, '\0', curread);
-	}
-      else if (!(ino->block_sizes[i]
+      if (!(ino->block_sizes[i]
 	    & grub_cpu_to_le32_compile_time (SQUASH_BLOCK_UNCOMPRESSED)))
 	{
 	  char *block;
@@ -878,57 +873,36 @@ direct_read (struct grub_squash_data *data,
 
 
 static grub_ssize_t
-grub_squash_read (grub_file_t file, char *buf, grub_size_t len)
+grub_squash_read_data (struct grub_squash_data *data, 
+		       struct grub_squash_cache_inode *ino,
+		       grub_off_t off, char *buf, grub_size_t len)
 {
-  struct grub_squash_data *data = file->data;
-  struct grub_squash_cache_inode *ino = &data->ino;
-  grub_off_t off = file->offset;
   grub_err_t err;
-  grub_uint64_t a, b;
+  grub_uint64_t a = 0, b;
   grub_uint32_t fragment = 0;
   int compressed = 0;
   struct grub_squash_frag_desc frag;
-  grub_off_t direct_len;
-  grub_uint64_t mask = grub_le_to_cpu32 (data->sb.block_size) - 1;
-  grub_size_t orig_len = len;
 
   switch (ino->ino.type)
     {
     case grub_cpu_to_le16_compile_time (SQUASH_TYPE_LONG_REGULAR):
+      a = grub_le_to_cpu64 (ino->ino.long_file.chunk);
       fragment = grub_le_to_cpu32 (ino->ino.long_file.fragment);
       break;
     case grub_cpu_to_le16_compile_time (SQUASH_TYPE_REGULAR):
+      a = grub_le_to_cpu32 (ino->ino.file.chunk);
       fragment = grub_le_to_cpu32 (ino->ino.file.fragment);
       break;
     }
 
-  /* Squash may pack file tail as fragment. So read initial part directly and
-     get tail from fragments */
-  direct_len = fragment == 0xffffffff ? file->size : file->size & ~mask;
-  if (off < direct_len)
-    {
-      grub_size_t read_len = direct_len - off;
-      grub_ssize_t res;
-
-      if (read_len > len)
-	read_len = len;
-      res = direct_read (data, ino, off, buf, read_len);
-      if ((grub_size_t) res != read_len)
-	return -1; /* FIXME: is short read possible here? */
-      len -= read_len;
-      if (!len)
-	return read_len;
-      buf += read_len;
-      off = 0;
-    }
-  else
-    off -= direct_len;
+  if (fragment == 0xffffffff)
+    return direct_read (data, ino, off, buf, len);
  
   err = read_chunk (data, &frag, sizeof (frag),
 		    data->fragments, sizeof (frag) * fragment);
   if (err)
     return -1;
-  a = grub_le_to_cpu64 (frag.offset);
+  a += grub_le_to_cpu64 (frag.offset);
   compressed = !(frag.size & grub_cpu_to_le32_compile_time (SQUASH_BLOCK_UNCOMPRESSED));
   if (ino->ino.type == grub_cpu_to_le16_compile_time (SQUASH_TYPE_LONG_REGULAR))
     b = grub_le_to_cpu32 (ino->ino.long_file.offset) + off;
@@ -969,7 +943,16 @@ grub_squash_read (grub_file_t file, char *buf, grub_size_t len)
       if (err)
 	return -1;
     }
-  return orig_len;
+  return len;
+}
+
+static grub_ssize_t
+grub_squash_read (grub_file_t file, char *buf, grub_size_t len)
+{
+  struct grub_squash_data *data = file->data;
+
+  return grub_squash_read_data (data, &data->ino,
+				file->offset, buf, len);
 }
 
 static grub_err_t

grub-core/fs/xfs.c

@@ -76,13 +76,8 @@ GRUB_MOD_LICENSE ("GPLv3+");
 
 /* incompat feature flags */
 #define XFS_SB_FEAT_INCOMPAT_FTYPE      (1 << 0)        /* filetype in dirent */
-#define XFS_SB_FEAT_INCOMPAT_SPINODES   (1 << 1)        /* sparse inode chunks */
-#define XFS_SB_FEAT_INCOMPAT_META_UUID  (1 << 2)        /* metadata UUID */
-
-/* We do not currently verify metadata UUID so it is safe to read such filesystem */
 #define XFS_SB_FEAT_INCOMPAT_SUPPORTED \
-	(XFS_SB_FEAT_INCOMPAT_FTYPE | \
-	 XFS_SB_FEAT_INCOMPAT_META_UUID)
+	(XFS_SB_FEAT_INCOMPAT_FTYPE)
 
 struct grub_xfs_sblock
 {

grub-core/gdb/cstub.c

@@ -336,7 +336,6 @@ grub_gdb_trap (int trap_no)
 	/* sAA..AA: Step one instruction from AA..AA(optional).  */
 	case 's':
 	  stepping = 1;
-	  /* FALLTHROUGH */
 
 	/* cAA..AA: Continue at address AA..AA(optional).  */
 	case 'c':

grub-core/genmod.sh.in

@@ -1,4 +1,4 @@
-#! @BUILD_SHEBANG@
+#! /bin/sh
 set -e
 
 # Copyright (C) 2010 Free Software Foundation, Inc.
@@ -79,9 +79,9 @@ else
     for dep in $deps; do echo "char moddep_$dep[] __attribute__ ((section(\"_moddeps, _moddeps\"))) = \"$dep\";" >>$t2; done
 
     if test -n "$deps"; then
-	@TARGET_CC@ @TARGET_LDFLAGS@ @TARGET_INCREMENTAL_LINK@ -ffreestanding -nostdlib -o $tmpfile2 $t1 $t2 $tmpfile
+	@TARGET_CC@ @TARGET_LDFLAGS@ -ffreestanding -nostdlib -o $tmpfile2 $t1 $t2 $tmpfile -Wl,-r,-d
     else
-	@TARGET_CC@ @TARGET_LDFLAGS@ @TARGET_INCREMENTAL_LINK@ -ffreestanding -nostdlib -o $tmpfile2 $t1 $tmpfile
+	@TARGET_CC@ @TARGET_LDFLAGS@ -ffreestanding -nostdlib -o $tmpfile2 $t1 $tmpfile -Wl,-r,-d
     fi
     rm -f $t1 $t2 $tmpfile
     mv $tmpfile2 $tmpfile
@@ -94,6 +94,6 @@ else
 	rm -f $tmpfile.bin
 fi
 if test x@platform@ != xemu; then
-    ./build-grub-module-verifier@BUILD_EXEEXT@ $tmpfile @target_cpu@ @platform@
+    ./build-grub-module-verifier@BUILD_EXEEXT@ $tmpfile @target_cpu@
 fi
 mv $tmpfile $outfile

grub-core/gensyminfo.sh.in

@@ -1,4 +1,4 @@
-#! @BUILD_SHEBANG@
+#! /bin/sh
 set -e
 
 # Copyright (C) 2010 Free Software Foundation, Inc.

grub-core/gnulib-fix-gcc7-fallthrough.diff

@@ -1,14 +0,0 @@
-diff --git grub-core/gnulib/regexec.c grub-core/gnulib/regexec.c
-index f632cd4..a7776f0 100644
---- grub-core/gnulib/regexec.c
-+++ grub-core/gnulib/regexec.c
-@@ -4099,6 +4099,9 @@ check_node_accept (const re_match_context_t *mctx, const re_token_t *node,
-     case OP_UTF8_PERIOD:
-       if (ch >= ASCII_CHARS)
-         return false;
-+#if defined __GNUC__ && __GNUC__ >= 7
-+      __attribute__ ((fallthrough));
-+#endif
-       /* FALLTHROUGH */
- #endif
-     case OP_PERIOD:

grub-core/gnulib/regexec.c

@@ -4099,9 +4099,6 @@ check_node_accept (const re_match_context_t *mctx, const re_token_t *node,
     case OP_UTF8_PERIOD:
       if (ch >= ASCII_CHARS)
         return false;
-#if defined __GNUC__ && __GNUC__ >= 7
-      __attribute__ ((fallthrough));
-#endif
       /* FALLTHROUGH */
 #endif
     case OP_PERIOD:

grub-core/kern/arm/dl.c

@@ -173,8 +173,6 @@ grub_arch_dl_relocate_symbols (grub_dl_t mod, void *ehdr,
 	    sym_addr += grub_arm_thm_call_get_offset ((grub_uint16_t *) target);
 
 	    grub_dprintf ("dl", "    sym_addr = 0x%08x\n", sym_addr);
-	    if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
-	      sym_addr |= 1;
 
 	    offset = sym_addr - (grub_uint32_t) target;
 
@@ -229,16 +227,13 @@ grub_arch_dl_relocate_symbols (grub_dl_t mod, void *ehdr,
 
 	    sym_addr += grub_arm_thm_jump19_get_offset ((grub_uint16_t *) target);
 
-	    if (ELF_ST_TYPE (sym->st_info) != STT_FUNC)
-	      sym_addr |= 1;
-
 	    offset = sym_addr - (grub_uint32_t) target;
 
 	    if (!grub_arm_thm_jump19_check_offset (offset)
 		|| !(sym_addr & 1))
 	      {
-		struct trampoline_thumb *tp = mod->trampptr;
-		mod->trampptr = tp + 1;
+		struct trampoline_thumb *tp = mod->gotptr;
+		mod->gotptr = tp + 1;
 		grub_memcpy (tp->template, thumb_template, sizeof (tp->template));
 		tp->neg_addr = -sym_addr - 4;
 		offset = ((grub_uint8_t *) tp - (grub_uint8_t *) target - 4) | 1;

grub-core/kern/arm64/dl.c

@@ -25,9 +25,14 @@
 #include <grub/i18n.h>
 #include <grub/cpu/reloc.h>
 
+struct trampoline
+{
 #define LDR 0x58000050
 #define BR 0xd61f0200
-
+  grub_uint32_t ldr; /* ldr	x16, 8 */
+  grub_uint32_t br; /* br x16 */
+  grub_uint64_t addr;
+};
 
 /*
  * Check if EHDR is a valid ELF header.
@@ -48,6 +53,42 @@ grub_arch_dl_check_header (void *ehdr)
 
 #pragma GCC diagnostic ignored "-Wcast-align"
 
+grub_err_t
+grub_arch_dl_get_tramp_got_size (const void *ehdr, grub_size_t *tramp,
+				 grub_size_t *got)
+{
+  const Elf_Ehdr *e = ehdr;
+  const Elf_Shdr *s;
+  unsigned i;
+
+  *tramp = 0;
+  *got = 0;
+
+  for (i = 0, s = (const Elf_Shdr *) ((grub_addr_t) e + e->e_shoff);
+       i < e->e_shnum;
+       i++, s = (const Elf_Shdr *) ((grub_addr_t) s + e->e_shentsize))
+    if (s->sh_type == SHT_REL || s->sh_type == SHT_RELA)
+      {
+	const Elf_Rel *rel, *max;
+
+	for (rel = (const Elf_Rel *) ((grub_addr_t) e + s->sh_offset),
+	       max = rel + s->sh_size / s->sh_entsize;
+	     rel < max;
+	     rel = (const Elf_Rel *) ((grub_addr_t) rel + s->sh_entsize))
+	  switch (ELF_R_TYPE (rel->r_info))
+	    {
+	    case R_AARCH64_CALL26:
+	    case R_AARCH64_JUMP26:
+	      {
+		*tramp += sizeof (struct trampoline);
+		break;
+	      }
+	    }
+      }
+
+  return GRUB_ERR_NONE;
+}
+
 /*
  * Unified function for both REL and RELA 
  */
@@ -56,7 +97,6 @@ grub_arch_dl_relocate_symbols (grub_dl_t mod, void *ehdr,
 			       Elf_Shdr *s, grub_dl_segment_t seg)
 {
   Elf_Rel *rel, *max;
-  unsigned unmatched_adr_got_page = 0;
 
   for (rel = (Elf_Rel *) ((char *) ehdr + s->sh_offset),
 	 max = (Elf_Rel *) ((char *) rel + s->sh_size);
@@ -105,7 +145,7 @@ grub_arch_dl_relocate_symbols (grub_dl_t mod, void *ehdr,
 
 	    if (!grub_arm_64_check_xxxx26_offset (offset))
 	      {
-		struct grub_arm64_trampoline *tp = mod->trampptr;
+		struct trampoline *tp = mod->trampptr;
 		mod->trampptr = tp + 1;
 		tp->ldr = LDR;
 		tp->br = BR;
@@ -120,56 +160,6 @@ grub_arch_dl_relocate_symbols (grub_dl_t mod, void *ehdr,
 	    grub_arm64_set_xxxx26_offset (place, offset);
 	  }
 	  break;
-	case R_AARCH64_PREL32:
-	  {
-	    grub_int64_t value;
-	    Elf64_Word *addr32 = place;
-	    value = ((grub_int32_t) *addr32) + sym_addr -
-	      (Elf64_Xword) (grub_addr_t) seg->addr - rel->r_offset;
-	    if (value != (grub_int32_t) value)
-	      return grub_error (GRUB_ERR_BAD_MODULE, "relocation out of range");
-	    grub_dprintf("dl", "  reloc_prel32 %p => 0x%016llx\n",
-			  place, (unsigned long long) sym_addr);
-	    *addr32 = value;
-	  }
-	  break;
-	case R_AARCH64_ADR_GOT_PAGE:
-	  {
-	    grub_uint64_t *gp = mod->gotptr;
-	    Elf_Rela *rel2;
-	    grub_int64_t gpoffset = ((grub_uint64_t) gp & ~0xfffULL) - (((grub_uint64_t) place) & ~0xfffULL);
-	    *gp = (grub_uint64_t) sym_addr;
-	    mod->gotptr = gp + 1;
-	    unmatched_adr_got_page++;
-	    grub_dprintf("dl", "  reloc_got %p => 0x%016llx (0x%016llx)\n",
-			 place, (unsigned long long) sym_addr, (unsigned long long) gp);
-	    if (!grub_arm64_check_hi21_signed (gpoffset))
-		return grub_error (GRUB_ERR_BAD_MODULE,
-				   "HI21 out of range");
-	    grub_arm64_set_hi21(place, gpoffset);
-	    for (rel2 = (Elf_Rela *) ((char *) rel + s->sh_entsize);
-		 rel2 < (Elf_Rela *) max;
-		 rel2 = (Elf_Rela *) ((char *) rel2 + s->sh_entsize))
-	      if (ELF_R_SYM (rel2->r_info)
-		  == ELF_R_SYM (rel->r_info)
-		  && ((Elf_Rela *) rel)->r_addend == rel2->r_addend
-		  && ELF_R_TYPE (rel2->r_info) == R_AARCH64_LD64_GOT_LO12_NC)
-		{
-		  grub_arm64_set_abs_lo12_ldst64 ((void *) ((grub_addr_t) seg->addr + rel2->r_offset),
-						  (grub_uint64_t)gp);
-		  break;
-		}
-	    if (rel2 >= (Elf_Rela *) max)
-	      return grub_error (GRUB_ERR_BAD_MODULE,
-				 "ADR_GOT_PAGE without matching LD64_GOT_LO12_NC");
-	  }
-	  break;
-	case R_AARCH64_LD64_GOT_LO12_NC:
-	  if (unmatched_adr_got_page == 0)
-	    return grub_error (GRUB_ERR_BAD_MODULE,
-			       "LD64_GOT_LO12_NC without matching ADR_GOT_PAGE");
-	  unmatched_adr_got_page--;
-	  break;
 	case R_AARCH64_ADR_PREL_PG_HI21:
 	  {
 	    grub_int64_t offset = (sym_addr & ~0xfffULL) - (((grub_uint64_t) place) & ~0xfffULL);

grub-core/kern/arm64/dl_helper.c

@@ -93,42 +93,3 @@ grub_arm64_set_abs_lo12_ldst64 (grub_uint32_t *place, grub_int64_t target)
   *place &= insmask;
   *place |= grub_cpu_to_le32 (target << 7) & ~insmask;
 }
-
-#pragma GCC diagnostic ignored "-Wcast-align"
-
-grub_err_t
-grub_arm64_dl_get_tramp_got_size (const void *ehdr, grub_size_t *tramp,
-				  grub_size_t *got)
-{
-  const Elf64_Ehdr *e = ehdr;
-  const Elf64_Shdr *s;
-  unsigned i;
-
-  *tramp = 0;
-  *got = 0;
-
-  for (i = 0, s = (Elf64_Shdr *) ((char *) e + grub_le_to_cpu64 (e->e_shoff));
-       i < grub_le_to_cpu16 (e->e_shnum);
-       i++, s = (Elf64_Shdr *) ((char *) s + grub_le_to_cpu16 (e->e_shentsize)))
-    if (s->sh_type == grub_cpu_to_le32_compile_time (SHT_REL)
-	|| s->sh_type == grub_cpu_to_le32_compile_time (SHT_RELA))
-      {
-	const Elf64_Rela *rel, *max;
-
-	for (rel = (Elf64_Rela *) ((char *) e + grub_le_to_cpu64 (s->sh_offset)),
-	       max = (const Elf64_Rela *) ((char *) rel + grub_le_to_cpu64 (s->sh_size));
-	     rel < max; rel = (const Elf64_Rela *) ((char *) rel + grub_le_to_cpu64 (s->sh_entsize)))
-	  switch (ELF64_R_TYPE (rel->r_info))
-	    {
-	    case R_AARCH64_CALL26:
-	    case R_AARCH64_JUMP26:
-	      *tramp += sizeof (struct grub_arm64_trampoline);
-	      break;
-	    case R_AARCH64_ADR_GOT_PAGE:
-	      *got += 8;
-	      break;
-	    }
-      }
-
-  return GRUB_ERR_NONE;
-}

grub-core/kern/efi/efi.c

@@ -366,9 +366,6 @@ grub_efi_get_filename (grub_efi_device_path_t *dp0)
 	  len = ((GRUB_EFI_DEVICE_PATH_LENGTH (dp) - 4)
 		 / sizeof (grub_efi_char16_t));
 	  fp = (grub_efi_file_path_device_path_t *) dp;
-	  /* According to EFI spec Path Name is NULL terminated */
-	  while (len > 0 && fp->path_name[len - 1] == 0)
-	    len--;
 
 	  p = (char *) grub_utf16_to_utf8 ((unsigned char *) p, fp->path_name, len);
 	}

grub-core/kern/efi/fdt.c

@@ -1,43 +0,0 @@
-/* fdt.c - EFI Flattened Device Tree interaction */
-/*
- *  GRUB  --  GRand Unified Bootloader
- *  Copyright (C) 2006,2007  Free Software Foundation, Inc.
- *
- *  GRUB 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 3 of the License, or
- *  (at your option) any later version.
- *
- *  GRUB 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 GRUB.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include <grub/efi/efi.h>
-#include <grub/mm.h>
-
-void *
-grub_efi_get_firmware_fdt (void)
-{
-  grub_efi_configuration_table_t *tables;
-  grub_efi_guid_t fdt_guid = GRUB_EFI_DEVICE_TREE_GUID;
-  void *firmware_fdt = NULL;
-  unsigned int i;
-
-  /* Look for FDT in UEFI config tables. */
-  tables = grub_efi_system_table->configuration_table;
-
-  for (i = 0; i < grub_efi_system_table->num_table_entries; i++)
-    if (grub_memcmp (&tables[i].vendor_guid, &fdt_guid, sizeof (fdt_guid)) == 0)
-      {
-	firmware_fdt = tables[i].vendor_table;
-	grub_dprintf ("linux", "found registered FDT @ %p\n", firmware_fdt);
-	break;
-      }
-
-  return firmware_fdt;
-}

grub-core/kern/efi/init.c

@@ -59,13 +59,10 @@ grub_machine_get_bootlocation (char **device, char **path)
   if (!image)
     return;
   *device = grub_efidisk_get_device_name (image->device_handle);
-  if (!*device && grub_efi_net_config)
-    {
-      grub_efi_net_config (image->device_handle, device, path);
-      return;
-    }
-
   *path = grub_efi_get_filename (image->file_path);
+  if (!*device && grub_efi_net_config)
+    grub_efi_net_config (image->device_handle, device, path);
+
   if (*path)
     {
       /* Get the directory.  */

grub-core/kern/emu/main.c

@@ -63,7 +63,6 @@ void
 grub_reboot (void)
 {
   longjmp (main_env, 1);
-  grub_fatal ("longjmp failed");
 }
 
 void

grub-core/kern/emu/misc.c

@@ -127,7 +127,6 @@ xasprintf (const char *fmt, ...)
   
   va_start (ap, fmt);
   result = grub_xvasprintf (fmt, ap);
-  va_end (ap);
   if (!result)
     grub_util_error ("%s", _("out of memory"));
   

grub-core/kern/ia64/dl.c

@@ -104,9 +104,6 @@ grub_arch_dl_relocate_symbols (grub_dl_t mod, void *ehdr,
 	case R_IA64_PCREL64LSB:
 	  *(grub_uint64_t *) addr += value - addr;
 	  break;
-	case R_IA64_GPREL64I:
-	  grub_ia64_set_immu64 (addr, value - (grub_addr_t) mod->base);
-	  break;
 	case R_IA64_GPREL22:
 	  if ((value - (grub_addr_t) mod->base) & ~MASK20)
 	    return grub_error (GRUB_ERR_BAD_MODULE,
@@ -119,7 +116,6 @@ grub_arch_dl_relocate_symbols (grub_dl_t mod, void *ehdr,
 	case R_IA64_LTOFF22:
 	  if (ELF_ST_TYPE (sym->st_info) == STT_FUNC)
 	    value = *(grub_uint64_t *) sym->st_value + rel->r_addend;
-	  /* Fallthrough.  */
 	case R_IA64_LTOFF_FPTR22:
 	  {
 	    grub_uint64_t *gpptr = mod->gotptr;

grub-core/kern/ia64/dl_helper.c

@@ -30,40 +30,6 @@
 #define MASK20 ((1 << 20) - 1)
 #define MASK3 (~(grub_addr_t) 3)
 
-void
-grub_ia64_set_immu64 (grub_addr_t addr, grub_uint64_t val)
-{
-  /* Copied from binutils.  */
-  grub_uint64_t *ptr = ((grub_uint64_t *) (addr & MASK3));
-  grub_uint64_t t0, t1;
-
-  t0 = grub_le_to_cpu64 (ptr[0]);
-  t1 = grub_le_to_cpu64 (ptr[1]);
-
-  /* tmpl/s: bits  0.. 5 in t0
-     slot 0: bits  5..45 in t0
-     slot 1: bits 46..63 in t0, bits 0..22 in t1
-     slot 2: bits 23..63 in t1 */
-
-  /* First, clear the bits that form the 64 bit constant.  */
-  t0 &= ~(0x3ffffLL << 46);
-  t1 &= ~(0x7fffffLL
-	  | ((  (0x07fLL << 13) | (0x1ffLL << 27)
-		| (0x01fLL << 22) | (0x001LL << 21)
-		| (0x001LL << 36)) << 23));
-
-  t0 |= ((val >> 22) & 0x03ffffLL) << 46;		/* 18 lsbs of imm41 */
-  t1 |= ((val >> 40) & 0x7fffffLL) <<  0;		/* 23 msbs of imm41 */
-  t1 |= (  (((val >>  0) & 0x07f) << 13)		/* imm7b */
-	   | (((val >>  7) & 0x1ff) << 27)		/* imm9d */
-	   | (((val >> 16) & 0x01f) << 22)		/* imm5c */
-	   | (((val >> 21) & 0x001) << 21)		/* ic */
-	   | (((val >> 63) & 0x001) << 36)) << 23;	/* i */
-
-  ptr[0] = t0;
-  ptr[1] = t1;
-}
-
 void
 grub_ia64_add_value_to_slot_20b (grub_addr_t addr, grub_uint32_t value)
 {
@@ -216,11 +182,11 @@ grub_ia64_dl_get_tramp_got_size (const void *ehdr, grub_size_t *tramp,
        i++, s = (Elf64_Shdr *) ((char *) s + grub_le_to_cpu16 (e->e_shentsize)))
     if (s->sh_type == grub_cpu_to_le32_compile_time (SHT_RELA))
       {
-	const Elf64_Rela *rel, *max;
+	Elf64_Rela *rel, *max;
 
 	for (rel = (Elf64_Rela *) ((char *) e + grub_le_to_cpu64 (s->sh_offset)),
-	       max = (const Elf64_Rela *) ((char *) rel + grub_le_to_cpu64 (s->sh_size));
-	     rel < max; rel = (const Elf64_Rela *) ((char *) rel + grub_le_to_cpu64 (s->sh_entsize)))
+	       max = rel + grub_le_to_cpu64 (s->sh_size) / grub_le_to_cpu64 (s->sh_entsize);
+	     rel < max; rel++)
 	  switch (ELF64_R_TYPE (grub_le_to_cpu64 (rel->r_info)))
 	    {
 	    case R_IA64_PCREL21B:

grub-core/kern/mips/dl.c

@@ -236,7 +236,6 @@ grub_arch_dl_relocate_symbols (grub_dl_t mod, void *ehdr,
 	      sym_value &= 0xffff0000;
 	      *(grub_uint16_t *) addr = 0;
 	    }
-	  /* Fallthrough.  */
 	case R_MIPS_CALL16:
 	  {
 	    grub_uint32_t *gpptr = mod->gotptr;

grub-core/kern/misc.c

@@ -391,13 +391,12 @@ grub_strtoull (const char *str, char **end, int base)
       unsigned long digit;
 
       digit = grub_tolower (*str) - '0';
-      if (digit >= 'a' - '0')
-	digit += '0' - 'a' + 10;
-      else if (digit > 9)
-	break;
-
-      if (digit >= (unsigned long) base)
-	break;
+      if (digit > 9)
+	{
+	  digit += '0' - 'a' + 10;
+	  if (digit >= (unsigned long) base)
+	    break;
+	}
 
       found = 1;
 

grub-core/kern/sparc64/dl.c

@@ -159,7 +159,6 @@ grub_arch_dl_relocate_symbols (grub_dl_t mod, void *ehdr,
 	  if (value >> 32)
 	    return grub_error (GRUB_ERR_BAD_MODULE,
 			       "address out of 32 bits range");
-	  /* Fallthrough.  */
 	case R_SPARC_LM22:
 	  *addr = (*addr & 0xFFC00000) | ((value >> 10) & 0x3FFFFF);
 	  break;

grub-core/lib/i386/relocator64.S

@@ -73,22 +73,6 @@ VARIABLE(grub_relocator64_rsp)
 
 	movq	%rax, %rsp
 
-#ifdef GRUB_MACHINE_EFI
-	jmp	LOCAL(skip_efi_stack_align)
-
-	/*
-	 * Here is grub_relocator64_efi_start() entry point. Most of the
-	 * code below is shared between grub_relocator64_efi_start()
-	 * and grub_relocator64_start().
-	 *
-	 * Think twice before changing anything there!!!
-	 */
-VARIABLE(grub_relocator64_efi_start)
-	/* Align the stack as UEFI spec requires. */
-	andq	$~15, %rsp
-
-LOCAL(skip_efi_stack_align):
-#endif
 	/* mov imm64, %rax */
 	.byte 	0x48
 	.byte	0xb8
@@ -136,11 +120,6 @@ LOCAL(jump_addr):
 VARIABLE(grub_relocator64_rip)
 	.quad	0
 
-#ifdef GRUB_MACHINE_EFI
-	/* Here grub_relocator64_efi_start() ends. Ufff... */
-VARIABLE(grub_relocator64_efi_end)
-#endif
-
 #ifndef __x86_64__
 	.p2align	4
 LOCAL(gdt):

grub-core/lib/i386/xen/relocator.S

@@ -16,8 +16,6 @@
  *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <grub/i386/memory.h>
-#include <grub/i386/types.h>
 #include <grub/symbol.h>
 #include <grub/xen.h>
 
@@ -25,86 +23,78 @@
 
 VARIABLE(grub_relocator_xen_remap_start)
 LOCAL(base):
-	/* Remap the remapper to it's new address. */
-	/* mov imm32, %ebx - %ebx: new virtual address of remapper */
+	/* mov imm32, %ebx */
 	.byte	0xbb
 VARIABLE(grub_relocator_xen_remapper_virt)
 	.long	0
 
-	/* mov imm32, %ecx - %ecx: low part of page table entry */
+	/* mov imm32, %ecx */
 	.byte	0xb9
 VARIABLE(grub_relocator_xen_remapper_map)
 	.long	0
 
-	/* mov imm32, %edx  - %edx: high part of page table entry */
+	/* mov imm32, %edx */
 	.byte	0xba
 VARIABLE(grub_relocator_xen_remapper_map_high)
 	.long	0
 
-	movl	%ebx, %ebp	/* %ebx is clobbered by hypercall */
+	movl	%ebx, %ebp
 
-	movl    $UVMF_INVLPG, %esi	/* esi: flags (inv. single entry) */
+	movl    $2, %esi
 	movl    $__HYPERVISOR_update_va_mapping, %eax
 	int     $0x82
 
 	movl	%ebp, %ebx
 	addl   $(LOCAL(cont) - LOCAL(base)), %ebx
 
-	jmp *%ebx		/* Continue with new virtual address */
+	jmp *%ebx
 
 LOCAL(cont):
-	/* Modify mappings of new page tables to be read-only. */
-	/* mov imm32, %eax */
-	.byte	0xb8
-VARIABLE(grub_relocator_xen_paging_areas_addr)
-	.long	0
-	movl	%eax, %ebx
+	xorl	%eax, %eax
+	movl	%eax, %ebp
 1:
-	movl	0(%ebx), %ebp	/* Get start pfn of the current area */
-	movl	GRUB_TARGET_SIZEOF_LONG(%ebx), %ecx	/* Get # of pg tables */
-	testl	%ecx, %ecx	/* 0 -> last area reached */
-	jz	3f
-	addl	$(2 * GRUB_TARGET_SIZEOF_LONG), %ebx
-	movl	%ebx, %esp	/* Save current area pointer */
 
-2:
-	movl	%ecx, %edi
 	/* mov imm32, %eax */
 	.byte	0xb8
 VARIABLE(grub_relocator_xen_mfn_list)
 	.long	0
-	movl    0(%eax, %ebp, 4), %ecx	/* mfn */
-	movl	%ebp, %ebx
-	shll	$PAGE_SHIFT, %ebx	/* virtual address (1:1 mapping) */
+	movl	%eax, %edi
+	movl	%ebp, %eax
+	movl    0(%edi, %eax, 4), %ecx
+
+	/* mov imm32, %ebx */
+	.byte	0xbb
+VARIABLE(grub_relocator_xen_paging_start)
+	.long	0
+	shll	$12, %eax
+	addl	%eax, %ebx
 	movl    %ecx, %edx
-	shll    $PAGE_SHIFT,  %ecx	/* prepare pte low part */
-	shrl    $(32 - PAGE_SHIFT),  %edx	/* pte high part */
-	orl     $(GRUB_PAGE_PRESENT | GRUB_PAGE_USER), %ecx	/* pte low */
-	movl    $UVMF_INVLPG, %esi
+	shll    $12,  %ecx
+	shrl    $20,  %edx
+	orl     $5, %ecx
+	movl    $2, %esi
 	movl    $__HYPERVISOR_update_va_mapping, %eax
-	int     $0x82		/* parameters: eax, ebx, ecx, edx, esi */
+	int     $0x82
 
-	incl	%ebp		/* next pfn */
-	movl	%edi, %ecx
+	incl	%ebp
+	/* mov imm32, %ecx */
+	.byte	0xb9
+VARIABLE(grub_relocator_xen_paging_size)
+	.long	0
+	cmpl	%ebp, %ecx
 
-	loop	2b
+	ja	1b
 
-	mov	%esp, %ebx	/* restore area poniter */
-	jmp	1b
-
-3:
-	/* Switch page tables: pin new L3 pt, load cr3, unpin old L3. */
 	/* mov imm32, %ebx */
 	.byte	0xbb
 VARIABLE(grub_relocator_xen_mmu_op_addr)
 	.long  0
-	movl   $3, %ecx		/* 3 mmu ops */
-	movl   $0, %edx		/* pdone (not used) */
-	movl   $DOMID_SELF, %esi
+	movl   $3, %ecx
+	movl   $0, %edx
+	movl   $0x7FF0, %esi
 	movl   $__HYPERVISOR_mmuext_op, %eax
 	int     $0x82
 
-	/* Continue in virtual kernel mapping. */
 	/* mov imm32, %eax */
 	.byte	0xb8
 VARIABLE(grub_relocator_xen_remap_continue)
@@ -112,9 +102,6 @@ VARIABLE(grub_relocator_xen_remap_continue)
 
 	jmp *%eax
 
-VARIABLE(grub_relocator_xen_paging_areas)
-	.long	0, 0, 0, 0, 0, 0, 0, 0
-
 VARIABLE(grub_relocator_xen_mmu_op)
 	.space 256
 
@@ -122,22 +109,21 @@ VARIABLE(grub_relocator_xen_remap_end)
 
 
 VARIABLE(grub_relocator_xen_start)
-	/* Unmap old remapper area. */
 	/* mov imm32, %eax */
 	.byte	0xb8
 VARIABLE(grub_relocator_xen_remapper_virt2)
 	.long	0
 
-	movl    %eax, %ebx
+	movl    %eax, %edi
 
-	xorl    %ecx, %ecx	/* Invalid pte */
+	xorl    %ecx, %ecx
 	xorl    %edx, %edx
 
-	movl    $UVMF_INVLPG, %esi
+	movl    $2, %esi
 	movl    $__HYPERVISOR_update_va_mapping, %eax
 	int     $0x82
 
-	/* Prepare registers for starting kernel. */
+
 	/* mov imm32, %eax */
 	.byte	0xb8
 VARIABLE(grub_relocator_xen_stack)
@@ -159,7 +145,6 @@ VARIABLE(grub_relocator_xen_start_info)
 VARIABLE(grub_relocator_xen_entry_point)
 	.long	0
 
-	/* Now start the new kernel. */
 	jmp *%eax
 
 VARIABLE(grub_relocator_xen_end)

grub-core/lib/x86_64/efi/relocator.c

@@ -1,80 +0,0 @@
-/*
- *  GRUB  --  GRand Unified Bootloader
- *  Copyright (C) 2009  Free Software Foundation, Inc.
- *  Copyright (C) 2016  Oracle and/or its affiliates. All rights reserved.
- *
- *  GRUB 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 3 of the License, or
- *  (at your option) any later version.
- *
- *  GRUB 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 GRUB.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include <grub/mm.h>
-#include <grub/misc.h>
-
-#include <grub/types.h>
-#include <grub/err.h>
-
-#include <grub/i386/relocator.h>
-#include <grub/relocator_private.h>
-
-extern grub_uint64_t grub_relocator64_rax;
-extern grub_uint64_t grub_relocator64_rbx;
-extern grub_uint64_t grub_relocator64_rcx;
-extern grub_uint64_t grub_relocator64_rdx;
-extern grub_uint64_t grub_relocator64_rip;
-extern grub_uint64_t grub_relocator64_rsi;
-
-extern grub_uint8_t grub_relocator64_efi_start;
-extern grub_uint8_t grub_relocator64_efi_end;
-
-#define RELOCATOR_SIZEOF(x)	(&grub_relocator##x##_end - &grub_relocator##x##_start)
-
-grub_err_t
-grub_relocator64_efi_boot (struct grub_relocator *rel,
-			   struct grub_relocator64_efi_state state)
-{
-  grub_err_t err;
-  void *relst;
-  grub_relocator_chunk_t ch;
-
-  /*
-   * 64-bit relocator code may live above 4 GiB quite well.
-   * However, I do not want ask for problems. Just in case.
-   */
-  err = grub_relocator_alloc_chunk_align (rel, &ch, 0,
-					  0x100000000 - RELOCATOR_SIZEOF (64_efi),
-					  RELOCATOR_SIZEOF (64_efi), 16,
-					  GRUB_RELOCATOR_PREFERENCE_NONE, 1);
-  if (err)
-    return err;
-
-  /* Do not touch %rsp! It points to EFI created stack. */
-  grub_relocator64_rax = state.rax;
-  grub_relocator64_rbx = state.rbx;
-  grub_relocator64_rcx = state.rcx;
-  grub_relocator64_rdx = state.rdx;
-  grub_relocator64_rip = state.rip;
-  grub_relocator64_rsi = state.rsi;
-
-  grub_memmove (get_virtual_current_address (ch), &grub_relocator64_efi_start,
-		RELOCATOR_SIZEOF (64_efi));
-
-  err = grub_relocator_prepare_relocs (rel, get_physical_target_address (ch),
-				       &relst, NULL);
-  if (err)
-    return err;
-
-  ((void (*) (void)) relst) ();
-
-  /* Not reached.  */
-  return GRUB_ERR_NONE;
-}

grub-core/lib/x86_64/xen/relocator.S

@@ -16,85 +16,95 @@
  *  along with GRUB.  If not, see <http://www.gnu.org/licenses/>.
  */
 
-#include <grub/x86_64/memory.h>
-#include <grub/x86_64/types.h>
 #include <grub/symbol.h>
 #include <grub/xen.h>
 
-/* Macro to load an imm64 value stored by the C-part into %rax: */
-#define MOV_IMM64_RAX(var) .byte 0x48, 0xb8; VARIABLE(var); .quad 0
-
 	.p2align	4	/* force 16-byte alignment */
 
 VARIABLE(grub_relocator_xen_remap_start)
 LOCAL(base):
-	/* Remap the remapper to it's new address. */
-	MOV_IMM64_RAX(grub_relocator_xen_remapper_virt)
+	/* mov imm64, %rax */
+	.byte 	0x48
+	.byte	0xb8
+VARIABLE(grub_relocator_xen_remapper_virt)
+	.quad	0
 
-	movq    %rax, %rdi	/* %rdi: new virtual address of remapper */
-	movq    %rax, %rbx	/* Remember new virtual address */
+	movq    %rax, %rdi
+	movq    %rax, %rbx
 
-	MOV_IMM64_RAX(grub_relocator_xen_remapper_map)
+	/* mov imm64, %rax */
+	.byte 	0x48
+	.byte	0xb8
+VARIABLE(grub_relocator_xen_remapper_map)
+	.quad	0
 
-	movq    %rax, %rsi	/* %rsi: page table entry */
+	movq    %rax, %rsi
 
-	movq    $UVMF_INVLPG, %rdx	/* %rdx: flags (inv. single entry) */
+	movq    $2, %rdx
 	movq    $__HYPERVISOR_update_va_mapping, %rax
-	syscall			/* Do the remap operation */
+	syscall
 
 	addq   $(LOCAL(cont) - LOCAL(base)), %rbx
 
-	jmp *%rbx		/* Continue with new virtual address */
+	jmp *%rbx
 
 LOCAL(cont):
-	/* Modify mappings of new page tables to be read-only. */
-	MOV_IMM64_RAX(grub_relocator_xen_mfn_list)
+	
+	/* mov imm64, %rcx */
+	.byte 	0x48
+	.byte	0xb9
+VARIABLE(grub_relocator_xen_paging_size)
+	.quad	0
 
-	movq	%rax, %rbx	/* %rbx is the base of the p2m list */
-	leaq	EXT_C(grub_relocator_xen_paging_areas) (%rip), %r8
+	/* mov imm64, %rax */
+	.byte 	0x48
+	.byte	0xb8
+VARIABLE(grub_relocator_xen_paging_start)
+	.quad	0
 
+	movq	%rax, %r12
+
+	/* mov imm64, %rax */
+	.byte 	0x48
+	.byte	0xb8
+VARIABLE(grub_relocator_xen_mfn_list)
+	.quad	0
+
+	movq	%rax, %rsi
 1:
-	movq	0(%r8), %r12	/* Get start pfn of the current area */
-	movq	GRUB_TARGET_SIZEOF_LONG(%r8), %rcx	/* Get # of pg tables */
-	testq	%rcx, %rcx	/* 0 -> last area reached */
-	jz	3f
-2:
 	movq	%r12, %rdi
-	shlq	$PAGE_SHIFT, %rdi	/* virtual address (1:1 mapping) */
-	movq    (%rbx, %r12, 8), %rsi	/* mfn */
-	shlq    $PAGE_SHIFT,  %rsi
-	orq     $(GRUB_PAGE_PRESENT | GRUB_PAGE_USER), %rsi	/* Build pte */
-	movq    $UVMF_INVLPG, %rdx
-	movq    %rcx, %r9	/* %rcx clobbered by hypercall */
+	movq    %rsi, %rbx
+	movq    0(%rsi), %rsi
+	shlq    $12,  %rsi
+	orq     $5, %rsi
+	movq    $2, %rdx
+	movq    %rcx, %r9
 	movq    $__HYPERVISOR_update_va_mapping, %rax
 	syscall
 
 	movq    %r9, %rcx
-	incq	%r12		/* next pfn */
+	addq    $8, %rbx
+	addq    $4096, %r12
+	movq    %rbx, %rsi
 
-	loop 2b
+	loop 1b
 
-	addq	$(2 * GRUB_TARGET_SIZEOF_LONG), %r8	/* next pg table area */
-	jmp	1b
-
-3:
-	/* Switch page tables: pin new L4 pt, load cr3, unpin old L4. */
-	leaq   EXT_C(grub_relocator_xen_mmu_op) (%rip), %rdi
-	movq   $3, %rsi		/* 3 mmu ops */
-	movq   $0, %rdx		/* pdone (not used) */
-	movq   $DOMID_SELF, %r10
+	leaq   LOCAL(mmu_op) (%rip), %rdi
+	movq   $3, %rsi
+	movq   $0, %rdx
+	movq   $0x7FF0, %r10
 	movq   $__HYPERVISOR_mmuext_op, %rax
 	syscall
 
-	/* Continue in virtual kernel mapping. */
-	MOV_IMM64_RAX(grub_relocator_xen_remap_continue)
+	/* mov imm64, %rax */
+	.byte 	0x48
+	.byte	0xb8
+VARIABLE(grub_relocator_xen_remap_continue)
+	.quad	0
 
 	jmp *%rax
 
-VARIABLE(grub_relocator_xen_paging_areas)
-	/* array of start, size pairs, size 0 is end marker */
-	.quad	0, 0, 0, 0, 0, 0, 0, 0
-
+LOCAL(mmu_op):
 VARIABLE(grub_relocator_xen_mmu_op)
 	.space 256
 
@@ -102,32 +112,46 @@ VARIABLE(grub_relocator_xen_remap_end)
 
 
 VARIABLE(grub_relocator_xen_start)
-	/* Unmap old remapper area. */
-	MOV_IMM64_RAX(grub_relocator_xen_remapper_virt2)
+	/* mov imm64, %rax */
+	.byte 	0x48
+	.byte	0xb8
+VARIABLE(grub_relocator_xen_remapper_virt2)
+	.quad	0
 
 	movq    %rax, %rdi
 
-	xorq    %rax, %rax	/* Invalid pte */
+	xorq    %rax, %rax
 	movq    %rax, %rsi
 
-	movq    $UVMF_INVLPG, %rdx
+	movq    $2, %rdx
 	movq    $__HYPERVISOR_update_va_mapping, %rax
 	syscall
 
-	/* Prepare registers for starting kernel. */
-	MOV_IMM64_RAX(grub_relocator_xen_stack)
+
+	/* mov imm64, %rax */
+	.byte 	0x48
+	.byte	0xb8
+VARIABLE(grub_relocator_xen_stack)
+	.quad	0
 
 	movq	%rax, %rsp
 
-	MOV_IMM64_RAX(grub_relocator_xen_start_info)
+	/* mov imm64, %rax */
+	.byte 	0x48
+	.byte	0xb8
+VARIABLE(grub_relocator_xen_start_info)
+	.quad	0
 
 	movq	%rax, %rsi
 
 	cld
 
-	MOV_IMM64_RAX(grub_relocator_xen_entry_point)
+	/* mov imm64, %rax */
+	.byte 	0x48
+	.byte	0xb8
+VARIABLE(grub_relocator_xen_entry_point)
+	.quad	0
 
-	/* Now start the new kernel. */
 	jmp *%rax
 
 VARIABLE(grub_relocator_xen_end)

grub-core/lib/xen/relocator.c

@@ -29,11 +29,6 @@
 
 typedef grub_addr_t grub_xen_reg_t;
 
-struct grub_relocator_xen_paging_area {
-  grub_xen_reg_t start;
-  grub_xen_reg_t size;
-} GRUB_PACKED;
-
 extern grub_uint8_t grub_relocator_xen_start;
 extern grub_uint8_t grub_relocator_xen_end;
 extern grub_uint8_t grub_relocator_xen_remap_start;
@@ -41,16 +36,15 @@ extern grub_uint8_t grub_relocator_xen_remap_end;
 extern grub_xen_reg_t grub_relocator_xen_stack;
 extern grub_xen_reg_t grub_relocator_xen_start_info;
 extern grub_xen_reg_t grub_relocator_xen_entry_point;
+extern grub_xen_reg_t grub_relocator_xen_paging_start;
+extern grub_xen_reg_t grub_relocator_xen_paging_size;
 extern grub_xen_reg_t grub_relocator_xen_remapper_virt;
 extern grub_xen_reg_t grub_relocator_xen_remapper_virt2;
 extern grub_xen_reg_t grub_relocator_xen_remapper_map;
 extern grub_xen_reg_t grub_relocator_xen_mfn_list;
-extern struct grub_relocator_xen_paging_area
-  grub_relocator_xen_paging_areas[XEN_MAX_MAPPINGS];
 extern grub_xen_reg_t grub_relocator_xen_remap_continue;
 #ifdef __i386__
 extern grub_xen_reg_t grub_relocator_xen_mmu_op_addr;
-extern grub_xen_reg_t grub_relocator_xen_paging_areas_addr;
 extern grub_xen_reg_t grub_relocator_xen_remapper_map_high;
 #endif
 extern mmuext_op_t grub_relocator_xen_mmu_op[3];
@@ -67,7 +61,6 @@ grub_relocator_xen_boot (struct grub_relocator *rel,
 {
   grub_err_t err;
   void *relst;
-  int i;
   grub_relocator_chunk_t ch, ch_tramp;
   grub_xen_mfn_t *mfn_list =
     (grub_xen_mfn_t *) grub_xen_start_page_addr->mfn_list;
@@ -84,11 +77,8 @@ grub_relocator_xen_boot (struct grub_relocator *rel,
   grub_relocator_xen_stack = state.stack;
   grub_relocator_xen_start_info = state.start_info;
   grub_relocator_xen_entry_point = state.entry_point;
-  for (i = 0; i < XEN_MAX_MAPPINGS; i++)
-    {
-      grub_relocator_xen_paging_areas[i].start = state.paging_start[i];
-      grub_relocator_xen_paging_areas[i].size = state.paging_size[i];
-    }
+  grub_relocator_xen_paging_start = state.paging_start << 12;
+  grub_relocator_xen_paging_size = state.paging_size;
   grub_relocator_xen_remapper_virt = remapper_virt;
   grub_relocator_xen_remapper_virt2 = remapper_virt;
   grub_relocator_xen_remap_continue = trampoline_virt;
@@ -98,12 +88,10 @@ grub_relocator_xen_boot (struct grub_relocator *rel,
   grub_relocator_xen_remapper_map_high = (mfn_list[remapper_pfn] >> 20);
   grub_relocator_xen_mmu_op_addr = (char *) &grub_relocator_xen_mmu_op
     - (char *) &grub_relocator_xen_remap_start + remapper_virt;
-  grub_relocator_xen_paging_areas_addr =
-    (char *) &grub_relocator_xen_paging_areas
-    - (char *) &grub_relocator_xen_remap_start + remapper_virt;
 #endif
 
-  grub_relocator_xen_mfn_list = state.mfn_list;
+  grub_relocator_xen_mfn_list = state.mfn_list
+    + state.paging_start * sizeof (grub_addr_t);
 
   grub_memset (grub_relocator_xen_mmu_op, 0,
 	       sizeof (grub_relocator_xen_mmu_op));
@@ -112,9 +100,9 @@ grub_relocator_xen_boot (struct grub_relocator *rel,
 #else
   grub_relocator_xen_mmu_op[0].cmd = MMUEXT_PIN_L4_TABLE;
 #endif
-  grub_relocator_xen_mmu_op[0].arg1.mfn = mfn_list[state.paging_start[0]];
+  grub_relocator_xen_mmu_op[0].arg1.mfn = mfn_list[state.paging_start];
   grub_relocator_xen_mmu_op[1].cmd = MMUEXT_NEW_BASEPTR;
-  grub_relocator_xen_mmu_op[1].arg1.mfn = mfn_list[state.paging_start[0]];
+  grub_relocator_xen_mmu_op[1].arg1.mfn = mfn_list[state.paging_start];
   grub_relocator_xen_mmu_op[2].cmd = MMUEXT_UNPIN_TABLE;
   grub_relocator_xen_mmu_op[2].arg1.mfn =
     mfn_list[grub_xen_start_page_addr->pt_base >> 12];

grub-core/lib/xzembed/xz_dec_lzma2.c

@@ -1044,8 +1044,6 @@ enum xz_ret xz_dec_lzma2_run(
 
 			s->lzma2.sequence = SEQ_LZMA_PREPARE;
 
-		/* Fall through */
-
 		case SEQ_LZMA_PREPARE:
 			if (s->lzma2.compressed < RC_INIT_BYTES)
 				return XZ_DATA_ERROR;
@@ -1056,8 +1054,6 @@ enum xz_ret xz_dec_lzma2_run(
 			s->lzma2.compressed -= RC_INIT_BYTES;
 			s->lzma2.sequence = SEQ_LZMA_RUN;
 
-		/* Fall through */
-
 		case SEQ_LZMA_RUN:
 			/*
 			 * Set dictionary limit to indicate how much we want

grub-core/lib/xzembed/xz_dec_stream.c

@@ -750,7 +750,6 @@ static enum xz_ret dec_main(struct xz_dec *s, struct xz_buf *b)
 
 			s->sequence = SEQ_BLOCK_START;
 
-			/* FALLTHROUGH */
 		case SEQ_BLOCK_START:
 			/* We need one byte of input to continue. */
 			if (b->in_pos == b->in_size)
@@ -774,7 +773,6 @@ static enum xz_ret dec_main(struct xz_dec *s, struct xz_buf *b)
 			s->temp.pos = 0;
 			s->sequence = SEQ_BLOCK_HEADER;
 
-			/* FALLTHROUGH */
 		case SEQ_BLOCK_HEADER:
 			if (!fill_temp(s, b))
 				return XZ_OK;
@@ -785,7 +783,6 @@ static enum xz_ret dec_main(struct xz_dec *s, struct xz_buf *b)
 
 			s->sequence = SEQ_BLOCK_UNCOMPRESS;
 
-			/* FALLTHROUGH */
 		case SEQ_BLOCK_UNCOMPRESS:
 			ret = dec_block(s, b);
 			if (ret != XZ_STREAM_END)
@@ -813,7 +810,6 @@ static enum xz_ret dec_main(struct xz_dec *s, struct xz_buf *b)
 
 			s->sequence = SEQ_BLOCK_CHECK;
 
-			/* FALLTHROUGH */
 		case SEQ_BLOCK_CHECK:
 			ret = hash_validate(s, b, 0);
 			if (ret != XZ_STREAM_END)
@@ -862,7 +858,6 @@ static enum xz_ret dec_main(struct xz_dec *s, struct xz_buf *b)
 
 			s->sequence = SEQ_INDEX_CRC32;
 
-			/* FALLTHROUGH */
 		case SEQ_INDEX_CRC32:
 			ret = hash_validate(s, b, 1);
 			if (ret != XZ_STREAM_END)
@@ -871,7 +866,6 @@ static enum xz_ret dec_main(struct xz_dec *s, struct xz_buf *b)
 			s->temp.size = STREAM_HEADER_SIZE;
 			s->sequence = SEQ_STREAM_FOOTER;
 
-			/* FALLTHROUGH */
 		case SEQ_STREAM_FOOTER:
 			if (!fill_temp(s, b))
 				return XZ_OK;

grub-core/loader/arm64/fdt.c

@@ -28,6 +28,28 @@
 static void *loaded_fdt;
 static void *fdt;
 
+static void *
+get_firmware_fdt (void)
+{
+  grub_efi_configuration_table_t *tables;
+  grub_efi_guid_t fdt_guid = GRUB_EFI_DEVICE_TREE_GUID;
+  void *firmware_fdt = NULL;
+  unsigned int i;
+
+  /* Look for FDT in UEFI config tables. */
+  tables = grub_efi_system_table->configuration_table;
+
+  for (i = 0; i < grub_efi_system_table->num_table_entries; i++)
+    if (grub_memcmp (&tables[i].vendor_guid, &fdt_guid, sizeof (fdt_guid)) == 0)
+      {
+	firmware_fdt = tables[i].vendor_table;
+	grub_dprintf ("linux", "found registered FDT @ %p\n", firmware_fdt);
+	break;
+      }
+
+  return firmware_fdt;
+}
+
 void *
 grub_fdt_load (grub_size_t additional_size)
 {
@@ -43,7 +65,7 @@ grub_fdt_load (grub_size_t additional_size)
   if (loaded_fdt)
     raw_fdt = loaded_fdt;
   else
-    raw_fdt = grub_efi_get_firmware_fdt();
+    raw_fdt = get_firmware_fdt();
 
   size =
     raw_fdt ? grub_fdt_get_totalsize (raw_fdt) : GRUB_FDT_EMPTY_TREE_SZ;

grub-core/loader/efi/chainloader.c

@@ -122,8 +122,6 @@ copy_file_path (grub_efi_file_path_device_path_t *fp,
     if (*p == '/')
       *p = '\\';
 
-  /* File Path is NULL terminated */
-  fp->path_name[size++] = '\0';
   fp->header.length = size * sizeof (grub_efi_char16_t) + sizeof (*fp);
 }
 
@@ -158,10 +156,8 @@ make_file_path (grub_efi_device_path_t *dp, const char *filename)
       d = GRUB_EFI_NEXT_DEVICE_PATH (d);
     }
 
-  /* File Path is NULL terminated. Allocate space for 2 extra characters */
-  /* FIXME why we split path in two components? */
   file_path = grub_malloc (size
-			   + ((grub_strlen (dir_start) + 2)
+			   + ((grub_strlen (dir_start) + 1)
 			      * GRUB_MAX_UTF16_PER_UTF8
 			      * sizeof (grub_efi_char16_t))
 			   + sizeof (grub_efi_file_path_device_path_t) * 2);

grub-core/loader/i386/coreboot/chainloader.c

@@ -384,7 +384,6 @@ load_chewed (grub_file_t file, const char *filename)
 	  segment.len = 0;
 	  segment.offset = 0;
 	  segment.len = 0;
-	  /* Fallthrough.  */
 	case PAYLOAD_SEGMENT_CODE:
 	case PAYLOAD_SEGMENT_DATA:
 	  {

grub-core/loader/i386/linux.c

@@ -915,8 +915,8 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
 	    grub_env_set ("gfxpayload", "text");
 	    grub_printf_ (N_("%s is deprecated. "
 			     "Use set gfxpayload=%s before "
-			     "linux command instead.\n"),
-			  argv[i], "text");
+			     "linux command instead.\n"), "text",
+			  argv[i]);
 	    break;
 
 	  case 1:
@@ -925,8 +925,8 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
 	    grub_env_set ("gfxpayload", "text");
 	    grub_printf_ (N_("%s is deprecated. "
 			     "Use set gfxpayload=%s before "
-			     "linux command instead.\n"),
-			  argv[i], "text");
+			     "linux command instead.\n"), "text",
+			  argv[i]);
 	    break;
 	  default:
 	    /* Ignore invalid values.  */
@@ -984,13 +984,10 @@ grub_cmd_linux (grub_command_t cmd __attribute__ ((unused)),
 	      {
 	      case 'g':
 		shift += 10;
-		/* FALLTHROUGH */
 	      case 'm':
 		shift += 10;
-		/* FALLTHROUGH */
 	      case 'k':
 		shift += 10;
-		/* FALLTHROUGH */
 	      default:
 		break;
 	      }

grub-core/loader/i386/multiboot_mbi.c

@@ -70,18 +70,9 @@ load_kernel (grub_file_t file, const char *filename,
 	     char *buffer, struct multiboot_header *header)
 {
   grub_err_t err;
-  mbi_load_data_t mld;
-
-  mld.file = file;
-  mld.filename = filename;
-  mld.buffer = buffer;
-  mld.mbi_ver = 1;
-  mld.relocatable = 0;
-  mld.avoid_efi_boot_services = 0;
-
   if (grub_multiboot_quirks & GRUB_MULTIBOOT_QUIRK_BAD_KLUDGE)
     {
-      err = grub_multiboot_load_elf (&mld);
+      err = grub_multiboot_load_elf (file, filename, buffer);
       if (err == GRUB_ERR_NONE) {
 	return GRUB_ERR_NONE;
       }
@@ -130,7 +121,7 @@ load_kernel (grub_file_t file, const char *filename,
       return GRUB_ERR_NONE;
     }
 
-  return grub_multiboot_load_elf (&mld);
+  return grub_multiboot_load_elf (file, filename, buffer);
 }
 
 static struct multiboot_header *

grub-core/loader/i386/xen_file.c

@@ -20,16 +20,12 @@
 #include <grub/i386/linux.h>
 #include <grub/misc.h>
 
-#define XZ_MAGIC "\3757zXZ\0"
-
 grub_elf_t
 grub_xen_file (grub_file_t file)
 {
   grub_elf_t elf;
   struct linux_kernel_header lh;
   grub_file_t off_file;
-  grub_uint32_t payload_offset, payload_length;
-  grub_uint8_t magic[6];
 
   elf = grub_elf_file (file, file->name);
   if (elf)
@@ -50,36 +46,20 @@ grub_xen_file (grub_file_t file)
       return NULL;
     }
 
-  payload_length = lh.payload_length;
-  payload_offset = (lh.setup_sects + 1) * 512
-    + lh.payload_offset;
-
-  if (payload_length < sizeof (magic))
+  if (lh.payload_length < 4)
     {
       grub_error (GRUB_ERR_BAD_OS, "payload too short");
       return NULL;
     }
 
   grub_dprintf ("xen", "found bzimage payload 0x%llx-0x%llx\n",
-		(unsigned long long) payload_offset,
+		(unsigned long long) (lh.setup_sects + 1) * 512
+		+ lh.payload_offset,
 		(unsigned long long) lh.payload_length);
 
-  grub_file_seek (file, payload_offset);
-
-  if (grub_file_read (file, &magic, sizeof (magic)) != sizeof (magic))
-    {
-      if (!grub_errno)
-	grub_error (GRUB_ERR_BAD_OS, N_("premature end of file %s"),
-		    file->name);
-      goto fail;
-    }
-
-  /* Kernel suffixes xz payload with their uncompressed size.
-     Trim it.  */
-  if (grub_memcmp (magic, XZ_MAGIC, sizeof (XZ_MAGIC) - 1) == 0)
-    payload_length -= 4;
-  off_file = grub_file_offset_open (file, payload_offset,
-				    payload_length);
+  off_file = grub_file_offset_open (file, (lh.setup_sects + 1) * 512
+				    + lh.payload_offset,
+				    lh.payload_length);
   if (!off_file)
     goto fail;
 

grub-core/loader/i386/xen_fileXX.c

@@ -18,7 +18,6 @@
 
 #include <grub/xen_file.h>
 #include <grub/misc.h>
-#include <xen/elfnote.h>
 
 static grub_err_t
 parse_xen_guest (grub_elf_t elf, struct grub_xen_file_info *xi,
@@ -27,8 +26,6 @@ parse_xen_guest (grub_elf_t elf, struct grub_xen_file_info *xi,
   char *buf;
   char *ptr;
   int has_paddr = 0;
-
-  grub_errno = GRUB_ERR_NONE;
   if (grub_file_seek (elf->file, off) == (grub_off_t) -1)
     return grub_errno;
   buf = grub_malloc (sz);
@@ -38,8 +35,7 @@ parse_xen_guest (grub_elf_t elf, struct grub_xen_file_info *xi,
   if (grub_file_read (elf->file, buf, sz) != (grub_ssize_t) sz)
     {
       if (grub_errno)
-	goto out;
-      grub_free (buf);
+	return grub_errno;
       return grub_error (GRUB_ERR_BAD_OS, N_("premature end of file %s"),
 			 elf->file->name);
     }
@@ -127,14 +123,14 @@ parse_xen_guest (grub_elf_t elf, struct grub_xen_file_info *xi,
 	{
 	  xi->virt_base = grub_strtoull (ptr + sizeof ("VIRT_BASE=") - 1, &ptr, 16);
 	  if (grub_errno)
-	    goto out;
+	    return grub_errno;
 	  continue;
 	}
       if (grub_strncmp (ptr, "VIRT_ENTRY=", sizeof ("VIRT_ENTRY=") - 1) == 0)
 	{
 	  xi->entry_point = grub_strtoull (ptr + sizeof ("VIRT_ENTRY=") - 1, &ptr, 16);
 	  if (grub_errno)
-	    goto out;
+	    return grub_errno;
 	  continue;
 	}
       if (grub_strncmp (ptr, "HYPERCALL_PAGE=", sizeof ("HYPERCALL_PAGE=") - 1) == 0)
@@ -142,7 +138,7 @@ parse_xen_guest (grub_elf_t elf, struct grub_xen_file_info *xi,
 	  xi->hypercall_page = grub_strtoull (ptr + sizeof ("HYPERCALL_PAGE=") - 1, &ptr, 16);
 	  xi->has_hypercall_page = 1;
 	  if (grub_errno)
-	    goto out;
+	    return grub_errno;
 	  continue;
 	}
       if (grub_strncmp (ptr, "ELF_PADDR_OFFSET=", sizeof ("ELF_PADDR_OFFSET=") - 1) == 0)
@@ -150,7 +146,7 @@ parse_xen_guest (grub_elf_t elf, struct grub_xen_file_info *xi,
 	  xi->paddr_offset = grub_strtoull (ptr + sizeof ("ELF_PADDR_OFFSET=") - 1, &ptr, 16);
 	  has_paddr = 1;
 	  if (grub_errno)
-	    goto out;
+	    return grub_errno;
 	  continue;
 	}
     }
@@ -158,11 +154,7 @@ parse_xen_guest (grub_elf_t elf, struct grub_xen_file_info *xi,
     xi->hypercall_page = (xi->hypercall_page << 12) + xi->virt_base;
   if (!has_paddr)
     xi->paddr_offset = xi->virt_base;
-
-out:
-  grub_free (buf);
-
-  return grub_errno;
+  return GRUB_ERR_NONE;
 }
 
 #pragma GCC diagnostic ignored "-Wcast-align"
@@ -204,35 +196,35 @@ parse_note (grub_elf_t elf, struct grub_xen_file_info *xi,
       xi->has_note = 1;
       switch (nh->n_type)
 	{
-	case XEN_ELFNOTE_ENTRY:
+	case 1:
 	  xi->entry_point = grub_le_to_cpu_addr (*(Elf_Addr *) desc);
 	  break;
-	case XEN_ELFNOTE_HYPERCALL_PAGE:
+	case 2:
 	  xi->hypercall_page = grub_le_to_cpu_addr (*(Elf_Addr *) desc);
 	  xi->has_hypercall_page = 1;
 	  break;
-	case XEN_ELFNOTE_VIRT_BASE:
+	case 3:
 	  xi->virt_base = grub_le_to_cpu_addr (*(Elf_Addr *) desc);
 	  break;
-	case XEN_ELFNOTE_PADDR_OFFSET:
+	case 4:
 	  xi->paddr_offset = grub_le_to_cpu_addr (*(Elf_Addr *) desc);
 	  break;
-	case XEN_ELFNOTE_XEN_VERSION:
+	case 5:
 	  grub_dprintf ("xen", "xenversion = `%s'\n", (char *) desc);
 	  break;
-	case XEN_ELFNOTE_GUEST_OS:
+	case 6:
 	  grub_dprintf ("xen", "name = `%s'\n", (char *) desc);
 	  break;
-	case XEN_ELFNOTE_GUEST_VERSION:
+	case 7:
 	  grub_dprintf ("xen", "version = `%s'\n", (char *) desc);
 	  break;
-	case XEN_ELFNOTE_LOADER:
+	case 8:
 	  if (descsz < 7
 	      || grub_memcmp (desc, "generic", descsz == 7 ? 7 : 8) != 0)
 	    return grub_error (GRUB_ERR_BAD_OS, "invalid loader");
 	  break;
 	  /* PAE */
-	case XEN_ELFNOTE_PAE_MODE:
+	case 9:
 	  grub_dprintf ("xen", "pae = `%s', %d, %d\n", (char *) desc,
 			xi->arch, descsz);
 	  if (xi->arch != GRUB_XEN_FILE_I386
@@ -261,13 +253,6 @@ parse_note (grub_elf_t elf, struct grub_xen_file_info *xi,
 					  descsz == 2 ? 2 : 3) == 0)
 	    xi->arch = GRUB_XEN_FILE_I386;
 	  break;
-	case XEN_ELFNOTE_INIT_P2M:
-	  xi->p2m_base = grub_le_to_cpu_addr (*(Elf_Addr *) desc);
-	  xi->has_p2m_base = 1;
-	  break;
-	case XEN_ELFNOTE_MOD_START_PFN:
-	  xi->unmapped_initrd = !!grub_le_to_cpu32(*(grub_uint32_t *) desc);
-	  break;
 	default:
 	  grub_dprintf ("xen", "unknown note type %d\n", nh->n_type);
 	  break;

grub-core/loader/multiboot.c

@@ -118,48 +118,6 @@ grub_multiboot_set_video_mode (void)
   return err;
 }
 
-#ifdef GRUB_MACHINE_EFI
-#ifdef __x86_64__
-#define grub_relocator_efi_boot		grub_relocator64_efi_boot
-#define grub_relocator_efi_state	grub_relocator64_efi_state
-#endif
-#endif
-
-#ifdef grub_relocator_efi_boot
-static void
-efi_boot (struct grub_relocator *rel,
-	  grub_uint32_t target)
-{
-  struct grub_relocator_efi_state state_efi = MULTIBOOT_EFI_INITIAL_STATE;
-
-  state_efi.MULTIBOOT_EFI_ENTRY_REGISTER = grub_multiboot_payload_eip;
-  state_efi.MULTIBOOT_EFI_MBI_REGISTER = target;
-
-  grub_relocator_efi_boot (rel, state_efi);
-}
-#else
-#define grub_efi_is_finished	1
-static void
-efi_boot (struct grub_relocator *rel __attribute__ ((unused)),
-	  grub_uint32_t target __attribute__ ((unused)))
-{
-}
-#endif
-
-#if defined (__i386__) || defined (__x86_64__)
-static void
-normal_boot (struct grub_relocator *rel, struct grub_relocator32_state state)
-{
-  grub_relocator32_boot (rel, state, 0);
-}
-#else
-static void
-normal_boot (struct grub_relocator *rel, struct grub_relocator32_state state)
-{
-  grub_relocator32_boot (rel, state);
-}
-#endif
-
 static grub_err_t
 grub_multiboot_boot (void)
 {
@@ -173,10 +131,11 @@ grub_multiboot_boot (void)
   if (err)
     return err;
 
-  if (grub_efi_is_finished)
-    normal_boot (grub_multiboot_relocator, state);
-  else
-    efi_boot (grub_multiboot_relocator, state.MULTIBOOT_MBI_REGISTER);
+#if defined (__i386__) || defined (__x86_64__)
+  grub_relocator32_boot (grub_multiboot_relocator, state, 0);
+#else
+  grub_relocator32_boot (grub_multiboot_relocator, state);
+#endif
 
   /* Not reached.  */
   return GRUB_ERR_NONE;
@@ -207,12 +166,13 @@ static grub_uint64_t highest_load;
 
 /* Load ELF32 or ELF64.  */
 grub_err_t
-grub_multiboot_load_elf (mbi_load_data_t *mld)
+grub_multiboot_load_elf (grub_file_t file, const char *filename,
+			 void *buffer)
 {
-  if (grub_multiboot_is_elf32 (mld->buffer))
-    return grub_multiboot_load_elf32 (mld);
-  else if (grub_multiboot_is_elf64 (mld->buffer))
-    return grub_multiboot_load_elf64 (mld);
+  if (grub_multiboot_is_elf32 (buffer))
+    return grub_multiboot_load_elf32 (file, filename, buffer);
+  else if (grub_multiboot_is_elf64 (buffer))
+    return grub_multiboot_load_elf64 (file, filename, buffer);
 
   return grub_error (GRUB_ERR_UNKNOWN_OS, N_("invalid arch-dependent ELF magic"));
 }

grub-core/loader/multiboot_elfxx.c

@@ -51,15 +51,11 @@ CONCAT(grub_multiboot_is_elf, XX) (void *buffer)
 }
 
 static grub_err_t
-CONCAT(grub_multiboot_load_elf, XX) (mbi_load_data_t *mld)
+CONCAT(grub_multiboot_load_elf, XX) (grub_file_t file, const char *filename, void *buffer)
 {
-  Elf_Ehdr *ehdr = (Elf_Ehdr *) mld->buffer;
+  Elf_Ehdr *ehdr = (Elf_Ehdr *) buffer;
   char *phdr_base;
-  grub_err_t err;
-  grub_relocator_chunk_t ch;
-  grub_uint32_t load_offset, load_size;
   int i;
-  void *source;
 
   if (ehdr->e_ident[EI_MAG0] != ELFMAG0
       || ehdr->e_ident[EI_MAG1] != ELFMAG1
@@ -79,86 +75,54 @@ CONCAT(grub_multiboot_load_elf, XX) (mbi_load_data_t *mld)
   if (ehdr->e_phoff + (grub_uint32_t) ehdr->e_phnum * ehdr->e_phentsize > MULTIBOOT_SEARCH)
     return grub_error (GRUB_ERR_BAD_OS, "program header at a too high offset");
 
-  phdr_base = (char *) mld->buffer + ehdr->e_phoff;
+  phdr_base = (char *) buffer + ehdr->e_phoff;
 #define phdr(i)			((Elf_Phdr *) (phdr_base + (i) * ehdr->e_phentsize))
 
-  mld->link_base_addr = ~0;
-
-  /* Calculate lowest and highest load address.  */
-  for (i = 0; i < ehdr->e_phnum; i++)
-    if (phdr(i)->p_type == PT_LOAD)
-      {
-	mld->link_base_addr = grub_min (mld->link_base_addr, phdr(i)->p_paddr);
-	highest_load = grub_max (highest_load, phdr(i)->p_paddr + phdr(i)->p_memsz);
-      }
-
-#ifdef MULTIBOOT_LOAD_ELF64
-  if (highest_load >= 0x100000000)
-    return grub_error (GRUB_ERR_BAD_OS, "segment crosses 4 GiB border");
-#endif
-
-  load_size = highest_load - mld->link_base_addr;
-
-  if (mld->relocatable)
-    {
-      if (load_size > mld->max_addr || mld->min_addr > mld->max_addr - load_size)
-	return grub_error (GRUB_ERR_BAD_OS, "invalid min/max address and/or load size");
-
-      err = grub_relocator_alloc_chunk_align (grub_multiboot_relocator, &ch,
-					      mld->min_addr, mld->max_addr - load_size,
-					      load_size, mld->align ? mld->align : 1,
-					      mld->preference, mld->avoid_efi_boot_services);
-    }
-  else
-    err = grub_relocator_alloc_chunk_addr (grub_multiboot_relocator, &ch,
-					   mld->link_base_addr, load_size);
-
-  if (err)
-    {
-      grub_dprintf ("multiboot_loader", "Cannot allocate memory for OS image\n");
-      return err;
-    }
-
-  mld->load_base_addr = get_physical_target_address (ch);
-  source = get_virtual_current_address (ch);
-
-  grub_dprintf ("multiboot_loader", "link_base_addr=0x%x, load_base_addr=0x%x, "
-		"load_size=0x%x, relocatable=%d\n", mld->link_base_addr,
-		mld->load_base_addr, load_size, mld->relocatable);
-
-  if (mld->relocatable)
-    grub_dprintf ("multiboot_loader", "align=0x%lx, preference=0x%x, avoid_efi_boot_services=%d\n",
-		  (long) mld->align, mld->preference, mld->avoid_efi_boot_services);
-
   /* Load every loadable segment in memory.  */
   for (i = 0; i < ehdr->e_phnum; i++)
     {
       if (phdr(i)->p_type == PT_LOAD)
         {
+	  grub_err_t err;
+	  void *source;
+
+	  if (phdr(i)->p_paddr + phdr(i)->p_memsz > highest_load)
+	    highest_load = phdr(i)->p_paddr + phdr(i)->p_memsz;
 
 	  grub_dprintf ("multiboot_loader", "segment %d: paddr=0x%lx, memsz=0x%lx, vaddr=0x%lx\n",
 			i, (long) phdr(i)->p_paddr, (long) phdr(i)->p_memsz, (long) phdr(i)->p_vaddr);
 
-	  load_offset = phdr(i)->p_paddr - mld->link_base_addr;
+	  {
+	    grub_relocator_chunk_t ch;
+	    err = grub_relocator_alloc_chunk_addr (grub_multiboot_relocator, 
+						   &ch, phdr(i)->p_paddr,
+						   phdr(i)->p_memsz);
+	    if (err)
+	      {
+		grub_dprintf ("multiboot_loader", "Error loading phdr %d\n", i);
+		return err;
+	      }
+	    source = get_virtual_current_address (ch);
+	  }
 
 	  if (phdr(i)->p_filesz != 0)
 	    {
-	      if (grub_file_seek (mld->file, (grub_off_t) phdr(i)->p_offset)
+	      if (grub_file_seek (file, (grub_off_t) phdr(i)->p_offset)
 		  == (grub_off_t) -1)
 		return grub_errno;
 
-	      if (grub_file_read (mld->file, (grub_uint8_t *) source + load_offset, phdr(i)->p_filesz)
+	      if (grub_file_read (file, source, phdr(i)->p_filesz)
 		  != (grub_ssize_t) phdr(i)->p_filesz)
 		{
 		  if (!grub_errno)
 		    grub_error (GRUB_ERR_FILE_READ_ERROR, N_("premature end of file %s"),
-				mld->filename);
+				filename);
 		  return grub_errno;
 		}
 	    }
 
           if (phdr(i)->p_filesz < phdr(i)->p_memsz)
-            grub_memset ((grub_uint8_t *) source + load_offset + phdr(i)->p_filesz, 0,
+            grub_memset ((grub_uint8_t *) source + phdr(i)->p_filesz, 0,
 			 phdr(i)->p_memsz - phdr(i)->p_filesz);
         }
     }
@@ -204,18 +168,18 @@ CONCAT(grub_multiboot_load_elf, XX) (mbi_load_data_t *mld)
       if (!shdr)
 	return grub_errno;
       
-      if (grub_file_seek (mld->file, ehdr->e_shoff) == (grub_off_t) -1)
+      if (grub_file_seek (file, ehdr->e_shoff) == (grub_off_t) -1)
 	{
 	  grub_free (shdr);
 	  return grub_errno;
 	}
 
-      if (grub_file_read (mld->file, shdr, (grub_uint32_t) ehdr->e_shnum * ehdr->e_shentsize)
+      if (grub_file_read (file, shdr, (grub_uint32_t) ehdr->e_shnum * ehdr->e_shentsize)
               != (grub_ssize_t) ehdr->e_shnum * ehdr->e_shentsize)
 	{
 	  if (!grub_errno)
 	    grub_error (GRUB_ERR_FILE_READ_ERROR, N_("premature end of file %s"),
-			mld->filename);
+			filename);
 	  return grub_errno;
 	}
       
@@ -225,9 +189,7 @@ CONCAT(grub_multiboot_load_elf, XX) (mbi_load_data_t *mld)
 	  Elf_Shdr *sh = (Elf_Shdr *) shdrptr;
 	  void *src;
 	  grub_addr_t target;
-
-	  if (mld->mbi_ver >= 2 && (sh->sh_type == SHT_REL || sh->sh_type == SHT_RELA))
-	    return grub_error (GRUB_ERR_NOT_IMPLEMENTED_YET, "ELF files with relocs are not supported yet");
+	  grub_err_t err;
 
 	  /* This section is a loaded section,
 	     so we don't care.  */
@@ -238,28 +200,33 @@ CONCAT(grub_multiboot_load_elf, XX) (mbi_load_data_t *mld)
 	  if (sh->sh_size == 0)
 	    continue;
 
-	  err = grub_relocator_alloc_chunk_align (grub_multiboot_relocator, &ch, 0,
-						  (0xffffffff - sh->sh_size) + 1,
-						  sh->sh_size, sh->sh_addralign,
-						  GRUB_RELOCATOR_PREFERENCE_NONE,
-						  mld->avoid_efi_boot_services);
-	  if (err)
-	    {
-	      grub_dprintf ("multiboot_loader", "Error loading shdr %d\n", i);
-	      return err;
-	    }
-	  src = get_virtual_current_address (ch);
-	  target = get_physical_target_address (ch);
+	  {
+	    grub_relocator_chunk_t ch;
+	    err = grub_relocator_alloc_chunk_align (grub_multiboot_relocator,
+						    &ch, 0,
+						    (0xffffffff - sh->sh_size)
+						    + 1, sh->sh_size,
+						    sh->sh_addralign,
+						    GRUB_RELOCATOR_PREFERENCE_NONE,
+						    0);
+	    if (err)
+	      {
+		grub_dprintf ("multiboot_loader", "Error loading shdr %d\n", i);
+		return err;
+	      }
+	    src = get_virtual_current_address (ch);
+	    target = get_physical_target_address (ch);
+	  }
 
-	  if (grub_file_seek (mld->file, sh->sh_offset) == (grub_off_t) -1)
+	  if (grub_file_seek (file, sh->sh_offset) == (grub_off_t) -1)
 	    return grub_errno;
 
-          if (grub_file_read (mld->file, src, sh->sh_size)
+          if (grub_file_read (file, src, sh->sh_size)
               != (grub_ssize_t) sh->sh_size)
 	    {
 	      if (!grub_errno)
 		grub_error (GRUB_ERR_FILE_READ_ERROR, N_("premature end of file %s"),
-			    mld->filename);
+			    filename);
 	      return grub_errno;
 	    }
 	  sh->sh_addr = target;

grub-core/loader/multiboot_mbi2.c

@@ -68,7 +68,6 @@ static grub_size_t elf_sec_num, elf_sec_entsize;
 static unsigned elf_sec_shstrndx;
 static void *elf_sections;
 static int keep_bs = 0;
-static grub_uint32_t load_base_addr;
 
 void
 grub_multiboot_add_elfsyms (grub_size_t num, grub_size_t entsize,
@@ -102,40 +101,36 @@ find_header (grub_properly_aligned_t *buffer, grub_ssize_t len)
 grub_err_t
 grub_multiboot_load (grub_file_t file, const char *filename)
 {
+  grub_properly_aligned_t *buffer;
   grub_ssize_t len;
   struct multiboot_header *header;
   grub_err_t err;
   struct multiboot_header_tag *tag;
   struct multiboot_header_tag_address *addr_tag = NULL;
-  struct multiboot_header_tag_relocatable *rel_tag;
-  int entry_specified = 0, efi_entry_specified = 0;
-  grub_addr_t entry = 0, efi_entry = 0;
+  int entry_specified = 0;
+  grub_addr_t entry = 0;
   grub_uint32_t console_required = 0;
   struct multiboot_header_tag_framebuffer *fbtag = NULL;
   int accepted_consoles = GRUB_MULTIBOOT_CONSOLE_EGA_TEXT;
-  mbi_load_data_t mld;
 
-  mld.mbi_ver = 2;
-  mld.relocatable = 0;
-
-  mld.buffer = grub_malloc (MULTIBOOT_SEARCH);
-  if (!mld.buffer)
+  buffer = grub_malloc (MULTIBOOT_SEARCH);
+  if (!buffer)
     return grub_errno;
 
-  len = grub_file_read (file, mld.buffer, MULTIBOOT_SEARCH);
+  len = grub_file_read (file, buffer, MULTIBOOT_SEARCH);
   if (len < 32)
     {
-      grub_free (mld.buffer);
+      grub_free (buffer);
       return grub_error (GRUB_ERR_BAD_OS, N_("premature end of file %s"), filename);
     }
 
   COMPILE_TIME_ASSERT (MULTIBOOT_HEADER_ALIGN % 4 == 0);
 
-  header = find_header (mld.buffer, len);
+  header = find_header (buffer, len);
 
   if (header == 0)
     {
-      grub_free (mld.buffer);
+      grub_free (buffer);
       return grub_error (GRUB_ERR_BAD_ARGUMENT, "no multiboot header found");
     }
 
@@ -177,13 +172,10 @@ grub_multiboot_load (grub_file_t file, const char *filename)
 	      case MULTIBOOT_TAG_TYPE_NETWORK:
 	      case MULTIBOOT_TAG_TYPE_EFI_MMAP:
 	      case MULTIBOOT_TAG_TYPE_EFI_BS:
-	      case MULTIBOOT_TAG_TYPE_EFI32_IH:
-	      case MULTIBOOT_TAG_TYPE_EFI64_IH:
-	      case MULTIBOOT_TAG_TYPE_LOAD_BASE_ADDR:
 		break;
 
 	      default:
-		grub_free (mld.buffer);
+		grub_free (buffer);
 		return grub_error (GRUB_ERR_UNKNOWN_OS,
 				   "unsupported information tag: 0x%x",
 				   request_tag->requests[i]);
@@ -200,13 +192,6 @@ grub_multiboot_load (grub_file_t file, const char *filename)
 	entry = ((struct multiboot_header_tag_entry_address *) tag)->entry_addr;
 	break;
 
-      case MULTIBOOT_HEADER_TAG_ENTRY_ADDRESS_EFI64:
-#if defined (GRUB_MACHINE_EFI) && defined (__x86_64__)
-	efi_entry_specified = 1;
-	efi_entry = ((struct multiboot_header_tag_entry_address *) tag)->entry_addr;
-#endif
-	break;
-
       case MULTIBOOT_HEADER_TAG_CONSOLE_FLAGS:
 	if (!(((struct multiboot_header_tag_console_flags *) tag)->console_flags
 	    & MULTIBOOT_CONSOLE_FLAGS_EGA_TEXT_SUPPORTED))
@@ -221,50 +206,27 @@ grub_multiboot_load (grub_file_t file, const char *filename)
 	accepted_consoles |= GRUB_MULTIBOOT_CONSOLE_FRAMEBUFFER;
 	break;
 
-      case MULTIBOOT_HEADER_TAG_RELOCATABLE:
-	mld.relocatable = 1;
-	rel_tag = (struct multiboot_header_tag_relocatable *) tag;
-	mld.min_addr = rel_tag->min_addr;
-	mld.max_addr = rel_tag->max_addr;
-	mld.align = rel_tag->align;
-	switch (rel_tag->preference)
-	  {
-	  case MULTIBOOT_LOAD_PREFERENCE_LOW:
-	    mld.preference = GRUB_RELOCATOR_PREFERENCE_LOW;
-	    break;
-
-	  case MULTIBOOT_LOAD_PREFERENCE_HIGH:
-	    mld.preference = GRUB_RELOCATOR_PREFERENCE_HIGH;
-	    break;
-
-	  default:
-	    mld.preference = GRUB_RELOCATOR_PREFERENCE_NONE;
-	  }
-	break;
-
 	/* GRUB always page-aligns modules.  */
       case MULTIBOOT_HEADER_TAG_MODULE_ALIGN:
 	break;
 
       case MULTIBOOT_HEADER_TAG_EFI_BS:
-#ifdef GRUB_MACHINE_EFI
 	keep_bs = 1;
-#endif
 	break;
 
       default:
 	if (! (tag->flags & MULTIBOOT_HEADER_TAG_OPTIONAL))
 	  {
-	    grub_free (mld.buffer);
+	    grub_free (buffer);
 	    return grub_error (GRUB_ERR_UNKNOWN_OS,
 			       "unsupported tag: 0x%x", tag->type);
 	  }
 	break;
       }
 
-  if (addr_tag && !entry_specified && !(keep_bs && efi_entry_specified))
+  if (addr_tag && !entry_specified)
     {
-      grub_free (mld.buffer);
+      grub_free (buffer);
       return grub_error (GRUB_ERR_UNKNOWN_OS,
 			 "load address tag without entry address tag");
     }
@@ -273,8 +235,8 @@ grub_multiboot_load (grub_file_t file, const char *filename)
     {
       grub_uint64_t load_addr = (addr_tag->load_addr + 1)
 	? addr_tag->load_addr : (addr_tag->header_addr
-				 - ((char *) header - (char *) mld.buffer));
-      int offset = ((char *) header - (char *) mld.buffer -
+				 - ((char *) header - (char *) buffer));
+      int offset = ((char *) header - (char *) buffer -
 	   (addr_tag->header_addr - load_addr));
       int load_size = ((addr_tag->load_end_addr == 0) ? file->size - offset :
 		       addr_tag->load_end_addr - addr_tag->load_addr);
@@ -287,50 +249,27 @@ grub_multiboot_load (grub_file_t file, const char *filename)
       else
 	code_size = load_size;
 
-      if (mld.relocatable)
-	{
-	  if (code_size > mld.max_addr || mld.min_addr > mld.max_addr - code_size)
-	    {
-	      grub_free (mld.buffer);
-	      return grub_error (GRUB_ERR_BAD_OS, "invalid min/max address and/or load size");
-	    }
-
-	  err = grub_relocator_alloc_chunk_align (grub_multiboot_relocator, &ch,
-						  mld.min_addr, mld.max_addr - code_size,
-						  code_size, mld.align ? mld.align : 1,
-						  mld.preference, keep_bs);
-	}
-      else
-	err = grub_relocator_alloc_chunk_addr (grub_multiboot_relocator,
-					       &ch, load_addr, code_size);
+      err = grub_relocator_alloc_chunk_addr (grub_multiboot_relocator, 
+					     &ch, load_addr,
+					     code_size);
       if (err)
 	{
 	  grub_dprintf ("multiboot_loader", "Error loading aout kludge\n");
-	  grub_free (mld.buffer);
+	  grub_free (buffer);
 	  return err;
 	}
-      mld.link_base_addr = load_addr;
-      mld.load_base_addr = get_physical_target_address (ch);
       source = get_virtual_current_address (ch);
 
-      grub_dprintf ("multiboot_loader", "link_base_addr=0x%x, load_base_addr=0x%x, "
-		    "load_size=0x%lx, relocatable=%d\n", mld.link_base_addr,
-		    mld.load_base_addr, (long) code_size, mld.relocatable);
-
-      if (mld.relocatable)
-	grub_dprintf ("multiboot_loader", "align=0x%lx, preference=0x%x, avoid_efi_boot_services=%d\n",
-		      (long) mld.align, mld.preference, keep_bs);
-
       if ((grub_file_seek (file, offset)) == (grub_off_t) -1)
 	{
-	  grub_free (mld.buffer);
+	  grub_free (buffer);
 	  return grub_errno;
 	}
 
       grub_file_read (file, source, load_size);
       if (grub_errno)
 	{
-	  grub_free (mld.buffer);
+	  grub_free (buffer);
 	  return grub_errno;
 	}
 
@@ -340,41 +279,17 @@ grub_multiboot_load (grub_file_t file, const char *filename)
     }
   else
     {
-      mld.file = file;
-      mld.filename = filename;
-      mld.avoid_efi_boot_services = keep_bs;
-      err = grub_multiboot_load_elf (&mld);
+      err = grub_multiboot_load_elf (file, filename, buffer);
       if (err)
 	{
-	  grub_free (mld.buffer);
+	  grub_free (buffer);
 	  return err;
 	}
     }
 
-  load_base_addr = mld.load_base_addr;
-
-  if (keep_bs && efi_entry_specified)
-    grub_multiboot_payload_eip = efi_entry;
-  else if (entry_specified)
+  if (entry_specified)
     grub_multiboot_payload_eip = entry;
 
-  if (mld.relocatable)
-    {
-      /*
-       * Both branches are mathematically equivalent. However, it looks
-       * that real life (C?) is more complicated. I am trying to avoid
-       * wrap around here if mld.load_base_addr < mld.link_base_addr.
-       * If you look at C operator precedence then everything should work.
-       * However, I am not 100% sure that a given compiler will not
-       * optimize/break this stuff. So, maybe we should use signed
-       * 64-bit int here.
-       */
-      if (mld.load_base_addr >= mld.link_base_addr)
-	grub_multiboot_payload_eip += mld.load_base_addr - mld.link_base_addr;
-      else
-	grub_multiboot_payload_eip -= mld.link_base_addr - mld.load_base_addr;
-    }
-
   if (fbtag)
     err = grub_multiboot_set_console (GRUB_MULTIBOOT_CONSOLE_FRAMEBUFFER,
 				      accepted_consoles,
@@ -462,7 +377,7 @@ static grub_size_t
 grub_multiboot_get_mbi_size (void)
 {
 #ifdef GRUB_MACHINE_EFI
-  if (!keep_bs && !efi_mmap_size)
+  if (!efi_mmap_size)
     find_efi_mmap_size ();    
 #endif
   return 2 * sizeof (grub_uint32_t) + sizeof (struct multiboot_tag)
@@ -481,16 +396,13 @@ grub_multiboot_get_mbi_size (void)
 		 + grub_get_multiboot_mmap_count ()
 		 * sizeof (struct multiboot_mmap_entry)), MULTIBOOT_TAG_ALIGN)
     + ALIGN_UP (sizeof (struct multiboot_tag_framebuffer), MULTIBOOT_TAG_ALIGN)
+    + ALIGN_UP (sizeof (struct multiboot_tag_efi32), MULTIBOOT_TAG_ALIGN)
+    + ALIGN_UP (sizeof (struct multiboot_tag_efi64), MULTIBOOT_TAG_ALIGN)
     + ALIGN_UP (sizeof (struct multiboot_tag_old_acpi)
 		+ sizeof (struct grub_acpi_rsdp_v10), MULTIBOOT_TAG_ALIGN)
-    + ALIGN_UP (sizeof (struct multiboot_tag_load_base_addr), MULTIBOOT_TAG_ALIGN)
     + acpiv2_size ()
     + net_size ()
 #ifdef GRUB_MACHINE_EFI
-    + ALIGN_UP (sizeof (struct multiboot_tag_efi32), MULTIBOOT_TAG_ALIGN)
-    + ALIGN_UP (sizeof (struct multiboot_tag_efi32_ih), MULTIBOOT_TAG_ALIGN)
-    + ALIGN_UP (sizeof (struct multiboot_tag_efi64), MULTIBOOT_TAG_ALIGN)
-    + ALIGN_UP (sizeof (struct multiboot_tag_efi64_ih), MULTIBOOT_TAG_ALIGN)
     + ALIGN_UP (sizeof (struct multiboot_tag_efi_mmap)
 		+ efi_mmap_size, MULTIBOOT_TAG_ALIGN)
 #endif
@@ -766,15 +678,6 @@ grub_multiboot_make_mbi (grub_uint32_t *target)
 		       % sizeof (grub_properly_aligned_t) == 0);
   ptrorig += (2 * sizeof (grub_uint32_t)) / sizeof (grub_properly_aligned_t);
 
-  {
-    struct multiboot_tag_load_base_addr *tag = (struct multiboot_tag_load_base_addr *) ptrorig;
-    tag->type = MULTIBOOT_TAG_TYPE_LOAD_BASE_ADDR;
-    tag->size = sizeof (struct multiboot_tag_load_base_addr);
-    tag->load_base_addr = load_base_addr;
-    ptrorig += ALIGN_UP (tag->size, MULTIBOOT_TAG_ALIGN)
-       / sizeof (grub_properly_aligned_t);
-  }
-
   {
     struct multiboot_tag_string *tag = (struct multiboot_tag_string *) ptrorig;
     tag->type = MULTIBOOT_TAG_TYPE_CMDLINE;
@@ -837,13 +740,12 @@ grub_multiboot_make_mbi (grub_uint32_t *target)
       }
   }
 
-  if (!keep_bs)
-    {
-      struct multiboot_tag_mmap *tag = (struct multiboot_tag_mmap *) ptrorig;
-      grub_fill_multiboot_mmap (tag);
-      ptrorig += ALIGN_UP (tag->size, MULTIBOOT_TAG_ALIGN)
-	/ sizeof (grub_properly_aligned_t);
-    }
+  {
+    struct multiboot_tag_mmap *tag = (struct multiboot_tag_mmap *) ptrorig;
+    grub_fill_multiboot_mmap (tag);
+    ptrorig += ALIGN_UP (tag->size, MULTIBOOT_TAG_ALIGN)
+      / sizeof (grub_properly_aligned_t);
+  }
 
   {
     struct multiboot_tag_elf_sections *tag
@@ -859,19 +761,18 @@ grub_multiboot_make_mbi (grub_uint32_t *target)
       / sizeof (grub_properly_aligned_t);
   }
 
-  if (!keep_bs)
-    {
-      struct multiboot_tag_basic_meminfo *tag
-	= (struct multiboot_tag_basic_meminfo *) ptrorig;
-      tag->type = MULTIBOOT_TAG_TYPE_BASIC_MEMINFO;
-      tag->size = sizeof (struct multiboot_tag_basic_meminfo);
+  {
+    struct multiboot_tag_basic_meminfo *tag
+      = (struct multiboot_tag_basic_meminfo *) ptrorig;
+    tag->type = MULTIBOOT_TAG_TYPE_BASIC_MEMINFO;
+    tag->size = sizeof (struct multiboot_tag_basic_meminfo); 
 
-      /* Convert from bytes to kilobytes.  */
-      tag->mem_lower = grub_mmap_get_lower () / 1024;
-      tag->mem_upper = grub_mmap_get_upper () / 1024;
-      ptrorig += ALIGN_UP (tag->size, MULTIBOOT_TAG_ALIGN)
-	/ sizeof (grub_properly_aligned_t);
-    }
+    /* Convert from bytes to kilobytes.  */
+    tag->mem_lower = grub_mmap_get_lower () / 1024;
+    tag->mem_upper = grub_mmap_get_upper () / 1024;
+    ptrorig += ALIGN_UP (tag->size, MULTIBOOT_TAG_ALIGN)
+       / sizeof (grub_properly_aligned_t);
+  }
 
   {
     struct grub_net_network_level_interface *net;
@@ -970,57 +871,36 @@ grub_multiboot_make_mbi (grub_uint32_t *target)
     grub_efi_uintn_t efi_desc_size;
     grub_efi_uint32_t efi_desc_version;
 
+    tag->type = MULTIBOOT_TAG_TYPE_EFI_MMAP;
+    tag->size = sizeof (*tag) + efi_mmap_size;
+
     if (!keep_bs)
+      err = grub_efi_finish_boot_services (&efi_mmap_size, tag->efi_mmap, NULL,
+					   &efi_desc_size, &efi_desc_version);
+    else
       {
-	tag->type = MULTIBOOT_TAG_TYPE_EFI_MMAP;
-	tag->size = sizeof (*tag) + efi_mmap_size;
-
-	err = grub_efi_finish_boot_services (&efi_mmap_size, tag->efi_mmap, NULL,
-					     &efi_desc_size, &efi_desc_version);
-
-	if (err)
-	  return err;
-
-	tag->descr_size = efi_desc_size;
-	tag->descr_vers = efi_desc_version;
-	tag->size = sizeof (*tag) + efi_mmap_size;
-
-	ptrorig += ALIGN_UP (tag->size, MULTIBOOT_TAG_ALIGN)
-	  / sizeof (grub_properly_aligned_t);
+	if (grub_efi_get_memory_map (&efi_mmap_size, (void *) tag->efi_mmap,
+				     NULL,
+				     &efi_desc_size, &efi_desc_version) <= 0)
+	  err = grub_error (GRUB_ERR_IO, "couldn't retrieve memory map");
       }
+    if (err)
+      return err;
+    tag->descr_size = efi_desc_size;
+    tag->descr_vers = efi_desc_version;
+    tag->size = sizeof (*tag) + efi_mmap_size;
+
+    ptrorig += ALIGN_UP (tag->size, MULTIBOOT_TAG_ALIGN)
+      / sizeof (grub_properly_aligned_t);
   }
 
   if (keep_bs)
     {
-      {
-	struct multiboot_tag *tag = (struct multiboot_tag *) ptrorig;
-	tag->type = MULTIBOOT_TAG_TYPE_EFI_BS;
-	tag->size = sizeof (struct multiboot_tag);
-	ptrorig += ALIGN_UP (tag->size, MULTIBOOT_TAG_ALIGN)
-	  / sizeof (grub_properly_aligned_t);
-      }
-
-#ifdef __i386__
-      {
-	struct multiboot_tag_efi32_ih *tag = (struct multiboot_tag_efi32_ih *) ptrorig;
-	tag->type = MULTIBOOT_TAG_TYPE_EFI32_IH;
-	tag->size = sizeof (struct multiboot_tag_efi32_ih);
-	tag->pointer = (grub_addr_t) grub_efi_image_handle;
-	ptrorig += ALIGN_UP (tag->size, MULTIBOOT_TAG_ALIGN)
-	  / sizeof (grub_properly_aligned_t);
-      }
-#endif
-
-#ifdef __x86_64__
-      {
-	struct multiboot_tag_efi64_ih *tag = (struct multiboot_tag_efi64_ih *) ptrorig;
-	tag->type = MULTIBOOT_TAG_TYPE_EFI64_IH;
-	tag->size = sizeof (struct multiboot_tag_efi64_ih);
-	tag->pointer = (grub_addr_t) grub_efi_image_handle;
-	ptrorig += ALIGN_UP (tag->size, MULTIBOOT_TAG_ALIGN)
-	  / sizeof (grub_properly_aligned_t);
-      }
-#endif
+      struct multiboot_tag *tag = (struct multiboot_tag *) ptrorig;
+      tag->type = MULTIBOOT_TAG_TYPE_EFI_BS;
+      tag->size = sizeof (struct multiboot_tag);
+      ptrorig += ALIGN_UP (tag->size, MULTIBOOT_TAG_ALIGN)
+	/ sizeof (grub_properly_aligned_t);
     }
 #endif
 

grub-core/modinfo.sh.in

@@ -1,4 +1,4 @@
-#!@BUILD_SHEBANG@
+#!/bin/sh
 
 # User-controllable options
 grub_modinfo_target_cpu=@target_cpu@
@@ -19,7 +19,6 @@ grub_target_cflags='@TARGET_CFLAGS@'
 grub_target_cppflags='@TARGET_CPPFLAGS@'
 grub_target_ccasflags='@TARGET_CCASFLAGS@'
 grub_target_ldflags='@TARGET_LDFLAGS@'
-grub_target_incremental_ldflags='@TARGET_INCREMENTAL_LINK@'
 grub_cflags='@CFLAGS@'
 grub_cppflags='@CPPFLAGS@'
 grub_ccasflags='@CCASFLAGS@'

grub-core/net/arp.c

@@ -111,8 +111,8 @@ grub_net_arp_send_request (struct grub_net_network_level_interface *inf,
 }
 
 grub_err_t
-grub_net_arp_receive (struct grub_net_buff *nb, struct grub_net_card *card,
-                      grub_uint16_t *vlantag)
+grub_net_arp_receive (struct grub_net_buff *nb,
+		      struct grub_net_card *card)
 {
   struct arppkt *arp_packet = (struct arppkt *) nb->data;
   grub_net_network_level_address_t sender_addr, target_addr;
@@ -138,14 +138,6 @@ grub_net_arp_receive (struct grub_net_buff *nb, struct grub_net_card *card,
 
   FOR_NET_NETWORK_LEVEL_INTERFACES (inf)
   {
-    /* Verify vlantag id */
-    if (inf->card == card && inf->vlantag != *vlantag)
-      {
-        grub_dprintf ("net", "invalid vlantag! %x != %x\n",
-                      inf->vlantag, *vlantag);
-        break;
-      }
-
     /* Am I the protocol address target? */
     if (grub_net_addr_cmp (&inf->address, &target_addr) == 0
 	&& arp_packet->op == grub_cpu_to_be16_compile_time (ARP_REQUEST))

grub-core/net/bootp.c

@@ -142,7 +142,6 @@ grub_net_configure_by_dhcp_ack (const char *name,
   grub_net_link_level_address_t hwaddr;
   struct grub_net_network_level_interface *inter;
   int mask = -1;
-  char server_ip[sizeof ("xxx.xxx.xxx.xxx")];
 
   addr.type = GRUB_NET_NETWORK_LEVEL_PROTOCOL_IPV4;
   addr.ipv4 = bp->your_ip;
@@ -193,22 +192,15 @@ grub_net_configure_by_dhcp_ack (const char *name,
   if (size > OFFSET_OF (boot_file, bp))
     grub_env_set_net_property (name, "boot_file", bp->boot_file,
                                sizeof (bp->boot_file));
-  if (bp->server_ip)
-    {
-      grub_snprintf (server_ip, sizeof (server_ip), "%d.%d.%d.%d",
-		     ((grub_uint8_t *) &bp->server_ip)[0],
-		     ((grub_uint8_t *) &bp->server_ip)[1],
-		     ((grub_uint8_t *) &bp->server_ip)[2],
-		     ((grub_uint8_t *) &bp->server_ip)[3]);
-      grub_env_set_net_property (name, "next_server", server_ip, sizeof (server_ip));
-      grub_print_error ();
-    }
-
   if (is_def)
     grub_net_default_server = 0;
   if (is_def && !grub_net_default_server && bp->server_ip)
     {
-      grub_net_default_server = grub_strdup (server_ip);
+      grub_net_default_server = grub_xasprintf ("%d.%d.%d.%d",
+						((grub_uint8_t *) &bp->server_ip)[0],
+						((grub_uint8_t *) &bp->server_ip)[1],
+						((grub_uint8_t *) &bp->server_ip)[2],
+						((grub_uint8_t *) &bp->server_ip)[3]);
       grub_print_error ();
     }
 
@@ -220,7 +212,11 @@ grub_net_configure_by_dhcp_ack (const char *name,
 
   if (device && !*device && bp->server_ip)
     {
-      *device = grub_xasprintf ("tftp,%s", server_ip);
+      *device = grub_xasprintf ("tftp,%d.%d.%d.%d",
+				((grub_uint8_t *) &bp->server_ip)[0],
+				((grub_uint8_t *) &bp->server_ip)[1],
+				((grub_uint8_t *) &bp->server_ip)[2],
+				((grub_uint8_t *) &bp->server_ip)[3]);
       grub_print_error ();
     }
   if (size > OFFSET_OF (server_name, bp)

grub-core/net/dns.c

@@ -238,15 +238,6 @@ recv_hook (grub_net_udp_socket_t sock __attribute__ ((unused)),
   char *redirect_save = NULL;
   grub_uint32_t ttl_all = ~0U;
 
-  /* Code apparently assumed that only one packet is received as response.
-     We may get multiple responses due to network condition, so check here
-     and quit early. */
-  if (*data->addresses)
-    {
-      grub_netbuff_free (nb);
-      return GRUB_ERR_NONE;
-    }
-
   head = (struct dns_header *) nb->data;
   ptr = (grub_uint8_t *) (head + 1);
   if (ptr >= nb->tail)

grub-core/net/drivers/ieee1275/ofnet.c

@@ -85,30 +85,24 @@ get_card_packet (struct grub_net_card *dev)
   grub_uint64_t start_time;
   struct grub_net_buff *nb;
 
-  start_time = grub_get_time_ms ();
-  do
-    rc = grub_ieee1275_read (data->handle, dev->rcvbuf, dev->rcvbufsize, &actual);
-  while ((actual <= 0 || rc < 0) && (grub_get_time_ms () - start_time < 200));
-
-  if (actual <= 0)
-    return NULL;
-
-  nb = grub_netbuff_alloc (actual + 2);
+  nb = grub_netbuff_alloc (dev->mtu + 64 + 2);
   if (!nb)
     return NULL;
   /* Reserve 2 bytes so that 2 + 14/18 bytes of ethernet header is divisible
      by 4. So that IP header is aligned on 4 bytes. */
   grub_netbuff_reserve (nb, 2);
 
-  grub_memcpy (nb->data, dev->rcvbuf, actual);
-
-  if (grub_netbuff_put (nb, actual))
+  start_time = grub_get_time_ms ();
+  do
+    rc = grub_ieee1275_read (data->handle, nb->data, dev->mtu + 64, &actual);
+  while ((actual <= 0 || rc < 0) && (grub_get_time_ms () - start_time < 200));
+  if (actual > 0)
     {
-      grub_netbuff_free (nb);
-      return NULL;
+      grub_netbuff_put (nb, actual);
+      return nb;
     }
-
-  return nb;
+  grub_netbuff_free (nb);
+  return NULL;
 }
 
 static struct grub_net_card_driver ofdriver =
@@ -146,18 +140,18 @@ enum
 };
 
 static int
-grub_ieee1275_parse_bootargs (const char *devpath, char *bootpath,
+grub_ieee1275_parse_bootpath (const char *devpath, char *bootpath,
                               char **device, struct grub_net_card **card)
 {
   char *args;
   char *comma_char = 0;
   char *equal_char = 0;
   grub_size_t field_counter = 0;
+
   grub_net_network_level_address_t client_addr, gateway_addr, subnet_mask;
   grub_net_link_level_address_t hw_addr;
   grub_net_interface_flags_t flags = 0;
   struct grub_net_network_level_interface *inter = NULL;
-  grub_uint16_t vlantag = 0;
 
   hw_addr.type = GRUB_NET_LINK_LEVEL_PROTOCOL_ETHERNET;
 
@@ -175,11 +169,6 @@ grub_ieee1275_parse_bootargs (const char *devpath, char *bootpath,
           *equal_char = 0;
           grub_env_set_net_property ((*card)->name, args, equal_char + 1,
                                      grub_strlen(equal_char + 1));
-
-          if ((grub_strcmp (args, "vtag") == 0) &&
-              (grub_strlen (equal_char + 1) == 8))
-            vlantag = grub_strtoul (equal_char + 1 + 4, 0, 16);
-
           *equal_char = '=';
         }
       else
@@ -218,10 +207,8 @@ grub_ieee1275_parse_bootargs (const char *devpath, char *bootpath,
                                   hw_addr.mac, sizeof(hw_addr.mac), 0);
       inter = grub_net_add_addr ((*card)->name, *card, &client_addr, &hw_addr,
                                  flags);
-      inter->vlantag = vlantag;
       grub_net_add_ipv4_local (inter,
                           __builtin_ctz (~grub_le_to_cpu32 (subnet_mask.ipv4)));
-
     }
 
   if (gateway_addr.ipv4 != 0)
@@ -274,7 +261,7 @@ grub_ieee1275_net_config_real (const char *devpath, char **device, char **path,
       }
     grub_free (canon);
 
-    grub_ieee1275_parse_bootargs (devpath, bootpath, device, &card);
+    grub_ieee1275_parse_bootpath (devpath, bootpath, device, &card);
 
     for (i = 0; i < ARRAY_SIZE (bootp_response_properties); i++)
       if (grub_ieee1275_get_property_length (grub_ieee1275_chosen,
@@ -307,91 +294,6 @@ grub_ieee1275_net_config_real (const char *devpath, char **device, char **path,
   }
 }
 
-/* Allocate memory with alloc-mem */
-static void *
-grub_ieee1275_alloc_mem (grub_size_t len)
-{
-  struct alloc_args
-  {
-    struct grub_ieee1275_common_hdr common;
-    grub_ieee1275_cell_t method;
-    grub_ieee1275_cell_t len;
-    grub_ieee1275_cell_t catch;
-    grub_ieee1275_cell_t result;
-  }
-  args;
-
-  if (grub_ieee1275_test_flag (GRUB_IEEE1275_FLAG_CANNOT_INTERPRET))
-    {
-      grub_error (GRUB_ERR_UNKNOWN_COMMAND, N_("interpret is not supported"));
-      return NULL;
-    }
-
-  INIT_IEEE1275_COMMON (&args.common, "interpret", 2, 2);
-  args.len = len;
-  args.method = (grub_ieee1275_cell_t) "alloc-mem";
-
-  if (IEEE1275_CALL_ENTRY_FN (&args) == -1 || args.catch)
-    {
-      grub_error (GRUB_ERR_INVALID_COMMAND, N_("alloc-mem failed"));
-      return NULL;
-    }
-  else
-    return (void *)args.result;
-}
-
-/* Free memory allocated by alloc-mem */
-static grub_err_t
-grub_ieee1275_free_mem (void *addr, grub_size_t len)
-{
-  struct free_args
-  {
-    struct grub_ieee1275_common_hdr common;
-    grub_ieee1275_cell_t method;
-    grub_ieee1275_cell_t len;
-    grub_ieee1275_cell_t addr;
-    grub_ieee1275_cell_t catch;
-  }
-  args;
-
-  if (grub_ieee1275_test_flag (GRUB_IEEE1275_FLAG_CANNOT_INTERPRET))
-    {
-      grub_error (GRUB_ERR_UNKNOWN_COMMAND, N_("interpret is not supported"));
-      return grub_errno;
-    }
-
-  INIT_IEEE1275_COMMON (&args.common, "interpret", 3, 1);
-  args.addr = (grub_ieee1275_cell_t)addr;
-  args.len = len;
-  args.method = (grub_ieee1275_cell_t) "free-mem";
-
-  if (IEEE1275_CALL_ENTRY_FN(&args) == -1 || args.catch)
-    {
-      grub_error (GRUB_ERR_INVALID_COMMAND, N_("free-mem failed"));
-      return grub_errno;
-    }
-
-  return GRUB_ERR_NONE;
-}
-
-static void *
-ofnet_alloc_netbuf (grub_size_t len)
-{
-  if (grub_ieee1275_test_flag (GRUB_IEEE1275_FLAG_VIRT_TO_REAL_BROKEN))
-    return grub_ieee1275_alloc_mem (len);
-  else
-    return grub_zalloc (len);
-}
-
-static void
-ofnet_free_netbuf (void *addr, grub_size_t len)
-{
-  if (grub_ieee1275_test_flag (GRUB_IEEE1275_FLAG_VIRT_TO_REAL_BROKEN))
-    grub_ieee1275_free_mem (addr, len);
-  else
-    grub_free (addr);
-}
-
 static int
 search_net_devices (struct grub_ieee1275_devalias *alias)
 {
@@ -507,19 +409,40 @@ search_net_devices (struct grub_ieee1275_devalias *alias)
   card->default_address = lla;
 
   card->txbufsize = ALIGN_UP (card->mtu, 64) + 256;
-  card->rcvbufsize = ALIGN_UP (card->mtu, 64) + 256;
 
-  card->txbuf = ofnet_alloc_netbuf (card->txbufsize);
-  if (!card->txbuf)
-    goto fail_netbuf;
-
-  card->rcvbuf = ofnet_alloc_netbuf (card->rcvbufsize);
-  if (!card->rcvbuf)
+  if (grub_ieee1275_test_flag (GRUB_IEEE1275_FLAG_VIRT_TO_REAL_BROKEN))
     {
-      grub_error_push ();
-      ofnet_free_netbuf (card->txbuf, card->txbufsize);
-      grub_error_pop ();
-      goto fail_netbuf;
+      struct alloc_args
+      {
+	struct grub_ieee1275_common_hdr common;
+	grub_ieee1275_cell_t method;
+	grub_ieee1275_cell_t len;
+	grub_ieee1275_cell_t catch;
+	grub_ieee1275_cell_t result;
+      }
+      args;
+      INIT_IEEE1275_COMMON (&args.common, "interpret", 2, 2);
+      args.len = card->txbufsize;
+      args.method = (grub_ieee1275_cell_t) "alloc-mem";
+
+      if (IEEE1275_CALL_ENTRY_FN (&args) == -1
+	  || args.catch)
+	{
+	  card->txbuf = 0;
+	  grub_error (GRUB_ERR_OUT_OF_MEMORY, N_("out of memory"));
+	}
+      else
+	card->txbuf = (void *) args.result;
+    }
+  else
+    card->txbuf = grub_zalloc (card->txbufsize);
+  if (!card->txbuf)
+    {
+      grub_free (ofdata->path);
+      grub_free (ofdata);
+      grub_free (card);
+      grub_print_error ();
+      return 0;
     }
   card->driver = NULL;
   card->data = ofdata;
@@ -532,13 +455,6 @@ search_net_devices (struct grub_ieee1275_devalias *alias)
   card->driver = &ofdriver;
   grub_net_card_register (card);
   return 0;
-
-fail_netbuf:
-  grub_free (ofdata->path);
-  grub_free (ofdata);
-  grub_free (card);
-  grub_print_error ();
-  return 0;
 }
 
 static void

grub-core/net/ethernet.c

@@ -18,7 +18,6 @@
 
 #include <grub/misc.h>
 #include <grub/mm.h>
-#include <grub/env.h>
 #include <grub/net/ethernet.h>
 #include <grub/net/ip.h>
 #include <grub/net/arp.h>
@@ -57,17 +56,10 @@ send_ethernet_packet (struct grub_net_network_level_interface *inf,
 {
   struct etherhdr *eth;
   grub_err_t err;
-  grub_uint8_t etherhdr_size;
-  grub_uint16_t vlantag_id = VLANTAG_IDENTIFIER;
 
-  etherhdr_size = sizeof (*eth);
-  COMPILE_TIME_ASSERT (sizeof (*eth) + 4 < GRUB_NET_MAX_LINK_HEADER_SIZE);
+  COMPILE_TIME_ASSERT (sizeof (*eth) < GRUB_NET_MAX_LINK_HEADER_SIZE);
 
-  /* Increase ethernet header in case of vlantag */
-  if (inf->vlantag != 0)
-    etherhdr_size += 4;
-
-  err = grub_netbuff_push (nb, etherhdr_size);
+  err = grub_netbuff_push (nb, sizeof (*eth));
   if (err)
     return err;
   eth = (struct etherhdr *) nb->data;
@@ -84,19 +76,6 @@ send_ethernet_packet (struct grub_net_network_level_interface *inf,
 	return err;
       inf->card->opened = 1;
     }
-
-  /* Check and add a vlan-tag if needed. */
-  if (inf->vlantag != 0)
-    {
-      /* Move eth type to the right */
-      grub_memcpy ((char *) nb->data + etherhdr_size - 2,
-                   (char *) nb->data + etherhdr_size - 6, 2);
-
-      /* Add the tag in the middle */
-      grub_memcpy ((char *) nb->data + etherhdr_size - 6, &vlantag_id, 2);
-      grub_memcpy ((char *) nb->data + etherhdr_size - 4, (char *) &(inf->vlantag), 2);
-    }
-
   return inf->card->driver->send (inf->card, nb);
 }
 
@@ -111,25 +90,10 @@ grub_net_recv_ethernet_packet (struct grub_net_buff *nb,
   grub_net_link_level_address_t hwaddress;
   grub_net_link_level_address_t src_hwaddress;
   grub_err_t err;
-  grub_uint8_t etherhdr_size = sizeof (*eth);
-  grub_uint16_t vlantag = 0;
-
-
-  /* Check if a vlan-tag is present. If so, the ethernet header is 4 bytes */
-  /* longer than the original one. The vlantag id is extracted and the header */
-  /* is reseted to the original size. */
-  if (grub_get_unaligned16 (nb->data + etherhdr_size - 2) == VLANTAG_IDENTIFIER)
-    {
-      vlantag = grub_get_unaligned16 (nb->data + etherhdr_size);
-      etherhdr_size += 4;
-      /* Move eth type to the original position */
-      grub_memcpy((char *) nb->data + etherhdr_size - 6,
-                  (char *) nb->data + etherhdr_size - 2, 2);
-    }
 
   eth = (struct etherhdr *) nb->data;
   type = grub_be_to_cpu16 (eth->type);
-  err = grub_netbuff_pull (nb, etherhdr_size);
+  err = grub_netbuff_pull (nb, sizeof (*eth));
   if (err)
     return err;
 
@@ -157,14 +121,13 @@ grub_net_recv_ethernet_packet (struct grub_net_buff *nb,
     {
       /* ARP packet. */
     case GRUB_NET_ETHERTYPE_ARP:
-      grub_net_arp_receive (nb, card, &vlantag);
+      grub_net_arp_receive (nb, card);
       grub_netbuff_free (nb);
       return GRUB_ERR_NONE;
       /* IP packet.  */
     case GRUB_NET_ETHERTYPE_IP:
     case GRUB_NET_ETHERTYPE_IP6:
-      return grub_net_recv_ip_packets (nb, card, &hwaddress, &src_hwaddress,
-                                       &vlantag);
+      return grub_net_recv_ip_packets (nb, card, &hwaddress, &src_hwaddress);
     }
   grub_netbuff_free (nb);
   return GRUB_ERR_NONE;

grub-core/net/ip.c

@@ -228,13 +228,12 @@ handle_dgram (struct grub_net_buff *nb,
 	      grub_net_ip_protocol_t proto,
 	      const grub_net_network_level_address_t *source,
 	      const grub_net_network_level_address_t *dest,
-              grub_uint16_t *vlantag,
 	      grub_uint8_t ttl)
 {
   struct grub_net_network_level_interface *inf = NULL;
   grub_err_t err;
   int multicast = 0;
-
+  
   /* DHCP needs special treatment since we don't know IP yet.  */
   {
     struct udphdr *udph;
@@ -294,15 +293,6 @@ handle_dgram (struct grub_net_buff *nb,
 	&& grub_net_addr_cmp (&inf->address, dest) == 0
 	&& grub_net_hwaddr_cmp (&inf->hwaddress, hwaddress) == 0)
       break;
-
-    /* Verify vlantag id */
-    if (inf->card == card && inf->vlantag != *vlantag)
-      {
-        grub_dprintf ("net", "invalid vlantag! %x != %x\n",
-                      inf->vlantag, *vlantag);
-        break;
-      }
-
     /* Solicited node multicast.  */
     if (inf->card == card
 	&& inf->address.type == GRUB_NET_NETWORK_LEVEL_PROTOCOL_IPV6
@@ -373,9 +363,7 @@ static void
 free_old_fragments (void)
 {
   struct reassemble *rsm, **prev;
-  grub_uint64_t limit_time = grub_get_time_ms ();
-
-  limit_time = (limit_time > 90000) ? limit_time - 90000 : 0;
+  grub_uint64_t limit_time = grub_get_time_ms () - 90000;
 
   for (prev = &reassembles, rsm = *prev; rsm; rsm = *prev)
     if (rsm->last_time < limit_time)
@@ -393,8 +381,7 @@ static grub_err_t
 grub_net_recv_ip4_packets (struct grub_net_buff *nb,
 			   struct grub_net_card *card,
 			   const grub_net_link_level_address_t *hwaddress,
-			   const grub_net_link_level_address_t *src_hwaddress,
-                           grub_uint16_t *vlantag)
+			   const grub_net_link_level_address_t *src_hwaddress)
 {
   struct iphdr *iph = (struct iphdr *) nb->data;
   grub_err_t err;
@@ -469,7 +456,7 @@ grub_net_recv_ip4_packets (struct grub_net_buff *nb,
       dest.ipv4 = iph->dest;
 
       return handle_dgram (nb, card, src_hwaddress, hwaddress, iph->protocol,
-			   &source, &dest, vlantag, iph->ttl);
+			   &source, &dest, iph->ttl);
     }
 
   for (prev = &reassembles, rsm = *prev; rsm; prev = &rsm->next, rsm = *prev)
@@ -605,7 +592,7 @@ grub_net_recv_ip4_packets (struct grub_net_buff *nb,
       dest.ipv4 = dst;
 
       return handle_dgram (ret, card, src_hwaddress,
-			   hwaddress, proto, &source, &dest, vlantag,
+			   hwaddress, proto, &source, &dest,
 			   ttl);
     }
 }
@@ -663,8 +650,7 @@ static grub_err_t
 grub_net_recv_ip6_packets (struct grub_net_buff *nb,
 			   struct grub_net_card *card,
 			   const grub_net_link_level_address_t *hwaddress,
-			   const grub_net_link_level_address_t *src_hwaddress,
-                           grub_uint16_t *vlantag)
+			   const grub_net_link_level_address_t *src_hwaddress)
 {
   struct ip6hdr *iph = (struct ip6hdr *) nb->data;
   grub_err_t err;
@@ -715,24 +701,21 @@ grub_net_recv_ip6_packets (struct grub_net_buff *nb,
   grub_memcpy (dest.ipv6, &iph->dest, sizeof (dest.ipv6));
 
   return handle_dgram (nb, card, src_hwaddress, hwaddress, iph->protocol,
-		       &source, &dest, vlantag, iph->ttl);
+		       &source, &dest, iph->ttl);
 }
 
 grub_err_t
 grub_net_recv_ip_packets (struct grub_net_buff *nb,
 			  struct grub_net_card *card,
 			  const grub_net_link_level_address_t *hwaddress,
-			  const grub_net_link_level_address_t *src_hwaddress,
-                          grub_uint16_t *vlantag)
+			  const grub_net_link_level_address_t *src_hwaddress)
 {
   struct iphdr *iph = (struct iphdr *) nb->data;
 
   if ((iph->verhdrlen >> 4) == 4)
-    return grub_net_recv_ip4_packets (nb, card, hwaddress, src_hwaddress,
-                                      vlantag);
+    return grub_net_recv_ip4_packets (nb, card, hwaddress, src_hwaddress);
   if ((iph->verhdrlen >> 4) == 6)
-    return grub_net_recv_ip6_packets (nb, card, hwaddress, src_hwaddress,
-                                      vlantag);
+    return grub_net_recv_ip6_packets (nb, card, hwaddress, src_hwaddress);
   grub_dprintf ("net", "Bad IP version: %d\n", (iph->verhdrlen >> 4));
   grub_netbuff_free (nb);
   return GRUB_ERR_NONE;

grub-core/normal/charset.c

@@ -1144,16 +1144,6 @@ grub_bidi_line_logical_to_visual (const grub_uint32_t *logical,
   }
 }
 
-static int
-is_visible (const struct grub_unicode_glyph *gl)
-{
-  if (gl->ncomb)
-    return 1;
-  if (gl->base == GRUB_UNICODE_LRM || gl->base == GRUB_UNICODE_RLM)
-    return 0;
-  return 1;
-}
-
 grub_ssize_t
 grub_bidi_logical_to_visual (const grub_uint32_t *logical,
 			     grub_size_t logical_len,
@@ -1174,7 +1164,6 @@ grub_bidi_logical_to_visual (const grub_uint32_t *logical,
       if (ptr == logical + logical_len || *ptr == '\n')
 	{
 	  grub_ssize_t ret;
-	  grub_ssize_t i, j;
 	  ret = grub_bidi_line_logical_to_visual (line_start,
 						  ptr - line_start,
 						  visual_ptr,
@@ -1193,10 +1182,7 @@ grub_bidi_logical_to_visual (const grub_uint32_t *logical,
 	      grub_free (*visual_out);
 	      return ret;
 	    }
-	  for (i = 0, j = 0; i < ret; i++)
-	    if (is_visible(&visual_ptr[i]))
-	      visual_ptr[j++] = visual_ptr[i];
-	  visual_ptr += j;
+	  visual_ptr += ret; 
 	  line_start = ptr;
 	  if (ptr != logical + logical_len)
 	    {

grub-core/osdep/devmapper/getroot.c

@@ -143,7 +143,7 @@ grub_util_get_dm_abstraction (const char *os_dev)
       grub_free (uuid);
       return GRUB_DEV_ABSTRACTION_LVM;
     }
-  if (strncmp (uuid, "CRYPT-LUKS1-", 12) == 0)
+  if (strncmp (uuid, "CRYPT-LUKS1-", 4) == 0)
     {
       grub_free (uuid);
       return GRUB_DEV_ABSTRACTION_LUKS;

grub-core/osdep/linux/getroot.c

@@ -380,30 +380,24 @@ get_btrfs_fs_prefix (const char *mount_path)
 char **
 grub_find_root_devices_from_mountinfo (const char *dir, char **relroot)
 {
-  FILE *fp = NULL;
+  FILE *fp;
   char *buf = NULL;
   size_t len = 0;
-  grub_size_t entry_len, entry_max = 4;
+  grub_size_t entry_len = 0, entry_max = 4;
   struct mountinfo_entry *entries;
   struct mountinfo_entry parent_entry = { 0, 0, 0, "", "", "", "" };
   int i;
-  int retry = 0;
-  int dir_fd = -1;
-  char **ret = NULL;
 
   if (! *dir)
     dir = "/";
   if (relroot)
     *relroot = NULL;
 
-  entries = xmalloc (entry_max * sizeof (*entries));
-
-again:
   fp = grub_util_fopen ("/proc/self/mountinfo", "r");
   if (! fp)
-    goto out; /* fall through to other methods */
+    return NULL; /* fall through to other methods */
 
-  entry_len = 0;
+  entries = xmalloc (entry_max * sizeof (*entries));
 
   /* First, build a list of relevant visible mounts.  */
   while (getline (&buf, &len, fp) > 0)
@@ -490,6 +484,7 @@ again:
   /* Now scan visible mounts for the ones we're interested in.  */
   for (i = entry_len - 1; i >= 0; i--)
     {
+      char **ret = NULL;
       char *fs_prefix = NULL;
       if (!*entries[i].device)
 	continue;
@@ -520,23 +515,6 @@ again:
 	  ret = grub_find_root_devices_from_btrfs (dir);
 	  fs_prefix = get_btrfs_fs_prefix (entries[i].enc_path);
 	}
-      else if (!retry && grub_strcmp (entries[i].fstype, "autofs") == 0)
-	{
-	  /* If the best match is automounted, try to trigger mount. We cannot
-	     simply return here because stat() on automounted directory does not
-	     trigger mount and returns bogus (pseudo)device number instead.
-	     We keep mountpoint open until end of scan to prevent timeout. */
-
-	  int flags = O_RDONLY|O_DIRECTORY;
-
-	  fclose (fp);
-#ifdef O_LARGEFILE
-	  flags |= O_LARGEFILE;
-#endif
-	  dir_fd = open (entries[i].enc_path, flags);
-	  retry = 1;
-	  goto again;
-	}
       if (!ret)
 	{
 	  ret = xmalloc (2 * sizeof (ret[0]));
@@ -566,17 +544,16 @@ again:
 	}
       if (fs_prefix != entries[i].enc_root)
 	free (fs_prefix);
-      break;
+      free (buf);
+      free (entries);
+      fclose (fp);
+      return ret;
     }
 
-out:
   free (buf);
   free (entries);
-  if (fp)
-    fclose (fp);
-  if (dir_fd != -1)
-    close (dir_fd);
-  return ret;
+  fclose (fp);
+  return NULL;
 }
 
 static char *

grub-core/osdep/unix/hostdisk.c

@@ -77,19 +77,11 @@ grub_util_get_fd_size (grub_util_fd_t fd, const char *name, unsigned *log_secsiz
 int
 grub_util_fd_seek (grub_util_fd_t fd, grub_uint64_t off)
 {
-#if SIZEOF_OFF_T == 8
   off_t offset = (off_t) off;
 
   if (lseek (fd, offset, SEEK_SET) != offset)
     return -1;
-#elif SIZEOF_OFF64_T == 8
-  off64_t offset = (off64_t) off;
 
-  if (lseek64 (fd, offset, SEEK_SET) != offset)
-    return -1;
-#else
-#error "No large file support"
-#endif
   return 0;
 }
 

grub-core/script/lexer.c

@@ -251,6 +251,7 @@ grub_script_lexer_init (struct grub_parser_param *parser, char *script,
     {
       parser->lexerstate = 0;
       yylex_destroy (lexerstate->yyscanner);
+      grub_free (lexerstate->yyscanner);
       grub_free (lexerstate->text);
       grub_free (lexerstate);
       return 0;

grub-core/term/at_keyboard.c

@@ -88,7 +88,7 @@ static const grub_uint8_t set1_mapping[128] =
     /* 0x4c */ GRUB_KEYBOARD_KEY_NUM5,        GRUB_KEYBOARD_KEY_NUM6, 
     /* 0x4e */ GRUB_KEYBOARD_KEY_NUMPLUS,     GRUB_KEYBOARD_KEY_NUM1, 
     /* 0x50 */ GRUB_KEYBOARD_KEY_NUM2,        GRUB_KEYBOARD_KEY_NUM3, 
-    /* 0x52 */ GRUB_KEYBOARD_KEY_NUM0,        GRUB_KEYBOARD_KEY_NUMDOT, 
+    /* 0x52 */ GRUB_KEYBOARD_KEY_NUMDOT,      GRUB_KEYBOARD_KEY_NUMDOT, 
     /* 0x54 */ 0,                             0, 
     /* 0x56 */ GRUB_KEYBOARD_KEY_102ND,       GRUB_KEYBOARD_KEY_F11, 
     /* 0x58 */ GRUB_KEYBOARD_KEY_F12,         0,
@@ -193,7 +193,7 @@ static const grub_uint8_t set2_mapping[256] =
     /* 0x6a */ GRUB_KEYBOARD_KEY_JP_YEN,      GRUB_KEYBOARD_KEY_NUM4,
     /* 0x6c */ GRUB_KEYBOARD_KEY_NUM7,        GRUB_KEYBOARD_KEY_KPCOMMA,
     /* 0x6e */ 0,                             0,
-    /* 0x70 */ GRUB_KEYBOARD_KEY_NUM0,        GRUB_KEYBOARD_KEY_NUMDOT,
+    /* 0x70 */ GRUB_KEYBOARD_KEY_NUMDOT,      GRUB_KEYBOARD_KEY_NUM0,
     /* 0x72 */ GRUB_KEYBOARD_KEY_NUM2,        GRUB_KEYBOARD_KEY_NUM5,
     /* 0x74 */ GRUB_KEYBOARD_KEY_NUM6,        GRUB_KEYBOARD_KEY_NUM8,
     /* 0x76 */ GRUB_KEYBOARD_KEY_ESCAPE,      GRUB_KEYBOARD_KEY_NUM_LOCK,

grub-core/term/gfxterm.c

@@ -668,7 +668,6 @@ draw_cursor (int show)
   unsigned int y;
   unsigned int width;
   unsigned int height;
-  unsigned int ascent;
   grub_video_color_t color;
   
   write_char ();
@@ -680,18 +679,13 @@ draw_cursor (int show)
       >= virtual_screen.rows)
     return;
 
-  /* Ensure that cursor doesn't go outside of character box.  */
-  ascent = grub_font_get_ascent(virtual_screen.font);
-  if (ascent > virtual_screen.normal_char_height - 2)
-    ascent = virtual_screen.normal_char_height - 2;
-
   /* Determine cursor properties and position on text layer. */
   x = virtual_screen.cursor_x * virtual_screen.normal_char_width;
   width = virtual_screen.normal_char_width;
   color = virtual_screen.fg_color;
   y = ((virtual_screen.cursor_y + virtual_screen.total_scroll)
        * virtual_screen.normal_char_height
-       + ascent);
+       + grub_font_get_ascent (virtual_screen.font));
   height = 2;
   
   /* Render cursor to text layer.  */

grub-core/tests/checksums.h

@@ -1,101 +1,101 @@
-  { "cmdline_cat", 640, 480, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi16 */, (grub_uint32_t []) { 0x59c36f00, 0x8851b0ee, 0x8851b0ee, 0xafb59f0b, 0xafb59f0b, 0x8c9b72f1, 0x8c9b72f1, 0x6eec5116, 0x6eec5116, 0xad82053e, 0xad82053e, 0x2eeae2ae, 0x2eeae2ae, 0x58cf8def, 0x58cf8def, 0x926f4d2f, 0x926f4d2f, 0xbd1c3236, 0xbd1c3236, 0x56012a95, 0x56012a95, 0x6d7c40ae, 0x6d7c40ae, 0xef750bc8, 0xef750bc8, 0x1080dd4a, 0x1080dd4a, 0xd7f9e5af, 0xd7f9e5af, 0x80b1b4a9, 0x80b1b4a9, 0x2c99415e, 0x2c99415e, 0x8d5761ff, 0x8d5761ff, 0xb964b489, 0xb964b489, 0x88a51f74, 0x88a51f74, 0x1da6c458, 0x1da6c458, 0x85e94025, 0x206ea54f, 0x7ee6c8fd, 0x7ee6c8fd, }, 45 },
-  { "cmdline_cat", 800, 600, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi16 */, (grub_uint32_t []) { 0xaa4593fe, 0x834b70a0, 0x834b70a0, 0xe7cc129f, 0xe7cc129f, 0x5ee2edc, 0x5ee2edc, 0xa1135cd7, 0xa1135cd7, 0xf7ce1f26, 0xf7ce1f26, 0xe9f803e8, 0xe9f803e8, 0x4b8f9724, 0x4b8f9724, 0x3fe3771a, 0x3fe3771a, 0x5584ee63, 0x5584ee63, 0xac193250, 0xac193250, 0x801f25f4, 0x801f25f4, 0x8d33aece, 0x8d33aece, 0xc6d95edc, 0xc6d95edc, 0xf121dee2, 0xf121dee2, 0x6ab10812, 0x6ab10812, 0x41a5b112, 0x41a5b112, 0xac6f712b, 0xac6f712b, 0x8aee7a19, 0x8aee7a19, 0xfe37c0ad, 0xfe37c0ad, 0x99c6a336, 0x99c6a336, 0x53b844c6, 0x73015447, 0x7a1a2254, 0x7a1a2254, }, 45 },
-  { "cmdline_cat", 1024, 768, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi16 */, (grub_uint32_t []) { 0xc9cbf769, 0xb121c912, 0xb121c912, 0x635a8739, 0x635a8739, 0x8288cba6, 0x8288cba6, 0xf5589d0, 0xf5589d0, 0x471642b3, 0x471642b3, 0xfb4826cf, 0xfb4826cf, 0x8b1083cf, 0x8b1083cf, 0x738b0c94, 0x738b0c94, 0x859c41b0, 0x859c41b0, 0x7c8d1be9, 0x7c8d1be9, 0x5b685e40, 0x5b685e40, 0x9cf80d95, 0x9cf80d95, 0x3541f915, 0x3541f915, 0x582b8557, 0x582b8557, 0x24cf88f7, 0x24cf88f7, 0x9e0af23, 0x9e0af23, 0x1033164b, 0x1033164b, 0x70ba51e2, 0x70ba51e2, 0xb051585c, 0xb051585c, 0xe1389f04, 0xe1389f04, 0x308bbb74, 0xdc9e6805, 0x4ddcff9f, 0x4ddcff9f, }, 45 },
-  { "cmdline_cat", 640, 480, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 640x480xrgba8888 */, (grub_uint32_t []) { 0x9813a416, 0xac16e832, 0xac16e832, 0xbf6ab9c6, 0xbf6ab9c6, 0x1063e15a, 0x1063e15a, 0xf908e3ff, 0xf908e3ff, 0xcb37d841, 0xcb37d841, 0x9b8ffa7d, 0x9b8ffa7d, 0x38d2a26c, 0x38d2a26c, 0x6989f09b, 0x6989f09b, 0x481451e, 0x481451e, 0x17b3177, 0x17b3177, 0x3ea52aeb, 0x3ea52aeb, 0xc24de674, 0xc24de674, 0x4ab163cc, 0x4ab163cc, 0xc482b092, 0xc482b092, 0x55ffc7e2, 0x55ffc7e2, 0x3b4b34dd, 0x3b4b34dd, 0x9b1f047f, 0x9b1f047f, 0x3d42e414, 0x3d42e414, 0x35b2fb06, 0x35b2fb06, 0xb813b35f, 0xb813b35f, 0xc3ede6e0, 0xc35214c3, 0x340f0107, 0x340f0107, }, 45 },
-  { "cmdline_cat", 800, 600, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 800x600xrgba8888 */, (grub_uint32_t []) { 0x5fcf013d, 0x9c47caee, 0x9c47caee, 0x6c9c4f38, 0x6c9c4f38, 0x79c49615, 0x79c49615, 0x70fe9708, 0x70fe9708, 0x8e90c077, 0x8e90c077, 0xd8205b47, 0xd8205b47, 0xa34337e2, 0xa34337e2, 0xf4dffa53, 0xf4dffa53, 0x90a0779c, 0x90a0779c, 0x322820bb, 0x322820bb, 0x50e3383f, 0x50e3383f, 0x4a976e3e, 0x4a976e3e, 0x90b6f8d9, 0x90b6f8d9, 0x4058c301, 0x4058c301, 0x221a6810, 0x221a6810, 0x1f78a00e, 0x1f78a00e, 0x6a633d2c, 0x6a633d2c, 0xca177c65, 0xca177c65, 0xabb6c7f9, 0xabb6c7f9, 0x635a35e8, 0x635a35e8, 0x6da78f10, 0x53467ff8, 0xd037fdfa, 0xd037fdfa, }, 45 },
-  { "cmdline_cat", 1024, 768, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 1024x768xrgba8888 */, (grub_uint32_t []) { 0xdd28f52b, 0x2b6b8225, 0x2b6b8225, 0x83df9995, 0x83df9995, 0x5165ad0b, 0x5165ad0b, 0xe5a6f96d, 0xe5a6f96d, 0x798df957, 0x798df957, 0x8c0567e2, 0x8c0567e2, 0x5e5d7389, 0x5e5d7389, 0x47a39dd, 0x47a39dd, 0x894f44af, 0x894f44af, 0x1dff0a6, 0x1dff0a6, 0xf496e67b, 0xf496e67b, 0x29cb5702, 0x29cb5702, 0xeaf1387d, 0xeaf1387d, 0x4a9bf7, 0x4a9bf7, 0x11d20bee, 0x11d20bee, 0xa103dc2d, 0xa103dc2d, 0xd0265db9, 0xd0265db9, 0x42267334, 0x42267334, 0x96f85e8c, 0x96f85e8c, 0xa28eac49, 0xa28eac49, 0x4e660ae7, 0x70741b3, 0x183f2f2e, 0x183f2f2e, }, 45 },
-  { "cmdline_cat", 2560, 1440, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 2560x1440xrgba8888 */, (grub_uint32_t []) { 0x43d1f34, 0x77b51f44, 0x77b51f44, 0xc8097569, 0xc8097569, 0x769aee5f, 0x769aee5f, 0xa35e159, 0xa35e159, 0x87a6341f, 0x87a6341f, 0xb61d944b, 0xb61d944b, 0x8b109cb3, 0x8b109cb3, 0xed3fb3e, 0xed3fb3e, 0xd7cc6c3, 0xd7cc6c3, 0x52077f0d, 0x52077f0d, 0x9d86d17e, 0x9d86d17e, 0x5e487bb, 0x5e487bb, 0x3a00041b, 0x3a00041b, 0xcfdeaf9e, 0xcfdeaf9e, 0x3e40af89, 0x3e40af89, 0x5ec41ea9, 0x5ec41ea9, 0x6298e4e7, 0x6298e4e7, 0xfd67f90e, 0xfd67f90e, 0x5ab5dc32, 0x5ab5dc32, 0xdd3ad694, 0xdd3ad694, 0x391222b4, 0xd4a98b43, 0xeaa2f62, 0xeaa2f62, }, 45 },
-  { "gfxterm_menu", 640, 480, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi16 */, (grub_uint32_t []) { 0x59c36f00, 0x45b0713c, 0x237f9dbf, 0x45b0713c, 0x646bc7b, 0x59c36f00, 0x59c36f00, 0x7fd94135, 0x7fd94135, 0x7fd94135, 0x1592c53, 0x1592c53, 0x1592c53, 0x63af3981, 0x63af3981, 0x63af3981, 0x59c36f00, 0x646bc7b, 0x646bc7b, 0x59c36f00, }, 20 },
-  { "gfxterm_menu", 800, 600, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi16 */, (grub_uint32_t []) { 0xaa4593fe, 0x84abc7db, 0x20814063, 0x84abc7db, 0xaaae42a4, 0xaa4593fe, 0xaa4593fe, 0x2e88732f, 0x2e88732f, 0x2e88732f, 0x887d7e48, 0x887d7e48, 0x887d7e48, 0xa545d530, 0xa545d530, 0xa545d530, 0xaa4593fe, 0xaaae42a4, 0xaaae42a4, 0xaa4593fe, }, 20 },
-  { "gfxterm_menu", 1024, 768, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi16 */, (grub_uint32_t []) { 0xc9cbf769, 0x5b85371a, 0xe10968c2, 0x5b85371a, 0x6925a9e, 0xc9cbf769, 0xc9cbf769, 0xda1c9f17, 0xda1c9f17, 0xda1c9f17, 0x24c45edb, 0x24c45edb, 0x24c45edb, 0xcd8ee1d3, 0xcd8ee1d3, 0xcd8ee1d3, 0xc9cbf769, 0x6925a9e, 0x6925a9e, 0xc9cbf769, }, 20 },
-  { "gfxterm_menu", 640, 480, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 640x480xrgba8888 */, (grub_uint32_t []) { 0x9813a416, 0x9130464d, 0x22904f7a, 0x9130464d, 0x3f660f95, 0x9813a416, 0x9813a416, 0xfb08d7cf, 0xfb08d7cf, 0xfb08d7cf, 0x6ad351fc, 0x6ad351fc, 0x6ad351fc, 0x73696c2c, 0x73696c2c, 0x73696c2c, 0x9813a416, 0x3f660f95, 0x3f660f95, 0x9813a416, }, 20 },
-  { "gfxterm_menu", 800, 600, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 800x600xrgba8888 */, (grub_uint32_t []) { 0x5fcf013d, 0x5185b14e, 0x4173aa2f, 0x5185b14e, 0x272384fd, 0x5fcf013d, 0x5fcf013d, 0x9e56a9e0, 0x9e56a9e0, 0x9e56a9e0, 0x4c46b196, 0x4c46b196, 0x4c46b196, 0x5a358e09, 0x5a358e09, 0x5a358e09, 0x5fcf013d, 0x272384fd, 0x272384fd, 0x5fcf013d, }, 20 },
-  { "gfxterm_menu", 1024, 768, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 1024x768xrgba8888 */, (grub_uint32_t []) { 0xdd28f52b, 0x5cc0d3ef, 0x8b87731, 0x5cc0d3ef, 0x47c509e8, 0xdd28f52b, 0xdd28f52b, 0xe1579057, 0xe1579057, 0xe1579057, 0xc06b69b3, 0xc06b69b3, 0xc06b69b3, 0xbdd3a23f, 0xbdd3a23f, 0xbdd3a23f, 0xdd28f52b, 0x47c509e8, 0x47c509e8, 0xdd28f52b, }, 20 },
-  { "gfxterm_menu", 2560, 1440, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 2560x1440xrgba8888 */, (grub_uint32_t []) { 0x43d1f34, 0xd1338a02, 0x7aa25dbf, 0xd1338a02, 0x2e8c9182, 0x43d1f34, 0x43d1f34, 0x6486f7c4, 0x6486f7c4, 0x6486f7c4, 0x1b8c5e6c, 0x1b8c5e6c, 0x1b8c5e6c, 0x82dd5bea, 0x82dd5bea, 0x82dd5bea, 0x43d1f34, 0x2e8c9182, 0x2e8c9182, 0x43d1f34, }, 20 },
-  { "gfxmenu", 640, 480, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi16 */, (grub_uint32_t []) { 0x59c36f00, 0x1027210c, 0x64e51c81, 0x1027210c, 0x45ca4a8a, 0x9a2e0d26, 0x2b88b6ce, 0x2b88b6ce, 0x2b88b6ce, 0x7750400e, 0x7750400e, 0x7750400e, 0x5ec88e9c, 0x5ec88e9c, 0x5ec88e9c, 0x59c36f00, 0x45ca4a8a, 0x45ca4a8a, }, 18 },
-  { "gfxmenu", 800, 600, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi16 */, (grub_uint32_t []) { 0xaa4593fe, 0x8d12f697, 0xc5b32248, 0x8d12f697, 0x56720aa4, 0xa9d58ccd, 0xa1b1a1b5, 0xa1b1a1b5, 0xa1b1a1b5, 0xf4ee0bbf, 0xf4ee0bbf, 0xf4ee0bbf, 0x9dddc3f6, 0x9dddc3f6, 0x9dddc3f6, 0xaa4593fe, 0x56720aa4, 0x56720aa4, }, 18 },
-  { "gfxmenu", 1024, 768, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi16 */, (grub_uint32_t []) { 0xc9cbf769, 0xa5ec9f45, 0xdb7085d8, 0xa5ec9f45, 0x9caf1d3f, 0x5411be8b, 0xa07e74d3, 0xa07e74d3, 0xa07e74d3, 0xdfc0d247, 0xdfc0d247, 0xdfc0d247, 0x9db4b23f, 0x9db4b23f, 0x9db4b23f, 0xc9cbf769, 0x9caf1d3f, 0x9caf1d3f, }, 18 },
-  { "gfxmenu", 640, 480, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 640x480xrgba8888 */, (grub_uint32_t []) { 0x1c3742c9, 0xce8e83bf, 0xeb96c838, 0xce8e83bf, 0x73cb3bc1, 0x740d78cf, 0x84312594, 0x84312594, 0x84312594, 0x6f94cfe8, 0x6f94cfe8, 0x6f94cfe8, 0x69dfcf18, 0x69dfcf18, 0x69dfcf18, 0x1c3742c9, 0x73cb3bc1, 0x73cb3bc1, }, 18 },
-  { "gfxmenu", 800, 600, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 800x600xrgba8888 */, (grub_uint32_t []) { 0xcc5a7bed, 0x56a03e51, 0xee7d8d4b, 0x56a03e51, 0x5bdf9413, 0xbcda144c, 0x131c0760, 0x131c0760, 0x131c0760, 0x7c55db71, 0x7c55db71, 0x7c55db71, 0x71a34572, 0x71a34572, 0x71a34572, 0xcc5a7bed, 0x5bdf9413, 0x5bdf9413, }, 18 },
-  { "gfxmenu", 1024, 768, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 1024x768xrgba8888 */, (grub_uint32_t []) { 0xef4a3312, 0xea8a9cf0, 0x8929e522, 0xea8a9cf0, 0x78f3dfbc, 0x5d55a141, 0xb9092e0b, 0xb9092e0b, 0xb9092e0b, 0x7fbb6a15, 0x7fbb6a15, 0x7fbb6a15, 0x6bdebaaa, 0x6bdebaaa, 0x6bdebaaa, 0xef4a3312, 0x78f3dfbc, 0x78f3dfbc, }, 18 },
-  { "gfxmenu", 2560, 1440, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 2560x1440xrgba8888 */, (grub_uint32_t []) { 0x54e48d80, 0x6dcf1d57, 0x925a4c8f, 0x6dcf1d57, 0x69005b38, 0x6d6bb4bc, 0x14f7c6b1, 0x14f7c6b1, 0x14f7c6b1, 0x95043060, 0x95043060, 0x95043060, 0x3a0890f, 0x3a0890f, 0x3a0890f, 0x54e48d80, 0x69005b38, 0x69005b38, }, 18 },
-  { "gfxterm_ar", 640, 480, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi16 */, (grub_uint32_t []) { 0x59c36f00, 0x77ff5efc, 0x791fe364, 0x77ff5efc, 0x340993bb, 0x59c36f00, 0x59c36f00, 0x3908ca1e, 0x3908ca1e, 0x3908ca1e, 0x4788a778, 0x4788a778, 0x4788a778, 0x257eb2aa, 0x257eb2aa, 0x257eb2aa, 0x59c36f00, 0x340993bb, 0x340993bb, 0x59c36f00, }, 20 },
-  { "gfxterm_ar", 800, 600, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi16 */, (grub_uint32_t []) { 0xaa4593fe, 0xb2d04b0f, 0x46cdbc23, 0xb2d04b0f, 0x9cd5ce70, 0xaa4593fe, 0xaa4593fe, 0x44bf6b37, 0x44bf6b37, 0x44bf6b37, 0xe24a6650, 0xe24a6650, 0xe24a6650, 0xcf72cd28, 0xcf72cd28, 0xcf72cd28, 0xaa4593fe, 0x9cd5ce70, 0x9cd5ce70, 0xaa4593fe, }, 20 },
-  { "gfxterm_ar", 1024, 768, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi16 */, (grub_uint32_t []) { 0xc9cbf769, 0x4bb823b8, 0x59349835, 0x4bb823b8, 0x16af4e3c, 0xc9cbf769, 0xc9cbf769, 0x2784b68e, 0x2784b68e, 0x2784b68e, 0xd95c7742, 0xd95c7742, 0xd95c7742, 0x3016c84a, 0x3016c84a, 0x3016c84a, 0xc9cbf769, 0x16af4e3c, 0x16af4e3c, 0xc9cbf769, }, 20 },
-  { "gfxterm_ar", 640, 480, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 640x480xrgba8888 */, (grub_uint32_t []) { 0x9813a416, 0xb821e44, 0x16b3ac05, 0xb821e44, 0xa5d4579c, 0x9813a416, 0x9813a416, 0xca80d730, 0xca80d730, 0xca80d730, 0x5b5b5103, 0x5b5b5103, 0x5b5b5103, 0x42e16cd3, 0x42e16cd3, 0x42e16cd3, 0x9813a416, 0xa5d4579c, 0xa5d4579c, 0x9813a416, }, 20 },
-  { "gfxterm_ar", 800, 600, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 800x600xrgba8888 */, (grub_uint32_t []) { 0x5fcf013d, 0xbe0b9671, 0x7f6e98d0, 0xbe0b9671, 0xc8ada3c2, 0x5fcf013d, 0x5fcf013d, 0x57a0c67d, 0x57a0c67d, 0x57a0c67d, 0x85b0de0b, 0x85b0de0b, 0x85b0de0b, 0x93c3e194, 0x93c3e194, 0x93c3e194, 0x5fcf013d, 0xc8ada3c2, 0xc8ada3c2, 0x5fcf013d, }, 20 },
-  { "gfxterm_ar", 1024, 768, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 1024x768xrgba8888 */, (grub_uint32_t []) { 0xdd28f52b, 0x9f18b29e, 0x50e7d383, 0x9f18b29e, 0x841d6899, 0xdd28f52b, 0xdd28f52b, 0xd12092dc, 0xd12092dc, 0xd12092dc, 0xf01c6b38, 0xf01c6b38, 0xf01c6b38, 0x8da4a0b4, 0x8da4a0b4, 0x8da4a0b4, 0xdd28f52b, 0x841d6899, 0x841d6899, 0xdd28f52b, }, 20 },
-  { "gfxterm_ar", 2560, 1440, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 2560x1440xrgba8888 */, (grub_uint32_t []) { 0x43d1f34, 0x4e8d4d8c, 0x3f32cb90, 0x4e8d4d8c, 0xb132560c, 0x43d1f34, 0x43d1f34, 0x1e7f303c, 0x1e7f303c, 0x1e7f303c, 0x61759994, 0x61759994, 0x61759994, 0xf8249c12, 0xf8249c12, 0xf8249c12, 0x43d1f34, 0xb132560c, 0xb132560c, 0x43d1f34, }, 20 },
-  { "gfxterm_cyr", 640, 480, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi16 */, (grub_uint32_t []) { 0x59c36f00, 0x4f39b2c5, 0x37084023, 0x4f39b2c5, 0xccf7f82, 0x59c36f00, 0x59c36f00, 0xb5dad2e, 0xb5dad2e, 0xb5dad2e, 0x75ddc048, 0x75ddc048, 0x75ddc048, 0x172bd59a, 0x172bd59a, 0x172bd59a, 0x59c36f00, 0xccf7f82, 0xccf7f82, 0x59c36f00, }, 20 },
-  { "gfxterm_cyr", 800, 600, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi16 */, (grub_uint32_t []) { 0xaa4593fe, 0xd5f24f8e, 0x76463f82, 0xd5f24f8e, 0xfbf7caf1, 0xaa4593fe, 0xaa4593fe, 0xb897c475, 0xb897c475, 0xb897c475, 0x1e62c912, 0x1e62c912, 0x1e62c912, 0x335a626a, 0x335a626a, 0x335a626a, 0xaa4593fe, 0xfbf7caf1, 0xfbf7caf1, 0xaa4593fe, }, 20 },
-  { "gfxterm_cyr", 1024, 768, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi16 */, (grub_uint32_t []) { 0xc9cbf769, 0x8aa7c8c3, 0x28620e7e, 0x8aa7c8c3, 0xd7b0a547, 0xc9cbf769, 0xc9cbf769, 0x860f1899, 0x860f1899, 0x860f1899, 0x78d7d955, 0x78d7d955, 0x78d7d955, 0x919d665d, 0x919d665d, 0x919d665d, 0xc9cbf769, 0xd7b0a547, 0xd7b0a547, 0xc9cbf769, }, 20 },
-  { "gfxterm_cyr", 640, 480, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 640x480xrgba8888 */, (grub_uint32_t []) { 0x9813a416, 0x89654b6, 0x26bab4dd, 0x89654b6, 0xa6c01d6e, 0x9813a416, 0x9813a416, 0xc67652d9, 0xc67652d9, 0xc67652d9, 0x57add4ea, 0x57add4ea, 0x57add4ea, 0x4e17e93a, 0x4e17e93a, 0x4e17e93a, 0x9813a416, 0xa6c01d6e, 0xa6c01d6e, 0x9813a416, }, 20 },
-  { "gfxterm_cyr", 800, 600, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 800x600xrgba8888 */, (grub_uint32_t []) { 0x5fcf013d, 0x77945f28, 0xec3ce845, 0x77945f28, 0x1326a9b, 0x5fcf013d, 0x5fcf013d, 0xc8e6e12c, 0xc8e6e12c, 0xc8e6e12c, 0x1af6f95a, 0x1af6f95a, 0x1af6f95a, 0xc85c6c5, 0xc85c6c5, 0xc85c6c5, 0x5fcf013d, 0x1326a9b, 0x1326a9b, 0x5fcf013d, }, 20 },
-  { "gfxterm_cyr", 1024, 768, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 1024x768xrgba8888 */, (grub_uint32_t []) { 0xdd28f52b, 0x4450a5dc, 0xda479f49, 0x4450a5dc, 0x5f557fdb, 0xdd28f52b, 0xdd28f52b, 0xddfe9197, 0xddfe9197, 0xddfe9197, 0xfcc26873, 0xfcc26873, 0xfcc26873, 0x817aa3ff, 0x817aa3ff, 0x817aa3ff, 0xdd28f52b, 0x5f557fdb, 0x5f557fdb, 0xdd28f52b, }, 20 },
-  { "gfxterm_cyr", 2560, 1440, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 2560x1440xrgba8888 */, (grub_uint32_t []) { 0x43d1f34, 0x409098da, 0x2e0890e, 0x409098da, 0xbf2f835a, 0x43d1f34, 0x43d1f34, 0x253d050e, 0x253d050e, 0x253d050e, 0x5a37aca6, 0x5a37aca6, 0x5a37aca6, 0xc366a920, 0xc366a920, 0xc366a920, 0x43d1f34, 0xbf2f835a, 0xbf2f835a, 0x43d1f34, }, 20 },
-  { "gfxterm_heb", 640, 480, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi16 */, (grub_uint32_t []) { 0x59c36f00, 0x546aa9f1, 0x56bf26d0, 0x546aa9f1, 0x179c64b6, 0x59c36f00, 0x59c36f00, 0xa98ad4a1, 0xa98ad4a1, 0xa98ad4a1, 0xd70ab9c7, 0xd70ab9c7, 0xd70ab9c7, 0xb5fcac15, 0xb5fcac15, 0xb5fcac15, 0x59c36f00, 0x179c64b6, 0x179c64b6, 0x59c36f00, }, 20 },
-  { "gfxterm_heb", 800, 600, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi16 */, (grub_uint32_t []) { 0xaa4593fe, 0x12592c97, 0xa10f7034, 0x12592c97, 0x3c5ca9e8, 0xaa4593fe, 0xaa4593fe, 0x2c3e194, 0x2c3e194, 0x2c3e194, 0xa436ecf3, 0xa436ecf3, 0xa436ecf3, 0x890e478b, 0x890e478b, 0x890e478b, 0xaa4593fe, 0x3c5ca9e8, 0x3c5ca9e8, 0xaa4593fe, }, 20 },
-  { "gfxterm_heb", 1024, 768, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi16 */, (grub_uint32_t []) { 0xc9cbf769, 0xed5de42a, 0x5cf94e51, 0xed5de42a, 0xb04a89ae, 0xc9cbf769, 0xc9cbf769, 0xdd578210, 0xdd578210, 0xdd578210, 0x238f43dc, 0x238f43dc, 0x238f43dc, 0xcac5fcd4, 0xcac5fcd4, 0xcac5fcd4, 0xc9cbf769, 0xb04a89ae, 0xb04a89ae, 0xc9cbf769, }, 20 },
-  { "gfxterm_heb", 640, 480, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 640x480xrgba8888 */, (grub_uint32_t []) { 0x9813a416, 0xbbc56f90, 0x4f643bbb, 0xbbc56f90, 0x15932648, 0x9813a416, 0x9813a416, 0x28aba4d1, 0x28aba4d1, 0x28aba4d1, 0xb97022e2, 0xb97022e2, 0xb97022e2, 0xa0ca1f32, 0xa0ca1f32, 0xa0ca1f32, 0x9813a416, 0x15932648, 0x15932648, 0x9813a416, }, 20 },
-  { "gfxterm_heb", 800, 600, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 800x600xrgba8888 */, (grub_uint32_t []) { 0x5fcf013d, 0x43465d8c, 0x6399888a, 0x43465d8c, 0x35e0683f, 0x5fcf013d, 0x5fcf013d, 0x4895c207, 0x4895c207, 0x4895c207, 0x9a85da71, 0x9a85da71, 0x9a85da71, 0x8cf6e5ee, 0x8cf6e5ee, 0x8cf6e5ee, 0x5fcf013d, 0x35e0683f, 0x35e0683f, 0x5fcf013d, }, 20 },
-  { "gfxterm_heb", 1024, 768, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 1024x768xrgba8888 */, (grub_uint32_t []) { 0xdd28f52b, 0xd1e7f231, 0xe67e195e, 0xd1e7f231, 0xcae22836, 0xdd28f52b, 0xdd28f52b, 0xe7ae9f08, 0xe7ae9f08, 0xe7ae9f08, 0xc69266ec, 0xc69266ec, 0xc69266ec, 0xbb2aad60, 0xbb2aad60, 0xbb2aad60, 0xdd28f52b, 0xcae22836, 0xcae22836, 0xdd28f52b, }, 20 },
-  { "gfxterm_heb", 2560, 1440, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 2560x1440xrgba8888 */, (grub_uint32_t []) { 0x43d1f34, 0x793e58f4, 0x5f939386, 0x793e58f4, 0x86814374, 0x43d1f34, 0x43d1f34, 0x12b2b9c1, 0x12b2b9c1, 0x12b2b9c1, 0x6db81069, 0x6db81069, 0x6db81069, 0xf4e915ef, 0xf4e915ef, 0xf4e915ef, 0x43d1f34, 0x86814374, 0x86814374, 0x43d1f34, }, 20 },
-  { "gfxterm_gre", 640, 480, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi16 */, (grub_uint32_t []) { 0x59c36f00, 0x226c0d75, 0x9e291f4f, 0x226c0d75, 0x619ac032, 0x59c36f00, 0x59c36f00, 0x6fb6253, 0x6fb6253, 0x6fb6253, 0x787b0f35, 0x787b0f35, 0x787b0f35, 0x1a8d1ae7, 0x1a8d1ae7, 0x1a8d1ae7, 0x59c36f00, 0x619ac032, 0x619ac032, 0x59c36f00, }, 20 },
-  { "gfxterm_gre", 800, 600, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi16 */, (grub_uint32_t []) { 0xaa4593fe, 0x8355045, 0xfe058b68, 0x8355045, 0x2630d53a, 0xaa4593fe, 0xaa4593fe, 0x290a3822, 0x290a3822, 0x290a3822, 0x8fff3545, 0x8fff3545, 0x8fff3545, 0xa2c79e3d, 0xa2c79e3d, 0xa2c79e3d, 0xaa4593fe, 0x2630d53a, 0x2630d53a, 0xaa4593fe, }, 20 },
-  { "gfxterm_gre", 1024, 768, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi16 */, (grub_uint32_t []) { 0xc9cbf769, 0xc702fa59, 0x74086887, 0xc702fa59, 0x9a1597dd, 0xc9cbf769, 0xc9cbf769, 0x60295baa, 0x60295baa, 0x60295baa, 0x9ef19a66, 0x9ef19a66, 0x9ef19a66, 0x77bb256e, 0x77bb256e, 0x77bb256e, 0xc9cbf769, 0x9a1597dd, 0x9a1597dd, 0xc9cbf769, }, 20 },
-  { "gfxterm_gre", 640, 480, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 640x480xrgba8888 */, (grub_uint32_t []) { 0x9813a416, 0x82385331, 0xf77eda42, 0x82385331, 0x2c6e1ae9, 0x9813a416, 0x9813a416, 0x140c0d1f, 0x140c0d1f, 0x140c0d1f, 0x85d78b2c, 0x85d78b2c, 0x85d78b2c, 0x9c6db6fc, 0x9c6db6fc, 0x9c6db6fc, 0x9813a416, 0x2c6e1ae9, 0x2c6e1ae9, 0x9813a416, }, 20 },
-  { "gfxterm_gre", 800, 600, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 800x600xrgba8888 */, (grub_uint32_t []) { 0x5fcf013d, 0x565d2d38, 0x34f757ec, 0x565d2d38, 0x20fb188b, 0x5fcf013d, 0x5fcf013d, 0x230bf123, 0x230bf123, 0x230bf123, 0xf11be955, 0xf11be955, 0xf11be955, 0xe768d6ca, 0xe768d6ca, 0xe768d6ca, 0x5fcf013d, 0x20fb188b, 0x20fb188b, 0x5fcf013d, }, 20 },
-  { "gfxterm_gre", 1024, 768, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 1024x768xrgba8888 */, (grub_uint32_t []) { 0xdd28f52b, 0x632132a4, 0x4a8c90b2, 0x632132a4, 0x7824e8a3, 0xdd28f52b, 0xdd28f52b, 0xef2bffce, 0xef2bffce, 0xef2bffce, 0xce17062a, 0xce17062a, 0xce17062a, 0xb3afcda6, 0xb3afcda6, 0xb3afcda6, 0xdd28f52b, 0x7824e8a3, 0x7824e8a3, 0xdd28f52b, }, 20 },
-  { "gfxterm_gre", 2560, 1440, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 2560x1440xrgba8888 */, (grub_uint32_t []) { 0x43d1f34, 0x461d4cfa, 0xfd3492c2, 0x461d4cfa, 0xb9a2577a, 0x43d1f34, 0x43d1f34, 0xfb72301f, 0xfb72301f, 0xfb72301f, 0x847899b7, 0x847899b7, 0x847899b7, 0x1d299c31, 0x1d299c31, 0x1d299c31, 0x43d1f34, 0xb9a2577a, 0xb9a2577a, 0x43d1f34, }, 20 },
-  { "gfxterm_ru", 640, 480, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi16 */, (grub_uint32_t []) { 0x59c36f00, 0x82758f66, 0xbac387fd, 0x82758f66, 0xc1834221, 0x59c36f00, 0x59c36f00, 0x4877befe, 0x4877befe, 0x4877befe, 0x36f7d398, 0x36f7d398, 0x36f7d398, 0x5401c64a, 0x5401c64a, 0x5401c64a, 0x59c36f00, 0xc1834221, 0xc1834221, 0x59c36f00, }, 20 },
-  { "gfxterm_ru", 800, 600, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi16 */, (grub_uint32_t []) { 0xaa4593fe, 0x4500a591, 0x9a40cbd8, 0x4500a591, 0x6b0520ee, 0xaa4593fe, 0xaa4593fe, 0x16db2902, 0x16db2902, 0x16db2902, 0xb02e2465, 0xb02e2465, 0xb02e2465, 0x9d168f1d, 0x9d168f1d, 0x9d168f1d, 0xaa4593fe, 0x6b0520ee, 0x6b0520ee, 0xaa4593fe, }, 20 },
-  { "gfxterm_ru", 1024, 768, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi16 */, (grub_uint32_t []) { 0xc9cbf769, 0x3cd9ea11, 0x1244c852, 0x3cd9ea11, 0x61ce8795, 0xc9cbf769, 0xc9cbf769, 0x6b15d6f0, 0x6b15d6f0, 0x6b15d6f0, 0x95cd173c, 0x95cd173c, 0x95cd173c, 0x7c87a834, 0x7c87a834, 0x7c87a834, 0xc9cbf769, 0x61ce8795, 0x61ce8795, 0xc9cbf769, }, 20 },
-  { "gfxterm_ru", 640, 480, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 640x480xrgba8888 */, (grub_uint32_t []) { 0x9813a416, 0xc818f15f, 0xbaf13382, 0xc818f15f, 0x664eb887, 0x9813a416, 0x9813a416, 0x350fe990, 0x350fe990, 0x350fe990, 0xa4d46fa3, 0xa4d46fa3, 0xa4d46fa3, 0xbd6e5273, 0xbd6e5273, 0xbd6e5273, 0x9813a416, 0x664eb887, 0x664eb887, 0x9813a416, }, 20 },
-  { "gfxterm_ru", 800, 600, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 800x600xrgba8888 */, (grub_uint32_t []) { 0x5fcf013d, 0xaa1dc81, 0x234341dd, 0xaa1dc81, 0x7c07e932, 0x5fcf013d, 0x5fcf013d, 0x969354c5, 0x969354c5, 0x969354c5, 0x44834cb3, 0x44834cb3, 0x44834cb3, 0x52f0732c, 0x52f0732c, 0x52f0732c, 0x5fcf013d, 0x7c07e932, 0x7c07e932, 0x5fcf013d, }, 20 },
-  { "gfxterm_ru", 1024, 768, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 1024x768xrgba8888 */, (grub_uint32_t []) { 0xdd28f52b, 0xd9aa4b29, 0x555fdda0, 0xd9aa4b29, 0xc2af912e, 0xdd28f52b, 0xdd28f52b, 0xe82cbfd, 0xe82cbfd, 0xe82cbfd, 0x2fbe3219, 0x2fbe3219, 0x2fbe3219, 0x5206f995, 0x5206f995, 0x5206f995, 0xdd28f52b, 0xc2af912e, 0xc2af912e, 0xdd28f52b, }, 20 },
-  { "gfxterm_ru", 2560, 1440, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 2560x1440xrgba8888 */, (grub_uint32_t []) { 0x43d1f34, 0xfd4e19ff, 0x42807b86, 0xfd4e19ff, 0x2f1027f, 0x43d1f34, 0x43d1f34, 0x924dc5be, 0x924dc5be, 0x924dc5be, 0xed476c16, 0xed476c16, 0xed476c16, 0x74166990, 0x74166990, 0x74166990, 0x43d1f34, 0x2f1027f, 0x2f1027f, 0x43d1f34, }, 20 },
-  { "gfxterm_fr", 640, 480, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi16 */, (grub_uint32_t []) { 0x59c36f00, 0x3a63a2e6, 0x118487d4, 0x3a63a2e6, 0x79956fa1, 0x59c36f00, 0x59c36f00, 0x389f4d2d, 0x389f4d2d, 0x389f4d2d, 0x461f204b, 0x461f204b, 0x461f204b, 0x24e93599, 0x24e93599, 0x24e93599, 0x59c36f00, 0x79956fa1, 0x79956fa1, 0x59c36f00, }, 20 },
-  { "gfxterm_fr", 800, 600, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi16 */, (grub_uint32_t []) { 0xaa4593fe, 0x62d33f4d, 0x9544a8f4, 0x62d33f4d, 0x4cd6ba32, 0xaa4593fe, 0xaa4593fe, 0xfb86a3a4, 0xfb86a3a4, 0xfb86a3a4, 0x5d73aec3, 0x5d73aec3, 0x5d73aec3, 0x704b05bb, 0x704b05bb, 0x704b05bb, 0xaa4593fe, 0x4cd6ba32, 0x4cd6ba32, 0xaa4593fe, }, 20 },
-  { "gfxterm_fr", 1024, 768, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi16 */, (grub_uint32_t []) { 0xc9cbf769, 0x8cc4b6dc, 0x1042c383, 0x8cc4b6dc, 0xd1d3db58, 0xc9cbf769, 0xc9cbf769, 0xeba8a32b, 0xeba8a32b, 0xeba8a32b, 0x157062e7, 0x157062e7, 0x157062e7, 0xfc3addef, 0xfc3addef, 0xfc3addef, 0xc9cbf769, 0xd1d3db58, 0xd1d3db58, 0xc9cbf769, }, 20 },
-  { "gfxterm_fr", 640, 480, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 640x480xrgba8888 */, (grub_uint32_t []) { 0x9813a416, 0x23f9afd, 0x465f5ecc, 0x23f9afd, 0xac69d325, 0x9813a416, 0x9813a416, 0xccf7a1e3, 0xccf7a1e3, 0xccf7a1e3, 0x5d2c27d0, 0x5d2c27d0, 0x5d2c27d0, 0x44961a00, 0x44961a00, 0x44961a00, 0x9813a416, 0xac69d325, 0xac69d325, 0x9813a416, }, 20 },
-  { "gfxterm_fr", 800, 600, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 800x600xrgba8888 */, (grub_uint32_t []) { 0x5fcf013d, 0xed796a26, 0x3132d083, 0xed796a26, 0x9bdf5f95, 0x5fcf013d, 0x5fcf013d, 0x42f66a49, 0x42f66a49, 0x42f66a49, 0x90e6723f, 0x90e6723f, 0x90e6723f, 0x86954da0, 0x86954da0, 0x86954da0, 0x5fcf013d, 0x9bdf5f95, 0x9bdf5f95, 0x5fcf013d, }, 20 },
-  { "gfxterm_fr", 1024, 768, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 1024x768xrgba8888 */, (grub_uint32_t []) { 0xdd28f52b, 0x54b28785, 0x7fbbe762, 0x54b28785, 0x4fb75d82, 0xdd28f52b, 0xdd28f52b, 0x14b1cf29, 0x14b1cf29, 0x14b1cf29, 0x358d36cd, 0x358d36cd, 0x358d36cd, 0x4835fd41, 0x4835fd41, 0x4835fd41, 0xdd28f52b, 0x4fb75d82, 0x4fb75d82, 0xdd28f52b, }, 20 },
-  { "gfxterm_fr", 2560, 1440, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 2560x1440xrgba8888 */, (grub_uint32_t []) { 0x43d1f34, 0x7acc2669, 0xbf1a1d96, 0x7acc2669, 0x85733de9, 0x43d1f34, 0x43d1f34, 0x2cc1e8f4, 0x2cc1e8f4, 0x2cc1e8f4, 0x53cb415c, 0x53cb415c, 0x53cb415c, 0xca9a44da, 0xca9a44da, 0xca9a44da, 0x43d1f34, 0x85733de9, 0x85733de9, 0x43d1f34, }, 20 },
-  { "gfxterm_quot", 640, 480, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi16 */, (grub_uint32_t []) { 0x59c36f00, 0xf9511593, 0x9f9ef910, 0xf9511593, 0xbaa7d8d4, 0x59c36f00, 0x59c36f00, 0x7fd94135, 0x7fd94135, 0x7fd94135, 0x1592c53, 0x1592c53, 0x1592c53, 0x63af3981, 0x63af3981, 0x63af3981, 0x59c36f00, 0xbaa7d8d4, 0xbaa7d8d4, 0x59c36f00, }, 20 },
-  { "gfxterm_quot", 800, 600, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi16 */, (grub_uint32_t []) { 0xaa4593fe, 0x3dcbe25f, 0x99e165e7, 0x3dcbe25f, 0x13ce6720, 0xaa4593fe, 0xaa4593fe, 0x2e88732f, 0x2e88732f, 0x2e88732f, 0x887d7e48, 0x887d7e48, 0x887d7e48, 0xa545d530, 0xa545d530, 0xa545d530, 0xaa4593fe, 0x13ce6720, 0x13ce6720, 0xaa4593fe, }, 20 },
-  { "gfxterm_quot", 1024, 768, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi16 */, (grub_uint32_t []) { 0xc9cbf769, 0xdbedc74c, 0x61619894, 0xdbedc74c, 0x86faaac8, 0xc9cbf769, 0xc9cbf769, 0xda1c9f17, 0xda1c9f17, 0xda1c9f17, 0x24c45edb, 0x24c45edb, 0x24c45edb, 0xcd8ee1d3, 0xcd8ee1d3, 0xcd8ee1d3, 0xc9cbf769, 0x86faaac8, 0x86faaac8, 0xc9cbf769, }, 20 },
-  { "gfxterm_quot", 640, 480, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 640x480xrgba8888 */, (grub_uint32_t []) { 0x9813a416, 0x2411f56f, 0x97b1fc58, 0x2411f56f, 0x8a47bcb7, 0x9813a416, 0x9813a416, 0xfb08d7cf, 0xfb08d7cf, 0xfb08d7cf, 0x6ad351fc, 0x6ad351fc, 0x6ad351fc, 0x73696c2c, 0x73696c2c, 0x73696c2c, 0x9813a416, 0x8a47bcb7, 0x8a47bcb7, 0x9813a416, }, 20 },
-  { "gfxterm_quot", 800, 600, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 800x600xrgba8888 */, (grub_uint32_t []) { 0x5fcf013d, 0x13a65fb6, 0x35044d7, 0x13a65fb6, 0x65006a05, 0x5fcf013d, 0x5fcf013d, 0x9e56a9e0, 0x9e56a9e0, 0x9e56a9e0, 0x4c46b196, 0x4c46b196, 0x4c46b196, 0x5a358e09, 0x5a358e09, 0x5a358e09, 0x5fcf013d, 0x65006a05, 0x65006a05, 0x5fcf013d, }, 20 },
-  { "gfxterm_quot", 1024, 768, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 1024x768xrgba8888 */, (grub_uint32_t []) { 0xdd28f52b, 0xc8f05290, 0x9c88f64e, 0xc8f05290, 0xd3f58897, 0xdd28f52b, 0xdd28f52b, 0xe1579057, 0xe1579057, 0xe1579057, 0xc06b69b3, 0xc06b69b3, 0xc06b69b3, 0xbdd3a23f, 0xbdd3a23f, 0xbdd3a23f, 0xdd28f52b, 0xd3f58897, 0xd3f58897, 0xdd28f52b, }, 20 },
-  { "gfxterm_quot", 2560, 1440, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 2560x1440xrgba8888 */, (grub_uint32_t []) { 0x43d1f34, 0x9cfbc80f, 0x376a1fb2, 0x9cfbc80f, 0x6344d38f, 0x43d1f34, 0x43d1f34, 0x6486f7c4, 0x6486f7c4, 0x6486f7c4, 0x1b8c5e6c, 0x1b8c5e6c, 0x1b8c5e6c, 0x82dd5bea, 0x82dd5bea, 0x82dd5bea, 0x43d1f34, 0x6344d38f, 0x6344d38f, 0x43d1f34, }, 20 },
-  { "gfxterm_piglatin", 640, 480, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi16 */, (grub_uint32_t []) { 0x59c36f00, 0xd327ca68, 0x9c977e8c, 0xd327ca68, 0x90d1072f, 0x59c36f00, 0x59c36f00, 0x71c9d9, 0x71c9d9, 0x71c9d9, 0x7ef1a4bf, 0x7ef1a4bf, 0x7ef1a4bf, 0x1c07b16d, 0x1c07b16d, 0x1c07b16d, 0x59c36f00, 0x90d1072f, 0x90d1072f, 0x59c36f00, }, 20 },
-  { "gfxterm_piglatin", 800, 600, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi16 */, (grub_uint32_t []) { 0xaa4593fe, 0x2da3855b, 0x24c7b138, 0x2da3855b, 0x3a60024, 0xaa4593fe, 0xaa4593fe, 0x147ff249, 0x147ff249, 0x147ff249, 0xb28aff2e, 0xb28aff2e, 0xb28aff2e, 0x9fb25456, 0x9fb25456, 0x9fb25456, 0xaa4593fe, 0x3a60024, 0x3a60024, 0xaa4593fe, }, 20 },
-  { "gfxterm_piglatin", 1024, 768, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi16 */, (grub_uint32_t []) { 0xc9cbf769, 0x660ab3d9, 0xa75b45c4, 0x660ab3d9, 0x3b1dde5d, 0xc9cbf769, 0xc9cbf769, 0x5ff884f5, 0x5ff884f5, 0x5ff884f5, 0xa1204539, 0xa1204539, 0xa1204539, 0x486afa31, 0x486afa31, 0x486afa31, 0xc9cbf769, 0x3b1dde5d, 0x3b1dde5d, 0xc9cbf769, }, 20 },
-  { "gfxterm_piglatin", 640, 480, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 640x480xrgba8888 */, (grub_uint32_t []) { 0x9813a416, 0x920957ee, 0xceebfd42, 0x920957ee, 0x3c5f1e36, 0x9813a416, 0x9813a416, 0xa917dbef, 0xa917dbef, 0xa917dbef, 0x38cc5ddc, 0x38cc5ddc, 0x38cc5ddc, 0x2176600c, 0x2176600c, 0x2176600c, 0x9813a416, 0x3c5f1e36, 0x3c5f1e36, 0x9813a416, }, 20 },
-  { "gfxterm_piglatin", 800, 600, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 800x600xrgba8888 */, (grub_uint32_t []) { 0x5fcf013d, 0x8298cd03, 0xfb88293a, 0x8298cd03, 0xf43ef8b0, 0x5fcf013d, 0x5fcf013d, 0x8f57f36b, 0x8f57f36b, 0x8f57f36b, 0x5d47eb1d, 0x5d47eb1d, 0x5d47eb1d, 0x4b34d482, 0x4b34d482, 0x4b34d482, 0x5fcf013d, 0xf43ef8b0, 0xf43ef8b0, 0x5fcf013d, }, 20 },
-  { "gfxterm_piglatin", 1024, 768, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 1024x768xrgba8888 */, (grub_uint32_t []) { 0xdd28f52b, 0xd8bbc577, 0xb2c37549, 0xd8bbc577, 0xc3be1f70, 0xdd28f52b, 0xdd28f52b, 0xd8b598e, 0xd8b598e, 0xd8b598e, 0x2cb7a06a, 0x2cb7a06a, 0x2cb7a06a, 0x510f6be6, 0x510f6be6, 0x510f6be6, 0xdd28f52b, 0xc3be1f70, 0xc3be1f70, 0xdd28f52b, }, 20 },
-  { "gfxterm_piglatin", 2560, 1440, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 2560x1440xrgba8888 */, (grub_uint32_t []) { 0x43d1f34, 0x4d7993a1, 0xbeefcd88, 0x4d7993a1, 0xb2c68821, 0x43d1f34, 0x43d1f34, 0x1dbc7020, 0x1dbc7020, 0x1dbc7020, 0x62b6d988, 0x62b6d988, 0x62b6d988, 0xfbe7dc0e, 0xfbe7dc0e, 0xfbe7dc0e, 0x43d1f34, 0xb2c68821, 0xb2c68821, 0x43d1f34, }, 20 },
-  { "gfxterm_ch", 640, 480, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi16 */, (grub_uint32_t []) { 0x59c36f00, 0x628b6f61, 0x50f94215, 0x628b6f61, 0x217da226, 0x59c36f00, 0x59c36f00, 0x5755be7f, 0x5755be7f, 0x5755be7f, 0x29d5d319, 0x29d5d319, 0x29d5d319, 0x4b23c6cb, 0x4b23c6cb, 0x4b23c6cb, 0x59c36f00, 0x217da226, 0x217da226, 0x59c36f00, }, 20 },
-  { "gfxterm_ch", 800, 600, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi16 */, (grub_uint32_t []) { 0xaa4593fe, 0x9f82cd08, 0xbc67f78d, 0x9f82cd08, 0xb1874877, 0xaa4593fe, 0xaa4593fe, 0x4749512e, 0x4749512e, 0x4749512e, 0xe1bc5c49, 0xe1bc5c49, 0xe1bc5c49, 0xcc84f731, 0xcc84f731, 0xcc84f731, 0xaa4593fe, 0xb1874877, 0xb1874877, 0xaa4593fe, }, 20 },
-  { "gfxterm_ch", 1024, 768, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi16 */, (grub_uint32_t []) { 0xc9cbf769, 0xbee47cfb, 0x88e98534, 0xbee47cfb, 0xe3f3117f, 0xc9cbf769, 0xc9cbf769, 0xe2396b15, 0xe2396b15, 0xe2396b15, 0x1ce1aad9, 0x1ce1aad9, 0x1ce1aad9, 0xf5ab15d1, 0xf5ab15d1, 0xf5ab15d1, 0xc9cbf769, 0xe3f3117f, 0xe3f3117f, 0xc9cbf769, }, 20 },
-  { "gfxterm_ch", 640, 480, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 640x480xrgba8888 */, (grub_uint32_t []) { 0x9813a416, 0x2bfd5a83, 0xbe3c6f2f, 0x2bfd5a83, 0x85ab135b, 0x9813a416, 0x9813a416, 0xce30693b, 0xce30693b, 0xce30693b, 0x5febef08, 0x5febef08, 0x5febef08, 0x4651d2d8, 0x4651d2d8, 0x4651d2d8, 0x9813a416, 0x85ab135b, 0x85ab135b, 0x9813a416, }, 20 },
-  { "gfxterm_ch", 800, 600, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 800x600xrgba8888 */, (grub_uint32_t []) { 0x5fcf013d, 0x1456f321, 0xc3a55992, 0x1456f321, 0x62f0c692, 0x5fcf013d, 0x5fcf013d, 0xbe3d534a, 0xbe3d534a, 0xbe3d534a, 0x6c2d4b3c, 0x6c2d4b3c, 0x6c2d4b3c, 0x7a5e74a3, 0x7a5e74a3, 0x7a5e74a3, 0x5fcf013d, 0x62f0c692, 0x62f0c692, 0x5fcf013d, }, 20 },
-  { "gfxterm_ch", 1024, 768, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 1024x768xrgba8888 */, (grub_uint32_t []) { 0xdd28f52b, 0xdcac6945, 0x43fbdf5a, 0xdcac6945, 0xc7a9b342, 0xdd28f52b, 0xdd28f52b, 0x274da20b, 0x274da20b, 0x274da20b, 0x6715bef, 0x6715bef, 0x6715bef, 0x7bc99063, 0x7bc99063, 0x7bc99063, 0xdd28f52b, 0xc7a9b342, 0xc7a9b342, 0xdd28f52b, }, 20 },
-  { "gfxterm_ch", 2560, 1440, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 2560x1440xrgba8888 */, (grub_uint32_t []) { 0x43d1f34, 0x571e16b1, 0xb9f25c2, 0x571e16b1, 0xa8a10d31, 0x43d1f34, 0x43d1f34, 0x25dfb69d, 0x25dfb69d, 0x25dfb69d, 0x5ad51f35, 0x5ad51f35, 0x5ad51f35, 0xc3841ab3, 0xc3841ab3, 0xc3841ab3, 0x43d1f34, 0xa8a10d31, 0xa8a10d31, 0x43d1f34, }, 20 },
-  { "gfxterm_red", 640, 480, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi16 */, (grub_uint32_t []) { 0x59c36f00, 0xec987771, 0x8a579bf2, 0xec987771, 0xbbb5c9af, 0x59c36f00, 0x59c36f00, 0x16780f43, 0x16780f43, 0x16780f43, 0x68f86225, 0x68f86225, 0x68f86225, 0xa0e77f7, 0xa0e77f7, 0xa0e77f7, 0x59c36f00, 0xbbb5c9af, 0xbbb5c9af, 0x59c36f00, }, 20 },
-  { "gfxterm_red", 800, 600, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi16 */, (grub_uint32_t []) { 0xaa4593fe, 0x97994d2c, 0x33b3ca94, 0x97994d2c, 0x273e977a, 0xaa4593fe, 0xaa4593fe, 0xa592c9d5, 0xa592c9d5, 0xa592c9d5, 0x367c4b2, 0x367c4b2, 0x367c4b2, 0x2e5f6fca, 0x2e5f6fca, 0x2e5f6fca, 0xaa4593fe, 0x273e977a, 0x273e977a, 0xaa4593fe, }, 20 },
-  { "gfxterm_red", 1024, 768, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi16 */, (grub_uint32_t []) { 0xc9cbf769, 0x5d2416aa, 0xe7a84972, 0x5d2416aa, 0x4d010804, 0xc9cbf769, 0xc9cbf769, 0x4e3a88a0, 0x4e3a88a0, 0x4e3a88a0, 0xb0e2496c, 0xb0e2496c, 0xb0e2496c, 0x59a8f664, 0x59a8f664, 0x59a8f664, 0xc9cbf769, 0x4d010804, 0x4d010804, 0xc9cbf769, }, 20 },
-  { "gfxterm_red", 640, 480, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 640x480xrgba8888 */, (grub_uint32_t []) { 0x9813a416, 0x1da65b43, 0xae065274, 0x1da65b43, 0x2dd7a76c, 0x9813a416, 0x9813a416, 0xf81d19f, 0xf81d19f, 0xf81d19f, 0x9e5a57ac, 0x9e5a57ac, 0x9e5a57ac, 0x87e06a7c, 0x87e06a7c, 0x87e06a7c, 0x9813a416, 0x2dd7a76c, 0x2dd7a76c, 0x9813a416, }, 20 },
-  { "gfxterm_red", 800, 600, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 800x600xrgba8888 */, (grub_uint32_t []) { 0x5fcf013d, 0xea8a940e, 0xfa7c8f6f, 0xea8a940e, 0x448d7bfb, 0x5fcf013d, 0x5fcf013d, 0x47c22fa0, 0x47c22fa0, 0x47c22fa0, 0x95d237d6, 0x95d237d6, 0x95d237d6, 0x83a10849, 0x83a10849, 0x83a10849, 0x5fcf013d, 0x448d7bfb, 0x448d7bfb, 0x5fcf013d, }, 20 },
-  { "gfxterm_red", 1024, 768, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 1024x768xrgba8888 */, (grub_uint32_t []) { 0xdd28f52b, 0xc0ac44fa, 0x94d4e024, 0xc0ac44fa, 0x4ec88f20, 0xdd28f52b, 0xdd28f52b, 0x2422f542, 0x2422f542, 0x2422f542, 0x51e0ca6, 0x51e0ca6, 0x51e0ca6, 0x78a6c72a, 0x78a6c72a, 0x78a6c72a, 0xdd28f52b, 0x4ec88f20, 0x4ec88f20, 0xdd28f52b, }, 20 },
-  { "gfxterm_red", 2560, 1440, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 2560x1440xrgba8888 */, (grub_uint32_t []) { 0x43d1f34, 0x248f7655, 0x8f1ea1e8, 0x248f7655, 0xb3d7f0f5, 0x43d1f34, 0x43d1f34, 0x8c408c04, 0x8c408c04, 0x8c408c04, 0xf34a25ac, 0xf34a25ac, 0xf34a25ac, 0x6a1b202a, 0x6a1b202a, 0x6a1b202a, 0x43d1f34, 0xb3d7f0f5, 0xb3d7f0f5, 0x43d1f34, }, 20 },
-  { "gfxterm_high", 640, 480, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi16 */, (grub_uint32_t []) { 0x59c36f00, 0xd6ba8f78, 0xb07563fb, 0xd6ba8f78, 0x6ef020b2, 0x59c36f00, 0x59c36f00, 0x7fd94135, 0x7fd94135, 0x7fd94135, 0x1592c53, 0x1592c53, 0x1592c53, 0x63af3981, 0x63af3981, 0x63af3981, 0x59c36f00, 0x6ef020b2, 0x6ef020b2, 0x59c36f00, }, 20 },
-  { "gfxterm_high", 800, 600, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi16 */, (grub_uint32_t []) { 0xaa4593fe, 0xf5257f70, 0x510ff8c8, 0xf5257f70, 0x36a3b7ff, 0xaa4593fe, 0xaa4593fe, 0x2e88732f, 0x2e88732f, 0x2e88732f, 0x887d7e48, 0x887d7e48, 0x887d7e48, 0xa545d530, 0xa545d530, 0xa545d530, 0xaa4593fe, 0x36a3b7ff, 0x36a3b7ff, 0xaa4593fe, }, 20 },
-  { "gfxterm_high", 1024, 768, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi16 */, (grub_uint32_t []) { 0xc9cbf769, 0x9f8effb3, 0x2502a06b, 0x9f8effb3, 0xddeb038e, 0xc9cbf769, 0xc9cbf769, 0xda1c9f17, 0xda1c9f17, 0xda1c9f17, 0x24c45edb, 0x24c45edb, 0x24c45edb, 0xcd8ee1d3, 0xcd8ee1d3, 0xcd8ee1d3, 0xc9cbf769, 0xddeb038e, 0xddeb038e, 0xc9cbf769, }, 20 },
-  { "gfxterm_high", 640, 480, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 640x480xrgba8888 */, (grub_uint32_t []) { 0x9813a416, 0x6aa72774, 0xd9072e43, 0x6aa72774, 0x24b4853d, 0x9813a416, 0x9813a416, 0xfb08d7cf, 0xfb08d7cf, 0xfb08d7cf, 0x6ad351fc, 0x6ad351fc, 0x6ad351fc, 0x73696c2c, 0x73696c2c, 0x73696c2c, 0x9813a416, 0x24b4853d, 0x24b4853d, 0x9813a416, }, 20 },
-  { "gfxterm_high", 800, 600, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 800x600xrgba8888 */, (grub_uint32_t []) { 0x5fcf013d, 0x936eb1d8, 0x8398aab9, 0x936eb1d8, 0x8beef, 0x5fcf013d, 0x5fcf013d, 0x9e56a9e0, 0x9e56a9e0, 0x9e56a9e0, 0x4c46b196, 0x4c46b196, 0x4c46b196, 0x5a358e09, 0x5a358e09, 0x5a358e09, 0x5fcf013d, 0x8beef, 0x8beef, 0x5fcf013d, }, 20 },
-  { "gfxterm_high", 1024, 768, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 1024x768xrgba8888 */, (grub_uint32_t []) { 0xdd28f52b, 0xdd4b9ec3, 0x89333a1d, 0xdd4b9ec3, 0x3acd5a9d, 0xdd28f52b, 0xdd28f52b, 0xe1579057, 0xe1579057, 0xe1579057, 0xc06b69b3, 0xc06b69b3, 0xc06b69b3, 0xbdd3a23f, 0xbdd3a23f, 0xbdd3a23f, 0xdd28f52b, 0x3acd5a9d, 0x3acd5a9d, 0xdd28f52b, }, 20 },
-  { "gfxterm_high", 2560, 1440, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 2560x1440xrgba8888 */, (grub_uint32_t []) { 0x43d1f34, 0x89f37601, 0x2262a1bc, 0x89f37601, 0xf17b28ae, 0x43d1f34, 0x43d1f34, 0x6486f7c4, 0x6486f7c4, 0x6486f7c4, 0x1b8c5e6c, 0x1b8c5e6c, 0x1b8c5e6c, 0x82dd5bea, 0x82dd5bea, 0x82dd5bea, 0x43d1f34, 0xf17b28ae, 0xf17b28ae, 0x43d1f34, }, 20 },
+  { "cmdline_cat", 640, 480, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi16 */, (grub_uint32_t []) { 0x59c36f00, 0x24285504, 0x24285504, 0x3cc7ae1, 0x3cc7ae1, 0x20e2971b, 0x20e2971b, 0xc295b4fc, 0xc295b4fc, 0x1fbe0d4, 0x1fbe0d4, 0x82930744, 0x82930744, 0xf4b66805, 0xf4b66805, 0x3e16a8c5, 0x3e16a8c5, 0x1165d7dc, 0x1165d7dc, 0xfa78cf7f, 0xfa78cf7f, 0xc105a544, 0xc105a544, 0x430cee22, 0x430cee22, 0xbcf938a0, 0xbcf938a0, 0x7b800045, 0x7b800045, 0x2cc85143, 0x2cc85143, 0x80e0a4b4, 0x80e0a4b4, 0x212e8415, 0x212e8415, 0x151d5163, 0x151d5163, 0x24dcfa9e, 0x24dcfa9e, 0xb1df21b2, 0xb1df21b2, 0x2990a5cf, 0x8c1740a5, 0xd29f2d17, 0xd29f2d17, }, 45 },
+  { "cmdline_cat", 800, 600, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi16 */, (grub_uint32_t []) { 0xaa4593fe, 0x2b224886, 0x2b224886, 0x4fa52ab9, 0x4fa52ab9, 0xad8716fa, 0xad8716fa, 0x97a64f1, 0x97a64f1, 0x5fa72700, 0x5fa72700, 0x41913bce, 0x41913bce, 0xe3e6af02, 0xe3e6af02, 0x978a4f3c, 0x978a4f3c, 0xfdedd645, 0xfdedd645, 0x4700a76, 0x4700a76, 0x28761dd2, 0x28761dd2, 0x255a96e8, 0x255a96e8, 0x6eb066fa, 0x6eb066fa, 0x5948e6c4, 0x5948e6c4, 0xc2d83034, 0xc2d83034, 0xe9cc8934, 0xe9cc8934, 0x406490d, 0x406490d, 0x2287423f, 0x2287423f, 0x565ef88b, 0x565ef88b, 0x31af9b10, 0x31af9b10, 0xfbd17ce0, 0xdb686c61, 0xd2731a72, 0xd2731a72, }, 45 },
+  { "cmdline_cat", 1024, 768, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi16 */, (grub_uint32_t []) { 0xc9cbf769, 0x999febcd, 0x999febcd, 0x4be4a5e6, 0x4be4a5e6, 0xaa36e979, 0xaa36e979, 0x27ebab0f, 0x27ebab0f, 0x6fa8606c, 0x6fa8606c, 0xd3f60410, 0xd3f60410, 0xa3aea110, 0xa3aea110, 0x5b352e4b, 0x5b352e4b, 0xad22636f, 0xad22636f, 0x54333936, 0x54333936, 0x73d67c9f, 0x73d67c9f, 0xb4462f4a, 0xb4462f4a, 0x1dffdbca, 0x1dffdbca, 0x7095a788, 0x7095a788, 0xc71aa28, 0xc71aa28, 0x215e8dfc, 0x215e8dfc, 0x388d3494, 0x388d3494, 0x5804733d, 0x5804733d, 0x98ef7a83, 0x98ef7a83, 0xc986bddb, 0xc986bddb, 0x183599ab, 0xf4204ada, 0x6562dd40, 0x6562dd40, }, 45 },
+  { "cmdline_cat", 640, 480, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 640x480xrgba8888 */, (grub_uint32_t []) { 0x9813a416, 0xea25e7f1, 0xea25e7f1, 0xf959b605, 0xf959b605, 0x5650ee99, 0x5650ee99, 0xbf3bec3c, 0xbf3bec3c, 0x8d04d782, 0x8d04d782, 0xddbcf5be, 0xddbcf5be, 0x7ee1adaf, 0x7ee1adaf, 0x2fbaff58, 0x2fbaff58, 0x42b24add, 0x42b24add, 0x47483eb4, 0x47483eb4, 0x78962528, 0x78962528, 0x847ee9b7, 0x847ee9b7, 0xc826c0f, 0xc826c0f, 0x82b1bf51, 0x82b1bf51, 0x13ccc821, 0x13ccc821, 0x7d783b1e, 0x7d783b1e, 0xdd2c0bbc, 0xdd2c0bbc, 0x7b71ebd7, 0x7b71ebd7, 0x7381f4c5, 0x7381f4c5, 0xfe20bc9c, 0xfe20bc9c, 0x85dee923, 0x85611b00, 0x723c0ec4, 0x723c0ec4, }, 45 },
+  { "cmdline_cat", 800, 600, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 800x600xrgba8888 */, (grub_uint32_t []) { 0x5fcf013d, 0xbc52dc5f, 0xbc52dc5f, 0x4c895989, 0x4c895989, 0x59d180a4, 0x59d180a4, 0x50eb81b9, 0x50eb81b9, 0xae85d6c6, 0xae85d6c6, 0xf8354df6, 0xf8354df6, 0x83562153, 0x83562153, 0xd4caece2, 0xd4caece2, 0xb0b5612d, 0xb0b5612d, 0x123d360a, 0x123d360a, 0x70f62e8e, 0x70f62e8e, 0x6a82788f, 0x6a82788f, 0xb0a3ee68, 0xb0a3ee68, 0x604dd5b0, 0x604dd5b0, 0x20f7ea1, 0x20f7ea1, 0x3f6db6bf, 0x3f6db6bf, 0x4a762b9d, 0x4a762b9d, 0xea026ad4, 0xea026ad4, 0x8ba3d148, 0x8ba3d148, 0x434f2359, 0x434f2359, 0x4db299a1, 0x73536949, 0xf022eb4b, 0xf022eb4b, }, 45 },
+  { "cmdline_cat", 1024, 768, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 1024x768xrgba8888 */, (grub_uint32_t []) { 0xdd28f52b, 0x7cfd676, 0x7cfd676, 0xaf7bcdc6, 0xaf7bcdc6, 0x7dc1f958, 0x7dc1f958, 0xc902ad3e, 0xc902ad3e, 0x5529ad04, 0x5529ad04, 0xa0a133b1, 0xa0a133b1, 0x72f927da, 0x72f927da, 0x28de6d8e, 0x28de6d8e, 0xa5eb10fc, 0xa5eb10fc, 0x2d7ba4f5, 0x2d7ba4f5, 0xd832b228, 0xd832b228, 0x56f0351, 0x56f0351, 0xc6556c2e, 0xc6556c2e, 0x2ceecfa4, 0x2ceecfa4, 0x3d765fbd, 0x3d765fbd, 0x8da7887e, 0x8da7887e, 0xfc8209ea, 0xfc8209ea, 0x6e822767, 0x6e822767, 0xba5c0adf, 0xba5c0adf, 0x8e2af81a, 0x8e2af81a, 0x62c25eb4, 0x2ba315e0, 0x349b7b7d, 0x349b7b7d, }, 45 },
+  { "cmdline_cat", 2560, 1440, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 2560x1440xrgba8888 */, (grub_uint32_t []) { 0x43d1f34, 0x361fdea5, 0x361fdea5, 0x89a3b488, 0x89a3b488, 0x37302fbe, 0x37302fbe, 0x4b9f20b8, 0x4b9f20b8, 0xc60cf5fe, 0xc60cf5fe, 0xf7b755aa, 0xf7b755aa, 0xcaba5d52, 0xcaba5d52, 0x4f793adf, 0x4f793adf, 0x4cd60722, 0x4cd60722, 0x13adbeec, 0x13adbeec, 0xdc2c109f, 0xdc2c109f, 0x444e465a, 0x444e465a, 0x7baac5fa, 0x7baac5fa, 0x8e746e7f, 0x8e746e7f, 0x7fea6e68, 0x7fea6e68, 0x1f6edf48, 0x1f6edf48, 0x23322506, 0x23322506, 0xbccd38ef, 0xbccd38ef, 0x1b1f1dd3, 0x1b1f1dd3, 0x9c901775, 0x9c901775, 0x78b8e355, 0x95034aa2, 0x4f00ee83, 0x4f00ee83, }, 45 },
+  { "gfxterm_menu", 640, 480, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi16 */, (grub_uint32_t []) { 0x59c36f00, 0xdf032925, 0xb9ccc5a6, 0xdf032925, 0x9cf5e462, 0x59c36f00, 0x59c36f00, 0xd3a0a4df, 0xd3a0a4df, 0xd3a0a4df, 0xad20c9b9, 0xad20c9b9, 0xad20c9b9, 0xcfd6dc6b, 0xcfd6dc6b, 0xcfd6dc6b, 0x59c36f00, 0x9cf5e462, 0x9cf5e462, 0x59c36f00, }, 20 },
+  { "gfxterm_menu", 800, 600, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi16 */, (grub_uint32_t []) { 0xaa4593fe, 0xa24e444d, 0x664c3f5, 0xa24e444d, 0x8c4bc132, 0xaa4593fe, 0xaa4593fe, 0x86e14b09, 0x86e14b09, 0x86e14b09, 0x2014466e, 0x2014466e, 0x2014466e, 0xd2ced16, 0xd2ced16, 0xd2ced16, 0xaa4593fe, 0x8c4bc132, 0x8c4bc132, 0xaa4593fe, }, 20 },
+  { "gfxterm_menu", 1024, 768, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi16 */, (grub_uint32_t []) { 0xc9cbf769, 0x6fa41086, 0xd5284f5e, 0x6fa41086, 0x32b37d02, 0xc9cbf769, 0xc9cbf769, 0xf2a2bdc8, 0xf2a2bdc8, 0xf2a2bdc8, 0xc7a7c04, 0xc7a7c04, 0xc7a7c04, 0xe530c30c, 0xe530c30c, 0xe530c30c, 0xc9cbf769, 0x32b37d02, 0x32b37d02, 0xc9cbf769, }, 20 },
+  { "gfxterm_menu", 640, 480, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 640x480xrgba8888 */, (grub_uint32_t []) { 0x9813a416, 0xd084e37c, 0x6324ea4b, 0xd084e37c, 0x7ed2aaa4, 0x9813a416, 0x9813a416, 0xbd3bd80c, 0xbd3bd80c, 0xbd3bd80c, 0x2ce05e3f, 0x2ce05e3f, 0x2ce05e3f, 0x355a63ef, 0x355a63ef, 0x355a63ef, 0x9813a416, 0x7ed2aaa4, 0x7ed2aaa4, 0x9813a416, }, 20 },
+  { "gfxterm_menu", 800, 600, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 800x600xrgba8888 */, (grub_uint32_t []) { 0x5fcf013d, 0x451273fe, 0x55e4689f, 0x451273fe, 0x33b4464d, 0x5fcf013d, 0x5fcf013d, 0xbe43bf51, 0xbe43bf51, 0xbe43bf51, 0x6c53a727, 0x6c53a727, 0x6c53a727, 0x7a2098b8, 0x7a2098b8, 0x7a2098b8, 0x5fcf013d, 0x33b4464d, 0x33b4464d, 0x5fcf013d, }, 20 },
+  { "gfxterm_menu", 1024, 768, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 1024x768xrgba8888 */, (grub_uint32_t []) { 0xdd28f52b, 0x93132338, 0xc76b87e6, 0x93132338, 0x8816f93f, 0xdd28f52b, 0xdd28f52b, 0xcdf3c404, 0xcdf3c404, 0xcdf3c404, 0xeccf3de0, 0xeccf3de0, 0xeccf3de0, 0x9177f66c, 0x9177f66c, 0x9177f66c, 0xdd28f52b, 0x8816f93f, 0x8816f93f, 0xdd28f52b, }, 20 },
+  { "gfxterm_menu", 2560, 1440, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 2560x1440xrgba8888 */, (grub_uint32_t []) { 0x43d1f34, 0xae6a4ef5, 0x5fb9948, 0xae6a4ef5, 0x51d55575, 0x43d1f34, 0x43d1f34, 0x252c3625, 0x252c3625, 0x252c3625, 0x5a269f8d, 0x5a269f8d, 0x5a269f8d, 0xc3779a0b, 0xc3779a0b, 0xc3779a0b, 0x43d1f34, 0x51d55575, 0x51d55575, 0x43d1f34, }, 20 },
+  { "gfxmenu", 640, 480, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi16 */, (grub_uint32_t []) { 0x59c36f00, 0x60e56714, 0x14275a99, 0x60e56714, 0x35080c92, 0x9a2e0d26, 0xc53fe194, 0xc53fe194, 0xc53fe194, 0x99e71754, 0x99e71754, 0x99e71754, 0xb07fd9c6, 0xb07fd9c6, 0xb07fd9c6, 0x59c36f00, 0x35080c92, 0x35080c92, }, 18 },
+  { "gfxmenu", 800, 600, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi16 */, (grub_uint32_t []) { 0xaa4593fe, 0x33d94a8c, 0x7b789e53, 0x33d94a8c, 0xe8b9b6bf, 0xa9d58ccd, 0x8cf0d333, 0x8cf0d333, 0x8cf0d333, 0xd9af7939, 0xd9af7939, 0xd9af7939, 0xb09cb170, 0xb09cb170, 0xb09cb170, 0xaa4593fe, 0xe8b9b6bf, 0xe8b9b6bf, }, 18 },
+  { "gfxmenu", 1024, 768, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi16 */, (grub_uint32_t []) { 0xc9cbf769, 0xe4669404, 0x9afa8e99, 0xe4669404, 0xdd25167e, 0x5411be8b, 0x3589841c, 0x3589841c, 0x3589841c, 0x4a372288, 0x4a372288, 0x4a372288, 0x84342f0, 0x84342f0, 0x84342f0, 0xc9cbf769, 0xdd25167e, 0xdd25167e, }, 18 },
+  { "gfxmenu", 640, 480, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 640x480xrgba8888 */, (grub_uint32_t []) { 0x1c3742c9, 0x37ed1568, 0x12f55eef, 0x37ed1568, 0x8aa8ad16, 0x740d78cf, 0x1a9dc2bc, 0x1a9dc2bc, 0x1a9dc2bc, 0xf13828c0, 0xf13828c0, 0xf13828c0, 0xf7732830, 0xf7732830, 0xf7732830, 0x1c3742c9, 0x8aa8ad16, 0x8aa8ad16, }, 18 },
+  { "gfxmenu", 800, 600, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 800x600xrgba8888 */, (grub_uint32_t []) { 0xcc5a7bed, 0xc5315ac9, 0x7dece9d3, 0xc5315ac9, 0xc84ef08b, 0xbcda144c, 0x321e548b, 0x321e548b, 0x321e548b, 0x5d57889a, 0x5d57889a, 0x5d57889a, 0x50a11699, 0x50a11699, 0x50a11699, 0xcc5a7bed, 0xc84ef08b, 0xc84ef08b, }, 18 },
+  { "gfxmenu", 1024, 768, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 1024x768xrgba8888 */, (grub_uint32_t []) { 0xef4a3312, 0x40a72ecd, 0x2304571f, 0x40a72ecd, 0xd2de6d81, 0x5d55a141, 0x8ccafa03, 0x8ccafa03, 0x8ccafa03, 0x4a78be1d, 0x4a78be1d, 0x4a78be1d, 0x5e1d6ea2, 0x5e1d6ea2, 0x5e1d6ea2, 0xef4a3312, 0xd2de6d81, 0xd2de6d81, }, 18 },
+  { "gfxmenu", 2560, 1440, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 2560x1440xrgba8888 */, (grub_uint32_t []) { 0x54e48d80, 0xe6143ead, 0x19816f75, 0xe6143ead, 0xe2db78c2, 0xa992f629, 0x5fefa0d1, 0x5fefa0d1, 0x5fefa0d1, 0xde1c5600, 0xde1c5600, 0xde1c5600, 0x48b8ef6f, 0x48b8ef6f, 0x48b8ef6f, 0x54e48d80, 0xe2db78c2, 0xe2db78c2, }, 18 },
+  { "gfxterm_ar", 640, 480, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi16 */, (grub_uint32_t []) { 0x59c36f00, 0x25ba43d4, 0x43fe620d, 0x25ba43d4, 0x664c8e93, 0x59c36f00, 0x59c36f00, 0xb2921a37, 0xb2921a37, 0xb2921a37, 0xcc127751, 0xcc127751, 0xcc127751, 0xaee46283, 0xaee46283, 0xaee46283, 0x59c36f00, 0x664c8e93, 0x664c8e93, 0x59c36f00, }, 20 },
+  { "gfxterm_ar", 800, 600, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi16 */, (grub_uint32_t []) { 0xaa4593fe, 0x2aa2a72b, 0x6d6df6e1, 0x2aa2a72b, 0x4a72254, 0xaa4593fe, 0xaa4593fe, 0xa3be9127, 0xa3be9127, 0xa3be9127, 0x54b9c40, 0x54b9c40, 0x54b9c40, 0x28733738, 0x28733738, 0x28733738, 0xaa4593fe, 0x4a72254, 0x4a72254, 0xaa4593fe, }, 20 },
+  { "gfxterm_ar", 1024, 768, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi16 */, (grub_uint32_t []) { 0xc9cbf769, 0x9e799f98, 0xe21ad041, 0x9e799f98, 0xc36ef21c, 0xc9cbf769, 0xc9cbf769, 0x93d6c07d, 0x93d6c07d, 0x93d6c07d, 0x6d0e01b1, 0x6d0e01b1, 0x6d0e01b1, 0x8444beb9, 0x8444beb9, 0x8444beb9, 0xc9cbf769, 0xc36ef21c, 0xc36ef21c, 0xc9cbf769, }, 20 },
+  { "gfxterm_ar", 640, 480, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 640x480xrgba8888 */, (grub_uint32_t []) { 0x9813a416, 0x7ffc43fd, 0x64505961, 0x7ffc43fd, 0xd1aa0a25, 0x9813a416, 0x9813a416, 0x5b5f9bd5, 0x5b5f9bd5, 0x5b5f9bd5, 0xca841de6, 0xca841de6, 0xca841de6, 0xd33e2036, 0xd33e2036, 0xd33e2036, 0x9813a416, 0xd1aa0a25, 0xd1aa0a25, 0x9813a416, }, 20 },
+  { "gfxterm_ar", 800, 600, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 800x600xrgba8888 */, (grub_uint32_t []) { 0x5fcf013d, 0x570ca3fc, 0x4f1cee0f, 0x570ca3fc, 0x21aa964f, 0x5fcf013d, 0x5fcf013d, 0xf2bc017e, 0xf2bc017e, 0xf2bc017e, 0x20ac1908, 0x20ac1908, 0x20ac1908, 0x36df2697, 0x36df2697, 0x36df2697, 0x5fcf013d, 0x21aa964f, 0x21aa964f, 0x5fcf013d, }, 20 },
+  { "gfxterm_ar", 1024, 768, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 1024x768xrgba8888 */, (grub_uint32_t []) { 0xdd28f52b, 0xcf9798d3, 0x5d39a7fa, 0xcf9798d3, 0xd49242d4, 0xdd28f52b, 0xdd28f52b, 0xe15747f0, 0xe15747f0, 0xe15747f0, 0xc06bbe14, 0xc06bbe14, 0xc06bbe14, 0xbdd37598, 0xbdd37598, 0xbdd37598, 0xdd28f52b, 0xd49242d4, 0xd49242d4, 0xdd28f52b, }, 20 },
+  { "gfxterm_ar", 2560, 1440, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 2560x1440xrgba8888 */, (grub_uint32_t []) { 0x43d1f34, 0xae6154e8, 0x59e627f7, 0xae6154e8, 0x51de4f68, 0x43d1f34, 0x43d1f34, 0x59a8eb9f, 0x59a8eb9f, 0x59a8eb9f, 0x26a24237, 0x26a24237, 0x26a24237, 0xbff347b1, 0xbff347b1, 0xbff347b1, 0x43d1f34, 0x51de4f68, 0x51de4f68, 0x43d1f34, }, 20 },
+  { "gfxterm_cyr", 640, 480, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi16 */, (grub_uint32_t []) { 0x59c36f00, 0xb2b04aa3, 0xca81b845, 0xb2b04aa3, 0xf14687e4, 0x59c36f00, 0x59c36f00, 0xc01ee8bb, 0xc01ee8bb, 0xc01ee8bb, 0xbe9e85dd, 0xbe9e85dd, 0xbe9e85dd, 0xdc68900f, 0xdc68900f, 0xdc68900f, 0x59c36f00, 0xf14687e4, 0xf14687e4, 0x59c36f00, }, 20 },
+  { "gfxterm_cyr", 800, 600, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi16 */, (grub_uint32_t []) { 0xaa4593fe, 0x19a66482, 0xba12148e, 0x19a66482, 0x37a3e1fd, 0xaa4593fe, 0xaa4593fe, 0xfa4f54c9, 0xfa4f54c9, 0xfa4f54c9, 0x5cba59ae, 0x5cba59ae, 0x5cba59ae, 0x7182f2d6, 0x7182f2d6, 0x7182f2d6, 0xaa4593fe, 0x37a3e1fd, 0x37a3e1fd, 0xaa4593fe, }, 20 },
+  { "gfxterm_cyr", 1024, 768, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi16 */, (grub_uint32_t []) { 0xc9cbf769, 0x6a5ddfe7, 0xc898195a, 0x6a5ddfe7, 0x374ab263, 0xc9cbf769, 0xc9cbf769, 0x7a6a0afe, 0x7a6a0afe, 0x7a6a0afe, 0x84b2cb32, 0x84b2cb32, 0x84b2cb32, 0x6df8743a, 0x6df8743a, 0x6df8743a, 0xc9cbf769, 0x374ab263, 0x374ab263, 0xc9cbf769, }, 20 },
+  { "gfxterm_cyr", 640, 480, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 640x480xrgba8888 */, (grub_uint32_t []) { 0x9813a416, 0xb6ca222a, 0x98e6c241, 0xb6ca222a, 0x189c6bf2, 0x9813a416, 0x9813a416, 0x7fad8eb7, 0x7fad8eb7, 0x7fad8eb7, 0xee760884, 0xee760884, 0xee760884, 0xf7cc3554, 0xf7cc3554, 0xf7cc3554, 0x9813a416, 0x189c6bf2, 0x189c6bf2, 0x9813a416, }, 20 },
+  { "gfxterm_cyr", 800, 600, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 800x600xrgba8888 */, (grub_uint32_t []) { 0x5fcf013d, 0x726d82d0, 0xe9c535bd, 0x726d82d0, 0x4cbb763, 0x5fcf013d, 0x5fcf013d, 0xf99de8d5, 0xf99de8d5, 0xf99de8d5, 0x2b8df0a3, 0x2b8df0a3, 0x2b8df0a3, 0x3dfecf3c, 0x3dfecf3c, 0x3dfecf3c, 0x5fcf013d, 0x4cbb763, 0x4cbb763, 0x5fcf013d, }, 20 },
+  { "gfxterm_cyr", 1024, 768, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 1024x768xrgba8888 */, (grub_uint32_t []) { 0xdd28f52b, 0xfe26fef7, 0x6031c462, 0xfe26fef7, 0xe52324f0, 0xdd28f52b, 0xdd28f52b, 0x84ff6e38, 0x84ff6e38, 0x84ff6e38, 0xa5c397dc, 0xa5c397dc, 0xa5c397dc, 0xd87b5c50, 0xd87b5c50, 0xd87b5c50, 0xdd28f52b, 0xe52324f0, 0xe52324f0, 0xdd28f52b, }, 20 },
+  { "gfxterm_cyr", 2560, 1440, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 2560x1440xrgba8888 */, (grub_uint32_t []) { 0x43d1f34, 0x25e34f8a, 0x67935e5e, 0x25e34f8a, 0xda5c540a, 0x43d1f34, 0x43d1f34, 0x7ebdd748, 0x7ebdd748, 0x7ebdd748, 0x1b77ee0, 0x1b77ee0, 0x1b77ee0, 0x98e67b66, 0x98e67b66, 0x98e67b66, 0x43d1f34, 0xda5c540a, 0xda5c540a, 0x43d1f34, }, 20 },
+  { "gfxterm_heb", 640, 480, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi16 */, (grub_uint32_t []) { 0x59c36f00, 0x67038f5e, 0x65d6007f, 0x67038f5e, 0x24f54219, 0x59c36f00, 0x59c36f00, 0xac294ffd, 0xac294ffd, 0xac294ffd, 0xd2a9229b, 0xd2a9229b, 0xd2a9229b, 0xb05f3749, 0xb05f3749, 0xb05f3749, 0x59c36f00, 0x24f54219, 0x24f54219, 0x59c36f00, }, 20 },
+  { "gfxterm_heb", 800, 600, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi16 */, (grub_uint32_t []) { 0xaa4593fe, 0x944464c7, 0x27123864, 0x944464c7, 0xba41e1b8, 0xaa4593fe, 0xaa4593fe, 0xa521274, 0xa521274, 0xa521274, 0xaca71f13, 0xaca71f13, 0xaca71f13, 0x819fb46b, 0x819fb46b, 0x819fb46b, 0xaa4593fe, 0xba41e1b8, 0xba41e1b8, 0xaa4593fe, }, 20 },
+  { "gfxterm_heb", 1024, 768, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi16 */, (grub_uint32_t []) { 0xc9cbf769, 0xfe97adaf, 0x4f3307d4, 0xfe97adaf, 0xa380c02b, 0xc9cbf769, 0xc9cbf769, 0xd202ced6, 0xd202ced6, 0xd202ced6, 0x2cda0f1a, 0x2cda0f1a, 0x2cda0f1a, 0xc590b012, 0xc590b012, 0xc590b012, 0xc9cbf769, 0xa380c02b, 0xa380c02b, 0xc9cbf769, }, 20 },
+  { "gfxterm_heb", 640, 480, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 640x480xrgba8888 */, (grub_uint32_t []) { 0x9813a416, 0x5b32a9ba, 0xaf93fd91, 0x5b32a9ba, 0xf564e062, 0x9813a416, 0x9813a416, 0xcfdbc809, 0xcfdbc809, 0xcfdbc809, 0x5e004e3a, 0x5e004e3a, 0x5e004e3a, 0x47ba73ea, 0x47ba73ea, 0x47ba73ea, 0x9813a416, 0xf564e062, 0xf564e062, 0x9813a416, }, 20 },
+  { "gfxterm_heb", 800, 600, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 800x600xrgba8888 */, (grub_uint32_t []) { 0x5fcf013d, 0x5e0e1ce8, 0x7ed1c9ee, 0x5e0e1ce8, 0x28a8295b, 0x5fcf013d, 0x5fcf013d, 0x615f5762, 0x615f5762, 0x615f5762, 0xb34f4f14, 0xb34f4f14, 0xb34f4f14, 0xa53c708b, 0xa53c708b, 0xa53c708b, 0x5fcf013d, 0x28a8295b, 0x28a8295b, 0x5fcf013d, }, 20 },
+  { "gfxterm_heb", 1024, 768, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 1024x768xrgba8888 */, (grub_uint32_t []) { 0xdd28f52b, 0xa473184a, 0x93eaf325, 0xa473184a, 0xbf76c24d, 0xdd28f52b, 0xdd28f52b, 0x714dd1f7, 0x714dd1f7, 0x714dd1f7, 0x50712813, 0x50712813, 0x50712813, 0x2dc9e39f, 0x2dc9e39f, 0x2dc9e39f, 0xdd28f52b, 0xbf76c24d, 0xbf76c24d, 0xdd28f52b, }, 20 },
+  { "gfxterm_heb", 2560, 1440, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 2560x1440xrgba8888 */, (grub_uint32_t []) { 0x43d1f34, 0xa725578b, 0x81889cf9, 0xa725578b, 0x589a4c0b, 0x43d1f34, 0x43d1f34, 0xf25ab3a8, 0xf25ab3a8, 0xf25ab3a8, 0x8d501a00, 0x8d501a00, 0x8d501a00, 0x14011f86, 0x14011f86, 0x14011f86, 0x43d1f34, 0x589a4c0b, 0x589a4c0b, 0x43d1f34, }, 20 },
+  { "gfxterm_gre", 640, 480, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi16 */, (grub_uint32_t []) { 0x59c36f00, 0xd69cdcbf, 0x6ad9ce85, 0xd69cdcbf, 0x956a11f8, 0x59c36f00, 0x59c36f00, 0xc4c10e6a, 0xc4c10e6a, 0xc4c10e6a, 0xba41630c, 0xba41630c, 0xba41630c, 0xd8b776de, 0xd8b776de, 0xd8b776de, 0x59c36f00, 0x956a11f8, 0x956a11f8, 0x59c36f00, }, 20 },
+  { "gfxterm_gre", 800, 600, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi16 */, (grub_uint32_t []) { 0xaa4593fe, 0x1acffa1b, 0xecff2136, 0x1acffa1b, 0x34ca7f64, 0xaa4593fe, 0xaa4593fe, 0xb57c29cc, 0xb57c29cc, 0xb57c29cc, 0x138924ab, 0x138924ab, 0x138924ab, 0x3eb18fd3, 0x3eb18fd3, 0x3eb18fd3, 0xaa4593fe, 0x34ca7f64, 0x34ca7f64, 0xaa4593fe, }, 20 },
+  { "gfxterm_gre", 1024, 768, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi16 */, (grub_uint32_t []) { 0xc9cbf769, 0x1cf8992, 0xb2c51b4c, 0x1cf8992, 0x5cd8e416, 0xc9cbf769, 0xc9cbf769, 0xba7b2d22, 0xba7b2d22, 0xba7b2d22, 0x44a3ecee, 0x44a3ecee, 0x44a3ecee, 0xade953e6, 0xade953e6, 0xade953e6, 0xc9cbf769, 0x5cd8e416, 0x5cd8e416, 0xc9cbf769, }, 20 },
+  { "gfxterm_gre", 640, 480, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 640x480xrgba8888 */, (grub_uint32_t []) { 0x9813a416, 0x1f39da0b, 0x6a7f5378, 0x1f39da0b, 0xb16f93d3, 0x9813a416, 0x9813a416, 0x8e8a2ed7, 0x8e8a2ed7, 0x8e8a2ed7, 0x1f51a8e4, 0x1f51a8e4, 0x1f51a8e4, 0x6eb9534, 0x6eb9534, 0x6eb9534, 0x9813a416, 0xb16f93d3, 0xb16f93d3, 0x9813a416, }, 20 },
+  { "gfxterm_gre", 800, 600, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 800x600xrgba8888 */, (grub_uint32_t []) { 0x5fcf013d, 0x27394d6b, 0x459337bf, 0x27394d6b, 0x519f78d8, 0x5fcf013d, 0x5fcf013d, 0x66ed4571, 0x66ed4571, 0x66ed4571, 0xb4fd5d07, 0xb4fd5d07, 0xb4fd5d07, 0xa28e6298, 0xa28e6298, 0xa28e6298, 0x5fcf013d, 0x519f78d8, 0x519f78d8, 0x5fcf013d, }, 20 },
+  { "gfxterm_gre", 1024, 768, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 1024x768xrgba8888 */, (grub_uint32_t []) { 0xdd28f52b, 0x624e1f92, 0x4be3bd84, 0x624e1f92, 0x794bc595, 0xdd28f52b, 0xdd28f52b, 0xd33767c, 0xd33767c, 0xd33767c, 0x2c0f8f98, 0x2c0f8f98, 0x2c0f8f98, 0x51b74414, 0x51b74414, 0x51b74414, 0xdd28f52b, 0x794bc595, 0x794bc595, 0xdd28f52b, }, 20 },
+  { "gfxterm_gre", 2560, 1440, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 2560x1440xrgba8888 */, (grub_uint32_t []) { 0x43d1f34, 0xbf5dab2e, 0x4747516, 0xbf5dab2e, 0x40e2b0ae, 0x43d1f34, 0x43d1f34, 0x3cc1d2dd, 0x3cc1d2dd, 0x3cc1d2dd, 0x43cb7b75, 0x43cb7b75, 0x43cb7b75, 0xda9a7ef3, 0xda9a7ef3, 0xda9a7ef3, 0x43d1f34, 0x40e2b0ae, 0x40e2b0ae, 0x43d1f34, }, 20 },
+  { "gfxterm_ru", 640, 480, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi16 */, (grub_uint32_t []) { 0x59c36f00, 0x2e284303, 0x169e4b98, 0x2e284303, 0x6dde8e44, 0x59c36f00, 0x59c36f00, 0xd2e0cf68, 0xd2e0cf68, 0xd2e0cf68, 0xac60a20e, 0xac60a20e, 0xac60a20e, 0xce96b7dc, 0xce96b7dc, 0xce96b7dc, 0x59c36f00, 0x6dde8e44, 0x6dde8e44, 0x59c36f00, }, 20 },
+  { "gfxterm_ru", 800, 600, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi16 */, (grub_uint32_t []) { 0xaa4593fe, 0x3a911f8f, 0xe5d171c6, 0x3a911f8f, 0x14949af0, 0xaa4593fe, 0xaa4593fe, 0xe7c628ac, 0xe7c628ac, 0xe7c628ac, 0x413325cb, 0x413325cb, 0x413325cb, 0x6c0b8eb3, 0x6c0b8eb3, 0x6c0b8eb3, 0xaa4593fe, 0x14949af0, 0x14949af0, 0xaa4593fe, }, 20 },
+  { "gfxterm_ru", 1024, 768, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi16 */, (grub_uint32_t []) { 0xc9cbf769, 0xa4645fb3, 0x8af97df0, 0xa4645fb3, 0xf9733237, 0xc9cbf769, 0xc9cbf769, 0xef376611, 0xef376611, 0xef376611, 0x11efa7dd, 0x11efa7dd, 0x11efa7dd, 0xf8a518d5, 0xf8a518d5, 0xf8a518d5, 0xc9cbf769, 0xf9733237, 0xf9733237, 0xc9cbf769, }, 20 },
+  { "gfxterm_ru", 640, 480, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 640x480xrgba8888 */, (grub_uint32_t []) { 0x9813a416, 0x7c3a337b, 0xed3f1a6, 0x7c3a337b, 0xd26c7aa3, 0x9813a416, 0x9813a416, 0x86aa8146, 0x86aa8146, 0x86aa8146, 0x17710775, 0x17710775, 0x17710775, 0xecb3aa5, 0xecb3aa5, 0xecb3aa5, 0x9813a416, 0xd26c7aa3, 0xd26c7aa3, 0x9813a416, }, 20 },
+  { "gfxterm_ru", 800, 600, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 800x600xrgba8888 */, (grub_uint32_t []) { 0x5fcf013d, 0x9f31781b, 0xb6d3e547, 0x9f31781b, 0xe9974da8, 0x5fcf013d, 0x5fcf013d, 0x3781245e, 0x3781245e, 0x3781245e, 0xe5913c28, 0xe5913c28, 0xe5913c28, 0xf3e203b7, 0xf3e203b7, 0xf3e203b7, 0x5fcf013d, 0xe9974da8, 0xe9974da8, 0x5fcf013d, }, 20 },
+  { "gfxterm_ru", 1024, 768, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 1024x768xrgba8888 */, (grub_uint32_t []) { 0xdd28f52b, 0xfc18d24f, 0x70ed44c6, 0xfc18d24f, 0xe71d0848, 0xdd28f52b, 0xdd28f52b, 0xc847f61f, 0xc847f61f, 0xc847f61f, 0xe97b0ffb, 0xe97b0ffb, 0xe97b0ffb, 0x94c3c477, 0x94c3c477, 0x94c3c477, 0xdd28f52b, 0xe71d0848, 0xe71d0848, 0xdd28f52b, }, 20 },
+  { "gfxterm_ru", 2560, 1440, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 2560x1440xrgba8888 */, (grub_uint32_t []) { 0x43d1f34, 0x7bb91866, 0xc4777a1f, 0x7bb91866, 0x840603e6, 0x43d1f34, 0x43d1f34, 0x2a49c131, 0x2a49c131, 0x2a49c131, 0x55436899, 0x55436899, 0x55436899, 0xcc126d1f, 0xcc126d1f, 0xcc126d1f, 0x43d1f34, 0x840603e6, 0x840603e6, 0x43d1f34, }, 20 },
+  { "gfxterm_fr", 640, 480, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi16 */, (grub_uint32_t []) { 0x59c36f00, 0xa0d0faff, 0x8b37dfcd, 0xa0d0faff, 0xe32637b8, 0x59c36f00, 0x59c36f00, 0x94e6a8c7, 0x94e6a8c7, 0x94e6a8c7, 0xea66c5a1, 0xea66c5a1, 0xea66c5a1, 0x8890d073, 0x8890d073, 0x8890d073, 0x59c36f00, 0xe32637b8, 0xe32637b8, 0x59c36f00, }, 20 },
+  { "gfxterm_fr", 800, 600, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi16 */, (grub_uint32_t []) { 0xaa4593fe, 0x4436bcdb, 0xb3a12b62, 0x4436bcdb, 0x6a3339a4, 0xaa4593fe, 0xaa4593fe, 0x53ef9b82, 0x53ef9b82, 0x53ef9b82, 0xf51a96e5, 0xf51a96e5, 0xf51a96e5, 0xd8223d9d, 0xd8223d9d, 0xd8223d9d, 0xaa4593fe, 0x6a3339a4, 0x6a3339a4, 0xaa4593fe, }, 20 },
+  { "gfxterm_fr", 1024, 768, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi16 */, (grub_uint32_t []) { 0xc9cbf769, 0xb8e59140, 0x2463e41f, 0xb8e59140, 0xe5f2fcc4, 0xc9cbf769, 0xc9cbf769, 0xc31681f4, 0xc31681f4, 0xc31681f4, 0x3dce4038, 0x3dce4038, 0x3dce4038, 0xd484ff30, 0xd484ff30, 0xd484ff30, 0xc9cbf769, 0xe5f2fcc4, 0xe5f2fcc4, 0xc9cbf769, }, 20 },
+  { "gfxterm_fr", 640, 480, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 640x480xrgba8888 */, (grub_uint32_t []) { 0x9813a416, 0x438b3fcc, 0x7ebfbfd, 0x438b3fcc, 0xeddd7614, 0x9813a416, 0x9813a416, 0x8ac4ae20, 0x8ac4ae20, 0x8ac4ae20, 0x1b1f2813, 0x1b1f2813, 0x1b1f2813, 0x2a515c3, 0x2a515c3, 0x2a515c3, 0x9813a416, 0xeddd7614, 0xeddd7614, 0x9813a416, }, 20 },
+  { "gfxterm_fr", 800, 600, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 800x600xrgba8888 */, (grub_uint32_t []) { 0x5fcf013d, 0xf9eea896, 0x25a51233, 0xf9eea896, 0x8f489d25, 0x5fcf013d, 0x5fcf013d, 0x62e37cf8, 0x62e37cf8, 0x62e37cf8, 0xb0f3648e, 0xb0f3648e, 0xb0f3648e, 0xa6805b11, 0xa6805b11, 0xa6805b11, 0x5fcf013d, 0x8f489d25, 0x8f489d25, 0x5fcf013d, }, 20 },
+  { "gfxterm_fr", 1024, 768, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 1024x768xrgba8888 */, (grub_uint32_t []) { 0xdd28f52b, 0x9b617752, 0xb06817b5, 0x9b617752, 0x8064ad55, 0xdd28f52b, 0xdd28f52b, 0x38159b7a, 0x38159b7a, 0x38159b7a, 0x1929629e, 0x1929629e, 0x1929629e, 0x6491a912, 0x6491a912, 0x6491a912, 0xdd28f52b, 0x8064ad55, 0x8064ad55, 0xdd28f52b, }, 20 },
+  { "gfxterm_fr", 2560, 1440, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 2560x1440xrgba8888 */, (grub_uint32_t []) { 0x43d1f34, 0x595e29e, 0xc043d961, 0x595e29e, 0xfa2af91e, 0x43d1f34, 0x43d1f34, 0x6d6b2915, 0x6d6b2915, 0x6d6b2915, 0x126180bd, 0x126180bd, 0x126180bd, 0x8b30853b, 0x8b30853b, 0x8b30853b, 0x43d1f34, 0xfa2af91e, 0xfa2af91e, 0x43d1f34, }, 20 },
+  { "gfxterm_quot", 640, 480, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi16 */, (grub_uint32_t []) { 0x59c36f00, 0x63e24d8a, 0x52da109, 0x63e24d8a, 0x201480cd, 0x59c36f00, 0x59c36f00, 0xd3a0a4df, 0xd3a0a4df, 0xd3a0a4df, 0xad20c9b9, 0xad20c9b9, 0xad20c9b9, 0xcfd6dc6b, 0xcfd6dc6b, 0xcfd6dc6b, 0x59c36f00, 0x201480cd, 0x201480cd, 0x59c36f00, }, 20 },
+  { "gfxterm_quot", 800, 600, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi16 */, (grub_uint32_t []) { 0xaa4593fe, 0x1b2e61c9, 0xbf04e671, 0x1b2e61c9, 0x352be4b6, 0xaa4593fe, 0xaa4593fe, 0x86e14b09, 0x86e14b09, 0x86e14b09, 0x2014466e, 0x2014466e, 0x2014466e, 0xd2ced16, 0xd2ced16, 0xd2ced16, 0xaa4593fe, 0x352be4b6, 0x352be4b6, 0xaa4593fe, }, 20 },
+  { "gfxterm_quot", 1024, 768, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi16 */, (grub_uint32_t []) { 0xc9cbf769, 0xefcce0d0, 0x5540bf08, 0xefcce0d0, 0xb2db8d54, 0xc9cbf769, 0xc9cbf769, 0xf2a2bdc8, 0xf2a2bdc8, 0xf2a2bdc8, 0xc7a7c04, 0xc7a7c04, 0xc7a7c04, 0xe530c30c, 0xe530c30c, 0xe530c30c, 0xc9cbf769, 0xb2db8d54, 0xb2db8d54, 0xc9cbf769, }, 20 },
+  { "gfxterm_quot", 640, 480, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 640x480xrgba8888 */, (grub_uint32_t []) { 0x9813a416, 0x65a5505e, 0xd6055969, 0x65a5505e, 0xcbf31986, 0x9813a416, 0x9813a416, 0xbd3bd80c, 0xbd3bd80c, 0xbd3bd80c, 0x2ce05e3f, 0x2ce05e3f, 0x2ce05e3f, 0x355a63ef, 0x355a63ef, 0x355a63ef, 0x9813a416, 0xcbf31986, 0xcbf31986, 0x9813a416, }, 20 },
+  { "gfxterm_quot", 800, 600, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 800x600xrgba8888 */, (grub_uint32_t []) { 0x5fcf013d, 0x7319d06, 0x17c78667, 0x7319d06, 0x7197a8b5, 0x5fcf013d, 0x5fcf013d, 0xbe43bf51, 0xbe43bf51, 0xbe43bf51, 0x6c53a727, 0x6c53a727, 0x6c53a727, 0x7a2098b8, 0x7a2098b8, 0x7a2098b8, 0x5fcf013d, 0x7197a8b5, 0x7197a8b5, 0x5fcf013d, }, 20 },
+  { "gfxterm_quot", 1024, 768, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 1024x768xrgba8888 */, (grub_uint32_t []) { 0xdd28f52b, 0x723a247, 0x535b0699, 0x723a247, 0x1c267840, 0xdd28f52b, 0xdd28f52b, 0xcdf3c404, 0xcdf3c404, 0xcdf3c404, 0xeccf3de0, 0xeccf3de0, 0xeccf3de0, 0x9177f66c, 0x9177f66c, 0x9177f66c, 0xdd28f52b, 0x1c267840, 0x1c267840, 0xdd28f52b, }, 20 },
+  { "gfxterm_quot", 2560, 1440, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 2560x1440xrgba8888 */, (grub_uint32_t []) { 0x43d1f34, 0xe3a20cf8, 0x4833db45, 0xe3a20cf8, 0x1c1d1778, 0x43d1f34, 0x43d1f34, 0x252c3625, 0x252c3625, 0x252c3625, 0x5a269f8d, 0x5a269f8d, 0x5a269f8d, 0xc3779a0b, 0xc3779a0b, 0xc3779a0b, 0x43d1f34, 0x1c1d1778, 0x1c1d1778, 0x43d1f34, }, 20 },
+  { "gfxterm_piglatin", 640, 480, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi16 */, (grub_uint32_t []) { 0x59c36f00, 0x24b38cd5, 0x6b033831, 0x24b38cd5, 0x67454192, 0x59c36f00, 0x59c36f00, 0xc12f3297, 0xc12f3297, 0xc12f3297, 0xbfaf5ff1, 0xbfaf5ff1, 0xbfaf5ff1, 0xdd594a23, 0xdd594a23, 0xdd594a23, 0x59c36f00, 0x67454192, 0x67454192, 0x59c36f00, }, 20 },
+  { "gfxterm_piglatin", 800, 600, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi16 */, (grub_uint32_t []) { 0xaa4593fe, 0x54f09885, 0x5d94ace6, 0x54f09885, 0x7af51dfa, 0xaa4593fe, 0xaa4593fe, 0xe3a05427, 0xe3a05427, 0xe3a05427, 0x45555940, 0x45555940, 0x45555940, 0x686df238, 0x686df238, 0x686df238, 0xaa4593fe, 0x7af51dfa, 0x7af51dfa, 0xaa4593fe, }, 20 },
+  { "gfxterm_piglatin", 1024, 768, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi16 */, (grub_uint32_t []) { 0xc9cbf769, 0x53c2ee74, 0x92931869, 0x53c2ee74, 0xed583f0, 0xc9cbf769, 0xc9cbf769, 0x76afdc1b, 0x76afdc1b, 0x76afdc1b, 0x88771dd7, 0x88771dd7, 0x88771dd7, 0x613da2df, 0x613da2df, 0x613da2df, 0xc9cbf769, 0xed583f0, 0xed583f0, 0xc9cbf769, }, 20 },
+  { "gfxterm_piglatin", 640, 480, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 640x480xrgba8888 */, (grub_uint32_t []) { 0x9813a416, 0x4e5ded6f, 0x12bf47c3, 0x4e5ded6f, 0xe00ba4b7, 0x9813a416, 0x9813a416, 0x72c4cb9c, 0x72c4cb9c, 0x72c4cb9c, 0xe31f4daf, 0xe31f4daf, 0xe31f4daf, 0xfaa5707f, 0xfaa5707f, 0xfaa5707f, 0x9813a416, 0xe00ba4b7, 0xe00ba4b7, 0x9813a416, }, 20 },
+  { "gfxterm_piglatin", 800, 600, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 800x600xrgba8888 */, (grub_uint32_t []) { 0x5fcf013d, 0x3566adf6, 0x4c7649cf, 0x3566adf6, 0x43c09845, 0x5fcf013d, 0x5fcf013d, 0xc2b479f, 0xc2b479f, 0xc2b479f, 0xde3b5fe9, 0xde3b5fe9, 0xde3b5fe9, 0xc8486076, 0xc8486076, 0xc8486076, 0x5fcf013d, 0x43c09845, 0x43c09845, 0x5fcf013d, }, 20 },
+  { "gfxterm_piglatin", 1024, 768, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 1024x768xrgba8888 */, (grub_uint32_t []) { 0xdd28f52b, 0xec1bda0d, 0x86636a33, 0xec1bda0d, 0xf71e000a, 0xdd28f52b, 0xdd28f52b, 0xda5ce270, 0xda5ce270, 0xda5ce270, 0xfb601b94, 0xfb601b94, 0xfb601b94, 0x86d8d018, 0x86d8d018, 0x86d8d018, 0xdd28f52b, 0xf71e000a, 0xf71e000a, 0xdd28f52b, }, 20 },
+  { "gfxterm_piglatin", 2560, 1440, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 2560x1440xrgba8888 */, (grub_uint32_t []) { 0x43d1f34, 0x619415be, 0x92024b97, 0x619415be, 0x9e2b0e3e, 0x43d1f34, 0x43d1f34, 0xfa2f329, 0xfa2f329, 0xfa2f329, 0x70a85a81, 0x70a85a81, 0x70a85a81, 0xe9f95f07, 0xe9f95f07, 0xe9f95f07, 0x43d1f34, 0x9e2b0e3e, 0x9e2b0e3e, 0x43d1f34, }, 20 },
+  { "gfxterm_ch", 640, 480, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi16 */, (grub_uint32_t []) { 0x59c36f00, 0x200688e1, 0x1274a595, 0x200688e1, 0x63f045a6, 0x59c36f00, 0x59c36f00, 0x2312e40c, 0x2312e40c, 0x2312e40c, 0x5d92896a, 0x5d92896a, 0x5d92896a, 0x3f649cb8, 0x3f649cb8, 0x3f649cb8, 0x59c36f00, 0x63f045a6, 0x63f045a6, 0x59c36f00, }, 20 },
+  { "gfxterm_ch", 800, 600, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi16 */, (grub_uint32_t []) { 0xaa4593fe, 0xa943b821, 0x8aa682a4, 0xa943b821, 0x87463d5e, 0xaa4593fe, 0xaa4593fe, 0xff049fb7, 0xff049fb7, 0xff049fb7, 0x59f192d0, 0x59f192d0, 0x59f192d0, 0x74c939a8, 0x74c939a8, 0x74c939a8, 0xaa4593fe, 0x87463d5e, 0x87463d5e, 0xaa4593fe, }, 20 },
+  { "gfxterm_ch", 1024, 768, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi16 */, (grub_uint32_t []) { 0xc9cbf769, 0x11b6367b, 0x27bbcfb4, 0x11b6367b, 0x4ca15bff, 0xc9cbf769, 0xc9cbf769, 0x51f424d6, 0x51f424d6, 0x51f424d6, 0xaf2ce51a, 0xaf2ce51a, 0xaf2ce51a, 0x46665a12, 0x46665a12, 0x46665a12, 0xc9cbf769, 0x4ca15bff, 0x4ca15bff, 0xc9cbf769, }, 20 },
+  { "gfxterm_ch", 640, 480, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 640x480xrgba8888 */, (grub_uint32_t []) { 0x9813a416, 0x7c16ec93, 0xe9d7d93f, 0x7c16ec93, 0xd240a54b, 0x9813a416, 0x9813a416, 0x9e5c75d9, 0x9e5c75d9, 0x9e5c75d9, 0xf87f3ea, 0xf87f3ea, 0xf87f3ea, 0x163dce3a, 0x163dce3a, 0x163dce3a, 0x9813a416, 0xd240a54b, 0xd240a54b, 0x9813a416, }, 20 },
+  { "gfxterm_ch", 800, 600, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 800x600xrgba8888 */, (grub_uint32_t []) { 0x5fcf013d, 0xe28608ec, 0x3575a25f, 0xe28608ec, 0x94203d5f, 0x5fcf013d, 0x5fcf013d, 0x7c6f7c86, 0x7c6f7c86, 0x7c6f7c86, 0xae7f64f0, 0xae7f64f0, 0xae7f64f0, 0xb80c5b6f, 0xb80c5b6f, 0xb80c5b6f, 0x5fcf013d, 0x94203d5f, 0x94203d5f, 0x5fcf013d, }, 20 },
+  { "gfxterm_ch", 1024, 768, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 1024x768xrgba8888 */, (grub_uint32_t []) { 0xdd28f52b, 0xb510e48, 0x9406b857, 0xb510e48, 0x1054d44f, 0xdd28f52b, 0xdd28f52b, 0x13c76182, 0x13c76182, 0x13c76182, 0x32fb9866, 0x32fb9866, 0x32fb9866, 0x4f4353ea, 0x4f4353ea, 0x4f4353ea, 0xdd28f52b, 0x1054d44f, 0x1054d44f, 0xdd28f52b, }, 20 },
+  { "gfxterm_ch", 2560, 1440, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 2560x1440xrgba8888 */, (grub_uint32_t []) { 0x43d1f34, 0xf256eb36, 0xaed7d845, 0xf256eb36, 0xde9f0b6, 0x43d1f34, 0x43d1f34, 0xbe644e0c, 0xbe644e0c, 0xbe644e0c, 0xc16ee7a4, 0xc16ee7a4, 0xc16ee7a4, 0x583fe222, 0x583fe222, 0x583fe222, 0x43d1f34, 0xde9f0b6, 0xde9f0b6, 0x43d1f34, }, 20 },
+  { "gfxterm_red", 640, 480, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi16 */, (grub_uint32_t []) { 0x59c36f00, 0xe382dd9, 0x68f7c15a, 0xe382dd9, 0x59159307, 0x59c36f00, 0x59c36f00, 0xba01eaa9, 0xba01eaa9, 0xba01eaa9, 0xc48187cf, 0xc48187cf, 0xc48187cf, 0xa677921d, 0xa677921d, 0xa677921d, 0x59c36f00, 0x59159307, 0x59159307, 0x59c36f00, }, 20 },
+  { "gfxterm_red", 800, 600, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi16 */, (grub_uint32_t []) { 0xaa4593fe, 0x3c908c, 0xa4161734, 0x3c908c, 0xb09b4ada, 0xaa4593fe, 0xaa4593fe, 0xdfbf1f3, 0xdfbf1f3, 0xdfbf1f3, 0xab0efc94, 0xab0efc94, 0xab0efc94, 0x863657ec, 0x863657ec, 0x863657ec, 0xaa4593fe, 0xb09b4ada, 0xb09b4ada, 0xaa4593fe, }, 20 },
+  { "gfxterm_red", 1024, 768, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi16 */, (grub_uint32_t []) { 0xc9cbf769, 0xd2e9527, 0xb7a2caff, 0xd2e9527, 0x1d0b8b89, 0xc9cbf769, 0xc9cbf769, 0x6684aa7f, 0x6684aa7f, 0x6684aa7f, 0x985c6bb3, 0x985c6bb3, 0x985c6bb3, 0x7116d4bb, 0x7116d4bb, 0x7116d4bb, 0xc9cbf769, 0x1d0b8b89, 0x1d0b8b89, 0xc9cbf769, }, 20 },
+  { "gfxterm_red", 640, 480, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 640x480xrgba8888 */, (grub_uint32_t []) { 0x9813a416, 0x1639705d, 0xa599796a, 0x1639705d, 0x26488c72, 0x9813a416, 0x9813a416, 0x49b2de5c, 0x49b2de5c, 0x49b2de5c, 0xd869586f, 0xd869586f, 0xd869586f, 0xc1d365bf, 0xc1d365bf, 0xc1d365bf, 0x9813a416, 0x26488c72, 0x26488c72, 0x9813a416, }, 20 },
+  { "gfxterm_red", 800, 600, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 800x600xrgba8888 */, (grub_uint32_t []) { 0x5fcf013d, 0x10d0c422, 0x26df43, 0x10d0c422, 0xbed72bd7, 0x5fcf013d, 0x5fcf013d, 0x67d73911, 0x67d73911, 0x67d73911, 0xb5c72167, 0xb5c72167, 0xb5c72167, 0xa3b41ef8, 0xa3b41ef8, 0xa3b41ef8, 0x5fcf013d, 0xbed72bd7, 0xbed72bd7, 0x5fcf013d, }, 20 },
+  { "gfxterm_red", 1024, 768, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 1024x768xrgba8888 */, (grub_uint32_t []) { 0xdd28f52b, 0xdd34e67a, 0x894c42a4, 0xdd34e67a, 0x53502da0, 0xdd28f52b, 0xdd28f52b, 0x886a111, 0x886a111, 0x886a111, 0x29ba58f5, 0x29ba58f5, 0x29ba58f5, 0x54029379, 0x54029379, 0x54029379, 0xdd28f52b, 0x53502da0, 0x53502da0, 0xdd28f52b, }, 20 },
+  { "gfxterm_red", 2560, 1440, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 2560x1440xrgba8888 */, (grub_uint32_t []) { 0x43d1f34, 0x410b50fc, 0xea9a8741, 0x410b50fc, 0xd653d65c, 0x43d1f34, 0x43d1f34, 0xcdea4de5, 0xcdea4de5, 0xcdea4de5, 0xb2e0e44d, 0xb2e0e44d, 0xb2e0e44d, 0x2bb1e1cb, 0x2bb1e1cb, 0x2bb1e1cb, 0x43d1f34, 0xd653d65c, 0xd653d65c, 0x43d1f34, }, 20 },
+  { "gfxterm_high", 640, 480, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi16 */, (grub_uint32_t []) { 0x59c36f00, 0x4c09d761, 0x2ac63be2, 0x4c09d761, 0xf44378ab, 0x59c36f00, 0x59c36f00, 0xd3a0a4df, 0xd3a0a4df, 0xd3a0a4df, 0xad20c9b9, 0xad20c9b9, 0xad20c9b9, 0xcfd6dc6b, 0xcfd6dc6b, 0xcfd6dc6b, 0x59c36f00, 0xf44378ab, 0xf44378ab, 0x59c36f00, }, 20 },
+  { "gfxterm_high", 800, 600, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi16 */, (grub_uint32_t []) { 0xaa4593fe, 0xd3c0fce6, 0x77ea7b5e, 0xd3c0fce6, 0x10463469, 0xaa4593fe, 0xaa4593fe, 0x86e14b09, 0x86e14b09, 0x86e14b09, 0x2014466e, 0x2014466e, 0x2014466e, 0xd2ced16, 0xd2ced16, 0xd2ced16, 0xaa4593fe, 0x10463469, 0x10463469, 0xaa4593fe, }, 20 },
+  { "gfxterm_high", 1024, 768, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi16 */, (grub_uint32_t []) { 0xc9cbf769, 0xabafd82f, 0x112387f7, 0xabafd82f, 0xe9ca2412, 0xc9cbf769, 0xc9cbf769, 0xf2a2bdc8, 0xf2a2bdc8, 0xf2a2bdc8, 0xc7a7c04, 0xc7a7c04, 0xc7a7c04, 0xe530c30c, 0xe530c30c, 0xe530c30c, 0xc9cbf769, 0xe9ca2412, 0xe9ca2412, 0xc9cbf769, }, 20 },
+  { "gfxterm_high", 640, 480, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 640x480xrgba8888 */, (grub_uint32_t []) { 0x9813a416, 0x2b138245, 0x98b38b72, 0x2b138245, 0x6500200c, 0x9813a416, 0x9813a416, 0xbd3bd80c, 0xbd3bd80c, 0xbd3bd80c, 0x2ce05e3f, 0x2ce05e3f, 0x2ce05e3f, 0x355a63ef, 0x355a63ef, 0x355a63ef, 0x9813a416, 0x6500200c, 0x6500200c, 0x9813a416, }, 20 },
+  { "gfxterm_high", 800, 600, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 800x600xrgba8888 */, (grub_uint32_t []) { 0x5fcf013d, 0x87f97368, 0x970f6809, 0x87f97368, 0x149f7c5f, 0x5fcf013d, 0x5fcf013d, 0xbe43bf51, 0xbe43bf51, 0xbe43bf51, 0x6c53a727, 0x6c53a727, 0x6c53a727, 0x7a2098b8, 0x7a2098b8, 0x7a2098b8, 0x5fcf013d, 0x149f7c5f, 0x149f7c5f, 0x5fcf013d, }, 20 },
+  { "gfxterm_high", 1024, 768, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 1024x768xrgba8888 */, (grub_uint32_t []) { 0xdd28f52b, 0x12986e14, 0x46e0caca, 0x12986e14, 0xf51eaa4a, 0xdd28f52b, 0xdd28f52b, 0xcdf3c404, 0xcdf3c404, 0xcdf3c404, 0xeccf3de0, 0xeccf3de0, 0xeccf3de0, 0x9177f66c, 0x9177f66c, 0x9177f66c, 0xdd28f52b, 0xf51eaa4a, 0xf51eaa4a, 0xdd28f52b, }, 20 },
+  { "gfxterm_high", 2560, 1440, 0x1, 256, 32, 4, 16, 8, 8, 8, 0, 8, 24, 8 /* 2560x1440xrgba8888 */, (grub_uint32_t []) { 0x43d1f34, 0xf6aab2f6, 0x5d3b654b, 0xf6aab2f6, 0x8e22ec59, 0x43d1f34, 0x43d1f34, 0x252c3625, 0x252c3625, 0x252c3625, 0x5a269f8d, 0x5a269f8d, 0x5a269f8d, 0xc3779a0b, 0xc3779a0b, 0xc3779a0b, 0x43d1f34, 0x8e22ec59, 0x8e22ec59, 0x43d1f34, }, 20 },
   { "videotest", 640, 480, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 640x480xi16 */, (grub_uint32_t []) { 0x1368a483, 0x1368a483, 0x1368a483, 0x1368a483, 0x1368a483, }, 5 },
   { "videotest", 800, 600, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 800x600xi16 */, (grub_uint32_t []) { 0x7033079c, 0x7033079c, 0x7033079c, 0x7033079c, 0x7033079c, }, 5 },
   { "videotest", 1024, 768, 0x2, 16, 8, 1, 0, 0, 0, 0, 0, 0, 0, 0 /* 1024x768xi16 */, (grub_uint32_t []) { 0xff583fbf, 0xff583fbf, 0xff583fbf, 0xff583fbf, 0xff583fbf, }, 5 },

grub-core/tests/lib/functional_test.c

@@ -26,23 +26,14 @@ GRUB_MOD_LICENSE ("GPLv3+");
 
 static grub_err_t
 grub_functional_test (grub_extcmd_context_t ctxt __attribute__ ((unused)),
-		      int argc,
-		      char **args)
+		      int argc __attribute__ ((unused)),
+		      char **args __attribute__ ((unused)))
 {
   grub_test_t test;
   int ok = 1;
-  int i;
 
   FOR_LIST_ELEMENTS (test, grub_test_list)
     {
-      if (argc != 0)
-	{
-	  for (i = 0; i < argc; i++)
-	    if (grub_strcmp(args[i], test->name) == 0)
-	      break;
-	  if (i == argc)
-	    continue;
-	}
       grub_errno = 0;
       ok = ok && !grub_test_run (test);
       grub_errno = 0;

grub-core/tests/setjmp_test.c

@@ -25,10 +25,7 @@ GRUB_MOD_LICENSE ("GPLv3+");
 static grub_jmp_buf jmp_point;
 static int expected, ctr;
 
-/* This fixes GCC7 "unintentional fallthrough" warning */
-static void jmp0 (void) __attribute__ ((noreturn));
-static void jmp1 (void) __attribute__ ((noreturn));
-static void jmp2 (void) __attribute__ ((noreturn));
+#pragma GCC diagnostic ignored "-Wmissing-noreturn"
 
 static void
 jmp0 (void)

grub-core/tests/strtoull_test.c

@@ -1,63 +0,0 @@
-/*
- *  GRUB  --  GRand Unified Bootloader
- *  Copyright (C) 2016 Free Software Foundation, Inc.
- *
- *  GRUB 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 3 of the License, or
- *  (at your option) any later version.
- *
- *  GRUB 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 GRUB.  If not, see <http://www.gnu.org/licenses/>.
- */
-
-#include <grub/test.h>
-#include <grub/dl.h>
-
-GRUB_MOD_LICENSE ("GPLv3+");
-
-static void
-strtoull_testcase (const char *input, int base, unsigned long long expected,
-		   int num_digits, grub_err_t error)
-{
-  char *output;
-  unsigned long long value;
-  grub_errno = 0;
-  value = grub_strtoull(input, &output, base);
-  grub_test_assert (grub_errno == error,
-		    "unexpected error. Expected %d, got %d. Input \"%s\"",
-		    error, grub_errno, input);
-  if (grub_errno)
-    {
-      grub_errno = 0;
-      return;
-    }
-  grub_test_assert (input + num_digits == output,
-		    "unexpected number of digits. Expected %d, got %d, input \"%s\"",
-		    num_digits, (int) (output - input), input);
-  grub_test_assert (value == expected,
-		    "unexpected return value. Expected %llu, got %llu, input \"\%s\"",
-		    expected, value, input);
-}
-
-static void
-strtoull_test (void)
-{
-  strtoull_testcase ("9", 0, 9, 1, GRUB_ERR_NONE);
-  strtoull_testcase ("0xaa", 0, 0xaa, 4, GRUB_ERR_NONE);
-  strtoull_testcase ("0xff", 0, 0xff, 4, GRUB_ERR_NONE);
-  strtoull_testcase ("0", 10, 0, 1, GRUB_ERR_NONE);
-  strtoull_testcase ("8", 8, 0, 0, GRUB_ERR_BAD_NUMBER);
-  strtoull_testcase ("38", 8, 3, 1, GRUB_ERR_NONE);
-  strtoull_testcase ("7", 8, 7, 1, GRUB_ERR_NONE);
-  strtoull_testcase ("1]", 16, 1, 1, GRUB_ERR_NONE);
-  strtoull_testcase ("18446744073709551616", 10, 0, 0, GRUB_ERR_OUT_OF_RANGE);
-}
-
-
-GRUB_FUNCTIONAL_TEST (strtoull_test, strtoull_test);

grub-core/video/fb/video_fb.c

@@ -743,7 +743,7 @@ grub_video_fb_unmap_color_int (struct grub_video_fbblit_info * source,
   if ((mode_info->mode_type
        & GRUB_VIDEO_MODE_TYPE_INDEX_COLOR) != 0)
     {
-      if ((mode_info->mode_type
+      if ((framebuffer.render_target->mode_info.mode_type
 	   & GRUB_VIDEO_MODE_TYPE_ALPHA) != 0
 	  && color == 0xf0)
         {

grub-core/video/ieee1275.c

@@ -181,7 +181,6 @@ grub_video_ieee1275_fill_mode_info (grub_ieee1275_phandle_t dev,
     case 32:
       out->reserved_mask_size = 8;
       out->reserved_field_pos = 24;
-      /* FALLTHROUGH */
 
     case 24:
       out->red_mask_size = 8;

grub-core/video/readers/jpeg.c

@@ -736,7 +736,6 @@ grub_jpeg_decode_jpeg (struct grub_jpeg_data *data)
 	case JPEG_MARKER_SOS:	/* Start Of Scan.  */
 	  if (grub_jpeg_decode_sos (data))
 	    break;
-	  /* FALLTHROUGH */
 	case JPEG_MARKER_RST0:	/* Restart.  */
 	case JPEG_MARKER_RST1:
 	case JPEG_MARKER_RST2:

include/grub/arm/linux.h

@@ -40,7 +40,11 @@
 # define LINUX_PHYS_OFFSET        (0x00008000)
 # define LINUX_INITRD_PHYS_OFFSET (LINUX_PHYS_OFFSET + 0x02000000)
 # define LINUX_FDT_PHYS_OFFSET    (LINUX_INITRD_PHYS_OFFSET - 0x10000)
-# define grub_arm_firmware_get_boot_data (grub_addr_t)grub_efi_get_firmware_fdt
+static inline grub_addr_t
+grub_arm_firmware_get_boot_data (void)
+{
+  return 0;
+}
 static inline grub_uint32_t
 grub_arm_firmware_get_machine_type (void)
 {

include/grub/arm64/reloc.h

@@ -19,13 +19,6 @@
 #ifndef GRUB_ARM64_RELOC_H
 #define GRUB_ARM64_RELOC_H 1
 
-struct grub_arm64_trampoline
-{
-  grub_uint32_t ldr; /* ldr	x16, 8 */
-  grub_uint32_t br; /* br x16 */
-  grub_uint64_t addr;
-};
-
 int grub_arm_64_check_xxxx26_offset (grub_int64_t offset);
 void
 grub_arm64_set_xxxx26_offset (grub_uint32_t *place, grub_int64_t offset);

include/grub/dl.h

@@ -263,16 +263,11 @@ void grub_arch_dl_init_linker (void);
 grub_err_t
 grub_ia64_dl_get_tramp_got_size (const void *ehdr, grub_size_t *tramp,
 				 grub_size_t *got);
-grub_err_t
-grub_arm64_dl_get_tramp_got_size (const void *ehdr, grub_size_t *tramp,
-				  grub_size_t *got);
 
 #if defined (__ia64__)
 #define GRUB_ARCH_DL_TRAMP_ALIGN GRUB_IA64_DL_TRAMP_ALIGN
 #define GRUB_ARCH_DL_GOT_ALIGN GRUB_IA64_DL_GOT_ALIGN
 #define grub_arch_dl_get_tramp_got_size grub_ia64_dl_get_tramp_got_size
-#elif defined (__aarch64__)
-#define grub_arch_dl_get_tramp_got_size grub_arm64_dl_get_tramp_got_size
 #else
 grub_err_t
 grub_arch_dl_get_tramp_got_size (const void *ehdr, grub_size_t *tramp,

include/grub/efi/efi.h

@@ -81,10 +81,6 @@ extern void (*EXPORT_VAR(grub_efi_net_config)) (grub_efi_handle_t hnd,
 						char **device,
 						char **path);
 
-#if defined(__arm__) || defined(__aarch64__)
-void *EXPORT_FUNC(grub_efi_get_firmware_fdt)(void);
-#endif
-
 grub_addr_t grub_efi_modules_addr (void);
 
 void grub_efi_mm_init (void);

include/grub/elf.h

@@ -2068,14 +2068,11 @@ typedef Elf32_Addr Elf32_Conflict;
 #define R_AARCH64_NONE			0	/* No relocation.  */
 #define R_AARCH64_ABS64			257	/* Direct 64 bit. */
 #define R_AARCH64_ABS32			258	/* Direct 32 bit.  */
-#define R_AARCH64_PREL32		261
 #define R_AARCH64_ADR_PREL_PG_HI21	275
 #define R_AARCH64_ADD_ABS_LO12_NC	277
 #define R_AARCH64_LDST64_ABS_LO12_NC	286
 #define R_AARCH64_JUMP26		282	/* 26-bit relative. */
 #define R_AARCH64_CALL26		283	/* 26-bit relative. */
-#define R_AARCH64_ADR_GOT_PAGE		311
-#define R_AARCH64_LD64_GOT_LO12_NC	312
 #define R_AARCH64_COPY			1024	/* Copy symbol at runtime.  */
 #define R_AARCH64_GLOB_DAT		1025	/* Create GOT entry.  */
 #define R_AARCH64_JUMP_SLOT		1026	/* Create PLT entry.  */

include/grub/i386/memory.h

@@ -20,8 +20,6 @@
 #ifndef GRUB_MEMORY_CPU_HEADER
 #define GRUB_MEMORY_CPU_HEADER	1
 
-#define PAGE_SHIFT		12
-
 /* The flag for protected mode.  */
 #define GRUB_MEMORY_CPU_CR0_PE_ON		0x1
 #define GRUB_MEMORY_CPU_CR4_PAE_ON		0x00000020
@@ -33,11 +31,6 @@
 #define GRUB_MEMORY_MACHINE_UPPER_START			0x100000	/* 1 MiB */
 #define GRUB_MEMORY_MACHINE_LOWER_SIZE			GRUB_MEMORY_MACHINE_UPPER_START
 
-/* Some PTE definitions. */
-#define GRUB_PAGE_PRESENT			0x00000001
-#define GRUB_PAGE_RW				0x00000002
-#define GRUB_PAGE_USER				0x00000004
-
 #ifndef ASM_FILE
 
 #define GRUB_MMAP_MALLOC_LOW 1

include/grub/i386/multiboot.h

@@ -30,17 +30,6 @@
 #define MULTIBOOT_MBI_REGISTER ebx
 #define MULTIBOOT_ARCHITECTURE_CURRENT MULTIBOOT_ARCHITECTURE_I386
 
-#ifdef GRUB_MACHINE_EFI
-#ifdef __x86_64__
-#define MULTIBOOT_EFI_INITIAL_STATE  { .rax = MULTIBOOT_BOOTLOADER_MAGIC,	\
-    .rcx = 0,									\
-    .rdx = 0,									\
-      }
-#define MULTIBOOT_EFI_ENTRY_REGISTER rip
-#define MULTIBOOT_EFI_MBI_REGISTER rbx
-#endif
-#endif
-
 #define MULTIBOOT_ELF32_MACHINE EM_386
 #define MULTIBOOT_ELF64_MACHINE EM_X86_64
 

include/grub/i386/relocator.h

@@ -65,20 +65,6 @@ struct grub_relocator64_state
   grub_addr_t cr3;
 };
 
-#ifdef GRUB_MACHINE_EFI
-#ifdef __x86_64__
-struct grub_relocator64_efi_state
-{
-  grub_uint64_t rax;
-  grub_uint64_t rbx;
-  grub_uint64_t rcx;
-  grub_uint64_t rdx;
-  grub_uint64_t rip;
-  grub_uint64_t rsi;
-};
-#endif
-#endif
-
 grub_err_t grub_relocator16_boot (struct grub_relocator *rel,
 				  struct grub_relocator16_state state);
 
@@ -90,11 +76,4 @@ grub_err_t grub_relocator64_boot (struct grub_relocator *rel,
 				  struct grub_relocator64_state state,
 				  grub_addr_t min_addr, grub_addr_t max_addr);
 
-#ifdef GRUB_MACHINE_EFI
-#ifdef __x86_64__
-grub_err_t grub_relocator64_efi_boot (struct grub_relocator *rel,
-				      struct grub_relocator64_efi_state state);
-#endif
-#endif
-
 #endif /* ! GRUB_RELOCATOR_CPU_HEADER */

include/grub/ia64/reloc.h

@@ -26,8 +26,6 @@ grub_ia64_add_value_to_slot_20b (grub_addr_t addr, grub_uint32_t value);
 void
 grub_ia64_add_value_to_slot_21 (grub_addr_t addr, grub_uint32_t value);
 void
-grub_ia64_set_immu64 (grub_addr_t addr, grub_uint64_t value);
-void
 grub_ia64_make_trampoline (struct grub_ia64_trampoline *tr, grub_uint64_t addr);
 
 struct grub_ia64_trampoline

include/grub/module_verifier.h

@@ -16,5 +16,5 @@ struct grub_module_verifier_arch {
   const int *short_relocations;
 };
 
-void grub_module_verify64(void *module_img, size_t module_size, const struct grub_module_verifier_arch *arch, const char **whitelist_empty);
-void grub_module_verify32(void *module_img, size_t module_size, const struct grub_module_verifier_arch *arch, const char **whitelist_empty);
+void grub_module_verify64(void *module_img, size_t module_size, const struct grub_module_verifier_arch *arch);
+void grub_module_verify32(void *module_img, size_t module_size, const struct grub_module_verifier_arch *arch);

include/grub/multiboot.h

@@ -91,28 +91,10 @@ grub_multiboot_set_console (int console_type, int accepted_consoles,
 			    int console_required);
 grub_err_t
 grub_multiboot_load (grub_file_t file, const char *filename);
-
-struct mbi_load_data
-{
-  grub_file_t file;
-  const char *filename;
-  void *buffer;
-  unsigned int mbi_ver;
-  int relocatable;
-  grub_uint32_t min_addr;
-  grub_uint32_t max_addr;
-  grub_size_t align;
-  grub_uint32_t preference;
-  grub_uint32_t link_base_addr;
-  grub_uint32_t load_base_addr;
-  int avoid_efi_boot_services;
-};
-typedef struct mbi_load_data mbi_load_data_t;
-
 /* Load ELF32 or ELF64.  */
 grub_err_t
-grub_multiboot_load_elf (mbi_load_data_t *mld);
-
+grub_multiboot_load_elf (grub_file_t file, const char *filename,
+			 void *buffer);
 extern grub_size_t grub_multiboot_pure_size;
 extern grub_size_t grub_multiboot_alloc_mbi;
 extern grub_uint32_t grub_multiboot_payload_eip;

include/grub/net.h

@@ -291,7 +291,6 @@ struct grub_net_network_level_interface
   grub_net_interface_flags_t flags;
   struct grub_net_bootp_packet *dhcp_ack;
   grub_size_t dhcp_acklen;
-  grub_uint16_t vlantag;
   void *data;
 };
 
@@ -562,6 +561,4 @@ extern char *grub_net_default_server;
 #define GRUB_NET_INTERVAL 400
 #define GRUB_NET_INTERVAL_ADDITION 20
 
-#define VLANTAG_IDENTIFIER 0x8100
-
 #endif /* ! GRUB_NET_HEADER */

include/grub/net/arp.h

@@ -22,11 +22,10 @@
 #include <grub/net.h>
 
 extern grub_err_t grub_net_arp_receive (struct grub_net_buff *nb,
-                                        struct grub_net_card *card,
-                                        grub_uint16_t *vlantag);
+					struct grub_net_card *card);
 
 grub_err_t
 grub_net_arp_send_request (struct grub_net_network_level_interface *inf,
-                           const grub_net_network_level_address_t *proto_addr);
+			   const grub_net_network_level_address_t *proto_addr);
 
 #endif 

include/grub/net/ip.h

@@ -48,8 +48,7 @@ grub_err_t
 grub_net_recv_ip_packets (struct grub_net_buff *nb,
 			  struct grub_net_card *card,
 			  const grub_net_link_level_address_t *hwaddress,
-			  const grub_net_link_level_address_t *src_hwaddress,
-                          grub_uint16_t *vlantag);
+			  const grub_net_link_level_address_t *src_hwaddress);
 
 grub_err_t
 grub_net_send_ip_packet (struct grub_net_network_level_interface *inf,

include/grub/util/mkimage.h

@@ -30,7 +30,7 @@ struct grub_mkimage_layout
   size_t align;
   grub_size_t ia64jmp_off;
   grub_size_t tramp_off;
-  grub_size_t got_off;
+  grub_size_t ia64_got_off;
   grub_size_t got_size;
   unsigned ia64jmpnum;
   grub_uint32_t bss_start;

include/grub/xen/relocator.h

@@ -23,13 +23,11 @@
 #include <grub/err.h>
 #include <grub/relocator.h>
 
-#define XEN_MAX_MAPPINGS 3
-
 struct grub_relocator_xen_state
 {
   grub_addr_t start_info;
-  grub_addr_t paging_start[XEN_MAX_MAPPINGS];
-  grub_addr_t paging_size[XEN_MAX_MAPPINGS];
+  grub_addr_t paging_start;
+  grub_addr_t paging_size;
   grub_addr_t mfn_list;
   grub_addr_t stack;
   grub_addr_t entry_point;

include/grub/xen_file.h

@@ -32,13 +32,10 @@ struct grub_xen_file_info
   grub_uint64_t entry_point;
   grub_uint64_t hypercall_page;
   grub_uint64_t paddr_offset;
-  grub_uint64_t p2m_base;
   int has_hypercall_page;
   int has_note;
   int has_xen_guest;
-  int has_p2m_base;
   int extended_cr3;
-  int unmapped_initrd;
   enum
   {
     GRUB_XEN_FILE_I386 = 1,

include/multiboot2.h

@@ -60,9 +60,6 @@
 #define MULTIBOOT_TAG_TYPE_NETWORK           16
 #define MULTIBOOT_TAG_TYPE_EFI_MMAP          17
 #define MULTIBOOT_TAG_TYPE_EFI_BS            18
-#define MULTIBOOT_TAG_TYPE_EFI32_IH          19
-#define MULTIBOOT_TAG_TYPE_EFI64_IH          20
-#define MULTIBOOT_TAG_TYPE_LOAD_BASE_ADDR    21
 
 #define MULTIBOOT_HEADER_TAG_END  0
 #define MULTIBOOT_HEADER_TAG_INFORMATION_REQUEST  1
@@ -72,17 +69,11 @@
 #define MULTIBOOT_HEADER_TAG_FRAMEBUFFER  5
 #define MULTIBOOT_HEADER_TAG_MODULE_ALIGN  6
 #define MULTIBOOT_HEADER_TAG_EFI_BS  7
-#define MULTIBOOT_HEADER_TAG_ENTRY_ADDRESS_EFI64  9
-#define MULTIBOOT_HEADER_TAG_RELOCATABLE  10
 
 #define MULTIBOOT_ARCHITECTURE_I386  0
 #define MULTIBOOT_ARCHITECTURE_MIPS32  4
 #define MULTIBOOT_HEADER_TAG_OPTIONAL 1
 
-#define MULTIBOOT_LOAD_PREFERENCE_NONE 0
-#define MULTIBOOT_LOAD_PREFERENCE_LOW 1
-#define MULTIBOOT_LOAD_PREFERENCE_HIGH 2
-
 #define MULTIBOOT_CONSOLE_FLAGS_CONSOLE_REQUIRED 1
 #define MULTIBOOT_CONSOLE_FLAGS_EGA_TEXT_SUPPORTED 2
 
@@ -167,17 +158,6 @@ struct multiboot_header_tag_module_align
   multiboot_uint32_t size;
 };
 
-struct multiboot_header_tag_relocatable
-{
-  multiboot_uint16_t type;
-  multiboot_uint16_t flags;
-  multiboot_uint32_t size;
-  multiboot_uint32_t min_addr;
-  multiboot_uint32_t max_addr;
-  multiboot_uint32_t align;
-  multiboot_uint32_t preference;
-};
-
 struct multiboot_color
 {
   multiboot_uint8_t red;
@@ -390,27 +370,6 @@ struct multiboot_tag_efi_mmap
   multiboot_uint8_t efi_mmap[0];
 }; 
 
-struct multiboot_tag_efi32_ih
-{
-  multiboot_uint32_t type;
-  multiboot_uint32_t size;
-  multiboot_uint32_t pointer;
-};
-
-struct multiboot_tag_efi64_ih
-{
-  multiboot_uint32_t type;
-  multiboot_uint32_t size;
-  multiboot_uint64_t pointer;
-};
-
-struct multiboot_tag_load_base_addr
-{
-  multiboot_uint32_t type;
-  multiboot_uint32_t size;
-  multiboot_uint32_t load_base_addr;
-};
-
 #endif /* ! ASM_FILE */
 
 #endif /* ! MULTIBOOT_HEADER */

include/xen/arch-x86/xen-x86_32.h

@@ -58,31 +58,34 @@
 #define __HYPERVISOR_VIRT_START_PAE    0xF5800000
 #define __MACH2PHYS_VIRT_START_PAE     0xF5800000
 #define __MACH2PHYS_VIRT_END_PAE       0xF6800000
-#define HYPERVISOR_VIRT_START_PAE      xen_mk_ulong(__HYPERVISOR_VIRT_START_PAE)
-#define MACH2PHYS_VIRT_START_PAE       xen_mk_ulong(__MACH2PHYS_VIRT_START_PAE)
-#define MACH2PHYS_VIRT_END_PAE         xen_mk_ulong(__MACH2PHYS_VIRT_END_PAE)
+#define HYPERVISOR_VIRT_START_PAE      \
+    mk_unsigned_long(__HYPERVISOR_VIRT_START_PAE)
+#define MACH2PHYS_VIRT_START_PAE       \
+    mk_unsigned_long(__MACH2PHYS_VIRT_START_PAE)
+#define MACH2PHYS_VIRT_END_PAE         \
+    mk_unsigned_long(__MACH2PHYS_VIRT_END_PAE)
 
 /* Non-PAE bounds are obsolete. */
 #define __HYPERVISOR_VIRT_START_NONPAE 0xFC000000
 #define __MACH2PHYS_VIRT_START_NONPAE  0xFC000000
 #define __MACH2PHYS_VIRT_END_NONPAE    0xFC400000
 #define HYPERVISOR_VIRT_START_NONPAE   \
-    xen_mk_ulong(__HYPERVISOR_VIRT_START_NONPAE)
+    mk_unsigned_long(__HYPERVISOR_VIRT_START_NONPAE)
 #define MACH2PHYS_VIRT_START_NONPAE    \
-    xen_mk_ulong(__MACH2PHYS_VIRT_START_NONPAE)
+    mk_unsigned_long(__MACH2PHYS_VIRT_START_NONPAE)
 #define MACH2PHYS_VIRT_END_NONPAE      \
-    xen_mk_ulong(__MACH2PHYS_VIRT_END_NONPAE)
+    mk_unsigned_long(__MACH2PHYS_VIRT_END_NONPAE)
 
 #define __HYPERVISOR_VIRT_START __HYPERVISOR_VIRT_START_PAE
 #define __MACH2PHYS_VIRT_START  __MACH2PHYS_VIRT_START_PAE
 #define __MACH2PHYS_VIRT_END    __MACH2PHYS_VIRT_END_PAE
 
 #ifndef HYPERVISOR_VIRT_START
-#define HYPERVISOR_VIRT_START xen_mk_ulong(__HYPERVISOR_VIRT_START)
+#define HYPERVISOR_VIRT_START mk_unsigned_long(__HYPERVISOR_VIRT_START)
 #endif
 
-#define MACH2PHYS_VIRT_START  xen_mk_ulong(__MACH2PHYS_VIRT_START)
-#define MACH2PHYS_VIRT_END    xen_mk_ulong(__MACH2PHYS_VIRT_END)
+#define MACH2PHYS_VIRT_START  mk_unsigned_long(__MACH2PHYS_VIRT_START)
+#define MACH2PHYS_VIRT_END    mk_unsigned_long(__MACH2PHYS_VIRT_END)
 #define MACH2PHYS_NR_ENTRIES  ((MACH2PHYS_VIRT_END-MACH2PHYS_VIRT_START)>>2)
 #ifndef machine_to_phys_mapping
 #define machine_to_phys_mapping ((unsigned long *)MACH2PHYS_VIRT_START)
@@ -101,7 +104,6 @@
     do { if ( sizeof(hnd) == 8 ) *(uint64_t *)&(hnd) = 0;   \
          (hnd).p = val;                                     \
     } while ( 0 )
-#define  int64_aligned_t  int64_t __attribute__((aligned(8)))
 #define uint64_aligned_t uint64_t __attribute__((aligned(8)))
 #define __XEN_GUEST_HANDLE_64(name) __guest_handle_64_ ## name
 #define XEN_GUEST_HANDLE_64(name) __XEN_GUEST_HANDLE_64(name)

include/xen/arch-x86/xen-x86_64.h

@@ -76,12 +76,12 @@
 #define __MACH2PHYS_VIRT_END    0xFFFF804000000000
 
 #ifndef HYPERVISOR_VIRT_START
-#define HYPERVISOR_VIRT_START xen_mk_ulong(__HYPERVISOR_VIRT_START)
-#define HYPERVISOR_VIRT_END   xen_mk_ulong(__HYPERVISOR_VIRT_END)
+#define HYPERVISOR_VIRT_START mk_unsigned_long(__HYPERVISOR_VIRT_START)
+#define HYPERVISOR_VIRT_END   mk_unsigned_long(__HYPERVISOR_VIRT_END)
 #endif
 
-#define MACH2PHYS_VIRT_START  xen_mk_ulong(__MACH2PHYS_VIRT_START)
-#define MACH2PHYS_VIRT_END    xen_mk_ulong(__MACH2PHYS_VIRT_END)
+#define MACH2PHYS_VIRT_START  mk_unsigned_long(__MACH2PHYS_VIRT_START)
+#define MACH2PHYS_VIRT_END    mk_unsigned_long(__MACH2PHYS_VIRT_END)
 #define MACH2PHYS_NR_ENTRIES  ((MACH2PHYS_VIRT_END-MACH2PHYS_VIRT_START)>>3)
 #ifndef machine_to_phys_mapping
 #define machine_to_phys_mapping ((unsigned long *)HYPERVISOR_VIRT_START)