LLVM 17.0.0git
LVBinaryReader.h
Go to the documentation of this file.
1//===-- LVBinaryReader.h ----------------------------------------*- 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// This file defines the LVBinaryReader class, which is used to describe a
10// binary reader.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_DEBUGINFO_LOGICALVIEW_READERS_LVBINARYREADER_H
15#define LLVM_DEBUGINFO_LOGICALVIEW_READERS_LVBINARYREADER_H
16
18#include "llvm/MC/MCAsmInfo.h"
19#include "llvm/MC/MCContext.h"
22#include "llvm/MC/MCInstrInfo.h"
27#include "llvm/Object/COFF.h"
29
30namespace llvm {
31namespace logicalview {
32
33constexpr bool UpdateHighAddress = false;
34
35// Logical scope, Section address, Section index, IsComdat.
36struct LVSymbolTableEntry final {
37 LVScope *Scope = nullptr;
40 bool IsComdat = false;
41 LVSymbolTableEntry() = default;
46};
47
48// Function names extracted from the object symbol table.
49class LVSymbolTable final {
50 using LVSymbolNames = std::map<std::string, LVSymbolTableEntry>;
51 LVSymbolNames SymbolNames;
52
53public:
54 LVSymbolTable() = default;
55
56 void add(StringRef Name, LVScope *Function, LVSectionIndex SectionIndex = 0);
58 bool IsComdat);
60
65
66 void print(raw_ostream &OS);
67};
68
69class LVBinaryReader : public LVReader {
70 // Function names extracted from the object symbol table.
71 LVSymbolTable SymbolTable;
72
73 // It contains the LVLineDebug elements representing the inlined logical
74 // lines for the current compile unit, created by parsing the CodeView
75 // S_INLINESITE symbol annotation data.
76 using LVInlineeLine = std::map<LVScope *, std::unique_ptr<LVLines>>;
77 LVInlineeLine CUInlineeLines;
78
79 // Instruction lines for a logical scope. These instructions are fetched
80 // during its merge with the debug lines.
82
83 // Links the scope with its first assembler address line.
85
86 // Mapping from virtual address to section.
87 // The virtual address refers to the address where the section is loaded.
88 using LVSectionAddresses = std::map<LVSectionIndex, object::SectionRef>;
89 LVSectionAddresses SectionAddresses;
90
91 void addSectionAddress(const object::SectionRef &Section) {
92 if (SectionAddresses.find(Section.getAddress()) == SectionAddresses.end())
93 SectionAddresses.emplace(Section.getAddress(), Section);
94 }
95
96 // Scopes with ranges for current compile unit. It is used to find a line
97 // giving its exact or closest address. To support comdat functions, all
98 // addresses for the same section are recorded in the same map.
99 using LVSectionRanges = std::map<LVSectionIndex, std::unique_ptr<LVRange>>;
100 LVSectionRanges SectionRanges;
101
102 // Image base and virtual address for Executable file.
103 uint64_t ImageBaseAddress = 0;
104 uint64_t VirtualAddress = 0;
105
106 // Object sections with machine code.
107 using LVSections = std::map<LVSectionIndex, object::SectionRef>;
108 LVSections Sections;
109
110 std::vector<std::unique_ptr<LVLines>> DiscoveredLines;
111
112protected:
113 // It contains the LVLineDebug elements representing the logical lines for
114 // the current compile unit, created by parsing the debug line section.
116
117 std::unique_ptr<const MCRegisterInfo> MRI;
118 std::unique_ptr<const MCAsmInfo> MAI;
119 std::unique_ptr<const MCSubtargetInfo> STI;
120 std::unique_ptr<const MCInstrInfo> MII;
121 std::unique_ptr<const MCDisassembler> MD;
122 std::unique_ptr<MCContext> MC;
123 std::unique_ptr<MCInstPrinter> MIP;
124
125 // Loads all info for the architecture of the provided object file.
126 Error loadGenericTargetInfo(StringRef TheTriple, StringRef TheFeatures);
127
128 virtual void mapRangeAddress(const object::ObjectFile &Obj) {}
129 virtual void mapRangeAddress(const object::ObjectFile &Obj,
130 const object::SectionRef &Section,
131 bool IsComdat) {}
132
133 // Create a mapping from virtual address to section.
134 void mapVirtualAddress(const object::ObjectFile &Obj);
135 void mapVirtualAddress(const object::COFFObjectFile &COFFObj);
136
138 getSection(LVScope *Scope, LVAddress Address, LVSectionIndex SectionIndex);
139
140 void addSectionRange(LVSectionIndex SectionIndex, LVScope *Scope);
141 void addSectionRange(LVSectionIndex SectionIndex, LVScope *Scope,
142 LVAddress LowerAddress, LVAddress UpperAddress);
144
146
150 const LVNameInfo &NameInfo);
151
152 void processLines(LVLines *DebugLines, LVSectionIndex SectionIndex);
153 void processLines(LVLines *DebugLines, LVSectionIndex SectionIndex,
155
156public:
157 LVBinaryReader() = delete;
159 LVBinaryType BinaryType)
160 : LVReader(Filename, FileFormatName, W, BinaryType) {}
163 virtual ~LVBinaryReader() = default;
164
165 void addInlineeLines(LVScope *Scope, LVLines &Lines) {
166 CUInlineeLines.emplace(Scope, std::make_unique<LVLines>(std::move(Lines)));
167 }
168
169 // Convert Segment::Offset pair to absolute address.
171 LVAddress Addendum = 0) {
172 return ImageBaseAddress + (Segment * VirtualAddress) + Offset + Addendum;
173 }
174
176 LVSectionIndex SectionIndex = 0);
178 LVSectionIndex SectionIndex, bool IsComdat);
180
185
187 return Scope ? getSymbolTableIndex(Scope->getLinkageName())
189 }
190
191 void print(raw_ostream &OS) const;
192
193#if !defined(NDEBUG) || defined(LLVM_ENABLE_DUMP)
194 void dump() const { print(dbgs()); }
195#endif
196};
197
198} // end namespace logicalview
199} // end namespace llvm
200
201#endif // LLVM_DEBUGINFO_LOGICALVIEW_READERS_LVBINARYREADER_H
raw_pwrite_stream & OS
Lightweight error class with error context and mandatory checking.
Definition: Error.h:156
Tagged union holding either a T or a Error.
Definition: Error.h:470
StringRef - Represent a constant reference to a string, i.e.
Definition: StringRef.h:50
const LVSymbolTableEntry & getSymbolTableEntry(StringRef Name)
LVSectionIndex updateSymbolTable(LVScope *Function)
Expected< std::pair< LVSectionIndex, object::SectionRef > > getSection(LVScope *Scope, LVAddress Address, LVSectionIndex SectionIndex)
LVSectionIndex getSectionIndex(LVScope *Scope) override
std::unique_ptr< MCContext > MC
void includeInlineeLines(LVSectionIndex SectionIndex, LVScope *Function)
std::unique_ptr< const MCInstrInfo > MII
void addInlineeLines(LVScope *Scope, LVLines &Lines)
LVBinaryReader(const LVBinaryReader &)=delete
LVAddress getSymbolTableAddress(StringRef Name)
void print(raw_ostream &OS) const
std::unique_ptr< const MCSubtargetInfo > STI
LVAddress linearAddress(uint16_t Segment, uint32_t Offset, LVAddress Addendum=0)
void addToSymbolTable(StringRef Name, LVScope *Function, LVSectionIndex SectionIndex=0)
virtual void mapRangeAddress(const object::ObjectFile &Obj)
void processLines(LVLines *DebugLines, LVSectionIndex SectionIndex)
void mapVirtualAddress(const object::ObjectFile &Obj)
std::unique_ptr< const MCAsmInfo > MAI
LVSectionIndex getSymbolTableIndex(StringRef Name)
LVBinaryReader & operator=(const LVBinaryReader &)=delete
virtual void mapRangeAddress(const object::ObjectFile &Obj, const object::SectionRef &Section, bool IsComdat)
bool getSymbolTableIsComdat(StringRef Name)
std::unique_ptr< const MCRegisterInfo > MRI
LVBinaryReader(StringRef Filename, StringRef FileFormatName, ScopedPrinter &W, LVBinaryType BinaryType)
std::unique_ptr< const MCDisassembler > MD
LVRange * getSectionRanges(LVSectionIndex SectionIndex)
Error loadGenericTargetInfo(StringRef TheTriple, StringRef TheFeatures)
void addSectionRange(LVSectionIndex SectionIndex, LVScope *Scope)
std::unique_ptr< MCInstPrinter > MIP
The logical reader owns of all the logical elements created during the debug information parsing.
Definition: LVReader.h:60
std::string FileFormatName
Definition: LVReader.h:127
LVSectionIndex DotTextSectionIndex
Definition: LVReader.h:133
LVSectionIndex getIndex(StringRef Name)
LVAddress getAddress(StringRef Name)
void add(StringRef Name, LVScope *Function, LVSectionIndex SectionIndex=0)
LVSectionIndex update(LVScope *Function)
const LVSymbolTableEntry & getEntry(StringRef Name)
This class is the base class for all object file types.
Definition: ObjectFile.h:228
This is a value type class that represents a single section in the list of sections in the object fil...
Definition: ObjectFile.h:80
This class implements an extremely fast bulk output stream that can only output to a stream.
Definition: raw_ostream.h:52
std::pair< LVAddress, uint64_t > LVNameInfo
Definition: LVScope.h:29
constexpr bool UpdateHighAddress
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
raw_ostream & dbgs()
dbgs() - This returns a reference to a raw_ostream for debugging messages.
Definition: Debug.cpp:163
LVSymbolTableEntry(LVScope *Scope, LVAddress Address, LVSectionIndex SectionIndex, bool IsComdat)