//===-- ReExportedSymbolTest.cpp ------------------------------------------===//
//
// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
// See https://llvm.org/LICENSE.txt for license information.
// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
//
//===----------------------------------------------------------------------===//

#include "Plugins/ObjectFile/ELF/ObjectFileELF.h"
#include "Plugins/Platform/Linux/PlatformLinux.h"
#include "Plugins/SymbolFile/Symtab/SymbolFileSymtab.h"
#include "TestingSupport/SubsystemRAII.h"
#include "TestingSupport/TestUtilities.h"
#include "lldb/Core/Debugger.h"
#include "lldb/Core/Module.h"
#include "lldb/Core/ModuleSpec.h"
#include "lldb/Host/FileSystem.h"
#include "lldb/Host/HostInfo.h"
#include "lldb/Symbol/ObjectFile.h"
#include "lldb/Symbol/Symbol.h"
#include "lldb/Symbol/Symtab.h"
#include "lldb/Target/Platform.h"
#include "lldb/Target/Target.h"
#include "lldb/Utility/ArchSpec.h"
#include "llvm/Testing/Support/Error.h"
#include "gtest/gtest.h"

using namespace lldb_private;
using namespace lldb;

namespace {
class ReExportedSymbolTest : public testing::Test {
  SubsystemRAII<FileSystem, HostInfo, ObjectFileELF, SymbolFileSymtab,
                platform_linux::PlatformLinux>
      subsystems;
};
} // namespace

// An ELF filter library naming two auxiliary filtees.  Its zero-sized
// exported functions "foo", "bar" and "open@@FBSD_1.0" are placeholders the
// dynamic linker resolves through the filtees.  ObjectFileELF leaves them as
// plain code symbols (re-export marking would clobber their address ranges);
// Symbol::ResolveReExportedSymbol shadows them at resolution time.  "bar" is
// defined by the first filtee, "foo" only by the second, so resolving "foo"
// exercises the ordered search across filtees.  "open@@FBSD_1.0" exercises
// version-suffix stripping, and the local "hidden_helper" must not be
// shadowed even though the first filtee exports that name.
//
// .dynstr content: "\0libaux1.so\0libaux2.so\0"
//   offset 0x1: "libaux1.so"
//   offset 0xC: "libaux2.so"
static const char *k_filter_yaml = R"(
--- !ELF
FileHeader:
  Class:           ELFCLASS64
  Data:            ELFDATA2LSB
  Type:            ET_DYN
  Machine:         EM_X86_64
Sections:
  - Name:            .text
    Type:            SHT_PROGBITS
    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
    Address:         0x1000
    AddressAlign:    0x10
    Content:         C3C3C3C3C3C3C3C3
  - Name:            .dynstr
    Type:            SHT_STRTAB
    Flags:           [ SHF_ALLOC ]
    Address:         0x2000
    AddressAlign:    0x1
    Content:         "006C6962617578312E736F006C6962617578322E736F00"
  - Name:            .dynamic
    Type:            SHT_DYNAMIC
    Flags:           [ SHF_ALLOC ]
    Address:         0x3000
    AddressAlign:    0x8
    Link:            .dynstr
    Entries:
      - Tag:             DT_AUXILIARY
        Value:           0x1
      - Tag:             DT_AUXILIARY
        Value:           0xC
      - Tag:             DT_NULL
        Value:           0x0
