src/vm/jit/patcher-common.cpp

   1 /* src/vm/jit/patcher-common.cpp - architecture independent code patching stuff
   2
   3    Copyright (C) 2007, 2008, 2009
   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/initialize.hpp"
  49 #include "vm/options.h"
  50 #include "vm/os.hpp"
  51 #include "vm/resolve.hpp"
  52
  53 #include "vm/jit/code.hpp"
  54 #include "vm/jit/disass.h"
  55 #include "vm/jit/jit.hpp"
  56 #include "vm/jit/patcher-common.hpp"
  57
  58
  59 /* patcher_function_list *******************************************************
  60
  61    This is a list which maps patcher function pointers to the according
  62    names of the patcher functions. It is only usefull for debugging
  63    purposes.
  64
  65 *******************************************************************************/
  66
  67 #if !defined(NDEBUG)
  68 typedef struct patcher_function_list_t {
  69         functionptr patcher;
  70         const char* name;
  71 } patcher_function_list_t;
  72
  73 static patcher_function_list_t patcher_function_list[] = {
  74         { PATCHER_initialize_class,              "initialize_class" },
  75 #ifdef ENABLE_VERIFIER
  76         { PATCHER_resolve_class,                 "resolve_class" },
  77 #endif /* ENABLE_VERIFIER */
  78         { PATCHER_resolve_native_function,       "resolve_native_function" },
  79         { PATCHER_invokestatic_special,          "invokestatic_special" },
  80         { PATCHER_invokevirtual,                 "invokevirtual" },
  81         { PATCHER_invokeinterface,               "invokeinterface" },
  82         { PATCHER_breakpoint,                    "breakpoint" },
  83         { NULL,                                  "-UNKNOWN PATCHER FUNCTION-" }
  84 };
  85 #endif
  86
  87
  88 /* patcher_list_create *********************************************************
  89
  90    Creates an empty patcher list for the given codeinfo.
  91
  92 *******************************************************************************/
  93
  94 void patcher_list_create(codeinfo *code)
  95 {
  96         code->patchers = new LockedList<patchref_t>();
  97 }
  98
  99
 100 /* patcher_list_reset **********************************************************
 101
 102    Resets the patcher list inside a codeinfo. This is usefull when
 103    resetting a codeinfo for recompiling.
 104
 105 *******************************************************************************/
 106
 107 void patcher_list_reset(codeinfo *code)
 108 {
 109 #if defined(ENABLE_STATISTICS)
 110         if (opt_stat)
 111                 size_patchref -= sizeof(patchref_t) * code->patchers->size();
 112 #endif
 113
 114         // Free all elements of the list.
 115         code->patchers->clear();
 116 }
 117
 118 /* patcher_list_free ***********************************************************
 119
 120    Frees the patcher list and all its entries for the given codeinfo.
 121
 122 *******************************************************************************/
 123
 124 void patcher_list_free(codeinfo *code)
 125 {
 126         // Free all elements of the list.
 127         patcher_list_reset(code);
 128
 129         // Free the list itself.
 130         delete code->patchers;
 131 }
 132
 133
 134 /**
 135  * Find an entry inside the patcher list for the given codeinfo by
 136  * specifying the program counter of the patcher position.
 137  *
 138  * NOTE: Caller should hold the patcher list lock or maintain
 139  * exclusive access otherwise.
 140  *
 141  * @param pc Program counter to find.
 142  *
 143  * @return Pointer to patcher.
 144  */
 145
 146 struct foo : public std::binary_function<patchref_t, void*, bool> {
 147         bool operator() (const patchref_t& pr, const void* pc) const
 148         {
 149                 return (pr.mpc == (uintptr_t) pc);
 150         }
 151 };
 152
 153 static patchref_t* patcher_list_find(codeinfo* code, void* pc)
 154 {
 155         // Search for a patcher with the given PC.
 156         List<patchref_t>::iterator it = std::find_if(code->patchers->begin(), code->patchers->end(), std::bind2nd(foo(), pc));
 157
 158         if (it == code->patchers->end())
 159                 return NULL;
 160
 161         return &(*it);
 162 }
 163
 164
 165 /**
 166  * Show the content of the whole patcher reference list for
 167  * debugging purposes.
 168  *
 169  * @param code The codeinfo containing the patcher list.
 170  */
 171 #if !defined(NDEBUG)
 172 void patcher_list_show(codeinfo *code)
 173 {
 174         for (List<patchref_t>::iterator it = code->patchers->begin(); it != code->patchers->end(); it++) {
 175                 patchref_t& pr = *it;
 176
 177                 // Lookup name in patcher function list.
 178                 patcher_function_list_t* l;
 179                 for (l = patcher_function_list; l->patcher != NULL; l++)
 180                         if (l->patcher == pr.patcher)
 181                                 break;
 182
 183                 // Display information about patcher.
 184                 printf("\tpatcher pc:"PRINTF_FORMAT_INTPTR_T, pr.mpc);
 185                 printf(" datap:"PRINTF_FORMAT_INTPTR_T, pr.datap);
 186                 printf(" ref:"PRINTF_FORMAT_INTPTR_T, (intptr_t) pr.ref);
 187 #if PATCHER_CALL_SIZE == 4
 188                 printf(" mcode:%08x", (uint32_t) pr.mcode);
 189 #elif PATCHER_CALL_SIZE == 2
 190                 printf(" mcode:%04x", (uint16_t) pr.mcode);
 191 #else
 192 # error Unknown PATCHER_CALL_SIZE
 193 #endif
 194                 printf(" type:%s\n", l->name);
 195
 196                 // Display machine code of patched position.
 197 #if 0 && defined(ENABLE_DISASSEMBLER)
 198                 printf("\t\tcurrent -> ");
 199                 disassinstr((uint8_t*) pr.mpc);
 200                 printf("\t\tapplied -> ");
 201                 disassinstr((uint8_t*) &(pr.mcode));
 202 #endif
 203         }
 204 }
 205 #endif
 206
 207
 208 /* patcher_add_patch_ref *******************************************************
 209
 210    Appends a new patcher reference to the list of patching positions.
 211
 212 *******************************************************************************/
 213
 214 void patcher_add_patch_ref(jitdata *jd, functionptr patcher, void* ref, s4 disp)
 215 {
 216         codegendata *cd   = jd->cd;
 217         codeinfo    *code = jd->code;
 218
 219 #if defined(ALIGN_PATCHER_TRAP)
 220         emit_patcher_alignment(cd);
 221 #endif
 222
 223         int32_t patchmpc = cd->mcodeptr - cd->mcodebase;
 224
 225 #if !defined(NDEBUG)
 226         if (patcher_list_find(code, (void*) (intptr_t) patchmpc) != NULL)
 227                 os::abort("patcher_add_patch_ref: different patchers at same position.");
 228 #endif
 229
 230 #if defined(USES_PATCHABLE_MEMORY_BARRIER)
 231         PATCHER_NOPS;
 232 #endif
 233
 234         // Set patcher information (mpc is resolved later).
 235         patchref_t pr;
 236
 237         pr.mpc     = patchmpc;
 238         pr.datap   = 0;
 239         pr.disp    = disp;
 240         pr.patcher = patcher;
 241         pr.ref     = ref;
 242         pr.mcode   = 0;
 243         pr.done    = false;
 244
 245         // Store patcher in the list (NOTE: structure is copied).
 246         code->patchers->push_back(pr);
 247
 248 #if defined(ENABLE_STATISTICS)
 249         if (opt_stat)
 250                 size_patchref += sizeof(patchref_t);
 251 #endif
 252
 253 #if defined(ENABLE_JIT) && (defined(__I386__) || defined(__M68K__) || defined(__SPARC_64__) || defined(__X86_64__))
 254
 255         /* XXX We can remove that when we don't use UD2 anymore on i386
 256            and x86_64. */
 257
 258         /* On some architectures the patcher stub call instruction might
 259            be longer than the actual instruction generated.  On this
 260            architectures we store the last patcher call position and after
 261            the basic block code generation is completed, we check the
 262            range and maybe generate some nop's. */
 263         /* The nops are generated in codegen_emit in each codegen */
 264
 265         cd->lastmcodeptr = cd->mcodeptr + PATCHER_CALL_SIZE;
 266 #endif
 267 }
 268
 269
 270 /**
 271  * Resolve all patchers in the current JIT run.
 272  *
 273  * @param jd JIT data-structure
 274  */
 275 void patcher_resolve(jitdata* jd)
 276 {
 277         // Get required compiler data.
 278         codeinfo* code = jd->code;
 279
 280         for (List<patchref_t>::iterator it = code->patchers->begin(); it != code->patchers->end(); it++) {
 281                 patchref_t& pr = *it;
 282
 283                 pr.mpc   += (intptr_t) code->entrypoint;
 284                 pr.datap  = (intptr_t) (pr.disp + code->entrypoint);
 285         }
 286 }
 287
 288
 289 /**
 290  * Check if the patcher is already patched.  This is done by comparing
 291  * the machine instruction.
 292  *
 293  * @param pr Patcher structure.
 294  *
 295  * @return true if patched, false otherwise.
 296  */
 297 bool patcher_is_patched(patchref_t* pr)
 298 {
 299         // Validate the instruction at the patching position is the same
 300         // instruction as the patcher structure contains.
 301         uint32_t mcode = *((uint32_t*) pr->mpc);
 302
 303 #if PATCHER_CALL_SIZE == 4
 304         if (mcode != pr->mcode) {
 305 #elif PATCHER_CALL_SIZE == 2
 306         if ((uint16_t) mcode != (uint16_t) pr->mcode) {
 307 #else
 308 #error Unknown PATCHER_CALL_SIZE
 309 #endif
 310                 // The code differs.
 311                 return false;
 312         }
 313
 314         return true;
 315 }
 316
 317
 318 /**
 319  *
 320  */
 321 bool patcher_is_patched_at(void* pc)
 322 {
 323         codeinfo* code = code_find_codeinfo_for_pc(pc);
 324
 325         // Get the patcher for the given PC.
 326         patchref_t* pr = patcher_list_find(code, pc);
 327
 328         if (pr == NULL) {
 329                 // The given PC is not a patcher position.
 330                 return false;
 331         }
 332
 333         // Validate the instruction.
 334         return patcher_is_patched(pr);
 335 }
 336
 337
 338 /* patcher_handler *************************************************************
 339
 340    Handles the request to patch JIT code at the given patching
 341    position. This function is normally called by the signal
 342    handler.
 343
 344    NOTE: The patcher list lock is used to maintain exclusive
 345    access of the patched position (in fact of the whole code).
 346    After patching has suceeded, the patcher reference should be
 347    removed from the patcher list to avoid double patching.
 348
 349 *******************************************************************************/
 350
 351 #if !defined(NDEBUG)
 352 /* XXX this indent is not thread safe! */
 353 /* XXX if you want it thread safe, place patcher_depth in threadobject! */
 354 static int patcher_depth = 0;
 355 #define TRACE_PATCHER_INDENT for (i=0; i<patcher_depth; i++) printf("\t")
 356 #endif /* !defined(NDEBUG) */
 357
 358 java_handle_t *patcher_handler(u1 *pc)
 359 {
 360         codeinfo      *code;
 361         patchref_t    *pr;
 362         bool           result;
 363 #if !defined(NDEBUG)
 364         patcher_function_list_t *l;
 365         int                      i;
 366 #endif
 367
 368         /* define the patcher function */
 369
 370         bool (*patcher_function)(patchref_t *);
 371
 372         /* search the codeinfo for the given PC */
 373
 374         code = code_find_codeinfo_for_pc(pc);
 375         assert(code);
 376
 377         // Enter a mutex on the patcher list.
 378         code->patchers->lock();
 379
 380         /* search the patcher information for the given PC */
 381
 382         pr = patcher_list_find(code, pc);
 383
 384         if (pr == NULL)
 385                 os::abort("patcher_handler: Unable to find patcher reference.");
 386
 387         if (pr->done) {
 388 #if !defined(NDEBUG)
 389                 if (opt_DebugPatcher) {
 390                         log_println("patcher_handler: double-patching detected!");
 391                 }
 392 #endif
 393                 code->patchers->unlock();
 394                 return NULL;
 395         }
 396
 397 #if !defined(NDEBUG)
 398         if (opt_DebugPatcher) {
 399                 for (l = patcher_function_list; l->patcher != NULL; l++)
 400                         if (l->patcher == pr->patcher)
 401                                 break;
 402
 403                 TRACE_PATCHER_INDENT; printf("patching in "); method_print(code->m); printf(" at %p\n", (void *) pr->mpc);
 404                 TRACE_PATCHER_INDENT; printf("\tpatcher function = %s <%p>\n", l->name, (void *) (intptr_t) pr->patcher);
 405
 406                 TRACE_PATCHER_INDENT;
 407                 printf("\tmachine code before = ");
 408
 409 # if defined(ENABLE_DISASSEMBLER)
 410                 disassinstr((u1*) (void*) pr->mpc);
 411 # else
 412                 printf("%x at %p (disassembler disabled)\n", *((uint32_t*) pr->mpc), (void*) pr->mpc);
 413 # endif
 414
 415                 patcher_depth++;
 416                 assert(patcher_depth > 0);
 417         }
 418 #endif
 419
 420         /* cast the passed function to a patcher function */
 421
 422         patcher_function = (bool (*)(patchref_t *)) (ptrint) pr->patcher;
 423
 424         /* call the proper patcher function */
 425
 426         result = (patcher_function)(pr);
 427
 428 #if !defined(NDEBUG)
 429         if (opt_DebugPatcher) {
 430                 assert(patcher_depth > 0);
 431                 patcher_depth--;
 432
 433                 TRACE_PATCHER_INDENT;
 434                 printf("\tmachine code after  = ");
 435
 436 # if defined(ENABLE_DISASSEMBLER)
 437                 disassinstr((u1*) (void*) pr->mpc);
 438 # else
 439                 printf("%x at %p (disassembler disabled)\n", *((uint32_t*) pr->mpc), (void*) pr->mpc);
 440 # endif
 441
 442                 if (result == false) {
 443                         TRACE_PATCHER_INDENT; printf("\tPATCHER EXCEPTION!\n");
 444                 }
 445         }
 446 #endif
 447
 448         // Check for return value and exit accordingly.
 449         if (result == false) {
 450                 // Mangle the pending exception.
 451                 resolve_handle_pending_exception(true);
 452
 453                 // Get the exception and return it.
 454                 java_handle_t* e = exceptions_get_and_clear_exception();
 455
 456                 code->patchers->unlock();
 457
 458                 return e;
 459         }
 460
 461         pr->done = true; /* XXX this is only preliminary to prevent double-patching */
 462
 463         code->patchers->unlock();
 464
 465         return NULL;
 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 #if defined(ENABLE_JVMTI)
 580         methodinfo* m = breakp->method;
 581         int32_t     l = breakp->location;
 582
 583         log_message_method("JVMTI: Reached breakpoint in method ", m);
 584         log_println("JVMTI: Reached breakpoint at location %d", l);
 585 #endif
 586
 587         // In case the breakpoint wants to be kept active, we simply
 588         // fail to "patch" at this point.
 589         if (!breakp->is_oneshot)
 590                 return false;
 591
 592         // Patch back original code.
 593         patcher_patch_code(pr);
 594
 595         return true;
 596 }
 597
 598
 599 /*
 600  * These are local overrides for various environment variables in Emacs.
 601  * Please do not remove this and leave it at the end of the file, where
 602  * Emacs will automagically detect them.
 603  * ---------------------------------------------------------------------
 604  * Local variables:
 605  * mode: c++
 606  * indent-tabs-mode: t
 607  * c-basic-offset: 4
 608  * tab-width: 4
 609  * End:
 610  * vim:noexpandtab:sw=4:ts=4:
 611  */
 612