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  * The VM wraps some additional data structures around the DexFile.  These
     19  * are defined here.
     20  */
     21 #ifndef DALVIK_DVMDEX_H_
     22 #define DALVIK_DVMDEX_H_
     23 
     24 #include "libdex/DexFile.h"
     25 
     26 /* extern */
     27 struct ClassObject;
     28 struct HashTable;
     29 struct InstField;
     30 struct Method;
     31 struct StringObject;
     32 
     33 
     34 /*
     35  * Some additional VM data structures that are associated with the DEX file.
     36  */
     37 struct DvmDex {
     38     /* pointer to the DexFile we're associated with */
     39     DexFile*            pDexFile;
     40 
     41     /* clone of pDexFile->pHeader (it's used frequently enough) */
     42     const DexHeader*    pHeader;
     43 
     44     /* interned strings; parallel to "stringIds" */
     45     struct StringObject** pResStrings;
     46 
     47     /* resolved classes; parallel to "typeIds" */
     48     struct ClassObject** pResClasses;
     49 
     50     /* resolved methods; parallel to "methodIds" */
     51     struct Method**     pResMethods;
     52 
     53     /* resolved instance fields; parallel to "fieldIds" */
     54     /* (this holds both InstField and StaticField) */
     55     struct Field**      pResFields;
     56 
     57     /* interface method lookup cache */
     58     struct AtomicCache* pInterfaceCache;
     59 
     60     /* shared memory region with file contents */
     61     bool                isMappedReadOnly;
     62     MemMapping          memMap;
     63 
     64     /* lock ensuring mutual exclusion during updates */
     65     pthread_mutex_t     modLock;
     66 };
     67 
     68 
     69 /*
     70  * Given a file descriptor for an open "optimized" DEX file, map it into
     71  * memory and parse the contents.
     72  *
     73  * On success, returns 0 and sets "*ppDvmDex" to a newly-allocated DvmDex.
     74  * On failure, returns a meaningful error code [currently just -1].
     75  */
     76 int dvmDexFileOpenFromFd(int fd, DvmDex** ppDvmDex);
     77 
     78 /*
     79  * Open a partial DEX file.  Only useful as part of the optimization process.
     80  */
     81 int dvmDexFileOpenPartial(const void* addr, int len, DvmDex** ppDvmDex);
     82 
     83 /*
     84  * Free a DvmDex structure, along with any associated structures.
     85  */
     86 void dvmDexFileFree(DvmDex* pDvmDex);
     87 
     88 
     89 /*
     90  * Change the 1- or 2-byte value at the specified address to a new value.  If
     91  * the location already has the new value, do nothing.
     92  *
     93  * This does not make any synchronization guarantees.  The caller must
     94  * ensure exclusivity vs. other callers.
     95  *
     96  * For the 2-byte call, the pointer should have 16-bit alignment.
     97  *
     98  * Returns "true" on success.
     99  */
    100 bool dvmDexChangeDex1(DvmDex* pDvmDex, u1* addr, u1 newVal);
    101 bool dvmDexChangeDex2(DvmDex* pDvmDex, u2* addr, u2 newVal);
    102 
    103 
    104 /*
    105  * Return the requested item if it has been resolved, or NULL if it hasn't.
    106  */
    107 INLINE struct StringObject* dvmDexGetResolvedString(const DvmDex* pDvmDex,
    108     u4 stringIdx)
    109 {
    110     assert(stringIdx < pDvmDex->pHeader->stringIdsSize);
    111     return pDvmDex->pResStrings[stringIdx];
    112 }
    113 INLINE struct ClassObject* dvmDexGetResolvedClass(const DvmDex* pDvmDex,
    114     u4 classIdx)
    115 {
    116     assert(classIdx < pDvmDex->pHeader->typeIdsSize);
    117     return pDvmDex->pResClasses[classIdx];
    118 }
    119 INLINE struct Method* dvmDexGetResolvedMethod(const DvmDex* pDvmDex,
    120     u4 methodIdx)
    121 {
    122     assert(methodIdx < pDvmDex->pHeader->methodIdsSize);
    123     return pDvmDex->pResMethods[methodIdx];
    124 }
    125 INLINE struct Field* dvmDexGetResolvedField(const DvmDex* pDvmDex,
    126     u4 fieldIdx)
    127 {
    128     assert(fieldIdx < pDvmDex->pHeader->fieldIdsSize);
    129     return pDvmDex->pResFields[fieldIdx];
    130 }
    131 
    132 /*
    133  * Update the resolved item table.  Resolution always produces the same
    134  * result, so we're not worried about atomicity here.
    135  */
    136 INLINE void dvmDexSetResolvedString(DvmDex* pDvmDex, u4 stringIdx,
    137     struct StringObject* str)
    138 {
    139     assert(stringIdx < pDvmDex->pHeader->stringIdsSize);
    140     pDvmDex->pResStrings[stringIdx] = str;
    141 }
    142 INLINE void dvmDexSetResolvedClass(DvmDex* pDvmDex, u4 classIdx,
    143     struct ClassObject* clazz)
    144 {
    145     assert(classIdx < pDvmDex->pHeader->typeIdsSize);
    146     pDvmDex->pResClasses[classIdx] = clazz;
    147 }
    148 INLINE void dvmDexSetResolvedMethod(DvmDex* pDvmDex, u4 methodIdx,
    149     struct Method* method)
    150 {
    151     assert(methodIdx < pDvmDex->pHeader->methodIdsSize);
    152     pDvmDex->pResMethods[methodIdx] = method;
    153 }
    154 INLINE void dvmDexSetResolvedField(DvmDex* pDvmDex, u4 fieldIdx,
    155     struct Field* field)
    156 {
    157     assert(fieldIdx < pDvmDex->pHeader->fieldIdsSize);
    158     pDvmDex->pResFields[fieldIdx] = field;
    159 }
    160 
    161 #endif  // DALVIK_DVMDEX_H_
    162