/* src/vm/jit/x86_64/patcher.c - x86_64 code patching functions Copyright (C) 1996-2005, 2006, 2007 R. Grafl, A. Krall, C. Kruegel, C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring, E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich, J. Wenninger, Institut f. Computersprachen - TU Wien This file is part of CACAO. This program is free software; you can redistribute it and/or modify it under the terms of the GNU General Public License as published by the Free Software Foundation; either version 2, or (at your option) any later version. This program is distributed in the hope that it will be useful, but WITHOUT ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details. You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301, USA. */ #include "config.h" #include #include "vm/types.h" #include "vm/jit/x86_64/codegen.h" #include "mm/memory.h" #include "native/native.h" #include "vm/builtin.h" #include "vm/exceptions.h" #include "vm/initialize.h" #include "vm/jit/patcher-common.h" #include "vm/jit/stacktrace.h" #include "vmcore/class.h" #include "vmcore/field.h" #include "vmcore/options.h" #include "vmcore/references.h" #include "vm/resolve.h" #define PATCH_BACK_ORIGINAL_MCODE \ do { \ *((uint16_t *) pr->mpc) = (uint16_t) pr->mcode; \ } while (0) /* patcher_patch_code ********************************************************** Just patches back the original machine code. *******************************************************************************/ void patcher_patch_code(patchref_t *pr) { PATCH_BACK_ORIGINAL_MCODE; } /* patcher_resolve_classref_to_classinfo *************************************** ACONST: 48 bf a0 f0 92 00 00 00 00 00 mov $0x92f0a0,%rdi MULTIANEWARRAY: 48 be 30 40 b2 00 00 00 00 00 mov $0xb24030,%rsi 48 89 e2 mov %rsp,%rdx 48 b8 7c 96 4b 00 00 00 00 00 mov $0x4b967c,%rax 48 ff d0 callq *%rax ARRAYCHECKCAST: 48 be b8 3f b2 00 00 00 00 00 mov $0xb23fb8,%rsi 48 b8 00 00 00 00 00 00 00 00 mov $0x0,%rax 48 ff d0 callq *%rax *******************************************************************************/ bool patcher_resolve_classref_to_classinfo(patchref_t *pr) { constant_classref *cr; intptr_t *datap; classinfo *c; cr = (constant_classref *) pr->ref; datap = (intptr_t *) pr->datap; /* get the classinfo */ if (!(c = resolve_classref_eager(cr))) return false; PATCH_BACK_ORIGINAL_MCODE; /* patch the classinfo pointer */ *datap = (intptr_t) c; return true; } /* patcher_resolve_classref_to_vftbl ******************************************* CHECKCAST (class): INSTANCEOF (class): *******************************************************************************/ bool patcher_resolve_classref_to_vftbl(patchref_t *pr) { constant_classref *cr; intptr_t *datap; classinfo *c; /* get stuff from the stack */ cr = (constant_classref *) pr->ref; datap = (intptr_t *) pr->datap; /* get the fieldinfo */ if (!(c = resolve_classref_eager(cr))) return false; PATCH_BACK_ORIGINAL_MCODE; /* patch super class' vftbl */ *datap = (intptr_t) c->vftbl; return true; } /* patcher_resolve_classref_to_flags ******************************************* CHECKCAST/INSTANCEOF: *******************************************************************************/ bool patcher_resolve_classref_to_flags(patchref_t *pr) { constant_classref *cr; int32_t *datap; classinfo *c; uint8_t *ra; cr = (constant_classref *) pr->ref; datap = (int32_t *) pr->datap; ra = (uint8_t *) pr->mpc; /* get the fieldinfo */ if (!(c = resolve_classref_eager(cr))) return false; PATCH_BACK_ORIGINAL_MCODE; /* if we show disassembly, we have to skip the nop's */ if (opt_shownops) ra = ra + PATCHER_CALL_SIZE; /* patch class flags */ /* *datap = c->flags; */ *((int32_t *) (ra + 2)) = c->flags; return true; } /* patcher_get_putstatic ******************************************************* Machine code: 4d 8b 15 86 fe ff ff mov -378(%rip),%r10 49 8b 32 mov (%r10),%rsi *******************************************************************************/ bool patcher_get_putstatic(patchref_t *pr) { unresolved_field *uf; intptr_t *datap; fieldinfo *fi; uf = (unresolved_field *) pr->ref; datap = (intptr_t *) pr->datap; /* get the fieldinfo */ if (!(fi = resolve_field_eager(uf))) return false; /* check if the field's class is initialized */ if (!(fi->class->state & CLASS_INITIALIZED)) if (!initialize_class(fi->class)) return false; PATCH_BACK_ORIGINAL_MCODE; /* patch the field value's address */ *datap = (intptr_t) fi->value; return true; } /* patcher_get_putfield ******************************************************** Machine code: 45 8b 8f 00 00 00 00 mov 0x0(%r15),%r9d *******************************************************************************/ bool patcher_get_putfield(patchref_t *pr) { uint8_t *ra; unresolved_field *uf; fieldinfo *fi; uint8_t byte; ra = (uint8_t *) pr->mpc; uf = (unresolved_field *) pr->ref; /* get the fieldinfo */ if (!(fi = resolve_field_eager(uf))) return false; PATCH_BACK_ORIGINAL_MCODE; /* if we show disassembly, we have to skip the nop's */ if (opt_shownops) ra = ra + PATCHER_CALL_SIZE; /* Patch the field's offset: we check for the field type, because the instructions have different lengths. */ if (IS_INT_LNG_TYPE(fi->type)) { /* Check for special case: %rsp or %r12 as base register. */ byte = *(ra + 3); if (byte == 0x24) *((int32_t *) (ra + 4)) = fi->offset; else *((int32_t *) (ra + 3)) = fi->offset; } else { /* Check for special case: %rsp or %r12 as base register. */ byte = *(ra + 5); if (byte == 0x24) *((int32_t *) (ra + 6)) = fi->offset; else *((int32_t *) (ra + 5)) = fi->offset; } return true; } /* patcher_putfieldconst ******************************************************* Machine code: 41 c7 85 00 00 00 00 7b 00 00 00 movl $0x7b,0x0(%r13) *******************************************************************************/ bool patcher_putfieldconst(patchref_t *pr) { uint8_t *ra; unresolved_field *uf; fieldinfo *fi; uint8_t byte; ra = (uint8_t *) pr->mpc; uf = (unresolved_field *) pr->ref; /* get the fieldinfo */ if (!(fi = resolve_field_eager(uf))) return false; PATCH_BACK_ORIGINAL_MCODE; /* if we show disassembly, we have to skip the nop's */ if (opt_shownops) ra = ra + PATCHER_CALL_SIZE; /* patch the field's offset */ if (IS_2_WORD_TYPE(fi->type) || IS_ADR_TYPE(fi->type)) { /* handle special case when the base register is %r12 */ byte = *(ra + 2); if (byte == 0x84) { *((uint32_t *) (ra + 4)) = fi->offset; *((uint32_t *) (ra + 12 + 4)) = fi->offset + 4; } else { *((uint32_t *) (ra + 3)) = fi->offset; *((uint32_t *) (ra + 11 + 3)) = fi->offset + 4; } } else { /* handle special case when the base register is %r12 */ byte = *(ra + 2); if (byte == 0x84) *((uint32_t *) (ra + 4)) = fi->offset; else *((uint32_t *) (ra + 3)) = fi->offset; } return true; } /* patcher_invokestatic_special ************************************************ Machine code: 49 ba 00 00 00 00 00 00 00 00 mov $0x0,%r10 49 ff d2 callq *%r10 *******************************************************************************/ bool patcher_invokestatic_special(patchref_t *pr) { unresolved_method *um; intptr_t *datap; methodinfo *m; /* get stuff from the stack */ um = (unresolved_method *) pr->ref; datap = (intptr_t *) pr->datap; /* get the fieldinfo */ if (!(m = resolve_method_eager(um))) return false; PATCH_BACK_ORIGINAL_MCODE; /* patch stubroutine */ *datap = (intptr_t) m->stubroutine; return true; } /* patcher_invokevirtual ******************************************************* Machine code: 4c 8b 17 mov (%rdi),%r10 49 8b 82 00 00 00 00 mov 0x0(%r10),%rax 48 ff d0 callq *%rax *******************************************************************************/ bool patcher_invokevirtual(patchref_t *pr) { uint8_t *ra; unresolved_method *um; methodinfo *m; ra = (uint8_t *) pr->mpc; um = (unresolved_method *) pr->ref; /* get the methodinfo */ if (!(m = resolve_method_eager(um))) return false; PATCH_BACK_ORIGINAL_MCODE; /* if we show disassembly, we have to skip the nop's */ if (opt_shownops) ra = ra + PATCHER_CALL_SIZE; /* patch vftbl index */ *((int32_t *) (ra + 3 + 3)) = (int32_t) (OFFSET(vftbl_t, table[0]) + sizeof(methodptr) * m->vftblindex); return true; } /* patcher_invokeinterface ***************************************************** Machine code: 4c 8b 17 mov (%rdi),%r10 4d 8b 92 00 00 00 00 mov 0x0(%r10),%r10 49 8b 82 00 00 00 00 mov 0x0(%r10),%rax 48 ff d0 callq *%rax *******************************************************************************/ bool patcher_invokeinterface(patchref_t *pr) { uint8_t *ra; unresolved_method *um; methodinfo *m; /* get stuff from the stack */ ra = (uint8_t *) pr->mpc; um = (unresolved_method *) pr->ref; /* get the fieldinfo */ if (!(m = resolve_method_eager(um))) return false; PATCH_BACK_ORIGINAL_MCODE; /* if we show disassembly, we have to skip the nop's */ if (opt_shownops) ra = ra + PATCHER_CALL_SIZE; /* patch interfacetable index */ *((int32_t *) (ra + 3 + 3)) = (int32_t) (OFFSET(vftbl_t, interfacetable[0]) - sizeof(methodptr) * m->class->index); /* patch method offset */ *((int32_t *) (ra + 3 + 7 + 3)) = (int32_t) (sizeof(methodptr) * (m - m->class->methods)); return true; } /* patcher_checkcast_interface ************************************************* Machine code: 45 8b 9a 1c 00 00 00 mov 0x1c(%r10),%r11d 41 81 fb 00 00 00 00 cmp $0x0,%r11d 0f 8f 08 00 00 00 jg 0x00002aaaaae511d5 48 8b 0c 25 03 00 00 00 mov 0x3,%rcx 4d 8b 9a 00 00 00 00 mov 0x0(%r10),%r11 *******************************************************************************/ bool patcher_checkcast_interface(patchref_t *pr) { uint8_t *ra; constant_classref *cr; classinfo *c; ra = (uint8_t *) pr->mpc; cr = (constant_classref *) pr->ref; /* get the fieldinfo */ if (!(c = resolve_classref_eager(cr))) return false; PATCH_BACK_ORIGINAL_MCODE; /* if we show disassembly, we have to skip the nop's */ if (opt_shownops) ra = ra + PATCHER_CALL_SIZE; /* patch super class index */ *((int32_t *) (ra + 7 + 3)) = c->index; *((int32_t *) (ra + 7 + 7 + 6 + 8 + 3)) = (int32_t) (OFFSET(vftbl_t, interfacetable[0]) - c->index * sizeof(methodptr*)); return true; } /* patcher_instanceof_interface ************************************************ Machine code: 45 8b 9a 1c 00 00 00 mov 0x1c(%r10),%r11d 41 81 fb 00 00 00 00 cmp $0x0,%r11d 0f 8e 94 04 00 00 jle 0x00002aaaaab018f8 4d 8b 9a 00 00 00 00 mov 0x0(%r10),%r11 *******************************************************************************/ bool patcher_instanceof_interface(patchref_t *pr) { uint8_t *ra; constant_classref *cr; classinfo *c; ra = (uint8_t *) pr->mpc; cr = (constant_classref *) pr->ref; /* get the fieldinfo */ if (!(c = resolve_classref_eager(cr))) return false; PATCH_BACK_ORIGINAL_MCODE; /* if we show disassembly, we have to skip the nop's */ if (opt_shownops) ra = ra + PATCHER_CALL_SIZE; /* patch super class index */ *((int32_t *) (ra + 7 + 3)) = c->index; *((int32_t *) (ra + 7 + 7 + 6 + 3)) = (int32_t) (OFFSET(vftbl_t, interfacetable[0]) - c->index * sizeof(methodptr*)); return true; } /* * These are local overrides for various environment variables in Emacs. * Please do not remove this and leave it at the end of the file, where * Emacs will automagically detect them. * --------------------------------------------------------------------- * Local variables: * mode: c * indent-tabs-mode: t * c-basic-offset: 4 * tab-width: 4 * End: * vim:noexpandtab:sw=4:ts=4: */