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
|
// SPDX-License-Identifier: GPL-3.0-or-later
#ifndef RCC_CODEGEN_SLOTINDEXES_H
#define RCC_CODEGEN_SLOTINDEXES_H
#include "rcc/CodeGen/MachineIRTypes.h"
#include "rcc/CodeGen/MachinePassManager.h"
#include "rcc/CodeGen/StableID.h"
#include "rcc/Support/Error.h"
#include <compare>
#include <cstddef>
#include <cstdint>
#include <string_view>
#include <unordered_map>
#include <vector>
namespace rcc {
class MachineBasicBlock;
class MachineFunction;
class MachineInstr;
class TargetDescription;
enum class SlotIndexKind : std::uint8_t {
Block,
EarlyClobber,
Register,
Dead,
};
class SlotIndex final {
public:
constexpr SlotIndex() noexcept = default;
[[nodiscard]] static constexpr SlotIndex fromValue(std::uint64_t Value) noexcept {
return SlotIndex(Value);
}
[[nodiscard]] constexpr bool isValid() const noexcept {
return Value != 0;
}
[[nodiscard]] constexpr std::uint64_t value() const noexcept {
return Value;
}
[[nodiscard]] constexpr SlotIndexKind kind() const noexcept {
return static_cast<SlotIndexKind>(Value & KindMask);
}
[[nodiscard]] constexpr SlotIndex baseIndex() const noexcept {
return SlotIndex(Value & ~KindMask);
}
[[nodiscard]] constexpr SlotIndex withKind(SlotIndexKind Kind) const noexcept {
return isValid() ? SlotIndex((Value & ~KindMask) | static_cast<std::uint64_t>(Kind))
: SlotIndex{};
}
[[nodiscard]] constexpr SlotIndex earlyClobberSlot() const noexcept {
return withKind(SlotIndexKind::EarlyClobber);
}
[[nodiscard]] constexpr SlotIndex registerSlot() const noexcept {
return withKind(SlotIndexKind::Register);
}
[[nodiscard]] constexpr SlotIndex deadSlot() const noexcept {
return withKind(SlotIndexKind::Dead);
}
friend constexpr bool operator==(SlotIndex, SlotIndex) noexcept = default;
friend constexpr auto operator<=>(SlotIndex, SlotIndex) noexcept = default;
private:
static constexpr std::uint64_t KindMask = 3;
explicit constexpr SlotIndex(std::uint64_t Value) noexcept : Value(Value) {}
std::uint64_t Value = 0;
};
class SlotIndexesAnalysis final {
public:
class Result final {
public:
[[nodiscard]] SlotIndex instructionIndex(const MachineInstr &Instruction) const noexcept;
[[nodiscard]] SlotIndex slot(const MachineInstr &Instruction) const noexcept {
return instructionIndex(Instruction);
}
[[nodiscard]] SlotIndex blockStart(const MachineBasicBlock &Block) const noexcept;
[[nodiscard]] SlotIndex blockEnd(const MachineBasicBlock &Block) const noexcept;
[[nodiscard]] const MachineInstr *instructionFromIndex(SlotIndex Index) const noexcept;
[[nodiscard]] const MachineBasicBlock *blockFromIndex(SlotIndex Index) const noexcept;
[[nodiscard]] Expected<void> insertInstruction(const MachineInstr &Instruction);
[[nodiscard]] Expected<void> eraseInstruction(const MachineInstr &Instruction);
[[nodiscard]] Expected<void> renumber(MachineFunction &Function);
[[nodiscard]] bool invalidate(const MachineFunction &,
const PreservedAnalyses &Preserved) const noexcept;
private:
std::unordered_map<MachineInstrStableID, SlotIndex> InstructionSlots;
std::unordered_map<std::uint64_t, const MachineInstr *> SlotToInstruction;
std::unordered_map<const MachineBasicBlock *, SlotIndex> BlockStarts;
std::unordered_map<const MachineBasicBlock *, SlotIndex> BlockEnds;
std::vector<const MachineBasicBlock *> BlocksByStart;
friend class SlotIndexesAnalysis;
};
[[nodiscard]] static constexpr std::string_view name() noexcept {
return "SlotIndexes";
}
[[nodiscard]] static Expected<Result> run(MachineFunction &Function,
const TargetDescription &Target,
MachineFunctionAnalysisManager &Analyses);
};
} // namespace rcc
template <> struct std::hash<rcc::SlotIndex> {
[[nodiscard]] std::size_t operator()(rcc::SlotIndex Index) const noexcept {
return std::hash<std::uint64_t>{}(Index.value());
}
};
#endif // RCC_CODEGEN_SLOTINDEXES_H
|
