1//===- RegisterCoalescer.h - Register Coalescing Interface ------*- C++ -*-===//
2//
3// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
4// See https://llvm.org/LICENSE.txt for license information.
5// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
6//
7//===----------------------------------------------------------------------===//
8//
9// This file contains the abstract interface for register coalescers,
10// allowing them to interact with and query register allocators.
11//
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_LIB_CODEGEN_REGISTERCOALESCER_H
15#define LLVM_LIB_CODEGEN_REGISTERCOALESCER_H
16
17#include "llvm/CodeGen/Register.h"
18
19namespace llvm {
20
21class MachineInstr;
22class TargetRegisterClass;
23class TargetRegisterInfo;
24
25 /// A helper class for register coalescers. When deciding if
26 /// two registers can be coalesced, CoalescerPair can determine if a copy
27 /// instruction would become an identity copy after coalescing.
28 class CoalescerPair {
29 const TargetRegisterInfo &TRI;
30
31 /// The register that will be left after coalescing. It can be a
32 /// virtual or physical register.
33 Register DstReg;
34
35 /// The virtual register that will be coalesced into dstReg.
36 Register SrcReg;
37
38 /// The sub-register index of the old DstReg in the new coalesced register.
39 unsigned DstIdx = 0;
40
41 /// The sub-register index of the old SrcReg in the new coalesced register.
42 unsigned SrcIdx = 0;
43
44 /// True when the original copy was a partial subregister copy.
45 bool Partial = false;
46
47 /// True when both regs are virtual and newRC is constrained.
48 bool CrossClass = false;
49
50 /// True when DstReg and SrcReg are reversed from the original
51 /// copy instruction.
52 bool Flipped = false;
53
54 /// The register class of the coalesced register, or NULL if DstReg
55 /// is a physreg. This register class may be a super-register of both
56 /// SrcReg and DstReg.
57 const TargetRegisterClass *NewRC = nullptr;
58
59 public:
60 CoalescerPair(const TargetRegisterInfo &tri) : TRI(tri) {}
61
62 /// Create a CoalescerPair representing a virtreg-to-physreg copy.
63 /// No need to call setRegisters().
64 CoalescerPair(Register VirtReg, MCRegister PhysReg,
65 const TargetRegisterInfo &tri)
66 : TRI(tri), DstReg(PhysReg), SrcReg(VirtReg) {}
67
68 /// Set registers to match the copy instruction MI. Return
69 /// false if MI is not a coalescable copy instruction.
70 bool setRegisters(const MachineInstr*);
71
72 /// Swap SrcReg and DstReg. Return false if swapping is impossible
73 /// because DstReg is a physical register, or SubIdx is set.
74 bool flip();
75
76 /// Return true if MI is a copy instruction that will become
77 /// an identity copy after coalescing.
78 bool isCoalescable(const MachineInstr*) const;
79
80 /// Return true if DstReg is a physical register.
81 bool isPhys() const { return !NewRC; }
82
83 /// Return true if the original copy instruction did not copy
84 /// the full register, but was a subreg operation.
85 bool isPartial() const { return Partial; }
86
87 /// Return true if DstReg is virtual and NewRC is a smaller
88 /// register class than DstReg's.
89 bool isCrossClass() const { return CrossClass; }
90
91 /// Return true when getSrcReg is the register being defined by
92 /// the original copy instruction.
93 bool isFlipped() const { return Flipped; }
94
95 /// Return the register (virtual or physical) that will remain
96 /// after coalescing.
97 Register getDstReg() const { return DstReg; }
98
99 /// Return the virtual register that will be coalesced away.
100 Register getSrcReg() const { return SrcReg; }
101
102 /// Return the subregister index that DstReg will be coalesced into, or 0.
103 unsigned getDstIdx() const { return DstIdx; }
104
105 /// Return the subregister index that SrcReg will be coalesced into, or 0.
106 unsigned getSrcIdx() const { return SrcIdx; }
107
108 /// Return the register class of the coalesced register.
109 const TargetRegisterClass *getNewRC() const { return NewRC; }
110 };
111
112} // end namespace llvm
113
114#endif // LLVM_LIB_CODEGEN_REGISTERCOALESCER_H
115

source code of llvm/lib/CodeGen/RegisterCoalescer.h