Symbols:
  - Name:            hidden_helper
    Type:            STT_FUNC
    Section:         .text
    Value:           0x1003
    Binding:         STB_LOCAL
  - Name:            foo
    Type:            STT_FUNC
    Section:         .text
    Value:           0x1000
    Binding:         STB_GLOBAL
  - Name:            bar
    Type:            STT_FUNC
    Section:         .text
    Value:           0x1001
    Binding:         STB_GLOBAL
  - Name:            "open@@FBSD_1.0"
    Type:            STT_FUNC
    Section:         .text
    Value:           0x1001
    Binding:         STB_WEAK
  # A real (nonzero-sized) function the filter defines itself.  Besides being
  # realistic -- a filter library like libc.so.7 is full of real functions --
  # it gives the object file a code symbol so that SymbolFileSymtab claims the
  # module (a module whose only symbols are re-export placeholders has no
  # abilities and would get no symbol table).
  - Name:            filter_local
    Type:            STT_FUNC
    Section:         .text
    Value:           0x1002
    Size:            0x2
    Binding:         STB_GLOBAL
  # A genuine (nonzero-sized) implementation that the first filtee *also*
  # defines.  The dynamic linker always searches the filtees before the
  # filter object's own definition, so the filtee must win even though the
  # filter's definition is real code and not a placeholder.
  - Name:            dup_impl
    Type:            STT_FUNC
    Section:         .text
    Value:           0x1004
    Size:            0x2
    Binding:         STB_GLOBAL
  # A placeholder whose name *both* filtees define.  The search stops at the
  # first filtee that provides it, so the second filtee's definition is never
  # reached.
  - Name:            in_both_filtees
    Type:            STT_FUNC
    Section:         .text
    Value:           0x1005
    Binding:         STB_GLOBAL
...
)";

static const char *k_aux1_yaml = R"(
--- !ELF
FileHeader:
  Class:           ELFCLASS64
  Data:            ELFDATA2LSB
  Type:            ET_DYN
  Machine:         EM_X86_64
Sections:
  - Name:            .text
    Type:            SHT_PROGBITS
    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
    Address:         0x1000
    AddressAlign:    0x10
    Content:         C3C3C3C3C3C3C3C3
Symbols:
  - Name:            bar
    Type:            STT_FUNC
    Section:         .text
    Value:           0x1000
    Size:            0x2
    Binding:         STB_GLOBAL
  - Name:            hidden_helper
    Type:            STT_FUNC
    Section:         .text
    Value:           0x1002
    Size:            0x2
    Binding:         STB_GLOBAL
  - Name:            dup_impl
    Type:            STT_FUNC
    Section:         .text
    Value:           0x1004
    Size:            0x2
    Binding:         STB_GLOBAL
  - Name:            in_both_filtees
    Type:            STT_FUNC
    Section:         .text
    Value:           0x1006
    Size:            0x2
    Binding:         STB_GLOBAL
...
)";

// The second filtee's definitions are weak: that is how FreeBSD's
// libsys.so.7 exports its syscall stubs, and weak definitions take part in
// dynamic linking just like global ones.
static const char *k_aux2_yaml = R"(
--- !ELF
FileHeader:
  Class:           ELFCLASS64
  Data:            ELFDATA2LSB
  Type:            ET_DYN
  Machine:         EM_X86_64
Sections:
  - Name:            .text
    Type:            SHT_PROGBITS
    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
    Address:         0x1000
    AddressAlign:    0x10
    Content:         C3C3C3C3C3C3
Symbols:
  - Name:            foo
    Type:            STT_FUNC
    Section:         .text
    Value:           0x1000
    Size:            0x2
    Binding:         STB_WEAK
  - Name:            open
    Type:            STT_FUNC
    Section:         .text
    Value:           0x1002
    Size:            0x2
    Binding:         STB_WEAK
  - Name:            in_both_filtees
    Type:            STT_FUNC
    Section:         .text
    Value:           0x1004
    Size:            0x2
    Binding:         STB_WEAK
...
)";

// Creates a module from \p file's in-memory buffer, gives it the name the
// filter's dynamic section refers to, and appends it to the target's image
// list.
static ModuleSP AddModule(Target &target, TestFile &file, const char *name) {
  ModuleSP module_sp = std::make_shared<Module>(file.moduleSpec());

  // The module is built from a buffer with no backing file.  Parse everything
  // that depends on that buffer *now*, while the module still has no file:
  //  - GetReExportedLibraries() parses and caches the dynamic section, which
  //    re-export resolution reads later.
  //  - GetSymtab() parses and caches the symbol table (and its symbol file).
  // Renaming afterwards would otherwise make these look for the symbols in the
  // now-nonexistent file.  The name is required so re-export resolution can
  // find the module in the target by the file spec recorded in the filter.
  if (ObjectFile *of = module_sp->GetObjectFile())
    of->GetReExportedLibraries();
  module_sp->GetSymtab();
  module_sp->SetFileSpecAndObjectName(FileSpec(name), ConstString());

  // Append without notifying: the module-added notification pulls in symbol
  // preloading and scripting-resource loading, which need a fully initialized
  // Debugger.  This test only needs the module to be findable in the target's
  // image list.
  target.GetImages().Append(module_sp, /*notify=*/false);
  return module_sp;
}

