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
120
121
122
123
124
125
126
127
128
129
130
131
132
133
| //===- SourceManagerInternals.h - SourceManager Internals -------*- 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
//
//===----------------------------------------------------------------------===//
//
/// \file
/// Defines implementation details of the clang::SourceManager class.
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_CLANG_BASIC_SOURCEMANAGERINTERNALS_H
#define LLVM_CLANG_BASIC_SOURCEMANAGERINTERNALS_H
#include "clang/Basic/SourceLocation.h"
#include "clang/Basic/SourceManager.h"
#include "llvm/ADT/StringMap.h"
#include "llvm/ADT/StringRef.h"
#include "llvm/Support/Allocator.h"
#include <cassert>
#include <map>
#include <vector>
namespace clang {
//===----------------------------------------------------------------------===//
// Line Table Implementation
//===----------------------------------------------------------------------===//
struct LineEntry {
/// The offset in this file that the line entry occurs at.
unsigned FileOffset;
/// The presumed line number of this line entry: \#line 4.
unsigned LineNo;
/// The ID of the filename identified by this line entry:
/// \#line 4 "foo.c". This is -1 if not specified.
int FilenameID;
/// Set the 0 if no flags, 1 if a system header,
SrcMgr::CharacteristicKind FileKind;
/// The offset of the virtual include stack location,
/// which is manipulated by GNU linemarker directives.
///
/// If this is 0 then there is no virtual \#includer.
unsigned IncludeOffset;
static LineEntry get(unsigned Offs, unsigned Line, int Filename,
SrcMgr::CharacteristicKind FileKind,
unsigned IncludeOffset) {
LineEntry E;
E.FileOffset = Offs;
E.LineNo = Line;
E.FilenameID = Filename;
E.FileKind = FileKind;
E.IncludeOffset = IncludeOffset;
return E;
}
};
// needed for FindNearestLineEntry (upper_bound of LineEntry)
inline bool operator<(const LineEntry &lhs, const LineEntry &rhs) {
// FIXME: should check the other field?
return lhs.FileOffset < rhs.FileOffset;
}
inline bool operator<(const LineEntry &E, unsigned Offset) {
return E.FileOffset < Offset;
}
inline bool operator<(unsigned Offset, const LineEntry &E) {
return Offset < E.FileOffset;
}
/// Used to hold and unique data used to represent \#line information.
class LineTableInfo {
/// Map used to assign unique IDs to filenames in \#line directives.
///
/// This allows us to unique the filenames that
/// frequently reoccur and reference them with indices. FilenameIDs holds
/// the mapping from string -> ID, and FilenamesByID holds the mapping of ID
/// to string.
llvm::StringMap<unsigned, llvm::BumpPtrAllocator> FilenameIDs;
std::vector<llvm::StringMapEntry<unsigned>*> FilenamesByID;
/// Map from FileIDs to a list of line entries (sorted by the offset
/// at which they occur in the file).
std::map<FileID, std::vector<LineEntry>> LineEntries;
public:
void clear() {
FilenameIDs.clear();
FilenamesByID.clear();
LineEntries.clear();
}
unsigned getLineTableFilenameID(StringRef Str);
StringRef getFilename(unsigned ID) const {
assert(ID < FilenamesByID.size() && "Invalid FilenameID");
return FilenamesByID[ID]->getKey();
}
unsigned getNumFilenames() const { return FilenamesByID.size(); }
void AddLineNote(FileID FID, unsigned Offset,
unsigned LineNo, int FilenameID,
unsigned EntryExit, SrcMgr::CharacteristicKind FileKind);
/// Find the line entry nearest to FID that is before it.
///
/// If there is no line entry before \p Offset in \p FID, returns null.
const LineEntry *FindNearestLineEntry(FileID FID, unsigned Offset);
// Low-level access
using iterator = std::map<FileID, std::vector<LineEntry>>::iterator;
iterator begin() { return LineEntries.begin(); }
iterator end() { return LineEntries.end(); }
/// Add a new line entry that has already been encoded into
/// the internal representation of the line table.
void AddEntry(FileID FID, const std::vector<LineEntry> &Entries);
};
} // namespace clang
#endif // LLVM_CLANG_BASIC_SOURCEMANAGERINTERNALS_H
|