Remove Emscripten support

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 generic Mips ABI is a modified version of the Itanium ABI.
     ///
     /// At the moment, only change from the generic ABI in this case is:
     ///   - representation of member function pointers adjusted as in ARM.
     GenericMIPS,
 
     /// The Microsoft ABI is the ABI used by Microsoft Visual Studio (and
     /// compatible compilers).
     ///
     /// FIXME: should this be split into Win32 and Win64 variants?
@@ skipping 19 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:
     case GenericMIPS:
       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:
     case GenericMIPS:
       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 GenericMIPS:
-    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:
     case GenericMIPS:
       return true;
     }
     llvm_unreachable("bad ABI kind");
   }
 
   /// When is record layout allowed to allocate objects in the tail
   /// padding of a base class?
@@ skipping 27 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:
     case GenericMIPS:
       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
@@ skipping 12 matching lines @@
   }
 
   friend bool operator!=(const TargetCXXABI &left, const TargetCXXABI &right) {
     return !(left == right);
   }
 };
 
 }  // end namespace clang
 
 #endif