# Miscellaenous alignment assertions and fixes.

# Remove bitfields if possible (not always possible).

# Upstream loves bitfields.

# 3.9.X upstream.

--- tools/clang/include/clang/AST/DeclCXX.h	2015-12-29 22:24:14.000000000 -0500

+++ tools/clang/include/clang/AST/DeclCXX.h	2016-05-08 23:19:20.540430947 -0400

@@ -2120,6 +2120,10 @@

   friend TrailingObjects;

 };

+static_assert(

+    llvm::AlignOf<CXXCtorInitializer>::Alignment >=

+        llvm::AlignOf<VarDecl *>::Alignment,

+    "Alignment is insufficient for objects appended to CXXCtorInitializer");

 /// \brief Represents a C++ constructor within a class.

 ///

--- tools/clang/include/clang/AST/DeclFriend.h	2015-12-29 17:13:13.000000000 -0500

+++ tools/clang/include/clang/AST/DeclFriend.h	2016-05-08 23:19:20.540430947 -0400

@@ -168,6 +168,9 @@

   friend class ASTDeclWriter;

   friend TrailingObjects;

 };

+static_assert(llvm::AlignOf<FriendDecl>::Alignment >=

+                  llvm::AlignOf<TemplateParameterList *>::Alignment,

+              "Alignment is insufficient for objects appended to FriendDecl");

 /// An iterator over the friend declarations of a class.

 class CXXRecordDecl::friend_iterator {

--- tools/clang/include/clang/AST/DeclGroup.h	2015-12-29 17:13:13.000000000 -0500

+++ tools/clang/include/clang/AST/DeclGroup.h	2016-05-08 23:19:20.541430972 -0400

@@ -14,6 +14,7 @@

 #ifndef LLVM_CLANG_AST_DECLGROUP_H

 #define LLVM_CLANG_AST_DECLGROUP_H

+#include "llvm/Support/AlignOf.h"

 #include "llvm/Support/DataTypes.h"

 #include "llvm/Support/TrailingObjects.h"

 #include <cassert>

@@ -50,6 +51,9 @@

   friend TrailingObjects;

 };

+static_assert(llvm::AlignOf<DeclGroup>::Alignment >=

+                  llvm::AlignOf<Decl *>::Alignment,

+              "Alignment is insufficient for objects appended to DeclGroup");

 class DeclGroupRef {

   // Note this is not a PointerIntPair because we need the address of the

--- tools/clang/include/clang/AST/Decl.h	2016-01-06 17:49:11.000000000 -0500

+++ tools/clang/include/clang/AST/Decl.h	2016-05-08 23:19:20.542430996 -0400

@@ -3713,6 +3713,9 @@

   static bool classof(const Decl *D) { return classofKind(D->getKind()); }

   static bool classofKind(Kind K) { return K == Import; }

 };

+static_assert(llvm::AlignOf<ImportDecl>::Alignment >=

+                  llvm::AlignOf<SourceLocation>::Alignment,

+              "Alignment is insufficient for objects appended to ImportDecl");

 /// \brief Represents an empty-declaration.

 class EmptyDecl : public Decl {

--- tools/clang/include/clang/AST/DeclOpenMP.h	2015-12-29 17:13:13.000000000 -0500

+++ tools/clang/include/clang/AST/DeclOpenMP.h	2016-05-08 23:19:20.542430996 -0400

@@ -85,6 +85,10 @@

   static bool classof(const Decl *D) { return classofKind(D->getKind()); }

   static bool classofKind(Kind K) { return K == OMPThreadPrivate; }

 };

+static_assert(

+    llvm::AlignOf<OMPThreadPrivateDecl>::Alignment >=

+        llvm::AlignOf<Expr *>::Alignment,

+    "Alignment is insufficient for objects appended to OMPThreadPrivateDecl");

 }  // end namespace clang

###

--- tools/clang/include/clang/AST/DeclTemplate.h	2015-12-29 14:13:13.000000000 -0800

+++ tools/clang/include/clang/AST/DeclTemplate.h	2016-05-09 13:56:11.451547165 -0700

@@ -56,11 +56,11 @@

   /// The number of template parameters in this template

   /// parameter list.

