[MC] Add support for generating missing GNU build notes

[tbaeder]

Summary

Add support for generating missing GNU build notes to the LLVM assembler.

This makes clang accept and pass through -Wa,--generate-missing-build-notes=[yes/no]. If =yes is passed (the default is no), then the assembler will check whether a .gnu.build.attributes section is present. If not, it will generate one for all relevant code sections.

This is the equivalent to what the GNU assembler gas is already doing in maybe_generate_build_notes() in gas/write.c: https://sourceware.org/git/?p=binutils-gdb.git;a=blob;f=gas/write.c;h=0b43063bbaab76d21fe3bac5fb4643bfff3c72e2;hb=HEAD#l1954

[tbaeder]

Add a test that checks that clang accepts -Wa,--generate-missing-build-notes=yes and -Wa,--generate-missing-build-notes=no

[tbaeder]

Ping

[MaskRay]

https://fedoraproject.org/wiki/Toolchain/Watermark Seems that .gnu.build.attributes is used with a GCC plugin (annobin?). The feature on its own is probably not that useful. .gnu.linkonce is a proto-comdat legacy feature which the patch should ignore.

[tbaeder]

In D84846#2396303, @MaskRay wrote:

https://fedoraproject.org/wiki/Toolchain/Watermark Seems that .gnu.build.attributes is used with a GCC plugin (annobin?). The feature on its own is probably not that useful. .gnu.linkonce is a proto-comdat legacy feature which the patch should ignore.

I can update the patch to ignore .gnu.linkonce. As for annobin, it can also be used as a clang plugin these days.

[tbaeder]

Sorry about the last change, that was the wrong patch.

clang/include/clang/AST/Expr.h

public:
 
   // Iterators
   child_range children() { return child_range(&Val, &Val+1); }
   const_child_range children() const {
     return const_child_range(&Val, &Val + 1);
   }
 };
 
