Author: Marco Elver Date: 2021-05-25T12:57:14+02:00 New Revision: 280333021e9550d80f5c1152a34e33e81df1e178
URL: https://github.com/llvm/llvm-project/commit/280333021e9550d80f5c1152a34e33e81df1e178 DIFF: https://github.com/llvm/llvm-project/commit/280333021e9550d80f5c1152a34e33e81df1e178.diff LOG: [SanitizeCoverage] Add support for NoSanitizeCoverage function attribute We really ought to support no_sanitize("coverage") in line with other sanitizers. This came up again in discussions on the Linux-kernel mailing lists, because we currently do workarounds using objtool to remove coverage instrumentation. Since that support is only on x86, to continue support coverage instrumentation on other architectures, we must support selectively disabling coverage instrumentation via function attributes. Unfortunately, for SanitizeCoverage, it has not been implemented as a sanitizer via fsanitize= and associated options in Sanitizers.def, but rolls its own option fsanitize-coverage. This meant that we never got "automatic" no_sanitize attribute support. Implement no_sanitize attribute support by special-casing the string "coverage" in the NoSanitizeAttr implementation. To keep the feature as unintrusive to existing IR generation as possible, define a new negative function attribute NoSanitizeCoverage to propagate the information through to the instrumentation pass. Fixes: https://bugs.llvm.org/show_bug.cgi?id=49035 Reviewed By: vitalybuka, morehouse Differential Revision: https://reviews.llvm.org/D102772 Added: Modified: clang/docs/SanitizerCoverage.rst clang/include/clang/Basic/Attr.td clang/include/clang/Basic/AttrDocs.td clang/lib/CodeGen/CodeGenFunction.cpp clang/lib/Sema/SemaDeclAttr.cpp clang/test/CodeGen/sanitize-coverage.c llvm/bindings/go/llvm/ir_test.go llvm/docs/BitCodeFormat.rst llvm/docs/LangRef.rst llvm/include/llvm/AsmParser/LLToken.h llvm/include/llvm/Bitcode/LLVMBitCodes.h llvm/include/llvm/IR/Attributes.td llvm/lib/AsmParser/LLLexer.cpp llvm/lib/AsmParser/LLParser.cpp llvm/lib/Bitcode/Reader/BitcodeReader.cpp llvm/lib/Bitcode/Writer/BitcodeWriter.cpp llvm/lib/IR/Attributes.cpp llvm/lib/IR/Verifier.cpp llvm/lib/Transforms/IPO/ForceFunctionAttrs.cpp llvm/lib/Transforms/Instrumentation/SanitizerCoverage.cpp llvm/lib/Transforms/Utils/CodeExtractor.cpp llvm/test/Bitcode/attributes.ll llvm/test/Bitcode/compatibility.ll llvm/utils/emacs/llvm-mode.el llvm/utils/llvm.grm llvm/utils/vim/syntax/llvm.vim llvm/utils/vscode/llvm/syntaxes/ll.tmLanguage.yaml Removed: ################################################################################ diff --git a/clang/docs/SanitizerCoverage.rst b/clang/docs/SanitizerCoverage.rst index 485a73d273aed..b0bb9823eb043 100644 --- a/clang/docs/SanitizerCoverage.rst +++ b/clang/docs/SanitizerCoverage.rst @@ -312,11 +312,17 @@ will not be instrumented. // for every non-constant array index. void __sanitizer_cov_trace_gep(uintptr_t Idx); -Partially disabling instrumentation -=================================== +Disabling instrumentation with ``__attribute__((no_sanitize("coverage")))`` +=========================================================================== + +It is possible to disable coverage instrumentation for select functions via the +function attribute ``__attribute__((no_sanitize("coverage")))``. + +Disabling instrumentation without source modification +===================================================== It is sometimes useful to tell SanitizerCoverage to instrument only a subset of the -functions in your target. +functions in your target without modifying source files. With ``-fsanitize-coverage-allowlist=allowlist.txt`` and ``-fsanitize-coverage-blocklist=blocklist.txt``, you can specify such a subset through the combination of an allowlist and a blocklist. diff --git a/clang/include/clang/Basic/Attr.td b/clang/include/clang/Basic/Attr.td index 5e04f32187cd2..6a39453153930 100644 --- a/clang/include/clang/Basic/Attr.td +++ b/clang/include/clang/Basic/Attr.td @@ -2897,6 +2897,10 @@ def NoSanitize : InheritableAttr { } return Mask; } + + bool hasCoverage() const { + return llvm::is_contained(sanitizers(), "coverage"); + } }]; } diff --git a/clang/include/clang/Basic/AttrDocs.td b/clang/include/clang/Basic/AttrDocs.td index cae9cec804ce9..e9ee45d91dc50 100644 --- a/clang/include/clang/Basic/AttrDocs.td +++ b/clang/include/clang/Basic/AttrDocs.td @@ -2564,12 +2564,17 @@ def NoSanitizeDocs : Documentation { let Content = [{ Use the ``no_sanitize`` attribute on a function or a global variable declaration to specify that a particular instrumentation or set of -instrumentations should not be applied. The attribute takes a list of -string literals, which have the same meaning as values accepted by the -``-fno-sanitize=`` flag. For example, -``__attribute__((no_sanitize("address", "thread")))`` specifies that -AddressSanitizer and ThreadSanitizer should not be applied to the -function or variable. +instrumentations should not be applied. + +The attribute takes a list of string literals with the following accepted +values: +* all values accepted by ``-fno-sanitize=``; +* ``coverage``, to disable SanitizerCoverage instrumentation. + +For example, ``__attribute__((no_sanitize("address", "thread")))`` specifies +that AddressSanitizer and ThreadSanitizer should not be applied to the function +or variable. Using ``__attribute__((no_sanitize("coverage")))`` specifies that +SanitizerCoverage should not be applied to the function. See :ref:`Controlling Code Generation <controlling-code-generation>` for a full list of supported sanitizer flags. diff --git a/clang/lib/CodeGen/CodeGenFunction.cpp b/clang/lib/CodeGen/CodeGenFunction.cpp index d4f046442ed85..518305e1113cd 100644 --- a/clang/lib/CodeGen/CodeGenFunction.cpp +++ b/clang/lib/CodeGen/CodeGenFunction.cpp @@ -734,8 +734,10 @@ void CodeGenFunction::StartFunction(GlobalDecl GD, QualType RetTy, } while (0); if (D) { - // Apply the no_sanitize* attributes to SanOpts. + bool NoSanitizeCoverage = false; + for (auto Attr : D->specific_attrs<NoSanitizeAttr>()) { + // Apply the no_sanitize* attributes to SanOpts. SanitizerMask mask = Attr->getMask(); SanOpts.Mask &= ~mask; if (mask & SanitizerKind::Address) @@ -746,7 +748,14 @@ void CodeGenFunction::StartFunction(GlobalDecl GD, QualType RetTy, SanOpts.set(SanitizerKind::KernelHWAddress, false); if (mask & SanitizerKind::KernelHWAddress) SanOpts.set(SanitizerKind::HWAddress, false); + + // SanitizeCoverage is not handled by SanOpts. + if (Attr->hasCoverage()) + NoSanitizeCoverage = true; } + + if (NoSanitizeCoverage && CGM.getCodeGenOpts().hasSanitizeCoverage()) + Fn->addFnAttr(llvm::Attribute::NoSanitizeCoverage); } // Apply sanitizer attributes to the function. diff --git a/clang/lib/Sema/SemaDeclAttr.cpp b/clang/lib/Sema/SemaDeclAttr.cpp index ea1930ea47d67..37f780f728d34 100644 --- a/clang/lib/Sema/SemaDeclAttr.cpp +++ b/clang/lib/Sema/SemaDeclAttr.cpp @@ -7290,7 +7290,8 @@ static void handleNoSanitizeAttr(Sema &S, Decl *D, const ParsedAttr &AL) { return; if (parseSanitizerValue(SanitizerName, /*AllowGroups=*/true) == - SanitizerMask()) + SanitizerMask() && + SanitizerName != "coverage") S.Diag(LiteralLoc, diag::warn_unknown_sanitizer_ignored) << SanitizerName; else if (isGlobalVar(D) && SanitizerName != "address") S.Diag(D->getLocation(), diag::err_attribute_wrong_decl_type) diff --git a/clang/test/CodeGen/sanitize-coverage.c b/clang/test/CodeGen/sanitize-coverage.c index b3e44e28cbce9..6fd0adcb4a880 100644 --- a/clang/test/CodeGen/sanitize-coverage.c +++ b/clang/test/CodeGen/sanitize-coverage.c @@ -31,4 +31,59 @@ void test_always_inline(int n) { always_inlined_fn(n); } +// CHECK-LABEL: define dso_local void @test_no_sanitize_coverage( +__attribute__((no_sanitize("coverage"))) void test_no_sanitize_coverage(int n) { + // CHECK-NOT: call void @__sanitizer_cov_trace_pc + // CHECK-NOT: call void @__sanitizer_cov_trace_const_cmp + // ASAN-DAG: call void @__asan_report_store + // MSAN-DAG: call void @__msan_warning + // BOUNDS-DAG: call void @__ubsan_handle_out_of_bounds + // TSAN-DAG: call void @__tsan_func_entry + // UBSAN-DAG: call void @__ubsan_handle + if (n) + x[n] = 42; +} + + +// CHECK-LABEL: define dso_local void @test_no_sanitize_combined( +__attribute__((no_sanitize("address", "memory", "thread", "bounds", "undefined", "coverage"))) +void test_no_sanitize_combined(int n) { + // CHECK-NOT: call void @__sanitizer_cov_trace_pc + // CHECK-NOT: call void @__sanitizer_cov_trace_const_cmp + // ASAN-NOT: call void @__asan_report_store + // MSAN-NOT: call void @__msan_warning + // BOUNDS-NOT: call void @__ubsan_handle_out_of_bounds + // TSAN-NOT: call void @__tsan_func_entry + // UBSAN-NOT: call void @__ubsan_handle + if (n) + x[n] = 42; +} + +// CHECK-LABEL: define dso_local void @test_no_sanitize_separate( +__attribute__((no_sanitize("address"))) +__attribute__((no_sanitize("memory"))) +__attribute__((no_sanitize("thread"))) +__attribute__((no_sanitize("bounds"))) +__attribute__((no_sanitize("undefined"))) +__attribute__((no_sanitize("coverage"))) +void test_no_sanitize_separate(int n) { + // CHECK-NOT: call void @__sanitizer_cov_trace_pc + // CHECK-NOT: call void @__sanitizer_cov_trace_const_cmp + // ASAN-NOT: call void @__asan_report_store + // MSAN-NOT: call void @__msan_warning + // BOUNDS-NOT: call void @__ubsan_handle_out_of_bounds + // TSAN-NOT: call void @__tsan_func_entry + // UBSAN-NOT: call void @__ubsan_handle + if (n) + x[n] = 42; +} + +// CHECK-LABEL: define dso_local void @test_no_sanitize_always_inline( +__attribute__((no_sanitize("coverage"))) +void test_no_sanitize_always_inline(int n) { + // CHECK-NOT: call void @__sanitizer_cov_trace_pc + // CHECK-NOT: call void @__sanitizer_cov_trace_const_cmp + always_inlined_fn(n); +} + // CHECK-LABEL: declare void diff --git a/llvm/bindings/go/llvm/ir_test.go b/llvm/bindings/go/llvm/ir_test.go index da204151a542b..71c47d94a0ecf 100644 --- a/llvm/bindings/go/llvm/ir_test.go +++ b/llvm/bindings/go/llvm/ir_test.go @@ -69,6 +69,7 @@ func TestAttributes(t *testing.T) { "noredzone", "noreturn", "nounwind", + "nosanitize_coverage", "optnone", "optsize", "readnone", diff --git a/llvm/docs/BitCodeFormat.rst b/llvm/docs/BitCodeFormat.rst index b789d14814041..830b63f57d7b3 100644 --- a/llvm/docs/BitCodeFormat.rst +++ b/llvm/docs/BitCodeFormat.rst @@ -1073,6 +1073,8 @@ The integer codes are mapped to well-known attributes as follows. * code 69: ``byref`` * code 70: ``mustprogress`` * code 74: ``vscale_range(<Min>[, <Max>])`` +* code 75: ``swiftasync`` +* code 76: ``nosanitize_coverage`` .. 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 4c2de632ed3a4..1ee3bd847d2c0 100644 --- a/llvm/docs/LangRef.rst +++ b/llvm/docs/LangRef.rst @@ -1691,6 +1691,9 @@ example: trap or generate asynchronous exceptions. Exception handling schemes that are recognized by LLVM to handle asynchronous exceptions, such as SEH, will still provide their implementation defined semantics. +``nosanitize_coverage`` + This attribute indicates that SanitizerCoverage instrumentation is disabled + for this function. ``null_pointer_is_valid`` If ``null_pointer_is_valid`` is set, then the ``null`` address in address-space 0 is considered to be a valid address for memory loads and diff --git a/llvm/include/llvm/AsmParser/LLToken.h b/llvm/include/llvm/AsmParser/LLToken.h index f261f4af9089c..7aed41e241aa3 100644 --- a/llvm/include/llvm/AsmParser/LLToken.h +++ b/llvm/include/llvm/AsmParser/LLToken.h @@ -217,6 +217,7 @@ enum Kind { kw_nosync, kw_nocf_check, kw_nounwind, + kw_nosanitize_coverage, kw_null_pointer_is_valid, kw_optforfuzzing, kw_optnone, diff --git a/llvm/include/llvm/Bitcode/LLVMBitCodes.h b/llvm/include/llvm/Bitcode/LLVMBitCodes.h index 9bc6863e851e6..9a23c0cf3f445 100644 --- a/llvm/include/llvm/Bitcode/LLVMBitCodes.h +++ b/llvm/include/llvm/Bitcode/LLVMBitCodes.h @@ -666,6 +666,7 @@ enum AttributeKindCodes { ATTR_KIND_NO_PROFILE = 73, ATTR_KIND_VSCALE_RANGE = 74, ATTR_KIND_SWIFT_ASYNC = 75, + ATTR_KIND_NO_SANITIZE_COVERAGE = 76, }; enum ComdatSelectionKindCodes { diff --git a/llvm/include/llvm/IR/Attributes.td b/llvm/include/llvm/IR/Attributes.td index d6223eff63029..177471c69fafe 100644 --- a/llvm/include/llvm/IR/Attributes.td +++ b/llvm/include/llvm/IR/Attributes.td @@ -154,6 +154,9 @@ def NoProfile : EnumAttr<"noprofile">; /// Function doesn't unwind stack. def NoUnwind : EnumAttr<"nounwind">; +/// No SanitizeCoverage instrumentation. +def NoSanitizeCoverage : EnumAttr<"nosanitize_coverage">; + /// Null pointer in address space zero is valid. def NullPointerIsValid : EnumAttr<"null_pointer_is_valid">; diff --git a/llvm/lib/AsmParser/LLLexer.cpp b/llvm/lib/AsmParser/LLLexer.cpp index 00e2fef80e986..ae7cab51ac1c9 100644 --- a/llvm/lib/AsmParser/LLLexer.cpp +++ b/llvm/lib/AsmParser/LLLexer.cpp @@ -671,6 +671,7 @@ lltok::Kind LLLexer::LexIdentifier() { KEYWORD(nocf_check); KEYWORD(noundef); KEYWORD(nounwind); + KEYWORD(nosanitize_coverage); KEYWORD(null_pointer_is_valid); KEYWORD(optforfuzzing); KEYWORD(optnone); diff --git a/llvm/lib/AsmParser/LLParser.cpp b/llvm/lib/AsmParser/LLParser.cpp index 3184aba838ac9..91599e2496892 100644 --- a/llvm/lib/AsmParser/LLParser.cpp +++ b/llvm/lib/AsmParser/LLParser.cpp @@ -1398,6 +1398,9 @@ bool LLParser::parseFnAttributeValuePairs(AttrBuilder &B, case lltok::kw_noprofile: B.addAttribute(Attribute::NoProfile); break; case lltok::kw_norecurse: B.addAttribute(Attribute::NoRecurse); break; case lltok::kw_nounwind: B.addAttribute(Attribute::NoUnwind); break; + case lltok::kw_nosanitize_coverage: + B.addAttribute(Attribute::NoSanitizeCoverage); + break; case lltok::kw_null_pointer_is_valid: B.addAttribute(Attribute::NullPointerIsValid); break; case lltok::kw_optforfuzzing: @@ -1825,6 +1828,7 @@ bool LLParser::parseOptionalParamAttrs(AttrBuilder &B) { case lltok::kw_noreturn: case lltok::kw_nocf_check: case lltok::kw_nounwind: + case lltok::kw_nosanitize_coverage: case lltok::kw_optforfuzzing: case lltok::kw_optnone: case lltok::kw_optsize: @@ -1936,6 +1940,7 @@ bool LLParser::parseOptionalReturnAttrs(AttrBuilder &B) { case lltok::kw_noreturn: case lltok::kw_nocf_check: case lltok::kw_nounwind: + case lltok::kw_nosanitize_coverage: case lltok::kw_optforfuzzing: case lltok::kw_optnone: case lltok::kw_optsize: diff --git a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp index 7d23f3b5728f9..6eac5529cf087 100644 --- a/llvm/lib/Bitcode/Reader/BitcodeReader.cpp +++ b/llvm/lib/Bitcode/Reader/BitcodeReader.cpp @@ -1474,6 +1474,8 @@ static Attribute::AttrKind getAttrFromCode(uint64_t Code) { return Attribute::NoCfCheck; case bitc::ATTR_KIND_NO_UNWIND: return Attribute::NoUnwind; + case bitc::ATTR_KIND_NO_SANITIZE_COVERAGE: + return Attribute::NoSanitizeCoverage; case bitc::ATTR_KIND_NULL_POINTER_IS_VALID: return Attribute::NullPointerIsValid; case bitc::ATTR_KIND_OPT_FOR_FUZZING: diff --git a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp index c5ff5619cd909..fd85b9c527165 100644 --- a/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp +++ b/llvm/lib/Bitcode/Writer/BitcodeWriter.cpp @@ -686,6 +686,8 @@ static uint64_t getAttrKindEncoding(Attribute::AttrKind Kind) { return bitc::ATTR_KIND_NO_PROFILE; case Attribute::NoUnwind: return bitc::ATTR_KIND_NO_UNWIND; + case Attribute::NoSanitizeCoverage: + return bitc::ATTR_KIND_NO_SANITIZE_COVERAGE; case Attribute::NullPointerIsValid: return bitc::ATTR_KIND_NULL_POINTER_IS_VALID; case Attribute::OptForFuzzing: diff --git a/llvm/lib/IR/Attributes.cpp b/llvm/lib/IR/Attributes.cpp index f63a65abc30bd..daf0f178e4c47 100644 --- a/llvm/lib/IR/Attributes.cpp +++ b/llvm/lib/IR/Attributes.cpp @@ -442,6 +442,8 @@ std::string Attribute::getAsString(bool InAttrGrp) const { return "noprofile"; if (hasAttribute(Attribute::NoUnwind)) return "nounwind"; + if (hasAttribute(Attribute::NoSanitizeCoverage)) + return "nosanitize_coverage"; if (hasAttribute(Attribute::OptForFuzzing)) return "optforfuzzing"; if (hasAttribute(Attribute::OptimizeNone)) diff --git a/llvm/lib/IR/Verifier.cpp b/llvm/lib/IR/Verifier.cpp index 80f343365afda..22d9e7717a9fe 100644 --- a/llvm/lib/IR/Verifier.cpp +++ b/llvm/lib/IR/Verifier.cpp @@ -1661,6 +1661,7 @@ static bool isFuncOnlyAttr(Attribute::AttrKind Kind) { case Attribute::NoCfCheck: case Attribute::NoUnwind: case Attribute::NoInline: + case Attribute::NoSanitizeCoverage: case Attribute::AlwaysInline: case Attribute::OptimizeForSize: case Attribute::StackProtect: diff --git a/llvm/lib/Transforms/IPO/ForceFunctionAttrs.cpp b/llvm/lib/Transforms/IPO/ForceFunctionAttrs.cpp index 1a4be75dcf2fc..521bc7308ea4b 100644 --- a/llvm/lib/Transforms/IPO/ForceFunctionAttrs.cpp +++ b/llvm/lib/Transforms/IPO/ForceFunctionAttrs.cpp @@ -53,6 +53,7 @@ static Attribute::AttrKind parseAttrKind(StringRef Kind) { .Case("nocf_check", Attribute::NoCfCheck) .Case("norecurse", Attribute::NoRecurse) .Case("nounwind", Attribute::NoUnwind) + .Case("nosanitize_coverage", Attribute::NoSanitizeCoverage) .Case("optforfuzzing", Attribute::OptForFuzzing) .Case("optnone", Attribute::OptimizeNone) .Case("optsize", Attribute::OptimizeForSize) diff --git a/llvm/lib/Transforms/Instrumentation/SanitizerCoverage.cpp b/llvm/lib/Transforms/Instrumentation/SanitizerCoverage.cpp index 60cdecdc018a4..8bce6b82482b5 100644 --- a/llvm/lib/Transforms/Instrumentation/SanitizerCoverage.cpp +++ b/llvm/lib/Transforms/Instrumentation/SanitizerCoverage.cpp @@ -621,6 +621,8 @@ void ModuleSanitizerCoverage::instrumentFunction( return; if (Blocklist && Blocklist->inSection("coverage", "fun", F.getName())) return; + if (F.hasFnAttribute(Attribute::NoSanitizeCoverage)) + return; if (Options.CoverageType >= SanitizerCoverageOptions::SCK_Edge) SplitAllCriticalEdges(F, CriticalEdgeSplittingOptions().setIgnoreUnreachableDests()); SmallVector<Instruction *, 8> IndirCalls; diff --git a/llvm/lib/Transforms/Utils/CodeExtractor.cpp b/llvm/lib/Transforms/Utils/CodeExtractor.cpp index a39ede9aaff66..189e87e180cb8 100644 --- a/llvm/lib/Transforms/Utils/CodeExtractor.cpp +++ b/llvm/lib/Transforms/Utils/CodeExtractor.cpp @@ -954,6 +954,7 @@ Function *CodeExtractor::constructFunction(const ValueSet &inputs, case Attribute::NonLazyBind: case Attribute::NoRedZone: case Attribute::NoUnwind: + case Attribute::NoSanitizeCoverage: case Attribute::NullPointerIsValid: case Attribute::OptForFuzzing: case Attribute::OptimizeNone: diff --git a/llvm/test/Bitcode/attributes.ll b/llvm/test/Bitcode/attributes.ll index 0ee8a43cc2ca2..894d475ebabe5 100644 --- a/llvm/test/Bitcode/attributes.ll +++ b/llvm/test/Bitcode/attributes.ll @@ -453,6 +453,12 @@ define void @f76(i8* swiftasync %0) ret void; } +; CHECK: define void @f77() #48 +define void @f77() nosanitize_coverage +{ + ret void; +} + ; CHECK: attributes #0 = { noreturn } ; CHECK: attributes #1 = { nounwind } ; CHECK: attributes #2 = { readnone } @@ -501,4 +507,5 @@ define void @f76(i8* swiftasync %0) ; CHECK: attributes #45 = { vscale_range(8,8) } ; CHECK: attributes #46 = { vscale_range(1,8) } ; CHECK: attributes #47 = { vscale_range(1,0) } +; CHECK: attributes #48 = { nosanitize_coverage } ; CHECK: attributes #[[NOBUILTIN]] = { nobuiltin } diff --git a/llvm/test/Bitcode/compatibility.ll b/llvm/test/Bitcode/compatibility.ll index 9ac8c06acde83..d55c558f5d267 100644 --- a/llvm/test/Bitcode/compatibility.ll +++ b/llvm/test/Bitcode/compatibility.ll @@ -1510,7 +1510,7 @@ exit: ; CHECK: select <2 x i1> <i1 true, i1 false>, <2 x i8> <i8 2, i8 3>, <2 x i8> <i8 3, i8 2> call void @f.nobuiltin() builtin - ; CHECK: call void @f.nobuiltin() #44 + ; CHECK: call void @f.nobuiltin() #45 call fastcc noalias i32* @f.noalias() noinline ; CHECK: call fastcc noalias i32* @f.noalias() #12 @@ -1904,6 +1904,9 @@ define void @instructions.strictfp() strictfp { ret void } +declare void @f.nosanitize_coverage() nosanitize_coverage +; CHECK: declare void @f.nosanitize_coverage() #44 + ; immarg attribute declare void @llvm.test.immarg.intrinsic(i32 immarg) ; CHECK: declare void @llvm.test.immarg.intrinsic(i32 immarg) @@ -1961,7 +1964,8 @@ declare void @byval_named_type(%named_type* byval(%named_type)) ; CHECK: attributes #41 = { writeonly } ; CHECK: attributes #42 = { speculatable } ; CHECK: attributes #43 = { strictfp } -; CHECK: attributes #44 = { builtin } +; CHECK: attributes #44 = { nosanitize_coverage } +; CHECK: attributes #45 = { builtin } ;; Metadata diff --git a/llvm/utils/emacs/llvm-mode.el b/llvm/utils/emacs/llvm-mode.el index 3ca86ae2cc957..4a0b90d57dda0 100644 --- a/llvm/utils/emacs/llvm-mode.el +++ b/llvm/utils/emacs/llvm-mode.el @@ -25,7 +25,7 @@ '("alwaysinline" "argmemonly" "allocsize" "builtin" "cold" "convergent" "dereferenceable" "dereferenceable_or_null" "hot" "inaccessiblememonly" "inaccessiblemem_or_argmemonly" "inalloca" "inlinehint" "jumptable" "minsize" "mustprogress" "naked" "nobuiltin" "nonnull" "nocallback" "nocf_check" "noduplicate" "nofree" "noimplicitfloat" "noinline" "nomerge" "nonlazybind" "noprofile" "noredzone" "noreturn" - "norecurse" "nosync" "noundef" "nounwind" "null_pointer_is_valid" "optforfuzzing" "optnone" "optsize" "preallocated" "readnone" "readonly" "returned" "returns_twice" + "norecurse" "nosync" "noundef" "nounwind" "nosanitize_coverage" "null_pointer_is_valid" "optforfuzzing" "optnone" "optsize" "preallocated" "readnone" "readonly" "returned" "returns_twice" "shadowcallstack" "speculatable" "speculative_load_hardening" "ssp" "sspreq" "sspstrong" "safestack" "sanitize_address" "sanitize_hwaddress" "sanitize_memtag" "sanitize_thread" "sanitize_memory" "strictfp" "swifterror" "uwtable" "vscale_range" "willreturn" "writeonly" "immarg") 'symbols) . font-lock-constant-face) ;; Variables diff --git a/llvm/utils/llvm.grm b/llvm/utils/llvm.grm index 9f4bb382c2b75..be6dec78f9f50 100644 --- a/llvm/utils/llvm.grm +++ b/llvm/utils/llvm.grm @@ -176,6 +176,7 @@ FuncAttr ::= noreturn | sanitize_thread | sanitize_memory | mustprogress + | nosanitize_coverage ; OptFuncAttrs ::= + _ | OptFuncAttrs FuncAttr ; diff --git a/llvm/utils/vim/syntax/llvm.vim b/llvm/utils/vim/syntax/llvm.vim index e4c570066df9e..7d0accc922ae8 100644 --- a/llvm/utils/vim/syntax/llvm.vim +++ b/llvm/utils/vim/syntax/llvm.vim @@ -138,6 +138,7 @@ syn keyword llvmKeyword \ nosync \ noundef \ nounwind + \ nosanitize_coverage \ null_pointer_is_valid \ optforfuzzing \ optnone diff --git a/llvm/utils/vscode/llvm/syntaxes/ll.tmLanguage.yaml b/llvm/utils/vscode/llvm/syntaxes/ll.tmLanguage.yaml index ff6707b21687f..18667303ab140 100644 --- a/llvm/utils/vscode/llvm/syntaxes/ll.tmLanguage.yaml +++ b/llvm/utils/vscode/llvm/syntaxes/ll.tmLanguage.yaml @@ -237,6 +237,7 @@ patterns: \\bnosync\\b|\ \\bnoundef\\b|\ \\bnounwind\\b|\ + \\bnosanitize_coverage\\b|\ \\bnull_pointer_is_valid\\b|\ \\boptforfuzzing\\b|\ \\boptnone\\b|\ _______________________________________________ cfe-commits mailing list cfe-commits@lists.llvm.org https://lists.llvm.org/cgi-bin/mailman/listinfo/cfe-commits