arch/x86/boot/compressed/head_64.S

   1 /* SPDX-License-Identifier: GPL-2.0 */
   2 /*
   3  *  linux/boot/head.S
   4  *
   5  *  Copyright (C) 1991, 1992, 1993  Linus Torvalds
   6  */
   7
   8 /*
   9  *  head.S contains the 32-bit startup code.
  10  *
  11  * NOTE!!! Startup happens at absolute address 0x00001000, which is also where
  12  * the page directory will exist. The startup code will be overwritten by
  13  * the page directory. [According to comments etc elsewhere on a compressed
  14  * kernel it will end up at 0x1000 + 1Mb I hope so as I assume this. - AC]
  15  *
  16  * Page 0 is deliberately kept safe, since System Management Mode code in
  17  * laptops may need to access the BIOS data stored there.  This is also
  18  * useful for future device drivers that either access the BIOS via VM86
  19  * mode.
  20  */
  21
  22 /*
  23  * High loaded stuff by Hans Lermen & Werner Almesberger, Feb. 1996
  24  */
  25         .code32
  26         .text
  27
  28 #include <linux/init.h>
  29 #include <linux/linkage.h>
  30 #include <asm/segment.h>
  31 #include <asm/boot.h>
  32 #include <asm/msr.h>
  33 #include <asm/processor-flags.h>
  34 #include <asm/asm-offsets.h>
  35 #include <asm/bootparam.h>
  36 #include "pgtable.h"
  37
  38 /*
  39  * Locally defined symbols should be marked hidden:
  40  */
  41         .hidden _bss
  42         .hidden _ebss
  43         .hidden _got
  44         .hidden _egot
  45
  46         __HEAD
  47         .code32
  48 SYM_FUNC_START(startup_32)
  49         /*
  50          * 32bit entry is 0 and it is ABI so immutable!
  51          * If we come here directly from a bootloader,
  52          * kernel(text+data+bss+brk) ramdisk, zero_page, command line
  53          * all need to be under the 4G limit.
  54          */
  55         cld
  56         cli
  57
  58 /*
  59  * Calculate the delta between where we were compiled to run
  60  * at and where we were actually loaded at.  This can only be done
  61  * with a short local call on x86.  Nothing  else will tell us what
  62  * address we are running at.  The reserved chunk of the real-mode
  63  * data at 0x1e4 (defined as a scratch field) are used as the stack
  64  * for this calculation. Only 4 bytes are needed.
  65  */
  66         leal    (BP_scratch+4)(%esi), %esp
  67         call    1f
  68 1:      popl    %ebp
  69         subl    $1b, %ebp
  70
  71         /* Load new GDT with the 64bit segments using 32bit descriptor */
  72         leal    gdt(%ebp), %eax
  73         movl    %eax, 2(%eax)
  74         lgdt    (%eax)
  75
  76         /* Load segment registers with our descriptors */
  77         movl    $__BOOT_DS, %eax
  78         movl    %eax, %ds
  79         movl    %eax, %es
  80         movl    %eax, %fs
  81         movl    %eax, %gs
  82         movl    %eax, %ss
  83
  84 /* setup a stack and make sure cpu supports long mode. */
  85         leal    boot_stack_end(%ebp), %esp
  86
  87         call    verify_cpu
  88         testl   %eax, %eax
  89         jnz     .Lno_longmode
  90
  91 /*
  92  * Compute the delta between where we were compiled to run at
  93  * and where the code will actually run at.
  94  *
  95  * %ebp contains the address we are loaded at by the boot loader and %ebx
  96  * contains the address where we should move the kernel image temporarily
  97  * for safe in-place decompression.
  98  */
  99
 100 #ifdef CONFIG_RELOCATABLE
 101         movl    %ebp, %ebx
 102         movl    BP_kernel_alignment(%esi), %eax
 103         decl    %eax
 104         addl    %eax, %ebx
 105         notl    %eax
 106         andl    %eax, %ebx
 107         cmpl    $LOAD_PHYSICAL_ADDR, %ebx
 108         jge     1f
 109 #endif
 110         movl    $LOAD_PHYSICAL_ADDR, %ebx
 111 1:
 112
 113         /* Target address to relocate to for decompression */
 114         movl    BP_init_size(%esi), %eax
 115         subl    $_end, %eax
 116         addl    %eax, %ebx
 117
 118 /*
 119  * Prepare for entering 64 bit mode
 120  */
 121
 122         /* Enable PAE mode */
 123         movl    %cr4, %eax
 124         orl     $X86_CR4_PAE, %eax
 125         movl    %eax, %cr4
 126
 127  /*
 128   * Build early 4G boot pagetable
 129   */
 130         /*
 131          * If SEV is active then set the encryption mask in the page tables.
 132          * This will insure that when the kernel is copied and decompressed
 133          * it will be done so encrypted.
 134          */
 135         call    get_sev_encryption_bit
 136         xorl    %edx, %edx
 137         testl   %eax, %eax
 138         jz      1f
 139         subl    $32, %eax       /* Encryption bit is always above bit 31 */
 140         bts     %eax, %edx      /* Set encryption mask for page tables */
 141 1:
 142
 143         /* Initialize Page tables to 0 */
 144         leal    pgtable(%ebx), %edi
 145         xorl    %eax, %eax
 146         movl    $(BOOT_INIT_PGT_SIZE/4), %ecx
 147         rep     stosl
 148
 149         /* Build Level 4 */
 150         leal    pgtable + 0(%ebx), %edi
 151         leal    0x1007 (%edi), %eax
 152         movl    %eax, 0(%edi)
 153         addl    %edx, 4(%edi)
 154
 155         /* Build Level 3 */
 156         leal    pgtable + 0x1000(%ebx), %edi
 157         leal    0x1007(%edi), %eax
 158         movl    $4, %ecx
 159 1:      movl    %eax, 0x00(%edi)
 160         addl    %edx, 0x04(%edi)
 161         addl    $0x00001000, %eax
 162         addl    $8, %edi
 163         decl    %ecx
 164         jnz     1b
 165
 166         /* Build Level 2 */
 167         leal    pgtable + 0x2000(%ebx), %edi
 168         movl    $0x00000183, %eax
 169         movl    $2048, %ecx
 170 1:      movl    %eax, 0(%edi)
 171         addl    %edx, 4(%edi)
 172         addl    $0x00200000, %eax
 173         addl    $8, %edi
 174         decl    %ecx
 175         jnz     1b
 176
 177         /* Enable the boot page tables */
 178         leal    pgtable(%ebx), %eax
 179         movl    %eax, %cr3
 180
 181         /* Enable Long mode in EFER (Extended Feature Enable Register) */
 182         movl    $MSR_EFER, %ecx
 183         rdmsr
 184         btsl    $_EFER_LME, %eax
 185         wrmsr
 186
 187         /* After gdt is loaded */
 188         xorl    %eax, %eax
 189         lldt    %ax
 190         movl    $__BOOT_TSS, %eax
 191         ltr     %ax
 192
 193         /*
 194          * Setup for the jump to 64bit mode
 195          *
 196          * When the jump is performend we will be in long mode but
 197          * in 32bit compatibility mode with EFER.LME = 1, CS.L = 0, CS.D = 1
 198          * (and in turn EFER.LMA = 1).  To jump into 64bit mode we use
 199          * the new gdt/idt that has __KERNEL_CS with CS.L = 1.
 200          * We place all of the values on our mini stack so lret can
 201          * used to perform that far jump.
 202          */
 203         pushl   $__KERNEL_CS
 204         leal    startup_64(%ebp), %eax
 205 #ifdef CONFIG_EFI_MIXED
 206         movl    efi32_boot_args(%ebp), %edi
 207         cmp     $0, %edi
 208         jz      1f
 209         leal    efi64_stub_entry(%ebp), %eax
 210         movl    efi32_boot_args+4(%ebp), %esi
 211         movl    efi32_boot_args+8(%ebp), %edx   // saved bootparams pointer
 212         cmpl    $0, %edx
 213         jnz     1f
 214         leal    efi_pe_entry(%ebp), %eax
 215         movl    %edi, %ecx                      // MS calling convention
 216         movl    %esi, %edx
 217 1:
 218 #endif
 219         pushl   %eax
 220
 221         /* Enter paged protected Mode, activating Long Mode */
 222         movl    $(X86_CR0_PG | X86_CR0_PE), %eax /* Enable Paging and Protected mode */
 223         movl    %eax, %cr0
 224
 225         /* Jump from 32bit compatibility mode into 64bit mode. */
 226         lret
 227 SYM_FUNC_END(startup_32)
 228
 229 #ifdef CONFIG_EFI_MIXED
 230         .org 0x190
 231 SYM_FUNC_START(efi32_stub_entry)
 232         add     $0x4, %esp              /* Discard return address */
 233         popl    %ecx
 234         popl    %edx
 235         popl    %esi
 236
 237         call    1f
 238 1:      pop     %ebp
 239         subl    $1b, %ebp
 240
 241         movl    %esi, efi32_boot_args+8(%ebp)
 242 SYM_INNER_LABEL(efi32_pe_stub_entry, SYM_L_LOCAL)
 243         movl    %ecx, efi32_boot_args(%ebp)
 244         movl    %edx, efi32_boot_args+4(%ebp)
 245         movb    $0, efi_is64(%ebp)
 246
 247         /* Save firmware GDTR and code/data selectors */
 248         sgdtl   efi32_boot_gdt(%ebp)
 249         movw    %cs, efi32_boot_cs(%ebp)
 250         movw    %ds, efi32_boot_ds(%ebp)
 251
 252         /* Disable paging */
 253         movl    %cr0, %eax
 254         btrl    $X86_CR0_PG_BIT, %eax
 255         movl    %eax, %cr0
 256
 257         jmp     startup_32
 258 SYM_FUNC_END(efi32_stub_entry)
 259 #endif
 260
 261         .code64
 262         .org 0x200
 263 SYM_CODE_START(startup_64)
 264         /*
 265          * 64bit entry is 0x200 and it is ABI so immutable!
 266          * We come here either from startup_32 or directly from a
 267          * 64bit bootloader.
 268          * If we come here from a bootloader, kernel(text+data+bss+brk),
 269          * ramdisk, zero_page, command line could be above 4G.
 270          * We depend on an identity mapped page table being provided
 271          * that maps our entire kernel(text+data+bss+brk), zero page
 272          * and command line.
 273          */
 274
 275         cld
 276         cli
 277
 278         /* Setup data segments. */
 279         xorl    %eax, %eax
 280         movl    %eax, %ds
 281         movl    %eax, %es
 282         movl    %eax, %ss
 283         movl    %eax, %fs
 284         movl    %eax, %gs
 285
 286         /*
 287          * Compute the decompressed kernel start address.  It is where
 288          * we were loaded at aligned to a 2M boundary. %rbp contains the
 289          * decompressed kernel start address.
 290          *
 291          * If it is a relocatable kernel then decompress and run the kernel
 292          * from load address aligned to 2MB addr, otherwise decompress and
 293          * run the kernel from LOAD_PHYSICAL_ADDR
 294          *
 295          * We cannot rely on the calculation done in 32-bit mode, since we
 296          * may have been invoked via the 64-bit entry point.
 297          */
 298
 299         /* Start with the delta to where the kernel will run at. */
 300 #ifdef CONFIG_RELOCATABLE
 301         leaq    startup_32(%rip) /* - $startup_32 */, %rbp
 302         movl    BP_kernel_alignment(%rsi), %eax
 303         decl    %eax
 304         addq    %rax, %rbp
 305         notq    %rax
 306         andq    %rax, %rbp
 307         cmpq    $LOAD_PHYSICAL_ADDR, %rbp
 308         jge     1f
 309 #endif
 310         movq    $LOAD_PHYSICAL_ADDR, %rbp
 311 1:
 312
 313         /* Target address to relocate to for decompression */
 314         movl    BP_init_size(%rsi), %ebx
 315         subl    $_end, %ebx
 316         addq    %rbp, %rbx
 317
 318         /* Set up the stack */
 319         leaq    boot_stack_end(%rbx), %rsp
 320
 321         /*
 322          * paging_prepare() and cleanup_trampoline() below can have GOT
 323          * references. Adjust the table with address we are running at.
 324          *
 325          * Zero RAX for adjust_got: the GOT was not adjusted before;
 326          * there's no adjustment to undo.
 327          */
 328         xorq    %rax, %rax
 329
 330         /*
 331          * Calculate the address the binary is loaded at and use it as
 332          * a GOT adjustment.
 333          */
 334         call    1f
 335 1:      popq    %rdi
 336         subq    $1b, %rdi
 337
 338         call    .Ladjust_got
 339
 340         /*
 341          * At this point we are in long mode with 4-level paging enabled,
 342          * but we might want to enable 5-level paging or vice versa.
 343          *
 344          * The problem is that we cannot do it directly. Setting or clearing
 345          * CR4.LA57 in long mode would trigger #GP. So we need to switch off
 346          * long mode and paging first.
 347          *
 348          * We also need a trampoline in lower memory to switch over from
 349          * 4- to 5-level paging for cases when the bootloader puts the kernel
 350          * above 4G, but didn't enable 5-level paging for us.
 351          *
 352          * The same trampoline can be used to switch from 5- to 4-level paging
 353          * mode, like when starting 4-level paging kernel via kexec() when
 354          * original kernel worked in 5-level paging mode.
 355          *
 356          * For the trampoline, we need the top page table to reside in lower
 357          * memory as we don't have a way to load 64-bit values into CR3 in
 358          * 32-bit mode.
 359          *
 360          * We go though the trampoline even if we don't have to: if we're
 361          * already in a desired paging mode. This way the trampoline code gets
 362          * tested on every boot.
 363          */
 364
 365         /* Make sure we have GDT with 32-bit code segment */
 366         leaq    gdt64(%rip), %rax
 367         addq    %rax, 2(%rax)
 368         lgdt    (%rax)
 369
 370         /*
 371          * paging_prepare() sets up the trampoline and checks if we need to
 372          * enable 5-level paging.
 373          *
 374          * paging_prepare() returns a two-quadword structure which lands
 375          * into RDX:RAX:
 376          *   - Address of the trampoline is returned in RAX.
 377          *   - Non zero RDX means trampoline needs to enable 5-level
 378          *     paging.
 379          *
 380          * RSI holds real mode data and needs to be preserved across
 381          * this function call.
 382          */
 383         pushq   %rsi
 384         movq    %rsi, %rdi              /* real mode address */
 385         call    paging_prepare
 386         popq    %rsi
 387
 388         /* Save the trampoline address in RCX */
 389         movq    %rax, %rcx
 390
 391         /*
 392          * Load the address of trampoline_return() into RDI.
 393          * It will be used by the trampoline to return to the main code.
 394          */
 395         leaq    trampoline_return(%rip), %rdi
 396
 397         /* Switch to compatibility mode (CS.L = 0 CS.D = 1) via far return */
 398         pushq   $__KERNEL32_CS
 399         leaq    TRAMPOLINE_32BIT_CODE_OFFSET(%rax), %rax
 400         pushq   %rax
 401         lretq
 402 trampoline_return:
 403         /* Restore the stack, the 32-bit trampoline uses its own stack */
 404         leaq    boot_stack_end(%rbx), %rsp
 405
 406         /*
 407          * cleanup_trampoline() would restore trampoline memory.
 408          *
 409          * RDI is address of the page table to use instead of page table
 410          * in trampoline memory (if required).
 411          *
 412          * RSI holds real mode data and needs to be preserved across
 413          * this function call.
 414          */
 415         pushq   %rsi
 416         leaq    top_pgtable(%rbx), %rdi
 417         call    cleanup_trampoline
 418         popq    %rsi
 419
 420         /* Zero EFLAGS */
 421         pushq   $0
 422         popfq
 423
 424         /*
 425          * Previously we've adjusted the GOT with address the binary was
 426          * loaded at. Now we need to re-adjust for relocation address.
 427          *
 428          * Calculate the address the binary is loaded at, so that we can
 429          * undo the previous GOT adjustment.
 430          */
 431         call    1f
 432 1:      popq    %rax
 433         subq    $1b, %rax
 434
 435         /* The new adjustment is the relocation address */
 436         movq    %rbx, %rdi
 437         call    .Ladjust_got
 438
 439 /*
 440  * Copy the compressed kernel to the end of our buffer
 441  * where decompression in place becomes safe.
 442  */
 443         pushq   %rsi
 444         leaq    (_bss-8)(%rip), %rsi
 445         leaq    (_bss-8)(%rbx), %rdi
 446         movq    $_bss /* - $startup_32 */, %rcx
 447         shrq    $3, %rcx
 448         std
 449         rep     movsq
 450         cld
 451         popq    %rsi
 452
 453         /*
 454          * The GDT may get overwritten either during the copy we just did or
 455          * during extract_kernel below. To avoid any issues, repoint the GDTR
 456          * to the new copy of the GDT.
 457          */
 458         leaq    gdt64(%rbx), %rax
 459         leaq    gdt(%rbx), %rdx
 460         movq    %rdx, 2(%rax)
 461         lgdt    (%rax)
 462
 463 /*
 464  * Jump to the relocated address.
 465  */
 466         leaq    .Lrelocated(%rbx), %rax
 467         jmp     *%rax
 468 SYM_CODE_END(startup_64)
 469
 470 #ifdef CONFIG_EFI_STUB
 471         .org 0x390
 472 SYM_FUNC_START(efi64_stub_entry)
 473 SYM_FUNC_START_ALIAS(efi_stub_entry)
 474         and     $~0xf, %rsp                     /* realign the stack */
 475         call    efi_main
 476         movq    %rax,%rsi
 477         movl    BP_code32_start(%esi), %eax
 478         leaq    startup_64(%rax), %rax
 479         jmp     *%rax
 480 SYM_FUNC_END(efi64_stub_entry)
 481 SYM_FUNC_END_ALIAS(efi_stub_entry)
 482 #endif
 483
 484         .text
 485 SYM_FUNC_START_LOCAL_NOALIGN(.Lrelocated)
 486
 487 /*
 488  * Clear BSS (stack is currently empty)
 489  */
 490         xorl    %eax, %eax
 491         leaq    _bss(%rip), %rdi
 492         leaq    _ebss(%rip), %rcx
 493         subq    %rdi, %rcx
 494         shrq    $3, %rcx
 495         rep     stosq
 496
 497 /*
 498  * Do the extraction, and jump to the new kernel..
 499  */
 500         pushq   %rsi                    /* Save the real mode argument */
 501         movq    %rsi, %rdi              /* real mode address */
 502         leaq    boot_heap(%rip), %rsi   /* malloc area for uncompression */
 503         leaq    input_data(%rip), %rdx  /* input_data */
 504         movl    $z_input_len, %ecx      /* input_len */
 505         movq    %rbp, %r8               /* output target address */
 506         movq    $z_output_len, %r9      /* decompressed length, end of relocs */
 507         call    extract_kernel          /* returns kernel location in %rax */
 508         popq    %rsi
 509
 510 /*
 511  * Jump to the decompressed kernel.
 512  */
 513         jmp     *%rax
 514 SYM_FUNC_END(.Lrelocated)
 515
 516 /*
 517  * Adjust the global offset table
 518  *
 519  * RAX is the previous adjustment of the table to undo (use 0 if it's the
 520  * first time we touch GOT).
 521  * RDI is the new adjustment to apply.
 522  */
 523 .Ladjust_got:
 524         /* Walk through the GOT adding the address to the entries */
 525         leaq    _got(%rip), %rdx
 526         leaq    _egot(%rip), %rcx
 527 1:
 528         cmpq    %rcx, %rdx
 529         jae     2f
 530         subq    %rax, (%rdx)    /* Undo previous adjustment */
 531         addq    %rdi, (%rdx)    /* Apply the new adjustment */
 532         addq    $8, %rdx
 533         jmp     1b
 534 2:
 535         ret
 536
 537         .code32
 538 /*
 539  * This is the 32-bit trampoline that will be copied over to low memory.
 540  *
 541  * RDI contains the return address (might be above 4G).
 542  * ECX contains the base address of the trampoline memory.
 543  * Non zero RDX means trampoline needs to enable 5-level paging.
 544  */
 545 SYM_CODE_START(trampoline_32bit_src)
 546         /* Set up data and stack segments */
 547         movl    $__KERNEL_DS, %eax
 548         movl    %eax, %ds
 549         movl    %eax, %ss
 550
 551         /* Set up new stack */
 552         leal    TRAMPOLINE_32BIT_STACK_END(%ecx), %esp
 553
 554         /* Disable paging */
 555         movl    %cr0, %eax
 556         btrl    $X86_CR0_PG_BIT, %eax
 557         movl    %eax, %cr0
 558
 559         /* Check what paging mode we want to be in after the trampoline */
 560         cmpl    $0, %edx
 561         jz      1f
 562
 563         /* We want 5-level paging: don't touch CR3 if it already points to 5-level page tables */
 564         movl    %cr4, %eax
 565         testl   $X86_CR4_LA57, %eax
 566         jnz     3f
 567         jmp     2f
 568 1:
 569         /* We want 4-level paging: don't touch CR3 if it already points to 4-level page tables */
 570         movl    %cr4, %eax
 571         testl   $X86_CR4_LA57, %eax
 572         jz      3f
 573 2:
 574         /* Point CR3 to the trampoline's new top level page table */
 575         leal    TRAMPOLINE_32BIT_PGTABLE_OFFSET(%ecx), %eax
 576         movl    %eax, %cr3
 577 3:
 578         /* Set EFER.LME=1 as a precaution in case hypervsior pulls the rug */
 579         pushl   %ecx
 580         pushl   %edx
 581         movl    $MSR_EFER, %ecx
 582         rdmsr
 583         btsl    $_EFER_LME, %eax
 584         wrmsr
 585         popl    %edx
 586         popl    %ecx
 587
 588         /* Enable PAE and LA57 (if required) paging modes */
 589         movl    $X86_CR4_PAE, %eax
 590         cmpl    $0, %edx
 591         jz      1f
 592         orl     $X86_CR4_LA57, %eax
 593 1:
 594         movl    %eax, %cr4
 595
 596         /* Calculate address of paging_enabled() once we are executing in the trampoline */
 597         leal    .Lpaging_enabled - trampoline_32bit_src + TRAMPOLINE_32BIT_CODE_OFFSET(%ecx), %eax
 598
 599         /* Prepare the stack for far return to Long Mode */
 600         pushl   $__KERNEL_CS
 601         pushl   %eax
 602
 603         /* Enable paging again */
 604         movl    $(X86_CR0_PG | X86_CR0_PE), %eax
 605         movl    %eax, %cr0
 606
 607         lret
 608 SYM_CODE_END(trampoline_32bit_src)
 609
 610         .code64
 611 SYM_FUNC_START_LOCAL_NOALIGN(.Lpaging_enabled)
 612         /* Return from the trampoline */
 613         jmp     *%rdi
 614 SYM_FUNC_END(.Lpaging_enabled)
 615
 616         /*
 617          * The trampoline code has a size limit.
 618          * Make sure we fail to compile if the trampoline code grows
 619          * beyond TRAMPOLINE_32BIT_CODE_SIZE bytes.
 620          */
 621         .org    trampoline_32bit_src + TRAMPOLINE_32BIT_CODE_SIZE
 622
 623         .code32
 624 SYM_FUNC_START_LOCAL_NOALIGN(.Lno_longmode)
 625         /* This isn't an x86-64 CPU, so hang intentionally, we cannot continue */
 626 1:
 627         hlt
 628         jmp     1b
 629 SYM_FUNC_END(.Lno_longmode)
 630
 631 #include "../../kernel/verify_cpu.S"
 632
 633         .data
 634 SYM_DATA_START_LOCAL(gdt64)
 635         .word   gdt_end - gdt - 1
 636         .quad   gdt - gdt64
 637 SYM_DATA_END(gdt64)
 638         .balign 8
 639 SYM_DATA_START_LOCAL(gdt)
 640         .word   gdt_end - gdt - 1
 641         .long   0
 642         .word   0
 643         .quad   0x00cf9a000000ffff      /* __KERNEL32_CS */
 644         .quad   0x00af9a000000ffff      /* __KERNEL_CS */
 645         .quad   0x00cf92000000ffff      /* __KERNEL_DS */
 646         .quad   0x0080890000000000      /* TS descriptor */
 647         .quad   0x0000000000000000      /* TS continued */
 648 SYM_DATA_END_LABEL(gdt, SYM_L_LOCAL, gdt_end)
 649
 650 #ifdef CONFIG_EFI_MIXED
 651 SYM_DATA_LOCAL(efi32_boot_args, .long 0, 0, 0)
 652 SYM_DATA(efi_is64, .byte 1)
 653
 654 #define ST32_boottime           60 // offsetof(efi_system_table_32_t, boottime)
 655 #define BS32_handle_protocol    88 // offsetof(efi_boot_services_32_t, handle_protocol)
 656 #define LI32_image_base         32 // offsetof(efi_loaded_image_32_t, image_base)
 657
 658         .text
 659         .code32
 660 SYM_FUNC_START(efi32_pe_entry)
 661         pushl   %ebp
 662
 663         call    verify_cpu                      // check for long mode support
 664         testl   %eax, %eax
 665         movl    $0x80000003, %eax               // EFI_UNSUPPORTED
 666         jnz     3f
 667
 668         call    1f
 669 1:      pop     %ebp
 670         subl    $1b, %ebp
 671
 672         /* Get the loaded image protocol pointer from the image handle */
 673         subl    $12, %esp                       // space for the loaded image pointer
 674         pushl   %esp                            // pass its address
 675         leal    4f(%ebp), %eax
 676         pushl   %eax                            // pass the GUID address
 677         pushl   28(%esp)                        // pass the image handle
 678
 679         movl    36(%esp), %eax                  // sys_table
 680         movl    ST32_boottime(%eax), %eax       // sys_table->boottime
 681         call    *BS32_handle_protocol(%eax)     // sys_table->boottime->handle_protocol
 682         cmp     $0, %eax
 683         jnz     2f
 684
 685         movl    32(%esp), %ecx                  // image_handle
 686         movl    36(%esp), %edx                  // sys_table
 687         movl    12(%esp), %esi                  // loaded_image
 688         movl    LI32_image_base(%esi), %esi     // loaded_image->image_base
 689         jmp     efi32_pe_stub_entry
 690
 691 2:      addl    $24, %esp
 692 3:      popl    %ebp
 693         ret
 694 SYM_FUNC_END(efi32_pe_entry)
 695
 696         .section ".rodata"
 697         /* EFI loaded image protocol GUID */
 698 4:      .long   0x5B1B31A1
 699         .word   0x9562, 0x11d2
 700         .byte   0x8E, 0x3F, 0x00, 0xA0, 0xC9, 0x69, 0x72, 0x3B
 701 #endif
 702
 703 /*
 704  * Stack and heap for uncompression
 705  */
 706         .bss
 707         .balign 4
 708 SYM_DATA_LOCAL(boot_heap,       .fill BOOT_HEAP_SIZE, 1, 0)
 709
 710 SYM_DATA_START_LOCAL(boot_stack)
 711         .fill BOOT_STACK_SIZE, 1, 0
 712 SYM_DATA_END_LABEL(boot_stack, SYM_L_LOCAL, boot_stack_end)
 713
 714 /*
 715  * Space for page tables (not in .bss so not zeroed)
 716  */
 717         .section ".pgtable","a",@nobits
 718         .balign 4096
 719 SYM_DATA_LOCAL(pgtable,         .fill BOOT_PGT_SIZE, 1, 0)
 720
 721 /*
 722  * The page table is going to be used instead of page table in the trampoline
 723  * memory.
 724  */
 725 SYM_DATA_LOCAL(top_pgtable,     .fill PAGE_SIZE, 1, 0)