caio/clang-p2996
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases Wiki Activity
Files
c6c7bfc4d2bc37f55f57504c19d47deb7645dd76
clang-p2996/lldb/tools/lldb-test/lldb-test.cpp
Aleksandr Urakov 709426b33a [PDB] Restore AST from PDB symbols 
Summary:
This patch adds an implementation of retrieving of declarations and declaration
contexts based on PDB symbols.

PDB has different type symbols for const-qualified types, and this
implementation ensures that only one declaration was created for both const
and non-const types, but creates different compiler types for them.

The implementation also processes the case when there are two symbols
corresponding to a variable. It's possible e.g. for class static variables,
they has one global symbol and one symbol belonging to a class.

PDB has no info about namespaces, so this implementation parses the full symbol
name and tries to figure out if the symbol belongs to namespace or not,
and then creates nested namespaces if necessary.

Reviewers: asmith, zturner, labath

Reviewed By: asmith

Subscribers: aleksandr.urakov, teemperor, lldb-commits, stella.stamenova

Tags: #lldb

Differential Revision: https://reviews.llvm.org/D51162

llvm-svn: 341782
2018-09-10 08:08:43 +00:00

959 lines
33 KiB
C++
Raw Blame History

//===- lldb-test.cpp ------------------------------------------ *- C++ --*-===//
//
// The LLVM Compiler Infrastructure
//
// This file is distributed under the University of Illinois Open Source
// License. See LICENSE.TXT for details.
//
//===----------------------------------------------------------------------===//
#include "FormatUtil.h"
#include "SystemInitializerTest.h"
#include "Plugins/SymbolFile/DWARF/SymbolFileDWARF.h"
#include "lldb/Breakpoint/BreakpointLocation.h"
#include "lldb/Core/Debugger.h"
#include "lldb/Core/Module.h"
#include "lldb/Core/Section.h"
#include "lldb/Expression/IRMemoryMap.h"
#include "lldb/Initialization/SystemLifetimeManager.h"
#include "lldb/Interpreter/CommandInterpreter.h"
#include "lldb/Interpreter/CommandReturnObject.h"
#include "lldb/Symbol/ClangASTContext.h"
#include "lldb/Symbol/ClangASTImporter.h"
#include "lldb/Symbol/CompileUnit.h"
#include "lldb/Symbol/LineTable.h"
#include "lldb/Symbol/SymbolVendor.h"
#include "lldb/Symbol/TypeList.h"
#include "lldb/Symbol/VariableList.h"
#include "lldb/Target/Process.h"
#include "lldb/Target/Target.h"
#include "lldb/Utility/CleanUp.h"
#include "lldb/Utility/DataExtractor.h"
#include "lldb/Utility/StreamString.h"
#include "llvm/ADT/IntervalMap.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/CommandLine.h"
#include "llvm/Support/ManagedStatic.h"
#include "llvm/Support/MathExtras.h"
#include "llvm/Support/Path.h"
#include "llvm/Support/PrettyStackTrace.h"
#include "llvm/Support/Signals.h"
#include "llvm/Support/WithColor.h"
#include <cstdio>
#include <thread>
using namespace lldb;
using namespace lldb_private;
using namespace llvm;
namespace opts {
static cl::SubCommand BreakpointSubcommand("breakpoints",
"Test breakpoint resolution");
cl::SubCommand ObjectFileSubcommand("object-file",
"Display LLDB object file information");
cl::SubCommand SymbolsSubcommand("symbols", "Dump symbols for an object file");
cl::SubCommand IRMemoryMapSubcommand("ir-memory-map", "Test IRMemoryMap");
cl::opt<std::string> Log("log", cl::desc("Path to a log file"), cl::init(""),
cl::sub(BreakpointSubcommand),
cl::sub(ObjectFileSubcommand),
cl::sub(SymbolsSubcommand),
cl::sub(IRMemoryMapSubcommand));
/// Create a target using the file pointed to by \p Filename, or abort.
TargetSP createTarget(Debugger &Dbg, const std::string &Filename);
/// Read \p Filename into a null-terminated buffer, or abort.
std::unique_ptr<MemoryBuffer> openFile(const std::string &Filename);
namespace breakpoint {
static cl::opt<std::string> Target(cl::Positional, cl::desc("<target>"),
cl::Required, cl::sub(BreakpointSubcommand));
static cl::opt<std::string> CommandFile(cl::Positional,
cl::desc("<command-file>"),
cl::init("-"),
cl::sub(BreakpointSubcommand));
static cl::opt<bool> Persistent(
"persistent",
cl::desc("Don't automatically remove all breakpoints before each command"),
cl::sub(BreakpointSubcommand));
static llvm::StringRef plural(uintmax_t value) { return value == 1 ? "" : "s"; }
static void dumpState(const BreakpointList &List, LinePrinter &P);
static std::string substitute(StringRef Cmd);
static int evaluateBreakpoints(Debugger &Dbg);
} // namespace breakpoint
namespace object {
cl::opt<bool> SectionContents("contents",
cl::desc("Dump each section's contents"),
cl::sub(ObjectFileSubcommand));
cl::list<std::string> InputFilenames(cl::Positional, cl::desc("<input files>"),
cl::OneOrMore,
cl::sub(ObjectFileSubcommand));
} // namespace object
namespace symbols {
static cl::list<std::string> InputFilenames(cl::Positional,
cl::desc("<input files>"),
cl::OneOrMore,
cl::sub(SymbolsSubcommand));
enum class FindType {
None,
Function,
Block,
Namespace,
Type,
Variable,
};
static cl::opt<FindType> Find(
"find", cl::desc("Choose search type:"),
cl::values(
clEnumValN(FindType::None, "none", "No search, just dump the module."),
clEnumValN(FindType::Function, "function", "Find functions."),
clEnumValN(FindType::Block, "block", "Find blocks."),
clEnumValN(FindType::Namespace, "namespace", "Find namespaces."),
clEnumValN(FindType::Type, "type", "Find types."),
clEnumValN(FindType::Variable, "variable", "Find global variables.")),
cl::sub(SymbolsSubcommand));
static cl::opt<std::string> Name("name", cl::desc("Name to find."),
cl::sub(SymbolsSubcommand));
static cl::opt<bool>
Regex("regex",
cl::desc("Search using regular expressions (avaliable for variables "
"and functions only)."),
cl::sub(SymbolsSubcommand));
static cl::opt<std::string>
Context("context",
cl::desc("Restrict search to the context of the given variable."),
cl::value_desc("variable"), cl::sub(SymbolsSubcommand));
static cl::list<FunctionNameType> FunctionNameFlags(
"function-flags", cl::desc("Function search 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 cl::opt<bool> DumpAST("dump-ast",
cl::desc("Dump AST restored from symbols."),
cl::sub(SymbolsSubcommand));
static cl::opt<bool> Verify("verify", cl::desc("Verify symbol information."),
cl::sub(SymbolsSubcommand));
static cl::opt<std::string> File("file",
cl::desc("File (compile unit) to search."),
cl::sub(SymbolsSubcommand));
static cl::opt<int> Line("line", cl::desc("Line to search."),
cl::sub(SymbolsSubcommand));
static Expected<CompilerDeclContext> getDeclContext(SymbolVendor &Vendor);
static Error findFunctions(lldb_private::Module &Module);
static Error findBlocks(lldb_private::Module &Module);
static Error findNamespaces(lldb_private::Module &Module);
static Error findTypes(lldb_private::Module &Module);
static Error findVariables(lldb_private::Module &Module);
static Error dumpModule(lldb_private::Module &Module);
static Error dumpAST(lldb_private::Module &Module);
static Error verify(lldb_private::Module &Module);
static Expected<Error (*)(lldb_private::Module &)> getAction();
static int dumpSymbols(Debugger &Dbg);
} // namespace symbols
namespace irmemorymap {
static cl::opt<std::string> Target(cl::Positional, cl::desc("<target>"),
cl::Required,
cl::sub(IRMemoryMapSubcommand));
static cl::opt<std::string> CommandFile(cl::Positional,
cl::desc("<command-file>"),
cl::init("-"),
cl::sub(IRMemoryMapSubcommand));
static cl::opt<bool> UseHostOnlyAllocationPolicy(
"host-only", cl::desc("Use the host-only allocation policy"),
cl::init(false), cl::sub(IRMemoryMapSubcommand));
using AllocationT = std::pair<addr_t, addr_t>;
using AddrIntervalMap =
IntervalMap<addr_t, unsigned, 8, IntervalMapHalfOpenInfo<addr_t>>;
struct IRMemoryMapTestState {
TargetSP Target;
IRMemoryMap Map;
AddrIntervalMap::Allocator IntervalMapAllocator;
AddrIntervalMap Allocations;
StringMap<addr_t> Label2AddrMap;
IRMemoryMapTestState(TargetSP Target)
: Target(Target), Map(Target), Allocations(IntervalMapAllocator) {}
};
bool areAllocationsOverlapping(const AllocationT &L, const AllocationT &R);
bool evalMalloc(StringRef Line, IRMemoryMapTestState &State);
bool evalFree(StringRef Line, IRMemoryMapTestState &State);
int evaluateMemoryMapCommands(Debugger &Dbg);
} // namespace irmemorymap
} // namespace opts
template <typename... Args>
static Error make_string_error(const char *Format, Args &&... args) {
return llvm::make_error<llvm::StringError>(
llvm::formatv(Format, std::forward<Args>(args)...).str(),
llvm::inconvertibleErrorCode());
}
TargetSP opts::createTarget(Debugger &Dbg, const std::string &Filename) {
TargetSP Target;
Status ST =
Dbg.GetTargetList().CreateTarget(Dbg, Filename, /*triple*/ "",
/*get_dependent_modules*/ false,
/*platform_options*/ nullptr, Target);
if (ST.Fail()) {
errs() << formatv("Failed to create target '{0}: {1}\n", Filename, ST);
exit(1);
}
return Target;
}
std::unique_ptr<MemoryBuffer> opts::openFile(const std::string &Filename) {
auto MB = MemoryBuffer::getFileOrSTDIN(Filename);
if (!MB) {
errs() << formatv("Could not open file '{0}: {1}\n", Filename,
MB.getError().message());
exit(1);
}
return std::move(*MB);
}
void opts::breakpoint::dumpState(const BreakpointList &List, LinePrinter &P) {
P.formatLine("{0} breakpoint{1}", List.GetSize(), plural(List.GetSize()));
if (List.GetSize() > 0)
P.formatLine("At least one breakpoint.");
for (size_t i = 0, e = List.GetSize(); i < e; ++i) {
BreakpointSP BP = List.GetBreakpointAtIndex(i);
P.formatLine("Breakpoint ID {0}:", BP->GetID());
AutoIndent Indent(P, 2);
P.formatLine("{0} location{1}.", BP->GetNumLocations(),
plural(BP->GetNumLocations()));
if (BP->GetNumLocations() > 0)
P.formatLine("At least one location.");
P.formatLine("{0} resolved location{1}.", BP->GetNumResolvedLocations(),
plural(BP->GetNumResolvedLocations()));
if (BP->GetNumResolvedLocations() > 0)
P.formatLine("At least one resolved location.");
for (size_t l = 0, le = BP->GetNumLocations(); l < le; ++l) {
BreakpointLocationSP Loc = BP->GetLocationAtIndex(l);
P.formatLine("Location ID {0}:", Loc->GetID());
AutoIndent Indent(P, 2);
P.formatLine("Enabled: {0}", Loc->IsEnabled());
P.formatLine("Resolved: {0}", Loc->IsResolved());
SymbolContext sc;
Loc->GetAddress().CalculateSymbolContext(&sc);
lldb_private::StreamString S;
sc.DumpStopContext(&S, BP->GetTarget().GetProcessSP().get(),
Loc->GetAddress(), false, true, false, true, true);
P.formatLine("Address: {0}", S.GetString());
}
}
P.NewLine();
}
std::string opts::breakpoint::substitute(StringRef Cmd) {
std::string Result;
raw_string_ostream OS(Result);
while (!Cmd.empty()) {
switch (Cmd[0]) {
case '%':
if (Cmd.consume_front("%p") && (Cmd.empty() || !isalnum(Cmd[0]))) {
OS << sys::path::parent_path(breakpoint::CommandFile);
break;
}
// fall through
default:
size_t pos = Cmd.find('%');
OS << Cmd.substr(0, pos);
Cmd = Cmd.substr(pos);
break;
}
}
return std::move(OS.str());
}
int opts::breakpoint::evaluateBreakpoints(Debugger &Dbg) {
TargetSP Target = opts::createTarget(Dbg, breakpoint::Target);
std::unique_ptr<MemoryBuffer> MB = opts::openFile(breakpoint::CommandFile);
LinePrinter P(4, outs());
StringRef Rest = MB->getBuffer();
int HadErrors = 0;
while (!Rest.empty()) {
StringRef Line;
std::tie(Line, Rest) = Rest.split('\n');
Line = Line.ltrim();
if (Line.empty() || Line[0] == '#')
continue;
if (!Persistent)
Target->RemoveAllBreakpoints(/*internal_also*/ true);
std::string Command = substitute(Line);
P.formatLine("Command: {0}", Command);
CommandReturnObject Result;
if (!Dbg.GetCommandInterpreter().HandleCommand(
Command.c_str(), /*add_to_history*/ eLazyBoolNo, Result)) {
P.formatLine("Failed: {0}", Result.GetErrorData());
HadErrors = 1;
continue;
}
dumpState(Target->GetBreakpointList(/*internal*/ false), P);
}
return HadErrors;
}
Expected<CompilerDeclContext>
opts::symbols::getDeclContext(SymbolVendor &Vendor) {
if (Context.empty())
return CompilerDeclContext();
VariableList List;
Vendor.FindGlobalVariables(ConstString(Context), nullptr, UINT32_MAX, List);
if (List.Empty())
return make_string_error("Context search didn't find a match.");
if (List.GetSize() > 1)
return make_string_error("Context search found multiple matches.");
return List.GetVariableAtIndex(0)->GetDeclContext();
}
Error opts::symbols::findFunctions(lldb_private::Module &Module) {
SymbolVendor &Vendor = *Module.GetSymbolVendor();
SymbolContextList List;
if (!File.empty()) {
assert(Line != 0);
FileSpec src_file(File, false);
size_t cu_count = Module.GetNumCompileUnits();
for (size_t i = 0; i < cu_count; i++) {
lldb::CompUnitSP cu_sp = Module.GetCompileUnitAtIndex(i);
if (!cu_sp)
continue;
LineEntry le;
cu_sp->FindLineEntry(0, Line, &src_file, false, &le);
if (!le.IsValid())
continue;
auto addr = le.GetSameLineContiguousAddressRange().GetBaseAddress();
if (!addr.IsValid())
continue;
SymbolContext sc;
uint32_t resolved =
addr.CalculateSymbolContext(&sc, eSymbolContextFunction);
if (resolved & eSymbolContextFunction)
List.Append(sc);
}
} else if (Regex) {
RegularExpression RE(Name);
assert(RE.IsValid());
Vendor.FindFunctions(RE, true, false, List);
} else {
Expected<CompilerDeclContext> ContextOr = getDeclContext(Vendor);
if (!ContextOr)
return ContextOr.takeError();
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";
return Error::success();
}
Error opts::symbols::findBlocks(lldb_private::Module &Module) {
assert(!Regex);
assert(!File.empty());
assert(Line != 0);
SymbolContextList List;
FileSpec src_file(File, false);
size_t cu_count = Module.GetNumCompileUnits();
for (size_t i = 0; i < cu_count; i++) {
lldb::CompUnitSP cu_sp = Module.GetCompileUnitAtIndex(i);
if (!cu_sp)
continue;
LineEntry le;
cu_sp->FindLineEntry(0, Line, &src_file, false, &le);
if (!le.IsValid())
continue;
auto addr = le.GetSameLineContiguousAddressRange().GetBaseAddress();
if (!addr.IsValid())
continue;
SymbolContext sc;
uint32_t resolved = addr.CalculateSymbolContext(&sc, eSymbolContextBlock);
if (resolved & eSymbolContextBlock)
List.Append(sc);
}
outs() << formatv("Found {0} blocks:\n", List.GetSize());
StreamString Stream;
List.Dump(&Stream, nullptr);
outs() << Stream.GetData() << "\n";
return Error::success();
}
Error opts::symbols::findNamespaces(lldb_private::Module &Module) {
SymbolVendor &Vendor = *Module.GetSymbolVendor();
Expected<CompilerDeclContext> ContextOr = getDeclContext(Vendor);
if (!ContextOr)
return ContextOr.takeError();
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";
return Error::success();
}
Error opts::symbols::findTypes(lldb_private::Module &Module) {
SymbolVendor &Vendor = *Module.GetSymbolVendor();
Expected<CompilerDeclContext> ContextOr = getDeclContext(Vendor);
if (!ContextOr)
return ContextOr.takeError();
CompilerDeclContext *ContextPtr =
ContextOr->IsValid() ? &*ContextOr : nullptr;
SymbolContext SC;
DenseSet<SymbolFile *> SearchedFiles;
TypeMap Map;
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";
return Error::success();
}
Error opts::symbols::findVariables(lldb_private::Module &Module) {
SymbolVendor &Vendor = *Module.GetSymbolVendor();
VariableList List;
if (Regex) {
RegularExpression RE(Name);
assert(RE.IsValid());
Vendor.FindGlobalVariables(RE, UINT32_MAX, List);
} else if (!File.empty()) {
CompUnitSP CU;
for (size_t Ind = 0; !CU && Ind < Module.GetNumCompileUnits(); ++Ind) {
CompUnitSP Candidate = Module.GetCompileUnitAtIndex(Ind);
if (!Candidate || Candidate->GetFilename().GetStringRef() != File)
continue;
if (CU)
return make_string_error("Multiple compile units for file `{0}` found.",
File);
CU = std::move(Candidate);
}
if (!CU)
return make_string_error("Compile unit `{0}` not found.", File);
List.AddVariables(CU->GetVariableList(true).get());
} else {
Expected<CompilerDeclContext> ContextOr = getDeclContext(Vendor);
if (!ContextOr)
return ContextOr.takeError();
CompilerDeclContext *ContextPtr =
ContextOr->IsValid() ? &*ContextOr : nullptr;
Vendor.FindGlobalVariables(ConstString(Name), ContextPtr, UINT32_MAX, List);
}
outs() << formatv("Found {0} variables:\n", List.GetSize());
StreamString Stream;
List.Dump(&Stream, false);
outs() << Stream.GetData() << "\n";
return Error::success();
}
Error opts::symbols::dumpModule(lldb_private::Module &Module) {
StreamString Stream;
Module.ParseAllDebugSymbols();
Module.Dump(&Stream);
outs() << Stream.GetData() << "\n";
return Error::success();
}
Error opts::symbols::dumpAST(lldb_private::Module &Module) {
SymbolVendor &plugin = *Module.GetSymbolVendor();
auto symfile = plugin.GetSymbolFile();
if (!symfile)
return make_string_error("Module has no symbol file.");
auto clang_ast_ctx = llvm::dyn_cast_or_null<ClangASTContext>(
symfile->GetTypeSystemForLanguage(eLanguageTypeC_plus_plus));
if (!clang_ast_ctx)
return make_string_error("Can't retrieve Clang AST context.");
auto ast_ctx = clang_ast_ctx->getASTContext();
if (!ast_ctx)
return make_string_error("Can't retrieve AST context.");
auto tu = ast_ctx->getTranslationUnitDecl();
if (!tu)
return make_string_error("Can't retrieve translation unit declaration.");
symfile->ParseDeclsForContext(CompilerDeclContext(
clang_ast_ctx, static_cast<clang::DeclContext *>(tu)));
tu->print(outs());
return Error::success();
}
Error opts::symbols::verify(lldb_private::Module &Module) {
SymbolVendor &plugin = *Module.GetSymbolVendor();
SymbolFile *symfile = plugin.GetSymbolFile();
if (!symfile)
return make_string_error("Module has no symbol file.");
uint32_t comp_units_count = symfile->GetNumCompileUnits();
outs() << "Found " << comp_units_count << " compile units.\n";
for (uint32_t i = 0; i < comp_units_count; i++) {
lldb::CompUnitSP comp_unit = symfile->ParseCompileUnitAtIndex(i);
if (!comp_unit)
return make_string_error("Connot parse compile unit {0}.", i);
outs() << "Processing '" << comp_unit->GetFilename().AsCString()
<< "' compile unit.\n";
LineTable *lt = comp_unit->GetLineTable();
if (!lt)
return make_string_error("Can't get a line table of a compile unit.");
uint32_t count = lt->GetSize();
outs() << "The line table contains " << count << " entries.\n";
if (count == 0)
continue;
LineEntry le;
if (!lt->GetLineEntryAtIndex(0, le))
return make_string_error("Can't get a line entry of a compile unit.");
for (uint32_t i = 1; i < count; i++) {
lldb::addr_t curr_end =
le.range.GetBaseAddress().GetFileAddress() + le.range.GetByteSize();
if (!lt->GetLineEntryAtIndex(i, le))
return make_string_error("Can't get a line entry of a compile unit");
if (curr_end > le.range.GetBaseAddress().GetFileAddress())
return make_string_error(
"Line table of a compile unit is inconsistent.");
}
}
outs() << "The symbol information is verified.\n";
return Error::success();
}
Expected<Error (*)(lldb_private::Module &)> opts::symbols::getAction() {
if (Verify && DumpAST)
return make_string_error(
"Cannot both verify symbol information and dump AST.");
if (Verify) {
if (Find != FindType::None)
return make_string_error(
"Cannot both search and verify symbol information.");
if (Regex || !Context.empty() || !Name.empty() || !File.empty() ||
Line != 0)
return make_string_error(
"-regex, -context, -name, -file and -line options are not "
"applicable for symbol verification.");
return verify;
}
if (DumpAST) {
if (Find != FindType::None)
return make_string_error(
"Cannot both search and dump AST.");
if (Regex || !Context.empty() || !Name.empty() || !File.empty() ||
Line != 0)
return make_string_error(
"-regex, -context, -name, -file and -line options are not "
"applicable for dumping AST.");
return dumpAST;
}
if (Regex && !Context.empty())
return make_string_error(
"Cannot search using both regular expressions and context.");
if (Regex && !RegularExpression(Name).IsValid())
return make_string_error("`{0}` is not a valid regular expression.", Name);
if (Regex + !Context.empty() + !File.empty() >= 2)
return make_string_error(
"Only one of -regex, -context and -file may be used simultaneously.");
if (Regex && Name.empty())
return make_string_error("-regex used without a -name");
switch (Find) {
case FindType::None:
if (!Context.empty() || !Name.empty() || !File.empty() || Line != 0)
return make_string_error(
"Specify search type (-find) to use search options.");
return dumpModule;
case FindType::Function:
if (!File.empty() + (Line != 0) == 1)
return make_string_error("Both file name and line number must be "
"specified when searching a function "
"by file position.");
if (Regex + (getFunctionNameFlags() != 0) + !File.empty() >= 2)
return make_string_error("Only one of regular expression, function-flags "
"and file position may be used simultaneously "
"when searching a function.");
return findFunctions;
case FindType::Block:
if (File.empty() || Line == 0)
return make_string_error("Both file name and line number must be "
"specified when searching a block.");
if (Regex || getFunctionNameFlags() != 0)
return make_string_error("Cannot use regular expression or "
"function-flags for searching a block.");
return findBlocks;
case FindType::Namespace:
if (Regex || !File.empty() || Line != 0)
return make_string_error("Cannot search for namespaces using regular "
"expressions, file names or line numbers.");
return findNamespaces;
case FindType::Type:
if (Regex || !File.empty() || Line != 0)
return make_string_error("Cannot search for types using regular "
"expressions, file names or line numbers.");
return findTypes;
case FindType::Variable:
if (Line != 0)
return make_string_error("Cannot search for variables "
"using line numbers.");
return findVariables;
}
llvm_unreachable("Unsupported symbol action.");
}
int opts::symbols::dumpSymbols(Debugger &Dbg) {
auto ActionOr = getAction();
if (!ActionOr) {
logAllUnhandledErrors(ActionOr.takeError(), WithColor::error(), "");
return 1;
}
auto Action = *ActionOr;
int HadErrors = 0;
for (const auto &File : InputFilenames) {
outs() << "Module: " << File << "\n";
ModuleSpec Spec{FileSpec(File, false)};
Spec.GetSymbolFileSpec().SetFile(File, false, FileSpec::Style::native);
auto ModulePtr = std::make_shared<lldb_private::Module>(Spec);
SymbolVendor *Vendor = ModulePtr->GetSymbolVendor();
if (!Vendor) {
WithColor::error() << "Module has no symbol vendor.\n";
HadErrors = 1;
continue;
}
if (Error E = Action(*ModulePtr)) {
WithColor::error() << toString(std::move(E)) << "\n";
HadErrors = 1;
}
outs().flush();
}
return HadErrors;
}
static int dumpObjectFiles(Debugger &Dbg) {
LinePrinter Printer(4, llvm::outs());
int HadErrors = 0;
for (const auto &File : opts::object::InputFilenames) {
ModuleSpec Spec{FileSpec(File, false)};
auto ModulePtr = std::make_shared<lldb_private::Module>(Spec);
// Fetch symbol vendor before we get the section list to give the symbol
// vendor a chance to populate it.
ModulePtr->GetSymbolVendor();
SectionList *Sections = ModulePtr->GetSectionList();
if (!Sections) {
llvm::errs() << "Could not load sections for module " << File << "\n";
HadErrors = 1;
continue;
}
Printer.formatLine("Architecture: {0}",
ModulePtr->GetArchitecture().GetTriple().getTriple());
Printer.formatLine("UUID: {0}", ModulePtr->GetUUID().GetAsString());
size_t Count = Sections->GetNumSections(0);
Printer.formatLine("Showing {0} sections", Count);
for (size_t I = 0; I < Count; ++I) {
AutoIndent Indent(Printer, 2);
auto S = Sections->GetSectionAtIndex(I);
assert(S);
Printer.formatLine("Index: {0}", I);
Printer.formatLine("Name: {0}", S->GetName().GetStringRef());
Printer.formatLine("Type: {0}", S->GetTypeAsCString());
Printer.formatLine("VM size: {0}", S->GetByteSize());
Printer.formatLine("File size: {0}", S->GetFileSize());
if (opts::object::SectionContents) {
DataExtractor Data;
S->GetSectionData(Data);
ArrayRef<uint8_t> Bytes = {Data.GetDataStart(), Data.GetDataEnd()};
Printer.formatBinary("Data: ", Bytes, 0);
}
Printer.NewLine();
}
}
return HadErrors;
}
/// Check if two half-open intervals intersect:
/// http://world.std.com/~swmcd/steven/tech/interval.html
bool opts::irmemorymap::areAllocationsOverlapping(const AllocationT &L,
const AllocationT &R) {
return R.first < L.second && L.first < R.second;
}
bool opts::irmemorymap::evalMalloc(StringRef Line,
IRMemoryMapTestState &State) {
// ::= <label> = malloc <size> <alignment>
StringRef Label;
std::tie(Label, Line) = Line.split('=');
if (Line.empty())
return false;
Label = Label.trim();
Line = Line.trim();
size_t Size;
uint8_t Alignment;
int Matches = sscanf(Line.data(), "malloc %zu %hhu", &Size, &Alignment);
if (Matches != 2)
return false;
outs() << formatv("Command: {0} = malloc(size={1}, alignment={2})\n", Label,
Size, Alignment);
if (!isPowerOf2_32(Alignment)) {
outs() << "Malloc error: alignment is not a power of 2\n";
exit(1);
}
IRMemoryMap::AllocationPolicy AP =
UseHostOnlyAllocationPolicy ? IRMemoryMap::eAllocationPolicyHostOnly
: IRMemoryMap::eAllocationPolicyProcessOnly;
// Issue the malloc in the target process with "-rw" permissions.
const uint32_t Permissions = 0x3;
const bool ZeroMemory = false;
Status ST;
addr_t Addr =
State.Map.Malloc(Size, Alignment, Permissions, AP, ZeroMemory, ST);
if (ST.Fail()) {
outs() << formatv("Malloc error: {0}\n", ST);
return true;
}
// Print the result of the allocation before checking its validity.
outs() << formatv("Malloc: address = {0:x}\n", Addr);
// Check that the allocation is aligned.
if (!Addr || Addr % Alignment != 0) {
outs() << "Malloc error: zero or unaligned allocation detected\n";
exit(1);
}
// Check that the allocation does not overlap another allocation. Do so by
// testing each allocation which may cover the interval [Addr, EndOfRegion).
addr_t EndOfRegion = Addr + Size;
auto Probe = State.Allocations.begin();
Probe.advanceTo(Addr); //< First interval s.t stop >= Addr.
AllocationT NewAllocation = {Addr, EndOfRegion};
while (Probe != State.Allocations.end() && Probe.start() < EndOfRegion) {
AllocationT ProbeAllocation = {Probe.start(), Probe.stop()};
if (areAllocationsOverlapping(ProbeAllocation, NewAllocation)) {
outs() << "Malloc error: overlapping allocation detected"
<< formatv(", previous allocation at [{0:x}, {1:x})\n",
Probe.start(), Probe.stop());
exit(1);
}
++Probe;
}
// Insert the new allocation into the interval map. Use unique allocation IDs
// to inhibit interval coalescing.
static unsigned AllocationID = 0;
if (Size)
State.Allocations.insert(Addr, EndOfRegion, AllocationID++);
// Store the label -> address mapping.
State.Label2AddrMap[Label] = Addr;
return true;
}
bool opts::irmemorymap::evalFree(StringRef Line, IRMemoryMapTestState &State) {
// ::= free <label>
if (!Line.consume_front("free"))
return false;
StringRef Label = Line.trim();
outs() << formatv("Command: free({0})\n", Label);
auto LabelIt = State.Label2AddrMap.find(Label);
if (LabelIt == State.Label2AddrMap.end()) {
outs() << "Free error: Invalid allocation label\n";
exit(1);
}
Status ST;
addr_t Addr = LabelIt->getValue();
State.Map.Free(Addr, ST);
if (ST.Fail()) {
outs() << formatv("Free error: {0}\n", ST);
exit(1);
}
// Erase the allocation from the live interval map.
auto Interval = State.Allocations.find(Addr);
if (Interval != State.Allocations.end()) {
outs() << formatv("Free: [{0:x}, {1:x})\n", Interval.start(),
Interval.stop());
Interval.erase();
}
return true;
}
int opts::irmemorymap::evaluateMemoryMapCommands(Debugger &Dbg) {
// Set up a Target.
TargetSP Target = opts::createTarget(Dbg, irmemorymap::Target);
// Set up a Process. In order to allocate memory within a target, this
// process must be alive and must support JIT'ing.
CommandReturnObject Result;
Dbg.SetAsyncExecution(false);
CommandInterpreter &CI = Dbg.GetCommandInterpreter();
auto IssueCmd = [&](const char *Cmd) -> bool {
return CI.HandleCommand(Cmd, eLazyBoolNo, Result);
};
if (!IssueCmd("b main") || !IssueCmd("run")) {
outs() << formatv("Failed: {0}\n", Result.GetErrorData());
exit(1);
}
ProcessSP Process = Target->GetProcessSP();
if (!Process || !Process->IsAlive() || !Process->CanJIT()) {
outs() << "Cannot use process to test IRMemoryMap\n";
exit(1);
}
// Set up an IRMemoryMap and associated testing state.
IRMemoryMapTestState State(Target);
// Parse and apply commands from the command file.
std::unique_ptr<MemoryBuffer> MB = opts::openFile(irmemorymap::CommandFile);
StringRef Rest = MB->getBuffer();
while (!Rest.empty()) {
StringRef Line;
std::tie(Line, Rest) = Rest.split('\n');
Line = Line.ltrim();
if (Line.empty() || Line[0] == '#')
continue;
if (evalMalloc(Line, State))
continue;
if (evalFree(Line, State))
continue;
errs() << "Could not parse line: " << Line << "\n";
exit(1);
}
return 0;
}
int main(int argc, const char *argv[]) {
StringRef ToolName = argv[0];
sys::PrintStackTraceOnErrorSignal(ToolName);
PrettyStackTraceProgram X(argc, argv);
llvm_shutdown_obj Y;
cl::ParseCommandLineOptions(argc, argv, "LLDB Testing Utility\n");
SystemLifetimeManager DebuggerLifetime;
DebuggerLifetime.Initialize(llvm::make_unique<SystemInitializerTest>(),
nullptr);
CleanUp TerminateDebugger([&] { DebuggerLifetime.Terminate(); });
auto Dbg = lldb_private::Debugger::CreateInstance();
if (!opts::Log.empty())
Dbg->EnableLog("lldb", {"all"}, opts::Log, 0, errs());
if (opts::BreakpointSubcommand)
return opts::breakpoint::evaluateBreakpoints(*Dbg);
if (opts::ObjectFileSubcommand)
return dumpObjectFiles(*Dbg);
if (opts::SymbolsSubcommand)
return opts::symbols::dumpSymbols(*Dbg);
if (opts::IRMemoryMapSubcommand)
return opts::irmemorymap::evaluateMemoryMapCommands(*Dbg);
WithColor::error() << "No command specified.\n";
return 1;
}
Reference in New Issue View Git Blame Copy Permalink