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:
+      // ARM-style pointers to member functions put the discriminator in the
+      // this adjustment, so they don't require functions to have any special
+      // alignment.
+      return false;
+    case GenericItanium:

[jvoung (off chromium), 2015/03/20 17:07:07]

Hmm, so LE32 uses GenericItanium directly and doesn't create a separate CXXABI. 
What it does is in
https://codereview.chromium.org/1022123003/diff/1/lib/CodeGen/ItaniumCXXABI.cpp,
it specially sets /* UseARMMethodPtrABI = */ true.

This means that LE32 almost gets everything about the ARM method pointer ABI,
except for this arePointersToMemberFunctionsAligned().

Is there a way to have the LE32 version be similar? Seems a bit unfortunate that
there are two places that control this. So, if possible it would be nice if
there was just one place that controls this.

Also, because "arePointersToMemberFunctionsAligned" didn't exist previously,
this is the first time that GenericARM/GenericAArch64 will stop aligning method
pointers, so might want be careful to run some ARM tests.

Grepping around, there's also a "getMemberPointerWidthAndAlign", which may need
to take this into account? That's at the lib/AST level, and I'm not sure of the
implications.

[JF, 2015/03/20 18:49:38]

As discussed on IRC I left ARM as it was, with a TODO, and we'll have only
Emscripten be different for now.

+    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