clang: add support for asmjs arch and Emscripten OS

include/clang/Basic/TargetCXXABI.h

 //===--- TargetCXXABI.h - C++ ABI Target Configuration ----------*- C++ -*-===//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 ///
 /// \file
@@ skipping 61 matching lines @@
     iOS64,
 
     /// The generic AArch64 ABI is also a modified version of the Itanium ABI,
     /// but it has fewer divergences than the 32-bit ARM ABI.
     ///
     /// The relevant changes from the generic ABI in this case are:
     ///   - representation of member function pointers adjusted as in ARM.
     ///   - guard variables  are smaller.
     GenericAArch64,
 
+    // @LOCALMOD-START Emscripten
+    /// Emscripten uses the Itanium C++, with the exception that it uses
+    /// ARM-style pointers to member functions.
+    Emscripten,
+    // @LOCALMOD-END Emscripten
+
     /// The Microsoft ABI is the ABI used by Microsoft Visual Studio (and
     /// compatible compilers).
     ///
     /// FIXME: should this be split into Win32 and Win64 variants?
     ///
     /// Only scattered and incomplete official documentation exists.
     Microsoft
   };
 
 private:
@@ skipping 13 matching lines @@
   }
 
   Kind getKind() const { return TheKind; }
 
   /// \brief Does this ABI generally fall into the Itanium family of ABIs?
   bool isItaniumFamily() const {
     switch (getKind()) {
     case GenericAArch64:
     case GenericItanium:
     case GenericARM:
+    case Emscripten: // @LOCALMOD Emscripten
     case iOS:
     case iOS64:
       return true;
 
     case Microsoft:
       return false;
     }
     llvm_unreachable("bad ABI kind");
   }
 
   /// \brief Is this ABI an MSVC-compatible ABI?
   bool isMicrosoft() const {
     switch (getKind()) {
     case GenericAArch64:
     case GenericItanium:
     case GenericARM:
+    case Emscripten: // @LOCALMOD Emscripten
     case iOS:
     case iOS64:
       return false;
 
     case Microsoft:
       return true;
     }
     llvm_unreachable("bad ABI kind");
   }
 
+  // @LOCALMOD-START Emscripten
+  /// \brief Are pointers to member functions differently aligned?
+  bool arePointersToMemberFunctionsAligned() const {
+    switch (getKind()) {
+    case Emscripten:
+      // Emscripten uses table indices for function pointers and therefore
+      // doesn't require alignment.
+      return false;
+    case GenericARM:
+    case GenericAArch64:
+      // TODO: ARM-style pointers to member functions put the discriminator in
+      //       the this adjustment, so they don't require functions to have any
+      //       special alignment and could therefore also return false.
+    case GenericItanium:
+    case iOS:
+    case iOS64:
+    case Microsoft:
+      return true;
+    }
+    llvm_unreachable("bad ABI kind");
+  }
+  // @LOCALMOD-END Emscripten
+
   /// \brief Is the default C++ member function calling convention
   /// the same as the default calling convention?
   bool isMemberFunctionCCDefault() const {
     // Right now, this is always false for Microsoft.
     return !isMicrosoft();
   }
 
   /// Are arguments to a call destroyed left to right in the callee?
   /// This is a fundamental language change, since it implies that objects
   /// passed by value do *not* live to the end of the full expression.
@@ skipping 52 matching lines @@
   /// exploiting this observation requires an ABI break and cannot be
   /// done on a generic Itanium platform.
   bool canKeyFunctionBeInline() const {
     switch (getKind()) {
     case GenericARM:
     case iOS64:
       return false;
 
     case GenericAArch64:
     case GenericItanium:
+    case Emscripten: // @LOCALMOD Emscripten
     case iOS:   // old iOS compilers did not follow this rule
     case Microsoft:
       return true;
     }
     llvm_unreachable("bad ABI kind");
   }
 
   /// When is record layout allowed to allocate objects in the tail
   /// padding of a base class?
   ///
@@ skipping 26 matching lines @@
     UseTailPaddingUnlessPOD11
   };
   TailPaddingUseRules getTailPaddingUseRules() const {
     switch (getKind()) {
     // To preserve binary compatibility, the generic Itanium ABI has
     // permanently locked the definition of POD to the rules of C++ TR1,
     // and that trickles down to all the derived ABIs.
     case GenericItanium:
     case GenericAArch64:
     case GenericARM:
+    case Emscripten: // @LOCALMOD Emscripten
     case iOS:
       return UseTailPaddingUnlessPOD03;
 
     // iOS on ARM64 uses the C++11 POD rules.  It does not honor the
     // Itanium exception about classes with over-large bitfields.
     case iOS64:
       return UseTailPaddingUnlessPOD11;
 
     // MSVC always allocates fields in the tail-padding of a base class
     // subobject, even if they're POD.
@@ skipping 11 matching lines @@
   }
 
   friend bool operator!=(const TargetCXXABI &left, const TargetCXXABI &right) {
     return !(left == right);
   }
 };
 
 }  // end namespace clang
 
 #endif