From 189ac9f14280d495d3d6f3c196f895e7b8e6098f Mon Sep 17 00:00:00 2001 From: Dmitriy Ivanov Date: Mon, 3 Nov 2014 21:15:25 -0800 Subject: [PATCH] Revert "Fix relocation to look for symbols in local group" This reverts commit fd2747bb585fc51b5ad56db09c0e9b66c7091a92. Bug: 18222321 Bug: 18211780 Change-Id: I2d4ebab1e73b7277161af76b99f8249825b22d65 --- linker/linked_list.h | 4 +- linker/linker.cpp | 193 +++++++----------- linker/linker.h | 6 +- tests/dlfcn_test.cpp | 186 ++--------------- .../Android.build.dlopen_check_order_dlsym.mk | 90 -------- ...lopen_check_order_reloc_main_executable.mk | 56 ----- ...build.dlopen_check_order_reloc_siblings.mk | 133 ------------ tests/libs/Android.mk | 75 ++++++- .../libs/dlopen_check_order_reloc_answer.cpp | 23 --- .../dlopen_check_order_reloc_answer_impl.cpp | 19 -- ...dlopen_check_order_reloc_nephew_answer.cpp | 21 -- .../dlopen_check_order_reloc_root_answer.cpp | 21 -- ...pen_check_order_reloc_root_answer_impl.cpp | 19 -- ...m_answer.cpp => dlopen_testlib_answer.cpp} | 4 +- 14 files changed, 162 insertions(+), 688 deletions(-) delete mode 100644 tests/libs/Android.build.dlopen_check_order_dlsym.mk delete mode 100644 tests/libs/Android.build.dlopen_check_order_reloc_main_executable.mk delete mode 100644 tests/libs/Android.build.dlopen_check_order_reloc_siblings.mk delete mode 100644 tests/libs/dlopen_check_order_reloc_answer.cpp delete mode 100644 tests/libs/dlopen_check_order_reloc_answer_impl.cpp delete mode 100644 tests/libs/dlopen_check_order_reloc_nephew_answer.cpp delete mode 100644 tests/libs/dlopen_check_order_reloc_root_answer.cpp delete mode 100644 tests/libs/dlopen_check_order_reloc_root_answer_impl.cpp rename tests/libs/{dlopen_check_order_dlsym_answer.cpp => dlopen_testlib_answer.cpp} (87%) diff --git a/linker/linked_list.h b/linker/linked_list.h index 72a32b4ba..4e62e208f 100644 --- a/linker/linked_list.h +++ b/linker/linked_list.h @@ -86,7 +86,7 @@ class LinkedList { } template - void for_each(F action) const { + void for_each(F action) { visit([&] (T* si) { action(si); return true; @@ -94,7 +94,7 @@ class LinkedList { } template - bool visit(F action) const { + bool visit(F action) { for (LinkedListEntry* e = head_; e != nullptr; e = e->next) { if (!action(e->element)) { return false; diff --git a/linker/linker.cpp b/linker/linker.cpp index eb1a483ae..41557e231 100644 --- a/linker/linker.cpp +++ b/linker/linker.cpp @@ -415,7 +415,7 @@ int dl_iterate_phdr(int (*cb)(dl_phdr_info* info, size_t size, void* data), void return rv; } -static ElfW(Sym)* soinfo_elf_lookup(const soinfo* si, unsigned hash, const char* name) { +static ElfW(Sym)* soinfo_elf_lookup(soinfo* si, unsigned hash, const char* name) { ElfW(Sym)* symtab = si->symtab; TRACE_TYPE(LOOKUP, "SEARCH %s in %s@%p %x %zd", @@ -481,7 +481,7 @@ static unsigned elfhash(const char* _name) { return h; } -static ElfW(Sym)* soinfo_do_lookup(soinfo* si, const char* name, soinfo** lsi, const soinfo::soinfo_list_t& local_group) { +static ElfW(Sym)* soinfo_do_lookup(soinfo* si, const char* name, soinfo** lsi) { unsigned elf_hash = elfhash(name); ElfW(Sym)* s = nullptr; @@ -527,21 +527,16 @@ static ElfW(Sym)* soinfo_do_lookup(soinfo* si, const char* name, soinfo** lsi, c } } - // 3. Look for it in the local group - if (s == nullptr) { - local_group.visit([&](soinfo* local_si) { - DEBUG("%s: looking up %s in %s (from local group)", si->name, name, local_si->name); - s = soinfo_elf_lookup(local_si, elf_hash, name); - if (s != nullptr) { - *lsi = local_si; - return false; - } + /* Look for symbols in the local scope (the object who is + * searching). This happens with C++ templates on x86 for some + * reason. + * + * Notes on weak symbols: + * The ELF specs are ambiguous about treatment of weak definitions in + * dynamic linking. Some systems return the first definition found + * and some the first non-weak definition. This is system dependent. + * Here we return the first definition found for simplicity. */ - return true; - }); - } - - // 4. Look for it in this library (unless we already did it because of DT_SYMBOLIC) if (s == nullptr && !si->has_DT_SYMBOLIC) { DEBUG("%s: looking up %s in local scope", si->name, name); s = soinfo_elf_lookup(si, elf_hash, name); @@ -550,7 +545,6 @@ static ElfW(Sym)* soinfo_do_lookup(soinfo* si, const char* name, soinfo** lsi, c } } - // 5. Dependencies if (s == nullptr) { si->get_children().visit([&](soinfo* child) { DEBUG("%s: looking up %s in %s", si->name, name, child->name); @@ -649,61 +643,33 @@ typedef linked_list_t StringLinkedList; typedef linked_list_t LoadTaskList; -// This function walks down the tree of soinfo dependencies -// in breadth-first order and -// * calls action(soinfo* si) for each node, and -// * terminates walk if action returns false. -// -// walk_dependencies_tree returns false if walk was terminated -// by the action and true otherwise. -template -static bool walk_dependencies_tree(soinfo* root_soinfos[], size_t root_soinfos_size, F action) { +// This is used by dlsym(3). It performs symbol lookup only within the +// specified soinfo object and its dependencies in breadth first order. +ElfW(Sym)* dlsym_handle_lookup(soinfo* si, soinfo** found, const char* name) { SoinfoLinkedList visit_list; SoinfoLinkedList visited; - for (size_t i = 0; i < root_soinfos_size; ++i) { - visit_list.push_back(root_soinfos[i]); - } - - soinfo* si; - while ((si = visit_list.pop_front()) != nullptr) { - if (visited.contains(si)) { + visit_list.push_back(si); + soinfo* current_soinfo; + while ((current_soinfo = visit_list.pop_front()) != nullptr) { + if (visited.contains(current_soinfo)) { continue; } - if (!action(si)) { - return false; + ElfW(Sym)* result = soinfo_elf_lookup(current_soinfo, elfhash(name), name); + + if (result != nullptr) { + *found = current_soinfo; + return result; } + visited.push_back(current_soinfo); - visited.push_back(si); - - si->get_children().for_each([&](soinfo* child) { + current_soinfo->get_children().for_each([&](soinfo* child) { visit_list.push_back(child); }); } - return true; -} - - -// This is used by dlsym(3). It performs symbol lookup only within the -// specified soinfo object and its dependencies in breadth first order. -ElfW(Sym)* dlsym_handle_lookup(soinfo* si, soinfo** found, const char* name) { - ElfW(Sym)* result = nullptr; - uint32_t elf_hash = elfhash(name); - - - walk_dependencies_tree(&si, 1, [&](soinfo* current_soinfo) { - result = soinfo_elf_lookup(current_soinfo, elf_hash, name); - if (result != nullptr) { - *found = current_soinfo; - return false; - } - - return true; - }); - - return result; + return nullptr; } /* This is used by dlsym(3) to performs a global symbol lookup. If the @@ -933,30 +899,19 @@ static bool is_recursive(soinfo* si, soinfo* parent) { }); } -static bool find_libraries(soinfo* start_with, const char* const library_names[], size_t library_names_count, soinfo* soinfos[], - soinfo* ld_preloads[], size_t ld_preloads_count, int rtld_flags, const android_dlextinfo* extinfo) { +static bool find_libraries(const char* const library_names[], size_t library_names_size, soinfo* soinfos[], + soinfo* ld_preloads[], size_t ld_preloads_size, int rtld_flags, const android_dlextinfo* extinfo) { // Step 0: prepare. LoadTaskList load_tasks; - for (size_t i = 0; i < library_names_count; ++i) { + for (size_t i = 0; i < library_names_size; ++i) { const char* name = library_names[i]; - load_tasks.push_back(LoadTask::create(name, start_with)); + load_tasks.push_back(LoadTask::create(name, nullptr)); } - // If soinfos array is null allocate one on stack. - // The array is needed in case of failure; for example - // when library_names[] = {libone.so, libtwo.so} and libone.so - // is loaded correctly but libtwo.so failed for some reason. - // In this case libone.so should be unloaded on return. - // See also implementation of failure_guard below. - - if (soinfos == nullptr) { - size_t soinfos_size = sizeof(soinfo*)*library_names_count; - soinfos = reinterpret_cast(alloca(soinfos_size)); - memset(soinfos, 0, soinfos_size); - } - - // list of libraries to link - see step 2. - size_t soinfos_count = 0; + // Libraries added to this list in reverse order so that we can + // start linking from bottom-up - see step 2. + SoinfoLinkedList found_libs; + size_t soinfos_size = 0; auto failure_guard = make_scope_guard([&]() { // Housekeeping @@ -964,7 +919,7 @@ static bool find_libraries(soinfo* start_with, const char* const library_names[] LoadTask::deleter(t); }); - for (size_t i = 0; iadd_child(si); } + found_libs.push_front(si); - // When ld_preloads is not null, the first - // ld_preloads_count libs are in fact ld_preloads. - if (ld_preloads != nullptr && soinfos_count < ld_preloads_count) { - ld_preloads[soinfos_count] = si; + // When ld_preloads is not null first + // ld_preloads_size libs are in fact ld_preloads. + if (ld_preloads != nullptr && soinfos_size < ld_preloads_size) { + ld_preloads[soinfos_size] = si; } - if (soinfos_count < library_names_count) { - soinfos[soinfos_count++] = si; + if (soinfos_sizeflags & FLAG_LINKED) == 0) { - if (!si->LinkImage(local_group, extinfo)) { + if (!si->LinkImage(extinfo)) { return false; } si->flags |= FLAG_LINKED; } - - return true; - }); - - if (linked) { - failure_guard.disable(); } - return linked; + // All is well - found_libs and load_tasks are empty at this point + // and all libs are successfully linked. + failure_guard.disable(); + return true; } static soinfo* find_library(const char* name, int rtld_flags, const android_dlextinfo* extinfo) { @@ -1034,7 +979,7 @@ static soinfo* find_library(const char* name, int rtld_flags, const android_dlex soinfo* si; - if (!find_libraries(nullptr, &name, 1, &si, nullptr, 0, rtld_flags, extinfo)) { + if (!find_libraries(&name, 1, &si, nullptr, 0, rtld_flags, extinfo)) { return nullptr; } @@ -1145,7 +1090,7 @@ static ElfW(Addr) call_ifunc_resolver(ElfW(Addr) resolver_addr) { } #if defined(USE_RELA) -int soinfo::Relocate(ElfW(Rela)* rela, unsigned count, const soinfo_list_t& local_group) { +int soinfo::Relocate(ElfW(Rela)* rela, unsigned count) { for (size_t idx = 0; idx < count; ++idx, ++rela) { unsigned type = ELFW(R_TYPE)(rela->r_info); unsigned sym = ELFW(R_SYM)(rela->r_info); @@ -1163,7 +1108,7 @@ int soinfo::Relocate(ElfW(Rela)* rela, unsigned count, const soinfo_list_t& loca if (sym != 0) { sym_name = get_string(symtab[sym].st_name); - s = soinfo_do_lookup(this, sym_name, &lsi, local_group); + s = soinfo_do_lookup(this, sym_name, &lsi); if (s == nullptr) { // We only allow an undefined symbol if this is a weak reference... s = &symtab[sym]; @@ -1422,7 +1367,7 @@ int soinfo::Relocate(ElfW(Rela)* rela, unsigned count, const soinfo_list_t& loca } #else // REL, not RELA. -int soinfo::Relocate(ElfW(Rel)* rel, unsigned count, const soinfo_list_t& local_group) { +int soinfo::Relocate(ElfW(Rel)* rel, unsigned count) { for (size_t idx = 0; idx < count; ++idx, ++rel) { unsigned type = ELFW(R_TYPE)(rel->r_info); // TODO: don't use unsigned for 'sym'. Use uint32_t or ElfW(Addr) instead. @@ -1441,7 +1386,7 @@ int soinfo::Relocate(ElfW(Rel)* rel, unsigned count, const soinfo_list_t& local_ if (sym != 0) { sym_name = get_string(symtab[sym].st_name); - s = soinfo_do_lookup(this, sym_name, &lsi, local_group); + s = soinfo_do_lookup(this, sym_name, &lsi); if (s == nullptr) { // We only allow an undefined symbol if this is a weak reference... s = &symtab[sym]; @@ -1627,7 +1572,7 @@ int soinfo::Relocate(ElfW(Rel)* rel, unsigned count, const soinfo_list_t& local_ #endif #if defined(__mips__) -static bool mips_relocate_got(soinfo* si, const soinfo::soinfo_list_t& local_group) { +static bool mips_relocate_got(soinfo* si) { ElfW(Addr)** got = si->plt_got; if (got == nullptr) { return true; @@ -1660,7 +1605,7 @@ static bool mips_relocate_got(soinfo* si, const soinfo::soinfo_list_t& local_gro // This is an undefined reference... try to locate it. const char* sym_name = si->get_string(sym->st_name); soinfo* lsi = nullptr; - ElfW(Sym)* s = soinfo_do_lookup(si, sym_name, &lsi, local_group); + ElfW(Sym)* s = soinfo_do_lookup(si, sym_name, &lsi); if (s == nullptr) { // We only allow an undefined symbol if this is a weak reference. s = &symtab[g]; @@ -2253,7 +2198,7 @@ bool soinfo::PrelinkImage() { return true; } -bool soinfo::LinkImage(const soinfo_list_t& local_group, const android_dlextinfo* extinfo) { +bool soinfo::LinkImage(const android_dlextinfo* extinfo) { #if !defined(__LP64__) if (has_text_relocations) { @@ -2272,26 +2217,26 @@ bool soinfo::LinkImage(const soinfo_list_t& local_group, const android_dlextinfo #if defined(USE_RELA) if (rela != nullptr) { DEBUG("[ relocating %s ]", name); - if (Relocate(rela, rela_count, local_group)) { + if (Relocate(rela, rela_count)) { return false; } } if (plt_rela != nullptr) { DEBUG("[ relocating %s plt ]", name); - if (Relocate(plt_rela, plt_rela_count, local_group)) { + if (Relocate(plt_rela, plt_rela_count)) { return false; } } #else if (rel != nullptr) { DEBUG("[ relocating %s ]", name); - if (Relocate(rel, rel_count, local_group)) { + if (Relocate(rel, rel_count)) { return false; } } if (plt_rel != nullptr) { DEBUG("[ relocating %s plt ]", name); - if (Relocate(plt_rel, plt_rel_count, local_group)) { + if (Relocate(plt_rel, plt_rel_count)) { return false; } } @@ -2365,7 +2310,7 @@ static void add_vdso(KernelArgumentBlock& args __unused) { si->load_bias = get_elf_exec_load_bias(ehdr_vdso); si->PrelinkImage(); - si->LinkImage(g_empty_list, nullptr); + si->LinkImage(nullptr); #endif } @@ -2511,11 +2456,21 @@ static ElfW(Addr) __linker_init_post_relocation(KernelArgumentBlock& args, ElfW( }); const char* needed_library_names[needed_libraries_count]; + soinfo* needed_library_si[needed_libraries_count]; memset(needed_library_names, 0, sizeof(needed_library_names)); needed_library_name_list.copy_to_array(needed_library_names, needed_libraries_count); - if (needed_libraries_count > 0 && !find_libraries(si, needed_library_names, needed_libraries_count, nullptr, g_ld_preloads, ld_preloads_count, RTLD_GLOBAL, nullptr)) { + if (needed_libraries_count > 0 && !find_libraries(needed_library_names, needed_libraries_count, needed_library_si, g_ld_preloads, ld_preloads_count, RTLD_GLOBAL, nullptr)) { + __libc_format_fd(2, "CANNOT LINK EXECUTABLE DEPENDENCIES: %s\n", linker_get_error_buffer()); + exit(EXIT_FAILURE); + } + + for (size_t i = 0; iadd_child(needed_library_si[i]); + } + + if (!si->LinkImage(nullptr)) { __libc_format_fd(2, "CANNOT LINK EXECUTABLE: %s\n", linker_get_error_buffer()); exit(EXIT_FAILURE); } @@ -2639,7 +2594,7 @@ extern "C" ElfW(Addr) __linker_init(void* raw_args) { linker_so.phnum = elf_hdr->e_phnum; linker_so.flags |= FLAG_LINKER; - if (!(linker_so.PrelinkImage() && linker_so.LinkImage(g_empty_list, nullptr))) { + if (!(linker_so.PrelinkImage() && linker_so.LinkImage(nullptr))) { // It would be nice to print an error message, but if the linker // can't link itself, there's no guarantee that we'll be able to // call write() (because it involves a GOT reference). We may as diff --git a/linker/linker.h b/linker/linker.h index 222aca11e..ebb4793af 100644 --- a/linker/linker.h +++ b/linker/linker.h @@ -207,7 +207,7 @@ struct soinfo { void CallDestructors(); void CallPreInitConstructors(); bool PrelinkImage(); - bool LinkImage(const soinfo_list_t& local_group, const android_dlextinfo* extinfo); + bool LinkImage(const android_dlextinfo* extinfo); void add_child(soinfo* child); void remove_all_links(); @@ -234,9 +234,9 @@ struct soinfo { void CallArray(const char* array_name, linker_function_t* functions, size_t count, bool reverse); void CallFunction(const char* function_name, linker_function_t function); #if defined(USE_RELA) - int Relocate(ElfW(Rela)* rela, unsigned count, const soinfo_list_t& local_group); + int Relocate(ElfW(Rela)* rela, unsigned count); #else - int Relocate(ElfW(Rel)* rel, unsigned count, const soinfo_list_t& local_group); + int Relocate(ElfW(Rel)* rel, unsigned count); #endif private: diff --git a/tests/dlfcn_test.cpp b/tests/dlfcn_test.cpp index e604f5abe..f1ec0f131 100644 --- a/tests/dlfcn_test.cpp +++ b/tests/dlfcn_test.cpp @@ -162,39 +162,39 @@ TEST(dlfcn, dlopen_check_relocation_dt_needed_order) { ASSERT_EQ(1, fn()); } -TEST(dlfcn, dlopen_check_order_dlsym) { +TEST(dlfcn, dlopen_check_order) { // Here is how the test library and its dt_needed // libraries are arranged // - // libtest_check_order_children.so + // libtest_check_order.so // | - // +-> ..._1_left.so + // +-> libtest_check_order_1_left.so // | | - // | +-> ..._a.so + // | +-> libtest_check_order_a.so // | | - // | +-> ...r_b.so + // | +-> libtest_check_order_b.so // | - // +-> ..._2_right.so + // +-> libtest_check_order_2_right.so // | | - // | +-> ..._d.so + // | +-> libtest_check_order_d.so // | | - // | +-> ..._b.so + // | +-> libtest_check_order_b.so // | - // +-> ..._3_c.so + // +-> libtest_check_order_3_c.so // // load order should be (1, 2, 3, a, b, d) // // get_answer() is defined in (2, 3, a, b, c) // get_answer2() is defined in (b, d) - void* sym = dlsym(RTLD_DEFAULT, "check_order_dlsym_get_answer"); + void* sym = dlsym(RTLD_DEFAULT, "dlopen_test_get_answer"); ASSERT_TRUE(sym == nullptr); - void* handle = dlopen("libtest_check_order_dlsym.so", RTLD_NOW | RTLD_GLOBAL); - ASSERT_TRUE(handle != nullptr) << dlerror(); + void* handle = dlopen("libtest_check_order.so", RTLD_NOW | RTLD_GLOBAL); + ASSERT_TRUE(handle != nullptr); typedef int (*fn_t) (void); fn_t fn, fn2; - fn = reinterpret_cast(dlsym(RTLD_DEFAULT, "check_order_dlsym_get_answer")); + fn = reinterpret_cast(dlsym(RTLD_DEFAULT, "dlopen_test_get_answer")); ASSERT_TRUE(fn != NULL) << dlerror(); - fn2 = reinterpret_cast(dlsym(RTLD_DEFAULT, "check_order_dlsym_get_answer2")); + fn2 = reinterpret_cast(dlsym(RTLD_DEFAULT, "dlopen_test_get_answer2")); ASSERT_TRUE(fn2 != NULL) << dlerror(); ASSERT_EQ(42, fn()); @@ -202,163 +202,6 @@ TEST(dlfcn, dlopen_check_order_dlsym) { dlclose(handle); } -TEST(dlfcn, dlopen_check_order_reloc_siblings) { - // This is how this one works: - // we lookup and call get_answer which is defined in '_2.so' - // and in turn calls external get_answer_impl() defined in _1.so and in '_[a-f].so' - // the correct _impl() is implemented by '_a.so'; - // - // Note that this is test for RTLD_LOCAL (TODO: test for GLOBAL?) - // - // Here is the picture: - // - // libtest_check_order_reloc_siblings.so - // | - // +-> ..._1.so <- empty - // | | - // | +-> ..._a.so <- exports correct answer_impl() - // | | - // | +-> ..._b.so <- every other letter exporting incorrect one. - // | - // +-> ..._2.so <- empty - // | | - // | +-> ..._c.so - // | | - // | +-> ..._d.so - // | - // +-> ..._3.so <- empty - // | - // +-> ..._e.so - // | - // +-> ..._f.so <- exports get_answer() that calls get_anser_impl(); - // implements incorrect get_answer_impl() - - void* handle = dlopen("libtest_check_order_reloc_siblings.so", RTLD_NOW | RTLD_NOLOAD); - ASSERT_TRUE(handle == nullptr); -#ifdef __BIONIC__ - // TODO: glibc returns nullptr on dlerror() here. Is it bug? - ASSERT_STREQ("dlopen failed: library \"libtest_check_order_reloc_siblings.so\" wasn't loaded and RTLD_NOLOAD prevented it", dlerror()); -#endif - - handle = dlopen("libtest_check_order_reloc_siblings.so", RTLD_NOW | RTLD_LOCAL); - ASSERT_TRUE(handle != nullptr) << dlerror(); - - typedef int (*fn_t) (void); - fn_t fn = reinterpret_cast(dlsym(handle, "check_order_reloc_get_answer")); - ASSERT_TRUE(fn != nullptr) << dlerror(); - ASSERT_EQ(42, fn()); - - ASSERT_EQ(0, dlclose(handle)); -} - -TEST(dlfcn, dlopen_check_order_reloc_siblings_with_preload) { - // This test uses the same library as dlopen_check_order_reloc_siblings. - // Unlike dlopen_check_order_reloc_siblings it preloads - // libtest_check_order_reloc_siblings_1.so (first dependency) prior to - // dlopen(libtest_check_order_reloc_siblings.so) - - void* handle = dlopen("libtest_check_order_reloc_siblings.so", RTLD_NOW | RTLD_NOLOAD); - ASSERT_TRUE(handle == nullptr); - handle = dlopen("libtest_check_order_reloc_siblings_1.so", RTLD_NOW | RTLD_NOLOAD); - ASSERT_TRUE(handle == nullptr); - - void* handle_for_1 = dlopen("libtest_check_order_reloc_siblings_1.so", RTLD_NOW | RTLD_LOCAL); - ASSERT_TRUE(handle_for_1 != nullptr) << dlerror(); - - handle = dlopen("libtest_check_order_reloc_siblings.so", RTLD_NOW | RTLD_LOCAL); - ASSERT_TRUE(handle != nullptr) << dlerror(); - - ASSERT_EQ(0, dlclose(handle_for_1)); - - typedef int (*fn_t) (void); - fn_t fn = reinterpret_cast(dlsym(handle, "check_order_reloc_get_answer")); - ASSERT_TRUE(fn != nullptr) << dlerror(); - ASSERT_EQ(42, fn()); - - ASSERT_EQ(0, dlclose(handle)); -} - -TEST(dlfcn, dlopen_check_order_reloc_nephew) { - // This is how this one works: - // we lookup and call nephew_get_answer which is defined in '_2.so' - // and in turn calls external get_answer_impl() defined in '_[a-f].so' - // the correct _impl() is implemented by '_a.so'; - // - // Here is the picture: - // - // libtest_check_order_reloc_siblings.so - // | - // +-> ..._1.so <- empty - // | | - // | +-> ..._a.so <- exports correct answer_impl() - // | | - // | +-> ..._b.so <- every other letter exporting incorrect one. - // | - // +-> ..._2.so <- empty - // | | - // | +-> ..._c.so - // | | - // | +-> ..._d.so - // | - // +-> ..._3.so <- nephew_get_answer() that calls get_answer_impl(); - // | - // +-> ..._e.so - // | - // +-> ..._f.so - - void* handle = dlopen("libtest_check_order_reloc_siblings.so", RTLD_NOW | RTLD_NOLOAD); - ASSERT_TRUE(handle == nullptr); -#ifdef __BIONIC__ - // TODO: glibc returns nullptr on dlerror() here. Is it bug? - ASSERT_STREQ("dlopen failed: library \"libtest_check_order_reloc_siblings.so\" wasn't loaded and RTLD_NOLOAD prevented it", dlerror()); -#endif - - handle = dlopen("libtest_check_order_reloc_siblings.so", RTLD_NOW | RTLD_LOCAL); - ASSERT_TRUE(handle != nullptr) << dlerror(); - - typedef int (*fn_t) (void); - fn_t fn = reinterpret_cast(dlsym(handle, "check_order_reloc_nephew_get_answer")); - ASSERT_TRUE(fn != nullptr) << dlerror(); - ASSERT_EQ(42, fn()); - - ASSERT_EQ(0, dlclose(handle)); -} - -extern "C" int check_order_reloc_root_get_answer_impl() { - return 42; -} - -TEST(dlfcn, dlopen_check_order_reloc_main_executable) { - // This is how this one works: - // we lookup and call get_answer3 which is defined in 'root.so' - // and in turn calls external root_get_answer_impl() defined in _2.so and - // above the correct _impl() is one in the executable. - // - // libtest_check_order_reloc_root.so - // | - // +-> ..._1.so <- empty - // | - // +-> ..._2.so <- gives incorrect answer for answer_main_impl() - // - - void* handle = dlopen("libtest_check_order_reloc_root.so", RTLD_NOW | RTLD_NOLOAD); - ASSERT_TRUE(handle == nullptr); -#ifdef __BIONIC__ - // TODO: glibc returns nullptr on dlerror() here. Is it bug? - ASSERT_STREQ("dlopen failed: library \"libtest_check_order_reloc_root.so\" wasn't loaded and RTLD_NOLOAD prevented it", dlerror()); -#endif - - handle = dlopen("libtest_check_order_reloc_root.so", RTLD_NOW | RTLD_LOCAL); - ASSERT_TRUE(handle != nullptr) << dlerror(); - - typedef int (*fn_t) (void); - fn_t fn = reinterpret_cast(dlsym(handle, "check_order_reloc_root_get_answer")); - ASSERT_TRUE(fn != nullptr) << dlerror(); - ASSERT_EQ(42, fn()); - - ASSERT_EQ(0, dlclose(handle)); -} - TEST(dlfcn, dlopen_check_rtld_local) { void* sym = dlsym(RTLD_DEFAULT, "dlopen_testlib_simple_func"); ASSERT_TRUE(sym == nullptr); @@ -499,6 +342,7 @@ TEST(dlfcn, dlopen_nodelete_dt_flags_1) { ASSERT_TRUE(!is_unloaded); } + TEST(dlfcn, dlopen_failure) { void* self = dlopen("/does/not/exist", RTLD_NOW); ASSERT_TRUE(self == NULL); diff --git a/tests/libs/Android.build.dlopen_check_order_dlsym.mk b/tests/libs/Android.build.dlopen_check_order_dlsym.mk deleted file mode 100644 index 73d8c1a83..000000000 --- a/tests/libs/Android.build.dlopen_check_order_dlsym.mk +++ /dev/null @@ -1,90 +0,0 @@ -# -# Copyright (C) 2012 The Android Open Source Project -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# - -# ----------------------------------------------------------------------------- -# Libraries used by dlfcn tests to verify correct load order: -# libtest_check_order_2_right.so -# ----------------------------------------------------------------------------- -libtest_check_order_dlsym_2_right_src_files := \ - dlopen_check_order_dlsym_answer.cpp - -libtest_check_order_dlsym_2_right_cflags := -D__ANSWER=42 -module := libtest_check_order_dlsym_2_right -include $(LOCAL_PATH)/Android.build.testlib.mk - -# ----------------------------------------------------------------------------- -# libtest_check_order_a.so -# ----------------------------------------------------------------------------- -libtest_check_order_dlsym_a_src_files := \ - dlopen_check_order_dlsym_answer.cpp - -libtest_check_order_dlsym_a_cflags := -D__ANSWER=1 -module := libtest_check_order_dlsym_a -include $(LOCAL_PATH)/Android.build.testlib.mk - -# ----------------------------------------------------------------------------- -# libtest_check_order_b.so -# ----------------------------------------------------------------------------- -libtest_check_order_dlsym_b_src_files := \ - dlopen_check_order_dlsym_answer.cpp - -libtest_check_order_dlsym_b_cflags := -D__ANSWER=2 -D__ANSWER2=43 -module := libtest_check_order_dlsym_b -include $(LOCAL_PATH)/Android.build.testlib.mk - -# ----------------------------------------------------------------------------- -# libtest_check_order_c.so -# ----------------------------------------------------------------------------- -libtest_check_order_dlsym_3_c_src_files := \ - dlopen_check_order_dlsym_answer.cpp - -libtest_check_order_dlsym_3_c_cflags := -D__ANSWER=3 -module := libtest_check_order_dlsym_3_c -include $(LOCAL_PATH)/Android.build.testlib.mk - -# ----------------------------------------------------------------------------- -# libtest_check_order_d.so -# ----------------------------------------------------------------------------- -libtest_check_order_dlsym_d_src_files := \ - dlopen_check_order_dlsym_answer.cpp - -libtest_check_order_dlsym_d_shared_libraries := libtest_check_order_dlsym_b -libtest_check_order_dlsym_d_cflags := -D__ANSWER=4 -D__ANSWER2=4 -module := libtest_check_order_dlsym_d -include $(LOCAL_PATH)/Android.build.testlib.mk - -# ----------------------------------------------------------------------------- -# libtest_check_order_left.so -# ----------------------------------------------------------------------------- -libtest_check_order_dlsym_1_left_src_files := \ - empty.cpp - -libtest_check_order_dlsym_1_left_shared_libraries := libtest_check_order_dlsym_a libtest_check_order_dlsym_b - -module := libtest_check_order_dlsym_1_left -include $(LOCAL_PATH)/Android.build.testlib.mk - -# ----------------------------------------------------------------------------- -# libtest_check_order.so -# ----------------------------------------------------------------------------- -libtest_check_order_dlsym_src_files := \ - empty.cpp - -libtest_check_order_dlsym_shared_libraries := libtest_check_order_dlsym_1_left \ - libtest_check_order_dlsym_2_right libtest_check_order_dlsym_3_c - -module := libtest_check_order_dlsym -include $(LOCAL_PATH)/Android.build.testlib.mk diff --git a/tests/libs/Android.build.dlopen_check_order_reloc_main_executable.mk b/tests/libs/Android.build.dlopen_check_order_reloc_main_executable.mk deleted file mode 100644 index 639696b25..000000000 --- a/tests/libs/Android.build.dlopen_check_order_reloc_main_executable.mk +++ /dev/null @@ -1,56 +0,0 @@ -# -# Copyright (C) 2012 The Android Open Source Project -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# - -# ----------------------------------------------------------------------------- -# Libraries used by dlfcn tests to verify correct relocation order: -# libtest_check_order_reloc_root*.so -# ----------------------------------------------------------------------------- - - -# ----------------------------------------------------------------------------- -# ..._1.so - empty -# ----------------------------------------------------------------------------- -libtest_check_order_reloc_root_1_src_files := \ - empty.cpp - - -module := libtest_check_order_reloc_root_1 -include $(LOCAL_PATH)/Android.build.testlib.mk - - -# ----------------------------------------------------------------------------- -# ..._2.so - this one has the incorrect answer -# ----------------------------------------------------------------------------- -libtest_check_order_reloc_root_2_src_files := \ - dlopen_check_order_reloc_root_answer_impl.cpp - -libtest_check_order_reloc_root_2_cflags := -D__ANSWER=2 - -module := libtest_check_order_reloc_root_2 -include $(LOCAL_PATH)/Android.build.testlib.mk - -# ----------------------------------------------------------------------------- -# libtest_check_order_reloc_root.so <- implements get_answer3() -# ----------------------------------------------------------------------------- -libtest_check_order_reloc_root_src_files := \ - dlopen_check_order_reloc_root_answer.cpp - -libtest_check_order_reloc_root_shared_libraries := \ - libtest_check_order_reloc_root_1 \ - libtest_check_order_reloc_root_2 - -module := libtest_check_order_reloc_root -include $(LOCAL_PATH)/Android.build.testlib.mk diff --git a/tests/libs/Android.build.dlopen_check_order_reloc_siblings.mk b/tests/libs/Android.build.dlopen_check_order_reloc_siblings.mk deleted file mode 100644 index 0f1a2b4da..000000000 --- a/tests/libs/Android.build.dlopen_check_order_reloc_siblings.mk +++ /dev/null @@ -1,133 +0,0 @@ -# -# Copyright (C) 2014 The Android Open Source Project -# -# Licensed under the Apache License, Version 2.0 (the "License"); -# you may not use this file except in compliance with the License. -# You may obtain a copy of the License at -# -# http://www.apache.org/licenses/LICENSE-2.0 -# -# Unless required by applicable law or agreed to in writing, software -# distributed under the License is distributed on an "AS IS" BASIS, -# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. -# See the License for the specific language governing permissions and -# limitations under the License. -# - -# ----------------------------------------------------------------------------- -# Libraries used by dlfcn tests to verify correct relocation order: -# libtest_check_order_reloc_siblings*.so -# ----------------------------------------------------------------------------- - -# ----------------------------------------------------------------------------- -# ..._1.so - empty -# ----------------------------------------------------------------------------- -libtest_check_order_reloc_siblings_1_src_files := \ - empty.cpp - -libtest_check_order_reloc_siblings_1_shared_libraries := \ - libtest_check_order_reloc_siblings_a \ - libtest_check_order_reloc_siblings_b - -module := libtest_check_order_reloc_siblings_1 -include $(LOCAL_PATH)/Android.build.testlib.mk - - -# ----------------------------------------------------------------------------- -# ..._2.so - empty -# ----------------------------------------------------------------------------- -libtest_check_order_reloc_siblings_2_src_files := \ - empty.cpp - -libtest_check_order_reloc_siblings_2_shared_libraries := \ - libtest_check_order_reloc_siblings_c \ - libtest_check_order_reloc_siblings_d - -module := libtest_check_order_reloc_siblings_2 -include $(LOCAL_PATH)/Android.build.testlib.mk - -# ----------------------------------------------------------------------------- -# ..._3.so - get_answer2(); -# ----------------------------------------------------------------------------- -libtest_check_order_reloc_siblings_3_src_files := \ - dlopen_check_order_reloc_nephew_answer.cpp - -libtest_check_order_reloc_siblings_3_shared_libraries := \ - libtest_check_order_reloc_siblings_e \ - libtest_check_order_reloc_siblings_f - -module := libtest_check_order_reloc_siblings_3 -include $(LOCAL_PATH)/Android.build.testlib.mk - -# ----------------------------------------------------------------------------- -# ..._a.so <- correct impl -# ----------------------------------------------------------------------------- -libtest_check_order_reloc_siblings_a_src_files := \ - dlopen_check_order_reloc_answer_impl.cpp - -libtest_check_order_reloc_siblings_a_cflags := -D__ANSWER=42 -module := libtest_check_order_reloc_siblings_a -include $(LOCAL_PATH)/Android.build.testlib.mk - -# ----------------------------------------------------------------------------- -# ..._b.so -# ----------------------------------------------------------------------------- -libtest_check_order_reloc_siblings_b_src_files := \ - dlopen_check_order_reloc_answer_impl.cpp - -libtest_check_order_reloc_siblings_b_cflags := -D__ANSWER=1 -module := libtest_check_order_reloc_siblings_b -include $(LOCAL_PATH)/Android.build.testlib.mk - -# ----------------------------------------------------------------------------- -# ..._c.so -# ----------------------------------------------------------------------------- -libtest_check_order_reloc_siblings_c_src_files := \ - dlopen_check_order_reloc_answer_impl.cpp - -libtest_check_order_reloc_siblings_c_cflags := -D__ANSWER=2 -module := libtest_check_order_reloc_siblings_c -include $(LOCAL_PATH)/Android.build.testlib.mk - -# ----------------------------------------------------------------------------- -# ..._d.so -# ----------------------------------------------------------------------------- -libtest_check_order_reloc_siblings_d_src_files := \ - dlopen_check_order_reloc_answer_impl.cpp - -libtest_check_order_reloc_siblings_d_cflags := -D__ANSWER=3 -module := libtest_check_order_reloc_siblings_d -include $(LOCAL_PATH)/Android.build.testlib.mk - -# ----------------------------------------------------------------------------- -# ..._e.so -# ----------------------------------------------------------------------------- -libtest_check_order_reloc_siblings_e_src_files := \ - dlopen_check_order_reloc_answer_impl.cpp - -libtest_check_order_reloc_siblings_e_cflags := -D__ANSWER=4 -module := libtest_check_order_reloc_siblings_e -include $(LOCAL_PATH)/Android.build.testlib.mk - -# ----------------------------------------------------------------------------- -# ..._f.so <- get_answer() -# ----------------------------------------------------------------------------- -libtest_check_order_reloc_siblings_f_src_files := \ - dlopen_check_order_reloc_answer.cpp - -module := libtest_check_order_reloc_siblings_f -include $(LOCAL_PATH)/Android.build.testlib.mk - -# ----------------------------------------------------------------------------- -# libtest_check_order_reloc_siblings.so -# ----------------------------------------------------------------------------- -libtest_check_order_reloc_siblings_src_files := \ - empty.cpp - -libtest_check_order_reloc_siblings_shared_libraries := \ - libtest_check_order_reloc_siblings_1 \ - libtest_check_order_reloc_siblings_2 \ - libtest_check_order_reloc_siblings_3 - -module := libtest_check_order_reloc_siblings -include $(LOCAL_PATH)/Android.build.testlib.mk diff --git a/tests/libs/Android.mk b/tests/libs/Android.mk index 05e7113ba..175a63539 100644 --- a/tests/libs/Android.mk +++ b/tests/libs/Android.mk @@ -21,9 +21,6 @@ common_cppflags += -std=gnu++11 common_additional_dependencies := \ $(LOCAL_PATH)/Android.mk \ $(LOCAL_PATH)/Android.build.dlext_testzip.mk \ - $(LOCAL_PATH)/Android.build.dlopen_check_order_dlsym.mk \ - $(LOCAL_PATH)/Android.build.dlopen_check_order_reloc_siblings.mk \ - $(LOCAL_PATH)/Android.build.dlopen_check_order_reloc_main_executable.mk \ $(LOCAL_PATH)/Android.build.testlib.mk \ $(TEST_PATH)/Android.build.mk @@ -153,19 +150,79 @@ module := libtest_nodelete_dt_flags_1 include $(LOCAL_PATH)/Android.build.testlib.mk # ----------------------------------------------------------------------------- -# Build libtest_check_order_dlsym.so with its dependencies. +# Libraries used by dlfcn tests to verify correct load order: +# libtest_check_order_2_right.so # ----------------------------------------------------------------------------- -include $(LOCAL_PATH)/Android.build.dlopen_check_order_dlsym.mk +libtest_check_order_2_right_src_files := \ + dlopen_testlib_answer.cpp + +libtest_check_order_2_right_cflags := -D__ANSWER=42 +module := libtest_check_order_2_right +include $(LOCAL_PATH)/Android.build.testlib.mk # ----------------------------------------------------------------------------- -# Build libtest_check_order_siblings.so with its dependencies. +# libtest_check_order_a.so # ----------------------------------------------------------------------------- -include $(LOCAL_PATH)/Android.build.dlopen_check_order_reloc_siblings.mk +libtest_check_order_a_src_files := \ + dlopen_testlib_answer.cpp + +libtest_check_order_a_cflags := -D__ANSWER=1 +module := libtest_check_order_a +include $(LOCAL_PATH)/Android.build.testlib.mk # ----------------------------------------------------------------------------- -# Build libtest_check_order_root.so with its dependencies. +# libtest_check_order_b.so # ----------------------------------------------------------------------------- -include $(LOCAL_PATH)/Android.build.dlopen_check_order_reloc_main_executable.mk +libtest_check_order_b_src_files := \ + dlopen_testlib_answer.cpp + +libtest_check_order_b_cflags := -D__ANSWER=2 -D__ANSWER2=43 +module := libtest_check_order_b +include $(LOCAL_PATH)/Android.build.testlib.mk + +# ----------------------------------------------------------------------------- +# libtest_check_order_c.so +# ----------------------------------------------------------------------------- +libtest_check_order_3_c_src_files := \ + dlopen_testlib_answer.cpp + +libtest_check_order_3_c_cflags := -D__ANSWER=3 +module := libtest_check_order_3_c +include $(LOCAL_PATH)/Android.build.testlib.mk + +# ----------------------------------------------------------------------------- +# libtest_check_order_d.so +# ----------------------------------------------------------------------------- +libtest_check_order_d_src_files := \ + dlopen_testlib_answer.cpp + +libtest_check_order_d_shared_libraries := libtest_check_order_b +libtest_check_order_d_cflags := -D__ANSWER=4 -D__ANSWER2=4 +module := libtest_check_order_d +include $(LOCAL_PATH)/Android.build.testlib.mk + +# ----------------------------------------------------------------------------- +# libtest_check_order_left.so +# ----------------------------------------------------------------------------- +libtest_check_order_1_left_src_files := \ + empty.cpp + +libtest_check_order_1_left_shared_libraries := libtest_check_order_a libtest_check_order_b + +module := libtest_check_order_1_left +include $(LOCAL_PATH)/Android.build.testlib.mk + +# ----------------------------------------------------------------------------- +# libtest_check_order.so +# ----------------------------------------------------------------------------- +libtest_check_order_src_files := \ + empty.cpp + +libtest_check_order_shared_libraries := libtest_check_order_1_left \ + libtest_check_order_2_right libtest_check_order_3_c + +module := libtest_check_order +include $(LOCAL_PATH)/Android.build.testlib.mk # ----------------------------------------------------------------------------- # Library with dependency loop used by dlfcn tests diff --git a/tests/libs/dlopen_check_order_reloc_answer.cpp b/tests/libs/dlopen_check_order_reloc_answer.cpp deleted file mode 100644 index 036670bee..000000000 --- a/tests/libs/dlopen_check_order_reloc_answer.cpp +++ /dev/null @@ -1,23 +0,0 @@ -/* - * Copyright (C) 2014 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -extern "C" int __attribute__((weak)) check_order_reloc_get_answer_impl() { - return 0; -} - -extern "C" int check_order_reloc_get_answer() { - return check_order_reloc_get_answer_impl(); -} diff --git a/tests/libs/dlopen_check_order_reloc_answer_impl.cpp b/tests/libs/dlopen_check_order_reloc_answer_impl.cpp deleted file mode 100644 index 324b905da..000000000 --- a/tests/libs/dlopen_check_order_reloc_answer_impl.cpp +++ /dev/null @@ -1,19 +0,0 @@ -/* - * Copyright (C) 2014 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -extern "C" int check_order_reloc_get_answer_impl() { - return __ANSWER; -} diff --git a/tests/libs/dlopen_check_order_reloc_nephew_answer.cpp b/tests/libs/dlopen_check_order_reloc_nephew_answer.cpp deleted file mode 100644 index 065d1bef7..000000000 --- a/tests/libs/dlopen_check_order_reloc_nephew_answer.cpp +++ /dev/null @@ -1,21 +0,0 @@ -/* - * Copyright (C) 2014 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -extern "C" int check_order_reloc_get_answer_impl(); - -extern "C" int check_order_reloc_nephew_get_answer() { - return check_order_reloc_get_answer_impl(); -} diff --git a/tests/libs/dlopen_check_order_reloc_root_answer.cpp b/tests/libs/dlopen_check_order_reloc_root_answer.cpp deleted file mode 100644 index b21abd77a..000000000 --- a/tests/libs/dlopen_check_order_reloc_root_answer.cpp +++ /dev/null @@ -1,21 +0,0 @@ -/* - * Copyright (C) 2014 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -extern "C" int check_order_reloc_root_get_answer_impl(); - -extern "C" int check_order_reloc_root_get_answer() { - return check_order_reloc_root_get_answer_impl(); -} diff --git a/tests/libs/dlopen_check_order_reloc_root_answer_impl.cpp b/tests/libs/dlopen_check_order_reloc_root_answer_impl.cpp deleted file mode 100644 index 25fb9aca9..000000000 --- a/tests/libs/dlopen_check_order_reloc_root_answer_impl.cpp +++ /dev/null @@ -1,19 +0,0 @@ -/* - * Copyright (C) 2014 The Android Open Source Project - * - * Licensed under the Apache License, Version 2.0 (the "License"); - * you may not use this file except in compliance with the License. - * You may obtain a copy of the License at - * - * http://www.apache.org/licenses/LICENSE-2.0 - * - * Unless required by applicable law or agreed to in writing, software - * distributed under the License is distributed on an "AS IS" BASIS, - * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. - * See the License for the specific language governing permissions and - * limitations under the License. - */ - -extern "C" int check_order_reloc_root_get_answer_impl() { - return __ANSWER; -} diff --git a/tests/libs/dlopen_check_order_dlsym_answer.cpp b/tests/libs/dlopen_testlib_answer.cpp similarity index 87% rename from tests/libs/dlopen_check_order_dlsym_answer.cpp rename to tests/libs/dlopen_testlib_answer.cpp index 2ae6cf79e..a4d75046e 100644 --- a/tests/libs/dlopen_check_order_dlsym_answer.cpp +++ b/tests/libs/dlopen_testlib_answer.cpp @@ -14,12 +14,12 @@ * limitations under the License. */ -extern "C" int check_order_dlsym_get_answer() { +extern "C" int dlopen_test_get_answer() { return __ANSWER; } #ifdef __ANSWER2 -extern "C" int check_order_dlsym_get_answer2() { +extern "C" int dlopen_test_get_answer2() { return __ANSWER2; } #endif