1 //===- MergeFunctions.cpp - Merge identical functions ---------------------===//
3 // The LLVM Compiler Infrastructure
5 // This file is distributed under the University of Illinois Open Source
6 // License. See LICENSE.TXT for details.
8 //===----------------------------------------------------------------------===//
10 // This pass looks for equivalent functions that are mergable and folds them.
12 // A hash is computed from the function, based on its type and number of
15 // Once all hashes are computed, we perform an expensive equality comparison
16 // on each function pair. This takes n^2/2 comparisons per bucket, so it's
17 // important that the hash function be high quality. The equality comparison
18 // iterates through each instruction in each basic block.
20 // When a match is found the functions are folded. If both functions are
21 // overridable, we move the functionality into a new internal function and
22 // leave two overridable thunks to it.
24 //===----------------------------------------------------------------------===//
28 // * virtual functions.
30 // Many functions have their address taken by the virtual function table for
31 // the object they belong to. However, as long as it's only used for a lookup
32 // and call, this is irrelevant, and we'd like to fold such functions.
34 // * switch from n^2 pair-wise comparisons to an n-way comparison for each
37 // * be smarter about bitcasts.
39 // In order to fold functions, we will sometimes add either bitcast instructions
40 // or bitcast constant expressions. Unfortunately, this can confound further
41 // analysis since the two functions differ where one has a bitcast and the
42 // other doesn't. We should learn to look through bitcasts.
44 //===----------------------------------------------------------------------===//
46 #define DEBUG_TYPE "mergefunc"
47 #include "llvm/Transforms/IPO.h"
48 #include "llvm/ADT/DenseMap.h"
49 #include "llvm/ADT/FoldingSet.h"
50 #include "llvm/ADT/SmallSet.h"
51 #include "llvm/ADT/Statistic.h"
52 #include "llvm/Constants.h"
53 #include "llvm/InlineAsm.h"
54 #include "llvm/Instructions.h"
55 #include "llvm/LLVMContext.h"
56 #include "llvm/Module.h"
57 #include "llvm/Pass.h"
58 #include "llvm/Support/CallSite.h"
59 #include "llvm/Support/Debug.h"
60 #include "llvm/Support/ErrorHandling.h"
61 #include "llvm/Support/IRBuilder.h"
62 #include "llvm/Support/raw_ostream.h"
63 #include "llvm/Target/TargetData.h"
68 STATISTIC(NumFunctionsMerged
, "Number of functions merged");
71 /// MergeFunctions finds functions which will generate identical machine code,
72 /// by considering all pointer types to be equivalent. Once identified,
73 /// MergeFunctions will fold them by replacing a call to one to a call to a
74 /// bitcast of the other.
76 class MergeFunctions
: public ModulePass
{
79 MergeFunctions() : ModulePass(ID
) {}
81 bool runOnModule(Module
&M
);
84 /// PairwiseCompareAndMerge - Given a list of functions, compare each pair
85 /// and merge the pairs of equivalent functions.
86 bool PairwiseCompareAndMerge(std::vector
<Function
*> &FnVec
);
88 /// MergeTwoFunctions - Merge two equivalent functions. Upon completion,
89 /// FnVec[j] should never be visited again.
90 void MergeTwoFunctions(std::vector
<Function
*> &FnVec
,
91 unsigned i
, unsigned j
) const;
93 /// WriteThunk - Replace G with a simple tail call to bitcast(F). Also
94 /// replace direct uses of G with bitcast(F).
95 void WriteThunk(Function
*F
, Function
*G
) const;
101 char MergeFunctions::ID
= 0;
102 INITIALIZE_PASS(MergeFunctions
, "mergefunc", "Merge Functions", false, false);
104 ModulePass
*llvm::createMergeFunctionsPass() {
105 return new MergeFunctions();
109 /// FunctionComparator - Compares two functions to determine whether or not
110 /// they will generate machine code with the same behaviour. TargetData is
111 /// used if available. The comparator always fails conservatively (erring on the
112 /// side of claiming that two functions are different).
113 class FunctionComparator
{
115 FunctionComparator(TargetData
*TD
, Function
*F1
, Function
*F2
)
116 : F1(F1
), F2(F2
), TD(TD
), IDMap1Count(0), IDMap2Count(0) {}
118 /// Compare - test whether the two functions have equivalent behaviour.
122 /// Compare - test whether two basic blocks have equivalent behaviour.
123 bool Compare(const BasicBlock
*BB1
, const BasicBlock
*BB2
);
125 /// Enumerate - Assign or look up previously assigned numbers for the two
126 /// values, and return whether the numbers are equal. Numbers are assigned in
127 /// the order visited.
128 bool Enumerate(const Value
*V1
, const Value
*V2
);
130 /// isEquivalentOperation - Compare two Instructions for equivalence, similar
131 /// to Instruction::isSameOperationAs but with modifications to the type
133 bool isEquivalentOperation(const Instruction
*I1
,
134 const Instruction
*I2
) const;
136 /// isEquivalentGEP - Compare two GEPs for equivalent pointer arithmetic.
137 bool isEquivalentGEP(const GEPOperator
*GEP1
, const GEPOperator
*GEP2
);
138 bool isEquivalentGEP(const GetElementPtrInst
*GEP1
,
139 const GetElementPtrInst
*GEP2
) {
140 return isEquivalentGEP(cast
<GEPOperator
>(GEP1
), cast
<GEPOperator
>(GEP2
));
143 /// isEquivalentType - Compare two Types, treating all pointer types as equal.
144 bool isEquivalentType(const Type
*Ty1
, const Type
*Ty2
) const;
146 // The two functions undergoing comparison.
151 typedef DenseMap
<const Value
*, unsigned long> IDMap
;
153 unsigned long IDMap1Count
, IDMap2Count
;
157 /// Compute a hash guaranteed to be equal for two equivalent functions, but
158 /// very likely to be different for different functions.
159 static unsigned long ProfileFunction(const Function
*F
) {
160 const FunctionType
*FTy
= F
->getFunctionType();
163 ID
.AddInteger(F
->size());
164 ID
.AddInteger(F
->getCallingConv());
165 ID
.AddBoolean(F
->hasGC());
166 ID
.AddBoolean(FTy
->isVarArg());
167 ID
.AddInteger(FTy
->getReturnType()->getTypeID());
168 for (unsigned i
= 0, e
= FTy
->getNumParams(); i
!= e
; ++i
)
169 ID
.AddInteger(FTy
->getParamType(i
)->getTypeID());
170 return ID
.ComputeHash();
173 /// isEquivalentType - any two pointers in the same address space are
174 /// equivalent. Otherwise, standard type equivalence rules apply.
175 bool FunctionComparator::isEquivalentType(const Type
*Ty1
,
176 const Type
*Ty2
) const {
179 if (Ty1
->getTypeID() != Ty2
->getTypeID())
182 switch(Ty1
->getTypeID()) {
184 llvm_unreachable("Unknown type!");
185 // Fall through in Release mode.
186 case Type::IntegerTyID
:
187 case Type::OpaqueTyID
:
188 // Ty1 == Ty2 would have returned true earlier.
192 case Type::FloatTyID
:
193 case Type::DoubleTyID
:
194 case Type::X86_FP80TyID
:
195 case Type::FP128TyID
:
196 case Type::PPC_FP128TyID
:
197 case Type::LabelTyID
:
198 case Type::MetadataTyID
:
201 case Type::PointerTyID
: {
202 const PointerType
*PTy1
= cast
<PointerType
>(Ty1
);
203 const PointerType
*PTy2
= cast
<PointerType
>(Ty2
);
204 return PTy1
->getAddressSpace() == PTy2
->getAddressSpace();
207 case Type::StructTyID
: {
208 const StructType
*STy1
= cast
<StructType
>(Ty1
);
209 const StructType
*STy2
= cast
<StructType
>(Ty2
);
210 if (STy1
->getNumElements() != STy2
->getNumElements())
213 if (STy1
->isPacked() != STy2
->isPacked())
216 for (unsigned i
= 0, e
= STy1
->getNumElements(); i
!= e
; ++i
) {
217 if (!isEquivalentType(STy1
->getElementType(i
), STy2
->getElementType(i
)))
223 case Type::UnionTyID
: {
224 const UnionType
*UTy1
= cast
<UnionType
>(Ty1
);
225 const UnionType
*UTy2
= cast
<UnionType
>(Ty2
);
227 if (UTy1
->getNumElements() != UTy2
->getNumElements())
230 for (unsigned i
= 0, e
= UTy1
->getNumElements(); i
!= e
; ++i
) {
231 if (!isEquivalentType(UTy1
->getElementType(i
), UTy2
->getElementType(i
)))
237 case Type::FunctionTyID
: {
238 const FunctionType
*FTy1
= cast
<FunctionType
>(Ty1
);
239 const FunctionType
*FTy2
= cast
<FunctionType
>(Ty2
);
240 if (FTy1
->getNumParams() != FTy2
->getNumParams() ||
241 FTy1
->isVarArg() != FTy2
->isVarArg())
244 if (!isEquivalentType(FTy1
->getReturnType(), FTy2
->getReturnType()))
247 for (unsigned i
= 0, e
= FTy1
->getNumParams(); i
!= e
; ++i
) {
248 if (!isEquivalentType(FTy1
->getParamType(i
), FTy2
->getParamType(i
)))
254 case Type::ArrayTyID
: {
255 const ArrayType
*ATy1
= cast
<ArrayType
>(Ty1
);
256 const ArrayType
*ATy2
= cast
<ArrayType
>(Ty2
);
257 return ATy1
->getNumElements() == ATy2
->getNumElements() &&
258 isEquivalentType(ATy1
->getElementType(), ATy2
->getElementType());
261 case Type::VectorTyID
: {
262 const VectorType
*VTy1
= cast
<VectorType
>(Ty1
);
263 const VectorType
*VTy2
= cast
<VectorType
>(Ty2
);
264 return VTy1
->getNumElements() == VTy2
->getNumElements() &&
265 isEquivalentType(VTy1
->getElementType(), VTy2
->getElementType());
270 /// isEquivalentOperation - determine whether the two operations are the same
271 /// except that pointer-to-A and pointer-to-B are equivalent. This should be
272 /// kept in sync with Instruction::isSameOperationAs.
273 bool FunctionComparator::isEquivalentOperation(const Instruction
*I1
,
274 const Instruction
*I2
) const {
275 if (I1
->getOpcode() != I2
->getOpcode() ||
276 I1
->getNumOperands() != I2
->getNumOperands() ||
277 !isEquivalentType(I1
->getType(), I2
->getType()) ||
278 !I1
->hasSameSubclassOptionalData(I2
))
281 // We have two instructions of identical opcode and #operands. Check to see
282 // if all operands are the same type
283 for (unsigned i
= 0, e
= I1
->getNumOperands(); i
!= e
; ++i
)
284 if (!isEquivalentType(I1
->getOperand(i
)->getType(),
285 I2
->getOperand(i
)->getType()))
288 // Check special state that is a part of some instructions.
289 if (const LoadInst
*LI
= dyn_cast
<LoadInst
>(I1
))
290 return LI
->isVolatile() == cast
<LoadInst
>(I2
)->isVolatile() &&
291 LI
->getAlignment() == cast
<LoadInst
>(I2
)->getAlignment();
292 if (const StoreInst
*SI
= dyn_cast
<StoreInst
>(I1
))
293 return SI
->isVolatile() == cast
<StoreInst
>(I2
)->isVolatile() &&
294 SI
->getAlignment() == cast
<StoreInst
>(I2
)->getAlignment();
295 if (const CmpInst
*CI
= dyn_cast
<CmpInst
>(I1
))
296 return CI
->getPredicate() == cast
<CmpInst
>(I2
)->getPredicate();
297 if (const CallInst
*CI
= dyn_cast
<CallInst
>(I1
))
298 return CI
->isTailCall() == cast
<CallInst
>(I2
)->isTailCall() &&
299 CI
->getCallingConv() == cast
<CallInst
>(I2
)->getCallingConv() &&
300 CI
->getAttributes().getRawPointer() ==
301 cast
<CallInst
>(I2
)->getAttributes().getRawPointer();
302 if (const InvokeInst
*CI
= dyn_cast
<InvokeInst
>(I1
))
303 return CI
->getCallingConv() == cast
<InvokeInst
>(I2
)->getCallingConv() &&
304 CI
->getAttributes().getRawPointer() ==
305 cast
<InvokeInst
>(I2
)->getAttributes().getRawPointer();
306 if (const InsertValueInst
*IVI
= dyn_cast
<InsertValueInst
>(I1
)) {
307 if (IVI
->getNumIndices() != cast
<InsertValueInst
>(I2
)->getNumIndices())
309 for (unsigned i
= 0, e
= IVI
->getNumIndices(); i
!= e
; ++i
)
310 if (IVI
->idx_begin()[i
] != cast
<InsertValueInst
>(I2
)->idx_begin()[i
])
314 if (const ExtractValueInst
*EVI
= dyn_cast
<ExtractValueInst
>(I1
)) {
315 if (EVI
->getNumIndices() != cast
<ExtractValueInst
>(I2
)->getNumIndices())
317 for (unsigned i
= 0, e
= EVI
->getNumIndices(); i
!= e
; ++i
)
318 if (EVI
->idx_begin()[i
] != cast
<ExtractValueInst
>(I2
)->idx_begin()[i
])
326 /// isEquivalentGEP - determine whether two GEP operations perform the same
327 /// underlying arithmetic.
328 bool FunctionComparator::isEquivalentGEP(const GEPOperator
*GEP1
,
329 const GEPOperator
*GEP2
) {
330 // When we have target data, we can reduce the GEP down to the value in bytes
331 // added to the address.
332 if (TD
&& GEP1
->hasAllConstantIndices() && GEP2
->hasAllConstantIndices()) {
333 SmallVector
<Value
*, 8> Indices1(GEP1
->idx_begin(), GEP1
->idx_end());
334 SmallVector
<Value
*, 8> Indices2(GEP2
->idx_begin(), GEP2
->idx_end());
335 uint64_t Offset1
= TD
->getIndexedOffset(GEP1
->getPointerOperandType(),
336 Indices1
.data(), Indices1
.size());
337 uint64_t Offset2
= TD
->getIndexedOffset(GEP2
->getPointerOperandType(),
338 Indices2
.data(), Indices2
.size());
339 return Offset1
== Offset2
;
342 if (GEP1
->getPointerOperand()->getType() !=
343 GEP2
->getPointerOperand()->getType())
346 if (GEP1
->getNumOperands() != GEP2
->getNumOperands())
349 for (unsigned i
= 0, e
= GEP1
->getNumOperands(); i
!= e
; ++i
) {
350 if (!Enumerate(GEP1
->getOperand(i
), GEP2
->getOperand(i
)))
357 /// Enumerate - Compare two values used by the two functions under pair-wise
358 /// comparison. If this is the first time the values are seen, they're added to
359 /// the mapping so that we will detect mismatches on next use.
360 bool FunctionComparator::Enumerate(const Value
*V1
, const Value
*V2
) {
361 // Check for function @f1 referring to itself and function @f2 referring to
362 // itself, or referring to each other, or both referring to either of them.
363 // They're all equivalent if the two functions are otherwise equivalent.
364 if (V1
== F1
&& V2
== F2
)
366 if (V1
== F2
&& V2
== F1
)
369 // TODO: constant expressions with GEP or references to F1 or F2.
370 if (isa
<Constant
>(V1
))
373 if (isa
<InlineAsm
>(V1
) && isa
<InlineAsm
>(V2
)) {
374 const InlineAsm
*IA1
= cast
<InlineAsm
>(V1
);
375 const InlineAsm
*IA2
= cast
<InlineAsm
>(V2
);
376 return IA1
->getAsmString() == IA2
->getAsmString() &&
377 IA1
->getConstraintString() == IA2
->getConstraintString();
380 unsigned long &ID1
= Map1
[V1
];
384 unsigned long &ID2
= Map2
[V2
];
391 /// Compare - test whether two basic blocks have equivalent behaviour.
392 bool FunctionComparator::Compare(const BasicBlock
*BB1
, const BasicBlock
*BB2
) {
393 BasicBlock::const_iterator F1I
= BB1
->begin(), F1E
= BB1
->end();
394 BasicBlock::const_iterator F2I
= BB2
->begin(), F2E
= BB2
->end();
397 if (!Enumerate(F1I
, F2I
))
400 if (const GetElementPtrInst
*GEP1
= dyn_cast
<GetElementPtrInst
>(F1I
)) {
401 const GetElementPtrInst
*GEP2
= dyn_cast
<GetElementPtrInst
>(F2I
);
405 if (!Enumerate(GEP1
->getPointerOperand(), GEP2
->getPointerOperand()))
408 if (!isEquivalentGEP(GEP1
, GEP2
))
411 if (!isEquivalentOperation(F1I
, F2I
))
414 assert(F1I
->getNumOperands() == F2I
->getNumOperands());
415 for (unsigned i
= 0, e
= F1I
->getNumOperands(); i
!= e
; ++i
) {
416 Value
*OpF1
= F1I
->getOperand(i
);
417 Value
*OpF2
= F2I
->getOperand(i
);
419 if (!Enumerate(OpF1
, OpF2
))
422 if (OpF1
->getValueID() != OpF2
->getValueID() ||
423 !isEquivalentType(OpF1
->getType(), OpF2
->getType()))
429 } while (F1I
!= F1E
&& F2I
!= F2E
);
431 return F1I
== F1E
&& F2I
== F2E
;
434 /// Compare - test whether the two functions have equivalent behaviour.
435 bool FunctionComparator::Compare() {
436 // We need to recheck everything, but check the things that weren't included
437 // in the hash first.
439 if (F1
->getAttributes() != F2
->getAttributes())
442 if (F1
->hasGC() != F2
->hasGC())
445 if (F1
->hasGC() && F1
->getGC() != F2
->getGC())
448 if (F1
->hasSection() != F2
->hasSection())
451 if (F1
->hasSection() && F1
->getSection() != F2
->getSection())
454 if (F1
->isVarArg() != F2
->isVarArg())
457 // TODO: if it's internal and only used in direct calls, we could handle this
459 if (F1
->getCallingConv() != F2
->getCallingConv())
462 if (!isEquivalentType(F1
->getFunctionType(), F2
->getFunctionType()))
465 assert(F1
->arg_size() == F2
->arg_size() &&
466 "Identical functions have a different number of args.");
468 // Visit the arguments so that they get enumerated in the order they're
470 for (Function::const_arg_iterator f1i
= F1
->arg_begin(),
471 f2i
= F2
->arg_begin(), f1e
= F1
->arg_end(); f1i
!= f1e
; ++f1i
, ++f2i
) {
472 if (!Enumerate(f1i
, f2i
))
473 llvm_unreachable("Arguments repeat");
476 // We do a CFG-ordered walk since the actual ordering of the blocks in the
477 // linked list is immaterial. Our walk starts at the entry block for both
478 // functions, then takes each block from each terminator in order. As an
479 // artifact, this also means that unreachable blocks are ignored.
480 SmallVector
<const BasicBlock
*, 8> F1BBs
, F2BBs
;
481 SmallSet
<const BasicBlock
*, 128> VisitedBBs
; // in terms of F1.
483 F1BBs
.push_back(&F1
->getEntryBlock());
484 F2BBs
.push_back(&F2
->getEntryBlock());
486 VisitedBBs
.insert(F1BBs
[0]);
487 while (!F1BBs
.empty()) {
488 const BasicBlock
*F1BB
= F1BBs
.pop_back_val();
489 const BasicBlock
*F2BB
= F2BBs
.pop_back_val();
491 if (!Enumerate(F1BB
, F2BB
) || !Compare(F1BB
, F2BB
))
494 const TerminatorInst
*F1TI
= F1BB
->getTerminator();
495 const TerminatorInst
*F2TI
= F2BB
->getTerminator();
497 assert(F1TI
->getNumSuccessors() == F2TI
->getNumSuccessors());
498 for (unsigned i
= 0, e
= F1TI
->getNumSuccessors(); i
!= e
; ++i
) {
499 if (!VisitedBBs
.insert(F1TI
->getSuccessor(i
)))
502 F1BBs
.push_back(F1TI
->getSuccessor(i
));
503 F2BBs
.push_back(F2TI
->getSuccessor(i
));
509 /// WriteThunk - Replace G with a simple tail call to bitcast(F). Also replace
510 /// direct uses of G with bitcast(F).
511 void MergeFunctions::WriteThunk(Function
*F
, Function
*G
) const {
512 if (!G
->mayBeOverridden()) {
513 // Redirect direct callers of G to F.
514 Constant
*BitcastF
= ConstantExpr::getBitCast(F
, G
->getType());
515 for (Value::use_iterator UI
= G
->use_begin(), UE
= G
->use_end();
517 Value::use_iterator TheIter
= UI
;
519 CallSite
CS(*TheIter
);
520 if (CS
&& CS
.isCallee(TheIter
))
521 TheIter
.getUse().set(BitcastF
);
525 // If G was internal then we may have replaced all uses if G with F. If so,
526 // stop here and delete G. There's no need for a thunk.
527 if (G
->hasLocalLinkage() && G
->use_empty()) {
528 G
->eraseFromParent();
532 Function
*NewG
= Function::Create(G
->getFunctionType(), G
->getLinkage(), "",
534 BasicBlock
*BB
= BasicBlock::Create(F
->getContext(), "", NewG
);
535 IRBuilder
<false> Builder(BB
);
537 SmallVector
<Value
*, 16> Args
;
539 const FunctionType
*FFTy
= F
->getFunctionType();
540 for (Function::arg_iterator AI
= NewG
->arg_begin(), AE
= NewG
->arg_end();
542 Args
.push_back(Builder
.CreateBitCast(AI
, FFTy
->getParamType(i
)));
546 CallInst
*CI
= Builder
.CreateCall(F
, Args
.begin(), Args
.end());
548 CI
->setCallingConv(F
->getCallingConv());
549 if (NewG
->getReturnType()->isVoidTy()) {
550 Builder
.CreateRetVoid();
552 Builder
.CreateRet(Builder
.CreateBitCast(CI
, NewG
->getReturnType()));
555 NewG
->copyAttributesFrom(G
);
557 G
->replaceAllUsesWith(NewG
);
558 G
->eraseFromParent();
561 /// MergeTwoFunctions - Merge two equivalent functions. Upon completion,
562 /// FnVec[j] should never be visited again.
563 void MergeFunctions::MergeTwoFunctions(std::vector
<Function
*> &FnVec
,
564 unsigned i
, unsigned j
) const {
565 Function
*F
= FnVec
[i
];
566 Function
*G
= FnVec
[j
];
568 if (F
->isWeakForLinker() && !G
->isWeakForLinker()) {
569 std::swap(FnVec
[i
], FnVec
[j
]);
573 if (F
->isWeakForLinker()) {
574 assert(G
->isWeakForLinker());
576 // Make them both thunks to the same internal function.
577 Function
*H
= Function::Create(F
->getFunctionType(), F
->getLinkage(), "",
579 H
->copyAttributesFrom(F
);
581 F
->replaceAllUsesWith(H
);
586 F
->setAlignment(std::max(G
->getAlignment(), H
->getAlignment()));
587 F
->setLinkage(GlobalValue::InternalLinkage
);
592 ++NumFunctionsMerged
;
595 /// PairwiseCompareAndMerge - Given a list of functions, compare each pair and
596 /// merge the pairs of equivalent functions.
597 bool MergeFunctions::PairwiseCompareAndMerge(std::vector
<Function
*> &FnVec
) {
598 bool Changed
= false;
599 for (int i
= 0, e
= FnVec
.size(); i
!= e
; ++i
) {
600 for (int j
= i
+ 1; j
!= e
; ++j
) {
601 bool isEqual
= FunctionComparator(TD
, FnVec
[i
], FnVec
[j
]).Compare();
603 DEBUG(dbgs() << " " << FnVec
[i
]->getName()
604 << (isEqual
? " == " : " != ") << FnVec
[j
]->getName() << "\n");
607 MergeTwoFunctions(FnVec
, i
, j
);
609 FnVec
.erase(FnVec
.begin() + j
);
617 bool MergeFunctions::runOnModule(Module
&M
) {
618 bool Changed
= false;
620 std::map
<unsigned long, std::vector
<Function
*> > FnMap
;
622 for (Module::iterator F
= M
.begin(), E
= M
.end(); F
!= E
; ++F
) {
623 if (F
->isDeclaration() || F
->hasAvailableExternallyLinkage())
626 FnMap
[ProfileFunction(F
)].push_back(F
);
629 TD
= getAnalysisIfAvailable
<TargetData
>();
633 LocalChanged
= false;
634 DEBUG(dbgs() << "size: " << FnMap
.size() << "\n");
635 for (std::map
<unsigned long, std::vector
<Function
*> >::iterator
636 I
= FnMap
.begin(), E
= FnMap
.end(); I
!= E
; ++I
) {
637 std::vector
<Function
*> &FnVec
= I
->second
;
638 DEBUG(dbgs() << "hash (" << I
->first
<< "): " << FnVec
.size() << "\n");
639 LocalChanged
|= PairwiseCompareAndMerge(FnVec
);
641 Changed
|= LocalChanged
;
642 } while (LocalChanged
);