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
134
135
136
137
138
139
140
141
142
143
|
#pragma once
#ifdef __GNUC__
#pragma GCC diagnostic push
#pragma GCC diagnostic ignored "-Wunused-parameter"
#endif
//===- Line.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
//
//===----------------------------------------------------------------------===//
#ifndef LLVM_DEBUGINFO_CODEVIEW_LINE_H
#define LLVM_DEBUGINFO_CODEVIEW_LINE_H
#include "llvm/DebugInfo/CodeView/TypeIndex.h"
#include "llvm/Support/Endian.h"
#include <cinttypes>
namespace llvm {
namespace codeview {
using llvm::support::ulittle32_t;
class LineInfo {
public:
enum : uint32_t {
AlwaysStepIntoLineNumber = 0xfeefee,
NeverStepIntoLineNumber = 0xf00f00
};
enum : int { EndLineDeltaShift = 24 };
enum : uint32_t {
StartLineMask = 0x00ffffff,
EndLineDeltaMask = 0x7f000000,
StatementFlag = 0x80000000u
};
LineInfo(uint32_t StartLine, uint32_t EndLine, bool IsStatement);
LineInfo(uint32_t LineData) : LineData(LineData) {}
uint32_t getStartLine() const { return LineData & StartLineMask; }
uint32_t getLineDelta() const {
return (LineData & EndLineDeltaMask) >> EndLineDeltaShift;
}
uint32_t getEndLine() const { return getStartLine() + getLineDelta(); }
bool isStatement() const { return (LineData & StatementFlag) != 0; }
uint32_t getRawData() const { return LineData; }
bool isAlwaysStepInto() const {
return getStartLine() == AlwaysStepIntoLineNumber;
}
bool isNeverStepInto() const {
return getStartLine() == NeverStepIntoLineNumber;
}
private:
uint32_t LineData;
};
class ColumnInfo {
private:
static const uint32_t StartColumnMask = 0x0000ffffu;
static const uint32_t EndColumnMask = 0xffff0000u;
static const int EndColumnShift = 16;
public:
ColumnInfo(uint16_t StartColumn, uint16_t EndColumn) {
ColumnData =
(static_cast<uint32_t>(StartColumn) & StartColumnMask) |
((static_cast<uint32_t>(EndColumn) << EndColumnShift) & EndColumnMask);
}
uint16_t getStartColumn() const {
return static_cast<uint16_t>(ColumnData & StartColumnMask);
}
uint16_t getEndColumn() const {
return static_cast<uint16_t>((ColumnData & EndColumnMask) >>
EndColumnShift);
}
uint32_t getRawData() const { return ColumnData; }
private:
uint32_t ColumnData;
};
class Line {
private:
int32_t CodeOffset;
LineInfo LineInf;
ColumnInfo ColumnInf;
public:
Line(int32_t CodeOffset, uint32_t StartLine, uint32_t EndLine,
uint16_t StartColumn, uint16_t EndColumn, bool IsStatement)
: CodeOffset(CodeOffset), LineInf(StartLine, EndLine, IsStatement),
ColumnInf(StartColumn, EndColumn) {}
Line(int32_t CodeOffset, LineInfo LineInf, ColumnInfo ColumnInf)
: CodeOffset(CodeOffset), LineInf(LineInf), ColumnInf(ColumnInf) {}
LineInfo getLineInfo() const { return LineInf; }
ColumnInfo getColumnInfo() const { return ColumnInf; }
int32_t getCodeOffset() const { return CodeOffset; }
uint32_t getStartLine() const { return LineInf.getStartLine(); }
uint32_t getLineDelta() const { return LineInf.getLineDelta(); }
uint32_t getEndLine() const { return LineInf.getEndLine(); }
uint16_t getStartColumn() const { return ColumnInf.getStartColumn(); }
uint16_t getEndColumn() const { return ColumnInf.getEndColumn(); }
bool isStatement() const { return LineInf.isStatement(); }
bool isAlwaysStepInto() const { return LineInf.isAlwaysStepInto(); }
bool isNeverStepInto() const { return LineInf.isNeverStepInto(); }
};
} // namespace codeview
} // namespace llvm
#endif
#ifdef __GNUC__
#pragma GCC diagnostic pop
#endif
|