-class VAArgPackExpr : public Expr {
-  SourceLocation BuiltinLoc;
-  SourceLocation RParenLoc;
-public:
-  VAArgPackExpr(SourceLocation BLoc, SourceLocation RPLoc, QualType t) :
-      Expr(VAArgPackExprClass, t, VK_RValue, OK_Ordinary),
-      BuiltinLoc(BLoc), RParenLoc(RPLoc) {
-    setDependence(ExprDependence::None);
-  }
-  explicit VAArgPackExpr(EmptyShell Empty)
-      : Expr(VAArgPackExprClass, Empty) {}
-
-  SourceLocation getBuiltinLoc() const { return BuiltinLoc; }
-  void setBuiltinLoc(SourceLocation L) { BuiltinLoc = L; }
-
-  SourceLocation getRParenLoc() const { return RParenLoc; }
-  void setRParenLoc(SourceLocation L) { RParenLoc = L; }
-
-  SourceLocation getBeginLoc() const LLVM_READONLY { return BuiltinLoc; }
-  SourceLocation getEndLoc() const LLVM_READONLY { return RParenLoc; }
-
-  static bool classof(const Stmt *T) {
-    return T->getStmtClass() == VAArgPackExprClass;
-  }
-
-  SourceLocation getLocation() const { return BuiltinLoc; }
-
-  child_range children() {
-    return child_range(child_iterator(), child_iterator());
-  }
-
-  const_child_range children() const {
-    return const_child_range(child_iterator(), child_iterator());
-  }
-
-};
-
 /// Represents a function call to one of __builtin_LINE(), __builtin_COLUMN(),
 /// __builtin_FUNCTION(), or __builtin_FILE().
 class SourceLocExpr final : public Expr {
   SourceLocation BuiltinLoc, RParenLoc;
   DeclContext *ParentContext;
 
 public:
   enum IdentKind { Function, File, Line, Column };

clang/include/clang/AST/RecursiveASTVisitor.h

 DEF_TRAVERSE_STMT(ExpressionTraitExpr,
                   { TRY_TO_TRAVERSE_OR_ENQUEUE_STMT(S->getQueriedExpression()); })
 
 DEF_TRAVERSE_STMT(VAArgExpr, {
   // The child-iterator will pick up the expression argument.
   TRY_TO(TraverseTypeLoc(S->getWrittenTypeInfo()->getTypeLoc()));
 })
 
-DEF_TRAVERSE_STMT(VAArgPackExpr, {})
-
 DEF_TRAVERSE_STMT(CXXTemporaryObjectExpr, {
   // This is called for code like 'return T()' where T is a class type.
   TRY_TO(TraverseTypeLoc(S->getTypeSourceInfo()->getTypeLoc()));
 })
 
 // Walk only the visible parts of lambda expressions.
 DEF_TRAVERSE_STMT(LambdaExpr, {
   // Visit the capture list.

clang/include/clang/Basic/StmtNodes.td

 def DesignatedInitExpr : StmtNode<Expr>;
 def DesignatedInitUpdateExpr : StmtNode<Expr>;
 def ImplicitValueInitExpr : StmtNode<Expr>;
 def NoInitExpr : StmtNode<Expr>;
 def ArrayInitLoopExpr : StmtNode<Expr>;
 def ArrayInitIndexExpr : StmtNode<Expr>;
 def ParenListExpr : StmtNode<Expr>;
 def VAArgExpr : StmtNode<Expr>;
-def VAArgPackExpr : StmtNode<Expr>;
 def GenericSelectionExpr : StmtNode<Expr>;
 def PseudoObjectExpr : StmtNode<Expr>;
 def SourceLocExpr : StmtNode<Expr>;
 
 // Wrapper expressions
 def FullExpr : StmtNode<Expr, 1>;
 def ConstantExpr : StmtNode<FullExpr>;
 

clang/include/clang/Basic/TokenKinds.def

 KEYWORD(__builtin_FUNCTION          , KEYALL)
 KEYWORD(__builtin_LINE              , KEYALL)
 KEYWORD(__builtin_COLUMN            , KEYALL)
 
 // __builtin_types_compatible_p is a GNU C extension that we handle like a C++
 // type trait.
 TYPE_TRAIT_2(__builtin_types_compatible_p, TypeCompatible, KEYNOCXX)
 KEYWORD(__builtin_va_arg            , KEYALL)
-KEYWORD(__builtin_va_arg_pack       , KEYALL)
 KEYWORD(__extension__               , KEYALL)
 KEYWORD(__float128                  , KEYALL)
 KEYWORD(__imag                      , KEYALL)
 KEYWORD(__int128                    , KEYALL)
 KEYWORD(__label__                   , KEYALL)
 KEYWORD(__real                      , KEYALL)
 KEYWORD(__thread                    , KEYALL)
 KEYWORD(__FUNCTION__                , KEYALL)

clang/include/clang/Sema/Sema.h

ExprResult ActOnChooseExpr(SourceLocation BuiltinLoc,
                              Expr *RHSExpr, SourceLocation RPLoc);
 
   // __builtin_va_arg(expr, type)
   ExprResult ActOnVAArg(SourceLocation BuiltinLoc, Expr *E, ParsedType Ty,
                         SourceLocation RPLoc);
   ExprResult BuildVAArgExpr(SourceLocation BuiltinLoc, Expr *E,
                             TypeSourceInfo *TInfo, SourceLocation RPLoc);
 
-  ExprResult ActOnVAArgPack(SourceLocation BuiltinLoc, SourceLocation RPLoc);
-  ExprResult BuildVAArgPackExpr(SourceLocation BuiltinLoc, SourceLocation RPLoc);
-
   // __builtin_LINE(), __builtin_FUNCTION(), __builtin_FILE(),
   // __builtin_COLUMN()
   ExprResult ActOnSourceLocExpr(SourceLocExpr::IdentKind Kind,
                                 SourceLocation BuiltinLoc,
                                 SourceLocation RPLoc);
 
   // Build a potentially resolved SourceLocExpr.
   ExprResult BuildSourceLocExpr(SourceLocExpr::IdentKind Kind,

clang/include/clang/Serialization/ASTBitCodes.h

enum StmtCode {
       EXPR_ARRAY_INIT_INDEX,
 
       /// An ImplicitValueInitExpr record.
       EXPR_IMPLICIT_VALUE_INIT,
 
       /// A VAArgExpr record.
       EXPR_VA_ARG,
 
-      EXPR_VA_ARG_PACK,
-
       /// An AddrLabelExpr record.
       EXPR_ADDR_LABEL,
 
       /// A StmtExpr record.
       EXPR_STMT,
 
       /// A ChooseExpr record.
       EXPR_CHOOSE,

clang/lib/AST/Expr.cpp

case BinaryOperatorClass: {
     R2 = BO->getRHS()->getSourceRange();
     return true;
   }
   case CompoundAssignOperatorClass:
   case VAArgExprClass:
   case AtomicExprClass:
     return false;
 
-  case VAArgPackExprClass:
-    return true;
-
   case ConditionalOperatorClass: {
     // If only one of the LHS or RHS is a warning, the operator might
     // be being used for control flow. Only warn if both the LHS and
     // RHS are warnings.
     const auto *Exp = cast<ConditionalOperator>(this);
     return Exp->getLHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx) &&
            Exp->getRHS()->isUnusedResultAWarning(WarnE, Loc, R1, R2, Ctx);
   }
bool Expr::HasSideEffects(const ASTContext &Ctx,
   case CXXNewExprClass:
   case CXXDeleteExprClass:
   case CoawaitExprClass:
   case DependentCoawaitExprClass:
   case CoyieldExprClass:
     // These always have a side-effect.
     return true;
 
-  case VAArgPackExprClass:
-    return false;
-
   case StmtExprClass: {
     // StmtExprs have a side-effect if any substatement does.
     SideEffectFinder Finder(Ctx, IncludePossibleEffects);
     Finder.Visit(cast<StmtExpr>(this)->getSubStmt());
     return Finder.hasSideEffects();
   }
 
   case ExprWithCleanupsClass:

clang/lib/AST/ExprClassification.cpp

#include "clang/AST/StmtNodes.inc"
   case Expr::CXXTemporaryObjectExprClass:
   case Expr::LambdaExprClass:
   case Expr::CXXStdInitializerListExprClass:
     return Cl::CL_ClassTemporary;
 
   case Expr::VAArgExprClass:
     return ClassifyUnnamed(Ctx, E->getType());
 
-  case Expr::VAArgPackExprClass:
-    return ClassifyUnnamed(Ctx, E->getType());
-
   case Expr::DesignatedInitExprClass:
     return ClassifyInternal(Ctx, cast<DesignatedInitExpr>(E)->getInit());
 
   case Expr::StmtExprClass: {
     const CompoundStmt *S = cast<StmtExpr>(E)->getSubStmt();
     if (const auto *LastExpr = dyn_cast_or_null<Expr>(S->body_back()))
       return ClassifyUnnamed(Ctx, LastExpr->getType());
     return Cl::CL_PRValue;

clang/lib/AST/ExprConstant.cpp

#include "clang/AST/StmtNodes.inc"
   case Expr::DesignatedInitExprClass:
   case Expr::ArrayInitLoopExprClass:
   case Expr::ArrayInitIndexExprClass:
   case Expr::NoInitExprClass:
   case Expr::DesignatedInitUpdateExprClass:
   case Expr::ImplicitValueInitExprClass:
   case Expr::ParenListExprClass:
   case Expr::VAArgExprClass:
-  case Expr::VAArgPackExprClass:
   case Expr::AddrLabelExprClass:
   case Expr::StmtExprClass:
   case Expr::CXXMemberCallExprClass:
   case Expr::CUDAKernelCallExprClass:
   case Expr::CXXAddrspaceCastExprClass:
   case Expr::CXXDynamicCastExprClass:
   case Expr::CXXTypeidExprClass:
   case Expr::CXXUuidofExprClass:

clang/lib/AST/ItaniumMangle.cpp

#include "clang/AST/StmtNodes.inc"
   case Expr::ShuffleVectorExprClass:
   case Expr::ConvertVectorExprClass:
   case Expr::StmtExprClass:
   case Expr::TypeTraitExprClass:
   case Expr::RequiresExprClass:
   case Expr::ArrayTypeTraitExprClass:
   case Expr::ExpressionTraitExprClass:
   case Expr::VAArgExprClass:
-  case Expr::VAArgPackExprClass:
   case Expr::CUDAKernelCallExprClass:
   case Expr::AsTypeExprClass:
   case Expr::PseudoObjectExprClass:
   case Expr::AtomicExprClass:
   case Expr::SourceLocExprClass:
   case Expr::BuiltinBitCastExprClass:
   {
     if (!NullOut) {

clang/lib/AST/StmtPrinter.cpp

 void StmtPrinter::VisitVAArgExpr(VAArgExpr *Node) {
   OS << "__builtin_va_arg(";
   PrintExpr(Node->getSubExpr());
   OS << ", ";
   Node->getType().print(OS, Policy);
   OS << ")";
 }
 
-void StmtPrinter::VisitVAArgPackExpr(VAArgPackExpr *Node) {
-  OS << "__builtin_va_arg_pack()";
-}
-
 void StmtPrinter::VisitPseudoObjectExpr(PseudoObjectExpr *Node) {
   PrintExpr(Node->getSyntacticForm());
 }
 
 void StmtPrinter::VisitAtomicExpr(AtomicExpr *Node) {
   const char *Name = nullptr;
   switch (Node->getOp()) {
 #define BUILTIN(ID, TYPE, ATTRS)

clang/lib/AST/StmtProfile.cpp

 void StmtProfiler::VisitGNUNullExpr(const GNUNullExpr *S) {
   VisitExpr(S);
 }
 
 void StmtProfiler::VisitVAArgExpr(const VAArgExpr *S) {
   VisitExpr(S);
 }
 
-void StmtProfiler::VisitVAArgPackExpr(const VAArgPackExpr *S) {
-  VisitExpr(S);
-}
-
 void StmtProfiler::VisitInitListExpr(const InitListExpr *S) {
   if (S->getSyntacticForm()) {
     VisitInitListExpr(S->getSyntacticForm());
     return;
   }
 
   VisitExpr(S);
 }

clang/lib/CodeGen/CGExpr.cpp

 #include "llvm/IR/LLVMContext.h"
 #include "llvm/IR/MDBuilder.h"
 #include "llvm/Support/ConvertUTF.h"
 #include "llvm/Support/MathExtras.h"
 #include "llvm/Support/Path.h"
 #include "llvm/Transforms/Utils/SanitizerStats.h"
 
 #include <string>
-#include <iostream>
 
 using namespace clang;
 using namespace CodeGen;
 
 //===--------------------------------------------------------------------===//
 //                        Miscellaneous Helper Methods
 //===--------------------------------------------------------------------===//
 
LValue CodeGenFunction::EmitLValue(const Expr *E) {
   case Expr::CXXMemberCallExprClass:
   case Expr::CXXOperatorCallExprClass:
   case Expr::UserDefinedLiteralClass:
     return EmitCallExprLValue(cast<CallExpr>(E));
   case Expr::CXXRewrittenBinaryOperatorClass:
     return EmitLValue(cast<CXXRewrittenBinaryOperator>(E)->getSemanticForm());
   case Expr::VAArgExprClass:
     return EmitVAArgExprLValue(cast<VAArgExpr>(E));
-  case Expr::VAArgPackExprClass:
-    std::cout << __FUNCTION__ << std::endl;
-    return EmitVAArgPackExprLValue(cast<VAArgPackExpr>(E));
   case Expr::DeclRefExprClass:
     return EmitDeclRefLValue(cast<DeclRefExpr>(E));
   case Expr::ConstantExprClass: {
     const ConstantExpr *CE = cast<ConstantExpr>(E);
     if (llvm::Value *Result = ConstantEmitter(*this).tryEmitConstantExpr(CE)) {
       QualType RetType = cast<CallExpr>(CE->getSubExpr()->IgnoreImplicit())
                              ->getCallReturnType(getContext());
       return MakeNaturalAlignAddrLValue(Result, RetType);
LValue CodeGenFunction::EmitCallExprLValue(const CallExpr *E) {
 
   assert(E->getCallReturnType(getContext())->isReferenceType() &&
          "Can't have a scalar return unless the return type is a "
          "reference type!");
 
   return MakeNaturalAlignPointeeAddrLValue(RV.getScalarVal(), E->getType());
 }
 
-LValue CodeGenFunction::EmitVAArgPackExprLValue(const VAArgPackExpr *E) {
-  return EmitAggExprToLValue(E);
-}
-
 LValue CodeGenFunction::EmitVAArgExprLValue(const VAArgExpr *E) {
   // FIXME: This shouldn't require another copy.
   return EmitAggExprToLValue(E);
 }
 
 LValue CodeGenFunction::EmitCXXConstructLValue(const CXXConstructExpr *E) {
   assert(E->getType()->getAsCXXRecordDecl()->hasTrivialDestructor()
          && "binding l-value to type which needs a temporary");

clang/lib/CodeGen/CGExprAgg.cpp

if (E->isGLValue()) {
       LValue LV = CGF.EmitPseudoObjectLValue(E);
       return EmitFinalDestCopy(E->getType(), LV);
     }
 
     CGF.EmitPseudoObjectRValue(E, EnsureSlot(E->getType()));
   }
 
   void VisitVAArgExpr(VAArgExpr *E);
-  void VisitVAArgPackExpr(VAArgPackExpr *E);
 
   void EmitInitializationToLValue(Expr *E, LValue Address);
   void EmitNullInitializationToLValue(LValue Address);
   //  case Expr::ChooseExprClass:
   void VisitCXXThrowExpr(const CXXThrowExpr *E) { CGF.EmitCXXThrowExpr(E); }
   void VisitAtomicExpr(AtomicExpr *E) {
     RValue Res = CGF.EmitAtomicExpr(E);
     EmitFinalDestCopy(E->getType(), Res);
void AggExprEmitter::VisitVAArgExpr(VAArgExpr *VE) {
   if (!ArgPtr.isValid()) {
     CGF.ErrorUnsupported(VE, "aggregate va_arg expression");
     return;
   }
 
   EmitFinalDestCopy(VE->getType(), CGF.MakeAddrLValue(ArgPtr, VE->getType()));
 }
 
-
-#include <iostream>
-void AggExprEmitter::VisitVAArgPackExpr(VAArgPackExpr *E) {
-  std::cout << "EMITTING VA ARG PACK EXPR"  << std::endl;
-  //Address ArgValue = Address::invalid();
-  //Address ArgPtr = CGF.EmitVAArg(VE, ArgValue);
-
-  //CGF.EmitVAArg(
-
-  // If EmitVAArg fails, emit an error.
-  //if (!ArgPtr.isValid()) {
-    //CGF.ErrorUnsupported(VE, "aggregate va_arg expression");
-    //return;
-  //}
-
-  //EmitFinalDestCopy(VE->getType(), CGF.MakeAddrLValue(ArgPtr, VE->getType()));
-
-}
-
-
 void AggExprEmitter::VisitCXXBindTemporaryExpr(CXXBindTemporaryExpr *E) {
   // Ensure that we have a slot, but if we already do, remember
   // whether it was externally destructed.
   bool wasExternallyDestructed = Dest.isExternallyDestructed();
   EnsureDest(E->getType());
 
   // We're going to push a destructor if there isn't already one.
   Dest.setExternallyDestructed();

clang/lib/CodeGen/CodeGenFunction.h

public:
 
   // Note: only available for agg return types
   LValue EmitBinaryOperatorLValue(const BinaryOperator *E);
   LValue EmitCompoundAssignmentLValue(const CompoundAssignOperator *E);
   // Note: only available for agg return types
   LValue EmitCallExprLValue(const CallExpr *E);
   // Note: only available for agg return types
   LValue EmitVAArgExprLValue(const VAArgExpr *E);
-  LValue EmitVAArgPackExprLValue(const VAArgPackExpr *E);
   LValue EmitDeclRefLValue(const DeclRefExpr *E);
   LValue EmitStringLiteralLValue(const StringLiteral *E);
   LValue EmitObjCEncodeExprLValue(const ObjCEncodeExpr *E);
   LValue EmitPredefinedLValue(const PredefinedExpr *E);
   LValue EmitUnaryOpLValue(const UnaryOperator *E);
   LValue EmitArraySubscriptExpr(const ArraySubscriptExpr *E,
                                 bool Accessed = false);
   LValue EmitMatrixSubscriptExpr(const MatrixSubscriptExpr *E);

clang/lib/Parse/ParseExpr.cpp

 #include "clang/AST/ExprCXX.h"
 #include "clang/Basic/PrettyStackTrace.h"
 #include "clang/Parse/RAIIObjectsForParser.h"
 #include "clang/Sema/DeclSpec.h"
 #include "clang/Sema/ParsedTemplate.h"
 #include "clang/Sema/Scope.h"
 #include "clang/Sema/TypoCorrection.h"
 #include "llvm/ADT/SmallVector.h"
-#include <iostream>
 using namespace clang;
 
 /// Simple precedence-based parser for binary/ternary operators.
 ///
 /// Note: we diverge from the C99 grammar when parsing the assignment-expression
 /// production.  C99 specifies that the LHS of an assignment operator should be
 /// parsed as a unary-expression, but consistency dictates that it be a
 /// conditional-expession.  In practice, the important thing here is that the
case tok::utf32_string_literal:
     break;
   case tok::kw__Generic:   // primary-expression: generic-selection [C11 6.5.1]
     Res = ParseGenericSelectionExpression();
     break;
   case tok::kw___builtin_available:
     Res = ParseAvailabilityCheckExpr(Tok.getLocation());
     break;
   case tok::kw___builtin_va_arg:
-  case tok::kw___builtin_va_arg_pack:
   case tok::kw___builtin_offsetof:
   case tok::kw___builtin_choose_expr:
   case tok::kw___builtin_astype: // primary-expression: [OCL] as_type()
   case tok::kw___builtin_convertvector:
   case tok::kw___builtin_COLUMN:
   case tok::kw___builtin_FILE:
   case tok::kw___builtin_FUNCTION:
   case tok::kw___builtin_LINE:
if (Tok.isNot(tok::r_paren)) {
       SkipUntil(tok::r_paren, StopAtSemi);
       return ExprError();
     }
 
     Res = Actions.ActOnConvertVectorExpr(Expr.get(), DestTy.get(), StartLoc,
                                          ConsumeParen());
     break;
   }
-  case tok::kw___builtin_va_arg_pack: {
-    std::cout << "OMG BUILTIN VA ARG PACK" << std::endl;
-    if (Tok.isNot(tok::r_paren)) {
-      Diag(Tok, diag::err_expected) << tok::r_paren;
-      SkipUntil(tok::r_paren, StopAtSemi);
-    }
-
-    // Parse
-
-    Res = Actions.ActOnVAArgPack(StartLoc, ConsumeParen());
-    break;
-  }
   case tok::kw___builtin_COLUMN:
   case tok::kw___builtin_FILE:
   case tok::kw___builtin_FUNCTION:
   case tok::kw___builtin_LINE: {
     // Attempt to consume the r-paren.
     if (Tok.isNot(tok::r_paren)) {
       Diag(Tok, diag::err_expected) << tok::r_paren;
       SkipUntil(tok::r_paren, StopAtSemi);

clang/lib/Sema/SemaExceptionSpec.cpp

CanThrowResult Sema::canThrow(const Stmt *S) {
   case Expr::ObjCIsaExprClass:
   case Expr::ObjCIvarRefExprClass:
   case Expr::ParenExprClass:
   case Expr::ParenListExprClass:
   case Expr::ShuffleVectorExprClass:
   case Expr::StmtExprClass:
   case Expr::ConvertVectorExprClass:
   case Expr::VAArgExprClass:
-  case Expr::VAArgPackExprClass:
     return canSubStmtsThrow(*this, S);
 
   case Expr::CompoundLiteralExprClass:
   case Expr::CXXConstCastExprClass:
   case Expr::CXXAddrspaceCastExprClass:
   case Expr::CXXReinterpretCastExprClass:
   case Expr::BuiltinBitCastExprClass:
       // FIXME: Properly determine whether a variably-modified type can throw.

clang/lib/Sema/SemaExpr.cpp

if (!PromoteType.isNull())
                           << PromoteType
                           << TInfo->getTypeLoc().getSourceRange());
   }
 
   QualType T = TInfo->getType().getNonLValueExprType(Context);
   return new (Context) VAArgExpr(BuiltinLoc, E, TInfo, RPLoc, T, IsMS);
 }
 
-ExprResult Sema::ActOnVAArgPack(SourceLocation BuiltinLoc, SourceLocation RPLoc) {
-  return BuildVAArgPackExpr(BuiltinLoc, RPLoc);
-}
-
-ExprResult Sema::BuildVAArgPackExpr(SourceLocation BuiltinLoc, SourceLocation RPLoc) {
-  QualType VaListType = Context.getBuiltinVaListType();
-  llvm::errs() << __FUNCTION__ << "\n";
-  //return ExprError();
-  return new (Context) VAArgPackExpr(BuiltinLoc, RPLoc, VaListType);
-}
-
 ExprResult Sema::ActOnGNUNullExpr(SourceLocation TokenLoc) {
   // The type of __null will be int or long, depending on the size of
   // pointers on the target.
   QualType Ty;
   unsigned pw = Context.getTargetInfo().getPointerWidth(0);
   if (pw == Context.getTargetInfo().getIntWidth())
     Ty = Context.IntTy;
   else if (pw == Context.getTargetInfo().getLongWidth())

clang/lib/Sema/TreeTransform.h

   /// Subclasses may override this routine to provide different behavior.
   ExprResult RebuildSourceLocExpr(SourceLocExpr::IdentKind Kind,
                                   SourceLocation BuiltinLoc,
                                   SourceLocation RPLoc,
                                   DeclContext *ParentContext) {
     return getSema().BuildSourceLocExpr(Kind, BuiltinLoc, RPLoc, ParentContext);
   }
 
-  ExprResult RebuildVAArgPackExpr(SourceLocation BuiltinLoc,
-                                  SourceLocation RPLoc) {
-    return getSema().BuildVAArgPackExpr (BuiltinLoc, RPLoc);
-  }
-
   /// Build a new Objective-C boxed expression.
   ///
   /// By default, performs semantic analysis to build the new expression.
   /// Subclasses may override this routine to provide different behavior.
   ExprResult RebuildConceptSpecializationExpr(NestedNameSpecifierLoc NNS,
       SourceLocation TemplateKWLoc, DeclarationNameInfo ConceptNameInfo,
       NamedDecl *FoundDecl, ConceptDecl *NamedConcept,
       TemplateArgumentListInfo *TALI) {
ExprResult TreeTransform<Derived>::TransformSourceLocExpr(SourceLocExpr *E) {
   if (!getDerived().AlwaysRebuild() && !NeedRebuildFunc)
     return E;
 
   return getDerived().RebuildSourceLocExpr(E->getIdentKind(), E->getBeginLoc(),
                                            E->getEndLoc(),
                                            getSema().CurContext);
 }
 
-template <typename Derived>
-ExprResult TreeTransform<Derived>::TransformVAArgPackExpr(VAArgPackExpr *E) {
-  if (!getDerived().AlwaysRebuild())
-    return E;
-
-  return getDerived().RebuildVAArgPackExpr(E->getBeginLoc(), E->getEndLoc());
-}
-
-template<typename Derived>
+template<typename Derived>
 ExprResult
 TreeTransform<Derived>::TransformCUDAKernelCallExpr(CUDAKernelCallExpr *E) {
   // Transform the callee.
   ExprResult Callee = getDerived().TransformExpr(E->getCallee());
   if (Callee.isInvalid())
     return ExprError();
 
   // Transform exec config.

clang/lib/Serialization/ASTReaderStmt.cpp

void ASTStmtReader::VisitVAArgExpr(VAArgExpr *E) {
   VisitExpr(E);
   E->setSubExpr(Record.readSubExpr());
   E->setWrittenTypeInfo(readTypeSourceInfo());
   E->setBuiltinLoc(readSourceLocation());
   E->setRParenLoc(readSourceLocation());
   E->setIsMicrosoftABI(Record.readInt());
 }
 
-void ASTStmtReader::VisitVAArgPackExpr(VAArgPackExpr *E) {
-  VisitExpr(E);
-  E->setBuiltinLoc(readSourceLocation());
-  E->setRParenLoc(readSourceLocation());
-}
-
 void ASTStmtReader::VisitSourceLocExpr(SourceLocExpr *E) {
   VisitExpr(E);
   E->ParentContext = readDeclAs<DeclContext>();
   E->BuiltinLoc = readSourceLocation();
   E->RParenLoc = readSourceLocation();
   E->SourceLocExprBits.Kind =
       static_cast<SourceLocExpr::IdentKind>(Record.readInt());
 }
while (true) {
     case EXPR_ARRAY_INIT_INDEX:
       S = new (Context) ArrayInitIndexExpr(Empty);
       break;
 
     case EXPR_VA_ARG:
       S = new (Context) VAArgExpr(Empty);
       break;
 
-    case EXPR_VA_ARG_PACK:
-      S = new (Context) VAArgPackExpr(Empty);
-      break;
-
     case EXPR_SOURCE_LOC:
       S = new (Context) SourceLocExpr(Empty);
       break;
 
     case EXPR_ADDR_LABEL:
       S = new (Context) AddrLabelExpr(Empty);
       break;
 

clang/lib/Serialization/ASTWriterStmt.cpp

void ASTStmtWriter::VisitVAArgExpr(VAArgExpr *E) {
   Record.AddStmt(E->getSubExpr());
   Record.AddTypeSourceInfo(E->getWrittenTypeInfo());
   Record.AddSourceLocation(E->getBuiltinLoc());
   Record.AddSourceLocation(E->getRParenLoc());
   Record.push_back(E->isMicrosoftABI());
   Code = serialization::EXPR_VA_ARG;
 }
 
-void ASTStmtWriter::VisitVAArgPackExpr(VAArgPackExpr *E) {
-  VisitExpr(E);
-  Record.AddSourceLocation(E->getBuiltinLoc());
-  Record.AddSourceLocation(E->getRParenLoc());
-  Code = serialization::EXPR_VA_ARG_PACK;
-}
-
 void ASTStmtWriter::VisitSourceLocExpr(SourceLocExpr *E) {
   VisitExpr(E);
   Record.AddDeclRef(cast_or_null<Decl>(E->getParentContext()));
   Record.AddSourceLocation(E->getBeginLoc());
   Record.AddSourceLocation(E->getEndLoc());
   Record.push_back(E->getIdentKind());
   Code = serialization::EXPR_SOURCE_LOC;
 }

clang/lib/StaticAnalyzer/Core/ExprEngine.cpp

switch (S->getStmtClass()) {
     case Stmt::ObjCEncodeExprClass:
     case Stmt::ObjCIsaExprClass:
     case Stmt::ObjCProtocolExprClass:
     case Stmt::ObjCSelectorExprClass:
     case Stmt::ParenListExprClass:
     case Stmt::ShuffleVectorExprClass:
     case Stmt::ConvertVectorExprClass:
     case Stmt::VAArgExprClass:
-    case Stmt::VAArgPackExprClass:
     case Stmt::CUDAKernelCallExprClass:
     case Stmt::OpaqueValueExprClass:
     case Stmt::AsTypeExprClass:
     case Stmt::ConceptSpecializationExprClass:
     case Stmt::CXXRewrittenBinaryOperatorClass:
     case Stmt::RequiresExprClass:
       // Fall through.
 

clang/tools/libclang/CXCursor.cpp

CXCursor cxcursor::MakeCXCursor(const Stmt *S, const Decl *Parent,
   case Stmt::ObjCIndirectCopyRestoreExprClass:
   case Stmt::OffsetOfExprClass:
   case Stmt::ParenListExprClass:
   case Stmt::PredefinedExprClass:
   case Stmt::ShuffleVectorExprClass:
   case Stmt::SourceLocExprClass:
   case Stmt::ConvertVectorExprClass:
   case Stmt::VAArgExprClass:
-  case Stmt::VAArgPackExprClass:
   case Stmt::ObjCArrayLiteralClass:
   case Stmt::ObjCDictionaryLiteralClass:
   case Stmt::ObjCBoxedExprClass:
   case Stmt::ObjCSubscriptRefExprClass:
   case Stmt::RecoveryExprClass:
     K = CXCursor_UnexposedExpr;
     break;