VirtualBox

Ignore:
Timestamp:
Oct 28, 2015 8:17:18 PM (9 years ago)
Author:
vboxsync
Message:

EFI/Firmware: 'svn merge /vendor/edk2/UDK2010.SR1 /vendor/edk2/current .', reverting and removing files+dirs listed in ReadMe.vbox, resolving conflicts with help from ../UDK2014.SP1/. This is a raw untested merge.

Location:
trunk/src/VBox/Devices/EFI/Firmware
Files:
2 deleted
3 edited

Legend:

Unmodified
Added
Removed

  • trunk/src/VBox/Devices/EFI/Firmware

  • trunk/src/VBox/Devices/EFI/Firmware/UefiCpuPkg/CpuDxe/Ia32/CpuAsm.S

    r48674 r58459  
    11#------------------------------------------------------------------------------
    22#*
    3 #*   Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
     3#*   Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>
    44#*   This program and the accompanying materials
    55#*   are licensed and made available under the terms and conditions of the BSD License
    … …  
    1919#.MMX
    2020#.XMM
    21 
    22 #EXTRN ASM_PFX(mErrorCodeFlag):DWORD # Error code flags for exceptions
    23 
    24 
    25 #
    26 # point to the external interrupt vector table
    27 #
    28 ExternalVectorTablePtr:
    29     .byte      0, 0, 0, 0
    30 
    31 ASM_GLOBAL ASM_PFX(InitializeExternalVectorTablePtr)
    32 ASM_PFX(InitializeExternalVectorTablePtr):
    33     movl    4(%esp), %eax
    34     movl    %eax, ExternalVectorTablePtr
    35     ret
    3621
    3722#------------------------------------------------------------------------------
    … …  
    6954    ret
    7055
    71 #---------------------------------------;
    72 # CommonInterruptEntry                  ;
    73 #---------------------------------------;
    74 # The follow algorithm is used for the common interrupt routine.
    75 
    76 ASM_GLOBAL ASM_PFX(CommonInterruptEntry)
    77 ASM_PFX(CommonInterruptEntry):
    78     cli
    79     #
    80     # All interrupt handlers are invoked through interrupt gates, so
    81     # IF flag automatically cleared at the entry point
    82     #
    83 
    84     #
    85     # Calculate vector number
    86     #
    87     # Get the return address of call, actually, it is the
    88     # address of vector number.
    89     #
    90     xchgl   (%esp), %ecx
    91     movw    (%ecx), %cx
    92     andl    $0x0FFFF, %ecx
    93     cmpl    $32, %ecx         # Intel reserved vector for exceptions?
    94     jae     NoErrorCode
    95     bt      %ecx, ASM_PFX(mErrorCodeFlag)
    96     jc      HasErrorCode
    97 
    98 NoErrorCode:
    99 
    100     #
    101     # Stack:
    102     # +---------------------+
    103     # +    EFlags           +
    104     # +---------------------+
    105     # +    CS               +
    106     # +---------------------+
    107     # +    EIP              +
    108     # +---------------------+
    109     # +    ECX              +
    110     # +---------------------+ <-- ESP
    111     #
    112     # Registers:
    113     #   ECX - Vector Number
    114     #
    115 
    116     #
    117     # Put Vector Number on stack
    118     #
    119     pushl   %ecx
    120 
    121     #
    122     # Put 0 (dummy) error code on stack, and restore ECX
    123     #
    124     xorl    %ecx, %ecx  # ECX = 0
    125     xchgl   4(%esp), %ecx
    126 
    127     jmp     ErrorCodeAndVectorOnStack
    128 
    129 HasErrorCode:
    130 
    131     #
    132     # Stack:
    133     # +---------------------+
    134     # +    EFlags           +
    135     # +---------------------+
    136     # +    CS               +
    137     # +---------------------+
    138     # +    EIP              +
    139     # +---------------------+
    140     # +    Error Code       +
    141     # +---------------------+
    142     # +    ECX              +
    143     # +---------------------+ <-- ESP
    144     #
    145     # Registers:
    146     #   ECX - Vector Number
    147     #
    148 
    149     #
    150     # Put Vector Number on stack and restore ECX
    151     #
    152     xchgl   (%esp), %ecx
    153 
    154     #
    155     # Fall through to join main routine code
    156     # at ErrorCodeAndVectorOnStack
    157     #
    158 CommonInterruptEntry_al_0000:
    159     jmp CommonInterruptEntry_al_0000
    160 
    161 ErrorCodeAndVectorOnStack:
    162     pushl   %ebp
    163     movl    %esp, %ebp
    164 
    165     #
    166     # Stack:
    167     # +---------------------+
    168     # +    EFlags           +
    169     # +---------------------+
    170     # +    CS               +
    171     # +---------------------+
    172     # +    EIP              +
    173     # +---------------------+
    174     # +    Error Code       +
    175     # +---------------------+
    176     # +    Vector Number    +
    177     # +---------------------+
    178     # +    EBP              +
    179     # +---------------------+ <-- EBP
    180     #
    181 
    182     #
    183     # Align stack to make sure that EFI_FX_SAVE_STATE_IA32 of EFI_SYSTEM_CONTEXT_IA32
    184     # is 16-byte aligned
    185     #
    186     andl    $0x0fffffff0, %esp
    187     subl    $12, %esp
    188 
    189 #; UINT32  Edi, Esi, Ebp, Esp, Ebx, Edx, Ecx, Eax;
    190     pushl   %eax
    191     pushl   %ecx
    192     pushl   %edx
    193     pushl   %ebx
    194     leal    24(%ebp), %ecx
    195     pushl   %ecx                          # ESP
    196     pushl   (%ebp)              # EBP
    197     pushl   %esi
    198     pushl   %edi
    199 
    200 #; UINT32  Gs, Fs, Es, Ds, Cs, Ss;
    201     movl    %ss, %eax
    202     pushl   %eax
    203     movzwl  16(%ebp), %eax
    204     pushl   %eax
    205     movl    %ds, %eax
    206     pushl   %eax
    207     movl    %es, %eax
    208     pushl   %eax
    209     movl    %fs, %eax
    210     pushl   %eax
    211     movl    %gs, %eax
    212     pushl   %eax
    213 
    214 #; UINT32  Eip;
    215     movl    12(%ebp), %eax
    216     pushl   %eax
    217 
    218 #; UINT32  Gdtr[2], Idtr[2];
    219     subl    $8, %esp
    220     sidt    (%esp)
    221     movl    2(%esp), %eax
    222     xchgl   (%esp), %eax
    223     andl    $0x0FFFF, %eax
    224     movl    %eax, 4(%esp)
    225 
    226     subl    $8, %esp
    227     sgdt    (%esp)
    228     movl    2(%esp), %eax
    229     xchgl   (%esp), %eax
    230     andl    $0x0FFFF, %eax
    231     movl    %eax, 4(%esp)
    232 
    233 #; UINT32  Ldtr, Tr;
    234     xorl    %eax, %eax
    235     str     %ax
    236     pushl   %eax
    237     sldt    %ax
    238     pushl   %eax
    239 
    240 #; UINT32  EFlags;
    241     movl    20(%ebp), %eax
    242     pushl   %eax
    243 
    244 #; UINT32  Cr0, Cr1, Cr2, Cr3, Cr4;
    245     movl    %cr4, %eax
    246     orl     $0x208, %eax
    247     movl    %eax, %cr4
    248     pushl   %eax
    249     movl    %cr3, %eax
    250     pushl   %eax
    251     movl    %cr2, %eax
    252     pushl   %eax
    253     xorl    %eax, %eax
    254     pushl   %eax
    255     movl    %cr0, %eax
    256     pushl   %eax
    257 
    258 #; UINT32  Dr0, Dr1, Dr2, Dr3, Dr6, Dr7;
    259     movl    %dr7, %eax
    260     pushl   %eax
    261     movl    %dr6, %eax
    262     pushl   %eax
    263     movl    %dr3, %eax
    264     pushl   %eax
    265     movl    %dr2, %eax
    266     pushl   %eax
    267     movl    %dr1, %eax
    268     pushl   %eax
    269     movl    %dr0, %eax
    270     pushl   %eax
    271 
    272 #; FX_SAVE_STATE_IA32 FxSaveState;
    273     subl    $512, %esp
    274     movl    %esp, %edi
    275     .byte      0x0f, 0x0ae, 0x07 #fxsave [edi]
    276 
    277 #; UEFI calling convention for IA32 requires that Direction flag in EFLAGs is clear
    278     cld
    279 
    280 #; UINT32  ExceptionData;
    281     pushl   8(%ebp)
    282 
    283 #; call into exception handler
    284     movl    ExternalVectorTablePtr, %eax  # get the interrupt vectors base
    285     orl     %eax, %eax                        # NULL?
    286     jz      nullExternalExceptionHandler
    287 
    288     mov     4(%ebp), %ecx
    289     movl    (%eax,%ecx,4), %eax
    290     orl     %eax, %eax                        # NULL?
    291     jz      nullExternalExceptionHandler
    292 
    293 #; Prepare parameter and call
    294     movl    %esp, %edx
    295     pushl   %edx
    296     movl    4(%ebp), %edx
    297     pushl   %edx
    298 
    299     #
    300     # Call External Exception Handler
    301     #
    302     call    *%eax
    303     addl    $8, %esp
    304 
    305 nullExternalExceptionHandler:
    306 
    307     cli
    308 #; UINT32  ExceptionData;
    309     addl    $4, %esp
    310 
    311 #; FX_SAVE_STATE_IA32 FxSaveState;
    312     movl    %esp, %esi
    313     .byte      0x0f, 0x0ae, 0x0e # fxrstor [esi]
    314     addl    $512, %esp
    315 
    316 #; UINT32  Dr0, Dr1, Dr2, Dr3, Dr6, Dr7;
    317 #; Skip restoration of DRx registers to support in-circuit emualators
    318 #; or debuggers set breakpoint in interrupt/exception context
    319     addl    $24, %esp
    320 
    321 #; UINT32  Cr0, Cr1, Cr2, Cr3, Cr4;
    322     popl    %eax
    323     movl    %eax, %cr0
    324     addl    $4, %esp    # not for Cr1
    325     popl    %eax
    326     movl    %eax, %cr2
    327     popl    %eax
    328     movl    %eax, %cr3
    329     popl    %eax
    330     movl    %eax, %cr4
    331 
    332 #; UINT32  EFlags;
    333     popl    20(%ebp)
    334 
    335 #; UINT32  Ldtr, Tr;
    336 #; UINT32  Gdtr[2], Idtr[2];
    337 #; Best not let anyone mess with these particular registers...
    338     addl    $24, %esp
    339 
    340 #; UINT32  Eip;
    341     popl    12(%ebp)
    342 
    343 #; UINT32  Gs, Fs, Es, Ds, Cs, Ss;
    344 #; NOTE - modified segment registers could hang the debugger...  We
    345 #;        could attempt to insulate ourselves against this possibility,
    346 #;        but that poses risks as well.
    347 #;
    348     popl    %gs
    349     popl    %fs
    350     popl    %es
    351     popl    %ds
    352     popl    16(%ebp)
    353     popl    %ss
    354 
    355 #; UINT32  Edi, Esi, Ebp, Esp, Ebx, Edx, Ecx, Eax;
    356     popl    %edi
    357     popl    %esi
    358     addl    $4, %esp   # not for ebp
    359     addl    $4, %esp   # not for esp
    360     popl    %ebx
    361     popl    %edx
    362     popl    %ecx
    363     popl    %eax
    364 
    365     movl    %ebp, %esp
    366     popl    %ebp
    367     addl    $8, %esp
    368     iretl
    369 
    370 
    37156#END
    37257

  • trunk/src/VBox/Devices/EFI/Firmware/UefiCpuPkg/CpuDxe/Ia32/CpuAsm.asm

    r48674 r58459  
    22;------------------------------------------------------------------------------
    33;*
    4 ;*   Copyright (c) 2006 - 2011, Intel Corporation. All rights reserved.<BR>
     4;*   Copyright (c) 2006 - 2013, Intel Corporation. All rights reserved.<BR>
    55;*   This program and the accompanying materials
    66;*   are licensed and made available under the terms and conditions of the BSD License
    … …  
    2020    .model  flat,C
    2121    .code
    22 
    23 EXTRN mErrorCodeFlag:DWORD ; Error code flags for exceptions
    24 
    25 ;
    26 ; point to the external interrupt vector table
    27 ;
    28 ExternalVectorTablePtr DWORD 0
    29 
    30 InitializeExternalVectorTablePtr PROC PUBLIC
    31     mov     eax, [esp+4]
    32     mov     ExternalVectorTablePtr, eax
    33     ret
    34 InitializeExternalVectorTablePtr ENDP
    3522
    3623;------------------------------------------------------------------------------
    … …  
    6855SetDataSelectors ENDP
    6956
    70 ;---------------------------------------;
    71 ; CommonInterruptEntry                  ;
    72 ;---------------------------------------;
    73 ; The follow algorithm is used for the common interrupt routine.
    74 
    75 CommonInterruptEntry PROC PUBLIC
    76     cli
    77     ;
    78     ; All interrupt handlers are invoked through interrupt gates, so
    79     ; IF flag automatically cleared at the entry point
    80     ;
    81 
    82     ;
    83     ; Calculate vector number
    84     ;
    85     ; Get the return address of call, actually, it is the
    86     ; address of vector number.
    87     ;
    88     xchg    ecx, [esp]
    89     mov     cx, [ecx]
    90     and     ecx, 0FFFFh
    91     cmp     ecx, 32         ; Intel reserved vector for exceptions?
    92     jae     NoErrorCode
    93     bt      mErrorCodeFlag, ecx
    94     jc      HasErrorCode
    95 
    96 NoErrorCode:
    97 
    98     ;
    99     ; Stack:
    100     ; +---------------------+
    101     ; +    EFlags           +
    102     ; +---------------------+
    103     ; +    CS               +
    104     ; +---------------------+
    105     ; +    EIP              +
    106     ; +---------------------+
    107     ; +    ECX              +
    108     ; +---------------------+ <-- ESP
    109     ;
    110     ; Registers:
    111     ;   ECX - Vector Number
    112     ;
    113 
    114     ;
    115     ; Put Vector Number on stack
    116     ;
    117     push    ecx
    118 
    119     ;
    120     ; Put 0 (dummy) error code on stack, and restore ECX
    121     ;
    122     xor     ecx, ecx  ; ECX = 0
    123     xchg    ecx, [esp+4]
    124 
    125     jmp     ErrorCodeAndVectorOnStack
    126 
    127 HasErrorCode:
    128 
    129     ;
    130     ; Stack:
    131     ; +---------------------+
    132     ; +    EFlags           +
    133     ; +---------------------+
    134     ; +    CS               +
    135     ; +---------------------+
    136     ; +    EIP              +
    137     ; +---------------------+
    138     ; +    Error Code       +
    139     ; +---------------------+
    140     ; +    ECX              +
    141     ; +---------------------+ <-- ESP
    142     ;
    143     ; Registers:
    144     ;   ECX - Vector Number
    145     ;
    146 
    147     ;
    148     ; Put Vector Number on stack and restore ECX
    149     ;
    150     xchg    ecx, [esp]
    151 
    152     ;
    153     ; Fall through to join main routine code
    154     ; at ErrorCodeAndVectorOnStack
    155     ;
    156 @@:
    157     jmp @B
    158 
    159 ErrorCodeAndVectorOnStack:
    160     push    ebp
    161     mov     ebp, esp
    162 
    163     ;
    164     ; Stack:
    165     ; +---------------------+
    166     ; +    EFlags           +
    167     ; +---------------------+
    168     ; +    CS               +
    169     ; +---------------------+
    170     ; +    EIP              +
    171     ; +---------------------+
    172     ; +    Error Code       +
    173     ; +---------------------+
    174     ; +    Vector Number    +
    175     ; +---------------------+
    176     ; +    EBP              +
    177     ; +---------------------+ <-- EBP
    178     ;
    179 
    180     ;
    181     ; Align stack to make sure that EFI_FX_SAVE_STATE_IA32 of EFI_SYSTEM_CONTEXT_IA32
    182     ; is 16-byte aligned
    183     ;
    184     and     esp, 0fffffff0h
    185     sub     esp, 12
    186 
    187 ;; UINT32  Edi, Esi, Ebp, Esp, Ebx, Edx, Ecx, Eax;
    188     push    eax
    189     push    ecx
    190     push    edx
    191     push    ebx
    192     lea     ecx, [ebp + 6 * 4]
    193     push    ecx                          ; ESP
    194     push    dword ptr [ebp]              ; EBP
    195     push    esi
    196     push    edi
    197 
    198 ;; UINT32  Gs, Fs, Es, Ds, Cs, Ss;
    199     mov     eax, ss
    200     push    eax
    201     movzx   eax, word ptr [ebp + 4 * 4]
    202     push    eax
    203     mov     eax, ds
    204     push    eax
    205     mov     eax, es
    206     push    eax
    207     mov     eax, fs
    208     push    eax
    209     mov     eax, gs
    210     push    eax
    211 
    212 ;; UINT32  Eip;
    213     mov     eax, [ebp + 3 * 4]
    214     push    eax
    215 
    216 ;; UINT32  Gdtr[2], Idtr[2];
    217     sub     esp, 8
    218     sidt    [esp]
    219     mov     eax, [esp + 2]
    220     xchg    eax, [esp]
    221     and     eax, 0FFFFh
    222     mov     [esp+4], eax
    223 
    224     sub     esp, 8
    225     sgdt    [esp]
    226     mov     eax, [esp + 2]
    227     xchg    eax, [esp]
    228     and     eax, 0FFFFh
    229     mov     [esp+4], eax
    230 
    231 ;; UINT32  Ldtr, Tr;
    232     xor     eax, eax
    233     str     ax
    234     push    eax
    235     sldt    ax
    236     push    eax
    237 
    238 ;; UINT32  EFlags;
    239     mov     eax, [ebp + 5 * 4]
    240     push    eax
    241 
    242 ;; UINT32  Cr0, Cr1, Cr2, Cr3, Cr4;
    243     mov     eax, cr4
    244     or      eax, 208h
    245     mov     cr4, eax
    246     push    eax
    247     mov     eax, cr3
    248     push    eax
    249     mov     eax, cr2
    250     push    eax
    251     xor     eax, eax
    252     push    eax
    253     mov     eax, cr0
    254     push    eax
    255 
    256 ;; UINT32  Dr0, Dr1, Dr2, Dr3, Dr6, Dr7;
    257     mov     eax, dr7
    258     push    eax
    259     mov     eax, dr6
    260     push    eax
    261     mov     eax, dr3
    262     push    eax
    263     mov     eax, dr2
    264     push    eax
    265     mov     eax, dr1
    266     push    eax
    267     mov     eax, dr0
    268     push    eax
    269 
    270 ;; FX_SAVE_STATE_IA32 FxSaveState;
    271     sub     esp, 512
    272     mov     edi, esp
    273     db      0fh, 0aeh, 07h ;fxsave [edi]
    274 
    275 ;; UEFI calling convention for IA32 requires that Direction flag in EFLAGs is clear
    276     cld
    277 
    278 ;; UINT32  ExceptionData;
    279     push    dword ptr [ebp + 2 * 4]
    280 
    281 ;; call into exception handler
    282     mov     eax, ExternalVectorTablePtr  ; get the interrupt vectors base
    283     or      eax, eax                        ; NULL?
    284     jz      nullExternalExceptionHandler
    285 
    286     mov     ecx, [ebp + 4]
    287     mov     eax, [eax + ecx * 4]
    288     or      eax, eax                        ; NULL?
    289     jz      nullExternalExceptionHandler
    290 
    291 ;; Prepare parameter and call
    292     mov     edx, esp
    293     push    edx
    294     mov     edx, dword ptr [ebp + 1 * 4]
    295     push    edx
    296 
    297     ;
    298     ; Call External Exception Handler
    299     ;
    300     call    eax
    301     add     esp, 8
    302 
    303 nullExternalExceptionHandler:
    304 
    305     cli
    306 ;; UINT32  ExceptionData;
    307     add     esp, 4
    308 
    309 ;; FX_SAVE_STATE_IA32 FxSaveState;
    310     mov     esi, esp
    311     db      0fh, 0aeh, 0eh ; fxrstor [esi]
    312     add     esp, 512
    313 
    314 ;; UINT32  Dr0, Dr1, Dr2, Dr3, Dr6, Dr7;
    315 ;; Skip restoration of DRx registers to support in-circuit emualators
    316 ;; or debuggers set breakpoint in interrupt/exception context
    317     add     esp, 4 * 6
    318 
    319 ;; UINT32  Cr0, Cr1, Cr2, Cr3, Cr4;
    320     pop     eax
    321     mov     cr0, eax
    322     add     esp, 4    ; not for Cr1
    323     pop     eax
    324     mov     cr2, eax
    325     pop     eax
    326     mov     cr3, eax
    327     pop     eax
    328     mov     cr4, eax
    329 
    330 ;; UINT32  EFlags;
    331     pop     dword ptr [ebp + 5 * 4]
    332 
    333 ;; UINT32  Ldtr, Tr;
    334 ;; UINT32  Gdtr[2], Idtr[2];
    335 ;; Best not let anyone mess with these particular registers...
    336     add     esp, 24
    337 
    338 ;; UINT32  Eip;
    339     pop     dword ptr [ebp + 3 * 4]
    340 
    341 ;; UINT32  Gs, Fs, Es, Ds, Cs, Ss;
    342 ;; NOTE - modified segment registers could hang the debugger...  We
    343 ;;        could attempt to insulate ourselves against this possibility,
    344 ;;        but that poses risks as well.
    345 ;;
    346     pop     gs
    347     pop     fs
    348     pop     es
    349     pop     ds
    350     pop     dword ptr [ebp + 4 * 4]
    351     pop     ss
    352 
    353 ;; UINT32  Edi, Esi, Ebp, Esp, Ebx, Edx, Ecx, Eax;
    354     pop     edi
    355     pop     esi
    356     add     esp, 4   ; not for ebp
    357     add     esp, 4   ; not for esp
    358     pop     ebx
    359     pop     edx
    360     pop     ecx
    361     pop     eax
    362 
    363     mov     esp, ebp
    364     pop     ebp
    365     add     esp, 8
    366     iretd
    367 
    368 CommonInterruptEntry ENDP
    36957
    37058END
Note: See TracChangeset for help on using the changeset viewer.

© 2024 Oracle Support Privacy / Do Not Sell My Info Terms of Use Trademark Policy Automated Access Etiquette