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
|
//===- llvm/Transforms/Instrumentation/DebugIR.h - Interface ----*- 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 the interface of the DebugIR pass. For most users,
// including Instrumentation.h and calling createDebugIRPass() is sufficient and
// there is no need to include this file.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_LIB_TRANSFORMS_INSTRUMENTATION_DEBUGIR_H
#define LLVM_LIB_TRANSFORMS_INSTRUMENTATION_DEBUGIR_H
#include "llvm/Pass.h"
namespace llvm {
class DebugIR : public llvm::ModulePass {
/// If true, write a source file to disk.
bool WriteSourceToDisk;
/// Hide certain (non-essential) debug information (only relevant if
/// createSource is true.
bool HideDebugIntrinsics;
bool HideDebugMetadata;
/// The location of the source file.
std::string Directory;
std::string Filename;
/// True if a temporary file name was generated.
bool GeneratedPath;
/// True if the file name was read from the Module.
bool ParsedPath;
public:
static char ID;
const char *getPassName() const override { return "DebugIR"; }
/// Generate a file on disk to be displayed in a debugger. If Filename and
/// Directory are empty, a temporary path will be generated.
DebugIR(bool HideDebugIntrinsics, bool HideDebugMetadata,
llvm::StringRef Directory, llvm::StringRef Filename)
: ModulePass(ID), WriteSourceToDisk(true),
HideDebugIntrinsics(HideDebugIntrinsics),
HideDebugMetadata(HideDebugMetadata), Directory(Directory),
Filename(Filename), GeneratedPath(false), ParsedPath(false) {}
/// Modify input in-place; do not generate additional files, and do not hide
/// any debug intrinsics/metadata that might be present.
DebugIR()
: ModulePass(ID), WriteSourceToDisk(false), HideDebugIntrinsics(false),
HideDebugMetadata(false), GeneratedPath(false), ParsedPath(false) {}
/// Run pass on M and set Path to the source file path in the output module.
bool runOnModule(llvm::Module &M, std::string &Path);
bool runOnModule(llvm::Module &M) override;
private:
/// Returns the concatenated Directory + Filename, without error checking
std::string getPath();
/// Attempts to read source information from debug information in M, and if
/// that fails, from M's identifier. Returns true on success, false otherwise.
bool getSourceInfo(const llvm::Module &M);
/// Replace the extension of Filename with NewExtension, and return true if
/// successful. Return false if extension could not be found or Filename is
/// empty.
bool updateExtension(llvm::StringRef NewExtension);
/// Generate a temporary filename and open an fd
void generateFilename(std::unique_ptr<int> &fd);
/// Creates DWARF CU/Subroutine metadata
void createDebugInfo(llvm::Module &M,
std::unique_ptr<llvm::Module> &DisplayM);
/// Returns true if either Directory or Filename is missing, false otherwise.
bool isMissingPath();
/// Write M to disk, optionally passing in an fd to an open file which is
/// closed by this function after writing. If no fd is specified, a new file
/// is opened, written, and closed.
void writeDebugBitcode(const llvm::Module *M, int *fd = nullptr);
};
} // llvm namespace
#endif
|
