1 //===-- CompileUnitIndex.cpp ------------------------------------*- C++ -*-===//
2 //
3 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4 // See https://llvm.org/LICENSE.txt for license information.
5 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6 //
7 //===----------------------------------------------------------------------===//
8 
9 #include "CompileUnitIndex.h"
10 
11 #include "PdbIndex.h"
12 #include "PdbUtil.h"
13 
14 #include "llvm/DebugInfo/CodeView/LazyRandomTypeCollection.h"
15 #include "llvm/DebugInfo/CodeView/SymbolDeserializer.h"
16 #include "llvm/DebugInfo/CodeView/TypeDeserializer.h"
17 #include "llvm/DebugInfo/MSF/MappedBlockStream.h"
18 #include "llvm/DebugInfo/PDB/Native/DbiModuleDescriptor.h"
19 #include "llvm/DebugInfo/PDB/Native/DbiStream.h"
20 #include "llvm/DebugInfo/PDB/Native/InfoStream.h"
21 #include "llvm/DebugInfo/PDB/Native/ModuleDebugStream.h"
22 #include "llvm/DebugInfo/PDB/Native/NamedStreamMap.h"
23 #include "llvm/DebugInfo/PDB/Native/TpiStream.h"
24 #include "llvm/Support/Path.h"
25 
26 #include "lldb/Utility/LLDBAssert.h"
27 
28 using namespace lldb;
29 using namespace lldb_private;
30 using namespace lldb_private::npdb;
31 using namespace llvm::codeview;
32 using namespace llvm::pdb;
33 
34 static bool IsMainFile(llvm::StringRef main, llvm::StringRef other) {
35   if (main == other)
36     return true;
37 
38   // If the files refer to the local file system, we can just ask the file
39   // system if they're equivalent.  But if the source isn't present on disk
40   // then we still want to try.
41   if (llvm::sys::fs::equivalent(main, other))
42     return true;
43 
44   llvm::SmallString<64> normalized(other);
45   llvm::sys::path::native(normalized);
46   return main.equals_lower(normalized);
47 }
48 
49 static void ParseCompile3(const CVSymbol &sym, CompilandIndexItem &cci) {
50   cci.m_compile_opts.emplace();
51   llvm::cantFail(
52       SymbolDeserializer::deserializeAs<Compile3Sym>(sym, *cci.m_compile_opts));
53 }
54 
55 static void ParseObjname(const CVSymbol &sym, CompilandIndexItem &cci) {
56   cci.m_obj_name.emplace();
57   llvm::cantFail(
58       SymbolDeserializer::deserializeAs<ObjNameSym>(sym, *cci.m_obj_name));
59 }
60 
61 static void ParseBuildInfo(PdbIndex &index, const CVSymbol &sym,
62                            CompilandIndexItem &cci) {
63   BuildInfoSym bis(SymbolRecordKind::BuildInfoSym);
64   llvm::cantFail(SymbolDeserializer::deserializeAs<BuildInfoSym>(sym, bis));
65 
66   // S_BUILDINFO just points to an LF_BUILDINFO in the IPI stream.  Let's do
67   // a little extra work to pull out the LF_BUILDINFO.
68   LazyRandomTypeCollection &types = index.ipi().typeCollection();
69   llvm::Optional<CVType> cvt = types.tryGetType(bis.BuildId);
70 
71   if (!cvt || cvt->kind() != LF_BUILDINFO)
72     return;
73 
74   BuildInfoRecord bir;
75   llvm::cantFail(TypeDeserializer::deserializeAs<BuildInfoRecord>(*cvt, bir));
76   cci.m_build_info.assign(bir.ArgIndices.begin(), bir.ArgIndices.end());
77 }
78 
79 static void ParseExtendedInfo(PdbIndex &index, CompilandIndexItem &item) {
80   const CVSymbolArray &syms = item.m_debug_stream.getSymbolArray();
81 
82   // This is a private function, it shouldn't be called if the information
83   // has already been parsed.
84   lldbassert(!item.m_obj_name);
85   lldbassert(!item.m_compile_opts);
86   lldbassert(item.m_build_info.empty());
87 
88   // We're looking for 3 things.  S_COMPILE3, S_OBJNAME, and S_BUILDINFO.
89   int found = 0;
90   for (const CVSymbol &sym : syms) {
91     switch (sym.kind()) {
92     case S_COMPILE3:
93       ParseCompile3(sym, item);
94       break;
95     case S_OBJNAME:
96       ParseObjname(sym, item);
97       break;
98     case S_BUILDINFO:
99       ParseBuildInfo(index, sym, item);
100       break;
101     default:
102       continue;
103     }
104     if (++found >= 3)
105       break;
106   }
107 }
108 
109 CompilandIndexItem::CompilandIndexItem(
110     PdbCompilandId id, llvm::pdb::ModuleDebugStreamRef debug_stream,
111     llvm::pdb::DbiModuleDescriptor descriptor)
112     : m_id(id), m_debug_stream(std::move(debug_stream)),
113       m_module_descriptor(std::move(descriptor)) {}
114 
115 CompilandIndexItem &CompileUnitIndex::GetOrCreateCompiland(uint16_t modi) {
116   auto result = m_comp_units.try_emplace(modi, nullptr);
117   if (!result.second)
118     return *result.first->second;
119 
120   // Find the module list and load its debug information stream and cache it
121   // since we need to use it for almost all interesting operations.
122   const DbiModuleList &modules = m_index.dbi().modules();
123   llvm::pdb::DbiModuleDescriptor descriptor = modules.getModuleDescriptor(modi);
124   uint16_t stream = descriptor.getModuleStreamIndex();
125   std::unique_ptr<llvm::msf::MappedBlockStream> stream_data =
126       m_index.pdb().createIndexedStream(stream);
127   llvm::pdb::ModuleDebugStreamRef debug_stream(descriptor,
128                                                std::move(stream_data));
129   cantFail(debug_stream.reload());
130 
131   std::unique_ptr<CompilandIndexItem> &cci = result.first->second;
132 
133   cci = llvm::make_unique<CompilandIndexItem>(
134       PdbCompilandId{modi}, std::move(debug_stream), std::move(descriptor));
135   ParseExtendedInfo(m_index, *cci);
136 
137   cci->m_strings.initialize(debug_stream.getSubsectionsArray());
138   PDBStringTable &strings = cantFail(m_index.pdb().getStringTable());
139   cci->m_strings.setStrings(strings.getStringTable());
140 
141   // We want the main source file to always comes first.  Note that we can't
142   // just push_back the main file onto the front because `GetMainSourceFile`
143   // computes it in such a way that it doesn't own the resulting memory.  So we
144   // have to iterate the module file list comparing each one to the main file
145   // name until we find it, and we can cache that one since the memory is backed
146   // by a contiguous chunk inside the mapped PDB.
147   llvm::SmallString<64> main_file = GetMainSourceFile(*cci);
148   std::string s = main_file.str();
149   llvm::sys::path::native(main_file);
150 
151   uint32_t file_count = modules.getSourceFileCount(modi);
152   cci->m_file_list.reserve(file_count);
153   bool found_main_file = false;
154   for (llvm::StringRef file : modules.source_files(modi)) {
155     if (!found_main_file && IsMainFile(main_file, file)) {
156       cci->m_file_list.insert(cci->m_file_list.begin(), file);
157       found_main_file = true;
158       continue;
159     }
160     cci->m_file_list.push_back(file);
161   }
162 
163   return *cci;
164 }
165 
166 const CompilandIndexItem *CompileUnitIndex::GetCompiland(uint16_t modi) const {
167   auto iter = m_comp_units.find(modi);
168   if (iter == m_comp_units.end())
169     return nullptr;
170   return iter->second.get();
171 }
172 
173 CompilandIndexItem *CompileUnitIndex::GetCompiland(uint16_t modi) {
174   auto iter = m_comp_units.find(modi);
175   if (iter == m_comp_units.end())
176     return nullptr;
177   return iter->second.get();
178 }
179 
180 llvm::SmallString<64>
181 CompileUnitIndex::GetMainSourceFile(const CompilandIndexItem &item) const {
182   // LF_BUILDINFO contains a list of arg indices which point to LF_STRING_ID
183   // records in the IPI stream.  The order of the arg indices is as follows:
184   // [0] - working directory where compiler was invoked.
185   // [1] - absolute path to compiler binary
186   // [2] - source file name
187   // [3] - path to compiler generated PDB (the /Zi PDB, although this entry gets
188   //       added even when using /Z7)
189   // [4] - full command line invocation.
190   //
191   // We need to form the path [0]\[2] to generate the full path to the main
192   // file.source
193   if (item.m_build_info.size() < 3)
194     return {""};
195 
196   LazyRandomTypeCollection &types = m_index.ipi().typeCollection();
197 
198   StringIdRecord working_dir;
199   StringIdRecord file_name;
200   CVType dir_cvt = types.getType(item.m_build_info[0]);
201   CVType file_cvt = types.getType(item.m_build_info[2]);
202   llvm::cantFail(
203       TypeDeserializer::deserializeAs<StringIdRecord>(dir_cvt, working_dir));
204   llvm::cantFail(
205       TypeDeserializer::deserializeAs<StringIdRecord>(file_cvt, file_name));
206 
207   llvm::sys::path::Style style = working_dir.String.startswith("/")
208                                      ? llvm::sys::path::Style::posix
209                                      : llvm::sys::path::Style::windows;
210   if (llvm::sys::path::is_absolute(file_name.String, style))
211     return file_name.String;
212 
213   llvm::SmallString<64> absolute_path = working_dir.String;
214   llvm::sys::path::append(absolute_path, file_name.String);
215   return absolute_path;
216 }
217