Index: include/clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h =================================================================== --- include/clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h +++ include/clang/StaticAnalyzer/Core/PathSensitive/CallEvent.h @@ -921,15 +921,28 @@ return getOriginExpr()->getOperatorNew(); } + // Size and maybe implicit alignment in C++17. Instead of size, the AST + // contains the construct-expression. Alignment is always hidden. + // We pretend that argument 0 is size and argument 1 is alignment (if passed + // implicitly) and the rest are placement args. This makes sure that the + // number of arguments is always the same as the number of parameters. + unsigned getNumImplicitArgs() const { + return getOriginExpr()->passAlignment() ? 2 : 1; + } + unsigned getNumArgs() const override { - return getOriginExpr()->getNumPlacementArgs() + 1; + return getOriginExpr()->getNumPlacementArgs() + getNumImplicitArgs(); } const Expr *getArgExpr(unsigned Index) const override { // The first argument of an allocator call is the size of the allocation. - if (Index == 0) + if (Index < getNumImplicitArgs()) return nullptr; - return getOriginExpr()->getPlacementArg(Index - 1); + return getOriginExpr()->getPlacementArg(Index - getNumImplicitArgs()); + } + + const Expr *getPlacementArgExpr(unsigned Index) const { + return getOriginExpr()->getPlacementArg(Index); } Kind getKind() const override { return CE_CXXAllocator; } Index: lib/StaticAnalyzer/Core/CallEvent.cpp =================================================================== --- lib/StaticAnalyzer/Core/CallEvent.cpp +++ lib/StaticAnalyzer/Core/CallEvent.cpp @@ -503,10 +503,14 @@ const ParmVarDecl *ParamDecl = *I; assert(ParamDecl && "Formal parameter has no decl?"); + // TODO: Support allocator calls. if (Call.getKind() != CE_CXXAllocator) if (Call.isArgumentConstructedDirectly(Idx)) continue; + // TODO: Allocators should receive the correct size and possibly alignment, + // determined in compile-time but not represented as arg-expressions, + // which makes getArgSVal() fail and return UnknownVal. SVal ArgVal = Call.getArgSVal(Idx); if (!ArgVal.isUnknown()) { Loc ParamLoc = SVB.makeLoc(MRMgr.getVarRegion(ParamDecl, CalleeCtx)); Index: test/Analysis/new-aligned.cpp =================================================================== --- /dev/null +++ test/Analysis/new-aligned.cpp @@ -0,0 +1,14 @@ +//RUN: %clang_analyze_cc1 -std=c++17 -analyze -analyzer-checker=core -verify %s + +// expected-no-diagnostics + +// Notice the weird alignment. +struct alignas(1024) S {}; + +void foo() { + // Operator new() here is the C++17 aligned new that takes two arguments: + // size and alignment. Size is passed implicitly as usual, and alignment + // is passed implicitly in a similar manner. + S *s = new S; // no-warning + delete s; +}