mirror of
https://github.com/c64scene-ar/llvm-6502.git
synced 2024-08-21 18:29:46 +00:00
Finish off PR23080 by renaming the debug info IR constructs from `MD*` to `DI*`. The last of the `DIDescriptor` classes were deleted in r235356, and the last of the related typedefs removed in r235413, so this has all baked for about a week. Note: If you have out-of-tree code (like a frontend), I recommend that you get everything compiling and tests passing with the *previous* commit before updating to this one. It'll be easier to keep track of what code is using the `DIDescriptor` hierarchy and what you've already updated, and I think you're extremely unlikely to insert bugs. YMMV of course. Back to *this* commit: I did this using the rename-md-di-nodes.sh upgrade script I've attached to PR23080 (both code and testcases) and filtered through clang-format-diff.py. I edited the tests for test/Assembler/invalid-generic-debug-node-*.ll by hand since the columns were off-by-three. It should work on your out-of-tree testcases (and code, if you've followed the advice in the previous paragraph). Some of the tests are in badly named files now (e.g., test/Assembler/invalid-mdcompositetype-missing-tag.ll should be 'dicompositetype'); I'll come back and move the files in a follow-up commit. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@236120 91177308-0d34-0410-b5e6-96231b3b80d8
154 lines
5.3 KiB
C++
154 lines
5.3 KiB
C++
//===- DebugInfo.h - Debug Information Helpers ------------------*- C++ -*-===//
|
|
//
|
|
// The LLVM Compiler Infrastructure
|
|
//
|
|
// This file is distributed under the University of Illinois Open Source
|
|
// License. See LICENSE.TXT for details.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
//
|
|
// This file defines a bunch of datatypes that are useful for creating and
|
|
// walking debug info in LLVM IR form. They essentially provide wrappers around
|
|
// the information in the global variables that's needed when constructing the
|
|
// DWARF information.
|
|
//
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
#ifndef LLVM_IR_DEBUGINFO_H
|
|
#define LLVM_IR_DEBUGINFO_H
|
|
|
|
#include "llvm/ADT/DenseMap.h"
|
|
#include "llvm/ADT/SmallPtrSet.h"
|
|
#include "llvm/ADT/SmallVector.h"
|
|
#include "llvm/ADT/StringRef.h"
|
|
#include "llvm/ADT/iterator_range.h"
|
|
#include "llvm/IR/DebugInfoMetadata.h"
|
|
#include "llvm/Support/Casting.h"
|
|
#include "llvm/Support/Dwarf.h"
|
|
#include "llvm/Support/ErrorHandling.h"
|
|
#include <iterator>
|
|
|
|
namespace llvm {
|
|
class Module;
|
|
class DbgDeclareInst;
|
|
class DbgValueInst;
|
|
|
|
/// \brief Maps from type identifier to the actual MDNode.
|
|
typedef DenseMap<const MDString *, DIType *> DITypeIdentifierMap;
|
|
|
|
/// \brief Find subprogram that is enclosing this scope.
|
|
DISubprogram *getDISubprogram(const MDNode *Scope);
|
|
|
|
/// \brief Find debug info for a given function.
|
|
///
|
|
/// \returns a valid subprogram, if found. Otherwise, return \c nullptr.
|
|
DISubprogram *getDISubprogram(const Function *F);
|
|
|
|
/// \brief Find underlying composite type.
|
|
DICompositeTypeBase *getDICompositeType(DIType *T);
|
|
|
|
/// \brief Generate map by visiting all retained types.
|
|
DITypeIdentifierMap generateDITypeIdentifierMap(const NamedMDNode *CU_Nodes);
|
|
|
|
/// \brief Strip debug info in the module if it exists.
|
|
///
|
|
/// To do this, we remove all calls to the debugger intrinsics and any named
|
|
/// metadata for debugging. We also remove debug locations for instructions.
|
|
/// Return true if module is modified.
|
|
bool StripDebugInfo(Module &M);
|
|
bool stripDebugInfo(Function &F);
|
|
|
|
/// \brief Return Debug Info Metadata Version by checking module flags.
|
|
unsigned getDebugMetadataVersionFromModule(const Module &M);
|
|
|
|
/// \brief Utility to find all debug info in a module.
|
|
///
|
|
/// DebugInfoFinder tries to list all debug info MDNodes used in a module. To
|
|
/// list debug info MDNodes used by an instruction, DebugInfoFinder uses
|
|
/// processDeclare, processValue and processLocation to handle DbgDeclareInst,
|
|
/// DbgValueInst and DbgLoc attached to instructions. processModule will go
|
|
/// through all DICompileUnits in llvm.dbg.cu and list debug info MDNodes
|
|
/// used by the CUs.
|
|
class DebugInfoFinder {
|
|
public:
|
|
DebugInfoFinder() : TypeMapInitialized(false) {}
|
|
|
|
/// \brief Process entire module and collect debug info anchors.
|
|
void processModule(const Module &M);
|
|
|
|
/// \brief Process DbgDeclareInst.
|
|
void processDeclare(const Module &M, const DbgDeclareInst *DDI);
|
|
/// \brief Process DbgValueInst.
|
|
void processValue(const Module &M, const DbgValueInst *DVI);
|
|
/// \brief Process debug info location.
|
|
void processLocation(const Module &M, const DILocation *Loc);
|
|
|
|
/// \brief Clear all lists.
|
|
void reset();
|
|
|
|
private:
|
|
void InitializeTypeMap(const Module &M);
|
|
|
|
void processType(DIType *DT);
|
|
void processSubprogram(DISubprogram *SP);
|
|
void processScope(DIScope *Scope);
|
|
bool addCompileUnit(DICompileUnit *CU);
|
|
bool addGlobalVariable(DIGlobalVariable *DIG);
|
|
bool addSubprogram(DISubprogram *SP);
|
|
bool addType(DIType *DT);
|
|
bool addScope(DIScope *Scope);
|
|
|
|
public:
|
|
typedef SmallVectorImpl<DICompileUnit *>::const_iterator
|
|
compile_unit_iterator;
|
|
typedef SmallVectorImpl<DISubprogram *>::const_iterator subprogram_iterator;
|
|
typedef SmallVectorImpl<DIGlobalVariable *>::const_iterator
|
|
global_variable_iterator;
|
|
typedef SmallVectorImpl<DIType *>::const_iterator type_iterator;
|
|
typedef SmallVectorImpl<DIScope *>::const_iterator scope_iterator;
|
|
|
|
iterator_range<compile_unit_iterator> compile_units() const {
|
|
return iterator_range<compile_unit_iterator>(CUs.begin(), CUs.end());
|
|
}
|
|
|
|
iterator_range<subprogram_iterator> subprograms() const {
|
|
return iterator_range<subprogram_iterator>(SPs.begin(), SPs.end());
|
|
}
|
|
|
|
iterator_range<global_variable_iterator> global_variables() const {
|
|
return iterator_range<global_variable_iterator>(GVs.begin(), GVs.end());
|
|
}
|
|
|
|
iterator_range<type_iterator> types() const {
|
|
return iterator_range<type_iterator>(TYs.begin(), TYs.end());
|
|
}
|
|
|
|
iterator_range<scope_iterator> scopes() const {
|
|
return iterator_range<scope_iterator>(Scopes.begin(), Scopes.end());
|
|
}
|
|
|
|
unsigned compile_unit_count() const { return CUs.size(); }
|
|
unsigned global_variable_count() const { return GVs.size(); }
|
|
unsigned subprogram_count() const { return SPs.size(); }
|
|
unsigned type_count() const { return TYs.size(); }
|
|
unsigned scope_count() const { return Scopes.size(); }
|
|
|
|
private:
|
|
SmallVector<DICompileUnit *, 8> CUs;
|
|
SmallVector<DISubprogram *, 8> SPs;
|
|
SmallVector<DIGlobalVariable *, 8> GVs;
|
|
SmallVector<DIType *, 8> TYs;
|
|
SmallVector<DIScope *, 8> Scopes;
|
|
SmallPtrSet<const MDNode *, 64> NodesSeen;
|
|
DITypeIdentifierMap TypeIdentifierMap;
|
|
|
|
/// \brief Specify if TypeIdentifierMap is initialized.
|
|
bool TypeMapInitialized;
|
|
};
|
|
|
|
DenseMap<const Function *, DISubprogram *> makeSubprogramMap(const Module &M);
|
|
|
|
} // end namespace llvm
|
|
|
|
#endif
|