1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
|
//===- DebugImporter.h - LLVM to MLIR Debug conversion -------*- 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 implements the translation between LLVMIR debug information and
// the corresponding MLIR representation.
//
//===----------------------------------------------------------------------===//
#ifndef MLIR_LIB_TARGET_LLVMIR_DEBUGIMPORTER_H_
#define MLIR_LIB_TARGET_LLVMIR_DEBUGIMPORTER_H_
#include "mlir/Dialect/LLVMIR/LLVMDialect.h"
#include "mlir/IR/BuiltinOps.h"
#include "mlir/IR/MLIRContext.h"
#include "mlir/Support/CyclicReplacerCache.h"
#include "llvm/ADT/MapVector.h"
#include "llvm/IR/DebugInfoMetadata.h"
namespace mlir {
class Operation;
namespace LLVM {
class LLVMFuncOp;
namespace detail {
class DebugImporter {
public:
DebugImporter(ModuleOp mlirModule, bool dropDICompositeTypeElements);
/// Translates the given LLVM debug location to an MLIR location.
Location translateLoc(llvm::DILocation *loc);
/// Translates the LLVM DWARF expression metadata to MLIR.
DIExpressionAttr translateExpression(llvm::DIExpression *node);
/// Translates the LLVM DWARF global variable expression metadata to MLIR.
DIGlobalVariableExpressionAttr
translateGlobalVariableExpression(llvm::DIGlobalVariableExpression *node);
/// Translates the debug information for the given function into a Location.
/// Returns UnknownLoc if `func` has no debug information attached to it.
Location translateFuncLocation(llvm::Function *func);
/// Translates the given LLVM debug metadata to MLIR.
DINodeAttr translate(llvm::DINode *node);
/// Infers the metadata type and translates it to MLIR.
template <typename DINodeT>
auto translate(DINodeT *node) {
// Infer the MLIR type from the LLVM metadata type.
using MLIRTypeT = decltype(translateImpl(node));
return cast_or_null<MLIRTypeT>(
translate(static_cast<llvm::DINode *>(node)));
}
private:
/// Translates the given LLVM debug metadata to the corresponding attribute.
DIBasicTypeAttr translateImpl(llvm::DIBasicType *node);
DICompileUnitAttr translateImpl(llvm::DICompileUnit *node);
DICompositeTypeAttr translateImpl(llvm::DICompositeType *node);
DIDerivedTypeAttr translateImpl(llvm::DIDerivedType *node);
DIStringTypeAttr translateImpl(llvm::DIStringType *node);
DIFileAttr translateImpl(llvm::DIFile *node);
DILabelAttr translateImpl(llvm::DILabel *node);
DILexicalBlockAttr translateImpl(llvm::DILexicalBlock *node);
DILexicalBlockFileAttr translateImpl(llvm::DILexicalBlockFile *node);
DIGlobalVariableAttr translateImpl(llvm::DIGlobalVariable *node);
DILocalVariableAttr translateImpl(llvm::DILocalVariable *node);
DIVariableAttr translateImpl(llvm::DIVariable *node);
DIModuleAttr translateImpl(llvm::DIModule *node);
DINamespaceAttr translateImpl(llvm::DINamespace *node);
DIScopeAttr translateImpl(llvm::DIScope *node);
DISubprogramAttr translateImpl(llvm::DISubprogram *node);
DISubrangeAttr translateImpl(llvm::DISubrange *node);
DISubroutineTypeAttr translateImpl(llvm::DISubroutineType *node);
DITypeAttr translateImpl(llvm::DIType *node);
/// Constructs a StringAttr from the MDString if it is non-null. Returns a
/// null attribute otherwise.
StringAttr getStringAttrOrNull(llvm::MDString *stringNode);
/// Get the DistinctAttr used to represent `node` if one was already created
/// for it, or create a new one if not.
DistinctAttr getOrCreateDistinctID(llvm::DINode *node);
std::optional<DINodeAttr> createRecSelf(llvm::DINode *node);
/// A mapping between distinct LLVM debug metadata nodes and the corresponding
/// distinct id attribute.
DenseMap<llvm::DINode *, DistinctAttr> nodeToDistinctAttr;
/// A mapping between DINodes that are recursive, and their assigned recId.
/// This is kept so that repeated occurrences of the same node can reuse the
/// same ID and be deduplicated.
DenseMap<llvm::DINode *, DistinctAttr> nodeToRecId;
CyclicReplacerCache<llvm::DINode *, DINodeAttr> cache;
MLIRContext *context;
ModuleOp mlirModule;
/// An option to control if DICompositeTypes should always be imported without
/// converting their elements. If set, the option avoids the recursive
/// traversal of composite type debug information, which can be expensive for
/// adversarial inputs.
bool dropDICompositeTypeElements;
};
} // namespace detail
} // namespace LLVM
} // namespace mlir
#endif // MLIR_LIB_TARGET_LLVMIR_DEBUGIMPORTER_H_
|
