[clang][patch] Modify sanitizer options names: renaming blacklist to blocklist

[mibintc]

Summary

This changes the option names that include substring blacklist to blocklist. Also there are some "resource directory" builtin file names. I changed those from blacklist to blocklist. I looked in the doc to see if the builtin file names appear in the documentation, I couldn't find hits using e.g. "asan_blacklist.txt site:llvm.org" so I cautiously think they aren't documented and therefore fair game.

In options.td there is a way to officially mark an option deprecated by adding it to a specific group, I didn't do that yet. When could we actually eliminate the old spelling? How about December 2021?

I thought it would be best to start with the external clang interface, but i also want to make more patches to eliminate whitelist and blacklist in the comments and in the object names, file names etc.

[aaron.ballman]

Thank you for working on this!

This changes the option names that include substring blacklist to blocklist.

I think this change works in some places, but in other places we say things like "blocklisted" which feels a bit awkward. I don't super love the name blocklist, but I don't super hate it either. All the alternative names I come up with aren't really great either, like UnsanitiziedEntities or IgnoredObjects. Maybe someone will have a better idea here than me, but I do think the current name is an improvement over the old name.

In options.td there is a way to officially mark an option deprecated by adding it to a specific group, I didn't do that yet. When could we actually eliminate the old spelling? How about December 2021?

I think we want to leave the deprecated options in for a full release cycle, so I'd say that (assuming this lands in Clang 13) we could remove support once we start work on Clang 14.

I thought it would be best to start with the external clang interface, but i also want to make more patches to eliminate whitelist and blacklist in the comments and in the object names, file names etc.

Fantastic, thank you!

clang/include/clang/AST/ASTContext.h

565

The comment should be updated as well.

clang/lib/Driver/SanitizerArgs.cpp

141

