Movatterモバイル変換

Go to the documentation of this file.

1//===-- DynamicLibrary.cpp - Runtime link/load libraries --------*- C++ -*-===//

2//

3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.

4// See https://llvm.org/LICENSE.txt for license information.

5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception

6//

7//===----------------------------------------------------------------------===//

8//

9// This file implements the operating system DynamicLibrary concept.

10//

11//===----------------------------------------------------------------------===//

13#include "llvm/Support/DynamicLibrary.h"

14#include "llvm-c/Support.h"

15#include "llvm/ADT/STLExtras.h"

16#include "llvm/ADT/StringMap.h"

17#include "llvm/Config/config.h"

18#include "llvm/Support/Mutex.h"

19#include <vector>

21using namespacellvm;

22using namespacellvm::sys;

24// All methods for HandleSet should be used holding SymbolsMutex.

25classDynamicLibrary::HandleSet {

26typedef std::vector<void *> HandleList;

27 HandleList Handles;

28void *Process =nullptr;

30public:

31staticvoid *DLOpen(constchar *Filename, std::string *Err);

32staticvoidDLClose(void *Handle);

33staticvoid *DLSym(void *Handle,constchar *Symbol);

35HandleSet() =default;

36~HandleSet();

38 HandleList::iteratorFind(void *Handle) {returnfind(Handles, Handle); }

40boolContains(void *Handle) {

41return Handle ==Process ||Find(Handle) != Handles.end();

42 }

44boolAddLibrary(void *Handle,bool IsProcess =false,bool CanClose =true,

45bool AllowDuplicates =false) {

46#ifdef _WIN32

47assert((Handle ==this ? IsProcess : !IsProcess) &&"Bad Handle.");

48#endif

49assert((!AllowDuplicates || !CanClose) &&

50"CanClose must be false if AllowDuplicates is true.");

52if (LLVM_LIKELY(!IsProcess)) {

53if (!AllowDuplicates &&Find(Handle) != Handles.end()) {

54if (CanClose)

55DLClose(Handle);

56returnfalse;

57 }

58 Handles.push_back(Handle);

59 }else {

60#ifndef _WIN32

61if (Process) {

62if (CanClose)

63DLClose(Process);

64if (Process == Handle)

65returnfalse;

66 }

67#endif

68Process = Handle;

69 }

70returntrue;

71 }

73voidCloseLibrary(void *Handle) {

74DLClose(Handle);

75 HandleList::iterator it =Find(Handle);

76if (it != Handles.end()) {

77 Handles.erase(it);

78 }

79 }

81void *LibLookup(constchar *Symbol,DynamicLibrary::SearchOrdering Order) {

82if (Order &SO_LoadOrder) {

83for (void *Handle : Handles) {

84if (void *Ptr =DLSym(Handle, Symbol))

85returnPtr;

86 }

87 }else {

88for (void *Handle :llvm::reverse(Handles)) {

89if (void *Ptr =DLSym(Handle, Symbol))

90returnPtr;

91 }

92 }

93returnnullptr;

94 }

96void *Lookup(constchar *Symbol,DynamicLibrary::SearchOrdering Order) {

97assert(!((Order &SO_LoadedFirst) && (Order &SO_LoadedLast)) &&

98"Invalid Ordering");

100if (!Process || (Order &SO_LoadedFirst)) {

101if (void *Ptr =LibLookup(Symbol, Order))

102returnPtr;

103 }

104if (Process) {

105// Use OS facilities to search the current binary and all loaded libs.

106if (void *Ptr =DLSym(Process, Symbol))

107returnPtr;

108

109// Search any libs that might have been skipped because of RTLD_LOCAL.

110if (Order &SO_LoadedLast) {

111if (void *Ptr =LibLookup(Symbol, Order))

112returnPtr;

113 }

114 }

115returnnullptr;

116 }

117};

118

119namespace{

120

121structGlobals {

122// Collection of symbol name/value pairs to be searched prior to any

123// libraries.

124llvm::StringMap<void *> ExplicitSymbols;

125// Collections of known library handles.

126DynamicLibrary::HandleSet OpenedHandles;

127DynamicLibrary::HandleSet OpenedTemporaryHandles;

128// Lock for ExplicitSymbols, OpenedHandles, and OpenedTemporaryHandles.

129llvm::sys::SmartMutex<true> SymbolsMutex;

130};

131

132Globals &getGlobals() {

133static GlobalsG;

134returnG;

135}

136

137}// namespace

