tyler.durden/audk
1
0
Fork 0
mirror of https://github.com/acidanthera/audk.git synced 2025-07-22 21:24:35 +02:00
Code Issues Packages Projects Releases Wiki Activity

Remove ".intel_syntax", convert MASM to GAS.

Browse Source 
git-svn-id: https://edk2.svn.sourceforge.net/svnroot/edk2/trunk/edk2@9079 6f19259b-4bc3-4df7-8a09-765794883524
This commit is contained in:
gikidy 2009-08-17 05:39:17 +00:00
parent b13151ffb6
commit 3668c083cd
2 changed files with 172 additions and 177 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

1
UefiCpuPkg/CpuDxe/Ia32/IvtAsm.S
View File

@ -24,7 +24,6 @@
# #
.macro SingleIdtVectorMacro vectorNum .macro SingleIdtVectorMacro vectorNum
.intel_syntax
call ASM_PFX(CommonInterruptEntry) call ASM_PFX(CommonInterruptEntry)
.short \vectorNum .short \vectorNum
nop nop

348
UefiCpuPkg/CpuDxe/X64/CpuAsm.S
View File

@ -1,4 +1,4 @@
# TITLE CpuAsm.asm: # TITLE CpuAsm.S:
#------------------------------------------------------------------------------ #------------------------------------------------------------------------------
#* #*
@ -30,11 +30,10 @@
ExternalVectorTablePtr: ExternalVectorTablePtr:
.byte 0, 0, 0, 0, 0, 0, 0, 0 .byte 0, 0, 0, 0, 0, 0, 0, 0
.intel_syntax
ASM_GLOBAL ASM_PFX(InitializeExternalVectorTablePtr) ASM_GLOBAL ASM_PFX(InitializeExternalVectorTablePtr)
ASM_PFX(InitializeExternalVectorTablePtr): ASM_PFX(InitializeExternalVectorTablePtr):
lea %rax, [%rip+ExternalVectorTablePtr] # save vector number lea ExternalVectorTablePtr(%rip), %rax # save vector number
mov [%rax], %rcx mov %rcx, (%rax)
ret ret
@ -44,16 +43,15 @@ ASM_PFX(InitializeExternalVectorTablePtr):
# UINT16 Selector # UINT16 Selector
# ); # );
#------------------------------------------------------------------------------ #------------------------------------------------------------------------------
.intel_syntax
ASM_GLOBAL ASM_PFX(SetCodeSelector) ASM_GLOBAL ASM_PFX(SetCodeSelector)
ASM_PFX(SetCodeSelector): ASM_PFX(SetCodeSelector):
sub %rsp, 0x10 subq $0x10, %rsp
lea %rax, [%rip+setCodeSelectorLongJump] leaq setCodeSelectorLongJump(%rip), %rax
mov [%rsp], %rax movq %rax, (%rsp)
mov [%rsp+4], %cx movw %cx, 4(%rsp)
jmp fword ptr [%rsp] .byte 0xFF, 0x2C, 0x24 # jmp (%rsp) note:fword jmp
setCodeSelectorLongJump: setCodeSelectorLongJump:
add %rsp, 0x10 addq $0x10, %rsp
ret ret
#------------------------------------------------------------------------------ #------------------------------------------------------------------------------
@ -62,14 +60,13 @@ setCodeSelectorLongJump:
# UINT16 Selector # UINT16 Selector
# ); # );
#------------------------------------------------------------------------------ #------------------------------------------------------------------------------
.intel_syntax
ASM_GLOBAL ASM_PFX(SetDataSelectors) ASM_GLOBAL ASM_PFX(SetDataSelectors)
ASM_PFX(SetDataSelectors): ASM_PFX(SetDataSelectors):
mov %ss, %cx movw %cx, %ss
mov %ds, %cx movw %cx, %ds
mov %es, %cx movw %cx, %es
mov %fs, %cx movw %cx, %fs
mov %gs, %cx movw %cx, %gs
ret ret
#---------------------------------------; #---------------------------------------;
@ -77,7 +74,6 @@ ASM_PFX(SetDataSelectors):
#---------------------------------------; #---------------------------------------;
# The follow algorithm is used for the common interrupt routine. # The follow algorithm is used for the common interrupt routine.
.intel_syntax
ASM_GLOBAL ASM_PFX(CommonInterruptEntry) ASM_GLOBAL ASM_PFX(CommonInterruptEntry)
ASM_PFX(CommonInterruptEntry): ASM_PFX(CommonInterruptEntry):
cli cli
@ -88,14 +84,14 @@ ASM_PFX(CommonInterruptEntry):
# #
# Calculate vector number # Calculate vector number
# #
xchg %rcx, [%rsp] # get the return address of call, actually, it is the address of vector number. xchgq (%rsp), %rcx # get the return address of call, actually, it is the address of vector number.
movzx %ecx, word ptr [%rcx] movzwl (%rcx), %ecx
cmp %ecx, 32 # Intel reserved vector for exceptions? cmp $32, %ecx # Intel reserved vector for exceptions?
jae NoErrorCode jae NoErrorCode
push %rax pushq %rax
lea %rax, [%rip+ASM_PFX(mErrorCodeFlag)] leaq ASM_PFX(mErrorCodeFlag)(%rip), %rax
bt dword ptr [%rax], %ecx bt %ecx, (%rax)
pop %rax popq %rax
jc CommonInterruptEntry_al_0000 jc CommonInterruptEntry_al_0000
NoErrorCode: NoErrorCode:
@ -104,11 +100,11 @@ NoErrorCode:
# Push a dummy error code on the stack # Push a dummy error code on the stack
# to maintain coherent stack map # to maintain coherent stack map
# #
push [%rsp] pushq (%rsp)
mov qword ptr [%rsp + 8], 0 movq $0, 8(%rsp)
CommonInterruptEntry_al_0000: CommonInterruptEntry_al_0000:
push %rbp pushq %rbp
mov %rbp, %rsp movq %rsp, %rbp
# #
# Stack: # Stack:
@ -140,219 +136,219 @@ CommonInterruptEntry_al_0000:
#; UINT64 Rdi, Rsi, Rbp, Rsp, Rbx, Rdx, Rcx, Rax; #; UINT64 Rdi, Rsi, Rbp, Rsp, Rbx, Rdx, Rcx, Rax;
#; UINT64 R8, R9, R10, R11, R12, R13, R14, R15; #; UINT64 R8, R9, R10, R11, R12, R13, R14, R15;
push %r15 pushq %r15
push %r14 pushq %r14
push %r13 pushq %r13
push %r12 pushq %r12
push %r11 pushq %r11
push %r10 pushq %r10
push %r9 pushq %r9
push %r8 pushq %r8
push %rax pushq %rax
push qword ptr [%rbp + 8] # RCX pushq 8(%rbp) # RCX
push %rdx pushq %rdx
push %rbx pushq %rbx
push qword ptr [%rbp + 48] # RSP pushq 48(%rbp) # RSP
push qword ptr [%rbp] # RBP pushq (%rbp) # RBP
push %rsi pushq %rsi
push %rdi pushq %rdi
#; UINT64 Gs, Fs, Es, Ds, Cs, Ss; insure high 16 bits of each is zero #; UINT64 Gs, Fs, Es, Ds, Cs, Ss; insure high 16 bits of each is zero
movzx %rax, word ptr [%rbp + 56] movzwq 56(%rbp), %rax
push %rax # for ss pushq %rax # for ss
movzx %rax, word ptr [%rbp + 32] movzwq 32(%rbp), %rax
push %rax # for cs pushq %rax # for cs
mov %rax, %ds movq %ds, %rax
push %rax pushq %rax
mov %rax, %es movq %es, %rax
push %rax pushq %rax
mov %rax, %fs movq %fs, %rax
push %rax pushq %rax
mov %rax, %gs movq %gs, %rax
push %rax pushq %rax
mov [%rbp + 8], %rcx # save vector number movq %rcx, 8(%rbp) # save vector number
#; UINT64 Rip; #; UINT64 Rip;
push qword ptr [%rbp + 24] pushq 24(%rbp)
#; UINT64 Gdtr[2], Idtr[2]; #; UINT64 Gdtr[2], Idtr[2];
xor %rax, %rax xorq %rax, %rax
push %rax pushq %rax
push %rax pushq %rax
sidt [%rsp] sidt (%rsp)
xchg %rax, [%rsp + 2] xchgq 2(%rsp), %rax
xchg %rax, [%rsp] xchgq (%rsp), %rax
xchg %rax, [%rsp + 8] xchgq 8(%rsp), %rax
xor %rax, %rax xorq %rax, %rax
push %rax pushq %rax
push %rax pushq %rax
sgdt [%rsp] sgdt (%rsp)
xchg %rax, [%rsp + 2] xchgq 2(%rsp), %rax
xchg %rax, [%rsp] xchgq (%rsp), %rax
xchg %rax, [%rsp + 8] xchgq 8(%rsp), %rax
#; UINT64 Ldtr, Tr; #; UINT64 Ldtr, Tr;
xor %rax, %rax xorq %rax, %rax
str %ax str %ax
push %rax pushq %rax
sldt %ax sldt %ax
push %rax pushq %rax
#; UINT64 RFlags; #; UINT64 RFlags;
push qword ptr [%rbp + 40] pushq 40(%rbp)
#; UINT64 Cr0, Cr1, Cr2, Cr3, Cr4, Cr8; #; UINT64 Cr0, Cr1, Cr2, Cr3, Cr4, Cr8;
mov %rax, %cr8 movq %cr8, %rax
push %rax pushq %rax
mov %rax, %cr4 movq %cr4, %rax
or %rax, 0x208 orq $0x208, %rax
mov %cr4, %rax movq %rax, %cr4
push %rax pushq %rax
mov %rax, %cr3 mov %cr3, %rax
push %rax pushq %rax
mov %rax, %cr2 mov %cr2, %rax
push %rax pushq %rax
xor %rax, %rax xorq %rax, %rax
push %rax pushq %rax
mov %rax, %cr0 mov %cr0, %rax
push %rax pushq %rax
#; UINT64 Dr0, Dr1, Dr2, Dr3, Dr6, Dr7; #; UINT64 Dr0, Dr1, Dr2, Dr3, Dr6, Dr7;
mov %rax, %dr7 movq %dr7, %rax
push %rax pushq %rax
#; clear Dr7 while executing debugger itself #; clear Dr7 while executing debugger itself
xor %rax, %rax xorq %rax, %rax
mov %dr7, %rax movq %rax, %dr7
mov %rax, %dr6 movq %dr6, %rax
push %rax pushq %rax
#; insure all status bits in dr6 are clear... #; insure all status bits in dr6 are clear...
xor %rax, %rax xorq %rax, %rax
mov %dr6, %rax movq %rax, %dr6
mov %rax, %dr3 movq %dr3, %rax
push %rax pushq %rax
mov %rax, %dr2 movq %dr2, %rax
push %rax pushq %rax
mov %rax, %dr1 movq %dr1, %rax
push %rax pushq %rax
mov %rax, %dr0 movq %dr0, %rax
push %rax pushq %rax
#; FX_SAVE_STATE_X64 FxSaveState; #; FX_SAVE_STATE_X64 FxSaveState;
sub %rsp, 512 subq $512, %rsp
mov %rdi, %rsp movq %rsp, %rdi
.byte 0x0f, 0x0ae, 0x07 #fxsave [rdi] .byte 0x0f, 0x0ae, 0x07 #fxsave [rdi]
#; UINT32 ExceptionData; #; UINT32 ExceptionData;
push qword ptr [%rbp + 16] pushq 16(%rbp)
#; call into exception handler #; call into exception handler
mov %rcx, [%rbp + 8] movq 8(%rbp), %rcx
lea %rax, [%rip+ExternalVectorTablePtr] leaq ExternalVectorTablePtr(%rip), %rax
mov %eax, [%eax] movl (%eax), %eax
mov %rax, [%rax + %rcx * 8] movq (%rax,%rcx,8), %rax
or %rax, %rax # NULL? orq %rax, %rax # NULL?
je nonNullValue# je nonNullValue#
#; Prepare parameter and call #; Prepare parameter and call
# mov rcx, [rbp + 8] # mov rcx, [rbp + 8]
mov %rdx, %rsp mov %rsp, %rdx
# #
# Per X64 calling convention, allocate maximum parameter stack space # Per X64 calling convention, allocate maximum parameter stack space
# and make sure RSP is 16-byte aligned # and make sure RSP is 16-byte aligned
# #
sub %rsp, 4 * 8 + 8 subq $40, %rsp
call %rax call *%rax
add %rsp, 4 * 8 + 8 addq $40, %rsp
nonNullValue: nonNullValue:
cli cli
#; UINT64 ExceptionData; #; UINT64 ExceptionData;
add %rsp, 8 addq $8, %rsp
#; FX_SAVE_STATE_X64 FxSaveState; #; FX_SAVE_STATE_X64 FxSaveState;
mov %rsi, %rsp movq %rsp, %rsi
.byte 0x0f, 0x0ae, 0x0E # fxrstor [rsi] .byte 0x0f, 0x0ae, 0x0E # fxrstor [rsi]
add %rsp, 512 addq $512, %rsp
#; UINT64 Dr0, Dr1, Dr2, Dr3, Dr6, Dr7; #; UINT64 Dr0, Dr1, Dr2, Dr3, Dr6, Dr7;
pop %rax popq %rax
mov %dr0, %rax movq %rax, %dr0
pop %rax popq %rax
mov %dr1, %rax movq %rax, %dr1
pop %rax popq %rax
mov %dr2, %rax movq %rax, %dr2
pop %rax popq %rax
mov %dr3, %rax movq %rax, %dr3
#; skip restore of dr6. We cleared dr6 during the context save. #; skip restore of dr6. We cleared dr6 during the context save.
add %rsp, 8 addq $8, %rsp
pop %rax popq %rax
mov %dr7, %rax movq %rax, %dr7
#; UINT64 Cr0, Cr1, Cr2, Cr3, Cr4, Cr8; #; UINT64 Cr0, Cr1, Cr2, Cr3, Cr4, Cr8;
pop %rax popq %rax
mov %cr0, %rax movq %rax, %cr0
add %rsp, 8 # not for Cr1 addq $8, %rsp # not for Cr1
pop %rax popq %rax
mov %cr2, %rax movq %rax, %cr2
pop %rax popq %rax
mov %cr3, %rax movq %rax, %cr3
pop %rax popq %rax
mov %cr4, %rax movq %rax, %cr4
pop %rax popq %rax
mov %cr8, %rax movq %rax, %cr8
#; UINT64 RFlags; #; UINT64 RFlags;
pop qword ptr [%rbp + 40] popq 40(%rbp)
#; UINT64 Ldtr, Tr; #; UINT64 Ldtr, Tr;
#; UINT64 Gdtr[2], Idtr[2]; #; UINT64 Gdtr[2], Idtr[2];
#; Best not let anyone mess with these particular registers... #; Best not let anyone mess with these particular registers...
add %rsp, 48 addq $48, %rsp
#; UINT64 Rip; #; UINT64 Rip;
pop qword ptr [%rbp + 24] popq 24(%rbp)
#; UINT64 Gs, Fs, Es, Ds, Cs, Ss; #; UINT64 Gs, Fs, Es, Ds, Cs, Ss;
pop %rax popq %rax
# mov gs, rax ; not for gs # mov %rax, %gs ; not for gs
pop %rax popq %rax
# mov fs, rax ; not for fs # mov %rax, %fs ; not for fs
# (X64 will not use fs and gs, so we do not restore it) # (X64 will not use fs and gs, so we do not restore it)
pop %rax popq %rax
mov %es, %rax movq %rax, %es
pop %rax popq %rax
mov %ds, %rax movq %rax, %ds
pop qword ptr [%rbp + 32] # for cs popq 32(%rbp) # for cs
pop qword ptr [%rbp + 56] # for ss popq 56(%rbp) # for ss
#; UINT64 Rdi, Rsi, Rbp, Rsp, Rbx, Rdx, Rcx, Rax; #; UINT64 Rdi, Rsi, Rbp, Rsp, Rbx, Rdx, Rcx, Rax;
#; UINT64 R8, R9, R10, R11, R12, R13, R14, R15; #; UINT64 R8, R9, R10, R11, R12, R13, R14, R15;
pop %rdi popq %rdi
pop %rsi popq %rsi
add %rsp, 8 # not for rbp addq $8, %rsp # not for rbp
pop qword ptr [%rbp + 48] # for rsp popq 48(%rbp) # for rsp
pop %rbx popq %rbx
pop %rdx popq %rdx
pop %rcx popq %rcx
pop %rax popq %rax
pop %r8 popq %r8
pop %r9 popq %r9
pop %r10 popq %r10
pop %r11 popq %r11
pop %r12 popq %r12
pop %r13 popq %r13
pop %r14 popq %r14
pop %r15 popq %r15
mov %rsp, %rbp movq %rbp, %rsp
pop %rbp popq %rbp
add %rsp, 16 addq $16, %rsp
iretq iretq