Revert "[-Wunsafe-buffer-usage] Add unsafe buffer checking opt-out pragmas"

This reverts commit aef05b5.
It causes a buildbot failure: https://lab.llvm.org/buildbot/#/builders/216/builds/16879/steps/6/logs/stdio

Author: ziqingluo-90

clang/include/clang/Analysis/Analyses/UnsafeBufferUsage.h

@@ -46,9 +46,6 @@ class UnsafeBufferUsageHandler {
     s += " #>";
     return s;
   }
-
-  /// Returns a reference to the `Preprocessor`:
-  virtual const Preprocessor & getPP() const;
 };
 
 // This function invokes the analysis and allows the caller to react to it

clang/include/clang/Basic/DiagnosticLexKinds.td

@@ -945,15 +945,4 @@ def err_dep_source_scanner_unexpected_tokens_at_import : Error<
 
 }
 
-def err_pp_double_begin_pragma_unsafe_buffer_usage :
-Error<"already inside '#pragma unsafe_buffer_usage'">;
-
-def err_pp_unmatched_end_begin_pragma_unsafe_buffer_usage :
-Error<"not currently inside '#pragma unsafe_buffer_usage'">;
-
-def err_pp_unclosed_pragma_unsafe_buffer_usage :
-Error<"'#pragma unsafe_buffer_usage' was not ended">;
-
-def err_pp_pragma_unsafe_buffer_usage_syntax :
-Error<"Expected 'begin' or 'end'">;
 }

clang/include/clang/Lex/Preprocessor.h

@@ -2688,51 +2688,6 @@ class Preprocessor {
   void emitMacroDeprecationWarning(const Token &Identifier) const;
   void emitRestrictExpansionWarning(const Token &Identifier) const;
   void emitFinalMacroWarning(const Token &Identifier, bool IsUndef) const;
-
-  /// This boolean state keeps track if the current scanned token (by this PP)
-  /// is in an "-Wunsafe-buffer-usage" opt-out region. Assuming PP scans a
-  /// translation unit in a linear order.
-  bool InSafeBufferOptOutRegion = 0;
-
-  /// Hold the start location of the current "-Wunsafe-buffer-usage" opt-out
-  /// region if PP is currently in such a region.  Hold undefined value
-  /// otherwise.
-  SourceLocation CurrentSafeBufferOptOutStart; // It is used to report the start location of an never-closed region.
-
-  // An ordered sequence of "-Wunsafe-buffer-usage" opt-out regions in one
-  // translation unit. Each region is represented by a pair of start and end
-  // locations.  A region is "open" if its' start and end locations are
-  // identical.
-  SmallVector<std::pair<SourceLocation, SourceLocation>, 8> SafeBufferOptOutMap;
-
-public:
-  /// \return true iff the given `Loc` is in a "-Wunsafe-buffer-usage" opt-out
-  /// region.  This `Loc` must be a source location that has been pre-processed.
-  bool isSafeBufferOptOut(const SourceManager&SourceMgr, const SourceLocation &Loc) const;
-
-  /// Alter the state of whether this PP currently is in a
-  /// "-Wunsafe-buffer-usage" opt-out region.
-  ///
-  /// \param isEnter: true if this PP is entering a region; otherwise, this PP
-  /// is exiting a region
-  /// \param Loc: the location of the entry or exit of a
-  /// region
-  /// \return true iff it is INVALID to enter or exit a region, i.e.,
-  /// attempt to enter a region before exiting a previous region, or exiting a
-  /// region that PP is not currently in.
-  bool enterOrExitSafeBufferOptOutRegion(bool isEnter,
-                                         const SourceLocation &Loc);
-
-  /// \return true iff this PP is currently in a "-Wunsafe-buffer-usage"
-  ///          opt-out region
-  bool isPPInSafeBufferOptOutRegion();
-
-  /// \param StartLoc: output argument. It will be set to the start location of
-  /// the current "-Wunsafe-buffer-usage" opt-out region iff this function
-  /// returns true.
-  /// \return true iff this PP is currently in a "-Wunsafe-buffer-usage"
-  ///          opt-out region
-  bool isPPInSafeBufferOptOutRegion(SourceLocation &StartLoc);
 };
 
 /// Abstract base class that describes a handler that will receive

clang/lib/Analysis/UnsafeBufferUsage.cpp

@@ -9,7 +9,6 @@
 #include "clang/Analysis/Analyses/UnsafeBufferUsage.h"
 #include "clang/AST/RecursiveASTVisitor.h"
 #include "clang/ASTMatchers/ASTMatchFinder.h"
-#include "clang/Lex/Preprocessor.h"
 #include "clang/Lex/Lexer.h"
 #include "llvm/ADT/SmallVector.h"
 #include <memory>
