1 /* 2 * Copyright 2010, 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 #ifndef BCC_SCRIPTCACHED_H 18 #define BCC_SCRIPTCACHED_H 19 20 #include "Config.h" 21 22 #include <bcc/bcc.h> 23 #include <bcc/bcc_cache.h> 24 #include <bcc/bcc_mccache.h> 25 #include "bcc_internal.h" 26 27 #if USE_MCJIT 28 #include "librsloader.h" 29 #endif 30 31 #include <llvm/ADT/SmallVector.h> 32 33 #include <map> 34 #include <string> 35 #include <utility> 36 #include <vector> 37 38 #include <stddef.h> 39 40 namespace llvm { 41 class Module; 42 } 43 44 namespace bcc { 45 class Script; 46 47 class ScriptCached { 48 friend class CacheReader; 49 friend class MCCacheReader; 50 51 private: 52 enum { SMALL_VECTOR_QUICKN = 16 }; 53 54 typedef llvm::SmallVector<std::pair<char const *, char const *>, 55 SMALL_VECTOR_QUICKN> PragmaList; 56 57 typedef std::map<std::string, std::pair<void *, size_t> > FuncTable; 58 59 private: 60 Script *mpOwner; 61 62 OBCC_ExportVarList *mpExportVars; 63 OBCC_ExportFuncList *mpExportFuncs; 64 PragmaList mPragmas; 65 OBCC_ObjectSlotList *mpObjectSlotList; 66 67 FuncTable mFunctions; 68 69 #if USE_OLD_JIT 70 char *mContext; 71 #endif 72 73 #if USE_MCJIT 74 RSExecRef mRSExecutable; 75 #endif 76 77 OBCC_StringPool *mpStringPoolRaw; 78 std::vector<char const *> mStringPool; 79 80 bool mLibRSThreadable; 81 82 public: ScriptCached(Script * owner)83 ScriptCached(Script *owner) 84 : mpOwner(owner), 85 mpExportVars(NULL), 86 mpExportFuncs(NULL), 87 mpObjectSlotList(NULL), 88 #if USE_OLD_JIT 89 mContext(NULL), 90 #endif 91 mpStringPoolRaw(NULL), 92 mLibRSThreadable(false) { 93 } 94 95 ~ScriptCached(); 96 97 void *lookup(const char *name); 98 99 getExportVarCount()100 size_t getExportVarCount() const { 101 return mpExportVars->count; 102 } 103 getExportFuncCount()104 size_t getExportFuncCount() const { 105 return mpExportFuncs->count; 106 } 107 getPragmaCount()108 size_t getPragmaCount() const { 109 return mPragmas.size(); 110 } 111 getFuncCount()112 size_t getFuncCount() const { 113 return mFunctions.size(); 114 } 115 getObjectSlotCount()116 size_t getObjectSlotCount() const { 117 return mpObjectSlotList->count; 118 } 119 120 void getExportVarList(size_t varListSize, void **varList); 121 122 void getExportFuncList(size_t funcListSize, void **funcList); 123 124 void getPragmaList(size_t pragmaListSize, 125 char const **keyList, 126 char const **valueList); 127 128 void getFuncInfoList(size_t funcInfoListSize, FuncInfo *funcNameList); 129 130 void getObjectSlotList(size_t objectSlotListSize, 131 uint32_t *objectSlotList); 132 133 #if USE_OLD_JIT getContext()134 char *getContext() { 135 return mContext; 136 } 137 #endif 138 139 // Dirty hack for libRS. 140 // TODO(all): This should be removed in the future. isLibRSThreadable()141 bool isLibRSThreadable() const { 142 return mLibRSThreadable; 143 } 144 145 #if 0 146 void registerSymbolCallback(BCCSymbolLookupFn pFn, BCCvoid *pContext) { 147 mCompiler.registerSymbolCallback(pFn, pContext); 148 } 149 #endif 150 }; 151 152 } // namespace bcc 153 154 #endif // BCC_SCRIPTCACHED_H 155