-  unsigned NumParams : 31;

+  unsigned NumParams;

   /// Whether this template parameter list contains an unexpanded parameter

   /// pack.

-  unsigned ContainsUnexpandedParameterPack : 1;

+  bool ContainsUnexpandedParameterPack;

 protected:

   size_t numTrailingObjects(OverloadToken<NamedDecl *>) const {

@@ -138,6 +138,10 @@

   friend TrailingObjects;

   template <size_t N> friend class FixedSizeTemplateParameterListStorage;

 };

+static_assert(

+    llvm::AlignOf<TemplateParameterList>::Alignment >=

+        llvm::AlignOf<NamedDecl *>::Alignment,

+    "Insufficient alignment for objects appended to TemplateParameterList");

 /// \brief Stores a list of template parameters for a TemplateDecl and its

 /// derived classes. Suitable for creating on the stack.

@@ -582,6 +586,21 @@

   Create(ASTContext &Context, const UnresolvedSetImpl &Templates,

          const TemplateArgumentListInfo &TemplateArgs);

+  DependentFunctionTemplateSpecializationInfo(

+    const DependentFunctionTemplateSpecializationInfo &RHS)

+    : NumTemplates(RHS.NumTemplates), NumArgs(RHS.NumArgs),

+    AngleLocs(RHS.AngleLocs) { }

+

+  DependentFunctionTemplateSpecializationInfo

+    &operator=(const DependentFunctionTemplateSpecializationInfo &RHS) {

+      if (this != &RHS) {

+        NumTemplates = RHS.NumTemplates;

+        NumArgs = RHS.NumArgs;

+        AngleLocs = RHS.AngleLocs;

+      }

+      return *this;

+    }

+

   /// \brief Returns the number of function templates that this might

   /// be a specialization of.

   unsigned getNumTemplates() const { return NumTemplates; }

@@ -617,6 +636,16 @@

   friend TrailingObjects;

 };

+static_assert(

+  llvm::AlignOf<DependentFunctionTemplateSpecializationInfo>::Alignment >=

+  llvm::AlignOf<TemplateArgumentLoc>::Alignment,

+  "Insufficient alignment for objects appended to "

+  "DependentFunctionTemplateSpecializationInfo");

+static_assert(llvm::AlignOf<TemplateArgumentLoc>::Alignment >=

+              llvm::AlignOf<FunctionTemplateDecl *>::Alignment,

+              "Insufficient alignment for objects appended to "

+              "DependentFunctionTemplateSpecializationInfo");

+

 /// Declaration of a redeclarable template.

 class RedeclarableTemplateDecl : public TemplateDecl, 

                                  public Redeclarable<RedeclarableTemplateDecl> 

@@ -1310,6 +1339,10 @@

   static bool classof(const Decl *D) { return classofKind(D->getKind()); }

   static bool classofKind(Kind K) { return K == NonTypeTemplateParm; }

 };

+static_assert(llvm::AlignOf<NonTypeTemplateParmDecl>::Alignment >=

+                  llvm::AlignOf<void *>::Alignment,

+              "Insufficient alignment for objects appended to "

+              "NonTypeTemplateParmDecl");

 /// TemplateTemplateParmDecl - Declares a template template parameter,

 /// e.g., "T" in

@@ -1478,6 +1511,10 @@

   friend class ASTDeclWriter;

   friend TrailingObjects;

 };

+static_assert(llvm::AlignOf<TemplateTemplateParmDecl>::Alignment >=

+                  llvm::AlignOf<TemplateParameterList *>::Alignment,

+              "Insufficient alignment for objects appended to "

+              "TemplateTemplateParmDecl");

 /// \brief Represents the builtin template declaration which is used to

 /// implement __make_integer_seq.  It serves no real purpose beyond existing as

###

--- tools/clang/include/clang/AST/ExprCXX.h	2016-01-06 14:34:54.000000000 -0800

+++ tools/clang/include/clang/AST/ExprCXX.h	2016-05-09 14:06:13.555769345 -0700

@@ -1013,6 +1013,11 @@

   friend class ASTStmtWriter;

 };

