[PDB] Resolve a symbol context block info correctly

[aleksandr.urakov]

Summary

This patch allows to resolve a symbol context block info even if a function info was not requested. Also it adds the correct resolving of nested blocks (the previous implementation used function blocks instead of them).

[asmith]

LGTM

[aleksandr.urakov]

Thanks!

lldb/trunk/lit/SymbolFile/PDB/function-nested-block.test

 REQUIRES: windows, lld
 RUN: clang-cl /c /Zi %S/Inputs/FunctionNestedBlockTest.cpp /o %t.obj
 RUN: lld-link /debug:full /nodefaultlib /entry:main %t.obj /out:%t.exe
-RUN: lldb-test symbols -find=function -file FunctionNestedBlockTest.cpp -line 4 %t.exe | FileCheck %s
+RUN: lldb-test symbols -find=function -file FunctionNestedBlockTest.cpp -line 4 %t.exe | FileCheck --check-prefix=CHECK-FUNCTION %s
+RUN: lldb-test symbols -find=block -file FunctionNestedBlockTest.cpp -line 4 %t.exe | FileCheck --check-prefix=CHECK-BLOCK %s
 
-CHECK: Found 1 functions:
-CHECK: name = "{{.*}}", mangled = "{{_?}}main"
+CHECK-FUNCTION: Found 1 functions:
+CHECK-FUNCTION: name = "{{.*}}", mangled = "{{_?}}main"
+
+CHECK-BLOCK: Found 1 blocks:
+CHECK-BLOCK: Blocks: id = {{.*}}, range = {{.*}}
+CHECK-BLOCK:         id = {{.*}}, range = {{.*}}

lldb/trunk/source/Plugins/SymbolFile/PDB/SymbolFilePDB.cpp

if (!cu_sp) {
       }
       return 0;
     }
     sc.comp_unit = cu_sp.get();
     resolved_flags |= eSymbolContextCompUnit;
     lldbassert(sc.module_sp == cu_sp->GetModule());
   }
 
-  if (resolve_scope & eSymbolContextFunction) {
+  if (resolve_scope & eSymbolContextFunction ||
+      resolve_scope & eSymbolContextBlock) {
     addr_t file_vm_addr = so_addr.GetFileAddress();
     auto symbol_up =
         m_session_up->findSymbolByAddress(file_vm_addr, PDB_SymType::Function);
     if (symbol_up) {
       auto *pdb_func = llvm::dyn_cast<PDBSymbolFunc>(symbol_up.get());
       assert(pdb_func);
       auto func_uid = pdb_func->getSymIndexId();
       sc.function = sc.comp_unit->FindFunctionByUID(func_uid).get();
       if (sc.function == nullptr)
         sc.function = ParseCompileUnitFunctionForPDBFunc(*pdb_func, sc);
       if (sc.function) {
         resolved_flags |= eSymbolContextFunction;
         if (resolve_scope & eSymbolContextBlock) {
-          Block &block = sc.function->GetBlock(true);
-          sc.block = block.FindBlockByID(sc.function->GetID());
+          auto block_symbol = m_session_up->findSymbolByAddress(
+              file_vm_addr, PDB_SymType::Block);
+          auto block_id = block_symbol ? block_symbol->getSymIndexId()
+                                       : sc.function->GetID();
+          sc.block = sc.function->GetBlock(true).FindBlockByID(block_id);
           if (sc.block)
             resolved_flags |= eSymbolContextBlock;
         }
       }
     }
   }
 
   if (resolve_scope & eSymbolContextLineEntry) {

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

 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>
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 verify(lldb_private::Module &Module);
 
 static Expected<Error (*)(lldb_private::Module &)> getAction();
 static int dumpSymbols(Debugger &Dbg);
Error opts::symbols::findFunctions(lldb_private::Module &Module) {
   }
   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;
 
if (!File.empty() + (Line != 0) == 1)
                                "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)