@@ -118,12 +117,6 @@ AST_MATCHER_P(Stmt, forEveryDescendant, internal::Matcher<Stmt>, innerMatcher) {
   return Visitor.findMatch(DynTypedNode::create(Node));
 }
 
-// Matches a `Stmt` node iff the node is in a safe-buffer opt-out region
-AST_MATCHER_P(Stmt, notInSafeBufferOptOut, const Preprocessor *, PP) {
-  const SourceManager &SM = Finder->getASTContext().getSourceManager();
-  return !PP->isSafeBufferOptOut(SM, Node.getBeginLoc());
-}
-
 AST_MATCHER_P(CastExpr, castSubExpr, internal::Matcher<Expr>, innerMatcher) {
   return innerMatcher.matches(*Node.getSubExpr(), Finder, Builder);
 }
@@ -555,8 +548,7 @@ class Strategy {
 } // namespace
 
 /// Scan the function and return a list of gadgets found with provided kits.
-static std::tuple<FixableGadgetList, WarningGadgetList, DeclUseTracker>
-findGadgets(const Decl *D, const Preprocessor &PP) {
+static std::tuple<FixableGadgetList, WarningGadgetList, DeclUseTracker> findGadgets(const Decl *D) {
 
   struct GadgetFinderCallback : MatchFinder::MatchCallback {
     FixableGadgetList FixableGadgets;
@@ -628,7 +620,7 @@ findGadgets(const Decl *D, const Preprocessor &PP) {
       stmt(anyOf(
         // Add Gadget::matcher() for every gadget in the registry.
 #define WARNING_GADGET(x)                                                              \
-        allOf(x ## Gadget::matcher().bind(#x), notInSafeBufferOptOut(&PP)),
+        x ## Gadget::matcher().bind(#x),
 #include "clang/Analysis/Analyses/UnsafeBufferUsageGadgets.def"
         // In parallel, match all DeclRefExprs so that to find out
         // whether there are any uncovered by gadgets.
@@ -1017,7 +1009,7 @@ void clang::checkUnsafeBufferUsage(const Decl *D,
   DeclUseTracker Tracker;
 
   {
-    auto [FixableGadgets, WarningGadgets, TrackerRes] = findGadgets(D, Handler.getPP());
+    auto [FixableGadgets, WarningGadgets, TrackerRes] = findGadgets(D);
     UnsafeOps = groupWarningGadgetsByVar(std::move(WarningGadgets));
     FixablesForUnsafeVars = groupFixablesByVar(std::move(FixableGadgets));
     Tracker = std::move(TrackerRes);

clang/lib/Lex/PPLexerChange.cpp

@@ -333,15 +333,6 @@ bool Preprocessor::HandleEndOfFile(Token &Result, bool isEndOfMacro) {
   assert(!CurTokenLexer &&
          "Ending a file when currently in a macro!");
 
-  SourceLocation UnclosedSafeBufferOptOutLoc;
-
-  if (IncludeMacroStack.empty() &&
-      isPPInSafeBufferOptOutRegion(UnclosedSafeBufferOptOutLoc)) {
-    // To warn if a "-Wunsafe-buffer-usage" opt-out region is still open by the
-    // end of a file.
-    Diag(UnclosedSafeBufferOptOutLoc,
-         diag::err_pp_unclosed_pragma_unsafe_buffer_usage);
-  }
   // If we have an unclosed module region from a pragma at the end of a
   // module, complain and close it now.
   const bool LeavingSubmodule = CurLexer && CurLexerSubmodule;

clang/lib/Lex/Pragma.cpp

@@ -1243,32 +1243,6 @@ struct PragmaDebugHandler : public PragmaHandler {
 #endif
 };
 
-struct PragmaUnsafeBufferUsageHandler : public PragmaHandler {
-  PragmaUnsafeBufferUsageHandler() : PragmaHandler("unsafe_buffer_usage") {}
-  void HandlePragma(Preprocessor &PP, PragmaIntroducer Introducer,
-                    Token &FirstToken) override {
-    Token Tok;
-
-    PP.LexUnexpandedToken(Tok);
-    if (Tok.isNot(tok::identifier)) {
-      PP.Diag(Tok, diag::err_pp_pragma_unsafe_buffer_usage_syntax);
-      return;
-    }
-
-    IdentifierInfo *II = Tok.getIdentifierInfo();
-    SourceLocation Loc = Tok.getLocation();
-
-    if (II->isStr("begin")) {
-      if (PP.enterOrExitSafeBufferOptOutRegion(true, Loc))
-        PP.Diag(Loc, diag::err_pp_double_begin_pragma_unsafe_buffer_usage);
-    } else if (II->isStr("end")) {
-      if (PP.enterOrExitSafeBufferOptOutRegion(false, Loc))
-        PP.Diag(Loc, diag::err_pp_unmatched_end_begin_pragma_unsafe_buffer_usage);
-    } else
-      PP.Diag(Tok, diag::err_pp_pragma_unsafe_buffer_usage_syntax);
-  }
-};
-
 /// PragmaDiagnosticHandler - e.g. '\#pragma GCC diagnostic ignored "-Wformat"'
 struct PragmaDiagnosticHandler : public PragmaHandler {
 private:
@@ -2154,9 +2128,6 @@ void Preprocessor::RegisterBuiltinPragmas() {
   ModuleHandler->AddPragma(new PragmaModuleBuildHandler());
   ModuleHandler->AddPragma(new PragmaModuleLoadHandler());
 
-  // Safe Buffers pragmas
-  AddPragmaHandler("clang", new PragmaUnsafeBufferUsageHandler);
-
   // Add region pragmas.
   AddPragmaHandler(new PragmaRegionHandler("region"));
   AddPragmaHandler(new PragmaRegionHandler("endregion"));

clang/lib/Lex/Preprocessor.cpp

@@ -1462,75 +1462,6 @@ void Preprocessor::emitFinalMacroWarning(const Token &Identifier,
   Diag(*A.FinalAnnotationLoc, diag::note_pp_macro_annotation) << 2;
 }
 
-bool Preprocessor::isSafeBufferOptOut(const SourceManager &SourceMgr,
-                                           const SourceLocation &Loc) const {
-  // Try to find a region in `SafeBufferOptOutMap` where `Loc` is in:
-  auto FirstRegionEndingAfterLoc = llvm::partition_point(
-      SafeBufferOptOutMap,
-      [&SourceMgr,
-       &Loc](const std::pair<SourceLocation, SourceLocation> &Region) {
-        return SourceMgr.isBeforeInTranslationUnit(Region.second, Loc);
-      });
-
-  if (FirstRegionEndingAfterLoc != SafeBufferOptOutMap.end()) {
-    // To test if the start location of the found region precedes `Loc`:
-    return SourceMgr.isBeforeInTranslationUnit(FirstRegionEndingAfterLoc->first,
-                                               Loc);
-  }
-  // If we do not find a region whose end location passes `Loc`, we want to
-  // check if the current region is still open:
-  if (!SafeBufferOptOutMap.empty() &&
-      SafeBufferOptOutMap.back().first == SafeBufferOptOutMap.back().second)
-    return SourceMgr.isBeforeInTranslationUnit(SafeBufferOptOutMap.back().first,
-                                               Loc);
-  return false;
-}
-
-bool Preprocessor::enterOrExitSafeBufferOptOutRegion(
-    bool isEnter, const SourceLocation &Loc) {
-  if (isEnter) {
-    if (isPPInSafeBufferOptOutRegion())
-      return true; // invalid enter action
-    InSafeBufferOptOutRegion = true;
-    CurrentSafeBufferOptOutStart = Loc;
-
-    // To set the start location of a new region:
-
-    if (!SafeBufferOptOutMap.empty()) {
-      auto *PrevRegion = &SafeBufferOptOutMap.back();
-      assert(PrevRegion->first != PrevRegion->second &&
-             "Shall not begin a safe buffer opt-out region before closing the "
-             "previous one.");
-    }
-    // If the start location equals to the end location, we call the region a
-    // open region or a unclosed region (i.e., end location has not been set
-    // yet).
-    SafeBufferOptOutMap.emplace_back(Loc, Loc);
-  } else {
-    if (!isPPInSafeBufferOptOutRegion())
-      return true; // invalid enter action
-    InSafeBufferOptOutRegion = false;
-
-    // To set the end location of the current open region:
-
-    assert(!SafeBufferOptOutMap.empty() &&
-           "Misordered safe buffer opt-out regions");
-    auto *CurrRegion = &SafeBufferOptOutMap.back();
-    assert(CurrRegion->first == CurrRegion->second &&
-           "Set end location to a closed safe buffer opt-out region");
-    CurrRegion->second = Loc;
-  }
-  return false;
-}
-
-bool Preprocessor::isPPInSafeBufferOptOutRegion() {
-  return InSafeBufferOptOutRegion;
-}
-bool Preprocessor::isPPInSafeBufferOptOutRegion(SourceLocation &StartLoc) {
-  StartLoc = CurrentSafeBufferOptOutStart;
-  return InSafeBufferOptOutRegion;
-}
-
 ModuleLoader::~ModuleLoader() = default;
 
 CommentHandler::~CommentHandler() = default;

clang/lib/Sema/AnalysisBasedWarnings.cpp

@@ -2213,10 +2213,6 @@ class UnsafeBufferUsageReporter : public UnsafeBufferUsageHandler {
         FD << F;
     }
   }
-
-  const clang::Preprocessor & getPP() const override {
-    return S.getPreprocessor();
-  }  
 };
 } // namespace