1 /* 2 * Copyright 2012, 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_EXECUTION_ENGINE_SYMBOL_RESOLVERS_H 18 #define BCC_EXECUTION_ENGINE_SYMBOL_RESOLVERS_H 19 20 #include <cstdlib> 21 #include <cstring> 22 23 #include "SymbolResolverInterface.h" 24 25 namespace bcc { 26 27 /* 28 * Symbol lookup via dlopen()/dlsym(). 29 */ 30 class DyldSymbolResolver : public SymbolResolverInterface { 31 public: 32 typedef void *HandleTy; 33 34 private: 35 HandleTy mHandle; 36 char *mError; 37 38 public: 39 // If pFileName is NULL, it will search symbol in the current process image. 40 DyldSymbolResolver(const char *pFileName, bool pLazyBinding = true); 41 42 virtual void *getAddress(const char *pName); 43 hasError()44 inline bool hasError() const 45 { return (mError != NULL); } getError()46 inline const char *getError() const 47 { return mError; } 48 49 ~DyldSymbolResolver(); 50 }; 51 52 /* 53 * Symbol lookup by searching through an array of SymbolMap. 54 */ 55 template<typename Subclass> 56 class ArraySymbolResolver : public SymbolResolverInterface { 57 public: 58 typedef struct { 59 // Symbol name 60 const char *mName; 61 // Symbol address 62 void *mAddr; 63 } SymbolMap; 64 65 private: 66 // True if the symbol name is sorted in the array. 67 bool mSorted; 68 CompareSymbolName(const void * pA,const void * pB)69 static int CompareSymbolName(const void *pA, const void *pB) { 70 return ::strcmp(reinterpret_cast<const SymbolMap *>(pA)->mName, 71 reinterpret_cast<const SymbolMap *>(pB)->mName); 72 } 73 74 public: mSorted(pSorted)75 ArraySymbolResolver(bool pSorted = false) : mSorted(pSorted) { } 76 getAddress(const char * pName)77 virtual void *getAddress(const char *pName) { 78 const SymbolMap *result = NULL; 79 80 if (mSorted) { 81 // Use binary search. 82 const SymbolMap key = { pName, NULL }; 83 84 result = reinterpret_cast<SymbolMap *>( 85 ::bsearch(&key, Subclass::SymbolArray, 86 Subclass::NumSymbols, 87 sizeof(SymbolMap), 88 CompareSymbolName)); 89 } else { 90 // Use linear search. 91 for (size_t i = 0; i < Subclass::NumSymbols; i++) { 92 if (::strcmp(Subclass::SymbolArray[i].mName, pName) == 0) { 93 result = &Subclass::SymbolArray[i]; 94 break; 95 } 96 } 97 } 98 99 return ((result != NULL) ? result->mAddr : NULL); 100 } 101 }; 102 103 template<typename ContextTy = void *> 104 class LookupFunctionSymbolResolver : public SymbolResolverInterface { 105 public: 106 typedef void *(*LookupFunctionTy)(ContextTy pContext, const char *pName); 107 108 private: 109 LookupFunctionTy mLookupFunc; 110 ContextTy mContext; 111 112 public: 113 LookupFunctionSymbolResolver(LookupFunctionTy pLookupFunc = NULL, 114 ContextTy pContext = NULL) mLookupFunc(pLookupFunc)115 : mLookupFunc(pLookupFunc), mContext(pContext) { } 116 getAddress(const char * pName)117 virtual void *getAddress(const char *pName) { 118 return ((mLookupFunc != NULL) ? mLookupFunc(mContext, pName) : NULL); 119 } 120 getLookupFunction()121 inline LookupFunctionTy getLookupFunction() const 122 { return mLookupFunc; } getContext()123 inline ContextTy getContext() const 124 { return mContext; } 125 setLookupFunction(LookupFunctionTy pLookupFunc)126 inline void setLookupFunction(LookupFunctionTy pLookupFunc) 127 { mLookupFunc = pLookupFunc; } setContext(ContextTy pContext)128 inline void setContext(ContextTy pContext) 129 { mContext = pContext; } 130 }; 131 132 } // end namespace bcc 133 134 #endif // BCC_EXECUTION_ENGINE_SYMBOL_RESOLVERS_H 135