1 2 /*--------------------------------------------------------------------*/ 3 /*--- Trampoline code page stuff. m_trampoline.S ---*/ 4 /*--------------------------------------------------------------------*/ 5 6 /* 7 This file is part of Valgrind, a dynamic binary instrumentation 8 framework. 9 10 Copyright (C) 2000-2017 Julian Seward 11 jseward (at) acm.org 12 Copyright (C) 2006-2017 OpenWorks LLP 13 info (at) open-works.co.uk 14 15 This program is free software; you can redistribute it and/or 16 modify it under the terms of the GNU General Public License as 17 published by the Free Software Foundation; either version 2 of the 18 License, or (at your option) any later version. 19 20 This program is distributed in the hope that it will be useful, but 21 WITHOUT ANY WARRANTY; without even the implied warranty of 22 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU 23 General Public License for more details. 24 25 You should have received a copy of the GNU General Public License 26 along with this program; if not, write to the Free Software 27 Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 28 02111-1307, USA. 29 30 The GNU General Public License is contained in the file COPYING. 31 */ 32 33 #include "pub_core_basics_asm.h" 34 #include "pub_core_vkiscnums_asm.h" 35 36 /* ------------------ SIMULATED CPU HELPERS ------------------ */ 37 /* 38 Replacements for some functions to do with vsyscalls and signals. 39 This code runs on the simulated CPU. 40 */ 41 42 /*---------------------- x86-linux ----------------------*/ 43 #if defined(VGP_x86_linux) 44 45 # define UD2_16 ud2 ; ud2 ; ud2 ; ud2 ;ud2 ; ud2 ; ud2 ; ud2 46 # define UD2_64 UD2_16 ; UD2_16 ; UD2_16 ; UD2_16 47 # define UD2_256 UD2_64 ; UD2_64 ; UD2_64 ; UD2_64 48 # define UD2_1024 UD2_256 ; UD2_256 ; UD2_256 ; UD2_256 49 # define UD2_PAGE UD2_1024 ; UD2_1024 ; UD2_1024 ; UD2_1024 50 51 /* a leading page of unexecutable code */ 52 UD2_PAGE 53 54 .global VG_(trampoline_stuff_start) 55 VG_(trampoline_stuff_start): 56 57 .global VG_(x86_linux_SUBST_FOR_sigreturn) 58 VG_(x86_linux_SUBST_FOR_sigreturn): 59 /* This is a very specific sequence which GDB uses to 60 recognize signal handler frames. Also gcc: see 61 x86_fallback_frame_state() in 62 gcc-4.1.0/gcc/config/i386/linux-unwind.h */ 63 popl %eax 64 movl $ __NR_sigreturn, %eax 65 int $0x80 66 ud2 67 68 .global VG_(x86_linux_SUBST_FOR_rt_sigreturn) 69 VG_(x86_linux_SUBST_FOR_rt_sigreturn): 70 /* Likewise for rt signal frames */ 71 movl $ __NR_rt_sigreturn, %eax 72 int $0x80 73 ud2 74 75 /* There's no particular reason that this needs to be handwritten 76 assembly, but since that's what this file contains, here's a 77 simple index implementation (written in C and compiled by gcc.) 78 79 unsigned char* REDIR_FOR_index ( const char* s, int c ) 80 { 81 unsigned char ch = (unsigned char)((unsigned int)c); 82 unsigned char* p = (unsigned char*)s; 83 while (1) { 84 if (*p == ch) return p; 85 if (*p == 0) return 0; 86 p++; 87 } 88 } 89 */ 90 .global VG_(x86_linux_REDIR_FOR_index) 91 .type VG_(x86_linux_REDIR_FOR_index), @function 92 VG_(x86_linux_REDIR_FOR_index): 93 pushl %ebp 94 movl %esp, %ebp 95 movl 8(%ebp), %eax 96 movzbl 12(%ebp), %ecx 97 movzbl (%eax), %edx 98 cmpb %dl, %cl 99 jne .L9 100 jmp .L2 101 .L11: 102 addl $1, %eax 103 movzbl (%eax), %edx 104 cmpb %dl, %cl 105 je .L2 106 .L9: 107 testb %dl, %dl 108 jne .L11 109 xorl %eax, %eax 110 .L2: 111 popl %ebp 112 ret 113 .size VG_(x86_linux_REDIR_FOR_index), .-VG_(x86_linux_REDIR_FOR_index) 114 115 /* There's no particular reason that this needs to be handwritten 116 assembly, but since that's what this file contains, here's a 117 simple strlen implementation (written in C and compiled by gcc.) 118 */ 119 .global VG_(x86_linux_REDIR_FOR_strlen) 120 .type VG_(x86_linux_REDIR_FOR_strlen), @function 121 VG_(x86_linux_REDIR_FOR_strlen): 122 pushl %ebp 123 movl %esp, %ebp 124 movl 8(%ebp), %edx 125 movl %edx, %eax 126 jmp 2f 127 1: incl %eax 128 2: cmpb $0, (%eax) 129 jne 1b 130 subl %edx, %eax 131 popl %ebp 132 ret 133 .size VG_(x86_linux_REDIR_FOR_strlen), .-VG_(x86_linux_REDIR_FOR_strlen) 134 135 136 .global VG_(trampoline_stuff_end) 137 VG_(trampoline_stuff_end): 138 139 /* and a trailing page of unexecutable code */ 140 UD2_PAGE 141 142 # undef UD2_16 143 # undef UD2_64 144 # undef UD2_256 145 # undef UD2_1024 146 # undef UD2_PAGE 147 148 /*---------------------- amd64-linux ----------------------*/ 149 #else 150 #if defined(VGP_amd64_linux) 151 152 # define UD2_16 ud2 ; ud2 ; ud2 ; ud2 ;ud2 ; ud2 ; ud2 ; ud2 153 # define UD2_64 UD2_16 ; UD2_16 ; UD2_16 ; UD2_16 154 # define UD2_256 UD2_64 ; UD2_64 ; UD2_64 ; UD2_64 155 # define UD2_1024 UD2_256 ; UD2_256 ; UD2_256 ; UD2_256 156 # define UD2_PAGE UD2_1024 ; UD2_1024 ; UD2_1024 ; UD2_1024 157 158 /* a leading page of unexecutable code */ 159 UD2_PAGE 160 161 .global VG_(trampoline_stuff_start) 162 VG_(trampoline_stuff_start): 163 164 .global VG_(amd64_linux_SUBST_FOR_rt_sigreturn) 165 VG_(amd64_linux_SUBST_FOR_rt_sigreturn): 166 /* This is a very specific sequence which GDB uses to 167 recognize signal handler frames. */ 168 movq $__NR_rt_sigreturn, %rax 169 syscall 170 ud2 171 172 .global VG_(amd64_linux_REDIR_FOR_vgettimeofday) 173 .type VG_(amd64_linux_REDIR_FOR_vgettimeofday), @function 174 VG_(amd64_linux_REDIR_FOR_vgettimeofday): 175 .LfnB2: 176 movq $__NR_gettimeofday, %rax 177 syscall 178 ret 179 .LfnE2: 180 .size VG_(amd64_linux_REDIR_FOR_vgettimeofday), .-.LfnB2 181 182 .global VG_(amd64_linux_REDIR_FOR_vtime) 183 .type VG_(amd64_linux_REDIR_FOR_vtime), @function 184 VG_(amd64_linux_REDIR_FOR_vtime): 185 .LfnB3: 186 movq $__NR_time, %rax 187 syscall 188 ret 189 .LfnE3: 190 .size VG_(amd64_linux_REDIR_FOR_vtime), .-.LfnB3 191 192 .global VG_(amd64_linux_REDIR_FOR_vgetcpu) 193 .type VG_(amd64_linux_REDIR_FOR_vgetcpu), @function 194 VG_(amd64_linux_REDIR_FOR_vgetcpu): 195 .LfnB4: 196 movq $__NR_getcpu, %rax 197 syscall 198 ret 199 .LfnE4: 200 .size VG_(amd64_linux_REDIR_FOR_vgetcpu), .-.LfnB4 201 202 /* There's no particular reason that this needs to be handwritten 203 assembly, but since that's what this file contains, here's a 204 simple strlen implementation (written in C and compiled by gcc.) 205 */ 206 .global VG_(amd64_linux_REDIR_FOR_strlen) 207 .type VG_(amd64_linux_REDIR_FOR_strlen), @function 208 VG_(amd64_linux_REDIR_FOR_strlen): 209 .LfnB5: 210 xorl %eax, %eax 211 cmpb $0, (%rdi) 212 movq %rdi, %rdx 213 je .L41 214 .L40: addq $1, %rdx 215 cmpb $0, (%rdx) 216 jne .L40 217 movq %rdx, %rax 218 subq %rdi, %rax 219 .L41: ret 220 .LfnE5: 221 .size VG_(amd64_linux_REDIR_FOR_strlen), .-VG_(amd64_linux_REDIR_FOR_strlen) 222 223 .global VG_(amd64_linux_REDIR_FOR_index) 224 .type VG_(amd64_linux_REDIR_FOR_index), @function 225 VG_(amd64_linux_REDIR_FOR_index): 226 movzbl (%rdi), %eax 227 movl %esi, %edx 228 cmpb %sil, %al 229 jne .L4 230 jmp .L5 231 .L10: 232 addq $1, %rdi 233 movzbl (%rdi), %eax 234 cmpb %dl, %al 235 je .L5 236 .L4: 237 testb %al, %al 238 jne .L10 239 xorl %eax, %eax 240 ret 241 .L5: 242 movq %rdi, %rax 243 ret 244 .size VG_(amd64_linux_REDIR_FOR_index), .-VG_(amd64_linux_REDIR_FOR_index) 245 246 247 248 /* A CIE for the above four functions, followed by their FDEs */ 249 .section .eh_frame,"a",@progbits 250 .Lframe1: 251 .long .LEcie1-.LScie1 252 .LScie1: 253 .long 0x0 254 .byte 0x1 255 .string "zR" 256 .uleb128 0x1 257 .sleb128 -8 258 .byte 0x10 259 .uleb128 0x1 260 .byte 0x3 261 .byte 0xc 262 .uleb128 0x7 263 .uleb128 0x8 264 .byte 0x90 265 .uleb128 0x1 266 .align 8 267 .LEcie1: 268 .LSfde2: 269 .long .LEfde2-.LASfde2 270 .LASfde2: 271 .long .LASfde2-.Lframe1 272 .long .LfnB2 273 .long .LfnE2-.LfnB2 274 .uleb128 0x0 275 .align 8 276 .LEfde2: 277 .LSfde3: 278 .long .LEfde3-.LASfde3 279 .LASfde3: 280 .long .LASfde3-.Lframe1 281 .long .LfnB3 282 .long .LfnE3-.LfnB3 283 .uleb128 0x0 284 .align 8 285 .LEfde3: 286 .LSfde4: 287 .long .LEfde4-.LASfde4 288 .LASfde4: 289 .long .LASfde4-.Lframe1 290 .long .LfnB4 291 .long .LfnE4-.LfnB4 292 .uleb128 0x0 293 .align 8 294 .LEfde4: 295 .LSfde5: 296 .long .LEfde5-.LASfde5 297 .LASfde5: 298 .long .LASfde5-.Lframe1 299 .long .LfnB5 300 .long .LfnE5-.LfnB5 301 .uleb128 0x0 302 .align 8 303 .LEfde5: 304 .previous 305 306 .global VG_(trampoline_stuff_end) 307 VG_(trampoline_stuff_end): 308 309 /* and a trailing page of unexecutable code */ 310 UD2_PAGE 311 312 # undef UD2_16 313 # undef UD2_64 314 # undef UD2_256 315 # undef UD2_1024 316 # undef UD2_PAGE 317 318 /*---------------- ppc32-linux ----------------*/ 319 #else 320 #if defined(VGP_ppc32_linux) 321 322 # define UD2_16 trap ; trap ; trap; trap 323 # define UD2_64 UD2_16 ; UD2_16 ; UD2_16 ; UD2_16 324 # define UD2_256 UD2_64 ; UD2_64 ; UD2_64 ; UD2_64 325 # define UD2_1024 UD2_256 ; UD2_256 ; UD2_256 ; UD2_256 326 # define UD2_PAGE UD2_1024 ; UD2_1024 ; UD2_1024 ; UD2_1024 327 328 /* a leading page of unexecutable code */ 329 UD2_PAGE 330 331 .global VG_(trampoline_stuff_start) 332 VG_(trampoline_stuff_start): 333 334 .global VG_(ppc32_linux_SUBST_FOR_sigreturn) 335 VG_(ppc32_linux_SUBST_FOR_sigreturn): 336 li 0,__NR_sigreturn 337 sc 338 .long 0 /*illegal insn*/ 339 340 .global VG_(ppc32_linux_SUBST_FOR_rt_sigreturn) 341 VG_(ppc32_linux_SUBST_FOR_rt_sigreturn): 342 li 0,__NR_rt_sigreturn 343 sc 344 .long 0 /*illegal insn*/ 345 346 /* There's no particular reason that this needs to be handwritten 347 assembly, but since that's what this file contains, here's a 348 simple strlen implementation (written in C and compiled by gcc.) 349 */ 350 .global VG_(ppc32_linux_REDIR_FOR_strlen) 351 .type VG_(ppc32_linux_REDIR_FOR_strlen), @function 352 VG_(ppc32_linux_REDIR_FOR_strlen): 353 lbz 4,0(3) 354 li 9,0 355 cmpwi 0,4,0 356 beq- 0,.L18 357 .L19: 358 lbzu 5,1(3) 359 addi 9,9,1 360 cmpwi 0,5,0 361 bne+ 0,.L19 362 .L18: 363 mr 3,9 364 blr 365 .size VG_(ppc32_linux_REDIR_FOR_strlen), .-VG_(ppc32_linux_REDIR_FOR_strlen) 366 367 /* Ditto strcmp */ 368 .global VG_(ppc32_linux_REDIR_FOR_strcmp) 369 .type VG_(ppc32_linux_REDIR_FOR_strcmp), @function 370 VG_(ppc32_linux_REDIR_FOR_strcmp): 371 .L20: 372 lbz 0,0(3) 373 cmpwi 7,0,0 374 bne- 7,.L21 375 lbz 0,0(4) 376 li 11,0 377 cmpwi 7,0,0 378 beq- 7,.L22 379 .L21: 380 lbz 0,0(3) 381 li 11,-1 382 cmpwi 7,0,0 383 beq- 7,.L22 384 lbz 0,0(4) 385 li 11,1 386 cmpwi 7,0,0 387 beq- 7,.L22 388 lbz 9,0(3) 389 lbz 0,0(4) 390 li 11,-1 391 cmplw 7,9,0 392 blt- 7,.L22 393 lbz 9,0(3) 394 lbz 0,0(4) 395 li 11,1 396 addi 3,3,1 397 addi 4,4,1 398 cmplw 7,9,0 399 ble+ 7,.L20 400 .L22: 401 mr 3,11 402 blr 403 .size VG_(ppc32_linux_REDIR_FOR_strcmp), .-VG_(ppc32_linux_REDIR_FOR_strcmp) 404 405 /* Ditto index/strchr */ 406 .global VG_(ppc32_linux_REDIR_FOR_strchr) 407 .type VG_(ppc32_linux_REDIR_FOR_strchr), @function 408 VG_(ppc32_linux_REDIR_FOR_strchr): 409 lbz 0,0(3) 410 rlwinm 4,4,0,0xff 411 cmpw 7,4,0 412 beqlr 7 413 cmpwi 7,0,0 414 bne 7,.L308 415 b .L304 416 .L309: 417 beq 6,.L304 418 .L308: 419 lbzu 0,1(3) 420 cmpw 7,4,0 421 cmpwi 6,0,0 422 bne 7,.L309 423 blr 424 .L304: 425 li 3,0 426 blr 427 .size VG_(ppc32_linux_REDIR_FOR_strchr),.-VG_(ppc32_linux_REDIR_FOR_strchr) 428 429 .global VG_(trampoline_stuff_end) 430 VG_(trampoline_stuff_end): 431 432 /* and a trailing page of unexecutable code */ 433 UD2_PAGE 434 435 # undef UD2_16 436 # undef UD2_64 437 # undef UD2_256 438 # undef UD2_1024 439 # undef UD2_PAGE 440 441 /*---------------- ppc64-linux ----------------*/ 442 #else 443 #if defined(VGP_ppc64be_linux) || defined(VGP_ppc64le_linux) 444 445 # define UD2_16 trap ; trap ; trap; trap 446 # define UD2_64 UD2_16 ; UD2_16 ; UD2_16 ; UD2_16 447 # define UD2_256 UD2_64 ; UD2_64 ; UD2_64 ; UD2_64 448 # define UD2_1024 UD2_256 ; UD2_256 ; UD2_256 ; UD2_256 449 # define UD2_PAGE UD2_1024 ; UD2_1024 ; UD2_1024 ; UD2_1024 450 451 /* a leading page of unexecutable code */ 452 UD2_PAGE 453 454 .global VG_(trampoline_stuff_start) 455 VG_(trampoline_stuff_start): 456 457 .global VG_(ppc64_linux_SUBST_FOR_rt_sigreturn) 458 VG_(ppc64_linux_SUBST_FOR_rt_sigreturn): 459 li 0,__NR_rt_sigreturn 460 sc 461 .long 0 /*illegal insn*/ 462 463 /* See comment in pub_core_trampoline.h for what this is for */ 464 .global VG_(ppctoc_magic_redirect_return_stub) 465 VG_(ppctoc_magic_redirect_return_stub): 466 trap 467 468 /* this function is written using the "dotless" ABI convention */ 469 .align 2 470 .globl VG_(ppc64_linux_REDIR_FOR_strlen) 471 #if !defined VGP_ppc64be_linux || _CALL_ELF == 2 472 /* Little Endian uses ELF version 2 */ 473 .type VG_(ppc64_linux_REDIR_FOR_strlen),@function 474 VG_(ppc64_linux_REDIR_FOR_strlen): 475 #else 476 /* Big Endian uses ELF version 1 */ 477 .section ".opd","aw" 478 .align 3 479 VG_(ppc64_linux_REDIR_FOR_strlen): 480 .quad .L.VG_(ppc64_linux_REDIR_FOR_strlen),.TOC.@tocbase,0 481 .previous 482 .size VG_(ppc64_linux_REDIR_FOR_strlen), \ 483 .L0end-.L.VG_(ppc64_linux_REDIR_FOR_strlen) 484 .type VG_(ppc64_linux_REDIR_FOR_strlen), @function 485 486 .L.VG_(ppc64_linux_REDIR_FOR_strlen): 487 #endif 488 #if _CALL_ELF == 2 489 0: addis 2,12,.TOC.-0b@ha 490 addi 2,2,.TOC.-0b@l 491 .localentry VG_(ppc64_linux_REDIR_FOR_strlen), .-VG_(ppc64_linux_REDIR_FOR_strlen) 492 #endif 493 mr 9,3 494 lbz 0,0(3) 495 li 3,0 496 cmpwi 7,0,0 497 beqlr 7 498 li 3,0 499 .L01: 500 addi 0,3,1 501 extsw 3,0 502 lbzx 0,9,3 503 cmpwi 7,0,0 504 bne 7,.L01 505 blr 506 507 #if !defined VGP_ppc64be_linux || _CALL_ELF == 2 508 .size VG_(ppc64_linux_REDIR_FOR_strlen),.-VG_(ppc64_linux_REDIR_FOR_strlen) 509 #else 510 .size VG_(ppc64_linux_REDIR_FOR_strlen),.-.L.VG_(ppc64_linux_REDIR_FOR_strlen) 511 #endif 512 .long 0 513 .byte 0,0,0,0,0,0,0,0 514 .L0end: 515 516 /* this function is written using the "dotless" ABI convention */ 517 .align 2 518 .globl VG_(ppc64_linux_REDIR_FOR_strchr) 519 #if !defined VGP_ppc64be_linux || _CALL_ELF == 2 520 .type VG_(ppc64_linux_REDIR_FOR_strchr),@function 521 VG_(ppc64_linux_REDIR_FOR_strchr): 522 #else 523 .section ".opd","aw" 524 .align 3 525 VG_(ppc64_linux_REDIR_FOR_strchr): 526 .quad .L.VG_(ppc64_linux_REDIR_FOR_strchr),.TOC.@tocbase,0 527 .previous 528 .size VG_(ppc64_linux_REDIR_FOR_strchr), \ 529 .L1end-.L.VG_(ppc64_linux_REDIR_FOR_strchr) 530 .type VG_(ppc64_linux_REDIR_FOR_strchr),@function 531 532 .L.VG_(ppc64_linux_REDIR_FOR_strchr): 533 #endif 534 #if _CALL_ELF == 2 535 0: addis 2,12,.TOC.-0b@ha 536 addi 2,2,.TOC.-0b@l 537 .localentry VG_(ppc64_linux_REDIR_FOR_strchr), .-VG_(ppc64_linux_REDIR_FOR_strchr) 538 #endif 539 lbz 0,0(3) 540 rldicl 4,4,0,56 541 cmpw 7,4,0 542 beqlr 7 543 cmpdi 7,0,0 544 bne 7,.L18 545 b .L14 546 #if !defined VGP_ppc64be_linux || _CALL_ELF == 2 547 .size VG_(ppc64_linux_REDIR_FOR_strchr),.-VG_(ppc64_linux_REDIR_FOR_strchr) 548 #else 549 .size VG_(ppc64_linux_REDIR_FOR_strchr),.-.L.VG_(ppc64_linux_REDIR_FOR_strchr) 550 #endif 551 .L19: 552 beq 6,.L14 553 .L18: 554 lbzu 0,1(3) 555 cmpw 7,4,0 556 cmpdi 6,0,0 557 bne 7,.L19 558 blr 559 .L14: 560 li 3,0 561 blr 562 .long 0 563 .byte 0,0,0,0,0,0,0,0 564 .L1end: 565 566 567 .global VG_(trampoline_stuff_end) 568 VG_(trampoline_stuff_end): 569 570 /* and a trailing page of unexecutable code */ 571 UD2_PAGE 572 573 # undef UD2_16 574 # undef UD2_64 575 # undef UD2_256 576 # undef UD2_1024 577 # undef UD2_PAGE 578 579 /*---------------- arm-linux ----------------*/ 580 #else 581 #if defined(VGP_arm_linux) 582 583 # define UD2_4 .word 0xFFFFFFFF 584 # define UD2_16 UD2_4 ; UD2_4 ; UD2_4 ; UD2_4 585 # define UD2_64 UD2_16 ; UD2_16 ; UD2_16 ; UD2_16 586 # define UD2_256 UD2_64 ; UD2_64 ; UD2_64 ; UD2_64 587 # define UD2_1024 UD2_256 ; UD2_256 ; UD2_256 ; UD2_256 588 # define UD2_PAGE UD2_1024 ; UD2_1024 ; UD2_1024 ; UD2_1024 589 590 /* a leading page of unexecutable code */ 591 UD2_PAGE 592 593 .global VG_(trampoline_stuff_start) 594 VG_(trampoline_stuff_start): 595 596 .global VG_(arm_linux_SUBST_FOR_sigreturn) 597 .type VG_(arm_linux_SUBST_FOR_sigreturn),#function 598 VG_(arm_linux_SUBST_FOR_sigreturn): 599 mov r7, # __NR_sigreturn 600 svc #0 601 .long 0xFFFFFFFF /*illegal insn*/ 602 .size VG_(arm_linux_SUBST_FOR_sigreturn), .-VG_(arm_linux_SUBST_FOR_sigreturn) 603 604 .global VG_(arm_linux_SUBST_FOR_rt_sigreturn) 605 .type VG_(arm_linux_SUBST_FOR_rt_sigreturn),#function 606 VG_(arm_linux_SUBST_FOR_rt_sigreturn): 607 mov r7, # __NR_rt_sigreturn 608 svc #0 609 .long 0xFFFFFFFF /*illegal insn*/ 610 .size VG_(arm_linux_SUBST_FOR_rt_sigreturn), .-VG_(arm_linux_SUBST_FOR_rt_sigreturn) 611 612 .global VG_(arm_linux_REDIR_FOR_strlen) 613 VG_(arm_linux_REDIR_FOR_strlen): 614 mov r2, r0 615 ldrb r0, [r0, #0] @ zero_extendqisi2 616 @ lr needed for prologue 617 cmp r0, #0 618 bxeq lr 619 mov r0, #0 620 .L5: 621 add r0, r0, #1 622 ldrb r3, [r0, r2] @ zero_extendqisi2 623 cmp r3, #0 624 bne .L5 625 bx lr 626 UD2_4 627 628 //.global VG_(arm_linux_REDIR_FOR_index) 629 //VG_(arm_linux_REDIR_FOR_index): 630 // ldrb r3, [r0, #0] @ zero_extendqisi2 631 // and r1, r1, #255 632 // cmp r3, r1 633 // @ lr needed for prologue 634 // bne .L9 635 // bx lr 636 //.L12: 637 // ldrb r3, [r0, #1]! @ zero_extendqisi2 638 // cmp r3, r1 639 // beq .L11 640 //.L9: 641 // cmp r3, #0 642 // bne .L12 643 // mov r0, #0 644 // bx lr 645 //.L11: 646 // bx lr 647 // UD2_4 648 649 .global VG_(arm_linux_REDIR_FOR_memcpy) 650 VG_(arm_linux_REDIR_FOR_memcpy): 651 stmfd sp!, {r4, r5, lr} 652 subs lr, r2, #0 653 mov r5, r0 654 beq .L2 655 cmp r0, r1 656 bls .L4 657 add r3, r0, lr 658 add r1, lr, r1 659 cmp lr, #3 660 sub r4, r3, #1 661 sub r0, r1, #1 662 ble .L28 663 sub ip, r3, #5 664 sub r1, r1, #5 665 .L8: 666 ldrb r3, [r1, #4] @ zero_extendqisi2 667 sub lr, lr, #4 668 strb r3, [ip, #4] 669 ldrb r2, [r1, #3] @ zero_extendqisi2 670 cmp lr, #3 671 strb r2, [ip, #3] 672 ldrb r3, [r1, #2] @ zero_extendqisi2 673 mov r4, ip 674 strb r3, [ip, #2] 675 ldrb r2, [r1, #1] @ zero_extendqisi2 676 mov r0, r1 677 strb r2, [ip, #1] 678 sub r1, r1, #4 679 sub ip, ip, #4 680 bgt .L8 681 cmp lr, #0 682 beq .L2 683 .L28: 684 sub r2, lr, #1 685 .L21: 686 sub r2, r2, #1 687 ldrb r3, [r0], #-1 @ zero_extendqisi2 688 cmn r2, #1 689 strb r3, [r4], #-1 690 bne .L21 691 .L2: 692 mov r0, r5 693 ldmfd sp!, {r4, r5, pc} 694 .L4: 695 bcs .L2 696 cmp lr, #3 697 mov ip, r0 698 ble .L29 699 .L19: 700 ldrb r3, [r1, #0] @ zero_extendqisi2 701 sub lr, lr, #4 702 strb r3, [ip, #0] 703 ldrb r2, [r1, #1] @ zero_extendqisi2 704 cmp lr, #3 705 strb r2, [ip, #1] 706 ldrb r3, [r1, #2] @ zero_extendqisi2 707 strb r3, [ip, #2] 708 ldrb r2, [r1, #3] @ zero_extendqisi2 709 add r1, r1, #4 710 strb r2, [ip, #3] 711 add ip, ip, #4 712 bgt .L19 713 cmp lr, #0 714 beq .L2 715 .L29: 716 sub r2, lr, #1 717 .L20: 718 sub r2, r2, #1 719 ldrb r3, [r1], #1 @ zero_extendqisi2 720 cmn r2, #1 721 strb r3, [ip], #1 722 bne .L20 723 mov r0, r5 724 ldmfd sp!, {r4, r5, pc} 725 UD2_4 726 727 .global VG_(arm_linux_REDIR_FOR_strcmp) 728 VG_(arm_linux_REDIR_FOR_strcmp): 729 .L64: 730 ldrb r3, [r0], #1 @ zero_extendqisi2 731 ldrb r2, [r1], #1 @ zero_extendqisi2 732 cmp r3, #0 733 beq .L67 734 cmp r3, r2 735 beq .L64 736 rsb r0, r2, r3 737 bx lr 738 .L67: 739 rsb r0, r2, #0 740 bx lr 741 UD2_4 742 743 .global VG_(trampoline_stuff_end) 744 VG_(trampoline_stuff_end): 745 746 /* and a trailing page of unexecutable code */ 747 UD2_PAGE 748 749 # undef UD2_4 750 # undef UD2_16 751 # undef UD2_64 752 # undef UD2_256 753 # undef UD2_1024 754 # undef UD2_PAGE 755 756 /*---------------- arm64-linux ----------------*/ 757 #else 758 #if defined(VGP_arm64_linux) 759 760 # define UD2_4 .word 0xFFFFFFFF 761 # define UD2_16 UD2_4 ; UD2_4 ; UD2_4 ; UD2_4 762 # define UD2_64 UD2_16 ; UD2_16 ; UD2_16 ; UD2_16 763 # define UD2_256 UD2_64 ; UD2_64 ; UD2_64 ; UD2_64 764 # define UD2_1024 UD2_256 ; UD2_256 ; UD2_256 ; UD2_256 765 # define UD2_PAGE UD2_1024 ; UD2_1024 ; UD2_1024 ; UD2_1024 766 767 /* a leading page of unexecutable code */ 768 UD2_PAGE 769 770 .global VG_(trampoline_stuff_start) 771 VG_(trampoline_stuff_start): 772 773 .global VG_(arm64_linux_SUBST_FOR_rt_sigreturn) 774 .type VG_(arm64_linux_SUBST_FOR_rt_sigreturn),#function 775 VG_(arm64_linux_SUBST_FOR_rt_sigreturn): 776 mov x8, # __NR_rt_sigreturn 777 svc #0 778 .long 0xFFFFFFFF /*illegal insn*/ 779 .size VG_(arm64_linux_SUBST_FOR_rt_sigreturn), \ 780 .-VG_(arm64_linux_SUBST_FOR_rt_sigreturn) 781 782 .global VG_(arm64_linux_REDIR_FOR_strlen) 783 .type VG_(arm64_linux_REDIR_FOR_strlen),#function 784 VG_(arm64_linux_REDIR_FOR_strlen): 785 mov x2, x0 786 ldrb w0, [x0] 787 cbz w0, .L5 788 mov x0, 0 789 .L4: 790 add x0, x0, 1 791 ldrb w1, [x2,x0] 792 cbnz w1, .L4 793 ret 794 .L5: 795 mov x0, 0 796 ret 797 .size VG_(arm64_linux_REDIR_FOR_strlen), .-VG_(arm64_linux_REDIR_FOR_strlen) 798 799 .global VG_(arm64_linux_REDIR_FOR_index) 800 .type VG_(arm64_linux_REDIR_FOR_index),#function 801 VG_(arm64_linux_REDIR_FOR_index): 802 ldrb w2, [x0] 803 uxtb w1, w1 804 cmp w2, w1 805 beq .L11 806 .L13: 807 cbz w2, .L16 808 ldrb w2, [x0,1]! 809 cmp w2, w1 810 bne .L13 811 .L11: 812 ret 813 .L16: 814 mov x0, 0 815 ret 816 .size VG_(arm64_linux_REDIR_FOR_index), .-VG_(arm64_linux_REDIR_FOR_index) 817 818 .global VG_(arm64_linux_REDIR_FOR_strcmp) 819 .type VG_(arm64_linux_REDIR_FOR_strcmp),#function 820 VG_(arm64_linux_REDIR_FOR_strcmp): 821 ldrb w2, [x0] 822 ldrb w3, [x1] 823 cmp w2, w3 824 bcc .L22 825 .L21: 826 bhi .L25 827 cbz w2, .L26 828 ldrb w2, [x0,1]! 829 ldrb w3, [x1,1]! 830 cmp w2, w3 831 bcs .L21 832 .L22: 833 mov x0, -1 834 ret 835 .L25: 836 mov x0, 1 837 ret 838 .L26: 839 mov x0, 0 840 ret 841 .size VG_(arm64_linux_REDIR_FOR_strcmp), .-VG_(arm64_linux_REDIR_FOR_strcmp) 842 843 .global VG_(trampoline_stuff_end) 844 VG_(trampoline_stuff_end): 845 846 /* and a trailing page of unexecutable code */ 847 UD2_PAGE 848 849 # undef UD2_4 850 # undef UD2_16 851 # undef UD2_64 852 # undef UD2_256 853 # undef UD2_1024 854 # undef UD2_PAGE 855 856 /*---------------- x86-darwin ----------------*/ 857 #else 858 #if defined(VGP_x86_darwin) 859 860 /* a leading page of unexecutable code */ 861 .fill 2048, 2, 0x0b0f /* `ud2` */ 862 863 .globl VG_(trampoline_stuff_start) 864 VG_(trampoline_stuff_start): 865 866 .globl VG_(x86_darwin_SUBST_FOR_sigreturn) 867 VG_(x86_darwin_SUBST_FOR_sigreturn): 868 /* XXX does this need to have any special form? (cf x86-linux 869 version) */ 870 movl $ __NR_DARWIN_FAKE_SIGRETURN, %eax 871 int $0x80 872 ud2 873 874 .globl VG_(x86_darwin_REDIR_FOR_strlen) 875 VG_(x86_darwin_REDIR_FOR_strlen): 876 movl 4(%esp), %edx 877 movl %edx, %eax 878 jmp 1f 879 0: 880 incl %eax 881 1: 882 cmpb $0, (%eax) 883 jne 0b 884 subl %edx, %eax 885 ret 886 887 .globl VG_(x86_darwin_REDIR_FOR_strcat) 888 VG_(x86_darwin_REDIR_FOR_strcat): 889 pushl %esi 890 movl 8(%esp), %esi 891 movl 12(%esp), %ecx 892 movl %esi, %edx 893 jmp 1f 894 0: 895 incl %edx 896 1: 897 cmpb $0, (%edx) 898 jne 0b 899 2: 900 movzbl (%ecx), %eax 901 incl %ecx 902 movb %al, (%edx) 903 incl %edx 904 testb %al, %al 905 jne 2b 906 movl %esi, %eax 907 popl %esi 908 ret 909 910 911 .globl VG_(x86_darwin_REDIR_FOR_strcmp) 912 VG_(x86_darwin_REDIR_FOR_strcmp): 913 movl 4(%esp), %edx 914 movl 8(%esp), %ecx 915 jmp 1f 916 0: 917 incl %edx 918 incl %ecx 919 1: 920 movzbl (%edx), %eax 921 testb %al, %al 922 je 2f 923 cmpb (%ecx), %al 924 je 0b 925 2: 926 movzbl (%ecx),%edx 927 movzbl %al,%eax 928 subl %edx, %eax 929 ret 930 931 932 .globl VG_(x86_darwin_REDIR_FOR_strcpy) 933 VG_(x86_darwin_REDIR_FOR_strcpy): 934 pushl %ebp 935 movl %esp, %ebp 936 pushl %esi 937 movl 8(%ebp), %esi 938 movl 12(%ebp), %ecx 939 movl %esi, %edx 940 jmp 1f 941 0: 942 incl %ecx 943 incl %edx 944 1: 945 movzbl (%ecx), %eax 946 testb %al, %al 947 movb %al, (%edx) 948 jne 0b 949 movl %esi, %eax 950 popl %esi 951 leave 952 ret 953 954 .globl VG_(x86_darwin_REDIR_FOR_strlcat) 955 VG_(x86_darwin_REDIR_FOR_strlcat): 956 pushl %ebp 957 movl %esp, %ebp 958 pushl %edi 959 pushl %esi 960 subl $16, %esp 961 movl 8(%ebp), %esi 962 movl 16(%ebp), %ecx 963 movl %esi, %edx 964 leal (%ecx,%esi), %eax 965 jmp 1f 966 0: 967 incl %edx 968 1: 969 cmpl %edx, %eax 970 je 2f 971 cmpb $0, (%edx) 972 jne 0b 973 2: 974 movl %edx, %edi 975 subl %esi, %edi 976 movl %ecx, %esi 977 subl %edi, %esi 978 je 3f 979 movl 12(%ebp), %eax 980 jmp 6f 981 3: 982 movl 12(%ebp), %eax 983 movl %eax, (%esp) 984 call VG_(x86_darwin_REDIR_FOR_strlen) 985 jmp 7f 986 4: 987 cmpl $1, %esi 988 je 5f 989 movb %cl, (%edx) 990 decl %esi 991 incl %edx 992 5: 993 incl %eax 994 6: 995 movzbl (%eax), %ecx 996 testb %cl, %cl 997 jne 4b 998 movb $0, (%edx) 999 subl 12(%ebp), %eax 1000 7: 1001 addl $16, %esp 1002 leal (%edi,%eax), %eax 1003 popl %esi 1004 popl %edi 1005 leave 1006 ret 1007 1008 1009 .globl VG_(trampoline_stuff_end) 1010 VG_(trampoline_stuff_end): 1011 1012 /* a trailing page of unexecutable code */ 1013 .fill 2048, 2, 0x0b0f /* `ud2` */ 1014 1015 1016 /*---------------- amd64-darwin ----------------*/ 1017 #else 1018 #if defined(VGP_amd64_darwin) 1019 1020 /* a leading page of unexecutable code */ 1021 .fill 2048, 2, 0x0b0f /* `ud2` */ 1022 1023 .globl VG_(trampoline_stuff_start) 1024 VG_(trampoline_stuff_start): 1025 1026 .globl VG_(amd64_darwin_SUBST_FOR_sigreturn) 1027 VG_(amd64_darwin_SUBST_FOR_sigreturn): 1028 /* XXX does this need to have any special form? (cf x86-linux 1029 version) */ 1030 movq $ __NR_DARWIN_FAKE_SIGRETURN, %rax 1031 syscall 1032 ud2 1033 1034 .globl VG_(amd64_darwin_REDIR_FOR_strlen) 1035 VG_(amd64_darwin_REDIR_FOR_strlen): 1036 movq %rdi, %rax 1037 jmp 1f 1038 0: 1039 incq %rax 1040 1: 1041 cmpb $0, (%rax) 1042 jne 0b 1043 subq %rdi, %rax 1044 ret 1045 1046 .globl VG_(amd64_darwin_REDIR_FOR_strcat) 1047 VG_(amd64_darwin_REDIR_FOR_strcat): 1048 movq %rdi, %rdx 1049 jmp 1f 1050 0: 1051 incq %rdx 1052 1: 1053 cmpb $0, (%rdx) 1054 jne 0b 1055 2: 1056 movzbl (%rsi), %eax 1057 incq %rsi 1058 movb %al, (%rdx) 1059 incq %rdx 1060 testb %al, %al 1061 jne 2b 1062 movq %rdi, %rax 1063 ret 1064 1065 1066 .globl VG_(amd64_darwin_REDIR_FOR_strcmp) 1067 VG_(amd64_darwin_REDIR_FOR_strcmp): 1068 jmp 1f 1069 0: 1070 incq %rdi 1071 incq %rsi 1072 1: 1073 movzbl (%rdi), %eax 1074 testb %al, %al 1075 je 2f 1076 cmpb (%rsi), %al 1077 je 0b 1078 2: 1079 movzbl (%rsi), %edx 1080 movzbl %al, %eax 1081 subl %edx, %eax 1082 ret 1083 1084 .globl VG_(amd64_darwin_REDIR_FOR_strcpy) 1085 VG_(amd64_darwin_REDIR_FOR_strcpy): 1086 pushq %rbp 1087 movq %rdi, %rdx 1088 movq %rsp, %rbp 1089 jmp 1f 1090 0: 1091 incq %rsi 1092 incq %rdx 1093 1: 1094 movzbl (%rsi), %eax 1095 testb %al, %al 1096 movb %al, (%rdx) 1097 jne 0b 1098 leave 1099 movq %rdi, %rax 1100 ret 1101 1102 .globl VG_(amd64_darwin_REDIR_FOR_strlcat) 1103 VG_(amd64_darwin_REDIR_FOR_strlcat): 1104 pushq %rbp 1105 leaq (%rdx,%rdi), %rax 1106 movq %rdi, %rcx 1107 movq %rsp, %rbp 1108 pushq %rbx 1109 subq $8, %rsp 1110 jmp 1f 1111 0: 1112 incq %rcx 1113 1: 1114 cmpq %rcx, %rax 1115 je 2f 1116 cmpb $0, (%rcx) 1117 jne 0b 1118 2: 1119 movq %rcx, %rbx 1120 subq %rdi, %rbx 1121 movq %rdx, %rdi 1122 subq %rbx, %rdi 1123 je 3f 1124 movq %rsi, %rax 1125 jmp 6f 1126 3: 1127 movq %rsi, %rdi 1128 call VG_(amd64_darwin_REDIR_FOR_strlen) 1129 jmp 7f 1130 4: 1131 cmpq $1, %rdi 1132 je 5f 1133 movb %dl, (%rcx) 1134 decq %rdi 1135 incq %rcx 1136 5: 1137 incq %rax 1138 6: 1139 movzbl (%rax), %edx 1140 testb %dl, %dl 1141 jne 4b 1142 movb $0, (%rcx) 1143 subq %rsi, %rax 1144 7: 1145 leaq (%rbx,%rax), %rax 1146 addq $8, %rsp 1147 popq %rbx 1148 leave 1149 ret 1150 1151 .globl VG_(amd64_darwin_REDIR_FOR_arc4random) 1152 VG_(amd64_darwin_REDIR_FOR_arc4random): 1153 /* not very random, hope dyld won't mind */ 1154 movq $0x76616c6772696e64, %rax 1155 ret 1156 1157 .globl VG_(amd64_darwin_REDIR_FOR_strchr) 1158 VG_(amd64_darwin_REDIR_FOR_strchr): 1159 pushq %rbp 1160 movq %rsp, %rbp 1161 movb (%rdi), %cl 1162 cmpb %sil, %cl 1163 jne 1f 1164 movq %rdi, %rax 1165 popq %rbp 1166 ret 1167 1: 1168 testb %cl, %cl 1169 movl $0, %eax 1170 je 2f 1171 movb 1(%rdi), %cl 1172 incq %rdi 1173 cmpb %sil, %cl 1174 movq %rdi, %rax 1175 jne 1b 1176 2: 1177 popq %rbp 1178 ret 1179 1180 .globl VG_(trampoline_stuff_end) 1181 VG_(trampoline_stuff_end): 1182 1183 /* a trailing page of unexecutable code */ 1184 .fill 2048, 2, 0x0b0f /* `ud2` */ 1185 1186 1187 /*---------------- s390x-linux ----------------*/ 1188 #else 1189 #if defined(VGP_s390x_linux) 1190 1191 /* a leading page of unexecutable code */ 1192 .fill 2048, 2, 0x0000 1193 1194 .global VG_(trampoline_stuff_start) 1195 VG_(trampoline_stuff_start): 1196 1197 .global VG_(s390x_linux_SUBST_FOR_sigreturn) 1198 VG_(s390x_linux_SUBST_FOR_sigreturn): 1199 svc __NR_sigreturn 1200 .short 0 1201 1202 .global VG_(s390x_linux_SUBST_FOR_rt_sigreturn) 1203 VG_(s390x_linux_SUBST_FOR_rt_sigreturn): 1204 /* Old gcc unwinding code checks for a sig(_rt)_return svc and then 1205 for ra = cfa to decide if it is a sig_rt_frame or not. Since we 1206 set ra to this trampoline, but the cfa is still in the stack, 1207 the unwinder thinks, that this is a non-rt frame and causes a 1208 crash in the gcc unwinder - which is used by the thread library 1209 and others. Therefore we add a lr 1,1 nop, to let the gcc 1210 unwinder bail out gracefully. This might also affect unwinding 1211 across the signal frame - tough luck. fixs390 */ 1212 lr 1,1 1213 svc __NR_rt_sigreturn 1214 .short 0 1215 1216 .global VG_(s390x_linux_REDIR_FOR_index) 1217 .type VG_(s390x_linux_REDIR_FOR_index),@function 1218 VG_(s390x_linux_REDIR_FOR_index): 1219 # 1220 # %r2 = address of string 1221 # %r3 = character to find 1222 # 1223 lghi %r0,255 1224 ngr %r0,%r3 # r0 = (unsigned char)r3 1225 lghi %r4,0 1226 .L1: 1227 llgc %r1,0(%r2) # r1 = byte from string 1228 cr %r1,%r0 # compare 1229 ber %r14 # return if found 1230 cr %r1,%r4 # end of string ? 1231 je .L2 1232 aghi %r2,1 # increment r2 1233 j .L1 1234 .L2: lghi %r2,0 # return value 0 1235 br %r14 1236 .size VG_(s390x_linux_REDIR_FOR_index), .-VG_(s390x_linux_REDIR_FOR_index) 1237 1238 .globl VG_(trampoline_stuff_end) 1239 VG_(trampoline_stuff_end): 1240 .fill 2048, 2, 0x0000 1241 1242 /*---------------------- mips32-linux ----------------------*/ 1243 #else 1244 #if defined(VGP_mips32_linux) 1245 1246 # define UD2_16 trap ; trap ; trap; trap 1247 # define UD2_64 UD2_16 ; UD2_16 ; UD2_16 ; UD2_16 1248 # define UD2_256 UD2_64 ; UD2_64 ; UD2_64 ; UD2_64 1249 # define UD2_1024 UD2_256 ; UD2_256 ; UD2_256 ; UD2_256 1250 # define UD2_PAGE UD2_1024 ; UD2_1024 ; UD2_1024 ; UD2_1024 1251 1252 1253 .global VG_(trampoline_stuff_start) 1254 VG_(trampoline_stuff_start): 1255 1256 .global VG_(mips32_linux_SUBST_FOR_sigreturn) 1257 VG_(mips32_linux_SUBST_FOR_sigreturn): 1258 li $v0,__NR_sigreturn 1259 syscall 1260 nop 1261 .long 0 /*illegal insn*/ 1262 1263 .global VG_(mips32_linux_SUBST_FOR_rt_sigreturn) 1264 VG_(mips32_linux_SUBST_FOR_rt_sigreturn): 1265 li $v0,__NR_rt_sigreturn 1266 syscall 1267 nop 1268 .long 0 /*illegal insn*/ 1269 1270 /* There's no particular reason that this needs to be handwritten 1271 assembly, but since that's what this file contains, here's a 1272 simple index() and strlen() implementations. 1273 */ 1274 1275 .set push 1276 .set noreorder 1277 1278 .global VG_(mips32_linux_REDIR_FOR_index) 1279 .type VG_(mips32_linux_REDIR_FOR_index), @function 1280 VG_(mips32_linux_REDIR_FOR_index): 1281 move $v0, $a0 1282 index_loop: 1283 lbu $t0, 0($v0) 1284 beq $t0, $a1, index_end 1285 nop 1286 bne $t0, $zero, index_loop 1287 addiu $v0, $v0, 1 1288 move $v0, $zero 1289 index_end: 1290 jr $ra 1291 nop 1292 .size VG_(mips32_linux_REDIR_FOR_index), .-VG_(mips32_linux_REDIR_FOR_index) 1293 1294 .global VG_(mips32_linux_REDIR_FOR_strlen) 1295 .type VG_(mips32_linux_REDIR_FOR_strlen), @function 1296 VG_(mips32_linux_REDIR_FOR_strlen): 1297 move $v0, $a0 1298 strlen_loop: 1299 lbu $t0, 0($a0) 1300 bne $t0, $zero, strlen_loop 1301 addiu $a0, $a0, 1 1302 subu $v0, $a0, $v0 1303 jr $ra 1304 addiu $v0, $v0, -1 1305 .size VG_(mips32_linux_REDIR_FOR_strlen), .-VG_(mips32_linux_REDIR_FOR_strlen) 1306 1307 .set pop 1308 1309 .global VG_(trampoline_stuff_end) 1310 VG_(trampoline_stuff_end): 1311 1312 1313 # undef UD2_16 1314 # undef UD2_64 1315 # undef UD2_256 1316 # undef UD2_1024 1317 # undef UD2_PAGE 1318 1319 /*---------------------- mips64-linux ----------------------*/ 1320 #else 1321 #if defined(VGP_mips64_linux) 1322 1323 # define UD2_16 trap ; trap ; trap; trap 1324 # define UD2_64 UD2_16 ; UD2_16 ; UD2_16 ; UD2_16 1325 # define UD2_256 UD2_64 ; UD2_64 ; UD2_64 ; UD2_64 1326 # define UD2_1024 UD2_256 ; UD2_256 ; UD2_256 ; UD2_256 1327 # define UD2_PAGE UD2_1024 ; UD2_1024 ; UD2_1024 ; UD2_1024 1328 1329 .global VG_(trampoline_stuff_start) 1330 VG_(trampoline_stuff_start): 1331 1332 .global VG_(mips64_linux_SUBST_FOR_rt_sigreturn) 1333 VG_(mips64_linux_SUBST_FOR_rt_sigreturn): 1334 li $2,__NR_rt_sigreturn 1335 syscall 1336 nop 1337 .long 0 /*illegal insn*/ 1338 1339 /* There's no particular reason that this needs to be handwritten 1340 assembly, but since that's what this file contains, here's a 1341 simple index() and strlen() implementations. 1342 */ 1343 1344 .set push 1345 .set noreorder 1346 1347 .global VG_(mips64_linux_REDIR_FOR_index) 1348 .type VG_(mips64_linux_REDIR_FOR_index), @function 1349 VG_(mips64_linux_REDIR_FOR_index): 1350 move $v0, $a0 1351 index_loop: 1352 lbu $t0, 0($v0) 1353 beq $t0, $a1, index_end 1354 nop 1355 bne $t0, $zero, index_loop 1356 daddiu $v0, $v0, 1 1357 move $v0, $zero 1358 index_end: 1359 jr $ra 1360 nop 1361 .size VG_(mips64_linux_REDIR_FOR_index), .-VG_(mips64_linux_REDIR_FOR_index) 1362 1363 .global VG_(mips64_linux_REDIR_FOR_strlen) 1364 .type VG_(mips64_linux_REDIR_FOR_strlen), @function 1365 VG_(mips64_linux_REDIR_FOR_strlen): 1366 move $v0, $a0 1367 strlen_loop: 1368 lbu $t0, 0($a0) 1369 bne $t0, $zero, strlen_loop 1370 daddiu $a0, $a0, 1 1371 dsubu $v0, $a0, $v0 1372 jr $ra 1373 daddiu $v0, $v0, -1 1374 .size VG_(mips64_linux_REDIR_FOR_strlen), .-VG_(mips64_linux_REDIR_FOR_strlen) 1375 1376 .set pop 1377 1378 .global VG_(trampoline_stuff_end) 1379 VG_(trampoline_stuff_end): 1380 1381 1382 # undef UD2_16 1383 # undef UD2_64 1384 # undef UD2_256 1385 # undef UD2_1024 1386 # undef UD2_PAGE 1387 1388 /*---------------- x86-solaris ----------------*/ 1389 #else 1390 #if defined(VGP_x86_solaris) 1391 1392 .global VG_(trampoline_stuff_start) 1393 VG_(trampoline_stuff_start): 1394 1395 /* int strcmp(const char *s1, const char *s2); */ 1396 .global VG_(x86_solaris_REDIR_FOR_strcmp) 1397 .type VG_(x86_solaris_REDIR_FOR_strcmp), @function 1398 VG_(x86_solaris_REDIR_FOR_strcmp): 1399 pushl %ebp /* establish a stack frame */ 1400 movl %esp, %ebp 1401 movl 8(%ebp), %edx /* get s1 */ 1402 movl 12(%esp), %ecx /* get s2 */ 1403 jmp 2f /* go compare the first characters */ 1404 1: 1405 incl %edx /* skip to the next s1 character */ 1406 incl %ecx /* skip to the next s2 character */ 1407 2: 1408 movzbl (%edx), %eax /* load a character from s1 */ 1409 testb %al, %al /* is it null? */ 1410 jz 3f /* yes, exit */ 1411 cmpb (%ecx), %al /* are the characters equal? */ 1412 je 1b /* yes, proceed with next characters */ 1413 3: 1414 movzbl (%ecx), %edx /* load a character from s2 */ 1415 subl %edx, %eax /* calculate the return value */ 1416 popl %ebp /* destroy the stack frame */ 1417 ret /* return to the caller */ 1418 .size VG_(x86_solaris_REDIR_FOR_strcmp), .-VG_(x86_solaris_REDIR_FOR_strcmp) 1419 1420 /* size_t strlen(const char *s); */ 1421 .global VG_(x86_solaris_REDIR_FOR_strlen) 1422 .type VG_(x86_solaris_REDIR_FOR_strlen), @function 1423 VG_(x86_solaris_REDIR_FOR_strlen): 1424 pushl %ebp /* establish a stack frame */ 1425 movl %esp, %ebp 1426 movl 8(%ebp), %edx /* get s */ 1427 movl %edx, %eax /* copy s */ 1428 jmp 2f /* go handle the first character */ 1429 1: 1430 incl %eax /* skip to the next s character */ 1431 2: 1432 cmpb $0, (%eax) /* is the s character null? */ 1433 jne 1b /* no, go process the next character */ 1434 subl %edx, %eax /* calculate the return value */ 1435 popl %ebp /* destroy the stack frame */ 1436 ret /* return to the caller */ 1437 .size VG_(x86_solaris_REDIR_FOR_strlen), .-VG_(x86_solaris_REDIR_FOR_strlen) 1438 1439 .global VG_(trampoline_stuff_end) 1440 VG_(trampoline_stuff_end): 1441 1442 /*---------------- amd64-solaris ----------------*/ 1443 #else 1444 #if defined(VGP_amd64_solaris) 1445 1446 .global VG_(trampoline_stuff_start) 1447 VG_(trampoline_stuff_start): 1448 1449 /* char *strcpy(char *restrict s1, const char *restrict s2); */ 1450 .global VG_(amd64_solaris_REDIR_FOR_strcpy) 1451 .type VG_(amd64_solaris_REDIR_FOR_strcpy), @function 1452 VG_(amd64_solaris_REDIR_FOR_strcpy): 1453 pushq %rbp /* establish a stack frame */ 1454 movq %rsp, %rbp 1455 movq %rdi, %rdx /* copy s1 */ 1456 1: 1457 movzbl (%rsi), %eax /* load one input character */ 1458 movb %al, (%rdx) /* copy to output/s1 */ 1459 incq %rsi /* skip to the next output character */ 1460 incq %rdx /* skip to the next input character */ 1461 testb %al, %al /* is the copied character null? */ 1462 jnz 1b /* no, copy the next character */ 1463 leave /* destroy the stack frame */ 1464 movq %rdi, %rax /* set s1 as the return value */ 1465 ret /* return to the caller */ 1466 .size VG_(amd64_solaris_REDIR_FOR_strcpy), .-VG_(amd64_solaris_REDIR_FOR_strcpy) 1467 1468 /* char *strncpy(char *restrict s1, const char *restrict s2, size_t n); */ 1469 .global VG_(amd64_solaris_REDIR_FOR_strncpy) 1470 .type VG_(amd64_solaris_REDIR_FOR_strncpy), @function 1471 VG_(amd64_solaris_REDIR_FOR_strncpy): 1472 pushq %rbp /* establish a stack frame */ 1473 movq %rsp, %rbp 1474 movq %rdi, %rcx /* copy s1 */ 1475 1: 1476 testq %rdx, %rdx /* is the remaining size zero? */ 1477 jz 3f /* yes, all done */ 1478 movzbl (%rsi), %eax /* load one input character */ 1479 movb %al, (%rcx) /* copy to output/s1 */ 1480 decq %rdx /* decrement the remaining size */ 1481 incq %rsi /* skip to the next output character */ 1482 incq %rcx /* skip to the next input character */ 1483 testb %al, %al /* is the copied character null? */ 1484 jnz 1b /* no, copy the next character */ 1485 2: 1486 testq %rdx, %rdx /* is the remaining size zero? */ 1487 jz 3f /* yes, all done */ 1488 movb $0, (%rdx) /* copy null to output/s2 */ 1489 decq %rdx /* decrement the remaining size */ 1490 incq %rsi /* skip to next output character */ 1491 jmp 2b /* proceed with the next character */ 1492 3: 1493 leave /* destroy the stack frame */ 1494 movq %rdi, %rax /* set s1 as the return value */ 1495 ret /* return to the caller */ 1496 .size VG_(amd64_solaris_REDIR_FOR_strncpy), .-VG_(amd64_solaris_REDIR_FOR_strncpy) 1497 1498 /* int strcmp(const char *s1, const char *s2); */ 1499 .global VG_(amd64_solaris_REDIR_FOR_strcmp) 1500 .type VG_(amd64_solaris_REDIR_FOR_strcmp), @function 1501 VG_(amd64_solaris_REDIR_FOR_strcmp): 1502 pushq %rbp /* establish a stack frame */ 1503 movq %rsp, %rbp 1504 jmp 2f /* go compare the first characters */ 1505 1: 1506 incq %rdi /* skip to the next s1 character */ 1507 incq %rsi /* skip to the next s2 character */ 1508 2: 1509 movzbl (%rdi), %eax /* load a character from s1 */ 1510 testb %al, %al /* is it null? */ 1511 jz 3f /* yes, exit */ 1512 cmpb (%rsi), %al /* are the characters equal? */ 1513 je 1b /* yes, proceed with next characters */ 1514 3: 1515 movzbl (%rsi), %edx /* load a character from s2 */ 1516 subl %edx, %eax /* calculate the return value */ 1517 leave /* destroy the stack frame */ 1518 ret /* return to the caller */ 1519 .size VG_(amd64_solaris_REDIR_FOR_strcmp), .-VG_(amd64_solaris_REDIR_FOR_strcmp) 1520 1521 /* char *strcat(char *restrict s1, const char *restrict s2); */ 1522 .global VG_(amd64_solaris_REDIR_FOR_strcat) 1523 .type VG_(amd64_solaris_REDIR_FOR_strcat), @function 1524 VG_(amd64_solaris_REDIR_FOR_strcat): 1525 pushq %rbp /* establish a stack frame */ 1526 movq %rsp, %rbp 1527 movq %rdi, %rdx /* copy s1 */ 1528 jmp 2f /* go handle the first character */ 1529 1: 1530 incq %rdx /* skip to the next s1 character */ 1531 2: 1532 cmpb $0, (%rdx) /* is the s1 character null? */ 1533 jne 1b /* no, go check the next character */ 1534 3: 1535 movzbl (%rsi), %eax /* load a character from s2 */ 1536 movb %al, (%rdx) /* copy the s2 character to s1 */ 1537 incq %rdx /* skip to the next s1 character */ 1538 incq %rsi /* skip to the next s2 character */ 1539 testb %al, %al /* was the character null? */ 1540 jnz 3b /* no, go copy the next character */ 1541 movq %rdi, %rax /* set s1 as the return value */ 1542 leave /* destroy the stack frame */ 1543 ret /* return to the caller */ 1544 .size VG_(amd64_solaris_REDIR_FOR_strcat), .-VG_(amd64_solaris_REDIR_FOR_strcat) 1545 1546 /* size_t strlen(const char *s); */ 1547 .global VG_(amd64_solaris_REDIR_FOR_strlen) 1548 .type VG_(amd64_solaris_REDIR_FOR_strlen), @function 1549 VG_(amd64_solaris_REDIR_FOR_strlen): 1550 pushq %rbp /* establish a stack frame */ 1551 movq %rsp, %rbp 1552 movq %rdi, %rax /* copy s */ 1553 jmp 2f /* go handle the first character */ 1554 1: 1555 incq %rax /* skip to the next s character */ 1556 2: 1557 cmpb $0, (%rax) /* is the s character null? */ 1558 jne 1b /* no, go process the next character */ 1559 subq %rdi, %rax /* calculate the return value */ 1560 leave /* destroy the stack frame */ 1561 ret /* return to the caller */ 1562 .size VG_(amd64_solaris_REDIR_FOR_strlen), .-VG_(amd64_solaris_REDIR_FOR_strlen) 1563 1564 .global VG_(trampoline_stuff_end) 1565 VG_(trampoline_stuff_end): 1566 1567 /*---------------- unknown ----------------*/ 1568 #else 1569 # error Unknown platform 1570 1571 #endif 1572 #endif 1573 #endif 1574 #endif 1575 #endif 1576 #endif 1577 #endif 1578 #endif 1579 #endif 1580 #endif 1581 #endif 1582 #endif 1583 #endif 1584 1585 /* Let the linker know we don't need an executable stack */ 1586 MARK_STACK_NO_EXEC 1587 1588 /*--------------------------------------------------------------------*/ 1589 /*--- end ---*/ 1590 /*--------------------------------------------------------------------*/ 1591
