Remove Emscripten support

lib/Transforms/NaCl/ResolvePNaClIntrinsics.cpp

 //===- ResolvePNaClIntrinsics.cpp - Resolve calls to PNaCl intrinsics ----====//
 //
 //                     The LLVM Compiler Infrastructure
 //
 // This file is distributed under the University of Illinois Open Source
 // License. See LICENSE.TXT for details.
 //
 //===----------------------------------------------------------------------===//
 //
 // This pass resolves calls to PNaCl stable bitcode intrinsics. It is
@@ skipping 148 matching lines @@
     Constant *C = Functor(Call);
     Call->replaceAllUsesWith(C);
     Call->eraseFromParent();
     return true;
   }
 
   ConstantCallResolver(const ConstantCallResolver &) = delete;
   ConstantCallResolver &operator=(const ConstantCallResolver &) = delete;
 };
 
-/// Resolve __nacl_atomic_is_lock_free to true/false at translation
-/// time. PNaCl's currently supported platforms all support lock-free atomics at
-/// byte sizes {1,2,4,8} except for MIPS and asmjs architectures that supports
-/// lock-free atomics at byte sizes {1,2,4}, and the alignment of the pointer is
-/// always expected to be natural (as guaranteed by C11 and C++11). PNaCl's
-/// Module-level ABI verification checks that the byte size is constant and in
-/// {1,2,4,8}.
+/// Resolve __nacl_atomic_is_lock_free to true/false at translation / time.
+//PNaCl's currently supported platforms all support lock-free atomics at / byte
+//sizes {1,2,4,8} except for MIPS architecture that supports / lock-free atomics
+//at byte sizes {1,2,4}, and the alignment of the pointer is / always expected
+//to be natural (as guaranteed by C11 and C++11). PNaCl's / Module-level ABI
+//verification checks that the byte size is constant and in / {1,2,4,8}.
 struct IsLockFreeToConstant {
   Constant *operator()(CallInst *Call) {
     uint64_t MaxLockFreeByteSize = 8;
     const APInt &ByteSize =
         cast<Constant>(Call->getOperand(0))->getUniqueInteger();
 
 #   if defined(PNACL_BROWSER_TRANSLATOR)
     switch (__builtin_nacl_target_arch()) {
     case PnaclTargetArchitectureX86_32:
     case PnaclTargetArchitectureX86_64:
     case PnaclTargetArchitectureARM_32:
       break;
     case PnaclTargetArchitectureMips_32:
       MaxLockFreeByteSize = 4;
       break;
     default:
       errs() << "Architecture: " << Triple::getArchTypeName(Arch) << "\n";
       report_fatal_error("is_lock_free: unhandled architecture");
     }
 #   else
     switch (Arch) {
     case Triple::x86:
     case Triple::x86_64:
     case Triple::arm:
       break;
     case Triple::mipsel:
-    case Triple::asmjs:
       MaxLockFreeByteSize = 4;
       break;
     default:
       errs() << "Architecture: " << Triple::getArchTypeName(Arch) << "\n";
       report_fatal_error("is_lock_free: unhandled architecture");
     }
 #   endif
 
     bool IsLockFree = ByteSize.ule(MaxLockFreeByteSize);
     auto *C = ConstantInt::get(Call->getType(), IsLockFree);
@@ skipping 267 matching lines @@
   return Changed;
 }
 
 char ResolvePNaClIntrinsics::ID = 0;
 INITIALIZE_PASS(ResolvePNaClIntrinsics, "resolve-pnacl-intrinsics",
                 "Resolve PNaCl intrinsic calls", false, false)
 
 FunctionPass *llvm::createResolvePNaClIntrinsicsPass() {
   return new ResolvePNaClIntrinsics();
 }