Index: lit/CMakeLists.txt =================================================================== --- lit/CMakeLists.txt +++ lit/CMakeLists.txt @@ -18,6 +18,24 @@ string(REPLACE ${CMAKE_CFG_INTDIR} ${LLVM_BUILD_MODE} LLDB_LIBS_DIR ${LLVM_LIBRARY_OUTPUT_INTDIR}) string(REPLACE ${CMAKE_CFG_INTDIR} ${LLVM_BUILD_MODE} LLDB_TOOLS_DIR ${LLVM_RUNTIME_OUTPUT_INTDIR}) +set(LLDB_TEST_DEPS + LLDBUnitTests + dsymutil + lldb + lldb-test + llvm-config + llvm-mc + llvm-objcopy + ) + +if(TARGET lld) + list(APPEND LLDB_TEST_DEPS lld) + set(LLDB_HAVE_LLD 1) +else() + set(LLDB_HAVE_LLD 0) +endif() + + if(BUILD_SHARED_LIBS) set(ENABLE_SHARED 1) else() @@ -36,16 +54,6 @@ ${CMAKE_CURRENT_BINARY_DIR}/Unit/lit.site.cfg ) -set(LLDB_TEST_DEPS - LLDBUnitTests - dsymutil - lldb - lldb-test - llvm-config - llvm-mc - llvm-objcopy - ) - if(NOT LLDB_BUILT_STANDALONE) list(APPEND LLDB_TEST_DEPS FileCheck not yaml2obj) endif() Index: lit/SymbolFile/DWARF/basic-function-lookup.cpp =================================================================== --- /dev/null +++ lit/SymbolFile/DWARF/basic-function-lookup.cpp @@ -0,0 +1,63 @@ +// REQUIRES: lld + +// RUN: clang %s -g -c -o %t.o --target=x86_64-pc-linux +// RUN: ld.lld %t.o -o %t +// RUN: lldb-test symbols --name=foo --lookup=function --function-flags=base %t | \ +// RUN: FileCheck --check-prefix=BASE %s +// RUN: lldb-test symbols --name=foo --lookup=function --function-flags=method %t | \ +// RUN: FileCheck --check-prefix=METHOD %s +// RUN: lldb-test symbols --name=foo --lookup=function --function-flags=full %t | \ +// RUN: FileCheck --check-prefix=FULL %s +// RUN: lldb-test symbols --name=foo --context=context --lookup=function --function-flags=base %t | \ +// RUN: FileCheck --check-prefix=CONTEXT %s +// RUN: lldb-test symbols --name=not_there --lookup=function %t | \ +// RUN: FileCheck --check-prefix=EMPTY %s + +// EMPTY: Found 0 functions: +// BASE: Found 4 functions: +// METHOD: Found 3 functions: +// FULL: Found 2 functions: +// CONTEXT: Found 1 functions: + +void foo() {} +// BASE-DAG: name = "foo()", mangled = "_Z3foov" +// FULL-DAG: name = "foo()", mangled = "_Z3foov" +void foo(int) {} +// BASE-DAG: name = "foo(int)", mangled = "_Z3fooi" +// FULL-DAG: name = "foo(int)", mangled = "_Z3fooi" + +namespace bar { +int context; +void foo() {} +// BASE-DAG: name = "bar::foo()", mangled = "_ZN3bar3fooEv" +// CONTEXT-DAG: name = "bar::foo()", mangled = "_ZN3bar3fooEv" +namespace baz { +void foo() {} +// BASE-DAG: name = "bar::baz::foo()", mangled = "_ZN3bar3baz3fooEv" +} // namespace baz +} // namespace bar + +struct foo {}; +void fbar(struct foo) {} + +void Foo() {} + +struct sbar { + void foo(); +// METHOD-DAG: name = "sbar::foo()", mangled = "_ZN4sbar3fooEv" + static void foo(int); +// METHOD-DAG: name = "sbar::foo(int)", mangled = "_ZN4sbar3fooEi" +}; +void sbar::foo() {} +void sbar::foo(int) {} + +void ffbar() { + struct sbar { + void foo() {} +// METHOD-DAG: name = "ffbar()::sbar::foo()", mangled = "_ZZ5ffbarvEN4sbar3fooEv" + }; + sbar a; + a.foo(); +} + +extern "C" void _start() {} Index: lit/SymbolFile/DWARF/basic-namespace-lookup.cpp =================================================================== --- /dev/null +++ lit/SymbolFile/DWARF/basic-namespace-lookup.cpp @@ -0,0 +1,27 @@ +// REQUIRES: lld + +// RUN: clang %s -g -c -o %t.o --target=x86_64-pc-linux +// RUN: ld.lld %t.o -o %t +// RUN: lldb-test symbols --name=foo --lookup=namespace %t | \ +// RUN: FileCheck --check-prefix=FOO %s +// RUN: lldb-test symbols --name=foo --lookup=namespace --context=context %t | \ +// RUN: FileCheck --check-prefix=CONTEXT %s +// RUN: lldb-test symbols --name=not_there --lookup=namespace %t | \ +// RUN: FileCheck --check-prefix=EMPTY %s + +namespace foo { +int X; +} +// FOO: Found namespace: foo + +namespace bar { +int context; +namespace foo { +// CONTEXT: Found namespace: bar::foo +int X; +} +} // namespace bar + +// EMPTY: Namespace not found. + +extern "C" void _start() {} Index: lit/SymbolFile/DWARF/basic-type-lookup.cpp =================================================================== --- /dev/null +++ lit/SymbolFile/DWARF/basic-type-lookup.cpp @@ -0,0 +1,38 @@ +// REQUIRES: lld + +// RUN: clang %s -g -c -o %t.o --target=x86_64-pc-linux +// RUN: ld.lld %t.o -o %t +// RUN: lldb-test symbols --name=foo --lookup=type %t | \ +// RUN: FileCheck --check-prefix=NAME %s +// RUN: lldb-test symbols --name=foo --context=context --lookup=type %t | \ +// RUN: FileCheck --check-prefix=CONTEXT %s +// RUN: lldb-test symbols --name=not_there --lookup=type %t | \ +// RUN: FileCheck --check-prefix=EMPTY %s + +// EMPTY: Found 0 types: +// NAME: Found 4 types: +// CONTEXT: Found 1 types: +struct foo { }; +// NAME-DAG: name = "foo", {{.*}} decl = basic-type-lookup.cpp:[[@LINE-1]] + +namespace bar { +int context; +struct foo {}; +// NAME-DAG: name = "foo", {{.*}} decl = basic-type-lookup.cpp:[[@LINE-1]] +// CONTEXT-DAG: name = "foo", {{.*}} decl = basic-type-lookup.cpp:[[@LINE-2]] +namespace baz { +struct foo {}; +// NAME-DAG: name = "foo", {{.*}} decl = basic-type-lookup.cpp:[[@LINE-1]] +} +} + +struct sbar { + struct foo {}; +// NAME-DAG: name = "foo", {{.*}} decl = basic-type-lookup.cpp:[[@LINE-1]] +}; + +struct foobar {}; + +struct Foo {}; + +extern "C" void _start(foo, bar::foo, bar::baz::foo, sbar::foo, foobar, Foo) {} Index: lit/SymbolFile/DWARF/basic-variable-lookup.cpp =================================================================== --- /dev/null +++ lit/SymbolFile/DWARF/basic-variable-lookup.cpp @@ -0,0 +1,55 @@ +// REQUIRES: lld + +// RUN: clang %s -g -c -o %t.o --target=x86_64-pc-linux +// RUN: ld.lld %t.o -o %t +// RUN: lldb-test symbols --name=foo --lookup=variable --context=context %t | \ +// RUN: FileCheck --check-prefix=CONTEXT %s +// RUN: lldb-test symbols --name=foo --lookup=variable %t | \ +// RUN: FileCheck --check-prefix=NAME %s +// RUN: lldb-test symbols --regex --name=foo --lookup=variable %t | \ +// RUN: FileCheck --check-prefix=REGEX %s +// RUN: lldb-test symbols --name=not_there --lookup=variable %t | \ +// RUN: FileCheck --check-prefix=EMPTY %s + +// EMPTY: Found 0 variables: +// NAME: Found 4 variables: +// CONTEXT: Found 1 variables: +// REGEX: Found 5 variables: +int foo; +// NAME-DAG: name = "foo", type = {{.*}} (int), {{.*}} decl = basic-variable-lookup.cpp:[[@LINE-1]] +// REGEX-DAG: name = "foo", type = {{.*}} (int), {{.*}} decl = basic-variable-lookup.cpp:[[@LINE-2]] +namespace bar { +int context; +long foo; +// NAME-DAG: name = "foo", type = {{.*}} (long int), {{.*}} decl = basic-variable-lookup.cpp:[[@LINE-1]] +// CONTEXT-DAG: name = "foo", type = {{.*}} (long int), {{.*}} decl = basic-variable-lookup.cpp:[[@LINE-2]] +// REGEX-DAG: name = "foo", type = {{.*}} (long int), {{.*}} decl = basic-variable-lookup.cpp:[[@LINE-3]] +namespace baz { +static short foo; +// NAME-DAG: name = "foo", type = {{.*}} (short), {{.*}} decl = basic-variable-lookup.cpp:[[@LINE-1]] +// REGEX-DAG: name = "foo", type = {{.*}} (short), {{.*}} decl = basic-variable-lookup.cpp:[[@LINE-2]] +} +} + +struct sbar { + static int foo; +// NAME-DAG: name = "foo", type = {{.*}} (int), {{.*}} decl = basic-variable-lookup.cpp:[[@LINE-1]] +// REGEX-DAG: name = "foo", type = {{.*}} (int), {{.*}} decl = basic-variable-lookup.cpp:[[@LINE-2]] +}; +int sbar::foo; + +int foobar; +// REGEX-DAG: name = "foobar", type = {{.*}} (int), {{.*}} decl = basic-variable-lookup.cpp:[[@LINE-1]] + +int fbar() { + static int foo; + return foo + bar::baz::foo; +} + +int Foo; + +struct ssbar { + int foo; +}; + +extern "C" void _start(sbar, ssbar) {} Index: lit/SymbolFile/DWARF/type-in-function-lookup.cpp =================================================================== --- /dev/null +++ lit/SymbolFile/DWARF/type-in-function-lookup.cpp @@ -0,0 +1,24 @@ +// REQUIRES: lld + +// XFAIL: * + +// RUN: clang %s -g -c -o %t.o --target=x86_64-pc-linux +// RUN: ld.lld %t.o -o %t +// RUN: lldb-test symbols --name=foo --lookup=type %t | \ +// RUN: FileCheck --check-prefix=NAME %s + +// Lookup for "foo" should find either both "struct foo" types or just the +// global one. Right now, it finds the definition inside bar(), which is +// definitely wrong. + +// NAME: Found 2 types: +struct foo {}; +// NAME-DAG: name = "foo", {{.*}} decl = basic-type-lookup.cpp:[[@LINE-1]] + +void bar() { + struct foo {}; +// NAME-DAG: name = "foo", {{.*}} decl = basic-type-lookup.cpp:[[@LINE-1]] + foo a; +} + +extern "C" void _start(foo) {} Index: lit/lit.cfg =================================================================== --- lit/lit.cfg +++ lit/lit.cfg @@ -132,6 +132,8 @@ config.available_features.add("compiler-msvc") config.available_features.add(binary_feature(config.have_zlib, "zlib", "no")) +if config.have_lld: + config.available_features.add("lld") # llvm-config knows whether it is compiled with asserts (and) # whether we are operating in release/debug mode. Index: lit/lit.site.cfg.in =================================================================== --- lit/lit.site.cfg.in +++ lit/lit.site.cfg.in @@ -13,6 +13,7 @@ config.cc = "@LLDB_TEST_C_COMPILER@" config.cxx = "@LLDB_TEST_CXX_COMPILER@" config.have_zlib = @LLVM_ENABLE_ZLIB@ +config.have_lld = @LLDB_HAVE_LLD@ # Support substitution of the tools and libs dirs with user parameters. This is # used when we can't determine the tool dir at configuration time. Index: tools/lldb-test/lldb-test.cpp =================================================================== --- tools/lldb-test/lldb-test.cpp +++ tools/lldb-test/lldb-test.cpp @@ -20,6 +20,9 @@ #include "lldb/Interpreter/CommandReturnObject.h" #include "lldb/Symbol/ClangASTContext.h" #include "lldb/Symbol/ClangASTImporter.h" +#include "lldb/Symbol/SymbolVendor.h" +#include "lldb/Symbol/TypeList.h" +#include "lldb/Symbol/VariableList.h" #include "lldb/Utility/DataExtractor.h" #include "lldb/Utility/StreamString.h" @@ -69,8 +72,65 @@ } // namespace module namespace symbols { -cl::list InputFilenames(cl::Positional, cl::desc(""), - cl::OneOrMore, cl::sub(SymbolsSubcommand)); +static cl::list InputFilenames(cl::Positional, + cl::desc(""), + cl::OneOrMore, + cl::sub(SymbolsSubcommand)); +enum class LookupType { + None, + Function, + Namespace, + Type, + Variable, +}; +static cl::opt Lookup( + "lookup", cl::desc("Choose lookup type:"), + cl::values( + clEnumValN(LookupType::None, "none", + "No lookup, just dump the module."), + clEnumValN(LookupType::Function, "function", "Find functions."), + clEnumValN(LookupType::Namespace, "namespace", "Find namespaces."), + clEnumValN(LookupType::Type, "type", "Find types."), + clEnumValN(LookupType::Variable, "variable", "Find global variables.")), + cl::sub(SymbolsSubcommand)); + +static cl::opt Name("name", cl::desc("Name to lookup."), + cl::sub(SymbolsSubcommand)); +static cl::opt + Regex("regex", + cl::desc("Lookup using regular expressions (avaliable for variables " + "and functions only)."), + cl::sub(SymbolsSubcommand)); +static cl::opt + Context("context", + cl::desc("Restrict search to the context of the given variable."), + cl::value_desc("variable"), cl::sub(SymbolsSubcommand)); + +static cl::list FunctionNameFlags( + "function-flags", cl::desc("Function lookup flags:"), + cl::values(clEnumValN(eFunctionNameTypeAuto, "auto", + "Automatically deduce flags based on name."), + clEnumValN(eFunctionNameTypeFull, "full", "Full function name."), + clEnumValN(eFunctionNameTypeBase, "base", "Base name."), + clEnumValN(eFunctionNameTypeMethod, "method", "Method name."), + clEnumValN(eFunctionNameTypeSelector, "selector", + "Selector name.")), + cl::sub(SymbolsSubcommand)); +static FunctionNameType getFunctionNameFlags() { + FunctionNameType Result = FunctionNameType(0); + for (FunctionNameType Flag : FunctionNameFlags) + Result = FunctionNameType(Result | Flag); + return Result; +} + +static Expected getDeclContext(SymbolVendor &Vendor); + +static void lookupFunctions(SymbolVendor &Vendor); +static void lookupNamespaces(SymbolVendor &Vendor); +static void lookupTypes(SymbolVendor &Vendor); +static void lookupVariables(SymbolVendor &Vendor); + +static void dumpSymbols(Debugger &Dbg); } } // namespace opts @@ -174,18 +234,167 @@ } } -static void dumpSymbols(Debugger &Dbg) { - for (const auto &File : opts::symbols::InputFilenames) { +Expected +opts::symbols::getDeclContext(SymbolVendor &Vendor) { + if (Context.empty()) + return CompilerDeclContext(); + VariableList List; + Vendor.FindGlobalVariables(ConstString(Context), nullptr, false, UINT32_MAX, + List); + if (List.GetSize() == 0) { + return make_error("Context search didn't find a match.", + inconvertibleErrorCode()); + } + if (List.GetSize() > 1) { + return make_error("Context search found multiple matches.", + inconvertibleErrorCode()); + } + return List.GetVariableAtIndex(0)->GetDeclContext(); +} + +void opts::symbols::lookupFunctions(SymbolVendor &Vendor) { + SymbolContextList List; + if (Regex) { + RegularExpression RE(Name); + if (!RE.IsValid()) { + errs() << "ERROR: `" << Name << "` is not a valid regular expression.\n"; + return; + } + Vendor.FindFunctions(RE, true, false, List); + } else { + Expected ContextOr = getDeclContext(Vendor); + if (!ContextOr) { + errs() << "ERROR: " << toString(ContextOr.takeError()) << "\n"; + return; + } + CompilerDeclContext *ContextPtr = + ContextOr->IsValid() ? &*ContextOr : nullptr; + + Vendor.FindFunctions(ConstString(Name), ContextPtr, getFunctionNameFlags(), + true, false, List); + } + outs() << formatv("Found {0} functions:\n", List.GetSize()); + StreamString Stream; + List.Dump(&Stream, nullptr); + outs() << Stream.GetData() << "\n"; +} + +void opts::symbols::lookupNamespaces(SymbolVendor &Vendor) { + Expected ContextOr = getDeclContext(Vendor); + if (!ContextOr) { + errs() << "ERROR: " << toString(ContextOr.takeError()) << "\n"; + return; + } + CompilerDeclContext *ContextPtr = + ContextOr->IsValid() ? &*ContextOr : nullptr; + + SymbolContext SC; + CompilerDeclContext Result = + Vendor.FindNamespace(SC, ConstString(Name), ContextPtr); + if (Result) + outs() << "Found namespace: " + << Result.GetScopeQualifiedName().GetStringRef() << "\n"; + else + outs() << "Namespace not found.\n"; +} + +void opts::symbols::lookupTypes(SymbolVendor &Vendor) { + SymbolContext SC; + DenseSet SearchedFiles; + TypeMap Map; + Expected ContextOr = getDeclContext(Vendor); + if (!ContextOr) { + errs() << "ERROR: " << toString(ContextOr.takeError()) << "\n"; + return; + } + CompilerDeclContext *ContextPtr = + ContextOr->IsValid() ? &*ContextOr : nullptr; + + Vendor.FindTypes(SC, ConstString(Name), ContextPtr, true, UINT32_MAX, + SearchedFiles, Map); + + outs() << formatv("Found {0} types:\n", Map.GetSize()); + StreamString Stream; + Map.Dump(&Stream, false); + outs() << Stream.GetData() << "\n"; +} + +void opts::symbols::lookupVariables(SymbolVendor &Vendor) { + VariableList List; + if (Regex) { + RegularExpression RE(Name); + if (!RE.IsValid()) { + errs() << "ERROR: `" << Name << "` is not a valid regular expression.\n"; + return; + } + Vendor.FindGlobalVariables(RE, false, UINT32_MAX, List); + } else { + Expected ContextOr = getDeclContext(Vendor); + if (!ContextOr) { + errs() << "ERROR: " << toString(ContextOr.takeError()) << "\n"; + return; + } + CompilerDeclContext *ContextPtr = + ContextOr->IsValid() ? &*ContextOr : nullptr; + + Vendor.FindGlobalVariables(ConstString(Name), ContextPtr, false, UINT32_MAX, + List); + } + outs() << formatv("Found {0} variables:\n", List.GetSize()); + StreamString Stream; + List.Dump(&Stream, false); + outs() << Stream.GetData() << "\n"; +} + +void opts::symbols::dumpSymbols(Debugger &Dbg) { + if (Lookup != LookupType::None && Regex && !Context.empty()) { + errs() + << "ERROR: Cannot lookup using both regular expressions and context.\n"; + return; + } + if ((Lookup == LookupType::Type || Lookup == LookupType::Namespace) && Regex) { + errs() << "ERROR: Cannot lookup types and namespaces using regular " + "expressions.\n"; + return; + } + if (Lookup == LookupType::Function && Regex && getFunctionNameFlags() != 0) { + errs() << "ERROR: Cannot lookup types using both regular expressions and " + "function-flags.\n"; + return; + } + for (const auto &File : InputFilenames) { + outs() << "Module: " << File << "\n"; ModuleSpec Spec{FileSpec(File, false)}; Spec.GetSymbolFileSpec().SetFile(File, false); auto ModulePtr = std::make_shared(Spec); + SymbolVendor *Vendor = ModulePtr->GetSymbolVendor(); + if (!Vendor) { + errs() << "ERROR: Module has no symbol vendor.\n"; + continue; + } - StreamString Stream; - ModulePtr->ParseAllDebugSymbols(); - ModulePtr->Dump(&Stream); - llvm::outs() << Stream.GetData() << "\n"; - llvm::outs().flush(); + switch(Lookup) { + case LookupType::Function: + lookupFunctions(*Vendor); + break; + case LookupType::Namespace: + lookupNamespaces(*Vendor); + break; + case LookupType::Type: + lookupTypes(*Vendor); + break; + case LookupType::Variable: + lookupVariables(*Vendor); + break; + case LookupType::None: + StreamString Stream; + ModulePtr->ParseAllDebugSymbols(); + ModulePtr->Dump(&Stream); + outs() << Stream.GetData() << "\n"; + break; + } + outs().flush(); } } @@ -246,7 +455,7 @@ if (opts::ModuleSubcommand) dumpModules(*Dbg); else if (opts::SymbolsSubcommand) - dumpSymbols(*Dbg); + opts::symbols::dumpSymbols(*Dbg); DebuggerLifetime->Terminate(); return 0;