clang -cc1 -cc1 -triple amd64-unknown-openbsd7.0 -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name FunctionComparator.cpp -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=cplusplus -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 1 -fhalf-no-semantic-interposition -mframe-pointer=all -relaxed-aliasing -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -tune-cpu generic -debugger-tuning=gdb -fcoverage-compilation-dir=/usr/src/gnu/usr.bin/clang/libLLVM/obj -resource-dir /usr/local/lib/clang/13.0.0 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/AMDGPU -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Analysis -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ASMParser -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/BinaryFormat -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Bitcode -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Bitcode -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Bitstream -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /include/llvm/CodeGen -I /include/llvm/CodeGen/PBQP -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/IR -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/IR -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms/Coroutines -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ProfileData/Coverage -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/DebugInfo/CodeView -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/DebugInfo/DWARF -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/DebugInfo -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/DebugInfo/MSF -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/DebugInfo/PDB -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Demangle -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ExecutionEngine -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ExecutionEngine/JITLink -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ExecutionEngine/Orc -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Frontend -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Frontend/OpenACC -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Frontend -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Frontend/OpenMP -I /include/llvm/CodeGen/GlobalISel -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/IRReader -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms/InstCombine -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/Transforms/InstCombine -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/LTO -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Linker -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/MC -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/MC/MCParser -I /include/llvm/CodeGen/MIRParser -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Object -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Option -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Passes -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ProfileData -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms/Scalar -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/ADT -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Support -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/DebugInfo/Symbolize -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Target -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms/Utils -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms/Vectorize -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include/llvm/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Target/X86 -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include/llvm/Transforms/IPO -I /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/include -I /usr/src/gnu/usr.bin/clang/libLLVM/../include -I /usr/src/gnu/usr.bin/clang/libLLVM/obj -I /usr/src/gnu/usr.bin/clang/libLLVM/obj/../include -D NDEBUG -D __STDC_LIMIT_MACROS -D __STDC_CONSTANT_MACROS -D __STDC_FORMAT_MACROS -D LLVM_PREFIX="/usr" -D PIC -internal-isystem /usr/include/c++/v1 -internal-isystem /usr/local/lib/clang/13.0.0/include -internal-externc-isystem /usr/include -O2 -Wno-unused-parameter -Wwrite-strings -Wno-missing-field-initializers -Wno-long-long -Wno-comment -std=c++14 -fdeprecated-macro -fdebug-compilation-dir=/usr/src/gnu/usr.bin/clang/libLLVM/obj -ferror-limit 19 -fvisibility-inlines-hidden -fwrapv -D_RET_PROTECTOR -ret-protector -fno-rtti -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -fno-builtin-malloc -fno-builtin-calloc -fno-builtin-realloc -fno-builtin-valloc -fno-builtin-free -fno-builtin-strdup -fno-builtin-strndup -analyzer-output=html -faddrsig -D__GCC_HAVE_DWARF2_CFI_ASM=1 -o /home/ben/Projects/vmm/scan-build/2022-01-12-194120-40624-1 -x c++ /usr/src/gnu/usr.bin/clang/libLLVM/../../../llvm/llvm/lib/Transforms/Utils/FunctionComparator.cpp
1 | |
2 | |
3 | |
4 | |
5 | |
6 | |
7 | |
8 | |
9 | |
10 | |
11 | |
12 | |
13 | |
14 | #include "llvm/Transforms/Utils/FunctionComparator.h" |
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/SmallPtrSet.h" |
20 | #include "llvm/ADT/SmallVector.h" |
21 | #include "llvm/IR/Attributes.h" |
22 | #include "llvm/IR/BasicBlock.h" |
23 | #include "llvm/IR/Constant.h" |
24 | #include "llvm/IR/Constants.h" |
25 | #include "llvm/IR/DataLayout.h" |
26 | #include "llvm/IR/DerivedTypes.h" |
27 | #include "llvm/IR/Function.h" |
28 | #include "llvm/IR/GlobalValue.h" |
29 | #include "llvm/IR/InlineAsm.h" |
30 | #include "llvm/IR/InstrTypes.h" |
31 | #include "llvm/IR/Instruction.h" |
32 | #include "llvm/IR/Instructions.h" |
33 | #include "llvm/IR/LLVMContext.h" |
34 | #include "llvm/IR/Metadata.h" |
35 | #include "llvm/IR/Module.h" |
36 | #include "llvm/IR/Operator.h" |
37 | #include "llvm/IR/Type.h" |
38 | #include "llvm/IR/Value.h" |
39 | #include "llvm/Support/Casting.h" |
40 | #include "llvm/Support/Compiler.h" |
41 | #include "llvm/Support/Debug.h" |
42 | #include "llvm/Support/ErrorHandling.h" |
43 | #include "llvm/Support/raw_ostream.h" |
44 | #include <cassert> |
45 | #include <cstddef> |
46 | #include <cstdint> |
47 | #include <utility> |
48 | |
49 | using namespace llvm; |
50 | |
51 | #define DEBUG_TYPE "functioncomparator" |
52 | |
53 | int FunctionComparator::cmpNumbers(uint64_t L, uint64_t R) const { |
54 | if (L < R) |
| 26 | | Assuming 'L' is >= 'R', which participates in a condition later | |
|
| |
55 | return -1; |
56 | if (L > R) |
| 28 | | Assuming 'L' is <= 'R', which participates in a condition later | |
|
| |
57 | return 1; |
58 | return 0; |
| 30 | | Returning zero, which participates in a condition later | |
|
59 | } |
60 | |
61 | int FunctionComparator::cmpOrderings(AtomicOrdering L, AtomicOrdering R) const { |
62 | if ((int)L < (int)R) |
63 | return -1; |
64 | if ((int)L > (int)R) |
65 | return 1; |
66 | return 0; |
67 | } |
68 | |
69 | int FunctionComparator::cmpAPInts(const APInt &L, const APInt &R) const { |
70 | if (int Res = cmpNumbers(L.getBitWidth(), R.getBitWidth())) |
71 | return Res; |
72 | if (L.ugt(R)) |
73 | return 1; |
74 | if (R.ugt(L)) |
75 | return -1; |
76 | return 0; |
77 | } |
78 | |
79 | int FunctionComparator::cmpAPFloats(const APFloat &L, const APFloat &R) const { |
80 | |
81 | |
82 | const fltSemantics &SL = L.getSemantics(), &SR = R.getSemantics(); |
83 | if (int Res = cmpNumbers(APFloat::semanticsPrecision(SL), |
84 | APFloat::semanticsPrecision(SR))) |
85 | return Res; |
86 | if (int Res = cmpNumbers(APFloat::semanticsMaxExponent(SL), |
87 | APFloat::semanticsMaxExponent(SR))) |
88 | return Res; |
89 | if (int Res = cmpNumbers(APFloat::semanticsMinExponent(SL), |
90 | APFloat::semanticsMinExponent(SR))) |
91 | return Res; |
92 | if (int Res = cmpNumbers(APFloat::semanticsSizeInBits(SL), |
93 | APFloat::semanticsSizeInBits(SR))) |
94 | return Res; |
95 | return cmpAPInts(L.bitcastToAPInt(), R.bitcastToAPInt()); |
96 | } |
97 | |
98 | int FunctionComparator::cmpMem(StringRef L, StringRef R) const { |
99 | |
100 | if (int Res = cmpNumbers(L.size(), R.size())) |
101 | return Res; |
102 | |
103 | |
104 | |
105 | return L.compare(R); |
106 | } |
107 | |
108 | int FunctionComparator::cmpAttrs(const AttributeList L, |
109 | const AttributeList R) const { |
110 | if (int Res = cmpNumbers(L.getNumAttrSets(), R.getNumAttrSets())) |
| |
111 | return Res; |
112 | |
113 | for (unsigned i = L.index_begin(), e = L.index_end(); i != e; ++i) { |
| 4 | | Assuming 'i' is not equal to 'e' | |
|
| 5 | | Loop condition is true. Entering loop body | |
|
114 | AttributeSet LAS = L.getAttributes(i); |
115 | AttributeSet RAS = R.getAttributes(i); |
116 | AttributeSet::iterator LI = LAS.begin(), LE = LAS.end(); |
117 | AttributeSet::iterator RI = RAS.begin(), RE = RAS.end(); |
118 | for (; LI != LE && RI != RE; ++LI, ++RI) { |
| 6 | | Assuming 'LI' is not equal to 'LE' | |
|
| 7 | | Assuming 'RI' is not equal to 'RE' | |
|
| 8 | | Loop condition is true. Entering loop body | |
|
119 | Attribute LA = *LI; |
120 | Attribute RA = *RI; |
121 | if (LA.isTypeAttribute() && RA.isTypeAttribute()) { |
| 9 | | Assuming the condition is true | |
|
| 10 | | Assuming the condition is true | |
|
| |
122 | if (LA.getKindAsEnum() != RA.getKindAsEnum()) |
| 12 | | Assuming the condition is false | |
|
| |
123 | return cmpNumbers(LA.getKindAsEnum(), RA.getKindAsEnum()); |
124 | |
125 | Type *TyL = LA.getValueAsType(); |
126 | Type *TyR = RA.getValueAsType(); |
127 | if (TyL && TyR) { |
| 14 | | Assuming 'TyL' is non-null | |
|
| 15 | | Assuming 'TyR' is non-null | |
|
| |
128 | if (int Res = cmpTypes(TyL, TyR)) |
| 17 | | Calling 'FunctionComparator::cmpTypes' | |
|
129 | return Res; |
130 | continue; |
131 | } |
132 | |
133 | |
134 | |
135 | if (int Res = cmpNumbers((uint64_t)TyL, (uint64_t)TyR)) |
136 | return Res; |
137 | continue; |
138 | } |
139 | if (LA < RA) |
140 | return -1; |
141 | if (RA < LA) |
142 | return 1; |
143 | } |
144 | if (LI != LE) |
145 | return 1; |
146 | if (RI != RE) |
147 | return -1; |
148 | } |
149 | return 0; |
150 | } |
151 | |
152 | int FunctionComparator::cmpRangeMetadata(const MDNode *L, |
153 | const MDNode *R) const { |
154 | if (L == R) |
155 | return 0; |
156 | if (!L) |
157 | return -1; |
158 | if (!R) |
159 | return 1; |
160 | |
161 | |
162 | |
163 | |
164 | |
165 | |
166 | |
167 | |
168 | if (int Res = cmpNumbers(L->getNumOperands(), R->getNumOperands())) |
169 | return Res; |
170 | for (size_t I = 0; I < L->getNumOperands(); ++I) { |
171 | ConstantInt *LLow = mdconst::extract<ConstantInt>(L->getOperand(I)); |
172 | ConstantInt *RLow = mdconst::extract<ConstantInt>(R->getOperand(I)); |
173 | if (int Res = cmpAPInts(LLow->getValue(), RLow->getValue())) |
174 | return Res; |
175 | } |
176 | return 0; |
177 | } |
178 | |
179 | int FunctionComparator::cmpOperandBundlesSchema(const CallBase &LCS, |
180 | const CallBase &RCS) const { |
181 | assert(LCS.getOpcode() == RCS.getOpcode() && "Can't compare otherwise!"); |
182 | |
183 | if (int Res = |
184 | cmpNumbers(LCS.getNumOperandBundles(), RCS.getNumOperandBundles())) |
185 | return Res; |
186 | |
187 | for (unsigned I = 0, E = LCS.getNumOperandBundles(); I != E; ++I) { |
188 | auto OBL = LCS.getOperandBundleAt(I); |
189 | auto OBR = RCS.getOperandBundleAt(I); |
190 | |
191 | if (int Res = OBL.getTagName().compare(OBR.getTagName())) |
192 | return Res; |
193 | |
194 | if (int Res = cmpNumbers(OBL.Inputs.size(), OBR.Inputs.size())) |
195 | return Res; |
196 | } |
197 | |
198 | return 0; |
199 | } |
200 | |
201 | |
202 | |
203 | |
204 | |
205 | |
206 | int FunctionComparator::cmpConstants(const Constant *L, |
207 | const Constant *R) const { |
208 | Type *TyL = L->getType(); |
209 | Type *TyR = R->getType(); |
210 | |
211 | |
212 | |
213 | |
214 | int TypesRes = cmpTypes(TyL, TyR); |
215 | if (TypesRes != 0) { |
216 | |
217 | if (!TyL->isFirstClassType()) { |
218 | if (TyR->isFirstClassType()) |
219 | return -1; |
220 | |
221 | |
222 | return TypesRes; |
223 | } |
224 | if (!TyR->isFirstClassType()) { |
225 | if (TyL->isFirstClassType()) |
226 | return 1; |
227 | return TypesRes; |
228 | } |
229 | |
230 | |
231 | |
232 | unsigned TyLWidth = 0; |
233 | unsigned TyRWidth = 0; |
234 | |
235 | if (auto *VecTyL = dyn_cast<VectorType>(TyL)) |
236 | TyLWidth = VecTyL->getPrimitiveSizeInBits().getFixedSize(); |
237 | if (auto *VecTyR = dyn_cast<VectorType>(TyR)) |
238 | TyRWidth = VecTyR->getPrimitiveSizeInBits().getFixedSize(); |
239 | |
240 | if (TyLWidth != TyRWidth) |
241 | return cmpNumbers(TyLWidth, TyRWidth); |
242 | |
243 | |
244 | if (!TyLWidth) { |
245 | PointerType *PTyL = dyn_cast<PointerType>(TyL); |
246 | PointerType *PTyR = dyn_cast<PointerType>(TyR); |
247 | if (PTyL && PTyR) { |
248 | unsigned AddrSpaceL = PTyL->getAddressSpace(); |
249 | unsigned AddrSpaceR = PTyR->getAddressSpace(); |
250 | if (int Res = cmpNumbers(AddrSpaceL, AddrSpaceR)) |
251 | return Res; |
252 | } |
253 | if (PTyL) |
254 | return 1; |
255 | if (PTyR) |
256 | return -1; |
257 | |
258 | |
259 | |
260 | return TypesRes; |
261 | } |
262 | } |
263 | |
264 | |
265 | |
266 | if (L->isNullValue() && R->isNullValue()) |
267 | return TypesRes; |
268 | if (L->isNullValue() && !R->isNullValue()) |
269 | return 1; |
270 | if (!L->isNullValue() && R->isNullValue()) |
271 | return -1; |
272 | |
273 | auto GlobalValueL = const_cast<GlobalValue *>(dyn_cast<GlobalValue>(L)); |
274 | auto GlobalValueR = const_cast<GlobalValue *>(dyn_cast<GlobalValue>(R)); |
275 | if (GlobalValueL && GlobalValueR) { |
276 | return cmpGlobalValues(GlobalValueL, GlobalValueR); |
277 | } |
278 | |
279 | if (int Res = cmpNumbers(L->getValueID(), R->getValueID())) |
280 | return Res; |
281 | |
282 | if (const auto *SeqL = dyn_cast<ConstantDataSequential>(L)) { |
283 | const auto *SeqR = cast<ConstantDataSequential>(R); |
284 | |
285 | |
286 | |
287 | |
288 | |
289 | return cmpMem(SeqL->getRawDataValues(), SeqR->getRawDataValues()); |
290 | } |
291 | |
292 | switch (L->getValueID()) { |
293 | case Value::UndefValueVal: |
294 | case Value::PoisonValueVal: |
295 | case Value::ConstantTokenNoneVal: |
296 | return TypesRes; |
297 | case Value::ConstantIntVal: { |
298 | const APInt &LInt = cast<ConstantInt>(L)->getValue(); |
299 | const APInt &RInt = cast<ConstantInt>(R)->getValue(); |
300 | return cmpAPInts(LInt, RInt); |
301 | } |
302 | case Value::ConstantFPVal: { |
303 | const APFloat &LAPF = cast<ConstantFP>(L)->getValueAPF(); |
304 | const APFloat &RAPF = cast<ConstantFP>(R)->getValueAPF(); |
305 | return cmpAPFloats(LAPF, RAPF); |
306 | } |
307 | case Value::ConstantArrayVal: { |
308 | const ConstantArray *LA = cast<ConstantArray>(L); |
309 | const ConstantArray *RA = cast<ConstantArray>(R); |
310 | uint64_t NumElementsL = cast<ArrayType>(TyL)->getNumElements(); |
311 | uint64_t NumElementsR = cast<ArrayType>(TyR)->getNumElements(); |
312 | if (int Res = cmpNumbers(NumElementsL, NumElementsR)) |
313 | return Res; |
314 | for (uint64_t i = 0; i < NumElementsL; ++i) { |
315 | if (int Res = cmpConstants(cast<Constant>(LA->getOperand(i)), |
316 | cast<Constant>(RA->getOperand(i)))) |
317 | return Res; |
318 | } |
319 | return 0; |
320 | } |
321 | case Value::ConstantStructVal: { |
322 | const ConstantStruct *LS = cast<ConstantStruct>(L); |
323 | const ConstantStruct *RS = cast<ConstantStruct>(R); |
324 | unsigned NumElementsL = cast<StructType>(TyL)->getNumElements(); |
325 | unsigned NumElementsR = cast<StructType>(TyR)->getNumElements(); |
326 | if (int Res = cmpNumbers(NumElementsL, NumElementsR)) |
327 | return Res; |
328 | for (unsigned i = 0; i != NumElementsL; ++i) { |
329 | if (int Res = cmpConstants(cast<Constant>(LS->getOperand(i)), |
330 | cast<Constant>(RS->getOperand(i)))) |
331 | return Res; |
332 | } |
333 | return 0; |
334 | } |
335 | case Value::ConstantVectorVal: { |
336 | const ConstantVector *LV = cast<ConstantVector>(L); |
337 | const ConstantVector *RV = cast<ConstantVector>(R); |
338 | unsigned NumElementsL = cast<FixedVectorType>(TyL)->getNumElements(); |
339 | unsigned NumElementsR = cast<FixedVectorType>(TyR)->getNumElements(); |
340 | if (int Res = cmpNumbers(NumElementsL, NumElementsR)) |
341 | return Res; |
342 | for (uint64_t i = 0; i < NumElementsL; ++i) { |
343 | if (int Res = cmpConstants(cast<Constant>(LV->getOperand(i)), |
344 | cast<Constant>(RV->getOperand(i)))) |
345 | return Res; |
346 | } |
347 | return 0; |
348 | } |
349 | case Value::ConstantExprVal: { |
350 | const ConstantExpr *LE = cast<ConstantExpr>(L); |
351 | const ConstantExpr *RE = cast<ConstantExpr>(R); |
352 | unsigned NumOperandsL = LE->getNumOperands(); |
353 | unsigned NumOperandsR = RE->getNumOperands(); |
354 | if (int Res = cmpNumbers(NumOperandsL, NumOperandsR)) |
355 | return Res; |
356 | for (unsigned i = 0; i < NumOperandsL; ++i) { |
357 | if (int Res = cmpConstants(cast<Constant>(LE->getOperand(i)), |
358 | cast<Constant>(RE->getOperand(i)))) |
359 | return Res; |
360 | } |
361 | return 0; |
362 | } |
363 | case Value::BlockAddressVal: { |
364 | const BlockAddress *LBA = cast<BlockAddress>(L); |
365 | const BlockAddress *RBA = cast<BlockAddress>(R); |
366 | if (int Res = cmpValues(LBA->getFunction(), RBA->getFunction())) |
367 | return Res; |
368 | if (LBA->getFunction() == RBA->getFunction()) { |
369 | |
370 | |
371 | Function *F = LBA->getFunction(); |
372 | BasicBlock *LBB = LBA->getBasicBlock(); |
373 | BasicBlock *RBB = RBA->getBasicBlock(); |
374 | if (LBB == RBB) |
375 | return 0; |
376 | for (BasicBlock &BB : F->getBasicBlockList()) { |
377 | if (&BB == LBB) { |
378 | assert(&BB != RBB); |
379 | return -1; |
380 | } |
381 | if (&BB == RBB) |
382 | return 1; |
383 | } |
384 | llvm_unreachable("Basic Block Address does not point to a basic block in " |
385 | "its function."); |
386 | return -1; |
387 | } else { |
388 | |
389 | |
390 | |
391 | assert(LBA->getFunction() == FnL && RBA->getFunction() == FnR); |
392 | |
393 | |
394 | return cmpValues(LBA->getBasicBlock(), RBA->getBasicBlock()); |
395 | } |
396 | } |
397 | default: |
398 | LLVM_DEBUG(dbgs() << "Looking at valueID " << L->getValueID() << "\n"); |
399 | llvm_unreachable("Constant ValueID not recognized."); |
400 | return -1; |
401 | } |
402 | } |
403 | |
404 | int FunctionComparator::cmpGlobalValues(GlobalValue *L, GlobalValue *R) const { |
405 | uint64_t LNumber = GlobalNumbers->getNumber(L); |
406 | uint64_t RNumber = GlobalNumbers->getNumber(R); |
407 | return cmpNumbers(LNumber, RNumber); |
408 | } |
409 | |
410 | |
411 | |
412 | |
413 | int FunctionComparator::cmpTypes(Type *TyL, Type *TyR) const { |
414 | PointerType *PTyL = dyn_cast<PointerType>(TyL); |
| 18 | | Assuming 'TyL' is a 'PointerType' | |
|
415 | PointerType *PTyR = dyn_cast<PointerType>(TyR); |
| 19 | | Assuming 'TyR' is not a 'PointerType' | |
|
| 20 | | 'PTyR' initialized to a null pointer value | |
|
416 | |
417 | const DataLayout &DL = FnL->getParent()->getDataLayout(); |
418 | if (PTyL && PTyL->getAddressSpace() == 0) |
| 21 | | Assuming the condition is false | |
|
| |
419 | TyL = DL.getIntPtrType(TyL); |
420 | if (PTyR && PTyR->getAddressSpace() == 0) |
421 | TyR = DL.getIntPtrType(TyR); |
422 | |
423 | if (TyL == TyR) |
| 23 | | Assuming 'TyL' is not equal to 'TyR' | |
|
| |
424 | return 0; |
425 | |
426 | if (int Res = cmpNumbers(TyL->getTypeID(), TyR->getTypeID())) |
| 25 | | Calling 'FunctionComparator::cmpNumbers' | |
|
| 31 | | Returning from 'FunctionComparator::cmpNumbers' | |
|
| |
427 | return Res; |
428 | |
429 | switch (TyL->getTypeID()) { |
| 33 | | Control jumps to 'case PointerTyID:' at line 447 | |
|
430 | default: |
431 | llvm_unreachable("Unknown type!"); |
432 | case Type::IntegerTyID: |
433 | return cmpNumbers(cast<IntegerType>(TyL)->getBitWidth(), |
434 | cast<IntegerType>(TyR)->getBitWidth()); |
435 | |
436 | case Type::VoidTyID: |
437 | case Type::FloatTyID: |
438 | case Type::DoubleTyID: |
439 | case Type::X86_FP80TyID: |
440 | case Type::FP128TyID: |
441 | case Type::PPC_FP128TyID: |
442 | case Type::LabelTyID: |
443 | case Type::MetadataTyID: |
444 | case Type::TokenTyID: |
445 | return 0; |
446 | |
447 | case Type::PointerTyID: |
448 | assert(PTyL && PTyR && "Both types must be pointers here."); |
449 | return cmpNumbers(PTyL->getAddressSpace(), PTyR->getAddressSpace()); |
| 34 | | Called C++ object pointer is null |
|
450 | |
451 | case Type::StructTyID: { |
452 | StructType *STyL = cast<StructType>(TyL); |
453 | StructType *STyR = cast<StructType>(TyR); |
454 | if (STyL->getNumElements() != STyR->getNumElements()) |
455 | return cmpNumbers(STyL->getNumElements(), STyR->getNumElements()); |
456 | |
457 | if (STyL->isPacked() != STyR->isPacked()) |
458 | return cmpNumbers(STyL->isPacked(), STyR->isPacked()); |
459 | |
460 | for (unsigned i = 0, e = STyL->getNumElements(); i != e; ++i) { |
461 | if (int Res = cmpTypes(STyL->getElementType(i), STyR->getElementType(i))) |
462 | return Res; |
463 | } |
464 | return 0; |
465 | } |
466 | |
467 | case Type::FunctionTyID: { |
468 | FunctionType *FTyL = cast<FunctionType>(TyL); |
469 | FunctionType *FTyR = cast<FunctionType>(TyR); |
470 | if (FTyL->getNumParams() != FTyR->getNumParams()) |
471 | return cmpNumbers(FTyL->getNumParams(), FTyR->getNumParams()); |
472 | |
473 | if (FTyL->isVarArg() != FTyR->isVarArg()) |
474 | return cmpNumbers(FTyL->isVarArg(), FTyR->isVarArg()); |
475 | |
476 | if (int Res = cmpTypes(FTyL->getReturnType(), FTyR->getReturnType())) |
477 | return Res; |
478 | |
479 | for (unsigned i = 0, e = FTyL->getNumParams(); i != e; ++i) { |
480 | if (int Res = cmpTypes(FTyL->getParamType(i), FTyR->getParamType(i))) |
481 | return Res; |
482 | } |
483 | return 0; |
484 | } |
485 | |
486 | case Type::ArrayTyID: { |
487 | auto *STyL = cast<ArrayType>(TyL); |
488 | auto *STyR = cast<ArrayType>(TyR); |
489 | if (STyL->getNumElements() != STyR->getNumElements()) |
490 | return cmpNumbers(STyL->getNumElements(), STyR->getNumElements()); |
491 | return cmpTypes(STyL->getElementType(), STyR->getElementType()); |
492 | } |
493 | case Type::FixedVectorTyID: |
494 | case Type::ScalableVectorTyID: { |
495 | auto *STyL = cast<VectorType>(TyL); |
496 | auto *STyR = cast<VectorType>(TyR); |
497 | if (STyL->getElementCount().isScalable() != |
498 | STyR->getElementCount().isScalable()) |
499 | return cmpNumbers(STyL->getElementCount().isScalable(), |
500 | STyR->getElementCount().isScalable()); |
501 | if (STyL->getElementCount() != STyR->getElementCount()) |
502 | return cmpNumbers(STyL->getElementCount().getKnownMinValue(), |
503 | STyR->getElementCount().getKnownMinValue()); |
504 | return cmpTypes(STyL->getElementType(), STyR->getElementType()); |
505 | } |
506 | } |
507 | } |
508 | |
509 | |
510 | |
511 | |
512 | |
513 | int FunctionComparator::cmpOperations(const Instruction *L, |
514 | const Instruction *R, |
515 | bool &needToCmpOperands) const { |
516 | needToCmpOperands = true; |
517 | if (int Res = cmpValues(L, R)) |
518 | return Res; |
519 | |
520 | |
521 | |
522 | |
523 | |
524 | if (int Res = cmpNumbers(L->getOpcode(), R->getOpcode())) |
525 | return Res; |
526 | |
527 | if (const GetElementPtrInst *GEPL = dyn_cast<GetElementPtrInst>(L)) { |
528 | needToCmpOperands = false; |
529 | const GetElementPtrInst *GEPR = cast<GetElementPtrInst>(R); |
530 | if (int Res = |
531 | cmpValues(GEPL->getPointerOperand(), GEPR->getPointerOperand())) |
532 | return Res; |
533 | return cmpGEPs(GEPL, GEPR); |
534 | } |
535 | |
536 | if (int Res = cmpNumbers(L->getNumOperands(), R->getNumOperands())) |
537 | return Res; |
538 | |
539 | if (int Res = cmpTypes(L->getType(), R->getType())) |
540 | return Res; |
541 | |
542 | if (int Res = cmpNumbers(L->getRawSubclassOptionalData(), |
543 | R->getRawSubclassOptionalData())) |
544 | return Res; |
545 | |
546 | |
547 | |
548 | for (unsigned i = 0, e = L->getNumOperands(); i != e; ++i) { |
549 | if (int Res = |
550 | cmpTypes(L->getOperand(i)->getType(), R->getOperand(i)->getType())) |
551 | return Res; |
552 | } |
553 | |
554 | |
555 | if (const AllocaInst *AI = dyn_cast<AllocaInst>(L)) { |
556 | if (int Res = cmpTypes(AI->getAllocatedType(), |
557 | cast<AllocaInst>(R)->getAllocatedType())) |
558 | return Res; |
559 | return cmpNumbers(AI->getAlignment(), cast<AllocaInst>(R)->getAlignment()); |
560 | } |
561 | if (const LoadInst *LI = dyn_cast<LoadInst>(L)) { |
562 | if (int Res = cmpNumbers(LI->isVolatile(), cast<LoadInst>(R)->isVolatile())) |
563 | return Res; |
564 | if (int Res = |
565 | cmpNumbers(LI->getAlignment(), cast<LoadInst>(R)->getAlignment())) |
566 | return Res; |
567 | if (int Res = |
568 | cmpOrderings(LI->getOrdering(), cast<LoadInst>(R)->getOrdering())) |
569 | return Res; |
570 | if (int Res = cmpNumbers(LI->getSyncScopeID(), |
571 | cast<LoadInst>(R)->getSyncScopeID())) |
572 | return Res; |
573 | return cmpRangeMetadata( |
574 | LI->getMetadata(LLVMContext::MD_range), |
575 | cast<LoadInst>(R)->getMetadata(LLVMContext::MD_range)); |
576 | } |
577 | if (const StoreInst *SI = dyn_cast<StoreInst>(L)) { |
578 | if (int Res = |
579 | cmpNumbers(SI->isVolatile(), cast<StoreInst>(R)->isVolatile())) |
580 | return Res; |
581 | if (int Res = |
582 | cmpNumbers(SI->getAlignment(), cast<StoreInst>(R)->getAlignment())) |
583 | return Res; |
584 | if (int Res = |
585 | cmpOrderings(SI->getOrdering(), cast<StoreInst>(R)->getOrdering())) |
586 | return Res; |
587 | return cmpNumbers(SI->getSyncScopeID(), |
588 | cast<StoreInst>(R)->getSyncScopeID()); |
589 | } |
590 | if (const CmpInst *CI = dyn_cast<CmpInst>(L)) |
591 | return cmpNumbers(CI->getPredicate(), cast<CmpInst>(R)->getPredicate()); |
592 | if (auto *CBL = dyn_cast<CallBase>(L)) { |
593 | auto *CBR = cast<CallBase>(R); |
594 | if (int Res = cmpNumbers(CBL->getCallingConv(), CBR->getCallingConv())) |
595 | return Res; |
596 | if (int Res = cmpAttrs(CBL->getAttributes(), CBR->getAttributes())) |
597 | return Res; |
598 | if (int Res = cmpOperandBundlesSchema(*CBL, *CBR)) |
599 | return Res; |
600 | if (const CallInst *CI = dyn_cast<CallInst>(L)) |
601 | if (int Res = cmpNumbers(CI->getTailCallKind(), |
602 | cast<CallInst>(R)->getTailCallKind())) |
603 | return Res; |
604 | return cmpRangeMetadata(L->getMetadata(LLVMContext::MD_range), |
605 | R->getMetadata(LLVMContext::MD_range)); |
606 | } |
607 | if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(L)) { |
608 | ArrayRef<unsigned> LIndices = IVI->getIndices(); |
609 | ArrayRef<unsigned> RIndices = cast<InsertValueInst>(R)->getIndices(); |
610 | if (int Res = cmpNumbers(LIndices.size(), RIndices.size())) |
611 | return Res; |
612 | for (size_t i = 0, e = LIndices.size(); i != e; ++i) { |
613 | if (int Res = cmpNumbers(LIndices[i], RIndices[i])) |
614 | return Res; |
615 | } |
616 | return 0; |
617 | } |
618 | if (const ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(L)) { |
619 | ArrayRef<unsigned> LIndices = EVI->getIndices(); |
620 | ArrayRef<unsigned> RIndices = cast<ExtractValueInst>(R)->getIndices(); |
621 | if (int Res = cmpNumbers(LIndices.size(), RIndices.size())) |
622 | return Res; |
623 | for (size_t i = 0, e = LIndices.size(); i != e; ++i) { |
624 | if (int Res = cmpNumbers(LIndices[i], RIndices[i])) |
625 | return Res; |
626 | } |
627 | } |
628 | if (const FenceInst *FI = dyn_cast<FenceInst>(L)) { |
629 | if (int Res = |
630 | cmpOrderings(FI->getOrdering(), cast<FenceInst>(R)->getOrdering())) |
631 | return Res; |
632 | return cmpNumbers(FI->getSyncScopeID(), |
633 | cast<FenceInst>(R)->getSyncScopeID()); |
634 | } |
635 | if (const AtomicCmpXchgInst *CXI = dyn_cast<AtomicCmpXchgInst>(L)) { |
636 | if (int Res = cmpNumbers(CXI->isVolatile(), |
637 | cast<AtomicCmpXchgInst>(R)->isVolatile())) |
638 | return Res; |
639 | if (int Res = |
640 | cmpNumbers(CXI->isWeak(), cast<AtomicCmpXchgInst>(R)->isWeak())) |
641 | return Res; |
642 | if (int Res = |
643 | cmpOrderings(CXI->getSuccessOrdering(), |
644 | cast<AtomicCmpXchgInst>(R)->getSuccessOrdering())) |
645 | return Res; |
646 | if (int Res = |
647 | cmpOrderings(CXI->getFailureOrdering(), |
648 | cast<AtomicCmpXchgInst>(R)->getFailureOrdering())) |
649 | return Res; |
650 | return cmpNumbers(CXI->getSyncScopeID(), |
651 | cast<AtomicCmpXchgInst>(R)->getSyncScopeID()); |
652 | } |
653 | if (const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(L)) { |
654 | if (int Res = cmpNumbers(RMWI->getOperation(), |
655 | cast<AtomicRMWInst>(R)->getOperation())) |
656 | return Res; |
657 | if (int Res = cmpNumbers(RMWI->isVolatile(), |
658 | cast<AtomicRMWInst>(R)->isVolatile())) |
659 | return Res; |
660 | if (int Res = cmpOrderings(RMWI->getOrdering(), |
661 | cast<AtomicRMWInst>(R)->getOrdering())) |
662 | return Res; |
663 | return cmpNumbers(RMWI->getSyncScopeID(), |
664 | cast<AtomicRMWInst>(R)->getSyncScopeID()); |
665 | } |
666 | if (const ShuffleVectorInst *SVI = dyn_cast<ShuffleVectorInst>(L)) { |
667 | ArrayRef<int> LMask = SVI->getShuffleMask(); |
668 | ArrayRef<int> RMask = cast<ShuffleVectorInst>(R)->getShuffleMask(); |
669 | if (int Res = cmpNumbers(LMask.size(), RMask.size())) |
670 | return Res; |
671 | for (size_t i = 0, e = LMask.size(); i != e; ++i) { |
672 | if (int Res = cmpNumbers(LMask[i], RMask[i])) |
673 | return Res; |
674 | } |
675 | } |
676 | if (const PHINode *PNL = dyn_cast<PHINode>(L)) { |
677 | const PHINode *PNR = cast<PHINode>(R); |
678 | |
679 | |
680 | |
681 | for (unsigned i = 0, e = PNL->getNumIncomingValues(); i != e; ++i) { |
682 | if (int Res = |
683 | cmpValues(PNL->getIncomingBlock(i), PNR->getIncomingBlock(i))) |
684 | return Res; |
685 | } |
686 | } |
687 | return 0; |
688 | } |
689 | |
690 | |
691 | |
692 | int FunctionComparator::cmpGEPs(const GEPOperator *GEPL, |
693 | const GEPOperator *GEPR) const { |
694 | unsigned int ASL = GEPL->getPointerAddressSpace(); |
695 | unsigned int ASR = GEPR->getPointerAddressSpace(); |
696 | |
697 | if (int Res = cmpNumbers(ASL, ASR)) |
698 | return Res; |
699 | |
700 | |
701 | |
702 | const DataLayout &DL = FnL->getParent()->getDataLayout(); |
703 | unsigned BitWidth = DL.getPointerSizeInBits(ASL); |
704 | APInt OffsetL(BitWidth, 0), OffsetR(BitWidth, 0); |
705 | if (GEPL->accumulateConstantOffset(DL, OffsetL) && |
706 | GEPR->accumulateConstantOffset(DL, OffsetR)) |
707 | return cmpAPInts(OffsetL, OffsetR); |
708 | if (int Res = |
709 | cmpTypes(GEPL->getSourceElementType(), GEPR->getSourceElementType())) |
710 | return Res; |
711 | |
712 | if (int Res = cmpNumbers(GEPL->getNumOperands(), GEPR->getNumOperands())) |
713 | return Res; |
714 | |
715 | for (unsigned i = 0, e = GEPL->getNumOperands(); i != e; ++i) { |
716 | if (int Res = cmpValues(GEPL->getOperand(i), GEPR->getOperand(i))) |
717 | return Res; |
718 | } |
719 | |
720 | return 0; |
721 | } |
722 | |
723 | int FunctionComparator::cmpInlineAsm(const InlineAsm *L, |
724 | const InlineAsm *R) const { |
725 | |
726 | |
727 | if (L == R) |
728 | return 0; |
729 | if (int Res = cmpTypes(L->getFunctionType(), R->getFunctionType())) |
730 | return Res; |
731 | if (int Res = cmpMem(L->getAsmString(), R->getAsmString())) |
732 | return Res; |
733 | if (int Res = cmpMem(L->getConstraintString(), R->getConstraintString())) |
734 | return Res; |
735 | if (int Res = cmpNumbers(L->hasSideEffects(), R->hasSideEffects())) |
736 | return Res; |
737 | if (int Res = cmpNumbers(L->isAlignStack(), R->isAlignStack())) |
738 | return Res; |
739 | if (int Res = cmpNumbers(L->getDialect(), R->getDialect())) |
740 | return Res; |
741 | assert(L->getFunctionType() != R->getFunctionType()); |
742 | return 0; |
743 | } |
744 | |
745 | |
746 | |
747 | |
748 | |
749 | int FunctionComparator::cmpValues(const Value *L, const Value *R) const { |
750 | |
751 | if (L == FnL) { |
752 | if (R == FnR) |
753 | return 0; |
754 | return -1; |
755 | } |
756 | if (R == FnR) { |
757 | if (L == FnL) |
758 | return 0; |
759 | return 1; |
760 | } |
761 | |
762 | const Constant *ConstL = dyn_cast<Constant>(L); |
763 | const Constant *ConstR = dyn_cast<Constant>(R); |
764 | if (ConstL && ConstR) { |
765 | if (L == R) |
766 | return 0; |
767 | return cmpConstants(ConstL, ConstR); |
768 | } |
769 | |
770 | if (ConstL) |
771 | return 1; |
772 | if (ConstR) |
773 | return -1; |
774 | |
775 | const InlineAsm *InlineAsmL = dyn_cast<InlineAsm>(L); |
776 | const InlineAsm *InlineAsmR = dyn_cast<InlineAsm>(R); |
777 | |
778 | if (InlineAsmL && InlineAsmR) |
779 | return cmpInlineAsm(InlineAsmL, InlineAsmR); |
780 | if (InlineAsmL) |
781 | return 1; |
782 | if (InlineAsmR) |
783 | return -1; |
784 | |
785 | auto LeftSN = sn_mapL.insert(std::make_pair(L, sn_mapL.size())), |
786 | RightSN = sn_mapR.insert(std::make_pair(R, sn_mapR.size())); |
787 | |
788 | return cmpNumbers(LeftSN.first->second, RightSN.first->second); |
789 | } |
790 | |
791 | |
792 | int FunctionComparator::cmpBasicBlocks(const BasicBlock *BBL, |
793 | const BasicBlock *BBR) const { |
794 | BasicBlock::const_iterator InstL = BBL->begin(), InstLE = BBL->end(); |
795 | BasicBlock::const_iterator InstR = BBR->begin(), InstRE = BBR->end(); |
796 | |
797 | do { |
798 | bool needToCmpOperands = true; |
799 | if (int Res = cmpOperations(&*InstL, &*InstR, needToCmpOperands)) |
800 | return Res; |
801 | if (needToCmpOperands) { |
802 | assert(InstL->getNumOperands() == InstR->getNumOperands()); |
803 | |
804 | for (unsigned i = 0, e = InstL->getNumOperands(); i != e; ++i) { |
805 | Value *OpL = InstL->getOperand(i); |
806 | Value *OpR = InstR->getOperand(i); |
807 | if (int Res = cmpValues(OpL, OpR)) |
808 | return Res; |
809 | |
810 | assert(cmpTypes(OpL->getType(), OpR->getType()) == 0); |
811 | } |
812 | } |
813 | |
814 | ++InstL; |
815 | ++InstR; |
816 | } while (InstL != InstLE && InstR != InstRE); |
817 | |
818 | if (InstL != InstLE && InstR == InstRE) |
819 | return 1; |
820 | if (InstL == InstLE && InstR != InstRE) |
821 | return -1; |
822 | return 0; |
823 | } |
824 | |
825 | int FunctionComparator::compareSignature() const { |
826 | if (int Res = cmpAttrs(FnL->getAttributes(), FnR->getAttributes())) |
| 2 | | Calling 'FunctionComparator::cmpAttrs' | |
|
827 | return Res; |
828 | |
829 | if (int Res = cmpNumbers(FnL->hasGC(), FnR->hasGC())) |
830 | return Res; |
831 | |
832 | if (FnL->hasGC()) { |
833 | if (int Res = cmpMem(FnL->getGC(), FnR->getGC())) |
834 | return Res; |
835 | } |
836 | |
837 | if (int Res = cmpNumbers(FnL->hasSection(), FnR->hasSection())) |
838 | return Res; |
839 | |
840 | if (FnL->hasSection()) { |
841 | if (int Res = cmpMem(FnL->getSection(), FnR->getSection())) |
842 | return Res; |
843 | } |
844 | |
845 | if (int Res = cmpNumbers(FnL->isVarArg(), FnR->isVarArg())) |
846 | return Res; |
847 | |
848 | |
849 | |
850 | if (int Res = cmpNumbers(FnL->getCallingConv(), FnR->getCallingConv())) |
851 | return Res; |
852 | |
853 | if (int Res = cmpTypes(FnL->getFunctionType(), FnR->getFunctionType())) |
854 | return Res; |
855 | |
856 | assert(FnL->arg_size() == FnR->arg_size() && |
857 | "Identically typed functions have different numbers of args!"); |
858 | |
859 | |
860 | |
861 | for (Function::const_arg_iterator ArgLI = FnL->arg_begin(), |
862 | ArgRI = FnR->arg_begin(), |
863 | ArgLE = FnL->arg_end(); |
864 | ArgLI != ArgLE; ++ArgLI, ++ArgRI) { |
865 | if (cmpValues(&*ArgLI, &*ArgRI) != 0) |
866 | llvm_unreachable("Arguments repeat!"); |
867 | } |
868 | return 0; |
869 | } |
870 | |
871 | |
872 | int FunctionComparator::compare() { |
873 | beginCompare(); |
874 | |
875 | if (int Res = compareSignature()) |
| 1 | Calling 'FunctionComparator::compareSignature' | |
|
876 | return Res; |
877 | |
878 | |
879 | |
880 | |
881 | |
882 | SmallVector<const BasicBlock *, 8> FnLBBs, FnRBBs; |
883 | SmallPtrSet<const BasicBlock *, 32> VisitedBBs; |
884 | |
885 | FnLBBs.push_back(&FnL->getEntryBlock()); |
886 | FnRBBs.push_back(&FnR->getEntryBlock()); |
887 | |
888 | VisitedBBs.insert(FnLBBs[0]); |
889 | while (!FnLBBs.empty()) { |
890 | const BasicBlock *BBL = FnLBBs.pop_back_val(); |
891 | const BasicBlock *BBR = FnRBBs.pop_back_val(); |
892 | |
893 | if (int Res = cmpValues(BBL, BBR)) |
894 | return Res; |
895 | |
896 | if (int Res = cmpBasicBlocks(BBL, BBR)) |
897 | return Res; |
898 | |
899 | const Instruction *TermL = BBL->getTerminator(); |
900 | const Instruction *TermR = BBR->getTerminator(); |
901 | |
902 | assert(TermL->getNumSuccessors() == TermR->getNumSuccessors()); |
903 | for (unsigned i = 0, e = TermL->getNumSuccessors(); i != e; ++i) { |
904 | if (!VisitedBBs.insert(TermL->getSuccessor(i)).second) |
905 | continue; |
906 | |
907 | FnLBBs.push_back(TermL->getSuccessor(i)); |
908 | FnRBBs.push_back(TermR->getSuccessor(i)); |
909 | } |
910 | } |
911 | return 0; |
912 | } |
913 | |
914 | namespace { |
915 | |
916 | |
917 | |
918 | |
919 | |
920 | |
921 | |
922 | |
923 | class HashAccumulator64 { |
924 | uint64_t Hash; |
925 | |
926 | public: |
927 | |
928 | HashAccumulator64() { Hash = 0x6acaa36bef8325c5ULL; } |
929 | |
930 | void add(uint64_t V) { Hash = hashing::detail::hash_16_bytes(Hash, V); } |
931 | |
932 | |
933 | uint64_t getHash() { return Hash; } |
934 | }; |
935 | |
936 | } |
937 | |
938 | |
939 | |
940 | |
941 | |
942 | |
943 | |
944 | |
945 | |
946 | |
947 | |
948 | FunctionComparator::FunctionHash FunctionComparator::functionHash(Function &F) { |
949 | HashAccumulator64 H; |
950 | H.add(F.isVarArg()); |
951 | H.add(F.arg_size()); |
952 | |
953 | SmallVector<const BasicBlock *, 8> BBs; |
954 | SmallPtrSet<const BasicBlock *, 16> VisitedBBs; |
955 | |
956 | |
957 | |
958 | BBs.push_back(&F.getEntryBlock()); |
959 | VisitedBBs.insert(BBs[0]); |
960 | while (!BBs.empty()) { |
961 | const BasicBlock *BB = BBs.pop_back_val(); |
962 | |
963 | |
964 | H.add(45798); |
965 | for (auto &Inst : *BB) { |
966 | H.add(Inst.getOpcode()); |
967 | } |
968 | const Instruction *Term = BB->getTerminator(); |
969 | for (unsigned i = 0, e = Term->getNumSuccessors(); i != e; ++i) { |
970 | if (!VisitedBBs.insert(Term->getSuccessor(i)).second) |
971 | continue; |
972 | BBs.push_back(Term->getSuccessor(i)); |
973 | } |
974 | } |
975 | return H.getHash(); |
976 | } |