+static_assert(llvm::AlignOf<CXXDefaultArgExpr>::Alignment >=

+              llvm::AlignOf<Expr *>::Alignment,

+              "Insufficient alignment for objects appended to "

+              "CXXDefaultArgExpr");

+

 /// \brief A use of a default initializer in a constructor or in aggregate

 /// initialization.

 ///

@@ -1678,6 +1683,17 @@

   friend class ASTStmtWriter;

 };

+static_assert(llvm::AlignOf<LambdaExpr>::Alignment >=

+              llvm::AlignOf<Stmt *>::Alignment,

+              "Insufficient alignment for objects appended to LambdaExpr");

+static_assert(llvm::AlignOf<Stmt *>::Alignment >=

+                  llvm::AlignOf<unsigned>::Alignment,

+              "Insufficient alignment for objects appended to LambdaExpr");

+// Code re-aligns before VarDecl *[]

+static_assert(llvm::AlignOf<LambdaExpr>::Alignment >=

+                  llvm::AlignOf<VarDecl *>::Alignment,

+              "Insufficient alignment for objects appended to LambdaExpr");

+

 /// An expression "T()" which creates a value-initialized rvalue of type

 /// T, which is a non-class type.  See (C++98 [5.2.3p2]).

 class CXXScalarValueInitExpr : public Expr {

@@ -2264,6 +2280,11 @@

   friend class ASTStmtWriter;

 };

+static_assert(

+    llvm::AlignOf<TypeTraitExpr>::Alignment >=

+    llvm::AlignOf<TypeSourceInfo *>::Alignment,

+    "Insufficient alignment for objects appended to TypeTraitExpr");

+

 /// \brief An Embarcadero array type trait, as used in the implementation of

 /// __array_rank and __array_extent.

 ///

@@ -2399,7 +2420,7 @@

 /// \brief A reference to an overloaded function set, either an

 /// \c UnresolvedLookupExpr or an \c UnresolvedMemberExpr.

-class OverloadExpr : public Expr {

+class LLVM_ALIGNAS(/*alignof(uint64_t)*/ 8) OverloadExpr : public Expr {

   /// \brief The common name of these declarations.

   DeclarationNameInfo NameInfo;

@@ -2689,6 +2710,11 @@

   }

 };

+static_assert(llvm::AlignOf<UnresolvedLookupExpr>::Alignment >=

+              llvm::AlignOf<ASTTemplateKWAndArgsInfo>::Alignment,

+              "Insufficient alignment for objects appended to "

+              "UnresolvedLookupExpr");

+

 /// \brief A qualified reference to a name whose declaration cannot

 /// yet be resolved.

 ///

@@ -2834,6 +2860,11 @@

   friend class ASTStmtWriter;

 };

+static_assert(llvm::AlignOf<DependentScopeDeclRefExpr>::Alignment >=

+              llvm::AlignOf<ASTTemplateKWAndArgsInfo>::Alignment,

+              "Insufficient alignment for objects appended to "

+              "DependentScopeDeclRefExpr");

+

 /// Represents an expression -- generally a full-expression -- that

 /// introduces cleanups to be run at the end of the sub-expression's

 /// evaluation.  The most common source of expression-introduced

@@ -2903,6 +2934,11 @@

   child_range children() { return child_range(&SubExpr, &SubExpr + 1); }

 };

+static_assert(llvm::AlignOf<ExprWithCleanups>::Alignment >=

+              llvm::AlignOf<ExprWithCleanups::CleanupObject>::Alignment,

+              "Insufficient alignment for objects appended to "

+              "ExprWithCleanups");

+

 /// \brief Describes an explicit type conversion that uses functional

 /// notion but could not be resolved because one or more arguments are

 /// type-dependent.

@@ -3024,6 +3060,11 @@

   }

 };

+static_assert(llvm::AlignOf<CXXUnresolvedConstructExpr>::Alignment >=

+              llvm::AlignOf<Expr *>::Alignment,

+              "Insufficient alignment for objects appended to "

+              "CXXUnresolvedConstructExpr");

+

 /// \brief Represents a C++ member access expression where the actual

 /// member referenced could not be resolved because the base

 /// expression or the member name was dependent.

