================ @@ -0,0 +1,300 @@ +//===-- LVIRReader.h --------------------------------------------*- C++ -*-===// +// +// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions. +// See https://llvm.org/LICENSE.txt for license information. +// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception +// +//===----------------------------------------------------------------------===// +// +// This file defines the LVIRReader class, which is used to describe a +// LLVM IR reader. +// +//===----------------------------------------------------------------------===// + +#ifndef LLVM_DEBUGINFO_LOGICALVIEW_READERS_LVIRREADER_H +#define LLVM_DEBUGINFO_LOGICALVIEW_READERS_LVIRREADER_H + +#include "llvm/DebugInfo/LogicalView/Core/LVReader.h" +#include "llvm/Transforms/Utils/DebugSSAUpdater.h" + +namespace llvm { +class DIFile; +class DINode; +class DILocation; +class DIScope; +class DISubprogram; +class DIVariable; +class BasicBlock; + +namespace object { +class IRObjectFile; +} + +namespace logicalview { + +class LVElement; +class LVLine; +class LVScopeCompileUnit; +class LVSymbol; +class LVType; + +class LVIRReader final : public LVReader { + object::IRObjectFile *BitCodeIR = nullptr; + MemoryBufferRef *TextualIR = nullptr; + + // Symbols with locations for current compile unit. + LVSymbols SymbolsWithLocations; + + LVSectionIndex SectionIndex = 0; + + const DICompileUnit *CUNode = nullptr; + + // The Dwarf Version (from the module flags). + unsigned DwarfVersion; + + // Location index for global variables. + uint64_t PoolAddressIndex = 0; + + // Whether to emit all linkage names, or just abstract subprograms. + bool UseAllLinkageNames = true; + + // Dependencies on external options (llc, etc). + bool includeMinimalInlineScopes() const; + bool useAllLinkageNames() const { return UseAllLinkageNames; } + + bool LanguageIsFortran = false; + void mapFortranLanguage(unsigned DWLang); + bool moduleIsInFortran() const { return LanguageIsFortran; } + + // Generate logical debug line before prologue. + bool GenerateLineBeforePrologue = true; + + // We assume a constante increase between instructions. + const unsigned OffsetIncrease = 4; + void updateLineOffset() { CurrentOffset += OffsetIncrease; } + + // An anonymous type for index type. + LVType *NodeIndexType = nullptr; + + std::unique_ptr<DbgValueRangeTable> DbgValueRanges; + + // Record the last assigned file index for each compile unit. + using LVIndexFiles = std::map<LVScopeCompileUnit *, size_t>; + LVIndexFiles IndexFiles; + + void updateFileIndex(LVScopeCompileUnit *CompileUnit, size_t FileIndex) { + LVIndexFiles::iterator Iter = IndexFiles.find(CompileUnit); + if (Iter == IndexFiles.end()) + IndexFiles.emplace(CompileUnit, FileIndex); + else + Iter->second = FileIndex; + } + + // Get the current assigned index file for the given compile unit. + size_t getFileIndex(LVScopeCompileUnit *CompileUnit) { + size_t FileIndex = 0; + LVIndexFiles::iterator Iter = IndexFiles.find(CompileUnit); + if (Iter != IndexFiles.end()) + FileIndex = Iter->second; + return FileIndex; + } + + // Collect the compile unit metadata files. + using LVCompileUnitFiles = std::map<const DIFile *, size_t>; + LVCompileUnitFiles CompileUnitFiles; + + size_t getOrCreateSourceID(const DIFile *File); + + // Associate the logical elements to metadata objects. + using LVMDObjects = std::map<const MDNode *, LVElement *>; + LVMDObjects MDObjects; + + void addMD(const MDNode *MD, LVElement *Element) { + if (MDObjects.find(MD) == MDObjects.end()) + MDObjects.emplace(MD, Element); + } + LVElement *getElementForSeenMD(const MDNode *MD) const { + LVMDObjects::const_iterator Iter = MDObjects.find(MD); + return Iter != MDObjects.end() ? Iter->second : nullptr; + } + LVScope *getScopeForSeenMD(const MDNode *MD) const { + return static_cast<LVScope *>(getElementForSeenMD(MD)); + } + LVSymbol *getSymbolForSeenMD(const MDNode *MD) const { + return static_cast<LVSymbol *>(getElementForSeenMD(MD)); + } + LVType *getTypeForSeenMD(const MDNode *MD) const { + return static_cast<LVType *>(getElementForSeenMD(MD)); + } + LVType *getLineForSeenMD(const MDNode *MD) const { + return static_cast<LVType *>(getElementForSeenMD(MD)); + } + + // Inlined concrete scopes with its associated inlined abstract scopes. + // When creating abstract scopes, there is no direct information to find + // the correct lexical scope. + using LVInlinedScopes = std::map<LVScope *, LVScope *>; + LVInlinedScopes InlinedScopes; + + void addInlinedScope(LVScope *ConcreteScope, LVScope *AbstractScope) { + if (InlinedScopes.find(ConcreteScope) == InlinedScopes.end()) + InlinedScopes.emplace(ConcreteScope, AbstractScope); + } + LVScope *getInlinedScope(LVScope *ConcreteScope) const { ---------------- CarlosAlbertoEnciso wrote:
The name is correct. The name issues are related to the general naming used when these functions `addInlinedScope` and `getInlinedScope` are called. https://github.com/llvm/llvm-project/pull/135440 _______________________________________________ llvm-branch-commits mailing list llvm-branch-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/llvm-branch-commits