Do we want to retain support for the old file names and warn about using a deprecated name if one is used? This would keep folks working who are relying on this (even if it's undocumented).

[mibintc]

In D96203#2546856, @aaron.ballman wrote:

Thank you for working on this!

This changes the option names that include substring blacklist to blocklist.

I think this change works in some places, but in other places we say things like "blocklisted" which feels a bit awkward. I don't super love the name blocklist, but I don't super hate it either. All the alternative names I come up with aren't really great either, like UnsanitiziedEntities or IgnoredObjects. Maybe someone will have a better idea here than me, but I do think the current name is an improvement over the old name.

There is a pre-existing patch https://reviews.llvm.org/D82244 using block and allow, that's why I chose blocklist. Although going in cold I would prefer to use allow and deny, and block seems to me a little like cheating (too similar to black). However I can "disagree and commit" (cf. https://en.wikipedia.org/wiki/Disagree_and_commit) with this choice of wording. I can search out the awkward Blocklisted and come up with different phrasing in the prose, but I think names in the program should use blocklist so that they can be easily connected to the option name for future maintainers of llvm. I'll check this.

In options.td there is a way to officially mark an option deprecated by adding it to a specific group, I didn't do that yet. When could we actually eliminate the old spelling? How about December 2021?

I think we want to leave the deprecated options in for a full release cycle, so I'd say that (assuming this lands in Clang 13) we could remove support once we start work on Clang 14.

I thought it would be best to start with the external clang interface, but i also want to make more patches to eliminate whitelist and blacklist in the comments and in the object names, file names etc.

Fantastic, thank you!

[aaron.ballman]

In D96203#2548471, @mibintc wrote:

In D96203#2546856, @aaron.ballman wrote:

Thank you for working on this!

This changes the option names that include substring blacklist to blocklist.

I think this change works in some places, but in other places we say things like "blocklisted" which feels a bit awkward. I don't super love the name blocklist, but I don't super hate it either. All the alternative names I come up with aren't really great either, like UnsanitiziedEntities or IgnoredObjects. Maybe someone will have a better idea here than me, but I do think the current name is an improvement over the old name.

There is a pre-existing patch https://reviews.llvm.org/D82244 using block and allow, that's why I chose blocklist. Although going in cold I would prefer to use allow and deny, and block seems to me a little like cheating (too similar to black).

That was my concern as well -- I can easily imagine someone seeing "blocklisted" and thinking it was a typo for "blacklisted" and undoing the change to comments with an NFC change.

However I can "disagree and commit" (cf. https://en.wikipedia.org/wiki/Disagree_and_commit) with this choice of wording. I can search out the awkward Blocklisted and come up with different phrasing in the prose, but I think names in the program should use blocklist so that they can be easily connected to the option name for future maintainers of llvm. I'll check this.

I agree that the frontend option names and the internal variable names need to connect to one another, so if we pick a new term, it should be used consistently. I'd be mildly happier with a better term than blocklist, but I can live with that name too.

[echristo]

In D96203#2548495, @aaron.ballman wrote:

In D96203#2548471, @mibintc wrote:

In D96203#2546856, @aaron.ballman wrote:

Thank you for working on this!

This changes the option names that include substring blacklist to blocklist.

I think this change works in some places, but in other places we say things like "blocklisted" which feels a bit awkward. I don't super love the name blocklist, but I don't super hate it either. All the alternative names I come up with aren't really great either, like UnsanitiziedEntities or IgnoredObjects. Maybe someone will have a better idea here than me, but I do think the current name is an improvement over the old name.

There is a pre-existing patch https://reviews.llvm.org/D82244 using block and allow, that's why I chose blocklist. Although going in cold I would prefer to use allow and deny, and block seems to me a little like cheating (too similar to black).

That was my concern as well -- I can easily imagine someone seeing "blocklisted" and thinking it was a typo for "blacklisted" and undoing the change to comments with an NFC change.

However I can "disagree and commit" (cf. https://en.wikipedia.org/wiki/Disagree_and_commit) with this choice of wording. I can search out the awkward Blocklisted and come up with different phrasing in the prose, but I think names in the program should use blocklist so that they can be easily connected to the option name for future maintainers of llvm. I'll check this.

I agree that the frontend option names and the internal variable names need to connect to one another, so if we pick a new term, it should be used consistently. I'd be mildly happier with a better term than blocklist, but I can live with that name too.

FWIW I would prefer denylist as well. (Also uses of whitelist should be allowlist, but also incremental :)

-eric

[MaskRay]

In D96203#2548529, @echristo wrote:

In D96203#2548495, @aaron.ballman wrote:

In D96203#2548471, @mibintc wrote:

In D96203#2546856, @aaron.ballman wrote:

Thank you for working on this!

This changes the option names that include substring blacklist to blocklist.

I think this change works in some places, but in other places we say things like "blocklisted" which feels a bit awkward. I don't super love the name blocklist, but I don't super hate it either. All the alternative names I come up with aren't really great either, like UnsanitiziedEntities or IgnoredObjects. Maybe someone will have a better idea here than me, but I do think the current name is an improvement over the old name.

There is a pre-existing patch https://reviews.llvm.org/D82244 using block and allow, that's why I chose blocklist. Although going in cold I would prefer to use allow and deny, and block seems to me a little like cheating (too similar to black).

That was my concern as well -- I can easily imagine someone seeing "blocklisted" and thinking it was a typo for "blacklisted" and undoing the change to comments with an NFC change.

However I can "disagree and commit" (cf. https://en.wikipedia.org/wiki/Disagree_and_commit) with this choice of wording. I can search out the awkward Blocklisted and come up with different phrasing in the prose, but I think names in the program should use blocklist so that they can be easily connected to the option name for future maintainers of llvm. I'll check this.

I agree that the frontend option names and the internal variable names need to connect to one another, so if we pick a new term, it should be used consistently. I'd be mildly happier with a better term than blocklist, but I can live with that name too.

FWIW I would prefer denylist as well. (Also uses of whitelist should be allowlist, but also incremental :)

-eric

I can change D82244 used blocklist to denylist . If there is no need for compatibility, I'll just replace the strings. If there is need for compatibility, I can make blocklist an alias.

[vitalybuka]

FWIW I would prefer denylist as well. (Also uses of whitelist should be allowlist, but also incremental :)

I feel like existing and proposed value do match the meaning of this list.
maybe ignorelist, skiplist (can be confused with data structure?), or just asan_no_sanitize.txt or even no_asan.txt

I can change D82244 used blocklist to denylist . If there is no need for compatibility, I'll just replace the strings. If there is need for compatibility, I can make blocklist an alias.

I don't think we need compatibility for D82244. If we change clang, we can update D82244 to the same for consistency.

clang/unittests/Driver/SanitizerArgsTest.cpp

134–136

always/never?

[mibintc]

In D96203#2559426, @vitalybuka wrote:

FWIW I would prefer denylist as well. (Also uses of whitelist should be allowlist, but also incremental :)

I feel like existing and proposed value do match the meaning of this list.
maybe ignorelist, skiplist (can be confused with data structure?), or just asan_no_sanitize.txt or even no_asan.txt

Would you use ignorelist (skiplist) in the option name as well as the filename? Can you recommend a name for the antonym as well (i.e. replacement for whitelist)

I can change D82244 used blocklist to denylist . If there is no need for compatibility, I'll just replace the strings. If there is need for compatibility, I can make blocklist an alias.

I don't think we need compatibility for D82244. If we change clang, we can update D82244 to the same for consistency.

Yes I agree.

clang/unittests/Driver/SanitizerArgsTest.cpp

134–136

Can you say a few more works here? You mean use always as replacement for white, and never as replacement for black?

[vitalybuka]

In D96203#2559792, @mibintc wrote:

In D96203#2559426, @vitalybuka wrote:

FWIW I would prefer denylist as well. (Also uses of whitelist should be allowlist, but also incremental :)

I feel like existing and proposed value do match the meaning of this list.
maybe ignorelist, skiplist (can be confused with data structure?), or just asan_no_sanitize.txt or even no_asan.txt

Would you use ignorelist (skiplist) in the option name as well as the filename? Can you recommend a name for the antonym as well (i.e. replacement for whitelist)

If we change that I would also replaced:
-list to -file to match other

We have attributes for a similar purpose in language:
https://clang.llvm.org/docs/AttributeReference.html#no-sanitize-address-no-address-safety-analysis
So maybe we can use that scheme for files which used for the same purpose?
-fno-sanitize-file=..../no_sanitize_address.txt

However we have -fno-sanitize-blocklist which then should be -fno-no-sanitize-file? :)
But I hope we can just remove that flag D79043

clang/include/clang/Driver/Options.td

1412–1434

This file has to many independent changes, I'd separate them into a separate patches when possible. At least user visible changes as this one and Inputs/resource_dir/share/ into a separate one.
Also it's easier to review.

clang/unittests/Driver/SanitizerArgsTest.cpp

134–136

This are internal variables of unittest, it can be anything
use use thatever is part of -fxray-*-instrument= flags

[vitalybuka]

clang/include/clang/Basic/SanitizerBlacklist.h

20

This file should go into a separate patch. It touches multiple files with simple changes but unlikely will case rollback.
It's unrelated to most critical change in Options.td which may need some discussion.
Options.td so I am ready accept such changes here changes ASAP.

28

NoSanitizeList ?

36

containsGlobal
containsType

[mibintc]

clang/include/clang/Basic/SanitizerBlacklist.h

20

I changed the filename in this patch, https://reviews.llvm.org/D96974

[vitalybuka]

Could you please rebase the patch onto D96974

[mibintc]

I rebased the patch and basically made no other changes. On the review there's a suggestion that 'blocklist' isn't the best word choice, do you have suggestions?

[echristo]

Exclusion list? or exclude?

[mibintc]

In D96203#2587942, @echristo wrote:

Exclusion list? or exclude?

In 2a4317bfb319e, (Fangrui Song 2020-06-19) changed option name fsanitize-coverage-whitelist to fsanitize-coverage-allowlist. So another possibility is AllowList and DisallowList

[vitalybuka]

To my taste "exclude" better represents meaning than "disallow".
E.g. disallow can be interpreted as "make them fatal". We can fix
2a4317bfb319e for consistency later.
-fsanitize-exclude-list= ?

[vitalybuka]

Is this abandoned patch?

[mibintc]

There was no resolution about what option name would be acceptable

clang/include/clang/AST/ASTContext.h

private:
 
   /// The associated SourceManager object.
   SourceManager &SourceMgr;
 
   /// The language options used to create the AST associated with
   ///  this ASTContext object.
   LangOptions &LangOpts;
 
   /// Blacklist object that is used by sanitizers to decide which
   /// entities should not be instrumented.
-  std::unique_ptr<SanitizerBlacklist> SanitizerBL;
+  std::unique_ptr<SanitizerBlocklist> SanitizerBL;
 
   /// Function filtering mechanism to determine whether a given function
   /// should be imbued with the XRay "always" or "never" attributes.
   std::unique_ptr<XRayFunctionFilter> XRayFilter;
 
   /// ProfileList object that is used by the profile instrumentation
   /// to decide which entities should be instrumented.
   std::unique_ptr<ProfileList> ProfList;
public:
   // If this condition is false, typo correction must be performed eagerly
   // rather than delayed in many places, as it makes use of dependent types.
   // the condition is false for clang's C-only codepath, as it doesn't support
   // dependent types yet.
   bool isDependenceAllowed() const {
     return LangOpts.CPlusPlus || LangOpts.RecoveryAST;
   }
 
-  const SanitizerBlacklist &getSanitizerBlacklist() const {
+  const SanitizerBlocklist &getSanitizerBlocklist() const {
     return *SanitizerBL;
   }
 
   const XRayFunctionFilter &getXRayFilter() const {
     return *XRayFilter;
   }
 
   const ProfileList &getProfileList() const { return *ProfList; }

clang/include/clang/Basic/LangOptions.h

 
 public:
   /// The used language standard.
   LangStandard::Kind LangStd;
 
   /// Set of enabled sanitizers.
   SanitizerSet Sanitize;
 
-  /// Paths to blacklist files specifying which objects
+  /// Paths to blocklist files specifying which objects
   /// (files, functions, variables) should not be instrumented.
-  std::vector<std::string> SanitizerBlacklistFiles;
+  std::vector<std::string> SanitizerBlocklistFiles;
 
   /// Paths to the XRay "always instrument" files specifying which
   /// objects (files, functions, variables) should be imbued with the XRay
   /// "always instrument" attribute.
   /// WARNING: This is a deprecated field and will go away in the future.
   std::vector<std::string> XRayAlwaysInstrumentFiles;
 
   /// Paths to the XRay "never instrument" files specifying which

clang/include/clang/Basic/SanitizerBlacklist.h

 //===--- SanitizerBlacklist.h - Blacklist for sanitizers --------*- C++ -*-===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
-// User-provided blacklist used to disable/alter instrumentation done in
+// User-provided blocklist used to disable/alter instrumentation done in
 // sanitizers.
 //
 //===----------------------------------------------------------------------===//
 #ifndef LLVM_CLANG_BASIC_SANITIZERBLACKLIST_H
 #define LLVM_CLANG_BASIC_SANITIZERBLACKLIST_H
 
 #include "clang/Basic/LLVM.h"
 #include "clang/Basic/SourceLocation.h"
 #include "llvm/ADT/StringRef.h"
 #include <memory>
 #include <vector>
 
 namespace clang {
 
 class SanitizerMask;
 class SourceManager;
 class SanitizerSpecialCaseList;
 
-class SanitizerBlacklist {
+class SanitizerBlocklist {
   std::unique_ptr<SanitizerSpecialCaseList> SSCL;
   SourceManager &SM;
 
 public:
-  SanitizerBlacklist(const std::vector<std::string> &BlacklistPaths,
+  SanitizerBlocklist(const std::vector<std::string> &BlocklistPaths,
                      SourceManager &SM);
-  ~SanitizerBlacklist();
-  bool isBlacklistedGlobal(SanitizerMask Mask, StringRef GlobalName,
+  ~SanitizerBlocklist();
+  bool isBlocklistedGlobal(SanitizerMask Mask, StringRef GlobalName,
                            StringRef Category = StringRef()) const;
-  bool isBlacklistedType(SanitizerMask Mask, StringRef MangledTypeName,
+  bool isBlocklistedType(SanitizerMask Mask, StringRef MangledTypeName,
                          StringRef Category = StringRef()) const;
-  bool isBlacklistedFunction(SanitizerMask Mask, StringRef FunctionName) const;
-  bool isBlacklistedFile(SanitizerMask Mask, StringRef FileName,
+  bool isBlocklistedFunction(SanitizerMask Mask, StringRef FunctionName) const;
+  bool isBlocklistedFile(SanitizerMask Mask, StringRef FileName,
                          StringRef Category = StringRef()) const;
-  bool isBlacklistedLocation(SanitizerMask Mask, SourceLocation Loc,
+  bool isBlocklistedLocation(SanitizerMask Mask, SourceLocation Loc,
                              StringRef Category = StringRef()) const;
 };
 
 }  // end namespace clang
 
 #endif

clang/include/clang/Driver/Options.td

 let Flags = [CC1Option, CoreOption] in {
 
 def fsanitize_EQ : CommaJoined<["-"], "fsanitize=">, Group<f_clang_Group>,
                    MetaVarName<"<check>">,
                    HelpText<"Turn on runtime checks for various forms of undefined "
                             "or suspicious behavior. See user manual for available checks">;
 def fno_sanitize_EQ : CommaJoined<["-"], "fno-sanitize=">, Group<f_clang_Group>,
                       Flags<[CoreOption, NoXarchOption]>;
+def fsanitize_blocklist : Joined<["-"], "fsanitize-blocklist=">,
+                          Group<f_clang_Group>,
+                          HelpText<"Path to blocklist file for sanitizers">,
+                          MarshallingInfoStringVector<LangOpts<"SanitizerBlocklistFiles">>;
 def fsanitize_blacklist : Joined<["-"], "fsanitize-blacklist=">,
-                          Group<f_clang_Group>,
-                          HelpText<"Path to blacklist file for sanitizers">,
-                          MarshallingInfoStringVector<LangOpts<"SanitizerBlacklistFiles">>;
-def fsanitize_system_blacklist : Joined<["-"], "fsanitize-system-blacklist=">,
-  HelpText<"Path to system blacklist file for sanitizers">,
+                          Group<f_clang_Group>, Alias<fsanitize_blocklist>,
+                          Flags<[HelpHidden]>,
+                          HelpText<"Deprecated, use -fsanitize-blocklist= instead">;
+def fsanitize_system_blocklist : Joined<["-"], "fsanitize-system-blocklist=">,
+  HelpText<"Path to system blocklist file for sanitizers">,
   Flags<[CC1Option]>;
+def fsanitize_system_blacklist : Joined<["-"], "fsanitize-system-blacklist=">,
+  Group<f_clang_Group>, Alias<fsanitize_system_blocklist>,
+  Flags<[CC1Option, HelpHidden]>,
+  HelpText<"Deprecated, use -fsanitize-system-blocklist= instead">;
+def fno_sanitize_blocklist : Flag<["-"], "fno-sanitize-blocklist">,
+                             Group<f_clang_Group>,
+                             HelpText<"Don't use blocklist file for sanitizers">;
 def fno_sanitize_blacklist : Flag<["-"], "fno-sanitize-blacklist">,
-                             Group<f_clang_Group>,
-                             HelpText<"Don't use blacklist file for sanitizers">;
+  Flags<[HelpHidden]>,
+  HelpText<"Deprecated, use -fno-sanitize-blocklist= instead">;
 def fsanitize_coverage
     : CommaJoined<["-"], "fsanitize-coverage=">,
       Group<f_clang_Group>,
       HelpText<"Specify the type of coverage instrumentation for Sanitizers">;
 def fno_sanitize_coverage
     : CommaJoined<["-"], "fno-sanitize-coverage=">,
       Group<f_clang_Group>, Flags<[CoreOption, NoXarchOption]>,
       HelpText<"Disable specified features of coverage instrumentation for "

clang/lib/AST/ASTContext.cpp

 ASTContext::ASTContext(LangOptions &LOpts, SourceManager &SM,
                        IdentifierTable &idents, SelectorTable &sels,
                        Builtin::Context &builtins)
     : ConstantArrayTypes(this_()), FunctionProtoTypes(this_()),
       TemplateSpecializationTypes(this_()),
       DependentTemplateSpecializationTypes(this_()), AutoTypes(this_()),
       SubstTemplateTemplateParmPacks(this_()),
       CanonTemplateTemplateParms(this_()), SourceMgr(SM), LangOpts(LOpts),
-      SanitizerBL(new SanitizerBlacklist(LangOpts.SanitizerBlacklistFiles, SM)),
+      SanitizerBL(new SanitizerBlocklist(LangOpts.SanitizerBlocklistFiles, SM)),
       XRayFilter(new XRayFunctionFilter(LangOpts.XRayAlwaysInstrumentFiles,
                                         LangOpts.XRayNeverInstrumentFiles,
                                         LangOpts.XRayAttrListFiles, SM)),
       ProfList(new ProfileList(LangOpts.ProfileListFiles, SM)),
       PrintingPolicy(LOpts), Idents(idents), Selectors(sels),
       BuiltinInfo(builtins), DeclarationNames(*this), Comments(SM),
       CommentCommandTraits(BumpAlloc, LOpts.CommentOpts),
       CompCategories(this_()), LastSDM(nullptr, 0) {

clang/lib/AST/Decl.cpp

 }
 
 bool RecordDecl::mayInsertExtraPadding(bool EmitRemark) const {
   ASTContext &Context = getASTContext();
   const SanitizerMask EnabledAsanMask = Context.getLangOpts().Sanitize.Mask &
       (SanitizerKind::Address | SanitizerKind::KernelAddress);
   if (!EnabledAsanMask || !Context.getLangOpts().SanitizeAddressFieldPadding)
     return false;
-  const auto &Blacklist = Context.getSanitizerBlacklist();
+  const auto &Blocklist = Context.getSanitizerBlocklist();
   const auto *CXXRD = dyn_cast<CXXRecordDecl>(this);
   // We may be able to relax some of these requirements.
   int ReasonToReject = -1;
   if (!CXXRD || CXXRD->isExternCContext())
     ReasonToReject = 0;  // is not C++.
   else if (CXXRD->hasAttr<PackedAttr>())
     ReasonToReject = 1;  // is packed.
   else if (CXXRD->isUnion())
     ReasonToReject = 2;  // is a union.
   else if (CXXRD->isTriviallyCopyable())
     ReasonToReject = 3;  // is trivially copyable.
   else if (CXXRD->hasTrivialDestructor())
     ReasonToReject = 4;  // has trivial destructor.
   else if (CXXRD->isStandardLayout())
     ReasonToReject = 5;  // is standard layout.
-  else if (Blacklist.isBlacklistedLocation(EnabledAsanMask, getLocation(),
+  else if (Blocklist.isBlocklistedLocation(EnabledAsanMask, getLocation(),
                                            "field-padding"))
     ReasonToReject = 6;  // is in an excluded file.
-  else if (Blacklist.isBlacklistedType(EnabledAsanMask,
+  else if (Blocklist.isBlocklistedType(EnabledAsanMask,
                                        getQualifiedNameAsString(),
                                        "field-padding"))
     ReasonToReject = 7;  // The type is excluded.
 
   if (EmitRemark) {
     if (ReasonToReject >= 0)
       Context.getDiagnostics().Report(
           getLocation(),

clang/lib/Basic/LangOptions.cpp

 void LangOptions::resetNonModularOptions() {
 #define LANGOPT(Name, Bits, Default, Description)
 #define BENIGN_LANGOPT(Name, Bits, Default, Description) Name = Default;
 #define BENIGN_ENUM_LANGOPT(Name, Type, Bits, Default, Description) \
   Name = static_cast<unsigned>(Default);
 #include "clang/Basic/LangOptions.def"
 
   // These options do not affect AST generation.
-  SanitizerBlacklistFiles.clear();
+  SanitizerBlocklistFiles.clear();
   XRayAlwaysInstrumentFiles.clear();
   XRayNeverInstrumentFiles.clear();
 
   CurrentModule.clear();
   IsHeaderFile = false;
 }
 
 bool LangOptions::isNoBuiltinFunc(StringRef FuncName) const {

clang/lib/Basic/SanitizerBlacklist.cpp

 //===--- SanitizerBlacklist.cpp - Blacklist for sanitizers ----------------===//
 //
 // Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
 // See https://llvm.org/LICENSE.txt for license information.
 // SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
 //
 //===----------------------------------------------------------------------===//
 //
-// User-provided blacklist used to disable/alter instrumentation done in
+// User-provided blocklist used to disable/alter instrumentation done in
 // sanitizers.
 //
 //===----------------------------------------------------------------------===//
 
 #include "clang/Basic/SanitizerBlacklist.h"
 #include "clang/Basic/FileManager.h"
 #include "clang/Basic/SanitizerSpecialCaseList.h"
 #include "clang/Basic/Sanitizers.h"
 #include "clang/Basic/SourceManager.h"
 
 using namespace clang;
 
-SanitizerBlacklist::SanitizerBlacklist(
-    const std::vector<std::string> &BlacklistPaths, SourceManager &SM)
+SanitizerBlocklist::SanitizerBlocklist(
+    const std::vector<std::string> &BlocklistPaths, SourceManager &SM)
     : SSCL(SanitizerSpecialCaseList::createOrDie(
-          BlacklistPaths, SM.getFileManager().getVirtualFileSystem())),
+          BlocklistPaths, SM.getFileManager().getVirtualFileSystem())),
       SM(SM) {}
 
-SanitizerBlacklist::~SanitizerBlacklist() = default;
+SanitizerBlocklist::~SanitizerBlocklist() = default;
 
-bool SanitizerBlacklist::isBlacklistedGlobal(SanitizerMask Mask,
+bool SanitizerBlocklist::isBlocklistedGlobal(SanitizerMask Mask,
                                              StringRef GlobalName,
                                              StringRef Category) const {
   return SSCL->inSection(Mask, "global", GlobalName, Category);
 }
 
-bool SanitizerBlacklist::isBlacklistedType(SanitizerMask Mask,
+bool SanitizerBlocklist::isBlocklistedType(SanitizerMask Mask,
                                            StringRef MangledTypeName,
                                            StringRef Category) const {
   return SSCL->inSection(Mask, "type", MangledTypeName, Category);
 }
 
-bool SanitizerBlacklist::isBlacklistedFunction(SanitizerMask Mask,
+bool SanitizerBlocklist::isBlocklistedFunction(SanitizerMask Mask,
                                                StringRef FunctionName) const {
   return SSCL->inSection(Mask, "fun", FunctionName);
 }
 
-bool SanitizerBlacklist::isBlacklistedFile(SanitizerMask Mask,
+bool SanitizerBlocklist::isBlocklistedFile(SanitizerMask Mask,
                                            StringRef FileName,
                                            StringRef Category) const {
   return SSCL->inSection(Mask, "src", FileName, Category);
 }
 
-bool SanitizerBlacklist::isBlacklistedLocation(SanitizerMask Mask,
+bool SanitizerBlocklist::isBlocklistedLocation(SanitizerMask Mask,
                                                SourceLocation Loc,
                                                StringRef Category) const {
   return Loc.isValid() &&
-         isBlacklistedFile(Mask, SM.getFilename(SM.getFileLoc(Loc)), Category);
+         isBlocklistedFile(Mask, SM.getFilename(SM.getFileLoc(Loc)), Category);
 }
 

clang/lib/CodeGen/BackendUtil.cpp

 }
 
 static void addDataFlowSanitizerPass(const PassManagerBuilder &Builder,
                                      legacy::PassManagerBase &PM) {
   const PassManagerBuilderWrapper &BuilderWrapper =
       static_cast<const PassManagerBuilderWrapper&>(Builder);
   const LangOptions &LangOpts = BuilderWrapper.getLangOpts();
   PM.add(
-      createDataFlowSanitizerLegacyPassPass(LangOpts.SanitizerBlacklistFiles));
+      createDataFlowSanitizerLegacyPassPass(LangOpts.SanitizerBlocklistFiles));
 }
 
 static TargetLibraryInfoImpl *createTLII(llvm::Triple &TargetTriple,
                                          const CodeGenOptions &CodeGenOpts) {
   TargetLibraryInfoImpl *TLII = new TargetLibraryInfoImpl(TargetTriple);
 
   switch (CodeGenOpts.getVecLib()) {
   case CodeGenOptions::Accelerate:
if (!CodeGenOpts.DisableLLVMPasses) {
     };
     HWASanPass(SanitizerKind::HWAddress, false);
     HWASanPass(SanitizerKind::KernelHWAddress, true);
 
     if (LangOpts.Sanitize.has(SanitizerKind::DataFlow)) {
       PB.registerOptimizerLastEPCallback(
           [this](ModulePassManager &MPM, PassBuilder::OptimizationLevel Level) {
             MPM.addPass(
-                DataFlowSanitizerPass(LangOpts.SanitizerBlacklistFiles));
+                DataFlowSanitizerPass(LangOpts.SanitizerBlocklistFiles));
           });
     }
 
     if (Optional<GCOVOptions> Options = getGCOVOptions(CodeGenOpts, LangOpts))
       PB.registerPipelineStartEPCallback(
           [Options](ModulePassManager &MPM,
                     PassBuilder::OptimizationLevel Level) {
             MPM.addPass(GCOVProfilerPass(*Options));

clang/lib/CodeGen/CGClass.cpp

case CFITCK_UnrelatedCast:
     break;
   case CFITCK_ICall:
   case CFITCK_NVMFCall:
   case CFITCK_VMFCall:
     llvm_unreachable("unexpected sanitizer kind");
   }
 
   std::string TypeName = RD->getQualifiedNameAsString();
-  if (getContext().getSanitizerBlacklist().isBlacklistedType(M, TypeName))
+  if (getContext().getSanitizerBlocklist().isBlocklistedType(M, TypeName))
     return;
 
   SanitizerScope SanScope(this);
   EmitSanitizerStatReport(SSK);
 
   llvm::Metadata *MD =
       CGM.CreateMetadataIdentifierForType(QualType(RD->getTypeForDecl(), 0));
   llvm::Value *TypeId = llvm::MetadataAsValue::get(getLLVMContext(), MD);
bool CodeGenFunction::ShouldEmitVTableTypeCheckedLoad(const CXXRecordDecl *RD) {
   if (CGM.getCodeGenOpts().VirtualFunctionElimination)
     return true;
 
   if (!SanOpts.has(SanitizerKind::CFIVCall) ||
       !CGM.getCodeGenOpts().SanitizeTrap.has(SanitizerKind::CFIVCall))
     return false;
 
   std::string TypeName = RD->getQualifiedNameAsString();
-  return !getContext().getSanitizerBlacklist().isBlacklistedType(
+  return !getContext().getSanitizerBlocklist().isBlocklistedType(
       SanitizerKind::CFIVCall, TypeName);
 }
 
 llvm::Value *CodeGenFunction::EmitVTableTypeCheckedLoad(
     const CXXRecordDecl *RD, llvm::Value *VTable, uint64_t VTableByteOffset) {
   SanitizerScope SanScope(this);
 
   EmitSanitizerStatReport(llvm::SanStat_CFI_VCall);
 
   llvm::Metadata *MD =
       CGM.CreateMetadataIdentifierForType(QualType(RD->getTypeForDecl(), 0));
   llvm::Value *TypeId = llvm::MetadataAsValue::get(CGM.getLLVMContext(), MD);
 
   llvm::Value *CastedVTable = Builder.CreateBitCast(VTable, Int8PtrTy);
   llvm::Value *CheckedLoad = Builder.CreateCall(
       CGM.getIntrinsic(llvm::Intrinsic::type_checked_load),
       {CastedVTable, llvm::ConstantInt::get(Int32Ty, VTableByteOffset),
        TypeId});
   llvm::Value *CheckResult = Builder.CreateExtractValue(CheckedLoad, 1);
 
   std::string TypeName = RD->getQualifiedNameAsString();
   if (SanOpts.has(SanitizerKind::CFIVCall) &&
-      !getContext().getSanitizerBlacklist().isBlacklistedType(
+      !getContext().getSanitizerBlocklist().isBlocklistedType(
           SanitizerKind::CFIVCall, TypeName)) {
     EmitCheck(std::make_pair(CheckResult, SanitizerKind::CFIVCall),
               SanitizerHandler::CFICheckFail, {}, {});
   }
 
   return Builder.CreateBitCast(
       Builder.CreateExtractValue(CheckedLoad, 0),
       cast<llvm::PointerType>(VTable->getType())->getElementType());

clang/lib/CodeGen/CGDeclCXX.cpp

llvm::Function *CodeGenModule::CreateGlobalInitOrCleanUpFunction(
   SetInternalFunctionAttributes(GlobalDecl(), Fn, FI);
 
   Fn->setCallingConv(getRuntimeCC());
 
   if (!getLangOpts().Exceptions)
     Fn->setDoesNotThrow();
 
   if (getLangOpts().Sanitize.has(SanitizerKind::Address) &&
-      !isInSanitizerBlacklist(SanitizerKind::Address, Fn, Loc))
+      !isInSanitizerBlocklist(SanitizerKind::Address, Fn, Loc))
     Fn->addFnAttr(llvm::Attribute::SanitizeAddress);
 
   if (getLangOpts().Sanitize.has(SanitizerKind::KernelAddress) &&
-      !isInSanitizerBlacklist(SanitizerKind::KernelAddress, Fn, Loc))
+      !isInSanitizerBlocklist(SanitizerKind::KernelAddress, Fn, Loc))
     Fn->addFnAttr(llvm::Attribute::SanitizeAddress);
 
   if (getLangOpts().Sanitize.has(SanitizerKind::HWAddress) &&
-      !isInSanitizerBlacklist(SanitizerKind::HWAddress, Fn, Loc))
+      !isInSanitizerBlocklist(SanitizerKind::HWAddress, Fn, Loc))
     Fn->addFnAttr(llvm::Attribute::SanitizeHWAddress);
 
   if (getLangOpts().Sanitize.has(SanitizerKind::KernelHWAddress) &&
-      !isInSanitizerBlacklist(SanitizerKind::KernelHWAddress, Fn, Loc))
+      !isInSanitizerBlocklist(SanitizerKind::KernelHWAddress, Fn, Loc))
     Fn->addFnAttr(llvm::Attribute::SanitizeHWAddress);
 
   if (getLangOpts().Sanitize.has(SanitizerKind::MemTag) &&
-      !isInSanitizerBlacklist(SanitizerKind::MemTag, Fn, Loc))
+      !isInSanitizerBlocklist(SanitizerKind::MemTag, Fn, Loc))
     Fn->addFnAttr(llvm::Attribute::SanitizeMemTag);
 
   if (getLangOpts().Sanitize.has(SanitizerKind::Thread) &&
-      !isInSanitizerBlacklist(SanitizerKind::Thread, Fn, Loc))
+      !isInSanitizerBlocklist(SanitizerKind::Thread, Fn, Loc))
     Fn->addFnAttr(llvm::Attribute::SanitizeThread);
 
   if (getLangOpts().Sanitize.has(SanitizerKind::Memory) &&
-      !isInSanitizerBlacklist(SanitizerKind::Memory, Fn, Loc))
+      !isInSanitizerBlocklist(SanitizerKind::Memory, Fn, Loc))
     Fn->addFnAttr(llvm::Attribute::SanitizeMemory);
 
   if (getLangOpts().Sanitize.has(SanitizerKind::KernelMemory) &&
-      !isInSanitizerBlacklist(SanitizerKind::KernelMemory, Fn, Loc))
+      !isInSanitizerBlocklist(SanitizerKind::KernelMemory, Fn, Loc))
     Fn->addFnAttr(llvm::Attribute::SanitizeMemory);
 
   if (getLangOpts().Sanitize.has(SanitizerKind::SafeStack) &&
-      !isInSanitizerBlacklist(SanitizerKind::SafeStack, Fn, Loc))
+      !isInSanitizerBlocklist(SanitizerKind::SafeStack, Fn, Loc))
     Fn->addFnAttr(llvm::Attribute::SafeStack);
 
   if (getLangOpts().Sanitize.has(SanitizerKind::ShadowCallStack) &&
-      !isInSanitizerBlacklist(SanitizerKind::ShadowCallStack, Fn, Loc))
+      !isInSanitizerBlocklist(SanitizerKind::ShadowCallStack, Fn, Loc))
     Fn->addFnAttr(llvm::Attribute::ShadowCallStack);
 
   return Fn;
 }
 
 /// Create a global pointer to a function that will initialize a global
 /// variable.  The user has requested that this pointer be emitted in a specific
 /// section.

clang/lib/CodeGen/CGExpr.cpp

if (SanOpts.has(SanitizerKind::Vptr) &&
     // FIXME: This is not guaranteed to be deterministic! Move to a
     //        fingerprinting mechanism once LLVM provides one. For the time
     //        being the implementation happens to be deterministic.
     SmallString<64> MangledName;
     llvm::raw_svector_ostream Out(MangledName);
     CGM.getCXXABI().getMangleContext().mangleCXXRTTI(Ty.getUnqualifiedType(),
                                                      Out);
 
-    // Blacklist based on the mangled type.
-    if (!CGM.getContext().getSanitizerBlacklist().isBlacklistedType(
+    // Blocklist based on the mangled type.
+    if (!CGM.getContext().getSanitizerBlocklist().isBlocklistedType(
             SanitizerKind::Vptr, Out.str())) {
       llvm::hash_code TypeHash = hash_value(Out.str());
 
       // Load the vptr, and compute hash_16_bytes(TypeHash, vptr).
       llvm::Value *Low = llvm::ConstantInt::get(Int64Ty, TypeHash);
       llvm::Type *VPtrTy = llvm::PointerType::get(IntPtrTy, 0);
       Address VPtrAddr(Builder.CreateBitCast(Ptr, VPtrTy), getPointerAlign());
       llvm::Value *VPtrVal = Builder.CreateLoad(VPtrAddr);

clang/lib/CodeGen/CodeGenFunction.cpp

if (const auto *FD = dyn_cast_or_null<FunctionDecl>(D))
     if (FD->usesSEHTry())
       CurSEHParent = FD;
   CurFuncDecl = (D ? D->getNonClosureContext() : nullptr);
   FnRetTy = RetTy;
   CurFn = Fn;
   CurFnInfo = &FnInfo;
   assert(CurFn->isDeclaration() && "Function already has body?");
 
-  // If this function has been blacklisted for any of the enabled sanitizers,
+  // If this function has been blocklisted for any of the enabled sanitizers,
   // disable the sanitizer for the function.
   do {
 #define SANITIZER(NAME, ID)                                                    \
   if (SanOpts.empty())                                                         \
     break;                                                                     \
   if (SanOpts.has(SanitizerKind::ID))                                          \
-    if (CGM.isInSanitizerBlacklist(SanitizerKind::ID, Fn, Loc))                \
+    if (CGM.isInSanitizerBlocklist(SanitizerKind::ID, Fn, Loc))                \
       SanOpts.set(SanitizerKind::ID, false);
 
 #include "clang/Basic/Sanitizers.def"
 #undef SANITIZER
   } while (0);
 
   if (D) {
     // Apply the no_sanitize* attributes to SanOpts.

clang/lib/CodeGen/CodeGenModule.h

public:
   llvm::Constant *EmitAnnotateAttr(llvm::GlobalValue *GV,
                                    const AnnotateAttr *AA,
                                    SourceLocation L);
 
   /// Add global annotations that are set on D, for the global GV. Those
   /// annotations are emitted during finalization of the LLVM code.
   void AddGlobalAnnotations(const ValueDecl *D, llvm::GlobalValue *GV);
 
-  bool isInSanitizerBlacklist(SanitizerMask Kind, llvm::Function *Fn,
+  bool isInSanitizerBlocklist(SanitizerMask Kind, llvm::Function *Fn,
                               SourceLocation Loc) const;
 
-  bool isInSanitizerBlacklist(llvm::GlobalVariable *GV, SourceLocation Loc,
+  bool isInSanitizerBlocklist(llvm::GlobalVariable *GV, SourceLocation Loc,
                               QualType Ty,
                               StringRef Category = StringRef()) const;
 
   /// Imbue XRay attributes to a function, applying the always/never attribute
   /// lists in the process. Returns true if we did imbue attributes this way,
   /// false otherwise.
   bool imbueXRayAttrs(llvm::Function *Fn, SourceLocation Loc,
                       StringRef Category = StringRef()) const;

clang/lib/CodeGen/CodeGenModule.cpp

 void CodeGenModule::AddGlobalAnnotations(const ValueDecl *D,
                                          llvm::GlobalValue *GV) {
   assert(D->hasAttr<AnnotateAttr>() && "no annotate attribute");
   // Get the struct elements for these annotations.
   for (const auto *I : D->specific_attrs<AnnotateAttr>())
     Annotations.push_back(EmitAnnotateAttr(GV, I, D->getLocation()));
 }
 
-bool CodeGenModule::isInSanitizerBlacklist(SanitizerMask Kind,
+bool CodeGenModule::isInSanitizerBlocklist(SanitizerMask Kind,
                                            llvm::Function *Fn,
                                            SourceLocation Loc) const {
-  const auto &SanitizerBL = getContext().getSanitizerBlacklist();
-  // Blacklist by function name.
-  if (SanitizerBL.isBlacklistedFunction(Kind, Fn->getName()))
+  const auto &SanitizerBL = getContext().getSanitizerBlocklist();
+  // Blocklist by function name.
+  if (SanitizerBL.isBlocklistedFunction(Kind, Fn->getName()))
     return true;
-  // Blacklist by location.
+  // Blocklist by location.
   if (Loc.isValid())
-    return SanitizerBL.isBlacklistedLocation(Kind, Loc);
+    return SanitizerBL.isBlocklistedLocation(Kind, Loc);
   // If location is unknown, this may be a compiler-generated function. Assume
   // it's located in the main file.
   auto &SM = Context.getSourceManager();
   if (const auto *MainFile = SM.getFileEntryForID(SM.getMainFileID())) {
-    return SanitizerBL.isBlacklistedFile(Kind, MainFile->getName());
+    return SanitizerBL.isBlocklistedFile(Kind, MainFile->getName());
   }
   return false;
 }
 
-bool CodeGenModule::isInSanitizerBlacklist(llvm::GlobalVariable *GV,
+bool CodeGenModule::isInSanitizerBlocklist(llvm::GlobalVariable *GV,
                                            SourceLocation Loc, QualType Ty,
                                            StringRef Category) const {
-  // For now globals can be blacklisted only in ASan and KASan.
+  // For now globals can be blocklisted only in ASan and KASan.
   const SanitizerMask EnabledAsanMask =
       LangOpts.Sanitize.Mask &
       (SanitizerKind::Address | SanitizerKind::KernelAddress |
        SanitizerKind::HWAddress | SanitizerKind::KernelHWAddress |
        SanitizerKind::MemTag);
   if (!EnabledAsanMask)
     return false;
-  const auto &SanitizerBL = getContext().getSanitizerBlacklist();
-  if (SanitizerBL.isBlacklistedGlobal(EnabledAsanMask, GV->getName(), Category))
+  const auto &SanitizerBL = getContext().getSanitizerBlocklist();
+  if (SanitizerBL.isBlocklistedGlobal(EnabledAsanMask, GV->getName(), Category))
     return true;
-  if (SanitizerBL.isBlacklistedLocation(EnabledAsanMask, Loc, Category))
+  if (SanitizerBL.isBlocklistedLocation(EnabledAsanMask, Loc, Category))
     return true;
   // Check global type.
   if (!Ty.isNull()) {
     // Drill down the array types: if global variable of a fixed type is
-    // blacklisted, we also don't instrument arrays of them.
+    // blocklisted, we also don't instrument arrays of them.
     while (auto AT = dyn_cast<ArrayType>(Ty.getTypePtr()))
       Ty = AT->getElementType();
     Ty = Ty.getCanonicalType().getUnqualifiedType();
-    // We allow to blacklist only record types (classes, structs etc.)
+    // We allow to blocklist only record types (classes, structs etc.)
     if (Ty->isRecordType()) {
       std::string TypeStr = Ty.getAsString(getContext().getPrintingPolicy());
-      if (SanitizerBL.isBlacklistedType(EnabledAsanMask, TypeStr, Category))
+      if (SanitizerBL.isBlocklistedType(EnabledAsanMask, TypeStr, Category))
         return true;
     }
   }
   return false;
 }
 
 bool CodeGenModule::imbueXRayAttrs(llvm::Function *Fn, SourceLocation Loc,
                                    StringRef Category) const {

clang/lib/CodeGen/SanitizerMetadata.cpp

 }
 
 void SanitizerMetadata::reportGlobalToASan(llvm::GlobalVariable *GV,
                                            SourceLocation Loc, StringRef Name,
                                            QualType Ty, bool IsDynInit,
                                            bool IsExcluded) {
   if (!isAsanHwasanOrMemTag(CGM.getLangOpts().Sanitize))
     return;
-  IsDynInit &= !CGM.isInSanitizerBlacklist(GV, Loc, Ty, "init");
-  IsExcluded |= CGM.isInSanitizerBlacklist(GV, Loc, Ty);
+  IsDynInit &= !CGM.isInSanitizerBlocklist(GV, Loc, Ty, "init");
+  IsExcluded |= CGM.isInSanitizerBlocklist(GV, Loc, Ty);
 
   llvm::Metadata *LocDescr = nullptr;
   llvm::Metadata *GlobalName = nullptr;
   llvm::LLVMContext &VMContext = CGM.getLLVMContext();
   if (!IsExcluded) {
     // Don't generate source location and global name if it is blacklisted -
     // it won't be instrumented anyway.
     LocDescr = getLocationMetadata(Loc);

clang/lib/Driver/SanitizerArgs.cpp

if (!SCL.get())
     D.Diag(MalformedSCLErrorDiagID) << BLError;
 }
 
 static void addDefaultBlacklists(const Driver &D, SanitizerMask Kinds,
                                  std::vector<std::string> &BlacklistFiles) {
   struct Blacklist {
     const char *File;
     SanitizerMask Mask;
-  } Blacklists[] = {{"asan_blacklist.txt", SanitizerKind::Address},
-                    {"hwasan_blacklist.txt", SanitizerKind::HWAddress},
-                    {"memtag_blacklist.txt", SanitizerKind::MemTag},
-                    {"msan_blacklist.txt", SanitizerKind::Memory},
-                    {"tsan_blacklist.txt", SanitizerKind::Thread},
+  } Blacklists[] = {{"asan_blocklist.txt", SanitizerKind::Address},
+                    {"hwasan_blocklist.txt", SanitizerKind::HWAddress},
+                    {"memtag_blocklist.txt", SanitizerKind::MemTag},
+                    {"msan_blocklist.txt", SanitizerKind::Memory},
+                    {"tsan_blocklist.txt", SanitizerKind::Thread},
                     {"dfsan_abilist.txt", SanitizerKind::DataFlow},
-                    {"cfi_blacklist.txt", SanitizerKind::CFI},
-                    {"ubsan_blacklist.txt",
+                    {"cfi_blocklist.txt", SanitizerKind::CFI},
+                    {"ubsan_blocklist.txt",
                      SanitizerKind::Undefined | SanitizerKind::Integer |
                          SanitizerKind::Nullability |
                          SanitizerKind::FloatDivideByZero}};
 
   for (auto BL : Blacklists) {
     if (!(Kinds & BL.Mask))
       continue;
 
for (const auto *Arg : Args) {
     }
   }
   RecoverableKinds &= Kinds;
   RecoverableKinds &= ~Unrecoverable;
 
   TrappingKinds &= Kinds;
   RecoverableKinds &= ~TrappingKinds;
 
-  // Setup blacklist files.
-  // Add default blacklist from resource directory for activated sanitizers, and
+  // Setup blocklist files.
+  // Add default blocklist from resource directory for activated sanitizers, and
   // validate special case lists format.
-  if (!Args.hasArgNoClaim(options::OPT_fno_sanitize_blacklist))
+  if (!Args.hasArgNoClaim(options::OPT_fno_sanitize_blocklist))
     addDefaultBlacklists(D, Kinds, SystemBlacklistFiles);
 
-  // Parse -f(no-)?sanitize-blacklist options.
+  // Parse -f(no-)?sanitize-blocklist options.
   // This also validates special case lists format.
   parseSpecialCaseListArg(D, Args, UserBlacklistFiles,
-                          options::OPT_fsanitize_blacklist,
-                          options::OPT_fno_sanitize_blacklist,
+                          options::OPT_fsanitize_blocklist,
+                          options::OPT_fno_sanitize_blocklist,
                           clang::diag::err_drv_malformed_sanitizer_blacklist);
 
   // Parse -f[no-]sanitize-memory-track-origins[=level] options.
   if (AllAddedKinds & SanitizerKind::Memory) {
     if (Arg *A =
             Args.getLastArg(options::OPT_fsanitize_memory_track_origins_EQ,
                             options::OPT_fsanitize_memory_track_origins,
                             options::OPT_fno_sanitize_memory_track_origins)) {
if (CoverageFeatures &
         (CoverageTracePC | CoverageTracePCGuard | CoverageInline8bitCounters |
          CoverageInlineBoolFlag))
       CoverageFeatures |= CoverageEdge;
 
     if (CoverageFeatures & CoverageStackDepth)
       CoverageFeatures |= CoverageFunc;
   }
 
-  // Parse -fsanitize-coverage-(black|white)list options if coverage enabled.
+  // Parse -fsanitize-coverage-(block|white)list options if coverage enabled.
   // This also validates special case lists format.
   // Here, OptSpecifier() acts as a never-matching command-line argument.
   // So, there is no way to clear coverage lists but you can append to them.
   if (CoverageFeatures) {
     parseSpecialCaseListArg(
         D, Args, CoverageAllowlistFiles,
         options::OPT_fsanitize_coverage_allowlist, OptSpecifier(),
         clang::diag::err_drv_malformed_sanitizer_coverage_whitelist);
if (!RecoverableSanitizers.empty())
     CmdArgs.push_back(Args.MakeArgString("-fsanitize-recover=" +
                                          toString(RecoverableSanitizers)));
 
   if (!TrapSanitizers.empty())
     CmdArgs.push_back(
         Args.MakeArgString("-fsanitize-trap=" + toString(TrapSanitizers)));
 
   addSpecialCaseListOpt(Args, CmdArgs,
-                        "-fsanitize-blacklist=", UserBlacklistFiles);
+                        "-fsanitize-blocklist=", UserBlacklistFiles);
   addSpecialCaseListOpt(Args, CmdArgs,
-                        "-fsanitize-system-blacklist=", SystemBlacklistFiles);
+                        "-fsanitize-system-blocklist=", SystemBlacklistFiles);
 
   if (MsanTrackOrigins)
     CmdArgs.push_back(Args.MakeArgString("-fsanitize-memory-track-origins=" +
                                          Twine(MsanTrackOrigins)));
 
   if (MsanUseAfterDtor)
     CmdArgs.push_back("-fsanitize-memory-use-after-dtor");
 

clang/lib/Frontend/CompilerInvocation.cpp

if (Args.hasArg(OPT_show_includes)) {
     // This behaves the same as cl.exe, when /E, /EP or /P are passed.
     if (Args.hasArg(options::OPT_E) || Args.hasArg(options::OPT_P))
       Opts.ShowIncludesDest = ShowIncludesDestination::Stderr;
     else
       Opts.ShowIncludesDest = ShowIncludesDestination::Stdout;
   } else {
     Opts.ShowIncludesDest = ShowIncludesDestination::None;
   }
-  // Add sanitizer blacklists as extra dependencies.
+  // Add sanitizer blocklists as extra dependencies.
   // They won't be discovered by the regular preprocessor, so
   // we let make / ninja to know about this implicit dependency.
-  if (!Args.hasArg(OPT_fno_sanitize_blacklist)) {
-    for (const auto *A : Args.filtered(OPT_fsanitize_blacklist)) {
+  if (!Args.hasArg(OPT_fno_sanitize_blocklist)) {
+    for (const auto *A : Args.filtered(OPT_fsanitize_blocklist)) {
       StringRef Val = A->getValue();
       if (Val.find('=') == StringRef::npos)
         Opts.ExtraDeps.push_back(std::string(Val));
     }
     if (Opts.IncludeSystemHeaders) {
-      for (const auto *A : Args.filtered(OPT_fsanitize_system_blacklist)) {
+      for (const auto *A : Args.filtered(OPT_fsanitize_system_blocklist)) {
         StringRef Val = A->getValue();
         if (Val.find('=') == StringRef::npos)
           Opts.ExtraDeps.push_back(std::string(Val));
       }
     }
   }
 
   // -fprofile-list= dependencies.
else if (Val == "fast-honor-pragmas")
       Opts.setDefaultFPContractMode(LangOptions::FPM_FastHonorPragmas);
     else
       Diags.Report(diag::err_drv_invalid_value) << A->getAsString(Args) << Val;
   }
 
   // Parse -fsanitize= arguments.
   parseSanitizerKinds("-fsanitize=", Args.getAllArgValues(OPT_fsanitize_EQ),
                       Diags, Opts.Sanitize);
-  std::vector<std::string> systemBlacklists =
-      Args.getAllArgValues(OPT_fsanitize_system_blacklist);
-  Opts.SanitizerBlacklistFiles.insert(Opts.SanitizerBlacklistFiles.end(),
-                                      systemBlacklists.begin(),
-                                      systemBlacklists.end());
+  std::vector<std::string> systemBlocklists =
+      Args.getAllArgValues(OPT_fsanitize_system_blocklist);
+  Opts.SanitizerBlocklistFiles.insert(Opts.SanitizerBlocklistFiles.end(),
+                                      systemBlocklists.begin(),
+                                      systemBlocklists.end());
 
   if (Arg *A = Args.getLastArg(OPT_fclang_abi_compat_EQ)) {
     Opts.setClangABICompat(LangOptions::ClangABI::Latest);
 
     StringRef Ver = A->getValue();
     std::pair<StringRef, StringRef> VerParts = Ver.split('.');
     unsigned Major, Minor = 0;
 

clang/test/Driver/fsanitize-blacklist.c

-// General blacklist usage.
+// General blocklist usage.
 
 // PR12920
 // REQUIRES: clang-driver
 
 // Make sure we don't match the -NOT lines with the linker invocation.
 // Delimiters match the start of the cc1 and the start of the linker lines
 // for fragile tests.
 // DELIMITERS: {{^ (\(in-process\)|")}}
 
 // RUN: echo "fun:foo" > %t.good
 // RUN: echo "fun:bar" > %t.second
 // RUN: echo "badline" > %t.bad
 
-// RUN: %clang -target x86_64-linux-gnu -fsanitize=address -fsanitize-blacklist=%t.good -fsanitize-blacklist=%t.second %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-BLACKLIST
-// RUN: %clang -target aarch64-linux-gnu -fsanitize=hwaddress -fsanitize-blacklist=%t.good -fsanitize-blacklist=%t.second %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-BLACKLIST
-// CHECK-BLACKLIST: -fsanitize-blacklist={{.*}}.good" "-fsanitize-blacklist={{.*}}.second
-
-// Check that the default blacklist is not added as an extra dependency.
-// RUN: %clang -target x86_64-linux-gnu -fsanitize=address -resource-dir=%S/Inputs/resource_dir %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-DEFAULT-BLACKLIST-ASAN --implicit-check-not=fdepfile-entry --implicit-check-not=-fsanitize-blacklist=
-// CHECK-DEFAULT-BLACKLIST-ASAN: -fsanitize-system-blacklist={{.*[^w]}}asan_blacklist.txt
-// RUN: %clang -target x86_64-linux-gnu -fsanitize=hwaddress -resource-dir=%S/Inputs/resource_dir %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-DEFAULT-BLACKLIST-HWASAN --implicit-check-not=fdepfile-entry --implicit-check-not=-fsanitize-blacklist=
-// CHECK-DEFAULT-BLACKLIST-HWASAN: -fsanitize-system-blacklist={{.*}}hwasan_blacklist.txt
-
-// RUN: %clang -target x86_64-linux-gnu -fsanitize=integer -resource-dir=%S/Inputs/resource_dir %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-DEFAULT-UBSAN-BLACKLIST --implicit-check-not=fdepfile-entry --implicit-check-not=-fsanitize-blacklist=
-// RUN: %clang -target x86_64-linux-gnu -fsanitize=nullability -resource-dir=%S/Inputs/resource_dir %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-DEFAULT-UBSAN-BLACKLIST --implicit-check-not=fdepfile-entry --implicit-check-not=-fsanitize-blacklist=
-// RUN: %clang -target x86_64-linux-gnu -fsanitize=undefined -resource-dir=%S/Inputs/resource_dir %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-DEFAULT-UBSAN-BLACKLIST --implicit-check-not=fdepfile-entry --implicit-check-not=-fsanitize-blacklist=
-// RUN: %clang -target x86_64-linux-gnu -fsanitize=alignment -resource-dir=%S/Inputs/resource_dir %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-DEFAULT-UBSAN-BLACKLIST --implicit-check-not=fdepfile-entry --implicit-check-not=-fsanitize-blacklist=
-// RUN: %clang -target %itanium_abi_triple -fsanitize=float-divide-by-zero -resource-dir=%S/Inputs/resource_dir %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-DEFAULT-UBSAN-BLACKLIST --implicit-check-not=fdepfile-entry --implicit-check-not=-fsanitize-blacklist=
-// CHECK-DEFAULT-UBSAN-BLACKLIST: -fsanitize-system-blacklist={{.*}}ubsan_blacklist.txt
-
-// Check that combining ubsan and another sanitizer results in both blacklists being used.
-// RUN: %clang -target x86_64-linux-gnu -fsanitize=undefined,address -resource-dir=%S/Inputs/resource_dir %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-DEFAULT-UBSAN-BLACKLIST --check-prefix=CHECK-DEFAULT-BLACKLIST-ASAN --implicit-check-not=fdepfile-entry --implicit-check-not=-fsanitize-blacklist=
-
-// Ignore -fsanitize-blacklist flag if there is no -fsanitize flag.
-// RUN: %clang -target x86_64-linux-gnu -fsanitize-blacklist=%t.good %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-NO-SANITIZE --check-prefix=DELIMITERS
-// CHECK-NO-SANITIZE-NOT: -fsanitize-blacklist
+// RUN: %clang -target x86_64-linux-gnu -fsanitize=address -fsanitize-blocklist=%t.good -fsanitize-blocklist=%t.second %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-BLOCKLIST
+// RUN: %clang -target aarch64-linux-gnu -fsanitize=hwaddress -fsanitize-blocklist=%t.good -fsanitize-blocklist=%t.second %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-BLOCKLIST
+// CHECK-BLOCKLIST: -fsanitize-blocklist={{.*}}.good" "-fsanitize-blocklist={{.*}}.second
+
+// Check that the default blocklist is not added as an extra dependency.
+// RUN: %clang -target x86_64-linux-gnu -fsanitize=address -resource-dir=%S/Inputs/resource_dir %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-DEFAULT-BLOCKLIST-ASAN --implicit-check-not=fdepfile-entry --implicit-check-not=-fsanitize-blocklist=
+// CHECK-DEFAULT-BLOCKLIST-ASAN: -fsanitize-system-blocklist={{.*[^w]}}asan_blocklist.txt
+// RUN: %clang -target x86_64-linux-gnu -fsanitize=hwaddress -resource-dir=%S/Inputs/resource_dir %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-DEFAULT-BLOCKLIST-HWASAN --implicit-check-not=fdepfile-entry --implicit-check-not=-fsanitize-blocklist=
+// CHECK-DEFAULT-BLOCKLIST-HWASAN: -fsanitize-system-blocklist={{.*}}hwasan_blocklist.txt
+
+// RUN: %clang -target x86_64-linux-gnu -fsanitize=integer -resource-dir=%S/Inputs/resource_dir %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-DEFAULT-UBSAN-BLOCKLIST --implicit-check-not=fdepfile-entry --implicit-check-not=-fsanitize-blocklist=
+// RUN: %clang -target x86_64-linux-gnu -fsanitize=nullability -resource-dir=%S/Inputs/resource_dir %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-DEFAULT-UBSAN-BLOCKLIST --implicit-check-not=fdepfile-entry --implicit-check-not=-fsanitize-blocklist=
+// RUN: %clang -target x86_64-linux-gnu -fsanitize=undefined -resource-dir=%S/Inputs/resource_dir %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-DEFAULT-UBSAN-BLOCKLIST --implicit-check-not=fdepfile-entry --implicit-check-not=-fsanitize-blocklist=
+// RUN: %clang -target x86_64-linux-gnu -fsanitize=alignment -resource-dir=%S/Inputs/resource_dir %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-DEFAULT-UBSAN-BLOCKLIST --implicit-check-not=fdepfile-entry --implicit-check-not=-fsanitize-blocklist=
+// RUN: %clang -target %itanium_abi_triple -fsanitize=float-divide-by-zero -resource-dir=%S/Inputs/resource_dir %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-DEFAULT-UBSAN-BLOCKLIST --implicit-check-not=fdepfile-entry --implicit-check-not=-fsanitize-blocklist=
+// CHECK-DEFAULT-UBSAN-BLOCKLIST: -fsanitize-system-blocklist={{.*}}ubsan_blocklist.txt
+
+// Check that combining ubsan and another sanitizer results in both blocklists being used.
+// RUN: %clang -target x86_64-linux-gnu -fsanitize=undefined,address -resource-dir=%S/Inputs/resource_dir %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-DEFAULT-UBSAN-BLOCKLIST --check-prefix=CHECK-DEFAULT-BLOCKLIST-ASAN --implicit-check-not=fdepfile-entry --implicit-check-not=-fsanitize-blocklist=
+
+// Ignore -fsanitize-blocklist flag if there is no -fsanitize flag.
+// RUN: %clang -target x86_64-linux-gnu -fsanitize-blocklist=%t.good %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-NO-SANITIZE --check-prefix=DELIMITERS
+// CHECK-NO-SANITIZE-NOT: -fsanitize-blocklist
 
-// Ignore -fsanitize-blacklist flag if there is no -fsanitize flag.
+// Ignore -fsanitize-blocklist flag if there is no -fsanitize flag.
 // Now, check for the absence of -fdepfile-entry flags.
-// RUN: %clang -target x86_64-linux-gnu -fsanitize-blacklist=%t.good %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-NO-SANITIZE2 --check-prefix=DELIMITERS
+// RUN: %clang -target x86_64-linux-gnu -fsanitize-blocklist=%t.good %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-NO-SANITIZE2 --check-prefix=DELIMITERS
 // CHECK-NO-SANITIZE2-NOT: -fdepfile-entry
 
-// Flag -fno-sanitize-blacklist wins if it is specified later.
-// RUN: %clang -target x86_64-linux-gnu -fsanitize=address -fsanitize-blacklist=%t.good -fno-sanitize-blacklist %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-NO-BLACKLIST --check-prefix=DELIMITERS
-// CHECK-NO-BLACKLIST-NOT: -fsanitize-blacklist
+// Flag -fno-sanitize-blocklist wins if it is specified later.
+// RUN: %clang -target x86_64-linux-gnu -fsanitize=address -fsanitize-blocklist=%t.good -fno-sanitize-blocklist %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-NO-BLOCKLIST --check-prefix=DELIMITERS
+// CHECK-NO-BLOCKLIST-NOT: -fsanitize-blocklist
 
-// Driver barks on unexisting blacklist files.
-// RUN: %clang -target x86_64-linux-gnu -fno-sanitize-blacklist -fsanitize-blacklist=unexisting.txt %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-NO-SUCH-FILE
+// Driver barks on unexisting blocklist files.
+// RUN: %clang -target x86_64-linux-gnu -fno-sanitize-blocklist -fsanitize-blocklist=unexisting.txt %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-NO-SUCH-FILE
 // CHECK-NO-SUCH-FILE: error: no such file or directory: 'unexisting.txt'
 
-// Driver properly reports malformed blacklist files.
-// RUN: %clang -target x86_64-linux-gnu -fsanitize=address -fsanitize-blacklist=%t.second -fsanitize-blacklist=%t.bad -fsanitize-blacklist=%t.good %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-BAD-BLACKLIST
-// CHECK-BAD-BLACKLIST: error: malformed sanitizer blacklist: 'error parsing file '{{.*}}.bad': malformed line 1: 'badline''
+// Driver properly reports malformed blocklist files.
+// RUN: %clang -target x86_64-linux-gnu -fsanitize=address -fsanitize-blocklist=%t.second -fsanitize-blocklist=%t.bad -fsanitize-blocklist=%t.good %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-BAD-BLOCKLIST
+// CHECK-BAD-BLOCKLIST: error: malformed sanitizer blacklist: 'error parsing file '{{.*}}.bad': malformed line 1: 'badline''
 
-// -fno-sanitize-blacklist disables all blacklists specified earlier.
-// RUN: %clang -target x86_64-linux-gnu -fsanitize=address -fsanitize-blacklist=%t.good -fno-sanitize-blacklist -fsanitize-blacklist=%t.second %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-ONLY-FIRST-DISABLED --implicit-check-not=-fsanitize-blacklist=
+// -fno-sanitize-blocklist disables all blocklists specified earlier.
+// RUN: %clang -target x86_64-linux-gnu -fsanitize=address -fsanitize-blocklist=%t.good -fno-sanitize-blocklist -fsanitize-blocklist=%t.second %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-ONLY-FIRST-DISABLED --implicit-check-not=-fsanitize-blocklist=
 // CHECK-ONLY_FIRST-DISABLED-NOT: good
-// CHECK-ONLY-FIRST-DISABLED: -fsanitize-blacklist={{.*}}.second
+// CHECK-ONLY-FIRST-DISABLED: -fsanitize-blocklist={{.*}}.second
 // CHECK-ONLY_FIRST-DISABLED-NOT: good
 
-// -fno-sanitize-blacklist disables the system blacklists.
-// RUN: %clang -target x86_64-linux-gnu -fsanitize=address -fno-sanitize-blacklist %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-DISABLED-SYSTEM --check-prefix=DELIMITERS
-// CHECK-DISABLED-SYSTEM-NOT: -fsanitize-system-blacklist
-
-// If cfi_blacklist.txt cannot be found in the resource dir, driver should fail.
-// RUN: %clang -target x86_64-linux-gnu -fsanitize=cfi -flto -fvisibility=default -resource-dir=/dev/null %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-MISSING-CFI-BLACKLIST
-// CHECK-MISSING-CFI-BLACKLIST: error: no such file or directory: '{{.*}}cfi_blacklist.txt'
-
-// -fno-sanitize-blacklist disables checking for cfi_blacklist.txt in the resource dir.
-// RUN: %clang -target x86_64-linux-gnu -fsanitize=cfi -flto -fvisibility=default -fno-sanitize-blacklist -resource-dir=/dev/null %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-MISSING-CFI-NO-BLACKLIST
-// CHECK-MISSING-CFI-NO-BLACKLIST-NOT: error: no such file or directory: '{{.*}}cfi_blacklist.txt'
+// -fno-sanitize-blocklist disables the system blocklists.
+// RUN: %clang -target x86_64-linux-gnu -fsanitize=address -fno-sanitize-blocklist %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-DISABLED-SYSTEM --check-prefix=DELIMITERS
+// CHECK-DISABLED-SYSTEM-NOT: -fsanitize-system-blocklist
+
+// If cfi_blocklist.txt cannot be found in the resource dir, driver should fail.
+// RUN: %clang -target x86_64-linux-gnu -fsanitize=cfi -flto -fvisibility=default -resource-dir=/dev/null %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-MISSING-CFI-BLOCKLIST
+// CHECK-MISSING-CFI-BLOCKLIST: error: no such file or directory: '{{.*}}cfi_blocklist.txt'
+
+// -fno-sanitize-blocklist disables checking for cfi_blocklist.txt in the resource dir.
+// RUN: %clang -target x86_64-linux-gnu -fsanitize=cfi -flto -fvisibility=default -fno-sanitize-blocklist -resource-dir=/dev/null %s -### 2>&1 | FileCheck %s --check-prefix=CHECK-MISSING-CFI-NO-BLOCKLIST
+// CHECK-MISSING-CFI-NO-BLOCKLIST-NOT: error: no such file or directory: '{{.*}}cfi_blocklist.txt'
 
 // DELIMITERS: {{^ *"}}

clang/test/Driver/print-file-name.c

 // Test that -print-file-name finds the correct file.
 
-// RUN: %clang -print-file-name=share/asan_blacklist.txt 2>&1 \
+// RUN: %clang -print-file-name=share/asan_blocklist.txt 2>&1 \
 // RUN:     -resource-dir=%S/Inputs/resource_dir \
 // RUN:     --target=x86_64-linux-gnu \
 // RUN:   | FileCheck --check-prefix=CHECK-RESOURCE-DIR %s
-// CHECK-RESOURCE-DIR: resource_dir{{/|\\}}share{{/|\\}}asan_blacklist.txt
+// CHECK-RESOURCE-DIR: resource_dir{{/|\\}}share{{/|\\}}asan_blocklist.txt
 
 // RUN: %clang -print-file-name=libclang_rt.builtins.a 2>&1 \
 // RUN:     -resource-dir=%S/Inputs/resource_dir_with_per_target_subdir \
 // RUN:     --target=x86_64-linux-gnu \
 // RUN:   | FileCheck --check-prefix=CHECK-COMPILER-RT %s
 // CHECK-COMPILER-RT: resource_dir_with_per_target_subdir{{/|\\}}lib{{/|\\}}x86_64-linux-gnu{{/|\\}}libclang_rt.builtins.a
 
 // RUN: %clang -print-file-name=include/c++/v1 2>&1 \
 // RUN:     -ccc-install-dir %S/Inputs/basic_linux_libcxx_tree/usr/bin \
 // RUN:     --target=x86_64-linux-gnu \
 // RUN:   | FileCheck --check-prefix=CHECK-INSTALL-DIR %s
 // CHECK-INSTALL-DIR: basic_linux_libcxx_tree{{/|\\}}usr{{/|\\}}bin{{/|\\}}..{{/|\\}}include{{/|\\}}c++{{/|\\}}v1

clang/test/Frontend/dependency-gen.c

 // CHECK-THREE: {{ }}a{{[/\\]}}b{{[/\\]}}x.h
 // RUN: %clang -MD -MF - %s -fsyntax-only -I .//./a/b/ | FileCheck -check-prefix=CHECK-FOUR %s
 // CHECK-FOUR: {{ }}a{{[/\\]}}b{{[/\\]}}x.h
 // RUN: %clang -MD -MF - %s -fsyntax-only -I a/b/. | FileCheck -check-prefix=CHECK-FIVE %s
 // CHECK-FIVE: {{ }}a{{[/\\]}}b{{[/\\]}}.{{[/\\]}}x.h
 // RUN: cd a/b
 // RUN: %clang -MD -MF - %s -fsyntax-only -I ./ | FileCheck -check-prefix=CHECK-SIX %s
 // CHECK-SIX: {{ }}x.h
-// RUN: echo "fun:foo" > %t.blacklist
-// RUN: %clang -MD -MF - %s -fsyntax-only -resource-dir=%S/Inputs/resource_dir_with_sanitizer_blacklist -fsanitize=undefined -flto -fvisibility=hidden -fsanitize-blacklist=%t.blacklist -I ./ | FileCheck -check-prefix=CHECK-SEVEN %s
-// CHECK-SEVEN: .blacklist
+// RUN: echo "fun:foo" > %t.blocklist
+// RUN: %clang -MD -MF - %s -fsyntax-only -resource-dir=%S/Inputs/resource_dir_with_sanitizer_blacklist -fsanitize=undefined -flto -fvisibility=hidden -fsanitize-blocklist=%t.blocklist -I ./ | FileCheck -check-prefix=CHECK-SEVEN %s
+// CHECK-SEVEN: .blocklist
 // CHECK-SEVEN: {{ }}x.h
 #ifndef INCLUDE_FLAG_TEST
 #include <x.h>
 #endif
 
-// RUN: echo "fun:foo" > %t.blacklist1
-// RUN: echo "fun:foo" > %t.blacklist2
-// RUN: %clang -MD -MF - %s -fsyntax-only -resource-dir=%S/Inputs/resource_dir_with_sanitizer_blacklist -fsanitize=undefined -flto -fvisibility=hidden -fsanitize-blacklist=%t.blacklist1 -fsanitize-blacklist=%t.blacklist2 -I ./ | FileCheck -check-prefix=TWO-BLACK-LISTS %s
-// TWO-BLACK-LISTS: dependency-gen.o:
-// TWO-BLACK-LISTS-DAG: blacklist1
-// TWO-BLACK-LISTS-DAG: blacklist2
-// TWO-BLACK-LISTS-DAG: x.h
-// TWO-BLACK-LISTS-DAG: dependency-gen.c
+// RUN: echo "fun:foo" > %t.blocklist1
+// RUN: echo "fun:foo" > %t.blocklist2
+// RUN: %clang -MD -MF - %s -fsyntax-only -resource-dir=%S/Inputs/resource_dir_with_sanitizer_blacklist -fsanitize=undefined -flto -fvisibility=hidden -fsanitize-blocklist=%t.blocklist1 -fsanitize-blocklist=%t.blocklist2 -I ./ | FileCheck -check-prefix=TWO-BLOCK-LISTS %s
+// TWO-BLOCK-LISTS: dependency-gen.o:
+// TWO-BLOCK-LISTS-DAG: blocklist1
+// TWO-BLOCK-LISTS-DAG: blocklist2
+// TWO-BLOCK-LISTS-DAG: x.h
+// TWO-BLOCK-LISTS-DAG: dependency-gen.c
 
 // RUN: %clang -MD -MF - %s -fsyntax-only -resource-dir=%S/Inputs/resource_dir_with_sanitizer_blacklist -fsanitize=undefined -flto -fvisibility=hidden -I ./ | FileCheck -check-prefix=USER-AND-SYS-DEPS %s
 // USER-AND-SYS-DEPS: dependency-gen.o:
-// USER-AND-SYS-DEPS-DAG: ubsan_blacklist.txt
+// USER-AND-SYS-DEPS-DAG: ubsan_blocklist.txt
 
 // RUN: %clang -MMD -MF - %s -fsyntax-only -resource-dir=%S/Inputs/resource_dir_with_sanitizer_blacklist -fsanitize=undefined -flto -fvisibility=hidden -I ./ | FileCheck -check-prefix=ONLY-USER-DEPS %s
 // ONLY-USER-DEPS: dependency-gen.o:
-// NOT-ONLY-USER-DEPS: ubsan_blacklist.txt
+// NOT-ONLY-USER-DEPS: ubsan_blocklist.txt

clang/unittests/Driver/SanitizerArgsTest.cpp

for (llvm::StringRef F : ExtraFiles)
       FS->addFile(F, time_t(), llvm::MemoryBuffer::getMemBuffer(""));
     return FS;
   }
 
   llvm::Optional<Driver> DriverInstance;
   std::unique_ptr<driver::Compilation> CompilationJob;
 };
 
-TEST_F(SanitizerArgsTest, Blacklists) {
+TEST_F(SanitizerArgsTest, Blocklists) {
   const std::string ResourceDir = "/opt/llvm/lib/resources";
-  const std::string UserBlacklist = "/source/my_blacklist.txt";
-  const std::string ASanBlacklist =
-      concatPaths({ResourceDir, "share", "asan_blacklist.txt"});
+  const std::string UserBlocklist = "/source/my_blocklist.txt";
+  const std::string ASanBlocklist =
+      concatPaths({ResourceDir, "share", "asan_blocklist.txt"});
 
   auto &Command = emulateSingleCompilation(
       /*ExtraArgs=*/{"-fsanitize=address", "-resource-dir", ResourceDir,
-                     std::string("-fsanitize-blacklist=") + UserBlacklist},
-      /*ExtraFiles=*/{ASanBlacklist, UserBlacklist});
+                     std::string("-fsanitize-blocklist=") + UserBlocklist},
+      /*ExtraFiles=*/{ASanBlocklist, UserBlocklist});
 
-  // System blacklists are added based on resource-dir.
+  // System blocklists are added based on resource-dir.
   EXPECT_THAT(Command.getArguments(),
-              Contains(StrEq(std::string("-fsanitize-system-blacklist=") +
-                             ASanBlacklist)));
-  // User blacklists should also be added.
+              Contains(StrEq(std::string("-fsanitize-system-blocklist=") +
+                             ASanBlocklist)));
+  // User blocklists should also be added.
   EXPECT_THAT(
       Command.getArguments(),
-      Contains(StrEq(std::string("-fsanitize-blacklist=") + UserBlacklist)));
+      Contains(StrEq(std::string("-fsanitize-blocklist=") + UserBlocklist)));
 }
 
 TEST_F(SanitizerArgsTest, XRayLists) {
   const std::string XRayWhitelist = "/source/xray_whitelist.txt";
-  const std::string XRayBlacklist = "/source/xray_blacklist.txt";
+  const std::string XRayBlocklist = "/source/xray_blocklist.txt";
   const std::string XRayAttrList = "/source/xray_attr_list.txt";
 
   auto &Command = emulateSingleCompilation(
       /*ExtraArgs=*/
       {
           "-fxray-instrument",
           "-fxray-always-instrument=" + XRayWhitelist,
-          "-fxray-never-instrument=" + XRayBlacklist,
+          "-fxray-never-instrument=" + XRayBlocklist,
           "-fxray-attr-list=" + XRayAttrList,
       },
-      /*ExtraFiles=*/{XRayWhitelist, XRayBlacklist, XRayAttrList});
+      /*ExtraFiles=*/{XRayWhitelist, XRayBlocklist, XRayAttrList});
 
-  // Blacklists exist in the filesystem, so they should be added to the
+  // Blocklists exist in the filesystem, so they should be added to the
   // compilation command, produced by the driver.
   EXPECT_THAT(Command.getArguments(),
               Contains(StrEq("-fxray-always-instrument=" + XRayWhitelist)));
   EXPECT_THAT(Command.getArguments(),
-              Contains(StrEq("-fxray-never-instrument=" + XRayBlacklist)));
+              Contains(StrEq("-fxray-never-instrument=" + XRayBlocklist)));
   EXPECT_THAT(Command.getArguments(),
               Contains(StrEq("-fxray-attr-list=" + XRayAttrList)));
 }
 
 } // namespace