From 35d21021337fc3dba82155c7232c2c5277b73883 Mon Sep 17 00:00:00 2001 From: Evgeniy Stepanov Date: Thu, 8 Aug 2013 08:22:39 +0000 Subject: Disable inlining between sanitized and non-sanitized functions. Inlining between functions with different values of sanitize_* attributes leads to over- or under-sanitizing, which is always bad. git-svn-id: https://llvm.org/svn/llvm-project/llvm/trunk@187967 91177308-0d34-0410-b5e6-96231b3b80d8 --- lib/Analysis/IPA/InlineCost.cpp | 28 +++++++-- test/Transforms/Inline/attributes.ll | 112 +++++++++++++++++++++++++++++++++++ 2 files changed, 135 insertions(+), 5 deletions(-) create mode 100644 test/Transforms/Inline/attributes.ll diff --git a/lib/Analysis/IPA/InlineCost.cpp b/lib/Analysis/IPA/InlineCost.cpp index 37d73a80f7..89dcd819ee 100644 --- a/lib/Analysis/IPA/InlineCost.cpp +++ b/lib/Analysis/IPA/InlineCost.cpp @@ -1171,6 +1171,22 @@ InlineCost InlineCostAnalysis::getInlineCost(CallSite CS, int Threshold) { return getInlineCost(CS, CS.getCalledFunction(), Threshold); } +/// \brief Test that two functions either have or have not the given attribute +/// at the same time. +static bool attributeMatches(Function *F1, Function *F2, + Attribute::AttrKind Attr) { + return F1->hasFnAttribute(Attr) == F2->hasFnAttribute(Attr); +} + +/// \brief Test that there are no attribute conflicts between Caller and Callee +/// that prevent inlining. +static bool functionsHaveCompatibleAttributes(Function *Caller, + Function *Callee) { + return attributeMatches(Caller, Callee, Attribute::SanitizeAddress) && + attributeMatches(Caller, Callee, Attribute::SanitizeMemory) && + attributeMatches(Caller, Callee, Attribute::SanitizeThread); +} + InlineCost InlineCostAnalysis::getInlineCost(CallSite CS, Function *Callee, int Threshold) { // Cannot inline indirect calls. @@ -1179,20 +1195,22 @@ InlineCost InlineCostAnalysis::getInlineCost(CallSite CS, Function *Callee, // Calls to functions with always-inline attributes should be inlined // whenever possible. - if (Callee->getAttributes().hasAttribute(AttributeSet::FunctionIndex, - Attribute::AlwaysInline)) { + if (Callee->hasFnAttribute(Attribute::AlwaysInline)) { if (isInlineViable(*Callee)) return llvm::InlineCost::getAlways(); return llvm::InlineCost::getNever(); } + // Never inline functions with conflicting attributes (unless callee has + // always-inline attribute). + if (!functionsHaveCompatibleAttributes(CS.getCaller(), Callee)) + return llvm::InlineCost::getNever(); + // Don't inline functions which can be redefined at link-time to mean // something else. Don't inline functions marked noinline or call sites // marked noinline. if (Callee->mayBeOverridden() || - Callee->getAttributes().hasAttribute(AttributeSet::FunctionIndex, - Attribute::NoInline) || - CS.isNoInline()) + Callee->hasFnAttribute(Attribute::NoInline) || CS.isNoInline()) return llvm::InlineCost::getNever(); DEBUG(llvm::dbgs() << " Analyzing call of " << Callee->getName() diff --git a/test/Transforms/Inline/attributes.ll b/test/Transforms/Inline/attributes.ll new file mode 100644 index 0000000000..53fb13f2ba --- /dev/null +++ b/test/Transforms/Inline/attributes.ll @@ -0,0 +1,112 @@ +; RUN: opt < %s -inline -S | FileCheck %s +target datalayout = "E-p:64:64:64-a0:0:8-f32:32:32-f64:64:64-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:32:64-v64:64:64-v128:128:128" + +define i32 @noattr_callee(i32 %i) { + ret i32 %i +} + +define i32 @sanitize_address_callee(i32 %i) sanitize_address { + ret i32 %i +} + +define i32 @sanitize_thread_callee(i32 %i) sanitize_thread { + ret i32 %i +} + +define i32 @sanitize_memory_callee(i32 %i) sanitize_memory { + ret i32 %i +} + +define i32 @alwaysinline_callee(i32 %i) alwaysinline { + ret i32 %i +} + +define i32 @alwaysinline_sanitize_address_callee(i32 %i) alwaysinline sanitize_address { + ret i32 %i +} + +define i32 @alwaysinline_sanitize_thread_callee(i32 %i) alwaysinline sanitize_thread { + ret i32 %i +} + +define i32 @alwaysinline_sanitize_memory_callee(i32 %i) alwaysinline sanitize_memory { + ret i32 %i +} + + +; Check that: +; * noattr callee is inlined into noattr caller, +; * sanitize_(address|memory|thread) callee is not inlined into noattr caller, +; * alwaysinline callee is always inlined no matter what sanitize_* attributes are present. + +define i32 @test_no_sanitize_address(i32 %arg) { + %x1 = call i32 @noattr_callee(i32 %arg) + %x2 = call i32 @sanitize_address_callee(i32 %x1) + %x3 = call i32 @alwaysinline_callee(i32 %x2) + %x4 = call i32 @alwaysinline_sanitize_address_callee(i32 %x3) + ret i32 %x4 +; CHECK-LABEL: @test_no_sanitize_address( +; CHECK-NEXT: @sanitize_address_callee +; CHECK-NEXT: ret i32 +} + +define i32 @test_no_sanitize_memory(i32 %arg) { + %x1 = call i32 @noattr_callee(i32 %arg) + %x2 = call i32 @sanitize_memory_callee(i32 %x1) + %x3 = call i32 @alwaysinline_callee(i32 %x2) + %x4 = call i32 @alwaysinline_sanitize_memory_callee(i32 %x3) + ret i32 %x4 +; CHECK-LABEL: @test_no_sanitize_memory( +; CHECK-NEXT: @sanitize_memory_callee +; CHECK-NEXT: ret i32 +} + +define i32 @test_no_sanitize_thread(i32 %arg) { + %x1 = call i32 @noattr_callee(i32 %arg) + %x2 = call i32 @sanitize_thread_callee(i32 %x1) + %x3 = call i32 @alwaysinline_callee(i32 %x2) + %x4 = call i32 @alwaysinline_sanitize_thread_callee(i32 %x3) + ret i32 %x4 +; CHECK-LABEL: @test_no_sanitize_thread( +; CHECK-NEXT: @sanitize_thread_callee +; CHECK-NEXT: ret i32 +} + + +; Check that: +; * noattr callee is not inlined into sanitize_(address|memory|thread) caller, +; * sanitize_(address|memory|thread) callee is inlined into the caller with the same attribute, +; * alwaysinline callee is always inlined no matter what sanitize_* attributes are present. + +define i32 @test_sanitize_address(i32 %arg) sanitize_address { + %x1 = call i32 @noattr_callee(i32 %arg) + %x2 = call i32 @sanitize_address_callee(i32 %x1) + %x3 = call i32 @alwaysinline_callee(i32 %x2) + %x4 = call i32 @alwaysinline_sanitize_address_callee(i32 %x3) + ret i32 %x4 +; CHECK-LABEL: @test_sanitize_address( +; CHECK-NEXT: @noattr_callee +; CHECK-NEXT: ret i32 +} + +define i32 @test_sanitize_memory(i32 %arg) sanitize_memory { + %x1 = call i32 @noattr_callee(i32 %arg) + %x2 = call i32 @sanitize_memory_callee(i32 %x1) + %x3 = call i32 @alwaysinline_callee(i32 %x2) + %x4 = call i32 @alwaysinline_sanitize_memory_callee(i32 %x3) + ret i32 %x4 +; CHECK-LABEL: @test_sanitize_memory( +; CHECK-NEXT: @noattr_callee +; CHECK-NEXT: ret i32 +} + +define i32 @test_sanitize_thread(i32 %arg) sanitize_thread { + %x1 = call i32 @noattr_callee(i32 %arg) + %x2 = call i32 @sanitize_thread_callee(i32 %x1) + %x3 = call i32 @alwaysinline_callee(i32 %x2) + %x4 = call i32 @alwaysinline_sanitize_thread_callee(i32 %x3) + ret i32 %x4 +; CHECK-LABEL: @test_sanitize_thread( +; CHECK-NEXT: @noattr_callee +; CHECK-NEXT: ret i32 +} -- cgit v1.2.3