// Find the symbol whose name is \p name, ignoring any @VERSION suffix, in
// \p module_sp by iterating the symbol table.  Iterating keeps the lookup
// independent of how the symtab name indexes treat versioned names, which is
// orthogonal to what is tested here.
static const Symbol *FindFilterSymbol(const ModuleSP &module_sp,
                                      llvm::StringRef name) {
  Symtab *symtab = module_sp->GetSymtab();
  if (!symtab)
    return nullptr;
  for (size_t i = 0, e = symtab->GetNumSymbols(); i != e; ++i) {
    const Symbol *symbol = symtab->SymbolAtIndex(i);
    llvm::StringRef symbol_name = symbol->GetName().GetStringRef();
    if (symbol_name.substr(0, symbol_name.find('@')) == name)
      return symbol;
  }
  return nullptr;
}

TEST_F(ReExportedSymbolTest, ResolveThroughFilteesInOrder) {
  // Note: the TestFiles are declared before the target so that their
  // in-memory buffers outlive the modules the target holds.
  auto filter_file = TestFile::fromYaml(k_filter_yaml);
  ASSERT_THAT_EXPECTED(filter_file, llvm::Succeeded());
  auto aux1_file = TestFile::fromYaml(k_aux1_yaml);
  ASSERT_THAT_EXPECTED(aux1_file, llvm::Succeeded());
  auto aux2_file = TestFile::fromYaml(k_aux2_yaml);
  ASSERT_THAT_EXPECTED(aux2_file, llvm::Succeeded());

  ArchSpec arch("x86_64-pc-linux");
  Platform::SetHostPlatform(
      platform_linux::PlatformLinux::CreateInstance(true, &arch));
  DebuggerSP debugger_sp = Debugger::CreateInstance();
  ASSERT_TRUE(debugger_sp);

  PlatformSP platform_sp;
  TargetSP target_sp;
  debugger_sp->GetTargetList().CreateTarget(
      *debugger_sp, "", arch, eLoadDependentsNo, platform_sp, target_sp);
  ASSERT_TRUE(target_sp);

  ModuleSP filter_sp = AddModule(*target_sp, *filter_file, "libfilter.so");
  ASSERT_TRUE(filter_sp);
  ModuleSP aux1_sp = AddModule(*target_sp, *aux1_file, "libaux1.so");
  ASSERT_TRUE(aux1_sp);
  ModuleSP aux2_sp = AddModule(*target_sp, *aux2_file, "libaux2.so");
  ASSERT_TRUE(aux2_sp);

  // Sanity: the filter module parsed its symbols and its DT_AUXILIARY filtees
  // were read in order.  Splitting these out pinpoints which layer fails if
  // resolution below does.
  ObjectFile *filter_of = filter_sp->GetObjectFile();
  ASSERT_NE(nullptr, filter_of);
  FileSpecList filtees = filter_of->GetReExportedLibraries();
  ASSERT_EQ(2u, filtees.GetSize());
  EXPECT_EQ(ConstString("libaux1.so"),
            filtees.GetFileSpecAtIndex(0).GetFilename());
  EXPECT_EQ(ConstString("libaux2.so"),
            filtees.GetFileSpecAtIndex(1).GetFilename());
  Symtab *filter_symtab = filter_sp->GetSymtab();
  ASSERT_NE(nullptr, filter_symtab);
  ASSERT_GT(filter_symtab->GetNumSymbols(), 0u);

  // The placeholders stay plain code symbols: marking them as re-exported
  // would reuse their address ranges as string-pointer storage and corrupt
  // the file-address indexes.
  const Symbol *bar = FindFilterSymbol(filter_sp, "bar");
  ASSERT_NE(nullptr, bar);
  EXPECT_EQ(eSymbolTypeCode, bar->GetType());

  // "bar" is found in the first filtee.
  Symbol *bar_def = bar->ResolveReExportedSymbol(*target_sp, filter_sp);
  ASSERT_NE(nullptr, bar_def);
  EXPECT_EQ(ConstString("bar"), bar_def->GetName());
  EXPECT_EQ(eSymbolTypeCode, bar_def->GetType());
  EXPECT_EQ(aux1_sp, bar_def->GetAddress().GetModule());

  // "foo" is not defined by the first filtee: resolution must continue with
  // the remaining filtees in declaration order and find it in the second.
  const Symbol *foo = FindFilterSymbol(filter_sp, "foo");
  ASSERT_NE(nullptr, foo);
  Symbol *foo_def = foo->ResolveReExportedSymbol(*target_sp, filter_sp);
  ASSERT_NE(nullptr, foo_def);
  EXPECT_EQ(ConstString("foo"), foo_def->GetName());
  EXPECT_EQ(eSymbolTypeCode, foo_def->GetType());
  EXPECT_EQ(aux2_sp, foo_def->GetAddress().GetModule());

  // "open@@FBSD_1.0": the @VERSION suffix is stripped before the filtees are
  // searched, since the filtee exports the plain name.
  const Symbol *open_sym = FindFilterSymbol(filter_sp, "open");
  ASSERT_NE(nullptr, open_sym);
  Symbol *open_def = open_sym->ResolveReExportedSymbol(*target_sp, filter_sp);
  ASSERT_NE(nullptr, open_def);
  EXPECT_EQ(ConstString("open"), open_def->GetName());
  EXPECT_EQ(aux2_sp, open_def->GetAddress().GetModule());

  // A local symbol is invisible to the dynamic linker and must not be
  // shadowed, even though the first filtee exports the same name.
  const Symbol *hidden = FindFilterSymbol(filter_sp, "hidden_helper");
  ASSERT_NE(nullptr, hidden);
  EXPECT_EQ(nullptr, hidden->ResolveReExportedSymbol(*target_sp, filter_sp));

  // A name no filtee provides resolves to nothing; callers then fall back
  // to the filter's own (intact) definition.
  const Symbol *filter_local = FindFilterSymbol(filter_sp, "filter_local");
  ASSERT_NE(nullptr, filter_local);
  EXPECT_EQ(nullptr,
            filter_local->ResolveReExportedSymbol(*target_sp, filter_sp));

  // Both the filter and the first filtee genuinely define "dup_impl"
  // (nonzero-sized code on both sides).  The dynamic linker searches the
  // filtees before the filter object's own definition, so the filtee's
  // definition must win.
  const Symbol *dup = FindFilterSymbol(filter_sp, "dup_impl");
  ASSERT_NE(nullptr, dup);
  EXPECT_EQ(eSymbolTypeCode, dup->GetType());
  Symbol *dup_def = dup->ResolveReExportedSymbol(*target_sp, filter_sp);
  ASSERT_NE(nullptr, dup_def);
  EXPECT_EQ(ConstString("dup_impl"), dup_def->GetName());
  EXPECT_EQ(aux1_sp, dup_def->GetAddress().GetModule());

  // Both filtees define "in_both_filtees".  They are searched in declaration
  // order and the search stops at the first hit, so the definition must come
  // from the first filtee, at its own address, and the second filtee's
  // definition must be ignored.
  const Symbol *in_both = FindFilterSymbol(filter_sp, "in_both_filtees");
  ASSERT_NE(nullptr, in_both);
  Symbol *in_both_def = in_both->ResolveReExportedSymbol(*target_sp, filter_sp);
  ASSERT_NE(nullptr, in_both_def);
  EXPECT_EQ(ConstString("in_both_filtees"), in_both_def->GetName());
  EXPECT_EQ(aux1_sp, in_both_def->GetAddress().GetModule());
  EXPECT_EQ(0x1006u, in_both_def->GetAddress().GetFileAddress());

  // Without the containing module nothing connects the symbol to the
  // filtees, so "foo" cannot be resolved.  This is why callers that have
  // the module should pass it.
  EXPECT_EQ(nullptr, foo->ResolveReExportedSymbol(*target_sp));
}