138

139#ifdef _WIN32

140

141#include "Windows/DynamicLibrary.inc"

142

143#else

144

145#include "Unix/DynamicLibrary.inc"

146

147#endif

148

149char DynamicLibrary::Invalid;

150DynamicLibrary::SearchOrdering DynamicLibrary::SearchOrder =

151DynamicLibrary::SO_Linker;

152

153namespacellvm {

154void *SearchForAddressOfSpecialSymbol(constchar *SymbolName) {

155return DoSearch(SymbolName);// DynamicLibrary.inc

156}

157}// namespace llvm

158

159voidDynamicLibrary::AddSymbol(StringRef SymbolName,void *SymbolValue) {

160auto &G = getGlobals();

161SmartScopedLock<true> Lock(G.SymbolsMutex);

162G.ExplicitSymbols[SymbolName] = SymbolValue;

163}

164

165DynamicLibrary DynamicLibrary::getPermanentLibrary(constchar *FileName,

166 std::string *Err) {

167auto &G = getGlobals();

168void *Handle =HandleSet::DLOpen(FileName, Err);

169if (Handle != &Invalid) {

170SmartScopedLock<true> Lock(G.SymbolsMutex);

171G.OpenedHandles.AddLibrary(Handle,/*IsProcess*/ FileName ==nullptr);

172 }

173

174returnDynamicLibrary(Handle);

175}

176

177DynamicLibrary DynamicLibrary::addPermanentLibrary(void *Handle,

178 std::string *Err) {

179auto &G = getGlobals();

180SmartScopedLock<true> Lock(G.SymbolsMutex);

181// If we've already loaded this library, tell the caller.

182if (!G.OpenedHandles.AddLibrary(Handle,/*IsProcess*/false,

183/*CanClose*/false))

184 *Err ="Library already loaded";

185

186returnDynamicLibrary(Handle);

187}

188

189DynamicLibrary DynamicLibrary::getLibrary(constchar *FileName,

190 std::string *Err) {

191assert(FileName &&"Use getPermanentLibrary() for opening process handle");

192void *Handle =HandleSet::DLOpen(FileName, Err);

193if (Handle != &Invalid) {

194auto &G = getGlobals();

195SmartScopedLock<true> Lock(G.SymbolsMutex);

196G.OpenedTemporaryHandles.AddLibrary(Handle,/*IsProcess*/false,

197/*CanClose*/false,

198/*AllowDuplicates*/true);

199 }

200returnDynamicLibrary(Handle);

201}

202

203voidDynamicLibrary::closeLibrary(DynamicLibrary &Lib) {

204auto &G = getGlobals();

205SmartScopedLock<true> Lock(G.SymbolsMutex);

206if (Lib.isValid()) {

207G.OpenedTemporaryHandles.CloseLibrary(Lib.Data);

208Lib.Data = &Invalid;

209 }

210}

211

212void *DynamicLibrary::getAddressOfSymbol(constchar *SymbolName) {

213if (!isValid())

214returnnullptr;

215returnHandleSet::DLSym(Data, SymbolName);

216}

217

218void *DynamicLibrary::SearchForAddressOfSymbol(constchar *SymbolName) {

219 {

220auto &G = getGlobals();

221SmartScopedLock<true> Lock(G.SymbolsMutex);

222

223// First check symbols added via AddSymbol().

224StringMap<void *>::iterator i =G.ExplicitSymbols.find(SymbolName);

225

226if (i !=G.ExplicitSymbols.end())

227return i->second;

228

229// Now search the libraries.

230if (void *Ptr =G.OpenedHandles.Lookup(SymbolName,SearchOrder))

231returnPtr;

232if (void *Ptr =G.OpenedTemporaryHandles.Lookup(SymbolName,SearchOrder))

233returnPtr;

234 }

235

236returnllvm::SearchForAddressOfSpecialSymbol(SymbolName);

237}

238

239//===----------------------------------------------------------------------===//

240// C API.

