mirrors/qemu
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

hw/i386: Use explicit little-endian LD/ST API

Browse Source 
The x86 architecture uses little endianness. Directly use
the little-endian LD/ST API.

Mechanical change using:

  $ end=le; \
    for acc in uw w l q tul; do \
      sed -i -e "s/ld${acc}_p(/ld${acc}_${end}_p(/" \
             -e "s/st${acc}_p(/st${acc}_${end}_p(/" \
        $(git grep -wlE '(ld|st)t?u?[wlq]_p' hw/i386/); \
    done

Signed-off-by: Philippe Mathieu-Daudé <philmd@linaro.org>
Reviewed-by: Richard Henderson <richard.henderson@linaro.org>
Message-Id: <20241004163042.85922-9-philmd@linaro.org>
This commit is contained in:
Philippe Mathieu-Daudé 2024-10-04 11:58:26 +02:00
parent ae412c0210
commit c3fb1fc926
2 changed files with 32 additions and 33 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

39
hw/i386/multiboot.c
View File

@ -133,9 +133,9 @@ static void mb_add_mod(MultibootState *s,
p = (char *)s->mb_buf + s->offset_mbinfo + MB_MOD_SIZE * s->mb_mods_count; p = (char *)s->mb_buf + s->offset_mbinfo + MB_MOD_SIZE * s->mb_mods_count;
stl_p(p + MB_MOD_START, start); stl_le_p(p + MB_MOD_START, start);
stl_p(p + MB_MOD_END, end); stl_le_p(p + MB_MOD_END, end);
stl_p(p + MB_MOD_CMDLINE, cmdline_phys); stl_le_p(p + MB_MOD_CMDLINE, cmdline_phys);
mb_debug("mod%02d: "HWADDR_FMT_plx" - "HWADDR_FMT_plx, mb_debug("mod%02d: "HWADDR_FMT_plx" - "HWADDR_FMT_plx,
s->mb_mods_count, start, end); s->mb_mods_count, start, end);
@ -168,9 +168,9 @@ int load_multiboot(X86MachineState *x86ms,
/* Ok, let's see if it is a multiboot image. /* Ok, let's see if it is a multiboot image.
The header is 12x32bit long, so the latest entry may be 8192 - 48. */ The header is 12x32bit long, so the latest entry may be 8192 - 48. */
for (i = 0; i < (8192 - 48); i += 4) { for (i = 0; i < (8192 - 48); i += 4) {
if (ldl_p(header+i) == 0x1BADB002) { if (ldl_le_p(header + i) == 0x1BADB002) {
uint32_t checksum = ldl_p(header+i+8); uint32_t checksum = ldl_le_p(header + i + 8);
flags = ldl_p(header+i+4); flags = ldl_le_p(header + i + 4);
checksum += flags; checksum += flags;
checksum += (uint32_t)0x1BADB002; checksum += (uint32_t)0x1BADB002;
if (!checksum) { if (!checksum) {
@ -223,11 +223,11 @@ int load_multiboot(X86MachineState *x86ms,
mb_kernel_size, (size_t)mh_entry_addr); mb_kernel_size, (size_t)mh_entry_addr);
} else { } else {
/* Valid if mh_flags sets MULTIBOOT_HEADER_HAS_ADDR. */ /* Valid if mh_flags sets MULTIBOOT_HEADER_HAS_ADDR. */
uint32_t mh_header_addr = ldl_p(header+i+12); uint32_t mh_header_addr = ldl_le_p(header + i + 12);
uint32_t mh_load_end_addr = ldl_p(header+i+20); uint32_t mh_load_end_addr = ldl_le_p(header + i + 20);
uint32_t mh_bss_end_addr = ldl_p(header+i+24); uint32_t mh_bss_end_addr = ldl_le_p(header + i + 24);
mh_load_addr = ldl_p(header+i+16); mh_load_addr = ldl_le_p(header + i + 16);
if (mh_header_addr < mh_load_addr) { if (mh_header_addr < mh_load_addr) {
error_report("invalid load_addr address"); error_report("invalid load_addr address");
exit(1); exit(1);
@ -239,7 +239,7 @@ int load_multiboot(X86MachineState *x86ms,
uint32_t mb_kernel_text_offset = i - (mh_header_addr - mh_load_addr); uint32_t mb_kernel_text_offset = i - (mh_header_addr - mh_load_addr);
uint32_t mb_load_size = 0; uint32_t mb_load_size = 0;
mh_entry_addr = ldl_p(header+i+28); mh_entry_addr = ldl_le_p(header + i + 28);
if (mh_load_end_addr) { if (mh_load_end_addr) {
if (mh_load_end_addr < mh_load_addr) { if (mh_load_end_addr < mh_load_addr) {
@ -364,22 +364,21 @@ int load_multiboot(X86MachineState *x86ms,
/* Commandline support */ /* Commandline support */
kcmdline = g_strdup_printf("%s %s", kernel_filename, kernel_cmdline); kcmdline = g_strdup_printf("%s %s", kernel_filename, kernel_cmdline);
stl_p(bootinfo + MBI_CMDLINE, mb_add_cmdline(&mbs, kcmdline)); stl_le_p(bootinfo + MBI_CMDLINE, mb_add_cmdline(&mbs, kcmdline));
stl_le_p(bootinfo + MBI_BOOTLOADER, mb_add_bootloader(&mbs,
stl_p(bootinfo + MBI_BOOTLOADER, mb_add_bootloader(&mbs, bootloader_name)); bootloader_name));
stl_le_p(bootinfo + MBI_MODS_ADDR, mbs.mb_buf_phys + mbs.offset_mbinfo);
stl_p(bootinfo + MBI_MODS_ADDR, mbs.mb_buf_phys + mbs.offset_mbinfo); stl_le_p(bootinfo + MBI_MODS_COUNT, mbs.mb_mods_count); /* mods_count */
stl_p(bootinfo + MBI_MODS_COUNT, mbs.mb_mods_count); /* mods_count */
/* the kernel is where we want it to be now */ /* the kernel is where we want it to be now */
stl_p(bootinfo + MBI_FLAGS, MULTIBOOT_FLAGS_MEMORY stl_le_p(bootinfo + MBI_FLAGS, MULTIBOOT_FLAGS_MEMORY
| MULTIBOOT_FLAGS_BOOT_DEVICE | MULTIBOOT_FLAGS_BOOT_DEVICE
| MULTIBOOT_FLAGS_CMDLINE | MULTIBOOT_FLAGS_CMDLINE
| MULTIBOOT_FLAGS_MODULES | MULTIBOOT_FLAGS_MODULES
| MULTIBOOT_FLAGS_MMAP | MULTIBOOT_FLAGS_MMAP
| MULTIBOOT_FLAGS_BOOTLOADER); | MULTIBOOT_FLAGS_BOOTLOADER);
stl_p(bootinfo + MBI_BOOT_DEVICE, 0x8000ffff); /* XXX: use the -boot switch? */ stl_le_p(bootinfo + MBI_BOOT_DEVICE, 0x8000ffff); /* XXX: use the -boot switch? */
stl_p(bootinfo + MBI_MMAP_ADDR, ADDR_E820_MAP); stl_le_p(bootinfo + MBI_MMAP_ADDR, ADDR_E820_MAP);
mb_debug("multiboot: entry_addr = %#x", mh_entry_addr); mb_debug("multiboot: entry_addr = %#x", mh_entry_addr);
mb_debug(" mb_buf_phys = "HWADDR_FMT_plx, mbs.mb_buf_phys); mb_debug(" mb_buf_phys = "HWADDR_FMT_plx, mbs.mb_buf_phys);

26
hw/i386/x86-common.c
View File

@ -586,7 +586,7 @@ static bool load_elfboot(const char *kernel_filename,
uint64_t elf_low, elf_high; uint64_t elf_low, elf_high;
int kernel_size; int kernel_size;
if (ldl_p(header) != 0x464c457f) { if (ldl_le_p(header) != 0x464c457f) {
return false; /* no elfboot */ return false; /* no elfboot */
} }
@ -669,8 +669,8 @@ void x86_load_linux(X86MachineState *x86ms,
* kernel protocol version. * kernel protocol version.
* Please see https://www.kernel.org/doc/Documentation/x86/boot.txt * Please see https://www.kernel.org/doc/Documentation/x86/boot.txt
*/ */
if (ldl_p(header + 0x202) == 0x53726448) /* Magic signature "HdrS" */ { if (ldl_le_p(header + 0x202) == 0x53726448) /* Magic signature "HdrS" */ {
protocol = lduw_p(header + 0x206); protocol = lduw_le_p(header + 0x206);
} else { } else {
/* /*
* This could be a multiboot kernel. If it is, let's stop treating it * This could be a multiboot kernel. If it is, let's stop treating it
@ -762,7 +762,7 @@ void x86_load_linux(X86MachineState *x86ms,
/* highest address for loading the initrd */ /* highest address for loading the initrd */
if (protocol >= 0x20c && if (protocol >= 0x20c &&
lduw_p(header + 0x236) & XLF_CAN_BE_LOADED_ABOVE_4G) { lduw_le_p(header + 0x236) & XLF_CAN_BE_LOADED_ABOVE_4G) {
/* /*
* Linux has supported initrd up to 4 GB for a very long time (2007, * Linux has supported initrd up to 4 GB for a very long time (2007,
* long before XLF_CAN_BE_LOADED_ABOVE_4G which was added in 2013), * long before XLF_CAN_BE_LOADED_ABOVE_4G which was added in 2013),
@ -781,7 +781,7 @@ void x86_load_linux(X86MachineState *x86ms,
*/ */
initrd_max = UINT32_MAX; initrd_max = UINT32_MAX;
} else if (protocol >= 0x203) { } else if (protocol >= 0x203) {
initrd_max = ldl_p(header + 0x22c); initrd_max = ldl_le_p(header + 0x22c);
} else { } else {
initrd_max = 0x37ffffff; initrd_max = 0x37ffffff;
} }
@ -797,10 +797,10 @@ void x86_load_linux(X86MachineState *x86ms,
sev_load_ctx.cmdline_size = strlen(kernel_cmdline) + 1; sev_load_ctx.cmdline_size = strlen(kernel_cmdline) + 1;
if (protocol >= 0x202) { if (protocol >= 0x202) {
stl_p(header + 0x228, cmdline_addr); stl_le_p(header + 0x228, cmdline_addr);
} else { } else {
stw_p(header + 0x20, 0xA33F); stw_le_p(header + 0x20, 0xA33F);
stw_p(header + 0x22, cmdline_addr - real_addr); stw_le_p(header + 0x22, cmdline_addr - real_addr);
} }
/* handle vga= parameter */ /* handle vga= parameter */
@ -824,7 +824,7 @@ void x86_load_linux(X86MachineState *x86ms,
exit(1); exit(1);
} }
} }
stw_p(header + 0x1fa, video_mode); stw_le_p(header + 0x1fa, video_mode);
} }
/* loader type */ /* loader type */
@ -839,7 +839,7 @@ void x86_load_linux(X86MachineState *x86ms,
/* heap */ /* heap */
if (protocol >= 0x201) { if (protocol >= 0x201) {
header[0x211] |= 0x80; /* CAN_USE_HEAP */ header[0x211] |= 0x80; /* CAN_USE_HEAP */
stw_p(header + 0x224, cmdline_addr - real_addr - 0x200); stw_le_p(header + 0x224, cmdline_addr - real_addr - 0x200);
} }
/* load initrd */ /* load initrd */
@ -879,8 +879,8 @@ void x86_load_linux(X86MachineState *x86ms,
sev_load_ctx.initrd_data = initrd_data; sev_load_ctx.initrd_data = initrd_data;
sev_load_ctx.initrd_size = initrd_size; sev_load_ctx.initrd_size = initrd_size;
stl_p(header + 0x218, initrd_addr); stl_le_p(header + 0x218, initrd_addr);
stl_p(header + 0x21c, initrd_size); stl_le_p(header + 0x21c, initrd_size);
} }
/* load kernel and setup */ /* load kernel and setup */
@ -926,7 +926,7 @@ void x86_load_linux(X86MachineState *x86ms,
kernel_size = setup_data_offset + sizeof(struct setup_data) + dtb_size; kernel_size = setup_data_offset + sizeof(struct setup_data) + dtb_size;
kernel = g_realloc(kernel, kernel_size); kernel = g_realloc(kernel, kernel_size);
stq_p(header + 0x250, prot_addr + setup_data_offset); stq_le_p(header + 0x250, prot_addr + setup_data_offset);
setup_data = (struct setup_data *)(kernel + setup_data_offset); setup_data = (struct setup_data *)(kernel + setup_data_offset);
setup_data->next = 0; setup_data->next = 0;