2003-05-29 15:11:31 +00:00
|
|
|
//===- InlineFunction.cpp - Code to perform function inlining -------------===//
|
2005-04-21 23:48:37 +00:00
|
|
|
//
|
2003-10-20 19:43:21 +00:00
|
|
|
// The LLVM Compiler Infrastructure
|
|
|
|
//
|
2007-12-29 20:36:04 +00:00
|
|
|
// This file is distributed under the University of Illinois Open Source
|
|
|
|
// License. See LICENSE.TXT for details.
|
2005-04-21 23:48:37 +00:00
|
|
|
//
|
2003-10-20 19:43:21 +00:00
|
|
|
//===----------------------------------------------------------------------===//
|
2003-05-29 15:11:31 +00:00
|
|
|
//
|
|
|
|
// This file implements inlining of a function into a call site, resolving
|
|
|
|
// parameters and the return value as appropriate.
|
|
|
|
//
|
|
|
|
//===----------------------------------------------------------------------===//
|
|
|
|
|
|
|
|
#include "llvm/Transforms/Utils/Cloning.h"
|
Add scoped-noalias metadata
This commit adds scoped noalias metadata. The primary motivations for this
feature are:
1. To preserve noalias function attribute information when inlining
2. To provide the ability to model block-scope C99 restrict pointers
Neither of these two abilities are added here, only the necessary
infrastructure. In fact, there should be no change to existing functionality,
only the addition of new features. The logic that converts noalias function
parameters into this metadata during inlining will come in a follow-up commit.
What is added here is the ability to generally specify noalias memory-access
sets. Regarding the metadata, alias-analysis scopes are defined similar to TBAA
nodes:
!scope0 = metadata !{ metadata !"scope of foo()" }
!scope1 = metadata !{ metadata !"scope 1", metadata !scope0 }
!scope2 = metadata !{ metadata !"scope 2", metadata !scope0 }
!scope3 = metadata !{ metadata !"scope 2.1", metadata !scope2 }
!scope4 = metadata !{ metadata !"scope 2.2", metadata !scope2 }
Loads and stores can be tagged with an alias-analysis scope, and also, with a
noalias tag for a specific scope:
... = load %ptr1, !alias.scope !{ !scope1 }
... = load %ptr2, !alias.scope !{ !scope1, !scope2 }, !noalias !{ !scope1 }
When evaluating an aliasing query, if one of the instructions is associated
with an alias.scope id that is identical to the noalias scope associated with
the other instruction, or is a descendant (in the scope hierarchy) of the
noalias scope associated with the other instruction, then the two memory
accesses are assumed not to alias.
Note that is the first element of the scope metadata is a string, then it can
be combined accross functions and translation units. The string can be replaced
by a self-reference to create globally unqiue scope identifiers.
[Note: This overview is slightly stylized, since the metadata nodes really need
to just be numbers (!0 instead of !scope0), and the scope lists are also global
unnamed metadata.]
Existing noalias metadata in a callee is "cloned" for use by the inlined code.
This is necessary because the aliasing scopes are unique to each call site
(because of possible control dependencies on the aliasing properties). For
example, consider a function: foo(noalias a, noalias b) { *a = *b; } that gets
inlined into bar() { ... if (...) foo(a1, b1); ... if (...) foo(a2, b2); } --
now just because we know that a1 does not alias with b1 at the first call site,
and a2 does not alias with b2 at the second call site, we cannot let inlining
these functons have the metadata imply that a1 does not alias with b2.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@213864 91177308-0d34-0410-b5e6-96231b3b80d8
2014-07-24 14:25:39 +00:00
|
|
|
#include "llvm/ADT/SmallSet.h"
|
2012-12-03 16:50:05 +00:00
|
|
|
#include "llvm/ADT/SmallVector.h"
|
Add scoped-noalias metadata
This commit adds scoped noalias metadata. The primary motivations for this
feature are:
1. To preserve noalias function attribute information when inlining
2. To provide the ability to model block-scope C99 restrict pointers
Neither of these two abilities are added here, only the necessary
infrastructure. In fact, there should be no change to existing functionality,
only the addition of new features. The logic that converts noalias function
parameters into this metadata during inlining will come in a follow-up commit.
What is added here is the ability to generally specify noalias memory-access
sets. Regarding the metadata, alias-analysis scopes are defined similar to TBAA
nodes:
!scope0 = metadata !{ metadata !"scope of foo()" }
!scope1 = metadata !{ metadata !"scope 1", metadata !scope0 }
!scope2 = metadata !{ metadata !"scope 2", metadata !scope0 }
!scope3 = metadata !{ metadata !"scope 2.1", metadata !scope2 }
!scope4 = metadata !{ metadata !"scope 2.2", metadata !scope2 }
Loads and stores can be tagged with an alias-analysis scope, and also, with a
noalias tag for a specific scope:
... = load %ptr1, !alias.scope !{ !scope1 }
... = load %ptr2, !alias.scope !{ !scope1, !scope2 }, !noalias !{ !scope1 }
When evaluating an aliasing query, if one of the instructions is associated
with an alias.scope id that is identical to the noalias scope associated with
the other instruction, or is a descendant (in the scope hierarchy) of the
noalias scope associated with the other instruction, then the two memory
accesses are assumed not to alias.
Note that is the first element of the scope metadata is a string, then it can
be combined accross functions and translation units. The string can be replaced
by a self-reference to create globally unqiue scope identifiers.
[Note: This overview is slightly stylized, since the metadata nodes really need
to just be numbers (!0 instead of !scope0), and the scope lists are also global
unnamed metadata.]
Existing noalias metadata in a callee is "cloned" for use by the inlined code.
This is necessary because the aliasing scopes are unique to each call site
(because of possible control dependencies on the aliasing properties). For
example, consider a function: foo(noalias a, noalias b) { *a = *b; } that gets
inlined into bar() { ... if (...) foo(a1, b1); ... if (...) foo(a2, b2); } --
now just because we know that a1 does not alias with b1 at the first call site,
and a2 does not alias with b2 at the second call site, we cannot let inlining
these functons have the metadata imply that a1 does not alias with b2.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@213864 91177308-0d34-0410-b5e6-96231b3b80d8
2014-07-24 14:25:39 +00:00
|
|
|
#include "llvm/ADT/SetVector.h"
|
2012-12-03 16:50:05 +00:00
|
|
|
#include "llvm/ADT/StringExtras.h"
|
2014-07-25 15:50:08 +00:00
|
|
|
#include "llvm/Analysis/AliasAnalysis.h"
|
2012-12-03 16:50:05 +00:00
|
|
|
#include "llvm/Analysis/CallGraph.h"
|
2014-07-25 15:50:08 +00:00
|
|
|
#include "llvm/Analysis/CaptureTracking.h"
|
2012-12-03 16:50:05 +00:00
|
|
|
#include "llvm/Analysis/InstructionSimplify.h"
|
Add scoped-noalias metadata
This commit adds scoped noalias metadata. The primary motivations for this
feature are:
1. To preserve noalias function attribute information when inlining
2. To provide the ability to model block-scope C99 restrict pointers
Neither of these two abilities are added here, only the necessary
infrastructure. In fact, there should be no change to existing functionality,
only the addition of new features. The logic that converts noalias function
parameters into this metadata during inlining will come in a follow-up commit.
What is added here is the ability to generally specify noalias memory-access
sets. Regarding the metadata, alias-analysis scopes are defined similar to TBAA
nodes:
!scope0 = metadata !{ metadata !"scope of foo()" }
!scope1 = metadata !{ metadata !"scope 1", metadata !scope0 }
!scope2 = metadata !{ metadata !"scope 2", metadata !scope0 }
!scope3 = metadata !{ metadata !"scope 2.1", metadata !scope2 }
!scope4 = metadata !{ metadata !"scope 2.2", metadata !scope2 }
Loads and stores can be tagged with an alias-analysis scope, and also, with a
noalias tag for a specific scope:
... = load %ptr1, !alias.scope !{ !scope1 }
... = load %ptr2, !alias.scope !{ !scope1, !scope2 }, !noalias !{ !scope1 }
When evaluating an aliasing query, if one of the instructions is associated
with an alias.scope id that is identical to the noalias scope associated with
the other instruction, or is a descendant (in the scope hierarchy) of the
noalias scope associated with the other instruction, then the two memory
accesses are assumed not to alias.
Note that is the first element of the scope metadata is a string, then it can
be combined accross functions and translation units. The string can be replaced
by a self-reference to create globally unqiue scope identifiers.
[Note: This overview is slightly stylized, since the metadata nodes really need
to just be numbers (!0 instead of !scope0), and the scope lists are also global
unnamed metadata.]
Existing noalias metadata in a callee is "cloned" for use by the inlined code.
This is necessary because the aliasing scopes are unique to each call site
(because of possible control dependencies on the aliasing properties). For
example, consider a function: foo(noalias a, noalias b) { *a = *b; } that gets
inlined into bar() { ... if (...) foo(a1, b1); ... if (...) foo(a2, b2); } --
now just because we know that a1 does not alias with b1 at the first call site,
and a2 does not alias with b2 at the second call site, we cannot let inlining
these functons have the metadata imply that a1 does not alias with b2.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@213864 91177308-0d34-0410-b5e6-96231b3b80d8
2014-07-24 14:25:39 +00:00
|
|
|
#include "llvm/Analysis/ValueTracking.h"
|
2013-01-02 11:36:10 +00:00
|
|
|
#include "llvm/IR/Attributes.h"
|
2014-03-04 11:01:28 +00:00
|
|
|
#include "llvm/IR/CallSite.h"
|
2014-05-15 20:11:28 +00:00
|
|
|
#include "llvm/IR/CFG.h"
|
2013-01-02 11:36:10 +00:00
|
|
|
#include "llvm/IR/Constants.h"
|
|
|
|
#include "llvm/IR/DataLayout.h"
|
2014-03-06 00:46:21 +00:00
|
|
|
#include "llvm/IR/DebugInfo.h"
|
2013-01-02 11:36:10 +00:00
|
|
|
#include "llvm/IR/DerivedTypes.h"
|
2014-07-25 15:50:08 +00:00
|
|
|
#include "llvm/IR/Dominators.h"
|
2013-01-02 11:36:10 +00:00
|
|
|
#include "llvm/IR/IRBuilder.h"
|
|
|
|
#include "llvm/IR/Instructions.h"
|
|
|
|
#include "llvm/IR/IntrinsicInst.h"
|
|
|
|
#include "llvm/IR/Intrinsics.h"
|
Add scoped-noalias metadata
This commit adds scoped noalias metadata. The primary motivations for this
feature are:
1. To preserve noalias function attribute information when inlining
2. To provide the ability to model block-scope C99 restrict pointers
Neither of these two abilities are added here, only the necessary
infrastructure. In fact, there should be no change to existing functionality,
only the addition of new features. The logic that converts noalias function
parameters into this metadata during inlining will come in a follow-up commit.
What is added here is the ability to generally specify noalias memory-access
sets. Regarding the metadata, alias-analysis scopes are defined similar to TBAA
nodes:
!scope0 = metadata !{ metadata !"scope of foo()" }
!scope1 = metadata !{ metadata !"scope 1", metadata !scope0 }
!scope2 = metadata !{ metadata !"scope 2", metadata !scope0 }
!scope3 = metadata !{ metadata !"scope 2.1", metadata !scope2 }
!scope4 = metadata !{ metadata !"scope 2.2", metadata !scope2 }
Loads and stores can be tagged with an alias-analysis scope, and also, with a
noalias tag for a specific scope:
... = load %ptr1, !alias.scope !{ !scope1 }
... = load %ptr2, !alias.scope !{ !scope1, !scope2 }, !noalias !{ !scope1 }
When evaluating an aliasing query, if one of the instructions is associated
with an alias.scope id that is identical to the noalias scope associated with
the other instruction, or is a descendant (in the scope hierarchy) of the
noalias scope associated with the other instruction, then the two memory
accesses are assumed not to alias.
Note that is the first element of the scope metadata is a string, then it can
be combined accross functions and translation units. The string can be replaced
by a self-reference to create globally unqiue scope identifiers.
[Note: This overview is slightly stylized, since the metadata nodes really need
to just be numbers (!0 instead of !scope0), and the scope lists are also global
unnamed metadata.]
Existing noalias metadata in a callee is "cloned" for use by the inlined code.
This is necessary because the aliasing scopes are unique to each call site
(because of possible control dependencies on the aliasing properties). For
example, consider a function: foo(noalias a, noalias b) { *a = *b; } that gets
inlined into bar() { ... if (...) foo(a1, b1); ... if (...) foo(a2, b2); } --
now just because we know that a1 does not alias with b1 at the first call site,
and a2 does not alias with b2 at the second call site, we cannot let inlining
these functons have the metadata imply that a1 does not alias with b2.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@213864 91177308-0d34-0410-b5e6-96231b3b80d8
2014-07-24 14:25:39 +00:00
|
|
|
#include "llvm/IR/MDBuilder.h"
|
2013-01-02 11:36:10 +00:00
|
|
|
#include "llvm/IR/Module.h"
|
2010-12-25 20:42:38 +00:00
|
|
|
#include "llvm/Transforms/Utils/Local.h"
|
2014-07-25 15:50:08 +00:00
|
|
|
#include "llvm/Support/CommandLine.h"
|
|
|
|
#include <algorithm>
|
2004-01-09 06:12:26 +00:00
|
|
|
using namespace llvm;
|
2003-05-29 15:11:31 +00:00
|
|
|
|
2014-07-25 15:50:08 +00:00
|
|
|
static cl::opt<bool>
|
|
|
|
EnableNoAliasConversion("enable-noalias-to-md-conversion", cl::init(false),
|
|
|
|
cl::Hidden,
|
|
|
|
cl::desc("Convert noalias attributes to metadata during inlining."));
|
|
|
|
|
2012-03-26 19:09:38 +00:00
|
|
|
bool llvm::InlineFunction(CallInst *CI, InlineFunctionInfo &IFI,
|
|
|
|
bool InsertLifetime) {
|
2012-02-25 02:56:01 +00:00
|
|
|
return InlineFunction(CallSite(CI), IFI, InsertLifetime);
|
2006-01-14 20:07:50 +00:00
|
|
|
}
|
2012-03-26 19:09:38 +00:00
|
|
|
bool llvm::InlineFunction(InvokeInst *II, InlineFunctionInfo &IFI,
|
|
|
|
bool InsertLifetime) {
|
2012-02-25 02:56:01 +00:00
|
|
|
return InlineFunction(CallSite(II), IFI, InsertLifetime);
|
2006-01-14 20:07:50 +00:00
|
|
|
}
|
2003-08-24 06:59:16 +00:00
|
|
|
|
2011-05-27 18:34:38 +00:00
|
|
|
namespace {
|
|
|
|
/// A class for recording information about inlining through an invoke.
|
|
|
|
class InvokeInliningInfo {
|
2012-06-09 00:01:45 +00:00
|
|
|
BasicBlock *OuterResumeDest; ///< Destination of the invoke's unwind.
|
|
|
|
BasicBlock *InnerResumeDest; ///< Destination for the callee's resume.
|
|
|
|
LandingPadInst *CallerLPad; ///< LandingPadInst associated with the invoke.
|
|
|
|
PHINode *InnerEHValuesPHI; ///< PHI for EH values from landingpad insts.
|
2012-01-31 01:22:03 +00:00
|
|
|
SmallVector<Value*, 8> UnwindDestPHIValues;
|
2011-08-14 08:01:36 +00:00
|
|
|
|
2011-07-28 00:38:23 +00:00
|
|
|
public:
|
2011-08-14 08:01:36 +00:00
|
|
|
InvokeInliningInfo(InvokeInst *II)
|
2014-04-25 05:29:35 +00:00
|
|
|
: OuterResumeDest(II->getUnwindDest()), InnerResumeDest(nullptr),
|
|
|
|
CallerLPad(nullptr), InnerEHValuesPHI(nullptr) {
|
2011-08-14 08:01:36 +00:00
|
|
|
// If there are PHI nodes in the unwind destination block, we need to keep
|
|
|
|
// track of which values came into them from the invoke before removing
|
|
|
|
// the edge from this block.
|
|
|
|
llvm::BasicBlock *InvokeBB = II->getParent();
|
2012-01-31 01:25:54 +00:00
|
|
|
BasicBlock::iterator I = OuterResumeDest->begin();
|
2011-08-14 08:01:36 +00:00
|
|
|
for (; isa<PHINode>(I); ++I) {
|
2011-05-27 18:34:38 +00:00
|
|
|
// Save the value to use for this edge.
|
2011-08-14 08:01:36 +00:00
|
|
|
PHINode *PHI = cast<PHINode>(I);
|
|
|
|
UnwindDestPHIValues.push_back(PHI->getIncomingValueForBlock(InvokeBB));
|
|
|
|
}
|
|
|
|
|
2012-01-31 00:56:53 +00:00
|
|
|
CallerLPad = cast<LandingPadInst>(I);
|
2011-05-27 18:34:38 +00:00
|
|
|
}
|
|
|
|
|
2012-01-31 01:25:54 +00:00
|
|
|
/// getOuterResumeDest - The outer unwind destination is the target of
|
|
|
|
/// unwind edges introduced for calls within the inlined function.
|
2012-01-31 01:22:03 +00:00
|
|
|
BasicBlock *getOuterResumeDest() const {
|
2012-01-31 01:25:54 +00:00
|
|
|
return OuterResumeDest;
|
2011-05-27 18:34:38 +00:00
|
|
|
}
|
|
|
|
|
2012-01-31 01:48:40 +00:00
|
|
|
BasicBlock *getInnerResumeDest();
|
2011-08-14 08:01:36 +00:00
|
|
|
|
|
|
|
LandingPadInst *getLandingPadInst() const { return CallerLPad; }
|
|
|
|
|
|
|
|
/// forwardResume - Forward the 'resume' instruction to the caller's landing
|
|
|
|
/// pad block. When the landing pad block has only one predecessor, this is
|
|
|
|
/// a simple branch. When there is more than one predecessor, we need to
|
|
|
|
/// split the landing pad block after the landingpad instruction and jump
|
|
|
|
/// to there.
|
2013-03-22 20:31:05 +00:00
|
|
|
void forwardResume(ResumeInst *RI,
|
2014-08-21 05:55:13 +00:00
|
|
|
SmallPtrSetImpl<LandingPadInst*> &InlinedLPads);
|
2011-08-14 08:01:36 +00:00
|
|
|
|
|
|
|
/// addIncomingPHIValuesFor - Add incoming-PHI values to the unwind
|
|
|
|
/// destination block for the given basic block, using the values for the
|
|
|
|
/// original invoke's source block.
|
2011-05-27 18:34:38 +00:00
|
|
|
void addIncomingPHIValuesFor(BasicBlock *BB) const {
|
2012-01-31 01:25:54 +00:00
|
|
|
addIncomingPHIValuesForInto(BB, OuterResumeDest);
|
2011-05-28 07:45:59 +00:00
|
|
|
}
|
Revert r136253, r136263, r136269, r136313, r136325, r136326, r136329, r136338,
r136339, r136341, r136369, r136387, r136392, r136396, r136429, r136430, r136444,
r136445, r136446, r136253 pending review.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@136556 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-30 05:42:50 +00:00
|
|
|
|
2011-05-28 07:45:59 +00:00
|
|
|
void addIncomingPHIValuesForInto(BasicBlock *src, BasicBlock *dest) const {
|
|
|
|
BasicBlock::iterator I = dest->begin();
|
2011-05-27 18:34:38 +00:00
|
|
|
for (unsigned i = 0, e = UnwindDestPHIValues.size(); i != e; ++i, ++I) {
|
Revert r136253, r136263, r136269, r136313, r136325, r136326, r136329, r136338,
r136339, r136341, r136369, r136387, r136392, r136396, r136429, r136430, r136444,
r136445, r136446, r136253 pending review.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@136556 91177308-0d34-0410-b5e6-96231b3b80d8
2011-07-30 05:42:50 +00:00
|
|
|
PHINode *phi = cast<PHINode>(I);
|
|
|
|
phi->addIncoming(UnwindDestPHIValues[i], src);
|
2011-05-27 18:34:38 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
};
|
|
|
|
}
|
|
|
|
|
2012-01-31 01:48:40 +00:00
|
|
|
/// getInnerResumeDest - Get or create a target for the branch from ResumeInsts.
|
|
|
|
BasicBlock *InvokeInliningInfo::getInnerResumeDest() {
|
2011-08-14 08:01:36 +00:00
|
|
|
if (InnerResumeDest) return InnerResumeDest;
|
|
|
|
|
|
|
|
// Split the landing pad.
|
|
|
|
BasicBlock::iterator SplitPoint = CallerLPad; ++SplitPoint;
|
|
|
|
InnerResumeDest =
|
|
|
|
OuterResumeDest->splitBasicBlock(SplitPoint,
|
|
|
|
OuterResumeDest->getName() + ".body");
|
|
|
|
|
|
|
|
// The number of incoming edges we expect to the inner landing pad.
|
|
|
|
const unsigned PHICapacity = 2;
|
|
|
|
|
|
|
|
// Create corresponding new PHIs for all the PHIs in the outer landing pad.
|
|
|
|
BasicBlock::iterator InsertPoint = InnerResumeDest->begin();
|
|
|
|
BasicBlock::iterator I = OuterResumeDest->begin();
|
|
|
|
for (unsigned i = 0, e = UnwindDestPHIValues.size(); i != e; ++i, ++I) {
|
|
|
|
PHINode *OuterPHI = cast<PHINode>(I);
|
|
|
|
PHINode *InnerPHI = PHINode::Create(OuterPHI->getType(), PHICapacity,
|
|
|
|
OuterPHI->getName() + ".lpad-body",
|
|
|
|
InsertPoint);
|
|
|
|
OuterPHI->replaceAllUsesWith(InnerPHI);
|
|
|
|
InnerPHI->addIncoming(OuterPHI, OuterResumeDest);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Create a PHI for the exception values.
|
|
|
|
InnerEHValuesPHI = PHINode::Create(CallerLPad->getType(), PHICapacity,
|
|
|
|
"eh.lpad-body", InsertPoint);
|
|
|
|
CallerLPad->replaceAllUsesWith(InnerEHValuesPHI);
|
|
|
|
InnerEHValuesPHI->addIncoming(CallerLPad, OuterResumeDest);
|
|
|
|
|
|
|
|
// All done.
|
|
|
|
return InnerResumeDest;
|
|
|
|
}
|
|
|
|
|
|
|
|
/// forwardResume - Forward the 'resume' instruction to the caller's landing pad
|
|
|
|
/// block. When the landing pad block has only one predecessor, this is a simple
|
|
|
|
/// branch. When there is more than one predecessor, we need to split the
|
|
|
|
/// landing pad block after the landingpad instruction and jump to there.
|
2013-03-21 23:30:12 +00:00
|
|
|
void InvokeInliningInfo::forwardResume(ResumeInst *RI,
|
2014-08-21 05:55:13 +00:00
|
|
|
SmallPtrSetImpl<LandingPadInst*> &InlinedLPads) {
|
2012-01-31 01:48:40 +00:00
|
|
|
BasicBlock *Dest = getInnerResumeDest();
|
2011-08-14 08:01:36 +00:00
|
|
|
BasicBlock *Src = RI->getParent();
|
|
|
|
|
|
|
|
BranchInst::Create(Dest, Src);
|
|
|
|
|
|
|
|
// Update the PHIs in the destination. They were inserted in an order which
|
|
|
|
// makes this work.
|
|
|
|
addIncomingPHIValuesForInto(Src, Dest);
|
|
|
|
|
|
|
|
InnerEHValuesPHI->addIncoming(RI->getOperand(0), Src);
|
|
|
|
RI->eraseFromParent();
|
|
|
|
}
|
|
|
|
|
2009-08-27 03:51:50 +00:00
|
|
|
/// HandleCallsInBlockInlinedThroughInvoke - When we inline a basic block into
|
2009-09-06 22:20:54 +00:00
|
|
|
/// an invoke, we have to turn all of the calls that can throw into
|
2009-08-27 03:51:50 +00:00
|
|
|
/// invokes. This function analyze BB to see if there are any calls, and if so,
|
|
|
|
/// it rewrites them to be invokes that jump to InvokeDest and fills in the PHI
|
2009-09-01 18:44:06 +00:00
|
|
|
/// nodes in that block with the values specified in InvokeDestPHIValues.
|
2013-12-02 20:50:59 +00:00
|
|
|
static void HandleCallsInBlockInlinedThroughInvoke(BasicBlock *BB,
|
2011-05-27 18:34:38 +00:00
|
|
|
InvokeInliningInfo &Invoke) {
|
2009-08-27 03:51:50 +00:00
|
|
|
for (BasicBlock::iterator BBI = BB->begin(), E = BB->end(); BBI != E; ) {
|
|
|
|
Instruction *I = BBI++;
|
2011-08-14 08:01:36 +00:00
|
|
|
|
2009-08-27 03:51:50 +00:00
|
|
|
// We only need to check for function calls: inlined invoke
|
|
|
|
// instructions require no special handling.
|
|
|
|
CallInst *CI = dyn_cast<CallInst>(I);
|
2012-01-31 01:05:20 +00:00
|
|
|
|
2009-08-27 03:51:50 +00:00
|
|
|
// If this call cannot unwind, don't convert it to an invoke.
|
2013-10-31 21:56:03 +00:00
|
|
|
// Inline asm calls cannot throw.
|
|
|
|
if (!CI || CI->doesNotThrow() || isa<InlineAsm>(CI->getCalledValue()))
|
2009-08-27 03:51:50 +00:00
|
|
|
continue;
|
2012-01-31 01:05:20 +00:00
|
|
|
|
|
|
|
// Convert this function call into an invoke instruction. First, split the
|
|
|
|
// basic block.
|
2009-08-27 03:51:50 +00:00
|
|
|
BasicBlock *Split = BB->splitBasicBlock(CI, CI->getName()+".noexc");
|
2011-05-27 18:34:38 +00:00
|
|
|
|
2011-05-28 07:45:59 +00:00
|
|
|
// Delete the unconditional branch inserted by splitBasicBlock
|
|
|
|
BB->getInstList().pop_back();
|
2011-05-27 18:34:38 +00:00
|
|
|
|
2012-01-31 01:14:49 +00:00
|
|
|
// Create the new invoke instruction.
|
2011-05-28 07:45:59 +00:00
|
|
|
ImmutableCallSite CS(CI);
|
|
|
|
SmallVector<Value*, 8> InvokeArgs(CS.arg_begin(), CS.arg_end());
|
2012-01-31 01:01:16 +00:00
|
|
|
InvokeInst *II = InvokeInst::Create(CI->getCalledValue(), Split,
|
2012-01-31 01:22:03 +00:00
|
|
|
Invoke.getOuterResumeDest(),
|
2012-01-31 01:01:16 +00:00
|
|
|
InvokeArgs, CI->getName(), BB);
|
2014-06-30 20:30:39 +00:00
|
|
|
II->setDebugLoc(CI->getDebugLoc());
|
2011-05-28 07:45:59 +00:00
|
|
|
II->setCallingConv(CI->getCallingConv());
|
|
|
|
II->setAttributes(CI->getAttributes());
|
2009-08-27 03:51:50 +00:00
|
|
|
|
2011-05-28 07:45:59 +00:00
|
|
|
// Make sure that anything using the call now uses the invoke! This also
|
|
|
|
// updates the CallGraph if present, because it uses a WeakVH.
|
|
|
|
CI->replaceAllUsesWith(II);
|
|
|
|
|
2012-01-31 01:01:16 +00:00
|
|
|
// Delete the original call
|
|
|
|
Split->getInstList().pop_front();
|
2011-05-27 18:34:38 +00:00
|
|
|
|
2012-01-31 01:01:16 +00:00
|
|
|
// Update any PHI nodes in the exceptional block to indicate that there is
|
|
|
|
// now a new entry in them.
|
2011-05-27 18:34:38 +00:00
|
|
|
Invoke.addIncomingPHIValuesFor(BB);
|
2013-12-02 20:50:59 +00:00
|
|
|
return;
|
2009-08-27 03:51:50 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-01-13 19:05:59 +00:00
|
|
|
/// HandleInlinedInvoke - If we inlined an invoke site, we need to convert calls
|
2012-02-06 21:44:22 +00:00
|
|
|
/// in the body of the inlined function into invokes.
|
2006-01-13 19:05:59 +00:00
|
|
|
///
|
2009-02-03 04:34:40 +00:00
|
|
|
/// II is the invoke instruction being inlined. FirstNewBlock is the first
|
2006-01-13 19:05:59 +00:00
|
|
|
/// block of the inlined code (the last block is the end of the function),
|
|
|
|
/// and InlineCodeInfo is information about the code that got inlined.
|
|
|
|
static void HandleInlinedInvoke(InvokeInst *II, BasicBlock *FirstNewBlock,
|
2009-09-01 18:44:06 +00:00
|
|
|
ClonedCodeInfo &InlinedCodeInfo) {
|
2006-01-13 19:05:59 +00:00
|
|
|
BasicBlock *InvokeDest = II->getUnwindDest();
|
|
|
|
|
|
|
|
Function *Caller = FirstNewBlock->getParent();
|
2008-09-05 12:37:12 +00:00
|
|
|
|
2006-01-13 19:05:59 +00:00
|
|
|
// The inlined code is currently at the end of the function, scan from the
|
|
|
|
// start of the inlined code to its end, checking for stuff we need to
|
2013-03-21 23:30:12 +00:00
|
|
|
// rewrite.
|
2011-05-27 18:34:38 +00:00
|
|
|
InvokeInliningInfo Invoke(II);
|
2013-03-21 23:30:12 +00:00
|
|
|
|
2013-03-22 20:31:05 +00:00
|
|
|
// Get all of the inlined landing pad instructions.
|
|
|
|
SmallPtrSet<LandingPadInst*, 16> InlinedLPads;
|
|
|
|
for (Function::iterator I = FirstNewBlock, E = Caller->end(); I != E; ++I)
|
|
|
|
if (InvokeInst *II = dyn_cast<InvokeInst>(I->getTerminator()))
|
|
|
|
InlinedLPads.insert(II->getLandingPadInst());
|
|
|
|
|
2013-12-08 00:50:58 +00:00
|
|
|
// Append the clauses from the outer landing pad instruction into the inlined
|
|
|
|
// landing pad instructions.
|
|
|
|
LandingPadInst *OuterLPad = Invoke.getLandingPadInst();
|
|
|
|
for (SmallPtrSet<LandingPadInst*, 16>::iterator I = InlinedLPads.begin(),
|
|
|
|
E = InlinedLPads.end(); I != E; ++I) {
|
|
|
|
LandingPadInst *InlinedLPad = *I;
|
|
|
|
unsigned OuterNum = OuterLPad->getNumClauses();
|
|
|
|
InlinedLPad->reserveClauses(OuterNum);
|
|
|
|
for (unsigned OuterIdx = 0; OuterIdx != OuterNum; ++OuterIdx)
|
|
|
|
InlinedLPad->addClause(OuterLPad->getClause(OuterIdx));
|
2013-12-08 00:51:21 +00:00
|
|
|
if (OuterLPad->isCleanup())
|
|
|
|
InlinedLPad->setCleanup(true);
|
2013-12-08 00:50:58 +00:00
|
|
|
}
|
|
|
|
|
2009-08-27 03:51:50 +00:00
|
|
|
for (Function::iterator BB = FirstNewBlock, E = Caller->end(); BB != E; ++BB){
|
|
|
|
if (InlinedCodeInfo.ContainsCalls)
|
2013-12-02 20:50:59 +00:00
|
|
|
HandleCallsInBlockInlinedThroughInvoke(BB, Invoke);
|
2009-08-27 03:51:50 +00:00
|
|
|
|
2013-03-21 23:30:12 +00:00
|
|
|
// Forward any resumes that are remaining here.
|
2012-01-31 01:14:49 +00:00
|
|
|
if (ResumeInst *RI = dyn_cast<ResumeInst>(BB->getTerminator()))
|
2013-03-22 20:31:05 +00:00
|
|
|
Invoke.forwardResume(RI, InlinedLPads);
|
2006-01-13 19:05:59 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Now that everything is happy, we have one final detail. The PHI nodes in
|
|
|
|
// the exception destination block still have entries due to the original
|
2013-03-21 23:30:12 +00:00
|
|
|
// invoke instruction. Eliminate these entries (which might even delete the
|
2006-01-13 19:05:59 +00:00
|
|
|
// PHI node) now.
|
|
|
|
InvokeDest->removePredecessor(II->getParent());
|
|
|
|
}
|
|
|
|
|
Add scoped-noalias metadata
This commit adds scoped noalias metadata. The primary motivations for this
feature are:
1. To preserve noalias function attribute information when inlining
2. To provide the ability to model block-scope C99 restrict pointers
Neither of these two abilities are added here, only the necessary
infrastructure. In fact, there should be no change to existing functionality,
only the addition of new features. The logic that converts noalias function
parameters into this metadata during inlining will come in a follow-up commit.
What is added here is the ability to generally specify noalias memory-access
sets. Regarding the metadata, alias-analysis scopes are defined similar to TBAA
nodes:
!scope0 = metadata !{ metadata !"scope of foo()" }
!scope1 = metadata !{ metadata !"scope 1", metadata !scope0 }
!scope2 = metadata !{ metadata !"scope 2", metadata !scope0 }
!scope3 = metadata !{ metadata !"scope 2.1", metadata !scope2 }
!scope4 = metadata !{ metadata !"scope 2.2", metadata !scope2 }
Loads and stores can be tagged with an alias-analysis scope, and also, with a
noalias tag for a specific scope:
... = load %ptr1, !alias.scope !{ !scope1 }
... = load %ptr2, !alias.scope !{ !scope1, !scope2 }, !noalias !{ !scope1 }
When evaluating an aliasing query, if one of the instructions is associated
with an alias.scope id that is identical to the noalias scope associated with
the other instruction, or is a descendant (in the scope hierarchy) of the
noalias scope associated with the other instruction, then the two memory
accesses are assumed not to alias.
Note that is the first element of the scope metadata is a string, then it can
be combined accross functions and translation units. The string can be replaced
by a self-reference to create globally unqiue scope identifiers.
[Note: This overview is slightly stylized, since the metadata nodes really need
to just be numbers (!0 instead of !scope0), and the scope lists are also global
unnamed metadata.]
Existing noalias metadata in a callee is "cloned" for use by the inlined code.
This is necessary because the aliasing scopes are unique to each call site
(because of possible control dependencies on the aliasing properties). For
example, consider a function: foo(noalias a, noalias b) { *a = *b; } that gets
inlined into bar() { ... if (...) foo(a1, b1); ... if (...) foo(a2, b2); } --
now just because we know that a1 does not alias with b1 at the first call site,
and a2 does not alias with b2 at the second call site, we cannot let inlining
these functons have the metadata imply that a1 does not alias with b2.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@213864 91177308-0d34-0410-b5e6-96231b3b80d8
2014-07-24 14:25:39 +00:00
|
|
|
/// CloneAliasScopeMetadata - When inlining a function that contains noalias
|
|
|
|
/// scope metadata, this metadata needs to be cloned so that the inlined blocks
|
|
|
|
/// have different "unqiue scopes" at every call site. Were this not done, then
|
|
|
|
/// aliasing scopes from a function inlined into a caller multiple times could
|
|
|
|
/// not be differentiated (and this would lead to miscompiles because the
|
|
|
|
/// non-aliasing property communicated by the metadata could have
|
|
|
|
/// call-site-specific control dependencies).
|
|
|
|
static void CloneAliasScopeMetadata(CallSite CS, ValueToValueMapTy &VMap) {
|
|
|
|
const Function *CalledFunc = CS.getCalledFunction();
|
|
|
|
SetVector<const MDNode *> MD;
|
|
|
|
|
|
|
|
// Note: We could only clone the metadata if it is already used in the
|
|
|
|
// caller. I'm omitting that check here because it might confuse
|
|
|
|
// inter-procedural alias analysis passes. We can revisit this if it becomes
|
|
|
|
// an efficiency or overhead problem.
|
|
|
|
|
|
|
|
for (Function::const_iterator I = CalledFunc->begin(), IE = CalledFunc->end();
|
|
|
|
I != IE; ++I)
|
|
|
|
for (BasicBlock::const_iterator J = I->begin(), JE = I->end(); J != JE; ++J) {
|
|
|
|
if (const MDNode *M = J->getMetadata(LLVMContext::MD_alias_scope))
|
|
|
|
MD.insert(M);
|
|
|
|
if (const MDNode *M = J->getMetadata(LLVMContext::MD_noalias))
|
|
|
|
MD.insert(M);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (MD.empty())
|
|
|
|
return;
|
|
|
|
|
|
|
|
// Walk the existing metadata, adding the complete (perhaps cyclic) chain to
|
|
|
|
// the set.
|
|
|
|
SmallVector<const Value *, 16> Queue(MD.begin(), MD.end());
|
|
|
|
while (!Queue.empty()) {
|
|
|
|
const MDNode *M = cast<MDNode>(Queue.pop_back_val());
|
|
|
|
for (unsigned i = 0, ie = M->getNumOperands(); i != ie; ++i)
|
|
|
|
if (const MDNode *M1 = dyn_cast<MDNode>(M->getOperand(i)))
|
|
|
|
if (MD.insert(M1))
|
|
|
|
Queue.push_back(M1);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Now we have a complete set of all metadata in the chains used to specify
|
|
|
|
// the noalias scopes and the lists of those scopes.
|
|
|
|
SmallVector<MDNode *, 16> DummyNodes;
|
|
|
|
DenseMap<const MDNode *, TrackingVH<MDNode> > MDMap;
|
|
|
|
for (SetVector<const MDNode *>::iterator I = MD.begin(), IE = MD.end();
|
|
|
|
I != IE; ++I) {
|
|
|
|
MDNode *Dummy = MDNode::getTemporary(CalledFunc->getContext(),
|
|
|
|
ArrayRef<Value*>());
|
|
|
|
DummyNodes.push_back(Dummy);
|
|
|
|
MDMap[*I] = Dummy;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Create new metadata nodes to replace the dummy nodes, replacing old
|
|
|
|
// metadata references with either a dummy node or an already-created new
|
|
|
|
// node.
|
|
|
|
for (SetVector<const MDNode *>::iterator I = MD.begin(), IE = MD.end();
|
|
|
|
I != IE; ++I) {
|
|
|
|
SmallVector<Value *, 4> NewOps;
|
|
|
|
for (unsigned i = 0, ie = (*I)->getNumOperands(); i != ie; ++i) {
|
|
|
|
const Value *V = (*I)->getOperand(i);
|
|
|
|
if (const MDNode *M = dyn_cast<MDNode>(V))
|
|
|
|
NewOps.push_back(MDMap[M]);
|
|
|
|
else
|
|
|
|
NewOps.push_back(const_cast<Value *>(V));
|
|
|
|
}
|
|
|
|
|
|
|
|
MDNode *NewM = MDNode::get(CalledFunc->getContext(), NewOps),
|
|
|
|
*TempM = MDMap[*I];
|
|
|
|
|
|
|
|
TempM->replaceAllUsesWith(NewM);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Now replace the metadata in the new inlined instructions with the
|
|
|
|
// repacements from the map.
|
|
|
|
for (ValueToValueMapTy::iterator VMI = VMap.begin(), VMIE = VMap.end();
|
|
|
|
VMI != VMIE; ++VMI) {
|
|
|
|
if (!VMI->second)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
Instruction *NI = dyn_cast<Instruction>(VMI->second);
|
|
|
|
if (!NI)
|
|
|
|
continue;
|
|
|
|
|
2014-08-14 21:09:37 +00:00
|
|
|
if (MDNode *M = NI->getMetadata(LLVMContext::MD_alias_scope)) {
|
|
|
|
MDNode *NewMD = MDMap[M];
|
|
|
|
// If the call site also had alias scope metadata (a list of scopes to
|
|
|
|
// which instructions inside it might belong), propagate those scopes to
|
|
|
|
// the inlined instructions.
|
|
|
|
if (MDNode *CSM =
|
|
|
|
CS.getInstruction()->getMetadata(LLVMContext::MD_alias_scope))
|
|
|
|
NewMD = MDNode::concatenate(NewMD, CSM);
|
|
|
|
NI->setMetadata(LLVMContext::MD_alias_scope, NewMD);
|
|
|
|
} else if (NI->mayReadOrWriteMemory()) {
|
|
|
|
if (MDNode *M =
|
|
|
|
CS.getInstruction()->getMetadata(LLVMContext::MD_alias_scope))
|
|
|
|
NI->setMetadata(LLVMContext::MD_alias_scope, M);
|
|
|
|
}
|
Add scoped-noalias metadata
This commit adds scoped noalias metadata. The primary motivations for this
feature are:
1. To preserve noalias function attribute information when inlining
2. To provide the ability to model block-scope C99 restrict pointers
Neither of these two abilities are added here, only the necessary
infrastructure. In fact, there should be no change to existing functionality,
only the addition of new features. The logic that converts noalias function
parameters into this metadata during inlining will come in a follow-up commit.
What is added here is the ability to generally specify noalias memory-access
sets. Regarding the metadata, alias-analysis scopes are defined similar to TBAA
nodes:
!scope0 = metadata !{ metadata !"scope of foo()" }
!scope1 = metadata !{ metadata !"scope 1", metadata !scope0 }
!scope2 = metadata !{ metadata !"scope 2", metadata !scope0 }
!scope3 = metadata !{ metadata !"scope 2.1", metadata !scope2 }
!scope4 = metadata !{ metadata !"scope 2.2", metadata !scope2 }
Loads and stores can be tagged with an alias-analysis scope, and also, with a
noalias tag for a specific scope:
... = load %ptr1, !alias.scope !{ !scope1 }
... = load %ptr2, !alias.scope !{ !scope1, !scope2 }, !noalias !{ !scope1 }
When evaluating an aliasing query, if one of the instructions is associated
with an alias.scope id that is identical to the noalias scope associated with
the other instruction, or is a descendant (in the scope hierarchy) of the
noalias scope associated with the other instruction, then the two memory
accesses are assumed not to alias.
Note that is the first element of the scope metadata is a string, then it can
be combined accross functions and translation units. The string can be replaced
by a self-reference to create globally unqiue scope identifiers.
[Note: This overview is slightly stylized, since the metadata nodes really need
to just be numbers (!0 instead of !scope0), and the scope lists are also global
unnamed metadata.]
Existing noalias metadata in a callee is "cloned" for use by the inlined code.
This is necessary because the aliasing scopes are unique to each call site
(because of possible control dependencies on the aliasing properties). For
example, consider a function: foo(noalias a, noalias b) { *a = *b; } that gets
inlined into bar() { ... if (...) foo(a1, b1); ... if (...) foo(a2, b2); } --
now just because we know that a1 does not alias with b1 at the first call site,
and a2 does not alias with b2 at the second call site, we cannot let inlining
these functons have the metadata imply that a1 does not alias with b2.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@213864 91177308-0d34-0410-b5e6-96231b3b80d8
2014-07-24 14:25:39 +00:00
|
|
|
|
2014-08-14 21:09:37 +00:00
|
|
|
if (MDNode *M = NI->getMetadata(LLVMContext::MD_noalias)) {
|
|
|
|
MDNode *NewMD = MDMap[M];
|
|
|
|
// If the call site also had noalias metadata (a list of scopes with
|
|
|
|
// which instructions inside it don't alias), propagate those scopes to
|
|
|
|
// the inlined instructions.
|
|
|
|
if (MDNode *CSM =
|
|
|
|
CS.getInstruction()->getMetadata(LLVMContext::MD_noalias))
|
|
|
|
NewMD = MDNode::concatenate(NewMD, CSM);
|
|
|
|
NI->setMetadata(LLVMContext::MD_noalias, NewMD);
|
|
|
|
} else if (NI->mayReadOrWriteMemory()) {
|
|
|
|
if (MDNode *M =
|
|
|
|
CS.getInstruction()->getMetadata(LLVMContext::MD_noalias))
|
|
|
|
NI->setMetadata(LLVMContext::MD_noalias, M);
|
|
|
|
}
|
Add scoped-noalias metadata
This commit adds scoped noalias metadata. The primary motivations for this
feature are:
1. To preserve noalias function attribute information when inlining
2. To provide the ability to model block-scope C99 restrict pointers
Neither of these two abilities are added here, only the necessary
infrastructure. In fact, there should be no change to existing functionality,
only the addition of new features. The logic that converts noalias function
parameters into this metadata during inlining will come in a follow-up commit.
What is added here is the ability to generally specify noalias memory-access
sets. Regarding the metadata, alias-analysis scopes are defined similar to TBAA
nodes:
!scope0 = metadata !{ metadata !"scope of foo()" }
!scope1 = metadata !{ metadata !"scope 1", metadata !scope0 }
!scope2 = metadata !{ metadata !"scope 2", metadata !scope0 }
!scope3 = metadata !{ metadata !"scope 2.1", metadata !scope2 }
!scope4 = metadata !{ metadata !"scope 2.2", metadata !scope2 }
Loads and stores can be tagged with an alias-analysis scope, and also, with a
noalias tag for a specific scope:
... = load %ptr1, !alias.scope !{ !scope1 }
... = load %ptr2, !alias.scope !{ !scope1, !scope2 }, !noalias !{ !scope1 }
When evaluating an aliasing query, if one of the instructions is associated
with an alias.scope id that is identical to the noalias scope associated with
the other instruction, or is a descendant (in the scope hierarchy) of the
noalias scope associated with the other instruction, then the two memory
accesses are assumed not to alias.
Note that is the first element of the scope metadata is a string, then it can
be combined accross functions and translation units. The string can be replaced
by a self-reference to create globally unqiue scope identifiers.
[Note: This overview is slightly stylized, since the metadata nodes really need
to just be numbers (!0 instead of !scope0), and the scope lists are also global
unnamed metadata.]
Existing noalias metadata in a callee is "cloned" for use by the inlined code.
This is necessary because the aliasing scopes are unique to each call site
(because of possible control dependencies on the aliasing properties). For
example, consider a function: foo(noalias a, noalias b) { *a = *b; } that gets
inlined into bar() { ... if (...) foo(a1, b1); ... if (...) foo(a2, b2); } --
now just because we know that a1 does not alias with b1 at the first call site,
and a2 does not alias with b2 at the second call site, we cannot let inlining
these functons have the metadata imply that a1 does not alias with b2.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@213864 91177308-0d34-0410-b5e6-96231b3b80d8
2014-07-24 14:25:39 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// Now that everything has been replaced, delete the dummy nodes.
|
|
|
|
for (unsigned i = 0, ie = DummyNodes.size(); i != ie; ++i)
|
|
|
|
MDNode::deleteTemporary(DummyNodes[i]);
|
|
|
|
}
|
|
|
|
|
2014-07-25 15:50:08 +00:00
|
|
|
/// AddAliasScopeMetadata - If the inlined function has noalias arguments, then
|
|
|
|
/// add new alias scopes for each noalias argument, tag the mapped noalias
|
|
|
|
/// parameters with noalias metadata specifying the new scope, and tag all
|
|
|
|
/// non-derived loads, stores and memory intrinsics with the new alias scopes.
|
|
|
|
static void AddAliasScopeMetadata(CallSite CS, ValueToValueMapTy &VMap,
|
|
|
|
const DataLayout *DL) {
|
|
|
|
if (!EnableNoAliasConversion)
|
|
|
|
return;
|
|
|
|
|
|
|
|
const Function *CalledFunc = CS.getCalledFunction();
|
|
|
|
SmallVector<const Argument *, 4> NoAliasArgs;
|
|
|
|
|
|
|
|
for (Function::const_arg_iterator I = CalledFunc->arg_begin(),
|
|
|
|
E = CalledFunc->arg_end(); I != E; ++I) {
|
|
|
|
if (I->hasNoAliasAttr() && !I->hasNUses(0))
|
|
|
|
NoAliasArgs.push_back(I);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (NoAliasArgs.empty())
|
|
|
|
return;
|
|
|
|
|
|
|
|
// To do a good job, if a noalias variable is captured, we need to know if
|
|
|
|
// the capture point dominates the particular use we're considering.
|
|
|
|
DominatorTree DT;
|
|
|
|
DT.recalculate(const_cast<Function&>(*CalledFunc));
|
|
|
|
|
|
|
|
// noalias indicates that pointer values based on the argument do not alias
|
|
|
|
// pointer values which are not based on it. So we add a new "scope" for each
|
|
|
|
// noalias function argument. Accesses using pointers based on that argument
|
|
|
|
// become part of that alias scope, accesses using pointers not based on that
|
|
|
|
// argument are tagged as noalias with that scope.
|
|
|
|
|
|
|
|
DenseMap<const Argument *, MDNode *> NewScopes;
|
|
|
|
MDBuilder MDB(CalledFunc->getContext());
|
|
|
|
|
|
|
|
// Create a new scope domain for this function.
|
|
|
|
MDNode *NewDomain =
|
|
|
|
MDB.createAnonymousAliasScopeDomain(CalledFunc->getName());
|
|
|
|
for (unsigned i = 0, e = NoAliasArgs.size(); i != e; ++i) {
|
|
|
|
const Argument *A = NoAliasArgs[i];
|
|
|
|
|
|
|
|
std::string Name = CalledFunc->getName();
|
|
|
|
if (A->hasName()) {
|
|
|
|
Name += ": %";
|
|
|
|
Name += A->getName();
|
|
|
|
} else {
|
|
|
|
Name += ": argument ";
|
|
|
|
Name += utostr(i);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Note: We always create a new anonymous root here. This is true regardless
|
|
|
|
// of the linkage of the callee because the aliasing "scope" is not just a
|
|
|
|
// property of the callee, but also all control dependencies in the caller.
|
|
|
|
MDNode *NewScope = MDB.createAnonymousAliasScope(NewDomain, Name);
|
|
|
|
NewScopes.insert(std::make_pair(A, NewScope));
|
|
|
|
}
|
|
|
|
|
|
|
|
// Iterate over all new instructions in the map; for all memory-access
|
|
|
|
// instructions, add the alias scope metadata.
|
|
|
|
for (ValueToValueMapTy::iterator VMI = VMap.begin(), VMIE = VMap.end();
|
|
|
|
VMI != VMIE; ++VMI) {
|
|
|
|
if (const Instruction *I = dyn_cast<Instruction>(VMI->first)) {
|
|
|
|
if (!VMI->second)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
Instruction *NI = dyn_cast<Instruction>(VMI->second);
|
|
|
|
if (!NI)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
SmallVector<const Value *, 2> PtrArgs;
|
|
|
|
|
|
|
|
if (const LoadInst *LI = dyn_cast<LoadInst>(I))
|
|
|
|
PtrArgs.push_back(LI->getPointerOperand());
|
|
|
|
else if (const StoreInst *SI = dyn_cast<StoreInst>(I))
|
|
|
|
PtrArgs.push_back(SI->getPointerOperand());
|
|
|
|
else if (const VAArgInst *VAAI = dyn_cast<VAArgInst>(I))
|
|
|
|
PtrArgs.push_back(VAAI->getPointerOperand());
|
|
|
|
else if (const AtomicCmpXchgInst *CXI = dyn_cast<AtomicCmpXchgInst>(I))
|
|
|
|
PtrArgs.push_back(CXI->getPointerOperand());
|
|
|
|
else if (const AtomicRMWInst *RMWI = dyn_cast<AtomicRMWInst>(I))
|
|
|
|
PtrArgs.push_back(RMWI->getPointerOperand());
|
2014-08-14 16:44:03 +00:00
|
|
|
else if (ImmutableCallSite ICS = ImmutableCallSite(I)) {
|
|
|
|
// If we know that the call does not access memory, then we'll still
|
|
|
|
// know that about the inlined clone of this call site, and we don't
|
|
|
|
// need to add metadata.
|
|
|
|
if (ICS.doesNotAccessMemory())
|
|
|
|
continue;
|
|
|
|
|
|
|
|
for (ImmutableCallSite::arg_iterator AI = ICS.arg_begin(),
|
|
|
|
AE = ICS.arg_end(); AI != AE; ++AI)
|
|
|
|
// We need to check the underlying objects of all arguments, not just
|
|
|
|
// the pointer arguments, because we might be passing pointers as
|
|
|
|
// integers, etc.
|
|
|
|
// FIXME: If we know that the call only accesses pointer arguments,
|
|
|
|
// then we only need to check the pointer arguments.
|
|
|
|
PtrArgs.push_back(*AI);
|
2014-07-25 15:50:08 +00:00
|
|
|
}
|
|
|
|
|
|
|
|
// If we found no pointers, then this instruction is not suitable for
|
|
|
|
// pairing with an instruction to receive aliasing metadata.
|
2014-08-14 16:44:03 +00:00
|
|
|
// However, if this is a call, this we might just alias with none of the
|
|
|
|
// noalias arguments.
|
|
|
|
if (PtrArgs.empty() && !isa<CallInst>(I) && !isa<InvokeInst>(I))
|
2014-07-25 15:50:08 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
// It is possible that there is only one underlying object, but you
|
|
|
|
// need to go through several PHIs to see it, and thus could be
|
|
|
|
// repeated in the Objects list.
|
|
|
|
SmallPtrSet<const Value *, 4> ObjSet;
|
|
|
|
SmallVector<Value *, 4> Scopes, NoAliases;
|
|
|
|
|
|
|
|
SmallSetVector<const Argument *, 4> NAPtrArgs;
|
|
|
|
for (unsigned i = 0, ie = PtrArgs.size(); i != ie; ++i) {
|
|
|
|
SmallVector<Value *, 4> Objects;
|
|
|
|
GetUnderlyingObjects(const_cast<Value*>(PtrArgs[i]),
|
|
|
|
Objects, DL, /* MaxLookup = */ 0);
|
|
|
|
|
|
|
|
for (Value *O : Objects)
|
|
|
|
ObjSet.insert(O);
|
|
|
|
}
|
|
|
|
|
|
|
|
// Figure out if we're derived from anyhing that is not a noalias
|
|
|
|
// argument.
|
|
|
|
bool CanDeriveViaCapture = false;
|
|
|
|
for (const Value *V : ObjSet)
|
|
|
|
if (!isIdentifiedFunctionLocal(const_cast<Value*>(V))) {
|
|
|
|
CanDeriveViaCapture = true;
|
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
|
|
|
// First, we want to figure out all of the sets with which we definitely
|
|
|
|
// don't alias. Iterate over all noalias set, and add those for which:
|
|
|
|
// 1. The noalias argument is not in the set of objects from which we
|
|
|
|
// definitely derive.
|
|
|
|
// 2. The noalias argument has not yet been captured.
|
|
|
|
for (const Argument *A : NoAliasArgs) {
|
|
|
|
if (!ObjSet.count(A) && (!CanDeriveViaCapture ||
|
|
|
|
A->hasNoCaptureAttr() ||
|
|
|
|
!PointerMayBeCapturedBefore(A,
|
|
|
|
/* ReturnCaptures */ false,
|
|
|
|
/* StoreCaptures */ false, I, &DT)))
|
|
|
|
NoAliases.push_back(NewScopes[A]);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!NoAliases.empty())
|
|
|
|
NI->setMetadata(LLVMContext::MD_noalias, MDNode::concatenate(
|
|
|
|
NI->getMetadata(LLVMContext::MD_noalias),
|
|
|
|
MDNode::get(CalledFunc->getContext(), NoAliases)));
|
|
|
|
// Next, we want to figure out all of the sets to which we might belong.
|
|
|
|
// We might below to a set if:
|
|
|
|
// 1. The noalias argument is in the set of underlying objects
|
|
|
|
// or
|
|
|
|
// 2. There is some non-noalias argument in our list and the no-alias
|
|
|
|
// argument has been captured.
|
|
|
|
|
|
|
|
for (const Argument *A : NoAliasArgs) {
|
|
|
|
if (ObjSet.count(A) || (CanDeriveViaCapture &&
|
|
|
|
PointerMayBeCapturedBefore(A,
|
|
|
|
/* ReturnCaptures */ false,
|
|
|
|
/* StoreCaptures */ false,
|
|
|
|
I, &DT)))
|
|
|
|
Scopes.push_back(NewScopes[A]);
|
|
|
|
}
|
|
|
|
|
|
|
|
if (!Scopes.empty())
|
|
|
|
NI->setMetadata(LLVMContext::MD_alias_scope, MDNode::concatenate(
|
|
|
|
NI->getMetadata(LLVMContext::MD_alias_scope),
|
|
|
|
MDNode::get(CalledFunc->getContext(), Scopes)));
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-07-12 18:29:36 +00:00
|
|
|
/// UpdateCallGraphAfterInlining - Once we have cloned code over from a callee
|
|
|
|
/// into the caller, update the specified callgraph to reflect the changes we
|
|
|
|
/// made. Note that it's possible that not all code was copied over, so only
|
2008-09-08 11:05:51 +00:00
|
|
|
/// some edges of the callgraph may remain.
|
|
|
|
static void UpdateCallGraphAfterInlining(CallSite CS,
|
2006-07-12 18:29:36 +00:00
|
|
|
Function::iterator FirstNewBlock,
|
2010-10-13 01:36:30 +00:00
|
|
|
ValueToValueMapTy &VMap,
|
2010-04-22 23:37:35 +00:00
|
|
|
InlineFunctionInfo &IFI) {
|
|
|
|
CallGraph &CG = *IFI.CG;
|
2008-09-08 11:05:51 +00:00
|
|
|
const Function *Caller = CS.getInstruction()->getParent()->getParent();
|
|
|
|
const Function *Callee = CS.getCalledFunction();
|
2006-01-14 20:07:50 +00:00
|
|
|
CallGraphNode *CalleeNode = CG[Callee];
|
|
|
|
CallGraphNode *CallerNode = CG[Caller];
|
2008-09-05 12:37:12 +00:00
|
|
|
|
2006-07-12 18:29:36 +00:00
|
|
|
// Since we inlined some uninlined call sites in the callee into the caller,
|
2006-01-14 20:07:50 +00:00
|
|
|
// add edges from the caller to all of the callees of the callee.
|
2009-01-15 18:40:09 +00:00
|
|
|
CallGraphNode::iterator I = CalleeNode->begin(), E = CalleeNode->end();
|
|
|
|
|
|
|
|
// Consider the case where CalleeNode == CallerNode.
|
2009-01-17 00:09:08 +00:00
|
|
|
CallGraphNode::CalledFunctionsVector CallCache;
|
2009-01-15 18:40:09 +00:00
|
|
|
if (CalleeNode == CallerNode) {
|
|
|
|
CallCache.assign(I, E);
|
|
|
|
I = CallCache.begin();
|
|
|
|
E = CallCache.end();
|
|
|
|
}
|
|
|
|
|
|
|
|
for (; I != E; ++I) {
|
2009-09-01 06:31:31 +00:00
|
|
|
const Value *OrigCall = I->first;
|
2008-09-05 12:37:12 +00:00
|
|
|
|
2010-10-13 01:36:30 +00:00
|
|
|
ValueToValueMapTy::iterator VMI = VMap.find(OrigCall);
|
2006-07-12 21:37:11 +00:00
|
|
|
// Only copy the edge if the call was inlined!
|
2014-04-25 05:29:35 +00:00
|
|
|
if (VMI == VMap.end() || VMI->second == nullptr)
|
2009-08-27 03:51:50 +00:00
|
|
|
continue;
|
|
|
|
|
|
|
|
// If the call was inlined, but then constant folded, there is no edge to
|
|
|
|
// add. Check for this case.
|
2010-04-22 21:31:00 +00:00
|
|
|
Instruction *NewCall = dyn_cast<Instruction>(VMI->second);
|
2014-04-25 05:29:35 +00:00
|
|
|
if (!NewCall) continue;
|
2010-05-01 01:26:13 +00:00
|
|
|
|
|
|
|
// Remember that this call site got inlined for the client of
|
|
|
|
// InlineFunction.
|
|
|
|
IFI.InlinedCalls.push_back(NewCall);
|
|
|
|
|
2010-04-22 21:31:00 +00:00
|
|
|
// It's possible that inlining the callsite will cause it to go from an
|
|
|
|
// indirect to a direct call by resolving a function pointer. If this
|
|
|
|
// happens, set the callee of the new call site to a more precise
|
|
|
|
// destination. This can also happen if the call graph node of the caller
|
|
|
|
// was just unnecessarily imprecise.
|
2014-04-25 05:29:35 +00:00
|
|
|
if (!I->second->getFunction())
|
2010-04-22 21:31:00 +00:00
|
|
|
if (Function *F = CallSite(NewCall).getCalledFunction()) {
|
|
|
|
// Indirect call site resolved to direct call.
|
2010-07-27 15:02:37 +00:00
|
|
|
CallerNode->addCalledFunction(CallSite(NewCall), CG[F]);
|
|
|
|
|
2010-04-22 21:31:00 +00:00
|
|
|
continue;
|
|
|
|
}
|
2010-07-27 15:02:37 +00:00
|
|
|
|
|
|
|
CallerNode->addCalledFunction(CallSite(NewCall), I->second);
|
2006-07-12 18:29:36 +00:00
|
|
|
}
|
2009-08-27 03:51:50 +00:00
|
|
|
|
2009-01-13 22:43:37 +00:00
|
|
|
// Update the call graph by deleting the edge from Callee to Caller. We must
|
|
|
|
// do this after the loop above in case Caller and Callee are the same.
|
|
|
|
CallerNode->removeCallEdgeFor(CS);
|
2006-01-14 20:07:50 +00:00
|
|
|
}
|
|
|
|
|
2014-04-15 18:01:54 +00:00
|
|
|
static void HandleByValArgumentInit(Value *Dst, Value *Src, Module *M,
|
|
|
|
BasicBlock *InsertBlock,
|
|
|
|
InlineFunctionInfo &IFI) {
|
|
|
|
LLVMContext &Context = Src->getContext();
|
|
|
|
Type *VoidPtrTy = Type::getInt8PtrTy(Context);
|
|
|
|
Type *AggTy = cast<PointerType>(Src->getType())->getElementType();
|
|
|
|
Type *Tys[3] = { VoidPtrTy, VoidPtrTy, Type::getInt64Ty(Context) };
|
|
|
|
Function *MemCpyFn = Intrinsic::getDeclaration(M, Intrinsic::memcpy, Tys);
|
|
|
|
IRBuilder<> builder(InsertBlock->begin());
|
|
|
|
Value *DstCast = builder.CreateBitCast(Dst, VoidPtrTy, "tmp");
|
|
|
|
Value *SrcCast = builder.CreateBitCast(Src, VoidPtrTy, "tmp");
|
|
|
|
|
|
|
|
Value *Size;
|
2014-04-25 05:29:35 +00:00
|
|
|
if (IFI.DL == nullptr)
|
2014-04-15 18:01:54 +00:00
|
|
|
Size = ConstantExpr::getSizeOf(AggTy);
|
|
|
|
else
|
|
|
|
Size = ConstantInt::get(Type::getInt64Ty(Context),
|
|
|
|
IFI.DL->getTypeStoreSize(AggTy));
|
|
|
|
|
|
|
|
// Always generate a memcpy of alignment 1 here because we don't know
|
|
|
|
// the alignment of the src pointer. Other optimizations can infer
|
|
|
|
// better alignment.
|
|
|
|
Value *CallArgs[] = {
|
|
|
|
DstCast, SrcCast, Size,
|
|
|
|
ConstantInt::get(Type::getInt32Ty(Context), 1),
|
|
|
|
ConstantInt::getFalse(Context) // isVolatile
|
|
|
|
};
|
|
|
|
builder.CreateCall(MemCpyFn, CallArgs);
|
|
|
|
}
|
|
|
|
|
2010-12-20 08:10:40 +00:00
|
|
|
/// HandleByValArgument - When inlining a call site that has a byval argument,
|
|
|
|
/// we have to make the implicit memcpy explicit by adding it.
|
2013-11-03 12:22:13 +00:00
|
|
|
static Value *HandleByValArgument(Value *Arg, Instruction *TheCall,
|
2010-12-20 07:57:41 +00:00
|
|
|
const Function *CalledFunc,
|
|
|
|
InlineFunctionInfo &IFI,
|
|
|
|
unsigned ByValAlignment) {
|
2014-04-23 20:58:57 +00:00
|
|
|
PointerType *ArgTy = cast<PointerType>(Arg->getType());
|
|
|
|
Type *AggTy = ArgTy->getElementType();
|
2010-12-20 08:10:40 +00:00
|
|
|
|
|
|
|
// If the called function is readonly, then it could not mutate the caller's
|
|
|
|
// copy of the byval'd memory. In this case, it is safe to elide the copy and
|
|
|
|
// temporary.
|
2013-11-03 12:22:13 +00:00
|
|
|
if (CalledFunc->onlyReadsMemory()) {
|
2010-12-20 08:10:40 +00:00
|
|
|
// If the byval argument has a specified alignment that is greater than the
|
|
|
|
// passed in pointer, then we either have to round up the input pointer or
|
|
|
|
// give up on this transformation.
|
|
|
|
if (ByValAlignment <= 1) // 0 = unspecified, 1 = no particular alignment.
|
2013-11-03 12:22:13 +00:00
|
|
|
return Arg;
|
2010-12-20 08:10:40 +00:00
|
|
|
|
2010-12-25 20:42:38 +00:00
|
|
|
// If the pointer is already known to be sufficiently aligned, or if we can
|
|
|
|
// round it up to a larger alignment, then we don't need a temporary.
|
2013-11-03 12:22:13 +00:00
|
|
|
if (getOrEnforceKnownAlignment(Arg, ByValAlignment,
|
2014-02-18 15:33:12 +00:00
|
|
|
IFI.DL) >= ByValAlignment)
|
2013-11-03 12:22:13 +00:00
|
|
|
return Arg;
|
2010-12-20 08:10:40 +00:00
|
|
|
|
2010-12-25 20:42:38 +00:00
|
|
|
// Otherwise, we have to make a memcpy to get a safe alignment. This is bad
|
|
|
|
// for code quality, but rarely happens and is required for correctness.
|
2010-12-20 08:10:40 +00:00
|
|
|
}
|
2010-12-20 07:57:41 +00:00
|
|
|
|
2012-10-08 16:38:25 +00:00
|
|
|
// Create the alloca. If we have DataLayout, use nice alignment.
|
2010-12-20 07:57:41 +00:00
|
|
|
unsigned Align = 1;
|
2014-02-18 15:33:12 +00:00
|
|
|
if (IFI.DL)
|
|
|
|
Align = IFI.DL->getPrefTypeAlignment(AggTy);
|
2010-12-20 07:57:41 +00:00
|
|
|
|
|
|
|
// If the byval had an alignment specified, we *must* use at least that
|
|
|
|
// alignment, as it is required by the byval argument (and uses of the
|
|
|
|
// pointer inside the callee).
|
|
|
|
Align = std::max(Align, ByValAlignment);
|
|
|
|
|
|
|
|
Function *Caller = TheCall->getParent()->getParent();
|
|
|
|
|
2014-04-25 05:29:35 +00:00
|
|
|
Value *NewAlloca = new AllocaInst(AggTy, nullptr, Align, Arg->getName(),
|
2010-12-20 07:57:41 +00:00
|
|
|
&*Caller->begin()->begin());
|
2014-04-15 18:06:46 +00:00
|
|
|
IFI.StaticAllocas.push_back(cast<AllocaInst>(NewAlloca));
|
2010-12-20 07:57:41 +00:00
|
|
|
|
|
|
|
// Uses of the argument in the function should use our new alloca
|
|
|
|
// instead.
|
|
|
|
return NewAlloca;
|
|
|
|
}
|
|
|
|
|
2011-05-22 05:22:10 +00:00
|
|
|
// isUsedByLifetimeMarker - Check whether this Value is used by a lifetime
|
|
|
|
// intrinsic.
|
|
|
|
static bool isUsedByLifetimeMarker(Value *V) {
|
2014-03-09 03:16:01 +00:00
|
|
|
for (User *U : V->users()) {
|
|
|
|
if (IntrinsicInst *II = dyn_cast<IntrinsicInst>(U)) {
|
2011-05-22 05:22:10 +00:00
|
|
|
switch (II->getIntrinsicID()) {
|
|
|
|
default: break;
|
|
|
|
case Intrinsic::lifetime_start:
|
|
|
|
case Intrinsic::lifetime_end:
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
|
|
|
// hasLifetimeMarkers - Check whether the given alloca already has
|
|
|
|
// lifetime.start or lifetime.end intrinsics.
|
|
|
|
static bool hasLifetimeMarkers(AllocaInst *AI) {
|
2014-04-23 20:58:57 +00:00
|
|
|
Type *Ty = AI->getType();
|
|
|
|
Type *Int8PtrTy = Type::getInt8PtrTy(Ty->getContext(),
|
|
|
|
Ty->getPointerAddressSpace());
|
|
|
|
if (Ty == Int8PtrTy)
|
2011-05-22 05:22:10 +00:00
|
|
|
return isUsedByLifetimeMarker(AI);
|
|
|
|
|
2011-06-14 00:59:24 +00:00
|
|
|
// Do a scan to find all the casts to i8*.
|
2014-03-09 03:16:01 +00:00
|
|
|
for (User *U : AI->users()) {
|
|
|
|
if (U->getType() != Int8PtrTy) continue;
|
|
|
|
if (U->stripPointerCasts() != AI) continue;
|
|
|
|
if (isUsedByLifetimeMarker(U))
|
2011-05-22 05:22:10 +00:00
|
|
|
return true;
|
|
|
|
}
|
|
|
|
return false;
|
|
|
|
}
|
|
|
|
|
2012-03-26 19:09:38 +00:00
|
|
|
/// updateInlinedAtInfo - Helper function used by fixupLineNumbers to
|
|
|
|
/// recursively update InlinedAtEntry of a DebugLoc.
|
2011-07-08 18:01:31 +00:00
|
|
|
static DebugLoc updateInlinedAtInfo(const DebugLoc &DL,
|
|
|
|
const DebugLoc &InlinedAtDL,
|
|
|
|
LLVMContext &Ctx) {
|
|
|
|
if (MDNode *IA = DL.getInlinedAt(Ctx)) {
|
|
|
|
DebugLoc NewInlinedAtDL
|
|
|
|
= updateInlinedAtInfo(DebugLoc::getFromDILocation(IA), InlinedAtDL, Ctx);
|
|
|
|
return DebugLoc::get(DL.getLine(), DL.getCol(), DL.getScope(Ctx),
|
|
|
|
NewInlinedAtDL.getAsMDNode(Ctx));
|
|
|
|
}
|
2012-03-26 19:09:38 +00:00
|
|
|
|
2011-07-08 18:01:31 +00:00
|
|
|
return DebugLoc::get(DL.getLine(), DL.getCol(), DL.getScope(Ctx),
|
|
|
|
InlinedAtDL.getAsMDNode(Ctx));
|
|
|
|
}
|
|
|
|
|
|
|
|
/// fixupLineNumbers - Update inlined instructions' line numbers to
|
|
|
|
/// to encode location where these instructions are inlined.
|
|
|
|
static void fixupLineNumbers(Function *Fn, Function::iterator FI,
|
2012-03-26 19:09:40 +00:00
|
|
|
Instruction *TheCall) {
|
2011-07-08 18:01:31 +00:00
|
|
|
DebugLoc TheCallDL = TheCall->getDebugLoc();
|
|
|
|
if (TheCallDL.isUnknown())
|
|
|
|
return;
|
|
|
|
|
|
|
|
for (; FI != Fn->end(); ++FI) {
|
|
|
|
for (BasicBlock::iterator BI = FI->begin(), BE = FI->end();
|
|
|
|
BI != BE; ++BI) {
|
|
|
|
DebugLoc DL = BI->getDebugLoc();
|
2014-06-09 09:09:19 +00:00
|
|
|
if (DL.isUnknown()) {
|
|
|
|
// If the inlined instruction has no line number, make it look as if it
|
|
|
|
// originates from the call location. This is important for
|
|
|
|
// ((__always_inline__, __nodebug__)) functions which must use caller
|
|
|
|
// location for all instructions in their function body.
|
|
|
|
BI->setDebugLoc(TheCallDL);
|
|
|
|
} else {
|
2011-07-08 18:01:31 +00:00
|
|
|
BI->setDebugLoc(updateInlinedAtInfo(DL, TheCallDL, BI->getContext()));
|
2011-08-10 21:50:54 +00:00
|
|
|
if (DbgValueInst *DVI = dyn_cast<DbgValueInst>(BI)) {
|
|
|
|
LLVMContext &Ctx = BI->getContext();
|
|
|
|
MDNode *InlinedAt = BI->getDebugLoc().getInlinedAt(Ctx);
|
|
|
|
DVI->setOperand(2, createInlinedVariable(DVI->getVariable(),
|
|
|
|
InlinedAt, Ctx));
|
|
|
|
}
|
|
|
|
}
|
2011-07-08 18:01:31 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2012-01-31 01:01:16 +00:00
|
|
|
/// InlineFunction - This function inlines the called function into the basic
|
|
|
|
/// block of the caller. This returns false if it is not possible to inline
|
|
|
|
/// this call. The program is still in a well defined state if this occurs
|
|
|
|
/// though.
|
|
|
|
///
|
|
|
|
/// Note that this only does one level of inlining. For example, if the
|
|
|
|
/// instruction 'call B' is inlined, and 'B' calls 'C', then the call to 'C' now
|
|
|
|
/// exists in the instruction stream. Similarly this will inline a recursive
|
|
|
|
/// function by one level.
|
2012-03-26 19:09:38 +00:00
|
|
|
bool llvm::InlineFunction(CallSite CS, InlineFunctionInfo &IFI,
|
|
|
|
bool InsertLifetime) {
|
2003-08-24 06:59:16 +00:00
|
|
|
Instruction *TheCall = CS.getInstruction();
|
|
|
|
assert(TheCall->getParent() && TheCall->getParent()->getParent() &&
|
|
|
|
"Instruction not in function!");
|
2003-05-29 15:11:31 +00:00
|
|
|
|
2010-04-22 23:07:58 +00:00
|
|
|
// If IFI has any state in it, zap it before we fill it in.
|
|
|
|
IFI.reset();
|
|
|
|
|
2003-08-24 06:59:16 +00:00
|
|
|
const Function *CalledFunc = CS.getCalledFunction();
|
2014-04-25 05:29:35 +00:00
|
|
|
if (!CalledFunc || // Can't inline external function or indirect
|
2007-01-30 20:08:39 +00:00
|
|
|
CalledFunc->isDeclaration() || // call, or call to a vararg function!
|
2010-03-24 23:35:21 +00:00
|
|
|
CalledFunc->getFunctionType()->isVarArg()) return false;
|
2003-05-29 15:11:31 +00:00
|
|
|
|
2007-12-19 21:13:37 +00:00
|
|
|
// If the call to the callee cannot throw, set the 'nounwind' flag on any
|
|
|
|
// calls that we inline.
|
|
|
|
bool MarkNoUnwind = CS.doesNotThrow();
|
|
|
|
|
2003-08-24 06:59:16 +00:00
|
|
|
BasicBlock *OrigBB = TheCall->getParent();
|
2003-05-29 15:11:31 +00:00
|
|
|
Function *Caller = OrigBB->getParent();
|
|
|
|
|
2007-12-25 03:10:07 +00:00
|
|
|
// GC poses two hazards to inlining, which only occur when the callee has GC:
|
|
|
|
// 1. If the caller has no GC, then the callee's GC must be propagated to the
|
|
|
|
// caller.
|
|
|
|
// 2. If the caller has a differing GC, it is invalid to inline.
|
2008-08-17 18:44:35 +00:00
|
|
|
if (CalledFunc->hasGC()) {
|
|
|
|
if (!Caller->hasGC())
|
|
|
|
Caller->setGC(CalledFunc->getGC());
|
|
|
|
else if (CalledFunc->getGC() != Caller->getGC())
|
2007-12-25 03:10:07 +00:00
|
|
|
return false;
|
|
|
|
}
|
2008-09-05 12:37:12 +00:00
|
|
|
|
2011-12-02 18:37:31 +00:00
|
|
|
// Get the personality function from the callee if it contains a landing pad.
|
2014-04-25 05:29:35 +00:00
|
|
|
Value *CalleePersonality = nullptr;
|
2011-12-02 18:37:31 +00:00
|
|
|
for (Function::const_iterator I = CalledFunc->begin(), E = CalledFunc->end();
|
|
|
|
I != E; ++I)
|
2011-08-14 08:01:36 +00:00
|
|
|
if (const InvokeInst *II = dyn_cast<InvokeInst>(I->getTerminator())) {
|
|
|
|
const BasicBlock *BB = II->getUnwindDest();
|
2012-01-31 00:56:53 +00:00
|
|
|
const LandingPadInst *LP = BB->getLandingPadInst();
|
|
|
|
CalleePersonality = LP->getPersonalityFn();
|
2011-08-14 08:01:36 +00:00
|
|
|
break;
|
|
|
|
}
|
|
|
|
|
2011-12-02 18:37:31 +00:00
|
|
|
// Find the personality function used by the landing pads of the caller. If it
|
|
|
|
// exists, then check to see that it matches the personality function used in
|
|
|
|
// the callee.
|
2012-01-31 01:01:16 +00:00
|
|
|
if (CalleePersonality) {
|
2011-12-02 18:37:31 +00:00
|
|
|
for (Function::const_iterator I = Caller->begin(), E = Caller->end();
|
|
|
|
I != E; ++I)
|
|
|
|
if (const InvokeInst *II = dyn_cast<InvokeInst>(I->getTerminator())) {
|
|
|
|
const BasicBlock *BB = II->getUnwindDest();
|
2012-01-31 00:56:53 +00:00
|
|
|
const LandingPadInst *LP = BB->getLandingPadInst();
|
2011-12-02 18:37:31 +00:00
|
|
|
|
|
|
|
// If the personality functions match, then we can perform the
|
|
|
|
// inlining. Otherwise, we can't inline.
|
|
|
|
// TODO: This isn't 100% true. Some personality functions are proper
|
|
|
|
// supersets of others and can be used in place of the other.
|
|
|
|
if (LP->getPersonalityFn() != CalleePersonality)
|
|
|
|
return false;
|
|
|
|
|
|
|
|
break;
|
|
|
|
}
|
2012-01-31 01:01:16 +00:00
|
|
|
}
|
2011-12-02 18:37:31 +00:00
|
|
|
|
2004-02-04 01:41:09 +00:00
|
|
|
// Get an iterator to the last basic block in the function, which will have
|
|
|
|
// the new function inlined after it.
|
|
|
|
Function::iterator LastBlock = &Caller->back();
|
|
|
|
|
2004-02-04 02:51:48 +00:00
|
|
|
// Make sure to capture all of the return instructions from the cloned
|
|
|
|
// function.
|
2009-08-27 04:02:30 +00:00
|
|
|
SmallVector<ReturnInst*, 8> Returns;
|
2006-01-13 19:05:59 +00:00
|
|
|
ClonedCodeInfo InlinedFunctionInfo;
|
2009-03-04 02:09:48 +00:00
|
|
|
Function::iterator FirstNewBlock;
|
2007-12-19 21:13:37 +00:00
|
|
|
|
2010-06-23 23:55:51 +00:00
|
|
|
{ // Scope to destroy VMap after cloning.
|
2010-10-13 01:36:30 +00:00
|
|
|
ValueToValueMapTy VMap;
|
2014-04-15 18:01:54 +00:00
|
|
|
// Keep a list of pair (dst, src) to emit byval initializations.
|
|
|
|
SmallVector<std::pair<Value*, Value*>, 4> ByValInit;
|
2006-05-27 01:28:04 +00:00
|
|
|
|
2008-06-20 17:11:32 +00:00
|
|
|
assert(CalledFunc->arg_size() == CS.arg_size() &&
|
2004-02-04 02:51:48 +00:00
|
|
|
"No varargs calls can be inlined!");
|
2008-09-05 12:37:12 +00:00
|
|
|
|
2008-01-11 06:09:30 +00:00
|
|
|
// Calculate the vector of arguments to pass into the function cloner, which
|
|
|
|
// matches up the formal to the actual argument values.
|
2004-02-04 02:51:48 +00:00
|
|
|
CallSite::arg_iterator AI = CS.arg_begin();
|
2008-01-11 06:09:30 +00:00
|
|
|
unsigned ArgNo = 0;
|
2005-03-15 04:54:21 +00:00
|
|
|
for (Function::const_arg_iterator I = CalledFunc->arg_begin(),
|
2008-01-11 06:09:30 +00:00
|
|
|
E = CalledFunc->arg_end(); I != E; ++I, ++AI, ++ArgNo) {
|
|
|
|
Value *ActualArg = *AI;
|
2008-09-05 12:37:12 +00:00
|
|
|
|
2008-01-27 18:12:58 +00:00
|
|
|
// When byval arguments actually inlined, we need to make the copy implied
|
|
|
|
// by them explicit. However, we don't do this if the callee is readonly
|
|
|
|
// or readnone, because the copy would be unneeded: the callee doesn't
|
|
|
|
// modify the struct.
|
2011-11-20 19:09:04 +00:00
|
|
|
if (CS.isByValArgument(ArgNo)) {
|
2013-11-03 12:22:13 +00:00
|
|
|
ActualArg = HandleByValArgument(ActualArg, TheCall, CalledFunc, IFI,
|
2010-12-20 07:57:41 +00:00
|
|
|
CalledFunc->getParamAlignment(ArgNo+1));
|
2014-04-21 20:48:47 +00:00
|
|
|
if (ActualArg != *AI)
|
2014-04-15 18:01:54 +00:00
|
|
|
ByValInit.push_back(std::make_pair(ActualArg, (Value*) *AI));
|
2008-01-11 06:09:30 +00:00
|
|
|
}
|
2008-09-05 12:37:12 +00:00
|
|
|
|
2010-06-23 23:55:51 +00:00
|
|
|
VMap[I] = ActualArg;
|
2008-01-11 06:09:30 +00:00
|
|
|
}
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2006-05-27 01:28:04 +00:00
|
|
|
// We want the inliner to prune the code as it copies. We would LOVE to
|
|
|
|
// have no dead or constant instructions leftover after inlining occurs
|
|
|
|
// (which can happen, e.g., because an argument was constant), but we'll be
|
|
|
|
// happy with whatever the cloner can do.
|
2010-08-26 15:41:53 +00:00
|
|
|
CloneAndPruneFunctionInto(Caller, CalledFunc, VMap,
|
|
|
|
/*ModuleLevelChanges=*/false, Returns, ".i",
|
2014-02-18 15:33:12 +00:00
|
|
|
&InlinedFunctionInfo, IFI.DL, TheCall);
|
2008-09-05 12:37:12 +00:00
|
|
|
|
2006-07-12 18:29:36 +00:00
|
|
|
// Remember the first block that is newly cloned over.
|
|
|
|
FirstNewBlock = LastBlock; ++FirstNewBlock;
|
2008-09-05 12:37:12 +00:00
|
|
|
|
2014-04-15 18:01:54 +00:00
|
|
|
// Inject byval arguments initialization.
|
|
|
|
for (std::pair<Value*, Value*> &Init : ByValInit)
|
|
|
|
HandleByValArgumentInit(Init.first, Init.second, Caller->getParent(),
|
|
|
|
FirstNewBlock, IFI);
|
|
|
|
|
2006-07-12 18:29:36 +00:00
|
|
|
// Update the callgraph if requested.
|
2010-04-22 23:07:58 +00:00
|
|
|
if (IFI.CG)
|
2010-06-23 23:55:51 +00:00
|
|
|
UpdateCallGraphAfterInlining(CS, FirstNewBlock, VMap, IFI);
|
2011-07-08 18:01:31 +00:00
|
|
|
|
|
|
|
// Update inlined instructions' line number information.
|
|
|
|
fixupLineNumbers(Caller, FirstNewBlock, TheCall);
|
Add scoped-noalias metadata
This commit adds scoped noalias metadata. The primary motivations for this
feature are:
1. To preserve noalias function attribute information when inlining
2. To provide the ability to model block-scope C99 restrict pointers
Neither of these two abilities are added here, only the necessary
infrastructure. In fact, there should be no change to existing functionality,
only the addition of new features. The logic that converts noalias function
parameters into this metadata during inlining will come in a follow-up commit.
What is added here is the ability to generally specify noalias memory-access
sets. Regarding the metadata, alias-analysis scopes are defined similar to TBAA
nodes:
!scope0 = metadata !{ metadata !"scope of foo()" }
!scope1 = metadata !{ metadata !"scope 1", metadata !scope0 }
!scope2 = metadata !{ metadata !"scope 2", metadata !scope0 }
!scope3 = metadata !{ metadata !"scope 2.1", metadata !scope2 }
!scope4 = metadata !{ metadata !"scope 2.2", metadata !scope2 }
Loads and stores can be tagged with an alias-analysis scope, and also, with a
noalias tag for a specific scope:
... = load %ptr1, !alias.scope !{ !scope1 }
... = load %ptr2, !alias.scope !{ !scope1, !scope2 }, !noalias !{ !scope1 }
When evaluating an aliasing query, if one of the instructions is associated
with an alias.scope id that is identical to the noalias scope associated with
the other instruction, or is a descendant (in the scope hierarchy) of the
noalias scope associated with the other instruction, then the two memory
accesses are assumed not to alias.
Note that is the first element of the scope metadata is a string, then it can
be combined accross functions and translation units. The string can be replaced
by a self-reference to create globally unqiue scope identifiers.
[Note: This overview is slightly stylized, since the metadata nodes really need
to just be numbers (!0 instead of !scope0), and the scope lists are also global
unnamed metadata.]
Existing noalias metadata in a callee is "cloned" for use by the inlined code.
This is necessary because the aliasing scopes are unique to each call site
(because of possible control dependencies on the aliasing properties). For
example, consider a function: foo(noalias a, noalias b) { *a = *b; } that gets
inlined into bar() { ... if (...) foo(a1, b1); ... if (...) foo(a2, b2); } --
now just because we know that a1 does not alias with b1 at the first call site,
and a2 does not alias with b2 at the second call site, we cannot let inlining
these functons have the metadata imply that a1 does not alias with b2.
git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@213864 91177308-0d34-0410-b5e6-96231b3b80d8
2014-07-24 14:25:39 +00:00
|
|
|
|
|
|
|
// Clone existing noalias metadata if necessary.
|
|
|
|
CloneAliasScopeMetadata(CS, VMap);
|
2014-07-25 15:50:08 +00:00
|
|
|
|
|
|
|
// Add noalias metadata if necessary.
|
|
|
|
AddAliasScopeMetadata(CS, VMap, IFI.DL);
|
2005-04-21 23:48:37 +00:00
|
|
|
}
|
2008-09-05 12:37:12 +00:00
|
|
|
|
2003-05-29 15:11:31 +00:00
|
|
|
// If there are any alloca instructions in the block that used to be the entry
|
|
|
|
// block for the callee, move them to the entry block of the caller. First
|
|
|
|
// calculate which instruction they should be inserted before. We insert the
|
|
|
|
// instructions at the end of the current alloca list.
|
2006-01-13 18:16:48 +00:00
|
|
|
{
|
2003-08-24 06:59:16 +00:00
|
|
|
BasicBlock::iterator InsertPoint = Caller->begin()->begin();
|
2004-02-04 02:51:48 +00:00
|
|
|
for (BasicBlock::iterator I = FirstNewBlock->begin(),
|
2009-08-27 03:51:50 +00:00
|
|
|
E = FirstNewBlock->end(); I != E; ) {
|
|
|
|
AllocaInst *AI = dyn_cast<AllocaInst>(I++);
|
2014-04-25 05:29:35 +00:00
|
|
|
if (!AI) continue;
|
2009-08-27 03:51:50 +00:00
|
|
|
|
|
|
|
// If the alloca is now dead, remove it. This often occurs due to code
|
|
|
|
// specialization.
|
|
|
|
if (AI->use_empty()) {
|
|
|
|
AI->eraseFromParent();
|
|
|
|
continue;
|
2006-09-13 19:23:57 +00:00
|
|
|
}
|
2009-08-27 03:51:50 +00:00
|
|
|
|
|
|
|
if (!isa<Constant>(AI->getArraySize()))
|
|
|
|
continue;
|
|
|
|
|
2010-12-06 07:43:04 +00:00
|
|
|
// Keep track of the static allocas that we inline into the caller.
|
2010-04-22 23:07:58 +00:00
|
|
|
IFI.StaticAllocas.push_back(AI);
|
2009-08-27 04:20:52 +00:00
|
|
|
|
2009-08-27 03:51:50 +00:00
|
|
|
// Scan for the block of allocas that we can move over, and move them
|
|
|
|
// all at once.
|
|
|
|
while (isa<AllocaInst>(I) &&
|
2009-08-27 04:20:52 +00:00
|
|
|
isa<Constant>(cast<AllocaInst>(I)->getArraySize())) {
|
2010-04-22 23:07:58 +00:00
|
|
|
IFI.StaticAllocas.push_back(cast<AllocaInst>(I));
|
2009-08-27 03:51:50 +00:00
|
|
|
++I;
|
2009-08-27 04:20:52 +00:00
|
|
|
}
|
2009-08-27 03:51:50 +00:00
|
|
|
|
|
|
|
// Transfer all of the allocas over in a block. Using splice means
|
|
|
|
// that the instructions aren't removed from the symbol table, then
|
|
|
|
// reinserted.
|
|
|
|
Caller->getEntryBlock().getInstList().splice(InsertPoint,
|
|
|
|
FirstNewBlock->getInstList(),
|
|
|
|
AI, I);
|
|
|
|
}
|
2003-08-24 06:59:16 +00:00
|
|
|
}
|
|
|
|
|
2014-05-15 20:11:28 +00:00
|
|
|
bool InlinedMustTailCalls = false;
|
|
|
|
if (InlinedFunctionInfo.ContainsCalls) {
|
2014-05-15 20:39:42 +00:00
|
|
|
CallInst::TailCallKind CallSiteTailKind = CallInst::TCK_None;
|
|
|
|
if (CallInst *CI = dyn_cast<CallInst>(TheCall))
|
|
|
|
CallSiteTailKind = CI->getTailCallKind();
|
|
|
|
|
2014-05-15 20:11:28 +00:00
|
|
|
for (Function::iterator BB = FirstNewBlock, E = Caller->end(); BB != E;
|
|
|
|
++BB) {
|
|
|
|
for (Instruction &I : *BB) {
|
|
|
|
CallInst *CI = dyn_cast<CallInst>(&I);
|
|
|
|
if (!CI)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// We need to reduce the strength of any inlined tail calls. For
|
|
|
|
// musttail, we have to avoid introducing potential unbounded stack
|
|
|
|
// growth. For example, if functions 'f' and 'g' are mutually recursive
|
|
|
|
// with musttail, we can inline 'g' into 'f' so long as we preserve
|
|
|
|
// musttail on the cloned call to 'f'. If either the inlined call site
|
|
|
|
// or the cloned call site is *not* musttail, the program already has
|
|
|
|
// one frame of stack growth, so it's safe to remove musttail. Here is
|
|
|
|
// a table of example transformations:
|
|
|
|
//
|
|
|
|
// f -> musttail g -> musttail f ==> f -> musttail f
|
|
|
|
// f -> musttail g -> tail f ==> f -> tail f
|
|
|
|
// f -> g -> musttail f ==> f -> f
|
|
|
|
// f -> g -> tail f ==> f -> f
|
|
|
|
CallInst::TailCallKind ChildTCK = CI->getTailCallKind();
|
|
|
|
ChildTCK = std::min(CallSiteTailKind, ChildTCK);
|
|
|
|
CI->setTailCallKind(ChildTCK);
|
|
|
|
InlinedMustTailCalls |= CI->isMustTailCall();
|
|
|
|
|
|
|
|
// Calls inlined through a 'nounwind' call site should be marked
|
|
|
|
// 'nounwind'.
|
|
|
|
if (MarkNoUnwind)
|
|
|
|
CI->setDoesNotThrow();
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2011-05-22 05:22:10 +00:00
|
|
|
// Leave lifetime markers for the static alloca's, scoping them to the
|
|
|
|
// function we just inlined.
|
2012-02-25 02:56:01 +00:00
|
|
|
if (InsertLifetime && !IFI.StaticAllocas.empty()) {
|
2011-05-22 05:22:10 +00:00
|
|
|
IRBuilder<> builder(FirstNewBlock->begin());
|
|
|
|
for (unsigned ai = 0, ae = IFI.StaticAllocas.size(); ai != ae; ++ai) {
|
|
|
|
AllocaInst *AI = IFI.StaticAllocas[ai];
|
|
|
|
|
|
|
|
// If the alloca is already scoped to something smaller than the whole
|
|
|
|
// function then there's no need to add redundant, less accurate markers.
|
|
|
|
if (hasLifetimeMarkers(AI))
|
|
|
|
continue;
|
|
|
|
|
2012-11-13 07:15:32 +00:00
|
|
|
// Try to determine the size of the allocation.
|
2014-04-25 05:29:35 +00:00
|
|
|
ConstantInt *AllocaSize = nullptr;
|
2012-11-13 07:15:32 +00:00
|
|
|
if (ConstantInt *AIArraySize =
|
|
|
|
dyn_cast<ConstantInt>(AI->getArraySize())) {
|
2014-02-18 15:33:12 +00:00
|
|
|
if (IFI.DL) {
|
2012-11-13 07:15:32 +00:00
|
|
|
Type *AllocaType = AI->getAllocatedType();
|
2014-02-18 15:33:12 +00:00
|
|
|
uint64_t AllocaTypeSize = IFI.DL->getTypeAllocSize(AllocaType);
|
2012-11-13 07:15:32 +00:00
|
|
|
uint64_t AllocaArraySize = AIArraySize->getLimitedValue();
|
|
|
|
assert(AllocaArraySize > 0 && "array size of AllocaInst is zero");
|
|
|
|
// Check that array size doesn't saturate uint64_t and doesn't
|
|
|
|
// overflow when it's multiplied by type size.
|
|
|
|
if (AllocaArraySize != ~0ULL &&
|
|
|
|
UINT64_MAX / AllocaArraySize >= AllocaTypeSize) {
|
|
|
|
AllocaSize = ConstantInt::get(Type::getInt64Ty(AI->getContext()),
|
|
|
|
AllocaArraySize * AllocaTypeSize);
|
|
|
|
}
|
|
|
|
}
|
|
|
|
}
|
|
|
|
|
|
|
|
builder.CreateLifetimeStart(AI, AllocaSize);
|
2014-05-15 21:10:46 +00:00
|
|
|
for (ReturnInst *RI : Returns) {
|
|
|
|
// Don't insert llvm.lifetime.end calls between a musttail call and a
|
|
|
|
// return. The return kills all local allocas.
|
2014-08-12 00:05:15 +00:00
|
|
|
if (InlinedMustTailCalls &&
|
|
|
|
RI->getParent()->getTerminatingMustTailCall())
|
2014-05-15 21:10:46 +00:00
|
|
|
continue;
|
2014-05-15 20:11:28 +00:00
|
|
|
IRBuilder<>(RI).CreateLifetimeEnd(AI, AllocaSize);
|
2014-05-15 21:10:46 +00:00
|
|
|
}
|
2011-05-22 05:22:10 +00:00
|
|
|
}
|
|
|
|
}
|
|
|
|
|
2006-01-13 19:34:14 +00:00
|
|
|
// If the inlined code contained dynamic alloca instructions, wrap the inlined
|
|
|
|
// code with llvm.stacksave/llvm.stackrestore intrinsics.
|
|
|
|
if (InlinedFunctionInfo.ContainsDynamicAllocas) {
|
|
|
|
Module *M = Caller->getParent();
|
|
|
|
// Get the two intrinsics we care about.
|
2009-10-17 05:39:39 +00:00
|
|
|
Function *StackSave = Intrinsic::getDeclaration(M, Intrinsic::stacksave);
|
|
|
|
Function *StackRestore=Intrinsic::getDeclaration(M,Intrinsic::stackrestore);
|
2006-07-12 18:29:36 +00:00
|
|
|
|
2006-01-13 19:34:14 +00:00
|
|
|
// Insert the llvm.stacksave.
|
2011-06-14 02:51:53 +00:00
|
|
|
CallInst *SavedPtr = IRBuilder<>(FirstNewBlock, FirstNewBlock->begin())
|
|
|
|
.CreateCall(StackSave, "savedstack");
|
2008-09-05 12:37:12 +00:00
|
|
|
|
2006-01-13 19:34:14 +00:00
|
|
|
// Insert a call to llvm.stackrestore before any return instructions in the
|
|
|
|
// inlined function.
|
2014-05-15 21:10:46 +00:00
|
|
|
for (ReturnInst *RI : Returns) {
|
|
|
|
// Don't insert llvm.stackrestore calls between a musttail call and a
|
|
|
|
// return. The return will restore the stack pointer.
|
2014-08-12 00:05:15 +00:00
|
|
|
if (InlinedMustTailCalls && RI->getParent()->getTerminatingMustTailCall())
|
2014-05-15 21:10:46 +00:00
|
|
|
continue;
|
2014-05-15 20:11:28 +00:00
|
|
|
IRBuilder<>(RI).CreateCall(StackRestore, SavedPtr);
|
2014-05-15 21:10:46 +00:00
|
|
|
}
|
2005-05-06 06:47:52 +00:00
|
|
|
}
|
|
|
|
|
2004-02-04 02:51:48 +00:00
|
|
|
// If we are inlining for an invoke instruction, we must make sure to rewrite
|
2012-02-06 21:44:22 +00:00
|
|
|
// any call instructions into invoke instructions.
|
2006-01-13 19:05:59 +00:00
|
|
|
if (InvokeInst *II = dyn_cast<InvokeInst>(TheCall))
|
2009-09-01 18:44:06 +00:00
|
|
|
HandleInlinedInvoke(II, FirstNewBlock, InlinedFunctionInfo);
|
2004-02-04 02:51:48 +00:00
|
|
|
|
2014-05-15 20:11:28 +00:00
|
|
|
// Handle any inlined musttail call sites. In order for a new call site to be
|
|
|
|
// musttail, the source of the clone and the inlined call site must have been
|
|
|
|
// musttail. Therefore it's safe to return without merging control into the
|
|
|
|
// phi below.
|
|
|
|
if (InlinedMustTailCalls) {
|
|
|
|
// Check if we need to bitcast the result of any musttail calls.
|
|
|
|
Type *NewRetTy = Caller->getReturnType();
|
|
|
|
bool NeedBitCast = !TheCall->use_empty() && TheCall->getType() != NewRetTy;
|
|
|
|
|
|
|
|
// Handle the returns preceded by musttail calls separately.
|
|
|
|
SmallVector<ReturnInst *, 8> NormalReturns;
|
|
|
|
for (ReturnInst *RI : Returns) {
|
2014-08-12 00:05:15 +00:00
|
|
|
CallInst *ReturnedMustTail =
|
|
|
|
RI->getParent()->getTerminatingMustTailCall();
|
2014-05-15 20:11:28 +00:00
|
|
|
if (!ReturnedMustTail) {
|
|
|
|
NormalReturns.push_back(RI);
|
|
|
|
continue;
|
|
|
|
}
|
|
|
|
if (!NeedBitCast)
|
|
|
|
continue;
|
|
|
|
|
|
|
|
// Delete the old return and any preceding bitcast.
|
|
|
|
BasicBlock *CurBB = RI->getParent();
|
|
|
|
auto *OldCast = dyn_cast_or_null<BitCastInst>(RI->getReturnValue());
|
|
|
|
RI->eraseFromParent();
|
|
|
|
if (OldCast)
|
|
|
|
OldCast->eraseFromParent();
|
|
|
|
|
|
|
|
// Insert a new bitcast and return with the right type.
|
|
|
|
IRBuilder<> Builder(CurBB);
|
|
|
|
Builder.CreateRet(Builder.CreateBitCast(ReturnedMustTail, NewRetTy));
|
|
|
|
}
|
|
|
|
|
|
|
|
// Leave behind the normal returns so we can merge control flow.
|
|
|
|
std::swap(Returns, NormalReturns);
|
|
|
|
}
|
|
|
|
|
2004-02-04 04:17:06 +00:00
|
|
|
// If we cloned in _exactly one_ basic block, and if that block ends in a
|
|
|
|
// return instruction, we splice the body of the inlined callee directly into
|
|
|
|
// the calling basic block.
|
|
|
|
if (Returns.size() == 1 && std::distance(FirstNewBlock, Caller->end()) == 1) {
|
|
|
|
// Move all of the instructions right before the call.
|
|
|
|
OrigBB->getInstList().splice(TheCall, FirstNewBlock->getInstList(),
|
|
|
|
FirstNewBlock->begin(), FirstNewBlock->end());
|
|
|
|
// Remove the cloned basic block.
|
|
|
|
Caller->getBasicBlockList().pop_back();
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2004-02-04 04:17:06 +00:00
|
|
|
// If the call site was an invoke instruction, add a branch to the normal
|
|
|
|
// destination.
|
2013-04-23 19:56:03 +00:00
|
|
|
if (InvokeInst *II = dyn_cast<InvokeInst>(TheCall)) {
|
|
|
|
BranchInst *NewBr = BranchInst::Create(II->getNormalDest(), TheCall);
|
|
|
|
NewBr->setDebugLoc(Returns[0]->getDebugLoc());
|
|
|
|
}
|
2004-02-04 04:17:06 +00:00
|
|
|
|
|
|
|
// If the return instruction returned a value, replace uses of the call with
|
|
|
|
// uses of the returned value.
|
2008-03-04 21:15:15 +00:00
|
|
|
if (!TheCall->use_empty()) {
|
|
|
|
ReturnInst *R = Returns[0];
|
2009-05-08 00:22:04 +00:00
|
|
|
if (TheCall == R->getReturnValue())
|
2009-07-30 23:03:37 +00:00
|
|
|
TheCall->replaceAllUsesWith(UndefValue::get(TheCall->getType()));
|
2009-05-08 00:22:04 +00:00
|
|
|
else
|
|
|
|
TheCall->replaceAllUsesWith(R->getReturnValue());
|
2008-03-04 21:15:15 +00:00
|
|
|
}
|
2004-02-04 04:17:06 +00:00
|
|
|
// Since we are now done with the Call/Invoke, we can delete it.
|
2008-06-21 22:08:46 +00:00
|
|
|
TheCall->eraseFromParent();
|
2004-02-04 04:17:06 +00:00
|
|
|
|
|
|
|
// Since we are now done with the return instruction, delete it also.
|
2008-06-21 22:08:46 +00:00
|
|
|
Returns[0]->eraseFromParent();
|
2004-02-04 04:17:06 +00:00
|
|
|
|
|
|
|
// We are now done with the inlining.
|
|
|
|
return true;
|
|
|
|
}
|
|
|
|
|
|
|
|
// Otherwise, we have the normal case, of more than one block to inline or
|
|
|
|
// multiple return sites.
|
|
|
|
|
2004-02-04 02:51:48 +00:00
|
|
|
// We want to clone the entire callee function into the hole between the
|
|
|
|
// "starter" and "ender" blocks. How we accomplish this depends on whether
|
|
|
|
// this is an invoke instruction or a call instruction.
|
|
|
|
BasicBlock *AfterCallBB;
|
2014-04-25 05:29:35 +00:00
|
|
|
BranchInst *CreatedBranchToNormalDest = nullptr;
|
2004-02-04 02:51:48 +00:00
|
|
|
if (InvokeInst *II = dyn_cast<InvokeInst>(TheCall)) {
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2004-02-04 02:51:48 +00:00
|
|
|
// Add an unconditional branch to make this look like the CallInst case...
|
2013-04-23 19:56:03 +00:00
|
|
|
CreatedBranchToNormalDest = BranchInst::Create(II->getNormalDest(), TheCall);
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2004-02-04 02:51:48 +00:00
|
|
|
// Split the basic block. This guarantees that no PHI nodes will have to be
|
|
|
|
// updated due to new incoming edges, and make the invoke case more
|
|
|
|
// symmetric to the call case.
|
2013-04-23 19:56:03 +00:00
|
|
|
AfterCallBB = OrigBB->splitBasicBlock(CreatedBranchToNormalDest,
|
2004-12-11 16:59:54 +00:00
|
|
|
CalledFunc->getName()+".exit");
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2004-02-04 02:51:48 +00:00
|
|
|
} else { // It's a call
|
2004-02-04 04:17:06 +00:00
|
|
|
// If this is a call instruction, we need to split the basic block that
|
|
|
|
// the call lives in.
|
2004-02-04 02:51:48 +00:00
|
|
|
//
|
|
|
|
AfterCallBB = OrigBB->splitBasicBlock(TheCall,
|
2004-12-11 16:59:54 +00:00
|
|
|
CalledFunc->getName()+".exit");
|
2004-02-04 02:51:48 +00:00
|
|
|
}
|
|
|
|
|
2004-02-04 04:17:06 +00:00
|
|
|
// Change the branch that used to go to AfterCallBB to branch to the first
|
|
|
|
// basic block of the inlined function.
|
|
|
|
//
|
|
|
|
TerminatorInst *Br = OrigBB->getTerminator();
|
2005-04-21 23:48:37 +00:00
|
|
|
assert(Br && Br->getOpcode() == Instruction::Br &&
|
2004-02-04 04:17:06 +00:00
|
|
|
"splitBasicBlock broken!");
|
|
|
|
Br->setOperand(0, FirstNewBlock);
|
|
|
|
|
|
|
|
|
|
|
|
// Now that the function is correct, make it a little bit nicer. In
|
|
|
|
// particular, move the basic blocks inserted from the end of the function
|
|
|
|
// into the space made by splitting the source basic block.
|
|
|
|
Caller->getBasicBlockList().splice(AfterCallBB, Caller->getBasicBlockList(),
|
|
|
|
FirstNewBlock, Caller->end());
|
|
|
|
|
2004-02-04 02:51:48 +00:00
|
|
|
// Handle all of the return instructions that we just cloned in, and eliminate
|
|
|
|
// any users of the original call/invoke instruction.
|
2011-07-18 04:54:35 +00:00
|
|
|
Type *RTy = CalledFunc->getReturnType();
|
2008-06-20 01:03:44 +00:00
|
|
|
|
2014-04-25 05:29:35 +00:00
|
|
|
PHINode *PHI = nullptr;
|
2008-07-23 00:34:11 +00:00
|
|
|
if (Returns.size() > 1) {
|
2004-02-04 02:51:48 +00:00
|
|
|
// The PHI node should go at the front of the new basic block to merge all
|
|
|
|
// possible incoming values.
|
|
|
|
if (!TheCall->use_empty()) {
|
2011-03-30 11:28:46 +00:00
|
|
|
PHI = PHINode::Create(RTy, Returns.size(), TheCall->getName(),
|
2008-07-23 00:34:11 +00:00
|
|
|
AfterCallBB->begin());
|
|
|
|
// Anything that used the result of the function call should now use the
|
|
|
|
// PHI node as their operand.
|
2008-09-05 12:37:12 +00:00
|
|
|
TheCall->replaceAllUsesWith(PHI);
|
2004-02-04 02:51:48 +00:00
|
|
|
}
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2009-01-15 18:40:09 +00:00
|
|
|
// Loop over all of the return instructions adding entries to the PHI node
|
|
|
|
// as appropriate.
|
2008-07-23 00:34:11 +00:00
|
|
|
if (PHI) {
|
|
|
|
for (unsigned i = 0, e = Returns.size(); i != e; ++i) {
|
|
|
|
ReturnInst *RI = Returns[i];
|
|
|
|
assert(RI->getReturnValue()->getType() == PHI->getType() &&
|
|
|
|
"Ret value not consistent in function!");
|
|
|
|
PHI->addIncoming(RI->getReturnValue(), RI->getParent());
|
2004-02-04 02:51:48 +00:00
|
|
|
}
|
2008-03-07 20:06:16 +00:00
|
|
|
}
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2009-10-27 05:39:41 +00:00
|
|
|
|
2009-01-16 23:08:50 +00:00
|
|
|
// Add a branch to the merge points and remove return instructions.
|
2013-04-30 22:45:10 +00:00
|
|
|
DebugLoc Loc;
|
2008-03-07 20:06:16 +00:00
|
|
|
for (unsigned i = 0, e = Returns.size(); i != e; ++i) {
|
2013-04-30 22:45:10 +00:00
|
|
|
ReturnInst *RI = Returns[i];
|
2013-04-30 17:08:16 +00:00
|
|
|
BranchInst* BI = BranchInst::Create(AfterCallBB, RI);
|
2013-04-30 22:45:10 +00:00
|
|
|
Loc = RI->getDebugLoc();
|
|
|
|
BI->setDebugLoc(Loc);
|
2008-03-10 18:34:00 +00:00
|
|
|
RI->eraseFromParent();
|
2004-02-04 02:51:48 +00:00
|
|
|
}
|
2013-04-30 17:08:16 +00:00
|
|
|
// We need to set the debug location to *somewhere* inside the
|
2013-04-30 17:33:32 +00:00
|
|
|
// inlined function. The line number may be nonsensical, but the
|
2013-04-30 17:08:16 +00:00
|
|
|
// instruction will at least be associated with the right
|
|
|
|
// function.
|
|
|
|
if (CreatedBranchToNormalDest)
|
2013-04-30 22:45:10 +00:00
|
|
|
CreatedBranchToNormalDest->setDebugLoc(Loc);
|
2008-03-10 18:34:00 +00:00
|
|
|
} else if (!Returns.empty()) {
|
|
|
|
// Otherwise, if there is exactly one return value, just replace anything
|
|
|
|
// using the return value of the call with the computed value.
|
2009-05-08 00:22:04 +00:00
|
|
|
if (!TheCall->use_empty()) {
|
|
|
|
if (TheCall == Returns[0]->getReturnValue())
|
2009-07-30 23:03:37 +00:00
|
|
|
TheCall->replaceAllUsesWith(UndefValue::get(TheCall->getType()));
|
2009-05-08 00:22:04 +00:00
|
|
|
else
|
|
|
|
TheCall->replaceAllUsesWith(Returns[0]->getReturnValue());
|
|
|
|
}
|
2008-09-05 12:37:12 +00:00
|
|
|
|
2011-06-23 09:09:15 +00:00
|
|
|
// Update PHI nodes that use the ReturnBB to use the AfterCallBB.
|
|
|
|
BasicBlock *ReturnBB = Returns[0]->getParent();
|
|
|
|
ReturnBB->replaceAllUsesWith(AfterCallBB);
|
|
|
|
|
2008-03-10 18:34:00 +00:00
|
|
|
// Splice the code from the return block into the block that it will return
|
|
|
|
// to, which contains the code that was after the call.
|
|
|
|
AfterCallBB->getInstList().splice(AfterCallBB->begin(),
|
|
|
|
ReturnBB->getInstList());
|
2008-09-05 12:37:12 +00:00
|
|
|
|
2013-04-23 19:56:03 +00:00
|
|
|
if (CreatedBranchToNormalDest)
|
|
|
|
CreatedBranchToNormalDest->setDebugLoc(Returns[0]->getDebugLoc());
|
|
|
|
|
2008-03-10 18:34:00 +00:00
|
|
|
// Delete the return instruction now and empty ReturnBB now.
|
|
|
|
Returns[0]->eraseFromParent();
|
|
|
|
ReturnBB->eraseFromParent();
|
2004-10-17 23:21:07 +00:00
|
|
|
} else if (!TheCall->use_empty()) {
|
|
|
|
// No returns, but something is using the return value of the call. Just
|
|
|
|
// nuke the result.
|
2009-07-30 23:03:37 +00:00
|
|
|
TheCall->replaceAllUsesWith(UndefValue::get(TheCall->getType()));
|
2004-02-04 02:51:48 +00:00
|
|
|
}
|
2005-04-21 23:48:37 +00:00
|
|
|
|
2004-02-04 02:51:48 +00:00
|
|
|
// Since we are now done with the Call/Invoke, we can delete it.
|
2004-10-17 23:21:07 +00:00
|
|
|
TheCall->eraseFromParent();
|
2003-05-29 15:11:31 +00:00
|
|
|
|
2014-05-15 20:11:28 +00:00
|
|
|
// If we inlined any musttail calls and the original return is now
|
|
|
|
// unreachable, delete it. It can only contain a bitcast and ret.
|
|
|
|
if (InlinedMustTailCalls && pred_begin(AfterCallBB) == pred_end(AfterCallBB))
|
|
|
|
AfterCallBB->eraseFromParent();
|
|
|
|
|
2003-08-24 04:06:56 +00:00
|
|
|
// We should always be able to fold the entry block of the function into the
|
|
|
|
// single predecessor of the block...
|
2004-04-16 05:17:59 +00:00
|
|
|
assert(cast<BranchInst>(Br)->isUnconditional() && "splitBasicBlock broken!");
|
2003-08-24 04:06:56 +00:00
|
|
|
BasicBlock *CalleeEntry = cast<BranchInst>(Br)->getSuccessor(0);
|
2004-02-04 04:17:06 +00:00
|
|
|
|
2004-04-16 05:17:59 +00:00
|
|
|
// Splice the code entry block into calling block, right before the
|
|
|
|
// unconditional branch.
|
2011-06-23 06:24:52 +00:00
|
|
|
CalleeEntry->replaceAllUsesWith(OrigBB); // Update PHI nodes
|
2011-06-23 09:09:15 +00:00
|
|
|
OrigBB->getInstList().splice(Br, CalleeEntry->getInstList());
|
2004-04-16 05:17:59 +00:00
|
|
|
|
|
|
|
// Remove the unconditional branch.
|
|
|
|
OrigBB->getInstList().erase(Br);
|
|
|
|
|
|
|
|
// Now we can remove the CalleeEntry block, which is now empty.
|
|
|
|
Caller->getBasicBlockList().erase(CalleeEntry);
|
2008-09-05 12:37:12 +00:00
|
|
|
|
2010-11-17 11:16:23 +00:00
|
|
|
// If we inserted a phi node, check to see if it has a single value (e.g. all
|
|
|
|
// the entries are the same or undef). If so, remove the PHI so it doesn't
|
|
|
|
// block other optimizations.
|
2012-01-31 01:01:16 +00:00
|
|
|
if (PHI) {
|
2014-02-18 15:33:12 +00:00
|
|
|
if (Value *V = SimplifyInstruction(PHI, IFI.DL)) {
|
2010-11-17 11:16:23 +00:00
|
|
|
PHI->replaceAllUsesWith(V);
|
|
|
|
PHI->eraseFromParent();
|
|
|
|
}
|
2012-01-31 01:01:16 +00:00
|
|
|
}
|
2010-11-17 11:16:23 +00:00
|
|
|
|
2003-05-29 15:11:31 +00:00
|
|
|
return true;
|
|
|
|
}
|