Fix alignment issues in Clang.

[jyknight]

Summary

Adds static_asserts to ensure alignment of concatenated objects is
correct, and fixes them where they are not.

Some const-correctness changes snuck in here too, since they were in the
area of code I was modifying.

This seems to make Clang actually work without Bus Error on 32bit
sparc.

[majnemer]

include/clang/AST/Type.h

3924–3930

This code is commented out.

4268–4272

As is this.

lib/CodeGen/CGCleanup.cpp

129

deallocate sounds more natural to me, what do you think?

[jyknight]

Address review comments.

[jyknight]

Any further comments? (Note: I will globally replace the text "Alignment sufficient for" to "Alignment is not sufficient for", as per the review comments on the LLVM half of this change.)

[jyknight]

Ping.

[jyknight]

Updated to head.

[rnk]

Most of actual fixes look good, but this adds an awful lot of static_asserts, and they are very far from the code implementing the trailing object array idiom. I chatted with Richard, and he suggested that wrap up the reinterpret_cast<T>(this + 1) idiom into something higher level. We could write a helper like this:

namespace llvm {
template <TrailingTy, LeadingTy>
TrailingTy *getTrailingObjects(LeadingTy *Obj) {
  static_assert(llvm::AlignOf<LeadingTy>::Alignment >= llvm::AlignOf<TrailingTy>::Alignment,
                "TrailingTy requires more alignment than LeadingTy provides");
  return reinterpret_cast<TrailingTy *>(Obj + 1);
}
}

The static_assert message ends up being less specific, but clang at least will print out the template instantiation backtrace, which should make it easy to figure out. This pattern should work so long as the trailing type is complete before the definition of the accessor, but the TemplateSpecializationType and TemplateArgument case is probably won't work. We should probably do the static_assert manually in the constructor in that case. The constructor also implements the trailing object array idiom, so again it keeps the assert closer to the relevant implementation.

What do you think?

include/clang/AST/Type.h

3924–3930

This still appears to be an issue?

[jyknight]

So, a couple things:

Firstly:

I think it's pretty sad that this idiom of manually dealing with memory layout is used all over the place, and has basically no abstraction. In addition to having to coordinate carefully between allocation and access, as it stands, it's almost impossible to tell from the header what the layout of the object actually is -- for example, in Decl.h, there's no hint that ImportDecl has a SourceLocation array appended to it. This is somewhat unfortunate.

I understand that it's done this way for speed and memory efficiency, but I can't help but think there *must* be a better way to accomplish it than to splatter manual object size arithmetic and reinterpret casts so widely over the codebase.

It'd be great if the GCC zero-length-array extension could be used, or if C++ had adopted C11's flexible array members. That would help in the perhaps 75% of cases where it's just a single optional trailing object, or array of trailing objects of the same type.

That makes the allocation size arithmetic easier -- offsetof(Type, arrayfield[num_elements]). It makes the access easier (just reference the field). And it makes the alignment simply handled by the compiler. I believe GCC's extension is supported by GCC, Clang, and VC++. I guess there's a desire to not use extensions like that even if they are supported by the compilers we care about?

And besides being not standard C++, that also wouldn't work for the ~25% of cases which have multiple kinds of appended objects, that come one after another. As an alternative to the GCC zero-length-array option, I had thought of perhaps making a template base class that handles these sorts of layouts, somehow, but hadn't really thought it through terribly far how it might work. (Or if it'd be too complicated to even be worth it.)

Secondly:

There are more cases where the suggestion doesn't work than just forward declarations. "this + 1" or "X + 1" is only used some of the time, there's many other ways that code accesses appended objects.

E.g. DeclTemplate.h DependentFunctionTemplateSpecializationInfo has:

FunctionTemplateDecl * const *getTemplates() const {
  return reinterpret_cast<FunctionTemplateDecl*const*>(&getTemplateArgs()[NumArgs]);
}

Or then there's DeclRefExpr

return reinterpret_cast<ASTTemplateKWAndArgsInfo *>(
    llvm::alignAddr(&getInternalFoundDecl() + 1,
                    llvm::alignOf<ASTTemplateKWAndArgsInfo>()));

which re-aligns, and thus doesn't require that getInternalFoundDecl() is aligned properly for the ASTTemplateKWAndArgsInfo object -- but the base DeclRefExpr itself really ought to be aligned enough for ASTTemplateKWAndArgsInfo, or else the layout of the object would change depending on its address!

Annnnnnnnnnnnnnnnnyways:

I had originally started to put these asserts in the constructors, but that seemed far from the accesses and was hidden off in a random cpp file, and sometimes there are multiple of them, spread around. So I tried the accesses, but sometimes those were spread around multiple places too. So eventually I just settled on the class definition, because it's always right there and there's one of it. :)

I can make the requested change, in the subset of cases where it works, and will certainly do so if still requested. But I'm not really sure it's worth it, because it removes what is often the only documentation of Weirdness going on, at the class definition site.

And, I think the Right Thing is to address the deeper problem of what really seems to me like borderline unreadable code -- somehow. If that can be done, it will naturally allow alignment asserts to be removed at the same time as the casts and sizeof arithmetic, because it'd be unnecessary if the compiler or some common library code was ensuring that allocation and sizing and offsets and alignment are all done consistently and correctly.

[rnk]

I think there were issues with trailing arrays, which is why Clang ended up settling on this pattern in the first place. Barring significant changes, I think wrapping this up with some library code is the way to go. That's kind of what we were thinking with getTrailingObjects(). :-)

I think for the oddball cases like multiple trailing arrays, we can do stuff like this:

FunctionTemplateDecl * const *getTemplates() const {
  return getTrailingObjects<FunctionTemplateDecl*const>(&getTemplateArgs()[NumArgs-1]);
}

In general, we probably want to lay out trailing arrays in order of higher alignments to lower alignments to avoid the extra alignment code, and if we get it wrong, the wrapper will tell us.

For the DeclRefExpr::getFoundDeclInternal() case, I could see adding some kind of wrapper struct with 8 byte alignment around the found found Decl pointer.

As far as documentation goes, I'd rather update the Doxygen to indicate which classes have trailing data. Most of the commonly used classes like DeclRefExpr are already annotated as such.

Another benefit of the getTrailingObjects wrapper is that we can static_assert that the class with trailing data is final.

In conclusion, I guess I would like to push for this wrapper. It seems like it moves incrementally closer towards the better end state that you want, which is less pointer arithmetic and casts sprinkled across the AST. Sound reasonable?

[jyknight]

Yes, that does sounds entirely reasonable.

However, before implementing your suggestion, I'm going to spend at least a little while first trying to write a more complete solution that I actually like, in hopes of not spending time to rework things to get a mediocre improvement when it could be a large improvement.

E.g., something like:

class ImportDecl : public Decl, TrailingObjects<ImportDecl, SourceLocation> {...}

or

class DependentFunctionTemplateSpecializationInfo : TrailingObjects<DependentFunctionTemplateSpecializationInfo, TemplateArgumentLoc, FunctionTemplateDecl*> {...}

with TrailingObjects implementing some useful protected functions.

If this doesn't seem to be working out reasonably, I'll implement your suggestion. :)

[jyknight]

Okay, so, I've deleted all the static-asserts from this CL -- so it is now basically just the fixes I had before, and not the static_asserts everywhere. Can we agree to commit a reduced-scope CL, so at least the alignment problems are resolved?

I'm also about to upload some CLs with a proposal for, and some example conversions to TrailingObjects class. If/Once there's agreement that it seems good and the initial few are submitted, I can finish up the remaining classes in follow-up CLs. (I'll cc everyone watching this on those new ones too.)

[jyknight]

Reduce scope of patch.

[rnk]

lgtm

[ovyalov]

cfe/trunk/lib/CodeGen/EHScopeStack.h

99 ↗

(On Diff #30018)

Android i386 build sets ScopeStackAlignment = 4 and breaking the build - http://lab.llvm.org:8011/builders/lldb-x86_64-ubuntu-14.04-android/builds/742
Could you handle this use case or consider reverting the CL?

[jyknight]

Blah.

So, the issue is that LLVM_ALIGNAS needs an integer, not a constant
expression, because of MSVC limitations. Otherwise, EHCleanupScope would
also specify uint64_t alignment, instead of 8.

I'll just change ScopeStackAlignment to a fixed 8, to match.
​

include/clang/AST/Decl.h

public:
   /// identifiers aren't available.
   ArrayRef<SourceLocation> getIdentifierLocs() const;
 
   SourceRange getSourceRange() const override LLVM_READONLY;
 
   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 sufficient for objects appended to ImportDecl");
 
 /// \brief Represents an empty-declaration.
 class EmptyDecl : public Decl {
   virtual void anchor();
   EmptyDecl(DeclContext *DC, SourceLocation L)
     : Decl(Empty, DC, L) { }
 
 public:

include/clang/AST/DeclBase.h

enum AvailabilityResult {
     AR_NotYetIntroduced,
     AR_Deprecated,
     AR_Unavailable
   };
 
 /// Decl - This represents one declaration (or definition), e.g. a variable,
 /// typedef, function, struct, etc.
 ///
+/// Note: There are objects tacked on before the *beginning* of Decl
+/// (and its subclasses) in its Decl::operator new(). Proper alignment
+/// of all subclasses (not requiring more than DeclObjAlignment) is
+/// asserted in DeclBase.cpp.
 class Decl {
 public:
+  /// \brief Alignment guaranteed when allocating Decl and any subtypes.
+  enum { DeclObjAlignment = llvm::AlignOf<uint64_t>::Alignment };
+
   /// \brief Lists the kind of concrete classes of Decl.
   enum Kind {
 #define DECL(DERIVED, BASE) DERIVED,
 #define ABSTRACT_DECL(DECL)
 #define DECL_RANGE(BASE, START, END) \
         first##BASE = START, last##BASE = END,
 #define LAST_DECL_RANGE(BASE, START, END) \
         first##BASE = START, last##BASE = END

include/clang/AST/DeclCXX.h

ArrayRef<VarDecl *> getArrayIndexes() {
     assert(getNumArrayIndices() != 0 && "Getting indexes for non-array init");
     return llvm::makeArrayRef(reinterpret_cast<VarDecl **>(this + 1),
                               getNumArrayIndices());
   }
 
   /// \brief Get the initializer.
   Expr *getInit() const { return static_cast<Expr*>(Init); }
 };
+static_assert(
+    llvm::AlignOf<CXXCtorInitializer>::Alignment >=
+        llvm::AlignOf<VarDecl *>::Alignment,
+    "Alignment sufficient for objects appended to CXXCtorInitializer");
 
 /// \brief Represents a C++ constructor within a class.
 ///
 /// For example:
 ///
 /// \code
 /// class X {
 /// public:

include/clang/AST/DeclFriend.h

public:
 
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
   static bool classofKind(Kind K) { return K == Decl::Friend; }
 
   friend class ASTDeclReader;
   friend class ASTDeclWriter;
 };
+static_assert(llvm::AlignOf<FriendDecl>::Alignment >=
+                  llvm::AlignOf<TemplateParameterList *>::Alignment,
+              "Alignment sufficient for objects appended to FriendDecl");
 
 /// An iterator over the friend declarations of a class.
 class CXXRecordDecl::friend_iterator {
   FriendDecl *Ptr;
 
   friend class CXXRecordDecl;
   explicit friend_iterator(FriendDecl *Ptr) : Ptr(Ptr) {}
 public:

include/clang/AST/DeclGroup.h

 //===--- DeclGroup.h - Classes for representing groups of Decls -*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 //  This file defines the DeclGroup, DeclGroupRef, and OwningDeclGroup classes.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_AST_DECLGROUP_H
 #define LLVM_CLANG_AST_DECLGROUP_H
 
+#include "llvm/Support/AlignOf.h"
 #include "llvm/Support/DataTypes.h"
 #include <cassert>
 
 namespace clang {
 
 class ASTContext;
 class Decl;
 class DeclGroup;
Decl*& operator[](unsigned i) {
     return ((Decl**) (this+1))[i];
   }
 
   Decl* const& operator[](unsigned i) const {
     assert (i < NumDecls && "Out-of-bounds access.");
     return ((Decl* const*) (this+1))[i];
   }
 };
+static_assert(llvm::AlignOf<DeclGroup>::Alignment >=
+                  llvm::AlignOf<Decl *>::Alignment,
+              "Alignment sufficient for objects appended to DeclGroup");
 
 class DeclGroupRef {
   // Note this is not a PointerIntPair because we need the address of the
   // non-group case to be valid as a Decl** for iteration.
   enum Kind { SingleDeclKind=0x0, DeclGroupKind=0x1, Mask=0x1 };
   Decl* D;
 
   Kind getKind() const {

include/clang/AST/DeclOpenMP.h

public:
   varlist_iterator varlist_begin() { return getVars().begin(); }
   varlist_iterator varlist_end() { return getVars().end(); }
   varlist_const_iterator varlist_begin() const { return getVars().begin(); }
   varlist_const_iterator varlist_end() const { return getVars().end(); }
 
   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 sufficient for objects appended to OMPThreadPrivateDecl");
 
 }  // end namespace clang
 
 #endif

include/clang/AST/DeclTemplate.h

 class VarTemplatePartialSpecializationDecl;
 
 /// \brief Stores a template parameter of any kind.
 typedef llvm::PointerUnion3<TemplateTypeParmDecl*, NonTypeTemplateParmDecl*,
                             TemplateTemplateParmDecl*> TemplateParameter;
 
 /// \brief Stores a list of template parameters for a TemplateDecl and its
 /// derived classes.
-class TemplateParameterList {
+class LLVM_ALIGNAS(/*alignof(void*)*/ LLVM_PTR_SIZE) TemplateParameterList {
   /// The location of the 'template' keyword.
   SourceLocation TemplateLoc;
 
   /// The locations of the '<' and '>' angle brackets.
   SourceLocation LAngleLoc, RAngleLoc;
 
   /// The number of template parameters in this template
   /// parameter list.
public:
   SourceLocation getTemplateLoc() const { return TemplateLoc; }
   SourceLocation getLAngleLoc() const { return LAngleLoc; }
   SourceLocation getRAngleLoc() const { return RAngleLoc; }
 
   SourceRange getSourceRange() const LLVM_READONLY {
     return SourceRange(TemplateLoc, RAngleLoc);
   }
 };
+static_assert(
+    llvm::AlignOf<TemplateParameterList>::Alignment >=
+        llvm::AlignOf<NamedDecl *>::Alignment,
+    "Alignment sufficient 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.
 template<size_t N>
 class FixedSizeTemplateParameterList : public TemplateParameterList {
   NamedDecl *Params[N];
 
 public:

 /// get one of these is in a friend declaration like the following:
 ///
 /// \code
 ///   template \<class T> void foo(T);
 ///   template \<class T> class A {
 ///     friend void foo<>(T);
 ///   };
 /// \endcode
-class DependentFunctionTemplateSpecializationInfo {
-  struct CA {
-    /// The number of potential template candidates.
-    unsigned NumTemplates;
+class LLVM_ALIGNAS(/*alignof(uint64_t)*/ 8) DependentFunctionTemplateSpecializationInfo {
 
-    /// The number of template arguments.
-    unsigned NumArgs;
-  };
-
-  union {
-    // Force sizeof to be a multiple of sizeof(void*) so that the
-    // trailing data is aligned.
-    void *Aligner;
-    struct CA d;
-  };
 
   /// The locations of the left and right angle brackets.
   SourceRange AngleLocs;
 
   FunctionTemplateDecl * const *getTemplates() const {
-    return reinterpret_cast<FunctionTemplateDecl*const*>(this+1);
+    return reinterpret_cast<FunctionTemplateDecl*const*>(&getTemplateArgs()[NumArgs]);
   }
 
 public:
   DependentFunctionTemplateSpecializationInfo(
                                  const UnresolvedSetImpl &Templates,
                                  const TemplateArgumentListInfo &TemplateArgs);
 
   /// \brief Returns the number of function templates that this might
   /// be a specialization of.
   unsigned getNumTemplates() const {
-    return d.NumTemplates;
+    return NumTemplates;
   }
 
   /// \brief Returns the i'th template candidate.
   FunctionTemplateDecl *getTemplate(unsigned I) const {
     assert(I < getNumTemplates() && "template index out of range");
     return getTemplates()[I];
   }
 
   /// \brief Returns the explicit template arguments that were given.
   const TemplateArgumentLoc *getTemplateArgs() const {
-    return reinterpret_cast<const TemplateArgumentLoc*>(
-                                            &getTemplates()[getNumTemplates()]);
+    return reinterpret_cast<const TemplateArgumentLoc*>(this + 1);
   }
 
   /// \brief Returns the number of explicit template arguments that were given.
   unsigned getNumTemplateArgs() const {
-    return d.NumArgs;
+    return NumArgs;
   }
 
   /// \brief Returns the nth template argument.
   const TemplateArgumentLoc &getTemplateArg(unsigned I) const {
     assert(I < getNumTemplateArgs() && "template arg index out of range");
     return getTemplateArgs()[I];
   }
 
   SourceLocation getLAngleLoc() const {
     return AngleLocs.getBegin();
   }
 
   SourceLocation getRAngleLoc() const {
     return AngleLocs.getEnd();
   }
 };
+static_assert(
+    llvm::AlignOf<DependentFunctionTemplateSpecializationInfo>::Alignment >=
+        llvm::AlignOf<TemplateArgumentLoc>::Alignment,
+    "Alignment sufficient for objects appended to "
+    "DependentFunctionTemplateSpecializationInfo");
+static_assert(llvm::AlignOf<TemplateArgumentLoc>::Alignment >=
+                  llvm::AlignOf<FunctionTemplateDecl *>::Alignment,
+              "Alignment sufficient for objects appended to "
+              "DependentFunctionTemplateSpecializationInfo");
 
 /// Declaration of a redeclarable template.
 class RedeclarableTemplateDecl : public TemplateDecl, 
                                  public Redeclarable<RedeclarableTemplateDecl> 
 {
   typedef Redeclarable<RedeclarableTemplateDecl> redeclarable_base;
   RedeclarableTemplateDecl *getNextRedeclarationImpl() override {
     return getNextRedeclaration();
TypeSourceInfo *getExpansionTypeSourceInfo(unsigned I) const {
     void * const *TypesAndInfos = reinterpret_cast<void * const*>(this + 1);
     return static_cast<TypeSourceInfo *>(TypesAndInfos[2*I+1]);
   }
 
   // Implement isa/cast/dyncast/etc.
   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,
+    "Alignment sufficient for objects appended to NonTypeTemplateParmDecl");
 
 /// TemplateTemplateParmDecl - Declares a template template parameter,
 /// e.g., "T" in
 /// @code
 /// template <template <typename> class T> class container { };
 /// @endcode
 /// A template template parameter is a TemplateDecl because it defines the
 /// name of a template and the template parameters allowable for substitution.
public:
 
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Decl *D) { return classofKind(D->getKind()); }
   static bool classofKind(Kind K) { return K == TemplateTemplateParm; }
 
   friend class ASTDeclReader;
   friend class ASTDeclWriter;
 };
+static_assert(
+    llvm::AlignOf<TemplateTemplateParmDecl>::Alignment >=
+        llvm::AlignOf<TemplateParameterList *>::Alignment,
+    "Alignment sufficient for objects appended to TemplateTemplateParmDecl");
 
 /// \brief Represents a class template specialization, which refers to
 /// a class template with a given set of template arguments.
 ///
 /// Class template specializations represent both explicit
 /// specialization of class templates, as in the example below, and
 /// implicit instantiations of class templates.
 ///

include/clang/AST/EvaluatedExprVisitor.h

#define PTR(CLASS) typename Ptr<CLASS>::type
 
   void VisitCallExpr(PTR(CallExpr) CE) {
     if (!CE->isUnevaluatedBuiltinCall(Context))
       return static_cast<ImplClass*>(this)->VisitExpr(CE);
   }
 
   void VisitLambdaExpr(PTR(LambdaExpr) LE) {
     // Only visit the capture initializers, and not the body.
-    for (LambdaExpr::capture_init_iterator I = LE->capture_init_begin(),
+    for (LambdaExpr::const_capture_init_iterator I = LE->capture_init_begin(),
                                                  E = LE->capture_init_end();
          I != E; ++I)
       if (*I)
         this->Visit(*I);
   }
 
   /// \brief The basis case walks all of the children of the statement or
   /// expression, assuming they are all potentially evaluated.
   void VisitStmt(PTR(Stmt) S) {

include/clang/AST/Expr.h

 ///       a NamedDecl (different from the referenced ValueDecl) which was found
 ///       during name lookup and/or overload resolution.
 ///   DeclRefExprBits.HasTemplateKWAndArgsInfo:
 ///       Specifies when this declaration reference expression has an explicit
 ///       C++ template keyword and/or template argument list.
 ///   DeclRefExprBits.RefersToEnclosingVariableOrCapture
 ///       Specifies when this declaration reference expression (validly)
 ///       refers to an enclosed local or a captured variable.
-class DeclRefExpr : public Expr {
+class LLVM_ALIGNAS(/*alignof(uint64_t)*/ 8) DeclRefExpr : public Expr {
   /// \brief The declaration that we are referencing.
   ValueDecl *D;
 
   /// \brief The location of the declaration name itself.
   SourceLocation Loc;
 
   /// \brief Provides source/type location info for the declaration name
   /// embedded in D.
bool hasTemplateKWAndArgsInfo() const {
     return DeclRefExprBits.HasTemplateKWAndArgsInfo;
   }
 
   /// \brief Return the optional template keyword and arguments info.
   ASTTemplateKWAndArgsInfo *getTemplateKWAndArgsInfo() {
     if (!hasTemplateKWAndArgsInfo())
       return nullptr;
 
-    if (hasFoundDecl())
+    if (hasFoundDecl()) {
       return reinterpret_cast<ASTTemplateKWAndArgsInfo *>(
-        &getInternalFoundDecl() + 1);
+          llvm::alignAddr(&getInternalFoundDecl() + 1,
+                          llvm::alignOf<ASTTemplateKWAndArgsInfo>()));
+    }
 
-    if (hasQualifier())
+    if (hasQualifier()) {
       return reinterpret_cast<ASTTemplateKWAndArgsInfo *>(
-        &getInternalQualifierLoc() + 1);
+          llvm::alignAddr(&getInternalQualifierLoc() + 1,
+                          llvm::alignOf<ASTTemplateKWAndArgsInfo>()));
+    }
 
     return reinterpret_cast<ASTTemplateKWAndArgsInfo *>(this + 1);
   }
 
   /// \brief Return the optional template keyword and arguments info.
   const ASTTemplateKWAndArgsInfo *getTemplateKWAndArgsInfo() const {
     return const_cast<DeclRefExpr*>(this)->getTemplateKWAndArgsInfo();
   }
public:
   }
 
   // Iterators
   child_range children() { return child_range(); }
 
   friend class ASTStmtReader;
   friend class ASTStmtWriter;
 };
+static_assert(llvm::AlignOf<DeclRefExpr>::Alignment >=
+                  llvm::AlignOf<NestedNameSpecifierLoc>::Alignment,
+              "Alignment sufficient for objects appended to DeclRefExpr");
+static_assert(llvm::AlignOf<NestedNameSpecifierLoc>::Alignment >=
+                  llvm::AlignOf<NamedDecl *>::Alignment,
+              "Alignment sufficient for objects appended to DeclRefExpr");
+// Code re-aligns before ASTTemplateKWAndArgsInfo
+static_assert(llvm::AlignOf<DeclRefExpr>::Alignment >=
+                  llvm::AlignOf<ASTTemplateKWAndArgsInfo>::Alignment,
+              "Alignment sufficient for objects appended to DeclRefExpr");
 
 /// \brief [C99 6.4.2.2] - A predefined identifier such as __func__.
 class PredefinedExpr : public Expr {
 public:
   enum IdentType {
     Func,
     Function,
     LFunction,  // Same as Function, but as wide string.
public:
   // Iterators
   child_range children() {
     Stmt **begin =
       reinterpret_cast<Stmt**>(reinterpret_cast<OffsetOfNode*>(this + 1)
                                + NumComps);
     return child_range(begin, begin + NumExprs);
   }
 };
+static_assert(llvm::AlignOf<OffsetOfExpr>::Alignment >=
+                  llvm::AlignOf<OffsetOfExpr::OffsetOfNode *>::Alignment,
+              "Alignment sufficient for objects appended to OffsetOfExpr");
+static_assert(llvm::AlignOf<OffsetOfExpr::OffsetOfNode>::Alignment >=
+                  llvm::AlignOf<Expr *>::Alignment,
+              "Alignment sufficient for objects appended to OffsetOfExpr");
 
 /// 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).
 class UnaryExprOrTypeTraitExpr : public Expr {
   union {
     TypeSourceInfo *Ty;
     Stmt *Ex;
public:
   child_range children() {
     return child_range(&SubExprs[0],
                        &SubExprs[0]+NumArgs+getNumPreArgs()+PREARGS_START);
   }
 };
 
 /// MemberExpr - [C99 6.5.2.3] Structure and Union Members.  X->F and X.F.
 ///
-class MemberExpr : public Expr {
+class LLVM_ALIGNAS(/*alignof(uint64_t)*/ 8) MemberExpr : public Expr {
+ public:
   /// Extra data stored in some member expressions.
-  struct MemberNameQualifier {
+  struct LLVM_ALIGNAS(/*alignof(uint64_t)*/ 8) MemberNameQualifier {
     /// \brief The nested-name-specifier that qualifies the name, including
     /// source-location information.
     NestedNameSpecifierLoc QualifierLoc;
 
     /// \brief The DeclAccessPair through which the MemberDecl was found due to
     /// name qualifiers.
     DeclAccessPair FoundDecl;
   };
 
+ private:
   /// Base - the expression for the base pointer or structure references.  In
   /// X.F, this is "X".
   Stmt *Base;
 
   /// MemberDecl - This is the decl being referenced by the field/member name.
   /// In X.F, this is the decl referenced by F.
   ValueDecl *MemberDecl;
 
public:
   }
 
   // Iterators
   child_range children() { return child_range(&Base, &Base+1); }
 
   friend class ASTReader;
   friend class ASTStmtWriter;
 };
+static_assert(llvm::AlignOf<MemberExpr>::Alignment >=
+                  llvm::AlignOf<MemberExpr::MemberNameQualifier>::Alignment,
+              "Alignment sufficient for objects appended to MemberExpr");
+static_assert(llvm::AlignOf<MemberExpr::MemberNameQualifier>::Alignment >=
+                  llvm::AlignOf<ASTTemplateKWAndArgsInfo>::Alignment,
+              "Alignment sufficient for objects appended to MemberExpr");
 
 /// CompoundLiteralExpr - [C99 6.5.2.5]
 ///
 class CompoundLiteralExpr : public Expr {
   /// LParenLoc - If non-null, this is the location of the left paren in a
   /// compound literal like "(int){4}".  This can be null if this is a
   /// synthesized compound expression.
   SourceLocation LParenLoc;
public:
   static bool classof(const Stmt *T) {
     return T->getStmtClass() >= firstCastExprConstant &&
            T->getStmtClass() <= lastCastExprConstant;
   }
 
   // Iterators
   child_range children() { return child_range(&Op, &Op+1); }
 };
+static_assert(llvm::AlignOf<CastExpr>::Alignment >=
+                  llvm::AlignOf<CXXBaseSpecifier *>::Alignment,
+              "Alignment sufficient 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
 /// source code. For example: converting T[]->T*, void f()->void
 /// (*f)(), float->double, short->int, etc.
 ///
 /// In C, implicit casts always produce rvalues. However, in C++, an
 /// implicit cast whose result is being bound to a reference will be
public:
   }
 
   // Iterators
   child_range children() {
     Stmt **begin = reinterpret_cast<Stmt**>(this + 1);
     return child_range(begin, begin + NumSubExprs);
   }
 };
+static_assert(
+    llvm::AlignOf<DesignatedInitExpr>::Alignment >=
+        llvm::AlignOf<Stmt *>::Alignment,
+    "Alignment sufficient for objects appended to DesignatedInitExpr");
 
 /// \brief Represents a place-holder for an object not to be initialized by
 /// anything.
 ///
 /// This only makes sense when it appears as part of an updater of a
 /// DesignatedInitUpdateExpr (see below). The base expression of a DIUE
 /// initializes a big object, and the NoInitExpr's mark the spots within the
 /// big object not to be overwritten by the updater.
child_range children() {
     Stmt **cs = reinterpret_cast<Stmt**>(getSubExprsBuffer());
     return child_range(cs, cs + getNumSubExprs());
   }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == PseudoObjectExprClass;
   }
 };
+static_assert(llvm::AlignOf<PseudoObjectExpr>::Alignment >=
+                  llvm::AlignOf<Expr *>::Alignment,
+              "Alignment sufficient for objects appended to PseudoObjectExpr");
 
 /// AtomicExpr - Variadic atomic builtins: __atomic_exchange, __atomic_fetch_*,
 /// __atomic_load, __atomic_store, and __atomic_compare_exchange_*, for the
 /// similarly-named C++11 instructions, and __c11 variants for <stdatomic.h>.
 /// All of these instructions take one primary pointer and at least one memory
 /// order.
 class AtomicExpr : public Expr {
 public:

include/clang/AST/ExprCXX.h

public:
   }
 
   // Iterators
   child_range children() { return child_range(); }
 
   friend class ASTStmtReader;
   friend class ASTStmtWriter;
 };
+static_assert(llvm::AlignOf<CXXDefaultArgExpr>::Alignment >=
+                  llvm::AlignOf<Expr *>::Alignment,
+              "Alignment sufficient for objects appended to CXXDefaultArgExpr");
 
 /// \brief A use of a default initializer in a constructor or in aggregate
 /// initialization.
 ///
 /// This wraps a use of a C++ default initializer (technically,
 /// a brace-or-equal-initializer for a non-static data member) when it
 /// is implicitly used in a mem-initializer-list in a constructor
 /// (C++11 [class.base.init]p8) or in aggregate initialization
class LambdaExpr : public Expr {
 
   /// \brief Construct an empty lambda expression.
   LambdaExpr(EmptyShell Empty, unsigned NumCaptures, bool HasArrayIndexVars)
     : Expr(LambdaExprClass, Empty),
       NumCaptures(NumCaptures), CaptureDefault(LCD_None), ExplicitParams(false),
       ExplicitResultType(false), HasArrayIndexVars(true) { 
     getStoredStmts()[NumCaptures] = nullptr;
   }
-  
-  Stmt **getStoredStmts() const {
-    return reinterpret_cast<Stmt **>(const_cast<LambdaExpr *>(this) + 1);
+  Stmt **getStoredStmts() {
+    return reinterpret_cast<Stmt **>(this + 1);
+  }
+
+  Stmt * const *getStoredStmts() const {
+    return reinterpret_cast<Stmt * const *>(this + 1);
   }
-  
   /// \brief Retrieve the mapping from captures to the first array index
   /// variable.
-  unsigned *getArrayIndexStarts() const {
+  unsigned *getArrayIndexStarts() {
     return reinterpret_cast<unsigned *>(getStoredStmts() + NumCaptures + 1);
   }
 
+  const unsigned *getArrayIndexStarts() const {
+    return reinterpret_cast<const unsigned *>(getStoredStmts() + NumCaptures + 1);
+  }
+
   /// \brief Retrieve the complete set of array-index variables.
-  VarDecl **getArrayIndexVars() const {
+  VarDecl **getArrayIndexVars() {
     unsigned ArrayIndexSize = llvm::RoundUpToAlignment(
         sizeof(unsigned) * (NumCaptures + 1), llvm::alignOf<VarDecl *>());
     return reinterpret_cast<VarDecl **>(
         reinterpret_cast<char *>(getArrayIndexStarts()) + ArrayIndexSize);
   }
 
+  VarDecl * const*getArrayIndexVars() const {
+    unsigned ArrayIndexSize = llvm::RoundUpToAlignment(
+        sizeof(unsigned) * (NumCaptures + 1), llvm::alignOf<VarDecl *>());
+    return reinterpret_cast<VarDecl * const*>(
+        reinterpret_cast<const char *>(getArrayIndexStarts()) + ArrayIndexSize);
+  }
+
 public:
   /// \brief Construct a new lambda expression.
   static LambdaExpr *Create(const ASTContext &C,
                             CXXRecordDecl *Class,
                             SourceRange IntroducerRange,
                             LambdaCaptureDefault CaptureDefault,
                             SourceLocation CaptureDefaultLoc,
                             ArrayRef<Capture> Captures,
public:
   /// \brief Retrieve an iterator pointing past the end of the sequence of
   /// implicit lambda captures.
   capture_iterator implicit_capture_end() const;
 
   /// \brief Iterator that walks over the capture initialization
   /// arguments.
   typedef Expr **capture_init_iterator;
 
+  /// \brief Const iterator that walks over the capture initialization
+  /// arguments.
+  typedef Expr * const *const_capture_init_iterator;
+
   /// \brief Retrieve the initialization expressions for this lambda's captures.
-  llvm::iterator_range<capture_init_iterator> capture_inits() const {
+  llvm::iterator_range<capture_init_iterator> capture_inits() {
     return llvm::iterator_range<capture_init_iterator>(capture_init_begin(),
                                                        capture_init_end());
   }
 
+  /// \brief Retrieve the initialization expressions for this lambda's captures.
+  llvm::iterator_range<const_capture_init_iterator> capture_inits() const {
+    return llvm::iterator_range<const_capture_init_iterator>(capture_init_begin(),
+                                                             capture_init_end());
+  }
+
   /// \brief Retrieve the first initialization argument for this
   /// lambda expression (which initializes the first capture field).
-  capture_init_iterator capture_init_begin() const {
+  capture_init_iterator capture_init_begin() {
     return reinterpret_cast<Expr **>(getStoredStmts());
   }
 
+  /// \brief Retrieve the first initialization argument for this
+  /// lambda expression (which initializes the first capture field).
+  const_capture_init_iterator capture_init_begin() const {
+    return reinterpret_cast<Expr * const*>(getStoredStmts());
+  }
+
+  /// \brief Retrieve the iterator pointing one past the last
+  /// initialization argument for this lambda expression.
+  capture_init_iterator capture_init_end() {
+    return capture_init_begin() + NumCaptures;
+  }
+
   /// \brief Retrieve the iterator pointing one past the last
   /// initialization argument for this lambda expression.
-  capture_init_iterator capture_init_end() const {
-    return capture_init_begin() + NumCaptures;    
+  const_capture_init_iterator capture_init_end() const {
+    return capture_init_begin() + NumCaptures;
   }
 
-  /// \brief Retrieve the set of index variables used in the capture 
+  /// \brief Retrieve the set of index variables used in the capture
   /// initializer of an array captured by copy.
   ///
-  /// \param Iter The iterator that points at the capture initializer for 
+  /// \param Iter The iterator that points at the capture initializer for
   /// which we are extracting the corresponding index variables.
-  ArrayRef<VarDecl *> getCaptureInitIndexVars(capture_init_iterator Iter) const;
+  ArrayRef<VarDecl *> getCaptureInitIndexVars(const_capture_init_iterator Iter) const;
   
   /// \brief Retrieve the source range covering the lambda introducer,
   /// which contains the explicit capture list surrounded by square
   /// brackets ([...]).
   SourceRange getIntroducerRange() const { return IntroducerRange; }
 
   /// \brief Retrieve the class that corresponds to the lambda.
   /// 
public:
 
   child_range children() {
     return child_range(getStoredStmts(), getStoredStmts() + NumCaptures + 1);
   }
 
   friend class ASTStmtReader;
   friend class ASTStmtWriter;
 };
+static_assert(llvm::AlignOf<LambdaExpr>::Alignment >=
+                  llvm::AlignOf<Stmt *>::Alignment,
+              "Alignment sufficient for objects appended to LambdaExpr");
+static_assert(llvm::AlignOf<Stmt *>::Alignment >=
+                  llvm::AlignOf<unsigned>::Alignment,
+              "Alignment sufficient for objects appended to LambdaExpr");
+// Code re-aligns before VarDecl *[]
+static_assert(llvm::AlignOf<LambdaExpr>::Alignment >=
+                  llvm::AlignOf<VarDecl *>::Alignment,
+              "Alignment sufficient 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 {
   SourceLocation RParenLoc;
   TypeSourceInfo *TypeInfo;
 
   friend class ASTStmtReader;
public:
   
   // Iterators
   child_range children() { return child_range(); }
   
   friend class ASTStmtReader;
   friend class ASTStmtWriter;
 
 };
+static_assert(llvm::AlignOf<TypeTraitExpr>::Alignment >=
+                  llvm::AlignOf<TypeSourceInfo *>::Alignment,
+              "Alignment sufficient for objects appended to TypeTraitExpr");
 
 /// \brief An Embarcadero array type trait, as used in the implementation of
 /// __array_rank and __array_extent.
 ///
 /// Example:
 /// \code
 ///   __array_rank(int[10][20]) == 2
 ///   __array_extent(int, 1)    == 20
public:
   child_range children() { return child_range(); }
 
   friend class ASTStmtReader;
 };
 
 
 /// \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;
 
   /// \brief The nested-name-specifier that qualifies the name, if any.
   NestedNameSpecifierLoc QualifierLoc;
 
   /// The results.  These are undesugared, which is to say, they may
   /// include UsingShadowDecls.  Access is relative to the naming
public:
   }
 
   child_range children() { return child_range(); }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == UnresolvedLookupExprClass;
   }
 };
+static_assert(
+    llvm::AlignOf<UnresolvedLookupExpr>::Alignment >=
+        llvm::AlignOf<ASTTemplateKWAndArgsInfo>::Alignment,
+    "Alignment sufficient for objects appended to UnresolvedLookupExpr");
 
 /// \brief A qualified reference to a name whose declaration cannot
 /// yet be resolved.
 ///
 /// DependentScopeDeclRefExpr is similar to DeclRefExpr in that
 /// it expresses a reference to a declaration such as
 /// X<T>::value. The difference, however, is that an
 /// DependentScopeDeclRefExpr node is used only within C++ templates when
 /// the qualification (e.g., X<T>::) refers to a dependent type. In
 /// this case, X<T>::value cannot resolve to a declaration because the
 /// declaration will differ from one instantiation of X<T> to the
 /// next. Therefore, DependentScopeDeclRefExpr keeps track of the
 /// qualifier (X<T>::) and the name of the entity being referenced
 /// ("value"). Such expressions will instantiate to a DeclRefExpr once the
 /// declaration can be found.
-class DependentScopeDeclRefExpr : public Expr {
+class LLVM_ALIGNAS(/*alignof(uint64_t)*/ 8) DependentScopeDeclRefExpr : public Expr {
   /// \brief The nested-name-specifier that qualifies this unresolved
   /// declaration name.
   NestedNameSpecifierLoc QualifierLoc;
 
   /// \brief The name of the entity we will be referencing.
   DeclarationNameInfo NameInfo;
 
   /// \brief Whether the name includes info for explicit template
static bool classof(const Stmt *T) {
     return T->getStmtClass() == DependentScopeDeclRefExprClass;
   }
 
   child_range children() { return child_range(); }
 
   friend class ASTStmtReader;
   friend class ASTStmtWriter;
 };
+static_assert(
+    llvm::AlignOf<DependentScopeDeclRefExpr>::Alignment >=
+        llvm::AlignOf<ASTTemplateKWAndArgsInfo>::Alignment,
+    "Alignment sufficient 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
 /// cleanups is temporary objects in C++, but several other kinds of
 /// expressions can create cleanups, including basically every
 /// call in ARC that returns an Objective-C pointer.
 ///
public:
   // Implement isa/cast/dyncast/etc.
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == ExprWithCleanupsClass;
   }
 
   // Iterators
   child_range children() { return child_range(&SubExpr, &SubExpr + 1); }
 };
+static_assert(llvm::AlignOf<ExprWithCleanups>::Alignment >=
+                  llvm::AlignOf<ExprWithCleanups::CleanupObject>::Alignment,
+              "Alignment sufficient 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.
 ///
 /// The explicit type conversions expressed by
 /// CXXUnresolvedConstructExpr have the form <tt>T(a1, a2, ..., aN)</tt>,
 /// where \c T is some type and \c a1, \c a2, ..., \c aN are values, and
public:
   }
 
   // Iterators
   child_range children() {
     Stmt **begin = reinterpret_cast<Stmt**>(this+1);
     return child_range(begin, begin + NumArgs);
   }
 };
+static_assert(
+    llvm::AlignOf<CXXUnresolvedConstructExpr>::Alignment >=
+        llvm::AlignOf<Expr *>::Alignment,
+    "Alignment sufficient 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.
 ///
 /// Like UnresolvedMemberExprs, these can be either implicit or
 /// explicit accesses.  It is only possible to get one of these with
 /// an implicit access if a qualifier is provided.
-class CXXDependentScopeMemberExpr : public Expr {
+class LLVM_ALIGNAS(/*alignof(uint64_t)*/ 8) CXXDependentScopeMemberExpr : public Expr {
   /// \brief The expression for the base pointer or class reference,
   /// e.g., the \c x in x.f.  Can be null in implicit accesses.
   Stmt *Base;
 
   /// \brief The type of the base expression.  Never null, even for
   /// implicit accesses.
   QualType BaseType;
 
public:
   child_range children() {
     if (isImplicitAccess()) return child_range();
     return child_range(&Base, &Base + 1);
   }
 
   friend class ASTStmtReader;
   friend class ASTStmtWriter;
 };
+static_assert(
+    llvm::AlignOf<CXXDependentScopeMemberExpr>::Alignment >=
+        llvm::AlignOf<ASTTemplateKWAndArgsInfo>::Alignment,
+    "Alignment sufficient for objects appended to CXXDependentScopeMemberExpr");
 
 /// \brief Represents a C++ member access expression for which lookup
 /// produced a set of overloaded functions.
 ///
 /// The member access may be explicit or implicit:
 /// \code
 ///    struct A {
 ///      int a, b;
 ///      int explicitAccess() { return this->a + this->A::b; }
 ///      int implicitAccess() { return a + A::b; }
 ///    };
 /// \endcode
 ///
 /// In the final AST, an explicit access always becomes a MemberExpr.
 /// An implicit access may become either a MemberExpr or a
 /// DeclRefExpr, depending on whether the member is static.
-class UnresolvedMemberExpr : public OverloadExpr {
+class LLVM_ALIGNAS(/*alignof(uint64_t)*/ 8) UnresolvedMemberExpr : public OverloadExpr {
   /// \brief Whether this member expression used the '->' operator or
   /// the '.' operator.
   bool IsArrow : 1;
 
   /// \brief Whether the lookup results contain an unresolved using
   /// declaration.
   bool HasUnresolvedUsing : 1;
 
public:
   }
 
   // Iterators
   child_range children() {
     if (isImplicitAccess()) return child_range();
     return child_range(&Base, &Base + 1);
   }
 };
+static_assert(
+    llvm::AlignOf<UnresolvedMemberExpr>::Alignment >=
+        llvm::AlignOf<ASTTemplateKWAndArgsInfo>::Alignment,
+    "Alignment sufficient for objects appended to UnresolvedMemberExpr");
+
+inline ASTTemplateKWAndArgsInfo *OverloadExpr::getTemplateKWAndArgsInfo() {
+  if (!HasTemplateKWAndArgsInfo) return nullptr;
+  if (isa<UnresolvedLookupExpr>(this))
+    return reinterpret_cast<ASTTemplateKWAndArgsInfo*>
+      (cast<UnresolvedLookupExpr>(this) + 1);
+  else
+    return reinterpret_cast<ASTTemplateKWAndArgsInfo*>
+      (cast<UnresolvedMemberExpr>(this) + 1);
+}
 
 /// \brief Represents a C++11 noexcept expression (C++ [expr.unary.noexcept]).
 ///
 /// The noexcept expression tests whether a given expression might throw. Its
 /// result is a boolean constant.
 class CXXNoexceptExpr : public Expr {
   bool Value : 1;
   Stmt *Operand;
public:
   }
 
   // Iterators
   child_range children() {
     return child_range(&Pattern, &Pattern + 1);
   }
 };
 
-inline ASTTemplateKWAndArgsInfo *OverloadExpr::getTemplateKWAndArgsInfo() {
-  if (!HasTemplateKWAndArgsInfo) return nullptr;
-  if (isa<UnresolvedLookupExpr>(this))
-    return reinterpret_cast<ASTTemplateKWAndArgsInfo*>
-      (cast<UnresolvedLookupExpr>(this) + 1);
-  else
-    return reinterpret_cast<ASTTemplateKWAndArgsInfo*>
-      (cast<UnresolvedMemberExpr>(this) + 1);
-}
 
 /// \brief Represents an expression that computes the length of a parameter
 /// pack.
 ///
 /// \code
 /// template<typename ...Types>
 /// struct count {
 ///   static const unsigned value = sizeof...(Types);
public:
   SourceLocation getLocEnd() const LLVM_READONLY { return NameLoc; }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == FunctionParmPackExprClass;
   }
 
   child_range children() { return child_range(); }
 };
+static_assert(
+    llvm::AlignOf<FunctionParmPackExpr>::Alignment >=
+        llvm::AlignOf<ParmVarDecl *>::Alignment,
+    "Alignment sufficient for objects appended to FunctionParmPackExpr");
 
 /// \brief Represents a prvalue temporary that is written into memory so that
 /// a reference can bind to it.
 ///
 /// Prvalue expressions are materialized when they need to have an address
 /// in memory for a reference to bind to. This happens when binding a
 /// reference to the result of a conversion, e.g.,
 ///

include/clang/AST/ExprObjC.h

public:
   // Iterators
   child_range children() { 
     return child_range((Stmt **)getElements(), 
                        (Stmt **)getElements() + NumElements);
   }
     
   friend class ASTStmtReader;
 };
+static_assert(llvm::AlignOf<ObjCArrayLiteral>::Alignment >=
+                  llvm::AlignOf<Expr *>::Alignment,
+              "Alignment sufficient for objects appended to ObjCArrayLiteral");
 
 /// \brief An element in an Objective-C dictionary literal.
 ///
 struct ObjCDictionaryElement {
   /// \brief The key for the dictionary element.
   Expr *Key;
   
   /// \brief The value of the dictionary element.

 namespace llvm {
 template <> struct isPodLike<clang::ObjCDictionaryElement> : std::true_type {};
 }
 
 namespace clang {
 /// ObjCDictionaryLiteral - AST node to represent objective-c dictionary 
 /// literals; as in:  @{@"name" : NSUserName(), @"date" : [NSDate date] };
 class ObjCDictionaryLiteral : public Expr {
+ public:
   /// \brief Key/value pair used to store the key and value of a given element.
   ///
   /// Objects of this type are stored directly after the expression.
   struct KeyValuePair {
     Expr *Key;
     Expr *Value;
   };
   
   /// \brief Data that describes an element that is a pack expansion, used if any
   /// of the elements in the dictionary literal are pack expansions.
   struct ExpansionData {
     /// \brief The location of the ellipsis, if this element is a pack
     /// expansion.
     SourceLocation EllipsisLoc;
 
     /// \brief If non-zero, the number of elements that this pack
     /// expansion will expand to (+1).
     unsigned NumExpansionsPlusOne;
   };
 
+ private:
   /// \brief The number of elements in this dictionary literal.
   unsigned NumElements : 31;
   
   /// \brief Determine whether this dictionary literal has any pack expansions.
   ///
   /// If the dictionary literal has pack expansions, then there will
   /// be an array of pack expansion data following the array of
   /// key/value pairs, which provide the locations of the ellipses (if
public:
   static bool classof(const Stmt *T) {
       return T->getStmtClass() == ObjCDictionaryLiteralClass;
   }
     
   // Iterators
   child_range children() { 
     // Note: we're taking advantage of the layout of the KeyValuePair struct
     // here. If that struct changes, this code will need to change as well.
+    static_assert(sizeof(KeyValuePair) == sizeof(Stmt *) * 2,
+                  "KeyValuePair is expected size");
     return child_range(reinterpret_cast<Stmt **>(this + 1),
                        reinterpret_cast<Stmt **>(this + 1) + NumElements * 2);
   }
     
   friend class ASTStmtReader;
   friend class ASTStmtWriter;
 };
-
+static_assert(
+    llvm::AlignOf<ObjCDictionaryLiteral>::Alignment >=
+        llvm::AlignOf<ObjCDictionaryLiteral::KeyValuePair>::Alignment,
+    "Alignment sufficient for objects appended to ObjCDictionaryLiteral");
+static_assert(
+    llvm::AlignOf<ObjCDictionaryLiteral::KeyValuePair>::Alignment >=
+        llvm::AlignOf<ObjCDictionaryLiteral::ExpansionData>::Alignment,
+    "Alignment sufficient 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
 /// obtained from ASTContext with the encoding type as an argument.
 class ObjCEncodeExpr : public Expr {
   TypeSourceInfo *EncodedType;
   SourceLocation AtLoc, RParenLoc;
 public:
public:
   }
   const_arg_iterator arg_end() const { 
     return reinterpret_cast<Stmt const * const*>(getArgs() + NumArgs); 
   }
 
   friend class ASTStmtReader;
   friend class ASTStmtWriter;
 };
+static_assert(llvm::AlignOf<ObjCMessageExpr>::Alignment >=
+                  llvm::AlignOf<void *>::Alignment,
+              "Alignment sufficient for objects appended to ObjCMessageExpr");
+static_assert(llvm::AlignOf<void *>::Alignment >=
+                  llvm::AlignOf<Expr *>::Alignment,
+              "Alignment sufficient for objects appended to ObjCMessageExpr");
+static_assert(llvm::AlignOf<Expr *>::Alignment >=
+                  llvm::AlignOf<SourceLocation>::Alignment,
+              "Alignment sufficient for objects appended to ObjCMessageExpr");
 
 /// ObjCIsaExpr - Represent X->isa and X.isa when X is an ObjC 'id' type.
 /// (similar in spirit to MemberExpr).
 class ObjCIsaExpr : public Expr {
   /// Base - the expression for the base object pointer.
   Stmt *Base;
 
   /// IsaMemberLoc - This is the location of the 'isa'.

include/clang/AST/Stmt.h

public:
   SourceLocation getLocEnd() const LLVM_READONLY { return SubStmt->getLocEnd();}
 
   child_range children() { return child_range(&SubStmt, &SubStmt + 1); }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == AttributedStmtClass;
   }
 };
-
+static_assert(llvm::AlignOf<AttributedStmt>::Alignment >=
+                  llvm::AlignOf<Attr *>::Alignment,
+              "Alignment sufficient for objects appended to AttributedStmt");
 
 /// IfStmt - This represents an if/then/else.
 ///
 class IfStmt : public Stmt {
   enum { VAR, COND, THEN, ELSE, END_EXPR };
   Stmt* SubExprs[END_EXPR];
 
   SourceLocation IfLoc;
private:
 
   /// \brief Construct a captured statement.
   CapturedStmt(Stmt *S, CapturedRegionKind Kind, ArrayRef<Capture> Captures,
                ArrayRef<Expr *> CaptureInits, CapturedDecl *CD, RecordDecl *RD);
 
   /// \brief Construct an empty captured statement.
   CapturedStmt(EmptyShell Empty, unsigned NumCaptures);
 
-  Stmt **getStoredStmts() const {
-    return reinterpret_cast<Stmt **>(const_cast<CapturedStmt *>(this) + 1);
+  Stmt **getStoredStmts() {
+    return reinterpret_cast<Stmt **>(this + 1);
+  }
+
+  Stmt * const *getStoredStmts() const {
+    return reinterpret_cast<Stmt * const *>(this + 1);
   }
 
   Capture *getStoredCaptures() const;
 
   void setCapturedStmt(Stmt *S) { getStoredStmts()[NumCaptures] = S; }
 
 public:
   static CapturedStmt *Create(const ASTContext &Context, Stmt *S,
                               CapturedRegionKind Kind,
                               ArrayRef<Capture> Captures,
                               ArrayRef<Expr *> CaptureInits,
                               CapturedDecl *CD, RecordDecl *RD);
 
   static CapturedStmt *CreateDeserialized(const ASTContext &Context,
                                           unsigned NumCaptures);
 
   /// \brief Retrieve the statement being captured.
   Stmt *getCapturedStmt() { return getStoredStmts()[NumCaptures]; }
-  const Stmt *getCapturedStmt() const {
-    return const_cast<CapturedStmt *>(this)->getCapturedStmt();
-  }
+  const Stmt *getCapturedStmt() const { return getStoredStmts()[NumCaptures]; }
 
   /// \brief Retrieve the outlined function declaration.
   CapturedDecl *getCapturedDecl() { return CapDeclAndKind.getPointer(); }
   const CapturedDecl *getCapturedDecl() const {
-    return const_cast<CapturedStmt *>(this)->getCapturedDecl();
+    return CapDeclAndKind.getPointer();
   }
 
   /// \brief Set the outlined function declaration.
   void setCapturedDecl(CapturedDecl *D) {
     assert(D && "null CapturedDecl");
     CapDeclAndKind.setPointer(D);
   }
 
public:
   capture_iterator capture_end() const {
     return getStoredCaptures() + NumCaptures;
   }
 
   /// \brief Retrieve the number of captures, including 'this'.
   unsigned capture_size() const { return NumCaptures; }
 
   /// \brief Iterator that walks over the capture initialization arguments.
-  typedef Expr **capture_init_iterator;
+  typedef Expr ** capture_init_iterator;
   typedef llvm::iterator_range<capture_init_iterator> capture_init_range;
 
-  capture_init_range capture_inits() const {
+  /// \brief Const iterator that walks over the capture initialization arguments.
+  typedef Expr * const * const_capture_init_iterator;
+  typedef llvm::iterator_range<const_capture_init_iterator> const_capture_init_range;
+
+  capture_init_range capture_inits() {
     return capture_init_range(capture_init_begin(), capture_init_end());
   }
 
+  const_capture_init_range capture_inits() const {
+    return const_capture_init_range(capture_init_begin(), capture_init_end());
+  }
+
   /// \brief Retrieve the first initialization argument.
-  capture_init_iterator capture_init_begin() const {
+  capture_init_iterator capture_init_begin() {
     return reinterpret_cast<Expr **>(getStoredStmts());
   }
 
+  const_capture_init_iterator capture_init_begin() const {
+    return reinterpret_cast<Expr * const*>(getStoredStmts());
+  }
+
   /// \brief Retrieve the iterator pointing one past the last initialization
   /// argument.
-  capture_init_iterator capture_init_end() const {
+  capture_init_iterator capture_init_end() {
+    return capture_init_begin() + NumCaptures;
+  }
+
+  const_capture_init_iterator capture_init_end() const {
     return capture_init_begin() + NumCaptures;
   }
 
   SourceLocation getLocStart() const LLVM_READONLY {
     return getCapturedStmt()->getLocStart();
   }
   SourceLocation getLocEnd() const LLVM_READONLY {
     return getCapturedStmt()->getLocEnd();
   }
   SourceRange getSourceRange() const LLVM_READONLY {
     return getCapturedStmt()->getSourceRange();
   }
 
   static bool classof(const Stmt *T) {
     return T->getStmtClass() == CapturedStmtClass;
   }
 
   child_range children();
 
   friend class ASTStmtReader;
 };
+static_assert(llvm::AlignOf<CapturedStmt>::Alignment >=
+                  llvm::AlignOf<Stmt *>::Alignment,
+              "Alignment sufficient for objects appended to CapturedStmt");
+// Code re-aligns before Capture[]
+static_assert(llvm::AlignOf<CapturedStmt>::Alignment >=
+                  llvm::AlignOf<CapturedStmt::Capture>::Alignment,
+              "Alignment sufficient for objects appended to CapturedStmt");
 
 }  // end namespace clang
 
 #endif

include/clang/AST/StmtCXX.h

public:
   }
 
   child_range children() {
     return child_range(getStmts(), getStmts() + getNumHandlers() + 1);
   }
 
   friend class ASTStmtReader;
 };
+static_assert(llvm::AlignOf<CXXTryStmt>::Alignment >=
+                  llvm::AlignOf<Stmt *>::Alignment,
+              "Alignment sufficient for objects appended to CXXTryStmt");
 
 /// CXXForRangeStmt - This represents C++0x [stmt.ranged]'s ranged for
 /// statement, represented as 'for (range-declarator : range-expression)'.
 ///
 /// This is stored in a partially-desugared form to allow full semantic
 /// analysis of the constituent components. The original syntactic components
 /// can be extracted using getLoopVariable and getRangeInit.
 class CXXForRangeStmt : public Stmt {

include/clang/AST/StmtObjC.h

static bool classof(const Stmt *T) {
     return T->getStmtClass() == ObjCAtTryStmtClass;
   }
 
   child_range children() {
     return child_range(getStmts(),
                        getStmts() + 1 + NumCatchStmts + HasFinally);
   }
 };
+static_assert(llvm::AlignOf<ObjCAtTryStmt>::Alignment >=
+                  llvm::AlignOf<Stmt *>::Alignment,
+              "Alignment sufficient for objects appended to ObjCAtTryStmt");
 
 /// \brief Represents Objective-C's \@synchronized statement.
 ///
 /// Example:
 /// \code
 ///   @synchronized (sem) {
 ///     do-something;
 ///   }

include/clang/AST/TemplateBase.h

public:
 
   /// \brief Print this template argument to the given output stream.
   void print(const PrintingPolicy &Policy, raw_ostream &Out) const;
              
   /// \brief Used to insert TemplateArguments into FoldingSets.
   void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Context) const;
 };
 
+static_assert(
+    llvm::AlignOf<TemplateSpecializationType>::Alignment >=
+        llvm::AlignOf<TemplateArgument>::Alignment,
+    "Alignment sufficient for objects appended to TemplateSpecializationType");
+static_assert(
+    llvm::AlignOf<TemplateArgument>::Alignment >=
+        llvm::AlignOf<QualType>::Alignment,
+    "Alignment sufficient for objects appended to TemplateSpecializationType");
+
+static_assert(llvm::AlignOf<DependentTemplateSpecializationType>::Alignment >=
+                  llvm::AlignOf<TemplateArgument>::Alignment,
+              "Alignment sufficient for objects appended to "
+              "DependentTemplateSpecializationType");
+
 /// Location information for a TemplateArgument.
 struct TemplateArgumentLocInfo {
 private:
 
   struct T {
     // FIXME: We'd like to just use the qualifier in the TemplateName,
     // but template arguments get canonicalized too quickly.
     NestedNameSpecifier *Qualifier;
struct ASTTemplateArgumentListInfo {
 
   void initializeFrom(const TemplateArgumentListInfo &List);
   void initializeFrom(const TemplateArgumentListInfo &List,
                       bool &Dependent, bool &InstantiationDependent,
                       bool &ContainsUnexpandedParameterPack);
   void copyInto(TemplateArgumentListInfo &List) const;
   static std::size_t sizeFor(unsigned NumTemplateArgs);
 };
+static_assert(
+    llvm::AlignOf<ASTTemplateArgumentListInfo>::Alignment >=
+        llvm::AlignOf<TemplateArgumentLoc>::Alignment,
+    "Alignment sufficient for objects appended to ASTTemplateArgumentListInfo");
 
 /// \brief Extends ASTTemplateArgumentListInfo with the source location
 /// information for the template keyword; this is used as part of the
 /// representation of qualified identifiers, such as S<T>::template apply<T>.
 struct ASTTemplateKWAndArgsInfo : public ASTTemplateArgumentListInfo {
   typedef ASTTemplateArgumentListInfo Base;
 
   // NOTE: the source location of the (optional) template keyword is
struct ASTTemplateKWAndArgsInfo : public ASTTemplateArgumentListInfo {
   void initializeFrom(SourceLocation TemplateKWLoc,
                       const TemplateArgumentListInfo &List,
                       bool &Dependent, bool &InstantiationDependent,
                       bool &ContainsUnexpandedParameterPack);
   void initializeFrom(SourceLocation TemplateKWLoc);
 
   static std::size_t sizeFor(unsigned NumTemplateArgs);
 };
+static_assert(
+    llvm::AlignOf<ASTTemplateKWAndArgsInfo>::Alignment >=
+        llvm::AlignOf<TemplateArgumentLoc>::Alignment,
+    "Alignment sufficient for objects appended to ASTTemplateKWAndArgsInfo");
+static_assert(
+    llvm::AlignOf<ASTTemplateKWAndArgsInfo>::Alignment >=
+        llvm::AlignOf<SourceLocation>::Alignment,
+    "Alignment sufficient for objects appended to ASTTemplateKWAndArgsInfo");
+static_assert(
+    llvm::AlignOf<TemplateArgumentLoc>::Alignment >=
+        llvm::AlignOf<SourceLocation>::Alignment,
+    "Alignment sufficient for objects appended to ASTTemplateKWAndArgsInfo");
 
 const DiagnosticBuilder &operator<<(const DiagnosticBuilder &DB,
                                     const TemplateArgument &Arg);
 
 inline TemplateSpecializationType::iterator
     TemplateSpecializationType::end() const {
   return getArgs() + getNumArgs();
 }

include/clang/AST/TemplateName.h

class OverloadedTemplateStorage : public UncommonTemplateNameStorage {
   }
 
 public:
   typedef NamedDecl *const *iterator;
 
   iterator begin() const { return getStorage(); }
   iterator end() const { return getStorage() + size(); }
 };
+static_assert(
+    llvm::AlignOf<OverloadedTemplateStorage>::Alignment >=
+        llvm::AlignOf<NamedDecl *>::Alignment,
+    "Alignment sufficient for objects appended to OverloadedTemplateStorage");
 
 /// \brief A structure for storing an already-substituted template template
 /// parameter pack.
 ///
 /// This kind of template names occurs when the parameter pack has been 
 /// provided with a template template argument pack in a context where its
 /// enclosing pack expansion could not be fully expanded.
 class SubstTemplateTemplateParmPackStorage

include/clang/AST/Type.h

private:
   // are consumed.  This only appears if HasAnyConsumedParams is true.
 
   friend class ASTContext;  // ASTContext creates these.
 
   const bool *getConsumedParamsBuffer() const {
     assert(hasAnyConsumedParams());
 
     // Find the end of the exceptions.
-    Expr *const *eh_end = reinterpret_cast<Expr *const *>(param_type_end());
-    if (getExceptionSpecType() != EST_ComputedNoexcept)
-      eh_end += NumExceptions;
-    else
+    Expr *const *eh_end = reinterpret_cast<Expr *const *>(exception_end());
+    if (getExceptionSpecType() == EST_ComputedNoexcept)
       eh_end += 1; // NoexceptExpr
+    // The memory layout of these types isn't handled here, so
+    // hopefully this is never called for them?
+    assert(getExceptionSpecType() != EST_Uninstantiated &&
+           getExceptionSpecType() != EST_Unevaluated);
 
     return reinterpret_cast<const bool*>(eh_end);
   }
 
 public:
   unsigned getNumParams() const { return NumParams; }
   QualType getParamType(unsigned i) const {
     assert(i < NumParams && "invalid parameter index");
static bool classof(const Type *T) {
     return T->getTypeClass() == FunctionProto;
   }
 
   void Profile(llvm::FoldingSetNodeID &ID, const ASTContext &Ctx);
   static void Profile(llvm::FoldingSetNodeID &ID, QualType Result,
                       param_type_iterator ArgTys, unsigned NumArgs,
                       const ExtProtoInfo &EPI, const ASTContext &Context);
 };
-
+static_assert(llvm::AlignOf<FunctionProtoType>::Alignment >=
+                  llvm::AlignOf<QualType>::Alignment,
+              "Alignment sufficient for objects appended to FunctionProtoType");
+// After QualType[], there can be one of 4 options: more QualType, Expr*, 2x FunctionDecl*, FunctionDecl*
+static_assert(llvm::AlignOf<QualType>::Alignment >=
+                  llvm::AlignOf<Expr *>::Alignment,
+              "Alignment sufficient for objects appended to FunctionProtoType");
+static_assert(llvm::AlignOf<QualType>::Alignment >=
+                  llvm::AlignOf<FunctionDecl *>::Alignment,
+              "Alignment sufficient for objects appended to FunctionProtoType");
+// And then, after any of those options, comes bool[]
+static_assert(llvm::AlignOf<QualType>::Alignment >=
+                  llvm::AlignOf<bool>::Alignment,
+              "Alignment sufficient for objects appended to FunctionProtoType");
+static_assert(llvm::AlignOf<Expr *>::Alignment >=
+                  llvm::AlignOf<bool>::Alignment,
+              "Alignment sufficient for objects appended to FunctionProtoType");
+static_assert(llvm::AlignOf<FunctionDecl *>::Alignment >=
+                  llvm::AlignOf<bool>::Alignment,
+              "Alignment sufficient for objects appended to FunctionProtoType");
 
 /// \brief Represents the dependent type named by a dependently-scoped
 /// typename using declaration, e.g.
 ///   using typename Base<T>::foo;
 /// Template instantiation turns these into the underlying type.
 class UnresolvedUsingType : public Type {
   UnresolvedUsingTypenameDecl *Decl;
 

 /// Template specializations are dependent if either the template or
 /// any of the template arguments are dependent, in which case the
 /// type may also be canonical.
 ///
 /// Instances of this type are allocated with a trailing array of
 /// TemplateArguments, followed by a QualType representing the
 /// non-canonical aliased type when the template is a type alias
 /// template.
-class TemplateSpecializationType
+class LLVM_ALIGNAS(/*alignof(uint64_t)*/ 8) TemplateSpecializationType
   : public Type, public llvm::FoldingSetNode {
   /// \brief The name of the template being specialized.  This is
   /// either a TemplateName::Template (in which case it is a
   /// ClassTemplateDecl*, a TemplateTemplateParmDecl*, or a
   /// TypeAliasTemplateDecl*), a
   /// TemplateName::SubstTemplateTemplateParmPack, or a
   /// TemplateName::SubstTemplateTemplateParm (in which case the
   /// replacement must, recursively, be one of these).
static void Profile(llvm::FoldingSetNodeID &ID, TemplateName T,
                       const TemplateArgument *Args,
                       unsigned NumArgs,
                       const ASTContext &Context);
 
   static bool classof(const Type *T) {
     return T->getTypeClass() == TemplateSpecialization;
   }
 };
+// The static_asserts for alignment of TemplateSpecializationType are
+// located after class TemplateArgument, as it is is forward declared
+// here.
 
 /// \brief The injected class name of a C++ class template or class
 /// template partial specialization.  Used to record that a type was
 /// spelled with a bare identifier rather than as a template-id; the
 /// equivalent for non-templated classes is just RecordType.
 ///
 /// Injected class name types are always dependent.  Template
 /// instantiation turns these into RecordTypes.
 ///
 /// Injected class name types are always canonical.  This works
 /// because it is impossible to compare an injected class name type
 /// with the corresponding non-injected template type, for the same
public:
   static bool classof(const Type *T) {
     return T->getTypeClass() == DependentName;
   }
 };
 
 /// DependentTemplateSpecializationType - Represents a template
 /// specialization type whose template cannot be resolved, e.g.
 ///   A<T>::template B<T>
-class DependentTemplateSpecializationType :
+class LLVM_ALIGNAS(/*alignof(uint64_t)*/ 8) DependentTemplateSpecializationType :
   public TypeWithKeyword, public llvm::FoldingSetNode {
 
   /// \brief The nested name specifier containing the qualifier.
   NestedNameSpecifier *NNS;
 
   /// \brief The identifier of the template.
   const IdentifierInfo *Name;
 
static void Profile(llvm::FoldingSetNodeID &ID,
                       const IdentifierInfo *Name,
                       unsigned NumArgs,
                       const TemplateArgument *Args);
 
   static bool classof(const Type *T) {
     return T->getTypeClass() == DependentTemplateSpecialization;
   }
 };
+// The static_asserts for alignment of
+// DependentTemplateSpecializationType are located after class
+// TemplateArgument, as it is is forward declared here.
 
 /// \brief Represents a pack expansion of types.
 ///
 /// Pack expansions are part of C++0x variadic templates. A pack
 /// expansion contains a pattern, which itself contains one or more
 /// "unexpanded" parameter packs. When instantiated, a pack expansion
 /// produces a series of types, each instantiated from the pattern of
 /// the expansion, where the Ith instantiation of the pattern uses the
 /// Ith arguments bound to each of the unexpanded parameter packs. The
 /// pack expansion is considered to "expand" these unexpanded

 
 public:
   void Profile(llvm::FoldingSetNodeID &ID);
   static void Profile(llvm::FoldingSetNodeID &ID,
                       QualType Base,
                       ObjCProtocolDecl *const *protocols,
                       unsigned NumProtocols);
 };
+static_assert(
+    llvm::AlignOf<ObjCObjectTypeImpl>::Alignment >=
+        llvm::AlignOf<ObjCProtocolDecl *>::Alignment,
+    "Alignment sufficient for objects appended to ObjCObjectTypeImpl");
 
 inline ObjCProtocolDecl **ObjCObjectType::getProtocolStorage() {
   return reinterpret_cast<ObjCProtocolDecl**>(
             static_cast<ObjCObjectTypeImpl*>(this) + 1);
 }
 
 /// ObjCInterfaceType - Interfaces are the core concept in Objective-C for
 /// object oriented design.  They basically correspond to C++ classes.  There

include/clang/AST/TypeLoc.h

static void initializeImpl(ASTContext &Context, TypeLoc TL,
                              SourceLocation Loc);
   static TypeLoc getNextTypeLocImpl(TypeLoc TL);
   static TypeLoc IgnoreParensImpl(TypeLoc TL);
   static SourceRange getLocalSourceRangeImpl(TypeLoc TL);
 };
 
 /// \brief Return the TypeLoc for a type source info.
 inline TypeLoc TypeSourceInfo::getTypeLoc() const {
+  // TODO: is this alignment already sufficient?
   return TypeLoc(Ty, const_cast<void*>(static_cast<const void*>(this + 1)));
 }
 
 /// \brief Wrapper of type source information for a type with
 /// no direct qualifiers.
 class UnqualTypeLoc : public TypeLoc {
 public:
   UnqualTypeLoc() {}

include/clang/CodeGen/CGFunctionInfo.h

static RequiredArgs getFromOpaqueData(unsigned value) {
     if (value == ~0U) return All;
     return RequiredArgs(value);
   }
 };
 
 /// CGFunctionInfo - Class to encapsulate the information about a
 /// function definition.
 class CGFunctionInfo : public llvm::FoldingSetNode {
+ public:
   struct ArgInfo {
     CanQualType type;
     ABIArgInfo info;
   };
-
+ private:
   /// The LLVM::CallingConv to use for this function (as specified by the
   /// user).
   unsigned CallingConvention : 8;
 
   /// The LLVM::CallingConv to actually use for this function, which may
   /// depend on the ABI.
   unsigned EffectiveCallingConvention : 8;
 
static void Profile(llvm::FoldingSetNodeID &ID,
     ID.AddInteger(required.getOpaqueData());
     resultType.Profile(ID);
     for (ArrayRef<CanQualType>::iterator
            i = argTypes.begin(), e = argTypes.end(); i != e; ++i) {
       i->Profile(ID);
     }
   }
 };
+static_assert(llvm::AlignOf<CGFunctionInfo>::Alignment >=
+                  llvm::AlignOf<CGFunctionInfo::ArgInfo>::Alignment,
+              "Alignment sufficient for objects appended to CGFunctionInfo");
 
 }  // end namespace CodeGen
 }  // end namespace clang
 
 #endif

include/clang/Lex/MacroArgs.h

 // This file defines the MacroArgs interface.
 //
 //===----------------------------------------------------------------------===//
 
 #ifndef LLVM_CLANG_LEX_MACROARGS_H
 #define LLVM_CLANG_LEX_MACROARGS_H
 
 #include "clang/Basic/LLVM.h"
+#include "clang/Lex/Token.h"
 #include "llvm/ADT/ArrayRef.h"
 #include <vector>
 
 namespace clang {
   class MacroInfo;
   class Preprocessor;
-  class Token;
   class SourceLocation;
 
 /// MacroArgs - An instance of this class captures information about
 /// the formal arguments specified to a function-like macro invocation.
 class MacroArgs {
   /// NumUnexpArgTokens - The number of raw, unexpanded tokens for the
   /// arguments.  All of the actual argument tokens are allocated immediately
   /// after the MacroArgs object in memory.  This is all of the arguments
static Token StringifyArgument(const Token *ArgToks,
                                  SourceLocation ExpansionLocStart,
                                  SourceLocation ExpansionLocEnd);
   
   
   /// deallocate - This should only be called by the Preprocessor when managing
   /// its freelist.
   MacroArgs *deallocate();
 };
+static_assert(llvm::AlignOf<MacroArgs>::Alignment >=
+                  llvm::AlignOf<Token>::Alignment,
+              "Alignment sufficient for objects appended to MacroArgs");
 
 }  // end namespace clang
 
 #endif

include/clang/Lex/MacroInfo.h

private:
 
   void setOwningModuleID(unsigned ID) {
     assert(isFromASTFile());
     *(unsigned *)(this + 1) = ID;
   }
 
   friend class Preprocessor;
 };
+static_assert(llvm::AlignOf<MacroInfo>::Alignment >=
+                  llvm::AlignOf<unsigned>::Alignment,
+              "Alignment sufficient for objects appended to MacroInfo");
 
 class DefMacroDirective;
 
 /// \brief Encapsulates changes to the "macros namespace" (the location where
 /// the macro name became active, the location where it was undefined, etc.).
 ///
 /// MacroDirectives, associated with an identifier, are used to model the macro
 /// history. Usually a macro definition (MacroInfo) is where a macro name
public:
   ArrayRef<ModuleMacro *> overrides() const {
     return llvm::makeArrayRef(overrides_begin(), overrides_end());
   }
   /// \}
 
   /// Get the number of macros that override this one.
   unsigned getNumOverridingMacros() const { return NumOverriddenBy; }
 };
+static_assert(llvm::AlignOf<ModuleMacro>::Alignment >=
+                  llvm::AlignOf<ModuleMacro *>::Alignment,
+              "Alignment sufficient for objects appended to ModuleMacro");
 
 /// \brief A description of the current definition of a macro.
 ///
 /// The definition of a macro comprises a set of (at least one) defining
 /// entities, which are either local MacroDirectives or imported ModuleMacros.
 class MacroDefinition {
   llvm::PointerIntPair<DefMacroDirective *, 1, bool> LatestLocalAndAmbiguous;
   ArrayRef<ModuleMacro *> ModuleMacros;

include/clang/Sema/AttributeList.h

private:
   /// The next attribute in the current position.
   AttributeList *NextInPosition;
 
   /// The next attribute allocated in the current Pool.
   AttributeList *NextInPool;
 
   /// Arguments, if any, are stored immediately following the object.
   ArgsUnion *getArgsBuffer() {
-    return reinterpret_cast<ArgsUnion*>(this+1);
+    return reinterpret_cast<ArgsUnion*>(this + 1);
   }
   ArgsUnion const *getArgsBuffer() const {
-    return reinterpret_cast<ArgsUnion const *>(this+1);
+    return reinterpret_cast<ArgsUnion const *>(this + 1);
   }
 
   enum AvailabilitySlot {
     IntroducedSlot, DeprecatedSlot, ObsoletedSlot
   };
 
   /// Availability information is stored immediately following the arguments,
   /// if any, at the end of the object.
public:
 
   /// \brief If the parsed attribute has a semantic equivalent, and it would
   /// have a semantic Spelling enumeration (due to having semantically-distinct
   /// spelling variations), return the value of that semantic spelling. If the
   /// parsed attribute does not have a semantic equivalent, or would not have
   /// a Spelling enumeration, the value UINT_MAX is returned.
   unsigned getSemanticSpelling() const;
 };
+static_assert(llvm::AlignOf<AttributeList>::Alignment >=
+                  llvm::AlignOf<ArgsUnion>::Alignment,
+              "Alignment sufficient for objects appended to AttributeList");
+static_assert(llvm::AlignOf<ArgsUnion>::Alignment >=
+                  llvm::AlignOf<AvailabilityChange>::Alignment,
+              "Alignment sufficient for objects appended to AttributeList");
+static_assert(
+    llvm::AlignOf<ArgsUnion>::Alignment >=
+        llvm::AlignOf<AttributeList::TypeTagForDatatypeData>::Alignment,
+    "Alignment sufficient for objects appended to AttributeList");
+static_assert(llvm::AlignOf<AttributeList>::Alignment >=
+                  llvm::AlignOf<ParsedType>::Alignment,
+              "Alignment sufficient for objects appended to AttributeList");
+static_assert(llvm::AlignOf<AttributeList>::Alignment >=
+                  llvm::AlignOf<AttributeList::PropertyData>::Alignment,
+              "Alignment sufficient for objects appended to AttributeList");
 
 /// A factory, from which one makes pools, from which one creates
 /// individual attributes which are deallocated with the pool.
 ///
 /// Note that it's tolerably cheap to create and destroy one of
 /// these as long as you don't actually allocate anything in it.
 class AttributeFactory {
 public:
private:
   /// sure that their allocator lives at least as long as this one.
   void reclaimPool(AttributeList *head);
 
 public:
   AttributeFactory();
   ~AttributeFactory();
 };
 
+
 class AttributePool {
   AttributeFactory &Factory;
   AttributeList *Head;
 
   void *allocate(size_t size) {
     return Factory.allocate(size);
   }
 

include/clang/Sema/CodeCompleteConsumer.h

public:
   const char *getBriefComment() const {
     return BriefComment;
   }
   
   /// \brief Retrieve a string representation of the code completion string,
   /// which is mainly useful for debugging.
   std::string getAsString() const;
 };
+static_assert(
+    llvm::AlignOf<CodeCompletionString>::Alignment >=
+        llvm::AlignOf<CodeCompletionString::Chunk>::Alignment,
+    "Alignment sufficient for objects appended to CodeCompletionString");
+static_assert(
+    llvm::AlignOf<CodeCompletionString::Chunk>::Alignment >=
+        llvm::AlignOf<const char *>::Alignment,
+    "Alignment sufficient for objects appended to CodeCompletionString");
 
 /// \brief An allocator used specifically for the purpose of code completion.
 class CodeCompletionAllocator : public llvm::BumpPtrAllocator {
 public:
   /// \brief Copy the given string into this allocator.
   const char *CopyString(const Twine &String);
 };
 

include/clang/Sema/ParsedTemplate.h

Allocate(unsigned NumArgs, SmallVectorImpl<TemplateIdAnnotation*> &List) {
       return TemplateId;
     }
     
     void Destroy() { 
       SS.~CXXScopeSpec();
       free(this); 
     }
   };
+  static_assert(
+      llvm::AlignOf<TemplateIdAnnotation>::Alignment >=
+          llvm::AlignOf<ParsedTemplateArgument>::Alignment,
+      "Alignment sufficient for objects appended to TemplateIdAnnotation");
 
   /// Retrieves the range of the given template parameter lists.
   SourceRange getTemplateParamsRange(TemplateParameterList const *const *Params,
                                      unsigned NumParams);  
 }
 
 #endif

include/clang/Serialization/Module.h

public:
   /// \brief The first source location in this module.
   SourceLocation FirstLoc;
 
   // === Input Files ===
   /// \brief The cursor to the start of the input-files block.
   llvm::BitstreamCursor InputFilesCursor;
 
   /// \brief Offsets for all of the input file entries in the AST file.
-  const uint64_t *InputFileOffsets;
+  std::vector<uint64_t> InputFileOffsets;
 
   /// \brief The input files that have been loaded from this AST file.
   std::vector<InputFile> InputFilesLoaded;
 
   /// \brief If non-zero, specifies the time when we last validated input
   /// files.  Zero means we never validated them.
   ///
   /// The time is specified in seconds since the start of the Epoch.

lib/AST/Decl.cpp

 }
 
 void
 FunctionDecl::setDependentTemplateSpecialization(ASTContext &Context,
                                     const UnresolvedSetImpl &Templates,
                              const TemplateArgumentListInfo &TemplateArgs) {
   assert(TemplateOrSpecialization.isNull());
   size_t Size = sizeof(DependentFunctionTemplateSpecializationInfo);
-  Size += Templates.size() * sizeof(FunctionTemplateDecl*);
   Size += TemplateArgs.size() * sizeof(TemplateArgumentLoc);
+  Size += Templates.size() * sizeof(FunctionTemplateDecl*);
   void *Buffer = Context.Allocate(Size);
   DependentFunctionTemplateSpecializationInfo *Info =
     new (Buffer) DependentFunctionTemplateSpecializationInfo(Templates,
                                                              TemplateArgs);
   TemplateOrSpecialization = Info;
 }
 
 DependentFunctionTemplateSpecializationInfo::
 DependentFunctionTemplateSpecializationInfo(const UnresolvedSetImpl &Ts,
                                       const TemplateArgumentListInfo &TArgs)
   : AngleLocs(TArgs.getLAngleLoc(), TArgs.getRAngleLoc()) {
   static_assert(sizeof(*this) % llvm::AlignOf<void *>::Alignment == 0,
                 "Trailing data is unaligned!");
 
-  d.NumTemplates = Ts.size();
-  d.NumArgs = TArgs.size();
+  NumTemplates = Ts.size();
+  NumArgs = TArgs.size();
 
   FunctionTemplateDecl **TsArray =
     const_cast<FunctionTemplateDecl**>(getTemplates());
   for (unsigned I = 0, E = Ts.size(); I != E; ++I)
     TsArray[I] = cast<FunctionTemplateDecl>(Ts[I]->getUnderlyingDecl());
 
   TemplateArgumentLoc *ArgsArray =
     const_cast<TemplateArgumentLoc*>(getTemplateArgs());

lib/AST/DeclBase.cpp

 #define DECL(DERIVED, BASE) static int n##DERIVED##s = 0;
 #define ABSTRACT_DECL(DECL)
 #include "clang/AST/DeclNodes.inc"
 
 void Decl::updateOutOfDate(IdentifierInfo &II) const {
   getASTContext().getExternalSource()->updateOutOfDateIdentifier(II);
 }
 
+#define DECL(DERIVED, BASE)                                                    \
+  static_assert(Decl::DeclObjAlignment >=                                      \
+                    llvm::AlignOf<DERIVED##Decl>::Alignment,                   \
+                "Alignment sufficient after objects prepended to " #DERIVED);
+#define ABSTRACT_DECL(DECL)
+#include "clang/AST/DeclNodes.inc"
+
 void *Decl::operator new(std::size_t Size, const ASTContext &Context,
                          unsigned ID, std::size_t Extra) {
   // Allocate an extra 8 bytes worth of storage, which ensures that the
-  // resulting pointer will still be 8-byte aligned. 
+  // resulting pointer will still be 8-byte aligned.
+  static_assert(sizeof(unsigned) * 2 >= DeclObjAlignment,
+                "Decl won't be misaligned");
   void *Start = Context.Allocate(Size + Extra + 8);
   void *Result = (char*)Start + 8;
 
   unsigned *PrefixPtr = (unsigned *)Result - 2;
 
   // Zero out the first 4 bytes; this is used to store the owning module ID.
   PrefixPtr[0] = 0;
 
   // Store the global declaration ID in the second 4 bytes.
   PrefixPtr[1] = ID;
 
   return Result;
 }
 
 void *Decl::operator new(std::size_t Size, const ASTContext &Ctx,
                          DeclContext *Parent, std::size_t Extra) {
   assert(!Parent || &Parent->getParentASTContext() == &Ctx);
   // With local visibility enabled, we track the owning module even for local
   // declarations.
   if (Ctx.getLangOpts().ModulesLocalVisibility) {
-    void *Buffer = ::operator new(sizeof(Module *) + Size + Extra, Ctx);
+    // Ensure required alignment of the resulting object by adding extra
+    // padding at the start if required.
+    size_t ExtraAlign =
+        llvm::OffsetToAlignment(sizeof(Module *), DeclObjAlignment);
+    char *Buffer = reinterpret_cast<char*>(
+        ::operator new(ExtraAlign + sizeof(Module *) + Size + Extra, Ctx));
+    Buffer += ExtraAlign;
     return new (Buffer) Module*(nullptr) + 1;
   }
   return ::operator new(Size + Extra, Ctx);
 }
 
 Module *Decl::getOwningModuleSlow() const {
   assert(isFromASTFile() && "Not from AST file?");
   return getASTContext().getExternalSource()->getModule(getOwningModuleID());

lib/AST/Expr.cpp

DeclRefExpr *DeclRefExpr::Create(const ASTContext &Context,
   if (D == FoundD)
     FoundD = nullptr;
 
   std::size_t Size = sizeof(DeclRefExpr);
   if (QualifierLoc)
     Size += sizeof(NestedNameSpecifierLoc);
   if (FoundD)
     Size += sizeof(NamedDecl *);
-  if (TemplateArgs)
+  if (TemplateArgs) {
+    Size = llvm::RoundUpToAlignment(Size, llvm::alignOf<ASTTemplateKWAndArgsInfo>());
     Size += ASTTemplateKWAndArgsInfo::sizeFor(TemplateArgs->size());
-  else if (TemplateKWLoc.isValid())
+  } else if (TemplateKWLoc.isValid()) {
+    Size = llvm::RoundUpToAlignment(Size, llvm::alignOf<ASTTemplateKWAndArgsInfo>());
     Size += ASTTemplateKWAndArgsInfo::sizeFor(0);
+  }
 
   void *Mem = Context.Allocate(Size, llvm::alignOf<DeclRefExpr>());
   return new (Mem) DeclRefExpr(Context, QualifierLoc, TemplateKWLoc, D,
                                RefersToEnclosingVariableOrCapture,
                                NameInfo, FoundD, TemplateArgs, T, VK);
 }
 
 DeclRefExpr *DeclRefExpr::CreateEmpty(const ASTContext &Context,
                                       bool HasQualifier,
                                       bool HasFoundDecl,
                                       bool HasTemplateKWAndArgsInfo,
                                       unsigned NumTemplateArgs) {
   std::size_t Size = sizeof(DeclRefExpr);
   if (HasQualifier)
     Size += sizeof(NestedNameSpecifierLoc);
   if (HasFoundDecl)
     Size += sizeof(NamedDecl *);
-  if (HasTemplateKWAndArgsInfo)
+  if (HasTemplateKWAndArgsInfo) {
+    Size = llvm::RoundUpToAlignment(Size, llvm::alignOf<ASTTemplateKWAndArgsInfo>());
     Size += ASTTemplateKWAndArgsInfo::sizeFor(NumTemplateArgs);
+  }
 
   void *Mem = Context.Allocate(Size, llvm::alignOf<DeclRefExpr>());
   return new (Mem) DeclRefExpr(EmptyShell());
 }
 
 SourceLocation DeclRefExpr::getLocStart() const {
   if (hasQualifier())
     return getQualifierLoc().getBeginLoc();

 
 DesignatedInitExpr *
 DesignatedInitExpr::Create(const ASTContext &C, Designator *Designators,
                            unsigned NumDesignators,
                            ArrayRef<Expr*> IndexExprs,
                            SourceLocation ColonOrEqualLoc,
                            bool UsesColonSyntax, Expr *Init) {
   void *Mem = C.Allocate(sizeof(DesignatedInitExpr) +
-                         sizeof(Stmt *) * (IndexExprs.size() + 1), 8);
+                         sizeof(Stmt *) * (IndexExprs.size() + 1), llvm::alignOf<DesignatedInitExpr>());
   return new (Mem) DesignatedInitExpr(C, C.VoidTy, NumDesignators, Designators,
                                       ColonOrEqualLoc, UsesColonSyntax,
                                       IndexExprs, Init);
 }
 
 DesignatedInitExpr *DesignatedInitExpr::CreateEmpty(const ASTContext &C,
                                                     unsigned NumIndexExprs) {
   void *Mem = C.Allocate(sizeof(DesignatedInitExpr) +

lib/AST/ExprCXX.cpp

LambdaExpr::capture_iterator LambdaExpr::implicit_capture_end() const {
   return capture_end();
 }
 
 LambdaExpr::capture_range LambdaExpr::implicit_captures() const {
   return capture_range(implicit_capture_begin(), implicit_capture_end());
 }
 
 ArrayRef<VarDecl *> 
-LambdaExpr::getCaptureInitIndexVars(capture_init_iterator Iter) const {
+LambdaExpr::getCaptureInitIndexVars(const_capture_init_iterator Iter) const {
   assert(HasArrayIndexVars && "No array index-var data?");
   
   unsigned Index = Iter - capture_init_begin();
   assert(Index < getLambdaClass()->getLambdaData().NumCaptures &&
          "Capture index out-of-range");
-  VarDecl **IndexVars = getArrayIndexVars();
-  unsigned *IndexStarts = getArrayIndexStarts();
+  VarDecl * const*IndexVars = getArrayIndexVars();
+  const unsigned *IndexStarts = getArrayIndexStarts();
   return llvm::makeArrayRef(IndexVars + IndexStarts[Index],
                             IndexVars + IndexStarts[Index + 1]);
 }
 
 CXXRecordDecl *LambdaExpr::getLambdaClass() const {
   return getType()->getAsCXXRecordDecl();
 }
 
 CXXMethodDecl *LambdaExpr::getCallOperator() const {
   CXXRecordDecl *Record = getLambdaClass();
   return Record->getLambdaCallOperator();  
 }
 
 TemplateParameterList *LambdaExpr::getTemplateParameterList() const {
   CXXRecordDecl *Record = getLambdaClass();
   return Record->getGenericLambdaTemplateParameterList();
 
 }
 
 CompoundStmt *LambdaExpr::getBody() const {
+  // FIXME: this mutation in getBody is bogus. It should be
+  // initialized in ASTStmtReader::VisitLambdaExpr, but for reasons I
+  // don't understand, that doesn't work.
   if (!getStoredStmts()[NumCaptures])
-    getStoredStmts()[NumCaptures] = getCallOperator()->getBody();
-    
+    *const_cast<clang::Stmt **>(&getStoredStmts()[NumCaptures]) = getCallOperator()->getBody();
   return reinterpret_cast<CompoundStmt *>(getStoredStmts()[NumCaptures]);
 }
 
 bool LambdaExpr::isMutable() const {
   return !getCallOperator()->isConst();
 }
 
 ExprWithCleanups::ExprWithCleanups(Expr *subexpr,

lib/AST/Stmt.cpp

SourceLocation ObjCAtTryStmt::getLocEnd() const {
   if (NumCatchStmts)
     return getCatchStmt(NumCatchStmts - 1)->getLocEnd();
   return getTryBody()->getLocEnd();
 }
 
 CXXTryStmt *CXXTryStmt::Create(const ASTContext &C, SourceLocation tryLoc,
                                Stmt *tryBlock, ArrayRef<Stmt*> handlers) {
   std::size_t Size = sizeof(CXXTryStmt);
-  Size += ((handlers.size() + 1) * sizeof(Stmt));
+  Size += ((handlers.size() + 1) * sizeof(Stmt *));
 
   void *Mem = C.Allocate(Size, llvm::alignOf<CXXTryStmt>());
   return new (Mem) CXXTryStmt(tryLoc, tryBlock, handlers);
 }
 
 CXXTryStmt *CXXTryStmt::Create(const ASTContext &C, EmptyShell Empty,
                                unsigned numHandlers) {
   std::size_t Size = sizeof(CXXTryStmt);
-  Size += ((numHandlers + 1) * sizeof(Stmt));
+  Size += ((numHandlers + 1) * sizeof(Stmt*));
 
   void *Mem = C.Allocate(Size, llvm::alignOf<CXXTryStmt>());
   return new (Mem) CXXTryStmt(Empty, numHandlers);
 }
 
 CXXTryStmt::CXXTryStmt(SourceLocation tryLoc, Stmt *tryBlock,
                        ArrayRef<Stmt*> handlers)
   : Stmt(CXXTryStmtClass), TryLoc(tryLoc), NumHandlers(handlers.size()) {
OMPTeamsDirective *OMPTeamsDirective::CreateEmpty(const ASTContext &C,
                                                   unsigned NumClauses,
                                                   EmptyShell) {
   unsigned Size = llvm::RoundUpToAlignment(sizeof(OMPTeamsDirective),
                                            llvm::alignOf<OMPClause *>());
   void *Mem =
       C.Allocate(Size + sizeof(OMPClause *) * NumClauses + sizeof(Stmt *));
   return new (Mem) OMPTeamsDirective(NumClauses);
 }
-

lib/Basic/IdentifierTable.cpp

static void Profile(llvm::FoldingSetNodeID &ID,
     ID.AddInteger(NumArgs);
     for (unsigned i = 0; i != NumArgs; ++i)
       ID.AddPointer(ArgTys[i]);
   }
   void Profile(llvm::FoldingSetNodeID &ID) {
     Profile(ID, keyword_begin(), getNumArgs());
   }
 };
+static_assert(
+    llvm::AlignOf<MultiKeywordSelector>::Alignment >=
+        llvm::AlignOf<IdentifierInfo *>::Alignment,
+    "Alignment sufficient for objects appended to MultiKeywordSelector");
+
 } // end namespace clang.
 
 unsigned Selector::getNumArgs() const {
   unsigned IIF = getIdentifierInfoFlag();
   if (IIF <= ZeroArg)
     return 0;
   if (IIF == OneArg)
     return 1;

lib/CodeGen/CGCleanup.h

public:
   typedef const Handler *iterator;
   iterator begin() const { return getHandlers(); }
   iterator end() const { return getHandlers() + getNumHandlers(); }
 
   static bool classof(const EHScope *Scope) {
     return Scope->getKind() == Catch;
   }
 };
+static_assert(llvm::AlignOf<EHCatchScope>::Alignment >=
+                  llvm::AlignOf<EHCatchScope::Handler *>::Alignment,
+              "Alignment sufficient for objects appended to EHCatchScope");
 
 /// A cleanup scope which generates the cleanup blocks lazily.
-class EHCleanupScope : public EHScope {
+class LLVM_ALIGNAS(/*alignof(uint64_t)*/ 8) EHCleanupScope : public EHScope {
   /// The nearest normal cleanup scope enclosing this one.
   EHScopeStack::stable_iterator EnclosingNormal;
 
   /// The nearest EH scope enclosing this one.
   EHScopeStack::stable_iterator EnclosingEH;
 
   /// The dual entry/exit block along the normal edge.  This is lazily
   /// created if needed before the cleanup is popped.
bool hasBranchThroughs() const {
     if (!ExtInfo) return false;
     return (ExtInfo->BranchAfters.size() != ExtInfo->Branches.size());
   }
 
   static bool classof(const EHScope *Scope) {
     return (Scope->getKind() == Cleanup);
   }
 };
+// NOTE: there's a bunch of different data classes tacked on after an
+// EHCleanupScope. It is asserted (in EHScopeStack::pushCleanup*) that
+// they don't require greater alignment than ScopeStackAlignment. So,
+// EHCleanupScope ought to have alignment equal to that -- not more
+// (would be misaligned by the stack allocator), and not less (would
+// break the appended classes).
+static_assert(llvm::AlignOf<EHCleanupScope>::Alignment ==
+                  EHScopeStack::ScopeStackAlignment,
+              "EHCleanupScope expected alignment");
 
 /// An exceptions scope which filters exceptions thrown through it.
 /// Only exceptions matching the filter types will be permitted to be
 /// thrown.
 ///
 /// This is used to implement C++ exception specifications.
 class EHFilterScope : public EHScope {
   // Essentially ends in a flexible array member:
llvm::Value *getFilter(unsigned i) const {
     assert(i < getNumFilters());
     return getFilters()[i];
   }
 
   static bool classof(const EHScope *scope) {
     return scope->getKind() == Filter;
   }
 };
+static_assert(llvm::AlignOf<EHFilterScope>::Alignment >=
+                  llvm::AlignOf<llvm::Value *>::Alignment,
+              "Alignment sufficient for objects appended to EHFilterScope");
 
 /// An exceptions scope which calls std::terminate if any exception
 /// reaches it.
 class EHTerminateScope : public EHScope {
 public:
   EHTerminateScope(EHScopeStack::stable_iterator enclosingEHScope)
     : EHScope(Terminate, enclosingEHScope) {}
   static size_t getSize() { return sizeof(EHTerminateScope); }
public:
   EHScope *get() const { 
     return reinterpret_cast<EHScope*>(Ptr);
   }
 
   EHScope *operator->() const { return get(); }
   EHScope &operator*() const { return *get(); }
 
   iterator &operator++() {
+    size_t Size;
     switch (get()->getKind()) {
     case EHScope::Catch:
-      Ptr += EHCatchScope::getSizeForNumHandlers(
+      Size = EHCatchScope::getSizeForNumHandlers(
           static_cast<const EHCatchScope*>(get())->getNumHandlers());
       break;
 
     case EHScope::Filter:
-      Ptr += EHFilterScope::getSizeForNumFilters(
+      Size = EHFilterScope::getSizeForNumFilters(
           static_cast<const EHFilterScope*>(get())->getNumFilters());
       break;
 
     case EHScope::Cleanup:
-      Ptr += static_cast<const EHCleanupScope*>(get())
+      Size = static_cast<const EHCleanupScope*>(get())
         ->getAllocatedSize();
       break;
 
     case EHScope::Terminate:
-      Ptr += EHTerminateScope::getSize();
+      Size = EHTerminateScope::getSize();
       break;
     }
-
+    Ptr += llvm::RoundUpToAlignment(Size, ScopeStackAlignment);
     return *this;
   }
 
   iterator next() {
     iterator copy = *this;
     ++copy;
     return copy;
   }
inline EHScopeStack::iterator EHScopeStack::end() const {
   return iterator(EndOfBuffer);
 }
 
 inline void EHScopeStack::popCatch() {
   assert(!empty() && "popping exception stack when not empty");
 
   EHCatchScope &scope = cast<EHCatchScope>(*begin());
   InnermostEHScope = scope.getEnclosingEHScope();
-  StartOfData += EHCatchScope::getSizeForNumHandlers(scope.getNumHandlers());
+  deallocate(EHCatchScope::getSizeForNumHandlers(scope.getNumHandlers()));
 }
 
 inline void EHScopeStack::popTerminate() {
   assert(!empty() && "popping exception stack when not empty");
 
   EHTerminateScope &scope = cast<EHTerminateScope>(*begin());
   InnermostEHScope = scope.getEnclosingEHScope();
-  StartOfData += EHTerminateScope::getSize();
+  deallocate(EHTerminateScope::getSize());
 }
 
 inline EHScopeStack::iterator EHScopeStack::find(stable_iterator sp) const {
   assert(sp.isValid() && "finding invalid savepoint");
   assert(sp.Size <= stable_begin().Size && "finding savepoint after pop");
   return iterator(EndOfBuffer - sp.Size);
 }
 

lib/CodeGen/CGCleanup.cpp

RValue DominatingValue<RValue>::saved_type::restore(CodeGenFunction &CGF) {
   }
   }
 
   llvm_unreachable("bad saved r-value kind");
 }
 
 /// Push an entry of the given size onto this protected-scope stack.
 char *EHScopeStack::allocate(size_t Size) {
+  Size = llvm::RoundUpToAlignment(Size, ScopeStackAlignment);
   if (!StartOfBuffer) {
     unsigned Capacity = 1024;
     while (Capacity < Size) Capacity *= 2;
     StartOfBuffer = new char[Capacity];
     StartOfData = EndOfBuffer = StartOfBuffer + Capacity;
   } else if (static_cast<size_t>(StartOfData - StartOfBuffer) < Size) {
     unsigned CurrentCapacity = EndOfBuffer - StartOfBuffer;
     unsigned UsedCapacity = CurrentCapacity - (StartOfData - StartOfBuffer);
if (!StartOfBuffer) {
     StartOfData = NewStartOfData;
   }
 
   assert(StartOfBuffer + Size <= StartOfData);
   StartOfData -= Size;
   return StartOfData;
 }
 
+void EHScopeStack::deallocate(size_t Size) {
+  StartOfData += llvm::RoundUpToAlignment(Size, ScopeStackAlignment);
+}
+
 bool EHScopeStack::containsOnlyLifetimeMarkers(
     EHScopeStack::stable_iterator Old) const {
   for (EHScopeStack::iterator it = begin(); stabilize(it) != Old; it++) {
     EHCleanupScope *cleanup = dyn_cast<EHCleanupScope>(&*it);
     if (!cleanup || !cleanup->isLifetimeMarker())
       return false;
   }
 
for (stable_iterator si = getInnermostEHScope(), se = stable_end();
     return si;
   }
 
   return stable_end();
 }
 
 
 void *EHScopeStack::pushCleanup(CleanupKind Kind, size_t Size) {
-  assert(((Size % sizeof(void*)) == 0) && "cleanup type is misaligned");
   char *Buffer = allocate(EHCleanupScope::getSizeForCleanupSize(Size));
   bool IsNormalCleanup = Kind & NormalCleanup;
   bool IsEHCleanup = Kind & EHCleanup;
   bool IsActive = !(Kind & InactiveCleanup);
   EHCleanupScope *Scope =
     new (Buffer) EHCleanupScope(IsNormalCleanup,
                                 IsEHCleanup,
                                 IsActive,

 
 void EHScopeStack::popCleanup() {
   assert(!empty() && "popping exception stack when not empty");
 
   assert(isa<EHCleanupScope>(*begin()));
   EHCleanupScope &Cleanup = cast<EHCleanupScope>(*begin());
   InnermostNormalCleanup = Cleanup.getEnclosingNormalCleanup();
   InnermostEHScope = Cleanup.getEnclosingEHScope();
-  StartOfData += Cleanup.getAllocatedSize();
+  deallocate(Cleanup.getAllocatedSize());
 
   // Destroy the cleanup.
   Cleanup.Destroy();
 
   // Check whether we can shrink the branch-fixups stack.
   if (!BranchFixups.empty()) {
     // If we no longer have any normal cleanups, all the fixups are
     // complete.
EHFilterScope *EHScopeStack::pushFilter(unsigned numFilters) {
   InnermostEHScope = stable_begin();
   return filter;
 }
 
 void EHScopeStack::popFilter() {
   assert(!empty() && "popping exception stack when not empty");
 
   EHFilterScope &filter = cast<EHFilterScope>(*begin());
-  StartOfData += EHFilterScope::getSizeForNumFilters(filter.getNumFilters());
+  deallocate(EHFilterScope::getSizeForNumFilters(filter.getNumFilters()));
 
   InnermostEHScope = filter.getEnclosingEHScope();
 }
 
 EHCatchScope *EHScopeStack::pushCatch(unsigned numHandlers) {
   char *buffer = allocate(EHCatchScope::getSizeForNumHandlers(numHandlers));
   EHCatchScope *scope =
     new (buffer) EHCatchScope(numHandlers, InnermostEHScope);

lib/CodeGen/CGExprCXX.cpp

void Emit(CodeGenFunction &CGF, Flags flags) override {
       // Pass the rest of the arguments, which must match exactly.
       for (unsigned I = 0; I != NumPlacementArgs; ++I)
         DeleteArgs.add(getPlacementArgs()[I], *AI++);
 
       // Call 'operator delete'.
       EmitNewDeleteCall(CGF, OperatorDelete, FPT, DeleteArgs);
     }
   };
+  static_assert(
+      llvm::AlignOf<CallDeleteDuringNew>::Alignment >=
+          llvm::AlignOf<RValue>::Alignment,
+      "Alignment sufficient for objects appended to CallDeleteDuringNew");
 
   /// A cleanup to call the given 'operator delete' function upon
   /// abnormal exit from a new expression when the new expression is
   /// conditional.
   class CallDeleteDuringConditionalNew : public EHScopeStack::Cleanup {
     size_t NumPlacementArgs;
     const FunctionDecl *OperatorDelete;
     DominatingValue<RValue>::saved_type Ptr;
void Emit(CodeGenFunction &CGF, Flags flags) override {
         RValue RV = getPlacementArgs()[I].restore(CGF);
         DeleteArgs.add(RV, *AI++);
       }
 
       // Call 'operator delete'.
       EmitNewDeleteCall(CGF, OperatorDelete, FPT, DeleteArgs);
     }
   };
+  static_assert(
+      llvm::AlignOf<CallDeleteDuringConditionalNew>::Alignment >=
+          llvm::AlignOf<DominatingValue<RValue>::saved_type>::Alignment,
+      "Alignment sufficient for objects appended to CallDeleteDuringNew");
 }
 
 /// Enter a cleanup to call 'operator delete' if the initializer in a
 /// new-expression throws.
 static void EnterNewDeleteCleanup(CodeGenFunction &CGF,
                                   const CXXNewExpr *E,
                                   llvm::Value *NewPtr,
                                   llvm::Value *AllocSize,

 }
 
 void CodeGenFunction::EmitLambdaExpr(const LambdaExpr *E, AggValueSlot Slot) {
   RunCleanupsScope Scope(*this);
   LValue SlotLV =
       MakeAddrLValue(Slot.getAddr(), E->getType(), Slot.getAlignment());
 
   CXXRecordDecl::field_iterator CurField = E->getLambdaClass()->field_begin();
-  for (LambdaExpr::capture_init_iterator i = E->capture_init_begin(),
+  for (LambdaExpr::const_capture_init_iterator i = E->capture_init_begin(),
                                          e = E->capture_init_end();
        i != e; ++i, ++CurField) {
     // Emit initialization
     LValue LV = EmitLValueForFieldInitialization(SlotLV, *CurField);
     if (CurField->hasCapturedVLAType()) {
       auto VAT = CurField->getCapturedVLAType();
       EmitStoreThroughLValue(RValue::get(VLASizeMap[VAT->getSizeExpr()]), LV);
     } else {
       ArrayRef<VarDecl *> ArrayIndexes;
       if (CurField->getType()->isArrayType())
         ArrayIndexes = E->getCaptureInitIndexVars(i);
       EmitInitializerForField(*CurField, LV, *i, ArrayIndexes);
     }
   }
 }

lib/CodeGen/CGStmt.cpp

LValue CodeGenFunction::InitCapturedStruct(const CapturedStmt &S) {
   const RecordDecl *RD = S.getCapturedRecordDecl();
   QualType RecordTy = getContext().getRecordType(RD);
 
   // Initialize the captured struct.
   LValue SlotLV = MakeNaturalAlignAddrLValue(
       CreateMemTemp(RecordTy, "agg.captured"), RecordTy);
 
   RecordDecl::field_iterator CurField = RD->field_begin();
-  for (CapturedStmt::capture_init_iterator I = S.capture_init_begin(),
+  for (CapturedStmt::const_capture_init_iterator I = S.capture_init_begin(),
                                                  E = S.capture_init_end();
        I != E; ++I, ++CurField) {
     LValue LV = EmitLValueForFieldInitialization(SlotLV, *CurField);
     if (CurField->hasCapturedVLAType()) {
       auto VAT = CurField->getCapturedVLAType();
       EmitStoreThroughLValue(RValue::get(VLASizeMap[VAT->getSizeExpr()]), LV);
     } else {
       EmitInitializerForField(*CurField, LV, *I, None);
     }

lib/CodeGen/EHScopeStack.h

enum CleanupKind : unsigned {
   InactiveNormalCleanup = NormalCleanup | InactiveCleanup,
   InactiveNormalAndEHCleanup = NormalAndEHCleanup | InactiveCleanup
 };
 
 /// A stack of scopes which respond to exceptions, including cleanups
 /// and catch blocks.
 class EHScopeStack {
 public:
+  enum { ScopeStackAlignment = llvm::AlignOf<uint64_t>::Alignment };
+
   /// A saved depth on the scope stack.  This is necessary because
   /// pushing scopes onto the stack invalidates iterators.
   class stable_iterator {
     friend class EHScopeStack;
 
     /// Offset from StartOfData to EndOfBuffer.
     ptrdiff_t Size;
 
private:
   ///     struct A { ~A(); }; // trivial ctor, non-trivial dtor
   ///     goto foo;
   ///     A a;
   ///    foo:
   ///     bar();
   SmallVector<BranchFixup, 8> BranchFixups;
 
   char *allocate(size_t Size);
+  void deallocate(size_t Size);
 
   void *pushCleanup(CleanupKind K, size_t DataSize);
 
 public:
   EHScopeStack() : StartOfBuffer(nullptr), EndOfBuffer(nullptr),
                    StartOfData(nullptr), InnermostNormalCleanup(stable_end()),
                    InnermostEHScope(stable_end()) {}
   ~EHScopeStack() { delete[] StartOfBuffer; }
 
   /// Push a lazily-created cleanup on the stack.
   template <class T, class... As> void pushCleanup(CleanupKind Kind, As... A) {
+    static_assert(llvm::AlignOf<T>::Alignment <= ScopeStackAlignment,
+                  "Cleanup's alignment less than maximum");
     void *Buffer = pushCleanup(Kind, sizeof(T));
     Cleanup *Obj = new (Buffer) T(A...);
     (void) Obj;
   }
 
   /// Push a lazily-created cleanup on the stack. Tuple version.
   template <class T, class... As>
   void pushCleanupTuple(CleanupKind Kind, std::tuple<As...> A) {
+    static_assert(llvm::AlignOf<T>::Alignment <= ScopeStackAlignment,
+                  "Cleanup's alignment less than maximum");
     void *Buffer = pushCleanup(Kind, sizeof(T));
     Cleanup *Obj = new (Buffer) T(std::move(A));
     (void) Obj;
   }
 
   // Feel free to add more variants of the following:
 
   /// Push a cleanup with non-constant storage requirements on the
   /// stack.  The cleanup type must provide an additional static method:
   ///   static size_t getExtraSize(size_t);
   /// The argument to this method will be the value N, which will also
   /// be passed as the first argument to the constructor.
   ///
   /// The data stored in the extra storage must obey the same
   /// restrictions as normal cleanup member data.
   ///
   /// The pointer returned from this method is valid until the cleanup
   /// stack is modified.
   template <class T, class... As>
   T *pushCleanupWithExtra(CleanupKind Kind, size_t N, As... A) {
+    static_assert(llvm::AlignOf<T>::Alignment <= ScopeStackAlignment,
+                  "Cleanup's alignment less than maximum");
     void *Buffer = pushCleanup(Kind, sizeof(T) + T::getExtraSize(N));
     return new (Buffer) T(N, A...);
   }
 
   void pushCopyOfCleanup(CleanupKind Kind, const void *Cleanup, size_t Size) {
     void *Buffer = pushCleanup(Kind, Size);
     std::memcpy(Buffer, Cleanup, Size);
   }

lib/Lex/PPDirectives.cpp

 MacroInfo *Preprocessor::AllocateMacroInfo(SourceLocation L) {
   MacroInfo *MI = AllocateMacroInfo();
   new (MI) MacroInfo(L);
   return MI;
 }
 
 MacroInfo *Preprocessor::AllocateDeserializedMacroInfo(SourceLocation L,
                                                        unsigned SubModuleID) {
-  static_assert(llvm::AlignOf<MacroInfo>::Alignment >= sizeof(SubModuleID),
-                "alignment for MacroInfo is less than the ID");
   DeserializedMacroInfoChain *MIChain =
       BP.Allocate<DeserializedMacroInfoChain>();
   MIChain->Next = DeserialMIChainHead;
   DeserialMIChainHead = MIChain;
 
   MacroInfo *MI = &MIChain->MI;
   new (MI) MacroInfo(L);
   MI->FromASTFile = true;

lib/Sema/SemaExceptionSpec.cpp

case Expr::CXXTemporaryObjectExprClass: {
     if (CT == CT_Can)
       return CT;
     return mergeCanThrow(CT, canSubExprsThrow(*this, E));
   }
 
   case Expr::LambdaExprClass: {
     const LambdaExpr *Lambda = cast<LambdaExpr>(E);
     CanThrowResult CT = CT_Cannot;
-    for (LambdaExpr::capture_init_iterator Cap = Lambda->capture_init_begin(),
+    for (LambdaExpr::const_capture_init_iterator Cap = Lambda->capture_init_begin(),
                                         CapEnd = Lambda->capture_init_end();
          Cap != CapEnd; ++Cap)
       CT = mergeCanThrow(CT, canThrow(*Cap));
     return CT;
   }
 
   case Expr::CXXNewExprClass: {
     CanThrowResult CT;

lib/Serialization/ASTReader.cpp

case MODULE_MAP_FILE:
       if (ASTReadResult Result =
               ReadModuleMapFileBlock(Record, F, ImportedBy, ClientLoadCapabilities))
         return Result;
       break;
 
     case INPUT_FILE_OFFSETS:
       NumInputs = Record[0];
       NumUserInputs = Record[1];
-      F.InputFileOffsets = (const uint64_t *)Blob.data();
+      F.InputFileOffsets.resize(NumInputs);
+      // Note: Blob.data may not be properly aligned, so use memcpy
+      // here which can deal.
+      memcpy(&F.InputFileOffsets[0], Blob.data(), NumInputs * sizeof(uint64_t));
       F.InputFilesLoaded.resize(NumInputs);
       break;
     }
   }
 }
 
 ASTReader::ASTReadResult
 ASTReader::ReadASTBlock(ModuleFile &F, unsigned ClientLoadCapabilities) {