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