#
# rep, repe (repz) and repne (repnz) prefixed string instructions
# only count as one instruction, even though they repeat many times
# This test makes sure the bbv plugin counts these instructions properly
# The answer is validated to hw perf counters.
#
.globl _start
_start:
cld # we want these to happen forward
#===============================================
# Some SSE2 instructions start with 0xf2 or 0xf3
# Check for them, to make sure our rep detection
# handles things properly.
# We should check this on x86 too, but then we'd
# have to check for SSE2 capability somehow?
#===================================
false_positives:
movdqu %xmm1,%xmm2
movdqu %xmm2,%xmm1
addsd %xmm1,%xmm2
pause
#===================================
# Check varied order of the size prefix
# with the rep prefix. Older binutils
# did this one way, newer binutils the other
#===================================
size_prefix:
# test 16-bit load
mov $8192, %rcx
mov $buffer1, %rsi # set source
.byte 0x66, 0xf3, 0xad # lodsw
mov $8192, %rcx
mov $buffer1, %rsi # set source
.byte 0xf3, 0x66, 0xad # lodsw
#===================================
# Load and Store Instructions
#===================================
loadstore:
xor %rax, %rax
mov $0xd, %al # set eax to d
# test 8-bit store
mov $16384, %rcx
mov $buffer1, %rdi # set destination
rep stosb # store d 16384 times, auto-increment
# test 8-bit load
mov $16384, %rcx
mov $buffer1, %rsi # set source
rep lodsb # load byte 16384 times, auto-increment
cmp $0xd,%al # if we loaded wrong value
jne print_error # print an error
# test 16-bit store
mov $0x020d,%ax # store 0x020d
mov $8192, %rcx
mov $buffer1, %rdi # set destination
rep stosw # store 8192 times, auto-increment
# test 16-bit load
mov $8192, %rcx
mov $buffer1, %rsi # set source
rep lodsw # load 8192 times, auto-increment
cmp $0x020d,%ax # if we loaded wrong value
jne print_error # print an error
# test 32-bit store
mov $0x0feb1378,%eax # store 0x0feb1378
mov $4096, %rcx
mov $buffer1, %rdi # set destination
rep stosl # store 4096 times, auto-increment
# test 32-bit load
mov $4096, %rcx
mov $buffer1, %rsi # set source
rep lodsl # load 4096 times, auto-increment
cmp $0x0feb1378,%eax # if we loaded wrong value
jne print_error # print an error
# test 64-bit store
mov $0xfeb131978a5a5a5a,%rax
mov $2048, %rcx
mov $buffer1, %rdi # set destination
rep stosq # store 2048 times, auto-increment
# test 64-bit load
mov $2048, %rcx
mov $buffer1, %rsi # set source
rep lodsq # load 2048 times, auto-increment
cmp $0x8a5a5a5a,%eax
# !if we loaded wrong value
jne print_error # print an error
#=============================
# Move instructions
#=============================
moves:
# test 8-bit move
mov $16384, %rcx
mov $buffer1, %rsi
mov $buffer2, %rdi
rep movsb
# test 16-bit move
mov $8192, %rcx
mov $buffer2, %rsi
mov $buffer1, %rdi
rep movsw
# test 32-bit move
mov $4096, %rcx
mov $buffer1, %rsi
mov $buffer2, %rdi
rep movsl
# test 64-bit move
mov $2048, %rcx
mov $buffer1, %rsi
mov $buffer2, %rdi
rep movsq
#==================================
# Compare equal instructions
#==================================
compare_equal:
# first set up the areas to compare
mov $0xa5a5a5a5,%eax
mov $buffer1, %rdi
mov $4096, %rcx
rep stosl
mov $0xa5a5a5a5,%eax
mov $buffer2, %rdi
mov $4096, %rcx
rep stosl
# test 8-bit
mov $buffer1,%rsi
mov $buffer2,%rdi
mov $16384, %rcx
repe cmpsb
jnz print_error
# test 16-bit
mov $buffer1,%rsi
mov $buffer2,%rdi
mov $8192, %rcx
repe cmpsw
jnz print_error
# test 32-bit
mov $buffer1,%rsi
mov $buffer2,%rdi
mov $4096, %rcx
repe cmpsl
jnz print_error
# test 64-bit
mov $buffer1,%rsi
mov $buffer2,%rdi
mov $2048, %rcx
repe cmpsq
jnz print_error
#==================================
# Compare not equal instructions
#==================================
compare_noteq:
# change second buffer
mov $0x5a5a5a5a,%eax
mov $buffer2, %rdi
mov $4096, %rcx
rep stosl
# test 8-bit
mov $buffer1,%rsi
mov $buffer2,%rdi
mov $16384, %rcx
# repne cmpsb FIXME! Not implemented valgrind
# je print_error
# test 16-bit
mov $buffer1,%rsi
mov $buffer2,%rdi
mov $8192, %rcx
# repne cmpsw FIXME! Not implemented valgrind
# je print_error
# test 32-bit
mov $buffer1,%rsi
mov $buffer2,%rdi
mov $4096, %rcx
# repne cmpsl FIXME! Not implemented valgrind
# je print_error
# test 64-bit
mov $buffer1,%rsi
mov $buffer2,%rdi
mov $2048, %rcx
# repne cmpsq FIXME! Not implemented valgrind
# je print_error
#====================================
# Check scan equal instruction
#====================================
scan_eq:
# test 8-bit
mov $0xa5,%al
mov $buffer1,%rdi
mov $16384, %rcx
repe scasb
jnz print_error
# test 16-bit
mov $0xa5a5,%ax
mov $buffer1,%rdi
mov $8192, %rcx
repe scasw
jnz print_error
# test 32-bit
mov $0xa5a5a5a5,%eax
mov $buffer1,%rdi
mov $4096, %rcx
repe scasl
jnz print_error
# test 64-bit
mov $0xa5a5a5a5a5a5a5a5,%rax
mov $buffer1,%rdi
mov $2048, %rcx
repe scasq
jnz print_error
#====================================
# Check scan not-equal instruction
#====================================
# test 8-bit
scan_ne:
mov $0xa5,%al
mov $buffer2,%rdi
mov $16384, %rcx
repne scasb
jz print_error
# test 16-bit
mov $0xa5a5,%ax
mov $buffer2,%rdi
mov $8192, %rcx
repne scasw
jz print_error
# test 32-bit
mov $0xa5a5a5a5,%eax
mov $buffer2,%rdi
mov $4096, %rcx
repne scasl
jz print_error
# test 64-bit
mov $0xa5a5a5a5a5a5a5a5,%rax
mov $buffer2,%rdi
mov $2048, %rcx
repne scasq
jz print_error
jmp exit # no error, skip to exit
print_error:
mov $1, %rax # Write syscall
mov $1, %rdi # print to stdout
mov $error_string, %rsi # string to print
mov $16, %edx # strlen
syscall # call syscall
#================================
# Exit
#================================
exit:
mov $60,%rax
xor %rdi,%rdi # we return 0
syscall # and exit
.data
error_string: .asciz "Error detected!\n"
.bss
.lcomm buffer1, 16384
.lcomm buffer2, 16384