LLVM 20.0.0git
GISelChangeObserver.h
Go to the documentation of this file.
1//===----- llvm/CodeGen/GlobalISel/GISelChangeObserver.h --------*- 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/// \file
9/// This contains common code to allow clients to notify changes to machine
10/// instr.
11///
12//===----------------------------------------------------------------------===//
13
14#ifndef LLVM_CODEGEN_GLOBALISEL_GISELCHANGEOBSERVER_H
15#define LLVM_CODEGEN_GLOBALISEL_GISELCHANGEOBSERVER_H
16
19
20namespace llvm {
21class MachineInstr;
22class MachineRegisterInfo;
23
24/// Abstract class that contains various methods for clients to notify about
25/// changes. This should be the preferred way for APIs to notify changes.
26/// Typically calling erasingInstr/createdInstr multiple times should not affect
27/// the result. The observer would likely need to check if it was already
28/// notified earlier (consider using GISelWorkList).
30 SmallPtrSet<MachineInstr *, 4> ChangingAllUsesOfReg;
31
32public:
33 virtual ~GISelChangeObserver() = default;
34
35 /// An instruction is about to be erased.
36 virtual void erasingInstr(MachineInstr &MI) = 0;
37
38 /// An instruction has been created and inserted into the function.
39 /// Note that the instruction might not be a fully fledged instruction at this
40 /// point and won't be if the MachineFunction::Delegate is calling it. This is
41 /// because the delegate only sees the construction of the MachineInstr before
42 /// operands have been added.
43 virtual void createdInstr(MachineInstr &MI) = 0;
44
45 /// This instruction is about to be mutated in some way.
46 virtual void changingInstr(MachineInstr &MI) = 0;
47
48 /// This instruction was mutated in some way.
49 virtual void changedInstr(MachineInstr &MI) = 0;
50
51 /// All the instructions using the given register are being changed.
52 /// For convenience, finishedChangingAllUsesOfReg() will report the completion
53 /// of the changes. The use list may change between this call and
54 /// finishedChangingAllUsesOfReg().
56 /// All instructions reported as changing by changingAllUsesOfReg() have
57 /// finished being changed.
59
60};
61
62/// Simple wrapper observer that takes several observers, and calls
63/// each one for each event. If there are multiple observers (say CSE,
64/// Legalizer, Combiner), it's sufficient to register this to the machine
65/// function as the delegate.
67 public GISelChangeObserver {
69
70public:
73 // Adds an observer.
74 void addObserver(GISelChangeObserver *O) { Observers.push_back(O); }
75 // Removes an observer from the list and does nothing if observer is not
76 // present.
78 auto It = llvm::find(Observers, O);
79 if (It != Observers.end())
80 Observers.erase(It);
81 }
82 // Removes all observers
83 void clearObservers() { Observers.clear(); }
84
85 // API for Observer.
86 void erasingInstr(MachineInstr &MI) override {
87 for (auto &O : Observers)
88 O->erasingInstr(MI);
89 }
90 void createdInstr(MachineInstr &MI) override {
91 for (auto &O : Observers)
92 O->createdInstr(MI);
93 }
94 void changingInstr(MachineInstr &MI) override {
95 for (auto &O : Observers)
96 O->changingInstr(MI);
97 }
98 void changedInstr(MachineInstr &MI) override {
99 for (auto &O : Observers)
100 O->changedInstr(MI);
101 }
102 // API for MachineFunction::Delegate
105};
106
107/// A simple RAII based Delegate installer.
108/// Use this in a scope to install a delegate to the MachineFunction and reset
109/// it at the end of the scope.
111 MachineFunction &MF;
113
114public:
117};
118
119/// A simple RAII based Observer installer.
120/// Use this in a scope to install the Observer to the MachineFunction and reset
121/// it at the end of the scope.
123 MachineFunction &MF;
124
125public:
128};
129
130/// Class to install both of the above.
134
135public:
137 : DelI(MF, &Wrapper), ObsI(MF, Wrapper) {}
139};
140
141} // namespace llvm
142#endif
unsigned const MachineRegisterInfo * MRI
amdgpu aa AMDGPU Address space based Alias Analysis Wrapper
IRTranslator LLVM IR MI
unsigned Reg
This file defines the SmallPtrSet class.
ArrayRef - Represent a constant reference to an array (0 or more elements consecutively in memory),...
Definition: ArrayRef.h:41
Abstract class that contains various methods for clients to notify about changes.
virtual void changingInstr(MachineInstr &MI)=0
This instruction is about to be mutated in some way.
void finishedChangingAllUsesOfReg()
All instructions reported as changing by changingAllUsesOfReg() have finished being changed.
virtual void changedInstr(MachineInstr &MI)=0
This instruction was mutated in some way.
virtual ~GISelChangeObserver()=default
virtual void createdInstr(MachineInstr &MI)=0
An instruction has been created and inserted into the function.
virtual void erasingInstr(MachineInstr &MI)=0
An instruction is about to be erased.
void changingAllUsesOfReg(const MachineRegisterInfo &MRI, Register Reg)
All the instructions using the given register are being changed.
Simple wrapper observer that takes several observers, and calls each one for each event.
void MF_HandleInsertion(MachineInstr &MI) override
Callback after an insertion. This should not modify the MI directly.
void removeObserver(GISelChangeObserver *O)
void changedInstr(MachineInstr &MI) override
This instruction was mutated in some way.
void MF_HandleRemoval(MachineInstr &MI) override
Callback before a removal. This should not modify the MI directly.
void changingInstr(MachineInstr &MI) override
This instruction is about to be mutated in some way.
void createdInstr(MachineInstr &MI) override
An instruction has been created and inserted into the function.
void erasingInstr(MachineInstr &MI) override
An instruction is about to be erased.
void addObserver(GISelChangeObserver *O)
GISelObserverWrapper(ArrayRef< GISelChangeObserver * > Obs)
Representation of each machine instruction.
Definition: MachineInstr.h:69
MachineRegisterInfo - Keep track of information for virtual and physical registers,...
A simple RAII based Delegate installer.
Class to install both of the above.
RAIIMFObsDelInstaller(MachineFunction &MF, GISelObserverWrapper &Wrapper)
A simple RAII based Observer installer.
Wrapper class representing virtual and physical registers.
Definition: Register.h:19
SmallPtrSet - This class implements a set which is optimized for holding SmallSize or less elements.
Definition: SmallPtrSet.h:502
iterator erase(const_iterator CI)
Definition: SmallVector.h:750
void push_back(const T &Elt)
Definition: SmallVector.h:426
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1209
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
auto find(R &&Range, const T &Val)
Provide wrappers to std::find which take ranges instead of having to pass begin/end explicitly.
Definition: STLExtras.h:1742