You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
250 lines
6.7 KiB
250 lines
6.7 KiB
/*
|
|
* Copyright 2002-2019 Intel Corporation.
|
|
*
|
|
* This software is provided to you as Sample Source Code as defined in the accompanying
|
|
* End User License Agreement for the Intel(R) Software Development Products ("Agreement")
|
|
* section 1.L.
|
|
*
|
|
* This software and the related documents are provided as is, with no express or implied
|
|
* warranties, other than those that are expressly stated in the License.
|
|
*/
|
|
|
|
# Add enter and leave as well, just for amusement
|
|
|
|
farret:
|
|
enter $32,$0
|
|
mov $5, %eax
|
|
leave
|
|
lret
|
|
|
|
.type FarCallTest, @function
|
|
.global FarCallTest
|
|
FarCallTest:
|
|
push %cs
|
|
call farret
|
|
ret
|
|
|
|
#
|
|
# Expose the MaskMovQ instruction
|
|
# MaskMovQ(char *dest, UINT64 src, UINT64 mask)
|
|
.type MaskMovQ, @function
|
|
.global MaskMovQ
|
|
MaskMovQ:
|
|
mov 4(%esp),%edi
|
|
movq 8(%esp),%mm1
|
|
movq 16(%esp),%mm0
|
|
maskmovq %mm0,%mm1
|
|
ret
|
|
|
|
#
|
|
# Some unlikely (but legal) push and pop instructions
|
|
# VOID * pushEsp(VOID * stack)
|
|
#
|
|
.type pushESP, @function
|
|
.global pushESP
|
|
pushESP:
|
|
mov %esp, %ecx # Save esp
|
|
mov 4(%esp),%esp
|
|
push %esp # Do the op
|
|
mov %esp, %eax # Result
|
|
mov %ecx, %esp # Stack with return address
|
|
ret
|
|
|
|
#
|
|
# VOID * popESP(VOID * stack)
|
|
#
|
|
.type popESP, @function
|
|
.global popESP
|
|
popESP:
|
|
mov %esp, %ecx # Save esp
|
|
mov 4(%esp),%esp # stack to play with
|
|
pop %esp # Do the op
|
|
mov %esp, %eax # Result
|
|
mov %ecx, %esp # Stack with return address
|
|
ret
|
|
#
|
|
# VOID * pushStarESP(VOID * stack)
|
|
#
|
|
.type pushStarESP, @function
|
|
.global pushStarESP
|
|
pushStarESP:
|
|
mov %esp, %ecx # Save esp
|
|
mov 4(%esp),%esp # stack to play with
|
|
push (%esp) # Do the op
|
|
mov %esp, %eax # Result
|
|
mov %ecx, %esp # Stack with return address
|
|
ret
|
|
|
|
#
|
|
# VOID * push4ESP(VOID * stack)
|
|
#
|
|
.type push4ESP, @function
|
|
.global push4ESP
|
|
push4ESP:
|
|
mov %esp, %ecx # Save esp
|
|
mov 4(%esp),%esp # stack to play with
|
|
push 4(%esp) # Do the op
|
|
mov %esp, %eax # Result
|
|
mov %ecx, %esp # Stack with return address
|
|
ret
|
|
|
|
#
|
|
# VOID * popStarESP(VOID * stack)
|
|
#
|
|
.type popStarESP, @function
|
|
.global popStarESP
|
|
popStarESP:
|
|
mov %esp, %ecx # Save esp
|
|
mov 4(%esp),%esp # stack to play with
|
|
pop (%esp) # Do the op
|
|
mov %esp, %eax # Result
|
|
mov %ecx, %esp # Stack with return address
|
|
ret
|
|
|
|
#
|
|
# VOID * pop4ESP(VOID * stack)
|
|
#
|
|
.type pop4ESP, @function
|
|
.global pop4ESP
|
|
pop4ESP:
|
|
mov %esp, %ecx # Save esp
|
|
mov 4(%esp),%esp # stack to play with
|
|
pop 4(%esp) # Do the op
|
|
mov %esp, %eax # Result
|
|
mov %ecx, %esp # Stack with return address
|
|
ret
|
|
|
|
#
|
|
# VOID * pushFlags(VOID * stack)
|
|
#
|
|
# This actually forces the flags first, and then pushes them
|
|
.type pushFlags, @function
|
|
.global pushFlags
|
|
pushFlags:
|
|
mov %esp, %ecx # Save esp
|
|
pushl $0x282 # Force flags
|
|
popf #
|
|
mov 4(%esp),%esp # stack to play with
|
|
pushf # Do the op
|
|
mov %esp, %eax # Result
|
|
mov %ecx, %esp # Stack with return address
|
|
ret
|
|
|
|
#
|
|
# VOID * pushIZero(VOID * stack)
|
|
# Push an immediate zero
|
|
.type pushIZero, @function
|
|
.global pushIZero
|
|
pushIZero:
|
|
mov %esp, %ecx # Save esp
|
|
mov 4(%esp),%esp # stack to play with
|
|
pushl $0 # Do the op
|
|
mov %esp, %eax # Result
|
|
mov %ecx, %esp # Stack with return address
|
|
ret
|
|
|
|
#
|
|
# VOID * pushWIZero(VOID * stack)
|
|
# Push an immediate zero
|
|
.type pushWIZero, @function
|
|
.global pushWIZero
|
|
pushWIZero:
|
|
mov %esp, %ecx # Save esp
|
|
mov 4(%esp),%esp # stack to play with
|
|
pushw $0 # Do the op
|
|
mov %esp, %eax # Result
|
|
mov %ecx, %esp # Stack with return address
|
|
ret
|
|
|
|
#
|
|
# VOID * pushIM1(VOID * stack)
|
|
# Push an immediate minus -1 (one byte sign extended...)
|
|
.type pushIM1, @function
|
|
.global pushIM1
|
|
pushIM1:
|
|
mov %esp, %ecx # Save esp
|
|
mov 4(%esp),%esp # stack to play with
|
|
pushl $-1 # Do the op
|
|
mov %esp, %eax # Result
|
|
mov %ecx, %esp # Stack with return address
|
|
ret
|
|
|
|
#
|
|
# VOID * pushIs16(VOID * stack)
|
|
# Push an immediate which fits in 16 (sign extended) bits
|
|
# (though the assembler leaves it as 32 bits).
|
|
.type pushIs16, @function
|
|
.global pushIs16
|
|
pushIs16:
|
|
mov %esp, %ecx # Save esp
|
|
mov 4(%esp),%esp # stack to play with
|
|
pushl $-32768 # Do the op
|
|
mov %esp, %eax # Result
|
|
mov %ecx, %esp # Stack with return address
|
|
ret
|
|
|
|
#
|
|
# VOID * pushMemAbs(VOID * stack)
|
|
# Push data from an absolute address
|
|
.data
|
|
value: .long 0x01234567
|
|
.text
|
|
.type pushMemAbs, @function
|
|
.global pushMemAbs
|
|
pushMemAbs:
|
|
mov %esp, %ecx # Save esp
|
|
mov 4(%esp),%esp # stack to play with
|
|
pushl value # Do the op
|
|
mov %esp, %eax # Result
|
|
mov %ecx, %esp # Stack with return address
|
|
ret
|
|
|
|
#
|
|
# VOID * pushCS(VOID * stack)
|
|
# Push CS
|
|
.text
|
|
.type pushCS, @function
|
|
.global pushCS
|
|
pushCS:
|
|
mov %esp, %ecx # Save esp
|
|
mov 4(%esp),%esp # stack to play with
|
|
pushl %cs # Do the op
|
|
mov %esp, %eax # Result
|
|
mov %ecx, %esp # Stack with return address
|
|
ret
|
|
|
|
#
|
|
# UINT16 readCS()
|
|
# Return the value of %cs
|
|
.text
|
|
.type readCS, @function
|
|
.global readCS
|
|
readCS:
|
|
mov %cs, %eax
|
|
ret
|
|
|
|
#
|
|
# VOID * pushFS(VOID * stack)
|
|
# Push FS
|
|
.text
|
|
.type pushFS, @function
|
|
.global pushFS
|
|
pushFS:
|
|
mov %esp, %ecx # Save esp
|
|
mov 4(%esp),%esp # stack to play with
|
|
pushl %fs # Do the op
|
|
mov %esp, %eax # Result
|
|
mov %ecx, %esp # Stack with return address
|
|
ret
|
|
|
|
#
|
|
# UINT16 readFS()
|
|
# Return the value of %fs
|
|
.text
|
|
.type readFS, @function
|
|
.global readFS
|
|
readFS:
|
|
mov %fs, %eax
|
|
ret
|
|
|