@@ -3046,11 +3087,11 @@

   /// \brief Whether this member expression used the '->' operator or

   /// the '.' operator.

-  bool IsArrow : 1;

+  bool IsArrow;

   /// \brief Whether this member expression has info for explicit template

   /// keyword and arguments.

-  bool HasTemplateKWAndArgsInfo : 1;

+  bool HasTemplateKWAndArgsInfo;

   /// \brief The location of the '->' or '.' operator.

   SourceLocation OperatorLoc;

@@ -3250,6 +3291,11 @@

   friend class ASTStmtWriter;

 };

+static_assert(llvm::AlignOf<CXXDependentScopeMemberExpr>::Alignment >=

+              llvm::AlignOf<ASTTemplateKWAndArgsInfo>::Alignment,

+              "Insufficient alignment for objects appended to "

+              "CXXDependentScopeMemberExpr");

+

 /// \brief Represents a C++ member access expression for which lookup

 /// produced a set of overloaded functions.

 ///

@@ -3271,11 +3317,11 @@

           UnresolvedMemberExpr, ASTTemplateKWAndArgsInfo, TemplateArgumentLoc> {

   /// \brief Whether this member expression used the '->' operator or

   /// the '.' operator.

-  bool IsArrow : 1;

+  bool IsArrow;

   /// \brief Whether the lookup results contain an unresolved using

   /// declaration.

-  bool HasUnresolvedUsing : 1;

+  bool HasUnresolvedUsing;

   /// \brief The expression for the base pointer or class reference,

   /// e.g., the \c x in x.f.

@@ -3399,6 +3445,11 @@

   }

 };

+static_assert(llvm::AlignOf<UnresolvedMemberExpr>::Alignment >=

+              llvm::AlignOf<ASTTemplateKWAndArgsInfo>::Alignment,

+              "Insufficient alignment for objects appended to "

+              "UnresolvedMemberExpr");

+

 inline ASTTemplateKWAndArgsInfo *

 OverloadExpr::getTrailingASTTemplateKWAndArgsInfo() {

   if (!HasTemplateKWAndArgsInfo)

@@ -3841,6 +3892,11 @@

   }

 };

+static_assert(llvm::AlignOf<FunctionParmPackExpr>::Alignment >=

+              llvm::AlignOf<ParmVarDecl *>::Alignment,

+              "Insufficient alignment for objects appended to "

+              "FunctionParmPackExpr");

+

 /// \brief Represents a prvalue temporary that is written into memory so that

 /// a reference can bind to it.

 ///

###

--- tools/clang/include/clang/AST/Expr.h	2016-01-07 12:59:26.000000000 -0800

+++ tools/clang/include/clang/AST/Expr.h	2016-05-09 13:48:08.744463290 -0700

@@ -1142,6 +1142,17 @@

   friend class ASTStmtWriter;

 };

+static_assert(llvm::AlignOf<DeclRefExpr>::Alignment >=

+                  llvm::AlignOf<NestedNameSpecifierLoc>::Alignment,

+              "Alignment is insufficient for objects appended to DeclRefExpr");

+static_assert(llvm::AlignOf<NestedNameSpecifierLoc>::Alignment >=

+                  llvm::AlignOf<NamedDecl *>::Alignment,

+              "Alignment is insufficient for objects appended to NestedNameSpecifierLoc");

+// Code re-aligns before ASTTemplateKWAndArgsInfo

+static_assert(llvm::AlignOf<DeclRefExpr>::Alignment >=

+                  llvm::AlignOf<ASTTemplateKWAndArgsInfo>::Alignment,

+              "Alignment is insufficient for objects appended to DeclRefExpr");

+

 /// \brief [C99 6.4.2.2] - A predefined identifier such as __func__.

 class PredefinedExpr : public Expr {

 public:

@@ -1753,7 +1764,7 @@

 /// Helper class for OffsetOfExpr.

 // __builtin_offsetof(type, identifier(.identifier|[expr])*)

-class OffsetOfNode {

+class LLVM_ALIGNAS(/*alignof(uint64_t)*/ 8) OffsetOfNode {

 public:

   /// \brief The kind of offsetof node we have.

   enum Kind {

@@ -1857,7 +1868,7 @@

 /// @endcode

 /// we can represent and evaluate the expression @c offsetof(struct T, s[2].d).

-class OffsetOfExpr final

+class LLVM_ALIGNAS(/*alignof(uint64_t)*/ 8) OffsetOfExpr final

     : public Expr,

       private llvm::TrailingObjects<OffsetOfExpr, OffsetOfNode, Expr *> {

   SourceLocation OperatorLoc, RParenLoc;

@@ -1954,6 +1965,22 @@

   friend TrailingObjects;

 };

+static_assert(llvm::AlignOf<OffsetOfExpr>::Alignment >=

+                  llvm::AlignOf<OffsetOfNode*>::Alignment,

+              "Insufficient aligment for objects appended to OffsetOfExpr");

+static_assert(llvm::AlignOf<OffsetOfNode>::Alignment >=

+                  llvm::AlignOf<Expr*>::Alignment,

+              "Insufficient alignment for objects appended to OffsetOfExpr");

+

+#if 0

+static_assert(llvm::AlignOf<OffsetOfExpr>::Alignment >=

+                  llvm::AlignOf<OffsetOfExpr::OffsetOfNode *>::Alignment,

+              "Alignment is insufficient for objects appended to OffsetOfExpr");

+static_assert(llvm::AlignOf<OffsetOfExpr::OffsetOfNode>::Alignment >=

+                  llvm::AlignOf<Expr *>::Alignment,

+              "Alignment is insufficient for objects appended to OffsetOfExpr");

+#endif

+

 /// UnaryExprOrTypeTraitExpr - expression with either a type or (unevaluated)

 /// expression operand.  Used for sizeof/alignof (C99 6.5.3.4) and

 /// vec_step (OpenCL 1.1 6.11.12).

@@ -2318,24 +2345,24 @@

   SourceLocation OperatorLoc;

   /// IsArrow - True if this is "X->F", false if this is "X.F".

-  bool IsArrow : 1;

+  bool IsArrow;

   /// \brief True if this member expression used a nested-name-specifier to

   /// refer to the member, e.g., "x->Base::f", or found its member via a using

   /// declaration.  When true, a MemberExprNameQualifier

   /// structure is allocated immediately after the MemberExpr.

-  bool HasQualifierOrFoundDecl : 1;

+  bool HasQualifierOrFoundDecl;

   /// \brief True if this member expression specified a template keyword

   /// and/or a template argument list explicitly, e.g., x->f<int>,

   /// x->template f, x->template f<int>.

   /// When true, an ASTTemplateKWAndArgsInfo structure and its

   /// TemplateArguments (if any) are present.

-  bool HasTemplateKWAndArgsInfo : 1;

+  bool HasTemplateKWAndArgsInfo;

   /// \brief True if this member expression refers to a method that

   /// was resolved from an overloaded set having size greater than 1.

-  bool HadMultipleCandidates : 1;

+  bool HadMultipleCandidates;

   size_t numTrailingObjects(OverloadToken<MemberExprNameQualifier>) const {

     return HasQualifierOrFoundDecl ? 1 : 0;

@@ -2688,6 +2715,11 @@

   // Iterators

   child_range children() { return child_range(&Op, &Op+1); }

 };

+static_assert(llvm::AlignOf<CastExpr>::Alignment >=

+                  llvm::AlignOf<CXXBaseSpecifier *>::Alignment,

+              "Alignment is insufficient for objects appended to CastExpr");

+// (Note that the data is actually tacked onto one of its subclasses,

+// but they'll inherit alignment)

 /// ImplicitCastExpr - Allows us to explicitly represent implicit type

 /// conversions, which have no direct representation in the original

@@ -4316,6 +4348,10 @@

     return child_range(&BaseAndUpdaterExprs[0], &BaseAndUpdaterExprs[0] + 2);

   }

 };

+static_assert(

+    llvm::AlignOf<DesignatedInitExpr>::Alignment >=

+        llvm::AlignOf<Stmt *>::Alignment,

+    "Alignment is insufficient for objects appended to DesignatedInitExpr");

 /// \brief Represents an implicitly-generated value initialization of

 /// an object of a given type.

@@ -4808,6 +4844,10 @@

   friend TrailingObjects;

   friend class ASTStmtReader;

 };

+static_assert(

+    llvm::AlignOf<PseudoObjectExpr>::Alignment >=

+        llvm::AlignOf<Expr *>::Alignment,

+    "Alignment is insufficient for objects appended to PseudoObjectExpr");

 /// AtomicExpr - Variadic atomic builtins: __atomic_exchange, __atomic_fetch_*,

 /// __atomic_load, __atomic_store, and __atomic_compare_exchange_*, for the

###

--- tools/clang/include/clang/AST/ExprObjC.h	2015-12-30 20:43:19.000000000 -0800

+++ tools/clang/include/clang/AST/ExprObjC.h	2016-05-09 14:56:41.962219122 -0700

@@ -206,6 +206,10 @@

   friend TrailingObjects;

   friend class ASTStmtReader;

 };

+static_assert(

+    llvm::AlignOf<ObjCArrayLiteral>::Alignment >=

+        llvm::AlignOf<Expr *>::Alignment,

+    "Alignment is insufficient for objects appended to ObjCArrayLiteral");

 /// \brief An element in an Objective-C dictionary literal.

 ///

@@ -260,7 +264,7 @@

                                     ObjCDictionaryLiteral_KeyValuePair,

                                     ObjCDictionaryLiteral_ExpansionData> {

   /// \brief The number of elements in this dictionary literal.

-  unsigned NumElements : 31;

+  unsigned NumElements;

   /// \brief Determine whether this dictionary literal has any pack expansions.

   ///

@@ -269,11 +273,12 @@

   /// key/value pairs, which provide the locations of the ellipses (if

   /// any) and number of elements in the expansion (if known). If

   /// there are no pack expansions, we optimize away this storage.

-  unsigned HasPackExpansions : 1;

+  bool HasPackExpansions;

   SourceRange Range;

   ObjCMethodDecl *DictWithObjectsMethod;

+public:

   typedef ObjCDictionaryLiteral_KeyValuePair KeyValuePair;

   typedef ObjCDictionaryLiteral_ExpansionData ExpansionData;

@@ -347,7 +352,14 @@

   friend class ASTStmtWriter;

   friend TrailingObjects;

 };

-

+static_assert(

+    llvm::AlignOf<ObjCDictionaryLiteral>::Alignment >=

+        llvm::AlignOf<ObjCDictionaryLiteral::KeyValuePair>::Alignment,

+    "Alignment is insufficient for objects appended to ObjCDictionaryLiteral");

+static_assert(

+    llvm::AlignOf<ObjCDictionaryLiteral::KeyValuePair>::Alignment >=

+        llvm::AlignOf<ObjCDictionaryLiteral::ExpansionData>::Alignment,

+    "Alignment is insufficient for objects appended to ObjCDictionaryLiteral");

 /// ObjCEncodeExpr, used for \@encode in Objective-C.  \@encode has the same

 /// type and behavior as StringLiteral except that the string initializer is

@@ -1377,6 +1389,17 @@

   friend class ASTStmtReader;

   friend class ASTStmtWriter;

 };

+static_assert(

+    llvm::AlignOf<ObjCMessageExpr>::Alignment >=

+        llvm::AlignOf<void *>::Alignment,

+    "Alignment is insufficient for objects appended to ObjCMessageExpr");

+static_assert(

+    llvm::AlignOf<void *>::Alignment >= llvm::AlignOf<Expr *>::Alignment,

+    "Alignment is insufficient for objects appended to ObjCMessageExpr");

+static_assert(

+    llvm::AlignOf<Expr *>::Alignment >=

+        llvm::AlignOf<SourceLocation>::Alignment,

+    "Alignment is insufficient for objects appended to ObjCMessageExpr");

 /// ObjCIsaExpr - Represent X->isa and X.isa when X is an ObjC 'id' type.

 /// (similar in spirit to MemberExpr).

### NO PACE

--- tools/clang/include/clang/AST/Mangle.h	2015-12-31 00:36:54.000000000 -0500

+++ tools/clang/include/clang/AST/Mangle.h	2016-05-08 23:19:20.547431117 -0400

@@ -129,6 +129,8 @@