/*--------------------------------------------------------------------*/
/*--- Trampoline code page stuff. m_trampoline.S ---*/
/*--------------------------------------------------------------------*/
/*
This file is part of Valgrind, a dynamic binary instrumentation
framework.
Copyright (C) 2000-2015 Julian Seward
jseward@acm.org
Copyright (C) 2006-2015 OpenWorks LLP
info@open-works.co.uk
This program is free software; you can redistribute it and/or
modify it under the terms of the GNU General Public License as
published by the Free Software Foundation; either version 2 of the
License, or (at your option) any later version.
This program is distributed in the hope that it will be useful, but
WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program; if not, write to the Free Software
Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA
02111-1307, USA.
The GNU General Public License is contained in the file COPYING.
*/
#include "pub_core_basics_asm.h"
#include "pub_core_vkiscnums_asm.h"
/* ------------------ SIMULATED CPU HELPERS ------------------ */
/*
Replacements for some functions to do with vsyscalls and signals.
This code runs on the simulated CPU.
*/
/*---------------------- x86-linux ----------------------*/
#if defined(VGP_x86_linux)
# define UD2_16 ud2 ; ud2 ; ud2 ; ud2 ;ud2 ; ud2 ; ud2 ; ud2
# define UD2_64 UD2_16 ; UD2_16 ; UD2_16 ; UD2_16
# define UD2_256 UD2_64 ; UD2_64 ; UD2_64 ; UD2_64
# define UD2_1024 UD2_256 ; UD2_256 ; UD2_256 ; UD2_256
# define UD2_PAGE UD2_1024 ; UD2_1024 ; UD2_1024 ; UD2_1024
/* a leading page of unexecutable code */
UD2_PAGE
.global VG_(trampoline_stuff_start)
VG_(trampoline_stuff_start):
.global VG_(x86_linux_SUBST_FOR_sigreturn)
VG_(x86_linux_SUBST_FOR_sigreturn):
/* This is a very specific sequence which GDB uses to
recognize signal handler frames. Also gcc: see
x86_fallback_frame_state() in
gcc-4.1.0/gcc/config/i386/linux-unwind.h */
popl %eax
movl $ __NR_sigreturn, %eax
int $0x80
ud2
.global VG_(x86_linux_SUBST_FOR_rt_sigreturn)
VG_(x86_linux_SUBST_FOR_rt_sigreturn):
/* Likewise for rt signal frames */
movl $ __NR_rt_sigreturn, %eax
int $0x80
ud2
/* There's no particular reason that this needs to be handwritten
assembly, but since that's what this file contains, here's a
simple index implementation (written in C and compiled by gcc.)
unsigned char* REDIR_FOR_index ( const char* s, int c )
{
unsigned char ch = (unsigned char)((unsigned int)c);
unsigned char* p = (unsigned char*)s;
while (1) {
if (*p == ch) return p;
if (*p == 0) return 0;
p++;
}
}
*/
.global VG_(x86_linux_REDIR_FOR_index)
.type VG_(x86_linux_REDIR_FOR_index), @function
VG_(x86_linux_REDIR_FOR_index):
pushl %ebp
movl %esp, %ebp
movl 8(%ebp), %eax
movzbl 12(%ebp), %ecx
movzbl (%eax), %edx
cmpb %dl, %cl
jne .L9
jmp .L2
.L11:
addl $1, %eax
movzbl (%eax), %edx
cmpb %dl, %cl
je .L2
.L9:
testb %dl, %dl
jne .L11
xorl %eax, %eax
.L2:
popl %ebp
ret
.size VG_(x86_linux_REDIR_FOR_index), .-VG_(x86_linux_REDIR_FOR_index)
/* There's no particular reason that this needs to be handwritten
assembly, but since that's what this file contains, here's a
simple strlen implementation (written in C and compiled by gcc.)
*/
.global VG_(x86_linux_REDIR_FOR_strlen)
.type VG_(x86_linux_REDIR_FOR_strlen), @function
VG_(x86_linux_REDIR_FOR_strlen):
pushl %ebp
movl %esp, %ebp
movl 8(%ebp), %edx
movl %edx, %eax
jmp 2f
1: incl %eax
2: cmpb $0, (%eax)
jne 1b
subl %edx, %eax
popl %ebp
ret
.size VG_(x86_linux_REDIR_FOR_strlen), .-VG_(x86_linux_REDIR_FOR_strlen)
.global VG_(trampoline_stuff_end)
VG_(trampoline_stuff_end):
/* and a trailing page of unexecutable code */
UD2_PAGE
# undef UD2_16
# undef UD2_64
# undef UD2_256
# undef UD2_1024
# undef UD2_PAGE
/*---------------------- amd64-linux ----------------------*/
#else
#if defined(VGP_amd64_linux)
# define UD2_16 ud2 ; ud2 ; ud2 ; ud2 ;ud2 ; ud2 ; ud2 ; ud2
# define UD2_64 UD2_16 ; UD2_16 ; UD2_16 ; UD2_16
# define UD2_256 UD2_64 ; UD2_64 ; UD2_64 ; UD2_64
# define UD2_1024 UD2_256 ; UD2_256 ; UD2_256 ; UD2_256
# define UD2_PAGE UD2_1024 ; UD2_1024 ; UD2_1024 ; UD2_1024
/* a leading page of unexecutable code */
UD2_PAGE
.global VG_(trampoline_stuff_start)
VG_(trampoline_stuff_start):
.global VG_(amd64_linux_SUBST_FOR_rt_sigreturn)
VG_(amd64_linux_SUBST_FOR_rt_sigreturn):
/* This is a very specific sequence which GDB uses to
recognize signal handler frames. */
movq $__NR_rt_sigreturn, %rax
syscall
ud2
.global VG_(amd64_linux_REDIR_FOR_vgettimeofday)
.type VG_(amd64_linux_REDIR_FOR_vgettimeofday), @function
VG_(amd64_linux_REDIR_FOR_vgettimeofday):
.LfnB2:
movq $__NR_gettimeofday, %rax
syscall
ret
.LfnE2:
.size VG_(amd64_linux_REDIR_FOR_vgettimeofday), .-.LfnB2
.global VG_(amd64_linux_REDIR_FOR_vtime)
.type VG_(amd64_linux_REDIR_FOR_vtime), @function
VG_(amd64_linux_REDIR_FOR_vtime):
.LfnB3:
movq $__NR_time, %rax
syscall
ret
.LfnE3:
.size VG_(amd64_linux_REDIR_FOR_vtime), .-.LfnB3
.global VG_(amd64_linux_REDIR_FOR_vgetcpu)
.type VG_(amd64_linux_REDIR_FOR_vgetcpu), @function
VG_(amd64_linux_REDIR_FOR_vgetcpu):
.LfnB4:
movq $__NR_getcpu, %rax
syscall
ret
.LfnE4:
.size VG_(amd64_linux_REDIR_FOR_vgetcpu), .-.LfnB4
/* There's no particular reason that this needs to be handwritten
assembly, but since that's what this file contains, here's a
simple strlen implementation (written in C and compiled by gcc.)
*/
.global VG_(amd64_linux_REDIR_FOR_strlen)
.type VG_(amd64_linux_REDIR_FOR_strlen), @function
VG_(amd64_linux_REDIR_FOR_strlen):
.LfnB5:
xorl %eax, %eax
cmpb $0, (%rdi)
movq %rdi, %rdx
je .L41
.L40: addq $1, %rdx
cmpb $0, (%rdx)
jne .L40
movq %rdx, %rax
subq %rdi, %rax
.L41: ret
.LfnE5:
.size VG_(amd64_linux_REDIR_FOR_strlen), .-VG_(amd64_linux_REDIR_FOR_strlen)
/* A CIE for the above four functions, followed by their FDEs */
.section .eh_frame,"a",@progbits
.Lframe1:
.long .LEcie1-.LScie1
.LScie1:
.long 0x0
.byte 0x1
.string "zR"
.uleb128 0x1
.sleb128 -8
.byte 0x10
.uleb128 0x1
.byte 0x3
.byte 0xc
.uleb128 0x7
.uleb128 0x8
.byte 0x90
.uleb128 0x1
.align 8
.LEcie1:
.LSfde2:
.long .LEfde2-.LASfde2
.LASfde2:
.long .LASfde2-.Lframe1
.long .LfnB2
.long .LfnE2-.LfnB2
.uleb128 0x0
.align 8
.LEfde2:
.LSfde3:
.long .LEfde3-.LASfde3
.LASfde3:
.long .LASfde3-.Lframe1
.long .LfnB3
.long .LfnE3-.LfnB3
.uleb128 0x0
.align 8
.LEfde3:
.LSfde4:
.long .LEfde4-.LASfde4
.LASfde4:
.long .LASfde4-.Lframe1
.long .LfnB4
.long .LfnE4-.LfnB4
.uleb128 0x0
.align 8
.LEfde4:
.LSfde5:
.long .LEfde5-.LASfde5
.LASfde5:
.long .LASfde5-.Lframe1
.long .LfnB5
.long .LfnE5-.LfnB5
.uleb128 0x0
.align 8
.LEfde5:
.previous
.global VG_(trampoline_stuff_end)
VG_(trampoline_stuff_end):
/* and a trailing page of unexecutable code */
UD2_PAGE
# undef UD2_16
# undef UD2_64
# undef UD2_256
# undef UD2_1024
# undef UD2_PAGE
/*---------------- ppc32-linux ----------------*/
#else
#if defined(VGP_ppc32_linux)
# define UD2_16 trap ; trap ; trap; trap
# define UD2_64 UD2_16 ; UD2_16 ; UD2_16 ; UD2_16
# define UD2_256 UD2_64 ; UD2_64 ; UD2_64 ; UD2_64
# define UD2_1024 UD2_256 ; UD2_256 ; UD2_256 ; UD2_256
# define UD2_PAGE UD2_1024 ; UD2_1024 ; UD2_1024 ; UD2_1024
/* a leading page of unexecutable code */
UD2_PAGE
.global VG_(trampoline_stuff_start)
VG_(trampoline_stuff_start):
.global VG_(ppc32_linux_SUBST_FOR_sigreturn)
VG_(ppc32_linux_SUBST_FOR_sigreturn):
li 0,__NR_sigreturn
sc
.long 0 /*illegal insn*/
.global VG_(ppc32_linux_SUBST_FOR_rt_sigreturn)
VG_(ppc32_linux_SUBST_FOR_rt_sigreturn):
li 0,__NR_rt_sigreturn
sc
.long 0 /*illegal insn*/
/* There's no particular reason that this needs to be handwritten
assembly, but since that's what this file contains, here's a
simple strlen implementation (written in C and compiled by gcc.)
*/
.global VG_(ppc32_linux_REDIR_FOR_strlen)
.type VG_(ppc32_linux_REDIR_FOR_strlen), @function
VG_(ppc32_linux_REDIR_FOR_strlen):
lbz 4,0(3)
li 9,0
cmpwi 0,4,0
beq- 0,.L18
.L19:
lbzu 5,1(3)
addi 9,9,1
cmpwi 0,5,0
bne+ 0,.L19
.L18:
mr 3,9
blr
.size VG_(ppc32_linux_REDIR_FOR_strlen), .-VG_(ppc32_linux_REDIR_FOR_strlen)
/* Ditto strcmp */
.global VG_(ppc32_linux_REDIR_FOR_strcmp)
.type VG_(ppc32_linux_REDIR_FOR_strcmp), @function
VG_(ppc32_linux_REDIR_FOR_strcmp):
.L20:
lbz 0,0(3)
cmpwi 7,0,0
bne- 7,.L21
lbz 0,0(4)
li 11,0
cmpwi 7,0,0
beq- 7,.L22
.L21:
lbz 0,0(3)
li 11,-1
cmpwi 7,0,0
beq- 7,.L22
lbz 0,0(4)
li 11,1
cmpwi 7,0,0
beq- 7,.L22
lbz 9,0(3)
lbz 0,0(4)
li 11,-1
cmplw 7,9,0
blt- 7,.L22
lbz 9,0(3)
lbz 0,0(4)
li 11,1
addi 3,3,1
addi 4,4,1
cmplw 7,9,0
ble+ 7,.L20
.L22:
mr 3,11
blr
.size VG_(ppc32_linux_REDIR_FOR_strcmp), .-VG_(ppc32_linux_REDIR_FOR_strcmp)
/* Ditto index/strchr */
.global VG_(ppc32_linux_REDIR_FOR_strchr)
.type VG_(ppc32_linux_REDIR_FOR_strchr), @function
VG_(ppc32_linux_REDIR_FOR_strchr):
lbz 0,0(3)
rlwinm 4,4,0,0xff
cmpw 7,4,0
beqlr 7
cmpwi 7,0,0
bne 7,.L308
b .L304
.L309:
beq 6,.L304
.L308:
lbzu 0,1(3)
cmpw 7,4,0
cmpwi 6,0,0
bne 7,.L309
blr
.L304:
li 3,0
blr
.size VG_(ppc32_linux_REDIR_FOR_strchr),.-VG_(ppc32_linux_REDIR_FOR_strchr)
.global VG_(trampoline_stuff_end)
VG_(trampoline_stuff_end):
/* and a trailing page of unexecutable code */
UD2_PAGE
# undef UD2_16
# undef UD2_64
# undef UD2_256
# undef UD2_1024
# undef UD2_PAGE
/*---------------- ppc64-linux ----------------*/
#else
#if defined(VGP_ppc64be_linux) || defined(VGP_ppc64le_linux)
# define UD2_16 trap ; trap ; trap; trap
# define UD2_64 UD2_16 ; UD2_16 ; UD2_16 ; UD2_16
# define UD2_256 UD2_64 ; UD2_64 ; UD2_64 ; UD2_64
# define UD2_1024 UD2_256 ; UD2_256 ; UD2_256 ; UD2_256
# define UD2_PAGE UD2_1024 ; UD2_1024 ; UD2_1024 ; UD2_1024
/* a leading page of unexecutable code */
UD2_PAGE
.global VG_(trampoline_stuff_start)
VG_(trampoline_stuff_start):
.global VG_(ppc64_linux_SUBST_FOR_rt_sigreturn)
VG_(ppc64_linux_SUBST_FOR_rt_sigreturn):
li 0,__NR_rt_sigreturn
sc
.long 0 /*illegal insn*/
/* See comment in pub_core_trampoline.h for what this is for */
.global VG_(ppctoc_magic_redirect_return_stub)
VG_(ppctoc_magic_redirect_return_stub):
trap
/* this function is written using the "dotless" ABI convention */
.align 2
.globl VG_(ppc64_linux_REDIR_FOR_strlen)
#if !defined VGP_ppc64be_linux || _CALL_ELF == 2
/* Little Endian uses ELF version 2 */
.type VG_(ppc64_linux_REDIR_FOR_strlen),@function
VG_(ppc64_linux_REDIR_FOR_strlen):
#else
/* Big Endian uses ELF version 1 */
.section ".opd","aw"
.align 3
VG_(ppc64_linux_REDIR_FOR_strlen):
.quad .L.VG_(ppc64_linux_REDIR_FOR_strlen),.TOC.@tocbase,0
.previous
.size VG_(ppc64_linux_REDIR_FOR_strlen), \
.L0end-.L.VG_(ppc64_linux_REDIR_FOR_strlen)
.type VG_(ppc64_linux_REDIR_FOR_strlen), @function
.L.VG_(ppc64_linux_REDIR_FOR_strlen):
#endif
#if _CALL_ELF == 2
0: addis 2,12,.TOC.-0b@ha
addi 2,2,.TOC.-0b@l
.localentry VG_(ppc64_linux_REDIR_FOR_strlen), .-VG_(ppc64_linux_REDIR_FOR_strlen)
#endif
mr 9,3
lbz 0,0(3)
li 3,0
cmpwi 7,0,0
beqlr 7
li 3,0
.L01:
addi 0,3,1
extsw 3,0
lbzx 0,9,3
cmpwi 7,0,0
bne 7,.L01
blr
#if !defined VGP_ppc64be_linux || _CALL_ELF == 2
.size VG_(ppc64_linux_REDIR_FOR_strlen),.-VG_(ppc64_linux_REDIR_FOR_strlen)
#else
.size VG_(ppc64_linux_REDIR_FOR_strlen),.-.L.VG_(ppc64_linux_REDIR_FOR_strlen)
#endif
.long 0
.byte 0,0,0,0,0,0,0,0
.L0end:
/* this function is written using the "dotless" ABI convention */
.align 2
.globl VG_(ppc64_linux_REDIR_FOR_strchr)
#if !defined VGP_ppc64be_linux || _CALL_ELF == 2
.type VG_(ppc64_linux_REDIR_FOR_strchr),@function
VG_(ppc64_linux_REDIR_FOR_strchr):
#else
.section ".opd","aw"
.align 3
VG_(ppc64_linux_REDIR_FOR_strchr):
.quad .L.VG_(ppc64_linux_REDIR_FOR_strchr),.TOC.@tocbase,0
.previous
.size VG_(ppc64_linux_REDIR_FOR_strchr), \
.L1end-.L.VG_(ppc64_linux_REDIR_FOR_strchr)
.type VG_(ppc64_linux_REDIR_FOR_strchr),@function
.L.VG_(ppc64_linux_REDIR_FOR_strchr):
#endif
#if _CALL_ELF == 2
0: addis 2,12,.TOC.-0b@ha
addi 2,2,.TOC.-0b@l
.localentry VG_(ppc64_linux_REDIR_FOR_strchr), .-VG_(ppc64_linux_REDIR_FOR_strchr)
#endif
lbz 0,0(3)
rldicl 4,4,0,56
cmpw 7,4,0
beqlr 7
cmpdi 7,0,0
bne 7,.L18
b .L14
#if !defined VGP_ppc64be_linux || _CALL_ELF == 2
.size VG_(ppc64_linux_REDIR_FOR_strchr),.-VG_(ppc64_linux_REDIR_FOR_strchr)
#else
.size VG_(ppc64_linux_REDIR_FOR_strchr),.-.L.VG_(ppc64_linux_REDIR_FOR_strchr)
#endif
.L19:
beq 6,.L14
.L18:
lbzu 0,1(3)
cmpw 7,4,0
cmpdi 6,0,0
bne 7,.L19
blr
.L14:
li 3,0
blr
.long 0
.byte 0,0,0,0,0,0,0,0
.L1end:
.global VG_(trampoline_stuff_end)
VG_(trampoline_stuff_end):
/* and a trailing page of unexecutable code */
UD2_PAGE
# undef UD2_16
# undef UD2_64
# undef UD2_256
# undef UD2_1024
# undef UD2_PAGE
/*---------------- arm-linux ----------------*/
#else
#if defined(VGP_arm_linux)
# define UD2_4 .word 0xFFFFFFFF
# define UD2_16 UD2_4 ; UD2_4 ; UD2_4 ; UD2_4
# define UD2_64 UD2_16 ; UD2_16 ; UD2_16 ; UD2_16
# define UD2_256 UD2_64 ; UD2_64 ; UD2_64 ; UD2_64
# define UD2_1024 UD2_256 ; UD2_256 ; UD2_256 ; UD2_256
# define UD2_PAGE UD2_1024 ; UD2_1024 ; UD2_1024 ; UD2_1024
/* a leading page of unexecutable code */
UD2_PAGE
.global VG_(trampoline_stuff_start)
VG_(trampoline_stuff_start):
.global VG_(arm_linux_SUBST_FOR_sigreturn)
.type VG_(arm_linux_SUBST_FOR_sigreturn),#function
VG_(arm_linux_SUBST_FOR_sigreturn):
mov r7, # __NR_sigreturn
svc #0
.long 0xFFFFFFFF /*illegal insn*/
.size VG_(arm_linux_SUBST_FOR_sigreturn), .-VG_(arm_linux_SUBST_FOR_sigreturn)
.global VG_(arm_linux_SUBST_FOR_rt_sigreturn)
.type VG_(arm_linux_SUBST_FOR_rt_sigreturn),#function
VG_(arm_linux_SUBST_FOR_rt_sigreturn):
mov r7, # __NR_rt_sigreturn
svc #0
.long 0xFFFFFFFF /*illegal insn*/
.size VG_(arm_linux_SUBST_FOR_rt_sigreturn), .-VG_(arm_linux_SUBST_FOR_rt_sigreturn)
.global VG_(arm_linux_REDIR_FOR_strlen)
VG_(arm_linux_REDIR_FOR_strlen):
mov r2, r0
ldrb r0, [r0, #0] @ zero_extendqisi2
@ lr needed for prologue
cmp r0, #0
bxeq lr
mov r0, #0
.L5:
add r0, r0, #1
ldrb r3, [r0, r2] @ zero_extendqisi2
cmp r3, #0
bne .L5
bx lr
UD2_4
//.global VG_(arm_linux_REDIR_FOR_index)
//VG_(arm_linux_REDIR_FOR_index):
// ldrb r3, [r0, #0] @ zero_extendqisi2
// and r1, r1, #255
// cmp r3, r1
// @ lr needed for prologue
// bne .L9
// bx lr
//.L12:
// ldrb r3, [r0, #1]! @ zero_extendqisi2
// cmp r3, r1
// beq .L11
//.L9:
// cmp r3, #0
// bne .L12
// mov r0, #0
// bx lr
//.L11:
// bx lr
// UD2_4
.global VG_(arm_linux_REDIR_FOR_memcpy)
VG_(arm_linux_REDIR_FOR_memcpy):
stmfd sp!, {r4, r5, lr}
subs lr, r2, #0
mov r5, r0
beq .L2
cmp r0, r1
bls .L4
add r3, r0, lr
add r1, lr, r1
cmp lr, #3
sub r4, r3, #1
sub r0, r1, #1
ble .L28
sub ip, r3, #5
sub r1, r1, #5
.L8:
ldrb r3, [r1, #4] @ zero_extendqisi2
sub lr, lr, #4
strb r3, [ip, #4]
ldrb r2, [r1, #3] @ zero_extendqisi2
cmp lr, #3
strb r2, [ip, #3]
ldrb r3, [r1, #2] @ zero_extendqisi2
mov r4, ip
strb r3, [ip, #2]
ldrb r2, [r1, #1] @ zero_extendqisi2
mov r0, r1
strb r2, [ip, #1]
sub r1, r1, #4
sub ip, ip, #4
bgt .L8
cmp lr, #0
beq .L2
.L28:
sub r2, lr, #1
.L21:
sub r2, r2, #1
ldrb r3, [r0], #-1 @ zero_extendqisi2
cmn r2, #1
strb r3, [r4], #-1
bne .L21
.L2:
mov r0, r5
ldmfd sp!, {r4, r5, pc}
.L4:
bcs .L2
cmp lr, #3
mov ip, r0
ble .L29
.L19:
ldrb r3, [r1, #0] @ zero_extendqisi2
sub lr, lr, #4
strb r3, [ip, #0]
ldrb r2, [r1, #1] @ zero_extendqisi2
cmp lr, #3
strb r2, [ip, #1]
ldrb r3, [r1, #2] @ zero_extendqisi2
strb r3, [ip, #2]
ldrb r2, [r1, #3] @ zero_extendqisi2
add r1, r1, #4
strb r2, [ip, #3]
add ip, ip, #4
bgt .L19
cmp lr, #0
beq .L2
.L29:
sub r2, lr, #1
.L20:
sub r2, r2, #1
ldrb r3, [r1], #1 @ zero_extendqisi2
cmn r2, #1
strb r3, [ip], #1
bne .L20
mov r0, r5
ldmfd sp!, {r4, r5, pc}
UD2_4
.global VG_(arm_linux_REDIR_FOR_strcmp)
VG_(arm_linux_REDIR_FOR_strcmp):
.L64:
ldrb r3, [r0], #1 @ zero_extendqisi2
ldrb r2, [r1], #1 @ zero_extendqisi2
cmp r3, #0
beq .L67
cmp r3, r2
beq .L64
rsb r0, r2, r3
bx lr
.L67:
rsb r0, r2, #0
bx lr
UD2_4
.global VG_(trampoline_stuff_end)
VG_(trampoline_stuff_end):
/* and a trailing page of unexecutable code */
UD2_PAGE
# undef UD2_4
# undef UD2_16
# undef UD2_64
# undef UD2_256
# undef UD2_1024
# undef UD2_PAGE
/*---------------- arm64-linux ----------------*/
#else
#if defined(VGP_arm64_linux)
# define UD2_4 .word 0xFFFFFFFF
# define UD2_16 UD2_4 ; UD2_4 ; UD2_4 ; UD2_4
# define UD2_64 UD2_16 ; UD2_16 ; UD2_16 ; UD2_16
# define UD2_256 UD2_64 ; UD2_64 ; UD2_64 ; UD2_64
# define UD2_1024 UD2_256 ; UD2_256 ; UD2_256 ; UD2_256
# define UD2_PAGE UD2_1024 ; UD2_1024 ; UD2_1024 ; UD2_1024
/* a leading page of unexecutable code */
UD2_PAGE
.global VG_(trampoline_stuff_start)
VG_(trampoline_stuff_start):
.global VG_(arm64_linux_SUBST_FOR_rt_sigreturn)
.type VG_(arm64_linux_SUBST_FOR_rt_sigreturn),#function
VG_(arm64_linux_SUBST_FOR_rt_sigreturn):
mov x8, # __NR_rt_sigreturn
svc #0
.long 0xFFFFFFFF /*illegal insn*/
.size VG_(arm64_linux_SUBST_FOR_rt_sigreturn), \
.-VG_(arm64_linux_SUBST_FOR_rt_sigreturn)
.global VG_(arm64_linux_REDIR_FOR_strlen)
.type VG_(arm64_linux_REDIR_FOR_strlen),#function
VG_(arm64_linux_REDIR_FOR_strlen):
mov x2, x0
ldrb w0, [x0]
cbz w0, .L5
mov x0, 0
.L4:
add x0, x0, 1
ldrb w1, [x2,x0]
cbnz w1, .L4
ret
.L5:
mov x0, 0
ret
.size VG_(arm64_linux_REDIR_FOR_strlen), .-VG_(arm64_linux_REDIR_FOR_strlen)
.global VG_(arm64_linux_REDIR_FOR_index)
.type VG_(arm64_linux_REDIR_FOR_index),#function
VG_(arm64_linux_REDIR_FOR_index):
ldrb w2, [x0]
uxtb w1, w1
cmp w2, w1
beq .L11
.L13:
cbz w2, .L16
ldrb w2, [x0,1]!
cmp w2, w1
bne .L13
.L11:
ret
.L16:
mov x0, 0
ret
.size VG_(arm64_linux_REDIR_FOR_index), .-VG_(arm64_linux_REDIR_FOR_index)
.global VG_(arm64_linux_REDIR_FOR_strcmp)
.type VG_(arm64_linux_REDIR_FOR_strcmp),#function
VG_(arm64_linux_REDIR_FOR_strcmp):
ldrb w2, [x0]
ldrb w3, [x1]
cmp w2, w3
bcc .L22
.L21:
bhi .L25
cbz w2, .L26
ldrb w2, [x0,1]!
ldrb w3, [x1,1]!
cmp w2, w3
bcs .L21
.L22:
mov x0, -1
ret
.L25:
mov x0, 1
ret
.L26:
mov x0, 0
ret
.size VG_(arm64_linux_REDIR_FOR_strcmp), .-VG_(arm64_linux_REDIR_FOR_strcmp)
.global VG_(trampoline_stuff_end)
VG_(trampoline_stuff_end):
/* and a trailing page of unexecutable code */
UD2_PAGE
# undef UD2_4
# undef UD2_16
# undef UD2_64
# undef UD2_256
# undef UD2_1024
# undef UD2_PAGE
/*---------------- x86-darwin ----------------*/
#else
#if defined(VGP_x86_darwin)
/* a leading page of unexecutable code */
.fill 2048, 2, 0x0b0f /* `ud2` */
.globl VG_(trampoline_stuff_start)
VG_(trampoline_stuff_start):
.globl VG_(x86_darwin_SUBST_FOR_sigreturn)
VG_(x86_darwin_SUBST_FOR_sigreturn):
/* XXX does this need to have any special form? (cf x86-linux
version) */
movl $ __NR_DARWIN_FAKE_SIGRETURN, %eax
int $0x80
ud2
.globl VG_(x86_darwin_REDIR_FOR_strlen)
VG_(x86_darwin_REDIR_FOR_strlen):
movl 4(%esp), %edx
movl %edx, %eax
jmp 1f
0:
incl %eax
1:
cmpb $0, (%eax)
jne 0b
subl %edx, %eax
ret
.globl VG_(x86_darwin_REDIR_FOR_strcat)
VG_(x86_darwin_REDIR_FOR_strcat):
pushl %esi
movl 8(%esp), %esi
movl 12(%esp), %ecx
movl %esi, %edx
jmp 1f
0:
incl %edx
1:
cmpb $0, (%edx)
jne 0b
2:
movzbl (%ecx), %eax
incl %ecx
movb %al, (%edx)
incl %edx
testb %al, %al
jne 2b
movl %esi, %eax
popl %esi
ret
.globl VG_(x86_darwin_REDIR_FOR_strcmp)
VG_(x86_darwin_REDIR_FOR_strcmp):
movl 4(%esp), %edx
movl 8(%esp), %ecx
jmp 1f
0:
incl %edx
incl %ecx
1:
movzbl (%edx), %eax
testb %al, %al
je 2f
cmpb (%ecx), %al
je 0b
2:
movzbl (%ecx),%edx
movzbl %al,%eax
subl %edx, %eax
ret
.globl VG_(x86_darwin_REDIR_FOR_strcpy)
VG_(x86_darwin_REDIR_FOR_strcpy):
pushl %ebp
movl %esp, %ebp
pushl %esi
movl 8(%ebp), %esi
movl 12(%ebp), %ecx
movl %esi, %edx
jmp 1f
0:
incl %ecx
incl %edx
1:
movzbl (%ecx), %eax
testb %al, %al
movb %al, (%edx)
jne 0b
movl %esi, %eax
popl %esi
leave
ret
.globl VG_(x86_darwin_REDIR_FOR_strlcat)
VG_(x86_darwin_REDIR_FOR_strlcat):
pushl %ebp
movl %esp, %ebp
pushl %edi
pushl %esi
subl $16, %esp
movl 8(%ebp), %esi
movl 16(%ebp), %ecx
movl %esi, %edx
leal (%ecx,%esi), %eax
jmp 1f
0:
incl %edx
1:
cmpl %edx, %eax
je 2f
cmpb $0, (%edx)
jne 0b
2:
movl %edx, %edi
subl %esi, %edi
movl %ecx, %esi
subl %edi, %esi
je 3f
movl 12(%ebp), %eax
jmp 6f
3:
movl 12(%ebp), %eax
movl %eax, (%esp)
call VG_(x86_darwin_REDIR_FOR_strlen)
jmp 7f
4:
cmpl $1, %esi
je 5f
movb %cl, (%edx)
decl %esi
incl %edx
5:
incl %eax
6:
movzbl (%eax), %ecx
testb %cl, %cl
jne 4b
movb $0, (%edx)
subl 12(%ebp), %eax
7:
addl $16, %esp
leal (%edi,%eax), %eax
popl %esi
popl %edi
leave
ret
.globl VG_(trampoline_stuff_end)
VG_(trampoline_stuff_end):
/* a trailing page of unexecutable code */
.fill 2048, 2, 0x0b0f /* `ud2` */
/*---------------- amd64-darwin ----------------*/
#else
#if defined(VGP_amd64_darwin)
/* a leading page of unexecutable code */
.fill 2048, 2, 0x0b0f /* `ud2` */
.globl VG_(trampoline_stuff_start)
VG_(trampoline_stuff_start):
.globl VG_(amd64_darwin_SUBST_FOR_sigreturn)
VG_(amd64_darwin_SUBST_FOR_sigreturn):
/* XXX does this need to have any special form? (cf x86-linux
version) */
movq $ __NR_DARWIN_FAKE_SIGRETURN, %rax
syscall
ud2
.globl VG_(amd64_darwin_REDIR_FOR_strlen)
VG_(amd64_darwin_REDIR_FOR_strlen):
movq %rdi, %rax
jmp 1f
0:
incq %rax
1:
cmpb $0, (%rax)
jne 0b
subq %rdi, %rax
ret
.globl VG_(amd64_darwin_REDIR_FOR_strcat)
VG_(amd64_darwin_REDIR_FOR_strcat):
movq %rdi, %rdx
jmp 1f
0:
incq %rdx
1:
cmpb $0, (%rdx)
jne 0b
2:
movzbl (%rsi), %eax
incq %rsi
movb %al, (%rdx)
incq %rdx
testb %al, %al
jne 2b
movq %rdi, %rax
ret
.globl VG_(amd64_darwin_REDIR_FOR_strcmp)
VG_(amd64_darwin_REDIR_FOR_strcmp):
jmp 1f
0:
incq %rdi
incq %rsi
1:
movzbl (%rdi), %eax
testb %al, %al
je 2f
cmpb (%rsi), %al
je 0b
2:
movzbl (%rsi), %edx
movzbl %al, %eax
subl %edx, %eax
ret
.globl VG_(amd64_darwin_REDIR_FOR_strcpy)
VG_(amd64_darwin_REDIR_FOR_strcpy):
pushq %rbp
movq %rdi, %rdx
movq %rsp, %rbp
jmp 1f
0:
incq %rsi
incq %rdx
1:
movzbl (%rsi), %eax
testb %al, %al
movb %al, (%rdx)
jne 0b
leave
movq %rdi, %rax
ret
.globl VG_(amd64_darwin_REDIR_FOR_strlcat)
VG_(amd64_darwin_REDIR_FOR_strlcat):
pushq %rbp
leaq (%rdx,%rdi), %rax
movq %rdi, %rcx
movq %rsp, %rbp
pushq %rbx
subq $8, %rsp
jmp 1f
0:
incq %rcx
1:
cmpq %rcx, %rax
je 2f
cmpb $0, (%rcx)
jne 0b
2:
movq %rcx, %rbx
subq %rdi, %rbx
movq %rdx, %rdi
subq %rbx, %rdi
je 3f
movq %rsi, %rax
jmp 6f
3:
movq %rsi, %rdi
call VG_(amd64_darwin_REDIR_FOR_strlen)
jmp 7f
4:
cmpq $1, %rdi
je 5f
movb %dl, (%rcx)
decq %rdi
incq %rcx
5:
incq %rax
6:
movzbl (%rax), %edx
testb %dl, %dl
jne 4b
movb $0, (%rcx)
subq %rsi, %rax
7:
leaq (%rbx,%rax), %rax
addq $8, %rsp
popq %rbx
leave
ret
.globl VG_(amd64_darwin_REDIR_FOR_arc4random)
VG_(amd64_darwin_REDIR_FOR_arc4random):
/* not very random, hope dyld won't mind */
movq $0x76616c6772696e64, %rax
ret
.globl VG_(amd64_darwin_REDIR_FOR_strchr)
VG_(amd64_darwin_REDIR_FOR_strchr):
pushq %rbp
movq %rsp, %rbp
movb (%rdi), %cl
cmpb %sil, %cl
jne 1f
movq %rdi, %rax
popq %rbp
ret
1:
testb %cl, %cl
movl $0, %eax
je 2f
movb 1(%rdi), %cl
incq %rdi
cmpb %sil, %cl
movq %rdi, %rax
jne 1b
2:
popq %rbp
ret
.globl VG_(trampoline_stuff_end)
VG_(trampoline_stuff_end):
/* a trailing page of unexecutable code */
.fill 2048, 2, 0x0b0f /* `ud2` */
/*---------------- s390x-linux ----------------*/
#else
#if defined(VGP_s390x_linux)
/* a leading page of unexecutable code */
.fill 2048, 2, 0x0000
.global VG_(trampoline_stuff_start)
VG_(trampoline_stuff_start):
.global VG_(s390x_linux_SUBST_FOR_sigreturn)
VG_(s390x_linux_SUBST_FOR_sigreturn):
svc __NR_sigreturn
.short 0
.global VG_(s390x_linux_SUBST_FOR_rt_sigreturn)
VG_(s390x_linux_SUBST_FOR_rt_sigreturn):
/* Old gcc unwinding code checks for a sig(_rt)_return svc and then
for ra = cfa to decide if it is a sig_rt_frame or not. Since we
set ra to this trampoline, but the cfa is still in the stack,
the unwinder thinks, that this is a non-rt frame and causes a
crash in the gcc unwinder - which is used by the thread library
and others. Therefore we add a lr 1,1 nop, to let the gcc
unwinder bail out gracefully. This might also affect unwinding
across the signal frame - tough luck. fixs390 */
lr 1,1
svc __NR_rt_sigreturn
.short 0
.global VG_(s390x_linux_REDIR_FOR_index)
.type VG_(s390x_linux_REDIR_FOR_index),@function
VG_(s390x_linux_REDIR_FOR_index):
#
# %r2 = addess of string
# %r3 = character to find
#
lghi %r0,255
ngr %r0,%r3 # r0 = (unsigned char)r3
lghi %r4,0
.L1:
llgc %r1,0(%r2) # r1 = byte from string
cr %r1,%r0 # compare
ber %r14 # return if found
cr %r1,%r4 # end of string ?
je .L2
aghi %r2,1 # increment r2
j .L1
.L2: lghi %r2,0 # return value 0
br %r14
.size VG_(s390x_linux_REDIR_FOR_index), .-VG_(s390x_linux_REDIR_FOR_index)
.globl VG_(trampoline_stuff_end)
VG_(trampoline_stuff_end):
.fill 2048, 2, 0x0000
/*---------------------- mips32-linux ----------------------*/
#else
#if defined(VGP_mips32_linux)
# define UD2_16 trap ; trap ; trap; trap
# define UD2_64 UD2_16 ; UD2_16 ; UD2_16 ; UD2_16
# define UD2_256 UD2_64 ; UD2_64 ; UD2_64 ; UD2_64
# define UD2_1024 UD2_256 ; UD2_256 ; UD2_256 ; UD2_256
# define UD2_PAGE UD2_1024 ; UD2_1024 ; UD2_1024 ; UD2_1024
.global VG_(trampoline_stuff_start)
VG_(trampoline_stuff_start):
.global VG_(mips32_linux_SUBST_FOR_sigreturn)
VG_(mips32_linux_SUBST_FOR_sigreturn):
li $v0,__NR_sigreturn
syscall
nop
.long 0 /*illegal insn*/
.global VG_(mips32_linux_SUBST_FOR_rt_sigreturn)
VG_(mips32_linux_SUBST_FOR_rt_sigreturn):
li $v0,__NR_rt_sigreturn
syscall
nop
.long 0 /*illegal insn*/
/* There's no particular reason that this needs to be handwritten
assembly, but since that's what this file contains, here's a
simple strlen implementation (written in C and compiled by gcc.)
*/
.global VG_(mips32_linux_REDIR_FOR_strlen)
.type VG_(mips32_linux_REDIR_FOR_strlen), @function
VG_(mips32_linux_REDIR_FOR_strlen):
li $v0, 0
//la $a0, string
j strlen_cond
strlen_loop:
addi $v0, $v0, 1
addi $a0, $a0, 1
strlen_cond:
lbu $t0, ($a0)
bne $t0, $zero, strlen_loop
jr $ra
.size VG_(mips32_linux_REDIR_FOR_strlen), .-VG_(mips32_linux_REDIR_FOR_strlen)
.global VG_(trampoline_stuff_end)
VG_(trampoline_stuff_end):
# undef UD2_16
# undef UD2_64
# undef UD2_256
# undef UD2_1024
# undef UD2_PAGE
/*---------------------- mips64-linux ----------------------*/
#else
#if defined(VGP_mips64_linux)
# define UD2_16 trap ; trap ; trap; trap
# define UD2_64 UD2_16 ; UD2_16 ; UD2_16 ; UD2_16
# define UD2_256 UD2_64 ; UD2_64 ; UD2_64 ; UD2_64
# define UD2_1024 UD2_256 ; UD2_256 ; UD2_256 ; UD2_256
# define UD2_PAGE UD2_1024 ; UD2_1024 ; UD2_1024 ; UD2_1024
.global VG_(trampoline_stuff_start)
VG_(trampoline_stuff_start):
.global VG_(mips64_linux_SUBST_FOR_rt_sigreturn)
VG_(mips64_linux_SUBST_FOR_rt_sigreturn):
li $2,__NR_rt_sigreturn
syscall
nop
.long 0 /*illegal insn*/
/* There's no particular reason that this needs to be handwritten
assembly, but since that's what this file contains, here's a
simple strlen implementation (written in C and compiled by gcc.)
*/
.global VG_(mips64_linux_REDIR_FOR_strlen)
.type VG_(mips64_linux_REDIR_FOR_strlen), @function
VG_(mips64_linux_REDIR_FOR_strlen):
lbu $12, 0($4)
li $13, 0
beq $12, $0, M01
nop
M02:
addiu $13, $13, 1
addiu $4, $4, 1
lbu $12, 0($4)
bne $12, $0, M02
nop
M01:
move $2, $13
jr $31
nop
.size VG_(mips64_linux_REDIR_FOR_strlen), .-VG_(mips64_linux_REDIR_FOR_strlen)
.global VG_(trampoline_stuff_end)
VG_(trampoline_stuff_end):
# undef UD2_16
# undef UD2_64
# undef UD2_256
# undef UD2_1024
# undef UD2_PAGE
/*---------------------- tilegx-linux ----------------------*/
#else
#if defined(VGP_tilegx_linux)
# define UD2_16 ill ; ill
# define UD2_64 UD2_16 ; UD2_16 ; UD2_16 ; UD2_16
# define UD2_256 UD2_64 ; UD2_64 ; UD2_64 ; UD2_64
# define UD2_1024 UD2_256 ; UD2_256 ; UD2_256 ; UD2_256
# define UD2_4K UD2_1024 ; UD2_1024 ; UD2_1024 ; UD2_1024
# define UD2_16K UD2_4K ; UD2_4K ; UD2_4K ; UD2_4K
# define UD2_PAGE UD2_16K ; UD2_16K ; UD2_16K ; UD2_16K
/* a leading page of unexecutable code */
UD2_PAGE
.global VG_(trampoline_stuff_start)
VG_(trampoline_stuff_start):
.global VG_(tilegx_linux_SUBST_FOR_rt_sigreturn)
VG_(tilegx_linux_SUBST_FOR_rt_sigreturn):
/* This is a very specific sequence which GDB uses to
recognize signal handler frames. */
moveli r10, __NR_rt_sigreturn
swint1
ill
.global VG_(tilegx_linux_REDIR_FOR_vgettimeofday)
.type VG_(tilegx_linux_REDIR_FOR_vgettimeofday), @function
VG_(tilegx_linux_REDIR_FOR_vgettimeofday):
moveli r10, __NR_gettimeofday
swint1
jrp lr
.size VG_(tilegx_linux_REDIR_FOR_vgettimeofday), .-VG_(tilegx_linux_REDIR_FOR_vgettimeofday)
.global VG_(tilegx_linux_REDIR_FOR_vtime)
.type VG_(tilegx_linux_REDIR_FOR_vtime), @function
VG_(tilegx_linux_REDIR_FOR_vtime):
moveli r10, __NR_gettimeofday
swint1
jrp lr
.size VG_(tilegx_linux_REDIR_FOR_vtime), .-VG_(tilegx_linux_REDIR_FOR_vtime)
.global VG_(tilegx_linux_REDIR_FOR_strlen)
.type VG_(tilegx_linux_REDIR_FOR_strlen), @function
VG_(tilegx_linux_REDIR_FOR_strlen):
{
movei r1, 0
beqz r0, 2f
}
1: {
addi r1, r1, 1
ld1s_add r2, r0, 1
}
bnezt r2, 1b
addi r1, r1, -1
2: move r0, r1
jrp lr
.size VG_(tilegx_linux_REDIR_FOR_strlen), .-VG_(tilegx_linux_REDIR_FOR_strlen)
.global VG_(trampoline_stuff_end)
VG_(trampoline_stuff_end):
/* and a trailing page of unexecutable code */
UD2_PAGE
# undef UD2_16
# undef UD2_64
# undef UD2_256
# undef UD2_1024
# undef UD2_4K
# undef UD2_16K
# undef UD2_PAGE
/*---------------- x86-solaris ----------------*/
#else
#if defined(VGP_x86_solaris)
.global VG_(trampoline_stuff_start)
VG_(trampoline_stuff_start):
/* int strcmp(const char *s1, const char *s2); */
.global VG_(x86_solaris_REDIR_FOR_strcmp)
.type VG_(x86_solaris_REDIR_FOR_strcmp), @function
VG_(x86_solaris_REDIR_FOR_strcmp):
pushl %ebp /* establish a stack frame */
movl %esp, %ebp
movl 8(%ebp), %edx /* get s1 */
movl 12(%esp), %ecx /* get s2 */
jmp 2f /* go compare the first characters */
1:
incl %edx /* skip to the next s1 character */
incl %ecx /* skip to the next s2 character */
2:
movzbl (%edx), %eax /* load a character from s1 */
testb %al, %al /* is it null? */
jz 3f /* yes, exit */
cmpb (%ecx), %al /* are the characters equal? */
je 1b /* yes, proceed with next characters */
3:
movzbl (%ecx), %edx /* load a character from s2 */
subl %edx, %eax /* calculate the return value */
popl %ebp /* destroy the stack frame */
ret /* return to the caller */
.size VG_(x86_solaris_REDIR_FOR_strcmp), .-VG_(x86_solaris_REDIR_FOR_strcmp)
/* size_t strlen(const char *s); */
.global VG_(x86_solaris_REDIR_FOR_strlen)
.type VG_(x86_solaris_REDIR_FOR_strlen), @function
VG_(x86_solaris_REDIR_FOR_strlen):
pushl %ebp /* establish a stack frame */
movl %esp, %ebp
movl 8(%ebp), %edx /* get s */
movl %edx, %eax /* copy s */
jmp 2f /* go handle the first character */
1:
incl %eax /* skip to the next s character */
2:
cmpb $0, (%eax) /* is the s character null? */
jne 1b /* no, go process the next character */
subl %edx, %eax /* calculate the return value */
popl %ebp /* destroy the stack frame */
ret /* return to the caller */
.size VG_(x86_solaris_REDIR_FOR_strlen), .-VG_(x86_solaris_REDIR_FOR_strlen)
.global VG_(trampoline_stuff_end)
VG_(trampoline_stuff_end):
/*---------------- amd64-solaris ----------------*/
#else
#if defined(VGP_amd64_solaris)
.global VG_(trampoline_stuff_start)
VG_(trampoline_stuff_start):
/* char *strcpy(char *restrict s1, const char *restrict s2); */
.global VG_(amd64_solaris_REDIR_FOR_strcpy)
.type VG_(amd64_solaris_REDIR_FOR_strcpy), @function
VG_(amd64_solaris_REDIR_FOR_strcpy):
pushq %rbp /* establish a stack frame */
movq %rsp, %rbp
movq %rdi, %rdx /* copy s1 */
1:
movzbl (%rsi), %eax /* load one input character */
movb %al, (%rdx) /* copy to output/s2 */
incq %rsi /* skip to the next output character */
incq %rdx /* skip to the next input character */
testb %al, %al /* is the copied character null? */
jnz 1b /* no, copy the next character */
leave /* destroy the stack frame */
movq %rdi, %rax /* set s1 as the return value */
ret /* return to the caller */
.size VG_(amd64_solaris_REDIR_FOR_strcpy), .-VG_(amd64_solaris_REDIR_FOR_strcpy)
/* char *strncpy(char *restrict s1, const char *restrict s2, size_t n); */
.global VG_(amd64_solaris_REDIR_FOR_strncpy)
.type VG_(amd64_solaris_REDIR_FOR_strncpy), @function
VG_(amd64_solaris_REDIR_FOR_strncpy):
pushq %rbp /* establish a stack frame */
movq %rsp, %rbp
movq %rdi, %rcx /* copy s1 */
1:
testq %rdx, %rdx /* is the remaining size zero? */
jz 3f /* yes, all done */
movzbl (%rsi), %eax /* load one input character */
movb %al, (%rcx) /* copy to output/s2 */
decq %rdx /* decrement the remaining size */
incq %rsi /* skip to the next output character */
incq %rcx /* skip to the next input character */
testb %al, %al /* is the copied character null? */
jnz 1b /* no, copy the next character */
2:
testq %rdx, %rdx /* is the remaining size zero? */
jz 3f /* yes, all done */
movb $0, (%rdx) /* copy null to output/s2 */
decq %rdx /* decrement the remaining size */
incq %rsi /* skip to next output character */
jmp 2b /* proceed with the next character */
3:
leave /* destroy the stack frame */
movq %rdi, %rax /* set s1 as the return value */
ret /* return to the caller */
.size VG_(amd64_solaris_REDIR_FOR_strncpy), .-VG_(amd64_solaris_REDIR_FOR_strncpy)
/* int strcmp(const char *s1, const char *s2); */
.global VG_(amd64_solaris_REDIR_FOR_strcmp)
.type VG_(amd64_solaris_REDIR_FOR_strcmp), @function
VG_(amd64_solaris_REDIR_FOR_strcmp):
pushq %rbp /* establish a stack frame */
movq %rsp, %rbp
jmp 2f /* go compare the first characters */
1:
incq %rdi /* skip to the next s1 character */
incq %rsi /* skip to the next s2 character */
2:
movzbl (%rdi), %eax /* load a character from s1 */
testb %al, %al /* is it null? */
jz 3f /* yes, exit */
cmpb (%rsi), %al /* are the characters equal? */
je 1b /* yes, proceed with next characters */
3:
movzbl (%rsi), %edx /* load a character from s2 */
subl %edx, %eax /* calculate the return value */
leave /* destroy the stack frame */
ret /* return to the caller */
.size VG_(amd64_solaris_REDIR_FOR_strcmp), .-VG_(amd64_solaris_REDIR_FOR_strcmp)
/* char *strcat(char *restrict s1, const char *restrict s2); */
.global VG_(amd64_solaris_REDIR_FOR_strcat)
.type VG_(amd64_solaris_REDIR_FOR_strcat), @function
VG_(amd64_solaris_REDIR_FOR_strcat):
pushq %rbp /* establish a stack frame */
movq %rsp, %rbp
movq %rdi, %rdx /* copy s1 */
jmp 2f /* go handle the first character */
1:
incq %rdx /* skip to the next s1 character */
2:
cmpb $0, (%rdx) /* is the s1 character null? */
jne 1b /* no, go check the next character */
3:
movzbl (%rsi), %eax /* load a character from s2 */
movb %al, (%rdx) /* copy the s2 character to s1 */
incq %rdx /* skip to the next s1 character */
incq %rsi /* skip to the next s2 character */
testb %al, %al /* was the character null? */
jnz 3b /* no, go copy the next character */
movq %rdi, %rax /* set s1 as the return value */
leave /* destroy the stack frame */
ret /* return to the caller */
.size VG_(amd64_solaris_REDIR_FOR_strcat), .-VG_(amd64_solaris_REDIR_FOR_strcat)
/* size_t strlen(const char *s); */
.global VG_(amd64_solaris_REDIR_FOR_strlen)
.type VG_(amd64_solaris_REDIR_FOR_strlen), @function
VG_(amd64_solaris_REDIR_FOR_strlen):
pushq %rbp /* establish a stack frame */
movq %rsp, %rbp
movq %rdi, %rax /* copy s */
jmp 2f /* go handle the first character */
1:
incq %rax /* skip to the next s character */
2:
cmpb $0, (%rax) /* is the s character null? */
jne 1b /* no, go process the next character */
subq %rdi, %rax /* calculate the return value */
leave /* destroy the stack frame */
ret /* return to the caller */
.size VG_(amd64_solaris_REDIR_FOR_strlen), .-VG_(amd64_solaris_REDIR_FOR_strlen)
.global VG_(trampoline_stuff_end)
VG_(trampoline_stuff_end):
/*---------------- unknown ----------------*/
#else
# error Unknown platform
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
#endif
/* Let the linker know we don't need an executable stack */
MARK_STACK_NO_EXEC
/*--------------------------------------------------------------------*/
/*--- end ---*/
/*--------------------------------------------------------------------*/