[analyzer] check for std::__addressof for inner pointer checker

[steakhal]

Summary

This is an extension to diff D99260. This adds an additional exception for std::__addressof in InnerPointerChecker.

Originally authored by alishuja (Ali Shuja Siddiqui).

[NoQ]

Thanks! Can you add a regression test for this, like D99260 does in test/Analysis/inner-pointer.cpp? We typically want all commits to have associated test cases.

[steakhal]

I'll finish this one.

[steakhal]

• rebased (now using matchesAny(...)
• added a test

[martong]

LGTM

[steakhal]

@alishuja, Shall I submit this patch with --author="Ali Shuja Siddiqui <[e-mail]>" (thus on your behalf) ?
The LLVM DeveloperPolicy mandates me for asking permission.

[alishuja]

@steakhal yes please go ahead, thank you.

clang/lib/StaticAnalyzer/Checkers/InnerPointerChecker.cpp

 REGISTER_MAP_WITH_PROGRAMSTATE(RawPtrMap, const MemRegion *, PtrSet)
 
 
 namespace {
 
 class InnerPointerChecker
     : public Checker<check::DeadSymbols, check::PostCall> {
 
-  CallDescription AppendFn, AssignFn, AddressofFn, ClearFn, CStrFn, DataFn,
-      DataMemberFn, EraseFn, InsertFn, PopBackFn, PushBackFn, ReplaceFn,
-      ReserveFn, ResizeFn, ShrinkToFitFn, SwapFn;
+  CallDescription AppendFn, AssignFn, AddressofFn, AddressofFn_, ClearFn,
+      CStrFn, DataFn, DataMemberFn, EraseFn, InsertFn, PopBackFn, PushBackFn,
+      ReplaceFn, ReserveFn, ResizeFn, ShrinkToFitFn, SwapFn;
 
 public:
   class InnerPointerBRVisitor : public BugReporterVisitor {
     SymbolRef PtrToBuf;
 
   public:
     InnerPointerBRVisitor(SymbolRef Sym) : PtrToBuf(Sym) {}
 
bool isSymbolTracked(ProgramStateRef State, SymbolRef Sym) {
       }
       return false;
     }
   };
 
   InnerPointerChecker()
       : AppendFn({"std", "basic_string", "append"}),
         AssignFn({"std", "basic_string", "assign"}),
-        AddressofFn({"std", "addressof"}),
+        AddressofFn({"std", "addressof"}), AddressofFn_({"std", "__addressof"}),
         ClearFn({"std", "basic_string", "clear"}),
         CStrFn({"std", "basic_string", "c_str"}), DataFn({"std", "data"}, 1),
         DataMemberFn({"std", "basic_string", "data"}),
         EraseFn({"std", "basic_string", "erase"}),
         InsertFn({"std", "basic_string", "insert"}),
         PopBackFn({"std", "basic_string", "pop_back"}),
         PushBackFn({"std", "basic_string", "push_back"}),
         ReplaceFn({"std", "basic_string", "replace"}),
for (unsigned I = 0, E = FD->getNumParams(); I != E; ++I) {
       unsigned ArgI = isaMemberOpCall ? I+1 : I;
 
       SVal Arg = FC->getArgSVal(ArgI);
       const auto *ArgRegion =
           dyn_cast_or_null<TypedValueRegion>(Arg.getAsRegion());
       if (!ArgRegion)
         continue;
 
-      // std::addressof function accepts a non-const reference as an argument,
+      // std::addressof functions accepts a non-const reference as an argument,
       // but doesn't modify it.
-      if (AddressofFn.matches(Call))
+      if (matchesAny(Call, AddressofFn, AddressofFn_))
         continue;
 
       markPtrSymbolsReleased(Call, State, ArgRegion, C);
     }
   }
 }
 
 // [string.require]

clang/test/Analysis/inner-pointer.cpp

 void func_value(T a);
 
 string my_string = "default";
 void default_arg(int a = 42, string &b = my_string);
 
 template <class T>
 T *addressof(T &arg);
 
+template <class T>
+T *__addressof(T &arg);
+
 char *data(std::string &c);
 
 } // end namespace std
 
 void consume(const char *) {}
 void consume(const wchar_t *) {}
 void consume(const char16_t *) {}
 void consume(const char32_t *) {}

 void func_addressof() {
   const char *c;
   std::string s;
   c = s.c_str();
   (void)addressof(s);
   consume(c); // no-warning
 }
 
+void func_AddressofFn_() {
+  const char *c;
+  std::string s;
+  c = s.c_str();
+  (void)std::__addressof(s);
+  consume(c); // no-warning
+}
+
 void func_std_data() {
   const char *c;
   std::string s;
   c = std::data(s);
   consume(c); // no-warning
 }
 
 struct T {