Add a test for reading lld-generated build-ids

[labath]

Summary

This test makes sure we are able to read the shorter build-ids which are
generated by lld.

To make this work, I've extended lldb-test to print the UUID of the
loaded object file. I've renamed the lldb-test subcommand from
"module-sections" to "object-file" to reflect the fact it prints more
than just the sections.

I've also added the module Architecture to the output, so we could avoid
printing the entire symbol file information just to get the ArchSpec
details in the lc_version_min test (which was also the only test in it's
folder not using the module-sections command).

[aprantl]

SGTM

lldb/trunk/lit/Modules/build-id-case.yaml

 # RUN: mkdir -p %t/.build-id/1b
 # RUN: yaml2obj %s > %t/.build-id/1b/8a73ac238390e32a7ff4ac8ebe4d6a41ecf5c9.debug
 # RUN: cd %t
 # RUN: llvm-objcopy --strip-all --add-gnu-debuglink=.build-id/1b/8a73ac238390e32a7ff4ac8ebe4d6a41ecf5c9.debug %t/.build-id/1b/8a73ac238390e32a7ff4ac8ebe4d6a41ecf5c9.debug %t/stripped.out
-# RUN: lldb-test module-sections %t/stripped.out | FileCheck %s
+# RUN: lldb-test object-file %t/stripped.out | FileCheck %s
 
 # CHECK: Name: .debug_frame
 # CHECK-NEXT: Type: dwarf-frame
 # CHECK-NEXT: VM size: 0
 # CHECK-NEXT: File size: 8
 
 --- !ELF
 FileHeader:

lldb/trunk/lit/Modules/compressed-sections.yaml

 # REQUIRES: zlib
 # RUN: yaml2obj %s > %t
-# RUN: lldb-test module-sections --contents %t | FileCheck %s
+# RUN: lldb-test object-file --contents %t | FileCheck %s
 --- !ELF
 FileHeader:
   Class:           ELFCLASS32
   Data:            ELFDATA2LSB
   Type:            ET_REL
   Machine:         EM_386
 Sections:
   - Name:            .hello_elf

lldb/trunk/lit/Modules/elf-duplicate-section.yaml

 # RUN: mkdir -p %t/.build-id/1b
 # RUN: yaml2obj %s > %t/.build-id/1b/8a73ac238390e32a7ff4ac8ebe4d6a41ecf5c9.debug
 # RUN: cd %t
 # RUN: llvm-objcopy --strip-all --add-gnu-debuglink=.build-id/1b/8a73ac238390e32a7ff4ac8ebe4d6a41ecf5c9.debug %t/.build-id/1b/8a73ac238390e32a7ff4ac8ebe4d6a41ecf5c9.debug %t/stripped.out
-# RUN: lldb-test module-sections %t/stripped.out | FileCheck %s
+# RUN: lldb-test object-file %t/stripped.out | FileCheck %s
 
 # Make sure that the debug_frame section is present only once.
 # CHECK: Name: .debug_frame
 # CHECK-NOT: .debug_frame
 
 --- !ELF
 FileHeader:
   Class:           ELFCLASS64

lldb/trunk/lit/Modules/elf-section-types.yaml

 # RUN: yaml2obj %s > %t
-# RUN: lldb-test module-sections %t | FileCheck %s
+# RUN: lldb-test object-file %t | FileCheck %s
 
 # CHECK: Name: .text
 # CHECK-NEXT: Type: code
 
 # CHECK: Name: .debug_info
 # CHECK-NEXT: Type: dwarf-info
 # CHECK-NEXT: VM size: 0
 # CHECK-NEXT: File size: 8

lldb/trunk/lit/Modules/lc_version_min.yaml

 # RUN: yaml2obj %s > %t.out
-# RUN: lldb-test symbols %t.out | FileCheck %s
+# RUN: lldb-test object-file %t.out | FileCheck %s
 
 # Test that the deployment target is parsed from the load commands.
-# CHECK: x86_64-apple-macosx10.9.0
+# CHECK: Architecture: x86_64-apple-macosx10.9.0
 --- !mach-o
 FileHeader:      
   magic:           0xFEEDFACF
   cputype:         0x01000007
   cpusubtype:      0x80000003
   filetype:        0x00000002
   ncmds:           14
   sizeofcmds:      728

lldb/trunk/lit/Modules/short-build-id.yaml

+# RUN: yaml2obj %s >%t
+# RUN: lldb-test object-file %t | FileCheck %s
+
+# CHECK: UUID: 333059A4-3CC3-D5F9
+
+--- !ELF
+FileHeader:      
+  Class:           ELFCLASS64
+  Data:            ELFDATA2LSB
+  Type:            ET_EXEC
+  Machine:         EM_X86_64
+  Entry:           0x0000000000201000
+Sections:        
+  - Name:            .note.gnu.build-id
+    Type:            SHT_NOTE
+    Flags:           [ SHF_ALLOC ]
+    Address:         0x0000000000200190
+    AddressAlign:    0x0000000000000004
+    Content:         040000000800000003000000474E5500333059A43CC3D5F9
+  - Name:            .text
+    Type:            SHT_PROGBITS
+    Flags:           [ SHF_ALLOC, SHF_EXECINSTR ]
+    Address:         0x0000000000201000
+    AddressAlign:    0x0000000000000004
+    Content:         ''
+...

lldb/trunk/tools/lldb-test/lldb-test.cpp

 
 using namespace lldb;
 using namespace lldb_private;
 using namespace llvm;
 
 namespace opts {
 static cl::SubCommand BreakpointSubcommand("breakpoints",
                                            "Test breakpoint resolution");
-cl::SubCommand ModuleSubcommand("module-sections",
-                                "Display LLDB Module Information");
+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(ModuleSubcommand), cl::sub(SymbolsSubcommand),
+                         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);
 
static cl::opt<bool> Persistent(
     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 module {
+namespace object {
 cl::opt<bool> SectionContents("contents",
                               cl::desc("Dump each section's contents"),
-                              cl::sub(ModuleSubcommand));
+                              cl::sub(ObjectFileSubcommand));
 cl::list<std::string> InputFilenames(cl::Positional, cl::desc("<input files>"),
-                                     cl::OneOrMore, cl::sub(ModuleSubcommand));
-} // namespace module
+                                     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,
if (Error E = Action(*ModulePtr)) {
       HadErrors = 1;
     }
 
     outs().flush();
   }
   return HadErrors;
 }
 
-static int dumpModules(Debugger &Dbg) {
+static int dumpObjectFiles(Debugger &Dbg) {
   LinePrinter Printer(4, llvm::outs());
 
   int HadErrors = 0;
-  for (const auto &File : opts::module::InputFilenames) {
+  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::module::SectionContents) {
+      if (opts::object::SectionContents) {
         DataExtractor Data;
         S->GetSectionData(Data);
         ArrayRef<uint8_t> Bytes = {Data.GetDataStart(), Data.GetDataEnd()};
         Printer.formatBinary("Data: ", Bytes, 0);
       }
       Printer.NewLine();
     }
   }
int main(int argc, const char *argv[]) {
 
   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::ModuleSubcommand)
-    return dumpModules(*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;
 }