2008-11-02 13:52:50 +08:00
|
|
|
//===- MergeFunctions.cpp - Merge identical functions ---------------------===//
|
|
|
|
//
|
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// This pass looks for equivalent functions that are mergable and folds them.
|
|
|
|
//
|
2014-06-22 08:57:09 +08:00
|
|
|
// Order relation is defined on set of functions. It was made through
|
|
|
|
// special function comparison procedure that returns
|
|
|
|
// 0 when functions are equal,
|
|
|
|
// -1 when Left function is less than right function, and
|
|
|
|
// 1 for opposite case. We need total-ordering, so we need to maintain
|
|
|
|
// four properties on the functions set:
|
|
|
|
// a <= a (reflexivity)
|
|
|
|
// if a <= b and b <= a then a = b (antisymmetry)
|
|
|
|
// if a <= b and b <= c then a <= c (transitivity).
|
|
|
|
// for all a and b: a <= b or b <= a (totality).
|
2008-11-02 13:52:50 +08:00
|
|
|
//
|
2014-06-22 08:57:09 +08:00
|
|
|
// Comparison iterates through each instruction in each basic block.
|
|
|
|
// Functions are kept on binary tree. For each new function F we perform
|
|
|
|
// lookup in binary tree.
|
|
|
|
// In practice it works the following way:
|
|
|
|
// -- We define Function* container class with custom "operator<" (FunctionPtr).
|
|
|
|
// -- "FunctionPtr" instances are stored in std::set collection, so every
|
|
|
|
// std::set::insert operation will give you result in log(N) time.
|
2008-11-02 13:52:50 +08:00
|
|
|
//
|
2010-05-13 13:48:45 +08:00
|
|
|
// When a match is found the functions are folded. If both functions are
|
|
|
|
// overridable, we move the functionality into a new internal function and
|
|
|
|
// leave two overridable thunks to it.
|
2008-11-02 13:52:50 +08:00
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
//
|
|
|
|
// Future work:
|
|
|
|
//
|
|
|
|
// * virtual functions.
|
|
|
|
//
|
|
|
|
// Many functions have their address taken by the virtual function table for
|
|
|
|
// the object they belong to. However, as long as it's only used for a lookup
|
2010-08-08 13:04:23 +08:00
|
|
|
// and call, this is irrelevant, and we'd like to fold such functions.
|
2008-11-02 13:52:50 +08:00
|
|
|
//
|
2010-08-08 13:04:23 +08:00
|
|
|
// * be smarter about bitcasts.
|
2010-05-13 13:48:45 +08:00
|
|
|
//
|
|
|
|
// In order to fold functions, we will sometimes add either bitcast instructions
|
|
|
|
// or bitcast constant expressions. Unfortunately, this can confound further
|
|
|
|
// analysis since the two functions differ where one has a bitcast and the
|
2010-08-08 13:04:23 +08:00
|
|
|
// other doesn't. We should learn to look through bitcasts.
|
2010-05-13 13:48:45 +08:00
|
|
|
//
|
2014-06-22 08:57:09 +08:00
|
|
|
// * Compare complex types with pointer types inside.
|
|
|
|
// * Compare cross-reference cases.
|
|
|
|
// * Compare complex expressions.
|
|
|
|
//
|
|
|
|
// All the three issues above could be described as ability to prove that
|
|
|
|
// fA == fB == fC == fE == fF == fG in example below:
|
|
|
|
//
|
|
|
|
// void fA() {
|
|
|
|
// fB();
|
|
|
|
// }
|
|
|
|
// void fB() {
|
|
|
|
// fA();
|
|
|
|
// }
|
|
|
|
//
|
|
|
|
// void fE() {
|
|
|
|
// fF();
|
|
|
|
// }
|
|
|
|
// void fF() {
|
|
|
|
// fG();
|
|
|
|
// }
|
|
|
|
// void fG() {
|
|
|
|
// fE();
|
|
|
|
// }
|
|
|
|
//
|
|
|
|
// Simplest cross-reference case (fA <--> fB) was implemented in previous
|
|
|
|
// versions of MergeFunctions, though it presented only in two function pairs
|
|
|
|
// in test-suite (that counts >50k functions)
|
|
|
|
// Though possibility to detect complex cross-referencing (e.g.: A->B->C->D->A)
|
|
|
|
// could cover much more cases.
|
|
|
|
//
|
2008-11-02 13:52:50 +08:00
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "llvm/Transforms/IPO.h"
|
2012-12-04 00:50:05 +08:00
|
|
|
#include "llvm/ADT/DenseSet.h"
|
|
|
|
#include "llvm/ADT/FoldingSet.h"
|
|
|
|
#include "llvm/ADT/STLExtras.h"
|
|
|
|
#include "llvm/ADT/SmallSet.h"
|
|
|
|
#include "llvm/ADT/Statistic.h"
|
2014-03-04 19:01:28 +08:00
|
|
|
#include "llvm/IR/CallSite.h"
|
2013-01-02 19:36:10 +08:00
|
|
|
#include "llvm/IR/Constants.h"
|
|
|
|
#include "llvm/IR/DataLayout.h"
|
|
|
|
#include "llvm/IR/IRBuilder.h"
|
|
|
|
#include "llvm/IR/InlineAsm.h"
|
|
|
|
#include "llvm/IR/Instructions.h"
|
|
|
|
#include "llvm/IR/LLVMContext.h"
|
|
|
|
#include "llvm/IR/Module.h"
|
|
|
|
#include "llvm/IR/Operator.h"
|
2014-03-04 19:17:44 +08:00
|
|
|
#include "llvm/IR/ValueHandle.h"
|
2008-11-02 13:52:50 +08:00
|
|
|
#include "llvm/Pass.h"
|
2014-06-22 02:58:11 +08:00
|
|
|
#include "llvm/Support/CommandLine.h"
|
2008-11-02 13:52:50 +08:00
|
|
|
#include "llvm/Support/Debug.h"
|
2009-07-12 04:10:48 +08:00
|
|
|
#include "llvm/Support/ErrorHandling.h"
|
2009-07-25 08:23:56 +08:00
|
|
|
#include "llvm/Support/raw_ostream.h"
|
2010-08-31 16:29:37 +08:00
|
|
|
#include <vector>
|
2008-11-02 13:52:50 +08:00
|
|
|
using namespace llvm;
|
|
|
|
|
2014-04-22 10:55:47 +08:00
|
|
|
#define DEBUG_TYPE "mergefunc"
|
|
|
|
|
2008-11-02 13:52:50 +08:00
|
|
|
STATISTIC(NumFunctionsMerged, "Number of functions merged");
|
2010-09-07 09:42:10 +08:00
|
|
|
STATISTIC(NumThunksWritten, "Number of thunks generated");
|
2011-01-25 16:56:50 +08:00
|
|
|
STATISTIC(NumAliasesWritten, "Number of aliases generated");
|
2010-09-07 09:42:10 +08:00
|
|
|
STATISTIC(NumDoubleWeak, "Number of new functions created");
|
2008-11-02 13:52:50 +08:00
|
|
|
|
2014-06-22 02:58:11 +08:00
|
|
|
static cl::opt<unsigned> NumFunctionsForSanityCheck(
|
|
|
|
"mergefunc-sanity",
|
|
|
|
cl::desc("How many functions in module could be used for "
|
|
|
|
"MergeFunctions pass sanity check. "
|
|
|
|
"'0' disables this check. Works only with '-debug' key."),
|
|
|
|
cl::init(0), cl::Hidden);
|
|
|
|
|
2010-09-05 17:00:32 +08:00
|
|
|
namespace {
|
|
|
|
|
2010-08-08 13:04:23 +08:00
|
|
|
/// FunctionComparator - Compares two functions to determine whether or not
|
2012-10-09 00:38:25 +08:00
|
|
|
/// they will generate machine code with the same behaviour. DataLayout is
|
2010-08-08 13:04:23 +08:00
|
|
|
/// used if available. The comparator always fails conservatively (erring on the
|
|
|
|
/// side of claiming that two functions are different).
|
2010-08-02 13:23:03 +08:00
|
|
|
class FunctionComparator {
|
|
|
|
public:
|
2015-03-10 10:37:25 +08:00
|
|
|
FunctionComparator(const Function *F1, const Function *F2)
|
|
|
|
: FnL(F1), FnR(F2) {}
|
2010-08-02 13:23:03 +08:00
|
|
|
|
2011-01-28 16:43:14 +08:00
|
|
|
/// Test whether the two functions have equivalent behaviour.
|
2014-06-22 01:55:51 +08:00
|
|
|
int compare();
|
2010-08-02 13:23:03 +08:00
|
|
|
|
|
|
|
private:
|
2011-01-28 16:43:14 +08:00
|
|
|
/// Test whether two basic blocks have equivalent behaviour.
|
2014-06-22 01:55:51 +08:00
|
|
|
int compare(const BasicBlock *BBL, const BasicBlock *BBR);
|
2010-08-02 13:23:03 +08:00
|
|
|
|
2014-05-07 17:05:10 +08:00
|
|
|
/// Constants comparison.
|
|
|
|
/// Its analog to lexicographical comparison between hypothetical numbers
|
|
|
|
/// of next format:
|
|
|
|
/// <bitcastability-trait><raw-bit-contents>
|
|
|
|
///
|
|
|
|
/// 1. Bitcastability.
|
|
|
|
/// Check whether L's type could be losslessly bitcasted to R's type.
|
|
|
|
/// On this stage method, in case when lossless bitcast is not possible
|
|
|
|
/// method returns -1 or 1, thus also defining which type is greater in
|
|
|
|
/// context of bitcastability.
|
|
|
|
/// Stage 0: If types are equal in terms of cmpTypes, then we can go straight
|
|
|
|
/// to the contents comparison.
|
|
|
|
/// If types differ, remember types comparison result and check
|
|
|
|
/// whether we still can bitcast types.
|
|
|
|
/// Stage 1: Types that satisfies isFirstClassType conditions are always
|
|
|
|
/// greater then others.
|
|
|
|
/// Stage 2: Vector is greater then non-vector.
|
|
|
|
/// If both types are vectors, then vector with greater bitwidth is
|
|
|
|
/// greater.
|
|
|
|
/// If both types are vectors with the same bitwidth, then types
|
|
|
|
/// are bitcastable, and we can skip other stages, and go to contents
|
|
|
|
/// comparison.
|
|
|
|
/// Stage 3: Pointer types are greater than non-pointers. If both types are
|
|
|
|
/// pointers of the same address space - go to contents comparison.
|
|
|
|
/// Different address spaces: pointer with greater address space is
|
|
|
|
/// greater.
|
|
|
|
/// Stage 4: Types are neither vectors, nor pointers. And they differ.
|
|
|
|
/// We don't know how to bitcast them. So, we better don't do it,
|
|
|
|
/// and return types comparison result (so it determines the
|
|
|
|
/// relationship among constants we don't know how to bitcast).
|
|
|
|
///
|
|
|
|
/// Just for clearance, let's see how the set of constants could look
|
|
|
|
/// on single dimension axis:
|
|
|
|
///
|
|
|
|
/// [NFCT], [FCT, "others"], [FCT, pointers], [FCT, vectors]
|
|
|
|
/// Where: NFCT - Not a FirstClassType
|
|
|
|
/// FCT - FirstClassTyp:
|
|
|
|
///
|
|
|
|
/// 2. Compare raw contents.
|
|
|
|
/// It ignores types on this stage and only compares bits from L and R.
|
|
|
|
/// Returns 0, if L and R has equivalent contents.
|
|
|
|
/// -1 or 1 if values are different.
|
|
|
|
/// Pretty trivial:
|
|
|
|
/// 2.1. If contents are numbers, compare numbers.
|
|
|
|
/// Ints with greater bitwidth are greater. Ints with same bitwidths
|
|
|
|
/// compared by their contents.
|
|
|
|
/// 2.2. "And so on". Just to avoid discrepancies with comments
|
|
|
|
/// perhaps it would be better to read the implementation itself.
|
|
|
|
/// 3. And again about overall picture. Let's look back at how the ordered set
|
|
|
|
/// of constants will look like:
|
|
|
|
/// [NFCT], [FCT, "others"], [FCT, pointers], [FCT, vectors]
|
|
|
|
///
|
|
|
|
/// Now look, what could be inside [FCT, "others"], for example:
|
|
|
|
/// [FCT, "others"] =
|
|
|
|
/// [
|
|
|
|
/// [double 0.1], [double 1.23],
|
|
|
|
/// [i32 1], [i32 2],
|
|
|
|
/// { double 1.0 }, ; StructTyID, NumElements = 1
|
|
|
|
/// { i32 1 }, ; StructTyID, NumElements = 1
|
|
|
|
/// { double 1, i32 1 }, ; StructTyID, NumElements = 2
|
|
|
|
/// { i32 1, double 1 } ; StructTyID, NumElements = 2
|
|
|
|
/// ]
|
|
|
|
///
|
|
|
|
/// Let's explain the order. Float numbers will be less than integers, just
|
|
|
|
/// because of cmpType terms: FloatTyID < IntegerTyID.
|
|
|
|
/// Floats (with same fltSemantics) are sorted according to their value.
|
|
|
|
/// Then you can see integers, and they are, like a floats,
|
|
|
|
/// could be easy sorted among each others.
|
|
|
|
/// The structures. Structures are grouped at the tail, again because of their
|
|
|
|
/// TypeID: StructTyID > IntegerTyID > FloatTyID.
|
|
|
|
/// Structures with greater number of elements are greater. Structures with
|
|
|
|
/// greater elements going first are greater.
|
|
|
|
/// The same logic with vectors, arrays and other possible complex types.
|
|
|
|
///
|
|
|
|
/// Bitcastable constants.
|
|
|
|
/// Let's assume, that some constant, belongs to some group of
|
|
|
|
/// "so-called-equal" values with different types, and at the same time
|
|
|
|
/// belongs to another group of constants with equal types
|
|
|
|
/// and "really" equal values.
|
|
|
|
///
|
|
|
|
/// Now, prove that this is impossible:
|
|
|
|
///
|
|
|
|
/// If constant A with type TyA is bitcastable to B with type TyB, then:
|
|
|
|
/// 1. All constants with equal types to TyA, are bitcastable to B. Since
|
|
|
|
/// those should be vectors (if TyA is vector), pointers
|
|
|
|
/// (if TyA is pointer), or else (if TyA equal to TyB), those types should
|
|
|
|
/// be equal to TyB.
|
|
|
|
/// 2. All constants with non-equal, but bitcastable types to TyA, are
|
|
|
|
/// bitcastable to B.
|
|
|
|
/// Once again, just because we allow it to vectors and pointers only.
|
|
|
|
/// This statement could be expanded as below:
|
|
|
|
/// 2.1. All vectors with equal bitwidth to vector A, has equal bitwidth to
|
|
|
|
/// vector B, and thus bitcastable to B as well.
|
|
|
|
/// 2.2. All pointers of the same address space, no matter what they point to,
|
|
|
|
/// bitcastable. So if C is pointer, it could be bitcasted to A and to B.
|
|
|
|
/// So any constant equal or bitcastable to A is equal or bitcastable to B.
|
|
|
|
/// QED.
|
|
|
|
///
|
|
|
|
/// In another words, for pointers and vectors, we ignore top-level type and
|
|
|
|
/// look at their particular properties (bit-width for vectors, and
|
|
|
|
/// address space for pointers).
|
|
|
|
/// If these properties are equal - compare their contents.
|
|
|
|
int cmpConstants(const Constant *L, const Constant *R);
|
|
|
|
|
2011-01-28 16:43:14 +08:00
|
|
|
/// Assign or look up previously assigned numbers for the two values, and
|
|
|
|
/// return whether the numbers are equal. Numbers are assigned in the order
|
|
|
|
/// visited.
|
2014-05-07 19:11:39 +08:00
|
|
|
/// Comparison order:
|
|
|
|
/// Stage 0: Value that is function itself is always greater then others.
|
|
|
|
/// If left and right values are references to their functions, then
|
|
|
|
/// they are equal.
|
|
|
|
/// Stage 1: Constants are greater than non-constants.
|
|
|
|
/// If both left and right are constants, then the result of
|
|
|
|
/// cmpConstants is used as cmpValues result.
|
|
|
|
/// Stage 2: InlineAsm instances are greater than others. If both left and
|
|
|
|
/// right are InlineAsm instances, InlineAsm* pointers casted to
|
|
|
|
/// integers and compared as numbers.
|
|
|
|
/// Stage 3: For all other cases we compare order we meet these values in
|
|
|
|
/// their functions. If right value was met first during scanning,
|
|
|
|
/// then left value is greater.
|
|
|
|
/// In another words, we compare serial numbers, for more details
|
|
|
|
/// see comments for sn_mapL and sn_mapR.
|
|
|
|
int cmpValues(const Value *L, const Value *R);
|
|
|
|
|
2011-01-28 16:43:14 +08:00
|
|
|
/// Compare two Instructions for equivalence, similar to
|
|
|
|
/// Instruction::isSameOperationAs but with modifications to the type
|
2010-08-08 13:04:23 +08:00
|
|
|
/// comparison.
|
2014-05-16 19:02:22 +08:00
|
|
|
/// Stages are listed in "most significant stage first" order:
|
|
|
|
/// On each stage below, we do comparison between some left and right
|
|
|
|
/// operation parts. If parts are non-equal, we assign parts comparison
|
|
|
|
/// result to the operation comparison result and exit from method.
|
|
|
|
/// Otherwise we proceed to the next stage.
|
|
|
|
/// Stages:
|
|
|
|
/// 1. Operations opcodes. Compared as numbers.
|
|
|
|
/// 2. Number of operands.
|
|
|
|
/// 3. Operation types. Compared with cmpType method.
|
|
|
|
/// 4. Compare operation subclass optional data as stream of bytes:
|
|
|
|
/// just convert it to integers and call cmpNumbers.
|
|
|
|
/// 5. Compare in operation operand types with cmpType in
|
|
|
|
/// most significant operand first order.
|
|
|
|
/// 6. Last stage. Check operations for some specific attributes.
|
|
|
|
/// For example, for Load it would be:
|
|
|
|
/// 6.1.Load: volatile (as boolean flag)
|
|
|
|
/// 6.2.Load: alignment (as integer numbers)
|
|
|
|
/// 6.3.Load: synch-scope (as integer numbers)
|
2014-06-21 03:11:56 +08:00
|
|
|
/// 6.4.Load: range metadata (as integer numbers)
|
2014-05-16 19:02:22 +08:00
|
|
|
/// On this stage its better to see the code, since its not more than 10-15
|
|
|
|
/// strings for particular instruction, and could change sometimes.
|
2014-07-31 15:16:59 +08:00
|
|
|
int cmpOperations(const Instruction *L, const Instruction *R) const;
|
2014-05-16 19:02:22 +08:00
|
|
|
|
2011-01-28 16:43:14 +08:00
|
|
|
/// Compare two GEPs for equivalent pointer arithmetic.
|
2014-05-16 19:55:02 +08:00
|
|
|
/// Parts to be compared for each comparison stage,
|
|
|
|
/// most significant stage first:
|
|
|
|
/// 1. Address space. As numbers.
|
2015-03-10 10:37:25 +08:00
|
|
|
/// 2. Constant offset, (using GEPOperator::accumulateConstantOffset method).
|
2014-05-16 19:55:02 +08:00
|
|
|
/// 3. Pointer operand type (using cmpType method).
|
|
|
|
/// 4. Number of operands.
|
|
|
|
/// 5. Compare operands, using cmpValues method.
|
2014-08-25 16:12:45 +08:00
|
|
|
int cmpGEPs(const GEPOperator *GEPL, const GEPOperator *GEPR);
|
|
|
|
int cmpGEPs(const GetElementPtrInst *GEPL, const GetElementPtrInst *GEPR) {
|
|
|
|
return cmpGEPs(cast<GEPOperator>(GEPL), cast<GEPOperator>(GEPR));
|
2014-05-16 19:55:02 +08:00
|
|
|
}
|
|
|
|
|
2014-03-13 19:54:50 +08:00
|
|
|
/// cmpType - compares two types,
|
|
|
|
/// defines total ordering among the types set.
|
|
|
|
///
|
|
|
|
/// Return values:
|
|
|
|
/// 0 if types are equal,
|
|
|
|
/// -1 if Left is less than Right,
|
|
|
|
/// +1 if Left is greater than Right.
|
|
|
|
///
|
|
|
|
/// Description:
|
|
|
|
/// Comparison is broken onto stages. Like in lexicographical comparison
|
|
|
|
/// stage coming first has higher priority.
|
|
|
|
/// On each explanation stage keep in mind total ordering properties.
|
|
|
|
///
|
2014-03-14 16:17:19 +08:00
|
|
|
/// 0. Before comparison we coerce pointer types of 0 address space to
|
|
|
|
/// integer.
|
2014-03-13 19:54:50 +08:00
|
|
|
/// We also don't bother with same type at left and right, so
|
|
|
|
/// just return 0 in this case.
|
|
|
|
///
|
|
|
|
/// 1. If types are of different kind (different type IDs).
|
|
|
|
/// Return result of type IDs comparison, treating them as numbers.
|
|
|
|
/// 2. If types are vectors or integers, compare Type* values as numbers.
|
|
|
|
/// 3. Types has same ID, so check whether they belongs to the next group:
|
|
|
|
/// * Void
|
|
|
|
/// * Float
|
|
|
|
/// * Double
|
|
|
|
/// * X86_FP80
|
|
|
|
/// * FP128
|
|
|
|
/// * PPC_FP128
|
|
|
|
/// * Label
|
|
|
|
/// * Metadata
|
|
|
|
/// If so - return 0, yes - we can treat these types as equal only because
|
|
|
|
/// their IDs are same.
|
|
|
|
/// 4. If Left and Right are pointers, return result of address space
|
|
|
|
/// comparison (numbers comparison). We can treat pointer types of same
|
|
|
|
/// address space as equal.
|
|
|
|
/// 5. If types are complex.
|
|
|
|
/// Then both Left and Right are to be expanded and their element types will
|
|
|
|
/// be checked with the same way. If we get Res != 0 on some stage, return it.
|
|
|
|
/// Otherwise return 0.
|
|
|
|
/// 6. For all other cases put llvm_unreachable.
|
2014-08-25 16:16:39 +08:00
|
|
|
int cmpTypes(Type *TyL, Type *TyR) const;
|
2014-03-13 19:54:50 +08:00
|
|
|
|
|
|
|
int cmpNumbers(uint64_t L, uint64_t R) const;
|
2010-08-02 13:23:03 +08:00
|
|
|
|
2014-08-25 16:19:50 +08:00
|
|
|
int cmpAPInts(const APInt &L, const APInt &R) const;
|
2014-08-25 16:22:46 +08:00
|
|
|
int cmpAPFloats(const APFloat &L, const APFloat &R) const;
|
2014-05-16 16:55:34 +08:00
|
|
|
int cmpStrings(StringRef L, StringRef R) const;
|
|
|
|
int cmpAttrs(const AttributeSet L, const AttributeSet R) const;
|
2014-05-07 17:05:10 +08:00
|
|
|
|
2010-08-02 13:23:03 +08:00
|
|
|
// The two functions undergoing comparison.
|
2014-06-22 01:55:51 +08:00
|
|
|
const Function *FnL, *FnR;
|
2010-08-02 13:23:03 +08:00
|
|
|
|
2014-05-07 19:11:39 +08:00
|
|
|
/// Assign serial numbers to values from left function, and values from
|
|
|
|
/// right function.
|
|
|
|
/// Explanation:
|
|
|
|
/// Being comparing functions we need to compare values we meet at left and
|
|
|
|
/// right sides.
|
|
|
|
/// Its easy to sort things out for external values. It just should be
|
|
|
|
/// the same value at left and right.
|
|
|
|
/// But for local values (those were introduced inside function body)
|
|
|
|
/// we have to ensure they were introduced at exactly the same place,
|
|
|
|
/// and plays the same role.
|
|
|
|
/// Let's assign serial number to each value when we meet it first time.
|
|
|
|
/// Values that were met at same place will be with same serial numbers.
|
|
|
|
/// In this case it would be good to explain few points about values assigned
|
|
|
|
/// to BBs and other ways of implementation (see below).
|
|
|
|
///
|
|
|
|
/// 1. Safety of BB reordering.
|
|
|
|
/// It's safe to change the order of BasicBlocks in function.
|
|
|
|
/// Relationship with other functions and serial numbering will not be
|
|
|
|
/// changed in this case.
|
|
|
|
/// As follows from FunctionComparator::compare(), we do CFG walk: we start
|
|
|
|
/// from the entry, and then take each terminator. So it doesn't matter how in
|
|
|
|
/// fact BBs are ordered in function. And since cmpValues are called during
|
|
|
|
/// this walk, the numbering depends only on how BBs located inside the CFG.
|
|
|
|
/// So the answer is - yes. We will get the same numbering.
|
|
|
|
///
|
|
|
|
/// 2. Impossibility to use dominance properties of values.
|
|
|
|
/// If we compare two instruction operands: first is usage of local
|
|
|
|
/// variable AL from function FL, and second is usage of local variable AR
|
|
|
|
/// from FR, we could compare their origins and check whether they are
|
|
|
|
/// defined at the same place.
|
|
|
|
/// But, we are still not able to compare operands of PHI nodes, since those
|
|
|
|
/// could be operands from further BBs we didn't scan yet.
|
|
|
|
/// So it's impossible to use dominance properties in general.
|
|
|
|
DenseMap<const Value*, int> sn_mapL, sn_mapR;
|
2010-08-02 13:23:03 +08:00
|
|
|
};
|
2011-01-28 15:36:21 +08:00
|
|
|
|
2014-09-10 18:08:25 +08:00
|
|
|
class FunctionNode {
|
2015-06-09 08:03:29 +08:00
|
|
|
mutable AssertingVH<Function> F;
|
2014-06-22 04:54:36 +08:00
|
|
|
|
|
|
|
public:
|
2015-03-10 10:37:25 +08:00
|
|
|
FunctionNode(Function *F) : F(F) {}
|
2014-06-22 04:54:36 +08:00
|
|
|
Function *getFunc() const { return F; }
|
2015-06-09 08:03:29 +08:00
|
|
|
|
|
|
|
/// Replace the reference to the function F by the function G, assuming their
|
|
|
|
/// implementations are equal.
|
|
|
|
void replaceBy(Function *G) const {
|
|
|
|
assert(!(*this < FunctionNode(G)) && !(FunctionNode(G) < *this) &&
|
|
|
|
"The two functions must be equal");
|
|
|
|
|
|
|
|
F = G;
|
|
|
|
}
|
|
|
|
|
2014-06-22 04:54:36 +08:00
|
|
|
void release() { F = 0; }
|
2014-09-10 18:08:25 +08:00
|
|
|
bool operator<(const FunctionNode &RHS) const {
|
2015-03-10 10:37:25 +08:00
|
|
|
return (FunctionComparator(F, RHS.getFunc()).compare()) == -1;
|
2014-06-22 04:54:36 +08:00
|
|
|
}
|
|
|
|
};
|
2015-06-23 17:49:53 +08:00
|
|
|
}
|
2010-08-02 13:23:03 +08:00
|
|
|
|
2014-03-13 19:54:50 +08:00
|
|
|
int FunctionComparator::cmpNumbers(uint64_t L, uint64_t R) const {
|
|
|
|
if (L < R) return -1;
|
|
|
|
if (L > R) return 1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-08-25 16:19:50 +08:00
|
|
|
int FunctionComparator::cmpAPInts(const APInt &L, const APInt &R) const {
|
2014-05-07 17:05:10 +08:00
|
|
|
if (int Res = cmpNumbers(L.getBitWidth(), R.getBitWidth()))
|
|
|
|
return Res;
|
|
|
|
if (L.ugt(R)) return 1;
|
|
|
|
if (R.ugt(L)) return -1;
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-08-25 16:22:46 +08:00
|
|
|
int FunctionComparator::cmpAPFloats(const APFloat &L, const APFloat &R) const {
|
2014-05-07 17:05:10 +08:00
|
|
|
if (int Res = cmpNumbers((uint64_t)&L.getSemantics(),
|
|
|
|
(uint64_t)&R.getSemantics()))
|
|
|
|
return Res;
|
2014-08-25 16:19:50 +08:00
|
|
|
return cmpAPInts(L.bitcastToAPInt(), R.bitcastToAPInt());
|
2014-05-07 17:05:10 +08:00
|
|
|
}
|
|
|
|
|
2014-05-16 16:55:34 +08:00
|
|
|
int FunctionComparator::cmpStrings(StringRef L, StringRef R) const {
|
|
|
|
// Prevent heavy comparison, compare sizes first.
|
|
|
|
if (int Res = cmpNumbers(L.size(), R.size()))
|
|
|
|
return Res;
|
|
|
|
|
|
|
|
// Compare strings lexicographically only when it is necessary: only when
|
|
|
|
// strings are equal in size.
|
|
|
|
return L.compare(R);
|
|
|
|
}
|
|
|
|
|
|
|
|
int FunctionComparator::cmpAttrs(const AttributeSet L,
|
|
|
|
const AttributeSet R) const {
|
|
|
|
if (int Res = cmpNumbers(L.getNumSlots(), R.getNumSlots()))
|
|
|
|
return Res;
|
|
|
|
|
|
|
|
for (unsigned i = 0, e = L.getNumSlots(); i != e; ++i) {
|
|
|
|
AttributeSet::iterator LI = L.begin(i), LE = L.end(i), RI = R.begin(i),
|
|
|
|
RE = R.end(i);
|
|
|
|
for (; LI != LE && RI != RE; ++LI, ++RI) {
|
|
|
|
Attribute LA = *LI;
|
|
|
|
Attribute RA = *RI;
|
|
|
|
if (LA < RA)
|
|
|
|
return -1;
|
|
|
|
if (RA < LA)
|
|
|
|
return 1;
|
|
|
|
}
|
|
|
|
if (LI != LE)
|
|
|
|
return 1;
|
|
|
|
if (RI != RE)
|
|
|
|
return -1;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
|
2014-05-07 17:05:10 +08:00
|
|
|
/// Constants comparison:
|
|
|
|
/// 1. Check whether type of L constant could be losslessly bitcasted to R
|
|
|
|
/// type.
|
|
|
|
/// 2. Compare constant contents.
|
|
|
|
/// For more details see declaration comments.
|
|
|
|
int FunctionComparator::cmpConstants(const Constant *L, const Constant *R) {
|
|
|
|
|
|
|
|
Type *TyL = L->getType();
|
|
|
|
Type *TyR = R->getType();
|
|
|
|
|
|
|
|
// Check whether types are bitcastable. This part is just re-factored
|
|
|
|
// Type::canLosslesslyBitCastTo method, but instead of returning true/false,
|
|
|
|
// we also pack into result which type is "less" for us.
|
2014-08-25 16:16:39 +08:00
|
|
|
int TypesRes = cmpTypes(TyL, TyR);
|
2014-05-07 17:05:10 +08:00
|
|
|
if (TypesRes != 0) {
|
|
|
|
// Types are different, but check whether we can bitcast them.
|
|
|
|
if (!TyL->isFirstClassType()) {
|
|
|
|
if (TyR->isFirstClassType())
|
|
|
|
return -1;
|
|
|
|
// Neither TyL nor TyR are values of first class type. Return the result
|
|
|
|
// of comparing the types
|
|
|
|
return TypesRes;
|
|
|
|
}
|
|
|
|
if (!TyR->isFirstClassType()) {
|
|
|
|
if (TyL->isFirstClassType())
|
|
|
|
return 1;
|
|
|
|
return TypesRes;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Vector -> Vector conversions are always lossless if the two vector types
|
|
|
|
// have the same size, otherwise not.
|
|
|
|
unsigned TyLWidth = 0;
|
|
|
|
unsigned TyRWidth = 0;
|
|
|
|
|
|
|
|
if (const VectorType *VecTyL = dyn_cast<VectorType>(TyL))
|
|
|
|
TyLWidth = VecTyL->getBitWidth();
|
|
|
|
if (const VectorType *VecTyR = dyn_cast<VectorType>(TyR))
|
|
|
|
TyRWidth = VecTyR->getBitWidth();
|
|
|
|
|
|
|
|
if (TyLWidth != TyRWidth)
|
|
|
|
return cmpNumbers(TyLWidth, TyRWidth);
|
|
|
|
|
|
|
|
// Zero bit-width means neither TyL nor TyR are vectors.
|
|
|
|
if (!TyLWidth) {
|
|
|
|
PointerType *PTyL = dyn_cast<PointerType>(TyL);
|
|
|
|
PointerType *PTyR = dyn_cast<PointerType>(TyR);
|
|
|
|
if (PTyL && PTyR) {
|
|
|
|
unsigned AddrSpaceL = PTyL->getAddressSpace();
|
|
|
|
unsigned AddrSpaceR = PTyR->getAddressSpace();
|
|
|
|
if (int Res = cmpNumbers(AddrSpaceL, AddrSpaceR))
|
|
|
|
return Res;
|
|
|
|
}
|
|
|
|
if (PTyL)
|
|
|
|
return 1;
|
|
|
|
if (PTyR)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
// TyL and TyR aren't vectors, nor pointers. We don't know how to
|
|
|
|
// bitcast them.
|
|
|
|
return TypesRes;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// OK, types are bitcastable, now check constant contents.
|
|
|
|
|
|
|
|
if (L->isNullValue() && R->isNullValue())
|
|
|
|
return TypesRes;
|
|
|
|
if (L->isNullValue() && !R->isNullValue())
|
|
|
|
return 1;
|
|
|
|
if (!L->isNullValue() && R->isNullValue())
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
if (int Res = cmpNumbers(L->getValueID(), R->getValueID()))
|
|
|
|
return Res;
|
|
|
|
|
|
|
|
switch (L->getValueID()) {
|
|
|
|
case Value::UndefValueVal: return TypesRes;
|
|
|
|
case Value::ConstantIntVal: {
|
|
|
|
const APInt &LInt = cast<ConstantInt>(L)->getValue();
|
|
|
|
const APInt &RInt = cast<ConstantInt>(R)->getValue();
|
2014-08-25 16:19:50 +08:00
|
|
|
return cmpAPInts(LInt, RInt);
|
2014-05-07 17:05:10 +08:00
|
|
|
}
|
|
|
|
case Value::ConstantFPVal: {
|
|
|
|
const APFloat &LAPF = cast<ConstantFP>(L)->getValueAPF();
|
|
|
|
const APFloat &RAPF = cast<ConstantFP>(R)->getValueAPF();
|
2014-08-25 16:22:46 +08:00
|
|
|
return cmpAPFloats(LAPF, RAPF);
|
2014-05-07 17:05:10 +08:00
|
|
|
}
|
|
|
|
case Value::ConstantArrayVal: {
|
|
|
|
const ConstantArray *LA = cast<ConstantArray>(L);
|
|
|
|
const ConstantArray *RA = cast<ConstantArray>(R);
|
|
|
|
uint64_t NumElementsL = cast<ArrayType>(TyL)->getNumElements();
|
|
|
|
uint64_t NumElementsR = cast<ArrayType>(TyR)->getNumElements();
|
|
|
|
if (int Res = cmpNumbers(NumElementsL, NumElementsR))
|
|
|
|
return Res;
|
|
|
|
for (uint64_t i = 0; i < NumElementsL; ++i) {
|
|
|
|
if (int Res = cmpConstants(cast<Constant>(LA->getOperand(i)),
|
|
|
|
cast<Constant>(RA->getOperand(i))))
|
|
|
|
return Res;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
case Value::ConstantStructVal: {
|
|
|
|
const ConstantStruct *LS = cast<ConstantStruct>(L);
|
|
|
|
const ConstantStruct *RS = cast<ConstantStruct>(R);
|
|
|
|
unsigned NumElementsL = cast<StructType>(TyL)->getNumElements();
|
|
|
|
unsigned NumElementsR = cast<StructType>(TyR)->getNumElements();
|
|
|
|
if (int Res = cmpNumbers(NumElementsL, NumElementsR))
|
|
|
|
return Res;
|
|
|
|
for (unsigned i = 0; i != NumElementsL; ++i) {
|
|
|
|
if (int Res = cmpConstants(cast<Constant>(LS->getOperand(i)),
|
|
|
|
cast<Constant>(RS->getOperand(i))))
|
|
|
|
return Res;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
case Value::ConstantVectorVal: {
|
|
|
|
const ConstantVector *LV = cast<ConstantVector>(L);
|
|
|
|
const ConstantVector *RV = cast<ConstantVector>(R);
|
|
|
|
unsigned NumElementsL = cast<VectorType>(TyL)->getNumElements();
|
|
|
|
unsigned NumElementsR = cast<VectorType>(TyR)->getNumElements();
|
|
|
|
if (int Res = cmpNumbers(NumElementsL, NumElementsR))
|
|
|
|
return Res;
|
|
|
|
for (uint64_t i = 0; i < NumElementsL; ++i) {
|
|
|
|
if (int Res = cmpConstants(cast<Constant>(LV->getOperand(i)),
|
|
|
|
cast<Constant>(RV->getOperand(i))))
|
|
|
|
return Res;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
case Value::ConstantExprVal: {
|
|
|
|
const ConstantExpr *LE = cast<ConstantExpr>(L);
|
|
|
|
const ConstantExpr *RE = cast<ConstantExpr>(R);
|
|
|
|
unsigned NumOperandsL = LE->getNumOperands();
|
|
|
|
unsigned NumOperandsR = RE->getNumOperands();
|
|
|
|
if (int Res = cmpNumbers(NumOperandsL, NumOperandsR))
|
|
|
|
return Res;
|
|
|
|
for (unsigned i = 0; i < NumOperandsL; ++i) {
|
|
|
|
if (int Res = cmpConstants(cast<Constant>(LE->getOperand(i)),
|
|
|
|
cast<Constant>(RE->getOperand(i))))
|
|
|
|
return Res;
|
|
|
|
}
|
|
|
|
return 0;
|
|
|
|
}
|
|
|
|
case Value::FunctionVal:
|
|
|
|
case Value::GlobalVariableVal:
|
|
|
|
case Value::GlobalAliasVal:
|
|
|
|
default: // Unknown constant, cast L and R pointers to numbers and compare.
|
|
|
|
return cmpNumbers((uint64_t)L, (uint64_t)R);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-03-13 19:54:50 +08:00
|
|
|
/// cmpType - compares two types,
|
|
|
|
/// defines total ordering among the types set.
|
|
|
|
/// See method declaration comments for more details.
|
2014-08-25 16:16:39 +08:00
|
|
|
int FunctionComparator::cmpTypes(Type *TyL, Type *TyR) const {
|
2013-11-27 00:11:03 +08:00
|
|
|
|
2014-03-14 16:48:52 +08:00
|
|
|
PointerType *PTyL = dyn_cast<PointerType>(TyL);
|
|
|
|
PointerType *PTyR = dyn_cast<PointerType>(TyR);
|
2013-11-27 00:11:03 +08:00
|
|
|
|
2015-03-10 10:37:25 +08:00
|
|
|
const DataLayout &DL = FnL->getParent()->getDataLayout();
|
|
|
|
if (PTyL && PTyL->getAddressSpace() == 0)
|
|
|
|
TyL = DL.getIntPtrType(TyL);
|
|
|
|
if (PTyR && PTyR->getAddressSpace() == 0)
|
|
|
|
TyR = DL.getIntPtrType(TyR);
|
2013-11-27 00:11:03 +08:00
|
|
|
|
2014-03-13 19:54:50 +08:00
|
|
|
if (TyL == TyR)
|
|
|
|
return 0;
|
2013-11-10 09:44:37 +08:00
|
|
|
|
2014-03-13 19:54:50 +08:00
|
|
|
if (int Res = cmpNumbers(TyL->getTypeID(), TyR->getTypeID()))
|
|
|
|
return Res;
|
2009-06-12 16:04:51 +08:00
|
|
|
|
2014-03-13 19:54:50 +08:00
|
|
|
switch (TyL->getTypeID()) {
|
2010-05-13 13:48:45 +08:00
|
|
|
default:
|
|
|
|
llvm_unreachable("Unknown type!");
|
2010-07-07 15:48:00 +08:00
|
|
|
// Fall through in Release mode.
|
2010-05-13 13:48:45 +08:00
|
|
|
case Type::IntegerTyID:
|
2011-01-26 16:50:18 +08:00
|
|
|
case Type::VectorTyID:
|
2014-03-13 19:54:50 +08:00
|
|
|
// TyL == TyR would have returned true earlier.
|
|
|
|
return cmpNumbers((uint64_t)TyL, (uint64_t)TyR);
|
2010-05-13 13:48:45 +08:00
|
|
|
|
2009-06-12 16:04:51 +08:00
|
|
|
case Type::VoidTyID:
|
|
|
|
case Type::FloatTyID:
|
|
|
|
case Type::DoubleTyID:
|
|
|
|
case Type::X86_FP80TyID:
|
|
|
|
case Type::FP128TyID:
|
|
|
|
case Type::PPC_FP128TyID:
|
|
|
|
case Type::LabelTyID:
|
|
|
|
case Type::MetadataTyID:
|
2014-03-13 19:54:50 +08:00
|
|
|
return 0;
|
2009-06-12 16:04:51 +08:00
|
|
|
|
|
|
|
case Type::PointerTyID: {
|
2014-03-14 16:48:52 +08:00
|
|
|
assert(PTyL && PTyR && "Both types must be pointers here.");
|
|
|
|
return cmpNumbers(PTyL->getAddressSpace(), PTyR->getAddressSpace());
|
2009-06-12 16:04:51 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
case Type::StructTyID: {
|
2014-03-14 16:48:52 +08:00
|
|
|
StructType *STyL = cast<StructType>(TyL);
|
|
|
|
StructType *STyR = cast<StructType>(TyR);
|
|
|
|
if (STyL->getNumElements() != STyR->getNumElements())
|
|
|
|
return cmpNumbers(STyL->getNumElements(), STyR->getNumElements());
|
2009-06-12 16:04:51 +08:00
|
|
|
|
2014-03-14 16:48:52 +08:00
|
|
|
if (STyL->isPacked() != STyR->isPacked())
|
|
|
|
return cmpNumbers(STyL->isPacked(), STyR->isPacked());
|
2009-06-12 16:04:51 +08:00
|
|
|
|
2014-03-14 16:48:52 +08:00
|
|
|
for (unsigned i = 0, e = STyL->getNumElements(); i != e; ++i) {
|
2014-08-25 16:16:39 +08:00
|
|
|
if (int Res = cmpTypes(STyL->getElementType(i), STyR->getElementType(i)))
|
2014-03-13 19:54:50 +08:00
|
|
|
return Res;
|
2009-06-12 16:04:51 +08:00
|
|
|
}
|
2014-03-13 19:54:50 +08:00
|
|
|
return 0;
|
2009-06-12 16:04:51 +08:00
|
|
|
}
|
|
|
|
|
|
|
|
case Type::FunctionTyID: {
|
2014-03-14 16:48:52 +08:00
|
|
|
FunctionType *FTyL = cast<FunctionType>(TyL);
|
|
|
|
FunctionType *FTyR = cast<FunctionType>(TyR);
|
|
|
|
if (FTyL->getNumParams() != FTyR->getNumParams())
|
|
|
|
return cmpNumbers(FTyL->getNumParams(), FTyR->getNumParams());
|
2014-03-13 19:54:50 +08:00
|
|
|
|
2014-03-14 16:48:52 +08:00
|
|
|
if (FTyL->isVarArg() != FTyR->isVarArg())
|
|
|
|
return cmpNumbers(FTyL->isVarArg(), FTyR->isVarArg());
|
2009-06-12 16:04:51 +08:00
|
|
|
|
2014-08-25 16:16:39 +08:00
|
|
|
if (int Res = cmpTypes(FTyL->getReturnType(), FTyR->getReturnType()))
|
2014-03-13 19:54:50 +08:00
|
|
|
return Res;
|
2009-06-12 16:04:51 +08:00
|
|
|
|
2014-03-14 16:48:52 +08:00
|
|
|
for (unsigned i = 0, e = FTyL->getNumParams(); i != e; ++i) {
|
2014-08-25 16:16:39 +08:00
|
|
|
if (int Res = cmpTypes(FTyL->getParamType(i), FTyR->getParamType(i)))
|
2014-03-13 19:54:50 +08:00
|
|
|
return Res;
|
2009-06-12 16:04:51 +08:00
|
|
|
}
|
2014-03-13 19:54:50 +08:00
|
|
|
return 0;
|
2009-06-12 16:04:51 +08:00
|
|
|
}
|
|
|
|
|
2010-07-16 14:31:12 +08:00
|
|
|
case Type::ArrayTyID: {
|
2014-03-14 16:48:52 +08:00
|
|
|
ArrayType *ATyL = cast<ArrayType>(TyL);
|
|
|
|
ArrayType *ATyR = cast<ArrayType>(TyR);
|
|
|
|
if (ATyL->getNumElements() != ATyR->getNumElements())
|
|
|
|
return cmpNumbers(ATyL->getNumElements(), ATyR->getNumElements());
|
2014-08-25 16:16:39 +08:00
|
|
|
return cmpTypes(ATyL->getElementType(), ATyR->getElementType());
|
2009-06-12 16:04:51 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-01-28 16:43:14 +08:00
|
|
|
// Determine whether the two operations are the same except that pointer-to-A
|
|
|
|
// and pointer-to-B are equivalent. This should be kept in sync with
|
|
|
|
// Instruction::isSameOperationAs.
|
2014-05-16 19:02:22 +08:00
|
|
|
// Read method declaration comments for more details.
|
2014-07-31 15:16:59 +08:00
|
|
|
int FunctionComparator::cmpOperations(const Instruction *L,
|
|
|
|
const Instruction *R) const {
|
2011-02-06 13:04:00 +08:00
|
|
|
// Differences from Instruction::isSameOperationAs:
|
|
|
|
// * replace type comparison with calls to isEquivalentType.
|
|
|
|
// * we test for I->hasSameSubclassOptionalData (nuw/nsw/tail) at the top
|
|
|
|
// * because of the above, we don't test for the tail bit on calls later on
|
2014-05-16 19:02:22 +08:00
|
|
|
if (int Res = cmpNumbers(L->getOpcode(), R->getOpcode()))
|
|
|
|
return Res;
|
|
|
|
|
|
|
|
if (int Res = cmpNumbers(L->getNumOperands(), R->getNumOperands()))
|
|
|
|
return Res;
|
|
|
|
|
2014-08-25 16:16:39 +08:00
|
|
|
if (int Res = cmpTypes(L->getType(), R->getType()))
|
2014-05-16 19:02:22 +08:00
|
|
|
return Res;
|
|
|
|
|
|
|
|
if (int Res = cmpNumbers(L->getRawSubclassOptionalData(),
|
|
|
|
R->getRawSubclassOptionalData()))
|
|
|
|
return Res;
|
2009-06-12 16:04:51 +08:00
|
|
|
|
2015-05-13 05:42:22 +08:00
|
|
|
if (const AllocaInst *AI = dyn_cast<AllocaInst>(L)) {
|
|
|
|
if (int Res = cmpTypes(AI->getAllocatedType(),
|
|
|
|
cast<AllocaInst>(R)->getAllocatedType()))
|
|
|
|
return Res;
|
|
|
|
if (int Res =
|
|
|
|
cmpNumbers(AI->getAlignment(), cast<AllocaInst>(R)->getAlignment()))
|
|
|
|
return Res;
|
|
|
|
}
|
|
|
|
|
2009-06-12 16:04:51 +08:00
|
|
|
// We have two instructions of identical opcode and #operands. Check to see
|
|
|
|
// if all operands are the same type
|
2014-05-16 19:02:22 +08:00
|
|
|
for (unsigned i = 0, e = L->getNumOperands(); i != e; ++i) {
|
|
|
|
if (int Res =
|
2014-08-25 16:16:39 +08:00
|
|
|
cmpTypes(L->getOperand(i)->getType(), R->getOperand(i)->getType()))
|
2014-05-16 19:02:22 +08:00
|
|
|
return Res;
|
|
|
|
}
|
2009-06-12 16:04:51 +08:00
|
|
|
|
|
|
|
// Check special state that is a part of some instructions.
|
2014-05-16 19:02:22 +08:00
|
|
|
if (const LoadInst *LI = dyn_cast<LoadInst>(L)) {
|
|
|
|
if (int Res = cmpNumbers(LI->isVolatile(), cast<LoadInst>(R)->isVolatile()))
|
|
|
|
return Res;
|
|
|
|
if (int Res =
|
|
|
|
cmpNumbers(LI->getAlignment(), cast<LoadInst>(R)->getAlignment()))
|
|
|
|
return Res;
|
|
|
|
if (int Res =
|
|
|
|
cmpNumbers(LI->getOrdering(), cast<LoadInst>(R)->getOrdering()))
|
|
|
|
return Res;
|
2014-06-21 03:11:56 +08:00
|
|
|
if (int Res =
|
|
|
|
cmpNumbers(LI->getSynchScope(), cast<LoadInst>(R)->getSynchScope()))
|
|
|
|
return Res;
|
|
|
|
return cmpNumbers((uint64_t)LI->getMetadata(LLVMContext::MD_range),
|
|
|
|
(uint64_t)cast<LoadInst>(R)->getMetadata(LLVMContext::MD_range));
|
2014-05-16 19:02:22 +08:00
|
|
|
}
|
|
|
|
if (const StoreInst *SI = dyn_cast<StoreInst>(L)) {
|
|
|
|
if (int Res =
|
|
|
|
cmpNumbers(SI->isVolatile(), cast<StoreInst>(R)->isVolatile()))
|
|
|
|
return Res;
|
|
|
|
if (int Res =
|
|
|
|
cmpNumbers(SI->getAlignment(), cast<StoreInst>(R)->getAlignment()))
|
|
|
|
return Res;
|
|
|
|
if (int Res =
|
|
|
|
cmpNumbers(SI->getOrdering(), cast<StoreInst>(R)->getOrdering()))
|
|
|
|
return Res;
|
|
|
|
return cmpNumbers(SI->getSynchScope(), cast<StoreInst>(R)->getSynchScope());
|
|
|
|
}
|
|
|
|
if (const CmpInst *CI = dyn_cast<CmpInst>(L))
|
|
|
|
return cmpNumbers(CI->getPredicate(), cast<CmpInst>(R)->getPredicate());
|
|
|
|
if (const CallInst *CI = dyn_cast<CallInst>(L)) {
|
|
|
|
if (int Res = cmpNumbers(CI->getCallingConv(),
|
|
|
|
cast<CallInst>(R)->getCallingConv()))
|
|
|
|
return Res;
|
2014-07-15 18:46:51 +08:00
|
|
|
if (int Res =
|
|
|
|
cmpAttrs(CI->getAttributes(), cast<CallInst>(R)->getAttributes()))
|
|
|
|
return Res;
|
|
|
|
return cmpNumbers(
|
|
|
|
(uint64_t)CI->getMetadata(LLVMContext::MD_range),
|
|
|
|
(uint64_t)cast<CallInst>(R)->getMetadata(LLVMContext::MD_range));
|
2014-05-16 19:02:22 +08:00
|
|
|
}
|
|
|
|
if (const InvokeInst *CI = dyn_cast<InvokeInst>(L)) {
|
|
|
|
if (int Res = cmpNumbers(CI->getCallingConv(),
|
|
|
|
cast<InvokeInst>(R)->getCallingConv()))
|
|
|
|
return Res;
|
2014-07-15 18:46:51 +08:00
|
|
|
if (int Res =
|
|
|
|
cmpAttrs(CI->getAttributes(), cast<InvokeInst>(R)->getAttributes()))
|
|
|
|
return Res;
|
|
|
|
return cmpNumbers(
|
|
|
|
(uint64_t)CI->getMetadata(LLVMContext::MD_range),
|
|
|
|
(uint64_t)cast<InvokeInst>(R)->getMetadata(LLVMContext::MD_range));
|
2014-05-16 19:02:22 +08:00
|
|
|
}
|
|
|
|
if (const InsertValueInst *IVI = dyn_cast<InsertValueInst>(L)) {
|
|
|
|
ArrayRef<unsigned> LIndices = IVI->getIndices();
|
|
|
|
ArrayRef<unsigned> RIndices = cast<InsertValueInst>(R)->getIndices();
|
|
|
|
if (int Res = cmpNumbers(LIndices.size(), RIndices.size()))
|
|
|
|
return Res;
|
|
|
|
for (size_t i = 0, e = LIndices.size(); i != e; ++i) {
|
|
|
|
if (int Res = cmpNumbers(LIndices[i], RIndices[i]))
|
|
|
|
return Res;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (const ExtractValueInst *EVI = dyn_cast<ExtractValueInst>(L)) {
|
|
|
|
ArrayRef<unsigned> LIndices = EVI->getIndices();
|
|
|
|
ArrayRef<unsigned> RIndices = cast<ExtractValueInst>(R)->getIndices();
|
|
|
|
if (int Res = cmpNumbers(LIndices.size(), RIndices.size()))
|
|
|
|
return Res;
|
|
|
|
for (size_t i = 0, e = LIndices.size(); i != e; ++i) {
|
|
|
|
if (int Res = cmpNumbers(LIndices[i], RIndices[i]))
|
|
|
|
return Res;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
if (const FenceInst *FI = dyn_cast<FenceInst>(L)) {
|
|
|
|
if (int Res =
|
|
|
|
cmpNumbers(FI->getOrdering(), cast<FenceInst>(R)->getOrdering()))
|
|
|
|
return Res;
|
|
|
|
return cmpNumbers(FI->getSynchScope(), cast<FenceInst>(R)->getSynchScope());
|
|
|
|
}
|
|
|
|
|
|
|
|
if (const AtomicCmpXchgInst *CXI = dyn_cast<AtomicCmpXchgInst>(L)) {
|
|
|
|
if (int Res = cmpNumbers(CXI->isVolatile(),
|
|
|
|
cast<AtomicCmpXchgInst>(R)->isVolatile()))
|
|
|
|
return Res;
|
IR: add "cmpxchg weak" variant to support permitted failure.
This commit adds a weak variant of the cmpxchg operation, as described
in C++11. A cmpxchg instruction with this modifier is permitted to
fail to store, even if the comparison indicated it should.
As a result, cmpxchg instructions must return a flag indicating
success in addition to their original iN value loaded. Thus, for
uniformity *all* cmpxchg instructions now return "{ iN, i1 }". The
second flag is 1 when the store succeeded.
At the DAG level, a new ATOMIC_CMP_SWAP_WITH_SUCCESS node has been
added as the natural representation for the new cmpxchg instructions.
It is a strong cmpxchg.
By default this gets Expanded to the existing ATOMIC_CMP_SWAP during
Legalization, so existing backends should see no change in behaviour.
If they wish to deal with the enhanced node instead, they can call
setOperationAction on it. Beware: as a node with 2 results, it cannot
be selected from TableGen.
Currently, no use is made of the extra information provided in this
patch. Test updates are almost entirely adapting the input IR to the
new scheme.
Summary for out of tree users:
------------------------------
+ Legacy Bitcode files are upgraded during read.
+ Legacy assembly IR files will be invalid.
+ Front-ends must adapt to different type for "cmpxchg".
+ Backends should be unaffected by default.
llvm-svn: 210903
2014-06-13 22:24:07 +08:00
|
|
|
if (int Res = cmpNumbers(CXI->isWeak(),
|
|
|
|
cast<AtomicCmpXchgInst>(R)->isWeak()))
|
|
|
|
return Res;
|
2014-05-16 19:02:22 +08:00
|
|
|
if (int Res = cmpNumbers(CXI->getSuccessOrdering(),
|
|
|
|
cast<AtomicCmpXchgInst>(R)->getSuccessOrdering()))
|
|
|
|
return Res;
|
|
|
|
if (int Res = cmpNumbers(CXI->getFailureOrdering(),
|
|
|
|
cast<AtomicCmpXchgInst>(R)->getFailureOrdering()))
|
|
|
|
return Res;
|
|
|
|
return cmpNumbers(CXI->getSynchScope(),
|
|
|
|
cast<AtomicCmpXchgInst>(R)->getSynchScope());
|
|
|
|
}
|
|
|
|
if (const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(L)) {
|
|
|
|
if (int Res = cmpNumbers(RMWI->getOperation(),
|
|
|
|
cast<AtomicRMWInst>(R)->getOperation()))
|
|
|
|
return Res;
|
|
|
|
if (int Res = cmpNumbers(RMWI->isVolatile(),
|
|
|
|
cast<AtomicRMWInst>(R)->isVolatile()))
|
|
|
|
return Res;
|
|
|
|
if (int Res = cmpNumbers(RMWI->getOrdering(),
|
|
|
|
cast<AtomicRMWInst>(R)->getOrdering()))
|
|
|
|
return Res;
|
|
|
|
return cmpNumbers(RMWI->getSynchScope(),
|
|
|
|
cast<AtomicRMWInst>(R)->getSynchScope());
|
|
|
|
}
|
|
|
|
return 0;
|
2008-11-02 13:52:50 +08:00
|
|
|
}
|
|
|
|
|
2011-01-28 16:43:14 +08:00
|
|
|
// Determine whether two GEP operations perform the same underlying arithmetic.
|
2014-05-16 19:55:02 +08:00
|
|
|
// Read method declaration comments for more details.
|
2014-08-25 16:12:45 +08:00
|
|
|
int FunctionComparator::cmpGEPs(const GEPOperator *GEPL,
|
2014-05-16 19:55:02 +08:00
|
|
|
const GEPOperator *GEPR) {
|
|
|
|
|
|
|
|
unsigned int ASL = GEPL->getPointerAddressSpace();
|
|
|
|
unsigned int ASR = GEPR->getPointerAddressSpace();
|
|
|
|
|
|
|
|
if (int Res = cmpNumbers(ASL, ASR))
|
|
|
|
return Res;
|
2013-11-10 09:44:37 +08:00
|
|
|
|
2014-05-16 19:55:02 +08:00
|
|
|
// When we have target data, we can reduce the GEP down to the value in bytes
|
|
|
|
// added to the address.
|
2015-03-10 10:37:25 +08:00
|
|
|
const DataLayout &DL = FnL->getParent()->getDataLayout();
|
|
|
|
unsigned BitWidth = DL.getPointerSizeInBits(ASL);
|
|
|
|
APInt OffsetL(BitWidth, 0), OffsetR(BitWidth, 0);
|
|
|
|
if (GEPL->accumulateConstantOffset(DL, OffsetL) &&
|
|
|
|
GEPR->accumulateConstantOffset(DL, OffsetR))
|
|
|
|
return cmpAPInts(OffsetL, OffsetR);
|
2008-11-02 13:52:50 +08:00
|
|
|
|
2014-05-16 19:55:02 +08:00
|
|
|
if (int Res = cmpNumbers((uint64_t)GEPL->getPointerOperand()->getType(),
|
|
|
|
(uint64_t)GEPR->getPointerOperand()->getType()))
|
|
|
|
return Res;
|
2008-11-02 13:52:50 +08:00
|
|
|
|
2014-05-16 19:55:02 +08:00
|
|
|
if (int Res = cmpNumbers(GEPL->getNumOperands(), GEPR->getNumOperands()))
|
|
|
|
return Res;
|
2008-11-02 13:52:50 +08:00
|
|
|
|
2014-05-16 19:55:02 +08:00
|
|
|
for (unsigned i = 0, e = GEPL->getNumOperands(); i != e; ++i) {
|
|
|
|
if (int Res = cmpValues(GEPL->getOperand(i), GEPR->getOperand(i)))
|
|
|
|
return Res;
|
2008-11-02 13:52:50 +08:00
|
|
|
}
|
|
|
|
|
2014-05-16 19:55:02 +08:00
|
|
|
return 0;
|
2008-11-02 13:52:50 +08:00
|
|
|
}
|
|
|
|
|
2014-05-07 19:11:39 +08:00
|
|
|
/// Compare two values used by the two functions under pair-wise comparison. If
|
|
|
|
/// this is the first time the values are seen, they're added to the mapping so
|
|
|
|
/// that we will detect mismatches on next use.
|
|
|
|
/// See comments in declaration for more details.
|
|
|
|
int FunctionComparator::cmpValues(const Value *L, const Value *R) {
|
|
|
|
// Catch self-reference case.
|
2014-06-22 01:55:51 +08:00
|
|
|
if (L == FnL) {
|
|
|
|
if (R == FnR)
|
2014-05-07 19:11:39 +08:00
|
|
|
return 0;
|
|
|
|
return -1;
|
|
|
|
}
|
2014-06-22 01:55:51 +08:00
|
|
|
if (R == FnR) {
|
|
|
|
if (L == FnL)
|
2014-05-07 19:11:39 +08:00
|
|
|
return 0;
|
|
|
|
return 1;
|
2011-01-27 16:38:19 +08:00
|
|
|
}
|
2008-11-02 13:52:50 +08:00
|
|
|
|
2014-05-07 19:11:39 +08:00
|
|
|
const Constant *ConstL = dyn_cast<Constant>(L);
|
|
|
|
const Constant *ConstR = dyn_cast<Constant>(R);
|
|
|
|
if (ConstL && ConstR) {
|
|
|
|
if (L == R)
|
|
|
|
return 0;
|
|
|
|
return cmpConstants(ConstL, ConstR);
|
|
|
|
}
|
2008-11-02 13:52:50 +08:00
|
|
|
|
2014-05-07 19:11:39 +08:00
|
|
|
if (ConstL)
|
|
|
|
return 1;
|
|
|
|
if (ConstR)
|
|
|
|
return -1;
|
2010-05-13 13:48:45 +08:00
|
|
|
|
2014-05-07 19:11:39 +08:00
|
|
|
const InlineAsm *InlineAsmL = dyn_cast<InlineAsm>(L);
|
|
|
|
const InlineAsm *InlineAsmR = dyn_cast<InlineAsm>(R);
|
2010-05-13 13:48:45 +08:00
|
|
|
|
2014-05-07 19:11:39 +08:00
|
|
|
if (InlineAsmL && InlineAsmR)
|
|
|
|
return cmpNumbers((uint64_t)L, (uint64_t)R);
|
|
|
|
if (InlineAsmL)
|
|
|
|
return 1;
|
|
|
|
if (InlineAsmR)
|
|
|
|
return -1;
|
|
|
|
|
|
|
|
auto LeftSN = sn_mapL.insert(std::make_pair(L, sn_mapL.size())),
|
|
|
|
RightSN = sn_mapR.insert(std::make_pair(R, sn_mapR.size()));
|
|
|
|
|
|
|
|
return cmpNumbers(LeftSN.first->second, RightSN.first->second);
|
|
|
|
}
|
2011-01-28 16:43:14 +08:00
|
|
|
// Test whether two basic blocks have equivalent behaviour.
|
2014-06-22 01:55:51 +08:00
|
|
|
int FunctionComparator::compare(const BasicBlock *BBL, const BasicBlock *BBR) {
|
|
|
|
BasicBlock::const_iterator InstL = BBL->begin(), InstLE = BBL->end();
|
|
|
|
BasicBlock::const_iterator InstR = BBR->begin(), InstRE = BBR->end();
|
2008-11-02 13:52:50 +08:00
|
|
|
|
2010-05-13 13:48:45 +08:00
|
|
|
do {
|
2014-06-22 01:55:51 +08:00
|
|
|
if (int Res = cmpValues(InstL, InstR))
|
|
|
|
return Res;
|
2008-11-02 13:52:50 +08:00
|
|
|
|
2014-06-22 01:55:51 +08:00
|
|
|
const GetElementPtrInst *GEPL = dyn_cast<GetElementPtrInst>(InstL);
|
|
|
|
const GetElementPtrInst *GEPR = dyn_cast<GetElementPtrInst>(InstR);
|
2008-11-02 13:52:50 +08:00
|
|
|
|
2014-06-22 01:55:51 +08:00
|
|
|
if (GEPL && !GEPR)
|
|
|
|
return 1;
|
|
|
|
if (GEPR && !GEPL)
|
|
|
|
return -1;
|
2008-11-02 13:52:50 +08:00
|
|
|
|
2014-06-22 01:55:51 +08:00
|
|
|
if (GEPL && GEPR) {
|
|
|
|
if (int Res =
|
|
|
|
cmpValues(GEPL->getPointerOperand(), GEPR->getPointerOperand()))
|
|
|
|
return Res;
|
2014-08-25 16:12:45 +08:00
|
|
|
if (int Res = cmpGEPs(GEPL, GEPR))
|
2014-06-22 01:55:51 +08:00
|
|
|
return Res;
|
2010-05-13 13:48:45 +08:00
|
|
|
} else {
|
2014-07-31 15:16:59 +08:00
|
|
|
if (int Res = cmpOperations(InstL, InstR))
|
2014-06-22 01:55:51 +08:00
|
|
|
return Res;
|
|
|
|
assert(InstL->getNumOperands() == InstR->getNumOperands());
|
2010-05-13 13:48:45 +08:00
|
|
|
|
2014-06-22 01:55:51 +08:00
|
|
|
for (unsigned i = 0, e = InstL->getNumOperands(); i != e; ++i) {
|
|
|
|
Value *OpL = InstL->getOperand(i);
|
|
|
|
Value *OpR = InstR->getOperand(i);
|
|
|
|
if (int Res = cmpValues(OpL, OpR))
|
|
|
|
return Res;
|
|
|
|
if (int Res = cmpNumbers(OpL->getValueID(), OpR->getValueID()))
|
|
|
|
return Res;
|
|
|
|
// TODO: Already checked in cmpOperation
|
2014-08-25 16:16:39 +08:00
|
|
|
if (int Res = cmpTypes(OpL->getType(), OpR->getType()))
|
2014-06-22 01:55:51 +08:00
|
|
|
return Res;
|
2008-11-02 13:52:50 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2014-06-22 01:55:51 +08:00
|
|
|
++InstL, ++InstR;
|
|
|
|
} while (InstL != InstLE && InstR != InstRE);
|
2008-11-02 13:52:50 +08:00
|
|
|
|
2014-06-22 01:55:51 +08:00
|
|
|
if (InstL != InstLE && InstR == InstRE)
|
|
|
|
return 1;
|
|
|
|
if (InstL == InstLE && InstR != InstRE)
|
|
|
|
return -1;
|
|
|
|
return 0;
|
2008-11-02 13:52:50 +08:00
|
|
|
}
|
|
|
|
|
2011-01-28 16:43:14 +08:00
|
|
|
// Test whether the two functions have equivalent behaviour.
|
2014-06-22 01:55:51 +08:00
|
|
|
int FunctionComparator::compare() {
|
2008-11-02 13:52:50 +08:00
|
|
|
|
2014-05-07 19:11:39 +08:00
|
|
|
sn_mapL.clear();
|
|
|
|
sn_mapR.clear();
|
|
|
|
|
2014-06-22 01:55:51 +08:00
|
|
|
if (int Res = cmpAttrs(FnL->getAttributes(), FnR->getAttributes()))
|
|
|
|
return Res;
|
2008-11-02 13:52:50 +08:00
|
|
|
|
2014-06-22 01:55:51 +08:00
|
|
|
if (int Res = cmpNumbers(FnL->hasGC(), FnR->hasGC()))
|
|
|
|
return Res;
|
2008-11-02 13:52:50 +08:00
|
|
|
|
2014-06-22 01:55:51 +08:00
|
|
|
if (FnL->hasGC()) {
|
|
|
|
if (int Res = cmpNumbers((uint64_t)FnL->getGC(), (uint64_t)FnR->getGC()))
|
|
|
|
return Res;
|
|
|
|
}
|
2008-11-02 13:52:50 +08:00
|
|
|
|
2014-06-22 01:55:51 +08:00
|
|
|
if (int Res = cmpNumbers(FnL->hasSection(), FnR->hasSection()))
|
|
|
|
return Res;
|
2008-11-02 13:52:50 +08:00
|
|
|
|
2014-06-22 01:55:51 +08:00
|
|
|
if (FnL->hasSection()) {
|
|
|
|
if (int Res = cmpStrings(FnL->getSection(), FnR->getSection()))
|
|
|
|
return Res;
|
|
|
|
}
|
2008-11-02 13:52:50 +08:00
|
|
|
|
2014-06-22 01:55:51 +08:00
|
|
|
if (int Res = cmpNumbers(FnL->isVarArg(), FnR->isVarArg()))
|
|
|
|
return Res;
|
2009-06-12 16:04:51 +08:00
|
|
|
|
2008-11-02 13:52:50 +08:00
|
|
|
// TODO: if it's internal and only used in direct calls, we could handle this
|
|
|
|
// case too.
|
2014-06-22 01:55:51 +08:00
|
|
|
if (int Res = cmpNumbers(FnL->getCallingConv(), FnR->getCallingConv()))
|
|
|
|
return Res;
|
2008-11-02 13:52:50 +08:00
|
|
|
|
2014-08-25 16:16:39 +08:00
|
|
|
if (int Res = cmpTypes(FnL->getFunctionType(), FnR->getFunctionType()))
|
2014-06-22 01:55:51 +08:00
|
|
|
return Res;
|
2008-11-02 13:52:50 +08:00
|
|
|
|
2014-06-22 01:55:51 +08:00
|
|
|
assert(FnL->arg_size() == FnR->arg_size() &&
|
2010-09-07 09:42:10 +08:00
|
|
|
"Identically typed functions have different numbers of args!");
|
2008-11-02 13:52:50 +08:00
|
|
|
|
2010-05-13 13:48:45 +08:00
|
|
|
// Visit the arguments so that they get enumerated in the order they're
|
|
|
|
// passed in.
|
2014-06-22 01:55:51 +08:00
|
|
|
for (Function::const_arg_iterator ArgLI = FnL->arg_begin(),
|
|
|
|
ArgRI = FnR->arg_begin(),
|
|
|
|
ArgLE = FnL->arg_end();
|
|
|
|
ArgLI != ArgLE; ++ArgLI, ++ArgRI) {
|
|
|
|
if (cmpValues(ArgLI, ArgRI) != 0)
|
2010-09-07 09:42:10 +08:00
|
|
|
llvm_unreachable("Arguments repeat!");
|
2010-05-13 13:48:45 +08:00
|
|
|
}
|
2008-11-02 13:52:50 +08:00
|
|
|
|
2010-08-08 13:04:23 +08:00
|
|
|
// We do a CFG-ordered walk since the actual ordering of the blocks in the
|
|
|
|
// linked list is immaterial. Our walk starts at the entry block for both
|
2010-08-02 13:23:03 +08:00
|
|
|
// functions, then takes each block from each terminator in order. As an
|
|
|
|
// artifact, this also means that unreachable blocks are ignored.
|
2014-06-22 01:55:51 +08:00
|
|
|
SmallVector<const BasicBlock *, 8> FnLBBs, FnRBBs;
|
2010-08-02 13:23:03 +08:00
|
|
|
SmallSet<const BasicBlock *, 128> VisitedBBs; // in terms of F1.
|
2010-08-06 15:21:30 +08:00
|
|
|
|
2014-06-22 01:55:51 +08:00
|
|
|
FnLBBs.push_back(&FnL->getEntryBlock());
|
|
|
|
FnRBBs.push_back(&FnR->getEntryBlock());
|
2010-08-06 15:21:30 +08:00
|
|
|
|
2014-06-22 01:55:51 +08:00
|
|
|
VisitedBBs.insert(FnLBBs[0]);
|
|
|
|
while (!FnLBBs.empty()) {
|
|
|
|
const BasicBlock *BBL = FnLBBs.pop_back_val();
|
|
|
|
const BasicBlock *BBR = FnRBBs.pop_back_val();
|
2010-08-06 15:21:30 +08:00
|
|
|
|
2014-06-22 01:55:51 +08:00
|
|
|
if (int Res = cmpValues(BBL, BBR))
|
|
|
|
return Res;
|
|
|
|
|
|
|
|
if (int Res = compare(BBL, BBR))
|
|
|
|
return Res;
|
2010-08-06 15:21:30 +08:00
|
|
|
|
2014-06-22 01:55:51 +08:00
|
|
|
const TerminatorInst *TermL = BBL->getTerminator();
|
|
|
|
const TerminatorInst *TermR = BBR->getTerminator();
|
2010-08-06 15:21:30 +08:00
|
|
|
|
2014-06-22 01:55:51 +08:00
|
|
|
assert(TermL->getNumSuccessors() == TermR->getNumSuccessors());
|
|
|
|
for (unsigned i = 0, e = TermL->getNumSuccessors(); i != e; ++i) {
|
2014-11-19 15:49:26 +08:00
|
|
|
if (!VisitedBBs.insert(TermL->getSuccessor(i)).second)
|
2010-05-13 14:45:13 +08:00
|
|
|
continue;
|
2010-08-06 15:21:30 +08:00
|
|
|
|
2014-06-22 01:55:51 +08:00
|
|
|
FnLBBs.push_back(TermL->getSuccessor(i));
|
|
|
|
FnRBBs.push_back(TermR->getSuccessor(i));
|
2010-05-13 13:48:45 +08:00
|
|
|
}
|
2008-11-02 13:52:50 +08:00
|
|
|
}
|
2014-06-22 01:55:51 +08:00
|
|
|
return 0;
|
2008-11-02 13:52:50 +08:00
|
|
|
}
|
|
|
|
|
2011-01-28 15:36:21 +08:00
|
|
|
namespace {
|
|
|
|
|
|
|
|
/// MergeFunctions finds functions which will generate identical machine code,
|
|
|
|
/// by considering all pointer types to be equivalent. Once identified,
|
|
|
|
/// MergeFunctions will fold them by replacing a call to one to a call to a
|
|
|
|
/// bitcast of the other.
|
|
|
|
///
|
|
|
|
class MergeFunctions : public ModulePass {
|
|
|
|
public:
|
|
|
|
static char ID;
|
|
|
|
MergeFunctions()
|
|
|
|
: ModulePass(ID), HasGlobalAliases(false) {
|
|
|
|
initializeMergeFunctionsPass(*PassRegistry::getPassRegistry());
|
|
|
|
}
|
|
|
|
|
2014-03-05 17:10:37 +08:00
|
|
|
bool runOnModule(Module &M) override;
|
2011-01-28 15:36:21 +08:00
|
|
|
|
|
|
|
private:
|
2014-09-10 18:08:25 +08:00
|
|
|
typedef std::set<FunctionNode> FnTreeType;
|
2011-01-28 15:36:21 +08:00
|
|
|
|
|
|
|
/// A work queue of functions that may have been modified and should be
|
|
|
|
/// analyzed again.
|
|
|
|
std::vector<WeakVH> Deferred;
|
|
|
|
|
2014-06-22 02:58:11 +08:00
|
|
|
/// Checks the rules of order relation introduced among functions set.
|
|
|
|
/// Returns true, if sanity check has been passed, and false if failed.
|
|
|
|
bool doSanityCheck(std::vector<WeakVH> &Worklist);
|
|
|
|
|
2014-06-22 04:54:36 +08:00
|
|
|
/// Insert a ComparableFunction into the FnTree, or merge it away if it's
|
2011-01-28 15:36:21 +08:00
|
|
|
/// equal to one that's already present.
|
2014-06-22 04:54:36 +08:00
|
|
|
bool insert(Function *NewFunction);
|
2011-01-28 15:36:21 +08:00
|
|
|
|
2014-06-22 04:54:36 +08:00
|
|
|
/// Remove a Function from the FnTree and queue it up for a second sweep of
|
2011-01-28 15:36:21 +08:00
|
|
|
/// analysis.
|
2011-01-28 16:43:14 +08:00
|
|
|
void remove(Function *F);
|
2011-01-28 15:36:21 +08:00
|
|
|
|
2014-06-22 04:54:36 +08:00
|
|
|
/// Find the functions that use this Value and remove them from FnTree and
|
2011-01-28 15:36:21 +08:00
|
|
|
/// queue the functions.
|
2011-01-28 16:43:14 +08:00
|
|
|
void removeUsers(Value *V);
|
2011-01-28 15:36:21 +08:00
|
|
|
|
|
|
|
/// Replace all direct calls of Old with calls of New. Will bitcast New if
|
|
|
|
/// necessary to make types match.
|
|
|
|
void replaceDirectCallers(Function *Old, Function *New);
|
|
|
|
|
2011-01-28 16:43:14 +08:00
|
|
|
/// Merge two equivalent functions. Upon completion, G may be deleted, or may
|
|
|
|
/// be converted into a thunk. In either case, it should never be visited
|
|
|
|
/// again.
|
|
|
|
void mergeTwoFunctions(Function *F, Function *G);
|
2011-01-28 15:36:21 +08:00
|
|
|
|
2011-01-28 16:43:14 +08:00
|
|
|
/// Replace G with a thunk or an alias to F. Deletes G.
|
|
|
|
void writeThunkOrAlias(Function *F, Function *G);
|
2011-01-28 15:36:21 +08:00
|
|
|
|
2011-01-28 16:43:14 +08:00
|
|
|
/// Replace G with a simple tail call to bitcast(F). Also replace direct uses
|
|
|
|
/// of G with bitcast(F). Deletes G.
|
|
|
|
void writeThunk(Function *F, Function *G);
|
2011-01-28 15:36:21 +08:00
|
|
|
|
2011-01-28 16:43:14 +08:00
|
|
|
/// Replace G with an alias to F. Deletes G.
|
|
|
|
void writeAlias(Function *F, Function *G);
|
2011-01-28 15:36:21 +08:00
|
|
|
|
2015-06-09 08:03:29 +08:00
|
|
|
/// Replace function F with function G in the function tree.
|
|
|
|
void replaceFunctionInTree(FnTreeType::iterator &IterToF, Function *G);
|
|
|
|
|
2011-01-28 16:43:14 +08:00
|
|
|
/// The set of all distinct functions. Use the insert() and remove() methods
|
|
|
|
/// to modify it.
|
2014-06-22 04:54:36 +08:00
|
|
|
FnTreeType FnTree;
|
2011-01-28 15:36:21 +08:00
|
|
|
|
|
|
|
/// Whether or not the target supports global aliases.
|
|
|
|
bool HasGlobalAliases;
|
|
|
|
};
|
|
|
|
|
|
|
|
} // end anonymous namespace
|
|
|
|
|
|
|
|
char MergeFunctions::ID = 0;
|
|
|
|
INITIALIZE_PASS(MergeFunctions, "mergefunc", "Merge Functions", false, false)
|
|
|
|
|
|
|
|
ModulePass *llvm::createMergeFunctionsPass() {
|
|
|
|
return new MergeFunctions();
|
|
|
|
}
|
|
|
|
|
2014-06-22 02:58:11 +08:00
|
|
|
bool MergeFunctions::doSanityCheck(std::vector<WeakVH> &Worklist) {
|
|
|
|
if (const unsigned Max = NumFunctionsForSanityCheck) {
|
|
|
|
unsigned TripleNumber = 0;
|
|
|
|
bool Valid = true;
|
|
|
|
|
|
|
|
dbgs() << "MERGEFUNC-SANITY: Started for first " << Max << " functions.\n";
|
|
|
|
|
|
|
|
unsigned i = 0;
|
|
|
|
for (std::vector<WeakVH>::iterator I = Worklist.begin(), E = Worklist.end();
|
|
|
|
I != E && i < Max; ++I, ++i) {
|
|
|
|
unsigned j = i;
|
|
|
|
for (std::vector<WeakVH>::iterator J = I; J != E && j < Max; ++J, ++j) {
|
|
|
|
Function *F1 = cast<Function>(*I);
|
|
|
|
Function *F2 = cast<Function>(*J);
|
2015-03-10 10:37:25 +08:00
|
|
|
int Res1 = FunctionComparator(F1, F2).compare();
|
|
|
|
int Res2 = FunctionComparator(F2, F1).compare();
|
2014-06-22 02:58:11 +08:00
|
|
|
|
|
|
|
// If F1 <= F2, then F2 >= F1, otherwise report failure.
|
|
|
|
if (Res1 != -Res2) {
|
|
|
|
dbgs() << "MERGEFUNC-SANITY: Non-symmetric; triple: " << TripleNumber
|
|
|
|
<< "\n";
|
|
|
|
F1->dump();
|
|
|
|
F2->dump();
|
|
|
|
Valid = false;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Res1 == 0)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
unsigned k = j;
|
|
|
|
for (std::vector<WeakVH>::iterator K = J; K != E && k < Max;
|
|
|
|
++k, ++K, ++TripleNumber) {
|
|
|
|
if (K == J)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
Function *F3 = cast<Function>(*K);
|
2015-03-10 10:37:25 +08:00
|
|
|
int Res3 = FunctionComparator(F1, F3).compare();
|
|
|
|
int Res4 = FunctionComparator(F2, F3).compare();
|
2014-06-22 02:58:11 +08:00
|
|
|
|
|
|
|
bool Transitive = true;
|
|
|
|
|
|
|
|
if (Res1 != 0 && Res1 == Res4) {
|
2014-06-22 03:07:51 +08:00
|
|
|
// F1 > F2, F2 > F3 => F1 > F3
|
2014-06-22 02:58:11 +08:00
|
|
|
Transitive = Res3 == Res1;
|
2014-06-22 03:07:51 +08:00
|
|
|
} else if (Res3 != 0 && Res3 == -Res4) {
|
|
|
|
// F1 > F3, F3 > F2 => F1 > F2
|
2014-06-22 02:58:11 +08:00
|
|
|
Transitive = Res3 == Res1;
|
2014-06-22 03:07:51 +08:00
|
|
|
} else if (Res4 != 0 && -Res3 == Res4) {
|
|
|
|
// F2 > F3, F3 > F1 => F2 > F1
|
2014-06-22 02:58:11 +08:00
|
|
|
Transitive = Res4 == -Res1;
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!Transitive) {
|
|
|
|
dbgs() << "MERGEFUNC-SANITY: Non-transitive; triple: "
|
|
|
|
<< TripleNumber << "\n";
|
|
|
|
dbgs() << "Res1, Res3, Res4: " << Res1 << ", " << Res3 << ", "
|
|
|
|
<< Res4 << "\n";
|
|
|
|
F1->dump();
|
|
|
|
F2->dump();
|
|
|
|
F3->dump();
|
|
|
|
Valid = false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
dbgs() << "MERGEFUNC-SANITY: " << (Valid ? "Passed." : "Failed.") << "\n";
|
|
|
|
return Valid;
|
|
|
|
}
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
2011-01-28 15:36:21 +08:00
|
|
|
bool MergeFunctions::runOnModule(Module &M) {
|
|
|
|
bool Changed = false;
|
|
|
|
|
|
|
|
for (Module::iterator I = M.begin(), E = M.end(); I != E; ++I) {
|
|
|
|
if (!I->isDeclaration() && !I->hasAvailableExternallyLinkage())
|
|
|
|
Deferred.push_back(WeakVH(I));
|
|
|
|
}
|
|
|
|
|
|
|
|
do {
|
|
|
|
std::vector<WeakVH> Worklist;
|
|
|
|
Deferred.swap(Worklist);
|
|
|
|
|
2014-06-22 02:58:11 +08:00
|
|
|
DEBUG(doSanityCheck(Worklist));
|
|
|
|
|
2011-01-28 15:36:21 +08:00
|
|
|
DEBUG(dbgs() << "size of module: " << M.size() << '\n');
|
|
|
|
DEBUG(dbgs() << "size of worklist: " << Worklist.size() << '\n');
|
|
|
|
|
|
|
|
// Insert only strong functions and merge them. Strong function merging
|
|
|
|
// always deletes one of them.
|
|
|
|
for (std::vector<WeakVH>::iterator I = Worklist.begin(),
|
|
|
|
E = Worklist.end(); I != E; ++I) {
|
|
|
|
if (!*I) continue;
|
|
|
|
Function *F = cast<Function>(*I);
|
|
|
|
if (!F->isDeclaration() && !F->hasAvailableExternallyLinkage() &&
|
|
|
|
!F->mayBeOverridden()) {
|
2014-06-22 04:54:36 +08:00
|
|
|
Changed |= insert(F);
|
2011-01-28 15:36:21 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
// Insert only weak functions and merge them. By doing these second we
|
|
|
|
// create thunks to the strong function when possible. When two weak
|
|
|
|
// functions are identical, we create a new strong function with two weak
|
|
|
|
// weak thunks to it which are identical but not mergable.
|
|
|
|
for (std::vector<WeakVH>::iterator I = Worklist.begin(),
|
|
|
|
E = Worklist.end(); I != E; ++I) {
|
|
|
|
if (!*I) continue;
|
|
|
|
Function *F = cast<Function>(*I);
|
|
|
|
if (!F->isDeclaration() && !F->hasAvailableExternallyLinkage() &&
|
|
|
|
F->mayBeOverridden()) {
|
2014-06-22 04:54:36 +08:00
|
|
|
Changed |= insert(F);
|
2011-01-28 15:36:21 +08:00
|
|
|
}
|
|
|
|
}
|
2014-06-22 04:54:36 +08:00
|
|
|
DEBUG(dbgs() << "size of FnTree: " << FnTree.size() << '\n');
|
2011-01-28 15:36:21 +08:00
|
|
|
} while (!Deferred.empty());
|
|
|
|
|
2014-06-22 04:54:36 +08:00
|
|
|
FnTree.clear();
|
2011-01-28 15:36:21 +08:00
|
|
|
|
|
|
|
return Changed;
|
|
|
|
}
|
|
|
|
|
2011-01-28 16:43:14 +08:00
|
|
|
// Replace direct callers of Old with New.
|
2011-01-25 16:56:50 +08:00
|
|
|
void MergeFunctions::replaceDirectCallers(Function *Old, Function *New) {
|
|
|
|
Constant *BitcastNew = ConstantExpr::getBitCast(New, Old->getType());
|
2014-03-09 11:16:01 +08:00
|
|
|
for (auto UI = Old->use_begin(), UE = Old->use_end(); UI != UE;) {
|
|
|
|
Use *U = &*UI;
|
2011-01-25 16:56:50 +08:00
|
|
|
++UI;
|
2014-03-09 11:16:01 +08:00
|
|
|
CallSite CS(U->getUser());
|
|
|
|
if (CS && CS.isCallee(U)) {
|
2011-01-28 16:43:14 +08:00
|
|
|
remove(CS.getInstruction()->getParent()->getParent());
|
2014-03-09 11:16:01 +08:00
|
|
|
U->set(BitcastNew);
|
2011-01-25 16:56:50 +08:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-01-28 16:43:14 +08:00
|
|
|
// Replace G with an alias to F if possible, or else a thunk to F. Deletes G.
|
|
|
|
void MergeFunctions::writeThunkOrAlias(Function *F, Function *G) {
|
2011-01-25 16:56:50 +08:00
|
|
|
if (HasGlobalAliases && G->hasUnnamedAddr()) {
|
|
|
|
if (G->hasExternalLinkage() || G->hasLocalLinkage() ||
|
|
|
|
G->hasWeakLinkage()) {
|
2011-01-28 16:43:14 +08:00
|
|
|
writeAlias(F, G);
|
2011-01-25 16:56:50 +08:00
|
|
|
return;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-01-28 16:43:14 +08:00
|
|
|
writeThunk(F, G);
|
2011-01-25 16:56:50 +08:00
|
|
|
}
|
|
|
|
|
2013-09-17 17:36:11 +08:00
|
|
|
// Helper for writeThunk,
|
|
|
|
// Selects proper bitcast operation,
|
2014-01-25 01:20:08 +08:00
|
|
|
// but a bit simpler then CastInst::getCastOpcode.
|
2014-05-01 01:53:04 +08:00
|
|
|
static Value *createCast(IRBuilder<false> &Builder, Value *V, Type *DestTy) {
|
2013-09-17 17:36:11 +08:00
|
|
|
Type *SrcTy = V->getType();
|
2014-05-01 01:53:04 +08:00
|
|
|
if (SrcTy->isStructTy()) {
|
|
|
|
assert(DestTy->isStructTy());
|
|
|
|
assert(SrcTy->getStructNumElements() == DestTy->getStructNumElements());
|
|
|
|
Value *Result = UndefValue::get(DestTy);
|
|
|
|
for (unsigned int I = 0, E = SrcTy->getStructNumElements(); I < E; ++I) {
|
|
|
|
Value *Element = createCast(
|
2014-08-27 13:25:25 +08:00
|
|
|
Builder, Builder.CreateExtractValue(V, makeArrayRef(I)),
|
2014-05-01 01:53:04 +08:00
|
|
|
DestTy->getStructElementType(I));
|
|
|
|
|
|
|
|
Result =
|
2014-08-27 13:25:25 +08:00
|
|
|
Builder.CreateInsertValue(Result, Element, makeArrayRef(I));
|
2014-05-01 01:53:04 +08:00
|
|
|
}
|
|
|
|
return Result;
|
|
|
|
}
|
|
|
|
assert(!DestTy->isStructTy());
|
2013-09-17 17:36:11 +08:00
|
|
|
if (SrcTy->isIntegerTy() && DestTy->isPointerTy())
|
|
|
|
return Builder.CreateIntToPtr(V, DestTy);
|
|
|
|
else if (SrcTy->isPointerTy() && DestTy->isIntegerTy())
|
|
|
|
return Builder.CreatePtrToInt(V, DestTy);
|
|
|
|
else
|
|
|
|
return Builder.CreateBitCast(V, DestTy);
|
|
|
|
}
|
|
|
|
|
2011-01-28 16:43:14 +08:00
|
|
|
// Replace G with a simple tail call to bitcast(F). Also replace direct uses
|
|
|
|
// of G with bitcast(F). Deletes G.
|
|
|
|
void MergeFunctions::writeThunk(Function *F, Function *G) {
|
2010-05-13 13:48:45 +08:00
|
|
|
if (!G->mayBeOverridden()) {
|
|
|
|
// Redirect direct callers of G to F.
|
2011-01-25 16:56:50 +08:00
|
|
|
replaceDirectCallers(G, F);
|
2010-05-13 13:48:45 +08:00
|
|
|
}
|
|
|
|
|
2010-09-07 09:42:10 +08:00
|
|
|
// If G was internal then we may have replaced all uses of G with F. If so,
|
2010-08-06 15:21:30 +08:00
|
|
|
// stop here and delete G. There's no need for a thunk.
|
|
|
|
if (G->hasLocalLinkage() && G->use_empty()) {
|
|
|
|
G->eraseFromParent();
|
|
|
|
return;
|
|
|
|
}
|
|
|
|
|
2009-06-12 23:56:56 +08:00
|
|
|
Function *NewG = Function::Create(G->getFunctionType(), G->getLinkage(), "",
|
|
|
|
G->getParent());
|
2009-08-14 05:58:54 +08:00
|
|
|
BasicBlock *BB = BasicBlock::Create(F->getContext(), "", NewG);
|
2010-08-08 13:04:23 +08:00
|
|
|
IRBuilder<false> Builder(BB);
|
2009-06-12 16:04:51 +08:00
|
|
|
|
2010-05-13 13:48:45 +08:00
|
|
|
SmallVector<Value *, 16> Args;
|
2009-06-12 16:04:51 +08:00
|
|
|
unsigned i = 0;
|
2011-07-18 12:54:35 +08:00
|
|
|
FunctionType *FFTy = F->getFunctionType();
|
2009-06-12 16:04:51 +08:00
|
|
|
for (Function::arg_iterator AI = NewG->arg_begin(), AE = NewG->arg_end();
|
|
|
|
AI != AE; ++AI) {
|
2013-09-17 17:36:11 +08:00
|
|
|
Args.push_back(createCast(Builder, (Value*)AI, FFTy->getParamType(i)));
|
2009-06-12 16:04:51 +08:00
|
|
|
++i;
|
2008-11-02 13:52:50 +08:00
|
|
|
}
|
|
|
|
|
2011-07-15 16:37:34 +08:00
|
|
|
CallInst *CI = Builder.CreateCall(F, Args);
|
2009-06-12 16:04:51 +08:00
|
|
|
CI->setTailCall();
|
2009-06-13 00:04:00 +08:00
|
|
|
CI->setCallingConv(F->getCallingConv());
|
2010-01-05 21:12:22 +08:00
|
|
|
if (NewG->getReturnType()->isVoidTy()) {
|
2010-08-08 13:04:23 +08:00
|
|
|
Builder.CreateRetVoid();
|
2009-06-12 16:04:51 +08:00
|
|
|
} else {
|
2013-09-17 17:36:11 +08:00
|
|
|
Builder.CreateRet(createCast(Builder, CI, NewG->getReturnType()));
|
2008-11-03 00:46:26 +08:00
|
|
|
}
|
|
|
|
|
2009-06-12 16:04:51 +08:00
|
|
|
NewG->copyAttributesFrom(G);
|
|
|
|
NewG->takeName(G);
|
2011-01-28 16:43:14 +08:00
|
|
|
removeUsers(G);
|
2009-06-12 16:04:51 +08:00
|
|
|
G->replaceAllUsesWith(NewG);
|
|
|
|
G->eraseFromParent();
|
2010-09-07 09:42:10 +08:00
|
|
|
|
2011-01-28 16:43:14 +08:00
|
|
|
DEBUG(dbgs() << "writeThunk: " << NewG->getName() << '\n');
|
2010-09-07 09:42:10 +08:00
|
|
|
++NumThunksWritten;
|
2008-11-02 13:52:50 +08:00
|
|
|
}
|
|
|
|
|
2011-01-28 16:43:14 +08:00
|
|
|
// Replace G with an alias to F and delete G.
|
|
|
|
void MergeFunctions::writeAlias(Function *F, Function *G) {
|
2014-05-16 21:34:04 +08:00
|
|
|
PointerType *PTy = G->getType();
|
2015-04-30 05:22:39 +08:00
|
|
|
auto *GA = GlobalAlias::create(PTy, G->getLinkage(), "", F);
|
2011-01-25 16:56:50 +08:00
|
|
|
F->setAlignment(std::max(F->getAlignment(), G->getAlignment()));
|
|
|
|
GA->takeName(G);
|
|
|
|
GA->setVisibility(G->getVisibility());
|
2011-01-28 16:43:14 +08:00
|
|
|
removeUsers(G);
|
2011-01-25 16:56:50 +08:00
|
|
|
G->replaceAllUsesWith(GA);
|
|
|
|
G->eraseFromParent();
|
|
|
|
|
2011-01-28 16:43:14 +08:00
|
|
|
DEBUG(dbgs() << "writeAlias: " << GA->getName() << '\n');
|
2011-01-25 16:56:50 +08:00
|
|
|
++NumAliasesWritten;
|
|
|
|
}
|
|
|
|
|
2011-01-28 16:43:14 +08:00
|
|
|
// Merge two equivalent functions. Upon completion, Function G is deleted.
|
|
|
|
void MergeFunctions::mergeTwoFunctions(Function *F, Function *G) {
|
2010-09-07 09:42:10 +08:00
|
|
|
if (F->mayBeOverridden()) {
|
|
|
|
assert(G->mayBeOverridden());
|
2009-06-12 23:56:56 +08:00
|
|
|
|
2015-06-10 02:19:17 +08:00
|
|
|
// Make them both thunks to the same internal function.
|
|
|
|
Function *H = Function::Create(F->getFunctionType(), F->getLinkage(), "",
|
|
|
|
F->getParent());
|
|
|
|
H->copyAttributesFrom(F);
|
|
|
|
H->takeName(F);
|
|
|
|
removeUsers(F);
|
|
|
|
F->replaceAllUsesWith(H);
|
2009-06-12 23:56:56 +08:00
|
|
|
|
2015-06-10 02:19:17 +08:00
|
|
|
unsigned MaxAlignment = std::max(G->getAlignment(), H->getAlignment());
|
2010-08-10 05:03:28 +08:00
|
|
|
|
2015-06-10 02:19:17 +08:00
|
|
|
if (HasGlobalAliases) {
|
2011-01-28 16:43:14 +08:00
|
|
|
writeAlias(F, G);
|
|
|
|
writeAlias(F, H);
|
2011-01-25 16:56:50 +08:00
|
|
|
} else {
|
2015-06-10 02:19:17 +08:00
|
|
|
writeThunk(F, G);
|
|
|
|
writeThunk(F, H);
|
2011-01-25 16:56:50 +08:00
|
|
|
}
|
2010-09-07 09:42:10 +08:00
|
|
|
|
2015-06-10 02:19:17 +08:00
|
|
|
F->setAlignment(MaxAlignment);
|
|
|
|
F->setLinkage(GlobalValue::PrivateLinkage);
|
2010-09-07 09:42:10 +08:00
|
|
|
++NumDoubleWeak;
|
2010-08-06 15:21:30 +08:00
|
|
|
} else {
|
2011-01-28 16:43:14 +08:00
|
|
|
writeThunkOrAlias(F, G);
|
2008-11-02 13:52:50 +08:00
|
|
|
}
|
|
|
|
|
2009-06-12 16:04:51 +08:00
|
|
|
++NumFunctionsMerged;
|
2008-11-02 13:52:50 +08:00
|
|
|
}
|
|
|
|
|
2015-06-09 08:03:29 +08:00
|
|
|
/// Replace function F for function G in the map.
|
|
|
|
void MergeFunctions::replaceFunctionInTree(FnTreeType::iterator &IterToF,
|
|
|
|
Function *G) {
|
|
|
|
Function *F = IterToF->getFunc();
|
|
|
|
|
|
|
|
// A total order is already guaranteed otherwise because we process strong
|
|
|
|
// functions before weak functions.
|
2015-06-09 17:28:37 +08:00
|
|
|
assert(((F->mayBeOverridden() && G->mayBeOverridden()) ||
|
|
|
|
(!F->mayBeOverridden() && !G->mayBeOverridden())) &&
|
2015-06-09 08:03:29 +08:00
|
|
|
"Only change functions if both are strong or both are weak");
|
2015-06-09 08:17:40 +08:00
|
|
|
(void)F;
|
2015-06-09 08:03:29 +08:00
|
|
|
|
|
|
|
IterToF->replaceBy(G);
|
|
|
|
}
|
|
|
|
|
2014-06-22 04:54:36 +08:00
|
|
|
// Insert a ComparableFunction into the FnTree, or merge it away if equal to one
|
2011-01-28 16:43:14 +08:00
|
|
|
// that was already inserted.
|
2014-06-22 04:54:36 +08:00
|
|
|
bool MergeFunctions::insert(Function *NewFunction) {
|
|
|
|
std::pair<FnTreeType::iterator, bool> Result =
|
2015-03-10 10:37:25 +08:00
|
|
|
FnTree.insert(FunctionNode(NewFunction));
|
2014-06-22 04:54:36 +08:00
|
|
|
|
2011-02-09 14:32:02 +08:00
|
|
|
if (Result.second) {
|
2014-06-22 04:54:36 +08:00
|
|
|
DEBUG(dbgs() << "Inserting as unique: " << NewFunction->getName() << '\n');
|
2010-09-05 16:22:49 +08:00
|
|
|
return false;
|
2011-02-09 14:32:02 +08:00
|
|
|
}
|
2010-08-31 13:53:05 +08:00
|
|
|
|
2014-09-10 18:08:25 +08:00
|
|
|
const FunctionNode &OldF = *Result.first;
|
2010-09-05 16:22:49 +08:00
|
|
|
|
2013-10-02 02:05:30 +08:00
|
|
|
// Don't merge tiny functions, since it can just end up making the function
|
|
|
|
// larger.
|
|
|
|
// FIXME: Should still merge them if they are unnamed_addr and produce an
|
|
|
|
// alias.
|
2014-06-22 04:54:36 +08:00
|
|
|
if (NewFunction->size() == 1) {
|
|
|
|
if (NewFunction->front().size() <= 2) {
|
|
|
|
DEBUG(dbgs() << NewFunction->getName()
|
|
|
|
<< " is to small to bother merging\n");
|
2013-10-02 02:05:30 +08:00
|
|
|
return false;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2015-06-09 08:03:29 +08:00
|
|
|
// Impose a total order (by name) on the replacement of functions. This is
|
|
|
|
// important when operating on more than one module independently to prevent
|
|
|
|
// cycles of thunks calling each other when the modules are linked together.
|
|
|
|
//
|
|
|
|
// When one function is weak and the other is strong there is an order imposed
|
|
|
|
// already. We process strong functions before weak functions.
|
|
|
|
if ((OldF.getFunc()->mayBeOverridden() && NewFunction->mayBeOverridden()) ||
|
|
|
|
(!OldF.getFunc()->mayBeOverridden() && !NewFunction->mayBeOverridden()))
|
|
|
|
if (OldF.getFunc()->getName() > NewFunction->getName()) {
|
|
|
|
// Swap the two functions.
|
|
|
|
Function *F = OldF.getFunc();
|
|
|
|
replaceFunctionInTree(Result.first, NewFunction);
|
|
|
|
NewFunction = F;
|
|
|
|
assert(OldF.getFunc() != F && "Must have swapped the functions.");
|
|
|
|
}
|
|
|
|
|
2010-09-05 16:22:49 +08:00
|
|
|
// Never thunk a strong function to a weak function.
|
2014-06-22 04:54:36 +08:00
|
|
|
assert(!OldF.getFunc()->mayBeOverridden() || NewFunction->mayBeOverridden());
|
2010-09-05 16:22:49 +08:00
|
|
|
|
2014-06-22 04:54:36 +08:00
|
|
|
DEBUG(dbgs() << " " << OldF.getFunc()->getName()
|
|
|
|
<< " == " << NewFunction->getName() << '\n');
|
2010-09-05 16:22:49 +08:00
|
|
|
|
2014-06-22 04:54:36 +08:00
|
|
|
Function *DeleteF = NewFunction;
|
2011-01-28 16:43:14 +08:00
|
|
|
mergeTwoFunctions(OldF.getFunc(), DeleteF);
|
2010-09-05 16:22:49 +08:00
|
|
|
return true;
|
2010-08-08 13:04:23 +08:00
|
|
|
}
|
2009-06-12 16:04:51 +08:00
|
|
|
|
2014-06-22 04:54:36 +08:00
|
|
|
// Remove a function from FnTree. If it was already in FnTree, add
|
|
|
|
// it to Deferred so that we'll look at it in the next round.
|
2011-01-28 16:43:14 +08:00
|
|
|
void MergeFunctions::remove(Function *F) {
|
2011-02-09 14:32:02 +08:00
|
|
|
// We need to make sure we remove F, not a function "equal" to F per the
|
|
|
|
// function equality comparator.
|
2015-03-10 10:37:25 +08:00
|
|
|
FnTreeType::iterator found = FnTree.find(FunctionNode(F));
|
2014-06-22 04:54:36 +08:00
|
|
|
size_t Erased = 0;
|
|
|
|
if (found != FnTree.end() && found->getFunc() == F) {
|
|
|
|
Erased = 1;
|
|
|
|
FnTree.erase(found);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (Erased) {
|
|
|
|
DEBUG(dbgs() << "Removed " << F->getName()
|
|
|
|
<< " from set and deferred it.\n");
|
2015-05-30 03:43:39 +08:00
|
|
|
Deferred.emplace_back(F);
|
2010-08-31 13:53:05 +08:00
|
|
|
}
|
2011-01-02 10:46:33 +08:00
|
|
|
}
|
2010-09-05 16:22:49 +08:00
|
|
|
|
2011-01-28 16:43:14 +08:00
|
|
|
// For each instruction used by the value, remove() the function that contains
|
|
|
|
// the instruction. This should happen right before a call to RAUW.
|
|
|
|
void MergeFunctions::removeUsers(Value *V) {
|
2011-01-03 03:16:44 +08:00
|
|
|
std::vector<Value *> Worklist;
|
|
|
|
Worklist.push_back(V);
|
2015-07-16 05:51:33 +08:00
|
|
|
SmallSet<Value*, 8> Visited;
|
|
|
|
Visited.insert(V);
|
2011-01-03 03:16:44 +08:00
|
|
|
while (!Worklist.empty()) {
|
|
|
|
Value *V = Worklist.back();
|
|
|
|
Worklist.pop_back();
|
|
|
|
|
2014-03-09 11:16:01 +08:00
|
|
|
for (User *U : V->users()) {
|
|
|
|
if (Instruction *I = dyn_cast<Instruction>(U)) {
|
2011-01-28 16:43:14 +08:00
|
|
|
remove(I->getParent()->getParent());
|
2014-03-09 11:16:01 +08:00
|
|
|
} else if (isa<GlobalValue>(U)) {
|
2011-01-15 18:16:23 +08:00
|
|
|
// do nothing
|
2014-03-09 11:16:01 +08:00
|
|
|
} else if (Constant *C = dyn_cast<Constant>(U)) {
|
2015-07-16 05:51:33 +08:00
|
|
|
for (User *UU : C->users()) {
|
|
|
|
if (!Visited.insert(UU).second)
|
|
|
|
Worklist.push_back(UU);
|
|
|
|
}
|
2011-01-03 03:16:44 +08:00
|
|
|
}
|
2010-09-05 16:22:49 +08:00
|
|
|
}
|
2010-08-31 13:53:05 +08:00
|
|
|
}
|
2010-09-05 16:22:49 +08:00
|
|
|
}
|