241//===----------------------------------------------------------------------===//

242

243LLVMBool LLVMLoadLibraryPermanently(constchar *Filename) {

244returnllvm::sys::DynamicLibrary::LoadLibraryPermanently(Filename);

245}

246

247void *LLVMSearchForAddressOfSymbol(constchar *symbolName) {

248returnllvm::sys::DynamicLibrary::SearchForAddressOfSymbol(symbolName);

249}

250

251voidLLVMAddSymbol(constchar *symbolName,void *symbolValue) {

252returnllvm::sys::DynamicLibrary::AddSymbol(symbolName, symbolValue);

253}

StringMap.h

This file defines the StringMap class.

LLVM_LIKELY

#define LLVM_LIKELY(EXPR)

Definition:Compiler.h:319

DynamicLibrary.h

#define G(x, y, z)

Definition:MD5.cpp:56

Mutex.h

assert

assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())

STLExtras.h

This file contains some templates that are useful if you are working with the STL at all.

Ptr

@ Ptr

Definition:TargetLibraryInfo.cpp:77

DynamicLibrary.inc

llvm::sys::DynamicLibrary::HandleSet

Definition:DynamicLibrary.cpp:25

llvm::sys::DynamicLibrary::HandleSet::AddLibrary

bool AddLibrary(void *Handle, bool IsProcess=false, bool CanClose=true, bool AllowDuplicates=false)

Definition:DynamicLibrary.cpp:44

llvm::sys::DynamicLibrary::HandleSet::Lookup

void * Lookup(const char *Symbol, DynamicLibrary::SearchOrdering Order)

Definition:DynamicLibrary.cpp:96

llvm::sys::DynamicLibrary::HandleSet::HandleSet

HandleSet()=default

llvm::sys::DynamicLibrary::HandleSet::Contains

bool Contains(void *Handle)

Definition:DynamicLibrary.cpp:40

llvm::sys::DynamicLibrary::HandleSet::Find

HandleList::iterator Find(void *Handle)

Definition:DynamicLibrary.cpp:38

llvm::sys::DynamicLibrary::HandleSet::DLOpen

static void * DLOpen(const char *Filename, std::string *Err)

llvm::sys::DynamicLibrary::HandleSet::~HandleSet

~HandleSet()

llvm::sys::DynamicLibrary::HandleSet::LibLookup

void * LibLookup(const char *Symbol, DynamicLibrary::SearchOrdering Order)

Definition:DynamicLibrary.cpp:81

llvm::sys::DynamicLibrary::HandleSet::DLSym

static void * DLSym(void *Handle, const char *Symbol)

llvm::sys::DynamicLibrary::HandleSet::DLClose

static void DLClose(void *Handle)

llvm::sys::DynamicLibrary::HandleSet::CloseLibrary

void CloseLibrary(void *Handle)

Definition:DynamicLibrary.cpp:73

llvm::StringMapIterator

Definition:StringMap.h:496

llvm::StringMap

StringMap - This is an unconventional map that is specialized for handling keys that are "strings",...

Definition:StringMap.h:128

llvm::StringRef

StringRef - Represent a constant reference to a string, i.e.

Definition:StringRef.h:51

llvm::sys::DynamicLibrary

This class provides a portable interface to dynamic libraries which also might be known as shared lib...

Definition:DynamicLibrary.h:33

llvm::sys::DynamicLibrary::getLibrary

static DynamicLibrary getLibrary(const char *FileName, std::string *Err=nullptr)

This function loads the dynamic library at the given path, using the library load operation from the ...

Definition:DynamicLibrary.cpp:189

llvm::sys::DynamicLibrary::addPermanentLibrary

static DynamicLibrary addPermanentLibrary(void *handle, std::string *errMsg=nullptr)

Registers an externally loaded library.

Definition:DynamicLibrary.cpp:177

llvm::sys::DynamicLibrary::AddSymbol

static void AddSymbol(StringRef symbolName, void *symbolValue)

This functions permanently adds the symbol symbolName with the value symbolValue.

Definition:DynamicLibrary.cpp:159

llvm::sys::DynamicLibrary::LoadLibraryPermanently

static bool LoadLibraryPermanently(const char *Filename, std::string *ErrMsg=nullptr)

