return Illegal;
if (!F && !IsIndirectCall)
return Illegal;
+ // Functions marked with the swifttailcc and tailcc calling conventions
+ // require special handling when outlining musttail functions. The
+ // calling convention must be passed down to the outlined function as
+ // well. Further, there is special handling for musttail calls as well,
+ // requiring a return call directly after. For now, the outliner does not
+ // support this, so we do not handle matching this case either.
+ if ((CI.getCallingConv() == CallingConv::SwiftTail ||
+ CI.getCallingConv() == CallingConv::Tail) &&
+ !EnableMustTailCalls)
+ return Illegal;
+ if (CI.isMustTailCall() && !EnableMustTailCalls)
+ return Illegal;
return Legal;
}
// TODO: We do not current handle similarity that changes the control flow.
// Flag that lets the classifier know whether we should allow intrinsics to
// be checked for similarity.
bool EnableIntrinsics = false;
+
+ // Flag that lets the classifier know whether we should allow tail calls to
+ // be checked for similarity.
+ bool EnableMustTailCalls = false;
};
/// Maps an Instruction to a member of InstrType.
IRSimilarityIdentifier(bool MatchBranches = true,
bool MatchIndirectCalls = true,
bool MatchCallsWithName = false,
- bool MatchIntrinsics = true)
+ bool MatchIntrinsics = true,
+ bool MatchMustTailCalls = true)
: Mapper(&InstDataAllocator, &InstDataListAllocator),
EnableBranches(MatchBranches), EnableIndirectCalls(MatchIndirectCalls),
EnableMatchingCallsByName(MatchCallsWithName),
- EnableIntrinsics(MatchIntrinsics) {}
+ EnableIntrinsics(MatchIntrinsics),
+ EnableMustTailCalls(MatchMustTailCalls) {}
private:
/// Map the instructions in the module to unsigned integers, using mapping
/// similarity.
bool EnableIntrinsics = true;
+ // The flag variable that marks whether we should allow tailcalls
+ // to be checked for similarity.
+ bool EnableMustTailCalls = false;
+
/// The SimilarityGroups found with the most recent run of \ref
/// findSimilarity. None if there is no recent run.
Optional<SimilarityGroupList> SimilarityCandidates;
struct OutlinableGroup;
namespace llvm {
+using namespace CallingConv;
using namespace IRSimilarity;
class Module;
// the call in outlined functions.
if (CI.canReturnTwice())
return false;
+ // TODO: Update the outliner to capture whether the outlined function
+ // needs these extra attributes.
+
+ // Functions marked with the swifttailcc and tailcc calling conventions
+ // require special handling when outlining musttail functions. The
+ // calling convention must be passed down to the outlined function as
+ // well. Further, there is special handling for musttail calls as well,
+ // requiring a return call directly after. For now, the outliner does not
+ // support this.
+ bool IsTailCC = CI.getCallingConv() == CallingConv::SwiftTail ||
+ CI.getCallingConv() == CallingConv::Tail;
+ if (IsTailCC && !EnableMustTailCalls)
+ return false;
+ if (CI.isMustTailCall() && !EnableMustTailCalls)
+ return false;
+ // The outliner can only handle musttail items if it is also accompanied
+ // by the tailcc or swifttailcc calling convention.
+ if (CI.isMustTailCall() && !IsTailCC)
+ return false;
return true;
}
// TODO: Handle FreezeInsts. Since a frozen value could be frozen inside
// The flag variable that marks whether we should allow intrinsics
// instructions to be outlined.
bool EnableIntrinsics = false;
+
+ // The flag variable that marks whether we should allow musttail calls.
+ bool EnableMustTailCalls = false;
};
/// A InstVisitor used to exclude certain instructions from being outlined.
Mapper.InstClassifier.EnableIndirectCalls = EnableIndirectCalls;
Mapper.EnableMatchCallsByName = EnableMatchingCallsByName;
Mapper.InstClassifier.EnableIntrinsics = EnableIntrinsics;
+ Mapper.InstClassifier.EnableMustTailCalls = EnableMustTailCalls;
populateMapper(Modules, InstrList, IntegerMapping);
findCandidates(InstrList, IntegerMapping);
Mapper.InstClassifier.EnableIndirectCalls = EnableIndirectCalls;
Mapper.EnableMatchCallsByName = EnableMatchingCallsByName;
Mapper.InstClassifier.EnableIntrinsics = EnableIntrinsics;
+ Mapper.InstClassifier.EnableMustTailCalls = EnableMustTailCalls;
std::vector<IRInstructionData *> InstrList;
std::vector<unsigned> IntegerMapping;
bool IRSimilarityIdentifierWrapperPass::doInitialization(Module &M) {
IRSI.reset(new IRSimilarityIdentifier(!DisableBranches, !DisableIndirectCalls,
- MatchCallsByName, !DisableIntrinsics));
+ MatchCallsByName, !DisableIntrinsics,
+ false));
return false;
}
IRSimilarityIdentifier IRSimilarityAnalysis::run(Module &M,
ModuleAnalysisManager &) {
auto IRSI = IRSimilarityIdentifier(!DisableBranches, !DisableIndirectCalls,
- MatchCallsByName, !DisableIntrinsics);
+ MatchCallsByName, !DisableIntrinsics,
+ false);
IRSI.findSimilarity(M);
return IRSI;
}
--- /dev/null
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --include-generated-funcs
+; RUN: opt -S -verify -iroutliner -ir-outlining-no-cost < %s | FileCheck %s
+
+; Check that we do not outline musttail when swifttaill cc or tailcc
+; is not present.
+
+declare void @musttail()
+
+define void @f1() {
+ %a = alloca i32, align 4
+ store i32 2, i32* %a, align 4
+ musttail call void @musttail()
+ ret void
+}
+
+define void @f2() {
+ %a = alloca i32, align 4
+ store i32 2, i32* %a, align 4
+ musttail call void @musttail()
+ ret void
+}
+; CHECK-LABEL: @f1(
+; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
+; CHECK-NEXT: store i32 2, i32* [[A]], align 4
+; CHECK-NEXT: musttail call void @musttail()
+; CHECK-NEXT: ret void
+;
+;
+; CHECK-LABEL: @f2(
+; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
+; CHECK-NEXT: store i32 2, i32* [[A]], align 4
+; CHECK-NEXT: musttail call void @musttail()
+; CHECK-NEXT: ret void
+;
--- /dev/null
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --include-generated-funcs
+; RUN: opt -S -verify -iroutliner -ir-outlining-no-cost < %s | FileCheck %s
+
+; Check that we do not outline musttail calls when swifttailcc is present.
+
+declare swifttailcc void @musttail()
+
+define swifttailcc void @f1() {
+ %a = alloca i32, align 4
+ store i32 2, i32* %a, align 4
+ musttail call swifttailcc void @musttail()
+ ret void
+}
+
+define swifttailcc void @f2() {
+ %a = alloca i32, align 4
+ store i32 2, i32* %a, align 4
+ musttail call swifttailcc void @musttail()
+ ret void
+}
+; CHECK-LABEL: @f1(
+; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
+; CHECK-NEXT: store i32 2, i32* [[A]], align 4
+; CHECK-NEXT: musttail call swifttailcc void @musttail()
+; CHECK-NEXT: ret void
+;
+;
+; CHECK-LABEL: @f2(
+; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
+; CHECK-NEXT: store i32 2, i32* [[A]], align 4
+; CHECK-NEXT: musttail call swifttailcc void @musttail()
+; CHECK-NEXT: ret void
+;
--- /dev/null
+; NOTE: Assertions have been autogenerated by utils/update_test_checks.py UTC_ARGS: --include-generated-funcs
+; RUN: opt -S -verify -iroutliner -ir-outlining-no-cost < %s | FileCheck %s
+
+; Check that we not do outline musttail calls when tailcc is present.
+
+declare tailcc void @musttail()
+
+define tailcc void @f1() {
+ %a = alloca i32, align 4
+ store i32 2, i32* %a, align 4
+ musttail call tailcc void @musttail()
+ ret void
+}
+
+define tailcc void @f2() {
+ %a = alloca i32, align 4
+ store i32 2, i32* %a, align 4
+ musttail call tailcc void @musttail()
+ ret void
+}
+; CHECK-LABEL: @f1(
+; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
+; CHECK-NEXT: store i32 2, i32* [[A]], align 4
+; CHECK-NEXT: musttail call tailcc void @musttail()
+; CHECK-NEXT: ret void
+;
+;
+; CHECK-LABEL: @f2(
+; CHECK-NEXT: [[A:%.*]] = alloca i32, align 4
+; CHECK-NEXT: store i32 2, i32* [[A]], align 4
+; CHECK-NEXT: musttail call tailcc void @musttail()
+; CHECK-NEXT: ret void
+;