src/vm/jit/arm/md.c

   1 /* src/vm/jit/arm/md.c - machine dependent Arm functions
   2
   3    Copyright (C) 1996-2005, 2006, 2007 R. Grafl, A. Krall, C. Kruegel,
   4    C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring,
   5    E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich,
   6    J. Wenninger, Institut f. Computersprachen - TU Wien
   7
   8    This file is part of CACAO.
   9
  10    This program is free software; you can redistribute it and/or
  11    modify it under the terms of the GNU General Public License as
  12    published by the Free Software Foundation; either version 2, or (at
  13    your option) any later version.
  14
  15    This program is distributed in the hope that it will be useful, but
  16    WITHOUT ANY WARRANTY; without even the implied warranty of
  17    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU
  18    General Public License for more details.
  19
  20    You should have received a copy of the GNU General Public License
  21    along with this program; if not, write to the Free Software
  22    Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
  23    02110-1301, USA.
  24
  25    $Id: md.c 7540 2007-03-20 00:02:41Z michi $
  26
  27 */
  28
  29
  30 #include "config.h"
  31
  32 #include <assert.h>
  33
  34 #include "vm/types.h"
  35
  36 #include "vm/jit/arm/md-abi.h"
  37
  38 #include "vm/exceptions.h"
  39 #include "vm/global.h"
  40
  41 #include "vm/jit/asmpart.h"
  42 #include "vm/jit/md.h"
  43
  44 #include "vm/jit/codegen-common.h" /* REMOVE ME: for codegendata */
  45
  46
  47 /* md_init *********************************************************************
  48
  49    Do some machine dependent initialization.
  50
  51 *******************************************************************************/
  52
  53 void md_init(void)
  54 {
  55         /* do nothing here */
  56 }
  57
  58
  59 /* md_codegen_patch_branch *****************************************************
  60
  61    Back-patches a branch instruction.
  62
  63 *******************************************************************************/
  64
  65 void md_codegen_patch_branch(codegendata *cd, s4 branchmpc, s4 targetmpc)
  66 {
  67         s4 *mcodeptr;
  68         s4  disp;                           /* branch displacement                */
  69
  70         /* calculate the patch position */
  71
  72         mcodeptr = (s4 *) (cd->mcodebase + branchmpc);
  73
  74         /* Calculate the branch displacement. */
  75
  76         disp = (targetmpc - branchmpc - 4) >> 2;
  77
  78         if ((disp < (s4) 0xff000000) || (disp > (s4) 0x00ffffff))
  79                 vm_abort("md_codegen_patch_branch: branch displacement out of range: %d > +/-%d", disp, 0x00ffffff);
  80
  81         /* sanity check: are we really patching a branch instruction */
  82
  83         assert((mcodeptr[-1] & 0x0e000000) == 0x0a000000);
  84
  85         /* patch the branch instruction before the mcodeptr */
  86
  87         mcodeptr[-1] |= (disp & 0x00ffffff);
  88 }
  89
  90
  91 /* md_stacktrace_get_returnaddress *********************************************
  92
  93    Returns the return address of the current stackframe, specified by
  94    the passed stack pointer and the stack frame size.
  95
  96 *******************************************************************************/
  97
  98 u1 *md_stacktrace_get_returnaddress(u1 *sp, u4 framesize)
  99 {
 100         u1 *ra;
 101
 102         /*printf("md_stacktrace_get_returnaddress(): called (sp=%x, framesize=%d)\n", sp, framesize);*/
 103
 104         /* on ARM the return address is located on the top of the stackframe */
 105         /* ATTENTION: this is only true for non-leaf methods !!! */
 106         ra = *((u1 **) (sp + framesize - SIZEOF_VOID_P));
 107
 108         /*printf("md_stacktrace_get_returnaddress(): result (ra=%x)\n", ra);*/
 109
 110         return ra;
 111 }
 112
 113
 114 /* md_assembler_get_patch_address **********************************************
 115
 116    Gets the patch address of the currently compiled method. The offset
 117    is extracted from the load instruction(s) before the jump and added
 118    to the right base address (PV or REG_METHODPTR).
 119
 120    Machine code:
 121
 122    e51cc040    ldr   ip, [ip, #-64]
 123    e1a0e00f    mov   lr, pc
 124    e1a0f00c    mov   pc, ip
 125
 126    or
 127
 128    e590b000    ldr   fp, [r0]
 129    e59bc000    ldr   ip, [fp]
 130    e1a0e00f    mov   lr, pc
 131    e1a0f00c    mov   pc, ip
 132
 133    How we find out the patching address to store new method pointer:
 134     - loaded IP with LDR IP,[METHODPTR]?
 135         yes=INVOKEVIRTUAL or INVOKEINTERFACE (things are easy!)
 136     - loaded IP from data segment
 137         yes=INVOKESTATIC or INVOKESPECIAL (things are complicated)
 138         recompute pointer to data segment, maybe larger offset
 139
 140 *******************************************************************************/
 141
 142 u1 *md_get_method_patch_address(u1 *ra, stackframeinfo *sfi, u1 *mptr)
 143 {
 144         u4  mcode;
 145         s4  offset;
 146         u1 *pa;                             /* patch address                      */
 147
 148         /* sanity check: are we inside jit code? */
 149
 150         assert(*((u4 *) (ra - 2*4)) == 0xe1a0e00f /*MOV LR,PC*/);
 151         assert(*((u4 *) (ra - 1*4)) == 0xe1a0f00c /*MOV PC,IP*/);
 152
 153         /* get the load instruction and offset */
 154
 155         mcode  = *((u4 *) (ra - 12));
 156         offset = (s4) (mcode & 0x0fff);
 157
 158         assert ((mcode & 0xff70f000) == 0xe510c000);
 159
 160         if ((mcode & 0x000f0000) == 0x000b0000) {
 161                 /* sanity check: offset was positive */
 162
 163                 assert((mcode & 0x00800000) == 0x00800000);
 164
 165                 /* we loaded from REG_METHODPTR */
 166
 167                 pa = mptr + offset;
 168         }
 169         else {
 170                 /* sanity check: we loaded from REG_IP; offset was negative or zero */
 171
 172                 assert((mcode & 0x008f0000) == 0x000c0000 ||
 173                        (mcode & 0x008f0fff) == 0x008c0000);
 174
 175                 /* we loaded from data segment; offset can be larger */
 176
 177                 mcode = *((u4 *) (ra - 4*4));
 178
 179                 /* check for "SUB IP, IP, #??, ROTL 12" */
 180
 181                 if ((mcode & 0xffffff00) == 0xe24cca00)
 182                         offset += (s4) ((mcode & 0x00ff) << 12);
 183
 184                 /* and get the final data segment address */
 185
 186                 pa = sfi->pv - offset;
 187         }
 188
 189         return pa;
 190 }
 191
 192
 193 /* md_codegen_get_pv_from_pc ***************************************************
 194
 195    TODO: document me
 196
 197 *******************************************************************************/
 198
 199 u1 *md_codegen_get_pv_from_pc(u1 *ra)
 200 {
 201         u1 *pv;
 202         u4  mcode1, mcode2, mcode3;
 203
 204         pv = ra;
 205
 206         /* this can either be a RECOMPUTE_IP in JIT code or a fake in asm_calljavafunction */
 207         mcode1 = *((u4*) ra);
 208         if ((mcode1 & 0xffffff00) == 0xe24fcf00 /*sub ip,pc,#__*/)
 209                 pv -= (s4) ((mcode1 & 0x000000ff) <<  2);
 210         else if ((mcode1 & 0xffffff00) == 0xe24fc000 /*sub ip,pc,#__*/)
 211                 pv -= (s4) (mcode1 & 0x000000ff);
 212         else {
 213                 /* if this happens, we got an unexpected instruction at (*ra) */
 214                 vm_abort("Unable to find method: %p (instr=%x)", ra, mcode1);
 215         }
 216
 217         /* if we have a RECOMPUTE_IP there can be more than one instruction */
 218         mcode2 = *((u4*) (ra + 4));
 219         mcode3 = *((u4*) (ra + 8));
 220         if ((mcode2 & 0xffffff00) == 0xe24ccb00 /*sub ip,ip,#__*/)
 221                 pv -= (s4) ((mcode2 & 0x000000ff) << 10);
 222         if ((mcode3 & 0xffffff00) == 0xe24cc700 /*sub ip,ip,#__*/)
 223                 pv -= (s4) ((mcode3 & 0x000000ff) << 18);
 224
 225         /* we used PC-relative adressing; but now it is LR-relative */
 226         pv += 8;
 227
 228         /* if we found our method the data segment has to be valid */
 229         /* we check this by looking up the IsLeaf field, which has to be boolean */
 230         assert( *((s4*)pv-4) == (s4)true || *((s4*)pv-4) == (s4)false );
 231
 232         return pv;
 233 }
 234
 235
 236 /* md_cacheflush ***************************************************************
 237
 238    Calls the system's function to flush the instruction and data
 239    cache.
 240
 241 *******************************************************************************/
 242
 243 void md_cacheflush(u1 *addr, s4 nbytes)
 244 {
 245         asm_cacheflush(addr, nbytes);
 246 }
 247
 248
 249 /* md_icacheflush **************************************************************
 250
 251    Calls the system's function to flush the instruction cache.
 252
 253 *******************************************************************************/
 254
 255 void md_icacheflush(u1 *addr, s4 nbytes)
 256 {
 257         asm_cacheflush(addr, nbytes);
 258 }
 259
 260
 261 /* md_dcacheflush **************************************************************
 262
 263    Calls the system's function to flush the data cache.
 264
 265 *******************************************************************************/
 266
 267 void md_dcacheflush(u1 *addr, s4 nbytes)
 268 {
 269         asm_cacheflush(addr, nbytes);
 270 }
 271
 272
 273 /*
 274  * These are local overrides for various environment variables in Emacs.
 275  * Please do not remove this and leave it at the end of the file, where
 276  * Emacs will automagically detect them.
 277  * ---------------------------------------------------------------------
 278  * Local variables:
 279  * mode: c
 280  * indent-tabs-mode: t
 281  * c-basic-offset: 4
 282  * tab-width: 4
 283  * End:
 284  * vim:noexpandtab:sw=4:ts=4:
 285  */