Author: Nick Desaulniers Date: 2020-11-17T17:27:14-08:00 New Revision: f4c6080ab820219c5bf78b0c2143e7fa194da296
URL: https://github.com/llvm/llvm-project/commit/f4c6080ab820219c5bf78b0c2143e7fa194da296 DIFF: https://github.com/llvm/llvm-project/commit/f4c6080ab820219c5bf78b0c2143e7fa194da296.diff LOG: Revert "[IR] add fn attr for no_stack_protector; prevent inlining on mismatch" This reverts commit b7926ce6d7a83cdf70c68d82bc3389c04009b841. Going with a simpler approach. Added: Modified: clang/include/clang/Basic/AttrDocs.td clang/lib/CodeGen/CodeGenModule.cpp clang/test/CodeGen/stack-protector.c llvm/bindings/go/llvm/ir_test.go llvm/bindings/ocaml/llvm/llvm.ml llvm/docs/BitCodeFormat.rst llvm/docs/LangRef.rst llvm/include/llvm/Bitcode/LLVMBitCodes.h llvm/include/llvm/IR/Attributes.td llvm/lib/AsmParser/LLLexer.cpp llvm/lib/AsmParser/LLParser.cpp llvm/lib/AsmParser/LLToken.h llvm/lib/Bitcode/Writer/BitcodeWriter.cpp llvm/lib/CodeGen/StackProtector.cpp llvm/lib/IR/Attributes.cpp llvm/lib/IR/Verifier.cpp llvm/lib/Transforms/IPO/ForceFunctionAttrs.cpp llvm/lib/Transforms/Utils/CodeExtractor.cpp llvm/lib/Transforms/Utils/InlineFunction.cpp llvm/test/CodeGen/X86/stack-protector-2.ll llvm/test/Transforms/CodeExtractor/PartialInlineAttributes.ll llvm/test/Transforms/Inline/inline_ssp.ll llvm/utils/emacs/llvm-mode.el llvm/utils/kate/llvm.xml llvm/utils/llvm.grm llvm/utils/vim/syntax/llvm.vim llvm/utils/vscode/llvm/syntaxes/ll.tmLanguage.yaml Removed: clang/test/Frontend/optimization-remark-missed-inline-stack-protectors.c llvm/test/Transforms/Inline/inline_nossp.ll llvm/test/Verifier/function-attribute-nossp-ssp-sspreq-sspstrong.ll ################################################################################ diff --git a/clang/include/clang/Basic/AttrDocs.td b/clang/include/clang/Basic/AttrDocs.td index 085d2bac1dea..8e04ea84b240 100644 --- a/clang/include/clang/Basic/AttrDocs.td +++ b/clang/include/clang/Basic/AttrDocs.td @@ -3938,10 +3938,6 @@ option. int bar(int y); // bar can be built with the stack protector. -A callee that has a stack protector will not be inlined into a -``__attribute__((no_stack_protector))`` caller, and vice-versa, even if the -callee is marked ``__attribute__((always_inline))``. - }]; } diff --git a/clang/lib/CodeGen/CodeGenModule.cpp b/clang/lib/CodeGen/CodeGenModule.cpp index f50aaf3e34f9..1f81faaa2c6f 100644 --- a/clang/lib/CodeGen/CodeGenModule.cpp +++ b/clang/lib/CodeGen/CodeGenModule.cpp @@ -1642,14 +1642,14 @@ void CodeGenModule::SetLLVMFunctionAttributesForDefinition(const Decl *D, if (!hasUnwindExceptions(LangOpts)) B.addAttribute(llvm::Attribute::NoUnwind); - if (D && D->hasAttr<NoStackProtectorAttr>()) - B.addAttribute(llvm::Attribute::NoStackProtect); - else if (LangOpts.getStackProtector() == LangOptions::SSPOn) - B.addAttribute(llvm::Attribute::StackProtect); - else if (LangOpts.getStackProtector() == LangOptions::SSPStrong) - B.addAttribute(llvm::Attribute::StackProtectStrong); - else if (LangOpts.getStackProtector() == LangOptions::SSPReq) - B.addAttribute(llvm::Attribute::StackProtectReq); + if (!D || !D->hasAttr<NoStackProtectorAttr>()) { + if (LangOpts.getStackProtector() == LangOptions::SSPOn) + B.addAttribute(llvm::Attribute::StackProtect); + else if (LangOpts.getStackProtector() == LangOptions::SSPStrong) + B.addAttribute(llvm::Attribute::StackProtectStrong); + else if (LangOpts.getStackProtector() == LangOptions::SSPReq) + B.addAttribute(llvm::Attribute::StackProtectReq); + } if (!D) { // If we don't have a declaration to control inlining, the function isn't diff --git a/clang/test/CodeGen/stack-protector.c b/clang/test/CodeGen/stack-protector.c index 2c637c2318d3..5037a3e0d6fe 100644 --- a/clang/test/CodeGen/stack-protector.c +++ b/clang/test/CodeGen/stack-protector.c @@ -36,7 +36,7 @@ void test2(const char *msg) { // SSPREQ: attributes #[[A]] = {{.*}} sspreq // SAFESTACK-NOSSP: attributes #[[A]] = {{.*}} safestack -// SAFESTACK-NOSSP-NOT: attributes #[[A]] = {{.*}} ssp +// SAFESTACK-NOSSP-NOT: ssp // SAFESTACK-SSP: attributes #[[A]] = {{.*}} safestack ssp{{ }} // SAFESTACK-SSPSTRONG: attributes #[[A]] = {{.*}} safestack sspstrong @@ -47,11 +47,6 @@ void test2(const char *msg) { // SSPSTRONG-NOT: attributes #[[B]] = {{.*}} sspstrong // SSPREQ-NOT: attributes #[[B]] = {{.*}} sspreq -// NOSSP: attributes #[[B]] = {{.*}} nossp -// SSP: attributes #[[B]] = {{.*}} nossp -// SSPSTRONG: attributes #[[B]] = {{.*}} nossp -// SSPREQ: attributes #[[B]] = {{.*}} nossp - // SAFESTACK-SSP: attributes #[[B]] = {{.*}} safestack // SAFESTACK-SSP-NOT: attributes #[[B]] = {{.*}} safestack ssp{{ }} // SAFESTACK-SSPSTRONG: attributes #[[B]] = {{.*}} safestack diff --git a/clang/test/Frontend/optimization-remark-missed-inline-stack-protectors.c b/clang/test/Frontend/optimization-remark-missed-inline-stack-protectors.c deleted file mode 100644 index 5be3c5a2cd7d..000000000000 --- a/clang/test/Frontend/optimization-remark-missed-inline-stack-protectors.c +++ /dev/null @@ -1,34 +0,0 @@ -// RUN: %clang_cc1 -stack-protector 2 -Rpass-missed=inline -O2 -verify %s -emit-llvm-only - -void side_effect(void); - -void foo(void) { - side_effect(); -} - -// expected-remark@+3 {{foo will not be inlined into bar: stack protected callee but caller requested no stack protector}} -__attribute__((no_stack_protector)) -void bar(void) { - foo(); -} - -// expected-remark@+2 {{bar will not be inlined into baz: stack protected caller but callee requested no stack protector}} -void baz(void) { - bar(); -} - -void ssp_callee(void); - -// No issue; matching stack protections. -void ssp_caller(void) { - ssp_callee(); -} - -__attribute__((no_stack_protector)) -void nossp_callee(void); - -// No issue; matching stack protections. -__attribute__((no_stack_protector)) -void nossp_caller(void) { - nossp_callee(); -} diff --git a/llvm/bindings/go/llvm/ir_test.go b/llvm/bindings/go/llvm/ir_test.go index cdbe77b968a0..8533112ba99a 100644 --- a/llvm/bindings/go/llvm/ir_test.go +++ b/llvm/bindings/go/llvm/ir_test.go @@ -78,7 +78,6 @@ func TestAttributes(t *testing.T) { "returns_twice", "signext", "safestack", - "nossp", "ssp", "sspreq", "sspstrong", diff --git a/llvm/bindings/ocaml/llvm/llvm.ml b/llvm/bindings/ocaml/llvm/llvm.ml index 23210226e870..fdef6eb176d6 100644 --- a/llvm/bindings/ocaml/llvm/llvm.ml +++ b/llvm/bindings/ocaml/llvm/llvm.ml @@ -122,7 +122,6 @@ module Attribute = struct | Noinline | Alwaysinline | Optsize - | Nossp | Ssp | Sspreq | Alignment of int diff --git a/llvm/docs/BitCodeFormat.rst b/llvm/docs/BitCodeFormat.rst index 0b2a100c5821..cf2c6113e85d 100644 --- a/llvm/docs/BitCodeFormat.rst +++ b/llvm/docs/BitCodeFormat.rst @@ -1070,7 +1070,6 @@ The integer codes are mapped to well-known attributes as follows. * code 68: ``noundef`` * code 69: ``byref`` * code 70: ``mustprogress`` -* code 71: ``nossp`` .. note:: The ``allocsize`` attribute has a special encoding for its arguments. Its two diff --git a/llvm/docs/LangRef.rst b/llvm/docs/LangRef.rst index 2c5e456e6c2f..0a71ba1abf74 100644 --- a/llvm/docs/LangRef.rst +++ b/llvm/docs/LangRef.rst @@ -1825,22 +1825,6 @@ example: undefined behavior, the undefined behavior may be observed even if the call site is dead code. -``nossp`` - This attribute indicates the function should not emit a stack smashing - protector. This is useful for code that intentionally manipulates the stack - canary, such as operating system kernel code that must save/restore such - canary values on context switch. - - If a function with the ``nossp`` attribute calls a callee function that has - a stack protector function attribute, such as ``ssp``, ``sspreq``, or - ``sspstrong`` (or vice-versa), then the callee will not be inline - substituted into the caller. Even when the callee is ``alwaysinline``, the - above holds. - - Such inlining might break assumptions in the function that was built - without stack protection. This permits the functions that would have stack - protection to retain their stack protector. - ``ssp`` This attribute indicates that the function should emit a stack smashing protector. It is in the form of a "canary" --- a random value diff --git a/llvm/include/llvm/Bitcode/LLVMBitCodes.h b/llvm/include/llvm/Bitcode/LLVMBitCodes.h index 90e461ea0e5f..8abb20ced0c3 100644 --- a/llvm/include/llvm/Bitcode/LLVMBitCodes.h +++ b/llvm/include/llvm/Bitcode/LLVMBitCodes.h @@ -652,7 +652,6 @@ enum AttributeKindCodes { ATTR_KIND_NOUNDEF = 68, ATTR_KIND_BYREF = 69, ATTR_KIND_MUSTPROGRESS = 70, - ATTR_KIND_NO_STACK_PROTECT = 71, }; enum ComdatSelectionKindCodes { diff --git a/llvm/include/llvm/IR/Attributes.td b/llvm/include/llvm/IR/Attributes.td index b8e84d02ed7b..762f4d69b795 100644 --- a/llvm/include/llvm/IR/Attributes.td +++ b/llvm/include/llvm/IR/Attributes.td @@ -191,9 +191,6 @@ def StackAlignment : IntAttr<"alignstack">; /// Function can be speculated. def Speculatable : EnumAttr<"speculatable">; -/// Stack protection explicitly disabled. -def NoStackProtect : EnumAttr<"nossp">; - /// Stack protection. def StackProtect : EnumAttr<"ssp">; diff --git a/llvm/lib/AsmParser/LLLexer.cpp b/llvm/lib/AsmParser/LLLexer.cpp index 3e36a3293c42..4dbc3f25f150 100644 --- a/llvm/lib/AsmParser/LLLexer.cpp +++ b/llvm/lib/AsmParser/LLLexer.cpp @@ -679,7 +679,6 @@ lltok::Kind LLLexer::LexIdentifier() { KEYWORD(signext); KEYWORD(speculatable); KEYWORD(sret); - KEYWORD(nossp); KEYWORD(ssp); KEYWORD(sspreq); KEYWORD(sspstrong); diff --git a/llvm/lib/AsmParser/LLParser.cpp b/llvm/lib/AsmParser/LLParser.cpp index 617831484f3c..f3c97c10469b 100644 --- a/llvm/lib/AsmParser/LLParser.cpp +++ b/llvm/lib/AsmParser/LLParser.cpp @@ -1377,9 +1377,6 @@ bool LLParser::parseFnAttributeValuePairs(AttrBuilder &B, case lltok::kw_returns_twice: B.addAttribute(Attribute::ReturnsTwice); break; case lltok::kw_speculatable: B.addAttribute(Attribute::Speculatable); break; - case lltok::kw_nossp: - B.addAttribute(Attribute::NoStackProtect); - break; case lltok::kw_ssp: B.addAttribute(Attribute::StackProtect); break; case lltok::kw_sspreq: B.addAttribute(Attribute::StackProtectReq); break; case lltok::kw_sspstrong: @@ -1791,7 +1788,6 @@ bool LLParser::parseOptionalParamAttrs(AttrBuilder &B) { case lltok::kw_sanitize_memory: case lltok::kw_sanitize_thread: case lltok::kw_speculative_load_hardening: - case lltok::kw_nossp: case lltok::kw_ssp: case lltok::kw_sspreq: case lltok::kw_sspstrong: @@ -1900,7 +1896,6 @@ bool LLParser::parseOptionalReturnAttrs(AttrBuilder &B) { case lltok::kw_sanitize_memory: case lltok::kw_sanitize_thread: case lltok::kw_speculative_load_hardening: - case lltok::kw_nossp: case lltok::kw_ssp: case lltok::kw_sspreq: case lltok::kw_sspstrong: diff --git a/llvm/lib/AsmParser/LLToken.h b/llvm/lib/AsmParser/LLToken.h index df770b059296..02df4d0ad8b0 100644 --- a/llvm/lib/AsmParser/LLToken.h +++ b/llvm/lib/AsmParser/LLToken.h @@ -224,7 +224,6 @@ enum Kind { kw_returns_twice, kw_signext, kw_speculatable, - kw_nossp, kw_ssp, kw_sspreq, kw_sspstrong, diff --git a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp index 7dd38a13b0fc..2a921a7e2928 100644 --- a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp +++ b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp @@ -700,8 +700,6 @@ static uint64_t getAttrKindEncoding(Attribute::AttrKind Kind) { return bitc::ATTR_KIND_SPECULATABLE; case Attribute::StackAlignment: return bitc::ATTR_KIND_STACK_ALIGNMENT; - case Attribute::NoStackProtect: - return bitc::ATTR_KIND_NO_STACK_PROTECT; case Attribute::StackProtect: return bitc::ATTR_KIND_STACK_PROTECT; case Attribute::StackProtectReq: diff --git a/llvm/lib/CodeGen/StackProtector.cpp b/llvm/lib/CodeGen/StackProtector.cpp index 01536e2645f8..8074793bc627 100644 --- a/llvm/lib/CodeGen/StackProtector.cpp +++ b/llvm/lib/CodeGen/StackProtector.cpp @@ -270,15 +270,13 @@ static const CallInst *findStackProtectorIntrinsic(Function &F) { /// regardless of size, functions with any buffer regardless of type and size, /// functions with aggregates that contain any buffer regardless of type and /// size, and functions that contain stack-based variables that have had their -/// address taken. The heuristic will be disregarded for functions explicitly -/// marked nossp. +/// address taken. bool StackProtector::RequiresStackProtector() { bool Strong = false; bool NeedsProtector = false; HasPrologue = findStackProtectorIntrinsic(*F); - if (F->hasFnAttribute(Attribute::SafeStack) || - F->hasFnAttribute(Attribute::NoStackProtect)) + if (F->hasFnAttribute(Attribute::SafeStack)) return false; // We are constructing the OptimizationRemarkEmitter on the fly rather than diff --git a/llvm/lib/IR/Attributes.cpp b/llvm/lib/IR/Attributes.cpp index cc9b78e7380d..63384689074d 100644 --- a/llvm/lib/IR/Attributes.cpp +++ b/llvm/lib/IR/Attributes.cpp @@ -425,8 +425,6 @@ std::string Attribute::getAsString(bool InAttrGrp) const { return "speculative_load_hardening"; if (hasAttribute(Attribute::Speculatable)) return "speculatable"; - if (hasAttribute(Attribute::NoStackProtect)) - return "nossp"; if (hasAttribute(Attribute::StackProtect)) return "ssp"; if (hasAttribute(Attribute::StackProtectReq)) @@ -1941,17 +1939,9 @@ static void setOR(Function &Caller, const Function &Callee) { /// If the inlined function had a higher stack protection level than the /// calling function, then bump up the caller's stack protection level. static void adjustCallerSSPLevel(Function &Caller, const Function &Callee) { - assert(!(Callee.hasFnAttribute(Attribute::NoStackProtect) && - (Caller.hasFnAttribute(Attribute::StackProtect) || - Caller.hasFnAttribute(Attribute::StackProtectStrong) || - Caller.hasFnAttribute(Attribute::StackProtectReq))) && - "stack protected caller but callee requested no stack protector"); - assert(!(Caller.hasFnAttribute(Attribute::NoStackProtect) && - (Callee.hasFnAttribute(Attribute::StackProtect) || - Callee.hasFnAttribute(Attribute::StackProtectStrong) || - Callee.hasFnAttribute(Attribute::StackProtectReq))) && - "stack protected callee but caller requested no stack protector"); // If upgrading the SSP attribute, clear out the old SSP Attributes first. + // Having multiple SSP attributes doesn't actually hurt, but it adds useless + // clutter to the IR. AttrBuilder OldSSPAttr; OldSSPAttr.addAttribute(Attribute::StackProtect) .addAttribute(Attribute::StackProtectStrong) diff --git a/llvm/lib/IR/Verifier.cpp b/llvm/lib/IR/Verifier.cpp index 6c57369f8d80..737cbb910f10 100644 --- a/llvm/lib/IR/Verifier.cpp +++ b/llvm/lib/IR/Verifier.cpp @@ -1602,7 +1602,6 @@ static bool isFuncOnlyAttr(Attribute::AttrKind Kind) { case Attribute::NoInline: case Attribute::AlwaysInline: case Attribute::OptimizeForSize: - case Attribute::NoStackProtect: case Attribute::StackProtect: case Attribute::StackProtectReq: case Attribute::StackProtectStrong: @@ -1998,19 +1997,6 @@ void Verifier::verifyFunctionAttrs(FunctionType *FT, AttributeList Attrs, CheckFailed( "\"patchable-function-entry\" takes an unsigned integer: " + S, V); } - { - unsigned N = 0; - if (Attrs.hasFnAttribute(Attribute::NoStackProtect)) - ++N; - if (Attrs.hasFnAttribute(Attribute::StackProtect)) - ++N; - if (Attrs.hasFnAttribute(Attribute::StackProtectReq)) - ++N; - if (Attrs.hasFnAttribute(Attribute::StackProtectStrong)) - ++N; - Assert(N < 2, - "nossp, ssp, sspreq, sspstrong fn attrs are mutually exclusive", V); - } } void Verifier::verifyFunctionMetadata( diff --git a/llvm/lib/Transforms/IPO/ForceFunctionAttrs.cpp b/llvm/lib/Transforms/IPO/ForceFunctionAttrs.cpp index 108c832b71e4..1a8bb225a626 100644 --- a/llvm/lib/Transforms/IPO/ForceFunctionAttrs.cpp +++ b/llvm/lib/Transforms/IPO/ForceFunctionAttrs.cpp @@ -68,7 +68,6 @@ static Attribute::AttrKind parseAttrKind(StringRef Kind) { .Case("sanitize_thread", Attribute::SanitizeThread) .Case("sanitize_memtag", Attribute::SanitizeMemTag) .Case("speculative_load_hardening", Attribute::SpeculativeLoadHardening) - .Case("nossp", Attribute::NoStackProtect) .Case("ssp", Attribute::StackProtect) .Case("sspreq", Attribute::StackProtectReq) .Case("sspstrong", Attribute::StackProtectStrong) diff --git a/llvm/lib/Transforms/Utils/CodeExtractor.cpp b/llvm/lib/Transforms/Utils/CodeExtractor.cpp index dc3c6bd2ac3b..0be7ccf25704 100644 --- a/llvm/lib/Transforms/Utils/CodeExtractor.cpp +++ b/llvm/lib/Transforms/Utils/CodeExtractor.cpp @@ -965,7 +965,6 @@ Function *CodeExtractor::constructFunction(const ValueSet &inputs, case Attribute::SanitizeHWAddress: case Attribute::SanitizeMemTag: case Attribute::SpeculativeLoadHardening: - case Attribute::NoStackProtect: case Attribute::StackProtect: case Attribute::StackProtectReq: case Attribute::StackProtectStrong: diff --git a/llvm/lib/Transforms/Utils/InlineFunction.cpp b/llvm/lib/Transforms/Utils/InlineFunction.cpp index 54c58256986d..05e692915f2b 100644 --- a/llvm/lib/Transforms/Utils/InlineFunction.cpp +++ b/llvm/lib/Transforms/Utils/InlineFunction.cpp @@ -1667,22 +1667,6 @@ llvm::InlineResult llvm::InlineFunction(CallBase &CB, InlineFunctionInfo &IFI, return InlineResult::failure("incompatible GC"); } - // Inlining a function that explicitly should not have a stack protector may - // break the code if inlined into a function that does have a stack - // protector. - if (LLVM_UNLIKELY(Caller->hasFnAttribute(Attribute::NoStackProtect))) - if (CalledFunc->hasFnAttribute(Attribute::StackProtect) || - CalledFunc->hasFnAttribute(Attribute::StackProtectStrong) || - CalledFunc->hasFnAttribute(Attribute::StackProtectReq)) - return InlineResult::failure( - "stack protected callee but caller requested no stack protector"); - if (LLVM_UNLIKELY(CalledFunc->hasFnAttribute(Attribute::NoStackProtect))) - if (Caller->hasFnAttribute(Attribute::StackProtect) || - Caller->hasFnAttribute(Attribute::StackProtectStrong) || - Caller->hasFnAttribute(Attribute::StackProtectReq)) - return InlineResult::failure( - "stack protected caller but callee requested no stack protector"); - // Get the personality function from the callee if it contains a landing pad. Constant *CalledPersonality = CalledFunc->hasPersonalityFn() diff --git a/llvm/test/CodeGen/X86/stack-protector-2.ll b/llvm/test/CodeGen/X86/stack-protector-2.ll index ffa8fd13cbce..dc86b93cdcca 100644 --- a/llvm/test/CodeGen/X86/stack-protector-2.ll +++ b/llvm/test/CodeGen/X86/stack-protector-2.ll @@ -1,5 +1,5 @@ ; RUN: llc -mtriple=x86_64-pc-linux-gnu -start-before=stack-protector -stop-after=stack-protector -o - < %s | FileCheck %s -; Bugs 42238/43308/47479: Test some additional situations not caught previously. +; Bugs 42238/43308: Test some additional situations not caught previously. define void @store_captures() #0 { ; CHECK-LABEL: @store_captures( @@ -162,31 +162,4 @@ entry: declare void @llvm.memset.p0i8.i64(i8* nocapture writeonly, i8, i64, i1 immarg) - -; Test that the same function does not get a canary if nossp fn attr is set. -declare dso_local void @foo(i8*) - -define dso_local void @bar_sspstrong(i64 %0) #0 { -; CHECK-LABEL: @bar_sspstrong -; CHECK-NEXT: %StackGuardSlot = alloca i8* - %2 = alloca i64, align 8 - store i64 %0, i64* %2, align 8 - %3 = load i64, i64* %2, align 8 - %4 = alloca i8, i64 %3, align 16 - call void @foo(i8* %4) - ret void -} - -define dso_local void @bar_nossp(i64 %0) #1 { -; CHECK-LABEL: @bar_nossp -; CHECK-NEXT: %2 = alloca i64 - %2 = alloca i64, align 8 - store i64 %0, i64* %2, align 8 - %3 = load i64, i64* %2, align 8 - %4 = alloca i8, i64 %3, align 16 - call void @foo(i8* %4) - ret void -} - attributes #0 = { sspstrong } -attributes #1 = { nossp } diff --git a/llvm/test/Transforms/CodeExtractor/PartialInlineAttributes.ll b/llvm/test/Transforms/CodeExtractor/PartialInlineAttributes.ll index 7636b8cfb7cd..18c934bc6a1a 100644 --- a/llvm/test/Transforms/CodeExtractor/PartialInlineAttributes.ll +++ b/llvm/test/Transforms/CodeExtractor/PartialInlineAttributes.ll @@ -73,10 +73,10 @@ entry: attributes #0 = { inlinehint minsize noduplicate noimplicitfloat norecurse noredzone nounwind nonlazybind optsize safestack sanitize_address sanitize_hwaddress sanitize_memory - sanitize_thread sspstrong strictfp uwtable "foo"="bar" + sanitize_thread ssp sspreq sspstrong strictfp uwtable "foo"="bar" "patchable-function"="prologue-short-redirect" "probe-stack"="_foo_guard" "stack-probe-size"="4096" } -; CHECK: attributes [[FN_ATTRS]] = { inlinehint minsize noduplicate noimplicitfloat norecurse noredzone nounwind nonlazybind optsize safestack sanitize_address sanitize_hwaddress sanitize_memory sanitize_thread sspstrong strictfp uwtable "foo"="bar" "patchable-function"="prologue-short-redirect" "probe-stack"="_foo_guard" "stack-probe-size"="4096" } +; CHECK: attributes [[FN_ATTRS]] = { inlinehint minsize noduplicate noimplicitfloat norecurse noredzone nounwind nonlazybind optsize safestack sanitize_address sanitize_hwaddress sanitize_memory sanitize_thread ssp sspreq sspstrong strictfp uwtable "foo"="bar" "patchable-function"="prologue-short-redirect" "probe-stack"="_foo_guard" "stack-probe-size"="4096" } ; attributes to drop attributes #1 = { diff --git a/llvm/test/Transforms/Inline/inline_nossp.ll b/llvm/test/Transforms/Inline/inline_nossp.ll deleted file mode 100644 index 52987e740da5..000000000000 --- a/llvm/test/Transforms/Inline/inline_nossp.ll +++ /dev/null @@ -1,64 +0,0 @@ -; RUN: opt -inline -o - -S %s | FileCheck %s -; RUN: opt -passes='cgscc(inline)' %s -S | FileCheck %s -; RUN: opt -always-inline -o - -S %s | FileCheck %s - -declare dso_local void @foo(i8*) - -define dso_local void @ssp(i64 %0) #0 { - %2 = alloca i64, align 8 - store i64 %0, i64* %2, align 8 - %3 = load i64, i64* %2, align 8 - %4 = alloca i8, i64 %3, align 16 - call void @foo(i8* %4) - ret void -} - -define dso_local void @ssp_alwaysinline(i64 %0) #1 { - %2 = alloca i64, align 8 - store i64 %0, i64* %2, align 8 - %3 = load i64, i64* %2, align 8 - %4 = alloca i8, i64 %3, align 16 - call void @foo(i8* %4) - ret void -} - -define dso_local void @nossp() #2 { -; Check that the calls to @ssp and @ssp_alwaysinline are not inlined into -; @nossp, since @nossp does not want a stack protector. -; CHECK-LABEL: @nossp -; CHECK-NEXT: call void @ssp -; CHECK-NEXT: call void @ssp_alwaysinline - call void @ssp(i64 1024) - call void @ssp_alwaysinline(i64 1024) - ret void -} - -define dso_local void @nossp_alwaysinline() #3 { - call void @ssp(i64 1024) - call void @ssp_alwaysinline(i64 1024) - ret void -} - -define dso_local void @nossp_caller() #2 { -; Permit nossp callee to be inlined into nossp caller. -; CHECK-LABEL: @nossp_caller -; CHECK-NEXT: call void @ssp -; CHECK-NEXT: call void @ssp_alwaysinline -; CHECK-NOT: call void @nossp_alwaysinline - call void @nossp_alwaysinline() - ret void -} - -define dso_local void @ssp2() #0 { -; Check the call to @nossp is not inlined, since @nossp should not have a stack -; protector. -; CHECK-LABEL: @ssp2 -; CHECK-NEXT: call void @nossp - call void @nossp() - ret void -} - -attributes #0 = { sspstrong } -attributes #1 = { sspstrong alwaysinline } -attributes #2 = { nossp } -attributes #3 = { nossp alwaysinline} diff --git a/llvm/test/Transforms/Inline/inline_ssp.ll b/llvm/test/Transforms/Inline/inline_ssp.ll index df59b33e4fdc..bad332dbff0a 100644 --- a/llvm/test/Transforms/Inline/inline_ssp.ll +++ b/llvm/test/Transforms/Inline/inline_ssp.ll @@ -1,10 +1,6 @@ ; RUN: opt -inline %s -S | FileCheck %s ; RUN: opt -passes='cgscc(inline)' %s -S | FileCheck %s ; Ensure SSP attributes are propagated correctly when inlining. -; This test case covers callers that are unspecified in their level of stack -; protection. See also llvm/test/Transforms/Inline/inline_nossp.ll -; which tests callers with ``nossp`` function attribute which is stack -; protection explicitly disabled. @.str = private unnamed_addr constant [11 x i8] c"fun_nossp\0A\00", align 1 @.str1 = private unnamed_addr constant [9 x i8] c"fun_ssp\0A\00", align 1 diff --git a/llvm/test/Verifier/function-attribute-nossp-ssp-sspreq-sspstrong.ll b/llvm/test/Verifier/function-attribute-nossp-ssp-sspreq-sspstrong.ll deleted file mode 100644 index 80074c427d78..000000000000 --- a/llvm/test/Verifier/function-attribute-nossp-ssp-sspreq-sspstrong.ll +++ /dev/null @@ -1,58 +0,0 @@ -; RUN: not opt -verify -o - %s 2>&1 | FileCheck %s -define void @test_1 () #1 { ret void } -define void @test_2 () #2 { ret void } -define void @test_3 () #3 { ret void } -define void @test_4 () #4 { ret void } -define void @test_5 () #5 { ret void } -define void @test_6 () #6 { ret void } -define void @test_7 () #7 { ret void } -define void @test_8 () #8 { ret void } -define void @test_9 () #9 { ret void } -define void @test_10 () #10 { ret void } -define void @test_11 () #10 { ret void } -define void @test_12 () #10 { ret void } -define void @test_13 () #10 { ret void } -define void @test_14 () #10 { ret void } - -attributes #0 = { nossp } -attributes #1 = { ssp } -attributes #2 = { sspreq } -attributes #3 = { sspstrong } - -attributes #4 = { nossp ssp } -attributes #5 = { nossp sspreq } -attributes #6 = { nossp sspstrong } - -attributes #7 = { ssp sspreq } -attributes #8 = { ssp sspstrong } - -attributes #9 = { sspreq sspstrong } - -attributes #10 = { nossp ssp sspreq } -attributes #11 = { nossp ssp sspstrong } -attributes #12 = { nossp sspreq sspstrong } -attributes #13 = { ssp sspreq sspstrong } -attributes #14 = { nossp ssp sspreq sspstrong } - -; CHECK: fn attrs are mutually exclusive -; CHECK-NEXT: void ()* @test_4 -; CHECK: fn attrs are mutually exclusive -; CHECK-NEXT: void ()* @test_5 -; CHECK: fn attrs are mutually exclusive -; CHECK-NEXT: void ()* @test_6 -; CHECK: fn attrs are mutually exclusive -; CHECK-NEXT: void ()* @test_7 -; CHECK: fn attrs are mutually exclusive -; CHECK-NEXT: void ()* @test_8 -; CHECK: fn attrs are mutually exclusive -; CHECK-NEXT: void ()* @test_9 -; CHECK: fn attrs are mutually exclusive -; CHECK-NEXT: void ()* @test_10 -; CHECK: fn attrs are mutually exclusive -; CHECK-NEXT: void ()* @test_11 -; CHECK: fn attrs are mutually exclusive -; CHECK-NEXT: void ()* @test_12 -; CHECK: fn attrs are mutually exclusive -; CHECK-NEXT: void ()* @test_13 -; CHECK: fn attrs are mutually exclusive -; CHECK-NEXT: void ()* @test_14 diff --git a/llvm/utils/emacs/llvm-mode.el b/llvm/utils/emacs/llvm-mode.el index 801b00c15247..bc24b12fb01f 100644 --- a/llvm/utils/emacs/llvm-mode.el +++ b/llvm/utils/emacs/llvm-mode.el @@ -26,7 +26,7 @@ "inaccessiblemem_or_argmemonly" "inlinehint" "jumptable" "minsize" "mustprogress" "naked" "nobuiltin" "noduplicate" "nofree" "noimplicitfloat" "noinline" "nonlazybind" "noredzone" "noreturn" "norecurse" "noundef" "nounwind" "optnone" "optsize" "readnone" "readonly" "returns_twice" - "speculatable" "nossp" "ssp" "sspreq" "sspstrong" "safestack" "sanitize_address" "sanitize_hwaddress" "sanitize_memtag" + "speculatable" "ssp" "sspreq" "sspstrong" "safestack" "sanitize_address" "sanitize_hwaddress" "sanitize_memtag" "sanitize_thread" "sanitize_memory" "strictfp" "uwtable" "willreturn" "writeonly" "immarg") 'symbols) . font-lock-constant-face) ;; Variables '("%[-a-zA-Z$._][-a-zA-Z$._0-9]*" . font-lock-variable-name-face) diff --git a/llvm/utils/kate/llvm.xml b/llvm/utils/kate/llvm.xml index 36e43c2d3749..5132aaf6fba5 100644 --- a/llvm/utils/kate/llvm.xml +++ b/llvm/utils/kate/llvm.xml @@ -93,7 +93,6 @@ <item> optsize </item> <item> readnone </item> <item> readonly </item> - <item> nossp </item> <item> ssp </item> <item> sspreq </item> <item> sspstrong </item> diff --git a/llvm/utils/llvm.grm b/llvm/utils/llvm.grm index b4dc5fd86526..398c04d9b6da 100644 --- a/llvm/utils/llvm.grm +++ b/llvm/utils/llvm.grm @@ -168,7 +168,6 @@ FuncAttr ::= noreturn | noinline | alwaysinline | optsize - | nossp | ssp | sspreq | returns_twice diff --git a/llvm/utils/vim/syntax/llvm.vim b/llvm/utils/vim/syntax/llvm.vim index 1e60ba7f480c..0914f6de3829 100644 --- a/llvm/utils/vim/syntax/llvm.vim +++ b/llvm/utils/vim/syntax/llvm.vim @@ -148,7 +148,6 @@ syn keyword llvmKeyword \ spir_func \ spir_kernel \ sret - \ nossp \ ssp \ sspreq \ sspstrong diff --git a/llvm/utils/vscode/llvm/syntaxes/ll.tmLanguage.yaml b/llvm/utils/vscode/llvm/syntaxes/ll.tmLanguage.yaml index 1733796b6e67..49c2dacd4c9e 100644 --- a/llvm/utils/vscode/llvm/syntaxes/ll.tmLanguage.yaml +++ b/llvm/utils/vscode/llvm/syntaxes/ll.tmLanguage.yaml @@ -245,7 +245,6 @@ patterns: \\bspir_func\\b|\ \\bspir_kernel\\b|\ \\bsret\\b|\ - \\bnossp\\b|\ \\bssp\\b|\ \\bsspreq\\b|\ \\bsspstrong\\b|\ _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits
