[clang-tidy] Crash fix for bugprone-misplaced-pointer-arithmetic-in-alloc

[baloghadamsoftware]

Summary

Placement new operators on non-object types cause crash in bugprone-misplaced-pointer-arithmetic-in-alloc. This patch fixes this issue.

[aaron.ballman]

LGTM!

[njames93]

Please fix the test case first, can't call operator new(unsigned long, void*) with an argument of type void*
The other failures the pre merge bot detected can safely be disregarded

[baloghadamsoftware]

In D87683#2274569, @njames93 wrote:

Please fix the test case first, can't call operator new(unsigned long, void*) with an argument of type void*
The other failures the pre merge bot detected can safely be disregarded

Placement new is defined per standard:

void* operator new  ( std::size_t count, void* ptr );

Here, the problem is that size_t is unsigned long on Linux and it seems that it is unsigned long long on Windows. How should I overcome this?

[martong]

In D87683#2274663, @baloghadamsoftware wrote:

In D87683#2274569, @njames93 wrote:

Please fix the test case first, can't call operator new(unsigned long, void*) with an argument of type void*
The other failures the pre merge bot detected can safely be disregarded

Placement new is defined per standard:

void* operator new  ( std::size_t count, void* ptr );

Here, the problem is that size_t is unsigned long on Linux and it seems that it is unsigned long long on Windows. How should I overcome this?

In CSA, to overcome the platform problem, it is common to add a target triple for the RUN line:
https://github.com/llvm/llvm-project/blob/master/clang/test/Analysis/std-c-library-functions.c#L14

[gribozavr2]

In D87683#2274883, @martong wrote:

In D87683#2274663, @baloghadamsoftware wrote:

In D87683#2274569, @njames93 wrote:

Please fix the test case first, can't call operator new(unsigned long, void*) with an argument of type void*
The other failures the pre merge bot detected can safely be disregarded

Placement new is defined per standard:

void* operator new  ( std::size_t count, void* ptr );

Here, the problem is that size_t is unsigned long on Linux and it seems that it is unsigned long long on Windows. How should I overcome this?

In CSA, to overcome the platform problem, it is common to add a target triple for the RUN line:
https://github.com/llvm/llvm-project/blob/master/clang/test/Analysis/std-c-library-functions.c#L14

Please make the tests generic if possible:

typedef decltype(sizeof(void*)) size_t;

[baloghadamsoftware]

std::size_t defined correctly in the tests.

clang-tools-extra/clang-tidy/bugprone/MisplacedPointerArithmeticInAllocCheck.cpp

if (const auto *Call = dyn_cast<CallExpr>(AllocExpr)) {
     }
     CallName = Func->getName().str();
   } else {
     const auto *New = cast<CXXNewExpr>(AllocExpr);
     if (New->isArray()) {
       CallName = "operator new[]";
     } else {
       const auto *CtrE = New->getConstructExpr();
-      if (!CtrE->getArg(CtrE->getNumArgs() - 1)
+      if (!CtrE || !CtrE->getArg(CtrE->getNumArgs() - 1)
                                      ->getType()
                                      ->isIntegralOrEnumerationType())
         return;
       CallName = "operator new";
     }
   }
 
   const SourceRange OldRParen = SourceRange(PtrArith->getLHS()->getEndLoc());
   const StringRef RParen =
       Lexer::getSourceText(CharSourceRange::getTokenRange(OldRParen),

clang-tools-extra/test/clang-tidy/checkers/bugprone-misplaced-pointer-arithmetic-in-alloc.cpp

void bad_new_array(int n, int m) {
   // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: arithmetic operation is applied to the result of operator new[]() instead of its size-like argument
   // CHECK-FIXES: p = new char[n - (m + 10)];
 
   p = new char[n] - m + 10;
   // CHECK-MESSAGES: :[[@LINE-1]]:7: warning: arithmetic operation is applied to the result of operator new[]() instead of its size-like argument
   // CHECK-FIXES: p = new char[n - m] + 10;
   // FIXME: should be p = new char[n - m + 10];
 }
+
+namespace std {
+typedef decltype(sizeof(void*)) size_t;
+}
+
+void* operator new(std::size_t, void*);
+
+void placement_new_ptr(void *buf, C *old) {
+  C **p = new (buf) C*(old) + 1;
+  // CHECK-MESSAGES-NOT: :[[@LINE-1]]:11: warning: arithmetic operation is applied to the result of operator new() instead of its size-like argument
+}