vm/InlineNative.cpp

   1 /*
   2  * Copyright (C) 2008 The Android Open Source Project
   3  *
   4  * Licensed under the Apache License, Version 2.0 (the "License");
   5  * you may not use this file except in compliance with the License.
   6  * You may obtain a copy of the License at
   7  *
   8  *      http://www.apache.org/licenses/LICENSE-2.0
   9  *
  10  * Unless required by applicable law or agreed to in writing, software
  11  * distributed under the License is distributed on an "AS IS" BASIS,
  12  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  13  * See the License for the specific language governing permissions and
  14  * limitations under the License.
  15  */
  16
  17 /*
  18  * Inlined native functions.  These definitions replace interpreted or
  19  * native implementations at runtime; "intrinsic" might be a better word.
  20  */
  21 #include "Dalvik.h"
  22
  23 #include <math.h>
  24
  25 #ifdef HAVE__MEMCMP16
  26 /* hand-coded assembly implementation, available on some platforms */
  27 //#warning "trying memcmp16"
  28 //#define CHECK_MEMCMP16
  29 /* "count" is in 16-bit units */
  30 extern "C" u4 __memcmp16(const u2* s0, const u2* s1, size_t count);
  31 #endif
  32
  33 /*
  34  * Some notes on "inline" functions.
  35  *
  36  * These are NOT simply native implementations.  A full method definition
  37  * must still be provided.  Depending on the flags passed into the VM
  38  * at runtime, the original or inline version may be selected by the
  39  * DEX optimizer.
  40  *
  41  * PLEASE DO NOT use this as the default location for native methods.
  42  * The difference between this and an "internal native" static method
  43  * call on a 200MHz ARM 9 is roughly 370ns vs. 700ns.  The code here
  44  * "secretly replaces" the other method, so you can't avoid having two
  45  * implementations.  Since the DEX optimizer mode can't be known ahead
  46  * of time, both implementations must be correct and complete.
  47  *
  48  * The only stuff that really needs to be here are methods that
  49  * are high-volume or must be low-overhead, e.g. certain String/Math
  50  * methods and some java.util.concurrent.atomic operations.
  51  *
  52  * Normally, a class is loaded and initialized the first time a static
  53  * method is invoked.  This property is NOT preserved here.  If you need
  54  * to access a static field in a class, you must ensure initialization
  55  * yourself (cheap/easy way is to check the resolved-methods table, and
  56  * resolve the method if it hasn't been).
  57  *
  58  * DO NOT replace "synchronized" methods.  We do not support method
  59  * synchronization here.
  60  *
  61  * DO NOT perform any allocations or do anything that could cause a
  62  * garbage collection.  The method arguments are not visible to the GC
  63  * and will not be pinned or updated when memory blocks move.  You are
  64  * allowed to allocate and throw an exception so long as you only do so
  65  * immediately before returning.
  66  *
  67  * Remember that these functions are executing while the thread is in
  68  * the "RUNNING" state, not the "NATIVE" state.  If you perform a blocking
  69  * operation you can stall the entire VM if the GC or debugger wants to
  70  * suspend the thread.  Since these are arguably native implementations
  71  * rather than VM internals, prefer NATIVE to VMWAIT if you want to change
  72  * the thread state.
  73  *
  74  * Always write results to 32-bit or 64-bit fields in "pResult", e.g. do
  75  * not write boolean results to pResult->z.  The interpreter expects
  76  * 32 or 64 bits to be set.
  77  *
  78  * Inline op methods return "false" if an exception was thrown, "true" if
  79  * everything went well.
  80  *
  81  * DO NOT provide implementations of methods that can be overridden by a
  82  * subclass, as polymorphism does not work correctly.  For safety you should
  83  * only provide inline functions for classes/methods declared "final".
  84  *
  85  * It's best to avoid inlining the overridden version of a method.  For
  86  * example, String.hashCode() is inherited from Object.hashCode().  Code
  87  * calling String.hashCode() through an Object reference will run the
  88  * "slow" version, while calling it through a String reference gets
  89  * the inlined version.  It's best to have just one version unless there
  90  * are clear performance gains.
  91  *
  92  * Because the actual method is not called, debugger breakpoints on these
  93  * methods will not happen.  (TODO: have the code here find the original
  94  * method and call it when the debugger is active.)  Additional steps have
  95  * been taken to allow method profiling to produce correct results.
  96  */
  97
  98
  99 /*
 100  * ===========================================================================
 101  *      org.apache.harmony.dalvik.NativeTestTarget
 102  * ===========================================================================
 103  */
 104
 105 /*
 106  * public static void emptyInlineMethod
 107  *
 108  * This exists only for benchmarks.
 109  */
 110 static bool org_apache_harmony_dalvik_NativeTestTarget_emptyInlineMethod(
 111     u4 arg0, u4 arg1, u4 arg2, u4 arg3, JValue* pResult)
 112 {
 113     // do nothing
 114     return true;
 115 }
 116
 117
 118 /*
 119  * ===========================================================================
 120  *      java.lang.String
 121  * ===========================================================================
 122  */
 123
 124 /*
 125  * public char charAt(int index)
 126  */
 127 bool javaLangString_charAt(u4 arg0, u4 arg1, u4 arg2, u4 arg3,
 128     JValue* pResult)
 129 {
 130     int count, offset;
 131     ArrayObject* chars;
 132
 133     /* null reference check on "this" */
 134     if ((Object*) arg0 == NULL) {
 135         dvmThrowNullPointerException(NULL);
 136         return false;
 137     }
 138
 139     //ALOGI("String.charAt this=0x%08x index=%d", arg0, arg1);
 140     count = dvmGetFieldInt((Object*) arg0, STRING_FIELDOFF_COUNT);
 141     if ((s4) arg1 < 0 || (s4) arg1 >= count) {
 142         dvmThrowStringIndexOutOfBoundsExceptionWithIndex(count, arg1);
 143         return false;
 144     } else {
 145         offset = dvmGetFieldInt((Object*) arg0, STRING_FIELDOFF_OFFSET);
 146         chars = (ArrayObject*)
 147             dvmGetFieldObject((Object*) arg0, STRING_FIELDOFF_VALUE);
 148
 149         pResult->i = ((const u2*)(void*)chars->contents)[arg1 + offset];
 150         return true;
 151     }
 152 }
 153
 154 #ifdef CHECK_MEMCMP16
 155 /*
 156  * Utility function when we're evaluating alternative implementations.
 157  */
 158 static void badMatch(StringObject* thisStrObj, StringObject* compStrObj,
 159     int expectResult, int newResult, const char* compareType)
 160 {
 161     ArrayObject* thisArray;
 162     ArrayObject* compArray;
 163     const char* thisStr;
 164     const char* compStr;
 165     int thisOffset, compOffset, thisCount, compCount;
 166
 167     thisCount =
 168         dvmGetFieldInt((Object*) thisStrObj, STRING_FIELDOFF_COUNT);
 169     compCount =
 170         dvmGetFieldInt((Object*) compStrObj, STRING_FIELDOFF_COUNT);
 171     thisOffset =
 172         dvmGetFieldInt((Object*) thisStrObj, STRING_FIELDOFF_OFFSET);
 173     compOffset =
 174         dvmGetFieldInt((Object*) compStrObj, STRING_FIELDOFF_OFFSET);
 175     thisArray = (ArrayObject*)
 176         dvmGetFieldObject((Object*) thisStrObj, STRING_FIELDOFF_VALUE);
 177     compArray = (ArrayObject*)
 178         dvmGetFieldObject((Object*) compStrObj, STRING_FIELDOFF_VALUE);
 179
 180     thisStr = dvmCreateCstrFromString(thisStrObj);
 181     compStr = dvmCreateCstrFromString(compStrObj);
 182
 183     ALOGE("%s expected %d got %d", compareType, expectResult, newResult);
 184     ALOGE(" this (o=%d l=%d) '%s'", thisOffset, thisCount, thisStr);
 185     ALOGE(" comp (o=%d l=%d) '%s'", compOffset, compCount, compStr);
 186     dvmPrintHexDumpEx(ANDROID_LOG_INFO, LOG_TAG,
 187         ((const u2*) thisArray->contents) + thisOffset, thisCount*2,
 188         kHexDumpLocal);
 189     dvmPrintHexDumpEx(ANDROID_LOG_INFO, LOG_TAG,
 190         ((const u2*) compArray->contents) + compOffset, compCount*2,
 191         kHexDumpLocal);
 192     dvmAbort();
 193 }
 194 #endif
 195
 196 /*
 197  * public int compareTo(String s)
 198  */
 199 bool javaLangString_compareTo(u4 arg0, u4 arg1, u4 arg2, u4 arg3,
 200     JValue* pResult)
 201 {
 202     /*
 203      * Null reference check on "this".  Normally this is performed during
 204      * the setup of the virtual method call.  We need to do it before
 205      * anything else.  While we're at it, check out the other string,
 206      * which must also be non-null.
 207      */
 208     if ((Object*) arg0 == NULL || (Object*) arg1 == NULL) {
 209         dvmThrowNullPointerException(NULL);
 210         return false;
 211     }
 212
 213     /* quick test for comparison with itself */
 214     if (arg0 == arg1) {
 215         pResult->i = 0;
 216         return true;
 217     }
 218
 219     /*
 220      * This would be simpler and faster if we promoted StringObject to
 221      * a full representation, lining up the C structure fields with the
 222      * actual object fields.
 223      */
 224     int thisCount, thisOffset, compCount, compOffset;
 225     ArrayObject* thisArray;
 226     ArrayObject* compArray;
 227     const u2* thisChars;
 228     const u2* compChars;
 229     int minCount, countDiff;
 230
 231     thisCount = dvmGetFieldInt((Object*) arg0, STRING_FIELDOFF_COUNT);
 232     compCount = dvmGetFieldInt((Object*) arg1, STRING_FIELDOFF_COUNT);
 233     countDiff = thisCount - compCount;
 234     minCount = (countDiff < 0) ? thisCount : compCount;
 235     thisOffset = dvmGetFieldInt((Object*) arg0, STRING_FIELDOFF_OFFSET);
 236     compOffset = dvmGetFieldInt((Object*) arg1, STRING_FIELDOFF_OFFSET);
 237     thisArray = (ArrayObject*)
 238         dvmGetFieldObject((Object*) arg0, STRING_FIELDOFF_VALUE);
 239     compArray = (ArrayObject*)
 240         dvmGetFieldObject((Object*) arg1, STRING_FIELDOFF_VALUE);
 241     thisChars = ((const u2*)(void*)thisArray->contents) + thisOffset;
 242     compChars = ((const u2*)(void*)compArray->contents) + compOffset;
 243
 244 #ifdef HAVE__MEMCMP16
 245     /*
 246      * Use assembly version, which returns the difference between the
 247      * characters.  The annoying part here is that 0x00e9 - 0xffff != 0x00ea,
 248      * because the interpreter converts the characters to 32-bit integers
 249      * *without* sign extension before it subtracts them (which makes some
 250      * sense since "char" is unsigned).  So what we get is the result of
 251      * 0x000000e9 - 0x0000ffff, which is 0xffff00ea.
 252      */
 253     int otherRes = __memcmp16(thisChars, compChars, minCount);
 254 # ifdef CHECK_MEMCMP16
 255     int i;
 256     for (i = 0; i < minCount; i++) {
 257         if (thisChars[i] != compChars[i]) {
 258             pResult->i = (s4) thisChars[i] - (s4) compChars[i];
 259             if (pResult->i != otherRes) {
 260                 badMatch((StringObject*) arg0, (StringObject*) arg1,
 261                     pResult->i, otherRes, "compareTo");
 262             }
 263             return true;
 264         }
 265     }
 266 # endif
 267     if (otherRes != 0) {
 268         pResult->i = otherRes;
 269         return true;
 270     }
 271
 272 #else
 273     /*
 274      * Straightforward implementation, examining 16 bits at a time.  Compare
 275      * the characters that overlap, and if they're all the same then return
 276      * the difference in lengths.
 277      */
 278     int i;
 279     for (i = 0; i < minCount; i++) {
 280         if (thisChars[i] != compChars[i]) {
 281             pResult->i = (s4) thisChars[i] - (s4) compChars[i];
 282             return true;
 283         }
 284     }
 285 #endif
 286
 287     pResult->i = countDiff;
 288     return true;
 289 }
 290
 291 /*
 292  * public boolean equals(Object anObject)
 293  */
 294 bool javaLangString_equals(u4 arg0, u4 arg1, u4 arg2, u4 arg3,
 295     JValue* pResult)
 296 {
 297     /*
 298      * Null reference check on "this".
 299      */
 300     if ((Object*) arg0 == NULL) {
 301         dvmThrowNullPointerException(NULL);
 302         return false;
 303     }
 304
 305     /* quick test for comparison with itself */
 306     if (arg0 == arg1) {
 307         pResult->i = true;
 308         return true;
 309     }
 310
 311     /*
 312      * See if the other object is also a String.
 313      *
 314      * str.equals(null) is expected to return false, presumably based on
 315      * the results of the instanceof test.
 316      */
 317     if (arg1 == 0 || ((Object*) arg0)->clazz != ((Object*) arg1)->clazz) {
 318         pResult->i = false;
 319         return true;
 320     }
 321
 322     /*
 323      * This would be simpler and faster if we promoted StringObject to
 324      * a full representation, lining up the C structure fields with the
 325      * actual object fields.
 326      */
 327     int thisCount, thisOffset, compCount, compOffset;
 328     ArrayObject* thisArray;
 329     ArrayObject* compArray;
 330     const u2* thisChars;
 331     const u2* compChars;
 332
 333     /* quick length check */
 334     thisCount = dvmGetFieldInt((Object*) arg0, STRING_FIELDOFF_COUNT);
 335     compCount = dvmGetFieldInt((Object*) arg1, STRING_FIELDOFF_COUNT);
 336     if (thisCount != compCount) {
 337         pResult->i = false;
 338         return true;
 339     }
 340
 341     /*
 342      * You may, at this point, be tempted to pull out the hashCode fields
 343      * and compare them.  If both fields have been initialized, and they
 344      * are not equal, we can return false immediately.
 345      *
 346      * However, the hashCode field is often not set.  If it is set,
 347      * there's an excellent chance that the String is being used as a key
 348      * in a hashed data structure (e.g. HashMap).  That data structure has
 349      * already made the comparison and determined that the hashes are equal,
 350      * making a check here redundant.
 351      *
 352      * It's not clear that checking the hashes will be a win in "typical"
 353      * use cases.  We err on the side of simplicity and ignore them.
 354      */
 355
 356     thisOffset = dvmGetFieldInt((Object*) arg0, STRING_FIELDOFF_OFFSET);
 357     compOffset = dvmGetFieldInt((Object*) arg1, STRING_FIELDOFF_OFFSET);
 358     thisArray = (ArrayObject*)
 359         dvmGetFieldObject((Object*) arg0, STRING_FIELDOFF_VALUE);
 360     compArray = (ArrayObject*)
 361         dvmGetFieldObject((Object*) arg1, STRING_FIELDOFF_VALUE);
 362     thisChars = ((const u2*)(void*)thisArray->contents) + thisOffset;
 363     compChars = ((const u2*)(void*)compArray->contents) + compOffset;
 364
 365 #ifdef HAVE__MEMCMP16
 366     pResult->i = (__memcmp16(thisChars, compChars, thisCount) == 0);
 367 # ifdef CHECK_MEMCMP16
 368     int otherRes = (memcmp(thisChars, compChars, thisCount * 2) == 0);
 369     if (pResult->i != otherRes) {
 370         badMatch((StringObject*) arg0, (StringObject*) arg1,
 371             otherRes, pResult->i, "equals-1");
 372     }
 373 # endif
 374 #else
 375     /*
 376      * Straightforward implementation, examining 16 bits at a time.  The
 377      * direction of the loop doesn't matter, and starting at the end may
 378      * give us an advantage when comparing certain types of strings (e.g.
 379      * class names).
 380      *
 381      * We want to go forward for benchmarks against __memcmp16 so we get a
 382      * meaningful comparison when the strings don't match (could also test
 383      * with palindromes).
 384      */
 385     int i;
 386     //for (i = 0; i < thisCount; i++)
 387     for (i = thisCount-1; i >= 0; --i)
 388     {
 389         if (thisChars[i] != compChars[i]) {
 390             pResult->i = false;
 391             return true;
 392         }
 393     }
 394     pResult->i = true;
 395 #endif
 396
 397     return true;
 398 }
 399
 400 /*
 401  * public int length()
 402  */
 403 bool javaLangString_length(u4 arg0, u4 arg1, u4 arg2, u4 arg3,
 404     JValue* pResult)
 405 {
 406     //ALOGI("String.length this=0x%08x pResult=%p", arg0, pResult);
 407
 408     /* null reference check on "this" */
 409     if ((Object*) arg0 == NULL) {
 410         dvmThrowNullPointerException(NULL);
 411         return false;
 412     }
 413
 414     pResult->i = dvmGetFieldInt((Object*) arg0, STRING_FIELDOFF_COUNT);
 415     return true;
 416 }
 417
 418 /*
 419  * public boolean isEmpty()
 420  */
 421 bool javaLangString_isEmpty(u4 arg0, u4 arg1, u4 arg2, u4 arg3,
 422     JValue* pResult)
 423 {
 424     //ALOGI("String.isEmpty this=0x%08x pResult=%p", arg0, pResult);
 425
 426     /* null reference check on "this" */
 427     if ((Object*) arg0 == NULL) {
 428         dvmThrowNullPointerException(NULL);
 429         return false;
 430     }
 431
 432     pResult->i = (dvmGetFieldInt((Object*) arg0, STRING_FIELDOFF_COUNT) == 0);
 433     return true;
 434 }
 435
 436 /*
 437  * Determine the index of the first character matching "ch".  The string
 438  * to search is described by "chars", "offset", and "count".
 439  *
 440  * The character must be <= 0xffff. Supplementary characters are handled in
 441  * Java.
 442  *
 443  * The "start" parameter must be clamped to [0..count].
 444  *
 445  * Returns -1 if no match is found.
 446  */
 447 static inline int indexOfCommon(Object* strObj, int ch, int start)
 448 {
 449     //if ((ch & 0xffff) != ch)        /* 32-bit code point */
 450     //    return -1;
 451
 452     /* pull out the basic elements */
 453     ArrayObject* charArray =
 454         (ArrayObject*) dvmGetFieldObject(strObj, STRING_FIELDOFF_VALUE);
 455     const u2* chars = (const u2*)(void*)charArray->contents;
 456     int offset = dvmGetFieldInt(strObj, STRING_FIELDOFF_OFFSET);
 457     int count = dvmGetFieldInt(strObj, STRING_FIELDOFF_COUNT);
 458     //ALOGI("String.indexOf(0x%08x, 0x%04x, %d) off=%d count=%d",
 459     //    (u4) strObj, ch, start, offset, count);
 460
 461     /* factor out the offset */
 462     chars += offset;
 463
 464     if (start < 0)
 465         start = 0;
 466     else if (start > count)
 467         start = count;
 468
 469 #if 0
 470     /* 16-bit loop, simple */
 471     while (start < count) {
 472         if (chars[start] == ch)
 473             return start;
 474         start++;
 475     }
 476 #else
 477     /* 16-bit loop, slightly better on ARM */
 478     const u2* ptr = chars + start;
 479     const u2* endPtr = chars + count;
 480     while (ptr < endPtr) {
 481         if (*ptr++ == ch)
 482             return (ptr-1) - chars;
 483     }
 484 #endif
 485
 486     return -1;
 487 }
 488
 489 /*
 490  * public int indexOf(int c, int start)
 491  *
 492  * Scan forward through the string for a matching character.
 493  * The character must be <= 0xffff; this method does not handle supplementary
 494  * characters.
 495  */
 496 bool javaLangString_fastIndexOf_II(u4 arg0, u4 arg1, u4 arg2, u4 arg3,
 497     JValue* pResult)
 498 {
 499     /* null reference check on "this" */
 500     if ((Object*) arg0 == NULL) {
 501         dvmThrowNullPointerException(NULL);
 502         return false;
 503     }
 504
 505     pResult->i = indexOfCommon((Object*) arg0, arg1, arg2);
 506     return true;
 507 }
 508
 509
 510 /*
 511  * ===========================================================================
 512  *      java.lang.Math
 513  * ===========================================================================
 514  */
 515
 516 union Convert32 {
 517     u4 arg;
 518     float ff;
 519 };
 520
 521 union Convert64 {
 522     u4 arg[2];
 523     s8 ll;
 524     double dd;
 525 };
 526
 527 /*
 528  * public static int abs(int)
 529  */
 530 bool javaLangMath_abs_int(u4 arg0, u4 arg1, u4 arg2, u4 arg3,
 531     JValue* pResult)
 532 {
 533     s4 val = (s4) arg0;
 534     pResult->i = (val >= 0) ? val : -val;
 535     return true;
 536 }
 537
 538 /*
 539  * public static long abs(long)
 540  */
 541 bool javaLangMath_abs_long(u4 arg0, u4 arg1, u4 arg2, u4 arg3,
 542     JValue* pResult)
 543 {
 544     Convert64 convert;
 545     convert.arg[0] = arg0;
 546     convert.arg[1] = arg1;
 547     s8 val = convert.ll;
 548     pResult->j = (val >= 0) ? val : -val;
 549     return true;
 550 }
 551
 552 /*
 553  * public static float abs(float)
 554  */
 555 bool javaLangMath_abs_float(u4 arg0, u4 arg1, u4 arg2, u4 arg3,
 556     JValue* pResult)
 557 {
 558     Convert32 convert;
 559     /* clear the sign bit; assumes a fairly common fp representation */
 560     convert.arg = arg0 & 0x7fffffff;
 561     pResult->f = convert.ff;
 562     return true;
 563 }
 564
 565 /*
 566  * public static double abs(double)
 567  */
 568 bool javaLangMath_abs_double(u4 arg0, u4 arg1, u4 arg2, u4 arg3,
 569     JValue* pResult)
 570 {
 571     Convert64 convert;
 572     convert.arg[0] = arg0;
 573     convert.arg[1] = arg1;
 574     /* clear the sign bit in the (endian-dependent) high word */
 575     convert.ll &= 0x7fffffffffffffffULL;
 576     pResult->d = convert.dd;
 577     return true;
 578 }
 579
 580 /*
 581  * public static int min(int)
 582  */
 583 bool javaLangMath_min_int(u4 arg0, u4 arg1, u4 arg2, u4 arg3,
 584     JValue* pResult)
 585 {
 586     pResult->i = ((s4) arg0 < (s4) arg1) ? arg0 : arg1;
 587     return true;
 588 }
 589
 590 /*
 591  * public static int max(int)
 592  */
 593 bool javaLangMath_max_int(u4 arg0, u4 arg1, u4 arg2, u4 arg3,
 594     JValue* pResult)
 595 {
 596     pResult->i = ((s4) arg0 > (s4) arg1) ? arg0 : arg1;
 597     return true;
 598 }
 599
 600 /*
 601  * public static double sqrt(double)
 602  *
 603  * With ARM VFP enabled, gcc turns this into an fsqrtd instruction, followed
 604  * by an fcmpd of the result against itself.  If it doesn't match (i.e.
 605  * it's NaN), the libm sqrt() is invoked.
 606  */
 607 bool javaLangMath_sqrt(u4 arg0, u4 arg1, u4 arg2, u4 arg3,
 608     JValue* pResult)
 609 {
 610     Convert64 convert;
 611     convert.arg[0] = arg0;
 612     convert.arg[1] = arg1;
 613     pResult->d = sqrt(convert.dd);
 614     return true;
 615 }
 616
 617 /*
 618  * public static double cos(double)
 619  */
 620 bool javaLangMath_cos(u4 arg0, u4 arg1, u4 arg2, u4 arg3,
 621     JValue* pResult)
 622 {
 623     Convert64 convert;
 624     convert.arg[0] = arg0;
 625     convert.arg[1] = arg1;
 626     pResult->d = cos(convert.dd);
 627     return true;
 628 }
 629
 630 /*
 631  * public static double sin(double)
 632  */
 633 bool javaLangMath_sin(u4 arg0, u4 arg1, u4 arg2, u4 arg3,
 634     JValue* pResult)
 635 {
 636     Convert64 convert;
 637     convert.arg[0] = arg0;
 638     convert.arg[1] = arg1;
 639     pResult->d = sin(convert.dd);
 640     return true;
 641 }
 642
 643 /*
 644  * ===========================================================================
 645  *      java.lang.Float
 646  * ===========================================================================
 647  */
 648
 649 bool javaLangFloat_floatToIntBits(u4 arg0, u4 arg1, u4 arg2, u4 arg,
 650     JValue* pResult)
 651 {
 652     Convert32 convert;
 653     convert.arg = arg0;
 654     pResult->i = isnanf(convert.ff) ? 0x7fc00000 : arg0;
 655     return true;
 656 }
 657
 658 bool javaLangFloat_floatToRawIntBits(u4 arg0, u4 arg1, u4 arg2, u4 arg,
 659     JValue* pResult)
 660 {
 661     pResult->i = arg0;
 662     return true;
 663 }
 664
 665 bool javaLangFloat_intBitsToFloat(u4 arg0, u4 arg1, u4 arg2, u4 arg,
 666     JValue* pResult)
 667 {
 668     Convert32 convert;
 669     convert.arg = arg0;
 670     pResult->f = convert.ff;
 671     return true;
 672 }
 673
 674 /*
 675  * ===========================================================================
 676  *      java.lang.Double
 677  * ===========================================================================
 678  */
 679
 680 bool javaLangDouble_doubleToLongBits(u4 arg0, u4 arg1, u4 arg2, u4 arg,
 681     JValue* pResult)
 682 {
 683     Convert64 convert;
 684     convert.arg[0] = arg0;
 685     convert.arg[1] = arg1;
 686     pResult->j = isnan(convert.dd) ? 0x7ff8000000000000LL : convert.ll;
 687     return true;
 688 }
 689
 690 bool javaLangDouble_doubleToRawLongBits(u4 arg0, u4 arg1, u4 arg2,
 691     u4 arg, JValue* pResult)
 692 {
 693     Convert64 convert;
 694     convert.arg[0] = arg0;
 695     convert.arg[1] = arg1;
 696     pResult->j = convert.ll;
 697     return true;
 698 }
 699
 700 bool javaLangDouble_longBitsToDouble(u4 arg0, u4 arg1, u4 arg2, u4 arg,
 701     JValue* pResult)
 702 {
 703     Convert64 convert;
 704     convert.arg[0] = arg0;
 705     convert.arg[1] = arg1;
 706     pResult->d = convert.dd;
 707     return true;
 708 }
 709
 710 /*
 711  * ===========================================================================
 712  *      Infrastructure
 713  * ===========================================================================
 714  */
 715
 716 /*
 717  * Table of methods.
 718  *
 719  * The DEX optimizer uses the class/method/signature string fields to decide
 720  * which calls it can trample.  The interpreter just uses the function
 721  * pointer field.
 722  *
 723  * IMPORTANT: you must update DALVIK_VM_BUILD in DalvikVersion.h if you make
 724  * changes to this table.
 725  *
 726  * NOTE: If present, the JIT will also need to know about changes
 727  * to this table.  Update the NativeInlineOps enum in InlineNative.h and
 728  * the dispatch code in compiler/codegen/<target>/Codegen.c.
 729  */
 730 const InlineOperation gDvmInlineOpsTable[] = {
 731     { org_apache_harmony_dalvik_NativeTestTarget_emptyInlineMethod,
 732         "Lorg/apache/harmony/dalvik/NativeTestTarget;",
 733         "emptyInlineMethod", "()V" },
 734
 735     { javaLangString_charAt, "Ljava/lang/String;", "charAt", "(I)C" },
 736     { javaLangString_compareTo, "Ljava/lang/String;", "compareTo", "(Ljava/lang/String;)I" },
 737     { javaLangString_equals, "Ljava/lang/String;", "equals", "(Ljava/lang/Object;)Z" },
 738     { javaLangString_fastIndexOf_II, "Ljava/lang/String;", "fastIndexOf", "(II)I" },
 739     { javaLangString_isEmpty, "Ljava/lang/String;", "isEmpty", "()Z" },
 740     { javaLangString_length, "Ljava/lang/String;", "length", "()I" },
 741
 742     { javaLangMath_abs_int, "Ljava/lang/Math;", "abs", "(I)I" },
 743     { javaLangMath_abs_long, "Ljava/lang/Math;", "abs", "(J)J" },
 744     { javaLangMath_abs_float, "Ljava/lang/Math;", "abs", "(F)F" },
 745     { javaLangMath_abs_double, "Ljava/lang/Math;", "abs", "(D)D" },
 746     { javaLangMath_min_int, "Ljava/lang/Math;", "min", "(II)I" },
 747     { javaLangMath_max_int, "Ljava/lang/Math;", "max", "(II)I" },
 748     { javaLangMath_sqrt, "Ljava/lang/Math;", "sqrt", "(D)D" },
 749     { javaLangMath_cos, "Ljava/lang/Math;", "cos", "(D)D" },
 750     { javaLangMath_sin, "Ljava/lang/Math;", "sin", "(D)D" },
 751
 752     { javaLangFloat_floatToIntBits, "Ljava/lang/Float;", "floatToIntBits", "(F)I" },
 753     { javaLangFloat_floatToRawIntBits, "Ljava/lang/Float;", "floatToRawIntBits", "(F)I" },
 754     { javaLangFloat_intBitsToFloat, "Ljava/lang/Float;", "intBitsToFloat", "(I)F" },
 755
 756     { javaLangDouble_doubleToLongBits, "Ljava/lang/Double;", "doubleToLongBits", "(D)J" },
 757     { javaLangDouble_doubleToRawLongBits, "Ljava/lang/Double;", "doubleToRawLongBits", "(D)J" },
 758     { javaLangDouble_longBitsToDouble, "Ljava/lang/Double;", "longBitsToDouble", "(J)D" },
 759
 760     // These are implemented exactly the same in Math and StrictMath,
 761     // so we can make the StrictMath calls fast too. Note that this
 762     // isn't true in general!
 763     { javaLangMath_abs_int, "Ljava/lang/StrictMath;", "abs", "(I)I" },
 764     { javaLangMath_abs_long, "Ljava/lang/StrictMath;", "abs", "(J)J" },
 765     { javaLangMath_abs_float, "Ljava/lang/StrictMath;", "abs", "(F)F" },
 766     { javaLangMath_abs_double, "Ljava/lang/StrictMath;", "abs", "(D)D" },
 767     { javaLangMath_min_int, "Ljava/lang/StrictMath;", "min", "(II)I" },
 768     { javaLangMath_max_int, "Ljava/lang/StrictMath;", "max", "(II)I" },
 769     { javaLangMath_sqrt, "Ljava/lang/StrictMath;", "sqrt", "(D)D" },
 770 };
 771
 772 /*
 773  * Allocate some tables.
 774  */
 775 bool dvmInlineNativeStartup()
 776 {
 777     gDvm.inlinedMethods =
 778         (Method**) calloc(NELEM(gDvmInlineOpsTable), sizeof(Method*));
 779     if (gDvm.inlinedMethods == NULL)
 780         return false;
 781
 782     return true;
 783 }
 784
 785 /*
 786  * Free generated tables.
 787  */
 788 void dvmInlineNativeShutdown()
 789 {
 790     free(gDvm.inlinedMethods);
 791 }
 792
 793
 794 /*
 795  * Get a pointer to the inlineops table.
 796  */
 797 const InlineOperation* dvmGetInlineOpsTable()
 798 {
 799     return gDvmInlineOpsTable;
 800 }
 801
 802 /*
 803  * Get the number of entries in the inlineops table.
 804  */
 805 int dvmGetInlineOpsTableLength()
 806 {
 807     return NELEM(gDvmInlineOpsTable);
 808 }
 809
 810 Method* dvmFindInlinableMethod(const char* classDescriptor,
 811     const char* methodName, const char* methodSignature)
 812 {
 813     /*
 814      * Find the class.
 815      */
 816     ClassObject* clazz = dvmFindClassNoInit(classDescriptor, NULL);
 817     if (clazz == NULL) {
 818         ALOGE("dvmFindInlinableMethod: can't find class '%s'",
 819             classDescriptor);
 820         dvmClearException(dvmThreadSelf());
 821         return NULL;
 822     }
 823
 824     /*
 825      * Method could be virtual or direct.  Try both.  Don't use
 826      * the "hier" versions.
 827      */
 828     Method* method = dvmFindDirectMethodByDescriptor(clazz, methodName,
 829         methodSignature);
 830     if (method == NULL) {
 831         method = dvmFindVirtualMethodByDescriptor(clazz, methodName,
 832             methodSignature);
 833     }
 834     if (method == NULL) {
 835         ALOGE("dvmFindInlinableMethod: can't find method %s.%s %s",
 836             clazz->descriptor, methodName, methodSignature);
 837         return NULL;
 838     }
 839
 840     /*
 841      * Check that the method is appropriate for inlining.
 842      */
 843     if (!dvmIsFinalClass(clazz) && !dvmIsFinalMethod(method)) {
 844         ALOGE("dvmFindInlinableMethod: can't inline non-final method %s.%s",
 845             clazz->descriptor, method->name);
 846         return NULL;
 847     }
 848     if (dvmIsSynchronizedMethod(method) ||
 849             dvmIsDeclaredSynchronizedMethod(method)) {
 850         ALOGE("dvmFindInlinableMethod: can't inline synchronized method %s.%s",
 851             clazz->descriptor, method->name);
 852         return NULL;
 853     }
 854
 855     return method;
 856 }
 857
 858 /*
 859  * Populate the methods table on first use.  It's possible the class
 860  * hasn't been resolved yet, so we need to do the full "calling the
 861  * method for the first time" routine.  (It's probably okay to skip
 862  * the access checks.)
 863  *
 864  * Currently assuming that we're only inlining stuff loaded by the
 865  * bootstrap class loader.  This is a safe assumption for many reasons.
 866  */
 867 Method* dvmResolveInlineNative(int opIndex)
 868 {
 869     assert(opIndex >= 0 && opIndex < NELEM(gDvmInlineOpsTable));
 870     Method* method = gDvm.inlinedMethods[opIndex];
 871     if (method != NULL) {
 872         return method;
 873     }
 874
 875     method = dvmFindInlinableMethod(
 876         gDvmInlineOpsTable[opIndex].classDescriptor,
 877         gDvmInlineOpsTable[opIndex].methodName,
 878         gDvmInlineOpsTable[opIndex].methodSignature);
 879
 880     if (method == NULL) {
 881         /* We already reported the error. */
 882         return NULL;
 883     }
 884
 885     gDvm.inlinedMethods[opIndex] = method;
 886     IF_ALOGV() {
 887         char* desc = dexProtoCopyMethodDescriptor(&method->prototype);
 888         ALOGV("Registered for profile: %s.%s %s",
 889             method->clazz->descriptor, method->name, desc);
 890         free(desc);
 891     }
 892
 893     return method;
 894 }
 895
 896 /*
 897  * Make an inline call for the "debug" interpreter, used when the debugger
 898  * or profiler is active.
 899  */
 900 bool dvmPerformInlineOp4Dbg(u4 arg0, u4 arg1, u4 arg2, u4 arg3,
 901     JValue* pResult, int opIndex)
 902 {
 903     Method* method = dvmResolveInlineNative(opIndex);
 904     if (method == NULL) {
 905         return (*gDvmInlineOpsTable[opIndex].func)(arg0, arg1, arg2, arg3,
 906             pResult);
 907     }
 908
 909     Thread* self = dvmThreadSelf();
 910     TRACE_METHOD_ENTER(self, method);
 911     bool result = (*gDvmInlineOpsTable[opIndex].func)(arg0, arg1, arg2, arg3,
 912         pResult);
 913     TRACE_METHOD_EXIT(self, method);
 914     return result;
 915 }