void* DynamicLibrary::SearchForAddressOfSymbol(const char *symbolName) { SmartScopedLock<true> Lock(*SymbolsMutex); // First check symbols added via AddSymbol(). if (ExplicitSymbols.isConstructed()) { StringMap<void *>::iterator i = ExplicitSymbols->find(symbolName); if (i != ExplicitSymbols->end()) return i->second; } #if HAVE_DLFCN_H // Now search the libraries. if (OpenedHandles) { for (DenseSet<void *>::iterator I = OpenedHandles->begin(), E = OpenedHandles->end(); I != E; ++I) { //lt_ptr ptr = lt_dlsym(*I, symbolName); void *ptr = dlsym(*I, symbolName); if (ptr) { return ptr; } } } #endif if (void *Result = llvm::SearchForAddressOfSpecialSymbol(symbolName)) return Result; // This macro returns the address of a well-known, explicit symbol #define EXPLICIT_SYMBOL(SYM) \ if (!strcmp(symbolName, #SYM)) return &SYM // On linux we have a weird situation. The stderr/out/in symbols are both // macros and global variables because of standards requirements. So, we // boldly use the EXPLICIT_SYMBOL macro without checking for a #define first. #if defined(__linux__) and !defined(__ANDROID__) and !defined(__ELLCC__) { EXPLICIT_SYMBOL(stderr); EXPLICIT_SYMBOL(stdout); EXPLICIT_SYMBOL(stdin); } #else // For everything else, we want to check to make sure the symbol isn't defined // as a macro before using EXPLICIT_SYMBOL. { #ifndef stdin EXPLICIT_SYMBOL(stdin); #endif #ifndef stdout EXPLICIT_SYMBOL(stdout); #endif #ifndef stderr EXPLICIT_SYMBOL(stderr); #endif } #endif #undef EXPLICIT_SYMBOL return nullptr; }
/// Return the type returned by DtoUnpaddedStruct called on a value of the /// specified type. /// Union types will get expanded into a struct, with a type for each member. LLType* DtoUnpaddedStructType(Type* dty) { assert(dty->ty == Tstruct); typedef llvm::DenseMap<Type*, llvm::StructType*> CacheT; static llvm::ManagedStatic<CacheT> cache; CacheT::iterator it = cache->find(dty); if (it != cache->end()) return it->second; TypeStruct* sty = static_cast<TypeStruct*>(dty); VarDeclarations& fields = sty->sym->fields; std::vector<LLType*> types; types.reserve(fields.dim); for (unsigned i = 0; i < fields.dim; i++) { LLType* fty; if (fields[i]->type->ty == Tstruct) { // Nested structs are the only members that can contain padding fty = DtoUnpaddedStructType(fields[i]->type); } else { fty = DtoType(fields[i]->type); } types.push_back(fty); } LLStructType* Ty = LLStructType::get(gIR->context(), types); cache->insert(std::make_pair(dty, Ty)); return Ty; }
LDSymbol* LDSymbol::Null() { // lazy initialization if (g_NullSymbol->resolveInfo() == NULL) { g_NullSymbol->setResolveInfo(*ResolveInfo::Null()); g_NullSymbol->setFragmentRef(FragmentRef::Create(*g_NullSymbolFragment, 0)); ResolveInfo::Null()->setSymPtr(&*g_NullSymbol); } return &*g_NullSymbol; }
/// Create - create a fragment reference for a given fragment. /// /// @param pFrag - the given fragment /// @param pOffset - the offset, can be larger than the fragment, but can not /// be larger than the section size. /// @return if the offset is legal, return the fragment reference. Otherwise, /// return NULL. FragmentRef* FragmentRef::Create(Fragment& pFrag, uint64_t pOffset) { int64_t offset = pOffset; Fragment* frag = &pFrag; while (frag != NULL) { offset -= frag->size(); if (offset <= 0) break; frag = frag->getNextNode(); } if ((frag != NULL) && (frag->size() != 0)) { if (offset == 0) frag = frag->getNextNode(); else offset += frag->size(); } if (frag == NULL) return Null(); FragmentRef* result = g_FragRefFactory->allocate(); new (result) FragmentRef(*frag, offset); return result; }
namespace mcld { typedef GCFactory<NameSpec, MCLD_SYMBOLS_PER_INPUT> NameSpecFactory; static llvm::ManagedStatic<NameSpecFactory> g_NameSpecFactory; //===----------------------------------------------------------------------===// // NameSpec //===----------------------------------------------------------------------===// NameSpec::NameSpec() { } NameSpec::NameSpec(const std::string& pName, bool pAsNeeded) : InputToken(InputToken::NameSpec, pName, pAsNeeded) { } NameSpec::~NameSpec() { } NameSpec* NameSpec::create(const std::string& pName, bool pAsNeeded) { NameSpec* result = g_NameSpecFactory->allocate(); new (result) NameSpec(pName, pAsNeeded); return result; } void NameSpec::destroy(NameSpec*& pNameSpec) { g_NameSpecFactory->destroy(pNameSpec); g_NameSpecFactory->deallocate(pNameSpec); pNameSpec = NULL; } void NameSpec::clear() { g_NameSpecFactory->clear(); } } // namespace mcld
namespace mcld { typedef GCFactory<SectionData, MCLD_SECTIONS_PER_INPUT> SectDataFactory; static llvm::ManagedStatic<SectDataFactory> g_SectDataFactory; //===----------------------------------------------------------------------===// // SectionData //===----------------------------------------------------------------------===// SectionData::SectionData() : m_pSection(NULL) { } SectionData::SectionData(LDSection& pSection) : m_pSection(&pSection) { } SectionData* SectionData::Create(LDSection& pSection) { SectionData* result = g_SectDataFactory->allocate(); new (result) SectionData(pSection); return result; } void SectionData::Destroy(SectionData*& pSection) { pSection->~SectionData(); g_SectDataFactory->deallocate(pSection); pSection = NULL; } void SectionData::Clear() { g_SectDataFactory->clear(); } } // namespace mcld
namespace mcld { typedef GCFactory<StrToken, MCLD_SYMBOLS_PER_INPUT> StrTokenFactory; static llvm::ManagedStatic<StrTokenFactory> g_StrTokenFactory; //===----------------------------------------------------------------------===// // StrToken //===----------------------------------------------------------------------===// StrToken::StrToken() : m_Kind(Unknown) { } StrToken::StrToken(Kind pKind, const std::string& pString) : m_Kind(pKind), m_Name(pString) { } StrToken::~StrToken() { } StrToken* StrToken::create(const std::string& pString) { StrToken* result = g_StrTokenFactory->allocate(); new (result) StrToken(String, pString); return result; } void StrToken::destroy(StrToken*& pStrToken) { g_StrTokenFactory->destroy(pStrToken); g_StrTokenFactory->deallocate(pStrToken); pStrToken = NULL; } void StrToken::clear() { g_StrTokenFactory->clear(); } } // namespace mcld
void SBDebugger::Initialize () { Log *log(GetLogIfAllCategoriesSet (LIBLLDB_LOG_API)); if (log) log->Printf ("SBDebugger::Initialize ()"); g_debugger_lifetime->Initialize(llvm::make_unique<SystemInitializerFull>(), LoadPlugin); }
LDSection* LDSection::Create(const std::string& pName, LDFileFormat::Kind pKind, uint32_t pType, uint32_t pFlag, uint64_t pSize, uint64_t pAddr) { LDSection* result = g_SectFactory->allocate(); new (result) LDSection(pName, pKind, pType, pFlag, pSize, pAddr); return result; }
DebugPrintEnabler(unsigned PassNumber) { #ifndef NDEBUG OldDebugFlag = llvm::DebugFlag; if (llvm::DebugFlag) return; if (DebugPassNumbers->empty()) return; // Enable debug printing if the pass number matches // one of the pass numbers provided as a command line option. for (auto DebugPassNumber : *DebugPassNumbers) { if (DebugPassNumber == PassNumber) { llvm::DebugFlag = true; return; } } #endif }
namespace mcld { typedef GCFactory<RelocData, MCLD_SECTIONS_PER_INPUT> RelocDataFactory; static llvm::ManagedStatic<RelocDataFactory> g_RelocDataFactory; //===----------------------------------------------------------------------===// // RelocData //===----------------------------------------------------------------------===// RelocData::RelocData() : m_pSection(NULL) { } RelocData::RelocData(LDSection& pSection) : m_pSection(&pSection) { } RelocData* RelocData::Create(LDSection& pSection) { RelocData* result = g_RelocDataFactory->allocate(); new (result) RelocData(pSection); return result; } void RelocData::Destroy(RelocData*& pSection) { pSection->~RelocData(); g_RelocDataFactory->deallocate(pSection); pSection = NULL; } void RelocData::Clear() { g_RelocDataFactory->clear(); } RelocData& RelocData::append(Relocation& pRelocation) { m_Relocations.push_back(&pRelocation); return *this; } Relocation& RelocData::remove(Relocation& pRelocation) { iterator iter(pRelocation); Relocation* rel = m_Relocations.remove(iter); return *rel; } } // namespace mcld
namespace mcld { typedef GCFactory<StringList, MCLD_SYMBOLS_PER_INPUT> StringListFactory; static llvm::ManagedStatic<StringListFactory> g_StringListFactory; //===----------------------------------------------------------------------===// // StringList //===----------------------------------------------------------------------===// StringList::StringList() { } StringList::~StringList() { } void StringList::push_back(StrToken* pToken) { m_Tokens.push_back(pToken); } void StringList::dump() const { for (const_iterator it = begin(), ie = end(); it != ie; ++it) mcld::outs() << (*it)->name() << "\t"; mcld::outs() << "\n"; } StringList* StringList::create() { StringList* result = g_StringListFactory->allocate(); new (result) StringList(); return result; } void StringList::destroy(StringList*& pStringList) { g_StringListFactory->destroy(pStringList); g_StringListFactory->deallocate(pStringList); pStringList = NULL; } void StringList::clear() { g_StringListFactory->clear(); } } // namespace mcld
FragOperand* FragOperand::create(Fragment& pFragment) { FragOperand* result = g_FragOperandFactory->allocate(); new (result) FragOperand(pFragment); return result; }
void SectDescOperand::clear() { g_SectDescOperandFactory->clear(); }
void SectDescOperand::destroy(SectDescOperand*& pOperand) { g_SectDescOperandFactory->destroy(pOperand); g_SectDescOperandFactory->deallocate(pOperand); pOperand = NULL; }
SectDescOperand* SectDescOperand::create( const SectionMap::Output* pOutputDesc) { SectDescOperand* result = g_SectDescOperandFactory->allocate(); new (result) SectDescOperand(pOutputDesc); return result; }
void EhFrame::Clear() { g_EhFrameFactory->clear(); }
void EhFrame::Destroy(EhFrame*& pSection) { pSection->~EhFrame(); g_EhFrameFactory->deallocate(pSection); pSection = NULL; }
void IntOperand::destroy(IntOperand*& pOperand) { g_IntOperandFactory->destroy(pOperand); g_IntOperandFactory->deallocate(pOperand); pOperand = NULL; }
void SymOperand::clear() { g_SymOperandFactory->clear(); }
SymOperand* SymOperand::create(const std::string& pName) { SymOperand* result = g_SymOperandFactory->allocate(); new (result) SymOperand(pName); return result; }
void FragOperand::destroy(FragOperand*& pOperand) { g_FragOperandFactory->destroy(pOperand); g_FragOperandFactory->deallocate(pOperand); pOperand = NULL; }
void FragOperand::clear() { g_FragOperandFactory->clear(); }
RelocData* RelocData::Create(LDSection& pSection) { RelocData* result = g_RelocDataFactory->allocate(); new (result) RelocData(pSection); return result; }
void SymOperand::destroy(SymOperand*& pOperand) { g_SymOperandFactory->destroy(pOperand); g_SymOperandFactory->deallocate(pOperand); pOperand = NULL; }
void RelocData::Destroy(RelocData*& pSection) { pSection->~RelocData(); g_RelocDataFactory->deallocate(pSection); pSection = NULL; }
IntOperand* IntOperand::create(uint64_t pValue) { IntOperand* result = g_IntOperandFactory->allocate(); new (result) IntOperand(pValue); return result; }
void RelocData::Clear() { g_RelocDataFactory->clear(); }
void IntOperand::clear() { g_IntOperandFactory->clear(); }
EhFrame* EhFrame::Create(LDSection& pSection) { EhFrame* result = g_EhFrameFactory->allocate(); new (result) EhFrame(pSection); return result; }