src/third_party/android_crazy_linker/src/src/crazy_linker_library_list.cpp - cobalt - Git at Google

 // Copyright 2014 The Chromium Authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.

 #include "crazy_linker_library_list.h"

 #include <assert.h>
 #include <crazy_linker.h>

 #include "crazy_linker_debug.h"
 #include "crazy_linker_globals.h"
 #include "crazy_linker_library_view.h"
 #include "crazy_linker_pointer_set.h"
 #include "crazy_linker_rdebug.h"
 #include "crazy_linker_shared_library.h"
 #include "crazy_linker_system.h"
 #include "crazy_linker_system_linker.h"
 #include "crazy_linker_util.h"

 #ifdef __ANDROID__
 #include "crazy_linker_system_android.h"
 #endif

 namespace crazy {

 namespace {

 // A helper struct used when looking up symbols in libraries.
 struct SymbolLookupState {
   void* found_addr = nullptr;
   void* weak_addr = nullptr;
   int weak_count = 0;

   // Check a symbol entry.
   bool CheckSymbol(const char* symbol, SharedLibrary* lib) {
     const ELF::Sym* entry = lib->LookupSymbolEntry(symbol);
     if (!entry)
       return false;

     void* address = reinterpret_cast<void*>(lib->load_bias() + entry->st_value);

     // If this is a strong symbol, record it and return true.
     if (ELF_ST_BIND(entry->st_info) == STB_GLOBAL) {
       found_addr = address;
       return true;
     }
     // If this is a weak symbol, record the first one and
     // increment the weak_count.
     if (++weak_count == 1)
       weak_addr = address;

     return false;
   }
 };

 }  // namespace

 LibraryList::LibraryList() {
 #ifdef __ANDROID__
   const int sdk_build_version = GetAndroidDeviceApiLevel();

   // If SDK version is Lollipop or earlier, we need to load anything
   // listed in LD_PRELOAD explicitly, because dlsym() on the main executable
   // fails to lookup in preloads on those releases. Also, when doing our
   // symbol resolution we need to explicity search preloads *before* we
   // search the main executable, to ensure that preloads override symbols
   // correctly. Searching preloads before main is opposite to the way the
   // system linker's ordering of these searches, but it is required here to
   // work round the platform's dlsym() issue.
   //
   // If SDK version is Lollipop-mr1 or later then dlsym() will search
   // preloads when invoked on the main executable, meaning that we do not
   // want (or need) to load them here. The platform itself will take care
   // of them for us, and so by not loading preloads here our preloads list
   // remains empty, so that searching it for name lookups is a no-op.
   //
   // For more, see:
   //   https://code.google.com/p/android/issues/detail?id=74255
   if (sdk_build_version <= ANDROID_SDK_VERSION_CODE_LOLLIPOP)
     LoadPreloads();
 #endif  // __ANDROID__
 }

 LibraryList::~LibraryList() {
   // Invalidate crazy library list.
   head_ = nullptr;

   // Destroy all known libraries in reverse order.
   while (!known_libraries_.IsEmpty()) {
     LibraryView* view = known_libraries_.PopLast();
     delete view;
   }
 }

 void LibraryList::LoadPreloads() {
   const char* ld_preload = GetEnv("LD_PRELOAD");
   if (!ld_preload)
     return;

   LOG("Preloads list is: %s", ld_preload);
   const char* current = ld_preload;
   const char* end = ld_preload + strlen(ld_preload);

   // Iterate over library names listed in the environment. The separator
   // here may be either space or colon.
   while (current < end) {
     const char* item = current;
     const size_t item_length = strcspn(current, " :");
     if (item_length == 0) {
       current += 1;
       continue;
     }
     current = item + item_length + 1;

     String lib_name(item, item_length);
     LOG("Attempting to preload %s", lib_name.c_str());

     if (FindKnownLibrary(lib_name.c_str())) {
       LOG("already loaded %s: ignoring", lib_name.c_str());
       continue;
     }

     Error error;
     LibraryView* preload = LoadLibraryWithSystemLinker(
         lib_name.c_str(), RTLD_NOW | RTLD_GLOBAL, &error);
     if (!preload) {
       LOG("'%s' cannot be preloaded: ignored\n", lib_name.c_str());
       continue;
     }

     preloaded_libraries_.PushBack(preload);
   }

   if (CRAZY_DEBUG) {
     LOG("Preloads loaded");
     for (const LibraryView* preload : preloaded_libraries_)
       LOG("  ... %p %s\n", preload, preload->GetName());
     LOG("    preloads @%p\n", &preloaded_libraries_);
   }
 }

 LibraryView* LibraryList::FindLibraryByName(const char* lib_name) {
   // Sanity check.
   if (!lib_name)
     return nullptr;

   for (LibraryView* view : known_libraries_) {
     if (!strcmp(lib_name, view->GetName()))
       return view;
   }
   return nullptr;
 }

 void* LibraryList::FindSymbolFrom(const char* symbol_name,
                                   const LibraryView* from) {
   SymbolLookupState lookup_state;

   if (!from)
     return nullptr;

   // Use a work-queue and a set to ensure to perform a breadth-first
   // search.
   Vector<const LibraryView*> work_queue;
   PointerSet visited_set;

   work_queue.PushBack(from);

   while (!work_queue.IsEmpty()) {
     const LibraryView* lib = work_queue.PopFirst();
     if (lib->IsCrazy()) {
       if (lookup_state.CheckSymbol(symbol_name, lib->GetCrazy()))
         return lookup_state.found_addr;
     } else if (lib->IsSystem()) {
       LibraryView::SearchResult sym = lib->LookupSymbol(symbol_name);
       if (sym.IsValid())
         return sym.address;
     }

     // If this is a crazy library, add non-visited dependencies
     // to the work queue.
     if (lib->IsCrazy()) {
       SharedLibrary::DependencyIterator iter(lib->GetCrazy());
       while (iter.GetNext()) {
         LibraryView* dependency = FindKnownLibrary(iter.GetName());
         if (dependency && !visited_set.Has(dependency)) {
           work_queue.PushBack(dependency);
           visited_set.Add(dependency);
         }
       }
     }
   }

   if (lookup_state.weak_count >= 1) {
     // There was at least a single weak symbol definition, so use
     // the first one found in breadth-first search order.
     return lookup_state.weak_addr;
   }

   // There was no symbol definition.
   return nullptr;
 }

 LibraryView* LibraryList::FindLibraryForAddress(void* address) {
   // Linearly scan all libraries, looking for one that contains
   // a given address. NOTE: This doesn't check that this falls
   // inside one of the mapped library segments.
   for (LibraryView* view : known_libraries_) {
     // TODO(digit): Search addresses inside system libraries.
     if (view->IsCrazy()) {
       SharedLibrary* lib = view->GetCrazy();
       if (lib->ContainsAddress(address))
         return view;
     }
   }
   return nullptr;
 }

 #ifdef __arm__
 _Unwind_Ptr LibraryList::FindArmExIdx(void* pc, int* count) {
   for (SharedLibrary* lib = head_; lib; lib = lib->list_next_) {
     if (lib->ContainsAddress(pc)) {
       *count = static_cast<int>(lib->arm_exidx_count_);
       return reinterpret_cast<_Unwind_Ptr>(lib->arm_exidx_);
     }
   }
   *count = 0;
   return static_cast<_Unwind_Ptr>(NULL);
 }
 #else  // !__arm__
 int LibraryList::IteratePhdr(PhdrIterationCallback callback, void* data) {
   int result = 0;
   for (SharedLibrary* lib = head_; lib; lib = lib->list_next_) {
     dl_phdr_info info;
     info.dlpi_addr = lib->link_map_.l_addr;
     info.dlpi_name = lib->link_map_.l_name;
     info.dlpi_phdr = lib->phdr();
     info.dlpi_phnum = lib->phdr_count();
     result = callback(&info, sizeof(info), data);
     if (result)
       break;
   }
   return result;
 }
 #endif  // !__arm__

 void LibraryList::UnloadLibrary(LibraryView* wrap) {
   // Sanity check.
   LOG("for %s (ref_count=%d)", wrap->GetName(), wrap->ref_count());

   if (!wrap->IsSystem() && !wrap->IsCrazy())
     return;

   if (!wrap->SafeDecrementRef())
     return;

   // If this is a crazy library, perform manual cleanup first.
   if (wrap->IsCrazy()) {
     SharedLibrary* lib = wrap->GetCrazy();

     // Remove from internal list of crazy libraries.
     if (lib->list_next_)
       lib->list_next_->list_prev_ = lib->list_prev_;
     if (lib->list_prev_)
       lib->list_prev_->list_next_ = lib->list_next_;
     if (lib == head_)
       head_ = lib->list_next_;

     // Call JNI_OnUnload, if necessary, then the destructors.
     LOG("Running JNI_OnUnload() for %s", wrap->GetName());
     lib->CallJniOnUnload();
     LOG("Running destructors for %s", wrap->GetName());
     lib->CallDestructors();

     // Unload the dependencies recursively.
     SharedLibrary::DependencyIterator iter(lib);
     while (iter.GetNext()) {
       LibraryView* dependency = FindKnownLibrary(iter.GetName());
       if (dependency)
         UnloadLibrary(dependency);
     }

     // Tell GDB of this removal.
     Globals::GetRDebug()->DelEntry(&lib->link_map_);
   }

   known_libraries_.Remove(wrap);

   // Delete the wrapper, which will delete the crazy library, or
   // dlclose() the system one.
   delete wrap;
 }

 LibraryView* LibraryList::LoadLibraryWithSystemLinker(const char* lib_name,
                                                       int dlopen_mode,
                                                       Error* error) {
   // First check whether a library with the same base name was
   // already loaded.
   LibraryView* view = FindKnownLibrary(lib_name);
   if (view) {
     view->AddRef();
     return view;
   }

   void* system_lib = SystemLinker::Open(lib_name, dlopen_mode);
   if (!system_lib) {
     error->Format("Can't load system library %s: %s", lib_name,
                   SystemLinker::Error());
     return nullptr;
   }

   // Can't really find the DT_SONAME of this library, assume if is its basename.
   view = new LibraryView(system_lib, GetBaseNamePtr(lib_name));
   known_libraries_.PushBack(view);

   LOG("System library %s loaded at %p", lib_name, view);
   return view;
 }

 LibraryView* LibraryList::LoadLibrary(const char* lib_name,
                                       uintptr_t load_address,
                                       SearchPathList* search_path_list,
                                       Error* error) {
   const char* base_name = GetBaseNamePtr(lib_name);

   LOG("lib_name='%s'", lib_name);

   // First check whether a library with the same base name was
   // already loaded.
   LibraryView* view = FindKnownLibrary(base_name);
   if (view) {
     if (load_address) {
       // Check that this is a crazy library and that is was loaded at
       // the correct address.
       if (!view->IsCrazy()) {
         error->Format("System library can't be loaded at fixed address %08x",
                       load_address);
         return nullptr;
       }
       uintptr_t actual_address = view->GetCrazy()->load_address();
       if (actual_address != load_address) {
         error->Format("Library already loaded at @%08x, can't load it at @%08x",
                       actual_address,
                       load_address);
         return nullptr;
       }
     }
     view->AddRef();
     return view;
   }

   // Find the full library path.
   String full_path;

   LOG("Looking through the search path list");
   SearchPathList::Result probe = search_path_list->FindFile(lib_name);
   if (!probe.IsValid()) {
     error->Format("Can't find library file %s", lib_name);
     return nullptr;
   }
   LOG("Found library: path %s @ 0x%x", probe.path.c_str(), probe.offset);

   if (IsSystemLibraryPath(probe.path.c_str())) {
     return LoadLibraryWithSystemLinker(probe.path.c_str(), RTLD_NOW, error);
   }

   // Load the library with the crazy linker.
   ScopedPtr<SharedLibrary> lib(new SharedLibrary());
   if (!lib->Load(probe.path.c_str(), load_address, probe.offset, error))
     return nullptr;

   // Load all dependendent libraries.
   LOG("Loading dependencies of %s", base_name);
   SharedLibrary::DependencyIterator iter(lib.Get());
   Vector<LibraryView*> dependencies;
   while (iter.GetNext()) {
     Error dep_error;
     // TODO(digit): Call LoadLibrary recursively instead when properly
     // detecting system vs Chromium libraries (http://crbug.com/843987).
     LibraryView* dependency =
         LoadLibraryWithSystemLinker(iter.GetName(), RTLD_NOW, &dep_error);
     if (!dependency) {
       error->Format("When loading %s: %s", base_name, dep_error.c_str());
       return nullptr;
     }
     dependencies.PushBack(dependency);
   }
   if (CRAZY_DEBUG) {
     LOG("Dependencies loaded for %s", base_name);
     for (const LibraryView* dep : dependencies)
       LOG("  ... %p %s\n", dep, dep->GetName());
     LOG("    dependencies @%p\n", &dependencies);
   }

   // Relocate the library.
   LOG("Relocating %s", base_name);
   if (!lib->Relocate(this, &preloaded_libraries_, &dependencies, error))
     return nullptr;

   // Notify GDB of load.
   lib->link_map_.l_addr = lib->load_bias();
   lib->link_map_.l_name = const_cast<char*>(lib->base_name_);
   lib->link_map_.l_ld = reinterpret_cast<uintptr_t>(lib->view_.dynamic());
   Globals::GetRDebug()->AddEntry(&lib->link_map_);

   // The library was properly loaded, add it to the list of crazy
   // libraries. IMPORTANT: Do this _before_ calling the constructors
   // because these could call dlopen().
   lib->list_next_ = head_;
   lib->list_prev_ = nullptr;
   if (head_)
     head_->list_prev_ = lib.Get();
   head_ = lib.Get();

   // Then create a new LibraryView for it.
   view = new LibraryView(lib.Release());
   known_libraries_.PushBack(view);

   LOG("Running constructors for %s", base_name);
   // Now run the constructors.
   view->GetCrazy()->CallConstructors();

   // Then try to call JNI_OnLoad() if necessary.
   LOG("Running JNI_OnLoad() for %s", base_name);
   Globals* globals = Globals::Get();
   if (!view->GetCrazy()->CallJniOnLoad(globals->java_vm(),
                                        globals->minimum_jni_version(), error)) {
     LOG("Error on JNI_OnLoad(): %s", error->c_str());
     UnloadLibrary(view);
     return nullptr;
   }

   LOG("Done loading %s", base_name);
   return view;
 }

 void LibraryList::AddLibrary(LibraryView* wrap) {
   known_libraries_.PushBack(wrap);
 }

 LibraryView* LibraryList::FindKnownLibrary(const char* name) {
   const char* base_name = GetBaseNamePtr(name);
   for (LibraryView* view : known_libraries_) {
     if (!strcmp(base_name, view->GetName()))
       return view;
   }
   return nullptr;
 }

 }  // namespace crazy
	// Copyright 2014 The Chromium Authors. All rights reserved.
	// Use of this source code is governed by a BSD-style license that can be
	// found in the LICENSE file.

	#include "crazy_linker_library_list.h"

	#include <assert.h>
	#include <crazy_linker.h>

	#include "crazy_linker_debug.h"
	#include "crazy_linker_globals.h"
	#include "crazy_linker_library_view.h"
	#include "crazy_linker_pointer_set.h"
	#include "crazy_linker_rdebug.h"
	#include "crazy_linker_shared_library.h"
	#include "crazy_linker_system.h"
	#include "crazy_linker_system_linker.h"
	#include "crazy_linker_util.h"

	#ifdef __ANDROID__
	#include "crazy_linker_system_android.h"
	#endif

	namespace crazy {

	namespace {

	// A helper struct used when looking up symbols in libraries.
	struct SymbolLookupState {
	void* found_addr = nullptr;
	void* weak_addr = nullptr;
	int weak_count = 0;

	// Check a symbol entry.
	bool CheckSymbol(const char* symbol, SharedLibrary* lib) {
	const ELF::Sym* entry = lib->LookupSymbolEntry(symbol);
	if (!entry)
	return false;

	void* address = reinterpret_cast<void*>(lib->load_bias() + entry->st_value);

	// If this is a strong symbol, record it and return true.
	if (ELF_ST_BIND(entry->st_info) == STB_GLOBAL) {
	found_addr = address;
	return true;
	}
	// If this is a weak symbol, record the first one and
	// increment the weak_count.
	if (++weak_count == 1)
	weak_addr = address;

	return false;
	}
	};

	} // namespace

	LibraryList::LibraryList() {
	#ifdef __ANDROID__
	const int sdk_build_version = GetAndroidDeviceApiLevel();

	// If SDK version is Lollipop or earlier, we need to load anything
	// listed in LD_PRELOAD explicitly, because dlsym() on the main executable
	// fails to lookup in preloads on those releases. Also, when doing our
	// symbol resolution we need to explicity search preloads before we
	// search the main executable, to ensure that preloads override symbols
	// correctly. Searching preloads before main is opposite to the way the
	// system linker's ordering of these searches, but it is required here to
	// work round the platform's dlsym() issue.
	//
	// If SDK version is Lollipop-mr1 or later then dlsym() will search
	// preloads when invoked on the main executable, meaning that we do not
	// want (or need) to load them here. The platform itself will take care
	// of them for us, and so by not loading preloads here our preloads list
	// remains empty, so that searching it for name lookups is a no-op.
	//
	// For more, see:
	// https://code.google.com/p/android/issues/detail?id=74255
	if (sdk_build_version <= ANDROID_SDK_VERSION_CODE_LOLLIPOP)
	LoadPreloads();
	#endif // __ANDROID__
	}

	LibraryList::~LibraryList() {
	// Invalidate crazy library list.
	head_ = nullptr;

	// Destroy all known libraries in reverse order.
	while (!known_libraries_.IsEmpty()) {
	LibraryView* view = known_libraries_.PopLast();
	delete view;
	}
	}

	void LibraryList::LoadPreloads() {
	const char* ld_preload = GetEnv("LD_PRELOAD");
	if (!ld_preload)
	return;

	LOG("Preloads list is: %s", ld_preload);
	const char* current = ld_preload;
	const char* end = ld_preload + strlen(ld_preload);

	// Iterate over library names listed in the environment. The separator
	// here may be either space or colon.
	while (current < end) {
	const char* item = current;
	const size_t item_length = strcspn(current, " :");
	if (item_length == 0) {
	current += 1;
	continue;
	}
	current = item + item_length + 1;

	String lib_name(item, item_length);
	LOG("Attempting to preload %s", lib_name.c_str());

	if (FindKnownLibrary(lib_name.c_str())) {
	LOG("already loaded %s: ignoring", lib_name.c_str());
	continue;
	}

	Error error;
	LibraryView* preload = LoadLibraryWithSystemLinker(
	lib_name.c_str(), RTLD_NOW \| RTLD_GLOBAL, &error);
	if (!preload) {
	LOG("'%s' cannot be preloaded: ignored\n", lib_name.c_str());
	continue;
	}

	preloaded_libraries_.PushBack(preload);
	}

	if (CRAZY_DEBUG) {
	LOG("Preloads loaded");
	for (const LibraryView* preload : preloaded_libraries_)
	LOG(" ... %p %s\n", preload, preload->GetName());
	LOG(" preloads @%p\n", &preloaded_libraries_);
	}
	}

	LibraryView* LibraryList::FindLibraryByName(const char* lib_name) {
	// Sanity check.
	if (!lib_name)
	return nullptr;

	for (LibraryView* view : known_libraries_) {
	if (!strcmp(lib_name, view->GetName()))
	return view;
	}
	return nullptr;
	}

	void* LibraryList::FindSymbolFrom(const char* symbol_name,
	const LibraryView* from) {
	SymbolLookupState lookup_state;

	if (!from)
	return nullptr;

	// Use a work-queue and a set to ensure to perform a breadth-first
	// search.
	Vector<const LibraryView*> work_queue;
	PointerSet visited_set;

	work_queue.PushBack(from);

	while (!work_queue.IsEmpty()) {
	const LibraryView* lib = work_queue.PopFirst();
	if (lib->IsCrazy()) {
	if (lookup_state.CheckSymbol(symbol_name, lib->GetCrazy()))
	return lookup_state.found_addr;
	} else if (lib->IsSystem()) {
	LibraryView::SearchResult sym = lib->LookupSymbol(symbol_name);
	if (sym.IsValid())
	return sym.address;
	}

	// If this is a crazy library, add non-visited dependencies
	// to the work queue.
	if (lib->IsCrazy()) {
	SharedLibrary::DependencyIterator iter(lib->GetCrazy());
	while (iter.GetNext()) {
	LibraryView* dependency = FindKnownLibrary(iter.GetName());
	if (dependency && !visited_set.Has(dependency)) {
	work_queue.PushBack(dependency);
	visited_set.Add(dependency);
	}
	}
	}
	}

	if (lookup_state.weak_count >= 1) {
	// There was at least a single weak symbol definition, so use
	// the first one found in breadth-first search order.
	return lookup_state.weak_addr;
	}

	// There was no symbol definition.
	return nullptr;
	}

	LibraryView* LibraryList::FindLibraryForAddress(void* address) {
	// Linearly scan all libraries, looking for one that contains
	// a given address. NOTE: This doesn't check that this falls
	// inside one of the mapped library segments.
	for (LibraryView* view : known_libraries_) {
	// TODO(digit): Search addresses inside system libraries.
	if (view->IsCrazy()) {
	SharedLibrary* lib = view->GetCrazy();
	if (lib->ContainsAddress(address))
	return view;
	}
	}
	return nullptr;
	}

	#ifdef __arm__
	_Unwind_Ptr LibraryList::FindArmExIdx(void* pc, int* count) {
	for (SharedLibrary* lib = head_; lib; lib = lib->list_next_) {
	if (lib->ContainsAddress(pc)) {
	*count = static_cast<int>(lib->arm_exidx_count_);
	return reinterpret_cast<_Unwind_Ptr>(lib->arm_exidx_);
	}
	}
	*count = 0;
	return static_cast<_Unwind_Ptr>(NULL);
	}
	#else // !__arm__
	int LibraryList::IteratePhdr(PhdrIterationCallback callback, void* data) {
	int result = 0;
	for (SharedLibrary* lib = head_; lib; lib = lib->list_next_) {
	dl_phdr_info info;
	info.dlpi_addr = lib->link_map_.l_addr;
	info.dlpi_name = lib->link_map_.l_name;
	info.dlpi_phdr = lib->phdr();
	info.dlpi_phnum = lib->phdr_count();
	result = callback(&info, sizeof(info), data);
	if (result)
	break;
	}
	return result;
	}
	#endif // !__arm__

	void LibraryList::UnloadLibrary(LibraryView* wrap) {
	// Sanity check.
	LOG("for %s (ref_count=%d)", wrap->GetName(), wrap->ref_count());

	if (!wrap->IsSystem() && !wrap->IsCrazy())
	return;

	if (!wrap->SafeDecrementRef())
	return;

	// If this is a crazy library, perform manual cleanup first.
	if (wrap->IsCrazy()) {
	SharedLibrary* lib = wrap->GetCrazy();

	// Remove from internal list of crazy libraries.
	if (lib->list_next_)
	lib->list_next_->list_prev_ = lib->list_prev_;
	if (lib->list_prev_)
	lib->list_prev_->list_next_ = lib->list_next_;
	if (lib == head_)
	head_ = lib->list_next_;

	// Call JNI_OnUnload, if necessary, then the destructors.
	LOG("Running JNI_OnUnload() for %s", wrap->GetName());
	lib->CallJniOnUnload();
	LOG("Running destructors for %s", wrap->GetName());
	lib->CallDestructors();

	// Unload the dependencies recursively.
	SharedLibrary::DependencyIterator iter(lib);
	while (iter.GetNext()) {
	LibraryView* dependency = FindKnownLibrary(iter.GetName());
	if (dependency)
	UnloadLibrary(dependency);
	}

	// Tell GDB of this removal.
	Globals::GetRDebug()->DelEntry(&lib->link_map_);
	}

	known_libraries_.Remove(wrap);

	// Delete the wrapper, which will delete the crazy library, or
	// dlclose() the system one.
	delete wrap;
	}

	LibraryView* LibraryList::LoadLibraryWithSystemLinker(const char* lib_name,
	int dlopen_mode,
	Error* error) {
	// First check whether a library with the same base name was
	// already loaded.
	LibraryView* view = FindKnownLibrary(lib_name);
	if (view) {
	view->AddRef();
	return view;
	}

	void* system_lib = SystemLinker::Open(lib_name, dlopen_mode);
	if (!system_lib) {
	error->Format("Can't load system library %s: %s", lib_name,
	SystemLinker::Error());
	return nullptr;
	}

	// Can't really find the DT_SONAME of this library, assume if is its basename.
	view = new LibraryView(system_lib, GetBaseNamePtr(lib_name));
	known_libraries_.PushBack(view);

	LOG("System library %s loaded at %p", lib_name, view);
	return view;
	}

	LibraryView* LibraryList::LoadLibrary(const char* lib_name,
	uintptr_t load_address,
	SearchPathList* search_path_list,
	Error* error) {
	const char* base_name = GetBaseNamePtr(lib_name);

	LOG("lib_name='%s'", lib_name);

	// First check whether a library with the same base name was
	// already loaded.
	LibraryView* view = FindKnownLibrary(base_name);
	if (view) {
	if (load_address) {
	// Check that this is a crazy library and that is was loaded at
	// the correct address.
	if (!view->IsCrazy()) {
	error->Format("System library can't be loaded at fixed address %08x",
	load_address);
	return nullptr;
	}
	uintptr_t actual_address = view->GetCrazy()->load_address();
	if (actual_address != load_address) {
	error->Format("Library already loaded at @%08x, can't load it at @%08x",
	actual_address,
	load_address);
	return nullptr;
	}
	}
	view->AddRef();
	return view;
	}

	// Find the full library path.
	String full_path;

	LOG("Looking through the search path list");
	SearchPathList::Result probe = search_path_list->FindFile(lib_name);
	if (!probe.IsValid()) {
	error->Format("Can't find library file %s", lib_name);
	return nullptr;
	}
	LOG("Found library: path %s @ 0x%x", probe.path.c_str(), probe.offset);

	if (IsSystemLibraryPath(probe.path.c_str())) {
	return LoadLibraryWithSystemLinker(probe.path.c_str(), RTLD_NOW, error);
	}

	// Load the library with the crazy linker.
	ScopedPtr<SharedLibrary> lib(new SharedLibrary());
	if (!lib->Load(probe.path.c_str(), load_address, probe.offset, error))
	return nullptr;

	// Load all dependendent libraries.
	LOG("Loading dependencies of %s", base_name);
	SharedLibrary::DependencyIterator iter(lib.Get());
	Vector<LibraryView*> dependencies;
	while (iter.GetNext()) {
	Error dep_error;
	// TODO(digit): Call LoadLibrary recursively instead when properly
	// detecting system vs Chromium libraries (http://crbug.com/843987).
	LibraryView* dependency =
	LoadLibraryWithSystemLinker(iter.GetName(), RTLD_NOW, &dep_error);
	if (!dependency) {
	error->Format("When loading %s: %s", base_name, dep_error.c_str());
	return nullptr;
	}
	dependencies.PushBack(dependency);
	}
	if (CRAZY_DEBUG) {
	LOG("Dependencies loaded for %s", base_name);
	for (const LibraryView* dep : dependencies)
	LOG(" ... %p %s\n", dep, dep->GetName());
	LOG(" dependencies @%p\n", &dependencies);
	}

	// Relocate the library.
	LOG("Relocating %s", base_name);
	if (!lib->Relocate(this, &preloaded_libraries_, &dependencies, error))
	return nullptr;

	// Notify GDB of load.
	lib->link_map_.l_addr = lib->load_bias();
	lib->link_map_.l_name = const_cast<char*>(lib->base_name_);
	lib->link_map_.l_ld = reinterpret_cast<uintptr_t>(lib->view_.dynamic());
	Globals::GetRDebug()->AddEntry(&lib->link_map_);

	// The library was properly loaded, add it to the list of crazy
	// libraries. IMPORTANT: Do this _before_ calling the constructors
	// because these could call dlopen().
	lib->list_next_ = head_;
	lib->list_prev_ = nullptr;
	if (head_)
	head_->list_prev_ = lib.Get();
	head_ = lib.Get();

	// Then create a new LibraryView for it.
	view = new LibraryView(lib.Release());
	known_libraries_.PushBack(view);

	LOG("Running constructors for %s", base_name);
	// Now run the constructors.
	view->GetCrazy()->CallConstructors();

	// Then try to call JNI_OnLoad() if necessary.
	LOG("Running JNI_OnLoad() for %s", base_name);
	Globals* globals = Globals::Get();
	if (!view->GetCrazy()->CallJniOnLoad(globals->java_vm(),
	globals->minimum_jni_version(), error)) {
	LOG("Error on JNI_OnLoad(): %s", error->c_str());
	UnloadLibrary(view);
	return nullptr;
	}

	LOG("Done loading %s", base_name);
	return view;
	}

	void LibraryList::AddLibrary(LibraryView* wrap) {
	known_libraries_.PushBack(wrap);
	}

	LibraryView* LibraryList::FindKnownLibrary(const char* name) {
	const char* base_name = GetBaseNamePtr(name);
	for (LibraryView* view : known_libraries_) {
	if (!strcmp(base_name, view->GetName()))
	return view;
	}
	return nullptr;
	}

	} // namespace crazy