This function permanently loads the dynamic library at the given path.

Definition:DynamicLibrary.h:86

llvm::sys::DynamicLibrary::SearchOrdering

SearchOrdering

Definition:DynamicLibrary.h:112

llvm::sys::DynamicLibrary::SO_LoadedLast

@ SO_LoadedLast

SO_LoadedLast - Search as SO_Linker would, then loaded libraries.

Definition:DynamicLibrary.h:121

llvm::sys::DynamicLibrary::SO_LoadOrder

@ SO_LoadOrder

SO_LoadOrder - Or this in to search libraries in the ordered loaded.

Definition:DynamicLibrary.h:124

llvm::sys::DynamicLibrary::SO_Linker

@ SO_Linker

SO_Linker - Search as a call to dlsym(dlopen(NULL)) would when DynamicLibrary::getPermanentLibrary(NU...

Definition:DynamicLibrary.h:116

llvm::sys::DynamicLibrary::SO_LoadedFirst

@ SO_LoadedFirst

SO_LoadedFirst - Search all loaded libraries, then as SO_Linker would.

Definition:DynamicLibrary.h:118

llvm::sys::DynamicLibrary::getPermanentLibrary

static DynamicLibrary getPermanentLibrary(const char *filename, std::string *errMsg=nullptr)

This function permanently loads the dynamic library at the given path using the library load operatio...

Definition:DynamicLibrary.cpp:165

llvm::sys::DynamicLibrary::SearchOrder

static SearchOrdering SearchOrder

Definition:DynamicLibrary.h:126

llvm::sys::DynamicLibrary::getAddressOfSymbol

void * getAddressOfSymbol(const char *symbolName)

Searches through the library for the symbol symbolName.

Definition:DynamicLibrary.cpp:212

llvm::sys::DynamicLibrary::isValid

bool isValid() const

Returns true if the object refers to a valid library.

Definition:DynamicLibrary.h:49

llvm::sys::DynamicLibrary::SearchForAddressOfSymbol

static void * SearchForAddressOfSymbol(const char *symbolName)

This function will search through all previously loaded dynamic libraries for the symbol symbolName.

Definition:DynamicLibrary.cpp:218

llvm::sys::DynamicLibrary::closeLibrary

static void closeLibrary(DynamicLibrary &Lib)

This function closes the dynamic library at the given path, using the library close operation of the ...

Definition:DynamicLibrary.cpp:203

llvm::sys::Process

A collection of legacy interfaces for querying information about the current executing process.

Definition:Process.h:43

llvm::sys::SmartMutex

SmartMutex - A mutex with a compile time constant parameter that indicates whether this mutex should ...

Definition:Mutex.h:28

LLVMLoadLibraryPermanently

LLVMBool LLVMLoadLibraryPermanently(const char *Filename)

This function permanently loads the dynamic library at the given path.

Definition:DynamicLibrary.cpp:243

LLVMAddSymbol

void LLVMAddSymbol(const char *symbolName, void *symbolValue)

This functions permanently adds the symbol symbolName with the value symbolValue.

Definition:DynamicLibrary.cpp:251

LLVMSearchForAddressOfSymbol

void * LLVMSearchForAddressOfSymbol(const char *symbolName)

This function will search through all previously loaded dynamic libraries for the symbol symbolName.

Definition:DynamicLibrary.cpp:247

LLVMBool

int LLVMBool

Definition:Types.h:28

Support.h

llvm::sys

Definition:Atomic.h:28

llvm::sys::SmartScopedLock

std::lock_guard< SmartMutex< mt_only > > SmartScopedLock

Definition:Mutex.h:69

llvm

This is an optimization pass for GlobalISel generic memory operations.

Definition:AddressRanges.h:18

llvm::find

auto find(R &&Range, const T &Val)

Provide wrappers to std::find which take ranges instead of having to pass begin/end explicitly.

Definition:STLExtras.h:1759

llvm::SubDirectoryType::Lib

@ Lib

llvm::reverse

auto reverse(ContainerTy &&C)

Definition:STLExtras.h:420

llvm::SearchForAddressOfSpecialSymbol

void * SearchForAddressOfSpecialSymbol(const char *SymbolName)

Definition:DynamicLibrary.cpp:154