Home | History | Annotate | Download | only in oo 
      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  * Helper functions to access data fields in Objects.
     19  */
     20 #ifndef DALVIK_OO_OBJECTINLINES_H_
     21 #define DALVIK_OO_OBJECTINLINES_H_
     22 
     23 /*
     24  * Store a single value in the array, and if the value isn't null,
     25  * note in the write barrier.
     26  */
     27 INLINE void dvmSetObjectArrayElement(const ArrayObject* obj, int index,
     28                                      Object* val) {
     29     ((Object **)(void *)(obj)->contents)[index] = val;
     30     if (val != NULL) {
     31         dvmWriteBarrierArray(obj, index, index + 1);
     32     }
     33 }
     34 
     35 
     36 /*
     37  * Field access functions.  Pass in the word offset from Field->byteOffset.
     38  *
     39  * We guarantee that long/double field data is 64-bit aligned, so it's safe
     40  * to access them with ldrd/strd on ARM.
     41  *
     42  * The VM treats all fields as 32 or 64 bits, so the field set functions
     43  * write 32 bits even if the underlying type is smaller.
     44  *
     45  * Setting Object types to non-null values includes a call to the
     46  * write barrier.
     47  */
     48 #define BYTE_OFFSET(_ptr, _offset)  ((void*) (((u1*)(_ptr)) + (_offset)))
     49 
     50 INLINE JValue* dvmFieldPtr(const Object* obj, int offset) {
     51     return ((JValue*)BYTE_OFFSET(obj, offset));
     52 }
     53 
     54 INLINE bool dvmGetFieldBoolean(const Object* obj, int offset) {
     55     return ((JValue*)BYTE_OFFSET(obj, offset))->z;
     56 }
     57 INLINE s1 dvmGetFieldByte(const Object* obj, int offset) {
     58     return ((JValue*)BYTE_OFFSET(obj, offset))->b;
     59 }
     60 INLINE s2 dvmGetFieldShort(const Object* obj, int offset) {
     61     return ((JValue*)BYTE_OFFSET(obj, offset))->s;
     62 }
     63 INLINE u2 dvmGetFieldChar(const Object* obj, int offset) {
     64     return ((JValue*)BYTE_OFFSET(obj, offset))->c;
     65 }
     66 INLINE s4 dvmGetFieldInt(const Object* obj, int offset) {
     67     return ((JValue*)BYTE_OFFSET(obj, offset))->i;
     68 }
     69 INLINE s8 dvmGetFieldLong(const Object* obj, int offset) {
     70     return ((JValue*)BYTE_OFFSET(obj, offset))->j;
     71 }
     72 INLINE float dvmGetFieldFloat(const Object* obj, int offset) {
     73     return ((JValue*)BYTE_OFFSET(obj, offset))->f;
     74 }
     75 INLINE double dvmGetFieldDouble(const Object* obj, int offset) {
     76     return ((JValue*)BYTE_OFFSET(obj, offset))->d;
     77 }
     78 INLINE Object* dvmGetFieldObject(const Object* obj, int offset) {
     79     return ((JValue*)BYTE_OFFSET(obj, offset))->l;
     80 }
     81 INLINE bool dvmGetFieldBooleanVolatile(const Object* obj, int offset) {
     82     s4* ptr = &((JValue*)BYTE_OFFSET(obj, offset))->i;
     83     return (bool)android_atomic_acquire_load(ptr);
     84 }
     85 INLINE s1 dvmGetFieldByteVolatile(const Object* obj, int offset) {
     86     s4* ptr = &((JValue*)BYTE_OFFSET(obj, offset))->i;
     87     return (s1)android_atomic_acquire_load(ptr);
     88 }
     89 INLINE s2 dvmGetFieldShortVolatile(const Object* obj, int offset) {
     90     s4* ptr = &((JValue*)BYTE_OFFSET(obj, offset))->i;
     91     return (s2)android_atomic_acquire_load(ptr);
     92 }
     93 INLINE u2 dvmGetFieldCharVolatile(const Object* obj, int offset) {
     94     s4* ptr = &((JValue*)BYTE_OFFSET(obj, offset))->i;
     95     return (u2)android_atomic_acquire_load(ptr);
     96 }
     97 INLINE s4 dvmGetFieldIntVolatile(const Object* obj, int offset) {
     98     s4* ptr = &((JValue*)BYTE_OFFSET(obj, offset))->i;
     99     return android_atomic_acquire_load(ptr);
    100 }
    101 INLINE float dvmGetFieldFloatVolatile(const Object* obj, int offset) {
    102     union { s4 ival; float fval; } alias;
    103     s4* ptr = &((JValue*)BYTE_OFFSET(obj, offset))->i;
    104     alias.ival = android_atomic_acquire_load(ptr);
    105     return alias.fval;
    106 }
    107 INLINE s8 dvmGetFieldLongVolatile(const Object* obj, int offset) {
    108     const s8* addr = (const s8*)BYTE_OFFSET(obj, offset);
    109     s8 val = dvmQuasiAtomicRead64(addr);
    110     ANDROID_MEMBAR_FULL();
    111     return val;
    112 }
    113 INLINE double dvmGetFieldDoubleVolatile(const Object* obj, int offset) {
    114     union { s8 lval; double dval; } alias;
    115     const s8* addr = (const s8*)BYTE_OFFSET(obj, offset);
    116     alias.lval = dvmQuasiAtomicRead64(addr);
    117     ANDROID_MEMBAR_FULL();
    118     return alias.dval;
    119 }
    120 INLINE Object* dvmGetFieldObjectVolatile(const Object* obj, int offset) {
    121     Object** ptr = &((JValue*)BYTE_OFFSET(obj, offset))->l;
    122     return (Object*)android_atomic_acquire_load((int32_t*)ptr);
    123 }
    124 
    125 INLINE void dvmSetFieldBoolean(Object* obj, int offset, bool val) {
    126     ((JValue*)BYTE_OFFSET(obj, offset))->i = val;
    127 }
    128 INLINE void dvmSetFieldByte(Object* obj, int offset, s1 val) {
    129     ((JValue*)BYTE_OFFSET(obj, offset))->i = val;
    130 }
    131 INLINE void dvmSetFieldShort(Object* obj, int offset, s2 val) {
    132     ((JValue*)BYTE_OFFSET(obj, offset))->i = val;
    133 }
    134 INLINE void dvmSetFieldChar(Object* obj, int offset, u2 val) {
    135     ((JValue*)BYTE_OFFSET(obj, offset))->i = val;
    136 }
    137 INLINE void dvmSetFieldInt(Object* obj, int offset, s4 val) {
    138     ((JValue*)BYTE_OFFSET(obj, offset))->i = val;
    139 }
    140 INLINE void dvmSetFieldFloat(Object* obj, int offset, float val) {
    141     ((JValue*)BYTE_OFFSET(obj, offset))->f = val;
    142 }
    143 INLINE void dvmSetFieldLong(Object* obj, int offset, s8 val) {
    144     ((JValue*)BYTE_OFFSET(obj, offset))->j = val;
    145 }
    146 INLINE void dvmSetFieldDouble(Object* obj, int offset, double val) {
    147     ((JValue*)BYTE_OFFSET(obj, offset))->d = val;
    148 }
    149 INLINE void dvmSetFieldObject(Object* obj, int offset, Object* val) {
    150     JValue* lhs = (JValue*)BYTE_OFFSET(obj, offset);
    151     lhs->l = val;
    152     if (val != NULL) {
    153         dvmWriteBarrierField(obj, &lhs->l);
    154     }
    155 }
    156 INLINE void dvmSetFieldIntVolatile(Object* obj, int offset, s4 val) {
    157     s4* ptr = &((JValue*)BYTE_OFFSET(obj, offset))->i;
    158     /*
    159      * TODO: add an android_atomic_synchronization_store() function and
    160      * use it in the 32-bit volatile set handlers.  On some platforms we
    161      * can use a fast atomic instruction and avoid the barriers.
    162      */
    163     ANDROID_MEMBAR_STORE();
    164     *ptr = val;
    165     ANDROID_MEMBAR_FULL();
    166 }
    167 INLINE void dvmSetFieldBooleanVolatile(Object* obj, int offset, bool val) {
    168     dvmSetFieldIntVolatile(obj, offset, val);
    169 }
    170 INLINE void dvmSetFieldByteVolatile(Object* obj, int offset, s1 val) {
    171     dvmSetFieldIntVolatile(obj, offset, val);
    172 }
    173 INLINE void dvmSetFieldShortVolatile(Object* obj, int offset, s2 val) {
    174     dvmSetFieldIntVolatile(obj, offset, val);
    175 }
    176 INLINE void dvmSetFieldCharVolatile(Object* obj, int offset, u2 val) {
    177     dvmSetFieldIntVolatile(obj, offset, val);
    178 }
    179 INLINE void dvmSetFieldFloatVolatile(Object* obj, int offset, float val) {
    180     union { s4 ival; float fval; } alias;
    181     alias.fval = val;
    182     dvmSetFieldIntVolatile(obj, offset, alias.ival);
    183 }
    184 INLINE void dvmSetFieldLongVolatile(Object* obj, int offset, s8 val) {
    185     s8* addr = (s8*)BYTE_OFFSET(obj, offset);
    186     dvmQuasiAtomicSwap64Sync(val, addr);
    187 }
    188 INLINE void dvmSetFieldDoubleVolatile(Object* obj, int offset, double val) {
    189     union { s8 lval; double dval; } alias;
    190     alias.dval = val;
    191     dvmSetFieldLongVolatile(obj, offset, alias.lval);
    192 }
    193 INLINE void dvmSetFieldObjectVolatile(Object* obj, int offset, Object* val) {
    194     Object** ptr = &((JValue*)BYTE_OFFSET(obj, offset))->l;
    195     ANDROID_MEMBAR_STORE();
    196     *ptr = val;
    197     ANDROID_MEMBAR_FULL();
    198     if (val != NULL) {
    199         dvmWriteBarrierField(obj, ptr);
    200     }
    201 }
    202 
    203 /*
    204  * Static field access functions.
    205  */
    206 INLINE JValue* dvmStaticFieldPtr(const StaticField* sfield) {
    207     return (JValue*)&sfield->value;
    208 }
    209 
    210 INLINE bool dvmGetStaticFieldBoolean(const StaticField* sfield) {
    211     return sfield->value.z;
    212 }
    213 INLINE s1 dvmGetStaticFieldByte(const StaticField* sfield) {
    214     return sfield->value.b;
    215 }
    216 INLINE s2 dvmGetStaticFieldShort(const StaticField* sfield) {
    217     return sfield->value.s;
    218 }
    219 INLINE u2 dvmGetStaticFieldChar(const StaticField* sfield) {
    220     return sfield->value.c;
    221 }
    222 INLINE s4 dvmGetStaticFieldInt(const StaticField* sfield) {
    223     return sfield->value.i;
    224 }
    225 INLINE float dvmGetStaticFieldFloat(const StaticField* sfield) {
    226     return sfield->value.f;
    227 }
    228 INLINE s8 dvmGetStaticFieldLong(const StaticField* sfield) {
    229     return sfield->value.j;
    230 }
    231 INLINE double dvmGetStaticFieldDouble(const StaticField* sfield) {
    232     return sfield->value.d;
    233 }
    234 INLINE Object* dvmGetStaticFieldObject(const StaticField* sfield) {
    235     return sfield->value.l;
    236 }
    237 INLINE bool dvmGetStaticFieldBooleanVolatile(const StaticField* sfield) {
    238     const s4* ptr = &(sfield->value.i);
    239     return (bool)android_atomic_acquire_load((s4*)ptr);
    240 }
    241 INLINE s1 dvmGetStaticFieldByteVolatile(const StaticField* sfield) {
    242     const s4* ptr = &(sfield->value.i);
    243     return (s1)android_atomic_acquire_load((s4*)ptr);
    244 }
    245 INLINE s2 dvmGetStaticFieldShortVolatile(const StaticField* sfield) {
    246     const s4* ptr = &(sfield->value.i);
    247     return (s2)android_atomic_acquire_load((s4*)ptr);
    248 }
    249 INLINE u2 dvmGetStaticFieldCharVolatile(const StaticField* sfield) {
    250     const s4* ptr = &(sfield->value.i);
    251     return (u2)android_atomic_acquire_load((s4*)ptr);
    252 }
    253 INLINE s4 dvmGetStaticFieldIntVolatile(const StaticField* sfield) {
    254     const s4* ptr = &(sfield->value.i);
    255     return android_atomic_acquire_load((s4*)ptr);
    256 }
    257 INLINE float dvmGetStaticFieldFloatVolatile(const StaticField* sfield) {
    258     union { s4 ival; float fval; } alias;
    259     const s4* ptr = &(sfield->value.i);
    260     alias.ival = android_atomic_acquire_load((s4*)ptr);
    261     return alias.fval;
    262 }
    263 INLINE s8 dvmGetStaticFieldLongVolatile(const StaticField* sfield) {
    264     const s8* addr = &sfield->value.j;
    265     s8 val = dvmQuasiAtomicRead64(addr);
    266     ANDROID_MEMBAR_FULL();
    267     return val;
    268 }
    269 INLINE double dvmGetStaticFieldDoubleVolatile(const StaticField* sfield) {
    270     union { s8 lval; double dval; } alias;
    271     const s8* addr = &sfield->value.j;
    272     alias.lval = dvmQuasiAtomicRead64(addr);
    273     ANDROID_MEMBAR_FULL();
    274     return alias.dval;
    275 }
    276 INLINE Object* dvmGetStaticFieldObjectVolatile(const StaticField* sfield) {
    277     Object* const* ptr = &(sfield->value.l);
    278     return (Object*)android_atomic_acquire_load((int32_t*)ptr);
    279 }
    280 
    281 INLINE void dvmSetStaticFieldBoolean(StaticField* sfield, bool val) {
    282     sfield->value.i = val;
    283 }
    284 INLINE void dvmSetStaticFieldByte(StaticField* sfield, s1 val) {
    285     sfield->value.i = val;
    286 }
    287 INLINE void dvmSetStaticFieldShort(StaticField* sfield, s2 val) {
    288     sfield->value.i = val;
    289 }
    290 INLINE void dvmSetStaticFieldChar(StaticField* sfield, u2 val) {
    291     sfield->value.i = val;
    292 }
    293 INLINE void dvmSetStaticFieldInt(StaticField* sfield, s4 val) {
    294     sfield->value.i = val;
    295 }
    296 INLINE void dvmSetStaticFieldFloat(StaticField* sfield, float val) {
    297     sfield->value.f = val;
    298 }
    299 INLINE void dvmSetStaticFieldLong(StaticField* sfield, s8 val) {
    300     sfield->value.j = val;
    301 }
    302 INLINE void dvmSetStaticFieldDouble(StaticField* sfield, double val) {
    303     sfield->value.d = val;
    304 }
    305 INLINE void dvmSetStaticFieldObject(StaticField* sfield, Object* val) {
    306     sfield->value.l = val;
    307     if (val != NULL) {
    308         dvmWriteBarrierField(sfield->clazz, &sfield->value.l);
    309     }
    310 }
    311 INLINE void dvmSetStaticFieldIntVolatile(StaticField* sfield, s4 val) {
    312     s4* ptr = &sfield->value.i;
    313     ANDROID_MEMBAR_STORE();
    314     *ptr = val;
    315     ANDROID_MEMBAR_FULL();
    316 }
    317 INLINE void dvmSetStaticFieldBooleanVolatile(StaticField* sfield, bool val) {
    318     dvmSetStaticFieldIntVolatile(sfield, val);
    319 }
    320 INLINE void dvmSetStaticFieldByteVolatile(StaticField* sfield, s1 val) {
    321     dvmSetStaticFieldIntVolatile(sfield, val);
    322 }
    323 INLINE void dvmSetStaticFieldShortVolatile(StaticField* sfield, s2 val) {
    324     dvmSetStaticFieldIntVolatile(sfield, val);
    325 }
    326 INLINE void dvmSetStaticFieldCharVolatile(StaticField* sfield, u2 val) {
    327     dvmSetStaticFieldIntVolatile(sfield, val);
    328 }
    329 INLINE void dvmSetStaticFieldFloatVolatile(StaticField* sfield, float val) {
    330     union { s4 ival; float fval; } alias;
    331     alias.fval = val;
    332     dvmSetStaticFieldIntVolatile(sfield, alias.ival);
    333 }
    334 INLINE void dvmSetStaticFieldLongVolatile(StaticField* sfield, s8 val) {
    335     s8* addr = &sfield->value.j;
    336     dvmQuasiAtomicSwap64Sync(val, addr);
    337 }
    338 INLINE void dvmSetStaticFieldDoubleVolatile(StaticField* sfield, double val) {
    339     union { s8 lval; double dval; } alias;
    340     alias.dval = val;
    341     dvmSetStaticFieldLongVolatile(sfield, alias.lval);
    342 }
    343 INLINE void dvmSetStaticFieldObjectVolatile(StaticField* sfield, Object* val) {
    344     Object** ptr = &(sfield->value.l);
    345     ANDROID_MEMBAR_STORE();
    346     *ptr = val;
    347     ANDROID_MEMBAR_FULL();
    348     if (val != NULL) {
    349         dvmWriteBarrierField(sfield->clazz, &sfield->value.l);
    350     }
    351 }
    352 
    353 #endif  // DALVIK_OO_OBJECTINLINES_H_
    354