LLVM 18.0.0git
MachineStableHash.cpp
Go to the documentation of this file.
1//===- lib/CodeGen/MachineStableHash.cpp ----------------------------------===//
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// Stable hashing for MachineInstr and MachineOperand. Useful or getting a
10// hash across runs, modules, etc.
11//
12//===----------------------------------------------------------------------===//
13
15#include "llvm/ADT/APFloat.h"
16#include "llvm/ADT/APInt.h"
17#include "llvm/ADT/ArrayRef.h"
18#include "llvm/ADT/Hashing.h"
19#include "llvm/ADT/STLExtras.h"
22#include "llvm/ADT/Statistic.h"
32#include "llvm/Config/llvm-config.h"
33#include "llvm/IR/Constants.h"
34#include "llvm/MC/MCSymbol.h"
37
38#define DEBUG_TYPE "machine-stable-hash"
39
40using namespace llvm;
41
42STATISTIC(StableHashBailingMachineBasicBlock,
43 "Number of encountered unsupported MachineOperands that were "
44 "MachineBasicBlocks while computing stable hashes");
45STATISTIC(StableHashBailingConstantPoolIndex,
46 "Number of encountered unsupported MachineOperands that were "
47 "ConstantPoolIndex while computing stable hashes");
48STATISTIC(StableHashBailingTargetIndexNoName,
49 "Number of encountered unsupported MachineOperands that were "
50 "TargetIndex with no name");
51STATISTIC(StableHashBailingGlobalAddress,
52 "Number of encountered unsupported MachineOperands that were "
53 "GlobalAddress while computing stable hashes");
54STATISTIC(StableHashBailingBlockAddress,
55 "Number of encountered unsupported MachineOperands that were "
56 "BlockAddress while computing stable hashes");
57STATISTIC(StableHashBailingMetadataUnsupported,
58 "Number of encountered unsupported MachineOperands that were "
59 "Metadata of an unsupported kind while computing stable hashes");
60
62 switch (MO.getType()) {
64 if (MO.getReg().isVirtual()) {
66 SmallVector<unsigned> DefOpcodes;
67 for (auto &Def : MRI.def_instructions(MO.getReg()))
68 DefOpcodes.push_back(Def.getOpcode());
69 return hash_combine_range(DefOpcodes.begin(), DefOpcodes.end());
70 }
71
72 // Register operands don't have target flags.
73 return stable_hash_combine(MO.getType(), MO.getReg(), MO.getSubReg(),
74 MO.isDef());
76 return stable_hash_combine(MO.getType(), MO.getTargetFlags(), MO.getImm());
79 auto Val = MO.isCImm() ? MO.getCImm()->getValue()
81 auto ValHash =
82 stable_hash_combine_array(Val.getRawData(), Val.getNumWords());
83 return hash_combine(MO.getType(), MO.getTargetFlags(), ValHash);
84 }
85
87 StableHashBailingMachineBasicBlock++;
88 return 0;
90 StableHashBailingConstantPoolIndex++;
91 return 0;
93 StableHashBailingBlockAddress++;
94 return 0;
96 StableHashBailingMetadataUnsupported++;
97 return 0;
99 StableHashBailingGlobalAddress++;
100 return 0;
102 if (const char *Name = MO.getTargetIndexName())
105 MO.getOffset());
106 StableHashBailingTargetIndexNoName++;
107 return 0;
108 }
109
113 MO.getIndex());
114
116 return hash_combine(MO.getType(), MO.getTargetFlags(), MO.getOffset(),
118
121 if (const MachineInstr *MI = MO.getParent()) {
122 if (const MachineBasicBlock *MBB = MI->getParent()) {
123 if (const MachineFunction *MF = MBB->getParent()) {
124 const TargetRegisterInfo *TRI = MF->getSubtarget().getRegisterInfo();
125 unsigned RegMaskSize =
126 MachineOperand::getRegMaskSize(TRI->getNumRegs());
127 const uint32_t *RegMask = MO.getRegMask();
128 std::vector<llvm::stable_hash> RegMaskHashes(RegMask,
129 RegMask + RegMaskSize);
130 return hash_combine(MO.getType(), MO.getTargetFlags(),
131 stable_hash_combine_array(RegMaskHashes.data(),
132 RegMaskHashes.size()));
133 }
134 }
135 }
136
137 assert(0 && "MachineOperand not associated with any MachineFunction");
138 return hash_combine(MO.getType(), MO.getTargetFlags());
139 }
140
142 std::vector<llvm::stable_hash> ShuffleMaskHashes;
143
145 MO.getShuffleMask(), std::back_inserter(ShuffleMaskHashes),
146 [](int S) -> llvm::stable_hash { return llvm::stable_hash(S); });
147
148 return hash_combine(MO.getType(), MO.getTargetFlags(),
149 stable_hash_combine_array(ShuffleMaskHashes.data(),
150 ShuffleMaskHashes.size()));
151 }
153 auto SymbolName = MO.getMCSymbol()->getName();
154 return hash_combine(MO.getType(), MO.getTargetFlags(),
155 stable_hash_combine_string(SymbolName));
156 }
159 MO.getCFIIndex());
162 MO.getIntrinsicID());
165 MO.getPredicate());
168 MO.getInstrRefOpIndex());
169 }
170 llvm_unreachable("Invalid machine operand type");
171}
172
173/// A stable hash value for machine instructions.
174/// Returns 0 if no stable hash could be computed.
175/// The hashing and equality testing functions ignore definitions so this is
176/// useful for CSE, etc.
178 bool HashConstantPoolIndices,
179 bool HashMemOperands) {
180 // Build up a buffer of hash code components.
181 SmallVector<stable_hash, 16> HashComponents;
182 HashComponents.reserve(MI.getNumOperands() + MI.getNumMemOperands() + 2);
183 HashComponents.push_back(MI.getOpcode());
184 HashComponents.push_back(MI.getFlags());
185 for (const MachineOperand &MO : MI.operands()) {
186 if (!HashVRegs && MO.isReg() && MO.isDef() && MO.getReg().isVirtual())
187 continue; // Skip virtual register defs.
188
189 if (MO.isCPI()) {
190 HashComponents.push_back(stable_hash_combine(
191 MO.getType(), MO.getTargetFlags(), MO.getIndex()));
192 continue;
193 }
194
195 stable_hash StableHash = stableHashValue(MO);
196 if (!StableHash)
197 return 0;
198 HashComponents.push_back(StableHash);
199 }
200
201 for (const auto *Op : MI.memoperands()) {
202 if (!HashMemOperands)
203 break;
204 HashComponents.push_back(static_cast<unsigned>(Op->getSize()));
205 HashComponents.push_back(static_cast<unsigned>(Op->getFlags()));
206 HashComponents.push_back(static_cast<unsigned>(Op->getOffset()));
207 HashComponents.push_back(static_cast<unsigned>(Op->getSuccessOrdering()));
208 HashComponents.push_back(static_cast<unsigned>(Op->getAddrSpace()));
209 HashComponents.push_back(static_cast<unsigned>(Op->getSyncScopeID()));
210 HashComponents.push_back(static_cast<unsigned>(Op->getBaseAlign().value()));
211 HashComponents.push_back(static_cast<unsigned>(Op->getFailureOrdering()));
212 }
213
214 return stable_hash_combine_range(HashComponents.begin(),
215 HashComponents.end());
216}
217
219 SmallVector<stable_hash> HashComponents;
220 // TODO: Hash more stuff like block alignment and branch probabilities.
221 for (const auto &MI : MBB)
222 HashComponents.push_back(stableHashValue(MI));
223 return stable_hash_combine_range(HashComponents.begin(),
224 HashComponents.end());
225}
226
228 SmallVector<stable_hash> HashComponents;
229 // TODO: Hash lots more stuff like function alignment and stack objects.
230 for (const auto &MBB : MF)
231 HashComponents.push_back(stableHashValue(MBB));
232 return stable_hash_combine_range(HashComponents.begin(),
233 HashComponents.end());
234}
unsigned const MachineRegisterInfo * MRI
MachineBasicBlock & MBB
This file declares a class to represent arbitrary precision floating point values and provide a varie...
This file implements a class to represent arbitrary precision integral constant values and operations...
This file contains the declarations for the subclasses of Constant, which represent the different fla...
std::string Name
IRTranslator LLVM IR MI
unsigned const TargetRegisterInfo * TRI
assert(ImpDefSCC.getReg()==AMDGPU::SCC &&ImpDefSCC.isDef())
This file contains some templates that are useful if you are working with the STL at all.
This file defines the SmallVector class.
This file defines the 'Statistic' class, which is designed to be an easy way to expose various metric...
#define STATISTIC(VARNAME, DESC)
Definition: Statistic.h:167
static constexpr uint32_t RegMask
Definition: aarch32.h:221
APInt bitcastToAPInt() const
Definition: APFloat.h:1210
const APFloat & getValueAPF() const
Definition: Constants.h:297
const APInt & getValue() const
Return the constant as an APInt value reference.
Definition: Constants.h:137
This class represents an Operation in the Expression.
StringRef getName() const
getName - Get the symbol name.
Definition: MCSymbol.h:205
const MachineFunction * getParent() const
Return the MachineFunction containing this basic block.
MachineRegisterInfo & getRegInfo()
getRegInfo - Return information about the registers currently in use.
Representation of each machine instruction.
Definition: MachineInstr.h:68
const MachineFunction * getMF() const
Return the function that contains the basic block that this instruction belongs to.
MachineOperand class - Representation of each machine instruction operand.
unsigned getSubReg() const
unsigned getInstrRefOpIndex() const
const ConstantInt * getCImm() const
const char * getTargetIndexName() const
getTargetIndexName - If this MachineOperand is a TargetIndex that has a name, attempt to get the name...
bool isCImm() const
isCImm - Test if this is a MO_CImmediate operand.
int64_t getImm() const
unsigned getInstrRefInstrIndex() const
ArrayRef< int > getShuffleMask() const
unsigned getCFIIndex() const
MachineInstr * getParent()
getParent - Return the instruction that this operand belongs to.
static unsigned getRegMaskSize(unsigned NumRegs)
Returns number of elements needed for a regmask array.
unsigned getTargetFlags() const
MachineOperandType getType() const
getType - Returns the MachineOperandType for this operand.
const char * getSymbolName() const
Register getReg() const
getReg - Returns the register number.
Intrinsic::ID getIntrinsicID() const
const uint32_t * getRegMask() const
getRegMask - Returns a bit mask of registers preserved by this RegMask operand.
const ConstantFP * getFPImm() const
unsigned getPredicate() const
MCSymbol * getMCSymbol() const
@ MO_CFIIndex
MCCFIInstruction index.
@ MO_Immediate
Immediate operand.
@ MO_ConstantPoolIndex
Address of indexed Constant in Constant Pool.
@ MO_MCSymbol
MCSymbol reference (for debug/eh info)
@ MO_Predicate
Generic predicate for ISel.
@ MO_GlobalAddress
Address of a global value.
@ MO_RegisterMask
Mask of preserved registers.
@ MO_ShuffleMask
Other IR Constant for ISel (shuffle masks)
@ MO_CImmediate
Immediate >64bit operand.
@ MO_BlockAddress
Address of a basic block.
@ MO_DbgInstrRef
Integer indices referring to an instruction+operand.
@ MO_MachineBasicBlock
MachineBasicBlock reference.
@ MO_FrameIndex
Abstract Stack Frame Index.
@ MO_Register
Register operand.
@ MO_ExternalSymbol
Name of external global symbol.
@ MO_IntrinsicID
Intrinsic ID for ISel.
@ MO_JumpTableIndex
Address of indexed Jump Table for switch.
@ MO_TargetIndex
Target-dependent index+offset operand.
@ MO_Metadata
Metadata reference (for debug info)
@ MO_FPImmediate
Floating-point immediate operand.
@ MO_RegisterLiveOut
Mask of live-out registers.
int64_t getOffset() const
Return the offset from the symbol in this operand.
MachineRegisterInfo - Keep track of information for virtual and physical registers,...
constexpr bool isVirtual() const
Return true if the specified register number is in the virtual register namespace.
Definition: Register.h:91
void reserve(size_type N)
Definition: SmallVector.h:667
void push_back(const T &Elt)
Definition: SmallVector.h:416
This is a 'vector' (really, a variable-sized array), optimized for the case when the array is small.
Definition: SmallVector.h:1200
TargetRegisterInfo base class - We assume that the target defines a static array of TargetRegisterDes...
#define llvm_unreachable(msg)
Marks that the current location is not supposed to be reachable.
This is an optimization pass for GlobalISel generic memory operations.
Definition: AddressRanges.h:18
stable_hash stable_hash_combine_range(InputIteratorT First, InputIteratorT Last)
Compute a stable_hash for a sequence of values.
Definition: StableHashing.h:84
OutputIt transform(R &&Range, OutputIt d_first, UnaryFunction F)
Wrapper function around std::transform to apply a function to a range and store the result elsewhere.
Definition: STLExtras.h:1932
stable_hash stable_hash_combine_array(const stable_hash *P, size_t C)
Definition: StableHashing.h:92
stable_hash stableHashValue(const MachineOperand &MO)
stable_hash stable_hash_combine(stable_hash A, stable_hash B)
Definition: StableHashing.h:51
stable_hash stable_hash_combine_string(const StringRef &S)
Definition: StableHashing.h:99
hash_code hash_combine(const Ts &...args)
Combine values into a single hash_code.
Definition: Hashing.h:613
hash_code hash_combine_range(InputIteratorT first, InputIteratorT last)
Compute a hash_code for a sequence of values.
Definition: Hashing.h:491