coregrind/m_dispatch/dispatch-amd64-solaris.S

   1
   2 /*--------------------------------------------------------------------*/
   3 /*--- The core dispatch loop, for jumping to a code address.       ---*/
   4 /*---                                     dispatch-amd64-solaris.S ---*/
   5 /*--------------------------------------------------------------------*/
   6
   7 /*
   8   This file is part of Valgrind, a dynamic binary instrumentation
   9   framework.
  10
  11   Copyright (C) 2000-2017 Julian Seward
  12      jseward@acm.org
  13
  14   This program is free software; you can redistribute it and/or
  15   modify it under the terms of the GNU General Public License as
  16   published by the Free Software Foundation; either version 2 of the
  17   License, or (at your option) any later version.
  18
  19   This program is distributed in the hope that it will be useful, but
  20   WITHOUT ANY WARRANTY; without even the implied warranty of
  21   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  22   General Public License for more details.
  23
  24   You should have received a copy of the GNU General Public License
  25   along with this program; if not, see <http://www.gnu.org/licenses/>.
  26
  27   The GNU General Public License is contained in the file COPYING.
  28 */
  29
  30 #include "pub_core_basics_asm.h"
  31
  32 #if defined(VGP_amd64_solaris)
  33
  34 #include "pub_core_dispatch_asm.h"
  35 #include "pub_core_transtab_asm.h"
  36 #include "libvex_guest_offsets.h"       /* for OFFSET_amd64_RIP */
  37
  38
  39 /*------------------------------------------------------------*/
  40 /*---                                                      ---*/
  41 /*--- The dispatch loop.  VG_(disp_run_translations) is    ---*/
  42 /*--- used to run all translations,                        ---*/
  43 /*--- including no-redir ones.                             ---*/
  44 /*---                                                      ---*/
  45 /*------------------------------------------------------------*/
  46
  47 /*----------------------------------------------------*/
  48 /*--- Entry and preamble (set everything up)       ---*/
  49 /*----------------------------------------------------*/
  50
  51 /* signature:
  52 void VG_(disp_run_translations)( UWord* two_words,
  53                                  void*  guest_state,
  54                                  Addr   host_addr );
  55 */
  56 .text
  57 .globl VG_(disp_run_translations)
  58 .type  VG_(disp_run_translations), @function
  59 VG_(disp_run_translations):
  60         /* %rdi holds two_words    */
  61         /* %rsi holds guest_state  */
  62         /* %rdx holds host_addr    */
  63
  64         /* The preamble */
  65
  66         /* Save integer registers, since this is a pseudo-function. */
  67         pushq   %rax
  68         pushq   %rbx
  69         pushq   %rcx
  70         pushq   %rdx
  71         pushq   %rsi
  72         pushq   %rbp
  73         pushq   %r8
  74         pushq   %r9
  75         pushq   %r10
  76         pushq   %r11
  77         pushq   %r12
  78         pushq   %r13
  79         pushq   %r14
  80         pushq   %r15
  81         /* %rdi must be saved last */
  82         pushq   %rdi
  83
  84         /* Get the host CPU in the state expected by generated code. */
  85
  86         /* set host FPU control word to the default mode expected
  87            by VEX-generated code.  See comments in libvex.h for
  88            more info. */
  89         finit
  90         pushq   $0x027F
  91         fldcw   (%rsp)
  92         addq    $8, %rsp
  93
  94         /* set host SSE control word to the default mode expected
  95            by VEX-generated code. */
  96         pushq   $0x1F80
  97         ldmxcsr (%rsp)
  98         addq    $8, %rsp
  99
 100         /* set dir flag to known value */
 101         cld
 102
 103         /* Set up the guest state pointer */
 104         movq    %rsi, %rbp
 105
 106         /* and jump into the code cache.  Chained translations in
 107            the code cache run, until for whatever reason, they can't
 108            continue.  When that happens, the translation in question
 109            will jump (or call) to one of the continuation points
 110            VG_(cp_...) below. */
 111         jmpq    *%rdx
 112         /*NOTREACHED*/
 113
 114 /*----------------------------------------------------*/
 115 /*--- Postamble and exit.                          ---*/
 116 /*----------------------------------------------------*/
 117
 118 postamble:
 119         /* At this point, %rax and %rdx contain two
 120            words to be returned to the caller.  %rax
 121            holds a TRC value, and %rdx optionally may
 122            hold another word (for CHAIN_ME exits, the
 123            address of the place to patch.) */
 124
 125         /* We're leaving.  Check that nobody messed with %mxcsr
 126            or %fpucw.  We can't mess with %rax or %rdx here as they
 127            hold the tentative return values, but any others are OK. */
 128 #if !defined(ENABLE_INNER)
 129         /* This check fails for self-hosting, so skip in that case */
 130         pushq   $0
 131         fstcw   (%rsp)
 132         cmpl    $0x027F, (%rsp)
 133         popq    %r15 /* get rid of the word without trashing %rflags */
 134         jnz     invariant_violation
 135 #endif
 136         pushq   $0
 137         stmxcsr (%rsp)
 138         andl    $0xFFFFFFC0, (%rsp)  /* mask out status flags */
 139         cmpl    $0x1F80, (%rsp)
 140         popq    %r15
 141         jnz     invariant_violation
 142         /* otherwise we're OK */
 143         jmp     remove_frame
 144 invariant_violation:
 145         movq    $VG_TRC_INVARIANT_FAILED, %rax
 146         movq    $0, %rdx
 147
 148 remove_frame:
 149         /* Pop %rdi, stash return values */
 150         popq    %rdi
 151         movq    %rax, 0(%rdi)
 152         movq    %rdx, 8(%rdi)
 153         /* Now pop everything else */
 154         popq    %r15
 155         popq    %r14
 156         popq    %r13
 157         popq    %r12
 158         popq    %r11
 159         popq    %r10
 160         popq    %r9
 161         popq    %r8
 162         popq    %rbp
 163         popq    %rsi
 164         popq    %rdx
 165         popq    %rcx
 166         popq    %rbx
 167         popq    %rax
 168         ret
 169
 170 /*----------------------------------------------------*/
 171 /*--- Continuation points                          ---*/
 172 /*----------------------------------------------------*/
 173
 174 /* ------ Chain me to slow entry point ------ */
 175 .global VG_(disp_cp_chain_me_to_slowEP)
 176 VG_(disp_cp_chain_me_to_slowEP):
 177         /* We got called.  The return address indicates
 178            where the patching needs to happen.  Collect
 179            the return address and, exit back to C land,
 180            handing the caller the pair (Chain_me_S, RA) */
 181         movq    $VG_TRC_CHAIN_ME_TO_SLOW_EP, %rax
 182         popq    %rdx
 183         /* 10 = movabsq $VG_(disp_chain_me_to_slowEP), %r11;
 184            3  = call *%r11 */
 185         subq    $10+3, %rdx
 186         jmp     postamble
 187
 188 /* ------ Chain me to fast entry point ------ */
 189 .global VG_(disp_cp_chain_me_to_fastEP)
 190 VG_(disp_cp_chain_me_to_fastEP):
 191         /* We got called.  The return address indicates
 192            where the patching needs to happen.  Collect
 193            the return address and, exit back to C land,
 194            handing the caller the pair (Chain_me_F, RA) */
 195         movq    $VG_TRC_CHAIN_ME_TO_FAST_EP, %rax
 196         popq    %rdx
 197         /* 10 = movabsq $VG_(disp_chain_me_to_fastEP), %r11;
 198            3  = call *%r11 */
 199         subq    $10+3, %rdx
 200         jmp     postamble
 201
 202 /* ------ Indirect but boring jump ------ */
 203 .global VG_(disp_cp_xindir)
 204 VG_(disp_cp_xindir):
 205         /* Where are we going? */
 206         movq    OFFSET_amd64_RIP(%rbp), %rax    // "guest"
 207
 208         /* stats only */
 209         addl    $1, VG_(stats__n_xIndirs_32)
 210
 211         // LIVE: %rbp (guest state ptr), %rax (guest address to go to).
 212         // We use 4 temporaries:
 213         //   %r9 (to point at the relevant FastCacheSet),
 214         //   %r10, %r11 and %r12 (scratch).
 215
 216         /* Try a fast lookup in the translation cache.  This is pretty much
 217            a handcoded version of VG_(lookupInFastCache). */
 218
 219         // Compute %r9 = VG_TT_FAST_HASH(guest)
 220         movq    %rax, %r9               // guest
 221         shrq    $VG_TT_FAST_BITS, %r9   // (guest >> VG_TT_FAST_BITS)
 222         xorq    %rax, %r9               // (guest >> VG_TT_FAST_BITS) ^ guest
 223         andq    $VG_TT_FAST_MASK, %r9   // setNo
 224
 225         // Compute %r9 = &VG_(tt_fast)[%r9]
 226         shlq    $VG_FAST_CACHE_SET_BITS, %r9  // setNo * sizeof(FastCacheSet)
 227         movabsq $VG_(tt_fast), %r10           // &VG_(tt_fast)[0]
 228         leaq    (%r10, %r9), %r9              // &VG_(tt_fast)[setNo]
 229
 230         // LIVE: %rbp (guest state ptr), %rax (guest addr), %r9 (cache set)
 231         // try way 0
 232         cmpq    %rax, FCS_g0(%r9)   // cmp against .guest0
 233         jnz     1f
 234         // hit at way 0
 235         jmp    *FCS_h0(%r9)         // goto .host0
 236         ud2
 237
 238 1:      // try way 1
 239         cmpq    %rax, FCS_g1(%r9)   // cmp against .guest1
 240         jnz     2f
 241         // hit at way 1; swap upwards
 242         /* stats only */
 243         addl    $1, VG_(stats__n_xIndir_hits1_32)
 244         movq    FCS_g0(%r9), %r10   // r10 = old .guest0
 245         movq    FCS_h0(%r9), %r11   // r11 = old .host0
 246         movq    FCS_h1(%r9), %r12   // r12 = old .host1
 247         movq    %rax, FCS_g0(%r9)   // new .guest0 = guest
 248         movq    %r12, FCS_h0(%r9)   // new .host0 = old .host1
 249         movq    %r10, FCS_g1(%r9)   // new .guest1 = old .guest0
 250         movq    %r11, FCS_h1(%r9)   // new .host1 = old .host0
 251         jmp     *%r12               // goto old .host1 a.k.a. new .host0
 252         ud2
 253
 254 2:      // try way 2
 255         cmpq    %rax, FCS_g2(%r9)   // cmp against .guest2
 256         jnz     3f
 257         // hit at way 2; swap upwards
 258         /* stats only */
 259         addl    $1, VG_(stats__n_xIndir_hits2_32)
 260         movq    FCS_g1(%r9), %r10
 261         movq    FCS_h1(%r9), %r11
 262         movq    FCS_h2(%r9), %r12
 263         movq    %rax, FCS_g1(%r9)
 264         movq    %r12, FCS_h1(%r9)
 265         movq    %r10, FCS_g2(%r9)
 266         movq    %r11, FCS_h2(%r9)
 267         jmp     *%r12
 268         ud2
 269
 270 3:      // try way 3
 271         cmpq    %rax, FCS_g3(%r9)   // cmp against .guest3
 272         jnz     4f
 273         // hit at way 3; swap upwards
 274         /* stats only */
 275         addl    $1, VG_(stats__n_xIndir_hits3_32)
 276         movq    FCS_g2(%r9), %r10
 277         movq    FCS_h2(%r9), %r11
 278         movq    FCS_h3(%r9), %r12
 279         movq    %rax, FCS_g2(%r9)
 280         movq    %r12, FCS_h2(%r9)
 281         movq    %r10, FCS_g3(%r9)
 282         movq    %r11, FCS_h3(%r9)
 283         jmp     *%r12
 284         ud2
 285
 286 4:      // fast lookup failed
 287         /* stats only */
 288         addl    $1, VG_(stats__n_xIndir_misses_32)
 289
 290         movq    $VG_TRC_INNER_FASTMISS, %rax
 291         movq    $0, %rdx
 292         jmp     postamble
 293
 294 /* ------ Assisted jump ------ */
 295 .global VG_(disp_cp_xassisted)
 296 VG_(disp_cp_xassisted):
 297         /* %rbp contains the TRC */
 298         movq    %rbp, %rax
 299         movq    $0, %rdx
 300         jmp     postamble
 301
 302 /* ------ Event check failed ------ */
 303 .global VG_(disp_cp_evcheck_fail)
 304 VG_(disp_cp_evcheck_fail):
 305         movq    $VG_TRC_INNER_COUNTERZERO, %rax
 306         movq    $0, %rdx
 307         jmp     postamble
 308
 309
 310 .size VG_(disp_run_translations), .-VG_(disp_run_translations)
 311
 312 #endif // defined(VGP_amd64_solaris)
 313
 314 /* Let the linker know we don't need an executable stack */
 315 MARK_STACK_NO_EXEC
 316
 317 /*--------------------------------------------------------------------*/
 318 /*--- end                                                          ---*/
 319 /*--------------------------------------------------------------------*/