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
|
// SPDX-License-Identifier: GPL-3.0-or-later
#ifndef RCC_CODEGEN_MACHINEOUTLINER_H
#define RCC_CODEGEN_MACHINEOUTLINER_H
#include "rcc/CodeGen/MachinePassManager.h"
#include "rcc/CodeGen/Register.h"
#include "rcc/Support/Error.h"
#include <cstdint>
#include <memory>
#include <string>
#include <unordered_map>
#include <vector>
namespace rcc {
class MachineBasicBlock;
class MachineFunction;
class MachineInstr;
class TargetDescription;
enum class MachineOutlinerInstrType : std::uint8_t {
Legal,
LegalTerminator,
Illegal,
Invisible,
};
struct MachineOutlinerFunctionProperties final {
bool LinkOnceODR = false;
bool HasSection = false;
bool HasComdat = false;
bool HasSectionPrefix = false;
};
using MachineOutlinerFunctionPropertyMap =
std::unordered_map<std::string, MachineOutlinerFunctionProperties>;
struct MachineOutlinerOptions final {
MachineOutlinerFunctionPropertyMap FunctionProperties;
};
struct MachineOutlinerCandidate final {
MachineFunction *Function = nullptr;
MachineBasicBlock *Block = nullptr;
std::vector<MachineInstr *> Instructions;
std::vector<PhysicalRegister> LiveIns;
std::vector<PhysicalRegister> DefinedRegisters;
std::uint32_t CallConstructionID = 0;
std::uint32_t CallOverhead = 0;
PhysicalRegister SaveRegister;
[[nodiscard]] MachineInstr &front() const noexcept;
[[nodiscard]] MachineInstr &back() const noexcept;
[[nodiscard]] bool containsRegister(PhysicalRegister Reg,
const TargetDescription &Target) const noexcept;
[[nodiscard]] bool isRegisterLiveAfter(PhysicalRegister Reg,
const TargetDescription &Target) const noexcept;
[[nodiscard]] bool isRegisterAvailable(PhysicalRegister Reg,
const TargetDescription &Target) const noexcept;
};
class TargetMachineOutlinerInfo {
public:
virtual ~TargetMachineOutlinerInfo();
[[nodiscard]] virtual bool isFunctionSafeToOutlineFrom(
const MachineFunction &Function,
const MachineOutlinerFunctionProperties &Properties) const noexcept = 0;
[[nodiscard]] virtual MachineOutlinerInstrType
getOutliningType(const MachineInstr &Instruction,
const MachineOutlinerFunctionProperties &Properties,
const TargetDescription &Target) const noexcept = 0;
[[nodiscard]] virtual Expected<bool> analyzeCandidate(MachineOutlinerCandidate &Candidate,
const TargetDescription &Target) const = 0;
[[nodiscard]] virtual Expected<std::uint32_t>
instructionSize(const MachineInstr &Instruction, const MachineFunction &Function,
const TargetDescription &Target) const = 0;
[[nodiscard]] virtual std::uint32_t
frameOverhead(const MachineOutlinerCandidate &Candidate) const noexcept = 0;
[[nodiscard]] virtual Expected<void>
insertOutlinedCall(MachineOutlinerCandidate &Candidate, std::string OutlinedFunctionName,
const TargetDescription &Target) const = 0;
[[nodiscard]] virtual Expected<void>
buildOutlinedFrame(MachineFunction &Function, MachineBasicBlock &Block,
const MachineOutlinerCandidate &Candidate,
const TargetDescription &Target) const = 0;
};
[[nodiscard]] std::unique_ptr<CompilationUnitPass>
createMachineOutlinerPass(std::unique_ptr<TargetMachineOutlinerInfo> TargetInfo,
MachineOutlinerOptions Options = {});
} // namespace rcc
#endif // RCC_CODEGEN_MACHINEOUTLINER_H
|
