src/vm/jit/patcher-common.cpp

   1 /* src/vm/jit/patcher-common.cpp - architecture independent code patching stuff
   2
   3    Copyright (C) 1996-2011
   4    CACAOVM - Verein zur Foerderung der freien virtuellen Maschine CACAO
   5    Copyright (C) 2008 Theobroma Systems Ltd.
   6
   7    This file is part of CACAO.
   8
   9    This program is free software; you can redistribute it and/or
  10    modify it under the terms of the GNU General Public License as
  11    published by the Free Software Foundation; either version 2, or (at
  12    your option) any later version.
  13
  14    This program is distributed in the hope that it will be useful, but
  15    WITHOUT ANY WARRANTY; without even the implied warranty of
  16    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  17    General Public License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with this program; if not, write to the Free Software
  21    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  22    02110-1301, USA.
  23
  24 */
  25
  26
  27 #include "config.h"
  28
  29 #include <assert.h>
  30 #include <stdint.h>
  31
  32 #include <algorithm>
  33 #include <functional>
  34
  35 #include "codegen.h"                   /* for PATCHER_NOPS */
  36 #include "md.h"
  37 #include "trap.hpp"
  38
  39 #include "mm/memory.hpp"
  40
  41 #include "native/native.hpp"
  42
  43 #include "toolbox/list.hpp"
  44 #include "toolbox/logging.hpp"           /* XXX remove me! */
  45
  46 #include "vm/breakpoint.hpp"
  47 #include "vm/exceptions.hpp"
  48 #include "vm/hook.hpp"
  49 #include "vm/initialize.hpp"
  50 #include "vm/options.h"
  51 #include "vm/os.hpp"
  52 #include "vm/resolve.hpp"
  53
  54 #include "vm/jit/code.hpp"
  55 #include "vm/jit/disass.h"
  56 #include "vm/jit/jit.hpp"
  57 #include "vm/jit/patcher-common.hpp"
  58
  59
  60 /* patcher_function_list *******************************************************
  61
  62    This is a list which maps patcher function pointers to the according
  63    names of the patcher functions. It is only usefull for debugging
  64    purposes.
  65
  66 *******************************************************************************/
  67
  68 #if !defined(NDEBUG)
  69 typedef struct patcher_function_list_t {
  70         functionptr patcher;
  71         const char* name;
  72 } patcher_function_list_t;
  73
  74 static patcher_function_list_t patcher_function_list[] = {
  75         { PATCHER_initialize_class,              "initialize_class" },
  76 #ifdef ENABLE_VERIFIER
  77         { PATCHER_resolve_class,                 "resolve_class" },
  78 #endif /* ENABLE_VERIFIER */
  79         { PATCHER_resolve_native_function,       "resolve_native_function" },
  80         { PATCHER_invokestatic_special,          "invokestatic_special" },
  81         { PATCHER_invokevirtual,                 "invokevirtual" },
  82         { PATCHER_invokeinterface,               "invokeinterface" },
  83         { PATCHER_breakpoint,                    "breakpoint" },
  84         { NULL,                                  "-UNKNOWN PATCHER FUNCTION-" }
  85 };
  86 #endif
  87
  88
  89 /* patcher_list_create *********************************************************
  90
  91    Creates an empty patcher list for the given codeinfo.
  92
  93 *******************************************************************************/
  94
  95 void patcher_list_create(codeinfo *code)
  96 {
  97         code->patchers = new LockedList<patchref_t>();
  98 }
  99
 100
 101 /* patcher_list_reset **********************************************************
 102
 103    Resets the patcher list inside a codeinfo. This is usefull when
 104    resetting a codeinfo for recompiling.
 105
 106 *******************************************************************************/
 107
 108 void patcher_list_reset(codeinfo *code)
 109 {
 110 #if defined(ENABLE_STATISTICS)
 111         if (opt_stat)
 112                 size_patchref -= sizeof(patchref_t) * code->patchers->size();
 113 #endif
 114
 115         // Free all elements of the list.
 116         code->patchers->clear();
 117 }
 118
 119 /* patcher_list_free ***********************************************************
 120
 121    Frees the patcher list and all its entries for the given codeinfo.
 122
 123 *******************************************************************************/
 124
 125 void patcher_list_free(codeinfo *code)
 126 {
 127         // Free all elements of the list.
 128         patcher_list_reset(code);
 129
 130         // Free the list itself.
 131         delete code->patchers;
 132 }
 133
 134
 135 /**
 136  * Find an entry inside the patcher list for the given codeinfo by
 137  * specifying the program counter of the patcher position.
 138  *
 139  * NOTE: Caller should hold the patcher list lock or maintain
 140  * exclusive access otherwise.
 141  *
 142  * @param pc Program counter to find.
 143  *
 144  * @return Pointer to patcher.
 145  */
 146
 147 struct foo : public std::binary_function<patchref_t, void*, bool> {
 148         bool operator() (const patchref_t& pr, const void* pc) const
 149         {
 150                 return (pr.mpc == (uintptr_t) pc);
 151         }
 152 };
 153
 154 static patchref_t* patcher_list_find(codeinfo* code, void* pc)
 155 {
 156         // Search for a patcher with the given PC.
 157         List<patchref_t>::iterator it = std::find_if(code->patchers->begin(), code->patchers->end(), std::bind2nd(foo(), pc));
 158
 159         if (it == code->patchers->end())
 160                 return NULL;
 161
 162         return &(*it);
 163 }
 164
 165
 166 /**
 167  * Show the content of the whole patcher reference list for
 168  * debugging purposes.
 169  *
 170  * @param code The codeinfo containing the patcher list.
 171  */
 172 #if !defined(NDEBUG)
 173 void patcher_list_show(codeinfo *code)
 174 {
 175         for (List<patchref_t>::iterator it = code->patchers->begin(); it != code->patchers->end(); it++) {
 176                 patchref_t& pr = *it;
 177
 178                 // Lookup name in patcher function list.
 179                 patcher_function_list_t* l;
 180                 for (l = patcher_function_list; l->patcher != NULL; l++)
 181                         if (l->patcher == pr.patcher)
 182                                 break;
 183
 184                 // Display information about patcher.
 185                 printf("\tpatcher pc:"PRINTF_FORMAT_INTPTR_T, pr.mpc);
 186                 printf(" datap:"PRINTF_FORMAT_INTPTR_T, pr.datap);
 187                 printf(" ref:"PRINTF_FORMAT_INTPTR_T, (intptr_t) pr.ref);
 188 #if PATCHER_CALL_SIZE == 4
 189                 printf(" mcode:%08x", (uint32_t) pr.mcode);
 190 #elif PATCHER_CALL_SIZE == 2
 191                 printf(" mcode:%04x", (uint16_t) pr.mcode);
 192 #else
 193 # error Unknown PATCHER_CALL_SIZE
 194 #endif
 195                 printf(" type:%s\n", l->name);
 196
 197                 // Display machine code of patched position.
 198 #if 0 && defined(ENABLE_DISASSEMBLER)
 199                 printf("\t\tcurrent -> ");
 200                 disassinstr((uint8_t*) pr.mpc);
 201                 printf("\t\tapplied -> ");
 202                 disassinstr((uint8_t*) &(pr.mcode));
 203 #endif
 204         }
 205 }
 206 #endif
 207
 208
 209 /* patcher_add_patch_ref *******************************************************
 210
 211    Appends a new patcher reference to the list of patching positions.
 212
 213    Returns a pointer to the newly created patchref_t.
 214
 215 *******************************************************************************/
 216
 217 patchref_t *patcher_add_patch_ref(jitdata *jd, functionptr patcher, void* ref, s4 disp)
 218 {
 219         codegendata *cd   = jd->cd;
 220         codeinfo    *code = jd->code;
 221
 222 #if defined(ALIGN_PATCHER_TRAP)
 223         emit_patcher_alignment(cd);
 224 #endif
 225
 226         int32_t patchmpc = cd->mcodeptr - cd->mcodebase;
 227
 228 #if !defined(NDEBUG)
 229         if (patcher_list_find(code, (void*) (intptr_t) patchmpc) != NULL)
 230                 os::abort("patcher_add_patch_ref: different patchers at same position.");
 231 #endif
 232
 233 #if defined(USES_PATCHABLE_MEMORY_BARRIER)
 234         PATCHER_NOPS;
 235 #endif
 236
 237         // Set patcher information (mpc is resolved later).
 238         patchref_t pr;
 239
 240         pr.mpc         = patchmpc;
 241         pr.datap       = 0;
 242         pr.disp        = disp;
 243         pr.disp_mb     = 0;
 244         pr.patch_align = 0;
 245         pr.patcher     = patcher;
 246         pr.ref         = ref;
 247         pr.mcode       = 0;
 248         pr.done        = false;
 249
 250         // Store patcher in the list (NOTE: structure is copied).
 251         code->patchers->push_back(pr);
 252
 253 #if defined(ENABLE_STATISTICS)
 254         if (opt_stat)
 255                 size_patchref += sizeof(patchref_t);
 256 #endif
 257
 258 #if defined(ENABLE_JIT) && (defined(__I386__) || defined(__M68K__) || defined(__SPARC_64__) || defined(__X86_64__))
 259
 260         /* XXX We can remove that when we don't use UD2 anymore on i386
 261            and x86_64. */
 262
 263         /* On some architectures the patcher stub call instruction might
 264            be longer than the actual instruction generated.  On this
 265            architectures we store the last patcher call position and after
 266            the basic block code generation is completed, we check the
 267            range and maybe generate some nop's. */
 268         /* The nops are generated in codegen_emit in each codegen */
 269
 270         cd->lastmcodeptr = cd->mcodeptr + PATCHER_CALL_SIZE;
 271 #endif
 272
 273         return &code->patchers->back();
 274 }
 275
 276
 277 /**
 278  * Resolve all patchers in the current JIT run.
 279  *
 280  * @param jd JIT data-structure
 281  */
 282 void patcher_resolve(jitdata* jd)
 283 {
 284         // Get required compiler data.
 285         codeinfo* code = jd->code;
 286
 287         for (List<patchref_t>::iterator it = code->patchers->begin(); it != code->patchers->end(); it++) {
 288                 patchref_t& pr = *it;
 289
 290                 pr.mpc   += (intptr_t) code->entrypoint;
 291                 pr.datap  = (intptr_t) (pr.disp + code->entrypoint);
 292         }
 293 }
 294
 295
 296 /**
 297  * Check if the patcher is already patched.  This is done by comparing
 298  * the machine instruction.
 299  *
 300  * @param pr Patcher structure.
 301  *
 302  * @return true if patched, false otherwise.
 303  */
 304 bool patcher_is_patched(patchref_t* pr)
 305 {
 306         // Validate the instruction at the patching position is the same
 307         // instruction as the patcher structure contains.
 308         uint32_t mcode = *((uint32_t*) pr->mpc);
 309
 310 #if PATCHER_CALL_SIZE == 4
 311         if (mcode != pr->mcode) {
 312 #elif PATCHER_CALL_SIZE == 2
 313         if ((uint16_t) mcode != (uint16_t) pr->mcode) {
 314 #else
 315 #error Unknown PATCHER_CALL_SIZE
 316 #endif
 317                 // The code differs.
 318                 return false;
 319         }
 320
 321         return true;
 322 }
 323
 324
 325 /**
 326  *
 327  */
 328 bool patcher_is_patched_at(void* pc)
 329 {
 330         codeinfo* code = code_find_codeinfo_for_pc(pc);
 331
 332         // Get the patcher for the given PC.
 333         patchref_t* pr = patcher_list_find(code, pc);
 334
 335         if (pr == NULL) {
 336                 // The given PC is not a patcher position.
 337                 return false;
 338         }
 339
 340         // Validate the instruction.
 341         return patcher_is_patched(pr);
 342 }
 343
 344
 345 /* patcher_handler *************************************************************
 346
 347    Handles the request to patch JIT code at the given patching
 348    position. This function is normally called by the signal
 349    handler.
 350
 351    NOTE: The patcher list lock is used to maintain exclusive
 352    access of the patched position (in fact of the whole code).
 353    After patching has suceeded, the patcher reference should be
 354    removed from the patcher list to avoid double patching.
 355
 356 *******************************************************************************/
 357
 358 #if !defined(NDEBUG)
 359 /* XXX this indent is not thread safe! */
 360 /* XXX if you want it thread safe, place patcher_depth in threadobject! */
 361 static int patcher_depth = 0;
 362 #define TRACE_PATCHER_INDENT for (i=0; i<patcher_depth; i++) printf("\t")
 363 #endif /* !defined(NDEBUG) */
 364
 365 bool patcher_handler(u1 *pc)
 366 {
 367         codeinfo      *code;
 368         patchref_t    *pr;
 369         bool           result;
 370 #if !defined(NDEBUG)
 371         patcher_function_list_t *l;
 372         int                      i;
 373 #endif
 374
 375         /* define the patcher function */
 376
 377         bool (*patcher_function)(patchref_t *);
 378
 379         /* search the codeinfo for the given PC */
 380
 381         code = code_find_codeinfo_for_pc(pc);
 382         assert(code);
 383
 384         // Enter a mutex on the patcher list.
 385         code->patchers->lock();
 386
 387         /* search the patcher information for the given PC */
 388
 389         pr = patcher_list_find(code, pc);
 390
 391         if (pr == NULL)
 392                 os::abort("patcher_handler: Unable to find patcher reference.");
 393
 394         if (pr->done) {
 395 #if !defined(NDEBUG)
 396                 if (opt_DebugPatcher) {
 397                         log_println("patcher_handler: double-patching detected!");
 398                 }
 399 #endif
 400                 code->patchers->unlock();
 401                 return true;
 402         }
 403
 404 #if !defined(NDEBUG)
 405         if (opt_DebugPatcher) {
 406                 for (l = patcher_function_list; l->patcher != NULL; l++)
 407                         if (l->patcher == pr->patcher)
 408                                 break;
 409
 410                 TRACE_PATCHER_INDENT; printf("patching in "); method_print(code->m); printf(" at %p\n", (void *) pr->mpc);
 411                 TRACE_PATCHER_INDENT; printf("\tpatcher function = %s <%p>\n", l->name, (void *) (intptr_t) pr->patcher);
 412
 413                 TRACE_PATCHER_INDENT;
 414                 printf("\tmachine code before = ");
 415
 416 # if defined(ENABLE_DISASSEMBLER)
 417                 disassinstr((u1*) (void*) pr->mpc);
 418 # else
 419                 printf("%x at %p (disassembler disabled)\n", *((uint32_t*) pr->mpc), (void*) pr->mpc);
 420 # endif
 421
 422                 patcher_depth++;
 423                 assert(patcher_depth > 0);
 424         }
 425 #endif
 426
 427         /* cast the passed function to a patcher function */
 428
 429         patcher_function = (bool (*)(patchref_t *)) (ptrint) pr->patcher;
 430
 431         /* call the proper patcher function */
 432
 433         result = (patcher_function)(pr);
 434
 435 #if !defined(NDEBUG)
 436         if (opt_DebugPatcher) {
 437                 assert(patcher_depth > 0);
 438                 patcher_depth--;
 439
 440                 TRACE_PATCHER_INDENT;
 441                 printf("\tmachine code after  = ");
 442
 443 # if defined(ENABLE_DISASSEMBLER)
 444                 disassinstr((u1*) (void*) pr->mpc);
 445 # else
 446                 printf("%x at %p (disassembler disabled)\n", *((uint32_t*) pr->mpc), (void*) pr->mpc);
 447 # endif
 448
 449                 if (result == false) {
 450                         TRACE_PATCHER_INDENT; printf("\tPATCHER EXCEPTION!\n");
 451                 }
 452         }
 453 #endif
 454
 455         // Check return value and mangle the pending exception.
 456         if (result == false)
 457                 resolve_handle_pending_exception(true);
 458
 459         // XXX This is only preliminary to prevent double-patching.
 460         else
 461                 pr->done = true;
 462
 463         code->patchers->unlock();
 464
 465         return result;
 466 }
 467
 468
 469 /* patcher_initialize_class ****************************************************
 470
 471    Initalizes a given classinfo pointer.
 472    This function does not patch any data.
 473
 474 *******************************************************************************/
 475
 476 bool patcher_initialize_class(patchref_t *pr)
 477 {
 478         classinfo *c;
 479
 480         /* get stuff from the patcher reference */
 481
 482         c = (classinfo *) pr->ref;
 483
 484         /* check if the class is initialized */
 485
 486         if (!(c->state & CLASS_INITIALIZED))
 487                 if (!initialize_class(c))
 488                         return false;
 489
 490         /* patch back original code */
 491
 492         patcher_patch_code(pr);
 493
 494         return true;
 495 }
 496
 497
 498 /* patcher_resolve_class *******************************************************
 499
 500    Resolves a given unresolved class reference.
 501    This function does not patch any data.
 502
 503 *******************************************************************************/
 504
 505 #ifdef ENABLE_VERIFIER
 506 bool patcher_resolve_class(patchref_t *pr)
 507 {
 508         unresolved_class *uc;
 509
 510         /* get stuff from the patcher reference */
 511
 512         uc = (unresolved_class *) pr->ref;
 513
 514         /* resolve the class and check subtype constraints */
 515
 516         if (!resolve_class_eager_no_access_check(uc))
 517                 return false;
 518
 519         /* patch back original code */
 520
 521         patcher_patch_code(pr);
 522
 523         return true;
 524 }
 525 #endif /* ENABLE_VERIFIER */
 526
 527
 528 /* patcher_resolve_native_function *********************************************
 529
 530    Resolves the native function for a given methodinfo.
 531    This function patches one data segment word.
 532
 533 *******************************************************************************/
 534
 535 bool patcher_resolve_native_function(patchref_t *pr)
 536 {
 537         methodinfo  *m;
 538         uint8_t     *datap;
 539
 540         /* get stuff from the patcher reference */
 541
 542         m     = (methodinfo *) pr->ref;
 543         datap = (uint8_t *)    pr->datap;
 544
 545         /* resolve native function */
 546
 547         NativeMethods& nm = VM::get_current()->get_nativemethods();
 548         void* f = nm.resolve_method(m);
 549
 550         if (f == NULL)
 551                 return false;
 552
 553         /* patch native function pointer */
 554
 555         *((intptr_t*) datap) = (intptr_t) f;
 556
 557         /* synchronize data cache */
 558
 559         md_dcacheflush(datap, SIZEOF_VOID_P);
 560
 561         /* patch back original code */
 562
 563         patcher_patch_code(pr);
 564
 565         return true;
 566 }
 567
 568
 569 /**
 570  * Deals with breakpoint instructions (ICMD_BREAKPOINT) compiled
 571  * into a JIT method. This patcher might never patch back the
 572  * original machine code because breakpoints are kept active.
 573  */
 574 bool patcher_breakpoint(patchref_t *pr)
 575 {
 576         // Get stuff from the patcher reference.
 577         Breakpoint* breakp = (Breakpoint*) pr->ref;
 578
 579         // Hook point when a breakpoint was triggered.
 580         Hook::breakpoint(breakp);
 581
 582         // In case the breakpoint wants to be kept active, we simply
 583         // fail to "patch" at this point.
 584         if (!breakp->is_oneshot)
 585                 return false;
 586
 587         // Patch back original code.
 588         patcher_patch_code(pr);
 589
 590         return true;
 591 }
 592
 593
 594 /*
 595  * These are local overrides for various environment variables in Emacs.
 596  * Please do not remove this and leave it at the end of the file, where
 597  * Emacs will automagically detect them.
 598  * ---------------------------------------------------------------------
 599  * Local variables:
 600  * mode: c++
 601  * indent-tabs-mode: t
 602  * c-basic-offset: 4
 603  * tab-width: 4
 604  * End:
 605  * vim:noexpandtab:sw=4:ts=4:
 606  */
 607