Home | History | Annotate | Download | only in vm
      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  * Common defines for all Dalvik code.
     19  */
     20 #ifndef DALVIK_COMMON_H_
     21 #define DALVIK_COMMON_H_
     22 
     23 #ifndef LOG_TAG
     24 # define LOG_TAG "dalvikvm"
     25 #endif
     26 
     27 #include <stdbool.h>
     28 #include <stdint.h>
     29 #include <stdio.h>
     30 #include <assert.h>
     31 #include "cutils/log.h"
     32 
     33 #if defined(HAVE_ENDIAN_H)
     34 # include <endian.h>
     35 #else /*not HAVE_ENDIAN_H*/
     36 # define __BIG_ENDIAN 4321
     37 # define __LITTLE_ENDIAN 1234
     38 # if defined(HAVE_LITTLE_ENDIAN)
     39 #  define __BYTE_ORDER __LITTLE_ENDIAN
     40 # else
     41 #  define __BYTE_ORDER __BIG_ENDIAN
     42 # endif
     43 #endif /*not HAVE_ENDIAN_H*/
     44 
     45 #if !defined(NDEBUG) && defined(WITH_DALVIK_ASSERT)
     46 # undef assert
     47 # define assert(x) \
     48     ((x) ? ((void)0) : (ALOGE("ASSERT FAILED (%s:%d): %s", \
     49         __FILE__, __LINE__, #x), *(int*)39=39, (void)0) )
     50 #endif
     51 
     52 #define MIN(x,y) (((x) < (y)) ? (x) : (y))
     53 #define MAX(x,y) (((x) > (y)) ? (x) : (y))
     54 
     55 #define LIKELY(exp) (__builtin_expect((exp) != 0, true))
     56 #define UNLIKELY(exp) (__builtin_expect((exp) != 0, false))
     57 
     58 #define ALIGN_UP(x, n) (((size_t)(x) + (n) - 1) & ~((n) - 1))
     59 #define ALIGN_DOWN(x, n) ((size_t)(x) & -(n))
     60 #define ALIGN_UP_TO_PAGE_SIZE(p) ALIGN_UP(p, SYSTEM_PAGE_SIZE)
     61 #define ALIGN_DOWN_TO_PAGE_SIZE(p) ALIGN_DOWN(p, SYSTEM_PAGE_SIZE)
     62 
     63 #define CLZ(x) __builtin_clz(x)
     64 
     65 /*
     66  * If "very verbose" logging is enabled, make it equivalent to ALOGV.
     67  * Otherwise, make it disappear.
     68  *
     69  * Define this above the #include "Dalvik.h" to enable for only a
     70  * single file.
     71  */
     72 /* #define VERY_VERBOSE_LOG */
     73 #if defined(VERY_VERBOSE_LOG)
     74 # define LOGVV      ALOGV
     75 # define IF_LOGVV() IF_ALOGV()
     76 #else
     77 # define LOGVV(...) ((void)0)
     78 # define IF_LOGVV() if (false)
     79 #endif
     80 
     81 
     82 /*
     83  * These match the definitions in the VM specification.
     84  */
     85 typedef uint8_t             u1;
     86 typedef uint16_t            u2;
     87 typedef uint32_t            u4;
     88 typedef uint64_t            u8;
     89 typedef int8_t              s1;
     90 typedef int16_t             s2;
     91 typedef int32_t             s4;
     92 typedef int64_t             s8;
     93 
     94 /*
     95  * Storage for primitive types and object references.
     96  *
     97  * Some parts of the code (notably object field access) assume that values
     98  * are "left aligned", i.e. given "JValue jv", "jv.i" and "*((s4*)&jv)"
     99  * yield the same result.  This seems to be guaranteed by gcc on big- and
    100  * little-endian systems.
    101  */
    102 struct Object;
    103 
    104 union JValue {
    105 #if defined(HAVE_LITTLE_ENDIAN)
    106     u1      z;
    107     s1      b;
    108     u2      c;
    109     s2      s;
    110     s4      i;
    111     s8      j;
    112     float   f;
    113     double  d;
    114     Object* l;
    115 #endif
    116 #if defined(HAVE_BIG_ENDIAN)
    117     struct {
    118         u1    _z[3];
    119         u1    z;
    120     };
    121     struct {
    122         s1    _b[3];
    123         s1    b;
    124     };
    125     struct {
    126         u2    _c;
    127         u2    c;
    128     };
    129     struct {
    130         s2    _s;
    131         s2    s;
    132     };
    133     s4      i;
    134     s8      j;
    135     float   f;
    136     double  d;
    137     void*   l;
    138 #endif
    139 };
    140 
    141 #define OFFSETOF_MEMBER(t, f)         \
    142   (reinterpret_cast<char*>(           \
    143      &reinterpret_cast<t*>(16)->f) -  \
    144    reinterpret_cast<char*>(16))
    145 
    146 #define NELEM(x) ((int) (sizeof(x) / sizeof((x)[0])))
    147 
    148 #endif  // DALVIK_COMMON_H_
    149